From 7455f5c4b9f3d0435d86c7e527300915f49cad3d Mon Sep 17 00:00:00 2001 From: eda Date: Tue, 4 Aug 2026 13:52:26 +0800 Subject: [PATCH 01/41] #28 /8206 feat: TreeSummarizedExperiment --- README.md | 24 +- .../tree_summarized_experiment_demo/main.mbt | 133 ++++ .../tree_summarized_experiment_demo/moon.pkg | 6 + src/summarized_experiment.mbt | 32 +- src/tree_summarized_experiment.mbt | 645 ++++++++++++++++++ test/moonbit/summarized_experiment_test.mbt | 8 + .../tree_summarized_experiment_test.mbt | 254 +++++++ 7 files changed, 1076 insertions(+), 26 deletions(-) create mode 100644 examples/tree_summarized_experiment_demo/main.mbt create mode 100644 examples/tree_summarized_experiment_demo/moon.pkg create mode 100644 src/tree_summarized_experiment.mbt create mode 100644 test/moonbit/tree_summarized_experiment_test.mbt diff --git a/README.md b/README.md index 7758052c..93c3f849 100644 --- a/README.md +++ b/README.md @@ -195,6 +195,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **edgeR** | Bioconductor edgeR | 差异表达分析、DGEList、精确检验、GLM拟合 | ✅ | | **limma** | Bioconductor limma | 差异表达分析、线性模型拟合、经验贝叶斯、voom变换、RPKM/CPM/quantile归一化、ComBat/removeBatchEffect批次校正、treat严格检验 | ✅ | | **SummarizedExperiment** | Bioconductor SummarizedExperiment | 多维基因组数据容器、Assays、行/列操作 | ✅ | +| **TreeSummarizedExperiment** | Bioconductor TreeSummarizedExperiment | 行/列树、节点链接、树节点子集、祖先/后代查询、层级聚合 | ✅ | | **IRanges** | Bioconductor IRanges | 整数区间操作、集合运算、重叠检测、findOverlaps高级类型、nearest、coverage、距离矩阵计算 | ✅ | | **TxDb** | Bioconductor GenomicFeatures | 转录本数据库、GTF解析、基因/转录本/外显子/CDS提取、UTR/内含子计算、启动子提取 | ✅ | | **ExPASy** | Biopython `Bio.ExPASy` | 蛋白质分析工具接口、Swiss-Prot条目解析、酶数据库查询、蛋白质参数计算（分子量、等电点、GRAVY、不稳定指数） | ✅ | @@ -444,6 +445,7 @@ IvanAXu/BioSeqs/ │ ├── matrix.mbt # Bioconductor Matrix 稀疏矩阵操作 (CSC/CSR格式、矩阵运算) │ ├── bioc_neighbors.mbt # BiocNeighbors 最近邻搜索 (KMKNN/Annoy) │ ├── summarized_experiment.mbt # SummarizedExperiment 多维基因组数据容器 +│ ├── tree_summarized_experiment.mbt # TreeSummarizedExperiment 树结构实验容器、节点子集与层级聚合 │ ├── dplyr.mbt # dplyr 数据操作 (DataFrame、filter、select、mutate、arrange、group_by、summarize、join) │ ├── plyranges.mbt # plyranges tidy基因组数据操作 (GRanges的filter/mutate/select/arrange/rename/summarise/join) │ ├── smith_waterman.mbt # Smith-Waterman 局部序列比对 (动态规划、自定义打分、回溯矩阵) @@ -824,6 +826,7 @@ IvanAXu/BioSeqs/ │ ├── substitution_matrices_demo/ # 现代替换矩阵示例 (矩阵注册表、频率矩阵计算、log-odds打分、Shannon熵、KL散度、NCBI解析) │ ├── suffix_array_tree_demo/ # Suffix Array & Suffix Tree 示例 │ ├── summarized_experiment_demo/ # SummarizedExperiment 数据容器示例 +│ ├── tree_summarized_experiment_demo/ # TreeSummarizedExperiment 行/列树链接、节点子集与聚合示例 │ ├── sva_demo/ # sva 替代变量分析与ComBat批次校正示例 (经验贝叶斯方法、PCA分析) │ ├── svd_superimposer_demo/ # SVDSuperimposer SVD蛋白质结构叠合示例 (旋转矩阵、平移向量、RMSD计算) │ ├── structure_alignment_demo/ # Bio.PDB.StructureAlignment 多蛋白质结构比对示例 @@ -1107,6 +1110,7 @@ IvanAXu/BioSeqs/ │ │ ├── suffix_array_tree_test.mbt │ │ ├── suffix_array_tree_wbtest.mbt │ │ ├── summarized_experiment_test.mbt +│ │ ├── tree_summarized_experiment_test.mbt │ │ ├── svd_superimposer_test.mbt │ │ ├── tree_io_test.mbt │ │ ├── txdb_test.mbt @@ -1400,7 +1404,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test --package IvanAXu/BioSeqs/test/moonbit # ✅ 8105 个测试全部通过 +moon test # ✅ 8206 个测试全部通过 ``` ### 模块对照表 @@ -1497,6 +1501,7 @@ moon test --package IvanAXu/BioSeqs/test/moonbit # ✅ 8105 个测试全 | `edger_advanced.mbt` | edgeR QLF/Camera/Roast | 准似然F检验、QL分散度估计、camera竞争性基因集检验、roast自足基因集检验 | | `limma.mbt` | Bioconductor limma | 线性模型与 voom 变换 | | `summarized_experiment.mbt` | Bioconductor SummarizedExperiment | 多维数据容器 | +| `tree_summarized_experiment.mbt` | Bioconductor TreeSummarizedExperiment | 行/列树与数据链接、按节点子集、层级聚合 | | `ballgown.mbt` | Bioconductor ballgown | 转录组水平差异表达 | | `ruvseq.mbt` | Bioconductor RUVSeq | RNA-seq 批次效应去除 | | `sva.mbt` | Bioconductor sva | 替代变量分析与 ComBat | @@ -2699,6 +2704,10 @@ moon test --package IvanAXu/BioSeqs/test/moonbit # ✅ 8105 个测试全 实现 CDAO（Comparative Data Analysis Ontology，比较数据分析本体）RDF/XML 格式的解析与序列化，参考 Biopython `Bio.Phylo.CDAO`。CDAO 是基于 RDF 的系统发育数据表示标准，使用 CDAO 本体术语将树结构编码为 RDF 三元组（subject-predicate-object），便于与语义网和本体推理系统互操作。核心 CDAO 本体术语：cdao:Tree（系统发育树）、cdao:Node（树节点）、cdao:Edge（树枝/边）、cdao:has_Root（树→根节点）、cdao:has_Child/has_Descendant（父→子节点）、cdao:has_Ancestor/has_Parent（子→父节点）、cdao:belongs_to_TU（节点→分类单元）、cdao:TU（分类单元/OTU/叶标签）、rdfs:label（标签文字）。核心数据结构：Cdaotree（id/rooted/root_node_id/name?）；CdaoNode（id/children : Array[String]/parent_id?/tu_id?/branch_length?/label?，关键字段标记 mut 以便构建时修改）；CdaoTU（id/label?）；CdaoDocument（trees : Array[Cdaotree]/nodes : Map[String, CdaoNode]/tus : Map[String, CdaoTU] 完整 RDF 图）。核心函数：cdao_namespace()/cdao_rdf_namespace()/cdao_rdfs_namespace() 返回命名空间 URI；cdao_parse(xml) 主解析入口 → cdao_parse_rdf_xml 提取 CdaoTriple 三元组（手写 XML 解析器，处理标签/属性/rdf:about/rdf:resource/文本内容/自闭合/嵌套子元素）→ cdao_build_document 三元组分类填充 Document（rdf:type 创建节点/TU、has_Root 创建 Tree、has_Child 填 children、has_Ancestor 填 parent_id、belongs_to_TU 填 tu_id、rdfs:label 填 label、has_branch_length 填 branch_length）；cdao_to_trees(doc) 递归 cdao_build_clade 将 CdaoDocument 转为 BioSeqs Tree 数组（TU 标签优先于节点标签）；cdao_write(tree) 将 Tree 序列化为 RDF/XML 字符串（CdaoWriteState 管理 node_counter/tu_counter/tu_map，递归 cdao_write_clade 输出节点与边，末尾输出 TU 元素，cdao_escape_xml 处理 & < > 实体转义）。适用于系统发育数据语义网交换、本体推理、CDAO 兼容工具链互操作。 +### 236. TreeSummarizedExperiment 树结构实验容器 (Bioconductor TreeSummarizedExperiment) + +实现结合实验矩阵与层级树的 `TreeSummarizedExperiment` 容器，复用现有 `SummarizedExperiment`、`Tree` 和 `Clade` 类型。容器支持 `row_tree`/`col_tree`、`row_links`/`col_links` 和 `reference_sequences`，其中 `TseLink` 记录节点标签、稳定别名、一基节点编号、叶节点状态和树名称，对应 Bioconductor 的 `rowTree`、`rowLinks`、`colTree`、`colLinks` 与 `referenceSeq` 语义。`subset_rows`/`subset_cols` 同步裁剪 assay、链接和参考序列；`subset_by_row_nodes`/`subset_by_col_nodes` 可按内部节点或叶节点选择所有已链接后代，保留原树结构。`aggregate_rows`/`aggregate_cols` 对目标节点覆盖的数据执行 Sum、Mean、Min 或 Max 聚合，并为结果重建节点链接。`tse_find_descendants`、`tse_find_ancestors` 和 `tse_is_leaf` 提供树节点查询。`is_valid` 检查 assay 维度、链接长度、树存在性和参考序列长度。适用于微生物分类丰度、系统发育表达矩阵和具有样本层级的数据分析。 + ## 性能优化 @@ -2801,8 +2810,8 @@ moon test --package IvanAXu/BioSeqs/test/moonbit # ✅ 8105 个测试全 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8105 | -| 通过数 | 8105 | +| 总测试数 | 8206 | +| 通过数 | 8206 | | 失败数 | 0 | | 通过率 | 100% | @@ -2813,10 +2822,10 @@ moon test --package IvanAXu/BioSeqs/test/moonbit # ✅ 8105 个测试全 moon build # 运行所有测试 -moon test --package IvanAXu/BioSeqs/test/moonbit +moon test # 运行单个模块测试 -moon test --package IvanAXu/BioSeqs/test/moonbit --test bio_seq_test +moon test test/moonbit/bio_seq_test.mbt # 更新快照测试 moon test --update @@ -2866,6 +2875,7 @@ moon test --update | edgeR | `edger_test.mbt` | 7 | | limma | `limma_test.mbt` | 10 | | SummarizedExperiment | `summarized_experiment_test.mbt` | 7 | +| TreeSummarizedExperiment | `tree_summarized_experiment_test.mbt` | 11 | | IRanges | `iranges_test.mbt` | 14 | | AlignIO | `align_io_test.mbt` | 12 | | Cluster | `cluster_test.mbt` | 12 | @@ -3156,7 +3166,7 @@ bash test/python/compare_seqio.sh moon build # 运行所有测试 -moon test --package IvanAXu/BioSeqs/test/moonbit +moon test # 更新接口文件 moon info @@ -3220,6 +3230,7 @@ moon run cmd/bench/main.mbt | edger_demo | edgeR 差异表达分析（DGEList创建、归一化因子、分散度估计、精确检验、GLM拟合） | `moon run examples/edger_demo/main.mbt` | | limma_demo | limma 差异表达分析（voom变换、线性模型拟合、经验贝叶斯、topTable、对比矩阵） | `moon run examples/limma_demo/main.mbt` | | summarized_experiment_demo | SummarizedExperiment 多维数据容器（Assays、行/列操作、合并） | `moon run examples/summarized_experiment_demo/main.mbt` | +| tree_summarized_experiment_demo | TreeSummarizedExperiment 行/列树链接、节点查询、树节点子集与层级聚合 | `moon run examples/tree_summarized_experiment_demo/main.mbt` | | iranges_demo | IRanges 整数区间操作（shift、resize、reduce、集合运算、重叠检测） | `moon run examples/iranges_demo/main.mbt` | | align_io_demo | 比对格式解析（ClustalW、FASTA、Stockholm格式解析与写入） | `moon run examples/align_io_demo/main.mbt` | | cluster_demo | 序列聚类分析（距离矩阵、层次聚类、Newick输出、轮廓系数） | `moon run examples/cluster_demo/main.mbt` | @@ -3418,6 +3429,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 群体遗传学分析（等位基因频率、基因型频率、哈迪-温伯格检验、FST统计、Watterson's theta） - ✅ 实现 edgeR 差异表达分析（DGEList创建、归一化因子、分散度估计、精确检验、GLM拟合） - ✅ 实现 SummarizedExperiment 多维数据容器（Assays、行/列操作、合并） +- ✅ 实现 TreeSummarizedExperiment 树结构实验容器（行/列树链接、节点子集、层级聚合） - ✅ 实现 IRanges 整数区间操作（shift、resize、reduce、集合运算、重叠检测） - ✅ 实现 比对格式解析（ClustalW、FASTA、Stockholm格式解析与写入） - ✅ 实现 序列聚类分析（距离矩阵、层次聚类、Newick输出、轮廓系数） diff --git a/examples/tree_summarized_experiment_demo/main.mbt b/examples/tree_summarized_experiment_demo/main.mbt new file mode 100644 index 00000000..84fac27d --- /dev/null +++ b/examples/tree_summarized_experiment_demo/main.mbt @@ -0,0 +1,133 @@ +///| +fn make_taxa_tree() -> @src.Tree { + let taxon_a = @src.Clade::new(name=Some("TaxonA")) + let taxon_b = @src.Clade::new(name=Some("TaxonB")) + let taxon_c = @src.Clade::new(name=Some("TaxonC")) + let taxon_d = @src.Clade::new(name=Some("TaxonD")) + let firmicutes = @src.Clade::new(name=Some("Firmicutes"), clades=[ + taxon_a, taxon_b, + ]) + let bacteroidota = @src.Clade::new(name=Some("Bacteroidota"), clades=[ + taxon_c, taxon_d, + ]) + let bacteria = @src.Clade::new(name=Some("Bacteria"), clades=[ + firmicutes, bacteroidota, + ]) + @src.Tree::new(bacteria, rooted=true, name=Some("taxonomy")) +} + +///| +fn make_sample_tree() -> @src.Tree { + let control_1 = @src.Clade::new(name=Some("Control1")) + let control_2 = @src.Clade::new(name=Some("Control2")) + let treated_1 = @src.Clade::new(name=Some("Treated1")) + let treated_2 = @src.Clade::new(name=Some("Treated2")) + let controls = @src.Clade::new(name=Some("Controls"), clades=[ + control_1, control_2, + ]) + let treated = @src.Clade::new(name=Some("Treated"), clades=[ + treated_1, treated_2, + ]) + let samples = @src.Clade::new(name=Some("Samples"), clades=[controls, treated]) + @src.Tree::new(samples, rooted=true, name=Some("sample_groups")) +} + +///| +fn print_assay(data : Array[Array[Double]]) -> Unit { + for row in data { + println(" [" + row.map(fn(value) { value.to_string() }).join(", ") + "]") + } +} + +///| +fn main { + println("=== TreeSummarizedExperiment Demo ===") + + let experiment = @src.summarized_experiment( + Map([ + ( + "counts", + [ + [10.0, 12.0, 20.0, 24.0], + [5.0, 7.0, 15.0, 17.0], + [30.0, 32.0, 18.0, 20.0], + [8.0, 10.0, 14.0, 16.0], + ], + ), + ]), + [("TaxonA", 0, 0), ("TaxonB", 0, 0), ("TaxonC", 0, 0), ("TaxonD", 0, 0)], + [ + Map([("sample", "Control1")]), + Map([("sample", "Control2")]), + Map([("sample", "Treated1")]), + Map([("sample", "Treated2")]), + ], + Map([("study", "microbiome-treatment")]), + ) + + let tse = @src.TreeSummarizedExperiment::new( + experiment~, + row_tree=Some(make_taxa_tree()), + row_node_labels=["TaxonA", "TaxonB", "TaxonC", "TaxonD"], + col_tree=Some(make_sample_tree()), + col_node_labels=["Control1", "Control2", "Treated1", "Treated2"], + reference_sequences=["ACGT", "AAGT", "CCGT", "TTGT"], + ) + + println("\n1. Container and links") + println(" Valid: \{tse.is_valid()}") + println(" Dimensions: \{tse.nrow()} rows x \{tse.ncol()} columns") + for link in tse.row_links() { + println( + " \{link.node_alias()} -> \{link.node_label()}, leaf=\{link.is_leaf()}", + ) + } + + println("\n2. Tree queries") + let descendants = @src.tse_find_descendants( + make_taxa_tree(), + "Firmicutes", + leaves_only=true, + ) + println(" Firmicutes descendants: " + descendants.join(", ")) + println( + " TaxonC ancestors: " + + @src.tse_find_ancestors(make_taxa_tree(), "TaxonC").join(" -> "), + ) + + println("\n3. Subset by an internal tree node") + match tse.subset_by_row_nodes(["Firmicutes"]) { + Some(subset) => + match subset.assay("counts") { + Some(data) => print_assay(data) + None => () + } + None => println(" Row tree is unavailable") + } + + println("\n4. Aggregate taxa to phylum level (sum)") + match tse.aggregate_rows(["Firmicutes", "Bacteroidota"]) { + Some(aggregated) => + match aggregated.assay("counts") { + Some(data) => print_assay(data) + None => () + } + None => println(" No matching row-tree nodes") + } + + println("\n5. Aggregate samples to treatment groups (mean)") + match + tse.aggregate_cols( + ["Controls", "Treated"], + aggregation=@src.tse_aggregation_mean(), + ) { + Some(aggregated) => + match aggregated.assay("counts") { + Some(data) => print_assay(data) + None => () + } + None => println(" No matching column-tree nodes") + } + + println("\n=== Demo Complete ===") +} diff --git a/examples/tree_summarized_experiment_demo/moon.pkg b/examples/tree_summarized_experiment_demo/moon.pkg new file mode 100644 index 00000000..8824b1ac --- /dev/null +++ b/examples/tree_summarized_experiment_demo/moon.pkg @@ -0,0 +1,6 @@ +import { + "IvanAXu/BioSeqs/src", + "moonbitlang/core/hashmap", +} + +pkgtype(kind: "executable") diff --git a/src/summarized_experiment.mbt b/src/summarized_experiment.mbt index 512b1c4a..7180a3f5 100644 --- a/src/summarized_experiment.mbt +++ b/src/summarized_experiment.mbt @@ -90,27 +90,23 @@ pub fn se_subset_rows( for name_idx = 0; name_idx < assay_names.length(); name_idx = name_idx + 1 { let name = assay_names[name_idx] let old_assay = se.assays[name] - let new_assay : Array[Array[Double]] = Array::make( - indices.length(), - Array::make(se_ncol(se), 0.0), - ) + let new_assay : Array[Array[Double]] = [] for i = 0; i < indices.length(); i = i + 1 { let old_idx = indices[i] + let row : Array[Double] = [] for j = 0; j < se_ncol(se); j = j + 1 { - new_assay[i][j] = old_assay[old_idx][j] + row.push(old_assay[old_idx][j]) } + new_assay.push(row) } new_assays[name] = new_assay } - let new_row_ranges : Array[(String, Int, Int)] = Array::make( - indices.length(), - ("", 0, 0), - ) + let new_row_ranges : Array[(String, Int, Int)] = [] for i = 0; i < indices.length(); i = i + 1 { - new_row_ranges[i] = se.row_ranges[indices[i]] + new_row_ranges.push(se.row_ranges[indices[i]]) } SummarizedExperiment::{ @@ -135,26 +131,22 @@ pub fn se_subset_cols( for name_idx = 0; name_idx < assay_names.length(); name_idx = name_idx + 1 { let name = assay_names[name_idx] let old_assay = se.assays[name] - let new_assay : Array[Array[Double]] = Array::make( - se_nrow(se), - Array::make(indices.length(), 0.0), - ) + let new_assay : Array[Array[Double]] = [] for i = 0; i < se_nrow(se); i = i + 1 { + let row : Array[Double] = [] for j = 0; j < indices.length(); j = j + 1 { - new_assay[i][j] = old_assay[i][indices[j]] + row.push(old_assay[i][indices[j]]) } + new_assay.push(row) } new_assays[name] = new_assay } - let new_col_data : Array[Map[String, String]] = Array::make( - indices.length(), - Map([], capacity=0), - ) + let new_col_data : Array[Map[String, String]] = [] for i = 0; i < indices.length(); i = i + 1 { - new_col_data[i] = se.col_data[indices[i]] + new_col_data.push(se.col_data[indices[i]]) } SummarizedExperiment::{ diff --git a/src/tree_summarized_experiment.mbt b/src/tree_summarized_experiment.mbt new file mode 100644 index 00000000..78d87bec --- /dev/null +++ b/src/tree_summarized_experiment.mbt @@ -0,0 +1,645 @@ +///| +/// TreeSummarizedExperiment - rectangular assays linked to row and column trees. +/// Inspired by the Bioconductor TreeSummarizedExperiment package. + +///| +/// Link between one assay dimension entry and a node in a tree. +pub struct TseLink { + node_label : String + node_alias : String + node_number : Int + is_leaf : Bool + tree_name : String +} + +///| +/// Construct a tree link. +pub fn TseLink::new( + node_label~ : String, + node_alias~ : String, + node_number~ : Int, + is_leaf~ : Bool, + tree_name? : String = "phylo", +) -> TseLink { + TseLink::{ node_label, node_alias, node_number, is_leaf, tree_name } +} + +///| +/// Return the node label. +pub fn TseLink::node_label(self : TseLink) -> String { + self.node_label +} + +///| +/// Return the stable node alias. +pub fn TseLink::node_alias(self : TseLink) -> String { + self.node_alias +} + +///| +/// Return the one-based node number. +pub fn TseLink::node_number(self : TseLink) -> Int { + self.node_number +} + +///| +/// Return whether the linked node is a leaf. +pub fn TseLink::is_leaf(self : TseLink) -> Bool { + self.is_leaf +} + +///| +/// Return the tree name used by the link. +pub fn TseLink::tree_name(self : TseLink) -> String { + self.tree_name +} + +///| +/// Supported aggregation functions for tree-level summaries. +pub enum TseAggregation { + Sum + Mean + Min + Max +} derive(Eq) + +///| +/// Create a sum aggregation strategy. +pub fn tse_aggregation_sum() -> TseAggregation { + TseAggregation::Sum +} + +///| +/// Create a mean aggregation strategy. +pub fn tse_aggregation_mean() -> TseAggregation { + TseAggregation::Mean +} + +///| +/// Create a minimum aggregation strategy. +pub fn tse_aggregation_min() -> TseAggregation { + TseAggregation::Min +} + +///| +/// Create a maximum aggregation strategy. +pub fn tse_aggregation_max() -> TseAggregation { + TseAggregation::Max +} + +///| +/// A SummarizedExperiment with optional hierarchical structures on both axes. +pub struct TreeSummarizedExperiment { + experiment : SummarizedExperiment + row_tree : Tree? + col_tree : Tree? + row_links : Array[TseLink] + col_links : Array[TseLink] + reference_sequences : Array[String] +} + +///| +/// Construct a TreeSummarizedExperiment. +/// +/// `row_node_labels` and `col_node_labels` map assay entries to named tree +/// nodes. Repeated labels are allowed, matching the Bioconductor link model. +pub fn TreeSummarizedExperiment::new( + experiment~ : SummarizedExperiment, + row_tree? : Tree? = None, + row_node_labels? : Array[String] = [], + col_tree? : Tree? = None, + col_node_labels? : Array[String] = [], + reference_sequences? : Array[String] = [], +) -> TreeSummarizedExperiment { + TreeSummarizedExperiment::{ + experiment, + row_tree, + col_tree, + row_links: tse_make_links(row_tree, row_node_labels), + col_links: tse_make_links(col_tree, col_node_labels), + reference_sequences, + } +} + +///| +/// Return the underlying SummarizedExperiment. +pub fn TreeSummarizedExperiment::experiment( + self : TreeSummarizedExperiment, +) -> SummarizedExperiment { + self.experiment +} + +///| +/// Return an assay by name. +pub fn TreeSummarizedExperiment::assay( + self : TreeSummarizedExperiment, + name : String, +) -> Array[Array[Double]]? { + se_assay(self.experiment, name) +} + +///| +/// Return all assay names. +pub fn TreeSummarizedExperiment::assay_names( + self : TreeSummarizedExperiment, +) -> Array[String] { + se_assay_names(self.experiment) +} + +///| +/// Return the number of assay rows. +pub fn TreeSummarizedExperiment::nrow(self : TreeSummarizedExperiment) -> Int { + se_nrow(self.experiment) +} + +///| +/// Return the number of assay columns. +pub fn TreeSummarizedExperiment::ncol(self : TreeSummarizedExperiment) -> Int { + se_ncol(self.experiment) +} + +///| +/// Return the row tree. +pub fn TreeSummarizedExperiment::row_tree( + self : TreeSummarizedExperiment, +) -> Tree? { + self.row_tree +} + +///| +/// Return the column tree. +pub fn TreeSummarizedExperiment::col_tree( + self : TreeSummarizedExperiment, +) -> Tree? { + self.col_tree +} + +///| +/// Return links between assay rows and row-tree nodes. +pub fn TreeSummarizedExperiment::row_links( + self : TreeSummarizedExperiment, +) -> Array[TseLink] { + self.row_links +} + +///| +/// Return links between assay columns and column-tree nodes. +pub fn TreeSummarizedExperiment::col_links( + self : TreeSummarizedExperiment, +) -> Array[TseLink] { + self.col_links +} + +///| +/// Return optional per-row reference sequences. +pub fn TreeSummarizedExperiment::reference_sequences( + self : TreeSummarizedExperiment, +) -> Array[String] { + self.reference_sequences +} + +///| +/// Check dimensions, tree links, reference sequences, and assay shapes. +pub fn TreeSummarizedExperiment::is_valid( + self : TreeSummarizedExperiment, +) -> Bool { + let nrow = self.nrow() + let ncol = self.ncol() + match self.row_tree { + Some(_) => if self.row_links.length() != nrow { return false } + None => if self.row_links.length() != 0 { return false } + } + match self.col_tree { + Some(_) => if self.col_links.length() != ncol { return false } + None => if self.col_links.length() != 0 { return false } + } + if self.reference_sequences.length() != 0 && + self.reference_sequences.length() != nrow { + return false + } + for assay_name in self.assay_names() { + match self.assay(assay_name) { + Some(assay) => { + if assay.length() != nrow { + return false + } + for row in assay { + if row.length() != ncol { + return false + } + } + } + None => return false + } + } + true +} + +///| +/// Subset assay rows while preserving the full tree and updating row links. +pub fn TreeSummarizedExperiment::subset_rows( + self : TreeSummarizedExperiment, + indices : Array[Int], +) -> TreeSummarizedExperiment { + let links : Array[TseLink] = [] + let sequences : Array[String] = [] + for index in indices { + if index >= 0 && index < self.row_links.length() { + links.push(self.row_links[index]) + } + if index >= 0 && index < self.reference_sequences.length() { + sequences.push(self.reference_sequences[index]) + } + } + TreeSummarizedExperiment::{ + experiment: se_subset_rows(self.experiment, indices), + row_tree: self.row_tree, + col_tree: self.col_tree, + row_links: links, + col_links: self.col_links, + reference_sequences: sequences, + } +} + +///| +/// Subset assay columns while preserving the full tree and updating col links. +pub fn TreeSummarizedExperiment::subset_cols( + self : TreeSummarizedExperiment, + indices : Array[Int], +) -> TreeSummarizedExperiment { + let links : Array[TseLink] = [] + for index in indices { + if index >= 0 && index < self.col_links.length() { + links.push(self.col_links[index]) + } + } + TreeSummarizedExperiment::{ + experiment: se_subset_cols(self.experiment, indices), + row_tree: self.row_tree, + col_tree: self.col_tree, + row_links: self.row_links, + col_links: links, + reference_sequences: self.reference_sequences, + } +} + +///| +/// Subset rows linked to the selected nodes or any of their descendants. +pub fn TreeSummarizedExperiment::subset_by_row_nodes( + self : TreeSummarizedExperiment, + node_labels : Array[String], +) -> TreeSummarizedExperiment? { + match self.row_tree { + None => None + Some(tree) => { + let indices = tse_link_indices_under(tree, self.row_links, node_labels) + Some(self.subset_rows(indices)) + } + } +} + +///| +/// Subset columns linked to the selected nodes or any of their descendants. +pub fn TreeSummarizedExperiment::subset_by_col_nodes( + self : TreeSummarizedExperiment, + node_labels : Array[String], +) -> TreeSummarizedExperiment? { + match self.col_tree { + None => None + Some(tree) => { + let indices = tse_link_indices_under(tree, self.col_links, node_labels) + Some(self.subset_cols(indices)) + } + } +} + +///| +/// Aggregate assay rows to arbitrary nodes in the row tree. +pub fn TreeSummarizedExperiment::aggregate_rows( + self : TreeSummarizedExperiment, + node_labels : Array[String], + aggregation? : TseAggregation = TseAggregation::Sum, +) -> TreeSummarizedExperiment? { + match self.row_tree { + None => None + Some(tree) => { + let targets = tse_existing_nodes(tree, node_labels) + if targets.length() == 0 { + return None + } + let groups = tse_link_groups_under(tree, self.row_links, targets) + let assays : Map[String, Array[Array[Double]]] = Map([]) + for assay_name in self.assay_names() { + match self.assay(assay_name) { + None => () + Some(assay) => { + let result : Array[Array[Double]] = [] + for group in groups { + let row : Array[Double] = [] + for col = 0; col < self.ncol(); col = col + 1 { + let values : Array[Double] = [] + for source_row in group { + values.push(assay[source_row][col]) + } + row.push(tse_aggregate_values(values, aggregation)) + } + result.push(row) + } + assays[assay_name] = result + } + } + } + let row_ranges = targets.map(fn(label) { (label, 0, 0) }) + let experiment = summarized_experiment( + assays, + row_ranges, + se_col_data(self.experiment), + se_metadata(self.experiment), + ) + Some(TreeSummarizedExperiment::{ + experiment, + row_tree: self.row_tree, + col_tree: self.col_tree, + row_links: tse_make_links(self.row_tree, targets), + col_links: self.col_links, + reference_sequences: [], + }) + } + } +} + +///| +/// Aggregate assay columns to arbitrary nodes in the column tree. +pub fn TreeSummarizedExperiment::aggregate_cols( + self : TreeSummarizedExperiment, + node_labels : Array[String], + aggregation? : TseAggregation = TseAggregation::Sum, +) -> TreeSummarizedExperiment? { + match self.col_tree { + None => None + Some(tree) => { + let targets = tse_existing_nodes(tree, node_labels) + if targets.length() == 0 { + return None + } + let groups = tse_link_groups_under(tree, self.col_links, targets) + let assays : Map[String, Array[Array[Double]]] = Map([]) + for assay_name in self.assay_names() { + match self.assay(assay_name) { + None => () + Some(assay) => { + let result : Array[Array[Double]] = [] + for source_row = 0 + source_row < self.nrow() + source_row = source_row + 1 { + let row : Array[Double] = [] + for group in groups { + let values : Array[Double] = [] + for source_col in group { + values.push(assay[source_row][source_col]) + } + row.push(tse_aggregate_values(values, aggregation)) + } + result.push(row) + } + assays[assay_name] = result + } + } + } + let col_data = targets.map(fn(label) { Map([("tree_node", label)]) }) + let experiment = summarized_experiment( + assays, + se_row_ranges(self.experiment), + col_data, + se_metadata(self.experiment), + ) + Some(TreeSummarizedExperiment::{ + experiment, + row_tree: self.row_tree, + col_tree: self.col_tree, + row_links: self.row_links, + col_links: tse_make_links(self.col_tree, targets), + reference_sequences: self.reference_sequences, + }) + } + } +} + +///| +/// Return descendant labels of a node. +pub fn tse_find_descendants( + tree : Tree, + node_label : String, + leaves_only? : Bool = false, +) -> Array[String] { + match tree.find_any(name=Some(node_label)) { + None => [] + Some(node) => { + let result : Array[String] = [] + tse_collect_descendant_labels(node, leaves_only, result) + result + } + } +} + +///| +/// Return ancestor labels from root to the parent of `node_label`. +pub fn tse_find_ancestors(tree : Tree, node_label : String) -> Array[String] { + match tree.get_path(node_label) { + None => [] + Some(path) => { + let result : Array[String] = [] + for index = 0; index + 1 < path.length(); index = index + 1 { + match path[index].name { + Some(name) => result.push(name) + None => () + } + } + result + } + } +} + +///| +/// Return whether a named tree node is a leaf. +pub fn tse_is_leaf(tree : Tree, node_label : String) -> Bool { + match tree.find_any(name=Some(node_label)) { + Some(node) => node.is_terminal() + None => false + } +} + +///| +fn tse_tree_name(tree : Tree) -> String { + tree.name.unwrap_or("phylo") +} + +///| +fn tse_ordered_nodes(tree : Tree) -> Array[Clade] { + let nodes = tree.get_terminals() + for node in tree.get_nonterminals() { + nodes.push(node) + } + nodes +} + +///| +fn tse_make_links(tree : Tree?, labels : Array[String]) -> Array[TseLink] { + match tree { + None => [] + Some(value) => { + let nodes = tse_ordered_nodes(value) + let result : Array[TseLink] = [] + for label in labels { + let mut found = false + for index = 0; index < nodes.length(); index = index + 1 { + if !found && nodes[index].name == Some(label) { + result.push( + TseLink::new( + node_label=label, + node_alias="alias_" + (index + 1).to_string(), + node_number=index + 1, + is_leaf=nodes[index].is_terminal(), + tree_name=tse_tree_name(value), + ), + ) + found = true + } + } + } + result + } + } +} + +///| +fn tse_node_is_under( + tree : Tree, + node_label : String, + ancestor : String, +) -> Bool { + if node_label == ancestor { + return true + } + match tree.get_path(node_label) { + None => false + Some(path) => { + for node in path { + if node.name == Some(ancestor) { + return true + } + } + false + } + } +} + +///| +fn tse_link_indices_under( + tree : Tree, + links : Array[TseLink], + node_labels : Array[String], +) -> Array[Int] { + let result : Array[Int] = [] + for index = 0; index < links.length(); index = index + 1 { + let mut selected = false + for node_label in node_labels { + if tse_node_is_under(tree, links[index].node_label, node_label) { + selected = true + } + } + if selected { + result.push(index) + } + } + result +} + +///| +fn tse_existing_nodes(tree : Tree, labels : Array[String]) -> Array[String] { + let result : Array[String] = [] + for label in labels { + if tree.find_any(name=Some(label)) is Some(_) { + let mut duplicate = false + for existing in result { + if existing == label { + duplicate = true + } + } + if !duplicate { + result.push(label) + } + } + } + result +} + +///| +fn tse_link_groups_under( + tree : Tree, + links : Array[TseLink], + node_labels : Array[String], +) -> Array[Array[Int]] { + node_labels.map(fn(label) { tse_link_indices_under(tree, links, [label]) }) +} + +///| +fn tse_aggregate_values( + values : Array[Double], + aggregation : TseAggregation, +) -> Double { + if values.length() == 0 { + return 0.0 + } + match aggregation { + TseAggregation::Sum => { + let mut total = 0.0 + for value in values { + total = total + value + } + total + } + TseAggregation::Mean => { + let mut total = 0.0 + for value in values { + total = total + value + } + total / values.length().to_double() + } + TseAggregation::Min => { + let mut result = values[0] + for value in values { + if value < result { + result = value + } + } + result + } + TseAggregation::Max => { + let mut result = values[0] + for value in values { + if value > result { + result = value + } + } + result + } + } +} + +///| +fn tse_collect_descendant_labels( + node : Clade, + leaves_only : Bool, + result : Array[String], +) -> Unit { + for child in node.clades { + if !leaves_only || child.is_terminal() { + match child.name { + Some(name) => result.push(name) + None => () + } + } + tse_collect_descendant_labels(child, leaves_only, result) + } +} diff --git a/test/moonbit/summarized_experiment_test.mbt b/test/moonbit/summarized_experiment_test.mbt index 5bc41bc8..e5d60f1b 100644 --- a/test/moonbit/summarized_experiment_test.mbt +++ b/test/moonbit/summarized_experiment_test.mbt @@ -53,6 +53,10 @@ test "summarized_experiment_subset_rows" { let se_sub = @src.se_subset_rows(se, [0, 2]) assert_eq(@src.se_nrow(se_sub), 2) + match @src.se_assay(se_sub, "counts") { + Some(assay) => assert_eq(assay, [[1.0, 2.0], [5.0, 6.0]]) + None => assert_true(false) + } } ///| @@ -70,6 +74,10 @@ test "summarized_experiment_subset_cols" { let se_sub = @src.se_subset_cols(se, [0, 2]) assert_eq(@src.se_ncol(se_sub), 2) + match @src.se_assay(se_sub, "counts") { + Some(assay) => assert_eq(assay, [[1.0, 3.0], [4.0, 6.0]]) + None => assert_true(false) + } } ///| diff --git a/test/moonbit/tree_summarized_experiment_test.mbt b/test/moonbit/tree_summarized_experiment_test.mbt new file mode 100644 index 00000000..389db219 --- /dev/null +++ b/test/moonbit/tree_summarized_experiment_test.mbt @@ -0,0 +1,254 @@ +///| +fn tse_test_row_tree() -> @src.Tree { + let a = @src.Clade::new(name=Some("A")) + let b = @src.Clade::new(name=Some("B")) + let c = @src.Clade::new(name=Some("C")) + let d = @src.Clade::new(name=Some("D")) + let group_a = @src.Clade::new(name=Some("GroupA"), clades=[a, b]) + let group_b = @src.Clade::new(name=Some("GroupB"), clades=[c, d]) + let root = @src.Clade::new(name=Some("All"), clades=[group_a, group_b]) + @src.Tree::new(root, rooted=true, name=Some("taxa")) +} + +///| +fn tse_test_col_tree() -> @src.Tree { + let s1 = @src.Clade::new(name=Some("S1")) + let s2 = @src.Clade::new(name=Some("S2")) + let s3 = @src.Clade::new(name=Some("S3")) + let s4 = @src.Clade::new(name=Some("S4")) + let control = @src.Clade::new(name=Some("Control"), clades=[s1, s2]) + let treated = @src.Clade::new(name=Some("Treated"), clades=[s3, s4]) + let root = @src.Clade::new(name=Some("Samples"), clades=[control, treated]) + @src.Tree::new(root, rooted=true, name=Some("samples")) +} + +///| +fn tse_test_experiment() -> @src.SummarizedExperiment { + @src.summarized_experiment( + Map([ + ( + "counts", + [ + [1.0, 2.0, 3.0, 4.0], + [3.0, 4.0, 5.0, 6.0], + [5.0, 6.0, 7.0, 8.0], + [7.0, 8.0, 9.0, 10.0], + ], + ), + ( + "normalized", + [ + [0.1, 0.2, 0.3, 0.4], + [0.3, 0.4, 0.5, 0.6], + [0.5, 0.6, 0.7, 0.8], + [0.7, 0.8, 0.9, 1.0], + ], + ), + ]), + [("A", 0, 0), ("B", 0, 0), ("C", 0, 0), ("D", 0, 0)], + [ + Map([("sample", "S1")]), + Map([("sample", "S2")]), + Map([("sample", "S3")]), + Map([("sample", "S4")]), + ], + Map([("study", "tree-demo")]), + ) +} + +///| +fn tse_test_object() -> @src.TreeSummarizedExperiment { + @src.TreeSummarizedExperiment::new( + experiment=tse_test_experiment(), + row_tree=Some(tse_test_row_tree()), + row_node_labels=["A", "B", "C", "D"], + col_tree=Some(tse_test_col_tree()), + col_node_labels=["S1", "S2", "S3", "S4"], + reference_sequences=["AAAA", "CCCC", "GGGG", "TTTT"], + ) +} + +///| +test "tree_summarized_experiment: construct and access links" { + let tse = tse_test_object() + assert_true(tse.is_valid()) + assert_eq(tse.nrow(), 4) + assert_eq(tse.ncol(), 4) + assert_eq(tse.assay_names().length(), 2) + assert_eq(tse.row_links().length(), 4) + assert_eq(tse.col_links().length(), 4) + assert_eq(tse.row_links()[0].node_label(), "A") + assert_eq(tse.row_links()[0].node_alias(), "alias_1") + assert_eq(tse.row_links()[0].node_number(), 1) + assert_true(tse.row_links()[0].is_leaf()) + assert_eq(tse.row_links()[0].tree_name(), "taxa") + assert_eq(tse.reference_sequences()[3], "TTTT") +} + +///| +test "tree_summarized_experiment: invalid link is detected" { + let tse = @src.TreeSummarizedExperiment::new( + experiment=tse_test_experiment(), + row_tree=Some(tse_test_row_tree()), + row_node_labels=["A", "B", "missing", "D"], + ) + assert_false(tse.is_valid()) + assert_eq(tse.row_links().length(), 3) +} + +///| +test "tree_summarized_experiment: tree node queries" { + let tree = tse_test_row_tree() + assert_eq(@src.tse_find_descendants(tree, "GroupA", leaves_only=true), [ + "A", "B", + ]) + assert_eq(@src.tse_find_ancestors(tree, "C"), ["All", "GroupB"]) + assert_true(@src.tse_is_leaf(tree, "D")) + assert_false(@src.tse_is_leaf(tree, "GroupB")) + assert_eq(@src.tse_find_descendants(tree, "missing").length(), 0) +} + +///| +test "tree_summarized_experiment: subset rows keeps links and sequences" { + let subset = tse_test_object().subset_rows([1, 3]) + assert_true(subset.is_valid()) + assert_eq(subset.nrow(), 2) + assert_eq(subset.row_links()[0].node_label(), "B") + assert_eq(subset.row_links()[1].node_label(), "D") + assert_eq(subset.reference_sequences(), ["CCCC", "TTTT"]) + match subset.assay("counts") { + Some(assay) => + assert_eq(assay, [[3.0, 4.0, 5.0, 6.0], [7.0, 8.0, 9.0, 10.0]]) + None => assert_true(false) + } +} + +///| +test "tree_summarized_experiment: subset by row tree node" { + match tse_test_object().subset_by_row_nodes(["GroupA"]) { + None => assert_true(false) + Some(subset) => { + assert_true(subset.is_valid()) + assert_eq(subset.nrow(), 2) + assert_eq(subset.row_links()[0].node_label(), "A") + assert_eq(subset.row_links()[1].node_label(), "B") + } + } +} + +///| +test "tree_summarized_experiment: subset by column tree node" { + match tse_test_object().subset_by_col_nodes(["Treated"]) { + None => assert_true(false) + Some(subset) => { + assert_true(subset.is_valid()) + assert_eq(subset.ncol(), 2) + assert_eq(subset.col_links()[0].node_label(), "S3") + assert_eq(subset.col_links()[1].node_label(), "S4") + } + } +} + +///| +test "tree_summarized_experiment: aggregate rows by sum" { + match tse_test_object().aggregate_rows(["GroupA", "GroupB"]) { + None => assert_true(false) + Some(aggregated) => { + assert_true(aggregated.is_valid()) + assert_eq(aggregated.nrow(), 2) + assert_eq(aggregated.row_links()[0].node_label(), "GroupA") + assert_false(aggregated.row_links()[0].is_leaf()) + match aggregated.assay("counts") { + Some(assay) => + assert_eq(assay, [[4.0, 6.0, 8.0, 10.0], [12.0, 14.0, 16.0, 18.0]]) + None => assert_true(false) + } + match aggregated.assay("normalized") { + Some(assay) => { + assert_true((assay[0][0] - 0.4).abs() < 1.0e-12) + assert_true((assay[0][1] - 0.6).abs() < 1.0e-12) + assert_true((assay[0][2] - 0.8).abs() < 1.0e-12) + assert_true((assay[0][3] - 1.0).abs() < 1.0e-12) + } + None => assert_true(false) + } + } + } +} + +///| +test "tree_summarized_experiment: aggregate rows by mean min and max" { + let tse = tse_test_object() + match + tse.aggregate_rows(["GroupA"], aggregation=@src.tse_aggregation_mean()) { + Some(result) => + match result.assay("counts") { + Some(assay) => assert_eq(assay[0], [2.0, 3.0, 4.0, 5.0]) + None => assert_true(false) + } + None => assert_true(false) + } + match tse.aggregate_rows(["GroupA"], aggregation=@src.tse_aggregation_min()) { + Some(result) => + match result.assay("counts") { + Some(assay) => assert_eq(assay[0], [1.0, 2.0, 3.0, 4.0]) + None => assert_true(false) + } + None => assert_true(false) + } + match tse.aggregate_rows(["GroupA"], aggregation=@src.tse_aggregation_max()) { + Some(result) => + match result.assay("counts") { + Some(assay) => assert_eq(assay[0], [3.0, 4.0, 5.0, 6.0]) + None => assert_true(false) + } + None => assert_true(false) + } +} + +///| +test "tree_summarized_experiment: aggregate columns" { + match tse_test_object().aggregate_cols(["Control", "Treated"]) { + None => assert_true(false) + Some(aggregated) => { + assert_true(aggregated.is_valid()) + assert_eq(aggregated.ncol(), 2) + assert_eq(aggregated.col_links()[0].node_label(), "Control") + match aggregated.assay("counts") { + Some(assay) => { + assert_eq(assay[0], [3.0, 7.0]) + assert_eq(assay[3], [15.0, 19.0]) + } + None => assert_true(false) + } + } + } +} + +///| +test "tree_summarized_experiment: duplicate links can aggregate" { + let tse = @src.TreeSummarizedExperiment::new( + experiment=tse_test_experiment(), + row_tree=Some(tse_test_row_tree()), + row_node_labels=["A", "A", "C", "D"], + ) + assert_true(tse.is_valid()) + match tse.aggregate_rows(["A"]) { + Some(aggregated) => + match aggregated.assay("counts") { + Some(assay) => assert_eq(assay[0], [4.0, 6.0, 8.0, 10.0]) + None => assert_true(false) + } + None => assert_true(false) + } +} + +///| +test "tree_summarized_experiment: works without trees" { + let tse = @src.TreeSummarizedExperiment::new(experiment=tse_test_experiment()) + assert_true(tse.is_valid()) + assert_eq(tse.row_links().length(), 0) + assert_eq(tse.col_links().length(), 0) + assert_true(tse.aggregate_rows(["All"]) is None) + assert_true(tse.subset_by_col_nodes(["Samples"]) is None) +} From 764259825c44194130afdeb28a7ecce46bcb6d18 Mon Sep 17 00:00:00 2001 From: eda Date: Tue, 4 Aug 2026 14:21:48 +0800 Subject: [PATCH 02/41] #28 /8222 feat(cellosaurus): like Biopython Bio.ExPASy.cellosaurus --- README.md | 20 +- examples/cellosaurus_demo/main.mbt | 35 +++ examples/cellosaurus_demo/moon.pkg | 7 + src/cellosaurus.mbt | 439 +++++++++++++++++++++++++++++ test/moonbit/cellosaurus_test.mbt | 194 +++++++++++++ 5 files changed, 691 insertions(+), 4 deletions(-) create mode 100644 examples/cellosaurus_demo/main.mbt create mode 100644 examples/cellosaurus_demo/moon.pkg create mode 100644 src/cellosaurus.mbt create mode 100644 test/moonbit/cellosaurus_test.mbt diff --git a/README.md b/README.md index 93c3f849..736c2fdf 100644 --- a/README.md +++ b/README.md @@ -199,6 +199,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **IRanges** | Bioconductor IRanges | 整数区间操作、集合运算、重叠检测、findOverlaps高级类型、nearest、coverage、距离矩阵计算 | ✅ | | **TxDb** | Bioconductor GenomicFeatures | 转录本数据库、GTF解析、基因/转录本/外显子/CDS提取、UTR/内含子计算、启动子提取 | ✅ | | **ExPASy** | Biopython `Bio.ExPASy` | 蛋白质分析工具接口、Swiss-Prot条目解析、酶数据库查询、蛋白质参数计算（分子量、等电点、GRAVY、不稳定指数） | ✅ | +| **Cellosaurus** | Biopython `Bio.ExPASy.cellosaurus` | Cellosaurus平面文本解析、类型化细胞系记录、数据库交叉引用、物种查询、序列化往返 | ✅ | | **Prosite** | Biopython `Bio.Prosite` | 蛋白质模体数据库搜索、Prosite模式解析、模体匹配算法、模体得分计算 | ✅ | | **PAML** | Biopython `Bio.PAML` | 分子进化分析、dN/dS计算（Nei-Gojobori方法）、Jukes-Cantor校正、密码子使用分析 | ✅ | | **Graphics** | Biopython `Bio.Graphics` | 生物信息学可视化、序列Logo绘制、序列比对可视化、基因组特征绘图 | ✅ | @@ -467,6 +468,7 @@ IvanAXu/BioSeqs/ │ ├── restriction.mbt # 限制性内切酶分析 (酶切位点查找、片段分析) │ ├── protparam.mbt # ProtParam 蛋白质参数分析 (不稳定指数、等电点、信号肽预测、二级结构倾向) │ ├── prosite.mbt # Bio.Prosite 蛋白质模体数据库搜索 +│ ├── cellosaurus.mbt # Bio.ExPASy.cellosaurus 细胞系数据库平面文件解析 │ ├── affy.mbt # Affy Affymetrix芯片数据分析 (RMA标准化、背景校正、分位数归一化) │ ├── feature_extraction.mbt # 机器学习特征提取 │ ├── faidx.mbt # FASTA 快速索引访问 (pyfaidx) @@ -767,6 +769,7 @@ IvanAXu/BioSeqs/ │ ├── enrichplot_demo/ # enrichplot 富集分析结果可视化示例 │ ├── ensembldb_demo/ # ensembldb Ensembl注释数据库接口示例 │ ├── expasy_demo/ # ExPASy 蛋白质分析工具接口示例 +│ ├── cellosaurus_demo/ # Cellosaurus 记录解析、查询与序列化示例 │ ├── entrez_demo/ # Entrez NCBI数据库访问示例 (ESearch、EFetch、PubMed/Gene/Taxonomy解析) │ ├── faidx_demo/ # FASTA 索引示例 │ ├── fgsea_demo/ # fgsea 快速基因集富集分析示例 (置换检验、NES/ES计算、Leading Edge基因) @@ -1149,6 +1152,7 @@ IvanAXu/BioSeqs/ │ │ ├── bioc_generics_test.mbt │ │ ├── bioc_parallel_test.mbt │ │ ├── bsseq_test.mbt +│ │ ├── cellosaurus_test.mbt │ │ ├── checksum_test.mbt │ │ ├── chipseeker_test.mbt │ │ ├── chromvar_test.mbt @@ -1404,7 +1408,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8206 个测试全部通过 +moon test # ✅ 8222 个测试全部通过 ``` ### 模块对照表 @@ -1544,6 +1548,7 @@ moon test # ✅ 8206 个测试全 | `medline.mbt` | BioPython `Bio.Medline` | Medline/PubMed 解析 | | `entrez.mbt` | BioPython `Bio.Entrez` | NCBI 数据库访问 | | `swissprot.mbt` | BioPython `Bio.SwissProt` | UniProt 记录解析 | +| `cellosaurus.mbt` | BioPython `Bio.ExPASy.cellosaurus` | Cellosaurus记录解析、交叉引用查询与平面文本序列化 | | `uniprot_io.mbt` | BioPython `Bio.SeqIO.UniprotIO` | UniProt XML 格式解析 | | `chem_utils.mbt` | BioPython `Bio.PDB.chem_utils` | 化学计算工具（键长、键角、二面角、分子式量） | | `jaspar.mbt` | BioPython `Bio.motifs.Jaspar` | JASPAR PFM 格式解析与模体分析 | @@ -2708,6 +2713,10 @@ moon test # ✅ 8206 个测试全 实现结合实验矩阵与层级树的 `TreeSummarizedExperiment` 容器，复用现有 `SummarizedExperiment`、`Tree` 和 `Clade` 类型。容器支持 `row_tree`/`col_tree`、`row_links`/`col_links` 和 `reference_sequences`，其中 `TseLink` 记录节点标签、稳定别名、一基节点编号、叶节点状态和树名称，对应 Bioconductor 的 `rowTree`、`rowLinks`、`colTree`、`colLinks` 与 `referenceSeq` 语义。`subset_rows`/`subset_cols` 同步裁剪 assay、链接和参考序列；`subset_by_row_nodes`/`subset_by_col_nodes` 可按内部节点或叶节点选择所有已链接后代，保留原树结构。`aggregate_rows`/`aggregate_cols` 对目标节点覆盖的数据执行 Sum、Mean、Min 或 Max 聚合，并为结果重建节点链接。`tse_find_descendants`、`tse_find_ancestors` 和 `tse_is_leaf` 提供树节点查询。`is_valid` 检查 assay 维度、链接长度、树存在性和参考序列长度。适用于微生物分类丰度、系统发育表达矩阵和具有样本层级的数据分析。 +### 237. Cellosaurus 细胞系数据库解析 (Bio.ExPASy.cellosaurus) + +实现与 Biopython `Bio.ExPASy.cellosaurus` 对应的 Cellosaurus 平面文本解析。`cellosaurus_parse` 支持批量记录，`cellosaurus_read` 支持零或一条记录；解析器识别 `ID`、`AC`、`AS`、`SY`、`DR`、`RX`、`WW`、`CC`、`ST`、`DI`、`OX`、`HI`、`OI`、`SX`、`AG`、`CA` 和 `DT` 字段，兼容数据库头部、未知扩展字段与 CRLF。`CellosaurusRecord` 提供类型化记录，`CellosaurusCrossReference` 将 `DR` 字段拆分为数据库和登录号；辅助方法支持次级登录号/同义名拆分、按数据库筛选交叉引用和物种文本查询。`to_string` 可生成规范平面文本并支持解析-序列化往返。缺失 `//` 终止符、记录嵌套、非法 `DR` 或单记录读取到多条记录时抛出 `CellosaurusError`。 + ## 性能优化 @@ -2810,8 +2819,8 @@ moon test # ✅ 8206 个测试全 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8206 | -| 通过数 | 8206 | +| 总测试数 | 8222 | +| 通过数 | 8222 | | 失败数 | 0 | | 通过率 | 100% | @@ -2908,6 +2917,7 @@ moon test --update | NeighborSearch | `neighbor_search_test.mbt` | 6 | | BiocNeighbors | `bioc_neighbors_test.mbt` | 61 | | SwissProt | `swissprot_test.mbt` | 8 | +| Cellosaurus | `cellosaurus_test.mbt` | 16 | | mmCIF | `mmcif_test.mbt` | 2 | | Nexus | `nexus_test.mbt` | 2 | | EMBOSS | `emboss_test.mbt` | 15 | @@ -3196,7 +3206,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 336 个示例程序，展示各模块的典型用法： +项目提供 337 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3266,6 +3276,7 @@ moon run cmd/bench/main.mbt | tree_construction_demo | TreeConstruction 系统发育树构建（UPGMA/WPGMA/NJ算法、替换模型、距离矩阵） | `moon run examples/tree_construction_demo/main.mbt` | | neighbor_search_demo | NeighborSearch KD树近邻搜索（半径搜索、最近邻、原子对搜索） | `moon run examples/neighbor_search_demo/main.mbt` | | swissprot_demo | SwissProt 蛋白数据库解析（记录解析、特征提取、参考文献） | `moon run examples/swissprot_demo/main.mbt` | +| cellosaurus_demo | Cellosaurus细胞系记录解析、物种/同义名/交叉引用查询和序列化往返 | `moon run examples/cellosaurus_demo/main.mbt` | | uniprot_io_demo | UniProt XML格式解析（蛋白质条目解析、功能注释提取、序列转换） | `moon run examples/uniprot_io_demo/main.mbt` | | chem_utils_demo | 化学计算工具（键长、键角、二面角、分子式量、氢键长度） | `moon run examples/chem_utils_demo/main.mbt` | | jaspar_demo | JASPAR PFM格式解析（模体矩阵解析、共有序列、PWM转换、序列扫描） | `moon run examples/jaspar_demo/main.mbt` | @@ -3462,6 +3473,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 TreeConstruction 系统发育树构建（UPGMA/WPGMA/NJ算法、替换模型、距离矩阵） - ✅ 实现 NeighborSearch KD树近邻搜索（半径搜索、最近邻、原子对搜索） - ✅ 实现 SwissProt 蛋白数据库解析（记录解析、特征提取、参考文献） +- ✅ 实现 Cellosaurus 细胞系数据库解析（多记录读取、交叉引用/物种查询、平面文本序列化） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/cellosaurus_demo/main.mbt b/examples/cellosaurus_demo/main.mbt new file mode 100644 index 00000000..bce3a9e6 --- /dev/null +++ b/examples/cellosaurus_demo/main.mbt @@ -0,0 +1,35 @@ +///| +/// Cellosaurus example: parse, query, and serialize a cell-line record. +/// +/// Run: moon run examples/cellosaurus_demo/main.mbt +fn main { + println("=== Cellosaurus Record Demo ===") + try { + let record = match @bio.cellosaurus_read(@bio.cellosaurus_sample_text()) { + Some(record) => record + None => abort("expected one Cellosaurus record") + } + + println("Record: \{record.repr()}") + println("Accession: \{record.accession}") + println("Human origin: \{record.has_species("Homo sapiens")}") + + println("Synonyms:") + for synonym in record.synonym_list() { + println(" - \{synonym}") + } + + println("Database cross-references:") + for reference in record.cross_references { + println(" - \{reference.database}: \{reference.accession}") + } + let ecacc = record.cross_references_for("ECACC") + println("ECACC accessions: \{ecacc.length()}") + + let serialized = record.to_string() + let reparsed = @bio.cellosaurus_parse(serialized) + println("Round-trip records: \{reparsed.length()}") + } catch { + _ => println("Failed to parse the Cellosaurus sample") + } +} diff --git a/examples/cellosaurus_demo/moon.pkg b/examples/cellosaurus_demo/moon.pkg new file mode 100644 index 00000000..f3a37d11 --- /dev/null +++ b/examples/cellosaurus_demo/moon.pkg @@ -0,0 +1,7 @@ +import { + "IvanAXu/BioSeqs/src" @bio, +} + +options( + "is-main": true, +) diff --git a/src/cellosaurus.mbt b/src/cellosaurus.mbt new file mode 100644 index 00000000..3900bbad --- /dev/null +++ b/src/cellosaurus.mbt @@ -0,0 +1,439 @@ +///| +/// Parser for the ExPASy Cellosaurus flat-file format. +/// +/// Mirrors the record model and parsing behavior of Biopython's +/// `Bio.ExPASy.cellosaurus` module. + +///| +/// Error raised for malformed or ambiguous Cellosaurus input. +pub suberror CellosaurusError { + CellosaurusError(String) +} + +///| +/// A Cellosaurus `DR` cross-reference. +pub struct CellosaurusCrossReference { + database : String + accession : String +} derive(Eq) + +///| +/// Create a Cellosaurus cross-reference. +pub fn CellosaurusCrossReference::new( + database~ : String, + accession~ : String, +) -> CellosaurusCrossReference { + CellosaurusCrossReference::{ database, accession } +} + +///| +/// A typed Cellosaurus cell-line record. +/// +/// Fields correspond to the official two-letter line codes: +/// ID, AC, AS, SY, DR, RX, WW, CC, ST, DI, OX, HI, OI, SX, AG, CA, and DT. +pub struct CellosaurusRecord { + identifier : String + accession : String + secondary_accessions : String + synonyms : String + cross_references : Array[CellosaurusCrossReference] + reference_identifiers : Array[String] + web_pages : Array[String] + comments : Array[String] + str_profiles : Array[String] + diseases : Array[String] + species : Array[String] + hierarchy : Array[String] + same_individual : Array[String] + sex : String + age : String + category : String + date : String +} derive(Eq) + +///| +/// Create a Cellosaurus record. +pub fn CellosaurusRecord::new( + identifier~ : String, + accession? : String = "", + secondary_accessions? : String = "", + synonyms? : String = "", + cross_references? : Array[CellosaurusCrossReference] = [], + reference_identifiers? : Array[String] = [], + web_pages? : Array[String] = [], + comments? : Array[String] = [], + str_profiles? : Array[String] = [], + diseases? : Array[String] = [], + species? : Array[String] = [], + hierarchy? : Array[String] = [], + same_individual? : Array[String] = [], + sex? : String = "", + age? : String = "", + category? : String = "", + date? : String = "", +) -> CellosaurusRecord { + CellosaurusRecord::{ + identifier, + accession, + secondary_accessions, + synonyms, + cross_references, + reference_identifiers, + web_pages, + comments, + str_profiles, + diseases, + species, + hierarchy, + same_individual, + sex, + age, + category, + date, + } +} + +///| +/// Return secondary accessions split on semicolons. +pub fn CellosaurusRecord::secondary_accession_list( + self : CellosaurusRecord, +) -> Array[String] { + cellosaurus_split_semicolon_list(self.secondary_accessions) +} + +///| +/// Return cell-line synonyms split on semicolons. +pub fn CellosaurusRecord::synonym_list( + self : CellosaurusRecord, +) -> Array[String] { + cellosaurus_split_semicolon_list(self.synonyms) +} + +///| +/// Return accessions referenced by the requested external database. +pub fn CellosaurusRecord::cross_references_for( + self : CellosaurusRecord, + database : String, +) -> Array[String] { + let result : Array[String] = [] + for reference in self.cross_references { + if reference.database == database { + result.push(reference.accession) + } + } + result +} + +///| +/// Test whether any OX line contains the requested species text. +pub fn CellosaurusRecord::has_species( + self : CellosaurusRecord, + species_name : String, +) -> Bool { + for origin in self.species { + if origin.contains(species_name) { + return true + } + } + false +} + +///| +/// Return a compact representation similar to Biopython's `Record.__repr__`. +pub fn CellosaurusRecord::repr(self : CellosaurusRecord) -> String { + if self.identifier.length() == 0 { + "CellosaurusRecord ( )" + } else if self.accession.length() == 0 { + "CellosaurusRecord (" + self.identifier + ")" + } else { + "CellosaurusRecord (" + self.identifier + ", " + self.accession + ")" + } +} + +///| +/// Serialize a record to canonical Cellosaurus flat-file text. +pub fn CellosaurusRecord::to_string(self : CellosaurusRecord) -> String { + let output = StringBuilder::new() + cellosaurus_write_field(output, "ID", self.identifier) + cellosaurus_write_field(output, "AC", self.accession) + cellosaurus_write_field(output, "AS", self.secondary_accessions) + cellosaurus_write_field(output, "SY", self.synonyms) + for reference in self.cross_references { + cellosaurus_write_field( + output, + "DR", + reference.database + "; " + reference.accession, + ) + } + cellosaurus_write_fields(output, "RX", self.reference_identifiers) + cellosaurus_write_fields(output, "WW", self.web_pages) + cellosaurus_write_fields(output, "CC", self.comments) + cellosaurus_write_fields(output, "ST", self.str_profiles) + cellosaurus_write_fields(output, "DI", self.diseases) + cellosaurus_write_fields(output, "OX", self.species) + cellosaurus_write_fields(output, "HI", self.hierarchy) + cellosaurus_write_fields(output, "OI", self.same_individual) + cellosaurus_write_field(output, "SX", self.sex) + cellosaurus_write_field(output, "AG", self.age) + cellosaurus_write_field(output, "CA", self.category) + cellosaurus_write_field(output, "DT", self.date) + output.write_string("//\n") + output.to_string() +} + +///| +/// Parse all Cellosaurus records from flat-file text. +/// +/// Header lines before the first ID record are ignored. A started record must +/// end with `//`; malformed DR lines and unterminated records raise +/// `CellosaurusError`. +pub fn cellosaurus_parse( + text : String, +) -> Array[CellosaurusRecord] raise CellosaurusError { + let records : Array[CellosaurusRecord] = [] + let mut current : CellosaurusBuilder? = None + let lines = text.split("\n").to_array() + for line_index, line_view in lines { + let mut line = line_view.to_owned() + if line.length() > 0 && + line.unsafe_get(line.length() - 1) == '\r'.to_int().to_uint16() { + line = line[0:line.length() - 1].to_owned() + } + if line.length() < 2 { + continue + } + let code = line[0:2].to_owned() + let value = if line.length() > 5 { line[5:].trim().to_owned() } else { "" } + if code == "ID" { + match current { + Some(_) => + raise CellosaurusError( + "Cellosaurus record before line " + + (line_index + 1).to_string() + + " is missing its // terminator", + ) + None => () + } + let builder = CellosaurusBuilder::new() + builder.identifier = value + current = Some(builder) + } else if code == "//" { + match current { + Some(builder) => { + records.push(builder.finish()) + current = None + } + None => () + } + } else { + match current { + Some(builder) => + cellosaurus_apply_field( + builder, + code, + value, + line_number=line_index + 1, + ) + None => () + } + } + } + match current { + Some(_) => + raise CellosaurusError( + "Unexpected end of Cellosaurus input: record is missing its // terminator", + ) + None => () + } + records +} + +///| +/// Read zero or one Cellosaurus record. +/// +/// Returns `None` for empty input and raises `CellosaurusError` if more than +/// one record is present. +pub fn cellosaurus_read( + text : String, +) -> CellosaurusRecord? raise CellosaurusError { + let records = cellosaurus_parse(text) + if records.length() == 0 { + None + } else if records.length() == 1 { + Some(records[0]) + } else { + raise CellosaurusError("More than one cell line record found") + } +} + +///| +/// Return a small valid Cellosaurus record for examples. +pub fn cellosaurus_sample_text() -> String { + "ID #15310-LN\n" + + "AC CVCL_E548\n" + + "SY 15310-LN; TER461; TER-461; Extract 519\n" + + "DR dbMHC; 48439\n" + + "DR ECACC; 94050311\n" + + "DR Wikidata; Q54398957\n" + + "WW http://pathology.ucla.edu/workfiles/360cx.pdf\n" + + "CC Population: Caucasian; French Canadian.\n" + + "CC Cell type: B-cell; CL=CL_0000236.\n" + + "OX NCBI_TaxID=9606; ! Homo sapiens (Human)\n" + + "SX Female\n" + + "AG Age unspecified\n" + + "CA Transformed cell line\n" + + "DT Created: 22-10-12; Last updated: 30-01-24; Version: 18\n" + + "//\n" +} + +///| +struct CellosaurusBuilder { + mut identifier : String + mut accession : String + mut secondary_accessions : String + mut synonyms : String + cross_references : Array[CellosaurusCrossReference] + reference_identifiers : Array[String] + web_pages : Array[String] + comments : Array[String] + str_profiles : Array[String] + diseases : Array[String] + species : Array[String] + hierarchy : Array[String] + same_individual : Array[String] + mut sex : String + mut age : String + mut category : String + mut date : String +} + +///| +fn CellosaurusBuilder::new() -> CellosaurusBuilder { + CellosaurusBuilder::{ + identifier: "", + accession: "", + secondary_accessions: "", + synonyms: "", + cross_references: [], + reference_identifiers: [], + web_pages: [], + comments: [], + str_profiles: [], + diseases: [], + species: [], + hierarchy: [], + same_individual: [], + sex: "", + age: "", + category: "", + date: "", + } +} + +///| +fn CellosaurusBuilder::finish(self : CellosaurusBuilder) -> CellosaurusRecord { + CellosaurusRecord::new( + identifier=self.identifier, + accession=self.accession, + secondary_accessions=self.secondary_accessions, + synonyms=self.synonyms, + cross_references=self.cross_references, + reference_identifiers=self.reference_identifiers, + web_pages=self.web_pages, + comments=self.comments, + str_profiles=self.str_profiles, + diseases=self.diseases, + species=self.species, + hierarchy=self.hierarchy, + same_individual=self.same_individual, + sex=self.sex, + age=self.age, + category=self.category, + date=self.date, + ) +} + +///| +fn cellosaurus_apply_field( + builder : CellosaurusBuilder, + code : String, + value : String, + line_number~ : Int, +) -> Unit raise CellosaurusError { + match code { + "AC" => builder.accession = builder.accession + value + "AS" => builder.secondary_accessions = builder.secondary_accessions + value + "SY" => builder.synonyms = builder.synonyms + value + "DR" => + match value.find(";") { + Some(separator) => { + let database = value[0:separator].trim().to_owned() + let accession = value[separator + 1:].trim().to_owned() + if database.length() == 0 || accession.length() == 0 { + raise CellosaurusError( + "Invalid DR field at line " + line_number.to_string(), + ) + } + builder.cross_references.push( + CellosaurusCrossReference::new(database~, accession~), + ) + } + None => + raise CellosaurusError( + "Invalid DR field at line " + + line_number.to_string() + + ": expected 'database; accession'", + ) + } + "RX" => builder.reference_identifiers.push(value) + "WW" => builder.web_pages.push(value) + "CC" => builder.comments.push(value) + "ST" => builder.str_profiles.push(value) + "DI" => builder.diseases.push(value) + "OX" => builder.species.push(value) + "HI" => builder.hierarchy.push(value) + "OI" => builder.same_individual.push(value) + "SX" => builder.sex = builder.sex + value + "AG" => builder.age = builder.age + value + "CA" => builder.category = builder.category + value + "DT" => builder.date = builder.date + value + _ => () + } +} + +///| +fn cellosaurus_split_semicolon_list(text : String) -> Array[String] { + let result : Array[String] = [] + for part in text.split(";") { + let value = part.trim().to_owned() + if value.length() > 0 { + result.push(value) + } + } + result +} + +///| +fn cellosaurus_write_field( + output : StringBuilder, + code : String, + value : String, +) -> Unit { + if value.length() > 0 { + output.write_string(code) + output.write_string(" ") + output.write_string(value) + output.write_string("\n") + } +} + +///| +fn cellosaurus_write_fields( + output : StringBuilder, + code : String, + values : Array[String], +) -> Unit { + for value in values { + cellosaurus_write_field(output, code, value) + } +} diff --git a/test/moonbit/cellosaurus_test.mbt b/test/moonbit/cellosaurus_test.mbt new file mode 100644 index 00000000..cae72a98 --- /dev/null +++ b/test/moonbit/cellosaurus_test.mbt @@ -0,0 +1,194 @@ +///| +/// Tests for Bio.ExPASy.cellosaurus-compatible parsing. + +///| +test "cellosaurus_parse_official_sample_fields" { + let records = @src.cellosaurus_parse(@src.cellosaurus_sample_text()) + assert_eq(records.length(), 1) + let record = records[0] + assert_eq(record.identifier, "#15310-LN") + assert_eq(record.accession, "CVCL_E548") + assert_eq(record.sex, "Female") + assert_eq(record.age, "Age unspecified") + assert_eq(record.category, "Transformed cell line") + assert_eq(record.comments.length(), 2) + assert_eq(record.species.length(), 1) +} + +///| +test "cellosaurus_parse_cross_references" { + let record = @src.cellosaurus_parse(@src.cellosaurus_sample_text())[0] + assert_eq(record.cross_references.length(), 3) + assert_eq(record.cross_references[0].database, "dbMHC") + assert_eq(record.cross_references[0].accession, "48439") + assert_eq(record.cross_references[2].database, "Wikidata") + assert_eq(record.cross_references[2].accession, "Q54398957") +} + +///| +test "cellosaurus_list_helpers" { + let record = @src.CellosaurusRecord::new( + identifier="XP3OS", + secondary_accessions="CVCL_F511; CVCL_TEST", + synonyms="Xeroderma Pigmentosum 3 OSaka; GM04314; GM4314", + ) + assert_eq(record.secondary_accession_list(), ["CVCL_F511", "CVCL_TEST"]) + assert_eq(record.synonym_list(), [ + "Xeroderma Pigmentosum 3 OSaka", "GM04314", "GM4314", + ]) +} + +///| +test "cellosaurus_cross_reference_filter" { + let text = "ID Example\n" + + "AC CVCL_0001\n" + + "DR JCRB; JCRB0303\n" + + "DR JCRB; KURB1002\n" + + "DR Wikidata; Q1\n" + + "//\n" + let record = @src.cellosaurus_parse(text)[0] + assert_eq(record.cross_references_for("JCRB"), ["JCRB0303", "KURB1002"]) + assert_eq(record.cross_references_for("ATCC"), []) +} + +///| +test "cellosaurus_species_and_repr" { + let record = @src.cellosaurus_parse(@src.cellosaurus_sample_text())[0] + assert_true(record.has_species("Homo sapiens")) + assert_false(record.has_species("Mus musculus")) + assert_eq(record.repr(), "CellosaurusRecord (#15310-LN, CVCL_E548)") +} + +///| +test "cellosaurus_parse_multiple_records" { + let text = "ID XP3OS\n" + + "AC CVCL_3245\n" + + "AS CVCL_F511\n" + + "RX PubMed=832273;\n" + + "ST Amelogenin: X\n" + + "DI ORDO; Orphanet_910; Xeroderma pigmentosum\n" + + "OX NCBI_TaxID=9606; ! Homo sapiens (Human)\n" + + "//\n" + + "ID 1-5c-4\n" + + "AC CVCL_2260\n" + + "HI CVCL_0030 ! HeLa\n" + + "OI CVCL_0002 ! Same donor\n" + + "CA Cancer cell line\n" + + "//\n" + let records = @src.cellosaurus_parse(text) + assert_eq(records.length(), 2) + assert_eq(records[0].secondary_accessions, "CVCL_F511") + assert_eq(records[0].reference_identifiers, ["PubMed=832273;"]) + assert_eq(records[0].str_profiles, ["Amelogenin: X"]) + assert_eq(records[0].diseases.length(), 1) + assert_eq(records[1].identifier, "1-5c-4") + assert_eq(records[1].hierarchy, ["CVCL_0030 ! HeLa"]) + assert_eq(records[1].same_individual, ["CVCL_0002 ! Same donor"]) +} + +///| +test "cellosaurus_read_single" { + match @src.cellosaurus_read(@src.cellosaurus_sample_text()) { + Some(record) => assert_eq(record.accession, "CVCL_E548") + None => fail("expected one Cellosaurus record") + } +} + +///| +test "cellosaurus_read_empty" { + assert_true(@src.cellosaurus_read("") is None) + assert_true(@src.cellosaurus_read("//\n") is None) +} + +///| +test "cellosaurus_read_multiple_error" { + let text = "ID First\nAC CVCL_0001\n//\n" + + "ID Second\nAC CVCL_0002\n//\n" + let raised = try { + ignore(@src.cellosaurus_read(text)) + false + } catch { + CellosaurusError(_) => true + } + assert_true(raised) +} + +///| +test "cellosaurus_unterminated_record_error" { + let raised = try { + ignore(@src.cellosaurus_parse("ID Incomplete\nAC CVCL_0001\n")) + false + } catch { + CellosaurusError(_) => true + } + assert_true(raised) +} + +///| +test "cellosaurus_new_id_before_terminator_error" { + let text = "ID First\nAC CVCL_0001\nID Second\nAC CVCL_0002\n//\n" + let raised = try { + ignore(@src.cellosaurus_parse(text)) + false + } catch { + CellosaurusError(_) => true + } + assert_true(raised) +} + +///| +test "cellosaurus_invalid_cross_reference_error" { + let raised = try { + ignore(@src.cellosaurus_parse("ID Bad\nDR missing delimiter\n//\n")) + false + } catch { + CellosaurusError(_) => true + } + assert_true(raised) +} + +///| +test "cellosaurus_header_unknown_and_crlf" { + let text = "Cellosaurus release header\r\n" + + "__________\r\n" + + "//\r\n" + + "ID CRLF example\r\n" + + "AC CVCL_TEST\r\n" + + "ZZ ignored extension\r\n" + + "OX NCBI_TaxID=10090; ! Mus musculus (Mouse)\r\n" + + "//\r\n" + let records = @src.cellosaurus_parse(text) + assert_eq(records.length(), 1) + assert_eq(records[0].identifier, "CRLF example") + assert_eq(records[0].accession, "CVCL_TEST") + assert_true(records[0].has_species("Mus musculus")) +} + +///| +test "cellosaurus_repeated_single_value_fields_concatenate" { + let text = "ID Split\n" + + "AC CVCL_\n" + + "AC 1234\n" + + "SY First; \n" + + "SY Second\n" + + "//\n" + let record = @src.cellosaurus_parse(text)[0] + assert_eq(record.accession, "CVCL_1234") + assert_eq(record.synonyms, "First;Second") +} + +///| +test "cellosaurus_serialization_round_trip" { + let original = @src.cellosaurus_parse(@src.cellosaurus_sample_text())[0] + let serialized = original.to_string() + let reparsed = @src.cellosaurus_parse(serialized) + assert_eq(reparsed.length(), 1) + assert_true(reparsed[0] == original) +} + +///| +test "cellosaurus_empty_constructor_repr" { + let record = @src.CellosaurusRecord::new(identifier="") + assert_eq(record.repr(), "CellosaurusRecord ( )") + assert_eq(record.to_string(), "//\n") +} From 785960603645ec80203e9d54301368b009095bec Mon Sep 17 00:00:00 2001 From: eda Date: Tue, 4 Aug 2026 14:50:09 +0800 Subject: [PATCH 03/41] #28 /8238 feat(ranged_summarized_experiment): RangedSummarizedExperiment ~GRanges --- README.md | 20 +- .../main.mbt | 112 +++ .../moon.pkg | 6 + src/ranged_summarized_experiment.mbt | 669 ++++++++++++++++++ .../ranged_summarized_experiment_test.mbt | 334 +++++++++ 5 files changed, 1137 insertions(+), 4 deletions(-) create mode 100644 examples/ranged_summarized_experiment_demo/main.mbt create mode 100644 examples/ranged_summarized_experiment_demo/moon.pkg create mode 100644 src/ranged_summarized_experiment.mbt create mode 100644 test/moonbit/ranged_summarized_experiment_test.mbt diff --git a/README.md b/README.md index 736c2fdf..632e8023 100644 --- a/README.md +++ b/README.md @@ -195,6 +195,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **edgeR** | Bioconductor edgeR | 差异表达分析、DGEList、精确检验、GLM拟合 | ✅ | | **limma** | Bioconductor limma | 差异表达分析、线性模型拟合、经验贝叶斯、voom变换、RPKM/CPM/quantile归一化、ComBat/removeBatchEffect批次校正、treat严格检验 | ✅ | | **SummarizedExperiment** | Bioconductor SummarizedExperiment | 多维基因组数据容器、Assays、行/列操作 | ✅ | +| **RangedSummarizedExperiment** | Bioconductor SummarizedExperiment | 完整GRanges行范围、链特异重叠/最近邻、覆盖度、区间变换与协调子集 | ✅ | | **TreeSummarizedExperiment** | Bioconductor TreeSummarizedExperiment | 行/列树、节点链接、树节点子集、祖先/后代查询、层级聚合 | ✅ | | **IRanges** | Bioconductor IRanges | 整数区间操作、集合运算、重叠检测、findOverlaps高级类型、nearest、coverage、距离矩阵计算 | ✅ | | **TxDb** | Bioconductor GenomicFeatures | 转录本数据库、GTF解析、基因/转录本/外显子/CDS提取、UTR/内含子计算、启动子提取 | ✅ | @@ -446,6 +447,7 @@ IvanAXu/BioSeqs/ │ ├── matrix.mbt # Bioconductor Matrix 稀疏矩阵操作 (CSC/CSR格式、矩阵运算) │ ├── bioc_neighbors.mbt # BiocNeighbors 最近邻搜索 (KMKNN/Annoy) │ ├── summarized_experiment.mbt # SummarizedExperiment 多维基因组数据容器 +│ ├── ranged_summarized_experiment.mbt # RangedSummarizedExperiment 完整GRanges行范围与协调操作 │ ├── tree_summarized_experiment.mbt # TreeSummarizedExperiment 树结构实验容器、节点子集与层级聚合 │ ├── dplyr.mbt # dplyr 数据操作 (DataFrame、filter、select、mutate、arrange、group_by、summarize、join) │ ├── plyranges.mbt # plyranges tidy基因组数据操作 (GRanges的filter/mutate/select/arrange/rename/summarise/join) @@ -829,6 +831,7 @@ IvanAXu/BioSeqs/ │ ├── substitution_matrices_demo/ # 现代替换矩阵示例 (矩阵注册表、频率矩阵计算、log-odds打分、Shannon熵、KL散度、NCBI解析) │ ├── suffix_array_tree_demo/ # Suffix Array & Suffix Tree 示例 │ ├── summarized_experiment_demo/ # SummarizedExperiment 数据容器示例 +│ ├── ranged_summarized_experiment_demo/ # RangedSummarizedExperiment 重叠、最近邻、区间变换与排序示例 │ ├── tree_summarized_experiment_demo/ # TreeSummarizedExperiment 行/列树链接、节点子集与聚合示例 │ ├── sva_demo/ # sva 替代变量分析与ComBat批次校正示例 (经验贝叶斯方法、PCA分析) │ ├── svd_superimposer_demo/ # SVDSuperimposer SVD蛋白质结构叠合示例 (旋转矩阵、平移向量、RMSD计算) @@ -1113,6 +1116,7 @@ IvanAXu/BioSeqs/ │ │ ├── suffix_array_tree_test.mbt │ │ ├── suffix_array_tree_wbtest.mbt │ │ ├── summarized_experiment_test.mbt +│ │ ├── ranged_summarized_experiment_test.mbt │ │ ├── tree_summarized_experiment_test.mbt │ │ ├── svd_superimposer_test.mbt │ │ ├── tree_io_test.mbt @@ -1408,7 +1412,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8222 个测试全部通过 +moon test # ✅ 8238 个测试全部通过 ``` ### 模块对照表 @@ -1505,6 +1509,7 @@ moon test # ✅ 8222 个测试全 | `edger_advanced.mbt` | edgeR QLF/Camera/Roast | 准似然F检验、QL分散度估计、camera竞争性基因集检验、roast自足基因集检验 | | `limma.mbt` | Bioconductor limma | 线性模型与 voom 变换 | | `summarized_experiment.mbt` | Bioconductor SummarizedExperiment | 多维数据容器 | +| `ranged_summarized_experiment.mbt` | Bioconductor RangedSummarizedExperiment | 完整GRanges行范围、链特异重叠/最近邻、覆盖度、区间变换与协调子集 | | `tree_summarized_experiment.mbt` | Bioconductor TreeSummarizedExperiment | 行/列树与数据链接、按节点子集、层级聚合 | | `ballgown.mbt` | Bioconductor ballgown | 转录组水平差异表达 | | `ruvseq.mbt` | Bioconductor RUVSeq | RNA-seq 批次效应去除 | @@ -2717,6 +2722,10 @@ moon test # ✅ 8222 个测试全 实现与 Biopython `Bio.ExPASy.cellosaurus` 对应的 Cellosaurus 平面文本解析。`cellosaurus_parse` 支持批量记录，`cellosaurus_read` 支持零或一条记录；解析器识别 `ID`、`AC`、`AS`、`SY`、`DR`、`RX`、`WW`、`CC`、`ST`、`DI`、`OX`、`HI`、`OI`、`SX`、`AG`、`CA` 和 `DT` 字段，兼容数据库头部、未知扩展字段与 CRLF。`CellosaurusRecord` 提供类型化记录，`CellosaurusCrossReference` 将 `DR` 字段拆分为数据库和登录号；辅助方法支持次级登录号/同义名拆分、按数据库筛选交叉引用和物种文本查询。`to_string` 可生成规范平面文本并支持解析-序列化往返。缺失 `//` 终止符、记录嵌套、非法 `DR` 或单记录读取到多条记录时抛出 `CellosaurusError`。 +### 238. RangedSummarizedExperiment 基因组区间实验容器 (Bioconductor SummarizedExperiment) + +实现以完整 `GRanges` 表示 assay 行的 `RangedSummarizedExperiment`，并复用现有 `SummarizedExperiment` 管理 assays、`col_data` 和 metadata。构造器严格校验行范围、行注释、行名和所有 assay 的行列维度；`subset_rows`/`subset_cols` 支持选择、重排和重复索引，并同步更新所有并行数据。`find_overlaps`、`count_overlaps`、`overlaps_any` 和 `subset_by_overlaps` 提供链特异重叠查询，`Strand::Star` 作为通配链，也可通过 `ignore_strand` 忽略链方向；`nearest` 和 `distance_to_nearest` 使用真实区间间距，无可用候选时返回 `-1`。`coverage` 计算按染色体的逐碱基覆盖度，`shift`、`narrow`、`resize`、`flank` 和 `promoters` 仅变换行范围并保持 assay 与注释不变；`sort` 按染色体、起点、终点和链排序，同时协调重排整个实验对象。当前实现对应 Bioconductor 的 `GRanges` 行范围语义，不包含 `GRangesList`。 + ## 性能优化 @@ -2819,8 +2828,8 @@ moon test # ✅ 8222 个测试全 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8222 | -| 通过数 | 8222 | +| 总测试数 | 8238 | +| 通过数 | 8238 | | 失败数 | 0 | | 通过率 | 100% | @@ -2884,6 +2893,7 @@ moon test --update | edgeR | `edger_test.mbt` | 7 | | limma | `limma_test.mbt` | 10 | | SummarizedExperiment | `summarized_experiment_test.mbt` | 7 | +| RangedSummarizedExperiment | `ranged_summarized_experiment_test.mbt` | 16 | | TreeSummarizedExperiment | `tree_summarized_experiment_test.mbt` | 11 | | IRanges | `iranges_test.mbt` | 14 | | AlignIO | `align_io_test.mbt` | 12 | @@ -3206,7 +3216,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 337 个示例程序，展示各模块的典型用法： +项目提供 344 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3240,6 +3250,7 @@ moon run cmd/bench/main.mbt | edger_demo | edgeR 差异表达分析（DGEList创建、归一化因子、分散度估计、精确检验、GLM拟合） | `moon run examples/edger_demo/main.mbt` | | limma_demo | limma 差异表达分析（voom变换、线性模型拟合、经验贝叶斯、topTable、对比矩阵） | `moon run examples/limma_demo/main.mbt` | | summarized_experiment_demo | SummarizedExperiment 多维数据容器（Assays、行/列操作、合并） | `moon run examples/summarized_experiment_demo/main.mbt` | +| ranged_summarized_experiment_demo | RangedSummarizedExperiment 完整GRanges行范围、链特异重叠、最近邻、promoter变换与协调排序 | `moon run examples/ranged_summarized_experiment_demo/main.mbt` | | tree_summarized_experiment_demo | TreeSummarizedExperiment 行/列树链接、节点查询、树节点子集与层级聚合 | `moon run examples/tree_summarized_experiment_demo/main.mbt` | | iranges_demo | IRanges 整数区间操作（shift、resize、reduce、集合运算、重叠检测） | `moon run examples/iranges_demo/main.mbt` | | align_io_demo | 比对格式解析（ClustalW、FASTA、Stockholm格式解析与写入） | `moon run examples/align_io_demo/main.mbt` | @@ -3440,6 +3451,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 群体遗传学分析（等位基因频率、基因型频率、哈迪-温伯格检验、FST统计、Watterson's theta） - ✅ 实现 edgeR 差异表达分析（DGEList创建、归一化因子、分散度估计、精确检验、GLM拟合） - ✅ 实现 SummarizedExperiment 多维数据容器（Assays、行/列操作、合并） +- ✅ 实现 RangedSummarizedExperiment 基因组区间实验容器（完整GRanges行范围、链特异重叠/最近邻、覆盖度、区间变换与协调子集） - ✅ 实现 TreeSummarizedExperiment 树结构实验容器（行/列树链接、节点子集、层级聚合） - ✅ 实现 IRanges 整数区间操作（shift、resize、reduce、集合运算、重叠检测） - ✅ 实现 比对格式解析（ClustalW、FASTA、Stockholm格式解析与写入） diff --git a/examples/ranged_summarized_experiment_demo/main.mbt b/examples/ranged_summarized_experiment_demo/main.mbt new file mode 100644 index 00000000..9034770d --- /dev/null +++ b/examples/ranged_summarized_experiment_demo/main.mbt @@ -0,0 +1,112 @@ +///| +fn print_ranges(names : Array[String], ranges : @src.GRanges) -> Unit { + for index = 0; index < @src.granges_length(ranges); index = index + 1 { + println( + " \{names[index]}: \{ranges.seqnames[index]}:\{ranges.starts[index]}-\{ranges.ends[index]}", + ) + } +} + +///| +fn main { + println("=== RangedSummarizedExperiment Demo ===") + + let experiment = @src.RangedSummarizedExperiment::new( + assays=Map([ + ( + "counts", + [ + [30.0, 31.0, 32.0], + [10.0, 11.0, 12.0], + [20.0, 21.0, 22.0], + [40.0, 41.0, 42.0], + ], + ), + ( + "logcounts", + [ + [3.40, 3.43, 3.47], + [2.40, 2.48, 2.56], + [3.04, 3.09, 3.14], + [3.71, 3.74, 3.76], + ], + ), + ]), + row_ranges=@src.granges( + ["chr2", "chr1", "chr1", "chr3"], + [(300, 349), (100, 149), (200, 249), (50, 99)], + [ + @src.strand_plus(), + @src.strand_plus(), + @src.strand_minus(), + @src.strand_star(), + ], + ), + col_data=[ + Map([("sample", "S1"), ("condition", "control")]), + Map([("sample", "S2"), ("condition", "treated")]), + Map([("sample", "S3"), ("condition", "treated")]), + ], + row_data=[ + Map([("biotype", "protein_coding")]), + Map([("biotype", "lncRNA")]), + Map([("biotype", "protein_coding")]), + Map([("biotype", "protein_coding")]), + ], + row_names=["geneC", "geneA", "geneB", "geneD"], + metadata=Map([("study", "range-aware-expression")]), + ) catch { + _ => abort("failed to construct RangedSummarizedExperiment") + } + + println("\n1. Container and row ranges") + println(" " + experiment.summary()) + print_ranges(experiment.row_names(), experiment.row_ranges()) + + let regions = @src.granges(["chr1", "chr1"], [(120, 170), (220, 230)], [ + @src.strand_plus(), + @src.strand_minus(), + ]) + println("\n2. Strand-aware overlaps") + for hit in experiment.find_overlaps(regions) { + println(" \{experiment.row_names()[hit.0]} overlaps query \{hit.1}") + } + let overlapping = experiment.subset_by_overlaps(regions) catch { + _ => abort("failed to subset overlapping rows") + } + println(" Retained rows: " + overlapping.row_names().join(", ")) + + println("\n3. Nearest ranges and interval distances") + let nearest = experiment.nearest(regions) + let distances = experiment.distance_to_nearest(regions) + for index = 0; index < experiment.nrow(); index = index + 1 { + println( + " \{experiment.row_names()[index]}: subject=\{nearest[index]}, distance=\{distances[index]}", + ) + } + + println("\n4. Strand-aware promoter ranges") + let promoter_experiment = experiment.promoters(upstream=100, downstream=20) catch { + _ => abort("failed to create promoter ranges") + } + print_ranges( + promoter_experiment.row_names(), + promoter_experiment.row_ranges(), + ) + + println("\n5. Sort ranges and assays together") + let sorted = experiment.sort() catch { + _ => abort("failed to sort experiment") + } + println(" Row order: " + sorted.row_names().join(", ")) + match sorted.assay("counts") { + Some(counts) => + println( + " First-sample counts: " + + counts.map(fn(row) { row[0].to_string() }).join(", "), + ) + None => println(" counts assay is unavailable") + } + + println("\n=== Demo Complete ===") +} diff --git a/examples/ranged_summarized_experiment_demo/moon.pkg b/examples/ranged_summarized_experiment_demo/moon.pkg new file mode 100644 index 00000000..8824b1ac --- /dev/null +++ b/examples/ranged_summarized_experiment_demo/moon.pkg @@ -0,0 +1,6 @@ +import { + "IvanAXu/BioSeqs/src", + "moonbitlang/core/hashmap", +} + +pkgtype(kind: "executable") diff --git a/src/ranged_summarized_experiment.mbt b/src/ranged_summarized_experiment.mbt new file mode 100644 index 00000000..6a369d07 --- /dev/null +++ b/src/ranged_summarized_experiment.mbt @@ -0,0 +1,669 @@ +///| +/// RangedSummarizedExperiment - Genomic-range-aware assay container inspired +/// by Bioconductor SummarizedExperiment. + +///| +pub suberror RangedSummarizedExperimentError { + RangedSummarizedExperimentError(String) +} + +///| +/// A SummarizedExperiment whose rows are represented by genomic ranges. +/// +/// `row_data` and `row_names` are optional parallel annotations. Empty arrays +/// represent absent annotations; otherwise their length must equal `nrow`. +pub struct RangedSummarizedExperiment { + experiment : SummarizedExperiment + row_ranges : GRanges + row_data : Array[Map[String, String]] + row_names : Array[String] +} + +///| +/// Construct a range-aware experiment and validate all parallel dimensions. +pub fn RangedSummarizedExperiment::new( + assays~ : Map[String, Array[Array[Double]]], + row_ranges~ : GRanges, + col_data~ : Array[Map[String, String]], + row_data? : Array[Map[String, String]] = [], + row_names? : Array[String] = [], + metadata? : Map[String, String] = Map([]), +) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { + match + rse_validation_error( + assays, + row_ranges, + col_data, + row_data, + row_names, + ) { + Some(message) => raise RangedSummarizedExperimentError(message) + None => { + let experiment = summarized_experiment( + assays, + rse_ranges_as_tuples(row_ranges), + col_data, + metadata, + ) + RangedSummarizedExperiment::{ + experiment, + row_ranges, + row_data, + row_names, + } + } + } +} + +///| +/// Attach full genomic ranges to an existing SummarizedExperiment. +pub fn RangedSummarizedExperiment::from_experiment( + experiment~ : SummarizedExperiment, + row_ranges~ : GRanges, + row_data? : Array[Map[String, String]] = [], + row_names? : Array[String] = [], +) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { + RangedSummarizedExperiment::new( + assays=rse_copy_assays(experiment), + row_ranges~, + col_data=se_col_data(experiment), + row_data~, + row_names~, + metadata=se_metadata(experiment), + ) +} + +///| +/// Return the underlying SummarizedExperiment. +pub fn RangedSummarizedExperiment::experiment( + self : RangedSummarizedExperiment, +) -> SummarizedExperiment { + self.experiment +} + +///| +/// Return an assay by name. +pub fn RangedSummarizedExperiment::assay( + self : RangedSummarizedExperiment, + name : String, +) -> Array[Array[Double]]? { + se_assay(self.experiment, name) +} + +///| +/// Return all assay names. +pub fn RangedSummarizedExperiment::assay_names( + self : RangedSummarizedExperiment, +) -> Array[String] { + se_assay_names(self.experiment) +} + +///| +/// Return the genomic ranges associated with assay rows. +pub fn RangedSummarizedExperiment::row_ranges( + self : RangedSummarizedExperiment, +) -> GRanges { + self.row_ranges +} + +///| +/// Return optional per-row annotations. +pub fn RangedSummarizedExperiment::row_data( + self : RangedSummarizedExperiment, +) -> Array[Map[String, String]] { + self.row_data +} + +///| +/// Return optional row names. +pub fn RangedSummarizedExperiment::row_names( + self : RangedSummarizedExperiment, +) -> Array[String] { + self.row_names +} + +///| +/// Return per-column sample annotations. +pub fn RangedSummarizedExperiment::col_data( + self : RangedSummarizedExperiment, +) -> Array[Map[String, String]] { + se_col_data(self.experiment) +} + +///| +/// Return experiment-wide metadata. +pub fn RangedSummarizedExperiment::metadata( + self : RangedSummarizedExperiment, +) -> Map[String, String] { + se_metadata(self.experiment) +} + +///| +/// Return the number of genomic features. +pub fn RangedSummarizedExperiment::nrow( + self : RangedSummarizedExperiment, +) -> Int { + granges_length(self.row_ranges) +} + +///| +/// Return the number of samples. +pub fn RangedSummarizedExperiment::ncol( + self : RangedSummarizedExperiment, +) -> Int { + se_ncol(self.experiment) +} + +///| +/// Check ranges, annotations, and assay dimensions. +pub fn RangedSummarizedExperiment::is_valid( + self : RangedSummarizedExperiment, +) -> Bool { + rse_validation_error( + rse_copy_assays(self.experiment), + self.row_ranges, + se_col_data(self.experiment), + self.row_data, + self.row_names, + ) is None +} + +///| +/// Replace row ranges without changing assays or annotations. +pub fn RangedSummarizedExperiment::with_row_ranges( + self : RangedSummarizedExperiment, + row_ranges : GRanges, +) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { + RangedSummarizedExperiment::new( + assays=rse_copy_assays(self.experiment), + row_ranges~, + col_data=se_col_data(self.experiment), + row_data=self.row_data, + row_names=self.row_names, + metadata=se_metadata(self.experiment), + ) +} + +///| +/// Select, reorder, or duplicate rows while keeping all row data coordinated. +pub fn RangedSummarizedExperiment::subset_rows( + self : RangedSummarizedExperiment, + indices : Array[Int], +) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { + rse_validate_indices(indices, self.nrow(), "row") + RangedSummarizedExperiment::{ + experiment: se_subset_rows(self.experiment, indices), + row_ranges: rse_take_ranges(self.row_ranges, indices), + row_data: rse_take_maps(self.row_data, indices), + row_names: rse_take_strings(self.row_names, indices), + } +} + +///| +/// Select, reorder, or duplicate columns while keeping sample data coordinated. +pub fn RangedSummarizedExperiment::subset_cols( + self : RangedSummarizedExperiment, + indices : Array[Int], +) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { + rse_validate_indices(indices, self.ncol(), "column") + RangedSummarizedExperiment::{ + experiment: se_subset_cols(self.experiment, indices), + row_ranges: self.row_ranges, + row_data: self.row_data, + row_names: self.row_names, + } +} + +///| +/// Find all row-range overlaps with a subject GRanges. +/// +/// Returned pairs contain zero-based `(row_index, subject_index)` values. +pub fn RangedSummarizedExperiment::find_overlaps( + self : RangedSummarizedExperiment, + subject : GRanges, + ignore_strand? : Bool = false, +) -> Array[(Int, Int)] { + let hits : Array[(Int, Int)] = [] + for query_index = 0; query_index < self.nrow(); query_index = query_index + 1 { + for subject_index = 0 + subject_index < granges_length(subject) + subject_index = subject_index + 1 { + if rse_ranges_overlap( + self.row_ranges, + query_index, + subject, + subject_index, + ignore_strand, + ) { + hits.push((query_index, subject_index)) + } + } + } + hits +} + +///| +/// Count subject overlaps for each assay row. +pub fn RangedSummarizedExperiment::count_overlaps( + self : RangedSummarizedExperiment, + subject : GRanges, + ignore_strand? : Bool = false, +) -> Array[Int] { + let counts = Array::make(self.nrow(), 0) + for hit in self.find_overlaps(subject, ignore_strand~) { + counts[hit.0] = counts[hit.0] + 1 + } + counts +} + +///| +/// Return an overlap flag for each assay row. +pub fn RangedSummarizedExperiment::overlaps_any( + self : RangedSummarizedExperiment, + subject : GRanges, + ignore_strand? : Bool = false, +) -> Array[Bool] { + self.count_overlaps(subject, ignore_strand~).map(fn(count) { count > 0 }) +} + +///| +/// Keep rows that overlap at least one subject range. +pub fn RangedSummarizedExperiment::subset_by_overlaps( + self : RangedSummarizedExperiment, + subject : GRanges, + ignore_strand? : Bool = false, +) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { + let indices : Array[Int] = [] + let keep = self.overlaps_any(subject, ignore_strand~) + for index = 0; index < keep.length(); index = index + 1 { + if keep[index] { + indices.push(index) + } + } + self.subset_rows(indices) +} + +///| +/// Return the nearest subject index for each row, or `-1` when unavailable. +pub fn RangedSummarizedExperiment::nearest( + self : RangedSummarizedExperiment, + subject : GRanges, + ignore_strand? : Bool = false, +) -> Array[Int] { + let nearest_indices = Array::make(self.nrow(), -1) + for query_index = 0; query_index < self.nrow(); query_index = query_index + 1 { + let mut best_index = -1 + let mut best_distance = 0 + for subject_index = 0 + subject_index < granges_length(subject) + subject_index = subject_index + 1 { + if self.row_ranges.seqnames[query_index] == + subject.seqnames[subject_index] && + rse_strands_compatible( + self.row_ranges.strands[query_index], + subject.strands[subject_index], + ignore_strand, + ) { + let distance = rse_interval_distance( + self.row_ranges.starts[query_index], + self.row_ranges.ends[query_index], + subject.starts[subject_index], + subject.ends[subject_index], + ) + if best_index < 0 || distance < best_distance { + best_index = subject_index + best_distance = distance + } + } + } + nearest_indices[query_index] = best_index + } + nearest_indices +} + +///| +/// Return the nearest subject distance for each row, or `-1` when unavailable. +pub fn RangedSummarizedExperiment::distance_to_nearest( + self : RangedSummarizedExperiment, + subject : GRanges, + ignore_strand? : Bool = false, +) -> Array[Int] { + let distances = Array::make(self.nrow(), -1) + let nearest_indices = self.nearest(subject, ignore_strand~) + for query_index = 0; query_index < self.nrow(); query_index = query_index + 1 { + let subject_index = nearest_indices[query_index] + if subject_index >= 0 { + distances[query_index] = rse_interval_distance( + self.row_ranges.starts[query_index], + self.row_ranges.ends[query_index], + subject.starts[subject_index], + subject.ends[subject_index], + ) + } + } + distances +} + +///| +/// Compute per-base coverage for configured sequence lengths. +pub fn RangedSummarizedExperiment::coverage( + self : RangedSummarizedExperiment, + sequence_lengths : Map[String, Int], +) -> Map[String, Array[Int]] { + coverage_granges(self.row_ranges, sequence_lengths) +} + +///| +/// Shift every genomic row range by a fixed number of bases. +pub fn RangedSummarizedExperiment::shift( + self : RangedSummarizedExperiment, + amount : Int, +) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { + self.with_row_ranges(granges_shift(self.row_ranges, amount)) +} + +///| +/// Narrow every genomic row range using one-based relative coordinates. +pub fn RangedSummarizedExperiment::narrow( + self : RangedSummarizedExperiment, + start : Int, + end : Int, +) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { + self.with_row_ranges(granges_narrow(self.row_ranges, start, end)) +} + +///| +/// Resize every genomic row range while fixing its start, end, or center. +pub fn RangedSummarizedExperiment::resize( + self : RangedSummarizedExperiment, + width : Int, + fix : String, +) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { + self.with_row_ranges(granges_resize(self.row_ranges, width, fix)) +} + +///| +/// Create flanking ranges while preserving assays and annotations. +pub fn RangedSummarizedExperiment::flank( + self : RangedSummarizedExperiment, + width : Int, + start : Bool, + both : Bool, +) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { + self.with_row_ranges(granges_flank(self.row_ranges, width, start, both)) +} + +///| +/// Create strand-aware promoter ranges. +pub fn RangedSummarizedExperiment::promoters( + self : RangedSummarizedExperiment, + upstream? : Int = 2000, + downstream? : Int = 200, +) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { + if upstream < 0 || downstream < 0 { + raise RangedSummarizedExperimentError( + "promoter upstream and downstream widths must be non-negative", + ) + } + self.with_row_ranges( + granges_promoters(self.row_ranges, upstream, downstream), + ) +} + +///| +/// Sort rows by sequence name, start, end, and strand. +pub fn RangedSummarizedExperiment::sort( + self : RangedSummarizedExperiment, + decreasing? : Bool = false, +) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { + let indices : Array[Int] = [] + for index = 0; index < self.nrow(); index = index + 1 { + indices.push(index) + } + let mut swapped = true + while swapped { + swapped = false + for index = 0; index + 1 < indices.length(); index = index + 1 { + let comparison = rse_compare_ranges( + self.row_ranges, + indices[index], + indices[index + 1], + ) + if (!decreasing && comparison > 0) || (decreasing && comparison < 0) { + let temporary = indices[index] + indices[index] = indices[index + 1] + indices[index + 1] = temporary + swapped = true + } + } + } + self.subset_rows(indices) +} + +///| +/// Return a compact container summary. +pub fn RangedSummarizedExperiment::summary( + self : RangedSummarizedExperiment, +) -> String { + "RangedSummarizedExperiment(" + + self.nrow().to_string() + + " ranges x " + + self.ncol().to_string() + + " samples, assays=[" + + self.assay_names().join(", ") + + "])" +} + +///| +fn rse_validation_error( + assays : Map[String, Array[Array[Double]]], + row_ranges : GRanges, + col_data : Array[Map[String, String]], + row_data : Array[Map[String, String]], + row_names : Array[String], +) -> String? { + let nrow = row_ranges.seqnames.length() + if row_ranges.starts.length() != nrow || + row_ranges.ends.length() != nrow || + row_ranges.strands.length() != nrow || + row_ranges.widths.length() != nrow { + return Some("all GRanges fields must have the same length") + } + for index = 0; index < nrow; index = index + 1 { + let expected_width = row_ranges.ends[index] - row_ranges.starts[index] + 1 + if expected_width < 0 || row_ranges.widths[index] != expected_width { + return Some( + "invalid genomic range width at row " + index.to_string(), + ) + } + } + if row_data.length() != 0 && row_data.length() != nrow { + return Some("row_data length must equal the number of row ranges") + } + if row_names.length() != 0 && row_names.length() != nrow { + return Some("row_names length must equal the number of row ranges") + } + + let assay_names = assays.keys().collect() + for assay_name in assay_names { + let assay = assays[assay_name] + if assay.length() != nrow { + return Some( + "assay '" + assay_name + "' row count must equal rowRanges length", + ) + } + for row_index = 0; row_index < assay.length(); row_index = row_index + 1 { + if assay[row_index].length() != col_data.length() { + return Some( + "assay '" + + assay_name + + "' column count must equal col_data length", + ) + } + } + } + None +} + +///| +fn rse_ranges_as_tuples( + row_ranges : GRanges, +) -> Array[(String, Int, Int)] { + let result : Array[(String, Int, Int)] = [] + for index = 0; index < granges_length(row_ranges); index = index + 1 { + result.push(( + row_ranges.seqnames[index], + row_ranges.starts[index], + row_ranges.ends[index], + )) + } + result +} + +///| +fn rse_copy_assays( + experiment : SummarizedExperiment, +) -> Map[String, Array[Array[Double]]] { + let names = se_assay_names(experiment) + let assays : Map[String, Array[Array[Double]]] = Map([], capacity=names.length()) + for name in names { + match se_assay(experiment, name) { + Some(assay) => assays[name] = assay + None => () + } + } + assays +} + +///| +fn rse_validate_indices( + indices : Array[Int], + upper_bound : Int, + axis : String, +) -> Unit raise RangedSummarizedExperimentError { + for index in indices { + if index < 0 || index >= upper_bound { + raise RangedSummarizedExperimentError( + axis + " index out of bounds: " + index.to_string(), + ) + } + } +} + +///| +fn rse_take_ranges(row_ranges : GRanges, indices : Array[Int]) -> GRanges { + let seqnames : Array[String] = [] + let starts : Array[Int] = [] + let ends : Array[Int] = [] + let strands : Array[Strand] = [] + let widths : Array[Int] = [] + for index in indices { + seqnames.push(row_ranges.seqnames[index]) + starts.push(row_ranges.starts[index]) + ends.push(row_ranges.ends[index]) + strands.push(row_ranges.strands[index]) + widths.push(row_ranges.widths[index]) + } + GRanges::{ seqnames, starts, ends, strands, widths } +} + +///| +fn rse_take_maps( + values : Array[Map[String, String]], + indices : Array[Int], +) -> Array[Map[String, String]] { + if values.length() == 0 { + return [] + } + indices.map(fn(index) { values[index] }) +} + +///| +fn rse_take_strings( + values : Array[String], + indices : Array[Int], +) -> Array[String] { + if values.length() == 0 { + return [] + } + indices.map(fn(index) { values[index] }) +} + +///| +fn rse_strands_compatible( + query : Strand, + subject : Strand, + ignore_strand : Bool, +) -> Bool { + ignore_strand || + query == Strand::Star || + subject == Strand::Star || + query == subject +} + +///| +fn rse_ranges_overlap( + query : GRanges, + query_index : Int, + subject : GRanges, + subject_index : Int, + ignore_strand : Bool, +) -> Bool { + query.seqnames[query_index] == subject.seqnames[subject_index] && + rse_strands_compatible( + query.strands[query_index], + subject.strands[subject_index], + ignore_strand, + ) && + query.starts[query_index] <= subject.ends[subject_index] && + query.ends[query_index] >= subject.starts[subject_index] +} + +///| +fn rse_interval_distance( + first_start : Int, + first_end : Int, + second_start : Int, + second_end : Int, +) -> Int { + if first_end < second_start { + second_start - first_end - 1 + } else if second_end < first_start { + first_start - second_end - 1 + } else { + 0 + } +} + +///| +fn rse_compare_ranges(row_ranges : GRanges, left : Int, right : Int) -> Int { + if row_ranges.seqnames[left] < row_ranges.seqnames[right] { + return -1 + } + if row_ranges.seqnames[left] > row_ranges.seqnames[right] { + return 1 + } + if row_ranges.starts[left] < row_ranges.starts[right] { + return -1 + } + if row_ranges.starts[left] > row_ranges.starts[right] { + return 1 + } + if row_ranges.ends[left] < row_ranges.ends[right] { + return -1 + } + if row_ranges.ends[left] > row_ranges.ends[right] { + return 1 + } + rse_strand_rank(row_ranges.strands[left]) - + rse_strand_rank(row_ranges.strands[right]) +} + +///| +fn rse_strand_rank(strand : Strand) -> Int { + match strand { + Strand::Plus => 0 + Strand::Minus => 1 + Strand::Star => 2 + } +} diff --git a/test/moonbit/ranged_summarized_experiment_test.mbt b/test/moonbit/ranged_summarized_experiment_test.mbt new file mode 100644 index 00000000..634e79ae --- /dev/null +++ b/test/moonbit/ranged_summarized_experiment_test.mbt @@ -0,0 +1,334 @@ +///| +fn rse_test_object() -> @src.RangedSummarizedExperiment { + try { + @src.RangedSummarizedExperiment::new( + assays=Map([ + ( + "counts", + [ + [30.0, 31.0, 32.0], + [10.0, 11.0, 12.0], + [20.0, 21.0, 22.0], + [40.0, 41.0, 42.0], + ], + ), + ( + "normalized", + [ + [3.0, 3.1, 3.2], + [1.0, 1.1, 1.2], + [2.0, 2.1, 2.2], + [4.0, 4.1, 4.2], + ], + ), + ]), + row_ranges=@src.granges( + ["chr2", "chr1", "chr1", "chr3"], + [(300, 349), (100, 149), (200, 249), (50, 99)], + [ + @src.strand_plus(), + @src.strand_plus(), + @src.strand_minus(), + @src.strand_star(), + ], + ), + col_data=[ + Map([("sample", "S1")]), + Map([("sample", "S2")]), + Map([("sample", "S3")]), + ], + row_data=[ + Map([("type", "geneC")]), + Map([("type", "geneA")]), + Map([("type", "geneB")]), + Map([("type", "geneD")]), + ], + row_names=["geneC", "geneA", "geneB", "geneD"], + metadata=Map([("study", "airway-like")]), + ) + } catch { + _ => abort("failed to construct RangedSummarizedExperiment fixture") + } +} + +///| +test "ranged_summarized_experiment: construct and access" { + let rse = rse_test_object() + assert_true(rse.is_valid()) + assert_eq(rse.nrow(), 4) + assert_eq(rse.ncol(), 3) + assert_eq(rse.assay_names().length(), 2) + assert_eq(rse.row_ranges().seqnames[0], "chr2") + assert_eq(rse.row_data()[1]["type"], "geneA") + assert_eq(rse.row_names()[2], "geneB") + assert_eq(rse.col_data()[2]["sample"], "S3") + assert_eq(rse.metadata()["study"], "airway-like") + assert_eq( + rse.summary(), + "RangedSummarizedExperiment(4 ranges x 3 samples, assays=[counts, normalized])", + ) +} + +///| +test "ranged_summarized_experiment: rejects assay row mismatch" { + let raised = try { + ignore( + @src.RangedSummarizedExperiment::new( + assays=Map([("counts", [[1.0, 2.0], [3.0, 4.0]])]), + row_ranges=@src.granges_single( + "chr1", + 1, + 10, + @src.strand_plus(), + ), + col_data=[Map([]), Map([])], + ), + ) + false + } catch { + RangedSummarizedExperimentError(_) => true + } + assert_true(raised) +} + +///| +test "ranged_summarized_experiment: rejects parallel annotation mismatch" { + let raised = try { + ignore( + @src.RangedSummarizedExperiment::new( + assays=Map([("counts", [[1.0], [2.0]])]), + row_ranges=@src.granges( + ["chr1", "chr1"], + [(1, 10), (20, 30)], + [@src.strand_plus(), @src.strand_plus()], + ), + col_data=[Map([])], + row_data=[Map([("id", "only-one")])], + ), + ) + false + } catch { + RangedSummarizedExperimentError(_) => true + } + assert_true(raised) +} + +///| +test "ranged_summarized_experiment: attach ranges to existing experiment" { + let experiment = @src.summarized_experiment( + Map([("counts", [[1.0, 2.0], [3.0, 4.0]])]), + [("legacy", 0, 0), ("legacy", 0, 0)], + [Map([("sample", "A")]), Map([("sample", "B")])], + Map([("source", "existing")]), + ) + let rse = try { + @src.RangedSummarizedExperiment::from_experiment( + experiment~, + row_ranges=@src.granges( + ["chr1", "chr2"], + [(10, 20), (30, 40)], + [@src.strand_plus(), @src.strand_minus()], + ), + row_names=["a", "b"], + ) + } catch { + _ => abort("failed to attach ranges") + } + assert_true(rse.is_valid()) + assert_eq(rse.row_ranges().seqnames, ["chr1", "chr2"]) + assert_eq(rse.metadata()["source"], "existing") +} + +///| +test "ranged_summarized_experiment: subset rows stays coordinated" { + let subset = rse_test_object().subset_rows([2, 0, 2]) + assert_true(subset.is_valid()) + assert_eq(subset.row_names(), ["geneB", "geneC", "geneB"]) + assert_eq(subset.row_ranges().seqnames, ["chr1", "chr2", "chr1"]) + assert_eq(subset.row_data()[0]["type"], "geneB") + match subset.assay("counts") { + Some(assay) => + assert_eq(assay, [ + [20.0, 21.0, 22.0], + [30.0, 31.0, 32.0], + [20.0, 21.0, 22.0], + ]) + None => assert_true(false) + } +} + +///| +test "ranged_summarized_experiment: subset columns stays coordinated" { + let subset = rse_test_object().subset_cols([2, 0]) + assert_true(subset.is_valid()) + assert_eq(subset.ncol(), 2) + assert_eq(subset.col_data()[0]["sample"], "S3") + assert_eq(subset.col_data()[1]["sample"], "S1") + assert_eq(subset.row_names(), ["geneC", "geneA", "geneB", "geneD"]) + match subset.assay("counts") { + Some(assay) => { + assert_eq(assay[0], [32.0, 30.0]) + assert_eq(assay[2], [22.0, 20.0]) + } + None => assert_true(false) + } +} + +///| +test "ranged_summarized_experiment: invalid subset index raises" { + let raised = try { + ignore(rse_test_object().subset_rows([4])) + false + } catch { + RangedSummarizedExperimentError(_) => true + } + assert_true(raised) +} + +///| +test "ranged_summarized_experiment: strand-aware overlaps" { + let subject = @src.granges( + ["chr1", "chr1", "chr3", "chr2"], + [(120, 130), (220, 230), (80, 120), (340, 360)], + [ + @src.strand_plus(), + @src.strand_plus(), + @src.strand_minus(), + @src.strand_plus(), + ], + ) + let rse = rse_test_object() + assert_eq(rse.find_overlaps(subject), [(0, 3), (1, 0), (3, 2)]) + assert_eq(rse.count_overlaps(subject), [1, 1, 0, 1]) + assert_eq(rse.overlaps_any(subject), [true, true, false, true]) + assert_eq( + rse.find_overlaps(subject, ignore_strand=true), + [(0, 3), (1, 0), (2, 1), (3, 2)], + ) +} + +///| +test "ranged_summarized_experiment: subset by overlaps keeps each row once" { + let subject = @src.granges( + ["chr1", "chr1", "chr1"], + [(105, 110), (120, 125), (225, 230)], + [@src.strand_plus(), @src.strand_plus(), @src.strand_minus()], + ) + let subset = rse_test_object().subset_by_overlaps(subject) + assert_eq(subset.nrow(), 2) + assert_eq(subset.row_names(), ["geneA", "geneB"]) + match subset.assay("counts") { + Some(assay) => + assert_eq(assay, [[10.0, 11.0, 12.0], [20.0, 21.0, 22.0]]) + None => assert_true(false) + } +} + +///| +test "ranged_summarized_experiment: nearest and distance" { + let subject = @src.granges( + ["chr1", "chr1", "chr3"], + [(160, 170), (260, 270), (1, 10)], + [@src.strand_plus(), @src.strand_minus(), @src.strand_plus()], + ) + let rse = rse_test_object() + assert_eq(rse.nearest(subject), [-1, 0, 1, 2]) + assert_eq(rse.distance_to_nearest(subject), [-1, 10, 10, 39]) +} + +///| +test "ranged_summarized_experiment: coverage delegates to row ranges" { + let sequence_lengths = Map([ + ("chr1", 260), + ("chr2", 350), + ("chr3", 100), + ]) + let coverage = rse_test_object().coverage(sequence_lengths) + assert_eq(coverage["chr1"][99], 1) + assert_eq(coverage["chr1"][149], 0) + assert_eq(coverage["chr1"][199], 1) + assert_eq(coverage["chr2"][299], 1) + assert_eq(coverage["chr3"][98], 1) +} + +///| +test "ranged_summarized_experiment: intra-range transformations preserve data" { + let rse = rse_test_object() + let shifted = rse.shift(10) + assert_eq(shifted.row_ranges().starts, [310, 110, 210, 60]) + + let narrowed = rse.narrow(2, 10) + assert_eq(narrowed.row_ranges().widths, [9, 9, 9, 9]) + + let resized = rse.resize(5, "start") + assert_eq(resized.row_ranges().ends, [304, 104, 204, 54]) + + let flanked = rse.flank(10, true, false) + assert_eq(flanked.row_ranges().starts[1], 90) + assert_eq(flanked.row_ranges().ends[1], 99) + + match shifted.assay("counts") { + Some(assay) => assert_eq(assay[1], [10.0, 11.0, 12.0]) + None => assert_true(false) + } + assert_eq(shifted.row_names(), rse.row_names()) +} + +///| +test "ranged_summarized_experiment: promoters are strand-aware" { + let promoters = rse_test_object().promoters(upstream=50, downstream=20) + assert_eq(promoters.row_ranges().starts, [250, 50, 230, 0]) + assert_eq(promoters.row_ranges().ends, [319, 119, 299, 69]) + assert_eq(promoters.row_ranges().widths, [70, 70, 70, 70]) + assert_true(promoters.is_valid()) +} + +///| +test "ranged_summarized_experiment: sort reorders all row components" { + let sorted = rse_test_object().sort() + assert_eq(sorted.row_ranges().seqnames, ["chr1", "chr1", "chr2", "chr3"]) + assert_eq(sorted.row_names(), ["geneA", "geneB", "geneC", "geneD"]) + assert_eq(sorted.row_data()[0]["type"], "geneA") + match sorted.assay("counts") { + Some(assay) => { + assert_eq(assay[0], [10.0, 11.0, 12.0]) + assert_eq(assay[2], [30.0, 31.0, 32.0]) + } + None => assert_true(false) + } + + let descending = rse_test_object().sort(decreasing=true) + assert_eq(descending.row_names(), ["geneD", "geneC", "geneB", "geneA"]) +} + +///| +test "ranged_summarized_experiment: replacing ranges validates length" { + let raised = try { + ignore( + rse_test_object().with_row_ranges( + @src.granges_single("chr1", 1, 10, @src.strand_plus()), + ), + ) + false + } catch { + RangedSummarizedExperimentError(_) => true + } + assert_true(raised) +} + +///| +test "ranged_summarized_experiment: empty container" { + let rse = try { + @src.RangedSummarizedExperiment::new( + assays=Map([]), + row_ranges=@src.granges([], [], []), + col_data=[], + ) + } catch { + _ => abort("failed to construct empty RangedSummarizedExperiment") + } + assert_true(rse.is_valid()) + assert_eq(rse.nrow(), 0) + assert_eq(rse.ncol(), 0) + assert_eq(rse.subset_by_overlaps(@src.granges([], [], [])).nrow(), 0) +} From 7c0a4884b1e4a6d63b66db672a76222ae31390b4 Mon Sep 17 00:00:00 2001 From: eda Date: Tue, 4 Aug 2026 15:12:37 +0800 Subject: [PATCH 04/41] #28 /8261 feat(unigene): NCBI UniGene --- README.md | 20 +- examples/unigene_demo/main.mbt | 68 +++ examples/unigene_demo/moon.pkg | 5 + src/unigene.mbt | 960 +++++++++++++++++++++++++++++++++ test/moonbit/unigene_test.mbt | 291 ++++++++++ 5 files changed, 1340 insertions(+), 4 deletions(-) create mode 100644 examples/unigene_demo/main.mbt create mode 100644 examples/unigene_demo/moon.pkg create mode 100644 src/unigene.mbt create mode 100644 test/moonbit/unigene_test.mbt diff --git a/README.md b/README.md index 632e8023..4173cf8b 100644 --- a/README.md +++ b/README.md @@ -201,6 +201,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **TxDb** | Bioconductor GenomicFeatures | 转录本数据库、GTF解析、基因/转录本/外显子/CDS提取、UTR/内含子计算、启动子提取 | ✅ | | **ExPASy** | Biopython `Bio.ExPASy` | 蛋白质分析工具接口、Swiss-Prot条目解析、酶数据库查询、蛋白质参数计算（分子量、等电点、GRAVY、不稳定指数） | ✅ | | **Cellosaurus** | Biopython `Bio.ExPASy.cellosaurus` | Cellosaurus平面文本解析、类型化细胞系记录、数据库交叉引用、物种查询、序列化往返 | ✅ | +| **UniGene** | Biopython `Bio.UniGene` | NCBI UniGene固定宽度记录解析、类型化序列/蛋白相似性/STS/转录本映射、严格SCOUNT校验、序列化往返 | ✅ | | **Prosite** | Biopython `Bio.Prosite` | 蛋白质模体数据库搜索、Prosite模式解析、模体匹配算法、模体得分计算 | ✅ | | **PAML** | Biopython `Bio.PAML` | 分子进化分析、dN/dS计算（Nei-Gojobori方法）、Jukes-Cantor校正、密码子使用分析 | ✅ | | **Graphics** | Biopython `Bio.Graphics` | 生物信息学可视化、序列Logo绘制、序列比对可视化、基因组特征绘图 | ✅ | @@ -471,6 +472,7 @@ IvanAXu/BioSeqs/ │ ├── protparam.mbt # ProtParam 蛋白质参数分析 (不稳定指数、等电点、信号肽预测、二级结构倾向) │ ├── prosite.mbt # Bio.Prosite 蛋白质模体数据库搜索 │ ├── cellosaurus.mbt # Bio.ExPASy.cellosaurus 细胞系数据库平面文件解析 +│ ├── unigene.mbt # Bio.UniGene NCBI UniGene固定宽度记录解析、查询与序列化 │ ├── affy.mbt # Affy Affymetrix芯片数据分析 (RMA标准化、背景校正、分位数归一化) │ ├── feature_extraction.mbt # 机器学习特征提取 │ ├── faidx.mbt # FASTA 快速索引访问 (pyfaidx) @@ -772,6 +774,7 @@ IvanAXu/BioSeqs/ │ ├── ensembldb_demo/ # ensembldb Ensembl注释数据库接口示例 │ ├── expasy_demo/ # ExPASy 蛋白质分析工具接口示例 │ ├── cellosaurus_demo/ # Cellosaurus 记录解析、查询与序列化示例 +│ ├── unigene_demo/ # UniGene cluster解析、子记录查询与序列化往返示例 │ ├── entrez_demo/ # Entrez NCBI数据库访问示例 (ESearch、EFetch、PubMed/Gene/Taxonomy解析) │ ├── faidx_demo/ # FASTA 索引示例 │ ├── fgsea_demo/ # fgsea 快速基因集富集分析示例 (置换检验、NES/ES计算、Leading Edge基因) @@ -1157,6 +1160,7 @@ IvanAXu/BioSeqs/ │ │ ├── bioc_parallel_test.mbt │ │ ├── bsseq_test.mbt │ │ ├── cellosaurus_test.mbt +│ │ ├── unigene_test.mbt │ │ ├── checksum_test.mbt │ │ ├── chipseeker_test.mbt │ │ ├── chromvar_test.mbt @@ -1412,7 +1416,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8238 个测试全部通过 +moon test # ✅ 8261 个测试全部通过 ``` ### 模块对照表 @@ -1554,6 +1558,7 @@ moon test # ✅ 8238 个测试全 | `entrez.mbt` | BioPython `Bio.Entrez` | NCBI 数据库访问 | | `swissprot.mbt` | BioPython `Bio.SwissProt` | UniProt 记录解析 | | `cellosaurus.mbt` | BioPython `Bio.ExPASy.cellosaurus` | Cellosaurus记录解析、交叉引用查询与平面文本序列化 | +| `unigene.mbt` | BioPython `Bio.UniGene` | NCBI UniGene固定宽度记录解析、类型化子记录查询、SCOUNT校验与序列化往返 | | `uniprot_io.mbt` | BioPython `Bio.SeqIO.UniprotIO` | UniProt XML 格式解析 | | `chem_utils.mbt` | BioPython `Bio.PDB.chem_utils` | 化学计算工具（键长、键角、二面角、分子式量） | | `jaspar.mbt` | BioPython `Bio.motifs.Jaspar` | JASPAR PFM 格式解析与模体分析 | @@ -2726,6 +2731,10 @@ moon test # ✅ 8238 个测试全 实现以完整 `GRanges` 表示 assay 行的 `RangedSummarizedExperiment`，并复用现有 `SummarizedExperiment` 管理 assays、`col_data` 和 metadata。构造器严格校验行范围、行注释、行名和所有 assay 的行列维度；`subset_rows`/`subset_cols` 支持选择、重排和重复索引，并同步更新所有并行数据。`find_overlaps`、`count_overlaps`、`overlaps_any` 和 `subset_by_overlaps` 提供链特异重叠查询，`Strand::Star` 作为通配链，也可通过 `ignore_strand` 忽略链方向；`nearest` 和 `distance_to_nearest` 使用真实区间间距，无可用候选时返回 `-1`。`coverage` 计算按染色体的逐碱基覆盖度，`shift`、`narrow`、`resize`、`flank` 和 `promoters` 仅变换行范围并保持 assay 与注释不变；`sort` 按染色体、起点、终点和链排序，同时协调重排整个实验对象。当前实现对应 Bioconductor 的 `GRanges` 行范围语义，不包含 `GRangesList`。 +### 239. UniGene 基因聚类记录解析 (Bio.UniGene) + +实现与 Biopython `Bio.UniGene` 对应的 NCBI UniGene 固定宽度平面文件解析。`unigene_parse` 支持多记录输入，`unigene_read` 强制读取单条记录；解析器覆盖 `ID`、`TITLE`、`GENE`、`CYTOBAND`、`EXPRESS`、`RESTR_EXPR`、`GNM_TERMINUS`、`GENE_ID`、`LOCUSLINK`、`HOMOL`、`CHROMOSOME`、`PROTSIM`、`TXMAP`、`SCOUNT`、`SEQUENCE` 和 `STS` 标签。`UniGeneRecord` 以类型化数组保存序列、蛋白相似性、STS 和转录本映射子记录，支持按序列类型、登录号、相似物种和 IMAGE clone 查询，并保留未知子字段用于兼容扩展格式。解析器支持 CRLF，严格检查固定 12 列标签、记录终止符、布尔值和非负 `SCOUNT`，且要求声明数量与实际 `SEQUENCE` 数量一致。`to_string` 生成规范固定宽度文本并支持解析-序列化往返；格式错误抛出 `UniGeneError`。 + ## 性能优化 @@ -2828,8 +2837,8 @@ moon test # ✅ 8238 个测试全 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8238 | -| 通过数 | 8238 | +| 总测试数 | 8261 | +| 通过数 | 8261 | | 失败数 | 0 | | 通过率 | 100% | @@ -2928,6 +2937,7 @@ moon test --update | BiocNeighbors | `bioc_neighbors_test.mbt` | 61 | | SwissProt | `swissprot_test.mbt` | 8 | | Cellosaurus | `cellosaurus_test.mbt` | 16 | +| UniGene | `unigene_test.mbt` | 23 | | mmCIF | `mmcif_test.mbt` | 2 | | Nexus | `nexus_test.mbt` | 2 | | EMBOSS | `emboss_test.mbt` | 15 | @@ -3216,7 +3226,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 344 个示例程序，展示各模块的典型用法： +项目提供 345 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3288,6 +3298,7 @@ moon run cmd/bench/main.mbt | neighbor_search_demo | NeighborSearch KD树近邻搜索（半径搜索、最近邻、原子对搜索） | `moon run examples/neighbor_search_demo/main.mbt` | | swissprot_demo | SwissProt 蛋白数据库解析（记录解析、特征提取、参考文献） | `moon run examples/swissprot_demo/main.mbt` | | cellosaurus_demo | Cellosaurus细胞系记录解析、物种/同义名/交叉引用查询和序列化往返 | `moon run examples/cellosaurus_demo/main.mbt` | +| unigene_demo | NCBI UniGene cluster解析、序列/蛋白相似性/STS/转录本映射查询和序列化往返 | `moon run examples/unigene_demo/main.mbt` | | uniprot_io_demo | UniProt XML格式解析（蛋白质条目解析、功能注释提取、序列转换） | `moon run examples/uniprot_io_demo/main.mbt` | | chem_utils_demo | 化学计算工具（键长、键角、二面角、分子式量、氢键长度） | `moon run examples/chem_utils_demo/main.mbt` | | jaspar_demo | JASPAR PFM格式解析（模体矩阵解析、共有序列、PWM转换、序列扫描） | `moon run examples/jaspar_demo/main.mbt` | @@ -3486,6 +3497,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 NeighborSearch KD树近邻搜索（半径搜索、最近邻、原子对搜索） - ✅ 实现 SwissProt 蛋白数据库解析（记录解析、特征提取、参考文献） - ✅ 实现 Cellosaurus 细胞系数据库解析（多记录读取、交叉引用/物种查询、平面文本序列化） +- ✅ 实现 UniGene 基因聚类记录解析（固定宽度多记录读取、类型化子记录查询、SCOUNT校验、平面文本序列化） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/unigene_demo/main.mbt b/examples/unigene_demo/main.mbt new file mode 100644 index 00000000..1971282c --- /dev/null +++ b/examples/unigene_demo/main.mbt @@ -0,0 +1,68 @@ +///| +fn main { + println("=== Bio.UniGene Demo ===") + + let record = @src.unigene_read(@src.unigene_sample_text()) catch { + _ => abort("failed to parse UniGene sample") + } + + println("\n1. Cluster") + println(" " + record.summary()) + println(" Species prefix: " + record.species) + println(" Cytoband: " + record.cytoband) + println(" Expression: " + record.expression.join(", ")) + println(" Restricted expression: " + record.restricted_expression.join(", ")) + + println("\n2. Protein similarities") + for similarity in record.protein_similarities { + println( + " " + + similarity.protein_id + + " (taxon " + + similarity.organism + + "): " + + similarity.percent + + "% over " + + similarity.alignment_length + + " aa", + ) + } + + println("\n3. Sequence entries") + println(" mRNA: " + record.sequences_of_type("mRNA").length().to_string()) + println(" EST: " + record.sequences_of_type("EST").length().to_string()) + for sequence in record.image_sequences() { + println( + " IMAGE clone " + + sequence.image_id + + ": " + + sequence.accession + + " (" + + sequence.read_end + + " end)", + ) + } + + println("\n4. Mapping information") + for transcript_map in record.transcript_maps { + println( + " Marker " + + transcript_map.marker + + " on panel " + + transcript_map.radiation_hybrid_panel, + ) + } + for site in record.sts { + println(" STS " + site.accession + ", UniSTS " + site.unists) + } + + println("\n5. Canonical serialization") + let serialized = record.to_string() + let reparsed = @src.unigene_read(serialized) catch { + _ => abort("failed to reparse serialized UniGene record") + } + println(" Serialized bytes: " + serialized.length().to_string()) + println(" Round trip preserved record: " + (record == reparsed).to_string()) + + println("\n=== Demo Complete ===") +} diff --git a/examples/unigene_demo/moon.pkg b/examples/unigene_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/unigene_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/unigene.mbt b/src/unigene.mbt new file mode 100644 index 00000000..bb708e74 --- /dev/null +++ b/src/unigene.mbt @@ -0,0 +1,960 @@ +///| +/// Parser and writer for NCBI UniGene flat files. +/// +/// The data model follows Biopython's `Bio.UniGene` module while retaining +/// unknown key-value fields found inside SEQUENCE, PROTSIM, STS, and TXMAP +/// lines. + +///| +/// Error raised for malformed or ambiguous UniGene input. +pub suberror UniGeneError { + UniGeneError(String) +} + +///| +/// A key-value field not covered by the standard UniGene schema. +pub struct UniGeneExtraField { + key : String + value : String +} derive(Eq) + +///| +pub fn UniGeneExtraField::new( + key~ : String, + value~ : String, +) -> UniGeneExtraField { + UniGeneExtraField::{ key, value } +} + +///| +/// One `SEQUENCE` line from a UniGene record. +pub struct UniGeneSequence { + accession : String + nucleotide_id : String + protein_id : String + clone_id : String + read_end : String + library_id : String + mgc : String + sequence_type : String + trace : String + is_image : Bool + image_id : String + extra_fields : Array[UniGeneExtraField] +} derive(Eq) + +///| +pub fn UniGeneSequence::new( + accession? : String = "", + nucleotide_id? : String = "", + protein_id? : String = "", + clone_id? : String = "", + read_end? : String = "", + library_id? : String = "", + mgc? : String = "", + sequence_type? : String = "", + trace? : String = "", + extra_fields? : Array[UniGeneExtraField] = [], +) -> UniGeneSequence { + let image_id = unigene_image_id(clone_id) + UniGeneSequence::{ + accession, + nucleotide_id, + protein_id, + clone_id, + read_end, + library_id, + mgc, + sequence_type, + trace, + is_image: image_id.length() > 0, + image_id, + extra_fields, + } +} + +///| +/// Return a field by its uppercase UniGene key. +pub fn UniGeneSequence::field(self : UniGeneSequence, key : String) -> String? { + match key { + "ACC" => unigene_nonempty(self.accession) + "NID" => unigene_nonempty(self.nucleotide_id) + "PID" => unigene_nonempty(self.protein_id) + "CLONE" => unigene_nonempty(self.clone_id) + "END" => unigene_nonempty(self.read_end) + "LID" => unigene_nonempty(self.library_id) + "MGC" => unigene_nonempty(self.mgc) + "SEQTYPE" => unigene_nonempty(self.sequence_type) + "TRACE" => unigene_nonempty(self.trace) + _ => unigene_extra_value(self.extra_fields, key) + } +} + +///| +/// Serialize this sequence entry without the fixed-width `SEQUENCE` tag. +pub fn UniGeneSequence::to_value(self : UniGeneSequence) -> String { + let fields : Array[String] = [] + unigene_push_field(fields, "ACC", self.accession) + unigene_push_field(fields, "NID", self.nucleotide_id) + unigene_push_field(fields, "PID", self.protein_id) + unigene_push_field(fields, "CLONE", self.clone_id) + unigene_push_field(fields, "END", self.read_end) + unigene_push_field(fields, "LID", self.library_id) + unigene_push_field(fields, "MGC", self.mgc) + unigene_push_field(fields, "SEQTYPE", self.sequence_type) + unigene_push_field(fields, "TRACE", self.trace) + for field in self.extra_fields { + unigene_push_field(fields, field.key, field.value) + } + fields.join("; ") +} + +///| +/// One `PROTSIM` protein-similarity line. +pub struct UniGeneProteinSimilarity { + organism : String + protein_gi : String + protein_id : String + percent : String + alignment_length : String + extra_fields : Array[UniGeneExtraField] +} derive(Eq) + +///| +pub fn UniGeneProteinSimilarity::new( + organism? : String = "", + protein_gi? : String = "", + protein_id? : String = "", + percent? : String = "", + alignment_length? : String = "", + extra_fields? : Array[UniGeneExtraField] = [], +) -> UniGeneProteinSimilarity { + UniGeneProteinSimilarity::{ + organism, + protein_gi, + protein_id, + percent, + alignment_length, + extra_fields, + } +} + +///| +/// Return a field by its uppercase UniGene key. +pub fn UniGeneProteinSimilarity::field( + self : UniGeneProteinSimilarity, + key : String, +) -> String? { + match key { + "ORG" => unigene_nonempty(self.organism) + "PROTGI" => unigene_nonempty(self.protein_gi) + "PROTID" => unigene_nonempty(self.protein_id) + "PCT" => unigene_nonempty(self.percent) + "ALN" => unigene_nonempty(self.alignment_length) + _ => unigene_extra_value(self.extra_fields, key) + } +} + +///| +pub fn UniGeneProteinSimilarity::to_value( + self : UniGeneProteinSimilarity, +) -> String { + let fields : Array[String] = [] + unigene_push_field(fields, "ORG", self.organism) + unigene_push_field(fields, "PROTGI", self.protein_gi) + unigene_push_field(fields, "PROTID", self.protein_id) + unigene_push_field(fields, "PCT", self.percent) + unigene_push_field(fields, "ALN", self.alignment_length) + for field in self.extra_fields { + unigene_push_field(fields, field.key, field.value) + } + fields.join("; ") +} + +///| +/// One `STS` sequence-tagged-site line. +pub struct UniGeneSTS { + accession : String + unists : String + extra_fields : Array[UniGeneExtraField] +} derive(Eq) + +///| +pub fn UniGeneSTS::new( + accession? : String = "", + unists? : String = "", + extra_fields? : Array[UniGeneExtraField] = [], +) -> UniGeneSTS { + UniGeneSTS::{ accession, unists, extra_fields } +} + +///| +pub fn UniGeneSTS::field(self : UniGeneSTS, key : String) -> String? { + match key { + "ACC" => unigene_nonempty(self.accession) + "UNISTS" => unigene_nonempty(self.unists) + _ => unigene_extra_value(self.extra_fields, key) + } +} + +///| +pub fn UniGeneSTS::to_value(self : UniGeneSTS) -> String { + let fields : Array[String] = [] + unigene_push_field(fields, "ACC", self.accession) + unigene_push_field(fields, "UNISTS", self.unists) + for field in self.extra_fields { + unigene_push_field(fields, field.key, field.value) + } + fields.join(" ") +} + +///| +/// One `TXMAP` transcript-map line. +pub struct UniGeneTranscriptMap { + marker : String + radiation_hybrid_panel : String + extra_fields : Array[UniGeneExtraField] +} derive(Eq) + +///| +pub fn UniGeneTranscriptMap::new( + marker? : String = "", + radiation_hybrid_panel? : String = "", + extra_fields? : Array[UniGeneExtraField] = [], +) -> UniGeneTranscriptMap { + UniGeneTranscriptMap::{ marker, radiation_hybrid_panel, extra_fields } +} + +///| +pub fn UniGeneTranscriptMap::field( + self : UniGeneTranscriptMap, + key : String, +) -> String? { + match key { + "MARKER" => unigene_nonempty(self.marker) + "RHPANEL" => unigene_nonempty(self.radiation_hybrid_panel) + _ => unigene_extra_value(self.extra_fields, key) + } +} + +///| +pub fn UniGeneTranscriptMap::to_value(self : UniGeneTranscriptMap) -> String { + let fields : Array[String] = [] + unigene_push_field(fields, "MARKER", self.marker) + unigene_push_field(fields, "RHPANEL", self.radiation_hybrid_panel) + for field in self.extra_fields { + unigene_push_field(fields, field.key, field.value) + } + fields.join("; ") +} + +///| +/// A complete UniGene cluster record. +pub struct UniGeneRecord { + identifier : String + species : String + title : String + symbol : String + cytoband : String + expression : Array[String] + restricted_expression : Array[String] + genomic_terminus : String + gene_id : String + locuslink : String + homology : Bool? + chromosome : String + protein_similarities : Array[UniGeneProteinSimilarity] + sequences : Array[UniGeneSequence] + sts : Array[UniGeneSTS] + transcript_maps : Array[UniGeneTranscriptMap] + declared_sequence_count : Int +} derive(Eq) + +///| +pub fn UniGeneRecord::new( + identifier~ : String, + species? : String = "", + title? : String = "", + symbol? : String = "", + cytoband? : String = "", + expression? : Array[String] = [], + restricted_expression? : Array[String] = [], + genomic_terminus? : String = "", + gene_id? : String = "", + locuslink? : String = "", + homology? : Bool? = None, + chromosome? : String = "", + protein_similarities? : Array[UniGeneProteinSimilarity] = [], + sequences? : Array[UniGeneSequence] = [], + sts? : Array[UniGeneSTS] = [], + transcript_maps? : Array[UniGeneTranscriptMap] = [], +) -> UniGeneRecord { + UniGeneRecord::{ + identifier, + species: if species.length() > 0 { + species + } else { + unigene_species(identifier) + }, + title, + symbol, + cytoband, + expression, + restricted_expression, + genomic_terminus, + gene_id, + locuslink, + homology, + chromosome, + protein_similarities, + sequences, + sts, + transcript_maps, + declared_sequence_count: sequences.length(), + } +} + +///| +/// Return all sequences with the requested `SEQTYPE`. +pub fn UniGeneRecord::sequences_of_type( + self : UniGeneRecord, + sequence_type : String, +) -> Array[UniGeneSequence] { + let result : Array[UniGeneSequence] = [] + for sequence in self.sequences { + if sequence.sequence_type == sequence_type { + result.push(sequence) + } + } + result +} + +///| +/// Return protein similarities for an NCBI taxonomy identifier. +pub fn UniGeneRecord::protein_similarities_for( + self : UniGeneRecord, + organism : String, +) -> Array[UniGeneProteinSimilarity] { + let result : Array[UniGeneProteinSimilarity] = [] + for similarity in self.protein_similarities { + if similarity.organism == organism { + result.push(similarity) + } + } + result +} + +///| +/// Return sequences whose CLONE value identifies an IMAGE clone. +pub fn UniGeneRecord::image_sequences( + self : UniGeneRecord, +) -> Array[UniGeneSequence] { + let result : Array[UniGeneSequence] = [] + for sequence in self.sequences { + if sequence.is_image { + result.push(sequence) + } + } + result +} + +///| +/// Find a sequence by GenBank/EMBL/DDBJ accession. +pub fn UniGeneRecord::find_sequence( + self : UniGeneRecord, + accession : String, +) -> UniGeneSequence? { + for sequence in self.sequences { + if sequence.accession == accession { + return Some(sequence) + } + } + None +} + +///| +/// Return a compact record description. +pub fn UniGeneRecord::summary(self : UniGeneRecord) -> String { + "UniGeneRecord(" + + self.identifier + + ", symbol=" + + self.symbol + + ", sequences=" + + self.sequences.length().to_string() + + ", protein_similarities=" + + self.protein_similarities.length().to_string() + + ")" +} + +///| +/// Serialize this record to canonical fixed-width UniGene text. +pub fn UniGeneRecord::to_string(self : UniGeneRecord) -> String { + let output = StringBuilder::new() + unigene_write_line(output, "ID", self.identifier) + unigene_write_line(output, "TITLE", self.title) + unigene_write_line(output, "GENE", self.symbol) + unigene_write_line(output, "CYTOBAND", self.cytoband) + unigene_write_line(output, "GENE_ID", self.gene_id) + unigene_write_line(output, "LOCUSLINK", self.locuslink) + match self.homology { + Some(value) => + unigene_write_line(output, "HOMOL", if value { "YES" } else { "NO" }) + None => () + } + if self.expression.length() > 0 { + unigene_write_line(output, "EXPRESS", self.expression.join("| ")) + } + if self.restricted_expression.length() > 0 { + unigene_write_line( + output, + "RESTR_EXPR", + self.restricted_expression.join("| "), + ) + } + unigene_write_line(output, "GNM_TERMINUS", self.genomic_terminus) + unigene_write_line(output, "CHROMOSOME", self.chromosome) + for similarity in self.protein_similarities { + unigene_write_line(output, "PROTSIM", similarity.to_value()) + } + for transcript_map in self.transcript_maps { + unigene_write_line(output, "TXMAP", transcript_map.to_value()) + } + unigene_write_line(output, "SCOUNT", self.sequences.length().to_string()) + for sequence in self.sequences { + unigene_write_line(output, "SEQUENCE", sequence.to_value()) + } + for site in self.sts { + unigene_write_line(output, "STS", site.to_value()) + } + output.write_string("//\n") + output.to_string() +} + +///| +/// Parse all records in UniGene flat-file text. +pub fn unigene_parse(text : String) -> Array[UniGeneRecord] raise UniGeneError { + let records : Array[UniGeneRecord] = [] + let mut current : UniGeneBuilder? = None + for line_index, line_view in text.split("\n") { + let mut line = line_view.to_owned() + if line.length() > 0 && + line.unsafe_get(line.length() - 1) == '\r'.to_int().to_uint16() { + line = line[0:line.length() - 1].to_owned() + } + if line.trim().length() == 0 { + continue + } + if line.trim().to_owned() == "//" { + match current { + Some(builder) => { + records.push(builder.finish()) + current = None + } + None => + raise UniGeneError( + "Unexpected UniGene terminator at line " + + (line_index + 1).to_string(), + ) + } + continue + } + let (tag, value) = unigene_split_line(line, line_number=line_index + 1) + if tag == "ID" { + match current { + Some(_) => + raise UniGeneError( + "UniGene record before line " + + (line_index + 1).to_string() + + " is missing its // terminator", + ) + None => () + } + if value.length() == 0 { + raise UniGeneError( + "Empty UniGene ID at line " + (line_index + 1).to_string(), + ) + } + let builder = UniGeneBuilder::new() + builder.identifier = value + current = Some(builder) + } else { + match current { + Some(builder) => + unigene_apply_field(builder, tag, value, line_number=line_index + 1) + None => + raise UniGeneError( + "UniGene field before ID at line " + (line_index + 1).to_string(), + ) + } + } + } + match current { + Some(_) => + raise UniGeneError( + "Unexpected end of UniGene input: record is missing its // terminator", + ) + None => () + } + records +} + +///| +/// Read exactly one UniGene record. +pub fn unigene_read(text : String) -> UniGeneRecord raise UniGeneError { + let records = unigene_parse(text) + if records.length() == 0 { + raise UniGeneError("No UniGene record found") + } else if records.length() > 1 { + raise UniGeneError("More than one UniGene record found") + } + records[0] +} + +///| +/// Return a compact valid UniGene record for examples and tests. +pub fn unigene_sample_text() -> String { + "ID Hs.12345\n" + + "TITLE Example kinase family member\n" + + "GENE EXK1\n" + + "CYTOBAND 7q31.2\n" + + "GENE_ID 12345\n" + + "LOCUSLINK 12345\n" + + "HOMOL YES\n" + + "EXPRESS brain| heart| adult\n" + + "RESTR_EXPR brain| adult\n" + + "GNM_TERMINUS T\n" + + "CHROMOSOME 7\n" + + "PROTSIM ORG=9606; PROTGI=123456; PROTID=NP_000001.1; PCT=99.50; ALN=401\n" + + "TXMAP MARKER=D7S1234; RHPANEL=GB4\n" + + "SCOUNT 3\n" + + "SEQUENCE ACC=NM_000001.2; NID=g123455; PID=g123456; SEQTYPE=mRNA\n" + + "SEQUENCE ACC=AA000001.1; NID=g223456; CLONE=IMAGE:123456; END=5'; LID=100; SEQTYPE=EST; TRACE=900001\n" + + "SEQUENCE ACC=AA000002.1; NID=g223457; CLONE=clone-2; END=3'; LID=100; MGC=600; SEQTYPE=EST\n" + + "STS ACC=G12345 UNISTS=76543\n" + + "//\n" +} + +///| +priv struct UniGeneBuilder { + mut identifier : String + mut title : String + mut symbol : String + mut cytoband : String + mut expression : Array[String] + mut restricted_expression : Array[String] + mut genomic_terminus : String + mut gene_id : String + mut locuslink : String + mut homology : Bool? + mut chromosome : String + protein_similarities : Array[UniGeneProteinSimilarity] + sequences : Array[UniGeneSequence] + sts : Array[UniGeneSTS] + transcript_maps : Array[UniGeneTranscriptMap] + mut declared_sequence_count : Int + mut has_sequence_count : Bool +} + +///| +fn UniGeneBuilder::new() -> UniGeneBuilder { + UniGeneBuilder::{ + identifier: "", + title: "", + symbol: "", + cytoband: "", + expression: [], + restricted_expression: [], + genomic_terminus: "", + gene_id: "", + locuslink: "", + homology: None, + chromosome: "", + protein_similarities: [], + sequences: [], + sts: [], + transcript_maps: [], + declared_sequence_count: 0, + has_sequence_count: false, + } +} + +///| +fn UniGeneBuilder::finish( + self : UniGeneBuilder, +) -> UniGeneRecord raise UniGeneError { + if !self.has_sequence_count { + raise UniGeneError( + "UniGene record " + self.identifier + " is missing its SCOUNT field", + ) + } + if self.declared_sequence_count != self.sequences.length() { + raise UniGeneError( + "UniGene record " + + self.identifier + + " declares " + + self.declared_sequence_count.to_string() + + " sequences but contains " + + self.sequences.length().to_string(), + ) + } + UniGeneRecord::{ + identifier: self.identifier, + species: unigene_species(self.identifier), + title: self.title, + symbol: self.symbol, + cytoband: self.cytoband, + expression: self.expression, + restricted_expression: self.restricted_expression, + genomic_terminus: self.genomic_terminus, + gene_id: self.gene_id, + locuslink: self.locuslink, + homology: self.homology, + chromosome: self.chromosome, + protein_similarities: self.protein_similarities, + sequences: self.sequences, + sts: self.sts, + transcript_maps: self.transcript_maps, + declared_sequence_count: self.declared_sequence_count, + } +} + +///| +fn unigene_apply_field( + builder : UniGeneBuilder, + tag : String, + value : String, + line_number~ : Int, +) -> Unit raise UniGeneError { + match tag { + "TITLE" => builder.title = value + "GENE" => builder.symbol = value + "CYTOBAND" => builder.cytoband = value + "EXPRESS" => builder.expression = unigene_split_list(value, "|") + "RESTR_EXPR" => + builder.restricted_expression = unigene_split_list(value, "|") + "GNM_TERMINUS" => builder.genomic_terminus = value + "GENE_ID" => builder.gene_id = value + "LOCUSLINK" => builder.locuslink = value + "HOMOL" => + if value == "YES" { + builder.homology = Some(true) + } else if value == "NO" { + builder.homology = Some(false) + } else { + raise UniGeneError( + "Invalid HOMOL value at line " + + line_number.to_string() + + ": expected YES or NO", + ) + } + "CHROMOSOME" => builder.chromosome = value + "PROTSIM" => + builder.protein_similarities.push( + unigene_parse_protein_similarity(value, line_number~), + ) + "TXMAP" => + builder.transcript_maps.push( + unigene_parse_transcript_map(value, line_number~), + ) + "SCOUNT" => { + if builder.has_sequence_count { + raise UniGeneError( + "Duplicate SCOUNT field at line " + line_number.to_string(), + ) + } + builder.declared_sequence_count = unigene_parse_nonnegative_int( + value, + context="SCOUNT at line " + line_number.to_string(), + ) + builder.has_sequence_count = true + } + "SEQUENCE" => + builder.sequences.push(unigene_parse_sequence(value, line_number~)) + "STS" => builder.sts.push(unigene_parse_sts(value, line_number~)) + _ => + raise UniGeneError( + "Unknown UniGene tag " + tag + " at line " + line_number.to_string(), + ) + } +} + +///| +fn unigene_parse_sequence( + value : String, + line_number~ : Int, +) -> UniGeneSequence raise UniGeneError { + let fields = unigene_parse_fields( + value, + separator=";", + context="SEQUENCE at line " + line_number.to_string(), + ) + let extras : Array[UniGeneExtraField] = [] + for field in fields { + if !unigene_is_known_sequence_key(field.key) { + extras.push(field) + } + } + UniGeneSequence::new( + accession=unigene_field_or_empty(fields, "ACC"), + nucleotide_id=unigene_field_or_empty(fields, "NID"), + protein_id=unigene_field_or_empty(fields, "PID"), + clone_id=unigene_field_or_empty(fields, "CLONE"), + read_end=unigene_field_or_empty(fields, "END"), + library_id=unigene_field_or_empty(fields, "LID"), + mgc=unigene_field_or_empty(fields, "MGC"), + sequence_type=unigene_field_or_empty(fields, "SEQTYPE"), + trace=unigene_field_or_empty(fields, "TRACE"), + extra_fields=extras, + ) +} + +///| +fn unigene_parse_protein_similarity( + value : String, + line_number~ : Int, +) -> UniGeneProteinSimilarity raise UniGeneError { + let fields = unigene_parse_fields( + value, + separator=";", + context="PROTSIM at line " + line_number.to_string(), + ) + let extras : Array[UniGeneExtraField] = [] + for field in fields { + if !unigene_is_known_protein_key(field.key) { + extras.push(field) + } + } + UniGeneProteinSimilarity::new( + organism=unigene_field_or_empty(fields, "ORG"), + protein_gi=unigene_field_or_empty(fields, "PROTGI"), + protein_id=unigene_field_or_empty(fields, "PROTID"), + percent=unigene_field_or_empty(fields, "PCT"), + alignment_length=unigene_field_or_empty(fields, "ALN"), + extra_fields=extras, + ) +} + +///| +fn unigene_parse_sts( + value : String, + line_number~ : Int, +) -> UniGeneSTS raise UniGeneError { + let fields = unigene_parse_fields( + value, + separator=" ", + context="STS at line " + line_number.to_string(), + ) + let extras : Array[UniGeneExtraField] = [] + for field in fields { + if field.key != "ACC" && field.key != "UNISTS" { + extras.push(field) + } + } + UniGeneSTS::new( + accession=unigene_field_or_empty(fields, "ACC"), + unists=unigene_field_or_empty(fields, "UNISTS"), + extra_fields=extras, + ) +} + +///| +fn unigene_parse_transcript_map( + value : String, + line_number~ : Int, +) -> UniGeneTranscriptMap raise UniGeneError { + let fields = unigene_parse_fields( + value, + separator=";", + context="TXMAP at line " + line_number.to_string(), + ) + let extras : Array[UniGeneExtraField] = [] + for field in fields { + if field.key != "MARKER" && field.key != "RHPANEL" { + extras.push(field) + } + } + UniGeneTranscriptMap::new( + marker=unigene_field_or_empty(fields, "MARKER"), + radiation_hybrid_panel=unigene_field_or_empty(fields, "RHPANEL"), + extra_fields=extras, + ) +} + +///| +fn unigene_split_line( + line : String, + line_number~ : Int, +) -> (String, String) raise UniGeneError { + if line.length() < 12 { + raise UniGeneError( + "Malformed fixed-width UniGene line at " + line_number.to_string(), + ) + } + let tag = line[0:12].trim().to_owned() + let value = line[12:].trim().to_owned() + if tag.length() == 0 { + raise UniGeneError("Missing UniGene tag at line " + line_number.to_string()) + } + (tag, value) +} + +///| +fn unigene_parse_fields( + value : String, + separator~ : String, + context~ : String, +) -> Array[UniGeneExtraField] raise UniGeneError { + let result : Array[UniGeneExtraField] = [] + for part_view in value.split(separator) { + let part = part_view.trim().to_owned() + if part.length() == 0 { + continue + } + match part.find("=") { + Some(position) => { + let key = part[0:position].trim().to_owned() + let field_value = part[position + 1:].trim().to_owned() + if key.length() == 0 || field_value.length() == 0 { + raise UniGeneError("Malformed key-value field in " + context) + } + result.push(UniGeneExtraField::new(key~, value=field_value)) + } + None => + raise UniGeneError( + "Malformed key-value field '" + part + "' in " + context, + ) + } + } + result +} + +///| +fn unigene_split_list(value : String, separator : String) -> Array[String] { + let result : Array[String] = [] + for part in value.split(separator) { + let item = part.trim().to_owned() + if item.length() > 0 { + result.push(item) + } + } + result +} + +///| +fn unigene_species(identifier : String) -> String { + match identifier.find(".") { + Some(position) => identifier[0:position].to_owned() + None => identifier + } +} + +///| +fn unigene_image_id(clone_id : String) -> String { + if clone_id.has_prefix("IMAGE:") && clone_id.length() > 6 { + clone_id[6:].trim().to_owned() + } else if clone_id.has_prefix("IMAGE ") && clone_id.length() > 6 { + clone_id[6:].trim().to_owned() + } else { + "" + } +} + +///| +fn unigene_field_or_empty( + fields : Array[UniGeneExtraField], + key : String, +) -> String { + match unigene_extra_value(fields, key) { + Some(value) => value + None => "" + } +} + +///| +fn unigene_extra_value( + fields : Array[UniGeneExtraField], + key : String, +) -> String? { + for field in fields { + if field.key == key { + return Some(field.value) + } + } + None +} + +///| +fn unigene_nonempty(value : String) -> String? { + if value.length() > 0 { + Some(value) + } else { + None + } +} + +///| +fn unigene_is_known_sequence_key(key : String) -> Bool { + key == "ACC" || + key == "NID" || + key == "PID" || + key == "CLONE" || + key == "END" || + key == "LID" || + key == "MGC" || + key == "SEQTYPE" || + key == "TRACE" +} + +///| +fn unigene_is_known_protein_key(key : String) -> Bool { + key == "ORG" || + key == "PROTGI" || + key == "PROTID" || + key == "PCT" || + key == "ALN" +} + +///| +fn unigene_parse_nonnegative_int( + value : String, + context~ : String, +) -> Int raise UniGeneError { + if value.length() == 0 { + raise UniGeneError("Missing integer value for " + context) + } + for index = 0; index < value.length(); index = index + 1 { + let character = value.unsafe_get(index).to_int() + if character < '0'.to_int() || character > '9'.to_int() { + raise UniGeneError("Invalid non-negative integer for " + context) + } + } + parse_int(value) +} + +///| +fn unigene_push_field( + fields : Array[String], + key : String, + value : String, +) -> Unit { + if value.length() > 0 { + fields.push(key + "=" + value) + } +} + +///| +fn unigene_write_line( + output : StringBuilder, + tag : String, + value : String, +) -> Unit { + if value.length() == 0 { + return + } + output.write_string(tag) + for index = tag.length(); index < 12; index = index + 1 { + output.write_char(' ') + } + output.write_string(value) + output.write_string("\n") +} diff --git a/test/moonbit/unigene_test.mbt b/test/moonbit/unigene_test.mbt new file mode 100644 index 00000000..67bfc0d1 --- /dev/null +++ b/test/moonbit/unigene_test.mbt @@ -0,0 +1,291 @@ +///| +/// Tests for the Biopython Bio.UniGene-compatible parser. + +///| +test "unigene parses core record fields" { + let record = @src.unigene_read(@src.unigene_sample_text()) + assert_eq(record.identifier, "Hs.12345") + assert_eq(record.species, "Hs") + assert_eq(record.title, "Example kinase family member") + assert_eq(record.symbol, "EXK1") + assert_eq(record.cytoband, "7q31.2") + assert_eq(record.gene_id, "12345") + assert_eq(record.locuslink, "12345") + assert_eq(record.chromosome, "7") + assert_eq(record.declared_sequence_count, 3) +} + +///| +test "unigene parses expression and homology fields" { + let record = @src.unigene_read(@src.unigene_sample_text()) + assert_eq(record.expression, ["brain", "heart", "adult"]) + assert_eq(record.restricted_expression, ["brain", "adult"]) + assert_eq(record.homology, Some(true)) + assert_eq(record.genomic_terminus, "T") +} + +///| +test "unigene parses protein similarity fields" { + let record = @src.unigene_read(@src.unigene_sample_text()) + assert_eq(record.protein_similarities.length(), 1) + let similarity = record.protein_similarities[0] + assert_eq(similarity.organism, "9606") + assert_eq(similarity.protein_gi, "123456") + assert_eq(similarity.protein_id, "NP_000001.1") + assert_eq(similarity.percent, "99.50") + assert_eq(similarity.alignment_length, "401") + assert_eq(similarity.field("PCT"), Some("99.50")) +} + +///| +test "unigene parses sequence entries and IMAGE clones" { + let record = @src.unigene_read(@src.unigene_sample_text()) + assert_eq(record.sequences.length(), 3) + let transcript = record.sequences[0] + assert_eq(transcript.accession, "NM_000001.2") + assert_eq(transcript.nucleotide_id, "g123455") + assert_eq(transcript.protein_id, "g123456") + assert_eq(transcript.sequence_type, "mRNA") + let image = record.sequences[1] + assert_true(image.is_image) + assert_eq(image.image_id, "123456") + assert_eq(image.read_end, "5'") + assert_eq(image.library_id, "100") + assert_eq(image.trace, "900001") +} + +///| +test "unigene parses STS and transcript map entries" { + let record = @src.unigene_read(@src.unigene_sample_text()) + assert_eq(record.sts.length(), 1) + assert_eq(record.sts[0].accession, "G12345") + assert_eq(record.sts[0].unists, "76543") + assert_eq(record.transcript_maps.length(), 1) + assert_eq(record.transcript_maps[0].marker, "D7S1234") + assert_eq(record.transcript_maps[0].radiation_hybrid_panel, "GB4") +} + +///| +test "unigene sequence type and accession queries" { + let record = @src.unigene_read(@src.unigene_sample_text()) + assert_eq(record.sequences_of_type("EST").length(), 2) + assert_eq(record.sequences_of_type("mRNA").length(), 1) + assert_eq(record.sequences_of_type("HTC").length(), 0) + match record.find_sequence("AA000002.1") { + Some(sequence) => assert_eq(sequence.mgc, "600") + None => abort("expected sequence accession") + } + assert_true(record.find_sequence("missing") is None) +} + +///| +test "unigene similarity and IMAGE queries" { + let record = @src.unigene_read(@src.unigene_sample_text()) + assert_eq(record.protein_similarities_for("9606").length(), 1) + assert_eq(record.protein_similarities_for("10090").length(), 0) + let image_sequences = record.image_sequences() + assert_eq(image_sequences.length(), 1) + assert_eq(image_sequences[0].accession, "AA000001.1") +} + +///| +test "unigene preserves unknown child fields" { + let text = "ID Mm.7\n" + + "PROTSIM ORG=10090; PROTID=NP_1; EVALUE=1e-30\n" + + "TXMAP MARKER=D1Mit1; METHOD=RH\n" + + "SCOUNT 1\n" + + "SEQUENCE ACC=NM_1; SEQTYPE=mRNA; STATUS=reviewed\n" + + "STS UNISTS=10 PANEL=RH\n" + + "//\n" + let record = @src.unigene_read(text) + assert_eq(record.protein_similarities[0].field("EVALUE"), Some("1e-30")) + assert_eq(record.transcript_maps[0].field("METHOD"), Some("RH")) + assert_eq(record.sequences[0].field("STATUS"), Some("reviewed")) + assert_eq(record.sts[0].field("PANEL"), Some("RH")) + let reparsed = @src.unigene_read(record.to_string()) + assert_eq(reparsed.protein_similarities[0].field("EVALUE"), Some("1e-30")) + assert_eq(reparsed.sequences[0].field("STATUS"), Some("reviewed")) +} + +///| +test "unigene parses multiple records" { + let second = "ID Mm.2\n" + + "TITLE Second cluster\n" + + "GENE Gene2\n" + + "HOMOL NO\n" + + "SCOUNT 0\n" + + "//\n" + let records = @src.unigene_parse(@src.unigene_sample_text() + second) + assert_eq(records.length(), 2) + assert_eq(records[0].identifier, "Hs.12345") + assert_eq(records[1].identifier, "Mm.2") + assert_eq(records[1].species, "Mm") + assert_eq(records[1].homology, Some(false)) +} + +///| +test "unigene read accepts exactly one record" { + let record = @src.unigene_read(@src.unigene_sample_text()) + assert_eq(record.identifier, "Hs.12345") + assert_true(record.summary().contains("sequences=3")) +} + +///| +test "unigene read rejects empty input" { + let raised = try { + ignore(@src.unigene_read("")) + false + } catch { + UniGeneError(_) => true + } + assert_true(raised) +} + +///| +test "unigene read rejects multiple records" { + let raised = try { + ignore( + @src.unigene_read(@src.unigene_sample_text() + @src.unigene_sample_text()), + ) + false + } catch { + UniGeneError(_) => true + } + assert_true(raised) +} + +///| +test "unigene validates declared sequence count" { + let text = "ID Hs.1\n" + + "SCOUNT 2\n" + + "SEQUENCE ACC=NM_1; SEQTYPE=mRNA\n" + + "//\n" + let raised = try { + ignore(@src.unigene_parse(text)) + false + } catch { + UniGeneError(_) => true + } + assert_true(raised) +} + +///| +test "unigene requires sequence count" { + let raised = try { + ignore(@src.unigene_parse("ID Hs.1\n//\n")) + false + } catch { + UniGeneError(_) => true + } + assert_true(raised) +} + +///| +test "unigene rejects invalid homology value" { + let text = "ID Hs.1\nHOMOL MAYBE\nSCOUNT 0\n//\n" + let raised = try { + ignore(@src.unigene_parse(text)) + false + } catch { + UniGeneError(_) => true + } + assert_true(raised) +} + +///| +test "unigene rejects unknown top-level tags" { + let text = "ID Hs.1\nUNKNOWN value\nSCOUNT 0\n//\n" + let raised = try { + ignore(@src.unigene_parse(text)) + false + } catch { + UniGeneError(_) => true + } + assert_true(raised) +} + +///| +test "unigene rejects malformed child fields" { + let text = "ID Hs.1\n" + + "SCOUNT 1\n" + + "SEQUENCE ACC=NM_1; INVALID\n" + + "//\n" + let raised = try { + ignore(@src.unigene_parse(text)) + false + } catch { + UniGeneError(_) => true + } + assert_true(raised) +} + +///| +test "unigene rejects unterminated records" { + let raised = try { + ignore(@src.unigene_parse("ID Hs.1\nSCOUNT 0\n")) + false + } catch { + UniGeneError(_) => true + } + assert_true(raised) +} + +///| +test "unigene rejects malformed fixed-width lines" { + let raised = try { + ignore(@src.unigene_parse("ID Hs.1\n")) + false + } catch { + UniGeneError(_) => true + } + assert_true(raised) +} + +///| +test "unigene supports CRLF input" { + let crlf = @src.unigene_sample_text().replace_all(old="\n", new="\r\n") + let record = @src.unigene_read(crlf) + assert_eq(record.identifier, "Hs.12345") + assert_eq(record.sequences.length(), 3) +} + +///| +test "unigene record serialization round trip" { + let original = @src.unigene_read(@src.unigene_sample_text()) + let serialized = original.to_string() + assert_true(serialized.contains("ID Hs.12345")) + assert_true(serialized.contains("SCOUNT 3")) + let reparsed = @src.unigene_read(serialized) + assert_true(reparsed == original) +} + +///| +test "unigene constructors serialize canonical records" { + let record = @src.UniGeneRecord::new( + identifier="Rn.9", + title="Constructed record", + symbol="Gene9", + homology=Some(false), + sequences=[ + @src.UniGeneSequence::new(accession="NM_9", sequence_type="mRNA"), + ], + sts=[@src.UniGeneSTS::new(unists="999")], + ) + let reparsed = @src.unigene_read(record.to_string()) + assert_eq(reparsed.species, "Rn") + assert_eq(reparsed.homology, Some(false)) + assert_eq(reparsed.sequences[0].accession, "NM_9") + assert_eq(reparsed.sts[0].unists, "999") +} + +///| +test "unigene rejects duplicate sequence counts" { + let text = "ID Hs.1\nSCOUNT 0\nSCOUNT 0\n//\n" + let raised = try { + ignore(@src.unigene_parse(text)) + false + } catch { + UniGeneError(_) => true + } + assert_true(raised) +} From 8af1dc95ee9008278953615d1eacaf3fd66e36a9 Mon Sep 17 00:00:00 2001 From: eda Date: Tue, 4 Aug 2026 15:58:01 +0800 Subject: [PATCH 05/41] #28 /8299 feat: GRangesList unlist/relist && u RangedSummarizedExperiment --- README.md | 36 +- examples/granges_list_demo/main.mbt | 110 +++ examples/granges_list_demo/moon.pkg | 6 + src/granges_list.mbt | 988 +++++++++++++++++++++++++++ src/ranged_summarized_experiment.mbt | 318 +++++++-- test/moonbit/granges_list_test.mbt | 681 ++++++++++++++++++ 6 files changed, 2080 insertions(+), 59 deletions(-) create mode 100644 examples/granges_list_demo/main.mbt create mode 100644 examples/granges_list_demo/moon.pkg create mode 100644 src/granges_list.mbt create mode 100644 test/moonbit/granges_list_test.mbt diff --git a/README.md b/README.md index 4173cf8b..5f67056f 100644 --- a/README.md +++ b/README.md @@ -37,7 +37,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **FASTA 索引** | pyfaidx | 快速随机访问、.fai 索引 | ✅ | | **机器学习特征** | scikit-learn | k-mer 频率、氨基酸组成、理化性质 | ✅ | | **Biostrings** | Bioconductor Biostrings | IUPAC 支持、RSCU、复杂度、Tm 计算、模式匹配(matchPattern/vmatchPattern)、错配和插入缺失检测、回文序列查找 | ✅ | -| **GenomicRanges** | Bioconductor GenomicRanges | GRanges、区间操作、集合运算、precede/follow、coverage计算、distance_to_nearest | ✅ | +| **GenomicRanges** | Bioconductor GenomicRanges | GRanges/GRangesList、复合特征、区间操作、集合运算、precede/follow、coverage计算、distance_to_nearest | ✅ | | **plyranges** | Bioconductor plyranges | dplyr-like tidy verbs for GRanges: filter/mutate/select/arrange/rename/group_by+summarise/join_by、metadata管理 | ✅ | | **pheatmap** | Bioconductor pheatmap | 增强型热图可视化：层次聚类(complete/average/ward)、距离矩阵(euclidean/manhattan/correlation)、行/列注释、颜色方案、聚类间隙 | ✅ | | **factoextra** | Bioconductor factoextra | PCA/因子分析工具：特征值计算、方差解释率、个体/变量坐标、cos2质量、贡献度评分、维度描述 | ✅ | @@ -195,7 +195,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **edgeR** | Bioconductor edgeR | 差异表达分析、DGEList、精确检验、GLM拟合 | ✅ | | **limma** | Bioconductor limma | 差异表达分析、线性模型拟合、经验贝叶斯、voom变换、RPKM/CPM/quantile归一化、ComBat/removeBatchEffect批次校正、treat严格检验 | ✅ | | **SummarizedExperiment** | Bioconductor SummarizedExperiment | 多维基因组数据容器、Assays、行/列操作 | ✅ | -| **RangedSummarizedExperiment** | Bioconductor SummarizedExperiment | 完整GRanges行范围、链特异重叠/最近邻、覆盖度、区间变换与协调子集 | ✅ | +| **RangedSummarizedExperiment** | Bioconductor SummarizedExperiment | GRanges/GRangesList行范围、复合特征精确重叠/最近邻、覆盖度、区间变换与协调子集 | ✅ | | **TreeSummarizedExperiment** | Bioconductor TreeSummarizedExperiment | 行/列树、节点链接、树节点子集、祖先/后代查询、层级聚合 | ✅ | | **IRanges** | Bioconductor IRanges | 整数区间操作、集合运算、重叠检测、findOverlaps高级类型、nearest、coverage、距离矩阵计算 | ✅ | | **TxDb** | Bioconductor GenomicFeatures | 转录本数据库、GTF解析、基因/转录本/外显子/CDS提取、UTR/内含子计算、启动子提取 | ✅ | @@ -339,6 +339,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **UCSC Chain文件/liftOver** | Bioconductor rtracklayer | Chain格式解析、基因组坐标liftOver转换、链段查找、染色体间坐标映射、位置/区间转换 | ✅ | | **Biostrings matchPDict** | Bioconductor Biostrings | 字典模式匹配(matchPDict/vmatchPattern)、多序列模式计数(vcountPattern)、错配容忍、最佳匹配查找 | ✅ | | **GenomicRanges gaps/reduce/disjoin** | Bioconductor GenomicRanges | gaps检测、reduce合并、disjoin拆分、setdiff/交集/并集集合运算、coverage计算、promoters提取、trim | ✅ | +| **GenomicRanges GRangesList** | Bioconductor GenomicRanges | 命名复合基因组特征、split/unlist/relist、逐组区间变换、并行集合运算、特征级重叠/最近邻/覆盖度 | ✅ | | **NGS质量修剪与接头去除** | Bioconductor ShortRead | 质量修剪(滑动窗口)、接头去除、poly-A修剪、长度/GC含量过滤、批量修剪、Fastq解析与序列化、统计计算 | ✅ | | **Mauve基因组比对** | Biopython `Bio.Align` | Mauve基因组比对格式、LCB检测、倒位/断点检测、覆盖率分析、BED导出、基因组重排率 | ✅ | | **Stockholm格式** | Biopython `Bio.Stockholm` | Stockholm/Pfam格式解析、二级结构注释、百分比一致性、保守性、FASTA/Stockholm互转 | ✅ | @@ -434,6 +435,7 @@ IvanAXu/BioSeqs/ │ ├── bioc_parallel.mbt # Bioconductor 并行计算框架 (任务分块、并行求和) │ ├── genomic_ranges.mbt # GenomicRanges 基因组区间操作 (GRanges、IRanges) │ ├── genomic_ranges_advanced.mbt # GenomicRanges tile/slidingWindows/区间运算 +│ ├── granges_list.mbt # GenomicRanges GRangesList 复合特征、重组、重叠与集合运算 │ ├── iranges.mbt # IRanges 整数区间操作 (集合运算、重叠检测) │ ├── genomic_alignments.mbt # GenomicAlignments 基因组比对分析 (GAlignments、coverage、summarizeOverlaps、pileup) │ ├── txdb.mbt # TxDb 转录本数据库 (GTF解析、基因/转录本/外显子/CDS提取、UTR/内含子计算) @@ -448,7 +450,7 @@ IvanAXu/BioSeqs/ │ ├── matrix.mbt # Bioconductor Matrix 稀疏矩阵操作 (CSC/CSR格式、矩阵运算) │ ├── bioc_neighbors.mbt # BiocNeighbors 最近邻搜索 (KMKNN/Annoy) │ ├── summarized_experiment.mbt # SummarizedExperiment 多维基因组数据容器 -│ ├── ranged_summarized_experiment.mbt # RangedSummarizedExperiment 完整GRanges行范围与协调操作 +│ ├── ranged_summarized_experiment.mbt # RangedSummarizedExperiment GRanges/GRangesList行范围与协调操作 │ ├── tree_summarized_experiment.mbt # TreeSummarizedExperiment 树结构实验容器、节点子集与层级聚合 │ ├── dplyr.mbt # dplyr 数据操作 (DataFrame、filter、select、mutate、arrange、group_by、summarize、join) │ ├── plyranges.mbt # plyranges tidy基因组数据操作 (GRanges的filter/mutate/select/arrange/rename/summarise/join) @@ -782,6 +784,7 @@ IvanAXu/BioSeqs/ │ ├── genomic_alignments_demo/ # GenomicAlignments 基因组比对分析示例 (GAlignments、coverage、summarizeOverlaps、pileup) │ ├── genomic_ranges_demo/ # GenomicRanges 基因组区间操作示例 │ ├── genomic_ranges_advanced_demo/ # GenomicRanges tile/slidingWindows/区间运算示例 +│ ├── granges_list_demo/ # GRangesList 复合转录本、精确重叠与分组实验容器示例 │ ├── geoquery_demo/ # GEOquery GEO数据库示例 (Series Matrix解析、SOFT格式解析、ExpressionSet转换、基因过滤) │ ├── go_enrichment_demo/ # GOEnrichment GO功能富集分析示例 (超几何检验、BH校正、富集结果过滤) │ ├── hmm_demo/ # Hidden Markov Model 基因预测示例 @@ -834,7 +837,7 @@ IvanAXu/BioSeqs/ │ ├── substitution_matrices_demo/ # 现代替换矩阵示例 (矩阵注册表、频率矩阵计算、log-odds打分、Shannon熵、KL散度、NCBI解析) │ ├── suffix_array_tree_demo/ # Suffix Array & Suffix Tree 示例 │ ├── summarized_experiment_demo/ # SummarizedExperiment 数据容器示例 -│ ├── ranged_summarized_experiment_demo/ # RangedSummarizedExperiment 重叠、最近邻、区间变换与排序示例 +│ ├── ranged_summarized_experiment_demo/ # RangedSummarizedExperiment GRanges重叠、最近邻、区间变换与排序示例 │ ├── tree_summarized_experiment_demo/ # TreeSummarizedExperiment 行/列树链接、节点子集与聚合示例 │ ├── sva_demo/ # sva 替代变量分析与ComBat批次校正示例 (经验贝叶斯方法、PCA分析) │ ├── svd_superimposer_demo/ # SVDSuperimposer SVD蛋白质结构叠合示例 (旋转矩阵、平移向量、RMSD计算) @@ -1088,6 +1091,7 @@ IvanAXu/BioSeqs/ │ │ ├── genomic_alignments_test.mbt │ │ ├── genomic_ranges_test.mbt │ │ ├── genomic_ranges_advanced_test.mbt +│ │ ├── granges_list_test.mbt │ │ ├── go_enrichment_test.mbt │ │ ├── hmm_test.mbt │ │ ├── hmm_wbtest.mbt @@ -1416,7 +1420,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8261 个测试全部通过 +moon test # ✅ 8299 个测试全部通过 ``` ### 模块对照表 @@ -1494,6 +1498,7 @@ moon test # ✅ 8261 个测试全 | `cram_wbtest.mbt` | pysam | CRAM 格式解析 | | `genomic_ranges.mbt` | Bioconductor GenomicRanges | GRanges 区间操作 | | `genomic_ranges_advanced.mbt` | GenomicRanges Tile/Windows | tile分箱、sliding_windows滑窗、tile_genome基因组覆盖、coverage_by_window覆盖度计算、bin_genome分箱统计、promoters启动子、gaps间隙、subtract区间减法 | +| `granges_list.mbt` | Bioconductor GenomicRanges | GRangesList复合特征、split/unlist/relist、逐组变换、集合运算、重叠/最近邻/覆盖度 | | `iranges.mbt` | Bioconductor IRanges | 整数区间操作 | | `genomic_alignments.mbt` | Bioconductor GenomicAlignments | GAlignments 比对分析 | | `variant_annotation.mbt` | Bioconductor VariantAnnotation | 变异注释 | @@ -1513,7 +1518,7 @@ moon test # ✅ 8261 个测试全 | `edger_advanced.mbt` | edgeR QLF/Camera/Roast | 准似然F检验、QL分散度估计、camera竞争性基因集检验、roast自足基因集检验 | | `limma.mbt` | Bioconductor limma | 线性模型与 voom 变换 | | `summarized_experiment.mbt` | Bioconductor SummarizedExperiment | 多维数据容器 | -| `ranged_summarized_experiment.mbt` | Bioconductor RangedSummarizedExperiment | 完整GRanges行范围、链特异重叠/最近邻、覆盖度、区间变换与协调子集 | +| `ranged_summarized_experiment.mbt` | Bioconductor RangedSummarizedExperiment | GRanges/GRangesList行范围、链特异重叠/最近邻、覆盖度、区间变换与协调子集 | | `tree_summarized_experiment.mbt` | Bioconductor TreeSummarizedExperiment | 行/列树与数据链接、按节点子集、层级聚合 | | `ballgown.mbt` | Bioconductor ballgown | 转录组水平差异表达 | | `ruvseq.mbt` | Bioconductor RUVSeq | RNA-seq 批次效应去除 | @@ -2729,13 +2734,17 @@ moon test # ✅ 8261 个测试全 ### 238. RangedSummarizedExperiment 基因组区间实验容器 (Bioconductor SummarizedExperiment) -实现以完整 `GRanges` 表示 assay 行的 `RangedSummarizedExperiment`，并复用现有 `SummarizedExperiment` 管理 assays、`col_data` 和 metadata。构造器严格校验行范围、行注释、行名和所有 assay 的行列维度；`subset_rows`/`subset_cols` 支持选择、重排和重复索引，并同步更新所有并行数据。`find_overlaps`、`count_overlaps`、`overlaps_any` 和 `subset_by_overlaps` 提供链特异重叠查询，`Strand::Star` 作为通配链，也可通过 `ignore_strand` 忽略链方向；`nearest` 和 `distance_to_nearest` 使用真实区间间距，无可用候选时返回 `-1`。`coverage` 计算按染色体的逐碱基覆盖度，`shift`、`narrow`、`resize`、`flank` 和 `promoters` 仅变换行范围并保持 assay 与注释不变；`sort` 按染色体、起点、终点和链排序，同时协调重排整个实验对象。当前实现对应 Bioconductor 的 `GRanges` 行范围语义，不包含 `GRangesList`。 +实现支持 `GRanges` 或 `GRangesList` assay 行范围的 `RangedSummarizedExperiment`，并复用现有 `SummarizedExperiment` 管理 assays、`col_data` 和 metadata。`new_with_range_groups` 和 `from_experiment_with_range_groups` 用复合范围表示转录本及其外显子等特征，外层元素与 assay 行严格平行；未显式提供 `row_data` 时会采用 `GRangesList.element_metadata`。容器内部使用每个复合特征的外接范围维持行维度，但 `find_overlaps`、`count_overlaps`、`overlaps_any`、`subset_by_overlaps`、`nearest`、`distance_to_nearest` 和 `coverage` 始终使用真实成员范围，因此不会将外显子之间的内含子误判为重叠。`subset_rows`/`subset_cols` 支持选择、重排和重复索引，并同步更新 assay、分组范围、行列注释与名称；`shift`、`narrow`、`resize`、`flank` 和 `promoters` 逐成员变换范围并保持实验数据不变。原有 `GRanges` 构造器与 API 保持兼容，`with_row_ranges` 可显式切回平面范围模式。 ### 239. UniGene 基因聚类记录解析 (Bio.UniGene) 实现与 Biopython `Bio.UniGene` 对应的 NCBI UniGene 固定宽度平面文件解析。`unigene_parse` 支持多记录输入，`unigene_read` 强制读取单条记录；解析器覆盖 `ID`、`TITLE`、`GENE`、`CYTOBAND`、`EXPRESS`、`RESTR_EXPR`、`GNM_TERMINUS`、`GENE_ID`、`LOCUSLINK`、`HOMOL`、`CHROMOSOME`、`PROTSIM`、`TXMAP`、`SCOUNT`、`SEQUENCE` 和 `STS` 标签。`UniGeneRecord` 以类型化数组保存序列、蛋白相似性、STS 和转录本映射子记录，支持按序列类型、登录号、相似物种和 IMAGE clone 查询，并保留未知子字段用于兼容扩展格式。解析器支持 CRLF，严格检查固定 12 列标签、记录终止符、布尔值和非负 `SCOUNT`，且要求声明数量与实际 `SEQUENCE` 数量一致。`to_string` 生成规范固定宽度文本并支持解析-序列化往返；格式错误抛出 `UniGeneError`。 +### 240. GRangesList 复合基因组特征 (Bioconductor GenomicRanges) + +实现 Bioconductor `GenomicRanges::GRangesList` 的复合特征语义，每个命名外层元素保存一组 `GRanges`，适合表示转录本-外显子、基因-调控区等一对多结构。构造器严格校验外层名称、元素元数据和内部范围维度；`granges_split_as_list` 按首次出现顺序分组，`granges_list_from_partition` 按元素长度分区，`unlist` 展平成单个 `GRanges`，`relist` 按原分区重建并保留名称和元数据。`subset`、`concat`、`parallel_concat` 支持外层选择和组合；`shift`、`narrow`、`resize`、`flank`、`promoters`、`reduce`、`disjoin` 和 `sort_ranges` 逐元素执行，`parallel_union`、`parallel_intersect` 和 `parallel_setdiff` 提供同位置元素间集合运算。`find_overlaps`、`count_overlaps`、`overlaps_any` 和分组对分组查询返回外层复合特征索引，并对同一特征的多个成员命中去重；`nearest`、`distance_to_nearest` 和 `coverage` 基于所有真实成员范围计算。`feature_bounds` 仅用于生成每个复合特征的协调外接范围，不替代精确区间计算。 + ## 性能优化 ### 优化策略 @@ -2837,8 +2846,8 @@ moon test # ✅ 8261 个测试全 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8261 | -| 通过数 | 8261 | +| 总测试数 | 8299 | +| 通过数 | 8299 | | 失败数 | 0 | | 通过率 | 100% | @@ -2878,6 +2887,7 @@ moon test --update | 特征提取 | `feature_extraction_test.mbt` | 19 | | Biostrings | `biostrings_test.mbt` | 21 | | GenomicRanges | `genomic_ranges_test.mbt` | 22 | +| GRangesList | `granges_list_test.mbt` | 38 | | plyranges | `plyranges_test.mbt` | 15 | | DESeq2 | `deseq2_test.mbt` | 10 | | dplyr | `dplyr_test.mbt` | 9 | @@ -3226,7 +3236,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 345 个示例程序，展示各模块的典型用法： +项目提供 346 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3242,6 +3252,7 @@ moon run cmd/bench/main.mbt | cram_demo | CRAM 格式解析（压缩二进制序列比对格式、CRAM转BAM、参考序列管理） | `moon run examples/cram_demo/main.mbt` | | biostrings_demo | Biostrings 序列分析（IUPAC、RSCU、复杂度、Tm） | `moon run examples/biostrings_demo/main.mbt` | | genomic_ranges_demo | GenomicRanges 基因组区间操作（GRanges、区间运算、集合操作） | `moon run examples/genomic_ranges_demo/main.mbt` | +| granges_list_demo | GRangesList复合转录本、unlist/relist、精确外显子重叠与分组RangedSummarizedExperiment | `moon run examples/granges_list_demo/main.mbt` | | deseq2_demo | DESeq2 差异表达分析（size factors归一化、分散度估计、负二项GLM拟合、Wald检验、LFC收缩） | `moon run examples/deseq2_demo/main.mbt` | | dplyr_demo | dplyr 数据操作（filter、select、mutate、arrange、group_by、summarize、join） | `moon run examples/dplyr_demo/main.mbt` | | plyranges_demo | plyranges tidy基因组数据操作（GRanges的filter/mutate/select/arrange/rename/summarise） | `moon run examples/plyranges_demo/main.mbt` | @@ -3260,7 +3271,7 @@ moon run cmd/bench/main.mbt | edger_demo | edgeR 差异表达分析（DGEList创建、归一化因子、分散度估计、精确检验、GLM拟合） | `moon run examples/edger_demo/main.mbt` | | limma_demo | limma 差异表达分析（voom变换、线性模型拟合、经验贝叶斯、topTable、对比矩阵） | `moon run examples/limma_demo/main.mbt` | | summarized_experiment_demo | SummarizedExperiment 多维数据容器（Assays、行/列操作、合并） | `moon run examples/summarized_experiment_demo/main.mbt` | -| ranged_summarized_experiment_demo | RangedSummarizedExperiment 完整GRanges行范围、链特异重叠、最近邻、promoter变换与协调排序 | `moon run examples/ranged_summarized_experiment_demo/main.mbt` | +| ranged_summarized_experiment_demo | RangedSummarizedExperiment GRanges行范围、链特异重叠、最近邻、promoter变换与协调排序 | `moon run examples/ranged_summarized_experiment_demo/main.mbt` | | tree_summarized_experiment_demo | TreeSummarizedExperiment 行/列树链接、节点查询、树节点子集与层级聚合 | `moon run examples/tree_summarized_experiment_demo/main.mbt` | | iranges_demo | IRanges 整数区间操作（shift、resize、reduce、集合运算、重叠检测） | `moon run examples/iranges_demo/main.mbt` | | align_io_demo | 比对格式解析（ClustalW、FASTA、Stockholm格式解析与写入） | `moon run examples/align_io_demo/main.mbt` | @@ -3447,6 +3458,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Biostrings 序列分析（IUPAC、RSCU、复杂度、Tm） - ✅ 实现 DESeq2 差异表达分析（数据集创建、结果分析、显著基因筛选） - ✅ 实现 GenomicRanges 基因组区间操作（GRanges、区间运算、集合操作） +- ✅ 实现 GenomicRanges GRangesList 复合特征（split/unlist/relist、逐组变换、集合运算、特征级重叠/最近邻/覆盖度） - ✅ 实现 dplyr 数据操作 - ✅ 实现 Smith-Waterman 局部序列比对（DNA/蛋白质比对、自定义打分、得分矩阵） - ✅ 实现 Needleman-Wunsch 全局序列比对（DNA/蛋白质比对、自定义打分、得分矩阵） @@ -3462,7 +3474,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 群体遗传学分析（等位基因频率、基因型频率、哈迪-温伯格检验、FST统计、Watterson's theta） - ✅ 实现 edgeR 差异表达分析（DGEList创建、归一化因子、分散度估计、精确检验、GLM拟合） - ✅ 实现 SummarizedExperiment 多维数据容器（Assays、行/列操作、合并） -- ✅ 实现 RangedSummarizedExperiment 基因组区间实验容器（完整GRanges行范围、链特异重叠/最近邻、覆盖度、区间变换与协调子集） +- ✅ 实现 RangedSummarizedExperiment 基因组区间实验容器（GRanges/GRangesList行范围、复合特征精确重叠/最近邻、覆盖度、区间变换与协调子集） - ✅ 实现 TreeSummarizedExperiment 树结构实验容器（行/列树链接、节点子集、层级聚合） - ✅ 实现 IRanges 整数区间操作（shift、resize、reduce、集合运算、重叠检测） - ✅ 实现 比对格式解析（ClustalW、FASTA、Stockholm格式解析与写入） diff --git a/examples/granges_list_demo/main.mbt b/examples/granges_list_demo/main.mbt new file mode 100644 index 00000000..8312fcd9 --- /dev/null +++ b/examples/granges_list_demo/main.mbt @@ -0,0 +1,110 @@ +///| +fn print_element(name : String, ranges : @src.GRanges) -> Unit { + println(" \{name} (\{@src.granges_length(ranges)} ranges)") + for index = 0; index < @src.granges_length(ranges); index = index + 1 { + println( + " \{ranges.seqnames[index]}:\{ranges.starts[index]}-\{ranges.ends[index]}", + ) + } +} + +///| +fn main { + println("=== Bioconductor GRangesList Demo ===") + + let transcripts = @src.granges_list( + [ + @src.granges(["chr1", "chr1"], [(100, 109), (200, 209)], [ + @src.strand_plus(), + @src.strand_plus(), + ]), + @src.granges(["chr1", "chr1"], [(150, 159), (300, 309)], [ + @src.strand_minus(), + @src.strand_minus(), + ]), + @src.granges_single("chr2", 50, 59, @src.strand_star()), + ], + names=["txA", "txB", "txC"], + element_metadata=[ + Map([("gene", "geneA")]), + Map([("gene", "geneB")]), + Map([("gene", "geneC")]), + ], + ) catch { + _ => abort("failed to construct transcript ranges") + } + + println("\n1. Compound genomic features") + println(" " + transcripts.summary()) + let names = transcripts.names() + for index = 0; index < transcripts.length(); index = index + 1 { + match transcripts.get(index) { + Some(ranges) => print_element(names[index], ranges) + None => abort("missing transcript ranges") + } + } + + println("\n2. Unlist and relist") + let flat = transcripts.unlist() + println(" Flattened range count: \{@src.granges_length(flat)}") + let rebuilt = transcripts.relist(flat) catch { + _ => abort("failed to relist flattened ranges") + } + println( + " Rebuilt element sizes: " + + rebuilt.element_lengths().map(fn(size) { size.to_string() }).join(", "), + ) + + println("\n3. Feature-level overlaps use member exons") + let queries = @src.granges(["chr1", "chr1"], [(120, 130), (205, 206)], [ + @src.strand_plus(), + @src.strand_plus(), + ]) + println(" Query 0 lies inside txA bounds but only in its intron.") + for hit in transcripts.find_overlaps(queries) { + println(" \{names[hit.0]} overlaps query \{hit.1}") + } + + println("\n4. Grouped RangedSummarizedExperiment") + let experiment = @src.RangedSummarizedExperiment::new_with_range_groups( + assays=Map([("counts", [[12.0, 18.0], [25.0, 30.0], [8.0, 11.0]])]), + row_range_groups=transcripts, + col_data=[ + Map([("sample", "S1"), ("condition", "control")]), + Map([("sample", "S2"), ("condition", "treated")]), + ], + row_names=names, + metadata=Map([("organism", "human")]), + ) catch { + _ => abort("failed to construct grouped experiment") + } + println(" " + experiment.summary()) + let overlapping = experiment.subset_by_overlaps(queries) catch { + _ => abort("failed to subset grouped experiment") + } + println(" Overlapping assay rows: " + overlapping.row_names().join(", ")) + + let shifted = experiment.shift(10) catch { + _ => abort("failed to shift grouped experiment") + } + match shifted.row_range_groups() { + Some(groups) => + match groups.get(0) { + Some(ranges) => + println( + " Shifted txA exon starts: " + + ranges.starts.map(fn(start) { start.to_string() }).join(", "), + ) + None => abort("missing shifted transcript") + } + None => abort("grouping was not preserved") + } + + println("\n5. Coverage uses all member ranges") + let coverage = experiment.coverage(Map([("chr1", 320), ("chr2", 80)])) + println( + " chr1 coverage at exon/intron positions 100/125: \{coverage["chr1"][99]}/\{coverage["chr1"][124]}", + ) + + println("\n=== Demo Complete ===") +} diff --git a/examples/granges_list_demo/moon.pkg b/examples/granges_list_demo/moon.pkg new file mode 100644 index 00000000..8824b1ac --- /dev/null +++ b/examples/granges_list_demo/moon.pkg @@ -0,0 +1,6 @@ +import { + "IvanAXu/BioSeqs/src", + "moonbitlang/core/hashmap", +} + +pkgtype(kind: "executable") diff --git a/src/granges_list.mbt b/src/granges_list.mbt new file mode 100644 index 00000000..b841821a --- /dev/null +++ b/src/granges_list.mbt @@ -0,0 +1,988 @@ +///| +/// GRangesList - grouped genomic ranges inspired by Bioconductor +/// GenomicRanges. + +///| +pub suberror GRangesListError { + GRangesListError(String) +} + +///| +/// A collection of GRanges elements representing compound genomic features. +/// +/// Typical elements are transcripts whose member ranges are exons. Names and +/// element metadata are optional, but when present they are parallel to the +/// outer list rather than to individual ranges. +pub struct GRangesList { + elements : Array[GRanges] + names : Array[String] + element_metadata : Array[Map[String, String]] +} + +///| +/// Construct and validate a grouped genomic-range collection. +pub fn GRangesList::new( + elements~ : Array[GRanges], + names? : Array[String] = [], + element_metadata? : Array[Map[String, String]] = [], +) -> GRangesList raise GRangesListError { + match grl_validation_error(elements, names, element_metadata) { + Some(message) => raise GRangesListError(message) + None => grl_create_unchecked(elements, names, element_metadata) + } +} + +///| +/// Function-style constructor matching the existing `granges` API. +pub fn granges_list( + elements : Array[GRanges], + names? : Array[String] = [], + element_metadata? : Array[Map[String, String]] = [], +) -> GRangesList raise GRangesListError { + GRangesList::new(elements~, names~, element_metadata~) +} + +///| +/// Split a flat GRanges into named elements in first-appearance group order. +pub fn granges_split_as_list( + ranges : GRanges, + groups : Array[String], +) -> GRangesList raise GRangesListError { + match grl_range_validation_error(ranges) { + Some(message) => raise GRangesListError(message) + None => () + } + if groups.length() != granges_length(ranges) { + raise GRangesListError( + "group vector length must equal the number of genomic ranges", + ) + } + let names : Array[String] = [] + for group in groups { + if !grl_strings_contains(names, group) { + names.push(group) + } + } + let elements : Array[GRanges] = [] + for name in names { + let indices : Array[Int] = [] + for index = 0; index < groups.length(); index = index + 1 { + if groups[index] == name { + indices.push(index) + } + } + elements.push(grl_take_ranges(ranges, indices)) + } + grl_create_unchecked(elements, names, []) +} + +///| +/// Partition a flat GRanges using explicit element lengths. +pub fn granges_list_from_partition( + ranges : GRanges, + element_lengths : Array[Int], + names? : Array[String] = [], + element_metadata? : Array[Map[String, String]] = [], +) -> GRangesList raise GRangesListError { + match grl_range_validation_error(ranges) { + Some(message) => raise GRangesListError(message) + None => () + } + if names.length() != 0 && names.length() != element_lengths.length() { + raise GRangesListError( + "names length must equal the number of list elements", + ) + } + if element_metadata.length() != 0 && + element_metadata.length() != element_lengths.length() { + raise GRangesListError( + "element metadata length must equal the number of list elements", + ) + } + let mut total = 0 + for length in element_lengths { + if length < 0 { + raise GRangesListError("element lengths must be non-negative") + } + total = total + length + } + if total != granges_length(ranges) { + raise GRangesListError( + "element lengths must sum to the number of genomic ranges", + ) + } + let elements : Array[GRanges] = [] + let mut offset = 0 + for length in element_lengths { + elements.push(grl_take_contiguous(ranges, offset, length)) + offset = offset + length + } + grl_create_unchecked(elements, names, element_metadata) +} + +///| +/// Return the number of compound features. +pub fn GRangesList::length(self : GRangesList) -> Int { + self.elements.length() +} + +///| +/// Return optional feature names. An empty array represents an unnamed list. +pub fn GRangesList::names(self : GRangesList) -> Array[String] { + self.names.copy() +} + +///| +/// Return optional feature-level metadata. +pub fn GRangesList::element_metadata( + self : GRangesList, +) -> Array[Map[String, String]] { + self.element_metadata.copy() +} + +///| +/// Return copies of all GRanges elements. +pub fn GRangesList::elements(self : GRangesList) -> Array[GRanges] { + self.elements.map(fn(element) { grl_copy_ranges(element) }) +} + +///| +/// Return the number of ranges in each compound feature. +pub fn GRangesList::element_lengths(self : GRangesList) -> Array[Int] { + self.elements.map(fn(element) { granges_length(element) }) +} + +///| +/// Return true when there are no elements or all elements are empty. +pub fn GRangesList::is_empty(self : GRangesList) -> Bool { + if self.elements.length() == 0 { + return true + } + for element in self.elements { + if granges_length(element) > 0 { + return false + } + } + true +} + +///| +/// Validate all outer and inner parallel dimensions. +pub fn GRangesList::is_valid(self : GRangesList) -> Bool { + grl_validation_error(self.elements, self.names, self.element_metadata) is None +} + +///| +/// Return a copied GRanges element by zero-based index. +pub fn GRangesList::get(self : GRangesList, index : Int) -> GRanges? { + if index < 0 || index >= self.elements.length() { + None + } else { + Some(grl_copy_ranges(self.elements[index])) + } +} + +///| +/// Return the first element with a matching name. +pub fn GRangesList::get_by_name(self : GRangesList, name : String) -> GRanges? { + for index = 0; index < self.names.length(); index = index + 1 { + if self.names[index] == name { + return Some(grl_copy_ranges(self.elements[index])) + } + } + None +} + +///| +/// Select, reorder, or duplicate outer list elements. +pub fn GRangesList::subset( + self : GRangesList, + indices : Array[Int], +) -> GRangesList raise GRangesListError { + grl_validate_indices(indices, self.elements.length()) + let elements = indices.map(fn(index) { grl_copy_ranges(self.elements[index]) }) + let names = if self.names.length() == 0 { + [] + } else { + indices.map(fn(index) { self.names[index] }) + } + let metadata = if self.element_metadata.length() == 0 { + [] + } else { + indices.map(fn(index) { self.element_metadata[index] }) + } + grl_create_unchecked(elements, names, metadata) +} + +///| +/// Concatenate all member ranges into a flat GRanges. +pub fn GRangesList::unlist(self : GRangesList) -> GRanges { + let result = grl_empty_ranges() + for element in self.elements { + grl_append_ranges(result, element) + } + result +} + +///| +/// Repartition a flat GRanges using this object's element boundaries. +pub fn GRangesList::relist( + self : GRangesList, + ranges : GRanges, +) -> GRangesList raise GRangesListError { + granges_list_from_partition( + ranges, + self.element_lengths(), + names=self.names, + element_metadata=self.element_metadata, + ) +} + +///| +/// Summarize each feature as one bounding range. +/// +/// Features spanning multiple sequence names receive `"*"` as the sequence +/// name, and mixed strands receive `Strand::Star`. Empty features are encoded +/// as a zero-width range at 0. +pub fn GRangesList::feature_bounds(self : GRangesList) -> GRanges { + let result = grl_empty_ranges() + for element in self.elements { + if granges_length(element) == 0 { + result.seqnames.push("") + result.starts.push(0) + result.ends.push(-1) + result.strands.push(Strand::Star) + result.widths.push(0) + } else { + let mut seqname = element.seqnames[0] + let mut strand = element.strands[0] + let mut start = element.starts[0] + let mut end = element.ends[0] + for index = 1; index < granges_length(element); index = index + 1 { + if element.seqnames[index] != seqname { + seqname = "*" + } + if element.strands[index] != strand { + strand = Strand::Star + } + if element.starts[index] < start { + start = element.starts[index] + } + if element.ends[index] > end { + end = element.ends[index] + } + } + result.seqnames.push(seqname) + result.starts.push(start) + result.ends.push(end) + result.strands.push(strand) + result.widths.push(end - start + 1) + } + } + result +} + +///| +/// Append the outer elements of two lists. +pub fn GRangesList::concat( + self : GRangesList, + other : GRangesList, +) -> GRangesList { + let elements = self.elements() + for element in other.elements { + elements.push(grl_copy_ranges(element)) + } + let names : Array[String] = [] + if self.names.length() > 0 || other.names.length() > 0 { + for index = 0; index < self.length(); index = index + 1 { + names.push(if self.names.length() > 0 { self.names[index] } else { "" }) + } + for index = 0; index < other.length(); index = index + 1 { + names.push(if other.names.length() > 0 { other.names[index] } else { "" }) + } + } + let metadata : Array[Map[String, String]] = [] + if self.element_metadata.length() > 0 || other.element_metadata.length() > 0 { + for index = 0; index < self.length(); index = index + 1 { + metadata.push( + if self.element_metadata.length() > 0 { + self.element_metadata[index] + } else { + Map([]) + }, + ) + } + for index = 0; index < other.length(); index = index + 1 { + metadata.push( + if other.element_metadata.length() > 0 { + other.element_metadata[index] + } else { + Map([]) + }, + ) + } + } + grl_create_unchecked(elements, names, metadata) +} + +///| +/// Concatenate corresponding GRanges elements. +pub fn GRangesList::parallel_concat( + self : GRangesList, + other : GRangesList, +) -> GRangesList raise GRangesListError { + grl_require_parallel(self, other) + let elements : Array[GRanges] = [] + for index = 0; index < self.length(); index = index + 1 { + elements.push( + grl_concat_ranges(self.elements[index], other.elements[index]), + ) + } + let names = grl_preferred_names(self, other) + let metadata = grl_preferred_metadata(self, other) + grl_create_unchecked(elements, names, metadata) +} + +///| +/// Shift every member range while preserving group boundaries. +pub fn GRangesList::shift(self : GRangesList, amount : Int) -> GRangesList { + grl_map(self, fn(element) { granges_shift(element, amount) }) +} + +///| +/// Narrow every member range using one-based relative coordinates. +pub fn GRangesList::narrow( + self : GRangesList, + start : Int, + end : Int, +) -> GRangesList { + grl_map(self, fn(element) { granges_narrow(element, start, end) }) +} + +///| +/// Resize every member range. +pub fn GRangesList::resize( + self : GRangesList, + width : Int, + fix : String, +) -> GRangesList { + grl_map(self, fn(element) { granges_resize(element, width, fix) }) +} + +///| +/// Create flanking ranges for every member range. +pub fn GRangesList::flank( + self : GRangesList, + width : Int, + start : Bool, + both : Bool, +) -> GRangesList { + grl_map(self, fn(element) { granges_flank(element, width, start, both) }) +} + +///| +/// Create strand-aware promoter ranges for every member range. +pub fn GRangesList::promoters( + self : GRangesList, + upstream? : Int = 2000, + downstream? : Int = 200, +) -> GRangesList raise GRangesListError { + if upstream < 0 || downstream < 0 { + raise GRangesListError( + "promoter upstream and downstream widths must be non-negative", + ) + } + grl_map(self, fn(element) { granges_promoters(element, upstream, downstream) }) +} + +///| +/// Reduce overlapping ranges independently within each feature. +pub fn GRangesList::reduce( + self : GRangesList, + min_gapwidth? : Int = 0, +) -> GRangesList { + grl_map(self, fn(element) { granges_reduce(element, min_gapwidth) }) +} + +///| +/// Disjoin ranges independently within each feature. +pub fn GRangesList::disjoin(self : GRangesList) -> GRangesList { + grl_map(self, fn(element) { granges_disjoin(element) }) +} + +///| +/// Sort ranges inside each feature without changing outer feature order. +pub fn GRangesList::sort_ranges(self : GRangesList) -> GRangesList { + grl_map(self, fn(element) { granges_sort(element) }) +} + +///| +/// Calculate the sum of member widths for every compound feature. +pub fn GRangesList::total_widths(self : GRangesList) -> Array[Int] { + self.elements.map(fn(element) { + let mut total = 0 + for width in element.widths { + total = total + width + } + total + }) +} + +///| +/// Compute an element-wise union of two parallel lists. +pub fn GRangesList::parallel_union( + self : GRangesList, + other : GRangesList, +) -> GRangesList raise GRangesListError { + grl_parallel_set_operation(self, other, fn(left, right) { + granges_union(left, right) + }) +} + +///| +/// Compute an element-wise intersection of two parallel lists. +pub fn GRangesList::parallel_intersect( + self : GRangesList, + other : GRangesList, +) -> GRangesList raise GRangesListError { + grl_parallel_set_operation(self, other, fn(left, right) { + granges_intersect(left, right) + }) +} + +///| +/// Compute an element-wise asymmetric difference of two parallel lists. +pub fn GRangesList::parallel_setdiff( + self : GRangesList, + other : GRangesList, +) -> GRangesList raise GRangesListError { + grl_parallel_set_operation(self, other, fn(left, right) { + granges_setdiff(left, right) + }) +} + +///| +/// Find subject ranges overlapping each compound query feature. +/// +/// A feature-subject pair is returned once even when multiple member ranges +/// overlap the same subject range. +pub fn GRangesList::find_overlaps( + self : GRangesList, + subject : GRanges, + ignore_strand? : Bool = false, +) -> Array[(Int, Int)] { + let hits : Array[(Int, Int)] = [] + for query_index = 0 + query_index < self.elements.length() + query_index = query_index + 1 { + for subject_index = 0 + subject_index < granges_length(subject) + subject_index = subject_index + 1 { + if grl_element_overlaps_range( + self.elements[query_index], + subject, + subject_index, + ignore_strand, + ) { + hits.push((query_index, subject_index)) + } + } + } + hits +} + +///| +/// Count distinct subject-range overlaps for each feature. +pub fn GRangesList::count_overlaps( + self : GRangesList, + subject : GRanges, + ignore_strand? : Bool = false, +) -> Array[Int] { + let counts = Array::make(self.length(), 0) + for hit in self.find_overlaps(subject, ignore_strand~) { + counts[hit.0] = counts[hit.0] + 1 + } + counts +} + +///| +/// Return one overlap flag per compound feature. +pub fn GRangesList::overlaps_any( + self : GRangesList, + subject : GRanges, + ignore_strand? : Bool = false, +) -> Array[Bool] { + self.count_overlaps(subject, ignore_strand~).map(fn(count) { count > 0 }) +} + +///| +/// Keep features that overlap at least one subject range. +pub fn GRangesList::subset_by_overlaps( + self : GRangesList, + subject : GRanges, + ignore_strand? : Bool = false, +) -> GRangesList raise GRangesListError { + let indices : Array[Int] = [] + let keep = self.overlaps_any(subject, ignore_strand~) + for index = 0; index < keep.length(); index = index + 1 { + if keep[index] { + indices.push(index) + } + } + self.subset(indices) +} + +///| +/// Find overlaps between compound features in two grouped collections. +pub fn GRangesList::find_group_overlaps( + self : GRangesList, + subject : GRangesList, + ignore_strand? : Bool = false, +) -> Array[(Int, Int)] { + let hits : Array[(Int, Int)] = [] + for query_index = 0 + query_index < self.length() + query_index = query_index + 1 { + for subject_index = 0 + subject_index < subject.length() + subject_index = subject_index + 1 { + if grl_elements_overlap( + self.elements[query_index], + subject.elements[subject_index], + ignore_strand, + ) { + hits.push((query_index, subject_index)) + } + } + } + hits +} + +///| +/// Count distinct subject features overlapping each query feature. +pub fn GRangesList::count_group_overlaps( + self : GRangesList, + subject : GRangesList, + ignore_strand? : Bool = false, +) -> Array[Int] { + let counts = Array::make(self.length(), 0) + for hit in self.find_group_overlaps(subject, ignore_strand~) { + counts[hit.0] = counts[hit.0] + 1 + } + counts +} + +///| +/// Find overlaps between flat query ranges and grouped subject features. +pub fn granges_find_overlaps_list( + query : GRanges, + subject : GRangesList, + ignore_strand? : Bool = false, +) -> Array[(Int, Int)] { + let hits : Array[(Int, Int)] = [] + for query_index = 0 + query_index < granges_length(query) + query_index = query_index + 1 { + for subject_index = 0 + subject_index < subject.length() + subject_index = subject_index + 1 { + if grl_element_overlaps_range( + subject.elements[subject_index], + query, + query_index, + ignore_strand, + ) { + hits.push((query_index, subject_index)) + } + } + } + hits +} + +///| +/// Return the nearest subject range for each compound feature. +pub fn GRangesList::nearest( + self : GRangesList, + subject : GRanges, + ignore_strand? : Bool = false, +) -> Array[Int] { + let result = Array::make(self.length(), -1) + for query_index = 0 + query_index < self.length() + query_index = query_index + 1 { + let nearest = grl_nearest_for_element( + self.elements[query_index], + subject, + ignore_strand, + ) + result[query_index] = nearest.0 + } + result +} + +///| +/// Return the minimum genomic distance to a subject range for each feature. +pub fn GRangesList::distance_to_nearest( + self : GRangesList, + subject : GRanges, + ignore_strand? : Bool = false, +) -> Array[Int] { + let result = Array::make(self.length(), -1) + for query_index = 0 + query_index < self.length() + query_index = query_index + 1 { + let nearest = grl_nearest_for_element( + self.elements[query_index], + subject, + ignore_strand, + ) + result[query_index] = nearest.1 + } + result +} + +///| +/// Compute per-base coverage across all member ranges. +pub fn GRangesList::coverage( + self : GRangesList, + sequence_lengths : Map[String, Int], +) -> Map[String, Array[Int]] { + coverage_granges(self.unlist(), sequence_lengths) +} + +///| +/// Return a compact list summary. +pub fn GRangesList::summary(self : GRangesList) -> String { + let mut total_ranges = 0 + for length in self.element_lengths() { + total_ranges = total_ranges + length + } + "GRangesList(" + + self.length().to_string() + + " elements, " + + total_ranges.to_string() + + " ranges)" +} + +///| +fn grl_create_unchecked( + elements : Array[GRanges], + names : Array[String], + element_metadata : Array[Map[String, String]], +) -> GRangesList { + GRangesList::{ + elements: elements.map(fn(element) { grl_copy_ranges(element) }), + names: names.copy(), + element_metadata: element_metadata.copy(), + } +} + +///| +fn grl_validation_error( + elements : Array[GRanges], + names : Array[String], + element_metadata : Array[Map[String, String]], +) -> String? { + if names.length() != 0 && names.length() != elements.length() { + return Some("names length must equal the number of list elements") + } + if element_metadata.length() != 0 && + element_metadata.length() != elements.length() { + return Some( + "element metadata length must equal the number of list elements", + ) + } + for index = 0; index < elements.length(); index = index + 1 { + match grl_range_validation_error(elements[index]) { + Some(message) => + return Some( + "invalid GRanges element " + index.to_string() + ": " + message, + ) + None => () + } + } + None +} + +///| +fn grl_range_validation_error(ranges : GRanges) -> String? { + let length = ranges.seqnames.length() + if ranges.starts.length() != length || + ranges.ends.length() != length || + ranges.strands.length() != length || + ranges.widths.length() != length { + return Some("all GRanges fields must have the same length") + } + for index = 0; index < length; index = index + 1 { + let expected_width = ranges.ends[index] - ranges.starts[index] + 1 + if expected_width < 0 || ranges.widths[index] != expected_width { + return Some("invalid genomic range width at index " + index.to_string()) + } + } + None +} + +///| +fn grl_validate_indices( + indices : Array[Int], + upper_bound : Int, +) -> Unit raise GRangesListError { + for index in indices { + if index < 0 || index >= upper_bound { + raise GRangesListError( + "list element index out of bounds: " + index.to_string(), + ) + } + } +} + +///| +fn grl_empty_ranges() -> GRanges { + GRanges::{ seqnames: [], starts: [], ends: [], strands: [], widths: [] } +} + +///| +fn grl_copy_ranges(ranges : GRanges) -> GRanges { + GRanges::{ + seqnames: ranges.seqnames.copy(), + starts: ranges.starts.copy(), + ends: ranges.ends.copy(), + strands: ranges.strands.copy(), + widths: ranges.widths.copy(), + } +} + +///| +fn grl_take_ranges(ranges : GRanges, indices : Array[Int]) -> GRanges { + let result = grl_empty_ranges() + for index in indices { + result.seqnames.push(ranges.seqnames[index]) + result.starts.push(ranges.starts[index]) + result.ends.push(ranges.ends[index]) + result.strands.push(ranges.strands[index]) + result.widths.push(ranges.widths[index]) + } + result +} + +///| +fn grl_take_contiguous(ranges : GRanges, offset : Int, length : Int) -> GRanges { + let indices : Array[Int] = [] + for index = offset; index < offset + length; index = index + 1 { + indices.push(index) + } + grl_take_ranges(ranges, indices) +} + +///| +fn grl_append_ranges(target : GRanges, source : GRanges) -> Unit { + for index = 0; index < granges_length(source); index = index + 1 { + target.seqnames.push(source.seqnames[index]) + target.starts.push(source.starts[index]) + target.ends.push(source.ends[index]) + target.strands.push(source.strands[index]) + target.widths.push(source.widths[index]) + } +} + +///| +fn grl_concat_ranges(left : GRanges, right : GRanges) -> GRanges { + let result = grl_copy_ranges(left) + grl_append_ranges(result, right) + result +} + +///| +fn grl_strings_contains(values : Array[String], target : String) -> Bool { + for value in values { + if value == target { + return true + } + } + false +} + +///| +fn grl_map( + ranges : GRangesList, + operation : (GRanges) -> GRanges, +) -> GRangesList { + grl_create_unchecked( + ranges.elements.map(fn(element) { operation(element) }), + ranges.names, + ranges.element_metadata, + ) +} + +///| +fn grl_require_parallel( + left : GRangesList, + right : GRangesList, +) -> Unit raise GRangesListError { + if left.length() != right.length() { + raise GRangesListError( + "parallel GRangesList operations require equal element counts", + ) + } +} + +///| +fn grl_preferred_names( + left : GRangesList, + right : GRangesList, +) -> Array[String] { + if left.names.length() > 0 { + left.names + } else { + right.names + } +} + +///| +fn grl_preferred_metadata( + left : GRangesList, + right : GRangesList, +) -> Array[Map[String, String]] { + if left.element_metadata.length() > 0 { + left.element_metadata + } else { + right.element_metadata + } +} + +///| +fn grl_parallel_set_operation( + left : GRangesList, + right : GRangesList, + operation : (GRanges, GRanges) -> GRanges, +) -> GRangesList raise GRangesListError { + grl_require_parallel(left, right) + let elements : Array[GRanges] = [] + for index = 0; index < left.length(); index = index + 1 { + elements.push(operation(left.elements[index], right.elements[index])) + } + grl_create_unchecked( + elements, + grl_preferred_names(left, right), + grl_preferred_metadata(left, right), + ) +} + +///| +fn grl_strands_compatible( + query : Strand, + subject : Strand, + ignore_strand : Bool, +) -> Bool { + ignore_strand || + query == Strand::Star || + subject == Strand::Star || + query == subject +} + +///| +fn grl_ranges_overlap( + query : GRanges, + query_index : Int, + subject : GRanges, + subject_index : Int, + ignore_strand : Bool, +) -> Bool { + query.seqnames[query_index] == subject.seqnames[subject_index] && + grl_strands_compatible( + query.strands[query_index], + subject.strands[subject_index], + ignore_strand, + ) && + query.starts[query_index] <= subject.ends[subject_index] && + query.ends[query_index] >= subject.starts[subject_index] +} + +///| +fn grl_element_overlaps_range( + element : GRanges, + subject : GRanges, + subject_index : Int, + ignore_strand : Bool, +) -> Bool { + for member_index = 0 + member_index < granges_length(element) + member_index = member_index + 1 { + if grl_ranges_overlap( + element, member_index, subject, subject_index, ignore_strand, + ) { + return true + } + } + false +} + +///| +fn grl_elements_overlap( + query : GRanges, + subject : GRanges, + ignore_strand : Bool, +) -> Bool { + for subject_index = 0 + subject_index < granges_length(subject) + subject_index = subject_index + 1 { + if grl_element_overlaps_range(query, subject, subject_index, ignore_strand) { + return true + } + } + false +} + +///| +fn grl_interval_distance( + first_start : Int, + first_end : Int, + second_start : Int, + second_end : Int, +) -> Int { + if first_end < second_start { + second_start - first_end - 1 + } else if second_end < first_start { + first_start - second_end - 1 + } else { + 0 + } +} + +///| +fn grl_nearest_for_element( + element : GRanges, + subject : GRanges, + ignore_strand : Bool, +) -> (Int, Int) { + let mut best_index = -1 + let mut best_distance = -1 + for member_index = 0 + member_index < granges_length(element) + member_index = member_index + 1 { + for subject_index = 0 + subject_index < granges_length(subject) + subject_index = subject_index + 1 { + if element.seqnames[member_index] == subject.seqnames[subject_index] && + grl_strands_compatible( + element.strands[member_index], + subject.strands[subject_index], + ignore_strand, + ) { + let distance = grl_interval_distance( + element.starts[member_index], + element.ends[member_index], + subject.starts[subject_index], + subject.ends[subject_index], + ) + if best_index < 0 || + distance < best_distance || + (distance == best_distance && subject_index < best_index) { + best_index = subject_index + best_distance = distance + } + } + } + } + (best_index, best_distance) +} diff --git a/src/ranged_summarized_experiment.mbt b/src/ranged_summarized_experiment.mbt index 6a369d07..d1bf3316 100644 --- a/src/ranged_summarized_experiment.mbt +++ b/src/ranged_summarized_experiment.mbt @@ -15,6 +15,7 @@ pub suberror RangedSummarizedExperimentError { pub struct RangedSummarizedExperiment { experiment : SummarizedExperiment row_ranges : GRanges + row_range_groups : GRangesList? row_data : Array[Map[String, String]] row_names : Array[String] } @@ -30,13 +31,7 @@ pub fn RangedSummarizedExperiment::new( metadata? : Map[String, String] = Map([]), ) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { match - rse_validation_error( - assays, - row_ranges, - col_data, - row_data, - row_names, - ) { + rse_validation_error(assays, row_ranges, col_data, row_data, row_names) { Some(message) => raise RangedSummarizedExperimentError(message) None => { let experiment = summarized_experiment( @@ -48,6 +43,7 @@ pub fn RangedSummarizedExperiment::new( RangedSummarizedExperiment::{ experiment, row_ranges, + row_range_groups: None, row_data, row_names, } @@ -55,6 +51,50 @@ pub fn RangedSummarizedExperiment::new( } } +///| +/// Construct an experiment whose rows are compound genomic features. +/// +/// Each GRangesList element corresponds to one assay row, such as a transcript +/// represented by multiple exons. Feature-level GRangesList metadata is used as +/// row data when explicit row data is absent. +pub fn RangedSummarizedExperiment::new_with_range_groups( + assays~ : Map[String, Array[Array[Double]]], + row_range_groups~ : GRangesList, + col_data~ : Array[Map[String, String]], + row_data? : Array[Map[String, String]] = [], + row_names? : Array[String] = [], + metadata? : Map[String, String] = Map([]), +) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { + let effective_row_data = if row_data.length() == 0 && + row_range_groups.element_metadata().length() > 0 { + row_range_groups.element_metadata() + } else { + row_data + } + let bounds = row_range_groups.feature_bounds() + match + rse_grouped_validation_error( + assays, row_range_groups, col_data, effective_row_data, row_names, + ) { + Some(message) => raise RangedSummarizedExperimentError(message) + None => { + let experiment = summarized_experiment( + assays, + rse_ranges_as_tuples(bounds), + col_data, + metadata, + ) + RangedSummarizedExperiment::{ + experiment, + row_ranges: bounds, + row_range_groups: Some(row_range_groups), + row_data: effective_row_data, + row_names, + } + } + } +} + ///| /// Attach full genomic ranges to an existing SummarizedExperiment. pub fn RangedSummarizedExperiment::from_experiment( @@ -73,6 +113,24 @@ pub fn RangedSummarizedExperiment::from_experiment( ) } +///| +/// Attach grouped genomic features to an existing SummarizedExperiment. +pub fn RangedSummarizedExperiment::from_experiment_with_range_groups( + experiment~ : SummarizedExperiment, + row_range_groups~ : GRangesList, + row_data? : Array[Map[String, String]] = [], + row_names? : Array[String] = [], +) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { + RangedSummarizedExperiment::new_with_range_groups( + assays=rse_copy_assays(experiment), + row_range_groups~, + col_data=se_col_data(experiment), + row_data~, + row_names~, + metadata=se_metadata(experiment), + ) +} + ///| /// Return the underlying SummarizedExperiment. pub fn RangedSummarizedExperiment::experiment( @@ -99,13 +157,42 @@ pub fn RangedSummarizedExperiment::assay_names( } ///| -/// Return the genomic ranges associated with assay rows. +/// Return one genomic range associated with each assay row. +/// +/// For grouped rows this returns feature bounds. Use `row_range_groups` to +/// retrieve the exact member ranges. pub fn RangedSummarizedExperiment::row_ranges( self : RangedSummarizedExperiment, ) -> GRanges { self.row_ranges } +///| +/// Return exact grouped row ranges when this is a GRangesList-backed object. +pub fn RangedSummarizedExperiment::row_range_groups( + self : RangedSummarizedExperiment, +) -> GRangesList? { + match self.row_range_groups { + Some(groups) => + Some( + grl_create_unchecked( + groups.elements(), + groups.names(), + groups.element_metadata(), + ), + ) + None => None + } +} + +///| +/// Return whether assay rows are represented by compound genomic features. +pub fn RangedSummarizedExperiment::has_grouped_row_ranges( + self : RangedSummarizedExperiment, +) -> Bool { + self.row_range_groups is Some(_) +} + ///| /// Return optional per-row annotations. pub fn RangedSummarizedExperiment::row_data( @@ -143,7 +230,10 @@ pub fn RangedSummarizedExperiment::metadata( pub fn RangedSummarizedExperiment::nrow( self : RangedSummarizedExperiment, ) -> Int { - granges_length(self.row_ranges) + match self.row_range_groups { + Some(groups) => groups.length() + None => granges_length(self.row_ranges) + } } ///| @@ -159,13 +249,27 @@ pub fn RangedSummarizedExperiment::ncol( pub fn RangedSummarizedExperiment::is_valid( self : RangedSummarizedExperiment, ) -> Bool { - rse_validation_error( - rse_copy_assays(self.experiment), - self.row_ranges, - se_col_data(self.experiment), - self.row_data, - self.row_names, - ) is None + match self.row_range_groups { + Some(groups) => + rse_grouped_validation_error( + rse_copy_assays(self.experiment), + groups, + se_col_data(self.experiment), + self.row_data, + self.row_names, + ) + is None && + rse_ranges_equal(self.row_ranges, groups.feature_bounds()) + None => + rse_validation_error( + rse_copy_assays(self.experiment), + self.row_ranges, + se_col_data(self.experiment), + self.row_data, + self.row_names, + ) + is None + } } ///| @@ -184,6 +288,22 @@ pub fn RangedSummarizedExperiment::with_row_ranges( ) } +///| +/// Replace row ranges with compound features without changing assays. +pub fn RangedSummarizedExperiment::with_row_range_groups( + self : RangedSummarizedExperiment, + row_range_groups : GRangesList, +) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { + RangedSummarizedExperiment::new_with_range_groups( + assays=rse_copy_assays(self.experiment), + row_range_groups~, + col_data=se_col_data(self.experiment), + row_data=self.row_data, + row_names=self.row_names, + metadata=se_metadata(self.experiment), + ) +} + ///| /// Select, reorder, or duplicate rows while keeping all row data coordinated. pub fn RangedSummarizedExperiment::subset_rows( @@ -191,9 +311,14 @@ pub fn RangedSummarizedExperiment::subset_rows( indices : Array[Int], ) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { rse_validate_indices(indices, self.nrow(), "row") + let row_range_groups = match self.row_range_groups { + Some(groups) => Some(rse_take_range_groups(groups, indices)) + None => None + } RangedSummarizedExperiment::{ experiment: se_subset_rows(self.experiment, indices), row_ranges: rse_take_ranges(self.row_ranges, indices), + row_range_groups, row_data: rse_take_maps(self.row_data, indices), row_names: rse_take_strings(self.row_names, indices), } @@ -209,6 +334,7 @@ pub fn RangedSummarizedExperiment::subset_cols( RangedSummarizedExperiment::{ experiment: se_subset_cols(self.experiment, indices), row_ranges: self.row_ranges, + row_range_groups: self.row_range_groups, row_data: self.row_data, row_names: self.row_names, } @@ -223,18 +349,22 @@ pub fn RangedSummarizedExperiment::find_overlaps( subject : GRanges, ignore_strand? : Bool = false, ) -> Array[(Int, Int)] { + match self.row_range_groups { + Some(groups) => return groups.find_overlaps(subject, ignore_strand~) + None => () + } let hits : Array[(Int, Int)] = [] for query_index = 0; query_index < self.nrow(); query_index = query_index + 1 { for subject_index = 0 subject_index < granges_length(subject) subject_index = subject_index + 1 { if rse_ranges_overlap( - self.row_ranges, - query_index, - subject, - subject_index, - ignore_strand, - ) { + self.row_ranges, + query_index, + subject, + subject_index, + ignore_strand, + ) { hits.push((query_index, subject_index)) } } @@ -290,6 +420,10 @@ pub fn RangedSummarizedExperiment::nearest( subject : GRanges, ignore_strand? : Bool = false, ) -> Array[Int] { + match self.row_range_groups { + Some(groups) => return groups.nearest(subject, ignore_strand~) + None => () + } let nearest_indices = Array::make(self.nrow(), -1) for query_index = 0; query_index < self.nrow(); query_index = query_index + 1 { let mut best_index = -1 @@ -298,7 +432,7 @@ pub fn RangedSummarizedExperiment::nearest( subject_index < granges_length(subject) subject_index = subject_index + 1 { if self.row_ranges.seqnames[query_index] == - subject.seqnames[subject_index] && + subject.seqnames[subject_index] && rse_strands_compatible( self.row_ranges.strands[query_index], subject.strands[subject_index], @@ -328,6 +462,10 @@ pub fn RangedSummarizedExperiment::distance_to_nearest( subject : GRanges, ignore_strand? : Bool = false, ) -> Array[Int] { + match self.row_range_groups { + Some(groups) => return groups.distance_to_nearest(subject, ignore_strand~) + None => () + } let distances = Array::make(self.nrow(), -1) let nearest_indices = self.nearest(subject, ignore_strand~) for query_index = 0; query_index < self.nrow(); query_index = query_index + 1 { @@ -350,7 +488,10 @@ pub fn RangedSummarizedExperiment::coverage( self : RangedSummarizedExperiment, sequence_lengths : Map[String, Int], ) -> Map[String, Array[Int]] { - coverage_granges(self.row_ranges, sequence_lengths) + match self.row_range_groups { + Some(groups) => groups.coverage(sequence_lengths) + None => coverage_granges(self.row_ranges, sequence_lengths) + } } ///| @@ -359,7 +500,10 @@ pub fn RangedSummarizedExperiment::shift( self : RangedSummarizedExperiment, amount : Int, ) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { - self.with_row_ranges(granges_shift(self.row_ranges, amount)) + match self.row_range_groups { + Some(groups) => self.with_row_range_groups(groups.shift(amount)) + None => self.with_row_ranges(granges_shift(self.row_ranges, amount)) + } } ///| @@ -369,7 +513,10 @@ pub fn RangedSummarizedExperiment::narrow( start : Int, end : Int, ) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { - self.with_row_ranges(granges_narrow(self.row_ranges, start, end)) + match self.row_range_groups { + Some(groups) => self.with_row_range_groups(groups.narrow(start, end)) + None => self.with_row_ranges(granges_narrow(self.row_ranges, start, end)) + } } ///| @@ -379,7 +526,10 @@ pub fn RangedSummarizedExperiment::resize( width : Int, fix : String, ) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { - self.with_row_ranges(granges_resize(self.row_ranges, width, fix)) + match self.row_range_groups { + Some(groups) => self.with_row_range_groups(groups.resize(width, fix)) + None => self.with_row_ranges(granges_resize(self.row_ranges, width, fix)) + } } ///| @@ -390,7 +540,11 @@ pub fn RangedSummarizedExperiment::flank( start : Bool, both : Bool, ) -> RangedSummarizedExperiment raise RangedSummarizedExperimentError { - self.with_row_ranges(granges_flank(self.row_ranges, width, start, both)) + match self.row_range_groups { + Some(groups) => self.with_row_range_groups(groups.flank(width, start, both)) + None => + self.with_row_ranges(granges_flank(self.row_ranges, width, start, both)) + } } ///| @@ -405,9 +559,19 @@ pub fn RangedSummarizedExperiment::promoters( "promoter upstream and downstream widths must be non-negative", ) } - self.with_row_ranges( - granges_promoters(self.row_ranges, upstream, downstream), - ) + match self.row_range_groups { + Some(groups) => { + let promoted = groups.promoters(upstream~, downstream~) catch { + GRangesListError(message) => + raise RangedSummarizedExperimentError(message) + } + self.with_row_range_groups(promoted) + } + None => + self.with_row_ranges( + granges_promoters(self.row_ranges, upstream, downstream), + ) + } } ///| @@ -445,15 +609,46 @@ pub fn RangedSummarizedExperiment::sort( pub fn RangedSummarizedExperiment::summary( self : RangedSummarizedExperiment, ) -> String { + let range_label = if self.has_grouped_row_ranges() { + " range groups x " + } else { + " ranges x " + } "RangedSummarizedExperiment(" + self.nrow().to_string() + - " ranges x " + + range_label + self.ncol().to_string() + " samples, assays=[" + self.assay_names().join(", ") + "])" } +///| +fn rse_grouped_validation_error( + assays : Map[String, Array[Array[Double]]], + row_range_groups : GRangesList, + col_data : Array[Map[String, String]], + row_data : Array[Map[String, String]], + row_names : Array[String], +) -> String? { + match + grl_validation_error( + row_range_groups.elements, + row_range_groups.names, + row_range_groups.element_metadata, + ) { + Some(message) => return Some(message) + None => () + } + rse_validation_error( + assays, + row_range_groups.feature_bounds(), + col_data, + row_data, + row_names, + ) +} + ///| fn rse_validation_error( assays : Map[String, Array[Array[Double]]], @@ -472,9 +667,7 @@ fn rse_validation_error( for index = 0; index < nrow; index = index + 1 { let expected_width = row_ranges.ends[index] - row_ranges.starts[index] + 1 if expected_width < 0 || row_ranges.widths[index] != expected_width { - return Some( - "invalid genomic range width at row " + index.to_string(), - ) + return Some("invalid genomic range width at row " + index.to_string()) } } if row_data.length() != 0 && row_data.length() != nrow { @@ -495,9 +688,7 @@ fn rse_validation_error( for row_index = 0; row_index < assay.length(); row_index = row_index + 1 { if assay[row_index].length() != col_data.length() { return Some( - "assay '" + - assay_name + - "' column count must equal col_data length", + "assay '" + assay_name + "' column count must equal col_data length", ) } } @@ -506,16 +697,25 @@ fn rse_validation_error( } ///| -fn rse_ranges_as_tuples( - row_ranges : GRanges, -) -> Array[(String, Int, Int)] { +fn rse_ranges_equal(left : GRanges, right : GRanges) -> Bool { + left.seqnames == right.seqnames && + left.starts == right.starts && + left.ends == right.ends && + left.strands == right.strands && + left.widths == right.widths +} + +///| +fn rse_ranges_as_tuples(row_ranges : GRanges) -> Array[(String, Int, Int)] { let result : Array[(String, Int, Int)] = [] for index = 0; index < granges_length(row_ranges); index = index + 1 { - result.push(( - row_ranges.seqnames[index], - row_ranges.starts[index], - row_ranges.ends[index], - )) + result.push( + ( + row_ranges.seqnames[index], + row_ranges.starts[index], + row_ranges.ends[index], + ), + ) } result } @@ -525,7 +725,10 @@ fn rse_copy_assays( experiment : SummarizedExperiment, ) -> Map[String, Array[Array[Double]]] { let names = se_assay_names(experiment) - let assays : Map[String, Array[Array[Double]]] = Map([], capacity=names.length()) + let assays : Map[String, Array[Array[Double]]] = Map( + [], + capacity=names.length(), + ) for name in names { match se_assay(experiment, name) { Some(assay) => assays[name] = assay @@ -567,6 +770,27 @@ fn rse_take_ranges(row_ranges : GRanges, indices : Array[Int]) -> GRanges { GRanges::{ seqnames, starts, ends, strands, widths } } +///| +fn rse_take_range_groups( + groups : GRangesList, + indices : Array[Int], +) -> GRangesList { + let elements = indices.map(fn(index) { + grl_copy_ranges(groups.elements[index]) + }) + let names = if groups.names.length() == 0 { + [] + } else { + indices.map(fn(index) { groups.names[index] }) + } + let metadata = if groups.element_metadata.length() == 0 { + [] + } else { + indices.map(fn(index) { groups.element_metadata[index] }) + } + grl_create_unchecked(elements, names, metadata) +} + ///| fn rse_take_maps( values : Array[Map[String, String]], diff --git a/test/moonbit/granges_list_test.mbt b/test/moonbit/granges_list_test.mbt new file mode 100644 index 00000000..ea6be3ca --- /dev/null +++ b/test/moonbit/granges_list_test.mbt @@ -0,0 +1,681 @@ +///| +fn grl_test_object() -> @src.GRangesList { + @src.granges_list( + [ + @src.granges(["chr1", "chr1"], [(100, 109), (200, 209)], [ + @src.strand_plus(), + @src.strand_plus(), + ]), + @src.granges(["chr1", "chr1"], [(150, 159), (300, 309)], [ + @src.strand_minus(), + @src.strand_minus(), + ]), + @src.granges_single("chr2", 50, 59, @src.strand_star()), + @src.granges([], [], []), + ], + names=["txA", "txB", "txC", "empty"], + element_metadata=[ + Map([("gene", "geneA")]), + Map([("gene", "geneB")]), + Map([("gene", "geneC")]), + Map([("gene", "none")]), + ], + ) catch { + _ => abort("failed to construct GRangesList fixture") + } +} + +///| +fn grl_test_subject() -> @src.GRanges { + @src.granges( + ["chr1", "chr1", "chr1", "chr2", "chr3"], + [(105, 205), (155, 156), (205, 206), (55, 55), (1, 10)], + [ + @src.strand_plus(), + @src.strand_minus(), + @src.strand_plus(), + @src.strand_star(), + @src.strand_plus(), + ], + ) +} + +///| +fn grl_test_experiment() -> @src.RangedSummarizedExperiment { + @src.RangedSummarizedExperiment::new_with_range_groups( + assays=Map([ + ("counts", [[10.0, 11.0], [20.0, 21.0], [30.0, 31.0], [40.0, 41.0]]), + ]), + row_range_groups=grl_test_object(), + col_data=[Map([("sample", "S1")]), Map([("sample", "S2")])], + row_names=["txA", "txB", "txC", "empty"], + metadata=Map([("organism", "human")]), + ) catch { + _ => abort("failed to construct grouped RangedSummarizedExperiment") + } +} + +///| +test "granges_list: construct and access" { + let ranges = grl_test_object() + assert_true(ranges.is_valid()) + assert_eq(ranges.length(), 4) + assert_eq(ranges.names(), ["txA", "txB", "txC", "empty"]) + assert_eq(ranges.element_lengths(), [2, 2, 1, 0]) + assert_eq(ranges.element_metadata()[1]["gene"], "geneB") + assert_false(ranges.is_empty()) + assert_eq(ranges.summary(), "GRangesList(4 elements, 5 ranges)") +} + +///| +test "granges_list: get by index and name returns ranges" { + let ranges = grl_test_object() + match ranges.get(1) { + Some(element) => { + assert_eq(element.starts, [150, 300]) + assert_true(element.strands == [@src.strand_minus(), @src.strand_minus()]) + } + None => assert_true(false) + } + match ranges.get_by_name("txC") { + Some(element) => assert_eq(element.seqnames, ["chr2"]) + None => assert_true(false) + } + assert_true(ranges.get(-1) is None) + assert_true(ranges.get_by_name("missing") is None) +} + +///| +test "granges_list: empty semantics include all-empty elements" { + let no_elements = @src.granges_list([]) catch { + _ => abort("empty list should be valid") + } + let empty_elements = @src.granges_list( + [@src.granges([], [], []), @src.granges([], [], [])], + names=["a", "b"], + ) catch { + _ => abort("all-empty list should be valid") + } + assert_true(no_elements.is_empty()) + assert_true(empty_elements.is_empty()) +} + +///| +test "granges_list: rejects outer dimension mismatch" { + let names_raised = try { + ignore( + @src.granges_list( + [@src.granges_single("chr1", 1, 2, @src.strand_plus())], + names=["a", "b"], + ), + ) + false + } catch { + GRangesListError(_) => true + } + let metadata_raised = try { + ignore( + @src.granges_list( + [@src.granges_single("chr1", 1, 2, @src.strand_plus())], + element_metadata=[Map([]), Map([])], + ), + ) + false + } catch { + GRangesListError(_) => true + } + assert_true(names_raised) + assert_true(metadata_raised) +} + +///| +test "granges_list: rejects malformed inner GRanges" { + let raised = try { + ignore( + @src.granges_list([ + @src.granges(["chr1", "chr2"], [(1, 10), (20, 30)], [@src.strand_plus()]), + ]), + ) + false + } catch { + GRangesListError(_) => true + } + assert_true(raised) +} + +///| +test "granges_list: split uses first-appearance group order" { + let flat = @src.granges( + ["chr1", "chr2", "chr1", "chr2", "chr1"], + [(1, 5), (10, 15), (20, 25), (30, 35), (40, 45)], + [ + @src.strand_plus(), + @src.strand_minus(), + @src.strand_plus(), + @src.strand_minus(), + @src.strand_plus(), + ], + ) + let split = @src.granges_split_as_list(flat, [ + "txB", "txA", "txB", "txA", "txC", + ]) + assert_eq(split.names(), ["txB", "txA", "txC"]) + assert_eq(split.element_lengths(), [2, 2, 1]) + match split.get_by_name("txB") { + Some(element) => assert_eq(element.starts, [1, 20]) + None => assert_true(false) + } +} + +///| +test "granges_list: split rejects group length mismatch" { + let raised = try { + ignore( + @src.granges_split_as_list( + @src.granges_single("chr1", 1, 10, @src.strand_plus()), + [], + ), + ) + false + } catch { + GRangesListError(_) => true + } + assert_true(raised) +} + +///| +test "granges_list: partition supports empty features" { + let flat = @src.granges( + ["chr1", "chr1", "chr2"], + [(1, 5), (10, 15), (20, 25)], + [@src.strand_plus(), @src.strand_plus(), @src.strand_minus()], + ) + let partitioned = @src.granges_list_from_partition(flat, [2, 0, 1], names=[ + "tx1", "empty", "tx2", + ]) + assert_eq(partitioned.element_lengths(), [2, 0, 1]) + match partitioned.get(1) { + Some(element) => assert_eq(@src.granges_length(element), 0) + None => assert_true(false) + } +} + +///| +test "granges_list: partition validates lengths" { + let flat = @src.granges_single("chr1", 1, 10, @src.strand_plus()) + let sum_raised = try { + ignore(@src.granges_list_from_partition(flat, [2])) + false + } catch { + GRangesListError(_) => true + } + let negative_raised = try { + ignore(@src.granges_list_from_partition(flat, [-1, 2])) + false + } catch { + GRangesListError(_) => true + } + assert_true(sum_raised) + assert_true(negative_raised) +} + +///| +test "granges_list: unlist preserves member order" { + let flat = grl_test_object().unlist() + assert_eq(flat.seqnames, ["chr1", "chr1", "chr1", "chr1", "chr2"]) + assert_eq(flat.starts, [100, 200, 150, 300, 50]) + assert_eq(flat.ends, [109, 209, 159, 309, 59]) +} + +///| +test "granges_list: unlist and relist round trip" { + let original = grl_test_object() + let rebuilt = original.relist(original.unlist()) + assert_eq(rebuilt.names(), original.names()) + assert_eq(rebuilt.element_lengths(), original.element_lengths()) + assert_eq(rebuilt.element_metadata()[2]["gene"], "geneC") + for index = 0; index < original.length(); index = index + 1 { + match (original.get(index), rebuilt.get(index)) { + (Some(left), Some(right)) => { + assert_eq(left.seqnames, right.seqnames) + assert_eq(left.starts, right.starts) + assert_eq(left.ends, right.ends) + assert_true(left.strands == right.strands) + } + _ => assert_true(false) + } + } +} + +///| +test "granges_list: relist rejects incompatible flat length" { + let raised = try { + ignore( + grl_test_object().relist( + @src.granges_single("chr1", 1, 10, @src.strand_plus()), + ), + ) + false + } catch { + GRangesListError(_) => true + } + assert_true(raised) +} + +///| +test "granges_list: subset coordinates names and metadata" { + let subset = grl_test_object().subset([2, 0, 2]) + assert_eq(subset.names(), ["txC", "txA", "txC"]) + assert_eq(subset.element_lengths(), [1, 2, 1]) + assert_eq(subset.element_metadata()[0]["gene"], "geneC") + assert_eq(subset.element_metadata()[1]["gene"], "geneA") +} + +///| +test "granges_list: invalid subset index raises" { + let raised = try { + ignore(grl_test_object().subset([4])) + false + } catch { + GRangesListError(_) => true + } + assert_true(raised) +} + +///| +test "granges_list: feature bounds summarize compound features" { + let bounds = grl_test_object().feature_bounds() + assert_eq(bounds.seqnames, ["chr1", "chr1", "chr2", ""]) + assert_eq(bounds.starts, [100, 150, 50, 0]) + assert_eq(bounds.ends, [209, 309, 59, -1]) + assert_eq(bounds.widths, [110, 160, 10, 0]) + assert_true(bounds.strands[0] == @src.strand_plus()) + assert_true(bounds.strands[1] == @src.strand_minus()) +} + +///| +test "granges_list: mixed feature bounds use wildcard identifiers" { + let mixed = @src.granges_list([ + @src.granges(["chr1", "chr2"], [(10, 20), (30, 40)], [ + @src.strand_plus(), + @src.strand_minus(), + ]), + ]) catch { + _ => abort("mixed feature should be valid") + } + let bounds = mixed.feature_bounds() + assert_eq(bounds.seqnames, ["*"]) + assert_true(bounds.strands == [@src.strand_star()]) + assert_eq(bounds.starts, [10]) + assert_eq(bounds.ends, [40]) +} + +///| +test "granges_list: concat appends outer elements" { + let left = grl_test_object().subset([0]) + let right = grl_test_object().subset([1, 2]) + let combined = left.concat(right) + assert_eq(combined.names(), ["txA", "txB", "txC"]) + assert_eq(combined.element_lengths(), [2, 2, 1]) + assert_eq(combined.element_metadata()[2]["gene"], "geneC") +} + +///| +test "granges_list: parallel concat combines corresponding features" { + let shifted = grl_test_object().shift(1000) + let combined = grl_test_object().parallel_concat(shifted) + assert_eq(combined.element_lengths(), [4, 4, 2, 0]) + match combined.get(0) { + Some(element) => assert_eq(element.starts, [100, 200, 1100, 1200]) + None => assert_true(false) + } +} + +///| +test "granges_list: parallel operations require equal element counts" { + let raised = try { + ignore(grl_test_object().parallel_concat(grl_test_object().subset([0, 1]))) + false + } catch { + GRangesListError(_) => true + } + assert_true(raised) +} + +///| +test "granges_list: intra-range operations preserve groups" { + let shifted = grl_test_object().shift(10) + let narrowed = grl_test_object().narrow(2, 5) + let resized = grl_test_object().resize(5, "start") + assert_eq(shifted.element_lengths(), [2, 2, 1, 0]) + match shifted.get(0) { + Some(element) => assert_eq(element.starts, [110, 210]) + None => assert_true(false) + } + match narrowed.get(0) { + Some(element) => { + assert_eq(element.starts, [101, 201]) + assert_eq(element.ends, [104, 204]) + } + None => assert_true(false) + } + match resized.get(1) { + Some(element) => assert_eq(element.ends, [154, 304]) + None => assert_true(false) + } +} + +///| +test "granges_list: flank and promoters preserve outer metadata" { + let flanked = grl_test_object().flank(5, true, false) + let promoted = grl_test_object().promoters(upstream=10, downstream=3) + assert_eq(flanked.names(), grl_test_object().names()) + assert_eq(promoted.element_metadata()[0]["gene"], "geneA") + match flanked.get(0) { + Some(element) => assert_eq(element.starts, [95, 195]) + None => assert_true(false) + } + match promoted.get(1) { + Some(element) => { + assert_eq(element.starts, [157, 307]) + assert_eq(element.ends, [169, 319]) + } + None => assert_true(false) + } +} + +///| +test "granges_list: promoters reject negative widths" { + let raised = try { + ignore(grl_test_object().promoters(upstream=-1)) + false + } catch { + GRangesListError(_) => true + } + assert_true(raised) +} + +///| +test "granges_list: reduce disjoin and sort operate per feature" { + let ranges = @src.granges_list( + [ + @src.granges(["chr1", "chr1", "chr1"], [(20, 30), (1, 10), (8, 15)], [ + @src.strand_plus(), + @src.strand_plus(), + @src.strand_plus(), + ]), + ], + names=["tx"], + ) catch { + _ => abort("failed to construct interval fixture") + } + match ranges.sort_ranges().get(0) { + Some(element) => assert_eq(element.starts, [1, 8, 20]) + None => assert_true(false) + } + match ranges.reduce().get(0) { + Some(element) => { + assert_eq(element.starts, [1, 20]) + assert_eq(element.ends, [15, 30]) + } + None => assert_true(false) + } + match ranges.disjoin().get(0) { + Some(element) => assert_eq(element.starts, [1, 8, 11, 16, 20]) + None => assert_true(false) + } +} + +///| +test "granges_list: width summaries exclude introns" { + assert_eq(grl_test_object().total_widths(), [20, 20, 10, 0]) +} + +///| +test "granges_list: parallel set operations preserve grouping" { + let left = @src.granges_list([ + @src.granges_single("chr1", 1, 10, @src.strand_star()), + @src.granges_single("chr2", 20, 30, @src.strand_star()), + ]) catch { + _ => abort("failed to build left set") + } + let right = @src.granges_list([ + @src.granges_single("chr1", 5, 15, @src.strand_star()), + @src.granges_single("chr2", 25, 35, @src.strand_star()), + ]) catch { + _ => abort("failed to build right set") + } + match left.parallel_union(right).get(0) { + Some(element) => { + assert_eq(element.starts, [1]) + assert_eq(element.ends, [15]) + } + None => assert_true(false) + } + match left.parallel_intersect(right).get(1) { + Some(element) => { + assert_eq(element.starts, [25]) + assert_eq(element.ends, [30]) + } + None => assert_true(false) + } + match left.parallel_setdiff(right).get(0) { + Some(element) => { + assert_eq(element.starts, [1]) + assert_eq(element.ends, [4]) + } + None => assert_true(false) + } +} + +///| +test "granges_list: feature overlaps are deduplicated and strand-aware" { + let ranges = grl_test_object() + let subject = grl_test_subject() + assert_eq(ranges.find_overlaps(subject), [(0, 0), (0, 2), (1, 1), (2, 3)]) + assert_eq(ranges.count_overlaps(subject), [2, 1, 1, 0]) + assert_eq(ranges.overlaps_any(subject), [true, true, true, false]) + assert_eq(ranges.find_overlaps(subject, ignore_strand=true), [ + (0, 0), + (0, 2), + (1, 0), + (1, 1), + (2, 3), + ]) +} + +///| +test "granges_list: subset by overlap keeps each feature once" { + let subset = grl_test_object().subset_by_overlaps(grl_test_subject()) + assert_eq(subset.names(), ["txA", "txB", "txC"]) + assert_eq(subset.element_lengths(), [2, 2, 1]) +} + +///| +test "granges_list: grouped subjects use feature indices" { + let subject = @src.granges_list( + [ + @src.granges(["chr1", "chr1"], [(105, 106), (205, 206)], [ + @src.strand_plus(), + @src.strand_plus(), + ]), + @src.granges_single("chr2", 55, 56, @src.strand_plus()), + ], + names=["feature1", "feature2"], + ) catch { + _ => abort("failed to construct grouped subject") + } + let query = grl_test_object() + assert_eq(query.find_group_overlaps(subject), [(0, 0), (2, 1)]) + assert_eq(query.count_group_overlaps(subject), [1, 0, 1, 0]) + assert_eq(@src.granges_find_overlaps_list(query.unlist(), subject), [ + (0, 0), + (1, 0), + (4, 1), + ]) +} + +///| +test "granges_list: nearest uses minimum member distance" { + let subject = @src.granges( + ["chr1", "chr1", "chr2"], + [(120, 125), (170, 175), (70, 75)], + [@src.strand_plus(), @src.strand_minus(), @src.strand_plus()], + ) + let ranges = grl_test_object() + assert_eq(ranges.nearest(subject), [0, 1, 2, -1]) + assert_eq(ranges.distance_to_nearest(subject), [10, 10, 10, -1]) +} + +///| +test "granges_list: coverage uses all member ranges" { + let coverage = grl_test_object().coverage(Map([("chr1", 320), ("chr2", 80)])) + assert_eq(coverage["chr1"][99], 1) + assert_eq(coverage["chr1"][149], 1) + assert_eq(coverage["chr1"][199], 1) + assert_eq(coverage["chr1"][299], 1) + assert_eq(coverage["chr1"][250], 0) + assert_eq(coverage["chr2"][49], 1) +} + +///| +test "grouped RangedSummarizedExperiment: construct and access" { + let experiment = grl_test_experiment() + assert_true(experiment.is_valid()) + assert_true(experiment.has_grouped_row_ranges()) + assert_eq(experiment.nrow(), 4) + assert_eq(experiment.ncol(), 2) + assert_eq(experiment.row_ranges().starts, [100, 150, 50, 0]) + assert_eq(experiment.row_ranges().ends, [209, 309, 59, -1]) + assert_eq(experiment.row_data()[0]["gene"], "geneA") + assert_eq(experiment.metadata()["organism"], "human") + assert_eq( + experiment.summary(), + "RangedSummarizedExperiment(4 range groups x 2 samples, assays=[counts])", + ) + match experiment.row_range_groups() { + Some(groups) => assert_eq(groups.element_lengths(), [2, 2, 1, 0]) + None => assert_true(false) + } +} + +///| +test "grouped RangedSummarizedExperiment: rejects assay mismatch" { + let raised = try { + ignore( + @src.RangedSummarizedExperiment::new_with_range_groups( + assays=Map([("counts", [[1.0], [2.0]])]), + row_range_groups=grl_test_object(), + col_data=[Map([])], + ), + ) + false + } catch { + RangedSummarizedExperimentError(_) => true + } + assert_true(raised) +} + +///| +test "grouped RangedSummarizedExperiment: exact overlaps avoid introns" { + let query = @src.granges( + ["chr1", "chr1", "chr1"], + [(120, 130), (205, 206), (250, 260)], + [@src.strand_plus(), @src.strand_plus(), @src.strand_minus()], + ) + let experiment = grl_test_experiment() + assert_eq(experiment.find_overlaps(query), [(0, 1)]) + assert_eq(experiment.count_overlaps(query), [1, 0, 0, 0]) +} + +///| +test "grouped RangedSummarizedExperiment: row subset stays coordinated" { + let subset = grl_test_experiment().subset_rows([2, 0, 2]) + assert_true(subset.is_valid()) + assert_eq(subset.row_names(), ["txC", "txA", "txC"]) + assert_eq(subset.row_data()[0]["gene"], "geneC") + match subset.row_range_groups() { + Some(groups) => { + assert_eq(groups.names(), ["txC", "txA", "txC"]) + assert_eq(groups.element_lengths(), [1, 2, 1]) + } + None => assert_true(false) + } + match subset.assay("counts") { + Some(assay) => assert_eq(assay, [[30.0, 31.0], [10.0, 11.0], [30.0, 31.0]]) + None => assert_true(false) + } +} + +///| +test "grouped RangedSummarizedExperiment: column subset preserves groups" { + let subset = grl_test_experiment().subset_cols([1]) + assert_true(subset.has_grouped_row_ranges()) + assert_eq(subset.ncol(), 1) + assert_eq(subset.col_data()[0]["sample"], "S2") + match subset.row_range_groups() { + Some(groups) => assert_eq(groups.element_lengths(), [2, 2, 1, 0]) + None => assert_true(false) + } +} + +///| +test "grouped RangedSummarizedExperiment: transformations preserve groups" { + let shifted = grl_test_experiment().shift(10) + let promoted = grl_test_experiment().promoters(upstream=10, downstream=3) + assert_true(shifted.has_grouped_row_ranges()) + assert_eq(shifted.row_ranges().starts, [110, 160, 60, 0]) + match shifted.row_range_groups() { + Some(groups) => + match groups.get(0) { + Some(element) => assert_eq(element.starts, [110, 210]) + None => assert_true(false) + } + None => assert_true(false) + } + match promoted.row_range_groups() { + Some(groups) => + match groups.get(1) { + Some(element) => assert_eq(element.starts, [157, 307]) + None => assert_true(false) + } + None => assert_true(false) + } +} + +///| +test "grouped RangedSummarizedExperiment: nearest and coverage use members" { + let subject = @src.granges( + ["chr1", "chr1", "chr2"], + [(120, 125), (170, 175), (70, 75)], + [@src.strand_plus(), @src.strand_minus(), @src.strand_plus()], + ) + let experiment = grl_test_experiment() + assert_eq(experiment.nearest(subject), [0, 1, 2, -1]) + assert_eq(experiment.distance_to_nearest(subject), [10, 10, 10, -1]) + let coverage = experiment.coverage(Map([("chr1", 320), ("chr2", 80)])) + assert_eq(coverage["chr1"][120], 0) + assert_eq(coverage["chr1"][199], 1) +} + +///| +test "grouped RangedSummarizedExperiment: flat replacement clears grouping" { + let flat = grl_test_experiment().with_row_ranges( + @src.granges( + ["chr1", "chr1", "chr2", "chr3"], + [(1, 10), (20, 30), (40, 50), (60, 70)], + [ + @src.strand_plus(), + @src.strand_minus(), + @src.strand_star(), + @src.strand_plus(), + ], + ), + ) + assert_false(flat.has_grouped_row_ranges()) + assert_true(flat.row_range_groups() is None) + assert_eq( + flat.summary(), + "RangedSummarizedExperiment(4 ranges x 2 samples, assays=[counts])", + ) +} From 47c39c2b4a17066d47a5be1b47a5c9a4f2a10f0c Mon Sep 17 00:00:00 2001 From: eda Date: Tue, 4 Aug 2026 16:45:16 +0800 Subject: [PATCH 06/41] #28 /8332 feat(hhr): Bio.Align.hhr HHsearch/HHblits --- README.md | 22 +- examples/hhr_demo/main.mbt | 66 ++ examples/hhr_demo/moon.pkg | 5 + src/hhr.mbt | 1657 ++++++++++++++++++++++++++++++++++++ test/moonbit/hhr_test.mbt | 386 +++++++++ 5 files changed, 2132 insertions(+), 4 deletions(-) create mode 100644 examples/hhr_demo/main.mbt create mode 100644 examples/hhr_demo/moon.pkg create mode 100644 src/hhr.mbt create mode 100644 test/moonbit/hhr_test.mbt diff --git a/README.md b/README.md index 5f67056f..81c560e2 100644 --- a/README.md +++ b/README.md @@ -31,6 +31,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **序列比对** | Biopython / scikit-bio | Needleman-Wunsch、Smith-Waterman、多序列比对、替换矩阵(BLOSUM/PAM) | ✅ | | **BLAST解析** | Biopython `Bio.Blast` | BLAST结果解析、tabular/xml格式、HSP过滤、最佳匹配 | ✅ | | **SearchIO** | Biopython `Bio.SearchIO` | 统一搜索结果模型、HMMER3解析、BLAT PSL解析、BLAST转换 | ✅ | +| **HH-suite HHR** | Biopython `Bio.Align.hhr` | HHsearch/HHblits HHR解析、profile-profile比对、命中筛选、坐标映射、序列化往返 | ✅ | | **系统发育树** | Biopython `Bio.Phylo` | 树结构、Newick 解析、距离计算、可视化 | ✅ | | **PDB 结构** | Biopython `Bio.PDB` | 原子/残基/链解析、结构操作 | ✅ | | **SAM/BAM/VCF** | pysam | 比对文件、变异检测、基因型查询 | ✅ | @@ -202,6 +203,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **ExPASy** | Biopython `Bio.ExPASy` | 蛋白质分析工具接口、Swiss-Prot条目解析、酶数据库查询、蛋白质参数计算（分子量、等电点、GRAVY、不稳定指数） | ✅ | | **Cellosaurus** | Biopython `Bio.ExPASy.cellosaurus` | Cellosaurus平面文本解析、类型化细胞系记录、数据库交叉引用、物种查询、序列化往返 | ✅ | | **UniGene** | Biopython `Bio.UniGene` | NCBI UniGene固定宽度记录解析、类型化序列/蛋白相似性/STS/转录本映射、严格SCOUNT校验、序列化往返 | ✅ | +| **HH-suite HHR** | Biopython `Bio.Align.hhr` | HHR元数据、命中摘要、多块profile比对、consensus/二级结构/DSSP/confidence注释、概率和E-value查询 | ✅ | | **Prosite** | Biopython `Bio.Prosite` | 蛋白质模体数据库搜索、Prosite模式解析、模体匹配算法、模体得分计算 | ✅ | | **PAML** | Biopython `Bio.PAML` | 分子进化分析、dN/dS计算（Nei-Gojobori方法）、Jukes-Cantor校正、密码子使用分析 | ✅ | | **Graphics** | Biopython `Bio.Graphics` | 生物信息学可视化、序列Logo绘制、序列比对可视化、基因组特征绘图 | ✅ | @@ -336,6 +338,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | BiocNeighbors | KMKNN和Annoy最近邻搜索，支持欧几里得/曼哈顿/余弦距离 | | ✅ | mixOmics | 多组学整合方法，包括PLS回归、稀疏PLS (sPLS)、DIABLO多块整合 | | **MAF格式解析** | Biopython `Bio.Align` | MAF多序列比对格式解析、块操作、百分比一致性、统计分析、选择/过滤/写回 | ✅ | +| **HH-suite HHR格式** | Biopython `Bio.Align.hhr` | HHsearch/HHblits结果严格解析、0-based坐标、query-target映射、规范化写回 | ✅ | | **UCSC Chain文件/liftOver** | Bioconductor rtracklayer | Chain格式解析、基因组坐标liftOver转换、链段查找、染色体间坐标映射、位置/区间转换 | ✅ | | **Biostrings matchPDict** | Bioconductor Biostrings | 字典模式匹配(matchPDict/vmatchPattern)、多序列模式计数(vcountPattern)、错配容忍、最佳匹配查找 | ✅ | | **GenomicRanges gaps/reduce/disjoin** | Bioconductor GenomicRanges | gaps检测、reduce合并、disjoin拆分、setdiff/交集/并集集合运算、coverage计算、promoters提取、trim | ✅ | @@ -723,6 +726,7 @@ IvanAXu/BioSeqs/ │ ├── transfac.mbt # Bio.Motifs.Transfac TRANSFAC转录因子结合谱解析 (PFM频率矩阵、AC/ID/DE/BF/CC字段、参考文献、共识序列) │ ├── hmmer_io.mbt # Bio.SearchIO.HmmerIO HMMER3输出解析 (domtblout域表、文本格式、Query/Hit/HSP/Domain聚合) │ ├── fasta_search_io.mbt # Bio.SearchIO.FastaIO FASTA搜索输出解析 (-m8紧凑表格、-m9带注释头、元数据提取) +│ ├── hhr.mbt # Bio.Align.hhr HH-suite HHR解析、命中查询、坐标映射与序列化 │ ├── gene_pop.mbt # Bio.PopGen.GenePop GenePop群体遗传学 (基因型解析、等位基因频率、杂合度、序列化往返) │ ├── stage_r.mbt # Bioconductor stageR 两阶段假设检验 (筛选+确认、Simes聚合、BH-FDR、Holm步降、OFDR控制) │ ├── enriched_heatmap.mbt # Bioconductor EnrichedHeatmap 基因组信号归一化 (窗口化、四种均值模式、行平滑、百分位裁剪) @@ -1054,6 +1058,7 @@ IvanAXu/BioSeqs/ │ ├── transfac_demo/ # TRANSFAC转录因子结合谱解析示例 (PFM矩阵、共识序列、频率计算、序列化、参考文献) │ ├── hmmer_io_demo/ # HMMER3输出解析示例 (domtblout域表、文本格式、Query/Hit/HSP聚合、多域比对) │ ├── fasta_search_io_demo/ # FASTA搜索输出解析示例 (-m8表格、-m9注释头、元数据、Query/Hit/HSP聚合) +│ ├── hhr_demo/ # HH-suite HHR解析、命中筛选、坐标映射与序列化往返示例 │ ├── gene_pop_demo/ # GenePop群体遗传学示例 (基因型解析、等位基因频率、杂合度统计、序列化往返) │ ├── stage_r_demo/ # stageR两阶段检验示例 (筛选+确认、Simes聚合、BH-FDR、Holm步降、OFDR控制) │ ├── enriched_heatmap_demo/ # EnrichedHeatmap富集热图示例 (信号归一化、四种均值模式、行平滑、链方向处理) @@ -1386,6 +1391,7 @@ IvanAXu/BioSeqs/ │ │ ├── transfac_full_test.mbt │ │ ├── hmmer_io_test.mbt │ │ ├── fasta_search_io_test.mbt +│ │ ├── hhr_test.mbt │ │ ├── gene_pop_test.mbt │ │ ├── stage_r_test.mbt │ │ ├── enriched_heatmap_test.mbt @@ -1420,7 +1426,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8299 个测试全部通过 +moon test # ✅ 8332 个测试全部通过 ``` ### 模块对照表 @@ -1464,6 +1470,7 @@ moon test # ✅ 8299 个测试全 | `align_abstract.mbt` | BioPython `Bio.Align.AlignAbstract` | 抽象比对类型、Shannon熵、同一性矩阵、简约信息位点 | | `codon_align.mbt` | BioPython `Bio.codonalign` | 密码子比对与 dN/dS 分析 | | `searchio.mbt` | BioPython `Bio.SearchIO` | 统一搜索结果模型、BLAST/HMMER解析、E-value过滤 | +| `hhr.mbt` | BioPython `Bio.Align.hhr` | HHsearch/HHblits HHR解析、profile比对注释、命中筛选、坐标映射与规范序列化 | #### 系统发育树 @@ -2745,6 +2752,10 @@ moon test # ✅ 8299 个测试全 实现 Bioconductor `GenomicRanges::GRangesList` 的复合特征语义，每个命名外层元素保存一组 `GRanges`，适合表示转录本-外显子、基因-调控区等一对多结构。构造器严格校验外层名称、元素元数据和内部范围维度；`granges_split_as_list` 按首次出现顺序分组，`granges_list_from_partition` 按元素长度分区，`unlist` 展平成单个 `GRanges`，`relist` 按原分区重建并保留名称和元数据。`subset`、`concat`、`parallel_concat` 支持外层选择和组合；`shift`、`narrow`、`resize`、`flank`、`promoters`、`reduce`、`disjoin` 和 `sort_ranges` 逐元素执行，`parallel_union`、`parallel_intersect` 和 `parallel_setdiff` 提供同位置元素间集合运算。`find_overlaps`、`count_overlaps`、`overlaps_any` 和分组对分组查询返回外层复合特征索引，并对同一特征的多个成员命中去重；`nearest`、`distance_to_nearest` 和 `coverage` 基于所有真实成员范围计算。`feature_bounds` 仅用于生成每个复合特征的协调外接范围，不替代精确区间计算。 +### 241. HH-suite HHR profile-profile 比对解析 (Bio.Align.hhr) + +实现与 Biopython `Bio.Align.hhr` 对应的 HHsearch/HHblits HHR 文本解析。`hhr_parse` 读取查询元数据、命中摘要表和多块 profile-profile 比对，使用 Biopython 风格的 0-based、end-exclusive 坐标，并保留 query/target consensus、预测二级结构、DSSP、逐列分数和 confidence。`HhrRecord` 支持按 target 查询、probability/E-value 过滤和最佳命中选择；`HhrAlignment` 提供去 gap 序列、identity/coverage 统计、`query_to_target` 坐标映射和 `aligned_pairs`。解析器严格校验 rank、摘要与详情数量、坐标跨度、跨块连续性、比对宽度、`Aligned_cols` 和终止标记，兼容 CRLF、无空行的官方布局、零命中及 EOF 结束的完整末块。`to_string` 生成规范 HHR 文本并支持解析-序列化往返；格式错误抛出 `HhrError`。 + ## 性能优化 ### 优化策略 @@ -2846,8 +2857,8 @@ moon test # ✅ 8299 个测试全 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8299 | -| 通过数 | 8299 | +| 总测试数 | 8332 | +| 通过数 | 8332 | | 失败数 | 0 | | 通过率 | 100% | @@ -2948,6 +2959,7 @@ moon test --update | SwissProt | `swissprot_test.mbt` | 8 | | Cellosaurus | `cellosaurus_test.mbt` | 16 | | UniGene | `unigene_test.mbt` | 23 | +| Bio.Align.hhr | `hhr_test.mbt` | 33 | | mmCIF | `mmcif_test.mbt` | 2 | | Nexus | `nexus_test.mbt` | 2 | | EMBOSS | `emboss_test.mbt` | 15 | @@ -3236,7 +3248,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 346 个示例程序，展示各模块的典型用法： +项目提供 349 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3310,6 +3322,7 @@ moon run cmd/bench/main.mbt | swissprot_demo | SwissProt 蛋白数据库解析（记录解析、特征提取、参考文献） | `moon run examples/swissprot_demo/main.mbt` | | cellosaurus_demo | Cellosaurus细胞系记录解析、物种/同义名/交叉引用查询和序列化往返 | `moon run examples/cellosaurus_demo/main.mbt` | | unigene_demo | NCBI UniGene cluster解析、序列/蛋白相似性/STS/转录本映射查询和序列化往返 | `moon run examples/unigene_demo/main.mbt` | +| hhr_demo | HH-suite HHR元数据与profile比对解析、命中筛选、query-target坐标映射和序列化往返 | `moon run examples/hhr_demo` | | uniprot_io_demo | UniProt XML格式解析（蛋白质条目解析、功能注释提取、序列转换） | `moon run examples/uniprot_io_demo/main.mbt` | | chem_utils_demo | 化学计算工具（键长、键角、二面角、分子式量、氢键长度） | `moon run examples/chem_utils_demo/main.mbt` | | jaspar_demo | JASPAR PFM格式解析（模体矩阵解析、共有序列、PWM转换、序列扫描） | `moon run examples/jaspar_demo/main.mbt` | @@ -3510,6 +3523,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 SwissProt 蛋白数据库解析（记录解析、特征提取、参考文献） - ✅ 实现 Cellosaurus 细胞系数据库解析（多记录读取、交叉引用/物种查询、平面文本序列化） - ✅ 实现 UniGene 基因聚类记录解析（固定宽度多记录读取、类型化子记录查询、SCOUNT校验、平面文本序列化） +- ✅ 实现 Bio.Align.hhr HH-suite HHR解析（元数据、命中摘要、多块profile比对、注释保留、过滤、坐标映射与序列化） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/hhr_demo/main.mbt b/examples/hhr_demo/main.mbt new file mode 100644 index 00000000..f9a5eef2 --- /dev/null +++ b/examples/hhr_demo/main.mbt @@ -0,0 +1,66 @@ +///| +fn main { + println("=== Biopython Bio.Align.hhr Demo ===") + + let record = @src.hhr_parse(@src.hhr_sample_text()) catch { + _ => abort("failed to parse HHR sample") + } + + println("\n1. HH-suite run metadata") + println(" " + record.summary()) + println(" Effective sequences: " + record.metadata.neff.to_string()) + println(" Searched HMMs: " + record.metadata.searched_hmms.to_string()) + + println("\n2. Ranked profile hits") + for alignment in record.alignments { + println(" " + alignment.summary()) + println( + " query/target coverage: " + + alignment.query_coverage().to_string() + + " / " + + alignment.target_coverage().to_string(), + ) + } + + println("\n3. Filtering and target lookup") + let confident = record.filter_by_probability(90.0) + println(" Hits with probability >= 90%: " + confident.length().to_string()) + match record.find_target("target_B") { + Some(alignment) => + println( + " target_B aligned query: " + + alignment.query_sequence + + "\n target_B aligned target: " + + alignment.target_sequence, + ) + None => abort("missing target_B") + } + + println("\n4. Coordinate mapping") + match record.best_alignment() { + Some(alignment) => { + println(" Best hit: " + alignment.target_name) + match alignment.query_to_target(3) { + Some(target_position) => + println( + " Query position 3 maps to target position " + + target_position.to_string() + + " (zero-based)", + ) + None => println(" Query position 3 maps to a target gap") + } + println(" Preserved confidence columns: " + alignment.confidence) + } + None => abort("missing best alignment") + } + + println("\n5. Canonical serialization") + let serialized = record.to_string() + let reparsed = @src.hhr_parse(serialized) catch { + _ => abort("failed to reparse canonical HHR") + } + println(" Serialized bytes: " + serialized.length().to_string()) + println(" Round trip preserved record: " + (record == reparsed).to_string()) + + println("\n=== Demo Complete ===") +} diff --git a/examples/hhr_demo/moon.pkg b/examples/hhr_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/hhr_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/hhr.mbt b/src/hhr.mbt new file mode 100644 index 00000000..1284fc74 --- /dev/null +++ b/src/hhr.mbt @@ -0,0 +1,1657 @@ +///| +/// Parser and data model for HH-suite HHR output. +/// +/// Mirrors the semantics of Biopython's `Bio.Align.hhr` module. An HHR file +/// describes one query profile and a ranked collection of pairwise +/// profile-profile alignments produced by HHsearch or HHblits. + +///| +/// Error raised for malformed or inconsistent HHR input. +pub suberror HhrError { + HhrError(String) +} + +///| +/// File-level metadata from the HHR header. +pub struct HhrMetadata { + query_name : String + match_columns : Int + sequence_count : Int + sequence_count_total : Int + neff : Double + template_neff : Double? + searched_hmms : Int + run_date : String + command_line : String +} derive(Eq) + +///| +/// Create HHR file-level metadata. +pub fn HhrMetadata::new( + query_name~ : String, + match_columns~ : Int, + sequence_count? : Int = 0, + sequence_count_total? : Int = 0, + neff? : Double = 0.0, + template_neff? : Double? = None, + searched_hmms? : Int = 0, + run_date? : String = "", + command_line? : String = "", +) -> HhrMetadata { + HhrMetadata::{ + query_name, + match_columns, + sequence_count, + sequence_count_total, + neff, + template_neff, + searched_hmms, + run_date, + command_line, + } +} + +///| +/// A row in the ranked HHR hit summary table. +/// +/// Coordinates are 0-based and end-exclusive, matching Biopython's alignment +/// coordinate convention. +pub struct HhrHitSummary { + rank : Int + target_name : String + description : String + probability : Double + evalue : Double + pvalue : Double + score : Double + secondary_structure_score : Double + aligned_columns : Int + query_start : Int + query_end : Int + target_start : Int + target_end : Int + target_length : Int +} derive(Eq) + +///| +/// One detailed pairwise profile alignment from an HHR file. +/// +/// Sequence and annotation strings contain alignment gaps and therefore all +/// non-empty annotation strings have the same length as `query_sequence`. +pub struct HhrAlignment { + rank : Int + query_name : String + query_length : Int + target_name : String + target_description : String + target_length : Int + probability : Double + evalue : Double + pvalue : Double + score : Double + secondary_structure_score : Double + identities : Double + similarity : Double + sum_probabilities : Double + aligned_columns : Int + query_start : Int + query_end : Int + target_start : Int + target_end : Int + query_sequence : String + target_sequence : String + query_consensus : String + target_consensus : String + query_secondary_structure : String + target_secondary_structure : String + target_dssp : String + column_score : String + confidence : String +} derive(Eq) + +///| +/// A complete HHR document. +pub struct HhrRecord { + metadata : HhrMetadata + hit_summaries : Array[HhrHitSummary] + alignments : Array[HhrAlignment] +} derive(Eq) + +///| +/// Return the number of detailed hit alignments. +pub fn HhrRecord::num_hits(self : HhrRecord) -> Int { + self.alignments.length() +} + +///| +/// Return an alignment by zero-based result index. +pub fn HhrRecord::get(self : HhrRecord, index : Int) -> HhrAlignment? { + if index < 0 || index >= self.alignments.length() { + None + } else { + Some(self.alignments[index]) + } +} + +///| +/// Return all alignments for a target identifier. +/// +/// HH-suite can report multiple local alignments for the same target. +pub fn HhrRecord::alignments_for_target( + self : HhrRecord, + target_name : String, +) -> Array[HhrAlignment] { + let result : Array[HhrAlignment] = [] + for alignment in self.alignments { + if alignment.target_name == target_name { + result.push(alignment) + } + } + result +} + +///| +/// Return the first ranked alignment for a target identifier. +pub fn HhrRecord::find_target( + self : HhrRecord, + target_name : String, +) -> HhrAlignment? { + for alignment in self.alignments { + if alignment.target_name == target_name { + return Some(alignment) + } + } + None +} + +///| +/// Return the best alignment by probability, then E-value, then rank. +pub fn HhrRecord::best_alignment(self : HhrRecord) -> HhrAlignment? { + if self.alignments.length() == 0 { + return None + } + let mut best = self.alignments[0] + for i = 1; i < self.alignments.length(); i = i + 1 { + let candidate = self.alignments[i] + if candidate.probability > best.probability || + ( + candidate.probability == best.probability && + candidate.evalue < best.evalue + ) || + ( + candidate.probability == best.probability && + candidate.evalue == best.evalue && + candidate.rank < best.rank + ) { + best = candidate + } + } + Some(best) +} + +///| +/// Return alignments whose HH-suite probability meets a minimum percentage. +pub fn HhrRecord::filter_by_probability( + self : HhrRecord, + minimum : Double, +) -> Array[HhrAlignment] { + let result : Array[HhrAlignment] = [] + for alignment in self.alignments { + if alignment.probability >= minimum { + result.push(alignment) + } + } + result +} + +///| +/// Return alignments whose E-value does not exceed a threshold. +pub fn HhrRecord::filter_by_evalue( + self : HhrRecord, + maximum : Double, +) -> Array[HhrAlignment] { + let result : Array[HhrAlignment] = [] + for alignment in self.alignments { + if alignment.evalue <= maximum { + result.push(alignment) + } + } + result +} + +///| +/// Return the number of alignment columns, including gap columns. +pub fn HhrAlignment::alignment_length(self : HhrAlignment) -> Int { + self.query_sequence.length() +} + +///| +/// Return the aligned query sequence without gaps. +pub fn HhrAlignment::ungapped_query(self : HhrAlignment) -> String { + hhr_remove_gaps(self.query_sequence) +} + +///| +/// Return the aligned target sequence without gaps. +pub fn HhrAlignment::ungapped_target(self : HhrAlignment) -> String { + hhr_remove_gaps(self.target_sequence) +} + +///| +/// Return exact identical residue columns, excluding gaps. +pub fn HhrAlignment::identity_count(self : HhrAlignment) -> Int { + let mut count = 0 + for i = 0; i < self.query_sequence.length(); i = i + 1 { + let query = self.query_sequence.unsafe_get(i).to_int() + let target = self.target_sequence.unsafe_get(i).to_int() + if query != '-'.to_int() && target != '-'.to_int() && query == target { + count = count + 1 + } + } + count +} + +///| +/// Return query coverage as aligned query residues divided by query length. +pub fn HhrAlignment::query_coverage(self : HhrAlignment) -> Double { + if self.query_length <= 0 { + 0.0 + } else { + (self.query_end - self.query_start).to_double() / + self.query_length.to_double() + } +} + +///| +/// Return target coverage as aligned target residues divided by target length. +pub fn HhrAlignment::target_coverage(self : HhrAlignment) -> Double { + if self.target_length <= 0 { + 0.0 + } else { + (self.target_end - self.target_start).to_double() / + self.target_length.to_double() + } +} + +///| +/// Map an absolute zero-based query position to its aligned target position. +/// +/// Returns `None` when the query position is outside this local alignment or +/// is aligned to a target gap. +pub fn HhrAlignment::query_to_target( + self : HhrAlignment, + query_position : Int, +) -> Int? { + if query_position < self.query_start || query_position >= self.query_end { + return None + } + let mut query_coordinate = self.query_start + let mut target_coordinate = self.target_start + for i = 0; i < self.query_sequence.length(); i = i + 1 { + let query_gap = self.query_sequence.unsafe_get(i).to_int() == '-'.to_int() + let target_gap = self.target_sequence.unsafe_get(i).to_int() == '-'.to_int() + if !query_gap && query_coordinate == query_position { + if target_gap { + return None + } + return Some(target_coordinate) + } + if !query_gap { + query_coordinate = query_coordinate + 1 + } + if !target_gap { + target_coordinate = target_coordinate + 1 + } + } + None +} + +///| +/// Return per-column absolute coordinates. +/// +/// A gap is represented by `None`; residue coordinates are zero-based. +pub fn HhrAlignment::aligned_pairs(self : HhrAlignment) -> Array[(Int?, Int?)] { + let pairs : Array[(Int?, Int?)] = [] + let mut query_coordinate = self.query_start + let mut target_coordinate = self.target_start + for i = 0; i < self.query_sequence.length(); i = i + 1 { + let query_gap = self.query_sequence.unsafe_get(i).to_int() == '-'.to_int() + let target_gap = self.target_sequence.unsafe_get(i).to_int() == '-'.to_int() + let query_value : Int? = if query_gap { + None + } else { + Some(query_coordinate) + } + let target_value : Int? = if target_gap { + None + } else { + Some(target_coordinate) + } + pairs.push((query_value, target_value)) + if !query_gap { + query_coordinate = query_coordinate + 1 + } + if !target_gap { + target_coordinate = target_coordinate + 1 + } + } + pairs +} + +///| +/// Return a compact alignment summary. +pub fn HhrAlignment::summary(self : HhrAlignment) -> String { + "HhrAlignment(rank=" + + self.rank.to_string() + + ", target=" + + self.target_name + + ", probability=" + + self.probability.to_string() + + ", evalue=" + + self.evalue.to_string() + + ", columns=" + + self.aligned_columns.to_string() + + ")" +} + +///| +/// Return a compact document summary. +pub fn HhrRecord::summary(self : HhrRecord) -> String { + "HhrRecord(query=" + + self.metadata.query_name + + ", columns=" + + self.metadata.match_columns.to_string() + + ", hits=" + + self.alignments.length().to_string() + + ")" +} + +///| +/// Parse one HHsearch or HHblits HHR document. +/// +/// The parser validates header keys, contiguous ranks, summary/detail +/// agreement, block widths, coordinates, full sequence lengths, and all +/// per-column annotation lengths. +pub fn hhr_parse(text : String) -> HhrRecord raise HhrError { + let lines = hhr_normalize_lines(text) + if lines.length() == 0 { + raise HhrError("Empty HHR input") + } + let expected_header = [ + "No", "Hit", "Prob", "E-value", "P-value", "Score", "SS", "Cols", "Query", "HMM", + "Template", "HMM", + ] + let mut index = 0 + let mut query_name = "" + let mut match_columns = -1 + let mut sequence_count = 0 + let mut sequence_count_total = 0 + let mut neff = 0.0 + let mut template_neff : Double? = None + let mut searched_hmms = 0 + let mut run_date = "" + let mut command_line = "" + while index < lines.length() && lines[index].trim().length() > 0 { + if hhr_split_whitespace(lines[index]) == expected_header { + break + } + let line = lines[index].trim().to_owned() + let split = hhr_first_whitespace(line) + if split is None { + raise HhrError("Malformed HHR header at line " + (index + 1).to_string()) + } + let (key, value) = split.unwrap() + match key { + "Query" => query_name = value + "Match_columns" => + match_columns = hhr_parse_nonnegative_int( + value, + "Match_columns", + index + 1, + ) + "No_of_seqs" => { + let marker = " out of " + let marker_index = hhr_find_substring(value, marker) + if marker_index < 0 { + raise HhrError( + "Malformed No_of_seqs at line " + (index + 1).to_string(), + ) + } + sequence_count = hhr_parse_nonnegative_int( + value[0:marker_index].to_owned(), + "No_of_seqs", + index + 1, + ) + sequence_count_total = hhr_parse_nonnegative_int( + value[marker_index + marker.length():].to_owned(), + "No_of_seqs total", + index + 1, + ) + } + "Neff" => neff = hhr_parse_number(value, "Neff", index + 1) + "Template_Neff" => + template_neff = Some( + hhr_parse_number(value, "Template_Neff", index + 1), + ) + "Searched_HMMs" => + searched_hmms = hhr_parse_nonnegative_int( + value, + "Searched_HMMs", + index + 1, + ) + "Date" => run_date = value + "Command" => command_line = value + _ => raise HhrError("Unknown HHR header key '" + key + "'") + } + index = index + 1 + } + if query_name.length() == 0 { + raise HhrError("HHR header is missing Query") + } + if match_columns < 0 { + raise HhrError("HHR header is missing Match_columns") + } + while index < lines.length() && lines[index].trim().length() == 0 { + index = index + 1 + } + if index >= lines.length() { + raise HhrError("Truncated HHR file before hit table") + } + let table_header = hhr_split_whitespace(lines[index]) + if table_header != expected_header { + raise HhrError("Invalid HHR hit table header") + } + index = index + 1 + let hit_summaries : Array[HhrHitSummary] = [] + while index < lines.length() { + let trimmed = lines[index].trim().to_owned() + if trimmed.length() == 0 { + index = index + 1 + break + } + if hhr_is_rank_line(trimmed) || trimmed == "Done!" { + break + } + let summary = hhr_parse_hit_summary( + lines[index], + hit_summaries.length() + 1, + index + 1, + ) + hit_summaries.push(summary) + index = index + 1 + } + while index < lines.length() && lines[index].trim().length() == 0 { + index = index + 1 + } + let alignments : Array[HhrAlignment] = [] + let mut current : HhrAlignmentBuilder? = None + let mut found_done = false + while index < lines.length() { + let line = lines[index] + let trimmed = line.trim().to_owned() + if trimmed.length() == 0 { + index = index + 1 + continue + } + if trimmed == "Done!" { + match current { + Some(builder) => { + alignments.push( + hhr_finish_alignment( + builder, query_name, match_columns, hit_summaries, + ), + ) + current = None + } + None => () + } + found_done = true + index = index + 1 + while index < lines.length() { + if lines[index].trim().length() > 0 { + raise HhrError("Additional data found after Done!") + } + index = index + 1 + } + break + } + if hhr_has_prefix(trimmed, "No ") { + match current { + Some(builder) => + alignments.push( + hhr_finish_alignment( + builder, query_name, match_columns, hit_summaries, + ), + ) + None => () + } + let words = hhr_split_whitespace(trimmed) + if words.length() != 2 || words[0] != "No" { + raise HhrError( + "Malformed alignment rank at line " + (index + 1).to_string(), + ) + } + let rank = hhr_parse_nonnegative_int( + words[1], + "alignment rank", + index + 1, + ) + if rank != alignments.length() + 1 { + raise HhrError( + "Non-contiguous alignment rank at line " + (index + 1).to_string(), + ) + } + current = Some(HhrAlignmentBuilder::new(rank)) + index = index + 1 + continue + } + let builder = match current { + Some(value) => value + None => + raise HhrError( + "Alignment content before a No line at line " + + (index + 1).to_string(), + ) + } + if hhr_has_prefix(line, ">") { + if builder.target_name.length() > 0 { + raise HhrError( + "Duplicate target header at line " + (index + 1).to_string(), + ) + } + let target_header = line[1:].trim().to_owned() + let split = hhr_first_whitespace(target_header) + match split { + Some((name, description)) => { + builder.target_name = name + builder.target_description = description + } + None => builder.target_name = target_header + } + } else if hhr_has_prefix(trimmed, "Probab=") { + hhr_parse_alignment_statistics(builder, trimmed, index + 1) + } else if hhr_has_prefix(line, "Q ss_pred ") { + builder.query_secondary_structure = builder.query_secondary_structure + + hhr_last_token(line, "query ss_pred", index + 1) + } else if hhr_has_prefix(line, "Q Consensus ") { + let part = hhr_parse_sequence_line(line, "Q Consensus", index + 1) + builder.query_consensus = builder.query_consensus + part.sequence + builder.block_width = part.sequence.length() + } else if hhr_has_prefix(line, "Q ") { + let part = hhr_parse_sequence_line(line, "Q", index + 1) + if builder.query_start < 0 { + builder.query_start = part.start + } else if part.start != builder.query_end { + raise HhrError( + "Discontinuous query coordinates at line " + (index + 1).to_string(), + ) + } + builder.query_end = part.end + if builder.query_length == 0 { + builder.query_length = part.total + } else if builder.query_length != part.total { + raise HhrError( + "Inconsistent query length at line " + (index + 1).to_string(), + ) + } + builder.query_sequence = builder.query_sequence + part.sequence + builder.block_width = part.sequence.length() + } else if hhr_has_prefix(line, "T ss_pred ") { + builder.target_secondary_structure = builder.target_secondary_structure + + hhr_last_token(line, "target ss_pred", index + 1) + } else if hhr_has_prefix(line, "T ss_dssp ") { + builder.target_dssp = builder.target_dssp + + hhr_last_token(line, "target ss_dssp", index + 1) + } else if hhr_has_prefix(line, "T Consensus ") { + let part = hhr_parse_sequence_line(line, "T Consensus", index + 1) + builder.target_consensus = builder.target_consensus + part.sequence + builder.block_width = part.sequence.length() + } else if hhr_has_prefix(line, "T ") { + let part = hhr_parse_sequence_line(line, "T", index + 1) + if builder.detail_target_name.length() == 0 { + builder.detail_target_name = part.name + } else if builder.detail_target_name != part.name { + raise HhrError( + "Inconsistent target name at line " + (index + 1).to_string(), + ) + } + if builder.target_start < 0 { + builder.target_start = part.start + } else if part.start != builder.target_end { + raise HhrError( + "Discontinuous target coordinates at line " + (index + 1).to_string(), + ) + } + builder.target_end = part.end + if builder.target_length == 0 { + builder.target_length = part.total + } else if builder.target_length != part.total { + raise HhrError( + "Inconsistent target length at line " + (index + 1).to_string(), + ) + } + builder.target_sequence = builder.target_sequence + part.sequence + builder.block_width = part.sequence.length() + } else if hhr_has_prefix(line, "Confidence") { + if builder.block_width <= 0 { + raise HhrError( + "Confidence before alignment block at line " + (index + 1).to_string(), + ) + } + builder.confidence = builder.confidence + + hhr_suffix(line, builder.block_width, "Confidence", index + 1) + } else if hhr_is_indented(line) { + if builder.block_width <= 0 { + raise HhrError( + "Column score before alignment block at line " + + (index + 1).to_string(), + ) + } + builder.column_score = builder.column_score + + hhr_suffix(line, builder.block_width, "column score", index + 1) + } else { + raise HhrError( + "Failed to parse HHR line " + (index + 1).to_string() + ": " + trimmed, + ) + } + index = index + 1 + } + if !found_done { + match current { + Some(builder) => + alignments.push( + hhr_finish_alignment( + builder, query_name, match_columns, hit_summaries, + ), + ) + None => () + } + } + if alignments.length() != hit_summaries.length() { + raise HhrError( + "Expected " + + hit_summaries.length().to_string() + + " alignments, found " + + alignments.length().to_string(), + ) + } + let metadata = HhrMetadata::new( + query_name~, + match_columns~, + sequence_count~, + sequence_count_total~, + neff~, + template_neff~, + searched_hmms~, + run_date~, + command_line~, + ) + HhrRecord::{ metadata, hit_summaries, alignments } +} + +///| +/// Serialize a parsed HHR document to a canonical, parseable HHR form. +pub fn HhrRecord::to_string(self : HhrRecord) -> String { + let output = StringBuilder::new() + output.write_string("Query " + self.metadata.query_name + "\n") + output.write_string( + "Match_columns " + self.metadata.match_columns.to_string() + "\n", + ) + output.write_string( + "No_of_seqs " + + self.metadata.sequence_count.to_string() + + " out of " + + self.metadata.sequence_count_total.to_string() + + "\n", + ) + output.write_string("Neff " + self.metadata.neff.to_string() + "\n") + match self.metadata.template_neff { + Some(value) => + output.write_string("Template_Neff " + value.to_string() + "\n") + None => () + } + output.write_string( + "Searched_HMMs " + self.metadata.searched_hmms.to_string() + "\n", + ) + if self.metadata.run_date.length() > 0 { + output.write_string("Date " + self.metadata.run_date + "\n") + } + if self.metadata.command_line.length() > 0 { + output.write_string("Command " + self.metadata.command_line + "\n") + } + output.write_string("\n") + output.write_string( + " No Hit Prob E-value P-value Score SS Cols Query HMM Template HMM\n", + ) + for summary in self.hit_summaries { + let description = if summary.description.length() > 0 { + " " + summary.description + } else { + "" + } + output.write_string( + " " + + summary.rank.to_string() + + " " + + summary.target_name + + description + + " " + + summary.probability.to_string() + + " " + + summary.evalue.to_string() + + " " + + summary.pvalue.to_string() + + " " + + summary.score.to_string() + + " " + + summary.secondary_structure_score.to_string() + + " " + + summary.aligned_columns.to_string() + + " " + + (summary.query_start + 1).to_string() + + "-" + + summary.query_end.to_string() + + " " + + (summary.target_start + 1).to_string() + + "-" + + summary.target_end.to_string() + + " (" + + summary.target_length.to_string() + + ")\n", + ) + } + output.write_string("\n") + for alignment in self.alignments { + output.write_string("No " + alignment.rank.to_string() + "\n") + output.write_string(">" + alignment.target_name) + if alignment.target_description.length() > 0 { + output.write_string(" " + alignment.target_description) + } + output.write_string("\n") + output.write_string( + "Probab=" + + alignment.probability.to_string() + + " E-value=" + + alignment.evalue.to_string() + + " Score=" + + alignment.score.to_string() + + " Aligned_cols=" + + alignment.aligned_columns.to_string() + + " Identities=" + + alignment.identities.to_string() + + "% Similarity=" + + alignment.similarity.to_string() + + " Sum_probs=" + + alignment.sum_probabilities.to_string() + + "\n", + ) + if alignment.query_secondary_structure.length() > 0 { + output.write_string( + "Q ss_pred " + alignment.query_secondary_structure + "\n", + ) + } + output.write_string( + "Q " + + alignment.query_name + + " " + + (alignment.query_start + 1).to_string() + + " " + + alignment.query_sequence + + " " + + alignment.query_end.to_string() + + " (" + + alignment.query_length.to_string() + + ")\n", + ) + if alignment.query_consensus.length() > 0 { + output.write_string( + "Q Consensus " + + (alignment.query_start + 1).to_string() + + " " + + alignment.query_consensus + + " " + + alignment.query_end.to_string() + + " (" + + alignment.query_length.to_string() + + ")\n", + ) + } + if alignment.column_score.length() > 0 { + output.write_string( + " " + alignment.column_score + "\n", + ) + } + if alignment.target_consensus.length() > 0 { + output.write_string( + "T Consensus " + + (alignment.target_start + 1).to_string() + + " " + + alignment.target_consensus + + " " + + alignment.target_end.to_string() + + " (" + + alignment.target_length.to_string() + + ")\n", + ) + } + output.write_string( + "T " + + alignment.target_name + + " " + + (alignment.target_start + 1).to_string() + + " " + + alignment.target_sequence + + " " + + alignment.target_end.to_string() + + " (" + + alignment.target_length.to_string() + + ")\n", + ) + if alignment.target_dssp.length() > 0 { + output.write_string("T ss_dssp " + alignment.target_dssp + "\n") + } + if alignment.target_secondary_structure.length() > 0 { + output.write_string( + "T ss_pred " + alignment.target_secondary_structure + "\n", + ) + } + if alignment.confidence.length() > 0 { + output.write_string("Confidence " + alignment.confidence + "\n") + } + } + output.write_string("Done!\n") + output.to_string() +} + +///| +/// Return a compact two-hit HHR document for examples and tests. +pub fn hhr_sample_text() -> String { + "Query demo_query\n" + + "Match_columns 12\n" + + "No_of_seqs 24 out of 40\n" + + "Neff 3.5\n" + + "Template_Neff 2.1\n" + + "Searched_HMMs 2\n" + + "Date Tue Aug 4 12:00:00 2026\n" + + "Command hhsearch -i demo.a3m -d pdb70\n" + + " No Hit Prob E-value P-value Score SS Cols Query HMM Template HMM\n" + + " 1 target_A Alpha beta enzyme 99.8 1.2E-20 4.0E-25 85.4 2.1 10 1-12 5-14 (40)\n" + + " 2 target_B Membrane protein 72.5 0.004 2.0E-6 31.2 0.0 8 3-10 2-9 (20)\n" + + "No 1\n" + + ">target_A Alpha beta enzyme\n" + + "Probab=99.8 E-value=1.2e-20 Score=85.4 Aligned_cols=10 Identities=72.7% Similarity=1.45 Sum_probs=10.8\n" + + "Q ss_pred CCHHHH\n" + + "Q demo_query 1 ACDEFG 6 (12)\n" + + "Q Consensus 1 AcDEfG 6 (12)\n" + + " ||+|.|\n" + + "T Consensus 5 AC-EfG 9 (40)\n" + + "T target_A 5 AC-EFG 9 (40)\n" + + "T ss_dssp CCEEEE\n" + + "T ss_pred CCHHHH\n" + + "Confidence 998879\n" + + "Q ss_pred HHEECC\n" + + "Q demo_query 7 HIKLMN 12 (12)\n" + + "Q Consensus 7 HiKLMn 12 (12)\n" + + " |.||||\n" + + "T Consensus 10 H-KLMN 14 (40)\n" + + "T target_A 10 H-KLMN 14 (40)\n" + + "T ss_dssp E-EECC\n" + + "T ss_pred H-EECC\n" + + "Confidence 976899\n" + + "No 2\n" + + ">target_B Membrane protein\n" + + "Probab=72.5 E-value=0.004 Score=31.2 Aligned_cols=8 Identities=50% Similarity=0.72 Sum_probs=6.2\n" + + "Q demo_query 3 DEFGHIKL 10 (12)\n" + + "Q Consensus 3 dEfGHiKl 10 (12)\n" + + " +||..||+\n" + + "T Consensus 2 TEFGYIKV 9 (20)\n" + + "T target_B 2 TEFGYIKV 9 (20)\n" + + "Confidence 67887765\n" + + "Done!\n" +} + +///| +priv struct HhrAlignmentBuilder { + rank : Int + mut target_name : String + mut target_description : String + mut detail_target_name : String + mut probability : Double + mut evalue : Double + mut score : Double + mut identities : Double + mut similarity : Double + mut sum_probabilities : Double + mut aligned_columns : Int + mut has_statistics : Bool + mut query_length : Int + mut target_length : Int + mut query_start : Int + mut query_end : Int + mut target_start : Int + mut target_end : Int + mut query_sequence : String + mut target_sequence : String + mut query_consensus : String + mut target_consensus : String + mut query_secondary_structure : String + mut target_secondary_structure : String + mut target_dssp : String + mut column_score : String + mut confidence : String + mut block_width : Int +} + +///| +fn HhrAlignmentBuilder::new(rank : Int) -> HhrAlignmentBuilder { + HhrAlignmentBuilder::{ + rank, + target_name: "", + target_description: "", + detail_target_name: "", + probability: 0.0, + evalue: 0.0, + score: 0.0, + identities: 0.0, + similarity: 0.0, + sum_probabilities: 0.0, + aligned_columns: 0, + has_statistics: false, + query_length: 0, + target_length: 0, + query_start: -1, + query_end: -1, + target_start: -1, + target_end: -1, + query_sequence: "", + target_sequence: "", + query_consensus: "", + target_consensus: "", + query_secondary_structure: "", + target_secondary_structure: "", + target_dssp: "", + column_score: "", + confidence: "", + block_width: 0, + } +} + +///| +priv struct HhrSequencePart { + name : String + start : Int + sequence : String + end : Int + total : Int +} + +///| +fn hhr_finish_alignment( + builder : HhrAlignmentBuilder, + query_name : String, + match_columns : Int, + summaries : Array[HhrHitSummary], +) -> HhrAlignment raise HhrError { + if builder.rank < 1 || builder.rank > summaries.length() { + raise HhrError("Detailed alignment rank has no summary row") + } + if builder.target_name.length() == 0 { + raise HhrError( + "Alignment " + builder.rank.to_string() + " is missing target header", + ) + } + if !builder.has_statistics { + raise HhrError( + "Alignment " + builder.rank.to_string() + " is missing statistics", + ) + } + if builder.query_sequence.length() == 0 || + builder.target_sequence.length() == 0 { + raise HhrError("Alignment " + builder.rank.to_string() + " has no sequence") + } + let width = builder.query_sequence.length() + if builder.target_sequence.length() != width { + raise HhrError( + "Alignment " + builder.rank.to_string() + " has unequal row widths", + ) + } + if builder.query_length != match_columns { + raise HhrError( + "Alignment " + + builder.rank.to_string() + + " query length disagrees with Match_columns", + ) + } + if builder.query_start < 0 || builder.target_start < 0 { + raise HhrError( + "Alignment " + builder.rank.to_string() + " has missing coordinates", + ) + } + let query_residues = hhr_count_residues(builder.query_sequence) + let target_residues = hhr_count_residues(builder.target_sequence) + if query_residues != builder.query_end - builder.query_start { + raise HhrError( + "Alignment " + + builder.rank.to_string() + + " query coordinates disagree with sequence", + ) + } + if target_residues != builder.target_end - builder.target_start { + raise HhrError( + "Alignment " + + builder.rank.to_string() + + " target coordinates disagree with sequence", + ) + } + hhr_validate_annotation( + builder.query_consensus, + width, + "query consensus", + builder.rank, + ) + hhr_validate_annotation( + builder.target_consensus, + width, + "target consensus", + builder.rank, + ) + hhr_validate_annotation( + builder.query_secondary_structure, + width, + "query secondary structure", + builder.rank, + ) + hhr_validate_annotation( + builder.target_secondary_structure, + width, + "target secondary structure", + builder.rank, + ) + hhr_validate_annotation( + builder.target_dssp, + width, + "target DSSP", + builder.rank, + ) + hhr_validate_annotation( + builder.column_score, + width, + "column score", + builder.rank, + ) + hhr_validate_annotation(builder.confidence, width, "confidence", builder.rank) + let summary = summaries[builder.rank - 1] + if summary.rank != builder.rank || summary.target_name != builder.target_name { + raise HhrError( + "Alignment " + builder.rank.to_string() + " disagrees with summary target", + ) + } + if builder.detail_target_name.length() > 0 && + builder.detail_target_name != builder.target_name { + raise HhrError( + "Alignment " + + builder.rank.to_string() + + " has inconsistent target identifiers", + ) + } + if builder.aligned_columns != summary.aligned_columns { + raise HhrError( + "Alignment " + + builder.rank.to_string() + + " aligned column count disagrees with summary", + ) + } + if builder.aligned_columns != + hhr_count_paired_residues(builder.query_sequence, builder.target_sequence) { + raise HhrError( + "Alignment " + + builder.rank.to_string() + + " Aligned_cols disagrees with sequence rows", + ) + } + if builder.query_start != summary.query_start || + builder.query_end != summary.query_end || + builder.target_start != summary.target_start || + builder.target_end != summary.target_end || + builder.target_length != summary.target_length { + raise HhrError( + "Alignment " + + builder.rank.to_string() + + " coordinates disagree with summary", + ) + } + HhrAlignment::{ + rank: builder.rank, + query_name, + query_length: builder.query_length, + target_name: builder.target_name, + target_description: builder.target_description, + target_length: builder.target_length, + probability: builder.probability, + evalue: builder.evalue, + pvalue: summary.pvalue, + score: builder.score, + secondary_structure_score: summary.secondary_structure_score, + identities: builder.identities, + similarity: builder.similarity, + sum_probabilities: builder.sum_probabilities, + aligned_columns: builder.aligned_columns, + query_start: builder.query_start, + query_end: builder.query_end, + target_start: builder.target_start, + target_end: builder.target_end, + query_sequence: builder.query_sequence, + target_sequence: builder.target_sequence, + query_consensus: builder.query_consensus, + target_consensus: builder.target_consensus, + query_secondary_structure: builder.query_secondary_structure, + target_secondary_structure: builder.target_secondary_structure, + target_dssp: builder.target_dssp, + column_score: builder.column_score, + confidence: builder.confidence, + } +} + +///| +fn hhr_parse_hit_summary( + line : String, + expected_rank : Int, + line_number : Int, +) -> HhrHitSummary raise HhrError { + let words = hhr_split_whitespace(line) + if words.length() < 11 { + raise HhrError( + "Malformed HHR hit summary at line " + line_number.to_string(), + ) + } + let rank = hhr_parse_nonnegative_int(words[0], "hit rank", line_number) + if rank != expected_rank { + raise HhrError("Non-contiguous hit rank at line " + line_number.to_string()) + } + let numeric_start = words.length() - 9 + if numeric_start < 2 { + raise HhrError( + "Malformed HHR hit summary at line " + line_number.to_string(), + ) + } + let description = hhr_join_words(words, 2, numeric_start) + let probability = hhr_parse_number( + words[numeric_start], + "hit probability", + line_number, + ) + let evalue = hhr_parse_number( + words[numeric_start + 1], + "hit E-value", + line_number, + ) + let pvalue = hhr_parse_number( + words[numeric_start + 2], + "hit P-value", + line_number, + ) + let score = hhr_parse_number( + words[numeric_start + 3], + "hit score", + line_number, + ) + let secondary_structure_score = hhr_parse_number( + words[numeric_start + 4], + "hit SS score", + line_number, + ) + let aligned_columns = hhr_parse_nonnegative_int( + words[numeric_start + 5], + "hit columns", + line_number, + ) + let (query_start, query_end) = hhr_parse_range( + words[numeric_start + 6], + "query range", + line_number, + ) + let (target_start, target_end) = hhr_parse_range( + words[numeric_start + 7], + "target range", + line_number, + ) + let target_length = hhr_parse_parenthesized_int( + words[numeric_start + 8], + "target length", + line_number, + ) + HhrHitSummary::{ + rank, + target_name: words[1], + description, + probability, + evalue, + pvalue, + score, + secondary_structure_score, + aligned_columns, + query_start, + query_end, + target_start, + target_end, + target_length, + } +} + +///| +fn hhr_parse_alignment_statistics( + builder : HhrAlignmentBuilder, + line : String, + line_number : Int, +) -> Unit raise HhrError { + if builder.has_statistics { + raise HhrError( + "Duplicate alignment statistics at line " + line_number.to_string(), + ) + } + let values : Map[String, String] = Map([]) + for word in hhr_split_whitespace(line) { + let equal = hhr_find_char(word, '='.to_int()) + if equal <= 0 || equal == word.length() - 1 { + raise HhrError( + "Malformed alignment statistic at line " + line_number.to_string(), + ) + } + let key = word[0:equal].to_owned() + let mut value = word[equal + 1:].to_owned() + if key == "Identities" && + value.length() > 0 && + value.unsafe_get(value.length() - 1).to_int() == '%'.to_int() { + value = value[0:value.length() - 1].to_owned() + } + values[key] = value + } + let required = [ + "Probab", "E-value", "Score", "Aligned_cols", "Identities", "Similarity", "Sum_probs", + ] + for key in required { + if values.get(key) is None { + raise HhrError("Missing " + key + " at line " + line_number.to_string()) + } + } + builder.probability = hhr_parse_number( + values["Probab"], + "Probab", + line_number, + ) + builder.evalue = hhr_parse_number(values["E-value"], "E-value", line_number) + builder.score = hhr_parse_number(values["Score"], "Score", line_number) + builder.aligned_columns = hhr_parse_nonnegative_int( + values["Aligned_cols"], + "Aligned_cols", + line_number, + ) + builder.identities = hhr_parse_number( + values["Identities"], + "Identities", + line_number, + ) + builder.similarity = hhr_parse_number( + values["Similarity"], + "Similarity", + line_number, + ) + builder.sum_probabilities = hhr_parse_number( + values["Sum_probs"], + "Sum_probs", + line_number, + ) + builder.has_statistics = true +} + +///| +fn hhr_parse_sequence_line( + line : String, + kind : String, + line_number : Int, +) -> HhrSequencePart raise HhrError { + let words = hhr_split_whitespace(line) + if words.length() != 6 { + raise HhrError("Malformed " + kind + " line at " + line_number.to_string()) + } + let name = words[1] + let start = hhr_parse_nonnegative_int(words[2], kind + " start", line_number) + if start <= 0 { + raise HhrError( + kind + " start must be positive at line " + line_number.to_string(), + ) + } + let sequence = words[3] + let end = hhr_parse_nonnegative_int(words[4], kind + " end", line_number) + let total = hhr_parse_parenthesized_int( + words[5], + kind + " total", + line_number, + ) + let converted_start = start - 1 + if end < converted_start || end > total { + raise HhrError( + "Invalid " + kind + " coordinates at line " + line_number.to_string(), + ) + } + if hhr_count_residues(sequence) != end - converted_start { + raise HhrError( + kind + + " coordinates disagree with sequence at line " + + line_number.to_string(), + ) + } + HhrSequencePart::{ name, start: converted_start, sequence, end, total } +} + +///| +fn hhr_validate_annotation( + annotation : String, + width : Int, + name : String, + rank : Int, +) -> Unit raise HhrError { + if annotation.length() > 0 && annotation.length() != width { + raise HhrError( + "Alignment " + + rank.to_string() + + " " + + name + + " width " + + annotation.length().to_string() + + " does not match alignment width " + + width.to_string(), + ) + } +} + +///| +fn hhr_normalize_lines(text : String) -> Array[String] { + let result : Array[String] = [] + for view in text.split("\n") { + let mut line = view.to_owned() + if line.length() > 0 && + line.unsafe_get(line.length() - 1).to_int() == '\r'.to_int() { + line = line[0:line.length() - 1].to_owned() + } + result.push(line) + } + result +} + +///| +fn hhr_split_whitespace(text : String) -> Array[String] { + let result : Array[String] = [] + let mut start = 0 + let mut in_word = false + for i = 0; i < text.length(); i = i + 1 { + let code = text.unsafe_get(i).to_int() + let whitespace = code == ' '.to_int() || + code == '\t'.to_int() || + code == '\r'.to_int() + if whitespace { + if in_word { + result.push(text[start:i].to_owned()) + in_word = false + } + } else if !in_word { + start = i + in_word = true + } + } + if in_word { + result.push(text[start:].to_owned()) + } + result +} + +///| +fn hhr_first_whitespace(text : String) -> (String, String)? { + for i = 0; i < text.length(); i = i + 1 { + let code = text.unsafe_get(i).to_int() + if code == ' '.to_int() || code == '\t'.to_int() { + let key = text[0:i].to_owned() + let value = text[i:].trim().to_owned() + if key.length() > 0 && value.length() > 0 { + return Some((key, value)) + } + return None + } + } + None +} + +///| +fn hhr_has_prefix(text : String, prefix : String) -> Bool { + if prefix.length() > text.length() { + return false + } + for i = 0; i < prefix.length(); i = i + 1 { + if text.unsafe_get(i).to_int() != prefix.unsafe_get(i).to_int() { + return false + } + } + true +} + +///| +fn hhr_is_indented(text : String) -> Bool { + text.length() > 0 && + ( + text.unsafe_get(0).to_int() == ' '.to_int() || + text.unsafe_get(0).to_int() == '\t'.to_int() + ) +} + +///| +fn hhr_is_rank_line(text : String) -> Bool { + let words = hhr_split_whitespace(text) + words.length() == 2 && words[0] == "No" +} + +///| +fn hhr_find_char(text : String, needle : Int) -> Int { + for i = 0; i < text.length(); i = i + 1 { + if text.unsafe_get(i).to_int() == needle { + return i + } + } + -1 +} + +///| +fn hhr_find_substring(text : String, needle : String) -> Int { + if needle.length() == 0 { + return 0 + } + if needle.length() > text.length() { + return -1 + } + for i = 0; i <= text.length() - needle.length(); i = i + 1 { + let mut matches = true + for j = 0; j < needle.length(); j = j + 1 { + if text.unsafe_get(i + j).to_int() != needle.unsafe_get(j).to_int() { + matches = false + break + } + } + if matches { + return i + } + } + -1 +} + +///| +fn hhr_parse_nonnegative_int( + text : String, + field : String, + line_number : Int, +) -> Int raise HhrError { + if text.length() == 0 { + raise HhrError("Empty " + field + " at line " + line_number.to_string()) + } + let mut value = 0 + for i = 0; i < text.length(); i = i + 1 { + let code = text.unsafe_get(i).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + raise HhrError("Invalid " + field + " at line " + line_number.to_string()) + } + value = value * 10 + code - '0'.to_int() + } + value +} + +///| +fn hhr_parse_number( + text : String, + field : String, + line_number : Int, +) -> Double raise HhrError { + if text.length() == 0 { + raise HhrError("Empty " + field + " at line " + line_number.to_string()) + } + let mut has_digit = false + for i = 0; i < text.length(); i = i + 1 { + let code = text.unsafe_get(i).to_int() + if code >= '0'.to_int() && code <= '9'.to_int() { + has_digit = true + } else if code != '-'.to_int() && + code != '+'.to_int() && + code != '.'.to_int() && + code != 'e'.to_int() && + code != 'E'.to_int() { + raise HhrError("Invalid " + field + " at line " + line_number.to_string()) + } + } + if !has_digit { + raise HhrError("Invalid " + field + " at line " + line_number.to_string()) + } + match parse_double(text) { + Some(value) => value + None => + raise HhrError("Invalid " + field + " at line " + line_number.to_string()) + } +} + +///| +fn hhr_parse_range( + text : String, + field : String, + line_number : Int, +) -> (Int, Int) raise HhrError { + let separator = hhr_find_char(text, '-'.to_int()) + if separator <= 0 || separator >= text.length() - 1 { + raise HhrError("Invalid " + field + " at line " + line_number.to_string()) + } + let start = hhr_parse_nonnegative_int( + text[0:separator].to_owned(), + field, + line_number, + ) + let end = hhr_parse_nonnegative_int( + text[separator + 1:].to_owned(), + field, + line_number, + ) + if start <= 0 || end < start { + raise HhrError("Invalid " + field + " at line " + line_number.to_string()) + } + (start - 1, end) +} + +///| +fn hhr_parse_parenthesized_int( + text : String, + field : String, + line_number : Int, +) -> Int raise HhrError { + if text.length() < 3 || + text.unsafe_get(0).to_int() != '('.to_int() || + text.unsafe_get(text.length() - 1).to_int() != ')'.to_int() { + raise HhrError("Invalid " + field + " at line " + line_number.to_string()) + } + hhr_parse_nonnegative_int( + text[1:text.length() - 1].to_owned(), + field, + line_number, + ) +} + +///| +fn hhr_last_token( + line : String, + field : String, + line_number : Int, +) -> String raise HhrError { + let words = hhr_split_whitespace(line) + if words.length() < 3 { + raise HhrError("Malformed " + field + " at line " + line_number.to_string()) + } + words[words.length() - 1] +} + +///| +fn hhr_suffix( + line : String, + width : Int, + field : String, + line_number : Int, +) -> String raise HhrError { + if width < 0 || line.length() < width { + raise HhrError("Short " + field + " at line " + line_number.to_string()) + } + line[line.length() - width:].to_owned() +} + +///| +fn hhr_join_words(words : Array[String], start : Int, end : Int) -> String { + let output = StringBuilder::new() + for i = start; i < end; i = i + 1 { + if i > start { + output.write_char(' ') + } + output.write_string(words[i]) + } + output.to_string() +} + +///| +fn hhr_remove_gaps(sequence : String) -> String { + let output = StringBuilder::new() + for i = 0; i < sequence.length(); i = i + 1 { + let code = sequence.unsafe_get(i).to_int() + if code != '-'.to_int() { + output.write_char(code.unsafe_to_char()) + } + } + output.to_string() +} + +///| +fn hhr_count_residues(sequence : String) -> Int { + let mut count = 0 + for i = 0; i < sequence.length(); i = i + 1 { + if sequence.unsafe_get(i).to_int() != '-'.to_int() { + count = count + 1 + } + } + count +} + +///| +fn hhr_count_paired_residues(query : String, target : String) -> Int { + let mut count = 0 + let width = if query.length() < target.length() { + query.length() + } else { + target.length() + } + for i = 0; i < width; i = i + 1 { + if query.unsafe_get(i).to_int() != '-'.to_int() && + target.unsafe_get(i).to_int() != '-'.to_int() { + count = count + 1 + } + } + count +} diff --git a/test/moonbit/hhr_test.mbt b/test/moonbit/hhr_test.mbt new file mode 100644 index 00000000..35f07a6c --- /dev/null +++ b/test/moonbit/hhr_test.mbt @@ -0,0 +1,386 @@ +///| +/// Tests for the Biopython Bio.Align.hhr-compatible parser. + +///| +fn hhr_minimal_text() -> String { + "Query mini_query\n" + + "Match_columns 4\n" + + "No_of_seqs 1 out of 1\n" + + "Neff 1.0\n" + + "Searched_HMMs 1\n" + + " No Hit Prob E-value P-value Score SS Cols Query HMM Template HMM\n" + + " 1 target_only 80.0 0.01 0.001 20.0 0.0 3 1-3 2-5 (5)\n" + + "No 1\n" + + ">target_only\n" + + "Probab=80.0 E-value=0.01 Score=20.0 Aligned_cols=3 Identities=66.7% Similarity=0.5 Sum_probs=2.4\n" + + "Q mini_query 1 AC-D 3 (4)\n" + + "T target_only 2 ACGD 5 (5)\n" + + "Done!\n" +} + +///| +fn hhr_raises(text : String) -> Bool { + try { + ignore(@src.hhr_parse(text)) + false + } catch { + HhrError(_) => true + } +} + +///| +test "hhr parses file metadata" { + let record = @src.hhr_parse(@src.hhr_sample_text()) + assert_eq(record.metadata.query_name, "demo_query") + assert_eq(record.metadata.match_columns, 12) + assert_eq(record.metadata.sequence_count, 24) + assert_eq(record.metadata.sequence_count_total, 40) + assert_true((record.metadata.neff - 3.5).abs() < 1.0e-12) + match record.metadata.template_neff { + Some(value) => assert_true((value - 2.1).abs() < 1.0e-12) + None => abort("expected Template_Neff") + } + assert_eq(record.metadata.searched_hmms, 2) + assert_eq(record.metadata.run_date, "Tue Aug 4 12:00:00 2026") + assert_eq(record.metadata.command_line, "hhsearch -i demo.a3m -d pdb70") +} + +///| +test "hhr parses ranked hit summaries" { + let record = @src.hhr_parse(@src.hhr_sample_text()) + assert_eq(record.hit_summaries.length(), 2) + let first = record.hit_summaries[0] + assert_eq(first.rank, 1) + assert_eq(first.target_name, "target_A") + assert_eq(first.description, "Alpha beta enzyme") + assert_true((first.probability - 99.8).abs() < 1.0e-12) + assert_true((first.evalue - 1.2e-20).abs() < 1.0e-30) + assert_true((first.pvalue - 4.0e-25).abs() < 1.0e-34) + assert_eq(first.aligned_columns, 10) + assert_eq(first.query_start, 0) + assert_eq(first.query_end, 12) + assert_eq(first.target_start, 4) + assert_eq(first.target_end, 14) + assert_eq(first.target_length, 40) +} + +///| +test "hhr joins multi-block profile alignments" { + let record = @src.hhr_parse(@src.hhr_sample_text()) + let alignment = record.alignments[0] + assert_eq(alignment.query_sequence, "ACDEFGHIKLMN") + assert_eq(alignment.target_sequence, "AC-EFGH-KLMN") + assert_eq(alignment.query_consensus, "AcDEfGHiKLMn") + assert_eq(alignment.target_consensus, "AC-EfGH-KLMN") + assert_eq(alignment.alignment_length(), 12) + assert_eq(alignment.aligned_columns, 10) + assert_eq(alignment.query_start, 0) + assert_eq(alignment.query_end, 12) + assert_eq(alignment.target_start, 4) + assert_eq(alignment.target_end, 14) +} + +///| +test "hhr preserves per-column annotations" { + let alignment = @src.hhr_parse(@src.hhr_sample_text()).alignments[0] + assert_eq(alignment.query_secondary_structure, "CCHHHHHHEECC") + assert_eq(alignment.target_secondary_structure, "CCHHHHH-EECC") + assert_eq(alignment.target_dssp, "CCEEEEE-EECC") + assert_eq(alignment.column_score, "||+|.||.||||") + assert_eq(alignment.confidence, "998879976899") +} + +///| +test "hhr exposes alignment statistics and sequence helpers" { + let alignment = @src.hhr_parse(@src.hhr_sample_text()).alignments[0] + assert_true((alignment.probability - 99.8).abs() < 1.0e-12) + assert_true((alignment.evalue - 1.2e-20).abs() < 1.0e-30) + assert_true((alignment.score - 85.4).abs() < 1.0e-12) + assert_true((alignment.identities - 72.7).abs() < 1.0e-12) + assert_true((alignment.similarity - 1.45).abs() < 1.0e-12) + assert_true((alignment.sum_probabilities - 10.8).abs() < 1.0e-12) + assert_eq(alignment.ungapped_query(), "ACDEFGHIKLMN") + assert_eq(alignment.ungapped_target(), "ACEFGHKLMN") + assert_eq(alignment.identity_count(), 10) + assert_true((alignment.query_coverage() - 1.0).abs() < 1.0e-12) + assert_true((alignment.target_coverage() - 0.25).abs() < 1.0e-12) +} + +///| +test "hhr maps query coordinates through target gaps" { + let alignment = @src.hhr_parse(@src.hhr_sample_text()).alignments[0] + assert_eq(alignment.query_to_target(0), Some(4)) + assert_true(alignment.query_to_target(2) is None) + assert_eq(alignment.query_to_target(3), Some(6)) + assert_true(alignment.query_to_target(7) is None) + assert_eq(alignment.query_to_target(11), Some(13)) + assert_true(alignment.query_to_target(12) is None) +} + +///| +test "hhr returns per-column coordinate pairs" { + let pairs = @src.hhr_parse(@src.hhr_sample_text()).alignments[0].aligned_pairs() + assert_eq(pairs.length(), 12) + match pairs[0] { + (Some(query), Some(target)) => { + assert_eq(query, 0) + assert_eq(target, 4) + } + _ => abort("expected paired first column") + } + match pairs[2] { + (Some(query), None) => assert_eq(query, 2) + _ => abort("expected target gap") + } + match pairs[11] { + (Some(query), Some(target)) => { + assert_eq(query, 11) + assert_eq(target, 13) + } + _ => abort("expected paired final column") + } +} + +///| +test "hhr supports record queries and filters" { + let record = @src.hhr_parse(@src.hhr_sample_text()) + assert_eq(record.num_hits(), 2) + assert_true(record.get(-1) is None) + assert_true(record.get(2) is None) + match record.get(1) { + Some(alignment) => assert_eq(alignment.target_name, "target_B") + None => abort("expected second alignment") + } + match record.find_target("target_A") { + Some(alignment) => assert_eq(alignment.rank, 1) + None => abort("expected target_A") + } + assert_true(record.find_target("missing") is None) + assert_eq(record.alignments_for_target("target_A").length(), 1) + assert_eq(record.filter_by_probability(90.0).length(), 1) + assert_eq(record.filter_by_evalue(0.01).length(), 2) + match record.best_alignment() { + Some(alignment) => assert_eq(alignment.rank, 1) + None => abort("expected best alignment") + } +} + +///| +test "hhr keeps repeated target alignments" { + let repeated = @src.hhr_sample_text().replace_all( + old="target_B", + new="target_A", + ) + let record = @src.hhr_parse(repeated) + assert_eq(record.alignments_for_target("target_A").length(), 2) + match record.find_target("target_A") { + Some(alignment) => assert_eq(alignment.rank, 1) + None => abort("expected repeated target") + } +} + +///| +test "hhr parses official layout without blank separators" { + let text = @src.hhr_sample_text() + assert_true(!text.contains("pdb70\n\n")) + assert_true(!text.contains("(20)\n\nNo 1")) + assert_eq(@src.hhr_parse(text).num_hits(), 2) +} + +///| +test "hhr accepts CRLF input" { + let text = @src.hhr_sample_text().replace_all(old="\n", new="\r\n") + let record = @src.hhr_parse(text) + assert_eq(record.metadata.query_name, "demo_query") + assert_eq(record.num_hits(), 2) +} + +///| +test "hhr parses optional metadata and annotation-free alignments" { + let record = @src.hhr_parse(hhr_minimal_text()) + assert_true(record.metadata.template_neff is None) + assert_eq(record.metadata.run_date, "") + let alignment = record.alignments[0] + assert_eq(alignment.target_description, "") + assert_eq(alignment.query_sequence, "AC-D") + assert_eq(alignment.target_sequence, "ACGD") + assert_eq(alignment.query_consensus, "") + assert_eq(alignment.target_consensus, "") + assert_eq(alignment.confidence, "") + assert_eq(alignment.aligned_columns, 3) + assert_true((alignment.query_coverage() - 0.75).abs() < 1.0e-12) + assert_true((alignment.target_coverage() - 0.8).abs() < 1.0e-12) +} + +///| +test "hhr parses zero-hit documents" { + let text = "Query empty_query\n" + + "Match_columns 0\n" + + "No_of_seqs 0 out of 0\n" + + "Neff 0.0\n" + + "Searched_HMMs 0\n" + + " No Hit Prob E-value P-value Score SS Cols Query HMM Template HMM\n" + + "Done!\n" + let record = @src.hhr_parse(text) + assert_eq(record.num_hits(), 0) + assert_true(record.best_alignment() is None) +} + +///| +test "hhr serialization round trip preserves the record" { + let original = @src.hhr_parse(@src.hhr_sample_text()) + let serialized = original.to_string() + assert_true(serialized.contains("Query demo_query")) + assert_true(serialized.contains("Done!")) + let reparsed = @src.hhr_parse(serialized) + assert_true(reparsed == original) +} + +///| +test "hhr accepts EOF after a complete alignment" { + let text = hhr_minimal_text().replace_all(old="Done!\n", new="") + assert_eq(@src.hhr_parse(text).num_hits(), 1) +} + +///| +test "hhr rejects empty input" { + assert_true(hhr_raises("")) +} + +///| +test "hhr requires core metadata" { + let text = hhr_minimal_text().replace_all(old="Match_columns 4\n", new="") + assert_true(hhr_raises(text)) +} + +///| +test "hhr rejects unknown header fields" { + let text = hhr_minimal_text().replace_all( + old="Match_columns 4\n", + new="Unexpected value\nMatch_columns 4\n", + ) + assert_true(hhr_raises(text)) +} + +///| +test "hhr rejects malformed sequence counts" { + let text = hhr_minimal_text().replace_all(old="1 out of 1", new="1 of 1") + assert_true(hhr_raises(text)) +} + +///| +test "hhr validates the hit table header" { + let text = hhr_minimal_text().replace_all(old="P-value", new="Pvalue") + assert_true(hhr_raises(text)) +} + +///| +test "hhr requires contiguous summary ranks" { + let text = @src.hhr_sample_text().replace_all( + old=" 2 target_B", + new=" 3 target_B", + ) + assert_true(hhr_raises(text)) +} + +///| +test "hhr requires contiguous detail ranks" { + let text = @src.hhr_sample_text().replace_all(old="No 2\n", new="No 3\n") + assert_true(hhr_raises(text)) +} + +///| +test "hhr validates summary and detail counts" { + let row = " 2 target_B Membrane protein 72.5 0.004 2.0E-6 31.2 0.0 8 3-10 2-9 (20)\n" + let text = @src.hhr_sample_text().replace_all(old=row, new="") + assert_true(hhr_raises(text)) +} + +///| +test "hhr validates summary and detail targets" { + let text = @src.hhr_sample_text().replace_all( + old=">target_A Alpha beta enzyme", + new=">other Alpha beta enzyme", + ) + assert_true(hhr_raises(text)) +} + +///| +test "hhr validates aligned column counts" { + let text = @src.hhr_sample_text().replace_all( + old="Aligned_cols=10", + new="Aligned_cols=9", + ) + assert_true(hhr_raises(text)) +} + +///| +test "hhr validates summary coordinates" { + let text = @src.hhr_sample_text().replace_all( + old="10 1-12 5-14 (40)", + new="10 1-12 5-13 (40)", + ) + assert_true(hhr_raises(text)) +} + +///| +test "hhr validates sequence coordinates" { + let text = @src.hhr_sample_text().replace_all( + old="T target_A 5 AC-EFG 9 (40)", + new="T target_A 5 AC-EFG 10 (40)", + ) + assert_true(hhr_raises(text)) +} + +///| +test "hhr validates multi-block coordinate continuity" { + let text = @src.hhr_sample_text().replace_all( + old="Q demo_query 7 HIKLMN", + new="Q demo_query 8 HIKLMN", + ) + assert_true(hhr_raises(text)) +} + +///| +test "hhr validates annotation widths" { + let text = @src.hhr_sample_text().replace_all( + old="Q ss_pred CCHHHH", + new="Q ss_pred CCHHH", + ) + assert_true(hhr_raises(text)) +} + +///| +test "hhr requires alignment statistics" { + let statistics = "Probab=80.0 E-value=0.01 Score=20.0 Aligned_cols=3 Identities=66.7% Similarity=0.5 Sum_probs=2.4\n" + assert_true( + hhr_raises(hhr_minimal_text().replace_all(old=statistics, new="")), + ) +} + +///| +test "hhr requires both alignment rows" { + let text = hhr_minimal_text().replace_all( + old="T target_only 2 ACGD 5 (5)\n", + new="", + ) + assert_true(hhr_raises(text)) +} + +///| +test "hhr rejects duplicate target headers" { + let text = hhr_minimal_text().replace_all( + old=">target_only\n", + new=">target_only\n>target_only\n", + ) + assert_true(hhr_raises(text)) +} + +///| +test "hhr rejects extra content after Done" { + let text = hhr_minimal_text().replace_all( + old="Done!\n", + new="Done!\ntrailing data\n", + ) + assert_true(hhr_raises(text)) +} From 6219fc834188d9f805fdea8bee0f2e8ce58c576b Mon Sep 17 00:00:00 2001 From: eda Date: Tue, 4 Aug 2026 17:14:50 +0800 Subject: [PATCH 07/41] #28 /8373 feat(sparse_array): Bioconductor SparseArray COO --- README.md | 25 +- examples/sparse_array_demo/main.mbt | 138 ++++ examples/sparse_array_demo/moon.pkg | 5 + src/sparse_array.mbt | 1108 +++++++++++++++++++++++++++ test/moonbit/sparse_array_test.mbt | 592 ++++++++++++++ 5 files changed, 1864 insertions(+), 4 deletions(-) create mode 100644 examples/sparse_array_demo/main.mbt create mode 100644 examples/sparse_array_demo/moon.pkg create mode 100644 src/sparse_array.mbt create mode 100644 test/moonbit/sparse_array_test.mbt diff --git a/README.md b/README.md index 81c560e2..46ae890e 100644 --- a/README.md +++ b/README.md @@ -122,6 +122,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | Bioconductor fishpond (Swish) | 非参数差异表达分析: Mann-Whitney-Wilcoxon秩和统计、置换检验、BH-FDR校正、log2FC方向判定 | | ✅ | Bioconductor MatrixGenerics | 矩阵行/列汇总统计: rowMeans/colMeans、rowSums/colSums、rowVars/colVars、rowSds/colSds、rowMedians/colMedians、rowMins/colMins、rowMaxs/colMaxs、rowRanges/colRanges、rowMad/colMad、rowCounts、rowAnys/colAnys、rowAlls/colAlls、块处理 | | ✅ | Bioconductor beachmat | 矩阵访问API: 列/行块处理(bmat_apply_col_blocks/bmat_apply_row_blocks)、线性迭代器(BmatIterator)、子集/转置/绑定、逐元素操作、类型安全访问 | +| ✅ | Bioconductor SparseArray | N维稀疏数组: 规范化COO、重复坐标合并、R列主序转换、切片/置换/绑定、稀疏算术、统计与矩阵乘法 | | ✅ | Bioconductor glmGamPoi | Gamma-Poisson广义线性模型: size factors估计、伪批量聚合、单基因拟合(IWLCS迭代加权最小二乘)、Wald差异表达检验、BH-FDR校正、线性代数求解、正态CDF与p值计算 | | ✅ | Bioconductor survival | 生存分析: Kaplan-Meier估计器(Greenwood标准误)、log-rank检验(两组比较)、Cox比例风险模型(Newton-Raphson偏似然拟合、Breslow ties)、卡方p值、中位生存期 | | ✅ | Bioconductor methylKit | 亚硫酸氢盐测序甲基化分析: 甲基化胞嘧啶统计、覆盖率过滤/归一化、Fisher精确检验差异甲基化、BH-FDR校正、DMR识别、样本相关性/聚类、BED导出 | @@ -288,6 +289,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **GSVA** | Bioconductor GSVA | 基因集变异分析、单样本通路评分（ssGSEA/zscore/PLAGE）、富集分析、置换检验、富集图可视化(enrichment map)、表型相关性分析(phenotype correlation)、生存分析(survival analysis)、分数分布分析与可视化 | ✅ | | **ChromVAR** | Bioconductor chromVAR | 染色质变异分析、TF motif富集、GC偏差校正、细胞聚类、变异性分析 | ✅ | | **DelayedArray** | Bioconductor DelayedArray | 延迟计算数组、懒加载操作、分块处理、行/列聚合、子集操作 | ✅ | +| **SparseArray** | Bioconductor SparseArray | N维规范化COO稀疏数组、坐标/线性索引、稀疏切片、维度置换与绑定、不可变赋值、算术/统计、矩阵乘法 | ✅ | | **AnnotationFilter** | Bioconductor AnnotationFilter | 基因注释过滤、染色体筛选、生物类型过滤、区域重叠检测、符号模式匹配 | ✅ | | **scDblFinder** | Bioconductor scDblFinder | 单细胞双细胞检测、Doublet评分计算、最近邻搜索、PCA降维、细胞过滤 | ✅ | | **Batchelor** | Bioconductor batchelor | 单细胞批次校正、rescaleBatches缩放校正、mutual nearest neighbor、fastMNN多批次校正、批次混合评分 | ✅ | @@ -352,6 +354,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **Storey q-value** | Bioconductor qvalue | π₀估计、Storey q-value计算、自助法π₀、FDR校正、显著性检验 | ✅ | | **独立假设加权(IHW)** | Bioconductor IHW | 协变量加权Bonferroni、局部/全局加权、Storey pi0加权、多协变量支持、迭代权重优化 | ✅ | | **DelayedMatrixStats** | Bioconductor DelayedMatrixStats | DelayedArray统计层、row/col统计(mean/var/sd/median/min/max/sum)、NA处理、子集操作 | ✅ | +| **SparseArray N维稀疏计算** | Bioconductor SparseArray | COO规范化、重复坐标合并与零消除、R列主序、稀疏子集/aperm/bind、Hadamard运算、crossprod/tcrossprod | ✅ | | **GC-RMA芯片分析** | Bioconductor gcrma | GC校正RMA、背景校正(IdealMM/Express)、GC查找表、分位数归一化、探针组汇总 | ✅ | | **ACE contig格式** | Biopython `Bio.Sequencing.Ace` | ACE组装格式解析、reads/contigs提取、共有序列生成、覆盖度分析、GC含量计算、格式化输出 | ✅ | | **蛋白质组学分析** | Biopython `Bio.SeqUtils.Proteomics` | 8种蛋白酶切(胰酶/糜酶/胃酶/LysC/ArgC/CNBr/GluC/AspN)、单同位素/平均质量计算、同位素分布、b/y碎片离子 | ✅ | @@ -451,6 +454,7 @@ IvanAXu/BioSeqs/ │ ├── edger_advanced.mbt # edgeR准似然F检验、camera/roast基因集检验 │ ├── limma.mbt # limma 差异表达、归一化、批次校正 (线性模型、经验贝叶斯、voom、RPKM/CPM/quantile、ComBat) │ ├── matrix.mbt # Bioconductor Matrix 稀疏矩阵操作 (CSC/CSR格式、矩阵运算) +│ ├── sparse_array.mbt # Bioconductor SparseArray N维规范化COO、切片/置换/绑定、稀疏算术与矩阵乘法 │ ├── bioc_neighbors.mbt # BiocNeighbors 最近邻搜索 (KMKNN/Annoy) │ ├── summarized_experiment.mbt # SummarizedExperiment 多维基因组数据容器 │ ├── ranged_summarized_experiment.mbt # RangedSummarizedExperiment GRanges/GRangesList行范围与协调操作 @@ -883,6 +887,7 @@ IvanAXu/BioSeqs/ │ ├── gsva_demo/ # GSVA 基因集变异分析示例 (ssGSEA/zscore/PLAGE评分、富集分析、置换检验、富集图可视化、表型相关性分析、生存分析、分数分布分析) │ ├── chromvar_demo/ # ChromVAR 染色质变异分析示例 (TF motif富集、GC偏差校正、细胞聚类、变异性分析) │ ├── delayed_array_demo/ # DelayedArray 延迟计算数组示例 (懒加载操作、分块处理、行/列聚合、子集操作) +│ ├── sparse_array_demo/ # SparseArray N维稀疏张量、切片/置换、统计、算术与矩阵乘法示例 │ ├── annotation_filter_demo/ # AnnotationFilter 基因注释过滤示例 (染色体筛选、生物类型过滤、区域重叠检测、符号模式匹配) │ ├── sc3_demo/ # SC3 单细胞共识聚类示例 │ ├── sc_dbl_finder_demo/ # scDblFinder 单细胞双细胞检测示例 (Doublet评分计算、最近邻搜索、PCA降维、细胞过滤) @@ -1180,6 +1185,7 @@ IvanAXu/BioSeqs/ │ │ ├── consensus_cluster_plus_test.mbt │ │ ├── csaw_test.mbt │ │ ├── delayed_array_test.mbt +│ │ ├── sparse_array_test.mbt │ │ ├── destiny_test.mbt │ │ ├── rtsne_test.mbt │ │ ├── uwot_test.mbt @@ -1426,7 +1432,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8332 个测试全部通过 +moon test # ✅ 8373 个测试全部通过 ``` ### 模块对照表 @@ -1541,6 +1547,7 @@ moon test # ✅ 8332 个测试全 | MoonBit 文件 | 对应 Python 库 | 核心功能 | | :--- | :--- | :--- | +| `sparse_array.mbt` | Bioconductor SparseArray | N维规范化COO、重复坐标合并与零消除、R列主序转换、稀疏切片/置换/绑定、算术/统计、矩阵乘法 | | `matrix_generics.mbt` | Bioconductor MatrixGenerics | rowMeans/colMeans、rowSums/colSums、rowVars/colVars、rowSds/colSds、rowMedians/colMedians、rowMins/colMins、rowMaxs/colMaxs、rowRanges/colRanges、rowMad/colMad、rowCounts、rowAnys/colAnys、rowAlls/colAlls、块处理 | | `beachmat.mbt` | Bioconductor beachmat | 列/行块处理、线性迭代器(BmatIterator)、子集/转置/绑定、逐元素操作、类型安全矩阵访问API | | `survival.mbt` | R/Bioconductor survival | Kaplan-Meier估计器(Greenwood标准误)、log-rank检验、Cox比例风险模型(Newton-Raphson偏似然拟合) | @@ -1649,6 +1656,7 @@ moon test # ✅ 8332 个测试全 | `gsva.mbt` | Bioconductor GSVA | 基因集变异分析 (ssGSEA/zscore/PLAGE评分) | | `chromvar.mbt` | Bioconductor chromVAR | 染色质变异分析 (TF motif富集、GC偏差校正) | | `delayed_array.mbt` | Bioconductor DelayedArray | 延迟计算数组 (懒加载操作、分块处理、行/列聚合) | +| `sparse_array.mbt` | Bioconductor SparseArray | N维稀疏数组、规范化COO存储、切片/置换/绑定、稀疏算术、统计与矩阵乘法 | | `annotation_filter.mbt` | Bioconductor AnnotationFilter | 基因注释过滤 (染色体筛选、生物类型过滤、区域重叠检测) | | `sc_dbl_finder.mbt` | Bioconductor scDblFinder | 单细胞双细胞检测 (Doublet评分、最近邻搜索、PCA降维) | | `seurat.mbt` | Bioconductor Seurat | 单细胞数据分析核心 (标准化、高可变基因、PCA、聚类、UMAP、差异表达、跨样本整合) | @@ -2756,6 +2764,12 @@ moon test # ✅ 8332 个测试全 实现与 Biopython `Bio.Align.hhr` 对应的 HHsearch/HHblits HHR 文本解析。`hhr_parse` 读取查询元数据、命中摘要表和多块 profile-profile 比对，使用 Biopython 风格的 0-based、end-exclusive 坐标，并保留 query/target consensus、预测二级结构、DSSP、逐列分数和 confidence。`HhrRecord` 支持按 target 查询、probability/E-value 过滤和最佳命中选择；`HhrAlignment` 提供去 gap 序列、identity/coverage 统计、`query_to_target` 坐标映射和 `aligned_pairs`。解析器严格校验 rank、摘要与详情数量、坐标跨度、跨块连续性、比对宽度、`Aligned_cols` 和终止标记，兼容 CRLF、无空行的官方布局、零命中及 EOF 结束的完整末块。`to_string` 生成规范 HHR 文本并支持解析-序列化往返；格式错误抛出 `HhrError`。 +### 242. N维稀疏数组基础设施 (Bioconductor SparseArray) + +实现与 Bioconductor `SparseArray` 核心语义对应的 N 维稀疏数组，作为现有二维 CSC/CSR `BiocMatrix` 的补充。`SparseArray::from_coo` 使用 0-based 坐标构建规范化 COO：构造时校验维度和坐标、深复制输入、按坐标排序、合并重复坐标，并删除合并后为零的条目；`from_flat`/`to_flat` 遵循 R 风格列主序（第一维变化最快），另提供矩阵和零数组构造器。查询 API 覆盖维度、长度、非零坐标/值、密度、坐标及线性随机访问和稠密转换，所有公开坐标访问器均返回防御性副本。 + +稀疏变换支持不可变单点/批量赋值、重复索引子集、0-based end-exclusive 切片、任意维度 `aperm`、二维转置和按指定维度绑定；加减、Hadamard 乘积、缩放和非零映射直接处理规范化非零条目。统计 API 包括全数组 sum/mean/min/max（极值正确纳入隐式零）以及二维 row/column sums、means 和非零计数；二维稀疏矩阵还支持 `matmul`、`crossprod` 和 `tcrossprod`。当前实现采用可移植的规范化 COO，并未宣称覆盖官方包的完整 SVT 存储后端。 + ## 性能优化 ### 优化策略 @@ -2857,8 +2871,8 @@ moon test # ✅ 8332 个测试全 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8332 | -| 通过数 | 8332 | +| 总测试数 | 8373 | +| 通过数 | 8373 | | 失败数 | 0 | | 通过率 | 100% | @@ -2960,6 +2974,7 @@ moon test --update | Cellosaurus | `cellosaurus_test.mbt` | 16 | | UniGene | `unigene_test.mbt` | 23 | | Bio.Align.hhr | `hhr_test.mbt` | 33 | +| SparseArray | `sparse_array_test.mbt` | 41 | | mmCIF | `mmcif_test.mbt` | 2 | | Nexus | `nexus_test.mbt` | 2 | | EMBOSS | `emboss_test.mbt` | 15 | @@ -3248,7 +3263,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 349 个示例程序，展示各模块的典型用法： +项目提供 350 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3323,6 +3338,7 @@ moon run cmd/bench/main.mbt | cellosaurus_demo | Cellosaurus细胞系记录解析、物种/同义名/交叉引用查询和序列化往返 | `moon run examples/cellosaurus_demo/main.mbt` | | unigene_demo | NCBI UniGene cluster解析、序列/蛋白相似性/STS/转录本映射查询和序列化往返 | `moon run examples/unigene_demo/main.mbt` | | hhr_demo | HH-suite HHR元数据与profile比对解析、命中筛选、query-target坐标映射和序列化往返 | `moon run examples/hhr_demo` | +| sparse_array_demo | SparseArray N维稀疏张量、切片/aperm、行列统计、稀疏算术和矩阵乘法 | `moon run examples/sparse_array_demo` | | uniprot_io_demo | UniProt XML格式解析（蛋白质条目解析、功能注释提取、序列转换） | `moon run examples/uniprot_io_demo/main.mbt` | | chem_utils_demo | 化学计算工具（键长、键角、二面角、分子式量、氢键长度） | `moon run examples/chem_utils_demo/main.mbt` | | jaspar_demo | JASPAR PFM格式解析（模体矩阵解析、共有序列、PWM转换、序列扫描） | `moon run examples/jaspar_demo/main.mbt` | @@ -3524,6 +3540,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Cellosaurus 细胞系数据库解析（多记录读取、交叉引用/物种查询、平面文本序列化） - ✅ 实现 UniGene 基因聚类记录解析（固定宽度多记录读取、类型化子记录查询、SCOUNT校验、平面文本序列化） - ✅ 实现 Bio.Align.hhr HH-suite HHR解析（元数据、命中摘要、多块profile比对、注释保留、过滤、坐标映射与序列化） +- ✅ 实现 Bioconductor SparseArray N维稀疏数组（规范化COO、R列主序、切片/置换/绑定、稀疏算术、统计与矩阵乘法） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/sparse_array_demo/main.mbt b/examples/sparse_array_demo/main.mbt new file mode 100644 index 00000000..bde89909 --- /dev/null +++ b/examples/sparse_array_demo/main.mbt @@ -0,0 +1,138 @@ +///| +fn format_doubles(values : Array[Double]) -> String { + let mut result = "[" + let mut index = 0 + while index < values.length() { + if index > 0 { + result = result + ", " + } + result = result + values[index].to_string() + index = index + 1 + } + result + "]" +} + +///| +fn format_ints(values : Array[Int]) -> String { + let mut result = "[" + let mut index = 0 + while index < values.length() { + if index > 0 { + result = result + ", " + } + result = result + values[index].to_string() + index = index + 1 + } + result + "]" +} + +///| +fn format_matrix(values : Array[Array[Double]]) -> String { + let mut result = "[" + let mut row = 0 + while row < values.length() { + if row > 0 { + result = result + ", " + } + result = result + format_doubles(values[row]) + row = row + 1 + } + result + "]" +} + +///| +fn main { + println("=== Bioconductor SparseArray Demo ===\n") + + let tensor = @src.sparse_array_sample() catch { + _ => abort("failed to create sparse tensor") + } + let tensor_summary = tensor.summary() catch { + _ => abort("failed to summarize sparse tensor") + } + let tensor_value = tensor.get([0, 4, 1]) catch { + _ => abort("failed to access sparse tensor") + } + println("1. Multidimensional sparse tensor") + println(" " + tensor_summary) + println(" value[0, 4, 1] = " + tensor_value.to_string()) + println( + " stored coordinates = " + tensor.nzcoordinates().length().to_string(), + ) + + let permuted = tensor.aperm([2, 0, 1]) catch { + _ => abort("failed to permute sparse tensor") + } + let permuted_summary = permuted.summary() catch { + _ => abort("failed to summarize permuted tensor") + } + let permuted_value = permuted.get([1, 0, 4]) catch { + _ => abort("failed to access permuted tensor") + } + println("\n2. Dimension permutation") + println(" " + permuted_summary) + println(" old [0, 4, 1] -> new [1, 0, 4] = " + permuted_value.to_string()) + + let sliced = tensor.slice([0, 0, 1], [4, 5, 2]) catch { + _ => abort("failed to slice sparse tensor") + } + let sliced_summary = sliced.summary() catch { + _ => abort("failed to summarize sparse slice") + } + println("\n3. Sparse slice without dense materialization") + println(" " + sliced_summary) + + let counts = @src.SparseArray::from_matrix([ + [1.0, 0.0, 2.0], + [0.0, 3.0, 0.0], + [4.0, 0.0, 5.0], + ]) catch { + _ => abort("failed to create sparse count matrix") + } + let counts_summary = counts.summary() catch { + _ => abort("failed to summarize sparse count matrix") + } + let row_sums = counts.row_sums() catch { + _ => abort("failed to compute row sums") + } + let column_sums = counts.column_sums() catch { + _ => abort("failed to compute column sums") + } + let row_nonzero_counts = counts.row_nonzero_counts() catch { + _ => abort("failed to count row nonzero values") + } + println("\n4. Matrix summaries") + println(" " + counts_summary) + println(" row sums: " + format_doubles(row_sums)) + println(" column sums: " + format_doubles(column_sums)) + println(" row nonzero counts: " + format_ints(row_nonzero_counts)) + + let design = @src.SparseArray::from_matrix([ + [1.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + ]) catch { + _ => abort("failed to create sparse design matrix") + } + let product = counts.matmul(design) catch { + _ => abort("failed to multiply sparse matrices") + } + println("\n5. Sparse matrix multiplication") + println(" result: " + format_matrix(product)) + + let normalized = counts.scale(0.5) catch { + _ => abort("failed to scale sparse matrix") + } + let combined = counts.add(normalized) catch { + _ => abort("failed to add sparse matrices") + } + let combined_summary = combined.summary() catch { + _ => abort("failed to summarize sparse arithmetic result") + } + let dense_combined = combined.to_dense_matrix() catch { + _ => abort("failed to materialize sparse arithmetic result") + } + println("\n6. Sparse arithmetic") + println(" counts + counts * 0.5: " + combined_summary) + println(" dense view: " + format_matrix(dense_combined)) +} diff --git a/examples/sparse_array_demo/moon.pkg b/examples/sparse_array_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/sparse_array_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/sparse_array.mbt b/src/sparse_array.mbt new file mode 100644 index 00000000..26362c29 --- /dev/null +++ b/src/sparse_array.mbt @@ -0,0 +1,1108 @@ +///| +/// Multidimensional sparse arrays inspired by Bioconductor SparseArray. +/// +/// Values are stored in a canonical coordinate (COO) representation. Every +/// public constructor validates dimensions and coordinates, sorts entries, +/// merges duplicate coordinates, and removes explicit zero values. + +///| +pub suberror SparseArrayError { + SparseArrayError(String) +} + +///| +pub struct SparseArrayEntry { + coordinates : Array[Int] + value : Double +} + +///| +pub struct SparseArray { + dimensions : Array[Int] + entries : Array[SparseArrayEntry] +} + +///| +pub fn SparseArrayEntry::coordinates(self : SparseArrayEntry) -> Array[Int] { + self.coordinates.copy() +} + +///| +pub fn SparseArrayEntry::value(self : SparseArrayEntry) -> Double { + self.value +} + +///| +fn sparse_array_compare_coordinates( + left : Array[Int], + right : Array[Int], +) -> Int { + let limit = if left.length() < right.length() { + left.length() + } else { + right.length() + } + let mut index = 0 + while index < limit { + if left[index] < right[index] { + return -1 + } + if left[index] > right[index] { + return 1 + } + index = index + 1 + } + if left.length() < right.length() { + -1 + } else if left.length() > right.length() { + 1 + } else { + 0 + } +} + +///| +fn sparse_array_validate_dimensions( + dimensions : Array[Int], +) -> Unit raise SparseArrayError { + if dimensions.length() == 0 { + raise SparseArrayError("SparseArray requires at least one dimension") + } + let mut dimension = 0 + while dimension < dimensions.length() { + if dimensions[dimension] < 0 { + raise SparseArrayError("SparseArray dimensions must be non-negative") + } + dimension = dimension + 1 + } +} + +///| +fn sparse_array_length(dimensions : Array[Int]) -> Int raise SparseArrayError { + let mut result = 1 + let mut dimension = 0 + while dimension < dimensions.length() { + let extent = dimensions[dimension] + if extent == 0 { + return 0 + } + let next = result * extent + if next / extent != result { + raise SparseArrayError("SparseArray dimensions are too large") + } + result = next + dimension = dimension + 1 + } + result +} + +///| +fn sparse_array_validate_coordinate( + dimensions : Array[Int], + coordinates : Array[Int], +) -> Unit raise SparseArrayError { + if coordinates.length() != dimensions.length() { + raise SparseArrayError( + "SparseArray coordinate rank does not match its dimensions", + ) + } + let mut dimension = 0 + while dimension < dimensions.length() { + let coordinate = coordinates[dimension] + if coordinate < 0 || coordinate >= dimensions[dimension] { + raise SparseArrayError( + "SparseArray coordinate is outside dimension " + dimension.to_string(), + ) + } + dimension = dimension + 1 + } +} + +///| +fn sparse_array_build( + dimensions : Array[Int], + entries : Array[SparseArrayEntry], +) -> SparseArray raise SparseArrayError { + sparse_array_validate_dimensions(dimensions) + ignore(sparse_array_length(dimensions)) + let sorted : Array[SparseArrayEntry] = [] + let mut index = 0 + while index < entries.length() { + sparse_array_validate_coordinate(dimensions, entries[index].coordinates) + sorted.push(SparseArrayEntry::{ + coordinates: entries[index].coordinates.copy(), + value: entries[index].value, + }) + index = index + 1 + } + sorted.sort_by(fn(left : SparseArrayEntry, right : SparseArrayEntry) -> Int { + sparse_array_compare_coordinates(left.coordinates, right.coordinates) + }) + let canonical : Array[SparseArrayEntry] = [] + index = 0 + while index < sorted.length() { + let coordinates = sorted[index].coordinates.copy() + let mut value = sorted[index].value + index = index + 1 + while index < sorted.length() && + sparse_array_compare_coordinates( + coordinates, + sorted[index].coordinates, + ) == + 0 { + value = value + sorted[index].value + index = index + 1 + } + if value != 0.0 { + canonical.push(SparseArrayEntry::{ coordinates, value }) + } + } + SparseArray::{ dimensions: dimensions.copy(), entries: canonical } +} + +///| +/// Construct a sparse array from coordinates and values. +/// +/// Coordinates are zero-based. Duplicate coordinates are added together and +/// entries whose resulting value is zero are omitted. +pub fn SparseArray::from_coo( + dimensions : Array[Int], + coordinates : Array[Array[Int]], + values : Array[Double], +) -> SparseArray raise SparseArrayError { + if coordinates.length() != values.length() { + raise SparseArrayError( + "SparseArray coordinates and values must have the same length", + ) + } + let entries : Array[SparseArrayEntry] = [] + let mut index = 0 + while index < values.length() { + entries.push(SparseArrayEntry::{ + coordinates: coordinates[index].copy(), + value: values[index], + }) + index = index + 1 + } + sparse_array_build(dimensions, entries) +} + +///| +/// Construct an all-zero sparse array. +pub fn SparseArray::zeros( + dimensions : Array[Int], +) -> SparseArray raise SparseArrayError { + sparse_array_build(dimensions, []) +} + +///| +fn sparse_array_linear_to_coordinates( + linear_index : Int, + dimensions : Array[Int], +) -> Array[Int] { + let coordinates : Array[Int] = [] + let mut remaining = linear_index + let mut dimension = 0 + while dimension < dimensions.length() { + coordinates.push(remaining % dimensions[dimension]) + remaining = remaining / dimensions[dimension] + dimension = dimension + 1 + } + coordinates +} + +///| +fn sparse_array_coordinates_to_linear( + coordinates : Array[Int], + dimensions : Array[Int], +) -> Int { + let mut linear_index = 0 + let mut stride = 1 + let mut dimension = 0 + while dimension < dimensions.length() { + linear_index = linear_index + coordinates[dimension] * stride + stride = stride * dimensions[dimension] + dimension = dimension + 1 + } + linear_index +} + +///| +/// Construct from column-major flat data, matching R array layout. +pub fn SparseArray::from_flat( + dimensions : Array[Int], + data : Array[Double], +) -> SparseArray raise SparseArrayError { + sparse_array_validate_dimensions(dimensions) + let expected = sparse_array_length(dimensions) + if data.length() != expected { + raise SparseArrayError( + "Flat data length does not match SparseArray dimensions", + ) + } + let entries : Array[SparseArrayEntry] = [] + let mut index = 0 + while index < data.length() { + if data[index] != 0.0 { + entries.push(SparseArrayEntry::{ + coordinates: sparse_array_linear_to_coordinates(index, dimensions), + value: data[index], + }) + } + index = index + 1 + } + sparse_array_build(dimensions, entries) +} + +///| +/// Construct a two-dimensional sparse array from a row-major MoonBit matrix. +pub fn SparseArray::from_matrix( + data : Array[Array[Double]], +) -> SparseArray raise SparseArrayError { + let rows = data.length() + let columns = if rows == 0 { 0 } else { data[0].length() } + let coordinates : Array[Array[Int]] = [] + let values : Array[Double] = [] + let mut row = 0 + while row < rows { + if data[row].length() != columns { + raise SparseArrayError("SparseArray input matrix must be rectangular") + } + let mut column = 0 + while column < columns { + if data[row][column] != 0.0 { + coordinates.push([row, column]) + values.push(data[row][column]) + } + column = column + 1 + } + row = row + 1 + } + SparseArray::from_coo([rows, columns], coordinates, values) +} + +///| +pub fn SparseArray::ndim(self : SparseArray) -> Int { + self.dimensions.length() +} + +///| +pub fn SparseArray::dim(self : SparseArray) -> Array[Int] { + self.dimensions.copy() +} + +///| +pub fn SparseArray::length(self : SparseArray) -> Int raise SparseArrayError { + sparse_array_length(self.dimensions) +} + +///| +pub fn SparseArray::nnzero(self : SparseArray) -> Int { + self.entries.length() +} + +///| +pub fn SparseArray::density( + self : SparseArray, +) -> Double raise SparseArrayError { + let total = self.length() + if total == 0 { + 0.0 + } else { + self.entries.length().to_double() / total.to_double() + } +} + +///| +pub fn SparseArray::is_sparse(self : SparseArray) -> Bool { + true +} + +///| +pub fn SparseArray::nzcoordinates(self : SparseArray) -> Array[Array[Int]] { + let result : Array[Array[Int]] = [] + let mut index = 0 + while index < self.entries.length() { + result.push(self.entries[index].coordinates.copy()) + index = index + 1 + } + result +} + +///| +pub fn SparseArray::nzvalues(self : SparseArray) -> Array[Double] { + let result : Array[Double] = [] + let mut index = 0 + while index < self.entries.length() { + result.push(self.entries[index].value) + index = index + 1 + } + result +} + +///| +pub fn SparseArray::nonzero_entries( + self : SparseArray, +) -> Array[SparseArrayEntry] { + let result : Array[SparseArrayEntry] = [] + let mut index = 0 + while index < self.entries.length() { + result.push(SparseArrayEntry::{ + coordinates: self.entries[index].coordinates.copy(), + value: self.entries[index].value, + }) + index = index + 1 + } + result +} + +///| +pub fn SparseArray::get( + self : SparseArray, + coordinates : Array[Int], +) -> Double raise SparseArrayError { + sparse_array_validate_coordinate(self.dimensions, coordinates) + let mut low = 0 + let mut high = self.entries.length() + while low < high { + let middle = low + (high - low) / 2 + let comparison = sparse_array_compare_coordinates( + self.entries[middle].coordinates, + coordinates, + ) + if comparison < 0 { + low = middle + 1 + } else { + high = middle + } + } + if low < self.entries.length() && + sparse_array_compare_coordinates(self.entries[low].coordinates, coordinates) == + 0 { + self.entries[low].value + } else { + 0.0 + } +} + +///| +pub fn SparseArray::get_linear( + self : SparseArray, + linear_index : Int, +) -> Double raise SparseArrayError { + let total = self.length() + if linear_index < 0 || linear_index >= total { + raise SparseArrayError("SparseArray linear index is out of bounds") + } + self.get(sparse_array_linear_to_coordinates(linear_index, self.dimensions)) +} + +///| +/// Return a new array with one coordinate replaced. +pub fn SparseArray::with_value( + self : SparseArray, + coordinates : Array[Int], + value : Double, +) -> SparseArray raise SparseArrayError { + sparse_array_validate_coordinate(self.dimensions, coordinates) + let entries : Array[SparseArrayEntry] = [] + let mut index = 0 + while index < self.entries.length() { + if sparse_array_compare_coordinates( + self.entries[index].coordinates, + coordinates, + ) != + 0 { + entries.push(SparseArrayEntry::{ + coordinates: self.entries[index].coordinates.copy(), + value: self.entries[index].value, + }) + } + index = index + 1 + } + if value != 0.0 { + entries.push(SparseArrayEntry::{ coordinates: coordinates.copy(), value }) + } + sparse_array_build(self.dimensions, entries) +} + +///| +/// Return a new array after replacing several coordinates in order. +pub fn SparseArray::with_values( + self : SparseArray, + coordinates : Array[Array[Int]], + values : Array[Double], +) -> SparseArray raise SparseArrayError { + if coordinates.length() != values.length() { + raise SparseArrayError( + "Replacement coordinates and values must have the same length", + ) + } + let mut result = self + let mut index = 0 + while index < values.length() { + result = result.with_value(coordinates[index], values[index]) + index = index + 1 + } + result +} + +///| +pub fn SparseArray::to_flat( + self : SparseArray, +) -> Array[Double] raise SparseArrayError { + let result = Array::make(self.length(), 0.0) + let mut index = 0 + while index < self.entries.length() { + let linear_index = sparse_array_coordinates_to_linear( + self.entries[index].coordinates, + self.dimensions, + ) + result[linear_index] = self.entries[index].value + index = index + 1 + } + result +} + +///| +pub fn SparseArray::to_dense_matrix( + self : SparseArray, +) -> Array[Array[Double]] raise SparseArrayError { + if self.ndim() != 2 { + raise SparseArrayError( + "Dense matrix conversion requires a two-dimensional SparseArray", + ) + } + let result : Array[Array[Double]] = [] + let mut row = 0 + while row < self.dimensions[0] { + result.push(Array::make(self.dimensions[1], 0.0)) + row = row + 1 + } + let mut index = 0 + while index < self.entries.length() { + let coordinates = self.entries[index].coordinates + result[coordinates[0]][coordinates[1]] = self.entries[index].value + index = index + 1 + } + result +} + +///| +/// Subset every dimension using zero-based index vectors. +/// +/// The output dimension sizes and order follow the supplied vectors. +/// Repeated indices are preserved without materializing implicit zero values. +pub fn SparseArray::subset( + self : SparseArray, + indices : Array[Array[Int]], +) -> SparseArray raise SparseArrayError { + if indices.length() != self.ndim() { + raise SparseArrayError( + "SparseArray subset requires one index vector per dimension", + ) + } + let output_dimensions : Array[Int] = [] + let mut dimension = 0 + while dimension < self.ndim() { + output_dimensions.push(indices[dimension].length()) + let mut index = 0 + while index < indices[dimension].length() { + let selected = indices[dimension][index] + if selected < 0 || selected >= self.dimensions[dimension] { + raise SparseArrayError( + "SparseArray subset index is out of bounds in dimension " + + dimension.to_string(), + ) + } + index = index + 1 + } + dimension = dimension + 1 + } + let output_entries : Array[SparseArrayEntry] = [] + let mut entry_index = 0 + while entry_index < self.entries.length() { + let matches : Array[Array[Int]] = [] + let mut include = true + dimension = 0 + while dimension < self.ndim() { + let positions : Array[Int] = [] + let mut output_index = 0 + while output_index < indices[dimension].length() { + if indices[dimension][output_index] == + self.entries[entry_index].coordinates[dimension] { + positions.push(output_index) + } + output_index = output_index + 1 + } + if positions.length() == 0 { + include = false + } + matches.push(positions) + dimension = dimension + 1 + } + if include { + let mut combination_count = 1 + dimension = 0 + while dimension < matches.length() { + combination_count = combination_count * matches[dimension].length() + dimension = dimension + 1 + } + let mut combination = 0 + while combination < combination_count { + let output_coordinates : Array[Int] = [] + let mut remaining = combination + dimension = 0 + while dimension < matches.length() { + let count = matches[dimension].length() + output_coordinates.push(matches[dimension][remaining % count]) + remaining = remaining / count + dimension = dimension + 1 + } + output_entries.push(SparseArrayEntry::{ + coordinates: output_coordinates, + value: self.entries[entry_index].value, + }) + combination = combination + 1 + } + } + entry_index = entry_index + 1 + } + sparse_array_build(output_dimensions, output_entries) +} + +///| +/// Slice dimensions with zero-based, end-exclusive ranges. +pub fn SparseArray::slice( + self : SparseArray, + starts : Array[Int], + ends : Array[Int], +) -> SparseArray raise SparseArrayError { + if starts.length() != self.ndim() || ends.length() != self.ndim() { + raise SparseArrayError("SparseArray slice bounds must match the array rank") + } + let indices : Array[Array[Int]] = [] + let mut dimension = 0 + while dimension < self.ndim() { + if starts[dimension] < 0 || + ends[dimension] < starts[dimension] || + ends[dimension] > self.dimensions[dimension] { + raise SparseArrayError( + "SparseArray slice bounds are invalid in dimension " + + dimension.to_string(), + ) + } + let selected : Array[Int] = [] + let mut index = starts[dimension] + while index < ends[dimension] { + selected.push(index) + index = index + 1 + } + indices.push(selected) + dimension = dimension + 1 + } + self.subset(indices) +} + +///| +/// Permute dimensions. Output dimension i is input dimension permutation[i]. +pub fn SparseArray::aperm( + self : SparseArray, + permutation : Array[Int], +) -> SparseArray raise SparseArrayError { + if permutation.length() != self.ndim() { + raise SparseArrayError("SparseArray permutation length must match its rank") + } + let seen = Array::make(self.ndim(), false) + let output_dimensions : Array[Int] = [] + let mut dimension = 0 + while dimension < permutation.length() { + let source = permutation[dimension] + if source < 0 || source >= self.ndim() || seen[source] { + raise SparseArrayError( + "SparseArray permutation must contain each dimension exactly once", + ) + } + seen[source] = true + output_dimensions.push(self.dimensions[source]) + dimension = dimension + 1 + } + let output_entries : Array[SparseArrayEntry] = [] + let mut entry_index = 0 + while entry_index < self.entries.length() { + let output_coordinates : Array[Int] = [] + dimension = 0 + while dimension < permutation.length() { + output_coordinates.push( + self.entries[entry_index].coordinates[permutation[dimension]], + ) + dimension = dimension + 1 + } + output_entries.push(SparseArrayEntry::{ + coordinates: output_coordinates, + value: self.entries[entry_index].value, + }) + entry_index = entry_index + 1 + } + sparse_array_build(output_dimensions, output_entries) +} + +///| +pub fn SparseArray::transpose( + self : SparseArray, +) -> SparseArray raise SparseArrayError { + if self.ndim() != 2 { + raise SparseArrayError( + "SparseArray transpose requires a two-dimensional array", + ) + } + self.aperm([1, 0]) +} + +///| +/// Bind two arrays along one dimension. +pub fn SparseArray::bind( + self : SparseArray, + other : SparseArray, + along : Int, +) -> SparseArray raise SparseArrayError { + if self.ndim() != other.ndim() { + raise SparseArrayError("SparseArray bind requires arrays of equal rank") + } + if along < 0 || along >= self.ndim() { + raise SparseArrayError("SparseArray bind dimension is out of bounds") + } + let output_dimensions = self.dimensions.copy() + let mut dimension = 0 + while dimension < self.ndim() { + if dimension != along && + self.dimensions[dimension] != other.dimensions[dimension] { + raise SparseArrayError( + "SparseArray bind dimensions differ outside the binding margin", + ) + } + dimension = dimension + 1 + } + output_dimensions[along] = self.dimensions[along] + other.dimensions[along] + let output_entries = self.nonzero_entries() + let mut index = 0 + while index < other.entries.length() { + let coordinates = other.entries[index].coordinates.copy() + coordinates[along] = coordinates[along] + self.dimensions[along] + output_entries.push(SparseArrayEntry::{ + coordinates, + value: other.entries[index].value, + }) + index = index + 1 + } + sparse_array_build(output_dimensions, output_entries) +} + +///| +fn sparse_array_require_same_dimensions( + left : SparseArray, + right : SparseArray, +) -> Unit raise SparseArrayError { + if left.dimensions != right.dimensions { + raise SparseArrayError( + "SparseArray arithmetic requires identical dimensions", + ) + } +} + +///| +fn sparse_array_add_scaled( + left : SparseArray, + right : SparseArray, + right_scale : Double, +) -> SparseArray raise SparseArrayError { + sparse_array_require_same_dimensions(left, right) + let output : Array[SparseArrayEntry] = [] + let mut left_index = 0 + let mut right_index = 0 + while left_index < left.entries.length() || + right_index < right.entries.length() { + if left_index >= left.entries.length() { + output.push(SparseArrayEntry::{ + coordinates: right.entries[right_index].coordinates.copy(), + value: right.entries[right_index].value * right_scale, + }) + right_index = right_index + 1 + } else if right_index >= right.entries.length() { + output.push(SparseArrayEntry::{ + coordinates: left.entries[left_index].coordinates.copy(), + value: left.entries[left_index].value, + }) + left_index = left_index + 1 + } else { + let comparison = sparse_array_compare_coordinates( + left.entries[left_index].coordinates, + right.entries[right_index].coordinates, + ) + if comparison < 0 { + output.push(SparseArrayEntry::{ + coordinates: left.entries[left_index].coordinates.copy(), + value: left.entries[left_index].value, + }) + left_index = left_index + 1 + } else if comparison > 0 { + output.push(SparseArrayEntry::{ + coordinates: right.entries[right_index].coordinates.copy(), + value: right.entries[right_index].value * right_scale, + }) + right_index = right_index + 1 + } else { + output.push(SparseArrayEntry::{ + coordinates: left.entries[left_index].coordinates.copy(), + value: left.entries[left_index].value + + right.entries[right_index].value * right_scale, + }) + left_index = left_index + 1 + right_index = right_index + 1 + } + } + } + sparse_array_build(left.dimensions, output) +} + +///| +pub fn SparseArray::add( + self : SparseArray, + other : SparseArray, +) -> SparseArray raise SparseArrayError { + sparse_array_add_scaled(self, other, 1.0) +} + +///| +pub fn SparseArray::subtract( + self : SparseArray, + other : SparseArray, +) -> SparseArray raise SparseArrayError { + sparse_array_add_scaled(self, other, -1.0) +} + +///| +pub fn SparseArray::hadamard( + self : SparseArray, + other : SparseArray, +) -> SparseArray raise SparseArrayError { + sparse_array_require_same_dimensions(self, other) + let output : Array[SparseArrayEntry] = [] + let mut left_index = 0 + let mut right_index = 0 + while left_index < self.entries.length() && + right_index < other.entries.length() { + let comparison = sparse_array_compare_coordinates( + self.entries[left_index].coordinates, + other.entries[right_index].coordinates, + ) + if comparison < 0 { + left_index = left_index + 1 + } else if comparison > 0 { + right_index = right_index + 1 + } else { + output.push(SparseArrayEntry::{ + coordinates: self.entries[left_index].coordinates.copy(), + value: self.entries[left_index].value * other.entries[right_index].value, + }) + left_index = left_index + 1 + right_index = right_index + 1 + } + } + sparse_array_build(self.dimensions, output) +} + +///| +pub fn SparseArray::scale( + self : SparseArray, + factor : Double, +) -> SparseArray raise SparseArrayError { + let output : Array[SparseArrayEntry] = [] + let mut index = 0 + while index < self.entries.length() { + output.push(SparseArrayEntry::{ + coordinates: self.entries[index].coordinates.copy(), + value: self.entries[index].value * factor, + }) + index = index + 1 + } + sparse_array_build(self.dimensions, output) +} + +///| +/// Apply a zero-preserving operation to all stored nonzero values. +pub fn SparseArray::map_nonzero( + self : SparseArray, + transform : (Double) -> Double, +) -> SparseArray raise SparseArrayError { + let output : Array[SparseArrayEntry] = [] + let mut index = 0 + while index < self.entries.length() { + output.push(SparseArrayEntry::{ + coordinates: self.entries[index].coordinates.copy(), + value: transform(self.entries[index].value), + }) + index = index + 1 + } + sparse_array_build(self.dimensions, output) +} + +///| +pub fn SparseArray::sum(self : SparseArray) -> Double { + let mut result = 0.0 + let mut index = 0 + while index < self.entries.length() { + result = result + self.entries[index].value + index = index + 1 + } + result +} + +///| +pub fn SparseArray::mean(self : SparseArray) -> Double? raise SparseArrayError { + let total = self.length() + if total == 0 { + None + } else { + Some(self.sum() / total.to_double()) + } +} + +///| +pub fn SparseArray::minimum( + self : SparseArray, +) -> Double? raise SparseArrayError { + let total = self.length() + if total == 0 { + return None + } + let mut result = if self.entries.length() < total { + 0.0 + } else { + self.entries[0].value + } + let mut index = 0 + while index < self.entries.length() { + if self.entries[index].value < result { + result = self.entries[index].value + } + index = index + 1 + } + Some(result) +} + +///| +pub fn SparseArray::maximum( + self : SparseArray, +) -> Double? raise SparseArrayError { + let total = self.length() + if total == 0 { + return None + } + let mut result = if self.entries.length() < total { + 0.0 + } else { + self.entries[0].value + } + let mut index = 0 + while index < self.entries.length() { + if self.entries[index].value > result { + result = self.entries[index].value + } + index = index + 1 + } + Some(result) +} + +///| +fn sparse_array_require_matrix( + array : SparseArray, +) -> Unit raise SparseArrayError { + if array.ndim() != 2 { + raise SparseArrayError( + "SparseArray operation requires a two-dimensional array", + ) + } +} + +///| +pub fn SparseArray::row_sums( + self : SparseArray, +) -> Array[Double] raise SparseArrayError { + sparse_array_require_matrix(self) + let result = Array::make(self.dimensions[0], 0.0) + let mut index = 0 + while index < self.entries.length() { + let row = self.entries[index].coordinates[0] + result[row] = result[row] + self.entries[index].value + index = index + 1 + } + result +} + +///| +pub fn SparseArray::column_sums( + self : SparseArray, +) -> Array[Double] raise SparseArrayError { + sparse_array_require_matrix(self) + let result = Array::make(self.dimensions[1], 0.0) + let mut index = 0 + while index < self.entries.length() { + let column = self.entries[index].coordinates[1] + result[column] = result[column] + self.entries[index].value + index = index + 1 + } + result +} + +///| +pub fn SparseArray::row_means( + self : SparseArray, +) -> Array[Double] raise SparseArrayError { + sparse_array_require_matrix(self) + if self.dimensions[1] == 0 { + raise SparseArrayError( + "Cannot compute row means for a matrix with zero columns", + ) + } + let result = self.row_sums() + let mut row = 0 + while row < result.length() { + result[row] = result[row] / self.dimensions[1].to_double() + row = row + 1 + } + result +} + +///| +pub fn SparseArray::column_means( + self : SparseArray, +) -> Array[Double] raise SparseArrayError { + sparse_array_require_matrix(self) + if self.dimensions[0] == 0 { + raise SparseArrayError( + "Cannot compute column means for a matrix with zero rows", + ) + } + let result = self.column_sums() + let mut column = 0 + while column < result.length() { + result[column] = result[column] / self.dimensions[0].to_double() + column = column + 1 + } + result +} + +///| +pub fn SparseArray::row_nonzero_counts( + self : SparseArray, +) -> Array[Int] raise SparseArrayError { + sparse_array_require_matrix(self) + let result = Array::make(self.dimensions[0], 0) + let mut index = 0 + while index < self.entries.length() { + let row = self.entries[index].coordinates[0] + result[row] = result[row] + 1 + index = index + 1 + } + result +} + +///| +pub fn SparseArray::column_nonzero_counts( + self : SparseArray, +) -> Array[Int] raise SparseArrayError { + sparse_array_require_matrix(self) + let result = Array::make(self.dimensions[1], 0) + let mut index = 0 + while index < self.entries.length() { + let column = self.entries[index].coordinates[1] + result[column] = result[column] + 1 + index = index + 1 + } + result +} + +///| +/// Sparse matrix multiplication. The result is dense, matching the +/// Bioconductor SparseMatrix multiplication contract. +pub fn SparseArray::matmul( + self : SparseArray, + other : SparseArray, +) -> Array[Array[Double]] raise SparseArrayError { + sparse_array_require_matrix(self) + sparse_array_require_matrix(other) + if self.dimensions[1] != other.dimensions[0] { + raise SparseArrayError( + "SparseArray matrix multiplication dimensions are incompatible", + ) + } + let result : Array[Array[Double]] = [] + let mut row = 0 + while row < self.dimensions[0] { + result.push(Array::make(other.dimensions[1], 0.0)) + row = row + 1 + } + let mut left_index = 0 + while left_index < self.entries.length() { + let left_coordinates = self.entries[left_index].coordinates + let mut right_index = 0 + while right_index < other.entries.length() { + let right_coordinates = other.entries[right_index].coordinates + if left_coordinates[1] == right_coordinates[0] { + let output_row = left_coordinates[0] + let output_column = right_coordinates[1] + result[output_row][output_column] = result[output_row][output_column] + + self.entries[left_index].value * other.entries[right_index].value + } + right_index = right_index + 1 + } + left_index = left_index + 1 + } + result +} + +///| +pub fn SparseArray::crossprod( + self : SparseArray, +) -> Array[Array[Double]] raise SparseArrayError { + self.transpose().matmul(self) +} + +///| +pub fn SparseArray::tcrossprod( + self : SparseArray, +) -> Array[Array[Double]] raise SparseArrayError { + self.matmul(self.transpose()) +} + +///| +pub fn SparseArray::summary( + self : SparseArray, +) -> String raise SparseArrayError { + let mut dimensions = "" + let mut index = 0 + while index < self.dimensions.length() { + if index > 0 { + dimensions = dimensions + " x " + } + dimensions = dimensions + self.dimensions[index].to_string() + index = index + 1 + } + "SparseArray(" + + dimensions + + ", nnzero=" + + self.nnzero().to_string() + + ", density=" + + self.density().to_string() + + ")" +} + +///| +pub fn sparse_array_sample() -> SparseArray raise SparseArrayError { + SparseArray::from_coo( + [4, 5, 2], + [[0, 0, 0], [1, 0, 0], [3, 2, 0], [0, 4, 1], [2, 1, 1]], + [10.0, 20.0, 30.0, 40.0, 50.0], + ) +} diff --git a/test/moonbit/sparse_array_test.mbt b/test/moonbit/sparse_array_test.mbt new file mode 100644 index 00000000..7126a137 --- /dev/null +++ b/test/moonbit/sparse_array_test.mbt @@ -0,0 +1,592 @@ +///| +fn sparse_array_matrix() -> @src.SparseArray { + @src.SparseArray::from_matrix([[1.0, 0.0, 2.0], [0.0, 3.0, 0.0]]) catch { + _ => abort("failed to create sparse matrix fixture") + } +} + +///| +test "sparse_array: canonical COO merges duplicates and removes zeros" { + let array = @src.SparseArray::from_coo( + [2, 3], + [[1, 2], [0, 1], [1, 2], [0, 0]], + [2.0, 3.0, -2.0, 0.0], + ) catch { + _ => abort("valid COO input should be accepted") + } + assert_eq(array.nnzero(), 1) + assert_eq(array.nzcoordinates(), [[0, 1]]) + assert_eq(array.nzvalues(), [3.0]) +} + +///| +test "sparse_array: dimensions length density and sparse marker" { + let array = @src.sparse_array_sample() catch { + _ => abort("sample should be valid") + } + assert_eq(array.ndim(), 3) + assert_eq(array.dim(), [4, 5, 2]) + assert_eq(array.length(), 40) + assert_eq(array.nnzero(), 5) + assert_eq(array.density(), 0.125) + assert_true(array.is_sparse()) +} + +///| +test "sparse_array: zero extent array is valid and empty" { + let array = @src.SparseArray::zeros([2, 0, 4]) catch { + _ => abort("zero extent should be valid") + } + assert_eq(array.length(), 0) + assert_eq(array.nnzero(), 0) + assert_eq(array.density(), 0.0) + assert_true(array.mean() is None) + assert_true(array.minimum() is None) + assert_true(array.maximum() is None) +} + +///| +test "sparse_array: rejects invalid dimensions" { + let empty_rank = try { + ignore(@src.SparseArray::zeros([])) + false + } catch { + SparseArrayError(_) => true + } + let negative_extent = try { + ignore(@src.SparseArray::zeros([2, -1])) + false + } catch { + SparseArrayError(_) => true + } + assert_true(empty_rank) + assert_true(negative_extent) +} + +///| +test "sparse_array: rejects malformed COO input" { + let length_mismatch = try { + ignore(@src.SparseArray::from_coo([2, 2], [[0, 0]], [])) + false + } catch { + SparseArrayError(_) => true + } + let rank_mismatch = try { + ignore(@src.SparseArray::from_coo([2, 2], [[0]], [1.0])) + false + } catch { + SparseArrayError(_) => true + } + let out_of_bounds = try { + ignore(@src.SparseArray::from_coo([2, 2], [[0, 2]], [1.0])) + false + } catch { + SparseArrayError(_) => true + } + assert_true(length_mismatch) + assert_true(rank_mismatch) + assert_true(out_of_bounds) +} + +///| +test "sparse_array: flat data uses R column-major ordering" { + let array = @src.SparseArray::from_flat([2, 3], [1.0, 2.0, 0.0, 3.0, 4.0, 0.0]) catch { + _ => abort("flat input should be valid") + } + assert_eq(array.to_dense_matrix(), [[1.0, 0.0, 4.0], [2.0, 3.0, 0.0]]) + assert_eq(array.to_flat(), [1.0, 2.0, 0.0, 3.0, 4.0, 0.0]) +} + +///| +test "sparse_array: rejects flat length mismatch" { + let raised = try { + ignore(@src.SparseArray::from_flat([2, 3], [1.0, 2.0])) + false + } catch { + SparseArrayError(_) => true + } + assert_true(raised) +} + +///| +test "sparse_array: matrix construction and dense conversion" { + let array = sparse_array_matrix() + assert_eq(array.dim(), [2, 3]) + assert_eq(array.nnzero(), 3) + assert_eq(array.to_dense_matrix(), [[1.0, 0.0, 2.0], [0.0, 3.0, 0.0]]) +} + +///| +test "sparse_array: rejects ragged matrix and multidimensional dense conversion" { + let ragged = try { + ignore(@src.SparseArray::from_matrix([[1.0], [2.0, 3.0]])) + false + } catch { + SparseArrayError(_) => true + } + let sample = @src.sparse_array_sample() catch { + _ => abort("sample should be valid") + } + let not_matrix = try { + ignore(sample.to_dense_matrix()) + false + } catch { + SparseArrayError(_) => true + } + assert_true(ragged) + assert_true(not_matrix) +} + +///| +test "sparse_array: coordinate and linear access" { + let array = sparse_array_matrix() + assert_eq(array.get([0, 0]), 1.0) + assert_eq(array.get([0, 1]), 0.0) + assert_eq(array.get([1, 1]), 3.0) + assert_eq(array.get_linear(0), 1.0) + assert_eq(array.get_linear(2), 0.0) + assert_eq(array.get_linear(3), 3.0) + assert_eq(array.get_linear(4), 2.0) +} + +///| +test "sparse_array: rejects invalid access" { + let array = sparse_array_matrix() + let bad_coordinate = try { + ignore(array.get([2, 0])) + false + } catch { + SparseArrayError(_) => true + } + let bad_rank = try { + ignore(array.get([0])) + false + } catch { + SparseArrayError(_) => true + } + let bad_linear = try { + ignore(array.get_linear(6)) + false + } catch { + SparseArrayError(_) => true + } + assert_true(bad_coordinate) + assert_true(bad_rank) + assert_true(bad_linear) +} + +///| +test "sparse_array: accessors return defensive coordinate copies" { + let array = sparse_array_matrix() + let dimensions = array.dim() + dimensions[0] = 99 + let coordinates = array.nzcoordinates() + coordinates[0][0] = 1 + let entries = array.nonzero_entries() + let first_coordinates = entries[0].coordinates() + first_coordinates[0] = 1 + assert_eq(array.dim(), [2, 3]) + assert_eq(array.get([0, 0]), 1.0) +} + +///| +test "sparse_array: immutable single-value assignment inserts replaces and removes" { + let original = sparse_array_matrix() + let inserted = original.with_value([1, 2], 4.0) + let replaced = inserted.with_value([0, 2], 5.0) + let removed = replaced.with_value([1, 1], 0.0) + assert_eq(original.get([1, 2]), 0.0) + assert_eq(inserted.get([1, 2]), 4.0) + assert_eq(replaced.get([0, 2]), 5.0) + assert_eq(removed.get([1, 1]), 0.0) + assert_eq(removed.nnzero(), 3) +} + +///| +test "sparse_array: ordered multiple assignment uses last replacement" { + let array = sparse_array_matrix().with_values([[0, 0], [1, 2], [0, 0]], [ + 8.0, 4.0, 9.0, + ]) + assert_eq(array.get([0, 0]), 9.0) + assert_eq(array.get([1, 2]), 4.0) +} + +///| +test "sparse_array: multiple assignment validates parallel lengths" { + let raised = try { + ignore(sparse_array_matrix().with_values([[0, 0]], [])) + false + } catch { + SparseArrayError(_) => true + } + assert_true(raised) +} + +///| +test "sparse_array: subset preserves order and repeated indices" { + let subset = sparse_array_matrix().subset([[1, 0, 1], [2, 1]]) + assert_eq(subset.dim(), [3, 2]) + assert_eq(subset.to_dense_matrix(), [[0.0, 3.0], [2.0, 0.0], [0.0, 3.0]]) + assert_eq(subset.nnzero(), 3) +} + +///| +test "sparse_array: empty subset remains sparse" { + let subset = sparse_array_matrix().subset([[], [0, 1]]) + assert_eq(subset.dim(), [0, 2]) + assert_eq(subset.length(), 0) + assert_eq(subset.nnzero(), 0) +} + +///| +test "sparse_array: subset validates rank and bounds" { + let array = sparse_array_matrix() + let bad_rank = try { + ignore(array.subset([[0, 1]])) + false + } catch { + SparseArrayError(_) => true + } + let bad_index = try { + ignore(array.subset([[0, 2], [0]])) + false + } catch { + SparseArrayError(_) => true + } + assert_true(bad_rank) + assert_true(bad_index) +} + +///| +test "sparse_array: end-exclusive multidimensional slice" { + let sliced = sparse_array_matrix().slice([0, 1], [2, 3]) + assert_eq(sliced.dim(), [2, 2]) + assert_eq(sliced.to_dense_matrix(), [[0.0, 2.0], [3.0, 0.0]]) +} + +///| +test "sparse_array: slice validates bounds" { + let array = sparse_array_matrix() + let bad_rank = try { + ignore(array.slice([0], [1])) + false + } catch { + SparseArrayError(_) => true + } + let reversed = try { + ignore(array.slice([1, 0], [0, 2])) + false + } catch { + SparseArrayError(_) => true + } + let too_large = try { + ignore(array.slice([0, 0], [3, 2])) + false + } catch { + SparseArrayError(_) => true + } + assert_true(bad_rank) + assert_true(reversed) + assert_true(too_large) +} + +///| +test "sparse_array: aperm reorders multidimensional coordinates" { + let sample = @src.sparse_array_sample() catch { + _ => abort("sample should be valid") + } + let permuted = sample.aperm([2, 0, 1]) + assert_eq(permuted.dim(), [2, 4, 5]) + assert_eq(permuted.get([1, 0, 4]), 40.0) + assert_eq(permuted.get([1, 2, 1]), 50.0) +} + +///| +test "sparse_array: aperm validates complete permutation" { + let sample = @src.sparse_array_sample() catch { + _ => abort("sample should be valid") + } + let wrong_length = try { + ignore(sample.aperm([1, 0])) + false + } catch { + SparseArrayError(_) => true + } + let duplicate = try { + ignore(sample.aperm([0, 0, 2])) + false + } catch { + SparseArrayError(_) => true + } + assert_true(wrong_length) + assert_true(duplicate) +} + +///| +test "sparse_array: matrix transpose remains sparse" { + let transposed = sparse_array_matrix().transpose() + assert_eq(transposed.dim(), [3, 2]) + assert_eq(transposed.to_dense_matrix(), [[1.0, 0.0], [0.0, 3.0], [2.0, 0.0]]) + assert_eq(transposed.nnzero(), 3) +} + +///| +test "sparse_array: transpose rejects non-matrix" { + let sample = @src.sparse_array_sample() catch { + _ => abort("sample should be valid") + } + let raised = try { + ignore(sample.transpose()) + false + } catch { + SparseArrayError(_) => true + } + assert_true(raised) +} + +///| +test "sparse_array: bind offsets coordinates along selected dimension" { + let left = @src.SparseArray::from_matrix([[1.0, 0.0], [0.0, 2.0]]) + let right = @src.SparseArray::from_matrix([[3.0, 4.0]]) + let bound = left.bind(right, 0) + assert_eq(bound.dim(), [3, 2]) + assert_eq(bound.to_dense_matrix(), [[1.0, 0.0], [0.0, 2.0], [3.0, 4.0]]) +} + +///| +test "sparse_array: bind validates rank margin and dimensions" { + let matrix = sparse_array_matrix() + let sample = @src.sparse_array_sample() catch { + _ => abort("sample should be valid") + } + let rank_mismatch = try { + ignore(matrix.bind(sample, 0)) + false + } catch { + SparseArrayError(_) => true + } + let bad_margin = try { + ignore(matrix.bind(matrix, 2)) + false + } catch { + SparseArrayError(_) => true + } + let other = @src.SparseArray::from_matrix([[1.0, 2.0]]) + let dimension_mismatch = try { + ignore(matrix.bind(other, 1)) + false + } catch { + SparseArrayError(_) => true + } + assert_true(rank_mismatch) + assert_true(bad_margin) + assert_true(dimension_mismatch) +} + +///| +test "sparse_array: addition merges coordinates and drops cancellation" { + let left = @src.SparseArray::from_matrix([[1.0, 0.0], [2.0, -3.0]]) + let right = @src.SparseArray::from_matrix([[-1.0, 4.0], [0.0, 3.0]]) + let result = left.add(right) + assert_eq(result.to_dense_matrix(), [[0.0, 4.0], [2.0, 0.0]]) + assert_eq(result.nnzero(), 2) +} + +///| +test "sparse_array: subtraction preserves sparse union" { + let left = @src.SparseArray::from_matrix([[1.0, 0.0], [2.0, -3.0]]) + let right = @src.SparseArray::from_matrix([[-1.0, 4.0], [0.0, 3.0]]) + assert_eq(left.subtract(right).to_dense_matrix(), [[2.0, -4.0], [2.0, -6.0]]) +} + +///| +test "sparse_array: Hadamard product only visits coordinate intersection" { + let left = @src.SparseArray::from_matrix([[1.0, 0.0], [2.0, -3.0]]) + let right = @src.SparseArray::from_matrix([[-1.0, 4.0], [0.0, 3.0]]) + let result = left.hadamard(right) + assert_eq(result.to_dense_matrix(), [[-1.0, 0.0], [0.0, -9.0]]) + assert_eq(result.nnzero(), 2) +} + +///| +test "sparse_array: arithmetic validates dimensions" { + let left = sparse_array_matrix() + let right = @src.SparseArray::from_matrix([[1.0, 2.0]]) + let add_raised = try { + ignore(left.add(right)) + false + } catch { + SparseArrayError(_) => true + } + let product_raised = try { + ignore(left.hadamard(right)) + false + } catch { + SparseArrayError(_) => true + } + assert_true(add_raised) + assert_true(product_raised) +} + +///| +test "sparse_array: scale and zero-preserving map remove generated zeros" { + let array = sparse_array_matrix() + assert_eq(array.scale(0.0).nnzero(), 0) + let mapped = array.map_nonzero(fn(value : Double) -> Double { + if value == 2.0 { + 0.0 + } else { + value * value + } + }) + assert_eq(mapped.to_dense_matrix(), [[1.0, 0.0, 0.0], [0.0, 9.0, 0.0]]) + assert_eq(mapped.nnzero(), 2) +} + +///| +test "sparse_array: whole-array summaries include implicit zeros" { + let array = @src.SparseArray::from_matrix([[-2.0, 0.0, 5.0], [0.0, 0.0, 1.0]]) + assert_eq(array.sum(), 4.0) + match array.mean() { + Some(value) => assert_true((value - 4.0 / 6.0).abs() < 1.0e-12) + None => assert_true(false) + } + match array.minimum() { + Some(value) => assert_eq(value, -2.0) + None => assert_true(false) + } + match array.maximum() { + Some(value) => assert_eq(value, 5.0) + None => assert_true(false) + } +} + +///| +test "sparse_array: extrema do not inject zero into fully dense arrays" { + let array = @src.SparseArray::from_matrix([[-2.0, -1.0]]) + match array.minimum() { + Some(value) => assert_eq(value, -2.0) + None => assert_true(false) + } + match array.maximum() { + Some(value) => assert_eq(value, -1.0) + None => assert_true(false) + } +} + +///| +test "sparse_array: row and column sums and means" { + let array = @src.SparseArray::from_matrix([[-2.0, 0.0, 5.0], [0.0, 0.0, 1.0]]) + assert_eq(array.row_sums(), [3.0, 1.0]) + assert_eq(array.column_sums(), [-2.0, 0.0, 6.0]) + let row_means = array.row_means() + assert_eq(row_means[0], 1.0) + assert_true((row_means[1] - 1.0 / 3.0).abs() < 1.0e-12) + assert_eq(array.column_means(), [-1.0, 0.0, 3.0]) +} + +///| +test "sparse_array: row and column nonzero counts" { + let array = sparse_array_matrix() + assert_eq(array.row_nonzero_counts(), [2, 1]) + assert_eq(array.column_nonzero_counts(), [1, 1, 1]) +} + +///| +test "sparse_array: matrix summaries reject rank and empty means" { + let sample = @src.sparse_array_sample() catch { + _ => abort("sample should be valid") + } + let rank_raised = try { + ignore(sample.row_sums()) + false + } catch { + SparseArrayError(_) => true + } + let no_columns = @src.SparseArray::zeros([2, 0]) catch { + _ => abort("zero-column matrix should be valid") + } + let row_mean_raised = try { + ignore(no_columns.row_means()) + false + } catch { + SparseArrayError(_) => true + } + let no_rows = @src.SparseArray::zeros([0, 2]) catch { + _ => abort("zero-row matrix should be valid") + } + let column_mean_raised = try { + ignore(no_rows.column_means()) + false + } catch { + SparseArrayError(_) => true + } + assert_true(rank_raised) + assert_true(row_mean_raised) + assert_true(column_mean_raised) +} + +///| +test "sparse_array: sparse matrix multiplication returns dense result" { + let left = sparse_array_matrix() + let right = @src.SparseArray::from_matrix([[0.0, 4.0], [5.0, 0.0], [6.0, 7.0]]) + assert_eq(left.matmul(right), [[12.0, 18.0], [15.0, 0.0]]) +} + +///| +test "sparse_array: crossprod and tcrossprod" { + let array = sparse_array_matrix() + assert_eq(array.crossprod(), [ + [1.0, 0.0, 2.0], + [0.0, 9.0, 0.0], + [2.0, 0.0, 4.0], + ]) + assert_eq(array.tcrossprod(), [[5.0, 0.0], [0.0, 9.0]]) +} + +///| +test "sparse_array: matrix multiplication validates rank and dimensions" { + let matrix = sparse_array_matrix() + let incompatible = @src.SparseArray::from_matrix([[1.0, 2.0]]) + let dimension_raised = try { + ignore(matrix.matmul(incompatible)) + false + } catch { + SparseArrayError(_) => true + } + let sample = @src.sparse_array_sample() catch { + _ => abort("sample should be valid") + } + let rank_raised = try { + ignore(sample.matmul(matrix)) + false + } catch { + SparseArrayError(_) => true + } + assert_true(dimension_raised) + assert_true(rank_raised) +} + +///| +test "sparse_array: three-dimensional flat round trip" { + let original = @src.sparse_array_sample() catch { + _ => abort("sample should be valid") + } + let restored = @src.SparseArray::from_flat(original.dim(), original.to_flat()) catch { + _ => abort("round trip should be valid") + } + assert_eq(restored.dim(), original.dim()) + assert_eq(restored.nzcoordinates(), original.nzcoordinates()) + assert_eq(restored.nzvalues(), original.nzvalues()) +} + +///| +test "sparse_array: sample and summary" { + let sample = @src.sparse_array_sample() catch { + _ => abort("sample should be valid") + } + let summary = sample.summary() + assert_true(summary.contains("SparseArray(4 x 5 x 2")) + assert_true(summary.contains("nnzero=5")) + assert_true(summary.contains("density=0.125")) +} From 49bdf34f589ca53b0589b35a6b0c57204bb1828f Mon Sep 17 00:00:00 2001 From: eda Date: Tue, 4 Aug 2026 17:45:51 +0800 Subject: [PATCH 08/41] #28 /8409 feat(cealign): Bio.PDB.cealign CEAligner CA/C4 AFP CE Z-score QCP --- README.md | 25 +- examples/cealign_demo/main.mbt | 87 ++ examples/cealign_demo/moon.pkg | 5 + src/cealign.mbt | 1028 ++++++++++++++++++++++++ src/qcp_superimposer.mbt | 100 ++- test/moonbit/cealign_test.mbt | 725 +++++++++++++++++ test/moonbit/qcp_superimposer_test.mbt | 26 +- 7 files changed, 1985 insertions(+), 11 deletions(-) create mode 100644 examples/cealign_demo/main.mbt create mode 100644 examples/cealign_demo/moon.pkg create mode 100644 src/cealign.mbt create mode 100644 test/moonbit/cealign_test.mbt diff --git a/README.md b/README.md index 46ae890e..f5d20510 100644 --- a/README.md +++ b/README.md @@ -34,6 +34,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **HH-suite HHR** | Biopython `Bio.Align.hhr` | HHsearch/HHblits HHR解析、profile-profile比对、命中筛选、坐标映射、序列化往返 | ✅ | | **系统发育树** | Biopython `Bio.Phylo` | 树结构、Newick 解析、距离计算、可视化 | ✅ | | **PDB 结构** | Biopython `Bio.PDB` | 原子/残基/链解析、结构操作 | ✅ | +| **CE 结构比对** | Biopython `Bio.PDB.cealign` | CA/C4'引导原子、AFP路径搜索、CE显著性、QCP刚体叠合、全原子变换 | ✅ | | **SAM/BAM/VCF** | pysam | 比对文件、变异检测、基因型查询 | ✅ | | **FASTA 索引** | pyfaidx | 快速随机访问、.fai 索引 | ✅ | | **机器学习特征** | scikit-learn | k-mer 频率、氨基酸组成、理化性质 | ✅ | @@ -234,6 +235,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **Affy** | Biopython `Bio.Affy` | Affymetrix芯片数据分析、RMA标准化、背景校正、分位数归一化 | ✅ | | **SVDSuperimposer** | Biopython `Bio.PDB.SVDSuperimposer` | SVD蛋白质结构叠合、旋转矩阵、平移向量、RMSD计算 | ✅ | | **QCPSuperimposer** | Biopython `Bio.PDB.QCPSuperimposer` | 四元数特征多项式结构叠合、高精度旋转矩阵、平移向量、RMSD计算 | ✅ | +| **CEAligner** | Biopython `Bio.PDB.cealign` | 组合扩展结构比对、AFP单调路径、CE Z-score、局部索引优化、QCP最优叠合 | ✅ | | **ResidueDepth** | Biopython `Bio.PDB.ResidueDepth` | 残基深度计算、溶剂可及表面积(SASA)、表面/核心残基识别 | ✅ | | **StructureAlignment** | Biopython `Bio.PDB.StructureAlignment` | 多蛋白质结构比对、动态规划比对、RMSD/TM-score计算、渐进式多结构比对 | ✅ | | **KEGG** | Biopython `Bio.KEGG` | KEGG基因/通路/化合物/酶记录解析、通路分析 | ✅ | @@ -597,6 +599,7 @@ IvanAXu/BioSeqs/ │ ├── phenotype.mbt # Bio.phenotype 表型微阵列分析 (WellRecord/PlateRecord/PhenFitParams、logistic/Gompertz拟合、CSV/JSON解析) │ ├── blast_applications.mbt # Bio.Blast.Applications BLAST命令行工具包装 (8种BLAST变体、快速构建器、参数管理) │ ├── qcp_superimposer.mbt # QCP叠加 (四元数旋转、结构比对、RMSD计算、最优叠加) +│ ├── cealign.mbt # Bio.PDB.cealign CE组合扩展结构比对 (AFP路径、Z-score、QCP叠合、全原子变换) │ ├── psea.mbt # Bio.PDB.PSEA 二级结构预测 (PseaAtom/PseaResult、CA-CA距离、虚拟二面角、H/E/C分配、三态到八态转换) │ ├── sff_io.mbt # Bio.SeqIO.SffIO SFF二进制格式解析 (SffHeader/SffRead/SffFile、二进制编码/解码、质量修剪) │ ├── seq_complexity.mbt # 序列复杂度与组成分析 (Shannon熵、GC偏斜、混沌游戏表示) @@ -934,6 +937,7 @@ IvanAXu/BioSeqs/ │ ├── edaseq_demo/ # EDASeq RNA-seq探索性分析示例 (GC归一化、Loess校正、RPKM计算) │ ├── pdb_vectors_demo/ # Bio.PDB.vectors 3D向量与旋转矩阵示例 (Vector3运算、Kabsch叠合、二面角计算) │ ├── qcp_superimposer_demo/ # Bio.PDB.QCPSuperimposer 四元数结构叠合示例 +│ ├── cealign_demo/ # Bio.PDB.cealign CE组合扩展结构比对、路径统计与不可变全原子变换示例 │ ├── circ_seq_demo/ # Bio.SeqUtils.CircSeq 环状DNA操作示例 (酶切分析、PCR引物设计、序列旋转) │ ├── align_abstract_demo/ # Bio.Align.AlignAbstract 抽象比对示例 (一致性序列、Shannon熵、同一性矩阵、简约信息位点) │ ├── maftools_demo/ # maftools 癌症基因组学示例 (MAF数据创建、突变分类、TMB计算、突变谱分析) @@ -1249,6 +1253,7 @@ IvanAXu/BioSeqs/ │ │ ├── prosite_test.mbt │ │ ├── psea_test.mbt │ │ ├── qcp_superimposer_test.mbt +│ │ ├── cealign_test.mbt │ │ ├── reactome_pa_test.mbt │ │ ├── residue_depth_test.mbt │ │ ├── rhdf5_test.mbt @@ -1432,7 +1437,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8373 个测试全部通过 +moon test # ✅ 8409 个测试全部通过 ``` ### 模块对照表 @@ -1494,6 +1499,7 @@ moon test # ✅ 8373 个测试全 | `pdb.mbt` | BioPython `Bio.PDB` | PDB 数据类型 | | `pdb_io.mbt` | BioPython `Bio.PDB.PDBIO` | PDB 文件 I/O | | `svd_superimposer.mbt` | BioPython `Bio.PDB.SVDSuperimposer` | SVD 蛋白质结构叠合 | +| `cealign.mbt` | BioPython `Bio.PDB.cealign` | CE组合扩展结构比对、AFP路径、CE显著性、QCP叠合与全原子变换 | | `neighbor_search.mbt` | BioPython `Bio.PDB.NeighborSearch` | KD 树近邻搜索 | | `mmcif.mbt` | BioPython `Bio.PDB.MMCIFParser` | mmCIF 格式解析 | | `pdb_vectors.mbt` | BioPython `Bio.PDB.vectors` | 3D向量/旋转矩阵、叉积、Kabsch叠合、二面角 | @@ -2770,6 +2776,12 @@ moon test # ✅ 8373 个测试全 稀疏变换支持不可变单点/批量赋值、重复索引子集、0-based end-exclusive 切片、任意维度 `aperm`、二维转置和按指定维度绑定；加减、Hadamard 乘积、缩放和非零映射直接处理规范化非零条目。统计 API 包括全数组 sum/mean/min/max（极值正确纳入隐式零）以及二维 row/column sums、means 和非零计数；二维稀疏矩阵还支持 `matmul`、`crossprod` 和 `tcrossprod`。当前实现采用可移植的规范化 COO，并未宣称覆盖官方包的完整 SVT 存储后端。 +### 243. CEAligner 组合扩展结构比对 (Biopython Bio.PDB.cealign) + +实现与 Biopython `Bio.PDB.cealign.CEAligner` 对应的组合扩展结构比对。`cealign_get_guide_atoms` 按模型、链和残基顺序提取引导原子，蛋白质优先使用 `CA`，缺失时回退到核酸 `C4'`；`CEAligner::set_reference` 保存不可变参考坐标，`align` 对移动结构建立分子内距离矩阵和 AFP 相似度矩阵，以 Biopython 阈值扩展严格单调的 CE 路径并保留最多 20 条候选。在最长候选路径中使用 `QCPSuperimposer` 选择最低 RMSD 叠合，默认窗口 8 时计算 CE 经验 Z-score，并可在显著路径上执行只接受 RMSD 降低的局部索引优化。 + +`CeAlignmentResult` 返回对齐索引、片段数、RMSD、Z-score、覆盖率、旋转矩阵和平移向量。`transform=true` 会将刚体变换应用到移动结构的全部原子，同时重建 `Structure` 以保证输入对象不被原地修改；`transform=false` 仅计算比对。公开辅助 API 还包括距离矩阵、片段相似度、路径搜索和独立结构变换，非法参数、引导原子缺失或结构长度不足时抛出 `CeAlignError`。 + ## 性能优化 ### 优化策略 @@ -2871,8 +2883,8 @@ moon test # ✅ 8373 个测试全 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8373 | -| 通过数 | 8373 | +| 总测试数 | 8409 | +| 通过数 | 8409 | | 失败数 | 0 | | 通过率 | 100% | @@ -3021,7 +3033,8 @@ moon test --update | uwot | `uwot_test.mbt` | 9 | | microbiome | `microbiome_test.mbt` | 33 | | tradeSeq | `tradeseq_test.mbt` | 12 | -| QCP叠加 | `qcp_superimposer_test.mbt` | 7 | +| QCP叠加 | `qcp_superimposer_test.mbt` | 8 | +| CEAligner | `cealign_test.mbt` | 35 | | 残基深度 | `residue_depth_test.mbt` | 10 | | 结构比对 | `structure_alignment_test.mbt` | 8 | | PDB向量 | `pdb_vectors_test.mbt` | 55 | @@ -3263,7 +3276,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 350 个示例程序，展示各模块的典型用法： +项目提供 351 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3339,6 +3352,7 @@ moon run cmd/bench/main.mbt | unigene_demo | NCBI UniGene cluster解析、序列/蛋白相似性/STS/转录本映射查询和序列化往返 | `moon run examples/unigene_demo/main.mbt` | | hhr_demo | HH-suite HHR元数据与profile比对解析、命中筛选、query-target坐标映射和序列化往返 | `moon run examples/hhr_demo` | | sparse_array_demo | SparseArray N维稀疏张量、切片/aperm、行列统计、稀疏算术和矩阵乘法 | `moon run examples/sparse_array_demo` | +| cealign_demo | CE组合扩展结构比对、AFP路径统计、CE显著性、QCP叠合与不可变全原子变换 | `moon run examples/cealign_demo` | | uniprot_io_demo | UniProt XML格式解析（蛋白质条目解析、功能注释提取、序列转换） | `moon run examples/uniprot_io_demo/main.mbt` | | chem_utils_demo | 化学计算工具（键长、键角、二面角、分子式量、氢键长度） | `moon run examples/chem_utils_demo/main.mbt` | | jaspar_demo | JASPAR PFM格式解析（模体矩阵解析、共有序列、PWM转换、序列扫描） | `moon run examples/jaspar_demo/main.mbt` | @@ -3541,6 +3555,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 UniGene 基因聚类记录解析（固定宽度多记录读取、类型化子记录查询、SCOUNT校验、平面文本序列化） - ✅ 实现 Bio.Align.hhr HH-suite HHR解析（元数据、命中摘要、多块profile比对、注释保留、过滤、坐标映射与序列化） - ✅ 实现 Bioconductor SparseArray N维稀疏数组（规范化COO、R列主序、切片/置换/绑定、稀疏算术、统计与矩阵乘法） +- ✅ 实现 Bio.PDB.cealign CE组合扩展结构比对（CA/C4'引导原子、AFP路径、CE Z-score、QCP叠合、局部优化与全原子变换） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/cealign_demo/main.mbt b/examples/cealign_demo/main.mbt new file mode 100644 index 00000000..a43e1551 --- /dev/null +++ b/examples/cealign_demo/main.mbt @@ -0,0 +1,87 @@ +///| +fn main { + println("=== Biopython Bio.PDB.cealign Demo ===") + let (reference, mobile) = @src.cealign_sample_structures() + let original_mobile_coordinate = mobile.get_atoms()[0].coord + + println("\n1. Configure a CE aligner") + let aligner = @src.CEAligner::new() catch { + _ => abort("failed to create CEAligner") + } + let configured = aligner.set_reference(reference) catch { + _ => abort("failed to set CE reference structure") + } + println( + " Window size / maximum gap: " + + configured.window_size.to_string() + + " / " + + configured.max_gap.to_string(), + ) + println( + " Reference guide atoms: " + configured.reference_length().to_string(), + ) + + println("\n2. Search CE fragment paths and superimpose structures") + let result = configured.align(mobile, transform=true, final_optimization=true) catch { + _ => abort("failed to align sample structures") + } + println(" " + result.summary()) + println( + " Aligned guide atoms / fragments: " + + result.path.aligned_length().to_string() + + " / " + + result.path.fragment_count.to_string(), + ) + println( + " RMSD / CE Z-score: " + + result.rmsd.to_string() + + " / " + + result.path.z_score.to_string(), + ) + println( + " Reference / mobile coverage: " + + result.reference_coverage().to_string() + + " / " + + result.mobile_coverage().to_string(), + ) + println( + " Final local optimization applied: " + + result.optimization_applied.to_string(), + ) + + println("\n3. Inspect the selected monotonic path") + let pairs = result.path.aligned_pairs() + let first = pairs[0] + let last = pairs[pairs.length() - 1] + println( + " First reference/mobile index: " + + first.0.to_string() + + " / " + + first.1.to_string(), + ) + println( + " Last reference/mobile index: " + + last.0.to_string() + + " / " + + last.1.to_string(), + ) + + println("\n4. Verify immutable all-atom transformation") + let unchanged_mobile_coordinate = mobile.get_atoms()[0].coord + let transformed_coordinate = result.structure.get_atoms()[0].coord + let reference_coordinate = reference.get_atoms()[0].coord + println( + " Input mobile coordinate unchanged: " + + (unchanged_mobile_coordinate.distance(original_mobile_coordinate) < 1.0e-12).to_string(), + ) + println( + " Transformed first guide distance to reference: " + + transformed_coordinate.distance(reference_coordinate).to_string(), + ) + println( + " Transformed atom count: " + + result.structure.get_atoms().length().to_string(), + ) + + println("\n=== Demo Complete ===") +} diff --git a/examples/cealign_demo/moon.pkg b/examples/cealign_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/cealign_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/cealign.mbt b/src/cealign.mbt new file mode 100644 index 00000000..d84b06b7 --- /dev/null +++ b/src/cealign.mbt @@ -0,0 +1,1028 @@ +///| +/// Protein structure alignment by Combinatorial Extension (CE). +/// +/// This module follows the core semantics of Biopython's +/// `Bio.PDB.cealign`: structures are represented by ordered CA or C4' guide +/// atoms, aligned fragment pairs are extended into monotonic paths, and the +/// longest paths are ranked by their post-superposition RMSD. + +///| +/// Error raised for invalid CE parameters or structures. +pub suberror CeAlignError { + CeAlignError(String) +} + +///| +/// A guide atom used by CEAligner. +/// +/// Proteins contribute CA atoms and nucleic acids contribute C4' atoms when +/// no CA atom is present in the residue. +pub struct CeGuideAtom { + model_id : Int + chain_id : Char + residue_number : Int + atom_name : String + coordinate : Vector3 +} + +///| +/// Create a CE guide atom. +pub fn CeGuideAtom::new( + model_id~ : Int, + chain_id~ : Char, + residue_number~ : Int, + atom_name~ : String, + coordinate~ : Vector3, +) -> CeGuideAtom { + CeGuideAtom::{ model_id, chain_id, residue_number, atom_name, coordinate } +} + +///| +/// One CE alignment path expanded to individual guide atom indices. +pub struct CeAlignmentPath { + reference_indices : Array[Int] + mobile_indices : Array[Int] + fragment_count : Int + similarity : Double + z_score : Double +} + +///| +/// Number of aligned guide atom pairs. +pub fn CeAlignmentPath::aligned_length(self : CeAlignmentPath) -> Int { + self.reference_indices.length() +} + +///| +/// Return aligned index pairs. +pub fn CeAlignmentPath::aligned_pairs( + self : CeAlignmentPath, +) -> Array[(Int, Int)] { + let pairs : Array[(Int, Int)] = [] + let mut index = 0 + while index < self.reference_indices.length() { + pairs.push((self.reference_indices[index], self.mobile_indices[index])) + index = index + 1 + } + pairs +} + +///| +/// Return a defensive copy of the reference indices. +pub fn CeAlignmentPath::reference_path(self : CeAlignmentPath) -> Array[Int] { + self.reference_indices.copy() +} + +///| +/// Return a defensive copy of the mobile indices. +pub fn CeAlignmentPath::mobile_path(self : CeAlignmentPath) -> Array[Int] { + self.mobile_indices.copy() +} + +///| +/// Result of aligning a mobile structure onto a reference structure. +pub struct CeAlignmentResult { + path : CeAlignmentPath + rmsd : Double + rotation : Array[Array[Double]] + translation : Array[Double] + reference_guide_count : Int + mobile_guide_count : Int + transformed : Bool + optimization_applied : Bool + structure : Structure +} + +///| +/// Fraction of reference guide atoms included in the alignment. +pub fn CeAlignmentResult::reference_coverage( + self : CeAlignmentResult, +) -> Double { + if self.reference_guide_count == 0 { + 0.0 + } else { + self.path.aligned_length().to_double() / + self.reference_guide_count.to_double() + } +} + +///| +/// Fraction of mobile guide atoms included in the alignment. +pub fn CeAlignmentResult::mobile_coverage(self : CeAlignmentResult) -> Double { + if self.mobile_guide_count == 0 { + 0.0 + } else { + self.path.aligned_length().to_double() / self.mobile_guide_count.to_double() + } +} + +///| +/// Return a defensive copy of the rotation matrix. +pub fn CeAlignmentResult::rotation_matrix( + self : CeAlignmentResult, +) -> Array[Array[Double]] { + let result : Array[Array[Double]] = [] + for row in self.rotation { + result.push(row.copy()) + } + result +} + +///| +/// Return a defensive copy of the translation vector. +pub fn CeAlignmentResult::translation_vector( + self : CeAlignmentResult, +) -> Array[Double] { + self.translation.copy() +} + +///| +/// Human-readable alignment summary. +pub fn CeAlignmentResult::summary(self : CeAlignmentResult) -> String { + "CEAlignment(aligned=" + + self.path.aligned_length().to_string() + + ", fragments=" + + self.path.fragment_count.to_string() + + ", rmsd=" + + self.rmsd.to_string() + + ", z_score=" + + self.path.z_score.to_string() + + ", reference_coverage=" + + self.reference_coverage().to_string() + + ", mobile_coverage=" + + self.mobile_coverage().to_string() + + ")" +} + +///| +/// Immutable CE aligner configuration and reference guide atom set. +pub struct CEAligner { + window_size : Int + max_gap : Int + reference_atoms : Array[CeGuideAtom] +} + +///| +/// Create a CEAligner. +pub fn CEAligner::new( + window_size? : Int = 8, + max_gap? : Int = 30, +) -> CEAligner raise CeAlignError { + if window_size <= 0 { + raise CeAlignError("window_size must be greater than zero") + } + if max_gap < 0 { + raise CeAlignError("max_gap must be non-negative") + } + CEAligner::{ window_size, max_gap, reference_atoms: [] } +} + +///| +/// Number of guide atoms in the current reference. +pub fn CEAligner::reference_length(self : CEAligner) -> Int { + self.reference_atoms.length() +} + +///| +/// Return a copy of the current reference coordinates. +pub fn CEAligner::reference_coordinates(self : CEAligner) -> Array[Vector3] { + let coordinates : Array[Vector3] = [] + for atom in self.reference_atoms { + coordinates.push(atom.coordinate) + } + coordinates +} + +///| +/// Extract ordered CA/C4' guide atoms from a structure. +/// +/// Ordering by model, chain, and residue number makes CE path construction +/// deterministic even when input chains are not stored in lexical order. +pub fn cealign_get_guide_atoms( + structure : Structure, +) -> Array[CeGuideAtom] raise CeAlignError { + let atoms : Array[CeGuideAtom] = [] + for model in structure.models { + for chain in model.chains { + for residue in chain.residues { + let guide = match residue.find_atom("CA") { + Some(atom) => Some(atom) + None => residue.find_atom("C4'") + } + match guide { + Some(atom) => + atoms.push( + CeGuideAtom::new( + model_id=model.id, + chain_id=chain.id, + residue_number=residue.resseq, + atom_name=atom.name, + coordinate=atom.coord, + ), + ) + None => () + } + } + } + } + atoms.sort_by(fn(left : CeGuideAtom, right : CeGuideAtom) -> Int { + if left.model_id < right.model_id { + -1 + } else if left.model_id > right.model_id { + 1 + } else if left.chain_id.to_int() < right.chain_id.to_int() { + -1 + } else if left.chain_id.to_int() > right.chain_id.to_int() { + 1 + } else if left.residue_number < right.residue_number { + -1 + } else if left.residue_number > right.residue_number { + 1 + } else { + 0 + } + }) + if atoms.length() == 0 { + raise CeAlignError( + "Structure " + structure.id + " does not have CA or C4' guide atoms", + ) + } + atoms +} + +///| +/// Set the immutable reference structure. +pub fn CEAligner::set_reference( + self : CEAligner, + structure : Structure, +) -> CEAligner raise CeAlignError { + let atoms = cealign_get_guide_atoms(structure) + if atoms.length() < self.window_size * 2 { + raise CeAlignError( + "Too few guide atoms in reference structure: " + + atoms.length().to_string() + + "; need at least " + + (self.window_size * 2).to_string(), + ) + } + CEAligner::{ ..self, reference_atoms: atoms } +} + +///| +/// Calculate a symmetric intramolecular distance matrix. +pub fn cealign_distance_matrix( + coordinates : Array[Vector3], +) -> Array[Array[Double]] { + let length = coordinates.length() + let matrix : Array[Array[Double]] = [] + let mut row = 0 + while row < length { + matrix.push(Array::make(length, 0.0)) + row = row + 1 + } + row = 0 + while row < length { + let mut column = row + while column < length { + let distance = coordinates[row].distance(coordinates[column]) + matrix[row][column] = distance + matrix[column][row] = distance + column = column + 1 + } + row = row + 1 + } + matrix +} + +///| +/// CE distance measure II for one aligned fragment pair. +/// +/// Values are non-positive; zero represents identical internal geometry. +pub fn cealign_fragment_similarity( + reference_distances : Array[Array[Double]], + mobile_distances : Array[Array[Double]], + reference_start : Int, + mobile_start : Int, + window_size : Int, +) -> Double { + if window_size <= 1 { + return 0.0 + } + if window_size == 2 { + return -(reference_distances[reference_start][reference_start + 1] - + mobile_distances[mobile_start][mobile_start + 1]).abs() + } + let mut difference = 0.0 + let mut first = 0 + while first < window_size - 2 { + let mut second = first + 2 + while second < window_size { + difference = difference + + (reference_distances[reference_start + first][reference_start + second] - + mobile_distances[mobile_start + first][mobile_start + second]).abs() + second = second + 1 + } + first = first + 1 + } + let term_count = (window_size - 1) * (window_size - 2) / 2 + -difference / term_count.to_double() +} + +///| +/// Build the CE aligned-fragment similarity matrix. +pub fn cealign_similarity_matrix( + reference : Array[Vector3], + mobile : Array[Vector3], + window_size : Int, +) -> Array[Array[Double]] raise CeAlignError { + if window_size <= 0 { + raise CeAlignError("window_size must be greater than zero") + } + if reference.length() < window_size || mobile.length() < window_size { + raise CeAlignError("coordinate sets must contain at least one full window") + } + let reference_distances = cealign_distance_matrix(reference) + let mobile_distances = cealign_distance_matrix(mobile) + let row_count = reference.length() - window_size + 1 + let column_count = mobile.length() - window_size + 1 + let similarity : Array[Array[Double]] = [] + let mut row = 0 + while row < row_count { + let values : Array[Double] = [] + let mut column = 0 + while column < column_count { + values.push( + cealign_fragment_similarity( + reference_distances, mobile_distances, row, column, window_size, + ), + ) + column = column + 1 + } + similarity.push(values) + row = row + 1 + } + similarity +} + +///| +struct CePathCandidate { + reference_starts : Array[Int] + mobile_starts : Array[Int] + fragment_count : Int + similarity : Double + z_score : Double +} + +///| +fn cealign_extension_similarity( + reference_distances : Array[Array[Double]], + mobile_distances : Array[Array[Double]], + reference_start_i : Int, + mobile_start_i : Int, + reference_start_j : Int, + mobile_start_j : Int, + window_size : Int, +) -> Double { + let last = window_size - 1 + let mut difference = (reference_distances[reference_start_i][reference_start_j] - + mobile_distances[mobile_start_i][mobile_start_j]).abs() + + (reference_distances[reference_start_i + last][reference_start_j + last] - + mobile_distances[mobile_start_i + last][mobile_start_j + last]).abs() + let mut offset = 1 + while offset < last { + difference = difference + + (reference_distances[reference_start_i + offset][reference_start_j + + last - + offset] - + mobile_distances[mobile_start_i + offset][mobile_start_j + last - offset]).abs() + offset = offset + 1 + } + -difference / window_size.to_double() +} + +///| +fn cealign_normal_survival(z : Double) -> Double { + if z <= 0.0 { + return 0.5 + } + let t = 1.0 / (1.0 + 0.2316419 * z) + let density = 0.3989422804014327 * @math.exp(-z * z / 2.0) + density * + t * + ( + 0.319381530 + + t * + (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))) + ) +} + +///| +fn cealign_inverse_survival(probability : Double) -> Double { + if probability >= 0.5 { + return 0.0 + } + let p = if probability < 1.0e-300 { 1.0e-300 } else { probability } + let eta = (-2.0 * @math.ln(p)).sqrt() + eta - + (2.515517 + 0.802853 * eta + 0.010328 * eta * eta) / + (1.0 + 1.432788 * eta + 0.189269 * eta * eta + 0.001308 * eta * eta * eta) +} + +///| +fn cealign_similarity_z_score( + fragment_count : Int, + similarity : Double, +) -> Double { + if fragment_count < 1 { + return 0.0 + } + let averages = [ + 2.54, 2.51, 2.72, 3.01, 3.31, 3.61, 3.90, 4.19, 4.47, 4.74, 4.99, 5.22, 5.46, + 5.70, 5.94, 6.13, 6.36, 6.52, 6.68, 6.91, + ] + let deviations = [ + 1.33, 0.88, 0.73, 0.71, 0.74, 0.80, 0.86, 0.92, 0.98, 1.04, 1.08, 1.10, 1.15, + 1.19, 1.23, 1.25, 1.32, 1.34, 1.36, 1.45, + ] + let average = if fragment_count <= 20 { + averages[fragment_count - 1] + } else { + 0.209874 * fragment_count.to_double() + 2.944714 + } + let deviation = if fragment_count <= 20 { + deviations[fragment_count - 1] + } else { + 0.039487 * fragment_count.to_double() + 0.675735 + } + let positive_similarity = -similarity + if positive_similarity > average { + 0.0 + } else { + (average - positive_similarity) / deviation + } +} + +///| +fn cealign_gap_z_score(fragment_count : Int, gap_count : Int) -> Double { + if fragment_count <= 1 { + return 0.0 + } + let averages = [ + 0.00, 11.50, 23.32, 35.95, 49.02, 62.44, 76.28, 90.26, 104.86, 119.97, 134.86, + 150.54, 164.86, 179.57, 194.39, 209.38, 224.74, 238.96, 253.72, 270.79, + ] + let deviations = [ + 0.00, 9.88, 14.34, 17.99, 21.10, 23.89, 26.55, 29.00, 31.11, 33.10, 35.02, 36.03, + 37.19, 38.82, 41.04, 43.35, 45.45, 48.41, 50.87, 52.27, + ] + let average = if fragment_count <= 20 { + averages[fragment_count - 1] + } else { + 14.949173 * fragment_count.to_double() - 14.581193 + } + let deviation = if fragment_count <= 20 { + deviations[fragment_count - 1] + } else { + 2.045067 * fragment_count.to_double() + 13.191095 + } + if gap_count.to_double() > average || deviation == 0.0 { + 0.0 + } else { + (average - gap_count.to_double()) / deviation + } +} + +///| +fn cealign_z_score( + window_size : Int, + fragment_count : Int, + similarity : Double, + gap_count : Int, +) -> Double { + if window_size != 8 { + return 0.0 + } + let similarity_z = cealign_similarity_z_score(fragment_count, similarity) + let gap_z = cealign_gap_z_score(fragment_count, gap_count) + let combined_probability = cealign_normal_survival(similarity_z) * + cealign_normal_survival(gap_z) + cealign_inverse_survival(combined_probability) +} + +///| +fn cealign_store_candidate( + candidates : Array[CePathCandidate], + candidate : CePathCandidate, +) -> Unit { + candidates.push(candidate) + candidates.sort_by(fn( + left : CePathCandidate, + right : CePathCandidate, + ) -> Int { + if left.fragment_count > right.fragment_count { + -1 + } else if left.fragment_count < right.fragment_count { + 1 + } else if left.similarity > right.similarity { + -1 + } else if left.similarity < right.similarity { + 1 + } else { + 0 + } + }) + if candidates.length() > 20 { + ignore(candidates.pop()) + } +} + +///| +fn cealign_expand_candidate( + candidate : CePathCandidate, + window_size : Int, +) -> CeAlignmentPath { + let reference_indices : Array[Int] = [] + let mobile_indices : Array[Int] = [] + let mut fragment = 0 + while fragment < candidate.fragment_count { + let mut offset = 0 + while offset < window_size { + reference_indices.push(candidate.reference_starts[fragment] + offset) + mobile_indices.push(candidate.mobile_starts[fragment] + offset) + offset = offset + 1 + } + fragment = fragment + 1 + } + CeAlignmentPath::{ + reference_indices, + mobile_indices, + fragment_count: candidate.fragment_count, + similarity: candidate.similarity, + z_score: candidate.z_score, + } +} + +///| +/// Find up to 20 CE paths, ordered by fragment count and similarity. +pub fn cealign_find_paths( + reference : Array[Vector3], + mobile : Array[Vector3], + window_size : Int, + max_gap : Int, +) -> Array[CeAlignmentPath] raise CeAlignError { + if window_size <= 0 { + raise CeAlignError("window_size must be greater than zero") + } + if max_gap < 0 { + raise CeAlignError("max_gap must be non-negative") + } + if reference.length() < window_size || mobile.length() < window_size { + raise CeAlignError("coordinate sets must contain at least one full window") + } + let reference_distances = cealign_distance_matrix(reference) + let mobile_distances = cealign_distance_matrix(mobile) + let similarity = cealign_similarity_matrix(reference, mobile, window_size) + let candidates : Array[CePathCandidate] = [] + let row_count = similarity.length() + let column_count = similarity[0].length() + let mut reference_start = 0 + while reference_start < row_count { + let mut mobile_start = 0 + while mobile_start < column_count { + if similarity[reference_start][mobile_start] > -3.0 { + let reference_starts = [reference_start] + let mobile_starts = [mobile_start] + let mut fragment_count = 1 + let mut path_similarity = similarity[reference_start][mobile_start] + let mut extending = true + while extending { + let previous_reference = reference_starts[fragment_count - 1] + let previous_mobile = mobile_starts[fragment_count - 1] + let mut best_reference = -1 + let mut best_mobile = -1 + let mut best_extension_similarity = -1000000.0 + let mut gap_slot = 0 + while gap_slot < max_gap * 2 + 1 { + let mut next_reference = previous_reference + window_size + let mut next_mobile = previous_mobile + window_size + if (gap_slot + 1) % 2 == 0 { + next_reference = next_reference + (gap_slot + 1) / 2 + } else { + next_mobile = next_mobile + (gap_slot + 1) / 2 + } + if next_reference < row_count && + next_mobile < column_count && + similarity[next_reference][next_mobile] > -3.0 { + let mut extension_similarity = 0.0 + let mut existing = 0 + while existing < fragment_count { + extension_similarity = extension_similarity + + cealign_extension_similarity( + reference_distances, + mobile_distances, + reference_starts[existing], + mobile_starts[existing], + next_reference, + next_mobile, + window_size, + ) + existing = existing + 1 + } + extension_similarity = extension_similarity / + fragment_count.to_double() + if extension_similarity > -4.0 && + extension_similarity > best_extension_similarity { + best_extension_similarity = extension_similarity + best_reference = next_reference + best_mobile = next_mobile + } + } + gap_slot = gap_slot + 1 + } + if best_reference < 0 { + extending = false + } else { + let count = fragment_count.to_double() + let current_terms = count + count * (count - 1.0) / 2.0 + let new_terms = count + 1.0 + count * (count + 1.0) / 2.0 + let new_similarity = ( + current_terms * path_similarity + + count * best_extension_similarity + + similarity[best_reference][best_mobile] + ) / + new_terms + if new_similarity > -4.0 { + reference_starts.push(best_reference) + mobile_starts.push(best_mobile) + fragment_count = fragment_count + 1 + path_similarity = new_similarity + } else { + extending = false + } + } + } + let mut gap_count = 0 + let mut fragment = 1 + while fragment < fragment_count { + gap_count = gap_count + + reference_starts[fragment] - + reference_starts[fragment - 1] - + 1 + gap_count = gap_count + + mobile_starts[fragment] - + mobile_starts[fragment - 1] - + 1 + fragment = fragment + 1 + } + cealign_store_candidate(candidates, CePathCandidate::{ + reference_starts, + mobile_starts, + fragment_count, + similarity: path_similarity, + z_score: cealign_z_score( + window_size, fragment_count, path_similarity, gap_count, + ), + }) + } + mobile_start = mobile_start + 1 + } + reference_start = reference_start + 1 + } + let paths : Array[CeAlignmentPath] = [] + for candidate in candidates { + paths.push(cealign_expand_candidate(candidate, window_size)) + } + paths +} + +///| +fn cealign_fit_path( + path : CeAlignmentPath, + reference : Array[Vector3], + mobile : Array[Vector3], +) -> QCPSuperimposer { + let fixed : Array[QCPAtomCoordinate] = [] + let moving : Array[QCPAtomCoordinate] = [] + let mut index = 0 + while index < path.reference_indices.length() { + let reference_coordinate = reference[path.reference_indices[index]] + let mobile_coordinate = mobile[path.mobile_indices[index]] + fixed.push( + QCPAtomCoordinate::new( + reference_coordinate.x, + reference_coordinate.y, + reference_coordinate.z, + ), + ) + moving.push( + QCPAtomCoordinate::new( + mobile_coordinate.x, + mobile_coordinate.y, + mobile_coordinate.z, + ), + ) + index = index + 1 + } + QCPSuperimposer::new().set(fixed, moving) +} + +///| +fn cealign_path_with_indices( + path : CeAlignmentPath, + reference_indices : Array[Int], + mobile_indices : Array[Int], +) -> CeAlignmentPath { + CeAlignmentPath::{ + ..path, + reference_indices: reference_indices.copy(), + mobile_indices: mobile_indices.copy(), + } +} + +///| +fn cealign_optimize_path( + path : CeAlignmentPath, + reference : Array[Vector3], + mobile : Array[Vector3], + window_size : Int, + initial_fit : QCPSuperimposer, +) -> (CeAlignmentPath, QCPSuperimposer) { + let reference_indices = path.reference_indices.copy() + let mobile_indices = path.mobile_indices.copy() + let mut best_fit = initial_fit + let half_window = window_size / 2 + let mut side = 0 + while side < 2 { + let indices = if side == 0 { reference_indices } else { mobile_indices } + let coordinate_count = if side == 0 { + reference.length() + } else { + mobile.length() + } + let mut index = 1 + while index + 1 < indices.length() { + let center = indices[index] + let left = indices[index - 1] + let right = indices[index + 1] + let mut minimum_shift = -half_window + if left - center + 1 > minimum_shift { + minimum_shift = left - center + 1 + } + if -center > minimum_shift { + minimum_shift = -center + } + let mut maximum_shift = half_window + if right - center - 1 < maximum_shift { + maximum_shift = right - center - 1 + } + if coordinate_count - 1 - center < maximum_shift { + maximum_shift = coordinate_count - 1 - center + } + let mut best_shift = 0 + let mut shift = minimum_shift + while shift <= maximum_shift { + if shift != 0 { + indices[index] = center + shift + let candidate_path = cealign_path_with_indices( + path, reference_indices, mobile_indices, + ) + let candidate_fit = cealign_fit_path( + candidate_path, reference, mobile, + ) + if candidate_fit.rmsd + 1.0e-12 < best_fit.rmsd { + best_shift = shift + best_fit = candidate_fit + } + } + indices[index] = center + shift = shift + 1 + } + indices[index] = center + best_shift + index = index + 1 + } + side = side + 1 + } + (cealign_path_with_indices(path, reference_indices, mobile_indices), best_fit) +} + +///| +fn cealign_validate_transform( + rotation : Array[Array[Double]], + translation : Array[Double], +) -> Unit raise CeAlignError { + if rotation.length() != 3 || + rotation[0].length() != 3 || + rotation[1].length() != 3 || + rotation[2].length() != 3 { + raise CeAlignError("rotation must be a 3 x 3 matrix") + } + if translation.length() != 3 { + raise CeAlignError("translation must contain three values") + } +} + +///| +fn cealign_transform_vector( + coordinate : Vector3, + rotation : Array[Array[Double]], + translation : Array[Double], +) -> Vector3 { + Vector3::new( + rotation[0][0] * coordinate.x + + rotation[0][1] * coordinate.y + + rotation[0][2] * coordinate.z + + translation[0], + rotation[1][0] * coordinate.x + + rotation[1][1] * coordinate.y + + rotation[1][2] * coordinate.z + + translation[1], + rotation[2][0] * coordinate.x + + rotation[2][1] * coordinate.y + + rotation[2][2] * coordinate.z + + translation[2], + ) +} + +///| +/// Apply a rigid transform to every atom and return a new structure. +pub fn cealign_transform_structure( + structure : Structure, + rotation : Array[Array[Double]], + translation : Array[Double], +) -> Structure raise CeAlignError { + cealign_validate_transform(rotation, translation) + let models : Array[Model] = [] + for model in structure.models { + let chains : Array[Chain] = [] + for chain in model.chains { + let residues : Array[Residue] = [] + for residue in chain.residues { + let atoms : Array[Atom] = [] + for atom in residue.atoms { + atoms.push(Atom::{ + ..atom, + coord: cealign_transform_vector(atom.coord, rotation, translation), + }) + } + residues.push(Residue::{ ..residue, atoms, }) + } + chains.push(Chain::{ ..chain, residues, }) + } + models.push(Model::{ ..model, chains, }) + } + Structure::{ ..structure, models, } +} + +///| +/// Align a mobile structure onto the configured reference. +/// +/// When `transform` is true, `result.structure` contains a transformed copy. +/// The input structure is never modified. +pub fn CEAligner::align( + self : CEAligner, + mobile_structure : Structure, + transform? : Bool = true, + final_optimization? : Bool = true, +) -> CeAlignmentResult raise CeAlignError { + if self.reference_atoms.length() == 0 { + raise CeAlignError("reference structure has not been set") + } + let mobile_atoms = cealign_get_guide_atoms(mobile_structure) + if mobile_atoms.length() < self.window_size * 2 { + raise CeAlignError( + "Too few guide atoms in mobile structure: " + + mobile_atoms.length().to_string() + + "; need at least " + + (self.window_size * 2).to_string(), + ) + } + let reference_coordinates : Array[Vector3] = [] + for atom in self.reference_atoms { + reference_coordinates.push(atom.coordinate) + } + let mobile_coordinates : Array[Vector3] = [] + for atom in mobile_atoms { + mobile_coordinates.push(atom.coordinate) + } + let paths = cealign_find_paths( + reference_coordinates, + mobile_coordinates, + self.window_size, + self.max_gap, + ) + if paths.length() == 0 { + raise CeAlignError("failed to find a suitable CE alignment path") + } + let longest_fragment_count = paths[0].fragment_count + let mut best_path = paths[0] + let mut best_fit = cealign_fit_path( + best_path, reference_coordinates, mobile_coordinates, + ) + let mut candidate_index = 1 + while candidate_index < paths.length() && + paths[candidate_index].fragment_count == longest_fragment_count { + let candidate_fit = cealign_fit_path( + paths[candidate_index], + reference_coordinates, + mobile_coordinates, + ) + if candidate_fit.rmsd < best_fit.rmsd { + best_path = paths[candidate_index] + best_fit = candidate_fit + } + candidate_index = candidate_index + 1 + } + let optimization_applied = final_optimization && best_path.z_score >= 3.5 + if optimization_applied { + let optimized = cealign_optimize_path( + best_path, + reference_coordinates, + mobile_coordinates, + self.window_size, + best_fit, + ) + best_path = optimized.0 + best_fit = optimized.1 + } + let rotation = best_fit.get_rot() + let translation = best_fit.get_tran() + let result_structure = if transform { + cealign_transform_structure(mobile_structure, rotation, translation) + } else { + mobile_structure + } + CeAlignmentResult::{ + path: best_path, + rmsd: best_fit.rmsd, + rotation, + translation, + reference_guide_count: self.reference_atoms.length(), + mobile_guide_count: mobile_atoms.length(), + transformed: transform, + optimization_applied, + structure: result_structure, + } +} + +///| +fn cealign_sample_structure( + id : String, + angle : Double, + translation : Vector3, +) -> Structure { + let residues : Array[Residue] = [] + let cosine = @math.cos(angle) + let sine = @math.sin(angle) + let mut index = 0 + while index < 32 { + let parameter = index.to_double() * 0.72 + let reference = Vector3::new( + @math.cos(parameter) * 4.0, + @math.sin(parameter) * 4.0, + index.to_double() * 1.35, + ) + let coordinate = Vector3::new( + cosine * reference.x - sine * reference.y + translation.x, + sine * reference.x + cosine * reference.y + translation.y, + reference.z + translation.z, + ) + let ca = Atom::new( + name="CA", + coord=coordinate, + resname="ALA", + chainid='A', + resseq=index + 1, + element="C", + ) + let side = Atom::new( + name="CB", + coord=Vector3::new( + coordinate.x + cosine, + coordinate.y + sine, + coordinate.z + 0.3, + ), + resname="ALA", + chainid='A', + resseq=index + 1, + element="C", + ) + residues.push( + Residue::new(resname="ALA", chainid='A', resseq=index + 1, atoms=[ + ca, side, + ]), + ) + index = index + 1 + } + Structure::new(id~, models=[ + Model::new(id=0, chains=[Chain::new(id='A', residues~)]), + ]) +} + +///| +/// Deterministic sample structures for tests and examples. +pub fn cealign_sample_structures() -> (Structure, Structure) { + ( + cealign_sample_structure("reference", 0.0, Vector3::new(0.0, 0.0, 0.0)), + cealign_sample_structure("mobile", 0.65, Vector3::new(8.0, -3.0, 4.0)), + ) +} diff --git a/src/qcp_superimposer.mbt b/src/qcp_superimposer.mbt index 87fe84bf..84209e05 100644 --- a/src/qcp_superimposer.mbt +++ b/src/qcp_superimposer.mbt @@ -292,6 +292,98 @@ pub fn compute_eigenvector(q : Array[Array[Double]], lambda : Double) -> Array[D [v0, v1, v2, v3] } +///| +/// Compute the eigenvector for the largest eigenvalue of a symmetric 4x4 +/// matrix using Jacobi rotations. +fn qcp_largest_eigenvector(q : Array[Array[Double]]) -> Array[Double] { + let matrix : Array[Array[Double]] = [] + let vectors : Array[Array[Double]] = [] + let mut row = 0 + while row < 4 { + matrix.push(q[row].copy()) + let vector_row = Array::make(4, 0.0) + vector_row[row] = 1.0 + vectors.push(vector_row) + row = row + 1 + } + let mut sweep = 0 + while sweep < 64 { + let mut pivot_row = 0 + let mut pivot_column = 1 + let mut largest = matrix[0][1].abs() + let mut current_row = 0 + while current_row < 3 { + let mut current_column = current_row + 1 + while current_column < 4 { + let magnitude = matrix[current_row][current_column].abs() + if magnitude > largest { + largest = magnitude + pivot_row = current_row + pivot_column = current_column + } + current_column = current_column + 1 + } + current_row = current_row + 1 + } + if largest < 1.0e-12 { + break + } + let diagonal_difference = matrix[pivot_column][pivot_column] - + matrix[pivot_row][pivot_row] + let ratio = diagonal_difference / + (2.0 * matrix[pivot_row][pivot_column]) + let tangent = if ratio >= 0.0 { + 1.0 / (ratio + (1.0 + ratio * ratio).sqrt()) + } else { + -1.0 / (-ratio + (1.0 + ratio * ratio).sqrt()) + } + let cosine = 1.0 / (1.0 + tangent * tangent).sqrt() + let sine = tangent * cosine + let pivot_value = matrix[pivot_row][pivot_column] + let row_diagonal = matrix[pivot_row][pivot_row] + let column_diagonal = matrix[pivot_column][pivot_column] + matrix[pivot_row][pivot_row] = row_diagonal - tangent * pivot_value + matrix[pivot_column][pivot_column] = column_diagonal + + tangent * pivot_value + matrix[pivot_row][pivot_column] = 0.0 + matrix[pivot_column][pivot_row] = 0.0 + let mut index = 0 + while index < 4 { + if index != pivot_row && index != pivot_column { + let row_value = matrix[index][pivot_row] + let column_value = matrix[index][pivot_column] + let rotated_row = cosine * row_value - sine * column_value + let rotated_column = sine * row_value + cosine * column_value + matrix[index][pivot_row] = rotated_row + matrix[pivot_row][index] = rotated_row + matrix[index][pivot_column] = rotated_column + matrix[pivot_column][index] = rotated_column + } + let vector_row = vectors[index][pivot_row] + let vector_column = vectors[index][pivot_column] + vectors[index][pivot_row] = cosine * vector_row - sine * vector_column + vectors[index][pivot_column] = sine * vector_row + + cosine * vector_column + index = index + 1 + } + sweep = sweep + 1 + } + let mut largest_index = 0 + let mut index = 1 + while index < 4 { + if matrix[index][index] > matrix[largest_index][largest_index] { + largest_index = index + } + index = index + 1 + } + [ + vectors[0][largest_index], + vectors[1][largest_index], + vectors[2][largest_index], + vectors[3][largest_index], + ] +} + ///| /// Convert quaternion to rotation matrix. pub fn quaternion_to_rotation(q : Array[Double]) -> Array[Array[Double]] { @@ -379,11 +471,9 @@ pub fn QCPSuperimposer::set(self : QCPSuperimposer, fixed : Array[QCPAtomCoordin let centroid_fixed = calculate_centroid(fixed) let centroid_moving = calculate_centroid(moving) - let c = build_correlation_matrix(fixed_centered, moving_centered) + let c = build_correlation_matrix(moving_centered, fixed_centered) let q = build_qcp_matrix(c) - - let lambda_max = solve_quartic(q) - let eigenvec = compute_eigenvector(q, lambda_max) + let eigenvec = qcp_largest_eigenvector(q) let rot = quaternion_to_rotation(eigenvec) @@ -431,4 +521,4 @@ pub fn bio_qcp_calculate_rmsd(fixed : Array[QCPAtomCoordinate], moving : Array[Q pub fn bio_qcp_apply_transform(coords : Array[QCPAtomCoordinate], rot : Array[Array[Double]], tran : Array[Double]) -> Array[QCPAtomCoordinate] { let superimposer = QCPSuperimposer::new().set_rot(rot).set_tran(tran) superimposer.apply(coords) -} \ No newline at end of file +} diff --git a/test/moonbit/cealign_test.mbt b/test/moonbit/cealign_test.mbt new file mode 100644 index 00000000..ba066304 --- /dev/null +++ b/test/moonbit/cealign_test.mbt @@ -0,0 +1,725 @@ +///| +/// Tests for Biopython Bio.PDB.cealign-compatible structure alignment. + +///| +fn ce_test_aligner(window_size : Int, max_gap : Int) -> @src.CEAligner { + @src.CEAligner::new(window_size~, max_gap~) catch { + _ => abort("valid CEAligner parameters should be accepted") + } +} + +///| +fn ce_test_curve(count : Int) -> Array[@src.Vector3] { + let coordinates : Array[@src.Vector3] = [] + let mut index = 0 + while index < count { + let value = index.to_double() + coordinates.push( + @src.Vector3::new( + value * 1.3, + value * value * 0.17 + (index % 3).to_double() * 0.4, + value * 0.9 + (index % 4).to_double() * 0.6, + ), + ) + index = index + 1 + } + coordinates +} + +///| +fn ce_test_transform_coordinates( + coordinates : Array[@src.Vector3], + cosine : Double, + sine : Double, + translation : @src.Vector3, +) -> Array[@src.Vector3] { + let result : Array[@src.Vector3] = [] + for coordinate in coordinates { + result.push( + @src.Vector3::new( + cosine * coordinate.x - sine * coordinate.y + translation.x, + sine * coordinate.x + cosine * coordinate.y + translation.y, + coordinate.z + translation.z, + ), + ) + } + result +} + +///| +fn ce_test_structure( + id : String, + coordinates : Array[@src.Vector3], + guide_name : String, +) -> @src.Structure { + let residues : Array[@src.Residue] = [] + let mut index = 0 + while index < coordinates.length() { + let guide = @src.Atom::new( + name=guide_name, + coord=coordinates[index], + resname="GLY", + chainid='A', + resseq=index + 1, + element=if guide_name == "CA" { "C" } else { "C" }, + ) + let companion = @src.Atom::new( + name="N", + coord=@src.Vector3::new( + coordinates[index].x + 0.3, + coordinates[index].y - 0.2, + coordinates[index].z + 0.1, + ), + resname="GLY", + chainid='A', + resseq=index + 1, + element="N", + ) + residues.push( + @src.Residue::new(resname="GLY", chainid='A', resseq=index + 1, atoms=[ + guide, companion, + ]), + ) + index = index + 1 + } + @src.Structure::new(id~, models=[ + @src.Model::new(id=0, chains=[@src.Chain::new(id='A', residues~)]), + ]) +} + +///| +fn ce_test_assert_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort("values differ beyond tolerance") + } +} + +///| +test "cealign: creates default and custom aligners" { + let default_aligner = @src.CEAligner::new() catch { + _ => abort("default CEAligner should be valid") + } + let custom = ce_test_aligner(4, 7) + assert_eq(default_aligner.window_size, 8) + assert_eq(default_aligner.max_gap, 30) + assert_eq(default_aligner.reference_length(), 0) + assert_eq(custom.window_size, 4) + assert_eq(custom.max_gap, 7) +} + +///| +test "cealign: rejects invalid parameters" { + let invalid_window = try { + ignore(@src.CEAligner::new(window_size=0)) + false + } catch { + CeAlignError(_) => true + } + let invalid_gap = try { + ignore(@src.CEAligner::new(max_gap=-1)) + false + } catch { + CeAlignError(_) => true + } + assert_true(invalid_window) + assert_true(invalid_gap) +} + +///| +test "cealign: extracts protein CA guide atoms" { + let structure = ce_test_structure("protein", ce_test_curve(4), "CA") + let atoms = @src.cealign_get_guide_atoms(structure) catch { + _ => abort("protein structure should provide guide atoms") + } + assert_eq(atoms.length(), 4) + assert_eq(atoms[0].atom_name, "CA") + assert_eq(atoms[0].residue_number, 1) +} + +///| +test "cealign: extracts nucleic acid C4 prime guide atoms" { + let structure = ce_test_structure("rna", ce_test_curve(4), "C4'") + let atoms = @src.cealign_get_guide_atoms(structure) catch { + _ => abort("nucleic acid structure should provide guide atoms") + } + assert_eq(atoms.length(), 4) + assert_eq(atoms[0].atom_name, "C4'") +} + +///| +test "cealign: prefers CA when a residue contains both guide atom types" { + let ca = @src.Atom::new(name="CA", coord=@src.Vector3::new(1.0, 2.0, 3.0)) + let c4 = @src.Atom::new(name="C4'", coord=@src.Vector3::new(9.0, 9.0, 9.0)) + let residue = @src.Residue::new(resname="MIX", chainid='A', resseq=1, atoms=[ + c4, ca, + ]) + let structure = @src.Structure::new(id="mixed", models=[ + @src.Model::new(id=0, chains=[@src.Chain::new(id='A', residues=[residue])]), + ]) + let atoms = @src.cealign_get_guide_atoms(structure) catch { + _ => abort("mixed residue should provide one guide atom") + } + assert_eq(atoms.length(), 1) + assert_eq(atoms[0].atom_name, "CA") + assert_eq(atoms[0].coordinate.x, 1.0) +} + +///| +test "cealign: sorts guide atoms by model chain and residue" { + let atom_a2 = @src.Atom::new( + name="CA", + coord=@src.Vector3::new(2.0, 0.0, 0.0), + ) + let atom_a1 = @src.Atom::new( + name="CA", + coord=@src.Vector3::new(1.0, 0.0, 0.0), + ) + let atom_b1 = @src.Atom::new( + name="CA", + coord=@src.Vector3::new(3.0, 0.0, 0.0), + ) + let chain_b = @src.Chain::new(id='B', residues=[ + @src.Residue::new(resname="GLY", chainid='B', resseq=1, atoms=[atom_b1]), + ]) + let chain_a = @src.Chain::new(id='A', residues=[ + @src.Residue::new(resname="GLY", chainid='A', resseq=2, atoms=[atom_a2]), + @src.Residue::new(resname="GLY", chainid='A', resseq=1, atoms=[atom_a1]), + ]) + let structure = @src.Structure::new(id="unordered", models=[ + @src.Model::new(id=0, chains=[chain_b, chain_a]), + ]) + let atoms = @src.cealign_get_guide_atoms(structure) catch { + _ => abort("guide atoms should be sortable") + } + assert_eq(atoms[0].chain_id, 'A') + assert_eq(atoms[0].residue_number, 1) + assert_eq(atoms[1].chain_id, 'A') + assert_eq(atoms[1].residue_number, 2) + assert_eq(atoms[2].chain_id, 'B') +} + +///| +test "cealign: rejects structures without guide atoms" { + let atom = @src.Atom::new(name="N", coord=@src.Vector3::new(0.0, 0.0, 0.0)) + let residue = @src.Residue::new(resname="GLY", chainid='A', resseq=1, atoms=[ + atom, + ]) + let structure = @src.Structure::new(id="no-guide", models=[ + @src.Model::new(id=0, chains=[@src.Chain::new(id='A', residues=[residue])]), + ]) + let raised = try { + ignore(@src.cealign_get_guide_atoms(structure)) + false + } catch { + CeAlignError(_) => true + } + assert_true(raised) +} + +///| +test "cealign: builds symmetric distance matrices" { + let matrix = @src.cealign_distance_matrix([ + @src.Vector3::new(0.0, 0.0, 0.0), + @src.Vector3::new(3.0, 4.0, 0.0), + @src.Vector3::new(3.0, 4.0, 12.0), + ]) + assert_eq(matrix.length(), 3) + assert_eq(matrix[0][0], 0.0) + assert_eq(matrix[0][1], 5.0) + assert_eq(matrix[1][0], 5.0) + assert_eq(matrix[1][2], 12.0) +} + +///| +test "cealign: identical fragments have zero dissimilarity" { + let coordinates = ce_test_curve(5) + let distances = @src.cealign_distance_matrix(coordinates) + let similarity = @src.cealign_fragment_similarity( + distances, distances, 0, 0, 4, + ) + assert_eq(similarity, 0.0) +} + +///| +test "cealign: distorted fragments have negative similarity" { + let first = ce_test_curve(5) + let second = first.copy() + second[3] = @src.Vector3::new(20.0, -10.0, 5.0) + let similarity = @src.cealign_fragment_similarity( + @src.cealign_distance_matrix(first), + @src.cealign_distance_matrix(second), + 0, + 0, + 4, + ) + assert_true(similarity < 0.0) +} + +///| +test "cealign: similarity matrix has all fragment starts" { + let similarity = @src.cealign_similarity_matrix( + ce_test_curve(7), + ce_test_curve(6), + 3, + ) catch { + _ => abort("valid coordinate sets should produce a matrix") + } + assert_eq(similarity.length(), 5) + assert_eq(similarity[0].length(), 4) + assert_eq(similarity[0][0], 0.0) +} + +///| +test "cealign: similarity matrix validates full windows" { + let raised = try { + ignore( + @src.cealign_similarity_matrix(ce_test_curve(2), ce_test_curve(4), 3), + ) + false + } catch { + CeAlignError(_) => true + } + assert_true(raised) +} + +///| +test "cealign: identical coordinates produce a full CE path" { + let coordinates = ce_test_curve(8) + let paths = @src.cealign_find_paths(coordinates, coordinates, 2, 0) catch { + _ => abort("identical coordinates should align") + } + assert_true(paths.length() > 0) + assert_eq(paths[0].fragment_count, 4) + assert_eq(paths[0].aligned_length(), 8) + assert_eq(paths[0].reference_path(), [0, 1, 2, 3, 4, 5, 6, 7]) + assert_eq(paths[0].mobile_path(), [0, 1, 2, 3, 4, 5, 6, 7]) +} + +///| +test "cealign: path search returns at most twenty ranked candidates" { + let coordinates = ce_test_curve(12) + let paths = @src.cealign_find_paths(coordinates, coordinates, 2, 2) catch { + _ => abort("valid coordinates should produce CE paths") + } + assert_true(paths.length() <= 20) + let mut index = 1 + while index < paths.length() { + assert_true(paths[index - 1].fragment_count >= paths[index].fragment_count) + index = index + 1 + } +} + +///| +test "cealign: CE paths are strictly monotonic" { + let coordinates = ce_test_curve(10) + let path = (@src.cealign_find_paths(coordinates, coordinates, 2, 1) catch { + _ => abort("valid coordinates should produce CE paths") + })[0] + let mut index = 1 + while index < path.aligned_length() { + assert_true( + path.reference_indices[index] > path.reference_indices[index - 1], + ) + assert_true(path.mobile_indices[index] > path.mobile_indices[index - 1]) + index = index + 1 + } +} + +///| +test "cealign: path accessors return defensive copies" { + let coordinates = ce_test_curve(8) + let path = (@src.cealign_find_paths(coordinates, coordinates, 2, 0) catch { + _ => abort("valid coordinates should produce CE paths") + })[0] + let reference_copy = path.reference_path() + reference_copy[0] = 99 + let mobile_copy = path.mobile_path() + mobile_copy[0] = 99 + assert_eq(path.reference_path()[0], 0) + assert_eq(path.mobile_path()[0], 0) +} + +///| +test "cealign: paths expose aligned index pairs" { + let coordinates = ce_test_curve(6) + let path = (@src.cealign_find_paths(coordinates, coordinates, 2, 0) catch { + _ => abort("valid coordinates should produce CE paths") + })[0] + let pairs = path.aligned_pairs() + assert_eq(pairs.length(), 6) + assert_eq(pairs[0], (0, 0)) + assert_eq(pairs[5], (5, 5)) +} + +///| +test "cealign: path search validates parameters" { + let invalid_gap = try { + ignore(@src.cealign_find_paths(ce_test_curve(4), ce_test_curve(4), 2, -1)) + false + } catch { + CeAlignError(_) => true + } + let invalid_window = try { + ignore(@src.cealign_find_paths(ce_test_curve(4), ce_test_curve(4), 0, 0)) + false + } catch { + CeAlignError(_) => true + } + assert_true(invalid_gap) + assert_true(invalid_window) +} + +///| +test "cealign: align requires a reference structure" { + let aligner = ce_test_aligner(2, 2) + let mobile = ce_test_structure("mobile", ce_test_curve(8), "CA") + let raised = try { + ignore(aligner.align(mobile, transform=false, final_optimization=false)) + false + } catch { + CeAlignError(_) => true + } + assert_true(raised) +} + +///| +test "cealign: reference must contain two complete windows" { + let aligner = ce_test_aligner(3, 2) + let reference = ce_test_structure("short", ce_test_curve(5), "CA") + let raised = try { + ignore(aligner.set_reference(reference)) + false + } catch { + CeAlignError(_) => true + } + assert_true(raised) +} + +///| +test "cealign: mobile structure must contain two complete windows" { + let reference = ce_test_structure("reference", ce_test_curve(8), "CA") + let mobile = ce_test_structure("short-mobile", ce_test_curve(3), "CA") + let aligner = ce_test_aligner(2, 2).set_reference(reference) catch { + _ => abort("reference should contain enough guide atoms") + } + let raised = try { + ignore(aligner.align(mobile, transform=false, final_optimization=false)) + false + } catch { + CeAlignError(_) => true + } + assert_true(raised) +} + +///| +test "cealign: set_reference retains ordered coordinates" { + let coordinates = ce_test_curve(8) + let reference = ce_test_structure("reference", coordinates, "CA") + let aligner = ce_test_aligner(2, 2).set_reference(reference) catch { + _ => abort("reference should be accepted") + } + let stored = aligner.reference_coordinates() + assert_eq(aligner.reference_length(), 8) + ce_test_assert_close(stored[0].x, coordinates[0].x, 1.0e-12) + ce_test_assert_close(stored[7].z, coordinates[7].z, 1.0e-12) +} + +///| +test "cealign: translated structures superimpose with low RMSD" { + let reference_coordinates = ce_test_curve(12) + let mobile_coordinates = ce_test_transform_coordinates( + reference_coordinates, + 1.0, + 0.0, + @src.Vector3::new(7.0, -4.0, 2.0), + ) + let reference = ce_test_structure("reference", reference_coordinates, "CA") + let mobile = ce_test_structure("mobile", mobile_coordinates, "CA") + let aligner = ce_test_aligner(3, 2).set_reference(reference) catch { + _ => abort("reference should be accepted") + } + let result = aligner.align(mobile, transform=false, final_optimization=false) catch { + _ => abort("translated structure should align") + } + assert_true(result.rmsd < 1.0e-5) + assert_eq(result.path.aligned_length(), 12) +} + +///| +test "cealign: rotated and translated sample structures align" { + let (reference, mobile) = @src.cealign_sample_structures() + let aligner = @src.CEAligner::new() catch { + _ => abort("default aligner should be valid") + } + let configured = aligner.set_reference(reference) catch { + _ => abort("sample reference should be accepted") + } + let result = configured.align( + mobile, + transform=true, + final_optimization=false, + ) catch { + _ => abort("sample structures should align") + } + assert_true(result.rmsd < 1.0e-4) + assert_eq(result.path.aligned_length(), 32) + assert_true(result.transformed) +} + +///| +test "cealign: transform false preserves returned coordinates" { + let coordinates = ce_test_curve(8) + let mobile_coordinates = ce_test_transform_coordinates( + coordinates, + 0.8, + 0.6, + @src.Vector3::new(2.0, 3.0, -1.0), + ) + let reference = ce_test_structure("reference", coordinates, "CA") + let mobile = ce_test_structure("mobile", mobile_coordinates, "CA") + let original = mobile.get_atoms()[0].coord + let aligner = ce_test_aligner(2, 2).set_reference(reference) catch { + _ => abort("reference should be accepted") + } + let result = aligner.align(mobile, transform=false, final_optimization=false) catch { + _ => abort("mobile structure should align") + } + let returned = result.structure.get_atoms()[0].coord + assert_false(result.transformed) + ce_test_assert_close(returned.x, original.x, 1.0e-12) + ce_test_assert_close(returned.y, original.y, 1.0e-12) + ce_test_assert_close(returned.z, original.z, 1.0e-12) +} + +///| +test "cealign: transform true moves guide and companion atoms" { + let coordinates = ce_test_curve(10) + let mobile_coordinates = ce_test_transform_coordinates( + coordinates, + 0.8, + 0.6, + @src.Vector3::new(4.0, -2.0, 3.0), + ) + let reference = ce_test_structure("reference", coordinates, "CA") + let mobile = ce_test_structure("mobile", mobile_coordinates, "CA") + let aligner = ce_test_aligner(2, 2).set_reference(reference) catch { + _ => abort("reference should be accepted") + } + let result = aligner.align(mobile, transform=true, final_optimization=false) catch { + _ => abort("mobile structure should align") + } + let transformed_atoms = result.structure.get_atoms() + assert_eq(transformed_atoms.length(), 20) + assert_true(transformed_atoms[0].coord.distance(coordinates[0]) < 1.0e-4) + assert_true( + transformed_atoms[1].coord.distance(mobile.get_atoms()[1].coord) > 0.1, + ) +} + +///| +test "cealign: alignment never mutates the input structure" { + let (reference, mobile) = @src.cealign_sample_structures() + let original = mobile.get_atoms()[0].coord + let aligner = @src.CEAligner::new() catch { + _ => abort("default aligner should be valid") + } + let configured = aligner.set_reference(reference) catch { + _ => abort("sample reference should be accepted") + } + ignore( + configured.align(mobile, transform=true, final_optimization=false) catch { + _ => abort("sample structures should align") + }, + ) + let after = mobile.get_atoms()[0].coord + assert_eq(after.x, original.x) + assert_eq(after.y, original.y) + assert_eq(after.z, original.z) +} + +///| +test "cealign: aligns nucleic acid structures through C4 prime atoms" { + let coordinates = ce_test_curve(8) + let mobile_coordinates = ce_test_transform_coordinates( + coordinates, + 0.8, + 0.6, + @src.Vector3::new(-2.0, 5.0, 1.0), + ) + let reference = ce_test_structure("rna-ref", coordinates, "C4'") + let mobile = ce_test_structure("rna-mobile", mobile_coordinates, "C4'") + let aligner = ce_test_aligner(2, 2).set_reference(reference) catch { + _ => abort("nucleic reference should be accepted") + } + let result = aligner.align(mobile, transform=false, final_optimization=false) catch { + _ => abort("nucleic structures should align") + } + assert_true(result.rmsd < 1.0e-4) + assert_eq(result.path.aligned_length(), 8) +} + +///| +test "cealign: reports reference and mobile coverage" { + let coordinates = ce_test_curve(10) + let reference = ce_test_structure("reference", coordinates, "CA") + let mobile = ce_test_structure("mobile", coordinates, "CA") + let aligner = ce_test_aligner(2, 2).set_reference(reference) catch { + _ => abort("reference should be accepted") + } + let result = aligner.align(mobile, transform=false, final_optimization=false) catch { + _ => abort("identical structures should align") + } + assert_eq(result.reference_coverage(), 1.0) + assert_eq(result.mobile_coverage(), 1.0) +} + +///| +test "cealign: local path can bridge an insertion within max_gap" { + let reference_coordinates = ce_test_curve(10) + let mobile_coordinates : Array[@src.Vector3] = [] + let mut index = 0 + while index < reference_coordinates.length() { + if index == 4 { + mobile_coordinates.push(@src.Vector3::new(30.0, -20.0, 15.0)) + } + mobile_coordinates.push(reference_coordinates[index]) + index = index + 1 + } + let paths = @src.cealign_find_paths( + reference_coordinates, mobile_coordinates, 2, 2, + ) catch { + _ => abort("CE should search paths across a short insertion") + } + assert_true(paths.length() > 0) + assert_true(paths[0].aligned_length() >= 8) + let pairs = paths[0].aligned_pairs() + let mut bridges_insertion = false + for pair in pairs { + if pair.0 >= 4 && pair.1 == pair.0 + 1 { + bridges_insertion = true + } + } + assert_true(bridges_insertion) +} + +///| +test "cealign: final optimization never increases RMSD" { + let (reference, mobile) = @src.cealign_sample_structures() + let configured = (@src.CEAligner::new() catch { + _ => abort("default aligner should be valid") + }).set_reference(reference) catch { + _ => abort("sample reference should be accepted") + } + let baseline = configured.align( + mobile, + transform=false, + final_optimization=false, + ) catch { + _ => abort("baseline alignment should succeed") + } + let optimized = configured.align( + mobile, + transform=false, + final_optimization=true, + ) catch { + _ => abort("optimized alignment should succeed") + } + assert_true(optimized.rmsd <= baseline.rmsd + 1.0e-12) + assert_true(optimized.path.z_score >= 3.5) + assert_true(optimized.optimization_applied) +} + +///| +test "cealign: result transform accessors are defensive" { + let coordinates = ce_test_curve(8) + let reference = ce_test_structure("reference", coordinates, "CA") + let mobile = ce_test_structure("mobile", coordinates, "CA") + let configured = ce_test_aligner(2, 2).set_reference(reference) catch { + _ => abort("reference should be accepted") + } + let result = configured.align( + mobile, + transform=false, + final_optimization=false, + ) catch { + _ => abort("identical structures should align") + } + let rotation = result.rotation_matrix() + let translation = result.translation_vector() + rotation[0][0] = 99.0 + translation[0] = 99.0 + assert_true(result.rotation_matrix()[0][0] < 2.0) + assert_true(result.translation_vector()[0].abs() < 1.0e-6) +} + +///| +test "cealign: validates explicit rigid transforms" { + let structure = ce_test_structure("protein", ce_test_curve(4), "CA") + let bad_rotation = try { + ignore( + @src.cealign_transform_structure(structure, [[1.0, 0.0], [0.0, 1.0]], [ + 0.0, 0.0, 0.0, + ]), + ) + false + } catch { + CeAlignError(_) => true + } + let bad_translation = try { + ignore( + @src.cealign_transform_structure( + structure, + [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], + [0.0, 0.0], + ), + ) + false + } catch { + CeAlignError(_) => true + } + assert_true(bad_rotation) + assert_true(bad_translation) +} + +///| +test "cealign: identity transform preserves atom coordinates" { + let structure = ce_test_structure("protein", ce_test_curve(4), "CA") + let transformed = @src.cealign_transform_structure( + structure, + [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]], + [0.0, 0.0, 0.0], + ) catch { + _ => abort("identity transform should be valid") + } + let original_coordinate = structure.get_atoms()[3].coord + let transformed_coordinate = transformed.get_atoms()[3].coord + assert_eq(transformed_coordinate.x, original_coordinate.x) + assert_eq(transformed_coordinate.y, original_coordinate.y) + assert_eq(transformed_coordinate.z, original_coordinate.z) +} + +///| +test "cealign: summary includes core alignment metrics" { + let coordinates = ce_test_curve(8) + let reference = ce_test_structure("reference", coordinates, "CA") + let mobile = ce_test_structure("mobile", coordinates, "CA") + let configured = ce_test_aligner(2, 2).set_reference(reference) catch { + _ => abort("reference should be accepted") + } + let result = configured.align( + mobile, + transform=false, + final_optimization=false, + ) catch { + _ => abort("identical structures should align") + } + let summary = result.summary() + assert_true(summary.has_prefix("CEAlignment(")) + assert_true(summary.contains("aligned=8")) + assert_true(summary.contains("rmsd=")) + assert_true(summary.contains("reference_coverage=1")) +} diff --git a/test/moonbit/qcp_superimposer_test.mbt b/test/moonbit/qcp_superimposer_test.mbt index 1e47d135..dc7cab99 100644 --- a/test/moonbit/qcp_superimposer_test.mbt +++ b/test/moonbit/qcp_superimposer_test.mbt @@ -55,6 +55,30 @@ test "qcp_superimposer_translated_coords" { assert_true(superimposer.get_rmsd() < 0.01) } +///| +test "qcp_superimposer_rotated_and_translated_coords" { + let fixed = [ + @src.QCPAtomCoordinate::new(1.0, 0.0, 0.0), + @src.QCPAtomCoordinate::new(0.0, 2.0, 0.0), + @src.QCPAtomCoordinate::new(0.0, 0.0, 3.0), + @src.QCPAtomCoordinate::new(1.0, 1.0, 1.0), + ] + let moving = [ + @src.QCPAtomCoordinate::new(5.0, -1.0, 4.0), + @src.QCPAtomCoordinate::new(3.0, -2.0, 4.0), + @src.QCPAtomCoordinate::new(5.0, -2.0, 7.0), + @src.QCPAtomCoordinate::new(4.0, -1.0, 5.0), + ] + let superimposer = @src.bio_qcp_superimpose(fixed, moving) + let transformed = superimposer.apply(moving) + assert_true(superimposer.get_rmsd() < 1.0e-8) + let mut index = 0 + while index < fixed.length() { + assert_true(transformed[index].distance(fixed[index]) < 1.0e-8) + index = index + 1 + } +} + ///| test "qcp_superimposer_calculate_rmsd" { let atoms1 = [ @@ -86,4 +110,4 @@ test "qcp_superimposer_apply_transform" { assert_eq(transformed.length(), 2) assert_true(transformed[0].x > 1.9) -} \ No newline at end of file +} From c90305790ec4dd28a491f627399a768279c125b5 Mon Sep 17 00:00:00 2001 From: eda Date: Tue, 4 Aug 2026 18:57:57 +0800 Subject: [PATCH 09/41] #28 feat(scrapper): Bioconductor scrapper RNA-seq --- README.md | 22 +- examples/scrapper_demo/main.mbt | 145 ++++ examples/scrapper_demo/moon.pkg | 5 + src/scrapper.mbt | 1390 +++++++++++++++++++++++++++++++ test/moonbit/scrapper_test.mbt | 653 +++++++++++++++ 5 files changed, 2211 insertions(+), 4 deletions(-) create mode 100644 examples/scrapper_demo/main.mbt create mode 100644 examples/scrapper_demo/moon.pkg create mode 100644 src/scrapper.mbt create mode 100644 test/moonbit/scrapper_test.mbt diff --git a/README.md b/README.md index f5d20510..3a7abdb9 100644 --- a/README.md +++ b/README.md @@ -274,6 +274,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **Matrix** | Bioconductor Matrix | 稀疏矩阵操作、CSC/CSR格式、矩阵运算（加法、乘法、转置）、行列统计、范数计算 | ✅ | | **BiocGenerics** | Bioconductor BiocGenerics | Bioconductor通用函数、NA处理、排序、集合运算、匹配、表统计、序列生成 | ✅ | | **scran** | Bioconductor scran | 单细胞归一化(sum_factors)、SNN图构建、Leiden聚类、差异标志物分析 | ✅ | +| **scrapper** | Bioconductor scrapper | 批次感知RNA QC、大小因子清洗与居中、log-normalization、LOWESS方差趋势、HVG选择、多因子pseudo-bulk、不可变SCE集成 | ✅ | | **monocle3** | Bioconductor monocle3 | 单细胞轨迹分析、PCA/UMAP降维、主图学习、拟时间排序、差异表达分析、分支点检测、分支特异性差异表达 | ✅ | | **ShortRead** | Bioconductor ShortRead | 短读序列质量控制、QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告生成 | ✅ | | **scater** | Bioconductor scater | 单细胞质量控制、QC指标计算、细胞/基因过滤、CPM/log-CPM标准化、HVG检测、PCA降维 | ✅ | @@ -527,6 +528,7 @@ IvanAXu/BioSeqs/ │ ├── graph.mbt # graph 图数据结构 (有向/无向图、最短路径、连通分量、DOT输出) │ ├── droplet_utils.mbt # DropletUtils 空液滴检测 (emptyDrops算法、knee点检测、细胞过滤) │ ├── scran.mbt # scran 单细胞归一化与聚类 (sum_factors、SNN图、Leiden聚类、标志物分析) +│ ├── scrapper.mbt # scrapper 单细胞预处理 (批次感知RNA QC、大小因子、LOWESS/HVG、pseudo-bulk、SCE集成) │ ├── monocle3.mbt # monocle3 单细胞轨迹分析 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read.mbt # ShortRead 短读序列质量控制 (QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告) │ ├── seq_quality_trim.mbt # NGS质量修剪与接头去除 (质量修剪、接头去除、poly-A修剪、长度/GC过滤、批量修剪) @@ -868,6 +870,7 @@ IvanAXu/BioSeqs/ │ ├── graph_demo/ # graph 图数据结构示例 (有向/无向图构建、最短路径、连通分量、DOT输出) │ ├── droplet_utils_demo/ # DropletUtils 空液滴检测示例 (emptyDrops算法、knee点检测、细胞过滤) │ ├── scran_demo/ # scran 单细胞归一化与聚类示例 (sum_factors、SNN图、Leiden聚类、标志物分析) +│ ├── scrapper_demo/ # scrapper 批次感知RNA QC、归一化、LOWESS/HVG、pseudo-bulk与SCE集成示例 │ ├── monocle3_demo/ # monocle3 单细胞轨迹分析示例 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read_demo/ # ShortRead 短读序列质量控制示例 (QA统计、adapter修剪、质量修剪、FastQC报告) │ ├── scater_demo/ # scater 单细胞质量控制示例 (QC指标计算、细胞/基因过滤、标准化、HVG检测、PCA) @@ -1263,6 +1266,7 @@ IvanAXu/BioSeqs/ │ │ ├── scater_test.mbt │ │ ├── scnorm_test.mbt │ │ ├── scran_test.mbt +│ │ ├── scrapper_test.mbt │ │ ├── search_io_test.mbt │ │ ├── searchio_new_test.mbt │ │ ├── seq_complexity_test.mbt @@ -1437,7 +1441,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8409 个测试全部通过 +moon test # ✅ 8444 个测试全部通过 ``` ### 模块对照表 @@ -1737,6 +1741,7 @@ moon test # ✅ 8409 个测试全 | `karyoploter.mbt` | `karyoploteR` | 核型可视化（染色体轨道、数据点、ASCII 渲染） | | `system_piper.mbt` | `SystemPipeR` | 流水线编排（步骤管理、依赖关系、进度追踪） | | `muscat.mbt` | `muscat` | 单细胞差异状态分析（伪批量聚合、DS 检验、QC） | +| `scrapper.mbt` | `scrapper` | 批次感知RNA QC、大小因子清洗/居中、count与log归一化、LOWESS方差趋势、HVG选择、多因子pseudo-bulk、SingleCellExperiment不可变包装 | | `infercnv.mbt` | `infercnv` | 单细胞拷贝数变异推断（基因组位置排序、参考细胞有界 LFC 计算、金字塔权重平滑、CNV 分数与恶性细胞预测） | | `scenic.mbt` | `SCENIC` | 单细胞调控网络推断与聚类（TF-target 共表达模块、Regulon 构建、AUCell 活性评分、二值化阈值、细胞状态与主控调控因子） | | `cibersort.mbt` | `CIBERSORT` | 免疫细胞去卷积（NNLS 求解、LM22 风格特征矩阵、Pearson 拟合优度、分数归一化） | @@ -2782,6 +2787,12 @@ moon test # ✅ 8409 个测试全 `CeAlignmentResult` 返回对齐索引、片段数、RMSD、Z-score、覆盖率、旋转矩阵和平移向量。`transform=true` 会将刚体变换应用到移动结构的全部原子，同时重建 `Structure` 以保证输入对象不被原地修改；`transform=false` 仅计算比对。公开辅助 API 还包括距离矩阵、片段相似度、路径搜索和独立结构变换，非法参数、引导原子缺失或结构长度不足时抛出 `CeAlignError`。 +### 244. scrapper 单细胞预处理 (Bioconductor scrapper) + +实现 Bioconductor `scrapper` 核心单细胞 RNA-seq 预处理流程，矩阵统一采用 feature × cell 方向。RNA QC 计算每个细胞的文库总量、检测基因数和命名 feature subset 比例，并用 `log(value + 1)` 空间的 median/MAD 下限及 subset 比例上限执行批次感知过滤；block 顺序按首次出现保留。大小因子支持非法值清洗、文库大小估计、全局/逐批次居中，以及保留批次间尺度的最低批次居中。count scaling 和可配置底数、pseudo-count 的 log-normalization 均返回新矩阵，不修改输入。 + +基因建模提供均值、sample variance、quarter-root LOWESS 局部线性趋势、左侧向原点外推、残差方差和带 ties/bound 控制的 HVG 选择。`scrapper_aggregate_across_cells` 可按一个或多个分类因子的唯一组合生成 pseudo-bulk sums、detected counts、means 和 medians，并返回组组合及每个细胞的组索引。`scrapper_normalize_rna_counts_sce` 与 `scrapper_quick_rna_qc_sce` 深复制 assay 和主要注释后写入结果，避免修改原 `SingleCellExperiment`。当前实现是无需 libscran C++ 的可移植 MoonBit 版本，不保证 LOWESS 与上游后端位级一致，也不覆盖 `scrapper` 的全部导出接口。 + ## 性能优化 ### 优化策略 @@ -2883,8 +2894,8 @@ moon test # ✅ 8409 个测试全 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8409 | -| 通过数 | 8409 | +| 总测试数 | 8444 | +| 通过数 | 8444 | | 失败数 | 0 | | 通过率 | 100% | @@ -3004,6 +3015,7 @@ moon test --update | graph | `graph_test.mbt` | 8 | | DropletUtils | `droplet_utils_test.mbt` | 6 | | scran | `scran_test.mbt` | 8 | +| scrapper | `scrapper_test.mbt` | 35 | | monocle3 | `monocle3_test.mbt` | 10 | | ShortRead | `short_read_test.mbt` | 15 | | scater | `scater_test.mbt` | 17 | @@ -3276,7 +3288,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 351 个示例程序，展示各模块的典型用法： +项目提供 352 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3365,6 +3377,7 @@ moon run cmd/bench/main.mbt | bioconductor_demo | Bioconductor模块综合示例（ChIPseeker峰注释(外显子/内含子/UTR分类、peak2gene关联)、DOSE疾病富集、ReactomePA通路分析、AnnotationDbi注释数据库、clusterProfiler富集框架、WGCNA共表达网络、Batchelor单细胞批次校正、Seurat单细胞分析） | `moon run examples/bioconductor_demo/main.mbt` | | short_read_demo | ShortRead 短读序列质量控制（QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告生成） | `moon run examples/short_read_demo/main.mbt` | | scater_demo | scater 单细胞质量控制（QC指标计算、细胞/基因过滤、CPM/log-CPM标准化、HVG检测、PCA降维） | `moon run examples/scater_demo/main.mbt` | +| scrapper_demo | 批次感知RNA QC、大小因子归一化、LOWESS/HVG、多因子pseudo-bulk和不可变SCE集成 | `moon run examples/scrapper_demo` | | mast_demo | MAST 单细胞差异表达分析（Hurdle模型、离散/连续检验、BH-FDR校正、结果汇总） | `moon run examples/mast_demo/main.mbt` | | genomic_files_demo | GenomicFiles 分布式基因组文件处理（BAM/BED/VCF扫描、区间查询、归约、覆盖度计算） | `moon run examples/genomic_files_demo/main.mbt` | | diffbind_demo | DiffBind ChIP-seq差异结合分析（峰值重叠、共识峰识别、TMM归一化、负二项分布检验） | `moon run examples/diffbind_demo/main.mbt` | @@ -3556,6 +3569,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bio.Align.hhr HH-suite HHR解析（元数据、命中摘要、多块profile比对、注释保留、过滤、坐标映射与序列化） - ✅ 实现 Bioconductor SparseArray N维稀疏数组（规范化COO、R列主序、切片/置换/绑定、稀疏算术、统计与矩阵乘法） - ✅ 实现 Bio.PDB.cealign CE组合扩展结构比对（CA/C4'引导原子、AFP路径、CE Z-score、QCP叠合、局部优化与全原子变换） +- ✅ 实现 Bioconductor scrapper 单细胞预处理（批次感知RNA QC、大小因子与log-normalization、LOWESS/HVG、多因子pseudo-bulk、不可变SCE集成） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/scrapper_demo/main.mbt b/examples/scrapper_demo/main.mbt new file mode 100644 index 00000000..f3d8e329 --- /dev/null +++ b/examples/scrapper_demo/main.mbt @@ -0,0 +1,145 @@ +///| +fn format_doubles(values : Array[Double]) -> String { + let mut result = "[" + let mut index = 0 + while index < values.length() { + if index > 0 { + result = result + ", " + } + result = result + values[index].to_string() + index = index + 1 + } + result + "]" +} + +///| +fn format_ints(values : Array[Int]) -> String { + let mut result = "[" + let mut index = 0 + while index < values.length() { + if index > 0 { + result = result + ", " + } + result = result + values[index].to_string() + index = index + 1 + } + result + "]" +} + +///| +fn format_strings(values : Array[String]) -> String { + let mut result = "[" + let mut index = 0 + while index < values.length() { + if index > 0 { + result = result + ", " + } + result = result + values[index] + index = index + 1 + } + result + "]" +} + +///| +fn main { + println("=== Bioconductor scrapper Demo ===") + let counts = @src.scrapper_sample_counts() + let blocks = ["batch1", "batch1", "batch1", "batch2", "batch2", "batch2"] + let mitochondrial = @src.ScrapperNamedSubset::new("mito", [2, 4]) + + println("\n1. Batch-aware RNA quality control") + let qc = @src.scrapper_quick_rna_qc(counts, subsets=[mitochondrial], blocks~) catch { + _ => abort("failed to compute scrapper RNA QC") + } + println(" " + qc.summary()) + println(" library sums: " + format_doubles(qc.metrics.sums)) + println(" detected genes: " + format_ints(qc.metrics.detected)) + println( + " mitochondrial proportions: " + + format_doubles(qc.metrics.subset_proportions[0]), + ) + + println("\n2. Library-size factors and log-normalization") + let size_factors = @src.scrapper_library_size_factors( + counts, + blocks~, + mode=@src.scrapper_center_per_block(), + ) catch { + _ => abort("failed to compute library size factors") + } + let logcounts = @src.scrapper_normalize_counts(counts, size_factors) catch { + _ => abort("failed to normalize counts") + } + println(" size factors: " + format_doubles(size_factors)) + println(" first normalized feature: " + format_doubles(logcounts[0])) + + println("\n3. Mean-variance trend and highly variable genes") + let model = @src.scrapper_model_gene_variances( + logcounts, + mean_filter=false, + min_window_count=3, + ) catch { + _ => abort("failed to model gene variances") + } + let highly_variable = model.highly_variable_genes(top=3) catch { + _ => abort("failed to choose highly variable genes") + } + println(" means: " + format_doubles(model.means)) + println(" residual variances: " + format_doubles(model.residuals)) + println(" selected 0-based genes: " + format_ints(highly_variable)) + + println("\n4. Multi-factor pseudo-bulk aggregation") + let aggregate = @src.scrapper_aggregate_across_cells( + counts, + [ + @src.ScrapperFactor::new("cluster", ["T", "T", "B", "T", "B", "B"]), + @src.ScrapperFactor::new("batch", blocks), + ], + compute_median=true, + ) catch { + _ => abort("failed to aggregate cells") + } + let pseudo_bulk_means = aggregate.means() catch { + _ => abort("failed to compute pseudo-bulk means") + } + println(" " + aggregate.summary()) + println(" groups: " + format_strings(aggregate.group_names)) + println(" cells per group: " + format_ints(aggregate.counts)) + println(" first feature means: " + format_doubles(pseudo_bulk_means[0])) + + println("\n5. Immutable SingleCellExperiment integration") + let sce = @src.SingleCellExperiment::new( + counts, + ["Gene1", "Gene2", "Gene3", "Gene4", "Gene5", "Gene6"], + ["Cell1", "Cell2", "Cell3", "Cell4", "Cell5", "Cell6"], + ) + let normalized_sce = @src.scrapper_normalize_rna_counts_sce( + sce, + blocks~, + mode=@src.scrapper_center_per_block(), + ) catch { + _ => abort("failed to normalize SingleCellExperiment") + } + let (annotated_sce, sce_qc) = @src.scrapper_quick_rna_qc_sce( + normalized_sce, + subsets=[mitochondrial], + blocks~, + ) catch { + _ => abort("failed to annotate SingleCellExperiment QC") + } + println( + " original logcounts rows: " + + @src.sce_get_assay(sce, "logcounts").length().to_string(), + ) + println( + " copied logcounts rows: " + + @src.sce_get_assay(annotated_sce, "logcounts").length().to_string(), + ) + println( + " copied QC metadata columns populated: " + + @src.sce_get_col_data(annotated_sce, "scrapper_keep").length().to_string(), + ) + println(" SCE QC retained cells: " + sce_qc.retained_count().to_string()) + + println("\n=== Demo Complete ===") +} diff --git a/examples/scrapper_demo/moon.pkg b/examples/scrapper_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/scrapper_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/scrapper.mbt b/src/scrapper.mbt new file mode 100644 index 00000000..e2537bf8 --- /dev/null +++ b/src/scrapper.mbt @@ -0,0 +1,1390 @@ +///| +/// Core single-cell preprocessing utilities inspired by Bioconductor scrapper. +/// +/// Matrices use the Bioconductor convention: features in rows and cells in +/// columns. The implementation covers RNA quality control, size-factor +/// normalization, mean-variance modelling, HVG selection and pseudo-bulk +/// aggregation. + +///| +pub suberror ScrapperError { + ScrapperError(String) +} + +///| +pub struct ScrapperNamedSubset { + name : String + indices : Array[Int] +} + +///| +pub struct ScrapperRnaQcMetrics { + sums : Array[Double] + detected : Array[Int] + subset_names : Array[String] + subset_proportions : Array[Array[Double]] +} + +///| +pub struct ScrapperRnaQcThresholds { + block_names : Array[String] + sum_lower : Array[Double] + detected_lower : Array[Double] + subset_upper : Array[Array[Double]] +} + +///| +pub struct ScrapperRnaQcResult { + metrics : ScrapperRnaQcMetrics + thresholds : ScrapperRnaQcThresholds + keep : Array[Bool] +} + +///| +pub enum ScrapperCenterMode { + Lowest + PerBlock +} derive(Eq, Debug) + +///| +pub struct ScrapperVarianceTrend { + fitted : Array[Double] + residuals : Array[Double] +} + +///| +pub struct ScrapperVarianceModel { + means : Array[Double] + variances : Array[Double] + fitted : Array[Double] + residuals : Array[Double] +} + +///| +pub struct ScrapperFactor { + name : String + levels : Array[String] +} + +///| +pub struct ScrapperAggregateResult { + factor_names : Array[String] + combinations : Array[Array[String]] + group_names : Array[String] + counts : Array[Int] + index : Array[Int] + sums : Array[Array[Double]] + detected : Array[Array[Int]] + medians : Array[Array[Double]] +} + +///| +pub fn ScrapperNamedSubset::new( + name : String, + indices : Array[Int], +) -> ScrapperNamedSubset { + ScrapperNamedSubset::{ name, indices: indices.copy() } +} + +///| +pub fn ScrapperFactor::new( + name : String, + levels : Array[String], +) -> ScrapperFactor { + ScrapperFactor::{ name, levels: levels.copy() } +} + +///| +pub fn scrapper_center_lowest() -> ScrapperCenterMode { + Lowest +} + +///| +pub fn scrapper_center_per_block() -> ScrapperCenterMode { + PerBlock +} + +///| +fn scrapper_is_finite(value : Double) -> Bool { + value == value && value.abs() < 1.0e300 +} + +///| +fn scrapper_matrix_shape( + matrix : Array[Array[Double]], + require_counts : Bool, +) -> (Int, Int) raise ScrapperError { + let rows = matrix.length() + let columns = if rows > 0 { matrix[0].length() } else { 0 } + let mut row = 0 + while row < rows { + if matrix[row].length() != columns { + raise ScrapperError("scrapper matrices must be rectangular") + } + let mut column = 0 + while column < columns { + let value = matrix[row][column] + if !scrapper_is_finite(value) { + raise ScrapperError("scrapper matrices must contain finite values") + } + if require_counts && value < 0.0 { + raise ScrapperError("scrapper count matrices must be non-negative") + } + column = column + 1 + } + row = row + 1 + } + (rows, columns) +} + +///| +fn scrapper_copy_matrix(matrix : Array[Array[Double]]) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + let mut row = 0 + while row < matrix.length() { + output.push(matrix[row].copy()) + row = row + 1 + } + output +} + +///| +fn scrapper_median(values : Array[Double]) -> Double { + if values.length() == 0 { + return 0.0 + } + let sorted = values.copy() + sorted.sort_by(fn(left : Double, right : Double) -> Int { + if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + let middle = sorted.length() / 2 + if sorted.length() % 2 == 1 { + sorted[middle] + } else { + (sorted[middle - 1] + sorted[middle]) / 2.0 + } +} + +///| +fn scrapper_mad(values : Array[Double], center : Double) -> Double { + if values.length() == 0 { + return 0.0 + } + let deviations : Array[Double] = [] + let mut index = 0 + while index < values.length() { + deviations.push((values[index] - center).abs()) + index = index + 1 + } + scrapper_median(deviations) * 1.4826 +} + +///| +fn scrapper_mean(values : Array[Double]) -> Double { + if values.length() == 0 { + return 0.0 + } + let mut total = 0.0 + let mut index = 0 + while index < values.length() { + total = total + values[index] + index = index + 1 + } + total / values.length().to_double() +} + +///| +fn scrapper_subset_masks( + subsets : Array[ScrapperNamedSubset], + features : Int, +) -> Array[Array[Bool]] raise ScrapperError { + let masks : Array[Array[Bool]] = [] + let seen_names : Map[String, Bool] = Map([], capacity=subsets.length()) + let mut subset = 0 + while subset < subsets.length() { + let current = subsets[subset] + if current.name.length() == 0 { + raise ScrapperError("scrapper subset names must not be empty") + } + if seen_names.contains(current.name) { + raise ScrapperError("scrapper subset names must be unique") + } + seen_names[current.name] = true + let mask = Array::make(features, false) + let mut position = 0 + while position < current.indices.length() { + let index = current.indices[position] + if index < 0 || index >= features { + raise ScrapperError("scrapper subset index is out of bounds") + } + mask[index] = true + position = position + 1 + } + masks.push(mask) + subset = subset + 1 + } + masks +} + +///| +/// Compute per-cell RNA QC metrics. +/// +/// `subset_proportions[s][c]` is the proportion of cell `c`'s total count +/// assigned to subset `s`. +pub fn scrapper_compute_rna_qc_metrics( + counts : Array[Array[Double]], + subsets? : Array[ScrapperNamedSubset] = [], + detection_limit? : Double = 0.0, +) -> ScrapperRnaQcMetrics raise ScrapperError { + let (features, cells) = scrapper_matrix_shape(counts, true) + if !scrapper_is_finite(detection_limit) { + raise ScrapperError("scrapper detection limit must be finite") + } + let masks = scrapper_subset_masks(subsets, features) + let sums = Array::make(cells, 0.0) + let detected = Array::make(cells, 0) + let subset_sums : Array[Array[Double]] = [] + let mut subset = 0 + while subset < subsets.length() { + subset_sums.push(Array::make(cells, 0.0)) + subset = subset + 1 + } + let mut feature = 0 + while feature < features { + let mut cell = 0 + while cell < cells { + let value = counts[feature][cell] + sums[cell] = sums[cell] + value + if value > detection_limit { + detected[cell] = detected[cell] + 1 + } + subset = 0 + while subset < subsets.length() { + if masks[subset][feature] { + subset_sums[subset][cell] = subset_sums[subset][cell] + value + } + subset = subset + 1 + } + cell = cell + 1 + } + feature = feature + 1 + } + let subset_proportions : Array[Array[Double]] = [] + subset = 0 + while subset < subsets.length() { + let proportions = Array::make(cells, 0.0) + let mut cell = 0 + while cell < cells { + if sums[cell] > 0.0 { + proportions[cell] = subset_sums[subset][cell] / sums[cell] + } + cell = cell + 1 + } + subset_proportions.push(proportions) + subset = subset + 1 + } + let subset_names : Array[String] = [] + subset = 0 + while subset < subsets.length() { + subset_names.push(subsets[subset].name) + subset = subset + 1 + } + ScrapperRnaQcMetrics::{ sums, detected, subset_names, subset_proportions } +} + +///| +fn scrapper_block_layout( + cells : Int, + blocks : Array[String], +) -> (Array[String], Array[Int]) raise ScrapperError { + if blocks.length() != 0 && blocks.length() != cells { + raise ScrapperError( + "scrapper block vector length must equal the number of cells", + ) + } + if blocks.length() == 0 { + return (["all"], Array::make(cells, 0)) + } + let names : Array[String] = [] + let mapping : Map[String, Int] = Map([], capacity=blocks.length()) + let index = Array::make(cells, 0) + let mut cell = 0 + while cell < cells { + let name = blocks[cell] + if name.length() == 0 { + raise ScrapperError("scrapper block names must not be empty") + } + match mapping.get(name) { + Some(found) => index[cell] = found + None => { + let found = names.length() + names.push(name) + mapping[name] = found + index[cell] = found + } + } + cell = cell + 1 + } + (names, index) +} + +///| +fn scrapper_log_lower_threshold( + values : Array[Double], + nmads : Double, +) -> Double { + let transformed : Array[Double] = [] + let mut index = 0 + while index < values.length() { + transformed.push(@math.ln(values[index] + 1.0)) + index = index + 1 + } + let center = scrapper_median(transformed) + let spread = scrapper_mad(transformed, center) + let result = @math.exp(center - nmads * spread) - 1.0 + if result > 0.0 { + result + } else { + 0.0 + } +} + +///| +fn scrapper_upper_threshold(values : Array[Double], nmads : Double) -> Double { + let center = scrapper_median(values) + center + nmads * scrapper_mad(values, center) +} + +///| +fn scrapper_threshold_tolerance(threshold : Double) -> Double { + threshold.abs().max(1.0) * 1.0e-12 +} + +///| +/// Suggest batch-aware RNA QC thresholds using median absolute deviations. +pub fn scrapper_suggest_rna_qc_thresholds( + metrics : ScrapperRnaQcMetrics, + blocks? : Array[String] = [], + sum_num_mads? : Double = 3.0, + detected_num_mads? : Double = 3.0, + subset_proportion_num_mads? : Double = 3.0, +) -> ScrapperRnaQcThresholds raise ScrapperError { + let cells = metrics.sums.length() + if metrics.detected.length() != cells { + raise ScrapperError("scrapper RNA QC metrics have inconsistent lengths") + } + if sum_num_mads < 0.0 || + detected_num_mads < 0.0 || + subset_proportion_num_mads < 0.0 { + raise ScrapperError("scrapper MAD multipliers must be non-negative") + } + let mut subset = 0 + while subset < metrics.subset_proportions.length() { + if metrics.subset_proportions[subset].length() != cells { + raise ScrapperError( + "scrapper RNA QC subset metrics have inconsistent lengths", + ) + } + subset = subset + 1 + } + if metrics.subset_names.length() != metrics.subset_proportions.length() { + raise ScrapperError("scrapper RNA QC subset names and values differ") + } + let (block_names, block_index) = scrapper_block_layout(cells, blocks) + let n_blocks = block_names.length() + let sum_lower = Array::make(n_blocks, 0.0) + let detected_lower = Array::make(n_blocks, 0.0) + let subset_upper : Array[Array[Double]] = [] + subset = 0 + while subset < metrics.subset_proportions.length() { + subset_upper.push(Array::make(n_blocks, 0.0)) + subset = subset + 1 + } + let mut block = 0 + while block < n_blocks { + let sums : Array[Double] = [] + let detected : Array[Double] = [] + let subset_values : Array[Array[Double]] = [] + subset = 0 + while subset < metrics.subset_proportions.length() { + subset_values.push([]) + subset = subset + 1 + } + let mut cell = 0 + while cell < cells { + if block_index[cell] == block { + sums.push(metrics.sums[cell]) + detected.push(metrics.detected[cell].to_double()) + subset = 0 + while subset < metrics.subset_proportions.length() { + subset_values[subset].push(metrics.subset_proportions[subset][cell]) + subset = subset + 1 + } + } + cell = cell + 1 + } + sum_lower[block] = scrapper_log_lower_threshold(sums, sum_num_mads) + detected_lower[block] = scrapper_log_lower_threshold( + detected, detected_num_mads, + ) + subset = 0 + while subset < metrics.subset_proportions.length() { + subset_upper[subset][block] = scrapper_upper_threshold( + subset_values[subset], + subset_proportion_num_mads, + ) + subset = subset + 1 + } + block = block + 1 + } + ScrapperRnaQcThresholds::{ + block_names, + sum_lower, + detected_lower, + subset_upper, + } +} + +///| +/// Apply RNA QC thresholds. `true` denotes a retained high-quality cell. +pub fn scrapper_filter_rna_qc_metrics( + thresholds : ScrapperRnaQcThresholds, + metrics : ScrapperRnaQcMetrics, + blocks? : Array[String] = [], +) -> Array[Bool] raise ScrapperError { + let cells = metrics.sums.length() + let (block_names, block_index) = scrapper_block_layout(cells, blocks) + if block_names != thresholds.block_names { + raise ScrapperError("scrapper QC block levels do not match the thresholds") + } + if thresholds.sum_lower.length() != block_names.length() || + thresholds.detected_lower.length() != block_names.length() { + raise ScrapperError("scrapper QC threshold lengths are inconsistent") + } + if thresholds.subset_upper.length() != metrics.subset_proportions.length() { + raise ScrapperError("scrapper QC subset threshold count is inconsistent") + } + let keep = Array::make(cells, true) + let mut cell = 0 + while cell < cells { + let block = block_index[cell] + let sum_lower = thresholds.sum_lower[block] + let detected_lower = thresholds.detected_lower[block] + if metrics.sums[cell] + scrapper_threshold_tolerance(sum_lower) < sum_lower || + metrics.detected[cell].to_double() + + scrapper_threshold_tolerance(detected_lower) < + detected_lower { + keep[cell] = false + } + let mut subset = 0 + while subset < metrics.subset_proportions.length() { + if thresholds.subset_upper[subset].length() != block_names.length() { + raise ScrapperError( + "scrapper QC subset threshold length is inconsistent", + ) + } + let subset_upper = thresholds.subset_upper[subset][block] + if metrics.subset_proportions[subset][cell] > + subset_upper + scrapper_threshold_tolerance(subset_upper) { + keep[cell] = false + } + subset = subset + 1 + } + cell = cell + 1 + } + keep +} + +///| +/// Run RNA QC metric calculation, threshold suggestion and filtering. +pub fn scrapper_quick_rna_qc( + counts : Array[Array[Double]], + subsets? : Array[ScrapperNamedSubset] = [], + blocks? : Array[String] = [], + sum_num_mads? : Double = 3.0, + detected_num_mads? : Double = 3.0, + subset_proportion_num_mads? : Double = 3.0, +) -> ScrapperRnaQcResult raise ScrapperError { + let metrics = scrapper_compute_rna_qc_metrics(counts, subsets~) + let thresholds = scrapper_suggest_rna_qc_thresholds( + metrics, + blocks~, + sum_num_mads~, + detected_num_mads~, + subset_proportion_num_mads~, + ) + let keep = scrapper_filter_rna_qc_metrics(thresholds, metrics, blocks~) + ScrapperRnaQcResult::{ metrics, thresholds, keep } +} + +///| +/// Replace invalid size factors with a positive fallback. +pub fn scrapper_sanitize_size_factors( + size_factors : Array[Double], + fallback? : Double = 1.0, +) -> Array[Double] raise ScrapperError { + if !scrapper_is_finite(fallback) || fallback <= 0.0 { + raise ScrapperError("scrapper size-factor fallback must be positive") + } + let output = size_factors.copy() + let mut index = 0 + while index < output.length() { + if !scrapper_is_finite(output[index]) || output[index] <= 0.0 { + output[index] = fallback + } + index = index + 1 + } + output +} + +///| +/// Center positive size factors at unity, optionally within or across blocks. +pub fn scrapper_center_size_factors( + size_factors : Array[Double], + blocks? : Array[String] = [], + mode? : ScrapperCenterMode = Lowest, +) -> Array[Double] raise ScrapperError { + if size_factors.length() == 0 { + return [] + } + let mut index = 0 + while index < size_factors.length() { + if !scrapper_is_finite(size_factors[index]) || size_factors[index] <= 0.0 { + raise ScrapperError( + "scrapper size factors must be finite and positive before centering", + ) + } + index = index + 1 + } + let (block_names, block_index) = scrapper_block_layout( + size_factors.length(), + blocks, + ) + let totals = Array::make(block_names.length(), 0.0) + let counts = Array::make(block_names.length(), 0) + index = 0 + while index < size_factors.length() { + let block = block_index[index] + totals[block] = totals[block] + size_factors[index] + counts[block] = counts[block] + 1 + index = index + 1 + } + let means = Array::make(block_names.length(), 0.0) + let mut block = 0 + while block < block_names.length() { + means[block] = totals[block] / counts[block].to_double() + block = block + 1 + } + let output = size_factors.copy() + match mode { + Lowest => { + let mut lowest = means[0] + block = 1 + while block < means.length() { + if means[block] < lowest { + lowest = means[block] + } + block = block + 1 + } + index = 0 + while index < output.length() { + output[index] = output[index] / lowest + index = index + 1 + } + } + PerBlock => { + index = 0 + while index < output.length() { + output[index] = output[index] / means[block_index[index]] + index = index + 1 + } + } + } + output +} + +///| +/// Compute library-size factors and center them at unity. +pub fn scrapper_library_size_factors( + counts : Array[Array[Double]], + blocks? : Array[String] = [], + mode? : ScrapperCenterMode = Lowest, +) -> Array[Double] raise ScrapperError { + let (features, cells) = scrapper_matrix_shape(counts, true) + if cells == 0 { + return [] + } + let totals = Array::make(cells, 0.0) + let mut feature = 0 + while feature < features { + let mut cell = 0 + while cell < cells { + totals[cell] = totals[cell] + counts[feature][cell] + cell = cell + 1 + } + feature = feature + 1 + } + let sanitized = scrapper_sanitize_size_factors(totals) + scrapper_center_size_factors(sanitized, blocks~, mode~) +} + +///| +/// Apply scaling normalization and an optional logarithmic transformation. +pub fn scrapper_normalize_counts( + counts : Array[Array[Double]], + size_factors : Array[Double], + log_transform? : Bool = true, + pseudo_count? : Double = 1.0, + log_base? : Double = 2.0, +) -> Array[Array[Double]] raise ScrapperError { + let (features, cells) = scrapper_matrix_shape(counts, true) + if size_factors.length() != cells { + raise ScrapperError( + "scrapper size-factor length must equal the number of cells", + ) + } + if log_transform && (!scrapper_is_finite(pseudo_count) || pseudo_count <= 0.0) { + raise ScrapperError("scrapper pseudo-count must be finite and positive") + } + if log_transform && + (!scrapper_is_finite(log_base) || log_base <= 0.0 || log_base == 1.0) { + raise ScrapperError("scrapper logarithm base must be positive and not one") + } + let mut cell = 0 + while cell < cells { + if !scrapper_is_finite(size_factors[cell]) || size_factors[cell] <= 0.0 { + raise ScrapperError("scrapper size factors must be finite and positive") + } + cell = cell + 1 + } + let denominator = if log_transform { @math.ln(log_base) } else { 1.0 } + let output : Array[Array[Double]] = [] + let mut feature = 0 + while feature < features { + let row = Array::make(cells, 0.0) + cell = 0 + while cell < cells { + let normalized = counts[feature][cell] / size_factors[cell] + row[cell] = if log_transform { + @math.ln(normalized + pseudo_count) / denominator + } else { + normalized + } + cell = cell + 1 + } + output.push(row) + feature = feature + 1 + } + output +} + +///| +fn scrapper_lowess_at( + x : Double, + x_values : Array[Double], + y_values : Array[Double], + window : Int, +) -> Double { + let distances : Array[(Double, Int)] = [] + let mut index = 0 + while index < x_values.length() { + distances.push(((x_values[index] - x).abs(), index)) + index = index + 1 + } + distances.sort_by(fn(left : (Double, Int), right : (Double, Int)) -> Int { + if left.0 < right.0 { + -1 + } else if left.0 > right.0 { + 1 + } else if left.1 < right.1 { + -1 + } else if left.1 > right.1 { + 1 + } else { + 0 + } + }) + let usable = if window < distances.length() { + window + } else { + distances.length() + } + let radius = if usable > 0 { distances[usable - 1].0 } else { 0.0 } + let mut weight_sum = 0.0 + let mut weighted_x = 0.0 + let mut weighted_y = 0.0 + index = 0 + while index < usable { + let point = distances[index].1 + let ratio = if radius > 0.0 { distances[index].0 / radius } else { 0.0 } + let one_minus_cube = 1.0 - ratio * ratio * ratio + let weight = one_minus_cube * one_minus_cube * one_minus_cube + weight_sum = weight_sum + weight + weighted_x = weighted_x + weight * x_values[point] + weighted_y = weighted_y + weight * y_values[point] + index = index + 1 + } + if weight_sum <= 0.0 { + return y_values[distances[0].1] + } + let mean_x = weighted_x / weight_sum + let mean_y = weighted_y / weight_sum + let mut covariance = 0.0 + let mut variance_x = 0.0 + index = 0 + while index < usable { + let point = distances[index].1 + let ratio = if radius > 0.0 { distances[index].0 / radius } else { 0.0 } + let one_minus_cube = 1.0 - ratio * ratio * ratio + let weight = one_minus_cube * one_minus_cube * one_minus_cube + let delta_x = x_values[point] - mean_x + covariance = covariance + weight * delta_x * (y_values[point] - mean_y) + variance_x = variance_x + weight * delta_x * delta_x + index = index + 1 + } + if variance_x <= 1.0e-20 { + mean_y + } else { + mean_y + covariance / variance_x * (x - mean_x) + } +} + +///| +/// Fit a LOWESS mean-variance trend with optional quarter-root stabilization. +pub fn scrapper_fit_variance_trend( + means : Array[Double], + variances : Array[Double], + mean_filter? : Bool = true, + min_mean? : Double = 0.1, + transform? : Bool = true, + span? : Double = 0.3, + min_window_count? : Int = 5, +) -> ScrapperVarianceTrend raise ScrapperError { + if means.length() != variances.length() { + raise ScrapperError( + "scrapper trend means and variances must have equal length", + ) + } + if span <= 0.0 || span > 1.0 { + raise ScrapperError("scrapper LOWESS span must be in (0, 1]") + } + if min_window_count <= 0 { + raise ScrapperError("scrapper LOWESS minimum window count must be positive") + } + let x_values : Array[Double] = [] + let y_values : Array[Double] = [] + let mut index = 0 + while index < means.length() { + if !scrapper_is_finite(means[index]) || + !scrapper_is_finite(variances[index]) || + variances[index] < 0.0 { + raise ScrapperError( + "scrapper trend inputs must be finite with non-negative variances", + ) + } + if !mean_filter || means[index] >= min_mean { + x_values.push(means[index]) + let variance = variances[index] + y_values.push(if transform { variance.sqrt().sqrt() } else { variance }) + } + index = index + 1 + } + if x_values.length() == 0 { + raise ScrapperError("scrapper trend has no genes above the mean filter") + } + let raw_window = (span * x_values.length().to_double()).ceil().to_int() + let mut window = if raw_window > min_window_count { + raw_window + } else { + min_window_count + } + if window > x_values.length() { + window = x_values.length() + } + let mut left_x = x_values[0] + index = 1 + while index < x_values.length() { + if x_values[index] < left_x { + left_x = x_values[index] + } + index = index + 1 + } + let left_y = scrapper_lowess_at(left_x, x_values, y_values, window) + let fitted = Array::make(means.length(), 0.0) + let residuals = Array::make(means.length(), 0.0) + index = 0 + while index < means.length() { + let transformed_fit = if mean_filter && means[index] < left_x { + if left_x > 0.0 { + left_y * means[index].max(0.0) / left_x + } else { + left_y + } + } else { + scrapper_lowess_at(means[index], x_values, y_values, window) + } + let non_negative = transformed_fit.max(0.0) + fitted[index] = if transform { + non_negative * non_negative * non_negative * non_negative + } else { + non_negative + } + residuals[index] = variances[index] - fitted[index] + index = index + 1 + } + ScrapperVarianceTrend::{ fitted, residuals } +} + +///| +/// Compute per-gene means/variances and fit the mean-variance trend. +pub fn scrapper_model_gene_variances( + expression : Array[Array[Double]], + mean_filter? : Bool = true, + min_mean? : Double = 0.1, + transform? : Bool = true, + span? : Double = 0.3, + min_window_count? : Int = 5, +) -> ScrapperVarianceModel raise ScrapperError { + let (features, cells) = scrapper_matrix_shape(expression, false) + if features == 0 || cells == 0 { + raise ScrapperError( + "scrapper variance modelling requires a non-empty matrix", + ) + } + let means = Array::make(features, 0.0) + let variances = Array::make(features, 0.0) + let mut feature = 0 + while feature < features { + means[feature] = scrapper_mean(expression[feature]) + if cells > 1 { + let mut sum_squares = 0.0 + let mut cell = 0 + while cell < cells { + let difference = expression[feature][cell] - means[feature] + sum_squares = sum_squares + difference * difference + cell = cell + 1 + } + variances[feature] = sum_squares / (cells - 1).to_double() + } + feature = feature + 1 + } + let trend = scrapper_fit_variance_trend( + means, + variances, + mean_filter~, + min_mean~, + transform~, + span~, + min_window_count~, + ) + ScrapperVarianceModel::{ + means, + variances, + fitted: trend.fitted, + residuals: trend.residuals, + } +} + +///| +/// Select top genes from a variance-related statistic. +pub fn scrapper_choose_highly_variable_genes( + statistics : Array[Double], + top? : Int = 4000, + larger? : Bool = true, + keep_ties? : Bool = true, + use_bound? : Bool = true, + bound? : Double = 0.0, +) -> Array[Int] raise ScrapperError { + if top < 0 { + raise ScrapperError("scrapper HVG top count must be non-negative") + } + if !scrapper_is_finite(bound) { + raise ScrapperError("scrapper HVG bound must be finite") + } + let candidates : Array[(Int, Double)] = [] + let mut index = 0 + while index < statistics.length() { + let value = statistics[index] + if !scrapper_is_finite(value) { + raise ScrapperError("scrapper HVG statistics must be finite") + } + let accepted = !use_bound || + (if larger { value >= bound } else { value <= bound }) + if accepted { + candidates.push((index, value)) + } + index = index + 1 + } + candidates.sort_by(fn(left : (Int, Double), right : (Int, Double)) -> Int { + if left.1 == right.1 { + if left.0 < right.0 { + -1 + } else if left.0 > right.0 { + 1 + } else { + 0 + } + } else if larger { + if left.1 > right.1 { + -1 + } else { + 1 + } + } else if left.1 < right.1 { + -1 + } else { + 1 + } + }) + if top == 0 || candidates.length() == 0 { + return [] + } + let target = if top < candidates.length() { top } else { candidates.length() } + let output : Array[Int] = [] + index = 0 + while index < target { + output.push(candidates[index].0) + index = index + 1 + } + if keep_ties && target < candidates.length() { + let cutoff = candidates[target - 1].1 + index = target + while index < candidates.length() && candidates[index].1 == cutoff { + output.push(candidates[index].0) + index = index + 1 + } + } + output +} + +///| +pub fn ScrapperVarianceModel::highly_variable_genes( + self : ScrapperVarianceModel, + top? : Int = 4000, + keep_ties? : Bool = true, + positive_only? : Bool = true, +) -> Array[Int] raise ScrapperError { + scrapper_choose_highly_variable_genes( + self.residuals, + top~, + keep_ties~, + use_bound=positive_only, + bound=0.0, + ) +} + +///| +fn scrapper_combination_key(levels : Array[String]) -> String { + let mut key = "" + let mut index = 0 + while index < levels.length() { + key = key + levels[index].length().to_string() + ":" + levels[index] + ";" + index = index + 1 + } + key +} + +///| +fn scrapper_combination_name( + factor_names : Array[String], + levels : Array[String], +) -> String { + let mut name = "" + let mut index = 0 + while index < levels.length() { + if index > 0 { + name = name + "," + } + name = name + factor_names[index] + "=" + levels[index] + index = index + 1 + } + name +} + +///| +/// Aggregate expression across one or more cell grouping factors. +pub fn scrapper_aggregate_across_cells( + expression : Array[Array[Double]], + factors : Array[ScrapperFactor], + compute_sum? : Bool = true, + compute_detected? : Bool = true, + compute_median? : Bool = false, + detection_limit? : Double = 0.0, +) -> ScrapperAggregateResult raise ScrapperError { + let (features, cells) = scrapper_matrix_shape(expression, false) + if factors.length() == 0 { + raise ScrapperError("scrapper aggregation requires at least one factor") + } + if !scrapper_is_finite(detection_limit) { + raise ScrapperError("scrapper aggregation detection limit must be finite") + } + let factor_names : Array[String] = [] + let seen_factor_names : Map[String, Bool] = Map([], capacity=factors.length()) + let mut factor = 0 + while factor < factors.length() { + if factors[factor].name.length() == 0 { + raise ScrapperError("scrapper factor names must not be empty") + } + if seen_factor_names.contains(factors[factor].name) { + raise ScrapperError("scrapper factor names must be unique") + } + if factors[factor].levels.length() != cells { + raise ScrapperError( + "scrapper factor length must equal the number of cells", + ) + } + seen_factor_names[factors[factor].name] = true + factor_names.push(factors[factor].name) + factor = factor + 1 + } + let combinations : Array[Array[String]] = [] + let group_names : Array[String] = [] + let mapping : Map[String, Int] = Map([], capacity=cells) + let index = Array::make(cells, 0) + let mut cell = 0 + while cell < cells { + let levels : Array[String] = [] + factor = 0 + while factor < factors.length() { + if factors[factor].levels[cell].length() == 0 { + raise ScrapperError("scrapper factor levels must not be empty") + } + levels.push(factors[factor].levels[cell]) + factor = factor + 1 + } + let key = scrapper_combination_key(levels) + match mapping.get(key) { + Some(found) => index[cell] = found + None => { + let found = combinations.length() + combinations.push(levels) + group_names.push(scrapper_combination_name(factor_names, levels)) + mapping[key] = found + index[cell] = found + } + } + cell = cell + 1 + } + let groups = combinations.length() + let counts = Array::make(groups, 0) + cell = 0 + while cell < cells { + counts[index[cell]] = counts[index[cell]] + 1 + cell = cell + 1 + } + let sums : Array[Array[Double]] = [] + let detected : Array[Array[Int]] = [] + let medians : Array[Array[Double]] = [] + let mut feature = 0 + while feature < features { + if compute_sum { + sums.push(Array::make(groups, 0.0)) + } + if compute_detected { + detected.push(Array::make(groups, 0)) + } + if compute_median { + medians.push(Array::make(groups, 0.0)) + } + feature = feature + 1 + } + feature = 0 + while feature < features { + cell = 0 + while cell < cells { + let group = index[cell] + let value = expression[feature][cell] + if compute_sum { + sums[feature][group] = sums[feature][group] + value + } + if compute_detected && value > detection_limit { + detected[feature][group] = detected[feature][group] + 1 + } + cell = cell + 1 + } + if compute_median { + let group = 0 + let mut current_group = group + while current_group < groups { + let values : Array[Double] = [] + cell = 0 + while cell < cells { + if index[cell] == current_group { + values.push(expression[feature][cell]) + } + cell = cell + 1 + } + medians[feature][current_group] = scrapper_median(values) + current_group = current_group + 1 + } + } + feature = feature + 1 + } + ScrapperAggregateResult::{ + factor_names, + combinations, + group_names, + counts, + index, + sums, + detected, + medians, + } +} + +///| +pub fn ScrapperAggregateResult::means( + self : ScrapperAggregateResult, +) -> Array[Array[Double]] raise ScrapperError { + if self.sums.length() == 0 { + raise ScrapperError("scrapper aggregate sums were not computed") + } + let output : Array[Array[Double]] = [] + let mut feature = 0 + while feature < self.sums.length() { + let row = Array::make(self.counts.length(), 0.0) + let mut group = 0 + while group < self.counts.length() { + if self.counts[group] > 0 { + row[group] = self.sums[feature][group] / self.counts[group].to_double() + } + group = group + 1 + } + output.push(row) + feature = feature + 1 + } + output +} + +///| +pub fn ScrapperAggregateResult::n_groups(self : ScrapperAggregateResult) -> Int { + self.combinations.length() +} + +///| +pub fn ScrapperAggregateResult::summary( + self : ScrapperAggregateResult, +) -> String { + "ScrapperAggregate(groups=" + + self.n_groups().to_string() + + ", cells=" + + self.index.length().to_string() + + ", features=" + + self.sums + .length() + .max(self.detected.length()) + .max(self.medians.length()) + .to_string() + + ")" +} + +///| +fn scrapper_copy_string_map( + source : Map[String, Array[String]], +) -> Map[String, Array[String]] { + let keys = source.keys().collect() + let output : Map[String, Array[String]] = Map([], capacity=keys.length()) + let mut index = 0 + while index < keys.length() { + output[keys[index]] = source[keys[index]].copy() + index = index + 1 + } + output +} + +///| +fn scrapper_copy_matrix_map( + source : Map[String, Array[Array[Double]]], +) -> Map[String, Array[Array[Double]]] { + let keys = source.keys().collect() + let output : Map[String, Array[Array[Double]]] = Map( + [], + capacity=keys.length() + 1, + ) + let mut index = 0 + while index < keys.length() { + output[keys[index]] = scrapper_copy_matrix(source[keys[index]]) + index = index + 1 + } + output +} + +///| +fn scrapper_copy_metadata(source : Map[String, String]) -> Map[String, String] { + let keys = source.keys().collect() + let output : Map[String, String] = Map([], capacity=keys.length()) + let mut index = 0 + while index < keys.length() { + output[keys[index]] = source[keys[index]] + index = index + 1 + } + output +} + +///| +fn scrapper_copy_alt_experiments( + source : Map[String, SingleCellExperiment], +) -> Map[String, SingleCellExperiment] { + let keys = source.keys().collect() + let output : Map[String, SingleCellExperiment] = Map( + [], + capacity=keys.length(), + ) + let mut index = 0 + while index < keys.length() { + output[keys[index]] = source[keys[index]] + index = index + 1 + } + output +} + +///| +fn scrapper_clone_sce( + sce : SingleCellExperiment, + assays : Map[String, Array[Array[Double]]], + col_data : Map[String, Array[String]], +) -> SingleCellExperiment { + SingleCellExperiment::{ + assays, + row_data: scrapper_copy_string_map(sce.row_data), + col_data, + reduced_dims: scrapper_copy_matrix_map(sce.reduced_dims), + alternative_experiments: scrapper_copy_alt_experiments( + sce.alternative_experiments, + ), + metadata: scrapper_copy_metadata(sce.metadata), + row_names: sce.row_names.copy(), + col_names: sce.col_names.copy(), + } +} + +///| +/// Normalize an SCE's count assay into a new assay without mutating the input. +pub fn scrapper_normalize_rna_counts_sce( + sce : SingleCellExperiment, + size_factors? : Array[Double] = [], + assay_name? : String = "counts", + output_assay? : String = "logcounts", + blocks? : Array[String] = [], + mode? : ScrapperCenterMode = Lowest, + pseudo_count? : Double = 1.0, +) -> SingleCellExperiment raise ScrapperError { + let counts = sce_get_assay(sce, assay_name) + if counts.length() == 0 { + raise ScrapperError("scrapper SCE input assay is missing or empty") + } + let factors = if size_factors.length() == 0 { + scrapper_library_size_factors(counts, blocks~, mode~) + } else { + scrapper_center_size_factors(size_factors, blocks~, mode~) + } + let normalized = scrapper_normalize_counts(counts, factors, pseudo_count~) + let assays = scrapper_copy_matrix_map(sce.assays) + assays[output_assay] = normalized + let col_data = scrapper_copy_string_map(sce.col_data) + let factor_strings : Array[String] = [] + let mut index = 0 + while index < factors.length() { + factor_strings.push(factors[index].to_string()) + index = index + 1 + } + col_data["size_factor"] = factor_strings + scrapper_clone_sce(sce, assays, col_data) +} + +///| +/// Run RNA QC on an SCE and return a copied SCE with QC columns plus results. +pub fn scrapper_quick_rna_qc_sce( + sce : SingleCellExperiment, + subsets? : Array[ScrapperNamedSubset] = [], + blocks? : Array[String] = [], + assay_name? : String = "counts", + sum_num_mads? : Double = 3.0, + detected_num_mads? : Double = 3.0, + subset_proportion_num_mads? : Double = 3.0, +) -> (SingleCellExperiment, ScrapperRnaQcResult) raise ScrapperError { + let counts = sce_get_assay(sce, assay_name) + if counts.length() == 0 { + raise ScrapperError("scrapper SCE input assay is missing or empty") + } + let result = scrapper_quick_rna_qc( + counts, + subsets~, + blocks~, + sum_num_mads~, + detected_num_mads~, + subset_proportion_num_mads~, + ) + let col_data = scrapper_copy_string_map(sce.col_data) + let sums : Array[String] = [] + let detected : Array[String] = [] + let keep : Array[String] = [] + let mut cell = 0 + while cell < result.metrics.sums.length() { + sums.push(result.metrics.sums[cell].to_string()) + detected.push(result.metrics.detected[cell].to_string()) + keep.push(result.keep[cell].to_string()) + cell = cell + 1 + } + col_data["scrapper_sum"] = sums + col_data["scrapper_detected"] = detected + col_data["scrapper_keep"] = keep + let mut subset = 0 + while subset < result.metrics.subset_names.length() { + let values : Array[String] = [] + cell = 0 + while cell < result.metrics.sums.length() { + values.push(result.metrics.subset_proportions[subset][cell].to_string()) + cell = cell + 1 + } + col_data["scrapper_subset_" + + result.metrics.subset_names[subset] + + "_proportion"] = values + subset = subset + 1 + } + let assays = scrapper_copy_matrix_map(sce.assays) + (scrapper_clone_sce(sce, assays, col_data), result) +} + +///| +/// A deterministic feature-by-cell count matrix for examples and tests. +pub fn scrapper_sample_counts() -> Array[Array[Double]] { + [ + [20.0, 18.0, 22.0, 60.0, 55.0, 65.0], + [8.0, 7.0, 9.0, 3.0, 4.0, 2.0], + [0.0, 1.0, 0.0, 15.0, 13.0, 17.0], + [2.0, 2.0, 3.0, 1.0, 1.0, 2.0], + [1.0, 1.0, 1.0, 12.0, 10.0, 11.0], + [4.0, 5.0, 4.0, 6.0, 7.0, 6.0], + ] +} + +///| +pub fn ScrapperRnaQcResult::retained_count(self : ScrapperRnaQcResult) -> Int { + let mut retained = 0 + let mut cell = 0 + while cell < self.keep.length() { + if self.keep[cell] { + retained = retained + 1 + } + cell = cell + 1 + } + retained +} + +///| +pub fn ScrapperRnaQcResult::summary(self : ScrapperRnaQcResult) -> String { + "ScrapperRNAQC(cells=" + + self.keep.length().to_string() + + ", retained=" + + self.retained_count().to_string() + + ", subsets=" + + self.metrics.subset_names.length().to_string() + + ")" +} diff --git a/test/moonbit/scrapper_test.mbt b/test/moonbit/scrapper_test.mbt new file mode 100644 index 00000000..19dfea0d --- /dev/null +++ b/test/moonbit/scrapper_test.mbt @@ -0,0 +1,653 @@ +///| +/// Tests for Bioconductor scrapper-inspired single-cell preprocessing. + +///| +fn scrapper_test_assert_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort("values differ beyond tolerance") + } +} + +///| +fn scrapper_test_sce() -> @src.SingleCellExperiment { + @src.SCEBuilder::new() + |> @src.SCEBuilder::add_assay("counts", [ + [3.0, 6.0, 9.0], + [1.0, 2.0, 3.0], + [0.0, 1.0, 0.0], + ]) + |> @src.SCEBuilder::add_row_data("symbol", ["A", "B", "MT-C"]) + |> @src.SCEBuilder::add_col_data("batch", ["x", "x", "y"]) + |> @src.SCEBuilder::add_reduced_dim("PCA", [ + [0.1, 0.2], + [0.3, 0.4], + [0.5, 0.6], + ]) + |> @src.SCEBuilder::build +} + +///| +test "scrapper: sample count matrix uses feature by cell orientation" { + let counts = @src.scrapper_sample_counts() + assert_eq(counts.length(), 6) + assert_eq(counts[0].length(), 6) + assert_eq(counts[0][3], 60.0) +} + +///| +test "scrapper: computes RNA QC sums detected genes and subset proportions" { + let metrics = @src.scrapper_compute_rna_qc_metrics( + [[10.0, 0.0, 1.0], [0.0, 0.0, 1.0], [5.0, 0.0, 0.0]], + subsets=[@src.ScrapperNamedSubset::new("mito", [0, 2])], + ) catch { + _ => abort("valid RNA QC input should be accepted") + } + assert_eq(metrics.sums, [15.0, 0.0, 2.0]) + assert_eq(metrics.detected, [2, 0, 2]) + assert_eq(metrics.subset_names, ["mito"]) + assert_eq(metrics.subset_proportions[0], [1.0, 0.0, 0.5]) +} + +///| +test "scrapper: RNA QC detection limit uses strict greater than comparison" { + let metrics = @src.scrapper_compute_rna_qc_metrics( + [[2.0, 1.0], [1.0, 1.0], [3.0, 0.0]], + detection_limit=1.0, + ) catch { + _ => abort("valid detection limit should be accepted") + } + assert_eq(metrics.sums, [6.0, 2.0]) + assert_eq(metrics.detected, [2, 0]) +} + +///| +test "scrapper: RNA QC rejects malformed count matrices" { + let ragged = try { + ignore(@src.scrapper_compute_rna_qc_metrics([[1.0], [2.0, 3.0]])) + false + } catch { + ScrapperError(_) => true + } + let negative = try { + ignore(@src.scrapper_compute_rna_qc_metrics([[1.0, -1.0]])) + false + } catch { + ScrapperError(_) => true + } + let non_finite = try { + ignore(@src.scrapper_compute_rna_qc_metrics([[1.0, @double.not_a_number]])) + false + } catch { + ScrapperError(_) => true + } + assert_true(ragged) + assert_true(negative) + assert_true(non_finite) +} + +///| +test "scrapper: RNA QC validates named feature subsets" { + let duplicate = try { + ignore( + @src.scrapper_compute_rna_qc_metrics([[1.0], [2.0]], subsets=[ + @src.ScrapperNamedSubset::new("mito", [0]), + @src.ScrapperNamedSubset::new("mito", [1]), + ]), + ) + false + } catch { + ScrapperError(_) => true + } + let out_of_bounds = try { + ignore( + @src.scrapper_compute_rna_qc_metrics([[1.0]], subsets=[ + @src.ScrapperNamedSubset::new("mito", [1]), + ]), + ) + false + } catch { + ScrapperError(_) => true + } + assert_true(duplicate) + assert_true(out_of_bounds) +} + +///| +test "scrapper: unblocked MAD thresholds filter low-library cells" { + let metrics = @src.scrapper_compute_rna_qc_metrics([[1.0, 10.0, 100.0]]) catch { + _ => abort("valid RNA QC input should be accepted") + } + let thresholds = @src.scrapper_suggest_rna_qc_thresholds( + metrics, + sum_num_mads=0.0, + detected_num_mads=0.0, + ) catch { + _ => abort("valid RNA QC metrics should produce thresholds") + } + let keep = @src.scrapper_filter_rna_qc_metrics(thresholds, metrics) catch { + _ => abort("thresholds should apply to their source metrics") + } + assert_eq(thresholds.block_names, ["all"]) + scrapper_test_assert_close(thresholds.sum_lower[0], 10.0, 1.0e-10) + assert_eq(keep, [false, true, true]) +} + +///| +test "scrapper: blocked MAD thresholds are estimated independently" { + let metrics = @src.scrapper_compute_rna_qc_metrics([[1.0, 2.0, 100.0, 200.0]]) catch { + _ => abort("valid RNA QC input should be accepted") + } + let blocks = ["A", "A", "B", "B"] + let thresholds = @src.scrapper_suggest_rna_qc_thresholds( + metrics, + blocks~, + sum_num_mads=0.0, + detected_num_mads=0.0, + ) catch { + _ => abort("valid blocks should produce thresholds") + } + let keep = @src.scrapper_filter_rna_qc_metrics(thresholds, metrics, blocks~) catch { + _ => abort("matching blocks should be accepted") + } + assert_eq(thresholds.block_names, ["A", "B"]) + assert_true(thresholds.sum_lower[1] > thresholds.sum_lower[0]) + assert_eq(keep, [false, true, false, true]) +} + +///| +test "scrapper: subset MAD upper threshold removes high-proportion cells" { + let metrics = @src.scrapper_compute_rna_qc_metrics( + [[9.0, 1.0, 5.0], [1.0, 9.0, 5.0]], + subsets=[@src.ScrapperNamedSubset::new("mito", [0])], + ) catch { + _ => abort("valid RNA QC input should be accepted") + } + let thresholds = @src.scrapper_suggest_rna_qc_thresholds( + metrics, + sum_num_mads=100.0, + detected_num_mads=100.0, + subset_proportion_num_mads=0.0, + ) catch { + _ => abort("valid RNA QC metrics should produce thresholds") + } + let keep = @src.scrapper_filter_rna_qc_metrics(thresholds, metrics) catch { + _ => abort("thresholds should apply to their source metrics") + } + assert_eq(thresholds.subset_upper[0], [0.5]) + assert_eq(keep, [false, true, true]) +} + +///| +test "scrapper: filter rejects a different block level ordering" { + let metrics = @src.scrapper_compute_rna_qc_metrics([[1.0, 2.0]]) catch { + _ => abort("valid RNA QC input should be accepted") + } + let thresholds = @src.scrapper_suggest_rna_qc_thresholds(metrics, blocks=[ + "A", "B", + ]) catch { + _ => abort("valid blocks should produce thresholds") + } + let raised = try { + ignore( + @src.scrapper_filter_rna_qc_metrics(thresholds, metrics, blocks=["B", "A"]), + ) + false + } catch { + ScrapperError(_) => true + } + assert_true(raised) +} + +///| +test "scrapper: quick RNA QC returns metrics thresholds and summary" { + let result = @src.scrapper_quick_rna_qc( + [[1.0, 10.0, 100.0]], + sum_num_mads=0.0, + detected_num_mads=0.0, + ) catch { + _ => abort("quick RNA QC should accept valid counts") + } + assert_eq(result.keep, [false, true, true]) + assert_eq(result.retained_count(), 2) + assert_eq(result.summary(), "ScrapperRNAQC(cells=3, retained=2, subsets=0)") +} + +///| +test "scrapper: sanitizes invalid size factors without mutating input" { + let input = [2.0, 0.0, -1.0, @double.not_a_number] + let output = @src.scrapper_sanitize_size_factors(input, fallback=3.0) catch { + _ => abort("positive fallback should be accepted") + } + assert_eq(output, [2.0, 3.0, 3.0, 3.0]) + assert_eq(input[0], 2.0) + assert_eq(input[1], 0.0) + assert_true(input[3].is_nan()) +} + +///| +test "scrapper: size-factor sanitization validates fallback" { + let raised = try { + ignore(@src.scrapper_sanitize_size_factors([1.0], fallback=0.0)) + false + } catch { + ScrapperError(_) => true + } + assert_true(raised) +} + +///| +test "scrapper: centers size factors across all cells" { + let centered = @src.scrapper_center_size_factors([1.0, 2.0, 3.0]) catch { + _ => abort("positive size factors should be centered") + } + assert_eq(centered, [0.5, 1.0, 1.5]) +} + +///| +test "scrapper: per-block centering gives each block unit mean" { + let centered = @src.scrapper_center_size_factors( + [1.0, 3.0, 10.0, 20.0], + blocks=["A", "A", "B", "B"], + mode=@src.scrapper_center_per_block(), + ) catch { + _ => abort("valid blocked size factors should be centered") + } + assert_eq(centered[0], 0.5) + assert_eq(centered[1], 1.5) + scrapper_test_assert_close(centered[2], 2.0 / 3.0, 1.0e-12) + scrapper_test_assert_close(centered[3], 4.0 / 3.0, 1.0e-12) +} + +///| +test "scrapper: lowest-block centering preserves between-block scale" { + let centered = @src.scrapper_center_size_factors( + [1.0, 3.0, 10.0, 20.0], + blocks=["A", "A", "B", "B"], + mode=@src.scrapper_center_lowest(), + ) catch { + _ => abort("valid blocked size factors should be centered") + } + assert_eq(centered, [0.5, 1.5, 5.0, 10.0]) +} + +///| +test "scrapper: computes centered library size factors" { + let factors = @src.scrapper_library_size_factors([[1.0, 2.0], [3.0, 6.0]]) catch { + _ => abort("valid counts should produce library size factors") + } + scrapper_test_assert_close(factors[0], 2.0 / 3.0, 1.0e-12) + scrapper_test_assert_close(factors[1], 4.0 / 3.0, 1.0e-12) +} + +///| +test "scrapper: zero libraries receive finite fallback factors" { + let factors = @src.scrapper_library_size_factors([[0.0, 0.0]]) catch { + _ => abort("zero libraries should use sanitized factors") + } + assert_eq(factors, [1.0, 1.0]) +} + +///| +test "scrapper: performs linear count scaling" { + let normalized = @src.scrapper_normalize_counts( + [[2.0, 8.0], [4.0, 4.0]], + [2.0, 4.0], + log_transform=false, + ) catch { + _ => abort("valid size factors should normalize counts") + } + assert_eq(normalized, [[1.0, 2.0], [2.0, 1.0]]) +} + +///| +test "scrapper: performs configurable log normalization" { + let normalized = @src.scrapper_normalize_counts( + [[3.0, 8.0]], + [1.0, 2.0], + pseudo_count=1.0, + log_base=2.0, + ) catch { + _ => abort("valid size factors should normalize counts") + } + scrapper_test_assert_close(normalized[0][0], 2.0, 1.0e-12) + scrapper_test_assert_close(normalized[0][1], 2.321928094887362, 1.0e-12) +} + +///| +test "scrapper: normalization validates size factors and logarithm base" { + let wrong_length = try { + ignore(@src.scrapper_normalize_counts([[1.0, 2.0]], [1.0])) + false + } catch { + ScrapperError(_) => true + } + let non_positive = try { + ignore(@src.scrapper_normalize_counts([[1.0]], [0.0])) + false + } catch { + ScrapperError(_) => true + } + let invalid_base = try { + ignore(@src.scrapper_normalize_counts([[1.0]], [1.0], log_base=1.0)) + false + } catch { + ScrapperError(_) => true + } + assert_true(wrong_length) + assert_true(non_positive) + assert_true(invalid_base) +} + +///| +test "scrapper: models per-gene means and sample variances" { + let model = @src.scrapper_model_gene_variances( + [[1.0, 2.0, 3.0], [2.0, 2.0, 2.0], [0.0, 0.0, 0.0]], + mean_filter=false, + transform=false, + span=1.0, + min_window_count=1, + ) catch { + _ => abort("valid expression should produce a variance model") + } + assert_eq(model.means, [2.0, 2.0, 0.0]) + assert_eq(model.variances, [1.0, 0.0, 0.0]) + let mut feature = 0 + while feature < model.means.length() { + scrapper_test_assert_close( + model.residuals[feature], + model.variances[feature] - model.fitted[feature], + 1.0e-12, + ) + feature = feature + 1 + } +} + +///| +test "scrapper: LOWESS reproduces a linear mean-variance trend" { + let trend = @src.scrapper_fit_variance_trend( + [1.0, 2.0, 3.0, 4.0, 5.0], + [2.0, 4.0, 6.0, 8.0, 10.0], + mean_filter=false, + transform=false, + span=1.0, + min_window_count=5, + ) catch { + _ => abort("valid trend inputs should be fitted") + } + let mut index = 0 + while index < trend.fitted.length() { + scrapper_test_assert_close( + trend.fitted[index], + (index + 1).to_double() * 2.0, + 1.0e-9, + ) + scrapper_test_assert_close(trend.residuals[index], 0.0, 1.0e-9) + index = index + 1 + } +} + +///| +test "scrapper: variance trend extrapolates below the mean filter" { + let trend = @src.scrapper_fit_variance_trend( + [0.05, 1.0, 2.0, 3.0], + [0.01, 1.0, 2.0, 3.0], + min_mean=1.0, + transform=false, + span=1.0, + min_window_count=3, + ) catch { + _ => abort("valid filtered trend should be fitted") + } + assert_true(trend.fitted[0] >= 0.0) + assert_true(trend.fitted[0] < trend.fitted[1]) +} + +///| +test "scrapper: variance trend validates fitting parameters" { + let mismatched = try { + ignore(@src.scrapper_fit_variance_trend([1.0], [1.0, 2.0])) + false + } catch { + ScrapperError(_) => true + } + let no_genes = try { + ignore( + @src.scrapper_fit_variance_trend( + [0.0], + [0.0], + mean_filter=true, + min_mean=1.0, + ), + ) + false + } catch { + ScrapperError(_) => true + } + assert_true(mismatched) + assert_true(no_genes) +} + +///| +test "scrapper: selects top HVGs with stable tie handling" { + let selected = @src.scrapper_choose_highly_variable_genes( + [0.5, 2.0, 2.0, -1.0, 1.0], + top=1, + keep_ties=true, + ) catch { + _ => abort("finite statistics should be ranked") + } + assert_eq(selected, [1, 2]) +} + +///| +test "scrapper: HVG selection supports smaller statistics and no bound" { + let selected = @src.scrapper_choose_highly_variable_genes( + [0.5, 2.0, 2.0, -1.0, 1.0], + top=2, + larger=false, + keep_ties=false, + use_bound=false, + ) catch { + _ => abort("finite statistics should be ranked") + } + assert_eq(selected, [3, 0]) +} + +///| +test "scrapper: variance model convenience method uses positive residuals" { + let model = @src.scrapper_model_gene_variances( + [[1.0, 2.0, 8.0], [2.0, 2.0, 2.0], [1.0, 2.0, 3.0]], + mean_filter=false, + transform=false, + span=1.0, + min_window_count=1, + ) catch { + _ => abort("valid expression should produce a variance model") + } + let selected = model.highly_variable_genes(top=3) catch { + _ => abort("finite residuals should be ranked") + } + let expected = @src.scrapper_choose_highly_variable_genes( + model.residuals, + top=3, + use_bound=true, + bound=0.0, + ) catch { + _ => abort("finite residuals should be ranked") + } + assert_eq(selected, expected) +} + +///| +test "scrapper: aggregates sums detection medians and means by one factor" { + let result = @src.scrapper_aggregate_across_cells( + [[1.0, 2.0, 3.0, 4.0], [0.0, 5.0, 0.0, 7.0]], + [@src.ScrapperFactor::new("cluster", ["A", "A", "B", "B"])], + compute_median=true, + ) catch { + _ => abort("valid grouping factor should aggregate expression") + } + let means = result.means() catch { + _ => abort("aggregate sums should support means") + } + assert_eq(result.factor_names, ["cluster"]) + assert_eq(result.group_names, ["cluster=A", "cluster=B"]) + assert_eq(result.counts, [2, 2]) + assert_eq(result.index, [0, 0, 1, 1]) + assert_eq(result.sums, [[3.0, 7.0], [5.0, 7.0]]) + assert_eq(result.detected, [[2, 2], [1, 1]]) + assert_eq(result.medians, [[1.5, 3.5], [2.5, 3.5]]) + assert_eq(means, [[1.5, 3.5], [2.5, 3.5]]) + assert_eq(result.n_groups(), 2) + assert_eq( + result.summary(), + "ScrapperAggregate(groups=2, cells=4, features=2)", + ) +} + +///| +test "scrapper: aggregates unique combinations of multiple factors" { + let result = @src.scrapper_aggregate_across_cells([[1.0, 2.0, 3.0, 4.0]], [ + @src.ScrapperFactor::new("cluster", ["A", "A", "B", "B"]), + @src.ScrapperFactor::new("batch", ["X", "Y", "X", "Y"]), + ]) catch { + _ => abort("valid grouping factors should aggregate expression") + } + assert_eq(result.factor_names, ["cluster", "batch"]) + assert_eq(result.n_groups(), 4) + assert_eq(result.group_names, [ + "cluster=A,batch=X", "cluster=A,batch=Y", "cluster=B,batch=X", "cluster=B,batch=Y", + ]) + assert_eq(result.index, [0, 1, 2, 3]) +} + +///| +test "scrapper: aggregation can omit optional summaries" { + let result = @src.scrapper_aggregate_across_cells( + [[1.0, 2.0]], + [@src.ScrapperFactor::new("group", ["A", "A"])], + compute_sum=false, + compute_detected=false, + compute_median=true, + ) catch { + _ => abort("median-only aggregation should be accepted") + } + assert_eq(result.sums.length(), 0) + assert_eq(result.detected.length(), 0) + assert_eq(result.medians, [[1.5]]) + let means_missing = try { + ignore(result.means()) + false + } catch { + ScrapperError(_) => true + } + assert_true(means_missing) +} + +///| +test "scrapper: aggregation validates grouping factors" { + let no_factors = try { + ignore(@src.scrapper_aggregate_across_cells([[1.0]], [])) + false + } catch { + ScrapperError(_) => true + } + let duplicate_names = try { + ignore( + @src.scrapper_aggregate_across_cells([[1.0]], [ + @src.ScrapperFactor::new("group", ["A"]), + @src.ScrapperFactor::new("group", ["B"]), + ]), + ) + false + } catch { + ScrapperError(_) => true + } + let wrong_length = try { + ignore( + @src.scrapper_aggregate_across_cells([[1.0, 2.0]], [ + @src.ScrapperFactor::new("group", ["A"]), + ]), + ) + false + } catch { + ScrapperError(_) => true + } + assert_true(no_factors) + assert_true(duplicate_names) + assert_true(wrong_length) +} + +///| +test "scrapper: aggregation validates a finite detection limit" { + let raised = try { + ignore( + @src.scrapper_aggregate_across_cells( + [[1.0]], + [@src.ScrapperFactor::new("group", ["A"])], + detection_limit=@double.not_a_number, + ), + ) + false + } catch { + ScrapperError(_) => true + } + assert_true(raised) +} + +///| +test "scrapper: SCE normalization adds assay and size factors immutably" { + let original = scrapper_test_sce() + let normalized = @src.scrapper_normalize_rna_counts_sce(original, size_factors=[ + 1.0, 1.0, 1.0, + ]) catch { + _ => abort("valid SCE counts should be normalized") + } + assert_eq(@src.sce_get_assay(original, "logcounts").length(), 0) + let logcounts = @src.sce_get_assay(normalized, "logcounts") + assert_eq(logcounts.length(), 3) + scrapper_test_assert_close(logcounts[0][0], 2.0, 1.0e-12) + assert_eq(@src.sce_get_col_data(normalized, "size_factor"), ["1", "1", "1"]) + assert_eq(@src.sce_get_col_data(original, "size_factor").length(), 0) + assert_eq(@src.sce_get_row_data(normalized, "symbol"), ["A", "B", "MT-C"]) + assert_eq(@src.sce_get_reduced_dim(normalized, "PCA").length(), 3) +} + +///| +test "scrapper: SCE normalization deep-copies assay matrices" { + let original = scrapper_test_sce() + let normalized = @src.scrapper_normalize_rna_counts_sce(original, size_factors=[ + 1.0, 1.0, 1.0, + ]) catch { + _ => abort("valid SCE counts should be normalized") + } + let copied_counts = @src.sce_get_assay(normalized, "counts") + copied_counts[0][0] = 999.0 + assert_eq(@src.sce_get_assay(original, "counts")[0][0], 3.0) +} + +///| +test "scrapper: SCE quick QC adds copied cell metadata" { + let original = scrapper_test_sce() + let (annotated, result) = @src.scrapper_quick_rna_qc_sce( + original, + subsets=[@src.ScrapperNamedSubset::new("mito", [2])], + blocks=["x", "x", "y"], + ) catch { + _ => abort("valid SCE counts should support quick RNA QC") + } + assert_eq(result.metrics.sums, [4.0, 9.0, 12.0]) + assert_eq(@src.sce_get_col_data(annotated, "scrapper_sum").length(), 3) + assert_eq(@src.sce_get_col_data(annotated, "scrapper_detected").length(), 3) + assert_eq(@src.sce_get_col_data(annotated, "scrapper_keep").length(), 3) + assert_eq( + @src.sce_get_col_data(annotated, "scrapper_subset_mito_proportion").length(), + 3, + ) + assert_eq(@src.sce_get_col_data(original, "scrapper_sum").length(), 0) + assert_eq(@src.sce_get_col_data(annotated, "batch"), ["x", "x", "y"]) +} From fbe8b4a7387bee1621823cc6044b10eb142e578a Mon Sep 17 00:00:00 2001 From: eda Date: Tue, 4 Aug 2026 19:32:00 +0800 Subject: [PATCH 10/41] #28 feat(binary_cif): Bio.PDB.binary_cif BinaryCIF maskPDB --- README.md | 23 +- examples/binary_cif_demo/main.mbt | 98 ++ examples/binary_cif_demo/moon.pkg | 5 + src/binary_cif.mbt | 1964 +++++++++++++++++++++++++++++ test/moonbit/binary_cif_test.mbt | 560 ++++++++ 5 files changed, 2646 insertions(+), 4 deletions(-) create mode 100644 examples/binary_cif_demo/main.mbt create mode 100644 examples/binary_cif_demo/moon.pkg create mode 100644 src/binary_cif.mbt create mode 100644 test/moonbit/binary_cif_test.mbt diff --git a/README.md b/README.md index 3a7abdb9..47f91884 100644 --- a/README.md +++ b/README.md @@ -34,6 +34,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **HH-suite HHR** | Biopython `Bio.Align.hhr` | HHsearch/HHblits HHR解析、profile-profile比对、命中筛选、坐标映射、序列化往返 | ✅ | | **系统发育树** | Biopython `Bio.Phylo` | 树结构、Newick 解析、距离计算、可视化 | ✅ | | **PDB 结构** | Biopython `Bio.PDB` | 原子/残基/链解析、结构操作 | ✅ | +| **BinaryCIF** | Biopython `Bio.PDB.binary_cif` | MessagePack解析、七类逆编码、三态缺失值、类别查询、PDB Structure转换 | ✅ | | **CE 结构比对** | Biopython `Bio.PDB.cealign` | CA/C4'引导原子、AFP路径搜索、CE显著性、QCP刚体叠合、全原子变换 | ✅ | | **SAM/BAM/VCF** | pysam | 比对文件、变异检测、基因型查询 | ✅ | | **FASTA 索引** | pyfaidx | 快速随机访问、.fai 索引 | ✅ | @@ -249,6 +250,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **UniProtIO** | Biopython `Bio.SeqIO.UniprotIO` | UniProt XML格式解析、蛋白质条目提取、基因名、物种、序列、功能注释、数据库交叉引用 | ✅ | | **chem_utils** | Biopython `Bio.PDB.chem_utils` | 化学计算工具：范德华半径、共价半径、键长、键角、二面角、经验式、分子式量、氢键长度 | ✅ | | **mmCIF** | Biopython `Bio.PDB.MMCIFParser` | mmCIF格式解析、数据块、类别、原子位点提取 | ✅ | +| **BinaryCIF** | Biopython `Bio.PDB.binary_cif` | 纯MoonBit MessagePack解析、ByteArray/FixedPoint/IntervalQuantization/RunLength/Delta/IntegerPacking/StringArray逆编码、mask与Structure转换 | ✅ | | **Nexus** | Biopython `Bio.Nexus` | NEXUS格式解析、数据矩阵、系统发育树、距离矩阵 | ✅ | | **EMBOSS** | EMBOSS suite | GC偏斜、AT偏斜、分子量、Tm值、ORF查找、距离计算、蛋白质参数 | ✅ | | **ChIPseeker** | Bioconductor ChIPseeker | ChIP-seq峰注释、基因距离计算、注释分类（启动子/外显子/内含子/UTR/基因间区）、BED格式读取、peak2gene关联分析、多峰值集重叠分析(peakOverlap)、Venn图可视化、饼图可视化、结果汇总与可视化 | ✅ | @@ -512,6 +514,7 @@ IvanAXu/BioSeqs/ │ ├── chem_utils.mbt # 化学计算工具 (范德华半径、共价半径、键长、键角、二面角、分子式量) │ ├── jaspar.mbt # JASPAR PFM格式解析 (模体矩阵、PWM转换、共有序列、序列扫描) │ ├── mmcif.mbt # mmCIF格式解析 (Bio.PDB.MMCIFParser、数据块、类别、原子位点) +│ ├── binary_cif.mbt # Bio.PDB.binary_cif MessagePack解析、七类逆编码、mask与Structure转换 │ ├── nexus.mbt # Nexus格式解析 (Bio.Nexus、数据矩阵、系统发育树、距离矩阵) │ ├── emboss.mbt # EMBOSS工具接口 (GC偏斜、AT偏斜、分子量、Tm值、ORF查找、距离计算) │ ├── chipseeker.mbt # ChIPseeker ChIP-seq峰注释分析 (峰-基因距离计算、注释分类(启动子/外显子/内含子/UTR/基因间区)、BED格式读取、peak2gene关联分析、结果汇总与可视化) @@ -813,6 +816,7 @@ IvanAXu/BioSeqs/ │ ├── medline_demo/ # Medline/PubMed解析示例 (文献记录、APA引用、MeSH过滤) │ ├── ml_features/ # 机器学习特征提取示例 │ ├── mmcif_demo/ # mmCIF格式解析示例 (数据块解析、类别查询、原子位点提取) +│ ├── binary_cif_demo/ # BinaryCIF MessagePack解析、编码管线、mask与PDB Structure转换示例 │ ├── motifs_demo/ # 序列模体识别示例 │ ├── motifs_advanced_demo/ # 模体高级功能示例 (JASPAR/TRANSFAC解析、模体比对、KL/JS散度、模体聚类) │ ├── multi_assay_experiment_demo/ # MultiAssayExperiment 多组学数据协调示例 (实验协调、样本映射) @@ -1395,6 +1399,7 @@ IvanAXu/BioSeqs/ │ │ ├── gck_io_test.mbt │ │ ├── alignace_test.mbt │ │ ├── mmtf_test.mbt +│ │ ├── binary_cif_test.mbt │ │ ├── naccess_test.mbt │ │ ├── wise_test.mbt │ │ ├── dnashape_test.mbt @@ -1441,7 +1446,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8444 个测试全部通过 +moon test # ✅ 8481 个测试全部通过 ``` ### 模块对照表 @@ -1506,6 +1511,7 @@ moon test # ✅ 8444 个测试全 | `cealign.mbt` | BioPython `Bio.PDB.cealign` | CE组合扩展结构比对、AFP路径、CE显著性、QCP叠合与全原子变换 | | `neighbor_search.mbt` | BioPython `Bio.PDB.NeighborSearch` | KD 树近邻搜索 | | `mmcif.mbt` | BioPython `Bio.PDB.MMCIFParser` | mmCIF 格式解析 | +| `binary_cif.mbt` | BioPython `Bio.PDB.binary_cif` | BinaryCIF MessagePack解析、七类逆编码、三态mask、类别查询与PDB Structure转换 | | `pdb_vectors.mbt` | BioPython `Bio.PDB.vectors` | 3D向量/旋转矩阵、叉积、Kabsch叠合、二面角 | | `pdb_analysis.mbt` | BioPython `Bio.PDB.StructureAnalysis` | 二面角计算、距离矩阵、接触图、氢键检测、二级结构分配、Ramachandran图、SASA计算(Shrake-Rupley)、结构质量评估、疏水性分析 | | `pdb_header.mbt` | BioPython `Bio.PDB.ParsePDBHeader` | PDB头部元数据解析 (HEADER/TITLE/COMPOUND/SOURCE/REMARK/AUTH/DBREF) | @@ -2793,6 +2799,12 @@ moon test # ✅ 8444 个测试全 基因建模提供均值、sample variance、quarter-root LOWESS 局部线性趋势、左侧向原点外推、残差方差和带 ties/bound 控制的 HVG 选择。`scrapper_aggregate_across_cells` 可按一个或多个分类因子的唯一组合生成 pseudo-bulk sums、detected counts、means 和 medians，并返回组组合及每个细胞的组索引。`scrapper_normalize_rna_counts_sce` 与 `scrapper_quick_rna_qc_sce` 深复制 assay 和主要注释后写入结果，避免修改原 `SingleCellExperiment`。当前实现是无需 libscran C++ 的可移植 MoonBit 版本，不保证 LOWESS 与上游后端位级一致，也不覆盖 `scrapper` 的全部导出接口。 +### 245. BinaryCIF 二进制结构格式 (Bio.PDB.binary_cif) + +实现与 Biopython `Bio.PDB.binary_cif` 对应的 BinaryCIF 解析与结构转换。`binary_cif_parse` 使用纯 MoonBit MessagePack 读取器解析 data block、category 和 column，并支持 `ByteArray`、`FixedPoint`、`IntervalQuantization`、`RunLength`、`Delta`、`IntegerPacking` 和 `StringArray` 七类 BinaryCIF 逆编码；编码流水线按规范逆序执行。列 API 提供整数、浮点、文本和原始 CIF token 查询，并将 mask 的 `0/1/2` 分别表示为 present、`.` 和 `?`。解析器严格检查 UTF-8、字节范围、数组长度、整数打包值域、字符串 offsets、MessagePack 嵌套深度及尾随数据。 + +`binary_cif_to_structure` 和 `binary_cif_parse_structure` 将 `_atom_site` 转为现有 `Structure -> Model -> Chain -> Residue -> Atom` 层次，保留模型号、链、残基、坐标、occupancy、B-factor、元素、altloc、插入码、formal charge 和 ATOM/HETATM 语义。模块内置真实 MessagePack fixture，覆盖两模型、蛋白质、水分子和三态 mask。输入 API 接收原始 `Array[Int]` 字节；gzip 数据需由调用方预先解压。BinaryCIF 类别仍保留完整多字符 chain ID，但现有 PDB `Chain.id` 为 `Char`，转换时使用首字符，并拒绝首字符冲突的链 ID。 + ## 性能优化 ### 优化策略 @@ -2894,8 +2906,8 @@ moon test # ✅ 8444 个测试全 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8444 | -| 通过数 | 8444 | +| 总测试数 | 8481 | +| 通过数 | 8481 | | 失败数 | 0 | | 通过率 | 100% | @@ -2999,6 +3011,7 @@ moon test --update | Bio.Align.hhr | `hhr_test.mbt` | 33 | | SparseArray | `sparse_array_test.mbt` | 41 | | mmCIF | `mmcif_test.mbt` | 2 | +| BinaryCIF | `binary_cif_test.mbt` | 37 | | Nexus | `nexus_test.mbt` | 2 | | EMBOSS | `emboss_test.mbt` | 15 | | ChIPseeker | `chipseeker_test.mbt` | 14 | @@ -3288,7 +3301,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 352 个示例程序，展示各模块的典型用法： +项目提供 353 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3372,6 +3385,7 @@ moon run cmd/bench/main.mbt | sva_demo | SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） | `moon run examples/sva_demo/main.mbt` | | ballgown_demo | Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） | `moon run examples/ballgown_demo/main.mbt` | | mmcif_demo | mmCIF格式解析（数据块解析、类别查询、原子位点提取、结构信息） | `moon run examples/mmcif_demo/main.mbt` | +| binary_cif_demo | BinaryCIF MessagePack解析、七类逆编码、三态mask与PDB Structure转换 | `moon run examples/binary_cif_demo` | | nexus_demo | Nexus格式解析（数据矩阵、系统发育树、距离矩阵、分类单元） | `moon run examples/nexus_demo/main.mbt` | | emboss_demo | EMBOSS工具接口（GC偏斜、AT偏斜、分子量、Tm值、ORF查找、距离计算） | `moon run examples/emboss_demo/main.mbt` | | bioconductor_demo | Bioconductor模块综合示例（ChIPseeker峰注释(外显子/内含子/UTR分类、peak2gene关联)、DOSE疾病富集、ReactomePA通路分析、AnnotationDbi注释数据库、clusterProfiler富集框架、WGCNA共表达网络、Batchelor单细胞批次校正、Seurat单细胞分析） | `moon run examples/bioconductor_demo/main.mbt` | @@ -3570,6 +3584,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bioconductor SparseArray N维稀疏数组（规范化COO、R列主序、切片/置换/绑定、稀疏算术、统计与矩阵乘法） - ✅ 实现 Bio.PDB.cealign CE组合扩展结构比对（CA/C4'引导原子、AFP路径、CE Z-score、QCP叠合、局部优化与全原子变换） - ✅ 实现 Bioconductor scrapper 单细胞预处理（批次感知RNA QC、大小因子与log-normalization、LOWESS/HVG、多因子pseudo-bulk、不可变SCE集成） +- ✅ 实现 Bio.PDB.binary_cif BinaryCIF解析（MessagePack、七类逆编码、三态mask、类别查询与PDB Structure转换） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/binary_cif_demo/main.mbt b/examples/binary_cif_demo/main.mbt new file mode 100644 index 00000000..b4836f31 --- /dev/null +++ b/examples/binary_cif_demo/main.mbt @@ -0,0 +1,98 @@ +///| +fn main { + println("=== Biopython Bio.PDB.binary_cif Demo ===") + + let bytes = @src.binary_cif_sample_bytes() + let file = @src.binary_cif_parse(bytes) catch { + _ => abort("failed to parse BinaryCIF sample") + } + + println("\n1. MessagePack BinaryCIF document") + println(" Encoded bytes: " + bytes.length().to_string()) + println(" Encoder: " + file.encoder) + println(" " + file.summary()) + + let block = file.get_block(0).unwrap() + let atom_site = block.get_category("atom_site").unwrap() + println("\n2. Category and column access") + println(" Block header: " + block.header) + println(" _atom_site rows: " + atom_site.row_count.to_string()) + let first_component = atom_site + .get_column("label_comp_id") + .unwrap() + .string_at(0) catch { + _ => abort("failed to read component column") + } + println( + " First component: " + first_component.unwrap(), + ) + let first_x = atom_site + .get_column("Cartn_x") + .unwrap() + .double_at(0) catch { + _ => abort("failed to read coordinate column") + } + println( + " First x coordinate: " + first_x.unwrap().to_string(), + ) + + println("\n3. CIF missing-value masks") + let altloc = atom_site.get_column("label_alt_id").unwrap() + let token0 = altloc.cif_token_at(0) catch { + _ => abort("failed to read mask row 0") + } + let token3 = altloc.cif_token_at(3) catch { + _ => abort("failed to read mask row 3") + } + let token6 = altloc.cif_token_at(6) catch { + _ => abort("failed to read mask row 6") + } + println(" Row 0 token: " + token0) + println(" Row 3 token: " + token3) + println(" Row 6 token: " + token6) + + println("\n4. PDB structure construction") + let structure = @src.binary_cif_to_structure(file) catch { + _ => abort("failed to construct PDB structure") + } + println(" Structure ID: " + structure.get_id()) + println(" Models: " + structure.get_num_models().to_string()) + println(" Chains: " + structure.get_num_chains().to_string()) + println(" Residues: " + structure.get_num_residues().to_string()) + println(" Atoms: " + structure.get_num_atoms().to_string()) + for model in structure.get_models() { + println( + " Model " + + model.get_id().to_string() + + ": " + + model.get_num_chains().to_string() + + " chain(s), " + + model.get_atoms().length().to_string() + + " atom(s)", + ) + } + + println("\n5. Atom annotations") + let atoms = structure.get_atoms() + let first = atoms[0].get_coord() + println( + " First atom " + + atoms[0].name + + ": (" + + first.x.to_string() + + ", " + + first.y.to_string() + + ", " + + first.z.to_string() + + ")", + ) + println( + " Alternate location on atom 4: " + atoms[3].altloc.to_string(), + ) + println(" Water residue is hetero: " + structure.get_residues()[2].is_het().to_string()) + + println("\nNotes") + println(" Gzip-compressed .bcif input must be decompressed before parsing.") + println(" PDB Structure chain IDs are one character; category data keeps full IDs.") + println("\n=== Demo Complete ===") +} diff --git a/examples/binary_cif_demo/moon.pkg b/examples/binary_cif_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/binary_cif_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/binary_cif.mbt b/src/binary_cif.mbt new file mode 100644 index 00000000..c8a6fa2a --- /dev/null +++ b/src/binary_cif.mbt @@ -0,0 +1,1964 @@ +// Bio.PDB.binary_cif - BinaryCIF decoding and PDB structure construction. +// +// BinaryCIF stores CIF data blocks in MessagePack and applies a reversible +// encoding pipeline to each column. The encoding list is decoded in reverse. + +///| +pub suberror BinaryCifError { + BinaryCifError(String) +} + +///| +pub enum BinaryCifMask { + BinaryCifPresent + BinaryCifNotPresent + BinaryCifUnknown +} derive(Eq, Debug) + +///| +pub enum BinaryCifColumnKind { + BinaryCifInteger + BinaryCifFloat + BinaryCifText +} derive(Eq, Debug) + +///| +pub enum BinaryCifColumnData { + BinaryCifIntegers(Array[Int]) + BinaryCifFloats(Array[Double]) + BinaryCifStrings(Array[String]) +} + +///| +pub struct BinaryCifColumn { + name : String + data : BinaryCifColumnData + mask : Array[Int] +} + +///| +pub struct BinaryCifCategory { + name : String + row_count : Int + columns : Array[BinaryCifColumn] +} + +///| +pub struct BinaryCifDataBlock { + header : String + categories : Array[BinaryCifCategory] +} + +///| +pub struct BinaryCifFile { + version : String + encoder : String + data_blocks : Array[BinaryCifDataBlock] +} + +///| +pub fn BinaryCifColumn::kind(self : BinaryCifColumn) -> BinaryCifColumnKind { + match self.data { + BinaryCifIntegers(_) => BinaryCifInteger + BinaryCifFloats(_) => BinaryCifFloat + BinaryCifStrings(_) => BinaryCifText + } +} + +///| +pub fn BinaryCifColumn::length(self : BinaryCifColumn) -> Int { + match self.data { + BinaryCifIntegers(values) => values.length() + BinaryCifFloats(values) => values.length() + BinaryCifStrings(values) => values.length() + } +} + +///| +pub fn BinaryCifColumn::mask_at( + self : BinaryCifColumn, + index : Int, +) -> BinaryCifMask raise BinaryCifError { + if index < 0 || index >= self.length() { + raise BinaryCifError("BinaryCIF column index is out of bounds") + } + let value = if self.mask.length() == 0 { 0 } else { self.mask[index] } + match value { + 0 => BinaryCifPresent + 1 => BinaryCifNotPresent + 2 => BinaryCifUnknown + _ => raise BinaryCifError("BinaryCIF mask value must be 0, 1, or 2") + } +} + +///| +pub fn BinaryCifColumn::int_at( + self : BinaryCifColumn, + index : Int, +) -> Int? raise BinaryCifError { + match self.mask_at(index) { + BinaryCifPresent => + match self.data { + BinaryCifIntegers(values) => Some(values[index]) + _ => raise BinaryCifError("BinaryCIF column is not an integer column") + } + _ => None + } +} + +///| +pub fn BinaryCifColumn::double_at( + self : BinaryCifColumn, + index : Int, +) -> Double? raise BinaryCifError { + match self.mask_at(index) { + BinaryCifPresent => + match self.data { + BinaryCifIntegers(values) => Some(values[index].to_double()) + BinaryCifFloats(values) => Some(values[index]) + _ => raise BinaryCifError("BinaryCIF column is not a numeric column") + } + _ => None + } +} + +///| +pub fn BinaryCifColumn::string_at( + self : BinaryCifColumn, + index : Int, +) -> String? raise BinaryCifError { + match self.mask_at(index) { + BinaryCifPresent => + match self.data { + BinaryCifStrings(values) => Some(values[index]) + _ => raise BinaryCifError("BinaryCIF column is not a string column") + } + _ => None + } +} + +///| +pub fn BinaryCifColumn::cif_token_at( + self : BinaryCifColumn, + index : Int, +) -> String raise BinaryCifError { + match self.mask_at(index) { + BinaryCifNotPresent => "." + BinaryCifUnknown => "?" + BinaryCifPresent => + match self.data { + BinaryCifIntegers(values) => values[index].to_string() + BinaryCifFloats(values) => values[index].to_string() + BinaryCifStrings(values) => values[index] + } + } +} + +///| +pub fn BinaryCifCategory::get_column( + self : BinaryCifCategory, + name : String, +) -> BinaryCifColumn? { + for column in self.columns { + if column.name == name || self.name + "." + column.name == name { + return Some(column) + } + } + None +} + +///| +pub fn BinaryCifDataBlock::get_category( + self : BinaryCifDataBlock, + name : String, +) -> BinaryCifCategory? { + for category in self.categories { + if category.name == name || + (name.length() > 0 && + name.unsafe_get(0).to_int() != '_'.to_int() && + category.name == "_" + name) { + return Some(category) + } + } + None +} + +///| +pub fn BinaryCifFile::get_block( + self : BinaryCifFile, + index : Int, +) -> BinaryCifDataBlock? { + if index < 0 || index >= self.data_blocks.length() { + None + } else { + Some(self.data_blocks[index]) + } +} + +///| +pub fn BinaryCifFile::summary(self : BinaryCifFile) -> String { + let mut category_count = 0 + let mut row_count = 0 + for block in self.data_blocks { + category_count = category_count + block.categories.length() + for category in block.categories { + row_count = row_count + category.row_count + } + } + "BinaryCIF(version=" + + self.version + + ", blocks=" + + self.data_blocks.length().to_string() + + ", categories=" + + category_count.to_string() + + ", rows=" + + row_count.to_string() + + ")" +} + +// MessagePack model and decoder. + +priv enum BcifMessage { + BcifNil + BcifBoolean(Bool) + BcifIntegerValue(Int) + BcifFloatValue(Double) + BcifTextValue(String) + BcifBinaryValue(Array[Int]) + BcifArrayValue(Array[BcifMessage]) + BcifMapValue(Map[String, BcifMessage]) +} + +priv struct BcifReader { + data : Array[Int] + mut position : Int +} + +fn bcif_read_byte(reader : BcifReader) -> Int raise BinaryCifError { + if reader.position >= reader.data.length() { + raise BinaryCifError("Truncated MessagePack input") + } + let value = reader.data[reader.position] + reader.position = reader.position + 1 + value +} + +fn bcif_read_unsigned( + reader : BcifReader, + byte_count : Int, +) -> Int raise BinaryCifError { + if byte_count <= 0 || byte_count > 4 { + raise BinaryCifError("Unsupported MessagePack unsigned integer width") + } + if reader.position + byte_count > reader.data.length() { + raise BinaryCifError("Truncated MessagePack integer") + } + let first = reader.data[reader.position] + if byte_count == 4 && first >= 128 { + raise BinaryCifError("MessagePack unsigned integer exceeds MoonBit Int") + } + let mut value = 0 + for _ in 0.. Int raise BinaryCifError { + if byte_count <= 0 || byte_count > 4 { + raise BinaryCifError("Unsupported MessagePack signed integer width") + } + if reader.position + byte_count > reader.data.length() { + raise BinaryCifError("Truncated MessagePack integer") + } + let first = bcif_read_byte(reader) + let mut value = if first >= 128 { first - 256 } else { first } + for _ in 1.. Int raise BinaryCifError { + for _ in 0..<4 { + if bcif_read_byte(reader) != 0 { + raise BinaryCifError("MessagePack uint64 exceeds MoonBit Int") + } + } + bcif_read_unsigned(reader, 4) +} + +fn bcif_read_i64(reader : BcifReader) -> Int raise BinaryCifError { + if reader.position + 8 > reader.data.length() { + raise BinaryCifError("Truncated MessagePack int64") + } + let sign_byte = reader.data[reader.position] + let expected = if sign_byte >= 128 { 255 } else { 0 } + for _ in 0..<4 { + if bcif_read_byte(reader) != expected { + raise BinaryCifError("MessagePack int64 exceeds MoonBit Int") + } + } + let next = reader.data[reader.position] + if (expected == 0 && next >= 128) || (expected == 255 && next < 128) { + raise BinaryCifError("MessagePack int64 exceeds MoonBit Int") + } + bcif_read_signed(reader, 4) +} + +fn bcif_pow2(exponent : Int) -> Double { + let mut power = if exponent < 0 { -exponent } else { exponent } + let mut base = 2.0 + let mut result = 1.0 + while power > 0 { + if power % 2 == 1 { + result = result * base + } + base = base * base + power = power / 2 + } + if exponent < 0 { 1.0 / result } else { result } +} + +fn bcif_float32_from_bytes( + b0 : Int, + b1 : Int, + b2 : Int, + b3 : Int, +) -> Double raise BinaryCifError { + let sign = if b0 >= 128 { -1.0 } else { 1.0 } + let exponent = (b0 & 0x7F) * 2 + (b1 >> 7) + let mantissa = (b1 & 0x7F) * 65536 + b2 * 256 + b3 + if exponent == 255 { + raise BinaryCifError("BinaryCIF does not accept non-finite floats") + } + if exponent == 0 { + sign * mantissa.to_double() * bcif_pow2(-149) + } else { + sign * + (1.0 + mantissa.to_double() / 8388608.0) * + bcif_pow2(exponent - 127) + } +} + +fn bcif_float64_from_bytes( + bytes : Array[Int], + offset : Int, + little_endian : Bool, +) -> Double raise BinaryCifError { + let ordered = Array::make(8, 0) + for i in 0..<8 { + ordered[i] = if little_endian { + bytes[offset + 7 - i] + } else { + bytes[offset + i] + } + } + let sign = if ordered[0] >= 128 { -1.0 } else { 1.0 } + let exponent = (ordered[0] & 0x7F) * 16 + (ordered[1] >> 4) + if exponent == 2047 { + raise BinaryCifError("BinaryCIF does not accept non-finite doubles") + } + let mut fraction = (ordered[1] & 0x0F).to_double() / 16.0 + let mut scale = 1.0 / 4096.0 + for i in 2..<8 { + fraction = fraction + ordered[i].to_double() * scale + scale = scale / 256.0 + } + if exponent == 0 { + sign * fraction * bcif_pow2(-1022) + } else { + sign * (1.0 + fraction) * bcif_pow2(exponent - 1023) + } +} + +fn bcif_read_float32(reader : BcifReader) -> Double raise BinaryCifError { + let b0 = bcif_read_byte(reader) + let b1 = bcif_read_byte(reader) + let b2 = bcif_read_byte(reader) + let b3 = bcif_read_byte(reader) + bcif_float32_from_bytes(b0, b1, b2, b3) +} + +fn bcif_read_float64(reader : BcifReader) -> Double raise BinaryCifError { + if reader.position + 8 > reader.data.length() { + raise BinaryCifError("Truncated MessagePack float64") + } + let value = bcif_float64_from_bytes(reader.data, reader.position, false) + reader.position = reader.position + 8 + value +} + +fn bcif_read_utf8( + reader : BcifReader, + length : Int, +) -> String raise BinaryCifError { + if length < 0 || reader.position + length > reader.data.length() { + raise BinaryCifError("Truncated MessagePack string") + } + let end = reader.position + length + let output = StringBuilder::new() + while reader.position < end { + let first = bcif_read_byte(reader) + if first < 0x80 { + output.write_char(first.unsafe_to_char()) + } else if first >= 0xC2 && first <= 0xDF { + if reader.position >= end { + raise BinaryCifError("Truncated UTF-8 sequence") + } + let second = bcif_read_byte(reader) + if second < 0x80 || second > 0xBF { + raise BinaryCifError("Invalid UTF-8 continuation byte") + } + output.write_char(((first & 0x1F) * 64 + (second & 0x3F)).unsafe_to_char()) + } else if first >= 0xE0 && first <= 0xEF { + if reader.position + 2 > end { + raise BinaryCifError("Truncated UTF-8 sequence") + } + let second = bcif_read_byte(reader) + let third = bcif_read_byte(reader) + if second < 0x80 || + second > 0xBF || + third < 0x80 || + third > 0xBF || + (first == 0xE0 && second < 0xA0) || + (first == 0xED && second >= 0xA0) { + raise BinaryCifError("Invalid UTF-8 sequence") + } + output.write_char( + ( + (first & 0x0F) * 4096 + + (second & 0x3F) * 64 + + (third & 0x3F) + ).unsafe_to_char(), + ) + } else if first >= 0xF0 && first <= 0xF4 { + if reader.position + 3 > end { + raise BinaryCifError("Truncated UTF-8 sequence") + } + let second = bcif_read_byte(reader) + let third = bcif_read_byte(reader) + let fourth = bcif_read_byte(reader) + if second < 0x80 || + second > 0xBF || + third < 0x80 || + third > 0xBF || + fourth < 0x80 || + fourth > 0xBF || + (first == 0xF0 && second < 0x90) || + (first == 0xF4 && second >= 0x90) { + raise BinaryCifError("Invalid UTF-8 sequence") + } + output.write_char( + ( + (first & 0x07) * 262144 + + (second & 0x3F) * 4096 + + (third & 0x3F) * 64 + + (fourth & 0x3F) + ).unsafe_to_char(), + ) + } else { + raise BinaryCifError("Invalid UTF-8 leading byte") + } + } + output.to_string() +} + +fn bcif_read_binary( + reader : BcifReader, + length : Int, +) -> Array[Int] raise BinaryCifError { + if length < 0 || reader.position + length > reader.data.length() { + raise BinaryCifError("Truncated MessagePack binary value") + } + let result = Array::make(length, 0) + for i in 0.. BcifMessage raise BinaryCifError { + if depth > 128 { + raise BinaryCifError("MessagePack nesting is too deep") + } + let marker = bcif_read_byte(reader) + if marker <= 0x7F { + return BcifIntegerValue(marker) + } + if marker >= 0xE0 { + return BcifIntegerValue(marker - 256) + } + if marker >= 0xA0 && marker <= 0xBF { + return BcifTextValue(bcif_read_utf8(reader, marker & 0x1F)) + } + if marker >= 0x90 && marker <= 0x9F { + let length = marker & 0x0F + let values = Array::new(capacity=length) + for _ in 0..= 0x80 && marker <= 0x8F { + return bcif_parse_map(reader, marker & 0x0F, depth + 1) + } + match marker { + 0xC0 => BcifNil + 0xC2 => BcifBoolean(false) + 0xC3 => BcifBoolean(true) + 0xC4 => BcifBinaryValue(bcif_read_binary(reader, bcif_read_unsigned(reader, 1))) + 0xC5 => BcifBinaryValue(bcif_read_binary(reader, bcif_read_unsigned(reader, 2))) + 0xC6 => BcifBinaryValue(bcif_read_binary(reader, bcif_read_unsigned(reader, 4))) + 0xCA => BcifFloatValue(bcif_read_float32(reader)) + 0xCB => BcifFloatValue(bcif_read_float64(reader)) + 0xCC => BcifIntegerValue(bcif_read_unsigned(reader, 1)) + 0xCD => BcifIntegerValue(bcif_read_unsigned(reader, 2)) + 0xCE => BcifIntegerValue(bcif_read_unsigned(reader, 4)) + 0xCF => BcifIntegerValue(bcif_read_u64(reader)) + 0xD0 => BcifIntegerValue(bcif_read_signed(reader, 1)) + 0xD1 => BcifIntegerValue(bcif_read_signed(reader, 2)) + 0xD2 => BcifIntegerValue(bcif_read_signed(reader, 4)) + 0xD3 => BcifIntegerValue(bcif_read_i64(reader)) + 0xD9 => BcifTextValue(bcif_read_utf8(reader, bcif_read_unsigned(reader, 1))) + 0xDA => BcifTextValue(bcif_read_utf8(reader, bcif_read_unsigned(reader, 2))) + 0xDB => BcifTextValue(bcif_read_utf8(reader, bcif_read_unsigned(reader, 4))) + 0xDC => { + let length = bcif_read_unsigned(reader, 2) + let values = Array::new(capacity=length) + for _ in 0.. { + let length = bcif_read_unsigned(reader, 4) + let values = Array::new(capacity=length) + for _ in 0.. bcif_parse_map(reader, bcif_read_unsigned(reader, 2), depth + 1) + 0xDF => bcif_parse_map(reader, bcif_read_unsigned(reader, 4), depth + 1) + _ => raise BinaryCifError( + "Unsupported MessagePack marker " + marker.to_string(), + ) + } +} + +fn bcif_parse_map( + reader : BcifReader, + length : Int, + depth : Int, +) -> BcifMessage raise BinaryCifError { + let values : Map[String, BcifMessage] = Map([], capacity=length) + for _ in 0.. value + _ => raise BinaryCifError("MessagePack map keys must be strings") + } + values[key] = bcif_parse_message(reader, depth) + } + BcifMapValue(values) +} + +fn bcif_as_map( + value : BcifMessage, + context : String, +) -> Map[String, BcifMessage] raise BinaryCifError { + match value { + BcifMapValue(result) => result + _ => raise BinaryCifError(context + " must be a MessagePack map") + } +} + +fn bcif_as_array( + value : BcifMessage, + context : String, +) -> Array[BcifMessage] raise BinaryCifError { + match value { + BcifArrayValue(result) => result + _ => raise BinaryCifError(context + " must be a MessagePack array") + } +} + +fn bcif_as_string( + value : BcifMessage, + context : String, +) -> String raise BinaryCifError { + match value { + BcifTextValue(result) => result + _ => raise BinaryCifError(context + " must be a string") + } +} + +fn bcif_as_int( + value : BcifMessage, + context : String, +) -> Int raise BinaryCifError { + match value { + BcifIntegerValue(result) => result + _ => raise BinaryCifError(context + " must be an integer") + } +} + +fn bcif_as_double( + value : BcifMessage, + context : String, +) -> Double raise BinaryCifError { + match value { + BcifIntegerValue(result) => result.to_double() + BcifFloatValue(result) => result + _ => raise BinaryCifError(context + " must be numeric") + } +} + +fn bcif_as_bool( + value : BcifMessage, + context : String, +) -> Bool raise BinaryCifError { + match value { + BcifBoolean(result) => result + _ => raise BinaryCifError(context + " must be a boolean") + } +} + +fn bcif_as_binary( + value : BcifMessage, + context : String, +) -> Array[Int] raise BinaryCifError { + match value { + BcifBinaryValue(result) => result + _ => raise BinaryCifError(context + " must be binary data") + } +} + +fn bcif_required( + values : Map[String, BcifMessage], + key : String, + context : String, +) -> BcifMessage raise BinaryCifError { + match values.get(key) { + Some(value) => value + None => raise BinaryCifError(context + " is missing '" + key + "'") + } +} + +fn bcif_encoding_int( + values : Map[String, BcifMessage], + key : String, + context : String, +) -> Int raise BinaryCifError { + bcif_as_int(bcif_required(values, key, context), context + "." + key) +} + +fn bcif_encoding_double( + values : Map[String, BcifMessage], + key : String, + context : String, +) -> Double raise BinaryCifError { + bcif_as_double(bcif_required(values, key, context), context + "." + key) +} + +// BinaryCIF encoding decoders. + +fn bcif_read_i16_le(data : Array[Int], offset : Int) -> Int { + let high = data[offset + 1] + (if high >= 128 { high - 256 } else { high }) * 256 + data[offset] +} + +fn bcif_read_u16_le(data : Array[Int], offset : Int) -> Int { + data[offset] + data[offset + 1] * 256 +} + +fn bcif_read_i32_le(data : Array[Int], offset : Int) -> Int { + let high = data[offset + 3] + (if high >= 128 { high - 256 } else { high }) * 16777216 + + data[offset + 2] * 65536 + + data[offset + 1] * 256 + + data[offset] +} + +fn bcif_read_u32_le( + data : Array[Int], + offset : Int, +) -> Int raise BinaryCifError { + if data[offset + 3] >= 128 { + raise BinaryCifError("BinaryCIF UInt32 exceeds MoonBit Int") + } + data[offset + 3] * 16777216 + + data[offset + 2] * 65536 + + data[offset + 1] * 256 + + data[offset] +} + +fn bcif_validate_bytes(data : Array[Int]) -> Unit raise BinaryCifError { + for value in data { + if value < 0 || value > 255 { + raise BinaryCifError("BinaryCIF byte array contains a non-byte value") + } + } +} + +///| +pub fn binary_cif_decode_int_bytes( + data : Array[Int], + type_code : Int, +) -> Array[Int] raise BinaryCifError { + bcif_validate_bytes(data) + let width = match type_code { + 1 | 4 => 1 + 2 | 5 => 2 + 3 | 6 => 4 + _ => raise BinaryCifError("BinaryCIF type is not an integer byte array") + } + if data.length() % width != 0 { + raise BinaryCifError("BinaryCIF byte array has an invalid length") + } + let result = Array::new(capacity=data.length() / width) + let mut offset = 0 + while offset < data.length() { + let value = match type_code { + 1 => { + let raw = data[offset] + if raw >= 128 { raw - 256 } else { raw } + } + 2 => bcif_read_i16_le(data, offset) + 3 => bcif_read_i32_le(data, offset) + 4 => data[offset] + 5 => bcif_read_u16_le(data, offset) + 6 => bcif_read_u32_le(data, offset) + _ => 0 + } + result.push(value) + offset = offset + width + } + result +} + +///| +pub fn binary_cif_decode_float_bytes( + data : Array[Int], + type_code : Int, +) -> Array[Double] raise BinaryCifError { + bcif_validate_bytes(data) + let width = match type_code { + 32 => 4 + 33 => 8 + _ => raise BinaryCifError("BinaryCIF type is not a floating-point byte array") + } + if data.length() % width != 0 { + raise BinaryCifError("BinaryCIF floating-point byte array has an invalid length") + } + let result = Array::new(capacity=data.length() / width) + let mut offset = 0 + while offset < data.length() { + if type_code == 32 { + result.push( + bcif_float32_from_bytes( + data[offset + 3], + data[offset + 2], + data[offset + 1], + data[offset], + ), + ) + } else { + result.push(bcif_float64_from_bytes(data, offset, true)) + } + offset = offset + width + } + result +} + +///| +pub fn binary_cif_decode_integer_packing( + data : Array[Int], + byte_count : Int, + is_unsigned : Bool, + source_size : Int, +) -> Array[Int] raise BinaryCifError { + if byte_count != 1 && byte_count != 2 { + raise BinaryCifError("BinaryCIF integer packing uses 1- or 2-byte values") + } + if source_size < 0 { + raise BinaryCifError("BinaryCIF integer packing source size is negative") + } + let upper = if is_unsigned { + if byte_count == 1 { 255 } else { 65535 } + } else if byte_count == 1 { + 127 + } else { + 32767 + } + let lower = if is_unsigned { + 0 + } else if byte_count == 1 { + -128 + } else { + -32768 + } + let result = Array::new(capacity=source_size) + let mut accumulator = 0 + for value in data { + if value < lower || value > upper { + raise BinaryCifError("BinaryCIF integer packing value is outside its byte range") + } + accumulator = accumulator + value + let continuation = value == upper || (!is_unsigned && value == lower) + if !continuation { + result.push(accumulator) + accumulator = 0 + } + } + if accumulator != 0 || result.length() != source_size { + raise BinaryCifError("BinaryCIF integer packing source size does not match") + } + result +} + +///| +pub fn binary_cif_decode_run_length( + data : Array[Int], + source_size : Int, +) -> Array[Int] raise BinaryCifError { + if source_size < 0 || data.length() % 2 != 0 { + raise BinaryCifError("Invalid BinaryCIF run-length encoding") + } + let result = Array::new(capacity=source_size) + let mut index = 0 + while index < data.length() { + let value = data[index] + let count = data[index + 1] + if count < 0 || result.length() + count > source_size { + raise BinaryCifError("Invalid BinaryCIF run length") + } + for _ in 0.. Array[Int] { + let result = Array::new(capacity=data.length()) + let mut current = origin + for value in data { + current = current + value + result.push(current) + } + result +} + +///| +pub fn binary_cif_decode_fixed_point( + data : Array[Int], + factor : Double, +) -> Array[Double] raise BinaryCifError { + if factor == 0.0 || factor.abs() > 1.0e300 { + raise BinaryCifError("BinaryCIF fixed-point factor must be finite and non-zero") + } + let result = Array::new(capacity=data.length()) + for value in data { + result.push(value.to_double() / factor) + } + result +} + +///| +pub fn binary_cif_decode_interval_quantization( + data : Array[Int], + minimum : Double, + maximum : Double, + number_of_steps : Int, +) -> Array[Double] raise BinaryCifError { + if number_of_steps < 2 || + minimum.abs() > 1.0e300 || + maximum.abs() > 1.0e300 || + maximum < minimum { + raise BinaryCifError("Invalid BinaryCIF interval quantization parameters") + } + let step = (maximum - minimum) / (number_of_steps - 1).to_double() + let result = Array::new(capacity=data.length()) + for value in data { + if value < 0 || value >= number_of_steps { + raise BinaryCifError("BinaryCIF quantized value is outside its interval") + } + result.push(minimum + value.to_double() * step) + } + result +} + +///| +pub fn binary_cif_decode_string_array( + indices : Array[Int], + offsets : Array[Int], + string_data : String, +) -> Array[String] raise BinaryCifError { + if offsets.length() == 0 || offsets[0] != 0 { + raise BinaryCifError("BinaryCIF string offsets must start at zero") + } + for i in 1.. string_data.length() { + raise BinaryCifError("BinaryCIF string offsets are invalid") + } + } + if offsets[offsets.length() - 1] != string_data.length() { + raise BinaryCifError("BinaryCIF string offsets do not cover the string data") + } + let dictionary = Array::new(capacity=offsets.length() - 1) + for i in 0..<(offsets.length() - 1) { + dictionary.push( + string_data[offsets[i]:offsets[i + 1]].to_owned(), + ) + } + let result = Array::new(capacity=indices.length()) + for index in indices { + if index < 0 || index >= dictionary.length() { + raise BinaryCifError("BinaryCIF string lookup index is out of bounds") + } + result.push(dictionary[index]) + } + result +} + +fn bcif_decoded_length(data : BinaryCifColumnData) -> Int { + match data { + BinaryCifIntegers(values) => values.length() + BinaryCifFloats(values) => values.length() + BinaryCifStrings(values) => values.length() + } +} + +fn bcif_decode_raw( + bytes : Array[Int], + encodings : Array[BcifMessage], +) -> BinaryCifColumnData raise BinaryCifError { + let mut raw_bytes : Array[Int]? = Some(bytes) + let mut decoded : BinaryCifColumnData? = None + let mut index = encodings.length() - 1 + while index >= 0 { + let encoding = bcif_as_map(encodings[index], "BinaryCIF encoding") + let kind = bcif_as_string( + bcif_required(encoding, "kind", "BinaryCIF encoding"), + "BinaryCIF encoding.kind", + ) + match kind { + "ByteArray" => { + let source = match raw_bytes { + Some(value) => value + None => raise BinaryCifError("ByteArray must be the final BinaryCIF encoding") + } + let type_code = bcif_encoding_int(encoding, "type", "ByteArray") + decoded = Some( + if type_code == 32 || type_code == 33 { + BinaryCifFloats(binary_cif_decode_float_bytes(source, type_code)) + } else { + BinaryCifIntegers(binary_cif_decode_int_bytes(source, type_code)) + }, + ) + raw_bytes = None + } + "IntegerPacking" => { + let values = match decoded { + Some(BinaryCifIntegers(value)) => value + _ => raise BinaryCifError("IntegerPacking requires integer input") + } + let byte_count = bcif_encoding_int(encoding, "byteCount", "IntegerPacking") + let source_size = bcif_encoding_int(encoding, "srcSize", "IntegerPacking") + let is_unsigned = bcif_as_bool( + bcif_required(encoding, "isUnsigned", "IntegerPacking"), + "IntegerPacking.isUnsigned", + ) + decoded = Some( + BinaryCifIntegers( + binary_cif_decode_integer_packing( + values, + byte_count, + is_unsigned, + source_size, + ), + ), + ) + } + "RunLength" => { + let values = match decoded { + Some(BinaryCifIntegers(value)) => value + _ => raise BinaryCifError("RunLength requires integer input") + } + decoded = Some( + BinaryCifIntegers( + binary_cif_decode_run_length( + values, + bcif_encoding_int(encoding, "srcSize", "RunLength"), + ), + ), + ) + } + "Delta" => { + let values = match decoded { + Some(BinaryCifIntegers(value)) => value + _ => raise BinaryCifError("Delta requires integer input") + } + decoded = Some( + BinaryCifIntegers( + binary_cif_decode_delta( + values, + bcif_encoding_int(encoding, "origin", "Delta"), + ), + ), + ) + } + "FixedPoint" => { + let values = match decoded { + Some(BinaryCifIntegers(value)) => value + _ => raise BinaryCifError("FixedPoint requires integer input") + } + decoded = Some( + BinaryCifFloats( + binary_cif_decode_fixed_point( + values, + bcif_encoding_double(encoding, "factor", "FixedPoint"), + ), + ), + ) + } + "IntervalQuantization" => { + let values = match decoded { + Some(BinaryCifIntegers(value)) => value + _ => raise BinaryCifError("IntervalQuantization requires integer input") + } + let steps = match encoding.get("numSteps") { + Some(value) => bcif_as_int(value, "IntervalQuantization.numSteps") + None => + bcif_as_int( + bcif_required(encoding, "num_steps", "IntervalQuantization"), + "IntervalQuantization.num_steps", + ) + } + decoded = Some( + BinaryCifFloats( + binary_cif_decode_interval_quantization( + values, + bcif_encoding_double(encoding, "min", "IntervalQuantization"), + bcif_encoding_double(encoding, "max", "IntervalQuantization"), + steps, + ), + ), + ) + } + "StringArray" => { + let source = match raw_bytes { + Some(value) => value + None => raise BinaryCifError("StringArray requires raw byte input") + } + let data_encodings = bcif_as_array( + bcif_required(encoding, "dataEncoding", "StringArray"), + "StringArray.dataEncoding", + ) + let offset_encodings = bcif_as_array( + bcif_required(encoding, "offsetEncoding", "StringArray"), + "StringArray.offsetEncoding", + ) + let offsets_bytes = bcif_as_binary( + bcif_required(encoding, "offsets", "StringArray"), + "StringArray.offsets", + ) + let indices = match bcif_decode_raw(source, data_encodings) { + BinaryCifIntegers(value) => value + _ => raise BinaryCifError("StringArray lookup data must decode to integers") + } + let offsets = match bcif_decode_raw(offsets_bytes, offset_encodings) { + BinaryCifIntegers(value) => value + _ => raise BinaryCifError("StringArray offsets must decode to integers") + } + decoded = Some( + BinaryCifStrings( + binary_cif_decode_string_array( + indices, + offsets, + bcif_as_string( + bcif_required(encoding, "stringData", "StringArray"), + "StringArray.stringData", + ), + ), + ), + ) + raw_bytes = None + } + _ => raise BinaryCifError("Unsupported BinaryCIF encoding '" + kind + "'") + } + index = index - 1 + } + match decoded { + Some(value) => value + None => raise BinaryCifError("BinaryCIF data has no encoding") + } +} + +fn bcif_decode_data( + value : BcifMessage, + context : String, +) -> BinaryCifColumnData raise BinaryCifError { + let data = bcif_as_map(value, context) + let bytes = bcif_as_binary( + bcif_required(data, "data", context), + context + ".data", + ) + let encodings = bcif_as_array( + bcif_required(data, "encoding", context), + context + ".encoding", + ) + bcif_decode_raw(bytes, encodings) +} + +fn bcif_parse_column( + value : BcifMessage, + row_count : Int, +) -> BinaryCifColumn raise BinaryCifError { + let column = bcif_as_map(value, "BinaryCIF column") + let name = bcif_as_string( + bcif_required(column, "name", "BinaryCIF column"), + "BinaryCIF column.name", + ) + let data = bcif_decode_data( + bcif_required(column, "data", "BinaryCIF column"), + "BinaryCIF column '" + name + "' data", + ) + if bcif_decoded_length(data) != row_count { + raise BinaryCifError( + "BinaryCIF column '" + name + "' length does not match rowCount", + ) + } + let mask = match column.get("mask") { + None | Some(BcifNil) => Array::make(row_count, 0) + Some(mask_value) => + match bcif_decode_data(mask_value, "BinaryCIF column mask") { + BinaryCifIntegers(values) => { + if values.length() != row_count { + raise BinaryCifError("BinaryCIF mask length does not match rowCount") + } + for item in values { + if item < 0 || item > 2 { + raise BinaryCifError("BinaryCIF mask value must be 0, 1, or 2") + } + } + values + } + _ => raise BinaryCifError("BinaryCIF mask must decode to integers") + } + } + BinaryCifColumn::{ name, data, mask } +} + +fn bcif_parse_category( + value : BcifMessage, +) -> BinaryCifCategory raise BinaryCifError { + let category = bcif_as_map(value, "BinaryCIF category") + let name = bcif_as_string( + bcif_required(category, "name", "BinaryCIF category"), + "BinaryCIF category.name", + ) + let row_count = bcif_as_int( + bcif_required(category, "rowCount", "BinaryCIF category"), + "BinaryCIF category.rowCount", + ) + if row_count < 0 { + raise BinaryCifError("BinaryCIF category rowCount is negative") + } + let raw_columns = bcif_as_array( + bcif_required(category, "columns", "BinaryCIF category"), + "BinaryCIF category.columns", + ) + let columns = Array::new(capacity=raw_columns.length()) + let seen : Map[String, Bool] = Map([], capacity=raw_columns.length()) + for raw_column in raw_columns { + let column = bcif_parse_column(raw_column, row_count) + if seen.contains(column.name) { + raise BinaryCifError("Duplicate BinaryCIF column '" + column.name + "'") + } + seen[column.name] = true + columns.push(column) + } + BinaryCifCategory::{ name, row_count, columns } +} + +fn bcif_parse_block( + value : BcifMessage, +) -> BinaryCifDataBlock raise BinaryCifError { + let block = bcif_as_map(value, "BinaryCIF data block") + let header = bcif_as_string( + bcif_required(block, "header", "BinaryCIF data block"), + "BinaryCIF data block.header", + ) + let raw_categories = bcif_as_array( + bcif_required(block, "categories", "BinaryCIF data block"), + "BinaryCIF data block.categories", + ) + let categories = Array::new(capacity=raw_categories.length()) + let seen : Map[String, Bool] = Map([], capacity=raw_categories.length()) + for raw_category in raw_categories { + let category = bcif_parse_category(raw_category) + if seen.contains(category.name) { + raise BinaryCifError("Duplicate BinaryCIF category '" + category.name + "'") + } + seen[category.name] = true + categories.push(category) + } + BinaryCifDataBlock::{ header, categories } +} + +///| +pub fn binary_cif_parse( + input : Array[Int], +) -> BinaryCifFile raise BinaryCifError { + if input.length() == 0 { + raise BinaryCifError("Empty BinaryCIF input") + } + for byte in input { + if byte < 0 || byte > 255 { + raise BinaryCifError("BinaryCIF input contains a non-byte value") + } + } + if input.length() >= 2 && input[0] == 0x1F && input[1] == 0x8B { + raise BinaryCifError("Gzip-compressed BinaryCIF input must be decompressed first") + } + let reader = BcifReader::{ data: input, position: 0 } + let root = bcif_as_map( + bcif_parse_message(reader, 0), + "BinaryCIF document", + ) + if reader.position != input.length() { + raise BinaryCifError("Additional bytes follow the BinaryCIF document") + } + let version = bcif_as_string( + bcif_required(root, "version", "BinaryCIF document"), + "BinaryCIF version", + ) + let encoder = bcif_as_string( + bcif_required(root, "encoder", "BinaryCIF document"), + "BinaryCIF encoder", + ) + let raw_blocks = bcif_as_array( + bcif_required(root, "dataBlocks", "BinaryCIF document"), + "BinaryCIF dataBlocks", + ) + if raw_blocks.length() == 0 { + raise BinaryCifError("BinaryCIF document has no data blocks") + } + let data_blocks = Array::new(capacity=raw_blocks.length()) + for raw_block in raw_blocks { + data_blocks.push(bcif_parse_block(raw_block)) + } + BinaryCifFile::{ version, encoder, data_blocks } +} + +// PDB Structure conversion. + +priv struct BcifResidueBuilder { + resname : String + chain_id : Char + sequence_id : Int + insertion_code : Char + hetero_field : String + atoms : Array[Atom] +} + +priv struct BcifChainBuilder { + full_id : String + chain_id : Char + residues : Array[BcifResidueBuilder] +} + +priv struct BcifModelBuilder { + model_number : Int + chains : Array[BcifChainBuilder] +} + +fn bcif_require_column( + category : BinaryCifCategory, + name : String, +) -> BinaryCifColumn raise BinaryCifError { + match category.get_column(name) { + Some(column) => column + None => raise BinaryCifError( + "BinaryCIF category '" + category.name + "' is missing column '" + name + "'", + ) + } +} + +fn bcif_required_string( + column : BinaryCifColumn, + row : Int, +) -> String raise BinaryCifError { + match column.string_at(row) { + Some(value) => value + None => raise BinaryCifError( + "Required BinaryCIF value '" + column.name + "' is missing", + ) + } +} + +fn bcif_required_int( + column : BinaryCifColumn, + row : Int, +) -> Int raise BinaryCifError { + match column.int_at(row) { + Some(value) => value + None => raise BinaryCifError( + "Required BinaryCIF value '" + column.name + "' is missing", + ) + } +} + +fn bcif_required_double( + column : BinaryCifColumn, + row : Int, +) -> Double raise BinaryCifError { + match column.double_at(row) { + Some(value) => value + None => raise BinaryCifError( + "Required BinaryCIF value '" + column.name + "' is missing", + ) + } +} + +fn bcif_optional_string( + category : BinaryCifCategory, + name : String, + row : Int, + fallback : String, +) -> String raise BinaryCifError { + match category.get_column(name) { + None => fallback + Some(column) => + match column.string_at(row) { + Some(value) => value + None => fallback + } + } +} + +fn bcif_optional_int( + category : BinaryCifCategory, + name : String, + row : Int, + fallback : Int, +) -> Int raise BinaryCifError { + match category.get_column(name) { + None => fallback + Some(column) => + match column.int_at(row) { + Some(value) => value + None => fallback + } + } +} + +fn bcif_optional_double( + category : BinaryCifCategory, + name : String, + row : Int, + fallback : Double, +) -> Double raise BinaryCifError { + match category.get_column(name) { + None => fallback + Some(column) => + match column.double_at(row) { + Some(value) => value + None => fallback + } + } +} + +fn bcif_first_char_or_space(value : String) -> Char { + if value.length() == 0 || value == "." || value == "?" { + ' ' + } else { + value.unsafe_get(0).unsafe_to_char() + } +} + +fn bcif_hetero_field(group : String, component : String) -> String { + if group == "HETATM" { + if component == "HOH" || component == "WAT" { "W" } else { "H" } + } else { + " " + } +} + +fn bcif_entry_id(file : BinaryCifFile) -> String raise BinaryCifError { + let block = file.data_blocks[0] + match block.get_category("_entry") { + Some(category) => + match category.get_column("id") { + Some(column) => + match column.string_at(0) { + Some(value) => value + None => block.header + } + None => block.header + } + None => block.header + } +} + +///| +pub fn binary_cif_to_structure( + file : BinaryCifFile, + structure_id? : String = "", +) -> Structure raise BinaryCifError { + if file.data_blocks.length() == 0 { + raise BinaryCifError("BinaryCIF file has no data blocks") + } + let block = file.data_blocks[0] + let atom_site = match block.get_category("_atom_site") { + Some(category) => category + None => raise BinaryCifError("BinaryCIF file has no _atom_site category") + } + let names = bcif_require_column(atom_site, "label_atom_id") + let components = bcif_require_column(atom_site, "label_comp_id") + let chains = bcif_require_column(atom_site, "label_asym_id") + let sequence_ids = bcif_require_column(atom_site, "auth_seq_id") + let xs = bcif_require_column(atom_site, "Cartn_x") + let ys = bcif_require_column(atom_site, "Cartn_y") + let zs = bcif_require_column(atom_site, "Cartn_z") + let builders : Array[BcifModelBuilder] = [] + for row in 0.. 0 { + structure_id + } else { + bcif_entry_id(file) + }, + models~, + ) +} + +///| +pub fn binary_cif_parse_structure( + input : Array[Int], + structure_id? : String = "", +) -> Structure raise BinaryCifError { + binary_cif_to_structure(binary_cif_parse(input), structure_id~) +} + +// A deterministic BinaryCIF fixture used by tests and examples. + +fn bcif_message_map(entries : Array[(String, BcifMessage)]) -> BcifMessage { + let values : Map[String, BcifMessage] = Map([], capacity=entries.length()) + for entry in entries { + let (key, value) = entry + values[key] = value + } + BcifMapValue(values) +} + +fn bcif_message_array(values : Array[BcifMessage]) -> BcifMessage { + BcifArrayValue(values) +} + +fn bcif_write_u16_be(output : Array[Int], value : Int) -> Unit { + output.push((value >> 8) & 0xFF) + output.push(value & 0xFF) +} + +fn bcif_write_u32_be(output : Array[Int], value : Int) -> Unit { + output.push((value >> 24) & 0xFF) + output.push((value >> 16) & 0xFF) + output.push((value >> 8) & 0xFF) + output.push(value & 0xFF) +} + +fn bcif_write_i32_le(output : Array[Int], value : Int) -> Unit { + output.push(value & 0xFF) + output.push((value >> 8) & 0xFF) + output.push((value >> 16) & 0xFF) + output.push((value >> 24) & 0xFF) +} + +fn bcif_pack_length( + output : Array[Int], + small_base : Int, + marker16 : Int, + marker32 : Int, + length : Int, +) -> Unit { + if length < 16 { + output.push(small_base + length) + } else if length <= 65535 { + output.push(marker16) + bcif_write_u16_be(output, length) + } else { + output.push(marker32) + bcif_write_u32_be(output, length) + } +} + +fn bcif_pack_string(output : Array[Int], value : String) -> Unit { + let length = value.length() + if length < 32 { + output.push(0xA0 + length) + } else if length <= 255 { + output.push(0xD9) + output.push(length) + } else if length <= 65535 { + output.push(0xDA) + bcif_write_u16_be(output, length) + } else { + output.push(0xDB) + bcif_write_u32_be(output, length) + } + for i in 0.. Unit { + output.push(0xCB) + if value == 0.0 { + for _ in 0..<8 { + output.push(0) + } + return + } + let sign = if value < 0.0 { 0x80 } else { 0 } + let mut normalized = value.abs() + let mut exponent = 0 + while normalized >= 2.0 { + normalized = normalized / 2.0 + exponent = exponent + 1 + } + while normalized < 1.0 { + normalized = normalized * 2.0 + exponent = exponent - 1 + } + let biased = exponent + 1023 + let mut fraction = normalized - 1.0 + fraction = fraction * 16.0 + let first_nibble = fraction.to_int() + fraction = fraction - first_nibble.to_double() + output.push(sign + (biased >> 4)) + output.push(((biased & 0x0F) << 4) + first_nibble) + for _ in 0..<6 { + fraction = fraction * 256.0 + let byte = fraction.to_int() + output.push(byte) + fraction = fraction - byte.to_double() + } +} + +fn bcif_pack_message(output : Array[Int], value : BcifMessage) -> Unit { + match value { + BcifNil => output.push(0xC0) + BcifBoolean(false) => output.push(0xC2) + BcifBoolean(true) => output.push(0xC3) + BcifIntegerValue(number) => + if number >= 0 && number <= 127 { + output.push(number) + } else if number >= -32 && number < 0 { + output.push(number & 0xFF) + } else { + output.push(0xD2) + bcif_write_u32_be(output, number) + } + BcifFloatValue(number) => bcif_pack_float64(output, number) + BcifTextValue(text) => bcif_pack_string(output, text) + BcifBinaryValue(bytes) => { + if bytes.length() <= 255 { + output.push(0xC4) + output.push(bytes.length()) + } else if bytes.length() <= 65535 { + output.push(0xC5) + bcif_write_u16_be(output, bytes.length()) + } else { + output.push(0xC6) + bcif_write_u32_be(output, bytes.length()) + } + for byte in bytes { + output.push(byte) + } + } + BcifArrayValue(values) => { + bcif_pack_length(output, 0x90, 0xDC, 0xDD, values.length()) + for item in values { + bcif_pack_message(output, item) + } + } + BcifMapValue(values) => { + let keys = values.keys().collect() + bcif_pack_length(output, 0x80, 0xDE, 0xDF, keys.length()) + for key in keys { + bcif_pack_string(output, key) + bcif_pack_message(output, values[key]) + } + } + } +} + +fn bcif_byte_array_encoding(type_code : Int) -> BcifMessage { + bcif_message_map([ + ("kind", BcifTextValue("ByteArray")), + ("type", BcifIntegerValue(type_code)), + ]) +} + +fn bcif_sample_int_column( + name : String, + values : Array[Int], +) -> BcifMessage { + let bytes = Array::new(capacity=values.length() * 4) + for value in values { + bcif_write_i32_le(bytes, value) + } + bcif_message_map([ + ("name", BcifTextValue(name)), + ( + "data", + bcif_message_map([ + ("data", BcifBinaryValue(bytes)), + ("encoding", bcif_message_array([bcif_byte_array_encoding(3)])), + ]), + ), + ]) +} + +fn bcif_sample_fixed_column( + name : String, + scaled_values : Array[Int], + factor : Int, +) -> BcifMessage { + let deltas = Array::new(capacity=scaled_values.length()) + let mut previous = 0 + for value in scaled_values { + deltas.push(value - previous) + previous = value + } + let bytes = Array::new(capacity=deltas.length() * 4) + for value in deltas { + bcif_write_i32_le(bytes, value) + } + bcif_message_map([ + ("name", BcifTextValue(name)), + ( + "data", + bcif_message_map([ + ("data", BcifBinaryValue(bytes)), + ( + "encoding", + bcif_message_array([ + bcif_message_map([ + ("kind", BcifTextValue("FixedPoint")), + ("factor", BcifIntegerValue(factor)), + ("srcType", BcifIntegerValue(33)), + ]), + bcif_message_map([ + ("kind", BcifTextValue("Delta")), + ("origin", BcifIntegerValue(0)), + ("srcType", BcifIntegerValue(3)), + ]), + bcif_byte_array_encoding(3), + ]), + ), + ]), + ), + ]) +} + +fn bcif_sample_string_column( + name : String, + values : Array[String], + mask? : Array[Int] = [], +) -> BcifMessage { + let dictionary : Array[String] = [] + let indices : Array[Int] = [] + let lookup : Map[String, Int] = Map([], capacity=values.length()) + for value in values { + let index = match lookup.get(value) { + Some(existing) => existing + None => { + let created = dictionary.length() + dictionary.push(value) + lookup[value] = created + created + } + } + indices.push(index) + } + let mut string_data = "" + let offsets = [0] + for value in dictionary { + string_data = string_data + value + offsets.push(string_data.length()) + } + let offset_bytes = Array::new(capacity=offsets.length() * 4) + for value in offsets { + bcif_write_i32_le(offset_bytes, value) + } + let index_bytes = Array::new(capacity=indices.length()) + for value in indices { + index_bytes.push(value) + } + let entries : Array[(String, BcifMessage)] = [ + ("name", BcifTextValue(name)), + ( + "data", + bcif_message_map([ + ("data", BcifBinaryValue(index_bytes)), + ( + "encoding", + bcif_message_array([ + bcif_message_map([ + ("kind", BcifTextValue("StringArray")), + ( + "dataEncoding", + bcif_message_array([bcif_byte_array_encoding(4)]), + ), + ("stringData", BcifTextValue(string_data)), + ( + "offsetEncoding", + bcif_message_array([bcif_byte_array_encoding(3)]), + ), + ("offsets", BcifBinaryValue(offset_bytes)), + ]), + ]), + ), + ]), + ), + ] + if mask.length() > 0 { + entries.push( + ( + "mask", + bcif_message_map([ + ("data", BcifBinaryValue(mask)), + ("encoding", bcif_message_array([bcif_byte_array_encoding(4)])), + ]), + ), + ) + } + bcif_message_map(entries) +} + +///| +pub fn binary_cif_sample_bytes() -> Array[Int] { + let atom_count = 8 + let atom_columns = [ + bcif_sample_string_column( + "group_PDB", + ["ATOM", "ATOM", "ATOM", "ATOM", "ATOM", "HETATM", "ATOM", "ATOM"], + ), + bcif_sample_int_column("id", [1, 2, 3, 4, 5, 6, 7, 8]), + bcif_sample_string_column( + "type_symbol", + ["N", "C", "C", "N", "C", "O", "N", "C"], + ), + bcif_sample_string_column( + "label_atom_id", + ["N", "CA", "C", "N", "CA", "O", "N", "CA"], + ), + bcif_sample_string_column( + "label_alt_id", + ["", "", "", "A", "A", "", "", ""], + mask=[1, 1, 1, 0, 0, 1, 2, 1], + ), + bcif_sample_string_column( + "label_comp_id", + ["GLY", "GLY", "GLY", "ALA", "ALA", "HOH", "SER", "SER"], + ), + bcif_sample_string_column( + "label_asym_id", + ["A", "A", "A", "A", "A", "B", "A", "A"], + ), + bcif_sample_int_column("auth_seq_id", [1, 1, 1, 2, 2, 10, 1, 1]), + bcif_sample_string_column( + "pdbx_PDB_ins_code", + ["", "", "", "A", "A", "", "", ""], + mask=[1, 1, 1, 0, 0, 1, 1, 1], + ), + bcif_sample_fixed_column( + "Cartn_x", + [100, 220, 340, 460, 580, 700, 820, 940], + 100, + ), + bcif_sample_fixed_column( + "Cartn_y", + [200, 300, 400, 500, 600, 700, 800, 900], + 100, + ), + bcif_sample_fixed_column( + "Cartn_z", + [-100, 0, 100, 200, 300, 400, 500, 600], + 100, + ), + bcif_sample_fixed_column( + "occupancy", + [100, 100, 100, 50, 50, 100, 100, 100], + 100, + ), + bcif_sample_fixed_column( + "B_iso_or_equiv", + [1000, 1100, 1200, 1300, 1400, 1500, 1600, 1700], + 100, + ), + bcif_sample_int_column("pdbx_PDB_model_num", [1, 1, 1, 1, 1, 1, 2, 2]), + ] + let document = bcif_message_map([ + ("version", BcifTextValue("0.3.0")), + ("encoder", BcifTextValue("BioSeqs MoonBit")), + ( + "dataBlocks", + bcif_message_array([ + bcif_message_map([ + ("header", BcifTextValue("BCIF")), + ( + "categories", + bcif_message_array([ + bcif_message_map([ + ("name", BcifTextValue("_entry")), + ("rowCount", BcifIntegerValue(1)), + ( + "columns", + bcif_message_array([ + bcif_sample_string_column("id", ["BCIF"]), + ]), + ), + ]), + bcif_message_map([ + ("name", BcifTextValue("_atom_site")), + ("rowCount", BcifIntegerValue(atom_count)), + ("columns", bcif_message_array(atom_columns)), + ]), + ]), + ), + ]), + ]), + ), + ]) + let output : Array[Int] = [] + bcif_pack_message(output, document) + output +} diff --git a/test/moonbit/binary_cif_test.mbt b/test/moonbit/binary_cif_test.mbt new file mode 100644 index 00000000..eaf63a4d --- /dev/null +++ b/test/moonbit/binary_cif_test.mbt @@ -0,0 +1,560 @@ +///| +/// Tests for the Biopython Bio.PDB.binary_cif-compatible decoder. + +///| +test "binary cif decodes signed and unsigned 8-bit byte arrays" { + let bytes = [0, 127, 128, 255] + assert_eq(@src.binary_cif_decode_int_bytes(bytes, 1), [0, 127, -128, -1]) + assert_eq(@src.binary_cif_decode_int_bytes(bytes, 4), [0, 127, 128, 255]) +} + +///| +test "binary cif decodes signed and unsigned 16-bit byte arrays" { + let bytes = [0x34, 0x12, 0x00, 0x80, 0xFF, 0xFF] + assert_eq( + @src.binary_cif_decode_int_bytes(bytes, 2), + [4660, -32768, -1], + ) + assert_eq( + @src.binary_cif_decode_int_bytes(bytes, 5), + [4660, 32768, 65535], + ) +} + +///| +test "binary cif decodes signed and unsigned 32-bit byte arrays" { + assert_eq( + @src.binary_cif_decode_int_bytes( + [0x78, 0x56, 0x34, 0x12, 0xFF, 0xFF, 0xFF, 0xFF], + 3, + ), + [305419896, -1], + ) + assert_eq( + @src.binary_cif_decode_int_bytes([0xFF, 0xFF, 0xFF, 0x7F], 6), + [2147483647], + ) +} + +///| +test "binary cif decodes little-endian float32 byte arrays" { + let values = @src.binary_cif_decode_float_bytes([ + 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x20, 0xC0, + ], 32) + assert_eq(values.length(), 2) + assert_true((values[0] - 1.0).abs() < 1.0e-12) + assert_true((values[1] + 2.5).abs() < 1.0e-12) +} + +///| +test "binary cif decodes little-endian float64 byte arrays" { + let values = @src.binary_cif_decode_float_bytes([ + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0xF0, + 0x3F, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x04, + 0xC0, + ], 33) + assert_eq(values.length(), 2) + assert_true((values[0] - 1.0).abs() < 1.0e-12) + assert_true((values[1] + 2.5).abs() < 1.0e-12) +} + +///| +test "binary cif byte array decoding rejects invalid inputs" { + let bad_length = try { + ignore(@src.binary_cif_decode_int_bytes([1], 2)) + false + } catch { + BinaryCifError(_) => true + } + let bad_type = try { + ignore(@src.binary_cif_decode_float_bytes([0, 0, 0, 0], 31)) + false + } catch { + BinaryCifError(_) => true + } + let non_byte = try { + ignore(@src.binary_cif_decode_int_bytes([256], 4)) + false + } catch { + BinaryCifError(_) => true + } + assert_true(bad_length) + assert_true(bad_type) + assert_true(non_byte) +} + +///| +test "binary cif decodes unsigned integer packing" { + assert_eq( + @src.binary_cif_decode_integer_packing([255, 5, 1], 1, true, 2), + [260, 1], + ) +} + +///| +test "binary cif decodes signed integer packing" { + assert_eq( + @src.binary_cif_decode_integer_packing( + [127, 5, -128, -2, 10], + 1, + false, + 3, + ), + [132, -130, 10], + ) +} + +///| +test "binary cif decodes two-byte integer packing" { + assert_eq( + @src.binary_cif_decode_integer_packing([65535, 100], 2, true, 1), + [65635], + ) + assert_eq( + @src.binary_cif_decode_integer_packing([-32768, -5], 2, false, 1), + [-32773], + ) +} + +///| +test "binary cif integer packing validates metadata and values" { + let bad_width = try { + ignore(@src.binary_cif_decode_integer_packing([1], 4, true, 1)) + false + } catch { + BinaryCifError(_) => true + } + let bad_range = try { + ignore(@src.binary_cif_decode_integer_packing([256], 1, true, 1)) + false + } catch { + BinaryCifError(_) => true + } + let bad_size = try { + ignore(@src.binary_cif_decode_integer_packing([1], 1, true, 2)) + false + } catch { + BinaryCifError(_) => true + } + assert_true(bad_width) + assert_true(bad_range) + assert_true(bad_size) +} + +///| +test "binary cif decodes run-length encoding" { + assert_eq( + @src.binary_cif_decode_run_length([4, 3, -1, 2], 5), + [4, 4, 4, -1, -1], + ) +} + +///| +test "binary cif run-length decoding rejects malformed data" { + let odd = try { + ignore(@src.binary_cif_decode_run_length([4, 3, 1], 3)) + false + } catch { + BinaryCifError(_) => true + } + let overflow = try { + ignore(@src.binary_cif_decode_run_length([4, 4], 3)) + false + } catch { + BinaryCifError(_) => true + } + let mismatch = try { + ignore(@src.binary_cif_decode_run_length([4, 2], 3)) + false + } catch { + BinaryCifError(_) => true + } + assert_true(odd) + assert_true(overflow) + assert_true(mismatch) +} + +///| +test "binary cif decodes delta encoding" { + assert_eq(@src.binary_cif_decode_delta([1, 2, -1, 5], 10), [11, 13, 12, 17]) +} + +///| +test "binary cif decodes fixed-point encoding" { + let values = @src.binary_cif_decode_fixed_point([100, -25, 0], 10.0) + assert_eq(values.length(), 3) + assert_true((values[0] - 10.0).abs() < 1.0e-12) + assert_true((values[1] + 2.5).abs() < 1.0e-12) + assert_true(values[2].abs() < 1.0e-12) +} + +///| +test "binary cif fixed-point decoding rejects zero factor" { + let raised = try { + ignore(@src.binary_cif_decode_fixed_point([1], 0.0)) + false + } catch { + BinaryCifError(_) => true + } + assert_true(raised) +} + +///| +test "binary cif decodes interval quantization" { + let values = @src.binary_cif_decode_interval_quantization( + [0, 2, 4], + 0.0, + 1.0, + 5, + ) + assert_eq(values.length(), 3) + assert_true(values[0].abs() < 1.0e-12) + assert_true((values[1] - 0.5).abs() < 1.0e-12) + assert_true((values[2] - 1.0).abs() < 1.0e-12) +} + +///| +test "binary cif interval quantization validates parameters and indices" { + let bad_steps = try { + ignore( + @src.binary_cif_decode_interval_quantization([0], 0.0, 1.0, 1), + ) + false + } catch { + BinaryCifError(_) => true + } + let bad_bounds = try { + ignore( + @src.binary_cif_decode_interval_quantization([0], 2.0, 1.0, 3), + ) + false + } catch { + BinaryCifError(_) => true + } + let bad_index = try { + ignore( + @src.binary_cif_decode_interval_quantization([3], 0.0, 1.0, 3), + ) + false + } catch { + BinaryCifError(_) => true + } + assert_true(bad_steps) + assert_true(bad_bounds) + assert_true(bad_index) +} + +///| +test "binary cif decodes dictionary string arrays" { + assert_eq( + @src.binary_cif_decode_string_array([1, 0, 1], [0, 3, 6], "ALAGLY"), + ["GLY", "ALA", "GLY"], + ) +} + +///| +test "binary cif string arrays validate offsets and indices" { + let bad_start = try { + ignore(@src.binary_cif_decode_string_array([0], [1, 3], "ALA")) + false + } catch { + BinaryCifError(_) => true + } + let bad_end = try { + ignore(@src.binary_cif_decode_string_array([0], [0, 2], "ALA")) + false + } catch { + BinaryCifError(_) => true + } + let bad_index = try { + ignore(@src.binary_cif_decode_string_array([1], [0, 3], "ALA")) + false + } catch { + BinaryCifError(_) => true + } + assert_true(bad_start) + assert_true(bad_end) + assert_true(bad_index) +} + +///| +test "binary cif parses sample document metadata" { + let file = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) + assert_eq(file.version, "0.3.0") + assert_eq(file.encoder, "BioSeqs MoonBit") + assert_eq(file.data_blocks.length(), 1) + assert_eq(file.data_blocks[0].header, "BCIF") +} + +///| +test "binary cif queries blocks and categories" { + let file = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) + assert_true(file.get_block(-1) is None) + assert_true(file.get_block(1) is None) + let block = file.get_block(0).unwrap() + assert_true(block.get_category("_atom_site") is Some(_)) + assert_true(block.get_category("atom_site") is Some(_)) + assert_true(block.get_category("missing") is None) + let atom_site = block.get_category("_atom_site").unwrap() + assert_eq(atom_site.name, "_atom_site") + assert_eq(atom_site.row_count, 8) +} + +///| +test "binary cif queries columns by short and qualified names" { + let file = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) + let atom_site = file.data_blocks[0].get_category("atom_site").unwrap() + assert_true(atom_site.get_column("label_atom_id") is Some(_)) + assert_true(atom_site.get_column("_atom_site.label_atom_id") is Some(_)) + assert_true(atom_site.get_column("missing") is None) +} + +///| +test "binary cif reports decoded column kinds and lengths" { + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) + .data_blocks[0] + .get_category("atom_site") + .unwrap() + assert_true( + atom_site.get_column("id").unwrap().kind() is + @src.BinaryCifColumnKind::BinaryCifInteger, + ) + assert_true( + atom_site.get_column("Cartn_x").unwrap().kind() is + @src.BinaryCifColumnKind::BinaryCifFloat, + ) + assert_true( + atom_site.get_column("label_atom_id").unwrap().kind() is + @src.BinaryCifColumnKind::BinaryCifText, + ) + assert_eq(atom_site.get_column("Cartn_x").unwrap().length(), 8) +} + +///| +test "binary cif reads integer columns" { + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) + .data_blocks[0] + .get_category("atom_site") + .unwrap() + let ids = atom_site.get_column("id").unwrap() + assert_eq(ids.int_at(0), Some(1)) + assert_eq(ids.int_at(7), Some(8)) + assert_eq(ids.double_at(3), Some(4.0)) +} + +///| +test "binary cif reverses fixed-point and delta pipelines" { + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) + .data_blocks[0] + .get_category("atom_site") + .unwrap() + let xs = atom_site.get_column("Cartn_x").unwrap() + assert_true((xs.double_at(0).unwrap() - 1.0).abs() < 1.0e-12) + assert_true((xs.double_at(1).unwrap() - 2.2).abs() < 1.0e-12) + assert_true((xs.double_at(7).unwrap() - 9.4).abs() < 1.0e-12) +} + +///| +test "binary cif reverses string array pipelines" { + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) + .data_blocks[0] + .get_category("atom_site") + .unwrap() + let components = atom_site.get_column("label_comp_id").unwrap() + assert_eq(components.string_at(0), Some("GLY")) + assert_eq(components.string_at(3), Some("ALA")) + assert_eq(components.string_at(5), Some("HOH")) + assert_eq(components.string_at(7), Some("SER")) +} + +///| +test "binary cif exposes present not-present and unknown masks" { + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) + .data_blocks[0] + .get_category("atom_site") + .unwrap() + let altloc = atom_site.get_column("label_alt_id").unwrap() + assert_true( + altloc.mask_at(0) is @src.BinaryCifMask::BinaryCifNotPresent, + ) + assert_true(altloc.mask_at(3) is @src.BinaryCifMask::BinaryCifPresent) + assert_true(altloc.mask_at(6) is @src.BinaryCifMask::BinaryCifUnknown) + assert_true(altloc.string_at(0) is None) + assert_eq(altloc.string_at(3), Some("A")) + assert_true(altloc.string_at(6) is None) + assert_eq(altloc.cif_token_at(0), ".") + assert_eq(altloc.cif_token_at(3), "A") + assert_eq(altloc.cif_token_at(6), "?") +} + +///| +test "binary cif column access validates type and bounds" { + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) + .data_blocks[0] + .get_category("atom_site") + .unwrap() + let names = atom_site.get_column("label_atom_id").unwrap() + let wrong_type = try { + ignore(names.int_at(0)) + false + } catch { + BinaryCifError(_) => true + } + let out_of_bounds = try { + ignore(names.string_at(8)) + false + } catch { + BinaryCifError(_) => true + } + assert_true(wrong_type) + assert_true(out_of_bounds) +} + +///| +test "binary cif summarizes document contents" { + let file = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) + assert_eq( + file.summary(), + "BinaryCIF(version=0.3.0, blocks=1, categories=2, rows=9)", + ) +} + +///| +test "binary cif builds pdb structure hierarchy" { + let structure = @src.binary_cif_parse_structure(@src.binary_cif_sample_bytes()) + assert_eq(structure.get_id(), "BCIF") + assert_eq(structure.get_num_models(), 2) + assert_eq(structure.get_num_chains(), 3) + assert_eq(structure.get_num_residues(), 4) + assert_eq(structure.get_num_atoms(), 8) +} + +///| +test "binary cif preserves model and chain grouping" { + let structure = @src.binary_cif_parse_structure(@src.binary_cif_sample_bytes()) + let models = structure.get_models() + assert_eq(models[0].get_id(), 0) + assert_eq(models[1].get_id(), 1) + assert_eq(models[0].get_num_chains(), 2) + assert_eq(models[1].get_num_chains(), 1) + assert_eq(models[0].get_chains()[0].get_id(), 'A') + assert_eq(models[0].get_chains()[1].get_id(), 'B') +} + +///| +test "binary cif preserves residues insertion codes and water" { + let structure = @src.binary_cif_parse_structure(@src.binary_cif_sample_bytes()) + let residues = structure.get_residues() + assert_eq(residues[0].resname, "GLY") + assert_eq(residues[0].resseq, 1) + assert_false(residues[0].is_het()) + assert_eq(residues[1].resname, "ALA") + assert_eq(residues[1].icode, 'A') + assert_eq(residues[2].resname, "HOH") + assert_true(residues[2].is_het()) + assert_eq(residues[2].chainid, 'B') + assert_eq(residues[3].resname, "SER") +} + +///| +test "binary cif preserves atom annotations and coordinates" { + let structure = @src.binary_cif_parse_structure(@src.binary_cif_sample_bytes()) + let atoms = structure.get_atoms() + assert_eq(atoms[0].name, "N") + assert_eq(atoms[0].element, "N") + let first = atoms[0].get_coord() + assert_true((first.x - 1.0).abs() < 1.0e-12) + assert_true((first.y - 2.0).abs() < 1.0e-12) + assert_true((first.z + 1.0).abs() < 1.0e-12) + assert_eq(atoms[3].altloc, 'A') + assert_true((atoms[3].occupancy - 0.5).abs() < 1.0e-12) + assert_true((atoms[3].bfactor - 13.0).abs() < 1.0e-12) +} + +///| +test "binary cif structure conversion supports id override" { + let file = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) + let structure = @src.binary_cif_to_structure(file, structure_id="custom") + assert_eq(structure.get_id(), "custom") + assert_eq(structure.get_num_atoms(), 8) +} + +///| +test "binary cif rejects empty gzip and non-byte inputs" { + let empty = try { + ignore(@src.binary_cif_parse([])) + false + } catch { + BinaryCifError(_) => true + } + let gzip = try { + ignore(@src.binary_cif_parse([0x1F, 0x8B, 0x08])) + false + } catch { + BinaryCifError(_) => true + } + let non_byte = try { + ignore(@src.binary_cif_parse([300])) + false + } catch { + BinaryCifError(_) => true + } + assert_true(empty) + assert_true(gzip) + assert_true(non_byte) +} + +///| +test "binary cif rejects truncated and trailing MessagePack data" { + let bytes = @src.binary_cif_sample_bytes() + let truncated : Array[Int] = [] + for i in 0..<(bytes.length() - 1) { + truncated.push(bytes[i]) + } + let truncated_raised = try { + ignore(@src.binary_cif_parse(truncated)) + false + } catch { + BinaryCifError(_) => true + } + bytes.push(0) + let trailing_raised = try { + ignore(@src.binary_cif_parse(bytes)) + false + } catch { + BinaryCifError(_) => true + } + assert_true(truncated_raised) + assert_true(trailing_raised) +} + +///| +test "binary cif rejects unsupported MessagePack markers and roots" { + let marker = try { + ignore(@src.binary_cif_parse([0xC1])) + false + } catch { + BinaryCifError(_) => true + } + let root = try { + ignore(@src.binary_cif_parse([0x90])) + false + } catch { + BinaryCifError(_) => true + } + assert_true(marker) + assert_true(root) +} From 3fba5317283cb51678464740e057b37624341870 Mon Sep 17 00:00:00 2001 From: eda Date: Tue, 4 Aug 2026 19:55:19 +0800 Subject: [PATCH 11/41] #28 feat(milo): Bioconductor miloR & KNN & GLM & graph spatial FDR --- README.md | 21 +- examples/milo_demo/main.mbt | 148 +++++ examples/milo_demo/moon.pkg | 5 + src/milo.mbt | 1234 +++++++++++++++++++++++++++++++++++ test/moonbit/milo_test.mbt | 697 ++++++++++++++++++++ 5 files changed, 2102 insertions(+), 3 deletions(-) create mode 100644 examples/milo_demo/main.mbt create mode 100644 examples/milo_demo/moon.pkg create mode 100644 src/milo.mbt create mode 100644 test/moonbit/milo_test.mbt diff --git a/README.md b/README.md index 47f91884..3e7f74bb 100644 --- a/README.md +++ b/README.md @@ -45,6 +45,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **pheatmap** | Bioconductor pheatmap | 增强型热图可视化：层次聚类(complete/average/ward)、距离矩阵(euclidean/manhattan/correlation)、行/列注释、颜色方案、聚类间隙 | ✅ | | **factoextra** | Bioconductor factoextra | PCA/因子分析工具：特征值计算、方差解释率、个体/变量坐标、cos2质量、贡献度评分、维度描述 | ✅ | | **DESeq2** | Bioconductor DESeq2 | 差异表达分析、size factors归一化、分散度估计、负二项GLM拟合、Wald检验、LFC收缩 | ✅ | +| **miloR** | Bioconductor miloR | 单细胞KNN邻域采样、样本计数、负二项差异丰度、graph spatial FDR、SCE接入 | ✅ | | **dplyr** | R dplyr | DataFrame 数据操作 | ✅ | | **enrichplot** | Bioconductor enrichplot | 富集分析结果可视化、dotplot/barplot/heatmap/cnetplot/enrichment map | ✅ | | **IsoformSwitchAnalyzeR** | Bioconductor IsoformSwitchAnalyzeR | 转录本异构体切换分析、PSI/DPSI/DIF值计算、功能后果预测 | ✅ | @@ -277,6 +278,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **BiocGenerics** | Bioconductor BiocGenerics | Bioconductor通用函数、NA处理、排序、集合运算、匹配、表统计、序列生成 | ✅ | | **scran** | Bioconductor scran | 单细胞归一化(sum_factors)、SNN图构建、Leiden聚类、差异标志物分析 | ✅ | | **scrapper** | Bioconductor scrapper | 批次感知RNA QC、大小因子清洗与居中、log-normalization、LOWESS方差趋势、HVG选择、多因子pseudo-bulk、不可变SCE集成 | ✅ | +| **miloR** | Bioconductor miloR | 精确KNN图、精炼重叠邻域、邻域×样本计数、NB-GLM/Wald检验、BH与四种graph spatial FDR、SingleCellExperiment接入 | ✅ | | **monocle3** | Bioconductor monocle3 | 单细胞轨迹分析、PCA/UMAP降维、主图学习、拟时间排序、差异表达分析、分支点检测、分支特异性差异表达 | ✅ | | **ShortRead** | Bioconductor ShortRead | 短读序列质量控制、QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告生成 | ✅ | | **scater** | Bioconductor scater | 单细胞质量控制、QC指标计算、细胞/基因过滤、CPM/log-CPM标准化、HVG检测、PCA降维 | ✅ | @@ -532,6 +534,7 @@ IvanAXu/BioSeqs/ │ ├── droplet_utils.mbt # DropletUtils 空液滴检测 (emptyDrops算法、knee点检测、细胞过滤) │ ├── scran.mbt # scran 单细胞归一化与聚类 (sum_factors、SNN图、Leiden聚类、标志物分析) │ ├── scrapper.mbt # scrapper 单细胞预处理 (批次感知RNA QC、大小因子、LOWESS/HVG、pseudo-bulk、SCE集成) +│ ├── milo.mbt # miloR KNN邻域差异丰度 (精炼采样、NB-GLM、graph spatial FDR、SCE接入) │ ├── monocle3.mbt # monocle3 单细胞轨迹分析 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read.mbt # ShortRead 短读序列质量控制 (QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告) │ ├── seq_quality_trim.mbt # NGS质量修剪与接头去除 (质量修剪、接头去除、poly-A修剪、长度/GC过滤、批量修剪) @@ -875,6 +878,7 @@ IvanAXu/BioSeqs/ │ ├── droplet_utils_demo/ # DropletUtils 空液滴检测示例 (emptyDrops算法、knee点检测、细胞过滤) │ ├── scran_demo/ # scran 单细胞归一化与聚类示例 (sum_factors、SNN图、Leiden聚类、标志物分析) │ ├── scrapper_demo/ # scrapper 批次感知RNA QC、归一化、LOWESS/HVG、pseudo-bulk与SCE集成示例 +│ ├── milo_demo/ # miloR KNN图、精炼邻域、NB差异丰度、spatial FDR与SCE接入示例 │ ├── monocle3_demo/ # monocle3 单细胞轨迹分析示例 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read_demo/ # ShortRead 短读序列质量控制示例 (QA统计、adapter修剪、质量修剪、FastQC报告) │ ├── scater_demo/ # scater 单细胞质量控制示例 (QC指标计算、细胞/基因过滤、标准化、HVG检测、PCA) @@ -1271,6 +1275,7 @@ IvanAXu/BioSeqs/ │ │ ├── scnorm_test.mbt │ │ ├── scran_test.mbt │ │ ├── scrapper_test.mbt +│ │ ├── milo_test.mbt │ │ ├── search_io_test.mbt │ │ ├── searchio_new_test.mbt │ │ ├── seq_complexity_test.mbt @@ -1748,6 +1753,7 @@ moon test # ✅ 8481 个测试全 | `system_piper.mbt` | `SystemPipeR` | 流水线编排（步骤管理、依赖关系、进度追踪） | | `muscat.mbt` | `muscat` | 单细胞差异状态分析（伪批量聚合、DS 检验、QC） | | `scrapper.mbt` | `scrapper` | 批次感知RNA QC、大小因子清洗/居中、count与log归一化、LOWESS方差趋势、HVG选择、多因子pseudo-bulk、SingleCellExperiment不可变包装 | +| `milo.mbt` | `miloR` | 精确KNN图、median精炼重叠邻域、邻域计数/表达、固定效应NB-GLM/Wald检验、graph spatial FDR与SCE接入 | | `infercnv.mbt` | `infercnv` | 单细胞拷贝数变异推断（基因组位置排序、参考细胞有界 LFC 计算、金字塔权重平滑、CNV 分数与恶性细胞预测） | | `scenic.mbt` | `SCENIC` | 单细胞调控网络推断与聚类（TF-target 共表达模块、Regulon 构建、AUCell 活性评分、二值化阈值、细胞状态与主控调控因子） | | `cibersort.mbt` | `CIBERSORT` | 免疫细胞去卷积（NNLS 求解、LM22 风格特征矩阵、Pearson 拟合优度、分数归一化） | @@ -2805,6 +2811,12 @@ moon test # ✅ 8481 个测试全 `binary_cif_to_structure` 和 `binary_cif_parse_structure` 将 `_atom_site` 转为现有 `Structure -> Model -> Chain -> Residue -> Atom` 层次，保留模型号、链、残基、坐标、occupancy、B-factor、元素、altloc、插入码、formal charge 和 ATOM/HETATM 语义。模块内置真实 MessagePack fixture，覆盖两模型、蛋白质、水分子和三态 mask。输入 API 接收原始 `Array[Int]` 字节；gzip 数据需由调用方预先解压。BinaryCIF 类别仍保留完整多字符 chain ID，但现有 PDB `Chain.id` 为 `Char`，转换时使用首字符，并拒绝首字符冲突的链 ID。 +### 246. miloR 单细胞邻域差异丰度 (Bioconductor miloR) + +实现 Bioconductor `miloR` 的核心单细胞邻域差异丰度流程。`milo_build_graph` 在 cell × dimension 降维坐标上构建排除自身、稳定处理距离 ties 的精确 KNN，并将有向边对称化为无向图；`make_neighborhoods` 使用确定性无放回采样，以种子邻域的逐维 median profile 查找精炼代表细胞，去重后生成重叠邻域。`count_cells` 按样本首次出现顺序生成 neighborhood × sample 计数，另提供邻域平均表达、重叠矩阵、距离度量和 `SingleCellExperiment` reduced-dimension 构造入口。 + +`test_neighborhoods` 使用 library-size offset、method-of-moments 离散度及向全局 median 的收缩，为每个邻域拟合 log-link 负二项 GLM，并输出指定系数的 log2 fold change、Wald 统计量、p-value 和 BH FDR。`milo_graph_spatial_fdr` 实现频率加权 BH，支持 k-distance、neighbour-distance、max-distance 和 graph-overlap 四类 connectivity 权重，也可显式禁用 spatial correction。当前模块是无外部 edgeR 依赖的可移植 fixed-effect 实现，不覆盖 NB-GLMM、edgeR TMM/RLE 与 quasi-likelihood 后端，也不提供上游绘图接口。 + ## 性能优化 ### 优化策略 @@ -2906,8 +2918,8 @@ moon test # ✅ 8481 个测试全 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8481 | -| 通过数 | 8481 | +| 总测试数 | 8518 | +| 通过数 | 8518 | | 失败数 | 0 | | 通过率 | 100% | @@ -3029,6 +3041,7 @@ moon test --update | DropletUtils | `droplet_utils_test.mbt` | 6 | | scran | `scran_test.mbt` | 8 | | scrapper | `scrapper_test.mbt` | 35 | +| miloR | `milo_test.mbt` | 37 | | monocle3 | `monocle3_test.mbt` | 10 | | ShortRead | `short_read_test.mbt` | 15 | | scater | `scater_test.mbt` | 17 | @@ -3301,7 +3314,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 353 个示例程序，展示各模块的典型用法： +项目提供 354 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3392,6 +3405,7 @@ moon run cmd/bench/main.mbt | short_read_demo | ShortRead 短读序列质量控制（QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告生成） | `moon run examples/short_read_demo/main.mbt` | | scater_demo | scater 单细胞质量控制（QC指标计算、细胞/基因过滤、CPM/log-CPM标准化、HVG检测、PCA降维） | `moon run examples/scater_demo/main.mbt` | | scrapper_demo | 批次感知RNA QC、大小因子归一化、LOWESS/HVG、多因子pseudo-bulk和不可变SCE集成 | `moon run examples/scrapper_demo` | +| milo_demo | 精确KNN图、精炼重叠邻域、样本计数、NB-GLM差异丰度、graph spatial FDR和SCE接入 | `moon run examples/milo_demo` | | mast_demo | MAST 单细胞差异表达分析（Hurdle模型、离散/连续检验、BH-FDR校正、结果汇总） | `moon run examples/mast_demo/main.mbt` | | genomic_files_demo | GenomicFiles 分布式基因组文件处理（BAM/BED/VCF扫描、区间查询、归约、覆盖度计算） | `moon run examples/genomic_files_demo/main.mbt` | | diffbind_demo | DiffBind ChIP-seq差异结合分析（峰值重叠、共识峰识别、TMM归一化、负二项分布检验） | `moon run examples/diffbind_demo/main.mbt` | @@ -3585,6 +3599,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bio.PDB.cealign CE组合扩展结构比对（CA/C4'引导原子、AFP路径、CE Z-score、QCP叠合、局部优化与全原子变换） - ✅ 实现 Bioconductor scrapper 单细胞预处理（批次感知RNA QC、大小因子与log-normalization、LOWESS/HVG、多因子pseudo-bulk、不可变SCE集成） - ✅ 实现 Bio.PDB.binary_cif BinaryCIF解析（MessagePack、七类逆编码、三态mask、类别查询与PDB Structure转换） +- ✅ 实现 Bioconductor miloR 单细胞邻域差异丰度（精确KNN图、median精炼采样、邻域计数、固定效应NB-GLM、graph spatial FDR与SCE接入） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/milo_demo/main.mbt b/examples/milo_demo/main.mbt new file mode 100644 index 00000000..4ab931c0 --- /dev/null +++ b/examples/milo_demo/main.mbt @@ -0,0 +1,148 @@ +///| +fn format_ints(values : Array[Int]) -> String { + let mut output = "[" + for index in 0.. 0 { + output = output + ", " + } + output = output + values[index].to_string() + } + output + "]" +} + +///| +fn format_doubles(values : Array[Double]) -> String { + let mut output = "[" + for index in 0.. 0 { + output = output + ", " + } + output = output + values[index].to_string() + } + output + "]" +} + +///| +fn main { + println("=== Bioconductor miloR Demo ===") + let data = @src.milo_sample_data() + + println("\n1. Exact KNN graph from reduced dimensions") + let graph = @src.milo_build_graph( + data.coordinates, + cell_names=data.cell_names, + k=8, + dimensions=2, + ) catch { + _ => abort("failed to build the Milo KNN graph") + } + println(" " + graph.summary()) + println(" first directed KNN: " + format_ints(graph.knn_indices[0])) + println( + " first undirected neighbors: " + format_ints(graph.graph_neighbors[0]), + ) + + println("\n2. Refined, overlapping neighborhoods") + let neighborhoods = graph.make_neighborhoods( + proportion=0.5, + refined=true, + seed=19, + ) catch { + _ => abort("failed to sample Milo neighborhoods") + } + println( + " refined representatives: " + + neighborhoods.neighborhood_indices.length().to_string(), + ) + println( + " first neighborhood: " + format_ints(neighborhoods.neighborhoods[0]), + ) + + println("\n3. Neighborhood-by-sample counts and mean expression") + let counted = neighborhoods.count_cells(data.sample_ids) catch { + _ => abort("failed to count cells by sample") + } + let feature_x : Array[Double] = [] + let feature_y : Array[Double] = [] + for coordinate in data.coordinates { + feature_x.push(coordinate[0]) + feature_y.push(coordinate[1]) + } + let means = counted.neighborhood_expression([feature_x, feature_y]) catch { + _ => abort("failed to aggregate neighborhood expression") + } + println(" sample order: " + counted.sample_names.to_string()) + println(" first count row: " + format_ints(counted.neighborhood_counts[0])) + println(" mean x by neighborhood: " + format_doubles(means[0])) + + println("\n4. Fixed-effect negative-binomial differential abundance") + let design = @src.milo_binary_design(data.sample_conditions, reference="A") catch { + _ => abort("failed to construct the Milo design matrix") + } + let results = counted.test_neighborhoods(design.matrix, 1, cell_sizes=[ + 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, + ]) catch { + _ => abort("failed to test Milo neighborhoods") + } + println(" coefficient: " + design.coefficient_name) + let mut left_depleted = 0 + let mut right_enriched = 0 + for result in results { + let x = counted.coordinates[result.index_cell][0] + if x < 2.5 && result.log_fc < 0.0 { + left_depleted = left_depleted + 1 + } else if x >= 2.5 && result.log_fc > 0.0 { + right_enriched = right_enriched + 1 + } + println( + " nhood " + + (result.neighborhood + 1).to_string() + + ": log2FC=" + + result.log_fc.to_string() + + ", FDR=" + + result.fdr.to_string() + + ", spatial FDR=" + + result.spatial_fdr.to_string(), + ) + } + println( + " state directions: left depleted=" + + left_depleted.to_string() + + ", right enriched=" + + right_enriched.to_string(), + ) + + println("\n5. Alternative graph-aware FDR and SCE integration") + let p_values : Array[Double] = [] + for result in results { + p_values.push(result.p_value) + } + let overlap_fdr = @src.milo_graph_spatial_fdr( + counted, + p_values, + weighting=@src.milo_graph_overlap_weighting(), + ) catch { + _ => abort("failed to compute graph-overlap FDR") + } + println(" graph-overlap FDR: " + format_doubles(overlap_fdr)) + + let sce = @src.SingleCellExperiment::new( + [Array::make(data.cell_names.length(), 1.0)], + ["marker"], + data.cell_names, + ) + let with_pca = @src.sce_set_reduced_dim(sce, "PCA", data.coordinates) + let sce_graph = @src.milo_from_single_cell_experiment( + with_pca, + reduced_dim="PCA", + k=8, + ) catch { + _ => abort("failed to construct Milo from SingleCellExperiment") + } + println(" SCE-backed graph: " + sce_graph.summary()) + + println( + "\nScope: portable fixed-effect NB-GLM; GLMM, edgeR TMM/RLE/QL backends and plotting are not included.", + ) + println("\n=== Demo Complete ===") +} diff --git a/examples/milo_demo/moon.pkg b/examples/milo_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/milo_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/milo.mbt b/src/milo.mbt new file mode 100644 index 00000000..90555832 --- /dev/null +++ b/src/milo.mbt @@ -0,0 +1,1234 @@ +///| +/// Graph-neighbourhood differential abundance analysis inspired by +/// Bioconductor miloR. +/// +/// The implementation covers exact KNN graph construction, refined +/// neighbourhood sampling, neighbourhood-by-sample counting, negative +/// binomial GLM testing and graph-aware weighted FDR correction. + +///| +pub suberror MiloError { + MiloError(String) +} + +///| +pub enum MiloSpatialWeighting { + KDistance + NeighbourDistance + MaxDistance + GraphOverlap + NoSpatialWeighting +} derive(Eq, Debug) + +///| +pub struct MiloExperiment { + coordinates : Array[Array[Double]] + cell_names : Array[String] + dimensions : Int + k : Int + knn_indices : Array[Array[Int]] + knn_distances : Array[Array[Double]] + graph_neighbors : Array[Array[Int]] + neighborhood_indices : Array[Int] + neighborhoods : Array[Array[Int]] + sample_names : Array[String] + neighborhood_counts : Array[Array[Int]] +} derive(Debug) + +///| +pub struct MiloDesign { + matrix : Array[Array[Double]] + levels : Array[String] + reference : String + coefficient_name : String +} derive(Debug) + +///| +pub struct MiloDAResult { + neighborhood : Int + index_cell : Int + tested : Bool + log_fc : Double + log_cpm : Double + statistic : Double + p_value : Double + fdr : Double + spatial_fdr : Double + dispersion : Double + mean_count : Double +} derive(Debug) + +///| +pub struct MiloSampleData { + coordinates : Array[Array[Double]] + cell_names : Array[String] + sample_ids : Array[String] + sample_names : Array[String] + sample_conditions : Array[String] +} derive(Debug) + +///| +priv struct MiloFit { + log_fc : Double + log_cpm : Double + statistic : Double + p_value : Double + dispersion : Double + mean_count : Double +} + +///| +pub fn milo_k_distance_weighting() -> MiloSpatialWeighting { + KDistance +} + +///| +pub fn milo_neighbour_distance_weighting() -> MiloSpatialWeighting { + NeighbourDistance +} + +///| +pub fn milo_max_distance_weighting() -> MiloSpatialWeighting { + MaxDistance +} + +///| +pub fn milo_graph_overlap_weighting() -> MiloSpatialWeighting { + GraphOverlap +} + +///| +pub fn milo_no_spatial_weighting() -> MiloSpatialWeighting { + NoSpatialWeighting +} + +///| +fn milo_is_finite(value : Double) -> Bool { + value == value && value.abs() < 1.0e300 +} + +///| +fn milo_copy_double_matrix( + matrix : Array[Array[Double]], +) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in matrix { + output.push(row.copy()) + } + output +} + +///| +fn milo_copy_int_matrix(matrix : Array[Array[Int]]) -> Array[Array[Int]] { + let output : Array[Array[Int]] = [] + for row in matrix { + output.push(row.copy()) + } + output +} + +///| +fn milo_validate_coordinates( + coordinates : Array[Array[Double]], + dimensions : Int, +) -> (Int, Int) raise MiloError { + let cells = coordinates.length() + if cells < 2 { + raise MiloError("miloR graph construction requires at least two cells") + } + let available_dimensions = coordinates[0].length() + if available_dimensions == 0 { + raise MiloError("miloR coordinates must contain at least one dimension") + } + for row in coordinates { + if row.length() != available_dimensions { + raise MiloError("miloR coordinates must be rectangular") + } + for value in row { + if !milo_is_finite(value) { + raise MiloError("miloR coordinates must contain finite values") + } + } + } + let used_dimensions = if dimensions == 0 { + available_dimensions + } else { + dimensions + } + if used_dimensions <= 0 || used_dimensions > available_dimensions { + raise MiloError( + "miloR dimensions must be positive and no larger than the coordinate rank", + ) + } + (cells, used_dimensions) +} + +///| +fn milo_validate_names( + names : Array[String], + cells : Int, +) -> Array[String] raise MiloError { + if names.length() == 0 { + let generated : Array[String] = [] + for index in 0.. Double { + let mut total = 0.0 + for dimension in 0.. Unit { + values.sort_by(fn(left : Int, right : Int) -> Int { + if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) +} + +///| +fn milo_build_knn( + coordinates : Array[Array[Double]], + dimensions : Int, + k : Int, +) -> (Array[Array[Int]], Array[Array[Double]]) { + let cells = coordinates.length() + let indices : Array[Array[Int]] = [] + let distances : Array[Array[Double]] = [] + for cell in 0.. Int { + if left.0 < right.0 { + -1 + } else if left.0 > right.0 { + 1 + } else if left.1 < right.1 { + -1 + } else if left.1 > right.1 { + 1 + } else { + 0 + } + }) + let cell_indices : Array[Int] = [] + let cell_distances : Array[Double] = [] + for neighbor in 0.. Array[Array[Int]] { + let neighbors : Array[Array[Int]] = [] + for _ in 0.. MiloExperiment raise MiloError { + let (cells, used_dimensions) = milo_validate_coordinates( + coordinates, dimensions, + ) + if k <= 0 || k >= cells { + raise MiloError("miloR k must be positive and smaller than the cell count") + } + let validated_names = milo_validate_names(cell_names, cells) + let copied_coordinates = milo_copy_double_matrix(coordinates) + let (knn_indices, knn_distances) = milo_build_knn( + copied_coordinates, used_dimensions, k, + ) + let graph_neighbors = milo_symmetrize_knn(knn_indices) + MiloExperiment::{ + coordinates: copied_coordinates, + cell_names: validated_names, + dimensions: used_dimensions, + k, + knn_indices, + knn_distances, + graph_neighbors, + neighborhood_indices: [], + neighborhoods: [], + sample_names: [], + neighborhood_counts: [], + } +} + +///| +/// Construct a Milo graph from a `SingleCellExperiment` reduced dimension. +pub fn milo_from_single_cell_experiment( + sce : SingleCellExperiment, + reduced_dim? : String = "PCA", + k? : Int = 10, + dimensions? : Int = 0, +) -> MiloExperiment raise MiloError { + let coordinates = sce_get_reduced_dim(sce, reduced_dim) + if coordinates.length() == 0 { + raise MiloError( + "miloR reduced dimension '" + reduced_dim + "' is missing or empty", + ) + } + milo_build_graph(coordinates, cell_names=sce.col_names, k~, dimensions~) +} + +///| +fn milo_rng_next(state : Int) -> Int { + let high = state / 44488 + let low = state % 44488 + let candidate = 48271 * low - 3399 * high + if candidate > 0 { + candidate + } else { + candidate + 2147483647 + } +} + +///| +fn milo_sample_vertices(cells : Int, count : Int, seed : Int) -> Array[Int] { + let sampled : Array[Int] = [] + let used = Array::make(cells, false) + let normalized_seed = if seed == 0 { + 1 + } else { + let positive = seed.abs() % 2147483646 + positive + 1 + } + let mut state = normalized_seed + while sampled.length() < count { + state = milo_rng_next(state) + let candidate = state % cells + if !used[candidate] { + used[candidate] = true + sampled.push(candidate) + } + } + sampled +} + +///| +fn milo_refine_vertex(experiment : MiloExperiment, vertex : Int) -> Int { + let median_profile = Array::make(experiment.dimensions, 0.0) + for dimension in 0.. MiloExperiment raise MiloError { + if !milo_is_finite(proportion) || proportion <= 0.0 || proportion >= 1.0 { + raise MiloError("miloR sampling proportion must be in (0, 1)") + } + let cells = self.coordinates.length() + let requested = (proportion * cells.to_double()).to_int() + let sample_count = requested.max(1).min(cells) + let initial = milo_sample_vertices(cells, sample_count, seed) + let indices : Array[Int] = [] + for vertex in initial { + let selected = if refined { + milo_refine_vertex(self, vertex) + } else { + vertex + } + if !indices.contains(selected) { + indices.push(selected) + } + } + let neighborhoods : Array[Array[Int]] = [] + for index_cell in indices { + let members : Array[Int] = [index_cell] + for neighbor in self.graph_neighbors[index_cell] { + if !members.contains(neighbor) { + members.push(neighbor) + } + } + milo_sort_ints(members) + neighborhoods.push(members) + } + MiloExperiment::{ + coordinates: milo_copy_double_matrix(self.coordinates), + cell_names: self.cell_names.copy(), + dimensions: self.dimensions, + k: self.k, + knn_indices: milo_copy_int_matrix(self.knn_indices), + knn_distances: milo_copy_double_matrix(self.knn_distances), + graph_neighbors: milo_copy_int_matrix(self.graph_neighbors), + neighborhood_indices: indices, + neighborhoods, + sample_names: [], + neighborhood_counts: [], + } +} + +///| +/// Count cells from each experimental sample in every neighbourhood. +pub fn MiloExperiment::count_cells( + self : MiloExperiment, + sample_ids : Array[String], +) -> MiloExperiment raise MiloError { + if self.neighborhoods.length() == 0 { + raise MiloError( + "miloR neighborhoods are missing; run make_neighborhoods first", + ) + } + if sample_ids.length() != self.coordinates.length() { + raise MiloError("miloR sample IDs must match the number of cells") + } + let sample_names : Array[String] = [] + let sample_lookup : Map[String, Int] = Map([], capacity=sample_ids.length()) + for sample in sample_ids { + if sample == "" { + raise MiloError("miloR sample IDs must not be empty") + } + if !sample_lookup.contains(sample) { + sample_lookup[sample] = sample_names.length() + sample_names.push(sample) + } + } + let counts : Array[Array[Int]] = [] + for neighborhood in self.neighborhoods { + let row = Array::make(sample_names.length(), 0) + for cell in neighborhood { + let sample_index = sample_lookup[sample_ids[cell]] + row[sample_index] = row[sample_index] + 1 + } + counts.push(row) + } + MiloExperiment::{ + coordinates: milo_copy_double_matrix(self.coordinates), + cell_names: self.cell_names.copy(), + dimensions: self.dimensions, + k: self.k, + knn_indices: milo_copy_int_matrix(self.knn_indices), + knn_distances: milo_copy_double_matrix(self.knn_distances), + graph_neighbors: milo_copy_int_matrix(self.graph_neighbors), + neighborhood_indices: self.neighborhood_indices.copy(), + neighborhoods: milo_copy_int_matrix(self.neighborhoods), + sample_names, + neighborhood_counts: counts, + } +} + +///| +/// Compute feature means across the cells in each neighbourhood. +/// +/// The input and output use features in rows. Input columns are cells and +/// output columns are neighbourhoods. +pub fn MiloExperiment::neighborhood_expression( + self : MiloExperiment, + expression : Array[Array[Double]], +) -> Array[Array[Double]] raise MiloError { + if self.neighborhoods.length() == 0 { + raise MiloError("miloR neighborhoods are missing") + } + let cells = self.coordinates.length() + let output : Array[Array[Double]] = [] + for feature in expression { + if feature.length() != cells { + raise MiloError("miloR expression columns must match the number of cells") + } + let row = Array::make(self.neighborhoods.length(), 0.0) + for neighborhood_index in 0.. Array[Array[Int]] { + let count = self.neighborhoods.length() + let overlaps : Array[Array[Int]] = [] + for _ in 0.. Double { + if members.length() < 2 { + return 0.0 + } + let mut total = 0.0 + let mut pairs = 0 + for left in 0..<(members.length() - 1) { + for right in (left + 1).. Array[Double] raise MiloError { + let count = experiment.neighborhoods.length() + if count == 0 { + raise MiloError("miloR neighborhoods are missing") + } + let connectivity = Array::make(count, 1.0) + match weighting { + KDistance => + for neighborhood in 0.. + for neighborhood in 0.. + for neighborhood in 0.. maximum { + maximum = distance + } + } + connectivity[neighborhood] = maximum + } + GraphOverlap => { + let overlaps = experiment.neighborhood_overlap_matrix() + for neighborhood in 0.. () + } + connectivity +} + +///| +/// Apply miloR/cydar-style frequency-weighted BH correction. +pub fn milo_graph_spatial_fdr( + experiment : MiloExperiment, + p_values : Array[Double], + weighting? : MiloSpatialWeighting = KDistance, +) -> Array[Double] raise MiloError { + let count = experiment.neighborhoods.length() + if p_values.length() != count { + raise MiloError("miloR p-values must match the neighborhood count") + } + for p_value in p_values { + if !milo_is_finite(p_value) || p_value < 0.0 || p_value > 1.0 { + raise MiloError("miloR p-values must be finite values in [0, 1]") + } + } + if weighting is NoSpatialWeighting { + return Array::make(count, @double.not_a_number) + } + let connectivity = milo_spatial_connectivity(experiment, weighting) + let weights = Array::make(count, 1.0) + for index in 0.. 1.0e-12 { + 1.0 / value + } else { + 1.0 + } + } + let order : Array[Int] = [] + for index in 0.. Int { + if p_values[left] < p_values[right] { + -1 + } else if p_values[left] > p_values[right] { + 1 + } else if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + let mut total_weight = 0.0 + for weight in weights { + total_weight = total_weight + weight + } + let raw = Array::make(count, 1.0) + let mut cumulative_weight = 0.0 + for rank in 0..= 0 { + cumulative_minimum = cumulative_minimum.min(raw[rank]) + adjusted[order[rank]] = cumulative_minimum + rank = rank - 1 + } + adjusted +} + +///| +/// Build an intercept-plus-binary-condition design matrix. +pub fn milo_binary_design( + conditions : Array[String], + reference? : String = "", +) -> MiloDesign raise MiloError { + if conditions.length() == 0 { + raise MiloError("miloR binary design requires at least one sample") + } + let levels : Array[String] = [] + for condition in conditions { + if condition == "" { + raise MiloError("miloR condition names must not be empty") + } + if !levels.contains(condition) { + levels.push(condition) + } + } + if levels.length() != 2 { + raise MiloError("miloR binary design requires exactly two conditions") + } + let selected_reference = if reference == "" { levels[0] } else { reference } + if !levels.contains(selected_reference) { + raise MiloError("miloR reference condition is not present") + } + let comparison = if levels[0] == selected_reference { + levels[1] + } else { + levels[0] + } + let matrix : Array[Array[Double]] = [] + for condition in conditions { + matrix.push([1.0, if condition == comparison { 1.0 } else { 0.0 }]) + } + MiloDesign::{ + matrix, + levels: [selected_reference, comparison], + reference: selected_reference, + coefficient_name: comparison + "_vs_" + selected_reference, + } +} + +///| +fn milo_matrix_inverse(matrix : Array[Array[Double]]) -> Array[Array[Double]]? { + let size = matrix.length() + if size == 0 { + return None + } + let augmented : Array[Array[Double]] = [] + for row in 0.. pivot_value { + pivot_row = candidate + pivot_value = candidate_value + } + } + if pivot_value < 1.0e-12 { + return None + } + if pivot_row != pivot_column { + let temporary = augmented[pivot_column] + augmented[pivot_column] = augmented[pivot_row] + augmented[pivot_row] = temporary + } + let divisor = augmented[pivot_column][pivot_column] + for column in 0..<(2 * size) { + augmented[pivot_column][column] = augmented[pivot_column][column] / + divisor + } + for row in 0.. Array[Double] { + let output = Array::make(matrix.length(), 0.0) + for row in 0.. Array[Array[Double]] { + let parameters = design[0].length() + let information : Array[Array[Double]] = [] + for _ in 0.. Int raise MiloError { + if design.length() != samples { + raise MiloError("miloR design rows must match neighborhood count columns") + } + if samples < 2 { + raise MiloError("miloR testing requires at least two samples") + } + let parameters = design[0].length() + if parameters == 0 || contrast_column < 0 || contrast_column >= parameters { + raise MiloError("miloR contrast column is out of bounds") + } + if samples <= parameters { + raise MiloError("miloR testing requires residual degrees of freedom") + } + for row in design { + if row.length() != parameters { + raise MiloError("miloR design matrix must be rectangular") + } + for value in row { + if !milo_is_finite(value) { + raise MiloError("miloR design matrix must contain finite values") + } + } + } + if milo_matrix_inverse(milo_design_information(design)) is None { + raise MiloError("miloR design matrix must have full column rank") + } + parameters +} + +///| +fn milo_library_offsets( + counts : Array[Array[Int]], + cell_sizes : Array[Double], +) -> (Array[Double], Array[Double]) raise MiloError { + let samples = counts[0].length() + let library_sizes = Array::make(samples, 0.0) + if cell_sizes.length() > 0 { + if cell_sizes.length() != samples { + raise MiloError("miloR cell sizes must match the sample count") + } + for sample in 0.. Double { + let normalized = Array::make(counts.length(), 0.0) + for sample in 0.. MiloFit { + let samples = counts.length() + let parameters = design[0].length() + let coefficients = Array::make(parameters, 0.0) + let mut count_total = 0.0 + let mut exposure_total = 0.0 + for sample in 0.. { + let updated = milo_matrix_vector_product(inverse, score) + let mut largest_change = 0.0 + for parameter in 0.. break + } + } + let standard_error = match covariance { + Some(matrix) => + matrix[contrast_column][contrast_column].abs().sqrt().max(1.0e-12) + None => 1.0e300 + } + let statistic = coefficients[contrast_column] / standard_error + let p_value = if milo_is_finite(statistic) { + (2.0 * (1.0 - stat_normal_cdf(statistic.abs()))).max(0.0).min(1.0) + } else { + 1.0 + } + let mut total_library = 0.0 + for size in library_sizes { + total_library = total_library + size + } + let log_cpm = @math.ln(count_total / total_library * 1000000.0 + 0.5) / + @math.ln(2.0) + MiloFit::{ + log_fc: coefficients[contrast_column] / @math.ln(2.0), + log_cpm, + statistic, + p_value, + dispersion, + mean_count: count_total / samples.to_double(), + } +} + +///| +/// Fit a fixed-effect negative binomial GLM to every neighbourhood. +/// +/// The design matrix is sample by coefficient and must follow +/// `experiment.sample_names`. The coefficient selected by `contrast_column` +/// is reported as log2 fold change. Raw dispersions are method-of-moments +/// estimates shrunk towards their median before IRLS fitting. +pub fn MiloExperiment::test_neighborhoods( + self : MiloExperiment, + design : Array[Array[Double]], + contrast_column : Int, + min_mean? : Double = 0.0, + weighting? : MiloSpatialWeighting = KDistance, + cell_sizes? : Array[Double] = [], +) -> Array[MiloDAResult] raise MiloError { + if self.neighborhood_counts.length() == 0 { + raise MiloError( + "miloR neighborhood counts are missing; run count_cells first", + ) + } + if !milo_is_finite(min_mean) || min_mean < 0.0 { + raise MiloError("miloR minimum mean count must be finite and non-negative") + } + let samples = self.sample_names.length() + let parameters = milo_validate_design(design, samples, contrast_column) + ignore(parameters) + for row in self.neighborhood_counts { + if row.length() != samples { + raise MiloError("miloR neighborhood count matrix is malformed") + } + for value in row { + if value < 0 { + raise MiloError("miloR neighborhood counts must be non-negative") + } + } + } + let (offsets, scales) = milo_library_offsets( + self.neighborhood_counts, + cell_sizes, + ) + let library_sizes = Array::make(samples, 0.0) + let mut geometric_reference = 0.0 + for scale in scales { + geometric_reference = geometric_reference + @math.ln(scale) + } + geometric_reference = @math.exp(geometric_reference / samples.to_double()) + for sample in 0.. 0 { + for sample in 0..= min_mean { + tested[neighborhood] = true + let fit = milo_fit_nb_glm( + row, design, offsets, library_sizes, contrast_column, shrunk_dispersion, + ) + p_values[neighborhood] = fit.p_value + fits.push(fit) + } else { + fits.push(MiloFit::{ + log_fc: 0.0, + log_cpm: 0.0, + statistic: 0.0, + p_value: 1.0, + dispersion: shrunk_dispersion, + mean_count: mean, + }) + } + } + let fdr = stat_bh(p_values) + let spatial_fdr = milo_graph_spatial_fdr(self, p_values, weighting~) + let results : Array[MiloDAResult] = [] + for neighborhood in 0.. String { + "Milo(cells=" + + self.coordinates.length().to_string() + + ", dimensions=" + + self.dimensions.to_string() + + ", k=" + + self.k.to_string() + + ", neighborhoods=" + + self.neighborhoods.length().to_string() + + ", samples=" + + self.sample_names.length().to_string() + + ")" +} + +///| +/// Deterministic two-state, eight-sample data for examples and tests. +/// +/// Condition A is enriched around the left state and condition B around the +/// right state. Every sample contributes four cells. +pub fn milo_sample_data() -> MiloSampleData { + let coordinates : Array[Array[Double]] = [] + let cell_names : Array[String] = [] + let sample_ids : Array[String] = [] + let sample_names : Array[String] = [] + let sample_conditions : Array[String] = [] + let mut cell_number = 1 + for sample in 0..<8 { + let condition = if sample < 4 { "A" } else { "B" } + let sample_name = condition + (sample % 4 + 1).to_string() + sample_names.push(sample_name) + sample_conditions.push(condition) + let left_count = if condition == "A" { 3 } else { 1 } + let right_count = 4 - left_count + for local in 0.. Unit { + if (actual - expected).abs() > tolerance { + abort("miloR values differ beyond tolerance") + } +} + +///| +fn milo_test_small_graph() -> @src.MiloExperiment { + @src.milo_build_graph( + [[0.0], [1.0], [3.0], [10.0]], + cell_names=["A", "B", "C", "D"], + k=1, + ) catch { + _ => abort("valid small Milo graph should build") + } +} + +///| +fn milo_test_counted() -> (@src.MiloExperiment, @src.MiloDesign) { + let data = @src.milo_sample_data() + let graph = @src.milo_build_graph( + data.coordinates, + cell_names=data.cell_names, + k=8, + dimensions=2, + ) catch { + _ => abort("sample Milo graph should build") + } + let neighborhoods = graph.make_neighborhoods(proportion=0.5, seed=19) catch { + _ => abort("sample Milo neighborhoods should build") + } + let counted = neighborhoods.count_cells(data.sample_ids) catch { + _ => abort("sample Milo cells should count") + } + let design = @src.milo_binary_design(data.sample_conditions, reference="A") catch { + _ => abort("sample Milo design should build") + } + (counted, design) +} + +///| +test "miloR: sample data contains balanced replicated samples" { + let data = @src.milo_sample_data() + assert_eq(data.coordinates.length(), 32) + assert_eq(data.cell_names.length(), 32) + assert_eq(data.sample_ids.length(), 32) + assert_eq(data.sample_names, ["A1", "A2", "A3", "A4", "B1", "B2", "B3", "B4"]) + assert_eq(data.sample_conditions, ["A", "A", "A", "A", "B", "B", "B", "B"]) +} + +///| +test "miloR: builds exact KNN graph and generates cell names" { + let graph = @src.milo_build_graph([[0.0], [1.0], [3.0]], k=1) catch { + _ => abort("valid graph should build") + } + assert_eq(graph.cell_names, ["Cell1", "Cell2", "Cell3"]) + assert_eq(graph.dimensions, 1) + assert_eq(graph.k, 1) + assert_eq(graph.knn_indices, [[1], [0], [1]]) +} + +///| +test "miloR: exact KNN excludes each query cell" { + let graph = milo_test_small_graph() + for cell in 0.. abort("valid graph should build") + } + assert_eq(graph.knn_indices[0], [1, 2, 3]) + assert_eq(graph.knn_distances[0], [1.0, 3.0, 10.0]) +} + +///| +test "miloR: KNN ties are resolved by cell index" { + let graph = @src.milo_build_graph([[-1.0], [0.0], [1.0]], k=2) catch { + _ => abort("valid tied graph should build") + } + assert_eq(graph.knn_indices[1], [0, 2]) +} + +///| +test "miloR: directed KNN edges are symmetrized" { + let graph = milo_test_small_graph() + assert_eq(graph.graph_neighbors, [[1], [0, 2], [1, 3], [2]]) +} + +///| +test "miloR: selected dimensions control graph distances" { + let graph = @src.milo_build_graph( + [[0.0, 100.0], [1.0, 0.0], [2.0, 100.0]], + k=1, + dimensions=1, + ) catch { + _ => abort("valid dimension subset should build") + } + assert_eq(graph.knn_indices[0], [1]) + assert_eq(graph.knn_indices[2], [1]) +} + +///| +test "miloR: graph construction copies coordinate input" { + let coordinates = [[0.0], [1.0], [2.0]] + let graph = @src.milo_build_graph(coordinates, k=1) catch { + _ => abort("valid graph should build") + } + coordinates[0][0] = 99.0 + assert_eq(graph.coordinates[0][0], 0.0) +} + +///| +test "miloR: graph rejects malformed coordinates" { + let too_small = try { + ignore(@src.milo_build_graph([[0.0]], k=1)) + false + } catch { + MiloError(_) => true + } + let ragged = try { + ignore(@src.milo_build_graph([[0.0], [1.0, 2.0]], k=1)) + false + } catch { + MiloError(_) => true + } + let non_finite = try { + ignore(@src.milo_build_graph([[0.0], [@double.not_a_number]], k=1)) + false + } catch { + MiloError(_) => true + } + assert_true(too_small) + assert_true(ragged) + assert_true(non_finite) +} + +///| +test "miloR: graph validates k and dimensions" { + let bad_k = try { + ignore(@src.milo_build_graph([[0.0], [1.0]], k=2)) + false + } catch { + MiloError(_) => true + } + let bad_dimensions = try { + ignore(@src.milo_build_graph([[0.0], [1.0]], k=1, dimensions=2)) + false + } catch { + MiloError(_) => true + } + assert_true(bad_k) + assert_true(bad_dimensions) +} + +///| +test "miloR: graph validates cell names" { + let wrong_length = try { + ignore(@src.milo_build_graph([[0.0], [1.0], [2.0]], cell_names=["A"], k=1)) + false + } catch { + MiloError(_) => true + } + let duplicates = try { + ignore( + @src.milo_build_graph( + [[0.0], [1.0], [2.0]], + cell_names=["A", "A", "B"], + k=1, + ), + ) + false + } catch { + MiloError(_) => true + } + assert_true(wrong_length) + assert_true(duplicates) +} + +///| +test "miloR: unrefined sampling is deterministic" { + let graph = @src.milo_build_graph( + [[0.0], [1.0], [2.0], [3.0], [4.0], [5.0]], + k=2, + ) catch { + _ => abort("valid graph should build") + } + let first = graph.make_neighborhoods(proportion=0.5, refined=false, seed=7) catch { + _ => abort("valid neighborhoods should build") + } + let second = graph.make_neighborhoods(proportion=0.5, refined=false, seed=7) catch { + _ => abort("valid neighborhoods should build") + } + assert_eq(first.neighborhood_indices, second.neighborhood_indices) + assert_eq(first.neighborhood_indices.length(), 3) +} + +///| +test "miloR: refined sampling collapses duplicate representatives" { + let data = @src.milo_sample_data() + let graph = @src.milo_build_graph(data.coordinates, k=4) catch { + _ => abort("valid graph should build") + } + let refined = graph.make_neighborhoods(proportion=0.5, refined=true, seed=11) catch { + _ => abort("valid refined neighborhoods should build") + } + assert_true(refined.neighborhoods.length() > 0) + assert_true(refined.neighborhoods.length() <= 16) + for index in refined.neighborhood_indices { + assert_true(index >= 0 && index < data.coordinates.length()) + } +} + +///| +test "miloR: neighborhoods include index and undirected graph neighbors" { + let graph = milo_test_small_graph() + let experiment = graph.make_neighborhoods( + proportion=0.75, + refined=false, + seed=3, + ) catch { + _ => abort("valid neighborhoods should build") + } + for neighborhood in 0.. true + } + let one = try { + ignore(graph.make_neighborhoods(proportion=1.0)) + false + } catch { + MiloError(_) => true + } + assert_true(zero) + assert_true(one) +} + +///| +test "miloR: counts neighborhood cells by first-seen sample order" { + let graph = milo_test_small_graph() + let neighborhoods = graph.make_neighborhoods( + proportion=0.75, + refined=false, + seed=5, + ) catch { + _ => abort("valid neighborhoods should build") + } + let counted = neighborhoods.count_cells(["S2", "S1", "S1", "S2"]) catch { + _ => abort("valid sample IDs should count") + } + assert_eq(counted.sample_names, ["S2", "S1"]) + for index in 0.. abort("valid neighborhoods should build") + } + let counted = neighborhoods.count_cells(["S1", "S1", "S2", "S2"]) catch { + _ => abort("valid sample IDs should count") + } + assert_eq(neighborhoods.sample_names.length(), 0) + assert_eq(counted.sample_names, ["S1", "S2"]) +} + +///| +test "miloR: counting validates workflow and sample IDs" { + let graph = milo_test_small_graph() + let before_neighborhoods = try { + ignore(graph.count_cells(["S1", "S1", "S2", "S2"])) + false + } catch { + MiloError(_) => true + } + let neighborhoods = graph.make_neighborhoods(proportion=0.5, refined=false) catch { + _ => abort("valid neighborhoods should build") + } + let wrong_length = try { + ignore(neighborhoods.count_cells(["S1"])) + false + } catch { + MiloError(_) => true + } + let empty = try { + ignore(neighborhoods.count_cells(["S1", "", "S2", "S2"])) + false + } catch { + MiloError(_) => true + } + assert_true(before_neighborhoods) + assert_true(wrong_length) + assert_true(empty) +} + +///| +test "miloR: computes mean feature expression per neighborhood" { + let graph = milo_test_small_graph() + let neighborhoods = graph.make_neighborhoods( + proportion=0.5, + refined=false, + seed=2, + ) catch { + _ => abort("valid neighborhoods should build") + } + let expression = neighborhoods.neighborhood_expression([[0.0, 2.0, 4.0, 8.0]]) catch { + _ => abort("valid expression should aggregate") + } + assert_eq(expression.length(), 1) + assert_eq(expression[0].length(), neighborhoods.neighborhoods.length()) + for index in 0.. abort("valid neighborhoods should build") + } + let wrong_length = try { + ignore(neighborhoods.neighborhood_expression([[1.0]])) + false + } catch { + MiloError(_) => true + } + let non_finite = try { + ignore( + neighborhoods.neighborhood_expression([ + [@double.not_a_number, 1.0, 2.0, 3.0], + ]), + ) + false + } catch { + MiloError(_) => true + } + assert_true(wrong_length) + assert_true(non_finite) +} + +///| +test "miloR: neighborhood overlap matrix is symmetric" { + let (experiment, _) = milo_test_counted() + let overlaps = experiment.neighborhood_overlap_matrix() + assert_eq(overlaps.length(), experiment.neighborhoods.length()) + for left in 0.. abort("valid binary design should build") + } + assert_eq(design.levels, ["control", "treated"]) + assert_eq(design.reference, "control") + assert_eq(design.coefficient_name, "treated_vs_control") + assert_eq(design.matrix, [[1.0, 1.0], [1.0, 0.0], [1.0, 1.0], [1.0, 0.0]]) +} + +///| +test "miloR: binary design validates conditions and reference" { + let one_level = try { + ignore(@src.milo_binary_design(["A", "A"])) + false + } catch { + MiloError(_) => true + } + let three_levels = try { + ignore(@src.milo_binary_design(["A", "B", "C"])) + false + } catch { + MiloError(_) => true + } + let absent_reference = try { + ignore(@src.milo_binary_design(["A", "B"], reference="C")) + false + } catch { + MiloError(_) => true + } + assert_true(one_level) + assert_true(three_levels) + assert_true(absent_reference) +} + +///| +test "miloR: graph spatial FDR supports k-distance weighting" { + let (experiment, _) = milo_test_counted() + let p_values = Array::make(experiment.neighborhoods.length(), 0.05) + let adjusted = @src.milo_graph_spatial_fdr(experiment, p_values) catch { + _ => abort("valid spatial FDR should compute") + } + assert_eq(adjusted.length(), p_values.length()) + for value in adjusted { + assert_true(value >= 0.0 && value <= 1.0) + } +} + +///| +test "miloR: spatial FDR supports all graph weighting schemes" { + let (experiment, _) = milo_test_counted() + let p_values : Array[Double] = [] + for index in 0.. abort("neighbor-distance FDR should compute") + } + let maximum = @src.milo_graph_spatial_fdr( + experiment, + p_values, + weighting=@src.milo_max_distance_weighting(), + ) catch { + _ => abort("maximum-distance FDR should compute") + } + let overlap = @src.milo_graph_spatial_fdr( + experiment, + p_values, + weighting=@src.milo_graph_overlap_weighting(), + ) catch { + _ => abort("graph-overlap FDR should compute") + } + assert_eq(neighbor.length(), p_values.length()) + assert_eq(maximum.length(), p_values.length()) + assert_eq(overlap.length(), p_values.length()) +} + +///| +test "miloR: disabled spatial weighting returns missing values" { + let (experiment, _) = milo_test_counted() + let adjusted = @src.milo_graph_spatial_fdr( + experiment, + Array::make(experiment.neighborhoods.length(), 0.5), + weighting=@src.milo_no_spatial_weighting(), + ) catch { + _ => abort("disabled spatial FDR should return missing values") + } + for value in adjusted { + assert_true(value.is_nan()) + } +} + +///| +test "miloR: spatial FDR validates p-values" { + let (experiment, _) = milo_test_counted() + let wrong_length = try { + ignore(@src.milo_graph_spatial_fdr(experiment, [])) + false + } catch { + MiloError(_) => true + } + let invalid = Array::make(experiment.neighborhoods.length(), 0.5) + invalid[0] = 1.5 + let out_of_range = try { + ignore(@src.milo_graph_spatial_fdr(experiment, invalid)) + false + } catch { + MiloError(_) => true + } + assert_true(wrong_length) + assert_true(out_of_range) +} + +///| +test "miloR: complete sample pipeline reports expected dimensions" { + let (experiment, _) = milo_test_counted() + assert_eq(experiment.coordinates.length(), 32) + assert_eq(experiment.sample_names.length(), 8) + assert_true(experiment.neighborhoods.length() > 1) + assert_true(experiment.summary().contains("cells=32")) + assert_true(experiment.summary().contains("samples=8")) +} + +///| +test "miloR: NB GLM returns one finite result per neighborhood" { + let (experiment, design) = milo_test_counted() + let results = experiment.test_neighborhoods(design.matrix, 1) catch { + _ => abort("valid Milo DA test should fit") + } + assert_eq(results.length(), experiment.neighborhoods.length()) + for result in results { + assert_true(result.tested) + assert_true(!result.log_fc.is_nan()) + assert_true(!result.statistic.is_nan()) + assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) + assert_true(result.fdr >= 0.0 && result.fdr <= 1.0) + assert_true(result.spatial_fdr >= 0.0 && result.spatial_fdr <= 1.0) + assert_true(result.dispersion > 0.0) + } +} + +///| +test "miloR: DA direction follows left and right state enrichment" { + let (experiment, design) = milo_test_counted() + let results = experiment.test_neighborhoods(design.matrix, 1, cell_sizes=[ + 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, + ]) catch { + _ => abort("valid Milo DA test should fit") + } + let mut left = 0 + let mut right = 0 + for result in results { + let x = experiment.coordinates[result.index_cell][0] + let counts = experiment.neighborhood_counts[result.neighborhood] + let condition_a = counts[0] + counts[1] + counts[2] + counts[3] + let condition_b = counts[4] + counts[5] + counts[6] + counts[7] + if x < 2.5 { + assert_true(condition_a >= condition_b) + if condition_a > condition_b { + assert_true(result.log_fc < 0.0) + left = left + 1 + } + } else { + assert_true(condition_b >= condition_a) + if condition_b > condition_a { + assert_true(result.log_fc > 0.0) + right = right + 1 + } + } + } + assert_true(left > 0) + assert_true(right > 0) +} + +///| +test "miloR: mean threshold marks low-count neighborhoods untested" { + let (experiment, design) = milo_test_counted() + let results = experiment.test_neighborhoods(design.matrix, 1, min_mean=100.0) catch { + _ => abort("valid threshold should apply") + } + for result in results { + assert_false(result.tested) + assert_eq(result.p_value, 1.0) + assert_eq(result.fdr, 1.0) + } +} + +///| +test "miloR: DA supports explicit cell-size normalization" { + let (experiment, design) = milo_test_counted() + let results = experiment.test_neighborhoods(design.matrix, 1, cell_sizes=[ + 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, 4.0, + ]) catch { + _ => abort("valid cell sizes should normalize") + } + assert_eq(results.length(), experiment.neighborhoods.length()) +} + +///| +test "miloR: DA supports disabling spatial correction" { + let (experiment, design) = milo_test_counted() + let results = experiment.test_neighborhoods( + design.matrix, + 1, + weighting=@src.milo_no_spatial_weighting(), + ) catch { + _ => abort("valid DA test should fit without spatial correction") + } + for result in results { + assert_true(result.spatial_fdr.is_nan()) + } +} + +///| +test "miloR: DA validates design dimensions rank and contrast" { + let (experiment, _) = milo_test_counted() + let wrong_rows = try { + ignore(experiment.test_neighborhoods([[1.0, 0.0]], 1)) + false + } catch { + MiloError(_) => true + } + let singular : Array[Array[Double]] = [] + for _ in 0..<8 { + singular.push([1.0, 1.0]) + } + let bad_rank = try { + ignore(experiment.test_neighborhoods(singular, 1)) + false + } catch { + MiloError(_) => true + } + let design = @src.milo_binary_design(["A", "A", "A", "A", "B", "B", "B", "B"]) catch { + _ => abort("valid design should build") + } + let bad_contrast = try { + ignore(experiment.test_neighborhoods(design.matrix, 2)) + false + } catch { + MiloError(_) => true + } + assert_true(wrong_rows) + assert_true(bad_rank) + assert_true(bad_contrast) +} + +///| +test "miloR: DA validates minimum mean and cell sizes" { + let (experiment, design) = milo_test_counted() + let bad_mean = try { + ignore(experiment.test_neighborhoods(design.matrix, 1, min_mean=-1.0)) + false + } catch { + MiloError(_) => true + } + let bad_sizes = try { + ignore(experiment.test_neighborhoods(design.matrix, 1, cell_sizes=[1.0])) + false + } catch { + MiloError(_) => true + } + assert_true(bad_mean) + assert_true(bad_sizes) +} + +///| +test "miloR: SCE constructor uses named reduced dimensions and cells" { + let sce = @src.SingleCellExperiment::new([[1.0, 2.0, 3.0, 4.0]], ["Gene1"], [ + "A", "B", "C", "D", + ]) + let with_pca = @src.sce_set_reduced_dim(sce, "PCA", [ + [0.0], + [1.0], + [2.0], + [3.0], + ]) + let graph = @src.milo_from_single_cell_experiment(with_pca, k=1) catch { + _ => abort("valid SCE reduced dimensions should build a graph") + } + assert_eq(graph.cell_names, ["A", "B", "C", "D"]) + assert_eq(graph.knn_indices.length(), 4) +} + +///| +test "miloR: SCE constructor rejects missing reduced dimensions" { + let sce = @src.SingleCellExperiment::new([[1.0, 2.0]], ["Gene1"], ["A", "B"]) + let missing = try { + ignore(@src.milo_from_single_cell_experiment(sce, k=1)) + false + } catch { + MiloError(_) => true + } + assert_true(missing) +} From bfc10dc08e5020dc232b0a126c5fd13985158d84 Mon Sep 17 00:00:00 2001 From: eda Date: Tue, 4 Aug 2026 21:12:59 +0800 Subject: [PATCH 12/41] #28 /8555 feat(infernal): Infernal cmscan/cmsearch Bio.SearchIO.InfernalIO & nfernal tabular & verbose SearchIO --- README.md | 25 +- examples/infernal_io_demo/main.mbt | 101 +++ examples/infernal_io_demo/moon.pkg | 5 + src/genomic_ranges.mbt | 2 +- src/infernal_io.mbt | 1360 ++++++++++++++++++++++++++++ test/moonbit/infernal_io_test.mbt | 473 ++++++++++ 6 files changed, 1960 insertions(+), 6 deletions(-) create mode 100644 examples/infernal_io_demo/main.mbt create mode 100644 examples/infernal_io_demo/moon.pkg create mode 100644 src/infernal_io.mbt create mode 100644 test/moonbit/infernal_io_test.mbt diff --git a/README.md b/README.md index 3e7f74bb..d47bab19 100644 --- a/README.md +++ b/README.md @@ -30,7 +30,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **序列 I/O** | Biopython `Bio.SeqIO` | FASTA/FASTQ/GenBank 解析与写入 | ✅ | | **序列比对** | Biopython / scikit-bio | Needleman-Wunsch、Smith-Waterman、多序列比对、替换矩阵(BLOSUM/PAM) | ✅ | | **BLAST解析** | Biopython `Bio.Blast` | BLAST结果解析、tabular/xml格式、HSP过滤、最佳匹配 | ✅ | -| **SearchIO** | Biopython `Bio.SearchIO` | 统一搜索结果模型、HMMER3解析、BLAT PSL解析、BLAST转换 | ✅ | +| **SearchIO** | Biopython `Bio.SearchIO` | 统一搜索结果模型、HMMER3/Infernal解析、BLAT PSL解析、BLAST转换 | ✅ | | **HH-suite HHR** | Biopython `Bio.Align.hhr` | HHsearch/HHblits HHR解析、profile-profile比对、命中筛选、坐标映射、序列化往返 | ✅ | | **系统发育树** | Biopython `Bio.Phylo` | 树结构、Newick 解析、距离计算、可视化 | ✅ | | **PDB 结构** | Biopython `Bio.PDB` | 原子/残基/链解析、结构操作 | ✅ | @@ -155,6 +155,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | Bio.SearchIO.ExonerateIO | Exonerate比对输出解析: vulgar格式解析(比对块三元组)、cigar格式解析、格式自动检测、分数过滤、内含子统计、vulgar/cigar字符串重建 | | ✅ | Bio.PDB.mmcifio | mmCIF文件写入: Structure对象序列化(data block/header/atom_site loop)、20列原子坐标格式化、HETATM支持、值转义、round-trip验证 | | ✅ | Bio.SearchIO.InterproscanIO | InterProScan输出解析: TSV 14列格式解析(蛋白质ID/分析数据库/签名/位置/分数/IPR/GO)、按数据库/蛋白质过滤、GO条目提取、按蛋白质分组 | +| ✅ | Bio.SearchIO.InfernalIO | Infernal cmscan/cmsearch解析: tabular格式1/2/3自动检测、non-verbose文本与--noali、CM/HMM-only、Query/Hit/HSP/Fragment层次、正负链坐标、local-end多片段、过滤与SearchIO转换 | | ✅ | Bio.PDB.SASA | 溶剂可及表面积计算: Shrake-Rupley滚动球算法(Fibonacci球面采样)、范德华半径查表、逐原子/残基/链SASA、骨架/侧链拆分 | | ✅ | Bio.SeqIO.NibIO | nib 2-bit二进制序列格式: DNA 2-bit编码(T=0/C=1/A=2/G=3)、4碱基/字节打包、hex I/O、子序列提取、反向互补、GC含量、压缩比 | | ✅ | ChIPseeker | ChIP-seq峰注释: 峰-TSS距离计算、基因组特征分配(Promoter/5'UTR/3'UTR/Exon/Intron/Downstream/Distal Intergenic)、最近基因查找、注释摘要 | @@ -741,6 +742,7 @@ IvanAXu/BioSeqs/ │ ├── transfac.mbt # Bio.Motifs.Transfac TRANSFAC转录因子结合谱解析 (PFM频率矩阵、AC/ID/DE/BF/CC字段、参考文献、共识序列) │ ├── hmmer_io.mbt # Bio.SearchIO.HmmerIO HMMER3输出解析 (domtblout域表、文本格式、Query/Hit/HSP/Domain聚合) │ ├── fasta_search_io.mbt # Bio.SearchIO.FastaIO FASTA搜索输出解析 (-m8紧凑表格、-m9带注释头、元数据提取) +│ ├── infernal_io.mbt # Bio.SearchIO.InfernalIO cmscan/cmsearch解析 (tabular 1/2/3、non-verbose文本、local-end片段) │ ├── hhr.mbt # Bio.Align.hhr HH-suite HHR解析、命中查询、坐标映射与序列化 │ ├── gene_pop.mbt # Bio.PopGen.GenePop GenePop群体遗传学 (基因型解析、等位基因频率、杂合度、序列化往返) │ ├── stage_r.mbt # Bioconductor stageR 两阶段假设检验 (筛选+确认、Simes聚合、BH-FDR、Holm步降、OFDR控制) @@ -1078,6 +1080,7 @@ IvanAXu/BioSeqs/ │ ├── transfac_demo/ # TRANSFAC转录因子结合谱解析示例 (PFM矩阵、共识序列、频率计算、序列化、参考文献) │ ├── hmmer_io_demo/ # HMMER3输出解析示例 (domtblout域表、文本格式、Query/Hit/HSP聚合、多域比对) │ ├── fasta_search_io_demo/ # FASTA搜索输出解析示例 (-m8表格、-m9注释头、元数据、Query/Hit/HSP聚合) +│ ├── infernal_io_demo/ # Infernal cmscan/cmsearch解析示例 (tabular 3、文本local-end、过滤、SearchIO转换) │ ├── hhr_demo/ # HH-suite HHR解析、命中筛选、坐标映射与序列化往返示例 │ ├── gene_pop_demo/ # GenePop群体遗传学示例 (基因型解析、等位基因频率、杂合度统计、序列化往返) │ ├── stage_r_demo/ # stageR两阶段检验示例 (筛选+确认、Simes聚合、BH-FDR、Holm步降、OFDR控制) @@ -1416,6 +1419,7 @@ IvanAXu/BioSeqs/ │ │ ├── transfac_full_test.mbt │ │ ├── hmmer_io_test.mbt │ │ ├── fasta_search_io_test.mbt +│ │ ├── infernal_io_test.mbt │ │ ├── hhr_test.mbt │ │ ├── gene_pop_test.mbt │ │ ├── stage_r_test.mbt @@ -1451,7 +1455,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8481 个测试全部通过 +moon test # ✅ 8555 个测试全部通过 ``` ### 模块对照表 @@ -1632,6 +1636,7 @@ moon test # ✅ 8481 个测试全 | `transfac.mbt` | BioPython `Bio.Motifs.Transfac` | TRANSFAC转录因子结合谱解析（两字母字段码AC/ID/DE/NA/OS/BF/CC/P0/XX//、位置频率矩阵PFM、参考文献RN/RA/RT/RL/RX、共识序列、频率计算、字母索引、序列化往返） | | `hmmer_io.mbt` | BioPython `Bio.SearchIO.HmmerIO` | HMMER3输出解析（domtblout域表23列格式、人类可读文本格式、Query/Hit/HSP/HSPFragment聚合、多域比对、i-Evalue/c-Evalue、bitscore、条件E值、Query/Domain/Alignment段标记） | | `fasta_search_io.mbt` | BioPython `Bio.SearchIO.FastaIO` | FASTA搜索输出解析（-m8紧凑表格12列、-m9带#注释头、程序/版本/数据库元数据提取、Query/Hit/HSP聚合、正负链判定、E-value/bitscore） | +| `infernal_io.mbt` | BioPython `Bio.SearchIO.InfernalIO` | Infernal cmscan/cmsearch解析（tabular格式1/2/3自动检测、non-verbose文本与--noali、CM/HMM-only、local-end多片段、正负链坐标、过滤与SearchIO转换） | | `gene_pop.mbt` | BioPython `Bio.PopGen.GenePop` | GenePop群体遗传学（基因型diploid/haploid解析、2/3位等位基因数字检测、Pop人口分隔、Locus名自动生成/#Loci注释、等位基因频率、观察/期望杂合度、序列化往返） | | `stage_r.mbt` | Bioconductor stageR | 两阶段假设检验（筛选阶段BH-FDR、确认阶段Holm步降、Simes聚合、OFDR控制、Dte/Dtu方法、确认p值G/R重缩放） | | `enriched_heatmap.mbt` | Bioconductor EnrichedHeatmap | 基因组信号归一化（目标区域窗口化、四种均值模式absolute/weighted/w0/coverage、行平滑、百分位裁剪、负链窗口反转） | @@ -1801,6 +1806,7 @@ moon test # ✅ 8481 个测试全 | `transfac.mbt` | Biopython `Bio.Motifs.Transfac` | TRANSFAC转录因子结合谱解析（两字母字段码AC/ID/DE/NA/OS/BF/CC/P0/XX//、位置频率矩阵PFM、参考文献RN/RA/RT/RL/RX、共识序列、频率计算、字母索引、序列化往返） | | `hmmer_io.mbt` | Biopython `Bio.SearchIO.HmmerIO` | HMMER3输出解析（domtblout域表23列格式、人类可读文本格式、Query/Hit/HSP/HSPFragment聚合、多域比对、i-Evalue/c-Evalue、bitscore、条件E值、Query/Domain/Alignment段标记） | | `fasta_search_io.mbt` | Biopython `Bio.SearchIO.FastaIO` | FASTA搜索输出解析（-m8紧凑表格12列、-m9带#注释头、程序/版本/数据库元数据提取、Query/Hit/HSP聚合、正负链判定、E-value/bitscore） | +| `infernal_io.mbt` | Biopython `Bio.SearchIO.InfernalIO` | Infernal cmscan/cmsearch解析（tabular格式1/2/3自动检测、non-verbose文本与--noali、CM/HMM-only、local-end多片段、正负链坐标、过滤与SearchIO转换） | | `gene_pop.mbt` | Biopython `Bio.PopGen.GenePop` | GenePop群体遗传学（基因型diploid/haploid解析、2/3位等位基因数字检测、Pop人口分隔、Locus名自动生成/#Loci注释、等位基因频率、观察/期望杂合度、序列化往返） | | `stage_r.mbt` | Bioconductor stageR | 两阶段假设检验（StageRMethod/StageRConfig/StageRResult数据结构、筛选阶段BH-FDR校正、确认阶段Holm步降程序、Simes聚合、OFDR控制、Dte/Dtu调整向量、确认p值G/R重缩放、显著性基因/假设提取） | | `enriched_heatmap.mbt` | Bioconductor EnrichedHeatmap | 基因组信号归一化（GenomicSignal/TargetRegion/MeanMode/EnrichedHeatmapConfig/NormalizedMatrix数据结构、目标区域窗口化、四种均值模式absolute/weighted/w0/coverage、行平滑、百分位裁剪、负链窗口反转、富集谱计算） | @@ -2817,6 +2823,12 @@ moon test # ✅ 8481 个测试全 `test_neighborhoods` 使用 library-size offset、method-of-moments 离散度及向全局 median 的收缩，为每个邻域拟合 log-link 负二项 GLM，并输出指定系数的 log2 fold change、Wald 统计量、p-value 和 BH FDR。`milo_graph_spatial_fdr` 实现频率加权 BH，支持 k-distance、neighbour-distance、max-distance 和 graph-overlap 四类 connectivity 权重，也可显式禁用 spatial correction。当前模块是无外部 edgeR 依赖的可移植 fixed-effect 实现，不覆盖 NB-GLMM、edgeR TMM/RLE 与 quasi-likelihood 后端，也不提供上游绘图接口。 +### 247. Infernal cmscan/cmsearch 输出解析 (Bio.SearchIO.InfernalIO) + +实现 Biopython 1.86 `Bio.SearchIO.InfernalIO` 的 Infernal `cmscan`/`cmsearch` 结果读取。`infernal_parse_tabular` 自动识别或显式选择 tabular 格式 1、2、3，保留 clan、模型/序列长度、截断、pipeline pass、GC、bias、bit score、E-value、included、overlap 及格式 2 的重叠索引和比例。所有序列坐标从 Infernal 的 1-based inclusive 规范化为 0-based half-open，并统一处理正负链。结果采用 `InfernalQueryResult -> InfernalHit -> InfernalHSP -> InfernalFragment` 类型层次，按输入顺序聚合重复 query 和 hit。 + +`infernal_parse_text` 支持 non-verbose plain text、`--noali`、CM pipeline 和 HMM-only pipeline，解析 query metadata、hit score、模型/序列比对及 CS、NC、similarity、PP 注释。模型和序列中的 `*[NN]*` local-end 标记会同步拆分为多个 fragment，并记录两侧 omission 长度和链方向坐标。查询 API 提供 best-HSP、E-value/included 过滤、摘要及到通用 `QueryResult` 的转换。当前范围不包括 verbose text、writer 或完整 Infernal 命令行封装。 + ## 性能优化 ### 优化策略 @@ -2918,8 +2930,8 @@ moon test # ✅ 8481 个测试全 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8518 | -| 通过数 | 8518 | +| 总测试数 | 8555 | +| 通过数 | 8555 | | 失败数 | 0 | | 通过率 | 100% | @@ -3219,6 +3231,7 @@ moon test --update | Bio.Motifs.Transfac | `transfac_full_test.mbt` | 18 | | Bio.SearchIO.HmmerIO | `hmmer_io_test.mbt` | 19 | | Bio.SearchIO.FastaIO | `fasta_search_io_test.mbt` | 19 | +| Bio.SearchIO.InfernalIO | `infernal_io_test.mbt` | 37 | | Bio.PopGen.GenePop | `gene_pop_test.mbt` | 34 | | Bioconductor stageR | `stage_r_test.mbt` | 25 | | Bioconductor EnrichedHeatmap | `enriched_heatmap_test.mbt` | 20 | @@ -3314,7 +3327,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 354 个示例程序，展示各模块的典型用法： +项目提供 355 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3498,6 +3511,7 @@ moon run cmd/bench/main.mbt | transfac_demo | TRANSFAC转录因子结合谱解析（PFM矩阵、共识序列、频率计算、序列化、参考文献） | `moon run examples/transfac_demo/main.mbt` | | hmmer_io_demo | HMMER3输出解析（domtblout域表、文本格式、Query/Hit/HSP聚合、多域比对） | `moon run examples/hmmer_io_demo/main.mbt` | | fasta_search_io_demo | FASTA搜索输出解析（-m8表格、-m9注释头、元数据、Query/Hit/HSP聚合） | `moon run examples/fasta_search_io_demo/main.mbt` | +| infernal_io_demo | Infernal cmscan/cmsearch解析（tabular 3、non-verbose文本、local-end片段、过滤与SearchIO转换） | `moon run examples/infernal_io_demo` | | gene_pop_demo | GenePop群体遗传学（基因型解析、等位基因频率、杂合度统计、序列化往返） | `moon run examples/gene_pop_demo/main.mbt` | | stage_r_demo | stageR两阶段假设检验（筛选+确认、Simes聚合、BH-FDR、Holm步降、OFDR控制） | `moon run examples/stage_r_demo/main.mbt` | | enriched_heatmap_demo | EnrichedHeatmap富集热图（信号归一化、四种均值模式、行平滑、链方向处理） | `moon run examples/enriched_heatmap_demo/main.mbt` | @@ -3600,6 +3614,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bioconductor scrapper 单细胞预处理（批次感知RNA QC、大小因子与log-normalization、LOWESS/HVG、多因子pseudo-bulk、不可变SCE集成） - ✅ 实现 Bio.PDB.binary_cif BinaryCIF解析（MessagePack、七类逆编码、三态mask、类别查询与PDB Structure转换） - ✅ 实现 Bioconductor miloR 单细胞邻域差异丰度（精确KNN图、median精炼采样、邻域计数、固定效应NB-GLM、graph spatial FDR与SCE接入） +- ✅ 实现 Bio.SearchIO.InfernalIO Infernal cmscan/cmsearch输出解析（tabular 1/2/3、non-verbose文本、--noali、CM/HMM-only、local-end多片段与SearchIO转换） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/infernal_io_demo/main.mbt b/examples/infernal_io_demo/main.mbt new file mode 100644 index 00000000..6914b337 --- /dev/null +++ b/examples/infernal_io_demo/main.mbt @@ -0,0 +1,101 @@ +///| +fn main { + println("=== Biopython Bio.SearchIO.InfernalIO Demo ===") + + println("\n1. Auto-detect and parse Infernal tabular output") + let tabular = @src.infernal_tabular_sample() + let format = @src.infernal_tabular_format(tabular) catch { + _ => abort("failed to detect Infernal tabular format") + } + let format_name = match format { + Format1 => "1" + Format2 => "2" + Format3 => "3" + } + println(" detected format: " + format_name) + let queries = @src.infernal_parse_tabular(tabular) catch { + _ => abort("failed to parse Infernal tabular sample") + } + for query in queries { + println(" " + query.summary()) + for hit in query.hits { + println( + " hit=" + + hit.id + + ", description=" + + hit.description + + ", HSPs=" + + hit.hsps.length().to_string(), + ) + } + } + + println("\n2. Reverse-strand normalized coordinates") + let reverse = queries[0].hits[0].hsps[1].fragments[0] + println( + " Infernal 480..412 -> zero-based half-open [" + + reverse.hit_start.to_string() + + ", " + + reverse.hit_end.to_string() + + "), strand=" + + (if reverse.hit_strand == @src.strand_minus() { "-" } else { "+" }), + ) + + println("\n3. Parse plain text and split local-end alignment") + let text_queries = @src.infernal_parse_text(@src.infernal_text_sample()) catch { + _ => abort("failed to parse Infernal plain-text sample") + } + let text_query = text_queries[0] + let local_hsp = text_query.hits[0].hsps[0] + println(" " + text_query.summary()) + println(" local-end fragments: " + local_hsp.fragments.length().to_string()) + for index in 0.. abort("failed to filter Infernal results") + } + println(" retained HSPs: " + filtered.count_hsps().to_string()) + match queries[0].hits[0].best_hsp() { + Some(best) => + println( + " best HSP: score=" + + best.bitscore.to_string() + + ", E-value=" + + best.evalue.to_string(), + ) + None => abort("expected a best Infernal HSP") + } + + println("\n5. Convert to the generic SearchIO hierarchy") + let generic = text_query.to_searchio() + println( + " QueryResult id=" + + generic.id + + ", hits=" + + generic.hits.length().to_string() + + ", fragments=" + + generic.hits[0].hsps[0].fragments.length().to_string(), + ) + + println( + "\nScope: Infernal 1.0+ non-verbose cmscan/cmsearch tabular formats 1/2/3, plain text, --noali, CM and HMM-only output.", + ) + println("\n=== Demo Complete ===") +} diff --git a/examples/infernal_io_demo/moon.pkg b/examples/infernal_io_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/infernal_io_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/genomic_ranges.mbt b/src/genomic_ranges.mbt index df6f59f0..8cbb7e2a 100644 --- a/src/genomic_ranges.mbt +++ b/src/genomic_ranges.mbt @@ -6,7 +6,7 @@ pub enum Strand { Plus Minus Star -} derive(Eq) +} derive(Eq, Debug) ///| pub fn strand_plus() -> Strand { diff --git a/src/infernal_io.mbt b/src/infernal_io.mbt new file mode 100644 index 00000000..770caba2 --- /dev/null +++ b/src/infernal_io.mbt @@ -0,0 +1,1360 @@ +///| +/// Bio.SearchIO.InfernalIO support for Infernal cmscan/cmsearch output. +/// +/// Infernal searches RNA sequence databases with covariance models. Its +/// terminology calls the model the query and the sequence the target. This +/// module follows Biopython SearchIO and exposes model coordinates as query +/// coordinates and sequence coordinates as hit coordinates. + +///| +pub suberror InfernalError { + InfernalError(String) +} + +///| +pub enum InfernalTabularFormat { + Format1 + Format2 + Format3 +} derive(Eq, Debug) + +///| +pub struct InfernalFragment { + query_start : Int + query_end : Int + hit_start : Int + hit_end : Int + hit_strand : Strand + query_sequence : String + hit_sequence : String + consensus_structure : String + noncanonical_pairs : String + similarity : String + posterior_probability : String + model_omission_before : Int + sequence_omission_before : Int +} derive(Debug) + +///| +pub struct InfernalHSP { + fragments : Array[InfernalFragment] + model : String + truncated : String + pipeline_pass : Int + gc : Double + bias : Double + bitscore : Double + evalue : Double + is_included : Bool + query_end_type : String + hit_end_type : String + average_accuracy : Double + overlap : String + any_index : Int? + any_overlap_fraction : Double? + reciprocal_overlap_fraction : Double? + winner_index : Int? + winner_overlap_fraction : Double? + winner_reciprocal_fraction : Double? +} derive(Debug) + +///| +pub struct InfernalHit { + id : String + accession : String + description : String + model_length : Int + hsps : Array[InfernalHSP] +} derive(Debug) + +///| +pub struct InfernalQueryResult { + id : String + accession : String + description : String + clan : String + sequence_length : Int + program : String + version : String + target : String + hits : Array[InfernalHit] +} derive(Debug) + +///| +priv struct InfernalTabRow { + query_id : String + query_accession : String + query_clan : String + query_length : Int + hit_id : String + hit_accession : String + hit_description : String + hit_model_length : Int + hsp : InfernalHSP +} + +///| +priv struct InfernalMarker { + start : Int + end : Int + model_size : Int + sequence_size : Int +} + +///| +fn infernal_split_whitespace(s : String) -> Array[String] { + let values : Array[String] = [] + let mut start = 0 + let mut in_token = false + for index in 0.. String { + let mut result = "" + for index in start.. start { + result = result + " " + } + result = result + values[index] + } + result +} + +///| +fn infernal_parse_int( + value : String, + label : String, +) -> Int raise InfernalError { + if value.length() == 0 { + raise InfernalError("missing integer field " + label) + } + let mut start = 0 + if value.unsafe_get(0).to_int() == '-'.to_int() { + if value.length() == 1 { + raise InfernalError("invalid integer in " + label + ": " + value) + } + start = 1 + } + for index in start.. '9'.to_int() { + raise InfernalError("invalid integer in " + label + ": " + value) + } + } + parse_int(value) +} + +///| +fn infernal_parse_double( + value : String, + label : String, +) -> Double raise InfernalError { + match parse_double(value) { + Some(number) => + if number.is_nan() { + raise InfernalError("NaN is not valid in " + label) + } else { + number + } + None => raise InfernalError("invalid number in " + label + ": " + value) + } +} + +///| +fn infernal_optional_int(value : String) -> Int? raise InfernalError { + if value == "-" || value == "\"" { + None + } else { + Some(infernal_parse_int(value, "overlap index")) + } +} + +///| +fn infernal_optional_double(value : String) -> Double? raise InfernalError { + if value == "-" || value == "\"" { + None + } else { + Some(infernal_parse_double(value, "overlap fraction")) + } +} + +///| +fn infernal_digit_count(value : String) -> Int { + let mut result = 0 + for index in 0..= '0'.to_int() && digit <= '9'.to_int() { + result = result * 10 + digit - '0'.to_int() + } + } + result +} + +///| +fn infernal_is_integer(value : String) -> Bool { + if value.length() == 0 { + return false + } + let mut start = 0 + if value.unsafe_get(0).to_int() == '-'.to_int() { + start = 1 + } + if start == value.length() { + return false + } + for index in start.. '9'.to_int() { + return false + } + } + true +} + +///| +fn infernal_coordinate_fragment( + model_from : Int, + model_to : Int, + sequence_from : Int, + sequence_to : Int, + strand : String, +) -> InfernalFragment raise InfernalError { + if model_from < 1 || model_to < 1 || sequence_from < 1 || sequence_to < 1 { + raise InfernalError("Infernal coordinates must be positive") + } + let (query_start, query_end) = if model_from <= model_to { + (model_from - 1, model_to) + } else { + (model_to - 1, model_from) + } + let (hit_start, hit_end, hit_strand) = match strand { + "+" => (sequence_from - 1, sequence_to, Strand::Plus) + "-" => (sequence_to - 1, sequence_from, Strand::Minus) + _ => raise InfernalError("invalid Infernal strand: " + strand) + } + InfernalFragment::{ + query_start, + query_end, + hit_start, + hit_end, + hit_strand, + query_sequence: "", + hit_sequence: "", + consensus_structure: "", + noncanonical_pairs: "", + similarity: "", + posterior_probability: "", + model_omission_before: 0, + sequence_omission_before: 0, + } +} + +///| +fn infernal_detect_tabular_format( + content : String, +) -> InfernalTabularFormat raise InfernalError { + let lines = split_by_char(content, '\n'.to_int()) + for line in lines { + let trimmed = line.trim().to_owned() + if trimmed.has_prefix("#") && trimmed.contains("target name") { + if trimmed.contains("clan name") { + return InfernalTabularFormat::Format2 + } + if trimmed.contains("mdl len") { + return InfernalTabularFormat::Format3 + } + return InfernalTabularFormat::Format1 + } + } + raise InfernalError( + "cannot determine Infernal tabular format; supply format=1, 2, or 3", + ) +} + +///| +pub fn infernal_tabular_format( + content : String, +) -> InfernalTabularFormat raise InfernalError { + infernal_detect_tabular_format(content) +} + +///| +fn infernal_format_number( + content : String, + requested : Int, +) -> Int raise InfernalError { + if requested != 0 { + if requested < 1 || requested > 3 { + raise InfernalError("Infernal tabular format must be 1, 2, or 3") + } + return requested + } + match infernal_detect_tabular_format(content) { + Format1 => 1 + Format2 => 2 + Format3 => 3 + } +} + +///| +fn infernal_parse_tab_row( + values : Array[String], + format : Int, +) -> InfernalTabRow raise InfernalError { + let minimum = if format == 1 { 18 } else if format == 2 { 29 } else { 20 } + if values.length() < minimum { + raise InfernalError( + "Infernal tabular format " + + format.to_string() + + " expects at least " + + minimum.to_string() + + " fields, found " + + values.length().to_string(), + ) + } + let mut offset = 0 + let mut clan = "" + let mut model_length = 0 + let mut sequence_length = 0 + let mut overlap = "" + let mut any_index : Int? = None + let mut any_fraction : Double? = None + let mut reciprocal_fraction : Double? = None + let mut winner_index : Int? = None + let mut winner_fraction : Double? = None + let mut winner_reciprocal : Double? = None + let description_start = if format == 1 { + 17 + } else if format == 2 { + offset = 1 + clan = values[5] + overlap = values[19] + any_index = infernal_optional_int(values[20]) + any_fraction = infernal_optional_double(values[21]) + reciprocal_fraction = infernal_optional_double(values[22]) + winner_index = infernal_optional_int(values[23]) + winner_fraction = infernal_optional_double(values[24]) + winner_reciprocal = infernal_optional_double(values[25]) + model_length = infernal_parse_int(values[26], "mdl len") + sequence_length = infernal_parse_int(values[27], "seq len") + 28 + } else { + model_length = infernal_parse_int(values[17], "mdl len") + sequence_length = infernal_parse_int(values[18], "seq len") + 19 + } + let target_name = values[offset] + let target_accession = values[offset + 1] + let query_name = values[offset + 2] + let query_accession = values[offset + 3] + let model_offset = if format == 2 { 6 } else { 4 } + let model = values[model_offset] + let model_from = infernal_parse_int(values[model_offset + 1], "mdl from") + let model_to = infernal_parse_int(values[model_offset + 2], "mdl to") + let sequence_from = infernal_parse_int(values[model_offset + 3], "seq from") + let sequence_to = infernal_parse_int(values[model_offset + 4], "seq to") + let strand = values[model_offset + 5] + let fragment = infernal_coordinate_fragment( + model_from, model_to, sequence_from, sequence_to, strand, + ) + let hsp = InfernalHSP::{ + fragments: [fragment], + model, + truncated: values[model_offset + 6], + pipeline_pass: infernal_parse_int(values[model_offset + 7], "pipeline pass"), + gc: infernal_parse_double(values[model_offset + 8], "gc"), + bias: infernal_parse_double(values[model_offset + 9], "bias"), + bitscore: infernal_parse_double(values[model_offset + 10], "score"), + evalue: infernal_parse_double(values[model_offset + 11], "E-value"), + is_included: values[model_offset + 12] == "!", + query_end_type: "", + hit_end_type: "", + average_accuracy: 0.0, + overlap, + any_index, + any_overlap_fraction: any_fraction, + reciprocal_overlap_fraction: reciprocal_fraction, + winner_index, + winner_overlap_fraction: winner_fraction, + winner_reciprocal_fraction: winner_reciprocal, + } + InfernalTabRow::{ + query_id: query_name, + query_accession, + query_clan: clan, + query_length: sequence_length, + hit_id: target_name, + hit_accession: target_accession, + hit_description: infernal_join(values, description_start), + hit_model_length: model_length, + hsp, + } +} + +///| +fn infernal_build_results( + rows : Array[InfernalTabRow], + program : String, + version : String, + target : String, +) -> Array[InfernalQueryResult] { + let query_order : Array[String] = [] + let by_query : Map[String, Array[InfernalTabRow]] = Map([], capacity=0) + for row in rows { + match by_query.get(row.query_id) { + Some(values) => values.push(row) + None => { + query_order.push(row.query_id) + by_query.set(row.query_id, [row]) + } + } + } + let results : Array[InfernalQueryResult] = [] + for query_id in query_order { + let query_rows = by_query.get(query_id).unwrap() + let hit_order : Array[String] = [] + let by_hit : Map[String, Array[InfernalTabRow]] = Map([], capacity=0) + for row in query_rows { + match by_hit.get(row.hit_id) { + Some(values) => values.push(row) + None => { + hit_order.push(row.hit_id) + by_hit.set(row.hit_id, [row]) + } + } + } + let hits : Array[InfernalHit] = [] + for hit_id in hit_order { + let hit_rows = by_hit.get(hit_id).unwrap() + let hsps : Array[InfernalHSP] = [] + for row in hit_rows { + hsps.push(row.hsp) + } + let first = hit_rows[0] + hits.push(InfernalHit::{ + id: hit_id, + accession: first.hit_accession, + description: first.hit_description, + model_length: first.hit_model_length, + hsps, + }) + } + let first = query_rows[0] + results.push(InfernalQueryResult::{ + id: query_id, + accession: first.query_accession, + description: "", + clan: first.query_clan, + sequence_length: first.query_length, + program, + version, + target, + hits, + }) + } + results +} + +///| +/// Parse Infernal `--tblout` formats 1, 2, and 3. +/// +/// The format is inferred from the header unless `format` is supplied. +/// Coordinates are normalized to zero-based, half-open intervals. Reverse +/// strand sequence coordinates are reordered while retaining `Strand::Minus`. +pub fn infernal_parse_tabular( + content : String, + format? : Int = 0, +) -> Array[InfernalQueryResult] raise InfernalError { + let selected = infernal_format_number(content, format) + let rows : Array[InfernalTabRow] = [] + let lines = split_by_char(content, '\n'.to_int()) + for line in lines { + let trimmed = line.trim().to_owned() + if trimmed.length() == 0 || trimmed.has_prefix("#") { + continue + } + rows.push( + infernal_parse_tab_row(infernal_split_whitespace(trimmed), selected), + ) + } + infernal_build_results(rows, "", "", "") +} + +///| +fn infernal_marker_at(sequence : String, start : Int) -> (Int, Int)? { + if start + 4 >= sequence.length() || + sequence.unsafe_get(start).to_int() != '*'.to_int() || + sequence.unsafe_get(start + 1).to_int() != '['.to_int() { + return None + } + let mut end = start + 2 + let mut size = 0 + let mut has_digit = false + while end < sequence.length() { + let value = sequence.unsafe_get(end).to_int() + if value == ']'.to_int() { + if end + 1 < sequence.length() && + sequence.unsafe_get(end + 1).to_int() == '*'.to_int() && + has_digit { + return Some((end + 2, size)) + } + return None + } + if value == ' '.to_int() { + end = end + 1 + continue + } + if value < '0'.to_int() || value > '9'.to_int() { + return None + } + has_digit = true + size = size * 10 + value - '0'.to_int() + end = end + 1 + } + None +} + +///| +fn infernal_find_markers( + model_sequence : String, + hit_sequence : String, +) -> Array[InfernalMarker] { + let markers : Array[InfernalMarker] = [] + let length = model_sequence.length().max(hit_sequence.length()) + let mut index = 0 + while index < length { + let model_marker = infernal_marker_at(model_sequence, index) + let hit_marker = infernal_marker_at(hit_sequence, index) + match (model_marker, hit_marker) { + (None, None) => index = index + 1 + _ => { + let model_end = match model_marker { + Some(value) => value.0 + None => index + } + let hit_end = match hit_marker { + Some(value) => value.0 + None => index + } + let end = model_end.max(hit_end) + markers.push(InfernalMarker::{ + start: index, + end, + model_size: match model_marker { + Some(value) => value.1 + None => 0 + }, + sequence_size: match hit_marker { + Some(value) => value.1 + None => 0 + }, + }) + index = if end > index { end } else { index + 1 } + } + } + } + markers +} + +///| +fn infernal_residue_count(sequence : String, start : Int, end : Int) -> Int { + let bounded_end = end.min(sequence.length()) + if start >= bounded_end { + return 0 + } + let mut count = 0 + for index in start..= 'A'.to_int() && value <= 'Z'.to_int()) || + (value >= 'a'.to_int() && value <= 'z'.to_int()) { + count = count + 1 + } + } + count +} + +///| +fn infernal_slice(sequence : String, start : Int, end : Int) -> String { + let bounded_start = start.min(sequence.length()) + let bounded_end = end.min(sequence.length()) + if bounded_start >= bounded_end { + "" + } else { + sequence[bounded_start:bounded_end].to_owned() + } +} + +///| +fn infernal_add_fragment( + fragments : Array[InfernalFragment], + model_sequence : String, + hit_sequence : String, + consensus_structure : String, + noncanonical_pairs : String, + similarity : String, + posterior_probability : String, + start : Int, + end : Int, + model_position : Int, + hit_position : Int, + strand : Strand, + model_omission : Int, + sequence_omission : Int, +) -> (Int, Int) { + let model_count = infernal_residue_count(model_sequence, start, end) + let hit_count = infernal_residue_count(hit_sequence, start, end) + if model_count == 0 && hit_count == 0 { + return (model_position, hit_position) + } + let (hit_start, hit_end, next_hit) = if strand == Strand::Minus { + (hit_position - hit_count, hit_position, hit_position - hit_count) + } else { + (hit_position, hit_position + hit_count, hit_position + hit_count) + } + fragments.push(InfernalFragment::{ + query_start: model_position, + query_end: model_position + model_count, + hit_start, + hit_end, + hit_strand: strand, + query_sequence: infernal_slice(model_sequence, start, end), + hit_sequence: infernal_slice(hit_sequence, start, end), + consensus_structure: infernal_slice(consensus_structure, start, end), + noncanonical_pairs: infernal_slice(noncanonical_pairs, start, end), + similarity: infernal_slice(similarity, start, end), + posterior_probability: infernal_slice(posterior_probability, start, end), + model_omission_before: model_omission, + sequence_omission_before: sequence_omission, + }) + (model_position + model_count, next_hit) +} + +///| +fn infernal_alignment_fragments( + base : InfernalFragment, + model_sequence : String, + hit_sequence : String, + consensus_structure : String, + noncanonical_pairs : String, + similarity : String, + posterior_probability : String, +) -> Array[InfernalFragment] { + let markers = infernal_find_markers(model_sequence, hit_sequence) + let fragments : Array[InfernalFragment] = [] + let mut model_position = base.query_start + let mut hit_position = if base.hit_strand == Strand::Minus { + base.hit_end + } else { + base.hit_start + } + let mut display_position = 0 + let mut model_omission = 0 + let mut sequence_omission = 0 + for marker in markers { + let next = infernal_add_fragment( + fragments, + model_sequence, + hit_sequence, + consensus_structure, + noncanonical_pairs, + similarity, + posterior_probability, + display_position, + marker.start, + model_position, + hit_position, + base.hit_strand, + model_omission, + sequence_omission, + ) + model_position = next.0 + hit_position = next.1 + let skipped_model = if marker.model_size > 0 { + marker.model_size + } else { + infernal_residue_count(model_sequence, marker.start, marker.end) + } + let skipped_hit = if marker.sequence_size > 0 { + marker.sequence_size + } else { + infernal_residue_count(hit_sequence, marker.start, marker.end) + } + model_position = model_position + skipped_model + hit_position = if base.hit_strand == Strand::Minus { + hit_position - skipped_hit + } else { + hit_position + skipped_hit + } + model_omission = skipped_model + sequence_omission = skipped_hit + display_position = marker.end + } + let display_end = model_sequence.length().max(hit_sequence.length()) + ignore( + infernal_add_fragment( + fragments, + model_sequence, + hit_sequence, + consensus_structure, + noncanonical_pairs, + similarity, + posterior_probability, + display_position, + display_end, + model_position, + hit_position, + base.hit_strand, + model_omission, + sequence_omission, + ), + ) + if fragments.length() == 0 { + [base] + } else { + fragments + } +} + +///| +fn infernal_text_metadata( + lines : Array[String], +) -> (String, String, String, Bool) { + let mut program = "" + let mut version = "" + let mut target = "" + let mut show_alignments = true + for line in lines { + let trimmed = line.trim().to_owned() + if trimmed.has_prefix("# cmsearch") || trimmed.has_prefix("# cmscan") { + let values = infernal_split_whitespace(trimmed) + if values.length() > 1 { + program = values[1] + } + } else if trimmed.has_prefix("# INFERNAL") { + let values = infernal_split_whitespace(trimmed) + if values.length() > 2 { + version = values[2] + } + } else if trimmed.has_prefix("#") && trimmed.contains(":") { + if trimmed.contains("target") { + let parts = split_by_char(trimmed, ':'.to_int()) + if parts.length() > 1 { + target = parts[1].trim().to_owned() + } + } + if trimmed.contains("show alignments in output") && + trimmed.has_suffix("no") { + show_alignments = false + } + } + } + (program, version, target, show_alignments) +} + +///| +fn infernal_text_hit_header(line : String) -> (String, String) { + let values = infernal_split_whitespace(line.trim().to_owned()) + if values.length() < 2 { + return ("", "") + } + (values[1], infernal_join(values, 2)) +} + +///| +fn infernal_parse_text_hsp( + row : Array[String], + model_sequence : String, + hit_sequence : String, + consensus_structure : String, + noncanonical_pairs : String, + similarity : String, + posterior_probability : String, +) -> InfernalHSP raise InfernalError { + if row.length() != 16 { + raise InfernalError( + "Infernal text alignment score row must contain 16 fields", + ) + } + let base = infernal_coordinate_fragment( + infernal_parse_int(row[6], "mdl from"), + infernal_parse_int(row[7], "mdl to"), + infernal_parse_int(row[9], "seq from"), + infernal_parse_int(row[10], "seq to"), + row[11], + ) + let fragments = if model_sequence.length() == 0 && hit_sequence.length() == 0 { + [base] + } else { + infernal_alignment_fragments( + base, model_sequence, hit_sequence, consensus_structure, noncanonical_pairs, + similarity, posterior_probability, + ) + } + InfernalHSP::{ + fragments, + model: row[5], + truncated: row[14], + pipeline_pass: 0, + gc: infernal_parse_double(row[15], "gc"), + bias: infernal_parse_double(row[4], "bias"), + bitscore: infernal_parse_double(row[3], "score"), + evalue: infernal_parse_double(row[2], "E-value"), + is_included: row[1] == "!", + query_end_type: row[8], + hit_end_type: row[12], + average_accuracy: infernal_parse_double(row[13], "accuracy"), + overlap: "", + any_index: None, + any_overlap_fraction: None, + reciprocal_overlap_fraction: None, + winner_index: None, + winner_overlap_fraction: None, + winner_reciprocal_fraction: None, + } +} + +///| +fn infernal_alignment_strings( + lines : Array[String], + start : Int, + end : Int, + query_id : String, + hit_id : String, +) -> (String, String, String, String, String, String) { + let mut model_sequence = "" + let mut hit_sequence = "" + let mut consensus = "" + let mut noncanonical = "" + let mut similarity = "" + let mut posterior = "" + let mut pending_similarity = "" + for index in start..= 4 && + infernal_is_integer(values[1]) && + infernal_is_integer(values[values.length() - 1]) { + let sequence = values[2] + if values[0] == hit_id { + hit_sequence = hit_sequence + sequence + if pending_similarity.length() > 0 { + similarity = similarity + pending_similarity + pending_similarity = "" + } + } else if values[0] == query_id || model_sequence.length() == 0 { + model_sequence = model_sequence + sequence + } + } else { + match values[0] { + "CS" | "SS_cons" => + if values.length() > 1 { + consensus = consensus + values[1] + } + "NC" => + if values.length() > 1 { + noncanonical = noncanonical + values[1] + } + "PP" => if values.length() > 1 { posterior = posterior + values[1] } + _ => + if model_sequence.length() > hit_sequence.length() { + pending_similarity = values[0] + } + } + } + } + (model_sequence, hit_sequence, consensus, noncanonical, similarity, posterior) +} + +///| +fn infernal_parse_text_hit( + lines : Array[String], + start : Int, + end : Int, + query_id : String, +) -> InfernalHit raise InfernalError { + let (hit_id, description) = infernal_text_hit_header(lines[start]) + if hit_id.length() == 0 { + raise InfernalError("invalid Infernal text hit header") + } + let mut row_index = -1 + for index in (start + 1).. Array[InfernalHit] raise InfernalError { + let hits : Array[InfernalHit] = [] + let mut table_started = false + for index in start.. (sequence_from - 1, sequence_to, Strand::Plus) + "-" => (sequence_to - 1, sequence_from, Strand::Minus) + _ => raise InfernalError("invalid Infernal strand: " + strand) + } + let fragment = InfernalFragment::{ + query_start: -1, + query_end: -1, + hit_start, + hit_end, + hit_strand, + query_sequence: "", + hit_sequence: "", + consensus_structure: "", + noncanonical_pairs: "", + similarity: "", + posterior_probability: "", + model_omission_before: 0, + sequence_omission_before: 0, + } + let hsp = InfernalHSP::{ + fragments: [fragment], + model: values[9], + truncated: values[10], + pipeline_pass: 0, + gc: infernal_parse_double(values[11], "gc"), + bias: infernal_parse_double(values[4], "bias"), + bitscore: infernal_parse_double(values[3], "score"), + evalue: infernal_parse_double(values[2], "E-value"), + is_included: values[1] == "!", + query_end_type: "", + hit_end_type: "", + average_accuracy: 0.0, + overlap: "", + any_index: None, + any_overlap_fraction: None, + reciprocal_overlap_fraction: None, + winner_index: None, + winner_overlap_fraction: None, + winner_reciprocal_fraction: None, + } + hits.push(InfernalHit::{ + id: hit_id, + accession: "", + description: infernal_join(values, 12), + model_length: 0, + hsps: [hsp], + }) + } + hits +} + +///| +fn infernal_merge_hits(source : Array[InfernalHit]) -> Array[InfernalHit] { + let order : Array[String] = [] + let grouped : Map[String, Array[InfernalHit]] = Map([], capacity=0) + for hit in source { + match grouped.get(hit.id) { + Some(values) => values.push(hit) + None => { + order.push(hit.id) + grouped.set(hit.id, [hit]) + } + } + } + let results : Array[InfernalHit] = [] + for hit_id in order { + let matches = grouped.get(hit_id).unwrap() + let hsps : Array[InfernalHSP] = [] + for hit in matches { + for hsp in hit.hsps { + hsps.push(hsp) + } + } + results.push(InfernalHit::{ ..matches[0], hsps, }) + } + results +} + +///| +/// Parse non-verbose Infernal plain-text output. +/// +/// Both alignment output and `--noali` score tables are supported. Alignment +/// local ends (`*[NN]*`) split one HSP into coordinate-aware fragments. +pub fn infernal_parse_text( + content : String, +) -> Array[InfernalQueryResult] raise InfernalError { + let lines = split_by_char(content, '\n'.to_int()) + let metadata = infernal_text_metadata(lines) + let results : Array[InfernalQueryResult] = [] + let mut index = 0 + while index < lines.length() { + let trimmed = lines[index].trim().to_owned() + if !trimmed.has_prefix("Query:") { + index = index + 1 + continue + } + let query_values = infernal_split_whitespace(trimmed) + if query_values.length() < 2 { + raise InfernalError("invalid Infernal Query line") + } + let query_id = query_values[1] + let mut query_length = 0 + for value in query_values { + if value.contains("M=") || value.contains("CLEN=") || value.contains("L=") { + query_length = infernal_digit_count(value) + } + } + let query_start = index + let mut query_end = index + 1 + while query_end < lines.length() && + !lines[query_end].trim().has_prefix("//") { + query_end = query_end + 1 + } + let mut accession = "" + let mut description = "" + for cursor in (query_start + 1).. 1 { + accession = values[1] + } + } else if current.has_prefix("Description:") { + let values = infernal_split_whitespace(current) + description = infernal_join(values, 1) + } + } + let hits : Array[InfernalHit] = [] + if metadata.3 { + let hit_starts : Array[Int] = [] + for cursor in (query_start + 1)..> ") { + hit_starts.push(cursor) + } + } + for hit_index in 0.. Int { + if self.fragments.length() == 0 { + -1 + } else { + let mut result = self.fragments[0].query_start + for fragment in self.fragments { + if fragment.query_start >= 0 && fragment.query_start < result { + result = fragment.query_start + } + } + result + } +} + +///| +pub fn InfernalHSP::query_end(self : InfernalHSP) -> Int { + let mut result = -1 + for fragment in self.fragments { + result = result.max(fragment.query_end) + } + result +} + +///| +pub fn InfernalHSP::hit_start(self : InfernalHSP) -> Int { + if self.fragments.length() == 0 { + -1 + } else { + let mut result = self.fragments[0].hit_start + for fragment in self.fragments { + result = result.min(fragment.hit_start) + } + result + } +} + +///| +pub fn InfernalHSP::hit_end(self : InfernalHSP) -> Int { + let mut result = -1 + for fragment in self.fragments { + result = result.max(fragment.hit_end) + } + result +} + +///| +pub fn InfernalHSP::alignment_span(self : InfernalHSP) -> Int { + let mut result = 0 + for fragment in self.fragments { + result = result + fragment.hit_end - fragment.hit_start + } + result +} + +///| +pub fn InfernalHit::best_hsp(self : InfernalHit) -> InfernalHSP? { + if self.hsps.length() == 0 { + return None + } + let mut best = self.hsps[0] + for hsp in self.hsps { + if hsp.evalue < best.evalue || + (hsp.evalue == best.evalue && hsp.bitscore > best.bitscore) { + best = hsp + } + } + Some(best) +} + +///| +pub fn InfernalQueryResult::count_hsps(self : InfernalQueryResult) -> Int { + let mut count = 0 + for hit in self.hits { + count = count + hit.hsps.length() + } + count +} + +///| +pub fn InfernalQueryResult::filter( + self : InfernalQueryResult, + maximum_evalue? : Double = 1.0, + included_only? : Bool = false, +) -> InfernalQueryResult raise InfernalError { + if maximum_evalue < 0.0 || maximum_evalue.is_nan() { + raise InfernalError("maximum_evalue must be non-negative") + } + let hits : Array[InfernalHit] = [] + for hit in self.hits { + let hsps : Array[InfernalHSP] = [] + for hsp in hit.hsps { + if hsp.evalue <= maximum_evalue && (!included_only || hsp.is_included) { + hsps.push(hsp) + } + } + if hsps.length() > 0 { + hits.push(InfernalHit::{ ..hit, hsps, }) + } + } + InfernalQueryResult::{ ..self, hits, } +} + +///| +/// Convert the Infernal-specific model to the repository SearchIO hierarchy. +pub fn InfernalQueryResult::to_searchio( + self : InfernalQueryResult, +) -> QueryResult { + let hits : Array[Hit] = [] + for source_hit in self.hits { + let hsps : Array[HSP] = [] + let mut hit_score = 0.0 + let mut hit_evalue = 1.0 + for source_hsp in source_hit.hsps { + let fragments : Array[HSPFragment] = [] + for source_fragment in source_hsp.fragments { + fragments.push( + HSPFragment::new( + source_fragment.query_start, + source_fragment.query_end, + source_fragment.hit_start, + source_fragment.hit_end, + Strand::Star, + source_fragment.hit_strand, + (source_fragment.hit_end - source_fragment.hit_start).max(0), + 0, + source_hsp.bitscore, + source_hsp.evalue, + source_fragment.query_sequence, + source_fragment.hit_sequence, + source_fragment.similarity, + ), + ) + } + hsps.push( + HSP::new( + source_hit.id, + source_hit.description, + fragments, + source_hsp.bitscore, + source_hsp.evalue, + source_hsp.bitscore, + ), + ) + hit_score = hit_score + source_hsp.bitscore + if source_hsp.evalue < hit_evalue { + hit_evalue = source_hsp.evalue + } + } + hits.push( + Hit::new( + source_hit.id, + source_hit.description, + source_hit.accession, + hsps, + hit_score, + hit_evalue, + ), + ) + } + QueryResult::new( + self.id, + self.description, + self.sequence_length, + hits, + self.program, + self.version, + self.target, + ) +} + +///| +pub fn InfernalQueryResult::summary(self : InfernalQueryResult) -> String { + "InfernalQueryResult(query=" + + self.id + + ", hits=" + + self.hits.length().to_string() + + ", hsps=" + + self.count_hsps().to_string() + + ", program=" + + self.program + + ")" +} + +///| +pub fn infernal_tabular_sample() -> String { + "#target name accession query name accession mdl mdl from mdl to seq from seq to strand trunc pass gc bias score E-value inc mdl len seq len description of target\n" + + "#----------- --------- ---------- --------- --- -------- -------- -------- -------- ------ ----- ---- -- ---- ----- ------- --- ------- ------- ---------------------\n" + + "chrA RFSEQ1 RF00001 RF00001 cm 1 71 101 171 + no 1 0.52 0.0 48.5 2.0e-14 ! 71 1000 bacterial 5S RNA locus\n" + + "chrA RFSEQ1 RF00001 RF00001 cm 2 70 480 412 - 3' 2 0.47 0.1 39.2 4.5e-09 ? 71 1000 reverse strand copy\n" + + "chrB RFSEQ2 RF00002 RF00002 hmm 3 66 20 83 + no 1 0.61 0.0 31.0 7.0e-06 ! 68 800 riboswitch candidate\n" +} + +///| +pub fn infernal_text_sample() -> String { + "# cmsearch :: search a covariance model against a sequence database\n" + + "# INFERNAL 1.1.5 (Sep 2023)\n" + + "# - - -\n" + + "# target sequence database: transcripts.fa\n" + + "# show alignments in output: yes\n" + + "# - - -\n" + + "Query: RFTEST [M=19]\n" + + "Accession: RFTEST.1\n" + + "Description: synthetic structured RNA\n" + + "Hit scores:\n" + + "Hit alignments:\n" + + ">> targetA synthetic RNA target\n" + + " ---- --------- ------ ----- ---- --- -------- -------- --- -------- -------- --- --- ---- ----- --\n" + + " 1 ! 2.0e-10 45.0 0.1 cm 1 19 [] 100 118 + .. 0.96 no 0.50\n" + + "CS (((....))).........\n" + + "RFTEST 1 ACGUACGU*[5]*AACCGG 19\n" + + "targetA 100 ACGUACGUGGGGGAACCGG 118\n" + + "PP 9999999999999999999\n" + + "Internal CM pipeline statistics summary:\n" + + "//\n" + + "[ok]\n" +} diff --git a/test/moonbit/infernal_io_test.mbt b/test/moonbit/infernal_io_test.mbt new file mode 100644 index 00000000..8a5af12c --- /dev/null +++ b/test/moonbit/infernal_io_test.mbt @@ -0,0 +1,473 @@ +///| +/// Tests for the Biopython Bio.SearchIO.InfernalIO-compatible parsers. + +///| +fn infernal_format1_text() -> String { + "# target name accession query name accession mdl mdl from mdl to seq from seq to strand trunc pass gc bias score E-value inc description of target\n" + + "# ----------- --------- ---------- --------- --- -------- -------- -------- -------- ------ ----- ---- -- ---- ----- ------- --- ---------------------\n" + + "seq1 SACC RFQ1 QACC cm 1 70 10 79 + no 1 0.50 0.0 20.0 1.0e-05 ! format one target\n" +} + +///| +fn infernal_format2_text() -> String { + "# idx target name accession query name accession clan name mdl mdl from mdl to seq from seq to strand trunc pass gc bias score E-value inc olp anyidx afrct1 afrct2 winidx wfrct1 wfrct2 mdl len seq len description of target\n" + + "# --- ----------- --------- ---------- --------- --------- --- -------- -------- -------- -------- ------ ----- ---- -- ---- ----- ------- --- --- ------ ------ ------ ------ ------ ------ ------- ------- ---------------------\n" + + "1 chr2 ACC2 RFQ2 RFQ2.1 CL001 cm 2 60 900 841 - 5' 3 0.44 0.2 55.0 3.0e-18 ! ^ 7 0.25 0.50 2 0.75 0.80 65 2000 format two target\n" +} + +///| +fn infernal_noali_text() -> String { + "# cmsearch :: search a covariance model against a sequence database\n" + + "# INFERNAL 1.1.5 (Sep 2023)\n" + + "# - - -\n" + + "# target sequence database: noali.fa\n" + + "# show alignments in output: no\n" + + "# - - -\n" + + "Query: RFNOALI [M=50]\n" + + "Accession: RFNOALI.1\n" + + "Description: score-only query\n" + + "Hit scores:\n" + + " ---- --------- ------ ----- ---- ---------------- -------- -------- --- --- ----- -- --------------\n" + + " 1 ! 1.0e-08 33.0 0.1 seqA 100 81 - cm no 0.45 reverse score hit\n" + + " 2 ? 2.0e-04 20.0 0.0 seqA 200 219 + hmm 3' 0.51 second domain\n" + + " 3 ! 5.0e-03 18.0 0.2 seqB 10 29 + cm no 0.39 other target\n" + + "Internal CM pipeline statistics summary:\n" + + "//\n" + + "[ok]\n" +} + +///| +fn infernal_no_hit_text() -> String { + "# cmscan :: search a sequence against a covariance model database\n" + + "# INFERNAL 1.1.5 (Sep 2023)\n" + + "# - - -\n" + + "# target CM database: Rfam.cm\n" + + "# show alignments in output: yes\n" + + "# - - -\n" + + "Query: empty_query [L=25]\n" + + "Hit scores:\n" + + " [No hits detected that satisfy reporting thresholds]\n" + + "Internal CM pipeline statistics summary:\n" + + "//\n" + + "[ok]\n" +} + +///| +fn infernal_reverse_text() -> String { + @src.infernal_text_sample() + .replace_all(old="100 118 + .. 0.96 no 0.50", new="200 182 - .. 0.96 no 0.50") + .replace_all( + old="targetA 100 ACGUACGUGGGGGAACCGG 118", + new="targetA 200 ACGUACGUGGGGGAACCGG 182", + ) +} + +///| +fn infernal_duplicate_alignment_text() -> String { + let second = ">> targetA synthetic RNA target\n" + + " ---- --------- ------ ----- ---- --- -------- -------- --- -------- -------- --- --- ---- ----- --\n" + + " 2 ? 4.0e-06 29.0 0.0 hmm 2 18 .. 300 316 + .. 0.88 3' 0.42\n" + + "CS ((..............))\n" + + "RFTEST 2 CGUACGUAACCGGAAAAC 18\n" + + "targetA 300 CGUACGUAACCGGAAAAC 316\n" + + "PP 88888888888888888\n" + @src.infernal_text_sample().replace_all( + old="Internal CM pipeline statistics summary:\n", + new=second + "Internal CM pipeline statistics summary:\n", + ) +} + +///| +fn infernal_tab_raises(content : String, format : Int) -> Bool { + try { + ignore(@src.infernal_parse_tabular(content, format~)) + false + } catch { + InfernalError(_) => true + } +} + +///| +fn infernal_text_raises(content : String) -> Bool { + try { + ignore(@src.infernal_parse_text(content)) + false + } catch { + InfernalError(_) => true + } +} + +///| +test "InfernalIO detects tabular formats 1, 2, and 3" { + assert_true(@src.infernal_tabular_format(infernal_format1_text()) is Format1) + assert_true(@src.infernal_tabular_format(infernal_format2_text()) is Format2) + assert_true( + @src.infernal_tabular_format(@src.infernal_tabular_sample()) is Format3, + ) +} + +///| +test "InfernalIO supports an explicit tabular format without a header" { + let row = "seq1 SACC RFQ1 QACC cm 1 70 10 79 + no 1 0.50 0.0 20.0 1.0e-05 ! explicit\n" + let results = @src.infernal_parse_tabular(row, format=1) + assert_eq(results.length(), 1) + assert_eq(results[0].id, "RFQ1") +} + +///| +test "InfernalIO parses format 1 core fields" { + let query = @src.infernal_parse_tabular(infernal_format1_text())[0] + assert_eq(query.id, "RFQ1") + assert_eq(query.accession, "QACC") + assert_eq(query.sequence_length, 0) + assert_eq(query.hits[0].id, "seq1") + assert_eq(query.hits[0].accession, "SACC") + assert_eq(query.hits[0].description, "format one target") + assert_eq(query.hits[0].hsps[0].model, "cm") +} + +///| +test "InfernalIO parses format 2 clan lengths and overlap fields" { + let query = @src.infernal_parse_tabular(infernal_format2_text())[0] + let hit = query.hits[0] + let hsp = hit.hsps[0] + assert_eq(query.clan, "CL001") + assert_eq(query.sequence_length, 2000) + assert_eq(hit.model_length, 65) + assert_eq(hsp.overlap, "^") + assert_eq(hsp.any_index, Some(7)) + assert_eq(hsp.winner_index, Some(2)) + assert_eq(hsp.pipeline_pass, 3) +} + +///| +test "InfernalIO parses format 2 overlap fractions" { + let hsp = @src.infernal_parse_tabular(infernal_format2_text())[0].hits[0].hsps[0] + assert_eq(hsp.any_overlap_fraction, Some(0.25)) + assert_eq(hsp.reciprocal_overlap_fraction, Some(0.50)) + assert_eq(hsp.winner_overlap_fraction, Some(0.75)) + assert_eq(hsp.winner_reciprocal_fraction, Some(0.80)) +} + +///| +test "InfernalIO accepts missing format 2 overlap values" { + let text = infernal_format2_text().replace_all( + old="^ 7 0.25 0.50 2 0.75 0.80", + new="= - - - \" \" \"", + ) + let hsp = @src.infernal_parse_tabular(text)[0].hits[0].hsps[0] + assert_eq(hsp.overlap, "=") + assert_true(hsp.any_index is None) + assert_true(hsp.any_overlap_fraction is None) + assert_true(hsp.winner_index is None) + assert_true(hsp.winner_overlap_fraction is None) +} + +///| +test "InfernalIO parses format 3 lengths and descriptions" { + let query = @src.infernal_parse_tabular(@src.infernal_tabular_sample())[0] + assert_eq(query.sequence_length, 1000) + assert_eq(query.hits[0].model_length, 71) + assert_eq(query.hits[0].description, "bacterial 5S RNA locus") +} + +///| +test "InfernalIO normalizes forward coordinates to zero-based half-open" { + let fragment = @src.infernal_parse_tabular(@src.infernal_tabular_sample())[0].hits[0].hsps[0].fragments[0] + assert_eq(fragment.query_start, 0) + assert_eq(fragment.query_end, 71) + assert_eq(fragment.hit_start, 100) + assert_eq(fragment.hit_end, 171) + assert_true(fragment.hit_strand == @src.strand_plus()) +} + +///| +test "InfernalIO normalizes reverse coordinates and retains strand" { + let fragment = @src.infernal_parse_tabular(@src.infernal_tabular_sample())[0].hits[0].hsps[1].fragments[0] + assert_eq(fragment.query_start, 1) + assert_eq(fragment.query_end, 70) + assert_eq(fragment.hit_start, 411) + assert_eq(fragment.hit_end, 480) + assert_true(fragment.hit_strand == @src.strand_minus()) +} + +///| +test "InfernalIO aggregates repeated target rows into HSPs" { + let query = @src.infernal_parse_tabular(@src.infernal_tabular_sample())[0] + assert_eq(query.hits.length(), 1) + assert_eq(query.hits[0].hsps.length(), 2) + assert_eq(query.count_hsps(), 2) +} + +///| +test "InfernalIO preserves query and hit first-seen order" { + let base = @src.infernal_tabular_sample() + let extra = "chrC RFSEQ3 RF00001 RF00001 cm 1 20 700 719 + no 1 0.40 0.0 10.0 0.01 ? 71 1000 later hit\n" + let text = base + extra + let results = @src.infernal_parse_tabular(text) + assert_eq(results.length(), 2) + assert_eq(results[0].id, "RF00001") + assert_eq(results[1].id, "RF00002") + assert_eq(results[0].hits[0].id, "chrA") + assert_eq(results[0].hits[1].id, "chrC") +} + +///| +test "InfernalIO parses inclusion and scientific E-values" { + let hsps = @src.infernal_parse_tabular(@src.infernal_tabular_sample())[0].hits[0].hsps + assert_true(hsps[0].is_included) + assert_false(hsps[1].is_included) + assert_true((hsps[0].evalue - 2.0e-14).abs() < 1.0e-24) +} + +///| +test "InfernalIO rejects unsupported explicit tabular formats" { + assert_true(infernal_tab_raises(infernal_format1_text(), 4)) +} + +///| +test "InfernalIO requires a header for automatic tabular detection" { + let row = "seq1 SACC RFQ1 QACC cm 1 70 10 79 + no 1 0.50 0.0 20.0 1.0e-05 ! explicit\n" + assert_true(infernal_tab_raises(row, 0)) +} + +///| +test "InfernalIO rejects short tabular rows" { + let text = "# target name accession query name accession mdl description of target\nshort row\n" + assert_true(infernal_tab_raises(text, 1)) +} + +///| +test "InfernalIO rejects invalid integer fields" { + let text = infernal_format1_text().replace_all(old="cm 1 70", new="cm x 70") + assert_true(infernal_tab_raises(text, 0)) +} + +///| +test "InfernalIO rejects invalid floating-point fields" { + let text = infernal_format1_text().replace_all( + old="20.0 1.0e-05", + new="bad 1.0e-05", + ) + assert_true(infernal_tab_raises(text, 0)) +} + +///| +test "InfernalIO rejects invalid strand fields" { + let text = infernal_format1_text().replace_all( + old="10 79 + no", + new="10 79 ? no", + ) + assert_true(infernal_tab_raises(text, 0)) +} + +///| +test "InfernalIO rejects non-positive coordinates" { + let text = infernal_format1_text().replace_all(old="cm 1 70", new="cm 0 70") + assert_true(infernal_tab_raises(text, 0)) +} + +///| +test "InfernalIO parses plain-text metadata and query fields" { + let query = @src.infernal_parse_text(@src.infernal_text_sample())[0] + assert_eq(query.id, "RFTEST") + assert_eq(query.accession, "RFTEST.1") + assert_eq(query.description, "synthetic structured RNA") + assert_eq(query.sequence_length, 19) + assert_eq(query.program, "cmsearch") + assert_eq(query.version, "1.1.5") + assert_eq(query.target, "transcripts.fa") +} + +///| +test "InfernalIO parses plain-text CM HSP statistics" { + let hsp = @src.infernal_parse_text(@src.infernal_text_sample())[0].hits[0].hsps[0] + assert_eq(hsp.model, "cm") + assert_eq(hsp.truncated, "no") + assert_eq(hsp.query_end_type, "[]") + assert_eq(hsp.hit_end_type, "..") + assert_true((hsp.bitscore - 45.0).abs() < 1.0e-12) + assert_true((hsp.average_accuracy - 0.96).abs() < 1.0e-12) + assert_true((hsp.gc - 0.50).abs() < 1.0e-12) +} + +///| +test "InfernalIO parses HMM-only pipeline output" { + let text = @src.infernal_text_sample() + .replace_all(old="0.1 cm 1 19", new="0.1 hmm 1 19") + .replace_all( + old="Internal CM pipeline statistics summary:", + new="Internal HMM-only pipeline statistics summary:", + ) + let hsp = @src.infernal_parse_text(text)[0].hits[0].hsps[0] + assert_eq(hsp.model, "hmm") + assert_eq(hsp.fragments.length(), 2) +} + +///| +test "InfernalIO preserves alignment sequences and annotations" { + let fragments = @src.infernal_parse_text(@src.infernal_text_sample())[0].hits[0].hsps[0].fragments + assert_eq(fragments[0].query_sequence, "ACGUACGU") + assert_eq(fragments[0].hit_sequence, "ACGUACGU") + assert_eq(fragments[0].consensus_structure, "(((....)") + assert_eq(fragments[0].posterior_probability, "99999999") + assert_eq(fragments[1].query_sequence, "AACCGG") + assert_eq(fragments[1].hit_sequence, "AACCGG") +} + +///| +test "InfernalIO splits local-end markers into multiple fragments" { + let hsp = @src.infernal_parse_text(@src.infernal_text_sample())[0].hits[0].hsps[0] + assert_eq(hsp.fragments.length(), 2) + assert_eq(hsp.fragments[0].model_omission_before, 0) + assert_eq(hsp.fragments[1].model_omission_before, 5) + assert_eq(hsp.fragments[1].sequence_omission_before, 5) + assert_eq(hsp.alignment_span(), 14) +} + +///| +test "InfernalIO advances coordinates across local ends" { + let fragments = @src.infernal_parse_text(@src.infernal_text_sample())[0].hits[0].hsps[0].fragments + assert_eq(fragments[0].query_start, 0) + assert_eq(fragments[0].query_end, 8) + assert_eq(fragments[0].hit_start, 99) + assert_eq(fragments[0].hit_end, 107) + assert_eq(fragments[1].query_start, 13) + assert_eq(fragments[1].query_end, 19) + assert_eq(fragments[1].hit_start, 112) + assert_eq(fragments[1].hit_end, 118) +} + +///| +test "InfernalIO advances reverse-strand local-end coordinates downward" { + let hsp = @src.infernal_parse_text(infernal_reverse_text())[0].hits[0].hsps[0] + assert_eq(hsp.fragments.length(), 2) + assert_eq(hsp.fragments[0].hit_start, 192) + assert_eq(hsp.fragments[0].hit_end, 200) + assert_eq(hsp.fragments[1].hit_start, 181) + assert_eq(hsp.fragments[1].hit_end, 187) + assert_true(hsp.fragments[1].hit_strand == @src.strand_minus()) + assert_eq(hsp.hit_start(), 181) + assert_eq(hsp.hit_end(), 200) +} + +///| +test "InfernalIO parses noali score tables" { + let query = @src.infernal_parse_text(infernal_noali_text())[0] + assert_eq(query.id, "RFNOALI") + assert_eq(query.target, "noali.fa") + assert_eq(query.hits.length(), 2) + assert_eq(query.count_hsps(), 3) + let fragment = query.hits[0].hsps[0].fragments[0] + assert_eq(fragment.query_start, -1) + assert_eq(fragment.hit_start, 80) + assert_eq(fragment.hit_end, 100) + assert_true(fragment.hit_strand == @src.strand_minus()) +} + +///| +test "InfernalIO merges duplicate noali targets and retains HSP order" { + let hit = @src.infernal_parse_text(infernal_noali_text())[0].hits[0] + assert_eq(hit.id, "seqA") + assert_eq(hit.description, "reverse score hit") + assert_eq(hit.hsps.length(), 2) + assert_true((hit.hsps[0].evalue - 1.0e-08).abs() < 1.0e-18) + assert_eq(hit.hsps[1].model, "hmm") +} + +///| +test "InfernalIO merges repeated alignment target sections" { + let query = @src.infernal_parse_text(infernal_duplicate_alignment_text())[0] + assert_eq(query.hits.length(), 1) + assert_eq(query.hits[0].hsps.length(), 2) + assert_eq(query.hits[0].hsps[1].model, "hmm") +} + +///| +test "InfernalIO returns empty hits for no-hit queries" { + let query = @src.infernal_parse_text(infernal_no_hit_text())[0] + assert_eq(query.id, "empty_query") + assert_eq(query.sequence_length, 25) + assert_eq(query.hits.length(), 0) +} + +///| +test "InfernalIO parses multiple plain-text queries" { + let second = @src.infernal_text_sample() + .replace_all(old="RFTEST", new="RFSECOND") + .replace_all(old="targetA", new="targetB") + let text = @src.infernal_text_sample().replace_all(old="[ok]\n", new="") + + second + let results = @src.infernal_parse_text(text) + assert_eq(results.length(), 2) + assert_eq(results[0].id, "RFTEST") + assert_eq(results[1].id, "RFSECOND") +} + +///| +test "InfernalIO chooses best HSP by E-value then score" { + let hit = @src.infernal_parse_tabular(@src.infernal_tabular_sample())[0].hits[0] + match hit.best_hsp() { + Some(hsp) => { + assert_true((hsp.evalue - 2.0e-14).abs() < 1.0e-24) + assert_true((hsp.bitscore - 48.5).abs() < 1.0e-12) + } + None => abort("expected a best Infernal HSP") + } +} + +///| +test "InfernalIO filters by E-value and inclusion state immutably" { + let query = @src.infernal_parse_tabular(@src.infernal_tabular_sample())[0] + let filtered = query.filter(maximum_evalue=1.0e-10, included_only=true) + assert_eq(filtered.hits.length(), 1) + assert_eq(filtered.count_hsps(), 1) + assert_eq(query.count_hsps(), 2) + assert_true(filtered.hits[0].hsps[0].is_included) +} + +///| +test "InfernalIO rejects invalid filter thresholds" { + let query = @src.infernal_parse_tabular(@src.infernal_tabular_sample())[0] + let raised = try { + ignore(query.filter(maximum_evalue=-1.0)) + false + } catch { + InfernalError(_) => true + } + assert_true(raised) +} + +///| +test "InfernalIO converts to the generic SearchIO hierarchy" { + let source = @src.infernal_parse_tabular(@src.infernal_tabular_sample())[0] + let query = source.to_searchio() + assert_eq(query.id, "RF00001") + assert_eq(query.seq_len, 1000) + assert_eq(query.hits.length(), 1) + assert_eq(query.hits[0].id, "chrA") + assert_eq(query.hits[0].accession, "RFSEQ1") + assert_eq(query.hits[0].hsps.length(), 2) + assert_eq(query.hits[0].hsps[1].fragments[0].hit_start, 411) + assert_true( + query.hits[0].hsps[1].fragments[0].hit_strand == @src.strand_minus(), + ) +} + +///| +test "InfernalIO summarizes query hierarchy counts" { + let query = @src.infernal_parse_tabular(@src.infernal_tabular_sample())[0] + assert_eq( + query.summary(), + "InfernalQueryResult(query=RF00001, hits=1, hsps=2, program=)", + ) +} + +///| +test "InfernalIO rejects malformed text alignment score rows" { + let malformed = @src.infernal_text_sample().replace_all( + old=" 1 ! 2.0e-10 45.0 0.1 cm 1 19 [] 100 118 + .. 0.96 no 0.50\n", + new=" 1 ! 2.0e-10 45.0 0.1 cm 1 19 [] 100 118 + .. 0.96 no\n", + ) + assert_true(infernal_text_raises(malformed)) +} From e66a1f6b864f6ea9ca0bcf1754db062df1c4e27a Mon Sep 17 00:00:00 2001 From: eda Date: Tue, 4 Aug 2026 21:59:26 +0800 Subject: [PATCH 13/41] =?UTF-8?q?#28=20/8593=20feat(variance=5Fpartition):?= =?UTF-8?q?=20LMM=20&=20ML/REML=E3=80=81BLUP=E3=80=81precision=20weights?= =?UTF-8?q?=E3=80=81dream=20SummarizedExperiment?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 24 +- examples/variance_partition_demo/main.mbt | 186 +++ examples/variance_partition_demo/moon.pkg | 6 + src/variance_partition.mbt | 1798 +++++++++++++++++++++ test/moonbit/variance_partition_test.mbt | 855 ++++++++++ 5 files changed, 2865 insertions(+), 4 deletions(-) create mode 100644 examples/variance_partition_demo/main.mbt create mode 100644 examples/variance_partition_demo/moon.pkg create mode 100644 src/variance_partition.mbt create mode 100644 test/moonbit/variance_partition_test.mbt diff --git a/README.md b/README.md index d47bab19..0895c324 100644 --- a/README.md +++ b/README.md @@ -156,6 +156,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | Bio.PDB.mmcifio | mmCIF文件写入: Structure对象序列化(data block/header/atom_site loop)、20列原子坐标格式化、HETATM支持、值转义、round-trip验证 | | ✅ | Bio.SearchIO.InterproscanIO | InterProScan输出解析: TSV 14列格式解析(蛋白质ID/分析数据库/签名/位置/分数/IPR/GO)、按数据库/蛋白质过滤、GO条目提取、按蛋白质分组 | | ✅ | Bio.SearchIO.InfernalIO | Infernal cmscan/cmsearch解析: tabular格式1/2/3自动检测、non-verbose文本与--noali、CM/HMM-only、Query/Hit/HSP/Fragment层次、正负链坐标、local-end多片段、过滤与SearchIO转换 | +| ✅ | Bioconductor variancePartition | 多随机截距线性混合模型、ML/REML方差分量、固定/随机/残差方差占比、precision weights、BLUP、dream contrast、数值Satterthwaite检验、BH-FDR与SummarizedExperiment接入 | | ✅ | Bio.PDB.SASA | 溶剂可及表面积计算: Shrake-Rupley滚动球算法(Fibonacci球面采样)、范德华半径查表、逐原子/残基/链SASA、骨架/侧链拆分 | | ✅ | Bio.SeqIO.NibIO | nib 2-bit二进制序列格式: DNA 2-bit编码(T=0/C=1/A=2/G=3)、4碱基/字节打包、hex I/O、子序列提取、反向互补、GC含量、压缩比 | | ✅ | ChIPseeker | ChIP-seq峰注释: 峰-TSS距离计算、基因组特征分配(Promoter/5'UTR/3'UTR/Exon/Intron/Downstream/Distal Intergenic)、最近基因查找、注释摘要 | @@ -200,6 +201,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **群体遗传学** | Biopython `Bio.PopGen` | 等位基因频率、FST、哈迪-温伯格检验 | ✅ | | **edgeR** | Bioconductor edgeR | 差异表达分析、DGEList、精确检验、GLM拟合 | ✅ | | **limma** | Bioconductor limma | 差异表达分析、线性模型拟合、经验贝叶斯、voom变换、RPKM/CPM/quantile归一化、ComBat/removeBatchEffect批次校正、treat严格检验 | ✅ | +| **variancePartition** | Bioconductor variancePartition | 重复测量线性混合模型、方差分解、BLUP、precision weights、dream contrast与Satterthwaite检验 | ✅ | | **SummarizedExperiment** | Bioconductor SummarizedExperiment | 多维基因组数据容器、Assays、行/列操作 | ✅ | | **RangedSummarizedExperiment** | Bioconductor SummarizedExperiment | GRanges/GRangesList行范围、复合特征精确重叠/最近邻、覆盖度、区间变换与协调子集 | ✅ | | **TreeSummarizedExperiment** | Bioconductor TreeSummarizedExperiment | 行/列树、节点链接、树节点子集、祖先/后代查询、层级聚合 | ✅ | @@ -536,6 +538,7 @@ IvanAXu/BioSeqs/ │ ├── scran.mbt # scran 单细胞归一化与聚类 (sum_factors、SNN图、Leiden聚类、标志物分析) │ ├── scrapper.mbt # scrapper 单细胞预处理 (批次感知RNA QC、大小因子、LOWESS/HVG、pseudo-bulk、SCE集成) │ ├── milo.mbt # miloR KNN邻域差异丰度 (精炼采样、NB-GLM、graph spatial FDR、SCE接入) +│ ├── variance_partition.mbt # variancePartition 混合模型方差分解、BLUP与dream重复测量检验 │ ├── monocle3.mbt # monocle3 单细胞轨迹分析 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read.mbt # ShortRead 短读序列质量控制 (QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告) │ ├── seq_quality_trim.mbt # NGS质量修剪与接头去除 (质量修剪、接头去除、poly-A修剪、长度/GC过滤、批量修剪) @@ -881,6 +884,7 @@ IvanAXu/BioSeqs/ │ ├── scran_demo/ # scran 单细胞归一化与聚类示例 (sum_factors、SNN图、Leiden聚类、标志物分析) │ ├── scrapper_demo/ # scrapper 批次感知RNA QC、归一化、LOWESS/HVG、pseudo-bulk与SCE集成示例 │ ├── milo_demo/ # miloR KNN图、精炼邻域、NB差异丰度、spatial FDR与SCE接入示例 +│ ├── variance_partition_demo/ # variancePartition 方差分解、BLUP、precision weights、dream与SE接入示例 │ ├── monocle3_demo/ # monocle3 单细胞轨迹分析示例 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read_demo/ # ShortRead 短读序列质量控制示例 (QA统计、adapter修剪、质量修剪、FastQC报告) │ ├── scater_demo/ # scater 单细胞质量控制示例 (QC指标计算、细胞/基因过滤、标准化、HVG检测、PCA) @@ -1279,6 +1283,7 @@ IvanAXu/BioSeqs/ │ │ ├── scran_test.mbt │ │ ├── scrapper_test.mbt │ │ ├── milo_test.mbt +│ │ ├── variance_partition_test.mbt │ │ ├── search_io_test.mbt │ │ ├── searchio_new_test.mbt │ │ ├── seq_complexity_test.mbt @@ -1455,7 +1460,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8555 个测试全部通过 +moon test # ✅ 8593 个测试全部通过 ``` ### 模块对照表 @@ -1555,6 +1560,7 @@ moon test # ✅ 8555 个测试全 | `edger.mbt` | Bioconductor edgeR | DGEList 差异表达 | | `edger_advanced.mbt` | edgeR QLF/Camera/Roast | 准似然F检验、QL分散度估计、camera竞争性基因集检验、roast自足基因集检验 | | `limma.mbt` | Bioconductor limma | 线性模型与 voom 变换 | +| `variance_partition.mbt` | Bioconductor variancePartition | 多随机截距LMM、ML/REML方差分量、固定/随机/残差占比、BLUP、precision weights、dream contrast、数值Satterthwaite与BH-FDR | | `summarized_experiment.mbt` | Bioconductor SummarizedExperiment | 多维数据容器 | | `ranged_summarized_experiment.mbt` | Bioconductor RangedSummarizedExperiment | GRanges/GRangesList行范围、链特异重叠/最近邻、覆盖度、区间变换与协调子集 | | `tree_summarized_experiment.mbt` | Bioconductor TreeSummarizedExperiment | 行/列树与数据链接、按节点子集、层级聚合 | @@ -1759,6 +1765,7 @@ moon test # ✅ 8555 个测试全 | `muscat.mbt` | `muscat` | 单细胞差异状态分析（伪批量聚合、DS 检验、QC） | | `scrapper.mbt` | `scrapper` | 批次感知RNA QC、大小因子清洗/居中、count与log归一化、LOWESS方差趋势、HVG选择、多因子pseudo-bulk、SingleCellExperiment不可变包装 | | `milo.mbt` | `miloR` | 精确KNN图、median精炼重叠邻域、邻域计数/表达、固定效应NB-GLM/Wald检验、graph spatial FDR与SCE接入 | +| `variance_partition.mbt` | `variancePartition` | typed fixed/random design、多随机截距LMM、ML/REML方差分解、BLUP、weighted dream contrast、Satterthwaite自由度与SummarizedExperiment入口 | | `infercnv.mbt` | `infercnv` | 单细胞拷贝数变异推断（基因组位置排序、参考细胞有界 LFC 计算、金字塔权重平滑、CNV 分数与恶性细胞预测） | | `scenic.mbt` | `SCENIC` | 单细胞调控网络推断与聚类（TF-target 共表达模块、Regulon 构建、AUCell 活性评分、二值化阈值、细胞状态与主控调控因子） | | `cibersort.mbt` | `CIBERSORT` | 免疫细胞去卷积（NNLS 求解、LM22 风格特征矩阵、Pearson 拟合优度、分数归一化） | @@ -2829,6 +2836,12 @@ moon test # ✅ 8555 个测试全 `infernal_parse_text` 支持 non-verbose plain text、`--noali`、CM pipeline 和 HMM-only pipeline，解析 query metadata、hit score、模型/序列比对及 CS、NC、similarity、PP 注释。模型和序列中的 `*[NN]*` local-end 标记会同步拆分为多个 fragment，并记录两侧 omission 长度和链方向坐标。查询 API 提供 best-HSP、E-value/included 过滤、摘要及到通用 `QueryResult` 的转换。当前范围不包括 verbose text、writer 或完整 Infernal 命令行封装。 +### 248. 重复测量方差分解与差异表达 (Bioconductor variancePartition) + +实现 Bioconductor `variancePartition`/`dream` 的可移植线性混合模型核心。`vp_numeric_effect`、`vp_categorical_effect`、`vp_random_effect` 和 `vp_design` 使用 typed design 表达连续变量、分类固定效应及稳定 level 编码的随机截距，避免解析 R formula 字符串。每个基因拟合 `y = Xβ + ΣZₖbₖ + ε`，以 Cholesky/GLS 计算固定效应，并在 log-variance 空间用 ML 或 REML 估计多个随机效应及异方差残差；`fit_extract_variance_partition` 按上游语义默认使用 ML。结果报告每个固定 term 的 `var(Xⱼβⱼ)`、随机方差、残差方差、归一化占比、拟合值、残差和各 level 的 BLUP。 + +observation-level precision weights 会先缩放到均值 1，并进入 `V = ΣτₖZₖZₖᵀ + σ²diag(1/w)`。`dream`/`dream_se` 对任意固定效应 contrast 计算估计值、标准误、数值 Satterthwaite 自由度、双侧 Student-t p 值和 BH-FDR；`fit_extract_variance_partition_se` 与 `dream_se` 可直接读取 `SummarizedExperiment` 的表达和 weights assay。当前范围支持随机截距，不包括随机斜率、Kenward-Roger、voom mean-variance trend、limma empirical Bayes、缺失值省略及上游绘图接口。 + ## 性能优化 ### 优化策略 @@ -2930,8 +2943,8 @@ moon test # ✅ 8555 个测试全 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8555 | -| 通过数 | 8555 | +| 总测试数 | 8593 | +| 通过数 | 8593 | | 失败数 | 0 | | 通过率 | 100% | @@ -3232,6 +3245,7 @@ moon test --update | Bio.SearchIO.HmmerIO | `hmmer_io_test.mbt` | 19 | | Bio.SearchIO.FastaIO | `fasta_search_io_test.mbt` | 19 | | Bio.SearchIO.InfernalIO | `infernal_io_test.mbt` | 37 | +| Bioconductor variancePartition | `variance_partition_test.mbt` | 38 | | Bio.PopGen.GenePop | `gene_pop_test.mbt` | 34 | | Bioconductor stageR | `stage_r_test.mbt` | 25 | | Bioconductor EnrichedHeatmap | `enriched_heatmap_test.mbt` | 20 | @@ -3327,7 +3341,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 355 个示例程序，展示各模块的典型用法： +项目提供 356 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3512,6 +3526,7 @@ moon run cmd/bench/main.mbt | hmmer_io_demo | HMMER3输出解析（domtblout域表、文本格式、Query/Hit/HSP聚合、多域比对） | `moon run examples/hmmer_io_demo/main.mbt` | | fasta_search_io_demo | FASTA搜索输出解析（-m8表格、-m9注释头、元数据、Query/Hit/HSP聚合） | `moon run examples/fasta_search_io_demo/main.mbt` | | infernal_io_demo | Infernal cmscan/cmsearch解析（tabular 3、non-verbose文本、local-end片段、过滤与SearchIO转换） | `moon run examples/infernal_io_demo` | +| variance_partition_demo | typed固定/随机设计、ML方差分解、BLUP、precision weights、dream contrast与SummarizedExperiment接入 | `moon run examples/variance_partition_demo` | | gene_pop_demo | GenePop群体遗传学（基因型解析、等位基因频率、杂合度统计、序列化往返） | `moon run examples/gene_pop_demo/main.mbt` | | stage_r_demo | stageR两阶段假设检验（筛选+确认、Simes聚合、BH-FDR、Holm步降、OFDR控制） | `moon run examples/stage_r_demo/main.mbt` | | enriched_heatmap_demo | EnrichedHeatmap富集热图（信号归一化、四种均值模式、行平滑、链方向处理） | `moon run examples/enriched_heatmap_demo/main.mbt` | @@ -3615,6 +3630,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bio.PDB.binary_cif BinaryCIF解析（MessagePack、七类逆编码、三态mask、类别查询与PDB Structure转换） - ✅ 实现 Bioconductor miloR 单细胞邻域差异丰度（精确KNN图、median精炼采样、邻域计数、固定效应NB-GLM、graph spatial FDR与SCE接入） - ✅ 实现 Bio.SearchIO.InfernalIO Infernal cmscan/cmsearch输出解析（tabular 1/2/3、non-verbose文本、--noali、CM/HMM-only、local-end多片段与SearchIO转换） +- ✅ 实现 Bioconductor variancePartition 重复测量混合模型（ML/REML方差分解、BLUP、precision weights、dream contrast、数值Satterthwaite、BH-FDR与SummarizedExperiment接入） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/variance_partition_demo/main.mbt b/examples/variance_partition_demo/main.mbt new file mode 100644 index 00000000..0fd31a6b --- /dev/null +++ b/examples/variance_partition_demo/main.mbt @@ -0,0 +1,186 @@ +///| +fn demo_samples() -> Array[String] { + let samples : Array[String] = [] + for subject in 0..<4 { + for replicate in 0..<4 { + samples.push( + "S" + (subject + 1).to_string() + "_R" + (replicate + 1).to_string(), + ) + } + } + samples +} + +///| +fn demo_subjects() -> Array[String] { + let subjects : Array[String] = [] + for subject in 0..<4 { + for _ in 0..<4 { + subjects.push("S" + (subject + 1).to_string()) + } + } + subjects +} + +///| +fn demo_treatments() -> Array[String] { + let treatments : Array[String] = [] + for _ in 0..<4 { + treatments.push("Control") + treatments.push("Treated") + treatments.push("Control") + treatments.push("Treated") + } + treatments +} + +///| +fn demo_subject_gene() -> Array[Double] { + let values : Array[Double] = [] + let noise = [0.08, 0.04, -0.08, -0.04] + for subject in 0..<4 { + let subject_effect = (subject.to_double() - 1.5) * 2.0 + for replicate in 0..<4 { + values.push(10.0 + subject_effect + noise[replicate]) + } + } + values +} + +///| +fn demo_treatment_gene() -> Array[Double] { + let values : Array[Double] = [] + let noise = [0.05, -0.03, -0.05, 0.03] + for subject in 0..<4 { + let subject_effect = (subject.to_double() - 1.5) * 0.08 + for replicate in 0..<4 { + let treatment_effect = if replicate % 2 == 1 { 4.0 } else { 0.0 } + values.push(6.0 + subject_effect + treatment_effect + noise[replicate]) + } + } + values +} + +///| +fn main { + println("=== Bioconductor variancePartition Demo ===") + let treatment = @src.vp_categorical_effect( + "Treatment", + demo_treatments(), + reference="Control", + ) catch { + _ => abort("failed to encode treatment") + } + let subject = @src.vp_random_effect("Subject", demo_subjects()) catch { + _ => abort("failed to encode subject") + } + let design = @src.vp_design(demo_samples(), [treatment], [subject]) catch { + _ => abort("failed to build mixed-model design") + } + let expression = [demo_subject_gene(), demo_treatment_gene()] + let weights = [ + Array::make(16, 1.0), + [ + 0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, + 1.0, + ], + ] + + println("\n1. Typed fixed and random effects") + println(" coefficients: " + design.coefficient_names.to_string()) + println(" random effect: " + design.random_effects[0].name) + println(" levels: " + design.random_effects[0].levels.to_string()) + + println("\n2. ML variance fractions with observation-level weights") + let partition = @src.fit_extract_variance_partition( + expression, + design, + gene_names=["subject_gene", "treatment_gene"], + weights~, + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("failed to partition variance") + } + println(partition.summary()) + for fit in partition.fits { + println(" " + fit.gene_name + ":") + for component in 0.. abort("failed to build treatment contrast") + } + let differential = @src.dream( + expression, + design, + contrast, + gene_names=["subject_gene", "treatment_gene"], + weights~, + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("failed to run dream") + } + for gene in differential.genes { + println( + " " + + gene.gene_name + + ": estimate=" + + gene.estimate.to_string() + + ", t=" + + gene.statistic.to_string() + + ", df=" + + gene.degrees_of_freedom.to_string() + + ", FDR=" + + gene.adjusted_p_value.to_string(), + ) + } + + println("\n5. SummarizedExperiment assay integration") + let experiment = @src.summarized_experiment( + Map([("logcounts", expression), ("weights", weights)]), + [], + [], + Map([("study", "repeated-measures-demo")]), + ) + let assay_result = @src.dream_se( + experiment, + "logcounts", + design, + contrast, + gene_names=["subject_gene", "treatment_gene"], + weights_assay="weights", + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("failed to run assay-backed dream") + } + println(" " + assay_result.summary()) + + println( + "\nScope: random intercepts and numerical Satterthwaite tests; random slopes, Kenward-Roger, voom/eBayes and plotting are not included.", + ) + println("\n=== Demo Complete ===") +} diff --git a/examples/variance_partition_demo/moon.pkg b/examples/variance_partition_demo/moon.pkg new file mode 100644 index 00000000..8824b1ac --- /dev/null +++ b/examples/variance_partition_demo/moon.pkg @@ -0,0 +1,6 @@ +import { + "IvanAXu/BioSeqs/src", + "moonbitlang/core/hashmap", +} + +pkgtype(kind: "executable") diff --git a/src/variance_partition.mbt b/src/variance_partition.mbt new file mode 100644 index 00000000..31aee5af --- /dev/null +++ b/src/variance_partition.mbt @@ -0,0 +1,1798 @@ +///| +/// Gene-level variance decomposition and repeated-measures differential +/// expression inspired by Bioconductor variancePartition. + +///| +pub suberror VariancePartitionError { + VariancePartitionError(String) +} + +///| +pub struct VariancePartitionFixedEffect { + name : String + column_names : Array[String] + columns : Array[Array[Double]] +} derive(Debug) + +///| +pub struct VariancePartitionRandomEffect { + name : String + levels : Array[String] + level_indices : Array[Int] +} derive(Debug) + +///| +pub struct VariancePartitionDesign { + sample_names : Array[String] + fixed_effects : Array[VariancePartitionFixedEffect] + random_effects : Array[VariancePartitionRandomEffect] + matrix : Array[Array[Double]] + coefficient_names : Array[String] + fixed_starts : Array[Int] + fixed_widths : Array[Int] + intercept : Bool +} derive(Debug) + +///| +pub struct VariancePartitionBLUP { + effect_name : String + levels : Array[String] + estimates : Array[Double] +} derive(Debug) + +///| +pub struct VariancePartitionFit { + gene_name : String + coefficient_names : Array[String] + coefficients : Array[Double] + coefficient_covariance : Array[Array[Double]] + fixed_effect_names : Array[String] + fixed_variances : Array[Double] + random_effect_names : Array[String] + random_variances : Array[Double] + residual_variance : Double + component_names : Array[String] + variance_fractions : Array[Double] + blups : Array[VariancePartitionBLUP] + fitted_values : Array[Double] + residuals : Array[Double] + log_likelihood : Double + converged : Bool + iterations : Int + reml : Bool +} derive(Debug) + +///| +pub struct VariancePartitionResult { + gene_names : Array[String] + component_names : Array[String] + fractions : Array[Array[Double]] + median_fractions : Array[Double] + fits : Array[VariancePartitionFit] +} derive(Debug) + +///| +pub struct DreamContrast { + name : String + coefficients : Array[Double] +} derive(Debug) + +///| +pub struct DreamGeneResult { + gene_name : String + estimate : Double + standard_error : Double + statistic : Double + degrees_of_freedom : Double + p_value : Double + adjusted_p_value : Double + converged : Bool + random_variances : Array[Double] + residual_variance : Double +} derive(Debug) + +///| +pub struct DreamResult { + contrast_name : String + coefficient_names : Array[String] + genes : Array[DreamGeneResult] +} derive(Debug) + +///| +priv struct VariancePartitionEvaluation { + objective : Double + beta : Array[Double] + beta_covariance : Array[Array[Double]] + fixed_fitted : Array[Double] + marginal_residual : Array[Double] + covariance_cholesky : Array[Array[Double]] +} + +///| +priv struct VariancePartitionCoreFit { + evaluation : VariancePartitionEvaluation + log_variances : Array[Double] + variances : Array[Double] + weights : Array[Double] + converged : Bool + iterations : Int +} + +///| +fn vp_is_finite(value : Double) -> Bool { + value == value && value.abs() < 1.0e300 +} + +///| +fn vp_find_string(values : Array[String], target : String) -> Int { + for index in 0.. Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for _ in 0.. Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in matrix { + output.push(row.copy()) + } + output +} + +///| +fn vp_dot(left : Array[Double], right : Array[Double]) -> Double { + let mut total = 0.0 + for index in 0.. Double { + if values.length() == 0 { + return 0.0 + } + let mut total = 0.0 + for value in values { + total = total + value + } + total / values.length().to_double() +} + +///| +fn vp_sample_variance(values : Array[Double]) -> Double { + if values.length() < 2 { + return 0.0 + } + let mean = vp_mean(values) + let mut total = 0.0 + for value in values { + let difference = value - mean + total = total + difference * difference + } + total / (values.length() - 1).to_double() +} + +///| +fn vp_matrix_vector( + matrix : Array[Array[Double]], + vector : Array[Double], +) -> Array[Double] { + let output = Array::make(matrix.length(), 0.0) + for row in 0.. Array[Array[Double]]? { + let size = matrix.length() + if size == 0 { + return None + } + let lower = vp_zero_matrix(size, size) + for row in 0.. Array[Double] { + let size = lower.length() + let forward = Array::make(size, 0.0) + for row in 0..= 0 { + let mut value = forward[row] + for column in (row + 1).. Array[Array[Double]] { + let size = lower.length() + let inverse = vp_zero_matrix(size, size) + for column in 0.. Double { + let mut value = 0.0 + for index in 0.. Array[Array[Double]]? { + let size = matrix.length() + if size == 0 { + return None + } + let augmented = vp_zero_matrix(size, 2 * size) + for row in 0.. pivot_value { + pivot_row = candidate + pivot_value = value + } + } + if pivot_value < 1.0e-12 { + return None + } + if pivot_row != pivot_column { + let temporary = augmented[pivot_column] + augmented[pivot_column] = augmented[pivot_row] + augmented[pivot_row] = temporary + } + let divisor = augmented[pivot_column][pivot_column] + for column in 0..<(2 * size) { + augmented[pivot_column][column] = augmented[pivot_column][column] / + divisor + } + for row in 0.. Unit raise VariancePartitionError { + if name == "" { + raise VariancePartitionError( + "variancePartition " + kind + " name must not be empty", + ) + } +} + +///| +pub fn vp_numeric_effect( + name : String, + values : Array[Double], +) -> VariancePartitionFixedEffect raise VariancePartitionError { + vp_validate_name(name, "fixed effect") + if values.length() == 0 { + raise VariancePartitionError( + "variancePartition numeric effect must contain observations", + ) + } + let columns : Array[Array[Double]] = [] + for value in values { + if !vp_is_finite(value) { + raise VariancePartitionError( + "variancePartition numeric effects must be finite", + ) + } + columns.push([value]) + } + VariancePartitionFixedEffect::{ name, column_names: [name], columns } +} + +///| +pub fn vp_categorical_effect( + name : String, + values : Array[String], + reference? : String = "", +) -> VariancePartitionFixedEffect raise VariancePartitionError { + vp_validate_name(name, "fixed effect") + if values.length() == 0 { + raise VariancePartitionError( + "variancePartition categorical effect must contain observations", + ) + } + let levels : Array[String] = [] + for value in values { + if value == "" { + raise VariancePartitionError( + "variancePartition categorical levels must not be empty", + ) + } + if !levels.contains(value) { + levels.push(value) + } + } + if levels.length() < 2 { + raise VariancePartitionError( + "variancePartition categorical effect requires at least two levels", + ) + } + let selected_reference = if reference == "" { levels[0] } else { reference } + if !levels.contains(selected_reference) { + raise VariancePartitionError( + "variancePartition categorical reference level is absent", + ) + } + let encoded_levels : Array[String] = [] + for level in levels { + if level != selected_reference { + encoded_levels.push(level) + } + } + let columns : Array[Array[Double]] = [] + for value in values { + let row = Array::make(encoded_levels.length(), 0.0) + for column in 0.. VariancePartitionRandomEffect raise VariancePartitionError { + vp_validate_name(name, "random effect") + if values.length() == 0 { + raise VariancePartitionError( + "variancePartition random effect must contain observations", + ) + } + let levels : Array[String] = [] + let indices : Array[Int] = [] + for value in values { + if value == "" { + raise VariancePartitionError( + "variancePartition random-effect levels must not be empty", + ) + } + let existing = vp_find_string(levels, value) + if existing >= 0 { + indices.push(existing) + } else { + levels.push(value) + indices.push(levels.length() - 1) + } + } + if levels.length() < 2 { + raise VariancePartitionError( + "variancePartition random effect requires at least two levels", + ) + } + if levels.length() >= values.length() { + raise VariancePartitionError( + "variancePartition random effects require replicated levels", + ) + } + VariancePartitionRandomEffect::{ name, levels, level_indices: indices } +} + +///| +pub fn vp_design( + sample_names : Array[String], + fixed_effects : Array[VariancePartitionFixedEffect], + random_effects : Array[VariancePartitionRandomEffect], + intercept? : Bool = true, +) -> VariancePartitionDesign raise VariancePartitionError { + let observations = sample_names.length() + if observations < 3 { + raise VariancePartitionError( + "variancePartition design requires at least three samples", + ) + } + let seen_samples : Map[String, Bool] = Map([], capacity=observations) + for sample in sample_names { + if sample == "" || seen_samples.contains(sample) { + raise VariancePartitionError( + "variancePartition sample names must be non-empty and unique", + ) + } + seen_samples[sample] = true + } + let seen_effects : Map[String, Bool] = Map( + [], + capacity=fixed_effects.length() + random_effects.length(), + ) + let coefficient_names : Array[String] = [] + if intercept { + coefficient_names.push("(Intercept)") + } + let fixed_starts : Array[Int] = [] + let fixed_widths : Array[Int] = [] + let copied_fixed : Array[VariancePartitionFixedEffect] = [] + let mut coefficient_count = if intercept { 1 } else { 0 } + for effect in fixed_effects { + vp_validate_name(effect.name, "fixed effect") + if seen_effects.contains(effect.name) { + raise VariancePartitionError( + "variancePartition effect names must be unique", + ) + } + seen_effects[effect.name] = true + if effect.columns.length() != observations || + effect.column_names.length() == 0 { + raise VariancePartitionError( + "variancePartition fixed-effect dimensions do not match samples", + ) + } + let width = effect.column_names.length() + for row in effect.columns { + if row.length() != width { + raise VariancePartitionError( + "variancePartition fixed-effect matrix must be rectangular", + ) + } + for value in row { + if !vp_is_finite(value) { + raise VariancePartitionError( + "variancePartition fixed-effect values must be finite", + ) + } + } + } + fixed_starts.push(coefficient_count) + fixed_widths.push(width) + coefficient_count = coefficient_count + width + for column_name in effect.column_names { + coefficient_names.push(column_name) + } + copied_fixed.push(VariancePartitionFixedEffect::{ + name: effect.name, + column_names: effect.column_names.copy(), + columns: vp_copy_matrix(effect.columns), + }) + } + let copied_random : Array[VariancePartitionRandomEffect] = [] + for effect in random_effects { + vp_validate_name(effect.name, "random effect") + if seen_effects.contains(effect.name) { + raise VariancePartitionError( + "variancePartition effect names must be unique", + ) + } + seen_effects[effect.name] = true + if effect.level_indices.length() != observations { + raise VariancePartitionError( + "variancePartition random-effect dimensions do not match samples", + ) + } + if effect.levels.length() < 2 || effect.levels.length() >= observations { + raise VariancePartitionError( + "variancePartition random effects require replicated levels", + ) + } + for index in effect.level_indices { + if index < 0 || index >= effect.levels.length() { + raise VariancePartitionError( + "variancePartition random-effect level index is invalid", + ) + } + } + copied_random.push(VariancePartitionRandomEffect::{ + name: effect.name, + levels: effect.levels.copy(), + level_indices: effect.level_indices.copy(), + }) + } + if coefficient_count == 0 || coefficient_count >= observations { + raise VariancePartitionError( + "variancePartition fixed-effect design has no residual degrees of freedom", + ) + } + let matrix = vp_zero_matrix(observations, coefficient_count) + for sample in 0.. DreamContrast raise VariancePartitionError { + vp_validate_name(name, "contrast") + let index = vp_find_string(design.coefficient_names, coefficient_name) + if index < 0 { + raise VariancePartitionError( + "variancePartition contrast coefficient is absent from the design", + ) + } + let coefficients = Array::make(design.coefficient_names.length(), 0.0) + coefficients[index] = 1.0 + DreamContrast::{ name, coefficients } +} + +///| +pub fn vp_contrast( + name : String, + coefficients : Array[Double], +) -> DreamContrast raise VariancePartitionError { + vp_validate_name(name, "contrast") + if coefficients.length() == 0 { + raise VariancePartitionError( + "variancePartition contrast must contain coefficients", + ) + } + let mut magnitude = 0.0 + for coefficient in coefficients { + if !vp_is_finite(coefficient) { + raise VariancePartitionError( + "variancePartition contrast coefficients must be finite", + ) + } + magnitude = magnitude + coefficient.abs() + } + if magnitude == 0.0 { + raise VariancePartitionError( + "variancePartition contrast must not be all zero", + ) + } + DreamContrast::{ name, coefficients: coefficients.copy() } +} + +///| +fn vp_scale_weights( + weights : Array[Double], + observations : Int, +) -> Array[Double] raise VariancePartitionError { + if weights.length() == 0 { + return Array::make(observations, 1.0) + } + if weights.length() != observations { + raise VariancePartitionError( + "variancePartition precision weights must match the samples", + ) + } + let mut total = 0.0 + for weight in weights { + if !vp_is_finite(weight) || weight <= 0.0 { + raise VariancePartitionError( + "variancePartition precision weights must be finite and positive", + ) + } + total = total + weight + } + let mean = total / observations.to_double() + let scaled = Array::make(observations, 0.0) + for index in 0.. Array[Array[Double]] { + let observations = design.sample_names.length() + let covariance = vp_zero_matrix(observations, observations) + for effect_index in 0.. VariancePartitionEvaluation? { + let observations = expression.length() + let parameters = design.coefficient_names.length() + let variances = Array::make(log_variances.length(), 0.0) + for index in 0.. value + None => return None + } + let inverse_expression = vp_cholesky_solve(covariance_cholesky, expression) + let inverse_design = vp_zero_matrix(observations, parameters) + for column in 0.. value + None => return None + } + let beta = vp_cholesky_solve(information_cholesky, right_hand_side) + let beta_covariance = vp_cholesky_inverse(information_cholesky) + let fixed_fitted = vp_matrix_vector(design.matrix, beta) + let marginal_residual = Array::make(observations, 0.0) + for index in 0.. VariancePartitionCoreFit raise VariancePartitionError { + let observations = design.sample_names.length() + if expression.length() != observations { + raise VariancePartitionError( + "variancePartition expression values must match the samples", + ) + } + for value in expression { + if !vp_is_finite(value) { + raise VariancePartitionError( + "variancePartition expression values must be finite", + ) + } + } + if max_iterations <= 0 { + raise VariancePartitionError( + "variancePartition max_iterations must be positive", + ) + } + if !vp_is_finite(tolerance) || tolerance <= 0.0 || tolerance >= 1.0 { + raise VariancePartitionError( + "variancePartition tolerance must be between zero and one", + ) + } + let scaled_weights = vp_scale_weights(weights, observations) + let component_count = design.random_effects.length() + 1 + let observed_variance = vp_sample_variance(expression).max(1.0e-8) + let initial = Array::make(component_count, 0.0) + if component_count == 1 { + initial[0] = observed_variance + } else { + let random_total = observed_variance * 0.5 + for index in 0..<(component_count - 1) { + initial[index] = random_total / (component_count - 1).to_double() + } + initial[component_count - 1] = observed_variance * 0.5 + } + let log_variances = Array::make(component_count, 0.0) + for index in 0.. value + None => + raise VariancePartitionError( + "variancePartition initial mixed model is not positive definite", + ) + } + let mut step = 1.0 + let mut iterations = 0 + while iterations < max_iterations && step > tolerance { + let mut improved = false + for parameter in 0.. + if candidate.objective + 1.0e-10 < best_evaluation.objective { + best_parameter = lower_candidate + best_evaluation = candidate + } + None => () + } + } + if upper_candidate != original { + log_variances[parameter] = upper_candidate + match + vp_evaluate_model( + expression, design, log_variances, scaled_weights, reml, + ) { + Some(candidate) => + if candidate.objective + 1.0e-10 < best_evaluation.objective { + best_parameter = upper_candidate + best_evaluation = candidate + } + None => () + } + } + log_variances[parameter] = best_parameter + if best_parameter != original { + current = best_evaluation + improved = true + } + } + if !improved { + step = step * 0.5 + } + iterations = iterations + 1 + } + let variances = Array::make(component_count, 0.0) + for index in 0.. Array[VariancePartitionBLUP] { + let solved_residual = vp_cholesky_solve( + core.evaluation.covariance_cholesky, + core.evaluation.marginal_residual, + ) + let output : Array[VariancePartitionBLUP] = [] + for effect_index in 0.. VariancePartitionFit { + let fixed_variances : Array[Double] = [] + let fixed_names : Array[String] = [] + for effect_index in 0.. VariancePartitionFit raise VariancePartitionError { + if gene_name == "" { + raise VariancePartitionError( + "variancePartition gene name must not be empty", + ) + } + let core = vp_fit_core( + expression, design, weights, reml, max_iterations, tolerance, + ) + vp_public_fit(gene_name, expression, design, core, reml) +} + +///| +pub fn VariancePartitionFit::fraction( + self : VariancePartitionFit, + component : String, +) -> Double? { + let index = vp_find_string(self.component_names, component) + if index < 0 { + None + } else { + Some(self.variance_fractions[index]) + } +} + +///| +pub fn VariancePartitionFit::blup( + self : VariancePartitionFit, + effect : String, + level : String, +) -> Double? { + for values in self.blups { + if values.effect_name == effect { + let index = vp_find_string(values.levels, level) + if index >= 0 { + return Some(values.estimates[index]) + } + return None + } + } + None +} + +///| +fn vp_validate_expression_matrix( + expression : Array[Array[Double]], + gene_names : Array[String], + samples : Int, + weights : Array[Array[Double]], +) -> Array[String] raise VariancePartitionError { + if expression.length() == 0 { + raise VariancePartitionError( + "variancePartition expression matrix must contain genes", + ) + } + let names : Array[String] = [] + if gene_names.length() == 0 { + for index in 0.. 0 { + if weights.length() != expression.length() { + raise VariancePartitionError( + "variancePartition weights must match expression rows", + ) + } + for row in weights { + if row.length() != samples { + raise VariancePartitionError( + "variancePartition weights must match expression columns", + ) + } + } + } + names +} + +///| +fn vp_median(values : Array[Double]) -> Double { + if values.length() == 0 { + return 0.0 + } + let sorted = values.copy() + sorted.sort_by(fn(left : Double, right : Double) -> Int { + if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + let middle = sorted.length() / 2 + if sorted.length() % 2 == 1 { + sorted[middle] + } else { + (sorted[middle - 1] + sorted[middle]) / 2.0 + } +} + +///| +pub fn fit_extract_variance_partition( + expression : Array[Array[Double]], + gene_names? : Array[String] = [], + design : VariancePartitionDesign, + weights? : Array[Array[Double]] = [], + reml? : Bool = false, + max_iterations? : Int = 100, + tolerance? : Double = 0.005, +) -> VariancePartitionResult raise VariancePartitionError { + let names = vp_validate_expression_matrix( + expression, + gene_names, + design.sample_names.length(), + weights, + ) + let fits : Array[VariancePartitionFit] = [] + let fractions : Array[Array[Double]] = [] + for gene in 0.. VariancePartitionResult raise VariancePartitionError { + let expression = match se_assay(experiment, assay_name) { + Some(value) => value + None => + raise VariancePartitionError( + "variancePartition assay is absent from SummarizedExperiment", + ) + } + let weights = if weights_assay == "" { + [] + } else { + match se_assay(experiment, weights_assay) { + Some(value) => value + None => + raise VariancePartitionError( + "variancePartition weights assay is absent from SummarizedExperiment", + ) + } + } + fit_extract_variance_partition( + expression, + design, + gene_names~, + weights~, + reml~, + max_iterations~, + tolerance~, + ) +} + +///| +pub fn VariancePartitionResult::fraction( + self : VariancePartitionResult, + gene : String, + component : String, +) -> Double? { + let gene_index = vp_find_string(self.gene_names, gene) + let component_index = vp_find_string(self.component_names, component) + if gene_index < 0 || component_index < 0 { + None + } else { + Some(self.fractions[gene_index][component_index]) + } +} + +///| +pub fn VariancePartitionResult::summary( + self : VariancePartitionResult, +) -> String { + let mut output = "variancePartition Summary\n" + output = output + "Genes: " + self.gene_names.length().to_string() + "\n" + for index in 0.. Double { + let mut value = 0.0 + for row in 0.. Double? { + match vp_evaluate_model(expression, design, log_variances, weights, reml) { + Some(value) => Some(value.objective) + None => None + } +} + +///| +fn vp_satterthwaite_df( + expression : Array[Double], + design : VariancePartitionDesign, + contrast : Array[Double], + core : VariancePartitionCoreFit, + reml : Bool, +) -> Double { + let residual_df = (expression.length() - design.coefficient_names.length()) + .to_double() + .max(1.0) + let base_variance = vp_contrast_variance( + core.evaluation.beta_covariance, + contrast, + ) + if base_variance <= 1.0e-20 { + return residual_df + } + let parameters = core.log_variances.length() + let step = 0.05 + let base_objective = core.evaluation.objective + let hessian = vp_zero_matrix(parameters, parameters) + let gradient = Array::make(parameters, 0.0) + for left in 0.. { + let positive_variance = vp_contrast_variance( + positive.beta_covariance, + contrast, + ) + let negative_variance = vp_contrast_variance( + negative.beta_covariance, + contrast, + ) + gradient[left] = (positive_variance - negative_variance) / (2.0 * step) + hessian[left][left] = ( + positive.objective - 2.0 * base_objective + negative.objective + ) / + (step * step) + } + _ => return residual_df + } + for right in (left + 1).. { + let value = (a - b - c + d) / (4.0 * step * step) + hessian[left][right] = value + hessian[right][left] = value + } + _ => return residual_df + } + } + } + for index in 0.. value + None => return residual_df + } + let mut variance_of_variance = 0.0 + for left in 0.. Double { + let coefficients = [ + 76.18009172947146, + -86.50532032941677, + 24.01409824083091, + -1.231739572450155, + 0.001208650973866179, + -0.000005395239384953, + ] + let mut shifted = value + let temporary = value + 5.5 + let leading = (value + 0.5) * @math.ln(temporary) - temporary + let mut series = 1.000000000190015 + for coefficient in coefficients { + shifted = shifted + 1.0 + series = series + coefficient / shifted + } + leading + @math.ln(2.5066282746310005 * series) +} + +///| +fn vp_beta_continued_fraction( + x : Double, + a : Double, + b : Double, +) -> Double { + let maximum_iterations = 200 + let epsilon = 3.0e-14 + let minimum = 1.0e-300 + let mut c = 1.0 + let mut d = 1.0 - (a + b) * x / (a + 1.0) + if d.abs() < minimum { + d = minimum + } + d = 1.0 / d + let mut fraction = d + let mut iteration = 1 + while iteration <= maximum_iterations { + let doubled = (2 * iteration).to_double() + let iteration_value = iteration.to_double() + let mut numerator = iteration_value * + (b - iteration_value) * + x / + ((a + doubled - 1.0) * (a + doubled)) + d = 1.0 + numerator * d + if d.abs() < minimum { + d = minimum + } + c = 1.0 + numerator / c + if c.abs() < minimum { + c = minimum + } + d = 1.0 / d + fraction = fraction * d * c + numerator = -(a + iteration_value) * + (a + b + iteration_value) * + x / + ((a + doubled) * (a + doubled + 1.0)) + d = 1.0 + numerator * d + if d.abs() < minimum { + d = minimum + } + c = 1.0 + numerator / c + if c.abs() < minimum { + c = minimum + } + d = 1.0 / d + let delta = d * c + fraction = fraction * delta + if (delta - 1.0).abs() <= epsilon { + break + } + iteration = iteration + 1 + } + fraction +} + +///| +fn vp_regularized_beta(x : Double, a : Double, b : Double) -> Double { + if x <= 0.0 { + return 0.0 + } + if x >= 1.0 { + return 1.0 + } + let log_front = vp_log_gamma(a + b) - + vp_log_gamma(a) - + vp_log_gamma(b) + + a * @math.ln(x) + + b * @math.ln(1.0 - x) + let front = @math.exp(log_front) + let result = if x < (a + 1.0) / (a + b + 2.0) { + front * vp_beta_continued_fraction(x, a, b) / a + } else { + 1.0 - front * vp_beta_continued_fraction(1.0 - x, b, a) / b + } + result.max(0.0).min(1.0) +} + +///| +fn vp_student_two_sided_p(statistic : Double, degrees : Double) -> Double { + if !vp_is_finite(statistic) || degrees <= 0.0 { + return 1.0 + } + let x = degrees / (degrees + statistic * statistic) + vp_regularized_beta(x, degrees / 2.0, 0.5) +} + +///| +fn vp_bh_adjust(results : Array[DreamGeneResult]) -> Array[DreamGeneResult] { + let count = results.length() + let order : Array[Int] = [] + for index in 0.. Int { + if results[left].p_value < results[right].p_value { + -1 + } else if results[left].p_value > results[right].p_value { + 1 + } else if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + let adjusted = Array::make(count, 1.0) + let mut running = 1.0 + let mut rank = count + while rank > 0 { + let original = order[rank - 1] + let candidate = (results[original].p_value * + count.to_double() / + rank.to_double()).min(1.0) + running = running.min(candidate) + adjusted[original] = running + rank = rank - 1 + } + let output : Array[DreamGeneResult] = [] + for index in 0.. DreamResult raise VariancePartitionError { + let names = vp_validate_expression_matrix( + expression, + gene_names, + design.sample_names.length(), + weights, + ) + if contrast.coefficients.length() != design.coefficient_names.length() { + raise VariancePartitionError( + "variancePartition contrast must match the fixed-effect design", + ) + } + let raw_results : Array[DreamGeneResult] = [] + for gene in 0.. DreamResult raise VariancePartitionError { + let expression = match se_assay(experiment, assay_name) { + Some(value) => value + None => + raise VariancePartitionError( + "variancePartition assay is absent from SummarizedExperiment", + ) + } + let weights = if weights_assay == "" { + [] + } else { + match se_assay(experiment, weights_assay) { + Some(value) => value + None => + raise VariancePartitionError( + "variancePartition weights assay is absent from SummarizedExperiment", + ) + } + } + dream( + expression, + design, + contrast, + gene_names~, + weights~, + reml~, + max_iterations~, + tolerance~, + ) +} + +///| +pub fn DreamResult::top_table( + self : DreamResult, + maximum_fdr? : Double = 1.0, +) -> Array[DreamGeneResult] raise VariancePartitionError { + if !vp_is_finite(maximum_fdr) || maximum_fdr < 0.0 || maximum_fdr > 1.0 { + raise VariancePartitionError( + "variancePartition maximum FDR must be between zero and one", + ) + } + let selected : Array[DreamGeneResult] = [] + for gene in self.genes { + if gene.adjusted_p_value <= maximum_fdr { + selected.push(gene) + } + } + selected.sort_by(fn(left : DreamGeneResult, right : DreamGeneResult) -> Int { + if left.p_value < right.p_value { + -1 + } else if left.p_value > right.p_value { + 1 + } else if left.gene_name < right.gene_name { + -1 + } else if left.gene_name > right.gene_name { + 1 + } else { + 0 + } + }) + selected +} + +///| +pub fn DreamResult::summary(self : DreamResult) -> String { + let mut significant = 0 + for gene in self.genes { + if gene.adjusted_p_value <= 0.05 { + significant = significant + 1 + } + } + "dream Differential Expression Summary\n" + + "Contrast: " + + self.contrast_name + + "\nGenes: " + + self.genes.length().to_string() + + "\nFDR <= 0.05: " + + significant.to_string() + + "\n" +} diff --git a/test/moonbit/variance_partition_test.mbt b/test/moonbit/variance_partition_test.mbt new file mode 100644 index 00000000..6ebd8946 --- /dev/null +++ b/test/moonbit/variance_partition_test.mbt @@ -0,0 +1,855 @@ +///| +/// Tests for Bioconductor variancePartition-inspired mixed models. + +///| +fn vp_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "variancePartition value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn vp_test_samples() -> Array[String] { + let samples : Array[String] = [] + for subject in 0..<4 { + for replicate in 0..<4 { + samples.push( + "S" + (subject + 1).to_string() + "_R" + (replicate + 1).to_string(), + ) + } + } + samples +} + +///| +fn vp_test_subjects() -> Array[String] { + let subjects : Array[String] = [] + for subject in 0..<4 { + for _ in 0..<4 { + subjects.push("S" + (subject + 1).to_string()) + } + } + subjects +} + +///| +fn vp_test_treatments() -> Array[String] { + let treatments : Array[String] = [] + for _ in 0..<4 { + treatments.push("Control") + treatments.push("Treated") + treatments.push("Control") + treatments.push("Treated") + } + treatments +} + +///| +fn vp_test_batches() -> Array[String] { + let batches : Array[String] = [] + for _ in 0..<4 { + batches.push("B1") + batches.push("B1") + batches.push("B2") + batches.push("B2") + } + batches +} + +///| +fn vp_test_design( + include_batch? : Bool = false, +) -> @src.VariancePartitionDesign { + let treatment = @src.vp_categorical_effect( + "Treatment", + vp_test_treatments(), + reference="Control", + ) catch { + _ => abort("valid treatment effect should build") + } + let subject = @src.vp_random_effect("Subject", vp_test_subjects()) catch { + _ => abort("valid subject effect should build") + } + let random_effects = [subject] + if include_batch { + let batch = @src.vp_random_effect("Batch", vp_test_batches()) catch { + _ => abort("valid batch effect should build") + } + random_effects.push(batch) + } + @src.vp_design(vp_test_samples(), [treatment], random_effects) catch { + _ => abort("valid variancePartition design should build") + } +} + +///| +fn vp_test_subject_gene() -> Array[Double] { + let values : Array[Double] = [] + let noise = [0.08, -0.08, 0.04, -0.04] + for subject in 0..<4 { + let subject_effect = (subject.to_double() - 1.5) * 2.0 + for replicate in 0..<4 { + let treatment_effect = if replicate % 2 == 1 { 0.1 } else { 0.0 } + values.push(10.0 + subject_effect + treatment_effect + noise[replicate]) + } + } + values +} + +///| +fn vp_test_treatment_gene() -> Array[Double] { + let values : Array[Double] = [] + let noise = [0.05, -0.03, -0.05, 0.03] + for subject in 0..<4 { + let subject_effect = (subject.to_double() - 1.5) * 0.08 + for replicate in 0..<4 { + let treatment_effect = if replicate % 2 == 1 { 4.0 } else { 0.0 } + values.push(6.0 + subject_effect + treatment_effect + noise[replicate]) + } + } + values +} + +///| +fn vp_test_batch_gene() -> Array[Double] { + let values : Array[Double] = [] + let noise = [0.03, -0.03, 0.02, -0.02] + for subject in 0..<4 { + let subject_effect = (subject.to_double() - 1.5) * 0.1 + for replicate in 0..<4 { + let batch_effect = if replicate >= 2 { 3.0 } else { 0.0 } + values.push(8.0 + subject_effect + batch_effect + noise[replicate]) + } + } + values +} + +///| +fn vp_test_residual_gene() -> Array[Double] { + let pattern = [1.0, -1.0, -1.0, 1.0] + let values : Array[Double] = [] + for subject in 0..<4 { + let scale = 1.0 + subject.to_double() * 0.1 + for replicate in 0..<4 { + values.push(5.0 + scale * pattern[replicate]) + } + } + values +} + +///| +fn vp_test_expression() -> Array[Array[Double]] { + [vp_test_subject_gene(), vp_test_treatment_gene(), vp_test_residual_gene()] +} + +///| +fn vp_test_assay() -> @src.SummarizedExperiment { + let expression = vp_test_expression() + let weights : Array[Array[Double]] = [] + for _ in 0.. abort("valid numeric effect should build") + } + assert_eq(effect.name, "Age") + assert_eq(effect.column_names, ["Age"]) + assert_eq(effect.columns, [[20.0], [30.0], [40.0]]) +} + +///| +test "variancePartition: categorical effect uses requested reference" { + let effect = @src.vp_categorical_effect( + "Disease", + ["Case", "Control", "Case", "Other"], + reference="Control", + ) catch { + _ => abort("valid categorical effect should build") + } + assert_eq(effect.column_names, ["Disease:Case", "Disease:Other"]) + assert_eq(effect.columns[0], [1.0, 0.0]) + assert_eq(effect.columns[1], [0.0, 0.0]) + assert_eq(effect.columns[3], [0.0, 1.0]) +} + +///| +test "variancePartition: random effect encoding is stable" { + let effect = @src.vp_random_effect("Subject", ["B", "A", "B", "A"]) catch { + _ => abort("valid random effect should build") + } + assert_eq(effect.levels, ["B", "A"]) + assert_eq(effect.level_indices, [0, 1, 0, 1]) +} + +///| +test "variancePartition: design expands intercept and treatment" { + let design = vp_test_design() + assert_eq(design.sample_names.length(), 16) + assert_eq(design.coefficient_names, ["(Intercept)", "Treatment:Treated"]) + assert_eq(design.matrix[0], [1.0, 0.0]) + assert_eq(design.matrix[1], [1.0, 1.0]) + assert_eq(design.random_effects[0].levels.length(), 4) +} + +///| +test "variancePartition: constructors copy caller arrays" { + let ages = [20.0, 30.0, 40.0] + let effect = @src.vp_numeric_effect("Age", ages) catch { + _ => abort("valid numeric effect should build") + } + ages[0] = 99.0 + assert_eq(effect.columns[0][0], 20.0) + let samples = vp_test_samples() + let design = vp_test_design() + samples[0] = "changed" + assert_eq(design.sample_names[0], "S1_R1") +} + +///| +test "variancePartition: subject random variance dominates subject gene" { + let fit = @src.vp_fit_gene( + vp_test_subject_gene(), + vp_test_design(), + gene_name="subject_gene", + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("subject mixed model should fit") + } + assert_true(fit.converged) + assert_true(fit.random_variances[0] > fit.residual_variance) + let fraction = fit.fraction("Subject") + match fraction { + Some(value) => assert_true(value > 0.8) + None => abort("Subject fraction should be present") + } +} + +///| +test "variancePartition: fixed variance dominates treatment gene" { + let fit = @src.vp_fit_gene( + vp_test_treatment_gene(), + vp_test_design(), + gene_name="treatment_gene", + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("treatment mixed model should fit") + } + vp_test_close(fit.coefficients[1], 4.0, 0.15) + match fit.fraction("Treatment") { + Some(value) => assert_true(value > 0.8) + None => abort("Treatment fraction should be present") + } +} + +///| +test "variancePartition: variance fractions sum to one" { + let fit = @src.vp_fit_gene( + vp_test_subject_gene(), + vp_test_design(), + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("mixed model should fit") + } + let mut total = 0.0 + for value in fit.variance_fractions { + assert_true(value >= 0.0) + total = total + value + } + vp_test_close(total, 1.0, 1.0e-10) +} + +///| +test "variancePartition: BLUPs recover subject ordering" { + let fit = @src.vp_fit_gene( + vp_test_subject_gene(), + vp_test_design(), + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("mixed model should fit") + } + let first = match fit.blup("Subject", "S1") { + Some(value) => value + None => abort("S1 BLUP should be present") + } + let last = match fit.blup("Subject", "S4") { + Some(value) => value + None => abort("S4 BLUP should be present") + } + assert_true(first < 0.0) + assert_true(last > 0.0) + assert_true(last > first) +} + +///| +test "variancePartition: fitted values and residuals preserve sample order" { + let expression = vp_test_treatment_gene() + let fit = @src.vp_fit_gene( + expression, + vp_test_design(), + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("mixed model should fit") + } + assert_eq(fit.fitted_values.length(), expression.length()) + assert_eq(fit.residuals.length(), expression.length()) + for index in 0.. abort("unweighted model should fit") + } + let weighted = @src.vp_fit_gene( + expression, + vp_test_design(), + weights=Array::make(expression.length(), 5.0), + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("weighted model should fit") + } + vp_test_close(unweighted.coefficients[1], weighted.coefficients[1], 1.0e-8) + vp_test_close( + unweighted.residual_variance, + weighted.residual_variance, + 1.0e-8, + ) +} + +///| +test "variancePartition: heterogeneous precision weights are accepted" { + let expression = vp_test_treatment_gene() + let weights = Array::make(expression.length(), 1.0) + weights[0] = 0.2 + let fit = @src.vp_fit_gene( + expression, + vp_test_design(), + weights~, + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("heterogeneous weighted model should fit") + } + assert_true(fit.residual_variance > 0.0) + assert_true(fit.log_likelihood < 1.0e300) +} + +///| +test "variancePartition: ML and REML fits are identified" { + let reml_fit = @src.vp_fit_gene( + vp_test_subject_gene(), + vp_test_design(), + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("REML model should fit") + } + let ml_fit = @src.vp_fit_gene( + vp_test_subject_gene(), + vp_test_design(), + reml=false, + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("ML model should fit") + } + assert_true(reml_fit.reml) + assert_false(ml_fit.reml) + assert_true(reml_fit.log_likelihood != ml_fit.log_likelihood) +} + +///| +test "variancePartition: multiple random intercepts are fitted" { + let fit = @src.vp_fit_gene( + vp_test_batch_gene(), + vp_test_design(include_batch=true), + gene_name="batch_gene", + max_iterations=100, + tolerance=0.01, + ) catch { + _ => abort("multi-random-effect model should fit") + } + assert_eq(fit.random_effect_names, ["Subject", "Batch"]) + assert_eq(fit.random_variances.length(), 2) + assert_true(fit.random_variances[1] > fit.random_variances[0]) + match fit.fraction("Batch") { + Some(value) => assert_true(value > 0.5) + None => abort("Batch fraction should be present") + } +} + +///| +test "variancePartition: fixed-only design reduces to linear model" { + let treatment = @src.vp_categorical_effect( + "Treatment", + vp_test_treatments(), + reference="Control", + ) catch { + _ => abort("valid fixed effect should build") + } + let design = @src.vp_design(vp_test_samples(), [treatment], []) catch { + _ => abort("fixed-only design should build") + } + let fit = @src.vp_fit_gene( + vp_test_treatment_gene(), + design, + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("fixed-only model should fit") + } + vp_test_close(fit.coefficients[1], 4.0, 0.15) + assert_eq(fit.random_variances.length(), 0) +} + +///| +test "variancePartition: matrix fit generates gene names" { + let result = @src.fit_extract_variance_partition( + vp_test_expression(), + vp_test_design(), + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("variance partition matrix should fit") + } + assert_eq(result.gene_names, ["Gene1", "Gene2", "Gene3"]) + assert_eq(result.fractions.length(), 3) + assert_eq(result.fits.length(), 3) + assert_false(result.fits[0].reml) +} + +///| +test "variancePartition: matrix result supports named lookup" { + let result = @src.fit_extract_variance_partition( + vp_test_expression(), + vp_test_design(), + gene_names=["subject", "treatment", "residual"], + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("variance partition matrix should fit") + } + match result.fraction("subject", "Subject") { + Some(value) => assert_true(value > 0.8) + None => abort("named variance fraction should be present") + } + assert_true(result.fraction("missing", "Subject") is None) +} + +///| +test "variancePartition: matrix result reports component medians" { + let result = @src.fit_extract_variance_partition( + vp_test_expression(), + vp_test_design(), + gene_names=["subject", "treatment", "residual"], + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("variance partition matrix should fit") + } + assert_eq(result.component_names, ["Treatment", "Subject", "Residuals"]) + assert_eq(result.median_fractions.length(), 3) + for value in result.median_fractions { + assert_true(value >= 0.0 && value <= 1.0) + } +} + +///| +test "variancePartition: result summary contains component names" { + let result = @src.fit_extract_variance_partition( + [vp_test_subject_gene()], + vp_test_design(), + gene_names=["subject"], + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("variance partition matrix should fit") + } + let summary = result.summary() + assert_true(summary.contains("variancePartition Summary")) + assert_true(summary.contains("Subject median fraction")) + assert_true(summary.contains("Genes: 1")) +} + +///| +test "variancePartition: dream estimates repeated-measures contrast" { + let design = vp_test_design() + let contrast = @src.vp_coefficient_contrast( + design, "Treated-Control", "Treatment:Treated", + ) catch { + _ => abort("valid coefficient contrast should build") + } + let result = @src.dream( + vp_test_expression(), + design, + contrast, + gene_names=["subject", "treatment", "residual"], + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("dream analysis should fit") + } + vp_test_close(result.genes[1].estimate, 4.0, 0.15) + assert_true(result.genes[1].standard_error > 0.0) + assert_true(result.genes[1].p_value < 0.001) +} + +///| +test "variancePartition: dream uses bounded small-sample degrees of freedom" { + let design = vp_test_design() + let contrast = @src.vp_coefficient_contrast( + design, "Treated-Control", "Treatment:Treated", + ) catch { + _ => abort("valid coefficient contrast should build") + } + let result = @src.dream( + [vp_test_treatment_gene()], + design, + contrast, + gene_names=["treatment"], + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("dream analysis should fit") + } + let degrees = result.genes[0].degrees_of_freedom + assert_true(degrees >= 1.0) + assert_true(degrees <= 14.0) +} + +///| +test "variancePartition: dream applies monotone BH correction" { + let design = vp_test_design() + let contrast = @src.vp_coefficient_contrast( + design, "Treated-Control", "Treatment:Treated", + ) catch { + _ => abort("valid coefficient contrast should build") + } + let result = @src.dream( + vp_test_expression(), + design, + contrast, + gene_names=["subject", "treatment", "residual"], + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("dream analysis should fit") + } + for gene in result.genes { + assert_true(gene.adjusted_p_value >= gene.p_value) + assert_true(gene.adjusted_p_value <= 1.0) + } +} + +///| +test "variancePartition: dream top table sorts by p-value" { + let design = vp_test_design() + let contrast = @src.vp_coefficient_contrast( + design, "Treated-Control", "Treatment:Treated", + ) catch { + _ => abort("valid coefficient contrast should build") + } + let result = @src.dream( + vp_test_expression(), + design, + contrast, + gene_names=["subject", "treatment", "residual"], + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("dream analysis should fit") + } + let table = result.top_table() catch { + _ => abort("valid top table should build") + } + assert_eq(table.length(), 3) + for index in 1.. abort("valid custom contrast should build") + } + assert_eq(contrast.name, "Treatment") + assert_eq(contrast.coefficients, [0.0, 1.0]) +} + +///| +test "variancePartition: dream summary reports contrast and significance" { + let design = vp_test_design() + let contrast = @src.vp_coefficient_contrast( + design, "Treated-Control", "Treatment:Treated", + ) catch { + _ => abort("valid coefficient contrast should build") + } + let result = @src.dream( + [vp_test_treatment_gene()], + design, + contrast, + gene_names=["treatment"], + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("dream analysis should fit") + } + let summary = result.summary() + assert_true(summary.contains("dream Differential Expression Summary")) + assert_true(summary.contains("Contrast: Treated-Control")) + assert_true(summary.contains("FDR <= 0.05: 1")) +} + +///| +test "variancePartition: SummarizedExperiment variance entry uses assays" { + let result = @src.fit_extract_variance_partition_se( + vp_test_assay(), + "logcounts", + vp_test_design(), + gene_names=["subject", "treatment", "residual"], + weights_assay="weights", + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("SummarizedExperiment variance analysis should fit") + } + assert_eq(result.gene_names.length(), 3) + match result.fraction("subject", "Subject") { + Some(value) => assert_true(value > 0.8) + None => abort("Subject fraction should be present") + } +} + +///| +test "variancePartition: SummarizedExperiment dream entry uses assays" { + let design = vp_test_design() + let contrast = @src.vp_coefficient_contrast( + design, "Treated-Control", "Treatment:Treated", + ) catch { + _ => abort("valid coefficient contrast should build") + } + let result = @src.dream_se( + vp_test_assay(), + "logcounts", + design, + contrast, + gene_names=["subject", "treatment", "residual"], + weights_assay="weights", + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("SummarizedExperiment dream analysis should fit") + } + assert_true(result.genes[1].p_value < 0.001) +} + +///| +test "variancePartition: rejects categorical reference that is absent" { + let failed = try { + ignore( + @src.vp_categorical_effect( + "Disease", + ["Case", "Control"], + reference="Other", + ), + ) + false + } catch { + VariancePartitionError(_) => true + } + assert_true(failed) +} + +///| +test "variancePartition: rejects unreplicated random effects" { + let failed = try { + ignore(@src.vp_random_effect("Subject", ["A", "B", "C"])) + false + } catch { + VariancePartitionError(_) => true + } + assert_true(failed) +} + +///| +test "variancePartition: rejects duplicate sample names" { + let age = @src.vp_numeric_effect("Age", [1.0, 2.0, 3.0]) catch { + _ => abort("numeric effect should build") + } + let failed = try { + ignore(@src.vp_design(["A", "A", "B"], [age], [])) + false + } catch { + VariancePartitionError(_) => true + } + assert_true(failed) +} + +///| +test "variancePartition: rejects rank-deficient fixed design" { + let first = @src.vp_numeric_effect("First", [0.0, 1.0, 2.0, 3.0]) catch { + _ => abort("numeric effect should build") + } + let second = @src.vp_numeric_effect("Second", [0.0, 2.0, 4.0, 6.0]) catch { + _ => abort("numeric effect should build") + } + let failed = try { + ignore(@src.vp_design(["A", "B", "C", "D"], [first, second], [])) + false + } catch { + VariancePartitionError(_) => true + } + assert_true(failed) +} + +///| +test "variancePartition: rejects expression dimension mismatch" { + let failed = try { + ignore(@src.vp_fit_gene([1.0, 2.0], vp_test_design())) + false + } catch { + VariancePartitionError(_) => true + } + assert_true(failed) +} + +///| +test "variancePartition: rejects nonpositive precision weights" { + let weights = Array::make(16, 1.0) + weights[3] = 0.0 + let failed = try { + ignore(@src.vp_fit_gene(vp_test_subject_gene(), vp_test_design(), weights~)) + false + } catch { + VariancePartitionError(_) => true + } + assert_true(failed) +} + +///| +test "variancePartition: rejects duplicate gene names" { + let failed = try { + ignore( + @src.fit_extract_variance_partition( + [vp_test_subject_gene(), vp_test_treatment_gene()], + vp_test_design(), + gene_names=["gene", "gene"], + ), + ) + false + } catch { + VariancePartitionError(_) => true + } + assert_true(failed) +} + +///| +test "variancePartition: rejects zero contrast" { + let failed = try { + ignore(@src.vp_contrast("zero", [0.0, 0.0])) + false + } catch { + VariancePartitionError(_) => true + } + assert_true(failed) +} + +///| +test "variancePartition: rejects contrast dimension mismatch" { + let failed = try { + ignore( + @src.dream( + [vp_test_treatment_gene()], + vp_test_design(), + @src.vp_contrast("bad", [1.0]) catch { + _ => abort("nonzero contrast should build") + }, + ), + ) + false + } catch { + VariancePartitionError(_) => true + } + assert_true(failed) +} + +///| +test "variancePartition: rejects invalid top-table FDR" { + let design = vp_test_design() + let contrast = @src.vp_coefficient_contrast( + design, "Treated-Control", "Treatment:Treated", + ) catch { + _ => abort("valid coefficient contrast should build") + } + let result = @src.dream( + [vp_test_treatment_gene()], + design, + contrast, + gene_names=["treatment"], + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("dream analysis should fit") + } + let failed = try { + ignore(result.top_table(maximum_fdr=1.5)) + false + } catch { + VariancePartitionError(_) => true + } + assert_true(failed) +} + +///| +test "variancePartition: reports missing SummarizedExperiment assay" { + let failed = try { + ignore( + @src.fit_extract_variance_partition_se( + vp_test_assay(), + "missing", + vp_test_design(), + ), + ) + false + } catch { + VariancePartitionError(_) => true + } + assert_true(failed) +} From 9d461a9875d565693d810fcf356ea9f12cb123bd Mon Sep 17 00:00:00 2001 From: eda Date: Tue, 4 Aug 2026 22:35:38 +0800 Subject: [PATCH 14/41] #28 /8634 feat(shared_reference_alignment): PWA/MSA insertion slots --- README.md | 26 +- .../shared_reference_alignment_demo/main.mbt | 103 +++ .../shared_reference_alignment_demo/moon.pkg | 5 + src/shared_reference_alignment.mbt | 839 ++++++++++++++++++ .../shared_reference_alignment_test.mbt | 591 ++++++++++++ 5 files changed, 1560 insertions(+), 4 deletions(-) create mode 100644 examples/shared_reference_alignment_demo/main.mbt create mode 100644 examples/shared_reference_alignment_demo/moon.pkg create mode 100644 src/shared_reference_alignment.mbt create mode 100644 test/moonbit/shared_reference_alignment_test.mbt diff --git a/README.md b/README.md index 0895c324..0f4d7ab7 100644 --- a/README.md +++ b/README.md @@ -32,6 +32,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **BLAST解析** | Biopython `Bio.Blast` | BLAST结果解析、tabular/xml格式、HSP过滤、最佳匹配 | ✅ | | **SearchIO** | Biopython `Bio.SearchIO` | 统一搜索结果模型、HMMER3/Infernal解析、BLAT PSL解析、BLAST转换 | ✅ | | **HH-suite HHR** | Biopython `Bio.Align.hhr` | HHsearch/HHblits HHR解析、profile-profile比对、命中筛选、坐标映射、序列化往返 | ✅ | +| **共享参考比对合并** | Biopython `Bio.Align.Alignment` | 合并共享同一参考序列的PWA/MSA、同步insertion slots、保留局部坐标与metadata、双向坐标映射 | ✅ | | **系统发育树** | Biopython `Bio.Phylo` | 树结构、Newick 解析、距离计算、可视化 | ✅ | | **PDB 结构** | Biopython `Bio.PDB` | 原子/残基/链解析、结构操作 | ✅ | | **BinaryCIF** | Biopython `Bio.PDB.binary_cif` | MessagePack解析、七类逆编码、三态缺失值、类别查询、PDB Structure转换 | ✅ | @@ -157,6 +158,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | Bio.SearchIO.InterproscanIO | InterProScan输出解析: TSV 14列格式解析(蛋白质ID/分析数据库/签名/位置/分数/IPR/GO)、按数据库/蛋白质过滤、GO条目提取、按蛋白质分组 | | ✅ | Bio.SearchIO.InfernalIO | Infernal cmscan/cmsearch解析: tabular格式1/2/3自动检测、non-verbose文本与--noali、CM/HMM-only、Query/Hit/HSP/Fragment层次、正负链坐标、local-end多片段、过滤与SearchIO转换 | | ✅ | Bioconductor variancePartition | 多随机截距线性混合模型、ML/REML方差分量、固定/随机/残差方差占比、precision weights、BLUP、dream contrast、数值Satterthwaite检验、BH-FDR与SummarizedExperiment接入 | +| ✅ | Bio.Align.Alignment shared-reference merge | 共享参考PWA/MSA合并、reference-boundary insertion slot同步、局部reference/query坐标、metadata、统计、MSA与aligned FASTA转换 | | ✅ | Bio.PDB.SASA | 溶剂可及表面积计算: Shrake-Rupley滚动球算法(Fibonacci球面采样)、范德华半径查表、逐原子/残基/链SASA、骨架/侧链拆分 | | ✅ | Bio.SeqIO.NibIO | nib 2-bit二进制序列格式: DNA 2-bit编码(T=0/C=1/A=2/G=3)、4碱基/字节打包、hex I/O、子序列提取、反向互补、GC含量、压缩比 | | ✅ | ChIPseeker | ChIP-seq峰注释: 峰-TSS距离计算、基因组特征分配(Promoter/5'UTR/3'UTR/Exon/Intron/Downstream/Distal Intergenic)、最近基因查找、注释摘要 | @@ -211,6 +213,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **Cellosaurus** | Biopython `Bio.ExPASy.cellosaurus` | Cellosaurus平面文本解析、类型化细胞系记录、数据库交叉引用、物种查询、序列化往返 | ✅ | | **UniGene** | Biopython `Bio.UniGene` | NCBI UniGene固定宽度记录解析、类型化序列/蛋白相似性/STS/转录本映射、严格SCOUNT校验、序列化往返 | ✅ | | **HH-suite HHR** | Biopython `Bio.Align.hhr` | HHR元数据、命中摘要、多块profile比对、consensus/二级结构/DSSP/confidence注释、概率和E-value查询 | ✅ | +| **共享参考比对合并** | Biopython `Bio.Align.Alignment.from_alignments_with_same_reference` | 混合PWA/MSA输入、首端/内部/末端insertion同步、多query投影、局部坐标与metadata保留、统计和格式转换 | ✅ | | **Prosite** | Biopython `Bio.Prosite` | 蛋白质模体数据库搜索、Prosite模式解析、模体匹配算法、模体得分计算 | ✅ | | **PAML** | Biopython `Bio.PAML` | 分子进化分析、dN/dS计算（Nei-Gojobori方法）、Jukes-Cantor校正、密码子使用分析 | ✅ | | **Graphics** | Biopython `Bio.Graphics` | 生物信息学可视化、序列Logo绘制、序列比对可视化、基因组特征绘图 | ✅ | @@ -351,6 +354,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | mixOmics | 多组学整合方法，包括PLS回归、稀疏PLS (sPLS)、DIABLO多块整合 | | **MAF格式解析** | Biopython `Bio.Align` | MAF多序列比对格式解析、块操作、百分比一致性、统计分析、选择/过滤/写回 | ✅ | | **HH-suite HHR格式** | Biopython `Bio.Align.hhr` | HHsearch/HHblits结果严格解析、0-based坐标、query-target映射、规范化写回 | ✅ | +| **共享参考比对同步** | Biopython `Bio.Align.Alignment` | 相同参考PWA/MSA合并、边界插入宽度归一化、query原始比对结构保留、reference/query/column坐标互映 | ✅ | | **UCSC Chain文件/liftOver** | Bioconductor rtracklayer | Chain格式解析、基因组坐标liftOver转换、链段查找、染色体间坐标映射、位置/区间转换 | ✅ | | **Biostrings matchPDict** | Bioconductor Biostrings | 字典模式匹配(matchPDict/vmatchPattern)、多序列模式计数(vcountPattern)、错配容忍、最佳匹配查找 | ✅ | | **GenomicRanges gaps/reduce/disjoin** | Bioconductor GenomicRanges | gaps检测、reduce合并、disjoin拆分、setdiff/交集/并集集合运算、coverage计算、promoters提取、trim | ✅ | @@ -406,6 +410,7 @@ IvanAXu/BioSeqs/ │ ├── fastq_io.mbt # FASTQ 格式解析 │ ├── genbank_io.mbt # GenBank 格式解析 │ ├── align.mbt # MultipleSeqAlignment 多序列比对 +│ ├── shared_reference_alignment.mbt # Bio.Align共享参考PWA/MSA合并、insertion slot同步与坐标映射 │ ├── alignio.mbt # 比对文件 I/O │ ├── clustal_io.mbt # Clustal 格式 │ ├── phylip_io.mbt # PHYLIP 格式 @@ -1086,6 +1091,7 @@ IvanAXu/BioSeqs/ │ ├── fasta_search_io_demo/ # FASTA搜索输出解析示例 (-m8表格、-m9注释头、元数据、Query/Hit/HSP聚合) │ ├── infernal_io_demo/ # Infernal cmscan/cmsearch解析示例 (tabular 3、文本local-end、过滤、SearchIO转换) │ ├── hhr_demo/ # HH-suite HHR解析、命中筛选、坐标映射与序列化往返示例 +│ ├── shared_reference_alignment_demo/ # 共享参考PWA/MSA合并、insertion同步、坐标映射与FASTA转换示例 │ ├── gene_pop_demo/ # GenePop群体遗传学示例 (基因型解析、等位基因频率、杂合度统计、序列化往返) │ ├── stage_r_demo/ # stageR两阶段检验示例 (筛选+确认、Simes聚合、BH-FDR、Holm步降、OFDR控制) │ ├── enriched_heatmap_demo/ # EnrichedHeatmap富集热图示例 (信号归一化、四种均值模式、行平滑、链方向处理) @@ -1284,6 +1290,7 @@ IvanAXu/BioSeqs/ │ │ ├── scrapper_test.mbt │ │ ├── milo_test.mbt │ │ ├── variance_partition_test.mbt +│ │ ├── shared_reference_alignment_test.mbt │ │ ├── search_io_test.mbt │ │ ├── searchio_new_test.mbt │ │ ├── seq_complexity_test.mbt @@ -1460,7 +1467,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8593 个测试全部通过 +moon test # ✅ 8634 个测试全部通过 ``` ### 模块对照表 @@ -1505,6 +1512,7 @@ moon test # ✅ 8593 个测试全 | `codon_align.mbt` | BioPython `Bio.codonalign` | 密码子比对与 dN/dS 分析 | | `searchio.mbt` | BioPython `Bio.SearchIO` | 统一搜索结果模型、BLAST/HMMER解析、E-value过滤 | | `hhr.mbt` | BioPython `Bio.Align.hhr` | HHsearch/HHblits HHR解析、profile比对注释、命中筛选、坐标映射与规范序列化 | +| `shared_reference_alignment.mbt` | BioPython `Bio.Align.Alignment.from_alignments_with_same_reference` | 共享参考PWA/MSA合并、insertion slot同步、局部坐标、双向映射、统计、MSA与FASTA转换 | #### 系统发育树 @@ -1766,6 +1774,7 @@ moon test # ✅ 8593 个测试全 | `scrapper.mbt` | `scrapper` | 批次感知RNA QC、大小因子清洗/居中、count与log归一化、LOWESS方差趋势、HVG选择、多因子pseudo-bulk、SingleCellExperiment不可变包装 | | `milo.mbt` | `miloR` | 精确KNN图、median精炼重叠邻域、邻域计数/表达、固定效应NB-GLM/Wald检验、graph spatial FDR与SCE接入 | | `variance_partition.mbt` | `variancePartition` | typed fixed/random design、多随机截距LMM、ML/REML方差分解、BLUP、weighted dream contrast、Satterthwaite自由度与SummarizedExperiment入口 | +| `shared_reference_alignment.mbt` | `Bio.Align.Alignment` | 同参考PWA/MSA的reference-boundary insertion同步、原query投影、局部坐标、metadata、统计与格式转换 | | `infercnv.mbt` | `infercnv` | 单细胞拷贝数变异推断（基因组位置排序、参考细胞有界 LFC 计算、金字塔权重平滑、CNV 分数与恶性细胞预测） | | `scenic.mbt` | `SCENIC` | 单细胞调控网络推断与聚类（TF-target 共表达模块、Regulon 构建、AUCell 活性评分、二值化阈值、细胞状态与主控调控因子） | | `cibersort.mbt` | `CIBERSORT` | 免疫细胞去卷积（NNLS 求解、LM22 风格特征矩阵、Pearson 拟合优度、分数归一化） | @@ -2842,6 +2851,12 @@ moon test # ✅ 8593 个测试全 observation-level precision weights 会先缩放到均值 1，并进入 `V = ΣτₖZₖZₖᵀ + σ²diag(1/w)`。`dream`/`dream_se` 对任意固定效应 contrast 计算估计值、标准误、数值 Satterthwaite 自由度、双侧 Student-t p 值和 BH-FDR；`fit_extract_variance_partition_se` 与 `dream_se` 可直接读取 `SummarizedExperiment` 的表达和 weights assay。当前范围支持随机截距，不包括随机斜率、Kenward-Roger、voom mean-variance trend、limma empirical Bayes、缺失值省略及上游绘图接口。 +### 249. 共享参考序列比对合并 (Biopython Bio.Align) + +实现 Biopython 1.86 `Alignment.from_alignments_with_same_reference` 的共享参考比对合并语义。`shared_reference_input` 表示一条参考和一条或多条 query 的 PWA/MSA，`shared_reference_input_from_pairwise` 可直接接入现有 `PairwiseAlignment`；构造过程验证 raw/aligned sequence、0-based half-open 局部坐标、行宽以及所有输入的参考内容和覆盖区间。核心 `alignments_with_same_reference` 将参考覆盖区间表示为 `L + 1` 个 reference-boundary insertion slots，取各输入同一边界插入宽度的最大值，再将原 query 行投影到统一列空间，因此不会重新比对 query，并支持首端、内部、末端 insertion 及单个输入中的多条 query。 + +`SharedReferenceAlignment` 保留参考/query名称、描述和局部坐标，提供 row/column 查询、reference/query/column 双向坐标映射，以及 identity、mismatch、insertion、deletion 统计。合并结果可转换为现有 `MultipleSeqAlignment` 或 aligned FASTA。算法复杂度为 `O(total input columns + merged rows × merged columns)`；当前要求所有输入覆盖同一参考区间，使用 `-` 表示 gap，不自动执行反向互补或 query 间二次比对。 + ## 性能优化 ### 优化策略 @@ -2943,8 +2958,8 @@ observation-level precision weights 会先缩放到均值 1，并进入 `V = Σ | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8593 | -| 通过数 | 8593 | +| 总测试数 | 8634 | +| 通过数 | 8634 | | 失败数 | 0 | | 通过率 | 100% | @@ -3046,6 +3061,7 @@ moon test --update | Cellosaurus | `cellosaurus_test.mbt` | 16 | | UniGene | `unigene_test.mbt` | 23 | | Bio.Align.hhr | `hhr_test.mbt` | 33 | +| Bio.Align shared-reference merge | `shared_reference_alignment_test.mbt` | 41 | | SparseArray | `sparse_array_test.mbt` | 41 | | mmCIF | `mmcif_test.mbt` | 2 | | BinaryCIF | `binary_cif_test.mbt` | 37 | @@ -3341,7 +3357,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 356 个示例程序，展示各模块的典型用法： +项目提供 357 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3527,6 +3543,7 @@ moon run cmd/bench/main.mbt | fasta_search_io_demo | FASTA搜索输出解析（-m8表格、-m9注释头、元数据、Query/Hit/HSP聚合） | `moon run examples/fasta_search_io_demo/main.mbt` | | infernal_io_demo | Infernal cmscan/cmsearch解析（tabular 3、non-verbose文本、local-end片段、过滤与SearchIO转换） | `moon run examples/infernal_io_demo` | | variance_partition_demo | typed固定/随机设计、ML方差分解、BLUP、precision weights、dream contrast与SummarizedExperiment接入 | `moon run examples/variance_partition_demo` | +| shared_reference_alignment_demo | 共享参考PWA/MSA合并、reference insertion同步、坐标映射、统计、MSA与aligned FASTA转换 | `moon run examples/shared_reference_alignment_demo` | | gene_pop_demo | GenePop群体遗传学（基因型解析、等位基因频率、杂合度统计、序列化往返） | `moon run examples/gene_pop_demo/main.mbt` | | stage_r_demo | stageR两阶段假设检验（筛选+确认、Simes聚合、BH-FDR、Holm步降、OFDR控制） | `moon run examples/stage_r_demo/main.mbt` | | enriched_heatmap_demo | EnrichedHeatmap富集热图（信号归一化、四种均值模式、行平滑、链方向处理） | `moon run examples/enriched_heatmap_demo/main.mbt` | @@ -3631,6 +3648,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bioconductor miloR 单细胞邻域差异丰度（精确KNN图、median精炼采样、邻域计数、固定效应NB-GLM、graph spatial FDR与SCE接入） - ✅ 实现 Bio.SearchIO.InfernalIO Infernal cmscan/cmsearch输出解析（tabular 1/2/3、non-verbose文本、--noali、CM/HMM-only、local-end多片段与SearchIO转换） - ✅ 实现 Bioconductor variancePartition 重复测量混合模型（ML/REML方差分解、BLUP、precision weights、dream contrast、数值Satterthwaite、BH-FDR与SummarizedExperiment接入） +- ✅ 实现 Bio.Align共享参考序列比对合并（混合PWA/MSA、reference-boundary insertion同步、局部坐标、双向映射、统计与格式转换） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/shared_reference_alignment_demo/main.mbt b/examples/shared_reference_alignment_demo/main.mbt new file mode 100644 index 00000000..125bd418 --- /dev/null +++ b/examples/shared_reference_alignment_demo/main.mbt @@ -0,0 +1,103 @@ +///| +fn main { + println("=== Biopython Shared-reference Alignment Demo ===") + + println("\n1. Adapt an existing pairwise alignment") + let pairwise = @src.pairaligner_align("ACGT", "ACT") + let pairwise_input = @src.shared_reference_input_from_pairwise( + pairwise, + reference_name="reference", + reference_description="shared DNA template", + query_name="pairwise_read", + query_description="one deletion", + ) catch { + _ => abort("failed to adapt pairwise alignment") + } + println(" reference: " + pairwise_input.aligned_reference) + println(" query: " + pairwise_input.queries[0].aligned_sequence) + + println("\n2. Build a multi-query alignment with an insertion") + let inserted = @src.shared_reference_sequence( + "inserted_read", + "ACGGT", + description="one insertion", + ) catch { + _ => abort("failed to build inserted query") + } + let deleted = @src.shared_reference_sequence( + "deleted_read", + "A---T", + description="three deletions", + ) catch { + _ => abort("failed to build deleted query") + } + let multiple_input = @src.shared_reference_input( + "ACGT", + "ACG-T", + [inserted, deleted], + reference_name="reference", + reference_description="shared DNA template", + ) catch { + _ => abort("failed to build multi-query input") + } + + println("\n3. Synchronize reference-boundary insertion slots") + let alignment = @src.alignments_with_same_reference([ + pairwise_input, multiple_input, + ]) catch { + _ => abort("failed to merge shared-reference alignments") + } + println(" " + alignment.summary()) + println(" insertion widths: " + alignment.insertion_widths.to_string()) + for index in 0.. reference: " + + alignment.query_to_reference(1, 3).to_string(), + ) + println( + " inserted_read query position 4 -> reference: " + + alignment.query_to_reference(1, 4).to_string(), + ) + println( + " reference position 3 -> inserted_read query: " + + alignment.reference_to_query(1, 3).to_string(), + ) + + println("\n5. Inspect alignment statistics") + for index in 0.. abort("failed to convert merged alignment") + } + println( + " MSA dimensions: " + + msa.num_records().to_string() + + " x " + + msa.get_alignment_length().to_string(), + ) + println(alignment.to_fasta()) + + println("=== Demo Complete ===") +} diff --git a/examples/shared_reference_alignment_demo/moon.pkg b/examples/shared_reference_alignment_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/shared_reference_alignment_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/shared_reference_alignment.mbt b/src/shared_reference_alignment.mbt new file mode 100644 index 00000000..a1ffe7e1 --- /dev/null +++ b/src/shared_reference_alignment.mbt @@ -0,0 +1,839 @@ +// Merge pairwise or multiple alignments that share one reference sequence. +// +// This implements the semantics of Biopython 1.86 +// Alignment.from_alignments_with_same_reference. Insertions are represented +// as slots between reference residues; each slot is widened to the largest +// insertion present in any input without realigning the query sequences. + +///| +/// Error raised by shared-reference alignment operations. +pub suberror SharedReferenceAlignmentError { + SharedReferenceAlignmentError(String) +} + +///| +/// One query row in an input or merged shared-reference alignment. +pub struct SharedReferenceSequence { + name : String + description : String + sequence : String + aligned_sequence : String + start : Int + end : Int +} derive(Eq, Debug) + +///| +/// An alignment containing one reference row and one or more query rows. +pub struct SharedReferenceInput { + reference_name : String + reference_description : String + reference : String + aligned_reference : String + reference_start : Int + reference_end : Int + queries : Array[SharedReferenceSequence] +} derive(Eq, Debug) + +///| +/// Counts comparing one merged query row with the shared reference. +pub struct SharedReferenceCounts { + identities : Int + mismatches : Int + insertions : Int + deletions : Int + aligned_pairs : Int +} derive(Eq, Debug) + +///| +/// A multiple sequence alignment formed without realigning the input queries. +pub struct SharedReferenceAlignment { + reference_name : String + reference_description : String + reference : String + reference_start : Int + reference_end : Int + aligned_reference : String + queries : Array[SharedReferenceSequence] + insertion_widths : Array[Int] +} derive(Eq, Debug) + +///| +/// Remove gap characters from an aligned sequence. +fn shared_reference_ungap(sequence : String) -> String { + let result = StringBuilder::new(size_hint=sequence.length()) + let mut index = 0 + while index < sequence.length() { + let residue = sequence.unsafe_get(index).unsafe_to_char() + if residue != '-' { + result.write_char(residue) + } + index = index + 1 + } + result.to_string() +} + +///| +/// Compare biological sequence text without considering letter case. +fn shared_reference_same_sequence(left : String, right : String) -> Bool { + left.to_upper() == right.to_upper() +} + +///| +/// Reject whitespace and, for raw sequences, embedded gap characters. +fn shared_reference_validate_sequence( + sequence : String, + label : String, + allow_gaps : Bool, +) -> Unit raise SharedReferenceAlignmentError { + let mut index = 0 + while index < sequence.length() { + let residue = sequence.unsafe_get(index).unsafe_to_char() + if residue == ' ' || residue == '\t' || residue == '\n' || residue == '\r' { + raise SharedReferenceAlignmentError(label + " contains whitespace") + } + if !allow_gaps && residue == '-' { + raise SharedReferenceAlignmentError(label + " must not contain gaps") + } + index = index + 1 + } +} + +///| +/// Return a byte-based substring after validating its bounds. +fn shared_reference_substring( + sequence : String, + start : Int, + end : Int, +) -> String raise SharedReferenceAlignmentError { + if start < 0 || end < start || end > sequence.length() { + raise SharedReferenceAlignmentError( + "sequence coordinates are out of bounds", + ) + } + sequence[start:end].to_owned() +} + +///| +/// Construct a query row. +/// +/// If `sequence` is omitted, the ungapped aligned row is used. Supplying the +/// full sequence and `start` preserves local-alignment query coordinates. +pub fn shared_reference_sequence( + name : String, + aligned_sequence : String, + description? : String = "", + sequence? : String = "", + start? : Int = 0, +) -> SharedReferenceSequence raise SharedReferenceAlignmentError { + if start < 0 { + raise SharedReferenceAlignmentError("query start must be non-negative") + } + shared_reference_validate_sequence( + aligned_sequence, "aligned query sequence", true, + ) + let aligned_ungapped = shared_reference_ungap(aligned_sequence) + let raw_sequence = if sequence == "" { + aligned_ungapped + } else { + shared_reference_validate_sequence(sequence, "query sequence", false) + sequence + } + let end = start + aligned_ungapped.length() + if end > raw_sequence.length() { + raise SharedReferenceAlignmentError( + "aligned query coordinates exceed the query sequence", + ) + } + let observed = shared_reference_substring(raw_sequence, start, end) + if !shared_reference_same_sequence(observed, aligned_ungapped) { + raise SharedReferenceAlignmentError( + "aligned query does not match the query sequence at its coordinates", + ) + } + SharedReferenceSequence::{ + name, + description, + sequence: raw_sequence, + aligned_sequence, + start, + end, + } +} + +///| +/// Construct an input alignment with a shared reference row. +pub fn shared_reference_input( + reference : String, + aligned_reference : String, + queries : Array[SharedReferenceSequence], + reference_name? : String = "reference", + reference_description? : String = "", + reference_start? : Int = 0, +) -> SharedReferenceInput raise SharedReferenceAlignmentError { + if reference.length() == 0 { + raise SharedReferenceAlignmentError("reference sequence must not be empty") + } + if reference_start < 0 { + raise SharedReferenceAlignmentError("reference start must be non-negative") + } + if queries.length() == 0 { + raise SharedReferenceAlignmentError( + "an input alignment must contain at least one query", + ) + } + shared_reference_validate_sequence(reference, "reference sequence", false) + shared_reference_validate_sequence( + aligned_reference, "aligned reference sequence", true, + ) + let reference_segment = shared_reference_ungap(aligned_reference) + let reference_end = reference_start + reference_segment.length() + if reference_end > reference.length() { + raise SharedReferenceAlignmentError( + "aligned reference coordinates exceed the reference sequence", + ) + } + let expected = shared_reference_substring( + reference, reference_start, reference_end, + ) + if !shared_reference_same_sequence(expected, reference_segment) { + raise SharedReferenceAlignmentError( + "aligned reference does not match the reference sequence at its coordinates", + ) + } + let query_copy : Array[SharedReferenceSequence] = [] + for query in queries { + if query.aligned_sequence.length() != aligned_reference.length() { + raise SharedReferenceAlignmentError( + "all rows in an input alignment must have the same length", + ) + } + query_copy.push(query) + } + SharedReferenceInput::{ + reference_name, + reference_description, + reference, + aligned_reference, + reference_start, + reference_end, + queries: query_copy, + } +} + +///| +/// Adapt an existing BioSeqs PairwiseAlignment to a shared-reference input. +pub fn shared_reference_input_from_pairwise( + alignment : PairwiseAlignment, + reference_name? : String = "reference", + reference_description? : String = "", + query_name? : String = "query", + query_description? : String = "", +) -> SharedReferenceInput raise SharedReferenceAlignmentError { + let query = shared_reference_sequence( + query_name, + alignment.aligned2(), + description=query_description, + sequence=alignment.query, + start=alignment.query_start, + ) + let input = shared_reference_input( + alignment.target, + alignment.aligned1(), + [query], + reference_name~, + reference_description~, + reference_start=alignment.target_start, + ) + if input.reference_end != alignment.target_end { + raise SharedReferenceAlignmentError( + "pairwise target coordinates disagree with its aligned reference", + ) + } + if query.end != alignment.query_end { + raise SharedReferenceAlignmentError( + "pairwise query coordinates disagree with its aligned query", + ) + } + input +} + +///| +/// Count reference-gap columns at every boundary in one input alignment. +fn shared_reference_slot_widths( + aligned_reference : String, + span : Int, +) -> Array[Int] raise SharedReferenceAlignmentError { + let widths = Array::make(span + 1, 0) + let mut reference_offset = 0 + let mut column = 0 + while column < aligned_reference.length() { + let residue = aligned_reference.unsafe_get(column).unsafe_to_char() + if residue == '-' { + widths[reference_offset] = widths[reference_offset] + 1 + } else { + reference_offset = reference_offset + 1 + if reference_offset > span { + raise SharedReferenceAlignmentError( + "aligned reference is longer than its declared span", + ) + } + } + column = column + 1 + } + if reference_offset != span { + raise SharedReferenceAlignmentError( + "aligned reference is shorter than its declared span", + ) + } + widths +} + +///| +/// Render a reference row with synchronized insertion slots. +fn shared_reference_render_reference( + reference : String, + reference_start : Int, + span : Int, + insertion_widths : Array[Int], +) -> String { + let result = StringBuilder::new() + let mut boundary = 0 + while boundary <= span { + result.write_string("-".repeat(insertion_widths[boundary])) + if boundary < span { + result.write_char( + reference.unsafe_get(reference_start + boundary).unsafe_to_char(), + ) + } + boundary = boundary + 1 + } + result.to_string() +} + +///| +/// Project one query into the synchronized insertion slots. +fn shared_reference_project_query( + aligned_reference : String, + aligned_query : String, + span : Int, + insertion_widths : Array[Int], +) -> String raise SharedReferenceAlignmentError { + let insertions : Array[StringBuilder] = [] + let bases = Array::make(span, '-') + let mut boundary = 0 + while boundary <= span { + insertions.push(StringBuilder::new()) + boundary = boundary + 1 + } + let mut reference_offset = 0 + let mut column = 0 + while column < aligned_reference.length() { + let reference_residue = aligned_reference + .unsafe_get(column) + .unsafe_to_char() + let query_residue = aligned_query.unsafe_get(column).unsafe_to_char() + if reference_residue == '-' { + insertions[reference_offset].write_char(query_residue) + } else { + if reference_offset >= span { + raise SharedReferenceAlignmentError( + "query projection exceeded the reference span", + ) + } + bases[reference_offset] = query_residue + reference_offset = reference_offset + 1 + } + column = column + 1 + } + if reference_offset != span { + raise SharedReferenceAlignmentError( + "query projection did not cover the reference span", + ) + } + let result = StringBuilder::new() + boundary = 0 + while boundary <= span { + let insertion = insertions[boundary].to_string() + result.write_string(insertion) + let padding = insertion_widths[boundary] - insertion.length() + if padding < 0 { + raise SharedReferenceAlignmentError( + "query insertion is wider than its synchronized slot", + ) + } + result.write_string("-".repeat(padding)) + if boundary < span { + result.write_char(bases[boundary]) + } + boundary = boundary + 1 + } + result.to_string() +} + +///| +/// Merge alignments whose first row is the same reference sequence. +/// +/// Queries are not realigned against each other. At each reference boundary, +/// the insertion slot is widened to the largest width found in any input. +pub fn alignments_with_same_reference( + inputs : Array[SharedReferenceInput], +) -> SharedReferenceAlignment raise SharedReferenceAlignmentError { + if inputs.length() == 0 { + raise SharedReferenceAlignmentError("no alignments were provided") + } + let first = inputs[0] + let reference_length = first.reference.length() + let reference_start = first.reference_start + let reference_end = first.reference_end + let span = reference_end - reference_start + let insertion_widths = Array::make(span + 1, 0) + let mut query_count = 0 + for input in inputs { + if input.reference.length() != reference_length { + raise SharedReferenceAlignmentError( + "all reference sequences must have the same length", + ) + } + if !shared_reference_same_sequence(input.reference, first.reference) { + raise SharedReferenceAlignmentError("all reference sequences must match") + } + if input.reference_start != reference_start || + input.reference_end != reference_end { + raise SharedReferenceAlignmentError( + "reference coordinates are inconsistent across alignments", + ) + } + let widths = shared_reference_slot_widths(input.aligned_reference, span) + let mut boundary = 0 + while boundary <= span { + if widths[boundary] > insertion_widths[boundary] { + insertion_widths[boundary] = widths[boundary] + } + boundary = boundary + 1 + } + query_count = query_count + input.queries.length() + } + if query_count == 0 { + raise SharedReferenceAlignmentError( + "the alignments do not contain query sequences", + ) + } + let aligned_reference = shared_reference_render_reference( + first.reference, + reference_start, + span, + insertion_widths, + ) + let merged_queries : Array[SharedReferenceSequence] = [] + for input in inputs { + for query in input.queries { + let aligned_sequence = shared_reference_project_query( + input.aligned_reference, + query.aligned_sequence, + span, + insertion_widths, + ) + merged_queries.push(SharedReferenceSequence::{ + name: query.name, + description: query.description, + sequence: query.sequence, + aligned_sequence, + start: query.start, + end: query.end, + }) + } + } + SharedReferenceAlignment::{ + reference_name: first.reference_name, + reference_description: first.reference_description, + reference: first.reference, + reference_start, + reference_end, + aligned_reference, + queries: merged_queries, + insertion_widths, + } +} + +///| +/// Return the number of rows, including the reference. +pub fn SharedReferenceAlignment::num_sequences( + self : SharedReferenceAlignment, +) -> Int { + self.queries.length() + 1 +} + +///| +/// Return the number of query rows. +pub fn SharedReferenceAlignment::num_queries( + self : SharedReferenceAlignment, +) -> Int { + self.queries.length() +} + +///| +/// Return the number of alignment columns. +pub fn SharedReferenceAlignment::alignment_length( + self : SharedReferenceAlignment, +) -> Int { + self.aligned_reference.length() +} + +///| +/// Return an aligned row by MSA row index; row zero is the reference. +pub fn SharedReferenceAlignment::row( + self : SharedReferenceAlignment, + index : Int, +) -> String? { + if index == 0 { + Some(self.aligned_reference) + } else if index > 0 && index <= self.queries.length() { + Some(self.queries[index - 1].aligned_sequence) + } else { + None + } +} + +///| +/// Return a row name by MSA row index. +pub fn SharedReferenceAlignment::row_name( + self : SharedReferenceAlignment, + index : Int, +) -> String? { + if index == 0 { + Some(self.reference_name) + } else if index > 0 && index <= self.queries.length() { + Some(self.queries[index - 1].name) + } else { + None + } +} + +///| +/// Find the first merged query by name. +pub fn SharedReferenceAlignment::find_query( + self : SharedReferenceAlignment, + name : String, +) -> SharedReferenceSequence? { + for query in self.queries { + if query.name == name { + return Some(query) + } + } + None +} + +///| +/// Return a column containing the reference followed by all queries. +pub fn SharedReferenceAlignment::column( + self : SharedReferenceAlignment, + index : Int, +) -> String? { + if index < 0 || index >= self.alignment_length() { + return None + } + let result = StringBuilder::new(size_hint=self.num_sequences()) + result.write_char(self.aligned_reference.unsafe_get(index).unsafe_to_char()) + for query in self.queries { + result.write_char(query.aligned_sequence.unsafe_get(index).unsafe_to_char()) + } + Some(result.to_string()) +} + +///| +/// Map an absolute reference position to an alignment column. +pub fn SharedReferenceAlignment::reference_to_column( + self : SharedReferenceAlignment, + position : Int, +) -> Int? { + if position < self.reference_start || position >= self.reference_end { + return None + } + let mut reference_position = self.reference_start + let mut column = 0 + while column < self.aligned_reference.length() { + let residue = self.aligned_reference.unsafe_get(column).unsafe_to_char() + if residue != '-' { + if reference_position == position { + return Some(column) + } + reference_position = reference_position + 1 + } + column = column + 1 + } + None +} + +///| +/// Map an alignment column to an absolute reference position. +pub fn SharedReferenceAlignment::column_to_reference( + self : SharedReferenceAlignment, + column : Int, +) -> Int? { + if column < 0 || column >= self.alignment_length() { + return None + } + let mut reference_position = self.reference_start + let mut index = 0 + while index <= column { + let residue = self.aligned_reference.unsafe_get(index).unsafe_to_char() + if residue != '-' { + if index == column { + return Some(reference_position) + } + reference_position = reference_position + 1 + } else if index == column { + return None + } + index = index + 1 + } + None +} + +///| +/// Map an absolute query position to an alignment column. +pub fn SharedReferenceAlignment::query_to_column( + self : SharedReferenceAlignment, + query_index : Int, + position : Int, +) -> Int? { + if query_index < 0 || query_index >= self.queries.length() { + return None + } + let query = self.queries[query_index] + if position < query.start || position >= query.end { + return None + } + let mut query_position = query.start + let mut column = 0 + while column < query.aligned_sequence.length() { + let residue = query.aligned_sequence.unsafe_get(column).unsafe_to_char() + if residue != '-' { + if query_position == position { + return Some(column) + } + query_position = query_position + 1 + } + column = column + 1 + } + None +} + +///| +/// Map an alignment column to an absolute query position. +pub fn SharedReferenceAlignment::column_to_query( + self : SharedReferenceAlignment, + query_index : Int, + column : Int, +) -> Int? { + if query_index < 0 || + query_index >= self.queries.length() || + column < 0 || + column >= self.alignment_length() { + return None + } + let query = self.queries[query_index] + let mut query_position = query.start + let mut index = 0 + while index <= column { + let residue = query.aligned_sequence.unsafe_get(index).unsafe_to_char() + if residue != '-' { + if index == column { + return Some(query_position) + } + query_position = query_position + 1 + } else if index == column { + return None + } + index = index + 1 + } + None +} + +///| +/// Map an absolute query position through the MSA to the reference. +pub fn SharedReferenceAlignment::query_to_reference( + self : SharedReferenceAlignment, + query_index : Int, + position : Int, +) -> Int? { + match self.query_to_column(query_index, position) { + Some(column) => self.column_to_reference(column) + None => None + } +} + +///| +/// Map an absolute reference position through the MSA to one query. +pub fn SharedReferenceAlignment::reference_to_query( + self : SharedReferenceAlignment, + query_index : Int, + position : Int, +) -> Int? { + match self.reference_to_column(position) { + Some(column) => self.column_to_query(query_index, column) + None => None + } +} + +///| +/// Count matches, mismatches, insertions, and deletions for one query. +pub fn SharedReferenceAlignment::counts( + self : SharedReferenceAlignment, + query_index : Int, +) -> SharedReferenceCounts? { + if query_index < 0 || query_index >= self.queries.length() { + return None + } + let query = self.queries[query_index] + let mut identities = 0 + let mut mismatches = 0 + let mut insertions = 0 + let mut deletions = 0 + let mut column = 0 + while column < self.alignment_length() { + let reference_residue = self.aligned_reference + .unsafe_get(column) + .unsafe_to_char() + let query_residue = query.aligned_sequence + .unsafe_get(column) + .unsafe_to_char() + if reference_residue == '-' { + if query_residue != '-' { + insertions = insertions + 1 + } + } else if query_residue == '-' { + deletions = deletions + 1 + } else if reference_residue.to_string().to_upper() == + query_residue.to_string().to_upper() { + identities = identities + 1 + } else { + mismatches = mismatches + 1 + } + column = column + 1 + } + Some(SharedReferenceCounts::{ + identities, + mismatches, + insertions, + deletions, + aligned_pairs: identities + mismatches, + }) +} + +///| +/// Percent identity among residue pairs, excluding gaps. +pub fn SharedReferenceCounts::identity_percent( + self : SharedReferenceCounts, +) -> Double { + if self.aligned_pairs == 0 { + 0.0 + } else { + self.identities.to_double() / self.aligned_pairs.to_double() * 100.0 + } +} + +///| +/// Convert the merged alignment to the existing MultipleSeqAlignment type. +pub fn SharedReferenceAlignment::to_msa( + self : SharedReferenceAlignment, +) -> MultipleSeqAlignment raise AlignIOError { + let records : Array[SeqRecord] = [ + SeqRecord::new( + Seq::new(self.aligned_reference), + id=self.reference_name, + name=self.reference_name, + description=self.reference_description, + ), + ] + for query in self.queries { + records.push( + SeqRecord::new( + Seq::new(query.aligned_sequence), + id=query.name, + name=query.name, + description=query.description, + ), + ) + } + MultipleSeqAlignment::new(records) +} + +///| +/// Serialize the merged alignment as aligned FASTA. +pub fn SharedReferenceAlignment::to_fasta( + self : SharedReferenceAlignment, +) -> String { + let result = StringBuilder::new() + result.write_char('>') + result.write_string(self.reference_name) + if self.reference_description != "" { + result.write_char(' ') + result.write_string(self.reference_description) + } + result.write_char('\n') + result.write_string(self.aligned_reference) + result.write_char('\n') + for query in self.queries { + result.write_char('>') + result.write_string(query.name) + if query.description != "" { + result.write_char(' ') + result.write_string(query.description) + } + result.write_char('\n') + result.write_string(query.aligned_sequence) + result.write_char('\n') + } + result.to_string() +} + +///| +/// Return a concise summary of a merged shared-reference alignment. +pub fn SharedReferenceAlignment::summary( + self : SharedReferenceAlignment, +) -> String { + "Shared-reference alignment: " + + self.num_sequences().to_string() + + " sequences, " + + self.alignment_length().to_string() + + " columns, reference " + + self.reference_start.to_string() + + ":" + + self.reference_end.to_string() +} + +///| +/// Deterministic sample combining one PWA and one three-row alignment. +pub fn shared_reference_alignment_sample() -> SharedReferenceAlignment raise SharedReferenceAlignmentError { + let first_query = shared_reference_sequence( + "seq1", + "AC-T", + description="one deletion", + ) + let first = shared_reference_input( + "ACGT", + "ACGT", + [first_query], + reference_name="reference", + reference_description="shared reference", + ) + let second_query = shared_reference_sequence( + "seq2", + "ACGGT", + description="one insertion", + ) + let third_query = shared_reference_sequence( + "seq3", + "A---T", + description="two deletions", + ) + let second = shared_reference_input( + "ACGT", + "ACG-T", + [second_query, third_query], + reference_name="reference", + reference_description="shared reference", + ) + alignments_with_same_reference([first, second]) +} diff --git a/test/moonbit/shared_reference_alignment_test.mbt b/test/moonbit/shared_reference_alignment_test.mbt new file mode 100644 index 00000000..77b3e8e9 --- /dev/null +++ b/test/moonbit/shared_reference_alignment_test.mbt @@ -0,0 +1,591 @@ +///| +fn shared_reference_test_sequence( + name : String, + aligned : String, +) -> @src.SharedReferenceSequence { + @src.shared_reference_sequence(name, aligned) catch { + _ => abort("valid shared-reference sequence should build") + } +} + +///| +fn shared_reference_test_input( + aligned_reference : String, + queries : Array[@src.SharedReferenceSequence], +) -> @src.SharedReferenceInput { + @src.shared_reference_input( + "ACGT", + aligned_reference, + queries, + reference_name="reference", + ) catch { + _ => abort("valid shared-reference input should build") + } +} + +///| +fn shared_reference_test_sample() -> @src.SharedReferenceAlignment { + @src.shared_reference_alignment_sample() catch { + _ => abort("shared-reference sample should merge") + } +} + +///| +test "shared reference: query constructor derives ungapped sequence" { + let query = shared_reference_test_sequence("read", "AC-GT") + assert_eq(query.name, "read") + assert_eq(query.sequence, "ACGT") + assert_eq(query.aligned_sequence, "AC-GT") + assert_eq(query.start, 0) + assert_eq(query.end, 4) +} + +///| +test "shared reference: query constructor preserves local coordinates" { + let query = @src.shared_reference_sequence( + "read", + "AC-GT", + sequence="NNACGTNN", + start=2, + ) catch { + _ => abort("valid local query should build") + } + assert_eq(query.sequence, "NNACGTNN") + assert_eq(query.start, 2) + assert_eq(query.end, 6) +} + +///| +test "shared reference: query constructor rejects negative start" { + let failed = try { + ignore(@src.shared_reference_sequence("read", "ACGT", start=-1)) + false + } catch { + SharedReferenceAlignmentError(_) => true + } + assert_true(failed) +} + +///| +test "shared reference: query constructor rejects sequence mismatch" { + let failed = try { + ignore( + @src.shared_reference_sequence("read", "ACGT", sequence="AACCAA", start=1), + ) + false + } catch { + SharedReferenceAlignmentError(_) => true + } + assert_true(failed) +} + +///| +test "shared reference: query constructor rejects whitespace" { + let failed = try { + ignore(@src.shared_reference_sequence("read", "AC GT")) + false + } catch { + SharedReferenceAlignmentError(_) => true + } + assert_true(failed) +} + +///| +test "shared reference: input validates and records reference span" { + let query = shared_reference_test_sequence("read", "AC-GT") + let input = shared_reference_test_input("AC-GT", [query]) + assert_eq(input.reference, "ACGT") + assert_eq(input.reference_start, 0) + assert_eq(input.reference_end, 4) + assert_eq(input.queries.length(), 1) +} + +///| +test "shared reference: input preserves reference metadata" { + let query = shared_reference_test_sequence("read", "ACGT") + let input = @src.shared_reference_input( + "ACGT", + "ACGT", + [query], + reference_name="plasmid", + reference_description="circular construct", + ) catch { + _ => abort("valid input should build") + } + assert_eq(input.reference_name, "plasmid") + assert_eq(input.reference_description, "circular construct") +} + +///| +test "shared reference: input copies caller query array" { + let queries = [shared_reference_test_sequence("read", "ACGT")] + let input = shared_reference_test_input("ACGT", queries) + queries.push(shared_reference_test_sequence("later", "ACGT")) + assert_eq(input.queries.length(), 1) +} + +///| +test "shared reference: input rejects empty reference" { + let query = shared_reference_test_sequence("read", "") + let failed = try { + ignore(@src.shared_reference_input("", "", [query])) + false + } catch { + SharedReferenceAlignmentError(_) => true + } + assert_true(failed) +} + +///| +test "shared reference: input rejects missing queries" { + let failed = try { + ignore(@src.shared_reference_input("ACGT", "ACGT", [])) + false + } catch { + SharedReferenceAlignmentError(_) => true + } + assert_true(failed) +} + +///| +test "shared reference: input rejects unequal row lengths" { + let query = shared_reference_test_sequence("read", "ACGT") + let failed = try { + ignore(@src.shared_reference_input("ACGT", "AC-GT", [query])) + false + } catch { + SharedReferenceAlignmentError(_) => true + } + assert_true(failed) +} + +///| +test "shared reference: input rejects aligned reference mismatch" { + let query = shared_reference_test_sequence("read", "AGGT") + let failed = try { + ignore(@src.shared_reference_input("ACGT", "AGGT", [query])) + false + } catch { + SharedReferenceAlignmentError(_) => true + } + assert_true(failed) +} + +///| +test "shared reference: official mixed PWA MSA example" { + let alignment = shared_reference_test_sample() + assert_eq(alignment.num_sequences(), 4) + assert_eq(alignment.num_queries(), 3) + assert_eq(alignment.alignment_length(), 5) + assert_eq(alignment.row(0), Some("ACG-T")) + assert_eq(alignment.row(1), Some("AC--T")) + assert_eq(alignment.row(2), Some("ACGGT")) + assert_eq(alignment.row(3), Some("A---T")) +} + +///| +test "shared reference: sample synchronizes insertion slots" { + let alignment = shared_reference_test_sample() + assert_eq(alignment.insertion_widths, [0, 0, 0, 1, 0]) + assert_eq(alignment.aligned_reference, "ACG-T") +} + +///| +test "shared reference: query ordering and metadata are stable" { + let alignment = shared_reference_test_sample() + assert_eq(alignment.queries[0].name, "seq1") + assert_eq(alignment.queries[1].name, "seq2") + assert_eq(alignment.queries[2].name, "seq3") + assert_eq(alignment.queries[1].description, "one insertion") +} + +///| +test "shared reference: leading insertion is synchronized" { + let first = shared_reference_test_input("-ACGT", [ + shared_reference_test_sequence("inserted", "TACGT"), + ]) + let second = shared_reference_test_input("ACGT", [ + shared_reference_test_sequence("plain", "ACGT"), + ]) + let alignment = @src.alignments_with_same_reference([first, second]) catch { + _ => abort("leading insertion should merge") + } + assert_eq(alignment.aligned_reference, "-ACGT") + assert_eq(alignment.queries[0].aligned_sequence, "TACGT") + assert_eq(alignment.queries[1].aligned_sequence, "-ACGT") +} + +///| +test "shared reference: trailing insertion is synchronized" { + let first = shared_reference_test_input("ACGT--", [ + shared_reference_test_sequence("inserted", "ACGTAA"), + ]) + let second = shared_reference_test_input("ACGT", [ + shared_reference_test_sequence("plain", "ACGT"), + ]) + let alignment = @src.alignments_with_same_reference([first, second]) catch { + _ => abort("trailing insertion should merge") + } + assert_eq(alignment.aligned_reference, "ACGT--") + assert_eq(alignment.queries[1].aligned_sequence, "ACGT--") +} + +///| +test "shared reference: widest insertion controls slot width" { + let short = shared_reference_test_input("AC-GT", [ + shared_reference_test_sequence("short", "ACTGT"), + ]) + let long = shared_reference_test_input("AC---GT", [ + shared_reference_test_sequence("long", "ACTTTGT"), + ]) + let alignment = @src.alignments_with_same_reference([short, long]) catch { + _ => abort("different insertion widths should merge") + } + assert_eq(alignment.aligned_reference, "AC---GT") + assert_eq(alignment.queries[0].aligned_sequence, "ACT--GT") + assert_eq(alignment.queries[1].aligned_sequence, "ACTTTGT") +} + +///| +test "shared reference: insertions at distinct boundaries are retained" { + let left = shared_reference_test_input("A-CGT", [ + shared_reference_test_sequence("left", "ATCGT"), + ]) + let right = shared_reference_test_input("ACG-T", [ + shared_reference_test_sequence("right", "ACGGT"), + ]) + let alignment = @src.alignments_with_same_reference([left, right]) catch { + _ => abort("distinct insertion slots should merge") + } + assert_eq(alignment.aligned_reference, "A-CG-T") + assert_eq(alignment.queries[0].aligned_sequence, "ATCG-T") + assert_eq(alignment.queries[1].aligned_sequence, "A-CGGT") +} + +///| +test "shared reference: multi-query input preserves internal gap columns" { + let first = shared_reference_test_input("AC--GT", [ + shared_reference_test_sequence("one", "ACT-GT"), + shared_reference_test_sequence("two", "AC-TGT"), + ]) + let second = shared_reference_test_input("ACGT", [ + shared_reference_test_sequence("plain", "ACGT"), + ]) + let alignment = @src.alignments_with_same_reference([first, second]) catch { + _ => abort("multi-query input should merge") + } + assert_eq(alignment.queries[0].aligned_sequence, "ACT-GT") + assert_eq(alignment.queries[1].aligned_sequence, "AC-TGT") + assert_eq(alignment.queries[2].aligned_sequence, "AC--GT") +} + +///| +test "shared reference: reference comparison is case insensitive" { + let upper = shared_reference_test_input("ACGT", [ + shared_reference_test_sequence("upper", "ACGT"), + ]) + let lower_query = shared_reference_test_sequence("lower", "acgt") + let lower = @src.shared_reference_input("acgt", "acgt", [lower_query]) catch { + _ => abort("lowercase input should build") + } + let alignment = @src.alignments_with_same_reference([upper, lower]) catch { + _ => abort("case-insensitive references should merge") + } + assert_eq(alignment.num_queries(), 2) +} + +///| +test "shared reference: merge rejects reference length mismatch" { + let first = shared_reference_test_input("ACGT", [ + shared_reference_test_sequence("one", "ACGT"), + ]) + let query = shared_reference_test_sequence("two", "ACGTA") + let second = @src.shared_reference_input("ACGTA", "ACGTA", [query]) catch { + _ => abort("second input should build") + } + let failed = try { + ignore(@src.alignments_with_same_reference([first, second])) + false + } catch { + SharedReferenceAlignmentError(_) => true + } + assert_true(failed) +} + +///| +test "shared reference: merge rejects reference content mismatch" { + let first = shared_reference_test_input("ACGT", [ + shared_reference_test_sequence("one", "ACGT"), + ]) + let query = shared_reference_test_sequence("two", "AGGT") + let second = @src.shared_reference_input("AGGT", "AGGT", [query]) catch { + _ => abort("second input should build") + } + let failed = try { + ignore(@src.alignments_with_same_reference([first, second])) + false + } catch { + SharedReferenceAlignmentError(_) => true + } + assert_true(failed) +} + +///| +test "shared reference: merge rejects inconsistent reference coordinates" { + let query1 = shared_reference_test_sequence("one", "ACGT") + let first = @src.shared_reference_input( + "AACGTT", + "ACGT", + [query1], + reference_start=1, + ) catch { + _ => abort("first local input should build") + } + let query2 = shared_reference_test_sequence("two", "AACG") + let second = @src.shared_reference_input( + "AACGTT", + "AACG", + [query2], + reference_start=0, + ) catch { + _ => abort("second local input should build") + } + let failed = try { + ignore(@src.alignments_with_same_reference([first, second])) + false + } catch { + SharedReferenceAlignmentError(_) => true + } + assert_true(failed) +} + +///| +test "shared reference: merge rejects empty input list" { + let failed = try { + ignore(@src.alignments_with_same_reference([])) + false + } catch { + SharedReferenceAlignmentError(_) => true + } + assert_true(failed) +} + +///| +test "shared reference: PairwiseAlignment adapter preserves global rows" { + let pairwise = @src.pairaligner_align("ACGT", "ACGGT") + let input = @src.shared_reference_input_from_pairwise( + pairwise, + reference_name="ref", + query_name="read", + ) catch { + _ => abort("global pairwise alignment should adapt") + } + assert_eq(input.reference, "ACGT") + assert_eq(input.reference_name, "ref") + assert_eq(input.queries[0].name, "read") + assert_eq(input.reference_start, 0) + assert_eq(input.reference_end, 4) +} + +///| +test "shared reference: PairwiseAlignment adapter preserves local offsets" { + let config = @src.PairwiseAlignerConfig::default_dna().set_mode( + @src.pairaligner_local(), + ) + let pairwise = @src.pairaligner_align("NNACGTNN", "TTACGTTT", config~) + let input = @src.shared_reference_input_from_pairwise( + pairwise, + query_name="local", + ) catch { + _ => abort("local pairwise alignment should adapt") + } + assert_eq(input.reference_start, 2) + assert_eq(input.reference_end, 6) + assert_eq(input.queries[0].start, 2) + assert_eq(input.queries[0].end, 6) +} + +///| +test "shared reference: row access includes reference and bounds checks" { + let alignment = shared_reference_test_sample() + assert_eq(alignment.row_name(0), Some("reference")) + assert_eq(alignment.row_name(2), Some("seq2")) + assert_eq(alignment.row(-1), None) + assert_eq(alignment.row(4), None) + assert_eq(alignment.row_name(4), None) +} + +///| +test "shared reference: column access returns all rows" { + let alignment = shared_reference_test_sample() + assert_eq(alignment.column(0), Some("AAAA")) + assert_eq(alignment.column(2), Some("G-G-")) + assert_eq(alignment.column(3), Some("--G-")) + assert_eq(alignment.column(-1), None) + assert_eq(alignment.column(5), None) +} + +///| +test "shared reference: reference column mapping skips insertion columns" { + let alignment = shared_reference_test_sample() + assert_eq(alignment.reference_to_column(0), Some(0)) + assert_eq(alignment.reference_to_column(2), Some(2)) + assert_eq(alignment.reference_to_column(3), Some(4)) + assert_eq(alignment.column_to_reference(3), None) + assert_eq(alignment.column_to_reference(4), Some(3)) +} + +///| +test "shared reference: query column mapping tracks insertions" { + let alignment = shared_reference_test_sample() + assert_eq(alignment.query_to_column(1, 2), Some(2)) + assert_eq(alignment.query_to_column(1, 3), Some(3)) + assert_eq(alignment.query_to_column(1, 4), Some(4)) + assert_eq(alignment.column_to_query(1, 3), Some(3)) + assert_eq(alignment.column_to_query(0, 3), None) +} + +///| +test "shared reference: query to reference maps insertion to none" { + let alignment = shared_reference_test_sample() + assert_eq(alignment.query_to_reference(1, 2), Some(2)) + assert_eq(alignment.query_to_reference(1, 3), None) + assert_eq(alignment.query_to_reference(1, 4), Some(3)) +} + +///| +test "shared reference: reference to query maps deletion to none" { + let alignment = shared_reference_test_sample() + assert_eq(alignment.reference_to_query(0, 0), Some(0)) + assert_eq(alignment.reference_to_query(0, 2), None) + assert_eq(alignment.reference_to_query(0, 3), Some(2)) +} + +///| +test "shared reference: counts classify deletion" { + let alignment = shared_reference_test_sample() + let counts = alignment.counts(0).unwrap() + assert_eq(counts.identities, 3) + assert_eq(counts.mismatches, 0) + assert_eq(counts.insertions, 0) + assert_eq(counts.deletions, 1) + assert_eq(counts.identity_percent(), 100.0) +} + +///| +test "shared reference: counts classify insertion" { + let alignment = shared_reference_test_sample() + let counts = alignment.counts(1).unwrap() + assert_eq(counts.identities, 4) + assert_eq(counts.insertions, 1) + assert_eq(counts.deletions, 0) + assert_eq(counts.aligned_pairs, 4) + assert_eq(alignment.counts(-1), None) +} + +///| +test "shared reference: find query returns metadata" { + let alignment = shared_reference_test_sample() + match alignment.find_query("seq2") { + Some(query) => assert_eq(query.description, "one insertion") + None => abort("seq2 should be present") + } + assert_eq(alignment.find_query("missing"), None) +} + +///| +test "shared reference: converts to MultipleSeqAlignment" { + let alignment = shared_reference_test_sample() + let msa = alignment.to_msa() catch { + _ => abort("valid shared-reference alignment should convert") + } + assert_eq(msa.num_records(), 4) + assert_eq(msa.get_alignment_length(), 5) + assert_eq(msa.records[0].id, "reference") + assert_eq(msa.records[1].description, "one deletion") + assert_eq(msa.records[2].seq.to_string(), "ACGGT") +} + +///| +test "shared reference: aligned FASTA preserves metadata" { + let alignment = shared_reference_test_sample() + assert_eq( + alignment.to_fasta(), + ">reference shared reference\nACG-T\n" + + ">seq1 one deletion\nAC--T\n" + + ">seq2 one insertion\nACGGT\n" + + ">seq3 two deletions\nA---T\n", + ) +} + +///| +test "shared reference: summary reports dimensions and span" { + let alignment = shared_reference_test_sample() + assert_eq( + alignment.summary(), + "Shared-reference alignment: 4 sequences, 5 columns, reference 0:4", + ) +} + +///| +test "shared reference: local alignment uses absolute coordinates" { + let first_query = @src.shared_reference_sequence( + "one", + "AC-GT", + sequence="NNACGTNN", + start=2, + ) catch { + _ => abort("local query should build") + } + let first = @src.shared_reference_input( + "NNAACGTNN", + "AC-GT", + [first_query], + reference_start=3, + ) catch { + _ => abort("local input should build") + } + let second_query = @src.shared_reference_sequence( + "two", + "ACGGT", + sequence="TTACGGTTT", + start=2, + ) catch { + _ => abort("inserted local query should build") + } + let second = @src.shared_reference_input( + "NNAACGTNN", + "ACG-T", + [second_query], + reference_start=3, + ) catch { + _ => abort("second local input should build") + } + let alignment = @src.alignments_with_same_reference([first, second]) catch { + _ => abort("local inputs should merge") + } + assert_eq(alignment.reference_start, 3) + assert_eq(alignment.reference_end, 7) + assert_eq(alignment.reference_to_column(6), Some(5)) + assert_eq(alignment.query_to_reference(1, 5), None) + assert_eq(alignment.query_to_reference(1, 6), Some(6)) +} + +///| +test "shared reference: supports protein residues and mismatches" { + let first_query = shared_reference_test_sequence("one", "MKTL") + let first = @src.shared_reference_input("MKTL", "MKTL", [first_query]) catch { + _ => abort("protein input should build") + } + let second_query = shared_reference_test_sequence("two", "MRATL") + let second = @src.shared_reference_input("MKTL", "MK-TL", [second_query]) catch { + _ => abort("inserted protein input should build") + } + let alignment = @src.alignments_with_same_reference([first, second]) catch { + _ => abort("protein alignments should merge") + } + let counts = alignment.counts(1).unwrap() + assert_eq(counts.identities, 3) + assert_eq(counts.mismatches, 1) + assert_eq(counts.insertions, 1) +} From cebe4c5be0b4b81e12ef2059c844e5c178874edf Mon Sep 17 00:00:00 2001 From: eda Date: Tue, 4 Aug 2026 23:33:33 +0800 Subject: [PATCH 15/41] #28 feat(decontx): Bioconductor decontX k-means & SingleCellExperiment --- README.md | 24 +- examples/decontx_demo/main.mbt | 109 ++++ examples/decontx_demo/moon.pkg | 5 + src/decontx.mbt | 997 +++++++++++++++++++++++++++++++++ test/moonbit/decontx_test.mbt | 656 ++++++++++++++++++++++ 5 files changed, 1787 insertions(+), 4 deletions(-) create mode 100644 examples/decontx_demo/main.mbt create mode 100644 examples/decontx_demo/moon.pkg create mode 100644 src/decontx.mbt create mode 100644 test/moonbit/decontx_test.mbt diff --git a/README.md b/README.md index 0f4d7ab7..77bcb9e6 100644 --- a/README.md +++ b/README.md @@ -159,6 +159,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | Bio.SearchIO.InfernalIO | Infernal cmscan/cmsearch解析: tabular格式1/2/3自动检测、non-verbose文本与--noali、CM/HMM-only、Query/Hit/HSP/Fragment层次、正负链坐标、local-end多片段、过滤与SearchIO转换 | | ✅ | Bioconductor variancePartition | 多随机截距线性混合模型、ML/REML方差分量、固定/随机/残差方差占比、precision weights、BLUP、dream contrast、数值Satterthwaite检验、BH-FDR与SummarizedExperiment接入 | | ✅ | Bio.Align.Alignment shared-reference merge | 共享参考PWA/MSA合并、reference-boundary insertion slot同步、局部reference/query坐标、metadata、统计、MSA与aligned FASTA转换 | +| ✅ | Bioconductor decontX | 单细胞ambient RNA去污染: cluster-native/contaminant多项式混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解、诊断与SingleCellExperiment接入 | | ✅ | Bio.PDB.SASA | 溶剂可及表面积计算: Shrake-Rupley滚动球算法(Fibonacci球面采样)、范德华半径查表、逐原子/残基/链SASA、骨架/侧链拆分 | | ✅ | Bio.SeqIO.NibIO | nib 2-bit二进制序列格式: DNA 2-bit编码(T=0/C=1/A=2/G=3)、4碱基/字节打包、hex I/O、子序列提取、反向互补、GC含量、压缩比 | | ✅ | ChIPseeker | ChIP-seq峰注释: 峰-TSS距离计算、基因组特征分配(Promoter/5'UTR/3'UTR/Exon/Intron/Downstream/Distal Intergenic)、最近基因查找、注释摘要 | @@ -284,6 +285,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **BiocGenerics** | Bioconductor BiocGenerics | Bioconductor通用函数、NA处理、排序、集合运算、匹配、表统计、序列生成 | ✅ | | **scran** | Bioconductor scran | 单细胞归一化(sum_factors)、SNN图构建、Leiden聚类、差异标志物分析 | ✅ | | **scrapper** | Bioconductor scrapper | 批次感知RNA QC、大小因子清洗与居中、log-normalization、LOWESS方差趋势、HVG选择、多因子pseudo-bulk、不可变SCE集成 | ✅ | +| **decontX** | Bioconductor decontX | cluster-aware ambient RNA混合模型、每细胞污染率、Beta/Dirichlet先验EM、empty-droplet profile、自动k-means、native/contaminant计数分解与SCE集成 | ✅ | | **miloR** | Bioconductor miloR | 精确KNN图、精炼重叠邻域、邻域×样本计数、NB-GLM/Wald检验、BH与四种graph spatial FDR、SingleCellExperiment接入 | ✅ | | **monocle3** | Bioconductor monocle3 | 单细胞轨迹分析、PCA/UMAP降维、主图学习、拟时间排序、差异表达分析、分支点检测、分支特异性差异表达 | ✅ | | **ShortRead** | Bioconductor ShortRead | 短读序列质量控制、QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告生成 | ✅ | @@ -542,6 +544,7 @@ IvanAXu/BioSeqs/ │ ├── droplet_utils.mbt # DropletUtils 空液滴检测 (emptyDrops算法、knee点检测、细胞过滤) │ ├── scran.mbt # scran 单细胞归一化与聚类 (sum_factors、SNN图、Leiden聚类、标志物分析) │ ├── scrapper.mbt # scrapper 单细胞预处理 (批次感知RNA QC、大小因子、LOWESS/HVG、pseudo-bulk、SCE集成) +│ ├── decontx.mbt # decontX ambient RNA去污染 (Bayesian EM、background、自动聚类、计数分解、SCE集成) │ ├── milo.mbt # miloR KNN邻域差异丰度 (精炼采样、NB-GLM、graph spatial FDR、SCE接入) │ ├── variance_partition.mbt # variancePartition 混合模型方差分解、BLUP与dream重复测量检验 │ ├── monocle3.mbt # monocle3 单细胞轨迹分析 (PCA/UMAP降维、主图学习、拟时间排序) @@ -888,6 +891,7 @@ IvanAXu/BioSeqs/ │ ├── droplet_utils_demo/ # DropletUtils 空液滴检测示例 (emptyDrops算法、knee点检测、细胞过滤) │ ├── scran_demo/ # scran 单细胞归一化与聚类示例 (sum_factors、SNN图、Leiden聚类、标志物分析) │ ├── scrapper_demo/ # scrapper 批次感知RNA QC、归一化、LOWESS/HVG、pseudo-bulk与SCE集成示例 +│ ├── decontx_demo/ # decontX cluster/background去污染、marker校正、诊断与SCE输出示例 │ ├── milo_demo/ # miloR KNN图、精炼邻域、NB差异丰度、spatial FDR与SCE接入示例 │ ├── variance_partition_demo/ # variancePartition 方差分解、BLUP、precision weights、dream与SE接入示例 │ ├── monocle3_demo/ # monocle3 单细胞轨迹分析示例 (PCA/UMAP降维、主图学习、拟时间排序) @@ -1288,6 +1292,7 @@ IvanAXu/BioSeqs/ │ │ ├── scnorm_test.mbt │ │ ├── scran_test.mbt │ │ ├── scrapper_test.mbt +│ │ ├── decontx_test.mbt │ │ ├── milo_test.mbt │ │ ├── variance_partition_test.mbt │ │ ├── shared_reference_alignment_test.mbt @@ -1467,7 +1472,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8634 个测试全部通过 +moon test # ✅ 8677 个测试全部通过 ``` ### 模块对照表 @@ -1569,6 +1574,7 @@ moon test # ✅ 8634 个测试全 | `edger_advanced.mbt` | edgeR QLF/Camera/Roast | 准似然F检验、QL分散度估计、camera竞争性基因集检验、roast自足基因集检验 | | `limma.mbt` | Bioconductor limma | 线性模型与 voom 变换 | | `variance_partition.mbt` | Bioconductor variancePartition | 多随机截距LMM、ML/REML方差分量、固定/随机/残差占比、BLUP、precision weights、dream contrast、数值Satterthwaite与BH-FDR | +| `decontx.mbt` | Bioconductor decontX | cluster-native/contaminant多项式混合、Beta/Dirichlet先验EM、background、自动聚类、计数分解与SCE输出 | | `summarized_experiment.mbt` | Bioconductor SummarizedExperiment | 多维数据容器 | | `ranged_summarized_experiment.mbt` | Bioconductor RangedSummarizedExperiment | GRanges/GRangesList行范围、链特异重叠/最近邻、覆盖度、区间变换与协调子集 | | `tree_summarized_experiment.mbt` | Bioconductor TreeSummarizedExperiment | 行/列树与数据链接、按节点子集、层级聚合 | @@ -1772,6 +1778,7 @@ moon test # ✅ 8634 个测试全 | `system_piper.mbt` | `SystemPipeR` | 流水线编排（步骤管理、依赖关系、进度追踪） | | `muscat.mbt` | `muscat` | 单细胞差异状态分析（伪批量聚合、DS 检验、QC） | | `scrapper.mbt` | `scrapper` | 批次感知RNA QC、大小因子清洗/居中、count与log归一化、LOWESS方差趋势、HVG选择、多因子pseudo-bulk、SingleCellExperiment不可变包装 | +| `decontx.mbt` | `decontX` | 每细胞native/contaminant Bayesian mixture、确定性EM、empty-droplet ambient profile、自动k-means、诊断与SingleCellExperiment不可变包装 | | `milo.mbt` | `miloR` | 精确KNN图、median精炼重叠邻域、邻域计数/表达、固定效应NB-GLM/Wald检验、graph spatial FDR与SCE接入 | | `variance_partition.mbt` | `variancePartition` | typed fixed/random design、多随机截距LMM、ML/REML方差分解、BLUP、weighted dream contrast、Satterthwaite自由度与SummarizedExperiment入口 | | `shared_reference_alignment.mbt` | `Bio.Align.Alignment` | 同参考PWA/MSA的reference-boundary insertion同步、原query投影、局部坐标、metadata、统计与格式转换 | @@ -2857,6 +2864,12 @@ observation-level precision weights 会先缩放到均值 1，并进入 `V = Σ `SharedReferenceAlignment` 保留参考/query名称、描述和局部坐标，提供 row/column 查询、reference/query/column 双向坐标映射，以及 identity、mismatch、insertion、deletion 统计。合并结果可转换为现有 `MultipleSeqAlignment` 或 aligned FASTA。算法复杂度为 `O(total input columns + merged rows × merged columns)`；当前要求所有输入覆盖同一参考区间，使用 `-` 表示 gap，不自动执行反向互补或 query 间二次比对。 +### 250. ambient RNA 去污染 (Bioconductor decontX) + +实现 Bioconductor `decontX` 的可移植单细胞 ambient RNA 去污染核心，输入统一为 gene × cell 非负计数矩阵。每个细胞由所属 cluster 的 native multinomial profile 与 contaminant multinomial profile 混合，污染率按细胞估计；无外部 background 时，污染 profile 由其他 cluster 的本征表达加权形成，提供 empty-droplet/background 矩阵时则使用固定的全局 ambient profile。确定性 EM 在 E-step 分解每个 gene × cell 的 native/contaminant 期望计数，在 M-step 更新 cluster profile 和污染率，并使用 Beta contamination prior、Dirichlet-style profile pseudocount、概率下限及 likelihood tolerance 控制收敛。 + +`decontx` 返回校正计数、污染计数、每细胞污染率、native/contaminant profiles、cluster 编码和完整 likelihood 诊断，且对每个观测保持 `corrected + contaminant = original`。查询 API 提供 cell/cluster estimates、最高污染细胞、名称索引和摘要；`decontx_auto` 对 library-size scaling 后的 `log(1 + count)` 表达执行确定性 k-means 初始化。`decontx_sce` 从指定 assay 和 cluster `colData` 读取输入，在复制的 `SingleCellExperiment` 中增加校正 assay、污染率、cluster 和迭代 metadata，不修改调用方对象。当前范围采用 cluster 标签或 k-means，而非上游 variational Bayes 聚类后端；不包含 GPU/稀疏矩阵专用求解器和绘图接口。 + ## 性能优化 ### 优化策略 @@ -2958,8 +2971,8 @@ observation-level precision weights 会先缩放到均值 1，并进入 `V = Σ | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8634 | -| 通过数 | 8634 | +| 总测试数 | 8677 | +| 通过数 | 8677 | | 失败数 | 0 | | 通过率 | 100% | @@ -3082,6 +3095,7 @@ moon test --update | DropletUtils | `droplet_utils_test.mbt` | 6 | | scran | `scran_test.mbt` | 8 | | scrapper | `scrapper_test.mbt` | 35 | +| decontX | `decontx_test.mbt` | 43 | | miloR | `milo_test.mbt` | 37 | | monocle3 | `monocle3_test.mbt` | 10 | | ShortRead | `short_read_test.mbt` | 15 | @@ -3357,7 +3371,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 357 个示例程序，展示各模块的典型用法： +项目提供 358 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3448,6 +3462,7 @@ moon run cmd/bench/main.mbt | short_read_demo | ShortRead 短读序列质量控制（QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告生成） | `moon run examples/short_read_demo/main.mbt` | | scater_demo | scater 单细胞质量控制（QC指标计算、细胞/基因过滤、CPM/log-CPM标准化、HVG检测、PCA降维） | `moon run examples/scater_demo/main.mbt` | | scrapper_demo | 批次感知RNA QC、大小因子归一化、LOWESS/HVG、多因子pseudo-bulk和不可变SCE集成 | `moon run examples/scrapper_demo` | +| decontx_demo | cluster/background ambient RNA去污染、每细胞污染率、marker校正、cluster诊断和不可变SCE输出 | `moon run examples/decontx_demo` | | milo_demo | 精确KNN图、精炼重叠邻域、样本计数、NB-GLM差异丰度、graph spatial FDR和SCE接入 | `moon run examples/milo_demo` | | mast_demo | MAST 单细胞差异表达分析（Hurdle模型、离散/连续检验、BH-FDR校正、结果汇总） | `moon run examples/mast_demo/main.mbt` | | genomic_files_demo | GenomicFiles 分布式基因组文件处理（BAM/BED/VCF扫描、区间查询、归约、覆盖度计算） | `moon run examples/genomic_files_demo/main.mbt` | @@ -3649,6 +3664,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bio.SearchIO.InfernalIO Infernal cmscan/cmsearch输出解析（tabular 1/2/3、non-verbose文本、--noali、CM/HMM-only、local-end多片段与SearchIO转换） - ✅ 实现 Bioconductor variancePartition 重复测量混合模型（ML/REML方差分解、BLUP、precision weights、dream contrast、数值Satterthwaite、BH-FDR与SummarizedExperiment接入） - ✅ 实现 Bio.Align共享参考序列比对合并（混合PWA/MSA、reference-boundary insertion同步、局部坐标、双向映射、统计与格式转换） +- ✅ 实现 Bioconductor decontX ambient RNA去污染（cluster-native/contaminant混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解与SCE集成） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/decontx_demo/main.mbt b/examples/decontx_demo/main.mbt new file mode 100644 index 00000000..6cc663dd --- /dev/null +++ b/examples/decontx_demo/main.mbt @@ -0,0 +1,109 @@ +///| +fn format_doubles(values : Array[Double]) -> String { + let mut result = "[" + let mut index = 0 + while index < values.length() { + if index > 0 { + result = result + ", " + } + result = result + values[index].to_string() + index = index + 1 + } + result + "]" +} + +///| +fn main { + println("=== Bioconductor decontX Demo ===") + let (counts, genes, cells, clusters, background) = @src.decontx_example_data() + + println("\n1. Infer cluster-aware ambient RNA contamination") + let result = @src.decontx(counts, genes, cells, clusters) catch { + _ => abort("failed to run cluster-aware decontX") + } + println(" " + result.summary()) + println(" per-cell contamination: " + format_doubles(result.contamination)) + + println("\n2. Inspect cross-population marker correction") + println( + " B marker in T1: observed=" + + counts[2][0].to_string() + + ", native=" + + result.corrected_counts[2][0].to_string() + + ", contaminant=" + + result.contamination_counts[2][0].to_string(), + ) + println( + " T marker in B1: observed=" + + counts[0][4].to_string() + + ", native=" + + result.corrected_counts[0][4].to_string() + + ", contaminant=" + + result.contamination_counts[0][4].to_string(), + ) + + println("\n3. Summarize contamination by cluster") + for estimate in result.cluster_estimates() { + println( + " " + + estimate.cluster + + ": cells=" + + estimate.n_cells.to_string() + + ", mean contamination=" + + estimate.mean_contamination.to_string() + + ", contaminant counts=" + + estimate.contaminant_counts.to_string(), + ) + } + let most_contaminated = result.most_contaminated_cells(2) + for estimate in most_contaminated { + println( + " high-contamination cell " + + estimate.cell_name + + ": " + + estimate.contamination.to_string(), + ) + } + + println("\n4. Use empty droplets as an explicit ambient profile") + let background_result = @src.decontx( + counts, + genes, + cells, + clusters, + background~, + ) catch { + _ => abort("failed to run background-aware decontX") + } + println(" " + background_result.summary()) + println( + " shared ambient profile: " + + format_doubles(background_result.contaminant_profiles[0]), + ) + + println("\n5. Add corrected counts and diagnostics to an SCE copy") + let sce = @src.SingleCellExperiment::new(counts, genes, cells) + sce.col_data["cluster"] = clusters + let output = @src.decontx_sce(sce, background~) catch { + _ => abort("failed to integrate decontX with SingleCellExperiment") + } + println( + " corrected assay dimensions: " + + @src.sce_get_assay(output.experiment, "decontXcounts").length().to_string() + + " genes x " + + output.result.n_cells().to_string() + + " cells", + ) + println( + " contamination metadata entries: " + + @src.sce_get_col_data(output.experiment, "decontX_contamination") + .length() + .to_string(), + ) + println( + " source object unchanged: " + + (@src.sce_get_assay(sce, "decontXcounts").length() == 0).to_string(), + ) + + println("\n=== Demo Complete ===") +} diff --git a/examples/decontx_demo/moon.pkg b/examples/decontx_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/decontx_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/decontx.mbt b/src/decontx.mbt new file mode 100644 index 00000000..753d8c04 --- /dev/null +++ b/src/decontx.mbt @@ -0,0 +1,997 @@ +// Ambient RNA decontamination for single-cell count matrices. +// +// This module follows the model introduced by Bioconductor decontX: +// each cell is a mixture of its cluster-native multinomial distribution +// and a contamination distribution derived from the other populations. + +///| +pub suberror DecontXError { + DecontXError(String) +} + +///| +/// Parameters for deterministic expectation-maximization inference. +pub struct DecontXConfig { + max_iterations : Int + tolerance : Double + contamination_prior_alpha : Double + contamination_prior_beta : Double + profile_pseudocount : Double + initial_contamination : Double + minimum_probability : Double +} derive(Eq, Debug) + +///| +pub fn DecontXConfig::create( + max_iterations? : Int = 100, + tolerance? : Double = 1.0e-6, + contamination_prior_alpha? : Double = 1.0, + contamination_prior_beta? : Double = 9.0, + profile_pseudocount? : Double = 0.5, + initial_contamination? : Double = 0.1, + minimum_probability? : Double = 1.0e-12, +) -> DecontXConfig raise DecontXError { + if max_iterations < 1 { + raise DecontXError::DecontXError("max_iterations must be positive") + } + if tolerance <= 0.0 { + raise DecontXError::DecontXError("tolerance must be positive") + } + if contamination_prior_alpha <= 0.0 || contamination_prior_beta <= 0.0 { + raise DecontXError::DecontXError("Beta prior parameters must be positive") + } + if profile_pseudocount <= 0.0 { + raise DecontXError::DecontXError("profile_pseudocount must be positive") + } + if initial_contamination < 0.0 || initial_contamination >= 1.0 { + raise DecontXError::DecontXError("initial_contamination must be in [0, 1)") + } + if minimum_probability <= 0.0 || minimum_probability >= 1.0 { + raise DecontXError::DecontXError("minimum_probability must be in (0, 1)") + } + DecontXConfig::{ + max_iterations, + tolerance, + contamination_prior_alpha, + contamination_prior_beta, + profile_pseudocount, + initial_contamination, + minimum_probability, + } +} + +///| +pub fn DecontXConfig::default() -> DecontXConfig { + DecontXConfig::{ + max_iterations: 100, + tolerance: 1.0e-6, + contamination_prior_alpha: 1.0, + contamination_prior_beta: 9.0, + profile_pseudocount: 0.5, + initial_contamination: 0.1, + minimum_probability: 1.0e-12, + } +} + +///| +pub struct DecontXDiagnostics { + iterations : Int + converged : Bool + initial_log_likelihood : Double + final_log_likelihood : Double + log_likelihoods : Array[Double] +} derive(Eq, Debug) + +///| +pub struct DecontXCellEstimate { + cell_name : String + cluster : String + contamination : Double + library_size : Double + native_counts : Double + contaminant_counts : Double +} derive(Eq, Debug) + +///| +pub struct DecontXClusterEstimate { + cluster : String + n_cells : Int + mean_contamination : Double + total_counts : Double + native_counts : Double + contaminant_counts : Double +} derive(Eq, Debug) + +///| +pub struct DecontXResult { + corrected_counts : Array[Array[Double]] + contamination_counts : Array[Array[Double]] + contamination : Array[Double] + native_profiles : Array[Array[Double]] + contaminant_profiles : Array[Array[Double]] + cluster_names : Array[String] + cluster_indices : Array[Int] + gene_names : Array[String] + cell_names : Array[String] + used_background : Bool + diagnostics : DecontXDiagnostics +} derive(Eq, Debug) + +///| +/// Result of adding decontamination outputs to a SingleCellExperiment copy. +pub struct DecontXSCEOutput { + experiment : SingleCellExperiment + result : DecontXResult +} + +///| +fn decontx_zero_matrix(rows : Int, columns : Int) -> Array[Array[Double]] { + let result : Array[Array[Double]] = Array::new() + let mut row = 0 + while row < rows { + result.push(Array::make(columns, 0.0)) + row = row + 1 + } + result +} + +///| +fn decontx_copy_matrix(matrix : Array[Array[Double]]) -> Array[Array[Double]] { + let result : Array[Array[Double]] = Array::new() + let mut row = 0 + while row < matrix.length() { + result.push(matrix[row].copy()) + row = row + 1 + } + result +} + +///| +fn decontx_validate_matrix( + matrix : Array[Array[Double]], + label : String, + expected_rows? : Int = -1, +) -> (Int, Int) raise DecontXError { + if matrix.length() == 0 { + raise DecontXError::DecontXError(label + " must contain at least one gene") + } + if expected_rows >= 0 && matrix.length() != expected_rows { + raise DecontXError::DecontXError( + label + " must have the same genes as counts", + ) + } + let columns = matrix[0].length() + if columns == 0 { + raise DecontXError::DecontXError(label + " must contain at least one cell") + } + let mut row = 0 + while row < matrix.length() { + if matrix[row].length() != columns { + raise DecontXError::DecontXError(label + " must be rectangular") + } + let mut column = 0 + while column < columns { + let value = matrix[row][column] + if value != value || value < 0.0 || value.abs() > 1.0e300 { + raise DecontXError::DecontXError( + label + " must contain finite non-negative counts", + ) + } + column = column + 1 + } + row = row + 1 + } + (matrix.length(), columns) +} + +///| +fn decontx_prepare_names( + supplied : Array[String], + length : Int, + prefix : String, +) -> Array[String] raise DecontXError { + if supplied.length() != 0 && supplied.length() != length { + raise DecontXError::DecontXError( + prefix + " names must match the matrix dimension", + ) + } + let names : Array[String] = Array::new() + let mut index = 0 + while index < length { + let name = if supplied.length() == 0 { + prefix + (index + 1).to_string() + } else { + supplied[index] + } + if name.trim().length() == 0 { + raise DecontXError::DecontXError(prefix + " names cannot be empty") + } + let mut previous = 0 + while previous < names.length() { + if names[previous] == name { + raise DecontXError::DecontXError( + prefix + " names must be unique: " + name, + ) + } + previous = previous + 1 + } + names.push(name) + index = index + 1 + } + names +} + +///| +fn decontx_encode_clusters( + labels : Array[String], + n_cells : Int, +) -> (Array[String], Array[Int]) raise DecontXError { + if labels.length() != n_cells { + raise DecontXError::DecontXError( + "cluster labels must match the number of cells", + ) + } + let names : Array[String] = Array::new() + let indices : Array[Int] = Array::new() + let mut cell = 0 + while cell < labels.length() { + let label = labels[cell] + if label.trim().length() == 0 { + raise DecontXError::DecontXError("cluster labels cannot be empty") + } + let mut found = -1 + let mut cluster = 0 + while cluster < names.length() { + if names[cluster] == label { + found = cluster + break + } + cluster = cluster + 1 + } + if found < 0 { + names.push(label) + found = names.length() - 1 + } + indices.push(found) + cell = cell + 1 + } + (names, indices) +} + +///| +fn decontx_normalize_profiles( + sums : Array[Array[Double]], + pseudocount : Double, +) -> Array[Array[Double]] { + let profiles = decontx_zero_matrix( + sums.length(), + if sums.length() > 0 { + sums[0].length() + } else { + 0 + }, + ) + let mut cluster = 0 + while cluster < sums.length() { + let mut total = pseudocount * sums[cluster].length().to_double() + let mut gene = 0 + while gene < sums[cluster].length() { + total = total + sums[cluster][gene] + gene = gene + 1 + } + gene = 0 + while gene < sums[cluster].length() { + profiles[cluster][gene] = (sums[cluster][gene] + pseudocount) / total + gene = gene + 1 + } + cluster = cluster + 1 + } + profiles +} + +///| +fn decontx_initial_native_sums( + counts : Array[Array[Double]], + cluster_indices : Array[Int], + n_clusters : Int, +) -> Array[Array[Double]] { + let sums = decontx_zero_matrix(n_clusters, counts.length()) + let n_cells = if counts.length() > 0 { counts[0].length() } else { 0 } + let mut cell = 0 + while cell < n_cells { + let cluster = cluster_indices[cell] + let mut gene = 0 + while gene < counts.length() { + sums[cluster][gene] = sums[cluster][gene] + counts[gene][cell] + gene = gene + 1 + } + cell = cell + 1 + } + sums +} + +///| +fn decontx_background_profile( + background : Array[Array[Double]], + n_genes : Int, + pseudocount : Double, +) -> Array[Double] raise DecontXError { + let (_, n_droplets) = decontx_validate_matrix( + background, + "background", + expected_rows=n_genes, + ) + let profile = Array::make(n_genes, pseudocount) + let mut total = pseudocount * n_genes.to_double() + let mut gene = 0 + while gene < n_genes { + let mut droplet = 0 + while droplet < n_droplets { + profile[gene] = profile[gene] + background[gene][droplet] + total = total + background[gene][droplet] + droplet = droplet + 1 + } + gene = gene + 1 + } + gene = 0 + while gene < n_genes { + profile[gene] = profile[gene] / total + gene = gene + 1 + } + profile +} + +///| +fn decontx_contaminant_profiles( + native_sums : Array[Array[Double]], + pseudocount : Double, + background_profile : Array[Double]?, +) -> Array[Array[Double]] { + let n_clusters = native_sums.length() + let n_genes = if n_clusters > 0 { native_sums[0].length() } else { 0 } + let profiles = decontx_zero_matrix(n_clusters, n_genes) + match background_profile { + Some(background) => { + let mut cluster = 0 + while cluster < n_clusters { + let mut gene = 0 + while gene < n_genes { + profiles[cluster][gene] = background[gene] + gene = gene + 1 + } + cluster = cluster + 1 + } + } + None => { + let mut cluster = 0 + while cluster < n_clusters { + let mut total = pseudocount * n_genes.to_double() + let mut gene = 0 + while gene < n_genes { + let mut other = 0 + let mut value = pseudocount + while other < n_clusters { + if other != cluster { + value = value + native_sums[other][gene] + } + other = other + 1 + } + profiles[cluster][gene] = value + total = total + value - pseudocount + gene = gene + 1 + } + gene = 0 + while gene < n_genes { + profiles[cluster][gene] = profiles[cluster][gene] / total + gene = gene + 1 + } + cluster = cluster + 1 + } + } + } + profiles +} + +///| +fn decontx_expectation( + counts : Array[Array[Double]], + cluster_indices : Array[Int], + contamination : Array[Double], + native_profiles : Array[Array[Double]], + contaminant_profiles : Array[Array[Double]], + minimum_probability : Double, +) -> ( + Array[Array[Double]], + Array[Array[Double]], + Array[Array[Double]], + Array[Double], + Double, +) { + let n_genes = counts.length() + let n_cells = if n_genes > 0 { counts[0].length() } else { 0 } + let n_clusters = native_profiles.length() + let corrected = decontx_zero_matrix(n_genes, n_cells) + let contaminant = decontx_zero_matrix(n_genes, n_cells) + let native_sums = decontx_zero_matrix(n_clusters, n_genes) + let contaminant_totals = Array::make(n_cells, 0.0) + let mut log_likelihood = 0.0 + let mut cell = 0 + while cell < n_cells { + let cluster = cluster_indices[cell] + let rho = contamination[cell] + let mut gene = 0 + while gene < n_genes { + let count = counts[gene][cell] + let native_weight = (1.0 - rho) * native_profiles[cluster][gene] + let contaminant_weight = rho * contaminant_profiles[cluster][gene] + let mixture = native_weight + contaminant_weight + let denominator = if mixture > minimum_probability { + mixture + } else { + minimum_probability + } + let native_probability = native_weight / denominator + let expected_native = count * native_probability + let expected_contaminant = count - expected_native + corrected[gene][cell] = expected_native + contaminant[gene][cell] = expected_contaminant + native_sums[cluster][gene] = native_sums[cluster][gene] + expected_native + contaminant_totals[cell] = contaminant_totals[cell] + expected_contaminant + if count > 0.0 { + log_likelihood = log_likelihood + count * @math.ln(denominator) + } + gene = gene + 1 + } + cell = cell + 1 + } + (corrected, contaminant, native_sums, contaminant_totals, log_likelihood) +} + +///| +fn decontx_library_sizes(counts : Array[Array[Double]]) -> Array[Double] { + let n_cells = if counts.length() > 0 { counts[0].length() } else { 0 } + let sizes = Array::make(n_cells, 0.0) + let mut gene = 0 + while gene < counts.length() { + let mut cell = 0 + while cell < n_cells { + sizes[cell] = sizes[cell] + counts[gene][cell] + cell = cell + 1 + } + gene = gene + 1 + } + sizes +} + +///| +/// Estimate and remove ambient RNA contamination from a gene-by-cell matrix. +/// +/// With no background matrix, each cluster's contaminant profile is estimated +/// from the native profiles of all other clusters. A supplied background +/// matrix is interpreted as genes-by-empty-droplets and fixes a common ambient +/// profile during inference. +pub fn decontx( + counts : Array[Array[Double]], + gene_names : Array[String], + cell_names : Array[String], + cluster_labels : Array[String], + config? : DecontXConfig = DecontXConfig::default(), + background? : Array[Array[Double]] = [], +) -> DecontXResult raise DecontXError { + let (n_genes, n_cells) = decontx_validate_matrix(counts, "counts") + let genes = decontx_prepare_names(gene_names, n_genes, "Gene") + let cells = decontx_prepare_names(cell_names, n_cells, "Cell") + let (cluster_names, cluster_indices) = decontx_encode_clusters( + cluster_labels, n_cells, + ) + let used_background = background.length() > 0 + if cluster_names.length() < 2 && !used_background { + raise DecontXError::DecontXError( + "at least two clusters are required without a background matrix", + ) + } + let background_profile = if used_background { + Some( + decontx_background_profile( + background, + n_genes, + config.profile_pseudocount, + ), + ) + } else { + None + } + let initial_sums = decontx_initial_native_sums( + counts, + cluster_indices, + cluster_names.length(), + ) + let mut native_profiles = decontx_normalize_profiles( + initial_sums, + config.profile_pseudocount, + ) + let mut contaminant_profiles = decontx_contaminant_profiles( + initial_sums, + config.profile_pseudocount, + background_profile, + ) + let contamination = Array::make(n_cells, config.initial_contamination) + let library_sizes = decontx_library_sizes(counts) + let log_likelihoods : Array[Double] = Array::new() + let mut iterations = 0 + let mut converged = false + while iterations < config.max_iterations && !converged { + let (_, _, native_sums, contaminant_totals, log_likelihood) = decontx_expectation( + counts, + cluster_indices, + contamination, + native_profiles, + contaminant_profiles, + config.minimum_probability, + ) + log_likelihoods.push(log_likelihood) + let next_native_profiles = decontx_normalize_profiles( + native_sums, + config.profile_pseudocount, + ) + let next_contaminant_profiles = decontx_contaminant_profiles( + native_sums, + config.profile_pseudocount, + background_profile, + ) + let next_contamination = Array::make(n_cells, 0.0) + let mut max_change = 0.0 + let mut cell = 0 + while cell < n_cells { + let posterior = ( + contaminant_totals[cell] + config.contamination_prior_alpha + ) / + ( + library_sizes[cell] + + config.contamination_prior_alpha + + config.contamination_prior_beta + ) + let bounded = if posterior < config.minimum_probability { + config.minimum_probability + } else if posterior > 1.0 - config.minimum_probability { + 1.0 - config.minimum_probability + } else { + posterior + } + next_contamination[cell] = bounded + let change = (bounded - contamination[cell]).abs() + if change > max_change { + max_change = change + } + cell = cell + 1 + } + let mut cluster = 0 + while cluster < native_profiles.length() { + let mut gene = 0 + while gene < n_genes { + let native_change = (next_native_profiles[cluster][gene] - + native_profiles[cluster][gene]).abs() + if native_change > max_change { + max_change = native_change + } + let contaminant_change = (next_contaminant_profiles[cluster][gene] - + contaminant_profiles[cluster][gene]).abs() + if contaminant_change > max_change { + max_change = contaminant_change + } + gene = gene + 1 + } + cluster = cluster + 1 + } + cell = 0 + while cell < n_cells { + contamination[cell] = next_contamination[cell] + cell = cell + 1 + } + native_profiles = next_native_profiles + contaminant_profiles = next_contaminant_profiles + iterations = iterations + 1 + converged = max_change <= config.tolerance + } + let (corrected, contaminant, _, _, final_log_likelihood) = decontx_expectation( + counts, + cluster_indices, + contamination, + native_profiles, + contaminant_profiles, + config.minimum_probability, + ) + let initial_log_likelihood = if log_likelihoods.length() > 0 { + log_likelihoods[0] + } else { + final_log_likelihood + } + DecontXResult::{ + corrected_counts: corrected, + contamination_counts: contaminant, + contamination, + native_profiles, + contaminant_profiles, + cluster_names, + cluster_indices, + gene_names: genes, + cell_names: cells, + used_background, + diagnostics: DecontXDiagnostics::{ + iterations, + converged, + initial_log_likelihood, + final_log_likelihood, + log_likelihoods, + }, + } +} + +///| +/// Infer initial populations with deterministic k-means on log-normalized +/// cell profiles before running decontamination. +pub fn decontx_auto( + counts : Array[Array[Double]], + gene_names : Array[String], + cell_names : Array[String], + n_clusters : Int, + config? : DecontXConfig = DecontXConfig::default(), + background? : Array[Array[Double]] = [], +) -> DecontXResult raise DecontXError { + let (n_genes, n_cells) = decontx_validate_matrix(counts, "counts") + if n_clusters < 2 || n_clusters > n_cells { + raise DecontXError::DecontXError( + "n_clusters must be between 2 and the number of cells", + ) + } + let library_sizes = decontx_library_sizes(counts) + let points : Array[Point] = Array::new() + let mut cell = 0 + while cell < n_cells { + let point : Array[Double] = Array::new() + let scale = if library_sizes[cell] > 0.0 { + 10000.0 / library_sizes[cell] + } else { + 1.0 + } + let mut gene = 0 + while gene < n_genes { + point.push(@math.ln(1.0 + counts[gene][cell] * scale)) + gene = gene + 1 + } + points.push(point) + cell = cell + 1 + } + let model = KMeans::new(n_clusters, 100, 1.0e-8).fit(points) + let labels : Array[String] = Array::new() + let assigned = model.get_labels() + cell = 0 + while cell < assigned.length() { + labels.push("cluster_" + (assigned[cell] + 1).to_string()) + cell = cell + 1 + } + decontx(counts, gene_names, cell_names, labels, config~, background~) +} + +///| +pub fn DecontXResult::n_genes(self : DecontXResult) -> Int { + self.corrected_counts.length() +} + +///| +pub fn DecontXResult::n_cells(self : DecontXResult) -> Int { + if self.corrected_counts.length() > 0 { + self.corrected_counts[0].length() + } else { + 0 + } +} + +///| +pub fn DecontXResult::n_clusters(self : DecontXResult) -> Int { + self.cluster_names.length() +} + +///| +pub fn DecontXResult::mean_contamination(self : DecontXResult) -> Double { + if self.contamination.length() == 0 { + return 0.0 + } + let mut total = 0.0 + let mut cell = 0 + while cell < self.contamination.length() { + total = total + self.contamination[cell] + cell = cell + 1 + } + total / self.contamination.length().to_double() +} + +///| +pub fn DecontXResult::gene_index(self : DecontXResult, name : String) -> Int? { + let mut gene = 0 + while gene < self.gene_names.length() { + if self.gene_names[gene] == name { + return Some(gene) + } + gene = gene + 1 + } + None +} + +///| +pub fn DecontXResult::cell_index(self : DecontXResult, name : String) -> Int? { + let mut cell = 0 + while cell < self.cell_names.length() { + if self.cell_names[cell] == name { + return Some(cell) + } + cell = cell + 1 + } + None +} + +///| +pub fn DecontXResult::cell_estimate( + self : DecontXResult, + index : Int, +) -> DecontXCellEstimate? { + if index < 0 || index >= self.n_cells() { + return None + } + let mut native = 0.0 + let mut contaminant = 0.0 + let mut gene = 0 + while gene < self.n_genes() { + native = native + self.corrected_counts[gene][index] + contaminant = contaminant + self.contamination_counts[gene][index] + gene = gene + 1 + } + Some(DecontXCellEstimate::{ + cell_name: self.cell_names[index], + cluster: self.cluster_names[self.cluster_indices[index]], + contamination: self.contamination[index], + library_size: native + contaminant, + native_counts: native, + contaminant_counts: contaminant, + }) +} + +///| +pub fn DecontXResult::cluster_estimates( + self : DecontXResult, +) -> Array[DecontXClusterEstimate] { + let result : Array[DecontXClusterEstimate] = Array::new() + let mut cluster = 0 + while cluster < self.cluster_names.length() { + let mut n_cells = 0 + let mut contamination_sum = 0.0 + let mut native = 0.0 + let mut contaminant = 0.0 + let mut cell = 0 + while cell < self.n_cells() { + if self.cluster_indices[cell] == cluster { + n_cells = n_cells + 1 + contamination_sum = contamination_sum + self.contamination[cell] + let mut gene = 0 + while gene < self.n_genes() { + native = native + self.corrected_counts[gene][cell] + contaminant = contaminant + self.contamination_counts[gene][cell] + gene = gene + 1 + } + } + cell = cell + 1 + } + result.push(DecontXClusterEstimate::{ + cluster: self.cluster_names[cluster], + n_cells, + mean_contamination: if n_cells > 0 { + contamination_sum / n_cells.to_double() + } else { + 0.0 + }, + total_counts: native + contaminant, + native_counts: native, + contaminant_counts: contaminant, + }) + cluster = cluster + 1 + } + result +} + +///| +pub fn DecontXResult::most_contaminated_cells( + self : DecontXResult, + n : Int, +) -> Array[DecontXCellEstimate] { + if n <= 0 { + return [] + } + let indices : Array[Int] = Array::new() + let mut cell = 0 + while cell < self.n_cells() { + indices.push(cell) + cell = cell + 1 + } + let mut position = 0 + while position < indices.length() { + let mut best = position + let mut candidate = position + 1 + while candidate < indices.length() { + if self.contamination[indices[candidate]] > + self.contamination[indices[best]] { + best = candidate + } + candidate = candidate + 1 + } + if best != position { + let temporary = indices[position] + indices[position] = indices[best] + indices[best] = temporary + } + position = position + 1 + } + let result : Array[DecontXCellEstimate] = Array::new() + let limit = if n < indices.length() { n } else { indices.length() } + position = 0 + while position < limit { + match self.cell_estimate(indices[position]) { + Some(estimate) => result.push(estimate) + None => () + } + position = position + 1 + } + result +} + +///| +pub fn DecontXResult::summary(self : DecontXResult) -> String { + "DecontX: " + + self.n_genes().to_string() + + " genes x " + + self.n_cells().to_string() + + " cells, " + + self.n_clusters().to_string() + + " clusters; mean contamination=" + + self.mean_contamination().to_string() + + ", iterations=" + + self.diagnostics.iterations.to_string() + + ", converged=" + + self.diagnostics.converged.to_string() + + ", background=" + + self.used_background.to_string() +} + +///| +fn decontx_copy_sce(sce : SingleCellExperiment) -> SingleCellExperiment { + let assays : Map[String, Array[Array[Double]]] = Map([]) + let assay_names = sce.assays.keys().collect() + let mut index = 0 + while index < assay_names.length() { + assays[assay_names[index]] = sce.assays[assay_names[index]] + index = index + 1 + } + let row_data : Map[String, Array[String]] = Map([]) + let row_keys = sce.row_data.keys().collect() + index = 0 + while index < row_keys.length() { + row_data[row_keys[index]] = sce.row_data[row_keys[index]] + index = index + 1 + } + let col_data : Map[String, Array[String]] = Map([]) + let col_keys = sce.col_data.keys().collect() + index = 0 + while index < col_keys.length() { + col_data[col_keys[index]] = sce.col_data[col_keys[index]] + index = index + 1 + } + let reduced_dims : Map[String, Array[Array[Double]]] = Map([]) + let reduced_keys = sce.reduced_dims.keys().collect() + index = 0 + while index < reduced_keys.length() { + reduced_dims[reduced_keys[index]] = sce.reduced_dims[reduced_keys[index]] + index = index + 1 + } + let alternative_experiments : Map[String, SingleCellExperiment] = Map([]) + let alternative_keys = sce.alternative_experiments.keys().collect() + index = 0 + while index < alternative_keys.length() { + alternative_experiments[alternative_keys[index]] = sce.alternative_experiments[alternative_keys[index]] + index = index + 1 + } + let metadata : Map[String, String] = Map([]) + let metadata_keys = sce.metadata.keys().collect() + index = 0 + while index < metadata_keys.length() { + metadata[metadata_keys[index]] = sce.metadata[metadata_keys[index]] + index = index + 1 + } + SingleCellExperiment::{ + assays, + row_data, + col_data, + reduced_dims, + alternative_experiments, + metadata, + row_names: sce.row_names.copy(), + col_names: sce.col_names.copy(), + } +} + +///| +/// Run decontamination on an SCE assay and return an immutable enriched copy. +pub fn decontx_sce( + sce : SingleCellExperiment, + cluster_column? : String = "cluster", + input_assay? : String = "counts", + output_assay? : String = "decontXcounts", + config? : DecontXConfig = DecontXConfig::default(), + background? : Array[Array[Double]] = [], +) -> DecontXSCEOutput raise DecontXError { + let counts = sce_get_assay(sce, input_assay) + if counts.length() == 0 { + raise DecontXError::DecontXError( + "SingleCellExperiment assay not found: " + input_assay, + ) + } + let clusters = sce_get_col_data(sce, cluster_column) + if clusters.length() == 0 { + raise DecontXError::DecontXError( + "SingleCellExperiment column data not found: " + cluster_column, + ) + } + let result = decontx( + counts, + sce.row_names, + sce.col_names, + clusters, + config~, + background~, + ) + let enriched = decontx_copy_sce(sce) + enriched.assays[output_assay] = decontx_copy_matrix(result.corrected_counts) + let contamination_strings : Array[String] = Array::new() + let mut cell = 0 + while cell < result.contamination.length() { + contamination_strings.push(result.contamination[cell].to_string()) + cell = cell + 1 + } + enriched.col_data["decontX_contamination"] = contamination_strings + enriched.col_data["decontX_cluster"] = clusters.copy() + enriched.metadata["decontX_iterations"] = result.diagnostics.iterations.to_string() + enriched.metadata["decontX_converged"] = result.diagnostics.converged.to_string() + enriched.metadata["decontX_background"] = result.used_background.to_string() + DecontXSCEOutput::{ experiment: enriched, result } +} + +///| +/// Small two-population matrix with cross-population marker contamination. +pub fn decontx_example_data() -> ( + Array[Array[Double]], + Array[String], + Array[String], + Array[String], + Array[Array[Double]], +) { + let counts = [ + [100.0, 90.0, 110.0, 95.0, 8.0, 5.0, 10.0, 6.0], + [80.0, 70.0, 85.0, 75.0, 4.0, 3.0, 5.0, 4.0], + [8.0, 6.0, 10.0, 7.0, 100.0, 90.0, 110.0, 95.0], + [4.0, 3.0, 5.0, 4.0, 80.0, 70.0, 85.0, 75.0], + [20.0, 22.0, 19.0, 21.0, 20.0, 22.0, 19.0, 21.0], + [2.0, 1.0, 2.0, 1.0, 2.0, 1.0, 2.0, 1.0], + ] + let gene_names = [ + "T_marker_1", "T_marker_2", "B_marker_1", "B_marker_2", "housekeeping", "low_expression", + ] + let cell_names = ["T1", "T2", "T3", "T4", "B1", "B2", "B3", "B4"] + let clusters = ["T", "T", "T", "T", "B", "B", "B", "B"] + let background = [ + [45.0, 50.0], + [35.0, 40.0], + [48.0, 52.0], + [37.0, 42.0], + [18.0, 20.0], + [2.0, 2.0], + ] + (counts, gene_names, cell_names, clusters, background) +} diff --git a/test/moonbit/decontx_test.mbt b/test/moonbit/decontx_test.mbt new file mode 100644 index 00000000..378ef477 --- /dev/null +++ b/test/moonbit/decontx_test.mbt @@ -0,0 +1,656 @@ +// Tests for Bioconductor decontX-inspired ambient RNA decontamination. + +///| +fn decontx_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "decontX value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn decontx_test_result() -> @src.DecontXResult { + let (counts, genes, cells, clusters, _) = @src.decontx_example_data() + @src.decontx(counts, genes, cells, clusters) catch { + _ => abort("example decontX analysis should succeed") + } +} + +///| +fn decontx_test_sce() -> @src.SingleCellExperiment { + let (counts, _, _, clusters, _) = @src.decontx_example_data() + @src.SCEBuilder::new() + |> @src.SCEBuilder::add_assay("counts", counts) + |> @src.SCEBuilder::add_row_data("symbol", [ + "TR1", "TR2", "BR1", "BR2", "HK", "LOW", + ]) + |> @src.SCEBuilder::add_col_data("cluster", clusters) + |> @src.SCEBuilder::build +} + +///| +test "decontX: default configuration is scientifically conservative" { + let config = @src.DecontXConfig::default() + assert_eq(config.max_iterations, 100) + assert_eq(config.tolerance, 1.0e-6) + assert_eq(config.contamination_prior_alpha, 1.0) + assert_eq(config.contamination_prior_beta, 9.0) + assert_eq(config.initial_contamination, 0.1) +} + +///| +test "decontX: custom configuration preserves all parameters" { + let config = @src.DecontXConfig::create( + max_iterations=25, + tolerance=1.0e-5, + contamination_prior_alpha=2.0, + contamination_prior_beta=8.0, + profile_pseudocount=0.25, + initial_contamination=0.2, + minimum_probability=1.0e-10, + ) catch { + _ => abort("valid custom configuration should build") + } + assert_eq(config.max_iterations, 25) + assert_eq(config.profile_pseudocount, 0.25) + assert_eq(config.minimum_probability, 1.0e-10) +} + +///| +test "decontX: configuration rejects invalid iteration and tolerance" { + let iterations = try { + ignore(@src.DecontXConfig::create(max_iterations=0)) + false + } catch { + DecontXError(_) => true + } + let tolerance = try { + ignore(@src.DecontXConfig::create(tolerance=0.0)) + false + } catch { + DecontXError(_) => true + } + assert_true(iterations) + assert_true(tolerance) +} + +///| +test "decontX: configuration rejects invalid priors" { + let beta = try { + ignore(@src.DecontXConfig::create(contamination_prior_beta=0.0)) + false + } catch { + DecontXError(_) => true + } + let profile = try { + ignore(@src.DecontXConfig::create(profile_pseudocount=-1.0)) + false + } catch { + DecontXError(_) => true + } + assert_true(beta) + assert_true(profile) +} + +///| +test "decontX: configuration rejects invalid probabilities" { + let initial = try { + ignore(@src.DecontXConfig::create(initial_contamination=1.0)) + false + } catch { + DecontXError(_) => true + } + let minimum = try { + ignore(@src.DecontXConfig::create(minimum_probability=0.0)) + false + } catch { + DecontXError(_) => true + } + assert_true(initial) + assert_true(minimum) +} + +///| +test "decontX: example data uses gene by cell orientation" { + let (counts, genes, cells, clusters, background) = @src.decontx_example_data() + assert_eq(counts.length(), 6) + assert_eq(counts[0].length(), 8) + assert_eq(genes.length(), 6) + assert_eq(cells.length(), 8) + assert_eq(clusters.length(), 8) + assert_eq(background.length(), 6) +} + +///| +test "decontX: result dimensions match the source matrix" { + let result = decontx_test_result() + assert_eq(result.n_genes(), 6) + assert_eq(result.n_cells(), 8) + assert_eq(result.n_clusters(), 2) + assert_eq(result.contamination_counts.length(), 6) + assert_eq(result.contamination_counts[0].length(), 8) +} + +///| +test "decontX: omitted identifiers are generated deterministically" { + let result = @src.decontx([[10.0, 1.0], [1.0, 10.0]], [], [], ["A", "B"]) catch { + _ => abort("generated names should be accepted") + } + assert_eq(result.gene_names, ["Gene1", "Gene2"]) + assert_eq(result.cell_names, ["Cell1", "Cell2"]) +} + +///| +test "decontX: cluster order follows first appearance" { + let result = @src.decontx([[10.0, 1.0, 5.0], [1.0, 10.0, 4.0]], [], [], [ + "B", "A", "B", + ]) catch { + _ => abort("valid labels should be accepted") + } + assert_eq(result.cluster_names, ["B", "A"]) + assert_eq(result.cluster_indices, [0, 1, 0]) +} + +///| +test "decontX: native and contaminant counts reconstruct observations" { + let (counts, _, _, _, _) = @src.decontx_example_data() + let result = decontx_test_result() + for gene in 0.. 0.0 && value < 1.0) + } +} + +///| +test "decontX: native profiles are normalized" { + let result = decontx_test_result() + for profile in result.native_profiles { + let mut total = 0.0 + for value in profile { + total = total + value + } + decontx_test_close(total, 1.0, 1.0e-10) + } +} + +///| +test "decontX: contaminant profiles are normalized" { + let result = decontx_test_result() + for profile in result.contaminant_profiles { + let mut total = 0.0 + for value in profile { + total = total + value + } + decontx_test_close(total, 1.0, 1.0e-10) + } +} + +///| +test "decontX: B-cell marker contamination is removed from T cells" { + let result = decontx_test_result() + assert_true(result.corrected_counts[2][0] < 8.0) + assert_true(result.contamination_counts[2][0] > 0.0) +} + +///| +test "decontX: T-cell marker contamination is removed from B cells" { + let result = decontx_test_result() + assert_true(result.corrected_counts[0][4] < 8.0) + assert_true(result.contamination_counts[0][4] > 0.0) +} + +///| +test "decontX: diagnostics record bounded inference work" { + let result = decontx_test_result() + assert_true(result.diagnostics.iterations >= 1) + assert_true(result.diagnostics.iterations <= 100) + assert_eq( + result.diagnostics.log_likelihoods.length(), + result.diagnostics.iterations, + ) +} + +///| +test "decontX: diagnostic likelihoods are finite" { + let result = decontx_test_result() + assert_true(result.diagnostics.initial_log_likelihood.abs() < 1.0e300) + assert_true(result.diagnostics.final_log_likelihood.abs() < 1.0e300) + for value in result.diagnostics.log_likelihoods { + assert_true(value == value) + assert_true(value.abs() < 1.0e300) + } +} + +///| +test "decontX: cell estimate reports decomposed library size" { + let result = decontx_test_result() + match result.cell_estimate(0) { + Some(estimate) => { + assert_eq(estimate.cell_name, "T1") + assert_eq(estimate.cluster, "T") + decontx_test_close( + estimate.native_counts + estimate.contaminant_counts, + estimate.library_size, + 1.0e-10, + ) + decontx_test_close(estimate.library_size, 214.0, 1.0e-10) + } + None => abort("valid cell estimate should exist") + } +} + +///| +test "decontX: cell estimate validates indices" { + let result = decontx_test_result() + assert_true(result.cell_estimate(-1) is None) + assert_true(result.cell_estimate(8) is None) +} + +///| +test "decontX: gene and cell lookup use preserved identifiers" { + let result = decontx_test_result() + assert_eq(result.gene_index("B_marker_1"), Some(2)) + assert_eq(result.cell_index("B3"), Some(6)) + assert_true(result.gene_index("missing") is None) + assert_true(result.cell_index("missing") is None) +} + +///| +test "decontX: cluster estimates partition all cells" { + let result = decontx_test_result() + let estimates = result.cluster_estimates() + assert_eq(estimates.length(), 2) + assert_eq(estimates[0].cluster, "T") + assert_eq(estimates[0].n_cells, 4) + assert_eq(estimates[1].cluster, "B") + assert_eq(estimates[1].n_cells, 4) + decontx_test_close( + estimates[0].native_counts + estimates[0].contaminant_counts, + estimates[0].total_counts, + 1.0e-10, + ) +} + +///| +test "decontX: most contaminated cells are sorted descending" { + let result = decontx_test_result() + let top = result.most_contaminated_cells(4) + assert_eq(top.length(), 4) + for index in 1..= top[index].contamination) + } +} + +///| +test "decontX: top-cell query handles zero and oversized limits" { + let result = decontx_test_result() + assert_eq(result.most_contaminated_cells(0).length(), 0) + assert_eq(result.most_contaminated_cells(100).length(), 8) +} + +///| +test "decontX: summary exposes model dimensions and convergence" { + let summary = decontx_test_result().summary() + assert_true(summary.contains("6 genes x 8 cells")) + assert_true(summary.contains("2 clusters")) + assert_true(summary.contains("mean contamination=")) + assert_true(summary.contains("converged=")) +} + +///| +test "decontX: explicit background fixes a common ambient profile" { + let (counts, genes, cells, clusters, background) = @src.decontx_example_data() + let result = @src.decontx(counts, genes, cells, clusters, background~) catch { + _ => abort("valid background should be accepted") + } + assert_true(result.used_background) + assert_eq(result.contaminant_profiles[0], result.contaminant_profiles[1]) +} + +///| +test "decontX: background changes the inferred contaminant distribution" { + let (counts, genes, cells, clusters, background) = @src.decontx_example_data() + let without = @src.decontx(counts, genes, cells, clusters) catch { + _ => abort("analysis without background should succeed") + } + let with_background = @src.decontx( + counts, + genes, + cells, + clusters, + background~, + ) catch { + _ => abort("analysis with background should succeed") + } + assert_true( + (without.contaminant_profiles[0][0] - + with_background.contaminant_profiles[0][0]).abs() > + 1.0e-6, + ) +} + +///| +test "decontX: one cluster is identifiable with external background" { + let result = @src.decontx( + [[10.0, 12.0], [2.0, 3.0]], + ["A", "B"], + ["C1", "C2"], + ["one", "one"], + background=[[1.0], [9.0]], + ) catch { + _ => abort("background should identify one-cluster contamination") + } + assert_eq(result.n_clusters(), 1) + assert_true(result.used_background) +} + +///| +test "decontX: one cluster without background is rejected" { + let raised = try { + ignore(@src.decontx([[10.0, 12.0], [2.0, 3.0]], [], [], ["one", "one"])) + false + } catch { + DecontXError(_) => true + } + assert_true(raised) +} + +///| +test "decontX: empty and ragged matrices are rejected" { + let empty = try { + ignore(@src.decontx([], [], [], [])) + false + } catch { + DecontXError(_) => true + } + let ragged = try { + ignore(@src.decontx([[1.0], [2.0, 3.0]], [], [], ["A"])) + false + } catch { + DecontXError(_) => true + } + assert_true(empty) + assert_true(ragged) +} + +///| +test "decontX: negative and non-finite counts are rejected" { + let negative = try { + ignore(@src.decontx([[1.0, -1.0]], [], [], ["A", "B"])) + false + } catch { + DecontXError(_) => true + } + let non_finite = try { + ignore(@src.decontx([[1.0, @double.not_a_number]], [], [], ["A", "B"])) + false + } catch { + DecontXError(_) => true + } + assert_true(negative) + assert_true(non_finite) +} + +///| +test "decontX: identifier dimensions are validated" { + let genes = try { + ignore(@src.decontx([[1.0, 2.0], [2.0, 1.0]], ["only_one"], [], ["A", "B"])) + false + } catch { + DecontXError(_) => true + } + let cells = try { + ignore(@src.decontx([[1.0, 2.0], [2.0, 1.0]], [], ["only_one"], ["A", "B"])) + false + } catch { + DecontXError(_) => true + } + assert_true(genes) + assert_true(cells) +} + +///| +test "decontX: duplicate and blank identifiers are rejected" { + let duplicate = try { + ignore( + @src.decontx([[1.0, 2.0], [2.0, 1.0]], ["same", "same"], [], ["A", "B"]), + ) + false + } catch { + DecontXError(_) => true + } + let blank = try { + ignore(@src.decontx([[1.0, 2.0], [2.0, 1.0]], [], ["C1", " "], ["A", "B"])) + false + } catch { + DecontXError(_) => true + } + assert_true(duplicate) + assert_true(blank) +} + +///| +test "decontX: cluster labels are validated" { + let length = try { + ignore(@src.decontx([[1.0, 2.0], [2.0, 1.0]], [], [], ["A"])) + false + } catch { + DecontXError(_) => true + } + let blank = try { + ignore(@src.decontx([[1.0, 2.0], [2.0, 1.0]], [], [], ["A", ""])) + false + } catch { + DecontXError(_) => true + } + assert_true(length) + assert_true(blank) +} + +///| +test "decontX: background dimensions and values are validated" { + let dimensions = try { + ignore( + @src.decontx([[1.0, 2.0], [2.0, 1.0]], [], [], ["A", "B"], background=[ + [1.0], + ]), + ) + false + } catch { + DecontXError(_) => true + } + let negative = try { + ignore( + @src.decontx([[1.0, 2.0], [2.0, 1.0]], [], [], ["A", "B"], background=[ + [1.0], + [-1.0], + ]), + ) + false + } catch { + DecontXError(_) => true + } + assert_true(dimensions) + assert_true(negative) +} + +///| +test "decontX: zero-library cells remain zero" { + let result = @src.decontx([[0.0, 10.0, 1.0], [0.0, 1.0, 10.0]], [], [], [ + "A", "A", "B", + ]) catch { + _ => abort("zero-library cells should be supported") + } + assert_eq(result.corrected_counts[0][0], 0.0) + assert_eq(result.corrected_counts[1][0], 0.0) + assert_eq(result.contamination_counts[0][0], 0.0) + assert_eq(result.contamination_counts[1][0], 0.0) +} + +///| +test "decontX: configured maximum iteration is respected" { + let (counts, genes, cells, clusters, _) = @src.decontx_example_data() + let config = @src.DecontXConfig::create(max_iterations=1, tolerance=1.0e-30) catch { + _ => abort("valid iteration limit should build") + } + let result = @src.decontx(counts, genes, cells, clusters, config~) catch { + _ => abort("bounded analysis should succeed") + } + assert_eq(result.diagnostics.iterations, 1) + assert_true(!result.diagnostics.converged) +} + +///| +test "decontX: stronger low-contamination prior shrinks estimates" { + let (counts, genes, cells, clusters, _) = @src.decontx_example_data() + let weak = @src.DecontXConfig::create( + max_iterations=1, + contamination_prior_alpha=1.0, + contamination_prior_beta=1.0, + ) catch { + _ => abort("weak prior should build") + } + let strong = @src.DecontXConfig::create( + max_iterations=1, + contamination_prior_alpha=1.0, + contamination_prior_beta=99.0, + ) catch { + _ => abort("strong prior should build") + } + let weak_result = @src.decontx(counts, genes, cells, clusters, config=weak) catch { + _ => abort("weak-prior analysis should succeed") + } + let strong_result = @src.decontx( + counts, + genes, + cells, + clusters, + config=strong, + ) catch { + _ => abort("strong-prior analysis should succeed") + } + assert_true( + strong_result.mean_contamination() < weak_result.mean_contamination(), + ) +} + +///| +test "decontX: automatic clustering finds both example populations" { + let (counts, genes, cells, _, _) = @src.decontx_example_data() + let result = @src.decontx_auto(counts, genes, cells, 2) catch { + _ => abort("automatic clustering should succeed") + } + assert_eq(result.n_cells(), 8) + assert_eq(result.n_clusters(), 2) + assert_true(result.cluster_names[0].has_prefix("cluster_")) +} + +///| +test "decontX: automatic clustering validates requested cluster count" { + let (counts, genes, cells, _, _) = @src.decontx_example_data() + let one = try { + ignore(@src.decontx_auto(counts, genes, cells, 1)) + false + } catch { + DecontXError(_) => true + } + let too_many = try { + ignore(@src.decontx_auto(counts, genes, cells, 9)) + false + } catch { + DecontXError(_) => true + } + assert_true(one) + assert_true(too_many) +} + +///| +test "decontX: SCE integration adds assay and diagnostics" { + let output = @src.decontx_sce(decontx_test_sce()) catch { + _ => abort("valid SCE integration should succeed") + } + let corrected = @src.sce_get_assay(output.experiment, "decontXcounts") + assert_eq(corrected.length(), 6) + assert_eq(corrected[0].length(), 8) + assert_eq( + @src.sce_get_col_data(output.experiment, "decontX_contamination").length(), + 8, + ) + assert_eq(@src.sce_get_col_data(output.experiment, "decontX_cluster"), [ + "T", "T", "T", "T", "B", "B", "B", "B", + ]) +} + +///| +test "decontX: SCE integration does not mutate the source container" { + let source = decontx_test_sce() + let _ = @src.decontx_sce(source) catch { + _ => abort("valid SCE integration should succeed") + } + assert_eq(@src.sce_get_assay(source, "decontXcounts").length(), 0) + assert_eq(@src.sce_get_col_data(source, "decontX_contamination").length(), 0) +} + +///| +test "decontX: SCE integration validates assay and cluster metadata" { + let missing_cluster = @src.SingleCellExperiment::new( + [[1.0, 2.0], [2.0, 1.0]], + ["G1", "G2"], + ["C1", "C2"], + ) + let cluster_error = try { + ignore(@src.decontx_sce(missing_cluster)) + false + } catch { + DecontXError(_) => true + } + let missing_assay = @src.SCEBuilder::new() + |> @src.SCEBuilder::add_assay("other", [[1.0, 2.0], [2.0, 1.0]]) + |> @src.SCEBuilder::add_col_data("cluster", ["A", "B"]) + |> @src.SCEBuilder::build + let assay_error = try { + ignore(@src.decontx_sce(missing_assay)) + false + } catch { + DecontXError(_) => true + } + assert_true(cluster_error) + assert_true(assay_error) +} + +///| +test "decontX: SCE integration supports a custom output assay" { + let output = @src.decontx_sce( + decontx_test_sce(), + output_assay="ambient_corrected", + ) catch { + _ => abort("custom output assay should be accepted") + } + assert_eq( + @src.sce_get_assay(output.experiment, "ambient_corrected").length(), + 6, + ) + assert_eq(@src.sce_get_assay(output.experiment, "decontXcounts").length(), 0) +} From 34b6755840a66211ec3bafcc4593fc39ce219813 Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 00:36:41 +0800 Subject: [PATCH 16/41] #28 /8721 feat(alignment_map): Bio.Align.Alignment map/mapall overhang & PSL & protein MSA & MSA --- README.md | 24 +- examples/alignment_map_demo/main.mbt | 135 +++ examples/alignment_map_demo/moon.pkg | 5 + src/alignment_map.mbt | 1372 ++++++++++++++++++++++++++ test/moonbit/alignment_map_test.mbt | 856 ++++++++++++++++ 5 files changed, 2388 insertions(+), 4 deletions(-) create mode 100644 examples/alignment_map_demo/main.mbt create mode 100644 examples/alignment_map_demo/moon.pkg create mode 100644 src/alignment_map.mbt create mode 100644 test/moonbit/alignment_map_test.mbt diff --git a/README.md b/README.md index 77bcb9e6..c6618e0c 100644 --- a/README.md +++ b/README.md @@ -159,6 +159,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | Bio.SearchIO.InfernalIO | Infernal cmscan/cmsearch解析: tabular格式1/2/3自动检测、non-verbose文本与--noali、CM/HMM-only、Query/Hit/HSP/Fragment层次、正负链坐标、local-end多片段、过滤与SearchIO转换 | | ✅ | Bioconductor variancePartition | 多随机截距线性混合模型、ML/REML方差分量、固定/随机/残差方差占比、precision weights、BLUP、dream contrast、数值Satterthwaite检验、BH-FDR与SummarizedExperiment接入 | | ✅ | Bio.Align.Alignment shared-reference merge | 共享参考PWA/MSA合并、reference-boundary insertion slot同步、局部reference/query坐标、metadata、统计、MSA与aligned FASTA转换 | +| ✅ | Bio.Align.Alignment map/mapall | 零起始半开区间alignment path组合、局部clipping、gap与正反链传播、双向坐标查询、PSL、批量map及protein MSA到codon-aware nucleotide MSA投影 | | ✅ | Bioconductor decontX | 单细胞ambient RNA去污染: cluster-native/contaminant多项式混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解、诊断与SingleCellExperiment接入 | | ✅ | Bio.PDB.SASA | 溶剂可及表面积计算: Shrake-Rupley滚动球算法(Fibonacci球面采样)、范德华半径查表、逐原子/残基/链SASA、骨架/侧链拆分 | | ✅ | Bio.SeqIO.NibIO | nib 2-bit二进制序列格式: DNA 2-bit编码(T=0/C=1/A=2/G=3)、4碱基/字节打包、hex I/O、子序列提取、反向互补、GC含量、压缩比 | @@ -215,6 +216,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **UniGene** | Biopython `Bio.UniGene` | NCBI UniGene固定宽度记录解析、类型化序列/蛋白相似性/STS/转录本映射、严格SCOUNT校验、序列化往返 | ✅ | | **HH-suite HHR** | Biopython `Bio.Align.hhr` | HHR元数据、命中摘要、多块profile比对、consensus/二级结构/DSSP/confidence注释、概率和E-value查询 | ✅ | | **共享参考比对合并** | Biopython `Bio.Align.Alignment.from_alignments_with_same_reference` | 混合PWA/MSA输入、首端/内部/末端insertion同步、多query投影、局部坐标与metadata保留、统计和格式转换 | ✅ | +| **Alignment坐标组合** | Biopython `Bio.Align.Alignment.map/mapall` | alignment path组合、局部overhang clipping、exon/intron与indel gap、正反链组合、坐标双向查询、PSL及1:1/1:3 MSA投影 | ✅ | | **Prosite** | Biopython `Bio.Prosite` | 蛋白质模体数据库搜索、Prosite模式解析、模体匹配算法、模体得分计算 | ✅ | | **PAML** | Biopython `Bio.PAML` | 分子进化分析、dN/dS计算（Nei-Gojobori方法）、Jukes-Cantor校正、密码子使用分析 | ✅ | | **Graphics** | Biopython `Bio.Graphics` | 生物信息学可视化、序列Logo绘制、序列比对可视化、基因组特征绘图 | ✅ | @@ -413,6 +415,7 @@ IvanAXu/BioSeqs/ │ ├── genbank_io.mbt # GenBank 格式解析 │ ├── align.mbt # MultipleSeqAlignment 多序列比对 │ ├── shared_reference_alignment.mbt # Bio.Align共享参考PWA/MSA合并、insertion slot同步与坐标映射 +│ ├── alignment_map.mbt # Bio.Align.Alignment map/mapall坐标路径组合与MSA投影 │ ├── alignio.mbt # 比对文件 I/O │ ├── clustal_io.mbt # Clustal 格式 │ ├── phylip_io.mbt # PHYLIP 格式 @@ -1096,6 +1099,7 @@ IvanAXu/BioSeqs/ │ ├── infernal_io_demo/ # Infernal cmscan/cmsearch解析示例 (tabular 3、文本local-end、过滤、SearchIO转换) │ ├── hhr_demo/ # HH-suite HHR解析、命中筛选、坐标映射与序列化往返示例 │ ├── shared_reference_alignment_demo/ # 共享参考PWA/MSA合并、insertion同步、坐标映射与FASTA转换示例 +│ ├── alignment_map_demo/ # Alignment.map/mapall、反链、PSL与protein-to-codon MSA投影示例 │ ├── gene_pop_demo/ # GenePop群体遗传学示例 (基因型解析、等位基因频率、杂合度统计、序列化往返) │ ├── stage_r_demo/ # stageR两阶段检验示例 (筛选+确认、Simes聚合、BH-FDR、Holm步降、OFDR控制) │ ├── enriched_heatmap_demo/ # EnrichedHeatmap富集热图示例 (信号归一化、四种均值模式、行平滑、链方向处理) @@ -1296,6 +1300,7 @@ IvanAXu/BioSeqs/ │ │ ├── milo_test.mbt │ │ ├── variance_partition_test.mbt │ │ ├── shared_reference_alignment_test.mbt +│ │ ├── alignment_map_test.mbt │ │ ├── search_io_test.mbt │ │ ├── searchio_new_test.mbt │ │ ├── seq_complexity_test.mbt @@ -1472,7 +1477,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8677 个测试全部通过 +moon test # ✅ 8721 个测试全部通过 ``` ### 模块对照表 @@ -1518,6 +1523,7 @@ moon test # ✅ 8677 个测试全 | `searchio.mbt` | BioPython `Bio.SearchIO` | 统一搜索结果模型、BLAST/HMMER解析、E-value过滤 | | `hhr.mbt` | BioPython `Bio.Align.hhr` | HHsearch/HHblits HHR解析、profile比对注释、命中筛选、坐标映射与规范序列化 | | `shared_reference_alignment.mbt` | BioPython `Bio.Align.Alignment.from_alignments_with_same_reference` | 共享参考PWA/MSA合并、insertion slot同步、局部坐标、双向映射、统计、MSA与FASTA转换 | +| `alignment_map.mbt` | BioPython `Bio.Align.Alignment.map/mapall` | alignment path组合、local clipping、gap与链向传播、双向坐标查询、PSL、map_many及codon-aware MSA投影 | #### 系统发育树 @@ -1782,6 +1788,7 @@ moon test # ✅ 8677 个测试全 | `milo.mbt` | `miloR` | 精确KNN图、median精炼重叠邻域、邻域计数/表达、固定效应NB-GLM/Wald检验、graph spatial FDR与SCE接入 | | `variance_partition.mbt` | `variancePartition` | typed fixed/random design、多随机截距LMM、ML/REML方差分解、BLUP、weighted dream contrast、Satterthwaite自由度与SummarizedExperiment入口 | | `shared_reference_alignment.mbt` | `Bio.Align.Alignment` | 同参考PWA/MSA的reference-boundary insertion同步、原query投影、局部坐标、metadata、统计与格式转换 | +| `alignment_map.mbt` | `Bio.Align.Alignment.map/mapall` | 两层alignment坐标组合、正反链与gap传播、PSL、批量映射及protein/nucleotide MSA投影 | | `infercnv.mbt` | `infercnv` | 单细胞拷贝数变异推断（基因组位置排序、参考细胞有界 LFC 计算、金字塔权重平滑、CNV 分数与恶性细胞预测） | | `scenic.mbt` | `SCENIC` | 单细胞调控网络推断与聚类（TF-target 共表达模块、Regulon 构建、AUCell 活性评分、二值化阈值、细胞状态与主控调控因子） | | `cibersort.mbt` | `CIBERSORT` | 免疫细胞去卷积（NNLS 求解、LM22 风格特征矩阵、Pearson 拟合优度、分数归一化） | @@ -2870,6 +2877,12 @@ observation-level precision weights 会先缩放到均值 1，并进入 `V = Σ `decontx` 返回校正计数、污染计数、每细胞污染率、native/contaminant profiles、cluster 编码和完整 likelihood 诊断，且对每个观测保持 `corrected + contaminant = original`。查询 API 提供 cell/cluster estimates、最高污染细胞、名称索引和摘要；`decontx_auto` 对 library-size scaling 后的 `log(1 + count)` 表达执行确定性 k-means 初始化。`decontx_sce` 从指定 assay 和 cluster `colData` 读取输入，在复制的 `SingleCellExperiment` 中增加校正 assay、污染率、cluster 和迭代 metadata，不修改调用方对象。当前范围采用 cluster 标签或 k-means，而非上游 variational Bayes 聚类后端；不包含 GPU/稀疏矩阵专用求解器和绘图接口。 +### 251. Alignment 坐标组合 (Biopython Bio.Align.Alignment.map/mapall) + +实现 Biopython `Alignment.map` 的 coordinate path composition：第一层表示 outer target 到 shared middle，第二层表示 shared middle 到 final query，组合过程只扫描并相交两条 alignment path，不重新执行序列比对，也不依赖序列内容。`CoordinatePairwiseAlignment` 使用零起始、半开区间坐标，支持局部 alignment 的左右 overhang clipping、exon/intron 与 insertion/deletion gap、正链/反链及双反链组合；可从现有 `PairwiseAlignment` 适配，也可仅提供序列长度和坐标。结果提供 aligned blocks/counts、target/query 双向坐标查询、可选反向互补的 gapped rows、PSL、摘要及 `map_many`。 + +`CoordinateMultipleAlignment.mapall` 将 MSA 每行通过对应 pairwise mapping 投影到统一列空间，支持 nucleotide 1:1 和 protein:nucleotide 1:3 两类一致比例，因此可将 protein MSA 转换为 codon-aware nucleotide MSA，并保留氨基酸 gap 对应的三碱基 gap。构造器会验证名称、序列、坐标边界、单调方向、step size、共享序列长度和跨行映射比例；当前不负责生成原始 pairwise alignment，也不支持混合比例、frameshift 或非整数缩放。 + ## 性能优化 ### 优化策略 @@ -2971,8 +2984,8 @@ observation-level precision weights 会先缩放到均值 1，并进入 `V = Σ | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8677 | -| 通过数 | 8677 | +| 总测试数 | 8721 | +| 通过数 | 8721 | | 失败数 | 0 | | 通过率 | 100% | @@ -3075,6 +3088,7 @@ moon test --update | UniGene | `unigene_test.mbt` | 23 | | Bio.Align.hhr | `hhr_test.mbt` | 33 | | Bio.Align shared-reference merge | `shared_reference_alignment_test.mbt` | 41 | +| Bio.Align Alignment.map/mapall | `alignment_map_test.mbt` | 44 | | SparseArray | `sparse_array_test.mbt` | 41 | | mmCIF | `mmcif_test.mbt` | 2 | | BinaryCIF | `binary_cif_test.mbt` | 37 | @@ -3371,7 +3385,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 358 个示例程序，展示各模块的典型用法： +项目提供 359 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3559,6 +3573,7 @@ moon run cmd/bench/main.mbt | infernal_io_demo | Infernal cmscan/cmsearch解析（tabular 3、non-verbose文本、local-end片段、过滤与SearchIO转换） | `moon run examples/infernal_io_demo` | | variance_partition_demo | typed固定/随机设计、ML方差分解、BLUP、precision weights、dream contrast与SummarizedExperiment接入 | `moon run examples/variance_partition_demo` | | shared_reference_alignment_demo | 共享参考PWA/MSA合并、reference insertion同步、坐标映射、统计、MSA与aligned FASTA转换 | `moon run examples/shared_reference_alignment_demo` | +| alignment_map_demo | chromosome→transcript→read坐标组合、intron gap、反链、坐标查询、PSL与protein-to-codon MSA投影 | `moon run examples/alignment_map_demo` | | gene_pop_demo | GenePop群体遗传学（基因型解析、等位基因频率、杂合度统计、序列化往返） | `moon run examples/gene_pop_demo/main.mbt` | | stage_r_demo | stageR两阶段假设检验（筛选+确认、Simes聚合、BH-FDR、Holm步降、OFDR控制） | `moon run examples/stage_r_demo/main.mbt` | | enriched_heatmap_demo | EnrichedHeatmap富集热图（信号归一化、四种均值模式、行平滑、链方向处理） | `moon run examples/enriched_heatmap_demo/main.mbt` | @@ -3664,6 +3679,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bio.SearchIO.InfernalIO Infernal cmscan/cmsearch输出解析（tabular 1/2/3、non-verbose文本、--noali、CM/HMM-only、local-end多片段与SearchIO转换） - ✅ 实现 Bioconductor variancePartition 重复测量混合模型（ML/REML方差分解、BLUP、precision weights、dream contrast、数值Satterthwaite、BH-FDR与SummarizedExperiment接入） - ✅ 实现 Bio.Align共享参考序列比对合并（混合PWA/MSA、reference-boundary insertion同步、局部坐标、双向映射、统计与格式转换） +- ✅ 实现 Bio.Align.Alignment map/mapall（alignment path组合、local clipping、gap与正反链传播、坐标查询、PSL及protein-to-codon MSA投影） - ✅ 实现 Bioconductor decontX ambient RNA去污染（cluster-native/contaminant混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解与SCE集成） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） diff --git a/examples/alignment_map_demo/main.mbt b/examples/alignment_map_demo/main.mbt new file mode 100644 index 00000000..b5e0833f --- /dev/null +++ b/examples/alignment_map_demo/main.mbt @@ -0,0 +1,135 @@ +///| +fn main { + println("=== Biopython Alignment.map/mapall Demo ===") + + println("\n1. Compose chromosome -> transcript -> read") + let chromosome_to_transcript = @src.coordinate_pairwise_alignment( + "chromosome", + "AAAAAAAACCCCCCCAAAAAAAAAAAGGGGGGAAAAAAAA", + "transcript", + "CCCCCCCGGGGGG", + [8, 15, 26, 32], + [0, 7, 7, 13], + ) catch { + _ => abort("failed to build chromosome-to-transcript alignment") + } + let transcript_to_read = @src.coordinate_pairwise_alignment( + "transcript", + "CCCCCCCGGGGGG", + "read", + "CCCCGGGG", + [3, 11], + [0, 8], + ) catch { + _ => abort("failed to build transcript-to-read alignment") + } + let chromosome_to_read = chromosome_to_transcript.map(transcript_to_read) catch { + _ => abort("failed to compose coordinate alignments") + } + println(" " + chromosome_to_read.summary()) + println( + " target coordinates: " + chromosome_to_read.target_coordinates.to_string(), + ) + println( + " query coordinates: " + chromosome_to_read.query_coordinates.to_string(), + ) + + println("\n2. Render the exon blocks and intron gap") + match chromosome_to_read.aligned_rows() { + Some((target, query)) => { + println(" chromosome: " + target) + println(" read: " + query) + } + None => abort("concrete alignment rows should render") + } + let counts = chromosome_to_read.counts() + println( + " blocks=" + + counts.blocks.to_string() + + ", aligned=" + + counts.aligned.to_string() + + ", query-gap bases=" + + counts.query_gap_bases.to_string(), + ) + + println("\n3. Query coordinates and serialize PSL") + println( + " chromosome position 14 -> read: " + + chromosome_to_read.target_to_query(14).to_string(), + ) + println( + " read position 4 -> chromosome: " + + chromosome_to_read.query_to_target(4).to_string(), + ) + let psl = chromosome_to_read.to_psl() catch { + _ => abort("failed to serialize PSL") + } + println(" PSL: " + psl) + + println("4. Preserve strand through composition") + let chromosome_to_reverse_transcript = @src.coordinate_pairwise_alignment( + "chromosome", + "AAAAAAAAAAAAGGGGGGGCCCCCGGGGGGAAAAAAAAAA", + "reverse_transcript", + "TCCCCCCGGGGGCCCCCCC", + [12, 31], + [19, 0], + ) catch { + _ => abort("failed to build reverse transcript alignment") + } + let reverse_transcript_to_read = @src.coordinate_pairwise_alignment( + "reverse_transcript", + "TCCCCCCGGGGGCCCCCCC", + "reverse_read", + "CCCGGGGGCC", + [4, 14], + [0, 10], + ) catch { + _ => abort("failed to build reverse read alignment") + } + let reverse_projection = chromosome_to_reverse_transcript.map( + reverse_transcript_to_read, + ) catch { + _ => abort("failed to compose reverse-strand alignment") + } + println(" " + reverse_projection.summary()) + println( + " projected query coordinates: " + + reverse_projection.query_coordinates.to_string(), + ) + + println("\n5. Project a protein MSA to a codon-aware nucleotide MSA") + let protein_msa = @src.coordinate_multiple_alignment( + ["protein_1", "protein_2"], + ["M-K", "MTK"], + ) catch { + _ => abort("failed to build protein MSA") + } + let protein_1_to_dna = @src.coordinate_pairwise_alignment( + "protein_1", + "MK", + "dna_1", + "ATGAAA", + [0, 2], + [0, 6], + ) catch { + _ => abort("failed to build first protein-to-DNA mapping") + } + let protein_2_to_dna = @src.coordinate_pairwise_alignment( + "protein_2", + "MTK", + "dna_2", + "ATGACCAAA", + [0, 3], + [0, 9], + ) catch { + _ => abort("failed to build second protein-to-DNA mapping") + } + let nucleotide_msa = protein_msa.mapall([protein_1_to_dna, protein_2_to_dna]) catch { + _ => abort("failed to project protein MSA") + } + println(" " + nucleotide_msa.summary()) + println(nucleotide_msa.to_fasta()) + + println("=== Demo Complete ===") +} diff --git a/examples/alignment_map_demo/moon.pkg b/examples/alignment_map_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/alignment_map_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/alignment_map.mbt b/src/alignment_map.mbt new file mode 100644 index 00000000..be14bede --- /dev/null +++ b/src/alignment_map.mbt @@ -0,0 +1,1372 @@ +// Compose coordinate-based alignments without realigning their sequences. +// +// This implements the core semantics of Biopython Bio.Align.Alignment.map +// and mapall. Coordinates are zero-based, half-open sequence boundaries. + +///| +/// Error raised by coordinate alignment construction or projection. +pub suberror AlignmentMapError { + AlignmentMapError(String) +} + +///| +/// One aligned block in a coordinate-based pairwise alignment. +pub struct CoordinateAlignmentBlock { + target_start : Int + target_end : Int + query_start : Int + query_end : Int + size : Int +} derive(Eq, Debug) + +///| +/// Coordinate representation of a pairwise alignment. +/// +/// Sequence text may be empty when only lengths and coordinates are known. +/// Target coordinates are non-decreasing. Query coordinates may increase or +/// decrease, allowing reverse-strand alignments. +pub struct CoordinatePairwiseAlignment { + target_name : String + query_name : String + target_sequence : String + query_sequence : String + target_length : Int + query_length : Int + target_coordinates : Array[Int] + query_coordinates : Array[Int] +} derive(Eq, Debug) + +///| +/// Coordinate representation of a multiple sequence alignment. +pub struct CoordinateMultipleAlignment { + names : Array[String] + sequences : Array[String] + coordinates : Array[Array[Int]] +} derive(Eq, Debug) + +///| +/// Basic alignment statistics derived from a coordinate path. +pub struct CoordinateAlignmentCounts { + aligned : Int + target_gap_bases : Int + query_gap_bases : Int + target_gap_events : Int + query_gap_events : Int + blocks : Int +} derive(Eq, Debug) + +///| +fn alignment_map_copy_ints(values : Array[Int]) -> Array[Int] { + let copy : Array[Int] = [] + for value in values { + copy.push(value) + } + copy +} + +///| +fn alignment_map_copy_strings(values : Array[String]) -> Array[String] { + let copy : Array[String] = [] + for value in values { + copy.push(value) + } + copy +} + +///| +fn alignment_map_abs(value : Int) -> Int { + if value < 0 { + -value + } else { + value + } +} + +///| +fn alignment_map_min(left : Int, right : Int) -> Int { + if left < right { + left + } else { + right + } +} + +///| +fn alignment_map_max(left : Int, right : Int) -> Int { + if left > right { + left + } else { + right + } +} + +///| +fn alignment_map_validate_name( + name : String, + label : String, +) -> Unit raise AlignmentMapError { + if name.length() == 0 { + raise AlignmentMapError(label + " must not be empty") + } +} + +///| +fn alignment_map_validate_sequence( + sequence : String, + expected_length : Int, + label : String, +) -> Unit raise AlignmentMapError { + if expected_length < 0 { + raise AlignmentMapError(label + " length must be non-negative") + } + if sequence.length() > 0 && sequence.length() != expected_length { + raise AlignmentMapError(label + " length does not match its declaration") + } + let mut index = 0 + while index < sequence.length() { + let residue = sequence.unsafe_get(index).unsafe_to_char() + if residue == '-' { + raise AlignmentMapError(label + " must not contain gap characters") + } + if residue == ' ' || residue == '\t' || residue == '\n' || residue == '\r' { + raise AlignmentMapError(label + " must not contain whitespace") + } + index = index + 1 + } +} + +///| +fn alignment_map_validate_coordinates( + target_length : Int, + query_length : Int, + target_coordinates : Array[Int], + query_coordinates : Array[Int], +) -> Unit raise AlignmentMapError { + if target_coordinates.length() != query_coordinates.length() { + raise AlignmentMapError( + "target and query coordinates must have equal length", + ) + } + if target_coordinates.length() == 1 { + raise AlignmentMapError( + "an alignment path must be empty or contain at least two points", + ) + } + let mut index = 0 + while index < target_coordinates.length() { + let target = target_coordinates[index] + let query = query_coordinates[index] + if target < 0 || target > target_length { + raise AlignmentMapError("target coordinate is out of bounds") + } + if query < 0 || query > query_length { + raise AlignmentMapError("query coordinate is out of bounds") + } + index = index + 1 + } + let mut query_direction = 0 + index = 0 + while index + 1 < target_coordinates.length() { + let target_step = target_coordinates[index + 1] - target_coordinates[index] + let query_step = query_coordinates[index + 1] - query_coordinates[index] + if target_step < 0 { + raise AlignmentMapError("target coordinates must be non-decreasing") + } + if target_step == 0 && query_step == 0 { + raise AlignmentMapError("consecutive alignment coordinates must differ") + } + if query_step > 0 { + if query_direction < 0 { + raise AlignmentMapError("query coordinates change direction") + } + query_direction = 1 + } else if query_step < 0 { + if query_direction > 0 { + raise AlignmentMapError("query coordinates change direction") + } + query_direction = -1 + } + index = index + 1 + } +} + +///| +fn alignment_map_create( + target_name : String, + target_sequence : String, + target_length : Int, + query_name : String, + query_sequence : String, + query_length : Int, + target_coordinates : Array[Int], + query_coordinates : Array[Int], +) -> CoordinatePairwiseAlignment raise AlignmentMapError { + alignment_map_validate_name(target_name, "target name") + alignment_map_validate_name(query_name, "query name") + alignment_map_validate_sequence( + target_sequence, target_length, "target sequence", + ) + alignment_map_validate_sequence( + query_sequence, query_length, "query sequence", + ) + alignment_map_validate_coordinates( + target_length, query_length, target_coordinates, query_coordinates, + ) + CoordinatePairwiseAlignment::{ + target_name, + query_name, + target_sequence, + query_sequence, + target_length, + query_length, + target_coordinates: alignment_map_copy_ints(target_coordinates), + query_coordinates: alignment_map_copy_ints(query_coordinates), + } +} + +///| +/// Construct a coordinate pairwise alignment from concrete sequences. +pub fn coordinate_pairwise_alignment( + target_name : String, + target_sequence : String, + query_name : String, + query_sequence : String, + target_coordinates : Array[Int], + query_coordinates : Array[Int], +) -> CoordinatePairwiseAlignment raise AlignmentMapError { + alignment_map_create( + target_name, + target_sequence, + target_sequence.length(), + query_name, + query_sequence, + query_sequence.length(), + target_coordinates, + query_coordinates, + ) +} + +///| +/// Construct an alignment when sequence text is unavailable. +pub fn coordinate_pairwise_alignment_with_lengths( + target_name : String, + target_length : Int, + query_name : String, + query_length : Int, + target_coordinates : Array[Int], + query_coordinates : Array[Int], + target_sequence? : String = "", + query_sequence? : String = "", +) -> CoordinatePairwiseAlignment raise AlignmentMapError { + alignment_map_create( + target_name, target_sequence, target_length, query_name, query_sequence, query_length, + target_coordinates, query_coordinates, + ) +} + +///| +/// Adapt the repository's existing PairwiseAlignment representation. +pub fn coordinate_alignment_from_pairwise( + alignment : PairwiseAlignment, + target_name? : String = "target", + query_name? : String = "query", +) -> CoordinatePairwiseAlignment raise AlignmentMapError { + if alignment.aligned_target.length() != alignment.aligned_query.length() { + raise AlignmentMapError("aligned pairwise rows must have equal length") + } + let target_coordinates = [alignment.target_start] + let query_coordinates = [alignment.query_start] + let mut target = alignment.target_start + let mut query = alignment.query_start + let mut column = 0 + while column < alignment.aligned_target.length() { + if alignment.aligned_target.unsafe_get(column).unsafe_to_char() != '-' { + target = target + 1 + } + if alignment.aligned_query.unsafe_get(column).unsafe_to_char() != '-' { + query = query + 1 + } + target_coordinates.push(target) + query_coordinates.push(query) + column = column + 1 + } + if target != alignment.target_end || query != alignment.query_end { + raise AlignmentMapError("pairwise coordinates disagree with aligned rows") + } + coordinate_pairwise_alignment( + target_name, + alignment.target, + query_name, + alignment.query, + target_coordinates, + query_coordinates, + ) +} + +///| +fn alignment_map_reverse(values : Array[Int]) -> Array[Int] { + let result : Array[Int] = [] + let mut index = values.length() + while index > 0 { + index = index - 1 + result.push(values[index]) + } + result +} + +///| +fn alignment_map_relationship( + target_coordinates : Array[Int], + query_coordinates : Array[Int], + label : String, +) -> Int raise AlignmentMapError { + let mut relationship = 0 + let mut index = 0 + while index + 1 < target_coordinates.length() { + let target_step = target_coordinates[index + 1] - target_coordinates[index] + let query_step = query_coordinates[index + 1] - query_coordinates[index] + if target_step != 0 && query_step != 0 { + let current = if target_step * query_step > 0 { 1 } else { -1 } + if relationship != 0 && relationship != current { + raise AlignmentMapError("inconsistent steps in " + label) + } + relationship = current + } + index = index + 1 + } + if relationship == 0 { + 1 + } else { + relationship + } +} + +///| +fn alignment_map_validate_equal_steps( + target_coordinates : Array[Int], + query_coordinates : Array[Int], + label : String, +) -> Unit raise AlignmentMapError { + let mut index = 0 + while index + 1 < target_coordinates.length() { + let target_step = target_coordinates[index + 1] - target_coordinates[index] + let query_step = query_coordinates[index + 1] - query_coordinates[index] + if target_step < 0 || query_step < 0 { + raise AlignmentMapError("normalized coordinates decrease in " + label) + } + if target_step > 0 && query_step > 0 && target_step != query_step { + raise AlignmentMapError("unequal aligned step sizes in " + label) + } + index = index + 1 + } +} + +///| +fn alignment_map_transform_against_reverse_middle( + alignment : CoordinatePairwiseAlignment, +) -> (Array[Int], Array[Int]) { + let target_reversed = alignment_map_reverse(alignment.target_coordinates) + let query_reversed = alignment_map_reverse(alignment.query_coordinates) + let targets : Array[Int] = [] + let queries : Array[Int] = [] + for value in target_reversed { + targets.push(alignment.target_length - value) + } + for value in query_reversed { + queries.push(alignment.query_length - value) + } + (targets, queries) +} + +///| +/// Compose `self` (outer target -> shared middle) with `next` +/// (shared middle -> final query). +pub fn CoordinatePairwiseAlignment::map( + self : CoordinatePairwiseAlignment, + next : CoordinatePairwiseAlignment, +) -> CoordinatePairwiseAlignment raise AlignmentMapError { + if self.query_length != next.target_length { + raise AlignmentMapError( + "first query length must equal second target length", + ) + } + if self.target_coordinates.length() == 0 || + next.target_coordinates.length() == 0 { + return alignment_map_create( + self.target_name, + self.target_sequence, + self.target_length, + next.query_name, + next.query_sequence, + next.query_length, + [], + [], + ) + } + let relationship1 = alignment_map_relationship( + self.target_coordinates, + self.query_coordinates, + "first alignment", + ) + let relationship2 = alignment_map_relationship( + next.target_coordinates, + next.query_coordinates, + "second alignment", + ) + let coordinates1_target = alignment_map_copy_ints(self.target_coordinates) + let coordinates1_query = alignment_map_copy_ints(self.query_coordinates) + let mut coordinates2_target = alignment_map_copy_ints(next.target_coordinates) + let mut coordinates2_query = alignment_map_copy_ints(next.query_coordinates) + if relationship1 > 0 { + if relationship2 < 0 { + let transformed : Array[Int] = [] + for value in coordinates2_query { + transformed.push(next.query_length - value) + } + coordinates2_query = transformed + } + } else { + let transformed_middle : Array[Int] = [] + for value in coordinates1_query { + transformed_middle.push(self.query_length - value) + } + coordinates1_query.clear() + for value in transformed_middle { + coordinates1_query.push(value) + } + let (reversed_target, reversed_query) = if relationship2 > 0 { + alignment_map_transform_against_reverse_middle(next) + } else { + let reversed_middle = alignment_map_reverse(next.target_coordinates) + let normalized_middle : Array[Int] = [] + for value in reversed_middle { + normalized_middle.push(next.target_length - value) + } + ( + normalized_middle, + alignment_map_reverse(next.query_coordinates), + ) + } + coordinates2_target = reversed_target + coordinates2_query = reversed_query + } + alignment_map_validate_equal_steps( + coordinates1_target, coordinates1_query, "first alignment", + ) + alignment_map_validate_equal_steps( + coordinates2_target, coordinates2_query, "second alignment", + ) + let mut first_segment = 0 + while first_segment + 1 < coordinates1_target.length() { + if coordinates1_target[first_segment] < + coordinates1_target[first_segment + 1] && + coordinates1_query[first_segment] < coordinates1_query[first_segment + 1] { + break + } + first_segment = first_segment + 1 + } + if first_segment + 1 >= coordinates1_target.length() { + return alignment_map_create( + self.target_name, + self.target_sequence, + self.target_length, + next.query_name, + next.query_sequence, + next.query_length, + [], + [], + ) + } + let mut outer_start = coordinates1_target[first_segment] + let mut middle_start = coordinates1_query[first_segment] + let mut outer_end = coordinates1_target[first_segment + 1] + let mut middle_end = coordinates1_query[first_segment + 1] + let path_target : Array[Int] = [] + let path_query : Array[Int] = [] + let mut output_target_end = 2147483647 + let mut output_query_end = 2147483647 + let mut second_target_start = 2147483647 + let mut second_query_start = 2147483647 + let mut point2 = 0 + while point2 < coordinates2_target.length() { + let second_target_end = coordinates2_target[point2] + let second_query_end = coordinates2_query[point2] + while second_query_start < second_query_end && + second_target_start < second_target_end { + let mut size = 0 + let mut handled = false + while !handled { + if second_target_start < middle_start { + size = alignment_map_min(second_target_end, middle_start) - + second_target_start + handled = true + } else if second_target_start < middle_end { + let offset = second_target_start - middle_start + size = alignment_map_min(second_target_end, middle_end) - + second_target_start + let query_start = second_query_start + let target_start = outer_start + offset + if target_start != output_target_end || + query_start != output_query_end { + if target_start > output_target_end && + query_start > output_query_end { + path_target.push(target_start) + path_query.push(output_query_end) + } + path_target.push(target_start) + path_query.push(query_start) + } + output_query_end = query_start + size + output_target_end = target_start + size + path_target.push(output_target_end) + path_query.push(output_query_end) + handled = true + } else { + first_segment = first_segment + 1 + let mut found = false + while first_segment + 1 < coordinates1_target.length() { + outer_start = coordinates1_target[first_segment] + middle_start = coordinates1_query[first_segment] + outer_end = coordinates1_target[first_segment + 1] + middle_end = coordinates1_query[first_segment + 1] + if outer_start < outer_end && middle_start < middle_end { + found = true + break + } + first_segment = first_segment + 1 + } + if !found { + size = second_query_end - second_query_start + handled = true + } + } + } + if size <= 0 { + break + } + second_query_start = second_query_start + size + second_target_start = second_target_start + size + } + second_target_start = second_target_end + second_query_start = second_query_end + point2 = point2 + 1 + } + if relationship1 != relationship2 { + let transformed : Array[Int] = [] + for value in path_query { + transformed.push(next.query_length - value) + } + path_query.clear() + for value in transformed { + path_query.push(value) + } + } + alignment_map_create( + self.target_name, + self.target_sequence, + self.target_length, + next.query_name, + next.query_sequence, + next.query_length, + path_target, + path_query, + ) +} + +///| +/// Map several alignments through the same outer alignment. +pub fn CoordinatePairwiseAlignment::map_many( + self : CoordinatePairwiseAlignment, + alignments : Array[CoordinatePairwiseAlignment], +) -> Array[CoordinatePairwiseAlignment] raise AlignmentMapError { + let results : Array[CoordinatePairwiseAlignment] = [] + for alignment in alignments { + results.push(self.map(alignment)) + } + results +} + +///| +pub fn CoordinatePairwiseAlignment::is_empty( + self : CoordinatePairwiseAlignment, +) -> Bool { + self.target_coordinates.length() == 0 +} + +///| +pub fn CoordinatePairwiseAlignment::is_reverse( + self : CoordinatePairwiseAlignment, +) -> Bool { + if self.query_coordinates.length() < 2 { + return false + } + self.query_coordinates[self.query_coordinates.length() - 1] < + self.query_coordinates[0] +} + +///| +pub fn CoordinatePairwiseAlignment::blocks( + self : CoordinatePairwiseAlignment, +) -> Array[CoordinateAlignmentBlock] { + let blocks : Array[CoordinateAlignmentBlock] = [] + let mut index = 0 + while index + 1 < self.target_coordinates.length() { + let target_start = self.target_coordinates[index] + let target_end = self.target_coordinates[index + 1] + let query_start = self.query_coordinates[index] + let query_end = self.query_coordinates[index + 1] + let target_size = target_end - target_start + let query_size = alignment_map_abs(query_end - query_start) + if target_size > 0 && query_size > 0 { + blocks.push(CoordinateAlignmentBlock::{ + target_start, + target_end, + query_start, + query_end, + size: alignment_map_min(target_size, query_size), + }) + } + index = index + 1 + } + blocks +} + +///| +pub fn CoordinatePairwiseAlignment::counts( + self : CoordinatePairwiseAlignment, +) -> CoordinateAlignmentCounts { + let mut aligned = 0 + let mut target_gap_bases = 0 + let mut query_gap_bases = 0 + let mut target_gap_events = 0 + let mut query_gap_events = 0 + let mut blocks = 0 + let mut index = 0 + while index + 1 < self.target_coordinates.length() { + let target_step = self.target_coordinates[index + 1] - + self.target_coordinates[index] + let query_step = alignment_map_abs( + self.query_coordinates[index + 1] - self.query_coordinates[index], + ) + if target_step > 0 && query_step > 0 { + aligned = aligned + alignment_map_min(target_step, query_step) + blocks = blocks + 1 + } else if target_step == 0 && query_step > 0 { + target_gap_bases = target_gap_bases + query_step + target_gap_events = target_gap_events + 1 + } else if target_step > 0 && query_step == 0 { + query_gap_bases = query_gap_bases + target_step + query_gap_events = query_gap_events + 1 + } + index = index + 1 + } + CoordinateAlignmentCounts::{ + aligned, + target_gap_bases, + query_gap_bases, + target_gap_events, + query_gap_events, + blocks, + } +} + +///| +pub fn CoordinatePairwiseAlignment::target_to_query( + self : CoordinatePairwiseAlignment, + position : Int, +) -> Int? { + let mut index = 0 + while index + 1 < self.target_coordinates.length() { + let target_start = self.target_coordinates[index] + let target_end = self.target_coordinates[index + 1] + let query_start = self.query_coordinates[index] + let query_end = self.query_coordinates[index + 1] + if target_start <= position && + position < target_end && + query_start != query_end { + let offset = position - target_start + if query_end > query_start { + return Some(query_start + offset) + } + return Some(query_start - offset - 1) + } + index = index + 1 + } + None +} + +///| +pub fn CoordinatePairwiseAlignment::query_to_target( + self : CoordinatePairwiseAlignment, + position : Int, +) -> Int? { + let mut index = 0 + while index + 1 < self.query_coordinates.length() { + let target_start = self.target_coordinates[index] + let target_end = self.target_coordinates[index + 1] + let query_start = self.query_coordinates[index] + let query_end = self.query_coordinates[index + 1] + if target_start != target_end { + if query_end > query_start && + query_start <= position && + position < query_end { + return Some(target_start + position - query_start) + } + if query_end < query_start && + query_end <= position && + position < query_start { + return Some(target_start + query_start - position - 1) + } + } + index = index + 1 + } + None +} + +///| +fn alignment_map_repeat( + builder : StringBuilder, + value : Char, + count : Int, +) -> Unit { + let mut index = 0 + while index < count { + builder.write_char(value) + index = index + 1 + } +} + +///| +fn alignment_map_complement(value : Char) -> Char { + match value { + 'A' => 'T' + 'a' => 't' + 'C' => 'G' + 'c' => 'g' + 'G' => 'C' + 'g' => 'c' + 'T' => 'A' + 't' => 'a' + 'U' => 'A' + 'u' => 'a' + _ => value + } +} + +///| +fn alignment_map_write_segment( + builder : StringBuilder, + sequence : String, + start : Int, + end : Int, + complement_reverse : Bool, +) -> Unit { + if end >= start { + let mut index = start + while index < end { + builder.write_char(sequence.unsafe_get(index).unsafe_to_char()) + index = index + 1 + } + } else { + let mut index = start + while index > end { + index = index - 1 + let residue = sequence.unsafe_get(index).unsafe_to_char() + builder.write_char( + if complement_reverse { + alignment_map_complement(residue) + } else { + residue + }, + ) + } + } +} + +///| +/// Render gapped rows when both sequence contents are available. +pub fn CoordinatePairwiseAlignment::aligned_rows( + self : CoordinatePairwiseAlignment, + complement_reverse? : Bool = true, +) -> (String, String)? { + if self.target_sequence.length() == 0 || self.query_sequence.length() == 0 { + return None + } + let target = StringBuilder::new() + let query = StringBuilder::new() + let mut index = 0 + while index + 1 < self.target_coordinates.length() { + let target_start = self.target_coordinates[index] + let target_end = self.target_coordinates[index + 1] + let query_start = self.query_coordinates[index] + let query_end = self.query_coordinates[index + 1] + let target_step = target_end - target_start + let query_step = alignment_map_abs(query_end - query_start) + if target_step > 0 && query_step > 0 { + alignment_map_write_segment( + target, + self.target_sequence, + target_start, + target_end, + false, + ) + alignment_map_write_segment( + query, + self.query_sequence, + query_start, + query_end, + complement_reverse, + ) + } else if target_step > 0 { + alignment_map_write_segment( + target, + self.target_sequence, + target_start, + target_end, + false, + ) + alignment_map_repeat(query, '-', target_step) + } else if query_step > 0 { + alignment_map_repeat(target, '-', query_step) + alignment_map_write_segment( + query, + self.query_sequence, + query_start, + query_end, + complement_reverse, + ) + } + index = index + 1 + } + Some((target.to_string(), query.to_string())) +} + +///| +fn alignment_map_join_ints(values : Array[Int]) -> String { + let builder = StringBuilder::new() + let mut index = 0 + while index < values.length() { + if index > 0 { + builder.write_char(',') + } + builder.write_string(values[index].to_string()) + index = index + 1 + } + if values.length() > 0 { + builder.write_char(',') + } + builder.to_string() +} + +///| +/// Serialize the coordinate blocks as a PSL record. +/// +/// Aligned positions are reported as matches because composition does not +/// require sequence contents; gap event/base counts remain exact. +pub fn CoordinatePairwiseAlignment::to_psl( + self : CoordinatePairwiseAlignment, +) -> String raise AlignmentMapError { + let blocks = self.blocks() + if blocks.length() == 0 { + raise AlignmentMapError("cannot serialize an empty alignment as PSL") + } + let counts = self.counts() + let block_sizes : Array[Int] = [] + let query_starts : Array[Int] = [] + let target_starts : Array[Int] = [] + let reverse = self.is_reverse() + let mut query_min = self.query_length + let mut query_max = 0 + let mut target_min = self.target_length + let mut target_max = 0 + for block in blocks { + block_sizes.push(block.size) + target_starts.push(block.target_start) + let block_query_min = alignment_map_min(block.query_start, block.query_end) + let block_query_max = alignment_map_max(block.query_start, block.query_end) + query_min = alignment_map_min(query_min, block_query_min) + query_max = alignment_map_max(query_max, block_query_max) + target_min = alignment_map_min(target_min, block.target_start) + target_max = alignment_map_max(target_max, block.target_end) + query_starts.push( + if reverse { + self.query_length - block_query_max + } else { + block_query_min + }, + ) + } + let strand = if reverse { "-" } else { "+" } + counts.aligned.to_string() + + "\t0\t0\t0\t" + + counts.target_gap_events.to_string() + + "\t" + + counts.target_gap_bases.to_string() + + "\t" + + counts.query_gap_events.to_string() + + "\t" + + counts.query_gap_bases.to_string() + + "\t" + + strand + + "\t" + + self.query_name + + "\t" + + self.query_length.to_string() + + "\t" + + query_min.to_string() + + "\t" + + query_max.to_string() + + "\t" + + self.target_name + + "\t" + + self.target_length.to_string() + + "\t" + + target_min.to_string() + + "\t" + + target_max.to_string() + + "\t" + + blocks.length().to_string() + + "\t" + + alignment_map_join_ints(block_sizes) + + "\t" + + alignment_map_join_ints(query_starts) + + "\t" + + alignment_map_join_ints(target_starts) + + "\n" +} + +///| +pub fn CoordinatePairwiseAlignment::summary( + self : CoordinatePairwiseAlignment, +) -> String { + let counts = self.counts() + "CoordinatePairwiseAlignment(" + + self.target_name + + " <- " + + self.query_name + + ", blocks=" + + counts.blocks.to_string() + + ", aligned=" + + counts.aligned.to_string() + + ", strand=" + + (if self.is_reverse() { "-" } else { "+" }) + + ")" +} + +///| +fn alignment_map_ungap(sequence : String) -> String { + let builder = StringBuilder::new() + let mut index = 0 + while index < sequence.length() { + let residue = sequence.unsafe_get(index).unsafe_to_char() + if residue != '-' { + builder.write_char(residue) + } + index = index + 1 + } + builder.to_string() +} + +///| +/// Build a coordinate MSA from equal-width gapped rows. +pub fn coordinate_multiple_alignment( + names : Array[String], + aligned_sequences : Array[String], +) -> CoordinateMultipleAlignment raise AlignmentMapError { + if names.length() == 0 { + raise AlignmentMapError( + "a multiple alignment must contain at least one row", + ) + } + if names.length() != aligned_sequences.length() { + raise AlignmentMapError("MSA names and rows must have equal length") + } + let width = aligned_sequences[0].length() + let sequences : Array[String] = [] + let coordinates : Array[Array[Int]] = [] + let mut row_index = 0 + while row_index < names.length() { + alignment_map_validate_name(names[row_index], "MSA row name") + if aligned_sequences[row_index].length() != width { + raise AlignmentMapError("all MSA rows must have equal width") + } + let raw = alignment_map_ungap(aligned_sequences[row_index]) + alignment_map_validate_sequence(raw, raw.length(), "MSA sequence") + sequences.push(raw) + let row = [0] + let mut coordinate = 0 + let mut column = 0 + while column < width { + if aligned_sequences[row_index].unsafe_get(column).unsafe_to_char() != '-' { + coordinate = coordinate + 1 + } + row.push(coordinate) + column = column + 1 + } + coordinates.push(row) + row_index = row_index + 1 + } + CoordinateMultipleAlignment::{ + names: alignment_map_copy_strings(names), + sequences, + coordinates, + } +} + +///| +fn alignment_map_factor( + alignment : CoordinatePairwiseAlignment, +) -> Int raise AlignmentMapError { + let mut factor = 0 + let mut index = 0 + while index + 1 < alignment.target_coordinates.length() { + let target_step = alignment_map_abs( + alignment.target_coordinates[index + 1] - + alignment.target_coordinates[index], + ) + let query_step = alignment_map_abs( + alignment.query_coordinates[index + 1] - + alignment.query_coordinates[index], + ) + if target_step > 0 && query_step > 0 { + let current = if query_step == target_step { + 1 + } else if query_step == 3 * target_step { + 3 + } else { + raise AlignmentMapError( + "mapall supports only 1:1 or protein-to-codon mappings", + ) + } + if factor != 0 && factor != current { + raise AlignmentMapError("mapping contains inconsistent step factors") + } + factor = current + } + index = index + 1 + } + if factor == 0 { + raise AlignmentMapError("mapping has no aligned blocks") + } + factor +} + +///| +fn alignment_map_validate_msa( + alignment : CoordinateMultipleAlignment, +) -> Unit raise AlignmentMapError { + if alignment.names.length() == 0 || + alignment.names.length() != alignment.sequences.length() || + alignment.names.length() != alignment.coordinates.length() { + raise AlignmentMapError("invalid multiple alignment dimensions") + } + let points = alignment.coordinates[0].length() + if points < 2 { + raise AlignmentMapError( + "multiple alignment must contain at least one column", + ) + } + let mut row_index = 0 + while row_index < alignment.names.length() { + alignment_map_validate_name(alignment.names[row_index], "MSA row name") + if alignment.coordinates[row_index].length() != points { + raise AlignmentMapError("MSA coordinate rows must have equal length") + } + let mut point = 0 + while point < points { + let coordinate = alignment.coordinates[row_index][point] + if coordinate < 0 || coordinate > alignment.sequences[row_index].length() { + raise AlignmentMapError("MSA coordinate is out of bounds") + } + if point > 0 && coordinate < alignment.coordinates[row_index][point - 1] { + raise AlignmentMapError("MSA coordinates must be non-decreasing") + } + point = point + 1 + } + row_index = row_index + 1 + } +} + +///| +/// Project every row of an MSA through its corresponding sequence mapping. +/// +/// A 1:1 mapping produces a mapped sequence MSA. A 1:3 protein-to-nucleotide +/// mapping produces a codon-aware nucleotide MSA without translating or +/// realigning the nucleotide sequences. +pub fn CoordinateMultipleAlignment::mapall( + self : CoordinateMultipleAlignment, + mappings : Array[CoordinatePairwiseAlignment], +) -> CoordinateMultipleAlignment raise AlignmentMapError { + alignment_map_validate_msa(self) + if mappings.length() != self.sequences.length() { + raise AlignmentMapError("mapall requires one mapping per MSA row") + } + let mut factor = 0 + let mut row_index = 0 + while row_index < mappings.length() { + if mappings[row_index].target_length != self.sequences[row_index].length() { + raise AlignmentMapError( + "mapping target length does not match its MSA row", + ) + } + let current_factor = alignment_map_factor(mappings[row_index]) + if factor == 0 { + factor = current_factor + } else if factor != current_factor { + raise AlignmentMapError("mapall mappings use inconsistent step factors") + } + row_index = row_index + 1 + } + let points = self.coordinates[0].length() + let master_coordinates = [0] + let mut master = 0 + let mut point = 0 + while point + 1 < points { + let mut step = 0 + row_index = 0 + while row_index < self.coordinates.length() { + let current = alignment_map_abs( + self.coordinates[row_index][point + 1] - + self.coordinates[row_index][point], + ) + step = alignment_map_max(step, current) + row_index = row_index + 1 + } + master = master + factor * step + master_coordinates.push(master) + point = point + 1 + } + let projected : Array[CoordinatePairwiseAlignment] = [] + row_index = 0 + while row_index < mappings.length() { + let scaled_row : Array[Int] = [] + for coordinate in self.coordinates[row_index] { + scaled_row.push(factor * coordinate) + } + let outer = alignment_map_create( + "alignment", + "", + master, + self.names[row_index], + "", + factor * self.sequences[row_index].length(), + master_coordinates, + scaled_row, + ) + let scaled_target : Array[Int] = [] + for coordinate in mappings[row_index].target_coordinates { + scaled_target.push(factor * coordinate) + } + let inner = alignment_map_create( + mappings[row_index].target_name, + "", + factor * mappings[row_index].target_length, + mappings[row_index].query_name, + mappings[row_index].query_sequence, + mappings[row_index].query_length, + scaled_target, + mappings[row_index].query_coordinates, + ) + projected.push(outer.map(inner)) + row_index = row_index + 1 + } + let output_coordinates : Array[Array[Int]] = [] + let indices = Array::make(projected.length(), 0) + row_index = 0 + while row_index < projected.length() { + output_coordinates.push([]) + row_index = row_index + 1 + } + let mut previous = 0 + while true { + let mut found = false + let mut position = 2147483647 + row_index = 0 + while row_index < projected.length() { + let index = indices[row_index] + if index < projected[row_index].target_coordinates.length() { + position = alignment_map_min( + position, + projected[row_index].target_coordinates[index], + ) + found = true + } + row_index = row_index + 1 + } + if !found { + break + } + row_index = 0 + while row_index < projected.length() { + let index = indices[row_index] + let output = output_coordinates[row_index] + if index >= projected[row_index].target_coordinates.length() { + output.push( + if output.length() == 0 { + 0 + } else { + output[output.length() - 1] + }, + ) + } else { + let current_target = projected[row_index].target_coordinates[index] + let current_query = projected[row_index].query_coordinates[index] + if current_target == position { + output.push(current_query) + indices[row_index] = index + 1 + } else if current_target > position { + if output.length() == 0 { + output.push(current_query) + } else { + let last = output[output.length() - 1] + let step = if current_query > last { + position - previous + } else { + 0 + } + output.push(last + step) + } + } else { + raise AlignmentMapError("mapall coordinate merge became inconsistent") + } + } + row_index = row_index + 1 + } + previous = position + } + let names : Array[String] = [] + let sequences : Array[String] = [] + for alignment in projected { + names.push(alignment.query_name) + sequences.push(alignment.query_sequence) + } + CoordinateMultipleAlignment::{ + names, + sequences, + coordinates: output_coordinates, + } +} + +///| +pub fn CoordinateMultipleAlignment::num_sequences( + self : CoordinateMultipleAlignment, +) -> Int { + self.sequences.length() +} + +///| +pub fn CoordinateMultipleAlignment::alignment_length( + self : CoordinateMultipleAlignment, +) -> Int { + if self.coordinates.length() == 0 || self.coordinates[0].length() < 2 { + return 0 + } + let mut length = 0 + let mut point = 0 + while point + 1 < self.coordinates[0].length() { + let mut step = 0 + for row in self.coordinates { + step = alignment_map_max( + step, + alignment_map_abs(row[point + 1] - row[point]), + ) + } + length = length + step + point = point + 1 + } + length +} + +///| +pub fn CoordinateMultipleAlignment::row( + self : CoordinateMultipleAlignment, + index : Int, + complement_reverse? : Bool = true, +) -> String? { + if index < 0 || + index >= self.sequences.length() || + self.coordinates.length() == 0 { + return None + } + let sequence = self.sequences[index] + if sequence.length() == 0 { + return None + } + let builder = StringBuilder::new() + let mut point = 0 + while point + 1 < self.coordinates[index].length() { + let start = self.coordinates[index][point] + let end = self.coordinates[index][point + 1] + let row_step = alignment_map_abs(end - start) + let mut width = 0 + for row_coordinates in self.coordinates { + width = alignment_map_max( + width, + alignment_map_abs(row_coordinates[point + 1] - row_coordinates[point]), + ) + } + if row_step == 0 { + alignment_map_repeat(builder, '-', width) + } else { + alignment_map_write_segment( + builder, sequence, start, end, complement_reverse, + ) + alignment_map_repeat(builder, '-', width - row_step) + } + point = point + 1 + } + Some(builder.to_string()) +} + +///| +pub fn CoordinateMultipleAlignment::to_fasta( + self : CoordinateMultipleAlignment, +) -> String { + let builder = StringBuilder::new() + let mut index = 0 + while index < self.names.length() { + builder.write_char('>') + builder.write_string(self.names[index]) + builder.write_char('\n') + match self.row(index) { + Some(row) => builder.write_string(row) + None => () + } + builder.write_char('\n') + index = index + 1 + } + builder.to_string() +} + +///| +pub fn CoordinateMultipleAlignment::summary( + self : CoordinateMultipleAlignment, +) -> String { + "CoordinateMultipleAlignment(rows=" + + self.num_sequences().to_string() + + ", columns=" + + self.alignment_length().to_string() + + ")" +} + +///| +/// Small chromosome/transcript/read example from the Biopython tutorial. +pub fn alignment_map_example() -> CoordinatePairwiseAlignment raise AlignmentMapError { + let chromosome = coordinate_pairwise_alignment( + "chromosome", + "AAAAAAAACCCCCCCAAAAAAAAAAAGGGGGGAAAAAAAA", + "transcript", + "CCCCCCCGGGGGG", + [8, 15, 26, 32], + [0, 7, 7, 13], + ) + let read = coordinate_pairwise_alignment( + "transcript", + "CCCCCCCGGGGGG", + "read", + "CCCCGGGG", + [3, 11], + [0, 8], + ) + chromosome.map(read) +} diff --git a/test/moonbit/alignment_map_test.mbt b/test/moonbit/alignment_map_test.mbt new file mode 100644 index 00000000..9e5d2bb0 --- /dev/null +++ b/test/moonbit/alignment_map_test.mbt @@ -0,0 +1,856 @@ +///| +fn alignment_map_pair( + target : String, + query : String, + target_coordinates : Array[Int], + query_coordinates : Array[Int], +) -> @src.CoordinatePairwiseAlignment { + @src.coordinate_pairwise_alignment( + "target", target, "query", query, target_coordinates, query_coordinates, + ) catch { + _ => abort("valid coordinate alignment should build") + } +} + +///| +fn alignment_map_tutorial_outer() -> @src.CoordinatePairwiseAlignment { + @src.coordinate_pairwise_alignment( + "chromosome", + "AAAAAAAACCCCCCCAAAAAAAAAAAGGGGGGAAAAAAAA", + "transcript", + "CCCCCCCGGGGGG", + [8, 15, 26, 32], + [0, 7, 7, 13], + ) catch { + _ => abort("valid tutorial outer alignment should build") + } +} + +///| +fn alignment_map_tutorial_read() -> @src.CoordinatePairwiseAlignment { + @src.coordinate_pairwise_alignment( + "transcript", + "CCCCCCCGGGGGG", + "read", + "CCCCGGGG", + [3, 11], + [0, 8], + ) catch { + _ => abort("valid tutorial read alignment should build") + } +} + +///| +test "alignment map: official chromosome transcript read coordinates" { + let mapped = alignment_map_tutorial_outer().map(alignment_map_tutorial_read()) catch { + _ => abort("official map should succeed") + } + assert_eq(mapped.target_coordinates, [11, 15, 26, 30]) + assert_eq(mapped.query_coordinates, [0, 4, 4, 8]) + assert_eq(mapped.target_name, "chromosome") + assert_eq(mapped.query_name, "read") +} + +///| +test "alignment map: official example renders exon gap" { + let mapped = @src.alignment_map_example() catch { + _ => abort("example should map") + } + match mapped.aligned_rows() { + Some((target, query)) => { + assert_eq(target, "CCCCAAAAAAAAAAAGGGG") + assert_eq(query, "CCCC-----------GGGG") + } + None => abort("concrete sequences should render") + } +} + +///| +test "alignment map: official example PSL" { + let mapped = @src.alignment_map_example() catch { + _ => abort("example should map") + } + let psl = mapped.to_psl() catch { + _ => abort("non-empty map should serialize") + } + assert_eq( + psl, "8\t0\t0\t0\t0\t0\t1\t11\t+\tread\t8\t0\t8\tchromosome\t40\t11\t30\t2\t4,4,\t0,4,\t11,26,\n", + ) +} + +///| +test "alignment map: internal overlap" { + let outer = @src.coordinate_pairwise_alignment( + "chromosome", + "AAAAAAAAAAAAGGGGGGGCCCCCGGGGGGAAAAAAAAAA", + "transcript", + "GGGGGGGCCCCCGGGGGGA", + [12, 31], + [0, 19], + ) catch { + _ => abort("outer should build") + } + let inner = @src.coordinate_pairwise_alignment( + "transcript", + "GGGGGGGCCCCCGGGGGGA", + "sequence", + "GGCCCCCGGG", + [5, 15], + [0, 10], + ) catch { + _ => abort("inner should build") + } + let mapped = outer.map(inner) catch { + _ => abort("internal map should succeed") + } + assert_eq(mapped.target_coordinates, [17, 27]) + assert_eq(mapped.query_coordinates, [0, 10]) +} + +///| +test "alignment map: clips left overhang" { + let outer = @src.coordinate_pairwise_alignment( + "chromosome", + "GGGCCCCCGGGGGGAAAAAAAAAA", + "transcript", + "AGGGGGCCCCCGGGGGGA", + [0, 15], + [3, 18], + ) catch { + _ => abort("outer should build") + } + let inner = @src.coordinate_pairwise_alignment( + "transcript", + "AGGGGGCCCCCGGGGGGA", + "sequence", + "GGGGGCCCCCGGG", + [1, 14], + [0, 13], + ) catch { + _ => abort("inner should build") + } + let mapped = outer.map(inner) catch { _ => abort("left clipping should map") } + assert_eq(mapped.target_coordinates, [0, 11]) + assert_eq(mapped.query_coordinates, [2, 13]) +} + +///| +test "alignment map: clips right overhang" { + let outer = @src.coordinate_pairwise_alignment( + "chromosome", + "AAAAAAAAAAAAGGGGGGGCCCCCGGG", + "transcript", + "GGGGGGGCCCCCGGGGGGA", + [12, 27], + [0, 15], + ) catch { + _ => abort("outer should build") + } + let inner = @src.coordinate_pairwise_alignment( + "transcript", + "GGGGGGGCCCCCGGGGGGA", + "sequence", + "GGCCCCCGGGGG", + [5, 17], + [0, 12], + ) catch { + _ => abort("inner should build") + } + let mapped = outer.map(inner) catch { + _ => abort("right clipping should map") + } + assert_eq(mapped.target_coordinates, [17, 27]) + assert_eq(mapped.query_coordinates, [0, 10]) +} + +///| +test "alignment map: reverse middle and reverse query yield forward result" { + let outer = @src.coordinate_pairwise_alignment( + "chromosome", + "AAAAAAAAAAAAGGGGGGGCCCCCGGGGGGAAAAAAAAAA", + "transcript", + "TCCCCCCGGGGGCCCCCCC", + [12, 31], + [19, 0], + ) catch { + _ => abort("reverse outer should build") + } + let inner = @src.coordinate_pairwise_alignment( + "transcript", + "TCCCCCCGGGGGCCCCCCC", + "sequence", + "GGCCCCCGGG", + [4, 14], + [10, 0], + ) catch { + _ => abort("reverse inner should build") + } + let mapped = outer.map(inner) catch { + _ => abort("double reverse should map") + } + assert_eq(mapped.target_coordinates, [17, 27]) + assert_eq(mapped.query_coordinates, [0, 10]) + assert_false(mapped.is_reverse()) +} + +///| +test "alignment map: reverse final query is preserved" { + let outer = @src.coordinate_pairwise_alignment( + "chromosome", + "AAAAAAAAAAAAGGGGGGGCCCCCGGGGGGAAAAAAAAAA", + "transcript", + "GGGGGGGCCCCCGGGGGGA", + [12, 31], + [0, 19], + ) catch { + _ => abort("outer should build") + } + let inner = @src.coordinate_pairwise_alignment( + "transcript", + "GGGGGGGCCCCCGGGGGGA", + "sequence", + "CCCGGGGGCC", + [5, 15], + [10, 0], + ) catch { + _ => abort("reverse sequence should build") + } + let mapped = outer.map(inner) catch { _ => abort("reverse query should map") } + assert_eq(mapped.target_coordinates, [17, 27]) + assert_eq(mapped.query_coordinates, [10, 0]) + assert_true(mapped.is_reverse()) +} + +///| +test "alignment map: reverse middle flips forward query" { + let outer = @src.coordinate_pairwise_alignment( + "chromosome", + "AAAAAAAAAAAAGGGGGGGCCCCCGGGGGGAAAAAAAAAA", + "transcript", + "TCCCCCCGGGGGCCCCCCC", + [12, 31], + [19, 0], + ) catch { + _ => abort("reverse outer should build") + } + let inner = @src.coordinate_pairwise_alignment( + "transcript", + "TCCCCCCGGGGGCCCCCCC", + "sequence", + "CCCGGGGGCC", + [4, 14], + [0, 10], + ) catch { + _ => abort("inner should build") + } + let mapped = outer.map(inner) catch { + _ => abort("reverse middle should map") + } + assert_eq(mapped.target_coordinates, [17, 27]) + assert_eq(mapped.query_coordinates, [10, 0]) +} + +///| +test "alignment map: coordinate blocks and counts" { + let mapped = @src.alignment_map_example() catch { + _ => abort("example should map") + } + let blocks = mapped.blocks() + assert_eq(blocks.length(), 2) + assert_eq(blocks[0].target_start, 11) + assert_eq(blocks[0].query_start, 0) + assert_eq(blocks[1].target_start, 26) + let counts = mapped.counts() + assert_eq(counts.aligned, 8) + assert_eq(counts.query_gap_events, 1) + assert_eq(counts.query_gap_bases, 11) + assert_eq(counts.target_gap_events, 0) +} + +///| +test "alignment map: target to query coordinate lookup" { + let mapped = @src.alignment_map_example() catch { + _ => abort("example should map") + } + assert_eq(mapped.target_to_query(11), Some(0)) + assert_eq(mapped.target_to_query(14), Some(3)) + assert_eq(mapped.target_to_query(20), None) + assert_eq(mapped.target_to_query(29), Some(7)) +} + +///| +test "alignment map: query to target coordinate lookup" { + let mapped = @src.alignment_map_example() catch { + _ => abort("example should map") + } + assert_eq(mapped.query_to_target(0), Some(11)) + assert_eq(mapped.query_to_target(3), Some(14)) + assert_eq(mapped.query_to_target(4), Some(26)) + assert_eq(mapped.query_to_target(7), Some(29)) +} + +///| +test "alignment map: reverse coordinate lookup" { + let alignment = alignment_map_pair("AACCGGTT", "AACCGGTT", [1, 5], [7, 3]) + assert_eq(alignment.target_to_query(1), Some(6)) + assert_eq(alignment.target_to_query(4), Some(3)) + assert_eq(alignment.query_to_target(6), Some(1)) + assert_eq(alignment.query_to_target(3), Some(4)) +} + +///| +test "alignment map: reverse rows use reverse complement" { + let alignment = alignment_map_pair("AAAAAA", "AAGC", [1, 5], [4, 0]) + match alignment.aligned_rows() { + Some((target, query)) => { + assert_eq(target, "AAAA") + assert_eq(query, "GCTT") + } + None => abort("rows should render") + } +} + +///| +test "alignment map: reverse PSL strand and query starts" { + let alignment = alignment_map_pair("AAAAAA", "AAGC", [1, 5], [4, 0]) + let psl = alignment.to_psl() catch { + _ => abort("reverse alignment should serialize") + } + assert_true(psl.contains("\t-\tquery\t4\t0\t4\ttarget\t6\t1\t5\t")) + assert_true(psl.has_suffix("\t4,\t0,\t1,\n")) +} + +///| +test "alignment map: summary reports direction" { + let alignment = alignment_map_pair("AAAAAA", "AAGC", [1, 5], [4, 0]) + assert_eq( + alignment.summary(), + "CoordinatePairwiseAlignment(target <- query, blocks=1, aligned=4, strand=-)", + ) +} + +///| +test "alignment map: undefined sequence contents still map" { + let outer = @src.coordinate_pairwise_alignment_with_lengths( + "genome", + 100, + "transcript", + 20, + [10, 20, 30, 40], + [0, 10, 10, 20], + ) catch { + _ => abort("undefined outer should build") + } + let inner = @src.coordinate_pairwise_alignment_with_lengths( + "transcript", + 20, + "read", + 8, + [6, 14], + [0, 8], + ) catch { + _ => abort("undefined inner should build") + } + let mapped = outer.map(inner) catch { + _ => abort("undefined alignments should map") + } + assert_eq(mapped.target_coordinates, [16, 20, 30, 34]) + assert_eq(mapped.aligned_rows(), None) +} + +///| +test "alignment map: map many preserves order" { + let outer = alignment_map_tutorial_outer() + let first = alignment_map_tutorial_read() + let second = @src.coordinate_pairwise_alignment( + "transcript", + "CCCCCCCGGGGGG", + "other", + "CCGG", + [5, 9], + [0, 4], + ) catch { + _ => abort("second read should build") + } + let mapped = outer.map_many([first, second]) catch { + _ => abort("map many should succeed") + } + assert_eq(mapped.length(), 2) + assert_eq(mapped[0].query_name, "read") + assert_eq(mapped[1].query_name, "other") +} + +///| +test "alignment map: no coordinate overlap returns empty" { + let outer = alignment_map_pair("AAAAAAAAAA", "CCCCCCCCCC", [0, 4], [0, 4]) + let inner = alignment_map_pair("CCCCCCCCCC", "GG", [7, 9], [0, 2]) + let mapped = outer.map(inner) catch { + _ => abort("disjoint paths should return an empty map") + } + assert_true(mapped.is_empty()) + assert_eq(mapped.blocks().length(), 0) +} + +///| +test "alignment map: empty input remains empty" { + let outer = @src.coordinate_pairwise_alignment_with_lengths( + "outer", + 10, + "middle", + 10, + [], + [], + ) catch { + _ => abort("empty coordinate map should build") + } + let inner = alignment_map_pair("AAAAAAAAAA", "AA", [0, 2], [0, 2]) + let mapped = outer.map(inner) catch { _ => abort("empty map should compose") } + assert_true(mapped.is_empty()) +} + +///| +test "alignment map: constructor copies coordinate arrays" { + let target_coordinates = [0, 4] + let query_coordinates = [0, 4] + let alignment = alignment_map_pair( + "AAAA", "AAAA", target_coordinates, query_coordinates, + ) + target_coordinates[1] = 2 + query_coordinates[1] = 3 + assert_eq(alignment.target_coordinates, [0, 4]) + assert_eq(alignment.query_coordinates, [0, 4]) +} + +///| +test "alignment map: adapts existing PairwiseAlignment" { + let pairwise = @src.pairaligner_align("AACCGG", "ACG") + let alignment = @src.coordinate_alignment_from_pairwise( + pairwise, + target_name="reference", + query_name="read", + ) catch { + _ => abort("pairwise adapter should succeed") + } + assert_eq( + alignment.target_coordinates.length(), + pairwise.aligned_target.length() + 1, + ) + assert_eq(alignment.target_coordinates[0], pairwise.target_start) + assert_eq( + alignment.target_coordinates[alignment.target_coordinates.length() - 1], + pairwise.target_end, + ) + assert_eq(alignment.target_name, "reference") +} + +///| +test "alignment map: pairwise adapter preserves rendered gaps" { + let pairwise = @src.pairaligner_align("AACCGG", "ACG") + let alignment = @src.coordinate_alignment_from_pairwise(pairwise) catch { + _ => abort("pairwise adapter should succeed") + } + match alignment.aligned_rows() { + Some((target, query)) => { + assert_eq(target, pairwise.aligned_target) + assert_eq(query, pairwise.aligned_query) + } + None => abort("adapted concrete rows should render") + } +} + +///| +test "alignment map: rejects empty name" { + let failed = try { + ignore( + @src.coordinate_pairwise_alignment("", "AAAA", "query", "AAAA", [0, 4], [ + 0, 4, + ]), + ) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} + +///| +test "alignment map: rejects gapped raw sequence" { + let failed = try { + ignore( + @src.coordinate_pairwise_alignment( + "target", + "AA-A", + "query", + "AAAA", + [0, 4], + [0, 4], + ), + ) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} + +///| +test "alignment map: rejects unequal coordinate arrays" { + let failed = try { + ignore( + @src.coordinate_pairwise_alignment( + "target", + "AAAA", + "query", + "AAAA", + [0, 4], + [0], + ), + ) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} + +///| +test "alignment map: rejects one-point path" { + let failed = try { + ignore( + @src.coordinate_pairwise_alignment( + "target", + "AAAA", + "query", + "AAAA", + [0], + [0], + ), + ) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} + +///| +test "alignment map: rejects coordinate out of bounds" { + let failed = try { + ignore( + @src.coordinate_pairwise_alignment( + "target", + "AAAA", + "query", + "AAAA", + [0, 5], + [0, 4], + ), + ) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} + +///| +test "alignment map: rejects decreasing target coordinates" { + let failed = try { + ignore( + @src.coordinate_pairwise_alignment( + "target", + "AAAA", + "query", + "AAAA", + [4, 0], + [4, 0], + ), + ) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} + +///| +test "alignment map: rejects query direction changes" { + let failed = try { + ignore( + @src.coordinate_pairwise_alignment( + "target", + "AAAA", + "query", + "AAAA", + [0, 2, 4], + [0, 2, 1], + ), + ) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} + +///| +test "alignment map: rejects repeated coordinate point" { + let failed = try { + ignore( + @src.coordinate_pairwise_alignment( + "target", + "AAAA", + "query", + "AAAA", + [0, 0], + [0, 0], + ), + ) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} + +///| +test "alignment map: rejects incompatible middle lengths" { + let outer = alignment_map_pair("AAAAAAAA", "CCCC", [0, 4], [0, 4]) + let inner = alignment_map_pair("CCCCCC", "GG", [0, 2], [0, 2]) + let failed = try { + ignore(outer.map(inner)) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} + +///| +test "alignment map: rejects unequal aligned steps" { + let outer = alignment_map_pair("AAAAAAAA", "CCCC", [0, 4], [0, 2]) + let inner = alignment_map_pair("CCCC", "GGGG", [0, 4], [0, 4]) + let failed = try { + ignore(outer.map(inner)) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} + +///| +test "alignment map: empty alignment cannot serialize PSL" { + let empty = @src.coordinate_pairwise_alignment_with_lengths( + "target", + 4, + "query", + 4, + [], + [], + ) catch { + _ => abort("empty alignment should build") + } + let failed = try { + ignore(empty.to_psl()) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} + +///| +test "alignment mapall: builds coordinate MSA from gapped rows" { + let alignment = @src.coordinate_multiple_alignment(["p1", "p2"], [ + "M-K", "MTK", + ]) catch { + _ => abort("valid MSA should build") + } + assert_eq(alignment.sequences, ["MK", "MTK"]) + assert_eq(alignment.coordinates[0], [0, 1, 1, 2]) + assert_eq(alignment.coordinates[1], [0, 1, 2, 3]) + assert_eq(alignment.alignment_length(), 3) +} + +///| +test "alignment mapall: protein MSA projects to codon MSA" { + let alignment = @src.coordinate_multiple_alignment(["p1", "p2"], [ + "M-K", "MTK", + ]) catch { + _ => abort("valid protein MSA should build") + } + let first = @src.coordinate_pairwise_alignment( + "p1", + "MK", + "dna1", + "ATGAAA", + [0, 2], + [0, 6], + ) catch { + _ => abort("valid codon mapping should build") + } + let second = @src.coordinate_pairwise_alignment( + "p2", + "MTK", + "dna2", + "ATGACCAAA", + [0, 3], + [0, 9], + ) catch { + _ => abort("valid codon mapping should build") + } + let mapped = alignment.mapall([first, second]) catch { + _ => abort("codon mapall should succeed") + } + assert_eq(mapped.num_sequences(), 2) + assert_eq(mapped.alignment_length(), 9) + assert_eq(mapped.row(0), Some("ATG---AAA")) + assert_eq(mapped.row(1), Some("ATGACCAAA")) +} + +///| +test "alignment mapall: nucleotide one-to-one projection" { + let alignment = @src.coordinate_multiple_alignment(["r1", "r2"], [ + "AC-G", "ACTG", + ]) catch { + _ => abort("valid nucleotide MSA should build") + } + let first = alignment_map_pair("ACG", "ACG", [0, 3], [0, 3]) + let second = alignment_map_pair("ACTG", "ACTG", [0, 4], [0, 4]) + let mapped = alignment.mapall([first, second]) catch { + _ => abort("one-to-one mapall should succeed") + } + assert_eq(mapped.row(0), Some("AC-G")) + assert_eq(mapped.row(1), Some("ACTG")) +} + +///| +test "alignment mapall: FASTA serialization" { + let alignment = @src.coordinate_multiple_alignment(["p1", "p2"], [ + "M-K", "MTK", + ]) catch { + _ => abort("valid MSA should build") + } + assert_eq(alignment.to_fasta(), ">p1\nM-K\n>p2\nMTK\n") + assert_eq( + alignment.summary(), + "CoordinateMultipleAlignment(rows=2, columns=3)", + ) +} + +///| +test "alignment mapall: rejects unequal MSA row width" { + let failed = try { + ignore(@src.coordinate_multiple_alignment(["p1", "p2"], ["MK", "M-K"])) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} + +///| +test "alignment mapall: rejects missing mapping" { + let alignment = @src.coordinate_multiple_alignment(["p1", "p2"], [ + "M-K", "MTK", + ]) catch { + _ => abort("valid MSA should build") + } + let first = @src.coordinate_pairwise_alignment( + "p1", + "MK", + "dna1", + "ATGAAA", + [0, 2], + [0, 6], + ) catch { + _ => abort("valid mapping should build") + } + let failed = try { + ignore(alignment.mapall([first])) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} + +///| +test "alignment mapall: rejects mapping target length mismatch" { + let alignment = @src.coordinate_multiple_alignment(["p1"], ["MK"]) catch { + _ => abort("valid MSA should build") + } + let mapping = @src.coordinate_pairwise_alignment( + "p1", + "MKK", + "dna1", + "ATGAAAAAA", + [0, 3], + [0, 9], + ) catch { + _ => abort("valid mapping should build") + } + let failed = try { + ignore(alignment.mapall([mapping])) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} + +///| +test "alignment mapall: rejects inconsistent factors" { + let alignment = @src.coordinate_multiple_alignment(["p1", "p2"], ["MK", "MK"]) catch { + _ => abort("valid MSA should build") + } + let nucleotide = alignment_map_pair("MK", "MK", [0, 2], [0, 2]) + let codon = @src.coordinate_pairwise_alignment( + "p2", + "MK", + "dna2", + "ATGAAA", + [0, 2], + [0, 6], + ) catch { + _ => abort("valid codon mapping should build") + } + let failed = try { + ignore(alignment.mapall([nucleotide, codon])) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} + +///| +test "alignment mapall: rejects unsupported two-to-one factor" { + let alignment = @src.coordinate_multiple_alignment(["p1"], ["MK"]) catch { + _ => abort("valid MSA should build") + } + let mapping = alignment_map_pair("MK", "ACGT", [0, 2], [0, 4]) + let failed = try { + ignore(alignment.mapall([mapping])) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} + +///| +test "alignment mapall: rejects mapping without aligned block" { + let alignment = @src.coordinate_multiple_alignment(["p1"], ["MK"]) catch { + _ => abort("valid MSA should build") + } + let mapping = alignment_map_pair("MK", "AA", [0, 2, 2], [0, 0, 2]) + let failed = try { + ignore(alignment.mapall([mapping])) + false + } catch { + AlignmentMapError(_) => true + } + assert_true(failed) +} From 8b48413eeab717e3535a4c2b88021fecc4027b22 Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 00:57:09 +0800 Subject: [PATCH 17/41] #28 feat(zinbwave): ZINB-WaVE --- README.md | 24 +- examples/zinbwave_demo/main.mbt | 95 ++ examples/zinbwave_demo/moon.pkg | 5 + src/zinbwave.mbt | 1597 +++++++++++++++++++++++++++++++ test/moonbit/zinbwave_test.mbt | 836 ++++++++++++++++ 5 files changed, 2553 insertions(+), 4 deletions(-) create mode 100644 examples/zinbwave_demo/main.mbt create mode 100644 examples/zinbwave_demo/moon.pkg create mode 100644 src/zinbwave.mbt create mode 100644 test/moonbit/zinbwave_test.mbt diff --git a/README.md b/README.md index c6618e0c..f66a4764 100644 --- a/README.md +++ b/README.md @@ -217,6 +217,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **HH-suite HHR** | Biopython `Bio.Align.hhr` | HHR元数据、命中摘要、多块profile比对、consensus/二级结构/DSSP/confidence注释、概率和E-value查询 | ✅ | | **共享参考比对合并** | Biopython `Bio.Align.Alignment.from_alignments_with_same_reference` | 混合PWA/MSA输入、首端/内部/末端insertion同步、多query投影、局部坐标与metadata保留、统计和格式转换 | ✅ | | **Alignment坐标组合** | Biopython `Bio.Align.Alignment.map/mapall` | alignment path组合、局部overhang clipping、exon/intron与indel gap、正反链组合、坐标双向查询、PSL及1:1/1:3 MSA投影 | ✅ | +| **zinbwave** | Bioconductor zinbwave | 零膨胀负二项低维模型、cell/gene协变量与offset、确定性latent factors、dispersion shrinkage、observational weights、残差/归一化/插补及SCE集成 | ✅ | | **Prosite** | Biopython `Bio.Prosite` | 蛋白质模体数据库搜索、Prosite模式解析、模体匹配算法、模体得分计算 | ✅ | | **PAML** | Biopython `Bio.PAML` | 分子进化分析、dN/dS计算（Nei-Gojobori方法）、Jukes-Cantor校正、密码子使用分析 | ✅ | | **Graphics** | Biopython `Bio.Graphics` | 生物信息学可视化、序列Logo绘制、序列比对可视化、基因组特征绘图 | ✅ | @@ -549,6 +550,7 @@ IvanAXu/BioSeqs/ │ ├── scrapper.mbt # scrapper 单细胞预处理 (批次感知RNA QC、大小因子、LOWESS/HVG、pseudo-bulk、SCE集成) │ ├── decontx.mbt # decontX ambient RNA去污染 (Bayesian EM、background、自动聚类、计数分解、SCE集成) │ ├── milo.mbt # miloR KNN邻域差异丰度 (精炼采样、NB-GLM、graph spatial FDR、SCE接入) +│ ├── zinbwave.mbt # zinbwave 零膨胀NB低维模型 (EM/IRLS、latent factors、observational weights、SCE接入) │ ├── variance_partition.mbt # variancePartition 混合模型方差分解、BLUP与dream重复测量检验 │ ├── monocle3.mbt # monocle3 单细胞轨迹分析 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read.mbt # ShortRead 短读序列质量控制 (QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告) @@ -896,6 +898,7 @@ IvanAXu/BioSeqs/ │ ├── scrapper_demo/ # scrapper 批次感知RNA QC、归一化、LOWESS/HVG、pseudo-bulk与SCE集成示例 │ ├── decontx_demo/ # decontX cluster/background去污染、marker校正、诊断与SCE输出示例 │ ├── milo_demo/ # miloR KNN图、精炼邻域、NB差异丰度、spatial FDR与SCE接入示例 +│ ├── zinbwave_demo/ # zinbwave latent factors、dropout权重、残差/插补与SCE集成示例 │ ├── variance_partition_demo/ # variancePartition 方差分解、BLUP、precision weights、dream与SE接入示例 │ ├── monocle3_demo/ # monocle3 单细胞轨迹分析示例 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read_demo/ # ShortRead 短读序列质量控制示例 (QA统计、adapter修剪、质量修剪、FastQC报告) @@ -1298,6 +1301,7 @@ IvanAXu/BioSeqs/ │ │ ├── scrapper_test.mbt │ │ ├── decontx_test.mbt │ │ ├── milo_test.mbt +│ │ ├── zinbwave_test.mbt │ │ ├── variance_partition_test.mbt │ │ ├── shared_reference_alignment_test.mbt │ │ ├── alignment_map_test.mbt @@ -1477,7 +1481,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8721 个测试全部通过 +moon test # ✅ 8775 个测试全部通过 ``` ### 模块对照表 @@ -1786,6 +1790,7 @@ moon test # ✅ 8721 个测试全 | `scrapper.mbt` | `scrapper` | 批次感知RNA QC、大小因子清洗/居中、count与log归一化、LOWESS方差趋势、HVG选择、多因子pseudo-bulk、SingleCellExperiment不可变包装 | | `decontx.mbt` | `decontX` | 每细胞native/contaminant Bayesian mixture、确定性EM、empty-droplet ambient profile、自动k-means、诊断与SingleCellExperiment不可变包装 | | `milo.mbt` | `miloR` | 精确KNN图、median精炼重叠邻域、邻域计数/表达、固定效应NB-GLM/Wald检验、graph spatial FDR与SCE接入 | +| `zinbwave.mbt` | `zinbwave` | ZINB交替EM/IRLS、cell/gene design与offset、确定性低维因子、gene dispersion shrinkage、observational weights、deviance residual及SingleCellExperiment包装 | | `variance_partition.mbt` | `variancePartition` | typed fixed/random design、多随机截距LMM、ML/REML方差分解、BLUP、weighted dream contrast、Satterthwaite自由度与SummarizedExperiment入口 | | `shared_reference_alignment.mbt` | `Bio.Align.Alignment` | 同参考PWA/MSA的reference-boundary insertion同步、原query投影、局部坐标、metadata、统计与格式转换 | | `alignment_map.mbt` | `Bio.Align.Alignment.map/mapall` | 两层alignment坐标组合、正反链与gap传播、PSL、批量映射及protein/nucleotide MSA投影 | @@ -2883,6 +2888,14 @@ observation-level precision weights 会先缩放到均值 1，并进入 `V = Σ `CoordinateMultipleAlignment.mapall` 将 MSA 每行通过对应 pairwise mapping 投影到统一列空间，支持 nucleotide 1:1 和 protein:nucleotide 1:3 两类一致比例，因此可将 protein MSA 转换为 codon-aware nucleotide MSA，并保留氨基酸 gap 对应的三碱基 gap。构造器会验证名称、序列、坐标边界、单调方向、step size、共享序列长度和跨行映射比例；当前不负责生成原始 pairwise alignment，也不支持混合比例、frameshift 或非整数缩放。 +### 252. 零膨胀负二项低维表示 (Bioconductor zinbwave) + +实现 Bioconductor `zinbwave` 的可移植 ZINB-WaVE 核心，输入统一为 gene × cell 非负整数计数矩阵。均值子模型使用 log link，零膨胀子模型使用 logit link，两者共享已知 cell-level design、gene-level design、显式 mean/zero offset 和未知 cell latent factors；每个基因单独估计 inverse-dispersion 对应的 dispersion。latent factors 从 library-offset corrected `log(count + 1)` 的 cell Gram matrix确定性初始化，随后与 NB mean、zero-inflation 和 gene/cell effects 交替更新，并在每轮中心化和 RMS 缩放以控制可识别性。 + +E-step 对零计数计算来自 NB component 的后验 responsibility，正计数 responsibility 固定为 1；M-step 分别使用 log-link NB IRLS、logistic IRLS 和带 ridge 的线性求解更新参数。gene dispersion 使用加权矩估计并向跨基因 median 收缩，最终结果提供完整 ZINB log-likelihood 轨迹、AIC/BIC、fitted means、structural-zero probabilities、下游差异分析 observational weights、NB deviance residuals、library-normalized values、零值后验插补和逐基因诊断。 + +`zinbwave_sce` 从指定 `SingleCellExperiment` assay 拟合模型，在不可变副本中加入 `zinbwave_weights`、`zinbwave_residuals`、`zinbwave_normalized`、`zinbwave_imputed` assays、低维表示和模型 metadata，不修改输入对象。构造器会诊断 ragged/负数/非整数/非有限计数、空 cell library、design/offset 维度和标识符问题。当前实现使用 dense MoonBit arrays 和确定性交替求解，不包含上游 R 包的并行后端、稀疏矩阵专用优化、epsilon penalty 路径或绘图接口。 + ## 性能优化 ### 优化策略 @@ -2984,8 +2997,8 @@ observation-level precision weights 会先缩放到均值 1，并进入 `V = Σ | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8721 | -| 通过数 | 8721 | +| 总测试数 | 8775 | +| 通过数 | 8775 | | 失败数 | 0 | | 通过率 | 100% | @@ -3111,6 +3124,7 @@ moon test --update | scrapper | `scrapper_test.mbt` | 35 | | decontX | `decontx_test.mbt` | 43 | | miloR | `milo_test.mbt` | 37 | +| zinbwave | `zinbwave_test.mbt` | 54 | | monocle3 | `monocle3_test.mbt` | 10 | | ShortRead | `short_read_test.mbt` | 15 | | scater | `scater_test.mbt` | 17 | @@ -3385,7 +3399,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 359 个示例程序，展示各模块的典型用法： +项目提供 360 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3478,6 +3492,7 @@ moon run cmd/bench/main.mbt | scrapper_demo | 批次感知RNA QC、大小因子归一化、LOWESS/HVG、多因子pseudo-bulk和不可变SCE集成 | `moon run examples/scrapper_demo` | | decontx_demo | cluster/background ambient RNA去污染、每细胞污染率、marker校正、cluster诊断和不可变SCE输出 | `moon run examples/decontx_demo` | | milo_demo | 精确KNN图、精炼重叠邻域、样本计数、NB-GLM差异丰度、graph spatial FDR和SCE接入 | `moon run examples/milo_demo` | +| zinbwave_demo | ZINB latent-factor拟合、dropout后验权重、归一化/插补/deviance residual和不可变SCE输出 | `moon run examples/zinbwave_demo` | | mast_demo | MAST 单细胞差异表达分析（Hurdle模型、离散/连续检验、BH-FDR校正、结果汇总） | `moon run examples/mast_demo/main.mbt` | | genomic_files_demo | GenomicFiles 分布式基因组文件处理（BAM/BED/VCF扫描、区间查询、归约、覆盖度计算） | `moon run examples/genomic_files_demo/main.mbt` | | diffbind_demo | DiffBind ChIP-seq差异结合分析（峰值重叠、共识峰识别、TMM归一化、负二项分布检验） | `moon run examples/diffbind_demo/main.mbt` | @@ -3681,6 +3696,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bio.Align共享参考序列比对合并（混合PWA/MSA、reference-boundary insertion同步、局部坐标、双向映射、统计与格式转换） - ✅ 实现 Bio.Align.Alignment map/mapall（alignment path组合、local clipping、gap与正反链传播、坐标查询、PSL及protein-to-codon MSA投影） - ✅ 实现 Bioconductor decontX ambient RNA去污染（cluster-native/contaminant混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解与SCE集成） +- ✅ 实现 Bioconductor zinbwave 零膨胀负二项低维模型（cell/gene协变量、offset、latent factors、dispersion shrinkage、observational weights、残差/插补与SCE集成） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/zinbwave_demo/main.mbt b/examples/zinbwave_demo/main.mbt new file mode 100644 index 00000000..1e04a6c1 --- /dev/null +++ b/examples/zinbwave_demo/main.mbt @@ -0,0 +1,95 @@ +///| +fn main { + println("=== Bioconductor zinbwave Demo ===") + let (counts, genes, cells, batch) = @src.zinbwave_example_data() + let config = @src.ZinbWaveConfig::create( + n_factors=2, + max_iterations=35, + inner_iterations=2, + tolerance=1.0e-5, + ridge=0.01, + ) catch { + _ => abort("failed to create zinbwave configuration") + } + + println("\n1. Fit a ZINB latent-factor model with a batch covariate") + let model = @src.zinbwave_fit( + counts, + config~, + cell_covariates=batch, + gene_names=genes, + cell_names=cells, + ) catch { + _ => abort("failed to fit zinbwave model") + } + println(" " + model.summary()) + println( + " log-likelihood: " + + model.diagnostics.initial_log_likelihood.to_string() + + " -> " + + model.diagnostics.final_log_likelihood.to_string(), + ) + + println("\n2. Inspect the inferred cell representation") + for cell in 0.. + println( + " " + + summary.gene_name + + ": observed zero fraction=" + + summary.observed_zero_fraction.to_string() + + ", fitted=" + + summary.fitted_zero_fraction.to_string() + + ", dispersion=" + + summary.dispersion.to_string(), + ) + None => abort("dropout gene summary should exist") + } + println( + " structural-zero posterior weight at dropout_gene/A1: " + + (1.0 - model.observational_weights[5][0]).to_string(), + ) + + println("\n4. Generate normalized, imputed, and residual matrices") + let normalized = model.normalized_values() + let imputed = model.impute_zeros(counts) catch { + _ => abort("failed to impute model zeros") + } + println(" normalized A_marker_1/A1=" + normalized[0][0].to_string()) + println(" imputed dropout_gene/A1=" + imputed[5][0].to_string()) + println( + " deviance residual A_marker_1/B1=" + + model.deviance_residuals[0][4].to_string(), + ) + + println("\n5. Add outputs to an immutable SingleCellExperiment copy") + let sce = @src.SingleCellExperiment::new(counts, genes, cells) + let output = @src.zinbwave_sce(sce, config~, cell_covariates=batch) catch { + _ => abort("failed to integrate zinbwave with SingleCellExperiment") + } + println( + " reduced dimensions: " + + @src.sce_get_reduced_dim(output.experiment, "zinbwave").length().to_string() + + " cells", + ) + println( + " observation-weight assay: " + + @src.sce_get_assay(output.experiment, "zinbwave_weights") + .length() + .to_string() + + " genes", + ) + println( + " source object unchanged: " + + (@src.sce_get_assay(sce, "zinbwave_weights").length() == 0).to_string(), + ) + + println("\n=== Demo Complete ===") +} diff --git a/examples/zinbwave_demo/moon.pkg b/examples/zinbwave_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/zinbwave_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/zinbwave.mbt b/src/zinbwave.mbt new file mode 100644 index 00000000..f66cfd74 --- /dev/null +++ b/src/zinbwave.mbt @@ -0,0 +1,1597 @@ +// Zero-inflated negative binomial factor models for single-cell counts. +// +// This module follows the model used by Bioconductor zinbwave: +// log(mu) = X beta_mu + (V gamma_mu)^T + W alpha_mu + O_mu +// logit(pi) = X beta_pi + (V gamma_pi)^T + W alpha_pi + O_pi +// where W contains inferred cell-level factors. Count matrices use the +// BioSeqs convention of genes in rows and cells in columns. + +///| +pub suberror ZinbWaveError { + ZinbWaveError(String) +} + +///| +pub struct ZinbWaveConfig { + n_factors : Int + max_iterations : Int + inner_iterations : Int + tolerance : Double + ridge : Double + dispersion_shrinkage : Double + minimum_mean : Double + minimum_probability : Double +} derive(Eq, Debug) + +///| +pub fn ZinbWaveConfig::create( + n_factors? : Int = 2, + max_iterations? : Int = 50, + inner_iterations? : Int = 2, + tolerance? : Double = 1.0e-5, + ridge? : Double = 1.0e-3, + dispersion_shrinkage? : Double = 5.0, + minimum_mean? : Double = 1.0e-8, + minimum_probability? : Double = 1.0e-6, +) -> ZinbWaveConfig raise ZinbWaveError { + if n_factors < 0 { + raise ZinbWaveError("zinbwave factor count must be non-negative") + } + if max_iterations < 1 || inner_iterations < 1 { + raise ZinbWaveError("zinbwave iteration counts must be positive") + } + if !zinbwave_is_finite(tolerance) || tolerance <= 0.0 { + raise ZinbWaveError("zinbwave tolerance must be finite and positive") + } + if !zinbwave_is_finite(ridge) || ridge < 0.0 { + raise ZinbWaveError( + "zinbwave ridge penalty must be finite and non-negative", + ) + } + if !zinbwave_is_finite(dispersion_shrinkage) || dispersion_shrinkage < 0.0 { + raise ZinbWaveError( + "zinbwave dispersion shrinkage must be finite and non-negative", + ) + } + if !zinbwave_is_finite(minimum_mean) || minimum_mean <= 0.0 { + raise ZinbWaveError("zinbwave minimum mean must be finite and positive") + } + if !zinbwave_is_finite(minimum_probability) || + minimum_probability <= 0.0 || + minimum_probability >= 0.5 { + raise ZinbWaveError( + "zinbwave minimum probability must be finite and in (0, 0.5)", + ) + } + ZinbWaveConfig::{ + n_factors, + max_iterations, + inner_iterations, + tolerance, + ridge, + dispersion_shrinkage, + minimum_mean, + minimum_probability, + } +} + +///| +pub fn ZinbWaveConfig::default() -> ZinbWaveConfig { + ZinbWaveConfig::{ + n_factors: 2, + max_iterations: 50, + inner_iterations: 2, + tolerance: 1.0e-5, + ridge: 1.0e-3, + dispersion_shrinkage: 5.0, + minimum_mean: 1.0e-8, + minimum_probability: 1.0e-6, + } +} + +///| +pub struct ZinbWaveDiagnostics { + iterations : Int + converged : Bool + initial_log_likelihood : Double + final_log_likelihood : Double + log_likelihoods : Array[Double] + maximum_parameter_change : Double +} derive(Eq, Debug) + +///| +pub struct ZinbWaveGeneSummary { + gene_name : String + dispersion : Double + inverse_dispersion : Double + observed_zero_fraction : Double + fitted_zero_fraction : Double + mean_count : Double + mean_fitted : Double +} derive(Eq, Debug) + +///| +pub struct ZinbWaveModel { + gene_names : Array[String] + cell_names : Array[String] + factors : Array[Array[Double]] + cell_design : Array[Array[Double]] + gene_design : Array[Array[Double]] + beta_mu : Array[Array[Double]] + beta_pi : Array[Array[Double]] + gamma_mu : Array[Array[Double]] + gamma_pi : Array[Array[Double]] + mean_offsets : Array[Array[Double]] + zero_offsets : Array[Array[Double]] + dispersions : Array[Double] + means : Array[Array[Double]] + zero_probabilities : Array[Array[Double]] + observational_weights : Array[Array[Double]] + deviance_residuals : Array[Array[Double]] + log_likelihood : Double + diagnostics : ZinbWaveDiagnostics + config : ZinbWaveConfig +} + +///| +pub struct ZinbWaveSCEOutput { + experiment : SingleCellExperiment + model : ZinbWaveModel +} + +///| +fn zinbwave_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn zinbwave_clamp(value : Double, lower : Double, upper : Double) -> Double { + value.max(lower).min(upper) +} + +///| +fn zinbwave_sigmoid(value : Double, minimum : Double) -> Double { + let probability = if value >= 0.0 { + let inverse = @math.exp(-value.min(40.0)) + 1.0 / (1.0 + inverse) + } else { + let exponential = @math.exp(value.max(-40.0)) + exponential / (1.0 + exponential) + } + zinbwave_clamp(probability, minimum, 1.0 - minimum) +} + +///| +fn zinbwave_logit(probability : Double, minimum : Double) -> Double { + let bounded = zinbwave_clamp(probability, minimum, 1.0 - minimum) + @math.ln(bounded / (1.0 - bounded)) +} + +///| +fn zinbwave_zero_matrix(rows : Int, columns : Int) -> Array[Array[Double]] { + let matrix : Array[Array[Double]] = [] + for _ in 0.. Array[Array[Double]] { + let copy : Array[Array[Double]] = [] + for row in matrix { + copy.push(row.copy()) + } + copy +} + +///| +fn zinbwave_validate_counts( + counts : Array[Array[Double]], +) -> (Int, Int) raise ZinbWaveError { + if counts.length() == 0 { + raise ZinbWaveError("zinbwave counts must contain at least one gene") + } + let cells = counts[0].length() + if cells < 2 { + raise ZinbWaveError("zinbwave counts must contain at least two cells") + } + for row in counts { + if row.length() != cells { + raise ZinbWaveError("zinbwave counts must be rectangular") + } + for value in row { + if !zinbwave_is_finite(value) || value < 0.0 { + raise ZinbWaveError( + "zinbwave counts must contain finite non-negative values", + ) + } + if (value - value.round()).abs() > 1.0e-8 { + raise ZinbWaveError("zinbwave requires integer-valued counts") + } + } + } + (counts.length(), cells) +} + +///| +fn zinbwave_validate_covariates( + covariates : Array[Array[Double]], + expected_rows : Int, + label : String, +) -> Int raise ZinbWaveError { + if covariates.length() == 0 { + return 0 + } + if covariates.length() != expected_rows { + raise ZinbWaveError(label + " rows must match the associated dimension") + } + let columns = covariates[0].length() + if columns == 0 { + raise ZinbWaveError(label + " must contain at least one column") + } + for row in covariates { + if row.length() != columns { + raise ZinbWaveError(label + " must be rectangular") + } + for value in row { + if !zinbwave_is_finite(value) { + raise ZinbWaveError(label + " must contain finite values") + } + } + } + columns +} + +///| +fn zinbwave_design_with_intercept( + covariates : Array[Array[Double]], + rows : Int, +) -> Array[Array[Double]] { + let columns = if covariates.length() == 0 { + 0 + } else { + covariates[0].length() + } + let design : Array[Array[Double]] = [] + for row in 0.. Array[Array[Double]] raise ZinbWaveError { + if offsets.length() == 0 { + return [] + } + if offsets.length() != genes { + raise ZinbWaveError(label + " rows must match the gene count") + } + let result : Array[Array[Double]] = [] + for row in offsets { + if row.length() != cells { + raise ZinbWaveError(label + " columns must match the cell count") + } + let values : Array[Double] = [] + for value in row { + if !zinbwave_is_finite(value) { + raise ZinbWaveError(label + " must contain finite values") + } + values.push(value) + } + result.push(values) + } + result +} + +///| +fn zinbwave_default_mean_offsets( + counts : Array[Array[Double]], +) -> Array[Array[Double]] raise ZinbWaveError { + let genes = counts.length() + let cells = counts[0].length() + let library_sizes = Array::make(cells, 0.0) + for gene in 0.. Array[String] raise ZinbWaveError { + if supplied.length() != 0 && supplied.length() != length { + raise ZinbWaveError(prefix + " names must match the matrix dimension") + } + let names : Array[String] = [] + for index in 0.. Array[Double] { + let size = right_hand_side.length() + if size == 0 { + return [] + } + let augmented : Array[Array[Double]] = [] + for row in 0.. pivot_size { + pivot_row = row + pivot_size = augmented[row][column].abs() + } + } + if pivot_row != column { + let temporary = augmented[column] + augmented[column] = augmented[pivot_row] + augmented[pivot_row] = temporary + } + if augmented[column][column].abs() < 1.0e-10 { + augmented[column][column] = if augmented[column][column] < 0.0 { + -1.0e-10 + } else { + 1.0e-10 + } + } + for row in (column + 1)..= 0 { + let mut value = augmented[row][size] + for column in (row + 1).. Array[Double] { + let observations = design.length() + let parameters = design[0].length() + let information = zinbwave_zero_matrix(parameters, parameters) + let score = Array::make(parameters, 0.0) + for observation in 0.. 0 { + information[parameter][parameter] = information[parameter][parameter] + + ridge + } + } + zinbwave_solve(information, score) +} + +///| +fn zinbwave_initialize_factors( + counts : Array[Array[Double]], + offsets : Array[Array[Double]], + n_factors : Int, +) -> Array[Array[Double]] { + let genes = counts.length() + let cells = counts[0].length() + let factors = zinbwave_zero_matrix(cells, 0) + if n_factors == 0 { + return factors + } + let transformed = zinbwave_zero_matrix(cells, genes) + for gene in 0.. Array[Array[Double]] { + let cells = cell_design.length() + let known = cell_design[0].length() + let latent = if factors.length() == 0 { 0 } else { factors[0].length() } + let design : Array[Array[Double]] = [] + for cell in 0.. (Array[Array[Double]], Array[Array[Double]]) { + let genes = counts.length() + let cells = counts[0].length() + let beta_mu : Array[Array[Double]] = [] + let beta_pi : Array[Array[Double]] = [] + for gene in 0.. Array[Double] { + let genes = counts.length() + let cells = counts[0].length() + let raw = Array::make(genes, 0.1) + for gene in 0.. 1.0e-8 { + ((variance - mean) / (mean * mean)).max(1.0e-4).min(100.0) + } else { + 1.0 + } + } + raw +} + +///| +fn zinbwave_linear_predictors( + beta_mu : Array[Array[Double]], + beta_pi : Array[Array[Double]], + gamma_mu : Array[Array[Double]], + gamma_pi : Array[Array[Double]], + cell_latent_design : Array[Array[Double]], + gene_design : Array[Array[Double]], + mean_offsets : Array[Array[Double]], + zero_offsets : Array[Array[Double]], + config : ZinbWaveConfig, +) -> (Array[Array[Double]], Array[Array[Double]]) { + let genes = beta_mu.length() + let cells = cell_latent_design.length() + let means = zinbwave_zero_matrix(genes, cells) + let probabilities = zinbwave_zero_matrix(genes, cells) + for gene in 0.. Double { + let coefficients = [ + 676.5203681218851, -1259.1392167224028, 771.3234287776531, -176.6150291621406, + 12.507343278686905, -0.13857109526572012, 0.000009984369578019572, 0.00000015056327351493116, + ] + if value < 0.5 { + return @math.ln(3.141592653589793 / @math.sin(3.141592653589793 * value)) - + zinbwave_lgamma(1.0 - value) + } + let shifted = value - 1.0 + let mut series = 0.9999999999998099 + for index in 0.. Double { + let theta = 1.0 / dispersion.max(1.0e-8) + zinbwave_lgamma(count + theta) - + zinbwave_lgamma(theta) - + zinbwave_lgamma(count + 1.0) + + theta * (@math.ln(theta) - @math.ln(theta + mean)) + + count * (@math.ln(mean) - @math.ln(theta + mean)) +} + +///| +fn zinbwave_responsibilities( + counts : Array[Array[Double]], + means : Array[Array[Double]], + probabilities : Array[Array[Double]], + dispersions : Array[Double], +) -> Array[Array[Double]] { + let genes = counts.length() + let cells = counts[0].length() + let weights = zinbwave_zero_matrix(genes, cells) + for gene in 0.. 0.0 { + weights[gene][cell] = 1.0 + } else { + let nb_zero = @math.exp( + theta * (@math.ln(theta) - @math.ln(theta + means[gene][cell])), + ) + let probability = probabilities[gene][cell] + let mixture = probability + (1.0 - probability) * nb_zero + weights[gene][cell] = ((1.0 - probability) * + nb_zero / + mixture.max(1.0e-300)).max(1.0e-12) + } + } + } + weights +} + +///| +fn zinbwave_log_likelihood( + counts : Array[Array[Double]], + means : Array[Array[Double]], + probabilities : Array[Array[Double]], + dispersions : Array[Double], +) -> Double { + let mut total = 0.0 + for gene in 0.. Double { + let genes = counts.length() + let cells = counts[0].length() + let mut maximum_change = 0.0 + for gene in 0.. Double { + let genes = counts.length() + let cells = counts[0].length() + let mut maximum_change = 0.0 + for cell in 0.. Double { + let latent = config.n_factors + if latent == 0 { + return 0.0 + } + let genes = counts.length() + let cells = counts[0].length() + let known = cell_design[0].length() + let mut maximum_change = 0.0 + for cell in 0.. Array[Double] { + let genes = counts.length() + let cells = counts[0].length() + let raw = Array::make(genes, 0.1) + for gene in 0.. 1.0e-12 { + (numerator / denominator).max(1.0e-4).min(100.0) + } else { + previous[gene] + } + } + let common = stat_median(raw).max(1.0e-4) + let information = cells.to_double() + let updated = Array::make(genes, 0.1) + for gene in 0.. Array[Array[Double]] { + let genes = counts.length() + let cells = counts[0].length() + let residuals = zinbwave_zero_matrix(genes, cells) + for gene in 0.. 0.0 { count * @math.ln(count / mean) } else { 0.0 } + let second = (count + theta) * @math.ln((count + theta) / (mean + theta)) + let deviance = (2.0 * (first - second)).max(0.0) + let sign = if count >= mean { 1.0 } else { -1.0 } + residuals[gene][cell] = sign * (weights[gene][cell] * deviance).sqrt() + } + } + residuals +} + +///| +pub fn zinbwave_fit( + counts : Array[Array[Double]], + config? : ZinbWaveConfig = ZinbWaveConfig::default(), + cell_covariates? : Array[Array[Double]] = [], + gene_covariates? : Array[Array[Double]] = [], + mean_offsets? : Array[Array[Double]] = [], + zero_offsets? : Array[Array[Double]] = [], + gene_names? : Array[String] = [], + cell_names? : Array[String] = [], +) -> ZinbWaveModel raise ZinbWaveError { + let (genes, cells) = zinbwave_validate_counts(counts) + ignore( + zinbwave_validate_covariates( + cell_covariates, cells, "zinbwave cell covariates", + ), + ) + ignore( + zinbwave_validate_covariates( + gene_covariates, genes, "zinbwave gene covariates", + ), + ) + if config.n_factors >= cells { + raise ZinbWaveError( + "zinbwave factor count must be smaller than the number of cells", + ) + } + if config.n_factors > genes { + raise ZinbWaveError( + "zinbwave factor count cannot exceed the number of genes", + ) + } + let prepared_gene_names = zinbwave_prepare_names(gene_names, genes, "Gene") + let prepared_cell_names = zinbwave_prepare_names(cell_names, cells, "Cell") + let prepared_mean_offsets = match + zinbwave_validate_offsets( + mean_offsets, genes, cells, "zinbwave mean offsets", + ) { + [] => zinbwave_default_mean_offsets(counts) + provided => provided + } + let prepared_zero_offsets = match + zinbwave_validate_offsets( + zero_offsets, genes, cells, "zinbwave zero offsets", + ) { + [] => zinbwave_zero_matrix(genes, cells) + provided => provided + } + let cell_design = zinbwave_design_with_intercept(cell_covariates, cells) + let gene_design = zinbwave_design_with_intercept(gene_covariates, genes) + let factors = zinbwave_initialize_factors( + counts, + prepared_mean_offsets, + config.n_factors, + ) + let mut cell_latent_design = zinbwave_cell_latent_design(cell_design, factors) + let (beta_mu, beta_pi) = zinbwave_initialize_coefficients( + counts, + prepared_mean_offsets, + cell_latent_design, + config.ridge, + config.minimum_probability, + ) + let gamma_mu = zinbwave_zero_matrix(cells, gene_design[0].length()) + let gamma_pi = zinbwave_zero_matrix(cells, gene_design[0].length()) + let mut dispersions = zinbwave_initial_dispersions( + counts, prepared_mean_offsets, + ) + let (initial_means, initial_probabilities) = zinbwave_linear_predictors( + beta_mu, beta_pi, gamma_mu, gamma_pi, cell_latent_design, gene_design, prepared_mean_offsets, + prepared_zero_offsets, config, + ) + let initial_log_likelihood = zinbwave_log_likelihood( + counts, initial_means, initial_probabilities, dispersions, + ) + let history : Array[Double] = [initial_log_likelihood] + let mut means = initial_means + let mut probabilities = initial_probabilities + let mut responsibilities = zinbwave_responsibilities( + counts, means, probabilities, dispersions, + ) + let mut converged = false + let mut completed_iterations = 0 + let mut maximum_parameter_change = 0.0 + for iteration in 0.. Int { + self.gene_names.length() +} + +///| +pub fn ZinbWaveModel::n_cells(self : ZinbWaveModel) -> Int { + self.cell_names.length() +} + +///| +pub fn ZinbWaveModel::n_factors(self : ZinbWaveModel) -> Int { + self.config.n_factors +} + +///| +pub fn ZinbWaveModel::n_parameters(self : ZinbWaveModel) -> Int { + let genes = self.n_genes() + let cells = self.n_cells() + genes * self.beta_mu[0].length() * 2 + + cells * self.gamma_mu[0].length() * 2 + + cells * self.n_factors() + + genes +} + +///| +pub fn ZinbWaveModel::aic(self : ZinbWaveModel) -> Double { + 2.0 * self.n_parameters().to_double() - 2.0 * self.log_likelihood +} + +///| +pub fn ZinbWaveModel::bic(self : ZinbWaveModel) -> Double { + let observations = (self.n_genes() * self.n_cells()).to_double() + @math.ln(observations) * self.n_parameters().to_double() - + 2.0 * self.log_likelihood +} + +///| +pub fn ZinbWaveModel::mean_zero_probability(self : ZinbWaveModel) -> Double { + let mut total = 0.0 + let mut count = 0 + for row in self.zero_probabilities { + for value in row { + total = total + value + count = count + 1 + } + } + if count == 0 { + 0.0 + } else { + total / count.to_double() + } +} + +///| +pub fn ZinbWaveModel::expected_mean( + self : ZinbWaveModel, + gene : Int, + cell : Int, +) -> Double? { + if gene < 0 || gene >= self.n_genes() || cell < 0 || cell >= self.n_cells() { + None + } else { + Some(self.means[gene][cell]) + } +} + +///| +pub fn ZinbWaveModel::zero_probability_at( + self : ZinbWaveModel, + gene : Int, + cell : Int, +) -> Double? { + if gene < 0 || gene >= self.n_genes() || cell < 0 || cell >= self.n_cells() { + None + } else { + Some(self.zero_probabilities[gene][cell]) + } +} + +///| +pub fn ZinbWaveModel::cell_factors( + self : ZinbWaveModel, + cell : Int, +) -> Array[Double]? { + if cell < 0 || cell >= self.n_cells() { + None + } else { + Some(self.factors[cell].copy()) + } +} + +///| +pub fn ZinbWaveModel::normalized_values( + self : ZinbWaveModel, +) -> Array[Array[Double]] { + let normalized = zinbwave_zero_matrix(self.n_genes(), self.n_cells()) + for gene in 0.. Array[Array[Double]] raise ZinbWaveError { + let (genes, cells) = zinbwave_validate_counts(counts) + if genes != self.n_genes() || cells != self.n_cells() { + raise ZinbWaveError("zinbwave imputation counts do not match the model") + } + let imputed = zinbwave_copy_matrix(counts) + for gene in 0.. ZinbWaveGeneSummary? { + if gene < 0 || + gene >= self.n_genes() || + counts.length() != self.n_genes() || + counts[gene].length() != self.n_cells() { + return None + } + let mut observed_zeros = 0.0 + let mut fitted_zeros = 0.0 + let mut observed_mean = 0.0 + let mut fitted_mean = 0.0 + let theta = 1.0 / self.dispersions[gene] + for cell in 0.. String { + "ZINB-WaVE(" + + self.n_genes().to_string() + + " genes x " + + self.n_cells().to_string() + + " cells, K=" + + self.n_factors().to_string() + + ", logLik=" + + self.log_likelihood.to_string() + + ", mean pi=" + + self.mean_zero_probability().to_string() + + ", iterations=" + + self.diagnostics.iterations.to_string() + + ", converged=" + + self.diagnostics.converged.to_string() + + ")" +} + +///| +fn zinbwave_copy_sce(sce : SingleCellExperiment) -> SingleCellExperiment { + let assays : Map[String, Array[Array[Double]]] = Map([]) + for key in sce.assays.keys() { + assays[key] = sce.assays[key] + } + let row_data : Map[String, Array[String]] = Map([]) + for key in sce.row_data.keys() { + row_data[key] = sce.row_data[key] + } + let col_data : Map[String, Array[String]] = Map([]) + for key in sce.col_data.keys() { + col_data[key] = sce.col_data[key] + } + let reduced_dims : Map[String, Array[Array[Double]]] = Map([]) + for key in sce.reduced_dims.keys() { + reduced_dims[key] = sce.reduced_dims[key] + } + let alternative_experiments : Map[String, SingleCellExperiment] = Map([]) + for key in sce.alternative_experiments.keys() { + alternative_experiments[key] = sce.alternative_experiments[key] + } + let metadata : Map[String, String] = Map([]) + for key in sce.metadata.keys() { + metadata[key] = sce.metadata[key] + } + SingleCellExperiment::{ + assays, + row_data, + col_data, + reduced_dims, + alternative_experiments, + metadata, + row_names: sce.row_names.copy(), + col_names: sce.col_names.copy(), + } +} + +///| +pub fn zinbwave_sce( + sce : SingleCellExperiment, + input_assay? : String = "counts", + reduced_dim_name? : String = "zinbwave", + config? : ZinbWaveConfig = ZinbWaveConfig::default(), + cell_covariates? : Array[Array[Double]] = [], + gene_covariates? : Array[Array[Double]] = [], + mean_offsets? : Array[Array[Double]] = [], + zero_offsets? : Array[Array[Double]] = [], +) -> ZinbWaveSCEOutput raise ZinbWaveError { + let counts = sce_get_assay(sce, input_assay) + if counts.length() == 0 { + raise ZinbWaveError( + "zinbwave SingleCellExperiment assay not found: " + input_assay, + ) + } + let model = zinbwave_fit( + counts, + config~, + cell_covariates~, + gene_covariates~, + mean_offsets~, + zero_offsets~, + gene_names=sce.row_names, + cell_names=sce.col_names, + ) + let enriched = zinbwave_copy_sce(sce) + enriched.assays["zinbwave_weights"] = zinbwave_copy_matrix( + model.observational_weights, + ) + enriched.assays["zinbwave_residuals"] = zinbwave_copy_matrix( + model.deviance_residuals, + ) + enriched.assays["zinbwave_normalized"] = model.normalized_values() + enriched.assays["zinbwave_imputed"] = model.impute_zeros(counts) + enriched.reduced_dims[reduced_dim_name] = zinbwave_copy_matrix(model.factors) + enriched.metadata["zinbwave_factors"] = model.n_factors().to_string() + enriched.metadata["zinbwave_iterations"] = model.diagnostics.iterations.to_string() + enriched.metadata["zinbwave_converged"] = model.diagnostics.converged.to_string() + enriched.metadata["zinbwave_log_likelihood"] = model.log_likelihood.to_string() + ZinbWaveSCEOutput::{ experiment: enriched, model } +} + +///| +pub fn zinbwave_example_data() -> ( + Array[Array[Double]], + Array[String], + Array[String], + Array[Array[Double]], +) { + let counts = [ + [18.0, 16.0, 20.0, 15.0, 0.0, 1.0, 0.0, 0.0], + [12.0, 10.0, 14.0, 11.0, 0.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 1.0, 0.0, 17.0, 19.0, 15.0, 18.0], + [1.0, 0.0, 0.0, 0.0, 11.0, 13.0, 10.0, 12.0], + [6.0, 5.0, 7.0, 6.0, 5.0, 7.0, 6.0, 5.0], + [0.0, 2.0, 0.0, 1.0, 0.0, 1.0, 0.0, 2.0], + ] + let gene_names = [ + "A_marker_1", "A_marker_2", "B_marker_1", "B_marker_2", "housekeeping", "dropout_gene", + ] + let cell_names = ["A1", "A2", "A3", "A4", "B1", "B2", "B3", "B4"] + let batch = [[0.0], [0.0], [1.0], [1.0], [0.0], [0.0], [1.0], [1.0]] + (counts, gene_names, cell_names, batch) +} diff --git a/test/moonbit/zinbwave_test.mbt b/test/moonbit/zinbwave_test.mbt new file mode 100644 index 00000000..04f7db8a --- /dev/null +++ b/test/moonbit/zinbwave_test.mbt @@ -0,0 +1,836 @@ +// Tests for the Bioconductor zinbwave-inspired ZINB factor model. + +///| +fn zinbwave_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "zinbwave value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn zinbwave_test_config() -> @src.ZinbWaveConfig { + @src.ZinbWaveConfig::create( + n_factors=2, + max_iterations=20, + inner_iterations=1, + tolerance=1.0e-4, + ridge=0.01, + ) catch { + _ => abort("test configuration should be valid") + } +} + +///| +fn zinbwave_test_model() -> @src.ZinbWaveModel { + let (counts, genes, cells, batch) = @src.zinbwave_example_data() + let config = zinbwave_test_config() + @src.zinbwave_fit( + counts, + config~, + cell_covariates=batch, + gene_names=genes, + cell_names=cells, + ) catch { + _ => abort("example zinbwave fit should succeed") + } +} + +///| +fn zinbwave_test_matrix( + rows : Int, + columns : Int, + value : Double, +) -> Array[Array[Double]] { + let matrix : Array[Array[Double]] = [] + for _ in 0.. @src.SingleCellExperiment { + let (counts, genes, cells, _) = @src.zinbwave_example_data() + @src.SingleCellExperiment::new(counts, genes, cells) +} + +///| +test "zinbwave: default configuration exposes model controls" { + let config = @src.ZinbWaveConfig::default() + assert_eq(config.n_factors, 2) + assert_eq(config.max_iterations, 50) + assert_eq(config.inner_iterations, 2) + assert_eq(config.tolerance, 1.0e-5) + assert_eq(config.dispersion_shrinkage, 5.0) +} + +///| +test "zinbwave: custom configuration preserves parameters" { + let config = @src.ZinbWaveConfig::create( + n_factors=1, + max_iterations=12, + inner_iterations=3, + tolerance=1.0e-6, + ridge=0.2, + dispersion_shrinkage=8.0, + minimum_mean=1.0e-7, + minimum_probability=1.0e-5, + ) catch { + _ => abort("custom configuration should be valid") + } + assert_eq(config.n_factors, 1) + assert_eq(config.max_iterations, 12) + assert_eq(config.inner_iterations, 3) + assert_eq(config.ridge, 0.2) + assert_eq(config.minimum_probability, 1.0e-5) +} + +///| +test "zinbwave: configuration rejects invalid factor and iteration counts" { + let factors = try { + ignore(@src.ZinbWaveConfig::create(n_factors=-1)) + false + } catch { + ZinbWaveError(_) => true + } + let iterations = try { + ignore(@src.ZinbWaveConfig::create(max_iterations=0)) + false + } catch { + ZinbWaveError(_) => true + } + let inner = try { + ignore(@src.ZinbWaveConfig::create(inner_iterations=0)) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(factors) + assert_true(iterations) + assert_true(inner) +} + +///| +test "zinbwave: configuration rejects invalid numeric controls" { + let tolerance = try { + ignore(@src.ZinbWaveConfig::create(tolerance=0.0)) + false + } catch { + ZinbWaveError(_) => true + } + let ridge = try { + ignore(@src.ZinbWaveConfig::create(ridge=-1.0)) + false + } catch { + ZinbWaveError(_) => true + } + let shrinkage = try { + ignore(@src.ZinbWaveConfig::create(dispersion_shrinkage=-1.0)) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(tolerance) + assert_true(ridge) + assert_true(shrinkage) +} + +///| +test "zinbwave: configuration rejects invalid probability bounds" { + let mean = try { + ignore(@src.ZinbWaveConfig::create(minimum_mean=0.0)) + false + } catch { + ZinbWaveError(_) => true + } + let probability = try { + ignore(@src.ZinbWaveConfig::create(minimum_probability=0.5)) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(mean) + assert_true(probability) +} + +///| +test "zinbwave: example data uses gene by cell orientation" { + let (counts, genes, cells, batch) = @src.zinbwave_example_data() + assert_eq(counts.length(), 6) + assert_eq(counts[0].length(), 8) + assert_eq(genes.length(), 6) + assert_eq(cells.length(), 8) + assert_eq(batch.length(), 8) + assert_eq(batch[0].length(), 1) +} + +///| +test "zinbwave: fit dimensions match the source matrix" { + let model = zinbwave_test_model() + assert_eq(model.n_genes(), 6) + assert_eq(model.n_cells(), 8) + assert_eq(model.n_factors(), 2) + assert_eq(model.means.length(), 6) + assert_eq(model.means[0].length(), 8) + assert_eq(model.factors.length(), 8) + assert_eq(model.factors[0].length(), 2) +} + +///| +test "zinbwave: custom identifiers are retained" { + let model = zinbwave_test_model() + assert_eq(model.gene_names[0], "A_marker_1") + assert_eq(model.gene_names[5], "dropout_gene") + assert_eq(model.cell_names[0], "A1") + assert_eq(model.cell_names[7], "B4") +} + +///| +test "zinbwave: omitted identifiers are generated deterministically" { + let config = @src.ZinbWaveConfig::create(n_factors=0, max_iterations=2) catch { + _ => abort("configuration should succeed") + } + let model = @src.zinbwave_fit([[4.0, 3.0], [2.0, 1.0]], config~) catch { + _ => abort("small fit should succeed") + } + assert_eq(model.gene_names, ["Gene1", "Gene2"]) + assert_eq(model.cell_names, ["Cell1", "Cell2"]) +} + +///| +test "zinbwave: cell and gene designs include intercepts" { + let model = zinbwave_test_model() + assert_eq(model.cell_design.length(), 8) + assert_eq(model.cell_design[0].length(), 2) + assert_eq(model.cell_design[0][0], 1.0) + assert_eq(model.gene_design.length(), 6) + assert_eq(model.gene_design[0], [1.0]) +} + +///| +test "zinbwave: latent factors are centered and scaled" { + let model = zinbwave_test_model() + for factor in 0.. + model.diagnostics.initial_log_likelihood, + ) +} + +///| +test "zinbwave: diagnostics track every outer iteration" { + let model = zinbwave_test_model() + assert_true(model.diagnostics.iterations > 0) + assert_eq( + model.diagnostics.log_likelihoods.length(), + model.diagnostics.iterations + 1, + ) + assert_eq( + model.diagnostics.final_log_likelihood, + model.diagnostics.log_likelihoods[model.diagnostics.log_likelihoods.length() - + 1], + ) +} + +///| +test "zinbwave: fitted means are finite and positive" { + let model = zinbwave_test_model() + for row in model.means { + for value in row { + assert_true(value > 0.0) + assert_true(value.abs() < 1.0e300) + } + } +} + +///| +test "zinbwave: zero probabilities are strictly bounded" { + let model = zinbwave_test_model() + for row in model.zero_probabilities { + for value in row { + assert_true(value > 0.0) + assert_true(value < 1.0) + } + } + assert_true(model.mean_zero_probability() > 0.0) + assert_true(model.mean_zero_probability() < 1.0) +} + +///| +test "zinbwave: gene dispersions are finite and positive" { + let model = zinbwave_test_model() + assert_eq(model.dispersions.length(), model.n_genes()) + for value in model.dispersions { + assert_true(value >= 1.0e-4) + assert_true(value <= 100.0) + } +} + +///| +test "zinbwave: observation weights are positive and at most one" { + let model = zinbwave_test_model() + for row in model.observational_weights { + for value in row { + assert_true(value > 0.0) + assert_true(value <= 1.0) + } + } +} + +///| +test "zinbwave: positive counts receive unit observation weight" { + let (counts, _, _, _) = @src.zinbwave_example_data() + let model = zinbwave_test_model() + for gene in 0.. 0.0 { + assert_eq(model.observational_weights[gene][cell], 1.0) + } + } + } +} + +///| +test "zinbwave: dropout-like zero receives downweighted NB responsibility" { + let model = zinbwave_test_model() + assert_true(model.observational_weights[5][0] < 0.5) + assert_true(model.zero_probabilities[5][0] > 0.5) +} + +///| +test "zinbwave: deviance residuals are finite with source dimensions" { + let model = zinbwave_test_model() + assert_eq(model.deviance_residuals.length(), 6) + assert_eq(model.deviance_residuals[0].length(), 8) + for row in model.deviance_residuals { + for value in row { + assert_true(value.abs() < 1.0e300) + } + } +} + +///| +test "zinbwave: normalized values remove library offsets" { + let model = zinbwave_test_model() + let normalized = model.normalized_values() + assert_eq(normalized.length(), model.n_genes()) + assert_eq(normalized[0].length(), model.n_cells()) + for row in normalized { + for value in row { + assert_true(value > 0.0) + } + } +} + +///| +test "zinbwave: imputation preserves observed positive counts" { + let (counts, _, _, _) = @src.zinbwave_example_data() + let model = zinbwave_test_model() + let imputed = model.impute_zeros(counts) catch { + _ => abort("imputation should succeed") + } + for gene in 0.. 0.0 { + assert_eq(imputed[gene][cell], counts[gene][cell]) + } + } + } +} + +///| +test "zinbwave: imputation fills structural zeros with non-negative signal" { + let (counts, _, _, _) = @src.zinbwave_example_data() + let model = zinbwave_test_model() + let imputed = model.impute_zeros(counts) catch { + _ => abort("imputation should succeed") + } + assert_true(imputed[5][0] > 0.0) + assert_true(imputed[5][0] < model.means[5][0]) +} + +///| +test "zinbwave: summary reports shape and latent dimension" { + let summary = zinbwave_test_model().summary() + assert_true(summary.contains("6 genes x 8 cells")) + assert_true(summary.contains("K=2")) + assert_true(summary.contains("logLik=")) +} + +///| +test "zinbwave: information criteria are finite" { + let model = zinbwave_test_model() + assert_true(model.n_parameters() > 0) + assert_true(model.aic().abs() < 1.0e300) + assert_true(model.bic().abs() < 1.0e300) + assert_true(model.bic() > model.aic()) +} + +///| +test "zinbwave: expected mean query handles bounds" { + let model = zinbwave_test_model() + match model.expected_mean(0, 0) { + Some(value) => assert_eq(value, model.means[0][0]) + None => abort("valid fitted mean should exist") + } + assert_true(model.expected_mean(-1, 0) is None) + assert_true(model.expected_mean(0, 8) is None) +} + +///| +test "zinbwave: zero probability query handles bounds" { + let model = zinbwave_test_model() + match model.zero_probability_at(5, 7) { + Some(value) => assert_eq(value, model.zero_probabilities[5][7]) + None => abort("valid zero probability should exist") + } + assert_true(model.zero_probability_at(6, 0) is None) +} + +///| +test "zinbwave: cell factor query returns an independent copy" { + let model = zinbwave_test_model() + match model.cell_factors(0) { + Some(values) => { + let original = model.factors[0][0] + values[0] = values[0] + 10.0 + assert_eq(model.factors[0][0], original) + } + None => abort("valid cell factors should exist") + } + assert_true(model.cell_factors(8) is None) +} + +///| +test "zinbwave: gene summary reports observed and fitted zeros" { + let (counts, _, _, _) = @src.zinbwave_example_data() + let model = zinbwave_test_model() + match model.gene_summary(counts, 5) { + Some(summary) => { + assert_eq(summary.gene_name, "dropout_gene") + assert_eq(summary.observed_zero_fraction, 0.5) + assert_true(summary.fitted_zero_fraction > 0.0) + assert_true(summary.fitted_zero_fraction < 1.0) + assert_true(summary.inverse_dispersion > 0.0) + } + None => abort("valid gene summary should exist") + } +} + +///| +test "zinbwave: gene summary rejects invalid dimensions and indices" { + let model = zinbwave_test_model() + assert_true(model.gene_summary([[1.0, 2.0]], 0) is None) + let (counts, _, _, _) = @src.zinbwave_example_data() + assert_true(model.gene_summary(counts, -1) is None) + assert_true(model.gene_summary(counts, 6) is None) +} + +///| +test "zinbwave: zero-factor model remains fully operational" { + let (counts, genes, cells, _) = @src.zinbwave_example_data() + let config = @src.ZinbWaveConfig::create( + n_factors=0, + max_iterations=5, + inner_iterations=1, + ) catch { + _ => abort("zero-factor configuration should succeed") + } + let model = @src.zinbwave_fit( + counts, + config~, + gene_names=genes, + cell_names=cells, + ) catch { + _ => abort("zero-factor fit should succeed") + } + assert_eq(model.n_factors(), 0) + assert_eq(model.factors.length(), 8) + assert_eq(model.factors[0].length(), 0) + assert_true(model.log_likelihood.abs() < 1.0e300) +} + +///| +test "zinbwave: explicit mean offsets are retained" { + let (counts, _, _, _) = @src.zinbwave_example_data() + let offsets = zinbwave_test_matrix(6, 8, 0.25) + let config = @src.ZinbWaveConfig::create(n_factors=1, max_iterations=3) catch { + _ => abort("configuration should succeed") + } + let model = @src.zinbwave_fit(counts, config~, mean_offsets=offsets) catch { + _ => abort("offset fit should succeed") + } + assert_eq(model.mean_offsets[0][0], 0.25) + assert_eq(model.mean_offsets[5][7], 0.25) +} + +///| +test "zinbwave: explicit zero offsets are retained" { + let (counts, _, _, _) = @src.zinbwave_example_data() + let offsets = zinbwave_test_matrix(6, 8, -0.5) + let config = @src.ZinbWaveConfig::create(n_factors=1, max_iterations=3) catch { + _ => abort("configuration should succeed") + } + let model = @src.zinbwave_fit(counts, config~, zero_offsets=offsets) catch { + _ => abort("zero-offset fit should succeed") + } + assert_eq(model.zero_offsets[0][0], -0.5) + assert_eq(model.zero_offsets[5][7], -0.5) +} + +///| +test "zinbwave: gene-level covariates are fitted with intercept" { + let (counts, _, _, _) = @src.zinbwave_example_data() + let gene_covariates = [[0.30], [0.35], [0.40], [0.45], [0.50], [0.55]] + let config = @src.ZinbWaveConfig::create(n_factors=1, max_iterations=4) catch { + _ => abort("configuration should succeed") + } + let model = @src.zinbwave_fit(counts, config~, gene_covariates~) catch { + _ => abort("gene covariate fit should succeed") + } + assert_eq(model.gene_design[0], [1.0, 0.30]) + assert_eq(model.gamma_mu.length(), 8) + assert_eq(model.gamma_mu[0].length(), 2) +} + +///| +test "zinbwave: empty count matrix is rejected" { + let rejected = try { + ignore(@src.zinbwave_fit([])) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(rejected) +} + +///| +test "zinbwave: one-cell count matrix is rejected" { + let rejected = try { + ignore(@src.zinbwave_fit([[1.0], [2.0]])) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(rejected) +} + +///| +test "zinbwave: ragged count matrix is rejected" { + let rejected = try { + ignore(@src.zinbwave_fit([[1.0, 2.0], [3.0]])) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(rejected) +} + +///| +test "zinbwave: negative and non-finite counts are rejected" { + let negative = try { + ignore(@src.zinbwave_fit([[1.0, -1.0], [2.0, 3.0]])) + false + } catch { + ZinbWaveError(_) => true + } + let non_finite = try { + ignore(@src.zinbwave_fit([[1.0, @double.not_a_number], [2.0, 3.0]])) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(negative) + assert_true(non_finite) +} + +///| +test "zinbwave: fractional counts are rejected" { + let rejected = try { + ignore(@src.zinbwave_fit([[1.5, 2.0], [3.0, 4.0]])) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(rejected) +} + +///| +test "zinbwave: empty cell libraries are rejected for automatic offsets" { + let rejected = try { + ignore(@src.zinbwave_fit([[1.0, 0.0], [2.0, 0.0]])) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(rejected) +} + +///| +test "zinbwave: excessive factor count is rejected" { + let config = @src.ZinbWaveConfig::create(n_factors=2) catch { + _ => abort("configuration itself should succeed") + } + let rejected = try { + ignore(@src.zinbwave_fit([[2.0, 1.0], [1.0, 2.0]], config~)) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(rejected) +} + +///| +test "zinbwave: malformed cell covariates are rejected" { + let (counts, _, _, _) = @src.zinbwave_example_data() + let wrong_rows = try { + ignore(@src.zinbwave_fit(counts, cell_covariates=[[0.0], [1.0]])) + false + } catch { + ZinbWaveError(_) => true + } + let ragged = try { + ignore( + @src.zinbwave_fit(counts, cell_covariates=[ + [0.0], + [0.0, 1.0], + [0.0], + [0.0], + [1.0], + [1.0], + [1.0], + [1.0], + ]), + ) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(wrong_rows) + assert_true(ragged) +} + +///| +test "zinbwave: malformed gene covariates are rejected" { + let (counts, _, _, _) = @src.zinbwave_example_data() + let rejected = try { + ignore(@src.zinbwave_fit(counts, gene_covariates=[[0.0], [1.0], [2.0]])) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(rejected) +} + +///| +test "zinbwave: malformed offsets are rejected" { + let (counts, _, _, _) = @src.zinbwave_example_data() + let rows = try { + ignore( + @src.zinbwave_fit(counts, mean_offsets=zinbwave_test_matrix(5, 8, 0.0)), + ) + false + } catch { + ZinbWaveError(_) => true + } + let columns = try { + ignore( + @src.zinbwave_fit(counts, zero_offsets=zinbwave_test_matrix(6, 7, 0.0)), + ) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(rows) + assert_true(columns) +} + +///| +test "zinbwave: non-finite offsets are rejected" { + let (counts, _, _, _) = @src.zinbwave_example_data() + let offsets = zinbwave_test_matrix(6, 8, 0.0) + offsets[2][3] = @double.not_a_number + let rejected = try { + ignore(@src.zinbwave_fit(counts, mean_offsets=offsets)) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(rejected) +} + +///| +test "zinbwave: identifier length mismatch is rejected" { + let (counts, _, _, _) = @src.zinbwave_example_data() + let genes = try { + ignore(@src.zinbwave_fit(counts, gene_names=["A"])) + false + } catch { + ZinbWaveError(_) => true + } + let cells = try { + ignore(@src.zinbwave_fit(counts, cell_names=["A"])) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(genes) + assert_true(cells) +} + +///| +test "zinbwave: duplicate and empty identifiers are rejected" { + let counts = [[2.0, 1.0], [1.0, 2.0]] + let config = @src.ZinbWaveConfig::create(n_factors=0) catch { + _ => abort("configuration should succeed") + } + let duplicate = try { + ignore(@src.zinbwave_fit(counts, config~, gene_names=["same", "same"])) + false + } catch { + ZinbWaveError(_) => true + } + let empty = try { + ignore(@src.zinbwave_fit(counts, config~, cell_names=["", "cell"])) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(duplicate) + assert_true(empty) +} + +///| +test "zinbwave: imputation rejects matrix shape mismatch" { + let model = zinbwave_test_model() + let rejected = try { + ignore(model.impute_zeros([[1.0, 2.0], [2.0, 1.0]])) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(rejected) +} + +///| +test "zinbwave: SCE integration adds assays and reduced dimensions" { + let (_, _, _, batch) = @src.zinbwave_example_data() + let config = zinbwave_test_config() + let output = @src.zinbwave_sce( + zinbwave_test_sce(), + config~, + cell_covariates=batch, + ) catch { + _ => abort("SCE integration should succeed") + } + assert_eq( + @src.sce_get_assay(output.experiment, "zinbwave_weights").length(), + 6, + ) + assert_eq( + @src.sce_get_assay(output.experiment, "zinbwave_residuals").length(), + 6, + ) + assert_eq( + @src.sce_get_assay(output.experiment, "zinbwave_normalized").length(), + 6, + ) + assert_eq( + @src.sce_get_assay(output.experiment, "zinbwave_imputed").length(), + 6, + ) + assert_eq(@src.sce_get_reduced_dim(output.experiment, "zinbwave").length(), 8) +} + +///| +test "zinbwave: SCE integration preserves source object" { + let source = zinbwave_test_sce() + let config = zinbwave_test_config() + ignore(@src.zinbwave_sce(source, config~)) catch { + _ => abort("SCE integration should succeed") + } + assert_eq(@src.sce_get_assay(source, "zinbwave_weights").length(), 0) + assert_eq(@src.sce_get_reduced_dim(source, "zinbwave").length(), 0) +} + +///| +test "zinbwave: SCE integration supports custom reduced dimension name" { + let config = zinbwave_test_config() + let output = @src.zinbwave_sce( + zinbwave_test_sce(), + reduced_dim_name="ZINB", + config~, + ) catch { + _ => abort("custom reduced dimension should succeed") + } + assert_eq(@src.sce_get_reduced_dim(output.experiment, "ZINB").length(), 8) + assert_eq(@src.sce_get_reduced_dim(output.experiment, "zinbwave").length(), 0) +} + +///| +test "zinbwave: SCE integration retains row and cell identifiers" { + let config = zinbwave_test_config() + let output = @src.zinbwave_sce(zinbwave_test_sce(), config~) catch { + _ => abort("SCE integration should succeed") + } + assert_eq(output.model.gene_names[0], "A_marker_1") + assert_eq(output.model.cell_names[7], "B4") + assert_eq(output.experiment.row_names[5], "dropout_gene") +} + +///| +test "zinbwave: SCE integration rejects missing assay" { + let config = zinbwave_test_config() + let rejected = try { + ignore( + @src.zinbwave_sce(zinbwave_test_sce(), input_assay="missing", config~), + ) + false + } catch { + ZinbWaveError(_) => true + } + assert_true(rejected) +} From f522d3b50452dc3e3be35178e735ae6e9a2c11e0 Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 02:17:12 +0800 Subject: [PATCH 18/41] feat(bigbed): Bio.Align.bigbed & BigBed v4 & BED3-BED12 & AutoSQL & B+Tree & R-tree & zlib/DEFLATE & BED & exon --- README.md | 26 +- examples/bigbed_demo/main.mbt | 166 +++ examples/bigbed_demo/moon.pkg | 5 + src/bigbed.mbt | 2475 +++++++++++++++++++++++++++++++++ test/moonbit/bigbed_test.mbt | 1079 ++++++++++++++ 5 files changed, 3747 insertions(+), 4 deletions(-) create mode 100644 examples/bigbed_demo/main.mbt create mode 100644 examples/bigbed_demo/moon.pkg create mode 100644 src/bigbed.mbt create mode 100644 test/moonbit/bigbed_test.mbt diff --git a/README.md b/README.md index f66a4764..0dea7397 100644 --- a/README.md +++ b/README.md @@ -160,6 +160,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | Bioconductor variancePartition | 多随机截距线性混合模型、ML/REML方差分量、固定/随机/残差方差占比、precision weights、BLUP、dream contrast、数值Satterthwaite检验、BH-FDR与SummarizedExperiment接入 | | ✅ | Bio.Align.Alignment shared-reference merge | 共享参考PWA/MSA合并、reference-boundary insertion slot同步、局部reference/query坐标、metadata、统计、MSA与aligned FASTA转换 | | ✅ | Bio.Align.Alignment map/mapall | 零起始半开区间alignment path组合、局部clipping、gap与正反链传播、双向坐标查询、PSL、批量map及protein MSA到codon-aware nucleotide MSA投影 | +| ✅ | Bio.Align.bigbed | BigBed v4二进制读写、BED3-BED12、AutoSQL扩展字段、多级chromosome B+ tree与R-tree、zlib/DEFLATE解码、区间/名称查询和BED导出 | | ✅ | Bioconductor decontX | 单细胞ambient RNA去污染: cluster-native/contaminant多项式混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解、诊断与SingleCellExperiment接入 | | ✅ | Bio.PDB.SASA | 溶剂可及表面积计算: Shrake-Rupley滚动球算法(Fibonacci球面采样)、范德华半径查表、逐原子/残基/链SASA、骨架/侧链拆分 | | ✅ | Bio.SeqIO.NibIO | nib 2-bit二进制序列格式: DNA 2-bit编码(T=0/C=1/A=2/G=3)、4碱基/字节打包、hex I/O、子序列提取、反向互补、GC含量、压缩比 | @@ -217,6 +218,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **HH-suite HHR** | Biopython `Bio.Align.hhr` | HHR元数据、命中摘要、多块profile比对、consensus/二级结构/DSSP/confidence注释、概率和E-value查询 | ✅ | | **共享参考比对合并** | Biopython `Bio.Align.Alignment.from_alignments_with_same_reference` | 混合PWA/MSA输入、首端/内部/末端insertion同步、多query投影、局部坐标与metadata保留、统计和格式转换 | ✅ | | **Alignment坐标组合** | Biopython `Bio.Align.Alignment.map/mapall` | alignment path组合、局部overhang clipping、exon/intron与indel gap、正反链组合、坐标双向查询、PSL及1:1/1:3 MSA投影 | ✅ | +| **BigBed二进制区间索引** | Biopython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12与AutoSQL、多级B+ tree/R-tree、stored/fixed/dynamic DEFLATE、区间/名称查询、链感知exon坐标及BED导出 | ✅ | | **zinbwave** | Bioconductor zinbwave | 零膨胀负二项低维模型、cell/gene协变量与offset、确定性latent factors、dispersion shrinkage、observational weights、残差/归一化/插补及SCE集成 | ✅ | | **Prosite** | Biopython `Bio.Prosite` | 蛋白质模体数据库搜索、Prosite模式解析、模体匹配算法、模体得分计算 | ✅ | | **PAML** | Biopython `Bio.PAML` | 分子进化分析、dN/dS计算（Nei-Gojobori方法）、Jukes-Cantor校正、密码子使用分析 | ✅ | @@ -417,6 +419,7 @@ IvanAXu/BioSeqs/ │ ├── align.mbt # MultipleSeqAlignment 多序列比对 │ ├── shared_reference_alignment.mbt # Bio.Align共享参考PWA/MSA合并、insertion slot同步与坐标映射 │ ├── alignment_map.mbt # Bio.Align.Alignment map/mapall坐标路径组合与MSA投影 +│ ├── bigbed.mbt # Bio.Align.bigbed v4、BED/AutoSQL、多级B+ tree/R-tree与DEFLATE │ ├── alignio.mbt # 比对文件 I/O │ ├── clustal_io.mbt # Clustal 格式 │ ├── phylip_io.mbt # PHYLIP 格式 @@ -1103,6 +1106,7 @@ IvanAXu/BioSeqs/ │ ├── hhr_demo/ # HH-suite HHR解析、命中筛选、坐标映射与序列化往返示例 │ ├── shared_reference_alignment_demo/ # 共享参考PWA/MSA合并、insertion同步、坐标映射与FASTA转换示例 │ ├── alignment_map_demo/ # Alignment.map/mapall、反链、PSL与protein-to-codon MSA投影示例 +│ ├── bigbed_demo/ # BigBed写入/解析、索引查询、负链exon坐标、BED导出与损坏诊断 │ ├── gene_pop_demo/ # GenePop群体遗传学示例 (基因型解析、等位基因频率、杂合度统计、序列化往返) │ ├── stage_r_demo/ # stageR两阶段检验示例 (筛选+确认、Simes聚合、BH-FDR、Holm步降、OFDR控制) │ ├── enriched_heatmap_demo/ # EnrichedHeatmap富集热图示例 (信号归一化、四种均值模式、行平滑、链方向处理) @@ -1305,6 +1309,7 @@ IvanAXu/BioSeqs/ │ │ ├── variance_partition_test.mbt │ │ ├── shared_reference_alignment_test.mbt │ │ ├── alignment_map_test.mbt +│ │ ├── bigbed_test.mbt │ │ ├── search_io_test.mbt │ │ ├── searchio_new_test.mbt │ │ ├── seq_complexity_test.mbt @@ -1481,7 +1486,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8775 个测试全部通过 +moon test # ✅ 8839 个测试全部通过 ``` ### 模块对照表 @@ -1528,6 +1533,7 @@ moon test # ✅ 8775 个测试全 | `hhr.mbt` | BioPython `Bio.Align.hhr` | HHsearch/HHblits HHR解析、profile比对注释、命中筛选、坐标映射与规范序列化 | | `shared_reference_alignment.mbt` | BioPython `Bio.Align.Alignment.from_alignments_with_same_reference` | 共享参考PWA/MSA合并、insertion slot同步、局部坐标、双向映射、统计、MSA与FASTA转换 | | `alignment_map.mbt` | BioPython `Bio.Align.Alignment.map/mapall` | alignment path组合、local clipping、gap与链向传播、双向坐标查询、PSL、map_many及codon-aware MSA投影 | +| `bigbed.mbt` | BioPython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12、AutoSQL、多级chromosome B+ tree/R-tree、zlib/DEFLATE及索引查询 | #### 系统发育树 @@ -1794,6 +1800,7 @@ moon test # ✅ 8775 个测试全 | `variance_partition.mbt` | `variancePartition` | typed fixed/random design、多随机截距LMM、ML/REML方差分解、BLUP、weighted dream contrast、Satterthwaite自由度与SummarizedExperiment入口 | | `shared_reference_alignment.mbt` | `Bio.Align.Alignment` | 同参考PWA/MSA的reference-boundary insertion同步、原query投影、局部坐标、metadata、统计与格式转换 | | `alignment_map.mbt` | `Bio.Align.Alignment.map/mapall` | 两层alignment坐标组合、正反链与gap传播、PSL、批量映射及protein/nucleotide MSA投影 | +| `bigbed.mbt` | `Bio.Align.bigbed` | BigBed v4二进制读写、BED/AutoSQL、平衡B+ tree/R-tree、完整DEFLATE块解码、区间/名称查询与BED导出 | | `infercnv.mbt` | `infercnv` | 单细胞拷贝数变异推断（基因组位置排序、参考细胞有界 LFC 计算、金字塔权重平滑、CNV 分数与恶性细胞预测） | | `scenic.mbt` | `SCENIC` | 单细胞调控网络推断与聚类（TF-target 共表达模块、Regulon 构建、AUCell 活性评分、二值化阈值、细胞状态与主控调控因子） | | `cibersort.mbt` | `CIBERSORT` | 免疫细胞去卷积（NNLS 求解、LM22 风格特征矩阵、Pearson 拟合优度、分数归一化） | @@ -2896,6 +2903,14 @@ E-step 对零计数计算来自 NB component 的后验 responsibility，正计 `zinbwave_sce` 从指定 `SingleCellExperiment` assay 拟合模型，在不可变副本中加入 `zinbwave_weights`、`zinbwave_residuals`、`zinbwave_normalized`、`zinbwave_imputed` assays、低维表示和模型 metadata，不修改输入对象。构造器会诊断 ragged/负数/非整数/非有限计数、空 cell library、design/offset 维度和标识符问题。当前实现使用 dense MoonBit arrays 和确定性交替求解，不包含上游 R 包的并行后端、稀疏矩阵专用优化、epsilon penalty 路径或绘图接口。 +### 253. BigBed 二进制区间索引 (Biopython Bio.Align.bigbed) + +实现 Biopython 1.86 `Bio.Align.bigbed` 对应的 UCSC BigBed v4 二进制读写核心。`bigbed_write` 将按染色体和起点排序的 BED3-BED12 记录编码为 binary BED 数据块，写入 64 字节主头、AutoSQL schema、chromosome B+ tree、record count、R-tree interval index、total summary 和尾部 magic；`bigbed_parse` 同时支持小端/大端文件并严格验证版本、偏移、树深度、记录计数、染色体边界及索引一致性。writer 可通过 `items_per_slot` 和 `block_size` 构建多数据块及平衡多级索引，而不是仅支持单叶节点。 + +标准 BED 渐进字段和 custom AutoSQL scalar/array 字段均可往返保留。压缩 reader 实现 RFC 1950/1951 zlib 的 stored、fixed Huffman 和 dynamic Huffman DEFLATE，包括 canonical code、code-length repeat、LZ77重叠复制、32 KiB距离、FCHECK/FDICT/CINFO及Adler-32校验；writer 使用确定性 stored DEFLATE。`BigBedFile::search` 通过R-tree剪枝执行0-based half-open区间查询，另提供全量记录、名称查询、汇总和BED文本导出。BED12记录可恢复含intron jump的target/query坐标路径，负链query坐标按转录本长度反向。 + +构造器和解析器会诊断无效BED字段、未排序记录、未知染色体、损坏magic、截断数据、异常树节点、非法zlib流及校验和不一致。当前范围不写入zoom levels或extra string indices；offset/count虽按u64布局读取和写入，但内存模型仍拒绝高32位非零的超大文件。writer的stored DEFLATE保证互操作性和确定性，但不追求压缩率。 + ## 性能优化 ### 优化策略 @@ -2997,8 +3012,8 @@ E-step 对零计数计算来自 NB component 的后验 responsibility，正计 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8775 | -| 通过数 | 8775 | +| 总测试数 | 8839 | +| 通过数 | 8839 | | 失败数 | 0 | | 通过率 | 100% | @@ -3102,6 +3117,7 @@ moon test --update | Bio.Align.hhr | `hhr_test.mbt` | 33 | | Bio.Align shared-reference merge | `shared_reference_alignment_test.mbt` | 41 | | Bio.Align Alignment.map/mapall | `alignment_map_test.mbt` | 44 | +| Bio.Align.bigbed | `bigbed_test.mbt` | 64 | | SparseArray | `sparse_array_test.mbt` | 41 | | mmCIF | `mmcif_test.mbt` | 2 | | BinaryCIF | `binary_cif_test.mbt` | 37 | @@ -3399,7 +3415,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 360 个示例程序，展示各模块的典型用法： +项目提供 361 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3589,6 +3605,7 @@ moon run cmd/bench/main.mbt | variance_partition_demo | typed固定/随机设计、ML方差分解、BLUP、precision weights、dream contrast与SummarizedExperiment接入 | `moon run examples/variance_partition_demo` | | shared_reference_alignment_demo | 共享参考PWA/MSA合并、reference insertion同步、坐标映射、统计、MSA与aligned FASTA转换 | `moon run examples/shared_reference_alignment_demo` | | alignment_map_demo | chromosome→transcript→read坐标组合、intron gap、反链、坐标查询、PSL与protein-to-codon MSA投影 | `moon run examples/alignment_map_demo` | +| bigbed_demo | BigBed v4压缩写入/解析、AutoSQL、多级索引查询、负链exon坐标、BED导出及损坏文件诊断 | `moon run examples/bigbed_demo` | | gene_pop_demo | GenePop群体遗传学（基因型解析、等位基因频率、杂合度统计、序列化往返） | `moon run examples/gene_pop_demo/main.mbt` | | stage_r_demo | stageR两阶段假设检验（筛选+确认、Simes聚合、BH-FDR、Holm步降、OFDR控制） | `moon run examples/stage_r_demo/main.mbt` | | enriched_heatmap_demo | EnrichedHeatmap富集热图（信号归一化、四种均值模式、行平滑、链方向处理） | `moon run examples/enriched_heatmap_demo/main.mbt` | @@ -3695,6 +3712,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bioconductor variancePartition 重复测量混合模型（ML/REML方差分解、BLUP、precision weights、dream contrast、数值Satterthwaite、BH-FDR与SummarizedExperiment接入） - ✅ 实现 Bio.Align共享参考序列比对合并（混合PWA/MSA、reference-boundary insertion同步、局部坐标、双向映射、统计与格式转换） - ✅ 实现 Bio.Align.Alignment map/mapall（alignment path组合、local clipping、gap与正反链传播、坐标查询、PSL及protein-to-codon MSA投影） +- ✅ 实现 Bio.Align.bigbed BigBed v4二进制区间格式（BED3-BED12、AutoSQL、多级B+ tree/R-tree、DEFLATE、区间/名称查询与BED导出） - ✅ 实现 Bioconductor decontX ambient RNA去污染（cluster-native/contaminant混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解与SCE集成） - ✅ 实现 Bioconductor zinbwave 零膨胀负二项低维模型（cell/gene协变量、offset、latent factors、dispersion shrinkage、observational weights、残差/插补与SCE集成） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） diff --git a/examples/bigbed_demo/main.mbt b/examples/bigbed_demo/main.mbt new file mode 100644 index 00000000..00676ad2 --- /dev/null +++ b/examples/bigbed_demo/main.mbt @@ -0,0 +1,166 @@ +///| +fn format_coordinate_path(path : Array[Array[Int]]) -> String { + let output = StringBuilder::new() + output.write_string("[") + for i in 0.. 0 { + output.write_string(", ") + } + output.write_string("[") + for j in 0.. 0 { + output.write_string(", ") + } + output.write_string(path[i][j].to_string()) + } + output.write_string("]") + } + output.write_string("]") + output.to_string() +} + +///| +fn main { + println("=== Biopython Bio.Align.bigbed Demo ===") + let targets = [ + @src.BigBedTarget::create("chr1", 1000000) catch { + _ => abort("failed to create chr1") + }, + @src.BigBedTarget::create("chr2", 500000) catch { + _ => abort("failed to create chr2") + }, + ] + let records = [ + @src.BigBedRecord::create( + "chr1", + 100, + 280, + name="transcript-A", + score=960, + strand="+", + thick_start=120, + thick_end=260, + item_rgb="40,120,220", + block_count=3, + block_sizes=[50, 40, 30], + block_starts=[0, 80, 150], + extra_fields=["GENE1"], + ) catch { + _ => abort("failed to create transcript-A") + }, + @src.BigBedRecord::create( + "chr1", + 250, + 410, + name="transcript-B", + score=870, + strand="-", + thick_start=270, + thick_end=390, + item_rgb="220,80,80", + block_count=2, + block_sizes=[60, 50], + block_starts=[0, 110], + extra_fields=["GENE1"], + ) catch { + _ => abort("failed to create transcript-B") + }, + @src.BigBedRecord::create( + "chr2", + 1000, + 1120, + name="transcript-C", + score=700, + strand="+", + block_count=2, + block_sizes=[45, 50], + block_starts=[0, 70], + extra_fields=["GENE2"], + ) catch { + _ => abort("failed to create transcript-C") + }, + ] + let gene_field = @src.BigBedField::create( + "string", + "gene", + comment="Gene identifier", + ) catch { + _ => abort("failed to create custom AutoSQL field") + } + let config = @src.BigBedWriteConfig::create( + bed_columns=12, + items_per_slot=2, + block_size=2, + compress=true, + schema_name="transcripts", + schema_comment="Indexed transcript annotations", + custom_fields=[gene_field], + ) catch { + _ => abort("failed to create BigBed configuration") + } + + println("\n1. Write and parse a compressed BigBed v4 stream") + let bytes = @src.bigbed_write(targets, records, config~) catch { + _ => abort("failed to write BigBed") + } + let file = @src.bigbed_parse(bytes) catch { + _ => abort("failed to parse BigBed") + } + println(" bytes=" + bytes.length().to_string()) + let summary = file.summary() catch { + _ => abort("failed to summarize BigBed") + } + println( + " records=\{summary.record_count}, targets=\{summary.target_count}, blocks=\{summary.data_block_count}, covered bases=\{summary.covered_bases}, compressed=\{summary.compressed}", + ) + + println("\n2. Inspect the embedded AutoSQL schema") + println(file.schema.to_auto_sql()) + + println("3. Query an overlapping chromosome interval through the R-tree") + let hits = file.search("chr1", start=240, end=300) catch { + _ => abort("failed to search BigBed") + } + for hit in hits { + let gene = match + hit.annotation(file.schema, "gene", file.header.defined_field_count) { + Some(value) => value + None => "missing" + } + println( + " " + + hit.name + + " " + + hit.chrom + + ":" + + hit.chrom_start.to_string() + + "-" + + hit.chrom_end.to_string() + + " gene=" + + gene, + ) + } + + println("\n4. Recover exon-aware reverse-strand coordinates") + let reverse = file.find_by_name("transcript-B") catch { + _ => abort("failed to query transcript name") + } + println( + " target/query path=" + format_coordinate_path(reverse[0].coordinates()), + ) + + println("\n5. Export records as BED text") + println(file.to_bed() catch { _ => abort("failed to export BED") }) + + println("\n6. Diagnose a damaged BigBed header") + let damaged = bytes.copy() + damaged[0] = 0 + try { + ignore(@src.bigbed_parse(damaged)) + abort("damaged BigBed unexpectedly parsed") + } catch { + BigBedError(message) => println(" rejected: " + message) + } + + println("\n=== Demo Complete ===") +} diff --git a/examples/bigbed_demo/moon.pkg b/examples/bigbed_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/bigbed_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/bigbed.mbt b/src/bigbed.mbt new file mode 100644 index 00000000..eb373646 --- /dev/null +++ b/src/bigbed.mbt @@ -0,0 +1,2475 @@ +// Bio.Align.bigbed - indexed UCSC BigBed records and interval queries. +// +// The implementation follows the BigBed version 4 binary layout used by +// Biopython: a chromosome B+ tree, binary BED data blocks, and an R-tree +// interval index. Writers use standards-compliant zlib stored blocks so the +// output remains deterministic without requiring a native compression library. + +///| +pub suberror BigBedError { + BigBedError(String) +} + +///| +pub struct BigBedField { + as_type : String + name : String + comment : String +} derive(Eq, Debug) + +///| +pub struct BigBedSchema { + name : String + comment : String + fields : Array[BigBedField] +} derive(Eq, Debug) + +///| +pub struct BigBedTarget { + name : String + length : Int +} derive(Eq, Debug) + +///| +pub struct BigBedRecord { + chrom : String + chrom_start : Int + chrom_end : Int + name : String + score : Int + strand : String + thick_start : Int + thick_end : Int + item_rgb : String + declared_block_count : Int + block_sizes : Array[Int] + block_starts : Array[Int] + extra_fields : Array[String] +} derive(Eq, Debug) + +///| +pub struct BigBedWriteConfig { + bed_columns : Int + items_per_slot : Int + block_size : Int + compress : Bool + schema_name : String + schema_comment : String + custom_fields : Array[BigBedField] +} derive(Eq, Debug) + +///| +pub struct BigBedHeader { + little_endian : Bool + version : Int + zoom_levels : Int + chromosome_tree_offset : Int + full_data_offset : Int + full_index_offset : Int + field_count : Int + defined_field_count : Int + auto_sql_offset : Int + total_summary_offset : Int + uncompress_buffer_size : Int + extra_indices_offset : Int +} derive(Eq, Debug) + +///| +pub struct BigBedBlockIndex { + start_chrom : Int + start_base : Int + end_chrom : Int + end_base : Int + data_offset : Int + data_size : Int +} derive(Eq, Debug) + +///| +pub struct BigBedSummary { + record_count : Int + target_count : Int + data_block_count : Int + covered_bases : Int + minimum_span : Int + maximum_span : Int + compressed : Bool +} derive(Eq, Debug) + +///| +pub struct BigBedFile { + header : BigBedHeader + schema : BigBedSchema + targets : Array[BigBedTarget] + source : Array[Int] + blocks : Array[BigBedBlockIndex] + record_count : Int +} + +///| +enum BigBedEndian { + BigBedLittleEndian + BigBedBigEndian +} derive(Eq) + +///| +let bigbed_magic : Int = 0x8789F2EB + +///| +let bigbed_version : Int = 4 + +///| +let bigbed_chrom_tree_magic : Int = 0x78CA8C91 + +///| +let bigbed_rtree_magic : Int = 0x2468ACE0 + +///| +let bigbed_standard_names : Array[String] = [ + "chrom", "chromStart", "chromEnd", "name", "score", "strand", "thickStart", "thickEnd", + "reserved", "blockCount", "blockSizes", "chromStarts", +] + +///| +let bigbed_standard_types : Array[String] = [ + "string", "uint", "uint", "string", "uint", "char[1]", "uint", "uint", "uint", + "int", "int[blockCount]", "int[blockCount]", +] + +///| +let bigbed_standard_comments : Array[String] = [ + "Reference sequence chromosome or scaffold", "Start position in chromosome", "End position in chromosome", + "Name of item.", "Score (0-1000)", "+ or - for strand", "Start of where display should be thick", + "End of where display should be thick", "Used as itemRgb", "Number of blocks", + "Comma separated list of block sizes", "Start positions relative to chromStart", +] + +///| +fn bigbed_fail(message : String) -> Unit raise BigBedError { + raise BigBedError(message) +} + +///| +fn bigbed_is_supported_type(as_type : String) -> Bool { + let base = if contains(as_type, "[") { + let mut end = 0 + while end < as_type.length() && + as_type.unsafe_get(end).to_int() != '['.to_int() { + end = end + 1 + } + as_type[0:end].to_owned() + } else { + as_type + } + base == "int" || + base == "uint" || + base == "short" || + base == "ushort" || + base == "byte" || + base == "ubyte" || + base == "float" || + base == "char" || + base == "string" || + base == "lstring" +} + +///| +fn bigbed_validate_text( + value : String, + label : String, +) -> Unit raise BigBedError { + for i in 0.. BigBedField raise BigBedError { + if !bigbed_is_supported_type(as_type) { + bigbed_fail("Unsupported AutoSQL field type '" + as_type + "'") + } + if name.length() == 0 { + bigbed_fail("AutoSQL field name must not be empty") + } + bigbed_validate_text(name, "AutoSQL field name") + BigBedField::{ as_type, name, comment } +} + +///| +fn bigbed_standard_fields(count : Int) -> Array[BigBedField] { + let fields : Array[BigBedField] = [] + for i in 0.. BigBedSchema raise BigBedError { + if name.length() == 0 { + bigbed_fail("AutoSQL table name must not be empty") + } + if fields.length() < 3 { + bigbed_fail("AutoSQL schema must contain at least three fields") + } + let seen : Map[String, Bool] = Map([]) + for field in fields { + if seen.contains(field.name) { + bigbed_fail("Duplicate AutoSQL field '" + field.name + "'") + } + seen[field.name] = true + } + BigBedSchema::{ name, comment, fields: fields.copy() } +} + +///| +pub fn BigBedSchema::default( + bed_columns? : Int = 12, +) -> BigBedSchema raise BigBedError { + if bed_columns < 3 || bed_columns > 12 { + bigbed_fail("BED column count must be between 3 and 12") + } + BigBedSchema::{ + name: "bed", + comment: "Browser Extensible Data", + fields: bigbed_standard_fields(bed_columns), + } +} + +///| +pub fn BigBedTarget::create( + name : String, + length : Int, +) -> BigBedTarget raise BigBedError { + if name.length() == 0 { + bigbed_fail("BigBed target name must not be empty") + } + bigbed_validate_text(name, "BigBed target name") + if length <= 0 { + bigbed_fail("BigBed target length must be positive") + } + BigBedTarget::{ name, length } +} + +///| +fn bigbed_validate_blocks( + span : Int, + sizes : Array[Int], + starts : Array[Int], +) -> Unit raise BigBedError { + if sizes.length() != starts.length() { + bigbed_fail("BED block sizes and starts must have equal lengths") + } + if sizes.length() == 0 { + return + } + if starts[0] != 0 { + bigbed_fail("The first BED block must start at chromStart") + } + let mut previous_end = 0 + for i in 0.. span { + bigbed_fail("BED block extends beyond chromEnd") + } + previous_end = block_end + } + if previous_end != span { + bigbed_fail("The last BED block must end at chromEnd") + } +} + +///| +pub fn BigBedRecord::create( + chrom : String, + chrom_start : Int, + chrom_end : Int, + name? : String = ".", + score? : Int = 0, + strand? : String = ".", + thick_start? : Int = -1, + thick_end? : Int = -1, + item_rgb? : String = "0", + block_count? : Int = -1, + block_sizes? : Array[Int] = [], + block_starts? : Array[Int] = [], + extra_fields? : Array[String] = [], +) -> BigBedRecord raise BigBedError { + if chrom.length() == 0 { + bigbed_fail("BED chromosome must not be empty") + } + bigbed_validate_text(chrom, "BED chromosome") + if chrom_start < 0 || chrom_end <= chrom_start { + bigbed_fail("BED coordinates must define a positive half-open interval") + } + if score < 0 || score > 1000 { + bigbed_fail("BED score must be between 0 and 1000") + } + if strand != "+" && strand != "-" && strand != "." { + bigbed_fail("BED strand must be '+', '-', or '.'") + } + bigbed_validate_text(name, "BED name") + bigbed_validate_text(item_rgb, "BED itemRgb") + for value in extra_fields { + bigbed_validate_text(value, "BigBed custom field") + } + let normalized_thick_start = if thick_start < 0 { + chrom_start + } else { + thick_start + } + let normalized_thick_end = if thick_end < 0 { chrom_end } else { thick_end } + if normalized_thick_start < chrom_start || + normalized_thick_start > normalized_thick_end || + normalized_thick_end > chrom_end { + bigbed_fail("BED thick interval must lie inside the record interval") + } + let normalized_block_count = if block_count < 0 { + block_sizes.length() + } else { + block_count + } + if normalized_block_count < 0 { + bigbed_fail("BED block count must not be negative") + } + if block_sizes.length() > 0 && block_sizes.length() != normalized_block_count { + bigbed_fail("BED block count does not match block sizes") + } + if block_starts.length() > 0 && + block_starts.length() != normalized_block_count { + bigbed_fail("BED block count does not match block starts") + } + if block_starts.length() > 0 && block_sizes.length() == 0 { + bigbed_fail("BED block starts require corresponding block sizes") + } + if block_sizes.length() > 0 && block_starts.length() > 0 { + bigbed_validate_blocks(chrom_end - chrom_start, block_sizes, block_starts) + } + BigBedRecord::{ + chrom, + chrom_start, + chrom_end, + name, + score, + strand, + thick_start: normalized_thick_start, + thick_end: normalized_thick_end, + item_rgb, + declared_block_count: normalized_block_count, + block_sizes: block_sizes.copy(), + block_starts: block_starts.copy(), + extra_fields: extra_fields.copy(), + } +} + +///| +pub fn BigBedWriteConfig::create( + bed_columns? : Int = 12, + items_per_slot? : Int = 512, + block_size? : Int = 256, + compress? : Bool = true, + schema_name? : String = "bed", + schema_comment? : String = "Browser Extensible Data", + custom_fields? : Array[BigBedField] = [], +) -> BigBedWriteConfig raise BigBedError { + if bed_columns < 3 || bed_columns > 12 { + bigbed_fail("BED column count must be between 3 and 12") + } + if items_per_slot <= 0 || items_per_slot > 65535 { + bigbed_fail("BigBed itemsPerSlot must be between 1 and 65535") + } + if block_size < 2 || block_size > 65535 { + bigbed_fail("BigBed blockSize must be between 2 and 65535") + } + let fields = bigbed_standard_fields(bed_columns) + for custom in custom_fields { + for standard in fields { + if standard.name == custom.name { + bigbed_fail( + "Custom AutoSQL field duplicates standard field '" + custom.name + "'", + ) + } + } + } + ignore( + BigBedSchema::create( + schema_name, + schema_comment, + { + let all = fields.copy() + for field in custom_fields { + all.push(field) + } + all + }, + ), + ) + BigBedWriteConfig::{ + bed_columns, + items_per_slot, + block_size, + compress, + schema_name, + schema_comment, + custom_fields: custom_fields.copy(), + } +} + +///| +pub fn BigBedWriteConfig::default() -> BigBedWriteConfig { + BigBedWriteConfig::{ + bed_columns: 12, + items_per_slot: 512, + block_size: 256, + compress: true, + schema_name: "bed", + schema_comment: "Browser Extensible Data", + custom_fields: [], + } +} + +///| +pub fn BigBedRecord::span(self : BigBedRecord) -> Int { + self.chrom_end - self.chrom_start +} + +///| +pub fn BigBedRecord::block_count(self : BigBedRecord) -> Int { + self.declared_block_count +} + +///| +pub fn BigBedRecord::query_size(self : BigBedRecord) -> Int { + if self.block_sizes.length() == 0 || + self.block_sizes.length() != self.block_starts.length() { + self.span() + } else { + let mut total = 0 + for size in self.block_sizes { + total = total + size + } + total + } +} + +///| +pub fn BigBedRecord::overlaps( + self : BigBedRecord, + chromosome : String, + start : Int, + end : Int, +) -> Bool { + self.chrom == chromosome && self.chrom_start < end && start < self.chrom_end +} + +///| +pub fn BigBedRecord::coordinates(self : BigBedRecord) -> Array[Array[Int]] { + let target : Array[Int] = [] + let query : Array[Int] = [] + let query_size = self.query_size() + if self.block_sizes.length() == 0 || + self.block_sizes.length() != self.block_starts.length() { + target.push(self.chrom_start) + target.push(self.chrom_end) + query.push(0) + query.push(query_size) + } else { + let mut query_position = 0 + for i in 0.. String? { + for i in 0.. String { + let builder = StringBuilder::new() + for i in 0.. String { + let output = StringBuilder::new() + output.write_string("table " + self.name + "\n") + output.write_string("\"" + bigbed_escape_auto_sql(self.comment) + "\"\n") + output.write_string("(\n") + for field in self.fields { + output.write_string( + " " + + field.as_type + + " " + + field.name + + "; \"" + + bigbed_escape_auto_sql(field.comment) + + "\"\n", + ) + } + output.write_string(")\n") + output.to_string() +} + +///| +fn bigbed_find_byte(text : String, code : Int, start : Int) -> Int { + for i in start.. String raise BigBedError { + let first = bigbed_find_byte(text, '"'.to_int(), 0) + if first < 0 { + bigbed_fail("Expected quoted AutoSQL text") + } + let second = bigbed_find_byte(text, '"'.to_int(), first + 1) + if second < 0 { + bigbed_fail("Unterminated quoted AutoSQL text") + } + text[first + 1:second].to_owned() +} + +///| +pub fn bigbed_parse_auto_sql(text : String) -> BigBedSchema raise BigBedError { + let lines = text.split("\n").to_array() + let mut table_name = "" + let mut table_comment = "" + let fields : Array[BigBedField] = [] + let mut saw_table = false + let mut in_fields = false + for raw in lines { + let line = trim(raw.to_owned()) + if line.length() == 0 { + continue + } + if !saw_table { + let words = split_by_char(line, ' '.to_int()) + if words.length() < 2 || words[0] != "table" { + bigbed_fail("AutoSQL declaration must start with 'table'") + } + table_name = words[1] + saw_table = true + continue + } + if table_comment.length() == 0 && !in_fields { + if line == "(" { + in_fields = true + } else { + table_comment = bigbed_quoted_value(line) + } + continue + } + if line == "(" { + in_fields = true + continue + } + if line == ")" { + in_fields = false + continue + } + if in_fields { + let semicolon = bigbed_find_byte(line, ';'.to_int(), 0) + if semicolon < 0 { + bigbed_fail("AutoSQL field declaration is missing ';'") + } + let definition = trim(line[0:semicolon].to_owned()) + let words = split_by_char(definition, ' '.to_int()) + let compact : Array[String] = [] + for word in words { + if word.length() > 0 { + compact.push(word) + } + } + if compact.length() != 2 { + bigbed_fail("AutoSQL field requires a type and name") + } + fields.push( + BigBedField::create( + compact[0], + compact[1], + comment=bigbed_quoted_value(line), + ), + ) + } + } + if !saw_table || in_fields || fields.length() == 0 { + bigbed_fail("Incomplete AutoSQL declaration") + } + BigBedSchema::create(table_name, table_comment, fields) +} + +///| +fn bigbed_check_range( + data : Array[Int], + position : Int, + size : Int, + label : String, +) -> Unit raise BigBedError { + if position < 0 || size < 0 || position > data.length() - size { + bigbed_fail("Truncated BigBed " + label) + } +} + +///| +fn bigbed_read_u16( + data : Array[Int], + position : Int, + endian : BigBedEndian, +) -> Int raise BigBedError { + bigbed_check_range(data, position, 2, "16-bit integer") + if endian == BigBedLittleEndian { + data[position] | (data[position + 1] << 8) + } else { + (data[position] << 8) | data[position + 1] + } +} + +///| +fn bigbed_read_u32( + data : Array[Int], + position : Int, + endian : BigBedEndian, +) -> Int raise BigBedError { + bigbed_check_range(data, position, 4, "32-bit integer") + if endian == BigBedLittleEndian { + data[position] | + (data[position + 1] << 8) | + (data[position + 2] << 16) | + (data[position + 3] << 24) + } else { + (data[position] << 24) | + (data[position + 1] << 16) | + (data[position + 2] << 8) | + data[position + 3] + } +} + +///| +fn bigbed_read_u64_local( + data : Array[Int], + position : Int, + endian : BigBedEndian, +) -> Int raise BigBedError { + let low_position = if endian == BigBedLittleEndian { + position + } else { + position + 4 + } + let high_position = if endian == BigBedLittleEndian { + position + 4 + } else { + position + } + let low = bigbed_read_u32(data, low_position, endian) + let high = bigbed_read_u32(data, high_position, endian) + if high != 0 || low < 0 { + bigbed_fail("BigBed offset or count exceeds the local Int range") + } + low +} + +///| +fn bigbed_push_u16(output : Array[Int], value : Int) -> Unit { + output.push(value & 0xFF) + output.push((value >> 8) & 0xFF) +} + +///| +fn bigbed_push_u32(output : Array[Int], value : Int) -> Unit { + output.push(value & 0xFF) + output.push((value >> 8) & 0xFF) + output.push((value >> 16) & 0xFF) + output.push((value >> 24) & 0xFF) +} + +///| +fn bigbed_push_u64_local(output : Array[Int], value : Int) -> Unit { + bigbed_push_u32(output, value) + bigbed_push_u32(output, 0) +} + +///| +fn bigbed_patch_u16(output : Array[Int], position : Int, value : Int) -> Unit { + output[position] = value & 0xFF + output[position + 1] = (value >> 8) & 0xFF +} + +///| +fn bigbed_patch_u32(output : Array[Int], position : Int, value : Int) -> Unit { + output[position] = value & 0xFF + output[position + 1] = (value >> 8) & 0xFF + output[position + 2] = (value >> 16) & 0xFF + output[position + 3] = (value >> 24) & 0xFF +} + +///| +fn bigbed_patch_u64_local( + output : Array[Int], + position : Int, + value : Int, +) -> Unit { + bigbed_patch_u32(output, position, value) + bigbed_patch_u32(output, position + 4, 0) +} + +///| +fn bigbed_push_text(output : Array[Int], value : String) -> Unit { + for i in 0.. String raise BigBedError { + bigbed_check_range(data, start, end - start, "text") + let builder = StringBuilder::new() + for i in start.. (String, Int) raise BigBedError { + if start < 0 || limit > data.length() || start >= limit { + bigbed_fail("Invalid BigBed string bounds") + } + let mut end = start + while end < limit && data[end] != 0 { + end = end + 1 + } + if end >= limit { + bigbed_fail("Unterminated BigBed string") + } + (bigbed_read_text(data, start, end), end + 1) +} + +///| +fn bigbed_parse_nonnegative_int( + value : String, + label : String, +) -> Int raise BigBedError { + if value.length() == 0 { + bigbed_fail("Missing integer for " + label) + } + let mut result = 0 + for i in 0.. '9'.to_int() { + bigbed_fail("Invalid integer '" + value + "' for " + label) + } + let digit = code - '0'.to_int() + if result > 214748364 || (result == 214748364 && digit > 7) { + bigbed_fail("Integer for " + label + " exceeds the local Int range") + } + result = result * 10 + digit + } + result +} + +///| +fn bigbed_parse_csv_ints( + value : String, + label : String, +) -> Array[Int] raise BigBedError { + let values : Array[Int] = [] + for word in split_by_char(value, ','.to_int()) { + if word.length() > 0 { + values.push(bigbed_parse_nonnegative_int(word, label)) + } + } + values +} + +///| +fn bigbed_csv(values : Array[Int]) -> String { + let output = StringBuilder::new() + for value in values { + output.write_string(value.to_string()) + output.write_string(",") + } + output.to_string() +} + +///| +fn bigbed_schema_for_config( + config : BigBedWriteConfig, +) -> BigBedSchema raise BigBedError { + let fields = bigbed_standard_fields(config.bed_columns) + for field in config.custom_fields { + fields.push(field) + } + BigBedSchema::create(config.schema_name, config.schema_comment, fields) +} + +///| +fn bigbed_validate_schema( + schema : BigBedSchema, + defined_fields : Int, +) -> Unit raise BigBedError { + if schema.fields.length() < defined_fields { + bigbed_fail("AutoSQL schema has fewer fields than the BigBed header") + } + for i in 0.. Int { + for i in 0.. Unit raise BigBedError { + if targets.length() == 0 { + bigbed_fail("BigBed requires at least one target sequence") + } + let seen : Map[String, Bool] = Map([]) + for target in targets { + ignore(BigBedTarget::create(target.name, target.length)) + if seen.contains(target.name) { + bigbed_fail("Duplicate BigBed target '" + target.name + "'") + } + seen[target.name] = true + } + let mut previous_chrom = -1 + let mut previous_start = -1 + for i in 0.. targets[chrom_id].length { + bigbed_fail( + "Record " + i.to_string() + " extends beyond its target sequence", + ) + } + if chrom_id < previous_chrom || + (chrom_id == previous_chrom && record.chrom_start < previous_start) { + bigbed_fail("BigBed records must be sorted by target and start") + } + if config.bed_columns >= 10 && record.declared_block_count <= 0 { + bigbed_fail("BED10-BED12 records require at least one block") + } + if config.bed_columns >= 11 && + record.block_sizes.length() != record.declared_block_count { + bigbed_fail("BED11-BED12 block count must match blockSizes") + } + if config.bed_columns >= 12 && + record.block_starts.length() != record.declared_block_count { + bigbed_fail("BED12 block count must match chromStarts") + } + if record.extra_fields.length() != config.custom_fields.length() { + bigbed_fail( + "Record " + i.to_string() + " has an incorrect number of custom fields", + ) + } + previous_chrom = chrom_id + previous_start = record.chrom_start + } +} + +///| +fn bigbed_rest_fields( + record : BigBedRecord, + bed_columns : Int, +) -> Array[String] { + let fields : Array[String] = [] + if bed_columns >= 4 { + fields.push(record.name) + } + if bed_columns >= 5 { + fields.push(record.score.to_string()) + } + if bed_columns >= 6 { + fields.push(record.strand) + } + if bed_columns >= 7 { + fields.push(record.thick_start.to_string()) + } + if bed_columns >= 8 { + fields.push(record.thick_end.to_string()) + } + if bed_columns >= 9 { + fields.push(record.item_rgb) + } + if bed_columns >= 10 { + fields.push(record.declared_block_count.to_string()) + } + if bed_columns >= 11 { + fields.push(bigbed_csv(record.block_sizes)) + } + if bed_columns >= 12 { + fields.push(bigbed_csv(record.block_starts)) + } + for value in record.extra_fields { + fields.push(value) + } + fields +} + +///| +fn bigbed_join_tabs(fields : Array[String]) -> String { + let output = StringBuilder::new() + for i in 0.. 0 { + output.write_string("\t") + } + output.write_string(fields[i]) + } + output.to_string() +} + +///| +fn bigbed_record_bytes( + record : BigBedRecord, + chrom_id : Int, + bed_columns : Int, +) -> Array[Int] { + let output : Array[Int] = [] + bigbed_push_u32(output, chrom_id) + bigbed_push_u32(output, record.chrom_start) + bigbed_push_u32(output, record.chrom_end) + bigbed_push_text( + output, + bigbed_join_tabs(bigbed_rest_fields(record, bed_columns)), + ) + output.push(0) + output +} + +///| +fn bigbed_adler32(data : Array[Int]) -> Int { + let mut a = 1 + let mut b = 0 + for byte in data { + a = (a + (byte & 0xFF)) % 65521 + b = (b + a) % 65521 + } + (b << 16) | a +} + +///| +struct BigBedBitReader { + data : Array[Int] + bit_position : Int + bit_limit : Int +} + +///| +struct BigBedHuffman { + counts : Array[Int] + symbols : Array[Int] +} + +///| +let bigbed_length_base : Array[Int] = [ + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, + 99, 115, 131, 163, 195, 227, 258, +] + +///| +let bigbed_length_extra : Array[Int] = [ + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, + 5, 0, +] + +///| +let bigbed_distance_base : Array[Int] = [ + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, + 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, +] + +///| +let bigbed_distance_extra : Array[Int] = [ + 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, + 12, 12, 13, 13, +] + +///| +fn bigbed_read_deflate_bits( + reader : BigBedBitReader, + count : Int, +) -> (Int, BigBedBitReader) raise BigBedError { + if count < 0 || count > 24 { + bigbed_fail("Invalid DEFLATE bit count") + } + if reader.bit_position + count > reader.bit_limit { + bigbed_fail("Truncated DEFLATE stream in BigBed data block") + } + let mut value = 0 + for i in 0..> (position % 8)) & 1 + value = value | (bit << i) + } + ( + value, + BigBedBitReader::{ + data: reader.data, + bit_position: reader.bit_position + count, + bit_limit: reader.bit_limit, + }, + ) +} + +///| +fn bigbed_align_deflate_reader( + reader : BigBedBitReader, +) -> BigBedBitReader raise BigBedError { + let aligned = (reader.bit_position + 7) / 8 * 8 + if aligned > reader.bit_limit { + bigbed_fail("Truncated DEFLATE byte alignment") + } + BigBedBitReader::{ + data: reader.data, + bit_position: aligned, + bit_limit: reader.bit_limit, + } +} + +///| +fn bigbed_build_huffman( + lengths : Array[Int], + label : String, +) -> BigBedHuffman raise BigBedError { + let counts : Array[Int] = Array::make(16, 0) + for length in lengths { + if length < 0 || length > 15 { + bigbed_fail("Invalid " + label + " Huffman code length") + } + counts[length] = counts[length] + 1 + } + if counts[0] == lengths.length() { + bigbed_fail("Empty " + label + " Huffman tree") + } + let mut remaining = 1 + for bits in 1..<16 { + remaining = (remaining << 1) - counts[bits] + if remaining < 0 { + bigbed_fail("Oversubscribed " + label + " Huffman tree") + } + } + let offsets : Array[Int] = Array::make(16, 0) + for bits in 1..<15 { + offsets[bits + 1] = offsets[bits] + counts[bits] + } + let next = offsets.copy() + let symbols : Array[Int] = Array::make(lengths.length() - counts[0], 0) + for symbol in 0.. 0 { + symbols[next[length]] = symbol + next[length] = next[length] + 1 + } + } + BigBedHuffman::{ counts, symbols } +} + +///| +fn bigbed_decode_huffman_symbol( + tree : BigBedHuffman, + input : BigBedBitReader, +) -> (Int, BigBedBitReader) raise BigBedError { + let mut reader = input + let mut code = 0 + let mut first = 0 + let mut index = 0 + for length in 1..<16 { + let (bit, next) = bigbed_read_deflate_bits(reader, 1) + reader = next + code = code | bit + let count = tree.counts[length] + if code < first + count { + let symbol_index = index + code - first + if symbol_index < 0 || symbol_index >= tree.symbols.length() { + bigbed_fail("Invalid canonical Huffman symbol index") + } + return (tree.symbols[symbol_index], reader) + } + index = index + count + first = (first + count) << 1 + code = code << 1 + } + bigbed_fail("Invalid Huffman code in BigBed DEFLATE stream") + (0, reader) +} + +///| +fn bigbed_fixed_huffman() -> (BigBedHuffman, BigBedHuffman) raise BigBedError { + let literal_lengths : Array[Int] = Array::make(288, 0) + for i in 0..<144 { + literal_lengths[i] = 8 + } + for i in 144..<256 { + literal_lengths[i] = 9 + } + for i in 256..<280 { + literal_lengths[i] = 7 + } + for i in 280..<288 { + literal_lengths[i] = 8 + } + let distance_lengths : Array[Int] = Array::make(32, 5) + ( + bigbed_build_huffman(literal_lengths, "fixed literal/length"), + bigbed_build_huffman(distance_lengths, "fixed distance"), + ) +} + +///| +fn bigbed_dynamic_huffman( + input : BigBedBitReader, +) -> (BigBedHuffman, BigBedHuffman, BigBedBitReader) raise BigBedError { + let mut reader = input + let (literal_bits, next) = bigbed_read_deflate_bits(reader, 5) + reader = next + let literal_count = literal_bits + 257 + let (distance_bits, next) = bigbed_read_deflate_bits(reader, 5) + reader = next + let distance_count = distance_bits + 1 + let (code_bits, next) = bigbed_read_deflate_bits(reader, 4) + reader = next + let code_count = code_bits + 4 + if literal_count > 286 || distance_count > 32 { + bigbed_fail("Invalid dynamic DEFLATE tree dimensions") + } + let code_order = [ + 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15, + ] + let code_lengths : Array[Int] = Array::make(19, 0) + for i in 0.. total { + bigbed_fail("DEFLATE code-length repeat exceeds its tree") + } + let previous = lengths[position - 1] + for _ in 0.. total { + bigbed_fail("DEFLATE zero repeat exceeds its tree") + } + position = position + repeat + } else if symbol == 18 { + let (extra, next) = bigbed_read_deflate_bits(reader, 7) + reader = next + let repeat = extra + 11 + if position + repeat > total { + bigbed_fail("DEFLATE long zero repeat exceeds its tree") + } + position = position + repeat + } else { + bigbed_fail("Invalid DEFLATE code-length symbol") + } + } + let literal_lengths : Array[Int] = [] + for i in 0.. BigBedBitReader raise BigBedError { + let mut reader = input + let mut done = false + while !done { + let (symbol, next) = bigbed_decode_huffman_symbol(literal_tree, reader) + reader = next + if symbol < 256 { + if output.length() >= maximum_output { + bigbed_fail("BigBed data block exceeds the declared buffer size") + } + output.push(symbol) + } else if symbol == 256 { + done = true + } else { + if symbol < 257 || symbol > 285 { + bigbed_fail("Invalid DEFLATE length symbol") + } + let length_index = symbol - 257 + let (length_extra, next) = bigbed_read_deflate_bits( + reader, + bigbed_length_extra[length_index], + ) + reader = next + let length = bigbed_length_base[length_index] + length_extra + let (distance_symbol, next) = bigbed_decode_huffman_symbol( + distance_tree, reader, + ) + reader = next + if distance_symbol < 0 || distance_symbol >= 30 { + bigbed_fail("Invalid DEFLATE distance symbol") + } + let (distance_extra, next) = bigbed_read_deflate_bits( + reader, + bigbed_distance_extra[distance_symbol], + ) + reader = next + let distance = bigbed_distance_base[distance_symbol] + distance_extra + if distance <= 0 || distance > output.length() || distance > 32768 { + bigbed_fail("Invalid LZ77 distance in BigBed DEFLATE stream") + } + if output.length() + length > maximum_output { + bigbed_fail("BigBed data block exceeds the declared buffer size") + } + for _ in 0.. Array[Int] { + let output : Array[Int] = [0x78, 0x01] + let mut position = 0 + if data.length() == 0 { + output.push(1) + bigbed_push_u16(output, 0) + bigbed_push_u16(output, 0xFFFF) + } + while position < data.length() { + let remaining = data.length() - position + let size = if remaining > 65535 { 65535 } else { remaining } + let final_block = position + size == data.length() + output.push(if final_block { 1 } else { 0 }) + bigbed_push_u16(output, size) + bigbed_push_u16(output, size ^ 0xFFFF) + for i in position..<(position + size) { + output.push(data[i]) + } + position = position + size + } + let checksum = bigbed_adler32(data) + output.push((checksum >> 24) & 0xFF) + output.push((checksum >> 16) & 0xFF) + output.push((checksum >> 8) & 0xFF) + output.push(checksum & 0xFF) + output +} + +///| +fn bigbed_zlib_unstore( + data : Array[Int], + maximum_output : Int, +) -> Array[Int] raise BigBedError { + if data.length() < 8 { + bigbed_fail("Truncated zlib data block") + } + let cmf = data[0] + let flags = data[1] + if (cmf & 0x0F) != 8 || cmf >> 4 > 7 || ((cmf << 8) | flags) % 31 != 0 { + bigbed_fail("Invalid zlib header in BigBed data block") + } + if (flags & 0x20) != 0 { + bigbed_fail("Preset zlib dictionaries are not supported") + } + let payload_end = data.length() - 4 + let output : Array[Int] = [] + let mut reader = BigBedBitReader::{ + data, + bit_position: 16, + bit_limit: payload_end * 8, + } + let mut done = false + while !done { + let (final_block, next) = bigbed_read_deflate_bits(reader, 1) + reader = next + let (block_type, next) = bigbed_read_deflate_bits(reader, 2) + reader = next + done = final_block == 1 + if block_type == 0 { + reader = bigbed_align_deflate_reader(reader) + let (size, next) = bigbed_read_deflate_bits(reader, 16) + reader = next + let (inverse, next) = bigbed_read_deflate_bits(reader, 16) + reader = next + if (size ^ 0xFFFF) != inverse { + bigbed_fail("Invalid stored DEFLATE block length") + } + if output.length() + size > maximum_output { + bigbed_fail("BigBed data block exceeds the declared buffer size") + } + for _ in 0.. Unit { + for byte in source { + output.push(byte) + } +} + +///| +fn bigbed_patch_header( + output : Array[Int], + chromosome_tree_offset : Int, + full_data_offset : Int, + full_index_offset : Int, + field_count : Int, + defined_field_count : Int, + auto_sql_offset : Int, + total_summary_offset : Int, + uncompress_buffer_size : Int, +) -> Unit { + bigbed_patch_u32(output, 0, bigbed_magic) + bigbed_patch_u16(output, 4, bigbed_version) + bigbed_patch_u16(output, 6, 0) + bigbed_patch_u64_local(output, 8, chromosome_tree_offset) + bigbed_patch_u64_local(output, 16, full_data_offset) + bigbed_patch_u64_local(output, 24, full_index_offset) + bigbed_patch_u16(output, 32, field_count) + bigbed_patch_u16(output, 34, defined_field_count) + bigbed_patch_u64_local(output, 36, auto_sql_offset) + bigbed_patch_u64_local(output, 44, total_summary_offset) + bigbed_patch_u32(output, 52, uncompress_buffer_size) + bigbed_patch_u64_local(output, 56, 0) +} + +///| +fn bigbed_write_tree_key( + output : Array[Int], + key : String, + key_size : Int, +) -> Unit { + for i in 0.. Int { + let mut height = 1 + let mut capacity = block_size + while capacity < item_count { + capacity = if capacity > item_count / block_size { + item_count + } else { + capacity * block_size + } + height = height + 1 + } + height +} + +///| +fn bigbed_tree_capacity( + item_count : Int, + block_size : Int, + height : Int, +) -> Int { + let mut capacity = 1 + for _ in 0.. item_count / block_size { + item_count + } else { + capacity * block_size + } + } + capacity +} + +///| +fn bigbed_write_chrom_node( + output : Array[Int], + targets : Array[BigBedTarget], + order : Array[Int], + start : Int, + end : Int, + key_size : Int, + block_size : Int, + height : Int, +) -> Unit { + let count = end - start + if height == 1 { + output.push(1) + output.push(0) + bigbed_push_u16(output, count) + for position in start.. Unit { + let mut key_size = 1 + for target in targets { + if target.name.length() > key_size { + key_size = target.name.length() + } + } + let order : Array[Int] = [] + for i in 0.. Int { + if targets[left].name < targets[right].name { + -1 + } else if targets[left].name > targets[right].name { + 1 + } else { + 0 + } + }) + bigbed_push_u32(output, bigbed_chrom_tree_magic) + bigbed_push_u32(output, configured_block_size) + bigbed_push_u32(output, key_size) + bigbed_push_u32(output, 8) + bigbed_push_u64_local(output, targets.length()) + bigbed_push_u64_local(output, 0) + bigbed_write_chrom_node( + output, + targets, + order, + 0, + targets.length(), + key_size, + configured_block_size, + bigbed_tree_height(targets.length(), configured_block_size), + ) +} + +///| +fn bigbed_block_overlaps( + block : BigBedBlockIndex, + chrom_id : Int, + start : Int, + end : Int, +) -> Bool { + let starts_before_query_end = block.start_chrom < chrom_id || + (block.start_chrom == chrom_id && block.start_base < end) + let query_starts_before_block_end = chrom_id < block.end_chrom || + (chrom_id == block.end_chrom && start < block.end_base) + starts_before_query_end && query_starts_before_block_end +} + +///| +fn bigbed_rtree_end( + blocks : Array[BigBedBlockIndex], + start : Int, + end : Int, +) -> (Int, Int) { + let mut end_chrom = blocks[start].end_chrom + let mut end_base = blocks[start].end_base + for i in (start + 1).. end_chrom || + (block.end_chrom == end_chrom && block.end_base > end_base) { + end_chrom = block.end_chrom + end_base = block.end_base + } + } + (end_chrom, end_base) +} + +///| +fn bigbed_write_rtree_node( + output : Array[Int], + blocks : Array[BigBedBlockIndex], + start : Int, + end : Int, + block_size : Int, + height : Int, +) -> Unit { + let count = end - start + if height == 1 { + output.push(1) + output.push(0) + bigbed_push_u16(output, count) + for i in start.. Unit { + bigbed_push_u32(output, bigbed_rtree_magic) + bigbed_push_u32(output, configured_block_size) + bigbed_push_u64_local(output, item_count) + if blocks.length() == 0 { + for _ in 0..<4 { + bigbed_push_u32(output, 0) + } + } else { + bigbed_push_u32(output, blocks[0].start_chrom) + bigbed_push_u32(output, blocks[0].start_base) + let (end_chrom, end_base) = bigbed_rtree_end(blocks, 0, blocks.length()) + bigbed_push_u32(output, end_chrom) + bigbed_push_u32(output, end_base) + } + bigbed_push_u64_local(output, end_file_offset) + bigbed_push_u32(output, items_per_slot) + bigbed_push_u32(output, 0) + if blocks.length() == 0 { + output.push(1) + output.push(0) + bigbed_push_u16(output, 0) + } else { + bigbed_write_rtree_node( + output, + blocks, + 0, + blocks.length(), + configured_block_size, + bigbed_tree_height(blocks.length(), configured_block_size), + ) + } +} + +///| +pub fn bigbed_write( + targets : Array[BigBedTarget], + records : Array[BigBedRecord], + config? : BigBedWriteConfig = BigBedWriteConfig::default(), +) -> Array[Int] raise BigBedError { + bigbed_validate_records(targets, records, config) + let schema = bigbed_schema_for_config(config) + let output : Array[Int] = Array::make(64, 0) + let auto_sql_offset = output.length() + bigbed_push_text(output, schema.to_auto_sql()) + output.push(0) + let total_summary_offset = output.length() + for _ in 0..<40 { + output.push(0) + } + let chromosome_tree_offset = output.length() + bigbed_write_chrom_tree(output, targets, config.block_size) + let full_data_offset = output.length() + bigbed_push_u64_local(output, records.length()) + let blocks : Array[BigBedBlockIndex] = [] + let mut maximum_uncompressed = 0 + let mut record_index = 0 + while record_index < records.length() { + let block_start_index = record_index + let block_end_index = if record_index + config.items_per_slot < + records.length() { + record_index + config.items_per_slot + } else { + records.length() + } + let raw : Array[Int] = [] + while record_index < block_end_index { + let record = records[record_index] + let chrom_id = bigbed_target_index(targets, record.chrom) + bigbed_append( + raw, + bigbed_record_bytes(record, chrom_id, config.bed_columns), + ) + record_index = record_index + 1 + } + if raw.length() > maximum_uncompressed { + maximum_uncompressed = raw.length() + } + let payload = if config.compress { bigbed_zlib_store(raw) } else { raw } + let data_offset = output.length() + bigbed_append(output, payload) + let first = records[block_start_index] + let mut end_chrom = bigbed_target_index(targets, first.chrom) + let mut end_base = first.chrom_end + for i in (block_start_index + 1).. end_chrom || + (chrom_id == end_chrom && records[i].chrom_end > end_base) { + end_chrom = chrom_id + end_base = records[i].chrom_end + } + } + blocks.push(BigBedBlockIndex::{ + start_chrom: bigbed_target_index(targets, first.chrom), + start_base: first.chrom_start, + end_chrom, + end_base, + data_offset, + data_size: payload.length(), + }) + } + let full_index_offset = output.length() + bigbed_write_rtree( + output, + blocks, + config.block_size, + records.length(), + config.items_per_slot, + full_index_offset, + ) + bigbed_push_u32(output, bigbed_magic) + bigbed_patch_header( + output, + chromosome_tree_offset, + full_data_offset, + full_index_offset, + schema.fields.length(), + config.bed_columns, + auto_sql_offset, + total_summary_offset, + if config.compress { + maximum_uncompressed + } else { + 0 + }, + ) + output +} + +///| +fn bigbed_detect_endian(data : Array[Int]) -> BigBedEndian raise BigBedError { + if data.length() < 4 { + bigbed_fail("BigBed input is shorter than its magic number") + } + let little = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24) + if little == bigbed_magic { + BigBedLittleEndian + } else { + let big = (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3] + if big == bigbed_magic { + BigBedBigEndian + } else { + bigbed_fail("Input does not contain the BigBed magic number") + BigBedLittleEndian + } + } +} + +///| +fn bigbed_read_header( + data : Array[Int], +) -> (BigBedHeader, BigBedEndian) raise BigBedError { + bigbed_check_range(data, 0, 64, "header") + let endian = bigbed_detect_endian(data) + let version = bigbed_read_u16(data, 4, endian) + if version != bigbed_version { + bigbed_fail( + "Unsupported BigBed version " + + version.to_string() + + "; expected version 4", + ) + } + let defined = bigbed_read_u16(data, 34, endian) + if defined < 3 || defined > 12 { + bigbed_fail("BigBed defined field count must be between 3 and 12") + } + let field_count = bigbed_read_u16(data, 32, endian) + if field_count < defined { + bigbed_fail("BigBed field count is smaller than its BED field count") + } + let header = BigBedHeader::{ + little_endian: endian == BigBedLittleEndian, + version, + zoom_levels: bigbed_read_u16(data, 6, endian), + chromosome_tree_offset: bigbed_read_u64_local(data, 8, endian), + full_data_offset: bigbed_read_u64_local(data, 16, endian), + full_index_offset: bigbed_read_u64_local(data, 24, endian), + field_count, + defined_field_count: defined, + auto_sql_offset: bigbed_read_u64_local(data, 36, endian), + total_summary_offset: bigbed_read_u64_local(data, 44, endian), + uncompress_buffer_size: bigbed_read_u32(data, 52, endian), + extra_indices_offset: bigbed_read_u64_local(data, 56, endian), + } + if header.chromosome_tree_offset < 64 || + header.full_data_offset <= header.chromosome_tree_offset || + header.full_index_offset <= header.full_data_offset || + header.full_index_offset >= data.length() { + bigbed_fail("BigBed header contains invalid section offsets") + } + (header, endian) +} + +///| +fn bigbed_read_key( + data : Array[Int], + position : Int, + key_size : Int, +) -> String raise BigBedError { + bigbed_check_range(data, position, key_size, "B+ tree key") + let mut end = position + while end < position + key_size && data[end] != 0 { + end = end + 1 + } + bigbed_read_text(data, position, end) +} + +///| +fn bigbed_read_chrom_node( + data : Array[Int], + position : Int, + key_size : Int, + endian : BigBedEndian, + targets : Array[BigBedTarget?], + depth : Int, +) -> Unit raise BigBedError { + if depth > 64 { + bigbed_fail("BigBed chromosome B+ tree exceeds 64 levels") + } + bigbed_check_range(data, position, 4, "B+ tree node") + let is_leaf = data[position] != 0 + let count = bigbed_read_u16(data, position + 2, endian) + let mut cursor = position + 4 + if is_leaf { + for _ in 0..= targets.length() { + bigbed_fail("Chromosome B+ tree contains an invalid target ID") + } + if targets[chrom_id] is Some(_) { + bigbed_fail("Chromosome B+ tree contains a duplicate target ID") + } + targets[chrom_id] = Some(BigBedTarget::create(name, chrom_size)) + } + } else { + let children : Array[Int] = [] + for _ in 0.. Array[BigBedTarget] raise BigBedError { + bigbed_check_range(data, offset, 32, "chromosome B+ tree header") + if bigbed_read_u32(data, offset, endian) != bigbed_chrom_tree_magic { + bigbed_fail("Invalid BigBed chromosome B+ tree magic number") + } + let key_size = bigbed_read_u32(data, offset + 8, endian) + let value_size = bigbed_read_u32(data, offset + 12, endian) + let item_count = bigbed_read_u64_local(data, offset + 16, endian) + if key_size <= 0 || value_size != 8 || item_count <= 0 { + bigbed_fail("Invalid BigBed chromosome B+ tree dimensions") + } + let slots : Array[BigBedTarget?] = Array::make(item_count, None) + bigbed_read_chrom_node(data, offset + 32, key_size, endian, slots, 0) + let targets : Array[BigBedTarget] = [] + for slot in slots { + match slot { + Some(target) => targets.push(target) + None => bigbed_fail("Chromosome B+ tree is missing a target ID") + } + } + targets +} + +///| +fn bigbed_read_rtree_node( + data : Array[Int], + position : Int, + endian : BigBedEndian, + blocks : Array[BigBedBlockIndex], + depth : Int, +) -> Unit raise BigBedError { + if depth > 64 { + bigbed_fail("BigBed R-tree exceeds 64 levels") + } + bigbed_check_range(data, position, 4, "R-tree node") + let is_leaf = data[position] != 0 + let count = bigbed_read_u16(data, position + 2, endian) + let mut cursor = position + 4 + if is_leaf { + for _ in 0.. (Array[BigBedBlockIndex], Int) raise BigBedError { + bigbed_check_range(data, offset, 48, "R-tree header") + if bigbed_read_u32(data, offset, endian) != bigbed_rtree_magic { + bigbed_fail("Invalid BigBed R-tree magic number") + } + let indexed_count = bigbed_read_u64_local(data, offset + 8, endian) + let blocks : Array[BigBedBlockIndex] = [] + bigbed_read_rtree_node(data, offset + 48, endian, blocks, 0) + for block in blocks { + bigbed_check_range( + data, + block.data_offset, + block.data_size, + "indexed data block", + ) + } + (blocks, indexed_count) +} + +///| +fn bigbed_read_schema( + data : Array[Int], + header : BigBedHeader, +) -> BigBedSchema raise BigBedError { + if header.auto_sql_offset == 0 { + return BigBedSchema::default(bed_columns=header.defined_field_count) + } + if header.auto_sql_offset < 64 || + header.auto_sql_offset >= header.chromosome_tree_offset { + bigbed_fail("BigBed AutoSQL offset is outside the metadata section") + } + let (text, _) = bigbed_read_c_string( + data, + header.auto_sql_offset, + header.chromosome_tree_offset, + ) + let schema = bigbed_parse_auto_sql(text) + if schema.fields.length() != header.field_count { + bigbed_fail("AutoSQL field count does not match the BigBed header") + } + bigbed_validate_schema(schema, header.defined_field_count) + schema +} + +///| +pub fn bigbed_parse(data : Array[Int]) -> BigBedFile raise BigBedError { + let (header, endian) = bigbed_read_header(data) + let trailing = bigbed_read_u32(data, data.length() - 4, endian) + if trailing != bigbed_magic { + bigbed_fail("BigBed trailing magic number is missing") + } + let schema = bigbed_read_schema(data, header) + let targets = bigbed_read_chrom_tree( + data, + header.chromosome_tree_offset, + endian, + ) + let record_count = bigbed_read_u64_local( + data, + header.full_data_offset, + endian, + ) + let (blocks, indexed_count) = bigbed_read_rtree( + data, + header.full_index_offset, + endian, + ) + if indexed_count != record_count { + bigbed_fail("BigBed data and R-tree record counts disagree") + } + BigBedFile::{ + header, + schema, + targets, + source: data.copy(), + blocks, + record_count, + } +} + +///| +fn bigbed_decode_block( + file : BigBedFile, + block : BigBedBlockIndex, +) -> Array[Int] raise BigBedError { + let payload : Array[Int] = [] + for i in block.data_offset..<(block.data_offset + block.data_size) { + payload.push(file.source[i]) + } + if file.header.uncompress_buffer_size > 0 { + bigbed_zlib_unstore(payload, file.header.uncompress_buffer_size) + } else { + payload + } +} + +///| +fn bigbed_record_from_words( + file : BigBedFile, + chrom_id : Int, + chrom_start : Int, + chrom_end : Int, + words : Array[String], +) -> BigBedRecord raise BigBedError { + if chrom_id < 0 || chrom_id >= file.targets.length() { + bigbed_fail("Binary BED record contains an invalid chromosome ID") + } + let expected_words = file.header.field_count - 3 + if words.length() != expected_words { + bigbed_fail( + "Binary BED record contains " + + words.length().to_string() + + " fields after its coordinates; expected " + + expected_words.to_string(), + ) + } + let bed_columns = file.header.defined_field_count + let name = if bed_columns >= 4 { words[0] } else { "." } + let score = if bed_columns >= 5 { + bigbed_parse_nonnegative_int(words[1], "BED score") + } else { + 0 + } + let strand = if bed_columns >= 6 { words[2] } else { "." } + let thick_start = if bed_columns >= 7 { + bigbed_parse_nonnegative_int(words[3], "BED thickStart") + } else { + chrom_start + } + let thick_end = if bed_columns >= 8 { + bigbed_parse_nonnegative_int(words[4], "BED thickEnd") + } else { + chrom_end + } + let item_rgb = if bed_columns >= 9 { words[5] } else { "0" } + let declared_blocks = if bed_columns >= 10 { + bigbed_parse_nonnegative_int(words[6], "BED blockCount") + } else { + 0 + } + let block_sizes = if bed_columns >= 11 { + bigbed_parse_csv_ints(words[7], "BED blockSizes") + } else { + [] + } + let block_starts = if bed_columns >= 12 { + bigbed_parse_csv_ints(words[8], "BED chromStarts") + } else { + [] + } + if bed_columns >= 11 && block_sizes.length() != declared_blocks { + bigbed_fail("BED blockCount does not match blockSizes") + } + if bed_columns >= 12 && block_starts.length() != declared_blocks { + bigbed_fail("BED blockCount does not match chromStarts") + } + let extra : Array[String] = [] + for i in (bed_columns - 3).. Array[BigBedRecord] raise BigBedError { + let data = bigbed_decode_block(file, block) + let endian = if file.header.little_endian { + BigBedLittleEndian + } else { + BigBedBigEndian + } + let records : Array[BigBedRecord] = [] + let mut position = 0 + while position < data.length() { + bigbed_check_range(data, position, 13, "binary BED record") + let chrom_id = bigbed_read_u32(data, position, endian) + let chrom_start = bigbed_read_u32(data, position + 4, endian) + let chrom_end = bigbed_read_u32(data, position + 8, endian) + let (rest, next) = bigbed_read_c_string(data, position + 12, data.length()) + let words = if rest.length() == 0 { + [] + } else { + split_by_char(rest, '\t'.to_int()) + } + records.push( + bigbed_record_from_words(file, chrom_id, chrom_start, chrom_end, words), + ) + position = next + } + records +} + +///| +pub fn BigBedFile::records( + self : BigBedFile, +) -> Array[BigBedRecord] raise BigBedError { + let records : Array[BigBedRecord] = [] + for block in self.blocks { + for record in bigbed_decode_records(self, block) { + records.push(record) + } + } + if records.length() != self.record_count { + bigbed_fail("Decoded BigBed record count does not match its header") + } + records +} + +///| +pub fn BigBedFile::search( + self : BigBedFile, + chromosome : String, + start? : Int = 0, + end? : Int = -1, +) -> Array[BigBedRecord] raise BigBedError { + let chrom_id = bigbed_target_index(self.targets, chromosome) + if chrom_id < 0 { + bigbed_fail("Unknown BigBed target '" + chromosome + "'") + } + let resolved_end = if end < 0 { self.targets[chrom_id].length } else { end } + if start < 0 || + resolved_end <= start || + resolved_end > self.targets[chrom_id].length { + bigbed_fail("BigBed search requires a valid positive half-open interval") + } + let results : Array[BigBedRecord] = [] + for block in self.blocks { + if bigbed_block_overlaps(block, chrom_id, start, resolved_end) { + for record in bigbed_decode_records(self, block) { + if record.overlaps(chromosome, start, resolved_end) { + results.push(record) + } + } + } + } + results +} + +///| +pub fn BigBedFile::find_by_name( + self : BigBedFile, + name : String, +) -> Array[BigBedRecord] raise BigBedError { + let results : Array[BigBedRecord] = [] + for record in self.records() { + if record.name == name { + results.push(record) + } + } + results +} + +///| +pub fn BigBedFile::target(self : BigBedFile, name : String) -> BigBedTarget? { + let index = bigbed_target_index(self.targets, name) + if index < 0 { + None + } else { + Some(self.targets[index]) + } +} + +///| +pub fn BigBedFile::is_compressed(self : BigBedFile) -> Bool { + self.header.uncompress_buffer_size > 0 +} + +///| +pub fn BigBedFile::summary( + self : BigBedFile, +) -> BigBedSummary raise BigBedError { + let mut covered_bases = 0 + let mut minimum_span = 0 + let mut maximum_span = 0 + let records = self.records() + for i in 0.. maximum_span { + maximum_span = span + } + } + BigBedSummary::{ + record_count: self.record_count, + target_count: self.targets.length(), + data_block_count: self.blocks.length(), + covered_bases, + minimum_span, + maximum_span, + compressed: self.is_compressed(), + } +} + +///| +pub fn BigBedFile::to_bed(self : BigBedFile) -> String raise BigBedError { + let output = StringBuilder::new() + let bed_columns = self.header.defined_field_count + for record in self.records() { + output.write_string(record.chrom) + output.write_string("\t") + output.write_string(record.chrom_start.to_string()) + output.write_string("\t") + output.write_string(record.chrom_end.to_string()) + let rest = bigbed_rest_fields(record, bed_columns) + for field in rest { + output.write_string("\t") + output.write_string(field) + } + output.write_string("\n") + } + output.to_string() +} + +///| +pub fn bigbed_example_data() -> (Array[BigBedTarget], Array[BigBedRecord]) { + let targets = [ + BigBedTarget::{ name: "chr1", length: 1000000 }, + BigBedTarget::{ name: "chr2", length: 500000 }, + ] + let records = [ + BigBedRecord::{ + chrom: "chr1", + chrom_start: 100, + chrom_end: 280, + name: "transcript-A", + score: 960, + strand: "+", + thick_start: 120, + thick_end: 260, + item_rgb: "40,120,220", + declared_block_count: 3, + block_sizes: [50, 40, 30], + block_starts: [0, 80, 150], + extra_fields: [], + }, + BigBedRecord::{ + chrom: "chr1", + chrom_start: 250, + chrom_end: 410, + name: "transcript-B", + score: 870, + strand: "-", + thick_start: 270, + thick_end: 390, + item_rgb: "220,80,80", + declared_block_count: 2, + block_sizes: [60, 50], + block_starts: [0, 110], + extra_fields: [], + }, + BigBedRecord::{ + chrom: "chr2", + chrom_start: 1000, + chrom_end: 1120, + name: "transcript-C", + score: 700, + strand: "+", + thick_start: 1000, + thick_end: 1120, + item_rgb: "0", + declared_block_count: 2, + block_sizes: [45, 50], + block_starts: [0, 70], + extra_fields: [], + }, + ] + (targets, records) +} diff --git a/test/moonbit/bigbed_test.mbt b/test/moonbit/bigbed_test.mbt new file mode 100644 index 00000000..a0a6f9ff --- /dev/null +++ b/test/moonbit/bigbed_test.mbt @@ -0,0 +1,1079 @@ +///| +fn bigbed_test_config( + compress? : Bool = true, + items_per_slot? : Int = 2, +) -> @src.BigBedWriteConfig { + @src.BigBedWriteConfig::create(compress~, items_per_slot~, block_size=4) catch { + _ => abort("BigBed test configuration should be valid") + } +} + +///| +fn bigbed_test_file( + compress? : Bool = true, + items_per_slot? : Int = 2, +) -> @src.BigBedFile { + let (targets, records) = @src.bigbed_example_data() + let config = bigbed_test_config(compress~, items_per_slot~) + let bytes = @src.bigbed_write(targets, records, config~) catch { + _ => abort("BigBed example should serialize") + } + @src.bigbed_parse(bytes) catch { + _ => abort("BigBed example should parse") + } +} + +///| +fn bigbed_simple_record( + block_count? : Int = 0, + block_sizes? : Array[Int] = [], + block_starts? : Array[Int] = [], + extra_fields? : Array[String] = [], +) -> @src.BigBedRecord { + @src.BigBedRecord::create( + "chr1", + 10, + 40, + name="item", + score=500, + strand="+", + block_count~, + block_sizes~, + block_starts~, + extra_fields~, + ) catch { + _ => abort("simple BigBed record should be valid") + } +} + +///| +fn bigbed_test_patch_u32( + data : Array[Int], + position : Int, + value : Int, +) -> Unit { + data[position] = value & 0xFF + data[position + 1] = (value >> 8) & 0xFF + data[position + 2] = (value >> 16) & 0xFF + data[position + 3] = (value >> 24) & 0xFF +} + +///| +fn bigbed_test_patch_u64( + data : Array[Int], + position : Int, + value : Int, +) -> Unit { + bigbed_test_patch_u32(data, position, value) + bigbed_test_patch_u32(data, position + 4, 0) +} + +///| +fn bigbed_test_replace_single_block( + source : Array[Int], + payload : Array[Int], + uncompressed_size : Int, +) -> Array[Int] { + let file = @src.bigbed_parse(source) catch { + _ => abort("source BigBed should parse") + } + if file.blocks.length() != 1 { + abort("fixture BigBed must contain one data block") + } + let block = file.blocks[0] + let output : Array[Int] = [] + for i in 0.. abort("field should be valid") + } + assert_eq(field.as_type, "float") + assert_eq(field.name, "expression") + assert_eq(field.comment, "Mean expression") +} + +///| +test "bigbed: field rejects unsupported AutoSQL type" { + let rejected = try { + ignore(@src.BigBedField::create("matrix", "value")) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: default schema has twelve standard fields" { + let schema = @src.BigBedSchema::default() catch { + _ => abort("default schema should build") + } + assert_eq(schema.name, "bed") + assert_eq(schema.fields.length(), 12) + assert_eq(schema.fields[0].name, "chrom") + assert_eq(schema.fields[11].name, "chromStarts") +} + +///| +test "bigbed: reduced default schema follows BED column count" { + let schema = @src.BigBedSchema::default(bed_columns=3) catch { + _ => abort("BED3 schema should build") + } + assert_eq(schema.fields.length(), 3) + assert_eq(schema.fields[2].name, "chromEnd") +} + +///| +test "bigbed: schema rejects fewer than three fields" { + let field = @src.BigBedField::create("string", "chrom") catch { + _ => abort("field should build") + } + let rejected = try { + ignore(@src.BigBedSchema::create("bad", "bad", [field])) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: AutoSQL standard schema round trip" { + let schema = @src.BigBedSchema::default() catch { + _ => abort("schema should build") + } + let parsed = @src.bigbed_parse_auto_sql(schema.to_auto_sql()) catch { + _ => abort("generated AutoSQL should parse") + } + assert_eq(parsed, schema) +} + +///| +test "bigbed: AutoSQL custom arrays parse" { + let schema = @src.bigbed_parse_auto_sql( + "table custom\n\"Custom BED\"\n(\n" + + "string chrom; \"Chromosome\"\n" + + "uint chromStart; \"Start\"\n" + + "uint chromEnd; \"End\"\n" + + "float[3] values; \"Values\"\n" + + ")\n", + ) catch { + _ => abort("custom AutoSQL should parse") + } + assert_eq(schema.fields.length(), 4) + assert_eq(schema.fields[3].as_type, "float[3]") +} + +///| +test "bigbed: malformed AutoSQL is rejected" { + let rejected = try { + ignore(@src.bigbed_parse_auto_sql("record bed\n")) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: target constructor validates length" { + let target = @src.BigBedTarget::create("chrX", 1000) catch { + _ => abort("target should build") + } + assert_eq(target.name, "chrX") + assert_eq(target.length, 1000) + let rejected = try { + ignore(@src.BigBedTarget::create("chrX", 0)) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: record constructor fills BED defaults" { + let record = @src.BigBedRecord::create("chr1", 10, 40) catch { + _ => abort("record should build") + } + assert_eq(record.name, ".") + assert_eq(record.score, 0) + assert_eq(record.strand, ".") + assert_eq(record.thick_start, 10) + assert_eq(record.thick_end, 40) +} + +///| +test "bigbed: record span and query size use blocks" { + let record = bigbed_simple_record(block_count=2, block_sizes=[10, 15], block_starts=[ + 0, 15, + ]) + assert_eq(record.span(), 30) + assert_eq(record.query_size(), 25) + assert_eq(record.block_count(), 2) +} + +///| +test "bigbed: record rejects invalid coordinates" { + let rejected = try { + ignore(@src.BigBedRecord::create("chr1", 20, 20)) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: record rejects score outside BED range" { + let rejected = try { + ignore(@src.BigBedRecord::create("chr1", 0, 10, score=1001)) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: record rejects invalid strand" { + let rejected = try { + ignore(@src.BigBedRecord::create("chr1", 0, 10, strand="?")) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: record rejects thick interval outside feature" { + let rejected = try { + ignore( + @src.BigBedRecord::create("chr1", 10, 30, thick_start=5, thick_end=20), + ) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: record rejects mismatched block arrays" { + let rejected = try { + ignore( + @src.BigBedRecord::create("chr1", 0, 20, block_sizes=[10, 5], block_starts=[ + 0, + ]), + ) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: record rejects a first block after chromStart" { + let rejected = try { + ignore( + @src.BigBedRecord::create("chr1", 0, 20, block_sizes=[10], block_starts=[ + 10, + ]), + ) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: overlap uses half-open boundaries" { + let record = bigbed_simple_record() + assert_true(record.overlaps("chr1", 0, 11)) + assert_true(record.overlaps("chr1", 39, 50)) + assert_true(!record.overlaps("chr1", 0, 10)) + assert_true(!record.overlaps("chr1", 40, 50)) +} + +///| +test "bigbed: forward BED12 coordinates include intron gaps" { + let (_, records) = @src.bigbed_example_data() + let coordinates = records[0].coordinates() + assert_eq(coordinates[0], [100, 150, 180, 220, 250, 280]) + assert_eq(coordinates[1], [0, 50, 50, 90, 90, 120]) +} + +///| +test "bigbed: reverse BED12 coordinates reverse query direction" { + let (_, records) = @src.bigbed_example_data() + let coordinates = records[1].coordinates() + assert_eq(coordinates[0], [250, 310, 360, 410]) + assert_eq(coordinates[1], [110, 50, 50, 0]) +} + +///| +test "bigbed: BED11 partial blocks use span coordinates" { + let record = bigbed_simple_record(block_count=2, block_sizes=[10, 20]) + assert_eq(record.block_count(), 2) + assert_eq(record.coordinates(), [[10, 40], [0, 30]]) +} + +///| +test "bigbed: default write configuration matches Biopython defaults" { + let config = @src.BigBedWriteConfig::default() + assert_eq(config.bed_columns, 12) + assert_eq(config.items_per_slot, 512) + assert_eq(config.block_size, 256) + assert_true(config.compress) +} + +///| +test "bigbed: configuration accepts custom fields" { + let field = @src.BigBedField::create("float", "signal") catch { + _ => abort("custom field should build") + } + let config = @src.BigBedWriteConfig::create(bed_columns=6, custom_fields=[ + field, + ]) catch { + _ => abort("custom config should build") + } + assert_eq(config.bed_columns, 6) + assert_eq(config.custom_fields[0].name, "signal") +} + +///| +test "bigbed: configuration rejects invalid BED columns" { + let low = try { + ignore(@src.BigBedWriteConfig::create(bed_columns=2)) + false + } catch { + BigBedError(_) => true + } + let high = try { + ignore(@src.BigBedWriteConfig::create(bed_columns=13)) + false + } catch { + BigBedError(_) => true + } + assert_true(low) + assert_true(high) +} + +///| +test "bigbed: configuration rejects invalid tree controls" { + let slot = try { + ignore(@src.BigBedWriteConfig::create(items_per_slot=0)) + false + } catch { + BigBedError(_) => true + } + let block = try { + ignore(@src.BigBedWriteConfig::create(block_size=0)) + false + } catch { + BigBedError(_) => true + } + let non_branching = try { + ignore(@src.BigBedWriteConfig::create(block_size=1)) + false + } catch { + BigBedError(_) => true + } + assert_true(slot) + assert_true(block) + assert_true(non_branching) +} + +///| +test "bigbed: compressed version 4 round trip" { + let file = bigbed_test_file() + assert_eq(file.header.version, 4) + assert_true(file.header.little_endian) + assert_true(file.is_compressed()) + assert_eq(file.record_count, 3) +} + +///| +test "bigbed: compressed round trip preserves all BED12 records" { + let file = bigbed_test_file() + let records = file.records() catch { _ => abort("records should decode") } + let (_, expected) = @src.bigbed_example_data() + assert_eq(records, expected) +} + +///| +test "bigbed: itemsPerSlot creates multiple indexed data blocks" { + let file = bigbed_test_file(items_per_slot=1) + assert_eq(file.blocks.length(), 3) + assert_eq(file.summary().data_block_count, 3) +} + +///| +test "bigbed: chromosome B+ tree preserves targets" { + let file = bigbed_test_file() + assert_eq(file.targets.length(), 2) + assert_eq(file.targets[0].name, "chr1") + assert_eq(file.targets[0].length, 1000000) + assert_eq(file.targets[1].name, "chr2") +} + +///| +test "bigbed: target lookup handles present and absent names" { + let file = bigbed_test_file() + match file.target("chr2") { + Some(target) => assert_eq(target.length, 500000) + None => abort("chr2 should exist") + } + assert_eq(file.target("chrM"), None) +} + +///| +test "bigbed: search returns both overlapping chr1 transcripts" { + let hits = bigbed_test_file().search("chr1", start=260, end=270) catch { + _ => abort("region search should succeed") + } + assert_eq(hits.length(), 2) + assert_eq(hits[0].name, "transcript-A") + assert_eq(hits[1].name, "transcript-B") +} + +///| +test "bigbed: search excludes record ending at query start" { + let hits = bigbed_test_file().search("chr1", start=280, end=300) catch { + _ => abort("boundary search should succeed") + } + assert_eq(hits.length(), 1) + assert_eq(hits[0].name, "transcript-B") +} + +///| +test "bigbed: search excludes record starting at query end" { + let hits = bigbed_test_file().search("chr1", start=0, end=100) catch { + _ => abort("boundary search should succeed") + } + assert_eq(hits.length(), 0) +} + +///| +test "bigbed: search prunes other chromosomes" { + let hits = bigbed_test_file(items_per_slot=1).search( + "chr2", + start=1000, + end=1001, + ) catch { + _ => abort("chr2 search should succeed") + } + assert_eq(hits.length(), 1) + assert_eq(hits[0].name, "transcript-C") +} + +///| +test "bigbed: search defaults to the complete chromosome" { + let hits = bigbed_test_file().search("chr1") catch { + _ => abort("whole chromosome search should succeed") + } + assert_eq(hits.length(), 2) +} + +///| +test "bigbed: search rejects unknown chromosome" { + let rejected = try { + ignore(bigbed_test_file().search("chrM")) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: search rejects invalid interval" { + let rejected = try { + ignore(bigbed_test_file().search("chr1", start=20, end=20)) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: name lookup scans indexed records" { + let hits = bigbed_test_file().find_by_name("transcript-C") catch { + _ => abort("name lookup should succeed") + } + assert_eq(hits.length(), 1) + assert_eq(hits[0].chrom, "chr2") +} + +///| +test "bigbed: summary reports spans and compression" { + let summary = bigbed_test_file().summary() catch { + _ => abort("summary should succeed") + } + assert_eq(summary.record_count, 3) + assert_eq(summary.target_count, 2) + assert_eq(summary.covered_bases, 460) + assert_eq(summary.minimum_span, 120) + assert_eq(summary.maximum_span, 180) + assert_true(summary.compressed) +} + +///| +test "bigbed: BED text export preserves trailing block commas" { + let text = bigbed_test_file().to_bed() catch { + _ => abort("BED export should succeed") + } + assert_true( + text.contains( + "chr1\t100\t280\ttranscript-A\t960\t+\t120\t260\t40,120,220\t3\t50,40,30,\t0,80,150,\n", + ), + ) +} + +///| +test "bigbed: uncompressed round trip" { + let file = bigbed_test_file(compress=false) + assert_true(!file.is_compressed()) + let records = file.records() catch { + _ => abort("uncompressed records should decode") + } + assert_eq(records.length(), 3) +} + +///| +test "bigbed: parser decodes standard fixed Huffman zlib blocks" { + let (targets, records) = @src.bigbed_example_data() + let config = @src.BigBedWriteConfig::create( + items_per_slot=3, + block_size=4, + compress=false, + ) catch { + _ => abort("fixture configuration should build") + } + let source = @src.bigbed_write(targets, records, config~) catch { + _ => abort("fixture source should serialize") + } + let fixed = [ + 120, 1, 99, 96, 96, 96, 72, 1, 98, 9, 70, 6, 134, 146, 162, 196, 188, 226, 228, + 162, 204, 130, 18, 93, 71, 78, 75, 51, 3, 78, 109, 78, 67, 35, 3, 78, 35, 32, + 203, 196, 64, 7, 200, 212, 49, 2, 114, 141, 57, 77, 13, 116, 128, 124, 99, 3, + 29, 78, 3, 29, 11, 160, 4, 144, 207, 0, 2, 191, 128, 120, 22, 170, 57, 78, 156, + 22, 230, 6, 156, 186, 156, 70, 64, 210, 216, 18, 104, 150, 17, 88, 139, 5, 144, + 197, 105, 102, 160, 99, 10, 54, 195, 208, 16, 104, 0, 80, 31, 195, 11, 102, 6, + 134, 4, 22, 20, 3, 156, 57, 205, 13, 192, 14, 49, 0, 82, 134, 32, 231, 128, 180, + 154, 152, 66, 181, 154, 3, 117, 2, 0, 27, 137, 36, 189, + ] + let bytes = bigbed_test_replace_single_block(source, fixed, 195) + let file = @src.bigbed_parse(bytes) catch { + _ => abort("fixed-Huffman BigBed should parse") + } + let decoded = file.records() catch { + _ => abort("fixed-Huffman data should decode") + } + assert_eq(decoded, records) +} + +///| +test "bigbed: parser decodes standard dynamic Huffman zlib blocks" { + let (targets, records) = @src.bigbed_example_data() + let config = @src.BigBedWriteConfig::create( + items_per_slot=3, + block_size=4, + compress=false, + ) catch { + _ => abort("fixture configuration should build") + } + let source = @src.bigbed_write(targets, records, config~) catch { + _ => abort("fixture source should serialize") + } + let dynamic = [ + 120, 218, 85, 142, 49, 14, 194, 48, 16, 4, 15, 65, 179, 63, 224, 15, 92, 164, + 243, 57, 142, 157, 18, 248, 8, 8, 26, 26, 132, 66, 94, 147, 23, 242, 6, 42, 214, + 22, 77, 44, 157, 189, 43, 107, 70, 39, 34, 114, 231, 236, 55, 34, 243, 116, 125, + 190, 111, 211, 227, 53, 119, 71, 140, 131, 225, 128, 224, 6, 103, 234, 77, 25, + 213, 89, 35, 146, 41, 123, 52, 133, 105, 225, 7, 187, 212, 243, 229, 44, 107, + 207, 9, 37, 27, 58, 56, 239, 56, 210, 229, 13, 41, 76, 24, 76, 83, 115, 132, + 64, 1, 57, 249, 108, 69, 46, 187, 149, 224, 140, 108, 109, 17, 227, 19, 234, + 58, 21, 237, 211, 31, 205, 36, 127, 27, 137, 36, 189, + ] + let bytes = bigbed_test_replace_single_block(source, dynamic, 195) + let file = @src.bigbed_parse(bytes) catch { + _ => abort("dynamic-Huffman BigBed should parse") + } + let decoded = file.records() catch { + _ => abort("dynamic-Huffman data should decode") + } + assert_eq(decoded, records) +} + +///| +test "bigbed: multilevel chromosome and interval trees round trip" { + let targets : Array[@src.BigBedTarget] = [] + let records : Array[@src.BigBedRecord] = [] + for i in 0..<10 { + let name = "chr" + (9 - i).to_string() + targets.push( + @src.BigBedTarget::create(name, 1000) catch { + _ => abort("multilevel target should build") + }, + ) + records.push( + @src.BigBedRecord::create(name, 10 + i, 30 + i) catch { + _ => abort("multilevel record should build") + }, + ) + } + let config = @src.BigBedWriteConfig::create( + bed_columns=3, + items_per_slot=1, + block_size=2, + compress=false, + ) catch { + _ => abort("multilevel configuration should build") + } + let bytes = @src.bigbed_write(targets, records, config~) catch { + _ => abort("multilevel BigBed should serialize") + } + let file = @src.bigbed_parse(bytes) catch { + _ => abort("multilevel BigBed should parse") + } + assert_eq(file.targets, targets) + assert_eq(file.blocks.length(), 10) + assert_eq(file.records(), records) + assert_eq(file.search("chr5", start=0, end=100).length(), 1) +} + +///| +test "bigbed: R-tree bounds retain earlier long intervals" { + let targets = [ + @src.BigBedTarget::create("chr1", 1000) catch { + _ => abort("target should build") + }, + ] + let records = [ + @src.BigBedRecord::create("chr1", 0, 900) catch { + _ => abort("long record should build") + }, + @src.BigBedRecord::create("chr1", 100, 200) catch { + _ => abort("short record should build") + }, + ] + let config = @src.BigBedWriteConfig::create( + bed_columns=3, + items_per_slot=2, + block_size=2, + compress=false, + ) catch { + _ => abort("configuration should build") + } + let bytes = @src.bigbed_write(targets, records, config~) catch { + _ => abort("BigBed should serialize") + } + let file = @src.bigbed_parse(bytes) catch { + _ => abort("BigBed should parse") + } + let hits = file.search("chr1", start=800, end=850) catch { + _ => abort("long interval query should succeed") + } + assert_eq(hits.length(), 1) + assert_eq(hits[0].chrom_end, 900) +} + +///| +test "bigbed: BED3 round trip drops optional columns" { + let targets = [ + @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("target should build") + }, + ] + let records = [bigbed_simple_record()] + let config = @src.BigBedWriteConfig::create(bed_columns=3) catch { + _ => abort("BED3 config should build") + } + let bytes = @src.bigbed_write(targets, records, config~) catch { + _ => abort("BED3 should serialize") + } + let parsed = @src.bigbed_parse(bytes) catch { + _ => abort("BED3 should parse") + } + let record = parsed.records()[0] + assert_eq(record.name, ".") + assert_eq(record.score, 0) + assert_eq(parsed.header.defined_field_count, 3) +} + +///| +test "bigbed: BED6 round trip preserves name score and strand" { + let targets = [ + @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("target should build") + }, + ] + let record = @src.BigBedRecord::create( + "chr1", + 10, + 40, + name="feature", + score=700, + strand="-", + ) catch { + _ => abort("BED6 record should build") + } + let config = @src.BigBedWriteConfig::create(bed_columns=6) catch { + _ => abort("BED6 config should build") + } + let parsed = @src.bigbed_parse(@src.bigbed_write(targets, [record], config~)) catch { + _ => abort("BED6 round trip should succeed") + } + let result = parsed.records()[0] + assert_eq(result.name, "feature") + assert_eq(result.score, 700) + assert_eq(result.strand, "-") +} + +///| +test "bigbed: BED10 preserves declared block count" { + let targets = [ + @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("target should build") + }, + ] + let config = @src.BigBedWriteConfig::create(bed_columns=10) catch { + _ => abort("BED10 config should build") + } + let record = bigbed_simple_record(block_count=2) + let parsed = @src.bigbed_parse(@src.bigbed_write(targets, [record], config~)) catch { + _ => abort("BED10 round trip should succeed") + } + assert_eq(parsed.records()[0].block_count(), 2) +} + +///| +test "bigbed: BED11 preserves block sizes without starts" { + let targets = [ + @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("target should build") + }, + ] + let config = @src.BigBedWriteConfig::create(bed_columns=11) catch { + _ => abort("BED11 config should build") + } + let record = bigbed_simple_record(block_count=2, block_sizes=[10, 20]) + let parsed = @src.bigbed_parse(@src.bigbed_write(targets, [record], config~)) catch { + _ => abort("BED11 round trip should succeed") + } + let result = parsed.records()[0] + assert_eq(result.block_count(), 2) + assert_eq(result.block_sizes, [10, 20]) + assert_eq(result.block_starts, []) +} + +///| +test "bigbed: custom AutoSQL annotation round trip" { + let field = @src.BigBedField::create("float", "signal") catch { + _ => abort("field should build") + } + let config = @src.BigBedWriteConfig::create(bed_columns=6, custom_fields=[ + field, + ]) catch { + _ => abort("config should build") + } + let targets = [ + @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("target should build") + }, + ] + let record = @src.BigBedRecord::create( + "chr1", + 10, + 40, + name="feature", + score=700, + strand="+", + extra_fields=["2.75"], + ) catch { + _ => abort("custom record should build") + } + let parsed = @src.bigbed_parse(@src.bigbed_write(targets, [record], config~)) catch { + _ => abort("custom BigBed should round trip") + } + let result = parsed.records()[0] + assert_eq(result.annotation(parsed.schema, "signal", 6), Some("2.75")) +} + +///| +test "bigbed: writer rejects unsorted records" { + let (targets, records) = @src.bigbed_example_data() + let rejected = try { + ignore(@src.bigbed_write(targets, [records[1], records[0], records[2]])) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: writer rejects unknown target" { + let targets = [ + @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("target should build") + }, + ] + let record = @src.BigBedRecord::create("chr2", 10, 20) catch { + _ => abort("record should build") + } + let rejected = try { + ignore(@src.bigbed_write(targets, [record])) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: writer rejects interval beyond target" { + let targets = [ + @src.BigBedTarget::create("chr1", 20) catch { + _ => abort("target should build") + }, + ] + let record = @src.BigBedRecord::create("chr1", 10, 30) catch { + _ => abort("record should build") + } + let rejected = try { + ignore(@src.bigbed_write(targets, [record])) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: writer rejects duplicate target names" { + let targets = [ + @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("target should build") + }, + @src.BigBedTarget::create("chr1", 200) catch { + _ => abort("target should build") + }, + ] + let rejected = try { + ignore(@src.bigbed_write(targets, [])) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: writer rejects custom field count mismatch" { + let field = @src.BigBedField::create("string", "category") catch { + _ => abort("field should build") + } + let config = @src.BigBedWriteConfig::create(bed_columns=3, custom_fields=[ + field, + ]) catch { + _ => abort("config should build") + } + let targets = [ + @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("target should build") + }, + ] + let rejected = try { + ignore(@src.bigbed_write(targets, [bigbed_simple_record()], config~)) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: deterministic writer produces identical bytes" { + let (targets, records) = @src.bigbed_example_data() + let config = bigbed_test_config() + let first = @src.bigbed_write(targets, records, config~) catch { + _ => abort("first serialization should succeed") + } + let second = @src.bigbed_write(targets, records, config~) catch { + _ => abort("second serialization should succeed") + } + assert_eq(first, second) +} + +///| +test "bigbed: parser rejects invalid leading magic" { + let (targets, records) = @src.bigbed_example_data() + let bytes = @src.bigbed_write(targets, records) catch { + _ => abort("serialization should succeed") + } + bytes[0] = 0 + let rejected = try { + ignore(@src.bigbed_parse(bytes)) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: parser rejects invalid trailing magic" { + let (targets, records) = @src.bigbed_example_data() + let bytes = @src.bigbed_write(targets, records) catch { + _ => abort("serialization should succeed") + } + bytes[bytes.length() - 1] = 0 + let rejected = try { + ignore(@src.bigbed_parse(bytes)) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: parser rejects unsupported version" { + let (targets, records) = @src.bigbed_example_data() + let bytes = @src.bigbed_write(targets, records) catch { + _ => abort("serialization should succeed") + } + bytes[4] = 3 + let rejected = try { + ignore(@src.bigbed_parse(bytes)) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: parser rejects truncated header" { + let rejected = try { + ignore(@src.bigbed_parse([0xEB, 0xF2, 0x89, 0x87])) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: parser rejects damaged R-tree magic" { + let (targets, records) = @src.bigbed_example_data() + let bytes = @src.bigbed_write(targets, records) catch { + _ => abort("serialization should succeed") + } + let file = @src.bigbed_parse(bytes) catch { + _ => abort("valid file should parse") + } + bytes[file.header.full_index_offset] = 0 + let rejected = try { + ignore(@src.bigbed_parse(bytes)) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: decoder rejects damaged zlib checksum" { + let (targets, records) = @src.bigbed_example_data() + let config = bigbed_test_config() + let bytes = @src.bigbed_write(targets, records, config~) catch { + _ => abort("serialization should succeed") + } + let file = @src.bigbed_parse(bytes) catch { + _ => abort("valid file should parse") + } + let block = file.blocks[0] + let checksum_byte = block.data_offset + block.data_size - 1 + bytes[checksum_byte] = bytes[checksum_byte] ^ 1 + let damaged = @src.bigbed_parse(bytes) catch { + _ => abort("index should still parse before data decoding") + } + let rejected = try { + ignore(damaged.records()) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: decoder rejects malformed Huffman DEFLATE" { + let (targets, records) = @src.bigbed_example_data() + let config = bigbed_test_config() + let bytes = @src.bigbed_write(targets, records, config~) catch { + _ => abort("serialization should succeed") + } + let file = @src.bigbed_parse(bytes) catch { + _ => abort("valid file should parse") + } + bytes[file.blocks[0].data_offset + 2] = 3 + let changed = @src.bigbed_parse(bytes) catch { + _ => abort("index should still parse") + } + let rejected = try { + ignore(changed.records()) + false + } catch { + BigBedError(_) => true + } + assert_true(rejected) +} + +///| +test "bigbed: empty file retains targets and zero records" { + let targets = [ + @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("target should build") + }, + ] + let bytes = @src.bigbed_write(targets, []) catch { + _ => abort("empty BigBed should serialize") + } + let file = @src.bigbed_parse(bytes) catch { + _ => abort("empty BigBed should parse") + } + assert_eq(file.record_count, 0) + assert_eq(file.records(), []) + assert_eq(file.search("chr1"), []) +} From 9cab648be9d04bc86ff183b610657331e9829ab4 Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 02:39:14 +0800 Subject: [PATCH 19/41] #28 feat(apeglm): apeglm GLM & Cauchy/Student-t & Laplace & FSR/FSOS/s-value & SummarizedExperiment --- README.md | 26 +- examples/apeglm_demo/main.mbt | 126 +++ examples/apeglm_demo/moon.pkg | 6 + src/apeglm.mbt | 1548 +++++++++++++++++++++++++++++++++ test/moonbit/apeglm_test.mbt | 1321 ++++++++++++++++++++++++++++ 5 files changed, 3022 insertions(+), 5 deletions(-) create mode 100644 examples/apeglm_demo/main.mbt create mode 100644 examples/apeglm_demo/moon.pkg create mode 100644 src/apeglm.mbt create mode 100644 test/moonbit/apeglm_test.mbt diff --git a/README.md b/README.md index 0dea7397..ebf2c537 100644 --- a/README.md +++ b/README.md @@ -220,6 +220,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **Alignment坐标组合** | Biopython `Bio.Align.Alignment.map/mapall` | alignment path组合、局部overhang clipping、exon/intron与indel gap、正反链组合、坐标双向查询、PSL及1:1/1:3 MSA投影 | ✅ | | **BigBed二进制区间索引** | Biopython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12与AutoSQL、多级B+ tree/R-tree、stored/fixed/dynamic DEFLATE、区间/名称查询、链感知exon坐标及BED导出 | ✅ | | **zinbwave** | Bioconductor zinbwave | 零膨胀负二项低维模型、cell/gene协变量与offset、确定性latent factors、dispersion shrinkage、observational weights、残差/归一化/插补及SCE集成 | ✅ | +| **apeglm** | Bioconductor apeglm | 负二项GLM、自适应经验贝叶斯Cauchy/Student-t先验、确定性多起点MAP、Laplace后验SD/区间、FSR/FSOS/s-value、DESeq2与SummarizedExperiment接入 | ✅ | | **Prosite** | Biopython `Bio.Prosite` | 蛋白质模体数据库搜索、Prosite模式解析、模体匹配算法、模体得分计算 | ✅ | | **PAML** | Biopython `Bio.PAML` | 分子进化分析、dN/dS计算（Nei-Gojobori方法）、Jukes-Cantor校正、密码子使用分析 | ✅ | | **Graphics** | Biopython `Bio.Graphics` | 生物信息学可视化、序列Logo绘制、序列比对可视化、基因组特征绘图 | ✅ | @@ -474,6 +475,7 @@ IvanAXu/BioSeqs/ │ ├── rhdf5.mbt # Bioconductor rhdf5 HDF5文件格式支持 │ ├── deseq2.mbt # DESeq2 差异表达分析 (size factors归一化、分散度估计、负二项GLM拟合、Wald检验、LFC收缩) │ ├── deseq2_advanced.mbt # DESeq2 VST方差稳定化变换、PCA可视化 +│ ├── apeglm.mbt # apeglm 自适应重尾LFC收缩、Laplace后验、FSR/FSOS与容器接入 │ ├── edger.mbt # edgeR 差异表达分析 (DGEList、精确检验、GLM拟合) │ ├── edger_advanced.mbt # edgeR准似然F检验、camera/roast基因集检验 │ ├── limma.mbt # limma 差异表达、归一化、批次校正 (线性模型、经验贝叶斯、voom、RPKM/CPM/quantile、ComBat) @@ -902,6 +904,7 @@ IvanAXu/BioSeqs/ │ ├── decontx_demo/ # decontX cluster/background去污染、marker校正、诊断与SCE输出示例 │ ├── milo_demo/ # miloR KNN图、精炼邻域、NB差异丰度、spatial FDR与SCE接入示例 │ ├── zinbwave_demo/ # zinbwave latent factors、dropout权重、残差/插补与SCE集成示例 +│ ├── apeglm_demo/ # apeglm MLE/MAP、重尾收缩、FSR/FSOS、TSV与SE接入示例 │ ├── variance_partition_demo/ # variancePartition 方差分解、BLUP、precision weights、dream与SE接入示例 │ ├── monocle3_demo/ # monocle3 单细胞轨迹分析示例 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read_demo/ # ShortRead 短读序列质量控制示例 (QA统计、adapter修剪、质量修剪、FastQC报告) @@ -1306,6 +1309,7 @@ IvanAXu/BioSeqs/ │ │ ├── decontx_test.mbt │ │ ├── milo_test.mbt │ │ ├── zinbwave_test.mbt +│ │ ├── apeglm_test.mbt │ │ ├── variance_partition_test.mbt │ │ ├── shared_reference_alignment_test.mbt │ │ ├── alignment_map_test.mbt @@ -1486,7 +1490,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8839 个测试全部通过 +moon test # ✅ 8905 个测试全部通过 ``` ### 模块对照表 @@ -1797,6 +1801,7 @@ moon test # ✅ 8839 个测试全 | `decontx.mbt` | `decontX` | 每细胞native/contaminant Bayesian mixture、确定性EM、empty-droplet ambient profile、自动k-means、诊断与SingleCellExperiment不可变包装 | | `milo.mbt` | `miloR` | 精确KNN图、median精炼重叠邻域、邻域计数/表达、固定效应NB-GLM/Wald检验、graph spatial FDR与SCE接入 | | `zinbwave.mbt` | `zinbwave` | ZINB交替EM/IRLS、cell/gene design与offset、确定性低维因子、gene dispersion shrinkage、observational weights、deviance residual及SingleCellExperiment包装 | +| `apeglm.mbt` | `apeglm` | 负二项GLM MLE、自适应Cauchy/Student-t先验、阻尼Newton多起点MAP、Laplace后验SD/区间、FSR/FSOS/s-value、DESeq2与SummarizedExperiment包装 | | `variance_partition.mbt` | `variancePartition` | typed fixed/random design、多随机截距LMM、ML/REML方差分解、BLUP、weighted dream contrast、Satterthwaite自由度与SummarizedExperiment入口 | | `shared_reference_alignment.mbt` | `Bio.Align.Alignment` | 同参考PWA/MSA的reference-boundary insertion同步、原query投影、局部坐标、metadata、统计与格式转换 | | `alignment_map.mbt` | `Bio.Align.Alignment.map/mapall` | 两层alignment坐标组合、正反链与gap传播、PSL、批量映射及protein/nucleotide MSA投影 | @@ -1910,7 +1915,7 @@ moon test # ✅ 8839 个测试全 ### 12. DESeq2 差异表达分析 (Bioconductor DESeq2) -实现完整的 RNA-seq 差异表达分析流程，支持从原始计数到差异表达基因筛选的全流程分析。可以创建 DESeqDataSet 对象管理计数矩阵、样本信息和设计矩阵。支持 size factors 估计（中位数比率法）进行测序深度校正，以及计数矩阵归一化和 log2 CPM 计算。支持分散度估计（parametric fit），结合经验贝叶斯收缩方法。支持负二项 GLM 拟合，通过迭代加权最小二乘法估计回归系数。支持 Wald 检验进行差异表达显著性检验，计算 log2 fold change、标准误、检验统计量和 p 值。支持 Benjamini-Hochberg 多重检验校正。支持 LFC 收缩（apeglm-like 方法），减小低表达基因的 fold change 估计偏差。支持显著基因筛选（按 adjusted p-value 和 LFC 阈值）和获取 top 差异表达基因。适用于 RNA-seq 差异表达分析。 +实现完整的 RNA-seq 差异表达分析流程，支持从原始计数到差异表达基因筛选的全流程分析。可以创建 DESeqDataSet 对象管理计数矩阵、样本信息和设计矩阵。支持 size factors 估计（中位数比率法）进行测序深度校正，以及计数矩阵归一化和 log2 CPM 计算。支持分散度估计（parametric fit），结合经验贝叶斯收缩方法。支持负二项 GLM 拟合，通过迭代加权最小二乘法估计回归系数。支持 Wald 检验进行差异表达显著性检验，计算 log2 fold change、标准误、检验统计量和 p 值。支持 Benjamini-Hochberg 多重检验校正。旧 `lfc_shrink` API 保留固定正态先验的轻量收缩行为；完整的自适应重尾 apeglm 实现在独立 `apeglm.mbt` 和第 254 节中。支持显著基因筛选（按 adjusted p-value 和 LFC 阈值）和获取 top 差异表达基因。适用于 RNA-seq 差异表达分析。 ### 13. Suffix Array & Suffix Tree (libdivsufsort) @@ -2911,6 +2916,14 @@ E-step 对零计数计算来自 NB component 的后验 responsibility，正计 构造器和解析器会诊断无效BED字段、未排序记录、未知染色体、损坏magic、截断数据、异常树节点、非法zlib流及校验和不一致。当前范围不写入zoom levels或extra string indices；offset/count虽按u64布局读取和写入，但内存模型仍拒绝高32位非零的超大文件。writer的stored DEFLATE保证互操作性和确定性，但不追求压缩率。 +### 254. 自适应重尾效应量收缩 (Bioconductor apeglm) + +实现 Bioconductor `apeglm` 的 negative-binomial 路径，用于对 RNA-seq GLM 的目标系数执行自适应重尾后验收缩。`apeglm_fit` 接受 gene × sample 非负整数计数、sample × coefficient 设计矩阵、逐基因 dispersion，以及可选 log offset 和 observation weight；模型使用 `log(mu) = offset + X beta`，所有内部系数、阈值和先验尺度统一使用 natural-log scale。每个基因先拟合无先验 NB-GLM MLE，再以异方差 Efron-Morris 方程从跨基因 MLE/SE 自适应估计先验方差；目标系数使用可配置自由度的 Student-t 先验，默认 `df=1` 即 Cauchy，intercept 和其他 nuisance 系数使用宽 Normal no-shrink prior。 + +MAP 求解器实现阻尼 Newton、Cholesky 信息矩阵求解、逐级 ridge 正定化、最大步长、28 级回溯线搜索和严格参数边界；从 MLE、0 和先验尺度的正负倍数生成精确数量的确定性多起点并选取最高 posterior mode。MAP 处逆信息矩阵给出 Laplace posterior covariance、SD 和可配置可信区间；结果同时计算 local false sign rate、超过效应阈值时发生 false sign or small effect 的 FSOS probability，以及按 FSR 排序累计均值定义的 s-value。查询 API 支持名称/索引查找、MAP/SD 矩阵、排序、筛选、摘要和 natural-log/log2 TSV 导出。 + +`apeglm_from_deseq2` 读取 `DESeqDataSet` 的 counts、design、dispersion 和 size-factor log offset；`apeglm_summarized_experiment` 在不可变副本中增加 `apeglm_map`、`apeglm_sd`、`apeglm_fsr`、`apeglm_svalue` 和 `apeglm_fsos` assays 及模型 metadata。构造器会诊断 ragged、负数、非整数或非有限计数，无效 design/dispersion/offset/weight、全零权重和重复标识符。当前范围实现 dense negative-binomial backend 和 Laplace/Normal posterior approximation，不包含上游 beta-binomial backend、grid/HPD integration、稀疏矩阵专用优化或并行执行。 + ## 性能优化 ### 优化策略 @@ -3012,8 +3025,8 @@ E-step 对零计数计算来自 NB component 的后验 responsibility，正计 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8839 | -| 通过数 | 8839 | +| 总测试数 | 8905 | +| 通过数 | 8905 | | 失败数 | 0 | | 通过率 | 100% | @@ -3141,6 +3154,7 @@ moon test --update | decontX | `decontx_test.mbt` | 43 | | miloR | `milo_test.mbt` | 37 | | zinbwave | `zinbwave_test.mbt` | 54 | +| apeglm | `apeglm_test.mbt` | 66 | | monocle3 | `monocle3_test.mbt` | 10 | | ShortRead | `short_read_test.mbt` | 15 | | scater | `scater_test.mbt` | 17 | @@ -3415,7 +3429,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 361 个示例程序，展示各模块的典型用法： +项目提供 362 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3509,6 +3523,7 @@ moon run cmd/bench/main.mbt | decontx_demo | cluster/background ambient RNA去污染、每细胞污染率、marker校正、cluster诊断和不可变SCE输出 | `moon run examples/decontx_demo` | | milo_demo | 精确KNN图、精炼重叠邻域、样本计数、NB-GLM差异丰度、graph spatial FDR和SCE接入 | `moon run examples/milo_demo` | | zinbwave_demo | ZINB latent-factor拟合、dropout后验权重、归一化/插补/deviance residual和不可变SCE输出 | `moon run examples/zinbwave_demo` | +| apeglm_demo | NB-GLM MLE与自适应重尾MAP、FSR/s-value/FSOS、log2 TSV及不可变SummarizedExperiment输出 | `moon run examples/apeglm_demo` | | mast_demo | MAST 单细胞差异表达分析（Hurdle模型、离散/连续检验、BH-FDR校正、结果汇总） | `moon run examples/mast_demo/main.mbt` | | genomic_files_demo | GenomicFiles 分布式基因组文件处理（BAM/BED/VCF扫描、区间查询、归约、覆盖度计算） | `moon run examples/genomic_files_demo/main.mbt` | | diffbind_demo | DiffBind ChIP-seq差异结合分析（峰值重叠、共识峰识别、TMM归一化、负二项分布检验） | `moon run examples/diffbind_demo/main.mbt` | @@ -3715,6 +3730,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bio.Align.bigbed BigBed v4二进制区间格式（BED3-BED12、AutoSQL、多级B+ tree/R-tree、DEFLATE、区间/名称查询与BED导出） - ✅ 实现 Bioconductor decontX ambient RNA去污染（cluster-native/contaminant混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解与SCE集成） - ✅ 实现 Bioconductor zinbwave 零膨胀负二项低维模型（cell/gene协变量、offset、latent factors、dispersion shrinkage、observational weights、残差/插补与SCE集成） +- ✅ 实现 Bioconductor apeglm 自适应重尾效应量收缩（NB-GLM MLE、经验贝叶斯Cauchy/Student-t先验、多起点MAP、Laplace后验、FSR/FSOS/s-value与容器接入） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/apeglm_demo/main.mbt b/examples/apeglm_demo/main.mbt new file mode 100644 index 00000000..c09f3945 --- /dev/null +++ b/examples/apeglm_demo/main.mbt @@ -0,0 +1,126 @@ +///| +fn print_gene(result : @src.ApeglmResult, name : String) -> Unit { + match result.find_gene(name) { + Some(gene) => + println( + " " + + name + + ": MLE=" + + (gene.mle[result.coefficient] / @math.ln(2.0)).to_string() + + ", MAP=" + + gene.effect(result.coefficient, log2_scale=true).to_string() + + ", posterior SD=" + + gene.standard_error(result.coefficient, log2_scale=true).to_string() + + ", FSR=" + + gene.fsr.to_string() + + ", s-value=" + + gene.s_value.to_string() + + ", FSOS=" + + gene.threshold_probability.to_string(), + ) + None => abort("example gene not found: " + name) + } +} + +///| +fn main { + println("=== Bioconductor apeglm Demo ===") + let (counts, design, dispersions, genes, coefficients) = @src.apeglm_example_data() + let config = @src.ApeglmConfig::create(coefficient=2, threshold=@math.ln(2.0)) catch { + _ => abort("failed to create apeglm configuration") + } + + println("\n1. Fit a batch-adjusted negative-binomial GLM") + let result = @src.apeglm_fit( + counts, + design, + dispersions, + config~, + gene_names=genes, + coefficient_names=coefficients, + ) catch { + _ => abort("failed to fit apeglm model") + } + let summary = result.summary(maximum_s_value=0.1) + println( + " coefficient=" + + summary.coefficient_name + + ", genes=" + + summary.gene_count.to_string() + + ", converged=" + + summary.converged_count.to_string() + + ", selected=" + + summary.selected_count.to_string(), + ) + println( + " adaptive Cauchy scale=" + + result.prior_control.prior_scale.to_string() + + " (natural-log scale)", + ) + + println("\n2. Compare unshrunk MLEs with posterior MAP estimates") + print_gene(result, "strong_up") + print_gene(result, "strong_down") + print_gene(result, "low_noisy") + print_gene(result, "stable") + + println("\n3. Rank and select effects by directional error control") + let ranked = result.ranked() + println( + " top-ranked gene=" + + ranked[0].gene_name + + ", absolute MAP=" + + ranked[0].map[result.coefficient].abs().to_string(), + ) + println( + " genes with s-value <= 0.10: " + + result.select(maximum_s_value=0.1).length().to_string(), + ) + + println("\n4. Add posterior summaries to an immutable container copy") + let assays : Map[String, Array[Array[Double]]] = Map([]) + assays["counts"] = counts + let metadata : Map[String, String] = Map([]) + metadata["source"] = "apeglm_demo" + let experiment = @src.summarized_experiment(assays, [], [], metadata) + let output = @src.apeglm_summarized_experiment( + experiment, + design, + dispersions, + config~, + gene_names=genes, + coefficient_names=coefficients, + ) catch { + _ => abort("failed to integrate apeglm with SummarizedExperiment") + } + let posterior_map = match @src.se_assay(output.experiment, "apeglm_map") { + Some(value) => value + None => abort("posterior MAP assay missing") + } + println( + " posterior MAP rows=" + + posterior_map.length().to_string() + + ", source object unchanged=" + + (@src.se_assay(experiment, "apeglm_map") is None).to_string(), + ) + + println("\n5. Export a DESeq2-style log2 table") + println(result.to_tsv(log2_scale=true)) + + println("6. Invalid model inputs produce explicit diagnostics") + let rejected = try { + ignore( + @src.apeglm_fit([[1.0, -1.0], [2.0, 3.0]], [[1.0, 0.0], [1.0, 1.0]], [ + 0.1, 0.1, + ]), + ) + false + } catch { + ApeglmError(message) => { + println(" " + message) + true + } + } + println(" malformed counts rejected=" + rejected.to_string()) + println("\n=== Demo Complete ===") +} diff --git a/examples/apeglm_demo/moon.pkg b/examples/apeglm_demo/moon.pkg new file mode 100644 index 00000000..8824b1ac --- /dev/null +++ b/examples/apeglm_demo/moon.pkg @@ -0,0 +1,6 @@ +import { + "IvanAXu/BioSeqs/src", + "moonbitlang/core/hashmap", +} + +pkgtype(kind: "executable") diff --git a/src/apeglm.mbt b/src/apeglm.mbt new file mode 100644 index 00000000..a0f4d891 --- /dev/null +++ b/src/apeglm.mbt @@ -0,0 +1,1548 @@ +// Approximate posterior estimation for negative-binomial GLM coefficients. +// +// This module follows Bioconductor apeglm's nbinom workflow. Coefficients and +// prior scales use the natural-log scale; convenience output methods can +// convert effects to log2 scale. + +///| +pub suberror ApeglmError { + ApeglmError(String) +} + +///| +pub struct ApeglmConfig { + coefficient : Int + threshold : Double + interval_level : Double + prior_scale : Double + prior_df : Double + prior_no_shrink_scale : Double + adaptive_prior : Bool + multiplier : Double + max_iterations : Int + tolerance : Double + max_step : Double + random_starts : Int +} derive(Eq, Debug) + +///| +pub fn ApeglmConfig::create( + coefficient? : Int = -1, + threshold? : Double = 0.0, + interval_level? : Double = 0.95, + prior_scale? : Double = 1.0, + prior_df? : Double = 1.0, + prior_no_shrink_scale? : Double = 15.0, + adaptive_prior? : Bool = true, + multiplier? : Double = 1.0, + max_iterations? : Int = 100, + tolerance? : Double = 1.0e-7, + max_step? : Double = 2.0, + random_starts? : Int = 5, +) -> ApeglmConfig raise ApeglmError { + if coefficient < -1 { + raise ApeglmError("apeglm coefficient must be -1 or a zero-based index") + } + if !apeglm_is_finite(threshold) || threshold < 0.0 { + raise ApeglmError("apeglm threshold must be finite and non-negative") + } + if !apeglm_is_finite(interval_level) || + interval_level <= 0.0 || + interval_level >= 1.0 { + raise ApeglmError("apeglm interval level must be finite and in (0, 1)") + } + if !apeglm_is_finite(prior_scale) || prior_scale <= 0.0 { + raise ApeglmError("apeglm prior scale must be finite and positive") + } + if !apeglm_is_finite(prior_df) || prior_df <= 0.0 { + raise ApeglmError( + "apeglm prior degrees of freedom must be finite and positive", + ) + } + if !apeglm_is_finite(prior_no_shrink_scale) || prior_no_shrink_scale <= 0.0 { + raise ApeglmError( + "apeglm no-shrink prior scale must be finite and positive", + ) + } + if !apeglm_is_finite(multiplier) || multiplier <= 0.0 { + raise ApeglmError("apeglm prior multiplier must be finite and positive") + } + if max_iterations < 1 { + raise ApeglmError("apeglm maximum iterations must be positive") + } + if !apeglm_is_finite(tolerance) || tolerance <= 0.0 { + raise ApeglmError("apeglm tolerance must be finite and positive") + } + if !apeglm_is_finite(max_step) || max_step <= 0.0 { + raise ApeglmError("apeglm maximum Newton step must be finite and positive") + } + if random_starts < 1 { + raise ApeglmError("apeglm start count must be positive") + } + ApeglmConfig::{ + coefficient, + threshold, + interval_level, + prior_scale, + prior_df, + prior_no_shrink_scale, + adaptive_prior, + multiplier, + max_iterations, + tolerance, + max_step, + random_starts, + } +} + +///| +pub fn ApeglmConfig::default() -> ApeglmConfig { + ApeglmConfig::{ + coefficient: -1, + threshold: 0.0, + interval_level: 0.95, + prior_scale: 1.0, + prior_df: 1.0, + prior_no_shrink_scale: 15.0, + adaptive_prior: true, + multiplier: 1.0, + max_iterations: 100, + tolerance: 1.0e-7, + max_step: 2.0, + random_starts: 5, + } +} + +///| +pub struct ApeglmPriorControl { + no_shrink : Array[Int] + prior_mean : Double + prior_scale : Double + prior_variance : Double + prior_df : Double + prior_no_shrink_scale : Double + adaptive : Bool +} derive(Debug) + +///| +pub struct ApeglmGeneResult { + gene_name : String + base_mean : Double + mle : Array[Double] + mle_sd : Array[Double] + map : Array[Double] + posterior_sd : Array[Double] + fsr : Double + s_value : Double + threshold_probability : Double + interval_lower : Double + interval_upper : Double + log_posterior : Double + converged : Bool + iterations : Int +} derive(Debug) + +///| +pub struct ApeglmResult { + gene_names : Array[String] + coefficient_names : Array[String] + coefficient : Int + genes : Array[ApeglmGeneResult] + prior_control : ApeglmPriorControl + threshold : Double + interval_level : Double + config : ApeglmConfig +} derive(Debug) + +///| +pub struct ApeglmSummary { + gene_count : Int + converged_count : Int + selected_count : Int + low_fsr_count : Int + prior_scale : Double + median_absolute_effect : Double + coefficient_name : String +} derive(Eq, Debug) + +///| +pub struct ApeglmSummarizedExperimentOutput { + experiment : SummarizedExperiment + result : ApeglmResult +} + +///| +priv struct ApeglmEvaluation { + value : Double + gradient : Array[Double] + information : Array[Array[Double]] +} + +///| +priv struct ApeglmOptimization { + beta : Array[Double] + covariance : Array[Array[Double]] + value : Double + converged : Bool + iterations : Int +} + +///| +fn apeglm_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn apeglm_clamp(value : Double, lower : Double, upper : Double) -> Double { + value.max(lower).min(upper) +} + +///| +fn apeglm_zero_matrix(rows : Int, columns : Int) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for _ in 0.. Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in matrix { + output.push(row.copy()) + } + output +} + +///| +fn apeglm_mean(values : Array[Double]) -> Double { + if values.length() == 0 { + return 0.0 + } + let mut total = 0.0 + for value in values { + total = total + value + } + total / values.length().to_double() +} + +///| +fn apeglm_normal_cdf(value : Double) -> Double { + let absolute = value.abs() + let t = 1.0 / (1.0 + 0.2316419 * absolute) + let density = 0.3989422804014327 * @math.exp(-0.5 * absolute * absolute) + let tail = density * + t * + ( + 0.319381530 + + t * + (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))) + ) + if value >= 0.0 { + apeglm_clamp(1.0 - tail, 0.0, 1.0) + } else { + apeglm_clamp(tail, 0.0, 1.0) + } +} + +///| +fn apeglm_normal_quantile(probability : Double) -> Double { + let target = apeglm_clamp(probability, 1.0e-12, 1.0 - 1.0e-12) + let mut lower = -8.0 + let mut upper = 8.0 + for _ in 0..<80 { + let middle = 0.5 * (lower + upper) + if apeglm_normal_cdf(middle) < target { + lower = middle + } else { + upper = middle + } + } + 0.5 * (lower + upper) +} + +///| +fn apeglm_cholesky(matrix : Array[Array[Double]]) -> Array[Array[Double]]? { + let size = matrix.length() + if size == 0 { + return None + } + let lower = apeglm_zero_matrix(size, size) + for row in 0.. Array[Array[Double]]? { + let mut ridge = 0.0 + for attempt in 0..<14 { + let candidate = apeglm_copy_matrix(matrix) + for index in 0.. return Some(lower) + None => ridge = if attempt == 0 { 1.0e-10 } else { ridge * 10.0 } + } + } + None +} + +///| +fn apeglm_cholesky_solve( + lower : Array[Array[Double]], + right_hand_side : Array[Double], +) -> Array[Double] { + let size = lower.length() + let forward = Array::make(size, 0.0) + for row in 0..= 0 { + let mut value = forward[row] + for column in (row + 1).. Array[Array[Double]] { + let size = lower.length() + let inverse = apeglm_zero_matrix(size, size) + for column in 0.. Array[Double] { + match apeglm_regularized_cholesky(information) { + Some(lower) => apeglm_cholesky_solve(lower, gradient) + None => { + let output = Array::make(gradient.length(), 0.0) + for index in 0.. Array[Array[Double]] { + match apeglm_regularized_cholesky(information) { + Some(lower) => apeglm_cholesky_inverse(lower) + None => { + let output = apeglm_zero_matrix( + information.length(), + information.length(), + ) + for index in 0.. Unit raise ApeglmError { + if matrix.length() != rows { + raise ApeglmError(label + " row count does not match the expected shape") + } + for row in matrix { + if row.length() != columns { + raise ApeglmError(label + " must be rectangular with the expected shape") + } + for value in row { + if !apeglm_is_finite(value) || (non_negative && value < 0.0) { + raise ApeglmError(label + " contains an invalid value") + } + } + } +} + +///| +fn apeglm_validate_inputs( + counts : Array[Array[Double]], + design : Array[Array[Double]], + dispersions : Array[Double], + offsets : Array[Array[Double]], + weights : Array[Array[Double]], + gene_names : Array[String], + coefficient_names : Array[String], + config : ApeglmConfig, +) -> (Int, Int, Int, Int) raise ApeglmError { + if counts.length() == 0 { + raise ApeglmError("apeglm counts must contain at least one feature") + } + let samples = counts[0].length() + if samples < 2 { + raise ApeglmError("apeglm counts must contain at least two samples") + } + apeglm_validate_matrix( + counts, + counts.length(), + samples, + "apeglm counts", + true, + ) + for row in counts { + for value in row { + if (value - value.round()).abs() > 1.0e-8 { + raise ApeglmError("apeglm requires integer-valued counts") + } + } + } + if design.length() != samples { + raise ApeglmError("apeglm design rows must match the sample count") + } + if design.length() == 0 || design[0].length() < 2 { + raise ApeglmError( + "apeglm negative-binomial design requires an intercept and a coefficient", + ) + } + let coefficients = design[0].length() + apeglm_validate_matrix(design, samples, coefficients, "apeglm design", false) + let coefficient = if config.coefficient < 0 { + coefficients - 1 + } else { + config.coefficient + } + if coefficient <= 0 || coefficient >= coefficients { + raise ApeglmError( + "apeglm coefficient must select a non-intercept design column", + ) + } + if dispersions.length() != counts.length() { + raise ApeglmError("apeglm dispersions must match the feature count") + } + for dispersion in dispersions { + if !apeglm_is_finite(dispersion) || dispersion <= 0.0 { + raise ApeglmError("apeglm dispersions must be finite and positive") + } + } + if offsets.length() > 0 { + apeglm_validate_matrix( + offsets, + counts.length(), + samples, + "apeglm offsets", + false, + ) + } + if weights.length() > 0 { + apeglm_validate_matrix( + weights, + counts.length(), + samples, + "apeglm weights", + true, + ) + for row in weights { + let mut positive = false + for value in row { + if value > 0.0 { + positive = true + } + } + if !positive { + raise ApeglmError( + "apeglm each feature must have at least one positive weight", + ) + } + } + } + if gene_names.length() > 0 && gene_names.length() != counts.length() { + raise ApeglmError("apeglm gene names must match the feature count") + } + if coefficient_names.length() > 0 && + coefficient_names.length() != coefficients { + raise ApeglmError( + "apeglm coefficient names must match the design column count", + ) + } + (counts.length(), samples, coefficients, coefficient) +} + +///| +fn apeglm_names( + names : Array[String], + count : Int, + prefix : String, +) -> Array[String] raise ApeglmError { + if names.length() == 0 { + let generated : Array[String] = [] + for index in 0.. Array[Array[Double]] { + if offsets.length() == 0 { + apeglm_zero_matrix(genes, samples) + } else { + apeglm_copy_matrix(offsets) + } +} + +///| +fn apeglm_weights( + weights : Array[Array[Double]], + genes : Int, + samples : Int, +) -> Array[Array[Double]] { + if weights.length() == 0 { + let output : Array[Array[Double]] = [] + for _ in 0.. Double raise ApeglmError { + if counts.length() == 0 || design.length() != counts.length() { + raise ApeglmError( + "apeglm log-likelihood counts and design must have matching rows", + ) + } + let coefficients = beta.length() + for row in design { + if row.length() != coefficients { + raise ApeglmError("apeglm log-likelihood design columns must match beta") + } + } + if !apeglm_is_finite(dispersion) || dispersion <= 0.0 { + raise ApeglmError("apeglm log-likelihood dispersion must be positive") + } + if offsets.length() > 0 && offsets.length() != counts.length() { + raise ApeglmError("apeglm log-likelihood offsets have invalid length") + } + if weights.length() > 0 && weights.length() != counts.length() { + raise ApeglmError("apeglm log-likelihood weights have invalid length") + } + let size = 1.0 / dispersion + let mut result = 0.0 + for sample in 0.. ApeglmEvaluation { + let coefficients = beta.length() + let gradient = Array::make(coefficients, 0.0) + let information = apeglm_zero_matrix(coefficients, coefficients) + let size = 1.0 / dispersion + let mut value = 0.0 + for sample in 0.. Array[Double] { + let coefficients = design[0].length() + let beta = Array::make(coefficients, 0.0) + let mut count_total = 0.0 + let mut exposure_total = 0.0 + for sample in 0.. ApeglmOptimization { + let beta = initial.copy() + let mut evaluation = apeglm_evaluate( + counts, + design, + dispersion, + offsets, + weights, + beta, + coefficient, + with_prior, + prior_scale, + config.prior_df, + config.prior_no_shrink_scale, + ) + let mut converged = false + let mut iterations = 0 + for iteration in 0.. config.max_step { + config.max_step / maximum + } else { + 1.0 + } + let mut line_scale = step_scale + let mut accepted = false + let mut accepted_change = 0.0 + let mut accepted_beta = beta.copy() + let mut accepted_evaluation = evaluation + for _ in 0..<28 { + let candidate = beta.copy() + let mut change = 0.0 + for index in 0..= evaluation.value - 1.0e-10 { + accepted = true + accepted_change = change + accepted_beta = candidate + accepted_evaluation = next + break + } + line_scale = line_scale * 0.5 + } + if !accepted { + let mut maximum_gradient = 0.0 + for value in evaluation.gradient { + maximum_gradient = maximum_gradient.max(value.abs()) + } + converged = maximum_gradient <= config.tolerance * 10.0 + break + } + for index in 0.. Array[Array[Double]] { + let starts : Array[Array[Double]] = [mle.copy()] + if starts.length() < count { + let center = mle.copy() + center[coefficient] = 0.0 + starts.push(center) + } + let locations = [ + 2.0 * prior_scale, + -2.0 * prior_scale, + 4.0 * prior_scale, + -4.0 * prior_scale, + prior_scale, + -prior_scale, + ] + let mut index = 0 + while starts.length() < count && index < locations.length() { + let candidate = mle.copy() + candidate[coefficient] = locations[index] + starts.push(candidate) + index = index + 1 + } + let mut shell = 8.0 + while starts.length() < count { + let candidate = mle.copy() + let sign = if starts.length() % 2 == 0 { 1.0 } else { -1.0 } + candidate[coefficient] = apeglm_clamp( + sign * shell * prior_scale, + -30.0, + 30.0, + ) + starts.push(candidate) + if sign < 0.0 { + shell = shell * 2.0 + } + } + starts +} + +///| +fn apeglm_fit_map( + counts : Array[Double], + design : Array[Array[Double]], + dispersion : Double, + offsets : Array[Double], + weights : Array[Double], + mle : Array[Double], + coefficient : Int, + prior_scale : Double, + config : ApeglmConfig, +) -> ApeglmOptimization { + let starts = apeglm_target_starts( + mle, + coefficient, + prior_scale, + config.random_starts, + ) + let mut best = apeglm_optimize( + counts, + design, + dispersion, + offsets, + weights, + starts[0], + coefficient, + true, + prior_scale, + config, + ) + for index in 1.. best.value { + best = candidate + } + } + best +} + +///| +fn apeglm_standard_errors(covariance : Array[Array[Double]]) -> Array[Double] { + let output = Array::make(covariance.length(), 0.0) + for index in 0.. Double { + let mut numerator = 0.0 + let mut denominator = 0.0 + for index in 0.. Double raise ApeglmError { + if estimates.length() == 0 || estimates.length() != standard_errors.length() { + raise ApeglmError( + "apeglm prior adaptation requires matching non-empty MLE and SE arrays", + ) + } + if !apeglm_is_finite(minimum) || + !apeglm_is_finite(maximum) || + minimum <= 0.0 || + maximum <= minimum { + raise ApeglmError("apeglm prior variance bounds are invalid") + } + for index in 0..= 0.0 { + return maximum + } + let mut lower = minimum + let mut upper = maximum + for _ in 0..<100 { + let middle = 0.5 * (lower + upper) + if apeglm_prior_objective(middle, estimates, standard_errors) > 0.0 { + lower = middle + } else { + upper = middle + } + } + 0.5 * (lower + upper) +} + +///| +pub fn apeglm_s_values(local_fsr : Array[Double]) -> Array[Double] { + let count = local_fsr.length() + let order : Array[Int] = [] + for index in 0.. second || (first == second && order[right] > order[right + 1]) { + let temporary = order[right] + order[right] = order[right + 1] + order[right + 1] = temporary + } + } + } + let output = Array::make(count, 0.0) + let mut cumulative = 0.0 + for rank in 0.. Double { + let normalized : Array[Double] = [] + for sample in 0.. ApeglmGeneResult { + ApeglmGeneResult::{ + gene_name: gene.gene_name, + base_mean: gene.base_mean, + mle: gene.mle, + mle_sd: gene.mle_sd, + map: gene.map, + posterior_sd: gene.posterior_sd, + fsr: gene.fsr, + s_value, + threshold_probability: gene.threshold_probability, + interval_lower: gene.interval_lower, + interval_upper: gene.interval_upper, + log_posterior: gene.log_posterior, + converged: gene.converged, + iterations: gene.iterations, + } +} + +///| +pub fn apeglm_fit( + counts : Array[Array[Double]], + design : Array[Array[Double]], + dispersions : Array[Double], + config? : ApeglmConfig = ApeglmConfig::default(), + offsets? : Array[Array[Double]] = [], + weights? : Array[Array[Double]] = [], + gene_names? : Array[String] = [], + coefficient_names? : Array[String] = [], +) -> ApeglmResult raise ApeglmError { + let (gene_count, sample_count, coefficient_count, coefficient) = apeglm_validate_inputs( + counts, design, dispersions, offsets, weights, gene_names, coefficient_names, + config, + ) + let names = apeglm_names(gene_names, gene_count, "feature_") + let coefficients = apeglm_names( + coefficient_names, coefficient_count, "coefficient_", + ) + let model_offsets = apeglm_offsets(offsets, gene_count, sample_count) + let model_weights = apeglm_weights(weights, gene_count, sample_count) + let mle_fits : Array[ApeglmOptimization] = [] + let target_mle : Array[Double] = [] + let target_se : Array[Double] = [] + for gene in 0..= 0.0 { + apeglm_normal_cdf((config.threshold - estimate) / standard_error) + } else { + 1.0 - apeglm_normal_cdf((-config.threshold - estimate) / standard_error) + } + local_fsr.push(fsr) + raw_genes.push(ApeglmGeneResult::{ + gene_name: names[gene], + base_mean: apeglm_base_mean(counts[gene], model_offsets[gene]), + mle: mle_fit.beta.copy(), + mle_sd, + map: map_fit.beta.copy(), + posterior_sd, + fsr, + s_value: 0.0, + threshold_probability: apeglm_clamp(threshold_probability, 0.0, 1.0), + interval_lower: estimate - quantile * standard_error, + interval_upper: estimate + quantile * standard_error, + log_posterior: map_fit.value, + converged: map_fit.converged, + iterations: map_fit.iterations, + }) + } + let s_values = apeglm_s_values(local_fsr) + let genes : Array[ApeglmGeneResult] = [] + for index in 0.. Double { + let value = self.map[coefficient] + if log2_scale { + value / @math.ln(2.0) + } else { + value + } +} + +///| +pub fn ApeglmGeneResult::standard_error( + self : ApeglmGeneResult, + coefficient : Int, + log2_scale? : Bool = false, +) -> Double { + let value = self.posterior_sd[coefficient] + if log2_scale { + value / @math.ln(2.0) + } else { + value + } +} + +///| +pub fn ApeglmResult::map_matrix(self : ApeglmResult) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for gene in self.genes { + output.push(gene.map.copy()) + } + output +} + +///| +pub fn ApeglmResult::sd_matrix(self : ApeglmResult) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for gene in self.genes { + output.push(gene.posterior_sd.copy()) + } + output +} + +///| +pub fn ApeglmResult::gene( + self : ApeglmResult, + index : Int, +) -> ApeglmGeneResult? { + if index < 0 || index >= self.genes.length() { + None + } else { + Some(self.genes[index]) + } +} + +///| +pub fn ApeglmResult::find_gene( + self : ApeglmResult, + name : String, +) -> ApeglmGeneResult? { + for gene in self.genes { + if gene.gene_name == name { + return Some(gene) + } + } + None +} + +///| +pub fn ApeglmResult::ranked(self : ApeglmResult) -> Array[ApeglmGeneResult] { + let output = self.genes.copy() + for left in 0.. second.s_value || + (first.s_value == second.s_value && first_effect < second_effect) { + output[right] = second + output[right + 1] = first + } + } + } + output +} + +///| +pub fn ApeglmResult::select( + self : ApeglmResult, + maximum_s_value? : Double = 0.05, + minimum_absolute_effect? : Double = 0.0, + use_threshold_probability? : Bool = false, +) -> Array[ApeglmGeneResult] { + let output : Array[ApeglmGeneResult] = [] + for gene in self.genes { + let probability = if use_threshold_probability { + gene.threshold_probability + } else { + gene.s_value + } + if probability <= maximum_s_value && + gene.map[self.coefficient].abs() >= minimum_absolute_effect { + output.push(gene) + } + } + output +} + +///| +pub fn ApeglmResult::summary( + self : ApeglmResult, + maximum_s_value? : Double = 0.05, +) -> ApeglmSummary { + let mut converged_count = 0 + let mut low_fsr_count = 0 + let effects : Array[Double] = [] + for gene in self.genes { + if gene.converged { + converged_count = converged_count + 1 + } + if gene.fsr <= maximum_s_value { + low_fsr_count = low_fsr_count + 1 + } + effects.push(gene.map[self.coefficient].abs()) + } + effects.sort() + let median_absolute_effect = if effects.length() == 0 { + 0.0 + } else if effects.length() % 2 == 1 { + effects[effects.length() / 2] + } else { + let middle = effects.length() / 2 + 0.5 * (effects[middle - 1] + effects[middle]) + } + ApeglmSummary::{ + gene_count: self.genes.length(), + converged_count, + selected_count: self.select(maximum_s_value~).length(), + low_fsr_count, + prior_scale: self.prior_control.prior_scale, + median_absolute_effect, + coefficient_name: self.coefficient_names[self.coefficient], + } +} + +///| +pub fn ApeglmResult::to_tsv( + self : ApeglmResult, + log2_scale? : Bool = true, +) -> String { + let output = StringBuilder::new() + let scale_label = if log2_scale { "log2" } else { "ln" } + output.write_string( + "gene\tbaseMean\t" + + scale_label + + "MLE\t" + + scale_label + + "MAP\tposteriorSD\tFSR\tsvalue\tFSOS\tintervalLower\tintervalUpper\tconverged\n", + ) + let divisor = if log2_scale { @math.ln(2.0) } else { 1.0 } + for gene in self.genes { + output.write_string(gene.gene_name) + output.write_string("\t") + output.write_string(gene.base_mean.to_string()) + output.write_string("\t") + output.write_string((gene.mle[self.coefficient] / divisor).to_string()) + output.write_string("\t") + output.write_string((gene.map[self.coefficient] / divisor).to_string()) + output.write_string("\t") + output.write_string( + (gene.posterior_sd[self.coefficient] / divisor).to_string(), + ) + output.write_string("\t") + output.write_string(gene.fsr.to_string()) + output.write_string("\t") + output.write_string(gene.s_value.to_string()) + output.write_string("\t") + output.write_string(gene.threshold_probability.to_string()) + output.write_string("\t") + output.write_string((gene.interval_lower / divisor).to_string()) + output.write_string("\t") + output.write_string((gene.interval_upper / divisor).to_string()) + output.write_string("\t") + output.write_string(gene.converged.to_string()) + output.write_string("\n") + } + output.to_string() +} + +///| +pub fn apeglm_from_deseq2( + dataset : DESeqDataSet, + config? : ApeglmConfig = ApeglmConfig::default(), + coefficient_names? : Array[String] = [], +) -> ApeglmResult raise ApeglmError { + let counts : Array[Array[Double]] = [] + for row in dataset.counts { + let converted : Array[Double] = [] + for value in row { + converted.push(value.to_double()) + } + counts.push(converted) + } + let samples = if counts.length() == 0 { 0 } else { counts[0].length() } + if dataset.size_factors.length() != samples { + raise ApeglmError("apeglm DESeq2 size factors must match the sample count") + } + let offsets : Array[Array[Double]] = [] + for _ in 0.. SummarizedExperiment { + let assays : Map[String, Array[Array[Double]]] = Map([]) + for key in experiment.assays.keys() { + assays[key] = apeglm_copy_matrix(experiment.assays[key]) + } + let metadata : Map[String, String] = Map([]) + for key in experiment.metadata.keys() { + metadata[key] = experiment.metadata[key] + } + SummarizedExperiment::{ + assays, + row_ranges: experiment.row_ranges.copy(), + col_data: experiment.col_data.copy(), + metadata, + } +} + +///| +pub fn apeglm_summarized_experiment( + experiment : SummarizedExperiment, + design : Array[Array[Double]], + dispersions : Array[Double], + config? : ApeglmConfig = ApeglmConfig::default(), + assay_name? : String = "counts", + offsets? : Array[Array[Double]] = [], + weights? : Array[Array[Double]] = [], + gene_names? : Array[String] = [], + coefficient_names? : Array[String] = [], +) -> ApeglmSummarizedExperimentOutput raise ApeglmError { + let counts = match se_assay(experiment, assay_name) { + Some(value) => value + None => + raise ApeglmError( + "apeglm SummarizedExperiment assay not found: " + assay_name, + ) + } + let result = apeglm_fit( + counts, + design, + dispersions, + config~, + offsets~, + weights~, + gene_names~, + coefficient_names~, + ) + let enriched = apeglm_copy_summarized_experiment(experiment) + let map : Array[Array[Double]] = [] + let standard_error : Array[Array[Double]] = [] + let fsr : Array[Array[Double]] = [] + let s_value : Array[Array[Double]] = [] + let threshold_probability : Array[Array[Double]] = [] + for gene in result.genes { + map.push([gene.map[result.coefficient]]) + standard_error.push([gene.posterior_sd[result.coefficient]]) + fsr.push([gene.fsr]) + s_value.push([gene.s_value]) + threshold_probability.push([gene.threshold_probability]) + } + enriched.assays["apeglm_map"] = map + enriched.assays["apeglm_sd"] = standard_error + enriched.assays["apeglm_fsr"] = fsr + enriched.assays["apeglm_svalue"] = s_value + enriched.assays["apeglm_fsos"] = threshold_probability + enriched.metadata["apeglm_coefficient"] = result.coefficient_names[result.coefficient] + enriched.metadata["apeglm_prior_scale"] = result.prior_control.prior_scale.to_string() + enriched.metadata["apeglm_scale"] = "natural-log" + ApeglmSummarizedExperimentOutput::{ experiment: enriched, result } +} + +///| +pub fn apeglm_example_data() -> ( + Array[Array[Double]], + Array[Array[Double]], + Array[Double], + Array[String], + Array[String], +) { + let counts = [ + [48.0, 52.0, 45.0, 54.0, 198.0, 220.0, 205.0, 230.0], + [160.0, 148.0, 171.0, 155.0, 39.0, 44.0, 35.0, 41.0], + [72.0, 68.0, 75.0, 70.0, 79.0, 74.0, 77.0, 73.0], + [0.0, 1.0, 0.0, 0.0, 4.0, 0.0, 5.0, 0.0], + [12.0, 20.0, 15.0, 18.0, 27.0, 19.0, 31.0, 23.0], + [310.0, 290.0, 325.0, 305.0, 640.0, 615.0, 670.0, 650.0], + [9.0, 8.0, 11.0, 10.0, 8.0, 12.0, 9.0, 11.0], + [3.0, 0.0, 2.0, 1.0, 0.0, 1.0, 0.0, 2.0], + ] + let design = [ + [1.0, 0.0, 0.0], + [1.0, 1.0, 0.0], + [1.0, 0.0, 0.0], + [1.0, 1.0, 0.0], + [1.0, 0.0, 1.0], + [1.0, 1.0, 1.0], + [1.0, 0.0, 1.0], + [1.0, 1.0, 1.0], + ] + let dispersions = [0.08, 0.08, 0.1, 0.8, 0.25, 0.05, 0.2, 0.9] + let genes = [ + "strong_up", "strong_down", "stable", "low_noisy", "moderate_up", "abundant_up", + "null_low", "sparse_null", + ] + let coefficient_names = ["intercept", "batch", "condition"] + (counts, design, dispersions, genes, coefficient_names) +} diff --git a/test/moonbit/apeglm_test.mbt b/test/moonbit/apeglm_test.mbt new file mode 100644 index 00000000..e9bb2a90 --- /dev/null +++ b/test/moonbit/apeglm_test.mbt @@ -0,0 +1,1321 @@ +// Tests for the Bioconductor apeglm-inspired heavy-tailed LFC shrinkage. + +///| +fn apeglm_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "apeglm value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn apeglm_test_config() -> @src.ApeglmConfig { + @src.ApeglmConfig::create( + coefficient=2, + threshold=@math.ln(2.0), + ) catch { + _ => abort("test configuration should be valid") + } +} + +///| +fn apeglm_test_result() -> @src.ApeglmResult { + let (counts, design, dispersions, genes, coefficients) = + @src.apeglm_example_data() + let config = apeglm_test_config() + @src.apeglm_fit( + counts, + design, + dispersions, + config~, + gene_names=genes, + coefficient_names=coefficients, + ) catch { + _ => abort("example apeglm fit should succeed") + } +} + +///| +fn apeglm_test_gene( + result : @src.ApeglmResult, + name : String, +) -> @src.ApeglmGeneResult { + match result.find_gene(name) { + Some(gene) => gene + None => abort("expected apeglm gene: " + name) + } +} + +///| +fn apeglm_test_zero_matrix( + rows : Int, + columns : Int, +) -> Array[Array[Double]] { + let matrix : Array[Array[Double]] = [] + for _ in 0.. @src.SummarizedExperiment { + let (counts, _, _, _, _) = @src.apeglm_example_data() + let assays : Map[String, Array[Array[Double]]] = Map([("counts", counts)]) + let metadata : Map[String, String] = Map([("source", "apeglm_test")]) + @src.summarized_experiment(assays, [], [], metadata) +} + +///| +test "apeglm: default configuration exposes inference controls" { + let config = @src.ApeglmConfig::default() + assert_eq(config.coefficient, -1) + assert_eq(config.threshold, 0.0) + assert_eq(config.interval_level, 0.95) + assert_eq(config.prior_scale, 1.0) + assert_eq(config.prior_df, 1.0) + assert_eq(config.prior_no_shrink_scale, 15.0) + assert_true(config.adaptive_prior) + assert_eq(config.random_starts, 5) +} + +///| +test "apeglm: custom configuration preserves parameters" { + let config = @src.ApeglmConfig::create( + coefficient=1, + threshold=0.5, + interval_level=0.9, + prior_scale=0.7, + prior_df=3.0, + prior_no_shrink_scale=12.0, + adaptive_prior=false, + multiplier=1.5, + max_iterations=40, + tolerance=1.0e-6, + max_step=1.0, + random_starts=9, + ) catch { + _ => abort("custom configuration should be valid") + } + assert_eq(config.coefficient, 1) + assert_eq(config.threshold, 0.5) + assert_eq(config.interval_level, 0.9) + assert_eq(config.prior_df, 3.0) + assert_false(config.adaptive_prior) + assert_eq(config.max_iterations, 40) + assert_eq(config.random_starts, 9) +} + +///| +test "apeglm: configuration rejects invalid coefficient indices" { + let raised = try { + ignore(@src.ApeglmConfig::create(coefficient=-2)) + false + } catch { + ApeglmError(_) => true + } + assert_true(raised) +} + +///| +test "apeglm: configuration rejects invalid probability controls" { + let threshold = try { + ignore(@src.ApeglmConfig::create(threshold=-0.1)) + false + } catch { + ApeglmError(_) => true + } + let interval = try { + ignore(@src.ApeglmConfig::create(interval_level=1.0)) + false + } catch { + ApeglmError(_) => true + } + assert_true(threshold) + assert_true(interval) +} + +///| +test "apeglm: configuration rejects invalid prior controls" { + let scale = try { + ignore(@src.ApeglmConfig::create(prior_scale=0.0)) + false + } catch { + ApeglmError(_) => true + } + let degrees = try { + ignore(@src.ApeglmConfig::create(prior_df=-1.0)) + false + } catch { + ApeglmError(_) => true + } + let nuisance = try { + ignore(@src.ApeglmConfig::create(prior_no_shrink_scale=0.0)) + false + } catch { + ApeglmError(_) => true + } + let multiplier = try { + ignore(@src.ApeglmConfig::create(multiplier=0.0)) + false + } catch { + ApeglmError(_) => true + } + assert_true(scale) + assert_true(degrees) + assert_true(nuisance) + assert_true(multiplier) +} + +///| +test "apeglm: configuration rejects invalid optimizer controls" { + let iterations = try { + ignore(@src.ApeglmConfig::create(max_iterations=0)) + false + } catch { + ApeglmError(_) => true + } + let tolerance = try { + ignore(@src.ApeglmConfig::create(tolerance=0.0)) + false + } catch { + ApeglmError(_) => true + } + let step = try { + ignore(@src.ApeglmConfig::create(max_step=-1.0)) + false + } catch { + ApeglmError(_) => true + } + let starts = try { + ignore(@src.ApeglmConfig::create(random_starts=0)) + false + } catch { + ApeglmError(_) => true + } + assert_true(iterations) + assert_true(tolerance) + assert_true(step) + assert_true(starts) +} + +///| +test "apeglm: example data has gene by sample orientation" { + let (counts, design, dispersions, genes, coefficients) = + @src.apeglm_example_data() + assert_eq(counts.length(), 8) + assert_eq(counts[0].length(), 8) + assert_eq(design.length(), 8) + assert_eq(design[0].length(), 3) + assert_eq(dispersions.length(), 8) + assert_eq(genes.length(), 8) + assert_eq(coefficients.length(), 3) +} + +///| +test "apeglm: example data identifies intended signals" { + let (_, design, _, genes, coefficients) = @src.apeglm_example_data() + assert_eq(genes[0], "strong_up") + assert_eq(genes[1], "strong_down") + assert_eq(genes[3], "low_noisy") + assert_eq(coefficients, ["intercept", "batch", "condition"]) + assert_eq(design[0], [1.0, 0.0, 0.0]) + assert_eq(design[4], [1.0, 0.0, 1.0]) +} + +///| +test "apeglm: fit dimensions match inputs" { + let result = apeglm_test_result() + assert_eq(result.genes.length(), 8) + assert_eq(result.gene_names.length(), 8) + assert_eq(result.coefficient_names.length(), 3) + assert_eq(result.coefficient, 2) + assert_eq(result.genes[0].map.length(), 3) + assert_eq(result.genes[0].posterior_sd.length(), 3) +} + +///| +test "apeglm: omitted names are generated deterministically" { + let result = @src.apeglm_fit( + [[10.0, 11.0, 20.0, 22.0]], + [[1.0, 0.0], [1.0, 0.0], [1.0, 1.0], [1.0, 1.0]], + [0.1], + ) catch { + _ => abort("small apeglm fit should succeed") + } + assert_eq(result.gene_names, ["feature_1"]) + assert_eq(result.coefficient_names, ["coefficient_1", "coefficient_2"]) +} + +///| +test "apeglm: default target is the last design coefficient" { + let result = @src.apeglm_fit( + [[5.0, 6.0, 10.0, 12.0]], + [ + [1.0, 0.0, 0.0], + [1.0, 1.0, 0.0], + [1.0, 0.0, 1.0], + [1.0, 1.0, 1.0], + ], + [0.2], + ) catch { + _ => abort("default coefficient fit should succeed") + } + assert_eq(result.coefficient, 2) +} + +///| +test "apeglm: nuisance coefficients are marked no-shrink" { + let result = apeglm_test_result() + assert_eq(result.prior_control.no_shrink, [0, 1]) + assert_eq(result.prior_control.prior_mean, 0.0) + assert_eq(result.prior_control.prior_df, 1.0) +} + +///| +test "apeglm: example genes converge" { + let result = apeglm_test_result() + for gene in result.genes { + assert_true(gene.converged) + assert_true(gene.iterations > 0) + assert_true(gene.iterations <= result.config.max_iterations) + } +} + +///| +test "apeglm: strong effects retain their directions" { + let result = apeglm_test_result() + let up = apeglm_test_gene(result, "strong_up") + let down = apeglm_test_gene(result, "strong_down") + assert_true(up.map[result.coefficient] > 1.0) + assert_true(down.map[result.coefficient] < -1.0) +} + +///| +test "apeglm: strong effects are only mildly shrunk" { + let result = apeglm_test_result() + for name in ["strong_up", "strong_down"] { + let gene = apeglm_test_gene(result, name) + let mle = gene.mle[result.coefficient].abs() + let map = gene.map[result.coefficient].abs() + assert_true(map <= mle + 1.0e-8) + assert_true(map >= 0.8 * mle) + } +} + +///| +test "apeglm: low-count noisy effect is strongly shrunk" { + let result = apeglm_test_result() + let gene = apeglm_test_gene(result, "low_noisy") + let mle = gene.mle[result.coefficient].abs() + let map = gene.map[result.coefficient].abs() + assert_true(mle > 1.0) + assert_true(map < 0.4 * mle) +} + +///| +test "apeglm: Cauchy tail preserves large effects" { + let result = apeglm_test_result() + let strong = apeglm_test_gene(result, "strong_up") + let noisy = apeglm_test_gene(result, "low_noisy") + let strong_ratio = strong.map[result.coefficient].abs() / + strong.mle[result.coefficient].abs() + let noisy_ratio = noisy.map[result.coefficient].abs() / + noisy.mle[result.coefficient].abs() + assert_true(strong_ratio > noisy_ratio) + assert_true(strong_ratio > 0.9) +} + +///| +test "apeglm: stable gene remains near zero" { + let result = apeglm_test_result() + let stable = apeglm_test_gene(result, "stable") + assert_true(stable.map[result.coefficient].abs() < 0.2) + assert_true(stable.fsr > 0.3) +} + +///| +test "apeglm: abundant moderate signal remains detectable" { + let result = apeglm_test_result() + let gene = apeglm_test_gene(result, "abundant_up") + assert_true(gene.map[result.coefficient] > 0.5) + assert_true(gene.fsr < 1.0e-3) +} + +///| +test "apeglm: posterior standard deviations are finite and positive" { + let result = apeglm_test_result() + for gene in result.genes { + for value in gene.posterior_sd { + assert_true(value > 0.0) + assert_true(value < 1.0e300) + assert_true(value == value) + } + } +} + +///| +test "apeglm: posterior intervals contain MAP estimates" { + let result = apeglm_test_result() + for gene in result.genes { + let estimate = gene.map[result.coefficient] + assert_true(gene.interval_lower < estimate) + assert_true(gene.interval_upper > estimate) + } +} + +///| +test "apeglm: local posterior probabilities are bounded" { + let result = apeglm_test_result() + for gene in result.genes { + assert_true(gene.fsr >= 0.0 && gene.fsr <= 0.5) + assert_true(gene.s_value >= 0.0 && gene.s_value <= 0.5) + assert_true( + gene.threshold_probability >= 0.0 && + gene.threshold_probability <= 1.0, + ) + } +} + +///| +test "apeglm: strong signals have lower FSR than null genes" { + let result = apeglm_test_result() + let up = apeglm_test_gene(result, "strong_up") + let down = apeglm_test_gene(result, "strong_down") + let null = apeglm_test_gene(result, "null_low") + assert_true(up.fsr < null.fsr) + assert_true(down.fsr < null.fsr) +} + +///| +test "apeglm: threshold probability distinguishes large effects" { + let result = apeglm_test_result() + let up = apeglm_test_gene(result, "strong_up") + let stable = apeglm_test_gene(result, "stable") + assert_true(up.threshold_probability < 0.01) + assert_true(stable.threshold_probability > 0.9) +} + +///| +test "apeglm: s-values use cumulative mean in FSR order" { + let values = @src.apeglm_s_values([0.3, 0.1, 0.2]) + apeglm_test_close(values[1], 0.1, 1.0e-12) + apeglm_test_close(values[2], 0.15, 1.0e-12) + apeglm_test_close(values[0], 0.2, 1.0e-12) +} + +///| +test "apeglm: s-values support empty and tied inputs" { + assert_eq(@src.apeglm_s_values([]), []) + assert_eq(@src.apeglm_s_values([0.2, 0.2]), [0.2, 0.2]) +} + +///| +test "apeglm: empirical Bayes prior variance is positive" { + let variance = @src.apeglm_prior_variance( + [1.5, -1.2, 0.1, 0.0], + [0.2, 0.3, 0.5, 0.6], + ) catch { + _ => abort("prior variance estimation should succeed") + } + assert_true(variance >= 1.0e-6) + assert_true(variance <= 400.0) +} + +///| +test "apeglm: empirical prior variance responds to effect spread" { + let narrow = @src.apeglm_prior_variance( + [0.1, -0.1, 0.0], + [0.5, 0.5, 0.5], + ) catch { + _ => abort("narrow prior estimate should succeed") + } + let broad = @src.apeglm_prior_variance( + [3.0, -3.0, 2.5], + [0.5, 0.5, 0.5], + ) catch { + _ => abort("broad prior estimate should succeed") + } + assert_true(broad > narrow) +} + +///| +test "apeglm: prior variance respects custom bounds" { + let variance = @src.apeglm_prior_variance( + [100.0, -100.0], + [0.1, 0.1], + minimum=0.01, + maximum=5.0, + ) catch { + _ => abort("bounded prior estimate should succeed") + } + apeglm_test_close(variance, 5.0, 1.0e-10) +} + +///| +test "apeglm: prior variance rejects malformed inputs" { + let length = try { + ignore(@src.apeglm_prior_variance([1.0], [0.1, 0.2])) + false + } catch { + ApeglmError(_) => true + } + let standard_error = try { + ignore(@src.apeglm_prior_variance([1.0], [0.0])) + false + } catch { + ApeglmError(_) => true + } + let bounds = try { + ignore(@src.apeglm_prior_variance([1.0], [0.1], minimum=2.0, maximum=1.0)) + false + } catch { + ApeglmError(_) => true + } + assert_true(length) + assert_true(standard_error) + assert_true(bounds) +} + +///| +test "apeglm: adaptive fit reports learned prior" { + let result = apeglm_test_result() + assert_true(result.prior_control.adaptive) + assert_true(result.prior_control.prior_variance > 0.0) + assert_true(result.prior_control.prior_scale >= 0.001) + assert_true(result.prior_control.prior_scale <= 1.0) +} + +///| +test "apeglm: fixed prior preserves configured scale" { + let (counts, design, dispersions, genes, coefficients) = + @src.apeglm_example_data() + let config = @src.ApeglmConfig::create( + coefficient=2, + prior_scale=0.4, + adaptive_prior=false, + ) catch { + _ => abort("fixed prior configuration should succeed") + } + let result = @src.apeglm_fit( + counts, + design, + dispersions, + config~, + gene_names=genes, + coefficient_names=coefficients, + ) catch { + _ => abort("fixed prior fit should succeed") + } + assert_false(result.prior_control.adaptive) + apeglm_test_close(result.prior_control.prior_scale, 0.4, 1.0e-12) + apeglm_test_close(result.prior_control.prior_variance, 0.16, 1.0e-12) +} + +///| +test "apeglm: adaptive multiplier obeys scale cap" { + let (counts, design, dispersions, _, _) = @src.apeglm_example_data() + let config = @src.ApeglmConfig::create( + coefficient=2, + multiplier=100.0, + ) catch { + _ => abort("multiplier configuration should succeed") + } + let result = @src.apeglm_fit(counts, design, dispersions, config~) catch { + _ => abort("multiplier fit should succeed") + } + apeglm_test_close(result.prior_control.prior_scale, 1.0, 1.0e-12) +} + +///| +test "apeglm: NB log-likelihood favors group-specific means" { + let counts = [10.0, 10.0, 40.0, 40.0] + let design = [[1.0, 0.0], [1.0, 0.0], [1.0, 1.0], [1.0, 1.0]] + let null = @src.apeglm_log_likelihood_nb( + counts, + design, + [@math.ln(25.0), 0.0], + 0.1, + ) catch { + _ => abort("null likelihood should succeed") + } + let fitted = @src.apeglm_log_likelihood_nb( + counts, + design, + [@math.ln(10.0), @math.ln(4.0)], + 0.1, + ) catch { + _ => abort("fitted likelihood should succeed") + } + assert_true(fitted > null) +} + +///| +test "apeglm: zero likelihood weight excludes an observation" { + let weighted = @src.apeglm_log_likelihood_nb( + [5.0, 100.0], + [[1.0], [1.0]], + [@math.ln(5.0)], + 0.2, + weights=[1.0, 0.0], + ) catch { + _ => abort("weighted likelihood should succeed") + } + let reference = @src.apeglm_log_likelihood_nb( + [5.0], + [[1.0]], + [@math.ln(5.0)], + 0.2, + ) catch { + _ => abort("reference likelihood should succeed") + } + apeglm_test_close(weighted, reference, 1.0e-12) +} + +///| +test "apeglm: likelihood offsets shift the linear predictor" { + let with_offset = @src.apeglm_log_likelihood_nb( + [2.0, 3.0], + [[1.0], [1.0]], + [0.0], + 0.2, + offsets=[@math.ln(2.0), @math.ln(2.0)], + ) catch { + _ => abort("offset likelihood should succeed") + } + let with_beta = @src.apeglm_log_likelihood_nb( + [2.0, 3.0], + [[1.0], [1.0]], + [@math.ln(2.0)], + 0.2, + ) catch { + _ => abort("shifted beta likelihood should succeed") + } + apeglm_test_close(with_offset, with_beta, 1.0e-12) +} + +///| +test "apeglm: likelihood rejects incompatible dimensions" { + let rows = try { + ignore( + @src.apeglm_log_likelihood_nb( + [1.0, 2.0], + [[1.0]], + [0.0], + 0.1, + ), + ) + false + } catch { + ApeglmError(_) => true + } + let columns = try { + ignore( + @src.apeglm_log_likelihood_nb( + [1.0], + [[1.0, 0.0]], + [0.0], + 0.1, + ), + ) + false + } catch { + ApeglmError(_) => true + } + assert_true(rows) + assert_true(columns) +} + +///| +test "apeglm: likelihood rejects invalid dispersion and auxiliaries" { + let dispersion = try { + ignore(@src.apeglm_log_likelihood_nb([1.0], [[1.0]], [0.0], 0.0)) + false + } catch { + ApeglmError(_) => true + } + let offsets = try { + ignore( + @src.apeglm_log_likelihood_nb( + [1.0, 2.0], + [[1.0], [1.0]], + [0.0], + 0.1, + offsets=[0.0], + ), + ) + false + } catch { + ApeglmError(_) => true + } + let weights = try { + ignore( + @src.apeglm_log_likelihood_nb( + [1.0, 2.0], + [[1.0], [1.0]], + [0.0], + 0.1, + weights=[1.0], + ), + ) + false + } catch { + ApeglmError(_) => true + } + assert_true(dispersion) + assert_true(offsets) + assert_true(weights) +} + +///| +test "apeglm: explicit zero offsets match omitted offsets" { + let (counts, design, dispersions, genes, coefficients) = + @src.apeglm_example_data() + let config = apeglm_test_config() + let baseline = @src.apeglm_fit( + counts, + design, + dispersions, + config~, + gene_names=genes, + coefficient_names=coefficients, + ) catch { + _ => abort("baseline fit should succeed") + } + let shifted = @src.apeglm_fit( + counts, + design, + dispersions, + config~, + offsets=apeglm_test_zero_matrix(8, 8), + gene_names=genes, + coefficient_names=coefficients, + ) catch { + _ => abort("zero offset fit should succeed") + } + apeglm_test_close( + baseline.genes[0].map[2], + shifted.genes[0].map[2], + 1.0e-12, + ) +} + +///| +test "apeglm: zero observation weights suppress an outlier" { + let config = @src.ApeglmConfig::create( + coefficient=1, + adaptive_prior=false, + prior_scale=1.0, + ) catch { + _ => abort("weight test configuration should succeed") + } + let result = @src.apeglm_fit( + [[10.0, 10.0, 20.0, 1000.0]], + [[1.0, 0.0], [1.0, 0.0], [1.0, 1.0], [1.0, 1.0]], + [0.1], + config~, + weights=[[1.0, 1.0, 1.0, 0.0]], + ) catch { + _ => abort("weighted fit should succeed") + } + assert_true(result.genes[0].map[1] > 0.0) + assert_true(result.genes[0].map[1] < 2.0) +} + +///| +test "apeglm: custom target coefficient is honored" { + let (counts, design, dispersions, genes, coefficients) = + @src.apeglm_example_data() + let config = @src.ApeglmConfig::create(coefficient=1) catch { + _ => abort("batch target configuration should succeed") + } + let result = @src.apeglm_fit( + counts, + design, + dispersions, + config~, + gene_names=genes, + coefficient_names=coefficients, + ) catch { + _ => abort("batch target fit should succeed") + } + assert_eq(result.coefficient, 1) + assert_eq(result.prior_control.no_shrink, [0, 2]) + assert_eq(result.summary().coefficient_name, "batch") +} + +///| +test "apeglm: MAP and SD matrix accessors preserve dimensions" { + let result = apeglm_test_result() + let maps = result.map_matrix() + let standard_errors = result.sd_matrix() + assert_eq(maps.length(), 8) + assert_eq(maps[0].length(), 3) + assert_eq(standard_errors.length(), 8) + assert_eq(standard_errors[0].length(), 3) + apeglm_test_close(maps[0][2], result.genes[0].map[2], 1.0e-12) +} + +///| +test "apeglm: matrix accessors return independent arrays" { + let result = apeglm_test_result() + let maps = result.map_matrix() + let original = result.genes[0].map[0] + maps[0][0] = original + 100.0 + apeglm_test_close(result.genes[0].map[0], original, 1.0e-12) +} + +///| +test "apeglm: index lookup handles bounds" { + let result = apeglm_test_result() + match result.gene(0) { + Some(gene) => assert_eq(gene.gene_name, "strong_up") + None => abort("first gene should exist") + } + assert_true(result.gene(-1) is None) + assert_true(result.gene(8) is None) +} + +///| +test "apeglm: name lookup finds and rejects genes" { + let result = apeglm_test_result() + match result.find_gene("stable") { + Some(gene) => assert_eq(gene.gene_name, "stable") + None => abort("stable gene should exist") + } + assert_true(result.find_gene("missing") is None) +} + +///| +test "apeglm: ranking prioritizes low directional error" { + let result = apeglm_test_result() + let ranked = result.ranked() + assert_eq(ranked.length(), 8) + assert_true(ranked[0].s_value <= ranked[1].s_value) + assert_true( + ranked[0].gene_name == "strong_up" || + ranked[0].gene_name == "strong_down", + ) +} + +///| +test "apeglm: selection applies s-value and effect filters" { + let result = apeglm_test_result() + let broad = result.select(maximum_s_value=0.1) + let strict = result.select( + maximum_s_value=0.1, + minimum_absolute_effect=1.0, + ) + assert_true(broad.length() >= strict.length()) + for gene in strict { + assert_true(gene.s_value <= 0.1) + assert_true(gene.map[result.coefficient].abs() >= 1.0) + } +} + +///| +test "apeglm: threshold selection uses FSOS probabilities" { + let result = apeglm_test_result() + let selected = result.select( + maximum_s_value=0.01, + use_threshold_probability=true, + ) + assert_true(selected.length() >= 2) + for gene in selected { + assert_true(gene.threshold_probability <= 0.01) + } +} + +///| +test "apeglm: summary reports fit diagnostics" { + let result = apeglm_test_result() + let summary = result.summary(maximum_s_value=0.1) + assert_eq(summary.gene_count, 8) + assert_eq(summary.converged_count, 8) + assert_eq(summary.coefficient_name, "condition") + assert_eq(summary.selected_count, result.select(maximum_s_value=0.1).length()) + assert_true(summary.prior_scale > 0.0) + assert_true(summary.median_absolute_effect >= 0.0) +} + +///| +test "apeglm: effect accessor converts natural log to log2" { + let result = apeglm_test_result() + let gene = result.genes[0] + apeglm_test_close( + gene.effect(2, log2_scale=true), + gene.effect(2) / @math.ln(2.0), + 1.0e-12, + ) +} + +///| +test "apeglm: standard error accessor converts to log2" { + let result = apeglm_test_result() + let gene = result.genes[0] + apeglm_test_close( + gene.standard_error(2, log2_scale=true), + gene.standard_error(2) / @math.ln(2.0), + 1.0e-12, + ) +} + +///| +test "apeglm: TSV export labels scales and includes genes" { + let result = apeglm_test_result() + let log2_table = result.to_tsv(log2_scale=true) + let natural_table = result.to_tsv(log2_scale=false) + assert_true(log2_table.contains("gene\tbaseMean\tlog2MLE\tlog2MAP")) + assert_true(natural_table.contains("gene\tbaseMean\tlnMLE\tlnMAP")) + assert_true(log2_table.contains("strong_up")) + assert_true(log2_table.contains("low_noisy")) +} + +///| +test "apeglm: repeated fitting is deterministic" { + let first = apeglm_test_result() + let second = apeglm_test_result() + for gene in 0.. abort("single start configuration should succeed") + } + let many = @src.ApeglmConfig::create(coefficient=2, random_starts=12) catch { + _ => abort("many start configuration should succeed") + } + let first = @src.apeglm_fit( + counts, + design, + dispersions, + config=one, + gene_names=genes, + coefficient_names=coefficients, + ) catch { + _ => abort("single start fit should succeed") + } + let second = @src.apeglm_fit( + counts, + design, + dispersions, + config=many, + gene_names=genes, + coefficient_names=coefficients, + ) catch { + _ => abort("many start fit should succeed") + } + assert_true(first.genes[0].map[2] > 0.0) + assert_true(second.genes[0].map[2] > 0.0) + assert_true(first.genes[1].map[2] < 0.0) + assert_true(second.genes[1].map[2] < 0.0) +} + +///| +test "apeglm: DESeq2 wrapper uses counts names and offsets" { + let dds = @src.DESeqDataSet::new( + [ + [48, 52, 45, 54, 198, 220, 205, 230], + [160, 148, 171, 155, 39, 44, 35, 41], + ], + ["up", "down"], + ["s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8"], + [ + [1.0, 0.0, 0.0], + [1.0, 1.0, 0.0], + [1.0, 0.0, 0.0], + [1.0, 1.0, 0.0], + [1.0, 0.0, 1.0], + [1.0, 1.0, 1.0], + [1.0, 0.0, 1.0], + [1.0, 1.0, 1.0], + ], + ) + let config = apeglm_test_config() + let result = @src.apeglm_from_deseq2( + dds, + config~, + coefficient_names=["intercept", "batch", "condition"], + ) catch { + _ => abort("DESeq2 integration should succeed") + } + assert_eq(result.gene_names, ["up", "down"]) + assert_true(result.genes[0].map[2] > 0.0) + assert_true(result.genes[1].map[2] < 0.0) +} + +///| +test "apeglm: SummarizedExperiment output adds posterior assays" { + let (_, design, dispersions, genes, coefficients) = + @src.apeglm_example_data() + let config = apeglm_test_config() + let output = @src.apeglm_summarized_experiment( + apeglm_test_experiment(), + design, + dispersions, + config~, + gene_names=genes, + coefficient_names=coefficients, + ) catch { + _ => abort("SummarizedExperiment integration should succeed") + } + for name in [ + "apeglm_map", + "apeglm_sd", + "apeglm_fsr", + "apeglm_svalue", + "apeglm_fsos", + ] { + match @src.se_assay(output.experiment, name) { + Some(assay) => { + assert_eq(assay.length(), 8) + assert_eq(assay[0].length(), 1) + } + None => abort("missing apeglm output assay: " + name) + } + } +} + +///| +test "apeglm: SummarizedExperiment integration is immutable" { + let (_, design, dispersions, genes, coefficients) = + @src.apeglm_example_data() + let experiment = apeglm_test_experiment() + let config = apeglm_test_config() + let output = @src.apeglm_summarized_experiment( + experiment, + design, + dispersions, + config~, + gene_names=genes, + coefficient_names=coefficients, + ) catch { + _ => abort("SummarizedExperiment integration should succeed") + } + assert_true(@src.se_assay(experiment, "apeglm_map") is None) + assert_true(experiment.metadata.get("apeglm_scale") is None) + assert_eq(output.experiment.metadata["apeglm_scale"], "natural-log") + assert_eq(output.experiment.metadata["apeglm_coefficient"], "condition") + assert_eq(output.experiment.metadata["source"], "apeglm_test") +} + +///| +test "apeglm: SummarizedExperiment rejects missing assay" { + let (_, design, dispersions, _, _) = @src.apeglm_example_data() + let raised = try { + ignore( + @src.apeglm_summarized_experiment( + apeglm_test_experiment(), + design, + dispersions, + assay_name="missing", + ), + ) + false + } catch { + ApeglmError(_) => true + } + assert_true(raised) +} + +///| +test "apeglm: fit rejects empty and single-sample counts" { + let empty = try { + ignore(@src.apeglm_fit([], [], [])) + false + } catch { + ApeglmError(_) => true + } + let single = try { + ignore(@src.apeglm_fit([[1.0]], [[1.0, 0.0]], [0.1])) + false + } catch { + ApeglmError(_) => true + } + assert_true(empty) + assert_true(single) +} + +///| +test "apeglm: fit rejects ragged and fractional counts" { + let ragged = try { + ignore( + @src.apeglm_fit( + [[1.0, 2.0], [3.0]], + [[1.0, 0.0], [1.0, 1.0]], + [0.1, 0.1], + ), + ) + false + } catch { + ApeglmError(_) => true + } + let fractional = try { + ignore( + @src.apeglm_fit( + [[1.5, 2.0]], + [[1.0, 0.0], [1.0, 1.0]], + [0.1], + ), + ) + false + } catch { + ApeglmError(_) => true + } + assert_true(ragged) + assert_true(fractional) +} + +///| +test "apeglm: fit rejects negative and non-finite counts" { + let negative = try { + ignore( + @src.apeglm_fit( + [[-1.0, 2.0]], + [[1.0, 0.0], [1.0, 1.0]], + [0.1], + ), + ) + false + } catch { + ApeglmError(_) => true + } + let overflow = try { + ignore( + @src.apeglm_fit( + [[1.0e301, 2.0]], + [[1.0, 0.0], [1.0, 1.0]], + [0.1], + ), + ) + false + } catch { + ApeglmError(_) => true + } + assert_true(negative) + assert_true(overflow) +} + +///| +test "apeglm: fit rejects malformed design matrices" { + let rows = try { + ignore(@src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0]], [0.1])) + false + } catch { + ApeglmError(_) => true + } + let columns = try { + ignore(@src.apeglm_fit([[1.0, 2.0]], [[1.0], [1.0]], [0.1])) + false + } catch { + ApeglmError(_) => true + } + let ragged = try { + ignore( + @src.apeglm_fit( + [[1.0, 2.0]], + [[1.0, 0.0], [1.0]], + [0.1], + ), + ) + false + } catch { + ApeglmError(_) => true + } + assert_true(rows) + assert_true(columns) + assert_true(ragged) +} + +///| +test "apeglm: fit rejects intercept and out-of-range targets" { + let intercept_config = @src.ApeglmConfig::create(coefficient=0) catch { + _ => abort("intercept index is syntactically valid") + } + let range_config = @src.ApeglmConfig::create(coefficient=2) catch { + _ => abort("range index is syntactically valid") + } + let intercept = try { + ignore( + @src.apeglm_fit( + [[1.0, 2.0]], + [[1.0, 0.0], [1.0, 1.0]], + [0.1], + config=intercept_config, + ), + ) + false + } catch { + ApeglmError(_) => true + } + let range = try { + ignore( + @src.apeglm_fit( + [[1.0, 2.0]], + [[1.0, 0.0], [1.0, 1.0]], + [0.1], + config=range_config, + ), + ) + false + } catch { + ApeglmError(_) => true + } + assert_true(intercept) + assert_true(range) +} + +///| +test "apeglm: fit rejects malformed dispersions" { + let length = try { + ignore( + @src.apeglm_fit( + [[1.0, 2.0], [3.0, 4.0]], + [[1.0, 0.0], [1.0, 1.0]], + [0.1], + ), + ) + false + } catch { + ApeglmError(_) => true + } + let value = try { + ignore( + @src.apeglm_fit( + [[1.0, 2.0]], + [[1.0, 0.0], [1.0, 1.0]], + [0.0], + ), + ) + false + } catch { + ApeglmError(_) => true + } + assert_true(length) + assert_true(value) +} + +///| +test "apeglm: fit validates offsets and observation weights" { + let offsets = try { + ignore( + @src.apeglm_fit( + [[1.0, 2.0]], + [[1.0, 0.0], [1.0, 1.0]], + [0.1], + offsets=[[0.0]], + ), + ) + false + } catch { + ApeglmError(_) => true + } + let weight_shape = try { + ignore( + @src.apeglm_fit( + [[1.0, 2.0]], + [[1.0, 0.0], [1.0, 1.0]], + [0.1], + weights=[[1.0]], + ), + ) + false + } catch { + ApeglmError(_) => true + } + let all_zero = try { + ignore( + @src.apeglm_fit( + [[1.0, 2.0]], + [[1.0, 0.0], [1.0, 1.0]], + [0.1], + weights=[[0.0, 0.0]], + ), + ) + false + } catch { + ApeglmError(_) => true + } + assert_true(offsets) + assert_true(weight_shape) + assert_true(all_zero) +} + +///| +test "apeglm: fit validates identifier lengths and uniqueness" { + let gene_length = try { + ignore( + @src.apeglm_fit( + [[1.0, 2.0]], + [[1.0, 0.0], [1.0, 1.0]], + [0.1], + gene_names=["a", "b"], + ), + ) + false + } catch { + ApeglmError(_) => true + } + let duplicate = try { + ignore( + @src.apeglm_fit( + [[1.0, 2.0], [2.0, 3.0]], + [[1.0, 0.0], [1.0, 1.0]], + [0.1, 0.1], + gene_names=["same", "same"], + ), + ) + false + } catch { + ApeglmError(_) => true + } + let coefficient_length = try { + ignore( + @src.apeglm_fit( + [[1.0, 2.0]], + [[1.0, 0.0], [1.0, 1.0]], + [0.1], + coefficient_names=["intercept"], + ), + ) + false + } catch { + ApeglmError(_) => true + } + let empty = try { + ignore( + @src.apeglm_fit( + [[1.0, 2.0]], + [[1.0, 0.0], [1.0, 1.0]], + [0.1], + gene_names=[""], + ), + ) + false + } catch { + ApeglmError(_) => true + } + assert_true(gene_length) + assert_true(duplicate) + assert_true(coefficient_length) + assert_true(empty) +} From 1730ead85154c789a0a5a3398f49ddbf9f9908fe Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 05:18:10 +0800 Subject: [PATCH 20/41] #28 feat(bigmaf): UCSC BigMaf --- README.md | 26 +- examples/bigmaf_demo/main.mbt | 72 ++ examples/bigmaf_demo/moon.pkg | 5 + src/bigmaf.mbt | 1344 +++++++++++++++++++++++++++++++++ test/moonbit/bigmaf_test.mbt | 1001 ++++++++++++++++++++++++ 5 files changed, 2444 insertions(+), 4 deletions(-) create mode 100644 examples/bigmaf_demo/main.mbt create mode 100644 examples/bigmaf_demo/moon.pkg create mode 100644 src/bigmaf.mbt create mode 100644 test/moonbit/bigmaf_test.mbt diff --git a/README.md b/README.md index ebf2c537..1dac6dff 100644 --- a/README.md +++ b/README.md @@ -161,6 +161,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | Bio.Align.Alignment shared-reference merge | 共享参考PWA/MSA合并、reference-boundary insertion slot同步、局部reference/query坐标、metadata、统计、MSA与aligned FASTA转换 | | ✅ | Bio.Align.Alignment map/mapall | 零起始半开区间alignment path组合、局部clipping、gap与正反链传播、双向坐标查询、PSL、批量map及protein MSA到codon-aware nucleotide MSA投影 | | ✅ | Bio.Align.bigbed | BigBed v4二进制读写、BED3-BED12、AutoSQL扩展字段、多级chromosome B+ tree与R-tree、zlib/DEFLATE解码、区间/名称查询和BED导出 | +| ✅ | Bio.Align.bigmaf | 标准bedMaf bed3+1读写、完整MAF a/s/i/e/q语义、正负链坐标映射、BigBed压缩索引查询、MAF导出和严格损坏数据诊断 | | ✅ | Bioconductor decontX | 单细胞ambient RNA去污染: cluster-native/contaminant多项式混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解、诊断与SingleCellExperiment接入 | | ✅ | Bio.PDB.SASA | 溶剂可及表面积计算: Shrake-Rupley滚动球算法(Fibonacci球面采样)、范德华半径查表、逐原子/残基/链SASA、骨架/侧链拆分 | | ✅ | Bio.SeqIO.NibIO | nib 2-bit二进制序列格式: DNA 2-bit编码(T=0/C=1/A=2/G=3)、4碱基/字节打包、hex I/O、子序列提取、反向互补、GC含量、压缩比 | @@ -219,6 +220,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **共享参考比对合并** | Biopython `Bio.Align.Alignment.from_alignments_with_same_reference` | 混合PWA/MSA输入、首端/内部/末端insertion同步、多query投影、局部坐标与metadata保留、统计和格式转换 | ✅ | | **Alignment坐标组合** | Biopython `Bio.Align.Alignment.map/mapall` | alignment path组合、局部overhang clipping、exon/intron与indel gap、正反链组合、坐标双向查询、PSL及1:1/1:3 MSA投影 | ✅ | | **BigBed二进制区间索引** | Biopython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12与AutoSQL、多级B+ tree/R-tree、stored/fixed/dynamic DEFLATE、区间/名称查询、链感知exon坐标及BED导出 | ✅ | +| **BigMaf多物种比对索引** | Biopython `Bio.Align.bigmaf` | 标准bedMaf AutoSQL、MAF a/s/i/e/q块、score/pass/comment、正负链坐标映射、压缩BigBed索引查询及普通MAF导出 | ✅ | | **zinbwave** | Bioconductor zinbwave | 零膨胀负二项低维模型、cell/gene协变量与offset、确定性latent factors、dispersion shrinkage、observational weights、残差/归一化/插补及SCE集成 | ✅ | | **apeglm** | Bioconductor apeglm | 负二项GLM、自适应经验贝叶斯Cauchy/Student-t先验、确定性多起点MAP、Laplace后验SD/区间、FSR/FSOS/s-value、DESeq2与SummarizedExperiment接入 | ✅ | | **Prosite** | Biopython `Bio.Prosite` | 蛋白质模体数据库搜索、Prosite模式解析、模体匹配算法、模体得分计算 | ✅ | @@ -421,6 +423,7 @@ IvanAXu/BioSeqs/ │ ├── shared_reference_alignment.mbt # Bio.Align共享参考PWA/MSA合并、insertion slot同步与坐标映射 │ ├── alignment_map.mbt # Bio.Align.Alignment map/mapall坐标路径组合与MSA投影 │ ├── bigbed.mbt # Bio.Align.bigbed v4、BED/AutoSQL、多级B+ tree/R-tree与DEFLATE +│ ├── bigmaf.mbt # Bio.Align.bigmaf bedMaf、MAF注释、链向坐标映射与索引查询 │ ├── alignio.mbt # 比对文件 I/O │ ├── clustal_io.mbt # Clustal 格式 │ ├── phylip_io.mbt # PHYLIP 格式 @@ -1110,6 +1113,7 @@ IvanAXu/BioSeqs/ │ ├── shared_reference_alignment_demo/ # 共享参考PWA/MSA合并、insertion同步、坐标映射与FASTA转换示例 │ ├── alignment_map_demo/ # Alignment.map/mapall、反链、PSL与protein-to-codon MSA投影示例 │ ├── bigbed_demo/ # BigBed写入/解析、索引查询、负链exon坐标、BED导出与损坏诊断 +│ ├── bigmaf_demo/ # BigMaf压缩写入、bedMaf schema、区间查询、负链映射与MAF导出 │ ├── gene_pop_demo/ # GenePop群体遗传学示例 (基因型解析、等位基因频率、杂合度统计、序列化往返) │ ├── stage_r_demo/ # stageR两阶段检验示例 (筛选+确认、Simes聚合、BH-FDR、Holm步降、OFDR控制) │ ├── enriched_heatmap_demo/ # EnrichedHeatmap富集热图示例 (信号归一化、四种均值模式、行平滑、链方向处理) @@ -1314,6 +1318,7 @@ IvanAXu/BioSeqs/ │ │ ├── shared_reference_alignment_test.mbt │ │ ├── alignment_map_test.mbt │ │ ├── bigbed_test.mbt +│ │ ├── bigmaf_test.mbt │ │ ├── search_io_test.mbt │ │ ├── searchio_new_test.mbt │ │ ├── seq_complexity_test.mbt @@ -1490,7 +1495,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8905 个测试全部通过 +moon test # ✅ 8984 个测试全部通过 ``` ### 模块对照表 @@ -1538,6 +1543,7 @@ moon test # ✅ 8905 个测试全 | `shared_reference_alignment.mbt` | BioPython `Bio.Align.Alignment.from_alignments_with_same_reference` | 共享参考PWA/MSA合并、insertion slot同步、局部坐标、双向映射、统计、MSA与FASTA转换 | | `alignment_map.mbt` | BioPython `Bio.Align.Alignment.map/mapall` | alignment path组合、local clipping、gap与链向传播、双向坐标查询、PSL、map_many及codon-aware MSA投影 | | `bigbed.mbt` | BioPython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12、AutoSQL、多级chromosome B+ tree/R-tree、zlib/DEFLATE及索引查询 | +| `bigmaf.mbt` | BioPython `Bio.Align.bigmaf` | bedMaf bed3+1读写、MAF a/s/i/e/q、正负链坐标映射、压缩索引查询、摘要和MAF导出 | #### 系统发育树 @@ -1806,6 +1812,7 @@ moon test # ✅ 8905 个测试全 | `shared_reference_alignment.mbt` | `Bio.Align.Alignment` | 同参考PWA/MSA的reference-boundary insertion同步、原query投影、局部坐标、metadata、统计与格式转换 | | `alignment_map.mbt` | `Bio.Align.Alignment.map/mapall` | 两层alignment坐标组合、正反链与gap传播、PSL、批量映射及protein/nucleotide MSA投影 | | `bigbed.mbt` | `Bio.Align.bigbed` | BigBed v4二进制读写、BED/AutoSQL、平衡B+ tree/R-tree、完整DEFLATE块解码、区间/名称查询与BED导出 | +| `bigmaf.mbt` | `Bio.Align.bigmaf` | bedMaf AutoSQL与MAF块往返、a/s/i/e/q注释、链感知坐标映射、BigBed索引查询和普通MAF导出 | | `infercnv.mbt` | `infercnv` | 单细胞拷贝数变异推断（基因组位置排序、参考细胞有界 LFC 计算、金字塔权重平滑、CNV 分数与恶性细胞预测） | | `scenic.mbt` | `SCENIC` | 单细胞调控网络推断与聚类（TF-target 共表达模块、Regulon 构建、AUCell 活性评分、二值化阈值、细胞状态与主控调控因子） | | `cibersort.mbt` | `CIBERSORT` | 免疫细胞去卷积（NNLS 求解、LM22 风格特征矩阵、Pearson 拟合优度、分数归一化） | @@ -2924,6 +2931,14 @@ MAP 求解器实现阻尼 Newton、Cholesky 信息矩阵求解、逐级 ridge `apeglm_from_deseq2` 读取 `DESeqDataSet` 的 counts、design、dispersion 和 size-factor log offset；`apeglm_summarized_experiment` 在不可变副本中增加 `apeglm_map`、`apeglm_sd`、`apeglm_fsr`、`apeglm_svalue` 和 `apeglm_fsos` assays 及模型 metadata。构造器会诊断 ragged、负数、非整数或非有限计数，无效 design/dispersion/offset/weight、全零权重和重复标识符。当前范围实现 dense negative-binomial backend 和 Laplace/Normal posterior approximation，不包含上游 beta-binomial backend、grid/HPD integration、稀疏矩阵专用优化或并行执行。 +### 255. BigMaf 多物种比对索引 (Biopython Bio.Align.bigmaf) + +实现 Biopython 1.86 `Bio.Align.bigmaf` 对应的 UCSC BigMaf 格式。`bigmaf_write` 将多物种 `BigMafBlock` 编码为标准 `bedMaf` `bed3+1` BigBed v4 文件，第四个 AutoSQL `lstring mafBlock` 字段保存分号分隔的完整 MAF block；二进制头、chromosome B+ tree、R-tree 和 DEFLATE 复用经过验证的 BigBed 实现。writer 验证第一条 component 为 `.` 正链参考、source size 与目标长度一致，并按目标顺序和半开区间稳定排序后写入压缩或非压缩数据块。 + +严格 MAF 模型完整保留 `a` 行的 score/pass、`s` sequence component、`i` insertion context、`q` aligned quality、`e` empty component 和注释。component API 提供去 gap 序列、正向序列/区间、alignment column 与 source coordinate 双向转换，以及参考位置到任意物种的映射；负链坐标按 MAF forward-coordinate 规则转换。`BigMafFile::search` 通过底层 R-tree 查询目标区间，同时接受裸 chromosome 或 reference-qualified 名称；另提供全量 block、pairwise identity、摘要和标准 MAF 文本导出。 + +解析器要求 `definedFieldCount=3`、`fieldCount=4` 及标准 `bedMaf` schema，并交叉验证 BED 区间、嵌入 MAF 第一条 component、reference prefix 和 chromosome target。构造器会诊断非法状态字符、负坐标、source 越界、size 与非 gap 长度不符、quality/gap 不同步、重复注释及不一致列宽；二进制层继续诊断损坏 magic、树节点、DEFLATE 和校验和。当前范围不生成 BigMaf zoom levels 或 extra indices，也不实现远程 HTTP range reader。 + ## 性能优化 ### 优化策略 @@ -3025,8 +3040,8 @@ MAP 求解器实现阻尼 Newton、Cholesky 信息矩阵求解、逐级 ridge | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8905 | -| 通过数 | 8905 | +| 总测试数 | 8984 | +| 通过数 | 8984 | | 失败数 | 0 | | 通过率 | 100% | @@ -3131,6 +3146,7 @@ moon test --update | Bio.Align shared-reference merge | `shared_reference_alignment_test.mbt` | 41 | | Bio.Align Alignment.map/mapall | `alignment_map_test.mbt` | 44 | | Bio.Align.bigbed | `bigbed_test.mbt` | 64 | +| Bio.Align.bigmaf | `bigmaf_test.mbt` | 79 | | SparseArray | `sparse_array_test.mbt` | 41 | | mmCIF | `mmcif_test.mbt` | 2 | | BinaryCIF | `binary_cif_test.mbt` | 37 | @@ -3429,7 +3445,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 362 个示例程序，展示各模块的典型用法： +项目提供 363 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3621,6 +3637,7 @@ moon run cmd/bench/main.mbt | shared_reference_alignment_demo | 共享参考PWA/MSA合并、reference insertion同步、坐标映射、统计、MSA与aligned FASTA转换 | `moon run examples/shared_reference_alignment_demo` | | alignment_map_demo | chromosome→transcript→read坐标组合、intron gap、反链、坐标查询、PSL与protein-to-codon MSA投影 | `moon run examples/alignment_map_demo` | | bigbed_demo | BigBed v4压缩写入/解析、AutoSQL、多级索引查询、负链exon坐标、BED导出及损坏文件诊断 | `moon run examples/bigbed_demo` | +| bigmaf_demo | BigMaf压缩bed3+1写入、bedMaf schema、R-tree区间查询、负链物种坐标映射和MAF a/s/i/e/q导出 | `moon run examples/bigmaf_demo` | | gene_pop_demo | GenePop群体遗传学（基因型解析、等位基因频率、杂合度统计、序列化往返） | `moon run examples/gene_pop_demo/main.mbt` | | stage_r_demo | stageR两阶段假设检验（筛选+确认、Simes聚合、BH-FDR、Holm步降、OFDR控制） | `moon run examples/stage_r_demo/main.mbt` | | enriched_heatmap_demo | EnrichedHeatmap富集热图（信号归一化、四种均值模式、行平滑、链方向处理） | `moon run examples/enriched_heatmap_demo/main.mbt` | @@ -3728,6 +3745,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bio.Align共享参考序列比对合并（混合PWA/MSA、reference-boundary insertion同步、局部坐标、双向映射、统计与格式转换） - ✅ 实现 Bio.Align.Alignment map/mapall（alignment path组合、local clipping、gap与正反链传播、坐标查询、PSL及protein-to-codon MSA投影） - ✅ 实现 Bio.Align.bigbed BigBed v4二进制区间格式（BED3-BED12、AutoSQL、多级B+ tree/R-tree、DEFLATE、区间/名称查询与BED导出） +- ✅ 实现 Bio.Align.bigmaf BigMaf多物种比对索引（标准bedMaf、MAF a/s/i/e/q、正负链坐标映射、压缩BigBed查询与MAF导出） - ✅ 实现 Bioconductor decontX ambient RNA去污染（cluster-native/contaminant混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解与SCE集成） - ✅ 实现 Bioconductor zinbwave 零膨胀负二项低维模型（cell/gene协变量、offset、latent factors、dispersion shrinkage、observational weights、残差/插补与SCE集成） - ✅ 实现 Bioconductor apeglm 自适应重尾效应量收缩（NB-GLM MLE、经验贝叶斯Cauchy/Student-t先验、多起点MAP、Laplace后验、FSR/FSOS/s-value与容器接入） diff --git a/examples/bigmaf_demo/main.mbt b/examples/bigmaf_demo/main.mbt new file mode 100644 index 00000000..f4c6f70d --- /dev/null +++ b/examples/bigmaf_demo/main.mbt @@ -0,0 +1,72 @@ +///| +fn main { + println("=== Biopython Bio.Align.bigmaf Demo ===") + let (reference, targets, blocks) = @src.bigmaf_example_data() catch { + BigMafError(message) => abort("failed to create BigMaf data: " + message) + } + let config = @src.BigMafWriteConfig::create( + compress=true, + block_size=3, + items_per_slot=2, + ) catch { + BigMafError(message) => abort("failed to configure BigMaf: " + message) + } + + println("\n1. Write and parse a compressed bed3+1 BigMaf stream") + let bytes = @src.bigmaf_write(reference, targets, blocks, config~) catch { + BigMafError(message) => abort("failed to write BigMaf: " + message) + } + let file = @src.bigmaf_parse(bytes) catch { + BigMafError(message) => abort("failed to parse BigMaf: " + message) + } + let summary = file.summary() catch { + BigMafError(message) => abort("failed to summarize BigMaf: " + message) + } + println( + " bytes=\{bytes.length()}, alignments=\{summary.alignment_count}, targets=\{summary.target_count}, components=\{summary.component_count}, compressed=\{summary.compressed}", + ) + + println("\n2. Inspect the standard bedMaf AutoSQL schema") + println(@src.bigmaf_schema().to_auto_sql()) + + println("3. Query chr7 through the BigBed R-tree") + let hits = file.search("hg38.chr7", start=95, end=110) catch { + BigMafError(message) => abort("failed to query BigMaf: " + message) + } + let block = hits[0] + let reference_component = block.reference_component() + println( + " hits=\{hits.length()}, reference=\{reference_component.source}:\{reference_component.start}-\{reference_component.start + reference_component.size}, columns=\{block.aligned_columns()}", + ) + println( + " score=\{block.score}, pass=\{block.pass_number}, identity=\{block.pairwise_identity()}", + ) + + println("\n4. Map a reference base to a reverse-strand component") + match block.map_reference_to(104, "mm39.chr5") { + Some(position) => + println(" hg38.chr7:104 -> mm39.chr5:" + position.to_string()) + None => println(" reference base maps to a gap") + } + match block.component("mm39.chr5") { + Some(component) => { + let (start, end) = component.forward_interval() + println( + " mouse forward interval=\{start}-\{end}, sequence=\{component.forward_sequence()}", + ) + } + None => abort("example mouse component is missing") + } + + println("\n5. Preserve MAF annotations and export standard MAF") + println( + " empty components=\{block.empty_components.length()}, comments=\{block.comments.length()}", + ) + println( + file.to_maf() catch { + BigMafError(message) => abort("failed to export MAF: " + message) + }, + ) + + println("=== Demo Complete ===") +} diff --git a/examples/bigmaf_demo/moon.pkg b/examples/bigmaf_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/bigmaf_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/bigmaf.mbt b/src/bigmaf.mbt new file mode 100644 index 00000000..73a4b5c7 --- /dev/null +++ b/src/bigmaf.mbt @@ -0,0 +1,1344 @@ +// Bio.Align.bigmaf - indexed UCSC BigMaf multiple alignments. +// +// BigMaf is a bed3+1 BigBed file whose custom lstring field contains a +// semicolon-delimited MAF block. The binary container is implemented by +// bigbed.mbt; this module owns strict MAF block validation and conversion. + +///| +pub suberror BigMafError { + BigMafError(String) +} + +///| +pub struct BigMafInsertion { + left_status : String + left_count : Int + right_status : String + right_count : Int +} derive(Eq, Debug) + +///| +pub struct BigMafComponent { + source : String + start : Int + size : Int + strand : String + source_size : Int + text : String + insertion : BigMafInsertion? + quality : String? +} derive(Eq, Debug) + +///| +pub struct BigMafEmptyComponent { + source : String + start : Int + size : Int + strand : String + source_size : Int + status : String +} derive(Eq, Debug) + +///| +pub struct BigMafBlock { + score : Double? + pass_number : Int? + components : Array[BigMafComponent] + empty_components : Array[BigMafEmptyComponent] + comments : Array[String] +} derive(Eq, Debug) + +///| +pub struct BigMafWriteConfig { + compress : Bool + block_size : Int + items_per_slot : Int +} derive(Eq, Debug) + +///| +pub struct BigMafSummary { + alignment_count : Int + target_count : Int + component_count : Int + empty_component_count : Int + aligned_columns : Int + covered_reference_bases : Int + compressed : Bool +} derive(Eq, Debug) + +///| +pub struct BigMafFile { + reference : String + bed : BigBedFile +} + +///| +fn bigmaf_fail(message : String) -> Unit raise BigMafError { + raise BigMafError(message) +} + +///| +fn bigmaf_is_space(code : Int) -> Bool { + code == ' '.to_int() || + code == '\t'.to_int() || + code == '\n'.to_int() || + code == '\r'.to_int() +} + +///| +fn bigmaf_words(text : String) -> Array[String] { + let words : Array[String] = [] + let mut start = -1 + for index in 0..= 0 { + words.push(text[start:index].to_owned()) + start = -1 + } + } else if start < 0 { + start = index + } + } + if start >= 0 { + words.push(text[start:text.length()].to_owned()) + } + words +} + +///| +fn bigmaf_validate_token( + value : String, + label : String, +) -> Unit raise BigMafError { + if value.length() == 0 { + bigmaf_fail(label + " must not be empty") + } + for index in 0.. Unit raise BigMafError { + for index in 0.. Int raise BigMafError { + if value.length() == 0 { + bigmaf_fail("Missing integer for " + label) + } + let mut first = 0 + if value.unsafe_get(0).to_int() == '-'.to_int() { + if value.length() == 1 { + bigmaf_fail("Invalid integer for " + label + ": " + value) + } + first = 1 + } + for index in first.. '9'.to_int() { + bigmaf_fail("Invalid integer for " + label + ": " + value) + } + } + parse_int(value) +} + +///| +fn bigmaf_parse_double( + value : String, + label : String, +) -> Double raise BigMafError { + match parse_double(value) { + Some(number) => + if number.is_nan() || number.abs() > 1.0e300 { + raise BigMafError("Non-finite number for " + label) + } else { + number + } + None => raise BigMafError("Invalid number for " + label + ": " + value) + } +} + +///| +fn bigmaf_non_gap_count(text : String) -> Int { + let mut count = 0 + for index in 0.. Unit raise BigMafError { + bigmaf_validate_token(text, "MAF aligned sequence") + for index in 0.. 126 { + bigmaf_fail("MAF aligned sequence contains a non-printable character") + } + } +} + +///| +fn bigmaf_insertion_status(status : String) -> Bool { + status == "C" || + status == "I" || + status == "N" || + status == "n" || + status == "M" || + status == "T" +} + +///| +fn bigmaf_empty_status(status : String) -> Bool { + status == "C" || status == "I" || status == "M" || status == "n" +} + +///| +fn bigmaf_source_parts(source : String) -> (String, String) raise BigMafError { + let mut dot = -1 + for index in 0..= source.length() { + bigmaf_fail( + "BigMaf reference component source must be '.'", + ) + } + (source[0:dot].to_owned(), source[dot + 1:source.length()].to_owned()) +} + +///| +pub fn BigMafInsertion::create( + left_status : String, + left_count : Int, + right_status : String, + right_count : Int, +) -> BigMafInsertion raise BigMafError { + if !bigmaf_insertion_status(left_status) || + !bigmaf_insertion_status(right_status) { + bigmaf_fail("MAF insertion status must be C, I, N, n, M, or T") + } + if left_count < 0 || right_count < 0 { + bigmaf_fail("MAF insertion counts must not be negative") + } + BigMafInsertion::{ left_status, left_count, right_status, right_count } +} + +///| +pub fn BigMafComponent::create( + source : String, + start : Int, + size : Int, + strand : String, + source_size : Int, + text : String, + insertion? : BigMafInsertion? = None, + quality? : String? = None, +) -> BigMafComponent raise BigMafError { + bigmaf_validate_token(source, "MAF source") + if start < 0 || size <= 0 || source_size <= 0 || start + size > source_size { + bigmaf_fail("MAF component coordinates exceed the source sequence") + } + if strand != "+" && strand != "-" { + bigmaf_fail("MAF component strand must be '+' or '-'") + } + bigmaf_validate_alignment_text(text) + if bigmaf_non_gap_count(text) != size { + bigmaf_fail("MAF component size does not match its non-gap sequence length") + } + match quality { + Some(value) => { + if value.length() != text.length() { + bigmaf_fail("MAF quality string must match the aligned sequence width") + } + for index in 0..= '0'.to_int() && quality_code <= '9'.to_int() + ) || + quality_code == 'F'.to_int() + if sequence_gap != quality_gap || (!quality_gap && !valid_score) { + bigmaf_fail( + "MAF quality must use 0-9/F and preserve aligned gap columns", + ) + } + } + } + None => () + } + match insertion { + Some(value) => + ignore( + BigMafInsertion::create( + value.left_status, + value.left_count, + value.right_status, + value.right_count, + ), + ) + None => () + } + BigMafComponent::{ + source, + start, + size, + strand, + source_size, + text, + insertion, + quality, + } +} + +///| +pub fn BigMafComponent::with_insertion( + self : BigMafComponent, + insertion : BigMafInsertion, +) -> BigMafComponent raise BigMafError { + BigMafComponent::create( + self.source, + self.start, + self.size, + self.strand, + self.source_size, + self.text, + insertion=Some(insertion), + quality=self.quality, + ) +} + +///| +pub fn BigMafComponent::with_quality( + self : BigMafComponent, + quality : String, +) -> BigMafComponent raise BigMafError { + BigMafComponent::create( + self.source, + self.start, + self.size, + self.strand, + self.source_size, + self.text, + insertion=self.insertion, + quality=Some(quality), + ) +} + +///| +pub fn BigMafEmptyComponent::create( + source : String, + start : Int, + size : Int, + strand : String, + source_size : Int, + status : String, +) -> BigMafEmptyComponent raise BigMafError { + bigmaf_validate_token(source, "MAF empty component source") + if start < 0 || size < 0 || source_size <= 0 || start + size > source_size { + bigmaf_fail("MAF empty component coordinates exceed the source sequence") + } + if strand != "+" && strand != "-" { + bigmaf_fail("MAF empty component strand must be '+' or '-'") + } + if !bigmaf_empty_status(status) { + bigmaf_fail("MAF empty component status must be C, I, M, or n") + } + BigMafEmptyComponent::{ source, start, size, strand, source_size, status } +} + +///| +pub fn BigMafBlock::create( + components : Array[BigMafComponent], + score? : Double? = None, + pass_number? : Int? = None, + empty_components? : Array[BigMafEmptyComponent] = [], + comments? : Array[String] = [], +) -> BigMafBlock raise BigMafError { + if components.length() == 0 { + bigmaf_fail("BigMaf blocks require at least one aligned component") + } + match score { + Some(value) => + if value.is_nan() || value.abs() > 1.0e300 { + bigmaf_fail("BigMaf block score must be finite") + } + None => () + } + match pass_number { + Some(value) => + if value <= 0 { + bigmaf_fail("MAF pass annotation must be positive") + } + None => () + } + let width = components[0].text.length() + for component in components { + ignore( + BigMafComponent::create( + component.source, + component.start, + component.size, + component.strand, + component.source_size, + component.text, + insertion=component.insertion, + quality=component.quality, + ), + ) + if component.text.length() != width { + bigmaf_fail("All MAF components in a block must have equal width") + } + } + for empty in empty_components { + ignore( + BigMafEmptyComponent::create( + empty.source, + empty.start, + empty.size, + empty.strand, + empty.source_size, + empty.status, + ), + ) + } + for comment in comments { + bigmaf_validate_comment(comment) + } + BigMafBlock::{ + score, + pass_number, + components: components.copy(), + empty_components: empty_components.copy(), + comments: comments.copy(), + } +} + +///| +pub fn BigMafWriteConfig::create( + compress? : Bool = true, + block_size? : Int = 256, + items_per_slot? : Int = 512, +) -> BigMafWriteConfig raise BigMafError { + if block_size < 2 || block_size > 65535 { + bigmaf_fail("BigMaf blockSize must be between 2 and 65535") + } + if items_per_slot <= 0 || items_per_slot > 65535 { + bigmaf_fail("BigMaf itemsPerSlot must be between 1 and 65535") + } + BigMafWriteConfig::{ compress, block_size, items_per_slot } +} + +///| +pub fn BigMafWriteConfig::default() -> BigMafWriteConfig { + BigMafWriteConfig::{ compress: true, block_size: 256, items_per_slot: 512 } +} + +///| +pub fn BigMafComponent::sequence(self : BigMafComponent) -> String { + let output = StringBuilder::new() + for index in 0.. String { + let sequence = self.sequence() + if self.strand == "+" { + sequence + } else { + reverse_complement(sequence) + } +} + +///| +pub fn BigMafComponent::forward_interval(self : BigMafComponent) -> (Int, Int) { + if self.strand == "+" { + (self.start, self.start + self.size) + } else { + (self.source_size - self.start - self.size, self.source_size - self.start) + } +} + +///| +pub fn BigMafEmptyComponent::forward_interval( + self : BigMafEmptyComponent, +) -> (Int, Int) { + if self.strand == "+" { + (self.start, self.start + self.size) + } else { + (self.source_size - self.start - self.size, self.source_size - self.start) + } +} + +///| +pub fn BigMafComponent::column_to_source( + self : BigMafComponent, + column : Int, +) -> Int? raise BigMafError { + if column < 0 || column >= self.text.length() { + bigmaf_fail("MAF alignment column is out of range") + } + if self.text.unsafe_get(column).to_int() == '-'.to_int() { + return None + } + let mut offset = 0 + for index in 0.. Int? { + let (forward_start, forward_end) = self.forward_interval() + if position < forward_start || position >= forward_end { + return None + } + let wanted = if self.strand == "+" { + position - self.start + } else { + self.source_size - self.start - position - 1 + } + let mut offset = 0 + for column in 0.. Int { + self.components[0].text.length() +} + +///| +pub fn BigMafBlock::reference_component(self : BigMafBlock) -> BigMafComponent { + self.components[0] +} + +///| +pub fn BigMafBlock::component( + self : BigMafBlock, + source : String, +) -> BigMafComponent? { + for component in self.components { + if component.source == source { + return Some(component) + } + } + None +} + +///| +pub fn BigMafBlock::sources(self : BigMafBlock) -> Array[String] { + let sources : Array[String] = [] + for component in self.components { + sources.push(component.source) + } + sources +} + +///| +pub fn BigMafBlock::map_reference_to( + self : BigMafBlock, + reference_position : Int, + source : String, +) -> Int? { + match self.components[0].source_to_column(reference_position) { + Some(column) => + match self.component(source) { + Some(component) => + component.column_to_source(column) catch { + _ => None + } + None => None + } + None => None + } +} + +///| +pub fn BigMafBlock::pairwise_identity(self : BigMafBlock) -> Double { + let mut matches = 0 + let mut comparisons = 0 + for column in 0.. Unit { + output.write_string( + "s " + + component.source + + " " + + component.start.to_string() + + " " + + component.size.to_string() + + " " + + component.strand + + " " + + component.source_size.to_string() + + " " + + component.text + + delimiter, + ) + match component.insertion { + Some(insertion) => + output.write_string( + "i " + + component.source + + " " + + insertion.left_status + + " " + + insertion.left_count.to_string() + + " " + + insertion.right_status + + " " + + insertion.right_count.to_string() + + delimiter, + ) + None => () + } + match component.quality { + Some(quality) => + output.write_string("q " + component.source + " " + quality + delimiter) + None => () + } +} + +///| +fn bigmaf_format_block(block : BigMafBlock, delimiter : String) -> String { + let output = StringBuilder::new() + for comment in block.comments { + output.write_string("# " + comment + delimiter) + } + output.write_string("a") + match block.score { + Some(score) => output.write_string(" score=" + score.to_string()) + None => () + } + match block.pass_number { + Some(pass_number) => output.write_string(" pass=" + pass_number.to_string()) + None => () + } + output.write_string(delimiter) + for component in block.components { + bigmaf_write_component(output, component, delimiter) + } + for empty in block.empty_components { + output.write_string( + "e " + + empty.source + + " " + + empty.start.to_string() + + " " + + empty.size.to_string() + + " " + + empty.strand + + " " + + empty.source_size.to_string() + + " " + + empty.status + + delimiter, + ) + } + output.to_string() +} + +///| +pub fn BigMafBlock::to_embedded_maf(self : BigMafBlock) -> String { + bigmaf_format_block(self, ";") +} + +///| +pub fn BigMafBlock::to_maf(self : BigMafBlock) -> String { + bigmaf_format_block(self, "\n") + "\n" +} + +///| +fn bigmaf_parse_score_line( + words : Array[String], +) -> (Double?, Int?) raise BigMafError { + let mut score : Double? = None + let mut pass_number : Int? = None + for index in 1.. BigMafBlock raise BigMafError { + if text.length() == 0 { + bigmaf_fail("BigMaf block text must not be empty") + } + let lines = text.split(";").to_array() + let components : Array[BigMafComponent] = [] + let empty_components : Array[BigMafEmptyComponent] = [] + let comments : Array[String] = [] + let mut score : Double? = None + let mut pass_number : Int? = None + let mut saw_alignment = false + let mut last_component = -1 + for raw in lines { + let line = trim(raw.to_owned()) + if line.length() == 0 { + continue + } + if line.unsafe_get(0).to_int() == '#'.to_int() { + comments.push(trim(line[1:line.length()].to_owned())) + continue + } + let words = bigmaf_words(line) + if words.length() == 0 { + continue + } + if words[0] == "a" { + if saw_alignment { + bigmaf_fail("BigMaf payload contains more than one MAF block") + } + let (found_score, found_pass) = bigmaf_parse_score_line(words) + score = found_score + pass_number = found_pass + saw_alignment = true + last_component = -1 + } else if words[0] == "s" { + if !saw_alignment { + bigmaf_fail("MAF sequence line appears before the alignment line") + } + if words.length() != 7 { + bigmaf_fail("MAF sequence lines must contain seven fields") + } + let component = BigMafComponent::create( + words[1], + bigmaf_parse_int(words[2], "MAF component start"), + bigmaf_parse_int(words[3], "MAF component size"), + words[4], + bigmaf_parse_int(words[5], "MAF source size"), + words[6], + ) + components.push(component) + last_component = components.length() - 1 + } else if words[0] == "i" { + if last_component < 0 || words.length() != 6 { + bigmaf_fail( + "MAF insertion lines must follow an s line and have six fields", + ) + } + if words[1] != components[last_component].source { + bigmaf_fail("MAF insertion source does not match the preceding s line") + } + if components[last_component].insertion is Some(_) { + bigmaf_fail("Duplicate MAF insertion line for one component") + } + let insertion = BigMafInsertion::create( + words[2], + bigmaf_parse_int(words[3], "MAF left insertion count"), + words[4], + bigmaf_parse_int(words[5], "MAF right insertion count"), + ) + components[last_component] = components[last_component].with_insertion( + insertion, + ) + } else if words[0] == "q" { + if last_component < 0 || words.length() != 3 { + bigmaf_fail( + "MAF quality lines must follow an s line and have three fields", + ) + } + if words[1] != components[last_component].source { + bigmaf_fail("MAF quality source does not match the preceding s line") + } + if components[last_component].quality is Some(_) { + bigmaf_fail("Duplicate MAF quality line for one component") + } + components[last_component] = components[last_component].with_quality( + words[2], + ) + } else if words[0] == "e" { + if !saw_alignment || words.length() != 7 { + bigmaf_fail("MAF empty component lines must contain seven fields") + } + empty_components.push( + BigMafEmptyComponent::create( + words[1], + bigmaf_parse_int(words[2], "MAF empty component start"), + bigmaf_parse_int(words[3], "MAF empty component size"), + words[4], + bigmaf_parse_int(words[5], "MAF empty source size"), + words[6], + ), + ) + last_component = -1 + } else { + bigmaf_fail("Unexpected MAF line type '" + words[0] + "'") + } + } + if !saw_alignment { + bigmaf_fail("BigMaf payload is missing its MAF alignment line") + } + BigMafBlock::create( + components, + score~, + pass_number~, + empty_components~, + comments~, + ) +} + +///| +pub fn bigmaf_schema() -> BigBedSchema { + BigBedSchema::{ + name: "bedMaf", + comment: "Bed3 with MAF block", + fields: [ + BigBedField::{ + as_type: "string", + name: "chrom", + comment: "Reference sequence chromosome or scaffold", + }, + BigBedField::{ + as_type: "uint", + name: "chromStart", + comment: "Start position in chromosome", + }, + BigBedField::{ + as_type: "uint", + name: "chromEnd", + comment: "End position in chromosome", + }, + BigBedField::{ + as_type: "lstring", + name: "mafBlock", + comment: "MAF block", + }, + ], + } +} + +///| +fn bigmaf_target_index( + targets : Array[BigBedTarget], + chromosome : String, +) -> Int { + for index in 0.. Array[Int] raise BigBedError, +) -> Array[Int] raise BigMafError { + operation() catch { + BigBedError(message) => raise BigMafError("BigBed: " + message) + } +} + +///| +pub fn bigmaf_write( + reference : String, + targets : Array[BigBedTarget], + blocks : Array[BigMafBlock], + config? : BigMafWriteConfig = BigMafWriteConfig::default(), +) -> Array[Int] raise BigMafError { + bigmaf_validate_token(reference, "BigMaf reference") + for index in 0.. bigmaf_fail("BigBed: " + message) + } + for previous in 0.. { + bigmaf_fail("BigBed: " + message) + BigBedRecord::{ + chrom: "", + chrom_start: 0, + chrom_end: 1, + name: ".", + score: 0, + strand: ".", + thick_start: 0, + thick_end: 1, + item_rgb: "0", + declared_block_count: 0, + block_sizes: [], + block_starts: [], + extra_fields: [], + } + } + } + records.push(record) + target_order.push(target_index) + } + let order : Array[Int] = [] + for index in 0.. Int { + if target_order[left] < target_order[right] { + -1 + } else if target_order[left] > target_order[right] { + 1 + } else if records[left].chrom_start < records[right].chrom_start { + -1 + } else if records[left].chrom_start > records[right].chrom_start { + 1 + } else if records[left].chrom_end < records[right].chrom_end { + -1 + } else if records[left].chrom_end > records[right].chrom_end { + 1 + } else { + 0 + } + }) + let sorted : Array[BigBedRecord] = [] + for index in order { + sorted.push(records[index]) + } + let field = BigBedField::{ + as_type: "lstring", + name: "mafBlock", + comment: "MAF block", + } + let bed_config = BigBedWriteConfig::create( + bed_columns=3, + items_per_slot=config.items_per_slot, + block_size=config.block_size, + compress=config.compress, + schema_name="bedMaf", + schema_comment="Bed3 with MAF block", + custom_fields=[field], + ) catch { + BigBedError(message) => { + bigmaf_fail("BigBed: " + message) + BigBedWriteConfig::default() + } + } + bigmaf_wrap_bigbed(fn() -> Array[Int] raise BigBedError { + bigbed_write(targets, sorted, config=bed_config) + }) +} + +///| +fn bigmaf_validate_schema(bed : BigBedFile) -> Unit raise BigMafError { + if bed.header.defined_field_count != 3 || + bed.header.field_count != 4 || + bed.schema.name != "bedMaf" || + bed.schema.fields.length() != 4 || + bed.schema.fields[3].name != "mafBlock" || + bed.schema.fields[3].as_type != "lstring" { + bigmaf_fail( + "BigMaf requires the standard bedMaf bed3+1 AutoSQL declaration", + ) + } +} + +///| +fn bigmaf_decode_record( + bed : BigBedFile, + record : BigBedRecord, + expected_reference : String, +) -> (String, BigMafBlock) raise BigMafError { + if record.extra_fields.length() != 1 { + bigmaf_fail("BigMaf binary records require one mafBlock field") + } + let block = bigmaf_parse_block(record.extra_fields[0]) + let component = block.components[0] + let (reference, chromosome) = bigmaf_source_parts(component.source) + if expected_reference.length() > 0 && reference != expected_reference { + bigmaf_fail("BigMaf records use inconsistent reference prefixes") + } + if component.strand != "+" { + bigmaf_fail("BigMaf reference components must use the forward strand") + } + if chromosome != record.chrom || + component.start != record.chrom_start || + component.start + component.size != record.chrom_end { + bigmaf_fail("BigMaf BED coordinates disagree with the embedded MAF block") + } + match bed.target(chromosome) { + Some(target) => + if component.source_size != target.length { + bigmaf_fail( + "BigMaf reference component source size disagrees with its target", + ) + } + None => bigmaf_fail("BigMaf record refers to an unknown target") + } + (reference, block) +} + +///| +pub fn bigmaf_parse(data : Array[Int]) -> BigMafFile raise BigMafError { + let bed = bigbed_parse(data) catch { + BigBedError(message) => { + bigmaf_fail("BigBed: " + message) + BigBedFile::{ + header: BigBedHeader::{ + little_endian: true, + version: 4, + zoom_levels: 0, + chromosome_tree_offset: 0, + full_data_offset: 0, + full_index_offset: 0, + field_count: 0, + defined_field_count: 0, + auto_sql_offset: 0, + total_summary_offset: 0, + uncompress_buffer_size: 0, + extra_indices_offset: 0, + }, + schema: bigmaf_schema(), + targets: [], + source: [], + blocks: [], + record_count: 0, + } + } + } + bigmaf_validate_schema(bed) + let records = bed.records() catch { + BigBedError(message) => { + bigmaf_fail("BigBed: " + message) + [] + } + } + let mut reference = "" + for record in records { + let (found, _) = bigmaf_decode_record(bed, record, reference) + if reference.length() == 0 { + reference = found + } + } + BigMafFile::{ reference, bed } +} + +///| +pub fn BigMafFile::blocks( + self : BigMafFile, +) -> Array[BigMafBlock] raise BigMafError { + let records = self.bed.records() catch { + BigBedError(message) => { + bigmaf_fail("BigBed: " + message) + [] + } + } + let blocks : Array[BigMafBlock] = [] + for record in records { + let (_, block) = bigmaf_decode_record(self.bed, record, self.reference) + blocks.push(block) + } + blocks +} + +///| +fn bigmaf_query_chromosome( + file : BigMafFile, + chromosome : String, +) -> String raise BigMafError { + if file.reference.length() == 0 { + return chromosome + } + let prefix = file.reference + "." + if chromosome.has_prefix(prefix) { + let suffix = chromosome[prefix.length():chromosome.length()].to_owned() + if suffix.length() == 0 { + bigmaf_fail("BigMaf query chromosome must not be empty") + } + suffix + } else { + chromosome + } +} + +///| +pub fn BigMafFile::search( + self : BigMafFile, + chromosome : String, + start? : Int = 0, + end? : Int = -1, +) -> Array[BigMafBlock] raise BigMafError { + let resolved = bigmaf_query_chromosome(self, chromosome) + let records = self.bed.search(resolved, start~, end~) catch { + BigBedError(message) => { + bigmaf_fail("BigBed: " + message) + [] + } + } + let blocks : Array[BigMafBlock] = [] + for record in records { + let (_, block) = bigmaf_decode_record(self.bed, record, self.reference) + blocks.push(block) + } + blocks +} + +///| +pub fn BigMafFile::target( + self : BigMafFile, + chromosome : String, +) -> BigBedTarget? { + let resolved = bigmaf_query_chromosome(self, chromosome) catch { + _ => return None + } + self.bed.target(resolved) +} + +///| +pub fn BigMafFile::is_compressed(self : BigMafFile) -> Bool { + self.bed.is_compressed() +} + +///| +pub fn BigMafFile::to_maf(self : BigMafFile) -> String raise BigMafError { + let output = StringBuilder::new() + output.write_string("##maf version=1\n\n") + for block in self.blocks() { + output.write_string(block.to_maf()) + } + output.to_string() +} + +///| +pub fn BigMafFile::summary( + self : BigMafFile, +) -> BigMafSummary raise BigMafError { + let blocks = self.blocks() + let mut component_count = 0 + let mut empty_component_count = 0 + let mut aligned_columns = 0 + let mut covered_reference_bases = 0 + for block in blocks { + component_count = component_count + block.components.length() + empty_component_count = empty_component_count + + block.empty_components.length() + aligned_columns = aligned_columns + block.aligned_columns() + covered_reference_bases = covered_reference_bases + block.components[0].size + } + BigMafSummary::{ + alignment_count: blocks.length(), + target_count: self.bed.targets.length(), + component_count, + empty_component_count, + aligned_columns, + covered_reference_bases, + compressed: self.is_compressed(), + } +} + +///| +pub fn bigmaf_example_data() -> ( + String, + Array[BigBedTarget], + Array[BigMafBlock], +) raise BigMafError { + let reference = "hg38" + let targets = [ + BigBedTarget::create("chr7", 1000) catch { + BigBedError(message) => { + bigmaf_fail("BigBed: " + message) + BigBedTarget::{ name: "chr7", length: 1000 } + } + }, + BigBedTarget::create("chr12", 800) catch { + BigBedError(message) => { + bigmaf_fail("BigBed: " + message) + BigBedTarget::{ name: "chr12", length: 800 } + } + }, + ] + let reference_one = BigMafComponent::create( + "hg38.chr7", + 100, + 8, + "+", + 1000, + "ACGT-ACGT", + quality=Some("9999-FFFF"), + ) + let chimp_one = BigMafComponent::create( + "panTro6.chr6", 200, 8, "+", 900, "ACGT-ACGT", + ) + let mouse_one = BigMafComponent::create( + "mm39.chr5", + 50, + 8, + "-", + 700, + "AC-TTACGT", + insertion=Some(BigMafInsertion::create("C", 0, "I", 12)), + ) + let empty = BigMafEmptyComponent::create( + "canFam6.chr6", 300, 20, "+", 850, "M", + ) + let first = BigMafBlock::create( + [reference_one, chimp_one, mouse_one], + score=Some(23262.0), + pass_number=Some(1), + empty_components=[empty], + comments=["conserved reference block"], + ) + let second = BigMafBlock::create( + [ + BigMafComponent::create("hg38.chr7", 300, 6, "+", 1000, "TTAAGA"), + BigMafComponent::create("panTro6.chr6", 410, 6, "+", 900, "TTAAGA"), + BigMafComponent::create("mm39.chr5", 120, 5, "+", 700, "TT-AGA"), + ], + score=Some(5062.0), + ) + let third = BigMafBlock::create( + [ + BigMafComponent::create("hg38.chr12", 40, 7, "+", 800, "GCA-GCTG"), + BigMafComponent::create("panTro6.chr10", 70, 7, "+", 600, "GCA-GCTG"), + ], + score=Some(6636.0), + ) + (reference, targets, [first, second, third]) +} diff --git a/test/moonbit/bigmaf_test.mbt b/test/moonbit/bigmaf_test.mbt new file mode 100644 index 00000000..f8015566 --- /dev/null +++ b/test/moonbit/bigmaf_test.mbt @@ -0,0 +1,1001 @@ +///| +fn bigmaf_test_data() -> ( + String, + Array[@src.BigBedTarget], + Array[@src.BigMafBlock], +) { + @src.bigmaf_example_data() catch { + _ => abort("BigMaf example data should be valid") + } +} + +///| +fn bigmaf_test_file( + compress? : Bool = true, + items_per_slot? : Int = 2, +) -> @src.BigMafFile { + let (reference, targets, blocks) = bigmaf_test_data() + let config = @src.BigMafWriteConfig::create( + compress~, + block_size=3, + items_per_slot~, + ) catch { + _ => abort("BigMaf test configuration should be valid") + } + let bytes = @src.bigmaf_write(reference, targets, blocks, config~) catch { + _ => abort("BigMaf example should serialize") + } + @src.bigmaf_parse(bytes) catch { + _ => abort("BigMaf example should parse") + } +} + +///| +fn bigmaf_test_component( + source? : String = "hg38.chr1", + start? : Int = 10, + size? : Int = 4, + strand? : String = "+", + source_size? : Int = 100, + text? : String = "AC-GT", +) -> @src.BigMafComponent { + @src.BigMafComponent::create(source, start, size, strand, source_size, text) catch { + _ => abort("test component should be valid") + } +} + +///| +fn bigmaf_test_block( + component? : @src.BigMafComponent = bigmaf_test_component(), +) -> @src.BigMafBlock { + @src.BigMafBlock::create([component]) catch { + _ => abort("test block should be valid") + } +} + +///| +fn bigmaf_test_close( + actual : Double, + expected : Double, + tolerance? : Double = 1.0e-12, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "BigMaf value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn bigmaf_test_custom_bytes( + payloads : Array[String], + intervals : Array[(Int, Int)], +) -> Array[Int] { + let target = @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("custom target should be valid") + } + let field = @src.BigBedField::create("lstring", "mafBlock") catch { + _ => abort("custom field should be valid") + } + let config = @src.BigBedWriteConfig::create( + bed_columns=3, + schema_name="bedMaf", + schema_comment="Bed3 with MAF block", + custom_fields=[field], + ) catch { + _ => abort("custom config should be valid") + } + let records : Array[@src.BigBedRecord] = [] + for index in 0.. abort("custom record should be valid") + }, + ) + } + @src.bigbed_write([target], records, config~) catch { + _ => abort("custom BigBed should serialize") + } +} + +///| +test "bigmaf: default configuration matches Biopython defaults" { + let config = @src.BigMafWriteConfig::default() + assert_true(config.compress) + assert_eq(config.block_size, 256) + assert_eq(config.items_per_slot, 512) +} + +///| +test "bigmaf: custom configuration is preserved" { + let config = @src.BigMafWriteConfig::create( + compress=false, + block_size=8, + items_per_slot=4, + ) catch { + _ => abort("configuration should be valid") + } + assert_true(!config.compress) + assert_eq(config.block_size, 8) + assert_eq(config.items_per_slot, 4) +} + +///| +test "bigmaf: configuration rejects blockSize below two" { + let rejected = try { + ignore(@src.BigMafWriteConfig::create(block_size=1)) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: configuration rejects zero itemsPerSlot" { + let rejected = try { + ignore(@src.BigMafWriteConfig::create(items_per_slot=0)) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: standard AutoSQL declaration is bed3 plus mafBlock" { + let schema = @src.bigmaf_schema() + assert_eq(schema.name, "bedMaf") + assert_eq(schema.comment, "Bed3 with MAF block") + assert_eq(schema.fields.length(), 4) + assert_eq(schema.fields[3].as_type, "lstring") + assert_eq(schema.fields[3].name, "mafBlock") +} + +///| +test "bigmaf: AutoSQL text contains the UCSC table declaration" { + let text = @src.bigmaf_schema().to_auto_sql() + assert_true(text.contains("table bedMaf")) + assert_true(text.contains("lstring mafBlock")) +} + +///| +test "bigmaf: insertion constructor preserves context" { + let insertion = @src.BigMafInsertion::create("C", 0, "I", 12) catch { + _ => abort("insertion context should be valid") + } + assert_eq(insertion.left_status, "C") + assert_eq(insertion.left_count, 0) + assert_eq(insertion.right_status, "I") + assert_eq(insertion.right_count, 12) +} + +///| +test "bigmaf: insertion rejects unknown status" { + let rejected = try { + ignore(@src.BigMafInsertion::create("X", 0, "C", 0)) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: insertion rejects negative count" { + let rejected = try { + ignore(@src.BigMafInsertion::create("C", -1, "C", 0)) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: component constructor preserves MAF fields" { + let component = bigmaf_test_component() + assert_eq(component.source, "hg38.chr1") + assert_eq(component.start, 10) + assert_eq(component.size, 4) + assert_eq(component.strand, "+") + assert_eq(component.source_size, 100) + assert_eq(component.text, "AC-GT") +} + +///| +test "bigmaf: component sequence removes alignment gaps" { + assert_eq(bigmaf_test_component().sequence(), "ACGT") +} + +///| +test "bigmaf: plus component reports forward interval" { + assert_eq(bigmaf_test_component().forward_interval(), (10, 14)) +} + +///| +test "bigmaf: minus component converts MAF reverse coordinates" { + let component = bigmaf_test_component( + source="mm39.chr1", + start=10, + strand="-", + ) + assert_eq(component.forward_interval(), (86, 90)) +} + +///| +test "bigmaf: minus component returns forward-oriented sequence" { + let component = bigmaf_test_component( + source="mm39.chr1", + start=10, + size=3, + strand="-", + text="ACG", + ) + assert_eq(component.forward_sequence(), "CGT") +} + +///| +test "bigmaf: plus column maps to source coordinate" { + let component = bigmaf_test_component() + assert_eq(component.column_to_source(0), Some(10)) + assert_eq(component.column_to_source(4), Some(13)) +} + +///| +test "bigmaf: alignment gap maps to no source coordinate" { + assert_eq(bigmaf_test_component().column_to_source(2), None) +} + +///| +test "bigmaf: plus source coordinate maps to alignment column" { + let component = bigmaf_test_component() + assert_eq(component.source_to_column(10), Some(0)) + assert_eq(component.source_to_column(12), Some(3)) + assert_eq(component.source_to_column(14), None) +} + +///| +test "bigmaf: minus columns descend in forward coordinates" { + let component = bigmaf_test_component( + source="mm39.chr1", + start=10, + strand="-", + ) + assert_eq(component.column_to_source(0), Some(89)) + assert_eq(component.column_to_source(4), Some(86)) +} + +///| +test "bigmaf: minus source coordinate maps back to column" { + let component = bigmaf_test_component( + source="mm39.chr1", + start=10, + strand="-", + ) + assert_eq(component.source_to_column(89), Some(0)) + assert_eq(component.source_to_column(87), Some(3)) +} + +///| +test "bigmaf: component accepts aligned quality string" { + let component = @src.BigMafComponent::create( + "hg38.chr1", + 10, + 4, + "+", + 100, + "AC-GT", + quality=Some("9F-73"), + ) catch { + _ => abort("quality should be valid") + } + assert_eq(component.quality, Some("9F-73")) +} + +///| +test "bigmaf: component rejects quality width mismatch" { + let rejected = try { + ignore( + @src.BigMafComponent::create( + "hg38.chr1", + 10, + 4, + "+", + 100, + "AC-GT", + quality=Some("9999"), + ), + ) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: component rejects quality gap mismatch" { + let rejected = try { + ignore( + @src.BigMafComponent::create( + "hg38.chr1", + 10, + 4, + "+", + 100, + "AC-GT", + quality=Some("99F99"), + ), + ) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: component rejects non-gap size mismatch" { + let rejected = try { + ignore(@src.BigMafComponent::create("hg38.chr1", 10, 5, "+", 100, "AC-GT")) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: component rejects coordinate overflow" { + let rejected = try { + ignore(@src.BigMafComponent::create("hg38.chr1", 98, 4, "+", 100, "ACGT")) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: component rejects invalid strand" { + let rejected = try { + ignore(@src.BigMafComponent::create("hg38.chr1", 10, 4, ".", 100, "ACGT")) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: empty component reports plus interval" { + let empty = @src.BigMafEmptyComponent::create( + "dog.chr1", 20, 5, "+", 100, "M", + ) catch { + _ => abort("empty component should be valid") + } + assert_eq(empty.forward_interval(), (20, 25)) +} + +///| +test "bigmaf: empty component reports minus interval" { + let empty = @src.BigMafEmptyComponent::create( + "dog.chr1", 20, 5, "-", 100, "n", + ) catch { + _ => abort("empty component should be valid") + } + assert_eq(empty.forward_interval(), (75, 80)) +} + +///| +test "bigmaf: empty component rejects invalid status" { + let rejected = try { + ignore(@src.BigMafEmptyComponent::create("dog.chr1", 20, 5, "+", 100, "T")) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: block preserves score pass comments and empty components" { + let empty = @src.BigMafEmptyComponent::create( + "dog.chr1", 20, 5, "+", 100, "M", + ) catch { + _ => abort("empty component should be valid") + } + let block = @src.BigMafBlock::create( + [bigmaf_test_component()], + score=Some(42.5), + pass_number=Some(2), + empty_components=[empty], + comments=["test"], + ) catch { + _ => abort("block should be valid") + } + assert_eq(block.score, Some(42.5)) + assert_eq(block.pass_number, Some(2)) + assert_eq(block.empty_components.length(), 1) + assert_eq(block.comments, ["test"]) +} + +///| +test "bigmaf: block rejects unequal alignment widths" { + let rejected = try { + ignore( + @src.BigMafBlock::create([ + bigmaf_test_component(), + bigmaf_test_component(source="mouse.chr1", size=3, text="ACG"), + ]), + ) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: block rejects non-positive pass annotation" { + let rejected = try { + ignore( + @src.BigMafBlock::create([bigmaf_test_component()], pass_number=Some(0)), + ) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: block rejects empty component array" { + let rejected = try { + ignore(@src.BigMafBlock::create([])) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: embedded formatter uses semicolon-delimited MAF" { + let (_, _, blocks) = bigmaf_test_data() + let text = blocks[0].to_embedded_maf() + assert_true(text.contains("a score=23262")) + assert_true(text.contains(";s hg38.chr7 100 8 + 1000 ACGT-ACGT;")) + assert_true(text.contains(";i mm39.chr5 C 0 I 12;")) + assert_true(text.contains(";q hg38.chr7 9999-FFFF;")) + assert_true(text.contains(";e canFam6.chr6 300 20 + 850 M;")) +} + +///| +test "bigmaf: embedded block round trip preserves all annotations" { + let (_, _, blocks) = bigmaf_test_data() + let parsed = @src.bigmaf_parse_block(blocks[0].to_embedded_maf()) catch { + _ => abort("embedded block should parse") + } + assert_eq(parsed, blocks[0]) +} + +///| +test "bigmaf: parser accepts comments before alignment line" { + let block = @src.bigmaf_parse_block( + "# first comment;#second;a score=1;s hg38.chr1 0 4 + 100 ACGT;", + ) catch { + _ => abort("commented block should parse") + } + assert_eq(block.comments, ["first comment", "second"]) +} + +///| +test "bigmaf: parser reads score and pass" { + let block = @src.bigmaf_parse_block( + "a score=1.25 pass=3;s hg38.chr1 0 4 + 100 ACGT;", + ) catch { + _ => abort("annotated block should parse") + } + assert_eq(block.score, Some(1.25)) + assert_eq(block.pass_number, Some(3)) +} + +///| +test "bigmaf: parser reads insertion quality and empty lines" { + let block = @src.bigmaf_parse_block( + "a;s hg38.chr1 0 4 + 100 AC-GT;i hg38.chr1 C 0 I 2;q hg38.chr1 99-FF;e dog.chr1 10 5 + 100 M;", + ) catch { + _ => abort("full MAF block should parse") + } + assert_true(block.components[0].insertion is Some(_)) + assert_eq(block.components[0].quality, Some("99-FF")) + assert_eq(block.empty_components.length(), 1) +} + +///| +test "bigmaf: parser rejects unknown alignment annotation" { + let rejected = try { + ignore( + @src.bigmaf_parse_block("a score=1 custom=x;s hg38.chr1 0 4 + 100 ACGT;"), + ) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: parser rejects malformed s line" { + let rejected = try { + ignore(@src.bigmaf_parse_block("a;s hg38.chr1 0 4 + 100;")) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: parser rejects insertion before component" { + let rejected = try { + ignore( + @src.bigmaf_parse_block( + "a;i hg38.chr1 C 0 C 0;s hg38.chr1 0 4 + 100 ACGT;", + ), + ) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: parser rejects mismatched insertion source" { + let rejected = try { + ignore( + @src.bigmaf_parse_block( + "a;s hg38.chr1 0 4 + 100 ACGT;i mouse.chr1 C 0 C 0;", + ), + ) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: parser rejects duplicate quality lines" { + let rejected = try { + ignore( + @src.bigmaf_parse_block( + "a;s hg38.chr1 0 4 + 100 ACGT;q hg38.chr1 9999;q hg38.chr1 9999;", + ), + ) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: parser rejects unknown line type" { + let rejected = try { + ignore(@src.bigmaf_parse_block("a;s hg38.chr1 0 4 + 100 ACGT;x unknown;")) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: parser rejects multiple alignment lines" { + let rejected = try { + ignore( + @src.bigmaf_parse_block( + "a;s hg38.chr1 0 4 + 100 ACGT;a;s hg38.chr1 4 4 + 100 ACGT;", + ), + ) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: parser rejects payload without alignment line" { + let rejected = try { + ignore(@src.bigmaf_parse_block("# comment;s hg38.chr1 0 4 + 100 ACGT;")) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: reference mapping follows shared alignment column" { + let (_, _, blocks) = bigmaf_test_data() + assert_eq(blocks[0].map_reference_to(100, "panTro6.chr6"), Some(200)) + assert_eq(blocks[0].map_reference_to(104, "panTro6.chr6"), Some(204)) +} + +///| +test "bigmaf: reference mapping returns none for target gap" { + let (_, _, blocks) = bigmaf_test_data() + assert_eq(blocks[1].map_reference_to(302, "mm39.chr5"), None) +} + +///| +test "bigmaf: reference mapping handles reverse target component" { + let (_, _, blocks) = bigmaf_test_data() + assert_eq(blocks[0].map_reference_to(100, "mm39.chr5"), Some(649)) + assert_eq(blocks[0].map_reference_to(102, "mm39.chr5"), None) +} + +///| +test "bigmaf: pairwise identity counts non-gap comparisons" { + let block = @src.BigMafBlock::create([ + bigmaf_test_component(source="ref.chr1", size=4, text="AC-GT"), + bigmaf_test_component(source="a.chr1", size=4, text="AC-AT"), + ]) catch { + _ => abort("identity block should be valid") + } + bigmaf_test_close(block.pairwise_identity(), 0.75) +} + +///| +test "bigmaf: component lookup and source list preserve order" { + let (_, _, blocks) = bigmaf_test_data() + assert_eq(blocks[0].sources(), ["hg38.chr7", "panTro6.chr6", "mm39.chr5"]) + match blocks[0].component("mm39.chr5") { + Some(component) => assert_eq(component.strand, "-") + None => abort("mouse component should exist") + } + assert_eq(blocks[0].component("missing"), None) +} + +///| +test "bigmaf: compressed binary round trip preserves blocks" { + let file = bigmaf_test_file() + let (_, _, expected) = bigmaf_test_data() + assert_eq(file.blocks(), expected) + assert_true(file.is_compressed()) +} + +///| +test "bigmaf: uncompressed binary round trip preserves blocks" { + let file = bigmaf_test_file(compress=false) + let (_, _, expected) = bigmaf_test_data() + assert_eq(file.blocks(), expected) + assert_true(!file.is_compressed()) +} + +///| +test "bigmaf: parsed binary exposes standard schema" { + let file = bigmaf_test_file() + assert_eq(file.bed.header.defined_field_count, 3) + assert_eq(file.bed.header.field_count, 4) + assert_eq(file.bed.schema, @src.bigmaf_schema()) +} + +///| +test "bigmaf: parser recovers reference prefix" { + assert_eq(bigmaf_test_file().reference, "hg38") +} + +///| +test "bigmaf: parser preserves chromosome targets" { + let file = bigmaf_test_file() + assert_eq(file.bed.targets.length(), 2) + assert_eq(file.bed.targets[0].name, "chr7") + assert_eq(file.bed.targets[1].name, "chr12") +} + +///| +test "bigmaf: writer sorts blocks by target and start" { + let (reference, targets, blocks) = bigmaf_test_data() + let bytes = @src.bigmaf_write(reference, targets, [ + blocks[1], + blocks[2], + blocks[0], + ]) catch { + _ => abort("unsorted blocks should serialize") + } + let parsed = @src.bigmaf_parse(bytes) catch { + _ => abort("sorted BigMaf should parse") + } + let ordered = parsed.blocks() + assert_eq(ordered[0], blocks[0]) + assert_eq(ordered[1], blocks[1]) + assert_eq(ordered[2], blocks[2]) +} + +///| +test "bigmaf: interval search returns overlapping block" { + let hits = bigmaf_test_file().search("chr7", start=104, end=105) catch { + _ => abort("interval search should succeed") + } + assert_eq(hits.length(), 1) + assert_eq(hits[0].score, Some(23262.0)) +} + +///| +test "bigmaf: interval search accepts reference-prefixed chromosome" { + let hits = bigmaf_test_file().search("hg38.chr7", start=300, end=301) catch { + _ => abort("prefixed interval search should succeed") + } + assert_eq(hits.length(), 1) + assert_eq(hits[0].score, Some(5062.0)) +} + +///| +test "bigmaf: interval search uses half-open boundaries" { + let hits = bigmaf_test_file().search("chr7", start=108, end=109) catch { + _ => abort("boundary search should succeed") + } + assert_eq(hits.length(), 0) +} + +///| +test "bigmaf: interval search rejects unknown chromosome" { + let rejected = try { + ignore(bigmaf_test_file().search("chrM")) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: all blocks retain scores" { + let blocks = bigmaf_test_file().blocks() catch { + _ => abort("all blocks should decode") + } + assert_eq(blocks.length(), 3) + assert_eq(blocks[0].score, Some(23262.0)) + assert_eq(blocks[2].score, Some(6636.0)) +} + +///| +test "bigmaf: summary reports alignment contents" { + let summary = bigmaf_test_file().summary() catch { + _ => abort("summary should succeed") + } + assert_eq(summary.alignment_count, 3) + assert_eq(summary.target_count, 2) + assert_eq(summary.component_count, 8) + assert_eq(summary.empty_component_count, 1) + assert_eq(summary.aligned_columns, 23) + assert_eq(summary.covered_reference_bases, 21) + assert_true(summary.compressed) +} + +///| +test "bigmaf: MAF export restores newline-delimited blocks" { + let text = bigmaf_test_file().to_maf() catch { + _ => abort("MAF export should succeed") + } + assert_true(text.has_prefix("##maf version=1\n\n")) + assert_true(text.contains("a score=23262")) + assert_true(text.contains("s hg38.chr12 40 7 + 800 GCA-GCTG")) + assert_true(!text.contains(";s ")) +} + +///| +test "bigmaf: writer is deterministic" { + let (reference, targets, blocks) = bigmaf_test_data() + let first = @src.bigmaf_write(reference, targets, blocks) catch { + _ => abort("first write should succeed") + } + let second = @src.bigmaf_write(reference, targets, blocks) catch { + _ => abort("second write should succeed") + } + assert_eq(first, second) +} + +///| +test "bigmaf: itemsPerSlot creates multiple indexed blocks" { + let file = bigmaf_test_file(items_per_slot=1) + assert_eq(file.bed.blocks.length(), 3) + assert_eq(file.search("chr12").length(), 1) +} + +///| +test "bigmaf: writer rejects inconsistent reference prefix" { + let (_, targets, blocks) = bigmaf_test_data() + let rejected = try { + ignore(@src.bigmaf_write("hg19", targets, blocks)) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: writer rejects dotted reference name" { + let (_, targets, blocks) = bigmaf_test_data() + let rejected = try { + ignore(@src.bigmaf_write("hg38.patch", targets, blocks)) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: writer rejects reference source size mismatch" { + let target = @src.BigBedTarget::create("chr1", 101) catch { + _ => abort("target should be valid") + } + let rejected = try { + ignore(@src.bigmaf_write("hg38", [target], [bigmaf_test_block()])) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: writer rejects reverse reference component" { + let target = @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("target should be valid") + } + let component = bigmaf_test_component(strand="-") + let rejected = try { + ignore(@src.bigmaf_write("hg38", [target], [bigmaf_test_block(component~)])) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: writer rejects empty targets" { + let rejected = try { + ignore(@src.bigmaf_write("hg38", [], [])) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: parser rejects ordinary BigBed schema" { + let target = @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("target should be valid") + } + let record = @src.BigBedRecord::create("chr1", 0, 4) catch { + _ => abort("record should be valid") + } + let config = @src.BigBedWriteConfig::create(bed_columns=3) catch { + _ => abort("config should be valid") + } + let bytes = @src.bigbed_write([target], [record], config~) catch { + _ => abort("BigBed should serialize") + } + let rejected = try { + ignore(@src.bigmaf_parse(bytes)) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: parser rejects BED and MAF coordinate disagreement" { + let bytes = bigmaf_test_custom_bytes(["a;s hg38.chr1 1 4 + 100 ACGT;"], [ + (0, 4), + ]) + let rejected = try { + ignore(@src.bigmaf_parse(bytes)) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: parser rejects inconsistent reference prefixes" { + let bytes = bigmaf_test_custom_bytes( + ["a;s hg38.chr1 0 4 + 100 ACGT;", "a;s hg19.chr1 10 4 + 100 ACGT;"], + [(0, 4), (10, 14)], + ) + let rejected = try { + ignore(@src.bigmaf_parse(bytes)) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: parser rejects malformed embedded block" { + let bytes = bigmaf_test_custom_bytes(["not-maf;"], [(0, 4)]) + let rejected = try { + ignore(@src.bigmaf_parse(bytes)) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: empty binary file retains targets" { + let target = @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("target should be valid") + } + let bytes = @src.bigmaf_write("hg38", [target], []) catch { + _ => abort("empty BigMaf should serialize") + } + let file = @src.bigmaf_parse(bytes) catch { + _ => abort("empty BigMaf should parse") + } + assert_eq(file.reference, "") + assert_eq(file.blocks(), []) + assert_eq(file.target("chr1"), Some(target)) +} + +///| +test "bigmaf: target lookup accepts reference-prefixed name" { + let file = bigmaf_test_file() + assert_eq(file.target("hg38.chr7"), file.target("chr7")) + assert_eq(file.target("hg38."), None) +} + +///| +test "bigmaf: source coordinate outside component returns none" { + assert_eq(bigmaf_test_component().source_to_column(9), None) + assert_eq(bigmaf_test_component().source_to_column(14), None) +} + +///| +test "bigmaf: column mapping rejects out-of-range column" { + let rejected = try { + ignore(bigmaf_test_component().column_to_source(5)) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} + +///| +test "bigmaf: block rejects semicolon in comment" { + let rejected = try { + ignore( + @src.BigMafBlock::create([bigmaf_test_component()], comments=[ + "invalid;comment", + ]), + ) + false + } catch { + BigMafError(_) => true + } + assert_true(rejected) +} From 015a9e95902be4c08b7b83e317662b21d81f7da5 Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 08:47:02 +0800 Subject: [PATCH 21/41] =?UTF-8?q?#28=20feat(dreamlet):=20Bioconductor=20dr?= =?UTF-8?q?eamlet=20sample=C3=97cell-type=20pseudobulk=20&=20dreamlet=20BH?= =?UTF-8?q?=20TMM?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 25 +- examples/dreamlet_demo/main.mbt | 149 +++ examples/dreamlet_demo/moon.pkg | 6 + src/dreamlet.mbt | 1537 +++++++++++++++++++++++++++++++ src/variance_partition.mbt | 2 +- test/moonbit/dreamlet_test.mbt | 932 +++++++++++++++++++ 6 files changed, 2646 insertions(+), 5 deletions(-) create mode 100644 examples/dreamlet_demo/main.mbt create mode 100644 examples/dreamlet_demo/moon.pkg create mode 100644 src/dreamlet.mbt create mode 100644 test/moonbit/dreamlet_test.mbt diff --git a/README.md b/README.md index 1dac6dff..aac82c47 100644 --- a/README.md +++ b/README.md @@ -208,6 +208,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **edgeR** | Bioconductor edgeR | 差异表达分析、DGEList、精确检验、GLM拟合 | ✅ | | **limma** | Bioconductor limma | 差异表达分析、线性模型拟合、经验贝叶斯、voom变换、RPKM/CPM/quantile归一化、ComBat/removeBatchEffect批次校正、treat严格检验 | ✅ | | **variancePartition** | Bioconductor variancePartition | 重复测量线性混合模型、方差分解、BLUP、precision weights、dream contrast与Satterthwaite检验 | ✅ | +| **dreamlet** | Bioconductor dreamlet | sample×cell-type pseudobulk、TMM、cell/sample/gene过滤、logCPM、Poisson/voom precision weights、分cell-type重复测量模型及study-wide FDR | ✅ | | **SummarizedExperiment** | Bioconductor SummarizedExperiment | 多维基因组数据容器、Assays、行/列操作 | ✅ | | **RangedSummarizedExperiment** | Bioconductor SummarizedExperiment | GRanges/GRangesList行范围、复合特征精确重叠/最近邻、覆盖度、区间变换与协调子集 | ✅ | | **TreeSummarizedExperiment** | Bioconductor TreeSummarizedExperiment | 行/列树、节点链接、树节点子集、祖先/后代查询、层级聚合 | ✅ | @@ -560,6 +561,7 @@ IvanAXu/BioSeqs/ │ ├── milo.mbt # miloR KNN邻域差异丰度 (精炼采样、NB-GLM、graph spatial FDR、SCE接入) │ ├── zinbwave.mbt # zinbwave 零膨胀NB低维模型 (EM/IRLS、latent factors、observational weights、SCE接入) │ ├── variance_partition.mbt # variancePartition 混合模型方差分解、BLUP与dream重复测量检验 +│ ├── dreamlet.mbt # dreamlet pseudobulk、TMM/voom权重、分cell-type混合模型与study-wide FDR │ ├── monocle3.mbt # monocle3 单细胞轨迹分析 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read.mbt # ShortRead 短读序列质量控制 (QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告) │ ├── seq_quality_trim.mbt # NGS质量修剪与接头去除 (质量修剪、接头去除、poly-A修剪、长度/GC过滤、批量修剪) @@ -909,6 +911,7 @@ IvanAXu/BioSeqs/ │ ├── zinbwave_demo/ # zinbwave latent factors、dropout权重、残差/插补与SCE集成示例 │ ├── apeglm_demo/ # apeglm MLE/MAP、重尾收缩、FSR/FSOS、TSV与SE接入示例 │ ├── variance_partition_demo/ # variancePartition 方差分解、BLUP、precision weights、dream与SE接入示例 +│ ├── dreamlet_demo/ # dreamlet SCE pseudobulk、TMM/voom、donor随机截距与跨cell-type FDR示例 │ ├── monocle3_demo/ # monocle3 单细胞轨迹分析示例 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read_demo/ # ShortRead 短读序列质量控制示例 (QA统计、adapter修剪、质量修剪、FastQC报告) │ ├── scater_demo/ # scater 单细胞质量控制示例 (QC指标计算、细胞/基因过滤、标准化、HVG检测、PCA) @@ -1315,6 +1318,7 @@ IvanAXu/BioSeqs/ │ │ ├── zinbwave_test.mbt │ │ ├── apeglm_test.mbt │ │ ├── variance_partition_test.mbt +│ │ ├── dreamlet_test.mbt │ │ ├── shared_reference_alignment_test.mbt │ │ ├── alignment_map_test.mbt │ │ ├── bigbed_test.mbt @@ -1495,7 +1499,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 8984 个测试全部通过 +moon test # ✅ 9042 个测试全部通过 ``` ### 模块对照表 @@ -1600,6 +1604,7 @@ moon test # ✅ 8984 个测试全 | `edger_advanced.mbt` | edgeR QLF/Camera/Roast | 准似然F检验、QL分散度估计、camera竞争性基因集检验、roast自足基因集检验 | | `limma.mbt` | Bioconductor limma | 线性模型与 voom 变换 | | `variance_partition.mbt` | Bioconductor variancePartition | 多随机截距LMM、ML/REML方差分量、固定/随机/残差占比、BLUP、precision weights、dream contrast、数值Satterthwaite与BH-FDR | +| `dreamlet.mbt` | Bioconductor dreamlet | sample×cell-type pseudobulk、完整TMM、CPM/logCPM、Poisson/voom权重、typed fixed/random design、分cell-type dream拟合及两级BH-FDR | | `decontx.mbt` | Bioconductor decontX | cluster-native/contaminant多项式混合、Beta/Dirichlet先验EM、background、自动聚类、计数分解与SCE输出 | | `summarized_experiment.mbt` | Bioconductor SummarizedExperiment | 多维数据容器 | | `ranged_summarized_experiment.mbt` | Bioconductor RangedSummarizedExperiment | GRanges/GRangesList行范围、链特异重叠/最近邻、覆盖度、区间变换与协调子集 | @@ -1809,6 +1814,7 @@ moon test # ✅ 8984 个测试全 | `zinbwave.mbt` | `zinbwave` | ZINB交替EM/IRLS、cell/gene design与offset、确定性低维因子、gene dispersion shrinkage、observational weights、deviance residual及SingleCellExperiment包装 | | `apeglm.mbt` | `apeglm` | 负二项GLM MLE、自适应Cauchy/Student-t先验、阻尼Newton多起点MAP、Laplace后验SD/区间、FSR/FSOS/s-value、DESeq2与SummarizedExperiment包装 | | `variance_partition.mbt` | `variancePartition` | typed fixed/random design、多随机截距LMM、ML/REML方差分解、BLUP、weighted dream contrast、Satterthwaite自由度与SummarizedExperiment入口 | +| `dreamlet.mbt` | `dreamlet` | SCE到sample×cluster pseudobulk、TMM/logCPM、两阶段voom precision weights、固定/随机效应筛选、逐cell-type dream和study-wide FDR | | `shared_reference_alignment.mbt` | `Bio.Align.Alignment` | 同参考PWA/MSA的reference-boundary insertion同步、原query投影、局部坐标、metadata、统计与格式转换 | | `alignment_map.mbt` | `Bio.Align.Alignment.map/mapall` | 两层alignment坐标组合、正反链与gap传播、PSL、批量映射及protein/nucleotide MSA投影 | | `bigbed.mbt` | `Bio.Align.bigbed` | BigBed v4二进制读写、BED/AutoSQL、平衡B+ tree/R-tree、完整DEFLATE块解码、区间/名称查询与BED导出 | @@ -2939,6 +2945,14 @@ MAP 求解器实现阻尼 Newton、Cholesky 信息矩阵求解、逐级 ridge 解析器要求 `definedFieldCount=3`、`fieldCount=4` 及标准 `bedMaf` schema，并交叉验证 BED 区间、嵌入 MAF 第一条 component、reference prefix 和 chromosome target。构造器会诊断非法状态字符、负坐标、source 越界、size 与非 gap 长度不符、quality/gap 不同步、重复注释及不一致列宽；二进制层继续诊断损坏 magic、树节点、DEFLATE 和校验和。当前范围不生成 BigMaf zoom levels 或 extra indices，也不实现远程 HTTP range reader。 +### 256. cohort-scale 单细胞重复测量分析 (Bioconductor dreamlet) + +实现 Bioconductor `dreamlet` 的 sample×cell-type pseudobulk 混合模型流程，输入统一为 gene×cell 非负整数计数。`dreamlet_aggregate_to_pseudobulk` 按 sample 和 cluster 首次出现顺序求 raw count sum，为缺失的 sample×cluster 组合补零列和 `cell_counts=0`，并验证被选择 metadata 在同一样本内保持一致；`dreamlet_aggregate_sce` 可直接读取 `SingleCellExperiment` assay 与 `colData`。每个 cell type 独立过滤低细胞数或零文库样本，并按 total count、最小 count、CPM 达标样本比例过滤基因，避免不同 cell type 共享不适用的 retained set。 + +归一化实现 edgeR 风格 TMM：按归一化 count 的 75% 分位数选择参考样本，计算 M/A 值，执行 log-ratio 与 abundance 双裁剪，以 inverse asymptotic variance 加权，并将因子几何中心化到 1。effective library size 用于 normalized CPM 和带 prior count 的 log2 CPM。precision-weight 流程先从 count 均值和 library scale 构造可配置的 Poisson 初始权重，再拟合 residual variance 四次方根对平均表达的 LOWESS 趋势，最终使用预测方差倒数作为 voom-style observation weights。 + +`DreamletEffectSpec` 和 `DreamletModelSpec` 以 typed numeric、categorical、random effects 代替 R formula 解析，并转换到现有 `variancePartition` 设计与求解器；常量固定效应和无重复 level 的随机效应会按 cell type 删除并记录。`dreamlet_process_assays` 输出每个 cell type 的过滤、TMM、表达、权重、design 和趋势诊断，`dreamlet` 对指定 coefficient 运行 weighted fixed/random mixed model，报告数值 Satterthwaite 检验、cluster 内 BH-FDR 和跨全部 gene×cell-type hypotheses 的 study-wide BH-FDR。查询 API 提供 assay lookup、top table 和分阶段摘要。当前范围支持 dense arrays 和随机截距，不解析 R formula，不包含随机斜率、Kenward-Roger、limma empirical Bayes、稀疏/并行后端、绘图或上游 `aggr_means` 的变化 numeric cell metadata 聚合。 + ## 性能优化 ### 优化策略 @@ -3040,8 +3054,8 @@ MAP 求解器实现阻尼 Newton、Cholesky 信息矩阵求解、逐级 ridge | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 8984 | -| 通过数 | 8984 | +| 总测试数 | 9042 | +| 通过数 | 9042 | | 失败数 | 0 | | 通过率 | 100% | @@ -3350,6 +3364,7 @@ moon test --update | Bio.SearchIO.FastaIO | `fasta_search_io_test.mbt` | 19 | | Bio.SearchIO.InfernalIO | `infernal_io_test.mbt` | 37 | | Bioconductor variancePartition | `variance_partition_test.mbt` | 38 | +| Bioconductor dreamlet | `dreamlet_test.mbt` | 58 | | Bio.PopGen.GenePop | `gene_pop_test.mbt` | 34 | | Bioconductor stageR | `stage_r_test.mbt` | 25 | | Bioconductor EnrichedHeatmap | `enriched_heatmap_test.mbt` | 20 | @@ -3445,7 +3460,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 363 个示例程序，展示各模块的典型用法： +项目提供 364 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3634,6 +3649,7 @@ moon run cmd/bench/main.mbt | fasta_search_io_demo | FASTA搜索输出解析（-m8表格、-m9注释头、元数据、Query/Hit/HSP聚合） | `moon run examples/fasta_search_io_demo/main.mbt` | | infernal_io_demo | Infernal cmscan/cmsearch解析（tabular 3、non-verbose文本、local-end片段、过滤与SearchIO转换） | `moon run examples/infernal_io_demo` | | variance_partition_demo | typed固定/随机设计、ML方差分解、BLUP、precision weights、dream contrast与SummarizedExperiment接入 | `moon run examples/variance_partition_demo` | +| dreamlet_demo | SingleCellExperiment pseudobulk、TMM/logCPM、Poisson/voom权重、donor随机截距和跨cell-type FDR | `moon run examples/dreamlet_demo` | | shared_reference_alignment_demo | 共享参考PWA/MSA合并、reference insertion同步、坐标映射、统计、MSA与aligned FASTA转换 | `moon run examples/shared_reference_alignment_demo` | | alignment_map_demo | chromosome→transcript→read坐标组合、intron gap、反链、坐标查询、PSL与protein-to-codon MSA投影 | `moon run examples/alignment_map_demo` | | bigbed_demo | BigBed v4压缩写入/解析、AutoSQL、多级索引查询、负链exon坐标、BED导出及损坏文件诊断 | `moon run examples/bigbed_demo` | @@ -3742,6 +3758,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bioconductor miloR 单细胞邻域差异丰度（精确KNN图、median精炼采样、邻域计数、固定效应NB-GLM、graph spatial FDR与SCE接入） - ✅ 实现 Bio.SearchIO.InfernalIO Infernal cmscan/cmsearch输出解析（tabular 1/2/3、non-verbose文本、--noali、CM/HMM-only、local-end多片段与SearchIO转换） - ✅ 实现 Bioconductor variancePartition 重复测量混合模型（ML/REML方差分解、BLUP、precision weights、dream contrast、数值Satterthwaite、BH-FDR与SummarizedExperiment接入） +- ✅ 实现 Bioconductor dreamlet cohort-scale单细胞重复测量分析（sample×cell-type pseudobulk、TMM、过滤、logCPM、Poisson/voom权重、typed混合模型与study-wide FDR） - ✅ 实现 Bio.Align共享参考序列比对合并（混合PWA/MSA、reference-boundary insertion同步、局部坐标、双向映射、统计与格式转换） - ✅ 实现 Bio.Align.Alignment map/mapall（alignment path组合、local clipping、gap与正反链传播、坐标查询、PSL及protein-to-codon MSA投影） - ✅ 实现 Bio.Align.bigbed BigBed v4二进制区间格式（BED3-BED12、AutoSQL、多级B+ tree/R-tree、DEFLATE、区间/名称查询与BED导出） diff --git a/examples/dreamlet_demo/main.mbt b/examples/dreamlet_demo/main.mbt new file mode 100644 index 00000000..f79b1660 --- /dev/null +++ b/examples/dreamlet_demo/main.mbt @@ -0,0 +1,149 @@ +///| +fn demo_data() -> ( + Array[Array[Double]], + Array[String], + Array[String], + Array[String], + Array[String], + Array[String], + Array[String], +) { + let genes = [ + "response_up", "stable", "T_cell_marker", "donor_signal", "response_down", + ] + let counts : Array[Array[Double]] = [[], [], [], [], []] + let cells : Array[String] = [] + let samples : Array[String] = [] + let clusters : Array[String] = [] + let treatments : Array[String] = [] + let donors : Array[String] = [] + for donor in 0..<4 { + for treatment in 0..<2 { + let sample = "D" + + (donor + 1).to_string() + + (if treatment == 0 { "_C" } else { "_T" }) + for cluster in 0..<2 { + let cluster_name = if cluster == 0 { "T_cell" } else { "Monocyte" } + for replicate in 0..<3 { + cells.push( + sample + "_" + cluster_name + "_" + (replicate + 1).to_string(), + ) + samples.push(sample) + clusters.push(cluster_name) + treatments.push(if treatment == 0 { "Control" } else { "Treated" }) + donors.push("D" + (donor + 1).to_string()) + counts[0].push( + (10 + treatment * 10 + donor + (if replicate == 2 { 1 } else { 0 })).to_double(), + ) + counts[1].push((8 + replicate % 2).to_double()) + counts[2].push( + (if cluster == 0 { 18 + treatment } else { 4 + treatment }).to_double(), + ) + counts[3].push((6 + donor * 2 + replicate).to_double()) + counts[4].push( + (18 - treatment * 8 + cluster + (if replicate == 1 { 1 } else { 0 })).to_double(), + ) + } + } + } + } + (counts, genes, cells, samples, clusters, treatments, donors) +} + +///| +fn main { + println("=== Bioconductor dreamlet Demo ===") + let (counts, genes, cells, samples, clusters, treatments, donors) = demo_data() + + println("\n1. Build a SingleCellExperiment with cohort metadata") + let sce = @src.SingleCellExperiment::new(counts, genes, cells) + sce.col_data["sample_id"] = samples + sce.col_data["cluster_id"] = clusters + sce.col_data["Treatment"] = treatments + sce.col_data["Donor"] = donors + println( + " " + + @src.sce_get_n_genes(sce).to_string() + + " genes x " + + @src.sce_get_n_cells(sce).to_string() + + " cells", + ) + + println("\n2. Aggregate raw counts by sample and cell type") + let pseudobulk = @src.dreamlet_aggregate_sce(sce, "sample_id", "cluster_id", metadata_fields=[ + "Treatment", "Donor", + ]) catch { + _ => abort("failed to aggregate the SingleCellExperiment") + } + println(pseudobulk.summary()) + + println("3. Apply filtering, TMM normalization, and voom weights") + let model = @src.dreamlet_model([ + @src.dreamlet_categorical_effect("Treatment", reference="Control"), + @src.dreamlet_random_effect("Donor"), + ]) catch { + _ => abort("failed to build the repeated-measures model") + } + let config = @src.DreamletProcessConfig::create( + min_cells=3, + min_count=2.0, + min_samples=4, + min_prop=0.5, + min_total_count=10.0, + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("failed to build dreamlet processing controls") + } + let processed = @src.dreamlet_process_assays(pseudobulk, model, config~) catch { + _ => abort("failed to process pseudobulk assays") + } + println(processed.summary()) + for assay in processed.assays { + println( + " " + + assay.cluster_id + + ": " + + assay.gene_names.length().to_string() + + " genes, TMM reference=" + + assay.tmm_reference_sample, + ) + } + + println("4. Fit the donor random-intercept treatment contrast") + let result = @src.dreamlet( + processed, + "Treatment:Treated", + contrast_name="Treated-Control", + max_iterations=80, + tolerance=0.01, + ) catch { + _ => abort("failed to run dreamlet differential expression") + } + println(result.summary()) + + println("5. Inspect the study-wide top table") + let top = result.top_table() catch { + _ => abort("failed to create the dreamlet top table") + } + let limit = if top.length() < 6 { top.length() } else { 6 } + for index in 0.. Unit raise DreamletError { + raise DreamletError(message) +} + +///| +fn dreamlet_is_finite(value : Double) -> Bool { + value == value && value.abs() < 1.0e300 +} + +///| +fn dreamlet_log2(value : Double) -> Double { + @math.ln(value) / @math.ln(2.0) +} + +///| +fn dreamlet_copy_matrix(matrix : Array[Array[Double]]) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in matrix { + output.push(row.copy()) + } + output +} + +///| +fn dreamlet_copy_metadata( + metadata : Map[String, Array[String]], +) -> Map[String, Array[String]] { + let keys = metadata.keys().collect() + let output : Map[String, Array[String]] = Map([], capacity=keys.length()) + for key in keys { + output[key] = metadata[key].copy() + } + output +} + +///| +fn dreamlet_mean(values : Array[Double]) -> Double { + if values.length() == 0 { + return 0.0 + } + let mut total = 0.0 + for value in values { + total = total + value + } + total / values.length().to_double() +} + +///| +fn dreamlet_median(values : Array[Double]) -> Double { + if values.length() == 0 { + return 0.0 + } + let sorted = values.copy() + sorted.sort_by(fn(left : Double, right : Double) -> Int { + if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + let middle = sorted.length() / 2 + if sorted.length() % 2 == 1 { + sorted[middle] + } else { + (sorted[middle - 1] + sorted[middle]) / 2.0 + } +} + +///| +fn dreamlet_quantile(values : Array[Double], probability : Double) -> Double { + if values.length() == 0 { + return 0.0 + } + let sorted = values.copy() + sorted.sort_by(fn(left : Double, right : Double) -> Int { + if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + if sorted.length() == 1 { + return sorted[0] + } + let location = probability * (sorted.length() - 1).to_double() + let lower = location.floor().to_int() + let upper = (lower + 1).min(sorted.length() - 1) + let fraction = location - lower.to_double() + sorted[lower] + fraction * (sorted[upper] - sorted[lower]) +} + +///| +fn dreamlet_validate_names( + values : Array[String], + kind : String, +) -> Unit raise DreamletError { + let seen : Map[String, Bool] = Map([], capacity=values.length()) + for value in values { + if value == "" { + dreamlet_fail("dreamlet " + kind + " names must not be empty") + } + if seen.contains(value) { + dreamlet_fail("dreamlet " + kind + " names must be unique") + } + seen[value] = true + } +} + +///| +fn dreamlet_validate_count_matrix( + counts : Array[Array[Double]], + observations : Int, + require_integer : Bool, +) -> Unit raise DreamletError { + if counts.length() == 0 || observations == 0 { + dreamlet_fail("dreamlet count matrix must not be empty") + } + for row in counts { + if row.length() != observations { + dreamlet_fail( + "dreamlet count matrix must be rectangular and match the observations", + ) + } + for value in row { + if !dreamlet_is_finite(value) || value < 0.0 { + dreamlet_fail("dreamlet counts must be finite and non-negative") + } + if require_integer && (value - value.round()).abs() > 1.0e-8 { + dreamlet_fail("dreamlet raw counts must contain integer values") + } + } + } +} + +///| +pub fn dreamlet_numeric_effect(name : String) -> DreamletEffectSpec { + DreamletEffectSpec::{ name, kind: DreamletEffectKind::Numeric, reference: "" } +} + +///| +pub fn dreamlet_categorical_effect( + name : String, + reference? : String = "", +) -> DreamletEffectSpec { + DreamletEffectSpec::{ name, kind: DreamletEffectKind::Categorical, reference } +} + +///| +pub fn dreamlet_random_effect(name : String) -> DreamletEffectSpec { + DreamletEffectSpec::{ name, kind: DreamletEffectKind::Random, reference: "" } +} + +///| +pub fn dreamlet_model( + effects : Array[DreamletEffectSpec], + intercept? : Bool = true, +) -> DreamletModelSpec raise DreamletError { + let seen : Map[String, Bool] = Map([], capacity=effects.length()) + let mut fixed_effects = 0 + for effect in effects { + if effect.name == "" { + dreamlet_fail("dreamlet effect names must not be empty") + } + if seen.contains(effect.name) { + dreamlet_fail("dreamlet effect names must be unique") + } + seen[effect.name] = true + match effect.kind { + DreamletEffectKind::Categorical => fixed_effects = fixed_effects + 1 + DreamletEffectKind::Numeric => { + fixed_effects = fixed_effects + 1 + if effect.reference != "" { + dreamlet_fail( + "dreamlet reference levels are only valid for categorical effects", + ) + } + } + DreamletEffectKind::Random => + if effect.reference != "" { + dreamlet_fail( + "dreamlet reference levels are only valid for categorical effects", + ) + } + } + } + if !intercept && fixed_effects == 0 { + dreamlet_fail("dreamlet model must contain at least one fixed coefficient") + } + DreamletModelSpec::{ effects: effects.copy(), intercept } +} + +///| +pub fn DreamletProcessConfig::create( + min_cells? : Int = 5, + min_count? : Double = 5.0, + min_samples? : Int = 4, + min_prop? : Double = 0.4, + min_total_count? : Double = 15.0, + prior_count? : Double = 0.5, + span? : Double = 0.5, + logratio_trim? : Double = 0.3, + sum_trim? : Double = 0.05, + use_poisson_initial_weights? : Bool = true, + rescale_initial_weights? : Bool = false, + max_iterations? : Int = 100, + tolerance? : Double = 0.005, +) -> DreamletProcessConfig raise DreamletError { + if min_cells < 1 { + dreamlet_fail("dreamlet min_cells must be positive") + } + if !dreamlet_is_finite(min_count) || min_count < 0.0 { + dreamlet_fail("dreamlet min_count must be finite and non-negative") + } + if min_samples < 3 { + dreamlet_fail("dreamlet min_samples must be at least three") + } + if !dreamlet_is_finite(min_prop) || min_prop <= 0.0 || min_prop > 1.0 { + dreamlet_fail("dreamlet min_prop must be in (0, 1]") + } + if !dreamlet_is_finite(min_total_count) || min_total_count < 0.0 { + dreamlet_fail("dreamlet min_total_count must be finite and non-negative") + } + if !dreamlet_is_finite(prior_count) || prior_count <= 0.0 { + dreamlet_fail("dreamlet prior_count must be finite and positive") + } + if !dreamlet_is_finite(span) || span <= 0.0 || span > 1.0 { + dreamlet_fail("dreamlet LOWESS span must be in (0, 1]") + } + if !dreamlet_is_finite(logratio_trim) || + logratio_trim < 0.0 || + logratio_trim >= 0.5 { + dreamlet_fail("dreamlet TMM log-ratio trim must be in [0, 0.5)") + } + if !dreamlet_is_finite(sum_trim) || sum_trim < 0.0 || sum_trim >= 0.5 { + dreamlet_fail("dreamlet TMM abundance trim must be in [0, 0.5)") + } + if max_iterations <= 0 { + dreamlet_fail("dreamlet max_iterations must be positive") + } + if !dreamlet_is_finite(tolerance) || tolerance <= 0.0 { + dreamlet_fail("dreamlet tolerance must be finite and positive") + } + DreamletProcessConfig::{ + min_cells, + min_count, + min_samples, + min_prop, + min_total_count, + prior_count, + span, + logratio_trim, + sum_trim, + use_poisson_initial_weights, + rescale_initial_weights, + max_iterations, + tolerance, + } +} + +///| +pub fn DreamletProcessConfig::default() -> DreamletProcessConfig { + DreamletProcessConfig::{ + min_cells: 5, + min_count: 5.0, + min_samples: 4, + min_prop: 0.4, + min_total_count: 15.0, + prior_count: 0.5, + span: 0.5, + logratio_trim: 0.3, + sum_trim: 0.05, + use_poisson_initial_weights: true, + rescale_initial_weights: false, + max_iterations: 100, + tolerance: 0.005, + } +} + +///| +pub fn dreamlet_aggregate_to_pseudobulk( + counts : Array[Array[Double]], + gene_names : Array[String], + cell_names : Array[String], + sample_ids : Array[String], + cluster_ids : Array[String], + cell_metadata? : Map[String, Array[String]] = Map([], capacity=0), +) -> DreamletPseudobulk raise DreamletError { + let cells = cell_names.length() + if gene_names.length() != counts.length() { + dreamlet_fail("dreamlet gene names must match count matrix rows") + } + dreamlet_validate_names(gene_names, "gene") + dreamlet_validate_names(cell_names, "cell") + if sample_ids.length() != cells || cluster_ids.length() != cells { + dreamlet_fail( + "dreamlet sample and cluster identifiers must match count matrix columns", + ) + } + dreamlet_validate_count_matrix(counts, cells, true) + let sample_names : Array[String] = [] + let cluster_names : Array[String] = [] + let sample_index : Map[String, Int] = Map([], capacity=cells) + let cluster_index : Map[String, Int] = Map([], capacity=cells) + for cell in 0.. DreamletPseudobulk raise DreamletError { + if sample_id == "" || cluster_id == "" || assay == "" { + dreamlet_fail("dreamlet SCE field and assay names must not be empty") + } + let counts = sce_get_assay(sce, assay) + if counts.length() == 0 { + dreamlet_fail("dreamlet SCE assay '" + assay + "' is absent or empty") + } + let samples = sce_get_col_data(sce, sample_id) + let clusters = sce_get_col_data(sce, cluster_id) + if samples.length() == 0 { + dreamlet_fail("dreamlet SCE sample field '" + sample_id + "' is absent") + } + if clusters.length() == 0 { + dreamlet_fail("dreamlet SCE cluster field '" + cluster_id + "' is absent") + } + let metadata : Map[String, Array[String]] = Map( + [], + capacity=metadata_fields.length(), + ) + let seen : Map[String, Bool] = Map([], capacity=metadata_fields.length()) + for field in metadata_fields { + if field == "" || seen.contains(field) { + dreamlet_fail( + "dreamlet SCE metadata field names must be non-empty and unique", + ) + } + seen[field] = true + let values = sce_get_col_data(sce, field) + if values.length() == 0 { + dreamlet_fail("dreamlet SCE metadata field '" + field + "' is absent") + } + metadata[field] = values.copy() + } + dreamlet_aggregate_to_pseudobulk( + counts, + sce.row_names, + sce.col_names, + samples, + clusters, + cell_metadata=metadata, + ) +} + +///| +fn dreamlet_tmm_rank(values : Array[Double], index : Int) -> Double { + let mut less = 0 + let mut equal = 0 + for value in values { + if value < values[index] { + less = less + 1 + } else if value == values[index] { + equal = equal + 1 + } + } + less.to_double() + (equal.to_double() + 1.0) / 2.0 +} + +///| +fn dreamlet_tmm_pair( + counts : Array[Array[Double]], + library_sizes : Array[Double], + sample : Int, + reference : Int, + logratio_trim : Double, + sum_trim : Double, +) -> Double { + if sample == reference { + return 1.0 + } + let m_values : Array[Double] = [] + let a_values : Array[Double] = [] + let variances : Array[Double] = [] + let observed_library = library_sizes[sample] + let reference_library = library_sizes[reference] + for gene in 0.. 0.0 && reference_count > 0.0 { + let observed_rate = observed / observed_library + let reference_rate = reference_count / reference_library + let m_value = dreamlet_log2(observed_rate / reference_rate) + let a_value = 0.5 * dreamlet_log2(observed_rate * reference_rate) + let variance = (observed_library - observed) / + (observed_library * observed) + + (reference_library - reference_count) / + (reference_library * reference_count) + if dreamlet_is_finite(m_value) && + dreamlet_is_finite(a_value) && + dreamlet_is_finite(variance) && + variance > 0.0 { + m_values.push(m_value) + a_values.push(a_value) + variances.push(variance) + } + } + } + let count = m_values.length() + if count == 0 { + return 1.0 + } + let lower_m = (count.to_double() * logratio_trim).floor().to_int() + 1 + let upper_m = count + 1 - lower_m + let lower_a = (count.to_double() * sum_trim).floor().to_int() + 1 + let upper_a = count + 1 - lower_a + let mut weighted_sum = 0.0 + let mut weight_sum = 0.0 + for index in 0..= lower_m.to_double() && + rank_m <= upper_m.to_double() && + rank_a >= lower_a.to_double() && + rank_a <= upper_a.to_double() { + let weight = 1.0 / variances[index] + weighted_sum = weighted_sum + weight * m_values[index] + weight_sum = weight_sum + weight + } + } + if weight_sum <= 0.0 { + 1.0 + } else { + @math.exp(weighted_sum / weight_sum * @math.ln(2.0)) + } +} + +///| +pub fn dreamlet_tmm( + counts : Array[Array[Double]], + logratio_trim? : Double = 0.3, + sum_trim? : Double = 0.05, +) -> DreamletTmmResult raise DreamletError { + if counts.length() == 0 || counts[0].length() == 0 { + dreamlet_fail("dreamlet TMM requires a non-empty count matrix") + } + let samples = counts[0].length() + dreamlet_validate_count_matrix(counts, samples, false) + if logratio_trim < 0.0 || logratio_trim >= 0.5 { + dreamlet_fail("dreamlet TMM log-ratio trim must be in [0, 0.5)") + } + if sum_trim < 0.0 || sum_trim >= 0.5 { + dreamlet_fail("dreamlet TMM abundance trim must be in [0, 0.5)") + } + let library_sizes = Array::make(samples, 0.0) + for sample in 0.. 0.0 { + all_zero = false + break + } + } + if !all_zero { + normalized.push(counts[gene][sample] / library_sizes[sample]) + } + } + upper_quartiles[sample] = dreamlet_quantile(normalized, 0.75) + } + let mean_upper = dreamlet_mean(upper_quartiles) + let median_upper = dreamlet_median(upper_quartiles) + let mut reference = 0 + if median_upper > 1.0e-20 { + let mut best = (upper_quartiles[0] - mean_upper).abs() + for sample in 1.. best_mass { + best_mass = mass + reference = sample + } + } + } + let factors = Array::make(samples, 1.0) + for sample in 0.. Array[Array[Double]] raise DreamletError { + if effective_library_sizes.length() == 0 { + dreamlet_fail("dreamlet normalized counts require library sizes") + } + dreamlet_validate_count_matrix( + counts, + effective_library_sizes.length(), + false, + ) + for size in effective_library_sizes { + if !dreamlet_is_finite(size) || size <= 0.0 { + dreamlet_fail( + "dreamlet effective library sizes must be finite and positive", + ) + } + } + let output : Array[Array[Double]] = [] + for row in counts { + let normalized = Array::make(row.length(), 0.0) + for sample in 0.. Array[Array[Double]] raise DreamletError { + if !dreamlet_is_finite(prior_count) || prior_count <= 0.0 { + dreamlet_fail("dreamlet log CPM prior count must be finite and positive") + } + if effective_library_sizes.length() == 0 { + dreamlet_fail("dreamlet log CPM requires library sizes") + } + dreamlet_validate_count_matrix( + counts, + effective_library_sizes.length(), + false, + ) + for size in effective_library_sizes { + if !dreamlet_is_finite(size) || size <= 0.0 { + dreamlet_fail( + "dreamlet effective library sizes must be finite and positive", + ) + } + } + let output : Array[Array[Double]] = [] + for row in counts { + let transformed = Array::make(row.length(), 0.0) + for sample in 0.. Map[String, Array[String]] { + let keys = metadata.keys().collect() + let output : Map[String, Array[String]] = Map([], capacity=keys.length()) + for key in keys { + let values : Array[String] = [] + for index in indices { + values.push(metadata[key][index]) + } + output[key] = values + } + output +} + +///| +fn dreamlet_unique_count(values : Array[String]) -> Int { + let seen : Map[String, Bool] = Map([], capacity=values.length()) + for value in values { + seen[value] = true + } + seen.length() +} + +///| +fn dreamlet_build_design( + sample_names : Array[String], + metadata : Map[String, Array[String]], + model : DreamletModelSpec, +) -> (VariancePartitionDesign, Array[String]) raise DreamletError { + let fixed : Array[VariancePartitionFixedEffect] = [] + let random : Array[VariancePartitionRandomEffect] = [] + let dropped : Array[String] = [] + for spec in model.effects { + match metadata.get(spec.name) { + None => + dreamlet_fail( + "dreamlet model metadata field '" + spec.name + "' is absent", + ) + Some(values) => { + if values.length() != sample_names.length() { + dreamlet_fail( + "dreamlet model metadata does not match retained samples", + ) + } + match spec.kind { + DreamletEffectKind::Numeric => { + let numeric : Array[Double] = [] + for value in values { + match parse_double(value) { + Some(parsed) => + if dreamlet_is_finite(parsed) { + numeric.push(parsed) + } else { + dreamlet_fail( + "dreamlet numeric metadata '" + + spec.name + + "' must be finite", + ) + } + None => + dreamlet_fail( + "dreamlet numeric metadata '" + + spec.name + + "' contains an invalid value", + ) + } + } + let mut varying = false + for index in 1.. 1.0e-12 { + varying = true + break + } + } + if varying { + let effect = vp_numeric_effect(spec.name, numeric) catch { + VariancePartitionError(message) => + raise DreamletError("variancePartition: " + message) + } + fixed.push(effect) + } else { + dropped.push(spec.name + ": constant numeric effect") + } + } + DreamletEffectKind::Categorical => { + let levels = dreamlet_unique_count(values) + if levels < 2 { + dropped.push(spec.name + ": constant categorical effect") + } else { + if spec.reference != "" && !values.contains(spec.reference) { + dreamlet_fail( + "dreamlet reference level '" + + spec.reference + + "' for '" + + spec.name + + "' is absent after filtering", + ) + } + let effect = vp_categorical_effect( + spec.name, + values, + reference=spec.reference, + ) catch { + VariancePartitionError(message) => + raise DreamletError("variancePartition: " + message) + } + fixed.push(effect) + } + } + DreamletEffectKind::Random => { + let levels = dreamlet_unique_count(values) + if levels < 2 { + dropped.push(spec.name + ": constant random effect") + } else if levels >= values.length() { + dropped.push( + spec.name + ": random effect has no replicated levels", + ) + } else { + let effect = vp_random_effect(spec.name, values) catch { + VariancePartitionError(message) => + raise DreamletError("variancePartition: " + message) + } + random.push(effect) + } + } + } + } + } + } + let design = vp_design(sample_names, fixed, random, intercept=model.intercept) catch { + VariancePartitionError(message) => + raise DreamletError("variancePartition: " + message) + } + (design, dropped) +} + +///| +fn dreamlet_initial_weights( + counts : Array[Array[Double]], + prior_count : Double, + poisson : Bool, +) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in counts { + let weights = Array::make(row.length(), 1.0) + if poisson { + let mut total = 0.0 + for sample in 0.. DreamletProcessedAssay raise DreamletError { + let retained_samples : Array[Int] = [] + let dropped_samples : Array[String] = [] + for sample in 0..= config.min_cells && + source.library_sizes[sample] > 0.0 { + retained_samples.push(sample) + } else { + dropped_samples.push(source.sample_names[sample]) + } + } + if retained_samples.length() < config.min_samples { + dreamlet_fail( + "fewer than " + + config.min_samples.to_string() + + " samples pass cell-count and library-size filters", + ) + } + let sample_names : Array[String] = [] + let cell_counts : Array[Int] = [] + let library_sizes : Array[Double] = [] + for index in retained_samples { + sample_names.push(source.sample_names[index]) + cell_counts.push(source.cell_counts[index]) + library_sizes.push(source.library_sizes[index]) + } + let retained_counts : Array[Array[Double]] = [] + for row in source.counts { + let selected : Array[Double] = [] + for index in retained_samples { + selected.push(row[index]) + } + retained_counts.push(selected) + } + let metadata = dreamlet_subset_metadata(source.metadata, retained_samples) + let tmm = dreamlet_tmm( + retained_counts, + logratio_trim=config.logratio_trim, + sum_trim=config.sum_trim, + ) + let effective_sizes = Array::make(sample_names.length(), 0.0) + for sample in 0..= cpm_cutoff { + expressed = expressed + 1 + } + } + if total >= config.min_total_count && expressed >= required_samples { + retained_genes.push(gene) + } else { + dropped_genes.push(gene_names[gene]) + } + } + if retained_genes.length() < 2 { + dreamlet_fail("fewer than two genes pass expression filters") + } + let filtered_names : Array[String] = [] + let filtered_counts : Array[Array[Double]] = [] + for gene in retained_genes { + filtered_names.push(gene_names[gene]) + filtered_counts.push(retained_counts[gene].copy()) + } + let normalized = dreamlet_compute_norm_counts( + filtered_counts, effective_sizes, + ) + let log_cpm = dreamlet_compute_log_cpm( + filtered_counts, + effective_sizes, + prior_count=config.prior_count, + ) + let (design, dropped_effects) = dreamlet_build_design( + sample_names, metadata, model, + ) + let initial = dreamlet_initial_weights( + filtered_counts, + config.prior_count, + config.use_poisson_initial_weights, + ) + let fits : Array[VariancePartitionFit] = [] + let trend_points : Array[(Double, Double)] = [] + let mean_log_library : Double = { + let values : Array[Double] = [] + for size in effective_sizes { + values.push(dreamlet_log2(size + 1.0)) + } + dreamlet_mean(values) + } + for gene in 0.. + raise DreamletError( + "initial precision model failed for gene '" + + filtered_names[gene] + + "': " + + message, + ) + } + fits.push(fit) + let x = dreamlet_mean(log_cpm[gene]) + + mean_log_library - + dreamlet_log2(1000000.0) + let y = fit.residual_variance.max(0.0).sqrt().sqrt() + trend_points.push((x, y)) + } + trend_points.sort_by(fn( + left : (Double, Double), + right : (Double, Double), + ) -> Int { + if left.0 < right.0 { + -1 + } else if left.0 > right.0 { + 1 + } else { + 0 + } + }) + let trend_x : Array[Double] = [] + let trend_y : Array[Double] = [] + for point in trend_points { + trend_x.push(point.0) + trend_y.push(point.1) + } + let trend_fitted = lowess( + trend_x, + trend_y, + f=config.span, + n_steps=0, + delta=0.0, + ) + let precision : Array[Array[Double]] = [] + for gene in 0.. DreamletProcessedData raise DreamletError { + if pseudobulk.assays.length() == 0 { + dreamlet_fail("dreamlet pseudobulk object contains no assays") + } + if pseudobulk.gene_names.length() == 0 { + dreamlet_fail("dreamlet pseudobulk object contains no genes") + } + ignore( + DreamletProcessConfig::create( + min_cells=config.min_cells, + min_count=config.min_count, + min_samples=config.min_samples, + min_prop=config.min_prop, + min_total_count=config.min_total_count, + prior_count=config.prior_count, + span=config.span, + logratio_trim=config.logratio_trim, + sum_trim=config.sum_trim, + use_poisson_initial_weights=config.use_poisson_initial_weights, + rescale_initial_weights=config.rescale_initial_weights, + max_iterations=config.max_iterations, + tolerance=config.tolerance, + ), + ) + let assays : Array[DreamletProcessedAssay] = [] + let exclusions : Array[DreamletExclusion] = [] + for source in pseudobulk.assays { + assays.push( + dreamlet_process_one(source, pseudobulk.gene_names, model, config), + ) catch { + DreamletError(message) => + exclusions.push(DreamletExclusion::{ + cluster_id: source.cluster_id, + reason: message, + }) + } + } + if assays.length() == 0 { + let reason = if exclusions.length() > 0 { + ": " + exclusions[0].reason + } else { + "" + } + dreamlet_fail("dreamlet retained no assays" + reason) + } + DreamletProcessedData::{ assays, exclusions, config } +} + +///| +fn dreamlet_bh_adjust(p_values : Array[Double]) -> Array[Double] { + let count = p_values.length() + let order : Array[Int] = [] + for index in 0.. Int { + if p_values[left] < p_values[right] { + -1 + } else if p_values[left] > p_values[right] { + 1 + } else { + left - right + } + }) + let adjusted = Array::make(count, 1.0) + let mut running = 1.0 + let mut rank = count + while rank > 0 { + let original = order[rank - 1] + let candidate = (p_values[original] * count.to_double() / rank.to_double()).min( + 1.0, + ) + running = running.min(candidate) + adjusted[original] = running.max(p_values[original]) + rank = rank - 1 + } + adjusted +} + +///| +pub fn dreamlet( + processed : DreamletProcessedData, + coefficient_name : String, + contrast_name? : String = "", + reml? : Bool = true, + max_iterations? : Int = 100, + tolerance? : Double = 0.005, +) -> DreamletResult raise DreamletError { + if coefficient_name == "" { + dreamlet_fail("dreamlet coefficient name must not be empty") + } + if max_iterations <= 0 || !dreamlet_is_finite(tolerance) || tolerance <= 0.0 { + dreamlet_fail("dreamlet fit controls are invalid") + } + let resolved_name = if contrast_name == "" { + coefficient_name + } else { + contrast_name + } + let assay_results : Array[DreamletAssayResult] = [] + let exclusions = processed.exclusions.copy() + let flattened : Array[DreamletGeneResult] = [] + for assay in processed.assays { + try { + let contrast = vp_coefficient_contrast( + assay.design, + resolved_name, + coefficient_name, + ) + let result = dream( + assay.log_cpm, + assay.design, + contrast, + gene_names=assay.gene_names, + weights=assay.precision_weights, + reml~, + max_iterations~, + tolerance~, + ) + assay_results.push(DreamletAssayResult::{ + cluster_id: assay.cluster_id, + result, + }) + for gene in result.genes { + flattened.push(DreamletGeneResult::{ + cluster_id: assay.cluster_id, + gene_name: gene.gene_name, + estimate: gene.estimate, + standard_error: gene.standard_error, + statistic: gene.statistic, + degrees_of_freedom: gene.degrees_of_freedom, + p_value: gene.p_value, + within_cluster_fdr: gene.adjusted_p_value, + study_wide_fdr: 1.0, + converged: gene.converged, + random_variances: gene.random_variances.copy(), + residual_variance: gene.residual_variance, + }) + } + } catch { + VariancePartitionError(message) => + exclusions.push(DreamletExclusion::{ + cluster_id: assay.cluster_id, + reason: "variancePartition: " + message, + }) + } + } + if assay_results.length() == 0 { + dreamlet_fail( + "dreamlet coefficient '" + + coefficient_name + + "' could not be fitted in any assay", + ) + } + let p_values : Array[Double] = [] + for gene in flattened { + p_values.push(gene.p_value) + } + let adjusted = dreamlet_bh_adjust(p_values) + let genes : Array[DreamletGeneResult] = [] + for index in 0.. DreamletPseudobulkAssay? { + for assay in self.assays { + if assay.cluster_id == cluster_id { + return Some(assay) + } + } + None +} + +///| +pub fn DreamletProcessedData::assay( + self : DreamletProcessedData, + cluster_id : String, +) -> DreamletProcessedAssay? { + for assay in self.assays { + if assay.cluster_id == cluster_id { + return Some(assay) + } + } + None +} + +///| +pub fn DreamletResult::assay( + self : DreamletResult, + cluster_id : String, +) -> DreamResult? { + for assay in self.assays { + if assay.cluster_id == cluster_id { + return Some(assay.result) + } + } + None +} + +///| +pub fn DreamletResult::top_table( + self : DreamletResult, + maximum_fdr? : Double = 1.0, + cluster_id? : String = "", +) -> Array[DreamletGeneResult] raise DreamletError { + if !dreamlet_is_finite(maximum_fdr) || maximum_fdr < 0.0 || maximum_fdr > 1.0 { + dreamlet_fail("dreamlet maximum FDR must be between zero and one") + } + let selected : Array[DreamletGeneResult] = [] + for gene in self.genes { + if gene.study_wide_fdr <= maximum_fdr && + (cluster_id == "" || gene.cluster_id == cluster_id) { + selected.push(gene) + } + } + selected.sort_by(fn( + left : DreamletGeneResult, + right : DreamletGeneResult, + ) -> Int { + if left.p_value < right.p_value { + -1 + } else if left.p_value > right.p_value { + 1 + } else if left.cluster_id < right.cluster_id { + -1 + } else if left.cluster_id > right.cluster_id { + 1 + } else if left.gene_name < right.gene_name { + -1 + } else if left.gene_name > right.gene_name { + 1 + } else { + 0 + } + }) + selected +} + +///| +pub fn DreamletPseudobulk::summary(self : DreamletPseudobulk) -> String { + let mut combinations = 0 + for assay in self.assays { + for cells in assay.cell_counts { + if cells > 0 { + combinations = combinations + 1 + } + } + } + "dreamlet Pseudobulk Summary\n" + + "Genes: " + + self.gene_names.length().to_string() + + "\nSamples: " + + self.sample_names.length().to_string() + + "\nCell types: " + + self.assays.length().to_string() + + "\nObserved sample-cell type combinations: " + + combinations.to_string() + + "\n" +} + +///| +pub fn DreamletProcessedData::summary(self : DreamletProcessedData) -> String { + let mut genes = 0 + for assay in self.assays { + genes = genes + assay.gene_names.length() + } + "dreamlet Processed Data Summary\n" + + "Retained cell types: " + + self.assays.length().to_string() + + "\nExcluded cell types: " + + self.exclusions.length().to_string() + + "\nGene-cell type models: " + + genes.to_string() + + "\n" +} + +///| +pub fn DreamletResult::summary(self : DreamletResult) -> String { + let mut significant = 0 + let mut converged = 0 + for gene in self.genes { + if gene.study_wide_fdr <= 0.05 { + significant = significant + 1 + } + if gene.converged { + converged = converged + 1 + } + } + "dreamlet Differential Expression Summary\n" + + "Contrast: " + + self.contrast_name + + "\nCell types: " + + self.assays.length().to_string() + + "\nTests: " + + self.genes.length().to_string() + + "\nConverged: " + + converged.to_string() + + "\nStudy-wide FDR <= 0.05: " + + significant.to_string() + + "\n" +} diff --git a/src/variance_partition.mbt b/src/variance_partition.mbt index 31aee5af..2b10dd92 100644 --- a/src/variance_partition.mbt +++ b/src/variance_partition.mbt @@ -1607,7 +1607,7 @@ fn vp_bh_adjust(results : Array[DreamGeneResult]) -> Array[DreamGeneResult] { count.to_double() / rank.to_double()).min(1.0) running = running.min(candidate) - adjusted[original] = running + adjusted[original] = running.max(results[original].p_value) rank = rank - 1 } let output : Array[DreamGeneResult] = [] diff --git a/test/moonbit/dreamlet_test.mbt b/test/moonbit/dreamlet_test.mbt new file mode 100644 index 00000000..a4bd4a9a --- /dev/null +++ b/test/moonbit/dreamlet_test.mbt @@ -0,0 +1,932 @@ +///| +/// Tests for the Bioconductor dreamlet-inspired pseudobulk mixed-model +/// workflow. + +///| +fn dreamlet_test_close( + actual : Double, + expected : Double, + tolerance? : Double = 1.0e-8, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "dreamlet value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn dreamlet_test_data() -> ( + Array[Array[Double]], + Array[String], + Array[String], + Array[String], + Array[String], + Map[String, Array[String]], +) { + let genes = [ + "response_up", "stable", "cell_type", "rare", "donor", "response_down", + ] + let counts : Array[Array[Double]] = [] + for _ in genes { + counts.push([]) + } + let cells : Array[String] = [] + let samples : Array[String] = [] + let clusters : Array[String] = [] + let treatments : Array[String] = [] + let donors : Array[String] = [] + let ages : Array[String] = [] + for donor in 0..<4 { + for treatment in 0..<2 { + let sample = "D" + + (donor + 1).to_string() + + (if treatment == 0 { "_C" } else { "_T" }) + for cluster in 0..<2 { + let cluster_name = if cluster == 0 { "T_cell" } else { "Monocyte" } + for replicate in 0..<3 { + cells.push( + sample + "_" + cluster_name + "_" + (replicate + 1).to_string(), + ) + samples.push(sample) + clusters.push(cluster_name) + treatments.push(if treatment == 0 { "Control" } else { "Treated" }) + donors.push("D" + (donor + 1).to_string()) + ages.push((30 + donor * 5).to_string()) + counts[0].push( + (10 + treatment * 10 + donor + (if replicate == 2 { 1 } else { 0 })).to_double(), + ) + counts[1].push((8 + replicate % 2).to_double()) + counts[2].push( + (if cluster == 0 { 18 + treatment } else { 4 + treatment }).to_double(), + ) + counts[3].push( + if donor == 0 && treatment == 0 && cluster == 0 && replicate == 0 { + 1.0 + } else { + 0.0 + }, + ) + counts[4].push((6 + donor * 2 + replicate).to_double()) + counts[5].push( + (18 - treatment * 8 + cluster + (if replicate == 1 { 1 } else { 0 })).to_double(), + ) + } + } + } + } + let metadata : Map[String, Array[String]] = Map([ + ("Treatment", treatments), + ("Donor", donors), + ("Age", ages), + ]) + (counts, genes, cells, samples, clusters, metadata) +} + +///| +fn dreamlet_test_pseudobulk() -> @src.DreamletPseudobulk { + let (counts, genes, cells, samples, clusters, metadata) = dreamlet_test_data() + @src.dreamlet_aggregate_to_pseudobulk( + counts, + genes, + cells, + samples, + clusters, + cell_metadata=metadata, + ) catch { + _ => abort("valid dreamlet pseudobulk aggregation should succeed") + } +} + +///| +fn dreamlet_test_config() -> @src.DreamletProcessConfig { + @src.DreamletProcessConfig::create( + min_cells=2, + min_count=1.0, + min_samples=6, + min_prop=0.5, + min_total_count=10.0, + span=0.7, + max_iterations=30, + tolerance=0.02, + ) catch { + _ => abort("valid dreamlet test configuration should build") + } +} + +///| +fn dreamlet_test_fixed_model() -> @src.DreamletModelSpec { + @src.dreamlet_model([ + @src.dreamlet_categorical_effect("Treatment", reference="Control"), + ]) catch { + _ => abort("valid dreamlet fixed model should build") + } +} + +///| +fn dreamlet_test_mixed_model() -> @src.DreamletModelSpec { + @src.dreamlet_model([ + @src.dreamlet_categorical_effect("Treatment", reference="Control"), + @src.dreamlet_random_effect("Donor"), + ]) catch { + _ => abort("valid dreamlet mixed model should build") + } +} + +///| +fn dreamlet_test_processed(mixed? : Bool = false) -> @src.DreamletProcessedData { + let model = if mixed { + dreamlet_test_mixed_model() + } else { + dreamlet_test_fixed_model() + } + @src.dreamlet_process_assays( + dreamlet_test_pseudobulk(), + model, + config=dreamlet_test_config(), + ) catch { + _ => abort("valid dreamlet processing should succeed") + } +} + +///| +fn dreamlet_test_result() -> @src.DreamletResult { + @src.dreamlet( + dreamlet_test_processed(), + "Treatment:Treated", + contrast_name="Treated-Control", + max_iterations=30, + tolerance=0.02, + ) catch { + _ => abort("valid dreamlet differential expression should succeed") + } +} + +///| +test "dreamlet: effect factories preserve kinds and references" { + let numeric = @src.dreamlet_numeric_effect("Age") + let categorical = @src.dreamlet_categorical_effect( + "Treatment", + reference="Control", + ) + let random = @src.dreamlet_random_effect("Donor") + assert_true(numeric.kind is Numeric) + assert_true(categorical.kind is Categorical) + assert_true(random.kind is Random) + assert_eq(categorical.reference, "Control") +} + +///| +test "dreamlet: typed model preserves effect order" { + let model = dreamlet_test_mixed_model() + assert_eq(model.effects.length(), 2) + assert_eq(model.effects[0].name, "Treatment") + assert_eq(model.effects[1].name, "Donor") + assert_true(model.intercept) +} + +///| +test "dreamlet: model rejects duplicate effect names" { + let raised = try { + ignore( + @src.dreamlet_model([ + @src.dreamlet_numeric_effect("Age"), + @src.dreamlet_random_effect("Age"), + ]), + ) + false + } catch { + DreamletError(_) => true + } + assert_true(raised) +} + +///| +test "dreamlet: model rejects empty effect names" { + let raised = try { + ignore(@src.dreamlet_model([@src.dreamlet_numeric_effect("")])) + false + } catch { + DreamletError(_) => true + } + assert_true(raised) +} + +///| +test "dreamlet: model rejects a no-intercept design without fixed effects" { + let raised = try { + ignore( + @src.dreamlet_model( + [@src.dreamlet_random_effect("Donor")], + intercept=false, + ), + ) + false + } catch { + DreamletError(_) => true + } + assert_true(raised) +} + +///| +test "dreamlet: default process configuration matches upstream defaults" { + let config = @src.DreamletProcessConfig::default() + assert_eq(config.min_cells, 5) + assert_eq(config.min_count, 5.0) + assert_eq(config.min_samples, 4) + assert_eq(config.min_prop, 0.4) + assert_eq(config.prior_count, 0.5) + assert_eq(config.logratio_trim, 0.3) + assert_eq(config.sum_trim, 0.05) +} + +///| +test "dreamlet: custom process configuration preserves controls" { + let config = dreamlet_test_config() + assert_eq(config.min_cells, 2) + assert_eq(config.min_samples, 6) + assert_eq(config.span, 0.7) + assert_true(config.use_poisson_initial_weights) + assert_false(config.rescale_initial_weights) +} + +///| +test "dreamlet: process configuration rejects invalid sample filters" { + let cells = try { + ignore(@src.DreamletProcessConfig::create(min_cells=0)) + false + } catch { + DreamletError(_) => true + } + let samples = try { + ignore(@src.DreamletProcessConfig::create(min_samples=2)) + false + } catch { + DreamletError(_) => true + } + assert_true(cells) + assert_true(samples) +} + +///| +test "dreamlet: process configuration rejects invalid proportions" { + let low = try { + ignore(@src.DreamletProcessConfig::create(min_prop=0.0)) + false + } catch { + DreamletError(_) => true + } + let high = try { + ignore(@src.DreamletProcessConfig::create(min_prop=1.1)) + false + } catch { + DreamletError(_) => true + } + assert_true(low) + assert_true(high) +} + +///| +test "dreamlet: process configuration rejects invalid TMM trims" { + let ratio = try { + ignore(@src.DreamletProcessConfig::create(logratio_trim=0.5)) + false + } catch { + DreamletError(_) => true + } + let abundance = try { + ignore(@src.DreamletProcessConfig::create(sum_trim=-0.1)) + false + } catch { + DreamletError(_) => true + } + assert_true(ratio) + assert_true(abundance) +} + +///| +test "dreamlet: pseudobulk uses gene by sample orientation" { + let pseudobulk = dreamlet_test_pseudobulk() + assert_eq(pseudobulk.gene_names.length(), 6) + assert_eq(pseudobulk.sample_names.length(), 8) + assert_eq(pseudobulk.assays.length(), 2) + assert_eq(pseudobulk.assays[0].counts.length(), 6) + assert_eq(pseudobulk.assays[0].counts[0].length(), 8) +} + +///| +test "dreamlet: pseudobulk preserves first-observed cell type order" { + let pseudobulk = dreamlet_test_pseudobulk() + assert_eq(pseudobulk.assays[0].cluster_id, "T_cell") + assert_eq(pseudobulk.assays[1].cluster_id, "Monocyte") +} + +///| +test "dreamlet: pseudobulk preserves first-observed sample order" { + let pseudobulk = dreamlet_test_pseudobulk() + assert_eq(pseudobulk.sample_names[0], "D1_C") + assert_eq(pseudobulk.sample_names[1], "D1_T") + assert_eq(pseudobulk.sample_names[7], "D4_T") +} + +///| +test "dreamlet: pseudobulk sums raw counts within sample and cell type" { + let pseudobulk = dreamlet_test_pseudobulk() + let assay = match pseudobulk.assay("T_cell") { + Some(value) => value + None => abort("T_cell assay should exist") + } + dreamlet_test_close(assay.counts[0][0], 31.0) + dreamlet_test_close(assay.counts[0][1], 61.0) +} + +///| +test "dreamlet: pseudobulk records observed cell counts" { + let pseudobulk = dreamlet_test_pseudobulk() + for assay in pseudobulk.assays { + for count in assay.cell_counts { + assert_eq(count, 3) + } + } +} + +///| +test "dreamlet: pseudobulk library sizes equal column sums" { + let assay = dreamlet_test_pseudobulk().assays[0] + for sample in 0.. abort("sparse combinations should aggregate") + } + let b = match result.assay("B") { + Some(value) => value + None => abort("B assay should exist") + } + assert_eq(b.cell_counts, [0, 1]) + assert_eq(b.counts[0], [0.0, 5.0]) +} + +///| +test "dreamlet: pseudobulk summary reports dimensions" { + let summary = dreamlet_test_pseudobulk().summary() + assert_true(summary.contains("Genes: 6")) + assert_true(summary.contains("Samples: 8")) + assert_true(summary.contains("Cell types: 2")) +} + +///| +test "dreamlet: aggregation rejects negative counts" { + let raised = try { + ignore( + @src.dreamlet_aggregate_to_pseudobulk([[-1.0]], ["g"], ["c"], ["s"], ["A"]), + ) + false + } catch { + DreamletError(_) => true + } + assert_true(raised) +} + +///| +test "dreamlet: aggregation rejects non-integer raw counts" { + let raised = try { + ignore( + @src.dreamlet_aggregate_to_pseudobulk([[1.5]], ["g"], ["c"], ["s"], ["A"]), + ) + false + } catch { + DreamletError(_) => true + } + assert_true(raised) +} + +///| +test "dreamlet: aggregation rejects duplicate gene names" { + let raised = try { + ignore( + @src.dreamlet_aggregate_to_pseudobulk( + [[1.0], [2.0]], + ["g", "g"], + ["c"], + ["s"], + ["A"], + ), + ) + false + } catch { + DreamletError(_) => true + } + assert_true(raised) +} + +///| +test "dreamlet: aggregation rejects metadata varying within sample" { + let metadata : Map[String, Array[String]] = Map([ + ("Treatment", ["Control", "Treated"]), + ]) + let raised = try { + ignore( + @src.dreamlet_aggregate_to_pseudobulk( + [[1.0, 2.0]], + ["g"], + ["c1", "c2"], + ["s", "s"], + ["A", "A"], + cell_metadata=metadata, + ), + ) + false + } catch { + DreamletError(_) => true + } + assert_true(raised) +} + +///| +test "dreamlet: aggregation rejects metadata dimension mismatch" { + let metadata : Map[String, Array[String]] = Map([("Group", ["A"])]) + let raised = try { + ignore( + @src.dreamlet_aggregate_to_pseudobulk( + [[1.0, 2.0]], + ["g"], + ["c1", "c2"], + ["s1", "s2"], + ["A", "A"], + cell_metadata=metadata, + ), + ) + false + } catch { + DreamletError(_) => true + } + assert_true(raised) +} + +///| +test "dreamlet: TMM factors have geometric mean one" { + let counts = [ + [100.0, 200.0, 90.0], + [50.0, 100.0, 55.0], + [30.0, 60.0, 25.0], + [10.0, 20.0, 12.0], + ] + let result = @src.dreamlet_tmm(counts) catch { + _ => abort("valid TMM normalization should succeed") + } + let mut product = 1.0 + for factor in result.factors { + product = product * factor + } + dreamlet_test_close(product, 1.0, tolerance=1.0e-10) +} + +///| +test "dreamlet: TMM identical compositions produce unit factors" { + let result = @src.dreamlet_tmm([ + [10.0, 20.0, 30.0], + [5.0, 10.0, 15.0], + [2.0, 4.0, 6.0], + ]) catch { + _ => abort("proportional libraries should normalize") + } + for factor in result.factors { + dreamlet_test_close(factor, 1.0, tolerance=1.0e-10) + } +} + +///| +test "dreamlet: TMM reference index is valid" { + let result = @src.dreamlet_tmm([ + [10.0, 12.0, 9.0], + [3.0, 7.0, 5.0], + [8.0, 4.0, 6.0], + ]) catch { + _ => abort("valid TMM normalization should succeed") + } + assert_true(result.reference_sample >= 0) + assert_true(result.reference_sample < 3) +} + +///| +test "dreamlet: TMM is invariant to a common count multiplier" { + let first = @src.dreamlet_tmm([ + [10.0, 12.0, 9.0], + [3.0, 7.0, 5.0], + [8.0, 4.0, 6.0], + ]) catch { + _ => abort("first TMM normalization should succeed") + } + let second = @src.dreamlet_tmm([ + [20.0, 24.0, 18.0], + [6.0, 14.0, 10.0], + [16.0, 8.0, 12.0], + ]) catch { + _ => abort("second TMM normalization should succeed") + } + for sample in 0..<3 { + dreamlet_test_close( + first.factors[sample], + second.factors[sample], + tolerance=1.0e-10, + ) + } +} + +///| +test "dreamlet: TMM rejects zero-size libraries" { + let raised = try { + ignore(@src.dreamlet_tmm([[1.0, 0.0], [2.0, 0.0]])) + false + } catch { + DreamletError(_) => true + } + assert_true(raised) +} + +///| +test "dreamlet: normalized counts are counts per million" { + let normalized = @src.dreamlet_compute_norm_counts( + [[10.0, 20.0], [90.0, 180.0]], + [100.0, 200.0], + ) catch { + _ => abort("valid normalized counts should succeed") + } + assert_eq(normalized[0], [100000.0, 100000.0]) + assert_eq(normalized[1], [900000.0, 900000.0]) +} + +///| +test "dreamlet: log CPM uses prior counts for zeros" { + let transformed = @src.dreamlet_compute_log_cpm( + [[0.0, 0.0]], + [100.0, 200.0], + prior_count=0.5, + ) catch { + _ => abort("valid log CPM should succeed") + } + assert_true(transformed[0][0] == transformed[0][0]) + assert_true(transformed[0][1] == transformed[0][1]) + assert_true(transformed[0][0] > transformed[0][1]) +} + +///| +test "dreamlet: count transformations reject invalid library sizes" { + let normalized = try { + ignore(@src.dreamlet_compute_norm_counts([[1.0]], [0.0])) + false + } catch { + DreamletError(_) => true + } + let logged = try { + ignore(@src.dreamlet_compute_log_cpm([[1.0]], [-1.0])) + false + } catch { + DreamletError(_) => true + } + assert_true(normalized) + assert_true(logged) +} + +///| +test "dreamlet: processAssays retains both well-powered cell types" { + let processed = dreamlet_test_processed() + assert_eq(processed.assays.length(), 2) + assert_eq(processed.exclusions.length(), 0) +} + +///| +test "dreamlet: processAssays filters rare genes" { + let assay = dreamlet_test_processed().assays[0] + assert_false(assay.gene_names.contains("rare")) + assert_true(assay.dropped_gene_names.contains("rare")) + assert_eq(assay.gene_names.length(), 5) +} + +///| +test "dreamlet: processAssays builds treatment design" { + let assay = dreamlet_test_processed().assays[0] + assert_eq(assay.design.coefficient_names, ["(Intercept)", "Treatment:Treated"]) + assert_eq(assay.design.sample_names, assay.sample_names) +} + +///| +test "dreamlet: mixed processAssays reuses random-effect solver" { + let assay = dreamlet_test_processed(mixed=true).assays[0] + assert_eq(assay.design.random_effects.length(), 1) + assert_eq(assay.design.random_effects[0].name, "Donor") + assert_eq(assay.design.random_effects[0].levels.length(), 4) +} + +///| +test "dreamlet: processAssays stores TMM effective libraries" { + let assay = dreamlet_test_processed().assays[0] + assert_eq(assay.norm_factors.length(), 8) + assert_eq(assay.effective_library_sizes.length(), 8) + for sample in 0..<8 { + dreamlet_test_close( + assay.effective_library_sizes[sample], + assay.library_sizes[sample] * assay.norm_factors[sample], + ) + } +} + +///| +test "dreamlet: processAssays stores normalized expression dimensions" { + let assay = dreamlet_test_processed().assays[0] + assert_eq(assay.normalized_cpm.length(), assay.gene_names.length()) + assert_eq(assay.log_cpm.length(), assay.gene_names.length()) + assert_eq(assay.log_cpm[0].length(), assay.sample_names.length()) +} + +///| +test "dreamlet: Poisson initial weights are row-centered" { + let assay = dreamlet_test_processed().assays[0] + for row in assay.initial_weights { + let mut total = 0.0 + for weight in row { + assert_true(weight > 0.0) + total = total + weight + } + dreamlet_test_close(total / row.length().to_double(), 1.0) + } +} + +///| +test "dreamlet: voom precision weights are finite and positive" { + let assay = dreamlet_test_processed().assays[0] + assert_eq(assay.precision_weights.length(), assay.gene_names.length()) + for row in assay.precision_weights { + assert_eq(row.length(), assay.sample_names.length()) + for weight in row { + assert_true(weight > 0.0) + assert_true(weight <= 1.0e8) + assert_true(weight == weight) + } + } +} + +///| +test "dreamlet: voom trend coordinates are sorted" { + let assay = dreamlet_test_processed().assays[0] + assert_eq(assay.voom_x.length(), assay.gene_names.length()) + assert_eq(assay.voom_y.length(), assay.gene_names.length()) + assert_eq(assay.voom_fitted.length(), assay.gene_names.length()) + for index in 1.. abort("constant-effect model should build") + } + let pseudobulk = dreamlet_test_pseudobulk() + for assay in pseudobulk.assays { + assay.metadata["Constant"] = Array::make(8, "1") + } + let processed = @src.dreamlet_process_assays( + pseudobulk, + model, + config=dreamlet_test_config(), + ) catch { + _ => abort("constant effects should be dropped") + } + assert_true(processed.assays[0].dropped_effects[0].contains("Constant")) +} + +///| +test "dreamlet: processAssays reports missing model metadata" { + let model = @src.dreamlet_model([@src.dreamlet_numeric_effect("Missing")]) catch { + _ => abort("model itself should build") + } + let raised = try { + ignore( + @src.dreamlet_process_assays( + dreamlet_test_pseudobulk(), + model, + config=dreamlet_test_config(), + ), + ) + false + } catch { + DreamletError(message) => message.contains("retained no assays") + } + assert_true(raised) +} + +///| +test "dreamlet: processed summary reports model count" { + let summary = dreamlet_test_processed().summary() + assert_true(summary.contains("Retained cell types: 2")) + assert_true(summary.contains("Excluded cell types: 0")) + assert_true(summary.contains("Gene-cell type models: 10")) +} + +///| +test "dreamlet: differential expression fits every retained cell type" { + let result = dreamlet_test_result() + assert_eq(result.assays.length(), 2) + assert_eq(result.genes.length(), 10) + assert_eq(result.contrast_name, "Treated-Control") +} + +///| +test "dreamlet: response-up effect is positive in each cell type" { + let result = dreamlet_test_result() + let mut found = 0 + for gene in result.genes { + if gene.gene_name == "response_up" { + assert_true(gene.estimate > 0.5) + found = found + 1 + } + } + assert_eq(found, 2) +} + +///| +test "dreamlet: response-down effect is negative in each cell type" { + let result = dreamlet_test_result() + let mut found = 0 + for gene in result.genes { + if gene.gene_name == "response_down" { + assert_true(gene.estimate < -0.3) + found = found + 1 + } + } + assert_eq(found, 2) +} + +///| +test "dreamlet: result stores within-cluster and study-wide FDR" { + let result = dreamlet_test_result() + for gene in result.genes { + assert_true(gene.within_cluster_fdr >= gene.p_value) + assert_true(gene.study_wide_fdr >= gene.p_value) + assert_true(gene.study_wide_fdr <= 1.0) + } +} + +///| +test "dreamlet: top table sorts all cell types by p-value" { + let table = dreamlet_test_result().top_table() catch { + _ => abort("valid dreamlet top table should succeed") + } + assert_eq(table.length(), 10) + for index in 1.. abort("cell-type dreamlet top table should succeed") + } + assert_eq(table.length(), 5) + for gene in table { + assert_eq(gene.cluster_id, "Monocyte") + } +} + +///| +test "dreamlet: result assay lookup exposes underlying dream result" { + let result = dreamlet_test_result() + match result.assay("T_cell") { + Some(value) => { + assert_eq(value.contrast_name, "Treated-Control") + assert_eq(value.genes.length(), 5) + } + None => abort("T_cell dream result should exist") + } + assert_true(result.assay("missing") is None) +} + +///| +test "dreamlet: result summary reports study-wide analysis" { + let summary = dreamlet_test_result().summary() + assert_true(summary.contains("dreamlet Differential Expression Summary")) + assert_true(summary.contains("Contrast: Treated-Control")) + assert_true(summary.contains("Cell types: 2")) + assert_true(summary.contains("Tests: 10")) +} + +///| +test "dreamlet: differential expression rejects absent coefficient" { + let raised = try { + ignore( + @src.dreamlet( + dreamlet_test_processed(), + "Missing", + max_iterations=10, + tolerance=0.05, + ), + ) + false + } catch { + DreamletError(_) => true + } + assert_true(raised) +} + +///| +test "dreamlet: top table validates FDR threshold" { + let raised = try { + ignore(dreamlet_test_result().top_table(maximum_fdr=1.1)) + false + } catch { + DreamletError(_) => true + } + assert_true(raised) +} + +///| +test "dreamlet: SCE integration preserves selected metadata" { + let (counts, genes, cells, samples, clusters, metadata) = dreamlet_test_data() + let sce = @src.SingleCellExperiment::new(counts, genes, cells) + sce.col_data["sample_id"] = samples + sce.col_data["cluster_id"] = clusters + sce.col_data["Treatment"] = metadata["Treatment"] + sce.col_data["Donor"] = metadata["Donor"] + let pseudobulk = @src.dreamlet_aggregate_sce(sce, "sample_id", "cluster_id", metadata_fields=[ + "Treatment", "Donor", + ]) catch { + _ => abort("valid SCE dreamlet aggregation should succeed") + } + assert_eq(pseudobulk.assays.length(), 2) + assert_eq(pseudobulk.assays[0].metadata["Treatment"][1], "Treated") +} + +///| +test "dreamlet: SCE integration rejects absent assay" { + let sce = @src.SingleCellExperiment::new([[1.0]], ["g"], ["c"]) + sce.col_data["sample"] = ["s"] + sce.col_data["cluster"] = ["A"] + let raised = try { + ignore( + @src.dreamlet_aggregate_sce(sce, "sample", "cluster", assay="missing"), + ) + false + } catch { + DreamletError(_) => true + } + assert_true(raised) +} + +///| +test "dreamlet: SCE integration rejects absent metadata field" { + let sce = @src.SingleCellExperiment::new([[1.0]], ["g"], ["c"]) + sce.col_data["sample"] = ["s"] + sce.col_data["cluster"] = ["A"] + let raised = try { + ignore( + @src.dreamlet_aggregate_sce(sce, "sample", "cluster", metadata_fields=[ + "Missing", + ]), + ) + false + } catch { + DreamletError(_) => true + } + assert_true(raised) +} From e8f330f5cabd306f69061532df0320d52c3c5459 Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 09:30:54 +0800 Subject: [PATCH 22/41] #28 feat(bigpsl): Biopython Bio.Align.bigpsl --- README.md | 24 +- examples/bigpsl_demo/main.mbt | 71 ++ examples/bigpsl_demo/moon.pkg | 5 + src/bigpsl.mbt | 1672 +++++++++++++++++++++++++++++++++ test/moonbit/bigpsl_test.mbt | 1230 ++++++++++++++++++++++++ 5 files changed, 2998 insertions(+), 4 deletions(-) create mode 100644 examples/bigpsl_demo/main.mbt create mode 100644 examples/bigpsl_demo/moon.pkg create mode 100644 src/bigpsl.mbt create mode 100644 test/moonbit/bigpsl_test.mbt diff --git a/README.md b/README.md index aac82c47..3fa20fe8 100644 --- a/README.md +++ b/README.md @@ -222,6 +222,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **Alignment坐标组合** | Biopython `Bio.Align.Alignment.map/mapall` | alignment path组合、局部overhang clipping、exon/intron与indel gap、正反链组合、坐标双向查询、PSL及1:1/1:3 MSA投影 | ✅ | | **BigBed二进制区间索引** | Biopython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12与AutoSQL、多级B+ tree/R-tree、stored/fixed/dynamic DEFLATE、区间/名称查询、链感知exon坐标及BED导出 | ✅ | | **BigMaf多物种比对索引** | Biopython `Bio.Align.bigmaf` | 标准bedMaf AutoSQL、MAF a/s/i/e/q块、score/pass/comment、正负链坐标映射、压缩BigBed索引查询及普通MAF导出 | ✅ | +| **BigPsl成对比对索引** | Biopython `Bio.Align.bigpsl` | 标准bed12+13 AutoSQL、核酸与translated protein坐标路径、正反链、match/repeat/N recount、压缩索引查询及PSL导出 | ✅ | | **zinbwave** | Bioconductor zinbwave | 零膨胀负二项低维模型、cell/gene协变量与offset、确定性latent factors、dispersion shrinkage、observational weights、残差/归一化/插补及SCE集成 | ✅ | | **apeglm** | Bioconductor apeglm | 负二项GLM、自适应经验贝叶斯Cauchy/Student-t先验、确定性多起点MAP、Laplace后验SD/区间、FSR/FSOS/s-value、DESeq2与SummarizedExperiment接入 | ✅ | | **Prosite** | Biopython `Bio.Prosite` | 蛋白质模体数据库搜索、Prosite模式解析、模体匹配算法、模体得分计算 | ✅ | @@ -425,6 +426,7 @@ IvanAXu/BioSeqs/ │ ├── alignment_map.mbt # Bio.Align.Alignment map/mapall坐标路径组合与MSA投影 │ ├── bigbed.mbt # Bio.Align.bigbed v4、BED/AutoSQL、多级B+ tree/R-tree与DEFLATE │ ├── bigmaf.mbt # Bio.Align.bigmaf bedMaf、MAF注释、链向坐标映射与索引查询 +│ ├── bigpsl.mbt # Bio.Align.bigpsl bed12+13、核酸/translated protein路径与PSL │ ├── alignio.mbt # 比对文件 I/O │ ├── clustal_io.mbt # Clustal 格式 │ ├── phylip_io.mbt # PHYLIP 格式 @@ -1117,6 +1119,7 @@ IvanAXu/BioSeqs/ │ ├── alignment_map_demo/ # Alignment.map/mapall、反链、PSL与protein-to-codon MSA投影示例 │ ├── bigbed_demo/ # BigBed写入/解析、索引查询、负链exon坐标、BED导出与损坏诊断 │ ├── bigmaf_demo/ # BigMaf压缩写入、bedMaf schema、区间查询、负链映射与MAF导出 +│ ├── bigpsl_demo/ # BigPsl压缩写入、R-tree查询、反链/translated坐标与PSL导出 │ ├── gene_pop_demo/ # GenePop群体遗传学示例 (基因型解析、等位基因频率、杂合度统计、序列化往返) │ ├── stage_r_demo/ # stageR两阶段检验示例 (筛选+确认、Simes聚合、BH-FDR、Holm步降、OFDR控制) │ ├── enriched_heatmap_demo/ # EnrichedHeatmap富集热图示例 (信号归一化、四种均值模式、行平滑、链方向处理) @@ -1323,6 +1326,7 @@ IvanAXu/BioSeqs/ │ │ ├── alignment_map_test.mbt │ │ ├── bigbed_test.mbt │ │ ├── bigmaf_test.mbt +│ │ ├── bigpsl_test.mbt │ │ ├── search_io_test.mbt │ │ ├── searchio_new_test.mbt │ │ ├── seq_complexity_test.mbt @@ -1499,7 +1503,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 9042 个测试全部通过 +moon test # ✅ 9116 个测试全部通过 ``` ### 模块对照表 @@ -1548,6 +1552,7 @@ moon test # ✅ 9042 个测试全 | `alignment_map.mbt` | BioPython `Bio.Align.Alignment.map/mapall` | alignment path组合、local clipping、gap与链向传播、双向坐标查询、PSL、map_many及codon-aware MSA投影 | | `bigbed.mbt` | BioPython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12、AutoSQL、多级chromosome B+ tree/R-tree、zlib/DEFLATE及索引查询 | | `bigmaf.mbt` | BioPython `Bio.Align.bigmaf` | bedMaf bed3+1读写、MAF a/s/i/e/q、正负链坐标映射、压缩索引查询、摘要和MAF导出 | +| `bigpsl.mbt` | BioPython `Bio.Align.bigpsl` | bed12+13读写、核酸/translated protein路径、双向坐标映射、recount、压缩查询、摘要和PSL导出 | #### 系统发育树 @@ -1819,6 +1824,7 @@ moon test # ✅ 9042 个测试全 | `alignment_map.mbt` | `Bio.Align.Alignment.map/mapall` | 两层alignment坐标组合、正反链与gap传播、PSL、批量映射及protein/nucleotide MSA投影 | | `bigbed.mbt` | `Bio.Align.bigbed` | BigBed v4二进制读写、BED/AutoSQL、平衡B+ tree/R-tree、完整DEFLATE块解码、区间/名称查询与BED导出 | | `bigmaf.mbt` | `Bio.Align.bigmaf` | bedMaf AutoSQL与MAF块往返、a/s/i/e/q注释、链感知坐标映射、BigBed索引查询和普通MAF导出 | +| `bigpsl.mbt` | `Bio.Align.bigpsl` | 标准bigPsl AutoSQL、核酸与translated DNA-protein坐标、链感知映射、match分类、BigBed索引和PSL导出 | | `infercnv.mbt` | `infercnv` | 单细胞拷贝数变异推断（基因组位置排序、参考细胞有界 LFC 计算、金字塔权重平滑、CNV 分数与恶性细胞预测） | | `scenic.mbt` | `SCENIC` | 单细胞调控网络推断与聚类（TF-target 共表达模块、Regulon 构建、AUCell 活性评分、二值化阈值、细胞状态与主控调控因子） | | `cibersort.mbt` | `CIBERSORT` | 免疫细胞去卷积（NNLS 求解、LM22 风格特征矩阵、Pearson 拟合优度、分数归一化） | @@ -2953,6 +2959,14 @@ MAP 求解器实现阻尼 Newton、Cholesky 信息矩阵求解、逐级 ridge `DreamletEffectSpec` 和 `DreamletModelSpec` 以 typed numeric、categorical、random effects 代替 R formula 解析，并转换到现有 `variancePartition` 设计与求解器；常量固定效应和无重复 level 的随机效应会按 cell type 删除并记录。`dreamlet_process_assays` 输出每个 cell type 的过滤、TMM、表达、权重、design 和趋势诊断，`dreamlet` 对指定 coefficient 运行 weighted fixed/random mixed model，报告数值 Satterthwaite 检验、cluster 内 BH-FDR 和跨全部 gene×cell-type hypotheses 的 study-wide BH-FDR。查询 API 提供 assay lookup、top table 和分阶段摘要。当前范围支持 dense arrays 和随机截距，不解析 R formula，不包含随机斜率、Kenward-Roger、limma empirical Bayes、稀疏/并行后端、绘图或上游 `aggr_means` 的变化 numeric cell metadata 聚合。 +### 257. BigPsl 成对比对索引 (Biopython Bio.Align.bigpsl) + +实现 Biopython 1.86 `Bio.Align.bigpsl` 对应的 UCSC BigPsl 格式。`bigpsl_write` 将 `BigPslAlignment` 编码为标准 BigBed v4 `bed12+13` 文件，完整写入 25 字段 `bigPsl` AutoSQL、chromosome B+ tree、R-tree 和可选 DEFLATE 数据块；`bigpsl_parse` 复用 BigBed 二进制校验并额外交叉验证 target/query 区间、block count、`oChromStarts`、`chromSize`、match 分类和 `seqType`。writer 支持选择性保存 query sequence 与 NCBI CDS 字段，默认保持文件紧凑。 + +坐标模型使用 0-based half-open path。核酸 block 要求 target 递增且 target/query 长度 1:1，支持 query 正反链；translated DNA-to-protein block 要求 query 递增且 target/query 长度 3:1，支持 target 正反链。API 提供 block/gap 统计、target/query 双向映射、amino acid 到 codon interval 映射、区间和 query-name 查询、摘要及标准 PSL 导出，其中反向 translated alignment 使用 PSL `+-` strand。`recount` 可按实际序列重新计算 match、mismatch、repeat-match 和 wildcard/N，核酸支持 lower/upper repeat mask，translated alignment 使用标准遗传密码并在反向 target 上先做 reverse complement。 + +构造器和解析器诊断名称、坐标边界/方向、非 1:1 或 3:1 block、无 aligned block、非法 score/thick interval、序列长度、match 总数、schema 及 strand 组合。当前范围不生成 zoom levels 或额外 string index，不实现远程 HTTP range reader；二进制容器能力与 BigBed 保持一致。 + ## 性能优化 ### 优化策略 @@ -3054,8 +3068,8 @@ MAP 求解器实现阻尼 Newton、Cholesky 信息矩阵求解、逐级 ridge | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 9042 | -| 通过数 | 9042 | +| 总测试数 | 9116 | +| 通过数 | 9116 | | 失败数 | 0 | | 通过率 | 100% | @@ -3460,7 +3474,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 364 个示例程序，展示各模块的典型用法： +项目提供 365 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3654,6 +3668,7 @@ moon run cmd/bench/main.mbt | alignment_map_demo | chromosome→transcript→read坐标组合、intron gap、反链、坐标查询、PSL与protein-to-codon MSA投影 | `moon run examples/alignment_map_demo` | | bigbed_demo | BigBed v4压缩写入/解析、AutoSQL、多级索引查询、负链exon坐标、BED导出及损坏文件诊断 | `moon run examples/bigbed_demo` | | bigmaf_demo | BigMaf压缩bed3+1写入、bedMaf schema、R-tree区间查询、负链物种坐标映射和MAF a/s/i/e/q导出 | `moon run examples/bigmaf_demo` | +| bigpsl_demo | BigPsl bed12+13压缩写入、AutoSQL、R-tree查询、反向核酸/translated protein坐标和PSL导出 | `moon run examples/bigpsl_demo` | | gene_pop_demo | GenePop群体遗传学（基因型解析、等位基因频率、杂合度统计、序列化往返） | `moon run examples/gene_pop_demo/main.mbt` | | stage_r_demo | stageR两阶段假设检验（筛选+确认、Simes聚合、BH-FDR、Holm步降、OFDR控制） | `moon run examples/stage_r_demo/main.mbt` | | enriched_heatmap_demo | EnrichedHeatmap富集热图（信号归一化、四种均值模式、行平滑、链方向处理） | `moon run examples/enriched_heatmap_demo/main.mbt` | @@ -3763,6 +3778,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bio.Align.Alignment map/mapall（alignment path组合、local clipping、gap与正反链传播、坐标查询、PSL及protein-to-codon MSA投影） - ✅ 实现 Bio.Align.bigbed BigBed v4二进制区间格式（BED3-BED12、AutoSQL、多级B+ tree/R-tree、DEFLATE、区间/名称查询与BED导出） - ✅ 实现 Bio.Align.bigmaf BigMaf多物种比对索引（标准bedMaf、MAF a/s/i/e/q、正负链坐标映射、压缩BigBed查询与MAF导出） +- ✅ 实现 Bio.Align.bigpsl BigPsl成对比对索引（标准bed12+13、核酸/translated protein坐标、match recount、压缩BigBed查询与PSL导出） - ✅ 实现 Bioconductor decontX ambient RNA去污染（cluster-native/contaminant混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解与SCE集成） - ✅ 实现 Bioconductor zinbwave 零膨胀负二项低维模型（cell/gene协变量、offset、latent factors、dispersion shrinkage、observational weights、残差/插补与SCE集成） - ✅ 实现 Bioconductor apeglm 自适应重尾效应量收缩（NB-GLM MLE、经验贝叶斯Cauchy/Student-t先验、多起点MAP、Laplace后验、FSR/FSOS/s-value与容器接入） diff --git a/examples/bigpsl_demo/main.mbt b/examples/bigpsl_demo/main.mbt new file mode 100644 index 00000000..87590755 --- /dev/null +++ b/examples/bigpsl_demo/main.mbt @@ -0,0 +1,71 @@ +///| +fn main { + println("=== Biopython Bio.Align.bigpsl Demo ===") + let (targets, alignments) = @src.bigpsl_example_data() catch { + BigPslError(message) => abort("failed to create BigPsl data: " + message) + } + let config = @src.BigPslWriteConfig::create( + compress=true, + block_size=3, + items_per_slot=1, + ) catch { + BigPslError(message) => abort("failed to configure BigPsl: " + message) + } + + println("\n1. Write and parse a compressed bed12+13 BigPsl stream") + let bytes = @src.bigpsl_write(targets, alignments, config~) catch { + BigPslError(message) => abort("failed to write BigPsl: " + message) + } + let file = @src.bigpsl_parse(bytes) catch { + BigPslError(message) => abort("failed to parse BigPsl: " + message) + } + let summary = file.summary() catch { + BigPslError(message) => abort("failed to summarize BigPsl: " + message) + } + println( + " bytes=\{bytes.length()}, alignments=\{summary.alignment_count}, targets=\{summary.target_count}, nucleotide=\{summary.nucleotide_count}, protein=\{summary.protein_count}, compressed=\{summary.compressed}", + ) + + println("\n2. Inspect the standard bigPsl AutoSQL schema") + println(@src.bigpsl_schema().to_auto_sql()) + + println("3. Query chr1 through the BigBed R-tree") + let hits = file.search("chr1", start=105, end=106) catch { + BigPslError(message) => abort("failed to query BigPsl: " + message) + } + println(" hits=" + hits.length().to_string()) + for alignment in hits { + println(" " + alignment.summary()) + println( + " target chr1:105 -> query " + + alignment.target_to_query(105).to_string(), + ) + } + + println("\n4. Recover reverse-query nucleotide coordinates") + let reverse = file.find_by_query("rna-reverse") catch { + BigPslError(message) => abort("failed to find reverse query: " + message) + } + println(" " + reverse[0].summary()) + println( + " target chr1:200 -> query " + reverse[0].target_to_query(200).to_string(), + ) + + println("\n5. Map amino acids to reverse-target codon intervals") + let protein = file.find_by_query("protein-reverse") catch { + BigPslError(message) => abort("failed to find protein query: " + message) + } + println(" " + protein[0].summary()) + println( + " amino acid 0 -> target codon " + + protein[0].query_to_target_interval(0).to_string(), + ) + + println("\n6. Export standard PSL text") + println( + file.to_psl() catch { + BigPslError(message) => abort("failed to export PSL: " + message) + }, + ) + println("=== Demo Complete ===") +} diff --git a/examples/bigpsl_demo/moon.pkg b/examples/bigpsl_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/bigpsl_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/bigpsl.mbt b/src/bigpsl.mbt new file mode 100644 index 00000000..8c31b1bd --- /dev/null +++ b/src/bigpsl.mbt @@ -0,0 +1,1672 @@ +// Bio.Align.bigpsl - indexed UCSC BigPsl pairwise alignments. +// +// BigPsl is a bed12+13 BigBed specialization. The BigBed container owns the +// binary layout and indices; this module owns pairwise-coordinate semantics, +// translated DNA-to-protein blocks, match categories, and strict schema +// validation. + +///| +pub suberror BigPslError { + BigPslError(String) +} + +///| +pub(all) enum BigPslSequenceType { + BigPslUnknown + BigPslNucleotide + BigPslProtein +} derive(Eq, Debug) + +///| +pub(all) enum BigPslMaskMode { + BigPslNoMask + BigPslMaskLower + BigPslMaskUpper +} derive(Eq, Debug) + +///| +pub struct BigPslBlock { + target_start : Int + target_end : Int + query_start : Int + query_end : Int + target_size : Int + query_size : Int +} derive(Eq, Debug) + +///| +pub struct BigPslAlignment { + target_name : String + target_size : Int + query_name : String + query_size : Int + target_coordinates : Array[Int] + query_coordinates : Array[Int] + query_sequence : String + cds : String + score : Int + thick_start : Int + thick_end : Int + item_rgb : String + matches : Int + mismatches : Int + repeat_matches : Int + n_count : Int + sequence_type : BigPslSequenceType +} derive(Eq, Debug) + +///| +pub struct BigPslWriteConfig { + compress : Bool + block_size : Int + items_per_slot : Int + store_query_sequence : Bool + store_cds : Bool +} derive(Eq, Debug) + +///| +pub struct BigPslAlignmentCounts { + aligned_query_units : Int + query_insert_units : Int + target_insert_bases : Int + query_insert_events : Int + target_insert_events : Int + block_count : Int +} derive(Eq, Debug) + +///| +pub struct BigPslSummary { + alignment_count : Int + target_count : Int + nucleotide_count : Int + protein_count : Int + unknown_count : Int + aligned_query_units : Int + covered_target_bases : Int + compressed : Bool +} derive(Eq, Debug) + +///| +pub struct BigPslFile { + bed : BigBedFile +} + +///| +priv struct BigPslStorage { + chrom_start : Int + chrom_end : Int + strand : String + other_start : Int + other_end : Int + other_strand : String + target_block_sizes : Array[Int] + target_block_starts : Array[Int] + other_block_starts : Array[Int] +} + +///| +fn bigpsl_fail(message : String) -> Unit raise BigPslError { + raise BigPslError(message) +} + +///| +fn bigpsl_abs(value : Int) -> Int { + if value < 0 { + -value + } else { + value + } +} + +///| +fn bigpsl_min(left : Int, right : Int) -> Int { + if left < right { + left + } else { + right + } +} + +///| +fn bigpsl_max(left : Int, right : Int) -> Int { + if left > right { + left + } else { + right + } +} + +///| +fn bigpsl_copy_ints(values : Array[Int]) -> Array[Int] { + let copy : Array[Int] = [] + for value in values { + copy.push(value) + } + copy +} + +///| +fn bigpsl_reverse_ints(values : Array[Int]) -> Array[Int] { + let reversed : Array[Int] = [] + let mut index = values.length() + while index > 0 { + index = index - 1 + reversed.push(values[index]) + } + reversed +} + +///| +fn bigpsl_validate_text( + value : String, + label : String, + allow_empty : Bool, +) -> Unit raise BigPslError { + if !allow_empty && value.length() == 0 { + bigpsl_fail(label + " must not be empty") + } + for index in 0.. Unit raise BigPslError { + if sequence.length() == 0 { + return + } + if sequence.length() != expected_size { + bigpsl_fail(label + " length does not match its declaration") + } + for index in 0.. Int { + match sequence_type { + BigPslUnknown => 0 + BigPslNucleotide => 1 + BigPslProtein => 2 + } +} + +///| +fn bigpsl_type_from_code(code : Int) -> BigPslSequenceType raise BigPslError { + match code { + 0 => BigPslUnknown + 1 => BigPslNucleotide + 2 => BigPslProtein + _ => { + bigpsl_fail("BigPsl seqType must be 0, 1, or 2") + BigPslUnknown + } + } +} + +///| +fn bigpsl_axis_direction( + coordinates : Array[Int], + label : String, +) -> Int raise BigPslError { + let mut direction = 0 + for index in 0..<(coordinates.length() - 1) { + let step = coordinates[index + 1] - coordinates[index] + if step > 0 { + if direction < 0 { + bigpsl_fail(label + " coordinates change direction") + } + direction = 1 + } else if step < 0 { + if direction > 0 { + bigpsl_fail(label + " coordinates change direction") + } + direction = -1 + } + } + direction +} + +///| +fn bigpsl_validate_coordinates( + target_size : Int, + query_size : Int, + target_coordinates : Array[Int], + query_coordinates : Array[Int], + sequence_type : BigPslSequenceType, +) -> Unit raise BigPslError { + if target_size <= 0 || query_size <= 0 { + bigpsl_fail("BigPsl target and query sizes must be positive") + } + if target_coordinates.length() != query_coordinates.length() { + bigpsl_fail( + "BigPsl target and query coordinate arrays must have equal length", + ) + } + if target_coordinates.length() < 2 { + bigpsl_fail("BigPsl alignment paths require at least two coordinate points") + } + for index in 0.. target_size { + bigpsl_fail("BigPsl target coordinate is out of bounds") + } + if query_coordinates[index] < 0 || query_coordinates[index] > query_size { + bigpsl_fail("BigPsl query coordinate is out of bounds") + } + } + let target_direction = bigpsl_axis_direction( + target_coordinates, "BigPsl target", + ) + let query_direction = bigpsl_axis_direction(query_coordinates, "BigPsl query") + let mut aligned_blocks = 0 + for index in 0..<(target_coordinates.length() - 1) { + let target_step = target_coordinates[index + 1] - target_coordinates[index] + let query_step = query_coordinates[index + 1] - query_coordinates[index] + if target_step == 0 && query_step == 0 { + bigpsl_fail("Consecutive BigPsl coordinate points must differ") + } + if target_step != 0 && query_step != 0 { + let target_count = bigpsl_abs(target_step) + let query_count = bigpsl_abs(query_step) + match sequence_type { + BigPslProtein => + if target_count != 3 * query_count { + bigpsl_fail( + "Protein BigPsl aligned target blocks must be three times their query blocks", + ) + } + _ => + if target_count != query_count { + bigpsl_fail( + "Nucleotide BigPsl aligned target and query blocks must have equal size", + ) + } + } + aligned_blocks = aligned_blocks + 1 + } + } + if aligned_blocks == 0 { + bigpsl_fail("BigPsl alignment must contain at least one aligned block") + } + match sequence_type { + BigPslProtein => { + if query_direction != 1 { + bigpsl_fail("Protein BigPsl query coordinates must increase") + } + if target_direction == 0 { + bigpsl_fail("Protein BigPsl target coordinates must have a direction") + } + } + _ => { + if target_direction != 1 { + bigpsl_fail("Nucleotide BigPsl target coordinates must increase") + } + if query_direction == 0 { + bigpsl_fail("Nucleotide BigPsl query coordinates must have a direction") + } + } + } +} + +///| +fn bigpsl_raw_blocks( + target_coordinates : Array[Int], + query_coordinates : Array[Int], +) -> Array[BigPslBlock] { + let blocks : Array[BigPslBlock] = [] + for index in 0..<(target_coordinates.length() - 1) { + let target_start = target_coordinates[index] + let target_end = target_coordinates[index + 1] + let query_start = query_coordinates[index] + let query_end = query_coordinates[index + 1] + let target_count = bigpsl_abs(target_end - target_start) + let query_count = bigpsl_abs(query_end - query_start) + if target_count > 0 && query_count > 0 { + blocks.push(BigPslBlock::{ + target_start, + target_end, + query_start, + query_end, + target_size: target_count, + query_size: query_count, + }) + } + } + blocks +} + +///| +fn bigpsl_aligned_query_units( + target_coordinates : Array[Int], + query_coordinates : Array[Int], +) -> Int { + let mut total = 0 + for block in bigpsl_raw_blocks(target_coordinates, query_coordinates) { + total = total + block.query_size + } + total +} + +///| +fn bigpsl_coordinate_interval(coordinates : Array[Int]) -> (Int, Int) { + let mut start = coordinates[0] + let mut end = coordinates[0] + for coordinate in coordinates { + start = bigpsl_min(start, coordinate) + end = bigpsl_max(end, coordinate) + } + (start, end) +} + +///| +pub fn BigPslAlignment::create( + target_name : String, + target_size : Int, + query_name : String, + query_size : Int, + target_coordinates : Array[Int], + query_coordinates : Array[Int], + sequence_type? : BigPslSequenceType = BigPslUnknown, + query_sequence? : String = "", + cds? : String = "", + score? : Int = 0, + thick_start? : Int = -1, + thick_end? : Int = -1, + item_rgb? : String = "0", + matches? : Int = -1, + mismatches? : Int = -1, + repeat_matches? : Int = -1, + n_count? : Int = -1, +) -> BigPslAlignment raise BigPslError { + bigpsl_validate_text(target_name, "BigPsl target name", false) + bigpsl_validate_text(query_name, "BigPsl query name", false) + bigpsl_validate_text(item_rgb, "BigPsl itemRgb", false) + bigpsl_validate_text(cds, "BigPsl CDS", true) + bigpsl_validate_sequence(query_sequence, query_size, "BigPsl query sequence") + bigpsl_validate_coordinates( + target_size, query_size, target_coordinates, query_coordinates, sequence_type, + ) + if score < 0 || score > 1000 { + bigpsl_fail("BigPsl score must be between 0 and 1000") + } + let (target_minimum, target_maximum) = bigpsl_coordinate_interval( + target_coordinates, + ) + let normalized_thick_start = if thick_start < 0 { + target_minimum + } else { + thick_start + } + let normalized_thick_end = if thick_end < 0 { + target_maximum + } else { + thick_end + } + if normalized_thick_start < target_minimum || + normalized_thick_start > normalized_thick_end || + normalized_thick_end > target_maximum { + bigpsl_fail("BigPsl thick interval must lie inside its target interval") + } + let aligned = bigpsl_aligned_query_units( + target_coordinates, query_coordinates, + ) + let all_unspecified = matches < 0 && + mismatches < 0 && + repeat_matches < 0 && + n_count < 0 + let normalized_matches = if all_unspecified { aligned } else { matches } + let normalized_mismatches = if all_unspecified { 0 } else { mismatches } + let normalized_repeat = if all_unspecified { 0 } else { repeat_matches } + let normalized_n = if all_unspecified { 0 } else { n_count } + if normalized_matches < 0 || + normalized_mismatches < 0 || + normalized_repeat < 0 || + normalized_n < 0 { + bigpsl_fail( + "BigPsl match categories must all be supplied or all be omitted", + ) + } + if normalized_matches + + normalized_mismatches + + normalized_repeat + + normalized_n != + aligned { + bigpsl_fail("BigPsl match categories must sum to the aligned query length") + } + BigPslAlignment::{ + target_name, + target_size, + query_name, + query_size, + target_coordinates: bigpsl_copy_ints(target_coordinates), + query_coordinates: bigpsl_copy_ints(query_coordinates), + query_sequence, + cds, + score, + thick_start: normalized_thick_start, + thick_end: normalized_thick_end, + item_rgb, + matches: normalized_matches, + mismatches: normalized_mismatches, + repeat_matches: normalized_repeat, + n_count: normalized_n, + sequence_type, + } +} + +///| +pub fn BigPslWriteConfig::create( + compress? : Bool = true, + block_size? : Int = 256, + items_per_slot? : Int = 512, + store_query_sequence? : Bool = false, + store_cds? : Bool = false, +) -> BigPslWriteConfig raise BigPslError { + if block_size < 2 || block_size > 65535 { + bigpsl_fail("BigPsl blockSize must be between 2 and 65535") + } + if items_per_slot <= 0 || items_per_slot > 65535 { + bigpsl_fail("BigPsl itemsPerSlot must be between 1 and 65535") + } + BigPslWriteConfig::{ + compress, + block_size, + items_per_slot, + store_query_sequence, + store_cds, + } +} + +///| +pub fn BigPslWriteConfig::default() -> BigPslWriteConfig { + BigPslWriteConfig::{ + compress: true, + block_size: 256, + items_per_slot: 512, + store_query_sequence: false, + store_cds: false, + } +} + +///| +pub fn BigPslAlignment::blocks(self : BigPslAlignment) -> Array[BigPslBlock] { + bigpsl_raw_blocks(self.target_coordinates, self.query_coordinates) +} + +///| +pub fn BigPslAlignment::target_interval(self : BigPslAlignment) -> (Int, Int) { + bigpsl_coordinate_interval(self.target_coordinates) +} + +///| +pub fn BigPslAlignment::query_interval(self : BigPslAlignment) -> (Int, Int) { + bigpsl_coordinate_interval(self.query_coordinates) +} + +///| +pub fn BigPslAlignment::is_reverse(self : BigPslAlignment) -> Bool { + let last = self.target_coordinates.length() - 1 + self.target_coordinates[0] > self.target_coordinates[last] || + self.query_coordinates[0] > self.query_coordinates[last] +} + +///| +pub fn BigPslAlignment::counts(self : BigPslAlignment) -> BigPslAlignmentCounts { + let mut aligned_query_units = 0 + let mut query_insert_units = 0 + let mut target_insert_bases = 0 + let mut query_insert_events = 0 + let mut target_insert_events = 0 + let mut block_count = 0 + for index in 0..<(self.target_coordinates.length() - 1) { + let target_step = bigpsl_abs( + self.target_coordinates[index + 1] - self.target_coordinates[index], + ) + let query_step = bigpsl_abs( + self.query_coordinates[index + 1] - self.query_coordinates[index], + ) + if target_step > 0 && query_step > 0 { + aligned_query_units = aligned_query_units + query_step + block_count = block_count + 1 + } else if target_step == 0 { + query_insert_units = query_insert_units + query_step + query_insert_events = query_insert_events + 1 + } else { + target_insert_bases = target_insert_bases + target_step + target_insert_events = target_insert_events + 1 + } + } + BigPslAlignmentCounts::{ + aligned_query_units, + query_insert_units, + target_insert_bases, + query_insert_events, + target_insert_events, + block_count, + } +} + +///| +pub fn BigPslAlignment::target_to_query( + self : BigPslAlignment, + position : Int, +) -> Int? { + if position < 0 || position >= self.target_size { + return None + } + for block in self.blocks() { + let minimum = bigpsl_min(block.target_start, block.target_end) + let maximum = bigpsl_max(block.target_start, block.target_end) + if position >= minimum && position < maximum { + let offset = if block.target_end > block.target_start { + position - block.target_start + } else { + block.target_start - 1 - position + } + let query_offset = match self.sequence_type { + BigPslProtein => offset / 3 + _ => offset + } + return Some( + if block.query_end > block.query_start { + block.query_start + query_offset + } else { + block.query_start - 1 - query_offset + }, + ) + } + } + None +} + +///| +pub fn BigPslAlignment::query_to_target_interval( + self : BigPslAlignment, + position : Int, +) -> (Int, Int)? { + if position < 0 || position >= self.query_size { + return None + } + for block in self.blocks() { + let minimum = bigpsl_min(block.query_start, block.query_end) + let maximum = bigpsl_max(block.query_start, block.query_end) + if position >= minimum && position < maximum { + let offset = if block.query_end > block.query_start { + position - block.query_start + } else { + block.query_start - 1 - position + } + let scale = match self.sequence_type { + BigPslProtein => 3 + _ => 1 + } + let oriented = offset * scale + let first = if block.target_end > block.target_start { + block.target_start + oriented + } else { + block.target_start - oriented - scale + } + return Some( + (bigpsl_min(first, first + scale), bigpsl_max(first, first + scale)), + ) + } + } + None +} + +///| +fn bigpsl_upper_code(code : Int) -> Int { + if code >= 'a'.to_int() && code <= 'z'.to_int() { + code - 32 + } else { + code + } +} + +///| +fn bigpsl_is_lower(code : Int) -> Bool { + code >= 'a'.to_int() && code <= 'z'.to_int() +} + +///| +fn bigpsl_is_upper(code : Int) -> Bool { + code >= 'A'.to_int() && code <= 'Z'.to_int() +} + +///| +fn bigpsl_complement_code(code : Int) -> Int { + match bigpsl_upper_code(code) { + 65 => 84 // A -> T + 67 => 71 // C -> G + 71 => 67 // G -> C + 84 => 65 // T -> A + 85 => 65 // U -> A + 82 => 89 // R -> Y + 89 => 82 // Y -> R + 77 => 75 // M -> K + 75 => 77 // K -> M + 66 => 86 // B -> V + 86 => 66 // V -> B + 68 => 72 // D -> H + 72 => 68 // H -> D + value => value + } +} + +///| +pub fn BigPslAlignment::recount( + self : BigPslAlignment, + target_sequence : String, + query_sequence : String, + mask? : BigPslMaskMode = BigPslNoMask, + wildcard? : Char = 'N', +) -> BigPslAlignment raise BigPslError { + bigpsl_validate_sequence( + target_sequence, + self.target_size, + "BigPsl target sequence", + ) + bigpsl_validate_sequence( + query_sequence, + self.query_size, + "BigPsl query sequence", + ) + if target_sequence.length() == 0 || query_sequence.length() == 0 { + bigpsl_fail("BigPsl recount requires concrete target and query sequences") + } + if self.sequence_type == BigPslProtein && mask != BigPslNoMask { + bigpsl_fail("Repeat masking is only defined for nucleotide BigPsl records") + } + let wildcard_code = bigpsl_upper_code(wildcard.to_int()) + let mut matches = 0 + let mut mismatches = 0 + let mut repeat_matches = 0 + let mut n_count = 0 + for block in self.blocks() { + match self.sequence_type { + BigPslProtein => { + let start = bigpsl_min(block.target_start, block.target_end) + let end = bigpsl_max(block.target_start, block.target_end) + let dna = target_sequence[start:end].to_owned() + let oriented = if block.target_end < block.target_start { + Seq::new(dna).reverse_complement() + } else { + Seq::new(dna) + } + let translated = oriented.translate() catch { + SeqError(message) => { + bigpsl_fail("Cannot translate BigPsl target block: " + message) + Seq::new("") + } + } + let amino = translated.to_string() + if amino.length() != block.query_size { + bigpsl_fail("Translated BigPsl target block has an unexpected length") + } + for offset in 0.. + for offset in 0.. block.query_start { + block.query_start + offset + } else { + block.query_start - 1 - offset + } + let raw_target = target_sequence.unsafe_get(target_index).to_int() + let target_code = bigpsl_upper_code(raw_target) + let raw_query = query_sequence.unsafe_get(query_index).to_int() + let query_code = if block.query_end < block.query_start { + bigpsl_complement_code(raw_query) + } else { + bigpsl_upper_code(raw_query) + } + if target_code == wildcard_code || query_code == wildcard_code { + n_count = n_count + 1 + } else if target_code != query_code { + mismatches = mismatches + 1 + } else { + let masked = match mask { + BigPslMaskLower => bigpsl_is_lower(raw_target) + BigPslMaskUpper => bigpsl_is_upper(raw_target) + BigPslNoMask => false + } + if masked { + repeat_matches = repeat_matches + 1 + } else { + matches = matches + 1 + } + } + } + } + } + BigPslAlignment::create( + self.target_name, + self.target_size, + self.query_name, + self.query_size, + self.target_coordinates, + self.query_coordinates, + sequence_type=self.sequence_type, + query_sequence~, + cds=self.cds, + score=self.score, + thick_start=self.thick_start, + thick_end=self.thick_end, + item_rgb=self.item_rgb, + matches~, + mismatches~, + repeat_matches~, + n_count~, + ) +} + +///| +fn bigpsl_storage(alignment : BigPslAlignment) -> BigPslStorage { + let blocks = alignment.blocks() + let target_reverse = alignment.target_coordinates[0] > + alignment.target_coordinates[alignment.target_coordinates.length() - 1] + let query_reverse = alignment.query_coordinates[0] > + alignment.query_coordinates[alignment.query_coordinates.length() - 1] + let strand = if target_reverse || query_reverse { "-" } else { "+" } + let other_strand = if target_reverse { "-" } else { "+" } + let ordered : Array[BigPslBlock] = [] + if target_reverse { + let mut index = blocks.length() + while index > 0 { + index = index - 1 + ordered.push(blocks[index]) + } + } else { + for block in blocks { + ordered.push(block) + } + } + let mut chrom_start = alignment.target_size + let mut chrom_end = 0 + let mut other_start = alignment.query_size + let mut other_end = 0 + for block in ordered { + chrom_start = bigpsl_min( + chrom_start, + bigpsl_min(block.target_start, block.target_end), + ) + chrom_end = bigpsl_max( + chrom_end, + bigpsl_max(block.target_start, block.target_end), + ) + other_start = bigpsl_min( + other_start, + bigpsl_min(block.query_start, block.query_end), + ) + other_end = bigpsl_max( + other_end, + bigpsl_max(block.query_start, block.query_end), + ) + } + let target_block_sizes : Array[Int] = [] + let target_block_starts : Array[Int] = [] + let other_block_starts : Array[Int] = [] + for block in ordered { + let target_minimum = bigpsl_min(block.target_start, block.target_end) + let query_minimum = bigpsl_min(block.query_start, block.query_end) + let query_maximum = bigpsl_max(block.query_start, block.query_end) + target_block_sizes.push(block.target_size) + target_block_starts.push(target_minimum - chrom_start) + other_block_starts.push( + if strand == "-" { + alignment.query_size - query_maximum + } else { + query_minimum + }, + ) + } + BigPslStorage::{ + chrom_start, + chrom_end, + strand, + other_start, + other_end, + other_strand, + target_block_sizes, + target_block_starts, + other_block_starts, + } +} + +///| +fn bigpsl_join_ints(values : Array[Int], trailing : Bool) -> String { + let output = StringBuilder::new() + for index in 0.. 0 { + output.write_char(',') + } + output.write_string(values[index].to_string()) + } + if trailing && values.length() > 0 { + output.write_char(',') + } + output.to_string() +} + +///| +pub fn bigpsl_schema() -> BigBedSchema { + let standard_names = [ + "chrom", "chromStart", "chromEnd", "name", "score", "strand", "thickStart", "thickEnd", + "reserved", "blockCount", "blockSizes", "chromStarts", + ] + let standard_types = [ + "string", "uint", "uint", "string", "uint", "char[1]", "uint", "uint", "uint", + "int", "int[blockCount]", "int[blockCount]", + ] + let standard_comments = [ + "Reference sequence chromosome or scaffold", "Start position in chromosome", + "End position in chromosome", "Name or ID of item, ideally both human readable and unique", + "Score (0-1000)", "+ or - indicates whether the query aligns to the + or - strand on the reference", + "Start of where display should be thick (start codon)", "End of where display should be thick (stop codon)", + "RGB value (use R,G,B string in input file)", "Number of blocks", "Comma separated list of block sizes", + "Start positions relative to chromStart", + ] + let custom_names = [ + "oChromStart", "oChromEnd", "oStrand", "oChromSize", "oChromStarts", "oSequence", + "oCDS", "chromSize", "match", "misMatch", "repMatch", "nCount", "seqType", + ] + let custom_types = [ + "uint", "uint", "char[1]", "uint", "int[blockCount]", "lstring", "string", "uint", + "uint", "uint", "uint", "uint", "uint", + ] + let custom_comments = [ + "Start position in other chromosome", "End position in other chromosome", "+ or -, - means that psl was reversed into BED-compatible coordinates", + "Size of other chromosome.", "Start positions relative to oChromStart or from oChromStart+oChromSize depending on strand", + "Sequence on other chrom (or edit list, or empty)", "CDS in NCBI format", "Size of target chromosome", + "Number of bases matched.", "Number of bases that don't match", "Number of bases that match but are part of repeats", + "Number of 'N' bases", "0=empty, 1=nucleotide, 2=amino_acid", + ] + let fields : Array[BigBedField] = [] + for index in 0.. Array[BigBedField] { + let schema = bigpsl_schema() + let fields : Array[BigBedField] = [] + for index in 12.. Int { + for index in 0.. BigPslAlignment raise BigPslError { + BigPslAlignment::create( + alignment.target_name, + alignment.target_size, + alignment.query_name, + alignment.query_size, + alignment.target_coordinates, + alignment.query_coordinates, + sequence_type=alignment.sequence_type, + query_sequence=alignment.query_sequence, + cds=alignment.cds, + score=alignment.score, + thick_start=alignment.thick_start, + thick_end=alignment.thick_end, + item_rgb=alignment.item_rgb, + matches=alignment.matches, + mismatches=alignment.mismatches, + repeat_matches=alignment.repeat_matches, + n_count=alignment.n_count, + ) +} + +///| +pub fn bigpsl_write( + targets : Array[BigBedTarget], + alignments : Array[BigPslAlignment], + config? : BigPslWriteConfig = BigPslWriteConfig::default(), +) -> Array[Int] raise BigPslError { + if targets.length() == 0 { + bigpsl_fail("BigPsl requires at least one target") + } + for index in 0.. bigpsl_fail("BigBed: " + message) + } + for previous in 0.. { + bigpsl_fail("BigBed: " + message) + BigBedRecord::{ + chrom: "", + chrom_start: 0, + chrom_end: 1, + name: ".", + score: 0, + strand: ".", + thick_start: 0, + thick_end: 1, + item_rgb: "0", + declared_block_count: 0, + block_sizes: [], + block_starts: [], + extra_fields: [], + } + } + } + records.push(record) + target_order.push(target_index) + } + let order : Array[Int] = [] + for index in 0.. Int { + if target_order[left] < target_order[right] { + -1 + } else if target_order[left] > target_order[right] { + 1 + } else if records[left].chrom_start < records[right].chrom_start { + -1 + } else if records[left].chrom_start > records[right].chrom_start { + 1 + } else if records[left].chrom_end < records[right].chrom_end { + -1 + } else if records[left].chrom_end > records[right].chrom_end { + 1 + } else { + 0 + } + }) + let sorted : Array[BigBedRecord] = [] + for index in order { + sorted.push(records[index]) + } + let bed_config = BigBedWriteConfig::create( + bed_columns=12, + items_per_slot=config.items_per_slot, + block_size=config.block_size, + compress=config.compress, + schema_name="bigPsl", + schema_comment="bigPsl pairwise alignment", + custom_fields=bigpsl_custom_fields(), + ) catch { + BigBedError(message) => { + bigpsl_fail("BigBed: " + message) + BigBedWriteConfig::default() + } + } + bigbed_write(targets, sorted, config=bed_config) catch { + BigBedError(message) => { + bigpsl_fail("BigBed: " + message) + [] + } + } +} + +///| +fn bigpsl_parse_int(value : String, label : String) -> Int raise BigPslError { + if value.length() == 0 { + bigpsl_fail("Missing integer for " + label) + } + for index in 0.. '9'.to_int() { + bigpsl_fail("Invalid integer for " + label + ": " + value) + } + } + parse_int(value) +} + +///| +fn bigpsl_split_csv( + value : String, + label : String, +) -> Array[Int] raise BigPslError { + if value.length() == 0 { + return [] + } + let values : Array[Int] = [] + let mut start = 0 + for index in 0..<=value.length() { + if index == value.length() || + value.unsafe_get(index).to_int() == ','.to_int() { + if index == start { + if index == value.length() && values.length() > 0 { + return values + } + bigpsl_fail("Empty value in " + label) + } + values.push(bigpsl_parse_int(value[start:index].to_owned(), label)) + start = index + 1 + } + } + values +} + +///| +fn bigpsl_validate_schema(bed : BigBedFile) -> Unit raise BigPslError { + let expected = bigpsl_schema() + if bed.header.defined_field_count != 12 || + bed.header.field_count != 25 || + bed.schema.name != "bigPsl" || + bed.schema.fields.length() != 25 { + bigpsl_fail("BigPsl requires the standard bigPsl bed12+13 declaration") + } + for index in 0.. BigPslAlignment raise BigPslError { + if record.extra_fields.length() != 13 { + bigpsl_fail("BigPsl binary records require thirteen custom fields") + } + if record.strand != "+" && record.strand != "-" { + bigpsl_fail("BigPsl BED strand must be '+' or '-'") + } + let other_start = bigpsl_parse_int( + record.extra_fields[0], + "BigPsl oChromStart", + ) + let other_end = bigpsl_parse_int(record.extra_fields[1], "BigPsl oChromEnd") + let other_strand = record.extra_fields[2] + if other_strand != "+" && other_strand != "-" { + bigpsl_fail("BigPsl oStrand must be '+' or '-'") + } + if other_strand == "-" && record.strand != "-" { + bigpsl_fail("BigPsl oStrand '-' requires BED strand '-'") + } + let query_size = bigpsl_parse_int(record.extra_fields[3], "BigPsl oChromSize") + let stored_query_starts = bigpsl_split_csv( + record.extra_fields[4], + "BigPsl oChromStarts", + ) + let query_sequence = record.extra_fields[5] + let cds = if record.extra_fields[6] == "n/a" { + "" + } else { + record.extra_fields[6] + } + let target_size = bigpsl_parse_int(record.extra_fields[7], "BigPsl chromSize") + let matches = bigpsl_parse_int(record.extra_fields[8], "BigPsl match") + let mismatches = bigpsl_parse_int(record.extra_fields[9], "BigPsl misMatch") + let repeat_matches = bigpsl_parse_int( + record.extra_fields[10], + "BigPsl repMatch", + ) + let n_count = bigpsl_parse_int(record.extra_fields[11], "BigPsl nCount") + let sequence_type = bigpsl_type_from_code( + bigpsl_parse_int(record.extra_fields[12], "BigPsl seqType"), + ) + match bed.target(record.chrom) { + Some(target) => + if target.length != target_size { + bigpsl_fail("BigPsl chromSize disagrees with its target declaration") + } + None => bigpsl_fail("BigPsl record refers to an unknown target") + } + let block_count = record.block_sizes.length() + if block_count == 0 || + record.block_starts.length() != block_count || + stored_query_starts.length() != block_count { + bigpsl_fail("BigPsl block arrays disagree with blockCount") + } + let target_starts : Array[Int] = [] + let target_block_sizes : Array[Int] = [] + let query_block_sizes : Array[Int] = [] + let query_starts : Array[Int] = [] + for index in 0.. { + if target_block_size % 3 != 0 { + bigpsl_fail( + "Protein BigPsl target block size must be divisible by three", + ) + } + target_block_size / 3 + } + _ => target_block_size + } + target_starts.push(record.chrom_start + record.block_starts[index]) + target_block_sizes.push(target_block_size) + query_block_sizes.push(query_block_size) + query_starts.push(stored_query_starts[index]) + if stored_query_starts[index] < 0 || + stored_query_starts[index] + query_block_size > query_size { + bigpsl_fail("BigPsl query block extends beyond oChromSize") + } + } + let ( + normalized_target_starts, + normalized_query_starts, + normalized_target_sizes, + normalized_query_sizes, + ) = if other_strand == "-" && record.strand == "-" { + let transformed_targets : Array[Int] = [] + let transformed_queries : Array[Int] = [] + for index in 0.. BigPslFile raise BigPslError { + let bed = bigbed_parse(data) catch { + BigBedError(message) => { + bigpsl_fail("BigBed: " + message) + BigBedFile::{ + header: BigBedHeader::{ + little_endian: true, + version: 4, + zoom_levels: 0, + chromosome_tree_offset: 0, + full_data_offset: 0, + full_index_offset: 0, + field_count: 0, + defined_field_count: 0, + auto_sql_offset: 0, + total_summary_offset: 0, + uncompress_buffer_size: 0, + extra_indices_offset: 0, + }, + schema: bigpsl_schema(), + targets: [], + source: [], + blocks: [], + record_count: 0, + } + } + } + bigpsl_validate_schema(bed) + let records = bed.records() catch { + BigBedError(message) => { + bigpsl_fail("BigBed: " + message) + [] + } + } + for record in records { + ignore(bigpsl_decode_record(bed, record)) + } + BigPslFile::{ bed, } +} + +///| +pub fn BigPslFile::alignments( + self : BigPslFile, +) -> Array[BigPslAlignment] raise BigPslError { + let records = self.bed.records() catch { + BigBedError(message) => { + bigpsl_fail("BigBed: " + message) + [] + } + } + let alignments : Array[BigPslAlignment] = [] + for record in records { + alignments.push(bigpsl_decode_record(self.bed, record)) + } + alignments +} + +///| +pub fn BigPslFile::search( + self : BigPslFile, + target : String, + start? : Int = 0, + end? : Int = -1, +) -> Array[BigPslAlignment] raise BigPslError { + let records = self.bed.search(target, start~, end~) catch { + BigBedError(message) => { + bigpsl_fail("BigBed: " + message) + [] + } + } + let alignments : Array[BigPslAlignment] = [] + for record in records { + alignments.push(bigpsl_decode_record(self.bed, record)) + } + alignments +} + +///| +pub fn BigPslFile::find_by_query( + self : BigPslFile, + query_name : String, +) -> Array[BigPslAlignment] raise BigPslError { + let records = self.bed.find_by_name(query_name) catch { + BigBedError(message) => { + bigpsl_fail("BigBed: " + message) + [] + } + } + let alignments : Array[BigPslAlignment] = [] + for record in records { + alignments.push(bigpsl_decode_record(self.bed, record)) + } + alignments +} + +///| +pub fn BigPslFile::target(self : BigPslFile, name : String) -> BigBedTarget? { + self.bed.target(name) +} + +///| +pub fn BigPslFile::is_compressed(self : BigPslFile) -> Bool { + self.bed.is_compressed() +} + +///| +pub fn BigPslAlignment::to_psl(self : BigPslAlignment) -> String { + let blocks = self.blocks() + let counts = self.counts() + let target_reverse = self.target_coordinates[0] > + self.target_coordinates[self.target_coordinates.length() - 1] + let query_reverse = self.query_coordinates[0] > + self.query_coordinates[self.query_coordinates.length() - 1] + let strand = if target_reverse { + "+-" + } else if query_reverse { + "-" + } else { + "+" + } + let block_sizes : Array[Int] = [] + let query_starts : Array[Int] = [] + let target_starts : Array[Int] = [] + for block in blocks { + block_sizes.push(block.query_size) + let query_minimum = bigpsl_min(block.query_start, block.query_end) + let query_maximum = bigpsl_max(block.query_start, block.query_end) + let target_minimum = bigpsl_min(block.target_start, block.target_end) + let target_maximum = bigpsl_max(block.target_start, block.target_end) + query_starts.push( + if query_reverse { + self.query_size - query_maximum + } else { + query_minimum + }, + ) + target_starts.push( + if target_reverse { + self.target_size - target_maximum + } else { + target_minimum + }, + ) + } + let (query_start, query_end) = self.query_interval() + let (target_start, target_end) = self.target_interval() + self.matches.to_string() + + "\t" + + self.mismatches.to_string() + + "\t" + + self.repeat_matches.to_string() + + "\t" + + self.n_count.to_string() + + "\t" + + counts.query_insert_events.to_string() + + "\t" + + counts.query_insert_units.to_string() + + "\t" + + counts.target_insert_events.to_string() + + "\t" + + counts.target_insert_bases.to_string() + + "\t" + + strand + + "\t" + + self.query_name + + "\t" + + self.query_size.to_string() + + "\t" + + query_start.to_string() + + "\t" + + query_end.to_string() + + "\t" + + self.target_name + + "\t" + + self.target_size.to_string() + + "\t" + + target_start.to_string() + + "\t" + + target_end.to_string() + + "\t" + + blocks.length().to_string() + + "\t" + + bigpsl_join_ints(block_sizes, true) + + "\t" + + bigpsl_join_ints(query_starts, true) + + "\t" + + bigpsl_join_ints(target_starts, true) + + "\n" +} + +///| +pub fn BigPslFile::to_psl(self : BigPslFile) -> String raise BigPslError { + let output = StringBuilder::new() + for alignment in self.alignments() { + output.write_string(alignment.to_psl()) + } + output.to_string() +} + +///| +pub fn BigPslAlignment::summary(self : BigPslAlignment) -> String { + let (start, end) = self.target_interval() + "BigPslAlignment(" + + self.target_name + + ":" + + start.to_string() + + "-" + + end.to_string() + + " <- " + + self.query_name + + ", blocks=" + + self.blocks().length().to_string() + + ", type=" + + (match self.sequence_type { + BigPslUnknown => "unknown" + BigPslNucleotide => "nucleotide" + BigPslProtein => "protein" + }) + + ")" +} + +///| +pub fn BigPslFile::summary( + self : BigPslFile, +) -> BigPslSummary raise BigPslError { + let alignments = self.alignments() + let mut nucleotide_count = 0 + let mut protein_count = 0 + let mut unknown_count = 0 + let mut aligned_query_units = 0 + let mut covered_target_bases = 0 + for alignment in alignments { + match alignment.sequence_type { + BigPslNucleotide => nucleotide_count = nucleotide_count + 1 + BigPslProtein => protein_count = protein_count + 1 + BigPslUnknown => unknown_count = unknown_count + 1 + } + aligned_query_units = aligned_query_units + + alignment.counts().aligned_query_units + let (start, end) = alignment.target_interval() + covered_target_bases = covered_target_bases + end - start + } + BigPslSummary::{ + alignment_count: alignments.length(), + target_count: self.bed.targets.length(), + nucleotide_count, + protein_count, + unknown_count, + aligned_query_units, + covered_target_bases, + compressed: self.is_compressed(), + } +} + +///| +pub fn bigpsl_example_data() -> (Array[BigBedTarget], Array[BigPslAlignment]) raise BigPslError { + let targets = [ + BigBedTarget::create("chr1", 1000) catch { + BigBedError(message) => { + bigpsl_fail("BigBed: " + message) + BigBedTarget::{ name: "chr1", length: 1000 } + } + }, + BigBedTarget::create("chr2", 800) catch { + BigBedError(message) => { + bigpsl_fail("BigBed: " + message) + BigBedTarget::{ name: "chr2", length: 800 } + } + }, + ] + let forward = BigPslAlignment::create( + "chr1", + 1000, + "rna-forward", + 30, + [100, 110, 120, 130], + [0, 10, 10, 20], + sequence_type=BigPslNucleotide, + score=900, + thick_start=103, + thick_end=127, + ) + let reverse = BigPslAlignment::create( + "chr1", + 1000, + "rna-reverse", + 40, + [200, 208, 208, 215], + [30, 22, 20, 13], + sequence_type=BigPslNucleotide, + score=850, + ) + let protein = BigPslAlignment::create( + "chr2", + 800, + "protein-reverse", + 20, + [500, 488, 470, 470, 455], + [0, 4, 4, 6, 11], + sequence_type=BigPslProtein, + score=1000, + ) + (targets, [forward, reverse, protein]) +} diff --git a/test/moonbit/bigpsl_test.mbt b/test/moonbit/bigpsl_test.mbt new file mode 100644 index 00000000..8ca39d49 --- /dev/null +++ b/test/moonbit/bigpsl_test.mbt @@ -0,0 +1,1230 @@ +///| +fn bigpsl_test_data() -> (Array[@src.BigBedTarget], Array[@src.BigPslAlignment]) { + @src.bigpsl_example_data() catch { + _ => abort("BigPsl example data should be valid") + } +} + +///| +fn bigpsl_test_file( + compress? : Bool = true, + items_per_slot? : Int = 2, +) -> @src.BigPslFile { + let (targets, alignments) = bigpsl_test_data() + let config = @src.BigPslWriteConfig::create( + compress~, + block_size=3, + items_per_slot~, + ) catch { + _ => abort("BigPsl test configuration should be valid") + } + let bytes = @src.bigpsl_write(targets, alignments, config~) catch { + _ => abort("BigPsl example should serialize") + } + @src.bigpsl_parse(bytes) catch { + _ => abort("BigPsl example should parse") + } +} + +///| +fn bigpsl_test_alignment( + target_coordinates? : Array[Int] = [10, 20], + query_coordinates? : Array[Int] = [0, 10], + sequence_type? : @src.BigPslSequenceType = @src.BigPslSequenceType::BigPslNucleotide, +) -> @src.BigPslAlignment { + @src.BigPslAlignment::create( + "chr1", + 100, + "query", + 20, + target_coordinates, + query_coordinates, + sequence_type~, + ) catch { + _ => abort("BigPsl test alignment should be valid") + } +} + +///| +fn bigpsl_test_custom_fields() -> Array[@src.BigBedField] { + let schema = @src.bigpsl_schema() + let fields : Array[@src.BigBedField] = [] + for index in 12.. Array[Int] { + let target = @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("raw BigPsl target should be valid") + } + let record = @src.BigBedRecord::create( + "chr1", + chrom_start, + chrom_end, + name="query", + score=500, + strand~, + block_count=block_sizes.length(), + block_sizes~, + block_starts~, + extra_fields~, + ) catch { + _ => abort("raw BigPsl record should be valid BigBed") + } + let config = @src.BigBedWriteConfig::create( + bed_columns=12, + schema_name="bigPsl", + schema_comment="bigPsl pairwise alignment", + custom_fields=bigpsl_test_custom_fields(), + ) catch { + _ => abort("raw BigPsl schema should be valid") + } + @src.bigbed_write([target], [record], config~) catch { + _ => abort("raw BigPsl BigBed should serialize") + } +} + +///| +fn bigpsl_test_standard_extra() -> Array[String] { + ["0", "10", "+", "20", "0", "", "", "100", "10", "0", "0", "0", "1"] +} + +///| +test "bigpsl: default configuration matches Biopython defaults" { + let config = @src.BigPslWriteConfig::default() + assert_true(config.compress) + assert_eq(config.block_size, 256) + assert_eq(config.items_per_slot, 512) + assert_true(!config.store_query_sequence) + assert_true(!config.store_cds) +} + +///| +test "bigpsl: custom configuration is preserved" { + let config = @src.BigPslWriteConfig::create( + compress=false, + block_size=8, + items_per_slot=4, + store_query_sequence=true, + store_cds=true, + ) catch { + _ => abort("custom configuration should be valid") + } + assert_true(!config.compress) + assert_eq(config.block_size, 8) + assert_eq(config.items_per_slot, 4) + assert_true(config.store_query_sequence) + assert_true(config.store_cds) +} + +///| +test "bigpsl: configuration rejects blockSize below two" { + let rejected = try { + ignore(@src.BigPslWriteConfig::create(block_size=1)) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: configuration rejects zero itemsPerSlot" { + let rejected = try { + ignore(@src.BigPslWriteConfig::create(items_per_slot=0)) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: standard schema is bed12 plus thirteen fields" { + let schema = @src.bigpsl_schema() + assert_eq(schema.name, "bigPsl") + assert_eq(schema.comment, "bigPsl pairwise alignment") + assert_eq(schema.fields.length(), 25) + assert_eq(schema.fields[11].name, "chromStarts") + assert_eq(schema.fields[12].name, "oChromStart") + assert_eq(schema.fields[24].name, "seqType") +} + +///| +test "bigpsl: standard schema preserves array and long-string types" { + let schema = @src.bigpsl_schema() + assert_eq(schema.fields[16].as_type, "int[blockCount]") + assert_eq(schema.fields[17].as_type, "lstring") + assert_eq(schema.fields[18].as_type, "string") +} + +///| +test "bigpsl: AutoSQL text contains the UCSC declaration" { + let text = @src.bigpsl_schema().to_auto_sql() + assert_true(text.contains("table bigPsl")) + assert_true(text.contains("int[blockCount] oChromStarts")) + assert_true(text.contains("uint seqType")) +} + +///| +test "bigpsl: constructor preserves metadata and defaults counts" { + let alignment = @src.BigPslAlignment::create( + "chr1", + 100, + "queryA", + 20, + [10, 15, 20, 25], + [0, 5, 5, 10], + sequence_type=@src.BigPslSequenceType::BigPslNucleotide, + score=700, + thick_start=12, + thick_end=24, + item_rgb="10,20,30", + ) catch { + _ => abort("alignment should be valid") + } + assert_eq(alignment.target_name, "chr1") + assert_eq(alignment.query_name, "queryA") + assert_eq(alignment.score, 700) + assert_eq(alignment.thick_start, 12) + assert_eq(alignment.thick_end, 24) + assert_eq(alignment.item_rgb, "10,20,30") + assert_eq(alignment.matches, 10) + assert_eq(alignment.mismatches, 0) +} + +///| +test "bigpsl: constructor accepts explicit match categories" { + let alignment = @src.BigPslAlignment::create( + "chr1", + 100, + "query", + 20, + [10, 20], + [0, 10], + matches=6, + mismatches=2, + repeat_matches=1, + n_count=1, + ) catch { + _ => abort("match categories should be valid") + } + assert_eq(alignment.matches, 6) + assert_eq(alignment.mismatches, 2) + assert_eq(alignment.repeat_matches, 1) + assert_eq(alignment.n_count, 1) +} + +///| +test "bigpsl: constructor rejects an empty target name" { + let rejected = try { + ignore( + @src.BigPslAlignment::create("", 100, "query", 20, [10, 20], [0, 10]), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: constructor rejects a zero target size" { + let rejected = try { + ignore(@src.BigPslAlignment::create("chr1", 0, "query", 20, [0, 1], [0, 1])) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: constructor rejects coordinate length mismatch" { + let rejected = try { + ignore( + @src.BigPslAlignment::create("chr1", 100, "query", 20, [10, 20], [ + 0, 5, 10, + ]), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: constructor rejects a one-point path" { + let rejected = try { + ignore(@src.BigPslAlignment::create("chr1", 100, "query", 20, [10], [0])) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: constructor rejects out-of-bounds target coordinates" { + let rejected = try { + ignore( + @src.BigPslAlignment::create("chr1", 100, "query", 20, [95, 105], [0, 10]), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: constructor rejects out-of-bounds query coordinates" { + let rejected = try { + ignore( + @src.BigPslAlignment::create("chr1", 100, "query", 20, [10, 20], [15, 25]), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: constructor rejects repeated coordinate points" { + let rejected = try { + ignore( + @src.BigPslAlignment::create("chr1", 100, "query", 20, [10, 10], [0, 0]), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: constructor rejects coordinate direction changes" { + let rejected = try { + ignore( + @src.BigPslAlignment::create("chr1", 100, "query", 20, [10, 20, 15], [ + 0, 10, 15, + ]), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: nucleotide alignment rejects reverse target coordinates" { + let rejected = try { + ignore( + @src.BigPslAlignment::create("chr1", 100, "query", 20, [20, 10], [0, 10]), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: nucleotide alignment requires equal diagonal steps" { + let rejected = try { + ignore( + @src.BigPslAlignment::create("chr1", 100, "query", 20, [10, 20], [0, 5]), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: protein alignment accepts three-to-one blocks" { + let alignment = @src.BigPslAlignment::create( + "chr1", + 100, + "protein", + 20, + [10, 40], + [0, 10], + sequence_type=@src.BigPslSequenceType::BigPslProtein, + ) catch { + _ => abort("translated alignment should be valid") + } + assert_eq(alignment.blocks()[0].target_size, 30) + assert_eq(alignment.blocks()[0].query_size, 10) +} + +///| +test "bigpsl: protein alignment rejects non-triplet blocks" { + let rejected = try { + ignore( + @src.BigPslAlignment::create( + "chr1", + 100, + "protein", + 20, + [10, 39], + [0, 10], + sequence_type=@src.BigPslSequenceType::BigPslProtein, + ), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: protein alignment rejects reverse query coordinates" { + let rejected = try { + ignore( + @src.BigPslAlignment::create( + "chr1", + 100, + "protein", + 20, + [10, 40], + [10, 0], + sequence_type=@src.BigPslSequenceType::BigPslProtein, + ), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: protein alignment accepts reverse target coordinates" { + let alignment = @src.BigPslAlignment::create( + "chr1", + 100, + "protein", + 20, + [40, 10], + [0, 10], + sequence_type=@src.BigPslSequenceType::BigPslProtein, + ) catch { + _ => abort("reverse translated alignment should be valid") + } + assert_true(alignment.is_reverse()) +} + +///| +test "bigpsl: constructor rejects a path without aligned blocks" { + let rejected = try { + ignore( + @src.BigPslAlignment::create("chr1", 100, "query", 20, [10, 20], [0, 0]), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: constructor rejects score above one thousand" { + let rejected = try { + ignore( + @src.BigPslAlignment::create( + "chr1", + 100, + "query", + 20, + [10, 20], + [0, 10], + score=1001, + ), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: constructor rejects an external thick interval" { + let rejected = try { + ignore( + @src.BigPslAlignment::create( + "chr1", + 100, + "query", + 20, + [10, 20], + [0, 10], + thick_start=5, + thick_end=20, + ), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: constructor rejects partially supplied match categories" { + let rejected = try { + ignore( + @src.BigPslAlignment::create( + "chr1", + 100, + "query", + 20, + [10, 20], + [0, 10], + matches=10, + ), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: constructor rejects a match total inconsistent with blocks" { + let rejected = try { + ignore( + @src.BigPslAlignment::create( + "chr1", + 100, + "query", + 20, + [10, 20], + [0, 10], + matches=9, + mismatches=0, + repeat_matches=0, + n_count=0, + ), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: constructor rejects a query sequence length mismatch" { + let rejected = try { + ignore( + @src.BigPslAlignment::create( + "chr1", + 100, + "query", + 20, + [10, 20], + [0, 10], + query_sequence="ACGT", + ), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: constructor rejects query sequence gaps" { + let rejected = try { + ignore( + @src.BigPslAlignment::create( + "chr1", + 100, + "query", + 5, + [10, 15], + [0, 5], + query_sequence="AC-GT", + ), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: block extraction preserves oriented coordinates" { + let alignment = bigpsl_test_alignment(target_coordinates=[10, 15, 20, 25], query_coordinates=[ + 0, 5, 5, 10, + ]) + let blocks = alignment.blocks() + assert_eq(blocks.length(), 2) + assert_eq(blocks[0].target_start, 10) + assert_eq(blocks[0].target_end, 15) + assert_eq(blocks[1].query_start, 5) + assert_eq(blocks[1].query_end, 10) +} + +///| +test "bigpsl: intervals include all blocks and gaps" { + let alignment = bigpsl_test_alignment(target_coordinates=[10, 15, 20, 25], query_coordinates=[ + 2, 7, 7, 12, + ]) + assert_eq(alignment.target_interval(), (10, 25)) + assert_eq(alignment.query_interval(), (2, 12)) +} + +///| +test "bigpsl: forward coordinate mapping is bidirectional" { + let alignment = bigpsl_test_alignment() + assert_eq(alignment.target_to_query(12), Some(2)) + assert_eq(alignment.query_to_target_interval(2), Some((12, 13))) + assert_eq(alignment.target_to_query(25), None) +} + +///| +test "bigpsl: reverse query mapping uses reverse-complement positions" { + let alignment = bigpsl_test_alignment(target_coordinates=[10, 20], query_coordinates=[ + 15, 5, + ]) + assert_eq(alignment.target_to_query(10), Some(14)) + assert_eq(alignment.target_to_query(19), Some(5)) + assert_eq(alignment.query_to_target_interval(14), Some((10, 11))) +} + +///| +test "bigpsl: protein mapping returns codon intervals" { + let alignment = @src.BigPslAlignment::create( + "chr1", + 100, + "protein", + 10, + [10, 25], + [2, 7], + sequence_type=@src.BigPslSequenceType::BigPslProtein, + ) catch { + _ => abort("protein alignment should be valid") + } + assert_eq(alignment.target_to_query(10), Some(2)) + assert_eq(alignment.target_to_query(12), Some(2)) + assert_eq(alignment.target_to_query(13), Some(3)) + assert_eq(alignment.query_to_target_interval(3), Some((13, 16))) +} + +///| +test "bigpsl: reverse protein mapping returns forward codon intervals" { + let alignment = @src.BigPslAlignment::create( + "chr1", + 100, + "protein", + 10, + [25, 10], + [2, 7], + sequence_type=@src.BigPslSequenceType::BigPslProtein, + ) catch { + _ => abort("reverse protein alignment should be valid") + } + assert_eq(alignment.target_to_query(24), Some(2)) + assert_eq(alignment.target_to_query(22), Some(2)) + assert_eq(alignment.query_to_target_interval(2), Some((22, 25))) + assert_eq(alignment.query_to_target_interval(6), Some((10, 13))) +} + +///| +test "bigpsl: gap counts distinguish query and target insertions" { + let alignment = @src.BigPslAlignment::create( + "chr1", + 100, + "query", + 30, + [10, 15, 15, 20, 23, 28], + [0, 5, 7, 12, 12, 17], + ) catch { + _ => abort("gapped alignment should be valid") + } + let counts = alignment.counts() + assert_eq(counts.aligned_query_units, 15) + assert_eq(counts.query_insert_events, 1) + assert_eq(counts.query_insert_units, 2) + assert_eq(counts.target_insert_events, 1) + assert_eq(counts.target_insert_bases, 3) + assert_eq(counts.block_count, 3) +} + +///| +test "bigpsl: nucleotide recount classifies matches mismatches and wildcard" { + let alignment = @src.BigPslAlignment::create("chr1", 6, "query", 6, [0, 6], [ + 0, 6, + ]) catch { + _ => abort("recount alignment should be valid") + } + let recounted = alignment.recount("AaCGNT", "AACGAC") catch { + _ => abort("nucleotide recount should succeed") + } + assert_eq(recounted.matches, 4) + assert_eq(recounted.mismatches, 1) + assert_eq(recounted.repeat_matches, 0) + assert_eq(recounted.n_count, 1) + assert_eq(recounted.query_sequence, "AACGAC") +} + +///| +test "bigpsl: lower-case mask reports repeat matches" { + let alignment = @src.BigPslAlignment::create("chr1", 6, "query", 6, [0, 6], [ + 0, 6, + ]) catch { + _ => abort("recount alignment should be valid") + } + let recounted = alignment.recount( + "AaCGNT", + "AACGAT", + mask=@src.BigPslMaskMode::BigPslMaskLower, + ) catch { + _ => abort("lower-mask recount should succeed") + } + assert_eq(recounted.matches, 4) + assert_eq(recounted.repeat_matches, 1) + assert_eq(recounted.n_count, 1) +} + +///| +test "bigpsl: upper-case mask reports repeat matches" { + let alignment = @src.BigPslAlignment::create("chr1", 6, "query", 6, [0, 6], [ + 0, 6, + ]) catch { + _ => abort("recount alignment should be valid") + } + let recounted = alignment.recount( + "AaCGNT", + "AACGAT", + mask=@src.BigPslMaskMode::BigPslMaskUpper, + ) catch { + _ => abort("upper-mask recount should succeed") + } + assert_eq(recounted.matches, 1) + assert_eq(recounted.repeat_matches, 4) + assert_eq(recounted.n_count, 1) +} + +///| +test "bigpsl: reverse nucleotide recount complements the query" { + let alignment = @src.BigPslAlignment::create("chr1", 4, "query", 4, [0, 4], [ + 4, 0, + ]) catch { + _ => abort("reverse recount alignment should be valid") + } + let recounted = alignment.recount("AACG", "CGTT") catch { + _ => abort("reverse recount should succeed") + } + assert_eq(recounted.matches, 4) + assert_eq(recounted.mismatches, 0) +} + +///| +test "bigpsl: forward translated recount uses the standard genetic code" { + let alignment = @src.BigPslAlignment::create( + "chr1", + 9, + "protein", + 3, + [0, 9], + [0, 3], + sequence_type=@src.BigPslSequenceType::BigPslProtein, + ) catch { + _ => abort("protein recount alignment should be valid") + } + let recounted = alignment.recount("ATGAAATTT", "MKF") catch { + _ => abort("protein recount should succeed") + } + assert_eq(recounted.matches, 3) + assert_eq(recounted.mismatches, 0) +} + +///| +test "bigpsl: reverse translated recount reverse-complements target codons" { + let alignment = @src.BigPslAlignment::create( + "chr1", + 9, + "protein", + 3, + [9, 0], + [0, 3], + sequence_type=@src.BigPslSequenceType::BigPslProtein, + ) catch { + _ => abort("reverse protein recount alignment should be valid") + } + let recounted = alignment.recount("AAATTTCAT", "MKF") catch { + _ => abort("reverse protein recount should succeed") + } + assert_eq(recounted.matches, 3) +} + +///| +test "bigpsl: translated recount supports X wildcard" { + let alignment = @src.BigPslAlignment::create( + "chr1", + 9, + "protein", + 3, + [0, 9], + [0, 3], + sequence_type=@src.BigPslSequenceType::BigPslProtein, + ) catch { + _ => abort("protein recount alignment should be valid") + } + let recounted = alignment.recount("ATGNNNTTT", "MXF", wildcard='X') catch { + _ => abort("ambiguous protein recount should succeed") + } + assert_eq(recounted.matches, 2) + assert_eq(recounted.n_count, 1) +} + +///| +test "bigpsl: protein recount rejects repeat masking" { + let alignment = @src.BigPslAlignment::create( + "chr1", + 9, + "protein", + 3, + [0, 9], + [0, 3], + sequence_type=@src.BigPslSequenceType::BigPslProtein, + ) catch { + _ => abort("protein recount alignment should be valid") + } + let rejected = try { + ignore( + alignment.recount( + "ATGAAATTT", + "MKF", + mask=@src.BigPslMaskMode::BigPslMaskLower, + ), + ) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: compressed binary round-trip preserves all example paths" { + let (_, expected) = bigpsl_test_data() + let observed = bigpsl_test_file().alignments() catch { + _ => abort("BigPsl alignments should decode") + } + assert_eq(observed.length(), expected.length()) + for index in 0.. abort("uncompressed BigPsl should decode") + } + assert_eq(alignments.length(), 3) +} + +///| +test "bigpsl: multiple data slots preserve target order" { + let file = bigpsl_test_file(items_per_slot=1) + assert_true(file.bed.blocks.length() >= 3) + let alignments = file.alignments() catch { + _ => abort("multi-block BigPsl should decode") + } + assert_eq(alignments[0].target_name, "chr1") + assert_eq(alignments[2].target_name, "chr2") +} + +///| +test "bigpsl: forward nucleotide path survives binary storage" { + let alignment = (bigpsl_test_file().alignments() catch { + _ => abort("alignments should decode") + })[0] + assert_eq(alignment.target_coordinates, [100, 110, 120, 130]) + assert_eq(alignment.query_coordinates, [0, 10, 10, 20]) +} + +///| +test "bigpsl: reverse nucleotide path survives binary storage" { + let alignment = (bigpsl_test_file().alignments() catch { + _ => abort("alignments should decode") + })[1] + assert_eq(alignment.target_coordinates, [200, 208, 208, 215]) + assert_eq(alignment.query_coordinates, [30, 22, 20, 13]) + assert_true(alignment.is_reverse()) +} + +///| +test "bigpsl: reverse translated path survives binary storage" { + let alignment = (bigpsl_test_file().alignments() catch { + _ => abort("alignments should decode") + })[2] + assert_eq(alignment.target_coordinates, [500, 488, 470, 470, 455]) + assert_eq(alignment.query_coordinates, [0, 4, 4, 6, 11]) + assert_eq(alignment.sequence_type, @src.BigPslSequenceType::BigPslProtein) +} + +///| +test "bigpsl: query sequence and CDS round-trip when requested" { + let target = @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("target should be valid") + } + let alignment = @src.BigPslAlignment::create( + "chr1", + 100, + "transcript", + 10, + [10, 20], + [0, 10], + sequence_type=@src.BigPslSequenceType::BigPslNucleotide, + query_sequence="AACCGGTTAA", + cds="2..8", + ) catch { + _ => abort("annotated alignment should be valid") + } + let config = @src.BigPslWriteConfig::create( + store_query_sequence=true, + store_cds=true, + ) catch { + _ => abort("storage configuration should be valid") + } + let bytes = @src.bigpsl_write([target], [alignment], config~) catch { + _ => abort("annotated BigPsl should serialize") + } + let parsed = @src.bigpsl_parse(bytes) catch { + _ => abort("annotated BigPsl should parse") + } + let observed = (parsed.alignments() catch { + _ => abort("annotated alignment should decode") + })[0] + assert_eq(observed.query_sequence, "AACCGGTTAA") + assert_eq(observed.cds, "2..8") +} + +///| +test "bigpsl: writer omits query sequence and CDS by default" { + let target = @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("target should be valid") + } + let alignment = @src.BigPslAlignment::create( + "chr1", + 100, + "transcript", + 10, + [10, 20], + [0, 10], + query_sequence="AACCGGTTAA", + cds="2..8", + ) catch { + _ => abort("annotated alignment should be valid") + } + let bytes = @src.bigpsl_write([target], [alignment]) catch { + _ => abort("BigPsl should serialize") + } + let parsed = @src.bigpsl_parse(bytes) catch { + _ => abort("BigPsl should parse") + } + let observed = (parsed.alignments() catch { + _ => abort("alignment should decode") + })[0] + assert_eq(observed.query_sequence, "") + assert_eq(observed.cds, "") +} + +///| +test "bigpsl: writer requires sequences when sequence storage is enabled" { + let (targets, alignments) = bigpsl_test_data() + let config = @src.BigPslWriteConfig::create(store_query_sequence=true) catch { + _ => abort("storage configuration should be valid") + } + let rejected = try { + ignore(@src.bigpsl_write(targets, alignments, config~)) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: writer rejects an unknown target" { + let target = @src.BigBedTarget::create("chr2", 100) catch { + _ => abort("target should be valid") + } + let rejected = try { + ignore(@src.bigpsl_write([target], [bigpsl_test_alignment()])) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: writer rejects a target length mismatch" { + let target = @src.BigBedTarget::create("chr1", 101) catch { + _ => abort("target should be valid") + } + let rejected = try { + ignore(@src.bigpsl_write([target], [bigpsl_test_alignment()])) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: interval search uses the BigBed R-tree" { + let file = bigpsl_test_file(items_per_slot=1) + let first = file.search("chr1", start=105, end=106) catch { + _ => abort("interval search should succeed") + } + assert_eq(first.length(), 1) + assert_eq(first[0].query_name, "rna-forward") + let second = file.search("chr1", start=210, end=211) catch { + _ => abort("interval search should succeed") + } + assert_eq(second.length(), 1) + assert_eq(second[0].query_name, "rna-reverse") +} + +///| +test "bigpsl: interval search rejects an unknown target" { + let rejected = try { + ignore(bigpsl_test_file().search("chr9", start=1, end=2)) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: query-name lookup returns matching alignments" { + let results = bigpsl_test_file().find_by_query("protein-reverse") catch { + _ => abort("query lookup should succeed") + } + assert_eq(results.length(), 1) + assert_eq(results[0].target_name, "chr2") +} + +///| +test "bigpsl: target lookup exposes chromosome sizes" { + match bigpsl_test_file().target("chr2") { + Some(target) => assert_eq(target.length, 800) + None => abort("chr2 target should exist") + } + assert_eq(bigpsl_test_file().target("missing"), None) +} + +///| +test "bigpsl: parser rejects a non-BigPsl schema" { + let target = @src.BigBedTarget::create("chr1", 100) catch { + _ => abort("target should be valid") + } + let record = @src.BigBedRecord::create("chr1", 10, 20) catch { + _ => abort("record should be valid") + } + let config = @src.BigBedWriteConfig::create(bed_columns=3) catch { + _ => abort("plain BigBed configuration should be valid") + } + let bytes = @src.bigbed_write([target], [record], config~) catch { + _ => abort("plain BigBed should serialize") + } + let rejected = try { + ignore(@src.bigpsl_parse(bytes)) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: parser rejects an unknown seqType" { + let extra = bigpsl_test_standard_extra() + extra[12] = "9" + let rejected = try { + ignore(@src.bigpsl_parse(bigpsl_test_raw_bytes(extra))) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: parser rejects mismatched query block counts" { + let extra = bigpsl_test_standard_extra() + extra[4] = "0,5" + let rejected = try { + ignore(@src.bigpsl_parse(bigpsl_test_raw_bytes(extra))) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: parser rejects a query sequence length mismatch" { + let extra = bigpsl_test_standard_extra() + extra[5] = "ACGT" + let rejected = try { + ignore(@src.bigpsl_parse(bigpsl_test_raw_bytes(extra))) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: parser rejects a chromosome size mismatch" { + let extra = bigpsl_test_standard_extra() + extra[7] = "99" + let rejected = try { + ignore(@src.bigpsl_parse(bigpsl_test_raw_bytes(extra))) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: parser rejects inconsistent match categories" { + let extra = bigpsl_test_standard_extra() + extra[8] = "9" + let rejected = try { + ignore(@src.bigpsl_parse(bigpsl_test_raw_bytes(extra))) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: parser rejects an inconsistent other interval" { + let extra = bigpsl_test_standard_extra() + extra[0] = "1" + let rejected = try { + ignore(@src.bigpsl_parse(bigpsl_test_raw_bytes(extra))) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: parser rejects oStrand minus with BED strand plus" { + let extra = bigpsl_test_standard_extra() + extra[2] = "-" + let rejected = try { + ignore(@src.bigpsl_parse(bigpsl_test_raw_bytes(extra))) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: parser rejects a non-triplet protein block" { + let extra = bigpsl_test_standard_extra() + extra[8] = "0" + extra[9] = "0" + extra[10] = "0" + extra[11] = "0" + extra[12] = "2" + let rejected = try { + ignore(@src.bigpsl_parse(bigpsl_test_raw_bytes(extra))) + false + } catch { + BigPslError(_) => true + } + assert_true(rejected) +} + +///| +test "bigpsl: nucleotide PSL export contains exact block and gap fields" { + let alignment = bigpsl_test_data().1[0] + let psl = alignment.to_psl() + assert_true(psl.has_prefix("20\t0\t0\t0\t0\t0\t1\t10\t+")) + assert_true( + psl.contains("\trna-forward\t30\t0\t20\tchr1\t1000\t100\t130\t2\t"), + ) + assert_true(psl.contains("10,10,\t0,10,\t100,120,")) +} + +///| +test "bigpsl: reverse translated PSL export uses two-character strand" { + let alignment = bigpsl_test_data().1[2] + let psl = alignment.to_psl() + assert_true(psl.contains("\t+-\tprotein-reverse\t")) + assert_true(psl.contains("\t2\t4,5,\t0,6,")) +} + +///| +test "bigpsl: file PSL export includes every query" { + let text = bigpsl_test_file().to_psl() catch { + _ => abort("PSL export should succeed") + } + assert_eq(text.split("\n").length(), 4) + assert_true(text.contains("rna-forward")) + assert_true(text.contains("rna-reverse")) + assert_true(text.contains("protein-reverse")) +} + +///| +test "bigpsl: alignment summary identifies type and block count" { + let summary = bigpsl_test_data().1[2].summary() + assert_true(summary.contains("chr2:455-500")) + assert_true(summary.contains("protein-reverse")) + assert_true(summary.contains("blocks=2")) + assert_true(summary.contains("type=protein")) +} + +///| +test "bigpsl: file summary aggregates sequence types and coverage" { + let summary = bigpsl_test_file().summary() catch { + _ => abort("file summary should succeed") + } + assert_eq(summary.alignment_count, 3) + assert_eq(summary.target_count, 2) + assert_eq(summary.nucleotide_count, 2) + assert_eq(summary.protein_count, 1) + assert_eq(summary.unknown_count, 0) + assert_eq(summary.aligned_query_units, 44) + assert_eq(summary.covered_target_bases, 90) + assert_true(summary.compressed) +} From a434c30c9c46afa1d1fdeca29107f8f7bb42f4a4 Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 10:13:58 +0800 Subject: [PATCH 23/41] #28 /9196 feat(aldex2): Bioconductor ALDEx2 --- README.md | 22 +- examples/aldex2_demo/main.mbt | 145 ++++ examples/aldex2_demo/moon.pkg | 6 + src/aldex2.mbt | 1541 +++++++++++++++++++++++++++++++++ test/moonbit/aldex2_test.mbt | 1449 +++++++++++++++++++++++++++++++ 5 files changed, 3160 insertions(+), 3 deletions(-) create mode 100644 examples/aldex2_demo/main.mbt create mode 100644 examples/aldex2_demo/moon.pkg create mode 100644 src/aldex2.mbt create mode 100644 test/moonbit/aldex2_test.mbt diff --git a/README.md b/README.md index 3fa20fe8..36cd5756 100644 --- a/README.md +++ b/README.md @@ -209,6 +209,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **limma** | Bioconductor limma | 差异表达分析、线性模型拟合、经验贝叶斯、voom变换、RPKM/CPM/quantile归一化、ComBat/removeBatchEffect批次校正、treat严格检验 | ✅ | | **variancePartition** | Bioconductor variancePartition | 重复测量线性混合模型、方差分解、BLUP、precision weights、dream contrast与Satterthwaite检验 | ✅ | | **dreamlet** | Bioconductor dreamlet | sample×cell-type pseudobulk、TMM、cell/sample/gene过滤、logCPM、Poisson/voom precision weights、分cell-type重复测量模型及study-wide FDR | ✅ | +| **ALDEx2** | Bioconductor ALDEx2 | Dirichlet Monte Carlo组成型差异丰度、六类denominator、Welch/Wilcoxon与配对检验、effect/overlap、Aitchison距离及SummarizedExperiment接入 | ✅ | | **SummarizedExperiment** | Bioconductor SummarizedExperiment | 多维基因组数据容器、Assays、行/列操作 | ✅ | | **RangedSummarizedExperiment** | Bioconductor SummarizedExperiment | GRanges/GRangesList行范围、复合特征精确重叠/最近邻、覆盖度、区间变换与协调子集 | ✅ | | **TreeSummarizedExperiment** | Bioconductor TreeSummarizedExperiment | 行/列树、节点链接、树节点子集、祖先/后代查询、层级聚合 | ✅ | @@ -482,6 +483,7 @@ IvanAXu/BioSeqs/ │ ├── deseq2.mbt # DESeq2 差异表达分析 (size factors归一化、分散度估计、负二项GLM拟合、Wald检验、LFC收缩) │ ├── deseq2_advanced.mbt # DESeq2 VST方差稳定化变换、PCA可视化 │ ├── apeglm.mbt # apeglm 自适应重尾LFC收缩、Laplace后验、FSR/FSOS与容器接入 +│ ├── aldex2.mbt # ALDEx2 Dirichlet Monte Carlo组成型推断、检验、effect与容器接入 │ ├── edger.mbt # edgeR 差异表达分析 (DGEList、精确检验、GLM拟合) │ ├── edger_advanced.mbt # edgeR准似然F检验、camera/roast基因集检验 │ ├── limma.mbt # limma 差异表达、归一化、批次校正 (线性模型、经验贝叶斯、voom、RPKM/CPM/quantile、ComBat) @@ -912,6 +914,7 @@ IvanAXu/BioSeqs/ │ ├── milo_demo/ # miloR KNN图、精炼邻域、NB差异丰度、spatial FDR与SCE接入示例 │ ├── zinbwave_demo/ # zinbwave latent factors、dropout权重、残差/插补与SCE集成示例 │ ├── apeglm_demo/ # apeglm MLE/MAP、重尾收缩、FSR/FSOS、TSV与SE接入示例 +│ ├── aldex2_demo/ # ALDEx2 IQLR、Dirichlet实例、effect/eBH、距离与SE接入示例 │ ├── variance_partition_demo/ # variancePartition 方差分解、BLUP、precision weights、dream与SE接入示例 │ ├── dreamlet_demo/ # dreamlet SCE pseudobulk、TMM/voom、donor随机截距与跨cell-type FDR示例 │ ├── monocle3_demo/ # monocle3 单细胞轨迹分析示例 (PCA/UMAP降维、主图学习、拟时间排序) @@ -1320,6 +1323,7 @@ IvanAXu/BioSeqs/ │ │ ├── milo_test.mbt │ │ ├── zinbwave_test.mbt │ │ ├── apeglm_test.mbt +│ │ ├── aldex2_test.mbt │ │ ├── variance_partition_test.mbt │ │ ├── dreamlet_test.mbt │ │ ├── shared_reference_alignment_test.mbt @@ -1818,6 +1822,7 @@ moon test # ✅ 9116 个测试全 | `milo.mbt` | `miloR` | 精确KNN图、median精炼重叠邻域、邻域计数/表达、固定效应NB-GLM/Wald检验、graph spatial FDR与SCE接入 | | `zinbwave.mbt` | `zinbwave` | ZINB交替EM/IRLS、cell/gene design与offset、确定性低维因子、gene dispersion shrinkage、observational weights、deviance residual及SingleCellExperiment包装 | | `apeglm.mbt` | `apeglm` | 负二项GLM MLE、自适应Cauchy/Student-t先验、阻尼Newton多起点MAP、Laplace后验SD/区间、FSR/FSOS/s-value、DESeq2与SummarizedExperiment包装 | +| `aldex2.mbt` | `ALDEx2` | count+prior Dirichlet Monte Carlo、all/median/IQLR/zero/LVHA/user分母、两组与配对检验、posterior expected BH、effect/overlap、距离和SummarizedExperiment包装 | | `variance_partition.mbt` | `variancePartition` | typed fixed/random design、多随机截距LMM、ML/REML方差分解、BLUP、weighted dream contrast、Satterthwaite自由度与SummarizedExperiment入口 | | `dreamlet.mbt` | `dreamlet` | SCE到sample×cluster pseudobulk、TMM/logCPM、两阶段voom precision weights、固定/随机效应筛选、逐cell-type dream和study-wide FDR | | `shared_reference_alignment.mbt` | `Bio.Align.Alignment` | 同参考PWA/MSA的reference-boundary insertion同步、原query投影、局部坐标、metadata、统计与格式转换 | @@ -2967,6 +2972,14 @@ MAP 求解器实现阻尼 Newton、Cholesky 信息矩阵求解、逐级 ridge 构造器和解析器诊断名称、坐标边界/方向、非 1:1 或 3:1 block、无 aligned block、非法 score/thick interval、序列长度、match 总数、schema 及 strand 组合。当前范围不生成 zoom levels 或额外 string index，不实现远程 HTTP range reader；二进制容器能力与 BigBed 保持一致。 +### 258. Dirichlet Monte Carlo 组成型差异丰度 (Bioconductor ALDEx2) + +实现 Bioconductor `ALDEx2` 的可移植两组组成型推断核心，输入统一为 feature × sample 非负整数计数。`aldex2_clr` 先过滤跨全部样本均为零的 feature，以 `count + prior`（默认 prior 0.5）作为 Dirichlet shape，使用显式 seed、Park-Miller LCG、Box-Muller normal 和 Marsaglia-Tsang gamma sampler 生成确定性 Monte Carlo 实例。log2 ratio 变换支持 `all`、`median`、IQLR、condition-specific `zero`、LVHA 和调用方指定原始输入 feature index 的 `user` denominator，也可接收 sample × Monte Carlo instance 的正 scale matrix 直接构造 scale-aware log abundance。 + +`aldex2_ttest` 在每个实例内执行两组 Welch 与 Mann-Whitney/Wilcoxon 检验，配对模式改用 paired t 和 signed-rank；每个实例独立执行标准 Benjamini-Hochberg 校正，再跨 posterior 实例求 expected p/eBH。`aldex2_effect` 报告组内 relative abundance、between/within difference、标准化 effect、可信区间和 sign overlap；另提供 posterior expected Aitchison距离、名称查询、排序、阈值筛选、摘要及 ALDEx2 风格 TSV。`aldex2_summarized_experiment` 在不可变副本中加入 effect、overlap、Welch eBH 和 Wilcoxon eBH assays，并按原始行索引回填被过滤的全零 feature。 + +构造器会诊断 ragged、负数、非整数或非有限计数，空样本文库、名称/condition/配对维度、denominator 和 scale matrix 错误。当前范围不包含 `aldex.glm`、Kruskal-Wallis、相关性、绘图、BiocParallel 或自动 gamma scale uncertainty simulation；effect posterior 使用同一实例内的确定性 pairwise 组合，不保证与上游最多 10000 次随机重采样逐位一致。 + ## 性能优化 ### 优化策略 @@ -3068,8 +3081,8 @@ MAP 求解器实现阻尼 Newton、Cholesky 信息矩阵求解、逐级 ridge | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 9116 | -| 通过数 | 9116 | +| 总测试数 | 9196 | +| 通过数 | 9196 | | 失败数 | 0 | | 通过率 | 100% | @@ -3199,6 +3212,7 @@ moon test --update | miloR | `milo_test.mbt` | 37 | | zinbwave | `zinbwave_test.mbt` | 54 | | apeglm | `apeglm_test.mbt` | 66 | +| ALDEx2 | `aldex2_test.mbt` | 80 | | monocle3 | `monocle3_test.mbt` | 10 | | ShortRead | `short_read_test.mbt` | 15 | | scater | `scater_test.mbt` | 17 | @@ -3474,7 +3488,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 365 个示例程序，展示各模块的典型用法： +项目提供 366 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3569,6 +3583,7 @@ moon run cmd/bench/main.mbt | milo_demo | 精确KNN图、精炼重叠邻域、样本计数、NB-GLM差异丰度、graph spatial FDR和SCE接入 | `moon run examples/milo_demo` | | zinbwave_demo | ZINB latent-factor拟合、dropout后验权重、归一化/插补/deviance residual和不可变SCE输出 | `moon run examples/zinbwave_demo` | | apeglm_demo | NB-GLM MLE与自适应重尾MAP、FSR/s-value/FSOS、log2 TSV及不可变SummarizedExperiment输出 | `moon run examples/apeglm_demo` | +| aldex2_demo | Dirichlet Monte Carlo、IQLR、posterior expected eBH、effect/overlap、Aitchison距离及不可变SummarizedExperiment输出 | `moon run examples/aldex2_demo` | | mast_demo | MAST 单细胞差异表达分析（Hurdle模型、离散/连续检验、BH-FDR校正、结果汇总） | `moon run examples/mast_demo/main.mbt` | | genomic_files_demo | GenomicFiles 分布式基因组文件处理（BAM/BED/VCF扫描、区间查询、归约、覆盖度计算） | `moon run examples/genomic_files_demo/main.mbt` | | diffbind_demo | DiffBind ChIP-seq差异结合分析（峰值重叠、共识峰识别、TMM归一化、负二项分布检验） | `moon run examples/diffbind_demo/main.mbt` | @@ -3782,6 +3797,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bioconductor decontX ambient RNA去污染（cluster-native/contaminant混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解与SCE集成） - ✅ 实现 Bioconductor zinbwave 零膨胀负二项低维模型（cell/gene协变量、offset、latent factors、dispersion shrinkage、observational weights、残差/插补与SCE集成） - ✅ 实现 Bioconductor apeglm 自适应重尾效应量收缩（NB-GLM MLE、经验贝叶斯Cauchy/Student-t先验、多起点MAP、Laplace后验、FSR/FSOS/s-value与容器接入） +- ✅ 实现 Bioconductor ALDEx2 组成型差异丰度（Dirichlet Monte Carlo、六类denominator、两组/配对检验、posterior expected BH、effect/overlap、距离与SummarizedExperiment接入） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/aldex2_demo/main.mbt b/examples/aldex2_demo/main.mbt new file mode 100644 index 00000000..bf815237 --- /dev/null +++ b/examples/aldex2_demo/main.mbt @@ -0,0 +1,145 @@ +///| +fn print_feature(result : @src.Aldex2Result, name : String) -> Unit { + let effect = match result.effects.find_feature(name) { + Some(value) => value + None => abort("ALDEx2 example feature not found: " + name) + } + let tests = match result.tests.find_feature(name) { + Some(value) => value + None => abort("ALDEx2 example test result not found: " + name) + } + println( + " " + + name + + ": effect=" + + effect.effect.to_string() + + ", overlap=" + + effect.overlap.to_string() + + ", Welch eBH=" + + tests.welch_adjusted.to_string() + + ", Wilcoxon eBH=" + + tests.wilcoxon_adjusted.to_string(), + ) +} + +///| +fn main { + println("=== Bioconductor ALDEx2 Demo ===") + let (counts, conditions, features, samples) = @src.aldex2_example_data() + let config = @src.Aldex2Config::create( + mc_samples=64, + denominator=@src.Aldex2Iqlr, + seed=2026, + ) catch { + _ => abort("failed to create ALDEx2 configuration") + } + + println("\n1. Draw deterministic Dirichlet instances and apply IQLR") + let clr = @src.aldex2_clr( + counts, + conditions, + config~, + feature_names=features, + sample_names=samples, + ) catch { + Aldex2Error(message) => abort("failed to construct ALDEx2 CLR: " + message) + } + println( + " retained features=" + + clr.feature_count().to_string() + + ", removed all-zero features=" + + clr.removed_feature_count().to_string() + + ", samples=" + + clr.sample_count().to_string() + + ", Monte Carlo instances=" + + clr.mc_sample_count().to_string(), + ) + + println("\n2. Estimate posterior tests and standardized effects") + let result = @src.aldex2( + counts, + conditions, + config~, + feature_names=features, + sample_names=samples, + ) catch { + Aldex2Error(message) => abort("failed to run ALDEx2: " + message) + } + print_feature(result, "increased") + print_feature(result, "decreased") + print_feature(result, "stable_high") + print_feature(result, "rare_increased") + + println("\n3. Rank, select, and summarize compositional effects") + let ranked = result.ranked() + let summary = result.summary(maximum_adjusted=0.1, minimum_effect=1.0) + println( + " largest absolute effect=" + + ranked[0].feature_name + + " (" + + ranked[0].effect.to_string() + + ")", + ) + println( + " Welch eBH <= 0.10=" + + summary.significant_welch_count.to_string() + + ", |effect| >= 1=" + + summary.large_effect_count.to_string() + + ", jointly selected=" + + result.select(maximum_adjusted=0.1, minimum_effect=1.0).length().to_string(), + ) + + println("\n4. Compute posterior expected Aitchison distances") + let distances = result.clr.expected_distance() + println( + " distance(C1, T1)=" + + distances[0][4].to_string() + + ", symmetric=" + + (distances[0][4] == distances[4][0]).to_string(), + ) + + println("\n5. Add posterior summaries to an immutable container copy") + let assays : Map[String, Array[Array[Double]]] = Map([("counts", counts)]) + let metadata : Map[String, String] = Map([("source", "aldex2_demo")]) + let experiment = @src.summarized_experiment(assays, [], [], metadata) + let output = @src.aldex2_summarized_experiment( + experiment, + conditions, + config~, + feature_names=features, + sample_names=samples, + ) catch { + Aldex2Error(message) => + abort("failed to integrate ALDEx2 with SummarizedExperiment: " + message) + } + let effect_assay = match @src.se_assay(output.experiment, "aldex2_effect") { + Some(value) => value + None => abort("ALDEx2 effect assay missing") + } + println( + " effect rows=" + + effect_assay.length().to_string() + + ", source object unchanged=" + + (@src.se_assay(experiment, "aldex2_effect") is None).to_string(), + ) + + println("\n6. Export an ALDEx2-compatible tabular summary") + println(result.to_tsv()) + + println("7. Invalid count matrices produce explicit diagnostics") + let rejected = try { + ignore( + @src.aldex2([[2.0, -1.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]], [ + "A", "A", "B", "B", + ]), + ) + false + } catch { + Aldex2Error(message) => { + println(" " + message) + true + } + } + println(" malformed counts rejected=" + rejected.to_string()) + println("\n=== Demo Complete ===") +} diff --git a/examples/aldex2_demo/moon.pkg b/examples/aldex2_demo/moon.pkg new file mode 100644 index 00000000..8824b1ac --- /dev/null +++ b/examples/aldex2_demo/moon.pkg @@ -0,0 +1,6 @@ +import { + "IvanAXu/BioSeqs/src", + "moonbitlang/core/hashmap", +} + +pkgtype(kind: "executable") diff --git a/src/aldex2.mbt b/src/aldex2.mbt new file mode 100644 index 00000000..fbb3c849 --- /dev/null +++ b/src/aldex2.mbt @@ -0,0 +1,1541 @@ +// Compositional differential-abundance inference inspired by Bioconductor +// ALDEx2. Count matrices use feature x sample orientation throughout. + +///| +pub suberror Aldex2Error { + Aldex2Error(String) +} + +///| +pub(all) enum Aldex2Denominator { + Aldex2All + Aldex2Median + Aldex2Iqlr + Aldex2Zero + Aldex2Lvha + Aldex2User +} derive(Eq, Debug) + +///| +pub struct Aldex2Config { + mc_samples : Int + prior : Double + denominator : Aldex2Denominator + denominator_indices : Array[Int] + seed : Int + paired : Bool + interval_level : Double +} derive(Eq, Debug) + +///| +pub fn Aldex2Config::create( + mc_samples? : Int = 128, + prior? : Double = 0.5, + denominator? : Aldex2Denominator = Aldex2All, + denominator_indices? : Array[Int] = [], + seed? : Int = 42, + paired? : Bool = false, + interval_level? : Double = 0.95, +) -> Aldex2Config raise Aldex2Error { + if mc_samples < 1 { + raise Aldex2Error("ALDEx2 Monte Carlo sample count must be positive") + } + if !aldex2_is_finite(prior) || prior <= 0.0 { + raise Aldex2Error("ALDEx2 Dirichlet prior must be finite and positive") + } + if seed <= 0 { + raise Aldex2Error("ALDEx2 random seed must be positive") + } + if !aldex2_is_finite(interval_level) || + interval_level <= 0.0 || + interval_level >= 1.0 { + raise Aldex2Error("ALDEx2 interval level must be finite and in (0, 1)") + } + if denominator == Aldex2User && denominator_indices.length() == 0 { + raise Aldex2Error("ALDEx2 user denominator must contain feature indices") + } + if denominator != Aldex2User && denominator_indices.length() > 0 { + raise Aldex2Error( + "ALDEx2 denominator indices require the user denominator mode", + ) + } + Aldex2Config::{ + mc_samples, + prior, + denominator, + denominator_indices: denominator_indices.copy(), + seed, + paired, + interval_level, + } +} + +///| +pub fn Aldex2Config::default() -> Aldex2Config { + Aldex2Config::{ + mc_samples: 128, + prior: 0.5, + denominator: Aldex2All, + denominator_indices: [], + seed: 42, + paired: false, + interval_level: 0.95, + } +} + +///| +pub struct Aldex2Clr { + counts : Array[Array[Double]] + feature_names : Array[String] + sample_names : Array[String] + conditions : Array[String] + group_names : Array[String] + group_indices : Array[Array[Int]] + original_feature_indices : Array[Int] + denominator_by_sample : Array[Array[Int]] + dirichlet : Array[Array[Array[Double]]] + analysis : Array[Array[Array[Double]]] + scale_samples : Array[Array[Double]] + original_feature_count : Int + config : Aldex2Config +} + +///| +pub struct Aldex2TestFeature { + feature_name : String + welch_p_value : Double + welch_adjusted : Double + wilcoxon_p_value : Double + wilcoxon_adjusted : Double +} derive(Eq, Debug) + +///| +pub struct Aldex2TestResult { + features : Array[Aldex2TestFeature] + group_a : String + group_b : String + paired : Bool + mc_samples : Int +} + +///| +pub struct Aldex2EffectFeature { + feature_name : String + rab_all : Double + rab_group_a : Double + rab_group_b : Double + diff_between : Double + diff_within : Double + effect : Double + effect_low : Double + effect_high : Double + overlap : Double +} derive(Eq, Debug) + +///| +pub struct Aldex2EffectResult { + features : Array[Aldex2EffectFeature] + group_a : String + group_b : String + paired : Bool + interval_level : Double +} + +///| +pub struct Aldex2Result { + clr : Aldex2Clr + tests : Aldex2TestResult + effects : Aldex2EffectResult +} + +///| +pub struct Aldex2Summary { + feature_count : Int + sample_count : Int + removed_feature_count : Int + significant_welch_count : Int + significant_wilcoxon_count : Int + large_effect_count : Int + group_a : String + group_b : String + mc_samples : Int + denominator : String + scale_model : Bool +} derive(Eq, Debug) + +///| +pub struct Aldex2SummarizedExperimentOutput { + experiment : SummarizedExperiment + result : Aldex2Result +} + +///| +fn aldex2_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn aldex2_log2(value : Double) -> Double { + @math.ln(value) / @math.ln(2.0) +} + +///| +fn aldex2_mean(values : Array[Double]) -> Double { + if values.length() == 0 { + return 0.0 + } + let mut total = 0.0 + for value in values { + total = total + value + } + total / values.length().to_double() +} + +///| +fn aldex2_variance(values : Array[Double]) -> Double { + if values.length() < 2 { + return 0.0 + } + let center = aldex2_mean(values) + let mut total = 0.0 + for value in values { + let delta = value - center + total = total + delta * delta + } + total / (values.length() - 1).to_double() +} + +///| +fn aldex2_quantile(values : Array[Double], probability : Double) -> Double { + if values.length() == 0 { + return 0.0 + } + let sorted = values.copy() + sorted.sort_by(fn(left : Double, right : Double) -> Int { + if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + if sorted.length() == 1 { + return sorted[0] + } + let position = probability.max(0.0).min(1.0) * + (sorted.length() - 1).to_double() + let lower = @math.floor(position).to_int() + let upper = (lower + 1).min(sorted.length() - 1) + let fraction = position - lower.to_double() + sorted[lower] * (1.0 - fraction) + sorted[upper] * fraction +} + +///| +fn aldex2_median(values : Array[Double]) -> Double { + aldex2_quantile(values, 0.5) +} + +///| +fn aldex2_default_names(prefix : String, count : Int) -> Array[String] { + let names : Array[String] = [] + for index in 0.. Unit raise Aldex2Error { + if names.length() != expected { + raise Aldex2Error("ALDEx2 " + label + " name count does not match data") + } + for index in 0.. (Array[String], Array[Array[Int]]) raise Aldex2Error { + let names : Array[String] = [] + let indices : Array[Array[Int]] = [] + for sample in 0.. Array[Int] { + let output : Array[Int] = [] + for index in 0.. Bool { + for value in values { + if value == target { + return true + } + } + false +} + +///| +fn aldex2_intersection(left : Array[Int], right : Array[Int]) -> Array[Int] { + let output : Array[Int] = [] + for value in left { + if aldex2_contains(right, value) { + output.push(value) + } + } + output +} + +///| +fn aldex2_lcg(state : Int) -> (Int, Double) { + let normalized = (state - 1) % 2147483646 + 1 + let quotient = normalized / 44488 + let remainder = normalized % 44488 + let candidate = 48271 * remainder - 3399 * quotient + let next = if candidate > 0 { candidate } else { candidate + 2147483647 } + (next, next.to_double() / 2147483647.0) +} + +///| +fn aldex2_normal(state : Int) -> (Int, Double) { + let (state1, raw1) = aldex2_lcg(state) + let (state2, raw2) = aldex2_lcg(state1) + let first = raw1.max(1.0e-15) + let value = (-2.0 * @math.ln(first)).sqrt() * + @math.cos(6.283185307179586 * raw2) + (state2, value) +} + +///| +fn aldex2_gamma(shape : Double, state : Int) -> (Int, Double) { + if shape < 1.0 { + let (state1, uniform) = aldex2_lcg(state) + let (state2, sampled) = aldex2_gamma(shape + 1.0, state1) + return (state2, sampled * @math.exp(@math.ln(uniform.max(1.0e-15)) / shape)) + } + let d = shape - 1.0 / 3.0 + let c = 1.0 / (9.0 * d).sqrt() + let mut current = state + while true { + let (state1, normal) = aldex2_normal(current) + current = state1 + let base = 1.0 + c * normal + if base > 0.0 { + let volume = base * base * base + let (state2, uniform) = aldex2_lcg(current) + current = state2 + if uniform < 1.0 - 0.0331 * normal * normal * normal * normal { + return (current, d * volume) + } + if @math.ln(uniform.max(1.0e-15)) < + 0.5 * normal * normal + d * (1.0 - volume + @math.ln(volume)) { + return (current, d * volume) + } + } + } + (current, shape) +} + +///| +fn aldex2_pseudoclr( + counts : Array[Array[Double]], + prior : Double, +) -> Array[Array[Double]] { + let feature_count = counts.length() + let sample_count = counts[0].length() + let output : Array[Array[Double]] = [] + for sample in 0.. Array[Double] { + let feature_count = transformed[0].length() + let output : Array[Double] = [] + for feature in 0.. Array[Int] raise Aldex2Error { + let transformed = aldex2_pseudoclr(counts, prior) + let sets : Array[Array[Int]] = [] + for samples in group_indices { + let variances = aldex2_variances_for_samples(transformed, samples) + let lower = aldex2_quantile(variances, 0.25) + let upper = aldex2_quantile(variances, 0.75) + let selected : Array[Int] = [] + for feature in 0.. lower && variances[feature] < upper { + selected.push(feature) + } + } + sets.push(selected) + } + let all_samples = aldex2_all_indices(transformed.length()) + let all_variances = aldex2_variances_for_samples(transformed, all_samples) + let all_lower = aldex2_quantile(all_variances, 0.25) + let all_upper = aldex2_quantile(all_variances, 0.75) + let all_selected : Array[Int] = [] + for feature in 0.. all_lower && all_variances[feature] < all_upper { + all_selected.push(feature) + } + } + sets.push(all_selected) + let mut intersection = sets[0].copy() + for index in 1.. Array[Int] raise Aldex2Error { + let transformed = aldex2_pseudoclr(counts, prior) + let sets : Array[Array[Int]] = [] + for samples in group_indices { + let variances = aldex2_variances_for_samples(transformed, samples) + let abundances : Array[Double] = [] + for feature in 0..= abundance_cutoff { + selected.push(feature) + } + } + sets.push(selected) + } + let mut intersection = sets[0].copy() + for index in 1.. Array[Array[Int]] raise Aldex2Error { + let feature_count = counts.length() + let shared = match config.denominator { + Aldex2Iqlr => aldex2_iqlr_indices(counts, groups, config.prior) + Aldex2Lvha => aldex2_lvha_indices(counts, groups, config.prior) + Aldex2User => { + let selected : Array[Int] = [] + for index in config.denominator_indices { + if index < 0 || index >= feature_count { + raise Aldex2Error( + "ALDEx2 user denominator feature index is out of bounds", + ) + } + if aldex2_contains(selected, index) { + raise Aldex2Error( + "ALDEx2 user denominator contains duplicate feature indices", + ) + } + selected.push(index) + } + selected + } + _ => aldex2_all_indices(feature_count) + } + let by_group : Array[Array[Int]] = [] + if config.denominator == Aldex2Zero { + for samples in groups { + let selected : Array[Int] = [] + for feature in 0.. 0.0 { + selected.push(feature) + } + } + if selected.length() == 0 { + raise Aldex2Error( + "ALDEx2 zero denominator has no observed features in a condition", + ) + } + by_group.push(selected) + } + } else { + for _ in groups { + by_group.push(shared.copy()) + } + } + let by_sample : Array[Array[Int]] = [] + for sample in 0.. Unit raise Aldex2Error { + if scale_samples.length() == 0 { + return + } + if scale_samples.length() != sample_count { + raise Aldex2Error("ALDEx2 scale sample rows must match samples") + } + for sample in 0.. Aldex2Clr raise Aldex2Error { + if counts.length() == 0 { + raise Aldex2Error("ALDEx2 count matrix must contain features") + } + let sample_count = counts[0].length() + if sample_count == 0 { + raise Aldex2Error("ALDEx2 count matrix must contain samples") + } + if conditions.length() != sample_count { + raise Aldex2Error("ALDEx2 condition count must match samples") + } + let supplied_features = if feature_names.length() == 0 { + aldex2_default_names("feature_", counts.length()) + } else { + feature_names.copy() + } + let supplied_samples = if sample_names.length() == 0 { + aldex2_default_names("sample_", sample_count) + } else { + sample_names.copy() + } + aldex2_validate_names(supplied_features, counts.length(), "feature") + aldex2_validate_names(supplied_samples, sample_count, "sample") + let library_sizes = Array::make(sample_count, 0.0) + let filtered_counts : Array[Array[Double]] = [] + let filtered_names : Array[String] = [] + let original_indices : Array[Int] = [] + for feature in 0.. 1.0e-9 { + raise Aldex2Error("ALDEx2 counts must be integers") + } + copied.push(value) + row_total = row_total + value + library_sizes[sample] = library_sizes[sample] + value + } + if row_total > 0.0 { + filtered_counts.push(copied) + filtered_names.push(supplied_features[feature]) + original_indices.push(feature) + } + } + if filtered_counts.length() == 0 { + raise Aldex2Error("ALDEx2 count matrix contains only zero features") + } + for sample in 0..= counts.length() { + raise Aldex2Error( + "ALDEx2 user denominator feature index is out of bounds", + ) + } + let mut filtered_index = -1 + for index in 0.. 0 { + let scale = aldex2_log2(scale_samples[sample][instance]) + for feature in 0.. Int { + self.feature_names.length() +} + +///| +pub fn Aldex2Clr::sample_count(self : Aldex2Clr) -> Int { + self.sample_names.length() +} + +///| +pub fn Aldex2Clr::mc_sample_count(self : Aldex2Clr) -> Int { + self.config.mc_samples +} + +///| +pub fn Aldex2Clr::removed_feature_count(self : Aldex2Clr) -> Int { + self.original_feature_count - self.feature_count() +} + +///| +pub fn Aldex2Clr::sample_instance( + self : Aldex2Clr, + sample : Int, + instance : Int, +) -> Array[Double]? { + if sample < 0 || + sample >= self.sample_count() || + instance < 0 || + instance >= self.config.mc_samples { + return None + } + let output : Array[Double] = [] + for feature in 0.. Array[Double]? { + if feature < 0 || + feature >= self.feature_count() || + instance < 0 || + instance >= self.config.mc_samples { + return None + } + let output : Array[Double] = [] + for sample in 0.. Double? { + if feature < 0 || + feature >= self.feature_count() || + sample < 0 || + sample >= self.sample_count() { + return None + } + Some(aldex2_median(self.analysis[sample][feature])) +} + +///| +pub fn Aldex2Clr::expected_proportion( + self : Aldex2Clr, + feature : Int, + sample : Int, +) -> Double? { + if feature < 0 || + feature >= self.feature_count() || + sample < 0 || + sample >= self.sample_count() { + return None + } + Some(aldex2_median(self.dirichlet[sample][feature])) +} + +///| +fn aldex2_welch( + group_a : Array[Double], + group_b : Array[Double], +) -> (Double, Double) { + if group_a.length() < 2 || group_b.length() < 2 { + return (0.0, 1.0) + } + let mean_a = aldex2_mean(group_a) + let mean_b = aldex2_mean(group_b) + let variance_a = aldex2_variance(group_a) + let variance_b = aldex2_variance(group_b) + let component_a = variance_a / group_a.length().to_double() + let component_b = variance_b / group_b.length().to_double() + let standard_error = (component_a + component_b).sqrt() + if standard_error <= 1.0e-15 { + if (mean_a - mean_b).abs() <= 1.0e-15 { + return (0.0, 1.0) + } + return (if mean_b > mean_a { 1.0e12 } else { -1.0e12 }, 0.0) + } + let statistic = (mean_b - mean_a) / standard_error + let denominator = component_a * + component_a / + (group_a.length() - 1).to_double() + + component_b * component_b / (group_b.length() - 1).to_double() + let degrees = if denominator > 0.0 { + (component_a + component_b) * (component_a + component_b) / denominator + } else { + (group_a.length() + group_b.length() - 2).to_double() + } + let p_value = (2.0 * (1.0 - stat_t_cdf(statistic.abs(), degrees))) + .max(0.0) + .min(1.0) + (statistic, p_value) +} + +///| +fn aldex2_paired_t( + group_a : Array[Double], + group_b : Array[Double], +) -> (Double, Double) { + if group_a.length() != group_b.length() || group_a.length() < 2 { + return (0.0, 1.0) + } + let differences : Array[Double] = [] + for index in 0.. 0.0 { 1.0e12 } else { -1.0e12 }, 0.0) + } + let statistic = center / standard_error + let p_value = (2.0 * + (1.0 - stat_t_cdf(statistic.abs(), (differences.length() - 1).to_double()))) + .max(0.0) + .min(1.0) + (statistic, p_value) +} + +///| +fn aldex2_bh_adjust(p_values : Array[Double]) -> Array[Double] { + let count = p_values.length() + if count == 0 { + return [] + } + let sorted : Array[(Double, Int)] = [] + for index in 0.. Int { + if left.0 < right.0 { + -1 + } else if left.0 > right.0 { + 1 + } else { + left.1 - right.1 + } + }) + let adjusted = Array::make(count, 1.0) + let mut running_minimum = 1.0 + let mut rank = count - 1 + while rank >= 0 { + let candidate = (sorted[rank].0 * count.to_double() / (rank + 1).to_double()).min( + 1.0, + ) + running_minimum = running_minimum.min(candidate) + adjusted[sorted[rank].1] = running_minimum + rank = rank - 1 + } + adjusted +} + +///| +pub fn aldex2_ttest(clr : Aldex2Clr) -> Aldex2TestResult raise Aldex2Error { + if clr.group_names.length() != 2 { + raise Aldex2Error("ALDEx2 t-test requires exactly two conditions") + } + if clr.group_indices[0].length() < 2 || clr.group_indices[1].length() < 2 { + raise Aldex2Error( + "ALDEx2 t-test requires at least two replicates per condition", + ) + } + let feature_count = clr.feature_count() + let mc_samples = clr.config.mc_samples + let welch : Array[Array[Double]] = [] + let wilcoxon : Array[Array[Double]] = [] + let welch_adjusted : Array[Array[Double]] = [] + let wilcoxon_adjusted : Array[Array[Double]] = [] + for _ in 0.. Array[Double] { + let output : Array[Double] = [] + for sample in samples { + for instance in 0.. (Array[Double], Array[Double]) { + let between : Array[Double] = [] + let within : Array[Double] = [] + for instance in 0.. (Array[Double], Array[Double]) { + let between : Array[Double] = [] + for instance in 0.. Aldex2EffectResult raise Aldex2Error { + if clr.group_names.length() != 2 { + raise Aldex2Error( + "ALDEx2 effect estimation requires exactly two conditions", + ) + } + if clr.group_indices[0].length() < 2 || clr.group_indices[1].length() < 2 { + raise Aldex2Error( + "ALDEx2 effect estimation requires at least two replicates per condition", + ) + } + let all_samples = aldex2_all_indices(clr.sample_count()) + let alpha = (1.0 - clr.config.interval_level) / 2.0 + let features : Array[Aldex2EffectFeature] = [] + for feature in 0.. 1.0e-12 { + between[index] / spread + } else if between[index].abs() <= 1.0e-12 { + 0.0 + } else { + between[index] / 1.0e-12 + } + effect_distribution.push(effect) + if effect < 0.0 { + negative = negative + 1 + } else if effect > 0.0 { + positive = positive + 1 + } + } + let overlap_denominator = (negative + positive).to_double() + 1.0 + let overlap = if overlap_denominator > 0.0 { + (negative.min(positive).to_double() + 0.5) / overlap_denominator + } else { + 0.5 + } + features.push(Aldex2EffectFeature::{ + feature_name: clr.feature_names[feature], + rab_all: aldex2_median(pooled_all), + rab_group_a: aldex2_median(pooled_a), + rab_group_b: aldex2_median(pooled_b), + diff_between: aldex2_median(between), + diff_within: aldex2_median(within), + effect: aldex2_median(effect_distribution), + effect_low: aldex2_quantile(effect_distribution, alpha), + effect_high: aldex2_quantile(effect_distribution, 1.0 - alpha), + overlap, + }) + } + Aldex2EffectResult::{ + features, + group_a: clr.group_names[0], + group_b: clr.group_names[1], + paired: clr.config.paired, + interval_level: clr.config.interval_level, + } +} + +///| +pub fn aldex2( + counts : Array[Array[Double]], + conditions : Array[String], + config? : Aldex2Config = Aldex2Config::default(), + feature_names? : Array[String] = [], + sample_names? : Array[String] = [], + scale_samples? : Array[Array[Double]] = [], +) -> Aldex2Result raise Aldex2Error { + let clr = aldex2_clr( + counts, + conditions, + config~, + feature_names~, + sample_names~, + scale_samples~, + ) + let tests = aldex2_ttest(clr) + let effects = aldex2_effect(clr) + Aldex2Result::{ clr, tests, effects } +} + +///| +pub fn Aldex2TestResult::find_feature( + self : Aldex2TestResult, + name : String, +) -> Aldex2TestFeature? { + for feature in self.features { + if feature.feature_name == name { + return Some(feature) + } + } + None +} + +///| +pub fn Aldex2EffectResult::find_feature( + self : Aldex2EffectResult, + name : String, +) -> Aldex2EffectFeature? { + for feature in self.features { + if feature.feature_name == name { + return Some(feature) + } + } + None +} + +///| +pub fn Aldex2Result::select( + self : Aldex2Result, + maximum_adjusted? : Double = 0.05, + minimum_effect? : Double = 1.0, +) -> Array[Aldex2EffectFeature] { + let selected : Array[Aldex2EffectFeature] = [] + for index in 0..= minimum_effect { + selected.push(self.effects.features[index]) + } + } + selected +} + +///| +pub fn Aldex2Result::ranked(self : Aldex2Result) -> Array[Aldex2EffectFeature] { + let ranked = self.effects.features.copy() + ranked.sort_by(fn( + left : Aldex2EffectFeature, + right : Aldex2EffectFeature, + ) -> Int { + if left.effect.abs() > right.effect.abs() { + -1 + } else if left.effect.abs() < right.effect.abs() { + 1 + } else if left.feature_name < right.feature_name { + -1 + } else if left.feature_name > right.feature_name { + 1 + } else { + 0 + } + }) + ranked +} + +///| +fn aldex2_denominator_name(value : Aldex2Denominator) -> String { + match value { + Aldex2All => "all" + Aldex2Median => "median" + Aldex2Iqlr => "iqlr" + Aldex2Zero => "zero" + Aldex2Lvha => "lvha" + Aldex2User => "user" + } +} + +///| +pub fn Aldex2Result::summary( + self : Aldex2Result, + maximum_adjusted? : Double = 0.05, + minimum_effect? : Double = 1.0, +) -> Aldex2Summary { + let mut welch_count = 0 + let mut wilcoxon_count = 0 + let mut effect_count = 0 + for index in 0..= minimum_effect { + effect_count = effect_count + 1 + } + } + Aldex2Summary::{ + feature_count: self.clr.feature_count(), + sample_count: self.clr.sample_count(), + removed_feature_count: self.clr.removed_feature_count(), + significant_welch_count: welch_count, + significant_wilcoxon_count: wilcoxon_count, + large_effect_count: effect_count, + group_a: self.tests.group_a, + group_b: self.tests.group_b, + mc_samples: self.clr.config.mc_samples, + denominator: aldex2_denominator_name(self.clr.config.denominator), + scale_model: self.clr.scale_samples.length() > 0, + } +} + +///| +pub fn Aldex2Clr::expected_distance(self : Aldex2Clr) -> Array[Array[Double]] { + let sample_count = self.sample_count() + let distances : Array[Array[Double]] = [] + for _ in 0.. String { + let buffer = StringBuilder::new() + buffer.write_string( + "feature\trab.all\trab.group.a\trab.group.b\tdiff.btw\tdiff.win\teffect\teffect.low\teffect.high\toverlap\twe.ep\twe.eBH\twi.ep\twi.eBH\n", + ) + for index in 0.. SummarizedExperiment { + let assays : Map[String, Array[Array[Double]]] = Map([]) + for key in experiment.assays.keys() { + let matrix : Array[Array[Double]] = [] + for row in experiment.assays[key] { + matrix.push(row.copy()) + } + assays[key] = matrix + } + let metadata : Map[String, String] = Map([]) + for key in experiment.metadata.keys() { + metadata[key] = experiment.metadata[key] + } + SummarizedExperiment::{ + assays, + row_ranges: experiment.row_ranges.copy(), + col_data: experiment.col_data.copy(), + metadata, + } +} + +///| +pub fn aldex2_summarized_experiment( + experiment : SummarizedExperiment, + conditions : Array[String], + config? : Aldex2Config = Aldex2Config::default(), + assay_name? : String = "counts", + feature_names? : Array[String] = [], + sample_names? : Array[String] = [], + scale_samples? : Array[Array[Double]] = [], +) -> Aldex2SummarizedExperimentOutput raise Aldex2Error { + let counts = match se_assay(experiment, assay_name) { + Some(value) => value + None => + raise Aldex2Error( + "ALDEx2 SummarizedExperiment assay not found: " + assay_name, + ) + } + let result = aldex2( + counts, + conditions, + config~, + feature_names~, + sample_names~, + scale_samples~, + ) + let enriched = aldex2_copy_experiment(experiment) + let effect = Array::make(result.clr.original_feature_count, [0.0]) + let overlap = Array::make(result.clr.original_feature_count, [1.0]) + let welch = Array::make(result.clr.original_feature_count, [1.0]) + let wilcoxon = Array::make(result.clr.original_feature_count, [1.0]) + for index in 0.. ( + Array[Array[Double]], + Array[String], + Array[String], + Array[String], +) { + let counts = [ + [120.0, 132.0, 115.0, 126.0, 480.0, 510.0, 495.0, 525.0], + [360.0, 340.0, 375.0, 355.0, 88.0, 95.0, 82.0, 90.0], + [210.0, 220.0, 205.0, 215.0, 225.0, 218.0, 230.0, 222.0], + [75.0, 82.0, 78.0, 80.0, 92.0, 86.0, 89.0, 94.0], + [42.0, 38.0, 45.0, 40.0, 44.0, 41.0, 43.0, 39.0], + [18.0, 24.0, 20.0, 22.0, 19.0, 21.0, 23.0, 20.0], + [6.0, 8.0, 5.0, 7.0, 26.0, 30.0, 28.0, 32.0], + [14.0, 12.0, 16.0, 13.0, 15.0, 14.0, 13.0, 16.0], + [90.0, 96.0, 88.0, 93.0, 97.0, 91.0, 95.0, 92.0], + [33.0, 36.0, 31.0, 35.0, 34.0, 32.0, 37.0, 33.0], + [55.0, 51.0, 58.0, 54.0, 57.0, 53.0, 56.0, 52.0], + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + ] + let conditions = [ + "control", "control", "control", "control", "treated", "treated", "treated", + "treated", + ] + let features = [ + "increased", "decreased", "stable_high", "mild", "stable_1", "stable_2", "rare_increased", + "stable_3", "stable_4", "stable_5", "stable_6", "all_zero", + ] + let samples = ["C1", "C2", "C3", "C4", "T1", "T2", "T3", "T4"] + (counts, conditions, features, samples) +} diff --git a/test/moonbit/aldex2_test.mbt b/test/moonbit/aldex2_test.mbt new file mode 100644 index 00000000..74101365 --- /dev/null +++ b/test/moonbit/aldex2_test.mbt @@ -0,0 +1,1449 @@ +// Tests for the Bioconductor ALDEx2-inspired compositional inference module. + +///| +fn aldex2_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "ALDEx2 value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn aldex2_test_config() -> @src.Aldex2Config { + @src.Aldex2Config::create( + mc_samples=32, + denominator=@src.Aldex2Iqlr, + seed=2026, + ) catch { + _ => abort("ALDEx2 test configuration should be valid") + } +} + +///| +fn aldex2_test_clr() -> @src.Aldex2Clr { + let (counts, conditions, features, samples) = @src.aldex2_example_data() + let config = aldex2_test_config() + @src.aldex2_clr( + counts, + conditions, + config~, + feature_names=features, + sample_names=samples, + ) catch { + Aldex2Error(message) => abort("ALDEx2 CLR should succeed: " + message) + } +} + +///| +fn aldex2_test_result() -> @src.Aldex2Result { + let (counts, conditions, features, samples) = @src.aldex2_example_data() + let config = aldex2_test_config() + @src.aldex2( + counts, + conditions, + config~, + feature_names=features, + sample_names=samples, + ) catch { + Aldex2Error(message) => abort("ALDEx2 example should succeed: " + message) + } +} + +///| +fn aldex2_test_effect( + result : @src.Aldex2Result, + name : String, +) -> @src.Aldex2EffectFeature { + match result.effects.find_feature(name) { + Some(value) => value + None => abort("expected ALDEx2 effect feature: " + name) + } +} + +///| +fn aldex2_test_statistics( + result : @src.Aldex2Result, + name : String, +) -> @src.Aldex2TestFeature { + match result.tests.find_feature(name) { + Some(value) => value + None => abort("expected ALDEx2 test feature: " + name) + } +} + +///| +fn aldex2_test_unwrap(values : Array[Double]?) -> Array[Double] { + match values { + Some(value) => value + None => abort("expected an ALDEx2 posterior slice") + } +} + +///| +fn aldex2_test_median(values : Array[Double]) -> Double { + let sorted = values.copy() + sorted.sort_by(fn(left : Double, right : Double) -> Int { + if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + if sorted.length() % 2 == 1 { + sorted[sorted.length() / 2] + } else { + (sorted[sorted.length() / 2 - 1] + sorted[sorted.length() / 2]) / 2.0 + } +} + +///| +fn aldex2_test_scale( + sample_count : Int, + mc_samples : Int, + value : Double, +) -> Array[Array[Double]] { + let scales : Array[Array[Double]] = [] + for _ in 0.. @src.SummarizedExperiment { + let (counts, _, _, _) = @src.aldex2_example_data() + let assays : Map[String, Array[Array[Double]]] = Map([("counts", counts)]) + let metadata : Map[String, String] = Map([("source", "aldex2_test")]) + @src.summarized_experiment(assays, [], [], metadata) +} + +///| +test "aldex2: default configuration matches upstream controls" { + let config = @src.Aldex2Config::default() + assert_eq(config.mc_samples, 128) + assert_eq(config.prior, 0.5) + assert_eq(config.denominator, @src.Aldex2All) + assert_eq(config.denominator_indices, []) + assert_eq(config.seed, 42) + assert_false(config.paired) + assert_eq(config.interval_level, 0.95) +} + +///| +test "aldex2: custom configuration preserves controls" { + let config = @src.Aldex2Config::create( + mc_samples=16, + prior=1.0, + denominator=@src.Aldex2User, + denominator_indices=[1, 3], + seed=99, + paired=true, + interval_level=0.9, + ) catch { + _ => abort("custom ALDEx2 configuration should be valid") + } + assert_eq(config.mc_samples, 16) + assert_eq(config.prior, 1.0) + assert_eq(config.denominator_indices, [1, 3]) + assert_eq(config.seed, 99) + assert_true(config.paired) + assert_eq(config.interval_level, 0.9) +} + +///| +test "aldex2: configuration rejects nonpositive Monte Carlo count" { + let raised = try { + ignore(@src.Aldex2Config::create(mc_samples=0)) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: configuration rejects nonpositive prior" { + let zero = try { + ignore(@src.Aldex2Config::create(prior=0.0)) + false + } catch { + Aldex2Error(_) => true + } + let negative = try { + ignore(@src.Aldex2Config::create(prior=-0.5)) + false + } catch { + Aldex2Error(_) => true + } + assert_true(zero) + assert_true(negative) +} + +///| +test "aldex2: configuration rejects nonpositive seed" { + let raised = try { + ignore(@src.Aldex2Config::create(seed=0)) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) + let config = @src.Aldex2Config::create(mc_samples=4, seed=2147483647) catch { + _ => abort("maximum Park-Miller seed should be normalized") + } + let clr = @src.aldex2_clr( + [[1.0, 2.0, 3.0, 4.0], [2.0, 3.0, 4.0, 5.0]], + ["A", "A", "B", "B"], + config~, + ) catch { + _ => abort("normalized Park-Miller seed should support sampling") + } + assert_eq(clr.mc_sample_count(), 4) +} + +///| +test "aldex2: configuration rejects invalid intervals" { + let zero = try { + ignore(@src.Aldex2Config::create(interval_level=0.0)) + false + } catch { + Aldex2Error(_) => true + } + let one = try { + ignore(@src.Aldex2Config::create(interval_level=1.0)) + false + } catch { + Aldex2Error(_) => true + } + assert_true(zero) + assert_true(one) +} + +///| +test "aldex2: user denominator requires feature indices" { + let raised = try { + ignore(@src.Aldex2Config::create(denominator=@src.Aldex2User)) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: denominator indices require user mode" { + let raised = try { + ignore( + @src.Aldex2Config::create(denominator=@src.Aldex2All, denominator_indices=[ + 0, + ]), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: example data uses feature by sample orientation" { + let (counts, conditions, features, samples) = @src.aldex2_example_data() + assert_eq(counts.length(), 12) + assert_eq(counts[0].length(), 8) + assert_eq(conditions.length(), 8) + assert_eq(features.length(), 12) + assert_eq(samples.length(), 8) +} + +///| +test "aldex2: example labels identify intended signals" { + let (_, conditions, features, samples) = @src.aldex2_example_data() + assert_eq(features[0], "increased") + assert_eq(features[1], "decreased") + assert_eq(features[11], "all_zero") + assert_eq(conditions[0], "control") + assert_eq(conditions[4], "treated") + assert_eq(samples[0], "C1") + assert_eq(samples[7], "T4") +} + +///| +test "aldex2: CLR dimensions match retained data" { + let clr = aldex2_test_clr() + assert_eq(clr.feature_count(), 11) + assert_eq(clr.sample_count(), 8) + assert_eq(clr.mc_sample_count(), 32) +} + +///| +test "aldex2: all-zero features are removed" { + let clr = aldex2_test_clr() + assert_eq(clr.removed_feature_count(), 1) + assert_eq(clr.original_feature_count, 12) + assert_eq(clr.original_feature_indices.length(), 11) + assert_eq(clr.original_feature_indices[10], 10) +} + +///| +test "aldex2: supplied feature and sample names are retained" { + let clr = aldex2_test_clr() + assert_eq(clr.feature_names[0], "increased") + assert_eq(clr.feature_names[10], "stable_6") + assert_eq(clr.sample_names[0], "C1") + assert_eq(clr.sample_names[7], "T4") +} + +///| +test "aldex2: omitted names are generated deterministically" { + let clr = @src.aldex2_clr( + [[10.0, 11.0, 20.0, 21.0], [5.0, 6.0, 7.0, 8.0]], + ["A", "A", "B", "B"], + config=@src.Aldex2Config::create(mc_samples=4) catch { + _ => abort("small ALDEx2 configuration should succeed") + }, + ) catch { + _ => abort("small ALDEx2 CLR should succeed") + } + assert_eq(clr.feature_names, ["feature_1", "feature_2"]) + assert_eq(clr.sample_names, ["sample_1", "sample_2", "sample_3", "sample_4"]) +} + +///| +test "aldex2: empty feature matrix is rejected" { + let raised = try { + ignore(@src.aldex2_clr([], ["A", "A", "B", "B"])) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: empty sample matrix is rejected" { + let raised = try { + ignore(@src.aldex2_clr([[]], [])) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: condition count must match samples" { + let raised = try { + ignore(@src.aldex2_clr([[1.0, 2.0]], ["A"])) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: ragged count matrices are rejected" { + let raised = try { + ignore( + @src.aldex2_clr([[1.0, 2.0, 3.0, 4.0], [1.0, 2.0]], ["A", "A", "B", "B"]), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: negative counts are rejected" { + let raised = try { + ignore(@src.aldex2_clr([[1.0, -1.0, 3.0, 4.0]], ["A", "A", "B", "B"])) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: fractional counts are rejected" { + let raised = try { + ignore(@src.aldex2_clr([[1.0, 2.5, 3.0, 4.0]], ["A", "A", "B", "B"])) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: nonfinite counts are rejected" { + let nonfinite = 1.0 / 0.0 + let raised = try { + ignore(@src.aldex2_clr([[1.0, nonfinite, 3.0, 4.0]], ["A", "A", "B", "B"])) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: all-zero data are rejected" { + let raised = try { + ignore(@src.aldex2_clr([[0.0, 0.0, 0.0, 0.0]], ["A", "A", "B", "B"])) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: empty sample libraries are rejected" { + let raised = try { + ignore( + @src.aldex2_clr([[1.0, 0.0, 2.0, 3.0], [1.0, 0.0, 2.0, 3.0]], [ + "A", "A", "B", "B", + ]), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: feature name count is validated" { + let raised = try { + ignore( + @src.aldex2_clr([[1.0, 2.0, 3.0, 4.0]], ["A", "A", "B", "B"], feature_names=[ + "one", "two", + ]), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: sample name count is validated" { + let raised = try { + ignore( + @src.aldex2_clr([[1.0, 2.0, 3.0, 4.0]], ["A", "A", "B", "B"], sample_names=[ + "one", + ]), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: empty names are rejected" { + let feature = try { + ignore( + @src.aldex2_clr([[1.0, 2.0, 3.0, 4.0]], ["A", "A", "B", "B"], feature_names=[ + "", + ]), + ) + false + } catch { + Aldex2Error(_) => true + } + let sample = try { + ignore( + @src.aldex2_clr([[1.0, 2.0, 3.0, 4.0]], ["A", "A", "B", "B"], sample_names=[ + "s1", "s2", " ", "s4", + ]), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(feature) + assert_true(sample) +} + +///| +test "aldex2: duplicate names are rejected" { + let feature = try { + ignore( + @src.aldex2_clr( + [[1.0, 2.0, 3.0, 4.0], [2.0, 3.0, 4.0, 5.0]], + ["A", "A", "B", "B"], + feature_names=["same", "same"], + ), + ) + false + } catch { + Aldex2Error(_) => true + } + let sample = try { + ignore( + @src.aldex2_clr([[1.0, 2.0, 3.0, 4.0]], ["A", "A", "B", "B"], sample_names=[ + "s", "s", "t1", "t2", + ]), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(feature) + assert_true(sample) +} + +///| +test "aldex2: empty condition labels are rejected" { + let raised = try { + ignore(@src.aldex2_clr([[1.0, 2.0, 3.0, 4.0]], ["A", " ", "B", "B"])) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: at least two conditions are required" { + let raised = try { + ignore(@src.aldex2_clr([[1.0, 2.0, 3.0, 4.0]], ["A", "A", "A", "A"])) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: paired analysis requires two conditions" { + let config = @src.Aldex2Config::create(mc_samples=4, paired=true) catch { + _ => abort("paired ALDEx2 configuration should succeed") + } + let raised = try { + ignore( + @src.aldex2_clr( + [[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]], + ["A", "A", "B", "B", "C", "C"], + config~, + ), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: paired groups require equal sample counts" { + let config = @src.Aldex2Config::create(mc_samples=4, paired=true) catch { + _ => abort("paired ALDEx2 configuration should succeed") + } + let raised = try { + ignore( + @src.aldex2_clr( + [[1.0, 2.0, 3.0, 4.0, 5.0]], + ["A", "A", "B", "B", "B"], + config~, + ), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: scale sample row count is validated" { + let config = @src.Aldex2Config::create(mc_samples=4) catch { + _ => abort("scale ALDEx2 configuration should succeed") + } + let raised = try { + ignore( + @src.aldex2_clr([[1.0, 2.0, 3.0, 4.0]], ["A", "A", "B", "B"], config~, scale_samples=[ + [1.0, 1.0, 1.0, 1.0], + ]), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: scale sample column count is validated" { + let config = @src.Aldex2Config::create(mc_samples=4) catch { + _ => abort("scale ALDEx2 configuration should succeed") + } + let raised = try { + ignore( + @src.aldex2_clr([[1.0, 2.0, 3.0, 4.0]], ["A", "A", "B", "B"], config~, scale_samples=[ + [1.0], + [1.0], + [1.0], + [1.0], + ]), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: scale samples must be finite and positive" { + let config = @src.Aldex2Config::create(mc_samples=2) catch { + _ => abort("scale ALDEx2 configuration should succeed") + } + let raised = try { + ignore( + @src.aldex2_clr([[1.0, 2.0, 3.0, 4.0]], ["A", "A", "B", "B"], config~, scale_samples=[ + [1.0, 1.0], + [1.0, 0.0], + [1.0, 1.0], + [1.0, 1.0], + ]), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: user denominator validates bounds" { + let config = @src.Aldex2Config::create( + mc_samples=4, + denominator=@src.Aldex2User, + denominator_indices=[2], + ) catch { + _ => abort("user ALDEx2 configuration should succeed") + } + let raised = try { + ignore( + @src.aldex2_clr( + [[1.0, 2.0, 3.0, 4.0], [2.0, 3.0, 4.0, 5.0]], + ["A", "A", "B", "B"], + config~, + ), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) + let zero_config = @src.Aldex2Config::create( + mc_samples=4, + denominator=@src.Aldex2User, + denominator_indices=[0], + ) catch { + _ => abort("all-zero denominator configuration should succeed") + } + let zero_raised = try { + ignore( + @src.aldex2_clr( + [[0.0, 0.0, 0.0, 0.0], [2.0, 3.0, 4.0, 5.0]], + ["A", "A", "B", "B"], + config=zero_config, + ), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(zero_raised) +} + +///| +test "aldex2: user denominator rejects duplicates" { + let config = @src.Aldex2Config::create( + mc_samples=4, + denominator=@src.Aldex2User, + denominator_indices=[0, 0], + ) catch { + _ => abort("user ALDEx2 configuration should succeed") + } + let raised = try { + ignore( + @src.aldex2_clr( + [[1.0, 2.0, 3.0, 4.0], [2.0, 3.0, 4.0, 5.0]], + ["A", "A", "B", "B"], + config~, + ), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: IQLR reports insufficient invariant features" { + let config = @src.Aldex2Config::create( + mc_samples=4, + denominator=@src.Aldex2Iqlr, + ) catch { + _ => abort("IQLR ALDEx2 configuration should succeed") + } + let raised = try { + ignore( + @src.aldex2_clr( + [[10.0, 11.0, 20.0, 21.0], [5.0, 6.0, 7.0, 8.0]], + ["A", "A", "B", "B"], + config~, + ), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: LVHA reports insufficient shared features" { + let config = @src.Aldex2Config::create( + mc_samples=4, + denominator=@src.Aldex2Lvha, + ) catch { + _ => abort("LVHA ALDEx2 configuration should succeed") + } + let raised = try { + ignore( + @src.aldex2_clr([[10.0, 11.0, 20.0, 21.0]], ["A", "A", "B", "B"], config~), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: posterior cube dimensions follow samples features and instances" { + let clr = aldex2_test_clr() + assert_eq(clr.dirichlet.length(), 8) + assert_eq(clr.dirichlet[0].length(), 11) + assert_eq(clr.dirichlet[0][0].length(), 32) + assert_eq(clr.analysis.length(), 8) + assert_eq(clr.analysis[0].length(), 11) + assert_eq(clr.analysis[0][0].length(), 32) +} + +///| +test "aldex2: every Dirichlet instance sums to one" { + let clr = aldex2_test_clr() + for sample in 0.. 0.0) + assert_true(value < 1.0) + assert_true(value == value) + } + } + } +} + +///| +test "aldex2: all denominator centers each CLR instance at zero" { + let config = @src.Aldex2Config::create(mc_samples=8) catch { + _ => abort("all-denominator ALDEx2 configuration should succeed") + } + let clr = @src.aldex2_clr( + [[10.0, 12.0, 20.0, 22.0], [5.0, 6.0, 8.0, 9.0], [3.0, 4.0, 5.0, 6.0]], + ["A", "A", "B", "B"], + config~, + ) catch { + _ => abort("all-denominator ALDEx2 CLR should succeed") + } + for sample in 0.. abort("median ALDEx2 configuration should succeed") + } + let clr = @src.aldex2_clr( + [ + [10.0, 12.0, 20.0, 22.0], + [5.0, 6.0, 8.0, 9.0], + [3.0, 4.0, 5.0, 6.0], + [9.0, 8.0, 7.0, 6.0], + ], + ["A", "A", "B", "B"], + config~, + ) catch { + _ => abort("median ALDEx2 CLR should succeed") + } + for sample in 0.. abort("first ALDEx2 configuration should succeed") + }, + feature_names=features, + sample_names=samples, + ) catch { + _ => abort("first ALDEx2 CLR should succeed") + } + let second = @src.aldex2_clr( + counts, + conditions, + config=@src.Aldex2Config::create(mc_samples=4, seed=2) catch { + _ => abort("second ALDEx2 configuration should succeed") + }, + feature_names=features, + sample_names=samples, + ) catch { + _ => abort("second ALDEx2 CLR should succeed") + } + assert_true(first.dirichlet != second.dirichlet) +} + +///| +test "aldex2: low-shape gamma path remains finite" { + let config = @src.Aldex2Config::create(mc_samples=16, prior=0.1) catch { + _ => abort("low-prior ALDEx2 configuration should succeed") + } + let clr = @src.aldex2_clr( + [[0.0, 0.0, 1.0, 1.0], [1.0, 1.0, 0.0, 0.0]], + ["A", "A", "B", "B"], + config~, + ) catch { + _ => abort("low-shape ALDEx2 CLR should succeed") + } + for feature in 0.. 0.0) + assert_true(value == value) + } + } +} + +///| +test "aldex2: posterior slice queries validate bounds" { + let clr = aldex2_test_clr() + assert_true(clr.sample_instance(0, 0) is Some(_)) + assert_true(clr.feature_instance(0, 0) is Some(_)) + assert_true(clr.sample_instance(-1, 0) is None) + assert_true(clr.sample_instance(0, 32) is None) + assert_true(clr.feature_instance(11, 0) is None) + assert_true(clr.feature_instance(0, -1) is None) +} + +///| +test "aldex2: posterior slice queries use documented orientation" { + let clr = aldex2_test_clr() + let sample = aldex2_test_unwrap(clr.sample_instance(0, 0)) + let feature = aldex2_test_unwrap(clr.feature_instance(0, 0)) + assert_eq(sample.length(), 11) + assert_eq(feature.length(), 8) + aldex2_test_close(sample[0], feature[0], 0.0) +} + +///| +test "aldex2: expected CLR query validates indices" { + let clr = aldex2_test_clr() + assert_true(clr.expected_clr(0, 0) is Some(_)) + assert_true(clr.expected_clr(-1, 0) is None) + assert_true(clr.expected_clr(0, 8) is None) +} + +///| +test "aldex2: expected proportions are bounded" { + let clr = aldex2_test_clr() + for feature in 0.. value + None => abort("expected ALDEx2 proportion") + } + assert_true(value > 0.0) + assert_true(value < 1.0) + } + assert_true(clr.expected_proportion(11, 0) is None) +} + +///| +test "aldex2: IQLR finds shared invariant features in example data" { + let clr = aldex2_test_clr() + assert_true(clr.denominator_by_sample[0].length() >= 2) + for sample in 1.. abort("LVHA ALDEx2 configuration should succeed") + } + let clr = @src.aldex2_clr( + [ + [100.0, 100.0, 100.0, 100.0], + [90.0, 90.0, 90.0, 90.0], + [80.0, 80.0, 80.0, 80.0], + [70.0, 70.0, 70.0, 70.0], + [60.0, 60.0, 60.0, 60.0], + [50.0, 50.0, 50.0, 50.0], + [40.0, 40.0, 40.0, 40.0], + [30.0, 30.0, 30.0, 30.0], + ], + ["A", "A", "B", "B"], + config~, + ) catch { + Aldex2Error(message) => abort("LVHA ALDEx2 CLR should succeed: " + message) + } + assert_true(clr.denominator_by_sample[0].length() >= 2) + assert_eq(clr.denominator_by_sample[0], clr.denominator_by_sample[3]) +} + +///| +test "aldex2: zero denominator is condition specific" { + let config = @src.Aldex2Config::create( + mc_samples=4, + denominator=@src.Aldex2Zero, + ) catch { + _ => abort("zero ALDEx2 configuration should succeed") + } + let clr = @src.aldex2_clr( + [[10.0, 11.0, 0.0, 0.0], [0.0, 0.0, 12.0, 13.0], [5.0, 6.0, 7.0, 8.0]], + ["A", "A", "B", "B"], + config~, + ) catch { + _ => abort("zero-denominator ALDEx2 CLR should succeed") + } + assert_eq(clr.denominator_by_sample[0], [0, 2]) + assert_eq(clr.denominator_by_sample[1], [0, 2]) + assert_eq(clr.denominator_by_sample[2], [1, 2]) + assert_eq(clr.denominator_by_sample[3], [1, 2]) +} + +///| +test "aldex2: user denominator centers selected features" { + let config = @src.Aldex2Config::create( + mc_samples=4, + denominator=@src.Aldex2User, + denominator_indices=[1, 3], + ) catch { + _ => abort("user ALDEx2 configuration should succeed") + } + let clr = @src.aldex2_clr( + [ + [0.0, 0.0, 0.0, 0.0], + [10.0, 11.0, 20.0, 21.0], + [5.0, 6.0, 8.0, 9.0], + [3.0, 4.0, 5.0, 6.0], + ], + ["A", "A", "B", "B"], + config~, + ) catch { + _ => abort("user-denominator ALDEx2 CLR should succeed") + } + assert_eq(clr.denominator_by_sample[0], [0, 2]) + assert_eq(clr.removed_feature_count(), 1) + let values = aldex2_test_unwrap(clr.sample_instance(0, 0)) + aldex2_test_close((values[0] + values[2]) / 2.0, 0.0, 1.0e-12) +} + +///| +test "aldex2: scale samples shift log abundance by log2 scale" { + let config = @src.Aldex2Config::create(mc_samples=4, seed=7) catch { + _ => abort("scale ALDEx2 configuration should succeed") + } + let counts = [ + [10.0, 11.0, 20.0, 21.0], + [5.0, 6.0, 8.0, 9.0], + [3.0, 4.0, 5.0, 6.0], + ] + let conditions = ["A", "A", "B", "B"] + let unit = @src.aldex2_clr( + counts, + conditions, + config~, + scale_samples=aldex2_test_scale(4, 4, 1.0), + ) catch { + _ => abort("unit-scale ALDEx2 CLR should succeed") + } + let four = @src.aldex2_clr( + counts, + conditions, + config~, + scale_samples=aldex2_test_scale(4, 4, 4.0), + ) catch { + _ => abort("four-scale ALDEx2 CLR should succeed") + } + let unit_values = aldex2_test_unwrap(unit.sample_instance(0, 0)) + let four_values = aldex2_test_unwrap(four.sample_instance(0, 0)) + for feature in 0.. abort("scale ALDEx2 configuration should succeed") + } + let counts = [ + [10.0, 11.0, 20.0, 21.0], + [5.0, 6.0, 8.0, 9.0], + [3.0, 4.0, 5.0, 6.0], + ] + let conditions = ["A", "A", "B", "B"] + let first = @src.aldex2_clr( + counts, + conditions, + config~, + scale_samples=aldex2_test_scale(4, 4, 1.0), + ) catch { + _ => abort("first scale ALDEx2 CLR should succeed") + } + let second = @src.aldex2_clr( + counts, + conditions, + config~, + scale_samples=aldex2_test_scale(4, 4, 10.0), + ) catch { + _ => abort("second scale ALDEx2 CLR should succeed") + } + let first_values = aldex2_test_unwrap(first.sample_instance(0, 0)) + let second_values = aldex2_test_unwrap(second.sample_instance(0, 0)) + aldex2_test_close( + first_values[0] - first_values[1], + second_values[0] - second_values[1], + 1.0e-12, + ) +} + +///| +test "aldex2: CLR construction permits multi-condition designs" { + let clr = @src.aldex2_clr( + [[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], [6.0, 5.0, 4.0, 3.0, 2.0, 1.0]], + ["A", "A", "B", "B", "C", "C"], + config=@src.Aldex2Config::create(mc_samples=4) catch { + _ => abort("multi-condition ALDEx2 configuration should succeed") + }, + ) catch { + _ => abort("multi-condition ALDEx2 CLR should succeed") + } + assert_eq(clr.group_names, ["A", "B", "C"]) + assert_eq(clr.group_indices, [[0, 1], [2, 3], [4, 5]]) +} + +///| +test "aldex2: t-test requires exactly two conditions" { + let clr = @src.aldex2_clr( + [[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], [6.0, 5.0, 4.0, 3.0, 2.0, 1.0]], + ["A", "A", "B", "B", "C", "C"], + config=@src.Aldex2Config::create(mc_samples=4) catch { + _ => abort("multi-condition ALDEx2 configuration should succeed") + }, + ) catch { + _ => abort("multi-condition ALDEx2 CLR should succeed") + } + let raised = try { + ignore(@src.aldex2_ttest(clr)) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: tests require two replicates per condition" { + let clr = @src.aldex2_clr( + [[1.0, 2.0, 3.0], [3.0, 2.0, 1.0]], + ["A", "B", "B"], + config=@src.Aldex2Config::create(mc_samples=4) catch { + _ => abort("small ALDEx2 configuration should succeed") + }, + ) catch { + _ => abort("small ALDEx2 CLR should succeed") + } + let raised = try { + ignore(@src.aldex2_ttest(clr)) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} + +///| +test "aldex2: posterior tests preserve feature metadata" { + let result = aldex2_test_result() + assert_eq(result.tests.features.length(), 11) + assert_eq(result.tests.features[0].feature_name, "increased") + assert_eq(result.tests.group_a, "control") + assert_eq(result.tests.group_b, "treated") + assert_false(result.tests.paired) + assert_eq(result.tests.mc_samples, 32) +} + +///| +test "aldex2: posterior expected p-values are bounded" { + let result = aldex2_test_result() + for feature in result.tests.features { + assert_true(feature.welch_p_value >= 0.0) + assert_true(feature.welch_p_value <= 1.0) + assert_true(feature.wilcoxon_p_value >= 0.0) + assert_true(feature.wilcoxon_p_value <= 1.0) + } +} + +///| +test "aldex2: posterior BH values are bounded and conservative" { + let result = aldex2_test_result() + for feature in result.tests.features { + assert_true(feature.welch_adjusted >= feature.welch_p_value - 1.0e-12) + assert_true(feature.welch_adjusted <= 1.0) + assert_true(feature.wilcoxon_adjusted >= feature.wilcoxon_p_value - 1.0e-12) + assert_true(feature.wilcoxon_adjusted <= 1.0) + } +} + +///| +test "aldex2: strong example signals have expected effect directions" { + let result = aldex2_test_result() + assert_true(aldex2_test_effect(result, "increased").effect > 3.0) + assert_true(aldex2_test_effect(result, "decreased").effect < -3.0) + assert_true(aldex2_test_effect(result, "rare_increased").effect > 1.0) +} + +///| +test "aldex2: strong example signals have small Welch eBH" { + let result = aldex2_test_result() + assert_true(aldex2_test_statistics(result, "increased").welch_adjusted < 0.01) + assert_true(aldex2_test_statistics(result, "decreased").welch_adjusted < 0.01) + assert_true( + aldex2_test_statistics(result, "rare_increased").welch_adjusted < 0.1, + ) +} + +///| +test "aldex2: stable feature remains near zero" { + let result = aldex2_test_result() + let stable = aldex2_test_effect(result, "stable_high") + assert_true(stable.effect.abs() < 1.0) + assert_true(stable.overlap > 0.2) + assert_true( + aldex2_test_statistics(result, "stable_high").welch_adjusted > 0.2, + ) +} + +///| +test "aldex2: effect intervals contain posterior medians" { + let result = aldex2_test_result() + for feature in result.effects.features { + assert_true(feature.effect_low <= feature.effect) + assert_true(feature.effect_high >= feature.effect) + } +} + +///| +test "aldex2: effect overlap is a bounded sign probability" { + let result = aldex2_test_result() + for feature in result.effects.features { + assert_true(feature.overlap > 0.0) + assert_true(feature.overlap <= 0.5) + } + assert_true( + aldex2_test_effect(result, "increased").overlap < + aldex2_test_effect(result, "stable_high").overlap, + ) +} + +///| +test "aldex2: paired analysis uses paired test and effect paths" { + let (counts, conditions, features, samples) = @src.aldex2_example_data() + let config = @src.Aldex2Config::create( + mc_samples=32, + denominator=@src.Aldex2Iqlr, + seed=2026, + paired=true, + ) catch { + _ => abort("paired ALDEx2 configuration should succeed") + } + let result = @src.aldex2( + counts, + conditions, + config~, + feature_names=features, + sample_names=samples, + ) catch { + _ => abort("paired ALDEx2 analysis should succeed") + } + assert_true(result.tests.paired) + assert_true(result.effects.paired) + assert_true(aldex2_test_effect(result, "increased").effect > 1.0) + assert_true(aldex2_test_effect(result, "decreased").effect < -1.0) +} + +///| +test "aldex2: result selection combines BH and effect thresholds" { + let result = aldex2_test_result() + let selected = result.select(maximum_adjusted=0.1, minimum_effect=1.0) + assert_true(selected.length() >= 3) + for feature in selected { + assert_true(feature.effect.abs() >= 1.0) + assert_true( + aldex2_test_statistics(result, feature.feature_name).welch_adjusted <= 0.1, + ) + } +} + +///| +test "aldex2: result ranking orders absolute effects descending" { + let ranked = aldex2_test_result().ranked() + assert_eq(ranked.length(), 11) + for index in 1..= ranked[index].effect.abs()) + } + assert_true( + ranked[0].feature_name == "increased" || + ranked[0].feature_name == "decreased", + ) +} + +///| +test "aldex2: result summary reports analysis controls" { + let summary = aldex2_test_result().summary( + maximum_adjusted=0.1, + minimum_effect=1.0, + ) + assert_eq(summary.feature_count, 11) + assert_eq(summary.sample_count, 8) + assert_eq(summary.removed_feature_count, 1) + assert_eq(summary.group_a, "control") + assert_eq(summary.group_b, "treated") + assert_eq(summary.mc_samples, 32) + assert_eq(summary.denominator, "iqlr") + assert_false(summary.scale_model) + assert_true(summary.significant_welch_count >= 3) + assert_true(summary.large_effect_count >= 3) +} + +///| +test "aldex2: scaled analysis is recorded in summary" { + let (counts, conditions, features, samples) = @src.aldex2_example_data() + let config = @src.Aldex2Config::create(mc_samples=8) catch { + _ => abort("scaled ALDEx2 configuration should succeed") + } + let result = @src.aldex2( + counts, + conditions, + config~, + feature_names=features, + sample_names=samples, + scale_samples=aldex2_test_scale(8, 8, 1.0), + ) catch { + _ => abort("scaled ALDEx2 analysis should succeed") + } + assert_true(result.summary().scale_model) +} + +///| +test "aldex2: expected distance matrix matches sample count" { + let distances = aldex2_test_clr().expected_distance() + assert_eq(distances.length(), 8) + for row in distances { + assert_eq(row.length(), 8) + } +} + +///| +test "aldex2: expected distances are symmetric with zero diagonal" { + let distances = aldex2_test_clr().expected_distance() + for left in 0..= 0.0) + } + } + assert_true(distances[0][4] > 0.0) +} + +///| +test "aldex2: TSV export contains upstream-style columns and rows" { + let table = aldex2_test_result().to_tsv() + assert_true(table.has_prefix("feature\trab.all\trab.group.a")) + assert_true(table.contains("\twe.ep\twe.eBH\twi.ep\twi.eBH\n")) + assert_true(table.contains("increased\t")) + assert_true(table.contains("decreased\t")) + assert_false(table.contains("all_zero\t")) +} + +///| +test "aldex2: feature lookup returns none for unknown names" { + let result = aldex2_test_result() + assert_true(result.tests.find_feature("missing") is None) + assert_true(result.effects.find_feature("missing") is None) +} + +///| +test "aldex2: SummarizedExperiment output adds posterior assays" { + let experiment = aldex2_test_experiment() + let (_, conditions, features, samples) = @src.aldex2_example_data() + let config = aldex2_test_config() + let output = @src.aldex2_summarized_experiment( + experiment, + conditions, + config~, + feature_names=features, + sample_names=samples, + ) catch { + _ => abort("ALDEx2 SummarizedExperiment integration should succeed") + } + for + name in [ + "aldex2_effect", "aldex2_overlap", "aldex2_welch_bh", "aldex2_wilcoxon_bh", + ] { + let assay = match @src.se_assay(output.experiment, name) { + Some(value) => value + None => abort("expected ALDEx2 assay: " + name) + } + assert_eq(assay.length(), 12) + assert_eq(assay[0].length(), 1) + } +} + +///| +test "aldex2: SummarizedExperiment reinserts filtered zero features" { + let experiment = aldex2_test_experiment() + let (_, conditions, features, samples) = @src.aldex2_example_data() + let config = aldex2_test_config() + let output = @src.aldex2_summarized_experiment( + experiment, + conditions, + config~, + feature_names=features, + sample_names=samples, + ) catch { + _ => abort("ALDEx2 SummarizedExperiment integration should succeed") + } + let effect = match @src.se_assay(output.experiment, "aldex2_effect") { + Some(value) => value + None => abort("ALDEx2 effect assay missing") + } + let welch = match @src.se_assay(output.experiment, "aldex2_welch_bh") { + Some(value) => value + None => abort("ALDEx2 Welch assay missing") + } + assert_eq(effect[11], [0.0]) + assert_eq(welch[11], [1.0]) +} + +///| +test "aldex2: SummarizedExperiment integration is immutable" { + let experiment = aldex2_test_experiment() + let (_, conditions, features, samples) = @src.aldex2_example_data() + let config = aldex2_test_config() + let output = @src.aldex2_summarized_experiment( + experiment, + conditions, + config~, + feature_names=features, + sample_names=samples, + ) catch { + _ => abort("ALDEx2 SummarizedExperiment integration should succeed") + } + assert_true(@src.se_assay(experiment, "aldex2_effect") is None) + assert_true(experiment.metadata.get("aldex2_mc_samples") is None) + assert_eq(output.experiment.metadata["source"], "aldex2_test") + assert_eq(output.experiment.metadata["aldex2_mc_samples"], "32") + assert_eq(output.experiment.metadata["aldex2_denominator"], "iqlr") + assert_eq(output.experiment.metadata["aldex2_groups"], "control,treated") +} + +///| +test "aldex2: SummarizedExperiment rejects missing assays" { + let experiment = aldex2_test_experiment() + let (_, conditions, features, samples) = @src.aldex2_example_data() + let raised = try { + ignore( + @src.aldex2_summarized_experiment( + experiment, + conditions, + assay_name="missing", + feature_names=features, + sample_names=samples, + ), + ) + false + } catch { + Aldex2Error(_) => true + } + assert_true(raised) +} From 32ececbccaf9378d5640b5ed09cc50abb2f8cdcd Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 11:07:33 +0800 Subject: [PATCH 24/41] #28 feat(alignment): Biopython Alignment.counts & BLOSUM45 --- README.md | 26 +- examples/alignment_counts_demo/main.mbt | 131 ++++ examples/alignment_counts_demo/moon.pkg | 5 + src/alignment_counts.mbt | 849 +++++++++++++++++++++++ src/subsmat.mbt | 278 ++++---- test/moonbit/alignment_counts_test.mbt | 852 ++++++++++++++++++++++++ 6 files changed, 1999 insertions(+), 142 deletions(-) create mode 100644 examples/alignment_counts_demo/main.mbt create mode 100644 examples/alignment_counts_demo/moon.pkg create mode 100644 src/alignment_counts.mbt create mode 100644 test/moonbit/alignment_counts_test.mbt diff --git a/README.md b/README.md index 36cd5756..03e99f67 100644 --- a/README.md +++ b/README.md @@ -33,6 +33,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **SearchIO** | Biopython `Bio.SearchIO` | 统一搜索结果模型、HMMER3/Infernal解析、BLAT PSL解析、BLAST转换 | ✅ | | **HH-suite HHR** | Biopython `Bio.Align.hhr` | HHsearch/HHblits HHR解析、profile-profile比对、命中筛选、坐标映射、序列化往返 | ✅ | | **共享参考比对合并** | Biopython `Bio.Align.Alignment` | 合并共享同一参考序列的PWA/MSA、同步insertion slots、保留局部坐标与metadata、双向坐标映射 | ✅ | +| **Alignment详细统计** | Biopython `Bio.Align.Alignment.counts` | 左/内部/右 insertion/deletion、gap open/extend、identity/mismatch/positive、wildcard、替换矩阵和十二类affine gap评分 | ✅ | | **系统发育树** | Biopython `Bio.Phylo` | 树结构、Newick 解析、距离计算、可视化 | ✅ | | **PDB 结构** | Biopython `Bio.PDB` | 原子/残基/链解析、结构操作 | ✅ | | **BinaryCIF** | Biopython `Bio.PDB.binary_cif` | MessagePack解析、七类逆编码、三态缺失值、类别查询、PDB Structure转换 | ✅ | @@ -160,6 +161,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | Bioconductor variancePartition | 多随机截距线性混合模型、ML/REML方差分量、固定/随机/残差方差占比、precision weights、BLUP、dream contrast、数值Satterthwaite检验、BH-FDR与SummarizedExperiment接入 | | ✅ | Bio.Align.Alignment shared-reference merge | 共享参考PWA/MSA合并、reference-boundary insertion slot同步、局部reference/query坐标、metadata、统计、MSA与aligned FASTA转换 | | ✅ | Bio.Align.Alignment map/mapall | 零起始半开区间alignment path组合、局部clipping、gap与正反链传播、双向坐标查询、PSL、批量map及protein MSA到codon-aware nucleotide MSA投影 | +| ✅ | Bio.Align.Alignment counts | pairwise/MSA详细gap分类、open/extend事件、identity/mismatch/positive、wildcard、替换矩阵与完整affine总分 | | ✅ | Bio.Align.bigbed | BigBed v4二进制读写、BED3-BED12、AutoSQL扩展字段、多级chromosome B+ tree与R-tree、zlib/DEFLATE解码、区间/名称查询和BED导出 | | ✅ | Bio.Align.bigmaf | 标准bedMaf bed3+1读写、完整MAF a/s/i/e/q语义、正负链坐标映射、BigBed压缩索引查询、MAF导出和严格损坏数据诊断 | | ✅ | Bioconductor decontX | 单细胞ambient RNA去污染: cluster-native/contaminant多项式混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解、诊断与SingleCellExperiment接入 | @@ -221,6 +223,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **HH-suite HHR** | Biopython `Bio.Align.hhr` | HHR元数据、命中摘要、多块profile比对、consensus/二级结构/DSSP/confidence注释、概率和E-value查询 | ✅ | | **共享参考比对合并** | Biopython `Bio.Align.Alignment.from_alignments_with_same_reference` | 混合PWA/MSA输入、首端/内部/末端insertion同步、多query投影、局部坐标与metadata保留、统计和格式转换 | ✅ | | **Alignment坐标组合** | Biopython `Bio.Align.Alignment.map/mapall` | alignment path组合、局部overhang clipping、exon/intron与indel gap、正反链组合、坐标双向查询、PSL及1:1/1:3 MSA投影 | ✅ | +| **Alignment详细计数与评分** | Biopython `Bio.Align.Alignment.counts` | 十二类affine gap事件、identity/mismatch/positive、wildcard、BLOSUM/PAM评分、反向链和MSA全部序列对汇总 | ✅ | | **BigBed二进制区间索引** | Biopython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12与AutoSQL、多级B+ tree/R-tree、stored/fixed/dynamic DEFLATE、区间/名称查询、链感知exon坐标及BED导出 | ✅ | | **BigMaf多物种比对索引** | Biopython `Bio.Align.bigmaf` | 标准bedMaf AutoSQL、MAF a/s/i/e/q块、score/pass/comment、正负链坐标映射、压缩BigBed索引查询及普通MAF导出 | ✅ | | **BigPsl成对比对索引** | Biopython `Bio.Align.bigpsl` | 标准bed12+13 AutoSQL、核酸与translated protein坐标路径、正反链、match/repeat/N recount、压缩索引查询及PSL导出 | ✅ | @@ -368,6 +371,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **MAF格式解析** | Biopython `Bio.Align` | MAF多序列比对格式解析、块操作、百分比一致性、统计分析、选择/过滤/写回 | ✅ | | **HH-suite HHR格式** | Biopython `Bio.Align.hhr` | HHsearch/HHblits结果严格解析、0-based坐标、query-target映射、规范化写回 | ✅ | | **共享参考比对同步** | Biopython `Bio.Align.Alignment` | 相同参考PWA/MSA合并、边界插入宽度归一化、query原始比对结构保留、reference/query/column坐标互映 | ✅ | +| **Alignment gap/composition统计** | Biopython `Bio.Align.Alignment.counts` | pairwise与MSA逐对统计、端部/内部gap分类、open/extend事件、替换和gap总分 | ✅ | | **UCSC Chain文件/liftOver** | Bioconductor rtracklayer | Chain格式解析、基因组坐标liftOver转换、链段查找、染色体间坐标映射、位置/区间转换 | ✅ | | **Biostrings matchPDict** | Bioconductor Biostrings | 字典模式匹配(matchPDict/vmatchPattern)、多序列模式计数(vcountPattern)、错配容忍、最佳匹配查找 | ✅ | | **GenomicRanges gaps/reduce/disjoin** | Bioconductor GenomicRanges | gaps检测、reduce合并、disjoin拆分、setdiff/交集/并集集合运算、coverage计算、promoters提取、trim | ✅ | @@ -425,6 +429,7 @@ IvanAXu/BioSeqs/ │ ├── align.mbt # MultipleSeqAlignment 多序列比对 │ ├── shared_reference_alignment.mbt # Bio.Align共享参考PWA/MSA合并、insertion slot同步与坐标映射 │ ├── alignment_map.mbt # Bio.Align.Alignment map/mapall坐标路径组合与MSA投影 +│ ├── alignment_counts.mbt # Bio.Align.Alignment.counts详细gap/composition统计与评分 │ ├── bigbed.mbt # Bio.Align.bigbed v4、BED/AutoSQL、多级B+ tree/R-tree与DEFLATE │ ├── bigmaf.mbt # Bio.Align.bigmaf bedMaf、MAF注释、链向坐标映射与索引查询 │ ├── bigpsl.mbt # Bio.Align.bigpsl bed12+13、核酸/translated protein路径与PSL @@ -1120,6 +1125,7 @@ IvanAXu/BioSeqs/ │ ├── hhr_demo/ # HH-suite HHR解析、命中筛选、坐标映射与序列化往返示例 │ ├── shared_reference_alignment_demo/ # 共享参考PWA/MSA合并、insertion同步、坐标映射与FASTA转换示例 │ ├── alignment_map_demo/ # Alignment.map/mapall、反链、PSL与protein-to-codon MSA投影示例 +│ ├── alignment_counts_demo/ # Alignment.counts gap分类、affine/BLOSUM评分、反链与MSA汇总示例 │ ├── bigbed_demo/ # BigBed写入/解析、索引查询、负链exon坐标、BED导出与损坏诊断 │ ├── bigmaf_demo/ # BigMaf压缩写入、bedMaf schema、区间查询、负链映射与MAF导出 │ ├── bigpsl_demo/ # BigPsl压缩写入、R-tree查询、反链/translated坐标与PSL导出 @@ -1328,6 +1334,7 @@ IvanAXu/BioSeqs/ │ │ ├── dreamlet_test.mbt │ │ ├── shared_reference_alignment_test.mbt │ │ ├── alignment_map_test.mbt +│ │ ├── alignment_counts_test.mbt │ │ ├── bigbed_test.mbt │ │ ├── bigmaf_test.mbt │ │ ├── bigpsl_test.mbt @@ -1554,6 +1561,7 @@ moon test # ✅ 9116 个测试全 | `hhr.mbt` | BioPython `Bio.Align.hhr` | HHsearch/HHblits HHR解析、profile比对注释、命中筛选、坐标映射与规范序列化 | | `shared_reference_alignment.mbt` | BioPython `Bio.Align.Alignment.from_alignments_with_same_reference` | 共享参考PWA/MSA合并、insertion slot同步、局部坐标、双向映射、统计、MSA与FASTA转换 | | `alignment_map.mbt` | BioPython `Bio.Align.Alignment.map/mapall` | alignment path组合、local clipping、gap与链向传播、双向坐标查询、PSL、map_many及codon-aware MSA投影 | +| `alignment_counts.mbt` | BioPython `Bio.Align.Alignment.counts` | left/internal/right insertion/deletion、open/extend、composition、wildcard、替换矩阵与十二类affine gap评分 | | `bigbed.mbt` | BioPython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12、AutoSQL、多级chromosome B+ tree/R-tree、zlib/DEFLATE及索引查询 | | `bigmaf.mbt` | BioPython `Bio.Align.bigmaf` | bedMaf bed3+1读写、MAF a/s/i/e/q、正负链坐标映射、压缩索引查询、摘要和MAF导出 | | `bigpsl.mbt` | BioPython `Bio.Align.bigpsl` | bed12+13读写、核酸/translated protein路径、双向坐标映射、recount、压缩查询、摘要和PSL导出 | @@ -1827,6 +1835,7 @@ moon test # ✅ 9116 个测试全 | `dreamlet.mbt` | `dreamlet` | SCE到sample×cluster pseudobulk、TMM/logCPM、两阶段voom precision weights、固定/随机效应筛选、逐cell-type dream和study-wide FDR | | `shared_reference_alignment.mbt` | `Bio.Align.Alignment` | 同参考PWA/MSA的reference-boundary insertion同步、原query投影、局部坐标、metadata、统计与格式转换 | | `alignment_map.mbt` | `Bio.Align.Alignment.map/mapall` | 两层alignment坐标组合、正反链与gap传播、PSL、批量映射及protein/nucleotide MSA投影 | +| `alignment_counts.mbt` | `Bio.Align.Alignment.counts` | pairwise/MSA gap事件和composition汇总、正反链、wildcard、替换矩阵及完整affine评分 | | `bigbed.mbt` | `Bio.Align.bigbed` | BigBed v4二进制读写、BED/AutoSQL、平衡B+ tree/R-tree、完整DEFLATE块解码、区间/名称查询与BED导出 | | `bigmaf.mbt` | `Bio.Align.bigmaf` | bedMaf AutoSQL与MAF块往返、a/s/i/e/q注释、链感知坐标映射、BigBed索引查询和普通MAF导出 | | `bigpsl.mbt` | `Bio.Align.bigpsl` | 标准bigPsl AutoSQL、核酸与translated DNA-protein坐标、链感知映射、match分类、BigBed索引和PSL导出 | @@ -2980,6 +2989,14 @@ MAP 求解器实现阻尼 Newton、Cholesky 信息矩阵求解、逐级 ridge 构造器会诊断 ragged、负数、非整数或非有限计数，空样本文库、名称/condition/配对维度、denominator 和 scale matrix 错误。当前范围不包含 `aldex.glm`、Kruskal-Wallis、相关性、绘图、BiocParallel 或自动 gamma scale uncertainty simulation；effect posterior 使用同一实例内的确定性 pairwise 组合，不保证与上游最多 10000 次随机重采样逐位一致。 +### 259. Alignment 详细计数与评分 (Biopython Bio.Align.Alignment.counts) + +实现 Biopython 1.86 `Alignment.counts` / `AlignmentCounts` 的坐标路径统计模型，并保留原有轻量 `CoordinatePairwiseAlignment::counts()` API。新 `alignment_counts` API 将 gap 分为 left/internal/right insertion 和 deletion 十二类 open/extend 事件；同方向连续 gap 计为 extension，diagonal step 重置 gap path。结果同时提供各层级聚合 getter、aligned、identity、mismatch、positive、gap/substitution/total score 和摘要。 + +composition 支持 wildcard、match/mismatch score 或替换矩阵；矩阵模式计算正分 substitution 的 positives，并对未知 residue 给出明确诊断。gap score 可使用统一 affine、按 insertion/deletion 方向区分，或完整十二参数配置。坐标读取支持反向链的归一化与反向互补；无序列文本时仍可统计坐标和 gap。`CoordinateMultipleAlignment::alignment_counts` 对全部无序序列对求和，并忽略为其他行插入的双 gap 列而保持当前 gap path。 + +实现覆盖路径长度、坐标单调性、aligned step、有限 score 和矩阵 alphabet 校验；专项测试包含官方 BLOSUM62/BLOSUM45 示例、左右/内部 gap、连续 open/extend、wildcard、反向链、length-only alignment 和 MSA 汇总。同步修正既有标准 20×20 `BLOSUM45` 的 139 个错误分值，与 Biopython 1.86 官方矩阵逐项一致。当前 API 统计已有 coordinate alignment，不负责执行新的序列比对。 + ## 性能优化 ### 优化策略 @@ -3081,8 +3098,8 @@ MAP 求解器实现阻尼 Newton、Cholesky 信息矩阵求解、逐级 ridge | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 9196 | -| 通过数 | 9196 | +| 总测试数 | 9253 | +| 通过数 | 9253 | | 失败数 | 0 | | 通过率 | 100% | @@ -3186,6 +3203,7 @@ moon test --update | Bio.Align.hhr | `hhr_test.mbt` | 33 | | Bio.Align shared-reference merge | `shared_reference_alignment_test.mbt` | 41 | | Bio.Align Alignment.map/mapall | `alignment_map_test.mbt` | 44 | +| Bio.Align Alignment.counts | `alignment_counts_test.mbt` | 57 | | Bio.Align.bigbed | `bigbed_test.mbt` | 64 | | Bio.Align.bigmaf | `bigmaf_test.mbt` | 79 | | SparseArray | `sparse_array_test.mbt` | 41 | @@ -3488,7 +3506,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 366 个示例程序，展示各模块的典型用法： +项目提供 367 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3681,6 +3699,7 @@ moon run cmd/bench/main.mbt | dreamlet_demo | SingleCellExperiment pseudobulk、TMM/logCPM、Poisson/voom权重、donor随机截距和跨cell-type FDR | `moon run examples/dreamlet_demo` | | shared_reference_alignment_demo | 共享参考PWA/MSA合并、reference insertion同步、坐标映射、统计、MSA与aligned FASTA转换 | `moon run examples/shared_reference_alignment_demo` | | alignment_map_demo | chromosome→transcript→read坐标组合、intron gap、反链、坐标查询、PSL与protein-to-codon MSA投影 | `moon run examples/alignment_map_demo` | +| alignment_counts_demo | left/internal/right gap与open/extend、affine/BLOSUM45评分、反向链和MSA逐对汇总 | `moon run examples/alignment_counts_demo` | | bigbed_demo | BigBed v4压缩写入/解析、AutoSQL、多级索引查询、负链exon坐标、BED导出及损坏文件诊断 | `moon run examples/bigbed_demo` | | bigmaf_demo | BigMaf压缩bed3+1写入、bedMaf schema、R-tree区间查询、负链物种坐标映射和MAF a/s/i/e/q导出 | `moon run examples/bigmaf_demo` | | bigpsl_demo | BigPsl bed12+13压缩写入、AutoSQL、R-tree查询、反向核酸/translated protein坐标和PSL导出 | `moon run examples/bigpsl_demo` | @@ -3791,6 +3810,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bioconductor dreamlet cohort-scale单细胞重复测量分析（sample×cell-type pseudobulk、TMM、过滤、logCPM、Poisson/voom权重、typed混合模型与study-wide FDR） - ✅ 实现 Bio.Align共享参考序列比对合并（混合PWA/MSA、reference-boundary insertion同步、局部坐标、双向映射、统计与格式转换） - ✅ 实现 Bio.Align.Alignment map/mapall（alignment path组合、local clipping、gap与正反链传播、坐标查询、PSL及protein-to-codon MSA投影） +- ✅ 实现 Bio.Align.Alignment counts（left/internal/right insertion/deletion、gap open/extend、identity/mismatch/positive、wildcard、替换矩阵、affine评分及MSA逐对汇总） - ✅ 实现 Bio.Align.bigbed BigBed v4二进制区间格式（BED3-BED12、AutoSQL、多级B+ tree/R-tree、DEFLATE、区间/名称查询与BED导出） - ✅ 实现 Bio.Align.bigmaf BigMaf多物种比对索引（标准bedMaf、MAF a/s/i/e/q、正负链坐标映射、压缩BigBed查询与MAF导出） - ✅ 实现 Bio.Align.bigpsl BigPsl成对比对索引（标准bed12+13、核酸/translated protein坐标、match recount、压缩BigBed查询与PSL导出） diff --git a/examples/alignment_counts_demo/main.mbt b/examples/alignment_counts_demo/main.mbt new file mode 100644 index 00000000..78f02f79 --- /dev/null +++ b/examples/alignment_counts_demo/main.mbt @@ -0,0 +1,131 @@ +///| +fn show_optional_int(value : Int?) -> String { + match value { + Some(number) => number.to_string() + None => "unknown" + } +} + +///| +fn show_optional_double(value : Double?) -> String { + match value { + Some(number) => number.to_string() + None => "unknown" + } +} + +///| +fn main { + println("=== Biopython Alignment.counts Demo ===") + + println("\n1. Classify and score an internal deletion") + let gapped = @src.coordinate_pairwise_alignment( + "target", + "GAACT", + "query", + "GAT", + [0, 2, 4, 5], + [0, 2, 2, 3], + ) catch { + _ => abort("failed to build gapped alignment") + } + let affine = @src.AlignmentGapScores::affine(-5.0, -1.0) catch { + _ => abort("failed to configure affine gap scores") + } + let scored = @src.AlignmentCountsConfig::scored( + match_score=2.0, + mismatch_score=-1.0, + gap_scores=affine, + ) catch { + _ => abort("failed to configure alignment scoring") + } + let counts = gapped.alignment_counts(config=scored) catch { + _ => abort("failed to calculate detailed counts") + } + println(" " + counts.summary()) + println( + " internal deletions=" + + counts.internal_deletions().to_string() + + " (open=" + + counts.open_internal_deletions.to_string() + + ", extend=" + + counts.extend_internal_deletions.to_string() + + ")", + ) + println( + " substitution=" + + show_optional_double(counts.substitution_score) + + ", gap=" + + show_optional_double(counts.gap_score) + + ", total=" + + show_optional_double(counts.score), + ) + + println("\n2. Count positives with the official BLOSUM45 matrix") + let protein = @src.coordinate_pairwise_alignment( + "protein_1", + "EPQSDPSVEPPLSQETFSDLWKLLPE", + "protein_2", + "EPSSETGMDPPLSQETFEDLWSLLPD", + [0, 26], + [0, 26], + ) catch { + _ => abort("failed to build protein alignment") + } + let protein_counts = protein.alignment_counts( + config=@src.AlignmentCountsConfig::with_matrix(@src.blosum45()), + ) catch { + _ => abort("failed to score protein alignment") + } + println( + " identities=" + + protein_counts.identities.to_string() + + ", mismatches=" + + protein_counts.mismatches.to_string() + + ", positives=" + + show_optional_int(protein_counts.positives) + + ", substitution score=" + + show_optional_double(protein_counts.substitution_score), + ) + + println("\n3. Read residues through a reverse-strand coordinate path") + let reverse = @src.coordinate_pairwise_alignment( + "reference", + "GAACT", + "reverse_read", + "ATC", + [0, 2, 4, 5], + [3, 1, 1, 0], + ) catch { + _ => abort("failed to build reverse-strand alignment") + } + let reverse_counts = reverse.alignment_counts() catch { + _ => abort("failed to count reverse-strand alignment") + } + println(" " + reverse_counts.summary()) + println( + " reverse internal deletions=" + + reverse_counts.internal_deletions().to_string(), + ) + + println("\n4. Sum counts and scores over every unordered MSA row pair") + let msa = @src.coordinate_multiple_alignment(["a", "b", "c"], [ + "A-AA", "AAAA", "A--A", + ]) catch { + _ => abort("failed to build multiple alignment") + } + let msa_counts = msa.alignment_counts(config=scored) catch { + _ => abort("failed to count multiple alignment") + } + println(" " + msa_counts.summary()) + println( + " gap opens=" + + msa_counts.open_gaps().to_string() + + ", gap extensions=" + + msa_counts.extend_gaps().to_string() + + ", total score=" + + show_optional_double(msa_counts.score), + ) + + println("\n=== Demo Complete ===") +} diff --git a/examples/alignment_counts_demo/moon.pkg b/examples/alignment_counts_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/alignment_counts_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/alignment_counts.mbt b/src/alignment_counts.mbt new file mode 100644 index 00000000..a40a8f58 --- /dev/null +++ b/src/alignment_counts.mbt @@ -0,0 +1,849 @@ +// Detailed coordinate alignment statistics compatible with Biopython +// Bio.Align.Alignment.counts and AlignmentCounts. + +///| +/// Error raised while configuring or calculating detailed alignment counts. +pub suberror AlignmentCountsError { + AlignmentCountsError(String) +} + +///| +/// Affine gap scores for each gap side and direction. +/// +/// An insertion is a gap in the target row; a deletion is a gap in the query +/// row. A gap of length n contributes one open score and n - 1 extend scores. +pub struct AlignmentGapScores { + open_left_insertion_score : Double + extend_left_insertion_score : Double + open_left_deletion_score : Double + extend_left_deletion_score : Double + open_internal_insertion_score : Double + extend_internal_insertion_score : Double + open_internal_deletion_score : Double + extend_internal_deletion_score : Double + open_right_insertion_score : Double + extend_right_insertion_score : Double + open_right_deletion_score : Double + extend_right_deletion_score : Double +} derive(Eq, Debug) + +///| +fn alignment_counts_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn alignment_counts_validate_score( + value : Double, + label : String, +) -> Unit raise AlignmentCountsError { + if !alignment_counts_is_finite(value) { + raise AlignmentCountsError(label + " must be finite") + } +} + +///| +/// Construct fully position- and direction-specific affine gap scores. +pub fn AlignmentGapScores::create( + open_left_insertion_score~ : Double, + extend_left_insertion_score~ : Double, + open_left_deletion_score~ : Double, + extend_left_deletion_score~ : Double, + open_internal_insertion_score~ : Double, + extend_internal_insertion_score~ : Double, + open_internal_deletion_score~ : Double, + extend_internal_deletion_score~ : Double, + open_right_insertion_score~ : Double, + extend_right_insertion_score~ : Double, + open_right_deletion_score~ : Double, + extend_right_deletion_score~ : Double, +) -> AlignmentGapScores raise AlignmentCountsError { + let values = [ + open_left_insertion_score, extend_left_insertion_score, open_left_deletion_score, + extend_left_deletion_score, open_internal_insertion_score, extend_internal_insertion_score, + open_internal_deletion_score, extend_internal_deletion_score, open_right_insertion_score, + extend_right_insertion_score, open_right_deletion_score, extend_right_deletion_score, + ] + let labels = [ + "open left insertion score", "extend left insertion score", "open left deletion score", + "extend left deletion score", "open internal insertion score", "extend internal insertion score", + "open internal deletion score", "extend internal deletion score", "open right insertion score", + "extend right insertion score", "open right deletion score", "extend right deletion score", + ] + let mut index = 0 + while index < values.length() { + alignment_counts_validate_score(values[index], labels[index]) + index = index + 1 + } + AlignmentGapScores::{ + open_left_insertion_score, + extend_left_insertion_score, + open_left_deletion_score, + extend_left_deletion_score, + open_internal_insertion_score, + extend_internal_insertion_score, + open_internal_deletion_score, + extend_internal_deletion_score, + open_right_insertion_score, + extend_right_insertion_score, + open_right_deletion_score, + extend_right_deletion_score, + } +} + +///| +/// Use one open score and one extend score for every gap class. +pub fn AlignmentGapScores::affine( + open_score : Double, + extend_score : Double, +) -> AlignmentGapScores raise AlignmentCountsError { + alignment_counts_validate_score(open_score, "gap open score") + alignment_counts_validate_score(extend_score, "gap extend score") + AlignmentGapScores::{ + open_left_insertion_score: open_score, + extend_left_insertion_score: extend_score, + open_left_deletion_score: open_score, + extend_left_deletion_score: extend_score, + open_internal_insertion_score: open_score, + extend_internal_insertion_score: extend_score, + open_internal_deletion_score: open_score, + extend_internal_deletion_score: extend_score, + open_right_insertion_score: open_score, + extend_right_insertion_score: extend_score, + open_right_deletion_score: open_score, + extend_right_deletion_score: extend_score, + } +} + +///| +/// Use direction-specific affine scores independent of gap position. +pub fn AlignmentGapScores::directional( + insertion_open_score~ : Double, + insertion_extend_score~ : Double, + deletion_open_score~ : Double, + deletion_extend_score~ : Double, +) -> AlignmentGapScores raise AlignmentCountsError { + alignment_counts_validate_score(insertion_open_score, "insertion open score") + alignment_counts_validate_score( + insertion_extend_score, "insertion extend score", + ) + alignment_counts_validate_score(deletion_open_score, "deletion open score") + alignment_counts_validate_score( + deletion_extend_score, "deletion extend score", + ) + AlignmentGapScores::{ + open_left_insertion_score: insertion_open_score, + extend_left_insertion_score: insertion_extend_score, + open_left_deletion_score: deletion_open_score, + extend_left_deletion_score: deletion_extend_score, + open_internal_insertion_score: insertion_open_score, + extend_internal_insertion_score: insertion_extend_score, + open_internal_deletion_score: deletion_open_score, + extend_internal_deletion_score: deletion_extend_score, + open_right_insertion_score: insertion_open_score, + extend_right_insertion_score: insertion_extend_score, + open_right_deletion_score: deletion_open_score, + extend_right_deletion_score: deletion_extend_score, + } +} + +///| +/// Optional composition and gap scoring used by `alignment_counts`. +/// +/// A substitution matrix takes precedence over match/mismatch scores. +/// Substitution and gap scores remain unknown unless their corresponding +/// configuration is present. +pub struct AlignmentCountsConfig { + wildcard : Char? + substitution_matrix : SubstitutionMatrix? + match_score : Double? + mismatch_score : Double? + gap_scores : AlignmentGapScores? +} + +///| +pub fn AlignmentCountsConfig::create( + wildcard? : Char? = None, + substitution_matrix? : SubstitutionMatrix? = None, + match_score? : Double? = None, + mismatch_score? : Double? = None, + gap_scores? : AlignmentGapScores? = None, +) -> AlignmentCountsConfig raise AlignmentCountsError { + match (match_score, mismatch_score) { + (Some(match_value), Some(mismatch_value)) => { + alignment_counts_validate_score(match_value, "match score") + alignment_counts_validate_score(mismatch_value, "mismatch score") + } + (None, None) => () + _ => + raise AlignmentCountsError( + "match and mismatch scores must be provided together", + ) + } + AlignmentCountsConfig::{ + wildcard, + substitution_matrix, + match_score, + mismatch_score, + gap_scores, + } +} + +///| +pub fn AlignmentCountsConfig::default() -> AlignmentCountsConfig { + AlignmentCountsConfig::{ + wildcard: None, + substitution_matrix: None, + match_score: None, + mismatch_score: None, + gap_scores: None, + } +} + +///| +/// Configure wildcard-aware counting without calculating scores. +pub fn AlignmentCountsConfig::with_wildcard( + wildcard : Char, +) -> AlignmentCountsConfig { + AlignmentCountsConfig::{ + wildcard: Some(wildcard), + substitution_matrix: None, + match_score: None, + mismatch_score: None, + gap_scores: None, + } +} + +///| +/// Configure substitution scoring and positive-match counting. +pub fn AlignmentCountsConfig::with_matrix( + matrix : SubstitutionMatrix, + wildcard? : Char? = None, +) -> AlignmentCountsConfig { + AlignmentCountsConfig::{ + wildcard, + substitution_matrix: Some(matrix), + match_score: None, + mismatch_score: None, + gap_scores: None, + } +} + +///| +/// Configure complete match/mismatch and affine gap scoring. +pub fn AlignmentCountsConfig::scored( + match_score~ : Double, + mismatch_score~ : Double, + gap_scores~ : AlignmentGapScores, + wildcard? : Char? = None, +) -> AlignmentCountsConfig raise AlignmentCountsError { + alignment_counts_validate_score(match_score, "match score") + alignment_counts_validate_score(mismatch_score, "mismatch score") + AlignmentCountsConfig::{ + wildcard, + substitution_matrix: None, + match_score: Some(match_score), + mismatch_score: Some(mismatch_score), + gap_scores: Some(gap_scores), + } +} + +///| +/// Configure complete substitution-matrix and affine gap scoring. +pub fn AlignmentCountsConfig::scored_matrix( + matrix~ : SubstitutionMatrix, + gap_scores~ : AlignmentGapScores, + wildcard? : Char? = None, +) -> AlignmentCountsConfig { + AlignmentCountsConfig::{ + wildcard, + substitution_matrix: Some(matrix), + match_score: None, + mismatch_score: None, + gap_scores: Some(gap_scores), + } +} + +///| +/// Detailed counts and optional scores for a coordinate alignment. +pub struct AlignmentCounts { + open_left_insertions : Int + extend_left_insertions : Int + open_left_deletions : Int + extend_left_deletions : Int + open_internal_insertions : Int + extend_internal_insertions : Int + open_internal_deletions : Int + extend_internal_deletions : Int + open_right_insertions : Int + extend_right_insertions : Int + open_right_deletions : Int + extend_right_deletions : Int + aligned : Int + identities : Int + mismatches : Int + positives : Int? + gap_score : Double? + substitution_score : Double? + score : Double? +} derive(Debug) + +///| +pub fn AlignmentCounts::left_insertions(self : AlignmentCounts) -> Int { + self.open_left_insertions + self.extend_left_insertions +} + +///| +pub fn AlignmentCounts::internal_insertions(self : AlignmentCounts) -> Int { + self.open_internal_insertions + self.extend_internal_insertions +} + +///| +pub fn AlignmentCounts::right_insertions(self : AlignmentCounts) -> Int { + self.open_right_insertions + self.extend_right_insertions +} + +///| +pub fn AlignmentCounts::left_deletions(self : AlignmentCounts) -> Int { + self.open_left_deletions + self.extend_left_deletions +} + +///| +pub fn AlignmentCounts::internal_deletions(self : AlignmentCounts) -> Int { + self.open_internal_deletions + self.extend_internal_deletions +} + +///| +pub fn AlignmentCounts::right_deletions(self : AlignmentCounts) -> Int { + self.open_right_deletions + self.extend_right_deletions +} + +///| +pub fn AlignmentCounts::open_insertions(self : AlignmentCounts) -> Int { + self.open_left_insertions + + self.open_internal_insertions + + self.open_right_insertions +} + +///| +pub fn AlignmentCounts::extend_insertions(self : AlignmentCounts) -> Int { + self.extend_left_insertions + + self.extend_internal_insertions + + self.extend_right_insertions +} + +///| +pub fn AlignmentCounts::insertions(self : AlignmentCounts) -> Int { + self.open_insertions() + self.extend_insertions() +} + +///| +pub fn AlignmentCounts::open_deletions(self : AlignmentCounts) -> Int { + self.open_left_deletions + + self.open_internal_deletions + + self.open_right_deletions +} + +///| +pub fn AlignmentCounts::extend_deletions(self : AlignmentCounts) -> Int { + self.extend_left_deletions + + self.extend_internal_deletions + + self.extend_right_deletions +} + +///| +pub fn AlignmentCounts::deletions(self : AlignmentCounts) -> Int { + self.open_deletions() + self.extend_deletions() +} + +///| +pub fn AlignmentCounts::open_left_gaps(self : AlignmentCounts) -> Int { + self.open_left_insertions + self.open_left_deletions +} + +///| +pub fn AlignmentCounts::extend_left_gaps(self : AlignmentCounts) -> Int { + self.extend_left_insertions + self.extend_left_deletions +} + +///| +pub fn AlignmentCounts::left_gaps(self : AlignmentCounts) -> Int { + self.open_left_gaps() + self.extend_left_gaps() +} + +///| +pub fn AlignmentCounts::open_internal_gaps(self : AlignmentCounts) -> Int { + self.open_internal_insertions + self.open_internal_deletions +} + +///| +pub fn AlignmentCounts::extend_internal_gaps(self : AlignmentCounts) -> Int { + self.extend_internal_insertions + self.extend_internal_deletions +} + +///| +pub fn AlignmentCounts::internal_gaps(self : AlignmentCounts) -> Int { + self.open_internal_gaps() + self.extend_internal_gaps() +} + +///| +pub fn AlignmentCounts::open_right_gaps(self : AlignmentCounts) -> Int { + self.open_right_insertions + self.open_right_deletions +} + +///| +pub fn AlignmentCounts::extend_right_gaps(self : AlignmentCounts) -> Int { + self.extend_right_insertions + self.extend_right_deletions +} + +///| +pub fn AlignmentCounts::right_gaps(self : AlignmentCounts) -> Int { + self.open_right_gaps() + self.extend_right_gaps() +} + +///| +pub fn AlignmentCounts::open_gaps(self : AlignmentCounts) -> Int { + self.open_insertions() + self.open_deletions() +} + +///| +pub fn AlignmentCounts::extend_gaps(self : AlignmentCounts) -> Int { + self.extend_insertions() + self.extend_deletions() +} + +///| +pub fn AlignmentCounts::gaps(self : AlignmentCounts) -> Int { + self.open_gaps() + self.extend_gaps() +} + +///| +pub fn AlignmentCounts::summary(self : AlignmentCounts) -> String { + "AlignmentCounts(aligned=" + + self.aligned.to_string() + + ", identities=" + + self.identities.to_string() + + ", mismatches=" + + self.mismatches.to_string() + + ", gaps=" + + self.gaps().to_string() + + ")" +} + +///| +struct AlignmentCountsAccumulator { + mut open_left_insertions : Int + mut extend_left_insertions : Int + mut open_left_deletions : Int + mut extend_left_deletions : Int + mut open_internal_insertions : Int + mut extend_internal_insertions : Int + mut open_internal_deletions : Int + mut extend_internal_deletions : Int + mut open_right_insertions : Int + mut extend_right_insertions : Int + mut open_right_deletions : Int + mut extend_right_deletions : Int + mut aligned : Int + mut identities : Int + mut mismatches : Int + mut positives : Int + mut matrix_score : Double +} + +///| +fn alignment_counts_accumulator() -> AlignmentCountsAccumulator { + AlignmentCountsAccumulator::{ + open_left_insertions: 0, + extend_left_insertions: 0, + open_left_deletions: 0, + extend_left_deletions: 0, + open_internal_insertions: 0, + extend_internal_insertions: 0, + open_internal_deletions: 0, + extend_internal_deletions: 0, + open_right_insertions: 0, + extend_right_insertions: 0, + open_right_deletions: 0, + extend_right_deletions: 0, + aligned: 0, + identities: 0, + mismatches: 0, + positives: 0, + matrix_score: 0.0, + } +} + +///| +fn alignment_counts_normalize_coordinates( + coordinates : Array[Int], + sequence_length : Int, + reverse : Bool, +) -> Array[Int] { + let normalized : Array[Int] = [] + for coordinate in coordinates { + normalized.push( + if reverse { + sequence_length - coordinate + } else { + coordinate + }, + ) + } + normalized +} + +///| +fn alignment_counts_complement(value : Char) -> Char { + match value { + 'A' => 'T' + 'a' => 't' + 'C' => 'G' + 'c' => 'g' + 'G' => 'C' + 'g' => 'c' + 'T' => 'A' + 't' => 'a' + 'U' => 'A' + 'u' => 'a' + _ => value + } +} + +///| +fn alignment_counts_residue( + sequence : String, + sequence_length : Int, + position : Int, + reverse : Bool, +) -> Char { + if reverse { + alignment_counts_complement( + sequence.unsafe_get(sequence_length - position - 1).unsafe_to_char(), + ) + } else { + sequence.unsafe_get(position).unsafe_to_char() + } +} + +///| +fn alignment_counts_add_gap( + counts : AlignmentCountsAccumulator, + insertion : Bool, + continuation : Bool, + start : Int, + end : Int, + left : Int, + right : Int, + size : Int, +) -> Unit { + let side = if start == left { 0 } else if end == right { 2 } else { 1 } + let open = if continuation { 0 } else { 1 } + let extend = if continuation { size } else { size - 1 } + if insertion { + if side == 0 { + counts.open_left_insertions = counts.open_left_insertions + open + counts.extend_left_insertions = counts.extend_left_insertions + extend + } else if side == 1 { + counts.open_internal_insertions = counts.open_internal_insertions + open + counts.extend_internal_insertions = counts.extend_internal_insertions + + extend + } else { + counts.open_right_insertions = counts.open_right_insertions + open + counts.extend_right_insertions = counts.extend_right_insertions + extend + } + } else if side == 0 { + counts.open_left_deletions = counts.open_left_deletions + open + counts.extend_left_deletions = counts.extend_left_deletions + extend + } else if side == 1 { + counts.open_internal_deletions = counts.open_internal_deletions + open + counts.extend_internal_deletions = counts.extend_internal_deletions + extend + } else { + counts.open_right_deletions = counts.open_right_deletions + open + counts.extend_right_deletions = counts.extend_right_deletions + extend + } +} + +///| +fn alignment_counts_add_residues( + counts : AlignmentCountsAccumulator, + first : Char, + second : Char, + config : AlignmentCountsConfig, +) -> Unit raise AlignmentCountsError { + match config.wildcard { + Some(wildcard) => if first == wildcard || second == wildcard { return } + None => () + } + if first == second { + counts.identities = counts.identities + 1 + } else { + counts.mismatches = counts.mismatches + 1 + } + match config.substitution_matrix { + Some(matrix) => { + let first_text = first.to_string() + let second_text = second.to_string() + if !matrix.contains(first_text) { + raise AlignmentCountsError( + "target residue '" + first_text + "' is not in substitution matrix", + ) + } + if !matrix.contains(second_text) { + raise AlignmentCountsError( + "query residue '" + second_text + "' is not in substitution matrix", + ) + } + let value = matrix.get_score_case_insensitive(first_text, second_text) + counts.matrix_score = counts.matrix_score + value.to_double() + if value > 0 { + counts.positives = counts.positives + 1 + } + } + None => () + } +} + +///| +fn alignment_counts_add_pair( + counts : AlignmentCountsAccumulator, + first_sequence : String, + first_length : Int, + first_coordinates : Array[Int], + first_reverse : Bool, + second_sequence : String, + second_length : Int, + second_coordinates : Array[Int], + second_reverse : Bool, + config : AlignmentCountsConfig, +) -> Unit raise AlignmentCountsError { + if first_coordinates.length() != second_coordinates.length() { + raise AlignmentCountsError( + "alignment coordinate rows must have equal length", + ) + } + if first_coordinates.length() == 1 { + raise AlignmentCountsError( + "an alignment path must be empty or contain at least two points", + ) + } + let first = alignment_counts_normalize_coordinates( + first_coordinates, first_length, first_reverse, + ) + let second = alignment_counts_normalize_coordinates( + second_coordinates, second_length, second_reverse, + ) + if first.length() == 0 { + return + } + let first_left = first[0] + let first_right = first[first.length() - 1] + let second_left = second[0] + let second_right = second[second.length() - 1] + let mut path = 0 + let mut index = 0 + while index + 1 < first.length() { + let first_start = first[index] + let first_end = first[index + 1] + let second_start = second[index] + let second_end = second[index + 1] + let first_step = first_end - first_start + let second_step = second_end - second_start + if first_step < 0 || second_step < 0 { + raise AlignmentCountsError( + "normalized alignment coordinates must be non-decreasing", + ) + } + if first_step == 0 && second_step == 0 { + // Multiple-alignment row pairs may share a gap inserted for other rows. + } else if first_step == 0 { + alignment_counts_add_gap( + counts, + true, + path == 1, + first_start, + first_end, + first_left, + first_right, + second_step, + ) + path = 1 + } else if second_step == 0 { + alignment_counts_add_gap( + counts, + false, + path == 2, + second_start, + second_end, + second_left, + second_right, + first_step, + ) + path = 2 + } else { + if first_step != second_step { + raise AlignmentCountsError( + "aligned coordinate steps must have equal length", + ) + } + path = 0 + counts.aligned = counts.aligned + first_step + if first_sequence.length() > 0 && second_sequence.length() > 0 { + let mut offset = 0 + while offset < first_step { + let first_residue = alignment_counts_residue( + first_sequence, + first_length, + first_start + offset, + first_reverse, + ) + let second_residue = alignment_counts_residue( + second_sequence, + second_length, + second_start + offset, + second_reverse, + ) + alignment_counts_add_residues( + counts, first_residue, second_residue, config, + ) + offset = offset + 1 + } + } + } + index = index + 1 + } +} + +///| +fn alignment_counts_gap_score( + counts : AlignmentCountsAccumulator, + scores : AlignmentGapScores, +) -> Double { + counts.open_left_insertions.to_double() * scores.open_left_insertion_score + + counts.extend_left_insertions.to_double() * scores.extend_left_insertion_score + + counts.open_left_deletions.to_double() * scores.open_left_deletion_score + + counts.extend_left_deletions.to_double() * scores.extend_left_deletion_score + + counts.open_internal_insertions.to_double() * + scores.open_internal_insertion_score + + counts.extend_internal_insertions.to_double() * + scores.extend_internal_insertion_score + + counts.open_internal_deletions.to_double() * + scores.open_internal_deletion_score + + counts.extend_internal_deletions.to_double() * + scores.extend_internal_deletion_score + + counts.open_right_insertions.to_double() * scores.open_right_insertion_score + + counts.extend_right_insertions.to_double() * + scores.extend_right_insertion_score + + counts.open_right_deletions.to_double() * scores.open_right_deletion_score + + counts.extend_right_deletions.to_double() * scores.extend_right_deletion_score +} + +///| +fn alignment_counts_finish( + counts : AlignmentCountsAccumulator, + config : AlignmentCountsConfig, +) -> AlignmentCounts { + let positives = match config.substitution_matrix { + Some(_) => Some(counts.positives) + None => None + } + let substitution_score = match config.substitution_matrix { + Some(_) => Some(counts.matrix_score) + None => + match (config.match_score, config.mismatch_score) { + (Some(match_value), Some(mismatch_value)) => + Some( + counts.identities.to_double() * match_value + + counts.mismatches.to_double() * mismatch_value, + ) + _ => None + } + } + let gap_score = match config.gap_scores { + Some(scores) => Some(alignment_counts_gap_score(counts, scores)) + None => None + } + let score = match (substitution_score, gap_score) { + (Some(substitution_value), Some(gap_value)) => + Some(substitution_value + gap_value) + _ => None + } + AlignmentCounts::{ + open_left_insertions: counts.open_left_insertions, + extend_left_insertions: counts.extend_left_insertions, + open_left_deletions: counts.open_left_deletions, + extend_left_deletions: counts.extend_left_deletions, + open_internal_insertions: counts.open_internal_insertions, + extend_internal_insertions: counts.extend_internal_insertions, + open_internal_deletions: counts.open_internal_deletions, + extend_internal_deletions: counts.extend_internal_deletions, + open_right_insertions: counts.open_right_insertions, + extend_right_insertions: counts.extend_right_insertions, + open_right_deletions: counts.open_right_deletions, + extend_right_deletions: counts.extend_right_deletions, + aligned: counts.aligned, + identities: counts.identities, + mismatches: counts.mismatches, + positives, + gap_score, + substitution_score, + score, + } +} + +///| +/// Calculate Biopython-style detailed statistics for a pairwise alignment. +pub fn CoordinatePairwiseAlignment::alignment_counts( + self : CoordinatePairwiseAlignment, + config? : AlignmentCountsConfig = AlignmentCountsConfig::default(), +) -> AlignmentCounts raise AlignmentCountsError { + let counts = alignment_counts_accumulator() + alignment_counts_add_pair( + counts, + self.target_sequence, + self.target_length, + self.target_coordinates, + false, + self.query_sequence, + self.query_length, + self.query_coordinates, + self.is_reverse(), + config, + ) + alignment_counts_finish(counts, config) +} + +///| +/// Sum detailed statistics over every unordered pair of MSA rows. +pub fn CoordinateMultipleAlignment::alignment_counts( + self : CoordinateMultipleAlignment, + config? : AlignmentCountsConfig = AlignmentCountsConfig::default(), +) -> AlignmentCounts raise AlignmentCountsError { + if self.names.length() != self.sequences.length() || + self.names.length() != self.coordinates.length() { + raise AlignmentCountsError( + "MSA names, sequences, and coordinates must have equal row counts", + ) + } + let counts = alignment_counts_accumulator() + let mut first = 0 + while first < self.sequences.length() { + let mut second = first + 1 + while second < self.sequences.length() { + alignment_counts_add_pair( + counts, + self.sequences[first], + self.sequences[first].length(), + self.coordinates[first], + false, + self.sequences[second], + self.sequences[second].length(), + self.coordinates[second], + false, + config, + ) + second = second + 1 + } + first = first + 1 + } + alignment_counts_finish(counts, config) +} diff --git a/src/subsmat.mbt b/src/subsmat.mbt index 6b2aec53..fc72d460 100644 --- a/src/subsmat.mbt +++ b/src/subsmat.mbt @@ -579,14 +579,14 @@ fn blosum45_data() -> Map[String, Map[String, Int]] { ("E", -1), ("G", 0), ("H", -2), - ("I", -2), - ("L", -2), + ("I", -1), + ("L", -1), ("K", -1), ("M", -1), - ("F", -3), + ("F", -2), ("P", -1), ("S", 1), - ("T", 1), + ("T", 0), ("W", -2), ("Y", -2), ("V", 0), @@ -597,28 +597,28 @@ fn blosum45_data() -> Map[String, Map[String, Int]] { ("N", 0), ("D", -1), ("C", -3), - ("Q", 2), + ("Q", 1), ("E", 0), ("G", -2), - ("H", 1), + ("H", 0), ("I", -3), ("L", -2), ("K", 3), ("M", -1), - ("F", -3), + ("F", -2), ("P", -2), ("S", -1), ("T", -1), ("W", -2), - ("Y", -2), - ("V", -3), + ("Y", -1), + ("V", -2), ]) m["N"] = Map([ ("A", -1), ("R", 0), ("N", 6), ("D", 2), - ("C", -3), + ("C", -2), ("Q", 0), ("E", 0), ("G", 0), @@ -627,29 +627,29 @@ fn blosum45_data() -> Map[String, Map[String, Int]] { ("L", -3), ("K", 0), ("M", -2), - ("F", -3), - ("P", -1), + ("F", -2), + ("P", -2), ("S", 1), ("T", 0), ("W", -4), ("Y", -2), - ("V", -2), + ("V", -3), ]) m["D"] = Map([ ("A", -2), ("R", -1), ("N", 2), ("D", 7), - ("C", -4), + ("C", -3), ("Q", 0), ("E", 2), ("G", -1), - ("H", -1), - ("I", -3), - ("L", -4), - ("K", -1), + ("H", 0), + ("I", -4), + ("L", -3), + ("K", 0), ("M", -3), - ("F", -3), + ("F", -4), ("P", -1), ("S", 0), ("T", -1), @@ -660,46 +660,46 @@ fn blosum45_data() -> Map[String, Map[String, Int]] { m["C"] = Map([ ("A", -1), ("R", -3), - ("N", -3), - ("D", -4), - ("C", 9), + ("N", -2), + ("D", -3), + ("C", 12), ("Q", -3), ("E", -3), ("G", -3), ("H", -3), - ("I", -1), - ("L", -1), + ("I", -3), + ("L", -2), ("K", -3), - ("M", -1), + ("M", -2), ("F", -2), - ("P", -3), + ("P", -4), ("S", -1), - ("T", 0), - ("W", -3), - ("Y", -2), + ("T", -1), + ("W", -5), + ("Y", -3), ("V", -1), ]) m["Q"] = Map([ ("A", -1), - ("R", 2), + ("R", 1), ("N", 0), ("D", 0), ("C", -3), - ("Q", 7), - ("E", 3), + ("Q", 6), + ("E", 2), ("G", -2), - ("H", 0), - ("I", -3), + ("H", 1), + ("I", -2), ("L", -2), ("K", 1), ("M", 0), - ("F", -3), + ("F", -4), ("P", -1), ("S", 0), ("T", -1), ("W", -2), ("Y", -1), - ("V", -2), + ("V", -3), ]) m["E"] = Map([ ("A", -1), @@ -707,21 +707,21 @@ fn blosum45_data() -> Map[String, Map[String, Int]] { ("N", 0), ("D", 2), ("C", -3), - ("Q", 3), + ("Q", 2), ("E", 6), ("G", -2), - ("H", -1), + ("H", 0), ("I", -3), - ("L", -3), + ("L", -2), ("K", 1), ("M", -2), ("F", -3), - ("P", -1), + ("P", 0), ("S", 0), ("T", -1), ("W", -3), ("Y", -2), - ("V", -2), + ("V", -3), ]) m["G"] = Map([ ("A", 0), @@ -731,12 +731,12 @@ fn blosum45_data() -> Map[String, Map[String, Int]] { ("C", -3), ("Q", -2), ("E", -2), - ("G", 6), + ("G", 7), ("H", -2), ("I", -4), - ("L", -4), + ("L", -3), ("K", -2), - ("M", -3), + ("M", -2), ("F", -3), ("P", -2), ("S", 0), @@ -747,33 +747,33 @@ fn blosum45_data() -> Map[String, Map[String, Int]] { ]) m["H"] = Map([ ("A", -2), - ("R", 1), + ("R", 0), ("N", 1), - ("D", -1), + ("D", 0), ("C", -3), - ("Q", 0), - ("E", -1), + ("Q", 1), + ("E", 0), ("G", -2), - ("H", 8), + ("H", 10), ("I", -3), - ("L", -3), + ("L", -2), ("K", -1), - ("M", -2), - ("F", -1), + ("M", 0), + ("F", -2), ("P", -2), ("S", -1), ("T", -2), - ("W", -2), + ("W", -3), ("Y", 2), ("V", -3), ]) m["I"] = Map([ - ("A", -2), + ("A", -1), ("R", -3), ("N", -2), - ("D", -3), - ("C", -1), - ("Q", -3), + ("D", -4), + ("C", -3), + ("Q", -2), ("E", -3), ("G", -4), ("H", -3), @@ -782,55 +782,55 @@ fn blosum45_data() -> Map[String, Map[String, Int]] { ("K", -3), ("M", 2), ("F", 0), - ("P", -3), + ("P", -2), ("S", -2), ("T", -1), - ("W", -3), - ("Y", -1), + ("W", -2), + ("Y", 0), ("V", 3), ]) m["L"] = Map([ - ("A", -2), + ("A", -1), ("R", -2), ("N", -3), - ("D", -4), - ("C", -1), + ("D", -3), + ("C", -2), ("Q", -2), - ("E", -3), - ("G", -4), - ("H", -3), + ("E", -2), + ("G", -3), + ("H", -2), ("I", 2), ("L", 5), - ("K", -2), - ("M", 3), - ("F", 0), + ("K", -3), + ("M", 2), + ("F", 1), ("P", -3), - ("S", -2), + ("S", -3), ("T", -1), ("W", -2), - ("Y", -1), + ("Y", 0), ("V", 1), ]) m["K"] = Map([ ("A", -1), ("R", 3), ("N", 0), - ("D", -1), + ("D", 0), ("C", -3), ("Q", 1), ("E", 1), ("G", -2), ("H", -1), ("I", -3), - ("L", -2), - ("K", 6), + ("L", -3), + ("K", 5), ("M", -1), ("F", -3), ("P", -1), - ("S", 0), + ("S", -1), ("T", -1), - ("W", -3), - ("Y", -2), + ("W", -2), + ("Y", -1), ("V", -2), ]) m["M"] = Map([ @@ -838,66 +838,66 @@ fn blosum45_data() -> Map[String, Map[String, Int]] { ("R", -1), ("N", -2), ("D", -3), - ("C", -1), + ("C", -2), ("Q", 0), ("E", -2), - ("G", -3), - ("H", -2), + ("G", -2), + ("H", 0), ("I", 2), - ("L", 3), + ("L", 2), ("K", -1), ("M", 6), ("F", 0), ("P", -2), - ("S", -1), + ("S", -2), ("T", -1), - ("W", -1), - ("Y", -1), + ("W", -2), + ("Y", 0), ("V", 1), ]) m["F"] = Map([ - ("A", -3), - ("R", -3), - ("N", -3), - ("D", -3), + ("A", -2), + ("R", -2), + ("N", -2), + ("D", -4), ("C", -2), - ("Q", -3), + ("Q", -4), ("E", -3), ("G", -3), - ("H", -1), + ("H", -2), ("I", 0), - ("L", 0), + ("L", 1), ("K", -3), ("M", 0), - ("F", 6), - ("P", -4), + ("F", 8), + ("P", -3), ("S", -2), - ("T", -2), + ("T", -1), ("W", 1), ("Y", 3), - ("V", -1), + ("V", 0), ]) m["P"] = Map([ ("A", -1), ("R", -2), - ("N", -1), + ("N", -2), ("D", -1), - ("C", -3), + ("C", -4), ("Q", -1), - ("E", -1), + ("E", 0), ("G", -2), ("H", -2), - ("I", -3), + ("I", -2), ("L", -3), ("K", -1), ("M", -2), - ("F", -4), - ("P", 8), + ("F", -3), + ("P", 9), ("S", -1), ("T", -1), - ("W", -4), + ("W", -3), ("Y", -3), - ("V", -2), + ("V", -3), ]) m["S"] = Map([ ("A", 1), @@ -910,23 +910,23 @@ fn blosum45_data() -> Map[String, Map[String, Int]] { ("G", 0), ("H", -1), ("I", -2), - ("L", -2), - ("K", 0), - ("M", -1), + ("L", -3), + ("K", -1), + ("M", -2), ("F", -2), ("P", -1), ("S", 4), ("T", 2), - ("W", -3), + ("W", -4), ("Y", -2), - ("V", -2), + ("V", -1), ]) m["T"] = Map([ - ("A", 1), + ("A", 0), ("R", -1), ("N", 0), ("D", -1), - ("C", 0), + ("C", -1), ("Q", -1), ("E", -1), ("G", -2), @@ -935,12 +935,12 @@ fn blosum45_data() -> Map[String, Map[String, Int]] { ("L", -1), ("K", -1), ("M", -1), - ("F", -2), + ("F", -1), ("P", -1), ("S", 2), ("T", 5), - ("W", -2), - ("Y", -2), + ("W", -3), + ("Y", -1), ("V", 0), ]) m["W"] = Map([ @@ -948,62 +948,62 @@ fn blosum45_data() -> Map[String, Map[String, Int]] { ("R", -2), ("N", -4), ("D", -4), - ("C", -3), + ("C", -5), ("Q", -2), ("E", -3), ("G", -2), - ("H", -2), - ("I", -3), + ("H", -3), + ("I", -2), ("L", -2), - ("K", -3), - ("M", -1), + ("K", -2), + ("M", -2), ("F", 1), - ("P", -4), - ("S", -3), - ("T", -2), - ("W", 11), - ("Y", 2), + ("P", -3), + ("S", -4), + ("T", -3), + ("W", 15), + ("Y", 3), ("V", -3), ]) m["Y"] = Map([ ("A", -2), - ("R", -2), + ("R", -1), ("N", -2), ("D", -2), - ("C", -2), + ("C", -3), ("Q", -1), ("E", -2), ("G", -3), ("H", 2), - ("I", -1), - ("L", -1), - ("K", -2), - ("M", -1), + ("I", 0), + ("L", 0), + ("K", -1), + ("M", 0), ("F", 3), ("P", -3), ("S", -2), - ("T", -2), - ("W", 2), - ("Y", 7), + ("T", -1), + ("W", 3), + ("Y", 8), ("V", -1), ]) m["V"] = Map([ ("A", 0), - ("R", -3), - ("N", -2), + ("R", -2), + ("N", -3), ("D", -3), ("C", -1), - ("Q", -2), - ("E", -2), + ("Q", -3), + ("E", -3), ("G", -3), ("H", -3), ("I", 3), ("L", 1), ("K", -2), ("M", 1), - ("F", -1), - ("P", -2), - ("S", -2), + ("F", 0), + ("P", -3), + ("S", -1), ("T", 0), ("W", -3), ("Y", -1), diff --git a/test/moonbit/alignment_counts_test.mbt b/test/moonbit/alignment_counts_test.mbt new file mode 100644 index 00000000..461e1636 --- /dev/null +++ b/test/moonbit/alignment_counts_test.mbt @@ -0,0 +1,852 @@ +///| +fn alignment_counts_pair( + target : String, + query : String, + target_coordinates : Array[Int], + query_coordinates : Array[Int], +) -> @src.CoordinatePairwiseAlignment { + @src.coordinate_pairwise_alignment( + "target", target, "query", query, target_coordinates, query_coordinates, + ) catch { + _ => abort("valid alignment should build") + } +} + +///| +fn alignment_counts_basic( + target : String, + query : String, + target_coordinates : Array[Int], + query_coordinates : Array[Int], +) -> @src.AlignmentCounts { + alignment_counts_pair(target, query, target_coordinates, query_coordinates).alignment_counts() catch { + _ => abort("valid alignment should count") + } +} + +///| +fn alignment_counts_affine( + open_score : Double, + extend_score : Double, +) -> @src.AlignmentGapScores { + @src.AlignmentGapScores::affine(open_score, extend_score) catch { + _ => abort("finite affine scores should build") + } +} + +///| +test "alignment counts: ungapped identities" { + let counts = alignment_counts_basic("ACGT", "ACGT", [0, 4], [0, 4]) + assert_eq(counts.aligned, 4) + assert_eq(counts.identities, 4) + assert_eq(counts.mismatches, 0) + assert_eq(counts.gaps(), 0) +} + +///| +test "alignment counts: ungapped mismatches" { + let counts = alignment_counts_basic("ACGT", "AGCT", [0, 4], [0, 4]) + assert_eq(counts.aligned, 4) + assert_eq(counts.identities, 2) + assert_eq(counts.mismatches, 2) +} + +///| +test "alignment counts: default scores are unknown" { + let counts = alignment_counts_basic("AC", "AC", [0, 2], [0, 2]) + assert_eq(counts.positives, None) + assert_eq(counts.substitution_score, None) + assert_eq(counts.gap_score, None) + assert_eq(counts.score, None) +} + +///| +test "alignment counts: wildcard excludes mismatch" { + let alignment = alignment_counts_pair("AC?T", "ACGT", [0, 4], [0, 4]) + let config = @src.AlignmentCountsConfig::with_wildcard('?') + let counts = alignment.alignment_counts(config~) catch { + _ => abort("wildcard counting should succeed") + } + assert_eq(counts.aligned, 4) + assert_eq(counts.identities, 3) + assert_eq(counts.mismatches, 0) +} + +///| +test "alignment counts: wildcard excludes identity" { + let alignment = alignment_counts_pair("AC?T", "AC?T", [0, 4], [0, 4]) + let config = @src.AlignmentCountsConfig::with_wildcard('?') + let counts = alignment.alignment_counts(config~) catch { + _ => abort("wildcard counting should succeed") + } + assert_eq(counts.identities, 3) + assert_eq(counts.mismatches, 0) +} + +///| +test "alignment counts: wildcard remains aligned" { + let alignment = alignment_counts_pair("NN", "AA", [0, 2], [0, 2]) + let counts = alignment.alignment_counts( + config=@src.AlignmentCountsConfig::with_wildcard('N'), + ) catch { + _ => abort("wildcard counting should succeed") + } + assert_eq(counts.aligned, 2) + assert_eq(counts.identities + counts.mismatches, 0) +} + +///| +test "alignment counts: BLOSUM62 official protein example" { + let alignment = alignment_counts_pair( + "EPQSDPSVEPPLSQETFSDLWKLLPE", + "EPSSETGMDPPLSQETFEDLWSLLPD", + [0, 26], + [0, 26], + ) + let config = @src.AlignmentCountsConfig::with_matrix(@src.blosum62()) + let counts = alignment.alignment_counts(config~) catch { + _ => abort("BLOSUM62 counting should succeed") + } + assert_eq(counts.identities, 17) + assert_eq(counts.mismatches, 9) + assert_eq(counts.positives, Some(21)) + assert_eq(counts.substitution_score, Some(101.0)) + assert_eq(counts.score, None) +} + +///| +test "alignment counts: BLOSUM45 official protein example" { + let alignment = alignment_counts_pair( + "EPQSDPSVEPPLSQETFSDLWKLLPE", + "EPSSETGMDPPLSQETFEDLWSLLPD", + [0, 26], + [0, 26], + ) + let config = @src.AlignmentCountsConfig::with_matrix(@src.blosum45()) + let counts = alignment.alignment_counts(config~) catch { + _ => abort("BLOSUM45 counting should succeed") + } + assert_eq(counts.positives, Some(21)) + assert_eq(counts.substitution_score, Some(122.0)) + let matrix = @src.blosum45() + assert_eq(matrix.get_score("C", "C"), 12) + assert_eq(matrix.get_score("P", "P"), 9) + assert_eq(matrix.get_score("W", "W"), 15) + assert_eq(matrix.get_score("K", "S"), -1) + assert_eq(matrix.get_score("S", "K"), -1) +} + +///| +test "alignment counts: matrix accepts lower case residues" { + let alignment = alignment_counts_pair("ar", "AR", [0, 2], [0, 2]) + let counts = alignment.alignment_counts( + config=@src.AlignmentCountsConfig::with_matrix(@src.blosum62()), + ) catch { + _ => abort("case-insensitive matrix scoring should succeed") + } + assert_eq(counts.identities, 0) + assert_eq(counts.mismatches, 2) + assert_eq(counts.positives, Some(2)) + assert_eq(counts.substitution_score, Some(9.0)) +} + +///| +test "alignment counts: matrix rejects unknown residue" { + let alignment = alignment_counts_pair("AX", "AA", [0, 2], [0, 2]) + let failed = try { + ignore( + alignment.alignment_counts( + config=@src.AlignmentCountsConfig::with_matrix(@src.blosum62()), + ), + ) + false + } catch { + AlignmentCountsError(_) => true + } + assert_true(failed) +} + +///| +test "alignment counts: matrix wildcard skips unknown residue" { + let alignment = alignment_counts_pair("AX", "AA", [0, 2], [0, 2]) + let config = @src.AlignmentCountsConfig::with_matrix( + @src.blosum62(), + wildcard=Some('X'), + ) + let counts = alignment.alignment_counts(config~) catch { + _ => abort("matrix wildcard should skip X") + } + assert_eq(counts.aligned, 2) + assert_eq(counts.identities, 1) + assert_eq(counts.positives, Some(1)) + assert_eq(counts.substitution_score, Some(4.0)) +} + +///| +test "alignment counts: match mismatch substitution score" { + let alignment = alignment_counts_pair("ACGT", "AGGT", [0, 4], [0, 4]) + let config = @src.AlignmentCountsConfig::create( + match_score=Some(2.0), + mismatch_score=Some(-1.0), + ) catch { + _ => abort("valid score config should build") + } + let counts = alignment.alignment_counts(config~) catch { + _ => abort("match scoring should succeed") + } + assert_eq(counts.substitution_score, Some(5.0)) + assert_eq(counts.gap_score, None) + assert_eq(counts.score, None) +} + +///| +test "alignment counts: matrix takes precedence over match score" { + let alignment = alignment_counts_pair("AA", "AA", [0, 2], [0, 2]) + let config = @src.AlignmentCountsConfig::create( + substitution_matrix=Some(@src.blosum62()), + match_score=Some(100.0), + mismatch_score=Some(-100.0), + ) catch { + _ => abort("combined config should build") + } + let counts = alignment.alignment_counts(config~) catch { + _ => abort("matrix precedence should count") + } + assert_eq(counts.substitution_score, Some(8.0)) +} + +///| +test "alignment counts: left insertion" { + let counts = alignment_counts_basic("AAAAA", "AAAAA", [2, 2, 5], [0, 2, 5]) + assert_eq(counts.open_left_insertions, 1) + assert_eq(counts.extend_left_insertions, 1) + assert_eq(counts.left_insertions(), 2) + assert_eq(counts.aligned, 3) +} + +///| +test "alignment counts: left deletion" { + let counts = alignment_counts_basic("AAAAA", "AAAAA", [0, 2, 5], [2, 2, 5]) + assert_eq(counts.open_left_deletions, 1) + assert_eq(counts.extend_left_deletions, 1) + assert_eq(counts.left_deletions(), 2) +} + +///| +test "alignment counts: internal insertion" { + let counts = alignment_counts_basic("AAAA", "AAAAAA", [0, 2, 2, 4], [ + 0, 2, 4, 6, + ]) + assert_eq(counts.open_internal_insertions, 1) + assert_eq(counts.extend_internal_insertions, 1) + assert_eq(counts.internal_insertions(), 2) +} + +///| +test "alignment counts: internal deletion" { + let counts = alignment_counts_basic("AAAAAA", "AAAA", [0, 2, 4, 6], [ + 0, 2, 2, 4, + ]) + assert_eq(counts.open_internal_deletions, 1) + assert_eq(counts.extend_internal_deletions, 1) + assert_eq(counts.internal_deletions(), 2) +} + +///| +test "alignment counts: right insertion" { + let counts = alignment_counts_basic("AAA", "AAAAA", [0, 3, 3], [0, 3, 5]) + assert_eq(counts.open_right_insertions, 1) + assert_eq(counts.extend_right_insertions, 1) + assert_eq(counts.right_insertions(), 2) +} + +///| +test "alignment counts: right deletion" { + let counts = alignment_counts_basic("AAAAA", "AAA", [0, 3, 5], [0, 3, 3]) + assert_eq(counts.open_right_deletions, 1) + assert_eq(counts.extend_right_deletions, 1) + assert_eq(counts.right_deletions(), 2) +} + +///| +test "alignment counts: one-letter gap has no extension" { + let counts = alignment_counts_basic("AAA", "AAAA", [0, 2, 2, 3], [0, 2, 3, 4]) + assert_eq(counts.open_internal_insertions, 1) + assert_eq(counts.extend_internal_insertions, 0) +} + +///| +test "alignment counts: four-letter gap has three extensions" { + let counts = alignment_counts_basic("AAAA", "AAAAAAAA", [0, 2, 2, 4], [ + 0, 2, 6, 8, + ]) + assert_eq(counts.open_internal_insertions, 1) + assert_eq(counts.extend_internal_insertions, 3) +} + +///| +test "alignment counts: split consecutive insertion remains one gap" { + let counts = alignment_counts_basic("AA", "AAAAA", [0, 0, 0, 2], [0, 1, 3, 5]) + assert_eq(counts.open_left_insertions, 1) + assert_eq(counts.extend_left_insertions, 2) +} + +///| +test "alignment counts: split consecutive deletion remains one gap" { + let counts = alignment_counts_basic("AAAAA", "AA", [0, 1, 3, 5], [0, 0, 0, 2]) + assert_eq(counts.open_left_deletions, 1) + assert_eq(counts.extend_left_deletions, 2) +} + +///| +test "alignment counts: diagonal resets insertion path" { + let counts = alignment_counts_basic("AAAA", "AAAAAA", [0, 1, 1, 3, 3, 4], [ + 0, 1, 2, 4, 5, 6, + ]) + assert_eq(counts.open_internal_insertions, 2) + assert_eq(counts.extend_internal_insertions, 0) +} + +///| +test "alignment counts: changing gap direction opens both gaps" { + let counts = alignment_counts_basic("AAAA", "AAAA", [0, 0, 2, 4], [0, 2, 2, 4]) + assert_eq(counts.open_left_insertions, 1) + assert_eq(counts.open_internal_deletions, 1) + assert_eq(counts.open_gaps(), 2) +} + +///| +test "alignment counts: left classification precedes right" { + let counts = alignment_counts_basic("", "", [], []) + assert_eq(counts.gaps(), 0) + let alignment = @src.coordinate_pairwise_alignment_with_lengths( + "target", + 0, + "query", + 2, + [0, 0], + [0, 2], + ) catch { + _ => abort("gap-only alignment should build") + } + let gap_counts = alignment.alignment_counts() catch { + _ => abort("gap-only alignment should count") + } + assert_eq(gap_counts.left_insertions(), 2) + assert_eq(gap_counts.right_insertions(), 0) +} + +///| +test "alignment counts: aggregate insertion properties" { + let counts = alignment_counts_basic("AAAA", "AAAAAAAA", [0, 0, 2, 2, 4, 4], [ + 0, 1, 3, 5, 7, 8, + ]) + assert_eq(counts.left_insertions(), 1) + assert_eq(counts.internal_insertions(), 2) + assert_eq(counts.right_insertions(), 1) + assert_eq(counts.insertions(), 4) + assert_eq(counts.open_insertions(), 3) + assert_eq(counts.extend_insertions(), 1) +} + +///| +test "alignment counts: aggregate deletion properties" { + let counts = alignment_counts_basic("AAAAAAAA", "AAAA", [0, 1, 3, 5, 7, 8], [ + 0, 0, 2, 2, 4, 4, + ]) + assert_eq(counts.left_deletions(), 1) + assert_eq(counts.internal_deletions(), 2) + assert_eq(counts.right_deletions(), 1) + assert_eq(counts.deletions(), 4) + assert_eq(counts.open_deletions(), 3) + assert_eq(counts.extend_deletions(), 1) +} + +///| +test "alignment counts: aggregate side properties" { + let counts = alignment_counts_basic("AAAA", "AAAA", [0, 0, 2, 4, 4], [ + 0, 1, 3, 3, 4, + ]) + assert_eq(counts.left_gaps(), 1) + assert_eq(counts.internal_gaps(), 2) + assert_eq(counts.right_gaps(), 1) + assert_eq(counts.gaps(), 4) + assert_eq(counts.open_gaps(), 3) + assert_eq(counts.extend_gaps(), 1) +} + +///| +test "alignment counts: affine complete score" { + let alignment = alignment_counts_pair("GAACT", "GAT", [0, 2, 4, 5], [ + 0, 2, 2, 3, + ]) + let config = @src.AlignmentCountsConfig::scored( + match_score=1.0, + mismatch_score=0.0, + gap_scores=alignment_counts_affine(-1.0, -1.0), + ) catch { + _ => abort("scored config should build") + } + let counts = alignment.alignment_counts(config~) catch { + _ => abort("scored counts should succeed") + } + assert_eq(counts.substitution_score, Some(3.0)) + assert_eq(counts.gap_score, Some(-2.0)) + assert_eq(counts.score, Some(1.0)) +} + +///| +test "alignment counts: affine open extend score" { + let alignment = alignment_counts_pair("GAACT", "GAT", [0, 2, 4, 5], [ + 0, 2, 2, 3, + ]) + let config = @src.AlignmentCountsConfig::scored( + match_score=2.0, + mismatch_score=-1.0, + gap_scores=alignment_counts_affine(-5.0, -1.0), + ) catch { + _ => abort("scored config should build") + } + let counts = alignment.alignment_counts(config~) catch { + _ => abort("scored counts should succeed") + } + assert_eq(counts.substitution_score, Some(6.0)) + assert_eq(counts.gap_score, Some(-6.0)) + assert_eq(counts.score, Some(0.0)) +} + +///| +test "alignment counts: directional insertion score" { + let scores = @src.AlignmentGapScores::directional( + insertion_open_score=-3.0, + insertion_extend_score=-0.5, + deletion_open_score=-8.0, + deletion_extend_score=-2.0, + ) catch { + _ => abort("directional scores should build") + } + let config = @src.AlignmentCountsConfig::scored( + match_score=0.0, + mismatch_score=0.0, + gap_scores=scores, + ) catch { + _ => abort("scored config should build") + } + let counts = alignment_counts_pair("AAA", "AAAAA", [0, 3, 3], [0, 3, 5]).alignment_counts( + config~, + ) catch { + _ => abort("directional score should count") + } + assert_eq(counts.gap_score, Some(-3.5)) +} + +///| +test "alignment counts: directional deletion score" { + let scores = @src.AlignmentGapScores::directional( + insertion_open_score=-3.0, + insertion_extend_score=-0.5, + deletion_open_score=-8.0, + deletion_extend_score=-2.0, + ) catch { + _ => abort("directional scores should build") + } + let config = @src.AlignmentCountsConfig::scored( + match_score=0.0, + mismatch_score=0.0, + gap_scores=scores, + ) catch { + _ => abort("scored config should build") + } + let counts = alignment_counts_pair("AAAAA", "AAA", [0, 3, 5], [0, 3, 3]).alignment_counts( + config~, + ) catch { + _ => abort("directional score should count") + } + assert_eq(counts.gap_score, Some(-10.0)) +} + +///| +test "alignment counts: all twelve gap scores are applied" { + let scores = @src.AlignmentGapScores::create( + open_left_insertion_score=-1.0, + extend_left_insertion_score=-2.0, + open_left_deletion_score=-3.0, + extend_left_deletion_score=-4.0, + open_internal_insertion_score=-5.0, + extend_internal_insertion_score=-6.0, + open_internal_deletion_score=-7.0, + extend_internal_deletion_score=-8.0, + open_right_insertion_score=-9.0, + extend_right_insertion_score=-10.0, + open_right_deletion_score=-11.0, + extend_right_deletion_score=-12.0, + ) catch { + _ => abort("position-specific scores should build") + } + let config = @src.AlignmentCountsConfig::scored( + match_score=0.0, + mismatch_score=0.0, + gap_scores=scores, + ) catch { + _ => abort("scored config should build") + } + let alignment = alignment_counts_pair("AAAA", "AAAAA", [0, 0, 2, 4, 4], [ + 0, 2, 4, 4, 5, + ]) + let counts = alignment.alignment_counts(config~) catch { + _ => abort("position-specific scoring should succeed") + } + assert_eq(counts.open_left_insertions, 1) + assert_eq(counts.extend_left_insertions, 1) + assert_eq(counts.open_internal_deletions, 1) + assert_eq(counts.extend_internal_deletions, 1) + assert_eq(counts.open_right_insertions, 1) + assert_eq(counts.gap_score, Some(-27.0)) +} + +///| +test "alignment counts: matrix and gap score total" { + let config = @src.AlignmentCountsConfig::scored_matrix( + matrix=@src.blosum62(), + gap_scores=alignment_counts_affine(-5.0, -1.0), + ) + let alignment = alignment_counts_pair("AAAA", "AAA", [0, 2, 3, 4], [ + 0, 2, 2, 3, + ]) + let counts = alignment.alignment_counts(config~) catch { + _ => abort("matrix gap scoring should succeed") + } + assert_eq(counts.substitution_score, Some(12.0)) + assert_eq(counts.gap_score, Some(-5.0)) + assert_eq(counts.score, Some(7.0)) + assert_eq(counts.positives, Some(3)) +} + +///| +test "alignment counts: reverse query identities" { + let counts = alignment_counts_basic("GAACT", "ATC", [0, 2, 4, 5], [3, 1, 1, 0]) + assert_eq(counts.aligned, 3) + assert_eq(counts.identities, 3) + assert_eq(counts.mismatches, 0) + assert_eq(counts.internal_deletions(), 2) +} + +///| +test "alignment counts: reverse query mismatch" { + let counts = alignment_counts_basic("GACT", "AATC", [0, 4], [4, 0]) + assert_eq(counts.aligned, 4) + assert_eq(counts.identities, 3) + assert_eq(counts.mismatches, 1) +} + +///| +test "alignment counts: reverse matrix score" { + let alignment = alignment_counts_pair("AAAA", "TTTT", [0, 4], [4, 0]) + let counts = alignment.alignment_counts( + config=@src.AlignmentCountsConfig::with_matrix(@src.blosum62()), + ) catch { + _ => abort("reverse matrix scoring should succeed") + } + assert_eq(counts.identities, 4) + assert_eq(counts.substitution_score, Some(16.0)) + assert_eq(counts.positives, Some(4)) +} + +///| +test "alignment counts: reverse right gap classification" { + let counts = alignment_counts_basic("AAAAA", "TTT", [0, 3, 5], [3, 0, 0]) + assert_eq(counts.right_deletions(), 2) + assert_eq(counts.open_right_deletions, 1) +} + +///| +test "alignment counts: reverse internal gap classification" { + let counts = alignment_counts_basic("AAAAAA", "TTTT", [0, 2, 4, 6], [ + 4, 2, 2, 0, + ]) + assert_eq(counts.internal_deletions(), 2) + assert_eq(counts.open_internal_deletions, 1) +} + +///| +test "alignment counts: empty path" { + let alignment = @src.coordinate_pairwise_alignment_with_lengths( + "target", + 10, + "query", + 20, + [], + [], + ) catch { + _ => abort("empty alignment should build") + } + let counts = alignment.alignment_counts() catch { + _ => abort("empty alignment should count") + } + assert_eq(counts.aligned, 0) + assert_eq(counts.gaps(), 0) + assert_eq( + counts.summary(), + "AlignmentCounts(aligned=0, identities=0, mismatches=0, gaps=0)", + ) +} + +///| +test "alignment counts: unknown sequence still counts coordinates" { + let alignment = @src.coordinate_pairwise_alignment_with_lengths( + "target", + 5, + "query", + 3, + [0, 2, 4, 5], + [0, 2, 2, 3], + ) catch { + _ => abort("length-only alignment should build") + } + let counts = alignment.alignment_counts() catch { + _ => abort("length-only alignment should count") + } + assert_eq(counts.aligned, 3) + assert_eq(counts.identities, 0) + assert_eq(counts.mismatches, 0) + assert_eq(counts.internal_deletions(), 2) +} + +///| +test "alignment counts: unknown sequence scored composition is zero" { + let alignment = @src.coordinate_pairwise_alignment_with_lengths( + "target", + 4, + "query", + 4, + [0, 4], + [0, 4], + ) catch { + _ => abort("length-only alignment should build") + } + let config = @src.AlignmentCountsConfig::create( + match_score=Some(2.0), + mismatch_score=Some(-1.0), + ) catch { + _ => abort("score config should build") + } + let counts = alignment.alignment_counts(config~) catch { + _ => abort("length-only scoring should count") + } + assert_eq(counts.aligned, 4) + assert_eq(counts.substitution_score, Some(0.0)) +} + +///| +test "alignment counts: rejects unequal aligned steps" { + let alignment = alignment_counts_pair("AAA", "AA", [0, 3], [0, 2]) + let failed = try { + ignore(alignment.alignment_counts()) + false + } catch { + AlignmentCountsError(_) => true + } + assert_true(failed) +} + +///| +test "alignment counts: config rejects lone match score" { + let failed = try { + ignore(@src.AlignmentCountsConfig::create(match_score=Some(1.0))) + false + } catch { + AlignmentCountsError(_) => true + } + assert_true(failed) +} + +///| +test "alignment counts: config rejects lone mismatch score" { + let failed = try { + ignore(@src.AlignmentCountsConfig::create(mismatch_score=Some(-1.0))) + false + } catch { + AlignmentCountsError(_) => true + } + assert_true(failed) +} + +///| +test "alignment counts: affine rejects non-finite open score" { + let failed = try { + ignore(@src.AlignmentGapScores::affine(1.0e301, -1.0)) + false + } catch { + AlignmentCountsError(_) => true + } + assert_true(failed) +} + +///| +test "alignment counts: directional rejects non-finite extend score" { + let failed = try { + ignore( + @src.AlignmentGapScores::directional( + insertion_open_score=-1.0, + insertion_extend_score=-1.0, + deletion_open_score=-1.0, + deletion_extend_score=1.0e301, + ), + ) + false + } catch { + AlignmentCountsError(_) => true + } + assert_true(failed) +} + +///| +test "alignment counts: legacy basic counts remain unchanged" { + let alignment = alignment_counts_pair("AAAAAA", "AAAA", [0, 2, 4, 6], [ + 0, 2, 2, 4, + ]) + let legacy = alignment.counts() + let detailed = alignment.alignment_counts() catch { + _ => abort("detailed counts should succeed") + } + assert_eq(legacy.aligned, detailed.aligned) + assert_eq(legacy.query_gap_bases, detailed.deletions()) + assert_eq(legacy.query_gap_events, detailed.open_deletions()) +} + +///| +test "alignment counts: summary reports core statistics" { + let counts = alignment_counts_basic("GAACT", "GAT", [0, 2, 4, 5], [0, 2, 2, 3]) + assert_eq( + counts.summary(), + "AlignmentCounts(aligned=3, identities=3, mismatches=0, gaps=2)", + ) +} + +///| +test "alignment counts: MSA official pairwise sums" { + let alignment = @src.coordinate_multiple_alignment( + ["target", "query1", "query2"], + ["CGGTTTTT", "AG-TTT--", "AGGTTT--"], + ) catch { + _ => abort("official MSA should build") + } + let counts = alignment.alignment_counts() catch { + _ => abort("MSA counts should succeed") + } + assert_eq(counts.aligned, 16) + assert_eq(counts.identities, 14) + assert_eq(counts.mismatches, 2) + assert_eq(counts.insertions(), 1) + assert_eq(counts.deletions(), 5) + assert_eq(counts.left_gaps(), 0) + assert_eq(counts.internal_gaps(), 2) + assert_eq(counts.right_gaps(), 4) +} + +///| +test "alignment counts: MSA shared gap columns are ignored" { + let alignment = @src.coordinate_multiple_alignment(["a", "b", "c"], [ + "AA--CC", "AA--CC", "AATTCC", + ]) catch { + _ => abort("MSA with shared gaps should build") + } + let counts = alignment.alignment_counts() catch { + _ => abort("shared gap columns should count") + } + assert_eq(counts.aligned, 12) + assert_eq(counts.identities, 12) + assert_eq(counts.gaps(), 4) +} + +///| +test "alignment counts: MSA matrix sums all unordered pairs" { + let alignment = @src.coordinate_multiple_alignment(["a", "b", "c"], [ + "AA", "AR", "RR", + ]) catch { + _ => abort("protein MSA should build") + } + let counts = alignment.alignment_counts( + config=@src.AlignmentCountsConfig::with_matrix(@src.blosum62()), + ) catch { + _ => abort("MSA matrix scoring should succeed") + } + assert_eq(counts.aligned, 6) + assert_eq(counts.identities, 2) + assert_eq(counts.mismatches, 4) + assert_eq(counts.positives, Some(2)) + assert_eq(counts.substitution_score, Some(5.0)) +} + +///| +test "alignment counts: MSA wildcard sums all unordered pairs" { + let alignment = @src.coordinate_multiple_alignment(["a", "b", "c"], [ + "AN", "AA", "AT", + ]) catch { + _ => abort("wildcard MSA should build") + } + let counts = alignment.alignment_counts( + config=@src.AlignmentCountsConfig::with_wildcard('N'), + ) catch { + _ => abort("MSA wildcard counting should succeed") + } + assert_eq(counts.aligned, 6) + assert_eq(counts.identities, 3) + assert_eq(counts.mismatches, 1) +} + +///| +test "alignment counts: MSA gap score sums pair gaps" { + let alignment = @src.coordinate_multiple_alignment(["a", "b", "c"], [ + "A-AA", "AAAA", "A--A", + ]) catch { + _ => abort("gapped MSA should build") + } + let config = @src.AlignmentCountsConfig::scored( + match_score=1.0, + mismatch_score=-1.0, + gap_scores=alignment_counts_affine(-2.0, -1.0), + ) catch { + _ => abort("scored config should build") + } + let counts = alignment.alignment_counts(config~) catch { + _ => abort("MSA gap scoring should succeed") + } + assert_eq(counts.gaps(), 4) + assert_eq(counts.open_gaps(), 3) + assert_eq(counts.extend_gaps(), 1) + assert_eq(counts.gap_score, Some(-7.0)) + assert_eq(counts.score, Some(0.0)) +} + +///| +test "alignment counts: one-row MSA has zero pair counts" { + let alignment = @src.coordinate_multiple_alignment(["only"], ["ACGT"]) catch { + _ => abort("one-row MSA should build") + } + let counts = alignment.alignment_counts() catch { + _ => abort("one-row MSA should count") + } + assert_eq(counts.aligned, 0) + assert_eq(counts.gaps(), 0) +} + +///| +test "alignment counts: scored one-row MSA has zero scores" { + let alignment = @src.coordinate_multiple_alignment(["only"], ["ACGT"]) catch { + _ => abort("one-row MSA should build") + } + let config = @src.AlignmentCountsConfig::scored( + match_score=1.0, + mismatch_score=-1.0, + gap_scores=alignment_counts_affine(-2.0, -1.0), + ) catch { + _ => abort("scored config should build") + } + let counts = alignment.alignment_counts(config~) catch { + _ => abort("one-row scored MSA should count") + } + assert_eq(counts.substitution_score, Some(0.0)) + assert_eq(counts.gap_score, Some(0.0)) + assert_eq(counts.score, Some(0.0)) +} From acecd706794860fbd48889ca09593ae2cb468285 Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 11:51:13 +0800 Subject: [PATCH 25/41] #28 feat: Bioconductor DirichletMultinomial DMM ROC SummarizedExperiment --- README.md | 22 +- examples/dirichlet_multinomial_demo/main.mbt | 162 ++ examples/dirichlet_multinomial_demo/moon.pkg | 6 + src/dirichlet_multinomial.mbt | 1823 ++++++++++++++++++ test/moonbit/dirichlet_multinomial_test.mbt | 994 ++++++++++ 5 files changed, 3004 insertions(+), 3 deletions(-) create mode 100644 examples/dirichlet_multinomial_demo/main.mbt create mode 100644 examples/dirichlet_multinomial_demo/moon.pkg create mode 100644 src/dirichlet_multinomial.mbt create mode 100644 test/moonbit/dirichlet_multinomial_test.mbt diff --git a/README.md b/README.md index 03e99f67..228d54a3 100644 --- a/README.md +++ b/README.md @@ -212,6 +212,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **variancePartition** | Bioconductor variancePartition | 重复测量线性混合模型、方差分解、BLUP、precision weights、dream contrast与Satterthwaite检验 | ✅ | | **dreamlet** | Bioconductor dreamlet | sample×cell-type pseudobulk、TMM、cell/sample/gene过滤、logCPM、Poisson/voom precision weights、分cell-type重复测量模型及study-wide FDR | ✅ | | **ALDEx2** | Bioconductor ALDEx2 | Dirichlet Monte Carlo组成型差异丰度、六类denominator、Welch/Wilcoxon与配对检验、effect/overlap、Aitchison距离及SummarizedExperiment接入 | ✅ | +| **DirichletMultinomial** | Bioconductor DirichletMultinomial | Dirichlet-multinomial概率、有限混合EM/BFGS聚类、Laplace/AIC/BIC选K、生成式分组分类、分层交叉验证、ROC及SummarizedExperiment接入 | ✅ | | **SummarizedExperiment** | Bioconductor SummarizedExperiment | 多维基因组数据容器、Assays、行/列操作 | ✅ | | **RangedSummarizedExperiment** | Bioconductor SummarizedExperiment | GRanges/GRangesList行范围、复合特征精确重叠/最近邻、覆盖度、区间变换与协调子集 | ✅ | | **TreeSummarizedExperiment** | Bioconductor TreeSummarizedExperiment | 行/列树、节点链接、树节点子集、祖先/后代查询、层级聚合 | ✅ | @@ -489,6 +490,7 @@ IvanAXu/BioSeqs/ │ ├── deseq2_advanced.mbt # DESeq2 VST方差稳定化变换、PCA可视化 │ ├── apeglm.mbt # apeglm 自适应重尾LFC收缩、Laplace后验、FSR/FSOS与容器接入 │ ├── aldex2.mbt # ALDEx2 Dirichlet Monte Carlo组成型推断、检验、effect与容器接入 +│ ├── dirichlet_multinomial.mbt # DirichletMultinomial有限混合EM、模型选择、分类、CV与ROC │ ├── edger.mbt # edgeR 差异表达分析 (DGEList、精确检验、GLM拟合) │ ├── edger_advanced.mbt # edgeR准似然F检验、camera/roast基因集检验 │ ├── limma.mbt # limma 差异表达、归一化、批次校正 (线性模型、经验贝叶斯、voom、RPKM/CPM/quantile、ComBat) @@ -920,6 +922,7 @@ IvanAXu/BioSeqs/ │ ├── zinbwave_demo/ # zinbwave latent factors、dropout权重、残差/插补与SCE集成示例 │ ├── apeglm_demo/ # apeglm MLE/MAP、重尾收缩、FSR/FSOS、TSV与SE接入示例 │ ├── aldex2_demo/ # ALDEx2 IQLR、Dirichlet实例、effect/eBH、距离与SE接入示例 +│ ├── dirichlet_multinomial_demo/ # DMM聚类、选K、分组分类、交叉验证、ROC与SE接入示例 │ ├── variance_partition_demo/ # variancePartition 方差分解、BLUP、precision weights、dream与SE接入示例 │ ├── dreamlet_demo/ # dreamlet SCE pseudobulk、TMM/voom、donor随机截距与跨cell-type FDR示例 │ ├── monocle3_demo/ # monocle3 单细胞轨迹分析示例 (PCA/UMAP降维、主图学习、拟时间排序) @@ -1330,6 +1333,7 @@ IvanAXu/BioSeqs/ │ │ ├── zinbwave_test.mbt │ │ ├── apeglm_test.mbt │ │ ├── aldex2_test.mbt +│ │ ├── dirichlet_multinomial_test.mbt │ │ ├── variance_partition_test.mbt │ │ ├── dreamlet_test.mbt │ │ ├── shared_reference_alignment_test.mbt @@ -1831,6 +1835,7 @@ moon test # ✅ 9116 个测试全 | `zinbwave.mbt` | `zinbwave` | ZINB交替EM/IRLS、cell/gene design与offset、确定性低维因子、gene dispersion shrinkage、observational weights、deviance residual及SingleCellExperiment包装 | | `apeglm.mbt` | `apeglm` | 负二项GLM MLE、自适应Cauchy/Student-t先验、阻尼Newton多起点MAP、Laplace后验SD/区间、FSR/FSOS/s-value、DESeq2与SummarizedExperiment包装 | | `aldex2.mbt` | `ALDEx2` | count+prior Dirichlet Monte Carlo、all/median/IQLR/zero/LVHA/user分母、两组与配对检验、posterior expected BH、effect/overlap、距离和SummarizedExperiment包装 | +| `dirichlet_multinomial.mbt` | `DirichletMultinomial` | sample×taxon DMM概率、soft k-means初始化、log-alpha BFGS/EM、Gamma prior、Hessian区间、Laplace/AIC/BIC、dmngroup分类、分层CV、ROC与SummarizedExperiment入口 | | `variance_partition.mbt` | `variancePartition` | typed fixed/random design、多随机截距LMM、ML/REML方差分解、BLUP、weighted dream contrast、Satterthwaite自由度与SummarizedExperiment入口 | | `dreamlet.mbt` | `dreamlet` | SCE到sample×cluster pseudobulk、TMM/logCPM、两阶段voom precision weights、固定/随机效应筛选、逐cell-type dream和study-wide FDR | | `shared_reference_alignment.mbt` | `Bio.Align.Alignment` | 同参考PWA/MSA的reference-boundary insertion同步、原query投影、局部坐标、metadata、统计与格式转换 | @@ -2997,6 +3002,14 @@ composition 支持 wildcard、match/mismatch score 或替换矩阵；矩阵模 实现覆盖路径长度、坐标单调性、aligned step、有限 score 和矩阵 alphabet 校验；专项测试包含官方 BLOSUM62/BLOSUM45 示例、左右/内部 gap、连续 open/extend、wildcard、反向链、length-only alignment 和 MSA 汇总。同步修正既有标准 20×20 `BLOSUM45` 的 139 个错误分值，与 Biopython 1.86 官方矩阵逐项一致。当前 API 统计已有 coordinate alignment，不负责执行新的序列比对。 +### 260. Dirichlet-multinomial 混合聚类与分类 (Bioconductor DirichletMultinomial) + +实现 Bioconductor `DirichletMultinomial` 的可移植有限混合模型核心，原生输入与上游 `dmn()` 一致，采用 sample × taxon 非负整数计数矩阵。基础 API 提供 Dirichlet-multinomial log-PMF、均值和含过度离散膨胀的协方差。混合拟合先在相对丰度空间执行确定性 soft k-means，再以 posterior responsibility 和 component weight 进行 EM；每个 component 的 alpha 使用 log 参数化、Gamma(shape=0.1, rate=0.1) prior、inverse-BFGS、Armijo 回溯线搜索和显式参数边界优化，避免正值约束被迭代破坏。 + +`DmnFit` 返回按 mixture weight 降序排列的 alpha、权重、sample responsibility、component proportions、浓度、Hessian 近似区间和 likelihood 轨迹，并提供新样本 evidence、posterior 与 assignment。goodness-of-fit 遵循上游参数计数 `P = K × taxa + K - 1`，报告 negative log evidence、log determinant、Laplace、AIC 和 BIC；`dirichlet_multinomial_select` 比较连续 K。`dirichlet_multinomial_group_fit` 为每个 phenotype 拟合独立 DMM 并结合经验 group prior 构造生成式分类器，可指定每组 K 或按 Laplace 自动选择；另提供确定性分层交叉验证、概率输出和二分类 ROC/AUC。 + +`dirichlet_multinomial_fit_se` 从 `SummarizedExperiment` 的 feature × sample assay 校验并转置为 sample × taxon。构造器会诊断空/ragged矩阵、负数、非整数或非有限 assay、零文库、组件数、名称、group、fold 和预测维度错误。当前实现使用 dense MoonBit arrays 和确定性单线程求解，不依赖上游 C/GSL，也不包含稀疏矩阵专用优化、并行多起点、绘图或完整 S4 方法分派。 + ## 性能优化 ### 优化策略 @@ -3098,8 +3111,8 @@ composition 支持 wildcard、match/mismatch score 或替换矩阵；矩阵模 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 9253 | -| 通过数 | 9253 | +| 总测试数 | 9311 | +| 通过数 | 9311 | | 失败数 | 0 | | 通过率 | 100% | @@ -3231,6 +3244,7 @@ moon test --update | zinbwave | `zinbwave_test.mbt` | 54 | | apeglm | `apeglm_test.mbt` | 66 | | ALDEx2 | `aldex2_test.mbt` | 80 | +| DirichletMultinomial | `dirichlet_multinomial_test.mbt` | 58 | | monocle3 | `monocle3_test.mbt` | 10 | | ShortRead | `short_read_test.mbt` | 15 | | scater | `scater_test.mbt` | 17 | @@ -3506,7 +3520,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 367 个示例程序，展示各模块的典型用法： +项目提供 368 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3602,6 +3616,7 @@ moon run cmd/bench/main.mbt | zinbwave_demo | ZINB latent-factor拟合、dropout后验权重、归一化/插补/deviance residual和不可变SCE输出 | `moon run examples/zinbwave_demo` | | apeglm_demo | NB-GLM MLE与自适应重尾MAP、FSR/s-value/FSOS、log2 TSV及不可变SummarizedExperiment输出 | `moon run examples/apeglm_demo` | | aldex2_demo | Dirichlet Monte Carlo、IQLR、posterior expected eBH、effect/overlap、Aitchison距离及不可变SummarizedExperiment输出 | `moon run examples/aldex2_demo` | +| dirichlet_multinomial_demo | Dirichlet-multinomial混合聚类、Laplace选K、分组分类、分层交叉验证、ROC与SummarizedExperiment转置入口 | `moon run examples/dirichlet_multinomial_demo` | | mast_demo | MAST 单细胞差异表达分析（Hurdle模型、离散/连续检验、BH-FDR校正、结果汇总） | `moon run examples/mast_demo/main.mbt` | | genomic_files_demo | GenomicFiles 分布式基因组文件处理（BAM/BED/VCF扫描、区间查询、归约、覆盖度计算） | `moon run examples/genomic_files_demo/main.mbt` | | diffbind_demo | DiffBind ChIP-seq差异结合分析（峰值重叠、共识峰识别、TMM归一化、负二项分布检验） | `moon run examples/diffbind_demo/main.mbt` | @@ -3818,6 +3833,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bioconductor zinbwave 零膨胀负二项低维模型（cell/gene协变量、offset、latent factors、dispersion shrinkage、observational weights、残差/插补与SCE集成） - ✅ 实现 Bioconductor apeglm 自适应重尾效应量收缩（NB-GLM MLE、经验贝叶斯Cauchy/Student-t先验、多起点MAP、Laplace后验、FSR/FSOS/s-value与容器接入） - ✅ 实现 Bioconductor ALDEx2 组成型差异丰度（Dirichlet Monte Carlo、六类denominator、两组/配对检验、posterior expected BH、effect/overlap、距离与SummarizedExperiment接入） +- ✅ 实现 Bioconductor DirichletMultinomial 混合聚类与分类（DMM概率、soft k-means、log-alpha BFGS/EM、Gamma prior、Laplace/AIC/BIC、dmngroup分类、分层CV、ROC与SummarizedExperiment接入） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/dirichlet_multinomial_demo/main.mbt b/examples/dirichlet_multinomial_demo/main.mbt new file mode 100644 index 00000000..b0626c54 --- /dev/null +++ b/examples/dirichlet_multinomial_demo/main.mbt @@ -0,0 +1,162 @@ +///| +fn example_counts() -> Array[Array[Int]] { + [ + [40, 3, 2], + [35, 4, 1], + [42, 2, 3], + [38, 5, 2], + [45, 3, 1], + [36, 2, 4], + [2, 40, 3], + [4, 35, 2], + [3, 43, 1], + [5, 38, 2], + [1, 44, 3], + [3, 36, 4], + ] +} + +///| +fn example_groups() -> Array[String] { + ["A", "A", "A", "A", "A", "A", "B", "B", "B", "B", "B", "B"] +} + +///| +fn main { + println("=== Bioconductor DirichletMultinomial Demo ===") + let counts = example_counts() + let groups = example_groups() + let taxa = ["taxon_a", "taxon_b", "taxon_c"] + let config = @src.DmnConfig::create( + components=2, + max_iterations=50, + optimizer_iterations=120, + soft_kmeans_iterations=60, + seed=2026, + ) catch { + DirichletMultinomialError(message) => + abort("failed to create DirichletMultinomial configuration: " + message) + } + + println("\n1. Fit a finite Dirichlet-multinomial mixture") + let fit = @src.dirichlet_multinomial_fit(counts, taxon_names=taxa, config~) catch { + DirichletMultinomialError(message) => + abort("failed to fit Dirichlet-multinomial mixture: " + message) + } + println(" " + fit.summary()) + println(" mixture weights=" + fit.mixture_weights().to_string()) + println(" component proportions=" + fit.component_proportions().to_string()) + println(" assignments=" + fit.assignments().to_string()) + + println("\n2. Compare K=1 and K=2 with the upstream Laplace criterion") + let selection = @src.dirichlet_multinomial_select( + counts, + 2, + criterion=@src.DmnLaplace, + taxon_names=taxa, + config=config.with_components(1), + ) catch { + DirichletMultinomialError(message) => + abort("failed to select Dirichlet-multinomial model: " + message) + } + println(" Laplace scores=" + selection.scores.to_string()) + println( + " selected components=" + selection.best_component_count().to_string(), + ) + + println("\n3. Train a dmngroup-style generative classifier") + let classifier = @src.dirichlet_multinomial_group_fit( + counts, + groups, + components_by_group=[1, 1], + taxon_names=taxa, + config=config.with_components(1), + ) catch { + DirichletMultinomialError(message) => + abort("failed to fit Dirichlet-multinomial classifier: " + message) + } + let novel = [[50, 1, 1], [1, 50, 1]] + let probabilities = classifier.predict(novel) catch { + DirichletMultinomialError(message) => + abort("failed to classify novel samples: " + message) + } + let predictions = classifier.predict_assignments(novel) catch { + DirichletMultinomialError(message) => + abort("failed to assign novel samples: " + message) + } + println(" class probabilities=" + probabilities.to_string()) + println(" predictions=" + predictions.to_string()) + + println("\n4. Run deterministic stratified cross-validation and ROC") + let cross_validation = @src.dirichlet_multinomial_cross_validate( + counts, + groups, + 3, + components_by_group=[1, 1], + taxon_names=taxa, + config=config.with_components(1), + ) catch { + DirichletMultinomialError(message) => + abort("failed to cross-validate classifier: " + message) + } + let truth : Array[Bool] = [] + let scores : Array[Double] = [] + for sample in 0.. + abort("failed to compute ROC: " + message) + } + println( + " accuracy=" + + cross_validation.accuracy.to_string() + + ", AUC=" + + roc.auc.to_string() + + ", best threshold=" + + roc.best_threshold.to_string(), + ) + + println("\n5. Fit a feature x sample SummarizedExperiment assay") + let assays : Map[String, Array[Array[Double]]] = Map([ + ( + "counts", + [ + [40.0, 35.0, 42.0, 2.0, 4.0, 3.0], + [3.0, 4.0, 2.0, 40.0, 35.0, 43.0], + [2.0, 1.0, 3.0, 3.0, 2.0, 1.0], + ], + ), + ]) + let experiment = @src.summarized_experiment(assays, [], [], Map([])) + let se_fit = @src.dirichlet_multinomial_fit_se( + experiment, + "counts", + taxon_names=taxa, + config~, + ) catch { + DirichletMultinomialError(message) => + abort("failed to fit SummarizedExperiment assay: " + message) + } + println( + " transposed dimensions=" + + se_fit.sample_count().to_string() + + " samples x " + + se_fit.taxon_count().to_string() + + " taxa", + ) + + println("\n6. Invalid count matrices produce explicit diagnostics") + let rejected = try { + ignore(@src.dirichlet_multinomial_fit([[3, -1], [2, 4]])) + false + } catch { + DirichletMultinomialError(message) => { + println(" " + message) + true + } + } + println(" malformed counts rejected=" + rejected.to_string()) + println("\n=== Demo Complete ===") +} diff --git a/examples/dirichlet_multinomial_demo/moon.pkg b/examples/dirichlet_multinomial_demo/moon.pkg new file mode 100644 index 00000000..8824b1ac --- /dev/null +++ b/examples/dirichlet_multinomial_demo/moon.pkg @@ -0,0 +1,6 @@ +import { + "IvanAXu/BioSeqs/src", + "moonbitlang/core/hashmap", +} + +pkgtype(kind: "executable") diff --git a/src/dirichlet_multinomial.mbt b/src/dirichlet_multinomial.mbt new file mode 100644 index 00000000..2e20ba28 --- /dev/null +++ b/src/dirichlet_multinomial.mbt @@ -0,0 +1,1823 @@ +// Dirichlet-multinomial mixture clustering and classification inspired by +// Bioconductor DirichletMultinomial. Count matrices use sample x taxon +// orientation, matching the upstream dmn() API. + +///| +pub suberror DirichletMultinomialError { + DirichletMultinomialError(String) +} + +///| +pub(all) enum DmnCriterion { + DmnLaplace + DmnBic + DmnAic +} derive(Eq, Debug) + +///| +pub struct DmnConfig { + components : Int + max_iterations : Int + optimizer_iterations : Int + soft_kmeans_iterations : Int + tolerance : Double + optimizer_tolerance : Double + soft_beta : Double + seed : Int + prior_shape : Double + prior_rate : Double + min_alpha : Double +} derive(Eq, Debug) + +///| +pub fn DmnConfig::create( + components? : Int = 1, + max_iterations? : Int = 100, + optimizer_iterations? : Int = 250, + soft_kmeans_iterations? : Int = 200, + tolerance? : Double = 1.0e-6, + optimizer_tolerance? : Double = 1.0e-5, + soft_beta? : Double = 50.0, + seed? : Int = 42, + prior_shape? : Double = 0.1, + prior_rate? : Double = 0.1, + min_alpha? : Double = 1.0e-8, +) -> DmnConfig raise DirichletMultinomialError { + if components < 1 { + raise DirichletMultinomialError( + "DirichletMultinomial component count must be positive", + ) + } + if max_iterations < 1 || + optimizer_iterations < 1 || + soft_kmeans_iterations < 1 { + raise DirichletMultinomialError( + "DirichletMultinomial iteration limits must be positive", + ) + } + if !dmn_is_finite(tolerance) || tolerance <= 0.0 { + raise DirichletMultinomialError( + "DirichletMultinomial EM tolerance must be finite and positive", + ) + } + if !dmn_is_finite(optimizer_tolerance) || optimizer_tolerance <= 0.0 { + raise DirichletMultinomialError( + "DirichletMultinomial optimizer tolerance must be finite and positive", + ) + } + if !dmn_is_finite(soft_beta) || soft_beta <= 0.0 { + raise DirichletMultinomialError( + "DirichletMultinomial soft k-means beta must be finite and positive", + ) + } + if seed <= 0 { + raise DirichletMultinomialError( + "DirichletMultinomial random seed must be positive", + ) + } + if !dmn_is_finite(prior_shape) || prior_shape <= 0.0 { + raise DirichletMultinomialError( + "DirichletMultinomial Gamma prior shape must be finite and positive", + ) + } + if !dmn_is_finite(prior_rate) || prior_rate <= 0.0 { + raise DirichletMultinomialError( + "DirichletMultinomial Gamma prior rate must be finite and positive", + ) + } + if !dmn_is_finite(min_alpha) || min_alpha <= 0.0 || min_alpha >= 1.0 { + raise DirichletMultinomialError( + "DirichletMultinomial minimum alpha must be finite and in (0, 1)", + ) + } + DmnConfig::{ + components, + max_iterations, + optimizer_iterations, + soft_kmeans_iterations, + tolerance, + optimizer_tolerance, + soft_beta, + seed, + prior_shape, + prior_rate, + min_alpha, + } +} + +///| +pub fn DmnConfig::default() -> DmnConfig { + DmnConfig::{ + components: 1, + max_iterations: 100, + optimizer_iterations: 250, + soft_kmeans_iterations: 200, + tolerance: 1.0e-6, + optimizer_tolerance: 1.0e-5, + soft_beta: 50.0, + seed: 42, + prior_shape: 0.1, + prior_rate: 0.1, + min_alpha: 1.0e-8, + } +} + +///| +pub fn DmnConfig::with_components( + self : DmnConfig, + components : Int, + seed? : Int = self.seed, +) -> DmnConfig raise DirichletMultinomialError { + DmnConfig::create( + components~, + max_iterations=self.max_iterations, + optimizer_iterations=self.optimizer_iterations, + soft_kmeans_iterations=self.soft_kmeans_iterations, + tolerance=self.tolerance, + optimizer_tolerance=self.optimizer_tolerance, + soft_beta=self.soft_beta, + seed~, + prior_shape=self.prior_shape, + prior_rate=self.prior_rate, + min_alpha=self.min_alpha, + ) +} + +///| +pub struct DmnGoodnessOfFit { + negative_log_evidence : Double + log_determinant : Double + laplace : Double + bic : Double + aic : Double +} derive(Eq, Debug) + +///| +pub struct DmnFit { + estimates : Array[Array[Double]] + lower : Array[Array[Double]] + upper : Array[Array[Double]] + weights : Array[Double] + responsibilities : Array[Array[Double]] + sample_names : Array[String] + taxon_names : Array[String] + goodness : DmnGoodnessOfFit + log_likelihoods : Array[Double] + converged : Bool + iterations : Int + config : DmnConfig +} + +///| +pub struct DmnModelSelection { + fits : Array[DmnFit] + scores : Array[Double] + best_index : Int + criterion : DmnCriterion +} + +///| +pub struct DmnGroupFit { + group_names : Array[String] + models : Array[DmnFit] + priors : Array[Double] + taxon_names : Array[String] +} + +///| +pub struct DmnCrossValidation { + probabilities : Array[Array[Double]] + predictions : Array[String] + truth : Array[String] + group_names : Array[String] + fold_ids : Array[Int] + correct : Int + accuracy : Double +} + +///| +pub struct DmnRoc { + thresholds : Array[Double] + sensitivity : Array[Double] + specificity : Array[Double] + auc : Double + best_threshold : Double +} derive(Eq, Debug) + +///| +fn dmn_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn dmn_make_matrix( + rows : Int, + columns : Int, + value : Double, +) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for _ in 0.. Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in values { + output.push(row.copy()) + } + output +} + +///| +fn dmn_default_names(prefix : String, count : Int) -> Array[String] { + let names : Array[String] = [] + for index in 0.. Unit raise DirichletMultinomialError { + if names.length() != expected { + raise DirichletMultinomialError( + "DirichletMultinomial " + label + " name count does not match data", + ) + } + let seen : Map[String, Bool] = Map([]) + for name in names { + let trimmed = name.trim().to_owned() + if trimmed.length() == 0 { + raise DirichletMultinomialError( + "DirichletMultinomial " + label + " names must not be empty", + ) + } + if seen.contains(trimmed) { + raise DirichletMultinomialError( + "DirichletMultinomial " + label + " names must be unique", + ) + } + seen[trimmed] = true + } +} + +///| +fn dmn_validate_counts( + counts : Array[Array[Int]], +) -> (Int, Int) raise DirichletMultinomialError { + if counts.length() == 0 { + raise DirichletMultinomialError( + "DirichletMultinomial count matrix must contain samples", + ) + } + let taxa = counts[0].length() + if taxa == 0 { + raise DirichletMultinomialError( + "DirichletMultinomial count matrix must contain taxa", + ) + } + for sample in 0.. Double { + let coefficients = [ + 0.9999999999998099, 676.5203681218851, -1259.1392167224028, 771.3234287776531, + -176.6150291621406, 12.507343278686905, -0.13857109526572012, 9.984369578019572e-6, + 1.5056327351493116e-7, + ] + if value < 0.5 { + let pi = 3.141592653589793 + return @math.ln(pi) - + @math.ln(@math.sin(pi * value).abs()) - + dmn_log_gamma(1.0 - value) + } + let shifted = value - 1.0 + let mut series = coefficients[0] + for index in 1.. Double { + let mut x = value + let mut result = 0.0 + while x < 8.0 { + result = result - 1.0 / x + x = x + 1.0 + } + let inverse = 1.0 / x + let inverse2 = inverse * inverse + result + + @math.ln(x) - + 0.5 * inverse - + inverse2 * (1.0 / 12.0 - inverse2 * (1.0 / 120.0 - inverse2 * (1.0 / 252.0))) +} + +///| +fn dmn_trigamma(value : Double) -> Double { + let mut x = value + let mut result = 0.0 + while x < 8.0 { + result = result + 1.0 / (x * x) + x = x + 1.0 + } + let inverse = 1.0 / x + let inverse2 = inverse * inverse + result + + inverse + + 0.5 * inverse2 + + inverse2 * inverse / 6.0 - + inverse2 * inverse2 * inverse / 30.0 + + inverse2 * inverse2 * inverse2 * inverse / 42.0 +} + +///| +fn dmn_log_sum_exp(values : Array[Double]) -> Double { + let mut maximum = values[0] + for value in values { + if value > maximum { + maximum = value + } + } + let mut total = 0.0 + for value in values { + total = total + @math.exp(value - maximum) + } + maximum + @math.ln(total) +} + +///| +fn dmn_row_total(row : Array[Int]) -> Int { + let mut total = 0 + for value in row { + total = total + value + } + total +} + +///| +fn dmn_component_log_kernel( + counts : Array[Int], + alpha : Array[Double], +) -> Double { + let mut alpha_total = 0.0 + let mut count_total = 0 + let mut value = 0.0 + for taxon in 0.. Double raise DirichletMultinomialError { + if counts.length() == 0 || counts.length() != alpha.length() { + raise DirichletMultinomialError( + "Dirichlet-multinomial count and alpha vectors must have equal positive length", + ) + } + let mut total = 0 + let mut coefficient = 0.0 + for index in 0.. Array[Double] raise DirichletMultinomialError { + if total_count < 0 || alpha.length() == 0 { + raise DirichletMultinomialError( + "Dirichlet-multinomial mean requires a non-negative count and positive alpha length", + ) + } + let mut concentration = 0.0 + for value in alpha { + if !dmn_is_finite(value) || value <= 0.0 { + raise DirichletMultinomialError( + "Dirichlet-multinomial alpha values must be finite and positive", + ) + } + concentration = concentration + value + } + alpha.map(fn(value) { total_count.to_double() * value / concentration }) +} + +///| +pub fn dirichlet_multinomial_covariance( + total_count : Int, + alpha : Array[Double], +) -> Array[Array[Double]] raise DirichletMultinomialError { + let mean = dirichlet_multinomial_mean(total_count, alpha) + let taxa = alpha.length() + let mut concentration = 0.0 + for value in alpha { + concentration = concentration + value + } + let inflation = (total_count.to_double() + concentration) / + (1.0 + concentration) + let covariance = dmn_make_matrix(taxa, taxa, 0.0) + for left in 0.. Int { + state * 48271 % 2147483647 +} + +///| +fn dmn_soft_kmeans( + counts : Array[Array[Int]], + config : DmnConfig, +) -> (Array[Array[Double]], Array[Array[Double]]) { + let samples = counts.length() + let taxa = counts[0].length() + let components = config.components + let proportions = dmn_make_matrix(samples, taxa, 0.0) + for sample in 0.. config.tolerance { + change = 0.0 + for component in 0.. (Double, Array[Double]) { + let samples = counts.length() + let taxa = lambda.length() + let alpha : Array[Double] = [] + let mut concentration = 0.0 + let mut lambda_sum = 0.0 + for value in lambda { + let bounded = value.max(-18.0).min(18.0) + let parameter = @math.exp(bounded).max(config.min_alpha) + alpha.push(parameter) + concentration = concentration + parameter + lambda_sum = lambda_sum + bounded + } + let mut weight = 0.0 + for value in membership { + weight = weight + value + } + + let mut objective = config.prior_rate * concentration - + config.prior_shape * lambda_sum - + weight * dmn_log_gamma(concentration) + for parameter in alpha { + objective = objective + weight * dmn_log_gamma(parameter) + } + for sample in 0.. 0.0 { + let total = dmn_row_total(counts[sample]).to_double() + objective = objective + + membership[sample] * dmn_log_gamma(concentration + total) + for taxon in 0.. Double { + let mut value = 0.0 + for index in 0.. Array[Array[Double]] { + let output = dmn_make_matrix(size, size, 0.0) + for index in 0.. Array[Double] { + let output = Array::make(matrix.length(), 0.0) + for row in 0.. Array[Double] { + let taxa = initial.length() + let mut lambda = initial.map(fn(value) { + @math.ln(value.max(config.min_alpha)) + }) + let mut inverse_hessian = dmn_identity(taxa) + let (initial_objective, initial_gradient) = dmn_alpha_objective_gradient( + lambda, counts, membership, config, + ) + let mut objective = initial_objective + let mut gradient = initial_gradient + let mut iteration = 0 + + while iteration < config.optimizer_iterations { + let mut maximum_gradient = 0.0 + for value in gradient { + maximum_gradient = maximum_gradient.max(value.abs()) + } + if maximum_gradient <= config.optimizer_tolerance { + break + } + + let transformed = dmn_matrix_vector(inverse_hessian, gradient) + let direction = transformed.map(fn(value) { -value }) + let mut directional_derivative = dmn_dot(gradient, direction) + if !dmn_is_finite(directional_derivative) || directional_derivative >= 0.0 { + let norm = dmn_dot(gradient, gradient).sqrt().max(1.0) + for index in 0.. 1.0e-12 { + let rho = 1.0 / curvature + let hessian_gradient = dmn_matrix_vector(inverse_hessian, gradient_change) + let quadratic = dmn_dot(gradient_change, hessian_gradient) + for row in 0.. (Array[Array[Double]], Double) { + let samples = counts.length() + let components = estimates.length() + let responsibilities = dmn_make_matrix(samples, components, 0.0) + let mut log_likelihood = 0.0 + for sample in 0.. Double { + let components = estimates.length() + let taxa = estimates[0].length() + let mut alpha_total = 0.0 + let mut lambda_total = 0.0 + for component in estimates { + for alpha in component { + alpha_total = alpha_total + alpha + lambda_total = lambda_total + @math.ln(alpha) + } + } + -log_likelihood + + (components * taxa).to_double() * dmn_log_gamma(config.prior_shape) - + config.prior_shape * + (components * taxa).to_double() * + @math.ln(config.prior_rate) + + config.prior_rate * alpha_total - + config.prior_shape * lambda_total +} + +///| +fn dmn_hessian( + counts : Array[Array[Int]], + membership : Array[Double], + alpha : Array[Double], + config : DmnConfig, +) -> Array[Array[Double]] { + let taxa = alpha.length() + let samples = counts.length() + let hessian = dmn_make_matrix(taxa, taxa, 0.0) + let mut concentration = 0.0 + let mut weight = 0.0 + for value in alpha { + concentration = concentration + value + } + for value in membership { + weight = weight + value + } + + let mut common_digamma = -weight * dmn_digamma(concentration) + let mut common_trigamma = -weight * dmn_trigamma(concentration) + for sample in 0.. Double { + let size = matrix.length() + let work = dmn_copy_matrix(matrix) + for index in 0.. maximum { + maximum = work[row][pivot].abs() + selected = row + } + } + if maximum < 1.0e-14 { + return 0.0 + } + if selected != pivot { + let swap = work[pivot] + work[pivot] = work[selected] + work[selected] = swap + } + let diagonal = work[pivot][pivot] + result = result + @math.ln(diagonal.abs()) + for row in (pivot + 1).. Array[Array[Double]]? { + let size = matrix.length() + let augmented = dmn_make_matrix(size, size * 2, 0.0) + for row in 0.. maximum { + maximum = augmented[row][pivot].abs() + selected = row + } + } + if maximum < 1.0e-14 { + return None + } + if selected != pivot { + let swap = augmented[pivot] + augmented[pivot] = augmented[selected] + augmented[selected] = swap + } + let diagonal = augmented[pivot][pivot] + for column in 0..<(size * 2) { + augmented[pivot][column] = augmented[pivot][column] / diagonal + } + for row in 0.. (Array[Array[Double]], Array[Double], Array[Array[Double]]) { + let order : Array[Int] = [] + for component in 0.. Int { + if weights[left] > weights[right] { + -1 + } else if weights[left] < weights[right] { + 1 + } else { + left - right + } + }) + let sorted_estimates : Array[Array[Double]] = [] + let sorted_weights : Array[Double] = [] + for component in order { + sorted_estimates.push(estimates[component].copy()) + sorted_weights.push(weights[component]) + } + let sorted_responsibilities = dmn_make_matrix( + responsibilities.length(), + weights.length(), + 0.0, + ) + for sample in 0.. DmnFit raise DirichletMultinomialError { + let (samples, taxa) = dmn_validate_counts(counts) + if config.components > samples { + raise DirichletMultinomialError( + "DirichletMultinomial component count must not exceed sample count", + ) + } + let resolved_sample_names = if sample_names.length() == 0 { + dmn_default_names("sample", samples) + } else { + dmn_validate_names(sample_names, samples, "sample") + sample_names.copy() + } + let resolved_taxon_names = if taxon_names.length() == 0 { + dmn_default_names("taxon", taxa) + } else { + dmn_validate_names(taxon_names, taxa, "taxon") + taxon_names.copy() + } + + let (initial_responsibilities, centers) = dmn_soft_kmeans(counts, config) + let mut responsibilities = initial_responsibilities + let estimates : Array[Array[Double]] = [] + for component in 0.. 0 && change <= config.tolerance * (1.0 + previous.abs()) { + converged = true + iteration = iteration + 1 + break + } + previous = negative_evidence + iteration = iteration + 1 + } + + let (final_responsibilities, final_log_likelihood) = dmn_expectation( + counts, estimates, weights, + ) + let (sorted_estimates, sorted_weights, sorted_responsibilities) = dmn_sort_components( + estimates, weights, final_responsibilities, + ) + let lower = dmn_make_matrix(config.components, taxa, 0.0) + let upper = dmn_make_matrix(config.components, taxa, 0.0) + let mut log_determinant = 0.0 + for component in 0.. 0 { + log_determinant = log_determinant + + @math.ln(samples.to_double()) - + @math.ln(sorted_weights[component].max(1.0e-300)) + } + match dmn_inverse(hessian) { + Some(covariance) => + for taxon in 0.. + for taxon in 0.. Int { + self.estimates.length() +} + +///| +pub fn DmnFit::sample_count(self : DmnFit) -> Int { + self.responsibilities.length() +} + +///| +pub fn DmnFit::taxon_count(self : DmnFit) -> Int { + self.taxon_names.length() +} + +///| +pub fn DmnFit::mixture(self : DmnFit) -> Array[Array[Double]] { + dmn_copy_matrix(self.responsibilities) +} + +///| +pub fn DmnFit::mixture_weights(self : DmnFit) -> Array[Double] { + self.weights.copy() +} + +///| +pub fn DmnFit::concentrations(self : DmnFit) -> Array[Double] { + self.estimates.map(fn(component) { + let mut total = 0.0 + for value in component { + total = total + value + } + total + }) +} + +///| +pub fn DmnFit::component_proportions(self : DmnFit) -> Array[Array[Double]] { + let output = dmn_copy_matrix(self.estimates) + for component in 0.. Array[Array[Double]] { + let taxa = self.taxon_count() + let components = self.component_count() + let output = dmn_make_matrix(taxa, components, 0.0) + for component in 0.. Array[Int] { + self.responsibilities.map(fn(row) { + let mut selected = 0 + for component in 1.. row[selected] { + selected = component + } + } + selected + }) +} + +///| +pub fn DmnFit::negative_log_evidence( + self : DmnFit, + counts : Array[Array[Int]], +) -> Array[Array[Double]] raise DirichletMultinomialError { + let (_, taxa) = dmn_validate_counts(counts) + if taxa != self.taxon_count() { + raise DirichletMultinomialError( + "DirichletMultinomial prediction taxon count does not match the model", + ) + } + let output = dmn_make_matrix(counts.length(), self.component_count(), 0.0) + for sample in 0.. Array[Array[Double]] raise DirichletMultinomialError { + let negative_evidence = self.negative_log_evidence(counts) + let output = dmn_make_matrix(counts.length(), self.component_count(), 0.0) + for sample in 0.. Array[Int] raise DirichletMultinomialError { + self + .predict(counts) + .map(fn(row) { + let mut selected = 0 + for component in 1.. row[selected] { + selected = component + } + } + selected + }) +} + +///| +pub fn DmnFit::summary(self : DmnFit) -> String { + "DMN fit: k=" + + self.component_count().to_string() + + ", samples=" + + self.sample_count().to_string() + + ", taxa=" + + self.taxon_count().to_string() + + ", iterations=" + + self.iterations.to_string() + + ", converged=" + + self.converged.to_string() + + ", Laplace=" + + self.goodness.laplace.to_string() + + ", BIC=" + + self.goodness.bic.to_string() + + ", AIC=" + + self.goodness.aic.to_string() +} + +///| +fn dmn_criterion_score(fit : DmnFit, criterion : DmnCriterion) -> Double { + match criterion { + DmnLaplace => fit.goodness.laplace + DmnBic => fit.goodness.bic + DmnAic => fit.goodness.aic + } +} + +///| +pub fn dirichlet_multinomial_select( + counts : Array[Array[Int]], + max_components : Int, + criterion? : DmnCriterion = DmnLaplace, + sample_names? : Array[String] = [], + taxon_names? : Array[String] = [], + config? : DmnConfig = DmnConfig::default(), +) -> DmnModelSelection raise DirichletMultinomialError { + let (samples, _) = dmn_validate_counts(counts) + if max_components < 1 || max_components > samples { + raise DirichletMultinomialError( + "DirichletMultinomial model-selection range must be within sample count", + ) + } + let fits : Array[DmnFit] = [] + let scores : Array[Double] = [] + let mut best_index = 0 + for components in 1..<=max_components { + let fit_config = config.with_components( + components, + seed=config.seed + components * 7919, + ) + let fit = dirichlet_multinomial_fit( + counts, + sample_names~, + taxon_names~, + config=fit_config, + ) + fits.push(fit) + let score = dmn_criterion_score(fit, criterion) + scores.push(score) + if score < scores[best_index] { + best_index = components - 1 + } + } + DmnModelSelection::{ fits, scores, best_index, criterion } +} + +///| +pub fn DmnModelSelection::best_fit(self : DmnModelSelection) -> DmnFit { + self.fits[self.best_index] +} + +///| +pub fn DmnModelSelection::best_component_count(self : DmnModelSelection) -> Int { + self.best_index + 1 +} + +///| +fn dmn_unique_groups(groups : Array[String]) -> Array[String] { + let output : Array[String] = [] + let seen : Map[String, Bool] = Map([]) + for group in groups { + if !seen.contains(group) { + seen[group] = true + output.push(group) + } + } + output +} + +///| +pub fn dirichlet_multinomial_group_fit( + counts : Array[Array[Int]], + groups : Array[String], + components_by_group? : Array[Int] = [], + max_components? : Int = 3, + taxon_names? : Array[String] = [], + config? : DmnConfig = DmnConfig::default(), +) -> DmnGroupFit raise DirichletMultinomialError { + let (samples, taxa) = dmn_validate_counts(counts) + if groups.length() != samples { + raise DirichletMultinomialError( + "DirichletMultinomial group label count does not match samples", + ) + } + for group in groups { + if group.trim().length() == 0 { + raise DirichletMultinomialError( + "DirichletMultinomial group labels must not be empty", + ) + } + } + let group_names = dmn_unique_groups(groups) + if group_names.length() < 2 { + raise DirichletMultinomialError( + "DirichletMultinomial group fitting requires at least two groups", + ) + } + if components_by_group.length() > 0 && + components_by_group.length() != group_names.length() { + raise DirichletMultinomialError( + "DirichletMultinomial group component counts must match group count", + ) + } + if components_by_group.length() == 0 && max_components < 1 { + raise DirichletMultinomialError( + "DirichletMultinomial maximum group component count must be positive", + ) + } + let resolved_taxon_names = if taxon_names.length() == 0 { + dmn_default_names("taxon", taxa) + } else { + dmn_validate_names(taxon_names, taxa, "taxon") + taxon_names.copy() + } + let models : Array[DmnFit] = [] + let priors : Array[Double] = [] + for group_index in 0.. 0 { + if components_by_group[group_index] < 1 || + components_by_group[group_index] > group_counts.length() { + raise DirichletMultinomialError( + "DirichletMultinomial group component count exceeds group sample count", + ) + } + dirichlet_multinomial_fit( + group_counts, + sample_names=group_samples, + taxon_names=resolved_taxon_names, + config=config.with_components( + components_by_group[group_index], + seed=config.seed + group_index * 3571 + 1, + ), + ) + } else { + let maximum = max_components.min(group_counts.length()) + dirichlet_multinomial_select( + group_counts, + maximum, + sample_names=group_samples, + taxon_names=resolved_taxon_names, + config=config.with_components( + 1, + seed=config.seed + group_index * 3571 + 1, + ), + ).best_fit() + } + models.push(model) + } + DmnGroupFit::{ + group_names, + models, + priors, + taxon_names: resolved_taxon_names, + } +} + +///| +pub fn DmnGroupFit::predict( + self : DmnGroupFit, + counts : Array[Array[Int]], +) -> Array[Array[Double]] raise DirichletMultinomialError { + let (_, taxa) = dmn_validate_counts(counts) + if taxa != self.taxon_names.length() { + raise DirichletMultinomialError( + "DirichletMultinomial group prediction taxon count does not match models", + ) + } + let output = dmn_make_matrix(counts.length(), self.group_names.length(), 0.0) + for sample in 0.. Array[String] raise DirichletMultinomialError { + self + .predict(counts) + .map(fn(row) { + let mut selected = 0 + for group in 1.. row[selected] { + selected = group + } + } + self.group_names[selected] + }) +} + +///| +pub fn dirichlet_multinomial_cross_validate( + counts : Array[Array[Int]], + groups : Array[String], + folds : Int, + components_by_group? : Array[Int] = [], + taxon_names? : Array[String] = [], + config? : DmnConfig = DmnConfig::default(), +) -> DmnCrossValidation raise DirichletMultinomialError { + let (samples, _) = dmn_validate_counts(counts) + if groups.length() != samples { + raise DirichletMultinomialError( + "DirichletMultinomial cross-validation group count does not match samples", + ) + } + let group_names = dmn_unique_groups(groups) + if folds < 2 { + raise DirichletMultinomialError( + "DirichletMultinomial cross-validation requires at least two folds", + ) + } + let group_seen : Map[String, Int] = Map([]) + let group_sizes : Map[String, Int] = Map([]) + for group in groups { + group_sizes[group] = match group_sizes.get(group) { + Some(value) => value + 1 + None => 1 + } + } + for group in group_names { + if group_sizes[group] < folds { + raise DirichletMultinomialError( + "DirichletMultinomial each group must contain at least one sample per fold", + ) + } + } + let fold_ids = Array::make(samples, 0) + for sample in 0.. value + None => 0 + } + fold_ids[sample] = seen % folds + group_seen[groups[sample]] = seen + 1 + } + + let probabilities = dmn_make_matrix(samples, group_names.length(), 0.0) + let predictions = Array::make(samples, "") + for fold in 0.. + probabilities[original][group] = fold_probabilities[index][classifier_group] + None => () + } + } + predictions[original] = fold_predictions[index] + } + } + let mut correct = 0 + for sample in 0.. DmnRoc raise DirichletMultinomialError { + if truth.length() == 0 || truth.length() != scores.length() { + raise DirichletMultinomialError( + "DirichletMultinomial ROC truth and score vectors must have equal positive length", + ) + } + let mut positives = 0 + let mut negatives = 0 + let mut maximum = scores[0] + let mut minimum = scores[0] + for index in 0.. Int { + if left > right { + -1 + } else if left < right { + 1 + } else { + 0 + } + }) + let thresholds : Array[Double] = [maximum + 1.0e-12] + for value in sorted_scores { + if (value - thresholds[thresholds.length() - 1]).abs() > 1.0e-12 { + thresholds.push(value) + } + } + thresholds.push(minimum - 1.0e-12) + let sensitivity : Array[Double] = [] + let specificity : Array[Double] = [] + let mut best_threshold = thresholds[0] + let mut best_youden = -1.0e300 + for threshold in thresholds { + let mut true_positive = 0 + let mut false_positive = 0 + for index in 0..= threshold { + if truth[index] { + true_positive = true_positive + 1 + } else { + false_positive = false_positive + 1 + } + } + } + let current_sensitivity = true_positive.to_double() / positives.to_double() + let current_specificity = 1.0 - + false_positive.to_double() / negatives.to_double() + sensitivity.push(current_sensitivity) + specificity.push(current_specificity) + let youden = current_sensitivity + current_specificity - 1.0 + if youden > best_youden { + best_youden = youden + best_threshold = threshold + } + } + let mut concordance = 0.0 + for positive in 0.. scores[negative] { + concordance = concordance + 1.0 + } else if scores[positive] == scores[negative] { + concordance = concordance + 0.5 + } + } + } + } + } + DmnRoc::{ + thresholds, + sensitivity, + specificity, + auc: concordance / (positives * negatives).to_double(), + best_threshold, + } +} + +///| +pub fn dirichlet_multinomial_fit_se( + experiment : SummarizedExperiment, + assay_name : String, + sample_names? : Array[String] = [], + taxon_names? : Array[String] = [], + config? : DmnConfig = DmnConfig::default(), +) -> DmnFit raise DirichletMultinomialError { + let assay = match se_assay(experiment, assay_name) { + Some(value) => value + None => + raise DirichletMultinomialError( + "DirichletMultinomial assay was not found in SummarizedExperiment", + ) + } + if assay.length() == 0 || assay[0].length() == 0 { + raise DirichletMultinomialError( + "DirichletMultinomial assay must contain taxa and samples", + ) + } + let taxa = assay.length() + let samples = assay[0].length() + let counts : Array[Array[Int]] = [] + for sample in 0.. 1.0e-8 { + raise DirichletMultinomialError( + "DirichletMultinomial assay must contain non-negative integer counts", + ) + } + row.push(value.round().to_int()) + } + counts.push(row) + } + dirichlet_multinomial_fit(counts, sample_names~, taxon_names~, config~) +} diff --git a/test/moonbit/dirichlet_multinomial_test.mbt b/test/moonbit/dirichlet_multinomial_test.mbt new file mode 100644 index 00000000..84b4d502 --- /dev/null +++ b/test/moonbit/dirichlet_multinomial_test.mbt @@ -0,0 +1,994 @@ +// Tests for the Bioconductor DirichletMultinomial-inspired module. + +///| +fn dmn_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "DirichletMultinomial value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn dmn_test_row_sum(values : Array[Double]) -> Double { + let mut total = 0.0 + for value in values { + total = total + value + } + total +} + +///| +fn dmn_test_counts() -> Array[Array[Int]] { + [ + [40, 3, 2], + [35, 4, 1], + [42, 2, 3], + [38, 5, 2], + [45, 3, 1], + [36, 2, 4], + [2, 40, 3], + [4, 35, 2], + [3, 43, 1], + [5, 38, 2], + [1, 44, 3], + [3, 36, 4], + ] +} + +///| +fn dmn_test_groups() -> Array[String] { + ["A", "A", "A", "A", "A", "A", "B", "B", "B", "B", "B", "B"] +} + +///| +fn dmn_test_config(components : Int) -> @src.DmnConfig { + @src.DmnConfig::create( + components~, + max_iterations=40, + optimizer_iterations=100, + soft_kmeans_iterations=50, + tolerance=1.0e-5, + optimizer_tolerance=1.0e-5, + seed=2026, + ) catch { + DirichletMultinomialError(message) => + abort("valid DirichletMultinomial configuration failed: " + message) + } +} + +///| +fn dmn_test_fit(components : Int) -> @src.DmnFit { + @src.dirichlet_multinomial_fit( + dmn_test_counts(), + taxon_names=["taxon_a", "taxon_b", "taxon_c"], + config=dmn_test_config(components), + ) catch { + DirichletMultinomialError(message) => + abort("DirichletMultinomial test fit failed: " + message) + } +} + +///| +test "dirichlet_multinomial: default configuration matches upstream controls" { + let config = @src.DmnConfig::default() + assert_eq(config.components, 1) + assert_eq(config.max_iterations, 100) + assert_eq(config.optimizer_iterations, 250) + assert_eq(config.soft_kmeans_iterations, 200) + assert_eq(config.tolerance, 1.0e-6) + assert_eq(config.optimizer_tolerance, 1.0e-5) + assert_eq(config.soft_beta, 50.0) + assert_eq(config.seed, 42) + assert_eq(config.prior_shape, 0.1) + assert_eq(config.prior_rate, 0.1) + assert_eq(config.min_alpha, 1.0e-8) +} + +///| +test "dirichlet_multinomial: custom configuration preserves controls" { + let config = @src.DmnConfig::create( + components=3, + max_iterations=9, + optimizer_iterations=11, + soft_kmeans_iterations=13, + tolerance=0.01, + optimizer_tolerance=0.02, + soft_beta=25.0, + seed=99, + prior_shape=0.2, + prior_rate=0.3, + min_alpha=1.0e-7, + ) catch { + _ => abort("custom DirichletMultinomial configuration should be valid") + } + assert_eq(config.components, 3) + assert_eq(config.max_iterations, 9) + assert_eq(config.optimizer_iterations, 11) + assert_eq(config.soft_kmeans_iterations, 13) + assert_eq(config.soft_beta, 25.0) + assert_eq(config.seed, 99) + assert_eq(config.prior_shape, 0.2) + assert_eq(config.prior_rate, 0.3) +} + +///| +test "dirichlet_multinomial: with_components preserves optimization controls" { + let original = dmn_test_config(1) + let changed = original.with_components(2, seed=77) catch { + _ => abort("with_components should accept positive component counts") + } + assert_eq(changed.components, 2) + assert_eq(changed.seed, 77) + assert_eq(changed.max_iterations, original.max_iterations) + assert_eq(changed.optimizer_iterations, original.optimizer_iterations) + assert_eq(changed.soft_beta, original.soft_beta) +} + +///| +test "dirichlet_multinomial: configuration rejects nonpositive components" { + let raised = try { + ignore(@src.DmnConfig::create(components=0)) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(raised) +} + +///| +test "dirichlet_multinomial: configuration rejects invalid iteration limits" { + let em = try { + ignore(@src.DmnConfig::create(max_iterations=0)) + false + } catch { + DirichletMultinomialError(_) => true + } + let optimizer = try { + ignore(@src.DmnConfig::create(optimizer_iterations=0)) + false + } catch { + DirichletMultinomialError(_) => true + } + let kmeans = try { + ignore(@src.DmnConfig::create(soft_kmeans_iterations=0)) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(em) + assert_true(optimizer) + assert_true(kmeans) +} + +///| +test "dirichlet_multinomial: configuration rejects invalid tolerances" { + let em = try { + ignore(@src.DmnConfig::create(tolerance=0.0)) + false + } catch { + DirichletMultinomialError(_) => true + } + let optimizer = try { + ignore(@src.DmnConfig::create(optimizer_tolerance=-0.1)) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(em) + assert_true(optimizer) +} + +///| +test "dirichlet_multinomial: configuration rejects invalid soft beta and seed" { + let beta = try { + ignore(@src.DmnConfig::create(soft_beta=0.0)) + false + } catch { + DirichletMultinomialError(_) => true + } + let seed = try { + ignore(@src.DmnConfig::create(seed=0)) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(beta) + assert_true(seed) +} + +///| +test "dirichlet_multinomial: configuration rejects invalid Gamma priors" { + let shape = try { + ignore(@src.DmnConfig::create(prior_shape=0.0)) + false + } catch { + DirichletMultinomialError(_) => true + } + let rate = try { + ignore(@src.DmnConfig::create(prior_rate=-0.1)) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(shape) + assert_true(rate) +} + +///| +test "dirichlet_multinomial: configuration rejects invalid alpha floor" { + let zero = try { + ignore(@src.DmnConfig::create(min_alpha=0.0)) + false + } catch { + DirichletMultinomialError(_) => true + } + let one = try { + ignore(@src.DmnConfig::create(min_alpha=1.0)) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(zero) + assert_true(one) +} + +///| +test "dirichlet_multinomial: known beta-binomial probability is exact" { + let value = @src.dirichlet_multinomial_log_pmf([2, 1], [1.0, 1.0]) catch { + _ => abort("valid Dirichlet-multinomial PMF should succeed") + } + dmn_test_close(value, -1.3862943611198906, 1.0e-10) +} + +///| +test "dirichlet_multinomial: PMF normalizes over two-count compositions" { + let mut total = 0.0 + for left in 0..<=2 { + let log_probability = @src.dirichlet_multinomial_log_pmf([left, 2 - left], [ + 1.0, 1.0, + ]) catch { + _ => abort("valid Dirichlet-multinomial PMF should succeed") + } + total = total + @math.exp(log_probability) + } + dmn_test_close(total, 1.0, 1.0e-10) +} + +///| +test "dirichlet_multinomial: PMF is symmetric under paired permutation" { + let left = @src.dirichlet_multinomial_log_pmf([4, 1], [2.0, 3.0]) catch { + _ => abort("valid Dirichlet-multinomial PMF should succeed") + } + let right = @src.dirichlet_multinomial_log_pmf([1, 4], [3.0, 2.0]) catch { + _ => abort("valid Dirichlet-multinomial PMF should succeed") + } + dmn_test_close(left, right, 1.0e-12) +} + +///| +test "dirichlet_multinomial: all-zero count vector has unit probability" { + let value = @src.dirichlet_multinomial_log_pmf([0, 0, 0], [0.5, 1.5, 2.5]) catch { + _ => abort("zero-count Dirichlet-multinomial PMF should succeed") + } + dmn_test_close(value, 0.0, 1.0e-12) +} + +///| +test "dirichlet_multinomial: PMF rejects dimension mismatch" { + let raised = try { + ignore(@src.dirichlet_multinomial_log_pmf([1, 2], [1.0])) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(raised) +} + +///| +test "dirichlet_multinomial: PMF rejects negative counts" { + let raised = try { + ignore(@src.dirichlet_multinomial_log_pmf([1, -1], [1.0, 1.0])) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(raised) +} + +///| +test "dirichlet_multinomial: PMF rejects nonpositive alpha" { + let zero = try { + ignore(@src.dirichlet_multinomial_log_pmf([1, 1], [1.0, 0.0])) + false + } catch { + DirichletMultinomialError(_) => true + } + let huge = try { + ignore(@src.dirichlet_multinomial_log_pmf([1, 1], [1.0, 1.0e301])) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(zero) + assert_true(huge) +} + +///| +test "dirichlet_multinomial: mean follows alpha proportions" { + let mean = @src.dirichlet_multinomial_mean(10, [2.0, 3.0]) catch { + _ => abort("valid Dirichlet-multinomial mean should succeed") + } + assert_eq(mean.length(), 2) + dmn_test_close(mean[0], 4.0, 1.0e-12) + dmn_test_close(mean[1], 6.0, 1.0e-12) +} + +///| +test "dirichlet_multinomial: zero-total mean is zero" { + let mean = @src.dirichlet_multinomial_mean(0, [2.0, 3.0]) catch { + _ => abort("zero-total Dirichlet-multinomial mean should succeed") + } + assert_eq(mean, [0.0, 0.0]) +} + +///| +test "dirichlet_multinomial: mean validates total and alpha" { + let total = try { + ignore(@src.dirichlet_multinomial_mean(-1, [1.0])) + false + } catch { + DirichletMultinomialError(_) => true + } + let alpha = try { + ignore(@src.dirichlet_multinomial_mean(2, [1.0, -1.0])) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(total) + assert_true(alpha) +} + +///| +test "dirichlet_multinomial: covariance includes overdispersion inflation" { + let covariance = @src.dirichlet_multinomial_covariance(10, [2.0, 3.0]) catch { + _ => abort("valid Dirichlet-multinomial covariance should succeed") + } + dmn_test_close(covariance[0][0], 6.0, 1.0e-12) + dmn_test_close(covariance[1][1], 6.0, 1.0e-12) + dmn_test_close(covariance[0][1], -6.0, 1.0e-12) + dmn_test_close(covariance[1][0], -6.0, 1.0e-12) +} + +///| +test "dirichlet_multinomial: zero-total covariance is zero" { + let covariance = @src.dirichlet_multinomial_covariance(0, [1.0, 2.0, 3.0]) catch { + _ => abort("zero-total covariance should succeed") + } + for row in covariance { + assert_eq(row, [0.0, 0.0, 0.0]) + } +} + +///| +test "dirichlet_multinomial: single-component fit exposes dimensions and names" { + let fit = dmn_test_fit(1) + assert_eq(fit.component_count(), 1) + assert_eq(fit.sample_count(), 12) + assert_eq(fit.taxon_count(), 3) + assert_eq(fit.sample_names[0], "sample1") + assert_eq(fit.sample_names[11], "sample12") + assert_eq(fit.taxon_names, ["taxon_a", "taxon_b", "taxon_c"]) +} + +///| +test "dirichlet_multinomial: single-component posterior and weight are one" { + let fit = dmn_test_fit(1) + assert_eq(fit.mixture_weights(), [1.0]) + for row in fit.mixture() { + dmn_test_close(row[0], 1.0, 1.0e-12) + } + assert_eq(fit.assignments(), Array::make(12, 0)) +} + +///| +test "dirichlet_multinomial: estimates and intervals remain positive" { + let fit = dmn_test_fit(1) + for taxon in 0.. 0.0) + assert_true(fit.lower[0][taxon] > 0.0) + assert_true(fit.upper[0][taxon] > 0.0) + assert_true(fit.lower[0][taxon] <= fit.upper[0][taxon]) + } +} + +///| +test "dirichlet_multinomial: component proportions and fitted scale normalize" { + let fit = dmn_test_fit(1) + let proportions = fit.component_proportions() + dmn_test_close(dmn_test_row_sum(proportions[0]), 1.0, 1.0e-12) + let scaled = fit.fitted(scale=true) + assert_eq(scaled.length(), 3) + assert_eq(scaled[0].length(), 1) + dmn_test_close(scaled[0][0] + scaled[1][0] + scaled[2][0], 1.0, 1.0e-12) +} + +///| +test "dirichlet_multinomial: fitted matrix transposes component alpha" { + let fit = dmn_test_fit(1) + let fitted = fit.fitted() + for taxon in 0..= weights[1]) + dmn_test_close(weights[0] + weights[1], 1.0, 1.0e-10) +} + +///| +test "dirichlet_multinomial: two-component posterior rows normalize" { + let fit = dmn_test_fit(2) + for row in fit.mixture() { + assert_eq(row.length(), 2) + dmn_test_close(dmn_test_row_sum(row), 1.0, 1.0e-10) + assert_true(row[0] >= 0.0 && row[0] <= 1.0) + assert_true(row[1] >= 0.0 && row[1] <= 1.0) + } +} + +///| +test "dirichlet_multinomial: synthetic clusters receive distinct assignments" { + let assignments = dmn_test_fit(2).assignments() + let first = assignments[0] + let second = assignments[6] + assert_true(first != second) + for sample in 0..<6 { + assert_eq(assignments[sample], first) + } + for sample in 6..<12 { + assert_eq(assignments[sample], second) + } +} + +///| +test "dirichlet_multinomial: synthetic components recover dominant taxa" { + let fit = dmn_test_fit(2) + let assignments = fit.assignments() + let proportions = fit.component_proportions() + let first_component = assignments[0] + let second_component = assignments[6] + assert_true(proportions[first_component][0] > proportions[first_component][1]) + assert_true( + proportions[second_component][1] > proportions[second_component][0], + ) +} + +///| +test "dirichlet_multinomial: prediction normalizes and classifies novel samples" { + let fit = dmn_test_fit(2) + let posterior = fit.predict([[50, 1, 1], [1, 50, 1]]) catch { + _ => abort("valid DirichletMultinomial prediction should succeed") + } + for row in posterior { + dmn_test_close(dmn_test_row_sum(row), 1.0, 1.0e-10) + } + let assignments = fit.predict_assignments([[50, 1, 1], [1, 50, 1]]) catch { + _ => abort("valid DirichletMultinomial assignment should succeed") + } + assert_true(assignments[0] != assignments[1]) +} + +///| +test "dirichlet_multinomial: component evidence has sample by component shape" { + let fit = dmn_test_fit(2) + let evidence = fit.negative_log_evidence([[50, 1, 1], [1, 50, 1]]) catch { + _ => abort("valid DirichletMultinomial evidence should succeed") + } + assert_eq(evidence.length(), 2) + assert_eq(evidence[0].length(), 2) + for row in evidence { + for value in row { + assert_true(value.abs() < 1.0e300) + } + } +} + +///| +test "dirichlet_multinomial: concentrations equal alpha row sums" { + let fit = dmn_test_fit(2) + let concentrations = fit.concentrations() + for component in 0.. true + } + assert_true(raised) +} + +///| +test "dirichlet_multinomial: model selection fits every requested K" { + let selection = @src.dirichlet_multinomial_select( + dmn_test_counts(), + 2, + taxon_names=["taxon_a", "taxon_b", "taxon_c"], + config=dmn_test_config(1), + ) catch { + _ => abort("DirichletMultinomial model selection should succeed") + } + assert_eq(selection.fits.length(), 2) + assert_eq(selection.scores.length(), 2) + assert_eq(selection.fits[0].component_count(), 1) + assert_eq(selection.fits[1].component_count(), 2) + assert_eq(selection.criterion, @src.DmnLaplace) +} + +///| +test "dirichlet_multinomial: model selection best index minimizes score" { + let selection = @src.dirichlet_multinomial_select( + dmn_test_counts(), + 2, + criterion=@src.DmnBic, + config=dmn_test_config(1), + ) catch { + _ => abort("DirichletMultinomial BIC selection should succeed") + } + assert_eq(selection.criterion, @src.DmnBic) + assert_eq( + selection.best_fit().component_count(), + selection.best_component_count(), + ) + assert_true(selection.scores[selection.best_index] <= selection.scores[0]) + assert_true(selection.scores[selection.best_index] <= selection.scores[1]) +} + +///| +test "dirichlet_multinomial: model selection validates component range" { + let zero = try { + ignore(@src.dirichlet_multinomial_select(dmn_test_counts(), 0)) + false + } catch { + DirichletMultinomialError(_) => true + } + let excessive = try { + ignore(@src.dirichlet_multinomial_select(dmn_test_counts(), 13)) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(zero) + assert_true(excessive) +} + +///| +test "dirichlet_multinomial: fit rejects empty and ragged matrices" { + let empty = try { + ignore(@src.dirichlet_multinomial_fit([])) + false + } catch { + DirichletMultinomialError(_) => true + } + let ragged = try { + ignore(@src.dirichlet_multinomial_fit([[1, 2], [3]])) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(empty) + assert_true(ragged) +} + +///| +test "dirichlet_multinomial: fit rejects negative and zero-library samples" { + let negative = try { + ignore(@src.dirichlet_multinomial_fit([[1, -1], [2, 3]])) + false + } catch { + DirichletMultinomialError(_) => true + } + let zero = try { + ignore(@src.dirichlet_multinomial_fit([[1, 2], [0, 0]])) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(negative) + assert_true(zero) +} + +///| +test "dirichlet_multinomial: fit rejects too many components" { + let raised = try { + ignore( + @src.dirichlet_multinomial_fit( + [[1, 2], [2, 1]], + config=dmn_test_config(3), + ), + ) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(raised) +} + +///| +test "dirichlet_multinomial: fit validates sample names" { + let count = try { + ignore( + @src.dirichlet_multinomial_fit([[1, 2], [2, 1]], sample_names=["one"]), + ) + false + } catch { + DirichletMultinomialError(_) => true + } + let duplicate = try { + ignore( + @src.dirichlet_multinomial_fit([[1, 2], [2, 1]], sample_names=[ + "same", "same", + ]), + ) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(count) + assert_true(duplicate) +} + +///| +test "dirichlet_multinomial: fit validates taxon names" { + let empty = try { + ignore( + @src.dirichlet_multinomial_fit([[1, 2], [2, 1]], taxon_names=[ + "taxon", " ", + ]), + ) + false + } catch { + DirichletMultinomialError(_) => true + } + let duplicate = try { + ignore( + @src.dirichlet_multinomial_fit([[1, 2], [2, 1]], taxon_names=[ + "same", "same", + ]), + ) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(empty) + assert_true(duplicate) +} + +///| +test "dirichlet_multinomial: returned mixture arrays are defensive copies" { + let fit = dmn_test_fit(1) + let weights = fit.mixture_weights() + weights[0] = 0.0 + let mixture = fit.mixture() + mixture[0][0] = 0.0 + assert_eq(fit.mixture_weights(), [1.0]) + assert_eq(fit.mixture()[0], [1.0]) +} + +///| +test "dirichlet_multinomial: group fit preserves labels and empirical priors" { + let classifier = @src.dirichlet_multinomial_group_fit( + dmn_test_counts(), + dmn_test_groups(), + components_by_group=[1, 1], + taxon_names=["taxon_a", "taxon_b", "taxon_c"], + config=dmn_test_config(1), + ) catch { + _ => abort("DirichletMultinomial group fit should succeed") + } + assert_eq(classifier.group_names, ["A", "B"]) + assert_eq(classifier.models.length(), 2) + assert_eq(classifier.priors, [0.5, 0.5]) + assert_eq(classifier.taxon_names, ["taxon_a", "taxon_b", "taxon_c"]) +} + +///| +test "dirichlet_multinomial: group prediction normalizes and separates classes" { + let classifier = @src.dirichlet_multinomial_group_fit( + dmn_test_counts(), + dmn_test_groups(), + components_by_group=[1, 1], + config=dmn_test_config(1), + ) catch { + _ => abort("DirichletMultinomial group fit should succeed") + } + let probabilities = classifier.predict([[50, 1, 1], [1, 50, 1]]) catch { + _ => abort("DirichletMultinomial group prediction should succeed") + } + for row in probabilities { + dmn_test_close(dmn_test_row_sum(row), 1.0, 1.0e-10) + } + let predictions = classifier.predict_assignments([[50, 1, 1], [1, 50, 1]]) catch { + _ => abort("DirichletMultinomial group assignment should succeed") + } + assert_eq(predictions, ["A", "B"]) +} + +///| +test "dirichlet_multinomial: group fitting validates labels and component counts" { + let labels = try { + ignore( + @src.dirichlet_multinomial_group_fit([[1, 2], [2, 1]], ["A"], components_by_group=[ + 1, 1, + ]), + ) + false + } catch { + DirichletMultinomialError(_) => true + } + let one_group = try { + ignore( + @src.dirichlet_multinomial_group_fit([[1, 2], [2, 1]], ["A", "A"], components_by_group=[ + 1, + ]), + ) + false + } catch { + DirichletMultinomialError(_) => true + } + let components = try { + ignore( + @src.dirichlet_multinomial_group_fit([[1, 2], [2, 1]], ["A", "B"], components_by_group=[ + 1, + ]), + ) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(labels) + assert_true(one_group) + assert_true(components) +} + +///| +test "dirichlet_multinomial: stratified cross-validation returns held-out results" { + let result = @src.dirichlet_multinomial_cross_validate( + dmn_test_counts(), + dmn_test_groups(), + 3, + components_by_group=[1, 1], + taxon_names=["taxon_a", "taxon_b", "taxon_c"], + config=dmn_test_config(1), + ) catch { + _ => abort("DirichletMultinomial cross-validation should succeed") + } + assert_eq(result.probabilities.length(), 12) + assert_eq(result.predictions.length(), 12) + assert_eq(result.truth, dmn_test_groups()) + assert_eq(result.group_names, ["A", "B"]) + assert_eq(result.fold_ids, [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]) + for row in result.probabilities { + dmn_test_close(dmn_test_row_sum(row), 1.0, 1.0e-10) + } + assert_true(result.accuracy >= 0.9) + assert_eq(result.correct.to_double() / 12.0, result.accuracy) +} + +///| +test "dirichlet_multinomial: cross-validation validates folds and group sizes" { + let folds = try { + ignore( + @src.dirichlet_multinomial_cross_validate( + dmn_test_counts(), + dmn_test_groups(), + 1, + ), + ) + false + } catch { + DirichletMultinomialError(_) => true + } + let sizes = try { + ignore( + @src.dirichlet_multinomial_cross_validate( + [[5, 1], [4, 1], [1, 5], [1, 4]], + ["A", "A", "B", "B"], + 3, + ), + ) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(folds) + assert_true(sizes) +} + +///| +test "dirichlet_multinomial: perfect ROC has unit AUC" { + let roc = @src.dirichlet_multinomial_roc([true, true, false, false], [ + 0.9, 0.8, 0.2, 0.1, + ]) catch { + _ => abort("valid DirichletMultinomial ROC should succeed") + } + assert_eq(roc.auc, 1.0) + assert_eq(roc.best_threshold, 0.8) + assert_eq(roc.sensitivity[0], 0.0) + assert_eq(roc.specificity[0], 1.0) + assert_eq(roc.sensitivity[roc.sensitivity.length() - 1], 1.0) + assert_eq(roc.specificity[roc.specificity.length() - 1], 0.0) +} + +///| +test "dirichlet_multinomial: tied ROC scores contribute half concordance" { + let roc = @src.dirichlet_multinomial_roc([true, false], [0.5, 0.5]) catch { + _ => abort("tied DirichletMultinomial ROC should succeed") + } + assert_eq(roc.auc, 0.5) + assert_eq(roc.thresholds.length(), 2) +} + +///| +test "dirichlet_multinomial: ROC rejects invalid labels and scores" { + let lengths = try { + ignore(@src.dirichlet_multinomial_roc([true], [0.5, 0.2])) + false + } catch { + DirichletMultinomialError(_) => true + } + let classes = try { + ignore(@src.dirichlet_multinomial_roc([true, true], [0.5, 0.2])) + false + } catch { + DirichletMultinomialError(_) => true + } + let score = try { + ignore(@src.dirichlet_multinomial_roc([true, false], [1.0e301, 0.2])) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(lengths) + assert_true(classes) + assert_true(score) +} + +///| +test "dirichlet_multinomial: SummarizedExperiment entry transposes feature by sample assay" { + let assays : Map[String, Array[Array[Double]]] = Map([ + ( + "counts", + [ + [40.0, 35.0, 42.0, 2.0, 4.0, 3.0], + [3.0, 4.0, 2.0, 40.0, 35.0, 43.0], + [2.0, 1.0, 3.0, 3.0, 2.0, 1.0], + ], + ), + ]) + let experiment = @src.summarized_experiment(assays, [], [], Map([])) + let fit = @src.dirichlet_multinomial_fit_se( + experiment, + "counts", + sample_names=["s1", "s2", "s3", "s4", "s5", "s6"], + taxon_names=["taxon_a", "taxon_b", "taxon_c"], + config=dmn_test_config(2), + ) catch { + _ => abort("DirichletMultinomial SummarizedExperiment fit should succeed") + } + assert_eq(fit.sample_count(), 6) + assert_eq(fit.taxon_count(), 3) + assert_eq(fit.sample_names[0], "s1") + assert_eq(fit.taxon_names[2], "taxon_c") + assert_true(fit.assignments()[0] != fit.assignments()[3]) +} + +///| +test "dirichlet_multinomial: SummarizedExperiment entry rejects missing assay" { + let experiment = @src.summarized_experiment(Map([]), [], [], Map([])) + let raised = try { + ignore(@src.dirichlet_multinomial_fit_se(experiment, "counts")) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(raised) +} + +///| +test "dirichlet_multinomial: SummarizedExperiment entry rejects noninteger assay" { + let assays : Map[String, Array[Array[Double]]] = Map([ + ("counts", [[1.5, 2.0], [3.0, 4.0]]), + ]) + let experiment = @src.summarized_experiment(assays, [], [], Map([])) + let raised = try { + ignore(@src.dirichlet_multinomial_fit_se(experiment, "counts")) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(raised) +} + +///| +test "dirichlet_multinomial: SummarizedExperiment entry rejects negative assay" { + let assays : Map[String, Array[Array[Double]]] = Map([ + ("counts", [[1.0, -2.0], [3.0, 4.0]]), + ]) + let experiment = @src.summarized_experiment(assays, [], [], Map([])) + let raised = try { + ignore(@src.dirichlet_multinomial_fit_se(experiment, "counts")) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(raised) +} + +///| +test "dirichlet_multinomial: SummarizedExperiment entry rejects ragged assay" { + let assays : Map[String, Array[Array[Double]]] = Map([ + ("counts", [[1.0, 2.0], [3.0]]), + ]) + let experiment = @src.summarized_experiment(assays, [], [], Map([])) + let raised = try { + ignore(@src.dirichlet_multinomial_fit_se(experiment, "counts")) + false + } catch { + DirichletMultinomialError(_) => true + } + assert_true(raised) +} From 1b8c1e7959ba7685126272e6616c9f13a7b1895b Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 12:33:51 +0800 Subject: [PATCH 26/41] #28 feat(align_tabular): Bio.Align.tabular & BLAST outfmt7 & FASTA 8CB/8CC & BTOP/aln_code --- README.md | 25 +- examples/align_tabular_demo/main.mbt | 119 ++ examples/align_tabular_demo/moon.pkg | 5 + src/align_tabular.mbt | 1788 ++++++++++++++++++++++++++ test/moonbit/align_tabular_test.mbt | 1342 +++++++++++++++++++ 5 files changed, 3275 insertions(+), 4 deletions(-) create mode 100644 examples/align_tabular_demo/main.mbt create mode 100644 examples/align_tabular_demo/moon.pkg create mode 100644 src/align_tabular.mbt create mode 100644 test/moonbit/align_tabular_test.mbt diff --git a/README.md b/README.md index 228d54a3..67b24fb7 100644 --- a/README.md +++ b/README.md @@ -373,6 +373,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **HH-suite HHR格式** | Biopython `Bio.Align.hhr` | HHsearch/HHblits结果严格解析、0-based坐标、query-target映射、规范化写回 | ✅ | | **共享参考比对同步** | Biopython `Bio.Align.Alignment` | 相同参考PWA/MSA合并、边界插入宽度归一化、query原始比对结构保留、reference/query/column坐标互映 | ✅ | | **Alignment gap/composition统计** | Biopython `Bio.Align.Alignment.counts` | pairwise与MSA逐对统计、端部/内部gap分类、open/extend事件、替换和gap总分 | ✅ | +| **Alignment-aware tabular搜索结果** | Biopython `Bio.Align.tabular` | BLAST outfmt 7、FASTA 8CB/8CC、BTOP/aln_code路径、链向及translated坐标 | ✅ | | **UCSC Chain文件/liftOver** | Bioconductor rtracklayer | Chain格式解析、基因组坐标liftOver转换、链段查找、染色体间坐标映射、位置/区间转换 | ✅ | | **Biostrings matchPDict** | Bioconductor Biostrings | 字典模式匹配(matchPDict/vmatchPattern)、多序列模式计数(vcountPattern)、错配容忍、最佳匹配查找 | ✅ | | **GenomicRanges gaps/reduce/disjoin** | Bioconductor GenomicRanges | gaps检测、reduce合并、disjoin拆分、setdiff/交集/并集集合运算、coverage计算、promoters提取、trim | ✅ | @@ -431,6 +432,7 @@ IvanAXu/BioSeqs/ │ ├── shared_reference_alignment.mbt # Bio.Align共享参考PWA/MSA合并、insertion slot同步与坐标映射 │ ├── alignment_map.mbt # Bio.Align.Alignment map/mapall坐标路径组合与MSA投影 │ ├── alignment_counts.mbt # Bio.Align.Alignment.counts详细gap/composition统计与评分 +│ ├── align_tabular.mbt # Bio.Align.tabular BLAST/FASTA traceback表格解析与坐标路径 │ ├── bigbed.mbt # Bio.Align.bigbed v4、BED/AutoSQL、多级B+ tree/R-tree与DEFLATE │ ├── bigmaf.mbt # Bio.Align.bigmaf bedMaf、MAF注释、链向坐标映射与索引查询 │ ├── bigpsl.mbt # Bio.Align.bigpsl bed12+13、核酸/translated protein路径与PSL @@ -1129,6 +1131,7 @@ IvanAXu/BioSeqs/ │ ├── shared_reference_alignment_demo/ # 共享参考PWA/MSA合并、insertion同步、坐标映射与FASTA转换示例 │ ├── alignment_map_demo/ # Alignment.map/mapall、反链、PSL与protein-to-codon MSA投影示例 │ ├── alignment_counts_demo/ # Alignment.counts gap分类、affine/BLOSUM评分、反链与MSA汇总示例 +│ ├── align_tabular_demo/ # BLAST BTOP、FASTA aln_code与translated反链坐标解析示例 │ ├── bigbed_demo/ # BigBed写入/解析、索引查询、负链exon坐标、BED导出与损坏诊断 │ ├── bigmaf_demo/ # BigMaf压缩写入、bedMaf schema、区间查询、负链映射与MAF导出 │ ├── bigpsl_demo/ # BigPsl压缩写入、R-tree查询、反链/translated坐标与PSL导出 @@ -1339,6 +1342,7 @@ IvanAXu/BioSeqs/ │ │ ├── shared_reference_alignment_test.mbt │ │ ├── alignment_map_test.mbt │ │ ├── alignment_counts_test.mbt +│ │ ├── align_tabular_test.mbt │ │ ├── bigbed_test.mbt │ │ ├── bigmaf_test.mbt │ │ ├── bigpsl_test.mbt @@ -1518,7 +1522,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 9116 个测试全部通过 +moon test # ✅ 9401 个测试全部通过 ``` ### 模块对照表 @@ -1566,6 +1570,7 @@ moon test # ✅ 9116 个测试全 | `shared_reference_alignment.mbt` | BioPython `Bio.Align.Alignment.from_alignments_with_same_reference` | 共享参考PWA/MSA合并、insertion slot同步、局部坐标、双向映射、统计、MSA与FASTA转换 | | `alignment_map.mbt` | BioPython `Bio.Align.Alignment.map/mapall` | alignment path组合、local clipping、gap与链向传播、双向坐标查询、PSL、map_many及codon-aware MSA投影 | | `alignment_counts.mbt` | BioPython `Bio.Align.Alignment.counts` | left/internal/right insertion/deletion、open/extend、composition、wildcard、替换矩阵与十二类affine gap评分 | +| `align_tabular.mbt` | BioPython `Bio.Align.tabular` | BLAST outfmt 7与FASTA 8CB/8CC元数据、BTOP/CIGAR traceback、链向及translated坐标 | | `bigbed.mbt` | BioPython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12、AutoSQL、多级chromosome B+ tree/R-tree、zlib/DEFLATE及索引查询 | | `bigmaf.mbt` | BioPython `Bio.Align.bigmaf` | bedMaf bed3+1读写、MAF a/s/i/e/q、正负链坐标映射、压缩索引查询、摘要和MAF导出 | | `bigpsl.mbt` | BioPython `Bio.Align.bigpsl` | bed12+13读写、核酸/translated protein路径、双向坐标映射、recount、压缩查询、摘要和PSL导出 | @@ -1841,6 +1846,7 @@ moon test # ✅ 9116 个测试全 | `shared_reference_alignment.mbt` | `Bio.Align.Alignment` | 同参考PWA/MSA的reference-boundary insertion同步、原query投影、局部坐标、metadata、统计与格式转换 | | `alignment_map.mbt` | `Bio.Align.Alignment.map/mapall` | 两层alignment坐标组合、正反链与gap传播、PSL、批量映射及protein/nucleotide MSA投影 | | `alignment_counts.mbt` | `Bio.Align.Alignment.counts` | pairwise/MSA gap事件和composition汇总、正反链、wildcard、替换矩阵及完整affine评分 | +| `align_tabular.mbt` | `Bio.Align.tabular` | BLAST/FASTA query block、完整字段词汇、BTOP/aln_code路径、translated轴换算、过滤与coordinate alignment转换 | | `bigbed.mbt` | `Bio.Align.bigbed` | BigBed v4二进制读写、BED/AutoSQL、平衡B+ tree/R-tree、完整DEFLATE块解码、区间/名称查询与BED导出 | | `bigmaf.mbt` | `Bio.Align.bigmaf` | bedMaf AutoSQL与MAF块往返、a/s/i/e/q注释、链感知坐标映射、BigBed索引查询和普通MAF导出 | | `bigpsl.mbt` | `Bio.Align.bigpsl` | 标准bigPsl AutoSQL、核酸与translated DNA-protein坐标、链感知映射、match分类、BigBed索引和PSL导出 | @@ -3010,6 +3016,14 @@ composition 支持 wildcard、match/mismatch score 或替换矩阵；矩阵模 `dirichlet_multinomial_fit_se` 从 `SummarizedExperiment` 的 feature × sample assay 校验并转置为 sample × taxon。构造器会诊断空/ragged矩阵、负数、非整数或非有限 assay、零文库、组件数、名称、group、fold 和预测维度错误。当前实现使用 dense MoonBit arrays 和确定性单线程求解，不依赖上游 C/GSL，也不包含稀疏矩阵专用优化、并行多起点、绘图或完整 S4 方法分派。 +### 261. Alignment-aware tabular 搜索结果解析 (Biopython Bio.Align.tabular) + +实现 Biopython 1.86 `Bio.Align.tabular` 的 alignment-aware 表格解析器，支持 NCBI BLAST `-outfmt 7`、FASTA `-m 8CB` BTOP 和 `-m 8CC` `aln_code`。解析结果按 query block 保留 program/version、command line、database、RID、query 描述与长度、完整上游字段词汇、声明命中数和零命中 query；`AlignTabularDocument` 提供扁平化、query 查询，`AlignTabularQueryResult` 提供 E-value 最佳命中与阈值过滤。 + +BTOP 和 FASTA CIGAR 会合并连续 operation 并重建显式 target/query coordinate path，区分 aligned、query gap 和 target gap。输入的 1-based inclusive 区间规范化为 0-based half-open，同时保留正反链方向；BLASTX、TBLASTN、TBLASTX、RPSTBLASTN、FASTX/FASTY 和 TFASTX/TFASTY 按核酸轴每个 residue 三个单位换算。绝对路径可转换为 `CoordinatePairwiseAlignment`，并提供 alignment columns、aligned residues、两类 gap residues、gap events 和摘要。 + +解析器严格诊断 header/字段重复或缺失、未知字段、列数、整数溢出、非法或非有限浮点、百分比和 E-value 范围、ID/长度冲突、坐标边界、traceback 截断与 operation、BTOP/CIGAR 同时出现、traceback span/序列消耗/alignment length 不一致，以及声明命中数和 processed query 数不匹配。当前范围聚焦文本解析和坐标重建，不执行 BLAST/FASTA 搜索，也不解析 XML、ASN.1 或普通无注释 outfmt 6 文档。 + ## 性能优化 ### 优化策略 @@ -3111,8 +3125,8 @@ composition 支持 wildcard、match/mismatch score 或替换矩阵；矩阵模 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 9311 | -| 通过数 | 9311 | +| 总测试数 | 9401 | +| 通过数 | 9401 | | 失败数 | 0 | | 通过率 | 100% | @@ -3217,6 +3231,7 @@ moon test --update | Bio.Align shared-reference merge | `shared_reference_alignment_test.mbt` | 41 | | Bio.Align Alignment.map/mapall | `alignment_map_test.mbt` | 44 | | Bio.Align Alignment.counts | `alignment_counts_test.mbt` | 57 | +| Bio.Align.tabular | `align_tabular_test.mbt` | 90 | | Bio.Align.bigbed | `bigbed_test.mbt` | 64 | | Bio.Align.bigmaf | `bigmaf_test.mbt` | 79 | | SparseArray | `sparse_array_test.mbt` | 41 | @@ -3520,7 +3535,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 368 个示例程序，展示各模块的典型用法： +项目提供 369 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3715,6 +3730,7 @@ moon run cmd/bench/main.mbt | shared_reference_alignment_demo | 共享参考PWA/MSA合并、reference insertion同步、坐标映射、统计、MSA与aligned FASTA转换 | `moon run examples/shared_reference_alignment_demo` | | alignment_map_demo | chromosome→transcript→read坐标组合、intron gap、反链、坐标查询、PSL与protein-to-codon MSA投影 | `moon run examples/alignment_map_demo` | | alignment_counts_demo | left/internal/right gap与open/extend、affine/BLOSUM45评分、反向链和MSA逐对汇总 | `moon run examples/alignment_counts_demo` | +| align_tabular_demo | BLAST outfmt 7 BTOP、FASTA 8CC aln_code、最佳命中和TBLASTX反链translated坐标 | `moon run examples/align_tabular_demo` | | bigbed_demo | BigBed v4压缩写入/解析、AutoSQL、多级索引查询、负链exon坐标、BED导出及损坏文件诊断 | `moon run examples/bigbed_demo` | | bigmaf_demo | BigMaf压缩bed3+1写入、bedMaf schema、R-tree区间查询、负链物种坐标映射和MAF a/s/i/e/q导出 | `moon run examples/bigmaf_demo` | | bigpsl_demo | BigPsl bed12+13压缩写入、AutoSQL、R-tree查询、反向核酸/translated protein坐标和PSL导出 | `moon run examples/bigpsl_demo` | @@ -3826,6 +3842,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bio.Align共享参考序列比对合并（混合PWA/MSA、reference-boundary insertion同步、局部坐标、双向映射、统计与格式转换） - ✅ 实现 Bio.Align.Alignment map/mapall（alignment path组合、local clipping、gap与正反链传播、坐标查询、PSL及protein-to-codon MSA投影） - ✅ 实现 Bio.Align.Alignment counts（left/internal/right insertion/deletion、gap open/extend、identity/mismatch/positive、wildcard、替换矩阵、affine评分及MSA逐对汇总） +- ✅ 实现 Bio.Align.tabular alignment-aware搜索结果解析（BLAST outfmt 7、FASTA 8CB/8CC、BTOP/aln_code、正反链与translated坐标、零命中query） - ✅ 实现 Bio.Align.bigbed BigBed v4二进制区间格式（BED3-BED12、AutoSQL、多级B+ tree/R-tree、DEFLATE、区间/名称查询与BED导出） - ✅ 实现 Bio.Align.bigmaf BigMaf多物种比对索引（标准bedMaf、MAF a/s/i/e/q、正负链坐标映射、压缩BigBed查询与MAF导出） - ✅ 实现 Bio.Align.bigpsl BigPsl成对比对索引（标准bed12+13、核酸/translated protein坐标、match recount、压缩BigBed查询与PSL导出） diff --git a/examples/align_tabular_demo/main.mbt b/examples/align_tabular_demo/main.mbt new file mode 100644 index 00000000..3e35a1e3 --- /dev/null +++ b/examples/align_tabular_demo/main.mbt @@ -0,0 +1,119 @@ +///| +fn parse_document(text : String) -> @src.AlignTabularDocument { + @src.align_tabular_parse(text) catch { + AlignTabularError(message) => abort("tabular parsing failed: " + message) + } +} + +///| +fn show_path(values : Array[Int]) -> String { + let mut result = "[" + for index in 0.. 0 { + result = result + ", " + } + result = result + values[index].to_string() + } + result + "]" +} + +///| +fn main { + println("=== Biopython Bio.Align.tabular Demo ===") + + println("\n1. Reconstruct BLAST outfmt 7 BTOP coordinate paths") + let blast = "# BLASTP 2.14.1+\n" + + "# Query: q1 protein query\n" + + "# Database: proteins\n" + + "# Fields: query id, subject id, % identity, alignment length, mismatches, gap opens, q. start, q. end, s. start, s. end, evalue, bit score, BTOP, query length, subject length, query seq, subject seq\n" + + "# 2 hits found\n" + + "q1\ts1\t75.0\t8\t2\t2\t3\t9\t10\t16\t1e-5\t42.0\t2AC1-GT-2\t20\t30\tAAAT-TGG\tAACTG-GG\n" + + "q1\ts2\t75.0\t8\t2\t2\t3\t9\t4\t10\t0.02\t31.0\t2AC1-GT-2\t20\t25\tAAAT-TGG\tAACTG-GG\n" + + "# BLAST processed 1 queries\n" + let blast_document = parse_document(blast) + let query = blast_document.queries[0] + println( + " program=" + + query.metadata.program + + ", query=" + + query.query_id + + ", hits=" + + query.alignments.length().to_string(), + ) + for alignment in query.alignments { + println(" " + alignment.summary()) + println( + " target path=" + + show_path(alignment.target_coordinates) + + ", query path=" + + show_path(alignment.query_coordinates), + ) + } + let best = query.best_by_evalue() catch { + AlignTabularError(message) => abort("best-hit selection failed: " + message) + } + match best { + Some(alignment) => println(" best E-value target=" + alignment.target_id) + None => println(" no E-value-bearing hit") + } + let coordinate = query.alignments[0].coordinate_alignment() catch { + AlignTabularError(message) => + abort("coordinate conversion failed: " + message) + } + println( + " coordinate alignment columns=" + + show_path(coordinate.target_coordinates) + + " / " + + show_path(coordinate.query_coordinates), + ) + + println("\n2. Decode FASTA -m 8CC aln_code") + let fasta = "# fasta36 -q -m 8CC query.aa database.aa\n" + + "# FASTA 36.3.8h May, 2020\n" + + "# Query: qf protein query - 218 aa\n" + + "# Database: database.aa\n" + + "# Fields: query id, subject id, % identity, alignment length, mismatches, gap opens, q. start, q. end, s. start, s. end, evalue, bit score, aln_code\n" + + "# 1 hits found\n" + + "qf\tsf\t50.0\t9\t4\t2\t4\t10\t6\t13\t1e-4\t30.0\t3M2I1D3M\n" + + "# FASTA processed 1 queries\n" + let fasta_document = parse_document(fasta) + let fasta_alignment = fasta_document.queries[0].alignments[0] + println(" command=" + fasta_alignment.metadata.command_line) + println( + " " + + fasta_alignment.summary() + + ", target gaps=" + + fasta_alignment.target_gap_residues().to_string() + + ", query gaps=" + + fasta_alignment.query_gap_residues().to_string(), + ) + + println("\n3. Preserve reverse translated TBLASTX coordinates") + let translated = "# TBLASTX 2.14.1+\n" + + "# Query: qn translated query\n" + + "# Database: nucleotides\n" + + "# Fields: query id, subject id, query length, subject length, q. start, q. end, s. start, s. end, alignment length, BTOP\n" + + "# 1 hits found\n" + + "qn\tsn\t60\t90\t30\t19\t45\t34\t4\t4\n" + let translated_alignment = parse_document(translated).queries[0].alignments[0] + println( + " query units/residue=" + + translated_alignment.query_units_per_residue.to_string() + + ", target units/residue=" + + translated_alignment.target_units_per_residue.to_string(), + ) + println( + " reverse query=" + + translated_alignment.query_is_reverse().to_string() + + ", reverse target=" + + translated_alignment.target_is_reverse().to_string(), + ) + println( + " target path=" + + show_path(translated_alignment.target_coordinates) + + ", query path=" + + show_path(translated_alignment.query_coordinates), + ) + + println("\n=== Demo Complete ===") +} diff --git a/examples/align_tabular_demo/moon.pkg b/examples/align_tabular_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/align_tabular_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/align_tabular.mbt b/src/align_tabular.mbt new file mode 100644 index 00000000..51b56935 --- /dev/null +++ b/src/align_tabular.mbt @@ -0,0 +1,1788 @@ +// Parse alignment-aware BLAST outfmt 7 and FASTA -m 8CB/-m 8CC output. +// +// This follows the field and traceback semantics of Biopython 1.86 +// Bio.Align.tabular. Unlike hit-table parsers, BTOP and aln_code values are +// expanded into explicit pairwise coordinate paths. + +///| +/// Error raised by alignment-aware tabular parsing and conversion. +pub suberror AlignTabularError { + AlignTabularError(String) +} + +///| +/// Source used to construct an alignment path. +pub enum AlignTabularTrace { + NoTrace + Btop + Cigar +} derive(Eq, Debug) + +///| +/// One run in a tabular alignment path. +/// +/// `Aligned` consumes both rows, `QueryGap` consumes only the target row, and +/// `TargetGap` consumes only the query row. +pub enum AlignTabularOperation { + Aligned + QueryGap + TargetGap +} derive(Eq, Debug) + +///| +/// One original field/value pair from a tabular row. +pub struct AlignTabularField { + name : String + value : String +} derive(Eq, Debug) + +///| +/// Metadata attached to one BLAST or FASTA query block. +pub struct AlignTabularMetadata { + program : String + version : String + command_line : String + database : String + rid : String +} derive(Eq, Debug) + +///| +/// One pairwise alignment parsed from a tabular row. +/// +/// Intervals are zero-based and half-open. Coordinate paths preserve the +/// reported strand direction. For translated searches, nucleotide axes use +/// nucleotide coordinates and have `units_per_residue == 3`. +pub struct AlignTabularAlignment { + metadata : AlignTabularMetadata + query_id : String + query_description : String + target_id : String + query_length : Int? + target_length : Int? + query_start : Int? + query_end : Int? + target_start : Int? + target_end : Int? + query_strand : Strand + target_strand : Strand + query_sequence : String + target_sequence : String + target_coordinates : Array[Int] + query_coordinates : Array[Int] + operations : Array[AlignTabularOperation] + trace : AlignTabularTrace + trace_text : String + path_is_absolute : Bool + target_units_per_residue : Int + query_units_per_residue : Int + fields : Array[AlignTabularField] +} derive(Debug) + +///| +/// One query block, including zero-hit queries. +pub struct AlignTabularQueryResult { + metadata : AlignTabularMetadata + query_id : String + query_description : String + query_length : Int? + query_unit : String + field_names : Array[String] + declared_hits : Int + alignments : Array[AlignTabularAlignment] +} derive(Debug) + +///| +/// Complete parsed document. +pub struct AlignTabularDocument { + queries : Array[AlignTabularQueryResult] + processed_queries : Int? +} derive(Debug) + +///| +priv struct AlignTabularRelativePath { + target_coordinates : Array[Int] + query_coordinates : Array[Int] + operations : Array[AlignTabularOperation] + columns : Int +} + +///| +fn align_tabular_starts_with(value : String, prefix : String) -> Bool { + if prefix.length() > value.length() { + return false + } + for index in 0.. Bool { + if suffix.length() > value.length() { + return false + } + let offset = value.length() - suffix.length() + for index in 0.. String { + value.trim().to_owned() +} + +///| +fn align_tabular_split_char(value : String, separator : Char) -> Array[String] { + let result : Array[String] = [] + let mut start = 0 + for index in 0.. Array[String] { + let result : Array[String] = [] + let mut start = 0 + let mut in_token = false + for index in 0.. String { + let mut result = "" + for index in start.. start { + result = result + " " + } + result = result + values[index] + } + result +} + +///| +fn align_tabular_last_delimiter(value : String, delimiter : String) -> Int? { + if delimiter.length() == 0 || delimiter.length() > value.length() { + return None + } + let mut found : Int? = None + for start in 0..<=(value.length() - delimiter.length()) { + let mut matches = true + for offset in 0.. Int raise AlignTabularError { + if value.length() == 0 { + raise AlignTabularError("missing integer field " + label) + } + let mut start = 0 + let negative = value.unsafe_get(0).to_int() == '-'.to_int() + if negative || value.unsafe_get(0).to_int() == '+'.to_int() { + start = 1 + } + if start == value.length() { + raise AlignTabularError("invalid integer in " + label + ": " + value) + } + for index in start.. '9'.to_int() { + raise AlignTabularError("invalid integer in " + label + ": " + value) + } + } + let mut first_digit = start + while first_digit < value.length() && + value.unsafe_get(first_digit).to_int() == '0'.to_int() { + first_digit = first_digit + 1 + } + if first_digit == value.length() { + return 0 + } + let significant_length = value.length() - first_digit + let limit = if negative { "2147483648" } else { "2147483647" } + let mut exceeds_limit = significant_length > limit.length() + let mut equals_limit = significant_length == limit.length() + if significant_length == limit.length() { + for offset in 0.. bound { + exceeds_limit = true + equals_limit = false + break + } else if digit < bound { + equals_limit = false + break + } + } + } + if exceeds_limit { + raise AlignTabularError("integer overflow in " + label + ": " + value) + } + if negative && equals_limit { + return -2147483647 - 1 + } + let mut result = 0 + for index in first_digit.. Double raise AlignTabularError { + if value.length() == 0 { + raise AlignTabularError("missing number field " + label) + } + let mut index = 0 + if value.unsafe_get(0).to_int() == '-'.to_int() || + value.unsafe_get(0).to_int() == '+'.to_int() { + index = 1 + } + let mut mantissa_digits = 0 + while index < value.length() { + let code = value.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + break + } + mantissa_digits = mantissa_digits + 1 + index = index + 1 + } + if index < value.length() && value.unsafe_get(index).to_int() == '.'.to_int() { + index = index + 1 + while index < value.length() { + let code = value.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + break + } + mantissa_digits = mantissa_digits + 1 + index = index + 1 + } + } + if mantissa_digits == 0 { + raise AlignTabularError("invalid number in " + label + ": " + value) + } + if index < value.length() && + ( + value.unsafe_get(index).to_int() == 'e'.to_int() || + value.unsafe_get(index).to_int() == 'E'.to_int() + ) { + index = index + 1 + let exponent_value_start = index + if index < value.length() && + ( + value.unsafe_get(index).to_int() == '-'.to_int() || + value.unsafe_get(index).to_int() == '+'.to_int() + ) { + index = index + 1 + } + let exponent_start = index + while index < value.length() { + let code = value.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + break + } + index = index + 1 + } + if index == exponent_start { + raise AlignTabularError("invalid number in " + label + ": " + value) + } + ignore( + align_tabular_parse_int( + value[exponent_value_start:index].to_owned(), + label + " exponent", + ), + ) + } + if index != value.length() { + raise AlignTabularError("invalid number in " + label + ": " + value) + } + let parse_value = if value.unsafe_get(0).to_int() == '+'.to_int() { + value[1:value.length()].to_owned() + } else { + value + } + match parse_double(parse_value) { + Some(number) => + if number.is_nan() || number.abs() > 1.0e300 { + raise AlignTabularError("non-finite number in " + label + ": " + value) + } else { + number + } + None => raise AlignTabularError("invalid number in " + label + ": " + value) + } +} + +///| +fn align_tabular_abs(value : Int) -> Int { + if value < 0 { + -value + } else { + value + } +} + +///| +fn align_tabular_copy_ints(values : Array[Int]) -> Array[Int] { + let result : Array[Int] = [] + for value in values { + result.push(value) + } + result +} + +///| +fn align_tabular_copy_strings(values : Array[String]) -> Array[String] { + let result : Array[String] = [] + for value in values { + result.push(value) + } + result +} + +///| +fn align_tabular_copy_operations( + values : Array[AlignTabularOperation], +) -> Array[AlignTabularOperation] { + let result : Array[AlignTabularOperation] = [] + for value in values { + result.push(value) + } + result +} + +///| +fn align_tabular_known_blast_program(program : String) -> Bool { + match program { + "BLASTN" + | "BLASTP" + | "BLASTX" + | "TBLASTN" + | "TBLASTX" + | "DELTABLAST" + | "PSIBLAST" + | "RPSBLAST" + | "RPSTBLASTN" => true + _ => false + } +} + +///| +fn align_tabular_known_fasta_program(program : String) -> Bool { + match program { + "FASTA" + | "SSEARCH" + | "GGSEARCH" + | "GLSEARCH" + | "FASTX" + | "FASTY" + | "TFASTX" + | "TFASTY" => true + _ => false + } +} + +///| +fn align_tabular_program_header(value : String) -> (String, String)? { + let parts = align_tabular_split_whitespace(value) + if parts.length() < 2 { + return None + } + let program = parts[0].to_upper() + if !align_tabular_known_blast_program(program) && + !align_tabular_known_fasta_program(program) { + return None + } + Some((program, align_tabular_join(parts, 1))) +} + +///| +fn align_tabular_field_value( + fields : Array[AlignTabularField], + name : String, +) -> String? { + for field in fields { + if field.name == name { + return Some(field.value) + } + } + None +} + +///| +fn align_tabular_optional_int( + fields : Array[AlignTabularField], + name : String, +) -> Int? raise AlignTabularError { + match align_tabular_field_value(fields, name) { + Some(value) => Some(align_tabular_parse_int(value, name)) + None => None + } +} + +///| +fn align_tabular_optional_double( + fields : Array[AlignTabularField], + name : String, +) -> Double? raise AlignTabularError { + match align_tabular_field_value(fields, name) { + Some(value) => Some(align_tabular_parse_double(value, name)) + None => None + } +} + +///| +fn align_tabular_is_known_field(name : String) -> Bool { + match name { + "query id" + | "subject id" + | "% identity" + | "alignment length" + | "mismatches" + | "gap opens" + | "q. start" + | "q. end" + | "s. start" + | "s. end" + | "evalue" + | "bit score" + | "BTOP" + | "aln_code" + | "query gi" + | "query acc." + | "query acc.ver" + | "query length" + | "subject ids" + | "subject gi" + | "subject gis" + | "subject acc." + | "subject acc.ver" + | "subject accs." + | "subject length" + | "query seq" + | "subject seq" + | "score" + | "identical" + | "positives" + | "gaps" + | "% positives" + | "% hsp coverage" + | "query/sbjct frames" + | "query frame" + | "sbjct frame" + | "subject tax ids" + | "subject sci names" + | "subject com names" + | "subject blast names" + | "subject super kingdoms" + | "subject title" + | "subject titles" + | "subject strand" + | "% subject coverage" => true + _ => false + } +} + +///| +fn align_tabular_validate_field_names( + names : Array[String], +) -> Unit raise AlignTabularError { + if names.length() == 0 { + raise AlignTabularError("Fields header must not be empty") + } + let seen : Map[String, Bool] = Map([], capacity=names.length()) + for name in names { + if name.length() == 0 { + raise AlignTabularError("Fields header contains an empty field") + } + if !align_tabular_is_known_field(name) { + raise AlignTabularError("unexpected tabular field: " + name) + } + if seen.contains(name) { + raise AlignTabularError("duplicate tabular field: " + name) + } + seen.set(name, true) + } +} + +///| +fn align_tabular_push_step( + target_coordinates : Array[Int], + query_coordinates : Array[Int], + operations : Array[AlignTabularOperation], + operation : AlignTabularOperation, + target_count : Int, + query_count : Int, +) -> Unit { + let last = operations.length() - 1 + if last >= 0 && operations[last] == operation { + let point = target_coordinates.length() - 1 + target_coordinates[point] = target_coordinates[point] + target_count + query_coordinates[point] = query_coordinates[point] + query_count + } else { + let point = target_coordinates.length() - 1 + target_coordinates.push(target_coordinates[point] + target_count) + query_coordinates.push(query_coordinates[point] + query_count) + operations.push(operation) + } +} + +///| +/// Parse a BLAST traceback operations (BTOP) string into a relative path. +pub fn align_tabular_parse_btop( + btop : String, +) -> (Array[Int], Array[Int], Array[AlignTabularOperation]) raise AlignTabularError { + if btop.length() == 0 { + raise AlignTabularError("BTOP value must not be empty") + } + let target_coordinates = [0] + let query_coordinates = [0] + let operations : Array[AlignTabularOperation] = [] + let mut index = 0 + while index < btop.length() { + let code = btop.unsafe_get(index).to_int() + if code >= '0'.to_int() && code <= '9'.to_int() { + let start = index + while index < btop.length() { + let digit = btop.unsafe_get(index).to_int() + if digit >= '0'.to_int() && digit <= '9'.to_int() { + index = index + 1 + } else { + break + } + } + let count = align_tabular_parse_int( + btop[start:index].to_owned(), + "BTOP match length", + ) + if count <= 0 { + raise AlignTabularError("BTOP match lengths must be positive") + } + align_tabular_push_step( + target_coordinates, + query_coordinates, + operations, + AlignTabularOperation::Aligned, + count, + count, + ) + } else { + if index + 1 >= btop.length() { + raise AlignTabularError("truncated BTOP residue pair") + } + let first = btop.unsafe_get(index).unsafe_to_char() + let second = btop.unsafe_get(index + 1).unsafe_to_char() + if first == '-' && second == '-' { + raise AlignTabularError("BTOP residue pair cannot contain two gaps") + } + if first == '-' { + align_tabular_push_step( + target_coordinates, + query_coordinates, + operations, + AlignTabularOperation::QueryGap, + 1, + 0, + ) + } else if second == '-' { + align_tabular_push_step( + target_coordinates, + query_coordinates, + operations, + AlignTabularOperation::TargetGap, + 0, + 1, + ) + } else { + let first_valid = first.is_ascii_alphabetic() || first == '*' + let second_valid = second.is_ascii_alphabetic() || second == '*' + if !first_valid || !second_valid { + raise AlignTabularError("invalid BTOP residue pair") + } + align_tabular_push_step( + target_coordinates, + query_coordinates, + operations, + AlignTabularOperation::Aligned, + 1, + 1, + ) + } + index = index + 2 + } + } + (target_coordinates, query_coordinates, operations) +} + +///| +/// Parse FASTA `aln_code` CIGAR syntax into a relative path. +/// +/// FASTA uses `I` for residues present only in the subject/target and `D` for +/// residues present only in the query, matching Biopython's parser. +pub fn align_tabular_parse_cigar( + cigar : String, +) -> (Array[Int], Array[Int], Array[AlignTabularOperation]) raise AlignTabularError { + if cigar.length() == 0 { + raise AlignTabularError("aln_code value must not be empty") + } + let target_coordinates = [0] + let query_coordinates = [0] + let operations : Array[AlignTabularOperation] = [] + let mut index = 0 + while index < cigar.length() { + let start = index + while index < cigar.length() { + let code = cigar.unsafe_get(index).to_int() + if code >= '0'.to_int() && code <= '9'.to_int() { + index = index + 1 + } else { + break + } + } + if start == index || index >= cigar.length() { + raise AlignTabularError("invalid aln_code operation") + } + let count = align_tabular_parse_int( + cigar[start:index].to_owned(), + "aln_code length", + ) + if count <= 0 { + raise AlignTabularError("aln_code lengths must be positive") + } + let operation = cigar.unsafe_get(index).unsafe_to_char() + match operation { + 'M' => + align_tabular_push_step( + target_coordinates, + query_coordinates, + operations, + AlignTabularOperation::Aligned, + count, + count, + ) + 'I' => + align_tabular_push_step( + target_coordinates, + query_coordinates, + operations, + AlignTabularOperation::QueryGap, + count, + 0, + ) + 'D' => + align_tabular_push_step( + target_coordinates, + query_coordinates, + operations, + AlignTabularOperation::TargetGap, + 0, + count, + ) + _ => raise AlignTabularError("unsupported aln_code operation") + } + index = index + 1 + } + (target_coordinates, query_coordinates, operations) +} + +///| +fn align_tabular_path( + fields : Array[AlignTabularField], +) -> AlignTabularRelativePath? raise AlignTabularError { + let btop = align_tabular_field_value(fields, "BTOP") + let cigar = align_tabular_field_value(fields, "aln_code") + if btop is Some(_) && cigar is Some(_) { + raise AlignTabularError("a row cannot contain both BTOP and aln_code") + } + let parsed = match (btop, cigar) { + (Some(value), None) => { + let (target, query, operations) = align_tabular_parse_btop(value) + Some((target, query, operations)) + } + (None, Some(value)) => { + let (target, query, operations) = align_tabular_parse_cigar(value) + Some((target, query, operations)) + } + _ => None + } + match parsed { + Some((target, query, operations)) => { + let mut columns = 0 + for index in 0.. query_count { target_count } else { query_count }) + } + Some(AlignTabularRelativePath::{ + target_coordinates: target, + query_coordinates: query, + operations, + columns, + }) + } + None => None + } +} + +///| +fn align_tabular_axis_factor(program : String, query : Bool) -> Int { + if query { + match program { + "BLASTX" | "TBLASTX" | "FASTX" | "FASTY" => 3 + _ => 1 + } + } else { + match program { + "TBLASTN" | "TBLASTX" | "RPSTBLASTN" | "TFASTX" | "TFASTY" => 3 + _ => 1 + } + } +} + +///| +fn align_tabular_interval( + reported_start : Int?, + reported_end : Int?, + label : String, +) -> (Int?, Int?, Strand) raise AlignTabularError { + match (reported_start, reported_end) { + (None, None) => (None, None, Strand::Star) + (Some(first), Some(last)) => { + if first <= 0 || last <= 0 { + raise AlignTabularError(label + " coordinates must be positive") + } + if first <= last { + (Some(first - 1), Some(last), Strand::Plus) + } else { + (Some(last - 1), Some(first), Strand::Minus) + } + } + _ => raise AlignTabularError(label + " start and end must appear together") + } +} + +///| +fn align_tabular_absolute_axis( + relative : Array[Int], + reported_start : Int, + reported_end : Int, + factor : Int, + label : String, +) -> Array[Int] raise AlignTabularError { + let consumed = relative[relative.length() - 1] - relative[0] + let expected = align_tabular_abs(reported_end - reported_start) + 1 + if consumed * factor != expected { + raise AlignTabularError( + label + + " traceback span " + + (consumed * factor).to_string() + + " does not match reported span " + + expected.to_string(), + ) + } + let direction = if reported_start <= reported_end { 1 } else { -1 } + let origin = if direction > 0 { reported_start - 1 } else { reported_start } + let result : Array[Int] = [] + for coordinate in relative { + result.push(origin + direction * coordinate * factor) + } + result +} + +///| +fn align_tabular_scale_axis(relative : Array[Int], factor : Int) -> Array[Int] { + let result : Array[Int] = [] + for coordinate in relative { + result.push(coordinate * factor) + } + result +} + +///| +fn align_tabular_ungapped_length(sequence : String) -> Int { + let mut length = 0 + for index in 0.. Unit raise AlignTabularError { + for index in 0.. (String, String, Int?, String) raise AlignTabularError { + let mut query_text = align_tabular_trim(value) + let mut length : Int? = None + let mut unit = "" + if fasta_style { + match align_tabular_last_delimiter(query_text, " - ") { + Some(delimiter) => { + let suffix = align_tabular_split_whitespace( + query_text[delimiter + 3:query_text.length()].to_owned(), + ) + if suffix.length() == 2 && (suffix[1] == "nt" || suffix[1] == "aa") { + let parsed_length = align_tabular_parse_int(suffix[0], "query size") + if parsed_length <= 0 { + raise AlignTabularError("query size must be positive") + } + length = Some(parsed_length) + unit = suffix[1] + query_text = align_tabular_trim(query_text[0:delimiter].to_owned()) + } + } + None => () + } + } + let parts = align_tabular_split_whitespace(query_text) + if parts.length() == 0 { + raise AlignTabularError("Query header must contain an identifier") + } + let identifier = parts[0] + let description = align_tabular_join(parts, 1) + (identifier, description, length, unit) +} + +///| +fn align_tabular_fields_header(value : String) -> Array[String] { + let raw = align_tabular_split_char(value, ',') + let result : Array[String] = [] + for field in raw { + result.push(align_tabular_trim(field)) + } + result +} + +///| +fn align_tabular_row_columns(line : String, expected : Int) -> Array[String] { + let tabular = align_tabular_split_char(line, '\t') + if tabular.length() == expected { + let result : Array[String] = [] + for value in tabular { + result.push(align_tabular_trim(value)) + } + return result + } + align_tabular_split_whitespace(line) +} + +///| +fn align_tabular_fields( + names : Array[String], + columns : Array[String], +) -> Array[AlignTabularField] raise AlignTabularError { + if columns.length() != names.length() { + raise AlignTabularError( + "tabular row has " + + columns.length().to_string() + + " columns but Fields declares " + + names.length().to_string(), + ) + } + let result : Array[AlignTabularField] = [] + for index in 0.. Unit raise AlignTabularError { + for field in fields { + match field.name { + "alignment length" + | "mismatches" + | "gap opens" + | "q. start" + | "q. end" + | "s. start" + | "s. end" + | "query length" + | "subject length" + | "score" + | "identical" + | "positives" + | "gaps" => { + let value = align_tabular_parse_int(field.value, field.name) + if value < 0 { + raise AlignTabularError(field.name + " must be non-negative") + } + if ( + field.name == "alignment length" || + field.name == "q. start" || + field.name == "q. end" || + field.name == "s. start" || + field.name == "s. end" || + field.name == "query length" || + field.name == "subject length" + ) && + value == 0 { + raise AlignTabularError(field.name + " must be positive") + } + } + "% identity" + | "evalue" + | "bit score" + | "% positives" + | "% hsp coverage" + | "% subject coverage" => { + let value = align_tabular_parse_double(field.value, field.name) + if value < 0.0 { + raise AlignTabularError(field.name + " must be non-negative") + } + if ( + field.name == "% identity" || + field.name == "% positives" || + field.name == "% hsp coverage" || + field.name == "% subject coverage" + ) && + value > 100.0 { + raise AlignTabularError(field.name + " must not exceed 100") + } + } + _ => () + } + } +} + +///| +fn align_tabular_alignment_from_row( + metadata : AlignTabularMetadata, + header_query_id : String, + header_description : String, + header_query_length : Int?, + names : Array[String], + line : String, +) -> AlignTabularAlignment raise AlignTabularError { + let columns = align_tabular_row_columns(line, names.length()) + let fields = align_tabular_fields(names, columns) + align_tabular_validate_numeric_fields(fields) + let query_id = match align_tabular_field_value(fields, "query id") { + Some(value) => value + None => + match align_tabular_field_value(fields, "query acc.ver") { + Some(value) => value + None => header_query_id + } + } + if query_id.length() == 0 { + raise AlignTabularError("tabular row has no query identifier") + } + if header_query_id.length() > 0 && query_id != header_query_id { + raise AlignTabularError( + "row query identifier " + + query_id + + " does not match Query header " + + header_query_id, + ) + } + let target_id = match align_tabular_field_value(fields, "subject id") { + Some(value) => value + None => + match align_tabular_field_value(fields, "subject acc.ver") { + Some(value) => value + None => "" + } + } + if target_id.length() == 0 { + raise AlignTabularError("tabular row has no subject identifier") + } + let row_query_length = align_tabular_optional_int(fields, "query length") + let query_length = match (header_query_length, row_query_length) { + (Some(header), Some(row)) => + if header != row { + raise AlignTabularError("query length disagrees with the Query header") + } else { + Some(header) + } + (Some(header), None) => Some(header) + (None, Some(row)) => Some(row) + (None, None) => None + } + match query_length { + Some(value) => + if value <= 0 { + raise AlignTabularError("query length must be positive") + } + None => () + } + let target_length = align_tabular_optional_int(fields, "subject length") + match target_length { + Some(value) => + if value <= 0 { + raise AlignTabularError("subject length must be positive") + } + None => () + } + let query_reported_start = align_tabular_optional_int(fields, "q. start") + let query_reported_end = align_tabular_optional_int(fields, "q. end") + let target_reported_start = align_tabular_optional_int(fields, "s. start") + let target_reported_end = align_tabular_optional_int(fields, "s. end") + let (query_start, query_end, query_strand) = align_tabular_interval( + query_reported_start, query_reported_end, "query", + ) + let (target_start, target_end, target_strand) = align_tabular_interval( + target_reported_start, target_reported_end, "subject", + ) + match (query_length, query_end) { + (Some(length), Some(end)) => + if end > length { + raise AlignTabularError("query coordinates exceed query length") + } + _ => () + } + match (target_length, target_end) { + (Some(length), Some(end)) => + if end > length { + raise AlignTabularError("subject coordinates exceed subject length") + } + _ => () + } + let query_sequence = align_tabular_field_value(fields, "query seq").unwrap_or( + "", + ) + let target_sequence = align_tabular_field_value(fields, "subject seq").unwrap_or( + "", + ) + align_tabular_validate_sequence(query_sequence, "query sequence") + align_tabular_validate_sequence(target_sequence, "subject sequence") + if query_sequence.length() > 0 && + target_sequence.length() > 0 && + query_sequence.length() != target_sequence.length() { + raise AlignTabularError( + "query and subject aligned sequences have different lengths", + ) + } + let path = align_tabular_path(fields) + let query_factor = align_tabular_axis_factor(metadata.program, true) + let target_factor = align_tabular_axis_factor(metadata.program, false) + let mut target_coordinates : Array[Int] = [] + let mut query_coordinates : Array[Int] = [] + let mut operations : Array[AlignTabularOperation] = [] + let mut path_is_absolute = false + let trace = if align_tabular_field_value(fields, "BTOP") is Some(_) { + AlignTabularTrace::Btop + } else if align_tabular_field_value(fields, "aln_code") is Some(_) { + AlignTabularTrace::Cigar + } else { + AlignTabularTrace::NoTrace + } + let trace_text = match trace { + Btop => align_tabular_field_value(fields, "BTOP").unwrap() + Cigar => align_tabular_field_value(fields, "aln_code").unwrap() + NoTrace => "" + } + match path { + Some(relative) => { + let alignment_length = align_tabular_optional_int( + fields, "alignment length", + ) + match alignment_length { + Some(length) => + if length != relative.columns { + raise AlignTabularError( + "traceback columns do not match alignment length", + ) + } + None => () + } + if query_sequence.length() > 0 { + if query_sequence.length() != relative.columns { + raise AlignTabularError( + "query sequence length does not match traceback columns", + ) + } + let consumed = relative.query_coordinates[relative.query_coordinates.length() - + 1] + if align_tabular_ungapped_length(query_sequence) != consumed { + raise AlignTabularError( + "query sequence consumption does not match traceback", + ) + } + } + if target_sequence.length() > 0 { + if target_sequence.length() != relative.columns { + raise AlignTabularError( + "subject sequence length does not match traceback columns", + ) + } + let consumed = relative.target_coordinates[relative.target_coordinates.length() - + 1] + if align_tabular_ungapped_length(target_sequence) != consumed { + raise AlignTabularError( + "subject sequence consumption does not match traceback", + ) + } + } + match + ( + query_reported_start, query_reported_end, target_reported_start, target_reported_end, + ) { + (Some(qs), Some(qe), Some(ts), Some(te)) => { + query_coordinates = align_tabular_absolute_axis( + relative.query_coordinates, + qs, + qe, + query_factor, + "query", + ) + target_coordinates = align_tabular_absolute_axis( + relative.target_coordinates, + ts, + te, + target_factor, + "subject", + ) + path_is_absolute = true + } + (None, None, None, None) => { + query_coordinates = align_tabular_scale_axis( + relative.query_coordinates, + query_factor, + ) + target_coordinates = align_tabular_scale_axis( + relative.target_coordinates, + target_factor, + ) + } + _ => + raise AlignTabularError( + "traceback requires all four query and subject coordinates", + ) + } + operations = align_tabular_copy_operations(relative.operations) + } + None => () + } + AlignTabularAlignment::{ + metadata, + query_id, + query_description: header_description, + target_id, + query_length, + target_length, + query_start, + query_end, + target_start, + target_end, + query_strand, + target_strand, + query_sequence, + target_sequence, + target_coordinates, + query_coordinates, + operations, + trace, + trace_text, + path_is_absolute, + target_units_per_residue: target_factor, + query_units_per_residue: query_factor, + fields, + } +} + +///| +fn align_tabular_parse_processed( + value : String, +) -> Int? raise AlignTabularError { + let suffix = " queries" + if !align_tabular_ends_with(value, suffix) { + return None + } + let prefixes = ["BLAST processed ", "FASTA processed "] + for prefix in prefixes { + if align_tabular_starts_with(value, prefix) { + let number = value[prefix.length():value.length() - suffix.length()].to_owned() + return Some(align_tabular_parse_int(number, "processed query count")) + } + } + None +} + +///| +fn align_tabular_parse_hits(value : String) -> Int? raise AlignTabularError { + let suffix = " hits found" + if !align_tabular_ends_with(value, suffix) { + return None + } + let number = align_tabular_trim( + value[0:value.length() - suffix.length()].to_owned(), + ) + Some(align_tabular_parse_int(number, "hit count")) +} + +///| +/// Parse BLAST outfmt 7 or FASTA `-m 8CB`/`-m 8CC` text. +pub fn align_tabular_parse( + content : String, +) -> AlignTabularDocument raise AlignTabularError { + if align_tabular_trim(content).length() == 0 { + raise AlignTabularError("empty alignment tabular document") + } + let lines = align_tabular_split_char(content, '\n') + let queries : Array[AlignTabularQueryResult] = [] + let mut processed_queries : Int? = None + let mut index = 0 + while index < lines.length() { + let line = align_tabular_trim(lines[index]) + if line.length() == 0 { + index = index + 1 + continue + } + if !align_tabular_starts_with(line, "# ") { + raise AlignTabularError("missing alignment tabular header") + } + let first_value = align_tabular_trim(line[2:line.length()].to_owned()) + match align_tabular_parse_processed(first_value) { + Some(count) => { + if count < 0 { + raise AlignTabularError("processed query count must be non-negative") + } + if processed_queries is Some(_) { + raise AlignTabularError("duplicate processed query summary") + } + processed_queries = Some(count) + index = index + 1 + continue + } + None => () + } + let mut command_line = "" + let mut program = "" + let mut version = "" + let mut fasta_style = false + match align_tabular_program_header(first_value) { + Some((parsed_program, parsed_version)) => { + program = parsed_program + version = parsed_version + fasta_style = align_tabular_known_fasta_program(program) + index = index + 1 + } + None => { + command_line = first_value + fasta_style = true + index = index + 1 + if index >= lines.length() { + raise AlignTabularError("missing FASTA program header") + } + let program_line = align_tabular_trim(lines[index]) + if !align_tabular_starts_with(program_line, "# ") { + raise AlignTabularError("missing FASTA program header") + } + let program_value = align_tabular_trim( + program_line[2:program_line.length()].to_owned(), + ) + match align_tabular_program_header(program_value) { + Some((parsed_program, parsed_version)) => + if !align_tabular_known_fasta_program(parsed_program) { + raise AlignTabularError( + "command line must be followed by a FASTA-suite program header", + ) + } else { + program = parsed_program + version = parsed_version + } + None => raise AlignTabularError("invalid FASTA program header") + } + index = index + 1 + } + } + let mut query_id = "" + let mut query_description = "" + let mut query_length : Int? = None + let mut query_unit = "" + let mut database = "" + let mut rid = "" + let mut field_names : Array[String] = [] + let mut declared_hits : Int? = None + let mut has_query = false + let mut has_database = false + let mut has_rid = false + let mut has_fields = false + while index < lines.length() { + let header = align_tabular_trim(lines[index]) + if !align_tabular_starts_with(header, "# ") { + break + } + let value = align_tabular_trim(header[2:header.length()].to_owned()) + match align_tabular_parse_hits(value) { + Some(count) => { + if count < 0 { + raise AlignTabularError("hit count must be non-negative") + } + declared_hits = Some(count) + index = index + 1 + break + } + None => () + } + if align_tabular_starts_with(value, "Query:") { + if has_query { + raise AlignTabularError("duplicate Query header") + } + has_query = true + let parsed = align_tabular_parse_query_header( + value[6:value.length()].to_owned(), + fasta_style, + ) + query_id = parsed.0 + query_description = parsed.1 + query_length = parsed.2 + query_unit = parsed.3 + } else if align_tabular_starts_with(value, "Database:") { + if has_database { + raise AlignTabularError("duplicate Database header") + } + has_database = true + database = align_tabular_trim(value[9:value.length()].to_owned()) + } else if align_tabular_starts_with(value, "RID:") { + if has_rid { + raise AlignTabularError("duplicate RID header") + } + has_rid = true + rid = align_tabular_trim(value[4:value.length()].to_owned()) + } else if align_tabular_starts_with(value, "Fields:") { + if has_fields { + raise AlignTabularError("duplicate Fields header") + } + has_fields = true + field_names = align_tabular_fields_header( + value[7:value.length()].to_owned(), + ) + align_tabular_validate_field_names(field_names) + } else { + raise AlignTabularError("unexpected header line: " + value) + } + index = index + 1 + } + let hit_count = match declared_hits { + Some(value) => value + None => raise AlignTabularError("query block is missing a hit count") + } + if query_id.length() == 0 { + raise AlignTabularError("query block is missing a Query header") + } + if database.length() == 0 { + raise AlignTabularError("query block is missing a Database header") + } + if hit_count > 0 && field_names.length() == 0 { + raise AlignTabularError("non-empty query block is missing Fields") + } + let metadata = AlignTabularMetadata::{ + program, + version, + command_line, + database, + rid, + } + let alignments : Array[AlignTabularAlignment] = [] + while index < lines.length() { + let row = align_tabular_trim(lines[index]) + if row.length() == 0 { + index = index + 1 + continue + } + if align_tabular_starts_with(row, "# ") { + break + } + alignments.push( + align_tabular_alignment_from_row( + metadata, query_id, query_description, query_length, field_names, row, + ), + ) + index = index + 1 + } + if alignments.length() != hit_count { + raise AlignTabularError( + "declared " + + hit_count.to_string() + + " hits but parsed " + + alignments.length().to_string() + + " rows", + ) + } + let mut inferred_query_length : Int? = None + for alignment in alignments { + if inferred_query_length is None && alignment.query_length is Some(_) { + inferred_query_length = alignment.query_length + } + } + let final_query_length = if query_length is Some(_) { + query_length + } else { + inferred_query_length + } + for alignment in alignments { + if final_query_length is Some(_) && + alignment.query_length is Some(_) && + final_query_length != alignment.query_length { + raise AlignTabularError("query length changes within a query block") + } + } + queries.push(AlignTabularQueryResult::{ + metadata, + query_id, + query_description, + query_length: final_query_length, + query_unit, + field_names: align_tabular_copy_strings(field_names), + declared_hits: hit_count, + alignments, + }) + } + match processed_queries { + Some(count) => + if count != queries.length() { + raise AlignTabularError( + "processed query count does not match parsed query blocks", + ) + } + None => () + } + AlignTabularDocument::{ queries, processed_queries } +} + +///| +/// Return an original row field. +pub fn AlignTabularAlignment::field( + self : AlignTabularAlignment, + name : String, +) -> String? { + align_tabular_field_value(self.fields, name) +} + +///| +/// Return an integer row field. +pub fn AlignTabularAlignment::integer_field( + self : AlignTabularAlignment, + name : String, +) -> Int? raise AlignTabularError { + align_tabular_optional_int(self.fields, name) +} + +///| +/// Return a floating-point row field. +pub fn AlignTabularAlignment::number_field( + self : AlignTabularAlignment, + name : String, +) -> Double? raise AlignTabularError { + align_tabular_optional_double(self.fields, name) +} + +///| +/// Number of printed alignment columns represented by the path. +pub fn AlignTabularAlignment::alignment_columns( + self : AlignTabularAlignment, +) -> Int { + let mut result = 0 + for index in 0.. query { target } else { query }) + } + result +} + +///| +/// Number of aligned residue pairs represented by the path. +pub fn AlignTabularAlignment::aligned_residues( + self : AlignTabularAlignment, +) -> Int { + let mut result = 0 + for index in 0.. Int { + let mut result = 0 + for index in 0.. Int { + let mut result = 0 + for index in 0.. Int { + let mut result = 0 + for operation in self.operations { + if operation != AlignTabularOperation::Aligned { + result = result + 1 + } + } + result +} + +///| +/// True if the query was reported on the reverse strand. +pub fn AlignTabularAlignment::query_is_reverse( + self : AlignTabularAlignment, +) -> Bool { + self.query_strand == Strand::Minus +} + +///| +/// True if the subject was reported on the reverse strand. +pub fn AlignTabularAlignment::target_is_reverse( + self : AlignTabularAlignment, +) -> Bool { + self.target_strand == Strand::Minus +} + +///| +/// Convert the path to the repository's coordinate alignment abstraction. +/// +/// The target axis is normalized to increasing order; the query axis then +/// represents relative strand orientation. +pub fn AlignTabularAlignment::coordinate_alignment( + self : AlignTabularAlignment, +) -> CoordinatePairwiseAlignment raise AlignTabularError { + if self.target_coordinates.length() == 0 || !self.path_is_absolute { + raise AlignTabularError( + "an absolute traceback path is required for coordinate conversion", + ) + } + let mut target = align_tabular_copy_ints(self.target_coordinates) + let mut query = align_tabular_copy_ints(self.query_coordinates) + if target[0] > target[target.length() - 1] { + let reversed_target : Array[Int] = [] + let reversed_query : Array[Int] = [] + let mut index = target.length() + while index > 0 { + index = index - 1 + reversed_target.push(target[index]) + reversed_query.push(query[index]) + } + target = reversed_target + query = reversed_query + } + let mut inferred_target_length = 0 + let mut inferred_query_length = 0 + for coordinate in target { + if coordinate > inferred_target_length { + inferred_target_length = coordinate + } + } + for coordinate in query { + if coordinate > inferred_query_length { + inferred_query_length = coordinate + } + } + let target_length = self.target_length.unwrap_or(inferred_target_length) + let query_length = self.query_length.unwrap_or(inferred_query_length) + coordinate_pairwise_alignment_with_lengths( + self.target_id, + target_length, + self.query_id, + query_length, + target, + query, + ) catch { + AlignmentMapError(message) => + raise AlignTabularError("coordinate conversion failed: " + message) + } +} + +///| +/// Compact human-readable alignment summary. +pub fn AlignTabularAlignment::summary(self : AlignTabularAlignment) -> String { + let mut result = self.query_id + " -> " + self.target_id + match self.field("evalue") { + Some(value) => result = result + ", E=" + value + None => () + } + match self.field("bit score") { + Some(value) => result = result + ", bits=" + value + None => () + } + if self.operations.length() > 0 { + result = result + + ", columns=" + + self.alignment_columns().to_string() + + ", gaps=" + + (self.query_gap_residues() + self.target_gap_residues()).to_string() + } + result +} + +///| +/// Flatten all query blocks into input-order alignments. +pub fn AlignTabularDocument::alignments( + self : AlignTabularDocument, +) -> Array[AlignTabularAlignment] { + let result : Array[AlignTabularAlignment] = [] + for query in self.queries { + for alignment in query.alignments { + result.push(alignment) + } + } + result +} + +///| +/// Find a query block by identifier. +pub fn AlignTabularDocument::find_query( + self : AlignTabularDocument, + query_id : String, +) -> AlignTabularQueryResult? { + for query in self.queries { + if query.query_id == query_id { + return Some(query) + } + } + None +} + +///| +/// Return the lowest-E-value alignment in a query block. +pub fn AlignTabularQueryResult::best_by_evalue( + self : AlignTabularQueryResult, +) -> AlignTabularAlignment? raise AlignTabularError { + let mut best : AlignTabularAlignment? = None + let mut best_value = 0.0 + for alignment in self.alignments { + match alignment.number_field("evalue") { + Some(value) => + if best is None || value < best_value { + best = Some(alignment) + best_value = value + } + None => () + } + } + best +} + +///| +/// Return alignments with E-value at or below a threshold. +pub fn AlignTabularQueryResult::filter_evalue( + self : AlignTabularQueryResult, + threshold : Double, +) -> Array[AlignTabularAlignment] raise AlignTabularError { + if threshold.is_nan() || threshold < 0.0 || threshold.abs() > 1.0e300 { + raise AlignTabularError("E-value threshold must be finite and non-negative") + } + let result : Array[AlignTabularAlignment] = [] + for alignment in self.alignments { + match alignment.number_field("evalue") { + Some(value) => if value <= threshold { result.push(alignment) } + None => () + } + } + result +} diff --git a/test/moonbit/align_tabular_test.mbt b/test/moonbit/align_tabular_test.mbt new file mode 100644 index 00000000..a29327d7 --- /dev/null +++ b/test/moonbit/align_tabular_test.mbt @@ -0,0 +1,1342 @@ +///| +fn align_tabular_test_join( + values : Array[String], + separator : String, +) -> String { + let mut result = "" + for index in 0.. 0 { + result = result + separator + } + result = result + values[index] + } + result +} + +///| +fn align_tabular_test_block( + program : String, + query : String, + database : String, + fields : Array[String], + rows : Array[Array[String]], + hits : Int, +) -> String { + let mut result = "# " + + program + + "\n# Query: " + + query + + "\n# Database: " + + database + + "\n" + if fields.length() > 0 { + result = result + + "# Fields: " + + align_tabular_test_join(fields, ", ") + + "\n" + } + result = result + "# " + hits.to_string() + " hits found\n" + for row in rows { + result = result + align_tabular_test_join(row, "\t") + "\n" + } + result +} + +///| +fn align_tabular_test_fields() -> Array[String] { + [ + "query id", "subject id", "% identity", "alignment length", "mismatches", "gap opens", + "q. start", "q. end", "s. start", "s. end", "evalue", "bit score", "BTOP", "query length", + "subject length", "query seq", "subject seq", + ] +} + +///| +fn align_tabular_test_values() -> Array[String] { + [ + "q1", "s1", "75.0", "8", "2", "2", "3", "9", "10", "16", "1e-5", "42.0", "2AC1-GT-2", + "20", "30", "AAAT-TGG", "AACTG-GG", + ] +} + +///| +fn align_tabular_test_document() -> @src.AlignTabularDocument { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 protein query", + "proteins", + align_tabular_test_fields(), + [align_tabular_test_values()], + 1, + ) + @src.align_tabular_parse(text) catch { + _ => abort("valid alignment-aware BLAST document should parse") + } +} + +///| +fn align_tabular_test_raises(content : String) -> Bool { + try { + ignore(@src.align_tabular_parse(content)) + false + } catch { + AlignTabularError(_) => true + } +} + +///| +fn align_tabular_test_btop_raises(value : String) -> Bool { + try { + ignore(@src.align_tabular_parse_btop(value)) + false + } catch { + AlignTabularError(_) => true + } +} + +///| +fn align_tabular_test_cigar_raises(value : String) -> Bool { + try { + ignore(@src.align_tabular_parse_cigar(value)) + false + } catch { + AlignTabularError(_) => true + } +} + +///| +test "Bio.Align.tabular BTOP: one match run" { + let (target, query, operations) = @src.align_tabular_parse_btop("12") catch { + _ => abort("valid BTOP should parse") + } + assert_eq(target, [0, 12]) + assert_eq(query, [0, 12]) + assert_eq(operations.length(), 1) + assert_true(operations[0] is @src.AlignTabularOperation::Aligned) +} + +///| +test "Bio.Align.tabular BTOP: mismatches merge with matches" { + let (target, query, operations) = @src.align_tabular_parse_btop("2AC3GT1") catch { + _ => abort("valid BTOP should parse") + } + assert_eq(target, [0, 8]) + assert_eq(query, [0, 8]) + assert_eq(operations.length(), 1) +} + +///| +test "Bio.Align.tabular BTOP: query gap consumes target" { + let (target, query, operations) = @src.align_tabular_parse_btop("2-G3") catch { + _ => abort("valid BTOP should parse") + } + assert_eq(target, [0, 2, 3, 6]) + assert_eq(query, [0, 2, 2, 5]) + assert_true(operations[1] is @src.AlignTabularOperation::QueryGap) +} + +///| +test "Bio.Align.tabular BTOP: target gap consumes query" { + let (target, query, operations) = @src.align_tabular_parse_btop("2G-3") catch { + _ => abort("valid BTOP should parse") + } + assert_eq(target, [0, 2, 2, 5]) + assert_eq(query, [0, 2, 3, 6]) + assert_true(operations[1] is @src.AlignTabularOperation::TargetGap) +} + +///| +test "Bio.Align.tabular BTOP: adjacent gaps form one run" { + let (target, query, operations) = @src.align_tabular_parse_btop("1-A-C2") catch { + _ => abort("valid BTOP should parse") + } + assert_eq(target, [0, 1, 3, 5]) + assert_eq(query, [0, 1, 1, 3]) + assert_eq(operations.length(), 3) +} + +///| +test "Bio.Align.tabular BTOP: stop residues are accepted" { + let (target, query, operations) = @src.align_tabular_parse_btop("1*A2") catch { + _ => abort("protein stop mismatch should parse") + } + assert_eq(target, [0, 4]) + assert_eq(query, [0, 4]) + assert_eq(operations.length(), 1) +} + +///| +test "Bio.Align.tabular CIGAR: one match run" { + let (target, query, operations) = @src.align_tabular_parse_cigar("218M") catch { + _ => abort("valid aln_code should parse") + } + assert_eq(target, [0, 218]) + assert_eq(query, [0, 218]) + assert_eq(operations.length(), 1) + assert_true(operations[0] is @src.AlignTabularOperation::Aligned) +} + +///| +test "Bio.Align.tabular CIGAR: FASTA insertion consumes target" { + let (target, query, operations) = @src.align_tabular_parse_cigar("3M2I4M") catch { + _ => abort("valid aln_code should parse") + } + assert_eq(target, [0, 3, 5, 9]) + assert_eq(query, [0, 3, 3, 7]) + assert_true(operations[1] is @src.AlignTabularOperation::QueryGap) +} + +///| +test "Bio.Align.tabular CIGAR: FASTA deletion consumes query" { + let (target, query, operations) = @src.align_tabular_parse_cigar("3M2D4M") catch { + _ => abort("valid aln_code should parse") + } + assert_eq(target, [0, 3, 3, 7]) + assert_eq(query, [0, 3, 5, 9]) + assert_true(operations[1] is @src.AlignTabularOperation::TargetGap) +} + +///| +test "Bio.Align.tabular CIGAR: adjacent operations are normalized" { + let (target, query, operations) = @src.align_tabular_parse_cigar("2M3M1I2I") catch { + _ => abort("valid aln_code should parse") + } + assert_eq(target, [0, 5, 8]) + assert_eq(query, [0, 5, 5]) + assert_eq(operations.length(), 2) +} + +///| +test "Bio.Align.tabular BLAST: metadata and descriptions" { + let document = align_tabular_test_document() + let query = document.queries[0] + assert_eq(query.metadata.program, "BLASTP") + assert_eq(query.metadata.version, "2.14.1+") + assert_eq(query.metadata.database, "proteins") + assert_eq(query.query_id, "q1") + assert_eq(query.query_description, "protein query") + assert_eq(query.declared_hits, 1) +} + +///| +test "Bio.Align.tabular BLAST: intervals are zero-based half-open" { + let alignment = align_tabular_test_document().queries[0].alignments[0] + assert_eq(alignment.query_start, Some(2)) + assert_eq(alignment.query_end, Some(9)) + assert_eq(alignment.target_start, Some(9)) + assert_eq(alignment.target_end, Some(16)) + assert_true(alignment.query_strand is @src.Strand::Plus) + assert_true(alignment.target_strand is @src.Strand::Plus) +} + +///| +test "Bio.Align.tabular BLAST: BTOP creates absolute coordinate path" { + let alignment = align_tabular_test_document().queries[0].alignments[0] + assert_eq(alignment.target_coordinates, [9, 13, 14, 14, 16]) + assert_eq(alignment.query_coordinates, [2, 6, 6, 7, 9]) + assert_true(alignment.path_is_absolute) + assert_true(alignment.trace is @src.AlignTabularTrace::Btop) +} + +///| +test "Bio.Align.tabular BLAST: path operations preserve gap direction" { + let alignment = align_tabular_test_document().queries[0].alignments[0] + assert_eq(alignment.operations.length(), 4) + assert_true(alignment.operations[0] is @src.AlignTabularOperation::Aligned) + assert_true(alignment.operations[1] is @src.AlignTabularOperation::QueryGap) + assert_true(alignment.operations[2] is @src.AlignTabularOperation::TargetGap) + assert_true(alignment.operations[3] is @src.AlignTabularOperation::Aligned) +} + +///| +test "Bio.Align.tabular BLAST: path statistics" { + let alignment = align_tabular_test_document().queries[0].alignments[0] + assert_eq(alignment.alignment_columns(), 8) + assert_eq(alignment.aligned_residues(), 6) + assert_eq(alignment.query_gap_residues(), 1) + assert_eq(alignment.target_gap_residues(), 1) + assert_eq(alignment.gap_events(), 2) +} + +///| +test "Bio.Align.tabular BLAST: typed and raw field lookup" { + let alignment = align_tabular_test_document().queries[0].alignments[0] + assert_eq(alignment.field("subject id"), Some("s1")) + assert_eq( + alignment.integer_field("alignment length") catch { + _ => abort("integer field should parse") + }, + Some(8), + ) + let evalue = alignment.number_field("evalue") catch { + _ => abort("numeric field should parse") + } + match evalue { + Some(value) => assert_true((value - 1.0e-5).abs() < 1.0e-15) + None => abort("numeric field should exist") + } + assert_eq(alignment.field("missing"), None) +} + +///| +test "Bio.Align.tabular BLAST: summary includes score and path statistics" { + let summary = align_tabular_test_document().queries[0].alignments[0].summary() + assert_true(summary.contains("q1 -> s1")) + assert_true(summary.contains("E=1e-5")) + assert_true(summary.contains("bits=42.0")) + assert_true(summary.contains("columns=8")) + assert_true(summary.contains("gaps=2")) +} + +///| +test "Bio.Align.tabular BLAST: coordinate alignment conversion" { + let converted = align_tabular_test_document().queries[0].alignments[0].coordinate_alignment() catch { + _ => abort("absolute path should convert") + } + assert_eq(converted.target_name, "s1") + assert_eq(converted.query_name, "q1") + assert_eq(converted.target_length, 30) + assert_eq(converted.query_length, 20) + assert_eq(converted.target_coordinates, [9, 13, 14, 14, 16]) + assert_eq(converted.query_coordinates, [2, 6, 6, 7, 9]) +} + +///| +test "Bio.Align.tabular BLAST: reverse query coordinates" { + let values = align_tabular_test_values() + values[6] = "9" + values[7] = "3" + let document = @src.align_tabular_parse( + align_tabular_test_block( + "BLASTN 2.14.1+", + "q1 reverse query", + "nucleotide", + align_tabular_test_fields(), + [values], + 1, + ), + ) catch { + _ => abort("reverse query should parse") + } + let alignment = document.queries[0].alignments[0] + assert_true(alignment.query_is_reverse()) + assert_eq(alignment.query_coordinates, [9, 5, 5, 4, 2]) +} + +///| +test "Bio.Align.tabular BLAST: reverse target conversion normalizes target" { + let values = align_tabular_test_values() + values[8] = "16" + values[9] = "10" + let document = @src.align_tabular_parse( + align_tabular_test_block( + "BLASTN 2.14.1+", + "q1 reverse target", + "nucleotide", + align_tabular_test_fields(), + [values], + 1, + ), + ) catch { + _ => abort("reverse target should parse") + } + let alignment = document.queries[0].alignments[0] + assert_true(alignment.target_is_reverse()) + assert_eq(alignment.target_coordinates, [16, 12, 11, 11, 9]) + let converted = alignment.coordinate_alignment() catch { + _ => abort("reverse target should normalize") + } + assert_eq(converted.target_coordinates, [9, 11, 11, 12, 16]) + assert_eq(converted.query_coordinates, [9, 7, 6, 6, 2]) +} + +///| +test "Bio.Align.tabular FASTA 8CC: command line and query size" { + let text = "# fasta36 -q -m 8CC query.aa database.aa\n" + + "# FASTA 36.3.8h May, 2020\n" + + "# Query: qf protein query - 218 aa\n" + + "# Database: database.aa\n" + + "# Fields: query id, subject id, % identity, alignment length, mismatches, gap opens, q. start, q. end, s. start, s. end, evalue, bit score, aln_code\n" + + "# 1 hits found\n" + + "qf\tsf\t50.0\t9\t4\t2\t4\t10\t6\t13\t1e-4\t30.0\t3M2I1D3M\n" + + "# FASTA processed 1 queries\n" + let document = @src.align_tabular_parse(text) catch { + _ => abort("valid FASTA 8CC should parse") + } + let query = document.queries[0] + assert_eq( + query.metadata.command_line, + "fasta36 -q -m 8CC query.aa database.aa", + ) + assert_eq(query.metadata.program, "FASTA") + assert_eq(query.query_length, Some(218)) + assert_eq(query.query_unit, "aa") + assert_eq(document.processed_queries, Some(1)) +} + +///| +test "Bio.Align.tabular FASTA 8CC: CIGAR path" { + let text = "# fasta36 -m 8CC q db\n" + + "# FASTA 36.3.8h\n" + + "# Query: qf protein - 218 aa\n" + + "# Database: db\n" + + "# Fields: query id, subject id, alignment length, q. start, q. end, s. start, s. end, aln_code\n" + + "# 1 hits found\n" + + "qf\tsf\t9\t4\t10\t6\t13\t3M2I1D3M\n" + let alignment = (@src.align_tabular_parse(text) catch { + _ => abort("valid FASTA CIGAR should parse") + }).queries[0].alignments[0] + assert_true(alignment.trace is @src.AlignTabularTrace::Cigar) + assert_eq(alignment.target_coordinates, [5, 8, 10, 10, 13]) + assert_eq(alignment.query_coordinates, [3, 6, 6, 7, 10]) + assert_eq(alignment.alignment_columns(), 9) +} + +///| +test "Bio.Align.tabular BLAST: multiple queries include zero-hit blocks" { + let first = align_tabular_test_block( + "BLASTP 2.14.1+", + "empty no matches", + "proteins", + [], + [], + 0, + ) + let second = align_tabular_test_block( + "BLASTP 2.14.1+", + "q2 one match", + "proteins", + ["query id", "subject id", "evalue"], + [["q2", "s2", "0.01"]], + 1, + ) + let document = @src.align_tabular_parse( + first + second + "# BLAST processed 2 queries\n", + ) catch { + _ => abort("multi-query BLAST should parse") + } + assert_eq(document.queries.length(), 2) + assert_eq(document.queries[0].alignments.length(), 0) + assert_eq(document.queries[1].alignments.length(), 1) + assert_eq(document.alignments().length(), 1) +} + +///| +test "Bio.Align.tabular BLAST: processed summary is optional" { + let document = align_tabular_test_document() + assert_eq(document.processed_queries, None) +} + +///| +test "Bio.Align.tabular BLAST: query and subject accession fallback" { + let document = @src.align_tabular_parse( + align_tabular_test_block( + "BLASTP 2.14.1+", + "QACC.1 accession query", + "proteins", + ["query acc.ver", "subject acc.ver", "evalue"], + [["QACC.1", "SACC.2", "0.2"]], + 1, + ), + ) catch { + _ => abort("accession-only identifiers should parse") + } + let alignment = document.queries[0].alignments[0] + assert_eq(alignment.query_id, "QACC.1") + assert_eq(alignment.target_id, "SACC.2") +} + +///| +test "Bio.Align.tabular BLAST: rows without traceback retain annotations" { + let document = @src.align_tabular_parse( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "proteins", + ["query id", "subject id", "alignment length", "evalue"], + [["q1", "s1", "12", "0.4"]], + 1, + ), + ) catch { + _ => abort("hit-table row should parse without traceback") + } + let alignment = document.queries[0].alignments[0] + assert_true(alignment.trace is @src.AlignTabularTrace::NoTrace) + assert_eq(alignment.operations.length(), 0) + assert_true(!alignment.path_is_absolute) +} + +///| +test "Bio.Align.tabular BLAST: complete upstream field vocabulary" { + let fields = [ + "query id", "subject id", "% identity", "alignment length", "mismatches", "gap opens", + "q. start", "q. end", "s. start", "s. end", "evalue", "bit score", "BTOP", "query gi", + "query acc.", "query acc.ver", "query length", "subject ids", "subject gi", "subject gis", + "subject acc.", "subject acc.ver", "subject accs.", "subject length", "query seq", + "subject seq", "score", "identical", "positives", "gaps", "% positives", "% hsp coverage", + "query/sbjct frames", "query frame", "sbjct frame", "subject tax ids", "subject sci names", + "subject com names", "subject blast names", "subject super kingdoms", "subject title", + "subject titles", "subject strand", "% subject coverage", + ] + let values = [ + "q1", "s1", "100", "3", "0", "0", "1", "3", "2", "4", "1e-20", "60.5", "3", "11", + "QACC", "q1", "10", "s1;s2", "22", "22;23", "SACC", "SACC.1", "SACC;ALT", "20", + "AAA", "AAA", "120", "3", "3", "0", "100", "30", "1/1", "1", "1", "9606", "Homo sapiens", + "human", "primates", "Eukaryota", "subject title with spaces", "title one<>title two", + "plus", "75", + ] + let alignment = (@src.align_tabular_parse( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 full fields", + "database", + fields, + [values], + 1, + ), + ) catch { + _ => abort("complete BLAST field vocabulary should parse") + }).queries[0].alignments[0] + assert_eq(alignment.fields.length(), 44) + assert_eq(alignment.field("subject title"), Some("subject title with spaces")) + assert_eq(alignment.field("subject tax ids"), Some("9606")) +} + +///| +test "Bio.Align.tabular BLASTX: query nucleotide axis is tripled" { + let alignment = (@src.align_tabular_parse( + align_tabular_test_block( + "BLASTX 2.14.1+", + "qx translated query", + "proteins", + [ + "query id", "subject id", "query length", "subject length", "q. start", + "q. end", "s. start", "s. end", "alignment length", "BTOP", + ], + [["qx", "sp", "30", "20", "1", "12", "5", "8", "4", "4"]], + 1, + ), + ) catch { + _ => abort("BLASTX coordinates should parse") + }).queries[0].alignments[0] + assert_eq(alignment.query_units_per_residue, 3) + assert_eq(alignment.target_units_per_residue, 1) + assert_eq(alignment.query_coordinates, [0, 12]) + assert_eq(alignment.target_coordinates, [4, 8]) + assert_eq(alignment.alignment_columns(), 4) +} + +///| +test "Bio.Align.tabular TBLASTN: target nucleotide axis is tripled" { + let alignment = (@src.align_tabular_parse( + align_tabular_test_block( + "TBLASTN 2.14.1+", + "qp protein query", + "nucleotides", + [ + "query id", "subject id", "query length", "subject length", "q. start", + "q. end", "s. start", "s. end", "alignment length", "BTOP", + ], + [["qp", "sn", "10", "60", "2", "5", "7", "18", "4", "4"]], + 1, + ), + ) catch { + _ => abort("TBLASTN coordinates should parse") + }).queries[0].alignments[0] + assert_eq(alignment.query_units_per_residue, 1) + assert_eq(alignment.target_units_per_residue, 3) + assert_eq(alignment.query_coordinates, [1, 5]) + assert_eq(alignment.target_coordinates, [6, 18]) +} + +///| +test "Bio.Align.tabular TBLASTX: both reverse nucleotide axes are tripled" { + let alignment = (@src.align_tabular_parse( + align_tabular_test_block( + "TBLASTX 2.14.1+", + "qn translated query", + "nucleotides", + [ + "query id", "subject id", "query length", "subject length", "q. start", + "q. end", "s. start", "s. end", "alignment length", "BTOP", + ], + [["qn", "sn", "60", "90", "30", "19", "45", "34", "4", "4"]], + 1, + ), + ) catch { + _ => abort("TBLASTX reverse coordinates should parse") + }).queries[0].alignments[0] + assert_eq(alignment.query_coordinates, [30, 18]) + assert_eq(alignment.target_coordinates, [45, 33]) + assert_true(alignment.query_is_reverse()) + assert_true(alignment.target_is_reverse()) +} + +///| +test "Bio.Align.tabular FASTX: query translated axis is tripled" { + let text = "# fastx36 -m 8CB q.nt db.aa\n" + + "# FASTX 36.3.8h\n" + + "# Query: qx translated - 30 nt\n" + + "# Database: db.aa\n" + + "# Fields: query id, subject id, alignment length, q. start, q. end, s. start, s. end, BTOP\n" + + "# 1 hits found\n" + + "qx\tsp\t4\t1\t12\t5\t8\t4\n" + let alignment = (@src.align_tabular_parse(text) catch { + _ => abort("FASTX coordinates should parse") + }).queries[0].alignments[0] + assert_eq(alignment.query_units_per_residue, 3) + assert_eq(alignment.query_coordinates, [0, 12]) +} + +///| +test "Bio.Align.tabular TFASTX: target translated axis is tripled" { + let text = "# tfastx36 -m 8CB q.aa db.nt\n" + + "# TFASTX 36.3.8h\n" + + "# Query: qp protein - 10 aa\n" + + "# Database: db.nt\n" + + "# Fields: query id, subject id, alignment length, q. start, q. end, s. start, s. end, BTOP\n" + + "# 1 hits found\n" + + "qp\tsn\t4\t2\t5\t7\t18\t4\n" + let alignment = (@src.align_tabular_parse(text) catch { + _ => abort("TFASTX coordinates should parse") + }).queries[0].alignments[0] + assert_eq(alignment.target_units_per_residue, 3) + assert_eq(alignment.target_coordinates, [6, 18]) +} + +///| +test "Bio.Align.tabular translated relative paths preserve axis units" { + let alignment = (@src.align_tabular_parse( + align_tabular_test_block( + "BLASTX 2.14.1+", + "qx translated query", + "proteins", + ["query id", "subject id", "alignment length", "BTOP"], + [["qx", "sp", "4", "4"]], + 1, + ), + ) catch { + _ => abort("relative translated path should parse") + }).queries[0].alignments[0] + assert_eq(alignment.query_coordinates, [0, 12]) + assert_eq(alignment.target_coordinates, [0, 4]) + assert_eq(alignment.alignment_columns(), 4) + assert_true(!alignment.path_is_absolute) +} + +///| +test "Bio.Align.tabular query lookup and flattening" { + let document = align_tabular_test_document() + match document.find_query("q1") { + Some(query) => assert_eq(query.alignments.length(), 1) + None => abort("query should be found") + } + assert_true(document.find_query("missing") is None) + assert_eq(document.alignments().length(), 1) +} + +///| +test "Bio.Align.tabular best hit uses minimum E-value" { + let document = @src.align_tabular_parse( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "proteins", + ["query id", "subject id", "evalue"], + [["q1", "late", "0.1"], ["q1", "best", "1e-20"], ["q1", "middle", "1e-5"]], + 3, + ), + ) catch { + _ => abort("three hits should parse") + } + let best = document.queries[0].best_by_evalue() catch { + _ => abort("best E-value should be computable") + } + match best { + Some(alignment) => assert_eq(alignment.target_id, "best") + None => abort("best hit should exist") + } +} + +///| +test "Bio.Align.tabular E-value filtering is inclusive" { + let document = @src.align_tabular_parse( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "proteins", + ["query id", "subject id", "evalue"], + [["q1", "a", "0.01"], ["q1", "b", "0.1"]], + 2, + ), + ) catch { + _ => abort("two hits should parse") + } + let filtered = document.queries[0].filter_evalue(0.01) catch { + _ => abort("finite threshold should filter") + } + assert_eq(filtered.length(), 1) + assert_eq(filtered[0].target_id, "a") +} + +///| +test "Bio.Align.tabular empty document is rejected" { + assert_true(align_tabular_test_raises(" \n\t")) +} + +///| +test "Bio.Align.tabular missing hash header is rejected" { + assert_true(align_tabular_test_raises("BLASTP 2.14.1+\n")) +} + +///| +test "Bio.Align.tabular missing FASTA program header is rejected" { + assert_true(align_tabular_test_raises("# fasta36 -m 8CB q db\n")) +} + +///| +test "Bio.Align.tabular FASTA command followed by BLAST is rejected" { + assert_true( + align_tabular_test_raises("# fasta36 -m 8CB q db\n# BLASTP 2.14.1+\n"), + ) +} + +///| +test "Bio.Align.tabular missing Query header is rejected" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + [], + [], + 0, + ).replace_all(old="# Query: q1 query\n", new="") + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular missing Database header is rejected" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + [], + [], + 0, + ).replace_all(old="# Database: db\n", new="") + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular missing hit count is rejected" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + [], + [], + 0, + ).replace_all(old="# 0 hits found\n", new="") + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular non-empty block requires Fields" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + [], + [["q1", "s1"]], + 1, + ) + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular unknown field is rejected" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + ["query id", "subject id", "unknown score"], + [["q1", "s1", "1"]], + 1, + ) + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular duplicate field is rejected" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + ["query id", "subject id", "subject id"], + [["q1", "s1", "s1"]], + 1, + ) + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular empty field name is rejected" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + ["query id", "", "subject id"], + [["q1", "", "s1"]], + 1, + ) + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular duplicate Query header is rejected" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + [], + [], + 0, + ).replace_all( + old="# Query: q1 query\n", + new="# Query: q1 query\n# Query: q1 query\n", + ) + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular duplicate Database header is rejected" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + [], + [], + 0, + ).replace_all(old="# Database: db\n", new="# Database: db\n# Database: db\n") + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular duplicate RID header is rejected" { + let text = "# BLASTP 2.14.1+\n" + + "# Query: q1 query\n" + + "# Database: db\n" + + "# RID: one\n" + + "# RID: two\n" + + "# 0 hits found\n" + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular duplicate Fields header is rejected" { + let text = "# BLASTP 2.14.1+\n" + + "# Query: q1 query\n" + + "# Database: db\n" + + "# Fields: query id, subject id\n" + + "# Fields: query id, subject id\n" + + "# 0 hits found\n" + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular negative hit count is rejected" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + [], + [], + -1, + ) + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular declared hit count must match rows" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + ["query id", "subject id"], + [["q1", "s1"]], + 2, + ) + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular processed count must match query blocks" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + [], + [], + 0, + ) + + "# BLAST processed 2 queries\n" + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular duplicate processed summary is rejected" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + [], + [], + 0, + ) + + "# BLAST processed 1 queries\n" + + "# BLAST processed 1 queries\n" + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular negative processed count is rejected" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + [], + [], + 0, + ) + + "# BLAST processed -1 queries\n" + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular row column count is validated" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + ["query id", "subject id", "evalue"], + [["q1", "s1"]], + 1, + ) + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular invalid integer field is rejected" { + let values = align_tabular_test_values() + values[3] = "8oops" + assert_true( + align_tabular_test_raises( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + align_tabular_test_fields(), + [values], + 1, + ), + ), + ) +} + +///| +test "Bio.Align.tabular invalid floating field is rejected" { + let values = align_tabular_test_values() + values[10] = "1e-5oops" + assert_true( + align_tabular_test_raises( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + align_tabular_test_fields(), + [values], + 1, + ), + ), + ) +} + +///| +test "Bio.Align.tabular NaN is rejected" { + let values = align_tabular_test_values() + values[10] = "NaN" + assert_true( + align_tabular_test_raises( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + align_tabular_test_fields(), + [values], + 1, + ), + ), + ) +} + +///| +test "Bio.Align.tabular percentage above one hundred is rejected" { + let values = align_tabular_test_values() + values[2] = "100.1" + assert_true( + align_tabular_test_raises( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + align_tabular_test_fields(), + [values], + 1, + ), + ), + ) +} + +///| +test "Bio.Align.tabular negative E-value is rejected" { + let values = align_tabular_test_values() + values[10] = "-0.1" + assert_true( + align_tabular_test_raises( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + align_tabular_test_fields(), + [values], + 1, + ), + ), + ) +} + +///| +test "Bio.Align.tabular zero coordinate is rejected" { + let values = align_tabular_test_values() + values[6] = "0" + assert_true( + align_tabular_test_raises( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + align_tabular_test_fields(), + [values], + 1, + ), + ), + ) +} + +///| +test "Bio.Align.tabular coordinate beyond sequence length is rejected" { + let values = align_tabular_test_values() + values[7] = "21" + assert_true( + align_tabular_test_raises( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + align_tabular_test_fields(), + [values], + 1, + ), + ), + ) +} + +///| +test "Bio.Align.tabular paired coordinates are required" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + ["query id", "subject id", "q. start"], + [["q1", "s1", "1"]], + 1, + ) + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular traceback requires all four coordinates" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + ["query id", "subject id", "q. start", "q. end", "alignment length", "BTOP"], + [["q1", "s1", "1", "4", "4", "4"]], + 1, + ) + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular traceback span must match reported coordinates" { + let values = align_tabular_test_values() + values[7] = "10" + assert_true( + align_tabular_test_raises( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + align_tabular_test_fields(), + [values], + 1, + ), + ), + ) +} + +///| +test "Bio.Align.tabular traceback columns must match alignment length" { + let values = align_tabular_test_values() + values[3] = "9" + assert_true( + align_tabular_test_raises( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + align_tabular_test_fields(), + [values], + 1, + ), + ), + ) +} + +///| +test "Bio.Align.tabular aligned sequence lengths must agree" { + let values = align_tabular_test_values() + values[16] = "AACTG-G" + assert_true( + align_tabular_test_raises( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + align_tabular_test_fields(), + [values], + 1, + ), + ), + ) +} + +///| +test "Bio.Align.tabular aligned sequence columns must match traceback" { + let values = align_tabular_test_values() + values[15] = "AAAT-TG" + values[16] = "AACTG-G" + assert_true( + align_tabular_test_raises( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + align_tabular_test_fields(), + [values], + 1, + ), + ), + ) +} + +///| +test "Bio.Align.tabular sequence consumption must match traceback" { + let values = align_tabular_test_values() + values[15] = "AAAATTGG" + assert_true( + align_tabular_test_raises( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + align_tabular_test_fields(), + [values], + 1, + ), + ), + ) +} + +///| +test "Bio.Align.tabular sequence whitespace is rejected" { + let fields = ["query id", "subject id", "query seq", "subject seq"] + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + fields, + [["q1", "s1", "AA AA", "AAAAA"]], + 1, + ) + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular BTOP and CIGAR cannot coexist" { + let fields = ["query id", "subject id", "BTOP", "aln_code"] + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + fields, + [["q1", "s1", "4", "4M"]], + 1, + ) + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular query identifier must match header" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + ["query id", "subject id"], + [["other", "s1"]], + 1, + ) + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular subject identifier is required" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + ["query id", "evalue"], + [["q1", "0.1"]], + 1, + ) + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular query length must be stable in block" { + let text = align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + ["query id", "subject id", "query length"], + [["q1", "s1", "10"], ["q1", "s2", "11"]], + 2, + ) + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular FASTA query size must agree with row" { + let text = "# fasta36 -m 8CB q db\n" + + "# FASTA 36.3.8h\n" + + "# Query: q1 query - 10 aa\n" + + "# Database: db\n" + + "# Fields: query id, subject id, query length\n" + + "# 1 hits found\n" + + "q1\ts1\t11\n" + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular FASTA query size must be positive" { + let text = "# fasta36 -m 8CB q db\n" + + "# FASTA 36.3.8h\n" + + "# Query: q1 query - 0 aa\n" + + "# Database: db\n" + + "# 0 hits found\n" + assert_true(align_tabular_test_raises(text)) +} + +///| +test "Bio.Align.tabular BTOP rejects empty value" { + assert_true(align_tabular_test_btop_raises("")) +} + +///| +test "Bio.Align.tabular BTOP rejects zero match run" { + assert_true(align_tabular_test_btop_raises("0")) +} + +///| +test "Bio.Align.tabular BTOP rejects truncated pair" { + assert_true(align_tabular_test_btop_raises("2A")) +} + +///| +test "Bio.Align.tabular BTOP rejects invalid residue pair" { + assert_true(align_tabular_test_btop_raises("A?")) +} + +///| +test "Bio.Align.tabular BTOP rejects two gaps" { + assert_true(align_tabular_test_btop_raises("--")) +} + +///| +test "Bio.Align.tabular CIGAR rejects empty value" { + assert_true(align_tabular_test_cigar_raises("")) +} + +///| +test "Bio.Align.tabular CIGAR requires leading length" { + assert_true(align_tabular_test_cigar_raises("M3")) +} + +///| +test "Bio.Align.tabular CIGAR requires trailing operation" { + assert_true(align_tabular_test_cigar_raises("3")) +} + +///| +test "Bio.Align.tabular CIGAR rejects zero length" { + assert_true(align_tabular_test_cigar_raises("0M")) +} + +///| +test "Bio.Align.tabular CIGAR rejects unsupported operation" { + assert_true(align_tabular_test_cigar_raises("3S")) +} + +///| +test "Bio.Align.tabular relative path cannot convert to coordinate alignment" { + let alignment = (@src.align_tabular_parse( + align_tabular_test_block( + "BLASTP 2.14.1+", + "q1 query", + "db", + ["query id", "subject id", "alignment length", "BTOP"], + [["q1", "s1", "4", "4"]], + 1, + ), + ) catch { + _ => abort("relative path should parse") + }).queries[0].alignments[0] + let rejected = try { + ignore(alignment.coordinate_alignment()) + false + } catch { + AlignTabularError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.tabular E-value filter rejects negative threshold" { + let rejected = try { + ignore(align_tabular_test_document().queries[0].filter_evalue(-0.1)) + false + } catch { + AlignTabularError(_) => true + } + assert_true(rejected) +} From aca082329640cec8c3726168b2d400f232c6aac7 Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 13:05:21 +0800 Subject: [PATCH 27/41] #28 feat(nnsvg): Bioconductor nnSVG & kNN & NNGP & profile ML & SpatialExperiment & nnSVG --- README.md | 25 +- examples/nnsvg_demo/main.mbt | 99 +++ examples/nnsvg_demo/moon.pkg | 5 + src/nnsvg.mbt | 1498 ++++++++++++++++++++++++++++++++++ test/moonbit/nnsvg_test.mbt | 968 ++++++++++++++++++++++ 5 files changed, 2591 insertions(+), 4 deletions(-) create mode 100644 examples/nnsvg_demo/main.mbt create mode 100644 examples/nnsvg_demo/moon.pkg create mode 100644 src/nnsvg.mbt create mode 100644 test/moonbit/nnsvg_test.mbt diff --git a/README.md b/README.md index 67b24fb7..d982835c 100644 --- a/README.md +++ b/README.md @@ -211,6 +211,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **limma** | Bioconductor limma | 差异表达分析、线性模型拟合、经验贝叶斯、voom变换、RPKM/CPM/quantile归一化、ComBat/removeBatchEffect批次校正、treat严格检验 | ✅ | | **variancePartition** | Bioconductor variancePartition | 重复测量线性混合模型、方差分解、BLUP、precision weights、dream contrast与Satterthwaite检验 | ✅ | | **dreamlet** | Bioconductor dreamlet | sample×cell-type pseudobulk、TMM、cell/sample/gene过滤、logCPM、Poisson/voom precision weights、分cell-type重复测量模型及study-wide FDR | ✅ | +| **nnSVG** | Bioconductor nnSVG | nearest-neighbor Gaussian process、空间变异基因检验、gene-specific length scale、协变量设计、空间方差占比、BH-FDR及SpatialExperiment接入 | ✅ | | **ALDEx2** | Bioconductor ALDEx2 | Dirichlet Monte Carlo组成型差异丰度、六类denominator、Welch/Wilcoxon与配对检验、effect/overlap、Aitchison距离及SummarizedExperiment接入 | ✅ | | **DirichletMultinomial** | Bioconductor DirichletMultinomial | Dirichlet-multinomial概率、有限混合EM/BFGS聚类、Laplace/AIC/BIC选K、生成式分组分类、分层交叉验证、ROC及SummarizedExperiment接入 | ✅ | | **SummarizedExperiment** | Bioconductor SummarizedExperiment | 多维基因组数据容器、Assays、行/列操作 | ✅ | @@ -575,6 +576,7 @@ IvanAXu/BioSeqs/ │ ├── zinbwave.mbt # zinbwave 零膨胀NB低维模型 (EM/IRLS、latent factors、observational weights、SCE接入) │ ├── variance_partition.mbt # variancePartition 混合模型方差分解、BLUP与dream重复测量检验 │ ├── dreamlet.mbt # dreamlet pseudobulk、TMM/voom权重、分cell-type混合模型与study-wide FDR +│ ├── nnsvg.mbt # nnSVG nearest-neighbor GP、空间变异检验、length scale与SpatialExperiment接入 │ ├── monocle3.mbt # monocle3 单细胞轨迹分析 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read.mbt # ShortRead 短读序列质量控制 (QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告) │ ├── seq_quality_trim.mbt # NGS质量修剪与接头去除 (质量修剪、接头去除、poly-A修剪、长度/GC过滤、批量修剪) @@ -927,6 +929,7 @@ IvanAXu/BioSeqs/ │ ├── dirichlet_multinomial_demo/ # DMM聚类、选K、分组分类、交叉验证、ROC与SE接入示例 │ ├── variance_partition_demo/ # variancePartition 方差分解、BLUP、precision weights、dream与SE接入示例 │ ├── dreamlet_demo/ # dreamlet SCE pseudobulk、TMM/voom、donor随机截距与跨cell-type FDR示例 +│ ├── nnsvg_demo/ # nnSVG空间变异基因、length scale、过滤与SpatialExperiment接入示例 │ ├── monocle3_demo/ # monocle3 单细胞轨迹分析示例 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read_demo/ # ShortRead 短读序列质量控制示例 (QA统计、adapter修剪、质量修剪、FastQC报告) │ ├── scater_demo/ # scater 单细胞质量控制示例 (QC指标计算、细胞/基因过滤、标准化、HVG检测、PCA) @@ -1339,6 +1342,7 @@ IvanAXu/BioSeqs/ │ │ ├── dirichlet_multinomial_test.mbt │ │ ├── variance_partition_test.mbt │ │ ├── dreamlet_test.mbt +│ │ ├── nnsvg_test.mbt │ │ ├── shared_reference_alignment_test.mbt │ │ ├── alignment_map_test.mbt │ │ ├── alignment_counts_test.mbt @@ -1522,7 +1526,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 9401 个测试全部通过 +moon test # ✅ 9468 个测试全部通过 ``` ### 模块对照表 @@ -1631,6 +1635,7 @@ moon test # ✅ 9401 个测试全 | `limma.mbt` | Bioconductor limma | 线性模型与 voom 变换 | | `variance_partition.mbt` | Bioconductor variancePartition | 多随机截距LMM、ML/REML方差分量、固定/随机/残差占比、BLUP、precision weights、dream contrast、数值Satterthwaite与BH-FDR | | `dreamlet.mbt` | Bioconductor dreamlet | sample×cell-type pseudobulk、完整TMM、CPM/logCPM、Poisson/voom权重、typed fixed/random design、分cell-type dream拟合及两级BH-FDR | +| `nnsvg.mbt` | Bioconductor nnSVG | 坐标缩放与前驱kNN、指数协方差NNGP、协变量GLS、profile ML、空间/非空间LR检验、gene-specific length scale、BH-FDR及SpatialExperiment接入 | | `decontx.mbt` | Bioconductor decontX | cluster-native/contaminant多项式混合、Beta/Dirichlet先验EM、background、自动聚类、计数分解与SCE输出 | | `summarized_experiment.mbt` | Bioconductor SummarizedExperiment | 多维数据容器 | | `ranged_summarized_experiment.mbt` | Bioconductor RangedSummarizedExperiment | GRanges/GRangesList行范围、链特异重叠/最近邻、覆盖度、区间变换与协调子集 | @@ -1843,6 +1848,7 @@ moon test # ✅ 9401 个测试全 | `dirichlet_multinomial.mbt` | `DirichletMultinomial` | sample×taxon DMM概率、soft k-means初始化、log-alpha BFGS/EM、Gamma prior、Hessian区间、Laplace/AIC/BIC、dmngroup分类、分层CV、ROC与SummarizedExperiment入口 | | `variance_partition.mbt` | `variancePartition` | typed fixed/random design、多随机截距LMM、ML/REML方差分解、BLUP、weighted dream contrast、Satterthwaite自由度与SummarizedExperiment入口 | | `dreamlet.mbt` | `dreamlet` | SCE到sample×cluster pseudobulk、TMM/logCPM、两阶段voom precision weights、固定/随机效应筛选、逐cell-type dream和study-wide FDR | +| `nnsvg.mbt` | `nnSVG` | AMMD/坐标和排序前驱kNN、指数协方差NNGP、covariate GLS、空间方差比例与length scale优化、LR/p-value/BH-FDR、过滤和SpatialExperiment rowData输出 | | `shared_reference_alignment.mbt` | `Bio.Align.Alignment` | 同参考PWA/MSA的reference-boundary insertion同步、原query投影、局部坐标、metadata、统计与格式转换 | | `alignment_map.mbt` | `Bio.Align.Alignment.map/mapall` | 两层alignment坐标组合、正反链与gap传播、PSL、批量映射及protein/nucleotide MSA投影 | | `alignment_counts.mbt` | `Bio.Align.Alignment.counts` | pairwise/MSA gap事件和composition汇总、正反链、wildcard、替换矩阵及完整affine评分 | @@ -3024,6 +3030,14 @@ BTOP 和 FASTA CIGAR 会合并连续 operation 并重建显式 target/query coor 解析器严格诊断 header/字段重复或缺失、未知字段、列数、整数溢出、非法或非有限浮点、百分比和 E-value 范围、ID/长度冲突、坐标边界、traceback 截断与 operation、BTOP/CIGAR 同时出现、traceback span/序列消耗/alignment length 不一致，以及声明命中数和 processed query 数不匹配。当前范围聚焦文本解析和坐标重建，不执行 BLAST/FASTA 搜索，也不解析 XML、ASN.1 或普通无注释 outfmt 6 文档。 +### 262. 最近邻高斯过程空间变异基因检测 (Bioconductor nnSVG) + +实现 Bioconductor `nnSVG` 的可移植 spatially variable gene 检测核心，输入统一为 gene × spot 表达矩阵与 spot × dimension 空间坐标。坐标按各维最大 range 统一缩放，支持确定性的 approximate maximum-minimum-distance (AMMD) 和坐标和排序；每个 spot 只连接处理顺序中的前驱近邻。指数协方差 `R(i,j)=exp(-distance/length_scale)` 通过 NNGP 条件分解生成局部回归系数和条件方差，避免构造完整高斯过程精度矩阵。 + +每个基因拟合 `y=X beta+w+epsilon`，以 NNGP generalized least squares profile maximum likelihood 联合搜索 gene-specific spatial length scale 和 spatial variance proportion，并通过确定性局部细化优化。结果报告 `sigma_sq`、`tau_sq`、`phi=1/length_scale`、空间方差占比、回归系数及收敛状态；空间模型与非空间线性模型使用 likelihood-ratio statistic 比较，以 chi-square df=2 tail 计算 p-value，再执行 Benjamini-Hochberg FDR 和稳定排名。满秩协变量设计受到严格校验，常量或达到方差下限的基因显式回退到非空间模型。 + +`nnsvg_filter_genes` 实现按最小计数、表达 spot 百分比和 `MT-`/`mt-` 前缀过滤；`nnsvg_spatial_experiment` 从指定 assay 与空间坐标运行模型，在不可变 `SpatialExperiment` 副本的 rowData 中写入 13 项 nnSVG 统计和 metadata。API 另提供基因查询、top/significant 结果、摘要与示例数据。当前实现使用 dense 小型前驱协方差矩阵和确定性单线程网格优化，不依赖 BRISC、R、BiocParallel 或稀疏矩阵后端。 + ## 性能优化 ### 优化策略 @@ -3125,8 +3139,8 @@ BTOP 和 FASTA CIGAR 会合并连续 operation 并重建显式 target/query coor | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 9401 | -| 通过数 | 9401 | +| 总测试数 | 9468 | +| 通过数 | 9468 | | 失败数 | 0 | | 通过率 | 100% | @@ -3440,6 +3454,7 @@ moon test --update | Bio.SearchIO.InfernalIO | `infernal_io_test.mbt` | 37 | | Bioconductor variancePartition | `variance_partition_test.mbt` | 38 | | Bioconductor dreamlet | `dreamlet_test.mbt` | 58 | +| Bioconductor nnSVG | `nnsvg_test.mbt` | 67 | | Bio.PopGen.GenePop | `gene_pop_test.mbt` | 34 | | Bioconductor stageR | `stage_r_test.mbt` | 25 | | Bioconductor EnrichedHeatmap | `enriched_heatmap_test.mbt` | 20 | @@ -3535,7 +3550,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 369 个示例程序，展示各模块的典型用法： +项目提供 370 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3727,6 +3742,7 @@ moon run cmd/bench/main.mbt | infernal_io_demo | Infernal cmscan/cmsearch解析（tabular 3、non-verbose文本、local-end片段、过滤与SearchIO转换） | `moon run examples/infernal_io_demo` | | variance_partition_demo | typed固定/随机设计、ML方差分解、BLUP、precision weights、dream contrast与SummarizedExperiment接入 | `moon run examples/variance_partition_demo` | | dreamlet_demo | SingleCellExperiment pseudobulk、TMM/logCPM、Poisson/voom权重、donor随机截距和跨cell-type FDR | `moon run examples/dreamlet_demo` | +| nnsvg_demo | nearest-neighbor GP空间变异基因检验、length scale、空间方差占比、基因过滤与SpatialExperiment接入 | `moon run examples/nnsvg_demo` | | shared_reference_alignment_demo | 共享参考PWA/MSA合并、reference insertion同步、坐标映射、统计、MSA与aligned FASTA转换 | `moon run examples/shared_reference_alignment_demo` | | alignment_map_demo | chromosome→transcript→read坐标组合、intron gap、反链、坐标查询、PSL与protein-to-codon MSA投影 | `moon run examples/alignment_map_demo` | | alignment_counts_demo | left/internal/right gap与open/extend、affine/BLOSUM45评分、反向链和MSA逐对汇总 | `moon run examples/alignment_counts_demo` | @@ -3851,6 +3867,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bioconductor apeglm 自适应重尾效应量收缩（NB-GLM MLE、经验贝叶斯Cauchy/Student-t先验、多起点MAP、Laplace后验、FSR/FSOS/s-value与容器接入） - ✅ 实现 Bioconductor ALDEx2 组成型差异丰度（Dirichlet Monte Carlo、六类denominator、两组/配对检验、posterior expected BH、effect/overlap、距离与SummarizedExperiment接入） - ✅ 实现 Bioconductor DirichletMultinomial 混合聚类与分类（DMM概率、soft k-means、log-alpha BFGS/EM、Gamma prior、Laplace/AIC/BIC、dmngroup分类、分层CV、ROC与SummarizedExperiment接入） +- ✅ 实现 Bioconductor nnSVG 空间变异基因检测（坐标缩放与前驱kNN、指数协方差NNGP、covariate GLS、gene-specific length scale、空间/非空间LR检验、BH-FDR与SpatialExperiment接入） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/nnsvg_demo/main.mbt b/examples/nnsvg_demo/main.mbt new file mode 100644 index 00000000..9d33a1be --- /dev/null +++ b/examples/nnsvg_demo/main.mbt @@ -0,0 +1,99 @@ +// Bioconductor nnSVG-inspired spatially variable gene analysis. + +///| +fn main { + let (expression, coordinates, gene_names) = @src.nnsvg_example_data() + let config = @src.NnsvgConfig::create( + n_neighbors=4, + length_scale_grid=8, + proportion_grid=8, + refinement_steps=2, + fdr_threshold=0.1, + ) catch { + NnsvgError(message) => abort("invalid nnSVG configuration: " + message) + } + + let result = @src.nnsvg_with_config( + expression, + coordinates, + config, + gene_names~, + ) catch { + NnsvgError(message) => abort("nnSVG fit failed: " + message) + } + + println("=== Direct nnSVG analysis ===") + println(result.summary()) + println("rank\tgene\tLR\tp-value\tFDR\tprop_sv\tlength_scale") + for gene in result.top(result.n_genes()) { + println( + gene.rank.to_string() + + "\t" + + gene.gene_name + + "\t" + + gene.likelihood_ratio.to_string() + + "\t" + + gene.p_value.to_string() + + "\t" + + gene.adjusted_p_value.to_string() + + "\t" + + gene.proportion_spatial_variance.to_string() + + "\t" + + gene.length_scale.to_string(), + ) + } + + let counts = [ + [0.0, 0.0, 4.0, 5.0, 0.0, 0.0], + [8.0, 9.0, 7.0, 8.0, 9.0, 8.0], + [5.0, 5.0, 5.0, 5.0, 5.0, 5.0], + ] + let filter = @src.nnsvg_filter_genes( + counts, + ["low_expression", "spatial_candidate", "MT-ND1"], + minimum_count=3.0, + minimum_spot_percentage=50.0, + ) catch { + NnsvgError(message) => abort("nnSVG filtering failed: " + message) + } + println("\n=== Upstream-compatible gene filtering ===") + println( + "kept=" + + filter.kept_indices.length().to_string() + + ", low-expression=" + + filter.removed_low_expression.length().to_string() + + ", mitochondrial=" + + filter.removed_mitochondrial.length().to_string(), + ) + + let experiment = @src.SpatialExperiment::new() + ignore(@src.se_add_assay(experiment, "logcounts", expression)) + for gene_name in gene_names { + ignore(@src.se_add_row(experiment, Map([("gene_name", gene_name)]))) + } + for spot in 0.. + abort("nnSVG SpatialExperiment integration failed: " + message) + } + println("\n=== SpatialExperiment integration ===") + println( + "rowData fields written for " + + integrated.experiment.row_data.length().to_string() + + " genes; first-gene padj=" + + integrated.experiment.row_data[0]["nnsvg_padj"], + ) +} diff --git a/examples/nnsvg_demo/moon.pkg b/examples/nnsvg_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/nnsvg_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/nnsvg.mbt b/src/nnsvg.mbt new file mode 100644 index 00000000..b25547f9 --- /dev/null +++ b/src/nnsvg.mbt @@ -0,0 +1,1498 @@ +// Nearest-neighbor Gaussian-process detection of spatially variable genes. +// +// This module follows the statistical model and result conventions of the +// Bioconductor nnSVG package: +// y = X beta + w + epsilon +// cov(w_i, w_j) = sigma_sq * exp(-distance(i, j) / length_scale) +// epsilon ~ N(0, tau_sq I) +// +// The Gaussian-process likelihood is evaluated with a predecessor k-nearest +// neighbor (NNGP) factorization. Expression matrices use genes in rows and +// spatial spots in columns. + +///| +pub suberror NnsvgError { + NnsvgError(String) +} + +///| +pub enum NnsvgOrdering { + Ammd + SumCoordinates +} derive(Eq, Debug) + +///| +pub fn nnsvg_ammd_ordering() -> NnsvgOrdering { + Ammd +} + +///| +pub fn nnsvg_sum_coordinates_ordering() -> NnsvgOrdering { + SumCoordinates +} + +///| +pub struct NnsvgConfig { + n_neighbors : Int + ordering : NnsvgOrdering + length_scale_min : Double + length_scale_max : Double + length_scale_grid : Int + proportion_grid : Int + refinement_steps : Int + minimum_variance : Double + fdr_threshold : Double +} derive(Eq, Debug) + +///| +pub fn NnsvgConfig::create( + n_neighbors? : Int = 10, + ordering? : NnsvgOrdering = Ammd, + length_scale_min? : Double = 0.02, + length_scale_max? : Double = 2.0, + length_scale_grid? : Int = 10, + proportion_grid? : Int = 10, + refinement_steps? : Int = 2, + minimum_variance? : Double = 1.0e-10, + fdr_threshold? : Double = 0.05, +) -> NnsvgConfig raise NnsvgError { + if n_neighbors < 1 { + raise NnsvgError("nnSVG neighbor count must be positive") + } + if !nnsvg_is_finite(length_scale_min) || length_scale_min <= 0.0 { + raise NnsvgError("nnSVG minimum length scale must be finite and positive") + } + if !nnsvg_is_finite(length_scale_max) || length_scale_max <= length_scale_min { + raise NnsvgError( + "nnSVG maximum length scale must be finite and exceed the minimum", + ) + } + if length_scale_grid < 2 || proportion_grid < 2 { + raise NnsvgError("nnSVG parameter grids must contain at least two points") + } + if refinement_steps < 0 { + raise NnsvgError("nnSVG refinement step count must be non-negative") + } + if !nnsvg_is_finite(minimum_variance) || minimum_variance <= 0.0 { + raise NnsvgError("nnSVG minimum variance must be finite and positive") + } + if !nnsvg_is_finite(fdr_threshold) || + fdr_threshold <= 0.0 || + fdr_threshold > 1.0 { + raise NnsvgError("nnSVG FDR threshold must be finite and in (0, 1]") + } + NnsvgConfig::{ + n_neighbors, + ordering, + length_scale_min, + length_scale_max, + length_scale_grid, + proportion_grid, + refinement_steps, + minimum_variance, + fdr_threshold, + } +} + +///| +pub fn NnsvgConfig::default() -> NnsvgConfig { + NnsvgConfig::{ + n_neighbors: 10, + ordering: Ammd, + length_scale_min: 0.02, + length_scale_max: 2.0, + length_scale_grid: 10, + proportion_grid: 10, + refinement_steps: 2, + minimum_variance: 1.0e-10, + fdr_threshold: 0.05, + } +} + +///| +pub struct NnsvgNeighborGraph { + coordinates : Array[Array[Double]] + order : Array[Int] + inverse_order : Array[Int] + neighbors : Array[Array[Int]] + distances : Array[Array[Double]] + n_neighbors : Int + ordering : NnsvgOrdering + range_scale : Double +} derive(Debug) + +///| +pub struct NnsvgGeneResult { + gene_name : String + sigma_sq : Double + tau_sq : Double + phi : Double + length_scale : Double + log_likelihood : Double + mean : Double + variance : Double + spatial_covariance : Double + proportion_spatial_variance : Double + linear_log_likelihood : Double + likelihood_ratio : Double + rank : Double + p_value : Double + adjusted_p_value : Double + beta : Array[Double] + converged : Bool +} derive(Debug) + +///| +pub struct NnsvgResult { + gene_names : Array[String] + genes : Array[NnsvgGeneResult] + graph : NnsvgNeighborGraph + design_columns : Int + config : NnsvgConfig +} derive(Debug) + +///| +pub struct NnsvgFilterResult { + counts : Array[Array[Double]] + gene_names : Array[String] + kept_indices : Array[Int] + removed_low_expression : Array[Int] + removed_mitochondrial : Array[Int] +} derive(Debug) + +///| +pub struct NnsvgSpatialFilterOutput { + experiment : SpatialExperiment + filter : NnsvgFilterResult +} + +///| +pub struct NnsvgSpatialExperimentOutput { + experiment : SpatialExperiment + result : NnsvgResult +} + +///| +priv struct NnsvgConditionalSystem { + coefficients : Array[Array[Double]] + conditional_variances : Array[Double] +} + +///| +priv struct NnsvgProfileFit { + beta : Array[Double] + total_variance : Double + proportion_spatial_variance : Double + length_scale : Double + log_likelihood : Double +} + +///| +priv struct NnsvgRawGeneFit { + gene_name : String + sigma_sq : Double + tau_sq : Double + phi : Double + length_scale : Double + log_likelihood : Double + mean : Double + variance : Double + spatial_covariance : Double + proportion_spatial_variance : Double + linear_log_likelihood : Double + likelihood_ratio : Double + p_value : Double + beta : Array[Double] + converged : Bool +} + +///| +fn nnsvg_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn nnsvg_zero_matrix(rows : Int, columns : Int) -> Array[Array[Double]] { + let matrix : Array[Array[Double]] = [] + for _ in 0.. Array[Array[Double]] { + let copy : Array[Array[Double]] = [] + for row in matrix { + copy.push(row.copy()) + } + copy +} + +///| +fn nnsvg_distance( + coordinates : Array[Array[Double]], + first : Int, + second : Int, +) -> Double { + let mut squared = 0.0 + for dimension in 0.. (Int, Int) raise NnsvgError { + if expression.length() == 0 { + raise NnsvgError("nnSVG expression must contain at least one gene") + } + let spots = expression[0].length() + if spots < 3 { + raise NnsvgError("nnSVG expression must contain at least three spots") + } + for row in expression { + if row.length() != spots { + raise NnsvgError("nnSVG expression must be rectangular") + } + for value in row { + if !nnsvg_is_finite(value) { + raise NnsvgError("nnSVG expression must contain finite values") + } + } + } + (expression.length(), spots) +} + +///| +fn nnsvg_validate_coordinates( + coordinates : Array[Array[Double]], + expected_spots : Int, +) -> Int raise NnsvgError { + if coordinates.length() != expected_spots { + raise NnsvgError( + "nnSVG coordinate rows must match the number of expression spots", + ) + } + if coordinates.length() == 0 || coordinates[0].length() < 2 { + raise NnsvgError("nnSVG coordinates must contain at least two dimensions") + } + let dimensions = coordinates[0].length() + for row in coordinates { + if row.length() != dimensions { + raise NnsvgError("nnSVG coordinates must be rectangular") + } + for value in row { + if !nnsvg_is_finite(value) { + raise NnsvgError("nnSVG coordinates must contain finite values") + } + } + } + dimensions +} + +///| +fn nnsvg_prepare_gene_names( + gene_names : Array[String], + genes : Int, +) -> Array[String] raise NnsvgError { + if gene_names.length() == 0 { + let generated : Array[String] = [] + for index in 0.. Array[Array[Double]]? { + let size = matrix.length() + if size == 0 { + return None + } + let lower = nnsvg_zero_matrix(size, size) + for row in 0.. Array[Double] { + let size = lower.length() + let forward = Array::make(size, 0.0) + for row in 0..= 0 { + let mut value = forward[row] + for column in (row + 1).. Array[Array[Double]] raise NnsvgError { + if design.length() == 0 { + let intercept : Array[Array[Double]] = [] + for _ in 0..= spots { + raise NnsvgError("nnSVG design must have fewer columns than spatial spots") + } + let prepared : Array[Array[Double]] = [] + for row in design { + if row.length() != columns { + raise NnsvgError("nnSVG design must be rectangular") + } + let copied = row.copy() + for value in copied { + if !nnsvg_is_finite(value) { + raise NnsvgError("nnSVG design must contain finite values") + } + } + prepared.push(copied) + } + let information = nnsvg_zero_matrix(columns, columns) + for row in prepared { + for first in 0.. prepared + None => raise NnsvgError("nnSVG design matrix must have full column rank") + } +} + +///| +fn nnsvg_scale_coordinates( + coordinates : Array[Array[Double]], +) -> (Array[Array[Double]], Double) raise NnsvgError { + let dimensions = coordinates[0].length() + let minima = coordinates[0].copy() + let maxima = coordinates[0].copy() + for row in 1.. Array[Int] { + let order : Array[Int] = [] + for index in 0.. Int { + let mut left_sum = 0.0 + let mut right_sum = 0.0 + for dimension in 0.. right_sum { + 1 + } else { + left - right + } + }) + order +} + +///| +fn nnsvg_ammd_order(coordinates : Array[Array[Double]]) -> Array[Int] { + let spots = coordinates.length() + let order : Array[Int] = [] + let selected = Array::make(spots, false) + let minimum_distances = Array::make(spots, 1.0e300) + let sum_order = nnsvg_sum_coordinate_order(coordinates) + let first = sum_order[0] + order.push(first) + selected[first] = true + for index in 0.. best_distance + 1.0e-14 || + ( + (minimum_distances[candidate] - best_distance).abs() <= 1.0e-14 && + (best < 0 || candidate < best) + ) + ) { + best = candidate + best_distance = minimum_distances[candidate] + } + } + order.push(best) + selected[best] = true + for candidate in 0.. NnsvgNeighborGraph raise NnsvgError { + if n_neighbors < 1 { + raise NnsvgError("nnSVG neighbor count must be positive") + } + if coordinates.length() < 3 { + raise NnsvgError("nnSVG coordinates must contain at least three spots") + } + ignore(nnsvg_validate_coordinates(coordinates, coordinates.length())) + let (scaled, range_scale) = nnsvg_scale_coordinates(coordinates) + let order = match ordering { + Ammd => nnsvg_ammd_order(scaled) + SumCoordinates => nnsvg_sum_coordinate_order(scaled) + } + let spots = scaled.length() + let inverse_order = Array::make(spots, 0) + for position in 0.. Int { + if left.0 < right.0 { + -1 + } else if left.0 > right.0 { + 1 + } else { + inverse_order[left.1] - inverse_order[right.1] + } + }) + let count = retained_neighbors.min(candidates.length()) + for index in 0.. NnsvgConditionalSystem? { + let spots = graph.coordinates.length() + let coefficients : Array[Array[Double]] = [] + for _ in 0.. 0 { + if proportion <= 0.0 { + coefficients[original] = Array::make(local_neighbors.length(), 0.0) + } else { + let covariance = nnsvg_zero_matrix( + local_neighbors.length(), + local_neighbors.length(), + ) + let cross_covariance = Array::make(local_neighbors.length(), 0.0) + for first in 0.. value + None => return None + } + let local_coefficients = nnsvg_cholesky_solve(lower, cross_covariance) + let mut reduction = 0.0 + for index in 0.. NnsvgProfileFit? { + let system = match + nnsvg_conditional_system(graph, proportion, length_scale, minimum_variance) { + Some(value) => value + None => return None + } + let columns = design[0].length() + let information = nnsvg_zero_matrix(columns, columns) + let score = Array::make(columns, 0.0) + let transformed_response = Array::make(values.length(), 0.0) + let transformed_design = nnsvg_zero_matrix(values.length(), columns) + let mut log_determinant = 0.0 + for position in 0.. value + None => return None + } + let beta = nnsvg_cholesky_solve(lower, score) + let mut residual_sum = 0.0 + for position in 0.. NnsvgProfileFit? { + match candidate { + None => best + Some(value) => + match best { + None => Some(value) + Some(current) => + if value.log_likelihood > current.log_likelihood { + Some(value) + } else { + Some(current) + } + } + } +} + +///| +fn nnsvg_optimize_spatial( + values : Array[Double], + design : Array[Array[Double]], + graph : NnsvgNeighborGraph, + config : NnsvgConfig, +) -> (NnsvgProfileFit, NnsvgProfileFit, Bool) raise NnsvgError { + let linear = match + nnsvg_profile_likelihood( + values, + design, + graph, + 0.0, + config.length_scale_min, + config.minimum_variance, + ) { + Some(value) => value + None => raise NnsvgError("nnSVG could not fit the non-spatial model") + } + if linear.total_variance <= config.minimum_variance * 1.000001 { + return (linear, linear, true) + } + let log_minimum = @math.ln(config.length_scale_min) + let log_maximum = @math.ln(config.length_scale_max) + let mut best : NnsvgProfileFit? = None + for length_index in 0.. value + None => return (linear, linear, false) + } + let mut refined = initial + let mut log_step = (log_maximum - log_minimum) / + (config.length_scale_grid - 1).to_double() + let mut proportion_step = 0.98 / (config.proportion_grid - 1).to_double() + for _ in 0.. refined = value + None => () + } + } + let selected = if refined.log_likelihood > linear.log_likelihood + 1.0e-10 { + refined + } else { + linear + } + (selected, linear, true) +} + +///| +fn nnsvg_mean(values : Array[Double]) -> Double { + let mut total = 0.0 + for value in values { + total = total + value + } + total / values.length().to_double() +} + +///| +fn nnsvg_variance(values : Array[Double], mean : Double) -> Double { + let mut total = 0.0 + for value in values { + let difference = value - mean + total = total + difference * difference + } + total / (values.length() - 1).to_double() +} + +///| +fn nnsvg_bh_adjust(p_values : Array[Double]) -> Array[Double] { + let count = p_values.length() + let order : Array[Int] = [] + for index in 0.. Int { + if p_values[left] < p_values[right] { + -1 + } else if p_values[left] > p_values[right] { + 1 + } else { + left - right + } + }) + let adjusted = Array::make(count, 1.0) + let mut running = 1.0 + let mut rank = count + while rank > 0 { + let original = order[rank - 1] + let candidate = (p_values[original] * count.to_double() / rank.to_double()).min( + 1.0, + ) + running = running.min(candidate) + adjusted[original] = running.max(p_values[original]) + rank = rank - 1 + } + adjusted +} + +///| +fn nnsvg_likelihood_ranks(likelihood_ratios : Array[Double]) -> Array[Double] { + let count = likelihood_ratios.length() + let order : Array[Int] = [] + for index in 0.. Int { + if likelihood_ratios[left] > likelihood_ratios[right] { + -1 + } else if likelihood_ratios[left] < likelihood_ratios[right] { + 1 + } else { + left - right + } + }) + let ranks = Array::make(count, 0.0) + let mut start = 0 + while start < count { + let mut end = start + 1 + while end < count && + (likelihood_ratios[order[end]] - likelihood_ratios[order[start]]).abs() <= + 1.0e-12 { + end = end + 1 + } + let average_rank = ((start + 1).to_double() + end.to_double()) / 2.0 + for position in start.. NnsvgResult raise NnsvgError { + let (gene_count, spot_count) = nnsvg_validate_expression(expression) + ignore(nnsvg_validate_coordinates(coordinates, spot_count)) + let prepared_names = nnsvg_prepare_gene_names(gene_names, gene_count) + let prepared_design = nnsvg_prepare_design(design, spot_count) + let graph = nnsvg_build_neighbors( + coordinates, + n_neighbors=config.n_neighbors, + ordering=config.ordering, + ) + let raw_results : Array[NnsvgRawGeneFit] = [] + let p_values = Array::make(gene_count, 1.0) + let likelihood_ratios = Array::make(gene_count, 0.0) + for gene in 0.. NnsvgResult raise NnsvgError { + let config = NnsvgConfig::create(n_neighbors~) + nnsvg_with_config(expression, coordinates, config, design~, gene_names~) +} + +///| +pub fn NnsvgResult::n_genes(self : NnsvgResult) -> Int { + self.genes.length() +} + +///| +pub fn NnsvgResult::n_spots(self : NnsvgResult) -> Int { + self.graph.coordinates.length() +} + +///| +pub fn NnsvgResult::gene( + self : NnsvgResult, + gene_name : String, +) -> NnsvgGeneResult? { + for gene in self.genes { + if gene.gene_name == gene_name { + return Some(gene) + } + } + None +} + +///| +pub fn NnsvgResult::significant( + self : NnsvgResult, + threshold? : Double = -1.0, +) -> Array[NnsvgGeneResult] { + let selected_threshold = if threshold < 0.0 { + self.config.fdr_threshold + } else { + threshold + } + let selected : Array[NnsvgGeneResult] = [] + for gene in self.genes { + if gene.adjusted_p_value <= selected_threshold { + selected.push(gene) + } + } + selected.sort_by(fn(left : NnsvgGeneResult, right : NnsvgGeneResult) -> Int { + if left.rank < right.rank { + -1 + } else if left.rank > right.rank { + 1 + } else { + 0 + } + }) + selected +} + +///| +pub fn NnsvgResult::top( + self : NnsvgResult, + count : Int, +) -> Array[NnsvgGeneResult] { + if count <= 0 { + return [] + } + let sorted = self.genes.copy() + sorted.sort_by(fn(left : NnsvgGeneResult, right : NnsvgGeneResult) -> Int { + if left.rank < right.rank { + -1 + } else if left.rank > right.rank { + 1 + } else { + 0 + } + }) + let output : Array[NnsvgGeneResult] = [] + for index in 0.. String { + "nnSVG(" + + self.n_genes().to_string() + + " genes x " + + self.n_spots().to_string() + + " spots, neighbors=" + + self.graph.n_neighbors.to_string() + + ", significant=" + + self.significant().length().to_string() + + ", FDR=" + + self.config.fdr_threshold.to_string() + + ")" +} + +///| +pub fn nnsvg_filter_genes( + counts : Array[Array[Double]], + gene_names : Array[String], + minimum_count? : Double = 3.0, + minimum_spot_percentage? : Double = 0.5, + filter_mitochondrial? : Bool = true, +) -> NnsvgFilterResult raise NnsvgError { + if counts.length() == 0 || counts[0].length() == 0 { + raise NnsvgError("nnSVG gene filtering requires a non-empty count matrix") + } + if gene_names.length() != counts.length() { + raise NnsvgError( + "nnSVG filtering gene names must match the count matrix rows", + ) + } + if !nnsvg_is_finite(minimum_count) || minimum_count < 0.0 { + raise NnsvgError( + "nnSVG filtering minimum count must be finite and non-negative", + ) + } + if !nnsvg_is_finite(minimum_spot_percentage) || + minimum_spot_percentage < 0.0 || + minimum_spot_percentage > 100.0 { + raise NnsvgError( + "nnSVG filtering spot percentage must be finite and in [0, 100]", + ) + } + let spots = counts[0].length() + let required_spots = (minimum_spot_percentage / 100.0 * spots.to_double()) + .ceil() + .to_int() + let filtered_counts : Array[Array[Double]] = [] + let filtered_names : Array[String] = [] + let kept_indices : Array[Int] = [] + let removed_low_expression : Array[Int] = [] + let removed_mitochondrial : Array[Int] = [] + for gene in 0..= minimum_count { + detected = detected + 1 + } + } + let low_expression = detected < required_spots + let mitochondrial = filter_mitochondrial && + ( + gene_names[gene].starts_with("MT-") || + gene_names[gene].starts_with("mt-") + ) + if low_expression { + removed_low_expression.push(gene) + } + if mitochondrial { + removed_mitochondrial.push(gene) + } + if !low_expression && !mitochondrial { + kept_indices.push(gene) + filtered_counts.push(counts[gene].copy()) + filtered_names.push(gene_names[gene]) + } + } + NnsvgFilterResult::{ + counts: filtered_counts, + gene_names: filtered_names, + kept_indices, + removed_low_expression, + removed_mitochondrial, + } +} + +///| +fn nnsvg_copy_string_map(source : Map[String, String]) -> Map[String, String] { + let copy : Map[String, String] = Map([]) + for key in source.keys() { + copy[key] = source[key] + } + copy +} + +///| +fn nnsvg_copy_spatial_experiment( + experiment : SpatialExperiment, +) -> SpatialExperiment { + let copy = SpatialExperiment::new() + for key in experiment.assay.keys() { + copy.assay[key] = nnsvg_copy_matrix(experiment.assay[key]) + } + for row in experiment.row_data { + copy.row_data.push(nnsvg_copy_string_map(row)) + } + for column in experiment.col_data { + copy.col_data.push(nnsvg_copy_string_map(column)) + } + for coordinate in experiment.spatial_coords { + copy.spatial_coords.push(coordinate) + } + for image in experiment.images { + copy.images.push(image) + } + for key in experiment.metadata.keys() { + copy.metadata[key] = experiment.metadata[key] + } + copy +} + +///| +fn nnsvg_spatial_gene_names( + experiment : SpatialExperiment, + genes : Int, +) -> Array[String] raise NnsvgError { + if experiment.row_data.length() != 0 && experiment.row_data.length() != genes { + raise NnsvgError( + "nnSVG SpatialExperiment rowData must match the assay rows", + ) + } + let names : Array[String] = [] + for gene in 0.. + if value.length() == 0 { + match row.get("gene_id") { + Some(identifier) => + if identifier.length() == 0 { + generated + } else { + identifier + } + None => generated + } + } else { + value + } + None => + match row.get("gene_id") { + Some(identifier) => + if identifier.length() == 0 { + generated + } else { + identifier + } + None => generated + } + } + names.push(name) + } + } + names +} + +///| +fn nnsvg_spatial_coordinates( + experiment : SpatialExperiment, +) -> Array[Array[Double]] { + let coordinates : Array[Array[Double]] = [] + let mut has_z_variation = false + if experiment.spatial_coords.length() > 0 { + let first_z = experiment.spatial_coords[0].z + for coordinate in experiment.spatial_coords { + if (coordinate.z - first_z).abs() > 1.0e-14 { + has_z_variation = true + } + } + } + for coordinate in experiment.spatial_coords { + if has_z_variation { + coordinates.push([coordinate.x, coordinate.y, coordinate.z]) + } else { + coordinates.push([coordinate.x, coordinate.y]) + } + } + coordinates +} + +///| +pub fn nnsvg_filter_spatial_experiment( + experiment : SpatialExperiment, + count_assay? : String = "counts", + minimum_count? : Double = 3.0, + minimum_spot_percentage? : Double = 0.5, + filter_mitochondrial? : Bool = true, +) -> NnsvgSpatialFilterOutput raise NnsvgError { + let counts = match experiment.assay.get(count_assay) { + Some(value) => value + None => + raise NnsvgError( + "nnSVG SpatialExperiment assay not found: " + count_assay, + ) + } + if counts.length() == 0 { + raise NnsvgError("nnSVG SpatialExperiment count assay is empty") + } + let gene_names = nnsvg_spatial_gene_names(experiment, counts.length()) + let filter = nnsvg_filter_genes( + counts, + gene_names, + minimum_count~, + minimum_spot_percentage~, + filter_mitochondrial~, + ) + let filtered = SpatialExperiment::new() + for assay_name in experiment.assay.keys() { + let source = experiment.assay[assay_name] + if source.length() != counts.length() { + raise NnsvgError( + "nnSVG SpatialExperiment assays must share the same gene rows", + ) + } + let subset : Array[Array[Double]] = [] + for index in filter.kept_indices { + subset.push(source[index].copy()) + } + filtered.assay[assay_name] = subset + } + for index in filter.kept_indices { + if experiment.row_data.length() == 0 { + filtered.row_data.push(Map([("gene_name", gene_names[index])])) + } else { + filtered.row_data.push(nnsvg_copy_string_map(experiment.row_data[index])) + } + } + for column in experiment.col_data { + filtered.col_data.push(nnsvg_copy_string_map(column)) + } + for coordinate in experiment.spatial_coords { + filtered.spatial_coords.push(coordinate) + } + for image in experiment.images { + filtered.images.push(image) + } + for key in experiment.metadata.keys() { + filtered.metadata[key] = experiment.metadata[key] + } + filtered.metadata["nnsvg_filter_kept"] = filter.kept_indices + .length() + .to_string() + filtered.metadata["nnsvg_filter_removed"] = (counts.length() - + filter.kept_indices.length()).to_string() + NnsvgSpatialFilterOutput::{ experiment: filtered, filter } +} + +///| +pub fn nnsvg_spatial_experiment( + experiment : SpatialExperiment, + assay_name? : String = "logcounts", + config? : NnsvgConfig = NnsvgConfig::default(), + design? : Array[Array[Double]] = [], +) -> NnsvgSpatialExperimentOutput raise NnsvgError { + let expression = match experiment.assay.get(assay_name) { + Some(value) => value + None => + raise NnsvgError("nnSVG SpatialExperiment assay not found: " + assay_name) + } + if expression.length() == 0 { + raise NnsvgError("nnSVG SpatialExperiment assay is empty") + } + let gene_names = nnsvg_spatial_gene_names(experiment, expression.length()) + let coordinates = nnsvg_spatial_coordinates(experiment) + let result = nnsvg_with_config( + expression, + coordinates, + config, + design~, + gene_names~, + ) + let enriched = nnsvg_copy_spatial_experiment(experiment) + if enriched.row_data.length() == 0 { + for gene_name in gene_names { + enriched.row_data.push(Map([("gene_name", gene_name)])) + } + } + for index in 0.. ( + Array[Array[Double]], + Array[Array[Double]], + Array[String], +) { + let coordinates = [ + [0.0, 0.0], + [1.0, 0.0], + [2.0, 0.0], + [3.0, 0.0], + [0.0, 1.0], + [1.0, 1.0], + [2.0, 1.0], + [3.0, 1.0], + [0.0, 2.0], + [1.0, 2.0], + [2.0, 2.0], + [3.0, 2.0], + ] + let expression = [ + [0.0, 0.5, 1.0, 1.5, 0.5, 1.0, 1.5, 2.0, 1.0, 1.5, 2.0, 2.5], + [2.5, 2.0, 1.5, 1.0, 2.0, 1.5, 1.0, 0.5, 1.5, 1.0, 0.5, 0.0], + [1.0, 2.0, 1.0, 2.0, 2.0, 1.0, 2.0, 1.0, 1.0, 2.0, 1.0, 2.0], + [3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0, 3.0], + ] + let gene_names = [ + "x_y_gradient", "reverse_gradient", "checkerboard", "constant", + ] + (expression, coordinates, gene_names) +} diff --git a/test/moonbit/nnsvg_test.mbt b/test/moonbit/nnsvg_test.mbt new file mode 100644 index 00000000..d6155bda --- /dev/null +++ b/test/moonbit/nnsvg_test.mbt @@ -0,0 +1,968 @@ +// Tests for the Bioconductor nnSVG-inspired NNGP spatial model. + +///| +fn nnsvg_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "nnSVG value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn nnsvg_test_config() -> @src.NnsvgConfig { + @src.NnsvgConfig::create( + n_neighbors=3, + length_scale_min=0.03, + length_scale_max=1.5, + length_scale_grid=5, + proportion_grid=5, + refinement_steps=1, + minimum_variance=1.0e-9, + fdr_threshold=0.1, + ) catch { + _ => abort("nnSVG test configuration should be valid") + } +} + +///| +fn nnsvg_test_result() -> @src.NnsvgResult { + let (expression, coordinates, gene_names) = @src.nnsvg_example_data() + @src.nnsvg_with_config( + expression, + coordinates, + nnsvg_test_config(), + gene_names~, + ) catch { + _ => abort("nnSVG example fit should succeed") + } +} + +///| +fn nnsvg_test_spatial_experiment() -> @src.SpatialExperiment { + let (expression, coordinates, gene_names) = @src.nnsvg_example_data() + let experiment = @src.SpatialExperiment::new() + ignore(@src.se_add_assay(experiment, "logcounts", expression)) + let counts : Array[Array[Double]] = [] + for row in expression { + let count_row : Array[Double] = [] + for value in row { + count_row.push((value * 4.0).round()) + } + counts.push(count_row) + } + ignore(@src.se_add_assay(experiment, "counts", counts)) + for gene_name in gene_names { + ignore(@src.se_add_row(experiment, Map([("gene_name", gene_name)]))) + } + for spot in 0.. abort("custom nnSVG configuration should be valid") + } + assert_eq(config.n_neighbors, 4) + assert_true(config.ordering is @src.NnsvgOrdering::SumCoordinates) + assert_eq(config.length_scale_grid, 7) + assert_eq(config.proportion_grid, 8) + assert_eq(config.refinement_steps, 3) + assert_eq(config.minimum_variance, 1.0e-8) +} + +///| +test "nnSVG: ordering helpers expose both ordering modes" { + assert_true(@src.nnsvg_ammd_ordering() is @src.NnsvgOrdering::Ammd) + assert_true( + @src.nnsvg_sum_coordinates_ordering() is @src.NnsvgOrdering::SumCoordinates, + ) +} + +///| +test "nnSVG: configuration rejects non-positive neighbor count" { + let failed = try { + ignore(@src.NnsvgConfig::create(n_neighbors=0)) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: configuration rejects non-positive minimum length scale" { + let failed = try { + ignore(@src.NnsvgConfig::create(length_scale_min=0.0)) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: configuration rejects reversed length-scale bounds" { + let failed = try { + ignore(@src.NnsvgConfig::create(length_scale_min=2.0, length_scale_max=1.0)) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: configuration rejects undersized parameter grids" { + let length_grid = try { + ignore(@src.NnsvgConfig::create(length_scale_grid=1)) + false + } catch { + NnsvgError(_) => true + } + let proportion_grid = try { + ignore(@src.NnsvgConfig::create(proportion_grid=1)) + false + } catch { + NnsvgError(_) => true + } + assert_true(length_grid) + assert_true(proportion_grid) +} + +///| +test "nnSVG: configuration rejects negative refinement count" { + let failed = try { + ignore(@src.NnsvgConfig::create(refinement_steps=-1)) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: configuration rejects invalid variance floor" { + let failed = try { + ignore(@src.NnsvgConfig::create(minimum_variance=0.0)) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: configuration rejects invalid FDR threshold" { + let zero = try { + ignore(@src.NnsvgConfig::create(fdr_threshold=0.0)) + false + } catch { + NnsvgError(_) => true + } + let large = try { + ignore(@src.NnsvgConfig::create(fdr_threshold=1.1)) + false + } catch { + NnsvgError(_) => true + } + assert_true(zero) + assert_true(large) +} + +///| +test "nnSVG: example data uses gene by spot orientation" { + let (expression, coordinates, gene_names) = @src.nnsvg_example_data() + assert_eq(expression.length(), 4) + assert_eq(expression[0].length(), 12) + assert_eq(coordinates.length(), 12) + assert_eq(coordinates[0].length(), 2) + assert_eq(gene_names.length(), 4) +} + +///| +test "nnSVG: neighbor graph scales coordinates by global range" { + let (_, coordinates, _) = @src.nnsvg_example_data() + let graph = @src.nnsvg_build_neighbors(coordinates, n_neighbors=3) catch { + _ => abort("neighbor graph should build") + } + nnsvg_test_close(graph.range_scale, 3.0, 1.0e-12) + nnsvg_test_close(graph.coordinates[3][0], 1.0, 1.0e-12) + nnsvg_test_close(graph.coordinates[4][1], 1.0 / 3.0, 1.0e-12) +} + +///| +test "nnSVG: sum-coordinate ordering is deterministic" { + let (_, coordinates, _) = @src.nnsvg_example_data() + let graph = @src.nnsvg_build_neighbors( + coordinates, + n_neighbors=2, + ordering=@src.nnsvg_sum_coordinates_ordering(), + ) catch { + _ => abort("sum-coordinate graph should build") + } + assert_eq(graph.order[0], 0) + assert_eq(graph.order[1], 1) + assert_eq(graph.order[2], 4) + assert_eq(graph.order.length(), coordinates.length()) +} + +///| +test "nnSVG: AMMD ordering is a full permutation" { + let (_, coordinates, _) = @src.nnsvg_example_data() + let graph = @src.nnsvg_build_neighbors(coordinates, n_neighbors=3) catch { + _ => abort("AMMD graph should build") + } + let seen = Array::make(coordinates.length(), false) + for index in graph.order { + assert_true(index >= 0 && index < coordinates.length()) + assert_false(seen[index]) + seen[index] = true + } + for value in seen { + assert_true(value) + } +} + +///| +test "nnSVG: AMMD ordering is reproducible" { + let (_, coordinates, _) = @src.nnsvg_example_data() + let first = @src.nnsvg_build_neighbors(coordinates, n_neighbors=3) catch { + _ => abort("first graph should build") + } + let second = @src.nnsvg_build_neighbors(coordinates, n_neighbors=3) catch { + _ => abort("second graph should build") + } + assert_eq(first.order, second.order) + assert_eq(first.neighbors, second.neighbors) +} + +///| +test "nnSVG: inverse ordering maps originals to processing positions" { + let (_, coordinates, _) = @src.nnsvg_example_data() + let graph = @src.nnsvg_build_neighbors(coordinates) catch { + _ => abort("graph should build") + } + for position in 0.. abort("graph should build") + } + for original in 0.. abort("graph should build") + } + assert_eq(graph.n_neighbors, coordinates.length() - 1) + for original in 0.. abort("graph should build") + } + for original in 0..= graph.distances[original][index - 1], + ) + } + } +} + +///| +test "nnSVG: duplicate coordinates remain valid with a nugget" { + let coordinates = [[0.0, 0.0], [0.0, 0.0], [1.0, 0.0], [1.0, 1.0]] + let graph = @src.nnsvg_build_neighbors(coordinates, n_neighbors=2) catch { + _ => abort("duplicate-coordinate graph should build") + } + assert_eq(graph.order.length(), 4) + assert_eq(graph.neighbors.length(), 4) +} + +///| +test "nnSVG: neighbor graph rejects too few spots" { + let failed = try { + ignore(@src.nnsvg_build_neighbors([[0.0, 0.0], [1.0, 1.0]])) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: neighbor graph rejects one-dimensional coordinates" { + let failed = try { + ignore(@src.nnsvg_build_neighbors([[0.0], [1.0], [2.0]])) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: neighbor graph rejects ragged coordinates" { + let failed = try { + ignore(@src.nnsvg_build_neighbors([[0.0, 0.0], [1.0], [2.0, 0.0]])) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: neighbor graph rejects non-finite coordinates" { + let failed = try { + ignore(@src.nnsvg_build_neighbors([[0.0, 0.0], [1.0e301, 1.0], [2.0, 0.0]])) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: neighbor graph rejects invariant coordinates" { + let failed = try { + ignore(@src.nnsvg_build_neighbors([[1.0, 1.0], [1.0, 1.0], [1.0, 1.0]])) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: fit dimensions and names match input" { + let result = nnsvg_test_result() + assert_eq(result.n_genes(), 4) + assert_eq(result.n_spots(), 12) + assert_eq(result.gene_names[0], "x_y_gradient") + assert_eq(result.genes[3].gene_name, "constant") + assert_eq(result.design_columns, 1) +} + +///| +test "nnSVG: default function generates gene names" { + let (expression, coordinates, _) = @src.nnsvg_example_data() + let result = @src.nnsvg(expression, coordinates, n_neighbors=3) catch { + _ => abort("default nnSVG fit should succeed") + } + assert_eq(result.gene_names[0], "gene_1") + assert_eq(result.gene_names[3], "gene_4") +} + +///| +test "nnSVG: custom design coefficients are retained" { + let (expression, coordinates, gene_names) = @src.nnsvg_example_data() + let design : Array[Array[Double]] = [] + for coordinate in coordinates { + design.push([1.0, coordinate[0]]) + } + let result = @src.nnsvg_with_config( + expression, + coordinates, + nnsvg_test_config(), + design~, + gene_names~, + ) catch { + _ => abort("covariate-adjusted nnSVG fit should succeed") + } + assert_eq(result.design_columns, 2) + for gene in result.genes { + assert_eq(gene.beta.length(), 2) + } +} + +///| +test "nnSVG: likelihood-ratio identity holds" { + let result = nnsvg_test_result() + for gene in result.genes { + nnsvg_test_close( + gene.likelihood_ratio, + 2.0 * (gene.log_likelihood - gene.linear_log_likelihood), + 1.0e-8, + ) + } +} + +///| +test "nnSVG: p-values use the two-degree chi-square tail" { + let result = nnsvg_test_result() + for gene in result.genes { + nnsvg_test_close( + gene.p_value, + @math.exp(-0.5 * gene.likelihood_ratio), + 1.0e-12, + ) + } +} + +///| +test "nnSVG: variance components reconstruct total fitted variance" { + let result = nnsvg_test_result() + for gene in result.genes { + let total = gene.sigma_sq + gene.tau_sq + assert_true(total > 0.0) + nnsvg_test_close( + gene.proportion_spatial_variance, + gene.sigma_sq / total, + 1.0e-10, + ) + } +} + +///| +test "nnSVG: positive spatial fits report reciprocal phi" { + let result = nnsvg_test_result() + for gene in result.genes { + if gene.length_scale > 0.0 { + nnsvg_test_close(gene.phi, 1.0 / gene.length_scale, 1.0e-10) + } else { + assert_eq(gene.phi, 0.0) + } + } +} + +///| +test "nnSVG: adjusted p-values are bounded and not below raw values" { + let result = nnsvg_test_result() + for gene in result.genes { + assert_true(gene.p_value >= 0.0 && gene.p_value <= 1.0) + assert_true( + gene.adjusted_p_value >= gene.p_value - 1.0e-12 && + gene.adjusted_p_value <= 1.0, + ) + } +} + +///| +test "nnSVG: constant gene falls back to non-spatial model" { + let result = nnsvg_test_result() + let constant = result.genes[3] + nnsvg_test_close(constant.likelihood_ratio, 0.0, 1.0e-12) + nnsvg_test_close(constant.p_value, 1.0, 1.0e-12) + nnsvg_test_close(constant.sigma_sq, 0.0, 1.0e-12) + assert_eq(constant.length_scale, 0.0) +} + +///| +test "nnSVG: spatial gradients outrank constant expression" { + let result = nnsvg_test_result() + assert_true(result.genes[0].rank < result.genes[3].rank) + assert_true(result.genes[1].rank < result.genes[3].rank) + assert_true( + result.genes[0].likelihood_ratio > result.genes[3].likelihood_ratio, + ) +} + +///| +test "nnSVG: gene lookup finds names and rejects unknown names" { + let result = nnsvg_test_result() + let found = match result.gene("checkerboard") { + Some(value) => value + None => abort("known gene should be found") + } + assert_eq(found.gene_name, "checkerboard") + assert_true(result.gene("missing") is None) +} + +///| +test "nnSVG: top results are ordered by rank" { + let top = nnsvg_test_result().top(3) + assert_eq(top.length(), 3) + assert_true(top[0].rank <= top[1].rank) + assert_true(top[1].rank <= top[2].rank) +} + +///| +test "nnSVG: top handles zero and oversized requests" { + let result = nnsvg_test_result() + assert_eq(result.top(0).length(), 0) + assert_eq(result.top(100).length(), result.n_genes()) +} + +///| +test "nnSVG: significant supports an explicit threshold" { + let result = nnsvg_test_result() + let all = result.significant(threshold=1.0) + let none = result.significant(threshold=0.0) + assert_eq(all.length(), result.n_genes()) + assert_eq(none.length(), 0) +} + +///| +test "nnSVG: summary reports dimensions and neighbor count" { + let summary = nnsvg_test_result().summary() + assert_true(summary.contains("4 genes x 12 spots")) + assert_true(summary.contains("neighbors=3")) + assert_true(summary.contains("FDR=0.1")) +} + +///| +test "nnSVG: fit rejects empty expression" { + let failed = try { + ignore(@src.nnsvg([], [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0]])) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: fit rejects too few spots" { + let failed = try { + ignore(@src.nnsvg([[1.0, 2.0]], [[0.0, 0.0], [1.0, 0.0]])) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: fit rejects ragged expression" { + let failed = try { + ignore( + @src.nnsvg([[1.0, 2.0, 3.0], [1.0, 2.0]], [ + [0.0, 0.0], + [1.0, 0.0], + [2.0, 0.0], + ]), + ) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: fit rejects non-finite expression" { + let failed = try { + ignore( + @src.nnsvg([[1.0, 1.0e301, 3.0]], [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0]]), + ) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: fit rejects coordinate count mismatch" { + let (expression, coordinates, _) = @src.nnsvg_example_data() + let shortened : Array[Array[Double]] = [] + for index in 0..<(coordinates.length() - 1) { + shortened.push(coordinates[index]) + } + let failed = try { + ignore(@src.nnsvg(expression, shortened)) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: fit rejects gene name count mismatch" { + let (expression, coordinates, _) = @src.nnsvg_example_data() + let failed = try { + ignore(@src.nnsvg(expression, coordinates, gene_names=["only_one"])) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: fit rejects design row mismatch" { + let (expression, coordinates, gene_names) = @src.nnsvg_example_data() + let failed = try { + ignore( + @src.nnsvg(expression, coordinates, design=[[1.0], [1.0]], gene_names~), + ) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: fit rejects rank-deficient design" { + let (expression, coordinates, gene_names) = @src.nnsvg_example_data() + let design : Array[Array[Double]] = [] + for _ in coordinates { + design.push([1.0, 1.0]) + } + let failed = try { + ignore(@src.nnsvg(expression, coordinates, design~, gene_names~)) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: gene filtering applies expression threshold" { + let counts = [ + [4.0, 4.0, 0.0, 0.0], + [2.0, 2.0, 2.0, 2.0], + [5.0, 5.0, 5.0, 5.0], + ] + let filter = @src.nnsvg_filter_genes( + counts, + ["A", "B", "C"], + minimum_count=3.0, + minimum_spot_percentage=50.0, + filter_mitochondrial=false, + ) catch { + _ => abort("gene filtering should succeed") + } + assert_eq(filter.kept_indices, [0, 2]) + assert_eq(filter.removed_low_expression, [1]) + assert_eq(filter.counts.length(), 2) +} + +///| +test "nnSVG: gene filtering removes mitochondrial prefixes" { + let filter = @src.nnsvg_filter_genes( + [[4.0, 4.0], [4.0, 4.0], [4.0, 4.0]], + ["MT-ND1", "mt-Co1", "ACTB"], + minimum_spot_percentage=100.0, + ) catch { + _ => abort("mitochondrial filtering should succeed") + } + assert_eq(filter.kept_indices, [2]) + assert_eq(filter.removed_mitochondrial, [0, 1]) +} + +///| +test "nnSVG: mitochondrial filtering can be disabled" { + let filter = @src.nnsvg_filter_genes( + [[4.0, 4.0], [4.0, 4.0]], + ["MT-ND1", "ACTB"], + minimum_spot_percentage=100.0, + filter_mitochondrial=false, + ) catch { + _ => abort("disabled mitochondrial filtering should succeed") + } + assert_eq(filter.kept_indices, [0, 1]) + assert_eq(filter.removed_mitochondrial.length(), 0) +} + +///| +test "nnSVG: default filter percentage requires one detected spot" { + let filter = @src.nnsvg_filter_genes( + [[0.0, 0.0, 0.0, 3.0], [0.0, 0.0, 0.0, 0.0]], + ["detected", "absent"], + filter_mitochondrial=false, + ) catch { + _ => abort("default filtering should succeed") + } + assert_eq(filter.kept_indices, [0]) + assert_eq(filter.removed_low_expression, [1]) +} + +///| +test "nnSVG: gene filtering rejects name mismatch" { + let failed = try { + ignore(@src.nnsvg_filter_genes([[1.0, 2.0]], [])) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: gene filtering rejects ragged counts" { + let failed = try { + ignore(@src.nnsvg_filter_genes([[1.0, 2.0], [1.0]], ["A", "B"])) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: gene filtering rejects negative counts" { + let failed = try { + ignore(@src.nnsvg_filter_genes([[-1.0, 2.0]], ["A"])) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: gene filtering rejects invalid thresholds" { + let count = try { + ignore(@src.nnsvg_filter_genes([[1.0, 2.0]], ["A"], minimum_count=-1.0)) + false + } catch { + NnsvgError(_) => true + } + let percentage = try { + ignore( + @src.nnsvg_filter_genes( + [[1.0, 2.0]], + ["A"], + minimum_spot_percentage=101.0, + ), + ) + false + } catch { + NnsvgError(_) => true + } + assert_true(count) + assert_true(percentage) +} + +///| +test "nnSVG: SpatialExperiment integration preserves assays" { + let experiment = nnsvg_test_spatial_experiment() + let output = @src.nnsvg_spatial_experiment( + experiment, + config=nnsvg_test_config(), + ) catch { + _ => abort("SpatialExperiment integration should succeed") + } + assert_eq(output.result.n_genes(), 4) + assert_true(output.experiment.assay.contains("logcounts")) + assert_true(output.experiment.assay.contains("counts")) +} + +///| +test "nnSVG: SpatialExperiment integration writes rowData statistics" { + let output = @src.nnsvg_spatial_experiment( + nnsvg_test_spatial_experiment(), + config=nnsvg_test_config(), + ) catch { + _ => abort("SpatialExperiment integration should succeed") + } + let row = output.experiment.row_data[0] + assert_true(row.contains("nnsvg_sigma_sq")) + assert_true(row.contains("nnsvg_tau_sq")) + assert_true(row.contains("nnsvg_prop_sv")) + assert_true(row.contains("nnsvg_LR_stat")) + assert_true(row.contains("nnsvg_pval")) + assert_true(row.contains("nnsvg_padj")) +} + +///| +test "nnSVG: SpatialExperiment integration writes metadata" { + let output = @src.nnsvg_spatial_experiment( + nnsvg_test_spatial_experiment(), + config=nnsvg_test_config(), + ) catch { + _ => abort("SpatialExperiment integration should succeed") + } + assert_eq(output.experiment.metadata["nnsvg_assay"], "logcounts") + assert_eq(output.experiment.metadata["nnsvg_neighbors"], "3") + assert_eq(output.experiment.metadata["nnsvg_genes"], "4") +} + +///| +test "nnSVG: SpatialExperiment integration leaves input rowData unchanged" { + let experiment = nnsvg_test_spatial_experiment() + ignore( + @src.nnsvg_spatial_experiment(experiment, config=nnsvg_test_config()) catch { + _ => abort("SpatialExperiment integration should succeed") + }, + ) + assert_false(experiment.row_data[0].contains("nnsvg_pval")) +} + +///| +test "nnSVG: SpatialExperiment integration rejects missing assay" { + let failed = try { + ignore( + @src.nnsvg_spatial_experiment( + nnsvg_test_spatial_experiment(), + assay_name="missing", + config=nnsvg_test_config(), + ), + ) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: SpatialExperiment integration rejects coordinate mismatch" { + let experiment = nnsvg_test_spatial_experiment() + ignore(experiment.spatial_coords.pop()) + let failed = try { + ignore( + @src.nnsvg_spatial_experiment(experiment, config=nnsvg_test_config()), + ) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: SpatialExperiment filter subsets every assay" { + let output = @src.nnsvg_filter_spatial_experiment( + nnsvg_test_spatial_experiment(), + minimum_count=5.0, + minimum_spot_percentage=50.0, + filter_mitochondrial=false, + ) catch { + _ => abort("SpatialExperiment filtering should succeed") + } + assert_eq( + output.experiment.assay["counts"].length(), + output.filter.kept_indices.length(), + ) + assert_eq( + output.experiment.assay["logcounts"].length(), + output.filter.kept_indices.length(), + ) + assert_eq( + output.experiment.row_data.length(), + output.filter.kept_indices.length(), + ) +} + +///| +test "nnSVG: SpatialExperiment filter preserves spot data" { + let experiment = nnsvg_test_spatial_experiment() + let output = @src.nnsvg_filter_spatial_experiment( + experiment, + minimum_count=5.0, + minimum_spot_percentage=50.0, + filter_mitochondrial=false, + ) catch { + _ => abort("SpatialExperiment filtering should succeed") + } + assert_eq( + output.experiment.spatial_coords.length(), + experiment.spatial_coords.length(), + ) + assert_eq(output.experiment.col_data.length(), experiment.col_data.length()) +} + +///| +test "nnSVG: SpatialExperiment filter records metadata" { + let output = @src.nnsvg_filter_spatial_experiment( + nnsvg_test_spatial_experiment(), + minimum_count=5.0, + minimum_spot_percentage=50.0, + filter_mitochondrial=false, + ) catch { + _ => abort("SpatialExperiment filtering should succeed") + } + assert_true(output.experiment.metadata.contains("nnsvg_filter_kept")) + assert_true(output.experiment.metadata.contains("nnsvg_filter_removed")) +} + +///| +test "nnSVG: SpatialExperiment filter rejects missing count assay" { + let failed = try { + ignore( + @src.nnsvg_filter_spatial_experiment( + nnsvg_test_spatial_experiment(), + count_assay="missing", + ), + ) + false + } catch { + NnsvgError(_) => true + } + assert_true(failed) +} + +///| +test "nnSVG: three-dimensional SpatialExperiment coordinates are supported" { + let experiment = nnsvg_test_spatial_experiment() + experiment.spatial_coords[1] = @src.SpatialCoord::new(1.0, 0.0, 1.0) + let output = @src.nnsvg_spatial_experiment( + experiment, + config=nnsvg_test_config(), + ) catch { + _ => abort("3D SpatialExperiment integration should succeed") + } + assert_eq(output.result.graph.coordinates[0].length(), 3) +} From 6829929868dadb2535e9b7ef7d1a94ce3dd1cd9d Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 15:44:37 +0800 Subject: [PATCH 28/41] feat(align_psl): Bio.Align.psl UCSC PSL/PSLX --- README.md | 27 +- examples/align_psl_demo/main.mbt | 112 +++ examples/align_psl_demo/moon.pkg | 5 + src/align_psl.mbt | 1509 ++++++++++++++++++++++++++++++ test/moonbit/align_psl_test.mbt | 1233 ++++++++++++++++++++++++ 5 files changed, 2882 insertions(+), 4 deletions(-) create mode 100644 examples/align_psl_demo/main.mbt create mode 100644 examples/align_psl_demo/moon.pkg create mode 100644 src/align_psl.mbt create mode 100644 test/moonbit/align_psl_test.mbt diff --git a/README.md b/README.md index d982835c..e7f227ac 100644 --- a/README.md +++ b/README.md @@ -34,6 +34,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **HH-suite HHR** | Biopython `Bio.Align.hhr` | HHsearch/HHblits HHR解析、profile-profile比对、命中筛选、坐标映射、序列化往返 | ✅ | | **共享参考比对合并** | Biopython `Bio.Align.Alignment` | 合并共享同一参考序列的PWA/MSA、同步insertion slots、保留局部坐标与metadata、双向坐标映射 | ✅ | | **Alignment详细统计** | Biopython `Bio.Align.Alignment.counts` | 左/内部/右 insertion/deletion、gap open/extend、identity/mismatch/positive、wildcard、替换矩阵和十二类affine gap评分 | ✅ | +| **PSL/PSLX成对比对** | Biopython `Bio.Align.psl` | 21/23列严格读写、核酸与translated DNA-protein路径、正反链坐标、block/gap统计、sequence-aware recount及坐标映射 | ✅ | | **系统发育树** | Biopython `Bio.Phylo` | 树结构、Newick 解析、距离计算、可视化 | ✅ | | **PDB 结构** | Biopython `Bio.PDB` | 原子/残基/链解析、结构操作 | ✅ | | **BinaryCIF** | Biopython `Bio.PDB.binary_cif` | MessagePack解析、七类逆编码、三态缺失值、类别查询、PDB Structure转换 | ✅ | @@ -162,6 +163,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | Bio.Align.Alignment shared-reference merge | 共享参考PWA/MSA合并、reference-boundary insertion slot同步、局部reference/query坐标、metadata、统计、MSA与aligned FASTA转换 | | ✅ | Bio.Align.Alignment map/mapall | 零起始半开区间alignment path组合、局部clipping、gap与正反链传播、双向坐标查询、PSL、批量map及protein MSA到codon-aware nucleotide MSA投影 | | ✅ | Bio.Align.Alignment counts | pairwise/MSA详细gap分类、open/extend事件、identity/mismatch/positive、wildcard、替换矩阵与完整affine总分 | +| ✅ | Bio.Align.psl | alignment-aware PSL/PSLX 21/23列严格解析与写出、核酸和translated 3:1路径、双轴链向、match/repeat/N recount、block序列及坐标互映 | | ✅ | Bio.Align.bigbed | BigBed v4二进制读写、BED3-BED12、AutoSQL扩展字段、多级chromosome B+ tree与R-tree、zlib/DEFLATE解码、区间/名称查询和BED导出 | | ✅ | Bio.Align.bigmaf | 标准bedMaf bed3+1读写、完整MAF a/s/i/e/q语义、正负链坐标映射、BigBed压缩索引查询、MAF导出和严格损坏数据诊断 | | ✅ | Bioconductor decontX | 单细胞ambient RNA去污染: cluster-native/contaminant多项式混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解、诊断与SingleCellExperiment接入 | @@ -375,6 +377,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **共享参考比对同步** | Biopython `Bio.Align.Alignment` | 相同参考PWA/MSA合并、边界插入宽度归一化、query原始比对结构保留、reference/query/column坐标互映 | ✅ | | **Alignment gap/composition统计** | Biopython `Bio.Align.Alignment.counts` | pairwise与MSA逐对统计、端部/内部gap分类、open/extend事件、替换和gap总分 | ✅ | | **Alignment-aware tabular搜索结果** | Biopython `Bio.Align.tabular` | BLAST outfmt 7、FASTA 8CB/8CC、BTOP/aln_code路径、链向及translated坐标 | ✅ | +| **Alignment-aware PSL/PSLX** | Biopython `Bio.Align.psl` | 21/23列格式、header、block/gap一致性、正反链、translated 3:1坐标、序列重计数与严格诊断 | ✅ | | **UCSC Chain文件/liftOver** | Bioconductor rtracklayer | Chain格式解析、基因组坐标liftOver转换、链段查找、染色体间坐标映射、位置/区间转换 | ✅ | | **Biostrings matchPDict** | Bioconductor Biostrings | 字典模式匹配(matchPDict/vmatchPattern)、多序列模式计数(vcountPattern)、错配容忍、最佳匹配查找 | ✅ | | **GenomicRanges gaps/reduce/disjoin** | Bioconductor GenomicRanges | gaps检测、reduce合并、disjoin拆分、setdiff/交集/并集集合运算、coverage计算、promoters提取、trim | ✅ | @@ -434,6 +437,7 @@ IvanAXu/BioSeqs/ │ ├── alignment_map.mbt # Bio.Align.Alignment map/mapall坐标路径组合与MSA投影 │ ├── alignment_counts.mbt # Bio.Align.Alignment.counts详细gap/composition统计与评分 │ ├── align_tabular.mbt # Bio.Align.tabular BLAST/FASTA traceback表格解析与坐标路径 +│ ├── align_psl.mbt # Bio.Align.psl PSL/PSLX严格读写、链向路径、统计与坐标映射 │ ├── bigbed.mbt # Bio.Align.bigbed v4、BED/AutoSQL、多级B+ tree/R-tree与DEFLATE │ ├── bigmaf.mbt # Bio.Align.bigmaf bedMaf、MAF注释、链向坐标映射与索引查询 │ ├── bigpsl.mbt # Bio.Align.bigpsl bed12+13、核酸/translated protein路径与PSL @@ -1135,6 +1139,7 @@ IvanAXu/BioSeqs/ │ ├── alignment_map_demo/ # Alignment.map/mapall、反链、PSL与protein-to-codon MSA投影示例 │ ├── alignment_counts_demo/ # Alignment.counts gap分类、affine/BLOSUM评分、反链与MSA汇总示例 │ ├── align_tabular_demo/ # BLAST BTOP、FASTA aln_code与translated反链坐标解析示例 +│ ├── align_psl_demo/ # PSL/PSLX读写、反链映射、translated recount与文档摘要示例 │ ├── bigbed_demo/ # BigBed写入/解析、索引查询、负链exon坐标、BED导出与损坏诊断 │ ├── bigmaf_demo/ # BigMaf压缩写入、bedMaf schema、区间查询、负链映射与MAF导出 │ ├── bigpsl_demo/ # BigPsl压缩写入、R-tree查询、反链/translated坐标与PSL导出 @@ -1347,6 +1352,7 @@ IvanAXu/BioSeqs/ │ │ ├── alignment_map_test.mbt │ │ ├── alignment_counts_test.mbt │ │ ├── align_tabular_test.mbt +│ │ ├── align_psl_test.mbt │ │ ├── bigbed_test.mbt │ │ ├── bigmaf_test.mbt │ │ ├── bigpsl_test.mbt @@ -1526,7 +1532,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 9468 个测试全部通过 +moon test # ✅ 9561 个测试全部通过 ``` ### 模块对照表 @@ -1575,6 +1581,7 @@ moon test # ✅ 9468 个测试全 | `alignment_map.mbt` | BioPython `Bio.Align.Alignment.map/mapall` | alignment path组合、local clipping、gap与链向传播、双向坐标查询、PSL、map_many及codon-aware MSA投影 | | `alignment_counts.mbt` | BioPython `Bio.Align.Alignment.counts` | left/internal/right insertion/deletion、open/extend、composition、wildcard、替换矩阵与十二类affine gap评分 | | `align_tabular.mbt` | BioPython `Bio.Align.tabular` | BLAST outfmt 7与FASTA 8CB/8CC元数据、BTOP/CIGAR traceback、链向及translated坐标 | +| `align_psl.mbt` | BioPython `Bio.Align.psl` | PSL/PSLX header与21/23列严格读写、核酸/translated block路径、正反链、match分类、recount及坐标转换 | | `bigbed.mbt` | BioPython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12、AutoSQL、多级chromosome B+ tree/R-tree、zlib/DEFLATE及索引查询 | | `bigmaf.mbt` | BioPython `Bio.Align.bigmaf` | bedMaf bed3+1读写、MAF a/s/i/e/q、正负链坐标映射、压缩索引查询、摘要和MAF导出 | | `bigpsl.mbt` | BioPython `Bio.Align.bigpsl` | bed12+13读写、核酸/translated protein路径、双向坐标映射、recount、压缩查询、摘要和PSL导出 | @@ -1853,6 +1860,7 @@ moon test # ✅ 9468 个测试全 | `alignment_map.mbt` | `Bio.Align.Alignment.map/mapall` | 两层alignment坐标组合、正反链与gap传播、PSL、批量映射及protein/nucleotide MSA投影 | | `alignment_counts.mbt` | `Bio.Align.Alignment.counts` | pairwise/MSA gap事件和composition汇总、正反链、wildcard、替换矩阵及完整affine评分 | | `align_tabular.mbt` | `Bio.Align.tabular` | BLAST/FASTA query block、完整字段词汇、BTOP/aln_code路径、translated轴换算、过滤与coordinate alignment转换 | +| `align_psl.mbt` | `Bio.Align.psl` | PSL/PSLX类型模型、严格字段与block一致性、核酸反向query、translated反向target、3:1 codon映射、序列重计数与往返 | | `bigbed.mbt` | `Bio.Align.bigbed` | BigBed v4二进制读写、BED/AutoSQL、平衡B+ tree/R-tree、完整DEFLATE块解码、区间/名称查询与BED导出 | | `bigmaf.mbt` | `Bio.Align.bigmaf` | bedMaf AutoSQL与MAF块往返、a/s/i/e/q注释、链感知坐标映射、BigBed索引查询和普通MAF导出 | | `bigpsl.mbt` | `Bio.Align.bigpsl` | 标准bigPsl AutoSQL、核酸与translated DNA-protein坐标、链感知映射、match分类、BigBed索引和PSL导出 | @@ -3038,6 +3046,14 @@ BTOP 和 FASTA CIGAR 会合并连续 operation 并重建显式 target/query coor `nnsvg_filter_genes` 实现按最小计数、表达 spot 百分比和 `MT-`/`mt-` 前缀过滤；`nnsvg_spatial_experiment` 从指定 assay 与空间坐标运行模型，在不可变 `SpatialExperiment` 副本的 rowData 中写入 13 项 nnSVG 统计和 metadata。API 另提供基因查询、top/significant 结果、摘要与示例数据。当前实现使用 dense 小型前驱协方差矩阵和确定性单线程网格优化，不依赖 BRISC、R、BiocParallel 或稀疏矩阵后端。 +### 263. Alignment-aware PSL/PSLX 读写与坐标模型 (Biopython Bio.Align.psl) + +实现 Biopython 1.86 `Bio.Align.psl` 对应的 alignment-aware UCSC PSL/PSLX 模型。`psl_parse` 接受带或不带 `psLayout version` header 的 21 列 PSL 和 23 列 PSLX，使用 0-based half-open 坐标重建显式 target/query path；`PslAlignment` 保留 match、mismatch、repeat match、N、query/target insertion 和 block sequence，不把全部对齐位置简化为 match。核酸比对支持 `+`/`-` query 方向，translated DNA-to-protein 比对支持 `++`/`+-` target 方向及严格 3:1 步长，PSLX translated target block 保存翻译后的氨基酸片段。 + +模块提供 block/gap 统计、identity/score、target-query 双向映射和 query residue 到 target codon interval 映射。`recount` 可从完整序列重新计算匹配分类，支持核酸反向互补、lower/upper repeat mask、自定义 wildcard，以及正向或反向 target DNA 翻译；writer 可选择 header、PSLX、自动 recount 和版本。`PslDocument` 支持 query/target 过滤、跨记录摘要和解析-写出往返，并可与 `CoordinatePairwiseAlignment` 互转；由于现有通用坐标模型要求 target 递增，`+-` translated alignment 在适配时给出明确错误。 + +解析器严格拒绝非十进制或溢出整数、非法 strand/列数、blockCount 与 CSV/PSLX 数量不一致、零长度/重叠/逆序/越界 block、首尾 gap、错误的核酸 1:1 或 translated 3:1 比例、match 分类总和、q/t insertion 统计及声明区间不一致。该模块负责普通文本 PSL/PSLX；`search_io.mbt` 继续提供简化的 BLAT 搜索结果适配，`bigpsl.mbt` 负责 bed12+13 BigBed 二进制索引。 + ## 性能优化 ### 优化策略 @@ -3139,8 +3155,8 @@ BTOP 和 FASTA CIGAR 会合并连续 operation 并重建显式 target/query coor | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 9468 | -| 通过数 | 9468 | +| 总测试数 | 9561 | +| 通过数 | 9561 | | 失败数 | 0 | | 通过率 | 100% | @@ -3246,6 +3262,7 @@ moon test --update | Bio.Align Alignment.map/mapall | `alignment_map_test.mbt` | 44 | | Bio.Align Alignment.counts | `alignment_counts_test.mbt` | 57 | | Bio.Align.tabular | `align_tabular_test.mbt` | 90 | +| Bio.Align.psl | `align_psl_test.mbt` | 93 | | Bio.Align.bigbed | `bigbed_test.mbt` | 64 | | Bio.Align.bigmaf | `bigmaf_test.mbt` | 79 | | SparseArray | `sparse_array_test.mbt` | 41 | @@ -3550,7 +3567,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 370 个示例程序，展示各模块的典型用法： +项目提供 371 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3747,6 +3764,7 @@ moon run cmd/bench/main.mbt | alignment_map_demo | chromosome→transcript→read坐标组合、intron gap、反链、坐标查询、PSL与protein-to-codon MSA投影 | `moon run examples/alignment_map_demo` | | alignment_counts_demo | left/internal/right gap与open/extend、affine/BLOSUM45评分、反向链和MSA逐对汇总 | `moon run examples/alignment_counts_demo` | | align_tabular_demo | BLAST outfmt 7 BTOP、FASTA 8CC aln_code、最佳命中和TBLASTX反链translated坐标 | `moon run examples/align_tabular_demo` | +| align_psl_demo | PSL/PSLX多记录读写、反向query映射、translated target recount、block sequence和摘要 | `moon run examples/align_psl_demo` | | bigbed_demo | BigBed v4压缩写入/解析、AutoSQL、多级索引查询、负链exon坐标、BED导出及损坏文件诊断 | `moon run examples/bigbed_demo` | | bigmaf_demo | BigMaf压缩bed3+1写入、bedMaf schema、R-tree区间查询、负链物种坐标映射和MAF a/s/i/e/q导出 | `moon run examples/bigmaf_demo` | | bigpsl_demo | BigPsl bed12+13压缩写入、AutoSQL、R-tree查询、反向核酸/translated protein坐标和PSL导出 | `moon run examples/bigpsl_demo` | @@ -3859,6 +3877,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bio.Align.Alignment map/mapall（alignment path组合、local clipping、gap与正反链传播、坐标查询、PSL及protein-to-codon MSA投影） - ✅ 实现 Bio.Align.Alignment counts（left/internal/right insertion/deletion、gap open/extend、identity/mismatch/positive、wildcard、替换矩阵、affine评分及MSA逐对汇总） - ✅ 实现 Bio.Align.tabular alignment-aware搜索结果解析（BLAST outfmt 7、FASTA 8CB/8CC、BTOP/aln_code、正反链与translated坐标、零命中query） +- ✅ 实现 Bio.Align.psl alignment-aware PSL/PSLX（21/23列严格读写、核酸/translated路径、双轴链向、block/gap统计、match recount、坐标映射与往返） - ✅ 实现 Bio.Align.bigbed BigBed v4二进制区间格式（BED3-BED12、AutoSQL、多级B+ tree/R-tree、DEFLATE、区间/名称查询与BED导出） - ✅ 实现 Bio.Align.bigmaf BigMaf多物种比对索引（标准bedMaf、MAF a/s/i/e/q、正负链坐标映射、压缩BigBed查询与MAF导出） - ✅ 实现 Bio.Align.bigpsl BigPsl成对比对索引（标准bed12+13、核酸/translated protein坐标、match recount、压缩BigBed查询与PSL导出） diff --git a/examples/align_psl_demo/main.mbt b/examples/align_psl_demo/main.mbt new file mode 100644 index 00000000..1830867c --- /dev/null +++ b/examples/align_psl_demo/main.mbt @@ -0,0 +1,112 @@ +///| +fn parse_psl(text : String) -> @src.PslDocument { + @src.psl_parse(text) catch { + PslError(message) => abort("PSL parsing failed: " + message) + } +} + +///| +fn no_header(pslx : Bool) -> @src.PslWriteConfig { + @src.PslWriteConfig::create(header=false, pslx~) catch { + PslError(message) => abort("PSL writer configuration failed: " + message) + } +} + +///| +fn main { + println("=== Biopython Bio.Align.psl Demo ===") + + println("\n1. Write and parse a multi-record PSL document") + let alignments = @src.psl_example_data() catch { + PslError(message) => abort("PSL example construction failed: " + message) + } + let text = @src.psl_write(alignments) catch { + PslError(message) => abort("PSL writing failed: " + message) + } + let document = parse_psl(text) + let summary = document.summary() + println( + " records=" + + summary.alignment_count.to_string() + + ", nucleotide=" + + summary.nucleotide_count.to_string() + + ", translated=" + + summary.protein_count.to_string(), + ) + println( + " aligned query units=" + + summary.aligned_query_units.to_string() + + ", query insert bases=" + + summary.query_insert_bases.to_string() + + ", target insert bases=" + + summary.target_insert_bases.to_string(), + ) + + println("\n2. Map a reverse-strand nucleotide query") + let reverse = document.query("readReverse")[0] + println(" strand reverse=" + reverse.is_reverse().to_string()) + match reverse.target_to_query(4) { + Some(position) => + println(" target base 4 maps to query base " + position.to_string()) + None => println(" target base 4 is outside aligned blocks") + } + match reverse.query_to_target_interval(7) { + Some((start, end)) => + println( + " query base 7 maps to target interval [" + + start.to_string() + + ", " + + end.to_string() + + ")", + ) + None => println(" query base 7 is outside aligned blocks") + } + + println("\n3. Emit and parse PSLX block sequences") + let protein = alignments[2].recount() catch { + PslError(message) => abort("translated recount failed: " + message) + } + let pslx = protein.format(config=no_header(true)) catch { + PslError(message) => abort("PSLX formatting failed: " + message) + } + let pslx_alignment = parse_psl(pslx).alignments[0] + println( + " PSLX blocks=" + + pslx_alignment.blocks().length().to_string() + + ", query fragment=" + + pslx_alignment.query_block_sequences[0] + + ", translated target fragment=" + + pslx_alignment.target_block_sequences[0], + ) + + println("\n4. Recount a reverse-target translated alignment") + let translated_reverse = @src.PslAlignment::create( + "codingReverse", + 18, + "peptide", + 4, + [18, 12, 9, 3], + [0, 2, 2, 4], + sequence_type=@src.PslProtein, + target_sequence="AAATCCAAAAAAAGCCAT", + query_sequence="MAFG", + ) catch { + PslError(message) => + abort("reverse translated alignment failed: " + message) + } + let recounted = translated_reverse.recount() catch { + PslError(message) => abort("reverse translated recount failed: " + message) + } + let translated_line = recounted.format(config=no_header(false)) catch { + PslError(message) => abort("translated PSL formatting failed: " + message) + } + println( + " strand=+-, matches=" + + recounted.matches.to_string() + + ", mismatches=" + + recounted.mismatches.to_string(), + ) + println(" " + translated_line) + + println("=== Demo Complete ===") +} diff --git a/examples/align_psl_demo/moon.pkg b/examples/align_psl_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/align_psl_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/align_psl.mbt b/src/align_psl.mbt new file mode 100644 index 00000000..20978e8e --- /dev/null +++ b/src/align_psl.mbt @@ -0,0 +1,1509 @@ +// Alignment-aware UCSC PSL/PSLX support. +// +// This module follows Biopython Bio.Align.psl coordinate semantics. PSL uses +// zero-based half-open intervals. Nucleotide alignments may reverse the query +// axis; translated DNA-to-protein alignments may reverse the target axis. + +///| +pub suberror PslError { + PslError(String) +} + +///| +pub(all) enum PslSequenceType { + PslNucleotide + PslProtein +} derive(Eq, Debug) + +///| +pub(all) enum PslMaskMode { + PslNoMask + PslMaskLower + PslMaskUpper +} derive(Eq, Debug) + +///| +pub struct PslBlock { + target_start : Int + target_end : Int + query_start : Int + query_end : Int + target_size : Int + query_size : Int + query_sequence : String + target_sequence : String +} derive(Eq, Debug) + +///| +pub struct PslCounts { + aligned_query_units : Int + query_insert_count : Int + query_insert_bases : Int + target_insert_count : Int + target_insert_bases : Int + block_count : Int +} derive(Eq, Debug) + +///| +pub struct PslAlignment { + target_name : String + target_size : Int + query_name : String + query_size : Int + target_coordinates : Array[Int] + query_coordinates : Array[Int] + sequence_type : PslSequenceType + matches : Int + mismatches : Int + repeat_matches : Int + n_count : Int + target_sequence : String + query_sequence : String + query_block_sequences : Array[String] + target_block_sequences : Array[String] +} + +///| +pub struct PslDocument { + version : String + has_header : Bool + alignments : Array[PslAlignment] +} + +///| +pub struct PslWriteConfig { + header : Bool + pslx : Bool + recount : Bool + mask : PslMaskMode + wildcard : Char +} + +///| +pub struct PslSummary { + alignment_count : Int + pslx_count : Int + nucleotide_count : Int + protein_count : Int + aligned_query_units : Int + query_insert_bases : Int + target_insert_bases : Int +} + +///| +priv struct PslStorage { + strand : String + query_start : Int + query_end : Int + target_start : Int + target_end : Int + block_sizes : Array[Int] + query_starts : Array[Int] + target_starts : Array[Int] +} + +///| +fn psl_fail(message : String) -> Unit raise PslError { + raise PslError(message) +} + +///| +fn psl_abs(value : Int) -> Int { + if value < 0 { + -value + } else { + value + } +} + +///| +fn psl_min(left : Int, right : Int) -> Int { + if left < right { + left + } else { + right + } +} + +///| +fn psl_max(left : Int, right : Int) -> Int { + if left > right { + left + } else { + right + } +} + +///| +fn psl_copy_ints(values : Array[Int]) -> Array[Int] { + let copy : Array[Int] = [] + for value in values { + copy.push(value) + } + copy +} + +///| +fn psl_copy_strings(values : Array[String]) -> Array[String] { + let copy : Array[String] = [] + for value in values { + copy.push(value) + } + copy +} + +///| +fn psl_reverse_ints(values : Array[Int]) -> Array[Int] { + let reversed : Array[Int] = [] + let mut index = values.length() + while index > 0 { + index = index - 1 + reversed.push(values[index]) + } + reversed +} + +///| +fn psl_strip_cr(value : String) -> String { + if value.length() > 0 && + value.unsafe_get(value.length() - 1).to_int() == '\r'.to_int() { + value[0:value.length() - 1].to_owned() + } else { + value + } +} + +///| +fn psl_validate_text( + value : String, + label : String, + allow_empty : Bool, +) -> Unit raise PslError { + if !allow_empty && value.length() == 0 { + psl_fail(label + " must not be empty") + } + for index in 0.. Unit raise PslError { + if sequence.length() == 0 { + return + } + if sequence.length() != expected_size { + psl_fail(label + " length does not match its declaration") + } + for index in 0.. Unit raise PslError { + if sequence.length() != expected_size { + psl_fail(label + " length does not match its block size") + } + for index in 0.. Int raise PslError { + let mut direction = 0 + for index in 0..<(coordinates.length() - 1) { + let step = coordinates[index + 1] - coordinates[index] + if step > 0 { + if direction < 0 { + psl_fail(label + " coordinates change direction") + } + direction = 1 + } else if step < 0 { + if direction > 0 { + psl_fail(label + " coordinates change direction") + } + direction = -1 + } + } + direction +} + +///| +fn psl_raw_blocks( + target_coordinates : Array[Int], + query_coordinates : Array[Int], + query_sequences : Array[String], + target_sequences : Array[String], +) -> Array[PslBlock] { + let blocks : Array[PslBlock] = [] + let mut block_index = 0 + for index in 0..<(target_coordinates.length() - 1) { + let target_start = target_coordinates[index] + let target_end = target_coordinates[index + 1] + let query_start = query_coordinates[index] + let query_end = query_coordinates[index + 1] + let target_size = psl_abs(target_end - target_start) + let query_size = psl_abs(query_end - query_start) + if target_size > 0 && query_size > 0 { + blocks.push(PslBlock::{ + target_start, + target_end, + query_start, + query_end, + target_size, + query_size, + query_sequence: if query_sequences.length() > 0 { + query_sequences[block_index] + } else { + "" + }, + target_sequence: if target_sequences.length() > 0 { + target_sequences[block_index] + } else { + "" + }, + }) + block_index = block_index + 1 + } + } + blocks +} + +///| +fn psl_path_counts( + target_coordinates : Array[Int], + query_coordinates : Array[Int], +) -> PslCounts { + let mut aligned_query_units = 0 + let mut query_insert_count = 0 + let mut query_insert_bases = 0 + let mut target_insert_count = 0 + let mut target_insert_bases = 0 + let mut block_count = 0 + for index in 0..<(target_coordinates.length() - 1) { + let target_step = psl_abs( + target_coordinates[index + 1] - target_coordinates[index], + ) + let query_step = psl_abs( + query_coordinates[index + 1] - query_coordinates[index], + ) + if target_step > 0 && query_step > 0 { + aligned_query_units = aligned_query_units + query_step + block_count = block_count + 1 + } else if target_step == 0 && query_step > 0 { + query_insert_count = query_insert_count + 1 + query_insert_bases = query_insert_bases + query_step + } else if target_step > 0 && query_step == 0 { + target_insert_count = target_insert_count + 1 + target_insert_bases = target_insert_bases + target_step + } + } + PslCounts::{ + aligned_query_units, + query_insert_count, + query_insert_bases, + target_insert_count, + target_insert_bases, + block_count, + } +} + +///| +pub fn PslAlignment::create( + target_name : String, + target_size : Int, + query_name : String, + query_size : Int, + target_coordinates : Array[Int], + query_coordinates : Array[Int], + sequence_type? : PslSequenceType = PslNucleotide, + matches? : Int = -1, + mismatches? : Int = -1, + repeat_matches? : Int = -1, + n_count? : Int = -1, + target_sequence? : String = "", + query_sequence? : String = "", + query_block_sequences? : Array[String] = [], + target_block_sequences? : Array[String] = [], +) -> PslAlignment raise PslError { + psl_validate_text(target_name, "PSL target name", false) + psl_validate_text(query_name, "PSL query name", false) + if target_size <= 0 || query_size <= 0 { + psl_fail("PSL target and query sizes must be positive") + } + if target_coordinates.length() != query_coordinates.length() { + psl_fail("PSL target and query coordinate arrays must have equal length") + } + if target_coordinates.length() < 2 { + psl_fail("PSL alignment path must contain at least two points") + } + let mut targets = psl_copy_ints(target_coordinates) + let mut queries = psl_copy_ints(query_coordinates) + let initial_target_direction = psl_axis_direction(targets, "PSL target") + let initial_query_direction = psl_axis_direction(queries, "PSL query") + match sequence_type { + PslNucleotide => + if initial_target_direction < 0 { + targets = psl_reverse_ints(targets) + queries = psl_reverse_ints(queries) + } + PslProtein => + if initial_query_direction < 0 { + targets = psl_reverse_ints(targets) + queries = psl_reverse_ints(queries) + } + } + let target_direction = psl_axis_direction(targets, "PSL target") + let query_direction = psl_axis_direction(queries, "PSL query") + match sequence_type { + PslNucleotide => + if target_direction <= 0 || query_direction == 0 { + psl_fail( + "nucleotide PSL requires an increasing target and an oriented query", + ) + } + PslProtein => + if query_direction <= 0 || target_direction == 0 { + psl_fail( + "translated PSL requires an increasing query and an oriented target", + ) + } + } + for index in 0.. target_size { + psl_fail("PSL target coordinate is out of bounds") + } + if queries[index] < 0 || queries[index] > query_size { + psl_fail("PSL query coordinate is out of bounds") + } + } + let mut block_count = 0 + for index in 0..<(targets.length() - 1) { + let target_step = psl_abs(targets[index + 1] - targets[index]) + let query_step = psl_abs(queries[index + 1] - queries[index]) + if target_step == 0 && query_step == 0 { + psl_fail("PSL path contains a zero-length step") + } + if target_step > 0 && query_step > 0 { + match sequence_type { + PslNucleotide => + if target_step != query_step { + psl_fail("nucleotide PSL aligned steps must have equal lengths") + } + PslProtein => + if target_step != 3 * query_step { + psl_fail("translated PSL aligned steps must have a 3:1 ratio") + } + } + block_count = block_count + 1 + } + } + if block_count == 0 { + psl_fail("PSL alignment must contain at least one aligned block") + } + let first_target_step = psl_abs(targets[1] - targets[0]) + let first_query_step = psl_abs(queries[1] - queries[0]) + let last = targets.length() - 1 + let last_target_step = psl_abs(targets[last] - targets[last - 1]) + let last_query_step = psl_abs(queries[last] - queries[last - 1]) + if first_target_step == 0 || + first_query_step == 0 || + last_target_step == 0 || + last_query_step == 0 { + psl_fail("PSL path cannot begin or end with an unaligned gap") + } + psl_validate_sequence(target_sequence, target_size, "PSL target sequence") + psl_validate_sequence(query_sequence, query_size, "PSL query sequence") + let has_query_blocks = query_block_sequences.length() > 0 + let has_target_blocks = target_block_sequences.length() > 0 + if has_query_blocks != has_target_blocks { + psl_fail("PSLX requires both query and target block sequences") + } + if has_query_blocks { + if query_block_sequences.length() != block_count || + target_block_sequences.length() != block_count { + psl_fail("PSLX block sequence count does not match blockCount") + } + let blocks = psl_raw_blocks(targets, queries, [], []) + for index in 0.. PslWriteConfig raise PslError { + let code = wildcard.to_int() + if code == 0 || + code == ','.to_int() || + code == '\t'.to_int() || + code == '\n'.to_int() || + code == '\r'.to_int() { + psl_fail("PSL wildcard must be a printable non-delimiter character") + } + PslWriteConfig::{ header, pslx, recount, mask, wildcard } +} + +///| +pub fn PslWriteConfig::default() -> PslWriteConfig { + PslWriteConfig::{ + header: true, + pslx: false, + recount: false, + mask: PslNoMask, + wildcard: 'N', + } +} + +///| +pub fn PslAlignment::blocks(self : PslAlignment) -> Array[PslBlock] { + psl_raw_blocks( + self.target_coordinates, + self.query_coordinates, + self.query_block_sequences, + self.target_block_sequences, + ) +} + +///| +pub fn PslAlignment::counts(self : PslAlignment) -> PslCounts { + psl_path_counts(self.target_coordinates, self.query_coordinates) +} + +///| +pub fn PslAlignment::is_reverse(self : PslAlignment) -> Bool { + match self.sequence_type { + PslNucleotide => + self.query_coordinates[0] > + self.query_coordinates[self.query_coordinates.length() - 1] + PslProtein => + self.target_coordinates[0] > + self.target_coordinates[self.target_coordinates.length() - 1] + } +} + +///| +pub fn PslAlignment::is_pslx(self : PslAlignment) -> Bool { + self.query_block_sequences.length() > 0 +} + +///| +pub fn PslAlignment::identity(self : PslAlignment) -> Double { + let total = self.matches + + self.mismatches + + self.repeat_matches + + self.n_count + if total == 0 { + 0.0 + } else { + (self.matches + self.repeat_matches).to_double() / total.to_double() + } +} + +///| +pub fn PslAlignment::score(self : PslAlignment) -> Int { + let counts = self.counts() + self.matches + + self.repeat_matches / 2 - + self.mismatches - + counts.query_insert_count - + counts.target_insert_count +} + +///| +pub fn PslAlignment::target_to_query( + self : PslAlignment, + position : Int, +) -> Int? { + if position < 0 || position >= self.target_size { + return None + } + for block in self.blocks() { + let target_minimum = psl_min(block.target_start, block.target_end) + let target_maximum = psl_max(block.target_start, block.target_end) + if position >= target_minimum && position < target_maximum { + let target_offset = if block.target_end > block.target_start { + position - block.target_start + } else { + block.target_start - 1 - position + } + let query_offset = match self.sequence_type { + PslNucleotide => target_offset + PslProtein => target_offset / 3 + } + return Some( + if block.query_end > block.query_start { + block.query_start + query_offset + } else { + block.query_start - 1 - query_offset + }, + ) + } + } + None +} + +///| +pub fn PslAlignment::query_to_target_interval( + self : PslAlignment, + position : Int, +) -> (Int, Int)? { + if position < 0 || position >= self.query_size { + return None + } + for block in self.blocks() { + let query_minimum = psl_min(block.query_start, block.query_end) + let query_maximum = psl_max(block.query_start, block.query_end) + if position >= query_minimum && position < query_maximum { + let query_offset = if block.query_end > block.query_start { + position - block.query_start + } else { + block.query_start - 1 - position + } + let scale = match self.sequence_type { + PslNucleotide => 1 + PslProtein => 3 + } + let oriented = query_offset * scale + let first = if block.target_end > block.target_start { + block.target_start + oriented + } else { + block.target_start - oriented - scale + } + return Some( + (psl_min(first, first + scale), psl_max(first, first + scale)), + ) + } + } + None +} + +///| +pub fn PslAlignment::query_to_target( + self : PslAlignment, + position : Int, +) -> Int? { + match self.query_to_target_interval(position) { + Some((start, _)) => Some(start) + None => None + } +} + +///| +fn psl_upper_code(code : Int) -> Int { + if code >= 'a'.to_int() && code <= 'z'.to_int() { + code - 32 + } else { + code + } +} + +///| +fn psl_is_lower(code : Int) -> Bool { + code >= 'a'.to_int() && code <= 'z'.to_int() +} + +///| +fn psl_is_upper(code : Int) -> Bool { + code >= 'A'.to_int() && code <= 'Z'.to_int() +} + +///| +fn psl_complement_code(code : Int) -> Int { + match psl_upper_code(code) { + 65 => 84 + 67 => 71 + 71 => 67 + 84 => 65 + 85 => 65 + 82 => 89 + 89 => 82 + 77 => 75 + 75 => 77 + 66 => 86 + 86 => 66 + 68 => 72 + 72 => 68 + value => value + } +} + +///| +fn psl_translated_block( + sequence : String, + start : Int, + end : Int, +) -> String raise PslError { + let minimum = psl_min(start, end) + let maximum = psl_max(start, end) + let dna = sequence[minimum:maximum].to_owned() + let oriented = if end < start { + Seq::new(dna).reverse_complement() + } else { + Seq::new(dna) + } + let protein = oriented.translate() catch { + SeqError(message) => { + psl_fail("cannot translate PSL target block: " + message) + Seq::new("") + } + } + protein.to_string() +} + +///| +pub fn PslAlignment::recount( + self : PslAlignment, + target_sequence? : String = "", + query_sequence? : String = "", + mask? : PslMaskMode = PslNoMask, + wildcard? : Char = 'N', +) -> PslAlignment raise PslError { + let target = if target_sequence.length() > 0 { + target_sequence + } else { + self.target_sequence + } + let query = if query_sequence.length() > 0 { + query_sequence + } else { + self.query_sequence + } + psl_validate_sequence(target, self.target_size, "PSL target sequence") + psl_validate_sequence(query, self.query_size, "PSL query sequence") + if target.length() == 0 || query.length() == 0 { + psl_fail("PSL recount requires concrete target and query sequences") + } + if self.sequence_type == PslProtein && mask != PslNoMask { + psl_fail("repeat masking is only defined for nucleotide PSL") + } + let wildcard_code = psl_upper_code(wildcard.to_int()) + let mut matches = 0 + let mut mismatches = 0 + let mut repeat_matches = 0 + let mut n_count = 0 + for block in self.blocks() { + match self.sequence_type { + PslProtein => { + let translated = psl_translated_block( + target, + block.target_start, + block.target_end, + ) + if translated.length() != block.query_size { + psl_fail("translated PSL target block has an unexpected length") + } + for offset in 0.. + for offset in 0.. block.query_start { + block.query_start + offset + } else { + block.query_start - 1 - offset + } + let raw_target = target.unsafe_get(target_index).to_int() + let target_code = psl_upper_code(raw_target) + let raw_query = query.unsafe_get(query_index).to_int() + let query_code = if block.query_end < block.query_start { + psl_complement_code(raw_query) + } else { + psl_upper_code(raw_query) + } + if target_code == wildcard_code || query_code == wildcard_code { + n_count = n_count + 1 + } else if target_code != query_code { + mismatches = mismatches + 1 + } else { + let masked = match mask { + PslMaskLower => psl_is_lower(raw_target) + PslMaskUpper => psl_is_upper(raw_target) + PslNoMask => false + } + if masked { + repeat_matches = repeat_matches + 1 + } else { + matches = matches + 1 + } + } + } + } + } + PslAlignment::create( + self.target_name, + self.target_size, + self.query_name, + self.query_size, + self.target_coordinates, + self.query_coordinates, + sequence_type=self.sequence_type, + matches~, + mismatches~, + repeat_matches~, + n_count~, + target_sequence=target, + query_sequence=query, + ) +} + +///| +fn psl_storage(alignment : PslAlignment) -> PslStorage { + let blocks = alignment.blocks() + let reverse = alignment.is_reverse() + let block_sizes : Array[Int] = [] + let query_starts : Array[Int] = [] + let target_starts : Array[Int] = [] + let mut query_start = alignment.query_size + let mut query_end = 0 + let mut target_start = alignment.target_size + let mut target_end = 0 + for block in blocks { + let query_minimum = psl_min(block.query_start, block.query_end) + let query_maximum = psl_max(block.query_start, block.query_end) + let target_minimum = psl_min(block.target_start, block.target_end) + let target_maximum = psl_max(block.target_start, block.target_end) + query_start = psl_min(query_start, query_minimum) + query_end = psl_max(query_end, query_maximum) + target_start = psl_min(target_start, target_minimum) + target_end = psl_max(target_end, target_maximum) + block_sizes.push(block.query_size) + query_starts.push( + if alignment.sequence_type == PslNucleotide && reverse { + alignment.query_size - query_maximum + } else { + query_minimum + }, + ) + target_starts.push( + if alignment.sequence_type == PslProtein && reverse { + alignment.target_size - target_maximum + } else { + target_minimum + }, + ) + } + let strand = match alignment.sequence_type { + PslNucleotide => if reverse { "-" } else { "+" } + PslProtein => if reverse { "+-" } else { "++" } + } + PslStorage::{ + strand, + query_start, + query_end, + target_start, + target_end, + block_sizes, + query_starts, + target_starts, + } +} + +///| +fn psl_join_ints(values : Array[Int]) -> String { + let output = StringBuilder::new() + for index in 0.. 0 { + output.write_char(',') + } + output.write_string(values[index].to_string()) + } + if values.length() > 0 { + output.write_char(',') + } + output.to_string() +} + +///| +fn psl_join_strings(values : Array[String]) -> String { + let output = StringBuilder::new() + for index in 0.. 0 { + output.write_char(',') + } + output.write_string(values[index]) + } + if values.length() > 0 { + output.write_char(',') + } + output.to_string() +} + +///| +fn psl_block_sequences( + alignment : PslAlignment, +) -> (Array[String], Array[String]) raise PslError { + if alignment.query_block_sequences.length() > 0 { + return ( + psl_copy_strings(alignment.query_block_sequences), + psl_copy_strings(alignment.target_block_sequences), + ) + } + if alignment.target_sequence.length() == 0 || + alignment.query_sequence.length() == 0 { + psl_fail( + "PSLX output requires block sequences or concrete target/query sequences", + ) + } + let query_sequences : Array[String] = [] + let target_sequences : Array[String] = [] + for block in alignment.blocks() { + match alignment.sequence_type { + PslNucleotide => { + let target = alignment.target_sequence[block.target_start:block.target_end].to_owned() + let query_minimum = psl_min(block.query_start, block.query_end) + let query_maximum = psl_max(block.query_start, block.query_end) + let raw_query = alignment.query_sequence[query_minimum:query_maximum].to_owned() + let query = if block.query_end < block.query_start { + Seq::new(raw_query).reverse_complement().to_string() + } else { + raw_query + } + target_sequences.push(target) + query_sequences.push(query) + } + PslProtein => { + let target = psl_translated_block( + alignment.target_sequence, + block.target_start, + block.target_end, + ) + let query = alignment.query_sequence[block.query_start:block.query_end].to_owned() + target_sequences.push(target) + query_sequences.push(query) + } + } + } + (query_sequences, target_sequences) +} + +///| +pub fn psl_header(version? : String = "3") -> String raise PslError { + psl_validate_text(version, "PSL version", false) + for index in 0.. String raise PslError { + let alignment = if config.recount { + self.recount(mask=config.mask, wildcard=config.wildcard) + } else { + self + } + let storage = psl_storage(alignment) + let counts = alignment.counts() + let output = StringBuilder::new() + let fields = [ + alignment.matches.to_string(), + alignment.mismatches.to_string(), + alignment.repeat_matches.to_string(), + alignment.n_count.to_string(), + counts.query_insert_count.to_string(), + counts.query_insert_bases.to_string(), + counts.target_insert_count.to_string(), + counts.target_insert_bases.to_string(), + storage.strand, + alignment.query_name, + alignment.query_size.to_string(), + storage.query_start.to_string(), + storage.query_end.to_string(), + alignment.target_name, + alignment.target_size.to_string(), + storage.target_start.to_string(), + storage.target_end.to_string(), + counts.block_count.to_string(), + psl_join_ints(storage.block_sizes), + psl_join_ints(storage.query_starts), + psl_join_ints(storage.target_starts), + ] + for index in 0.. 0 { + output.write_char('\t') + } + output.write_string(fields[index]) + } + if config.pslx { + let (query_sequences, target_sequences) = psl_block_sequences(alignment) + output.write_char('\t') + output.write_string(psl_join_strings(query_sequences)) + output.write_char('\t') + output.write_string(psl_join_strings(target_sequences)) + } + output.write_char('\n') + output.to_string() +} + +///| +pub fn psl_write( + alignments : Array[PslAlignment], + config? : PslWriteConfig = PslWriteConfig::default(), + version? : String = "3", +) -> String raise PslError { + let output = StringBuilder::new() + if config.header { + output.write_string(psl_header(version~)) + } + for alignment in alignments { + output.write_string(alignment.format(config~)) + } + output.to_string() +} + +///| +fn psl_parse_int(value : String, label : String) -> Int raise PslError { + if value.length() == 0 { + psl_fail(label + " must not be empty") + } + let mut result = 0 + for index in 0.. '9'.to_int() { + psl_fail(label + " must be a non-negative integer") + } + let digit = code - '0'.to_int() + if result > (2147483647 - digit) / 10 { + psl_fail(label + " exceeds the supported integer range") + } + result = result * 10 + digit + } + result +} + +///| +fn psl_parse_csv_ints( + value : String, + label : String, +) -> Array[Int] raise PslError { + let parts = split_by_char(value, ','.to_int()) + let values : Array[Int] = [] + for index in 0.. Array[String] raise PslError { + let parts = split_by_char(value, ','.to_int()) + let values : Array[String] = [] + for index in 0.. PslAlignment raise PslError { + let words = split_by_char(line, '\t'.to_int()) + if words.length() != 21 && words.length() != 23 { + psl_fail( + "PSL line " + + line_number.to_string() + + " has " + + words.length().to_string() + + " columns; expected 21 or 23", + ) + } + let matches = psl_parse_int(words[0], "PSL matches") + let mismatches = psl_parse_int(words[1], "PSL misMatches") + let repeat_matches = psl_parse_int(words[2], "PSL repMatches") + let n_count = psl_parse_int(words[3], "PSL nCount") + let declared_query_insert_count = psl_parse_int(words[4], "PSL qNumInsert") + let declared_query_insert_bases = psl_parse_int(words[5], "PSL qBaseInsert") + let declared_target_insert_count = psl_parse_int(words[6], "PSL tNumInsert") + let declared_target_insert_bases = psl_parse_int(words[7], "PSL tBaseInsert") + let strand = words[8] + let sequence_type = match strand { + "+" | "-" => PslNucleotide + "++" | "+-" => PslProtein + _ => { + psl_fail("PSL strand must be '+', '-', '++', or '+-'") + PslNucleotide + } + } + let query_name = words[9] + let query_size = psl_parse_int(words[10], "PSL qSize") + let declared_query_start = psl_parse_int(words[11], "PSL qStart") + let declared_query_end = psl_parse_int(words[12], "PSL qEnd") + let target_name = words[13] + let target_size = psl_parse_int(words[14], "PSL tSize") + let declared_target_start = psl_parse_int(words[15], "PSL tStart") + let declared_target_end = psl_parse_int(words[16], "PSL tEnd") + let block_count = psl_parse_int(words[17], "PSL blockCount") + if block_count <= 0 { + psl_fail("PSL blockCount must be positive") + } + let block_sizes = psl_parse_csv_ints(words[18], "PSL blockSizes") + let query_starts = psl_parse_csv_ints(words[19], "PSL qStarts") + let target_starts = psl_parse_csv_ints(words[20], "PSL tStarts") + if block_sizes.length() != block_count || + query_starts.length() != block_count || + target_starts.length() != block_count { + psl_fail("PSL block arrays do not match blockCount") + } + let query_block_sequences : Array[String] = if words.length() == 23 { + psl_parse_csv_strings(words[21], "PSLX query sequences") + } else { + [] + } + let target_block_sequences : Array[String] = if words.length() == 23 { + psl_parse_csv_strings(words[22], "PSLX target sequences") + } else { + [] + } + if words.length() == 23 && + ( + query_block_sequences.length() != block_count || + target_block_sequences.length() != block_count + ) { + psl_fail("PSLX sequence arrays do not match blockCount") + } + let target_coordinates : Array[Int] = [target_starts[0]] + let query_coordinates : Array[Int] = [query_starts[0]] + let mut target_position = target_starts[0] + let mut query_position = query_starts[0] + for index in 0.. block_size + PslProtein => 3 * block_size + } + let target_start = target_starts[index] + let query_start = query_starts[index] + if target_start < target_position || query_start < query_position { + psl_fail("PSL blocks overlap or are not sorted") + } + if target_start + target_block_size > target_size || + query_start + block_size > query_size { + psl_fail("PSL block extends beyond a declared sequence size") + } + if target_start != target_position { + target_coordinates.push(target_start) + query_coordinates.push(query_position) + target_position = target_start + } + if query_start != query_position { + target_coordinates.push(target_position) + query_coordinates.push(query_start) + query_position = query_start + } + target_position = target_position + target_block_size + query_position = query_position + block_size + target_coordinates.push(target_position) + query_coordinates.push(query_position) + } + if strand == "-" { + for index in 0.. Bool { + if line.length() == 0 { + return false + } + for index in 0.. PslDocument raise PslError { + let raw_lines = split_by_char(content, '\n'.to_int()) + let lines : Array[String] = [] + for line in raw_lines { + lines.push(psl_strip_cr(line)) + } + let mut index = 0 + while index < lines.length() && lines[index].length() == 0 { + index = index + 1 + } + if index >= lines.length() { + psl_fail("PSL input is empty") + } + let mut version = "" + let mut has_header = false + if starts_with(lines[index], 0, "psLayout ") { + let words = split_by_whitespace(lines[index]) + if words.length() != 3 || words[1] != "version" { + psl_fail("malformed PSL header") + } + version = words[2] + psl_validate_text(version, "PSL version", false) + has_header = true + index = index + 1 + let mut found_separator = false + while index < lines.length() { + if psl_is_separator(lines[index]) { + found_separator = true + index = index + 1 + break + } + index = index + 1 + } + if !found_separator { + psl_fail("PSL header separator was not found") + } + } + let alignments : Array[PslAlignment] = [] + while index < lines.length() { + if lines[index].length() > 0 { + alignments.push(psl_parse_record(lines[index], index + 1)) + } + index = index + 1 + } + PslDocument::{ version, has_header, alignments } +} + +///| +pub fn PslDocument::query( + self : PslDocument, + name : String, +) -> Array[PslAlignment] { + let results : Array[PslAlignment] = [] + for alignment in self.alignments { + if alignment.query_name == name { + results.push(alignment) + } + } + results +} + +///| +pub fn PslDocument::target( + self : PslDocument, + name : String, +) -> Array[PslAlignment] { + let results : Array[PslAlignment] = [] + for alignment in self.alignments { + if alignment.target_name == name { + results.push(alignment) + } + } + results +} + +///| +pub fn PslDocument::summary(self : PslDocument) -> PslSummary { + let mut pslx_count = 0 + let mut nucleotide_count = 0 + let mut protein_count = 0 + let mut aligned_query_units = 0 + let mut query_insert_bases = 0 + let mut target_insert_bases = 0 + for alignment in self.alignments { + if alignment.is_pslx() { + pslx_count = pslx_count + 1 + } + match alignment.sequence_type { + PslNucleotide => nucleotide_count = nucleotide_count + 1 + PslProtein => protein_count = protein_count + 1 + } + let counts = alignment.counts() + aligned_query_units = aligned_query_units + counts.aligned_query_units + query_insert_bases = query_insert_bases + counts.query_insert_bases + target_insert_bases = target_insert_bases + counts.target_insert_bases + } + PslSummary::{ + alignment_count: self.alignments.length(), + pslx_count, + nucleotide_count, + protein_count, + aligned_query_units, + query_insert_bases, + target_insert_bases, + } +} + +///| +pub fn PslDocument::write( + self : PslDocument, + config? : PslWriteConfig = PslWriteConfig::default(), +) -> String raise PslError { + let version = if self.version.length() > 0 { self.version } else { "3" } + psl_write(self.alignments, config~, version~) +} + +///| +pub fn PslAlignment::to_coordinate_alignment( + self : PslAlignment, +) -> CoordinatePairwiseAlignment raise PslError { + if self.sequence_type == PslProtein && self.is_reverse() { + psl_fail( + "reverse-target translated PSL cannot use the target-increasing coordinate adapter", + ) + } + coordinate_pairwise_alignment_with_lengths( + self.target_name, + self.target_size, + self.query_name, + self.query_size, + self.target_coordinates, + self.query_coordinates, + target_sequence=self.target_sequence, + query_sequence=self.query_sequence, + ) catch { + AlignmentMapError(message) => { + psl_fail("cannot convert PSL coordinate path: " + message) + coordinate_pairwise_alignment_with_lengths( + "target", + 1, + "query", + 1, + [0, 1], + [0, 1], + ) catch { + _ => abort("unreachable PSL coordinate fallback") + } + } + } +} + +///| +pub fn psl_from_coordinate_alignment( + alignment : CoordinatePairwiseAlignment, + sequence_type? : PslSequenceType = PslNucleotide, +) -> PslAlignment raise PslError { + PslAlignment::create( + alignment.target_name, + alignment.target_length, + alignment.query_name, + alignment.query_length, + alignment.target_coordinates, + alignment.query_coordinates, + sequence_type~, + target_sequence=alignment.target_sequence, + query_sequence=alignment.query_sequence, + ) +} + +///| +pub fn psl_example_data() -> Array[PslAlignment] raise PslError { + let nucleotide = PslAlignment::create( + "chrExample", + 24, + "readForward", + 12, + [2, 6, 9, 9, 13], + [0, 4, 4, 6, 10], + target_sequence="TTACGTGGGACGTCCCAAATTTGG", + query_sequence="ACGTGGACGTAA", + matches=6, + mismatches=1, + repeat_matches=0, + n_count=1, + ) + let reverse = PslAlignment::create( + "chrExample", + 24, + "readReverse", + 8, + [4, 8, 10, 14], + [8, 4, 4, 0], + ) + let protein = PslAlignment::create( + "codingDna", + 12, + "peptide", + 2, + [0, 6], + [0, 2], + sequence_type=PslProtein, + target_sequence="ATGGCTTAATAG", + query_sequence="MA", + ).recount() + [nucleotide, reverse, protein] +} diff --git a/test/moonbit/align_psl_test.mbt b/test/moonbit/align_psl_test.mbt new file mode 100644 index 00000000..5ab440dc --- /dev/null +++ b/test/moonbit/align_psl_test.mbt @@ -0,0 +1,1233 @@ +///| +fn psl_test_join(values : Array[String], separator : String) -> String { + let output = StringBuilder::new() + for index in 0.. 0 { + output.write_string(separator) + } + output.write_string(values[index]) + } + output.to_string() +} + +///| +fn psl_test_fields() -> Array[String] { + [ + "6", "1", "0", "1", "1", "2", "1", "3", "+", "query1", "20", "1", "11", "chr1", + "30", "2", "13", "2", "4,4,", "1,7,", "2,9,", + ] +} + +///| +fn psl_test_line(fields : Array[String]) -> String { + psl_test_join(fields, "\t") + "\n" +} + +///| +fn psl_test_parse_raises(content : String) -> Bool { + try { + ignore(@src.psl_parse(content)) + false + } catch { + PslError(_) => true + } +} + +///| +fn psl_test_create_raises( + target_coordinates : Array[Int], + query_coordinates : Array[Int], +) -> Bool { + try { + ignore( + @src.PslAlignment::create( + "target", 30, "query", 20, target_coordinates, query_coordinates, + ), + ) + false + } catch { + PslError(_) => true + } +} + +///| +fn psl_test_forward() -> @src.PslAlignment { + @src.PslAlignment::create( + "chr1", + 30, + "query1", + 20, + [2, 6, 9, 9, 13], + [1, 5, 5, 7, 11], + matches=6, + mismatches=1, + repeat_matches=0, + n_count=1, + ) catch { + PslError(message) => abort("valid forward PSL failed: " + message) + } +} + +///| +fn psl_test_reverse() -> @src.PslAlignment { + @src.PslAlignment::create("chrR", 30, "queryR", 10, [4, 8, 10, 14], [ + 8, 4, 4, 0, + ]) catch { + PslError(message) => abort("valid reverse PSL failed: " + message) + } +} + +///| +fn psl_test_protein(reverse : Bool) -> @src.PslAlignment { + if reverse { + @src.PslAlignment::create( + "codingReverse", + 18, + "peptide", + 4, + [18, 12, 9, 3], + [0, 2, 2, 4], + sequence_type=@src.PslProtein, + target_sequence="AAATCCAAAAAAAGCCAT", + query_sequence="MAFG", + ) catch { + PslError(message) => + abort("valid reverse translated PSL failed: " + message) + } + } else { + @src.PslAlignment::create( + "codingForward", + 18, + "peptide", + 4, + [0, 6, 9, 15], + [0, 2, 2, 4], + sequence_type=@src.PslProtein, + target_sequence="ATGGCTAAATTTGGATAG", + query_sequence="MAFG", + ) catch { + PslError(message) => + abort("valid forward translated PSL failed: " + message) + } + } +} + +///| +test "Bio.Align.psl constructor: forward path and metadata" { + let alignment = psl_test_forward() + assert_eq(alignment.target_name, "chr1") + assert_eq(alignment.target_size, 30) + assert_eq(alignment.query_name, "query1") + assert_eq(alignment.query_size, 20) + assert_eq(alignment.target_coordinates, [2, 6, 9, 9, 13]) + assert_eq(alignment.query_coordinates, [1, 5, 5, 7, 11]) + assert_true(alignment.sequence_type is @src.PslSequenceType::PslNucleotide) +} + +///| +test "Bio.Align.psl constructor: omitted categories become matches" { + let alignment = @src.PslAlignment::create("target", 10, "query", 10, [1, 5], [ + 2, 6, + ]) catch { + _ => abort("valid default categories should construct") + } + assert_eq(alignment.matches, 4) + assert_eq(alignment.mismatches, 0) + assert_eq(alignment.repeat_matches, 0) + assert_eq(alignment.n_count, 0) +} + +///| +test "Bio.Align.psl constructor: defensive coordinate copy" { + let target = [1, 5] + let query = [2, 6] + let alignment = @src.PslAlignment::create( + "target", 10, "query", 10, target, query, + ) catch { + _ => abort("valid alignment should construct") + } + target[0] = 0 + query[0] = 0 + assert_eq(alignment.target_coordinates, [1, 5]) + assert_eq(alignment.query_coordinates, [2, 6]) +} + +///| +test "Bio.Align.psl constructor: decreasing target is normalized" { + let alignment = @src.PslAlignment::create( + "target", + 20, + "query", + 20, + [10, 6], + [8, 4], + ) catch { + _ => abort("decreasing nucleotide target should normalize") + } + assert_eq(alignment.target_coordinates, [6, 10]) + assert_eq(alignment.query_coordinates, [4, 8]) + assert_false(alignment.is_reverse()) +} + +///| +test "Bio.Align.psl constructor: decreasing protein query is normalized" { + let alignment = @src.PslAlignment::create( + "target", + 12, + "query", + 4, + [0, 6], + [2, 0], + sequence_type=@src.PslProtein, + ) catch { + _ => abort("decreasing protein query should normalize") + } + assert_eq(alignment.target_coordinates, [6, 0]) + assert_eq(alignment.query_coordinates, [0, 2]) + assert_true(alignment.is_reverse()) +} + +///| +test "Bio.Align.psl constructor: empty target name is rejected" { + let raised = try { + ignore(@src.PslAlignment::create("", 10, "q", 10, [0, 2], [0, 2])) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl constructor: control characters are rejected" { + let raised = try { + ignore( + @src.PslAlignment::create("target", 10, "bad\tquery", 10, [0, 2], [0, 2]), + ) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl constructor: non-positive sequence size is rejected" { + let raised = try { + ignore(@src.PslAlignment::create("t", 0, "q", 10, [0, 2], [0, 2])) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl constructor: unequal coordinate arrays are rejected" { + assert_true(psl_test_create_raises([0, 2], [0, 2, 3])) +} + +///| +test "Bio.Align.psl constructor: one coordinate point is rejected" { + assert_true(psl_test_create_raises([0], [0])) +} + +///| +test "Bio.Align.psl constructor: target direction changes are rejected" { + assert_true(psl_test_create_raises([0, 4, 2], [0, 4, 6])) +} + +///| +test "Bio.Align.psl constructor: query direction changes are rejected" { + assert_true(psl_test_create_raises([0, 4, 6], [0, 4, 2])) +} + +///| +test "Bio.Align.psl constructor: out-of-bounds target is rejected" { + assert_true(psl_test_create_raises([29, 31], [0, 2])) +} + +///| +test "Bio.Align.psl constructor: out-of-bounds query is rejected" { + assert_true(psl_test_create_raises([0, 2], [19, 21])) +} + +///| +test "Bio.Align.psl constructor: zero-length path step is rejected" { + assert_true(psl_test_create_raises([0, 0, 2], [0, 0, 2])) +} + +///| +test "Bio.Align.psl constructor: nucleotide aligned ratio is enforced" { + assert_true(psl_test_create_raises([0, 4], [0, 3])) +} + +///| +test "Bio.Align.psl constructor: translated aligned ratio is enforced" { + let raised = try { + ignore( + @src.PslAlignment::create( + "t", + 20, + "q", + 10, + [0, 5], + [0, 2], + sequence_type=@src.PslProtein, + ), + ) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl constructor: gap-only path is rejected" { + assert_true(psl_test_create_raises([0, 0, 4], [0, 2, 2])) +} + +///| +test "Bio.Align.psl constructor: leading gap is rejected" { + assert_true(psl_test_create_raises([0, 0, 4], [0, 2, 6])) +} + +///| +test "Bio.Align.psl constructor: trailing gap is rejected" { + assert_true(psl_test_create_raises([0, 4, 4], [0, 4, 6])) +} + +///| +test "Bio.Align.psl constructor: sequence length is validated" { + let raised = try { + ignore( + @src.PslAlignment::create( + "t", + 5, + "q", + 5, + [0, 5], + [0, 5], + target_sequence="ACGT", + ), + ) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl constructor: gapped sequence is rejected" { + let raised = try { + ignore( + @src.PslAlignment::create( + "t", + 5, + "q", + 5, + [0, 5], + [0, 5], + query_sequence="AC-TG", + ), + ) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl constructor: both PSLX sequence arrays are required" { + let raised = try { + ignore( + @src.PslAlignment::create("t", 5, "q", 5, [0, 5], [0, 5], query_block_sequences=[ + "ACGTA", + ]), + ) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl constructor: PSLX block count is validated" { + let raised = try { + ignore( + @src.PslAlignment::create( + "t", + 12, + "q", + 12, + [0, 4, 8, 12], + [0, 4, 4, 8], + query_block_sequences=["AAAA"], + target_block_sequences=["AAAA"], + ), + ) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl constructor: PSLX fragment length is validated" { + let raised = try { + ignore( + @src.PslAlignment::create( + "t", + 5, + "q", + 5, + [0, 5], + [0, 5], + query_block_sequences=["ACGT"], + target_block_sequences=["ACGTA"], + ), + ) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl constructor: PSLX fragment delimiter is rejected" { + let raised = try { + ignore( + @src.PslAlignment::create( + "t", + 5, + "q", + 5, + [0, 5], + [0, 5], + query_block_sequences=["AC,TA"], + target_block_sequences=["ACGTA"], + ), + ) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl constructor: partial categories are rejected" { + let raised = try { + ignore(@src.PslAlignment::create("t", 5, "q", 5, [0, 5], [0, 5], matches=5)) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl constructor: category sum is validated" { + let raised = try { + ignore( + @src.PslAlignment::create( + "t", + 5, + "q", + 5, + [0, 5], + [0, 5], + matches=4, + mismatches=0, + repeat_matches=0, + n_count=0, + ), + ) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl blocks: aligned segments preserve orientation" { + let blocks = psl_test_reverse().blocks() + assert_eq(blocks.length(), 2) + assert_eq(blocks[0].target_start, 4) + assert_eq(blocks[0].target_end, 8) + assert_eq(blocks[0].query_start, 8) + assert_eq(blocks[0].query_end, 4) + assert_eq(blocks[0].target_size, 4) + assert_eq(blocks[0].query_size, 4) +} + +///| +test "Bio.Align.psl counts: query and target gaps are independent" { + let counts = psl_test_forward().counts() + assert_eq(counts.aligned_query_units, 8) + assert_eq(counts.query_insert_count, 1) + assert_eq(counts.query_insert_bases, 2) + assert_eq(counts.target_insert_count, 1) + assert_eq(counts.target_insert_bases, 3) + assert_eq(counts.block_count, 2) +} + +///| +test "Bio.Align.psl metrics: identity and score" { + let alignment = psl_test_forward() + assert_eq(alignment.identity(), 0.75) + assert_eq(alignment.score(), 3) +} + +///| +test "Bio.Align.psl mapping: forward target to query" { + let alignment = psl_test_forward() + assert_eq(alignment.target_to_query(2), Some(1)) + assert_eq(alignment.target_to_query(5), Some(4)) + assert_eq(alignment.target_to_query(6), None) + assert_eq(alignment.target_to_query(9), Some(7)) + assert_eq(alignment.target_to_query(-1), None) +} + +///| +test "Bio.Align.psl mapping: forward query to target" { + let alignment = psl_test_forward() + assert_eq(alignment.query_to_target(1), Some(2)) + assert_eq(alignment.query_to_target(5), None) + assert_eq(alignment.query_to_target(7), Some(9)) + assert_eq(alignment.query_to_target_interval(10), Some((12, 13))) + assert_eq(alignment.query_to_target(20), None) +} + +///| +test "Bio.Align.psl mapping: reverse nucleotide coordinates" { + let alignment = psl_test_reverse() + assert_eq(alignment.target_to_query(4), Some(7)) + assert_eq(alignment.target_to_query(7), Some(4)) + assert_eq(alignment.target_to_query(8), None) + assert_eq(alignment.query_to_target(7), Some(4)) + assert_eq(alignment.query_to_target(4), Some(7)) + assert_eq(alignment.query_to_target(3), Some(10)) +} + +///| +test "Bio.Align.psl mapping: translated codon intervals" { + let alignment = psl_test_protein(false) + assert_eq(alignment.query_to_target_interval(0), Some((0, 3))) + assert_eq(alignment.query_to_target_interval(2), Some((9, 12))) + assert_eq(alignment.target_to_query(10), Some(2)) + assert_eq(alignment.target_to_query(12), Some(3)) + assert_eq(alignment.target_to_query(7), None) +} + +///| +test "Bio.Align.psl mapping: reverse translated codon intervals" { + let alignment = psl_test_protein(true) + assert_eq(alignment.query_to_target_interval(0), Some((15, 18))) + assert_eq(alignment.query_to_target_interval(2), Some((6, 9))) + assert_eq(alignment.target_to_query(17), Some(0)) + assert_eq(alignment.target_to_query(14), Some(1)) + assert_eq(alignment.target_to_query(10), None) +} + +///| +test "Bio.Align.psl recount: mismatch and wildcard" { + let alignment = @src.PslAlignment::create( + "target", + 5, + "query", + 5, + [0, 5], + [0, 5], + target_sequence="ACGTN", + query_sequence="ACGCA", + ) catch { + _ => abort("valid sequence alignment should construct") + } + let recounted = alignment.recount() catch { + _ => abort("sequence-aware recount should succeed") + } + assert_eq(recounted.matches, 3) + assert_eq(recounted.mismatches, 1) + assert_eq(recounted.repeat_matches, 0) + assert_eq(recounted.n_count, 1) +} + +///| +test "Bio.Align.psl recount: lowercase target repeat masking" { + let alignment = @src.PslAlignment::create( + "target", + 5, + "query", + 5, + [0, 5], + [0, 5], + target_sequence="AcGTN", + query_sequence="ACGTA", + ) catch { + _ => abort("valid sequence alignment should construct") + } + let recounted = alignment.recount(mask=@src.PslMaskLower) catch { + _ => abort("lowercase repeat recount should succeed") + } + assert_eq(recounted.matches, 3) + assert_eq(recounted.repeat_matches, 1) + assert_eq(recounted.n_count, 1) +} + +///| +test "Bio.Align.psl recount: uppercase target repeat masking" { + let alignment = @src.PslAlignment::create( + "target", + 5, + "query", + 5, + [0, 5], + [0, 5], + target_sequence="AcGTN", + query_sequence="ACGTA", + ) catch { + _ => abort("valid sequence alignment should construct") + } + let recounted = alignment.recount(mask=@src.PslMaskUpper) catch { + _ => abort("uppercase repeat recount should succeed") + } + assert_eq(recounted.matches, 1) + assert_eq(recounted.repeat_matches, 3) + assert_eq(recounted.n_count, 1) +} + +///| +test "Bio.Align.psl recount: custom wildcard" { + let alignment = @src.PslAlignment::create( + "target", + 4, + "query", + 4, + [0, 4], + [0, 4], + target_sequence="ACXT", + query_sequence="ACGT", + ) catch { + _ => abort("valid sequence alignment should construct") + } + let recounted = alignment.recount(wildcard='X') catch { + _ => abort("custom wildcard recount should succeed") + } + assert_eq(recounted.matches, 3) + assert_eq(recounted.n_count, 1) +} + +///| +test "Bio.Align.psl recount: reverse complement query" { + let alignment = @src.PslAlignment::create( + "target", + 4, + "query", + 4, + [0, 4], + [4, 0], + target_sequence="AGTC", + query_sequence="GACT", + ) catch { + _ => abort("valid reverse sequence alignment should construct") + } + let recounted = alignment.recount() catch { + _ => abort("reverse-complement recount should succeed") + } + assert_eq(recounted.matches, 4) + assert_eq(recounted.mismatches, 0) +} + +///| +test "Bio.Align.psl recount: translated forward DNA" { + let recounted = psl_test_protein(false).recount() catch { + _ => abort("forward translated recount should succeed") + } + assert_eq(recounted.matches, 4) + assert_eq(recounted.mismatches, 0) +} + +///| +test "Bio.Align.psl recount: translated reverse-complement DNA" { + let recounted = psl_test_protein(true).recount() catch { + _ => abort("reverse translated recount should succeed") + } + assert_eq(recounted.matches, 4) + assert_eq(recounted.mismatches, 0) +} + +///| +test "Bio.Align.psl recount: concrete sequences are required" { + let raised = try { + ignore(psl_test_forward().recount()) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl recount: protein repeat mask is rejected" { + let raised = try { + ignore(psl_test_protein(false).recount(mask=@src.PslMaskLower)) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl writer config: defaults" { + let config = @src.PslWriteConfig::default() + assert_true(config.header) + assert_false(config.pslx) + assert_false(config.recount) + assert_true(config.mask is @src.PslMaskMode::PslNoMask) + assert_eq(config.wildcard, 'N') +} + +///| +test "Bio.Align.psl writer config: custom options" { + let config = @src.PslWriteConfig::create( + header=false, + pslx=true, + recount=true, + mask=@src.PslMaskLower, + wildcard='X', + ) catch { + _ => abort("valid writer config should construct") + } + assert_false(config.header) + assert_true(config.pslx) + assert_true(config.recount) + assert_true(config.mask is @src.PslMaskMode::PslMaskLower) + assert_eq(config.wildcard, 'X') +} + +///| +test "Bio.Align.psl writer config: delimiter wildcard is rejected" { + let raised = try { + ignore(@src.PslWriteConfig::create(wildcard=',')) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl header: version and column labels" { + let header = @src.psl_header(version="4") catch { + _ => abort("valid PSL header should format") + } + assert_true(header.has_prefix("psLayout version 4\n\n")) + assert_true(header.contains("blockSizes")) +} + +///| +test "Bio.Align.psl header: whitespace version is rejected" { + let raised = try { + ignore(@src.psl_header(version="3 draft")) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl format: exact forward 21-column record" { + let config = @src.PslWriteConfig::create(header=false) catch { + _ => abort("valid writer config should construct") + } + let line = psl_test_forward().format(config~) catch { + _ => abort("valid PSL should format") + } + assert_eq(line, psl_test_line(psl_test_fields())) +} + +///| +test "Bio.Align.psl format: reverse nucleotide storage coordinates" { + let config = @src.PslWriteConfig::create(header=false) catch { + _ => abort("valid writer config should construct") + } + let line = psl_test_reverse().format(config~) catch { + _ => abort("valid reverse PSL should format") + } + assert_true(line.contains("\t-\tqueryR\t10\t0\t8\tchrR\t30\t4\t14\t")) + assert_true(line.has_suffix("\t4,4,\t2,6,\t4,10,\n")) +} + +///| +test "Bio.Align.psl format: translated strand forms" { + let config = @src.PslWriteConfig::create(header=false) catch { + _ => abort("valid writer config should construct") + } + let forward = psl_test_protein(false).format(config~) catch { + _ => abort("forward protein PSL should format") + } + let reverse = psl_test_protein(true).format(config~) catch { + _ => abort("reverse protein PSL should format") + } + assert_true(forward.contains("\t++\tpeptide\t")) + assert_true(reverse.contains("\t+-\tpeptide\t")) + assert_true(reverse.has_suffix("\t2,2,\t0,2,\t0,9,\n")) +} + +///| +test "Bio.Align.psl format: generated nucleotide PSLX blocks" { + let alignment = @src.PslAlignment::create( + "target", + 8, + "query", + 8, + [0, 4, 8], + [8, 4, 0], + target_sequence="ACGTTTAA", + query_sequence="TTAAAACG", + ) catch { + _ => abort("valid reverse PSLX source should construct") + } + let config = @src.PslWriteConfig::create(header=false, pslx=true) catch { + _ => abort("valid PSLX config should construct") + } + let line = alignment.format(config~) catch { + _ => abort("PSLX output should derive block sequences") + } + assert_true(line.has_suffix("\tCGTT,TTAA,\tACGT,TTAA,\n")) +} + +///| +test "Bio.Align.psl format: generated translated PSLX blocks" { + let config = @src.PslWriteConfig::create(header=false, pslx=true) catch { + _ => abort("valid PSLX config should construct") + } + let line = psl_test_protein(false).format(config~) catch { + _ => abort("translated PSLX output should derive amino-acid blocks") + } + assert_true(line.has_suffix("\tMA,FG,\tMA,FG,\n")) +} + +///| +test "Bio.Align.psl format: PSLX needs sequence data" { + let config = @src.PslWriteConfig::create(header=false, pslx=true) catch { + _ => abort("valid PSLX config should construct") + } + let raised = try { + ignore(psl_test_forward().format(config~)) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl format: writer can recount sequences" { + let alignment = @src.PslAlignment::create( + "target", + 4, + "query", + 4, + [0, 4], + [0, 4], + target_sequence="ACGT", + query_sequence="ACGA", + ) catch { + _ => abort("valid alignment should construct") + } + let config = @src.PslWriteConfig::create(header=false, recount=true) catch { + _ => abort("valid recount config should construct") + } + let line = alignment.format(config~) catch { + _ => abort("recounting writer should succeed") + } + assert_true(line.has_prefix("3\t1\t0\t0\t")) +} + +///| +test "Bio.Align.psl parse: headerless 21-column record" { + let document = @src.psl_parse(psl_test_line(psl_test_fields())) catch { + _ => abort("valid headerless PSL should parse") + } + assert_false(document.has_header) + assert_eq(document.version, "") + assert_eq(document.alignments.length(), 1) + assert_eq(document.alignments[0].target_coordinates, [2, 6, 9, 9, 13]) + assert_eq(document.alignments[0].query_coordinates, [1, 5, 5, 7, 11]) +} + +///| +test "Bio.Align.psl parse: generated header and CRLF" { + let text = @src.psl_write([psl_test_forward()]) catch { + _ => abort("valid PSL document should write") + } + let crlf = text.replace_all(old="\n", new="\r\n") + let document = @src.psl_parse(crlf) catch { + _ => abort("CRLF PSL should parse") + } + assert_true(document.has_header) + assert_eq(document.version, "3") + assert_eq(document.alignments.length(), 1) +} + +///| +test "Bio.Align.psl parse: 23-column PSLX record" { + let fields = psl_test_fields() + fields.push("ACGT,NNAA,") + fields.push("ACGT,NNTA,") + let document = @src.psl_parse(psl_test_line(fields)) catch { + _ => abort("valid PSLX should parse") + } + let alignment = document.alignments[0] + assert_true(alignment.is_pslx()) + assert_eq(alignment.query_block_sequences, ["ACGT", "NNAA"]) + assert_eq(alignment.target_block_sequences, ["ACGT", "NNTA"]) + assert_eq(alignment.blocks()[1].query_sequence, "NNAA") +} + +///| +test "Bio.Align.psl parse: reverse nucleotide path" { + let config = @src.PslWriteConfig::create(header=false) catch { + _ => abort("valid config should construct") + } + let line = psl_test_reverse().format(config~) catch { + _ => abort("reverse PSL should format") + } + let parsed = @src.psl_parse(line) catch { + _ => abort("reverse PSL should parse") + } + assert_eq(parsed.alignments[0].query_coordinates, [8, 4, 4, 0]) + assert_true(parsed.alignments[0].is_reverse()) + let biopython_fixture = "175\t0\t6\t0\t0\t0\t2\t1530\t-\tNR_046654.1\t181\t0\t181\tchr3\t198295559\t42530895\t42532606\t3\t63,75,43,\t0,63,138,\t42530895,42532020,42532563,\n" + let fixture = @src.psl_parse(biopython_fixture) catch { + _ => abort("Biopython negative-strand fixture should parse") + } + let fixture_alignment = fixture.alignments[0] + assert_eq(fixture_alignment.target_coordinates, [ + 42530895, 42530958, 42532020, 42532095, 42532563, 42532606, + ]) + assert_eq(fixture_alignment.query_coordinates, [181, 118, 118, 43, 43, 0]) + assert_eq(fixture_alignment.counts().target_insert_bases, 1530) + assert_eq( + fixture_alignment.format(config~) catch { + _ => abort("Biopython negative-strand fixture should format") + }, + biopython_fixture, + ) +} + +///| +test "Bio.Align.psl parse: translated forward and reverse paths" { + let config = @src.PslWriteConfig::create(header=false) catch { + _ => abort("valid config should construct") + } + let forward = psl_test_protein(false).format(config~) catch { + _ => abort("forward protein PSL should format") + } + let reverse = psl_test_protein(true).format(config~) catch { + _ => abort("reverse protein PSL should format") + } + let text = forward + reverse + let document = @src.psl_parse(text) catch { + _ => abort("translated PSL records should parse") + } + assert_eq(document.alignments.length(), 2) + assert_eq(document.alignments[0].target_coordinates, [0, 6, 9, 15]) + assert_eq(document.alignments[1].target_coordinates, [18, 12, 9, 3]) +} + +///| +test "Bio.Align.psl parse: empty input is rejected" { + assert_true(psl_test_parse_raises("\n\r\n")) +} + +///| +test "Bio.Align.psl parse: malformed header is rejected" { + assert_true(psl_test_parse_raises("psLayout bad 3\n-----\n")) +} + +///| +test "Bio.Align.psl parse: missing header separator is rejected" { + assert_true(psl_test_parse_raises("psLayout version 3\ncolumns only\n")) +} + +///| +test "Bio.Align.psl parse: wrong column count is rejected" { + assert_true(psl_test_parse_raises("1\t2\t3\n")) +} + +///| +test "Bio.Align.psl parse: integer trailing garbage is rejected" { + let fields = psl_test_fields() + fields[0] = "6oops" + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: integer overflow is rejected" { + let fields = psl_test_fields() + fields[10] = "2147483648" + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: unsupported strand is rejected" { + let fields = psl_test_fields() + fields[8] = "--" + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: zero block count is rejected" { + let fields = psl_test_fields() + fields[17] = "0" + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: block array count is validated" { + let fields = psl_test_fields() + fields[18] = "4," + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: empty CSV element is rejected" { + let fields = psl_test_fields() + fields[18] = "4,,4," + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: zero block size is rejected" { + let fields = psl_test_fields() + fields[18] = "4,0," + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: overlapping target blocks are rejected" { + let fields = psl_test_fields() + fields[20] = "2,5," + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: overlapping query blocks are rejected" { + let fields = psl_test_fields() + fields[19] = "1,4," + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: block beyond target size is rejected" { + let fields = psl_test_fields() + fields[14] = "12" + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: match category sum is validated" { + let fields = psl_test_fields() + fields[0] = "7" + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: query insertion statistics are validated" { + let fields = psl_test_fields() + fields[4] = "0" + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: target insertion statistics are validated" { + let fields = psl_test_fields() + fields[7] = "2" + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: query interval is validated" { + let fields = psl_test_fields() + fields[11] = "0" + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: target interval is validated" { + let fields = psl_test_fields() + fields[16] = "14" + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: PSLX sequence count is validated" { + let fields = psl_test_fields() + fields.push("ACGT,") + fields.push("ACGT,NNTA,") + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: PSLX fragment length is validated" { + let fields = psl_test_fields() + fields.push("ACG,NNAA,") + fields.push("ACGT,NNTA,") + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl parse: PSLX invalid residue delimiter is rejected" { + let fields = psl_test_fields() + fields.push("AC-T,NNAA,") + fields.push("ACGT,NNTA,") + assert_true(psl_test_parse_raises(psl_test_line(fields))) +} + +///| +test "Bio.Align.psl document: query and target filters" { + let config = @src.PslWriteConfig::create(header=false) catch { + _ => abort("valid config should construct") + } + let text = @src.psl_write( + [psl_test_forward(), psl_test_reverse(), psl_test_protein(false)], + config~, + ) catch { + _ => abort("valid multi-record PSL should write") + } + let document = @src.psl_parse(text) catch { + _ => abort("valid multi-record PSL should parse") + } + assert_eq(document.query("peptide").length(), 1) + assert_eq(document.query("missing").length(), 0) + assert_eq(document.target("chr1").length(), 1) +} + +///| +test "Bio.Align.psl document: summary aggregates path types" { + let fields = psl_test_fields() + fields.push("ACGT,NNAA,") + fields.push("ACGT,NNTA,") + let config = @src.PslWriteConfig::create(header=false) catch { + _ => abort("valid config should construct") + } + let text = psl_test_line(fields) + + (psl_test_protein(false).format(config~) catch { + _ => abort("valid translated PSL should format") + }) + let summary = (@src.psl_parse(text) catch { + _ => abort("valid mixed PSL should parse") + }).summary() + assert_eq(summary.alignment_count, 2) + assert_eq(summary.pslx_count, 1) + assert_eq(summary.nucleotide_count, 1) + assert_eq(summary.protein_count, 1) + assert_eq(summary.aligned_query_units, 12) + assert_eq(summary.query_insert_bases, 2) + assert_eq(summary.target_insert_bases, 6) +} + +///| +test "Bio.Align.psl document: parse-write round trip" { + let config = @src.PslWriteConfig::create(header=false) catch { + _ => abort("valid config should construct") + } + let initial = @src.psl_write( + [psl_test_forward(), psl_test_reverse(), psl_test_protein(true)], + config~, + ) catch { + _ => abort("valid PSL records should write") + } + let document = @src.psl_parse(initial) catch { + _ => abort("valid PSL records should parse") + } + let rewritten = document.write(config~) catch { + _ => abort("parsed PSL document should write") + } + assert_eq(rewritten, initial) +} + +///| +test "Bio.Align.psl document: header-only input is valid" { + let header = @src.psl_header() catch { + _ => abort("default PSL header should format") + } + let document = @src.psl_parse(header) catch { + _ => abort("header-only PSL should parse") + } + assert_true(document.has_header) + assert_eq(document.alignments.length(), 0) +} + +///| +test "Bio.Align.psl coordinate adapter: forward conversion" { + let coordinate = psl_test_forward().to_coordinate_alignment() catch { + _ => abort("forward PSL should adapt to coordinate alignment") + } + assert_eq(coordinate.target_name, "chr1") + assert_eq(coordinate.query_name, "query1") + assert_eq(coordinate.target_coordinates, [2, 6, 9, 9, 13]) + assert_eq(coordinate.query_coordinates, [1, 5, 5, 7, 11]) +} + +///| +test "Bio.Align.psl coordinate adapter: reverse nucleotide conversion" { + let coordinate = psl_test_reverse().to_coordinate_alignment() catch { + _ => abort("reverse-query PSL should adapt") + } + assert_eq(coordinate.query_coordinates, [8, 4, 4, 0]) +} + +///| +test "Bio.Align.psl coordinate adapter: reverse translated target is rejected" { + let raised = try { + ignore(psl_test_protein(true).to_coordinate_alignment()) + false + } catch { + PslError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.psl coordinate adapter: build from coordinate alignment" { + let coordinate = @src.coordinate_pairwise_alignment_with_lengths( + "target", + 20, + "query", + 20, + [2, 6, 9, 13], + [1, 5, 5, 9], + ) catch { + _ => abort("valid coordinate alignment should construct") + } + let alignment = @src.psl_from_coordinate_alignment(coordinate) catch { + _ => abort("coordinate alignment should convert to PSL") + } + assert_eq(alignment.target_coordinates, [2, 6, 9, 13]) + assert_eq(alignment.query_coordinates, [1, 5, 5, 9]) + assert_eq(alignment.counts().target_insert_bases, 3) +} + +///| +test "Bio.Align.psl example data: all records construct and summarize" { + let alignments = @src.psl_example_data() catch { + PslError(message) => abort("PSL example data failed: " + message) + } + assert_eq(alignments.length(), 3) + assert_false(alignments[0].is_reverse()) + assert_true(alignments[1].is_reverse()) + assert_true(alignments[2].sequence_type is @src.PslSequenceType::PslProtein) +} From 850f438b8e49ccf50d463fb7feec59874218bd75 Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 16:41:26 +0800 Subject: [PATCH 29/41] #28 feat(banksy): Bioconductor Banksy & banksy & lambda & PCA & k-means & SpatialExperiment --- README.md | 25 +- examples/banksy_demo/main.mbt | 183 +++ examples/banksy_demo/moon.pkg | 5 + src/banksy.mbt | 2070 +++++++++++++++++++++++++++++++++ test/moonbit/banksy_test.mbt | 1479 +++++++++++++++++++++++ 5 files changed, 3758 insertions(+), 4 deletions(-) create mode 100644 examples/banksy_demo/main.mbt create mode 100644 examples/banksy_demo/moon.pkg create mode 100644 src/banksy.mbt create mode 100644 test/moonbit/banksy_test.mbt diff --git a/README.md b/README.md index e7f227ac..166af11c 100644 --- a/README.md +++ b/README.md @@ -214,6 +214,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **variancePartition** | Bioconductor variancePartition | 重复测量线性混合模型、方差分解、BLUP、precision weights、dream contrast与Satterthwaite检验 | ✅ | | **dreamlet** | Bioconductor dreamlet | sample×cell-type pseudobulk、TMM、cell/sample/gene过滤、logCPM、Poisson/voom precision weights、分cell-type重复测量模型及study-wide FDR | ✅ | | **nnSVG** | Bioconductor nnSVG | nearest-neighbor Gaussian process、空间变异基因检验、gene-specific length scale、协变量设计、空间方差占比、BH-FDR及SpatialExperiment接入 | ✅ | +| **Banksy** | Bioconductor Banksy | H0邻域均值与H1+方位harmonic、六类空间核、lambda联合特征、分组标准化、PCA、多起点k-means、标签平滑、参数扫描及SpatialExperiment接入 | ✅ | | **ALDEx2** | Bioconductor ALDEx2 | Dirichlet Monte Carlo组成型差异丰度、六类denominator、Welch/Wilcoxon与配对检验、effect/overlap、Aitchison距离及SummarizedExperiment接入 | ✅ | | **DirichletMultinomial** | Bioconductor DirichletMultinomial | Dirichlet-multinomial概率、有限混合EM/BFGS聚类、Laplace/AIC/BIC选K、生成式分组分类、分层交叉验证、ROC及SummarizedExperiment接入 | ✅ | | **SummarizedExperiment** | Bioconductor SummarizedExperiment | 多维基因组数据容器、Assays、行/列操作 | ✅ | @@ -581,6 +582,7 @@ IvanAXu/BioSeqs/ │ ├── variance_partition.mbt # variancePartition 混合模型方差分解、BLUP与dream重复测量检验 │ ├── dreamlet.mbt # dreamlet pseudobulk、TMM/voom权重、分cell-type混合模型与study-wide FDR │ ├── nnsvg.mbt # nnSVG nearest-neighbor GP、空间变异检验、length scale与SpatialExperiment接入 +│ ├── banksy.mbt # Banksy空间邻域harmonic、lambda联合特征、PCA、聚类、平滑与SpatialExperiment接入 │ ├── monocle3.mbt # monocle3 单细胞轨迹分析 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read.mbt # ShortRead 短读序列质量控制 (QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告) │ ├── seq_quality_trim.mbt # NGS质量修剪与接头去除 (质量修剪、接头去除、poly-A修剪、长度/GC过滤、批量修剪) @@ -934,6 +936,7 @@ IvanAXu/BioSeqs/ │ ├── variance_partition_demo/ # variancePartition 方差分解、BLUP、precision weights、dream与SE接入示例 │ ├── dreamlet_demo/ # dreamlet SCE pseudobulk、TMM/voom、donor随机截距与跨cell-type FDR示例 │ ├── nnsvg_demo/ # nnSVG空间变异基因、length scale、过滤与SpatialExperiment接入示例 +│ ├── banksy_demo/ # Banksy H0/H1、lambda扫描、PCA聚类、平滑与SpatialExperiment接入示例 │ ├── monocle3_demo/ # monocle3 单细胞轨迹分析示例 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read_demo/ # ShortRead 短读序列质量控制示例 (QA统计、adapter修剪、质量修剪、FastQC报告) │ ├── scater_demo/ # scater 单细胞质量控制示例 (QC指标计算、细胞/基因过滤、标准化、HVG检测、PCA) @@ -1348,6 +1351,7 @@ IvanAXu/BioSeqs/ │ │ ├── variance_partition_test.mbt │ │ ├── dreamlet_test.mbt │ │ ├── nnsvg_test.mbt +│ │ ├── banksy_test.mbt │ │ ├── shared_reference_alignment_test.mbt │ │ ├── alignment_map_test.mbt │ │ ├── alignment_counts_test.mbt @@ -1532,7 +1536,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 9561 个测试全部通过 +moon test # ✅ 9639 个测试全部通过 ``` ### 模块对照表 @@ -1643,6 +1647,7 @@ moon test # ✅ 9561 个测试全 | `variance_partition.mbt` | Bioconductor variancePartition | 多随机截距LMM、ML/REML方差分量、固定/随机/残差占比、BLUP、precision weights、dream contrast、数值Satterthwaite与BH-FDR | | `dreamlet.mbt` | Bioconductor dreamlet | sample×cell-type pseudobulk、完整TMM、CPM/logCPM、Poisson/voom权重、typed fixed/random design、分cell-type dream拟合及两级BH-FDR | | `nnsvg.mbt` | Bioconductor nnSVG | 坐标缩放与前驱kNN、指数协方差NNGP、协变量GLS、profile ML、空间/非空间LR检验、gene-specific length scale、BH-FDR及SpatialExperiment接入 | +| `banksy.mbt` | Bioconductor Banksy | H0邻域均值、H1+方位Fourier/Gabor harmonic、六类空间核、lambda联合矩阵、分组标准化、PCA、多起点k-means、平滑、ARI与SpatialExperiment接入 | | `decontx.mbt` | Bioconductor decontX | cluster-native/contaminant多项式混合、Beta/Dirichlet先验EM、background、自动聚类、计数分解与SCE输出 | | `summarized_experiment.mbt` | Bioconductor SummarizedExperiment | 多维数据容器 | | `ranged_summarized_experiment.mbt` | Bioconductor RangedSummarizedExperiment | GRanges/GRangesList行范围、链特异重叠/最近邻、覆盖度、区间变换与协调子集 | @@ -1856,6 +1861,7 @@ moon test # ✅ 9561 个测试全 | `variance_partition.mbt` | `variancePartition` | typed fixed/random design、多随机截距LMM、ML/REML方差分解、BLUP、weighted dream contrast、Satterthwaite自由度与SummarizedExperiment入口 | | `dreamlet.mbt` | `dreamlet` | SCE到sample×cluster pseudobulk、TMM/logCPM、两阶段voom precision weights、固定/随机效应筛选、逐cell-type dream和study-wide FDR | | `nnsvg.mbt` | `nnSVG` | AMMD/坐标和排序前驱kNN、指数协方差NNGP、covariate GLS、空间方差比例与length scale优化、LR/p-value/BH-FDR、过滤和SpatialExperiment rowData输出 | +| `banksy.mbt` | `Banksy` | kNN/radius邻域核、H0/H1+空间harmonic、lambda加权BANKSY矩阵、global/group scaling、Gram-Jacobi PCA、确定性多起点聚类、平滑与SpatialExperiment输出 | | `shared_reference_alignment.mbt` | `Bio.Align.Alignment` | 同参考PWA/MSA的reference-boundary insertion同步、原query投影、局部坐标、metadata、统计与格式转换 | | `alignment_map.mbt` | `Bio.Align.Alignment.map/mapall` | 两层alignment坐标组合、正反链与gap传播、PSL、批量映射及protein/nucleotide MSA投影 | | `alignment_counts.mbt` | `Bio.Align.Alignment.counts` | pairwise/MSA gap事件和composition汇总、正反链、wildcard、替换矩阵及完整affine评分 | @@ -3054,6 +3060,14 @@ BTOP 和 FASTA CIGAR 会合并连续 operation 并重建显式 target/query coor 解析器严格拒绝非十进制或溢出整数、非法 strand/列数、blockCount 与 CSV/PSLX 数量不一致、零长度/重叠/逆序/越界 block、首尾 gap、错误的核酸 1:1 或 translated 3:1 比例、match 分类总和、q/t insertion 统计及声明区间不一致。该模块负责普通文本 PSL/PSLX；`search_io.mbt` 继续提供简化的 BLAT 搜索结果适配，`bigpsl.mbt` 负责 bed12+13 BigBed 二进制索引。 +### 264. 空间邻域增强聚类 (Bioconductor Banksy) + +实现 Bioconductor `Banksy` 1.9.1 的空间转录组邻域增强特征与聚类工作流。输入统一为 gene × spot 表达矩阵及 spot × dimension 坐标；`H0` 计算归一化加权邻域均值，`H1+` 在局部非加权均值中心化后计算方位 Fourier/Gabor harmonic 幅值。支持 `kNN_median`、inverse-distance、inverse-power、rank、uniform 和 radius-Gaussian 六类空间核、每阶独立邻域大小、确定性邻居采样，以及二维方位角和多维欧氏距离。 + +`banksy_get_matrix` 按 `sqrt(1-lambda)` 加权原始表达，并将 `lambda * 2^-m` 在 `H0..HM` 间归一化后开方加权；支持全局或按 section/sample 分组的 feature 标准化。下游提供 spots Gram 矩阵上的 Jacobi PCA、确定性 farthest-point 多起点 k-means、空 cluster 重播种、silhouette、空间近邻一致率、Adjusted Rand Index、同步标签平滑和多 lambda 参数扫描，适配 cell typing 与 tissue domain segmentation 两类用法。 + +`banksy_spatial_experiment` 从指定 assay、rowData、colData 和二维/三维 spatial coordinates 构建模型，在不可变容器副本中写回 `H0..HM` assays、原始/平滑 cluster 标签与 metadata。所有入口校验矩阵方向、矩形性、有限值、名称唯一性、邻域/采样边界、lambda、PCA/聚类维度及分组完整性。当前实现使用 dense MoonBit arrays、确定性单线程 Jacobi PCA 与 k-means，不依赖 R、BiocParallel、igraph、Leiden 或稀疏矩阵后端。 + ## 性能优化 ### 优化策略 @@ -3155,8 +3169,8 @@ BTOP 和 FASTA CIGAR 会合并连续 operation 并重建显式 target/query coor | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 9561 | -| 通过数 | 9561 | +| 总测试数 | 9639 | +| 通过数 | 9639 | | 失败数 | 0 | | 通过率 | 100% | @@ -3472,6 +3486,7 @@ moon test --update | Bioconductor variancePartition | `variance_partition_test.mbt` | 38 | | Bioconductor dreamlet | `dreamlet_test.mbt` | 58 | | Bioconductor nnSVG | `nnsvg_test.mbt` | 67 | +| Bioconductor Banksy | `banksy_test.mbt` | 78 | | Bio.PopGen.GenePop | `gene_pop_test.mbt` | 34 | | Bioconductor stageR | `stage_r_test.mbt` | 25 | | Bioconductor EnrichedHeatmap | `enriched_heatmap_test.mbt` | 20 | @@ -3567,7 +3582,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 371 个示例程序，展示各模块的典型用法： +项目提供 372 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3760,6 +3775,7 @@ moon run cmd/bench/main.mbt | variance_partition_demo | typed固定/随机设计、ML方差分解、BLUP、precision weights、dream contrast与SummarizedExperiment接入 | `moon run examples/variance_partition_demo` | | dreamlet_demo | SingleCellExperiment pseudobulk、TMM/logCPM、Poisson/voom权重、donor随机截距和跨cell-type FDR | `moon run examples/dreamlet_demo` | | nnsvg_demo | nearest-neighbor GP空间变异基因检验、length scale、空间方差占比、基因过滤与SpatialExperiment接入 | `moon run examples/nnsvg_demo` | +| banksy_demo | H0/H1空间邻域特征、cell-typing/domain lambda、PCA聚类、标签平滑、参数扫描与SpatialExperiment接入 | `moon run examples/banksy_demo` | | shared_reference_alignment_demo | 共享参考PWA/MSA合并、reference insertion同步、坐标映射、统计、MSA与aligned FASTA转换 | `moon run examples/shared_reference_alignment_demo` | | alignment_map_demo | chromosome→transcript→read坐标组合、intron gap、反链、坐标查询、PSL与protein-to-codon MSA投影 | `moon run examples/alignment_map_demo` | | alignment_counts_demo | left/internal/right gap与open/extend、affine/BLOSUM45评分、反向链和MSA逐对汇总 | `moon run examples/alignment_counts_demo` | @@ -3887,6 +3903,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bioconductor ALDEx2 组成型差异丰度（Dirichlet Monte Carlo、六类denominator、两组/配对检验、posterior expected BH、effect/overlap、距离与SummarizedExperiment接入） - ✅ 实现 Bioconductor DirichletMultinomial 混合聚类与分类（DMM概率、soft k-means、log-alpha BFGS/EM、Gamma prior、Laplace/AIC/BIC、dmngroup分类、分层CV、ROC与SummarizedExperiment接入） - ✅ 实现 Bioconductor nnSVG 空间变异基因检测（坐标缩放与前驱kNN、指数协方差NNGP、covariate GLS、gene-specific length scale、空间/非空间LR检验、BH-FDR与SpatialExperiment接入） +- ✅ 实现 Bioconductor Banksy 空间邻域增强聚类（六类空间核、H0/H1+、lambda联合矩阵、分组标准化、PCA、多起点k-means、标签平滑、参数扫描与SpatialExperiment接入） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） diff --git a/examples/banksy_demo/main.mbt b/examples/banksy_demo/main.mbt new file mode 100644 index 00000000..48d9e83f --- /dev/null +++ b/examples/banksy_demo/main.mbt @@ -0,0 +1,183 @@ +// Bioconductor Banksy-inspired spatial clustering workflow. + +///| +fn banksy_demo_config() -> @src.BanksyComputeConfig { + @src.BanksyComputeConfig::create( + max_harmonic=1, + k_geom=[4, 4], + spatial_mode=@src.banksy_knn_median(), + seed=7, + ) catch { + BanksyError(message) => abort("invalid BANKSY configuration: " + message) + } +} + +///| +fn banksy_demo_cluster_config() -> @src.BanksyClusterConfig { + @src.BanksyClusterConfig::create( + n_clusters=2, + n_starts=8, + max_iterations=100, + tolerance=1.0e-8, + seed=3, + ) catch { + BanksyError(message) => + abort("invalid BANKSY cluster configuration: " + message) + } +} + +///| +fn main { + println("=== Bioconductor Banksy Demo ===") + let (expression, coordinates, gene_names, spot_names) = @src.banksy_example_data() + let config = banksy_demo_config() + let model = @src.banksy_compute_with_config( + expression, + coordinates, + config, + gene_names~, + spot_names~, + ) catch { + BanksyError(message) => + abort("BANKSY feature computation failed: " + message) + } + + println("\n1. Compute spatial neighborhood harmonics") + println(" " + model.summary()) + println( + " first spot left_marker: expression=" + + model.expression[0][0].to_string() + + ", H0=" + + model.harmonics[0][0][0].to_string() + + ", H1=" + + model.harmonics[1][0][0].to_string(), + ) + let mut weight_sum = 0.0 + for neighbor in model.neighbors[0][0] { + weight_sum = weight_sum + neighbor.weight + } + println( + " H0 neighbors=" + + model.neighbors[0][0].length().to_string() + + ", normalized weight sum=" + + weight_sum.to_string(), + ) + + println("\n2. Compare cell-typing and spatial-domain lambda values") + let typing = @src.banksy_run( + model, + lambda=0.2, + n_components=3, + cluster_config=banksy_demo_cluster_config(), + max_harmonic=1, + scale=true, + smooth=true, + smoothing_k=3, + smoothing_threshold=0.5, + smoothing_iterations=10, + ) catch { + BanksyError(message) => abort("BANKSY cell-typing run failed: " + message) + } + let domains = @src.banksy_run( + model, + lambda=0.8, + n_components=3, + cluster_config=banksy_demo_cluster_config(), + max_harmonic=1, + scale=true, + smooth=true, + smoothing_k=3, + smoothing_threshold=0.5, + smoothing_iterations=10, + ) catch { + BanksyError(message) => abort("BANKSY domain run failed: " + message) + } + println(" lambda=0.2: " + typing.summary()) + println(" lambda=0.8: " + domains.summary()) + println( + " PCA dimensions=" + + typing.pca.n_spots().to_string() + + "x" + + typing.pca.n_components.to_string() + + ", cluster sizes=" + + typing.clustering.cluster_sizes.to_string(), + ) + let ari = @src.banksy_adjusted_rand_index( + typing.final_labels(), + domains.final_labels(), + ) catch { + BanksyError(message) => abort("BANKSY ARI failed: " + message) + } + println(" adjusted Rand index between lambda runs=" + ari.to_string()) + + println("\n3. Sweep spatial weights") + let sweep = @src.banksy_parameter_sweep( + model, + [0.0, 0.2, 0.5, 0.8], + n_components=3, + cluster_config=banksy_demo_cluster_config(), + max_harmonic=1, + scale=true, + ) catch { + BanksyError(message) => abort("BANKSY parameter sweep failed: " + message) + } + for run in sweep { + println( + " lambda=" + + run.lambda.to_string() + + ", silhouette=" + + run.clustering.silhouette.to_string() + + ", spatial agreement=" + + run.spatial_agreement.to_string(), + ) + } + + println("\n4. Enrich an immutable SpatialExperiment") + let experiment = @src.SpatialExperiment::new() + ignore(@src.se_add_assay(experiment, "logcounts", expression)) + for gene_name in gene_names { + ignore(@src.se_add_row(experiment, Map([("gene_name", gene_name)]))) + } + for spot in 0.. + abort("BANKSY SpatialExperiment integration failed: " + message) + } + println( + " assays include H0=" + + integrated.experiment.assay.contains("H0").to_string() + + ", H1=" + + integrated.experiment.assay.contains("H1").to_string(), + ) + println( + " first cluster=" + + integrated.experiment.col_data[0]["banksy_cluster"] + + ", input remains unchanged=" + + (!experiment.assay.contains("H0")).to_string(), + ) + println("=== Demo Complete ===") +} diff --git a/examples/banksy_demo/moon.pkg b/examples/banksy_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/banksy_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/banksy.mbt b/src/banksy.mbt new file mode 100644 index 00000000..59ec00d4 --- /dev/null +++ b/src/banksy.mbt @@ -0,0 +1,2070 @@ +// Spatially aware clustering inspired by the Bioconductor Banksy package. +// +// Expression matrices use genes in rows and spots in columns. Neighborhood +// harmonics follow Banksy's H0, H1, ... convention: +// H0 = weighted neighborhood mean +// Hm = |sum_j weight_ij * centered(x_j) * exp(i * m * phi_ij)| + +///| +pub suberror BanksyError { + BanksyError(String) +} + +///| +pub(all) enum BanksySpatialMode { + BanksyKnnMedian + BanksyKnnInverseDistance + BanksyKnnInversePower + BanksyKnnRank + BanksyKnnUniform + BanksyRadiusGaussian +} derive(Eq, Debug) + +///| +pub fn banksy_knn_median() -> BanksySpatialMode { + BanksyKnnMedian +} + +///| +pub fn banksy_knn_inverse_distance() -> BanksySpatialMode { + BanksyKnnInverseDistance +} + +///| +pub fn banksy_knn_inverse_power() -> BanksySpatialMode { + BanksyKnnInversePower +} + +///| +pub fn banksy_knn_rank() -> BanksySpatialMode { + BanksyKnnRank +} + +///| +pub fn banksy_knn_uniform() -> BanksySpatialMode { + BanksyKnnUniform +} + +///| +pub fn banksy_radius_gaussian() -> BanksySpatialMode { + BanksyRadiusGaussian +} + +///| +pub struct BanksyComputeConfig { + max_harmonic : Int + k_geom : Array[Int] + spatial_mode : BanksySpatialMode + distance_power : Double + sigma : Double + alpha : Double + k_spatial : Int + sample_size : Int + sample_renormalize : Bool + seed : Int + center_harmonics : Bool +} derive(Debug) + +///| +pub fn BanksyComputeConfig::create( + max_harmonic? : Int = 0, + k_geom? : Array[Int] = [15], + spatial_mode? : BanksySpatialMode = BanksyKnnMedian, + distance_power? : Double = 2.0, + sigma? : Double = 1.5, + alpha? : Double = 0.05, + k_spatial? : Int = 100, + sample_size? : Int = 0, + sample_renormalize? : Bool = true, + seed? : Int = 1, + center_harmonics? : Bool = true, +) -> BanksyComputeConfig raise BanksyError { + if max_harmonic < 0 { + raise BanksyError("BANKSY maximum harmonic must be non-negative") + } + if k_geom.length() != 1 && k_geom.length() != max_harmonic + 1 { + raise BanksyError( + "BANKSY k_geom must contain one value or one value per harmonic", + ) + } + for value in k_geom { + if value < 1 { + raise BanksyError("BANKSY k_geom values must be positive") + } + } + if !banksy_is_finite(distance_power) || distance_power <= 0.0 { + raise BanksyError("BANKSY distance power must be finite and positive") + } + if !banksy_is_finite(sigma) || sigma <= 0.0 { + raise BanksyError("BANKSY Gaussian sigma must be finite and positive") + } + if !banksy_is_finite(alpha) || alpha <= 0.0 || alpha >= 1.0 { + raise BanksyError("BANKSY radial alpha must be finite and in (0, 1)") + } + if k_spatial < 1 { + raise BanksyError("BANKSY radial neighbor count must be positive") + } + if sample_size < 0 { + raise BanksyError("BANKSY sample size must be non-negative") + } + if seed < 0 { + raise BanksyError("BANKSY seed must be non-negative") + } + BanksyComputeConfig::{ + max_harmonic, + k_geom: k_geom.copy(), + spatial_mode, + distance_power, + sigma, + alpha, + k_spatial, + sample_size, + sample_renormalize, + seed, + center_harmonics, + } +} + +///| +pub fn BanksyComputeConfig::default() -> BanksyComputeConfig { + BanksyComputeConfig::{ + max_harmonic: 0, + k_geom: [15], + spatial_mode: BanksyKnnMedian, + distance_power: 2.0, + sigma: 1.5, + alpha: 0.05, + k_spatial: 100, + sample_size: 0, + sample_renormalize: true, + seed: 1, + center_harmonics: true, + } +} + +///| +pub struct BanksyNeighbor { + index : Int + distance : Double + weight : Double + angle : Double +} derive(Eq, Debug) + +///| +pub struct BanksyModel { + expression : Array[Array[Double]] + coordinates : Array[Array[Double]] + gene_names : Array[String] + spot_names : Array[String] + harmonics : Array[Array[Array[Double]]] + neighbors : Array[Array[Array[BanksyNeighbor]]] + config : BanksyComputeConfig +} derive(Debug) + +///| +pub struct BanksyMatrix { + values : Array[Array[Double]] + feature_names : Array[String] + component_weights : Array[Double] + lambda : Double + max_harmonic : Int + scaled : Bool +} derive(Debug) + +///| +pub struct BanksyPcaResult { + scores : Array[Array[Double]] + loadings : Array[Array[Double]] + eigenvalues : Array[Double] + variance_explained : Array[Double] + n_components : Int +} derive(Debug) + +///| +pub struct BanksyClusterConfig { + n_clusters : Int + n_starts : Int + max_iterations : Int + tolerance : Double + seed : Int +} derive(Eq, Debug) + +///| +pub fn BanksyClusterConfig::create( + n_clusters? : Int = 5, + n_starts? : Int = 10, + max_iterations? : Int = 100, + tolerance? : Double = 1.0e-6, + seed? : Int = 1, +) -> BanksyClusterConfig raise BanksyError { + if n_clusters < 1 { + raise BanksyError("BANKSY cluster count must be positive") + } + if n_starts < 1 { + raise BanksyError("BANKSY k-means start count must be positive") + } + if max_iterations < 1 { + raise BanksyError("BANKSY k-means iteration limit must be positive") + } + if !banksy_is_finite(tolerance) || tolerance <= 0.0 { + raise BanksyError("BANKSY k-means tolerance must be finite and positive") + } + if seed < 0 { + raise BanksyError("BANKSY k-means seed must be non-negative") + } + BanksyClusterConfig::{ n_clusters, n_starts, max_iterations, tolerance, seed } +} + +///| +pub fn BanksyClusterConfig::default() -> BanksyClusterConfig { + BanksyClusterConfig::{ + n_clusters: 5, + n_starts: 10, + max_iterations: 100, + tolerance: 1.0e-6, + seed: 1, + } +} + +///| +pub struct BanksyClusterResult { + labels : Array[Int] + centroids : Array[Array[Double]] + cluster_sizes : Array[Int] + inertia : Double + iterations : Int + converged : Bool + silhouette : Double +} derive(Debug) + +///| +pub struct BanksySmoothingResult { + labels : Array[Int] + iterations : Int + changed_labels : Int + converged : Bool +} derive(Eq, Debug) + +///| +pub struct BanksyRun { + lambda : Double + matrix : BanksyMatrix + pca : BanksyPcaResult + clustering : BanksyClusterResult + smoothing : BanksySmoothingResult? + spatial_agreement : Double +} derive(Debug) + +///| +pub struct BanksySpatialExperimentOutput { + experiment : SpatialExperiment + model : BanksyModel + run : BanksyRun +} + +///| +priv struct BanksyDistanceIndex { + index : Int + distance : Double +} + +///| +priv struct BanksyKmeansFit { + labels : Array[Int] + centroids : Array[Array[Double]] + inertia : Double + iterations : Int + converged : Bool +} + +///| +fn banksy_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn banksy_zero_matrix(rows : Int, columns : Int) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for _ in 0.. Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in matrix { + output.push(row.copy()) + } + output +} + +///| +fn banksy_validate_names( + names : Array[String], + expected : Int, + prefix : String, + label : String, +) -> Array[String] raise BanksyError { + if names.length() == 0 { + let generated : Array[String] = [] + for index in 0.. (Int, Int, Array[String], Array[String]) raise BanksyError { + if expression.length() == 0 { + raise BanksyError("BANKSY expression must contain at least one gene") + } + let spots = expression[0].length() + if spots < 2 { + raise BanksyError("BANKSY expression must contain at least two spots") + } + for row in expression { + if row.length() != spots { + raise BanksyError("BANKSY expression must be rectangular") + } + for value in row { + if !banksy_is_finite(value) { + raise BanksyError("BANKSY expression values must be finite") + } + } + } + if coordinates.length() != spots { + raise BanksyError("BANKSY coordinates must contain one row per spot") + } + let dimensions = coordinates[0].length() + if dimensions < 2 { + raise BanksyError("BANKSY coordinates require at least two dimensions") + } + for coordinate in coordinates { + if coordinate.length() != dimensions { + raise BanksyError("BANKSY coordinates must be rectangular") + } + for value in coordinate { + if !banksy_is_finite(value) { + raise BanksyError("BANKSY coordinates must be finite") + } + } + } + let genes = expression.length() + let checked_genes = banksy_validate_names(gene_names, genes, "gene_", "gene") + let checked_spots = banksy_validate_names(spot_names, spots, "spot_", "spot") + (genes, spots, checked_genes, checked_spots) +} + +///| +fn banksy_distance( + coordinates : Array[Array[Double]], + first : Int, + second : Int, +) -> Double { + let mut squared = 0.0 + for dimension in 0.. Double { + let dx = coordinates[to][0] - coordinates[from][0] + let dy = coordinates[to][1] - coordinates[from][1] + let angle = @math.atan2(dy, dx) + if angle < 0.0 { + angle + 2.0 * 3.141592653589793 + } else { + angle + } +} + +///| +fn banksy_sorted_distances( + coordinates : Array[Array[Double]], + source : Int, +) -> Array[BanksyDistanceIndex] { + let distances : Array[BanksyDistanceIndex] = [] + for target in 0.. Int { + if left.distance < right.distance { + -1 + } else if left.distance > right.distance { + 1 + } else if left.index < right.index { + -1 + } else if left.index > right.index { + 1 + } else { + 0 + } + }) + distances +} + +///| +fn banksy_median(values : Array[Double]) -> Double { + if values.length() == 0 { + return 0.0 + } + let sorted = values.copy() + sorted.sort() + let middle = sorted.length() / 2 + if sorted.length() % 2 == 1 { + sorted[middle] + } else { + (sorted[middle - 1] + sorted[middle]) / 2.0 + } +} + +///| +fn banksy_sample_order( + length : Int, + sample_size : Int, + seed : Int, + source : Int, +) -> Array[Int] { + let order : Array[Int] = [] + for index in 0..= length { + return order + } + let scores : Array[Int] = Array::make(length, 0) + for index in 0.. Int { + if scores[left] < scores[right] { + -1 + } else if scores[left] > scores[right] { + 1 + } else if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + let selected : Array[Int] = [] + for index in 0.. Array[BanksyNeighbor] { + let mut total = 0.0 + for neighbor in neighbors { + total = total + neighbor.weight + } + if total <= 0.0 { + return neighbors + } + let normalized : Array[BanksyNeighbor] = [] + for neighbor in neighbors { + normalized.push(BanksyNeighbor::{ + ..neighbor, + weight: neighbor.weight / total, + }) + } + normalized +} + +///| +fn banksy_global_nearest_median(coordinates : Array[Array[Double]]) -> Double { + let nearest : Array[Double] = [] + for source in 0.. 0 { + nearest.push(sorted[0].distance) + } + } + banksy_median(nearest).max(1.0e-12) +} + +///| +fn banksy_neighbor_graph( + coordinates : Array[Array[Double]], + config : BanksyComputeConfig, + harmonic : Int, +) -> Array[Array[BanksyNeighbor]] raise BanksyError { + let spots = coordinates.length() + let k_geom = if config.k_geom.length() == 1 { + config.k_geom[0] + } else { + config.k_geom[harmonic] + } + let requested = match config.spatial_mode { + BanksyRadiusGaussian => config.k_spatial + _ => k_geom + } + if requested >= spots { + raise BanksyError( + "BANKSY neighbor count must be smaller than the number of spots", + ) + } + if config.sample_size > requested { + raise BanksyError( + "BANKSY sample size must not exceed the available neighbor count", + ) + } + let nearest_median = if config.spatial_mode is BanksyRadiusGaussian { + banksy_global_nearest_median(coordinates) + } else { + 1.0 + } + let radius = config.sigma * + (-coordinates[0].length().to_double() * @math.ln(config.alpha)).sqrt() * + nearest_median + let graph : Array[Array[BanksyNeighbor]] = [] + for source in 0..= radius { + continue + } + let safe_distance = candidate.distance.max(1.0e-12) + let weight = match config.spatial_mode { + BanksyKnnMedian => + @math.exp( + -(candidate.distance * candidate.distance) / + (local_median * local_median), + ) + BanksyKnnInverseDistance => 1.0 / safe_distance + BanksyKnnInversePower => + 1.0 / @math.pow(safe_distance, config.distance_power) + BanksyKnnRank => { + let rank_value = (rank + 1).to_double() + let width = requested.to_double() / 1.5 + @math.exp(-(rank_value * rank_value) / (2.0 * width * width)) + } + BanksyKnnUniform => 1.0 + BanksyRadiusGaussian => + @math.exp( + -0.5 * + (candidate.distance / (nearest_median * config.sigma)) * + (candidate.distance / (nearest_median * config.sigma)), + ) + } + raw.push(BanksyNeighbor::{ + index: candidate.index, + distance: candidate.distance, + weight, + angle: banksy_angle(coordinates, source, candidate.index), + }) + } + if raw.length() == 0 { + let candidate = sorted[0] + raw.push(BanksyNeighbor::{ + index: candidate.index, + distance: candidate.distance, + weight: 1.0, + angle: banksy_angle(coordinates, source, candidate.index), + }) + } + let normalized = banksy_normalize_neighbors(raw) + if config.sample_size > 0 && config.sample_size < normalized.length() { + let order = banksy_sample_order( + normalized.length(), + config.sample_size, + config.seed + harmonic * 7919, + source, + ) + let sampled : Array[BanksyNeighbor] = [] + for index in order { + sampled.push(normalized[index]) + } + if config.sample_renormalize { + graph.push(banksy_normalize_neighbors(sampled)) + } else { + graph.push(sampled) + } + } else { + graph.push(normalized) + } + } + graph +} + +///| +fn banksy_compute_harmonic( + expression : Array[Array[Double]], + graph : Array[Array[BanksyNeighbor]], + harmonic : Int, + center : Bool, +) -> Array[Array[Double]] { + let genes = expression.length() + let spots = graph.length() + let output = banksy_zero_matrix(genes, spots) + for gene in 0.. 0 && center { + for neighbor in neighborhood { + local_mean = local_mean + expression[gene][neighbor.index] + } + local_mean = local_mean / neighborhood.length().to_double() + } + if harmonic == 0 { + let mut value = 0.0 + for neighbor in neighborhood { + value = value + neighbor.weight * expression[gene][neighbor.index] + } + output[gene][spot] = value + } else { + let mut real = 0.0 + let mut imaginary = 0.0 + for neighbor in neighborhood { + let value = expression[gene][neighbor.index] - local_mean + let phase = harmonic.to_double() * neighbor.angle + real = real + neighbor.weight * value * @math.cos(phase) + imaginary = imaginary + neighbor.weight * value * @math.sin(phase) + } + output[gene][spot] = (real * real + imaginary * imaginary).sqrt() + } + } + } + output +} + +///| +pub fn banksy_compute_with_config( + expression : Array[Array[Double]], + coordinates : Array[Array[Double]], + config : BanksyComputeConfig, + gene_names? : Array[String] = [], + spot_names? : Array[String] = [], +) -> BanksyModel raise BanksyError { + let (_, _, checked_genes, checked_spots) = banksy_validate_input( + expression, coordinates, gene_names, spot_names, + ) + let harmonics : Array[Array[Array[Double]]] = [] + let graphs : Array[Array[Array[BanksyNeighbor]]] = [] + for harmonic in 0..<=config.max_harmonic { + let graph = banksy_neighbor_graph(coordinates, config, harmonic) + let values = banksy_compute_harmonic( + expression, + graph, + harmonic, + harmonic > 0 && config.center_harmonics, + ) + graphs.push(graph) + harmonics.push(values) + } + BanksyModel::{ + expression: banksy_copy_matrix(expression), + coordinates: banksy_copy_matrix(coordinates), + gene_names: checked_genes, + spot_names: checked_spots, + harmonics, + neighbors: graphs, + config, + } +} + +///| +pub fn banksy_compute( + expression : Array[Array[Double]], + coordinates : Array[Array[Double]], + k_geom? : Int = 15, + compute_agf? : Bool = false, + gene_names? : Array[String] = [], + spot_names? : Array[String] = [], +) -> BanksyModel raise BanksyError { + let config = BanksyComputeConfig::create( + max_harmonic=if compute_agf { 1 } else { 0 }, + k_geom=[k_geom], + ) + banksy_compute_with_config( + expression, + coordinates, + config, + gene_names~, + spot_names~, + ) +} + +///| +pub fn BanksyModel::n_genes(self : BanksyModel) -> Int { + self.expression.length() +} + +///| +pub fn BanksyModel::n_spots(self : BanksyModel) -> Int { + if self.expression.length() == 0 { + 0 + } else { + self.expression[0].length() + } +} + +///| +pub fn BanksyModel::max_harmonic(self : BanksyModel) -> Int { + self.harmonics.length() - 1 +} + +///| +pub fn BanksyModel::harmonic( + self : BanksyModel, + order : Int, +) -> Array[Array[Double]]? { + if order < 0 || order >= self.harmonics.length() { + None + } else { + Some(banksy_copy_matrix(self.harmonics[order])) + } +} + +///| +pub fn BanksyModel::summary(self : BanksyModel) -> String { + "BANKSY model: " + + self.n_genes().to_string() + + " genes, " + + self.n_spots().to_string() + + " spots, H0-H" + + self.max_harmonic().to_string() +} + +///| +fn banksy_validate_groups( + groups : Array[String], + spots : Int, +) -> Array[String] raise BanksyError { + if groups.length() == 0 { + return [] + } + if groups.length() != spots { + raise BanksyError("BANKSY scaling groups must contain one label per spot") + } + for group in groups { + if group.length() == 0 { + raise BanksyError("BANKSY scaling group labels must not be empty") + } + } + groups.copy() +} + +///| +fn banksy_scale_component( + matrix : Array[Array[Double]], + groups : Array[String], +) -> Array[Array[Double]] { + let output = banksy_copy_matrix(matrix) + if matrix.length() == 0 { + return output + } + let spots = matrix[0].length() + if groups.length() == 0 { + for row in 0.. 1 { + (sum_square / (spots - 1).to_double()).sqrt() + } else { + 0.0 + } + for spot in 0.. 1.0e-14 { + (matrix[row][spot] - mean) / standard_deviation + } else { + 0.0 + } + } + } + return output + } + let unique : Array[String] = [] + let seen : Map[String, Bool] = Map([]) + for group in groups { + if !seen.contains(group) { + seen[group] = true + unique.push(group) + } + } + for row in 0.. 1 { + (sum_square / (indices.length() - 1).to_double()).sqrt() + } else { + 0.0 + } + for spot in indices { + output[row][spot] = if standard_deviation > 1.0e-14 { + (matrix[row][spot] - mean) / standard_deviation + } else { + 0.0 + } + } + } + } + output +} + +///| +pub fn banksy_component_weights( + lambda : Double, + max_harmonic : Int, +) -> Array[Double] raise BanksyError { + if !banksy_is_finite(lambda) || lambda < 0.0 || lambda > 1.0 { + raise BanksyError("BANKSY lambda must be finite and in [0, 1]") + } + if max_harmonic < 0 { + raise BanksyError("BANKSY maximum harmonic must be non-negative") + } + let raw : Array[Double] = [] + let mut total = 0.0 + for harmonic in 0..<=max_harmonic { + let value = @math.pow(2.0, -harmonic.to_double()) + raw.push(value) + total = total + value + } + let weights : Array[Double] = [(1.0 - lambda).sqrt()] + for value in raw { + weights.push((lambda * value / total).sqrt()) + } + weights +} + +///| +pub fn banksy_get_matrix( + model : BanksyModel, + lambda? : Double = 0.2, + max_harmonic? : Int = -1, + scale? : Bool = false, + groups? : Array[String] = [], +) -> BanksyMatrix raise BanksyError { + let maximum = if max_harmonic < 0 { + model.max_harmonic() + } else { + max_harmonic + } + if maximum < 0 || maximum > model.max_harmonic() { + raise BanksyError("BANKSY requested harmonic was not computed") + } + let checked_groups = banksy_validate_groups(groups, model.n_spots()) + let weights = banksy_component_weights(lambda, maximum) + let values : Array[Array[Double]] = [] + let feature_names : Array[String] = [] + let own = if scale { + banksy_scale_component(model.expression, checked_groups) + } else { + banksy_copy_matrix(model.expression) + } + for gene in 0.. Int { + self.values.length() +} + +///| +pub fn BanksyMatrix::n_spots(self : BanksyMatrix) -> Int { + if self.values.length() == 0 { + 0 + } else { + self.values[0].length() + } +} + +///| +pub fn BanksyMatrix::spot_matrix(self : BanksyMatrix) -> Array[Array[Double]] { + let output = banksy_zero_matrix(self.n_spots(), self.n_features()) + for feature in 0.. Array[Array[Double]] { + if data.length() == 0 { + return [] + } + let output = banksy_copy_matrix(data) + for column in 0.. Array[Array[Double]] { + let matrix = banksy_zero_matrix(size, size) + for index in 0.. (Array[Double], Array[Array[Double]]) { + let size = input.length() + let matrix = banksy_copy_matrix(input) + let vectors = banksy_identity(size) + let limit = (size * size * 30).max(60) + for _ in 0.. 1 { 1 } else { 0 } + let mut maximum = 0.0 + for row in 0.. maximum { + maximum = value + p = row + q = column + } + } + } + if maximum < 1.0e-12 || size < 2 { + break + } + let app = matrix[p][p] + let aqq = matrix[q][q] + let apq = matrix[p][q] + let tau = (aqq - app) / (2.0 * apq) + let t = if tau >= 0.0 { + 1.0 / (tau + (1.0 + tau * tau).sqrt()) + } else { + -1.0 / (-tau + (1.0 + tau * tau).sqrt()) + } + let cosine = 1.0 / (1.0 + t * t).sqrt() + let sine = t * cosine + for index in 0.. Int { + if values[left] > values[right] { + -1 + } else if values[left] < values[right] { + 1 + } else if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + let sorted_values : Array[Double] = [] + let sorted_vectors = banksy_zero_matrix(size, size) + for column in 0.. BanksyPcaResult raise BanksyError { + let spots = matrix.n_spots() + let features = matrix.n_features() + if spots < 2 || features < 1 { + raise BanksyError("BANKSY PCA requires at least two spots and one feature") + } + let maximum = (spots - 1).min(features) + if n_components < 1 || n_components > maximum { + raise BanksyError( + "BANKSY PCA component count must be in [1, min(spots - 1, features)]", + ) + } + let centered = banksy_center_columns(matrix.spot_matrix()) + let gram = banksy_zero_matrix(spots, spots) + for first in 0.. 0.0 { + total_variance = total_variance + value + } + } + if total_variance <= 1.0e-14 { + raise BanksyError("BANKSY PCA input has no non-constant variation") + } + let component_count = n_components + let scores = banksy_zero_matrix(spots, component_count) + let loadings = banksy_zero_matrix(features, component_count) + let eigenvalues : Array[Double] = [] + let variance_explained : Array[Double] = [] + for component in 0.. 1.0e-14 { + for feature in 0.. loadings[largest][component].abs() { + largest = feature + } + } + if loadings[largest][component] < 0.0 { + for spot in 0.. Int { + self.scores.length() +} + +///| +pub fn BanksyPcaResult::summary(self : BanksyPcaResult) -> String { + let mut cumulative = 0.0 + for value in self.variance_explained { + cumulative = cumulative + value + } + "BANKSY PCA: " + + self.n_components.to_string() + + " components, explained variance=" + + cumulative.to_string() +} + +///| +fn banksy_squared_distance( + left : Array[Double], + right : Array[Double], +) -> Double { + let mut value = 0.0 + for index in 0.. Array[Array[Double]] { + let centroids : Array[Array[Double]] = [data[first_index].copy()] + let selected = Array::make(data.length(), false) + selected[first_index] = true + while centroids.length() < clusters { + let mut best_index = -1 + let mut best_distance = -1.0 + for point in 0.. best_distance { + best_distance = minimum + best_index = point + } + } + if best_index < 0 { + break + } + selected[best_index] = true + centroids.push(data[best_index].copy()) + } + centroids +} + +///| +fn banksy_assign_clusters( + data : Array[Array[Double]], + centroids : Array[Array[Double]], +) -> (Array[Int], Double) { + let labels = Array::make(data.length(), 0) + let mut inertia = 0.0 + for point in 0.. Array[Array[Double]] { + let clusters = old_centroids.length() + let dimensions = data[0].length() + let centroids = banksy_zero_matrix(clusters, dimensions) + let counts = Array::make(clusters, 0) + for point in 0.. 0 { + for dimension in 0.. farthest_distance { + farthest = point + farthest_distance = distance + } + } + centroids[cluster] = data[farthest].copy() + } + } + centroids +} + +///| +fn banksy_kmeans_once( + data : Array[Array[Double]], + config : BanksyClusterConfig, + start : Int, +) -> BanksyKmeansFit { + let first = (config.seed % data.length() + start) % data.length() + let mut centroids = banksy_initialize_centroids( + data, + config.n_clusters, + first, + ) + let mut labels = Array::make(data.length(), -1) + let mut iterations = 0 + let mut converged = false + for iteration in 0.. Double raise BanksyError { + if data.length() != labels.length() { + raise BanksyError("BANKSY silhouette labels must match data rows") + } + if data.length() < 2 { + return 0.0 + } + let mut maximum_label = -1 + for label in labels { + if label < 0 { + raise BanksyError("BANKSY cluster labels must be non-negative") + } + maximum_label = maximum_label.max(label) + } + let clusters = maximum_label + 1 + let mut total = 0.0 + for point in 0.. 0 { + b = b.min(other_sums[cluster] / other_counts[cluster].to_double()) + } + } + if b < 1.0e299 { + let denominator = a.max(b) + if denominator > 0.0 { + total = total + (b - a) / denominator + } + } + } + total / data.length().to_double() +} + +///| +pub fn banksy_cluster( + pca : BanksyPcaResult, + config? : BanksyClusterConfig = BanksyClusterConfig::default(), +) -> BanksyClusterResult raise BanksyError { + if pca.scores.length() == 0 { + raise BanksyError("BANKSY clustering requires non-empty PCA scores") + } + if config.n_clusters > pca.scores.length() { + raise BanksyError("BANKSY cluster count must not exceed the spot count") + } + let mut best : BanksyKmeansFit? = None + for start in 0.. Some(fit) + Some(current) => + if fit.inertia < current.inertia { + Some(fit) + } else { + Some(current) + } + } + } + let fit = match best { + Some(value) => value + None => raise BanksyError("BANKSY k-means did not produce a fit") + } + let sizes = Array::make(config.n_clusters, 0) + for label in fit.labels { + sizes[label] = sizes[label] + 1 + } + let silhouette = banksy_silhouette(pca.scores, fit.labels) + BanksyClusterResult::{ + labels: fit.labels, + centroids: fit.centroids, + cluster_sizes: sizes, + inertia: fit.inertia, + iterations: fit.iterations, + converged: fit.converged, + silhouette, + } +} + +///| +pub fn BanksyClusterResult::n_clusters(self : BanksyClusterResult) -> Int { + self.cluster_sizes.length() +} + +///| +pub fn BanksyClusterResult::summary(self : BanksyClusterResult) -> String { + "BANKSY clustering: " + + self.n_clusters().to_string() + + " clusters, inertia=" + + self.inertia.to_string() + + ", silhouette=" + + self.silhouette.to_string() +} + +///| +fn banksy_plain_knn( + coordinates : Array[Array[Double]], + k : Int, +) -> Array[Array[Int]] raise BanksyError { + if k < 1 || k >= coordinates.length() { + raise BanksyError( + "BANKSY smoothing neighbor count must be in [1, spots - 1]", + ) + } + let output : Array[Array[Int]] = [] + for source in 0.. BanksySmoothingResult raise BanksyError { + if labels.length() != coordinates.length() || labels.length() < 2 { + raise BanksyError( + "BANKSY smoothing labels and coordinates must contain the same spots", + ) + } + if !banksy_is_finite(proportion_threshold) || + proportion_threshold < 0.0 || + proportion_threshold > 1.0 { + raise BanksyError("BANKSY smoothing proportion threshold must be in [0, 1]") + } + if max_iterations == 0 || max_iterations < -1 { + raise BanksyError( + "BANKSY smoothing iterations must be positive or -1 for convergence", + ) + } + let mut maximum_label = -1 + for label in labels { + if label < 0 { + raise BanksyError("BANKSY smoothing labels must be non-negative") + } + maximum_label = maximum_label.max(label) + } + let neighbors = banksy_plain_knn(coordinates, k) + let raw = labels.copy() + let mut current = labels.copy() + let limit = if max_iterations == -1 { 10000 } else { max_iterations } + let mut iterations = 0 + let mut converged = false + for iteration in 0.. counts[best] { + best = label + } + } + let proportion = counts[best].to_double() / (k + 1).to_double() + if proportion > proportion_threshold { + next[spot] = best + } + if next[spot] != current[spot] { + changes = changes + 1 + } + } + current = next + iterations = iteration + 1 + if changes == 0 { + converged = true + break + } + } + let mut total_changed = 0 + for spot in 0.. Double raise BanksyError { + if labels.length() != coordinates.length() || labels.length() < 2 { + raise BanksyError("BANKSY spatial agreement labels must match coordinates") + } + let neighbors = banksy_plain_knn(coordinates, k) + let mut matches = 0 + let mut total = 0 + for spot in 0.. Double raise BanksyError { + if left.length() != right.length() || left.length() < 2 { + raise BanksyError( + "BANKSY ARI label vectors must have equal length of at least two", + ) + } + let left_counts : Map[Int, Int] = Map([]) + let right_counts : Map[Int, Int] = Map([]) + let cells : Map[String, Int] = Map([]) + for index in 0.. value + 1 + None => 1 + } + right_counts[right[index]] = match right_counts.get(right[index]) { + Some(value) => value + 1 + None => 1 + } + let key = left[index].to_string() + ":" + right[index].to_string() + cells[key] = match cells.get(key) { + Some(value) => value + 1 + None => 1 + } + } + let choose_two = fn(value : Int) -> Double { + (value * (value - 1) / 2).to_double() + } + let mut cell_sum = 0.0 + for key in cells.keys() { + cell_sum = cell_sum + choose_two(cells[key]) + } + let mut left_sum = 0.0 + for key in left_counts.keys() { + left_sum = left_sum + choose_two(left_counts[key]) + } + let mut right_sum = 0.0 + for key in right_counts.keys() { + right_sum = right_sum + choose_two(right_counts[key]) + } + let total_pairs = choose_two(left.length()) + let expected = left_sum * right_sum / total_pairs + let maximum = (left_sum + right_sum) / 2.0 + if (maximum - expected).abs() <= 1.0e-14 { + if (cell_sum - expected).abs() <= 1.0e-14 { + 1.0 + } else { + 0.0 + } + } else { + (cell_sum - expected) / (maximum - expected) + } +} + +///| +pub fn banksy_run( + model : BanksyModel, + lambda? : Double = 0.2, + n_components? : Int = 20, + cluster_config? : BanksyClusterConfig = BanksyClusterConfig::default(), + max_harmonic? : Int = -1, + scale? : Bool = true, + groups? : Array[String] = [], + smooth? : Bool = false, + smoothing_k? : Int = 15, + smoothing_threshold? : Double = 0.5, + smoothing_iterations? : Int = 10, +) -> BanksyRun raise BanksyError { + let matrix = banksy_get_matrix(model, lambda~, max_harmonic~, scale~, groups~) + let pca = banksy_run_pca(matrix, n_components~) + let clustering = banksy_cluster(pca, config=cluster_config) + let smoothing = if smooth { + Some( + banksy_smooth_labels( + clustering.labels, + model.coordinates, + k=smoothing_k, + proportion_threshold=smoothing_threshold, + max_iterations=smoothing_iterations, + ), + ) + } else { + None + } + let final_labels = match smoothing { + Some(result) => result.labels + None => clustering.labels + } + let agreement_k = smoothing_k.min(model.n_spots() - 1).max(1) + let agreement = banksy_spatial_agreement( + final_labels, + model.coordinates, + k=agreement_k, + ) + BanksyRun::{ + lambda, + matrix, + pca, + clustering, + smoothing, + spatial_agreement: agreement, + } +} + +///| +pub fn banksy_parameter_sweep( + model : BanksyModel, + lambdas : Array[Double], + n_components? : Int = 20, + cluster_config? : BanksyClusterConfig = BanksyClusterConfig::default(), + max_harmonic? : Int = -1, + scale? : Bool = true, + groups? : Array[String] = [], +) -> Array[BanksyRun] raise BanksyError { + if lambdas.length() == 0 { + raise BanksyError("BANKSY parameter sweep requires at least one lambda") + } + let runs : Array[BanksyRun] = [] + for lambda in lambdas { + runs.push( + banksy_run( + model, + lambda~, + n_components~, + cluster_config~, + max_harmonic~, + scale~, + groups~, + ), + ) + } + runs +} + +///| +pub fn BanksyRun::final_labels(self : BanksyRun) -> Array[Int] { + match self.smoothing { + Some(result) => result.labels.copy() + None => self.clustering.labels.copy() + } +} + +///| +pub fn BanksyRun::summary(self : BanksyRun) -> String { + "BANKSY run: lambda=" + + self.lambda.to_string() + + ", " + + self.clustering.summary() + + ", spatial agreement=" + + self.spatial_agreement.to_string() +} + +///| +fn banksy_copy_string_map(source : Map[String, String]) -> Map[String, String] { + let copied : Map[String, String] = Map([]) + for key in source.keys() { + copied[key] = source[key] + } + copied +} + +///| +fn banksy_copy_spatial_experiment( + experiment : SpatialExperiment, +) -> SpatialExperiment { + let copied = SpatialExperiment::new() + for key in experiment.assay.keys() { + copied.assay[key] = banksy_copy_matrix(experiment.assay[key]) + } + for row in experiment.row_data { + copied.row_data.push(banksy_copy_string_map(row)) + } + for column in experiment.col_data { + copied.col_data.push(banksy_copy_string_map(column)) + } + for coordinate in experiment.spatial_coords { + copied.spatial_coords.push(coordinate) + } + for image in experiment.images { + copied.images.push( + SpatialImage::new( + image.id, + banksy_copy_matrix(image.data), + image.scale_factor, + ), + ) + } + for key in experiment.metadata.keys() { + copied.metadata[key] = experiment.metadata[key] + } + copied +} + +///| +fn banksy_experiment_gene_names( + experiment : SpatialExperiment, + genes : Int, +) -> Array[String] raise BanksyError { + if experiment.row_data.length() != 0 && experiment.row_data.length() != genes { + raise BanksyError("BANKSY SpatialExperiment rowData must match assay rows") + } + let names : Array[String] = [] + for gene in 0.. + if value.length() > 0 { + value + } else { + match row.get("gene_id") { + Some(identifier) => + if identifier.length() > 0 { + identifier + } else { + generated + } + None => generated + } + } + None => + match row.get("gene_id") { + Some(identifier) => + if identifier.length() > 0 { + identifier + } else { + generated + } + None => generated + } + } + names.push(name) + } + } + names +} + +///| +fn banksy_experiment_spot_names( + experiment : SpatialExperiment, + spots : Int, +) -> Array[String] raise BanksyError { + if experiment.col_data.length() != 0 && experiment.col_data.length() != spots { + raise BanksyError( + "BANKSY SpatialExperiment colData must match assay columns", + ) + } + let names : Array[String] = [] + for spot in 0.. if value.length() > 0 { value } else { generated } + None => generated + } + names.push(name) + } + } + names +} + +///| +fn banksy_experiment_coordinates( + experiment : SpatialExperiment, + spots : Int, +) -> Array[Array[Double]] raise BanksyError { + if experiment.spatial_coords.length() != spots { + raise BanksyError( + "BANKSY SpatialExperiment requires one spatial coordinate per spot", + ) + } + let mut use_z = false + if spots > 0 { + let first = experiment.spatial_coords[0].z + for coordinate in experiment.spatial_coords { + if (coordinate.z - first).abs() > 1.0e-14 { + use_z = true + } + } + } + let coordinates : Array[Array[Double]] = [] + for coordinate in experiment.spatial_coords { + if use_z { + coordinates.push([coordinate.x, coordinate.y, coordinate.z]) + } else { + coordinates.push([coordinate.x, coordinate.y]) + } + } + coordinates +} + +///| +pub fn banksy_spatial_experiment( + experiment : SpatialExperiment, + assay_name? : String = "logcounts", + config? : BanksyComputeConfig = BanksyComputeConfig::default(), + lambda? : Double = 0.2, + n_components? : Int = 20, + cluster_config? : BanksyClusterConfig = BanksyClusterConfig::default(), + max_harmonic? : Int = -1, + scale? : Bool = true, + group_key? : String = "", + smooth? : Bool = true, + smoothing_k? : Int = 15, + smoothing_threshold? : Double = 0.5, + smoothing_iterations? : Int = 10, +) -> BanksySpatialExperimentOutput raise BanksyError { + let expression = match experiment.assay.get(assay_name) { + Some(value) => value + None => + raise BanksyError( + "BANKSY SpatialExperiment assay not found: " + assay_name, + ) + } + if expression.length() == 0 { + raise BanksyError("BANKSY SpatialExperiment assay must not be empty") + } + let spots = expression[0].length() + let gene_names = banksy_experiment_gene_names(experiment, expression.length()) + let spot_names = banksy_experiment_spot_names(experiment, spots) + let coordinates = banksy_experiment_coordinates(experiment, spots) + let groups : Array[String] = [] + if group_key.length() > 0 { + if experiment.col_data.length() != spots { + raise BanksyError( + "BANKSY grouping requires complete SpatialExperiment colData", + ) + } + for column in experiment.col_data { + match column.get(group_key) { + Some(value) => + if value.length() == 0 { + raise BanksyError( + "BANKSY SpatialExperiment grouping values must not be empty", + ) + } else { + groups.push(value) + } + None => + raise BanksyError( + "BANKSY SpatialExperiment group field not found: " + group_key, + ) + } + } + } + let model = banksy_compute_with_config( + expression, + coordinates, + config, + gene_names~, + spot_names~, + ) + let run = banksy_run( + model, + lambda~, + n_components~, + cluster_config~, + max_harmonic~, + scale~, + groups~, + smooth~, + smoothing_k~, + smoothing_threshold~, + smoothing_iterations~, + ) + let enriched = banksy_copy_spatial_experiment(experiment) + if enriched.row_data.length() == 0 { + for gene_name in gene_names { + enriched.row_data.push(Map([("gene_name", gene_name)])) + } + } + if enriched.col_data.length() == 0 { + for spot_name in spot_names { + enriched.col_data.push(Map([("spot_id", spot_name)])) + } + } + for harmonic in 0..<=model.max_harmonic() { + enriched.assay["H" + harmonic.to_string()] = banksy_copy_matrix( + model.harmonics[harmonic], + ) + } + let labels = run.final_labels() + for spot in 0.. ( + Array[Array[Double]], + Array[Array[Double]], + Array[String], + Array[String], +) { + let width = 6 + let height = 4 + let spots = width * height + let coordinates : Array[Array[Double]] = [] + let spot_names : Array[String] = [] + let expression = banksy_zero_matrix(5, spots) + for y in 0..= width / 2 { 8.0 } else { 1.0 } + let upper = if y < height / 2 { 6.0 } else { 2.0 } + let boundary = if x == 2 || x == 3 { 7.0 } else { 1.0 } + let variation = ((x * 3 + y * 5) % 4).to_double() * 0.15 + expression[0][spot] = left + variation + expression[1][spot] = right + variation + expression[2][spot] = upper + variation + expression[3][spot] = boundary + variation + expression[4][spot] = 3.0 + variation + } + } + ( + expression, + coordinates, + ["left_marker", "right_marker", "upper_marker", "boundary", "baseline"], + spot_names, + ) +} diff --git a/test/moonbit/banksy_test.mbt b/test/moonbit/banksy_test.mbt new file mode 100644 index 00000000..c2e63cab --- /dev/null +++ b/test/moonbit/banksy_test.mbt @@ -0,0 +1,1479 @@ +// Tests for the Bioconductor Banksy-inspired spatial clustering workflow. + +///| +fn banksy_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "BANKSY value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn banksy_test_config( + mode : @src.BanksySpatialMode, +) -> @src.BanksyComputeConfig { + @src.BanksyComputeConfig::create( + max_harmonic=1, + k_geom=[4, 4], + spatial_mode=mode, + distance_power=2.0, + sigma=1.5, + alpha=0.05, + k_spatial=4, + seed=7, + ) catch { + _ => abort("BANKSY test configuration should be valid") + } +} + +///| +fn banksy_test_model() -> @src.BanksyModel { + let (expression, coordinates, gene_names, spot_names) = @src.banksy_example_data() + @src.banksy_compute_with_config( + expression, + coordinates, + banksy_test_config(@src.banksy_knn_median()), + gene_names~, + spot_names~, + ) catch { + _ => abort("BANKSY example model should compute") + } +} + +///| +fn banksy_test_matrix() -> @src.BanksyMatrix { + @src.banksy_get_matrix( + banksy_test_model(), + lambda=0.2, + max_harmonic=1, + scale=true, + ) catch { + _ => abort("BANKSY example matrix should compute") + } +} + +///| +fn banksy_test_pca() -> @src.BanksyPcaResult { + @src.banksy_run_pca(banksy_test_matrix(), n_components=3) catch { + _ => abort("BANKSY example PCA should compute") + } +} + +///| +fn banksy_test_cluster_config() -> @src.BanksyClusterConfig { + @src.BanksyClusterConfig::create( + n_clusters=2, + n_starts=5, + max_iterations=100, + tolerance=1.0e-8, + seed=3, + ) catch { + _ => abort("BANKSY cluster configuration should be valid") + } +} + +///| +fn banksy_test_experiment() -> @src.SpatialExperiment { + let (expression, coordinates, gene_names, spot_names) = @src.banksy_example_data() + let experiment = @src.SpatialExperiment::new() + ignore(@src.se_add_assay(experiment, "logcounts", expression)) + for gene_name in gene_names { + ignore(@src.se_add_row(experiment, Map([("gene_name", gene_name)]))) + } + for spot in 0.. abort("custom BANKSY configuration should be valid") + } + assert_eq(config.max_harmonic, 2) + assert_eq(config.k_geom, [3, 4, 5]) + assert_eq(config.distance_power, 3.0) + assert_eq(config.sample_size, 2) + assert_eq(config.sample_renormalize, false) + assert_eq(config.seed, 9) + assert_eq(config.center_harmonics, false) +} + +///| +test "BANKSY: compute configuration copies neighbor counts" { + let counts = [2, 3] + let config = @src.BanksyComputeConfig::create(max_harmonic=1, k_geom=counts) catch { + _ => abort("BANKSY configuration should copy k_geom") + } + counts[0] = 9 + assert_eq(config.k_geom, [2, 3]) +} + +///| +test "BANKSY: compute configuration rejects negative harmonic" { + let failed = try { + ignore(@src.BanksyComputeConfig::create(max_harmonic=-1)) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} + +///| +test "BANKSY: compute configuration rejects wrong k_geom length" { + let failed = try { + ignore(@src.BanksyComputeConfig::create(max_harmonic=2, k_geom=[2, 3])) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} + +///| +test "BANKSY: compute configuration rejects non-positive k_geom" { + let failed = try { + ignore(@src.BanksyComputeConfig::create(k_geom=[0])) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} + +///| +test "BANKSY: compute configuration rejects invalid distance power" { + let failed = try { + ignore(@src.BanksyComputeConfig::create(distance_power=0.0)) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} + +///| +test "BANKSY: compute configuration rejects invalid Gaussian sigma" { + let failed = try { + ignore(@src.BanksyComputeConfig::create(sigma=-1.0)) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} + +///| +test "BANKSY: compute configuration rejects radial alpha endpoints" { + let zero = try { + ignore(@src.BanksyComputeConfig::create(alpha=0.0)) + false + } catch { + BanksyError(_) => true + } + let one = try { + ignore(@src.BanksyComputeConfig::create(alpha=1.0)) + false + } catch { + BanksyError(_) => true + } + assert_true(zero) + assert_true(one) +} + +///| +test "BANKSY: compute configuration rejects radial neighbor count" { + let failed = try { + ignore(@src.BanksyComputeConfig::create(k_spatial=0)) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} + +///| +test "BANKSY: compute configuration rejects negative sampling controls" { + let sample = try { + ignore(@src.BanksyComputeConfig::create(sample_size=-1)) + false + } catch { + BanksyError(_) => true + } + let seed = try { + ignore(@src.BanksyComputeConfig::create(seed=-1)) + false + } catch { + BanksyError(_) => true + } + assert_true(sample) + assert_true(seed) +} + +///| +test "BANKSY: example data has gene by spot orientation" { + let (expression, coordinates, gene_names, spot_names) = @src.banksy_example_data() + assert_eq(expression.length(), 5) + assert_eq(expression[0].length(), 24) + assert_eq(coordinates.length(), 24) + assert_eq(coordinates[0].length(), 2) + assert_eq(gene_names.length(), 5) + assert_eq(spot_names.length(), 24) +} + +///| +test "BANKSY: simple compute defaults to H0 and generated names" { + let model = @src.banksy_compute( + [[1.0, 2.0, 3.0, 4.0]], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [3.0, 0.0]], + k_geom=2, + ) catch { + _ => abort("simple BANKSY compute should succeed") + } + assert_eq(model.n_genes(), 1) + assert_eq(model.n_spots(), 4) + assert_eq(model.max_harmonic(), 0) + assert_eq(model.gene_names, ["gene_1"]) + assert_eq(model.spot_names, ["spot_1", "spot_2", "spot_3", "spot_4"]) +} + +///| +test "BANKSY: compute_agf adds H1" { + let model = @src.banksy_compute( + [[1.0, 2.0, 3.0, 4.0]], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [3.0, 0.0]], + k_geom=2, + compute_agf=true, + ) catch { + _ => abort("BANKSY AGF compute should succeed") + } + assert_eq(model.max_harmonic(), 1) + assert_true(model.harmonic(0) is Some(_)) + assert_true(model.harmonic(1) is Some(_)) + assert_true(model.harmonic(2) is None) +} + +///| +test "BANKSY: model owns defensive copies of input" { + let expression = [[1.0, 2.0, 3.0]] + let coordinates = [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0]] + let model = @src.banksy_compute(expression, coordinates, k_geom=1) catch { + _ => abort("BANKSY defensive copy fixture should compute") + } + expression[0][0] = 99.0 + coordinates[0][0] = 99.0 + assert_eq(model.expression[0][0], 1.0) + assert_eq(model.coordinates[0][0], 0.0) +} + +///| +test "BANKSY: harmonic accessor returns a defensive copy" { + let model = banksy_test_model() + let first = match model.harmonic(0) { + Some(value) => value + None => abort("H0 should exist") + } + let expected = first[0][0] + first[0][0] = 999.0 + let second = match model.harmonic(0) { + Some(value) => value + None => abort("H0 should exist") + } + assert_eq(second[0][0], expected) +} + +///| +test "BANKSY: H0 preserves constant expression" { + let model = @src.banksy_compute( + [[7.0, 7.0, 7.0, 7.0]], + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], + k_geom=3, + ) catch { + _ => abort("constant BANKSY fixture should compute") + } + for value in model.harmonics[0][0] { + banksy_test_close(value, 7.0, 1.0e-12) + } +} + +///| +test "BANKSY: centered H1 is zero for constant expression" { + let model = @src.banksy_compute( + [[4.0, 4.0, 4.0, 4.0]], + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]], + k_geom=3, + compute_agf=true, + ) catch { + _ => abort("constant BANKSY AGF fixture should compute") + } + for value in model.harmonics[1][0] { + banksy_test_close(value, 0.0, 1.0e-12) + } +} + +///| +test "BANKSY: directional gradient produces positive H1" { + let model = @src.banksy_compute( + [[0.0, 1.0, 2.0, 3.0, 4.0]], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [3.0, 0.0], [4.0, 0.0]], + k_geom=2, + compute_agf=true, + ) catch { + _ => abort("gradient BANKSY fixture should compute") + } + assert_true(model.harmonics[1][0][2] > 0.0) +} + +///| +test "BANKSY: each spatial kernel produces normalized weights" { + let modes = [ + @src.banksy_knn_median(), + @src.banksy_knn_inverse_distance(), + @src.banksy_knn_inverse_power(), + @src.banksy_knn_rank(), + @src.banksy_knn_uniform(), + @src.banksy_radius_gaussian(), + ] + let (expression, coordinates, gene_names, spot_names) = @src.banksy_example_data() + for mode in modes { + let model = @src.banksy_compute_with_config( + expression, + coordinates, + banksy_test_config(mode), + gene_names~, + spot_names~, + ) catch { + _ => abort("all BANKSY kernels should compute") + } + for neighborhood in model.neighbors[0] { + let mut total = 0.0 + for neighbor in neighborhood { + total = total + neighbor.weight + } + banksy_test_close(total, 1.0, 1.0e-10) + } + } +} + +///| +test "BANKSY: uniform kernel assigns equal weights" { + let model = @src.banksy_compute_with_config( + [[1.0, 2.0, 3.0, 4.0, 5.0]], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [3.0, 0.0], [4.0, 0.0]], + @src.BanksyComputeConfig::create( + max_harmonic=0, + k_geom=[3], + spatial_mode=@src.banksy_knn_uniform(), + ) catch { + _ => abort("uniform configuration should be valid") + }, + ) catch { + _ => abort("uniform kernel should compute") + } + for neighbor in model.neighbors[0][2] { + banksy_test_close(neighbor.weight, 1.0 / 3.0, 1.0e-12) + } +} + +///| +test "BANKSY: inverse-distance kernel favors closer spots" { + let model = @src.banksy_compute_with_config( + [[1.0, 2.0, 3.0, 4.0]], + [[0.0, 0.0], [1.0, 0.0], [3.0, 0.0], [7.0, 0.0]], + @src.BanksyComputeConfig::create( + k_geom=[3], + spatial_mode=@src.banksy_knn_inverse_distance(), + ) catch { + _ => abort("inverse-distance configuration should be valid") + }, + ) catch { + _ => abort("inverse-distance kernel should compute") + } + assert_true(model.neighbors[0][0][0].weight > model.neighbors[0][0][1].weight) + assert_true(model.neighbors[0][0][1].weight > model.neighbors[0][0][2].weight) +} + +///| +test "BANKSY: rank kernel weights decrease with rank" { + let model = @src.banksy_compute_with_config( + [[1.0, 2.0, 3.0, 4.0, 5.0]], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [3.0, 0.0], [4.0, 0.0]], + @src.BanksyComputeConfig::create( + k_geom=[4], + spatial_mode=@src.banksy_knn_rank(), + ) catch { + _ => abort("rank configuration should be valid") + }, + ) catch { + _ => abort("rank kernel should compute") + } + let neighborhood = model.neighbors[0][0] + assert_true(neighborhood[0].weight > neighborhood[1].weight) + assert_true(neighborhood[1].weight > neighborhood[2].weight) + assert_true(neighborhood[2].weight > neighborhood[3].weight) +} + +///| +test "BANKSY: neighbor angles use the first two spatial dimensions" { + let model = @src.banksy_compute( + [[1.0, 2.0, 3.0]], + [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]], + k_geom=2, + ) catch { + _ => abort("angle fixture should compute") + } + banksy_test_close(model.neighbors[0][0][0].angle, 0.0, 1.0e-12) + banksy_test_close( + model.neighbors[0][0][1].angle, + 3.141592653589793 / 2.0, + 1.0e-12, + ) +} + +///| +test "BANKSY: deterministic sampling selects requested neighbors" { + let config = @src.BanksyComputeConfig::create( + k_geom=[5], + sample_size=2, + sample_renormalize=true, + seed=11, + ) catch { + _ => abort("sampling configuration should be valid") + } + let expression = [[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]] + let coordinates = [ + [0.0, 0.0], + [1.0, 0.0], + [2.0, 0.0], + [3.0, 0.0], + [4.0, 0.0], + [5.0, 0.0], + ] + let first = @src.banksy_compute_with_config(expression, coordinates, config) catch { + _ => abort("sampled BANKSY model should compute") + } + let second = @src.banksy_compute_with_config(expression, coordinates, config) catch { + _ => abort("sampled BANKSY model should repeat") + } + assert_eq(first.neighbors[0][0].length(), 2) + assert_eq(first.neighbors[0][0], second.neighbors[0][0]) + banksy_test_close( + first.neighbors[0][0][0].weight + first.neighbors[0][0][1].weight, + 1.0, + 1.0e-12, + ) +} + +///| +test "BANKSY: non-renormalized sampling retains original mass" { + let model = @src.banksy_compute_with_config( + [[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [3.0, 0.0], [4.0, 0.0], [5.0, 0.0]], + @src.BanksyComputeConfig::create( + k_geom=[5], + sample_size=2, + sample_renormalize=false, + ) catch { + _ => abort("non-renormalized sampling configuration should be valid") + }, + ) catch { + _ => abort("non-renormalized sampling should compute") + } + let mut total = 0.0 + for neighbor in model.neighbors[0][0] { + total = total + neighbor.weight + } + assert_true(total > 0.0) + assert_true(total < 1.0) +} + +///| +test "BANKSY: model summary reports dimensions and harmonics" { + let summary = banksy_test_model().summary() + assert_true(summary.contains("5 genes")) + assert_true(summary.contains("24 spots")) + assert_true(summary.contains("H0-H1")) +} + +///| +test "BANKSY: compute rejects empty expression" { + let failed = try { + ignore(@src.banksy_compute([], [])) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} + +///| +test "BANKSY: compute rejects a single spot" { + let failed = try { + ignore(@src.banksy_compute([[1.0]], [[0.0, 0.0]], k_geom=1)) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} + +///| +test "BANKSY: compute rejects ragged expression" { + let failed = try { + ignore( + @src.banksy_compute( + [[1.0, 2.0, 3.0], [4.0, 5.0]], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0]], + k_geom=1, + ), + ) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} + +///| +test "BANKSY: compute rejects non-finite expression" { + let failed = try { + ignore( + @src.banksy_compute( + [[1.0, 1.0e301, 3.0]], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0]], + k_geom=1, + ), + ) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} + +///| +test "BANKSY: compute rejects coordinate count mismatch" { + let failed = try { + ignore( + @src.banksy_compute([[1.0, 2.0, 3.0]], [[0.0, 0.0], [1.0, 0.0]], k_geom=1), + ) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} + +///| +test "BANKSY: compute rejects one-dimensional coordinates" { + let failed = try { + ignore( + @src.banksy_compute([[1.0, 2.0, 3.0]], [[0.0], [1.0], [2.0]], k_geom=1), + ) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} + +///| +test "BANKSY: compute rejects ragged coordinates" { + let failed = try { + ignore( + @src.banksy_compute( + [[1.0, 2.0, 3.0]], + [[0.0, 0.0], [1.0, 0.0, 1.0], [2.0, 0.0]], + k_geom=1, + ), + ) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} + +///| +test "BANKSY: compute rejects duplicate names" { + let duplicate_gene = try { + ignore( + @src.banksy_compute( + [[1.0, 2.0, 3.0], [3.0, 2.0, 1.0]], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0]], + k_geom=1, + gene_names=["g", "g"], + ), + ) + false + } catch { + BanksyError(_) => true + } + let duplicate_spot = try { + ignore( + @src.banksy_compute( + [[1.0, 2.0, 3.0]], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0]], + k_geom=1, + spot_names=["s", "s", "t"], + ), + ) + false + } catch { + BanksyError(_) => true + } + assert_true(duplicate_gene) + assert_true(duplicate_spot) +} + +///| +test "BANKSY: compute rejects excessive neighbor and sample counts" { + let neighbors = try { + ignore( + @src.banksy_compute( + [[1.0, 2.0, 3.0]], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0]], + k_geom=3, + ), + ) + false + } catch { + BanksyError(_) => true + } + let sample = try { + let config = @src.BanksyComputeConfig::create(k_geom=[2], sample_size=3) + ignore( + @src.banksy_compute_with_config( + [[1.0, 2.0, 3.0]], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0]], + config, + ), + ) + false + } catch { + BanksyError(_) => true + } + assert_true(neighbors) + assert_true(sample) +} + +///| +test "BANKSY: M1 component weights match upstream lambda split" { + let weights = @src.banksy_component_weights(0.2, 1) catch { + _ => abort("valid BANKSY weights should compute") + } + banksy_test_close(weights[0], 0.8.sqrt(), 1.0e-12) + banksy_test_close(weights[1], (0.4 / 3.0).sqrt(), 1.0e-12) + banksy_test_close(weights[2], (0.2 / 3.0).sqrt(), 1.0e-12) +} + +///| +test "BANKSY: lambda endpoints isolate expression and spatial components" { + let expression = @src.banksy_component_weights(0.0, 1) catch { + _ => abort("lambda zero should be valid") + } + let spatial = @src.banksy_component_weights(1.0, 1) catch { + _ => abort("lambda one should be valid") + } + assert_eq(expression[0], 1.0) + assert_eq(expression[1], 0.0) + assert_eq(expression[2], 0.0) + assert_eq(spatial[0], 0.0) + banksy_test_close( + spatial[1] * spatial[1] + spatial[2] * spatial[2], + 1.0, + 1.0e-12, + ) +} + +///| +test "BANKSY: component weights reject invalid arguments" { + let lambda = try { + ignore(@src.banksy_component_weights(1.1, 1)) + false + } catch { + BanksyError(_) => true + } + let harmonic = try { + ignore(@src.banksy_component_weights(0.2, -1)) + false + } catch { + BanksyError(_) => true + } + assert_true(lambda) + assert_true(harmonic) +} + +///| +test "BANKSY: joint matrix concatenates expression H0 and H1" { + let matrix = @src.banksy_get_matrix( + banksy_test_model(), + lambda=0.2, + max_harmonic=1, + ) catch { + _ => abort("BANKSY matrix should compute") + } + assert_eq(matrix.n_features(), 15) + assert_eq(matrix.n_spots(), 24) + assert_eq(matrix.feature_names[0], "left_marker") + assert_eq(matrix.feature_names[5], "left_marker_H0") + assert_eq(matrix.feature_names[10], "left_marker_H1") + assert_eq(matrix.component_weights.length(), 3) +} + +///| +test "BANKSY: spot matrix transposes feature orientation" { + let matrix = @src.banksy_get_matrix( + banksy_test_model(), + lambda=0.2, + max_harmonic=0, + ) catch { + _ => abort("BANKSY matrix should compute") + } + let spots = matrix.spot_matrix() + assert_eq(spots.length(), matrix.n_spots()) + assert_eq(spots[0].length(), matrix.n_features()) + assert_eq(spots[3][2], matrix.values[2][3]) +} + +///| +test "BANKSY: global scaling centers every feature" { + let matrix = banksy_test_matrix() + for row in matrix.values { + let mut mean = 0.0 + for value in row { + mean = mean + value + } + mean = mean / row.length().to_double() + banksy_test_close(mean, 0.0, 1.0e-10) + } +} + +///| +test "BANKSY: scaling maps constant features to zero" { + let model = @src.banksy_compute( + [[5.0, 5.0, 5.0, 5.0]], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [3.0, 0.0]], + k_geom=2, + ) catch { + _ => abort("constant BANKSY model should compute") + } + let matrix = @src.banksy_get_matrix(model, scale=true) catch { + _ => abort("constant BANKSY matrix should scale") + } + for row in matrix.values { + for value in row { + banksy_test_close(value, 0.0, 1.0e-12) + } + } +} + +///| +test "BANKSY: group scaling centers each group independently" { + let model = @src.banksy_compute( + [[1.0, 3.0, 101.0, 103.0]], + [[0.0, 0.0], [1.0, 0.0], [10.0, 0.0], [11.0, 0.0]], + k_geom=1, + ) catch { + _ => abort("group scaling fixture should compute") + } + let matrix = @src.banksy_get_matrix( + model, + lambda=0.0, + max_harmonic=0, + scale=true, + groups=["A", "A", "B", "B"], + ) catch { + _ => abort("group scaling should compute") + } + banksy_test_close(matrix.values[0][0] + matrix.values[0][1], 0.0, 1.0e-12) + banksy_test_close(matrix.values[0][2] + matrix.values[0][3], 0.0, 1.0e-12) +} + +///| +test "BANKSY: joint matrix validates groups and harmonics" { + let model = banksy_test_model() + let groups = try { + ignore(@src.banksy_get_matrix(model, scale=true, groups=["A"])) + false + } catch { + BanksyError(_) => true + } + let harmonic = try { + ignore(@src.banksy_get_matrix(model, max_harmonic=2)) + false + } catch { + BanksyError(_) => true + } + assert_true(groups) + assert_true(harmonic) +} + +///| +test "BANKSY: PCA returns requested dimensions" { + let pca = banksy_test_pca() + assert_eq(pca.n_components, 3) + assert_eq(pca.n_spots(), 24) + assert_eq(pca.scores[0].length(), 3) + assert_eq(pca.loadings.length(), 15) + assert_eq(pca.loadings[0].length(), 3) + assert_eq(pca.eigenvalues.length(), 3) +} + +///| +test "BANKSY: PCA scores are centered" { + let pca = banksy_test_pca() + for component in 0..= pca.eigenvalues[1]) + assert_true(pca.eigenvalues[1] >= pca.eigenvalues[2]) + let mut total = 0.0 + for value in pca.variance_explained { + assert_true(value >= 0.0) + assert_true(value <= 1.0) + total = total + value + } + assert_true(total > 0.0) + assert_true(total <= 1.0 + 1.0e-10) +} + +///| +test "BANKSY: PCA summary reports component count" { + let summary = banksy_test_pca().summary() + assert_true(summary.contains("3 components")) + assert_true(summary.contains("explained variance")) +} + +///| +test "BANKSY: PCA validates component count" { + let matrix = banksy_test_matrix() + let zero = try { + ignore(@src.banksy_run_pca(matrix, n_components=0)) + false + } catch { + BanksyError(_) => true + } + let large = try { + ignore(@src.banksy_run_pca(matrix, n_components=24)) + false + } catch { + BanksyError(_) => true + } + assert_true(zero) + assert_true(large) +} + +///| +test "BANKSY: PCA rejects constant input" { + let model = @src.banksy_compute( + [[5.0, 5.0, 5.0, 5.0]], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [3.0, 0.0]], + k_geom=2, + ) catch { + _ => abort("constant PCA fixture should compute") + } + let matrix = @src.banksy_get_matrix(model, lambda=0.0) catch { + _ => abort("constant PCA matrix should compute") + } + let failed = try { + ignore(@src.banksy_run_pca(matrix, n_components=1)) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} + +///| +test "BANKSY: default cluster configuration exposes deterministic controls" { + let config = @src.BanksyClusterConfig::default() + assert_eq(config.n_clusters, 5) + assert_eq(config.n_starts, 10) + assert_eq(config.max_iterations, 100) + assert_eq(config.tolerance, 1.0e-6) + assert_eq(config.seed, 1) +} + +///| +test "BANKSY: cluster configuration preserves custom controls" { + let config = banksy_test_cluster_config() + assert_eq(config.n_clusters, 2) + assert_eq(config.n_starts, 5) + assert_eq(config.max_iterations, 100) + assert_eq(config.tolerance, 1.0e-8) + assert_eq(config.seed, 3) +} + +///| +test "BANKSY: cluster configuration rejects invalid controls" { + let clusters = try { + ignore(@src.BanksyClusterConfig::create(n_clusters=0)) + false + } catch { + BanksyError(_) => true + } + let starts = try { + ignore(@src.BanksyClusterConfig::create(n_starts=0)) + false + } catch { + BanksyError(_) => true + } + let iterations = try { + ignore(@src.BanksyClusterConfig::create(max_iterations=0)) + false + } catch { + BanksyError(_) => true + } + let tolerance = try { + ignore(@src.BanksyClusterConfig::create(tolerance=0.0)) + false + } catch { + BanksyError(_) => true + } + let seed = try { + ignore(@src.BanksyClusterConfig::create(seed=-1)) + false + } catch { + BanksyError(_) => true + } + assert_true(clusters) + assert_true(starts) + assert_true(iterations) + assert_true(tolerance) + assert_true(seed) +} + +///| +test "BANKSY: deterministic k-means recovers two separated groups" { + let model = @src.banksy_compute( + [[-5.0, -4.8, -5.2, 5.0, 4.8, 5.2]], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [10.0, 0.0], [11.0, 0.0], [12.0, 0.0]], + k_geom=1, + ) catch { + _ => abort("separated BANKSY model should compute") + } + let matrix = @src.banksy_get_matrix(model, lambda=0.0, max_harmonic=0) catch { + _ => abort("separated BANKSY matrix should compute") + } + let pca = @src.banksy_run_pca(matrix, n_components=1) catch { + _ => abort("separated BANKSY PCA should compute") + } + let fit = @src.banksy_cluster(pca, config=banksy_test_cluster_config()) catch { + _ => abort("separated BANKSY clusters should fit") + } + assert_eq(fit.n_clusters(), 2) + assert_eq(fit.cluster_sizes[0] + fit.cluster_sizes[1], 6) + assert_eq(fit.labels[0], fit.labels[1]) + assert_eq(fit.labels[1], fit.labels[2]) + assert_eq(fit.labels[3], fit.labels[4]) + assert_eq(fit.labels[4], fit.labels[5]) + assert_true(fit.labels[0] != fit.labels[3]) + assert_true(fit.silhouette > 0.9) +} + +///| +test "BANKSY: k-means is reproducible for fixed configuration" { + let pca = banksy_test_pca() + let first = @src.banksy_cluster(pca, config=banksy_test_cluster_config()) catch { + _ => abort("first BANKSY clustering should fit") + } + let second = @src.banksy_cluster(pca, config=banksy_test_cluster_config()) catch { + _ => abort("second BANKSY clustering should fit") + } + assert_eq(first.labels, second.labels) + assert_eq(first.inertia, second.inertia) +} + +///| +test "BANKSY: cluster result summary reports fit metrics" { + let fit = @src.banksy_cluster( + banksy_test_pca(), + config=banksy_test_cluster_config(), + ) catch { + _ => abort("BANKSY clustering should fit") + } + let summary = fit.summary() + assert_true(summary.contains("2 clusters")) + assert_true(summary.contains("inertia")) + assert_true(summary.contains("silhouette")) +} + +///| +test "BANKSY: clustering rejects more clusters than spots" { + let failed = try { + ignore( + @src.banksy_cluster( + banksy_test_pca(), + config=@src.BanksyClusterConfig::create(n_clusters=25), + ), + ) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} + +///| +test "BANKSY: silhouette is high for separated groups" { + let value = @src.banksy_silhouette([[0.0], [0.1], [10.0], [10.1]], [ + 0, 0, 1, 1, + ]) catch { + _ => abort("valid silhouette should compute") + } + assert_true(value > 0.98) +} + +///| +test "BANKSY: silhouette validates labels" { + let length = try { + ignore(@src.banksy_silhouette([[0.0], [1.0]], [0])) + false + } catch { + BanksyError(_) => true + } + let negative = try { + ignore(@src.banksy_silhouette([[0.0], [1.0]], [0, -1])) + false + } catch { + BanksyError(_) => true + } + assert_true(length) + assert_true(negative) +} + +///| +test "BANKSY: label smoothing repairs an isolated label" { + let result = @src.banksy_smooth_labels( + [0, 0, 1, 0, 0], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [3.0, 0.0], [4.0, 0.0]], + k=2, + proportion_threshold=0.5, + max_iterations=5, + ) catch { + _ => abort("BANKSY smoothing should compute") + } + assert_eq(result.labels, [0, 0, 0, 0, 0]) + assert_eq(result.changed_labels, 1) + assert_true(result.converged) +} + +///| +test "BANKSY: strict smoothing threshold can retain labels" { + let result = @src.banksy_smooth_labels( + [0, 1, 0, 1], + [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [3.0, 0.0]], + k=1, + proportion_threshold=1.0, + max_iterations=2, + ) catch { + _ => abort("strict BANKSY smoothing should compute") + } + assert_eq(result.labels, [0, 1, 0, 1]) + assert_eq(result.changed_labels, 0) +} + +///| +test "BANKSY: smoothing validates controls" { + let k = try { + ignore(@src.banksy_smooth_labels([0, 1], [[0.0, 0.0], [1.0, 0.0]], k=2)) + false + } catch { + BanksyError(_) => true + } + let threshold = try { + ignore( + @src.banksy_smooth_labels( + [0, 1], + [[0.0, 0.0], [1.0, 0.0]], + k=1, + proportion_threshold=1.1, + ), + ) + false + } catch { + BanksyError(_) => true + } + let iterations = try { + ignore( + @src.banksy_smooth_labels( + [0, 1], + [[0.0, 0.0], [1.0, 0.0]], + k=1, + max_iterations=0, + ), + ) + false + } catch { + BanksyError(_) => true + } + assert_true(k) + assert_true(threshold) + assert_true(iterations) +} + +///| +test "BANKSY: spatial agreement identifies homogeneous labels" { + let coordinates = [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [3.0, 0.0]] + let homogeneous = @src.banksy_spatial_agreement( + [0, 0, 0, 0], + coordinates, + k=2, + ) catch { + _ => abort("homogeneous agreement should compute") + } + let alternating = @src.banksy_spatial_agreement( + [0, 1, 0, 1], + coordinates, + k=1, + ) catch { + _ => abort("alternating agreement should compute") + } + assert_eq(homogeneous, 1.0) + assert_true(alternating < homogeneous) +} + +///| +test "BANKSY: ARI is one for identical and relabeled partitions" { + let identical = @src.banksy_adjusted_rand_index([0, 0, 1, 1, 2, 2], [ + 0, 0, 1, 1, 2, 2, + ]) catch { + _ => abort("identical ARI should compute") + } + let relabeled = @src.banksy_adjusted_rand_index([0, 0, 1, 1, 2, 2], [ + 2, 2, 0, 0, 1, 1, + ]) catch { + _ => abort("relabeled ARI should compute") + } + assert_eq(identical, 1.0) + assert_eq(relabeled, 1.0) +} + +///| +test "BANKSY: ARI detects disagreeing partitions" { + let value = @src.banksy_adjusted_rand_index([0, 0, 0, 1, 1, 1], [ + 0, 1, 0, 1, 0, 1, + ]) catch { + _ => abort("disagreeing ARI should compute") + } + assert_true(value < 0.3) +} + +///| +test "BANKSY: ARI validates label vectors" { + let length = try { + ignore(@src.banksy_adjusted_rand_index([0, 1], [0])) + false + } catch { + BanksyError(_) => true + } + let negative = try { + ignore(@src.banksy_adjusted_rand_index([0, -1], [0, 1])) + false + } catch { + BanksyError(_) => true + } + assert_true(length) + assert_true(negative) +} + +///| +test "BANKSY: complete run exposes matrix PCA clustering and agreement" { + let run = @src.banksy_run( + banksy_test_model(), + lambda=0.2, + n_components=3, + cluster_config=banksy_test_cluster_config(), + max_harmonic=1, + scale=true, + smooth=false, + smoothing_k=3, + ) catch { + _ => abort("complete BANKSY run should compute") + } + assert_eq(run.lambda, 0.2) + assert_eq(run.matrix.n_features(), 15) + assert_eq(run.pca.n_components, 3) + assert_eq(run.clustering.n_clusters(), 2) + assert_true(run.smoothing is None) + assert_true(run.spatial_agreement >= 0.0) + assert_true(run.spatial_agreement <= 1.0) + assert_eq(run.final_labels(), run.clustering.labels) +} + +///| +test "BANKSY: complete run can smooth labels" { + let run = @src.banksy_run( + banksy_test_model(), + lambda=0.8, + n_components=3, + cluster_config=banksy_test_cluster_config(), + max_harmonic=1, + smooth=true, + smoothing_k=3, + smoothing_iterations=5, + ) catch { + _ => abort("smoothed BANKSY run should compute") + } + assert_true(run.smoothing is Some(_)) + assert_eq(run.final_labels().length(), 24) +} + +///| +test "BANKSY: run summary includes lambda and spatial agreement" { + let run = @src.banksy_run( + banksy_test_model(), + lambda=0.2, + n_components=3, + cluster_config=banksy_test_cluster_config(), + smoothing_k=3, + ) catch { + _ => abort("BANKSY summary run should compute") + } + let summary = run.summary() + assert_true(summary.contains("lambda=0.2")) + assert_true(summary.contains("spatial agreement")) +} + +///| +test "BANKSY: parameter sweep preserves lambda order" { + let runs = @src.banksy_parameter_sweep( + banksy_test_model(), + [0.0, 0.2, 0.8], + n_components=3, + cluster_config=banksy_test_cluster_config(), + max_harmonic=1, + ) catch { + _ => abort("BANKSY parameter sweep should compute") + } + assert_eq(runs.length(), 3) + assert_eq(runs[0].lambda, 0.0) + assert_eq(runs[1].lambda, 0.2) + assert_eq(runs[2].lambda, 0.8) +} + +///| +test "BANKSY: parameter sweep rejects empty lambda list" { + let failed = try { + ignore( + @src.banksy_parameter_sweep( + banksy_test_model(), + [], + n_components=3, + cluster_config=banksy_test_cluster_config(), + ), + ) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} + +///| +test "BANKSY: SpatialExperiment wrapper writes harmonics and labels" { + let output = @src.banksy_spatial_experiment( + banksy_test_experiment(), + config=banksy_test_config(@src.banksy_knn_median()), + lambda=0.2, + n_components=3, + cluster_config=banksy_test_cluster_config(), + max_harmonic=1, + group_key="section", + smooth=true, + smoothing_k=3, + smoothing_iterations=5, + ) catch { + _ => abort("BANKSY SpatialExperiment integration should compute") + } + assert_true(output.experiment.assay.contains("logcounts")) + assert_true(output.experiment.assay.contains("H0")) + assert_true(output.experiment.assay.contains("H1")) + assert_eq(output.experiment.assay["H0"].length(), 5) + assert_eq(output.experiment.assay["H0"][0].length(), 24) + assert_true(output.experiment.col_data[0].contains("banksy_cluster")) + assert_true(output.experiment.col_data[0].contains("banksy_cluster_raw")) + assert_eq(output.experiment.metadata["banksy_assay"], "logcounts") + assert_eq(output.experiment.metadata["banksy_lambda"], "0.2") + assert_eq(output.experiment.metadata["banksy_max_harmonic"], "1") + assert_eq(output.model.n_spots(), 24) +} + +///| +test "BANKSY: SpatialExperiment wrapper does not mutate its input" { + let experiment = banksy_test_experiment() + let output = @src.banksy_spatial_experiment( + experiment, + config=banksy_test_config(@src.banksy_knn_median()), + lambda=0.2, + n_components=3, + cluster_config=banksy_test_cluster_config(), + max_harmonic=1, + smooth=false, + smoothing_k=3, + ) catch { + _ => abort("immutable BANKSY integration should compute") + } + assert_true(!experiment.assay.contains("H0")) + assert_true(!experiment.col_data[0].contains("banksy_cluster")) + assert_true(!experiment.metadata.contains("banksy_lambda")) + output.experiment.assay["H0"][0][0] = 999.0 + assert_true(experiment.assay["logcounts"][0][0] != 999.0) +} + +///| +test "BANKSY: SpatialExperiment wrapper generates missing annotations" { + let (expression, coordinates, _, _) = @src.banksy_example_data() + let experiment = @src.SpatialExperiment::new() + ignore(@src.se_add_assay(experiment, "logcounts", expression)) + for coordinate in coordinates { + ignore( + @src.se_add_spatial_coord( + experiment, + @src.SpatialCoord::new_2d(coordinate[0], coordinate[1]), + ), + ) + } + let output = @src.banksy_spatial_experiment( + experiment, + config=banksy_test_config(@src.banksy_knn_median()), + n_components=3, + cluster_config=banksy_test_cluster_config(), + max_harmonic=1, + smooth=false, + smoothing_k=3, + ) catch { + _ => abort("BANKSY should generate missing annotations") + } + assert_eq(output.experiment.row_data.length(), 5) + assert_eq(output.experiment.col_data.length(), 24) + assert_eq(output.experiment.row_data[0]["gene_name"], "gene_1") + assert_eq(output.experiment.col_data[0]["spot_id"], "spot_1") +} + +///| +test "BANKSY: SpatialExperiment wrapper validates assay and coordinates" { + let missing_assay = try { + ignore( + @src.banksy_spatial_experiment( + @src.SpatialExperiment::new(), + assay_name="missing", + ), + ) + false + } catch { + BanksyError(_) => true + } + let experiment = @src.SpatialExperiment::new() + ignore(@src.se_add_assay(experiment, "logcounts", [[1.0, 2.0]])) + let missing_coordinates = try { + ignore( + @src.banksy_spatial_experiment( + experiment, + config=@src.BanksyComputeConfig::create(k_geom=[1]), + n_components=1, + cluster_config=@src.BanksyClusterConfig::create(n_clusters=1), + ), + ) + false + } catch { + BanksyError(_) => true + } + assert_true(missing_assay) + assert_true(missing_coordinates) +} + +///| +test "BANKSY: SpatialExperiment wrapper validates grouping field" { + let failed = try { + ignore( + @src.banksy_spatial_experiment( + banksy_test_experiment(), + config=banksy_test_config(@src.banksy_knn_median()), + n_components=3, + cluster_config=banksy_test_cluster_config(), + max_harmonic=1, + group_key="missing", + smooth=false, + smoothing_k=3, + ), + ) + false + } catch { + BanksyError(_) => true + } + assert_true(failed) +} From 6aa169e786683526988cd2c21803c97a045a5230 Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 17:06:34 +0800 Subject: [PATCH 30/41] 328 feat(align_sam): Bio.Align.sam alignment-aware SAM implementation & SAM header/reference & CIGAR clip & MD/NM --- README.md | 29 +- examples/align_sam_demo/main.mbt | 153 +++ examples/align_sam_demo/moon.pkg | 5 + src/align_sam.mbt | 2072 ++++++++++++++++++++++++++++++ test/moonbit/align_sam_test.mbt | 1232 ++++++++++++++++++ 5 files changed, 3487 insertions(+), 4 deletions(-) create mode 100644 examples/align_sam_demo/main.mbt create mode 100644 examples/align_sam_demo/moon.pkg create mode 100644 src/align_sam.mbt create mode 100644 test/moonbit/align_sam_test.mbt diff --git a/README.md b/README.md index 166af11c..2c246226 100644 --- a/README.md +++ b/README.md @@ -35,6 +35,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **共享参考比对合并** | Biopython `Bio.Align.Alignment` | 合并共享同一参考序列的PWA/MSA、同步insertion slots、保留局部坐标与metadata、双向坐标映射 | ✅ | | **Alignment详细统计** | Biopython `Bio.Align.Alignment.counts` | 左/内部/右 insertion/deletion、gap open/extend、identity/mismatch/positive、wildcard、替换矩阵和十二类affine gap评分 | ✅ | | **PSL/PSLX成对比对** | Biopython `Bio.Align.psl` | 21/23列严格读写、核酸与translated DNA-protein路径、正反链坐标、block/gap统计、sequence-aware recount及坐标映射 | ✅ | +| **Alignment-aware SAM** | Biopython `Bio.Align.sam` | SAM header与typed tag严格读写、CIGAR坐标路径、正反链、soft/hard clipping、PHRED、MD/NM及坐标映射 | ✅ | | **系统发育树** | Biopython `Bio.Phylo` | 树结构、Newick 解析、距离计算、可视化 | ✅ | | **PDB 结构** | Biopython `Bio.PDB` | 原子/残基/链解析、结构操作 | ✅ | | **BinaryCIF** | Biopython `Bio.PDB.binary_cif` | MessagePack解析、七类逆编码、三态缺失值、类别查询、PDB Structure转换 | ✅ | @@ -164,6 +165,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | Bio.Align.Alignment map/mapall | 零起始半开区间alignment path组合、局部clipping、gap与正反链传播、双向坐标查询、PSL、批量map及protein MSA到codon-aware nucleotide MSA投影 | | ✅ | Bio.Align.Alignment counts | pairwise/MSA详细gap分类、open/extend事件、identity/mismatch/positive、wildcard、替换矩阵与完整affine总分 | | ✅ | Bio.Align.psl | alignment-aware PSL/PSLX 21/23列严格解析与写出、核酸和translated 3:1路径、双轴链向、match/repeat/N recount、block序列及坐标互映 | +| ✅ | Bio.Align.sam | alignment-aware SAM header/record严格读写、显式CIGAR path、反向链序列与PHRED语义、typed tags、MD/NM和双向坐标映射 | | ✅ | Bio.Align.bigbed | BigBed v4二进制读写、BED3-BED12、AutoSQL扩展字段、多级chromosome B+ tree与R-tree、zlib/DEFLATE解码、区间/名称查询和BED导出 | | ✅ | Bio.Align.bigmaf | 标准bedMaf bed3+1读写、完整MAF a/s/i/e/q语义、正负链坐标映射、BigBed压缩索引查询、MAF导出和严格损坏数据诊断 | | ✅ | Bioconductor decontX | 单细胞ambient RNA去污染: cluster-native/contaminant多项式混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解、诊断与SingleCellExperiment接入 | @@ -229,6 +231,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **共享参考比对合并** | Biopython `Bio.Align.Alignment.from_alignments_with_same_reference` | 混合PWA/MSA输入、首端/内部/末端insertion同步、多query投影、局部坐标与metadata保留、统计和格式转换 | ✅ | | **Alignment坐标组合** | Biopython `Bio.Align.Alignment.map/mapall` | alignment path组合、局部overhang clipping、exon/intron与indel gap、正反链组合、坐标双向查询、PSL及1:1/1:3 MSA投影 | ✅ | | **Alignment详细计数与评分** | Biopython `Bio.Align.Alignment.counts` | 十二类affine gap事件、identity/mismatch/positive、wildcard、BLOSUM/PAM评分、反向链和MSA全部序列对汇总 | ✅ | +| **SAM坐标比对读写** | Biopython `Bio.Align.sam` | header/reference模型、M/I/D/N/=/X显式路径、反向链与clipping、typed tags、PHRED、MD/NM和严格往返 | ✅ | | **BigBed二进制区间索引** | Biopython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12与AutoSQL、多级B+ tree/R-tree、stored/fixed/dynamic DEFLATE、区间/名称查询、链感知exon坐标及BED导出 | ✅ | | **BigMaf多物种比对索引** | Biopython `Bio.Align.bigmaf` | 标准bedMaf AutoSQL、MAF a/s/i/e/q块、score/pass/comment、正负链坐标映射、压缩BigBed索引查询及普通MAF导出 | ✅ | | **BigPsl成对比对索引** | Biopython `Bio.Align.bigpsl` | 标准bed12+13 AutoSQL、核酸与translated protein坐标路径、正反链、match/repeat/N recount、压缩索引查询及PSL导出 | ✅ | @@ -379,6 +382,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **Alignment gap/composition统计** | Biopython `Bio.Align.Alignment.counts` | pairwise与MSA逐对统计、端部/内部gap分类、open/extend事件、替换和gap总分 | ✅ | | **Alignment-aware tabular搜索结果** | Biopython `Bio.Align.tabular` | BLAST outfmt 7、FASTA 8CB/8CC、BTOP/aln_code路径、链向及translated坐标 | ✅ | | **Alignment-aware PSL/PSLX** | Biopython `Bio.Align.psl` | 21/23列格式、header、block/gap一致性、正反链、translated 3:1坐标、序列重计数与严格诊断 | ✅ | +| **Alignment-aware SAM** | Biopython `Bio.Align.sam` | SAM 1.6 header/record、typed optional tags、CIGAR path、clipping、反向链、PHRED、MD/NM与规范写回 | ✅ | | **UCSC Chain文件/liftOver** | Bioconductor rtracklayer | Chain格式解析、基因组坐标liftOver转换、链段查找、染色体间坐标映射、位置/区间转换 | ✅ | | **Biostrings matchPDict** | Bioconductor Biostrings | 字典模式匹配(matchPDict/vmatchPattern)、多序列模式计数(vcountPattern)、错配容忍、最佳匹配查找 | ✅ | | **GenomicRanges gaps/reduce/disjoin** | Bioconductor GenomicRanges | gaps检测、reduce合并、disjoin拆分、setdiff/交集/并集集合运算、coverage计算、promoters提取、trim | ✅ | @@ -439,6 +443,7 @@ IvanAXu/BioSeqs/ │ ├── alignment_counts.mbt # Bio.Align.Alignment.counts详细gap/composition统计与评分 │ ├── align_tabular.mbt # Bio.Align.tabular BLAST/FASTA traceback表格解析与坐标路径 │ ├── align_psl.mbt # Bio.Align.psl PSL/PSLX严格读写、链向路径、统计与坐标映射 +│ ├── align_sam.mbt # Bio.Align.sam严格读写、CIGAR路径、typed tags、MD/NM与反向链 │ ├── bigbed.mbt # Bio.Align.bigbed v4、BED/AutoSQL、多级B+ tree/R-tree与DEFLATE │ ├── bigmaf.mbt # Bio.Align.bigmaf bedMaf、MAF注释、链向坐标映射与索引查询 │ ├── bigpsl.mbt # Bio.Align.bigpsl bed12+13、核酸/translated protein路径与PSL @@ -1143,6 +1148,7 @@ IvanAXu/BioSeqs/ │ ├── alignment_counts_demo/ # Alignment.counts gap分类、affine/BLOSUM评分、反链与MSA汇总示例 │ ├── align_tabular_demo/ # BLAST BTOP、FASTA aln_code与translated反链坐标解析示例 │ ├── align_psl_demo/ # PSL/PSLX读写、反链映射、translated recount与文档摘要示例 +│ ├── align_sam_demo/ # SAM header/path、反链、splicing、typed tags、MD/NM与往返示例 │ ├── bigbed_demo/ # BigBed写入/解析、索引查询、负链exon坐标、BED导出与损坏诊断 │ ├── bigmaf_demo/ # BigMaf压缩写入、bedMaf schema、区间查询、负链映射与MAF导出 │ ├── bigpsl_demo/ # BigPsl压缩写入、R-tree查询、反链/translated坐标与PSL导出 @@ -1357,6 +1363,7 @@ IvanAXu/BioSeqs/ │ │ ├── alignment_counts_test.mbt │ │ ├── align_tabular_test.mbt │ │ ├── align_psl_test.mbt +│ │ ├── align_sam_test.mbt │ │ ├── bigbed_test.mbt │ │ ├── bigmaf_test.mbt │ │ ├── bigpsl_test.mbt @@ -1536,7 +1543,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 9639 个测试全部通过 +moon test # ✅ 9733 个测试全部通过 ``` ### 模块对照表 @@ -1586,6 +1593,7 @@ moon test # ✅ 9639 个测试全 | `alignment_counts.mbt` | BioPython `Bio.Align.Alignment.counts` | left/internal/right insertion/deletion、open/extend、composition、wildcard、替换矩阵与十二类affine gap评分 | | `align_tabular.mbt` | BioPython `Bio.Align.tabular` | BLAST outfmt 7与FASTA 8CB/8CC元数据、BTOP/CIGAR traceback、链向及translated坐标 | | `align_psl.mbt` | BioPython `Bio.Align.psl` | PSL/PSLX header与21/23列严格读写、核酸/translated block路径、正反链、match分类、recount及坐标转换 | +| `align_sam.mbt` | BioPython `Bio.Align.sam` | SAM header/reference与record严格读写、typed tags、CIGAR path、反向链、clipping、PHRED、MD/NM及坐标互映 | | `bigbed.mbt` | BioPython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12、AutoSQL、多级chromosome B+ tree/R-tree、zlib/DEFLATE及索引查询 | | `bigmaf.mbt` | BioPython `Bio.Align.bigmaf` | bedMaf bed3+1读写、MAF a/s/i/e/q、正负链坐标映射、压缩索引查询、摘要和MAF导出 | | `bigpsl.mbt` | BioPython `Bio.Align.bigpsl` | bed12+13读写、核酸/translated protein路径、双向坐标映射、recount、压缩查询、摘要和PSL导出 | @@ -1619,6 +1627,7 @@ moon test # ✅ 9639 个测试全 | MoonBit 文件 | 对应 Python 库 | 核心功能 | | :--- | :--- | :--- | | `sam.mbt` | pysam | SAM 文件解析 | +| `align_sam.mbt` | Biopython `Bio.Align.sam` | alignment-aware SAM严格解析与写出、显式坐标路径、typed tags、MD/NM、PHRED及正反链映射 | | `bam.mbt` | pysam | BAM 文件解析 | | `bgzf.mbt` | pysam | BGZF 解压缩 | | `vcf.mbt` | pysam | VCF 文件解析 | @@ -1867,6 +1876,7 @@ moon test # ✅ 9639 个测试全 | `alignment_counts.mbt` | `Bio.Align.Alignment.counts` | pairwise/MSA gap事件和composition汇总、正反链、wildcard、替换矩阵及完整affine评分 | | `align_tabular.mbt` | `Bio.Align.tabular` | BLAST/FASTA query block、完整字段词汇、BTOP/aln_code路径、translated轴换算、过滤与coordinate alignment转换 | | `align_psl.mbt` | `Bio.Align.psl` | PSL/PSLX类型模型、严格字段与block一致性、核酸反向query、translated反向target、3:1 codon映射、序列重计数与往返 | +| `align_sam.mbt` | `Bio.Align.sam` | header/reference与alignment类型模型、CIGAR路径、反向链与clipping、typed tags、PHRED、MD/NM、规范读写和坐标查询 | | `bigbed.mbt` | `Bio.Align.bigbed` | BigBed v4二进制读写、BED/AutoSQL、平衡B+ tree/R-tree、完整DEFLATE块解码、区间/名称查询与BED导出 | | `bigmaf.mbt` | `Bio.Align.bigmaf` | bedMaf AutoSQL与MAF块往返、a/s/i/e/q注释、链感知坐标映射、BigBed索引查询和普通MAF导出 | | `bigpsl.mbt` | `Bio.Align.bigpsl` | 标准bigPsl AutoSQL、核酸与translated DNA-protein坐标、链感知映射、match分类、BigBed索引和PSL导出 | @@ -3068,6 +3078,14 @@ BTOP 和 FASTA CIGAR 会合并连续 operation 并重建显式 target/query coor `banksy_spatial_experiment` 从指定 assay、rowData、colData 和二维/三维 spatial coordinates 构建模型，在不可变容器副本中写回 `H0..HM` assays、原始/平滑 cluster 标签与 metadata。所有入口校验矩阵方向、矩形性、有限值、名称唯一性、邻域/采样边界、lambda、PCA/聚类维度及分组完整性。当前实现使用 dense MoonBit arrays、确定性单线程 Jacobi PCA 与 k-means，不依赖 R、BiocParallel、igraph、Leiden 或稀疏矩阵后端。 +### 265. Alignment-aware SAM 严格读写与坐标模型 (Biopython Bio.Align.sam) + +实现 Biopython 1.86 `Bio.Align.sam` 的 alignment-aware SAM 模型，并与已有宽松记录级 `sam.mbt` 并存。`align_sam_parse` 解析 `@HD/@SQ/@RG/@PG/@CO` 及扩展 header，索引 reference metadata；每条 mapped record 将 1-based `POS/PNEXT` 规范化为 0-based 坐标，并从 `M/I/D/N/=/X` 构建显式 target/query path。soft/hard clipping 保留在 CIGAR 元数据中，`N` 与 deletion 分开统计；反向链 query sequence 和 PHRED 转为生物学正向语义，坐标递减，写回时恢复 SAM 存储方向。 + +optional tags 保留 `A/i/f/Z/H/B:c/C/s/S/i/I/f` 的类型和数组 subtype，提供类型化构造与防御性查询。模块支持 CIGAR 统计、flag/reference/mate访问、target-query 双向坐标映射、aligned row 重建、MD reference reconstruction、NM 计算及基于完整 reference 的 MD 生成。`align_sam_format` 和 `align_sam_write` 提供规范 record/document 往返，`align_sam_create` 从生物学方向的 sequence、qualities、CIGAR 和 typed tags 构造 mapped alignment。 + +解析器严格诊断 header 顺序与重复 reference、字段数和整数边界、mapped/unmapped 一致性、reference 越界、CIGAR clipping/P 操作、SEQ/QUAL/CIGAR 长度、PHRED 范围、重复或非法 tag、B-array subtype/range，以及 MD token 与 CIGAR `=/X/D` 的逐碱基结构冲突。当前范围聚焦 SAM 文本和 alignment coordinate semantics，不解码 BAM/CRAM；二进制格式继续由现有 `bam.mbt`、`cram_wbtest.mbt` 负责。 + ## 性能优化 ### 优化策略 @@ -3169,8 +3187,8 @@ BTOP 和 FASTA CIGAR 会合并连续 operation 并重建显式 target/query coor | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 9639 | -| 通过数 | 9639 | +| 总测试数 | 9733 | +| 通过数 | 9733 | | 失败数 | 0 | | 通过率 | 100% | @@ -3277,6 +3295,7 @@ moon test --update | Bio.Align Alignment.counts | `alignment_counts_test.mbt` | 57 | | Bio.Align.tabular | `align_tabular_test.mbt` | 90 | | Bio.Align.psl | `align_psl_test.mbt` | 93 | +| Bio.Align.sam | `align_sam_test.mbt` | 94 | | Bio.Align.bigbed | `bigbed_test.mbt` | 64 | | Bio.Align.bigmaf | `bigmaf_test.mbt` | 79 | | SparseArray | `sparse_array_test.mbt` | 41 | @@ -3582,7 +3601,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 372 个示例程序，展示各模块的典型用法： +项目提供 373 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3781,6 +3800,7 @@ moon run cmd/bench/main.mbt | alignment_counts_demo | left/internal/right gap与open/extend、affine/BLOSUM45评分、反向链和MSA逐对汇总 | `moon run examples/alignment_counts_demo` | | align_tabular_demo | BLAST outfmt 7 BTOP、FASTA 8CC aln_code、最佳命中和TBLASTX反链translated坐标 | `moon run examples/align_tabular_demo` | | align_psl_demo | PSL/PSLX多记录读写、反向query映射、translated target recount、block sequence和摘要 | `moon run examples/align_psl_demo` | +| align_sam_demo | SAM header/reference、正反链CIGAR路径、splicing、typed tags、PHRED、MD/NM、aligned rows与规范往返 | `moon run examples/align_sam_demo` | | bigbed_demo | BigBed v4压缩写入/解析、AutoSQL、多级索引查询、负链exon坐标、BED导出及损坏文件诊断 | `moon run examples/bigbed_demo` | | bigmaf_demo | BigMaf压缩bed3+1写入、bedMaf schema、R-tree区间查询、负链物种坐标映射和MAF a/s/i/e/q导出 | `moon run examples/bigmaf_demo` | | bigpsl_demo | BigPsl bed12+13压缩写入、AutoSQL、R-tree查询、反向核酸/translated protein坐标和PSL导出 | `moon run examples/bigpsl_demo` | @@ -3894,6 +3914,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bio.Align.Alignment counts（left/internal/right insertion/deletion、gap open/extend、identity/mismatch/positive、wildcard、替换矩阵、affine评分及MSA逐对汇总） - ✅ 实现 Bio.Align.tabular alignment-aware搜索结果解析（BLAST outfmt 7、FASTA 8CB/8CC、BTOP/aln_code、正反链与translated坐标、零命中query） - ✅ 实现 Bio.Align.psl alignment-aware PSL/PSLX（21/23列严格读写、核酸/translated路径、双轴链向、block/gap统计、match recount、坐标映射与往返） +- ✅ 实现 Bio.Align.sam alignment-aware SAM（header/reference与typed tags、CIGAR坐标路径、正反链与clipping、PHRED、MD/NM、严格校验及规范往返） - ✅ 实现 Bio.Align.bigbed BigBed v4二进制区间格式（BED3-BED12、AutoSQL、多级B+ tree/R-tree、DEFLATE、区间/名称查询与BED导出） - ✅ 实现 Bio.Align.bigmaf BigMaf多物种比对索引（标准bedMaf、MAF a/s/i/e/q、正负链坐标映射、压缩BigBed查询与MAF导出） - ✅ 实现 Bio.Align.bigpsl BigPsl成对比对索引（标准bed12+13、核酸/translated protein坐标、match recount、压缩BigBed查询与PSL导出） diff --git a/examples/align_sam_demo/main.mbt b/examples/align_sam_demo/main.mbt new file mode 100644 index 00000000..9e7a59ca --- /dev/null +++ b/examples/align_sam_demo/main.mbt @@ -0,0 +1,153 @@ +///| +fn parse_sam(text : String) -> @src.AlignSamDocument { + @src.align_sam_parse(text) catch { + AlignSamError(message) => abort("SAM parsing failed: " + message) + } +} + +///| +fn demo_reference() -> String { + "N".repeat(4) + "ACGTTCGGAA" + "N".repeat(26) +} + +///| +fn optional_int(value : Int?) -> String { + match value { + Some(item) => item.to_string() + None => "unknown" + } +} + +///| +fn coordinate_text(values : Array[Int]) -> String { + let output = StringBuilder::new() + output.write_char('[') + for index in 0.. 0 { + output.write_string(", ") + } + output.write_string(values[index].to_string()) + } + output.write_char(']') + output.to_string() +} + +///| +fn main { + println("=== Biopython Bio.Align.sam Demo ===") + + println("\n1. Parse headers, references, and records") + let document = parse_sam(@src.align_sam_example_data()) + println( + " headers=" + + document.headers.length().to_string() + + ", references=" + + document.references.length().to_string() + + ", alignments=" + + document.alignments.length().to_string(), + ) + match document.reference("chr1") { + Some(reference) => + println( + " reference " + + reference.name + + ", length=" + + reference.length.to_string(), + ) + None => abort("chr1 was not indexed") + } + + println("\n2. Inspect a clipped and gapped forward alignment") + let forward = document.alignments[0] + let stats = forward.stats() + println(" " + forward.summary()) + println( + " CIGAR=" + + @src.align_sam_cigar_string(forward.cigar) + + ", query bases=" + + stats.query_consumed.to_string() + + ", reference bases=" + + stats.reference_consumed.to_string(), + ) + match forward.target_to_query(8) { + Some(position) => + println(" target base 8 maps to query base " + position.to_string()) + None => println(" target base 8 lies in a gap") + } + let md = match forward.string_tag("MD") { + Some(value) => value + None => "unknown" + } + println(" NM=" + optional_int(forward.computed_nm()) + ", MD=" + md) + + println("\n3. Reconstruct aligned rows and calculate MD") + let rows = forward.aligned_rows(reference_sequence=demo_reference()) catch { + AlignSamError(message) => abort("row reconstruction failed: " + message) + } + let calculated_md = @src.align_sam_calculate_md(forward, demo_reference()) catch { + AlignSamError(message) => abort("MD calculation failed: " + message) + } + println(" target " + rows.0) + println(" query " + rows.1) + println(" calculated MD=" + calculated_md) + + println("\n4. Inspect reverse-strand and spliced coordinates") + let reverse = document.alignments[1] + println( + " reverse=" + + reverse.is_reverse().to_string() + + ", biological query=" + + reverse.query_sequence, + ) + println( + " query path " + + coordinate_text(reverse.query_coordinates) + + ", skipped reference bases=" + + reverse.stats().skipped.to_string(), + ) + match reverse.target_to_query(27) { + Some(position) => + println( + " target base 27 maps to reverse query base " + position.to_string(), + ) + None => println(" target base 27 lies in the skipped interval") + } + + println("\n5. Construct and round-trip a typed SAM record") + let tags = [ + @src.align_sam_integer_tag("NM", 0), + @src.align_sam_string_tag("RG", "demo"), + @src.align_sam_float_array_tag("BF", [0.25, 0.75]), + ] catch { + AlignSamError(message) => abort("tag construction failed: " + message) + } + let created = @src.align_sam_create( + "created_read", + "chr1", + 40, + 15, + "AACGTT", + "1S4M1S", + reverse=true, + mapq=50, + qualities=[30, 31, 32, 33, 34, 35], + tags~, + ) catch { + AlignSamError(message) => abort("alignment construction failed: " + message) + } + let record = @src.align_sam_format(created) catch { + AlignSamError(message) => abort("SAM formatting failed: " + message) + } + let reparsed = parse_sam("@SQ\tSN:chr1\tLN:40\n" + record).alignments[0] + println(" " + record) + println( + " round-trip query=" + + reparsed.query_sequence + + ", mapq=" + + optional_int(reparsed.mapq) + + ", tags=" + + reparsed.tags.length().to_string(), + ) + + println("=== Demo Complete ===") +} diff --git a/examples/align_sam_demo/moon.pkg b/examples/align_sam_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/align_sam_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/align_sam.mbt b/src/align_sam.mbt new file mode 100644 index 00000000..d8064c83 --- /dev/null +++ b/src/align_sam.mbt @@ -0,0 +1,2072 @@ +// Alignment-aware SAM parsing, coordinate paths, typed tags, and writing. +// +// This module follows Biopython 1.86 Bio.Align.sam semantics. SAM POS and +// PNEXT fields are converted from one-based coordinates to zero-based values. + +///| +pub suberror AlignSamError { + AlignSamError(String) +} + +///| +pub(all) enum AlignSamOperation { + SamAligned + SamInsertion + SamDeletion + SamSkipped + SamEqual + SamMismatch +} derive(Eq, Debug) + +///| +pub(all) enum AlignSamTagValue { + SamTagInteger(Int) + SamTagFloat(Double) + SamTagCharacter(String) + SamTagString(String) + SamTagHex(String) + SamTagIntegerArray(String, Array[Int]) + SamTagFloatArray(Array[Double]) +} derive(Debug) + +///| +pub struct AlignSamHeaderField { + key : String + value : String +} derive(Eq, Debug) + +///| +pub struct AlignSamHeader { + record_type : String + fields : Array[AlignSamHeaderField] + comment : String +} derive(Debug) + +///| +pub struct AlignSamReference { + name : String + length : Int + annotations : Array[AlignSamHeaderField] +} derive(Debug) + +///| +pub struct AlignSamCigarElement { + operation : String + length : Int +} derive(Eq, Debug) + +///| +pub struct AlignSamTag { + name : String + value : AlignSamTagValue +} derive(Debug) + +///| +pub struct AlignSamStats { + reference_consumed : Int + query_consumed : Int + aligned : Int + inserted : Int + deleted : Int + skipped : Int + soft_clipped : Int + hard_clipped : Int +} derive(Eq, Debug) + +///| +pub struct AlignSamAlignment { + query_name : String + flag : Int + reference_name : String + reference_length : Int? + target_coordinates : Array[Int] + query_coordinates : Array[Int] + operations : Array[AlignSamOperation] + cigar : Array[AlignSamCigarElement] + mapq : Int? + mate_reference : String? + mate_position : Int? + template_length : Int? + query_sequence : String + sequence_known : Bool + qualities : Array[Int] + qualities_known : Bool + hard_clip_left : Int? + hard_clip_right : Int? + tags : Array[AlignSamTag] +} + +///| +pub struct AlignSamDocument { + headers : Array[AlignSamHeader] + references : Array[AlignSamReference] + alignments : Array[AlignSamAlignment] +} + +///| +fn align_sam_fail(message : String) -> Unit raise AlignSamError { + raise AlignSamError(message) +} + +///| +fn align_sam_copy_ints(values : Array[Int]) -> Array[Int] { + let copy : Array[Int] = [] + for value in values { + copy.push(value) + } + copy +} + +///| +fn align_sam_copy_doubles(values : Array[Double]) -> Array[Double] { + let copy : Array[Double] = [] + for value in values { + copy.push(value) + } + copy +} + +///| +fn align_sam_copy_tag_value(value : AlignSamTagValue) -> AlignSamTagValue { + match value { + SamTagInteger(item) => SamTagInteger(item) + SamTagFloat(item) => SamTagFloat(item) + SamTagCharacter(item) => SamTagCharacter(item) + SamTagString(item) => SamTagString(item) + SamTagHex(item) => SamTagHex(item) + SamTagIntegerArray(kind, items) => + SamTagIntegerArray(kind, align_sam_copy_ints(items)) + SamTagFloatArray(items) => SamTagFloatArray(align_sam_copy_doubles(items)) + } +} + +///| +fn align_sam_copy_cigar( + values : Array[AlignSamCigarElement], +) -> Array[AlignSamCigarElement] { + let copy : Array[AlignSamCigarElement] = [] + for value in values { + copy.push(AlignSamCigarElement::{ + operation: value.operation, + length: value.length, + }) + } + copy +} + +///| +fn align_sam_copy_fields( + values : Array[AlignSamHeaderField], +) -> Array[AlignSamHeaderField] { + let copy : Array[AlignSamHeaderField] = [] + for value in values { + copy.push(AlignSamHeaderField::{ key: value.key, value: value.value }) + } + copy +} + +///| +fn align_sam_strip_cr(value : String) -> String { + if value.length() > 0 && + value.unsafe_get(value.length() - 1).to_int() == '\r'.to_int() { + value[0:value.length() - 1].to_owned() + } else { + value + } +} + +///| +fn align_sam_split_lines(value : String) -> Array[String] { + let lines : Array[String] = [] + let mut start = 0 + for index in 0.. Array[String] { + let parts : Array[String] = [] + let mut start = 0 + for index in 0.. Int? { + for index in start.. Int raise AlignSamError { + if value.length() == 0 { + align_sam_fail(label + " is missing") + } + let mut index = 0 + let negative = value.unsafe_get(0).to_int() == '-'.to_int() + if negative || value.unsafe_get(0).to_int() == '+'.to_int() { + index = 1 + } + if index == value.length() { + align_sam_fail(label + " is not an integer") + } + if value == "-2147483648" { + return -2147483647 - 1 + } + let mut result = 0 + while index < value.length() { + let code = value.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + align_sam_fail(label + " is not an integer: " + value) + } + let digit = code - '0'.to_int() + if result > (2147483647 - digit) / 10 { + align_sam_fail(label + " exceeds the MoonBit Int range") + } + result = result * 10 + digit + index = index + 1 + } + if negative { + -result + } else { + result + } +} + +///| +fn align_sam_parse_double( + value : String, + label : String, +) -> Double raise AlignSamError { + match parse_double(value) { + Some(result) => { + if result.abs() > 1.0e300 { + align_sam_fail(label + " must be finite") + } + result + } + None => { + align_sam_fail(label + " is not a floating-point number: " + value) + 0.0 + } + } +} + +///| +fn align_sam_validate_token( + value : String, + label : String, + allow_star : Bool, +) -> Unit raise AlignSamError { + if value.length() == 0 { + align_sam_fail(label + " must not be empty") + } + if value == "*" && allow_star { + return + } + for index in 0.. Unit raise AlignSamError { + if name.length() != 2 { + align_sam_fail("SAM tag names must contain exactly two characters") + } + let first = name.unsafe_get(0).to_int() + let second = name.unsafe_get(1).to_int() + let first_ok = (first >= 'A'.to_int() && first <= 'Z'.to_int()) || + (first >= 'a'.to_int() && first <= 'z'.to_int()) + let second_ok = (second >= 'A'.to_int() && second <= 'Z'.to_int()) || + (second >= 'a'.to_int() && second <= 'z'.to_int()) || + (second >= '0'.to_int() && second <= '9'.to_int()) + if !first_ok || !second_ok { + align_sam_fail("invalid SAM tag name " + name) + } +} + +///| +fn align_sam_is_hex(code : Int) -> Bool { + (code >= '0'.to_int() && code <= '9'.to_int()) || + (code >= 'A'.to_int() && code <= 'F'.to_int()) || + (code >= 'a'.to_int() && code <= 'f'.to_int()) +} + +///| +fn align_sam_is_md_base(code : Int) -> Bool { + code == 'A'.to_int() || + code == 'C'.to_int() || + code == 'G'.to_int() || + code == 'T'.to_int() || + code == 'N'.to_int() || + code == 'a'.to_int() || + code == 'c'.to_int() || + code == 'g'.to_int() || + code == 't'.to_int() || + code == 'n'.to_int() +} + +///| +fn align_sam_operation_from_text( + operation : String, +) -> AlignSamOperation raise AlignSamError { + if operation == "M" { + SamAligned + } else if operation == "I" { + SamInsertion + } else if operation == "D" { + SamDeletion + } else if operation == "N" { + SamSkipped + } else if operation == "=" { + SamEqual + } else if operation == "X" { + SamMismatch + } else { + align_sam_fail("CIGAR operation " + operation + " has no alignment path") + SamAligned + } +} + +///| +fn align_sam_is_clip(operation : String) -> Bool { + operation == "S" || operation == "H" +} + +///| +fn align_sam_is_core(operation : String) -> Bool { + operation == "M" || + operation == "I" || + operation == "D" || + operation == "N" || + operation == "=" || + operation == "X" +} + +///| +pub fn align_sam_parse_cigar( + text : String, +) -> Array[AlignSamCigarElement] raise AlignSamError { + if text == "*" { + return [] + } + if text.length() == 0 { + align_sam_fail("CIGAR must not be empty") + } + let elements : Array[AlignSamCigarElement] = [] + let mut start = 0 + let mut index = 0 + while index < text.length() { + let code = text.unsafe_get(index).to_int() + if code >= '0'.to_int() && code <= '9'.to_int() { + index = index + 1 + continue + } + if index == start { + align_sam_fail("CIGAR operation is missing a length") + } + let length = align_sam_parse_int( + text[start:index].to_owned(), + "CIGAR length", + ) + if length <= 0 { + align_sam_fail("CIGAR lengths must be positive") + } + let operation = text[index:index + 1].to_owned() + if operation == "P" { + align_sam_fail( + "CIGAR padding operation P is not supported by Bio.Align.sam", + ) + } + if !align_sam_is_clip(operation) && !align_sam_is_core(operation) { + align_sam_fail("unknown CIGAR operation " + operation) + } + elements.push(AlignSamCigarElement::{ operation, length }) + index = index + 1 + start = index + } + if start != text.length() { + align_sam_fail("CIGAR ends with a length but no operation") + } + let mut first_core = elements.length() + let mut last_core = -1 + for element_index in 0.. last_core + 1 { + element_index = element_index - 1 + let operation = elements[element_index].operation + if operation == "S" { + seen_soft = true + } else if operation == "H" && !seen_soft { + // Right hard clipping is outermost and therefore visited first. + } else if operation == "H" { + align_sam_fail("right hard clipping must follow right soft clipping") + } + } + align_sam_copy_cigar(elements) +} + +///| +pub fn align_sam_cigar_string(elements : Array[AlignSamCigarElement]) -> String { + if elements.length() == 0 { + return "*" + } + let output = StringBuilder::new() + for element in elements { + output.write_string(element.length.to_string()) + output.write_string(element.operation) + } + output.to_string() +} + +///| +fn align_sam_cigar_query_consumed( + elements : Array[AlignSamCigarElement], +) -> Int { + let mut total = 0 + for element in elements { + if element.operation == "M" || + element.operation == "I" || + element.operation == "S" || + element.operation == "=" || + element.operation == "X" { + total = total + element.length + } + } + total +} + +///| +fn align_sam_left_soft(elements : Array[AlignSamCigarElement]) -> Int { + let mut total = 0 + for element in elements { + if align_sam_is_core(element.operation) { + break + } + if element.operation == "S" { + total = total + element.length + } + } + total +} + +///| +fn align_sam_raw_hard_clips( + elements : Array[AlignSamCigarElement], +) -> (Int?, Int?) { + let mut left = 0 + let mut right = 0 + for element in elements { + if align_sam_is_core(element.operation) { + break + } + if element.operation == "H" { + left = left + element.length + } + } + let mut index = elements.length() + while index > 0 { + index = index - 1 + let element = elements[index] + if align_sam_is_core(element.operation) { + break + } + if element.operation == "H" { + right = right + element.length + } + } + ( + if left == 0 { + None + } else { + Some(left) + }, + if right == 0 { + None + } else { + Some(right) + }, + ) +} + +///| +fn align_sam_build_path( + target_start : Int, + cigar : Array[AlignSamCigarElement], + query_length : Int, + reverse : Bool, +) -> (Array[Int], Array[Int], Array[AlignSamOperation]) raise AlignSamError { + let target_coordinates : Array[Int] = [target_start] + let query_coordinates : Array[Int] = [align_sam_left_soft(cigar)] + let operations : Array[AlignSamOperation] = [] + let mut target = target_start + let mut query = query_coordinates[0] + for element in cigar { + let operation = element.operation + if operation == "S" || operation == "H" { + continue + } + if operation == "M" || operation == "=" || operation == "X" { + target = target + element.length + query = query + element.length + } else if operation == "I" { + query = query + element.length + } else if operation == "D" || operation == "N" { + target = target + element.length + } + target_coordinates.push(target) + query_coordinates.push(query) + operations.push(align_sam_operation_from_text(operation)) + } + if query_length != align_sam_cigar_query_consumed(cigar) { + align_sam_fail( + "query length does not match query-consuming CIGAR operations", + ) + } + if reverse { + for index in 0.. AlignSamTag raise AlignSamError { + let first = match align_sam_find_char(field, ':', 0) { + Some(value) => value + None => { + align_sam_fail("SAM optional tag is missing its datatype") + 0 + } + } + let second = match align_sam_find_char(field, ':', first + 1) { + Some(value) => value + None => { + align_sam_fail("SAM optional tag is missing its value") + 0 + } + } + let name = field[0:first].to_owned() + let datatype = field[first + 1:second].to_owned() + let text = field[second + 1:field.length()].to_owned() + align_sam_validate_tag_name(name) + let value = if datatype == "i" { + SamTagInteger(align_sam_parse_int(text, "SAM integer tag " + name)) + } else if datatype == "f" { + SamTagFloat(align_sam_parse_double(text, "SAM float tag " + name)) + } else if datatype == "A" { + if text.length() != 1 { + align_sam_fail("SAM A tag " + name + " must contain one character") + } + let code = text.unsafe_get(0).to_int() + if code < 33 || code > 126 { + align_sam_fail("SAM A tag " + name + " must be printable ASCII") + } + SamTagCharacter(text) + } else if datatype == "Z" { + for index in 0.. 126 { + align_sam_fail("SAM Z tag " + name + " contains invalid text") + } + } + SamTagString(text) + } else if datatype == "H" { + if text.length() % 2 != 0 { + align_sam_fail("SAM H tag " + name + " must contain byte pairs") + } + for index in 0.. 127) { + align_sam_fail("SAM B:c value is outside the signed byte range") + } + if subtype == "C" && (item < 0 || item > 255) { + align_sam_fail("SAM B:C value is outside the unsigned byte range") + } + if subtype == "s" && (item < -32768 || item > 32767) { + align_sam_fail("SAM B:s value is outside the signed short range") + } + if subtype == "S" && (item < 0 || item > 65535) { + align_sam_fail("SAM B:S value is outside the unsigned short range") + } + if subtype == "I" && item < 0 { + align_sam_fail("SAM B:I values must be non-negative") + } + items.push(item) + } + SamTagIntegerArray(subtype, items) + } else { + align_sam_fail("unknown SAM B tag subtype " + subtype) + SamTagIntegerArray("i", []) + } + } else { + align_sam_fail("unknown SAM optional tag datatype " + datatype) + SamTagString("") + } + AlignSamTag::{ name, value } +} + +///| +fn align_sam_tag_text(tag : AlignSamTag) -> String { + let prefix = tag.name + ":" + match tag.value { + SamTagInteger(value) => prefix + "i:" + value.to_string() + SamTagFloat(value) => prefix + "f:" + value.to_string() + SamTagCharacter(value) => prefix + "A:" + value + SamTagString(value) => prefix + "Z:" + value + SamTagHex(value) => prefix + "H:" + value + SamTagIntegerArray(kind, values) => { + let output = StringBuilder::new() + output.write_string(prefix) + output.write_string("B:") + output.write_string(kind) + for value in values { + output.write_char(',') + output.write_string(value.to_string()) + } + output.to_string() + } + SamTagFloatArray(values) => { + let output = StringBuilder::new() + output.write_string(prefix) + output.write_string("B:f") + for value in values { + output.write_char(',') + output.write_string(value.to_string()) + } + output.to_string() + } + } +} + +///| +pub fn align_sam_integer_tag( + name : String, + value : Int, +) -> AlignSamTag raise AlignSamError { + align_sam_validate_tag_name(name) + AlignSamTag::{ name, value: SamTagInteger(value) } +} + +///| +pub fn align_sam_float_tag( + name : String, + value : Double, +) -> AlignSamTag raise AlignSamError { + align_sam_validate_tag_name(name) + if value.abs() > 1.0e300 { + align_sam_fail("SAM floating-point tag value must be finite") + } + AlignSamTag::{ name, value: SamTagFloat(value) } +} + +///| +pub fn align_sam_string_tag( + name : String, + value : String, +) -> AlignSamTag raise AlignSamError { + align_sam_parse_tag(name + ":Z:" + value) +} + +///| +pub fn align_sam_character_tag( + name : String, + value : String, +) -> AlignSamTag raise AlignSamError { + align_sam_parse_tag(name + ":A:" + value) +} + +///| +pub fn align_sam_hex_tag( + name : String, + value : String, +) -> AlignSamTag raise AlignSamError { + align_sam_parse_tag(name + ":H:" + value) +} + +///| +pub fn align_sam_integer_array_tag( + name : String, + subtype : String, + values : Array[Int], +) -> AlignSamTag raise AlignSamError { + let output = StringBuilder::new() + output.write_string(name) + output.write_string(":B:") + output.write_string(subtype) + for value in values { + output.write_char(',') + output.write_string(value.to_string()) + } + align_sam_parse_tag(output.to_string()) +} + +///| +pub fn align_sam_float_array_tag( + name : String, + values : Array[Double], +) -> AlignSamTag raise AlignSamError { + let output = StringBuilder::new() + output.write_string(name) + output.write_string(":B:f") + for value in values { + output.write_char(',') + output.write_string(value.to_string()) + } + align_sam_parse_tag(output.to_string()) +} + +///| +fn align_sam_parse_header(line : String) -> AlignSamHeader raise AlignSamError { + if line.length() < 3 || line.unsafe_get(0).to_int() != '@'.to_int() { + align_sam_fail("invalid SAM header line") + } + let parts = align_sam_split_char(line, '\t') + let record_type = parts[0][1:parts[0].length()].to_owned() + if record_type.length() != 2 { + align_sam_fail("SAM header record type must contain two characters") + } + if record_type == "CO" { + let mut comment = "" + for index in 1.. 1 { + comment = comment + "\t" + } + comment = comment + parts[index] + } + return AlignSamHeader::{ record_type, fields: [], comment } + } + let fields : Array[AlignSamHeaderField] = [] + let seen : Map[String, Bool] = Map([]) + for index in 1.. value + None => { + align_sam_fail("SAM header field is missing ':'") + 0 + } + } + let key = part[0:separator].to_owned() + let value = part[separator + 1:part.length()].to_owned() + if key.length() != 2 || value.length() == 0 { + align_sam_fail("invalid SAM header field " + part) + } + if seen.contains(key) { + align_sam_fail("duplicate SAM header field " + key) + } + seen[key] = true + fields.push(AlignSamHeaderField::{ key, value }) + } + AlignSamHeader::{ record_type, fields, comment: "" } +} + +///| +fn align_sam_header_value(header : AlignSamHeader, key : String) -> String? { + for field in header.fields { + if field.key == key { + return Some(field.value) + } + } + None +} + +///| +fn align_sam_parse_reference( + header : AlignSamHeader, +) -> AlignSamReference raise AlignSamError { + let name = match align_sam_header_value(header, "SN") { + Some(value) => value + None => { + align_sam_fail("@SQ header is missing SN") + "" + } + } + align_sam_validate_token(name, "@SQ SN", false) + let length = match align_sam_header_value(header, "LN") { + Some(value) => align_sam_parse_int(value, "@SQ LN") + None => { + align_sam_fail("@SQ header is missing LN") + 0 + } + } + if length <= 0 { + align_sam_fail("@SQ LN must be positive") + } + let annotations : Array[AlignSamHeaderField] = [] + for field in header.fields { + if field.key != "SN" && field.key != "LN" { + if field.key == "TP" && + field.value != "linear" && + field.value != "circular" { + align_sam_fail("@SQ TP must be linear or circular") + } + annotations.push(AlignSamHeaderField::{ + key: field.key, + value: field.value, + }) + } + } + AlignSamReference::{ name, length, annotations } +} + +///| +fn align_sam_validate_sequence(sequence : String) -> Unit raise AlignSamError { + for index in 0..= 'A'.to_int() && code <= 'Z'.to_int()) || + (code >= 'a'.to_int() && code <= 'z'.to_int()) || + code == '='.to_int() || + code == '.'.to_int() + if !valid { + align_sam_fail("SAM SEQ contains an invalid character") + } + } +} + +///| +fn align_sam_reverse_ints(values : Array[Int]) -> Array[Int] { + let reversed : Array[Int] = [] + let mut index = values.length() + while index > 0 { + index = index - 1 + reversed.push(values[index]) + } + reversed +} + +///| +fn align_sam_reverse_complement(sequence : String) -> String { + Seq::new(sequence).reverse_complement().to_string() +} + +///| +fn align_sam_reference_length( + references : Array[AlignSamReference], + name : String, +) -> Int? { + for reference in references { + if reference.name == name { + return Some(reference.length) + } + } + None +} + +///| +fn align_sam_validate_md( + md : String, + cigar : Array[AlignSamCigarElement], +) -> Unit raise AlignSamError { + if md.length() == 0 { + align_sam_fail("MD tag must not be empty") + } + let expected : Array[String] = [] + for element in cigar { + if element.operation == "M" || + element.operation == "=" || + element.operation == "X" || + element.operation == "D" { + for _ in 0.. '9'.to_int() { + align_sam_fail( + "MD tag must start with and alternate through match counts", + ) + } + let start = index + while index < md.length() { + let digit = md.unsafe_get(index).to_int() + if digit < '0'.to_int() || digit > '9'.to_int() { + break + } + index = index + 1 + } + let matches = align_sam_parse_int( + md[start:index].to_owned(), + "MD match count", + ) + for _ in 0..= expected.length() { + align_sam_fail("MD match count exceeds the CIGAR reference path") + } + if expected[pointer] == "D" || expected[pointer] == "X" { + align_sam_fail("MD match count conflicts with the CIGAR operation") + } + pointer = pointer + 1 + } + expect_count = false + continue + } + if code == '^'.to_int() { + index = index + 1 + let start = index + while index < md.length() && + align_sam_is_md_base(md.unsafe_get(index).to_int()) { + if pointer >= expected.length() || expected[pointer] != "D" { + align_sam_fail("MD deletion does not match a CIGAR D operation") + } + pointer = pointer + 1 + index = index + 1 + } + if index == start { + align_sam_fail("MD deletion marker must be followed by bases") + } + expect_count = true + continue + } + if align_sam_is_md_base(code) { + if pointer >= expected.length() || expected[pointer] == "D" { + align_sam_fail("MD mismatch does not match an aligned CIGAR operation") + } + if expected[pointer] == "=" { + align_sam_fail("MD mismatch conflicts with a CIGAR = operation") + } + pointer = pointer + 1 + index = index + 1 + expect_count = true + continue + } + align_sam_fail("MD tag contains an invalid character") + } + if expect_count || pointer != expected.length() { + align_sam_fail( + "MD tag consumes " + + pointer.to_string() + + " reference bases but CIGAR requires " + + expected.length().to_string(), + ) + } +} + +///| +fn align_sam_parse_alignment( + line : String, + references : Array[AlignSamReference], +) -> AlignSamAlignment raise AlignSamError { + let fields = align_sam_split_char(line, '\t') + if fields.length() < 11 { + align_sam_fail( + "SAM alignment has " + + fields.length().to_string() + + " fields; expected at least 11", + ) + } + let query_name = fields[0] + align_sam_validate_token(query_name, "QNAME", false) + let flag = align_sam_parse_int(fields[1], "FLAG") + if flag < 0 || flag > 65535 { + align_sam_fail("FLAG must be between 0 and 65535") + } + let unmapped = (flag & 0x4) != 0 + let reverse = (flag & 0x10) != 0 + let reference_name = fields[2] + align_sam_validate_token(reference_name, "RNAME", true) + let one_based_position = align_sam_parse_int(fields[3], "POS") + let raw_mapq = align_sam_parse_int(fields[4], "MAPQ") + if raw_mapq < 0 || raw_mapq > 255 { + align_sam_fail("MAPQ must be between 0 and 255") + } + let cigar = align_sam_parse_cigar(fields[5]) catch { + AlignSamError(message) => + if unmapped && fields[5] == "*" { + [] + } else { + raise AlignSamError(message) + } + } + let raw_mate_reference = fields[6] + align_sam_validate_token(raw_mate_reference, "RNEXT", true) + let raw_mate_position = align_sam_parse_int(fields[7], "PNEXT") + let raw_template_length = align_sam_parse_int(fields[8], "TLEN") + let raw_sequence = fields[9] + let sequence_known = raw_sequence != "*" + if sequence_known { + align_sam_validate_sequence(raw_sequence) + } + let quality_text = fields[10] + let qualities_known = quality_text != "*" + let raw_qualities : Array[Int] = [] + if qualities_known { + if !sequence_known || quality_text.length() != raw_sequence.length() { + align_sam_fail("QUAL length must equal SEQ length") + } + for index in 0.. 126 { + align_sam_fail("QUAL contains a character outside PHRED+33 range") + } + raw_qualities.push(code - 33) + } + } + let tags : Array[AlignSamTag] = [] + let seen_tags : Map[String, Bool] = Map([]) + let mut md : String? = None + for index in 11.. md = Some(value) + _ => align_sam_fail("MD tag must use Z datatype") + } + } + if tag.name == "AS" { + match tag.value { + SamTagInteger(_) => () + _ => align_sam_fail("AS tag must use i datatype") + } + } + tags.push(tag) + } + if unmapped { + if reference_name != "*" || one_based_position != 0 || fields[5] != "*" { + align_sam_fail( + "unmapped SAM records must use RNAME *, POS 0, and CIGAR *", + ) + } + } else { + if reference_name == "*" { + align_sam_fail("mapped SAM records require a reference name") + } + if one_based_position <= 0 { + align_sam_fail("mapped SAM POS must be positive") + } + if fields[5] == "*" { + align_sam_fail("mapped SAM records require a CIGAR") + } + } + if raw_mate_position < 0 { + align_sam_fail("PNEXT must be non-negative") + } + let query_length = if sequence_known { + raw_sequence.length() + } else if unmapped { + 0 + } else { + align_sam_cigar_query_consumed(cigar) + } + let reference_length : Int? = if unmapped { + None + } else { + let length = align_sam_reference_length(references, reference_name) + if references.length() > 0 && length is None { + align_sam_fail( + "mapped reference " + reference_name + " is absent from @SQ", + ) + } + length + } + let (target_coordinates, query_coordinates, operations) = if unmapped { + ([], [], []) + } else { + let target_start = one_based_position - 1 + let path = align_sam_build_path(target_start, cigar, query_length, reverse) + match reference_length { + Some(length) => + if path.0[path.0.length() - 1] > length { + align_sam_fail("alignment extends beyond its @SQ reference length") + } + None => () + } + path + } + match md { + Some(value) => { + if unmapped { + align_sam_fail("unmapped SAM records cannot carry an MD tag") + } + align_sam_validate_md(value, cigar) + } + None => () + } + let raw_hard_clips : (Int?, Int?) = if unmapped { + (None, None) + } else { + align_sam_raw_hard_clips(cigar) + } + let raw_hard_left = raw_hard_clips.0 + let raw_hard_right = raw_hard_clips.1 + let hard_clip_left = if reverse { raw_hard_right } else { raw_hard_left } + let hard_clip_right = if reverse { raw_hard_left } else { raw_hard_right } + let query_sequence = if !sequence_known { + "" + } else if reverse { + align_sam_reverse_complement(raw_sequence) + } else { + raw_sequence + } + let qualities = if !qualities_known { + [] + } else if reverse { + align_sam_reverse_ints(raw_qualities) + } else { + raw_qualities + } + let mate_reference : String? = if raw_mate_reference == "*" { + None + } else if raw_mate_reference == "=" { + if reference_name == "*" { + align_sam_fail("RNEXT = requires a mapped reference") + } + Some(reference_name) + } else { + Some(raw_mate_reference) + } + AlignSamAlignment::{ + query_name, + flag, + reference_name, + reference_length, + target_coordinates, + query_coordinates, + operations, + cigar, + mapq: if raw_mapq == 255 { + None + } else { + Some(raw_mapq) + }, + mate_reference, + mate_position: if raw_mate_position == 0 { + None + } else { + Some(raw_mate_position - 1) + }, + template_length: if raw_template_length == 0 { + None + } else { + Some(raw_template_length) + }, + query_sequence, + sequence_known, + qualities, + qualities_known, + hard_clip_left, + hard_clip_right, + tags, + } +} + +///| +pub fn align_sam_parse(text : String) -> AlignSamDocument raise AlignSamError { + let headers : Array[AlignSamHeader] = [] + let references : Array[AlignSamReference] = [] + let alignments : Array[AlignSamAlignment] = [] + let reference_names : Map[String, Bool] = Map([]) + let mut saw_alignment = false + let mut saw_hd = false + for line in align_sam_split_lines(text) { + if line.length() == 0 { + continue + } + if line.unsafe_get(0).to_int() == '@'.to_int() { + if saw_alignment { + align_sam_fail("SAM headers must precede alignment records") + } + let header = align_sam_parse_header(line) + if header.record_type == "HD" { + if saw_hd || headers.length() > 0 { + align_sam_fail("@HD must be the first and only @HD record") + } + saw_hd = true + if align_sam_header_value(header, "VN") is None { + align_sam_fail("@HD header is missing VN") + } + } + if header.record_type == "SQ" { + let reference = align_sam_parse_reference(header) + if reference_names.contains(reference.name) { + align_sam_fail("duplicate @SQ reference " + reference.name) + } + reference_names[reference.name] = true + references.push(reference) + } + headers.push(header) + } else { + saw_alignment = true + alignments.push(align_sam_parse_alignment(line, references)) + } + } + AlignSamDocument::{ headers, references, alignments } +} + +///| +pub fn AlignSamDocument::reference( + self : AlignSamDocument, + name : String, +) -> AlignSamReference? { + for reference in self.references { + if reference.name == name { + return Some(AlignSamReference::{ + name: reference.name, + length: reference.length, + annotations: align_sam_copy_fields(reference.annotations), + }) + } + } + None +} + +///| +pub fn AlignSamAlignment::is_unmapped(self : AlignSamAlignment) -> Bool { + (self.flag & 0x4) != 0 +} + +///| +pub fn AlignSamAlignment::is_reverse(self : AlignSamAlignment) -> Bool { + (self.flag & 0x10) != 0 +} + +///| +pub fn AlignSamAlignment::is_paired(self : AlignSamAlignment) -> Bool { + (self.flag & 0x1) != 0 +} + +///| +pub fn AlignSamAlignment::is_secondary(self : AlignSamAlignment) -> Bool { + (self.flag & 0x100) != 0 +} + +///| +pub fn AlignSamAlignment::is_supplementary(self : AlignSamAlignment) -> Bool { + (self.flag & 0x800) != 0 +} + +///| +pub fn AlignSamAlignment::query_length(self : AlignSamAlignment) -> Int { + if self.sequence_known { + self.query_sequence.length() + } else { + align_sam_cigar_query_consumed(self.cigar) + } +} + +///| +pub fn AlignSamAlignment::reference_start(self : AlignSamAlignment) -> Int? { + if self.target_coordinates.length() == 0 { + None + } else { + Some(self.target_coordinates[0]) + } +} + +///| +pub fn AlignSamAlignment::reference_end(self : AlignSamAlignment) -> Int? { + if self.target_coordinates.length() == 0 { + None + } else { + Some(self.target_coordinates[self.target_coordinates.length() - 1]) + } +} + +///| +pub fn AlignSamAlignment::tag( + self : AlignSamAlignment, + name : String, +) -> AlignSamTag? { + for tag in self.tags { + if tag.name == name { + return Some(AlignSamTag::{ + name: tag.name, + value: align_sam_copy_tag_value(tag.value), + }) + } + } + None +} + +///| +pub fn AlignSamAlignment::integer_tag( + self : AlignSamAlignment, + name : String, +) -> Int? { + match self.tag(name) { + Some(tag) => + match tag.value { + SamTagInteger(value) => Some(value) + _ => None + } + None => None + } +} + +///| +pub fn AlignSamAlignment::string_tag( + self : AlignSamAlignment, + name : String, +) -> String? { + match self.tag(name) { + Some(tag) => + match tag.value { + SamTagCharacter(value) => Some(value) + SamTagString(value) => Some(value) + SamTagHex(value) => Some(value) + _ => None + } + None => None + } +} + +///| +pub fn AlignSamAlignment::stats(self : AlignSamAlignment) -> AlignSamStats { + let mut reference_consumed = 0 + let mut query_consumed = 0 + let mut aligned = 0 + let mut inserted = 0 + let mut deleted = 0 + let mut skipped = 0 + let mut soft_clipped = 0 + let mut hard_clipped = 0 + for element in self.cigar { + let length = element.length + if element.operation == "M" || + element.operation == "=" || + element.operation == "X" { + reference_consumed = reference_consumed + length + query_consumed = query_consumed + length + aligned = aligned + length + } else if element.operation == "I" { + query_consumed = query_consumed + length + inserted = inserted + length + } else if element.operation == "D" { + reference_consumed = reference_consumed + length + deleted = deleted + length + } else if element.operation == "N" { + reference_consumed = reference_consumed + length + skipped = skipped + length + } else if element.operation == "S" { + query_consumed = query_consumed + length + soft_clipped = soft_clipped + length + } else if element.operation == "H" { + hard_clipped = hard_clipped + length + } + } + AlignSamStats::{ + reference_consumed, + query_consumed, + aligned, + inserted, + deleted, + skipped, + soft_clipped, + hard_clipped, + } +} + +///| +fn align_sam_is_aligned_operation(operation : AlignSamOperation) -> Bool { + operation == SamAligned || operation == SamEqual || operation == SamMismatch +} + +///| +pub fn AlignSamAlignment::target_to_query( + self : AlignSamAlignment, + position : Int, +) -> Int? { + for index in 0..= target_start && position < target_end { + let query_start = self.query_coordinates[index] + let query_end = self.query_coordinates[index + 1] + let offset = position - target_start + if query_end >= query_start { + return Some(query_start + offset) + } else { + return Some(query_start - 1 - offset) + } + } + } + None +} + +///| +pub fn AlignSamAlignment::query_to_target( + self : AlignSamAlignment, + position : Int, +) -> Int? { + for index in 0..= query_start { + if position >= query_start && position < query_end { + return Some(self.target_coordinates[index] + position - query_start) + } + } else if position >= query_end && position < query_start { + return Some(self.target_coordinates[index] + query_start - 1 - position) + } + } + None +} + +///| +fn align_sam_raw_sequence(alignment : AlignSamAlignment) -> String { + if !alignment.sequence_known { + "*" + } else if alignment.is_reverse() { + align_sam_reverse_complement(alignment.query_sequence) + } else { + alignment.query_sequence + } +} + +///| +fn align_sam_md_positions( + alignment : AlignSamAlignment, +) -> (Array[Int], Array[String]) { + let positions : Array[Int] = [] + let defaults : Array[String] = [] + let raw_sequence = align_sam_raw_sequence(alignment) + let mut target = match alignment.reference_start() { + Some(value) => value + None => 0 + } + let mut query = 0 + for element in alignment.cigar { + let operation = element.operation + if operation == "S" { + query = query + element.length + } else if operation == "M" || operation == "=" || operation == "X" { + for offset in 0.. (Array[Int], Array[String]) raise AlignSamError { + let (positions, values) = align_sam_md_positions(alignment) + let md = match alignment.string_tag("MD") { + Some(value) => value + None => return (positions, values) + } + let mut pointer = 0 + let mut index = 0 + while index < md.length() { + let code = md.unsafe_get(index).to_int() + if code >= '0'.to_int() && code <= '9'.to_int() { + let start = index + while index < md.length() { + let digit = md.unsafe_get(index).to_int() + if digit < '0'.to_int() || digit > '9'.to_int() { + break + } + index = index + 1 + } + pointer = pointer + + align_sam_parse_int(md[start:index].to_owned(), "MD match count") + } else if code == '^'.to_int() { + index = index + 1 + while index < md.length() && + align_sam_is_md_base(md.unsafe_get(index).to_int()) { + if pointer >= values.length() { + align_sam_fail("MD deletion exceeds the CIGAR path") + } + values[pointer] = md[index:index + 1].to_owned() + pointer = pointer + 1 + index = index + 1 + } + } else { + if pointer >= values.length() { + align_sam_fail("MD mismatch exceeds the CIGAR path") + } + values[pointer] = md[index:index + 1].to_owned() + pointer = pointer + 1 + index = index + 1 + } + } + if pointer != values.length() { + align_sam_fail("MD tag does not cover the complete CIGAR reference path") + } + (positions, values) +} + +///| +fn align_sam_reference_char( + positions : Array[Int], + values : Array[String], + position : Int, +) -> String { + for index in 0.. (String, String) raise AlignSamError { + if self.is_unmapped() { + align_sam_fail("unmapped SAM records do not have aligned rows") + } + if reference_sequence.length() > 0 { + match self.reference_length { + Some(length) => + if reference_sequence.length() != length { + align_sam_fail("reference sequence length does not match @SQ LN") + } + None => () + } + } + let (md_positions, md_values) = align_sam_reference_from_md(self) + let raw_sequence = align_sam_raw_sequence(self) + let target_row = StringBuilder::new() + let query_row = StringBuilder::new() + let mut target = match self.reference_start() { + Some(value) => value + None => 0 + } + let mut query = 0 + for element in self.cigar { + let operation = element.operation + if operation == "S" { + query = query + element.length + } else if operation == "M" || operation == "=" || operation == "X" { + for offset in 0.. 0 { + target_row.write_string( + reference_sequence[target_position:target_position + 1].to_owned(), + ) + } else { + target_row.write_string( + align_sam_reference_char(md_positions, md_values, target_position), + ) + } + if self.sequence_known { + query_row.write_string( + raw_sequence[query + offset:query + offset + 1].to_owned(), + ) + } else { + query_row.write_char('?') + } + } + target = target + element.length + query = query + element.length + } else if operation == "I" { + target_row.write_string("-".repeat(element.length)) + if self.sequence_known { + query_row.write_string( + raw_sequence[query:query + element.length].to_owned(), + ) + } else { + query_row.write_string("?".repeat(element.length)) + } + query = query + element.length + } else if operation == "D" || operation == "N" { + for offset in 0.. 0 { + target_row.write_string( + reference_sequence[target_position:target_position + 1].to_owned(), + ) + } else { + target_row.write_string( + align_sam_reference_char(md_positions, md_values, target_position), + ) + } + } + query_row.write_string("-".repeat(element.length)) + target = target + element.length + } + } + (target_row.to_string(), query_row.to_string()) +} + +///| +pub fn AlignSamAlignment::computed_nm(self : AlignSamAlignment) -> Int? { + if self.is_unmapped() { + return None + } + let mut count = 0 + for element in self.cigar { + if element.operation == "I" || + element.operation == "D" || + element.operation == "X" { + count = count + element.length + } + } + match self.string_tag("MD") { + Some(md) => { + let mut index = 0 + let mut in_deletion = false + while index < md.length() { + let code = md.unsafe_get(index).to_int() + if code == '^'.to_int() { + in_deletion = true + } else if code >= '0'.to_int() && code <= '9'.to_int() { + in_deletion = false + } else if align_sam_is_md_base(code) && !in_deletion { + count = count + 1 + } + index = index + 1 + } + // X operations and MD mismatch letters describe the same substitutions. + let mut explicit_mismatches = 0 + for element in self.cigar { + if element.operation == "X" { + explicit_mismatches = explicit_mismatches + element.length + } + } + Some(count - explicit_mismatches) + } + None => { + for element in self.cigar { + if element.operation == "M" { + return None + } + } + Some(count) + } + } +} + +///| +pub fn align_sam_calculate_md( + alignment : AlignSamAlignment, + reference_sequence : String, +) -> String raise AlignSamError { + if alignment.is_unmapped() { + align_sam_fail("cannot calculate MD for an unmapped record") + } + match alignment.reference_length { + Some(length) => + if reference_sequence.length() != length { + align_sam_fail("reference sequence length does not match @SQ LN") + } + None => () + } + let raw_sequence = align_sam_raw_sequence(alignment) + if !alignment.sequence_known { + align_sam_fail("cannot calculate MD without a query sequence") + } + let mut target = match alignment.reference_start() { + Some(value) => value + None => 0 + } + let mut query = 0 + let mut matches = 0 + let output = StringBuilder::new() + for element in alignment.cigar { + let operation = element.operation + if operation == "S" { + query = query + element.length + } else if operation == "M" || operation == "=" || operation == "X" { + for offset in 0.. String raise AlignSamError { + if !alignment.qualities_known { + return "*" + } + let values = if alignment.is_reverse() { + align_sam_reverse_ints(alignment.qualities) + } else { + align_sam_copy_ints(alignment.qualities) + } + let output = StringBuilder::new() + for value in values { + if value < 0 || value > 93 { + align_sam_fail("PHRED quality must be between 0 and 93") + } + output.write_char((value + 33).unsafe_to_char()) + } + output.to_string() +} + +///| +pub fn align_sam_format( + alignment : AlignSamAlignment, + calculate_md? : Bool = false, + reference_sequence? : String = "", +) -> String raise AlignSamError { + let output = StringBuilder::new() + output.write_string(alignment.query_name) + output.write_char('\t') + output.write_string(alignment.flag.to_string()) + output.write_char('\t') + output.write_string(alignment.reference_name) + output.write_char('\t') + let position = match alignment.reference_start() { + Some(value) => value + 1 + None => 0 + } + output.write_string(position.to_string()) + output.write_char('\t') + output.write_string( + match alignment.mapq { + Some(value) => value.to_string() + None => "255" + }, + ) + output.write_char('\t') + output.write_string(align_sam_cigar_string(alignment.cigar)) + output.write_char('\t') + let mate_reference = match alignment.mate_reference { + Some(value) => + if value == alignment.reference_name && alignment.reference_name != "*" { + "=" + } else { + value + } + None => "*" + } + output.write_string(mate_reference) + output.write_char('\t') + output.write_string( + match alignment.mate_position { + Some(value) => (value + 1).to_string() + None => "0" + }, + ) + output.write_char('\t') + output.write_string( + match alignment.template_length { + Some(value) => value.to_string() + None => "0" + }, + ) + output.write_char('\t') + output.write_string(align_sam_raw_sequence(alignment)) + output.write_char('\t') + output.write_string(align_sam_quality_text(alignment)) + for tag in alignment.tags { + if calculate_md && tag.name == "MD" { + continue + } + output.write_char('\t') + output.write_string(align_sam_tag_text(tag)) + } + if calculate_md { + if reference_sequence.length() == 0 { + align_sam_fail("reference_sequence is required when calculate_md is true") + } + output.write_string("\tMD:Z:") + output.write_string(align_sam_calculate_md(alignment, reference_sequence)) + } + output.write_char('\n') + output.to_string() +} + +///| +fn align_sam_header_text(header : AlignSamHeader) -> String { + let output = StringBuilder::new() + output.write_char('@') + output.write_string(header.record_type) + if header.record_type == "CO" { + if header.comment.length() > 0 { + output.write_char('\t') + output.write_string(header.comment) + } + } else { + for field in header.fields { + output.write_char('\t') + output.write_string(field.key) + output.write_char(':') + output.write_string(field.value) + } + } + output.write_char('\n') + output.to_string() +} + +///| +pub fn align_sam_write( + document : AlignSamDocument, +) -> String raise AlignSamError { + let output = StringBuilder::new() + for header in document.headers { + output.write_string(align_sam_header_text(header)) + } + for alignment in document.alignments { + output.write_string(align_sam_format(alignment)) + } + output.to_string() +} + +///| +fn align_sam_format_tags(tags : Array[AlignSamTag]) -> String { + let output = StringBuilder::new() + for tag in tags { + output.write_char('\t') + output.write_string(align_sam_tag_text(tag)) + } + output.to_string() +} + +///| +fn align_sam_quality_from_values( + qualities : Array[Int], +) -> String raise AlignSamError { + let output = StringBuilder::new() + for value in qualities { + if value < 0 || value > 93 { + align_sam_fail("PHRED quality must be between 0 and 93") + } + output.write_char((value + 33).unsafe_to_char()) + } + output.to_string() +} + +///| +pub fn align_sam_create( + query_name : String, + reference_name : String, + reference_length : Int, + target_start : Int, + query_sequence : String, + cigar : String, + reverse? : Bool = false, + mapq? : Int = 255, + qualities? : Array[Int] = [], + tags? : Array[AlignSamTag] = [], + flag? : Int = 0, +) -> AlignSamAlignment raise AlignSamError { + if reference_length <= 0 { + align_sam_fail("reference_length must be positive") + } + if target_start < 0 { + align_sam_fail("target_start must be non-negative") + } + if (flag & 0x4) != 0 { + align_sam_fail("align_sam_create constructs mapped alignments") + } + let final_flag = if reverse { flag | 0x10 } else { flag & 0xffef } + let stored_sequence = if reverse { + align_sam_reverse_complement(query_sequence) + } else { + query_sequence + } + let stored_qualities = if reverse { + align_sam_reverse_ints(qualities) + } else { + align_sam_copy_ints(qualities) + } + if qualities.length() > 0 && qualities.length() != query_sequence.length() { + align_sam_fail("qualities length must equal query_sequence length") + } + let quality_text = if qualities.length() == 0 { + "*" + } else { + align_sam_quality_from_values(stored_qualities) + } + let text = "@SQ\tSN:" + + reference_name + + "\tLN:" + + reference_length.to_string() + + "\n" + + query_name + + "\t" + + final_flag.to_string() + + "\t" + + reference_name + + "\t" + + (target_start + 1).to_string() + + "\t" + + mapq.to_string() + + "\t" + + cigar + + "\t*\t0\t0\t" + + stored_sequence + + "\t" + + quality_text + + align_sam_format_tags(tags) + + "\n" + let document = align_sam_parse(text) + document.alignments[0] +} + +///| +pub fn AlignSamAlignment::summary(self : AlignSamAlignment) -> String { + if self.is_unmapped() { + return "SAM alignment " + self.query_name + ": unmapped" + } + let stats = self.stats() + let start = match self.reference_start() { + Some(value) => value.to_string() + None => "?" + } + let end = match self.reference_end() { + Some(value) => value.to_string() + None => "?" + } + "SAM alignment " + + self.query_name + + " -> " + + self.reference_name + + ":" + + start + + "-" + + end + + ", aligned=" + + stats.aligned.to_string() + + ", inserted=" + + stats.inserted.to_string() + + ", deleted=" + + stats.deleted.to_string() + + ", skipped=" + + stats.skipped.to_string() +} + +///| +pub fn align_sam_example_data() -> String { + "@HD\tVN:1.6\tSO:coordinate\n" + + "@SQ\tSN:chr1\tLN:40\tAS:demo\n" + + "@RG\tID:rg1\tSM:sample1\n" + + "read_forward\t0\tchr1\t5\t60\t3S4M1I2M1D3M2S\t*\t0\t0\tGGGACGTATCGTAAA\tIIIIIIIIIIIIIII\tNM:i:3\tMD:Z:6^G1A1\tAS:i:8\tRG:Z:rg1\n" + + "read_reverse\t16\tchr1\t20\t40\t2H2S5M3N3M1S1H\t*\t0\t0\tTACGTACGTAA\tJJJJJJJJJJJ\tNM:i:0\tMD:Z:8\tAS:i:8\n" + + "read_unmapped\t4\t*\t0\t0\t*\t*\t0\t0\tACGT\t!!!!\tRG:Z:rg1\n" +} diff --git a/test/moonbit/align_sam_test.mbt b/test/moonbit/align_sam_test.mbt new file mode 100644 index 00000000..30a6c380 --- /dev/null +++ b/test/moonbit/align_sam_test.mbt @@ -0,0 +1,1232 @@ +///| +fn align_sam_test_parse(text : String) -> @src.AlignSamDocument { + @src.align_sam_parse(text) catch { + AlignSamError(message) => abort("valid SAM failed: " + message) + } +} + +///| +fn align_sam_test_parse_raises(text : String) -> Bool { + try { + ignore(@src.align_sam_parse(text)) + false + } catch { + AlignSamError(_) => true + } +} + +///| +fn align_sam_test_cigar_raises(text : String) -> Bool { + try { + ignore(@src.align_sam_parse_cigar(text)) + false + } catch { + AlignSamError(_) => true + } +} + +///| +fn align_sam_test_record( + flag : String, + reference : String, + position : String, + mapq : String, + cigar : String, + mate_reference : String, + mate_position : String, + template_length : String, + sequence : String, + quality : String, + tags : String, +) -> String { + let suffix = if tags == "" { "" } else { "\t" + tags } + "read\t" + + flag + + "\t" + + reference + + "\t" + + position + + "\t" + + mapq + + "\t" + + cigar + + "\t" + + mate_reference + + "\t" + + mate_position + + "\t" + + template_length + + "\t" + + sequence + + "\t" + + quality + + suffix + + "\n" +} + +///| +fn align_sam_test_mapped( + cigar : String, + sequence : String, + quality : String, + tags : String, +) -> String { + "@SQ\tSN:chr1\tLN:100\n" + + align_sam_test_record( + "0", "chr1", "1", "60", cigar, "*", "0", "0", sequence, quality, tags, + ) +} + +///| +fn align_sam_test_forward() -> @src.AlignSamAlignment { + align_sam_test_parse(@src.align_sam_example_data()).alignments[0] +} + +///| +fn align_sam_test_reverse() -> @src.AlignSamAlignment { + align_sam_test_parse(@src.align_sam_example_data()).alignments[1] +} + +///| +fn align_sam_test_reference() -> String { + "N".repeat(4) + "ACGTTCGGAA" + "N".repeat(26) +} + +///| +test "Bio.Align.sam parses header, references, and alignments" { + let document = align_sam_test_parse(@src.align_sam_example_data()) + assert_eq(document.headers.length(), 3) + assert_eq(document.references.length(), 1) + assert_eq(document.alignments.length(), 3) +} + +///| +test "Bio.Align.sam preserves HD metadata" { + let document = align_sam_test_parse(@src.align_sam_example_data()) + let header = document.headers[0] + assert_eq(header.record_type, "HD") + assert_eq(header.fields[0].key, "VN") + assert_eq(header.fields[0].value, "1.6") + assert_eq(header.fields[1].key, "SO") + assert_eq(header.fields[1].value, "coordinate") +} + +///| +test "Bio.Align.sam exposes SQ metadata and lookup" { + let document = align_sam_test_parse(@src.align_sam_example_data()) + match document.reference("chr1") { + Some(reference) => { + assert_eq(reference.name, "chr1") + assert_eq(reference.length, 40) + assert_eq(reference.annotations.length(), 1) + assert_eq(reference.annotations[0].key, "AS") + assert_eq(reference.annotations[0].value, "demo") + } + None => abort("chr1 reference was not indexed") + } + assert_true(document.reference("missing") is None) +} + +///| +test "Bio.Align.sam parses comments and extension headers" { + let document = align_sam_test_parse( + "@HD\tVN:1.6\n@CO\tfirst\tsecond\n@ZZ\tID:extension\n", + ) + assert_eq(document.headers.length(), 3) + assert_eq(document.headers[1].record_type, "CO") + assert_eq(document.headers[1].comment, "first\tsecond") + assert_eq(document.headers[2].record_type, "ZZ") + assert_eq(document.headers[2].fields[0].value, "extension") +} + +///| +test "Bio.Align.sam accepts CRLF and blank lines" { + let document = align_sam_test_parse( + "\r\n@SQ\tSN:chr1\tLN:10\r\n\r\n" + + "read\t0\tchr1\t1\t60\t4M\t*\t0\t0\tACGT\t!!!!\r\n", + ) + assert_eq(document.alignments.length(), 1) + assert_eq(document.alignments[0].query_name, "read") +} + +///| +test "Bio.Align.sam parses an empty document" { + let document = align_sam_test_parse("\n\r\n") + assert_eq(document.headers.length(), 0) + assert_eq(document.references.length(), 0) + assert_eq(document.alignments.length(), 0) +} + +///| +test "Bio.Align.sam forward record fields" { + let alignment = align_sam_test_forward() + assert_eq(alignment.query_name, "read_forward") + assert_eq(alignment.reference_name, "chr1") + assert_eq(alignment.reference_length, Some(40)) + assert_eq(alignment.reference_start(), Some(4)) + assert_eq(alignment.reference_end(), Some(14)) + assert_eq(alignment.mapq, Some(60)) + assert_false(alignment.is_reverse()) +} + +///| +test "Bio.Align.sam forward coordinate path" { + let alignment = align_sam_test_forward() + assert_eq(alignment.target_coordinates, [4, 8, 8, 10, 11, 14]) + assert_eq(alignment.query_coordinates, [3, 7, 8, 10, 10, 13]) + assert_eq(alignment.operations, [ + @src.SamAligned, + @src.SamInsertion, + @src.SamAligned, + @src.SamDeletion, + @src.SamAligned, + ]) +} + +///| +test "Bio.Align.sam reverse sequence and qualities use biological orientation" { + let alignment = align_sam_test_reverse() + assert_true(alignment.is_reverse()) + assert_eq(alignment.query_sequence, "TTACGTACGTA") + assert_eq(alignment.qualities.length(), 11) + assert_eq(alignment.qualities[0], 41) + assert_eq(alignment.qualities[10], 41) + assert_eq(alignment.hard_clip_left, Some(1)) + assert_eq(alignment.hard_clip_right, Some(2)) +} + +///| +test "Bio.Align.sam reverse coordinate path decreases query coordinates" { + let alignment = align_sam_test_reverse() + assert_eq(alignment.target_coordinates, [19, 24, 27, 30]) + assert_eq(alignment.query_coordinates, [9, 4, 4, 1]) + assert_eq(alignment.operations, [ + @src.SamAligned, + @src.SamSkipped, + @src.SamAligned, + ]) +} + +///| +test "Bio.Align.sam unmapped record has no alignment path" { + let alignment = align_sam_test_parse(@src.align_sam_example_data()).alignments[2] + assert_true(alignment.is_unmapped()) + assert_eq(alignment.reference_name, "*") + assert_eq(alignment.target_coordinates.length(), 0) + assert_eq(alignment.query_coordinates.length(), 0) + assert_eq(alignment.operations.length(), 0) + assert_eq(alignment.query_sequence, "ACGT") +} + +///| +test "Bio.Align.sam flag helpers" { + let document = align_sam_test_parse( + align_sam_test_record( + (0x1 | 0x4 | 0x100 | 0x800).to_string(), + "*", + "0", + "0", + "*", + "*", + "0", + "0", + "*", + "*", + "", + ), + ) + let alignment = document.alignments[0] + assert_true(alignment.is_paired()) + assert_true(alignment.is_unmapped()) + assert_true(alignment.is_secondary()) + assert_true(alignment.is_supplementary()) + assert_false(alignment.is_reverse()) +} + +///| +test "Bio.Align.sam converts mate positions to zero based" { + let alignment = align_sam_test_parse( + "@SQ\tSN:chr1\tLN:20\n@SQ\tSN:chr2\tLN:20\n" + + align_sam_test_record( + "1", "chr1", "2", "30", "4M", "chr2", "8", "-5", "ACGT", "!!!!", "", + ), + ).alignments[0] + assert_eq(alignment.mate_reference, Some("chr2")) + assert_eq(alignment.mate_position, Some(7)) + assert_eq(alignment.template_length, Some(-5)) +} + +///| +test "Bio.Align.sam expands equal mate reference" { + let alignment = align_sam_test_parse( + "@SQ\tSN:chr1\tLN:20\n" + + align_sam_test_record( + "1", "chr1", "2", "30", "4M", "=", "8", "5", "ACGT", "!!!!", "", + ), + ).alignments[0] + assert_eq(alignment.mate_reference, Some("chr1")) + let formatted = @src.align_sam_format(alignment) catch { + AlignSamError(message) => abort(message) + } + assert_eq( + formatted, + align_sam_test_record( + "1", "chr1", "2", "30", "4M", "=", "8", "5", "ACGT", "!!!!", "", + ), + ) +} + +///| +test "Bio.Align.sam MAPQ 255 is represented as unknown" { + let alignment = align_sam_test_parse( + align_sam_test_record( + "0", "contig", "1", "255", "4M", "*", "0", "0", "ACGT", "*", "", + ), + ).alignments[0] + assert_true(alignment.mapq is None) + assert_true(alignment.reference_length is None) +} + +///| +test "Bio.Align.sam parses reference-less mapped SAM" { + let alignment = align_sam_test_parse( + align_sam_test_record( + "0", "contig", "3", "20", "2M1D2M", "*", "0", "0", "ACGT", "!!!!", "", + ), + ).alignments[0] + assert_eq(alignment.reference_start(), Some(2)) + assert_eq(alignment.reference_end(), Some(7)) + assert_true(alignment.reference_length is None) +} + +///| +test "Bio.Align.sam CIGAR supports all alignment operations" { + let cigar = @src.align_sam_parse_cigar("1H2S3M4I5D6N7=8X9S10H") catch { + AlignSamError(message) => abort(message) + } + assert_eq(cigar.length(), 10) + assert_eq(cigar[0].operation, "H") + assert_eq(cigar[1].operation, "S") + assert_eq(cigar[2].operation, "M") + assert_eq(cigar[3].operation, "I") + assert_eq(cigar[4].operation, "D") + assert_eq(cigar[5].operation, "N") + assert_eq(cigar[6].operation, "=") + assert_eq(cigar[7].operation, "X") + assert_eq(cigar[8].length, 9) + assert_eq(cigar[9].length, 10) +} + +///| +test "Bio.Align.sam CIGAR star has no elements" { + let cigar = @src.align_sam_parse_cigar("*") catch { + AlignSamError(message) => abort(message) + } + assert_eq(cigar.length(), 0) + assert_eq(@src.align_sam_cigar_string(cigar), "*") +} + +///| +test "Bio.Align.sam CIGAR round trip" { + let cigar = @src.align_sam_parse_cigar("2H3S4M1I2=1X1D5N2M1S4H") catch { + AlignSamError(message) => abort(message) + } + assert_eq(@src.align_sam_cigar_string(cigar), "2H3S4M1I2=1X1D5N2M1S4H") +} + +///| +test "Bio.Align.sam reports CIGAR statistics" { + let stats = align_sam_test_forward().stats() + assert_eq(stats.reference_consumed, 10) + assert_eq(stats.query_consumed, 15) + assert_eq(stats.aligned, 9) + assert_eq(stats.inserted, 1) + assert_eq(stats.deleted, 1) + assert_eq(stats.skipped, 0) + assert_eq(stats.soft_clipped, 5) + assert_eq(stats.hard_clipped, 0) +} + +///| +test "Bio.Align.sam reports spliced and hard clipping statistics" { + let stats = align_sam_test_reverse().stats() + assert_eq(stats.reference_consumed, 11) + assert_eq(stats.query_consumed, 11) + assert_eq(stats.aligned, 8) + assert_eq(stats.skipped, 3) + assert_eq(stats.soft_clipped, 3) + assert_eq(stats.hard_clipped, 3) +} + +///| +test "Bio.Align.sam maps target bases to forward query bases" { + let alignment = align_sam_test_forward() + assert_eq(alignment.target_to_query(4), Some(3)) + assert_eq(alignment.target_to_query(7), Some(6)) + assert_eq(alignment.target_to_query(8), Some(8)) + assert_eq(alignment.target_to_query(10), None) + assert_eq(alignment.target_to_query(13), Some(12)) +} + +///| +test "Bio.Align.sam maps forward query bases to target bases" { + let alignment = align_sam_test_forward() + assert_eq(alignment.query_to_target(3), Some(4)) + assert_eq(alignment.query_to_target(7), None) + assert_eq(alignment.query_to_target(8), Some(8)) + assert_eq(alignment.query_to_target(12), Some(13)) + assert_eq(alignment.query_to_target(14), None) +} + +///| +test "Bio.Align.sam maps target bases to reverse query bases" { + let alignment = align_sam_test_reverse() + assert_eq(alignment.target_to_query(19), Some(8)) + assert_eq(alignment.target_to_query(23), Some(4)) + assert_eq(alignment.target_to_query(24), None) + assert_eq(alignment.target_to_query(27), Some(3)) + assert_eq(alignment.target_to_query(29), Some(1)) +} + +///| +test "Bio.Align.sam maps reverse query bases to target bases" { + let alignment = align_sam_test_reverse() + assert_eq(alignment.query_to_target(8), Some(19)) + assert_eq(alignment.query_to_target(4), Some(23)) + assert_eq(alignment.query_to_target(3), Some(27)) + assert_eq(alignment.query_to_target(1), Some(29)) + assert_eq(alignment.query_to_target(0), None) +} + +///| +test "Bio.Align.sam parses scalar typed tags" { + let alignment = align_sam_test_parse( + align_sam_test_mapped( + "4M", "ACGT", "!!!!", "AA:A:x\tXI:i:-2147483648\tFF:f:1.5\tZZ:Z:hello\tHX:H:0aFF", + ), + ).alignments[0] + assert_eq(alignment.string_tag("AA"), Some("x")) + assert_eq(alignment.integer_tag("XI"), Some(-2147483647 - 1)) + assert_eq(alignment.string_tag("ZZ"), Some("hello")) + assert_eq(alignment.string_tag("HX"), Some("0aFF")) + match alignment.tag("FF") { + Some(tag) => + match tag.value { + @src.SamTagFloat(value) => assert_eq(value, 1.5) + _ => abort("FF did not retain float type") + } + None => abort("FF tag is missing") + } +} + +///| +test "Bio.Align.sam parses typed integer arrays" { + let alignment = align_sam_test_parse( + align_sam_test_mapped( + "4M", "ACGT", "!!!!", "BC:B:c,-1,2\tBU:B:C,0,255\tBS:B:s,-2,3\tBT:B:S,0,65535\tBI:B:i,-4,5\tBJ:B:I,0,7", + ), + ).alignments[0] + match alignment.tag("BC") { + Some(tag) => + match tag.value { + @src.SamTagIntegerArray(kind, values) => { + assert_eq(kind, "c") + assert_eq(values, [-1, 2]) + } + _ => abort("BC did not retain integer array type") + } + None => abort("BC tag is missing") + } + match alignment.tag("BT") { + Some(tag) => + match tag.value { + @src.SamTagIntegerArray(kind, values) => { + assert_eq(kind, "S") + assert_eq(values, [0, 65535]) + } + _ => abort("BT did not retain integer array type") + } + None => abort("BT tag is missing") + } + assert_eq(alignment.tags.length(), 6) +} + +///| +test "Bio.Align.sam parses typed float arrays" { + let alignment = align_sam_test_parse( + align_sam_test_mapped("4M", "ACGT", "!!!!", "BF:B:f,1.5,-2.25"), + ).alignments[0] + match alignment.tag("BF") { + Some(tag) => + match tag.value { + @src.SamTagFloatArray(values) => assert_eq(values, [1.5, -2.25]) + _ => abort("BF did not retain float array type") + } + None => abort("BF tag is missing") + } +} + +///| +test "Bio.Align.sam tag lookup returns defensive array copies" { + let alignment = align_sam_test_parse( + align_sam_test_mapped("4M", "ACGT", "!!!!", "BI:B:i,1,2"), + ).alignments[0] + match alignment.tag("BI") { + Some(tag) => + match tag.value { + @src.SamTagIntegerArray(_, values) => values[0] = 99 + _ => abort("BI did not retain integer array type") + } + None => abort("BI tag is missing") + } + match alignment.tag("BI") { + Some(tag) => + match tag.value { + @src.SamTagIntegerArray(_, values) => assert_eq(values, [1, 2]) + _ => abort("BI did not retain integer array type") + } + None => abort("BI tag is missing") + } +} + +///| +test "Bio.Align.sam typed tag constructors" { + let tags = [ + @src.align_sam_integer_tag("NM", 2), + @src.align_sam_float_tag("ZF", 1.25), + @src.align_sam_string_tag("RG", "group1"), + @src.align_sam_character_tag("XC", "Y"), + @src.align_sam_hex_tag("XH", "CAFE"), + @src.align_sam_integer_array_tag("BI", "s", [-2, 3]), + @src.align_sam_float_array_tag("BF", [0.5, 1.5]), + ] catch { + AlignSamError(message) => abort(message) + } + let alignment = @src.align_sam_create( + "created", + "chr1", + 20, + 2, + "ACGT", + "4M", + tags~, + ) catch { + AlignSamError(message) => abort(message) + } + assert_eq(alignment.tags.length(), 7) + assert_eq(alignment.integer_tag("NM"), Some(2)) + assert_eq(alignment.string_tag("RG"), Some("group1")) +} + +///| +test "Bio.Align.sam reconstructs aligned rows from MD" { + let rows = align_sam_test_forward().aligned_rows() catch { + AlignSamError(message) => abort(message) + } + assert_eq(rows.0, "ACGT-TCGGAA") + assert_eq(rows.1, "ACGTATC-GTA") +} + +///| +test "Bio.Align.sam reconstructs skipped rows without a reference" { + let rows = align_sam_test_reverse().aligned_rows() catch { + AlignSamError(message) => abort(message) + } + assert_eq(rows.0, "CGTAC???GTA") + assert_eq(rows.1, "CGTAC---GTA") +} + +///| +test "Bio.Align.sam reconstructs rows from a full reference" { + let rows = align_sam_test_forward().aligned_rows( + reference_sequence=align_sam_test_reference(), + ) catch { + AlignSamError(message) => abort(message) + } + assert_eq(rows.0, "ACGT-TCGGAA") + assert_eq(rows.1, "ACGTATC-GTA") +} + +///| +test "Bio.Align.sam computes NM from MD, insertions, and deletions" { + assert_eq(align_sam_test_forward().computed_nm(), Some(3)) + assert_eq(align_sam_test_reverse().computed_nm(), Some(0)) +} + +///| +test "Bio.Align.sam returns unknown NM for ambiguous M without MD" { + let alignment = align_sam_test_parse( + align_sam_test_mapped("4M", "ACGT", "!!!!", ""), + ).alignments[0] + assert_true(alignment.computed_nm() is None) +} + +///| +test "Bio.Align.sam computes NM from explicit equal and mismatch CIGAR" { + let alignment = align_sam_test_parse( + align_sam_test_mapped("2=1X1I1D1=", "ACGTA", "!!!!!", ""), + ).alignments[0] + assert_eq(alignment.computed_nm(), Some(3)) +} + +///| +test "Bio.Align.sam calculates an MD tag from reference sequence" { + let md = @src.align_sam_calculate_md( + align_sam_test_forward(), + align_sam_test_reference(), + ) catch { + AlignSamError(message) => abort(message) + } + assert_eq(md, "6^G1A1") +} + +///| +test "Bio.Align.sam calculated MD replaces an existing tag on format" { + let formatted = @src.align_sam_format( + align_sam_test_forward(), + calculate_md=true, + reference_sequence=align_sam_test_reference(), + ) catch { + AlignSamError(message) => abort(message) + } + let alignment = align_sam_test_parse("@SQ\tSN:chr1\tLN:40\n" + formatted).alignments[0] + assert_eq(alignment.string_tag("MD"), Some("6^G1A1")) + assert_eq(alignment.tags.length(), 4) +} + +///| +test "Bio.Align.sam record formatting round trips reverse orientation" { + let original = align_sam_test_reverse() + let formatted = @src.align_sam_format(original) catch { + AlignSamError(message) => abort(message) + } + let parsed = align_sam_test_parse("@SQ\tSN:chr1\tLN:40\n" + formatted).alignments[0] + assert_eq(parsed.query_sequence, original.query_sequence) + assert_eq(parsed.qualities, original.qualities) + assert_eq(parsed.query_coordinates, original.query_coordinates) + assert_eq(parsed.hard_clip_left, original.hard_clip_left) + assert_eq(parsed.hard_clip_right, original.hard_clip_right) +} + +///| +test "Bio.Align.sam document write is canonical and lossless" { + let text = @src.align_sam_example_data() + let written = @src.align_sam_write(align_sam_test_parse(text)) catch { + AlignSamError(message) => abort(message) + } + assert_eq(written, text) +} + +///| +test "Bio.Align.sam creates forward mapped alignments" { + let alignment = @src.align_sam_create( + "created", + "chr1", + 30, + 5, + "AACGTT", + "1S4M1S", + mapq=42, + qualities=[10, 11, 12, 13, 14, 15], + ) catch { + AlignSamError(message) => abort(message) + } + assert_eq(alignment.reference_start(), Some(5)) + assert_eq(alignment.reference_end(), Some(9)) + assert_eq(alignment.query_coordinates, [1, 5]) + assert_eq(alignment.query_sequence, "AACGTT") + assert_eq(alignment.qualities, [10, 11, 12, 13, 14, 15]) + assert_eq(alignment.mapq, Some(42)) +} + +///| +test "Bio.Align.sam creates reverse mapped alignments" { + let alignment = @src.align_sam_create( + "reverse", + "chr1", + 30, + 5, + "AACGTT", + "1H1S4M1S2H", + reverse=true, + qualities=[10, 11, 12, 13, 14, 15], + ) catch { + AlignSamError(message) => abort(message) + } + assert_true(alignment.is_reverse()) + assert_eq(alignment.query_sequence, "AACGTT") + assert_eq(alignment.qualities, [10, 11, 12, 13, 14, 15]) + assert_eq(alignment.query_coordinates, [5, 1]) + assert_eq(alignment.hard_clip_left, Some(2)) + assert_eq(alignment.hard_clip_right, Some(1)) +} + +///| +test "Bio.Align.sam summary reports path statistics" { + assert_eq( + align_sam_test_forward().summary(), + "SAM alignment read_forward -> chr1:4-14, aligned=9, inserted=1, deleted=1, skipped=0", + ) + let unmapped = align_sam_test_parse( + align_sam_test_record( + "4", "*", "0", "0", "*", "*", "0", "0", "*", "*", "", + ), + ).alignments[0] + assert_eq(unmapped.summary(), "SAM alignment read: unmapped") +} + +///| +test "Bio.Align.sam preserves unknown sequence and qualities" { + let alignment = align_sam_test_parse( + align_sam_test_record( + "0", "contig", "1", "10", "4M", "*", "0", "0", "*", "*", "", + ), + ).alignments[0] + assert_false(alignment.sequence_known) + assert_false(alignment.qualities_known) + assert_eq(alignment.query_length(), 4) + assert_eq(alignment.query_sequence, "") + assert_eq(alignment.qualities.length(), 0) +} + +///| +test "Bio.Align.sam rejects empty CIGAR text" { + assert_true(align_sam_test_cigar_raises("")) +} + +///| +test "Bio.Align.sam rejects CIGAR without a leading length" { + assert_true(align_sam_test_cigar_raises("M4")) +} + +///| +test "Bio.Align.sam rejects CIGAR without a trailing operation" { + assert_true(align_sam_test_cigar_raises("4M2")) +} + +///| +test "Bio.Align.sam rejects zero-length CIGAR operations" { + assert_true(align_sam_test_cigar_raises("0M")) +} + +///| +test "Bio.Align.sam rejects unknown CIGAR operations" { + assert_true(align_sam_test_cigar_raises("4Q")) +} + +///| +test "Bio.Align.sam rejects padding CIGAR operations" { + assert_true(align_sam_test_cigar_raises("2M1P2M")) +} + +///| +test "Bio.Align.sam rejects interior clipping" { + assert_true(align_sam_test_cigar_raises("2M1S2M")) + assert_true(align_sam_test_cigar_raises("2M1H2M")) +} + +///| +test "Bio.Align.sam rejects invalid left clipping order" { + assert_true(align_sam_test_cigar_raises("1S2H4M")) +} + +///| +test "Bio.Align.sam rejects invalid right clipping order" { + assert_true(align_sam_test_cigar_raises("4M2H1S")) +} + +///| +test "Bio.Align.sam rejects clip-only CIGAR" { + assert_true(align_sam_test_cigar_raises("2H4S")) +} + +///| +test "Bio.Align.sam rejects headers after alignments" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_record( + "4", "*", "0", "0", "*", "*", "0", "0", "*", "*", "", + ) + + "@HD\tVN:1.6\n", + ), + ) +} + +///| +test "Bio.Align.sam rejects HD after another header" { + assert_true(align_sam_test_parse_raises("@SQ\tSN:chr1\tLN:10\n@HD\tVN:1.6\n")) +} + +///| +test "Bio.Align.sam rejects duplicate HD" { + assert_true(align_sam_test_parse_raises("@HD\tVN:1.6\n@HD\tVN:1.6\n")) +} + +///| +test "Bio.Align.sam rejects HD without version" { + assert_true(align_sam_test_parse_raises("@HD\tSO:coordinate\n")) +} + +///| +test "Bio.Align.sam rejects malformed SQ metadata" { + assert_true(align_sam_test_parse_raises("@SQ\tLN:10\n")) + assert_true(align_sam_test_parse_raises("@SQ\tSN:chr1\n")) + assert_true(align_sam_test_parse_raises("@SQ\tSN:chr1\tLN:0\n")) + assert_true(align_sam_test_parse_raises("@SQ\tSN:chr1\tLN:10\tTP:branched\n")) +} + +///| +test "Bio.Align.sam rejects duplicate references" { + assert_true( + align_sam_test_parse_raises("@SQ\tSN:chr1\tLN:10\n@SQ\tSN:chr1\tLN:20\n"), + ) +} + +///| +test "Bio.Align.sam rejects duplicate header fields" { + assert_true(align_sam_test_parse_raises("@HD\tVN:1.6\tVN:1.5\n")) +} + +///| +test "Bio.Align.sam rejects alignment with too few fields" { + assert_true(align_sam_test_parse_raises("read\t0\tchr1\n")) +} + +///| +test "Bio.Align.sam validates FLAG range" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_record( + "-1", "*", "0", "0", "*", "*", "0", "0", "*", "*", "", + ), + ), + ) + assert_true( + align_sam_test_parse_raises( + align_sam_test_record( + "65536", "*", "0", "0", "*", "*", "0", "0", "*", "*", "", + ), + ), + ) +} + +///| +test "Bio.Align.sam validates MAPQ range" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_record( + "0", "chr1", "1", "-1", "1M", "*", "0", "0", "A", "!", "", + ), + ), + ) + assert_true( + align_sam_test_parse_raises( + align_sam_test_record( + "0", "chr1", "1", "256", "1M", "*", "0", "0", "A", "!", "", + ), + ), + ) +} + +///| +test "Bio.Align.sam validates mapped record fields" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_record( + "0", "*", "1", "60", "1M", "*", "0", "0", "A", "!", "", + ), + ), + ) + assert_true( + align_sam_test_parse_raises( + align_sam_test_record( + "0", "chr1", "0", "60", "1M", "*", "0", "0", "A", "!", "", + ), + ), + ) + assert_true( + align_sam_test_parse_raises( + align_sam_test_record( + "0", "chr1", "1", "60", "*", "*", "0", "0", "A", "!", "", + ), + ), + ) +} + +///| +test "Bio.Align.sam validates unmapped record fields" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_record( + "4", "chr1", "1", "0", "*", "*", "0", "0", "A", "!", "", + ), + ), + ) + assert_true( + align_sam_test_parse_raises( + align_sam_test_record( + "4", "*", "0", "0", "1M", "*", "0", "0", "A", "!", "", + ), + ), + ) +} + +///| +test "Bio.Align.sam rejects unknown references when SQ is present" { + assert_true( + align_sam_test_parse_raises( + "@SQ\tSN:chr1\tLN:10\n" + + align_sam_test_record( + "0", "chr2", "1", "60", "1M", "*", "0", "0", "A", "!", "", + ), + ), + ) +} + +///| +test "Bio.Align.sam rejects alignments beyond reference length" { + assert_true( + align_sam_test_parse_raises( + "@SQ\tSN:chr1\tLN:10\n" + + align_sam_test_record( + "0", "chr1", "9", "60", "3M", "*", "0", "0", "ACG", "!!!", "", + ), + ), + ) +} + +///| +test "Bio.Align.sam validates query length against CIGAR" { + assert_true( + align_sam_test_parse_raises(align_sam_test_mapped("4M", "ACG", "!!!", "")), + ) +} + +///| +test "Bio.Align.sam rejects invalid sequence characters" { + assert_true( + align_sam_test_parse_raises(align_sam_test_mapped("4M", "AC*G", "!!!!", "")), + ) +} + +///| +test "Bio.Align.sam requires QUAL and SEQ lengths to match" { + assert_true( + align_sam_test_parse_raises(align_sam_test_mapped("4M", "ACGT", "!!!", "")), + ) + assert_true( + align_sam_test_parse_raises(align_sam_test_mapped("4M", "*", "!!!!", "")), + ) +} + +///| +test "Bio.Align.sam validates PHRED text range" { + assert_true( + align_sam_test_parse_raises(align_sam_test_mapped("1M", "A", " ", "")), + ) +} + +///| +test "Bio.Align.sam rejects negative mate positions" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_record( + "0", "chr1", "1", "60", "1M", "*", "-1", "0", "A", "!", "", + ), + ), + ) +} + +///| +test "Bio.Align.sam rejects equal mate reference for unmapped record" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_record( + "4", "*", "0", "0", "*", "=", "0", "0", "*", "*", "", + ), + ), + ) +} + +///| +test "Bio.Align.sam rejects duplicate optional tags" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_mapped("1M", "A", "!", "NM:i:0\tNM:i:1"), + ), + ) +} + +///| +test "Bio.Align.sam validates optional tag names" { + assert_true( + align_sam_test_parse_raises(align_sam_test_mapped("1M", "A", "!", "A_:i:1")), + ) + assert_true( + align_sam_test_parse_raises(align_sam_test_mapped("1M", "A", "!", "1A:i:1")), + ) +} + +///| +test "Bio.Align.sam rejects unknown optional tag types" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_mapped("1M", "A", "!", "ZZ:q:value"), + ), + ) +} + +///| +test "Bio.Align.sam validates character tags" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_mapped("1M", "A", "!", "AA:A:XY"), + ), + ) +} + +///| +test "Bio.Align.sam validates hexadecimal tags" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_mapped("1M", "A", "!", "HX:H:ABC"), + ), + ) + assert_true( + align_sam_test_parse_raises( + align_sam_test_mapped("1M", "A", "!", "HX:H:AZ"), + ), + ) +} + +///| +test "Bio.Align.sam validates array tag subtypes" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_mapped("1M", "A", "!", "BA:B:q,1"), + ), + ) + assert_true( + align_sam_test_parse_raises(align_sam_test_mapped("1M", "A", "!", "BA:B:i")), + ) +} + +///| +test "Bio.Align.sam validates array tag integer ranges" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_mapped("1M", "A", "!", "BA:B:c,128"), + ), + ) + assert_true( + align_sam_test_parse_raises( + align_sam_test_mapped("1M", "A", "!", "BA:B:C,-1"), + ), + ) + assert_true( + align_sam_test_parse_raises( + align_sam_test_mapped("1M", "A", "!", "BA:B:s,32768"), + ), + ) + assert_true( + align_sam_test_parse_raises( + align_sam_test_mapped("1M", "A", "!", "BA:B:S,65536"), + ), + ) + assert_true( + align_sam_test_parse_raises( + align_sam_test_mapped("1M", "A", "!", "BA:B:I,-1"), + ), + ) +} + +///| +test "Bio.Align.sam requires MD to use string datatype" { + assert_true( + align_sam_test_parse_raises(align_sam_test_mapped("1M", "A", "!", "MD:i:1")), + ) +} + +///| +test "Bio.Align.sam requires AS to use integer datatype" { + assert_true( + align_sam_test_parse_raises(align_sam_test_mapped("1M", "A", "!", "AS:Z:1")), + ) +} + +///| +test "Bio.Align.sam validates MD total reference consumption" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_mapped("4M", "ACGT", "!!!!", "MD:Z:3"), + ), + ) +} + +///| +test "Bio.Align.sam validates MD token grammar" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_mapped("1M", "A", "!", "MD:Z:A0"), + ), + ) + assert_true( + align_sam_test_parse_raises( + align_sam_test_mapped("1M", "A", "!", "MD:Z:0A"), + ), + ) +} + +///| +test "Bio.Align.sam aligns MD deletions with CIGAR D" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_mapped("1M", "A", "!", "MD:Z:0^A0"), + ), + ) + assert_true( + align_sam_test_parse_raises(align_sam_test_mapped("1D", "*", "*", "MD:Z:1")), + ) +} + +///| +test "Bio.Align.sam aligns MD mismatches with equal and mismatch CIGAR" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_mapped("1=", "A", "!", "MD:Z:0C0"), + ), + ) + assert_true( + align_sam_test_parse_raises(align_sam_test_mapped("1X", "A", "!", "MD:Z:1")), + ) + let alignment = align_sam_test_parse( + align_sam_test_mapped("1X", "A", "!", "MD:Z:0C0"), + ).alignments[0] + assert_eq(alignment.computed_nm(), Some(1)) +} + +///| +test "Bio.Align.sam rejects MD on unmapped records" { + assert_true( + align_sam_test_parse_raises( + align_sam_test_record( + "4", "*", "0", "0", "*", "*", "0", "0", "A", "!", "MD:Z:0", + ), + ), + ) +} + +///| +test "Bio.Align.sam aligned rows reject unmapped records" { + let alignment = align_sam_test_parse( + align_sam_test_record( + "4", "*", "0", "0", "*", "*", "0", "0", "A", "!", "", + ), + ).alignments[0] + let failed = try { + ignore(alignment.aligned_rows()) + false + } catch { + AlignSamError(_) => true + } + assert_true(failed) +} + +///| +test "Bio.Align.sam validates reference length for row reconstruction" { + let failed = try { + ignore(align_sam_test_forward().aligned_rows(reference_sequence="ACGT")) + false + } catch { + AlignSamError(_) => true + } + assert_true(failed) +} + +///| +test "Bio.Align.sam calculate MD requires mapped sequence and reference" { + let unknown = align_sam_test_parse( + align_sam_test_record( + "0", "contig", "1", "60", "1M", "*", "0", "0", "*", "*", "", + ), + ).alignments[0] + let failed_unknown = try { + ignore(@src.align_sam_calculate_md(unknown, "A")) + false + } catch { + AlignSamError(_) => true + } + assert_true(failed_unknown) + let failed_length = try { + ignore( + @src.align_sam_calculate_md(align_sam_test_forward(), "A".repeat(39)), + ) + false + } catch { + AlignSamError(_) => true + } + assert_true(failed_length) +} + +///| +test "Bio.Align.sam format requires reference when calculating MD" { + let failed = try { + ignore(@src.align_sam_format(align_sam_test_forward(), calculate_md=true)) + false + } catch { + AlignSamError(_) => true + } + assert_true(failed) +} + +///| +test "Bio.Align.sam constructor validates reference geometry" { + let bad_length = try { + ignore(@src.align_sam_create("r", "chr1", 0, 0, "A", "1M")) + false + } catch { + AlignSamError(_) => true + } + let bad_start = try { + ignore(@src.align_sam_create("r", "chr1", 10, -1, "A", "1M")) + false + } catch { + AlignSamError(_) => true + } + let overrun = try { + ignore(@src.align_sam_create("r", "chr1", 10, 9, "AA", "2M")) + false + } catch { + AlignSamError(_) => true + } + assert_true(bad_length) + assert_true(bad_start) + assert_true(overrun) +} + +///| +test "Bio.Align.sam constructor validates qualities and flags" { + let bad_quality = try { + ignore( + @src.align_sam_create("r", "chr1", 10, 0, "AA", "2M", qualities=[20]), + ) + false + } catch { + AlignSamError(_) => true + } + let bad_flag = try { + ignore(@src.align_sam_create("r", "chr1", 10, 0, "A", "1M", flag=0x4)) + false + } catch { + AlignSamError(_) => true + } + let bad_mapq = try { + ignore(@src.align_sam_create("r", "chr1", 10, 0, "A", "1M", mapq=256)) + false + } catch { + AlignSamError(_) => true + } + assert_true(bad_quality) + assert_true(bad_flag) + assert_true(bad_mapq) +} From 0ad274dd6b2d81905648e0cd143ca8fed4e0301f Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 18:42:20 +0800 Subject: [PATCH 31/41] #28 feat(celda): Bioconductor celda_CG --- README.md | 26 +- examples/celda_demo/main.mbt | 147 +++ examples/celda_demo/moon.pkg | 5 + src/celda.mbt | 1648 ++++++++++++++++++++++++++++++++++ test/moonbit/celda_test.mbt | 1293 ++++++++++++++++++++++++++ 5 files changed, 3115 insertions(+), 4 deletions(-) create mode 100644 examples/celda_demo/main.mbt create mode 100644 examples/celda_demo/moon.pkg create mode 100644 src/celda.mbt create mode 100644 test/moonbit/celda_test.mbt diff --git a/README.md b/README.md index 2c246226..c9f16383 100644 --- a/README.md +++ b/README.md @@ -169,6 +169,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | Bio.Align.bigbed | BigBed v4二进制读写、BED3-BED12、AutoSQL扩展字段、多级chromosome B+ tree与R-tree、zlib/DEFLATE解码、区间/名称查询和BED导出 | | ✅ | Bio.Align.bigmaf | 标准bedMaf bed3+1读写、完整MAF a/s/i/e/q语义、正负链坐标映射、BigBed压缩索引查询、MAF导出和严格损坏数据诊断 | | ✅ | Bioconductor decontX | 单细胞ambient RNA去污染: cluster-native/contaminant多项式混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解、诊断与SingleCellExperiment接入 | +| ✅ | Bioconductor celda | `celda_CG`细胞群与基因模块联合聚类: 分层Dirichlet-multinomial、collapsed likelihood、EM/Gibbs、多链、K/L模型选择、预测与SingleCellExperiment接入 | | ✅ | Bio.PDB.SASA | 溶剂可及表面积计算: Shrake-Rupley滚动球算法(Fibonacci球面采样)、范德华半径查表、逐原子/残基/链SASA、骨架/侧链拆分 | | ✅ | Bio.SeqIO.NibIO | nib 2-bit二进制序列格式: DNA 2-bit编码(T=0/C=1/A=2/G=3)、4碱基/字节打包、hex I/O、子序列提取、反向互补、GC含量、压缩比 | | ✅ | ChIPseeker | ChIP-seq峰注释: 峰-TSS距离计算、基因组特征分配(Promoter/5'UTR/3'UTR/Exon/Intron/Downstream/Distal Intergenic)、最近基因查找、注释摘要 | @@ -308,6 +309,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **scran** | Bioconductor scran | 单细胞归一化(sum_factors)、SNN图构建、Leiden聚类、差异标志物分析 | ✅ | | **scrapper** | Bioconductor scrapper | 批次感知RNA QC、大小因子清洗与居中、log-normalization、LOWESS方差趋势、HVG选择、多因子pseudo-bulk、不可变SCE集成 | ✅ | | **decontX** | Bioconductor decontX | cluster-aware ambient RNA混合模型、每细胞污染率、Beta/Dirichlet先验EM、empty-droplet profile、自动k-means、native/contaminant计数分解与SCE集成 | ✅ | +| **celda** | Bioconductor celda | `celda_CG`细胞群/基因模块联合聚类、collapsed likelihood、EM/Gibbs、多链、K/L网格选择、新细胞预测与SCE集成 | ✅ | | **miloR** | Bioconductor miloR | 精确KNN图、精炼重叠邻域、邻域×样本计数、NB-GLM/Wald检验、BH与四种graph spatial FDR、SingleCellExperiment接入 | ✅ | | **monocle3** | Bioconductor monocle3 | 单细胞轨迹分析、PCA/UMAP降维、主图学习、拟时间排序、差异表达分析、分支点检测、分支特异性差异表达 | ✅ | | **ShortRead** | Bioconductor ShortRead | 短读序列质量控制、QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告生成 | ✅ | @@ -582,6 +584,7 @@ IvanAXu/BioSeqs/ │ ├── scran.mbt # scran 单细胞归一化与聚类 (sum_factors、SNN图、Leiden聚类、标志物分析) │ ├── scrapper.mbt # scrapper 单细胞预处理 (批次感知RNA QC、大小因子、LOWESS/HVG、pseudo-bulk、SCE集成) │ ├── decontx.mbt # decontX ambient RNA去污染 (Bayesian EM、background、自动聚类、计数分解、SCE集成) +│ ├── celda.mbt # celda_CG 细胞群与基因模块联合聚类 (collapsed likelihood、EM/Gibbs、多链、模型选择、SCE集成) │ ├── milo.mbt # miloR KNN邻域差异丰度 (精炼采样、NB-GLM、graph spatial FDR、SCE接入) │ ├── zinbwave.mbt # zinbwave 零膨胀NB低维模型 (EM/IRLS、latent factors、observational weights、SCE接入) │ ├── variance_partition.mbt # variancePartition 混合模型方差分解、BLUP与dream重复测量检验 @@ -933,6 +936,7 @@ IvanAXu/BioSeqs/ │ ├── scran_demo/ # scran 单细胞归一化与聚类示例 (sum_factors、SNN图、Leiden聚类、标志物分析) │ ├── scrapper_demo/ # scrapper 批次感知RNA QC、归一化、LOWESS/HVG、pseudo-bulk与SCE集成示例 │ ├── decontx_demo/ # decontX cluster/background去污染、marker校正、诊断与SCE输出示例 +│ ├── celda_demo/ # celda_CG联合聚类、module marker、细胞预测、模型选择与SCE输出示例 │ ├── milo_demo/ # miloR KNN图、精炼邻域、NB差异丰度、spatial FDR与SCE接入示例 │ ├── zinbwave_demo/ # zinbwave latent factors、dropout权重、残差/插补与SCE集成示例 │ ├── apeglm_demo/ # apeglm MLE/MAP、重尾收缩、FSR/FSOS、TSV与SE接入示例 @@ -1349,6 +1353,7 @@ IvanAXu/BioSeqs/ │ │ ├── scran_test.mbt │ │ ├── scrapper_test.mbt │ │ ├── decontx_test.mbt +│ │ ├── celda_test.mbt │ │ ├── milo_test.mbt │ │ ├── zinbwave_test.mbt │ │ ├── apeglm_test.mbt @@ -1543,7 +1548,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 9733 个测试全部通过 +moon test # ✅ 9808 个测试全部通过 ``` ### 模块对照表 @@ -1658,6 +1663,7 @@ moon test # ✅ 9733 个测试全 | `nnsvg.mbt` | Bioconductor nnSVG | 坐标缩放与前驱kNN、指数协方差NNGP、协变量GLS、profile ML、空间/非空间LR检验、gene-specific length scale、BH-FDR及SpatialExperiment接入 | | `banksy.mbt` | Bioconductor Banksy | H0邻域均值、H1+方位Fourier/Gabor harmonic、六类空间核、lambda联合矩阵、分组标准化、PCA、多起点k-means、平滑、ARI与SpatialExperiment接入 | | `decontx.mbt` | Bioconductor decontX | cluster-native/contaminant多项式混合、Beta/Dirichlet先验EM、background、自动聚类、计数分解与SCE输出 | +| `celda.mbt` | Bioconductor celda | `celda_CG`分层Dirichlet-multinomial、细胞群/基因模块联合推断、collapsed likelihood、EM/Gibbs、多链、K/L选择、预测与SCE输出 | | `summarized_experiment.mbt` | Bioconductor SummarizedExperiment | 多维数据容器 | | `ranged_summarized_experiment.mbt` | Bioconductor RangedSummarizedExperiment | GRanges/GRangesList行范围、链特异重叠/最近邻、覆盖度、区间变换与协调子集 | | `tree_summarized_experiment.mbt` | Bioconductor TreeSummarizedExperiment | 行/列树与数据链接、按节点子集、层级聚合 | @@ -1862,6 +1868,7 @@ moon test # ✅ 9733 个测试全 | `muscat.mbt` | `muscat` | 单细胞差异状态分析（伪批量聚合、DS 检验、QC） | | `scrapper.mbt` | `scrapper` | 批次感知RNA QC、大小因子清洗/居中、count与log归一化、LOWESS方差趋势、HVG选择、多因子pseudo-bulk、SingleCellExperiment不可变包装 | | `decontx.mbt` | `decontX` | 每细胞native/contaminant Bayesian mixture、确定性EM、empty-droplet ambient profile、自动k-means、诊断与SingleCellExperiment不可变包装 | +| `celda.mbt` | `celda` | `celda_CG`细胞群/基因模块联合聚类、四层Dirichlet-multinomial、collapsed EM/Gibbs、多链诊断、K/L网格选择、预测与SingleCellExperiment不可变包装 | | `milo.mbt` | `miloR` | 精确KNN图、median精炼重叠邻域、邻域计数/表达、固定效应NB-GLM/Wald检验、graph spatial FDR与SCE接入 | | `zinbwave.mbt` | `zinbwave` | ZINB交替EM/IRLS、cell/gene design与offset、确定性低维因子、gene dispersion shrinkage、observational weights、deviance residual及SingleCellExperiment包装 | | `apeglm.mbt` | `apeglm` | 负二项GLM MLE、自适应Cauchy/Student-t先验、阻尼Newton多起点MAP、Laplace后验SD/区间、FSR/FSOS/s-value、DESeq2与SummarizedExperiment包装 | @@ -3086,6 +3093,14 @@ optional tags 保留 `A/i/f/Z/H/B:c/C/s/S/i/I/f` 的类型和数组 subtype， 解析器严格诊断 header 顺序与重复 reference、字段数和整数边界、mapped/unmapped 一致性、reference 越界、CIGAR clipping/P 操作、SEQ/QUAL/CIGAR 长度、PHRED 范围、重复或非法 tag、B-array subtype/range，以及 MD token 与 CIGAR `=/X/D` 的逐碱基结构冲突。当前范围聚焦 SAM 文本和 alignment coordinate semantics，不解码 BAM/CRAM；二进制格式继续由现有 `bam.mbt`、`cram_wbtest.mbt` 负责。 +### 266. 细胞群与基因模块联合聚类 (Bioconductor celda) + +实现 Bioconductor `celda` 的 `celda_CG` 可移植核心，输入统一为 feature × cell 非负整数计数矩阵。模型联合推断 cell population 标签与 feature module 标签，并以 `Theta`（sample 内 population）、`Phi`（population 内 module）、`Psi`（module 内 feature）和 `Eta`（全局 module abundance）构成四层 Dirichlet-multinomial；collapsed log-likelihood 使用 `alpha/beta/delta/gamma` 超参数，并保留上游每个 module 一个 pseudogene 的平滑语义。 + +推断支持确定性 hard-EM 与 seeded Gibbs、多链 farthest-first/balanced 初始化、最佳状态保存、提前停止、非空 population/module 约束及稳定标签重排。结果提供 posterior 参数、fitted counts、population/module 成员与 top features、perplexity、AIC/BIC、独立 likelihood 计算和新细胞 posterior prediction；`celda_cg_grid_search` 可按 BIC、perplexity 或 likelihood 比较 K/L 候选。 + +`celda_cg_sce` 从指定 assay 和可选 sample `colData` 读取输入，在不可变 `SingleCellExperiment` 副本中写入 fitted assay、1-based population/module 标签及模型诊断 metadata。所有入口校验矩阵方向、矩形性、有限非负整数、名称唯一性、sample/初始标签完整性和超参数边界。当前实现采用 dense MoonBit arrays 和单线程完整 collapsed likelihood 重算，面向中小型矩阵及可验证工作流，不等同于上游 C++/OpenMP 大规模性能后端。 + ## 性能优化 ### 优化策略 @@ -3187,8 +3202,8 @@ optional tags 保留 `A/i/f/Z/H/B:c/C/s/S/i/I/f` 的类型和数组 subtype， | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 9733 | -| 通过数 | 9733 | +| 总测试数 | 9808 | +| 通过数 | 9808 | | 失败数 | 0 | | 通过率 | 100% | @@ -3319,6 +3334,7 @@ moon test --update | scran | `scran_test.mbt` | 8 | | scrapper | `scrapper_test.mbt` | 35 | | decontX | `decontx_test.mbt` | 43 | +| celda_CG | `celda_test.mbt` | 75 | | miloR | `milo_test.mbt` | 37 | | zinbwave | `zinbwave_test.mbt` | 54 | | apeglm | `apeglm_test.mbt` | 66 | @@ -3601,7 +3617,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 373 个示例程序，展示各模块的典型用法： +项目提供 374 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3693,6 +3709,7 @@ moon run cmd/bench/main.mbt | scater_demo | scater 单细胞质量控制（QC指标计算、细胞/基因过滤、CPM/log-CPM标准化、HVG检测、PCA降维） | `moon run examples/scater_demo/main.mbt` | | scrapper_demo | 批次感知RNA QC、大小因子归一化、LOWESS/HVG、多因子pseudo-bulk和不可变SCE集成 | `moon run examples/scrapper_demo` | | decontx_demo | cluster/background ambient RNA去污染、每细胞污染率、marker校正、cluster诊断和不可变SCE输出 | `moon run examples/decontx_demo` | +| celda_demo | `celda_CG`细胞群/基因模块联合聚类、top markers、新细胞预测、BIC模型选择和不可变SCE输出 | `moon run examples/celda_demo` | | milo_demo | 精确KNN图、精炼重叠邻域、样本计数、NB-GLM差异丰度、graph spatial FDR和SCE接入 | `moon run examples/milo_demo` | | zinbwave_demo | ZINB latent-factor拟合、dropout后验权重、归一化/插补/deviance residual和不可变SCE输出 | `moon run examples/zinbwave_demo` | | apeglm_demo | NB-GLM MLE与自适应重尾MAP、FSR/s-value/FSOS、log2 TSV及不可变SummarizedExperiment输出 | `moon run examples/apeglm_demo` | @@ -3919,6 +3936,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bio.Align.bigmaf BigMaf多物种比对索引（标准bedMaf、MAF a/s/i/e/q、正负链坐标映射、压缩BigBed查询与MAF导出） - ✅ 实现 Bio.Align.bigpsl BigPsl成对比对索引（标准bed12+13、核酸/translated protein坐标、match recount、压缩BigBed查询与PSL导出） - ✅ 实现 Bioconductor decontX ambient RNA去污染（cluster-native/contaminant混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解与SCE集成） +- ✅ 实现 Bioconductor celda `celda_CG`细胞群与基因模块联合聚类（分层Dirichlet-multinomial、collapsed EM/Gibbs、多链、K/L选择、预测与SCE集成） - ✅ 实现 Bioconductor zinbwave 零膨胀负二项低维模型（cell/gene协变量、offset、latent factors、dispersion shrinkage、observational weights、残差/插补与SCE集成） - ✅ 实现 Bioconductor apeglm 自适应重尾效应量收缩（NB-GLM MLE、经验贝叶斯Cauchy/Student-t先验、多起点MAP、Laplace后验、FSR/FSOS/s-value与容器接入） - ✅ 实现 Bioconductor ALDEx2 组成型差异丰度（Dirichlet Monte Carlo、六类denominator、两组/配对检验、posterior expected BH、effect/overlap、距离与SummarizedExperiment接入） diff --git a/examples/celda_demo/main.mbt b/examples/celda_demo/main.mbt new file mode 100644 index 00000000..ccab72a9 --- /dev/null +++ b/examples/celda_demo/main.mbt @@ -0,0 +1,147 @@ +// Bioconductor celda_CG-inspired joint cell and feature clustering workflow. + +///| +fn celda_demo_config() -> @src.CeldaCGConfig { + @src.CeldaCGConfig::create( + 3, + 4, + max_iterations=20, + stop_iterations=4, + chains=3, + seed=2026, + ) catch { + _ => abort("invalid celda_CG configuration") + } +} + +///| +fn main { + println("=== Bioconductor celda_CG Demo ===") + let (counts, features, cells, samples) = @src.celda_cg_example_data() + + println("\n1. Jointly cluster cells and feature modules") + let result = @src.celda_cg_fit( + counts, + samples, + celda_demo_config(), + feature_names=features, + cell_names=cells, + ) catch { + _ => abort("celda_CG model fitting failed") + } + println(" " + result.summary()) + println( + " chains=" + + result.diagnostics.chain_scores.length().to_string() + + ", selected chain=" + + (result.diagnostics.best_chain + 1).to_string(), + ) + for population in 0.. abort("population query failed") + } + println( + " population " + + (population + 1).to_string() + + ": " + + members.length().to_string() + + " cells", + ) + } + + println("\n2. Inspect feature modules and their strongest markers") + for module_ in 0.. abort("feature module query failed") + } + let mut marker_text = "" + for index in 0.. 0 { + marker_text = marker_text + ", " + } + marker_text = marker_text + + top[index].feature_name + + " (" + + top[index].probability.to_string() + + ")" + } + println(" module " + (module_ + 1).to_string() + ": " + marker_text) + } + + println("\n3. Predict populations for new cells") + let new_counts : Array[Array[Double]] = [] + for feature in 0.. abort("celda_CG prediction failed") + } + for cell in 0.. population " + + (prediction.assignments[cell] + 1).to_string(), + ) + } + + println("\n4. Compare candidate K values by BIC") + let grid_config = @src.CeldaCGConfig::create( + 1, + 1, + max_iterations=8, + stop_iterations=2, + chains=1, + seed=31, + ) catch { + _ => abort("invalid grid-search configuration") + } + let grid = @src.celda_cg_grid_search( + counts, + samples, + [2, 3], + [4], + grid_config, + feature_names=features, + cell_names=cells, + ) catch { + _ => abort("celda_CG grid search failed") + } + for entry in grid.entries { + println( + " K=" + + entry.cell_populations.to_string() + + ", L=" + + entry.feature_modules.to_string() + + ", BIC=" + + entry.score.to_string(), + ) + } + println( + " selected K=" + grid.best_result().config.cell_populations.to_string(), + ) + + println("\n5. Add fitted counts and labels to an SCE copy") + let sce = @src.SingleCellExperiment::new(counts, features, cells) + sce.col_data["donor"] = samples + let output = @src.celda_cg_sce( + sce, + celda_demo_config(), + sample_column="donor", + ) catch { + _ => abort("celda_CG SCE integration failed") + } + println( + " fitted assay rows=" + + @src.sce_get_assay(output.experiment, "celda_fitted").length().to_string(), + ) + println( + " cell labels=" + + @src.sce_get_col_data(output.experiment, "celda_cell_population") + .length() + .to_string() + + ", source unchanged=" + + (@src.sce_get_assay(sce, "celda_fitted").length() == 0).to_string(), + ) + println("\n=== Demo Complete ===") +} diff --git a/examples/celda_demo/moon.pkg b/examples/celda_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/celda_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/celda.mbt b/src/celda.mbt new file mode 100644 index 00000000..27988406 --- /dev/null +++ b/src/celda.mbt @@ -0,0 +1,1648 @@ +// Cellular Latent Dirichlet Allocation for single-cell count matrices. +// +// This module implements the celda_CG hierarchy from Bioconductor celda. +// Matrices use feature x cell orientation and labels are zero-based. + +///| +pub suberror CeldaError { + CeldaError(String) +} + +///| +pub(all) enum CeldaAlgorithm { + CeldaEm + CeldaGibbs +} derive(Eq, Debug) + +///| +pub(all) enum CeldaCGCriterion { + CeldaBic + CeldaPerplexity + CeldaLogLikelihood +} derive(Eq, Debug) + +///| +pub struct CeldaCGConfig { + cell_populations : Int + feature_modules : Int + alpha : Double + beta : Double + delta : Double + gamma : Double + algorithm : CeldaAlgorithm + max_iterations : Int + stop_iterations : Int + chains : Int + tolerance : Double + seed : Int +} derive(Eq, Debug) + +///| +pub fn CeldaCGConfig::create( + cell_populations : Int, + feature_modules : Int, + alpha? : Double = 1.0, + beta? : Double = 1.0, + delta? : Double = 1.0, + gamma? : Double = 1.0, + algorithm? : CeldaAlgorithm = CeldaEm, + max_iterations? : Int = 200, + stop_iterations? : Int = 10, + chains? : Int = 3, + tolerance? : Double = 1.0e-8, + seed? : Int = 12345, +) -> CeldaCGConfig raise CeldaError { + if cell_populations < 1 { + raise CeldaError::CeldaError("celda_CG cell_populations must be positive") + } + if feature_modules < 1 { + raise CeldaError::CeldaError("celda_CG feature_modules must be positive") + } + if !celda_is_finite(alpha) || alpha <= 0.0 { + raise CeldaError::CeldaError("celda_CG alpha must be finite and positive") + } + if !celda_is_finite(beta) || beta <= 0.0 { + raise CeldaError::CeldaError("celda_CG beta must be finite and positive") + } + if !celda_is_finite(delta) || delta <= 0.0 { + raise CeldaError::CeldaError("celda_CG delta must be finite and positive") + } + if !celda_is_finite(gamma) || gamma <= 0.0 { + raise CeldaError::CeldaError("celda_CG gamma must be finite and positive") + } + if max_iterations < 1 || stop_iterations < 1 { + raise CeldaError::CeldaError("celda_CG iteration limits must be positive") + } + if chains < 1 { + raise CeldaError::CeldaError("celda_CG chains must be positive") + } + if !celda_is_finite(tolerance) || tolerance <= 0.0 { + raise CeldaError::CeldaError( + "celda_CG tolerance must be finite and positive", + ) + } + if seed <= 0 { + raise CeldaError::CeldaError("celda_CG seed must be positive") + } + CeldaCGConfig::{ + cell_populations, + feature_modules, + alpha, + beta, + delta, + gamma, + algorithm, + max_iterations, + stop_iterations, + chains, + tolerance, + seed, + } +} + +///| +pub fn CeldaCGConfig::with_dimensions( + self : CeldaCGConfig, + cell_populations : Int, + feature_modules : Int, + seed? : Int = self.seed, +) -> CeldaCGConfig raise CeldaError { + CeldaCGConfig::create( + cell_populations, + feature_modules, + alpha=self.alpha, + beta=self.beta, + delta=self.delta, + gamma=self.gamma, + algorithm=self.algorithm, + max_iterations=self.max_iterations, + stop_iterations=self.stop_iterations, + chains=self.chains, + tolerance=self.tolerance, + seed~, + ) +} + +///| +pub struct CeldaCGDiagnostics { + iterations : Int + converged : Bool + log_likelihoods : Array[Double] + chain_scores : Array[Double] + best_chain : Int +} derive(Eq, Debug) + +///| +pub struct CeldaFeatureScore { + feature_index : Int + feature_name : String + probability : Double + total_count : Double +} derive(Eq, Debug) + +///| +pub struct CeldaCGResult { + cell_clusters : Array[Int] + feature_modules : Array[Int] + sample_indices : Array[Int] + sample_names : Array[String] + feature_names : Array[String] + cell_names : Array[String] + theta : Array[Array[Double]] + phi : Array[Array[Double]] + psi : Array[Array[Double]] + eta : Array[Double] + fitted_counts : Array[Array[Double]] + feature_totals : Array[Double] + cell_totals : Array[Double] + log_likelihood : Double + perplexity : Double + aic : Double + bic : Double + diagnostics : CeldaCGDiagnostics + config : CeldaCGConfig +} + +///| +pub struct CeldaCGPrediction { + probabilities : Array[Array[Double]] + assignments : Array[Int] +} derive(Eq, Debug) + +///| +pub struct CeldaCGGridEntry { + cell_populations : Int + feature_modules : Int + score : Double + result : CeldaCGResult +} + +///| +pub struct CeldaCGGridSearch { + entries : Array[CeldaCGGridEntry] + best_index : Int + criterion : CeldaCGCriterion +} + +///| +pub struct CeldaCGSCEOutput { + experiment : SingleCellExperiment + result : CeldaCGResult +} + +///| +priv struct CeldaCGSufficient { + population_by_sample : Array[Array[Double]] + module_by_population : Array[Array[Double]] + feature_totals : Array[Double] + module_totals : Array[Double] + features_by_module : Array[Int] + cell_totals : Array[Double] +} + +///| +priv struct CeldaRng { + mut state : Int +} + +///| +fn CeldaRng::new(seed : Int) -> CeldaRng { + let normalized = (seed - 1) % 2147483646 + 1 + CeldaRng::{ state: normalized } +} + +///| +fn CeldaRng::uniform(self : CeldaRng) -> Double { + let quotient = self.state / 44488 + let remainder = self.state % 44488 + let candidate = 48271 * remainder - 3399 * quotient + self.state = if candidate > 0 { candidate } else { candidate + 2147483647 } + self.state.to_double() / 2147483647.0 +} + +///| +fn celda_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn celda_log_gamma(value : Double) -> Double { + let coefficients = [ + 0.9999999999998099, 676.5203681218851, -1259.1392167224028, 771.3234287776531, + -176.6150291621406, 12.507343278686905, -0.13857109526572012, 9.984369578019572e-6, + 1.5056327351493116e-7, + ] + if value < 0.5 { + let pi = 3.141592653589793 + return @math.ln(pi) - + @math.ln(@math.sin(pi * value).abs()) - + celda_log_gamma(1.0 - value) + } + let shifted = value - 1.0 + let mut series = coefficients[0] + for index in 1.. Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for _ in 0.. Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in values { + output.push(row.copy()) + } + output +} + +///| +fn celda_default_names(prefix : String, count : Int) -> Array[String] { + let output : Array[String] = [] + for index in 0.. Array[String] raise CeldaError { + if supplied.length() == 0 { + return celda_default_names(prefix, count) + } + if supplied.length() != count { + raise CeldaError::CeldaError( + "celda_CG " + prefix + " names must match the matrix dimension", + ) + } + let seen : Map[String, Bool] = Map([]) + let output : Array[String] = [] + for name in supplied { + let trimmed = name.trim().to_owned() + if trimmed.length() == 0 { + raise CeldaError::CeldaError( + "celda_CG " + prefix + " names cannot be empty", + ) + } + if seen.contains(trimmed) { + raise CeldaError::CeldaError( + "celda_CG " + prefix + " names must be unique: " + trimmed, + ) + } + seen[trimmed] = true + output.push(trimmed) + } + output +} + +///| +fn celda_validate_counts( + counts : Array[Array[Double]], +) -> (Int, Int) raise CeldaError { + if counts.length() == 0 { + raise CeldaError::CeldaError( + "celda_CG counts must contain at least one feature", + ) + } + let cells = counts[0].length() + if cells == 0 { + raise CeldaError::CeldaError( + "celda_CG counts must contain at least one cell", + ) + } + let cell_totals = Array::make(cells, 0.0) + for feature in 0.. Unit raise CeldaError { + if labels.length() != count { + raise CeldaError::CeldaError( + "celda_CG " + label + " assignments must match the data dimension", + ) + } + let observed = Array::make(groups, 0) + for value in labels { + if value < 0 || value >= groups { + raise CeldaError::CeldaError( + "celda_CG " + label + " assignments are out of range", + ) + } + observed[value] = observed[value] + 1 + } + for size in observed { + if size == 0 { + raise CeldaError::CeldaError( + "celda_CG predefined " + label + " assignments must use every label", + ) + } + } +} + +///| +fn celda_encode_samples( + labels : Array[String], + cells : Int, +) -> (Array[String], Array[Int]) raise CeldaError { + let source = if labels.length() == 0 { + Array::make(cells, "Sample1") + } else { + labels + } + if source.length() != cells { + raise CeldaError::CeldaError( + "celda_CG sample labels must match the number of cells", + ) + } + let names : Array[String] = [] + let indices : Array[Int] = [] + for raw in source { + let label = raw.trim().to_owned() + if label.length() == 0 { + raise CeldaError::CeldaError("celda_CG sample labels cannot be empty") + } + let mut found = -1 + for index in 0.. Array[Int] { + let sizes = Array::make(groups, 0) + for label in labels { + sizes[label] = sizes[label] + 1 + } + sizes +} + +///| +fn celda_balanced_random_labels( + count : Int, + groups : Int, + rng : CeldaRng, +) -> Array[Int] { + let labels : Array[Int] = [] + for index in 0.. 0 { + let target = (rng.uniform() * (index + 1).to_double()).floor().to_int() + let temporary = labels[index] + labels[index] = labels[target] + labels[target] = temporary + index = index - 1 + } + labels +} + +///| +fn celda_squared_distance( + left : Array[Double], + right : Array[Double], +) -> Double { + let mut total = 0.0 + for index in 0.. Array[Array[Double]] { + let features = counts.length() + let cells = counts[0].length() + let output = celda_zero_matrix(cells, features) + for cell in 0.. Array[Array[Double]] { + let features = counts.length() + let cells = counts[0].length() + let output = celda_zero_matrix(features, cells) + for feature in 0.. Array[Int] { + let count = profiles.length() + let centers : Array[Int] = [offset % count] + while centers.length() < groups { + let mut best_index = -1 + let mut best_distance = -1.0 + for index in 0.. best_distance { + best_distance = nearest + best_index = index + } + } + } + centers.push(best_index) + } + let labels = Array::make(count, 0) + for index in 0.. CeldaCGSufficient { + let features = counts.length() + let cells = counts[0].length() + let population_by_sample = celda_zero_matrix(populations, sample_count) + let module_by_population = celda_zero_matrix(modules, populations) + let feature_totals = Array::make(features, 0.0) + let module_totals = Array::make(modules, 0.0) + let features_by_module = Array::make(modules, 1) + let cell_totals = Array::make(cells, 0.0) + for cell in 0.. Double { + let populations = config.cell_populations + let modules = config.feature_modules + let mut theta = sample_count.to_double() * + celda_log_gamma(populations.to_double() * config.alpha) - + (sample_count * populations).to_double() * celda_log_gamma(config.alpha) + for sample in 0.. Double { + let sufficient = celda_sufficient( + counts, + sample_indices, + sample_count, + cell_clusters, + feature_modules, + config.cell_populations, + config.feature_modules, + ) + celda_log_likelihood_from_sufficient(sufficient, sample_count, config) +} + +///| +pub fn celda_cg_log_likelihood( + counts : Array[Array[Double]], + sample_labels : Array[String], + cell_clusters : Array[Int], + feature_modules : Array[Int], + config : CeldaCGConfig, +) -> Double raise CeldaError { + let (features, cells) = celda_validate_counts(counts) + if config.cell_populations > cells { + raise CeldaError::CeldaError( + "celda_CG cell_populations cannot exceed the number of cells", + ) + } + if config.feature_modules > features { + raise CeldaError::CeldaError( + "celda_CG feature_modules cannot exceed the number of features", + ) + } + celda_validate_labels(cell_clusters, cells, config.cell_populations, "cell") + celda_validate_labels( + feature_modules, + features, + config.feature_modules, + "feature", + ) + let (sample_names, sample_indices) = celda_encode_samples( + sample_labels, cells, + ) + celda_internal_log_likelihood( + counts, + sample_indices, + sample_names.length(), + cell_clusters, + feature_modules, + config, + ) +} + +///| +fn celda_softmax(scores : Array[Double]) -> Array[Double] { + let mut maximum = scores[0] + for score in scores { + if score > maximum { + maximum = score + } + } + let probabilities = Array::make(scores.length(), 0.0) + let mut total = 0.0 + for index in 0.. Int { + match algorithm { + CeldaEm => { + let mut best = current + let mut best_score = scores[current] + for index in 0.. best_score + 1.0e-12 { + best = index + best_score = scores[index] + } + } + best + } + CeldaGibbs => { + let probabilities = celda_softmax(scores) + let target = rng.uniform() + let mut cumulative = 0.0 + for index in 0.. Unit { + let sizes = celda_group_sizes(feature_modules, config.feature_modules) + for feature in 0.. 1 { + let scores = Array::make(config.feature_modules, -1.0e300) + for candidate in 0.. Unit { + let sizes = celda_group_sizes(cell_clusters, config.cell_populations) + for cell in 0.. 1 { + let scores = Array::make(config.cell_populations, -1.0e300) + for candidate in 0.. Array[Int] { + let totals = Array::make(groups, 0.0) + for index in 0.. totals[order[best]] { + best = right + } + } + if best != left { + let temporary = order[left] + order[left] = order[best] + order[best] = temporary + } + } + let mapping = Array::make(groups, 0) + for index in 0.. ( + Array[Array[Double]], + Array[Array[Double]], + Array[Array[Double]], + Array[Double], + Array[Array[Double]], + Array[Double], + Array[Double], +) { + let sufficient = celda_sufficient( + counts, + sample_indices, + sample_count, + cell_clusters, + feature_modules, + config.cell_populations, + config.feature_modules, + ) + let theta = celda_zero_matrix(config.cell_populations, sample_count) + for sample in 0.. Double { + let mut negative_log_likelihood = 0.0 + let mut total_counts = 0.0 + for feature in 0.. 0.0 { + let probability = (fitted[feature][cell] / cell_totals[cell]).max( + 1.0e-300, + ) + negative_log_likelihood = negative_log_likelihood - + value * @math.ln(probability) + total_counts = total_counts + value + } + } + } + @math.exp(negative_log_likelihood / total_counts) +} + +///| +fn celda_information_criteria( + log_likelihood : Double, + features : Int, + cells : Int, + samples : Int, + config : CeldaCGConfig, +) -> (Double, Double) { + let parameter_count = samples * (config.cell_populations - 1) + + config.cell_populations * (config.feature_modules - 1) + + features + + config.feature_modules - + 1 + let aic = -2.0 * log_likelihood + 2.0 * parameter_count.to_double() + let observations = (features * cells).to_double().max(2.0) + let bic = -2.0 * log_likelihood + + parameter_count.to_double() * @math.ln(observations) + (aic, bic) +} + +///| +pub fn celda_cg_fit( + counts : Array[Array[Double]], + sample_labels : Array[String], + config : CeldaCGConfig, + feature_names? : Array[String] = [], + cell_names? : Array[String] = [], + initial_cell_clusters? : Array[Int] = [], + initial_feature_modules? : Array[Int] = [], +) -> CeldaCGResult raise CeldaError { + let (features, cells) = celda_validate_counts(counts) + if config.cell_populations > cells { + raise CeldaError::CeldaError( + "celda_CG cell_populations cannot exceed the number of cells", + ) + } + if config.feature_modules > features { + raise CeldaError::CeldaError( + "celda_CG feature_modules cannot exceed the number of features", + ) + } + let prepared_features = celda_prepare_names( + feature_names, features, "Feature", + ) + let prepared_cells = celda_prepare_names(cell_names, cells, "Cell") + let (sample_names, sample_indices) = celda_encode_samples( + sample_labels, cells, + ) + if initial_cell_clusters.length() > 0 { + celda_validate_labels( + initial_cell_clusters, + cells, + config.cell_populations, + "cell", + ) + } + if initial_feature_modules.length() > 0 { + celda_validate_labels( + initial_feature_modules, + features, + config.feature_modules, + "feature", + ) + } + let cell_profiles = celda_cell_profiles(counts) + let feature_profiles = celda_feature_profiles(counts) + let chain_scores : Array[Double] = [] + let mut global_score = -1.0e300 + let mut global_cells : Array[Int] = [] + let mut global_features : Array[Int] = [] + let mut global_history : Array[Double] = [] + let mut global_iterations = 0 + let mut global_converged = false + let mut best_chain = 0 + for chain in 0.. 0 { + initial_cell_clusters.copy() + } else if chain == 0 { + celda_farthest_labels(cell_profiles, config.cell_populations, chain_seed) + } else { + celda_balanced_random_labels(cells, config.cell_populations, rng) + } + let feature_modules = if initial_feature_modules.length() > 0 { + initial_feature_modules.copy() + } else if chain == 0 { + celda_farthest_labels( + feature_profiles, + config.feature_modules, + chain_seed + 17, + ) + } else { + celda_balanced_random_labels(features, config.feature_modules, rng) + } + let initial_score = celda_internal_log_likelihood( + counts, + sample_indices, + sample_names.length(), + cell_clusters, + feature_modules, + config, + ) + let history : Array[Double] = [initial_score] + let mut chain_best = initial_score + let mut best_cells = cell_clusters.copy() + let mut best_features = feature_modules.copy() + let mut without_improvement = 0 + let mut iterations = 0 + while iterations < config.max_iterations && + without_improvement < config.stop_iterations { + celda_update_features( + counts, + sample_indices, + sample_names.length(), + cell_clusters, + feature_modules, + config, + rng, + ) + celda_update_cells( + counts, + sample_indices, + sample_names.length(), + cell_clusters, + feature_modules, + config, + rng, + ) + let score = celda_internal_log_likelihood( + counts, + sample_indices, + sample_names.length(), + cell_clusters, + feature_modules, + config, + ) + history.push(score) + iterations = iterations + 1 + if score > chain_best + config.tolerance { + chain_best = score + best_cells = cell_clusters.copy() + best_features = feature_modules.copy() + without_improvement = 0 + } else { + without_improvement = without_improvement + 1 + } + } + chain_scores.push(chain_best) + if chain == 0 || chain_best > global_score { + global_score = chain_best + global_cells = best_cells + global_features = best_features + global_history = history + global_iterations = iterations + global_converged = without_improvement >= config.stop_iterations + best_chain = chain + } + } + let cell_weights = Array::make(cells, 1.0) + let feature_weights = Array::make(features, 0.0) + for feature in 0.. Int { + self.feature_names.length() +} + +///| +pub fn CeldaCGResult::n_cells(self : CeldaCGResult) -> Int { + self.cell_names.length() +} + +///| +pub fn CeldaCGResult::n_samples(self : CeldaCGResult) -> Int { + self.sample_names.length() +} + +///| +pub fn CeldaCGResult::population_sizes(self : CeldaCGResult) -> Array[Int] { + celda_group_sizes(self.cell_clusters, self.config.cell_populations) +} + +///| +pub fn CeldaCGResult::module_sizes(self : CeldaCGResult) -> Array[Int] { + celda_group_sizes(self.feature_modules, self.config.feature_modules) +} + +///| +pub fn CeldaCGResult::cell_population( + self : CeldaCGResult, + name : String, +) -> Int? { + for index in 0.. Int? { + for index in 0.. Array[String] raise CeldaError { + if population < 0 || population >= self.config.cell_populations { + raise CeldaError::CeldaError("celda_CG population index is out of range") + } + let output : Array[String] = [] + for index in 0.. Array[String] raise CeldaError { + if module_ < 0 || module_ >= self.config.feature_modules { + raise CeldaError::CeldaError("celda_CG module index is out of range") + } + let output : Array[String] = [] + for index in 0.. Array[CeldaFeatureScore] raise CeldaError { + if module_ < 0 || module_ >= self.config.feature_modules { + raise CeldaError::CeldaError("celda_CG module index is out of range") + } + if limit < 1 { + raise CeldaError::CeldaError("celda_CG top feature limit must be positive") + } + let scores : Array[CeldaFeatureScore] = [] + for feature in 0.. scores[best].probability { + best = right + } + } + if best != left { + let temporary = scores[left] + scores[left] = scores[best] + scores[best] = temporary + } + } + let output : Array[CeldaFeatureScore] = [] + let count = if limit < scores.length() { limit } else { scores.length() } + for index in 0.. String { + "celda_CG: " + + self.n_features().to_string() + + " features x " + + self.n_cells().to_string() + + " cells, K=" + + self.config.cell_populations.to_string() + + ", L=" + + self.config.feature_modules.to_string() + + ", logLik=" + + self.log_likelihood.to_string() + + ", perplexity=" + + self.perplexity.to_string() + + ", converged=" + + self.diagnostics.converged.to_string() +} + +///| +pub fn celda_cg_predict_cells( + result : CeldaCGResult, + counts : Array[Array[Double]], +) -> CeldaCGPrediction raise CeldaError { + let (features, cells) = celda_validate_counts(counts) + if features != result.n_features() { + raise CeldaError::CeldaError( + "celda_CG prediction features must match the fitted model", + ) + } + let probabilities = celda_zero_matrix(cells, result.config.cell_populations) + let assignments = Array::make(cells, 0) + for cell in 0.. 0.0 { + score = score + + counts[feature][cell] * + @math.ln((raw[feature] / denominator).max(1.0e-300)) + } + } + let mut prior = 0.0 + for sample in 0.. posterior[best] { + best = population + } + } + assignments[cell] = best + } + CeldaCGPrediction::{ probabilities, assignments } +} + +///| +pub fn celda_cg_grid_search( + counts : Array[Array[Double]], + sample_labels : Array[String], + cell_populations : Array[Int], + feature_modules : Array[Int], + base_config : CeldaCGConfig, + criterion? : CeldaCGCriterion = CeldaBic, + feature_names? : Array[String] = [], + cell_names? : Array[String] = [], +) -> CeldaCGGridSearch raise CeldaError { + if cell_populations.length() == 0 || feature_modules.length() == 0 { + raise CeldaError::CeldaError( + "celda_CG grid search dimensions cannot be empty", + ) + } + let entries : Array[CeldaCGGridEntry] = [] + let seen : Map[String, Bool] = Map([]) + let mut best_index = 0 + for k in cell_populations { + for l in feature_modules { + let key = k.to_string() + ":" + l.to_string() + if seen.contains(key) { + raise CeldaError::CeldaError( + "celda_CG grid search dimensions must be unique", + ) + } + seen[key] = true + let seed = (base_config.seed - 1 + entries.length() * 7919) % 2147483646 + + 1 + let config = base_config.with_dimensions(k, l, seed~) + let result = celda_cg_fit( + counts, + sample_labels, + config, + feature_names~, + cell_names~, + ) + let score = match criterion { + CeldaBic => result.bic + CeldaPerplexity => result.perplexity + CeldaLogLikelihood => result.log_likelihood + } + entries.push(CeldaCGGridEntry::{ + cell_populations: k, + feature_modules: l, + score, + result, + }) + let current = entries.length() - 1 + let better = match criterion { + CeldaLogLikelihood => entries[current].score > entries[best_index].score + _ => entries[current].score < entries[best_index].score + } + if current == 0 || better { + best_index = current + } + } + } + CeldaCGGridSearch::{ entries, best_index, criterion } +} + +///| +pub fn CeldaCGGridSearch::best_result( + self : CeldaCGGridSearch, +) -> CeldaCGResult { + self.entries[self.best_index].result +} + +///| +fn celda_copy_sce(sce : SingleCellExperiment) -> SingleCellExperiment { + let assays : Map[String, Array[Array[Double]]] = Map([]) + for key in sce.assays.keys() { + assays[key] = celda_copy_matrix(sce.assays[key]) + } + let row_data : Map[String, Array[String]] = Map([]) + for key in sce.row_data.keys() { + row_data[key] = sce.row_data[key].copy() + } + let col_data : Map[String, Array[String]] = Map([]) + for key in sce.col_data.keys() { + col_data[key] = sce.col_data[key].copy() + } + let reduced_dims : Map[String, Array[Array[Double]]] = Map([]) + for key in sce.reduced_dims.keys() { + reduced_dims[key] = celda_copy_matrix(sce.reduced_dims[key]) + } + let alternative_experiments : Map[String, SingleCellExperiment] = Map([]) + for key in sce.alternative_experiments.keys() { + alternative_experiments[key] = sce.alternative_experiments[key] + } + let metadata : Map[String, String] = Map([]) + for key in sce.metadata.keys() { + metadata[key] = sce.metadata[key] + } + SingleCellExperiment::{ + assays, + row_data, + col_data, + reduced_dims, + alternative_experiments, + metadata, + row_names: sce.row_names.copy(), + col_names: sce.col_names.copy(), + } +} + +///| +pub fn celda_cg_sce( + sce : SingleCellExperiment, + config : CeldaCGConfig, + sample_column? : String = "", + input_assay? : String = "counts", + fitted_assay? : String = "celda_fitted", +) -> CeldaCGSCEOutput raise CeldaError { + let counts = sce_get_assay(sce, input_assay) + if counts.length() == 0 { + raise CeldaError::CeldaError( + "celda_CG SingleCellExperiment assay not found: " + input_assay, + ) + } + let samples = if sample_column.length() == 0 { + [] + } else { + let values = sce_get_col_data(sce, sample_column) + if values.length() == 0 { + raise CeldaError::CeldaError( + "celda_CG SingleCellExperiment column data not found: " + sample_column, + ) + } + values + } + let result = celda_cg_fit( + counts, + samples, + config, + feature_names=sce.row_names, + cell_names=sce.col_names, + ) + let enriched = celda_copy_sce(sce) + enriched.assays[fitted_assay] = celda_copy_matrix(result.fitted_counts) + let module_labels : Array[String] = [] + for value in result.feature_modules { + module_labels.push((value + 1).to_string()) + } + let population_labels : Array[String] = [] + let output_samples : Array[String] = [] + for cell in 0.. ( + Array[Array[Double]], + Array[String], + Array[String], + Array[String], +) { + let counts = [ + [90.0, 84.0, 88.0, 82.0, 4.0, 3.0, 5.0, 4.0, 3.0, 2.0, 4.0, 3.0], + [72.0, 69.0, 75.0, 70.0, 3.0, 2.0, 4.0, 3.0, 2.0, 2.0, 3.0, 2.0], + [55.0, 50.0, 58.0, 53.0, 2.0, 3.0, 2.0, 3.0, 2.0, 3.0, 2.0, 3.0], + [3.0, 4.0, 3.0, 4.0, 92.0, 87.0, 95.0, 90.0, 4.0, 3.0, 5.0, 4.0], + [2.0, 3.0, 2.0, 3.0, 74.0, 71.0, 78.0, 73.0, 3.0, 2.0, 4.0, 3.0], + [3.0, 2.0, 3.0, 2.0, 58.0, 54.0, 61.0, 56.0, 2.0, 3.0, 2.0, 3.0], + [4.0, 3.0, 5.0, 4.0, 3.0, 4.0, 3.0, 4.0, 94.0, 89.0, 97.0, 92.0], + [3.0, 2.0, 4.0, 3.0, 2.0, 3.0, 2.0, 3.0, 76.0, 72.0, 80.0, 75.0], + [2.0, 3.0, 2.0, 3.0, 3.0, 2.0, 3.0, 2.0, 59.0, 55.0, 63.0, 57.0], + [22.0, 20.0, 21.0, 23.0, 21.0, 22.0, 20.0, 23.0, 22.0, 21.0, 23.0, 20.0], + [17.0, 18.0, 16.0, 19.0, 18.0, 17.0, 19.0, 16.0, 17.0, 19.0, 16.0, 18.0], + [12.0, 11.0, 13.0, 12.0, 11.0, 13.0, 12.0, 11.0, 13.0, 12.0, 11.0, 13.0], + ] + let features = [ + "T_marker_1", "T_marker_2", "T_marker_3", "B_marker_1", "B_marker_2", "B_marker_3", + "Mono_marker_1", "Mono_marker_2", "Mono_marker_3", "RPL", "RPS", "ACTB", + ] + let cells = [ + "T1", "T2", "T3", "T4", "B1", "B2", "B3", "B4", "M1", "M2", "M3", "M4", + ] + let samples = [ + "Donor1", "Donor1", "Donor2", "Donor2", "Donor1", "Donor1", "Donor2", "Donor2", + "Donor1", "Donor1", "Donor2", "Donor2", + ] + (counts, features, cells, samples) +} diff --git a/test/moonbit/celda_test.mbt b/test/moonbit/celda_test.mbt new file mode 100644 index 00000000..8066e127 --- /dev/null +++ b/test/moonbit/celda_test.mbt @@ -0,0 +1,1293 @@ +// Tests for Bioconductor celda_CG-inspired joint cell and feature clustering. + +///| +fn celda_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "celda_CG value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn celda_test_sum(values : Array[Double]) -> Double { + let mut total = 0.0 + for value in values { + total = total + value + } + total +} + +///| +fn celda_test_config() -> @src.CeldaCGConfig { + @src.CeldaCGConfig::create( + 3, + 4, + max_iterations=15, + stop_iterations=3, + chains=2, + seed=2026, + ) catch { + _ => abort("valid celda_CG configuration should build") + } +} + +///| +fn celda_test_result() -> @src.CeldaCGResult { + let (counts, features, cells, samples) = @src.celda_cg_example_data() + @src.celda_cg_fit( + counts, + samples, + celda_test_config(), + feature_names=features, + cell_names=cells, + ) catch { + _ => abort("example celda_CG analysis should succeed") + } +} + +///| +fn celda_test_sce() -> @src.SingleCellExperiment { + let (counts, features, cells, samples) = @src.celda_cg_example_data() + let sce = @src.SingleCellExperiment::new(counts, features, cells) + sce.col_data["donor"] = samples + sce.metadata["source"] = "celda_test" + sce +} + +///| +test "celda_CG: default configuration preserves upstream hyperparameters" { + let config = @src.CeldaCGConfig::create(3, 4) catch { + _ => abort("default configuration should build") + } + assert_eq(config.cell_populations, 3) + assert_eq(config.feature_modules, 4) + assert_eq(config.alpha, 1.0) + assert_eq(config.beta, 1.0) + assert_eq(config.delta, 1.0) + assert_eq(config.gamma, 1.0) + assert_eq(config.algorithm, @src.CeldaEm) + assert_eq(config.max_iterations, 200) + assert_eq(config.stop_iterations, 10) + assert_eq(config.chains, 3) + assert_eq(config.tolerance, 1.0e-8) + assert_eq(config.seed, 12345) +} + +///| +test "celda_CG: custom configuration preserves every option" { + let config = @src.CeldaCGConfig::create( + 2, + 3, + alpha=0.5, + beta=0.25, + delta=0.75, + gamma=2.0, + algorithm=@src.CeldaGibbs, + max_iterations=20, + stop_iterations=4, + chains=5, + tolerance=1.0e-6, + seed=99, + ) catch { + _ => abort("custom configuration should build") + } + assert_eq(config.alpha, 0.5) + assert_eq(config.beta, 0.25) + assert_eq(config.delta, 0.75) + assert_eq(config.gamma, 2.0) + assert_eq(config.algorithm, @src.CeldaGibbs) + assert_eq(config.max_iterations, 20) + assert_eq(config.stop_iterations, 4) + assert_eq(config.chains, 5) + assert_eq(config.tolerance, 1.0e-6) + assert_eq(config.seed, 99) +} + +///| +test "celda_CG: with_dimensions retains inference controls" { + let original = celda_test_config() + let updated = original.with_dimensions(2, 5, seed=77) catch { + _ => abort("valid dimensions should build") + } + assert_eq(updated.cell_populations, 2) + assert_eq(updated.feature_modules, 5) + assert_eq(updated.max_iterations, original.max_iterations) + assert_eq(updated.stop_iterations, original.stop_iterations) + assert_eq(updated.chains, original.chains) + assert_eq(updated.seed, 77) +} + +///| +test "celda_CG: configuration rejects non-positive dimensions" { + let bad_k = try { + ignore(@src.CeldaCGConfig::create(0, 2)) + false + } catch { + CeldaError(_) => true + } + let bad_l = try { + ignore(@src.CeldaCGConfig::create(2, 0)) + false + } catch { + CeldaError(_) => true + } + assert_true(bad_k) + assert_true(bad_l) +} + +///| +test "celda_CG: configuration rejects invalid Dirichlet priors" { + let alpha = try { + ignore(@src.CeldaCGConfig::create(2, 2, alpha=0.0)) + false + } catch { + CeldaError(_) => true + } + let beta = try { + ignore(@src.CeldaCGConfig::create(2, 2, beta=-1.0)) + false + } catch { + CeldaError(_) => true + } + let delta = try { + ignore(@src.CeldaCGConfig::create(2, 2, delta=Double::nan())) + false + } catch { + CeldaError(_) => true + } + let gamma = try { + ignore(@src.CeldaCGConfig::create(2, 2, gamma=1.0e301)) + false + } catch { + CeldaError(_) => true + } + assert_true(alpha) + assert_true(beta) + assert_true(delta) + assert_true(gamma) +} + +///| +test "celda_CG: configuration rejects invalid iteration limits" { + let maximum = try { + ignore(@src.CeldaCGConfig::create(2, 2, max_iterations=0)) + false + } catch { + CeldaError(_) => true + } + let stopping = try { + ignore(@src.CeldaCGConfig::create(2, 2, stop_iterations=0)) + false + } catch { + CeldaError(_) => true + } + assert_true(maximum) + assert_true(stopping) +} + +///| +test "celda_CG: configuration rejects invalid chains and tolerance" { + let chains = try { + ignore(@src.CeldaCGConfig::create(2, 2, chains=0)) + false + } catch { + CeldaError(_) => true + } + let tolerance = try { + ignore(@src.CeldaCGConfig::create(2, 2, tolerance=0.0)) + false + } catch { + CeldaError(_) => true + } + assert_true(chains) + assert_true(tolerance) +} + +///| +test "celda_CG: configuration rejects non-positive random seeds" { + let rejected = try { + ignore(@src.CeldaCGConfig::create(2, 2, seed=0)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: example data uses feature by cell orientation" { + let (counts, features, cells, samples) = @src.celda_cg_example_data() + assert_eq(counts.length(), 12) + assert_eq(counts[0].length(), 12) + assert_eq(features.length(), 12) + assert_eq(cells.length(), 12) + assert_eq(samples.length(), 12) + assert_eq(features[0], "T_marker_1") + assert_eq(cells[8], "M1") +} + +///| +test "celda_CG: fit rejects an empty count matrix" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore(@src.celda_cg_fit([], [], config)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: fit rejects a matrix without cells" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore(@src.celda_cg_fit([[]], [], config)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: fit rejects a non-rectangular matrix" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore(@src.celda_cg_fit([[1.0, 2.0], [3.0]], [], config)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: fit rejects negative counts" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore(@src.celda_cg_fit([[1.0, -1.0]], [], config)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: fit rejects fractional counts" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore(@src.celda_cg_fit([[1.0, 1.5]], [], config)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: fit rejects NaN counts" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore(@src.celda_cg_fit([[1.0, Double::nan()]], [], config)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: fit rejects effectively infinite counts" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore(@src.celda_cg_fit([[1.0, 1.0e301]], [], config)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: fit rejects all-zero features" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore(@src.celda_cg_fit([[1.0, 2.0], [0.0, 0.0]], [], config)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: fit rejects all-zero cells" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore(@src.celda_cg_fit([[1.0, 0.0], [2.0, 0.0]], [], config)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: fit rejects more populations than cells" { + let config = @src.CeldaCGConfig::create(3, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore(@src.celda_cg_fit([[1.0, 2.0]], [], config)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: fit rejects more modules than features" { + let config = @src.CeldaCGConfig::create(1, 2) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore(@src.celda_cg_fit([[1.0, 2.0]], [], config)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: sample labels must match the number of cells" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore(@src.celda_cg_fit([[1.0, 2.0]], ["S1"], config)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: sample labels cannot be blank" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore(@src.celda_cg_fit([[1.0, 2.0]], ["S1", " "], config)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: sample order follows first appearance" { + let config = @src.CeldaCGConfig::create( + 1, + 1, + max_iterations=1, + stop_iterations=1, + chains=1, + ) catch { + _ => abort("configuration should build") + } + let result = @src.celda_cg_fit([[2.0, 3.0, 4.0]], ["B", "A", "B"], config) catch { + _ => abort("valid sample labels should fit") + } + assert_eq(result.sample_names, ["B", "A"]) + assert_eq(result.sample_indices, [0, 1, 0]) +} + +///| +test "celda_CG: omitted identifiers are generated deterministically" { + let config = @src.CeldaCGConfig::create( + 1, + 1, + max_iterations=1, + stop_iterations=1, + chains=1, + ) catch { + _ => abort("configuration should build") + } + let result = @src.celda_cg_fit([[2.0, 3.0], [3.0, 2.0]], [], config) catch { + _ => abort("generated names should be accepted") + } + assert_eq(result.feature_names, ["Feature1", "Feature2"]) + assert_eq(result.cell_names, ["Cell1", "Cell2"]) + assert_eq(result.sample_names, ["Sample1"]) +} + +///| +test "celda_CG: feature identifiers must match the matrix" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore( + @src.celda_cg_fit([[1.0, 2.0], [2.0, 1.0]], [], config, feature_names=[ + "G1", + ]), + ) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: cell identifiers must match the matrix" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore( + @src.celda_cg_fit([[1.0, 2.0], [2.0, 1.0]], [], config, cell_names=["C1"]), + ) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: identifiers cannot be blank" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore( + @src.celda_cg_fit([[1.0, 2.0], [2.0, 1.0]], [], config, feature_names=[ + "G1", " ", + ]), + ) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: identifiers must be unique after trimming" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore( + @src.celda_cg_fit([[1.0, 2.0], [2.0, 1.0]], [], config, feature_names=[ + "G1", " G1 ", + ]), + ) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: predefined cell labels must match and use all populations" { + let config = @src.CeldaCGConfig::create(2, 1) catch { + _ => abort("configuration should build") + } + let wrong_length = try { + ignore( + @src.celda_cg_fit([[2.0, 3.0, 4.0]], [], config, initial_cell_clusters=[ + 0, 1, + ]), + ) + false + } catch { + CeldaError(_) => true + } + let missing = try { + ignore( + @src.celda_cg_fit([[2.0, 3.0, 4.0]], [], config, initial_cell_clusters=[ + 0, 0, 0, + ]), + ) + false + } catch { + CeldaError(_) => true + } + assert_true(wrong_length) + assert_true(missing) +} + +///| +test "celda_CG: predefined cell labels reject out-of-range values" { + let config = @src.CeldaCGConfig::create(2, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore( + @src.celda_cg_fit([[2.0, 3.0, 4.0]], [], config, initial_cell_clusters=[ + 0, 1, 2, + ]), + ) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: predefined feature labels must match and use all modules" { + let config = @src.CeldaCGConfig::create(1, 2) catch { + _ => abort("configuration should build") + } + let wrong_length = try { + ignore( + @src.celda_cg_fit([[2.0, 3.0], [3.0, 2.0], [1.0, 1.0]], [], config, initial_feature_modules=[ + 0, 1, + ]), + ) + false + } catch { + CeldaError(_) => true + } + let missing = try { + ignore( + @src.celda_cg_fit([[2.0, 3.0], [3.0, 2.0], [1.0, 1.0]], [], config, initial_feature_modules=[ + 0, 0, 0, + ]), + ) + false + } catch { + CeldaError(_) => true + } + assert_true(wrong_length) + assert_true(missing) +} + +///| +test "celda_CG: predefined feature labels reject out-of-range values" { + let config = @src.CeldaCGConfig::create(1, 2) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore( + @src.celda_cg_fit([[2.0, 3.0], [3.0, 2.0], [1.0, 1.0]], [], config, initial_feature_modules=[ + 0, 1, -1, + ]), + ) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: one-population one-module likelihood matches closed form" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let value = @src.celda_cg_log_likelihood( + [[2.0, 1.0], [1.0, 2.0]], + [], + [0, 0], + [0, 0], + config, + ) catch { + _ => abort("valid labels should produce a likelihood") + } + celda_test_close(value, -6.327936783729195, 1.0e-9) +} + +///| +test "celda_CG: omitted and explicit default samples have equal likelihood" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let counts = [[2.0, 1.0], [1.0, 2.0]] + let implicit = @src.celda_cg_log_likelihood( + counts, + [], + [0, 0], + [0, 0], + config, + ) catch { + _ => abort("implicit sample should work") + } + let explicit = @src.celda_cg_log_likelihood( + counts, + ["Sample1", "Sample1"], + [0, 0], + [0, 0], + config, + ) catch { + _ => abort("explicit sample should work") + } + celda_test_close(implicit, explicit, 1.0e-12) +} + +///| +test "celda_CG: likelihood validates assignment occupancy" { + let config = @src.CeldaCGConfig::create(2, 2) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore( + @src.celda_cg_log_likelihood( + [[2.0, 1.0], [1.0, 2.0]], + [], + [0, 0], + [0, 1], + config, + ), + ) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: result dimensions match the example matrix" { + let result = celda_test_result() + assert_eq(result.n_features(), 12) + assert_eq(result.n_cells(), 12) + assert_eq(result.n_samples(), 2) + assert_eq(result.cell_clusters.length(), 12) + assert_eq(result.feature_modules.length(), 12) +} + +///| +test "celda_CG: model selection metrics are finite" { + let result = celda_test_result() + assert_true(result.log_likelihood == result.log_likelihood) + assert_true(result.log_likelihood.abs() < 1.0e300) + assert_true(result.perplexity > 1.0) + assert_true(result.perplexity < 1.0e300) + assert_true(result.aic > 0.0) + assert_true(result.bic > 0.0) +} + +///| +test "celda_CG: diagnostics record bounded optimization work" { + let result = celda_test_result() + assert_true(result.diagnostics.iterations >= 1) + assert_true(result.diagnostics.iterations <= result.config.max_iterations) + assert_eq( + result.diagnostics.log_likelihoods.length(), + result.diagnostics.iterations + 1, + ) + assert_true(result.diagnostics.best_chain >= 0) + assert_true(result.diagnostics.best_chain < result.config.chains) +} + +///| +test "celda_CG: diagnostics include one finite score per chain" { + let result = celda_test_result() + assert_eq(result.diagnostics.chain_scores.length(), result.config.chains) + for score in result.diagnostics.chain_scores { + assert_true(score == score) + assert_true(score.abs() < 1.0e300) + } +} + +///| +test "celda_CG: hard EM is reproducible for a fixed seed" { + let (counts, features, cells, samples) = @src.celda_cg_example_data() + let first = @src.celda_cg_fit( + counts, + samples, + celda_test_config(), + feature_names=features, + cell_names=cells, + ) catch { + _ => abort("first fit should succeed") + } + let second = @src.celda_cg_fit( + counts, + samples, + celda_test_config(), + feature_names=features, + cell_names=cells, + ) catch { + _ => abort("second fit should succeed") + } + assert_eq(first.cell_clusters, second.cell_clusters) + assert_eq(first.feature_modules, second.feature_modules) + assert_eq(first.log_likelihood, second.log_likelihood) +} + +///| +test "celda_CG: seeded Gibbs inference is reproducible" { + let (counts, features, cells, samples) = @src.celda_cg_example_data() + let config = @src.CeldaCGConfig::create( + 3, + 4, + algorithm=@src.CeldaGibbs, + max_iterations=6, + stop_iterations=3, + chains=2, + seed=456, + ) catch { + _ => abort("Gibbs configuration should build") + } + let first = @src.celda_cg_fit( + counts, + samples, + config, + feature_names=features, + cell_names=cells, + ) catch { + _ => abort("first Gibbs fit should succeed") + } + let second = @src.celda_cg_fit( + counts, + samples, + config, + feature_names=features, + cell_names=cells, + ) catch { + _ => abort("second Gibbs fit should succeed") + } + assert_eq(first.cell_clusters, second.cell_clusters) + assert_eq(first.feature_modules, second.feature_modules) + assert_eq(first.log_likelihood, second.log_likelihood) +} + +///| +test "celda_CG: every inferred population remains occupied" { + let result = celda_test_result() + let sizes = result.population_sizes() + assert_eq(sizes.length(), 3) + for size in sizes { + assert_true(size > 0) + } + assert_eq(celda_test_sum(sizes.map(fn(value) { value.to_double() })), 12.0) +} + +///| +test "celda_CG: every inferred feature module remains occupied" { + let result = celda_test_result() + let sizes = result.module_sizes() + assert_eq(sizes.length(), 4) + let mut total = 0 + for size in sizes { + assert_true(size > 0) + total = total + size + } + assert_eq(total, 12) +} + +///| +test "celda_CG: example cell types form three distinct populations" { + let result = celda_test_result() + for index in 1..<4 { + assert_eq(result.cell_clusters[index], result.cell_clusters[0]) + } + for index in 5..<8 { + assert_eq(result.cell_clusters[index], result.cell_clusters[4]) + } + for index in 9..<12 { + assert_eq(result.cell_clusters[index], result.cell_clusters[8]) + } + assert_true(result.cell_clusters[0] != result.cell_clusters[4]) + assert_true(result.cell_clusters[0] != result.cell_clusters[8]) + assert_true(result.cell_clusters[4] != result.cell_clusters[8]) +} + +///| +test "celda_CG: example marker families form distinct modules" { + let result = celda_test_result() + assert_eq(result.feature_modules[0], result.feature_modules[1]) + assert_eq(result.feature_modules[1], result.feature_modules[2]) + assert_eq(result.feature_modules[3], result.feature_modules[4]) + assert_eq(result.feature_modules[4], result.feature_modules[5]) + assert_eq(result.feature_modules[6], result.feature_modules[7]) + assert_eq(result.feature_modules[7], result.feature_modules[8]) + assert_eq(result.feature_modules[9], result.feature_modules[10]) + assert_eq(result.feature_modules[10], result.feature_modules[11]) +} + +///| +test "celda_CG: theta is population by sample and column-normalized" { + let result = celda_test_result() + assert_eq(result.theta.length(), 3) + assert_eq(result.theta[0].length(), 2) + for sample in 0.. 0.0) + } else { + assert_eq(result.psi[feature][module_], 0.0) + } + } + } +} + +///| +test "celda_CG: psi reserves pseudogene probability in every module" { + let result = celda_test_result() + for module_ in 0.. 0.0) + assert_true(total < 1.0) + } +} + +///| +test "celda_CG: eta is a normalized feature-module abundance" { + let result = celda_test_result() + assert_eq(result.eta.length(), 4) + for probability in result.eta { + assert_true(probability > 0.0) + } + celda_test_close(celda_test_sum(result.eta), 1.0, 1.0e-12) +} + +///| +test "celda_CG: fitted counts match source dimensions" { + let result = celda_test_result() + assert_eq(result.fitted_counts.length(), 12) + assert_eq(result.fitted_counts[0].length(), 12) + for row in result.fitted_counts { + for value in row { + assert_true(value >= 0.0) + assert_true(value.abs() < 1.0e300) + } + } +} + +///| +test "celda_CG: fitted counts preserve every cell library size" { + let result = celda_test_result() + for cell in 0.. true + } + let module_ = try { + ignore(result.features_in_module(-1)) + false + } catch { + CeldaError(_) => true + } + assert_true(population) + assert_true(module_) +} + +///| +test "celda_CG: top features are sorted by posterior probability" { + let result = celda_test_result() + let module_ = result.feature_modules[0] + let scores = result.top_features(module_, limit=3) catch { + _ => abort("valid module should have top features") + } + assert_true(scores.length() >= 1) + for index in 1..= scores[index].probability) + } + for score in scores { + assert_eq(result.feature_modules[score.feature_index], module_) + assert_eq(result.feature_names[score.feature_index], score.feature_name) + } +} + +///| +test "celda_CG: top feature query validates module and limit" { + let result = celda_test_result() + let module_ = try { + ignore(result.top_features(4)) + false + } catch { + CeldaError(_) => true + } + let limit = try { + ignore(result.top_features(0, limit=0)) + false + } catch { + CeldaError(_) => true + } + assert_true(module_) + assert_true(limit) +} + +///| +test "celda_CG: summary reports dimensions and model family" { + let summary = celda_test_result().summary() + assert_true(summary.contains("celda_CG")) + assert_true(summary.contains("12 features x 12 cells")) + assert_true(summary.contains("K=3")) + assert_true(summary.contains("L=4")) +} + +///| +test "celda_CG: prediction returns cell by population probabilities" { + let (counts, _, _, _) = @src.celda_cg_example_data() + let result = celda_test_result() + let prediction = @src.celda_cg_predict_cells(result, counts) catch { + _ => abort("training matrix should be predictable") + } + assert_eq(prediction.probabilities.length(), 12) + assert_eq(prediction.probabilities[0].length(), 3) + assert_eq(prediction.assignments.length(), 12) +} + +///| +test "celda_CG: prediction probabilities are normalized" { + let (counts, _, _, _) = @src.celda_cg_example_data() + let prediction = @src.celda_cg_predict_cells(celda_test_result(), counts) catch { + _ => abort("training matrix should be predictable") + } + for probabilities in prediction.probabilities { + celda_test_close(celda_test_sum(probabilities), 1.0, 1.0e-12) + for probability in probabilities { + assert_true(probability >= 0.0) + assert_true(probability <= 1.0) + } + } +} + +///| +test "celda_CG: training cells predict their inferred populations" { + let (counts, _, _, _) = @src.celda_cg_example_data() + let result = celda_test_result() + let prediction = @src.celda_cg_predict_cells(result, counts) catch { + _ => abort("training matrix should be predictable") + } + assert_eq(prediction.assignments, result.cell_clusters) +} + +///| +test "celda_CG: prediction rejects a mismatched feature space" { + let rejected = try { + ignore( + @src.celda_cg_predict_cells(celda_test_result(), [[1.0, 2.0], [2.0, 1.0]]), + ) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: grid search evaluates the Cartesian K by L grid" { + let (counts, features, cells, samples) = @src.celda_cg_example_data() + let base = @src.CeldaCGConfig::create( + 1, + 1, + max_iterations=5, + stop_iterations=2, + chains=1, + seed=41, + ) catch { + _ => abort("base grid configuration should build") + } + let grid = @src.celda_cg_grid_search( + counts, + samples, + [2, 3], + [3, 4], + base, + feature_names=features, + cell_names=cells, + ) catch { + _ => abort("valid grid should fit") + } + assert_eq(grid.entries.length(), 4) + assert_true(grid.best_index >= 0) + assert_true(grid.best_index < 4) + assert_eq(grid.criterion, @src.CeldaBic) +} + +///| +test "celda_CG: grid best_result matches the selected entry" { + let (counts, _, _, samples) = @src.celda_cg_example_data() + let base = @src.CeldaCGConfig::create( + 1, + 1, + max_iterations=3, + stop_iterations=1, + chains=1, + ) catch { + _ => abort("base grid configuration should build") + } + let grid = @src.celda_cg_grid_search( + counts, + samples, + [2, 3], + [4], + base, + criterion=@src.CeldaLogLikelihood, + ) catch { + _ => abort("valid likelihood grid should fit") + } + let best = grid.best_result() + assert_eq(best.log_likelihood, grid.entries[grid.best_index].score) +} + +///| +test "celda_CG: grid search rejects empty dimensions" { + let (counts, _, _, samples) = @src.celda_cg_example_data() + let base = celda_test_config() + let rejected = try { + ignore(@src.celda_cg_grid_search(counts, samples, [], [2], base)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: grid search rejects duplicate K-L combinations" { + let (counts, _, _, samples) = @src.celda_cg_example_data() + let base = celda_test_config() + let rejected = try { + ignore(@src.celda_cg_grid_search(counts, samples, [2, 2], [3], base)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: SCE integration adds fitted assay and assignments" { + let output = @src.celda_cg_sce( + celda_test_sce(), + celda_test_config(), + sample_column="donor", + ) catch { + _ => abort("valid SCE integration should succeed") + } + assert_eq(@src.sce_get_assay(output.experiment, "celda_fitted").length(), 12) + assert_eq( + @src.sce_get_row_data(output.experiment, "celda_feature_module").length(), + 12, + ) + assert_eq( + @src.sce_get_col_data(output.experiment, "celda_cell_population").length(), + 12, + ) +} + +///| +test "celda_CG: SCE integration writes sample and model metadata" { + let output = @src.celda_cg_sce( + celda_test_sce(), + celda_test_config(), + sample_column="donor", + ) catch { + _ => abort("valid SCE integration should succeed") + } + assert_eq(@src.sce_get_col_data(output.experiment, "celda_sample_label"), [ + "Donor1", "Donor1", "Donor2", "Donor2", "Donor1", "Donor1", "Donor2", "Donor2", + "Donor1", "Donor1", "Donor2", "Donor2", + ]) + assert_eq(output.experiment.metadata["celda_model"], "celda_CG") + assert_eq(output.experiment.metadata["celda_K"], "3") + assert_eq(output.experiment.metadata["celda_L"], "4") + assert_eq(output.experiment.metadata["source"], "celda_test") +} + +///| +test "celda_CG: SCE integration does not mutate the source object" { + let source = celda_test_sce() + ignore( + @src.celda_cg_sce(source, celda_test_config(), sample_column="donor") catch { + _ => abort("valid SCE integration should succeed") + }, + ) + assert_eq(@src.sce_get_assay(source, "celda_fitted").length(), 0) + assert_eq(@src.sce_get_row_data(source, "celda_feature_module").length(), 0) + assert_eq(@src.sce_get_col_data(source, "celda_cell_population").length(), 0) +} + +///| +test "celda_CG: SCE integration supports custom assay names" { + let output = @src.celda_cg_sce( + celda_test_sce(), + celda_test_config(), + sample_column="donor", + fitted_assay="celda_reconstructed", + ) catch { + _ => abort("custom fitted assay should work") + } + assert_eq( + @src.sce_get_assay(output.experiment, "celda_reconstructed").length(), + 12, + ) + assert_eq(@src.sce_get_assay(output.experiment, "celda_fitted").length(), 0) +} + +///| +test "celda_CG: SCE integration validates the input assay" { + let source = @src.SCEBuilder::new() + |> @src.SCEBuilder::add_assay("other", [[1.0, 2.0], [2.0, 1.0]]) + |> @src.SCEBuilder::build + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore(@src.celda_cg_sce(source, config)) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} + +///| +test "celda_CG: SCE integration validates sample column metadata" { + let config = @src.CeldaCGConfig::create(1, 1) catch { + _ => abort("configuration should build") + } + let rejected = try { + ignore(@src.celda_cg_sce(celda_test_sce(), config, sample_column="missing")) + false + } catch { + CeldaError(_) => true + } + assert_true(rejected) +} From 464e4ec424bdc25d3da2276115357aed7693b497 Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 20:11:38 +0800 Subject: [PATCH 32/41] #28 pass: 10046 feat: Bio.Align.a2m & Bio.Align.emboss EMBOSS & Bio.Align.exonerate Exonerate cigar/vulgar --- README.md | 62 +- examples/a2m_demo/main.mbt | 77 + examples/a2m_demo/moon.pkg | 5 + examples/align_emboss_demo/main.mbt | 130 ++ examples/align_emboss_demo/moon.pkg | 5 + examples/align_exonerate_demo/main.mbt | 101 ++ examples/align_exonerate_demo/moon.pkg | 5 + src/a2m.mbt | 930 ++++++++++++ src/align_emboss.mbt | 1792 ++++++++++++++++++++++++ src/align_exonerate.mbt | 1319 +++++++++++++++++ test/moonbit/a2m_test.mbt | 780 +++++++++++ test/moonbit/align_emboss_test.mbt | 935 +++++++++++++ test/moonbit/align_exonerate_test.mbt | 933 ++++++++++++ 13 files changed, 7070 insertions(+), 4 deletions(-) create mode 100644 examples/a2m_demo/main.mbt create mode 100644 examples/a2m_demo/moon.pkg create mode 100644 examples/align_emboss_demo/main.mbt create mode 100644 examples/align_emboss_demo/moon.pkg create mode 100644 examples/align_exonerate_demo/main.mbt create mode 100644 examples/align_exonerate_demo/moon.pkg create mode 100644 src/a2m.mbt create mode 100644 src/align_emboss.mbt create mode 100644 src/align_exonerate.mbt create mode 100644 test/moonbit/a2m_test.mbt create mode 100644 test/moonbit/align_emboss_test.mbt create mode 100644 test/moonbit/align_exonerate_test.mbt diff --git a/README.md b/README.md index c9f16383..dd4a3644 100644 --- a/README.md +++ b/README.md @@ -36,6 +36,9 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **Alignment详细统计** | Biopython `Bio.Align.Alignment.counts` | 左/内部/右 insertion/deletion、gap open/extend、identity/mismatch/positive、wildcard、替换矩阵和十二类affine gap评分 | ✅ | | **PSL/PSLX成对比对** | Biopython `Bio.Align.psl` | 21/23列严格读写、核酸与translated DNA-protein路径、正反链坐标、block/gap统计、sequence-aware recount及坐标映射 | ✅ | | **Alignment-aware SAM** | Biopython `Bio.Align.sam` | SAM header与typed tag严格读写、CIGAR坐标路径、正反链、soft/hard clipping、PHRED、MD/NM及坐标映射 | ✅ | +| **A2M状态感知多序列比对** | Biopython `Bio.Align.a2m` | match/insertion列状态、大小写与点语义、严格读写、坐标映射、插入槽、统计、共识及match-only投影 | ✅ | +| **EMBOSS alignment输出** | Biopython `Bio.Align.emboss` | srspair/pair/simple报告、多alignment与多序列、局部/反向坐标、consensus统计、坐标路径及规范往返 | ✅ | +| **Exonerate alignment输出** | Biopython `Bio.Align.exonerate` | cigar/vulgar严格读写、完整operation path、正反链与protein strand、3:1 translated坐标、双向映射及规范往返 | ✅ | | **系统发育树** | Biopython `Bio.Phylo` | 树结构、Newick 解析、距离计算、可视化 | ✅ | | **PDB 结构** | Biopython `Bio.PDB` | 原子/残基/链解析、结构操作 | ✅ | | **BinaryCIF** | Biopython `Bio.PDB.binary_cif` | MessagePack解析、七类逆编码、三态缺失值、类别查询、PDB Structure转换 | ✅ | @@ -166,6 +169,9 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | Bio.Align.Alignment counts | pairwise/MSA详细gap分类、open/extend事件、identity/mismatch/positive、wildcard、替换矩阵与完整affine总分 | | ✅ | Bio.Align.psl | alignment-aware PSL/PSLX 21/23列严格解析与写出、核酸和translated 3:1路径、双轴链向、match/repeat/N recount、block序列及坐标互映 | | ✅ | Bio.Align.sam | alignment-aware SAM header/record严格读写、显式CIGAR path、反向链序列与PHRED语义、typed tags、MD/NM和双向坐标映射 | +| ✅ | Bio.Align.a2m | A2M match/insertion状态推导、大小写与点gap规范读写、插入槽、逐行坐标映射、pair counts、共识和match projection | +| ✅ | Bio.Align.emboss | EMBOSS srspair/pair/simple文件元数据与多alignment解析、任意序列数、纯gap block、局部/反向坐标、consensus统计、compact path和规范写回 | +| ✅ | Bio.Align.exonerate | Exonerate cigar/vulgar文件元数据与严格读写、完整M/5/I/3/C/G/N/S/F操作、正反链/protein strand、3:1 translated path、坐标互映和统计 | | ✅ | Bio.Align.bigbed | BigBed v4二进制读写、BED3-BED12、AutoSQL扩展字段、多级chromosome B+ tree与R-tree、zlib/DEFLATE解码、区间/名称查询和BED导出 | | ✅ | Bio.Align.bigmaf | 标准bedMaf bed3+1读写、完整MAF a/s/i/e/q语义、正负链坐标映射、BigBed压缩索引查询、MAF导出和严格损坏数据诊断 | | ✅ | Bioconductor decontX | 单细胞ambient RNA去污染: cluster-native/contaminant多项式混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解、诊断与SingleCellExperiment接入 | @@ -233,6 +239,9 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **Alignment坐标组合** | Biopython `Bio.Align.Alignment.map/mapall` | alignment path组合、局部overhang clipping、exon/intron与indel gap、正反链组合、坐标双向查询、PSL及1:1/1:3 MSA投影 | ✅ | | **Alignment详细计数与评分** | Biopython `Bio.Align.Alignment.counts` | 十二类affine gap事件、identity/mismatch/positive、wildcard、BLOSUM/PAM评分、反向链和MSA全部序列对汇总 | ✅ | | **SAM坐标比对读写** | Biopython `Bio.Align.sam` | header/reference模型、M/I/D/N/=/X显式路径、反向链与clipping、typed tags、PHRED、MD/NM和严格往返 | ✅ | +| **A2M状态感知比对** | Biopython `Bio.Align.a2m` | D/I列状态、大小写与点gap编码、wrapped/CRLF读写、坐标互映、插入槽、统计、共识与match投影 | ✅ | +| **EMBOSS alignment报告** | Biopython `Bio.Align.emboss` | srspair/pair/simple元数据、固定列block、多alignment/多序列、正反向绝对坐标、pair counts与canonical writer | ✅ | +| **Exonerate alignment报告** | Biopython `Bio.Align.exonerate` | header/footer与cigar/vulgar、operation normalization、链感知绝对路径、protein-DNA 3:1映射、统计与canonical writer | ✅ | | **BigBed二进制区间索引** | Biopython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12与AutoSQL、多级B+ tree/R-tree、stored/fixed/dynamic DEFLATE、区间/名称查询、链感知exon坐标及BED导出 | ✅ | | **BigMaf多物种比对索引** | Biopython `Bio.Align.bigmaf` | 标准bedMaf AutoSQL、MAF a/s/i/e/q块、score/pass/comment、正负链坐标映射、压缩BigBed索引查询及普通MAF导出 | ✅ | | **BigPsl成对比对索引** | Biopython `Bio.Align.bigpsl` | 标准bed12+13 AutoSQL、核酸与translated protein坐标路径、正反链、match/repeat/N recount、压缩索引查询及PSL导出 | ✅ | @@ -385,6 +394,9 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **Alignment-aware tabular搜索结果** | Biopython `Bio.Align.tabular` | BLAST outfmt 7、FASTA 8CB/8CC、BTOP/aln_code路径、链向及translated坐标 | ✅ | | **Alignment-aware PSL/PSLX** | Biopython `Bio.Align.psl` | 21/23列格式、header、block/gap一致性、正反链、translated 3:1坐标、序列重计数与严格诊断 | ✅ | | **Alignment-aware SAM** | Biopython `Bio.Align.sam` | SAM 1.6 header/record、typed optional tags、CIGAR path、clipping、反向链、PHRED、MD/NM与规范写回 | ✅ | +| **A2M状态感知MSA** | Biopython `Bio.Align.a2m` | match/deletion与insertion列、canonical大小写/点编码、严格往返、坐标映射、插入槽、统计与共识 | ✅ | +| **EMBOSS alignment output** | Biopython `Bio.Align.emboss` | water/needle/stretcher/matcher/alignret输出、srspair/pair/simple、metadata、consensus、局部/反向坐标与严格诊断 | ✅ | +| **Exonerate alignment output** | Biopython `Bio.Align.exonerate` | cigar/vulgar报告、M/5/I/3/C/G/N/S/F路径、正反链与protein strand、translated coordinates、严格诊断与双格式写回 | ✅ | | **UCSC Chain文件/liftOver** | Bioconductor rtracklayer | Chain格式解析、基因组坐标liftOver转换、链段查找、染色体间坐标映射、位置/区间转换 | ✅ | | **Biostrings matchPDict** | Bioconductor Biostrings | 字典模式匹配(matchPDict/vmatchPattern)、多序列模式计数(vcountPattern)、错配容忍、最佳匹配查找 | ✅ | | **GenomicRanges gaps/reduce/disjoin** | Bioconductor GenomicRanges | gaps检测、reduce合并、disjoin拆分、setdiff/交集/并集集合运算、coverage计算、promoters提取、trim | ✅ | @@ -446,6 +458,9 @@ IvanAXu/BioSeqs/ │ ├── align_tabular.mbt # Bio.Align.tabular BLAST/FASTA traceback表格解析与坐标路径 │ ├── align_psl.mbt # Bio.Align.psl PSL/PSLX严格读写、链向路径、统计与坐标映射 │ ├── align_sam.mbt # Bio.Align.sam严格读写、CIGAR路径、typed tags、MD/NM与反向链 +│ ├── a2m.mbt # Bio.Align.a2m状态感知MSA读写、坐标、插入槽、统计与投影 +│ ├── align_emboss.mbt # Bio.Align.emboss srspair/pair/simple解析、坐标、统计与规范写回 +│ ├── align_exonerate.mbt # Bio.Align.exonerate cigar/vulgar路径、链向、translated映射与规范写回 │ ├── bigbed.mbt # Bio.Align.bigbed v4、BED/AutoSQL、多级B+ tree/R-tree与DEFLATE │ ├── bigmaf.mbt # Bio.Align.bigmaf bedMaf、MAF注释、链向坐标映射与索引查询 │ ├── bigpsl.mbt # Bio.Align.bigpsl bed12+13、核酸/translated protein路径与PSL @@ -1153,6 +1168,9 @@ IvanAXu/BioSeqs/ │ ├── align_tabular_demo/ # BLAST BTOP、FASTA aln_code与translated反链坐标解析示例 │ ├── align_psl_demo/ # PSL/PSLX读写、反链映射、translated recount与文档摘要示例 │ ├── align_sam_demo/ # SAM header/path、反链、splicing、typed tags、MD/NM与往返示例 +│ ├── a2m_demo/ # A2M状态解析、插入槽、共识、坐标、统计、投影与往返示例 +│ ├── align_emboss_demo/ # EMBOSS元数据、局部/反向坐标、path、统计与wrapped往返示例 +│ ├── align_exonerate_demo/ # Exonerate剪接/translated path、坐标映射、统计与双格式往返示例 │ ├── bigbed_demo/ # BigBed写入/解析、索引查询、负链exon坐标、BED导出与损坏诊断 │ ├── bigmaf_demo/ # BigMaf压缩写入、bedMaf schema、区间查询、负链映射与MAF导出 │ ├── bigpsl_demo/ # BigPsl压缩写入、R-tree查询、反链/translated坐标与PSL导出 @@ -1369,6 +1387,9 @@ IvanAXu/BioSeqs/ │ │ ├── align_tabular_test.mbt │ │ ├── align_psl_test.mbt │ │ ├── align_sam_test.mbt +│ │ ├── a2m_test.mbt +│ │ ├── align_emboss_test.mbt +│ │ ├── align_exonerate_test.mbt │ │ ├── bigbed_test.mbt │ │ ├── bigmaf_test.mbt │ │ ├── bigpsl_test.mbt @@ -1548,7 +1569,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 9808 个测试全部通过 +moon test # ✅ 10046 个测试全部通过 ``` ### 模块对照表 @@ -1599,6 +1620,9 @@ moon test # ✅ 9808 个测试全 | `align_tabular.mbt` | BioPython `Bio.Align.tabular` | BLAST outfmt 7与FASTA 8CB/8CC元数据、BTOP/CIGAR traceback、链向及translated坐标 | | `align_psl.mbt` | BioPython `Bio.Align.psl` | PSL/PSLX header与21/23列严格读写、核酸/translated block路径、正反链、match分类、recount及坐标转换 | | `align_sam.mbt` | BioPython `Bio.Align.sam` | SAM header/reference与record严格读写、typed tags、CIGAR path、反向链、clipping、PHRED、MD/NM及坐标互映 | +| `a2m.mbt` | BioPython `Bio.Align.a2m` | D/I列状态感知A2M读写、大小写/点编码、逐行坐标映射、插入槽、pair counts、共识及match projection | +| `align_emboss.mbt` | BioPython `Bio.Align.emboss` | srspair/pair/simple report解析、文件/比对元数据、多序列block、局部/反向坐标、pair counts、compact path与规范写回 | +| `align_exonerate.mbt` | BioPython `Bio.Align.exonerate` | alignment-aware cigar/vulgar严格读写、完整operation path、链向与protein strand、translated mapping、统计和规范写回 | | `bigbed.mbt` | BioPython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12、AutoSQL、多级chromosome B+ tree/R-tree、zlib/DEFLATE及索引查询 | | `bigmaf.mbt` | BioPython `Bio.Align.bigmaf` | bedMaf bed3+1读写、MAF a/s/i/e/q、正负链坐标映射、压缩索引查询、摘要和MAF导出 | | `bigpsl.mbt` | BioPython `Bio.Align.bigpsl` | bed12+13读写、核酸/translated protein路径、双向坐标映射、recount、压缩查询、摘要和PSL导出 | @@ -1884,6 +1908,9 @@ moon test # ✅ 9808 个测试全 | `align_tabular.mbt` | `Bio.Align.tabular` | BLAST/FASTA query block、完整字段词汇、BTOP/aln_code路径、translated轴换算、过滤与coordinate alignment转换 | | `align_psl.mbt` | `Bio.Align.psl` | PSL/PSLX类型模型、严格字段与block一致性、核酸反向query、translated反向target、3:1 codon映射、序列重计数与往返 | | `align_sam.mbt` | `Bio.Align.sam` | header/reference与alignment类型模型、CIGAR路径、反向链与clipping、typed tags、PHRED、MD/NM、规范读写和坐标查询 | +| `a2m.mbt` | `Bio.Align.a2m` | match/insertion状态模型、canonical字符编码、wrapped/CRLF解析、行/列坐标互映、插入槽、统计、共识、切片和match-only投影 | +| `align_emboss.mbt` | `Bio.Align.emboss` | EMBOSS文件与alignment类型模型、固定21列body、多alignment/多序列、纯gap block、链感知绝对坐标、consensus统计和canonical writer | +| `align_exonerate.mbt` | `Bio.Align.exonerate` | Exonerate document/alignment/operation模型、cigar/vulgar、正反链/protein坐标、3:1 translated mapping、双向查询、统计和canonical writer | | `bigbed.mbt` | `Bio.Align.bigbed` | BigBed v4二进制读写、BED/AutoSQL、平衡B+ tree/R-tree、完整DEFLATE块解码、区间/名称查询与BED导出 | | `bigmaf.mbt` | `Bio.Align.bigmaf` | bedMaf AutoSQL与MAF块往返、a/s/i/e/q注释、链感知坐标映射、BigBed索引查询和普通MAF导出 | | `bigpsl.mbt` | `Bio.Align.bigpsl` | 标准bigPsl AutoSQL、核酸与translated DNA-protein坐标、链感知映射、match分类、BigBed索引和PSL导出 | @@ -3101,6 +3128,24 @@ optional tags 保留 `A/i/f/Z/H/B:c/C/s/S/i/I/f` 的类型和数组 subtype， `celda_cg_sce` 从指定 assay 和可选 sample `colData` 读取输入，在不可变 `SingleCellExperiment` 副本中写入 fitted assay、1-based population/module 标签及模型诊断 metadata。所有入口校验矩阵方向、矩形性、有限非负整数、名称唯一性、sample/初始标签完整性和超参数边界。当前实现采用 dense MoonBit arrays 和单线程完整 collapsed likelihood 重算，面向中小型矩阵及可验证工作流，不等同于上游 C++/OpenMP 大规模性能后端。 +### 267. A2M 状态感知多序列比对 (Biopython Bio.Align.a2m) + +实现 Biopython 1.86 `Bio.Align.a2m` 的单 MSA 严格读写。解析器由首行逐列推导 `D`（match/deletion）或 `I`（insertion）状态，验证后续行在同列使用相同字符类别；内部将残基统一为大写、`.`/`-` 统一为 gap，同时独立保留状态，因此写回时可准确恢复 match 列大写/连字符和 insertion 列小写/点。支持 wrapped sequence、空行、CRLF、header 描述和 canonical line wrapping，并对空记录、非等宽行、非法字符、状态错位及非法构造参数给出类型化错误。 + +`A2mAlignment` 提供 sequence position、alignment column 与跨行 residue 的 0-based 映射，gap 返回 `None`；连续 insertion-state 列按 reference-boundary slot 汇总。分析 API 覆盖逐列坐标对、identity/mismatch/gap/double-gap、match/insertion aligned counts、占用率、阈值共识、列切片和 match-only 投影。独立状态模型避免传统 `MultipleSeqAlignment` 归一化后丢失 A2M 的模型列语义。 + +### 268. EMBOSS alignment 输出解析与坐标模型 (Biopython Bio.Align.emboss) + +实现 Biopython 1.86 `Bio.Align.emboss` 的 alignment-aware parser，读取 water、needle、stretcher、matcher、alignret 等工具产生的 `srspair`、`pair` 和 `simple` 报告。类型化 document 保留 Program、Rundate、Commandline、Align_format、Report_file；每个 alignment 保留任意数量的序列、matrix、gap/extend penalty、score、Identity/Similarity/Gaps 及 longest/shortest 注释。固定 21 列正文支持截断 identifier、多 block、多 alignment、全空格 consensus 和纯 gap block。 + +EMBOSS 的 1-based inclusive 坐标在内部规范为 0-based boundary/residue 坐标；正向、反向和局部区间均支持 column-to-position、position-to-column、跨行映射、aligned pairs 与 compact coordinate path。pair counts 区分 identity、mismatch、insertion/deletion、double-gap、gap-open 和 consensus positive。严格校验覆盖 header/annotation、数值范围、row顺序、block宽度、坐标连续性、declared Length 和报告统计；额外提供 wrapped canonical writer，以补足上游只读模块并保证严格往返。 + +### 269. Exonerate alignment 输出读写与坐标模型 (Biopython Bio.Align.exonerate) + +实现 Biopython 1.86 `Bio.Align.exonerate` 的 alignment-aware Exonerate 模型，与既有 `exonerate.mbt` 的 `Bio.SearchIO.ExonerateIO` 搜索结果聚合 API 并存。`align_exonerate_parse` 严格读取 `Command line`、`Hostname`、completion marker 和零个或多个 `cigar:`/`vulgar:` alignment；不可变 document、alignment 和 operation 类型保留 query/target identifier、0-based boundary、`+`/`-`/`.` strand、score 及每段双轴步长。 + +vulgar 的 `M/5/I/3/C/G/N/S/F` 操作规范为显式 `M/5/N/3/C/D/I/U/S/F` path，其中双轴 non-equivalenced region 拆成可查询的 target/query movement，并在写回时无损重组。模块支持正向、反向和 protein strand、DNA/protein 3:1 translated CIGAR、绝对 coordinate path、query-target 双向 residue/codon 映射、aligned pairs，以及 match、gap open、intron、non-equivalenced、split codon 和 frame shift 统计。vulgar writer 保留完整操作语义，cigar writer 将特殊操作规范投影为 `M/I/D` 且保持路径；严格诊断覆盖 header/footer、字段与数值、strand方向、operation合法性和 endpoint span。当前模块负责 alignment coordinate semantics，不替代搜索结果层的 `Bio.SearchIO.ExonerateIO`。 + ## 性能优化 ### 优化策略 @@ -3202,8 +3247,8 @@ optional tags 保留 `A/i/f/Z/H/B:c/C/s/S/i/I/f` 的类型和数组 subtype， | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 9808 | -| 通过数 | 9808 | +| 总测试数 | 10046 | +| 通过数 | 10046 | | 失败数 | 0 | | 通过率 | 100% | @@ -3311,6 +3356,9 @@ moon test --update | Bio.Align.tabular | `align_tabular_test.mbt` | 90 | | Bio.Align.psl | `align_psl_test.mbt` | 93 | | Bio.Align.sam | `align_sam_test.mbt` | 94 | +| Bio.Align.a2m | `a2m_test.mbt` | 71 | +| Bio.Align.emboss | `align_emboss_test.mbt` | 81 | +| Bio.Align.exonerate | `align_exonerate_test.mbt` | 86 | | Bio.Align.bigbed | `bigbed_test.mbt` | 64 | | Bio.Align.bigmaf | `bigmaf_test.mbt` | 79 | | SparseArray | `sparse_array_test.mbt` | 41 | @@ -3617,7 +3665,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 374 个示例程序，展示各模块的典型用法： +项目提供 377 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3818,6 +3866,9 @@ moon run cmd/bench/main.mbt | align_tabular_demo | BLAST outfmt 7 BTOP、FASTA 8CC aln_code、最佳命中和TBLASTX反链translated坐标 | `moon run examples/align_tabular_demo` | | align_psl_demo | PSL/PSLX多记录读写、反向query映射、translated target recount、block sequence和摘要 | `moon run examples/align_psl_demo` | | align_sam_demo | SAM header/reference、正反链CIGAR路径、splicing、typed tags、PHRED、MD/NM、aligned rows与规范往返 | `moon run examples/align_sam_demo` | +| a2m_demo | A2M D/I列状态、插入槽、match共识、跨行坐标映射、pair counts、match projection与wrapped往返 | `moon run examples/a2m_demo` | +| align_emboss_demo | EMBOSS srspair元数据、局部/反向坐标、consensus、compact path、pair counts与wrapped规范往返 | `moon run examples/align_emboss_demo` | +| align_exonerate_demo | Exonerate spliced vulgar path、反向protein-to-DNA 3:1映射、operation统计及vulgar/cigar规范往返 | `moon run examples/align_exonerate_demo` | | bigbed_demo | BigBed v4压缩写入/解析、AutoSQL、多级索引查询、负链exon坐标、BED导出及损坏文件诊断 | `moon run examples/bigbed_demo` | | bigmaf_demo | BigMaf压缩bed3+1写入、bedMaf schema、R-tree区间查询、负链物种坐标映射和MAF a/s/i/e/q导出 | `moon run examples/bigmaf_demo` | | bigpsl_demo | BigPsl bed12+13压缩写入、AutoSQL、R-tree查询、反向核酸/translated protein坐标和PSL导出 | `moon run examples/bigpsl_demo` | @@ -3932,6 +3983,9 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bio.Align.tabular alignment-aware搜索结果解析（BLAST outfmt 7、FASTA 8CB/8CC、BTOP/aln_code、正反链与translated坐标、零命中query） - ✅ 实现 Bio.Align.psl alignment-aware PSL/PSLX（21/23列严格读写、核酸/translated路径、双轴链向、block/gap统计、match recount、坐标映射与往返） - ✅ 实现 Bio.Align.sam alignment-aware SAM（header/reference与typed tags、CIGAR坐标路径、正反链与clipping、PHRED、MD/NM、严格校验及规范往返） +- ✅ 实现 Bio.Align.a2m 状态感知多序列比对（D/I列状态、大小写与点gap编码、wrapped/CRLF严格读写、坐标映射、插入槽、统计、共识与match-only投影） +- ✅ 实现 Bio.Align.emboss alignment输出（srspair/pair/simple、多alignment/多序列、局部/反向坐标、纯gap block、consensus统计、compact path与规范往返） +- ✅ 实现 Bio.Align.exonerate alignment输出（cigar/vulgar、完整operation path、正反链/protein strand、3:1 translated坐标、双向映射、统计与规范往返） - ✅ 实现 Bio.Align.bigbed BigBed v4二进制区间格式（BED3-BED12、AutoSQL、多级B+ tree/R-tree、DEFLATE、区间/名称查询与BED导出） - ✅ 实现 Bio.Align.bigmaf BigMaf多物种比对索引（标准bedMaf、MAF a/s/i/e/q、正负链坐标映射、压缩BigBed查询与MAF导出） - ✅ 实现 Bio.Align.bigpsl BigPsl成对比对索引（标准bed12+13、核酸/translated protein坐标、match recount、压缩BigBed查询与PSL导出） diff --git a/examples/a2m_demo/main.mbt b/examples/a2m_demo/main.mbt new file mode 100644 index 00000000..e9e11e35 --- /dev/null +++ b/examples/a2m_demo/main.mbt @@ -0,0 +1,77 @@ +///| +fn main { + println("=== Biopython Bio.Align.a2m Demo ===") + + let alignment = @src.a2m_parse(@src.a2m_example_text()) catch { + _ => abort("failed to parse A2M sample") + } + + println("\n1. State-aware A2M parsing") + println(" " + alignment.summary()) + println(" Column states: " + alignment.states) + println(" Reference sequence: " + alignment.sequences[0].sequence) + + println("\n2. Insertion slots and match consensus") + for insertion in alignment.insertion_runs() { + println( + " Slot " + + insertion.slot.to_string() + + ": columns [" + + insertion.start_column.to_string() + + ", " + + insertion.end_column.to_string() + + "), width " + + insertion.width.to_string(), + ) + } + let consensus = alignment.consensus(include_insertions=false) catch { + _ => abort("failed to calculate A2M consensus") + } + println(" Match-state consensus: " + consensus) + + println("\n3. Coordinate mapping") + match alignment.map_position(0, 1, 5) { + Some(position) => + println( + " Reference residue 5 maps to query_one residue " + + position.to_string() + + " (zero-based)", + ) + None => println(" Reference residue 5 maps to a query_one gap") + } + + println("\n4. Pairwise alignment statistics") + let counts = alignment.pair_counts(0, 1) catch { + _ => abort("failed to calculate A2M pair counts") + } + println( + " Aligned/identity/mismatch: " + + counts.aligned.to_string() + + "/" + + counts.identities.to_string() + + "/" + + counts.mismatches.to_string(), + ) + println(" Identity fraction: " + counts.identity().to_string()) + + println("\n5. Match-only projection") + let projected = alignment.match_projection() catch { + _ => abort("failed to project A2M match columns") + } + println(" " + projected.summary()) + println(" Projected states: " + projected.states) + + println("\n6. Wrapped canonical serialization") + let serialized = @src.a2m_write(alignment, line_width=6) catch { + _ => abort("failed to write A2M alignment") + } + let reparsed = @src.a2m_parse(serialized) catch { + _ => abort("failed to reparse A2M alignment") + } + println(" Serialized bytes: " + serialized.length().to_string()) + println( + " Round trip preserved alignment: " + (alignment == reparsed).to_string(), + ) + + println("\n=== Demo Complete ===") +} diff --git a/examples/a2m_demo/moon.pkg b/examples/a2m_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/a2m_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/examples/align_emboss_demo/main.mbt b/examples/align_emboss_demo/main.mbt new file mode 100644 index 00000000..b69ad51f --- /dev/null +++ b/examples/align_emboss_demo/main.mbt @@ -0,0 +1,130 @@ +///| +fn coordinate_text(values : Array[Int]) -> String { + let output = StringBuilder::new() + output.write_char('[') + for index in 0.. 0 { + output.write_string(", ") + } + output.write_string(values[index].to_string()) + } + output.write_char(']') + output.to_string() +} + +///| +fn main { + println("=== Biopython Bio.Align.emboss Demo ===") + + let document = @src.align_emboss_parse(@src.align_emboss_example_text()) catch { + AlignEmbossError(message) => abort("EMBOSS parsing failed: " + message) + } + let alignment = document.alignments[0] + + println("\n1. Parse report and alignment metadata") + println(" " + document.summary()) + println(" " + alignment.summary()) + println( + " matrix=" + + alignment.annotations.matrix + + ", score=" + + alignment.annotations.score.unwrap_or(0.0).to_string(), + ) + + println("\n2. Preserve local coordinates and consensus") + for sequence in alignment.sequences { + println( + " " + + sequence.id + + ": boundaries [" + + sequence.start.to_string() + + ", " + + sequence.end.to_string() + + "), residues=" + + sequence.sequence.length().to_string(), + ) + } + println(" consensus: " + alignment.consensus) + + println("\n3. Map absolute residue coordinates") + match alignment.map_position(0, 1, 87) { + Some(position) => + println( + " reference residue 87 maps to query residue " + + position.to_string() + + " (zero-based absolute coordinates)", + ) + None => println(" reference residue 87 maps to a query gap") + } + let path = alignment.coordinate_path() + println(" reference path: " + coordinate_text(path[0])) + println(" query path: " + coordinate_text(path[1])) + + println("\n4. Calculate pairwise EMBOSS statistics") + let counts = alignment.pair_counts(0, 1) catch { + AlignEmbossError(message) => abort("pair counting failed: " + message) + } + println( + " identities/mismatches/gaps: " + + counts.identities.to_string() + + "/" + + counts.mismatches.to_string() + + "/" + + (counts.insertions + counts.deletions).to_string(), + ) + println( + " positives=" + + counts.positives.to_string() + + ", identity=" + + counts.identity().to_string(), + ) + + println("\n5. Handle reverse-strand boundaries") + let annotations = @src.AlignEmbossAnnotations::create(4) catch { + AlignEmbossError(message) => + abort("annotation construction failed: " + message) + } + let forward = @src.AlignEmbossSequence::create("target", "ACGT", 2, 6) catch { + AlignEmbossError(message) => + abort("forward row construction failed: " + message) + } + let reverse = @src.AlignEmbossSequence::create("reverse", "ACGT", 20, 16) catch { + AlignEmbossError(message) => + abort("reverse row construction failed: " + message) + } + let reverse_alignment = @src.AlignEmbossAlignment::create( + [forward, reverse], + annotations, + consensus="||||", + ) catch { + AlignEmbossError(message) => + abort("reverse alignment construction failed: " + message) + } + println( + " reverse columns 0..3 map to residues " + + reverse_alignment + .column_to_sequence_position(1, 0) + .unwrap_or(-1) + .to_string() + + ".." + + reverse_alignment + .column_to_sequence_position(1, 3) + .unwrap_or(-1) + .to_string(), + ) + + println("\n6. Wrapped canonical serialization") + let serialized = @src.align_emboss_write(document, line_width=7) catch { + AlignEmbossError(message) => abort("EMBOSS writing failed: " + message) + } + let reparsed = @src.align_emboss_parse(serialized) catch { + AlignEmbossError(message) => + abort("serialized EMBOSS parsing failed: " + message) + } + println(" serialized bytes: " + serialized.length().to_string()) + println( + " round trip preserved report: " + (document == reparsed).to_string(), + ) + + println("\n=== Demo Complete ===") +} diff --git a/examples/align_emboss_demo/moon.pkg b/examples/align_emboss_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/align_emboss_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/examples/align_exonerate_demo/main.mbt b/examples/align_exonerate_demo/main.mbt new file mode 100644 index 00000000..70e666b5 --- /dev/null +++ b/examples/align_exonerate_demo/main.mbt @@ -0,0 +1,101 @@ +///| +fn coordinate_text(values : Array[Int]) -> String { + let output = StringBuilder::new() + output.write_char('[') + for index in 0.. 0 { + output.write_string(", ") + } + output.write_string(values[index].to_string()) + } + output.write_char(']') + output.to_string() +} + +///| +fn main { + println("=== Biopython Bio.Align.exonerate Demo ===") + + let document = @src.align_exonerate_parse(@src.align_exonerate_example_text()) catch { + AlignExonerateError(message) => + abort("Exonerate parsing failed: " + message) + } + let spliced = document.alignments[0] + let translated = document.alignments[1] + + println("\n1. Parse report metadata and alignments") + println(" " + document.summary()) + println(" command: " + document.metadata.command_line) + for alignment in document.alignments { + println(" " + alignment.summary()) + } + + println("\n2. Preserve spliced vulgar operations") + let spliced_path = spliced.coordinate_path() + println(" operations: " + spliced.operation_codes()) + println(" target path: " + coordinate_text(spliced_path[0])) + println(" query path: " + coordinate_text(spliced_path[1])) + let spliced_counts = spliced.counts() + println( + " introns=" + + spliced_counts.introns.to_string() + + ", intron units=" + + spliced_counts.intron_units.to_string() + + ", matching operations=" + + spliced_counts.matching_operations.to_string(), + ) + + println("\n3. Map residues across an intron") + println( + " query residue 6 -> target residue " + + spliced.query_position_to_target(6).unwrap_or(-1).to_string(), + ) + println( + " target residue 108 -> query residue " + + spliced.target_position_to_query(108).unwrap_or(-1).to_string() + + " (-1 denotes an intron)", + ) + + println("\n4. Handle protein-to-DNA reverse translation") + let translated_path = translated.coordinate_path() + println(" target path: " + coordinate_text(translated_path[0])) + println(" query path: " + coordinate_text(translated_path[1])) + for residue in 0.. reverse-strand nucleotide " + + translated.query_position_to_target(residue).unwrap_or(-1).to_string(), + ) + } + + println("\n5. Write canonical vulgar and cigar reports") + let vulgar = @src.align_exonerate_write(document, format="vulgar") catch { + AlignExonerateError(message) => + abort("vulgar serialization failed: " + message) + } + let cigar = @src.align_exonerate_write(document, format="cigar") catch { + AlignExonerateError(message) => + abort("cigar serialization failed: " + message) + } + let vulgar_round_trip = @src.align_exonerate_parse(vulgar) catch { + AlignExonerateError(message) => + abort("vulgar round trip failed: " + message) + } + let cigar_round_trip = @src.align_exonerate_parse(cigar) catch { + AlignExonerateError(message) => abort("cigar round trip failed: " + message) + } + println( + " vulgar preserves document: " + + (vulgar_round_trip == document).to_string(), + ) + println( + " cigar preserves first coordinate path: " + + (cigar_round_trip.alignments[0].coordinate_path() == + spliced.coordinate_path()).to_string(), + ) + println(" vulgar bytes: " + vulgar.length().to_string()) + println(" cigar bytes: " + cigar.length().to_string()) + + println("\n=== Demo Complete ===") +} diff --git a/examples/align_exonerate_demo/moon.pkg b/examples/align_exonerate_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/align_exonerate_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/a2m.mbt b/src/a2m.mbt new file mode 100644 index 00000000..2876f818 --- /dev/null +++ b/src/a2m.mbt @@ -0,0 +1,930 @@ +// Biopython-compatible A2M multiple sequence alignment support. +// +// A2M uses upper-case residues and '-' in model match columns, and lower-case +// residues and '.' in insertion columns. The first row defines the state of +// every column. Internally rows are normalized to upper-case residues and '-'; +// the separate state string preserves the information required for round-trip +// serialization. + +///| +/// Error raised for malformed A2M data or invalid alignment operations. +pub suberror A2mError { + A2mError(String) +} + +///| +/// State assigned to an A2M alignment column. +pub(all) enum A2mColumnState { + A2mMatch + A2mInsertion +} derive(Eq, Debug) + +///| +/// One normalized sequence row in an A2M alignment. +/// +/// `aligned_sequence` contains upper-case residues and '-' gaps. `sequence` +/// contains the ungapped residues. +pub struct A2mSequence { + id : String + description : String + sequence : String + aligned_sequence : String +} derive(Eq, Debug) + +///| +/// A state-aware A2M multiple sequence alignment. +/// +/// `states` contains one `D` (model match/deletion) or `I` (insertion) for +/// each alignment column, following Biopython's column annotation convention. +pub struct A2mAlignment { + sequences : Array[A2mSequence] + states : String +} derive(Eq, Debug) + +///| +/// A contiguous run of insertion-state columns. +/// +/// `slot` is the number of match columns preceding the run. Therefore slot 0 +/// is before the first match column and slot `match_columns()` is after the +/// final match column. +pub struct A2mInsertionRun { + slot : Int + start_column : Int + end_column : Int + width : Int +} derive(Eq, Debug) + +///| +/// Pairwise statistics for two rows in an A2M alignment. +pub struct A2mPairCounts { + columns : Int + aligned : Int + identities : Int + mismatches : Int + gap_columns : Int + double_gap_columns : Int + match_aligned : Int + insertion_aligned : Int +} derive(Eq, Debug) + +///| +/// Construct a normalized A2M sequence row. +pub fn A2mSequence::create( + id : String, + aligned_sequence : String, + description? : String = "", +) -> A2mSequence raise A2mError { + a2m_validate_id(id) + a2m_validate_description(description) + if aligned_sequence.length() == 0 { + raise A2mError("A2M aligned sequence must not be empty") + } + let normalized = a2m_normalize_aligned_sequence(aligned_sequence) + A2mSequence::{ + id, + description, + sequence: a2m_remove_gaps(normalized), + aligned_sequence: normalized, + } +} + +///| +/// Construct an A2M alignment from normalized rows and a `D`/`I` state string. +pub fn A2mAlignment::create( + sequences : Array[A2mSequence], + states : String, +) -> A2mAlignment raise A2mError { + let copied : Array[A2mSequence] = [] + for sequence in sequences { + copied.push(sequence) + } + let alignment = A2mAlignment::{ sequences: copied, states } + a2m_validate_alignment(alignment) + alignment +} + +///| +/// Construct an A2M alignment directly from row metadata and normalized rows. +pub fn a2m_from_aligned( + ids : Array[String], + aligned_sequences : Array[String], + states : String, + descriptions? : Array[String] = [], +) -> A2mAlignment raise A2mError { + if ids.length() == 0 { + raise A2mError("A2M alignment must contain at least one sequence") + } + if ids.length() != aligned_sequences.length() { + raise A2mError( + "A2M identifiers and aligned sequences must have equal lengths", + ) + } + if descriptions.length() != 0 && descriptions.length() != ids.length() { + raise A2mError("A2M descriptions must be empty or match the sequence count") + } + let sequences : Array[A2mSequence] = [] + for index = 0; index < ids.length(); index = index + 1 { + let description = if descriptions.length() == 0 { + "" + } else { + descriptions[index] + } + sequences.push( + A2mSequence::create(ids[index], aligned_sequences[index], description~), + ) + } + A2mAlignment::create(sequences, states) +} + +///| +/// Parse one A2M multiple sequence alignment. +/// +/// The first row defines the state of each column. All following rows must use +/// the same character class in each column. Wrapped sequence lines and CRLF +/// input are accepted; blank lines are ignored. +pub fn a2m_parse(text : String) -> A2mAlignment raise A2mError { + let lines = a2m_normalize_lines(text) + let ids : Array[String] = [] + let descriptions : Array[String] = [] + let encoded_rows : Array[String] = [] + let mut current = -1 + for raw_line in lines { + let line = raw_line.trim().to_owned() + if line.length() == 0 { + continue + } + if line.unsafe_get(0).to_int() == '>'.to_int() { + let header = line[1:].trim().to_owned() + if header.length() == 0 { + raise A2mError("A2M header must contain a sequence identifier") + } + let (id, description) = a2m_parse_header(header) + a2m_validate_id(id) + a2m_validate_description(description) + ids.push(id) + descriptions.push(description) + encoded_rows.push("") + current = encoded_rows.length() - 1 + } else { + if current < 0 { + raise A2mError("A2M sequence data appears before the first header") + } + a2m_validate_encoded_fragment(line) + encoded_rows[current] = encoded_rows[current] + line + } + } + if encoded_rows.length() == 0 { + raise A2mError("Empty A2M input") + } + let width = encoded_rows[0].length() + if width == 0 { + raise A2mError("A2M sequences must not be empty") + } + let states_builder = StringBuilder::new(size_hint=width) + for column = 0; column < width; column = column + 1 { + let code = encoded_rows[0].unsafe_get(column).to_int() + if a2m_is_upper(code) || code == '-'.to_int() { + states_builder.write_char('D') + } else if a2m_is_lower(code) || code == '.'.to_int() { + states_builder.write_char('I') + } else { + raise A2mError( + "Invalid A2M character in first sequence at column " + + column.to_string(), + ) + } + } + let states = states_builder.to_string() + let sequences : Array[A2mSequence] = [] + for row = 0; row < encoded_rows.length(); row = row + 1 { + let encoded = encoded_rows[row] + if encoded.length() != width { + raise A2mError( + "A2M row '" + + ids[row] + + "' has width " + + encoded.length().to_string() + + "; expected " + + width.to_string(), + ) + } + let normalized = StringBuilder::new(size_hint=width) + for column = 0; column < width; column = column + 1 { + let code = encoded.unsafe_get(column).to_int() + let state = states.unsafe_get(column).to_int() + if state == 'D'.to_int() { + if code == '-'.to_int() { + normalized.write_char('-') + } else if a2m_is_upper(code) { + normalized.write_char(code.unsafe_to_char()) + } else { + raise A2mError( + "A2M row '" + + ids[row] + + "' uses an insertion character in match column " + + column.to_string(), + ) + } + } else if code == '.'.to_int() { + normalized.write_char('-') + } else if a2m_is_lower(code) { + normalized.write_char(a2m_upper_code(code).unsafe_to_char()) + } else { + raise A2mError( + "A2M row '" + + ids[row] + + "' uses a match character in insertion column " + + column.to_string(), + ) + } + } + sequences.push(A2mSequence::{ + id: ids[row], + description: descriptions[row], + sequence: a2m_remove_gaps(normalized.to_string()), + aligned_sequence: normalized.to_string(), + }) + } + A2mAlignment::create(sequences, states) +} + +///| +/// Serialize one A2M alignment. +/// +/// A `line_width` of zero emits one sequence line per row. Positive values +/// wrap rows without changing column states. +pub fn a2m_write( + alignment : A2mAlignment, + line_width? : Int = 0, +) -> String raise A2mError { + a2m_validate_alignment(alignment) + if line_width < 0 { + raise A2mError("A2M line width must be non-negative") + } + let output = StringBuilder::new() + for row = 0; row < alignment.sequences.length(); row = row + 1 { + let sequence = alignment.sequences[row] + output.write_char('>') + output.write_string(sequence.id) + if sequence.description.length() > 0 { + output.write_char(' ') + output.write_string(sequence.description) + } + output.write_char('\n') + let encoded = alignment.encoded_sequence(row).unwrap() + if line_width == 0 { + output.write_string(encoded) + output.write_char('\n') + } else { + let mut start = 0 + while start < encoded.length() { + let end = if start + line_width < encoded.length() { + start + line_width + } else { + encoded.length() + } + output.write_string(encoded[start:end].to_owned()) + output.write_char('\n') + start = end + } + } + } + output.to_string() +} + +///| +/// Return the number of rows. +pub fn A2mAlignment::num_sequences(self : A2mAlignment) -> Int { + self.sequences.length() +} + +///| +/// Return the number of alignment columns. +pub fn A2mAlignment::alignment_length(self : A2mAlignment) -> Int { + self.states.length() +} + +///| +/// Return the number of model match/deletion columns. +pub fn A2mAlignment::match_columns(self : A2mAlignment) -> Int { + let mut count = 0 + for index = 0; index < self.states.length(); index = index + 1 { + if self.states.unsafe_get(index).to_int() == 'D'.to_int() { + count = count + 1 + } + } + count +} + +///| +/// Return the number of insertion-state columns. +pub fn A2mAlignment::insertion_columns(self : A2mAlignment) -> Int { + self.alignment_length() - self.match_columns() +} + +///| +/// Return a column state by zero-based alignment coordinate. +pub fn A2mAlignment::column_state( + self : A2mAlignment, + column : Int, +) -> A2mColumnState? { + if column < 0 || column >= self.states.length() { + None + } else if self.states.unsafe_get(column).to_int() == 'D'.to_int() { + Some(A2mMatch) + } else { + Some(A2mInsertion) + } +} + +///| +/// Return all row characters at an alignment column. +pub fn A2mAlignment::column(self : A2mAlignment, column : Int) -> String? { + if column < 0 || column >= self.states.length() { + return None + } + let result = StringBuilder::new(size_hint=self.sequences.length()) + for sequence in self.sequences { + result.write_char( + sequence.aligned_sequence.unsafe_get(column).unsafe_to_char(), + ) + } + Some(result.to_string()) +} + +///| +/// Find the first row with an exact sequence identifier. +pub fn A2mAlignment::find_sequence(self : A2mAlignment, id : String) -> Int? { + for index = 0; index < self.sequences.length(); index = index + 1 { + if self.sequences[index].id == id { + return Some(index) + } + } + None +} + +///| +/// Return a row in canonical A2M character form. +pub fn A2mAlignment::encoded_sequence( + self : A2mAlignment, + row : Int, +) -> String? { + if row < 0 || row >= self.sequences.length() { + return None + } + let aligned = self.sequences[row].aligned_sequence + let result = StringBuilder::new(size_hint=self.states.length()) + for column = 0; column < self.states.length(); column = column + 1 { + let code = aligned.unsafe_get(column).to_int() + if self.states.unsafe_get(column).to_int() == 'D'.to_int() { + result.write_char(code.unsafe_to_char()) + } else if code == '-'.to_int() { + result.write_char('.') + } else { + result.write_char(a2m_lower_code(code).unsafe_to_char()) + } + } + Some(result.to_string()) +} + +///| +/// Map an ungapped row coordinate to its alignment column. +pub fn A2mAlignment::sequence_position_to_column( + self : A2mAlignment, + row : Int, + position : Int, +) -> Int? { + if row < 0 || row >= self.sequences.length() || position < 0 { + return None + } + let aligned = self.sequences[row].aligned_sequence + let mut coordinate = 0 + for column = 0; column < aligned.length(); column = column + 1 { + if aligned.unsafe_get(column).to_int() != '-'.to_int() { + if coordinate == position { + return Some(column) + } + coordinate = coordinate + 1 + } + } + None +} + +///| +/// Map an alignment column to an ungapped row coordinate. +/// +/// Gap columns return `None`. +pub fn A2mAlignment::column_to_sequence_position( + self : A2mAlignment, + row : Int, + column : Int, +) -> Int? { + if row < 0 || + row >= self.sequences.length() || + column < 0 || + column >= self.states.length() { + return None + } + let aligned = self.sequences[row].aligned_sequence + if aligned.unsafe_get(column).to_int() == '-'.to_int() { + return None + } + let mut coordinate = 0 + for index = 0; index < column; index = index + 1 { + if aligned.unsafe_get(index).to_int() != '-'.to_int() { + coordinate = coordinate + 1 + } + } + Some(coordinate) +} + +///| +/// Map a residue coordinate from one row through the alignment to another. +/// +/// Returns `None` for out-of-range coordinates and target gaps. +pub fn A2mAlignment::map_position( + self : A2mAlignment, + source_row : Int, + target_row : Int, + source_position : Int, +) -> Int? { + if target_row < 0 || target_row >= self.sequences.length() { + return None + } + match self.sequence_position_to_column(source_row, source_position) { + Some(column) => self.column_to_sequence_position(target_row, column) + None => None + } +} + +///| +/// Return per-column coordinates for two rows. +/// +/// Residues are represented by zero-based coordinates and gaps by `None`. +pub fn A2mAlignment::aligned_pairs( + self : A2mAlignment, + first_row : Int, + second_row : Int, +) -> Array[(Int?, Int?)] raise A2mError { + a2m_validate_row(self, first_row) + a2m_validate_row(self, second_row) + let first = self.sequences[first_row].aligned_sequence + let second = self.sequences[second_row].aligned_sequence + let result : Array[(Int?, Int?)] = [] + let mut first_coordinate = 0 + let mut second_coordinate = 0 + for column = 0; column < self.states.length(); column = column + 1 { + let first_gap = first.unsafe_get(column).to_int() == '-'.to_int() + let second_gap = second.unsafe_get(column).to_int() == '-'.to_int() + let first_value : Int? = if first_gap { + None + } else { + Some(first_coordinate) + } + let second_value : Int? = if second_gap { + None + } else { + Some(second_coordinate) + } + result.push((first_value, second_value)) + if !first_gap { + first_coordinate = first_coordinate + 1 + } + if !second_gap { + second_coordinate = second_coordinate + 1 + } + } + result +} + +///| +/// Compute pairwise identity, mismatch, and gap counts for two rows. +pub fn A2mAlignment::pair_counts( + self : A2mAlignment, + first_row : Int, + second_row : Int, +) -> A2mPairCounts raise A2mError { + a2m_validate_row(self, first_row) + a2m_validate_row(self, second_row) + let first = self.sequences[first_row].aligned_sequence + let second = self.sequences[second_row].aligned_sequence + let mut aligned = 0 + let mut identities = 0 + let mut mismatches = 0 + let mut gap_columns = 0 + let mut double_gap_columns = 0 + let mut match_aligned = 0 + let mut insertion_aligned = 0 + for column = 0; column < self.states.length(); column = column + 1 { + let first_code = first.unsafe_get(column).to_int() + let second_code = second.unsafe_get(column).to_int() + let first_gap = first_code == '-'.to_int() + let second_gap = second_code == '-'.to_int() + if first_gap && second_gap { + double_gap_columns = double_gap_columns + 1 + } else if first_gap || second_gap { + gap_columns = gap_columns + 1 + } else { + aligned = aligned + 1 + if first_code == second_code { + identities = identities + 1 + } else { + mismatches = mismatches + 1 + } + if self.states.unsafe_get(column).to_int() == 'D'.to_int() { + match_aligned = match_aligned + 1 + } else { + insertion_aligned = insertion_aligned + 1 + } + } + } + A2mPairCounts::{ + columns: self.states.length(), + aligned, + identities, + mismatches, + gap_columns, + double_gap_columns, + match_aligned, + insertion_aligned, + } +} + +///| +/// Return identity fraction over columns containing residues in both rows. +pub fn A2mPairCounts::identity(self : A2mPairCounts) -> Double { + if self.aligned == 0 { + 0.0 + } else { + self.identities.to_double() / self.aligned.to_double() + } +} + +///| +/// Locate contiguous insertion-state runs and their model slots. +pub fn A2mAlignment::insertion_runs( + self : A2mAlignment, +) -> Array[A2mInsertionRun] { + let result : Array[A2mInsertionRun] = [] + let mut column = 0 + let mut slot = 0 + while column < self.states.length() { + if self.states.unsafe_get(column).to_int() == 'D'.to_int() { + slot = slot + 1 + column = column + 1 + } else { + let start = column + while column < self.states.length() && + self.states.unsafe_get(column).to_int() == 'I'.to_int() { + column = column + 1 + } + result.push(A2mInsertionRun::{ + slot, + start_column: start, + end_column: column, + width: column - start, + }) + } + } + result +} + +///| +/// Calculate a majority consensus. +/// +/// Gaps do not vote. Columns without residues produce `-`; columns below +/// `minimum_fraction` produce `X`. Setting `include_insertions` to false +/// returns a model match-state consensus. +pub fn A2mAlignment::consensus( + self : A2mAlignment, + include_insertions? : Bool = true, + minimum_fraction? : Double = 0.0, +) -> String raise A2mError { + if minimum_fraction != minimum_fraction || + minimum_fraction < 0.0 || + minimum_fraction > 1.0 { + raise A2mError("A2M consensus minimum fraction must be between 0 and 1") + } + let result = StringBuilder::new() + for column = 0; column < self.states.length(); column = column + 1 { + if !include_insertions && + self.states.unsafe_get(column).to_int() == 'I'.to_int() { + continue + } + let counts = Array::make(26, 0) + let mut residues = 0 + for sequence in self.sequences { + let code = sequence.aligned_sequence.unsafe_get(column).to_int() + if a2m_is_upper(code) { + let index = code - 'A'.to_int() + counts[index] = counts[index] + 1 + residues = residues + 1 + } + } + if residues == 0 { + result.write_char('-') + continue + } + let mut best_index = 0 + let mut best_count = counts[0] + for index = 1; index < counts.length(); index = index + 1 { + if counts[index] > best_count { + best_index = index + best_count = counts[index] + } + } + let fraction = best_count.to_double() / residues.to_double() + if fraction < minimum_fraction { + result.write_char('X') + } else { + result.write_char((best_index + 'A'.to_int()).unsafe_to_char()) + } + } + result.to_string() +} + +///| +/// Return per-column residue occupancy as a fraction of row count. +pub fn A2mAlignment::occupancy(self : A2mAlignment) -> Array[Double] { + let result : Array[Double] = [] + for column = 0; column < self.states.length(); column = column + 1 { + let mut residues = 0 + for sequence in self.sequences { + if sequence.aligned_sequence.unsafe_get(column).to_int() != '-'.to_int() { + residues = residues + 1 + } + } + result.push(residues.to_double() / self.sequences.length().to_double()) + } + result +} + +///| +/// Return a new alignment containing only model match/deletion columns. +pub fn A2mAlignment::match_projection( + self : A2mAlignment, +) -> A2mAlignment raise A2mError { + let match_count = self.match_columns() + if match_count == 0 { + raise A2mError("A2M alignment has no match columns to project") + } + let states = StringBuilder::new(size_hint=match_count) + let mut emitted = 0 + while emitted < match_count { + states.write_char('D') + emitted = emitted + 1 + } + let sequences : Array[A2mSequence] = [] + for sequence in self.sequences { + let row = StringBuilder::new(size_hint=match_count) + for column = 0; column < self.states.length(); column = column + 1 { + if self.states.unsafe_get(column).to_int() == 'D'.to_int() { + row.write_char( + sequence.aligned_sequence.unsafe_get(column).unsafe_to_char(), + ) + } + } + sequences.push( + A2mSequence::create( + sequence.id, + row.to_string(), + description=sequence.description, + ), + ) + } + A2mAlignment::create(sequences, states.to_string()) +} + +///| +/// Extract a non-empty half-open range of alignment columns. +pub fn A2mAlignment::slice_columns( + self : A2mAlignment, + start : Int, + end : Int, +) -> A2mAlignment raise A2mError { + if start < 0 || end <= start || end > self.states.length() { + raise A2mError("A2M column slice is out of bounds or empty") + } + let sequences : Array[A2mSequence] = [] + for sequence in self.sequences { + sequences.push( + A2mSequence::create( + sequence.id, + sequence.aligned_sequence[start:end].to_owned(), + description=sequence.description, + ), + ) + } + A2mAlignment::create(sequences, self.states[start:end].to_owned()) +} + +///| +/// Return a compact alignment summary. +pub fn A2mAlignment::summary(self : A2mAlignment) -> String { + "A2mAlignment(sequences=" + + self.sequences.length().to_string() + + ", columns=" + + self.states.length().to_string() + + ", match=" + + self.match_columns().to_string() + + ", insertion=" + + self.insertion_columns().to_string() + + ")" +} + +///| +/// Return a small state-aware A2M example. +pub fn a2m_example_text() -> String { + ">reference SAM model reference\n" + + "ACDefG-HIkLM\n" + + ">query_one insertion and deletion\n" + + "ACD..GTHI.LM\n" + + ">query_two divergent homolog\n" + + "ATDqrG-HI.L-\n" +} + +///| +fn a2m_validate_alignment(alignment : A2mAlignment) -> Unit raise A2mError { + if alignment.sequences.length() == 0 { + raise A2mError("A2M alignment must contain at least one sequence") + } + let width = alignment.states.length() + if width == 0 { + raise A2mError("A2M state string must not be empty") + } + for column = 0; column < width; column = column + 1 { + let state = alignment.states.unsafe_get(column).to_int() + if state != 'D'.to_int() && state != 'I'.to_int() { + raise A2mError( + "A2M state string contains a character other than D or I at column " + + column.to_string(), + ) + } + } + for row = 0; row < alignment.sequences.length(); row = row + 1 { + let sequence = alignment.sequences[row] + a2m_validate_id(sequence.id) + a2m_validate_description(sequence.description) + if sequence.aligned_sequence.length() != width { + raise A2mError( + "A2M row '" + + sequence.id + + "' has width " + + sequence.aligned_sequence.length().to_string() + + "; expected " + + width.to_string(), + ) + } + for column = 0; column < width; column = column + 1 { + let code = sequence.aligned_sequence.unsafe_get(column).to_int() + if code != '-'.to_int() && !a2m_is_upper(code) { + raise A2mError( + "Normalized A2M row '" + + sequence.id + + "' contains an invalid character at column " + + column.to_string(), + ) + } + } + if a2m_remove_gaps(sequence.aligned_sequence) != sequence.sequence { + raise A2mError( + "A2M row '" + sequence.id + "' has inconsistent ungapped sequence", + ) + } + } +} + +///| +fn a2m_validate_row(alignment : A2mAlignment, row : Int) -> Unit raise A2mError { + if row < 0 || row >= alignment.sequences.length() { + raise A2mError("A2M row index is out of bounds") + } +} + +///| +fn a2m_validate_id(id : String) -> Unit raise A2mError { + if id.length() == 0 { + raise A2mError("A2M sequence identifier must not be empty") + } + for index = 0; index < id.length(); index = index + 1 { + let code = id.unsafe_get(index).to_int() + if code == ' '.to_int() || + code == '\t'.to_int() || + code == '\n'.to_int() || + code == '\r'.to_int() { + raise A2mError("A2M sequence identifier must not contain whitespace") + } + } +} + +///| +fn a2m_validate_description(description : String) -> Unit raise A2mError { + for index = 0; index < description.length(); index = index + 1 { + let code = description.unsafe_get(index).to_int() + if code == '\n'.to_int() || code == '\r'.to_int() { + raise A2mError("A2M description must not contain line breaks") + } + } +} + +///| +fn a2m_validate_encoded_fragment(fragment : String) -> Unit raise A2mError { + for index = 0; index < fragment.length(); index = index + 1 { + let code = fragment.unsafe_get(index).to_int() + if !a2m_is_upper(code) && + !a2m_is_lower(code) && + code != '-'.to_int() && + code != '.'.to_int() { + raise A2mError( + "Invalid A2M sequence character at wrapped-line offset " + + index.to_string(), + ) + } + } +} + +///| +fn a2m_normalize_aligned_sequence(sequence : String) -> String raise A2mError { + let result = StringBuilder::new(size_hint=sequence.length()) + for index = 0; index < sequence.length(); index = index + 1 { + let code = sequence.unsafe_get(index).to_int() + if code == '-'.to_int() { + result.write_char('-') + } else if a2m_is_upper(code) { + result.write_char(code.unsafe_to_char()) + } else if a2m_is_lower(code) { + result.write_char(a2m_upper_code(code).unsafe_to_char()) + } else { + raise A2mError( + "Normalized A2M sequence contains an invalid character at column " + + index.to_string(), + ) + } + } + result.to_string() +} + +///| +fn a2m_remove_gaps(sequence : String) -> String { + let result = StringBuilder::new(size_hint=sequence.length()) + for index = 0; index < sequence.length(); index = index + 1 { + let code = sequence.unsafe_get(index).to_int() + if code != '-'.to_int() { + result.write_char(code.unsafe_to_char()) + } + } + result.to_string() +} + +///| +fn a2m_parse_header(header : String) -> (String, String) { + for index = 0; index < header.length(); index = index + 1 { + let code = header.unsafe_get(index).to_int() + if code == ' '.to_int() || code == '\t'.to_int() { + return (header[0:index].to_owned(), header[index:].trim().to_owned()) + } + } + (header, "") +} + +///| +fn a2m_normalize_lines(text : String) -> Array[String] { + let result : Array[String] = [] + for view in text.split("\n") { + let mut line = view.to_owned() + if line.length() > 0 && + line.unsafe_get(line.length() - 1).to_int() == '\r'.to_int() { + line = line[0:line.length() - 1].to_owned() + } + result.push(line) + } + result +} + +///| +fn a2m_is_upper(code : Int) -> Bool { + code >= 'A'.to_int() && code <= 'Z'.to_int() +} + +///| +fn a2m_is_lower(code : Int) -> Bool { + code >= 'a'.to_int() && code <= 'z'.to_int() +} + +///| +fn a2m_upper_code(code : Int) -> Int { + if a2m_is_lower(code) { + code - ('a'.to_int() - 'A'.to_int()) + } else { + code + } +} + +///| +fn a2m_lower_code(code : Int) -> Int { + if a2m_is_upper(code) { + code + ('a'.to_int() - 'A'.to_int()) + } else { + code + } +} diff --git a/src/align_emboss.mbt b/src/align_emboss.mbt new file mode 100644 index 00000000..f837e7f4 --- /dev/null +++ b/src/align_emboss.mbt @@ -0,0 +1,1792 @@ +// Alignment-aware EMBOSS srspair/pair/simple support. +// +// This module follows Biopython 1.86 Bio.Align.emboss semantics. EMBOSS +// sequence lines use a fixed 21-character prefix and one-based inclusive +// printed coordinates. Public coordinates are normalized to zero-based +// residue positions and boundary coordinates. + +///| +/// Error raised for malformed EMBOSS alignment output or invalid operations. +pub suberror AlignEmbossError { + AlignEmbossError(String) +} + +///| +/// Orientation of a sequence row in an EMBOSS alignment. +pub(all) enum AlignEmbossStrand { + AlignEmbossForward + AlignEmbossReverse +} derive(Eq, Debug) + +///| +/// File-level metadata from the EMBOSS report header. +pub struct AlignEmbossMetadata { + program : String + rundate : String + report_file : String + align_format : String + command_line : String +} derive(Eq, Debug) + +///| +/// Per-alignment annotations reported by EMBOSS. +pub struct AlignEmbossAnnotations { + matrix : String + gap_penalty : Double? + extend_penalty : Double? + length : Int + identity : Int? + similarity : Int? + gaps : Int? + score : Double? + longest_identity : String + longest_similarity : String + shortest_identity : String + shortest_similarity : String +} derive(Eq, Debug) + +///| +/// One sequence row in an EMBOSS alignment. +/// +/// `start` and `end` are zero-based boundary coordinates. Forward rows have +/// `start <= end`; reverse rows have `start > end`. `aligned_sequence` is in +/// displayed alignment orientation and `sequence` is the same row without +/// gap characters. +pub struct AlignEmbossSequence { + id : String + sequence : String + aligned_sequence : String + start : Int + end : Int + strand : AlignEmbossStrand +} derive(Eq, Debug) + +///| +/// One parsed EMBOSS pairwise or multiple sequence alignment. +pub struct AlignEmbossAlignment { + sequences : Array[AlignEmbossSequence] + consensus : String + annotations : AlignEmbossAnnotations +} derive(Eq, Debug) + +///| +/// A complete EMBOSS report containing one or more alignments. +pub struct AlignEmbossDocument { + metadata : AlignEmbossMetadata + alignments : Array[AlignEmbossAlignment] +} derive(Eq, Debug) + +///| +/// Pairwise statistics for two rows in an EMBOSS alignment. +pub struct AlignEmbossPairCounts { + columns : Int + aligned : Int + identities : Int + mismatches : Int + insertions : Int + deletions : Int + double_gap_columns : Int + insertion_opens : Int + deletion_opens : Int + positives : Int +} derive(Eq, Debug) + +///| +/// Construct file-level EMBOSS metadata. +pub fn AlignEmbossMetadata::create( + program? : String = "", + rundate? : String = "", + report_file? : String = "", + align_format? : String = "srspair", + command_line? : String = "", +) -> AlignEmbossMetadata raise AlignEmbossError { + align_emboss_validate_header_value(program, "Program") + align_emboss_validate_header_value(rundate, "Rundate") + align_emboss_validate_header_value(report_file, "Report_file") + align_emboss_validate_header_value(command_line, "Command line") + if align_format != "srspair" && + align_format != "pair" && + align_format != "simple" { + raise AlignEmbossError( + "EMBOSS Align_format must be srspair, pair, or simple", + ) + } + AlignEmbossMetadata::{ + program, + rundate, + report_file, + align_format, + command_line, + } +} + +///| +/// Construct per-alignment EMBOSS annotations. +pub fn AlignEmbossAnnotations::create( + length : Int, + matrix? : String = "", + gap_penalty? : Double? = None, + extend_penalty? : Double? = None, + identity? : Int? = None, + similarity? : Int? = None, + gaps? : Int? = None, + score? : Double? = None, + longest_identity? : String = "", + longest_similarity? : String = "", + shortest_identity? : String = "", + shortest_similarity? : String = "", +) -> AlignEmbossAnnotations raise AlignEmbossError { + if length <= 0 { + raise AlignEmbossError("EMBOSS alignment length must be positive") + } + align_emboss_validate_header_value(matrix, "Matrix") + align_emboss_validate_optional_nonnegative_double(gap_penalty, "Gap_penalty") + align_emboss_validate_optional_nonnegative_double( + extend_penalty, "Extend_penalty", + ) + align_emboss_validate_optional_count(identity, length, "Identity") + align_emboss_validate_optional_count(similarity, length, "Similarity") + align_emboss_validate_optional_count(gaps, length, "Gaps") + match score { + Some(value) => + if value.abs() > 1.0e300 { + raise AlignEmbossError("EMBOSS Score must be finite") + } + None => () + } + AlignEmbossAnnotations::{ + matrix, + gap_penalty, + extend_penalty, + length, + identity, + similarity, + gaps, + score, + longest_identity, + longest_similarity, + shortest_identity, + shortest_similarity, + } +} + +///| +/// Construct one normalized EMBOSS sequence row. +pub fn AlignEmbossSequence::create( + id : String, + aligned_sequence : String, + start : Int, + end : Int, +) -> AlignEmbossSequence raise AlignEmbossError { + align_emboss_validate_id(id) + if aligned_sequence.length() == 0 { + raise AlignEmbossError("EMBOSS aligned sequence must not be empty") + } + align_emboss_validate_aligned_fragment(aligned_sequence, "sequence row") + if start < 0 || end < 0 { + raise AlignEmbossError("EMBOSS sequence coordinates must be non-negative") + } + let sequence = align_emboss_remove_gaps(aligned_sequence) + let span = if start >= end { start - end } else { end - start } + if sequence.length() != span { + raise AlignEmbossError( + "EMBOSS ungapped sequence length does not match its coordinate span", + ) + } + let strand = if start <= end { + AlignEmbossForward + } else { + AlignEmbossReverse + } + AlignEmbossSequence::{ id, sequence, aligned_sequence, start, end, strand } +} + +///| +/// Construct one EMBOSS alignment. +pub fn AlignEmbossAlignment::create( + sequences : Array[AlignEmbossSequence], + annotations : AlignEmbossAnnotations, + consensus? : String = "", +) -> AlignEmbossAlignment raise AlignEmbossError { + let copied : Array[AlignEmbossSequence] = [] + for sequence in sequences { + copied.push(sequence) + } + let alignment = AlignEmbossAlignment::{ + sequences: copied, + consensus, + annotations, + } + align_emboss_validate_alignment(alignment) + alignment +} + +///| +/// Construct a complete EMBOSS report. +pub fn AlignEmbossDocument::create( + metadata : AlignEmbossMetadata, + alignments : Array[AlignEmbossAlignment], +) -> AlignEmbossDocument raise AlignEmbossError { + if alignments.length() == 0 { + raise AlignEmbossError("EMBOSS document must contain an alignment") + } + let copied : Array[AlignEmbossAlignment] = [] + for alignment in alignments { + align_emboss_validate_alignment(alignment) + copied.push(alignment) + } + AlignEmbossDocument::{ metadata, alignments: copied } +} + +///| +/// Parse an EMBOSS srspair, pair, or simple alignment report. +/// +/// The parser accepts LF or CRLF input and validates file/alignment headers, +/// declared row order, fixed sequence-line fields, block widths, coordinate +/// continuity, final alignment width, consensus width, and reported counts. +pub fn align_emboss_parse( + text : String, +) -> AlignEmbossDocument raise AlignEmbossError { + let lines = align_emboss_lines(text) + if lines.length() == 0 || (lines.length() == 1 && lines[0].length() == 0) { + raise AlignEmbossError("Empty EMBOSS input") + } + let header_divider = "########################################" + if lines[0].trim().to_owned() != header_divider { + raise AlignEmbossError("EMBOSS file is missing its header divider") + } + let mut program = "" + let mut rundate = "" + let mut report_file = "" + let mut align_format = "srspair" + let mut command_line = "" + let mut index = 1 + let mut header_closed = false + while index < lines.length() { + let line = lines[index] + if line.trim().to_owned() == header_divider { + header_closed = true + index = index + 1 + break + } + if align_emboss_has_prefix(line, "# ") { + if command_line.length() == 0 { + raise AlignEmbossError( + "EMBOSS command continuation appears before Commandline", + ) + } + command_line = command_line + " " + line[1:].trim().to_owned() + index = index + 1 + continue + } + if !align_emboss_has_prefix(line, "# ") { + raise AlignEmbossError( + "Unexpected EMBOSS header line " + (index + 1).to_string(), + ) + } + let content = line[2:].to_owned() + let (key, value) = align_emboss_split_key_value( + content, + "header", + index + 1, + ) + match key { + "Program" => program = value + "Rundate" => rundate = value + "Report_file" => report_file = value + "Align_format" => align_format = value + "Commandline" => command_line = value + _ => () + } + index = index + 1 + } + if !header_closed { + raise AlignEmbossError("Truncated EMBOSS file header") + } + let metadata = AlignEmbossMetadata::create( + program~, + rundate~, + report_file~, + align_format~, + command_line~, + ) + let alignments : Array[AlignEmbossAlignment] = [] + while index < lines.length() { + let line = lines[index].trim().to_owned() + if line.length() == 0 || align_emboss_is_separator(line) { + index = index + 1 + continue + } + if line != "#=======================================" { + raise AlignEmbossError( + "Unexpected content before EMBOSS alignment at line " + + (index + 1).to_string(), + ) + } + let (alignment, next_index) = align_emboss_parse_alignment( + lines, index, metadata, + ) + alignments.push(alignment) + index = next_index + } + AlignEmbossDocument::create(metadata, alignments) +} + +///| +/// Serialize an EMBOSS document in a canonical parseable form. +/// +/// The upstream Biopython module is read-only; this writer is a MoonBit +/// extension for reproducible round trips. Sequence blocks default to the +/// EMBOSS width of 50 columns. +pub fn align_emboss_write( + document : AlignEmbossDocument, + line_width? : Int = 50, +) -> String raise AlignEmbossError { + if line_width <= 0 || line_width > 50 { + raise AlignEmbossError("EMBOSS line width must be between 1 and 50") + } + if document.alignments.length() == 0 { + raise AlignEmbossError("EMBOSS document must contain an alignment") + } + let output = StringBuilder::new() + output.write_string("########################################\n") + if document.metadata.program.length() > 0 { + output.write_string("# Program: " + document.metadata.program + "\n") + } + if document.metadata.rundate.length() > 0 { + output.write_string("# Rundate: " + document.metadata.rundate + "\n") + } + if document.metadata.command_line.length() > 0 { + output.write_string( + "# Commandline: " + document.metadata.command_line + "\n", + ) + } + output.write_string( + "# Align_format: " + document.metadata.align_format + "\n", + ) + if document.metadata.report_file.length() > 0 { + output.write_string( + "# Report_file: " + document.metadata.report_file + "\n", + ) + } + output.write_string("########################################\n") + for alignment in document.alignments { + align_emboss_validate_alignment(alignment) + output.write_string("#=======================================\n#\n") + output.write_string( + "# Aligned_sequences: " + alignment.sequences.length().to_string() + "\n", + ) + for row = 0; row < alignment.sequences.length(); row = row + 1 { + output.write_string( + "# " + (row + 1).to_string() + ": " + alignment.sequences[row].id + "\n", + ) + } + if alignment.annotations.matrix.length() > 0 { + output.write_string("# Matrix: " + alignment.annotations.matrix + "\n") + } + align_emboss_write_optional_double( + output, + "Gap_penalty", + alignment.annotations.gap_penalty, + ) + align_emboss_write_optional_double( + output, + "Extend_penalty", + alignment.annotations.extend_penalty, + ) + output.write_string("#\n") + output.write_string( + "# Length: " + alignment.annotations.length.to_string() + "\n", + ) + align_emboss_write_optional_count( + output, + "Identity", + alignment.annotations.identity, + alignment.annotations.length, + ) + align_emboss_write_optional_count( + output, + "Similarity", + alignment.annotations.similarity, + alignment.annotations.length, + ) + align_emboss_write_optional_count( + output, + "Gaps", + alignment.annotations.gaps, + alignment.annotations.length, + ) + match alignment.annotations.score { + Some(value) => output.write_string("# Score: " + value.to_string() + "\n") + None => () + } + align_emboss_write_long_annotation( + output, + "Longest_Identity", + alignment.annotations.longest_identity, + ) + align_emboss_write_long_annotation( + output, + "Longest_Similarity", + alignment.annotations.longest_similarity, + ) + align_emboss_write_long_annotation( + output, + "Shortest_Identity", + alignment.annotations.shortest_identity, + ) + align_emboss_write_long_annotation( + output, + "Shortest_Similarity", + alignment.annotations.shortest_similarity, + ) + output.write_string("#\n#=======================================\n") + let width = alignment.alignment_length() + let mut column = 0 + while column < width { + let block_end = if column + line_width < width { + column + line_width + } else { + width + } + for row = 0; row < alignment.sequences.length(); row = row + 1 { + let sequence = alignment.sequences[row] + let fragment = sequence.aligned_sequence[column:block_end].to_owned() + let boundary = align_emboss_boundary_at(sequence, column) + let residues = align_emboss_count_residues(fragment) + let (printed_start, printed_end) = align_emboss_printed_coordinates( + sequence, boundary, residues, + ) + output.write_string( + align_emboss_sequence_prefix(sequence.id, printed_start) + + fragment + + " " + + align_emboss_pad_left(printed_end.to_string(), 7) + + "\n", + ) + } + if alignment.consensus.length() > 0 { + output.write_string( + " ".repeat(21) + + alignment.consensus[column:block_end].to_owned() + + "\n", + ) + } + output.write_char('\n') + column = block_end + } + output.write_string( + "#---------------------------------------\n" + + "#---------------------------------------\n", + ) + } + output.to_string() +} + +///| +/// Return the number of alignments in a report. +pub fn AlignEmbossDocument::num_alignments(self : AlignEmbossDocument) -> Int { + self.alignments.length() +} + +///| +/// Return an alignment by zero-based index. +pub fn AlignEmbossDocument::get( + self : AlignEmbossDocument, + index : Int, +) -> AlignEmbossAlignment? { + if index < 0 || index >= self.alignments.length() { + None + } else { + Some(self.alignments[index]) + } +} + +///| +/// Return the number of sequence rows. +pub fn AlignEmbossAlignment::num_sequences(self : AlignEmbossAlignment) -> Int { + self.sequences.length() +} + +///| +/// Return the alignment width including gap columns. +pub fn AlignEmbossAlignment::alignment_length( + self : AlignEmbossAlignment, +) -> Int { + self.annotations.length +} + +///| +/// Find the first row with an exact declared identifier. +pub fn AlignEmbossAlignment::find_sequence( + self : AlignEmbossAlignment, + id : String, +) -> Int? { + for row = 0; row < self.sequences.length(); row = row + 1 { + if self.sequences[row].id == id { + return Some(row) + } + } + None +} + +///| +/// Return all row characters at an alignment column. +pub fn AlignEmbossAlignment::column( + self : AlignEmbossAlignment, + column : Int, +) -> String? { + if column < 0 || column >= self.alignment_length() { + return None + } + let result = StringBuilder::new(size_hint=self.sequences.length()) + for sequence in self.sequences { + result.write_char( + sequence.aligned_sequence.unsafe_get(column).unsafe_to_char(), + ) + } + Some(result.to_string()) +} + +///| +/// Return the zero-based absolute residue position at an alignment column. +/// +/// Gap columns and invalid indices return `None`. +pub fn AlignEmbossAlignment::column_to_sequence_position( + self : AlignEmbossAlignment, + row : Int, + column : Int, +) -> Int? { + if row < 0 || + row >= self.sequences.length() || + column < 0 || + column >= self.alignment_length() { + return None + } + let sequence = self.sequences[row] + if sequence.aligned_sequence.unsafe_get(column).to_int() == '-'.to_int() { + return None + } + let boundary = align_emboss_boundary_at(sequence, column) + if sequence.strand == AlignEmbossForward { + Some(boundary) + } else { + Some(boundary - 1) + } +} + +///| +/// Map a zero-based absolute residue position to its alignment column. +pub fn AlignEmbossAlignment::sequence_position_to_column( + self : AlignEmbossAlignment, + row : Int, + position : Int, +) -> Int? { + if row < 0 || row >= self.sequences.length() || position < 0 { + return None + } + for column = 0; column < self.alignment_length(); column = column + 1 { + match self.column_to_sequence_position(row, column) { + Some(value) => if value == position { return Some(column) } + None => () + } + } + None +} + +///| +/// Map a residue position from one row through the alignment to another row. +pub fn AlignEmbossAlignment::map_position( + self : AlignEmbossAlignment, + source_row : Int, + target_row : Int, + source_position : Int, +) -> Int? { + if target_row < 0 || target_row >= self.sequences.length() { + return None + } + match self.sequence_position_to_column(source_row, source_position) { + Some(column) => self.column_to_sequence_position(target_row, column) + None => None + } +} + +///| +/// Return per-column absolute coordinates for two rows. +/// +/// Gaps are represented by `None`. +pub fn AlignEmbossAlignment::aligned_pairs( + self : AlignEmbossAlignment, + first_row : Int, + second_row : Int, +) -> Array[(Int?, Int?)] raise AlignEmbossError { + align_emboss_validate_row(self, first_row) + align_emboss_validate_row(self, second_row) + let pairs : Array[(Int?, Int?)] = [] + for column = 0; column < self.alignment_length(); column = column + 1 { + pairs.push( + ( + self.column_to_sequence_position(first_row, column), + self.column_to_sequence_position(second_row, column), + ), + ) + } + pairs +} + +///| +/// Build a compact Biopython-style boundary coordinate path. +/// +/// The outer array contains one coordinate array per row. Breakpoints are +/// emitted whenever the per-column movement vector changes. +pub fn AlignEmbossAlignment::coordinate_path( + self : AlignEmbossAlignment, +) -> Array[Array[Int]] { + let result : Array[Array[Int]] = [] + for sequence in self.sequences { + result.push([sequence.start]) + } + if self.alignment_length() == 0 { + return result + } + for column = 1; column < self.alignment_length(); column = column + 1 { + let mut changed = false + for row = 0; row < self.sequences.length(); row = row + 1 { + let sequence = self.sequences[row] + let previous = align_emboss_column_step(sequence, column - 1) + let current = align_emboss_column_step(sequence, column) + if previous != current { + changed = true + break + } + } + if changed { + for row = 0; row < self.sequences.length(); row = row + 1 { + result[row].push(align_emboss_boundary_at(self.sequences[row], column)) + } + } + } + for row = 0; row < self.sequences.length(); row = row + 1 { + result[row].push(self.sequences[row].end) + } + result +} + +///| +/// Compute pairwise residue, gap, gap-open, and positive-column counts. +/// +/// A gap in the first row is an insertion; a gap in the second row is a +/// deletion. `positives` uses `|` and `:` from the EMBOSS consensus when +/// available, otherwise it equals exact identities. +pub fn AlignEmbossAlignment::pair_counts( + self : AlignEmbossAlignment, + first_row : Int, + second_row : Int, +) -> AlignEmbossPairCounts raise AlignEmbossError { + align_emboss_validate_row(self, first_row) + align_emboss_validate_row(self, second_row) + let first = self.sequences[first_row].aligned_sequence + let second = self.sequences[second_row].aligned_sequence + let mut aligned = 0 + let mut identities = 0 + let mut mismatches = 0 + let mut insertions = 0 + let mut deletions = 0 + let mut double_gap_columns = 0 + let mut insertion_opens = 0 + let mut deletion_opens = 0 + let mut positives = 0 + let mut in_insertion = false + let mut in_deletion = false + for column = 0; column < self.alignment_length(); column = column + 1 { + let first_code = first.unsafe_get(column).to_int() + let second_code = second.unsafe_get(column).to_int() + let first_gap = first_code == '-'.to_int() + let second_gap = second_code == '-'.to_int() + if first_gap && second_gap { + double_gap_columns = double_gap_columns + 1 + in_insertion = false + in_deletion = false + } else if first_gap { + insertions = insertions + 1 + if !in_insertion { + insertion_opens = insertion_opens + 1 + } + in_insertion = true + in_deletion = false + } else if second_gap { + deletions = deletions + 1 + if !in_deletion { + deletion_opens = deletion_opens + 1 + } + in_deletion = true + in_insertion = false + } else { + aligned = aligned + 1 + if first_code == second_code { + identities = identities + 1 + } else { + mismatches = mismatches + 1 + } + if self.consensus.length() == self.alignment_length() { + let marker = self.consensus.unsafe_get(column).to_int() + if marker == '|'.to_int() || marker == ':'.to_int() { + positives = positives + 1 + } + } else if first_code == second_code { + positives = positives + 1 + } + in_insertion = false + in_deletion = false + } + } + AlignEmbossPairCounts::{ + columns: self.alignment_length(), + aligned, + identities, + mismatches, + insertions, + deletions, + double_gap_columns, + insertion_opens, + deletion_opens, + positives, + } +} + +///| +/// Return exact identity divided by columns where both rows have residues. +pub fn AlignEmbossPairCounts::identity(self : AlignEmbossPairCounts) -> Double { + if self.aligned == 0 { + 0.0 + } else { + self.identities.to_double() / self.aligned.to_double() + } +} + +///| +/// Return a compact alignment description. +pub fn AlignEmbossAlignment::summary(self : AlignEmbossAlignment) -> String { + "EMBOSS alignment(rows=" + + self.sequences.length().to_string() + + ", columns=" + + self.alignment_length().to_string() + + ", matrix=" + + self.annotations.matrix + + ")" +} + +///| +/// Return a compact report description. +pub fn AlignEmbossDocument::summary(self : AlignEmbossDocument) -> String { + "EMBOSS report(program=" + + self.metadata.program + + ", format=" + + self.metadata.align_format + + ", alignments=" + + self.alignments.length().to_string() + + ")" +} + +///| +/// Small EMBOSS srspair document used by tests and examples. +pub fn align_emboss_example_text() -> String { + "########################################\n" + + "# Program: water\n" + + "# Rundate: Wed Jan 16 17:23:19 2002\n" + + "# Commandline: water\n" + + "# -asequence reference.fa\n" + + "# -bsequence query.fa\n" + + "# Align_format: srspair\n" + + "# Report_file: stdout\n" + + "########################################\n" + + "#=======================================\n" + + "#\n" + + "# Aligned_sequences: 2\n" + + "# 1: reference_sequence\n" + + "# 2: query_sequence\n" + + "# Matrix: EDNAFULL\n" + + "# Gap_penalty: 10.0\n" + + "# Extend_penalty: 0.5\n" + + "#\n" + + "# Length: 18\n" + + "# Identity: 16/18 (88.9%)\n" + + "# Similarity: 17/18 (94.4%)\n" + + "# Gaps: 1/18 ( 5.6%)\n" + + "# Score: 72.5\n" + + "#\n" + + "#=======================================\n" + + "reference_seq 79 ACGTTGAGT-CTGGGATG 95\n" + + " ||||||||| ||||:|||\n" + + "query_sequence 1 ACGTTGAGTACTGGAATG 18\n" + + "#---------------------------------------\n" + + "#---------------------------------------\n" +} + +///| +fn align_emboss_parse_alignment( + lines : Array[String], + start_index : Int, + metadata : AlignEmbossMetadata, +) -> (AlignEmbossAlignment, Int) raise AlignEmbossError { + let mut index = start_index + 1 + let identifiers : Array[String] = [] + let mut number_of_sequences = -1 + let mut length = -1 + let mut matrix = "" + let mut gap_penalty : Double? = None + let mut extend_penalty : Double? = None + let mut identity : Int? = None + let mut similarity : Int? = None + let mut gaps : Int? = None + let mut score : Double? = None + let mut longest_identity = "" + let mut longest_similarity = "" + let mut shortest_identity = "" + let mut shortest_similarity = "" + let mut metadata_closed = false + while index < lines.length() { + let line = lines[index] + let trimmed = line.trim().to_owned() + if trimmed == "#=======================================" { + metadata_closed = true + index = index + 1 + break + } + if trimmed == "#" || trimmed.length() == 0 { + index = index + 1 + continue + } + if !align_emboss_has_prefix(line, "# ") { + raise AlignEmbossError( + "Unexpected EMBOSS alignment header line " + (index + 1).to_string(), + ) + } + let content = line[2:].to_owned() + let (key, value) = align_emboss_split_annotation(content, index + 1) + if key == "Aligned_sequences" { + if number_of_sequences >= 0 { + raise AlignEmbossError("Duplicate EMBOSS Aligned_sequences") + } + number_of_sequences = align_emboss_parse_positive_int( + value, + "Aligned_sequences", + index + 1, + ) + index = index + 1 + for expected = 1; expected <= number_of_sequences; expected = expected + 1 { + if index >= lines.length() || + !align_emboss_has_prefix(lines[index], "# ") { + raise AlignEmbossError("Truncated EMBOSS sequence identifier list") + } + let (number_text, identifier) = align_emboss_split_key_value( + lines[index][2:].to_owned(), + "sequence identifier", + index + 1, + ) + let number = align_emboss_parse_positive_int( + number_text, + "sequence number", + index + 1, + ) + if number != expected { + raise AlignEmbossError( + "Non-contiguous EMBOSS sequence identifier numbering", + ) + } + align_emboss_validate_id(identifier) + identifiers.push(identifier) + index = index + 1 + } + continue + } + match key { + "Matrix" => matrix = value + "Gap_penalty" => + gap_penalty = Some( + align_emboss_parse_number(value, "Gap_penalty", index + 1), + ) + "Extend_penalty" => + extend_penalty = Some( + align_emboss_parse_number(value, "Extend_penalty", index + 1), + ) + "Length" => + length = align_emboss_parse_positive_int(value, "Length", index + 1) + "Identity" => + identity = Some( + align_emboss_parse_fraction_count(value, "Identity", index + 1), + ) + "Similarity" => + similarity = Some( + align_emboss_parse_fraction_count(value, "Similarity", index + 1), + ) + "Gaps" => + gaps = Some(align_emboss_parse_fraction_count(value, "Gaps", index + 1)) + "Score" => + score = Some(align_emboss_parse_number(value, "Score", index + 1)) + "Longest_Identity" => longest_identity = value + "Longest_Similarity" => longest_similarity = value + "Shortest_Identity" => shortest_identity = value + "Shortest_Similarity" => shortest_similarity = value + _ => + raise AlignEmbossError( + "Unknown EMBOSS alignment annotation '" + key + "'", + ) + } + index = index + 1 + } + if !metadata_closed { + raise AlignEmbossError("Truncated EMBOSS alignment header") + } + if number_of_sequences <= 0 || identifiers.length() != number_of_sequences { + raise AlignEmbossError("Number of EMBOSS sequences is missing") + } + if length <= 0 { + raise AlignEmbossError("Length of EMBOSS alignment is missing") + } + let annotations = AlignEmbossAnnotations::create( + length, + matrix~, + gap_penalty~, + extend_penalty~, + identity~, + similarity~, + gaps~, + score~, + longest_identity~, + longest_similarity~, + shortest_identity~, + shortest_similarity~, + ) + let aligned_rows : Array[String] = [] + let ungapped_rows : Array[String] = [] + let starts : Array[Int] = [] + let ends : Array[Int] = [] + let directions : Array[Int] = [] + for _row = 0; _row < number_of_sequences; _row = _row + 1 { + aligned_rows.push("") + ungapped_rows.push("") + starts.push(0) + ends.push(0) + directions.push(0) + } + let consensus_builder = StringBuilder::new(size_hint=length) + let mut consensus_seen = false + let mut row_index = 0 + let mut block_width = 0 + while index < lines.length() { + let line = lines[index] + let trimmed = line.trim().to_owned() + if align_emboss_is_separator(trimmed) { + index = index + 1 + break + } + if trimmed.length() == 0 && line.length() < 21 { + if row_index == number_of_sequences { + row_index = 0 + block_width = 0 + } + index = index + 1 + continue + } + if line.length() < 21 { + raise AlignEmbossError( + "Malformed EMBOSS alignment body at line " + (index + 1).to_string(), + ) + } + let prefix = line[0:21].to_owned().trim().to_owned() + if prefix.length() == 0 { + if block_width <= 0 { + raise AlignEmbossError( + "EMBOSS consensus appears before a sequence block", + ) + } + let raw = line[21:].to_owned() + let chunk = align_emboss_consensus_chunk(raw, block_width, index + 1) + consensus_builder.write_string(chunk) + consensus_seen = true + index = index + 1 + continue + } + if row_index == number_of_sequences { + row_index = 0 + block_width = 0 + } + let prefix_words = align_emboss_split_whitespace(prefix) + if prefix_words.length() != 2 { + raise AlignEmbossError( + "Malformed EMBOSS sequence prefix at line " + (index + 1).to_string(), + ) + } + let printed_id = prefix_words[0] + if !align_emboss_has_prefix(identifiers[row_index], printed_id) { + raise AlignEmbossError( + "Unexpected EMBOSS sequence identifier at line " + + (index + 1).to_string(), + ) + } + let printed_start = align_emboss_parse_nonnegative_int( + prefix_words[1], + "sequence start", + index + 1, + ) + let suffix_words = align_emboss_split_whitespace(line[21:].to_owned()) + if suffix_words.length() != 2 { + raise AlignEmbossError( + "Malformed EMBOSS sequence fields at line " + (index + 1).to_string(), + ) + } + let fragment = suffix_words[0] + align_emboss_validate_aligned_fragment( + fragment, + "line " + (index + 1).to_string(), + ) + let printed_end = align_emboss_parse_nonnegative_int( + suffix_words[1], + "sequence end", + index + 1, + ) + if block_width == 0 { + block_width = fragment.length() + } else if fragment.length() != block_width { + raise AlignEmbossError( + "Inconsistent EMBOSS sequence block width at line " + + (index + 1).to_string(), + ) + } + let ungapped = align_emboss_remove_gaps(fragment) + let consumed = ungapped.length() + let previous_total = ungapped_rows[row_index].length() + if previous_total == 0 && consumed > 0 { + if printed_start < printed_end { + let start_boundary = printed_start - 1 + if printed_start <= 0 || printed_end != start_boundary + consumed { + raise AlignEmbossError( + "Invalid forward EMBOSS coordinates at line " + + (index + 1).to_string(), + ) + } + starts[row_index] = start_boundary + ends[row_index] = printed_end + directions[row_index] = 1 + } else if printed_start > printed_end { + let end_boundary = printed_end - 1 + if printed_end <= 0 || end_boundary != printed_start - consumed { + raise AlignEmbossError( + "Invalid reverse EMBOSS coordinates at line " + + (index + 1).to_string(), + ) + } + starts[row_index] = printed_start + ends[row_index] = end_boundary + directions[row_index] = -1 + } else { + if consumed != 1 || printed_start <= 0 { + raise AlignEmbossError( + "Ambiguous EMBOSS coordinates at line " + (index + 1).to_string(), + ) + } + // A one-residue block prints the same coordinate in either direction. + // Keep the one-based residue coordinate until another block resolves it. + starts[row_index] = printed_start + ends[row_index] = printed_end + directions[row_index] = 0 + } + } else if consumed == 0 { + if directions[row_index] >= 0 { + if printed_start != ends[row_index] || printed_end != printed_start { + raise AlignEmbossError( + "Invalid forward gap-only EMBOSS coordinates at line " + + (index + 1).to_string(), + ) + } + } else if printed_start - 1 != ends[row_index] || + printed_end != printed_start { + raise AlignEmbossError( + "Invalid reverse gap-only EMBOSS coordinates at line " + + (index + 1).to_string(), + ) + } + } else if directions[row_index] > 0 { + let start_boundary = printed_start - 1 + if printed_start <= 0 || + start_boundary != ends[row_index] || + printed_end != start_boundary + consumed { + raise AlignEmbossError( + "Discontinuous forward EMBOSS coordinates at line " + + (index + 1).to_string(), + ) + } + ends[row_index] = printed_end + } else if directions[row_index] < 0 { + let end_boundary = printed_end - 1 + if printed_end <= 0 || + printed_start != ends[row_index] || + end_boundary != printed_start - consumed { + raise AlignEmbossError( + "Discontinuous reverse EMBOSS coordinates at line " + + (index + 1).to_string(), + ) + } + ends[row_index] = end_boundary + } else if printed_start == ends[row_index] + 1 { + let start_boundary = printed_start - 1 + if printed_end != start_boundary + consumed { + raise AlignEmbossError( + "Discontinuous forward EMBOSS coordinates at line " + + (index + 1).to_string(), + ) + } + starts[row_index] = starts[row_index] - 1 + ends[row_index] = printed_end + directions[row_index] = 1 + } else if printed_start + 1 == ends[row_index] { + let end_boundary = printed_end - 1 + if printed_end <= 0 || end_boundary != printed_start - consumed { + raise AlignEmbossError( + "Discontinuous reverse EMBOSS coordinates at line " + + (index + 1).to_string(), + ) + } + ends[row_index] = end_boundary + directions[row_index] = -1 + } else { + raise AlignEmbossError( + "Cannot determine EMBOSS row orientation at line " + + (index + 1).to_string(), + ) + } + aligned_rows[row_index] = aligned_rows[row_index] + fragment + ungapped_rows[row_index] = ungapped_rows[row_index] + ungapped + row_index = row_index + 1 + index = index + 1 + } + let sequences : Array[AlignEmbossSequence] = [] + for row = 0; row < number_of_sequences; row = row + 1 { + if directions[row] == 0 && ungapped_rows[row].length() == 1 { + starts[row] = starts[row] - 1 + directions[row] = 1 + } + if aligned_rows[row].length() != length { + raise AlignEmbossError( + "EMBOSS row '" + + identifiers[row] + + "' has width " + + aligned_rows[row].length().to_string() + + "; expected " + + length.to_string(), + ) + } + sequences.push( + AlignEmbossSequence::create( + identifiers[row], + aligned_rows[row], + starts[row], + ends[row], + ), + ) + } + let consensus = if consensus_seen { + let value = consensus_builder.to_string() + if value.length() != length { + raise AlignEmbossError( + "EMBOSS consensus width does not match declared Length", + ) + } + value + } else { + "" + } + let alignment = AlignEmbossAlignment::create( + sequences, + annotations, + consensus~, + ) + align_emboss_validate_reported_counts(alignment) + ignore(metadata) + (alignment, index) +} + +///| +fn align_emboss_validate_alignment( + alignment : AlignEmbossAlignment, +) -> Unit raise AlignEmbossError { + if alignment.sequences.length() == 0 { + raise AlignEmbossError("EMBOSS alignment must contain a sequence") + } + if alignment.annotations.length <= 0 { + raise AlignEmbossError("EMBOSS alignment length must be positive") + } + for sequence in alignment.sequences { + align_emboss_validate_id(sequence.id) + if sequence.aligned_sequence.length() != alignment.annotations.length { + raise AlignEmbossError( + "EMBOSS sequence width does not match alignment length", + ) + } + align_emboss_validate_aligned_fragment( + sequence.aligned_sequence, + "sequence row", + ) + if align_emboss_remove_gaps(sequence.aligned_sequence) != sequence.sequence { + raise AlignEmbossError("EMBOSS ungapped sequence is inconsistent") + } + let span = if sequence.start >= sequence.end { + sequence.start - sequence.end + } else { + sequence.end - sequence.start + } + if span != sequence.sequence.length() { + raise AlignEmbossError("EMBOSS sequence coordinate span is inconsistent") + } + if sequence.start <= sequence.end && sequence.strand != AlignEmbossForward { + raise AlignEmbossError("EMBOSS sequence strand is inconsistent") + } + if sequence.start > sequence.end && sequence.strand != AlignEmbossReverse { + raise AlignEmbossError("EMBOSS sequence strand is inconsistent") + } + } + if alignment.consensus.length() != 0 && + alignment.consensus.length() != alignment.annotations.length { + raise AlignEmbossError("EMBOSS consensus width must match alignment length") + } + for index = 0; index < alignment.consensus.length(); index = index + 1 { + let code = alignment.consensus.unsafe_get(index).to_int() + if code < 32 || code > 126 { + raise AlignEmbossError("EMBOSS consensus contains a control character") + } + } +} + +///| +fn align_emboss_validate_reported_counts( + alignment : AlignEmbossAlignment, +) -> Unit raise AlignEmbossError { + if alignment.sequences.length() != 2 { + return + } + let counts = alignment.pair_counts(0, 1) + match alignment.annotations.identity { + Some(value) => + if value != counts.identities { + raise AlignEmbossError( + "Reported EMBOSS Identity does not match sequence rows", + ) + } + None => () + } + match alignment.annotations.gaps { + Some(value) => + if value != + counts.insertions + counts.deletions + counts.double_gap_columns { + raise AlignEmbossError( + "Reported EMBOSS Gaps does not match sequence rows", + ) + } + None => () + } + match alignment.annotations.similarity { + Some(value) => + if alignment.consensus.length() == alignment.alignment_length() && + value != counts.positives { + raise AlignEmbossError( + "Reported EMBOSS Similarity does not match consensus", + ) + } + None => () + } +} + +///| +fn align_emboss_validate_row( + alignment : AlignEmbossAlignment, + row : Int, +) -> Unit raise AlignEmbossError { + if row < 0 || row >= alignment.sequences.length() { + raise AlignEmbossError("EMBOSS row index is out of range") + } +} + +///| +fn align_emboss_boundary_at( + sequence : AlignEmbossSequence, + column : Int, +) -> Int { + let mut consumed = 0 + for index = 0; index < column; index = index + 1 { + if sequence.aligned_sequence.unsafe_get(index).to_int() != '-'.to_int() { + consumed = consumed + 1 + } + } + if sequence.strand == AlignEmbossForward { + sequence.start + consumed + } else { + sequence.start - consumed + } +} + +///| +fn align_emboss_column_step( + sequence : AlignEmbossSequence, + column : Int, +) -> Int { + if sequence.aligned_sequence.unsafe_get(column).to_int() == '-'.to_int() { + 0 + } else if sequence.strand == AlignEmbossForward { + 1 + } else { + -1 + } +} + +///| +fn align_emboss_printed_coordinates( + sequence : AlignEmbossSequence, + boundary : Int, + residues : Int, +) -> (Int, Int) { + if sequence.strand == AlignEmbossForward { + if residues == 0 { + (boundary, boundary) + } else { + (boundary + 1, boundary + residues) + } + } else if residues == 0 { + (boundary + 1, boundary + 1) + } else { + (boundary, boundary - residues + 1) + } +} + +///| +fn align_emboss_sequence_prefix(id : String, start : Int) -> String { + let displayed = if id.length() > 13 { id[0:13].to_owned() } else { id } + align_emboss_pad_right(displayed, 13) + + " " + + align_emboss_pad_left(start.to_string(), 6) + + " " +} + +///| +fn align_emboss_pad_left(text : String, width : Int) -> String { + if text.length() >= width { + text + } else { + " ".repeat(width - text.length()) + text + } +} + +///| +fn align_emboss_pad_right(text : String, width : Int) -> String { + if text.length() >= width { + text + } else { + text + " ".repeat(width - text.length()) + } +} + +///| +fn align_emboss_consensus_chunk( + raw : String, + width : Int, + line_number : Int, +) -> String raise AlignEmbossError { + if raw.length() <= width { + raw + " ".repeat(width - raw.length()) + } else { + let extra = raw[width:].to_owned() + if extra.trim().length() > 0 { + raise AlignEmbossError( + "EMBOSS consensus exceeds block width at line " + + line_number.to_string(), + ) + } + raw[0:width].to_owned() + } +} + +///| +fn align_emboss_split_annotation( + content : String, + line_number : Int, +) -> (String, String) raise AlignEmbossError { + let colon = align_emboss_find_char(content, ':'.to_int()) + if colon >= 0 { + return ( + content[0:colon].trim().to_owned(), + content[colon + 1:].trim().to_owned(), + ) + } + let marker = " = " + let equal = align_emboss_find_substring(content, marker) + if equal >= 0 { + return ( + content[0:equal].trim().to_owned(), + content[equal + marker.length():].trim().to_owned(), + ) + } + raise AlignEmbossError( + "Malformed EMBOSS annotation at line " + line_number.to_string(), + ) +} + +///| +fn align_emboss_split_key_value( + content : String, + context : String, + line_number : Int, +) -> (String, String) raise AlignEmbossError { + let separator = align_emboss_find_char(content, ':'.to_int()) + if separator <= 0 { + raise AlignEmbossError( + "Malformed EMBOSS " + context + " at line " + line_number.to_string(), + ) + } + let key = content[0:separator].trim().to_owned() + let value = content[separator + 1:].trim().to_owned() + if key.length() == 0 || value.length() == 0 { + raise AlignEmbossError( + "Empty EMBOSS " + context + " field at line " + line_number.to_string(), + ) + } + (key, value) +} + +///| +fn align_emboss_parse_fraction_count( + text : String, + field : String, + line_number : Int, +) -> Int raise AlignEmbossError { + let slash = align_emboss_find_char(text, '/'.to_int()) + let count_text = if slash < 0 { + text + } else { + text[0:slash].trim().to_owned() + } + align_emboss_parse_nonnegative_int(count_text, field, line_number) +} + +///| +fn align_emboss_parse_positive_int( + text : String, + field : String, + line_number : Int, +) -> Int raise AlignEmbossError { + let value = align_emboss_parse_nonnegative_int(text, field, line_number) + if value <= 0 { + raise AlignEmbossError( + "EMBOSS " + field + " must be positive at line " + line_number.to_string(), + ) + } + value +} + +///| +fn align_emboss_parse_nonnegative_int( + text : String, + field : String, + line_number : Int, +) -> Int raise AlignEmbossError { + if text.length() == 0 { + raise AlignEmbossError( + "Empty EMBOSS " + field + " at line " + line_number.to_string(), + ) + } + let mut value = 0 + for index = 0; index < text.length(); index = index + 1 { + let code = text.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + raise AlignEmbossError( + "Invalid EMBOSS " + field + " at line " + line_number.to_string(), + ) + } + value = value * 10 + code - '0'.to_int() + } + value +} + +///| +fn align_emboss_parse_number( + text : String, + field : String, + line_number : Int, +) -> Double raise AlignEmbossError { + if text.length() == 0 { + raise AlignEmbossError( + "Empty EMBOSS " + field + " at line " + line_number.to_string(), + ) + } + let mut has_digit = false + for index = 0; index < text.length(); index = index + 1 { + let code = text.unsafe_get(index).to_int() + if code >= '0'.to_int() && code <= '9'.to_int() { + has_digit = true + } else if code != '-'.to_int() && + code != '+'.to_int() && + code != '.'.to_int() && + code != 'e'.to_int() && + code != 'E'.to_int() { + raise AlignEmbossError( + "Invalid EMBOSS " + field + " at line " + line_number.to_string(), + ) + } + } + if !has_digit { + raise AlignEmbossError( + "Invalid EMBOSS " + field + " at line " + line_number.to_string(), + ) + } + match parse_double(text) { + Some(value) => + if value.abs() > 1.0e300 { + raise AlignEmbossError( + "Non-finite EMBOSS " + field + " at line " + line_number.to_string(), + ) + } else { + value + } + None => + raise AlignEmbossError( + "Invalid EMBOSS " + field + " at line " + line_number.to_string(), + ) + } +} + +///| +fn align_emboss_validate_id(id : String) -> Unit raise AlignEmbossError { + if id.length() == 0 { + raise AlignEmbossError("EMBOSS sequence identifier must not be empty") + } + for index = 0; index < id.length(); index = index + 1 { + let code = id.unsafe_get(index).to_int() + if code <= 32 || code == 127 { + raise AlignEmbossError( + "EMBOSS sequence identifier must not contain whitespace", + ) + } + } +} + +///| +fn align_emboss_validate_header_value( + value : String, + field : String, +) -> Unit raise AlignEmbossError { + for index = 0; index < value.length(); index = index + 1 { + let code = value.unsafe_get(index).to_int() + if code == '\n'.to_int() || code == '\r'.to_int() { + raise AlignEmbossError("EMBOSS " + field + " must not contain a newline") + } + } +} + +///| +fn align_emboss_validate_aligned_fragment( + fragment : String, + context : String, +) -> Unit raise AlignEmbossError { + if fragment.length() == 0 { + raise AlignEmbossError("Empty EMBOSS aligned fragment in " + context) + } + for index = 0; index < fragment.length(); index = index + 1 { + let code = fragment.unsafe_get(index).to_int() + if code <= 32 || code > 126 { + raise AlignEmbossError("Invalid EMBOSS aligned character in " + context) + } + } +} + +///| +fn align_emboss_validate_optional_count( + value : Int?, + length : Int, + field : String, +) -> Unit raise AlignEmbossError { + match value { + Some(count) => + if count < 0 || count > length { + raise AlignEmbossError( + "EMBOSS " + field + " must be between zero and Length", + ) + } + None => () + } +} + +///| +fn align_emboss_validate_optional_nonnegative_double( + value : Double?, + field : String, +) -> Unit raise AlignEmbossError { + match value { + Some(number) => + if number < 0.0 || number.abs() > 1.0e300 { + raise AlignEmbossError( + "EMBOSS " + field + " must be finite and non-negative", + ) + } + None => () + } +} + +///| +fn align_emboss_remove_gaps(sequence : String) -> String { + let result = StringBuilder::new(size_hint=sequence.length()) + for index = 0; index < sequence.length(); index = index + 1 { + let code = sequence.unsafe_get(index).to_int() + if code != '-'.to_int() { + result.write_char(code.unsafe_to_char()) + } + } + result.to_string() +} + +///| +fn align_emboss_count_residues(sequence : String) -> Int { + let mut count = 0 + for index = 0; index < sequence.length(); index = index + 1 { + if sequence.unsafe_get(index).to_int() != '-'.to_int() { + count = count + 1 + } + } + count +} + +///| +fn align_emboss_lines(text : String) -> Array[String] { + let raw = text.split("\n") + let lines : Array[String] = [] + for line in raw { + let owned = line.to_owned() + if owned.length() > 0 && + owned.unsafe_get(owned.length() - 1).to_int() == '\r'.to_int() { + lines.push(owned[0:owned.length() - 1].to_owned()) + } else { + lines.push(owned) + } + } + lines +} + +///| +fn align_emboss_split_whitespace(text : String) -> Array[String] { + let result : Array[String] = [] + let mut index = 0 + while index < text.length() { + while index < text.length() && + align_emboss_is_whitespace(text.unsafe_get(index).to_int()) { + index = index + 1 + } + if index >= text.length() { + break + } + let start = index + while index < text.length() && + !align_emboss_is_whitespace(text.unsafe_get(index).to_int()) { + index = index + 1 + } + result.push(text[start:index].to_owned()) + } + result +} + +///| +fn align_emboss_is_whitespace(code : Int) -> Bool { + code == ' '.to_int() || + code == '\t'.to_int() || + code == '\r'.to_int() || + code == '\n'.to_int() +} + +///| +fn align_emboss_has_prefix(text : String, prefix : String) -> Bool { + if prefix.length() > text.length() { + return false + } + for index = 0; index < prefix.length(); index = index + 1 { + if text.unsafe_get(index).to_int() != prefix.unsafe_get(index).to_int() { + return false + } + } + true +} + +///| +fn align_emboss_is_separator(text : String) -> Bool { + text == "#---------------------------------------" +} + +///| +fn align_emboss_find_char(text : String, target : Int) -> Int { + for index = 0; index < text.length(); index = index + 1 { + if text.unsafe_get(index).to_int() == target { + return index + } + } + -1 +} + +///| +fn align_emboss_find_substring(text : String, target : String) -> Int { + if target.length() == 0 { + return 0 + } + if target.length() > text.length() { + return -1 + } + for start = 0; start <= text.length() - target.length(); start = start + 1 { + let mut equal = true + for offset = 0; offset < target.length(); offset = offset + 1 { + if text.unsafe_get(start + offset).to_int() != + target.unsafe_get(offset).to_int() { + equal = false + break + } + } + if equal { + return start + } + } + -1 +} + +///| +fn align_emboss_write_optional_double( + output : StringBuilder, + key : String, + value : Double?, +) -> Unit { + match value { + Some(number) => + output.write_string("# " + key + ": " + number.to_string() + "\n") + None => () + } +} + +///| +fn align_emboss_write_optional_count( + output : StringBuilder, + key : String, + value : Int?, + length : Int, +) -> Unit { + match value { + Some(count) => + output.write_string( + "# " + key + ": " + count.to_string() + "/" + length.to_string() + "\n", + ) + None => () + } +} + +///| +fn align_emboss_write_long_annotation( + output : StringBuilder, + key : String, + value : String, +) -> Unit { + if value.length() > 0 { + output.write_string("# " + key + " = " + value + "\n") + } +} diff --git a/src/align_exonerate.mbt b/src/align_exonerate.mbt new file mode 100644 index 00000000..7f78318b --- /dev/null +++ b/src/align_exonerate.mbt @@ -0,0 +1,1319 @@ +// Alignment-aware Exonerate cigar/vulgar support. +// +// This module follows Biopython 1.86 Bio.Align.exonerate semantics. Exonerate +// coordinates are zero-based boundaries. Operations keep query and target +// steps separately so DNA/protein 3:1 alignments do not lose information. + +///| +/// Error raised for malformed alignment-aware Exonerate data. +pub suberror AlignExonerateError { + AlignExonerateError(String) +} + +///| +/// Orientation or molecule type reported for an Exonerate sequence. +pub(all) enum AlignExonerateStrand { + AlignExonerateForward + AlignExonerateReverse + AlignExonerateProtein +} derive(Eq, Debug) + +///| +/// File-level Exonerate metadata. +pub struct AlignExonerateMetadata { + program : String + command_line : String + hostname : String +} derive(Eq, Debug) + +///| +/// One normalized Exonerate path operation. +/// +/// Codes use alignment-aware semantics: +/// `M` match, `5`/`3` splice sites, `N` intron, `C` codon, `D` deletion, +/// `I` insertion, `U` non-equivalenced region, `S` split codon, and `F` +/// frame shift. Steps are non-negative molecular coordinates. +pub struct AlignExonerateOperation { + code : String + query_step : Int + target_step : Int +} derive(Eq, Debug) + +///| +/// One pairwise alignment from an Exonerate report. +pub struct AlignExonerateAlignment { + query_id : String + query_start : Int + query_end : Int + query_strand : AlignExonerateStrand + target_id : String + target_start : Int + target_end : Int + target_strand : AlignExonerateStrand + score : Double + operations : Array[AlignExonerateOperation] +} derive(Eq, Debug) + +///| +/// A complete Exonerate report. +pub struct AlignExonerateDocument { + metadata : AlignExonerateMetadata + alignments : Array[AlignExonerateAlignment] +} derive(Eq, Debug) + +///| +/// Operation and coordinate statistics for one Exonerate alignment. +pub struct AlignExonerateCounts { + operations : Int + matching_operations : Int + aligned_query_units : Int + aligned_target_units : Int + insertions : Int + deletions : Int + insertion_opens : Int + deletion_opens : Int + introns : Int + intron_units : Int + non_equivalenced_units : Int + split_codons : Int + frameshifts : Int +} derive(Eq, Debug) + +///| +/// Construct Exonerate file metadata. +pub fn AlignExonerateMetadata::create( + command_line? : String = "", + hostname? : String = "", +) -> AlignExonerateMetadata raise AlignExonerateError { + align_exonerate_validate_header_value(command_line, "Command line") + align_exonerate_validate_header_value(hostname, "Hostname") + AlignExonerateMetadata::{ program: "exonerate", command_line, hostname } +} + +///| +/// Construct and validate one normalized Exonerate operation. +pub fn AlignExonerateOperation::create( + code : String, + query_step : Int, + target_step : Int, +) -> AlignExonerateOperation raise AlignExonerateError { + align_exonerate_validate_operation(code, query_step, target_step) + AlignExonerateOperation::{ code, query_step, target_step } +} + +///| +/// Construct one alignment and validate operation totals against its bounds. +pub fn AlignExonerateAlignment::create( + query_id : String, + query_start : Int, + query_end : Int, + query_strand : AlignExonerateStrand, + target_id : String, + target_start : Int, + target_end : Int, + target_strand : AlignExonerateStrand, + score : Double, + operations : Array[AlignExonerateOperation], +) -> AlignExonerateAlignment raise AlignExonerateError { + align_exonerate_validate_id(query_id, "query") + align_exonerate_validate_id(target_id, "target") + align_exonerate_validate_axis(query_start, query_end, query_strand, "query") + align_exonerate_validate_axis( + target_start, target_end, target_strand, "target", + ) + if score.abs() > 1.0e300 { + raise AlignExonerateError("Exonerate score must be finite") + } + if operations.length() == 0 { + raise AlignExonerateError("Exonerate alignment must contain an operation") + } + let copied : Array[AlignExonerateOperation] = [] + let mut query_span = 0 + let mut target_span = 0 + for operation in operations { + align_exonerate_validate_operation( + operation.code, + operation.query_step, + operation.target_step, + ) + query_span = query_span + operation.query_step + target_span = target_span + operation.target_step + copied.push(operation) + } + if query_span != align_exonerate_abs(query_end - query_start) { + raise AlignExonerateError( + "Exonerate query operation span does not match its coordinates", + ) + } + if target_span != align_exonerate_abs(target_end - target_start) { + raise AlignExonerateError( + "Exonerate target operation span does not match its coordinates", + ) + } + AlignExonerateAlignment::{ + query_id, + query_start, + query_end, + query_strand, + target_id, + target_start, + target_end, + target_strand, + score, + operations: copied, + } +} + +///| +/// Construct a complete report. Exonerate reports with no hits are valid. +pub fn AlignExonerateDocument::create( + metadata : AlignExonerateMetadata, + alignments : Array[AlignExonerateAlignment], +) -> AlignExonerateDocument raise AlignExonerateError { + if metadata.program != "exonerate" { + raise AlignExonerateError("Exonerate metadata program must be exonerate") + } + let copied : Array[AlignExonerateAlignment] = [] + for alignment in alignments { + let validated = AlignExonerateAlignment::create( + alignment.query_id, + alignment.query_start, + alignment.query_end, + alignment.query_strand, + alignment.target_id, + alignment.target_start, + alignment.target_end, + alignment.target_strand, + alignment.score, + alignment.operations, + ) + copied.push(validated) + } + AlignExonerateDocument::{ metadata, alignments: copied } +} + +///| +pub fn AlignExonerateDocument::num_alignments( + self : AlignExonerateDocument, +) -> Int { + self.alignments.length() +} + +///| +pub fn AlignExonerateDocument::get( + self : AlignExonerateDocument, + index : Int, +) -> AlignExonerateAlignment? { + if index < 0 || index >= self.alignments.length() { + None + } else { + Some(self.alignments[index]) + } +} + +///| +pub fn AlignExonerateDocument::find_by_query( + self : AlignExonerateDocument, + query_id : String, +) -> Array[AlignExonerateAlignment] { + let result : Array[AlignExonerateAlignment] = [] + for alignment in self.alignments { + if alignment.query_id == query_id { + result.push(alignment) + } + } + result +} + +///| +pub fn AlignExonerateDocument::best_alignment( + self : AlignExonerateDocument, +) -> AlignExonerateAlignment? { + if self.alignments.length() == 0 { + return None + } + let mut best = self.alignments[0] + for index = 1; index < self.alignments.length(); index = index + 1 { + if self.alignments[index].score > best.score { + best = self.alignments[index] + } + } + Some(best) +} + +///| +pub fn AlignExonerateDocument::summary(self : AlignExonerateDocument) -> String { + "Exonerate report(host=" + + self.metadata.hostname + + ", alignments=" + + self.alignments.length().to_string() + + ")" +} + +///| +pub fn AlignExonerateAlignment::query_length( + self : AlignExonerateAlignment, +) -> Int { + if self.query_strand == AlignExonerateReverse { + self.query_start + } else { + self.query_end + } +} + +///| +pub fn AlignExonerateAlignment::target_length( + self : AlignExonerateAlignment, +) -> Int { + if self.target_strand == AlignExonerateReverse { + self.target_start + } else { + self.target_end + } +} + +///| +pub fn AlignExonerateAlignment::num_operations( + self : AlignExonerateAlignment, +) -> Int { + self.operations.length() +} + +///| +pub fn AlignExonerateAlignment::operation_codes( + self : AlignExonerateAlignment, +) -> String { + let output = StringBuilder::new(size_hint=self.operations.length()) + for operation in self.operations { + output.write_string(operation.code) + } + output.to_string() +} + +///| +/// Return `[target_coordinates, query_coordinates]` boundary paths. +pub fn AlignExonerateAlignment::coordinate_path( + self : AlignExonerateAlignment, +) -> Array[Array[Int]] { + let target = [self.target_start] + let query = [self.query_start] + let target_sign = align_exonerate_strand_sign(self.target_strand) + let query_sign = align_exonerate_strand_sign(self.query_strand) + let mut target_position = self.target_start + let mut query_position = self.query_start + for operation in self.operations { + target_position = target_position + target_sign * operation.target_step + query_position = query_position + query_sign * operation.query_step + target.push(target_position) + query.push(query_position) + } + [target, query] +} + +///| +/// Map an absolute query residue to the corresponding target residue. +/// +/// A target gap returns `None`. For translated alignments, a protein residue +/// maps to the first nucleotide of its codon and each nucleotide maps to its +/// containing protein residue. +pub fn AlignExonerateAlignment::query_position_to_target( + self : AlignExonerateAlignment, + position : Int, +) -> Int? { + align_exonerate_map_position(self, position, true) +} + +///| +/// Map an absolute target residue to the corresponding query residue. +pub fn AlignExonerateAlignment::target_position_to_query( + self : AlignExonerateAlignment, + position : Int, +) -> Int? { + align_exonerate_map_position(self, position, false) +} + +///| +/// Return target/query residue pairs for all query units in aligned segments. +pub fn AlignExonerateAlignment::aligned_pairs( + self : AlignExonerateAlignment, +) -> Array[(Int, Int)] { + let pairs : Array[(Int, Int)] = [] + let query_sign = align_exonerate_strand_sign(self.query_strand) + let target_sign = align_exonerate_strand_sign(self.target_strand) + let mut query_boundary = self.query_start + let mut target_boundary = self.target_start + for operation in self.operations { + if operation.query_step > 0 && operation.target_step > 0 { + for offset = 0; offset < operation.query_step; offset = offset + 1 { + let query_position = if query_sign > 0 { + query_boundary + offset + } else { + query_boundary - 1 - offset + } + let target_offset = offset * + operation.target_step / + operation.query_step + let target_position = if target_sign > 0 { + target_boundary + target_offset + } else { + target_boundary - 1 - target_offset + } + pairs.push((target_position, query_position)) + } + } + query_boundary = query_boundary + query_sign * operation.query_step + target_boundary = target_boundary + target_sign * operation.target_step + } + pairs +} + +///| +/// Calculate operation-aware alignment statistics. +pub fn AlignExonerateAlignment::counts( + self : AlignExonerateAlignment, +) -> AlignExonerateCounts { + let mut matching_operations = 0 + let mut aligned_query_units = 0 + let mut aligned_target_units = 0 + let mut insertions = 0 + let mut deletions = 0 + let mut insertion_opens = 0 + let mut deletion_opens = 0 + let mut introns = 0 + let mut intron_units = 0 + let mut non_equivalenced_units = 0 + let mut split_codons = 0 + let mut frameshifts = 0 + let mut previous_insertion = false + let mut previous_deletion = false + for operation in self.operations { + if operation.query_step > 0 && operation.target_step > 0 { + aligned_query_units = aligned_query_units + operation.query_step + aligned_target_units = aligned_target_units + operation.target_step + if operation.code == "M" || operation.code == "C" { + matching_operations = matching_operations + 1 + } + } + let insertion = operation.target_step == 0 && operation.query_step > 0 + let deletion = operation.query_step == 0 && operation.target_step > 0 + if insertion { + insertions = insertions + operation.query_step + if !previous_insertion { + insertion_opens = insertion_opens + 1 + } + } + if deletion { + deletions = deletions + operation.target_step + if !previous_deletion { + deletion_opens = deletion_opens + 1 + } + } + if operation.code == "N" { + introns = introns + 1 + intron_units = intron_units + operation.query_step + operation.target_step + } else if operation.code == "U" { + non_equivalenced_units = non_equivalenced_units + + operation.query_step + + operation.target_step + } else if operation.code == "S" { + split_codons = split_codons + 1 + } else if operation.code == "F" { + frameshifts = frameshifts + 1 + } + previous_insertion = insertion + previous_deletion = deletion + } + AlignExonerateCounts::{ + operations: self.operations.length(), + matching_operations, + aligned_query_units, + aligned_target_units, + insertions, + deletions, + insertion_opens, + deletion_opens, + introns, + intron_units, + non_equivalenced_units, + split_codons, + frameshifts, + } +} + +///| +pub fn AlignExonerateAlignment::summary( + self : AlignExonerateAlignment, +) -> String { + "Exonerate alignment(query=" + + self.query_id + + ", target=" + + self.target_id + + ", score=" + + self.score.to_string() + + ", operations=" + + self.operations.length().to_string() + + ")" +} + +///| +/// Parse an alignment-aware Exonerate cigar/vulgar report. +pub fn align_exonerate_parse( + text : String, +) -> AlignExonerateDocument raise AlignExonerateError { + let lines = align_exonerate_lines(text) + if lines.length() < 3 { + raise AlignExonerateError("Truncated Exonerate report header") + } + let command_line = align_exonerate_parse_header_line( + lines[0], + "Command line: ", + "Command line", + 1, + ) + let hostname = align_exonerate_parse_header_line( + lines[1], + "Hostname: ", + "Hostname", + 2, + ) + let metadata = AlignExonerateMetadata::create(command_line~, hostname~) + let alignments : Array[AlignExonerateAlignment] = [] + let mut footer_seen = false + for index = 2; index < lines.length(); index = index + 1 { + let trimmed = lines[index].trim().to_owned() + if footer_seen { + if trimmed.length() > 0 { + raise AlignExonerateError( + "Additional data after Exonerate completion marker at line " + + (index + 1).to_string(), + ) + } + continue + } + if trimmed.length() == 0 { + continue + } + if trimmed == "-- completed exonerate analysis" { + footer_seen = true + } else if trimmed.has_prefix("vulgar: ") { + alignments.push( + align_exonerate_parse_vulgar_line(trimmed[8:].to_owned(), index + 1), + ) + } else if trimmed.has_prefix("cigar: ") { + alignments.push( + align_exonerate_parse_cigar_line(trimmed[7:].to_owned(), index + 1), + ) + } else { + raise AlignExonerateError( + "Unexpected Exonerate body line at line " + (index + 1).to_string(), + ) + } + } + if !footer_seen { + raise AlignExonerateError( + "Failed to find completed Exonerate analysis marker", + ) + } + AlignExonerateDocument::create(metadata, alignments) +} + +///| +/// Serialize a complete report as canonical `vulgar` or `cigar` output. +pub fn align_exonerate_write( + document : AlignExonerateDocument, + format? : String = "vulgar", +) -> String raise AlignExonerateError { + if format != "vulgar" && format != "cigar" { + raise AlignExonerateError("Exonerate output format must be vulgar or cigar") + } + let validated = AlignExonerateDocument::create( + document.metadata, + document.alignments, + ) + let output = StringBuilder::new() + output.write_string( + "Command line: [" + validated.metadata.command_line + "]\n", + ) + output.write_string("Hostname: [" + validated.metadata.hostname + "]\n") + for alignment in validated.alignments { + if format == "vulgar" { + output.write_string(align_exonerate_format_vulgar(alignment)) + } else { + output.write_string(align_exonerate_format_cigar(alignment)) + } + } + output.write_string("-- completed exonerate analysis\n") + output.to_string() +} + +///| +fn align_exonerate_parse_vulgar_line( + content : String, + line_number : Int, +) -> AlignExonerateAlignment raise AlignExonerateError { + let words = align_exonerate_split_whitespace(content) + if words.length() < 12 || (words.length() - 9) % 3 != 0 { + raise AlignExonerateError( + "Malformed Exonerate vulgar field count at line " + + line_number.to_string(), + ) + } + let query_id = words[0] + let query_start = align_exonerate_parse_int( + words[1], + "query start", + line_number, + ) + let query_end = align_exonerate_parse_int(words[2], "query end", line_number) + let query_strand = align_exonerate_parse_strand( + words[3], + "query", + line_number, + ) + let target_id = words[4] + let target_start = align_exonerate_parse_int( + words[5], + "target start", + line_number, + ) + let target_end = align_exonerate_parse_int( + words[6], + "target end", + line_number, + ) + let target_strand = align_exonerate_parse_strand( + words[7], + "target", + line_number, + ) + let score = align_exonerate_parse_score(words[8], line_number) + let operations : Array[AlignExonerateOperation] = [] + let mut index = 9 + while index < words.length() { + let raw_code = words[index] + let query_step = align_exonerate_parse_int( + words[index + 1], + "query step", + line_number, + ) + let target_step = align_exonerate_parse_int( + words[index + 2], + "target step", + line_number, + ) + if raw_code == "G" { + if query_step == 0 && target_step > 0 { + operations.push(AlignExonerateOperation::create("D", 0, target_step)) + } else if target_step == 0 && query_step > 0 { + operations.push(AlignExonerateOperation::create("I", query_step, 0)) + } else { + raise AlignExonerateError( + "Exonerate vulgar gap must advance exactly one sequence at line " + + line_number.to_string(), + ) + } + } else if raw_code == "I" { + operations.push( + AlignExonerateOperation::create("N", query_step, target_step), + ) + } else if raw_code == "N" { + if target_step > 0 { + operations.push(AlignExonerateOperation::create("U", 0, target_step)) + } + if query_step > 0 { + operations.push(AlignExonerateOperation::create("U", query_step, 0)) + } + if query_step == 0 && target_step == 0 { + raise AlignExonerateError( + "Empty Exonerate non-equivalenced operation at line " + + line_number.to_string(), + ) + } + } else { + operations.push( + AlignExonerateOperation::create(raw_code, query_step, target_step), + ) + } + index = index + 3 + } + AlignExonerateAlignment::create( + query_id, query_start, query_end, query_strand, target_id, target_start, target_end, + target_strand, score, operations, + ) +} + +///| +fn align_exonerate_parse_cigar_line( + content : String, + line_number : Int, +) -> AlignExonerateAlignment raise AlignExonerateError { + let words = align_exonerate_split_whitespace(content) + if words.length() < 11 || (words.length() - 9) % 2 != 0 { + raise AlignExonerateError( + "Malformed Exonerate cigar field count at line " + line_number.to_string(), + ) + } + let query_id = words[0] + let query_start = align_exonerate_parse_int( + words[1], + "query start", + line_number, + ) + let query_end = align_exonerate_parse_int(words[2], "query end", line_number) + let query_strand = align_exonerate_parse_strand( + words[3], + "query", + line_number, + ) + let target_id = words[4] + let target_start = align_exonerate_parse_int( + words[5], + "target start", + line_number, + ) + let target_end = align_exonerate_parse_int( + words[6], + "target end", + line_number, + ) + let target_strand = align_exonerate_parse_strand( + words[7], + "target", + line_number, + ) + let score = align_exonerate_parse_score(words[8], line_number) + let operations : Array[AlignExonerateOperation] = [] + let mut raw_query = 0 + let mut raw_target = 0 + let mut normalized_query = 0 + let mut normalized_target = 0 + let mut index = 9 + while index < words.length() { + let code = words[index] + let step = align_exonerate_parse_positive_int( + words[index + 1], + "cigar step", + line_number, + ) + if code == "M" { + raw_query = raw_query + step + raw_target = raw_target + step + } else if code == "I" { + if query_strand == AlignExonerateProtein && + target_strand != AlignExonerateProtein { + raw_query = raw_query + step * 3 + } else { + raw_query = raw_query + step + } + } else if code == "D" { + if target_strand == AlignExonerateProtein && + query_strand != AlignExonerateProtein { + raw_target = raw_target + step * 3 + } else { + raw_target = raw_target + step + } + } else { + raise AlignExonerateError( + "Unknown Exonerate cigar operation " + + code + + " at line " + + line_number.to_string(), + ) + } + let next_query = align_exonerate_normalize_cigar_offset( + raw_query, query_strand, target_strand, + ) + let next_target = align_exonerate_normalize_cigar_offset( + raw_target, target_strand, query_strand, + ) + let query_step = next_query - normalized_query + let target_step = next_target - normalized_target + operations.push( + AlignExonerateOperation::create(code, query_step, target_step), + ) + normalized_query = next_query + normalized_target = next_target + index = index + 2 + } + AlignExonerateAlignment::create( + query_id, query_start, query_end, query_strand, target_id, target_start, target_end, + target_strand, score, operations, + ) +} + +///| +fn align_exonerate_format_header( + alignment : AlignExonerateAlignment, +) -> Array[String] { + [ + alignment.query_id, + alignment.query_start.to_string(), + alignment.query_end.to_string(), + align_exonerate_strand_symbol(alignment.query_strand), + alignment.target_id, + alignment.target_start.to_string(), + alignment.target_end.to_string(), + align_exonerate_strand_symbol(alignment.target_strand), + alignment.score.to_string(), + ] +} + +///| +fn align_exonerate_format_vulgar( + alignment : AlignExonerateAlignment, +) -> String raise AlignExonerateError { + let words = ["vulgar:"] + for word in align_exonerate_format_header(alignment) { + words.push(word) + } + let mut index = 0 + while index < alignment.operations.length() { + let operation = alignment.operations[index] + if operation.code == "U" { + let mut query_step = 0 + let mut target_step = 0 + while index < alignment.operations.length() && + alignment.operations[index].code == "U" { + query_step = query_step + alignment.operations[index].query_step + target_step = target_step + alignment.operations[index].target_step + index = index + 1 + } + align_exonerate_append_vulgar(words, "N", query_step, target_step) + continue + } + let code = if operation.code == "N" { + "I" + } else if operation.code == "D" || operation.code == "I" { + "G" + } else { + operation.code + } + align_exonerate_append_vulgar( + words, + code, + operation.query_step, + operation.target_step, + ) + index = index + 1 + } + words.join(" ") + "\n" +} + +///| +fn align_exonerate_append_vulgar( + words : Array[String], + code : String, + query_step : Int, + target_step : Int, +) -> Unit { + words.push(code) + words.push(query_step.to_string()) + words.push(target_step.to_string()) +} + +///| +fn align_exonerate_format_cigar( + alignment : AlignExonerateAlignment, +) -> String raise AlignExonerateError { + let words = ["cigar:"] + for word in align_exonerate_format_header(alignment) { + words.push(word) + } + for operation in alignment.operations { + if operation.code == "M" { + let step = if alignment.query_strand == AlignExonerateProtein && + alignment.target_strand != AlignExonerateProtein { + operation.target_step + } else if alignment.target_strand == AlignExonerateProtein && + alignment.query_strand != AlignExonerateProtein { + operation.query_step + } else { + if operation.query_step != operation.target_step { + raise AlignExonerateError( + "Cannot encode unequal non-translated match steps as cigar", + ) + } + operation.query_step + } + align_exonerate_append_cigar(words, "M", step) + } else if operation.code == "5" || operation.code == "3" { + align_exonerate_append_cigar_movement(words, operation) + } else if operation.code == "N" { + align_exonerate_append_cigar_movement(words, operation) + } else if operation.code == "C" { + if operation.query_step != operation.target_step { + raise AlignExonerateError("Cannot encode unequal codon steps as cigar") + } + align_exonerate_append_cigar(words, "M", operation.query_step) + } else if operation.code == "D" { + align_exonerate_append_cigar(words, "D", operation.target_step) + } else if operation.code == "I" { + align_exonerate_append_cigar(words, "I", operation.query_step) + } else if operation.code == "U" || + operation.code == "S" || + operation.code == "F" { + if operation.target_step > 0 { + align_exonerate_append_cigar(words, "D", operation.target_step) + } + if operation.query_step > 0 { + align_exonerate_append_cigar(words, "I", operation.query_step) + } + } else { + raise AlignExonerateError( + "Cannot encode Exonerate operation " + operation.code + " as cigar", + ) + } + } + words.join(" ") + "\n" +} + +///| +fn align_exonerate_append_cigar_movement( + words : Array[String], + operation : AlignExonerateOperation, +) -> Unit raise AlignExonerateError { + if operation.query_step == 0 { + align_exonerate_append_cigar(words, "D", operation.target_step) + } else if operation.target_step == 0 { + align_exonerate_append_cigar(words, "I", operation.query_step) + } else if operation.query_step == operation.target_step { + align_exonerate_append_cigar(words, "M", operation.query_step) + } else { + raise AlignExonerateError( + "Cannot encode two-axis splice/intron movement as cigar", + ) + } +} + +///| +fn align_exonerate_append_cigar( + words : Array[String], + code : String, + step : Int, +) -> Unit raise AlignExonerateError { + if step <= 0 { + raise AlignExonerateError("Exonerate cigar step must be positive") + } + words.push(code) + words.push(step.to_string()) +} + +///| +fn align_exonerate_map_position( + alignment : AlignExonerateAlignment, + position : Int, + from_query : Bool, +) -> Int? { + let query_sign = align_exonerate_strand_sign(alignment.query_strand) + let target_sign = align_exonerate_strand_sign(alignment.target_strand) + let mut query_boundary = alignment.query_start + let mut target_boundary = alignment.target_start + for operation in alignment.operations { + let source_boundary = if from_query { + query_boundary + } else { + target_boundary + } + let source_sign = if from_query { query_sign } else { target_sign } + let source_step = if from_query { + operation.query_step + } else { + operation.target_step + } + let destination_boundary = if from_query { + target_boundary + } else { + query_boundary + } + let destination_sign = if from_query { target_sign } else { query_sign } + let destination_step = if from_query { + operation.target_step + } else { + operation.query_step + } + let offset = if source_sign > 0 { + position - source_boundary + } else { + source_boundary - 1 - position + } + if offset >= 0 && offset < source_step { + if destination_step == 0 { + return None + } + let destination_offset = offset * destination_step / source_step + if destination_sign > 0 { + return Some(destination_boundary + destination_offset) + } + return Some(destination_boundary - 1 - destination_offset) + } + query_boundary = query_boundary + query_sign * operation.query_step + target_boundary = target_boundary + target_sign * operation.target_step + } + None +} + +///| +fn align_exonerate_validate_operation( + code : String, + query_step : Int, + target_step : Int, +) -> Unit raise AlignExonerateError { + if query_step < 0 || target_step < 0 { + raise AlignExonerateError("Exonerate operation steps must be non-negative") + } + if query_step == 0 && target_step == 0 { + raise AlignExonerateError("Exonerate operation must advance a sequence") + } + if code == "M" { + if query_step == 0 || target_step == 0 { + raise AlignExonerateError("Exonerate match must advance both sequences") + } + } else if code == "5" || code == "3" { + if query_step != 2 && target_step != 2 { + raise AlignExonerateError( + "Exonerate splice-site operation must contain a two-unit step", + ) + } + } else if code == "N" { + if (query_step == 0) == (target_step == 0) { + raise AlignExonerateError( + "Exonerate intron must advance exactly one sequence", + ) + } + } else if code == "C" { + if query_step == 0 || + target_step == 0 || + query_step % 3 != 0 || + target_step % 3 != 0 { + raise AlignExonerateError( + "Exonerate codon operation must use positive multiples of three", + ) + } + } else if code == "D" { + if query_step != 0 || target_step <= 0 { + raise AlignExonerateError( + "Exonerate deletion must advance only the target", + ) + } + } else if code == "I" { + if target_step != 0 || query_step <= 0 { + raise AlignExonerateError( + "Exonerate insertion must advance only the query", + ) + } + } else if code == "U" { + if (query_step == 0) == (target_step == 0) { + raise AlignExonerateError( + "Normalized Exonerate U must advance exactly one sequence", + ) + } + } else if code == "S" { + () + } else if code == "F" { + if (query_step == 0) == (target_step == 0) { + raise AlignExonerateError( + "Exonerate frame shift must advance exactly one sequence", + ) + } + } else { + raise AlignExonerateError("Unknown Exonerate operation " + code) + } +} + +///| +fn align_exonerate_validate_axis( + start : Int, + end : Int, + strand : AlignExonerateStrand, + field : String, +) -> Unit raise AlignExonerateError { + if start < 0 || end < 0 { + raise AlignExonerateError( + "Exonerate " + field + " coordinates must be non-negative", + ) + } + if strand == AlignExonerateReverse { + if end >= start { + raise AlignExonerateError( + "Reverse Exonerate " + field + " coordinates must decrease", + ) + } + } else if end <= start { + raise AlignExonerateError( + "Forward/protein Exonerate " + field + " coordinates must increase", + ) + } +} + +///| +fn align_exonerate_validate_id( + id : String, + field : String, +) -> Unit raise AlignExonerateError { + if id.length() == 0 { + raise AlignExonerateError( + "Exonerate " + field + " identifier must not be empty", + ) + } + for index = 0; index < id.length(); index = index + 1 { + let code = id.unsafe_get(index).to_int() + if align_exonerate_is_whitespace(code) || code == 127 { + raise AlignExonerateError( + "Exonerate " + field + " identifier must not contain whitespace", + ) + } + } +} + +///| +fn align_exonerate_validate_header_value( + value : String, + field : String, +) -> Unit raise AlignExonerateError { + for index = 0; index < value.length(); index = index + 1 { + let code = value.unsafe_get(index).to_int() + if code == '\n'.to_int() || code == '\r'.to_int() { + raise AlignExonerateError( + "Exonerate " + field + " must not contain a newline", + ) + } + } +} + +///| +fn align_exonerate_parse_header_line( + line : String, + prefix : String, + field : String, + line_number : Int, +) -> String raise AlignExonerateError { + if !line.has_prefix(prefix) { + raise AlignExonerateError( + "Missing Exonerate " + field + " at line " + line_number.to_string(), + ) + } + let value = line[prefix.length():].trim().to_owned() + if value.length() < 2 || + value.unsafe_get(0).to_int() != '['.to_int() || + value.unsafe_get(value.length() - 1).to_int() != ']'.to_int() { + raise AlignExonerateError( + "Malformed bracketed Exonerate " + + field + + " at line " + + line_number.to_string(), + ) + } + value[1:value.length() - 1].to_owned() +} + +///| +fn align_exonerate_parse_strand( + text : String, + field : String, + line_number : Int, +) -> AlignExonerateStrand raise AlignExonerateError { + if text == "+" { + AlignExonerateForward + } else if text == "-" { + AlignExonerateReverse + } else if text == "." { + AlignExonerateProtein + } else { + raise AlignExonerateError( + "Invalid Exonerate " + + field + + " strand at line " + + line_number.to_string(), + ) + } +} + +///| +fn align_exonerate_strand_symbol(strand : AlignExonerateStrand) -> String { + if strand == AlignExonerateForward { + "+" + } else if strand == AlignExonerateReverse { + "-" + } else { + "." + } +} + +///| +fn align_exonerate_strand_sign(strand : AlignExonerateStrand) -> Int { + if strand == AlignExonerateReverse { + -1 + } else { + 1 + } +} + +///| +fn align_exonerate_parse_positive_int( + text : String, + field : String, + line_number : Int, +) -> Int raise AlignExonerateError { + let value = align_exonerate_parse_int(text, field, line_number) + if value <= 0 { + raise AlignExonerateError( + "Exonerate " + + field + + " must be positive at line " + + line_number.to_string(), + ) + } + value +} + +///| +fn align_exonerate_parse_int( + text : String, + field : String, + line_number : Int, +) -> Int raise AlignExonerateError { + if text.length() == 0 { + raise AlignExonerateError( + "Empty Exonerate " + field + " at line " + line_number.to_string(), + ) + } + let mut value = 0 + for index = 0; index < text.length(); index = index + 1 { + let code = text.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + raise AlignExonerateError( + "Invalid Exonerate " + field + " at line " + line_number.to_string(), + ) + } + let digit = code - '0'.to_int() + if value > 214748364 || (value == 214748364 && digit > 7) { + raise AlignExonerateError( + "Exonerate " + + field + + " is too large at line " + + line_number.to_string(), + ) + } + value = value * 10 + digit + } + value +} + +///| +fn align_exonerate_parse_score( + text : String, + line_number : Int, +) -> Double raise AlignExonerateError { + let mut has_digit = false + for index = 0; index < text.length(); index = index + 1 { + let code = text.unsafe_get(index).to_int() + if code >= '0'.to_int() && code <= '9'.to_int() { + has_digit = true + } else if code != '+'.to_int() && + code != '-'.to_int() && + code != '.'.to_int() && + code != 'e'.to_int() && + code != 'E'.to_int() { + raise AlignExonerateError( + "Invalid Exonerate score at line " + line_number.to_string(), + ) + } + } + if !has_digit { + raise AlignExonerateError( + "Invalid Exonerate score at line " + line_number.to_string(), + ) + } + match parse_double(text) { + Some(value) => + if value.abs() > 1.0e300 { + raise AlignExonerateError( + "Non-finite Exonerate score at line " + line_number.to_string(), + ) + } else { + value + } + None => + raise AlignExonerateError( + "Invalid Exonerate score at line " + line_number.to_string(), + ) + } +} + +///| +fn align_exonerate_normalize_cigar_offset( + raw : Int, + strand : AlignExonerateStrand, + other : AlignExonerateStrand, +) -> Int { + if strand == AlignExonerateProtein && other != AlignExonerateProtein { + (raw + 2) / 3 + } else { + raw + } +} + +///| +fn align_exonerate_lines(text : String) -> Array[String] { + let raw = text.split("\n") + let lines : Array[String] = [] + for line in raw { + let owned = line.to_owned() + if owned.length() > 0 && + owned.unsafe_get(owned.length() - 1).to_int() == '\r'.to_int() { + lines.push(owned[0:owned.length() - 1].to_owned()) + } else { + lines.push(owned) + } + } + lines +} + +///| +fn align_exonerate_split_whitespace(text : String) -> Array[String] { + let result : Array[String] = [] + let mut index = 0 + while index < text.length() { + while index < text.length() && + align_exonerate_is_whitespace(text.unsafe_get(index).to_int()) { + index = index + 1 + } + if index >= text.length() { + break + } + let start = index + while index < text.length() && + !align_exonerate_is_whitespace(text.unsafe_get(index).to_int()) { + index = index + 1 + } + result.push(text[start:index].to_owned()) + } + result +} + +///| +fn align_exonerate_is_whitespace(code : Int) -> Bool { + code == ' '.to_int() || + code == '\t'.to_int() || + code == '\n'.to_int() || + code == '\r'.to_int() +} + +///| +fn align_exonerate_abs(value : Int) -> Int { + if value < 0 { + -value + } else { + value + } +} + +///| +/// Small report covering splicing and translated reverse-strand coordinates. +pub fn align_exonerate_example_text() -> String { + "Command line: [exonerate -m est2genome query.fa target.fa --showvulgar yes]\n" + + "Hostname: [moonbit]\n" + + "vulgar: transcript 0 18 + chromosome 100 218 + 250 M 6 6 5 0 2 I 0 96 3 0 2 M 12 12\n" + + "vulgar: protein 0 4 . genome 500 488 - 80 M 4 12\n" + + "-- completed exonerate analysis\n" +} diff --git a/test/moonbit/a2m_test.mbt b/test/moonbit/a2m_test.mbt new file mode 100644 index 00000000..b0970511 --- /dev/null +++ b/test/moonbit/a2m_test.mbt @@ -0,0 +1,780 @@ +// Black-box tests for Biopython Bio.Align.a2m-compatible support. + +///| +fn a2m_sample() -> @src.A2mAlignment { + @src.a2m_parse(@src.a2m_example_text()) catch { + _ => abort("valid A2M example should parse") + } +} + +///| +fn a2m_raises(text : String) -> Bool { + try { + ignore(@src.a2m_parse(text)) + false + } catch { + A2mError(_) => true + } +} + +///| +test "a2m parses sequence identifiers" { + let alignment = a2m_sample() + assert_eq(alignment.num_sequences(), 3) + assert_eq(alignment.sequences[0].id, "reference") + assert_eq(alignment.sequences[1].id, "query_one") + assert_eq(alignment.sequences[2].id, "query_two") +} + +///| +test "a2m parses descriptions" { + let alignment = a2m_sample() + assert_eq(alignment.sequences[0].description, "SAM model reference") + assert_eq(alignment.sequences[1].description, "insertion and deletion") + assert_eq(alignment.sequences[2].description, "divergent homolog") +} + +///| +test "a2m derives states from first row" { + let alignment = a2m_sample() + assert_eq(alignment.states, "DDDIIDDDDIDD") + assert_eq(alignment.alignment_length(), 12) +} + +///| +test "a2m normalizes match and insertion residues" { + let alignment = a2m_sample() + assert_eq(alignment.sequences[0].aligned_sequence, "ACDEFG-HIKLM") + assert_eq(alignment.sequences[1].aligned_sequence, "ACD--GTHI-LM") + assert_eq(alignment.sequences[2].aligned_sequence, "ATDQRG-HI-L-") +} + +///| +test "a2m stores ungapped sequences" { + let alignment = a2m_sample() + assert_eq(alignment.sequences[0].sequence, "ACDEFGHIKLM") + assert_eq(alignment.sequences[1].sequence, "ACDGTHILM") + assert_eq(alignment.sequences[2].sequence, "ATDQRGHIL") +} + +///| +test "a2m accepts wrapped sequence lines" { + let text = ">ref description\nACDe\nfG-H\nIkLM\n>query\nACD.\n.GTH\nI.LM\n" + let alignment = @src.a2m_parse(text) catch { + _ => abort("wrapped A2M should parse") + } + assert_eq(alignment.num_sequences(), 2) + assert_eq(alignment.states, "DDDIIDDDDIDD") + assert_eq(alignment.sequences[0].aligned_sequence, "ACDEFG-HIKLM") + assert_eq(alignment.sequences[1].aligned_sequence, "ACD--GTHI-LM") +} + +///| +test "a2m ignores blank lines" { + let text = "\n>ref\nACdE\n\n>query\nAC.E\n\n" + let alignment = @src.a2m_parse(text) catch { + _ => abort("A2M with blank lines should parse") + } + assert_eq(alignment.states, "DDID") + assert_eq(alignment.num_sequences(), 2) +} + +///| +test "a2m accepts CRLF input" { + let text = @src.a2m_example_text().replace_all(old="\n", new="\r\n") + assert_eq( + @src.a2m_parse(text) catch { + _ => abort("CRLF A2M should parse") + }, + a2m_sample(), + ) +} + +///| +test "a2m writes canonical character classes" { + let alignment = a2m_sample() + assert_eq( + @src.a2m_write(alignment) catch { + _ => abort("valid A2M should serialize") + }, + @src.a2m_example_text(), + ) +} + +///| +test "a2m writer wraps rows" { + let text = @src.a2m_write(a2m_sample(), line_width=5) catch { + _ => abort("valid wrapped serialization should succeed") + } + assert_true(text.contains("ACDef\nG-HIk\nLM\n")) + assert_true(text.contains("ACD..\nGTHI.\nLM\n")) +} + +///| +test "a2m wrapped serialization round trips" { + let original = a2m_sample() + let text = @src.a2m_write(original, line_width=4) catch { + _ => abort("valid wrapped serialization should succeed") + } + let reparsed = @src.a2m_parse(text) catch { + _ => abort("wrapped serialization should reparse") + } + assert_eq(reparsed, original) +} + +///| +test "a2m reports match and insertion column counts" { + let alignment = a2m_sample() + assert_eq(alignment.match_columns(), 9) + assert_eq(alignment.insertion_columns(), 3) +} + +///| +test "a2m returns column states" { + let alignment = a2m_sample() + assert_eq(alignment.column_state(0), Some(@src.A2mMatch)) + assert_eq(alignment.column_state(3), Some(@src.A2mInsertion)) + assert_eq(alignment.column_state(9), Some(@src.A2mInsertion)) + assert_true(alignment.column_state(-1) is None) + assert_true(alignment.column_state(12) is None) +} + +///| +test "a2m returns alignment columns" { + let alignment = a2m_sample() + assert_eq(alignment.column(0), Some("AAA")) + assert_eq(alignment.column(3), Some("E-Q")) + assert_eq(alignment.column(6), Some("-T-")) + assert_true(alignment.column(-1) is None) + assert_true(alignment.column(12) is None) +} + +///| +test "a2m finds sequence identifiers" { + let alignment = a2m_sample() + assert_eq(alignment.find_sequence("query_one"), Some(1)) + assert_eq(alignment.find_sequence("reference"), Some(0)) + assert_true(alignment.find_sequence("missing") is None) +} + +///| +test "a2m reconstructs encoded rows" { + let alignment = a2m_sample() + assert_eq(alignment.encoded_sequence(0), Some("ACDefG-HIkLM")) + assert_eq(alignment.encoded_sequence(1), Some("ACD..GTHI.LM")) + assert_eq(alignment.encoded_sequence(2), Some("ATDqrG-HI.L-")) + assert_true(alignment.encoded_sequence(-1) is None) + assert_true(alignment.encoded_sequence(3) is None) +} + +///| +test "a2m maps sequence coordinates to columns" { + let alignment = a2m_sample() + assert_eq(alignment.sequence_position_to_column(0, 0), Some(0)) + assert_eq(alignment.sequence_position_to_column(0, 3), Some(3)) + assert_eq(alignment.sequence_position_to_column(0, 6), Some(7)) + assert_eq(alignment.sequence_position_to_column(0, 10), Some(11)) + assert_true(alignment.sequence_position_to_column(0, 11) is None) +} + +///| +test "a2m maps columns to sequence coordinates" { + let alignment = a2m_sample() + assert_eq(alignment.column_to_sequence_position(1, 0), Some(0)) + assert_eq(alignment.column_to_sequence_position(1, 5), Some(3)) + assert_eq(alignment.column_to_sequence_position(1, 6), Some(4)) + assert_true(alignment.column_to_sequence_position(1, 3) is None) + assert_eq(alignment.column_to_sequence_position(1, 11), Some(8)) +} + +///| +test "a2m maps positions between rows" { + let alignment = a2m_sample() + assert_eq(alignment.map_position(0, 1, 0), Some(0)) + assert_true(alignment.map_position(0, 1, 3) is None) + assert_eq(alignment.map_position(0, 1, 5), Some(3)) + assert_eq(alignment.map_position(0, 1, 6), Some(5)) + assert_true(alignment.map_position(0, 1, 8) is None) +} + +///| +test "a2m maps insertion residues to reference gaps" { + let alignment = a2m_sample() + assert_eq(alignment.sequence_position_to_column(1, 4), Some(6)) + assert_true(alignment.map_position(1, 0, 4) is None) +} + +///| +test "a2m returns aligned coordinate pairs" { + let pairs = a2m_sample().aligned_pairs(0, 1) catch { + _ => abort("valid row pair should succeed") + } + assert_eq(pairs.length(), 12) + assert_eq(pairs[0], (Some(0), Some(0))) + assert_eq(pairs[3], (Some(3), None)) + assert_eq(pairs[6], (None, Some(4))) + assert_eq(pairs[11], (Some(10), Some(8))) +} + +///| +test "a2m counts identical pair" { + let counts = a2m_sample().pair_counts(0, 1) catch { + _ => abort("valid row pair should count") + } + assert_eq(counts.columns, 12) + assert_eq(counts.aligned, 8) + assert_eq(counts.identities, 8) + assert_eq(counts.mismatches, 0) + assert_eq(counts.gap_columns, 4) + assert_eq(counts.double_gap_columns, 0) + assert_eq(counts.match_aligned, 8) + assert_eq(counts.insertion_aligned, 0) + assert_true((counts.identity() - 1.0).abs() < 1.0e-12) +} + +///| +test "a2m counts divergent pair and insertion states" { + let counts = a2m_sample().pair_counts(0, 2) catch { + _ => abort("valid row pair should count") + } + assert_eq(counts.aligned, 9) + assert_eq(counts.identities, 6) + assert_eq(counts.mismatches, 3) + assert_eq(counts.gap_columns, 2) + assert_eq(counts.double_gap_columns, 1) + assert_eq(counts.match_aligned, 7) + assert_eq(counts.insertion_aligned, 2) + assert_true((counts.identity() - 2.0 / 3.0).abs() < 1.0e-12) +} + +///| +test "a2m identity is zero without paired residues" { + let alignment = @src.a2m_from_aligned(["left", "right"], ["A-", "-C"], "DD") catch { + _ => abort("valid disjoint alignment should build") + } + let counts = alignment.pair_counts(0, 1) catch { + _ => abort("valid disjoint pair should count") + } + assert_eq(counts.aligned, 0) + assert_true(counts.identity().abs() < 1.0e-12) +} + +///| +test "a2m locates insertion runs" { + let runs = a2m_sample().insertion_runs() + assert_eq(runs.length(), 2) + assert_eq(runs[0].slot, 3) + assert_eq(runs[0].start_column, 3) + assert_eq(runs[0].end_column, 5) + assert_eq(runs[0].width, 2) + assert_eq(runs[1].slot, 7) + assert_eq(runs[1].start_column, 9) + assert_eq(runs[1].end_column, 10) +} + +///| +test "a2m handles terminal insertion slots" { + let alignment = @src.a2m_parse(">ref\naBCd\n>query\n.EF.\n") catch { + _ => abort("terminal insertion alignment should parse") + } + let runs = alignment.insertion_runs() + assert_eq(runs.length(), 2) + assert_eq(runs[0].slot, 0) + assert_eq(runs[0].width, 1) + assert_eq(runs[1].slot, 2) + assert_eq(runs[1].width, 1) +} + +///| +test "a2m computes all-column consensus" { + assert_eq( + a2m_sample().consensus() catch { + _ => abort("valid consensus should succeed") + }, + "ACDEFGTHIKLM", + ) +} + +///| +test "a2m computes match-state consensus" { + assert_eq( + a2m_sample().consensus(include_insertions=false) catch { + _ => abort("valid match consensus should succeed") + }, + "ACDGTHILM", + ) +} + +///| +test "a2m applies consensus threshold" { + assert_eq( + a2m_sample().consensus(minimum_fraction=0.8) catch { + _ => abort("valid threshold consensus should succeed") + }, + "AXDXXGTHIKLM", + ) +} + +///| +test "a2m consensus breaks ties lexicographically" { + let alignment = @src.a2m_from_aligned(["z", "a"], ["T", "C"], "D") catch { + _ => abort("valid tie alignment should build") + } + assert_eq( + alignment.consensus() catch { + _ => abort("valid tie consensus should succeed") + }, + "C", + ) +} + +///| +test "a2m consensus emits gap for empty column" { + let alignment = @src.a2m_from_aligned(["one", "two"], ["-", "-"], "D") catch { + _ => abort("all-gap alignment should build") + } + assert_eq( + alignment.consensus() catch { + _ => abort("all-gap consensus should succeed") + }, + "-", + ) +} + +///| +test "a2m reports occupancy" { + let occupancy = a2m_sample().occupancy() + assert_eq(occupancy.length(), 12) + assert_true((occupancy[0] - 1.0).abs() < 1.0e-12) + assert_true((occupancy[3] - 2.0 / 3.0).abs() < 1.0e-12) + assert_true((occupancy[6] - 1.0 / 3.0).abs() < 1.0e-12) + assert_true((occupancy[9] - 1.0 / 3.0).abs() < 1.0e-12) + assert_true((occupancy[11] - 2.0 / 3.0).abs() < 1.0e-12) +} + +///| +test "a2m projects match columns" { + let projected = a2m_sample().match_projection() catch { + _ => abort("match projection should succeed") + } + assert_eq(projected.states, "DDDDDDDDD") + assert_eq(projected.sequences[0].aligned_sequence, "ACDG-HILM") + assert_eq(projected.sequences[1].aligned_sequence, "ACDGTHILM") + assert_eq(projected.sequences[2].aligned_sequence, "ATDG-HIL-") + assert_eq(projected.sequences[0].description, "SAM model reference") +} + +///| +test "a2m slices columns and preserves states" { + let sliced = a2m_sample().slice_columns(2, 10) catch { + _ => abort("valid A2M slice should succeed") + } + assert_eq(sliced.states, "DIIDDDDI") + assert_eq(sliced.sequences[0].aligned_sequence, "DEFG-HIK") + assert_eq(sliced.sequences[1].aligned_sequence, "D--GTHI-") + assert_eq(sliced.sequences[2].aligned_sequence, "DQRG-HI-") +} + +///| +test "a2m summarizes alignment" { + assert_eq( + a2m_sample().summary(), + "A2mAlignment(sequences=3, columns=12, match=9, insertion=3)", + ) +} + +///| +test "a2m sequence constructor normalizes case" { + let sequence = @src.A2mSequence::create( + "protein", + "AcD-Ef", + description="mixed case", + ) catch { + _ => abort("valid normalized row should build") + } + assert_eq(sequence.aligned_sequence, "ACD-EF") + assert_eq(sequence.sequence, "ACDEF") + assert_eq(sequence.description, "mixed case") +} + +///| +test "a2m alignment constructor copies rows" { + let rows = [ + @src.A2mSequence::create("one", "AC-") catch { + _ => abort("valid row should build") + }, + @src.A2mSequence::create("two", "A-C") catch { + _ => abort("valid row should build") + }, + ] + let alignment = @src.A2mAlignment::create(rows, "DID") catch { + _ => abort("valid alignment should build") + } + rows.push( + @src.A2mSequence::create("three", "ACC") catch { + _ => abort("valid row should build") + }, + ) + assert_eq(alignment.num_sequences(), 2) +} + +///| +test "a2m builds from aligned rows without descriptions" { + let alignment = @src.a2m_from_aligned(["one", "two"], ["AC-", "A-C"], "DID") catch { + _ => abort("valid direct alignment should build") + } + assert_eq(alignment.sequences[0].description, "") + assert_eq(alignment.encoded_sequence(0), Some("Ac-")) + assert_eq(alignment.encoded_sequence(1), Some("A.C")) +} + +///| +test "a2m builds from aligned rows with descriptions" { + let alignment = @src.a2m_from_aligned(["one", "two"], ["AC-", "A-C"], "DID", descriptions=[ + "first row", "second row", + ]) catch { + _ => abort("valid described alignment should build") + } + assert_eq(alignment.sequences[1].description, "second row") +} + +///| +test "a2m accepts duplicate identifiers like Biopython" { + let alignment = @src.a2m_parse(">same\nAC\n>same\nAT\n") catch { + _ => abort("duplicate A2M identifiers should parse") + } + assert_eq(alignment.num_sequences(), 2) + assert_eq(alignment.find_sequence("same"), Some(0)) +} + +///| +test "a2m supports a single sequence" { + let alignment = @src.a2m_parse(">only\nACdE\n") catch { + _ => abort("single-row A2M should parse") + } + assert_eq(alignment.num_sequences(), 1) + assert_eq(alignment.states, "DDID") + assert_eq(alignment.occupancy(), [1.0, 1.0, 1.0, 1.0]) +} + +///| +test "a2m rejects empty input" { + assert_true(a2m_raises("")) + assert_true(a2m_raises("\n\r\n")) +} + +///| +test "a2m rejects sequence before header" { + assert_true(a2m_raises("ACDE\n>query\nACDE\n")) +} + +///| +test "a2m rejects empty header" { + assert_true(a2m_raises(">\nACDE\n")) + assert_true(a2m_raises("> \nACDE\n")) +} + +///| +test "a2m rejects empty first row" { + assert_true(a2m_raises(">empty\n>filled\nACDE\n")) +} + +///| +test "a2m rejects unequal row widths" { + assert_true(a2m_raises(">one\nACDE\n>two\nACD\n")) + assert_true(a2m_raises(">one\nACD\n>two\nACDE\n")) +} + +///| +test "a2m rejects invalid sequence characters" { + assert_true(a2m_raises(">one\nAC*D\n")) + assert_true(a2m_raises(">one\nAC_D\n")) + assert_true(a2m_raises(">one\nAC/D\n")) +} + +///| +test "a2m rejects embedded sequence whitespace" { + assert_true(a2m_raises(">one\nAC DE\n")) + assert_true(a2m_raises(">one\nAC\tDE\n")) +} + +///| +test "a2m rejects insertion character in match column" { + assert_true(a2m_raises(">model\nACDE\n>query\nACdE\n")) + assert_true(a2m_raises(">model\nAC-E\n>query\nAC.E\n")) +} + +///| +test "a2m rejects match character in insertion column" { + assert_true(a2m_raises(">model\nACdE\n>query\nACDE\n")) + assert_true(a2m_raises(">model\nAC.E\n>query\nAC-E\n")) +} + +///| +test "a2m rejects invalid constructor state" { + let raised = try { + ignore(@src.a2m_from_aligned(["one"], ["ACD"], "DXD")) + false + } catch { + A2mError(_) => true + } + assert_true(raised) +} + +///| +test "a2m rejects state width mismatch" { + let raised = try { + ignore(@src.a2m_from_aligned(["one"], ["ACD"], "DD")) + false + } catch { + A2mError(_) => true + } + assert_true(raised) +} + +///| +test "a2m rejects empty alignment constructor" { + let rows : Array[@src.A2mSequence] = [] + let raised = try { + ignore(@src.A2mAlignment::create(rows, "D")) + false + } catch { + A2mError(_) => true + } + assert_true(raised) +} + +///| +test "a2m rejects empty sequence constructor" { + let raised = try { + ignore(@src.A2mSequence::create("one", "")) + false + } catch { + A2mError(_) => true + } + assert_true(raised) +} + +///| +test "a2m rejects invalid normalized row characters" { + let dot = try { + ignore(@src.A2mSequence::create("one", "AC.D")) + false + } catch { + A2mError(_) => true + } + let star = try { + ignore(@src.A2mSequence::create("one", "AC*D")) + false + } catch { + A2mError(_) => true + } + assert_true(dot) + assert_true(star) +} + +///| +test "a2m rejects empty sequence identifier" { + let raised = try { + ignore(@src.A2mSequence::create("", "ACD")) + false + } catch { + A2mError(_) => true + } + assert_true(raised) +} + +///| +test "a2m rejects whitespace in sequence identifier" { + let space = try { + ignore(@src.A2mSequence::create("bad id", "ACD")) + false + } catch { + A2mError(_) => true + } + let tab = try { + ignore(@src.A2mSequence::create("bad\tid", "ACD")) + false + } catch { + A2mError(_) => true + } + assert_true(space) + assert_true(tab) +} + +///| +test "a2m rejects line breaks in description" { + let raised = try { + ignore( + @src.A2mSequence::create("one", "ACD", description="bad\ndescription"), + ) + false + } catch { + A2mError(_) => true + } + assert_true(raised) +} + +///| +test "a2m rejects direct identifier row count mismatch" { + let raised = try { + ignore(@src.a2m_from_aligned(["one", "two"], ["ACD"], "DDD")) + false + } catch { + A2mError(_) => true + } + assert_true(raised) +} + +///| +test "a2m rejects direct description count mismatch" { + let raised = try { + ignore( + @src.a2m_from_aligned(["one", "two"], ["ACD", "ACD"], "DDD", descriptions=[ + "only one", + ]), + ) + false + } catch { + A2mError(_) => true + } + assert_true(raised) +} + +///| +test "a2m rejects negative writer width" { + let raised = try { + ignore(@src.a2m_write(a2m_sample(), line_width=-1)) + false + } catch { + A2mError(_) => true + } + assert_true(raised) +} + +///| +test "a2m rejects match projection without match states" { + let alignment = @src.a2m_from_aligned(["one", "two"], ["AC", "A-"], "II") catch { + _ => abort("insertion-only alignment should build") + } + let raised = try { + ignore(alignment.match_projection()) + false + } catch { + A2mError(_) => true + } + assert_true(raised) +} + +///| +test "a2m rejects negative column slice" { + let raised = try { + ignore(a2m_sample().slice_columns(-1, 2)) + false + } catch { + A2mError(_) => true + } + assert_true(raised) +} + +///| +test "a2m rejects empty column slice" { + let raised = try { + ignore(a2m_sample().slice_columns(2, 2)) + false + } catch { + A2mError(_) => true + } + assert_true(raised) +} + +///| +test "a2m rejects column slice past end" { + let raised = try { + ignore(a2m_sample().slice_columns(0, 13)) + false + } catch { + A2mError(_) => true + } + assert_true(raised) +} + +///| +test "a2m rejects invalid aligned pair row" { + let low = try { + ignore(a2m_sample().aligned_pairs(-1, 0)) + false + } catch { + A2mError(_) => true + } + let high = try { + ignore(a2m_sample().aligned_pairs(0, 3)) + false + } catch { + A2mError(_) => true + } + assert_true(low) + assert_true(high) +} + +///| +test "a2m rejects invalid pair count row" { + let raised = try { + ignore(a2m_sample().pair_counts(3, 0)) + false + } catch { + A2mError(_) => true + } + assert_true(raised) +} + +///| +test "a2m rejects invalid consensus threshold" { + let low = try { + ignore(a2m_sample().consensus(minimum_fraction=-0.1)) + false + } catch { + A2mError(_) => true + } + let high = try { + ignore(a2m_sample().consensus(minimum_fraction=1.1)) + false + } catch { + A2mError(_) => true + } + assert_true(low) + assert_true(high) +} + +///| +test "a2m accessors reject invalid rows and positions" { + let alignment = a2m_sample() + assert_true(alignment.sequence_position_to_column(-1, 0) is None) + assert_true(alignment.sequence_position_to_column(3, 0) is None) + assert_true(alignment.sequence_position_to_column(0, -1) is None) + assert_true(alignment.column_to_sequence_position(-1, 0) is None) + assert_true(alignment.column_to_sequence_position(3, 0) is None) + assert_true(alignment.column_to_sequence_position(0, -1) is None) + assert_true(alignment.column_to_sequence_position(0, 12) is None) +} + +///| +test "a2m map rejects invalid target row" { + let alignment = a2m_sample() + assert_true(alignment.map_position(0, -1, 0) is None) + assert_true(alignment.map_position(0, 3, 0) is None) + assert_true(alignment.map_position(3, 0, 0) is None) + assert_true(alignment.map_position(0, 1, -1) is None) +} + +///| +test "a2m insertion-only alignment retains coordinates" { + let alignment = @src.a2m_from_aligned(["one", "two"], ["AC", "A-"], "II") catch { + _ => abort("insertion-only alignment should build") + } + assert_eq(alignment.match_columns(), 0) + assert_eq(alignment.insertion_columns(), 2) + assert_eq(alignment.map_position(0, 1, 0), Some(0)) + assert_true(alignment.map_position(0, 1, 1) is None) + assert_eq(alignment.insertion_runs()[0].slot, 0) +} diff --git a/test/moonbit/align_emboss_test.mbt b/test/moonbit/align_emboss_test.mbt new file mode 100644 index 00000000..838d655a --- /dev/null +++ b/test/moonbit/align_emboss_test.mbt @@ -0,0 +1,935 @@ +// Black-box tests for Biopython Bio.Align.emboss-compatible support. + +///| +fn align_emboss_test_parse(text : String) -> @src.AlignEmbossDocument { + @src.align_emboss_parse(text) catch { + AlignEmbossError(message) => abort("valid EMBOSS input failed: " + message) + } +} + +///| +fn align_emboss_test_raises(text : String) -> Bool { + try { + ignore(@src.align_emboss_parse(text)) + false + } catch { + AlignEmbossError(_) => true + } +} + +///| +fn align_emboss_test_sample() -> @src.AlignEmbossDocument { + align_emboss_test_parse(@src.align_emboss_example_text()) +} + +///| +fn align_emboss_test_reverse_text() -> String { + "########################################\n" + + "# Program: water\n" + + "# Rundate: Sat 22 Oct 2022 22:56:15\n" + + "# Commandline: water -sreverse2\n" + + "# Align_format: srspair\n" + + "# Report_file: water_reverse4.txt\n" + + "########################################\n" + + "#=======================================\n" + + "#\n" + + "# Aligned_sequences: 2\n" + + "# 1: seqA\n" + + "# 2: seqB\n" + + "# Matrix: EDNAFULL\n" + + "# Gap_penalty: 1.0\n" + + "# Extend_penalty: 0.5\n" + + "#\n" + + "# Length: 19\n" + + "# Identity: 16/19 (84.2%)\n" + + "# Similarity: 16/19 (84.2%)\n" + + "# Gaps: 3/19 (15.8%)\n" + + "# Score: 77.5\n" + + "#\n" + + "#=======================================\n" + + "seqA 3 GGGCCCGGTT-TAAAAAAA 20\n" + + " |||||||| ||||||||\n" + + "seqB 19 GGGCCCGG--GTAAAAAAA 3\n" + + "#---------------------------------------\n" + + "#---------------------------------------\n" +} + +///| +fn align_emboss_test_simple_text() -> String { + "########################################\n" + + "# Program: matcher\n" + + "# Rundate: Tue 8 Dec 2009 11:48:35\n" + + "# Commandline: matcher -aformat simple\n" + + "# Align_format: simple\n" + + "# Report_file: matcher_simple.txt\n" + + "########################################\n" + + "#=======================================\n" + + "#\n" + + "# Aligned_sequences: 2\n" + + "# 1: AF069992_1\n" + + "# 2: CAA85685.1\n" + + "# Matrix: EBLOSUM62\n" + + "# Gap_penalty: 14\n" + + "# Extend_penalty: 4\n" + + "#\n" + + "# Length: 16\n" + + "# Identity: 7/16 (43.8%)\n" + + "# Similarity: 8/16 (50.0%)\n" + + "# Gaps: 0/16 ( 0.0%)\n" + + "# Score: 29\n" + + "#\n" + + "#=======================================\n" + + "AF069992_1 73 GPPPQSPDENRAGESS 88\n" + + " |.||:......|.|||\n" + + "CAA85685.1 47 GVPPEEAGAAVAAESS 62\n" + + "#---------------------------------------\n" + + "#---------------------------------------\n" +} + +///| +fn align_emboss_test_multiple_rows_text() -> String { + "########################################\n" + + "# Program: alignret\n" + + "# Align_format: simple\n" + + "# Report_file: stdout\n" + + "########################################\n" + + "#=======================================\n" + + "#\n" + + "# Aligned_sequences: 4\n" + + "# 1: alpha\n" + + "# 2: beta\n" + + "# 3: gamma\n" + + "# 4: delta\n" + + "# Matrix: EBLOSUM62\n" + + "# Length: 6\n" + + "# Identity: 3/6\n" + + "# Similarity: 3/6\n" + + "# Gaps: 4/6\n" + + "# Score: 10\n" + + "#\n" + + "#=======================================\n" + + "alpha 1 AC-GTT 5\n" + + "beta 1 ACCG-T 5\n" + + "gamma 1 A--GTT 4\n" + + "delta 1 AC-G-T 4\n" + + " | | |\n" + + "#---------------------------------------\n" + + "#---------------------------------------\n" +} + +///| +fn align_emboss_test_gap_blocks_text() -> String { + "########################################\n" + + "# Program: needle\n" + + "# Align_format: srspair\n" + + "########################################\n" + + "#=======================================\n" + + "# Aligned_sequences: 2\n" + + "# 1: full\n" + + "# 2: overhang\n" + + "# Length: 6\n" + + "# Identity: 3/6\n" + + "# Similarity: 3/6\n" + + "# Gaps: 3/6\n" + + "#=======================================\n" + + "full 1 AAA 3\n" + + " \n" + + "overhang 0 --- 0\n" + + "\n" + + "full 4 CCC 6\n" + + " |||\n" + + "overhang 1 CCC 3\n" + + "#---------------------------------------\n" +} + +///| +test "Bio.Align.emboss parses file metadata" { + let document = align_emboss_test_sample() + assert_eq(document.metadata.program, "water") + assert_eq(document.metadata.rundate, "Wed Jan 16 17:23:19 2002") + assert_eq(document.metadata.report_file, "stdout") + assert_eq(document.metadata.align_format, "srspair") +} + +///| +test "Bio.Align.emboss joins command continuations" { + let document = align_emboss_test_sample() + assert_eq( + document.metadata.command_line, + "water -asequence reference.fa -bsequence query.fa", + ) +} + +///| +test "Bio.Align.emboss defaults to srspair" { + let text = @src.align_emboss_example_text().replace_all( + old="# Align_format: srspair\n", + new="", + ) + assert_eq(align_emboss_test_parse(text).metadata.align_format, "srspair") +} + +///| +test "Bio.Align.emboss report summary" { + assert_eq( + align_emboss_test_sample().summary(), + "EMBOSS report(program=water, format=srspair, alignments=1)", + ) +} + +///| +test "Bio.Align.emboss document accessors" { + let document = align_emboss_test_sample() + assert_eq(document.num_alignments(), 1) + assert_true(document.get(0) is Some(_)) + assert_true(document.get(-1) is None) + assert_true(document.get(1) is None) +} + +///| +test "Bio.Align.emboss parses alignment annotations" { + let annotations = align_emboss_test_sample().alignments[0].annotations + assert_eq(annotations.matrix, "EDNAFULL") + assert_eq(annotations.gap_penalty, Some(10.0)) + assert_eq(annotations.extend_penalty, Some(0.5)) + assert_eq(annotations.length, 18) + assert_eq(annotations.identity, Some(16)) + assert_eq(annotations.similarity, Some(17)) + assert_eq(annotations.gaps, Some(1)) + assert_eq(annotations.score, Some(72.5)) +} + +///| +test "Bio.Align.emboss parses row identifiers" { + let alignment = align_emboss_test_sample().alignments[0] + assert_eq(alignment.num_sequences(), 2) + assert_eq(alignment.sequences[0].id, "reference_sequence") + assert_eq(alignment.sequences[1].id, "query_sequence") +} + +///| +test "Bio.Align.emboss stores aligned and ungapped rows" { + let alignment = align_emboss_test_sample().alignments[0] + assert_eq(alignment.sequences[0].aligned_sequence, "ACGTTGAGT-CTGGGATG") + assert_eq(alignment.sequences[0].sequence, "ACGTTGAGTCTGGGATG") + assert_eq(alignment.sequences[1].aligned_sequence, "ACGTTGAGTACTGGAATG") + assert_eq(alignment.sequences[1].sequence, "ACGTTGAGTACTGGAATG") +} + +///| +test "Bio.Align.emboss normalizes forward boundaries" { + let alignment = align_emboss_test_sample().alignments[0] + assert_eq(alignment.sequences[0].start, 78) + assert_eq(alignment.sequences[0].end, 95) + assert_eq(alignment.sequences[1].start, 0) + assert_eq(alignment.sequences[1].end, 18) + assert_eq(alignment.sequences[0].strand, AlignEmbossForward) +} + +///| +test "Bio.Align.emboss preserves consensus columns" { + let alignment = align_emboss_test_sample().alignments[0] + assert_eq(alignment.consensus, "||||||||| ||||:|||") + assert_eq(alignment.consensus.length(), alignment.alignment_length()) +} + +///| +test "Bio.Align.emboss alignment accessors" { + let alignment = align_emboss_test_sample().alignments[0] + assert_eq(alignment.alignment_length(), 18) + assert_eq(alignment.find_sequence("query_sequence"), Some(1)) + assert_true(alignment.find_sequence("missing") is None) + assert_eq(alignment.column(9), Some("-A")) + assert_true(alignment.column(-1) is None) + assert_true(alignment.column(18) is None) +} + +///| +test "Bio.Align.emboss alignment summary" { + assert_eq( + align_emboss_test_sample().alignments[0].summary(), + "EMBOSS alignment(rows=2, columns=18, matrix=EDNAFULL)", + ) +} + +///| +test "Bio.Align.emboss maps forward columns to positions" { + let alignment = align_emboss_test_sample().alignments[0] + assert_eq(alignment.column_to_sequence_position(0, 0), Some(78)) + assert_eq(alignment.column_to_sequence_position(0, 8), Some(86)) + assert_true(alignment.column_to_sequence_position(0, 9) is None) + assert_eq(alignment.column_to_sequence_position(0, 10), Some(87)) + assert_eq(alignment.column_to_sequence_position(0, 17), Some(94)) +} + +///| +test "Bio.Align.emboss maps positions to columns" { + let alignment = align_emboss_test_sample().alignments[0] + assert_eq(alignment.sequence_position_to_column(0, 78), Some(0)) + assert_eq(alignment.sequence_position_to_column(0, 87), Some(10)) + assert_eq(alignment.sequence_position_to_column(0, 94), Some(17)) + assert_true(alignment.sequence_position_to_column(0, 77) is None) + assert_true(alignment.sequence_position_to_column(0, 95) is None) +} + +///| +test "Bio.Align.emboss maps positions between rows" { + let alignment = align_emboss_test_sample().alignments[0] + assert_eq(alignment.map_position(0, 1, 78), Some(0)) + assert_eq(alignment.map_position(0, 1, 87), Some(10)) + assert_true(alignment.map_position(1, 0, 9) is None) + assert_true(alignment.map_position(0, 4, 78) is None) +} + +///| +test "Bio.Align.emboss aligned pairs use absolute coordinates" { + let pairs = align_emboss_test_sample().alignments[0].aligned_pairs(0, 1) catch { + _ => abort("valid row indices should produce aligned pairs") + } + assert_eq(pairs.length(), 18) + assert_eq(pairs[0], (Some(78), Some(0))) + assert_eq(pairs[9], (None, Some(9))) + assert_eq(pairs[10], (Some(87), Some(10))) + assert_eq(pairs[17], (Some(94), Some(17))) +} + +///| +test "Bio.Align.emboss rejects invalid aligned-pair row" { + let alignment = align_emboss_test_sample().alignments[0] + let raised = try { + ignore(alignment.aligned_pairs(0, 2)) + false + } catch { + AlignEmbossError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.emboss builds compact coordinate path" { + let path = align_emboss_test_sample().alignments[0].coordinate_path() + assert_eq(path.length(), 2) + assert_eq(path[0], [78, 87, 87, 95]) + assert_eq(path[1], [0, 9, 10, 18]) +} + +///| +test "Bio.Align.emboss counts aligned residues and identities" { + let counts = align_emboss_test_sample().alignments[0].pair_counts(0, 1) catch { + _ => abort("valid rows should be counted") + } + assert_eq(counts.columns, 18) + assert_eq(counts.aligned, 17) + assert_eq(counts.identities, 16) + assert_eq(counts.mismatches, 1) +} + +///| +test "Bio.Align.emboss counts insertion gaps and opens" { + let counts = align_emboss_test_sample().alignments[0].pair_counts(0, 1) catch { + _ => abort("valid rows should be counted") + } + assert_eq(counts.insertions, 1) + assert_eq(counts.deletions, 0) + assert_eq(counts.insertion_opens, 1) + assert_eq(counts.deletion_opens, 0) + assert_eq(counts.double_gap_columns, 0) +} + +///| +test "Bio.Align.emboss counts consensus positives" { + let counts = align_emboss_test_sample().alignments[0].pair_counts(0, 1) catch { + _ => abort("valid rows should be counted") + } + assert_eq(counts.positives, 17) + assert_eq(counts.identity(), 16.0 / 17.0) +} + +///| +test "Bio.Align.emboss reverses gap direction with row order" { + let counts = align_emboss_test_sample().alignments[0].pair_counts(1, 0) catch { + _ => abort("valid rows should be counted") + } + assert_eq(counts.insertions, 0) + assert_eq(counts.deletions, 1) + assert_eq(counts.deletion_opens, 1) +} + +///| +test "Bio.Align.emboss parses simple format" { + let document = align_emboss_test_parse(align_emboss_test_simple_text()) + let alignment = document.alignments[0] + assert_eq(document.metadata.align_format, "simple") + assert_eq(alignment.sequences[0].start, 72) + assert_eq(alignment.sequences[0].end, 88) + assert_eq(alignment.sequences[1].start, 46) + assert_eq(alignment.sequences[1].end, 62) + assert_eq(alignment.annotations.identity, Some(7)) + assert_eq(alignment.annotations.similarity, Some(8)) +} + +///| +test "Bio.Align.emboss parses multiple sequence simple alignment" { + let alignment = align_emboss_test_parse( + align_emboss_test_multiple_rows_text(), + ).alignments[0] + assert_eq(alignment.num_sequences(), 4) + assert_eq(alignment.column(2), Some("-C--")) + assert_eq(alignment.consensus, "| | |") + assert_eq(alignment.coordinate_path().length(), 4) +} + +///| +test "Bio.Align.emboss parses gap-only leading block" { + let alignment = align_emboss_test_parse(align_emboss_test_gap_blocks_text()).alignments[0] + assert_eq(alignment.sequences[1].aligned_sequence, "---CCC") + assert_eq(alignment.sequences[1].sequence, "CCC") + assert_eq(alignment.sequences[1].start, 0) + assert_eq(alignment.sequences[1].end, 3) + assert_eq(alignment.coordinate_path()[1], [0, 0, 3]) +} + +///| +test "Bio.Align.emboss parses reverse strand row" { + let alignment = align_emboss_test_parse(align_emboss_test_reverse_text()).alignments[0] + let reverse = alignment.sequences[1] + assert_eq(reverse.start, 19) + assert_eq(reverse.end, 2) + assert_eq(reverse.strand, AlignEmbossReverse) + assert_eq(reverse.sequence, "GGGCCCGGGTAAAAAAA") +} + +///| +test "Bio.Align.emboss maps reverse coordinates" { + let alignment = align_emboss_test_parse(align_emboss_test_reverse_text()).alignments[0] + assert_eq(alignment.column_to_sequence_position(1, 0), Some(18)) + assert_eq(alignment.column_to_sequence_position(1, 7), Some(11)) + assert_true(alignment.column_to_sequence_position(1, 8) is None) + assert_true(alignment.column_to_sequence_position(1, 9) is None) + assert_eq(alignment.column_to_sequence_position(1, 10), Some(10)) + assert_eq(alignment.column_to_sequence_position(1, 18), Some(2)) +} + +///| +test "Bio.Align.emboss reverse position lookup" { + let alignment = align_emboss_test_parse(align_emboss_test_reverse_text()).alignments[0] + assert_eq(alignment.sequence_position_to_column(1, 18), Some(0)) + assert_eq(alignment.sequence_position_to_column(1, 10), Some(10)) + assert_eq(alignment.sequence_position_to_column(1, 2), Some(18)) + assert_true(alignment.sequence_position_to_column(1, 19) is None) +} + +///| +test "Bio.Align.emboss reverse coordinate path decreases" { + let path = align_emboss_test_parse(align_emboss_test_reverse_text()).alignments[0].coordinate_path() + assert_eq(path[0], [2, 10, 12, 12, 20]) + assert_eq(path[1], [19, 11, 11, 10, 2]) +} + +///| +test "Bio.Align.emboss reverse pair counts" { + let alignment = align_emboss_test_parse(align_emboss_test_reverse_text()).alignments[0] + let counts = alignment.pair_counts(0, 1) catch { + _ => abort("reverse rows should be counted") + } + assert_eq(counts.aligned, 16) + assert_eq(counts.identities, 16) + assert_eq(counts.insertions, 1) + assert_eq(counts.deletions, 2) + assert_eq(counts.insertion_opens, 1) + assert_eq(counts.deletion_opens, 1) +} + +///| +test "Bio.Align.emboss accepts CRLF" { + let crlf = @src.align_emboss_example_text().replace_all(old="\n", new="\r\n") + assert_eq(align_emboss_test_parse(crlf), align_emboss_test_sample()) +} + +///| +test "Bio.Align.emboss accepts trailing spaces on separators" { + let text = @src.align_emboss_example_text().replace_all( + old="#---------------------------------------\n", + new="#--------------------------------------- \n", + ) + assert_eq(align_emboss_test_parse(text).alignments[0].annotations.length, 18) +} + +///| +test "Bio.Align.emboss parses nobrief equal annotations" { + let text = @src.align_emboss_example_text().replace_all( + old="# Score: 72.5\n", + new="# Score: 72.5\n# Longest_Identity = 9\n# Shortest_Similarity = 2\n", + ) + let annotations = align_emboss_test_parse(text).alignments[0].annotations + assert_eq(annotations.longest_identity, "9") + assert_eq(annotations.shortest_similarity, "2") +} + +///| +test "Bio.Align.emboss writes canonical report" { + let output = @src.align_emboss_write(align_emboss_test_sample()) catch { + _ => abort("valid EMBOSS document should serialize") + } + assert_true(output.has_prefix("########################################\n")) + assert_true(output.contains("# Aligned_sequences: 2\n")) + assert_true(output.contains("# Length: 18\n")) + assert_true(output.contains("reference_seq")) +} + +///| +test "Bio.Align.emboss writer round trip" { + let document = align_emboss_test_sample() + let output = @src.align_emboss_write(document) catch { + _ => abort("valid EMBOSS document should serialize") + } + assert_eq(align_emboss_test_parse(output), document) +} + +///| +test "Bio.Align.emboss writer wraps sequence blocks" { + let document = align_emboss_test_sample() + let output = @src.align_emboss_write(document, line_width=7) catch { + _ => abort("valid EMBOSS document should wrap") + } + assert_eq(align_emboss_test_parse(output), document) +} + +///| +test "Bio.Align.emboss reverse writer round trip" { + let document = align_emboss_test_parse(align_emboss_test_reverse_text()) + let output = @src.align_emboss_write(document, line_width=1) catch { + _ => abort("reverse EMBOSS document should serialize") + } + assert_eq(align_emboss_test_parse(output), document) +} + +///| +test "Bio.Align.emboss multiple-row writer round trip" { + let document = align_emboss_test_parse(align_emboss_test_multiple_rows_text()) + let output = @src.align_emboss_write(document, line_width=3) catch { + _ => abort("multiple-row EMBOSS document should serialize") + } + assert_eq(align_emboss_test_parse(output), document) +} + +///| +test "Bio.Align.emboss writer supports multiple alignments" { + let document = align_emboss_test_sample() + let doubled = @src.AlignEmbossDocument::create(document.metadata, [ + document.alignments[0], + document.alignments[0], + ]) catch { + _ => abort("valid multi-alignment document should construct") + } + let output = @src.align_emboss_write(doubled, line_width=9) catch { + _ => abort("multi-alignment EMBOSS document should serialize") + } + let parsed = align_emboss_test_parse(output) + assert_eq(parsed.num_alignments(), 2) + assert_eq(parsed, doubled) +} + +///| +test "Bio.Align.emboss writer rejects zero width" { + let raised = try { + ignore(@src.align_emboss_write(align_emboss_test_sample(), line_width=0)) + false + } catch { + AlignEmbossError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.emboss writer rejects width above format maximum" { + let raised = try { + ignore(@src.align_emboss_write(align_emboss_test_sample(), line_width=51)) + false + } catch { + AlignEmbossError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.emboss constructs metadata" { + let metadata = @src.AlignEmbossMetadata::create( + program="needle", + align_format="pair", + ) catch { + _ => abort("valid metadata should construct") + } + assert_eq(metadata.program, "needle") + assert_eq(metadata.align_format, "pair") +} + +///| +test "Bio.Align.emboss rejects invalid metadata format" { + let raised = try { + ignore(@src.AlignEmbossMetadata::create(align_format="json")) + false + } catch { + AlignEmbossError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.emboss constructs sequence row" { + let sequence = @src.AlignEmbossSequence::create("row", "AC-GT", 5, 9) catch { + _ => abort("valid row should construct") + } + assert_eq(sequence.sequence, "ACGT") + assert_eq(sequence.strand, AlignEmbossForward) +} + +///| +test "Bio.Align.emboss constructs reverse sequence row" { + let sequence = @src.AlignEmbossSequence::create("row", "AC-GT", 9, 5) catch { + _ => abort("valid reverse row should construct") + } + assert_eq(sequence.sequence, "ACGT") + assert_eq(sequence.strand, AlignEmbossReverse) +} + +///| +test "Bio.Align.emboss rejects row span mismatch" { + let raised = try { + ignore(@src.AlignEmbossSequence::create("row", "AC-GT", 5, 10)) + false + } catch { + AlignEmbossError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.emboss rejects empty input" { + assert_true(align_emboss_test_raises("")) +} + +///| +test "Bio.Align.emboss rejects missing file divider" { + assert_true(align_emboss_test_raises("# Program: water\n")) +} + +///| +test "Bio.Align.emboss rejects truncated header" { + assert_true( + align_emboss_test_raises( + "########################################\n# Program: water\n", + ), + ) +} + +///| +test "Bio.Align.emboss rejects malformed header line" { + let text = @src.align_emboss_example_text().replace_all( + old="# Program: water\n", + new="Program: water\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects command continuation before commandline" { + let text = @src.align_emboss_example_text().replace_all( + old="# Program: water\n", + new="# Program: water\n# orphan\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects invalid align format" { + let text = @src.align_emboss_example_text().replace_all( + old="# Align_format: srspair\n", + new="# Align_format: unknown\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects header-only report" { + assert_true( + align_emboss_test_raises( + "########################################\n" + + "# Program: water\n" + + "########################################\n", + ), + ) +} + +///| +test "Bio.Align.emboss rejects content before alignment" { + let text = @src.align_emboss_example_text().replace_all( + old="#=======================================\n", + new="unexpected\n#=======================================\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects duplicate sequence count" { + let text = @src.align_emboss_example_text().replace_all( + old="# Matrix: EDNAFULL\n", + new="# Aligned_sequences: 2\n# 1: x\n# 2: y\n# Matrix: EDNAFULL\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects zero sequence count" { + let text = @src.align_emboss_example_text().replace_all( + old="# Aligned_sequences: 2\n", + new="# Aligned_sequences: 0\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects non-contiguous sequence numbering" { + let text = @src.align_emboss_example_text().replace_all( + old="# 2: query_sequence\n", + new="# 3: query_sequence\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects whitespace in declared identifier" { + let text = @src.align_emboss_example_text().replace_all( + old="# 1: reference_sequence\n", + new="# 1: reference sequence\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects unknown alignment annotation" { + let text = @src.align_emboss_example_text().replace_all( + old="# Matrix: EDNAFULL\n", + new="# Unknown: value\n# Matrix: EDNAFULL\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects missing alignment length" { + let text = @src.align_emboss_example_text().replace_all( + old="# Length: 18\n", + new="", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects invalid alignment length" { + let text = @src.align_emboss_example_text().replace_all( + old="# Length: 18\n", + new="# Length: eighteen\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects annotation count above length" { + let text = @src.align_emboss_example_text().replace_all( + old="# Identity: 16/18 (88.9%)\n", + new="# Identity: 19/18 (105.6%)\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects malformed body line" { + let text = @src.align_emboss_example_text().replace_all( + old="reference_seq 79 ACGTTGAGT-CTGGGATG 95\n", + new="short\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects unexpected row identifier" { + let text = @src.align_emboss_example_text().replace_all( + old="reference_seq 79", + new="other_id 79", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects invalid sequence start" { + let text = @src.align_emboss_example_text().replace_all( + old="reference_seq 79", + new="reference_seq xx", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects invalid sequence end" { + let text = @src.align_emboss_example_text().replace_all( + old="ACGTTGAGT-CTGGGATG 95", + new="ACGTTGAGT-CTGGGATG xx", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects inconsistent block width" { + let text = @src.align_emboss_example_text().replace_all( + old="query_sequence 1 ACGTTGAGTACTGGAATG 18", + new="query_sequence 1 ACGTTGAGTACTGGAAT 17", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects coordinate consumption mismatch" { + let text = @src.align_emboss_example_text().replace_all( + old="reference_seq 79 ACGTTGAGT-CTGGGATG 95", + new="reference_seq 79 ACGTTGAGT-CTGGGATG 94", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects declared width mismatch" { + let text = @src.align_emboss_example_text() + .replace_all(old="# Length: 18\n", new="# Length: 19\n") + .replace_all(old="# Identity: 16/18 (88.9%)\n", new="# Identity: 16/19\n") + .replace_all( + old="# Similarity: 17/18 (94.4%)\n", + new="# Similarity: 17/19\n", + ) + .replace_all(old="# Gaps: 1/18 ( 5.6%)\n", new="# Gaps: 1/19\n") + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects consensus before sequence block" { + let text = @src.align_emboss_example_text().replace_all( + old="reference_seq 79 ACGTTGAGT-CTGGGATG 95\n", + new=" ||||||||||||||||||\n" + + "reference_seq 79 ACGTTGAGT-CTGGGATG 95\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects consensus wider than block" { + let text = @src.align_emboss_example_text().replace_all( + old=" ||||||||| ||||:|||\n", + new=" ||||||||| ||||:|||X\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects identity disagreement" { + let text = @src.align_emboss_example_text().replace_all( + old="# Identity: 16/18 (88.9%)\n", + new="# Identity: 15/18\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects similarity disagreement" { + let text = @src.align_emboss_example_text().replace_all( + old="# Similarity: 17/18 (94.4%)\n", + new="# Similarity: 16/18\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects gap disagreement" { + let text = @src.align_emboss_example_text().replace_all( + old="# Gaps: 1/18 ( 5.6%)\n", + new="# Gaps: 2/18\n", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects invalid reverse coordinates" { + let text = align_emboss_test_reverse_text().replace_all( + old="seqB 19 GGGCCCGG--GTAAAAAAA 3", + new="seqB 19 GGGCCCGG--GTAAAAAAA 4", + ) + assert_true(align_emboss_test_raises(text)) +} + +///| +test "Bio.Align.emboss rejects out-of-range count rows" { + let alignment = align_emboss_test_sample().alignments[0] + let raised = try { + ignore(alignment.pair_counts(-1, 1)) + false + } catch { + AlignEmbossError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.emboss constructor rejects empty document" { + let metadata = @src.AlignEmbossMetadata::create() catch { + _ => abort("default metadata should construct") + } + let raised = try { + ignore(@src.AlignEmbossDocument::create(metadata, [])) + false + } catch { + AlignEmbossError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.emboss constructor rejects invalid annotation length" { + let raised = try { + ignore(@src.AlignEmbossAnnotations::create(0)) + false + } catch { + AlignEmbossError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.emboss constructor rejects negative gap penalty" { + let raised = try { + ignore(@src.AlignEmbossAnnotations::create(5, gap_penalty=Some(-1.0))) + false + } catch { + AlignEmbossError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.emboss constructor rejects empty row identifier" { + let raised = try { + ignore(@src.AlignEmbossSequence::create("", "AC", 0, 2)) + false + } catch { + AlignEmbossError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.emboss constructor rejects empty aligned row" { + let raised = try { + ignore(@src.AlignEmbossSequence::create("row", "", 0, 0)) + false + } catch { + AlignEmbossError(_) => true + } + assert_true(raised) +} diff --git a/test/moonbit/align_exonerate_test.mbt b/test/moonbit/align_exonerate_test.mbt new file mode 100644 index 00000000..c2e335c0 --- /dev/null +++ b/test/moonbit/align_exonerate_test.mbt @@ -0,0 +1,933 @@ +// Black-box tests for Biopython Bio.Align.exonerate-compatible support. + +///| +fn align_exonerate_test_parse(text : String) -> @src.AlignExonerateDocument { + @src.align_exonerate_parse(text) catch { + AlignExonerateError(message) => + abort("valid alignment-aware Exonerate input failed: " + message) + } +} + +///| +fn align_exonerate_test_raises(text : String) -> Bool { + try { + ignore(@src.align_exonerate_parse(text)) + false + } catch { + AlignExonerateError(_) => true + } +} + +///| +fn align_exonerate_test_write_raises( + document : @src.AlignExonerateDocument, + format : String, +) -> Bool { + try { + ignore(@src.align_exonerate_write(document, format~)) + false + } catch { + AlignExonerateError(_) => true + } +} + +///| +fn align_exonerate_test_sample() -> @src.AlignExonerateDocument { + align_exonerate_test_parse(@src.align_exonerate_example_text()) +} + +///| +fn align_exonerate_test_cigar_text() -> String { + "Command line: [exonerate -m affine:local q.fa t.fa]\n" + + "Hostname: [blackbriar]\n" + + "cigar: query 0 8 + target 20 11 - 42 M 3 I 2 M 2 D 3 M 1\n" + + "-- completed exonerate analysis\n" +} + +///| +fn align_exonerate_test_all_operations_text() -> String { + "Command line: [exonerate -m coding2genome q.fa t.fa]\n" + + "Hostname: [worker]\n" + + "vulgar: q 0 15 + t 0 31 + 7 M 3 3 5 0 2 I 0 10 3 0 2 C 3 3 G 2 0 G 0 4 N 5 6 S 1 1 F 1 0\n" + + "-- completed exonerate analysis\n" +} + +///| +fn align_exonerate_test_empty_text() -> String { + "Command line: [exonerate -m est2genome q.fa t.fa]\n" + + "Hostname: [worker]\n" + + "-- completed exonerate analysis\n" +} + +///| +test "Bio.Align.exonerate parses metadata" { + let document = align_exonerate_test_sample() + assert_eq(document.metadata.program, "exonerate") + assert_eq( + document.metadata.command_line, + "exonerate -m est2genome query.fa target.fa --showvulgar yes", + ) + assert_eq(document.metadata.hostname, "moonbit") +} + +///| +test "Bio.Align.exonerate report summary" { + assert_eq( + align_exonerate_test_sample().summary(), + "Exonerate report(host=moonbit, alignments=2)", + ) +} + +///| +test "Bio.Align.exonerate document accessors" { + let document = align_exonerate_test_sample() + assert_eq(document.num_alignments(), 2) + assert_true(document.get(0) is Some(_)) + assert_true(document.get(-1) is None) + assert_true(document.get(2) is None) +} + +///| +test "Bio.Align.exonerate query lookup" { + let document = align_exonerate_test_sample() + assert_eq(document.find_by_query("transcript").length(), 1) + assert_eq(document.find_by_query("missing").length(), 0) +} + +///| +test "Bio.Align.exonerate selects best score" { + let best = align_exonerate_test_sample().best_alignment() + match best { + Some(alignment) => { + assert_eq(alignment.query_id, "transcript") + assert_eq(alignment.score, 250.0) + } + None => abort("sample must have a best alignment") + } +} + +///| +test "Bio.Align.exonerate parses identifiers and score" { + let alignment = align_exonerate_test_sample().alignments[0] + assert_eq(alignment.query_id, "transcript") + assert_eq(alignment.target_id, "chromosome") + assert_eq(alignment.score, 250.0) +} + +///| +test "Bio.Align.exonerate normalizes spliced operations" { + let alignment = align_exonerate_test_sample().alignments[0] + assert_eq(alignment.operation_codes(), "M5N3M") + assert_eq(alignment.num_operations(), 5) + assert_eq(alignment.operations[2].query_step, 0) + assert_eq(alignment.operations[2].target_step, 96) +} + +///| +test "Bio.Align.exonerate builds spliced coordinate path" { + let path = align_exonerate_test_sample().alignments[0].coordinate_path() + assert_eq(path[0], [100, 106, 108, 204, 206, 218]) + assert_eq(path[1], [0, 6, 6, 6, 6, 18]) +} + +///| +test "Bio.Align.exonerate preserves forward bounds" { + let alignment = align_exonerate_test_sample().alignments[0] + assert_eq(alignment.query_start, 0) + assert_eq(alignment.query_end, 18) + assert_eq(alignment.target_start, 100) + assert_eq(alignment.target_end, 218) + assert_eq(alignment.query_strand, @src.AlignExonerateForward) + assert_eq(alignment.target_strand, @src.AlignExonerateForward) +} + +///| +test "Bio.Align.exonerate reports inferred sequence lengths" { + let first = align_exonerate_test_sample().alignments[0] + let second = align_exonerate_test_sample().alignments[1] + assert_eq(first.query_length(), 18) + assert_eq(first.target_length(), 218) + assert_eq(second.query_length(), 4) + assert_eq(second.target_length(), 500) +} + +///| +test "Bio.Align.exonerate maps forward query positions" { + let alignment = align_exonerate_test_sample().alignments[0] + assert_eq(alignment.query_position_to_target(0), Some(100)) + assert_eq(alignment.query_position_to_target(5), Some(105)) + assert_eq(alignment.query_position_to_target(6), Some(206)) + assert_eq(alignment.query_position_to_target(17), Some(217)) +} + +///| +test "Bio.Align.exonerate maps forward target positions" { + let alignment = align_exonerate_test_sample().alignments[0] + assert_eq(alignment.target_position_to_query(100), Some(0)) + assert_eq(alignment.target_position_to_query(217), Some(17)) +} + +///| +test "Bio.Align.exonerate mapping returns none in splice and intron" { + let alignment = align_exonerate_test_sample().alignments[0] + assert_eq(alignment.target_position_to_query(106), None) + assert_eq(alignment.target_position_to_query(108), None) + assert_eq(alignment.target_position_to_query(204), None) +} + +///| +test "Bio.Align.exonerate mapping rejects outside positions" { + let alignment = align_exonerate_test_sample().alignments[0] + assert_eq(alignment.query_position_to_target(-1), None) + assert_eq(alignment.query_position_to_target(18), None) + assert_eq(alignment.target_position_to_query(218), None) +} + +///| +test "Bio.Align.exonerate parses protein strand" { + let alignment = align_exonerate_test_sample().alignments[1] + assert_eq(alignment.query_strand, @src.AlignExonerateProtein) + assert_eq(alignment.target_strand, @src.AlignExonerateReverse) + assert_eq(alignment.operation_codes(), "M") +} + +///| +test "Bio.Align.exonerate builds translated reverse path" { + let path = align_exonerate_test_sample().alignments[1].coordinate_path() + assert_eq(path[0], [500, 488]) + assert_eq(path[1], [0, 4]) +} + +///| +test "Bio.Align.exonerate maps protein to reverse codons" { + let alignment = align_exonerate_test_sample().alignments[1] + assert_eq(alignment.query_position_to_target(0), Some(499)) + assert_eq(alignment.query_position_to_target(1), Some(496)) + assert_eq(alignment.query_position_to_target(3), Some(490)) +} + +///| +test "Bio.Align.exonerate maps reverse DNA to protein" { + let alignment = align_exonerate_test_sample().alignments[1] + assert_eq(alignment.target_position_to_query(499), Some(0)) + assert_eq(alignment.target_position_to_query(498), Some(0)) + assert_eq(alignment.target_position_to_query(497), Some(0)) + assert_eq(alignment.target_position_to_query(496), Some(1)) +} + +///| +test "Bio.Align.exonerate emits translated aligned pairs" { + let pairs = align_exonerate_test_sample().alignments[1].aligned_pairs() + assert_eq(pairs.length(), 4) + assert_eq(pairs[0], (499, 0)) + assert_eq(pairs[1], (496, 1)) + assert_eq(pairs[3], (490, 3)) +} + +///| +test "Bio.Align.exonerate counts spliced alignment" { + let counts = align_exonerate_test_sample().alignments[0].counts() + assert_eq(counts.operations, 5) + assert_eq(counts.matching_operations, 2) + assert_eq(counts.aligned_query_units, 18) + assert_eq(counts.aligned_target_units, 18) + assert_eq(counts.introns, 1) + assert_eq(counts.intron_units, 96) +} + +///| +test "Bio.Align.exonerate counts contiguous target gaps" { + let counts = align_exonerate_test_sample().alignments[0].counts() + assert_eq(counts.insertions, 0) + assert_eq(counts.deletions, 100) + assert_eq(counts.insertion_opens, 0) + assert_eq(counts.deletion_opens, 1) +} + +///| +test "Bio.Align.exonerate alignment summary" { + assert_eq( + align_exonerate_test_sample().alignments[1].summary(), + "Exonerate alignment(query=protein, target=genome, score=80, operations=1)", + ) +} + +///| +test "Bio.Align.exonerate parses reverse cigar" { + let alignment = align_exonerate_test_parse(align_exonerate_test_cigar_text()).alignments[0] + assert_eq(alignment.query_strand, @src.AlignExonerateForward) + assert_eq(alignment.target_strand, @src.AlignExonerateReverse) + assert_eq(alignment.operation_codes(), "MIMDM") +} + +///| +test "Bio.Align.exonerate cigar coordinate path" { + let path = align_exonerate_test_parse(align_exonerate_test_cigar_text()).alignments[0].coordinate_path() + assert_eq(path[0], [20, 17, 17, 15, 12, 11]) + assert_eq(path[1], [0, 3, 5, 7, 7, 8]) +} + +///| +test "Bio.Align.exonerate parses protein2dna cigar" { + let text = "Command line: [protein2dna]\n" + + "Hostname: [host]\n" + + "cigar: protein 0 4 . genome 100 91 - 20 M 6 I 1 M 3\n" + + "-- completed exonerate analysis\n" + let alignment = align_exonerate_test_parse(text).alignments[0] + assert_eq(alignment.operation_codes(), "MIM") + assert_eq(alignment.operations[0].query_step, 2) + assert_eq(alignment.operations[0].target_step, 6) + assert_eq(alignment.operations[1].query_step, 1) +} + +///| +test "Bio.Align.exonerate protein2dna cigar path" { + let text = "Command line: [protein2dna]\n" + + "Hostname: [host]\n" + + "cigar: protein 0 4 . genome 100 91 - 20 M 6 I 1 M 3\n" + + "-- completed exonerate analysis\n" + let path = align_exonerate_test_parse(text).alignments[0].coordinate_path() + assert_eq(path[0], [100, 94, 94, 91]) + assert_eq(path[1], [0, 2, 3, 4]) +} + +///| +test "Bio.Align.exonerate parses dna2protein cigar" { + let text = "Command line: [dna2protein]\n" + + "Hostname: [host]\n" + + "cigar: dna 0 9 + protein 0 4 . 20 M 6 D 1 M 3\n" + + "-- completed exonerate analysis\n" + let alignment = align_exonerate_test_parse(text).alignments[0] + assert_eq(alignment.operation_codes(), "MDM") + assert_eq(alignment.operations[0].query_step, 6) + assert_eq(alignment.operations[0].target_step, 2) + assert_eq(alignment.operations[1].target_step, 1) +} + +///| +test "Bio.Align.exonerate dna2protein mapping" { + let text = "Command line: [dna2protein]\n" + + "Hostname: [host]\n" + + "cigar: dna 0 9 + protein 0 4 . 20 M 6 D 1 M 3\n" + + "-- completed exonerate analysis\n" + let alignment = align_exonerate_test_parse(text).alignments[0] + assert_eq(alignment.query_position_to_target(0), Some(0)) + assert_eq(alignment.query_position_to_target(3), Some(1)) + assert_eq(alignment.target_position_to_query(2), None) + assert_eq(alignment.query_position_to_target(6), Some(3)) +} + +///| +test "Bio.Align.exonerate parses every vulgar operation" { + let alignment = align_exonerate_test_parse( + align_exonerate_test_all_operations_text(), + ).alignments[0] + assert_eq(alignment.operation_codes(), "M5N3CIDUUSF") + assert_eq(alignment.num_operations(), 11) +} + +///| +test "Bio.Align.exonerate splits non-equivalenced operation" { + let alignment = align_exonerate_test_parse( + align_exonerate_test_all_operations_text(), + ).alignments[0] + assert_eq(alignment.operations[7].code, "U") + assert_eq(alignment.operations[7].query_step, 0) + assert_eq(alignment.operations[7].target_step, 6) + assert_eq(alignment.operations[8].query_step, 5) + assert_eq(alignment.operations[8].target_step, 0) +} + +///| +test "Bio.Align.exonerate counts special operations" { + let counts = align_exonerate_test_parse( + align_exonerate_test_all_operations_text(), + ).alignments[0].counts() + assert_eq(counts.introns, 1) + assert_eq(counts.intron_units, 10) + assert_eq(counts.non_equivalenced_units, 11) + assert_eq(counts.split_codons, 1) + assert_eq(counts.frameshifts, 1) +} + +///| +test "Bio.Align.exonerate counts insertions and deletions" { + let counts = align_exonerate_test_parse( + align_exonerate_test_all_operations_text(), + ).alignments[0].counts() + assert_eq(counts.insertions, 8) + assert_eq(counts.deletions, 24) + assert_eq(counts.insertion_opens, 3) + assert_eq(counts.deletion_opens, 2) +} + +///| +test "Bio.Align.exonerate vulgar canonical round trip" { + let document = align_exonerate_test_parse( + align_exonerate_test_all_operations_text(), + ) + let output = @src.align_exonerate_write(document, format="vulgar") catch { + AlignExonerateError(message) => abort("vulgar writing failed: " + message) + } + assert_eq(align_exonerate_test_parse(output), document) +} + +///| +test "Bio.Align.exonerate sample vulgar round trip" { + let document = align_exonerate_test_sample() + let output = @src.align_exonerate_write(document) catch { + AlignExonerateError(message) => + abort("default vulgar writing failed: " + message) + } + assert_eq(align_exonerate_test_parse(output), document) +} + +///| +test "Bio.Align.exonerate cigar round trip preserves cigar paths" { + let document = align_exonerate_test_parse(align_exonerate_test_cigar_text()) + let output = @src.align_exonerate_write(document, format="cigar") catch { + AlignExonerateError(message) => abort("cigar writing failed: " + message) + } + assert_eq(align_exonerate_test_parse(output), document) +} + +///| +test "Bio.Align.exonerate vulgar to cigar preserves paths" { + let document = align_exonerate_test_sample() + let output = @src.align_exonerate_write(document, format="cigar") catch { + AlignExonerateError(message) => + abort("vulgar-to-cigar writing failed: " + message) + } + let converted = align_exonerate_test_parse(output) + assert_eq( + converted.alignments[0].coordinate_path(), + document.alignments[0].coordinate_path(), + ) + assert_eq( + converted.alignments[1].coordinate_path(), + document.alignments[1].coordinate_path(), + ) +} + +///| +test "Bio.Align.exonerate translated cigar round trip" { + let document = align_exonerate_test_sample() + let output = @src.align_exonerate_write(document, format="cigar") catch { + AlignExonerateError(message) => + abort("translated cigar writing failed: " + message) + } + let converted = align_exonerate_test_parse(output) + assert_eq(converted.alignments[1].operations[0].query_step, 4) + assert_eq(converted.alignments[1].operations[0].target_step, 12) +} + +///| +test "Bio.Align.exonerate writes canonical metadata and footer" { + let output = @src.align_exonerate_write( + align_exonerate_test_sample(), + format="vulgar", + ) catch { + AlignExonerateError(message) => + abort("canonical writing failed: " + message) + } + assert_true(output.has_prefix("Command line: [")) + assert_true(output.contains("\nHostname: [moonbit]\n")) + assert_true(output.has_suffix("-- completed exonerate analysis\n")) +} + +///| +test "Bio.Align.exonerate supports valid zero-hit report" { + let document = align_exonerate_test_parse(align_exonerate_test_empty_text()) + assert_eq(document.num_alignments(), 0) + assert_eq(document.best_alignment(), None) +} + +///| +test "Bio.Align.exonerate zero-hit round trip" { + let document = align_exonerate_test_parse(align_exonerate_test_empty_text()) + let output = @src.align_exonerate_write(document) catch { + AlignExonerateError(message) => abort("zero-hit writing failed: " + message) + } + assert_eq(align_exonerate_test_parse(output), document) +} + +///| +test "Bio.Align.exonerate accepts CRLF" { + let text = @src.align_exonerate_example_text().replace_all( + old="\n", + new="\r\n", + ) + assert_eq(align_exonerate_test_parse(text).num_alignments(), 2) +} + +///| +test "Bio.Align.exonerate accepts blank body lines" { + let text = @src.align_exonerate_example_text().replace_all( + old="Hostname: [moonbit]\n", + new="Hostname: [moonbit]\n\n", + ) + assert_eq(align_exonerate_test_parse(text).num_alignments(), 2) +} + +///| +test "Bio.Align.exonerate parses mixed cigar and vulgar lines" { + let text = "Command line: [mixed]\n" + + "Hostname: [host]\n" + + "vulgar: q 0 3 + t 0 3 + 1 M 3 3\n" + + "cigar: q 0 3 + t 0 3 + 1 M 3\n" + + "-- completed exonerate analysis\n" + let document = align_exonerate_test_parse(text) + assert_eq(document.num_alignments(), 2) + assert_eq( + document.alignments[0].coordinate_path(), + document.alignments[1].coordinate_path(), + ) +} + +///| +test "Bio.Align.exonerate metadata constructor" { + let metadata = @src.AlignExonerateMetadata::create( + command_line="exonerate query.fa target.fa", + hostname="node", + ) catch { + AlignExonerateError(message) => + abort("metadata construction failed: " + message) + } + assert_eq(metadata.program, "exonerate") + assert_eq(metadata.hostname, "node") +} + +///| +test "Bio.Align.exonerate operation constructors" { + let match_op = @src.AlignExonerateOperation::create("M", 3, 3) catch { + AlignExonerateError(message) => + abort("match construction failed: " + message) + } + let intron = @src.AlignExonerateOperation::create("N", 0, 10) catch { + AlignExonerateError(message) => + abort("intron construction failed: " + message) + } + assert_eq(match_op.code, "M") + assert_eq(intron.target_step, 10) +} + +///| +test "Bio.Align.exonerate alignment constructor" { + let operation = @src.AlignExonerateOperation::create("M", 3, 3) catch { + AlignExonerateError(message) => + abort("operation construction failed: " + message) + } + let alignment = @src.AlignExonerateAlignment::create( + "q", + 0, + 3, + @src.AlignExonerateForward, + "t", + 10, + 7, + @src.AlignExonerateReverse, + 5.0, + [operation], + ) catch { + AlignExonerateError(message) => + abort("alignment construction failed: " + message) + } + assert_eq(alignment.coordinate_path()[0], [10, 7]) +} + +///| +test "Bio.Align.exonerate document constructor copies alignments" { + let metadata = @src.AlignExonerateMetadata::create() catch { + AlignExonerateError(message) => + abort("metadata construction failed: " + message) + } + let alignments : Array[@src.AlignExonerateAlignment] = [] + let document = @src.AlignExonerateDocument::create(metadata, alignments) catch { + AlignExonerateError(message) => + abort("document construction failed: " + message) + } + alignments.push(align_exonerate_test_sample().alignments[0]) + assert_eq(document.num_alignments(), 0) +} + +///| +test "Bio.Align.exonerate rejects empty input" { + assert_true(align_exonerate_test_raises("")) +} + +///| +test "Bio.Align.exonerate rejects missing command header" { + assert_true( + align_exonerate_test_raises( + "Hostname: [host]\n-- completed exonerate analysis\n", + ), + ) +} + +///| +test "Bio.Align.exonerate rejects missing hostname header" { + assert_true( + align_exonerate_test_raises( + "Command line: [cmd]\n-- completed exonerate analysis\n", + ), + ) +} + +///| +test "Bio.Align.exonerate rejects unbracketed command" { + assert_true( + align_exonerate_test_raises( + "Command line: cmd\nHostname: [host]\n-- completed exonerate analysis\n", + ), + ) +} + +///| +test "Bio.Align.exonerate rejects unbracketed hostname" { + assert_true( + align_exonerate_test_raises( + "Command line: [cmd]\nHostname: host\n-- completed exonerate analysis\n", + ), + ) +} + +///| +test "Bio.Align.exonerate rejects missing footer" { + assert_true( + align_exonerate_test_raises("Command line: [cmd]\nHostname: [host]\n"), + ) +} + +///| +test "Bio.Align.exonerate rejects data after footer" { + assert_true( + align_exonerate_test_raises( + align_exonerate_test_empty_text() + "vulgar: q 0 1 + t 0 1 + 1 M 1 1\n", + ), + ) +} + +///| +test "Bio.Align.exonerate rejects unknown body line" { + assert_true( + align_exonerate_test_raises( + "Command line: [cmd]\nHostname: [host]\nunknown\n-- completed exonerate analysis\n", + ), + ) +} + +///| +test "Bio.Align.exonerate rejects malformed vulgar field count" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 3 + t 0 3 + 1 M 3\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects malformed cigar field count" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "cigar: q 0 3 + t 0 3 + 1 M\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects negative coordinate" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q -1 2 + t 0 3 + 1 M 3 3\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects coordinate overflow" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 2147483648 + t 0 1 + 1 M 1 1\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects invalid score" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 3 + t 0 3 + score M 3 3\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects non-finite score" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 3 + t 0 3 + 1e301 M 3 3\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects invalid query strand" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 3 ? t 0 3 + 1 M 3 3\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects invalid target strand" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 3 + t 0 3 ? 1 M 3 3\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects forward decreasing coordinates" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 3 0 + t 0 3 + 1 M 3 3\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects reverse increasing coordinates" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 3 - t 0 3 + 1 M 3 3\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects protein decreasing coordinates" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 3 0 . t 0 3 + 1 M 3 3\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects query span mismatch" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 4 + t 0 3 + 1 M 3 3\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects target span mismatch" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 3 + t 0 4 + 1 M 3 3\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects unknown vulgar operation" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 3 + t 0 3 + 1 X 3 3\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects empty vulgar operation" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 1 + t 0 1 + 1 M 0 0\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects two-axis vulgar gap" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 1 + t 0 1 + 1 G 1 1\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects empty vulgar gap" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 1 + t 0 1 + 1 G 0 0\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects invalid splice site" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 1 + t 0 1 + 1 5 1 1\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects invalid codon step" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 2 + t 0 2 + 1 C 2 2\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects two-axis intron" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 1 + t 0 1 + 1 I 1 1\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects empty non-equivalenced region" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "vulgar: q 0 1 + t 0 1 + 1 N 0 0\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects unknown cigar operation" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "cigar: q 0 3 + t 0 3 + 1 X 3\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects zero cigar step" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "cigar: q 0 1 + t 0 1 + 1 M 0\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate rejects header-only alignment line" { + let text = "Command line: [cmd]\nHostname: [host]\n" + + "cigar: q 0 1 + t 0 1 + 1\n" + + "-- completed exonerate analysis\n" + assert_true(align_exonerate_test_raises(text)) +} + +///| +test "Bio.Align.exonerate metadata rejects newline" { + let raised = try { + ignore(@src.AlignExonerateMetadata::create(hostname="bad\nhost")) + false + } catch { + AlignExonerateError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.exonerate operation rejects negative step" { + let raised = try { + ignore(@src.AlignExonerateOperation::create("M", -1, 1)) + false + } catch { + AlignExonerateError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.exonerate operation rejects unknown code" { + let raised = try { + ignore(@src.AlignExonerateOperation::create("Q", 1, 1)) + false + } catch { + AlignExonerateError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.exonerate alignment rejects whitespace identifier" { + let operation = @src.AlignExonerateOperation::create("M", 1, 1) catch { + AlignExonerateError(message) => + abort("operation construction failed: " + message) + } + let raised = try { + ignore( + @src.AlignExonerateAlignment::create( + "bad query", + 0, + 1, + @src.AlignExonerateForward, + "target", + 0, + 1, + @src.AlignExonerateForward, + 1.0, + [operation], + ), + ) + false + } catch { + AlignExonerateError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.exonerate alignment rejects no operations" { + let raised = try { + ignore( + @src.AlignExonerateAlignment::create( + "q", + 0, + 1, + @src.AlignExonerateForward, + "t", + 0, + 1, + @src.AlignExonerateForward, + 1.0, + [], + ), + ) + false + } catch { + AlignExonerateError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.exonerate rejects unsupported writer format" { + assert_true( + align_exonerate_test_write_raises(align_exonerate_test_sample(), "text"), + ) +} + +///| +test "Bio.Align.exonerate cigar writer rejects unequal plain match" { + let operation = @src.AlignExonerateOperation::create("M", 1, 2) catch { + AlignExonerateError(message) => + abort("operation construction failed: " + message) + } + let alignment = @src.AlignExonerateAlignment::create( + "q", + 0, + 1, + @src.AlignExonerateForward, + "t", + 0, + 2, + @src.AlignExonerateForward, + 1.0, + [operation], + ) catch { + AlignExonerateError(message) => + abort("alignment construction failed: " + message) + } + let metadata = @src.AlignExonerateMetadata::create() catch { + AlignExonerateError(message) => + abort("metadata construction failed: " + message) + } + let document = @src.AlignExonerateDocument::create(metadata, [alignment]) catch { + AlignExonerateError(message) => + abort("document construction failed: " + message) + } + assert_true(align_exonerate_test_write_raises(document, "cigar")) +} From 8dce9b1063f2d0b77bb34d8b1aa0c5a13e6e7e95 Mon Sep 17 00:00:00 2001 From: eda Date: Wed, 5 Aug 2026 23:51:20 +0800 Subject: [PATCH 33/41] #28 pass:10852 feat: MSF, NEXUS, Stockholm, Chain, MAF, BED alignment formats --- README.md | 142 +- examples/align_bed_demo/main.mbt | 157 ++ examples/align_bed_demo/moon.pkg | 5 + examples/align_chain_demo/main.mbt | 114 ++ examples/align_chain_demo/moon.pkg | 5 + examples/align_maf_demo/main.mbt | 155 ++ examples/align_maf_demo/moon.pkg | 5 + examples/align_nexus_demo/main.mbt | 134 ++ examples/align_nexus_demo/moon.pkg | 5 + examples/align_stockholm_demo/main.mbt | 119 ++ examples/align_stockholm_demo/moon.pkg | 5 + examples/msf_demo/main.mbt | 113 ++ examples/msf_demo/moon.pkg | 5 + src/align_bed.mbt | 1265 ++++++++++++ src/align_chain.mbt | 1403 ++++++++++++++ src/align_maf.mbt | 1418 ++++++++++++++ src/align_nexus.mbt | 2111 +++++++++++++++++++++ src/align_stockholm.mbt | 2426 ++++++++++++++++++++++++ src/msf.mbt | 1395 ++++++++++++++ test/moonbit/align_bed_test.mbt | 1290 +++++++++++++ test/moonbit/align_chain_test.mbt | 1340 +++++++++++++ test/moonbit/align_maf_test.mbt | 1266 +++++++++++++ test/moonbit/align_nexus_test.mbt | 1069 +++++++++++ test/moonbit/align_stockholm_test.mbt | 1569 +++++++++++++++ test/moonbit/msf_test.mbt | 1140 +++++++++++ 25 files changed, 18648 insertions(+), 8 deletions(-) create mode 100644 examples/align_bed_demo/main.mbt create mode 100644 examples/align_bed_demo/moon.pkg create mode 100644 examples/align_chain_demo/main.mbt create mode 100644 examples/align_chain_demo/moon.pkg create mode 100644 examples/align_maf_demo/main.mbt create mode 100644 examples/align_maf_demo/moon.pkg create mode 100644 examples/align_nexus_demo/main.mbt create mode 100644 examples/align_nexus_demo/moon.pkg create mode 100644 examples/align_stockholm_demo/main.mbt create mode 100644 examples/align_stockholm_demo/moon.pkg create mode 100644 examples/msf_demo/main.mbt create mode 100644 examples/msf_demo/moon.pkg create mode 100644 src/align_bed.mbt create mode 100644 src/align_chain.mbt create mode 100644 src/align_maf.mbt create mode 100644 src/align_nexus.mbt create mode 100644 src/align_stockholm.mbt create mode 100644 src/msf.mbt create mode 100644 test/moonbit/align_bed_test.mbt create mode 100644 test/moonbit/align_chain_test.mbt create mode 100644 test/moonbit/align_maf_test.mbt create mode 100644 test/moonbit/align_nexus_test.mbt create mode 100644 test/moonbit/align_stockholm_test.mbt create mode 100644 test/moonbit/msf_test.mbt diff --git a/README.md b/README.md index dd4a3644..09aef93e 100644 --- a/README.md +++ b/README.md @@ -39,6 +39,12 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **A2M状态感知多序列比对** | Biopython `Bio.Align.a2m` | match/insertion列状态、大小写与点语义、严格读写、坐标映射、插入槽、统计、共识及match-only投影 | ✅ | | **EMBOSS alignment输出** | Biopython `Bio.Align.emboss` | srspair/pair/simple报告、多alignment与多序列、局部/反向坐标、consensus统计、坐标路径及规范往返 | ✅ | | **Exonerate alignment输出** | Biopython `Bio.Align.exonerate` | cigar/vulgar严格读写、完整operation path、正反链与protein strand、3:1 translated坐标、双向映射及规范往返 | ✅ | +| **GCG MSF多序列比对** | Biopython `Bio.Align.msf` | AA/NA/PileUp严格解析、interleaved rows、标准GCG checksum、gap规范化、坐标路径、统计及canonical writer | ✅ | +| **NEXUS多序列比对** | Biopython `Bio.Align.nexus` | DATA/CHARACTERS/TAXA、nested comments、quoted taxa、sequential/interleaved MATRIX、MATCHCHAR、坐标统计及canonical writer | ✅ | +| **Stockholm注释型多序列比对** | Biopython `Bio.Align.stockholm` | 多记录严格读写、GF/GS/GR/GC、reference与database reference、insertion/deletion列、all-gap压缩、坐标统计及canonical writer | ✅ | +| **UCSC Chain成对比对** | Biopython `Bio.Align.chain` | 12/13字段严格读写、连续多记录、正反双轴绝对坐标路径、size/dt/dq块、双向位置/区间映射、反转及canonical writer | ✅ | +| **现代MAF多基因组比对** | Biopython `Bio.Align.maf` | track/header与a/s/i/e/q严格读写、正负链绝对坐标路径、任意component映射、MafIndex半开区间查询、多外显子拼接及canonical writer | ✅ | +| **现代BED成对比对** | Biopython `Bio.Align.bed` | BED3-BED12严格读写、正负链target/query路径、exon block重建、双向residue映射、半开区间查询及分级writer | ✅ | | **系统发育树** | Biopython `Bio.Phylo` | 树结构、Newick 解析、距离计算、可视化 | ✅ | | **PDB 结构** | Biopython `Bio.PDB` | 原子/残基/链解析、结构操作 | ✅ | | **BinaryCIF** | Biopython `Bio.PDB.binary_cif` | MessagePack解析、七类逆编码、三态缺失值、类别查询、PDB Structure转换 | ✅ | @@ -79,7 +85,9 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | Bio.protein_analysis | 蛋白质序列高级分析: Kyte-Doolittle疏水性滑动窗口、GOR二级结构预测、Hopp-Woods抗原性、跨膜区段预测、氨基酸/二肽/三肽组成、Shannon熵保守性评分 | | ✅ | Bio.PCD | 质谱PCD格式解析: 质谱图谱(Scan/RT/PEPMASS)、峰列表提取、总离子流色谱图(TIC)、基峰色谱图(BPC)、m/z范围过滤、前体离子信息、序列化往返 | | ✅ | Bio.PDB.Dice + Selection | PDB结构切割（链/残基/原子/模型提取）、B因子过滤、几何选择、结构统计、序列提取 | -| ✅ | Bio.Align.MAF | MAF (Multiple Alignment Format) 多序列比对格式解析、块处理、百分比一致性计算、统计分析、格式转换 | +| ✅ | Bio.Align.MAF | 宽松MAF块解析、选择/过滤、百分比一致性、统计分析与格式转换 | +| ✅ | Bio.Align.maf | 现代MAF document/track、严格a/s/i/e/q、绝对坐标路径、component映射、参考区间索引、多外显子拼接与规范往返 | +| ✅ | Bio.Align.bed | BED3-BED12 pairwise alignment、双轴链向坐标、block投影、双向residue映射、区间搜索与分级写回 | | ✅ | Bio.Align.Mauve | Mauve 基因组比对格式解析、LCB(共线性块)检测、倒位检测、断点检测、基因组覆盖率、BED导出 | | ✅ | Bio.Stockholm | Stockholm 格式解析 (Pfam/Rfam比对格式)、二级结构注释、百分比一致性、保守性分析、FASTA转换 | | ✅ | Bio.PopGen (advanced) | 高级群体遗传学统计: Tajima's D, Fu & Li's D/F, McDonald-Kreitman检验, 等位基因频率谱, 中性分析 | @@ -172,6 +180,12 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | Bio.Align.a2m | A2M match/insertion状态推导、大小写与点gap规范读写、插入槽、逐行坐标映射、pair counts、共识和match projection | | ✅ | Bio.Align.emboss | EMBOSS srspair/pair/simple文件元数据与多alignment解析、任意序列数、纯gap block、局部/反向坐标、consensus统计、compact path和规范写回 | | ✅ | Bio.Align.exonerate | Exonerate cigar/vulgar文件元数据与严格读写、完整M/5/I/3/C/G/N/S/F操作、正反链/protein strand、3:1 translated path、坐标互映和统计 | +| ✅ | Bio.Align.msf | GCG/PileUp MSF蛋白质与核酸MSA、Check/CompCheck、interleaved blocks、标准checksum、短行补齐、坐标映射、统计与规范写回 | +| ✅ | Bio.Align.nexus | NEXUS DATA/CHARACTERS与TAXA block、nested comments、quoted/duplicate taxa、sequential/interleaved MATRIX、datatype校验、MATCHCHAR、坐标映射、统计与规范写回 | +| ✅ | Bio.Align.stockholm | Stockholm多记录、GF/GS/GR/GC标准与自定义注释、reference/database/nested-domain、M/D/I列操作、all-gap压缩、坐标映射、统计与规范写回 | +| ✅ | Bio.Align.chain | UCSC Chain严格多记录读写、float score与可选ID、正反target/query绝对坐标路径、size/dt/dq重建、双向位置/区间映射、反转和查询 | +| ✅ | Bio.Align.maf | MAF track/header与a/s/i/e/q严格读写、plus/minus绝对路径、任意component映射、MafIndex半开查询、多外显子拼接与canonical writer | +| ✅ | Bio.Align.bed | BED3-BED12严格解析与写出、numeric/text score、正负链query坐标、exon blocks、双向residue mapping、search与summary | | ✅ | Bio.Align.bigbed | BigBed v4二进制读写、BED3-BED12、AutoSQL扩展字段、多级chromosome B+ tree与R-tree、zlib/DEFLATE解码、区间/名称查询和BED导出 | | ✅ | Bio.Align.bigmaf | 标准bedMaf bed3+1读写、完整MAF a/s/i/e/q语义、正负链坐标映射、BigBed压缩索引查询、MAF导出和严格损坏数据诊断 | | ✅ | Bioconductor decontX | 单细胞ambient RNA去污染: cluster-native/contaminant多项式混合、Beta/Dirichlet先验EM、empty-droplet background、自动聚类、计数分解、诊断与SingleCellExperiment接入 | @@ -242,6 +256,12 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **A2M状态感知比对** | Biopython `Bio.Align.a2m` | D/I列状态、大小写与点gap编码、wrapped/CRLF读写、坐标互映、插入槽、统计、共识与match投影 | ✅ | | **EMBOSS alignment报告** | Biopython `Bio.Align.emboss` | srspair/pair/simple元数据、固定列block、多alignment/多序列、正反向绝对坐标、pair counts与canonical writer | ✅ | | **Exonerate alignment报告** | Biopython `Bio.Align.exonerate` | header/footer与cigar/vulgar、operation normalization、链感知绝对路径、protein-DNA 3:1映射、统计与canonical writer | ✅ | +| **GCG MSF alignment** | Biopython `Bio.Align.msf` | AA/NA/PileUp header、Name metadata、interleaved blocks、GCG checksum、三类gap、coordinate path、pair counts与writer | ✅ | +| **NEXUS alignment** | Biopython `Bio.Align.nexus` | DATA/CHARACTERS/TAXA block、quote/comment词法、sequential/interleaved rows、DNA/RNA/protein/standard校验、MATCHCHAR、坐标与writer | ✅ | +| **Stockholm alignment** | Biopython `Bio.Align.stockholm` | 严格header/terminator与多记录、GF/GS/GR/GC映射、M/D/I操作、all-gap列压缩、reference、坐标、统计与writer | ✅ | +| **UCSC Chain alignment** | Biopython `Bio.Align.chain` | 12/13列header、连续记录、float score、双轴链向、绝对half-open路径、size/dt/dq、坐标查询、反转与规范写回 | ✅ | +| **MAF alignment/index** | Biopython `Bio.Align.maf` | track/header与a/s/i/e/q、正负链绝对坐标、任意component映射、MafIndex半开查询、多外显子拼接与规范写回 | ✅ | +| **BED pairwise alignment** | Biopython `Bio.Align.bed` | BED3-BED12、target/query双轴路径、反链转录本坐标、block/counts、双向位置映射、区间搜索与分级写回 | ✅ | | **BigBed二进制区间索引** | Biopython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12与AutoSQL、多级B+ tree/R-tree、stored/fixed/dynamic DEFLATE、区间/名称查询、链感知exon坐标及BED导出 | ✅ | | **BigMaf多物种比对索引** | Biopython `Bio.Align.bigmaf` | 标准bedMaf AutoSQL、MAF a/s/i/e/q块、score/pass/comment、正负链坐标映射、压缩BigBed索引查询及普通MAF导出 | ✅ | | **BigPsl成对比对索引** | Biopython `Bio.Align.bigpsl` | 标准bed12+13 AutoSQL、核酸与translated protein坐标路径、正反链、match/repeat/N recount、压缩索引查询及PSL导出 | ✅ | @@ -387,7 +407,9 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | BiocSingular | SVD奇异值分解，支持Exact/IRLBA/Randomized三种算法，用于单细胞降维 | | ✅ | BiocNeighbors | KMKNN和Annoy最近邻搜索，支持欧几里得/曼哈顿/余弦距离 | | ✅ | mixOmics | 多组学整合方法，包括PLS回归、稀疏PLS (sPLS)、DIABLO多块整合 | -| **MAF格式解析** | Biopython `Bio.Align` | MAF多序列比对格式解析、块操作、百分比一致性、统计分析、选择/过滤/写回 | ✅ | +| **MAF宽松块分析** | Biopython `Bio.Align` | MAF块解析、百分比一致性、统计分析、选择/过滤/写回 | ✅ | +| **现代MAF alignment API** | Biopython `Bio.Align.maf` | track/header、严格a/s/i/e/q、正负链绝对坐标、component映射、MafIndex区间搜索、多外显子拼接及canonical写回 | ✅ | +| **现代BED alignment API** | Biopython `Bio.Align.bed` | 分级BED3-BED12读写、链感知双轴路径、exon block投影、residue mapping、overlap search与summary | ✅ | | **HH-suite HHR格式** | Biopython `Bio.Align.hhr` | HHsearch/HHblits结果严格解析、0-based坐标、query-target映射、规范化写回 | ✅ | | **共享参考比对同步** | Biopython `Bio.Align.Alignment` | 相同参考PWA/MSA合并、边界插入宽度归一化、query原始比对结构保留、reference/query/column坐标互映 | ✅ | | **Alignment gap/composition统计** | Biopython `Bio.Align.Alignment.counts` | pairwise与MSA逐对统计、端部/内部gap分类、open/extend事件、替换和gap总分 | ✅ | @@ -397,6 +419,12 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **A2M状态感知MSA** | Biopython `Bio.Align.a2m` | match/deletion与insertion列、canonical大小写/点编码、严格往返、坐标映射、插入槽、统计与共识 | ✅ | | **EMBOSS alignment output** | Biopython `Bio.Align.emboss` | water/needle/stretcher/matcher/alignret输出、srspair/pair/simple、metadata、consensus、局部/反向坐标与严格诊断 | ✅ | | **Exonerate alignment output** | Biopython `Bio.Align.exonerate` | cigar/vulgar报告、M/5/I/3/C/G/N/S/F路径、正反链与protein strand、translated coordinates、严格诊断与双格式写回 | ✅ | +| **GCG MSF alignment format** | Biopython `Bio.Align.msf` | protein/nucleotide MSF、PileUp与EMBOSS变体、interleaved MSA、GCG checksum、坐标和统计、严格读写 | ✅ | +| **NEXUS alignment format** | Biopython `Bio.Align.nexus` | NEXUS header与block、nested comments、quoted taxa、sequential/interleaved MATRIX、MATCHCHAR、all-gap压缩、坐标统计与严格读写 | ✅ | +| **Stockholm alignment format** | Biopython `Bio.Align.stockholm` | 多记录严格解析、GF/GS/GR/GC与自定义注释、reference与database reference、insertion/deletion列、all-gap压缩、坐标统计与严格写回 | ✅ | +| **UCSC Chain alignment format** | Biopython `Bio.Align.chain` | 严格header/block/span校验、连续多记录、正反双轴absolute path、canonical block重建、位置/区间映射、反转与ID/overlap查询 | ✅ | +| **MAF alignment format/index** | Biopython `Bio.Align.maf` | track/##maf metadata、a/s/i/e/q关联校验、链感知absolute path、任意序列坐标映射、reference interval index与spliced alignment | ✅ | +| **BED alignment format** | Biopython `Bio.Align.bed` | BED3-BED12字段层级、numeric/text score、正负链transcript path、block几何校验、双向mapping及canonical projection | ✅ | | **UCSC Chain文件/liftOver** | Bioconductor rtracklayer | Chain格式解析、基因组坐标liftOver转换、链段查找、染色体间坐标映射、位置/区间转换 | ✅ | | **Biostrings matchPDict** | Bioconductor Biostrings | 字典模式匹配(matchPDict/vmatchPattern)、多序列模式计数(vcountPattern)、错配容忍、最佳匹配查找 | ✅ | | **GenomicRanges gaps/reduce/disjoin** | Bioconductor GenomicRanges | gaps检测、reduce合并、disjoin拆分、setdiff/交集/并集集合运算、coverage计算、promoters提取、trim | ✅ | @@ -461,6 +489,12 @@ IvanAXu/BioSeqs/ │ ├── a2m.mbt # Bio.Align.a2m状态感知MSA读写、坐标、插入槽、统计与投影 │ ├── align_emboss.mbt # Bio.Align.emboss srspair/pair/simple解析、坐标、统计与规范写回 │ ├── align_exonerate.mbt # Bio.Align.exonerate cigar/vulgar路径、链向、translated映射与规范写回 +│ ├── msf.mbt # Bio.Align.msf GCG/PileUp MSA、checksum、坐标统计与规范写回 +│ ├── align_nexus.mbt # Bio.Align.nexus DATA/CHARACTERS、interleave、MATCHCHAR、坐标统计与写回 +│ ├── align_stockholm.mbt # Bio.Align.stockholm GF/GS/GR/GC、多记录、列操作、坐标统计与写回 +│ ├── align_chain.mbt # Bio.Align.chain严格读写、双轴链向绝对路径、block重建与坐标映射 +│ ├── align_maf.mbt # Bio.Align.maf严格文档读写、绝对坐标、MafIndex查询与多外显子拼接 +│ ├── align_bed.mbt # Bio.Align.bed BED3-BED12、双轴路径、block投影、坐标映射与分级写回 │ ├── bigbed.mbt # Bio.Align.bigbed v4、BED/AutoSQL、多级B+ tree/R-tree与DEFLATE │ ├── bigmaf.mbt # Bio.Align.bigmaf bedMaf、MAF注释、链向坐标映射与索引查询 │ ├── bigpsl.mbt # Bio.Align.bigpsl bed12+13、核酸/translated protein路径与PSL @@ -702,7 +736,7 @@ IvanAXu/BioSeqs/ │ ├── geoquery.mbt # GEO数据库查询 (GDS/GSE/GSM解析、数据下载、平台信息) │ ├── ggtree.mbt # ggtree 系统发育树可视化布局 (矩形/放射状/无根布局、节点坐标映射) │ ├── mix_omics.mbt # mixOmics 多组学整合 (PLS/sPLS/DIABLO) -│ ├── maf.mbt # MAF (Multiple Alignment Format) 多序列比对格式解析与分析 +│ ├── maf.mbt # 早期宽松MAF块解析、选择、过滤与统计分析 │ ├── mauve.mbt # Mauve 基因组比对格式解析与重排分析 │ ├── stockholm.mbt # Stockholm 格式解析 (Pfam/Rfam比对) 与二级结构分析 │ ├── popgen_advanced.mbt # 高级群体遗传学统计 (Tajima's D, Fu & Li's D/F, MK检验) @@ -1171,6 +1205,12 @@ IvanAXu/BioSeqs/ │ ├── a2m_demo/ # A2M状态解析、插入槽、共识、坐标、统计、投影与往返示例 │ ├── align_emboss_demo/ # EMBOSS元数据、局部/反向坐标、path、统计与wrapped往返示例 │ ├── align_exonerate_demo/ # Exonerate剪接/translated path、坐标映射、统计与双格式往返示例 +│ ├── msf_demo/ # GCG MSF解析、checksum、坐标映射、统计、宽度异常与规范往返示例 +│ ├── align_nexus_demo/ # NEXUS interleave解析、quoted taxa、坐标统计、all-gap压缩与规范往返示例 +│ ├── align_stockholm_demo/ # Stockholm GF/GS/GR/GC、insertion列、坐标统计、all-gap压缩与规范往返示例 +│ ├── align_chain_demo/ # Chain多记录、正反链路径、block/counts、坐标映射、反转与规范往返示例 +│ ├── align_maf_demo/ # MAF track/a/s/i/e/q、绝对路径、component映射、索引、拼接与规范往返示例 +│ ├── align_bed_demo/ # BED3-BED12、正负链路径、block、坐标映射、搜索、统计与规范往返示例 │ ├── bigbed_demo/ # BigBed写入/解析、索引查询、负链exon坐标、BED导出与损坏诊断 │ ├── bigmaf_demo/ # BigMaf压缩写入、bedMaf schema、区间查询、负链映射与MAF导出 │ ├── bigpsl_demo/ # BigPsl压缩写入、R-tree查询、反链/translated坐标与PSL导出 @@ -1390,6 +1430,12 @@ IvanAXu/BioSeqs/ │ │ ├── a2m_test.mbt │ │ ├── align_emboss_test.mbt │ │ ├── align_exonerate_test.mbt +│ │ ├── msf_test.mbt +│ │ ├── align_nexus_test.mbt +│ │ ├── align_stockholm_test.mbt +│ │ ├── align_chain_test.mbt +│ │ ├── align_maf_test.mbt +│ │ ├── align_bed_test.mbt │ │ ├── bigbed_test.mbt │ │ ├── bigmaf_test.mbt │ │ ├── bigpsl_test.mbt @@ -1569,7 +1615,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 10046 个测试全部通过 +moon test # ✅ 10389 个测试全部通过 ``` ### 模块对照表 @@ -1623,6 +1669,12 @@ moon test # ✅ 10046 个测试全 | `a2m.mbt` | BioPython `Bio.Align.a2m` | D/I列状态感知A2M读写、大小写/点编码、逐行坐标映射、插入槽、pair counts、共识及match projection | | `align_emboss.mbt` | BioPython `Bio.Align.emboss` | srspair/pair/simple report解析、文件/比对元数据、多序列block、局部/反向坐标、pair counts、compact path与规范写回 | | `align_exonerate.mbt` | BioPython `Bio.Align.exonerate` | alignment-aware cigar/vulgar严格读写、完整operation path、链向与protein strand、translated mapping、统计和规范写回 | +| `msf.mbt` | BioPython `Bio.Align.msf` | GCG/PileUp MSF严格解析、AA/NA metadata、interleaved rows、标准checksum、坐标映射、统计与canonical writer | +| `align_nexus.mbt` | BioPython `Bio.Align.nexus` | DATA/CHARACTERS/TAXA block、quote/comment-aware解析、sequential/interleaved MATRIX、datatype与MATCHCHAR、坐标统计和canonical writer | +| `align_stockholm.mbt` | BioPython `Bio.Align.stockholm` | 严格多记录Stockholm读写、GF/GS/GR/GC映射、reference与database reference、M/D/I列、all-gap压缩、坐标统计和canonical writer | +| `align_chain.mbt` | BioPython `Bio.Align.chain` | UCSC Chain 12/13字段header与size/dt/dq严格读写、双轴正反链absolute path、坐标映射、反转、ID/overlap查询与canonical writer | +| `align_maf.mbt` | BioPython `Bio.Align.maf` | MAF document/track与a/s/i/e/q严格读写、链感知absolute path、component映射、MafIndex半开查询、多外显子拼接与canonical writer | +| `align_bed.mbt` | BioPython `Bio.Align.bed` | BED3-BED12 pairwise alignment读写、numeric/text score、链感知target/query path、blocks、双向映射、区间查询与分级writer | | `bigbed.mbt` | BioPython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12、AutoSQL、多级chromosome B+ tree/R-tree、zlib/DEFLATE及索引查询 | | `bigmaf.mbt` | BioPython `Bio.Align.bigmaf` | bedMaf bed3+1读写、MAF a/s/i/e/q、正负链坐标映射、压缩索引查询、摘要和MAF导出 | | `bigpsl.mbt` | BioPython `Bio.Align.bigpsl` | bed12+13读写、核酸/translated protein路径、双向坐标映射、recount、压缩查询、摘要和PSL导出 | @@ -1849,7 +1901,9 @@ moon test # ✅ 10046 个测试全 | `rtsne.mbt` | Bioconductor Rtsne | t-SNE降维算法 (TsneConfig/TsneResult数据结构、成对距离计算、条件概率估计与perplexity优化、联合概率矩阵构建、梯度下降优化、动量/early exaggeration调度) | | `uwot.mbt` | Bioconductor uwot | UMAP降维算法 (UmapConfig/UmapResult数据结构、k近邻搜索、模糊单纯集构建、局部模糊集并集、SGD低维嵌入优化、负采样、min_dist/spread参数控制) | | `tradeseq.mbt` | Bioconductor tradeSeq | 轨迹差异表达分析 (TrajectoryPoint/GeneExpressionData/GAMFit/DifferentialExpressionResult数据结构、GAM广义可加模型拟合、样条基函数、条件效应检验、BH-FDR校正) | -| `maf.mbt` | BioPython `Bio.Align` | MAF多序列比对格式解析与分析 (块处理、百分比一致性、统计分析、选择/过滤) | +| `maf.mbt` | BioPython `Bio.Align` | 早期宽松MAF块解析与分析 (块处理、百分比一致性、统计分析、选择/过滤) | +| `align_maf.mbt` | BioPython `Bio.Align.maf` | 现代MAF文档、严格a/s/i/e/q、绝对坐标路径、reference index、多外显子拼接与规范写回 | +| `align_bed.mbt` | BioPython `Bio.Align.bed` | 现代BED pairwise alignment、正负链transcript路径、exon block、坐标映射、搜索、统计与BED3-BED12写回 | | `mauve.mbt` | BioPython `Bio.Align` | Mauve基因组比对格式解析 (LCB检测、倒位/断点、覆盖率、BED导出) | | `stockholm.mbt` | BioPython `Bio.Stockholm` | Stockholm格式解析与分析 (Pfam/Rfam格式、二级结构、保守性、FASTA转换) | | `popgen_advanced.mbt` | BioPython `Bio.PopGen` | 高级群体遗传学统计 (Tajima's D、Fu & Li's D/F、MK检验、等位基因频率谱) | @@ -1911,6 +1965,12 @@ moon test # ✅ 10046 个测试全 | `a2m.mbt` | `Bio.Align.a2m` | match/insertion状态模型、canonical字符编码、wrapped/CRLF解析、行/列坐标互映、插入槽、统计、共识、切片和match-only投影 | | `align_emboss.mbt` | `Bio.Align.emboss` | EMBOSS文件与alignment类型模型、固定21列body、多alignment/多序列、纯gap block、链感知绝对坐标、consensus统计和canonical writer | | `align_exonerate.mbt` | `Bio.Align.exonerate` | Exonerate document/alignment/operation模型、cigar/vulgar、正反链/protein坐标、3:1 translated mapping、双向查询、统计和canonical writer | +| `msf.mbt` | `Bio.Align.msf` | GCG MSF metadata/sequence/alignment模型、标准checksum、interleaved parser、短行补齐、coordinate path、pair counts、consensus和writer | +| `align_nexus.mbt` | `Bio.Align.nexus` | 独立alignment metadata/sequence模型、nested comment与quoted token lexer、sequential/interleaved parser、MATCHCHAR、all-gap压缩、坐标查询、统计和writer | +| `align_stockholm.mbt` | `Bio.Align.stockholm` | 有序GF/GS/GR/GC与reference模型、多记录parser、M/D/I列语义、all-gap压缩、annotation-aware切片、坐标查询、统计和writer | +| `align_chain.mbt` | `Bio.Align.chain` | 不可变alignment/block/counts模型、严格多记录parser、链感知absolute coordinate path、block重建、双向位置/区间映射、pairs、invert和writer | +| `align_maf.mbt` | `Bio.Align.maf` | 不可变document/track/index/spliced模型、严格a/s/i/e/q parser、链感知absolute path、任意component映射、区间查询、拼接和writer | +| `align_bed.mbt` | `Bio.Align.bed` | 不可变alignment/document/score/block模型、BED3-BED12 parser、双轴路径校验、block投影、双向residue mapping、search、summary和writer | | `bigbed.mbt` | `Bio.Align.bigbed` | BigBed v4二进制读写、BED/AutoSQL、平衡B+ tree/R-tree、完整DEFLATE块解码、区间/名称查询与BED导出 | | `bigmaf.mbt` | `Bio.Align.bigmaf` | bedMaf AutoSQL与MAF块往返、a/s/i/e/q注释、链感知坐标映射、BigBed索引查询和普通MAF导出 | | `bigpsl.mbt` | `Bio.Align.bigpsl` | 标准bigPsl AutoSQL、核酸与translated DNA-protein坐标、链感知映射、match分类、BigBed索引和PSL导出 | @@ -3146,6 +3206,54 @@ EMBOSS 的 1-based inclusive 坐标在内部规范为 0-based boundary/residue vulgar 的 `M/5/I/3/C/G/N/S/F` 操作规范为显式 `M/5/N/3/C/D/I/U/S/F` path，其中双轴 non-equivalenced region 拆成可查询的 target/query movement，并在写回时无损重组。模块支持正向、反向和 protein strand、DNA/protein 3:1 translated CIGAR、绝对 coordinate path、query-target 双向 residue/codon 映射、aligned pairs，以及 match、gap open、intron、non-equivalenced、split codon 和 frame shift 统计。vulgar writer 保留完整操作语义，cigar writer 将特殊操作规范投影为 `M/I/D` 且保持路径；严格诊断覆盖 header/footer、字段与数值、strand方向、operation合法性和 endpoint span。当前模块负责 alignment coordinate semantics，不替代搜索结果层的 `Bio.SearchIO.ExonerateIO`。 +### 270. GCG MSF 多序列比对读写与坐标模型 (Biopython Bio.Align.msf) + +实现 Biopython 1.86 `Bio.Align.msf` 的 GCG/PileUp 多序列比对格式。`msf_parse` 支持 `!!AA_MULTIPLE_ALIGNMENT`、`!!NA_MULTIPLE_ALIGNMENT` 和 `PileUp` header，解析 `MSF:/Type:/Check:`、EMBOSS `CompCheck:`、自由 preamble/title/date、每行 `Name:/Len:/Check:/Weight:` metadata、可选 `oo`、数字坐标行和 interleaved sequence blocks。`.`、`~`、`-` gap 在内部统一为 `-`，蛋白质与核酸残基分别校验，CRLF 与小写输入被规范化。 + +模块实现位置权重 1..57 循环的标准 GCG checksum，并支持默认严格校验或显式关闭验证；第三方零 checksum 视为未提供。官方 W protein fixture 的 93-residue 行会补齐到 99 列；DOA fixture 一类 header width 与实际宽度不一致的文件保留 `declared_length`，由 `length_mismatch` 暴露而不中止解析。不可变 metadata、sequence、alignment 和 pair-count 模型提供 row/column 双向映射、跨行 residue 映射、aligned pairs、compact coordinate path、identity/mismatch/gap-open、occupancy、阈值 consensus 和 checksum 摘要。 + +`msf_write` 重新计算行级与文件级 checksum，按可配置 block/group width 输出 canonical interleaved MSF，并可选择 `.`, `~` 或 `-` gap。严格诊断覆盖 header/type 冲突、数值溢出、重复 ID、descriptor/body 损坏、声明 residue 数不一致、非法字符、all-gap column 以及 writer 参数。当前实现聚焦单个文本 MSF alignment，不负责流式多记录容器。 + +### 271. NEXUS 多序列比对读写与坐标模型 (Biopython Bio.Align.nexus) + +实现 Biopython 1.86 `Bio.Align.nexus` 的现代 alignment 语义，并与原有 `nexus.mbt` 的浅层 `Bio.Nexus` block API 分离。`align_nexus_parse` 严格检查 `#NEXUS`，以 quote/comment-aware lexer 处理任意嵌套 `[...]` comment、分号命令边界、单/双引号 taxon name 和 doubled apostrophe；支持 `DATA`/`CHARACTERS`、独立 `TAXA`/`TAXLABELS`、`DIMENSIONS NTAX/NCHAR`、`FORMAT DATATYPE/MISSING/GAP/MATCHCHAR/INTERLEAVE/RESPECTCASE/SYMBOLS`，以及带标签、无标签、wrapped sequential 和 interleaved MATRIX。后续 interleave block 可按 NEXUS 的空格/下划线等价规则关联 taxon，duplicate taxon 仍保留原始 ID。 + +DNA、RNA、protein 和 standard datatype 分别执行残基集合校验；custom missing/gap 被规范化，其中 missing 仍推进 residue coordinate，只有 gap 不推进。`MATCHCHAR` 以首行同列残基展开，source 中全 gap 列在最终 alignment 中移除，同时 metadata 保留原始宽度和删除列数。不可变 metadata、sequence、alignment 与 counts 模型提供 row/column 双向位置查询、跨序列 residue mapping、aligned pairs、compact coordinate path、逐对及全 MSA identity/mismatch/gap-open 统计、occupancy、阈值 consensus 和摘要。 + +`align_nexus_write` 输出 canonical DATA block，正确 quote taxon name 并将 apostrophe 写为 `''`，支持 custom gap、可配置 block width 和显式 sequential/interleaved；未指定模式时，alignment 宽度大于 1000 自动 interleave，与 Biopython writer 一致。严格诊断覆盖 header、comment/quote、block、dimensions、format、matrix、datatype、taxon关联、MATCHCHAR 和 writer 参数。官方 9×48 fixture 在移除两个全 gap 列后得到 9×46 alignment，全部序列对统计为 862 aligned、256 identities、606 mismatches 和 596 gap columns。 + +### 272. Stockholm 多序列比对读写、注释与坐标模型 (Biopython Bio.Align.stockholm) + +实现 Biopython 1.86 `Bio.Align.stockholm` 的现代 alignment 语义，并保留原有 `stockholm.mbt` 的宽松 block-oriented API。`align_stockholm_parse` 严格检查 `# STOCKHOLM 1.0` header 和 `//` terminator，`align_stockholm_parse_all` 支持连续多记录；sequence row 必须唯一且等宽。类型化不可变模型保留 GF alignment annotation、GS sequence annotation、GR residue annotation 和 GC column annotation，映射标准字段并保留自定义 GS/GR/GC；reference 的 RN/RM/RT/RA/RL/RC、database reference 的 DR/DC、nested domain 的 NE/NL 和重复 AU/WK/SM 均按输入顺序建模。 + +解析器区分 `-` deletion gap 与 `.` insertion gap，形成每列 `M/D/I` operation；同列禁止混用两类 gap。内部 aligned row 将 gap 规范为 `-`，GR 同时保存 residue-level 与 aligned value。source 中全 gap 列会与 GC、GR 和 operation 同步压缩，并保留 source width 与删除列数。查询 API 提供 row/column 双向位置映射、跨行 residue mapping、aligned pairs、compact coordinate path、annotation-aware column slicing、逐对及全 MSA identity/mismatch/gap-open 统计、occupancy、阈值 consensus 和摘要。 + +`align_stockholm_write` 输出 canonical GF/GS/GR/GC 顺序，根据 operation 将 insertion gap 恢复为 `.`，按 row gap 展开 residue-level GR，并对长 CC/RC/RT 文本折行；`align_stockholm_write_all` 支持多记录往返。严格诊断覆盖 header/terminator、annotation字段、SQ row count、数值溢出、orphan/duplicate reference字段、非法列操作、annotation宽度和writer不支持的未知GF。官方 HAT fixture 保留 3×33 alignment、完整注释与 insertion column；专项 fixture 验证 source 7列压缩为 retained 4列且 operation 为 `MIMM`。 + +### 273. UCSC Chain成对比对读写与坐标模型 (Biopython Bio.Align.chain) + +实现 Biopython 1.86 `Bio.Align.chain` 的现代 pairwise alignment 语义，并与现有 `chain_liftover.mbt` 的宽松 rtracklayer-style liftOver API 并存。`align_chain_parse` 严格读取 12/13 字段 header，支持有限浮点 score、可选 chain ID、连续多记录、CRLF/空白分隔及 target/query 任意 `+`/`-` 组合；每条 `size dt dq` 和末尾 `size` 记录被重建为 zero-based half-open 的绝对坐标路径，负链通过递减边界表示。 + +不可变 `AlignChainAlignment`、`AlignChainCoordinate`、`AlignChainBlock`、`AlignChainCounts` 和 range/pair 模型提供 canonical block 重建、`M/D/I` operation path、aligned/gap/open统计、双向 residue 映射、区间拆分映射、受上限保护的 aligned-pair 展开、target/query反转、chain ID查找和target overlap查询。`align_chain_write`/`align_chain_write_all` 从绝对路径恢复规范 header 与block，可稳定多记录往返。 + +严格诊断覆盖 identifier、strand、非负整数、32位溢出、NaN/极值score、header区间、block字段数、末尾block、零长度segment、单调性、aligned step等长及累计span一致性。官方风格 181-base reverse-query fixture 重建 `MDMDM`、181 aligned bases、1530 target gap bases和1711列；第二条fixture覆盖reverse target与双向gap。旧 `cl_*` API 保持兼容，继续面向宽松的基因组liftOver工作流。 + +### 274. MAF多基因组比对读写、坐标路径与参考索引 (Biopython Bio.Align.maf) + +实现 Biopython 1.86 `Bio.Align.maf` 的现代 alignment 语义，并保留 `maf.mbt` 的早期宽松块分析 API。新模块复用 `bigmaf.mbt` 已验证的 `BigMafComponent`、`BigMafEmptyComponent`、`BigMafInsertion` 和 `BigMafBlock` 作为严格数据层，在其上提供不可变 `AlignMafTrack`、`AlignMafDocument`、`AlignMafIndex`、`AlignMafSplicedAlignment` 和摘要模型。parser 支持 quoted/escaped UCSC `track` metadata、`##maf version/scoring/program`、文档与块注释，以及标准 `a/s/i/e/q` 记录；`i/q` 必须紧随同源 `s` 行并与其列宽、gap位置一致。 + +component 坐标使用 zero-based half-open forward genomic axis；负链 MAF start 被转换为递减的绝对边界。`align_maf_coordinate_path` 按列状态变化压缩多序列路径，`align_maf_map_position` 可在任意两个 component 间双向映射 residue，并在目标gap处返回 `None`。gap字符 `.`, `=`, `_` 统一规范为 `-`；数值解析拒绝负整数、32位溢出、NaN和极端score，source span 使用减法边界检查避免加法溢出。 + +`AlignMafIndex::create` 要求每块参考 component 唯一且source size/strand一致，并按forward interval构建内存索引。`search`/`search_ranges` 使用半开overlap、文件顺序返回和跨区间去重；`get_spliced` 验证递增不重叠外显子，保留reference gap对应插入列，未覆盖参考填 `N`、其他物种填 `-`，并支持完整结果反向互补。重叠reference block会被诊断为歧义；当前拼接明确要求plus-strand reference。`align_maf_write` 输出canonical track/header与a/s/i/q/e顺序，可稳定文档往返；BigMaf二进制容器和旧宽松MAF分析接口继续独立存在。 + +### 275. BED成对比对读写、双轴坐标与分级写回 (Biopython Bio.Align.bed) + +实现 Biopython 1.86 `Bio.Align.bed` 的现代 pairwise alignment 语义，并与 `bigbed.mbt` 的 BigBed v4二进制容器、AutoSQL和索引职责分离。不可变 `AlignBedAlignment`、`AlignBedDocument`、`AlignBedCoordinate`、`AlignBedBlock`、`AlignBedCounts` 和 `AlignBedSummary` 建模 target/query 双轴路径；`AlignBedScore` 同时保留有限数值 score 与无空白文本 score。parser 支持 BED3-BED12、CRLF和通用空白，其中 BED3-BED9按连续单块解释，BED12重建完整exon path；BED10仅接受单块，BED11仅在缺失的blockStarts可无损推断时接受。 + +坐标统一为 zero-based half-open boundary。target规范化为递增轴，plus query递增、minus query递减；BED12的query size由blockSizes求和，target-only segment表示intron。`blocks` 从一般路径投影aligned segments，`map_target_position`/`map_query_position` 仅映射aligned residue并在intron或不可表示gap返回 `None`。`counts` 汇总aligned bases、双轴skip bases/open和columns，document提供half-open `search`、有序target/query集合及跨记录summary。 + +严格校验覆盖3-12列、非负32位整数、有限score、strand、thick interval、block count/list长度、正size、首尾span、排序/重叠/越界、坐标单调性、零长度segment和aligned step等长。writer可从一般target/query path生成canonical blocks，并按 `bed_columns` 输出 BED3-BED12；query-only segment按BED可表达能力被投影跳过，反向target path先规范化。该层处理文本pairwise alignment，`bigbed.mbt` 继续独立处理压缩二进制存储和索引。 + ## 性能优化 ### 优化策略 @@ -3247,8 +3355,8 @@ vulgar 的 `M/5/I/3/C/G/N/S/F` 操作规范为显式 `M/5/N/3/C/D/I/U/S/F` path | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 10046 | -| 通过数 | 10046 | +| 总测试数 | 10852 | +| 通过数 | 10852 | | 失败数 | 0 | | 通过率 | 100% | @@ -3359,6 +3467,12 @@ moon test --update | Bio.Align.a2m | `a2m_test.mbt` | 71 | | Bio.Align.emboss | `align_emboss_test.mbt` | 81 | | Bio.Align.exonerate | `align_exonerate_test.mbt` | 86 | +| Bio.Align.msf | `msf_test.mbt` | 95 | +| Bio.Align.nexus | `align_nexus_test.mbt` | 100 | +| Bio.Align.stockholm | `align_stockholm_test.mbt` | 148 | +| Bio.Align.chain | `align_chain_test.mbt` | 156 | +| Bio.Align.maf | `align_maf_test.mbt` | 155 | +| Bio.Align.bed | `align_bed_test.mbt` | 152 | | Bio.Align.bigbed | `bigbed_test.mbt` | 64 | | Bio.Align.bigmaf | `bigmaf_test.mbt` | 79 | | SparseArray | `sparse_array_test.mbt` | 41 | @@ -3665,7 +3779,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 377 个示例程序，展示各模块的典型用法： +项目提供 383 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3869,6 +3983,12 @@ moon run cmd/bench/main.mbt | a2m_demo | A2M D/I列状态、插入槽、match共识、跨行坐标映射、pair counts、match projection与wrapped往返 | `moon run examples/a2m_demo` | | align_emboss_demo | EMBOSS srspair元数据、局部/反向坐标、consensus、compact path、pair counts与wrapped规范往返 | `moon run examples/align_emboss_demo` | | align_exonerate_demo | Exonerate spliced vulgar path、反向protein-to-DNA 3:1映射、operation统计及vulgar/cigar规范往返 | `moon run examples/align_exonerate_demo` | +| msf_demo | GCG/PileUp MSF metadata与checksum、interleaved rows、coordinate path、pair counts、consensus、宽度异常及规范往返 | `moon run examples/msf_demo` | +| align_nexus_demo | NEXUS interleaved DATA、quoted taxa、MATCHCHAR、coordinate path、residue mapping、统计、all-gap压缩与canonical往返 | `moon run examples/align_nexus_demo` | +| align_stockholm_demo | Stockholm GF/GS/GR/GC与reference、insertion operation、coordinate path、residue mapping、统计、all-gap压缩与canonical往返 | `moon run examples/align_stockholm_demo` | +| align_chain_demo | UCSC Chain连续记录、正反双轴绝对路径、block/counts、双向位置与区间映射、反转及canonical往返 | `moon run examples/align_chain_demo` | +| align_maf_demo | MAF track/header、a/s/i/e/q、plus/minus绝对路径、component映射、MafIndex查询、多外显子拼接与canonical往返 | `moon run examples/align_maf_demo` | +| align_bed_demo | BED3/BED12、numeric/text score、正负链双轴路径、exon blocks、双向mapping、搜索、统计、BED3-BED12分级写回与canonical往返 | `moon run examples/align_bed_demo` | | bigbed_demo | BigBed v4压缩写入/解析、AutoSQL、多级索引查询、负链exon坐标、BED导出及损坏文件诊断 | `moon run examples/bigbed_demo` | | bigmaf_demo | BigMaf压缩bed3+1写入、bedMaf schema、R-tree区间查询、负链物种坐标映射和MAF a/s/i/e/q导出 | `moon run examples/bigmaf_demo` | | bigpsl_demo | BigPsl bed12+13压缩写入、AutoSQL、R-tree查询、反向核酸/translated protein坐标和PSL导出 | `moon run examples/bigpsl_demo` | @@ -3986,6 +4106,12 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bio.Align.a2m 状态感知多序列比对（D/I列状态、大小写与点gap编码、wrapped/CRLF严格读写、坐标映射、插入槽、统计、共识与match-only投影） - ✅ 实现 Bio.Align.emboss alignment输出（srspair/pair/simple、多alignment/多序列、局部/反向坐标、纯gap block、consensus统计、compact path与规范往返） - ✅ 实现 Bio.Align.exonerate alignment输出（cigar/vulgar、完整operation path、正反链/protein strand、3:1 translated坐标、双向映射、统计与规范往返） +- ✅ 实现 Bio.Align.msf GCG/PileUp多序列比对（AA/NA header、interleaved rows、标准checksum、gap规范化、坐标映射、统计与canonical writer） +- ✅ 实现 Bio.Align.nexus NEXUS多序列比对（DATA/CHARACTERS/TAXA、nested comments、quoted/duplicate taxa、sequential/interleaved MATRIX、datatype/MATCHCHAR、坐标统计与canonical writer） +- ✅ 实现 Bio.Align.stockholm Stockholm多序列比对（严格多记录、GF/GS/GR/GC、reference/database/nested-domain、M/D/I列、all-gap压缩、坐标统计与canonical writer） +- ✅ 实现 Bio.Align.chain UCSC Chain成对比对（12/13字段严格多记录、float score、正反双轴absolute path、size/dt/dq、坐标映射、反转、查询与canonical writer） +- ✅ 实现 Bio.Align.maf MAF多基因组比对（track/header、严格a/s/i/e/q、正负链absolute path、component映射、MafIndex半开查询、多外显子拼接与canonical writer） +- ✅ 实现 Bio.Align.bed BED成对比对（BED3-BED12严格读写、numeric/text score、正负链双轴路径、block投影、双向residue映射、区间查询、统计与分级writer） - ✅ 实现 Bio.Align.bigbed BigBed v4二进制区间格式（BED3-BED12、AutoSQL、多级B+ tree/R-tree、DEFLATE、区间/名称查询与BED导出） - ✅ 实现 Bio.Align.bigmaf BigMaf多物种比对索引（标准bedMaf、MAF a/s/i/e/q、正负链坐标映射、压缩BigBed查询与MAF导出） - ✅ 实现 Bio.Align.bigpsl BigPsl成对比对索引（标准bed12+13、核酸/translated protein坐标、match recount、压缩BigBed查询与PSL导出） diff --git a/examples/align_bed_demo/main.mbt b/examples/align_bed_demo/main.mbt new file mode 100644 index 00000000..47424924 --- /dev/null +++ b/examples/align_bed_demo/main.mbt @@ -0,0 +1,157 @@ +///| +fn bed_coordinate_path_text( + coordinates : Array[@src.AlignBedCoordinate], +) -> String { + let output = StringBuilder::new() + for index = 0; index < coordinates.length(); index = index + 1 { + if index > 0 { + output.write_string(" -> ") + } + output.write_string( + "(" + + coordinates[index].target.to_string() + + ", " + + coordinates[index].query.to_string() + + ")", + ) + } + output.to_string() +} + +///| +fn main { + println("=== Biopython Bio.Align.bed Demo ===") + + let document = @src.align_bed_parse(@src.align_bed_example_text()) catch { + AlignBedError(message) => abort("BED parsing failed: " + message) + } + let plus = document.alignments[0] + let minus = document.alignments[1] + + println("\n1. Parse mixed BED3 and BED12 records") + println( + " records=" + + document.alignments.length().to_string() + + ", targets=" + + document.targets().length().to_string() + + ", queries=" + + document.queries().length().to_string(), + ) + println( + " numeric score=" + + plus.score.unwrap().number().unwrap_or(-1.0).to_string(), + ) + let text_score_document = @src.align_bed_parse( + "chr1\t10\t20\tcurated-hit\thigh-confidence\t+", + ) catch { + AlignBedError(message) => abort("text BED score parsing failed: " + message) + } + println( + " text score=" + + text_score_document.alignments[0].score.unwrap().text_value().unwrap_or( + "missing", + ), + ) + + println("\n2. Inspect plus/minus target-query coordinate paths") + println(" plus: " + bed_coordinate_path_text(plus.coordinates)) + println(" minus: " + bed_coordinate_path_text(minus.coordinates)) + println( + " plus strand=" + + plus.strand() + + ", minus strand=" + + minus.strand(), + ) + + println("\n3. Reconstruct exon blocks and transcript sizes") + for index = 0; index < plus.blocks().length(); index = index + 1 { + let block = plus.blocks()[index] + println( + " exon " + + (index + 1).to_string() + + ": target[" + + block.target_start.to_string() + + ", " + + block.target_end.to_string() + + ") query[" + + block.query_start.to_string() + + ", " + + block.query_end.to_string() + + ")", + ) + } + println( + " plus query size=" + + plus.query_size().to_string() + + ", minus query size=" + + minus.query_size().to_string(), + ) + + println("\n4. Map aligned residues in both directions") + println( + " plus target 1000 -> query " + + plus.map_target_position(1000).unwrap_or(-1).to_string(), + ) + println( + " plus query 1054 -> target " + + plus.map_query_position(1054).unwrap_or(-1).to_string(), + ) + println( + " minus target 2000 -> query " + + minus.map_target_position(2000).unwrap_or(-1).to_string(), + ) + println( + " intron target 3000 -> query " + + plus.map_target_position(3000).unwrap_or(-1).to_string(), + ) + + println("\n5. Count path operations and query half-open intervals") + let counts = plus.counts() + let summary = document.summary() + let hits = document.search("chr22", 4900, 5100) catch { + AlignBedError(message) => abort("BED interval search failed: " + message) + } + println( + " aligned=" + + counts.aligned.to_string() + + ", intron bases=" + + counts.target_skip_bases.to_string() + + ", blocks=" + + counts.blocks.to_string(), + ) + println( + " document aligned=" + + summary.aligned_bases.to_string() + + ", plus/minus=" + + summary.plus_strand_count.to_string() + + "/" + + summary.minus_strand_count.to_string(), + ) + println(" chr22 overlaps [4900, 5100): " + hits.length().to_string()) + + println("\n6. Project one alignment to BED3 through BED12") + for columns = 3; columns <= 12; columns = columns + 1 { + let line = @src.align_bed_format(plus, bed_columns=columns) catch { + AlignBedError(message) => abort("BED formatting failed: " + message) + } + println( + " BED" + + columns.to_string() + + ": " + + line[0:line.length() - 1].to_owned(), + ) + } + + println("\n7. Write canonical BED12 and parse it again") + let single = @src.AlignBedDocument::create([plus]) catch { + AlignBedError(message) => abort("BED document creation failed: " + message) + } + let canonical = @src.align_bed_write(single) catch { + AlignBedError(message) => abort("BED serialization failed: " + message) + } + let round_trip = @src.align_bed_parse(canonical) catch { + AlignBedError(message) => abort("BED round-trip parsing failed: " + message) + } + println(" " + canonical[0:canonical.length() - 1].to_owned()) + println(" round-trip preserved: " + (round_trip == single).to_string()) +} diff --git a/examples/align_bed_demo/moon.pkg b/examples/align_bed_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/align_bed_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/examples/align_chain_demo/main.mbt b/examples/align_chain_demo/main.mbt new file mode 100644 index 00000000..91c30ec5 --- /dev/null +++ b/examples/align_chain_demo/main.mbt @@ -0,0 +1,114 @@ +///| +fn chain_coordinate_path_text( + coordinates : Array[@src.AlignChainCoordinate], +) -> String { + let output = StringBuilder::new() + for index = 0; index < coordinates.length(); index = index + 1 { + if index > 0 { + output.write_string(" -> ") + } + output.write_string( + "(" + + coordinates[index].target.to_string() + + ", " + + coordinates[index].query.to_string() + + ")", + ) + } + output.to_string() +} + +///| +fn main { + println("=== Biopython Bio.Align.chain Demo ===") + + let alignments = @src.align_chain_parse_all(@src.align_chain_example_text()) catch { + AlignChainError(message) => abort("Chain parsing failed: " + message) + } + let alignment = alignments[0] + + println("\n1. Parse consecutive UCSC Chain records") + println(" records: " + alignments.length().to_string()) + for record in alignments { + println(" " + record.summary()) + } + + println("\n2. Inspect absolute coordinates and canonical blocks") + println(" operations: " + alignment.operation_path()) + println(" coordinates: " + chain_coordinate_path_text(alignment.coordinates)) + let blocks = alignment.blocks() catch { + AlignChainError(message) => + abort("Chain block reconstruction failed: " + message) + } + for index = 0; index < blocks.length(); index = index + 1 { + let block = blocks[index] + println( + " block " + + (index + 1).to_string() + + ": size=" + + block.size.to_string() + + ", dt=" + + block.target_gap.to_string() + + ", dq=" + + block.query_gap.to_string(), + ) + } + + println("\n3. Calculate coordinate-only counts") + let counts = alignment.counts() + println( + " aligned=" + + counts.aligned.to_string() + + ", target-gap bases=" + + counts.target_gap_bases.to_string() + + ", query-gap bases=" + + counts.query_gap_bases.to_string(), + ) + println( + " alignment length=" + + alignment.alignment_length().to_string() + + ", aligned blocks=" + + counts.aligned_blocks.to_string(), + ) + + println("\n4. Map residues and intervals in both directions") + println( + " target 42530895 -> query " + + alignment.map_target_position(42530895).unwrap_or(-1).to_string(), + ) + println( + " query 180 -> target " + + alignment.map_query_position(180).unwrap_or(-1).to_string(), + ) + let pieces = alignment.map_target_range(42530950, 42532030) catch { + AlignChainError(message) => abort("Chain range mapping failed: " + message) + } + for piece in pieces { + println( + " target[" + + piece.target_start.to_string() + + ", " + + piece.target_end.to_string() + + ") -> query[" + + piece.query_start.to_string() + + ", " + + piece.query_end.to_string() + + ")", + ) + } + + println("\n5. Invert and round-trip canonical Chain output") + let inverted = alignment.invert() catch { + AlignChainError(message) => abort("Chain inversion failed: " + message) + } + println(" inverted: " + inverted.summary()) + let canonical = @src.align_chain_write_all(alignments) catch { + AlignChainError(message) => abort("Chain serialization failed: " + message) + } + let round_trip = @src.align_chain_parse_all(canonical) catch { + AlignChainError(message) => + abort("Chain round-trip parsing failed: " + message) + } + println(" output bytes: " + canonical.length().to_string()) + println(" round-trip preserved: " + (round_trip == alignments).to_string()) +} diff --git a/examples/align_chain_demo/moon.pkg b/examples/align_chain_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/align_chain_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/examples/align_maf_demo/main.mbt b/examples/align_maf_demo/main.mbt new file mode 100644 index 00000000..8ab22b35 --- /dev/null +++ b/examples/align_maf_demo/main.mbt @@ -0,0 +1,155 @@ +///| +fn maf_integer_array_text(values : Array[Int]) -> String { + let output = StringBuilder::new() + output.write_char('[') + for index = 0; index < values.length(); index = index + 1 { + if index > 0 { + output.write_string(", ") + } + output.write_string(values[index].to_string()) + } + output.write_char(']') + output.to_string() +} + +///| +fn main { + println("=== Biopython Bio.Align.maf Demo ===") + + let document = @src.align_maf_parse(@src.align_maf_example_text()) catch { + AlignMafError(message) => abort("MAF parsing failed: " + message) + } + let track = match document.track { + Some(value) => value + None => abort("example MAF track metadata is missing") + } + + println("\n1. Parse MAF header, track metadata, and a/s/i/e/q records") + println( + " version=" + + document.version + + ", scoring=" + + document.scoring.unwrap_or("none") + + ", program=" + + document.program.unwrap_or("none"), + ) + println( + " track=" + + track.name.unwrap_or("unnamed") + + ", visibility=" + + track.visibility.unwrap_or("default") + + ", species=" + + track.species_order.length().to_string(), + ) + println( + " blocks=" + + document.blocks.length().to_string() + + ", comments=" + + document.comments.length().to_string(), + ) + let first = document.blocks[0] + let reference = first.components[0] + let insertion = match reference.insertion { + Some(value) => + value.left_status + + ":" + + value.left_count.to_string() + + "/" + + value.right_status + + ":" + + value.right_count.to_string() + None => "none" + } + println( + " reference=" + + reference.source + + ", sequence=" + + reference.sequence() + + ", insertion=" + + insertion + + ", quality=" + + reference.quality.unwrap_or("none"), + ) + println( + " empty component=" + + first.empty_components[0].source + + ", status=" + + first.empty_components[0].status, + ) + + println("\n2. Build absolute coordinate paths across plus/minus strands") + let path = @src.align_maf_coordinate_path(first) + for point in path { + println( + " column " + + point.column.to_string() + + " -> " + + maf_integer_array_text(point.positions), + ) + } + let to_mouse = @src.align_maf_map_position( + first, "hg38.chr7", 100, "mm39.chr5", + ) catch { + AlignMafError(message) => abort("MAF position mapping failed: " + message) + } + let to_human = @src.align_maf_map_position( + first, "mm39.chr5", 449, "hg38.chr7", + ) catch { + AlignMafError(message) => abort("MAF reverse mapping failed: " + message) + } + println( + " hg38:100 -> mm39:" + + to_mouse.unwrap_or(-1).to_string() + + "; mm39:449 -> hg38:" + + to_human.unwrap_or(-1).to_string(), + ) + + println("\n3. Summarize the multi-block document") + let summary = document.summary() + println( + " components=" + + summary.component_count.to_string() + + ", empty=" + + summary.empty_component_count.to_string() + + ", aligned columns=" + + summary.aligned_columns.to_string(), + ) + println( + " reference bases=" + + summary.reference_bases.to_string() + + ", distinct sources=" + + summary.source_count.to_string(), + ) + + println("\n4. Query a MafIndex-style half-open reference interval") + let index = @src.AlignMafIndex::create(document, "hg38.chr7") catch { + AlignMafError(message) => abort("MAF index creation failed: " + message) + } + let hits = index.search(103, 111) catch { + AlignMafError(message) => abort("MAF interval search failed: " + message) + } + println( + " entries=" + + index.entry_count().to_string() + + ", overlaps [103, 111)=" + + hits.length().to_string(), + ) + + println("\n5. Splice multiple exons with missing-data filling") + let spliced = index.get_spliced([102, 110], [106, 113]) catch { + AlignMafError(message) => abort("MAF splicing failed: " + message) + } + println(" hg38.chr7: " + spliced.sequence("hg38.chr7").unwrap_or("missing")) + println(" mm39.chr5: " + spliced.sequence("mm39.chr5").unwrap_or("missing")) + println(" output columns: " + spliced.columns.to_string()) + + println("\n6. Write canonical MAF and parse it again") + let canonical = @src.align_maf_write(document) catch { + AlignMafError(message) => abort("MAF serialization failed: " + message) + } + let round_trip = @src.align_maf_parse(canonical) catch { + AlignMafError(message) => abort("MAF round-trip parsing failed: " + message) + } + println(" output bytes: " + canonical.length().to_string()) + println(" round-trip preserved: " + (round_trip == document).to_string()) +} diff --git a/examples/align_maf_demo/moon.pkg b/examples/align_maf_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/align_maf_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/examples/align_nexus_demo/main.mbt b/examples/align_nexus_demo/main.mbt new file mode 100644 index 00000000..db5cccc9 --- /dev/null +++ b/examples/align_nexus_demo/main.mbt @@ -0,0 +1,134 @@ +///| +fn nexus_integer_array_text(values : Array[Int]) -> String { + let output = StringBuilder::new() + output.write_char('[') + for index = 0; index < values.length(); index = index + 1 { + if index > 0 { + output.write_string(", ") + } + output.write_string(values[index].to_string()) + } + output.write_char(']') + output.to_string() +} + +///| +fn main { + println("=== Biopython Bio.Align.nexus Demo ===") + + let alignment = @src.align_nexus_parse(@src.align_nexus_example_text()) catch { + AlignNexusError(message) => abort("NEXUS parsing failed: " + message) + } + + println("\n1. Parse an interleaved DATA matrix") + println(" " + alignment.summary()) + println( + " datatype: " + + alignment.metadata.data_type.code() + + " (" + + alignment.metadata.data_type.molecule_type() + + ")", + ) + let match_character = match alignment.metadata.match_character { + Some(value) => value + None => "none" + } + println( + " missing=" + + alignment.metadata.missing_character + + ", gap=" + + alignment.metadata.gap_character + + ", matchchar=" + + match_character, + ) + for sequence in alignment.sequences { + println( + " " + + sequence.id + + ": " + + sequence.aligned_sequence + + " -> " + + sequence.sequence, + ) + } + + println("\n2. Inspect coordinate paths and residue mapping") + let path = alignment.coordinate_path() + for row = 0; row < alignment.num_sequences(); row = row + 1 { + println( + " " + + alignment.sequences[row].id + + ": " + + nexus_integer_array_text(path[row]), + ) + } + println( + " reference residue 5 -> query one residue " + + alignment.map_position(0, 1, 5).unwrap_or(-1).to_string(), + ) + println( + " reference residue 7 -> query one residue " + + alignment.map_position(0, 1, 7).unwrap_or(-1).to_string() + + " (-1 denotes a gap)", + ) + + println("\n3. Calculate all-pairs statistics") + let counts = alignment.counts() + println( + " pairs=" + + counts.pairs.to_string() + + ", aligned=" + + counts.aligned.to_string() + + ", identities=" + + counts.identities.to_string() + + ", gaps=" + + counts.gap_columns.to_string(), + ) + let consensus = alignment.consensus(minimum_fraction=0.67) catch { + AlignNexusError(message) => abort("consensus failed: " + message) + } + println(" consensus: " + consensus) + println( + " occupancy at source gap column: " + alignment.occupancy()[4].to_string(), + ) + + println("\n4. Write canonical interleaved NEXUS and parse it again") + let canonical = @src.align_nexus_write( + alignment, + interleave=Some(true), + block_width=4, + ) catch { + AlignNexusError(message) => abort("NEXUS serialization failed: " + message) + } + let round_trip = @src.align_nexus_parse(canonical) catch { + AlignNexusError(message) => abort("round-trip parsing failed: " + message) + } + println(" output bytes: " + canonical.length().to_string()) + println( + " quoted IDs and rows preserved: " + + (round_trip.sequences == alignment.sequences).to_string(), + ) + println( + " coordinate path preserved: " + + (round_trip.coordinate_path() == alignment.coordinate_path()).to_string(), + ) + + println("\n5. Remove all-gap source columns during construction") + let compact = @src.align_nexus_from_aligned( + ["reference", "query"], + ["A-C--GT", "ATC--GT"], + @src.AlignNexusDna, + ) catch { + AlignNexusError(message) => + abort("alignment construction failed: " + message) + } + println( + " source columns=" + + compact.source_alignment_length().to_string() + + ", alignment columns=" + + compact.alignment_length().to_string() + + ", removed=" + + compact.metadata.removed_all_gap_columns.to_string(), + ) + println(" compact reference: " + compact.sequences[0].aligned_sequence) +} diff --git a/examples/align_nexus_demo/moon.pkg b/examples/align_nexus_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/align_nexus_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/examples/align_stockholm_demo/main.mbt b/examples/align_stockholm_demo/main.mbt new file mode 100644 index 00000000..30d4676d --- /dev/null +++ b/examples/align_stockholm_demo/main.mbt @@ -0,0 +1,119 @@ +///| +fn stockholm_integer_array_text(values : Array[Int]) -> String { + let output = StringBuilder::new() + output.write_char('[') + for index = 0; index < values.length(); index = index + 1 { + if index > 0 { + output.write_string(", ") + } + output.write_string(values[index].to_string()) + } + output.write_char(']') + output.to_string() +} + +///| +fn main { + println("=== Biopython Bio.Align.stockholm Demo ===") + + let alignment = @src.align_stockholm_parse( + @src.align_stockholm_example_text(), + ) catch { + AlignStockholmError(message) => + abort("Stockholm parsing failed: " + message) + } + + println("\n1. Parse the official Pfam HAT record") + println(" " + alignment.summary()) + println( + " family: " + + alignment.annotation("identifier").unwrap_or("unknown") + + " (" + + alignment.annotation("accession").unwrap_or("unknown") + + ")", + ) + println( + " references=" + + alignment.references.length().to_string() + + ", database references=" + + alignment.database_references.length().to_string(), + ) + for sequence in alignment.sequences { + println( + " " + + sequence.id + + ": " + + sequence.aligned_sequence + + " -> " + + sequence.sequence, + ) + } + + println("\n2. Inspect insertion operations and coordinates") + println(" operations: " + alignment.operations) + let path = alignment.coordinate_path() + for row = 0; row < alignment.num_sequences(); row = row + 1 { + println( + " " + + alignment.sequences[row].id + + ": " + + stockholm_integer_array_text(path[row]), + ) + } + println( + " row 3 residue 17 -> row 1 residue " + + alignment.map_position(2, 0, 17).unwrap_or(-1).to_string() + + " (-1 denotes a gap)", + ) + + println("\n3. Calculate alignment statistics") + let counts = alignment.counts() + println( + " pairs=" + + counts.pairs.to_string() + + ", aligned=" + + counts.aligned.to_string() + + ", identities=" + + counts.identities.to_string() + + ", gap columns=" + + counts.gap_columns.to_string(), + ) + let consensus = alignment.consensus() catch { + AlignStockholmError(message) => abort("consensus failed: " + message) + } + println(" consensus: " + consensus) + println( + " insertion-column occupancy: " + alignment.occupancy()[17].to_string(), + ) + + println("\n4. Write canonical Stockholm and parse it again") + let canonical = @src.align_stockholm_write(alignment) catch { + AlignStockholmError(message) => + abort("Stockholm serialization failed: " + message) + } + let round_trip = @src.align_stockholm_parse(canonical) catch { + AlignStockholmError(message) => + abort("Stockholm round-trip parsing failed: " + message) + } + println(" output bytes: " + canonical.length().to_string()) + println( + " rows preserved: " + + (round_trip.sequences == alignment.sequences).to_string(), + ) + println( + " operations preserved: " + + (round_trip.operations == alignment.operations).to_string(), + ) + + println("\n5. Remove all-gap source columns during construction") + let compact = @src.align_stockholm_from_aligned(["alpha", "beta"], [ + "A.-C--G", "AT-C--G", + ]) catch { + AlignStockholmError(message) => + abort("Stockholm construction failed: " + message) + } + println(" " + compact.summary()) + println(" operations: " + compact.operations) + println(" alpha: " + compact.sequences[0].aligned_sequence) + println(" beta: " + compact.sequences[1].aligned_sequence) +} diff --git a/examples/align_stockholm_demo/moon.pkg b/examples/align_stockholm_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/align_stockholm_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/examples/msf_demo/main.mbt b/examples/msf_demo/main.mbt new file mode 100644 index 00000000..e89bee88 --- /dev/null +++ b/examples/msf_demo/main.mbt @@ -0,0 +1,113 @@ +///| +fn integer_array_text(values : Array[Int]) -> String { + let output = StringBuilder::new() + output.write_char('[') + for index = 0; index < values.length(); index = index + 1 { + if index > 0 { + output.write_string(", ") + } + output.write_string(values[index].to_string()) + } + output.write_char(']') + output.to_string() +} + +///| +fn main { + println("=== Biopython Bio.Align.msf Demo ===") + + let alignment = @src.msf_parse(@src.msf_example_text()) catch { + MsfError(message) => abort("MSF parsing failed: " + message) + } + + println("\n1. Parse interleaved MSF metadata and rows") + println(" " + alignment.summary()) + println(" title: " + alignment.metadata.title) + for sequence in alignment.sequences { + println( + " " + + sequence.id + + ": residues=" + + sequence.length.to_string() + + ", weight=" + + sequence.weight.to_string() + + ", checksum=" + + sequence.checksum.to_string(), + ) + } + + println("\n2. Build a Biopython-style coordinate path") + let path = alignment.coordinate_path() + for row = 0; row < alignment.num_sequences(); row = row + 1 { + println( + " " + alignment.sequences[row].id + ": " + integer_array_text(path[row]), + ) + } + println( + " reference residue 4 -> query_one residue " + + alignment.map_position(0, 1, 4).unwrap_or(-1).to_string(), + ) + println( + " reference residue 3 -> query_one residue " + + alignment.map_position(0, 1, 3).unwrap_or(-1).to_string() + + " (-1 denotes a gap)", + ) + + println("\n3. Calculate pair statistics and consensus") + let counts = alignment.pair_counts(0, 2) catch { + MsfError(message) => abort("pair counting failed: " + message) + } + println( + " aligned=" + + counts.aligned.to_string() + + ", identities=" + + counts.identities.to_string() + + ", mismatches=" + + counts.mismatches.to_string() + + ", gap opens=" + + counts.gap_opens.to_string(), + ) + let consensus = alignment.consensus(minimum_fraction=0.67) catch { + MsfError(message) => abort("consensus failed: " + message) + } + println(" consensus: " + consensus) + println(" occupancy at column 1: " + alignment.occupancy()[1].to_string()) + + println("\n4. Write canonical MSF and parse it again") + let canonical = @src.msf_write( + alignment, + block_width=12, + group_width=4, + gap_character="~", + ) catch { + MsfError(message) => abort("MSF serialization failed: " + message) + } + let round_trip = @src.msf_parse(canonical) catch { + MsfError(message) => abort("round-trip parsing failed: " + message) + } + println(" output bytes: " + canonical.length().to_string()) + println(" checksums valid: " + round_trip.checksums_valid().to_string()) + println( + " aligned rows preserved: " + + (round_trip.sequences[1].aligned_sequence == + alignment.sequences[1].aligned_sequence).to_string(), + ) + + println("\n5. Preserve third-party declared-width mismatches") + let mismatch_text = "!!AA_MULTIPLE_ALIGNMENT\n" + + "MSF: 2 Type: P Check: 0 ..\n" + + "Name: full Len: 4 Check: 0 Weight: 1.0\n" + + "Name: short Len: 2 Check: 0 Weight: 1.0\n" + + "//\n\nfull ACDE\nshort AC\n" + let mismatch = @src.msf_parse(mismatch_text) catch { + MsfError(message) => abort("length-mismatch parsing failed: " + message) + } + println( + " declared=" + + mismatch.metadata.declared_length.to_string() + + ", actual=" + + mismatch.alignment_length().to_string() + + ", mismatch=" + + mismatch.length_mismatch().to_string(), + ) +} diff --git a/examples/msf_demo/moon.pkg b/examples/msf_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/msf_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/align_bed.mbt b/src/align_bed.mbt new file mode 100644 index 00000000..ae36eace --- /dev/null +++ b/src/align_bed.mbt @@ -0,0 +1,1265 @@ +// Biopython-compatible Bio.Align.bed support. +// +// This module models standalone BED records as pairwise alignment coordinate +// paths. BigBed binary storage remains implemented separately in bigbed.mbt. + +///| +/// Error raised for malformed BED data or invalid coordinate operations. +pub suberror AlignBedError { + AlignBedError(String) +} + +///| +/// A BED score. Biopython preserves non-numeric score tokens as text. +pub enum AlignBedScore { + AlignBedNumeric(Double) + AlignBedText(String) +} derive(Eq, Debug) + +///| +/// One point in the target/query absolute coordinate path. +pub struct AlignBedCoordinate { + target : Int + query : Int +} derive(Eq, Debug) + +///| +/// One aligned BED block in absolute target and query coordinates. +pub struct AlignBedBlock { + target_start : Int + target_end : Int + query_start : Int + query_end : Int +} derive(Eq, Debug) + +///| +/// Coordinate-only alignment counts. +pub struct AlignBedCounts { + aligned : Int + target_skip_bases : Int + query_skip_bases : Int + target_skip_opens : Int + query_skip_opens : Int + blocks : Int + columns : Int +} derive(Eq, Debug) + +///| +/// One BED pairwise alignment. +/// +/// Target coordinates may be stored in either orientation by callers; BED +/// serialization normalizes them to increasing genomic coordinates. Query +/// coordinates decrease for reverse-strand alignments. +pub struct AlignBedAlignment { + target_id : String + query_id : String? + coordinates : Array[AlignBedCoordinate] + score : AlignBedScore? + thick_start : Int? + thick_end : Int? + item_rgb : String? + source_columns : Int +} derive(Eq, Debug) + +///| +/// Summary across all records in a BED document. +pub struct AlignBedSummary { + alignment_count : Int + target_count : Int + query_count : Int + plus_strand_count : Int + minus_strand_count : Int + aligned_bases : Int + target_skip_bases : Int +} derive(Eq, Debug) + +///| +/// A standalone BED document containing zero or more pairwise alignments. +pub struct AlignBedDocument { + alignments : Array[AlignBedAlignment] +} derive(Eq, Debug) + +///| +fn align_bed_fail(message : String) -> Unit raise AlignBedError { + raise AlignBedError(message) +} + +///| +fn align_bed_abs(value : Int) -> Int { + if value < 0 { + -value + } else { + value + } +} + +///| +fn align_bed_min(left : Int, right : Int) -> Int { + if left < right { + left + } else { + right + } +} + +///| +fn align_bed_max(left : Int, right : Int) -> Int { + if left > right { + left + } else { + right + } +} + +///| +fn align_bed_sign(value : Int) -> Int { + if value < 0 { + -1 + } else if value > 0 { + 1 + } else { + 0 + } +} + +///| +fn align_bed_copy_coordinates( + coordinates : Array[AlignBedCoordinate], +) -> Array[AlignBedCoordinate] { + let copied : Array[AlignBedCoordinate] = [] + for coordinate in coordinates { + copied.push(coordinate) + } + copied +} + +///| +fn align_bed_copy_alignments( + alignments : Array[AlignBedAlignment], +) -> Array[AlignBedAlignment] { + let copied : Array[AlignBedAlignment] = [] + for alignment in alignments { + copied.push(alignment) + } + copied +} + +///| +fn align_bed_validate_token( + value : String, + label : String, + allow_empty : Bool, +) -> Unit raise AlignBedError { + if !allow_empty && value.length() == 0 { + align_bed_fail(label + " must not be empty") + } + for index in 0.. Unit raise AlignBedError { + match score { + AlignBedNumeric(value) => + if value.is_nan() || value.abs() > 1.0e300 { + align_bed_fail("BED score must be finite") + } + AlignBedText(value) => + align_bed_validate_token(value, "BED score", false) + } +} + +///| +fn align_bed_reversed_coordinates( + coordinates : Array[AlignBedCoordinate], +) -> Array[AlignBedCoordinate] { + let reversed : Array[AlignBedCoordinate] = [] + for index in 0.. Array[AlignBedCoordinate] { + if coordinates.length() > 1 && + coordinates[0].target > coordinates[coordinates.length() - 1].target { + align_bed_reversed_coordinates(coordinates) + } else { + align_bed_copy_coordinates(coordinates) + } +} + +///| +fn align_bed_blocks_from_coordinates( + coordinates : Array[AlignBedCoordinate], +) -> Array[AlignBedBlock] { + let forward = align_bed_forward_coordinates(coordinates) + let blocks : Array[AlignBedBlock] = [] + if forward.length() < 2 { + return blocks + } + let mut target_start = forward[0].target + let mut query_start = forward[0].query + for index in 1.. Unit raise AlignBedError { + align_bed_validate_token(alignment.target_id, "BED target identifier", false) + match alignment.query_id { + Some(value) => + align_bed_validate_token(value, "BED query identifier", false) + None => () + } + if alignment.source_columns < 3 || alignment.source_columns > 12 { + align_bed_fail("BED column count must be between 3 and 12") + } + match alignment.score { + Some(value) => align_bed_validate_score(value) + None => () + } + match alignment.item_rgb { + Some(value) => align_bed_validate_token(value, "BED itemRgb", false) + None => () + } + if alignment.coordinates.length() < 2 { + align_bed_fail("BED coordinate path must contain at least two points") + } + let mut target_direction = 0 + let mut query_direction = 0 + let mut aligned_segments = 0 + for index in 0.. + if value < interval_start || value > interval_end { + align_bed_fail("BED thickStart must lie inside the target interval") + } + None => () + } + match alignment.thick_end { + Some(value) => + if value < interval_start || value > interval_end { + align_bed_fail("BED thickEnd must lie inside the target interval") + } + None => () + } + match (alignment.thick_start, alignment.thick_end) { + (Some(start), Some(end)) => + if start > end { + align_bed_fail("BED thickStart must not exceed thickEnd") + } + _ => () + } +} + +///| +/// Construct one coordinate point. +pub fn AlignBedCoordinate::create( + target : Int, + query : Int, +) -> AlignBedCoordinate raise AlignBedError { + if target < 0 || query < 0 { + align_bed_fail("BED coordinates must be non-negative") + } + AlignBedCoordinate::{ target, query } +} + +///| +/// Construct a finite numeric BED score. +pub fn AlignBedScore::numeric( + value : Double, +) -> AlignBedScore raise AlignBedError { + let score = AlignBedNumeric(value) + align_bed_validate_score(score) + score +} + +///| +/// Construct a non-empty textual BED score token. +pub fn AlignBedScore::text( + value : String, +) -> AlignBedScore raise AlignBedError { + let score = AlignBedText(value) + align_bed_validate_score(score) + score +} + +///| +/// Return the numeric score, if this score was parsed as a number. +pub fn AlignBedScore::number(self : AlignBedScore) -> Double? { + match self { + AlignBedNumeric(value) => Some(value) + AlignBedText(_) => None + } +} + +///| +/// Return the original textual score, if this is a non-numeric token. +pub fn AlignBedScore::text_value(self : AlignBedScore) -> String? { + match self { + AlignBedNumeric(_) => None + AlignBedText(value) => Some(value) + } +} + +///| +/// Construct and validate a pairwise BED alignment. +pub fn AlignBedAlignment::create( + target_id : String, + query_id : String?, + coordinates : Array[AlignBedCoordinate], + score? : AlignBedScore? = None, + thick_start? : Int? = None, + thick_end? : Int? = None, + item_rgb? : String? = None, + source_columns? : Int = 12, +) -> AlignBedAlignment raise AlignBedError { + let alignment = AlignBedAlignment::{ + target_id, + query_id, + coordinates: align_bed_copy_coordinates(coordinates), + score, + thick_start, + thick_end, + item_rgb, + source_columns, + } + align_bed_validate_alignment(alignment) + alignment +} + +///| +/// Construct a BED document and copy the input alignment array. +pub fn AlignBedDocument::create( + alignments : Array[AlignBedAlignment], +) -> AlignBedDocument raise AlignBedError { + let copied = align_bed_copy_alignments(alignments) + for alignment in copied { + align_bed_validate_alignment(alignment) + } + AlignBedDocument::{ alignments: copied } +} + +///| +fn align_bed_strip_cr(value : String) -> String { + if value.length() > 0 && + value.unsafe_get(value.length() - 1).to_int() == '\r'.to_int() { + value[0:value.length() - 1].to_owned() + } else { + value + } +} + +///| +fn align_bed_split_lines(value : String) -> Array[String] { + let lines : Array[String] = [] + let mut start = 0 + for index in 0.. 0 { + lines.push("") + } + lines +} + +///| +fn align_bed_is_whitespace(code : Int) -> Bool { + code == ' '.to_int() || + code == '\t'.to_int() || + code == '\r'.to_int() || + code == '\n'.to_int() +} + +///| +fn align_bed_trim(value : String) -> String { + let mut start = 0 + while start < value.length() && + align_bed_is_whitespace(value.unsafe_get(start).to_int()) { + start = start + 1 + } + let mut end = value.length() + while end > start && + align_bed_is_whitespace(value.unsafe_get(end - 1).to_int()) { + end = end - 1 + } + value[start:end].to_owned() +} + +///| +fn align_bed_split_whitespace(value : String) -> Array[String] { + let words : Array[String] = [] + let mut index = 0 + while index < value.length() { + while index < value.length() && + align_bed_is_whitespace(value.unsafe_get(index).to_int()) { + index = index + 1 + } + if index >= value.length() { + break + } + let start = index + while index < value.length() && + !align_bed_is_whitespace(value.unsafe_get(index).to_int()) { + index = index + 1 + } + words.push(value[start:index].to_owned()) + } + words +} + +///| +fn align_bed_parse_uint( + value : String, + label : String, +) -> Int raise AlignBedError { + if value.length() == 0 { + align_bed_fail(label + " must be an unsigned integer") + } + let mut result = 0 + for index in 0.. '9'.to_int() { + align_bed_fail(label + " must be an unsigned integer") + } + let digit = code - '0'.to_int() + if result > (2147483647 - digit) / 10 { + align_bed_fail(label + " exceeds the supported integer range") + } + result = result * 10 + digit + } + result +} + +///| +fn align_bed_is_number(value : String) -> Bool { + if value.length() == 0 { + return false + } + let mut index = 0 + if value.unsafe_get(index).to_int() == '-'.to_int() || + value.unsafe_get(index).to_int() == '+'.to_int() { + index = index + 1 + } + let mut digits = 0 + while index < value.length() { + let code = value.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + break + } + digits = digits + 1 + index = index + 1 + } + if index < value.length() && value.unsafe_get(index).to_int() == '.'.to_int() { + index = index + 1 + while index < value.length() { + let code = value.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + break + } + digits = digits + 1 + index = index + 1 + } + } + if digits == 0 { + return false + } + if index < value.length() && + ( + value.unsafe_get(index).to_int() == 'e'.to_int() || + value.unsafe_get(index).to_int() == 'E'.to_int() + ) { + index = index + 1 + if index < value.length() && + ( + value.unsafe_get(index).to_int() == '-'.to_int() || + value.unsafe_get(index).to_int() == '+'.to_int() + ) { + index = index + 1 + } + let exponent_start = index + while index < value.length() { + let code = value.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + break + } + index = index + 1 + } + if index == exponent_start { + return false + } + } + index == value.length() +} + +///| +fn align_bed_parse_score(value : String) -> AlignBedScore raise AlignBedError { + if !align_bed_is_number(value) { + return AlignBedScore::text(value) + } + let parsed_value = if value.unsafe_get(0).to_int() == '+'.to_int() { + value[1:value.length()].to_owned() + } else { + value + } + let number = match parse_double(parsed_value) { + Some(result) => result + None => { + align_bed_fail("BED numeric score could not be parsed") + 0.0 + } + } + AlignBedScore::numeric(number) +} + +///| +fn align_bed_parse_uint_list( + value : String, + label : String, +) -> Array[Int] raise AlignBedError { + let values : Array[Int] = [] + let mut start = 0 + for index in 0.. Unit raise AlignBedError { + if count <= 0 { + align_bed_fail("BED blockCount must be positive") + } + if sizes.length() != count { + align_bed_fail("BED blockCount does not match blockSizes") + } + if starts.length() != count { + align_bed_fail("BED blockCount does not match blockStarts") + } + if starts[0] != 0 { + align_bed_fail("the first BED block must start at chromStart") + } + let mut previous_end = 0 + for index in 0.. span || size > span - start { + align_bed_fail("BED block extends beyond chromEnd") + } + previous_end = start + size + } + if previous_end != span { + align_bed_fail("the last BED block must end at chromEnd") + } +} + +///| +fn align_bed_infer_starts( + span : Int, + sizes : Array[Int], +) -> Array[Int] raise AlignBedError { + let starts : Array[Int] = [] + let mut position = 0 + for size in sizes { + if size <= 0 || position > span || size > span - position { + align_bed_fail("BED11 blockSizes cannot be placed inside chromEnd") + } + starts.push(position) + position = position + size + } + if position != span { + align_bed_fail( + "BED11 blockStarts are ambiguous unless blockSizes cover the full span", + ) + } + starts +} + +///| +fn align_bed_coordinates_from_blocks( + chrom_start : Int, + strand : String, + sizes : Array[Int], + starts : Array[Int], +) -> Array[AlignBedCoordinate] { + let coordinates : Array[AlignBedCoordinate] = [] + let mut query_position = 0 + let mut target_position = chrom_start + coordinates.push(AlignBedCoordinate::{ + target: chrom_start, + query: 0, + }) + for index in 0.. AlignBedAlignment raise AlignBedError { + let words = align_bed_split_whitespace(line) + let bed_columns = words.length() + if bed_columns < 3 || bed_columns > 12 { + align_bed_fail( + "expected between 3 and 12 BED columns at line " + + line_number.to_string() + + ", found " + + bed_columns.to_string(), + ) + } + let target_id = words[0] + align_bed_validate_token(target_id, "BED target identifier", false) + let chrom_start = align_bed_parse_uint(words[1], "BED chromStart") + let chrom_end = align_bed_parse_uint(words[2], "BED chromEnd") + if chrom_end <= chrom_start { + align_bed_fail("BED coordinates must define a positive half-open interval") + } + let span = chrom_end - chrom_start + let query_id = if bed_columns >= 4 { + align_bed_validate_token(words[3], "BED query identifier", false) + Some(words[3]) + } else { + None + } + let score = if bed_columns >= 5 { + Some(align_bed_parse_score(words[4])) + } else { + None + } + let strand = if bed_columns >= 6 { + if words[5] != "+" && words[5] != "-" && words[5] != "." { + align_bed_fail("BED strand must be '+', '-', or '.'") + } + if words[5] == "-" { "-" } else { "+" } + } else { + "+" + } + let thick_start = if bed_columns >= 7 { + Some(align_bed_parse_uint(words[6], "BED thickStart")) + } else { + None + } + let thick_end = if bed_columns >= 8 { + Some(align_bed_parse_uint(words[7], "BED thickEnd")) + } else { + None + } + let item_rgb = if bed_columns >= 9 { + align_bed_validate_token(words[8], "BED itemRgb", false) + Some(words[8]) + } else { + None + } + let sizes : Array[Int] = [] + let starts : Array[Int] = [] + if bed_columns <= 9 { + sizes.push(span) + starts.push(0) + } else { + let block_count = align_bed_parse_uint(words[9], "BED blockCount") + if bed_columns == 10 { + if block_count != 1 { + align_bed_fail( + "BED10 records with multiple blocks lack blockSizes and blockStarts", + ) + } + sizes.push(span) + starts.push(0) + } else { + let parsed_sizes = align_bed_parse_uint_list(words[10], "BED blockSizes") + if parsed_sizes.length() != block_count { + align_bed_fail("BED blockCount does not match blockSizes") + } + for size in parsed_sizes { + sizes.push(size) + } + if bed_columns == 11 { + let inferred = align_bed_infer_starts(span, sizes) + for start in inferred { + starts.push(start) + } + } else { + let parsed_starts = align_bed_parse_uint_list( + words[11], + "BED blockStarts", + ) + for start in parsed_starts { + starts.push(start) + } + } + align_bed_validate_blocks(span, block_count, sizes, starts) + } + } + let coordinates = align_bed_coordinates_from_blocks( + chrom_start, + strand, + sizes, + starts, + ) + AlignBedAlignment::create( + target_id, + query_id, + coordinates, + score~, + thick_start~, + thick_end~, + item_rgb~, + source_columns=bed_columns, + ) +} + +///| +/// Parse all BED records from a string. +pub fn align_bed_parse( + text : String, +) -> AlignBedDocument raise AlignBedError { + if text.length() == 0 { + return AlignBedDocument::create([]) + } + let lines = align_bed_split_lines(text) + let alignments : Array[AlignBedAlignment] = [] + for index in 0.. Array[AlignBedBlock] { + align_bed_blocks_from_coordinates(self.coordinates) +} + +///| +/// Return the relative query strand encoded by this coordinate path. +pub fn AlignBedAlignment::strand(self : AlignBedAlignment) -> String { + let forward = align_bed_forward_coordinates(self.coordinates) + if forward[0].query > forward[forward.length() - 1].query { + "-" + } else { + "+" + } +} + +///| +/// Return the first aligned target coordinate. +pub fn AlignBedAlignment::target_start(self : AlignBedAlignment) -> Int { + self.blocks()[0].target_start +} + +///| +/// Return the exclusive final aligned target coordinate. +pub fn AlignBedAlignment::target_end(self : AlignBedAlignment) -> Int { + let blocks = self.blocks() + blocks[blocks.length() - 1].target_end +} + +///| +/// Return the query length represented by BED blocks. +pub fn AlignBedAlignment::query_size(self : AlignBedAlignment) -> Int { + let mut size = 0 + for block in self.blocks() { + size = size + (block.target_end - block.target_start) + } + size +} + +///| +/// Return the number of aligned target/query residues. +pub fn AlignBedAlignment::aligned_bases(self : AlignBedAlignment) -> Int { + self.query_size() +} + +///| +/// Return the target span between the first and final aligned blocks. +pub fn AlignBedAlignment::target_span(self : AlignBedAlignment) -> Int { + self.target_end() - self.target_start() +} + +///| +/// Return coordinate-only alignment statistics. +pub fn AlignBedAlignment::counts(self : AlignBedAlignment) -> AlignBedCounts { + let mut aligned = 0 + let mut target_skips = 0 + let mut query_skips = 0 + let mut target_opens = 0 + let mut query_opens = 0 + let mut columns = 0 + for index in 0..<(self.coordinates.length() - 1) { + let current = self.coordinates[index] + let next = self.coordinates[index + 1] + let target_step = align_bed_abs(next.target - current.target) + let query_step = align_bed_abs(next.query - current.query) + if target_step > 0 && query_step > 0 { + aligned = aligned + target_step + } else if target_step > 0 { + target_skips = target_skips + target_step + target_opens = target_opens + 1 + } else { + query_skips = query_skips + query_step + query_opens = query_opens + 1 + } + columns = columns + align_bed_max(target_step, query_step) + } + AlignBedCounts::{ + aligned, + target_skip_bases: target_skips, + query_skip_bases: query_skips, + target_skip_opens: target_opens, + query_skip_opens: query_opens, + blocks: self.blocks().length(), + columns, + } +} + +///| +fn align_bed_map_on_segment( + source : Int, + source_start : Int, + source_end : Int, + destination_start : Int, + destination_end : Int, +) -> Int? { + let source_step = source_end - source_start + let destination_step = destination_end - destination_start + if source_step == 0 || + destination_step == 0 || + align_bed_abs(source_step) != align_bed_abs(destination_step) { + return None + } + let offset = if source_step > 0 { + if source < source_start || source >= source_end { + return None + } + source - source_start + } else { + if source < source_end || source >= source_start { + return None + } + source_start - 1 - source + } + if destination_step > 0 { + Some(destination_start + offset) + } else { + Some(destination_start - 1 - offset) + } +} + +///| +/// Map one target residue to the query, returning `None` in an intron/gap. +pub fn AlignBedAlignment::map_target_position( + self : AlignBedAlignment, + position : Int, +) -> Int? { + if position < 0 { + return None + } + for index in 0..<(self.coordinates.length() - 1) { + let current = self.coordinates[index] + let next = self.coordinates[index + 1] + match + align_bed_map_on_segment( + position, + current.target, + next.target, + current.query, + next.query, + ) { + Some(mapped) => return Some(mapped) + None => () + } + } + None +} + +///| +/// Map one query residue to the target, returning `None` in an unaligned gap. +pub fn AlignBedAlignment::map_query_position( + self : AlignBedAlignment, + position : Int, +) -> Int? { + if position < 0 { + return None + } + for index in 0..<(self.coordinates.length() - 1) { + let current = self.coordinates[index] + let next = self.coordinates[index + 1] + match + align_bed_map_on_segment( + position, + current.query, + next.query, + current.target, + next.target, + ) { + Some(mapped) => return Some(mapped) + None => () + } + } + None +} + +///| +/// Return true if the aligned target interval overlaps a half-open query. +pub fn AlignBedAlignment::overlaps( + self : AlignBedAlignment, + target_id : String, + start : Int, + end : Int, +) -> Bool { + end > start && + self.target_id == target_id && + self.target_start() < end && + start < self.target_end() +} + +///| +fn align_bed_join_tabs(fields : Array[String]) -> String { + let output = StringBuilder::new() + for index in 0.. 0 { + output.write_char('\t') + } + output.write_string(fields[index]) + } + output.to_string() +} + +///| +fn align_bed_integer_list(values : Array[Int]) -> String { + let output = StringBuilder::new() + for value in values { + output.write_string(value.to_string()) + output.write_char(',') + } + output.to_string() +} + +///| +fn align_bed_score_text(score : AlignBedScore) -> String { + match score { + AlignBedNumeric(value) => value.to_string() + AlignBedText(value) => value + } +} + +///| +/// Format one alignment using BED3 through BED12. +pub fn align_bed_format( + alignment : AlignBedAlignment, + bed_columns? : Int = 12, +) -> String raise AlignBedError { + if bed_columns < 3 || bed_columns > 12 { + align_bed_fail("BED column count must be between 3 and 12") + } + align_bed_validate_alignment(alignment) + let blocks = alignment.blocks() + if blocks.length() == 0 { + return "" + } + let chrom_start = blocks[0].target_start + let chrom_end = blocks[blocks.length() - 1].target_end + let fields : Array[String] = [ + alignment.target_id, + chrom_start.to_string(), + chrom_end.to_string(), + ] + if bed_columns == 3 { + return align_bed_join_tabs(fields) + "\n" + } + fields.push(alignment.query_id.unwrap_or("query")) + if bed_columns == 4 { + return align_bed_join_tabs(fields) + "\n" + } + fields.push( + match alignment.score { + Some(score) => align_bed_score_text(score) + None => "0" + }, + ) + if bed_columns == 5 { + return align_bed_join_tabs(fields) + "\n" + } + fields.push(alignment.strand()) + if bed_columns == 6 { + return align_bed_join_tabs(fields) + "\n" + } + fields.push(alignment.thick_start.unwrap_or(chrom_start).to_string()) + if bed_columns == 7 { + return align_bed_join_tabs(fields) + "\n" + } + fields.push(alignment.thick_end.unwrap_or(chrom_end).to_string()) + if bed_columns == 8 { + return align_bed_join_tabs(fields) + "\n" + } + fields.push(alignment.item_rgb.unwrap_or("0")) + if bed_columns == 9 { + return align_bed_join_tabs(fields) + "\n" + } + fields.push(blocks.length().to_string()) + if bed_columns == 10 { + return align_bed_join_tabs(fields) + "\n" + } + let block_sizes : Array[Int] = [] + let block_starts : Array[Int] = [] + for block in blocks { + block_sizes.push(block.target_end - block.target_start) + block_starts.push(block.target_start - chrom_start) + } + fields.push(align_bed_integer_list(block_sizes)) + if bed_columns == 11 { + return align_bed_join_tabs(fields) + "\n" + } + fields.push(align_bed_integer_list(block_starts)) + align_bed_join_tabs(fields) + "\n" +} + +///| +/// Serialize all records in a BED document. +pub fn align_bed_write( + document : AlignBedDocument, + bed_columns? : Int = 12, +) -> String raise AlignBedError { + let validated = AlignBedDocument::create(document.alignments) + let output = StringBuilder::new() + for alignment in validated.alignments { + output.write_string(align_bed_format(alignment, bed_columns~)) + } + output.to_string() +} + +///| +/// Find all records overlapping one target half-open interval. +pub fn AlignBedDocument::search( + self : AlignBedDocument, + target_id : String, + start : Int, + end : Int, +) -> Array[AlignBedAlignment] raise AlignBedError { + if start < 0 || end <= start { + align_bed_fail("BED search interval must satisfy 0 <= start < end") + } + let results : Array[AlignBedAlignment] = [] + for alignment in self.alignments { + if alignment.overlaps(target_id, start, end) { + results.push(alignment) + } + } + results +} + +///| +/// Return distinct target identifiers in first-seen order. +pub fn AlignBedDocument::targets(self : AlignBedDocument) -> Array[String] { + let targets : Array[String] = [] + let seen : Map[String, Bool] = Map([]) + for alignment in self.alignments { + if !seen.contains(alignment.target_id) { + seen[alignment.target_id] = true + targets.push(alignment.target_id) + } + } + targets +} + +///| +/// Return distinct non-missing query identifiers in first-seen order. +pub fn AlignBedDocument::queries(self : AlignBedDocument) -> Array[String] { + let queries : Array[String] = [] + let seen : Map[String, Bool] = Map([]) + for alignment in self.alignments { + match alignment.query_id { + Some(query) => + if !seen.contains(query) { + seen[query] = true + queries.push(query) + } + None => () + } + } + queries +} + +///| +/// Summarize all records in the document. +pub fn AlignBedDocument::summary(self : AlignBedDocument) -> AlignBedSummary { + let mut plus = 0 + let mut minus = 0 + let mut aligned = 0 + let mut target_skips = 0 + for alignment in self.alignments { + if alignment.strand() == "-" { + minus = minus + 1 + } else { + plus = plus + 1 + } + let counts = alignment.counts() + aligned = aligned + counts.aligned + target_skips = target_skips + counts.target_skip_bases + } + AlignBedSummary::{ + alignment_count: self.alignments.length(), + target_count: self.targets().length(), + query_count: self.queries().length(), + plus_strand_count: plus, + minus_strand_count: minus, + aligned_bases: aligned, + target_skip_bases: target_skips, + } +} + +///| +/// A compact Biopython-style BED3/BED12 fixture. +pub fn align_bed_example_text() -> String { + "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\t2\t567,488,\t0,3512,\n" + + "chr22\t2000\t6000\tmRNA2\t900\t-\t2300\t5960\t0,255,0\t2\t433,399,\t0,3601,\n" + + "chr7\t100\t180" +} diff --git a/src/align_chain.mbt b/src/align_chain.mbt new file mode 100644 index 00000000..cdaac195 --- /dev/null +++ b/src/align_chain.mbt @@ -0,0 +1,1403 @@ +// Biopython-compatible Bio.Align.chain support. +// +// This module is intentionally separate from chain_liftover.mbt. The older +// module provides a permissive rtracklayer-style liftOver API, while this file +// models modern Bio.Align pairwise alignments as absolute coordinate paths. + +///| +/// Error raised for malformed chain data or invalid coordinate operations. +pub suberror AlignChainError { + AlignChainError(String) +} + +///| +/// One point in a two-row absolute coordinate path. +pub struct AlignChainCoordinate { + target : Int + query : Int +} derive(Eq, Debug) + +///| +/// One canonical UCSC chain block. +/// +/// A non-final row contains all three fields. The final row uses `size` only, +/// and therefore has zero target and query gaps. +pub struct AlignChainBlock { + size : Int + target_gap : Int + query_gap : Int +} derive(Eq, Debug) + +///| +/// One aligned part of a requested genomic range. +/// +/// Coordinates are always zero-based, forward-axis, half-open intervals. +pub struct AlignChainRangeMapping { + target_start : Int + target_end : Int + query_start : Int + query_end : Int + target_strand : String + query_strand : String +} derive(Eq, Debug) + +///| +/// One aligned residue pair in forward genomic coordinates. +pub struct AlignChainPair { + target : Int + query : Int +} derive(Eq, Debug) + +///| +/// Coordinate-only chain alignment statistics. +pub struct AlignChainCounts { + aligned : Int + target_gap_bases : Int + query_gap_bases : Int + gap_columns : Int + target_gap_opens : Int + query_gap_opens : Int + aligned_blocks : Int + path_segments : Int +} derive(Eq, Debug) + +///| +/// A coordinate-aware pairwise chain alignment. +/// +/// `coordinates` follows Biopython's `Alignment.coordinates` convention. +/// Reverse strands are represented by decreasing coordinates. Chain files do +/// not store sequence letters, only sequence lengths and the coordinate path. +pub struct AlignChainAlignment { + target_id : String + target_size : Int + query_id : String + query_size : Int + score : Double + chain_id : String + coordinates : Array[AlignChainCoordinate] +} derive(Eq, Debug) + +///| +fn align_chain_fail(message : String) -> Unit raise AlignChainError { + raise AlignChainError(message) +} + +///| +fn align_chain_abs(value : Int) -> Int { + if value < 0 { + -value + } else { + value + } +} + +///| +fn align_chain_min(left : Int, right : Int) -> Int { + if left < right { + left + } else { + right + } +} + +///| +fn align_chain_max(left : Int, right : Int) -> Int { + if left > right { + left + } else { + right + } +} + +///| +fn align_chain_sign(value : Int) -> Int { + if value < 0 { + -1 + } else if value > 0 { + 1 + } else { + 0 + } +} + +///| +fn align_chain_copy_coordinates( + coordinates : Array[AlignChainCoordinate], +) -> Array[AlignChainCoordinate] { + let copied : Array[AlignChainCoordinate] = [] + for coordinate in coordinates { + copied.push(coordinate) + } + copied +} + +///| +fn align_chain_copy_alignments( + alignments : Array[AlignChainAlignment], +) -> Array[AlignChainAlignment] { + let copied : Array[AlignChainAlignment] = [] + for alignment in alignments { + copied.push(alignment) + } + copied +} + +///| +fn align_chain_validate_token( + value : String, + label : String, + allow_empty : Bool, +) -> Unit raise AlignChainError { + if !allow_empty && value.length() == 0 { + align_chain_fail(label + " must not be empty") + } + for index in 0.. Unit raise AlignChainError { + if strand != "+" && strand != "-" { + align_chain_fail(label + " strand must be '+' or '-'") + } +} + +///| +fn align_chain_validate_interval( + start : Int, + end : Int, + size : Int, + label : String, +) -> Unit raise AlignChainError { + if size < 0 { + align_chain_fail(label + " size must be non-negative") + } + if start < 0 || end < start || end > size { + align_chain_fail(label + " interval must satisfy 0 <= start <= end <= size") + } +} + +///| +fn align_chain_validate_alignment( + alignment : AlignChainAlignment, +) -> Unit raise AlignChainError { + align_chain_validate_token(alignment.target_id, "target identifier", false) + align_chain_validate_token(alignment.query_id, "query identifier", false) + align_chain_validate_token(alignment.chain_id, "chain identifier", true) + if alignment.target_size < 0 { + align_chain_fail("target size must be non-negative") + } + if alignment.query_size < 0 { + align_chain_fail("query size must be non-negative") + } + if alignment.score.is_nan() || alignment.score.abs() > 1.0e300 { + align_chain_fail("chain score must be finite") + } + if alignment.coordinates.length() < 2 { + align_chain_fail("chain coordinate path must contain at least two points") + } + let mut target_direction = 0 + let mut query_direction = 0 + let mut aligned = 0 + for index in 0.. alignment.target_size { + align_chain_fail("target coordinate is outside the declared sequence") + } + if point.query < 0 || point.query > alignment.query_size { + align_chain_fail("query coordinate is outside the declared sequence") + } + if index + 1 < alignment.coordinates.length() { + let next = alignment.coordinates[index + 1] + let target_step = next.target - point.target + let query_step = next.query - point.query + if target_step == 0 && query_step == 0 { + align_chain_fail("chain coordinate path contains a zero-length segment") + } + if target_step != 0 { + let direction = align_chain_sign(target_step) + if target_direction == 0 { + target_direction = direction + } else if target_direction != direction { + align_chain_fail("target coordinates must be monotonic") + } + } + if query_step != 0 { + let direction = align_chain_sign(query_step) + if query_direction == 0 { + query_direction = direction + } else if query_direction != direction { + align_chain_fail("query coordinates must be monotonic") + } + } + if target_step != 0 && query_step != 0 { + if align_chain_abs(target_step) != align_chain_abs(query_step) { + align_chain_fail( + "aligned target and query steps must have equal lengths", + ) + } + aligned = aligned + align_chain_abs(target_step) + } + } + } + if target_direction == 0 || query_direction == 0 || aligned == 0 { + align_chain_fail("chain path must contain at least one aligned segment") + } +} + +///| +/// Construct one absolute coordinate. +pub fn AlignChainCoordinate::create( + target : Int, + query : Int, +) -> AlignChainCoordinate raise AlignChainError { + if target < 0 || query < 0 { + align_chain_fail("chain coordinates must be non-negative") + } + AlignChainCoordinate::{ target, query } +} + +///| +/// Construct one chain block. +pub fn AlignChainBlock::create( + size : Int, + target_gap? : Int = 0, + query_gap? : Int = 0, +) -> AlignChainBlock raise AlignChainError { + if size < 0 || target_gap < 0 || query_gap < 0 { + align_chain_fail("chain block values must be non-negative") + } + AlignChainBlock::{ size, target_gap, query_gap } +} + +///| +/// Construct and validate a coordinate-aware chain alignment. +pub fn AlignChainAlignment::create( + target_id : String, + target_size : Int, + query_id : String, + query_size : Int, + coordinates : Array[AlignChainCoordinate], + score? : Double = 0.0, + chain_id? : String = "", +) -> AlignChainAlignment raise AlignChainError { + let alignment = AlignChainAlignment::{ + target_id, + target_size, + query_id, + query_size, + score, + chain_id, + coordinates: align_chain_copy_coordinates(coordinates), + } + align_chain_validate_alignment(alignment) + alignment +} + +///| +fn align_chain_oriented_coordinate( + coordinate : Int, + size : Int, + strand : String, +) -> Int { + if strand == "+" { + coordinate + } else { + size - coordinate + } +} + +///| +/// Build an alignment from normalized UCSC header coordinates and blocks. +pub fn align_chain_from_blocks( + target_id : String, + target_size : Int, + target_strand : String, + target_start : Int, + target_end : Int, + query_id : String, + query_size : Int, + query_strand : String, + query_start : Int, + query_end : Int, + blocks : Array[AlignChainBlock], + score? : Double = 0.0, + chain_id? : String = "", +) -> AlignChainAlignment raise AlignChainError { + align_chain_validate_token(target_id, "target identifier", false) + align_chain_validate_token(query_id, "query identifier", false) + align_chain_validate_token(chain_id, "chain identifier", true) + align_chain_validate_strand(target_strand, "target") + align_chain_validate_strand(query_strand, "query") + align_chain_validate_interval(target_start, target_end, target_size, "target") + align_chain_validate_interval(query_start, query_end, query_size, "query") + if score.is_nan() || score.abs() > 1.0e300 { + align_chain_fail("chain score must be finite") + } + if blocks.length() == 0 { + align_chain_fail("chain record must contain at least one block row") + } + let relative : Array[AlignChainCoordinate] = [ + AlignChainCoordinate::{ target: 0, query: 0 }, + ] + let mut target_position = 0 + let mut query_position = 0 + let mut aligned = 0 + for index in 0.. 0 { + target_position = target_position + block.size + query_position = query_position + block.size + relative.push(AlignChainCoordinate::{ + target: target_position, + query: query_position, + }) + aligned = aligned + block.size + } + if block.target_gap > 0 { + target_position = target_position + block.target_gap + relative.push(AlignChainCoordinate::{ + target: target_position, + query: query_position, + }) + } + if block.query_gap > 0 { + query_position = query_position + block.query_gap + relative.push(AlignChainCoordinate::{ + target: target_position, + query: query_position, + }) + } + if target_position > target_end - target_start { + align_chain_fail("chain blocks exceed the declared target span") + } + if query_position > query_end - query_start { + align_chain_fail("chain blocks exceed the declared query span") + } + } + if aligned == 0 { + align_chain_fail("chain record must contain aligned bases") + } + if target_position != target_end - target_start { + align_chain_fail("chain blocks do not match the declared target span") + } + if query_position != query_end - query_start { + align_chain_fail("chain blocks do not match the declared query span") + } + let coordinates : Array[AlignChainCoordinate] = [] + for point in relative { + let target_oriented = target_start + point.target + let query_oriented = query_start + point.query + coordinates.push(AlignChainCoordinate::{ + target: align_chain_oriented_coordinate( + target_oriented, target_size, target_strand, + ), + query: align_chain_oriented_coordinate( + query_oriented, query_size, query_strand, + ), + }) + } + AlignChainAlignment::create( + target_id, + target_size, + query_id, + query_size, + coordinates, + score~, + chain_id~, + ) +} + +///| +fn align_chain_strip_cr(value : String) -> String { + if value.length() > 0 && + value.unsafe_get(value.length() - 1).to_int() == '\r'.to_int() { + value[0:value.length() - 1].to_owned() + } else { + value + } +} + +///| +fn align_chain_split_lines(value : String) -> Array[String] { + let lines : Array[String] = [] + let mut start = 0 + for index in 0.. 0 { + lines.push("") + } + lines +} + +///| +fn align_chain_is_whitespace(code : Int) -> Bool { + code == ' '.to_int() || + code == '\t'.to_int() || + code == '\r'.to_int() || + code == '\n'.to_int() +} + +///| +fn align_chain_trim(value : String) -> String { + let mut start = 0 + while start < value.length() && + align_chain_is_whitespace(value.unsafe_get(start).to_int()) { + start = start + 1 + } + let mut end = value.length() + while end > start && + align_chain_is_whitespace(value.unsafe_get(end - 1).to_int()) { + end = end - 1 + } + value[start:end].to_owned() +} + +///| +fn align_chain_split_whitespace(value : String) -> Array[String] { + let words : Array[String] = [] + let mut index = 0 + while index < value.length() { + while index < value.length() && + align_chain_is_whitespace(value.unsafe_get(index).to_int()) { + index = index + 1 + } + if index >= value.length() { + break + } + let start = index + while index < value.length() && + !align_chain_is_whitespace(value.unsafe_get(index).to_int()) { + index = index + 1 + } + words.push(value[start:index].to_owned()) + } + words +} + +///| +fn align_chain_parse_uint( + value : String, + label : String, +) -> Int raise AlignChainError { + if value.length() == 0 { + align_chain_fail(label + " must be an unsigned integer") + } + let mut result = 0 + for index in 0.. '9'.to_int() { + align_chain_fail(label + " must be an unsigned integer") + } + let digit = code - '0'.to_int() + if result > (2147483647 - digit) / 10 { + align_chain_fail(label + " exceeds the supported integer range") + } + result = result * 10 + digit + } + result +} + +///| +fn align_chain_is_score(value : String) -> Bool { + if value.length() == 0 { + return false + } + let mut index = 0 + if value.unsafe_get(index).to_int() == '-'.to_int() || + value.unsafe_get(index).to_int() == '+'.to_int() { + index = index + 1 + } + let mut digits = 0 + while index < value.length() { + let code = value.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + break + } + digits = digits + 1 + index = index + 1 + } + if index < value.length() && value.unsafe_get(index).to_int() == '.'.to_int() { + index = index + 1 + while index < value.length() { + let code = value.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + break + } + digits = digits + 1 + index = index + 1 + } + } + if digits == 0 { + return false + } + if index < value.length() && + ( + value.unsafe_get(index).to_int() == 'e'.to_int() || + value.unsafe_get(index).to_int() == 'E'.to_int() + ) { + index = index + 1 + if index < value.length() && + ( + value.unsafe_get(index).to_int() == '-'.to_int() || + value.unsafe_get(index).to_int() == '+'.to_int() + ) { + index = index + 1 + } + let exponent_start = index + while index < value.length() { + let code = value.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + break + } + index = index + 1 + } + if index == exponent_start { + return false + } + } + index == value.length() +} + +///| +fn align_chain_parse_score(value : String) -> Double raise AlignChainError { + if !align_chain_is_score(value) { + align_chain_fail("chain score must be a number") + } + let parse_value = if value.length() > 0 && + value.unsafe_get(0).to_int() == '+'.to_int() { + value[1:value.length()].to_owned() + } else { + value + } + let number = match parse_double(parse_value) { + Some(number) => number + None => { + align_chain_fail("chain score must be a number") + 0.0 + } + } + if number.is_nan() || number.abs() > 1.0e300 { + align_chain_fail("chain score must be finite") + } + number +} + +///| +fn align_chain_parse_record( + lines : Array[String], + start : Int, +) -> (AlignChainAlignment, Int) raise AlignChainError { + let header = align_chain_split_whitespace(align_chain_trim(lines[start])) + if header.length() != 12 && header.length() != 13 { + align_chain_fail( + "chain header must contain exactly 12 or 13 whitespace-delimited fields", + ) + } + if header[0] != "chain" { + align_chain_fail("chain record must start with the 'chain' keyword") + } + let score = align_chain_parse_score(header[1]) + let target_id = header[2] + let target_size = align_chain_parse_uint(header[3], "target size") + let target_strand = header[4] + let target_start = align_chain_parse_uint(header[5], "target start") + let target_end = align_chain_parse_uint(header[6], "target end") + let query_id = header[7] + let query_size = align_chain_parse_uint(header[8], "query size") + let query_strand = header[9] + let query_start = align_chain_parse_uint(header[10], "query start") + let query_end = align_chain_parse_uint(header[11], "query end") + let chain_id = if header.length() == 13 { header[12] } else { "" } + align_chain_validate_strand(target_strand, "target") + align_chain_validate_strand(query_strand, "query") + align_chain_validate_interval(target_start, target_end, target_size, "target") + align_chain_validate_interval(query_start, query_end, query_size, "query") + let blocks : Array[AlignChainBlock] = [] + let mut index = start + 1 + let mut terminated = false + while index < lines.length() { + let line = align_chain_trim(lines[index]) + if line.length() == 0 { + align_chain_fail("blank line found before the final chain block") + } + let words = align_chain_split_whitespace(line) + if words.length() > 0 && words[0] == "chain" { + align_chain_fail("chain record is missing its final size-only block") + } + if words.length() != 1 && words.length() != 3 { + align_chain_fail("chain block must contain one or three integer fields") + } + let size = align_chain_parse_uint(words[0], "chain block size") + if words.length() == 1 { + blocks.push(AlignChainBlock::{ size, target_gap: 0, query_gap: 0 }) + index = index + 1 + terminated = true + break + } + let target_gap = align_chain_parse_uint(words[1], "target gap") + let query_gap = align_chain_parse_uint(words[2], "query gap") + if target_gap == 0 && query_gap == 0 { + align_chain_fail("non-final chain block must contain a non-zero gap") + } + blocks.push(AlignChainBlock::{ size, target_gap, query_gap }) + index = index + 1 + } + if !terminated { + align_chain_fail("chain record is missing its final size-only block") + } + let alignment = align_chain_from_blocks( + target_id, + target_size, + target_strand, + target_start, + target_end, + query_id, + query_size, + query_strand, + query_start, + query_end, + blocks, + score~, + chain_id~, + ) + (alignment, index) +} + +///| +/// Parse all chain records in a string. +pub fn align_chain_parse_all( + text : String, +) -> Array[AlignChainAlignment] raise AlignChainError { + let lines = align_chain_split_lines(text) + let alignments : Array[AlignChainAlignment] = [] + let mut index = 0 + while index < lines.length() { + let line = align_chain_trim(lines[index]) + if line.length() == 0 { + index = index + 1 + continue + } + if align_chain_split_whitespace(line)[0] != "chain" { + align_chain_fail( + "unexpected content before chain record at line " + + (index + 1).to_string(), + ) + } + let (alignment, next) = align_chain_parse_record(lines, index) + alignments.push(alignment) + index = next + } + alignments +} + +///| +/// Parse exactly one chain record. +pub fn align_chain_parse( + text : String, +) -> AlignChainAlignment raise AlignChainError { + let alignments = align_chain_parse_all(text) + if alignments.length() == 0 { + align_chain_fail("chain input contains no records") + } + if alignments.length() != 1 { + align_chain_fail("expected exactly one chain record") + } + alignments[0] +} + +///| +/// Return the target strand encoded by the coordinate path. +pub fn AlignChainAlignment::target_strand(self : AlignChainAlignment) -> String { + if self.coordinates[self.coordinates.length() - 1].target > + self.coordinates[0].target { + "+" + } else { + "-" + } +} + +///| +/// Return the query strand encoded by the coordinate path. +pub fn AlignChainAlignment::query_strand(self : AlignChainAlignment) -> String { + if self.coordinates[self.coordinates.length() - 1].query > + self.coordinates[0].query { + "+" + } else { + "-" + } +} + +///| +/// Return the normalized target start. +pub fn AlignChainAlignment::target_start(self : AlignChainAlignment) -> Int { + align_chain_min( + self.coordinates[0].target, + self.coordinates[self.coordinates.length() - 1].target, + ) +} + +///| +/// Return the normalized target end. +pub fn AlignChainAlignment::target_end(self : AlignChainAlignment) -> Int { + align_chain_max( + self.coordinates[0].target, + self.coordinates[self.coordinates.length() - 1].target, + ) +} + +///| +/// Return the normalized query start. +pub fn AlignChainAlignment::query_start(self : AlignChainAlignment) -> Int { + align_chain_min( + self.coordinates[0].query, + self.coordinates[self.coordinates.length() - 1].query, + ) +} + +///| +/// Return the normalized query end. +pub fn AlignChainAlignment::query_end(self : AlignChainAlignment) -> Int { + align_chain_max( + self.coordinates[0].query, + self.coordinates[self.coordinates.length() - 1].query, + ) +} + +///| +fn align_chain_target_oriented( + alignment : AlignChainAlignment, + coordinate : Int, +) -> Int { + if alignment.target_strand() == "+" { + coordinate + } else { + alignment.target_size - coordinate + } +} + +///| +fn align_chain_query_oriented( + alignment : AlignChainAlignment, + coordinate : Int, +) -> Int { + if alignment.query_strand() == "+" { + coordinate + } else { + alignment.query_size - coordinate + } +} + +///| +/// Convert the coordinate path to canonical chain block rows. +pub fn AlignChainAlignment::blocks( + self : AlignChainAlignment, +) -> Array[AlignChainBlock] raise AlignChainError { + align_chain_validate_alignment(self) + let blocks : Array[AlignChainBlock] = [] + let mut size = 0 + let mut target_gap = 0 + let mut query_gap = 0 + for index in 0..<(self.coordinates.length() - 1) { + let current = self.coordinates[index] + let next = self.coordinates[index + 1] + let target_step = align_chain_target_oriented(self, next.target) - + align_chain_target_oriented(self, current.target) + let query_step = align_chain_query_oriented(self, next.query) - + align_chain_query_oriented(self, current.query) + if target_step < 0 || query_step < 0 { + align_chain_fail("chain coordinate path is not monotonic on its strand") + } + if target_step > 0 && query_step > 0 { + if target_step != query_step { + align_chain_fail( + "aligned target and query steps must have equal lengths", + ) + } + if target_gap > 0 || query_gap > 0 { + blocks.push(AlignChainBlock::{ size, target_gap, query_gap }) + size = target_step + target_gap = 0 + query_gap = 0 + } else { + size = size + target_step + } + } else if target_step > 0 { + target_gap = target_gap + target_step + } else if query_step > 0 { + query_gap = query_gap + query_step + } + } + if target_gap > 0 || query_gap > 0 { + blocks.push(AlignChainBlock::{ size, target_gap, query_gap }) + size = 0 + } + blocks.push(AlignChainBlock::{ size, target_gap: 0, query_gap: 0 }) + blocks +} + +///| +fn align_chain_header_target_start(alignment : AlignChainAlignment) -> Int { + align_chain_target_oriented(alignment, alignment.coordinates[0].target) +} + +///| +fn align_chain_header_target_end(alignment : AlignChainAlignment) -> Int { + align_chain_target_oriented( + alignment, + alignment.coordinates[alignment.coordinates.length() - 1].target, + ) +} + +///| +fn align_chain_header_query_start(alignment : AlignChainAlignment) -> Int { + align_chain_query_oriented(alignment, alignment.coordinates[0].query) +} + +///| +fn align_chain_header_query_end(alignment : AlignChainAlignment) -> Int { + align_chain_query_oriented( + alignment, + alignment.coordinates[alignment.coordinates.length() - 1].query, + ) +} + +///| +/// Serialize one alignment as a canonical UCSC chain record. +pub fn align_chain_write( + alignment : AlignChainAlignment, +) -> String raise AlignChainError { + align_chain_validate_alignment(alignment) + let output = StringBuilder::new() + output.write_string("chain ") + output.write_string(alignment.score.to_string()) + output.write_char(' ') + output.write_string(alignment.target_id) + output.write_char(' ') + output.write_string(alignment.target_size.to_string()) + output.write_char(' ') + output.write_string(alignment.target_strand()) + output.write_char(' ') + output.write_string(align_chain_header_target_start(alignment).to_string()) + output.write_char(' ') + output.write_string(align_chain_header_target_end(alignment).to_string()) + output.write_char(' ') + output.write_string(alignment.query_id) + output.write_char(' ') + output.write_string(alignment.query_size.to_string()) + output.write_char(' ') + output.write_string(alignment.query_strand()) + output.write_char(' ') + output.write_string(align_chain_header_query_start(alignment).to_string()) + output.write_char(' ') + output.write_string(align_chain_header_query_end(alignment).to_string()) + if alignment.chain_id.length() > 0 { + output.write_char(' ') + output.write_string(alignment.chain_id) + } + output.write_char('\n') + let blocks = alignment.blocks() + for index in 0.. String raise AlignChainError { + let output = StringBuilder::new() + for alignment in alignments { + output.write_string(align_chain_write(alignment)) + } + output.to_string() +} + +///| +/// Return one operation per coordinate-path segment. +/// +/// `M` consumes both rows, `D` consumes target only, and `I` consumes query +/// only. +pub fn AlignChainAlignment::operation_path( + self : AlignChainAlignment, +) -> String { + let output = StringBuilder::new() + for index in 0..<(self.coordinates.length() - 1) { + let current = self.coordinates[index] + let next = self.coordinates[index + 1] + let target_step = next.target - current.target + let query_step = next.query - current.query + if target_step != 0 && query_step != 0 { + output.write_char('M') + } else if target_step != 0 { + output.write_char('D') + } else { + output.write_char('I') + } + } + output.to_string() +} + +///| +/// Count the number of alignment columns represented by the path. +pub fn AlignChainAlignment::alignment_length(self : AlignChainAlignment) -> Int { + let mut length = 0 + for index in 0..<(self.coordinates.length() - 1) { + let current = self.coordinates[index] + let next = self.coordinates[index + 1] + length = length + + align_chain_max( + align_chain_abs(next.target - current.target), + align_chain_abs(next.query - current.query), + ) + } + length +} + +///| +/// Count aligned bases. +pub fn AlignChainAlignment::aligned_bases(self : AlignChainAlignment) -> Int { + let mut aligned = 0 + for index in 0..<(self.coordinates.length() - 1) { + let current = self.coordinates[index] + let next = self.coordinates[index + 1] + let target_step = align_chain_abs(next.target - current.target) + let query_step = align_chain_abs(next.query - current.query) + if target_step > 0 && query_step > 0 { + aligned = aligned + target_step + } + } + aligned +} + +///| +/// Compute coordinate-only alignment counts. +pub fn AlignChainAlignment::counts( + self : AlignChainAlignment, +) -> AlignChainCounts { + let mut aligned = 0 + let mut target_gap_bases = 0 + let mut query_gap_bases = 0 + let mut target_gap_opens = 0 + let mut query_gap_opens = 0 + let mut aligned_blocks = 0 + let mut previous = 'X' + for index in 0..<(self.coordinates.length() - 1) { + let current = self.coordinates[index] + let next = self.coordinates[index + 1] + let target_step = align_chain_abs(next.target - current.target) + let query_step = align_chain_abs(next.query - current.query) + if target_step > 0 && query_step > 0 { + aligned = aligned + target_step + if previous != 'M' { + aligned_blocks = aligned_blocks + 1 + } + previous = 'M' + } else if target_step > 0 { + target_gap_bases = target_gap_bases + target_step + if previous != 'D' { + target_gap_opens = target_gap_opens + 1 + } + previous = 'D' + } else { + query_gap_bases = query_gap_bases + query_step + if previous != 'I' { + query_gap_opens = query_gap_opens + 1 + } + previous = 'I' + } + } + AlignChainCounts::{ + aligned, + target_gap_bases, + query_gap_bases, + gap_columns: target_gap_bases + query_gap_bases, + target_gap_opens, + query_gap_opens, + aligned_blocks, + path_segments: self.coordinates.length() - 1, + } +} + +///| +fn align_chain_map_on_segment( + source : Int, + source_start : Int, + source_end : Int, + destination_start : Int, + destination_end : Int, +) -> Int? { + let source_step = source_end - source_start + let destination_step = destination_end - destination_start + if source_step == 0 || + destination_step == 0 || + align_chain_abs(source_step) != align_chain_abs(destination_step) { + return None + } + let offset = if source_step > 0 { + if source < source_start || source >= source_end { + return None + } + source - source_start + } else { + if source < source_end || source >= source_start { + return None + } + source_start - 1 - source + } + if destination_step > 0 { + Some(destination_start + offset) + } else { + Some(destination_start - 1 - offset) + } +} + +///| +/// Map one target residue to the query, returning `None` in an unaligned gap. +pub fn AlignChainAlignment::map_target_position( + self : AlignChainAlignment, + position : Int, +) -> Int? { + if position < 0 || position >= self.target_size { + return None + } + for index in 0..<(self.coordinates.length() - 1) { + let current = self.coordinates[index] + let next = self.coordinates[index + 1] + match + align_chain_map_on_segment( + position, + current.target, + next.target, + current.query, + next.query, + ) { + Some(mapped) => return Some(mapped) + None => () + } + } + None +} + +///| +/// Map one query residue to the target, returning `None` in an unaligned gap. +pub fn AlignChainAlignment::map_query_position( + self : AlignChainAlignment, + position : Int, +) -> Int? { + if position < 0 || position >= self.query_size { + return None + } + for index in 0..<(self.coordinates.length() - 1) { + let current = self.coordinates[index] + let next = self.coordinates[index + 1] + match + align_chain_map_on_segment( + position, + current.query, + next.query, + current.target, + next.target, + ) { + Some(mapped) => return Some(mapped) + None => () + } + } + None +} + +///| +fn align_chain_range_mapping( + alignment : AlignChainAlignment, + target_start : Int, + target_end : Int, + query_start : Int, + query_end : Int, +) -> AlignChainRangeMapping { + AlignChainRangeMapping::{ + target_start, + target_end, + query_start, + query_end, + target_strand: alignment.target_strand(), + query_strand: alignment.query_strand(), + } +} + +///| +/// Map a target interval to all aligned query pieces. +/// +/// Target-only gap portions are omitted, so one input interval may yield +/// multiple output pieces. +pub fn AlignChainAlignment::map_target_range( + self : AlignChainAlignment, + start : Int, + end : Int, +) -> Array[AlignChainRangeMapping] raise AlignChainError { + if start < 0 || end <= start || end > self.target_size { + align_chain_fail("target range must satisfy 0 <= start < end <= size") + } + let mappings : Array[AlignChainRangeMapping] = [] + for index in 0..<(self.coordinates.length() - 1) { + let current = self.coordinates[index] + let next = self.coordinates[index + 1] + let target_low = align_chain_min(current.target, next.target) + let target_high = align_chain_max(current.target, next.target) + if current.target != next.target && current.query != next.query { + let piece_start = align_chain_max(start, target_low) + let piece_end = align_chain_min(end, target_high) + if piece_start < piece_end { + let query_first = match self.map_target_position(piece_start) { + Some(value) => value + None => { + align_chain_fail("internal target range mapping failure") + 0 + } + } + let query_last = match self.map_target_position(piece_end - 1) { + Some(value) => value + None => { + align_chain_fail("internal target range mapping failure") + 0 + } + } + mappings.push( + align_chain_range_mapping( + self, + piece_start, + piece_end, + align_chain_min(query_first, query_last), + align_chain_max(query_first, query_last) + 1, + ), + ) + } + } + } + mappings +} + +///| +/// Map a query interval to all aligned target pieces. +pub fn AlignChainAlignment::map_query_range( + self : AlignChainAlignment, + start : Int, + end : Int, +) -> Array[AlignChainRangeMapping] raise AlignChainError { + if start < 0 || end <= start || end > self.query_size { + align_chain_fail("query range must satisfy 0 <= start < end <= size") + } + let mappings : Array[AlignChainRangeMapping] = [] + for index in 0..<(self.coordinates.length() - 1) { + let current = self.coordinates[index] + let next = self.coordinates[index + 1] + let query_low = align_chain_min(current.query, next.query) + let query_high = align_chain_max(current.query, next.query) + if current.target != next.target && current.query != next.query { + let piece_start = align_chain_max(start, query_low) + let piece_end = align_chain_min(end, query_high) + if piece_start < piece_end { + let target_first = match self.map_query_position(piece_start) { + Some(value) => value + None => { + align_chain_fail("internal query range mapping failure") + 0 + } + } + let target_last = match self.map_query_position(piece_end - 1) { + Some(value) => value + None => { + align_chain_fail("internal query range mapping failure") + 0 + } + } + mappings.push( + align_chain_range_mapping( + self, + align_chain_min(target_first, target_last), + align_chain_max(target_first, target_last) + 1, + piece_start, + piece_end, + ), + ) + } + } + } + mappings +} + +///| +/// Materialize aligned residue pairs, subject to a caller-controlled limit. +pub fn AlignChainAlignment::aligned_pairs( + self : AlignChainAlignment, + limit? : Int = 1000000, +) -> Array[AlignChainPair] raise AlignChainError { + if limit < 0 { + align_chain_fail("aligned-pair limit must be non-negative") + } + let aligned = self.aligned_bases() + if aligned > limit { + align_chain_fail("aligned-pair count exceeds the requested limit") + } + let pairs : Array[AlignChainPair] = [] + for index in 0..<(self.coordinates.length() - 1) { + let current = self.coordinates[index] + let next = self.coordinates[index + 1] + let target_step = next.target - current.target + let query_step = next.query - current.query + if target_step != 0 && query_step != 0 { + let length = align_chain_abs(target_step) + let target_direction = align_chain_sign(target_step) + let query_direction = align_chain_sign(query_step) + for offset in 0.. 0 { + current.target + offset + } else { + current.target - 1 - offset + }, + query: if query_direction > 0 { + current.query + offset + } else { + current.query - 1 - offset + }, + }) + } + } + } + pairs +} + +///| +/// Swap target and query while preserving score, ID, and path orientation. +pub fn AlignChainAlignment::invert( + self : AlignChainAlignment, +) -> AlignChainAlignment raise AlignChainError { + let coordinates : Array[AlignChainCoordinate] = [] + for point in self.coordinates { + coordinates.push(AlignChainCoordinate::{ + target: point.query, + query: point.target, + }) + } + AlignChainAlignment::create( + self.query_id, + self.query_size, + self.target_id, + self.target_size, + coordinates, + score=self.score, + chain_id=self.chain_id, + ) +} + +///| +/// Find the first alignment with the requested chain ID. +pub fn align_chain_find_by_id( + alignments : Array[AlignChainAlignment], + chain_id : String, +) -> AlignChainAlignment? { + for alignment in alignments { + if alignment.chain_id == chain_id { + return Some(alignment) + } + } + None +} + +///| +/// Return alignments whose target span overlaps a half-open interval. +pub fn align_chain_target_overlaps( + alignments : Array[AlignChainAlignment], + target_id : String, + start : Int, + end : Int, +) -> Array[AlignChainAlignment] raise AlignChainError { + if start < 0 || end <= start { + align_chain_fail("overlap query must satisfy 0 <= start < end") + } + let matches : Array[AlignChainAlignment] = [] + for alignment in alignments { + if alignment.target_id == target_id && + alignment.target_start() < end && + alignment.target_end() > start { + matches.push(alignment) + } + } + align_chain_copy_alignments(matches) +} + +///| +/// Return a concise alignment summary. +pub fn AlignChainAlignment::summary(self : AlignChainAlignment) -> String { + let counts = self.counts() + "AlignChainAlignment(target=" + + self.target_id + + ":" + + self.target_start().to_string() + + "-" + + self.target_end().to_string() + + self.target_strand() + + ", query=" + + self.query_id + + ":" + + self.query_start().to_string() + + "-" + + self.query_end().to_string() + + self.query_strand() + + ", aligned=" + + counts.aligned.to_string() + + ", gaps=" + + counts.gap_columns.to_string() + + ")" +} + +///| +/// Return a compact two-record fixture based on Biopython's chain examples. +pub fn align_chain_example_text() -> String { + "chain 176 chr3 198295559 + 42530895 42532606 NR_046654.1 181 - 0 181 1\n" + + "63\t1062\t0\n" + + "75\t468\t0\n" + + "43\n\n" + + "chain 500 chr1 1000 - 100 200 queryA 500 + 20 130 reverse-target\n" + + "40\t10\t20\n" + + "50\n" +} diff --git a/src/align_maf.mbt b/src/align_maf.mbt new file mode 100644 index 00000000..f05cb40d --- /dev/null +++ b/src/align_maf.mbt @@ -0,0 +1,1418 @@ +// Biopython-compatible Bio.Align.maf support. +// +// The legacy maf.mbt API remains available for permissive block analysis. +// This module models modern MAF documents, strict a/s/i/e/q records, +// absolute coordinate paths, and in-memory MafIndex-style interval queries. + +///| +pub suberror AlignMafError { + AlignMafError(String) +} + +///| +pub struct AlignMafTrack { + name : String? + description : String? + frames : String? + maf_dot : String? + visibility : String? + species_order : Array[String] +} derive(Eq, Debug) + +///| +pub struct AlignMafDocument { + version : String + scoring : String? + program : String? + comments : Array[String] + track : AlignMafTrack? + blocks : Array[BigMafBlock] +} derive(Eq, Debug) + +///| +pub struct AlignMafCoordinate { + column : Int + positions : Array[Int] +} derive(Eq, Debug) + +///| +pub struct AlignMafIndexEntry { + block_index : Int + start : Int + end : Int +} derive(Eq, Debug) + +///| +pub struct AlignMafIndex { + reference : String + source_size : Int + reference_strand : String + entries : Array[AlignMafIndexEntry] + blocks : Array[BigMafBlock] +} derive(Eq, Debug) + +///| +pub struct AlignMafSplicedSequence { + source : String + text : String +} derive(Eq, Debug) + +///| +pub struct AlignMafSplicedAlignment { + reference : String + strand : String + starts : Array[Int] + ends : Array[Int] + sequences : Array[AlignMafSplicedSequence] + columns : Int +} derive(Eq, Debug) + +///| +pub struct AlignMafSummary { + block_count : Int + component_count : Int + empty_component_count : Int + aligned_columns : Int + reference_bases : Int + source_count : Int +} derive(Eq, Debug) + +///| +fn align_maf_fail(message : String) -> Unit raise AlignMafError { + raise AlignMafError(message) +} + +///| +fn align_maf_is_space(code : Int) -> Bool { + code == ' '.to_int() || + code == '\t'.to_int() || + code == '\r'.to_int() || + code == '\n'.to_int() +} + +///| +fn align_maf_trim(value : String) -> String { + let mut start = 0 + while start < value.length() && + align_maf_is_space(value.unsafe_get(start).to_int()) { + start = start + 1 + } + let mut end = value.length() + while end > start && align_maf_is_space(value.unsafe_get(end - 1).to_int()) { + end = end - 1 + } + value[start:end].to_owned() +} + +///| +fn align_maf_strip_cr(value : String) -> String { + if value.length() > 0 && + value.unsafe_get(value.length() - 1).to_int() == '\r'.to_int() { + value[0:value.length() - 1].to_owned() + } else { + value + } +} + +///| +fn align_maf_lines(value : String) -> Array[String] { + let raw = value.split("\n").to_array() + let lines : Array[String] = [] + for line in raw { + lines.push(align_maf_strip_cr(line.to_owned())) + } + lines +} + +///| +fn align_maf_words(value : String) -> Array[String] { + let words : Array[String] = [] + let mut index = 0 + while index < value.length() { + while index < value.length() && + align_maf_is_space(value.unsafe_get(index).to_int()) { + index = index + 1 + } + if index >= value.length() { + break + } + let start = index + while index < value.length() && + !align_maf_is_space(value.unsafe_get(index).to_int()) { + index = index + 1 + } + words.push(value[start:index].to_owned()) + } + words +} + +///| +fn align_maf_shell_words(value : String) -> Array[String] raise AlignMafError { + let words : Array[String] = [] + let mut current = "" + let mut quote = 0 + let mut escaped = false + let mut has_value = false + for index in 0.. (String, String) raise AlignMafError { + let mut equal = -1 + for index in 0.. Unit raise AlignMafError { + if value.length() == 0 { + align_maf_fail(label + " must not be empty") + } + for index in 0.. Unit raise AlignMafError { + align_maf_validate_scalar(value, label) + for index in 0.. Int raise AlignMafError { + if value.length() == 0 { + align_maf_fail(label + " must be an unsigned integer") + } + let mut result = 0 + for index in 0.. '9'.to_int() { + align_maf_fail(label + " must be an unsigned integer") + } + let digit = code - '0'.to_int() + if result > (2147483647 - digit) / 10 { + align_maf_fail(label + " exceeds the supported integer range") + } + result = result * 10 + digit + } + result +} + +///| +fn align_maf_is_number(value : String) -> Bool { + if value.length() == 0 { + return false + } + let mut index = 0 + if value.unsafe_get(index).to_int() == '-'.to_int() || + value.unsafe_get(index).to_int() == '+'.to_int() { + index = index + 1 + } + let mut digits = 0 + while index < value.length() { + let code = value.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + break + } + digits = digits + 1 + index = index + 1 + } + if index < value.length() && value.unsafe_get(index).to_int() == '.'.to_int() { + index = index + 1 + while index < value.length() { + let code = value.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + break + } + digits = digits + 1 + index = index + 1 + } + } + if digits == 0 { + return false + } + if index < value.length() && + ( + value.unsafe_get(index).to_int() == 'e'.to_int() || + value.unsafe_get(index).to_int() == 'E'.to_int() + ) { + index = index + 1 + if index < value.length() && + ( + value.unsafe_get(index).to_int() == '-'.to_int() || + value.unsafe_get(index).to_int() == '+'.to_int() + ) { + index = index + 1 + } + let exponent_start = index + while index < value.length() { + let code = value.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + break + } + index = index + 1 + } + if index == exponent_start { + return false + } + } + index == value.length() +} + +///| +fn align_maf_parse_double( + value : String, + label : String, +) -> Double raise AlignMafError { + if !align_maf_is_number(value) { + align_maf_fail(label + " must be a number") + } + let parsed_value = if value.unsafe_get(0).to_int() == '+'.to_int() { + value[1:value.length()].to_owned() + } else { + value + } + let number = match parse_double(parsed_value) { + Some(number) => number + None => { + align_maf_fail(label + " must be a number") + 0.0 + } + } + if number.is_nan() || number.abs() > 1.0e300 { + align_maf_fail(label + " must be finite") + } + number +} + +///| +fn align_maf_copy_strings(values : Array[String]) -> Array[String] { + let copied : Array[String] = [] + for value in values { + copied.push(value) + } + copied +} + +///| +fn align_maf_copy_blocks(values : Array[BigMafBlock]) -> Array[BigMafBlock] { + let copied : Array[BigMafBlock] = [] + for value in values { + copied.push(value) + } + copied +} + +///| +fn align_maf_copy_ints(values : Array[Int]) -> Array[Int] { + let copied : Array[Int] = [] + for value in values { + copied.push(value) + } + copied +} + +///| +pub fn AlignMafTrack::create( + name? : String? = None, + description? : String? = None, + frames? : String? = None, + maf_dot? : String? = None, + visibility? : String? = None, + species_order? : Array[String] = [], +) -> AlignMafTrack raise AlignMafError { + match name { + Some(value) => align_maf_validate_scalar(value, "MAF track name") + None => () + } + match description { + Some(value) => align_maf_validate_scalar(value, "MAF track description") + None => () + } + match frames { + Some(value) => align_maf_validate_scalar(value, "MAF track frames") + None => () + } + match maf_dot { + Some(value) => + if value != "on" && value != "off" { + align_maf_fail("MAF track mafDot must be 'on' or 'off'") + } + None => () + } + match visibility { + Some(value) => + if value != "dense" && value != "pack" && value != "full" { + align_maf_fail( + "MAF track visibility must be 'dense', 'pack', or 'full'", + ) + } + None => () + } + for source in species_order { + align_maf_validate_token(source, "MAF track species") + } + AlignMafTrack::{ + name, + description, + frames, + maf_dot, + visibility, + species_order: align_maf_copy_strings(species_order), + } +} + +///| +pub fn AlignMafDocument::create( + blocks : Array[BigMafBlock], + version? : String = "1", + scoring? : String? = None, + program? : String? = None, + comments? : Array[String] = [], + track? : AlignMafTrack? = None, +) -> AlignMafDocument raise AlignMafError { + if version != "1" { + align_maf_fail("MAF version must be 1") + } + match scoring { + Some(value) => align_maf_validate_token(value, "MAF scoring metadata") + None => () + } + match program { + Some(value) => align_maf_validate_token(value, "MAF program metadata") + None => () + } + for comment in comments { + align_maf_validate_scalar(comment, "MAF comment") + } + AlignMafDocument::{ + version, + scoring, + program, + comments: align_maf_copy_strings(comments), + track, + blocks: align_maf_copy_blocks(blocks), + } +} + +///| +fn align_maf_parse_track(line : String) -> AlignMafTrack raise AlignMafError { + let words = align_maf_shell_words(line) + if words.length() < 2 || words[0] != "track" { + align_maf_fail("Malformed MAF track line") + } + let mut name : String? = None + let mut description : String? = None + let mut frames : String? = None + let mut maf_dot : String? = None + let mut visibility : String? = None + let species_order : Array[String] = [] + for index in 1.. 0 { + align_maf_fail("Duplicate MAF track speciesOrder") + } + for source in align_maf_words(value) { + species_order.push(source) + } + if species_order.length() == 0 { + align_maf_fail("MAF track speciesOrder must not be empty") + } + } else { + align_maf_fail("Unexpected MAF track variable '" + key + "'") + } + } + AlignMafTrack::create( + name~, + description~, + frames~, + maf_dot~, + visibility~, + species_order~, + ) +} + +///| +fn align_maf_normalize_text(value : String) -> String { + let output = StringBuilder::new(size_hint=value.length()) + for index in 0.. BigMafBlock raise AlignMafError { + if lines.length() == 0 { + align_maf_fail("MAF alignment block must not be empty") + } + let header = align_maf_words(align_maf_trim(lines[0])) + if header.length() == 0 || header[0] != "a" { + align_maf_fail("MAF alignment block must start with an 'a' line") + } + let mut score : Double? = None + let mut pass_number : Int? = None + for index in 1.. source_size || + component_size > source_size - component_start { + align_maf_fail("MAF component coordinates exceed the source sequence") + } + let component = BigMafComponent::create( + words[1], + component_start, + component_size, + words[4], + source_size, + align_maf_normalize_text(words[6]), + ) catch { + BigMafError(message) => { + align_maf_fail(message) + abort("") + } + } + components.push(component) + last_component = components.length() - 1 + } else if words[0] == "i" { + if last_component < 0 || words.length() != 6 { + align_maf_fail( + "MAF insertion lines must follow an s line and have six fields", + ) + } + if words[1] != components[last_component].source { + align_maf_fail( + "MAF insertion source does not match the preceding s line", + ) + } + if components[last_component].insertion is Some(_) { + align_maf_fail("Duplicate MAF insertion line for one component") + } + let left_count = align_maf_parse_uint( + words[3], + "MAF left insertion count", + ) + let right_count = align_maf_parse_uint( + words[5], + "MAF right insertion count", + ) + let insertion = BigMafInsertion::create( + words[2], + left_count, + words[4], + right_count, + ) catch { + BigMafError(message) => { + align_maf_fail(message) + abort("") + } + } + components[last_component] = components[last_component].with_insertion( + insertion, + ) catch { + BigMafError(message) => { + align_maf_fail(message) + abort("") + } + } + } else if words[0] == "q" { + if last_component < 0 || words.length() != 3 { + align_maf_fail( + "MAF quality lines must follow an s line and have three fields", + ) + } + if words[1] != components[last_component].source { + align_maf_fail("MAF quality source does not match the preceding s line") + } + if components[last_component].quality is Some(_) { + align_maf_fail("Duplicate MAF quality line for one component") + } + components[last_component] = components[last_component].with_quality( + words[2], + ) catch { + BigMafError(message) => { + align_maf_fail(message) + abort("") + } + } + } else if words[0] == "e" { + if words.length() != 7 { + align_maf_fail("MAF empty component lines must contain seven fields") + } + let empty_start = align_maf_parse_uint( + words[2], + "MAF empty component start", + ) + let empty_size = align_maf_parse_uint( + words[3], + "MAF empty component size", + ) + let empty_source_size = align_maf_parse_uint( + words[5], + "MAF empty source size", + ) + if empty_source_size <= 0 || + empty_start > empty_source_size || + empty_size > empty_source_size - empty_start { + align_maf_fail( + "MAF empty component coordinates exceed the source sequence", + ) + } + let empty = BigMafEmptyComponent::create( + words[1], + empty_start, + empty_size, + words[4], + empty_source_size, + words[6], + ) catch { + BigMafError(message) => { + align_maf_fail(message) + abort("") + } + } + empty_components.push(empty) + last_component = -1 + } else { + align_maf_fail("Unexpected MAF line type '" + words[0] + "'") + } + } + BigMafBlock::create(components, score~, pass_number~, empty_components~) catch { + BigMafError(message) => { + align_maf_fail(message) + abort("") + } + } +} + +///| +pub fn align_maf_parse(text : String) -> AlignMafDocument raise AlignMafError { + let lines = align_maf_lines(text) + let mut index = 0 + while index < lines.length() && align_maf_trim(lines[index]).length() == 0 { + index = index + 1 + } + if index >= lines.length() { + align_maf_fail("MAF input is empty") + } + let mut track : AlignMafTrack? = None + let first = align_maf_trim(lines[index]) + if first == "track" || first.has_prefix("track ") { + track = Some(align_maf_parse_track(first)) + index = index + 1 + } + while index < lines.length() && align_maf_trim(lines[index]).length() == 0 { + index = index + 1 + } + if index >= lines.length() { + align_maf_fail("MAF input is missing its header") + } + let header = align_maf_words(align_maf_trim(lines[index])) + if header.length() == 0 || header[0] != "##maf" { + align_maf_fail("MAF header line must start with ##maf") + } + let mut version : String? = None + let mut scoring : String? = None + let mut program : String? = None + for field_index in 1.. value + None => { + align_maf_fail("MAF header must declare version=1") + "" + } + } + if found_version != "1" { + align_maf_fail("MAF version must be 1") + } + index = index + 1 + let comments : Array[String] = [] + let blocks : Array[BigMafBlock] = [] + let mut current : Array[String] = [] + let mut saw_block = false + while index < lines.length() { + let line = align_maf_trim(lines[index]) + if line.length() == 0 { + index = index + 1 + continue + } + if line.unsafe_get(0).to_int() == '#'.to_int() && + current.length() == 0 && + !saw_block { + comments.push(align_maf_trim(line[1:line.length()].to_owned())) + } else if line == "a" || line.has_prefix("a ") || line.has_prefix("a\t") { + if current.length() > 0 { + blocks.push(align_maf_parse_block(current)) + } + current = [line] + saw_block = true + } else { + if current.length() == 0 { + align_maf_fail("MAF data line appears before an alignment line") + } + current.push(line) + } + index = index + 1 + } + if current.length() > 0 { + blocks.push(align_maf_parse_block(current)) + } + AlignMafDocument::create( + blocks, + version=found_version, + scoring~, + program~, + comments~, + track~, + ) +} + +///| +fn align_maf_quote_track(value : String) -> String { + let mut needs_quotes = false + let output = StringBuilder::new(size_hint=value.length()) + for index in 0.. Unit { + output.write_string("track") + match track.name { + Some(value) => output.write_string(" name=" + align_maf_quote_track(value)) + None => () + } + match track.description { + Some(value) => + output.write_string(" description=" + align_maf_quote_track(value)) + None => () + } + match track.frames { + Some(value) => + output.write_string(" frames=" + align_maf_quote_track(value)) + None => () + } + match track.maf_dot { + Some(value) => output.write_string(" mafDot=" + value) + None => () + } + match track.visibility { + Some(value) => output.write_string(" visibility=" + value) + None => () + } + if track.species_order.length() > 0 { + let species = StringBuilder::new() + for index in 0.. 0 { + species.write_char(' ') + } + species.write_string(track.species_order[index]) + } + output.write_string( + " speciesOrder=" + align_maf_quote_track(species.to_string()), + ) + } + output.write_char('\n') +} + +///| +pub fn align_maf_write( + document : AlignMafDocument, +) -> String raise AlignMafError { + let validated = AlignMafDocument::create( + document.blocks, + version=document.version, + scoring=document.scoring, + program=document.program, + comments=document.comments, + track=document.track, + ) + let output = StringBuilder::new() + match validated.track { + Some(track) => align_maf_write_track(output, track) + None => () + } + output.write_string("##maf version=1") + match validated.scoring { + Some(value) => output.write_string(" scoring=" + value) + None => () + } + match validated.program { + Some(value) => output.write_string(" program=" + value) + None => () + } + output.write_char('\n') + for comment in validated.comments { + output.write_string("# " + comment + "\n") + } + output.write_char('\n') + for block in validated.blocks { + output.write_string(block.to_maf()) + } + output.to_string() +} + +///| +fn align_maf_pattern_equal(left : Array[Bool], right : Array[Bool]) -> Bool { + if left.length() != right.length() { + return false + } + for index in 0.. Array[Bool] { + let pattern : Array[Bool] = [] + for component in block.components { + pattern.push(component.text.unsafe_get(column).to_int() != '-'.to_int()) + } + pattern +} + +///| +fn align_maf_copy_positions(positions : Array[Int]) -> Array[Int] { + let copied : Array[Int] = [] + for position in positions { + copied.push(position) + } + copied +} + +///| +pub fn align_maf_coordinate_path( + block : BigMafBlock, +) -> Array[AlignMafCoordinate] { + let width = block.aligned_columns() + let positions : Array[Int] = [] + for component in block.components { + positions.push( + if component.strand == "+" { + component.start + } else { + component.source_size - component.start + }, + ) + } + let path : Array[AlignMafCoordinate] = [ + AlignMafCoordinate::{ + column: 0, + positions: align_maf_copy_positions(positions), + }, + ] + if width == 0 { + return path + } + let mut previous = align_maf_column_pattern(block, 0) + for column in 0.. 0 && !align_maf_pattern_equal(previous, pattern) { + path.push(AlignMafCoordinate::{ + column, + positions: align_maf_copy_positions(positions), + }) + } + for row in 0.. Int? raise AlignMafError { + let from = match block.component(from_source) { + Some(component) => component + None => return None + } + let to = match block.component(to_source) { + Some(component) => component + None => return None + } + match from.source_to_column(position) { + Some(column) => + to.column_to_source(column) catch { + BigMafError(message) => { + align_maf_fail(message) + None + } + } + None => None + } +} + +///| +pub fn AlignMafDocument::sources(self : AlignMafDocument) -> Array[String] { + let sources : Array[String] = [] + for block in self.blocks { + for component in block.components { + if !sources.contains(component.source) { + sources.push(component.source) + } + } + for empty in block.empty_components { + if !sources.contains(empty.source) { + sources.push(empty.source) + } + } + } + sources +} + +///| +pub fn AlignMafDocument::summary(self : AlignMafDocument) -> AlignMafSummary { + let mut component_count = 0 + let mut empty_component_count = 0 + let mut aligned_columns = 0 + let mut reference_bases = 0 + for block in self.blocks { + component_count = component_count + block.components.length() + empty_component_count = empty_component_count + + block.empty_components.length() + aligned_columns = aligned_columns + block.aligned_columns() + if block.components.length() > 0 { + reference_bases = reference_bases + block.components[0].size + } + } + AlignMafSummary::{ + block_count: self.blocks.length(), + component_count, + empty_component_count, + aligned_columns, + reference_bases, + source_count: self.sources().length(), + } +} + +///| +fn align_maf_entry_sort(entries : Array[AlignMafIndexEntry]) -> Unit { + for index in 1.. 0 && + ( + entries[position - 1].start > value.start || + ( + entries[position - 1].start == value.start && + entries[position - 1].end > value.end + ) + ) { + entries[position] = entries[position - 1] + position = position - 1 + } + entries[position] = value + } +} + +///| +pub fn AlignMafIndex::create( + document : AlignMafDocument, + reference : String, +) -> AlignMafIndex raise AlignMafError { + align_maf_validate_token(reference, "MAF index reference") + if document.blocks.length() == 0 { + align_maf_fail("MAF index requires at least one alignment block") + } + let entries : Array[AlignMafIndexEntry] = [] + let mut source_size = -1 + let mut reference_strand = "" + for block_index in 0.. value + None => { + align_maf_fail("MAF index reference is missing from an alignment block") + block.components[0] + } + } + if source_size < 0 { + source_size = component.source_size + reference_strand = component.strand + } else { + if component.source_size != source_size { + align_maf_fail("MAF index reference source sizes are inconsistent") + } + if component.strand != reference_strand { + align_maf_fail("MAF index reference strands are inconsistent") + } + } + let (start, end) = component.forward_interval() + entries.push(AlignMafIndexEntry::{ block_index, start, end }) + } + align_maf_entry_sort(entries) + AlignMafIndex::{ + reference, + source_size, + reference_strand, + entries, + blocks: align_maf_copy_blocks(document.blocks), + } +} + +///| +fn align_maf_validate_range( + start : Int, + end : Int, + source_size : Int, +) -> Unit raise AlignMafError { + if start < 0 || end <= start || end > source_size { + align_maf_fail( + "MAF query interval must satisfy 0 <= start < end <= source size", + ) + } +} + +///| +pub fn AlignMafIndex::search( + self : AlignMafIndex, + start : Int, + end : Int, +) -> Array[BigMafBlock] raise AlignMafError { + align_maf_validate_range(start, end, self.source_size) + let blocks : Array[BigMafBlock] = [] + for entry in self.entries { + if entry.start < end && entry.end > start { + blocks.push(self.blocks[entry.block_index]) + } + } + blocks +} + +///| +pub fn AlignMafIndex::search_ranges( + self : AlignMafIndex, + starts : Array[Int], + ends : Array[Int], +) -> Array[BigMafBlock] raise AlignMafError { + if starts.length() == 0 || starts.length() != ends.length() { + align_maf_fail("MAF range arrays must be non-empty and have equal lengths") + } + let selected = Array::make(self.blocks.length(), false) + for index in 0.. starts[index] { + selected[entry.block_index] = true + } + } + } + let blocks : Array[BigMafBlock] = [] + for index in 0.. Int { + self.entries.length() +} + +///| +fn align_maf_repeat(value : String, count : Int) -> String { + let output = StringBuilder::new(size_hint=count) + for _ in 0.. Array[String] { + let sources : Array[String] = [index.reference] + for block in index.blocks { + for component in block.components { + if component.source != index.reference && + !sources.contains(component.source) { + sources.push(component.source) + } + } + } + sources +} + +///| +fn align_maf_append_missing(texts : Array[String], count : Int) -> Unit { + if count <= 0 { + return + } + texts[0] = texts[0] + align_maf_repeat("N", count) + for index in 1.. AlignMafSplicedAlignment raise AlignMafError { + if starts.length() == 0 || starts.length() != ends.length() { + align_maf_fail("MAF exon arrays must be non-empty and have equal lengths") + } + if strand != "+" && strand != "-" { + align_maf_fail("MAF spliced strand must be '+' or '-'") + } + if self.reference_strand != "+" { + align_maf_fail( + "MAF splicing currently requires a plus-strand reference component", + ) + } + for index in 0.. 0 && starts[index] < ends[index - 1] { + align_maf_fail("MAF exon intervals must be sorted and non-overlapping") + } + } + let sources = align_maf_splice_sources(self) + let texts = Array::make(sources.length(), "") + for exon_index in 0..= exon_end { + continue + } + let overlap_start = if entry.start > exon_start { + entry.start + } else { + exon_start + } + let overlap_end = if entry.end < exon_end { entry.end } else { exon_end } + if overlap_start < current { + align_maf_fail( + "Overlapping MAF reference blocks make splicing ambiguous", + ) + } + align_maf_append_missing(texts, overlap_start - current) + let block = self.blocks[entry.block_index] + let reference = match block.component(self.reference) { + Some(component) => component + None => { + align_maf_fail("Indexed MAF block lost its reference component") + block.components[0] + } + } + let first_column = match reference.source_to_column(overlap_start) { + Some(column) => column + None => { + align_maf_fail("MAF reference interval does not map to a column") + 0 + } + } + let last_column = match reference.source_to_column(overlap_end - 1) { + Some(column) => column + None => { + align_maf_fail("MAF reference interval does not map to a column") + 0 + } + } + let column_start = if first_column < last_column { + first_column + } else { + last_column + } + let column_end = if first_column > last_column { + first_column + 1 + } else { + last_column + 1 + } + let width = column_end - column_start + for source_index in 0.. + texts[source_index] = texts[source_index] + + component.text[column_start:column_end].to_owned() + None => + texts[source_index] = texts[source_index] + + align_maf_repeat("-", width) + } + } + current = overlap_end + } + align_maf_append_missing(texts, exon_end - current) + } + if strand == "-" { + for index in 0.. String? { + for sequence in self.sequences { + if sequence.source == source { + return Some(sequence.text) + } + } + None +} + +///| +pub fn AlignMafSplicedAlignment::ungapped_length( + self : AlignMafSplicedAlignment, + source : String, +) -> Int? { + match self.sequence(source) { + Some(text) => { + let mut count = 0 + for index in 0.. None + } +} + +///| +pub fn align_maf_example_text() -> String { + "track name=\"Multiz demo\" description=\"MAF coordinate example\" " + + "mafDot=on visibility=pack speciesOrder=\"hg38 mm39 rn7\"\n" + + "##maf version=1 scoring=blastz program=multiz\n" + + "# generated fixture\n\n" + + "a score=23262.0 pass=1\n" + + "s hg38.chr7 100 8 + 1000 AC-TGCAAT\n" + + "i hg38.chr7 C 0 I 2\n" + + "q hg38.chr7 98-765432\n" + + "s mm39.chr5 50 8 - 500 ACCTG-AAT\n" + + "e rn7.chr1 80 6 + 700 I\n\n" + + "a score=125.5\n" + + "s hg38.chr7 110 4 + 1000 GGTT\n" + + "s mm39.chr5 70 3 - 500 G-TT\n\n" + + "a score=80\n" + + "s hg38.chr7 120 4 + 1000 AAAA\n" + + "s rn7.chr1 90 4 + 700 AATA\n" +} diff --git a/src/align_nexus.mbt b/src/align_nexus.mbt new file mode 100644 index 00000000..631f335b --- /dev/null +++ b/src/align_nexus.mbt @@ -0,0 +1,2111 @@ +// Biopython-compatible Bio.Align.nexus support. +// +// This module is intentionally separate from nexus.mbt. The older module +// exposes Bio.Nexus-style block access, while this file models one modern, +// coordinate-aware alignment matrix. + +///| +/// Error raised for malformed NEXUS alignment data or invalid operations. +pub suberror AlignNexusError { + AlignNexusError(String) +} + +///| +/// Sequence datatype declared by a NEXUS FORMAT command. +pub(all) enum AlignNexusDataType { + AlignNexusDna + AlignNexusRna + AlignNexusProtein + AlignNexusStandard +} derive(Eq, Debug) + +///| +/// File-level metadata retained from a DATA or CHARACTERS block. +/// +/// `declared_characters` is the NCHAR value in the source file. +/// `removed_all_gap_columns` records columns omitted from the alignment, +/// matching Biopython's `Bio.Align.nexus` behavior. +pub struct AlignNexusMetadata { + block_name : String + declared_taxa : Int + declared_characters : Int + data_type : AlignNexusDataType + missing_character : String + gap_character : String + match_character : String? + interleaved : Bool + respect_case : Bool + symbols : String + removed_all_gap_columns : Int +} derive(Eq, Debug) + +///| +/// One NEXUS matrix row. +/// +/// `aligned_sequence` always uses `-` for gaps. `sequence` is the same row +/// with gaps removed; missing-data symbols remain coordinate-bearing. +pub struct AlignNexusSequence { + id : String + sequence : String + aligned_sequence : String +} derive(Eq, Debug) + +///| +/// A coordinate-aware NEXUS multiple sequence alignment. +pub struct AlignNexusAlignment { + metadata : AlignNexusMetadata + sequences : Array[AlignNexusSequence] +} derive(Eq, Debug) + +///| +/// Pairwise or all-pairs alignment statistics. +pub struct AlignNexusCounts { + pairs : Int + aligned : Int + identities : Int + mismatches : Int + gap_columns : Int + double_gap_columns : Int + gap_opens : Int +} derive(Eq, Debug) + +///| +/// Internal FORMAT state used while parsing commands. +priv struct AlignNexusFormat { + data_type : AlignNexusDataType + missing_character : String + gap_character : String + match_character : String? + interleaved : Bool + respect_case : Bool + symbols : String + labels : Bool +} + +///| +/// Construct validated NEXUS alignment metadata. +pub fn AlignNexusMetadata::create( + declared_taxa : Int, + declared_characters : Int, + data_type : AlignNexusDataType, + block_name? : String = "data", + missing_character? : String = "?", + gap_character? : String = "-", + match_character? : String? = None, + interleaved? : Bool = false, + respect_case? : Bool = false, + symbols? : String = "", + removed_all_gap_columns? : Int = 0, +) -> AlignNexusMetadata raise AlignNexusError { + if declared_taxa <= 0 { + raise AlignNexusError("NEXUS NTAX must be positive") + } + if declared_characters <= 0 { + raise AlignNexusError("NEXUS NCHAR must be positive") + } + let normalized_block = block_name.to_lower().trim().to_owned() + if normalized_block != "data" && normalized_block != "characters" { + raise AlignNexusError("NEXUS alignment block must be DATA or CHARACTERS") + } + align_nexus_validate_format_char( + missing_character, "NEXUS missing-data character", + ) + align_nexus_validate_format_char(gap_character, "NEXUS gap character") + if missing_character == gap_character { + raise AlignNexusError( + "NEXUS missing-data and gap characters must be different", + ) + } + match match_character { + Some(value) => { + align_nexus_validate_format_char(value, "NEXUS match character") + if value == missing_character || value == gap_character { + raise AlignNexusError( + "NEXUS match character must differ from missing and gap characters", + ) + } + } + None => () + } + align_nexus_validate_symbols(data_type, symbols, respect_case) + if removed_all_gap_columns < 0 || + removed_all_gap_columns >= declared_characters { + raise AlignNexusError("NEXUS removed all-gap column count is outside NCHAR") + } + AlignNexusMetadata::{ + block_name: normalized_block, + declared_taxa, + declared_characters, + data_type, + missing_character, + gap_character, + match_character, + interleaved, + respect_case, + symbols, + removed_all_gap_columns, + } +} + +///| +/// Construct and normalize one standalone NEXUS row. +pub fn AlignNexusSequence::create( + id : String, + aligned_sequence : String, + data_type : AlignNexusDataType, + missing_character? : String = "?", + gap_character? : String = "-", + symbols? : String = "", + respect_case? : Bool = false, +) -> AlignNexusSequence raise AlignNexusError { + align_nexus_validate_id(id) + if aligned_sequence.length() == 0 { + raise AlignNexusError("NEXUS aligned sequence must not be empty") + } + align_nexus_validate_format_char( + missing_character, "NEXUS missing-data character", + ) + align_nexus_validate_format_char(gap_character, "NEXUS gap character") + if missing_character == gap_character { + raise AlignNexusError( + "NEXUS missing-data and gap characters must be different", + ) + } + align_nexus_validate_symbols(data_type, symbols, respect_case) + let normalized = align_nexus_normalize_row( + aligned_sequence, data_type, missing_character, gap_character, symbols, respect_case, + ) + AlignNexusSequence::{ + id, + sequence: align_nexus_remove_gaps(normalized), + aligned_sequence: normalized, + } +} + +///| +/// Construct a validated coordinate-aware NEXUS alignment. +pub fn AlignNexusAlignment::create( + metadata : AlignNexusMetadata, + sequences : Array[AlignNexusSequence], +) -> AlignNexusAlignment raise AlignNexusError { + let copied : Array[AlignNexusSequence] = [] + for sequence in sequences { + copied.push(sequence) + } + let alignment = AlignNexusAlignment::{ metadata, sequences: copied } + align_nexus_validate_alignment(alignment) + alignment +} + +///| +/// Construct an alignment directly from identifiers and printed rows. +/// +/// Source gap symbols are normalized to `-`, and columns containing only gaps +/// are removed exactly as they are when parsing a NEXUS file. +pub fn align_nexus_from_aligned( + ids : Array[String], + aligned_sequences : Array[String], + data_type : AlignNexusDataType, + missing_character? : String = "?", + gap_character? : String = "-", + symbols? : String = "", + respect_case? : Bool = false, +) -> AlignNexusAlignment raise AlignNexusError { + if ids.length() == 0 { + raise AlignNexusError("NEXUS alignment must contain at least one sequence") + } + if ids.length() != aligned_sequences.length() { + raise AlignNexusError( + "NEXUS identifiers and aligned rows must have equal lengths", + ) + } + let width = aligned_sequences[0].length() + if width == 0 { + raise AlignNexusError("NEXUS alignment must contain at least one column") + } + for row in aligned_sequences { + if row.length() != width { + raise AlignNexusError("NEXUS aligned rows must have equal widths") + } + } + let normalized : Array[String] = [] + for row in aligned_sequences { + normalized.push( + align_nexus_normalize_row( + row, data_type, missing_character, gap_character, symbols, respect_case, + ), + ) + } + let prepared = align_nexus_remove_all_gap_columns(normalized) + if prepared.0.length() == 0 || prepared.0[0].length() == 0 { + raise AlignNexusError( + "NEXUS alignment must contain a non-gap alignment column", + ) + } + let metadata = AlignNexusMetadata::create( + ids.length(), + width, + data_type, + missing_character~, + gap_character~, + respect_case~, + symbols~, + removed_all_gap_columns=prepared.1, + ) + let sequences : Array[AlignNexusSequence] = [] + for index = 0; index < ids.length(); index = index + 1 { + align_nexus_validate_id(ids[index]) + sequences.push(AlignNexusSequence::{ + id: ids[index], + sequence: align_nexus_remove_gaps(prepared.0[index]), + aligned_sequence: prepared.0[index], + }) + } + AlignNexusAlignment::create(metadata, sequences) +} + +///| +/// Parse one Biopython-compatible NEXUS alignment. +/// +/// The parser recognizes DATA and CHARACTERS matrices, TAXA/TAXLABELS, +/// sequential and interleaved layouts, nested comments, quoted identifiers, +/// doubled quote escaping, custom missing/gap/match symbols, and the DNA, RNA, +/// protein, nucleotide, and standard datatypes. +pub fn align_nexus_parse( + text : String, +) -> AlignNexusAlignment raise AlignNexusError { + let lines = align_nexus_normalize_lines(text) + if lines.length() == 0 || + (lines.length() == 1 && lines[0].trim().length() == 0) { + raise AlignNexusError("Empty NEXUS file") + } + if lines[0].trim() != "#NEXUS" { + raise AlignNexusError("File does not start with NEXUS header") + } + let body_builder = StringBuilder::new() + for index = 1; index < lines.length(); index = index + 1 { + if index > 1 { + body_builder.write_char('\n') + } + body_builder.write_string(lines[index]) + } + let commands = align_nexus_scan_commands(body_builder.to_string()) + let mut active_block = "" + let mut tax_ntax = -1 + let mut data_ntax = -1 + let mut data_nchar = -1 + let taxlabels : Array[String] = [] + let mut block_name = "" + let mut matrix_body : String? = None + let mut format = AlignNexusFormat::{ + data_type: AlignNexusDna, + missing_character: "?", + gap_character: "-", + match_character: None, + interleaved: false, + respect_case: false, + symbols: "", + labels: true, + } + for command in commands { + let split = align_nexus_split_keyword(command) + let keyword = split.0 + let options = split.1 + if keyword == "begin" { + if active_block.length() != 0 { + raise AlignNexusError("NEXUS blocks must not be nested") + } + let words = align_nexus_tokenize(options) + if words.length() != 1 { + raise AlignNexusError("Malformed NEXUS BEGIN command") + } + active_block = words[0].to_lower() + continue + } + if keyword == "end" || keyword == "endblock" { + if active_block.length() == 0 { + raise AlignNexusError("Unmatched NEXUS END command") + } + active_block = "" + continue + } + if active_block.length() == 0 { + raise AlignNexusError( + "NEXUS command '" + keyword + "' appears outside a block", + ) + } + if active_block == "taxa" { + if keyword == "dimensions" { + let dimensions = align_nexus_parse_dimensions(options) + if dimensions.0 >= 0 { + tax_ntax = dimensions.0 + } + if dimensions.1 >= 0 { + raise AlignNexusError("NCHAR is not valid in a TAXA block") + } + } else if keyword == "taxlabels" { + let parsed_labels = align_nexus_parse_taxlabels(options) + taxlabels.clear() + for label in parsed_labels { + taxlabels.push(label) + } + } else if keyword != "title" && keyword != "link" { + raise AlignNexusError( + "Unsupported command '" + keyword + "' in NEXUS TAXA block", + ) + } + continue + } + if active_block == "data" || active_block == "characters" { + if keyword == "dimensions" { + let dimensions = align_nexus_parse_dimensions(options) + if dimensions.0 >= 0 { + data_ntax = dimensions.0 + } + if dimensions.1 >= 0 { + data_nchar = dimensions.1 + } + } else if keyword == "format" { + format = align_nexus_parse_format(options, format) + } else if keyword == "taxlabels" { + let parsed_labels = align_nexus_parse_taxlabels(options) + taxlabels.clear() + for label in parsed_labels { + taxlabels.push(label) + } + } else if keyword == "matrix" { + match matrix_body { + Some(_) => + raise AlignNexusError( + "A NEXUS file may contain only one alignment matrix", + ) + None => { + matrix_body = Some(options) + block_name = active_block + } + } + } else if keyword != "title" && + keyword != "link" && + keyword != "options" && + keyword != "charlabels" && + keyword != "charstatelabels" && + keyword != "statelabels" && + keyword != "eliminate" { + raise AlignNexusError( + "Unsupported command '" + + keyword + + "' in NEXUS " + + active_block.to_upper() + + " block", + ) + } + continue + } + // Alignment parsing deliberately ignores unrelated SETS, TREES, CODONS, + // and vendor-specific blocks after their command boundaries are scanned. + } + if active_block.length() != 0 { + raise AlignNexusError("NEXUS block is missing its END command") + } + let body = match matrix_body { + Some(value) => value + None => + raise AlignNexusError("NEXUS file does not contain an alignment matrix") + } + let ntax = if data_ntax >= 0 { data_ntax } else { tax_ntax } + if ntax <= 0 { + raise AlignNexusError("NEXUS NTAX must be specified before MATRIX") + } + if data_nchar <= 0 { + raise AlignNexusError("NEXUS NCHAR must be specified before MATRIX") + } + if tax_ntax >= 0 && data_ntax >= 0 && tax_ntax != data_ntax { + raise AlignNexusError("NEXUS TAXA and alignment NTAX values disagree") + } + if taxlabels.length() != 0 && taxlabels.length() != ntax { + raise AlignNexusError("NEXUS TAXLABELS count does not match NTAX") + } + align_nexus_validate_format(format) + let parsed = align_nexus_parse_matrix( + body, ntax, data_nchar, format, taxlabels, + ) + let resolved = align_nexus_resolve_and_normalize_rows(parsed.1, format) + let prepared = align_nexus_remove_all_gap_columns(resolved) + if prepared.0.length() == 0 || prepared.0[0].length() == 0 { + raise AlignNexusError("NEXUS matrix contains no non-gap alignment column") + } + let metadata = AlignNexusMetadata::create( + ntax, + data_nchar, + format.data_type, + block_name~, + missing_character=format.missing_character, + gap_character=format.gap_character, + match_character=format.match_character, + interleaved=format.interleaved, + respect_case=format.respect_case, + symbols=format.symbols, + removed_all_gap_columns=prepared.1, + ) + let sequences : Array[AlignNexusSequence] = [] + for index = 0; index < ntax; index = index + 1 { + sequences.push(AlignNexusSequence::{ + id: parsed.0[index], + sequence: align_nexus_remove_gaps(prepared.0[index]), + aligned_sequence: prepared.0[index], + }) + } + AlignNexusAlignment::create(metadata, sequences) +} + +///| +/// Write one canonical NEXUS DATA alignment. +/// +/// When `interleave` is omitted, alignments wider than 1000 columns are +/// interleaved, matching Biopython 1.86. Interleaved blocks default to 70 +/// columns. +pub fn align_nexus_write( + alignment : AlignNexusAlignment, + interleave? : Bool? = None, + block_width? : Int = 70, +) -> String raise AlignNexusError { + align_nexus_validate_alignment(alignment) + let width = alignment.alignment_length() + if width == 0 { + raise AlignNexusError("Non-empty NEXUS sequences are required") + } + if block_width <= 0 { + raise AlignNexusError("NEXUS writer block width must be positive") + } + let use_interleave = match interleave { + Some(value) => value + None => width > 1000 + } + let names : Array[String] = [] + let mut name_width = 0 + for sequence in alignment.sequences { + let safe = align_nexus_safe_name(sequence.id) + names.push(safe) + if safe.length() > name_width { + name_width = safe.length() + } + } + let output = StringBuilder::new() + output.write_string("#NEXUS\n") + output.write_string("begin data;\n") + output.write_string( + "dimensions ntax=" + + alignment.num_sequences().to_string() + + " nchar=" + + width.to_string() + + ";\n", + ) + output.write_string( + "format datatype=" + + alignment.metadata.data_type.code() + + " missing=" + + alignment.metadata.missing_character + + " gap=" + + alignment.metadata.gap_character, + ) + if alignment.metadata.data_type == AlignNexusStandard { + output.write_string( + " symbols=\"" + + align_nexus_escape_double_quotes(alignment.metadata.symbols) + + "\"", + ) + } + if alignment.metadata.respect_case { + output.write_string(" respectcase") + } + if use_interleave { + output.write_string(" interleave") + } + output.write_string(";\n") + output.write_string("matrix\n") + if use_interleave { + let mut start = 0 + while start < width { + let end = align_nexus_min(start + block_width, width) + for row = 0; row < alignment.sequences.length(); row = row + 1 { + output.write_string(align_nexus_pad_right(names[row], name_width + 1)) + output.write_string( + align_nexus_output_fragment( + alignment.sequences[row].aligned_sequence, + start, + end, + alignment.metadata.gap_character, + ), + ) + output.write_char('\n') + } + output.write_char('\n') + start = end + } + } else { + for row = 0; row < alignment.sequences.length(); row = row + 1 { + output.write_string(align_nexus_pad_right(names[row], name_width + 1)) + output.write_string( + align_nexus_output_fragment( + alignment.sequences[row].aligned_sequence, + 0, + width, + alignment.metadata.gap_character, + ), + ) + output.write_char('\n') + } + } + output.write_string(";\n") + output.write_string("end;\n") + output.to_string() +} + +///| +/// Return the canonical lowercase FORMAT datatype name. +pub fn AlignNexusDataType::code(self : AlignNexusDataType) -> String { + match self { + AlignNexusDna => "dna" + AlignNexusRna => "rna" + AlignNexusProtein => "protein" + AlignNexusStandard => "standard" + } +} + +///| +/// Return the Biopython-style molecule type annotation. +pub fn AlignNexusDataType::molecule_type(self : AlignNexusDataType) -> String { + match self { + AlignNexusDna => "DNA" + AlignNexusRna => "RNA" + AlignNexusProtein => "protein" + AlignNexusStandard => "" + } +} + +///| +/// Return the number of sequence rows. +pub fn AlignNexusAlignment::num_sequences(self : AlignNexusAlignment) -> Int { + self.sequences.length() +} + +///| +/// Return the alignment width after removal of all-gap source columns. +pub fn AlignNexusAlignment::alignment_length(self : AlignNexusAlignment) -> Int { + if self.sequences.length() == 0 { + 0 + } else { + self.sequences[0].aligned_sequence.length() + } +} + +///| +/// Return the source width before all-gap columns were removed. +pub fn AlignNexusAlignment::source_alignment_length( + self : AlignNexusAlignment, +) -> Int { + self.metadata.declared_characters +} + +///| +/// Locate the first row with an exact identifier. +pub fn AlignNexusAlignment::find_sequence( + self : AlignNexusAlignment, + id : String, +) -> Int? { + for index = 0; index < self.sequences.length(); index = index + 1 { + if self.sequences[index].id == id { + return Some(index) + } + } + None +} + +///| +/// Return one printed alignment column. +pub fn AlignNexusAlignment::column( + self : AlignNexusAlignment, + column : Int, +) -> String? { + if column < 0 || column >= self.alignment_length() { + return None + } + let output = StringBuilder::new(size_hint=self.sequences.length()) + for sequence in self.sequences { + output.write_char( + sequence.aligned_sequence.unsafe_get(column).unsafe_to_char(), + ) + } + Some(output.to_string()) +} + +///| +/// Map a zero-based ungapped row position to an alignment column. +pub fn AlignNexusAlignment::sequence_position_to_column( + self : AlignNexusAlignment, + row : Int, + position : Int, +) -> Int? { + if row < 0 || row >= self.sequences.length() || position < 0 { + return None + } + let aligned = self.sequences[row].aligned_sequence + let mut coordinate = 0 + for column = 0; column < aligned.length(); column = column + 1 { + if aligned.unsafe_get(column).to_int() != '-'.to_int() { + if coordinate == position { + return Some(column) + } + coordinate = coordinate + 1 + } + } + None +} + +///| +/// Map a printed column to a zero-based ungapped row position. +pub fn AlignNexusAlignment::column_to_sequence_position( + self : AlignNexusAlignment, + row : Int, + column : Int, +) -> Int? { + if row < 0 || + row >= self.sequences.length() || + column < 0 || + column >= self.alignment_length() { + return None + } + let aligned = self.sequences[row].aligned_sequence + if aligned.unsafe_get(column).to_int() == '-'.to_int() { + return None + } + let mut coordinate = 0 + for index = 0; index < column; index = index + 1 { + if aligned.unsafe_get(index).to_int() != '-'.to_int() { + coordinate = coordinate + 1 + } + } + Some(coordinate) +} + +///| +/// Map one residue through the alignment to another row. +pub fn AlignNexusAlignment::map_position( + self : AlignNexusAlignment, + source_row : Int, + target_row : Int, + source_position : Int, +) -> Int? { + if target_row < 0 || target_row >= self.sequences.length() { + return None + } + match self.sequence_position_to_column(source_row, source_position) { + Some(column) => self.column_to_sequence_position(target_row, column) + None => None + } +} + +///| +/// Return per-column residue coordinates for two rows. +pub fn AlignNexusAlignment::aligned_pairs( + self : AlignNexusAlignment, + first_row : Int, + second_row : Int, +) -> Array[(Int?, Int?)] raise AlignNexusError { + align_nexus_validate_row(self, first_row) + align_nexus_validate_row(self, second_row) + let result : Array[(Int?, Int?)] = [] + let mut first_position = 0 + let mut second_position = 0 + for column = 0; column < self.alignment_length(); column = column + 1 { + let first_gap = self.sequences[first_row].aligned_sequence + .unsafe_get(column) + .to_int() == + '-'.to_int() + let second_gap = self.sequences[second_row].aligned_sequence + .unsafe_get(column) + .to_int() == + '-'.to_int() + result.push( + ( + if first_gap { + None + } else { + Some(first_position) + }, + if second_gap { + None + } else { + Some(second_position) + }, + ), + ) + if !first_gap { + first_position = first_position + 1 + } + if !second_gap { + second_position = second_position + 1 + } + } + result +} + +///| +/// Return a compact Biopython-style coordinate path for all rows. +pub fn AlignNexusAlignment::coordinate_path( + self : AlignNexusAlignment, +) -> Array[Array[Int]] { + let paths : Array[Array[Int]] = [] + let coordinates = Array::make(self.sequences.length(), 0) + for _row = 0; _row < self.sequences.length(); _row = _row + 1 { + paths.push([0]) + } + let width = self.alignment_length() + for column = 0; column < width; column = column + 1 { + for row = 0; row < self.sequences.length(); row = row + 1 { + if self.sequences[row].aligned_sequence.unsafe_get(column).to_int() != + '-'.to_int() { + coordinates[row] = coordinates[row] + 1 + } + } + let boundary = if column + 1 == width { + true + } else { + align_nexus_movement_changes(self, column, column + 1) + } + if boundary { + for row = 0; row < self.sequences.length(); row = row + 1 { + paths[row].push(coordinates[row]) + } + } + } + paths +} + +///| +/// Compute statistics for one pair of rows. +pub fn AlignNexusAlignment::pair_counts( + self : AlignNexusAlignment, + first_row : Int, + second_row : Int, +) -> AlignNexusCounts raise AlignNexusError { + align_nexus_validate_row(self, first_row) + align_nexus_validate_row(self, second_row) + align_nexus_count_pair(self, first_row, second_row) +} + +///| +/// Aggregate statistics across every unordered pair of rows. +pub fn AlignNexusAlignment::counts( + self : AlignNexusAlignment, +) -> AlignNexusCounts { + let mut pairs = 0 + let mut aligned = 0 + let mut identities = 0 + let mut mismatches = 0 + let mut gap_columns = 0 + let mut double_gap_columns = 0 + let mut gap_opens = 0 + for first = 0; first < self.sequences.length(); first = first + 1 { + for second = first + 1 + second < self.sequences.length() + second = second + 1 { + let counts = align_nexus_count_pair(self, first, second) + pairs = pairs + 1 + aligned = aligned + counts.aligned + identities = identities + counts.identities + mismatches = mismatches + counts.mismatches + gap_columns = gap_columns + counts.gap_columns + double_gap_columns = double_gap_columns + counts.double_gap_columns + gap_opens = gap_opens + counts.gap_opens + } + } + AlignNexusCounts::{ + pairs, + aligned, + identities, + mismatches, + gap_columns, + double_gap_columns, + gap_opens, + } +} + +///| +/// Return exact identity over columns containing residues in both rows. +pub fn AlignNexusCounts::identity(self : AlignNexusCounts) -> Double { + if self.aligned == 0 { + 0.0 + } else { + self.identities.to_double() / self.aligned.to_double() + } +} + +///| +/// Calculate a majority consensus. Gaps do not vote. +pub fn AlignNexusAlignment::consensus( + self : AlignNexusAlignment, + minimum_fraction? : Double = 0.0, +) -> String raise AlignNexusError { + if minimum_fraction != minimum_fraction || + minimum_fraction < 0.0 || + minimum_fraction > 1.0 { + raise AlignNexusError( + "NEXUS consensus minimum fraction must be between 0 and 1", + ) + } + let output = StringBuilder::new(size_hint=self.alignment_length()) + for column = 0; column < self.alignment_length(); column = column + 1 { + let counts = Array::make(128, 0) + let mut residues = 0 + for sequence in self.sequences { + let code = sequence.aligned_sequence.unsafe_get(column).to_int() + if code != '-'.to_int() { + if code >= 0 && code < counts.length() { + counts[code] = counts[code] + 1 + } + residues = residues + 1 + } + } + if residues == 0 { + output.write_char('-') + continue + } + let mut best_code = 0 + let mut best_count = -1 + for code = 0; code < counts.length(); code = code + 1 { + if counts[code] > best_count { + best_code = code + best_count = counts[code] + } + } + if best_count.to_double() / residues.to_double() < minimum_fraction { + output.write_char('X') + } else { + output.write_char(best_code.unsafe_to_char()) + } + } + output.to_string() +} + +///| +/// Return per-column non-gap occupancy. +pub fn AlignNexusAlignment::occupancy( + self : AlignNexusAlignment, +) -> Array[Double] { + let result : Array[Double] = [] + for column = 0; column < self.alignment_length(); column = column + 1 { + let mut residues = 0 + for sequence in self.sequences { + if sequence.aligned_sequence.unsafe_get(column).to_int() != '-'.to_int() { + residues = residues + 1 + } + } + result.push(residues.to_double() / self.sequences.length().to_double()) + } + result +} + +///| +/// Return a compact alignment summary. +pub fn AlignNexusAlignment::summary(self : AlignNexusAlignment) -> String { + "AlignNexusAlignment(type=" + + self.metadata.data_type.code() + + ", sequences=" + + self.num_sequences().to_string() + + ", columns=" + + self.alignment_length().to_string() + + ", source_columns=" + + self.source_alignment_length().to_string() + + ", removed_all_gap=" + + self.metadata.removed_all_gap_columns.to_string() + + ")" +} + +///| +/// Return a compact interleaved NEXUS example with quoting and MATCHCHAR. +pub fn align_nexus_example_text() -> String { + "#NEXUS\n" + + "[MoonBit NEXUS example with a [nested] comment]\n" + + "begin data;\n" + + "dimensions ntax=3 nchar=12;\n" + + "format datatype=dna missing=? gap=- matchchar=. interleave=yes;\n" + + "matrix\n" + + "reference ACGT--\n" + + "'query one' A.GT??\n" + + "'isn''t_query' .C-T--\n" + + "\n" + + "reference ACGTAC\n" + + "query_one ..G-AC\n" + + "'isn''t_query' A-GTAC\n" + + ";\n" + + "end;\n" +} + +///| +fn align_nexus_validate_alignment( + alignment : AlignNexusAlignment, +) -> Unit raise AlignNexusError { + if alignment.sequences.length() == 0 { + raise AlignNexusError("NEXUS alignment must contain at least one sequence") + } + if alignment.sequences.length() != alignment.metadata.declared_taxa { + raise AlignNexusError("NEXUS sequence count does not match declared NTAX") + } + let width = alignment.sequences[0].aligned_sequence.length() + if width + alignment.metadata.removed_all_gap_columns != + alignment.metadata.declared_characters { + raise AlignNexusError( + "NEXUS alignment width and removed columns do not match NCHAR", + ) + } + align_nexus_validate_format_char( + alignment.metadata.missing_character, + "NEXUS missing-data character", + ) + align_nexus_validate_format_char( + alignment.metadata.gap_character, + "NEXUS gap character", + ) + align_nexus_validate_symbols( + alignment.metadata.data_type, + alignment.metadata.symbols, + alignment.metadata.respect_case, + ) + for sequence in alignment.sequences { + align_nexus_validate_id(sequence.id) + if sequence.aligned_sequence.length() != width { + raise AlignNexusError("NEXUS aligned rows must have equal widths") + } + for index = 0; index < sequence.aligned_sequence.length(); index = index + 1 { + let code = sequence.aligned_sequence.unsafe_get(index).to_int() + if code != '-'.to_int() && + code != alignment.metadata.missing_character.unsafe_get(0).to_int() && + !align_nexus_valid_residue( + code, + alignment.metadata.data_type, + alignment.metadata.symbols, + alignment.metadata.respect_case, + ) { + raise AlignNexusError( + "NEXUS sequence contains a residue inconsistent with FORMAT", + ) + } + } + if align_nexus_remove_gaps(sequence.aligned_sequence) != sequence.sequence { + raise AlignNexusError( + "NEXUS sequence row has inconsistent derived fields", + ) + } + } + for column = 0; column < width; column = column + 1 { + let mut has_residue = false + for sequence in alignment.sequences { + if sequence.aligned_sequence.unsafe_get(column).to_int() != '-'.to_int() { + has_residue = true + } + } + if !has_residue { + raise AlignNexusError( + "NEXUS alignment contains an unremoved all-gap column", + ) + } + } +} + +///| +fn align_nexus_validate_row( + alignment : AlignNexusAlignment, + row : Int, +) -> Unit raise AlignNexusError { + if row < 0 || row >= alignment.sequences.length() { + raise AlignNexusError("NEXUS row index is out of bounds") + } +} + +///| +fn align_nexus_count_pair( + alignment : AlignNexusAlignment, + first_row : Int, + second_row : Int, +) -> AlignNexusCounts { + let first = alignment.sequences[first_row].aligned_sequence + let second = alignment.sequences[second_row].aligned_sequence + let mut aligned = 0 + let mut identities = 0 + let mut mismatches = 0 + let mut gap_columns = 0 + let mut double_gap_columns = 0 + let mut gap_opens = 0 + let mut in_gap = false + for column = 0; column < alignment.alignment_length(); column = column + 1 { + let first_code = first.unsafe_get(column).to_int() + let second_code = second.unsafe_get(column).to_int() + let first_gap = first_code == '-'.to_int() + let second_gap = second_code == '-'.to_int() + if first_gap && second_gap { + double_gap_columns = double_gap_columns + 1 + in_gap = false + } else if first_gap || second_gap { + gap_columns = gap_columns + 1 + if !in_gap { + gap_opens = gap_opens + 1 + } + in_gap = true + } else { + aligned = aligned + 1 + if first_code == second_code { + identities = identities + 1 + } else { + mismatches = mismatches + 1 + } + in_gap = false + } + } + AlignNexusCounts::{ + pairs: 1, + aligned, + identities, + mismatches, + gap_columns, + double_gap_columns, + gap_opens, + } +} + +///| +fn align_nexus_scan_commands( + body : String, +) -> Array[String] raise AlignNexusError { + let commands : Array[String] = [] + let mut current = StringBuilder::new() + let mut quote = 0 + let mut comment_depth = 0 + let mut index = 0 + while index < body.length() { + let code = body.unsafe_get(index).to_int() + if comment_depth > 0 { + if code == '['.to_int() { + comment_depth = comment_depth + 1 + } else if code == ']'.to_int() { + comment_depth = comment_depth - 1 + } else if code == '\n'.to_int() { + current.write_char('\n') + } + index = index + 1 + continue + } + if quote != 0 { + current.write_char(code.unsafe_to_char()) + if code == quote { + if index + 1 < body.length() && + body.unsafe_get(index + 1).to_int() == quote { + current.write_char(quote.unsafe_to_char()) + index = index + 2 + continue + } + quote = 0 + } + index = index + 1 + continue + } + if code == '['.to_int() { + comment_depth = 1 + } else if code == ']'.to_int() { + raise AlignNexusError("Unmatched closing NEXUS comment bracket") + } else if code == '\''.to_int() || code == '"'.to_int() { + quote = code + current.write_char(code.unsafe_to_char()) + } else if code == ';'.to_int() { + let command = current.to_string().trim().to_owned() + if command.length() > 0 { + commands.push(command) + } + current = StringBuilder::new() + } else { + current.write_char(code.unsafe_to_char()) + } + index = index + 1 + } + if comment_depth != 0 { + raise AlignNexusError("Unterminated NEXUS comment") + } + if quote != 0 { + raise AlignNexusError("Unterminated quoted NEXUS token") + } + if current.to_string().trim().length() != 0 { + raise AlignNexusError("NEXUS command is missing a semicolon") + } + commands +} + +///| +fn align_nexus_split_keyword(command : String) -> (String, String) { + let mut index = 0 + while index < command.length() && + align_nexus_is_whitespace(command.unsafe_get(index).to_int()) { + index = index + 1 + } + let start = index + while index < command.length() && + !align_nexus_is_whitespace(command.unsafe_get(index).to_int()) { + index = index + 1 + } + ( + command[start:index].to_owned().to_lower(), + command[index:].to_owned().trim().to_owned(), + ) +} + +///| +fn align_nexus_tokenize(text : String) -> Array[String] raise AlignNexusError { + let tokens : Array[String] = [] + let mut index = 0 + while index < text.length() { + while index < text.length() && + align_nexus_is_whitespace(text.unsafe_get(index).to_int()) { + index = index + 1 + } + if index >= text.length() { + break + } + let code = text.unsafe_get(index).to_int() + if code == '='.to_int() || code == ','.to_int() { + tokens.push(code.unsafe_to_char().to_string()) + index = index + 1 + continue + } + if code == '\''.to_int() || code == '"'.to_int() { + let quote = code + let output = StringBuilder::new() + index = index + 1 + let mut closed = false + while index < text.length() { + let current = text.unsafe_get(index).to_int() + if current == quote { + if index + 1 < text.length() && + text.unsafe_get(index + 1).to_int() == quote { + output.write_char(quote.unsafe_to_char()) + index = index + 2 + } else { + index = index + 1 + closed = true + break + } + } else { + output.write_char(current.unsafe_to_char()) + index = index + 1 + } + } + if !closed { + raise AlignNexusError("Unterminated quoted NEXUS token") + } + tokens.push(output.to_string()) + continue + } + let start = index + while index < text.length() { + let current = text.unsafe_get(index).to_int() + if align_nexus_is_whitespace(current) || + current == '='.to_int() || + current == ','.to_int() { + break + } + index = index + 1 + } + tokens.push(text[start:index].to_owned()) + } + tokens +} + +///| +fn align_nexus_parse_dimensions( + text : String, +) -> (Int, Int) raise AlignNexusError { + let tokens = align_nexus_tokenize(text) + let mut ntax = -1 + let mut nchar = -1 + let mut index = 0 + while index < tokens.length() { + let key = tokens[index].to_lower() + if key == "newtaxa" { + index = index + 1 + continue + } + if key != "ntax" && key != "nchar" { + raise AlignNexusError( + "Unknown NEXUS DIMENSIONS option '" + tokens[index] + "'", + ) + } + if index + 2 >= tokens.length() || tokens[index + 1] != "=" { + raise AlignNexusError("Malformed NEXUS DIMENSIONS assignment") + } + let value = align_nexus_parse_positive_int( + tokens[index + 2], + "NEXUS " + key.to_upper(), + ) + if key == "ntax" { + if ntax >= 0 { + raise AlignNexusError("Duplicated NEXUS NTAX assignment") + } + ntax = value + } else { + if nchar >= 0 { + raise AlignNexusError("Duplicated NEXUS NCHAR assignment") + } + nchar = value + } + index = index + 3 + } + (ntax, nchar) +} + +///| +fn align_nexus_parse_format( + text : String, + initial : AlignNexusFormat, +) -> AlignNexusFormat raise AlignNexusError { + let tokens = align_nexus_tokenize(text) + let mut data_type = initial.data_type + let mut missing = initial.missing_character + let mut gap = initial.gap_character + let mut match_character = initial.match_character + let mut interleaved = initial.interleaved + let mut respect_case = initial.respect_case + let mut symbols = initial.symbols + let mut labels = initial.labels + let mut index = 0 + while index < tokens.length() { + let key = tokens[index].to_lower() + if key == "interleave" { + if index + 1 < tokens.length() && tokens[index + 1] == "=" { + if index + 2 >= tokens.length() { + raise AlignNexusError("Missing NEXUS INTERLEAVE value") + } + interleaved = align_nexus_parse_yes_no( + tokens[index + 2], + "NEXUS INTERLEAVE", + ) + index = index + 3 + } else { + interleaved = true + index = index + 1 + } + continue + } + if key == "nointerleave" { + interleaved = false + index = index + 1 + continue + } + if key == "respectcase" { + respect_case = true + index = index + 1 + continue + } + if key == "labels" { + if index + 1 < tokens.length() && tokens[index + 1] == "=" { + if index + 2 >= tokens.length() { + raise AlignNexusError("Missing NEXUS LABELS value") + } + let value = tokens[index + 2].to_lower() + if value == "no" || value == "none" { + labels = false + } else if value == "yes" || value == "left" { + labels = true + } else { + raise AlignNexusError("Unsupported NEXUS LABELS value") + } + index = index + 3 + } else { + labels = true + index = index + 1 + } + continue + } + if key == "nolabels" { + labels = false + index = index + 1 + continue + } + if key == "transpose" || + key == "tokens" || + key == "notokens" || + key == "equate" { + raise AlignNexusError( + "NEXUS FORMAT option '" + key + "' is not supported for alignments", + ) + } + if key != "datatype" && + key != "missing" && + key != "gap" && + key != "matchchar" && + key != "symbols" { + raise AlignNexusError( + "Unknown NEXUS FORMAT option '" + tokens[index] + "'", + ) + } + if index + 2 >= tokens.length() || tokens[index + 1] != "=" { + raise AlignNexusError( + "Malformed NEXUS FORMAT assignment for " + key.to_upper(), + ) + } + let value = tokens[index + 2] + if key == "datatype" { + data_type = match value.to_lower() { + "dna" | "nucleotide" => AlignNexusDna + "rna" => AlignNexusRna + "protein" => AlignNexusProtein + "standard" => AlignNexusStandard + other => + raise AlignNexusError("Unsupported NEXUS datatype '" + other + "'") + } + } else if key == "missing" { + missing = value + } else if key == "gap" { + gap = value + } else if key == "matchchar" { + match_character = Some(value) + } else { + symbols = value + } + index = index + 3 + } + let result = AlignNexusFormat::{ + data_type, + missing_character: missing, + gap_character: gap, + match_character, + interleaved, + respect_case, + symbols, + labels, + } + align_nexus_validate_format(result) + result +} + +///| +fn align_nexus_validate_format( + format : AlignNexusFormat, +) -> Unit raise AlignNexusError { + align_nexus_validate_format_char( + format.missing_character, + "NEXUS missing-data character", + ) + align_nexus_validate_format_char(format.gap_character, "NEXUS gap character") + if format.missing_character == format.gap_character { + raise AlignNexusError( + "NEXUS missing-data and gap characters must be different", + ) + } + match format.match_character { + Some(value) => { + align_nexus_validate_format_char(value, "NEXUS match character") + if value == format.missing_character || value == format.gap_character { + raise AlignNexusError( + "NEXUS match character must differ from missing and gap characters", + ) + } + } + None => () + } + align_nexus_validate_symbols( + format.data_type, + format.symbols, + format.respect_case, + ) +} + +///| +fn align_nexus_parse_taxlabels( + text : String, +) -> Array[String] raise AlignNexusError { + let tokens = align_nexus_tokenize(text) + let labels : Array[String] = [] + for token in tokens { + if token != "," { + align_nexus_validate_id(token) + labels.push(token) + } + } + if labels.length() == 0 { + raise AlignNexusError("NEXUS TAXLABELS must not be empty") + } + labels +} + +///| +fn align_nexus_parse_matrix( + body : String, + ntax : Int, + nchar : Int, + format : AlignNexusFormat, + taxlabels : Array[String], +) -> (Array[String], Array[String]) raise AlignNexusError { + let raw_lines = align_nexus_normalize_lines(body) + let lines : Array[String] = [] + for raw in raw_lines { + let trimmed = raw.trim().to_owned() + if trimmed.length() > 0 { + lines.push(trimmed) + } + } + if lines.length() == 0 { + raise AlignNexusError("NEXUS MATRIX must not be empty") + } + if format.interleaved { + align_nexus_parse_interleaved_matrix( + lines, + ntax, + nchar, + format.labels, + taxlabels, + ) + } else { + align_nexus_parse_sequential_matrix( + lines, + ntax, + nchar, + format.labels, + taxlabels, + ) + } +} + +///| +fn align_nexus_parse_interleaved_matrix( + lines : Array[String], + ntax : Int, + nchar : Int, + labels : Bool, + taxlabels : Array[String], +) -> (Array[String], Array[String]) raise AlignNexusError { + if !labels && taxlabels.length() != ntax { + raise AlignNexusError("NEXUS LABELS=NO matrices require NTAX TAXLABELS") + } + let entry_ids : Array[String] = [] + let entry_chunks : Array[String] = [] + let mut line_index = 0 + while line_index < lines.length() { + if labels { + let parsed = align_nexus_parse_labeled_line(lines[line_index]) + let mut chunk = align_nexus_remove_whitespace(parsed.1) + line_index = line_index + 1 + if chunk.length() == 0 { + if line_index >= lines.length() { + raise AlignNexusError("Missing sequence after NEXUS matrix label") + } + chunk = align_nexus_remove_whitespace(lines[line_index]) + line_index = line_index + 1 + } + align_nexus_validate_id(parsed.0) + entry_ids.push(parsed.0) + entry_chunks.push(chunk) + } else { + entry_ids.push(taxlabels[entry_ids.length() % ntax]) + entry_chunks.push(align_nexus_remove_whitespace(lines[line_index])) + line_index = line_index + 1 + } + } + if entry_ids.length() == 0 || entry_ids.length() % ntax != 0 { + raise AlignNexusError( + "Interleaved NEXUS MATRIX does not contain complete NTAX blocks", + ) + } + let ids : Array[String] = [] + let rows = Array::make(ntax, "") + let block_count = entry_ids.length() / ntax + for block = 0; block < block_count; block = block + 1 { + let first_chunk_length = entry_chunks[block * ntax].length() + if first_chunk_length == 0 { + raise AlignNexusError("NEXUS interleaved matrix chunk must not be empty") + } + for row = 0; row < ntax; row = row + 1 { + let entry = block * ntax + row + if entry_chunks[entry].length() != first_chunk_length { + raise AlignNexusError( + "Rows in one NEXUS interleaved block must have equal widths", + ) + } + if block == 0 { + ids.push(entry_ids[entry]) + } else if !align_nexus_labels_equivalent(ids[row], entry_ids[entry]) { + raise AlignNexusError( + "NEXUS interleaved taxon order or label changed between blocks", + ) + } + rows[row] = rows[row] + entry_chunks[entry] + } + } + for row = 0; row < ntax; row = row + 1 { + if rows[row].length() != nchar { + raise AlignNexusError( + "NEXUS NCHAR does not match interleaved row length for '" + + ids[row] + + "'", + ) + } + } + (ids, rows) +} + +///| +fn align_nexus_parse_sequential_matrix( + lines : Array[String], + ntax : Int, + nchar : Int, + labels : Bool, + taxlabels : Array[String], +) -> (Array[String], Array[String]) raise AlignNexusError { + if !labels && taxlabels.length() != ntax { + raise AlignNexusError("NEXUS LABELS=NO matrices require NTAX TAXLABELS") + } + let ids : Array[String] = [] + let rows : Array[String] = [] + let mut line_index = 0 + for row = 0; row < ntax; row = row + 1 { + if line_index >= lines.length() { + raise AlignNexusError("Not enough taxa in NEXUS MATRIX") + } + let mut sequence = "" + if labels { + let parsed = align_nexus_parse_labeled_line(lines[line_index]) + align_nexus_validate_id(parsed.0) + ids.push(parsed.0) + sequence = align_nexus_remove_whitespace(parsed.1) + } else { + ids.push(taxlabels[row]) + sequence = align_nexus_remove_whitespace(lines[line_index]) + } + line_index = line_index + 1 + while sequence.length() < nchar { + if line_index >= lines.length() { + raise AlignNexusError("NEXUS MATRIX row is shorter than declared NCHAR") + } + sequence = sequence + align_nexus_remove_whitespace(lines[line_index]) + line_index = line_index + 1 + } + if sequence.length() != nchar { + raise AlignNexusError("NEXUS MATRIX row is longer than declared NCHAR") + } + rows.push(sequence) + } + if line_index != lines.length() { + raise AlignNexusError("Too many taxa or sequence lines in NEXUS MATRIX") + } + (ids, rows) +} + +///| +fn align_nexus_parse_labeled_line( + line : String, +) -> (String, String) raise AlignNexusError { + let mut index = 0 + while index < line.length() && + align_nexus_is_whitespace(line.unsafe_get(index).to_int()) { + index = index + 1 + } + if index >= line.length() { + raise AlignNexusError("Empty NEXUS MATRIX row") + } + let code = line.unsafe_get(index).to_int() + if code == '\''.to_int() || code == '"'.to_int() { + let quote = code + let label = StringBuilder::new() + index = index + 1 + let mut closed = false + while index < line.length() { + let current = line.unsafe_get(index).to_int() + if current == quote { + if index + 1 < line.length() && + line.unsafe_get(index + 1).to_int() == quote { + label.write_char(quote.unsafe_to_char()) + index = index + 2 + } else { + index = index + 1 + closed = true + break + } + } else { + label.write_char(current.unsafe_to_char()) + index = index + 1 + } + } + if !closed { + raise AlignNexusError("Unterminated quoted NEXUS taxon name") + } + if index < line.length() && + !align_nexus_is_whitespace(line.unsafe_get(index).to_int()) { + raise AlignNexusError( + "Quoted NEXUS taxon name must be followed by whitespace", + ) + } + (label.to_string(), line[index:].to_owned().trim().to_owned()) + } else { + let start = index + while index < line.length() && + !align_nexus_is_whitespace(line.unsafe_get(index).to_int()) { + index = index + 1 + } + (line[start:index].to_owned(), line[index:].to_owned().trim().to_owned()) + } +} + +///| +fn align_nexus_resolve_and_normalize_rows( + rows : Array[String], + format : AlignNexusFormat, +) -> Array[String] raise AlignNexusError { + let resolved : Array[String] = [] + for row_index = 0; row_index < rows.length(); row_index = row_index + 1 { + let output = StringBuilder::new(size_hint=rows[row_index].length()) + for column = 0; column < rows[row_index].length(); column = column + 1 { + let mut code = rows[row_index].unsafe_get(column).to_int() + match format.match_character { + Some(character) => + if code == character.unsafe_get(0).to_int() { + if row_index == 0 { + raise AlignNexusError( + "NEXUS match character is not allowed in the first row", + ) + } + code = resolved[0].unsafe_get(column).to_int() + } + None => () + } + output.write_char(code.unsafe_to_char()) + } + resolved.push( + align_nexus_normalize_row( + output.to_string(), + format.data_type, + format.missing_character, + format.gap_character, + format.symbols, + format.respect_case, + ), + ) + } + resolved +} + +///| +fn align_nexus_normalize_row( + row : String, + data_type : AlignNexusDataType, + missing_character : String, + gap_character : String, + symbols : String, + respect_case : Bool, +) -> String raise AlignNexusError { + let output = StringBuilder::new(size_hint=row.length()) + let missing_code = missing_character.unsafe_get(0).to_int() + let gap_code = gap_character.unsafe_get(0).to_int() + for index = 0; index < row.length(); index = index + 1 { + let code = row.unsafe_get(index).to_int() + if code == gap_code { + output.write_char('-') + } else if code == missing_code || + align_nexus_valid_residue(code, data_type, symbols, respect_case) { + output.write_char(code.unsafe_to_char()) + } else { + raise AlignNexusError( + "Illegal " + + data_type.code() + + " character '" + + code.unsafe_to_char().to_string() + + "' in NEXUS MATRIX", + ) + } + } + output.to_string() +} + +///| +fn align_nexus_valid_residue( + code : Int, + data_type : AlignNexusDataType, + symbols : String, + respect_case : Bool, +) -> Bool { + match data_type { + AlignNexusDna => + align_nexus_contains_code("ACGTRYSWKMBDHVNacgtryswkmbdhvn", code) + AlignNexusRna => + align_nexus_contains_code("ACGURYSWKMBDHVNacguryswkmbdhvn", code) + AlignNexusProtein => + align_nexus_contains_code( + "ACDEFGHIKLMNPQRSTVWYBZX*acdefghiklmnpqrstvywbzx", code, + ) + AlignNexusStandard => + if align_nexus_contains_code(symbols, code) { + true + } else if !respect_case { + align_nexus_contains_code(symbols, align_nexus_swap_case(code)) + } else { + false + } + } +} + +///| +fn align_nexus_validate_symbols( + data_type : AlignNexusDataType, + symbols : String, + respect_case : Bool, +) -> Unit raise AlignNexusError { + if data_type == AlignNexusStandard && symbols.length() == 0 { + raise AlignNexusError( + "NEXUS standard datatype requires a non-empty SYMBOLS value", + ) + } + let seen : Array[Int] = [] + for index = 0; index < symbols.length(); index = index + 1 { + let code = symbols.unsafe_get(index).to_int() + if code < 33 || + code > 126 || + align_nexus_is_whitespace(code) || + code == '\''.to_int() || + code == '"'.to_int() || + code == '['.to_int() || + code == ']'.to_int() || + code == '('.to_int() || + code == ')'.to_int() || + code == ','.to_int() || + code == ';'.to_int() || + code == '='.to_int() { + raise AlignNexusError( + "NEXUS SYMBOLS must contain distinct printable state characters", + ) + } + let comparable = if respect_case { + code + } else { + align_nexus_upper_code(code) + } + for previous in seen { + if previous == comparable { + raise AlignNexusError("NEXUS SYMBOLS contains a duplicate state") + } + } + seen.push(comparable) + } +} + +///| +fn align_nexus_validate_format_char( + value : String, + label : String, +) -> Unit raise AlignNexusError { + if value.length() != 1 { + raise AlignNexusError(label + " must be one ASCII character") + } + let code = value.unsafe_get(0).to_int() + if code < 33 || + code > 126 || + code == '['.to_int() || + code == ']'.to_int() || + code == '\''.to_int() || + code == '"'.to_int() || + code == ';'.to_int() { + raise AlignNexusError( + label + " must be one printable non-reserved character", + ) + } +} + +///| +fn align_nexus_validate_id(id : String) -> Unit raise AlignNexusError { + if id.length() == 0 { + raise AlignNexusError("NEXUS taxon identifier must not be empty") + } + for index = 0; index < id.length(); index = index + 1 { + let code = id.unsafe_get(index).to_int() + if code < 32 || + code == 127 || + code == '\n'.to_int() || + code == '\r'.to_int() { + raise AlignNexusError( + "NEXUS taxon identifier contains a control character", + ) + } + } +} + +///| +fn align_nexus_remove_all_gap_columns( + rows : Array[String], +) -> (Array[String], Int) { + if rows.length() == 0 { + return ([], 0) + } + let width = rows[0].length() + let keep = Array::make(width, false) + let mut removed = 0 + for column = 0; column < width; column = column + 1 { + for row in rows { + if row.unsafe_get(column).to_int() != '-'.to_int() { + keep[column] = true + } + } + if !keep[column] { + removed = removed + 1 + } + } + let result : Array[String] = [] + for row in rows { + let output = StringBuilder::new(size_hint=width - removed) + for column = 0; column < width; column = column + 1 { + if keep[column] { + output.write_char(row.unsafe_get(column).unsafe_to_char()) + } + } + result.push(output.to_string()) + } + (result, removed) +} + +///| +fn align_nexus_movement_changes( + alignment : AlignNexusAlignment, + first_column : Int, + second_column : Int, +) -> Bool { + for row = 0; row < alignment.sequences.length(); row = row + 1 { + let first = alignment.sequences[row].aligned_sequence + .unsafe_get(first_column) + .to_int() != + '-'.to_int() + let second = alignment.sequences[row].aligned_sequence + .unsafe_get(second_column) + .to_int() != + '-'.to_int() + if first != second { + return true + } + } + false +} + +///| +fn align_nexus_labels_equivalent(first : String, second : String) -> Bool { + if first == second { + return true + } + let left = StringBuilder::new(size_hint=first.length()) + let right = StringBuilder::new(size_hint=second.length()) + for index = 0; index < first.length(); index = index + 1 { + let code = first.unsafe_get(index).to_int() + left.write_char( + (if code == ' '.to_int() { '_'.to_int() } else { code }).unsafe_to_char(), + ) + } + for index = 0; index < second.length(); index = index + 1 { + let code = second.unsafe_get(index).to_int() + right.write_char( + (if code == ' '.to_int() { '_'.to_int() } else { code }).unsafe_to_char(), + ) + } + left.to_string() == right.to_string() +} + +///| +fn align_nexus_safe_name(id : String) -> String { + let mut quote = false + for index = 0; index < id.length(); index = index + 1 { + let code = id.unsafe_get(index).to_int() + let safe = (code >= 'A'.to_int() && code <= 'Z'.to_int()) || + (code >= 'a'.to_int() && code <= 'z'.to_int()) || + (code >= '0'.to_int() && code <= '9'.to_int()) || + code == '_'.to_int() || + code == '-'.to_int() || + code == '.'.to_int() + if !safe { + quote = true + } + } + if !quote { + return id + } + let output = StringBuilder::new(size_hint=id.length() + 2) + output.write_char('\'') + for index = 0; index < id.length(); index = index + 1 { + let code = id.unsafe_get(index).to_int() + output.write_char(code.unsafe_to_char()) + if code == '\''.to_int() { + output.write_char('\'') + } + } + output.write_char('\'') + output.to_string() +} + +///| +fn align_nexus_output_fragment( + row : String, + start : Int, + end : Int, + gap_character : String, +) -> String { + let output = StringBuilder::new(size_hint=end - start) + let gap_code = gap_character.unsafe_get(0).to_int() + for index = start; index < end; index = index + 1 { + let code = row.unsafe_get(index).to_int() + output.write_char( + (if code == '-'.to_int() { gap_code } else { code }).unsafe_to_char(), + ) + } + output.to_string() +} + +///| +fn align_nexus_escape_double_quotes(value : String) -> String { + let output = StringBuilder::new(size_hint=value.length()) + for index = 0; index < value.length(); index = index + 1 { + let code = value.unsafe_get(index).to_int() + output.write_char(code.unsafe_to_char()) + if code == '"'.to_int() { + output.write_char('"') + } + } + output.to_string() +} + +///| +fn align_nexus_remove_gaps(sequence : String) -> String { + let output = StringBuilder::new(size_hint=sequence.length()) + for index = 0; index < sequence.length(); index = index + 1 { + let code = sequence.unsafe_get(index).to_int() + if code != '-'.to_int() { + output.write_char(code.unsafe_to_char()) + } + } + output.to_string() +} + +///| +fn align_nexus_remove_whitespace(value : String) -> String { + let output = StringBuilder::new(size_hint=value.length()) + for index = 0; index < value.length(); index = index + 1 { + let code = value.unsafe_get(index).to_int() + if !align_nexus_is_whitespace(code) { + output.write_char(code.unsafe_to_char()) + } + } + output.to_string() +} + +///| +fn align_nexus_normalize_lines(text : String) -> Array[String] { + let raw_lines = text.split("\n") + let lines : Array[String] = [] + for raw in raw_lines { + let owned = raw.to_owned() + if owned.length() > 0 && + owned.unsafe_get(owned.length() - 1).to_int() == '\r'.to_int() { + lines.push(owned[0:owned.length() - 1].to_owned()) + } else { + lines.push(owned) + } + } + lines +} + +///| +fn align_nexus_parse_positive_int( + text : String, + label : String, +) -> Int raise AlignNexusError { + if text.length() == 0 { + raise AlignNexusError(label + " is empty") + } + let mut value = 0 + for index = 0; index < text.length(); index = index + 1 { + let code = text.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + raise AlignNexusError(label + " must be a positive integer") + } + let digit = code - '0'.to_int() + if value > 214748364 || (value == 214748364 && digit > 7) { + raise AlignNexusError(label + " is outside the supported integer range") + } + value = value * 10 + digit + } + if value <= 0 { + raise AlignNexusError(label + " must be positive") + } + value +} + +///| +fn align_nexus_parse_yes_no( + value : String, + label : String, +) -> Bool raise AlignNexusError { + match value.to_lower() { + "yes" | "true" => true + "no" | "false" => false + _ => raise AlignNexusError(label + " must be YES or NO") + } +} + +///| +fn align_nexus_is_whitespace(code : Int) -> Bool { + code == ' '.to_int() || + code == '\t'.to_int() || + code == '\n'.to_int() || + code == '\r'.to_int() +} + +///| +fn align_nexus_contains_code(values : String, target : Int) -> Bool { + for index = 0; index < values.length(); index = index + 1 { + if values.unsafe_get(index).to_int() == target { + return true + } + } + false +} + +///| +fn align_nexus_upper_code(code : Int) -> Int { + if code >= 'a'.to_int() && code <= 'z'.to_int() { + code - 'a'.to_int() + 'A'.to_int() + } else { + code + } +} + +///| +fn align_nexus_swap_case(code : Int) -> Int { + if code >= 'a'.to_int() && code <= 'z'.to_int() { + code - 'a'.to_int() + 'A'.to_int() + } else if code >= 'A'.to_int() && code <= 'Z'.to_int() { + code - 'A'.to_int() + 'a'.to_int() + } else { + code + } +} + +///| +fn align_nexus_pad_right(value : String, width : Int) -> String { + if value.length() >= width { + return value + } + let output = StringBuilder::new(size_hint=width) + output.write_string(value) + for _index = value.length(); _index < width; _index = _index + 1 { + output.write_char(' ') + } + output.to_string() +} + +///| +fn align_nexus_min(first : Int, second : Int) -> Int { + if first < second { + first + } else { + second + } +} diff --git a/src/align_stockholm.mbt b/src/align_stockholm.mbt new file mode 100644 index 00000000..9252ad95 --- /dev/null +++ b/src/align_stockholm.mbt @@ -0,0 +1,2426 @@ +// Biopython-compatible Bio.Align.stockholm support. +// +// This module is intentionally separate from stockholm.mbt. The older module +// exposes a permissive block-oriented API, while this file models modern, +// coordinate-aware Stockholm alignments and their typed annotations. + +///| +/// Error raised for malformed Stockholm data or invalid operations. +pub suberror AlignStockholmError { + AlignStockholmError(String) +} + +///| +/// A mapped GF or GS annotation. +/// +/// `code` is the Stockholm tag and `feature` is Biopython's descriptive name. +pub struct AlignStockholmAnnotation { + code : String + feature : String + value : String +} derive(Eq, Debug) + +///| +/// A mapped GC annotation with one character per retained alignment column. +pub struct AlignStockholmColumnAnnotation { + code : String + feature : String + value : String +} derive(Eq, Debug) + +///| +/// A mapped GR annotation. +/// +/// `value` contains one character per ungapped residue. `aligned_value` +/// contains one character per retained alignment column. +pub struct AlignStockholmLetterAnnotation { + code : String + feature : String + value : String + aligned_value : String +} derive(Eq, Debug) + +///| +/// One structured Stockholm reference. +pub struct AlignStockholmReference { + number : Int + medline : String + title : String + author : String + location : String + comment : String +} derive(Eq, Debug) + +///| +/// One structured database reference. +pub struct AlignStockholmDatabaseReference { + reference : String + comment : String +} derive(Eq, Debug) + +///| +/// One nested-domain annotation. +pub struct AlignStockholmNestedDomain { + accession : String + location : String +} derive(Eq, Debug) + +///| +/// One sequence row and its GS/GR annotations. +pub struct AlignStockholmSequence { + id : String + description : String + sequence : String + aligned_sequence : String + annotations : Array[AlignStockholmAnnotation] + dbxrefs : Array[String] + letter_annotations : Array[AlignStockholmLetterAnnotation] +} derive(Eq, Debug) + +///| +/// A coordinate-aware Stockholm 1.0 alignment. +/// +/// `operations` contains one `M`, `D`, or `I` per retained column. A source +/// `-` gap marks a deletion column and a source `.` gap marks an insertion +/// column, matching Biopython's `Bio.Align.stockholm` behavior. +pub struct AlignStockholmAlignment { + version : String + sequences : Array[AlignStockholmSequence] + annotations : Array[AlignStockholmAnnotation] + column_annotations : Array[AlignStockholmColumnAnnotation] + references : Array[AlignStockholmReference] + database_references : Array[AlignStockholmDatabaseReference] + nested_domains : Array[AlignStockholmNestedDomain] + operations : String + source_columns : Int + removed_all_gap_columns : Int +} derive(Eq, Debug) + +///| +/// Pairwise or all-pairs Stockholm alignment statistics. +pub struct AlignStockholmCounts { + pairs : Int + aligned : Int + identities : Int + mismatches : Int + gap_columns : Int + double_gap_columns : Int + gap_opens : Int +} derive(Eq, Debug) + +///| +priv struct AlignStockholmRawAnnotation { + code : String + value : String +} + +///| +priv struct AlignStockholmRawSequenceAnnotation { + sequence_id : String + code : String + value : String +} + +///| +priv struct AlignStockholmReferenceBuilder { + number : Int + mut medline : String + mut title : String + mut author : String + mut location : String + comment : String +} + +///| +priv struct AlignStockholmDatabaseReferenceBuilder { + reference : String + mut comment : String +} + +///| +priv struct AlignStockholmNestedDomainBuilder { + accession : String + mut location : String +} + +///| +/// Construct a generic GF or GS annotation. +pub fn AlignStockholmAnnotation::create( + code : String, + value : String, + feature? : String? = None, +) -> AlignStockholmAnnotation raise AlignStockholmError { + align_stockholm_validate_annotation_code(code) + AlignStockholmAnnotation::{ + code, + feature: match feature { + Some(name) => name + None => code + }, + value, + } +} + +///| +/// Construct a generic GC annotation. +pub fn AlignStockholmColumnAnnotation::create( + code : String, + value : String, + feature? : String? = None, +) -> AlignStockholmColumnAnnotation raise AlignStockholmError { + align_stockholm_validate_annotation_code(code) + AlignStockholmColumnAnnotation::{ + code, + feature: match feature { + Some(name) => name + None => align_stockholm_gc_feature(code) + }, + value, + } +} + +///| +/// Construct a generic GR annotation. +pub fn AlignStockholmLetterAnnotation::create( + code : String, + value : String, + aligned_value : String, + feature? : String? = None, +) -> AlignStockholmLetterAnnotation raise AlignStockholmError { + align_stockholm_validate_annotation_code(code) + AlignStockholmLetterAnnotation::{ + code, + feature: match feature { + Some(name) => name + None => align_stockholm_gr_feature(code) + }, + value, + aligned_value, + } +} + +///| +/// Construct one standalone Stockholm row. +pub fn AlignStockholmSequence::create( + id : String, + aligned_sequence : String, + description? : String = "", + annotations? : Array[AlignStockholmAnnotation] = [], + dbxrefs? : Array[String] = [], + letter_annotations? : Array[AlignStockholmLetterAnnotation] = [], +) -> AlignStockholmSequence raise AlignStockholmError { + align_stockholm_validate_id(id) + if aligned_sequence.length() == 0 { + raise AlignStockholmError("Stockholm aligned sequence must not be empty") + } + let normalized = align_stockholm_normalize_row(aligned_sequence) + let copied_annotations : Array[AlignStockholmAnnotation] = [] + for annotation in annotations { + copied_annotations.push(annotation) + } + let copied_dbxrefs : Array[String] = [] + for dbxref in dbxrefs { + copied_dbxrefs.push(dbxref) + } + let copied_letter_annotations : Array[AlignStockholmLetterAnnotation] = [] + for annotation in letter_annotations { + copied_letter_annotations.push(annotation) + } + let sequence = AlignStockholmSequence::{ + id, + description, + sequence: align_stockholm_remove_gaps(normalized), + aligned_sequence: normalized, + annotations: copied_annotations, + dbxrefs: copied_dbxrefs, + letter_annotations: copied_letter_annotations, + } + align_stockholm_validate_sequence_annotations(sequence) + sequence +} + +///| +/// Construct and validate one coordinate-aware Stockholm alignment. +pub fn AlignStockholmAlignment::create( + sequences : Array[AlignStockholmSequence], + annotations? : Array[AlignStockholmAnnotation] = [], + column_annotations? : Array[AlignStockholmColumnAnnotation] = [], + references? : Array[AlignStockholmReference] = [], + database_references? : Array[AlignStockholmDatabaseReference] = [], + nested_domains? : Array[AlignStockholmNestedDomain] = [], + operations? : String = "", + source_columns? : Int = 0, + removed_all_gap_columns? : Int = 0, +) -> AlignStockholmAlignment raise AlignStockholmError { + let copied_sequences : Array[AlignStockholmSequence] = [] + for sequence in sequences { + copied_sequences.push(sequence) + } + let copied_annotations : Array[AlignStockholmAnnotation] = [] + for annotation in annotations { + copied_annotations.push(annotation) + } + let copied_column_annotations : Array[AlignStockholmColumnAnnotation] = [] + for annotation in column_annotations { + copied_column_annotations.push(annotation) + } + let copied_references : Array[AlignStockholmReference] = [] + for reference in references { + copied_references.push(reference) + } + let copied_database_references : Array[AlignStockholmDatabaseReference] = [] + for reference in database_references { + copied_database_references.push(reference) + } + let copied_nested_domains : Array[AlignStockholmNestedDomain] = [] + for domain in nested_domains { + copied_nested_domains.push(domain) + } + let width = if copied_sequences.length() == 0 { + 0 + } else { + copied_sequences[0].aligned_sequence.length() + } + let actual_operations = if operations.length() == 0 && width > 0 { + align_stockholm_infer_operations(copied_sequences) + } else { + operations + } + let actual_source_columns = if source_columns == 0 { + width + removed_all_gap_columns + } else { + source_columns + } + let alignment = AlignStockholmAlignment::{ + version: "1.0", + sequences: copied_sequences, + annotations: copied_annotations, + column_annotations: copied_column_annotations, + references: copied_references, + database_references: copied_database_references, + nested_domains: copied_nested_domains, + operations: actual_operations, + source_columns: actual_source_columns, + removed_all_gap_columns, + } + align_stockholm_validate_alignment(alignment) + alignment +} + +///| +/// Construct an alignment from identifiers and printed rows. +/// +/// Source `.` and `-` gaps retain their insertion/deletion operation class. +/// Columns containing only gaps are removed. +pub fn align_stockholm_from_aligned( + ids : Array[String], + aligned_sequences : Array[String], +) -> AlignStockholmAlignment raise AlignStockholmError { + if ids.length() == 0 { + raise AlignStockholmError( + "Stockholm alignment must contain at least one sequence", + ) + } + if ids.length() != aligned_sequences.length() { + raise AlignStockholmError( + "Stockholm identifiers and aligned rows must have equal lengths", + ) + } + let width = aligned_sequences[0].length() + if width == 0 { + raise AlignStockholmError( + "Stockholm alignment must contain at least one column", + ) + } + for row in aligned_sequences { + if row.length() != width { + raise AlignStockholmError("Stockholm aligned rows must have equal widths") + } + } + let prepared = align_stockholm_prepare_rows(aligned_sequences) + if prepared.0.length() == 0 || prepared.0[0].length() == 0 { + raise AlignStockholmError( + "Stockholm alignment contains no non-gap alignment column", + ) + } + let sequences : Array[AlignStockholmSequence] = [] + for index = 0; index < ids.length(); index = index + 1 { + sequences.push( + AlignStockholmSequence::create(ids[index], prepared.0[index]), + ) + } + AlignStockholmAlignment::create( + sequences, + operations=prepared.1, + source_columns=width, + removed_all_gap_columns=align_stockholm_count_true(prepared.2), + ) +} + +///| +/// Parse exactly one Stockholm 1.0 alignment. +pub fn align_stockholm_parse( + text : String, +) -> AlignStockholmAlignment raise AlignStockholmError { + let alignments = align_stockholm_parse_all(text) + if alignments.length() == 0 { + raise AlignStockholmError("Stockholm input contains no alignment") + } + if alignments.length() != 1 { + raise AlignStockholmError( + "Expected one Stockholm alignment, found " + + alignments.length().to_string(), + ) + } + alignments[0] +} + +///| +/// Parse all concatenated Stockholm 1.0 alignments. +pub fn align_stockholm_parse_all( + text : String, +) -> Array[AlignStockholmAlignment] raise AlignStockholmError { + let lines = align_stockholm_normalize_lines(text) + let alignments : Array[AlignStockholmAlignment] = [] + let mut index = 0 + while index < lines.length() { + while index < lines.length() && lines[index].trim().length() == 0 { + index = index + 1 + } + if index >= lines.length() { + break + } + if lines[index].trim() != "# STOCKHOLM 1.0" { + raise AlignStockholmError( + "Expected '# STOCKHOLM 1.0' at line " + (index + 1).to_string(), + ) + } + let start = index + 1 + index = start + while index < lines.length() && lines[index].trim() != "//" { + if lines[index].trim() == "# STOCKHOLM 1.0" { + raise AlignStockholmError( + "Stockholm alignment is missing its // terminator", + ) + } + index = index + 1 + } + if index >= lines.length() { + raise AlignStockholmError( + "Stockholm alignment is missing its // terminator", + ) + } + alignments.push(align_stockholm_parse_record(lines, start, index)) + index = index + 1 + } + alignments +} + +///| +/// Write one canonical Stockholm 1.0 alignment. +pub fn align_stockholm_write( + alignment : AlignStockholmAlignment, +) -> String raise AlignStockholmError { + align_stockholm_validate_alignment(alignment) + let rows = alignment.num_sequences() + let columns = alignment.alignment_length() + if rows == 0 { + raise AlignStockholmError("Must have at least one Stockholm sequence") + } + if columns == 0 { + raise AlignStockholmError("Non-empty Stockholm sequences are required") + } + let output = StringBuilder::new() + output.write_string("# STOCKHOLM 1.0\n") + for annotation in alignment.annotations { + if !align_stockholm_is_known_gf(annotation.code) { + raise AlignStockholmError( + "Unknown Stockholm GF annotation " + annotation.code, + ) + } + if annotation.code == "CC" { + output.write_string( + align_stockholm_wrap_text("#=GF CC ", annotation.value), + ) + } else { + output.write_string( + "#=GF " + annotation.code + " " + annotation.value + "\n", + ) + } + } + for domain in alignment.nested_domains { + if domain.accession.length() > 0 { + output.write_string("#=GF NE " + domain.accession + "\n") + } + if domain.location.length() > 0 { + output.write_string("#=GF NL " + domain.location + "\n") + } + } + for reference in alignment.references { + if reference.comment.length() > 0 { + output.write_string( + align_stockholm_wrap_text("#=GF RC ", reference.comment), + ) + } + output.write_string("#=GF RN [" + reference.number.to_string() + "]\n") + if reference.medline.length() > 0 { + output.write_string("#=GF RM " + reference.medline + "\n") + } + if reference.title.length() > 0 { + output.write_string( + align_stockholm_wrap_text("#=GF RT ", reference.title), + ) + } + if reference.author.length() > 0 { + output.write_string("#=GF RA " + reference.author + "\n") + } + if reference.location.length() > 0 { + output.write_string("#=GF RL " + reference.location + "\n") + } + } + for reference in alignment.database_references { + output.write_string("#=GF DR " + reference.reference + "\n") + if reference.comment.length() > 0 { + output.write_string("#=GF DC " + reference.comment + "\n") + } + } + output.write_string("#=GF SQ " + rows.to_string() + "\n") + let mut name_width = 0 + for sequence in alignment.sequences { + if sequence.id.length() > name_width { + name_width = sequence.id.length() + } + } + let start = align_stockholm_max(name_width, 20) + 12 + for sequence in alignment.sequences { + let padded_name = align_stockholm_pad_right(sequence.id, name_width) + for annotation in sequence.annotations { + output.write_string( + "#=GS " + + padded_name + + " " + + annotation.code + + " " + + annotation.value + + "\n", + ) + } + if sequence.description.length() > 0 { + output.write_string( + "#=GS " + padded_name + " DE " + sequence.description + "\n", + ) + } + for dbxref in sequence.dbxrefs { + output.write_string("#=GS " + padded_name + " DR " + dbxref + "\n") + } + } + for row = 0; row < alignment.sequences.length(); row = row + 1 { + let sequence = alignment.sequences[row] + output.write_string(align_stockholm_pad_right(sequence.id, start)) + output.write_string( + align_stockholm_render_row( + sequence.aligned_sequence, + alignment.operations, + ), + ) + output.write_char('\n') + let padded_name = align_stockholm_pad_right(sequence.id, name_width) + for annotation in sequence.letter_annotations { + output.write_string( + align_stockholm_pad_right( + "#=GR " + padded_name + " " + annotation.code + " ", + start, + ), + ) + output.write_string( + align_stockholm_render_letter_annotation(sequence, annotation.value), + ) + output.write_char('\n') + } + } + for annotation in alignment.column_annotations { + output.write_string( + align_stockholm_pad_right("#=GC " + annotation.code + " ", start), + ) + output.write_string(annotation.value) + output.write_char('\n') + } + output.write_string("//\n") + output.to_string() +} + +///| +/// Write concatenated Stockholm records. +pub fn align_stockholm_write_all( + alignments : Array[AlignStockholmAlignment], +) -> String raise AlignStockholmError { + let output = StringBuilder::new() + for alignment in alignments { + output.write_string(align_stockholm_write(alignment)) + } + output.to_string() +} + +///| +/// Return the number of rows. +pub fn AlignStockholmAlignment::num_sequences( + self : AlignStockholmAlignment, +) -> Int { + self.sequences.length() +} + +///| +/// Return the retained alignment width. +pub fn AlignStockholmAlignment::alignment_length( + self : AlignStockholmAlignment, +) -> Int { + if self.sequences.length() == 0 { + 0 + } else { + self.sequences[0].aligned_sequence.length() + } +} + +///| +/// Return the source width before all-gap columns were removed. +pub fn AlignStockholmAlignment::source_alignment_length( + self : AlignStockholmAlignment, +) -> Int { + self.source_columns +} + +///| +/// Find a sequence by exact identifier. +pub fn AlignStockholmAlignment::find_sequence( + self : AlignStockholmAlignment, + id : String, +) -> Int? { + for index = 0; index < self.sequences.length(); index = index + 1 { + if self.sequences[index].id == id { + return Some(index) + } + } + None +} + +///| +/// Return all GF values matching a Stockholm code or mapped feature. +pub fn AlignStockholmAlignment::annotation_values( + self : AlignStockholmAlignment, + name : String, +) -> Array[String] { + let values : Array[String] = [] + for annotation in self.annotations { + if annotation.code == name || annotation.feature == name { + values.push(annotation.value) + } + } + values +} + +///| +/// Return the first GF value matching a Stockholm code or mapped feature. +pub fn AlignStockholmAlignment::annotation( + self : AlignStockholmAlignment, + name : String, +) -> String? { + for annotation in self.annotations { + if annotation.code == name || annotation.feature == name { + return Some(annotation.value) + } + } + None +} + +///| +/// Return a GC value matching a Stockholm code or mapped feature. +pub fn AlignStockholmAlignment::column_annotation( + self : AlignStockholmAlignment, + name : String, +) -> String? { + for annotation in self.column_annotations { + if annotation.code == name || annotation.feature == name { + return Some(annotation.value) + } + } + None +} + +///| +/// Return the first GS value matching a Stockholm code or mapped feature. +pub fn AlignStockholmSequence::annotation( + self : AlignStockholmSequence, + name : String, +) -> String? { + for annotation in self.annotations { + if annotation.code == name || annotation.feature == name { + return Some(annotation.value) + } + } + None +} + +///| +/// Return a residue-level GR value matching a code or mapped feature. +pub fn AlignStockholmSequence::letter_annotation( + self : AlignStockholmSequence, + name : String, +) -> String? { + for annotation in self.letter_annotations { + if annotation.code == name || annotation.feature == name { + return Some(annotation.value) + } + } + None +} + +///| +/// Return one printed alignment column. +pub fn AlignStockholmAlignment::column( + self : AlignStockholmAlignment, + column : Int, +) -> String? { + if column < 0 || column >= self.alignment_length() { + return None + } + let output = StringBuilder::new(size_hint=self.sequences.length()) + for sequence in self.sequences { + output.write_char( + sequence.aligned_sequence.unsafe_get(column).unsafe_to_char(), + ) + } + Some(output.to_string()) +} + +///| +/// Map a zero-based ungapped sequence position to an alignment column. +pub fn AlignStockholmAlignment::sequence_position_to_column( + self : AlignStockholmAlignment, + row : Int, + position : Int, +) -> Int? { + if row < 0 || row >= self.sequences.length() || position < 0 { + return None + } + let aligned = self.sequences[row].aligned_sequence + let mut coordinate = 0 + for column = 0; column < aligned.length(); column = column + 1 { + if aligned.unsafe_get(column).to_int() != '-'.to_int() { + if coordinate == position { + return Some(column) + } + coordinate = coordinate + 1 + } + } + None +} + +///| +/// Map a retained column to a zero-based ungapped sequence position. +pub fn AlignStockholmAlignment::column_to_sequence_position( + self : AlignStockholmAlignment, + row : Int, + column : Int, +) -> Int? { + if row < 0 || + row >= self.sequences.length() || + column < 0 || + column >= self.alignment_length() { + return None + } + let aligned = self.sequences[row].aligned_sequence + if aligned.unsafe_get(column).to_int() == '-'.to_int() { + return None + } + let mut coordinate = 0 + for index = 0; index < column; index = index + 1 { + if aligned.unsafe_get(index).to_int() != '-'.to_int() { + coordinate = coordinate + 1 + } + } + Some(coordinate) +} + +///| +/// Map one residue through the alignment to another row. +pub fn AlignStockholmAlignment::map_position( + self : AlignStockholmAlignment, + source_row : Int, + target_row : Int, + source_position : Int, +) -> Int? { + if target_row < 0 || target_row >= self.sequences.length() { + return None + } + match self.sequence_position_to_column(source_row, source_position) { + Some(column) => self.column_to_sequence_position(target_row, column) + None => None + } +} + +///| +/// Return per-column residue coordinates for two rows. +pub fn AlignStockholmAlignment::aligned_pairs( + self : AlignStockholmAlignment, + first_row : Int, + second_row : Int, +) -> Array[(Int?, Int?)] raise AlignStockholmError { + align_stockholm_validate_row(self, first_row) + align_stockholm_validate_row(self, second_row) + let pairs : Array[(Int?, Int?)] = [] + let mut first_position = 0 + let mut second_position = 0 + for column = 0; column < self.alignment_length(); column = column + 1 { + let first_gap = self.sequences[first_row].aligned_sequence + .unsafe_get(column) + .to_int() == + '-'.to_int() + let second_gap = self.sequences[second_row].aligned_sequence + .unsafe_get(column) + .to_int() == + '-'.to_int() + pairs.push( + ( + if first_gap { + None + } else { + Some(first_position) + }, + if second_gap { + None + } else { + Some(second_position) + }, + ), + ) + if !first_gap { + first_position = first_position + 1 + } + if !second_gap { + second_position = second_position + 1 + } + } + pairs +} + +///| +/// Return a compact Biopython-style coordinate path for all rows. +pub fn AlignStockholmAlignment::coordinate_path( + self : AlignStockholmAlignment, +) -> Array[Array[Int]] { + let paths : Array[Array[Int]] = [] + let coordinates = Array::make(self.sequences.length(), 0) + for _row = 0; _row < self.sequences.length(); _row = _row + 1 { + paths.push([0]) + } + let width = self.alignment_length() + for column = 0; column < width; column = column + 1 { + for row = 0; row < self.sequences.length(); row = row + 1 { + if self.sequences[row].aligned_sequence.unsafe_get(column).to_int() != + '-'.to_int() { + coordinates[row] = coordinates[row] + 1 + } + } + let boundary = if column + 1 == width { + true + } else { + align_stockholm_movement_changes(self, column, column + 1) + } + if boundary { + for row = 0; row < self.sequences.length(); row = row + 1 { + paths[row].push(coordinates[row]) + } + } + } + paths +} + +///| +/// Slice retained alignment columns and all GC/GR annotations together. +pub fn AlignStockholmAlignment::slice_columns( + self : AlignStockholmAlignment, + start : Int, + end : Int, +) -> AlignStockholmAlignment raise AlignStockholmError { + if start < 0 || end <= start || end > self.alignment_length() { + raise AlignStockholmError("Invalid Stockholm column slice") + } + let sequences : Array[AlignStockholmSequence] = [] + for sequence in self.sequences { + let aligned = sequence.aligned_sequence[start:end].to_owned() + let letter_annotations : Array[AlignStockholmLetterAnnotation] = [] + for annotation in sequence.letter_annotations { + let aligned_value = annotation.aligned_value[start:end].to_owned() + let value = align_stockholm_residue_annotation_value( + aligned, aligned_value, + ) + letter_annotations.push(AlignStockholmLetterAnnotation::{ + code: annotation.code, + feature: annotation.feature, + value, + aligned_value, + }) + } + sequences.push(AlignStockholmSequence::{ + id: sequence.id, + description: sequence.description, + sequence: align_stockholm_remove_gaps(aligned), + aligned_sequence: aligned, + annotations: sequence.annotations, + dbxrefs: sequence.dbxrefs, + letter_annotations, + }) + } + let column_annotations : Array[AlignStockholmColumnAnnotation] = [] + for annotation in self.column_annotations { + column_annotations.push(AlignStockholmColumnAnnotation::{ + code: annotation.code, + feature: annotation.feature, + value: annotation.value[start:end].to_owned(), + }) + } + AlignStockholmAlignment::create( + sequences, + annotations=self.annotations, + column_annotations~, + references=self.references, + database_references=self.database_references, + nested_domains=self.nested_domains, + operations=self.operations[start:end].to_owned(), + source_columns=end - start, + ) +} + +///| +/// Compute statistics for one pair of rows. +pub fn AlignStockholmAlignment::pair_counts( + self : AlignStockholmAlignment, + first_row : Int, + second_row : Int, +) -> AlignStockholmCounts raise AlignStockholmError { + align_stockholm_validate_row(self, first_row) + align_stockholm_validate_row(self, second_row) + align_stockholm_count_pair(self, first_row, second_row) +} + +///| +/// Aggregate statistics across every unordered row pair. +pub fn AlignStockholmAlignment::counts( + self : AlignStockholmAlignment, +) -> AlignStockholmCounts { + let mut result = AlignStockholmCounts::{ + pairs: 0, + aligned: 0, + identities: 0, + mismatches: 0, + gap_columns: 0, + double_gap_columns: 0, + gap_opens: 0, + } + for first = 0; first < self.sequences.length(); first = first + 1 { + for second = first + 1 + second < self.sequences.length() + second = second + 1 { + let counts = align_stockholm_count_pair(self, first, second) + result = AlignStockholmCounts::{ + pairs: result.pairs + counts.pairs, + aligned: result.aligned + counts.aligned, + identities: result.identities + counts.identities, + mismatches: result.mismatches + counts.mismatches, + gap_columns: result.gap_columns + counts.gap_columns, + double_gap_columns: result.double_gap_columns + + counts.double_gap_columns, + gap_opens: result.gap_opens + counts.gap_opens, + } + } + } + result +} + +///| +/// Return identities divided by aligned residue pairs. +pub fn AlignStockholmCounts::identity(self : AlignStockholmCounts) -> Double { + if self.aligned == 0 { + 0.0 + } else { + self.identities.to_double() / self.aligned.to_double() + } +} + +///| +/// Calculate a majority consensus; gaps do not vote. +pub fn AlignStockholmAlignment::consensus( + self : AlignStockholmAlignment, + minimum_fraction? : Double = 0.5, + ambiguous? : String = "X", +) -> String raise AlignStockholmError { + if minimum_fraction < 0.0 || minimum_fraction > 1.0 { + raise AlignStockholmError( + "Stockholm consensus minimum fraction must be between 0 and 1", + ) + } + if ambiguous.length() != 1 { + raise AlignStockholmError( + "Stockholm consensus ambiguous symbol must be one character", + ) + } + let output = StringBuilder::new(size_hint=self.alignment_length()) + for column = 0; column < self.alignment_length(); column = column + 1 { + let symbols : Array[Int] = [] + let counts : Array[Int] = [] + let mut residues = 0 + for sequence in self.sequences { + let code = sequence.aligned_sequence.unsafe_get(column).to_int() + if code != '-'.to_int() { + residues = residues + 1 + let normalized = align_stockholm_upper_code(code) + let mut found = -1 + for index = 0; index < symbols.length(); index = index + 1 { + if symbols[index] == normalized { + found = index + break + } + } + if found < 0 { + symbols.push(normalized) + counts.push(1) + } else { + counts[found] = counts[found] + 1 + } + } + } + if residues == 0 { + output.write_string(ambiguous) + continue + } + let mut best = 0 + for index = 1; index < counts.length(); index = index + 1 { + if counts[index] > counts[best] || + (counts[index] == counts[best] && symbols[index] < symbols[best]) { + best = index + } + } + if counts[best].to_double() / residues.to_double() >= minimum_fraction { + output.write_char(symbols[best].unsafe_to_char()) + } else { + output.write_string(ambiguous) + } + } + output.to_string() +} + +///| +/// Return per-column non-gap occupancy. +pub fn AlignStockholmAlignment::occupancy( + self : AlignStockholmAlignment, +) -> Array[Double] { + let values : Array[Double] = [] + for column = 0; column < self.alignment_length(); column = column + 1 { + let mut residues = 0 + for sequence in self.sequences { + if sequence.aligned_sequence.unsafe_get(column).to_int() != '-'.to_int() { + residues = residues + 1 + } + } + values.push( + if self.sequences.length() == 0 { + 0.0 + } else { + residues.to_double() / self.sequences.length().to_double() + }, + ) + } + values +} + +///| +/// Return a compact alignment summary. +pub fn AlignStockholmAlignment::summary( + self : AlignStockholmAlignment, +) -> String { + "AlignStockholmAlignment(version=" + + self.version + + ", sequences=" + + self.num_sequences().to_string() + + ", columns=" + + self.alignment_length().to_string() + + ", source_columns=" + + self.source_columns.to_string() + + ", removed_all_gap=" + + self.removed_all_gap_columns.to_string() + + ")" +} + +///| +/// Official Biopython HAT fixture used by the example and black-box tests. +pub fn align_stockholm_example_text() -> String { + "# STOCKHOLM 1.0\n" + + "#=GF ID HAT\n" + + "#=GF AC PF02184.18\n" + + "#=GF DE HAT (Half-A-TPR) repeat\n" + + "#=GF AU SMART;\n" + + "#=GF SE Alignment kindly provided by SMART\n" + + "#=GF GA 21.00 21.00;\n" + + "#=GF TC 21.00 21.00;\n" + + "#=GF NC 20.90 20.90;\n" + + "#=GF BM hmmbuild HMM.ann SEED.ann\n" + + "#=GF SM hmmsearch -Z 57096847 -E 1000 --cpu 4 HMM pfamseq\n" + + "#=GF TP Repeat\n" + + "#=GF CL CL0020\n" + + "#=GF RN [1]\n" + + "#=GF RM 9478129\n" + + "#=GF RT The HAT helix, a repetitive motif implicated in RNA processing.\n" + + "#=GF RA Preker PJ, Keller W;\n" + + "#=GF RL Trends Biochem Sci 1998;23:15-16.\n" + + "#=GF DR INTERPRO; IPR003107;\n" + + "#=GF DR SMART; HAT;\n" + + "#=GF DR SO; 0001068; polypeptide_repeat;\n" + + "#=GF CC The HAT (Half A TPR) repeat is found in several RNA processing\n" + + "#=GF CC proteins [1].\n" + + "#=GF SQ 3\n" + + "#=GS CRN_DROME/191-222 AC P17886.2\n" + + "#=GS CLF1_SCHPO/185-216 AC P87312.1\n" + + "#=GS CLF1_SCHPO/185-216 DR PDB; 3JB9 R; 185-216;\n" + + "#=GS O16376_CAEEL/201-233 AC O16376.2\n" + + "CRN_DROME/191-222 KEIDRAREIYERFVYVH.PDVKNWIKFARFEES\n" + + "CLF1_SCHPO/185-216 HENERARGIYERFVVVH.PEVTNWLRWARFEEE\n" + + "#=GR CLF1_SCHPO/185-216 SS --HHHHHHHHHHHHHHS.--HHHHHHHHHHHHH\n" + + "O16376_CAEEL/201-233 KEIDRARSVYQRFLHVHGINVQNWIKYAKFEER\n" + + "#=GC SS_cons --HHHHHHHHHHHHHHS.--HHHHHHHHHHHHH\n" + + "#=GC seq_cons KEIDRARuIYERFVaVH.P-VpNWIKaARFEEc\n" + + "//\n" +} + +///| +fn align_stockholm_parse_record( + lines : Array[String], + start : Int, + end : Int, +) -> AlignStockholmAlignment raise AlignStockholmError { + let ids : Array[String] = [] + let rows : Array[String] = [] + let gf : Array[AlignStockholmRawAnnotation] = [] + let gs : Array[AlignStockholmRawSequenceAnnotation] = [] + let gc : Array[AlignStockholmRawAnnotation] = [] + let gr : Array[AlignStockholmRawSequenceAnnotation] = [] + let mut last_sequence_id = "" + for line_index = start; line_index < end; line_index = line_index + 1 { + let line = lines[line_index].trim().to_owned() + if line.length() == 0 { + continue + } + if align_stockholm_starts_with(line, "#=GF") { + let rest = align_stockholm_markup_rest(line, "#=GF", line_index) + let fields = align_stockholm_take_fields(rest, 1) + if fields.0.length() != 1 || fields.1.length() == 0 { + raise AlignStockholmError( + "Malformed GF annotation at line " + (line_index + 1).to_string(), + ) + } + gf.push(AlignStockholmRawAnnotation::{ + code: fields.0[0], + value: fields.1, + }) + continue + } + if align_stockholm_starts_with(line, "#=GS") { + let rest = align_stockholm_markup_rest(line, "#=GS", line_index) + let fields = align_stockholm_take_fields(rest, 2) + if fields.0.length() != 2 { + raise AlignStockholmError( + "Malformed GS annotation at line " + (line_index + 1).to_string(), + ) + } + gs.push(AlignStockholmRawSequenceAnnotation::{ + sequence_id: fields.0[0], + code: fields.0[1], + value: fields.1, + }) + continue + } + if align_stockholm_starts_with(line, "#=GC") { + let rest = align_stockholm_markup_rest(line, "#=GC", line_index) + let fields = align_stockholm_take_fields(rest, 1) + if fields.0.length() != 1 || fields.1.length() == 0 { + raise AlignStockholmError( + "Malformed GC annotation at line " + (line_index + 1).to_string(), + ) + } + align_stockholm_append_raw(gc, fields.0[0], fields.1) + continue + } + if align_stockholm_starts_with(line, "#=GR") { + let rest = align_stockholm_markup_rest(line, "#=GR", line_index) + let fields = align_stockholm_take_fields(rest, 2) + if fields.0.length() != 2 || fields.1.length() == 0 { + raise AlignStockholmError( + "Malformed GR annotation at line " + (line_index + 1).to_string(), + ) + } + if last_sequence_id.length() == 0 || fields.0[0] != last_sequence_id { + raise AlignStockholmError("GR annotation must follow its sequence row") + } + for annotation in gr { + if annotation.sequence_id == fields.0[0] && + annotation.code == fields.0[1] { + raise AlignStockholmError( + "Duplicate GR annotation " + fields.0[1] + " for " + fields.0[0], + ) + } + } + gr.push(AlignStockholmRawSequenceAnnotation::{ + sequence_id: fields.0[0], + code: fields.0[1], + value: fields.1, + }) + continue + } + if line.unsafe_get(0).to_int() == '#'.to_int() { + continue + } + let tokens = align_stockholm_split_whitespace(line) + if tokens.length() != 2 { + raise AlignStockholmError( + "Could not split Stockholm sequence line " + + (line_index + 1).to_string() + + " into identifier and aligned sequence", + ) + } + align_stockholm_validate_id(tokens[0]) + for existing in ids { + if existing == tokens[0] { + raise AlignStockholmError( + "Duplicate Stockholm sequence identifier " + tokens[0], + ) + } + } + if rows.length() > 0 && tokens[1].length() != rows[0].length() { + raise AlignStockholmError( + "Aligned sequence " + + tokens[0] + + " consists of " + + tokens[1].length().to_string() + + " letters, expected " + + rows[0].length().to_string() + + " letters", + ) + } + if tokens[1].length() == 0 { + raise AlignStockholmError("Stockholm sequence row must not be empty") + } + align_stockholm_validate_printed_row(tokens[1]) + ids.push(tokens[0]) + rows.push(tokens[1]) + last_sequence_id = tokens[0] + } + if ids.length() == 0 { + raise AlignStockholmError( + "Stockholm alignment must contain at least one sequence", + ) + } + let prepared = align_stockholm_prepare_rows(rows) + if prepared.0[0].length() == 0 { + raise AlignStockholmError( + "Stockholm alignment contains no non-gap alignment column", + ) + } + let annotations = align_stockholm_build_gf(gf, ids.length()) + let references = align_stockholm_build_references(gf) + let database_references = align_stockholm_build_database_references(gf) + let nested_domains = align_stockholm_build_nested_domains(gf) + let column_annotations = align_stockholm_build_gc( + gc, + rows[0].length(), + prepared.2, + ) + let sequences : Array[AlignStockholmSequence] = [] + for row_index = 0; row_index < ids.length(); row_index = row_index + 1 { + let sequence_annotations : Array[AlignStockholmAnnotation] = [] + let dbxrefs : Array[String] = [] + let mut description = "" + for annotation in gs { + if annotation.sequence_id != ids[row_index] { + continue + } + if annotation.code == "DR" { + dbxrefs.push(annotation.value) + continue + } + if annotation.code == "DE" { + if description.length() > 0 { + raise AlignStockholmError( + "Duplicate GS DE annotation for " + ids[row_index], + ) + } + description = annotation.value + continue + } + for existing in sequence_annotations { + if existing.code == annotation.code { + raise AlignStockholmError( + "Duplicate GS annotation " + + annotation.code + + " for " + + ids[row_index], + ) + } + } + sequence_annotations.push(AlignStockholmAnnotation::{ + code: annotation.code, + feature: align_stockholm_gs_feature(annotation.code), + value: annotation.value, + }) + } + let letter_annotations : Array[AlignStockholmLetterAnnotation] = [] + for annotation in gr { + if annotation.sequence_id != ids[row_index] { + continue + } + if annotation.value.length() != rows[0].length() { + raise AlignStockholmError( + "GR " + + annotation.code + + " length is " + + annotation.value.length().to_string() + + ", expected " + + rows[0].length().to_string(), + ) + } + let aligned_value = align_stockholm_remove_columns( + annotation.value, + prepared.2, + ) + let value = if annotation.code == "CSA" { + align_stockholm_remove_character(annotation.value, '-'.to_int()) + } else { + align_stockholm_remove_character(annotation.value, '.'.to_int()) + } + let ungapped = align_stockholm_remove_gaps(prepared.0[row_index]) + if value.length() != ungapped.length() { + raise AlignStockholmError( + "GR " + + annotation.code + + " does not contain one value per residue for " + + ids[row_index], + ) + } + letter_annotations.push(AlignStockholmLetterAnnotation::{ + code: annotation.code, + feature: align_stockholm_gr_feature(annotation.code), + value, + aligned_value, + }) + } + sequences.push(AlignStockholmSequence::{ + id: ids[row_index], + description, + sequence: align_stockholm_remove_gaps(prepared.0[row_index]), + aligned_sequence: prepared.0[row_index], + annotations: sequence_annotations, + dbxrefs, + letter_annotations, + }) + } + for annotation in gs { + if align_stockholm_find_string(ids, annotation.sequence_id) < 0 { + raise AlignStockholmError( + "Failed to find GS sequence " + annotation.sequence_id, + ) + } + } + for annotation in gr { + if align_stockholm_find_string(ids, annotation.sequence_id) < 0 { + raise AlignStockholmError( + "Failed to find GR sequence " + annotation.sequence_id, + ) + } + } + AlignStockholmAlignment::create( + sequences, + annotations~, + column_annotations~, + references~, + database_references~, + nested_domains~, + operations=prepared.1, + source_columns=rows[0].length(), + removed_all_gap_columns=align_stockholm_count_true(prepared.2), + ) +} + +///| +fn align_stockholm_build_gf( + raw : Array[AlignStockholmRawAnnotation], + rows : Int, +) -> Array[AlignStockholmAnnotation] raise AlignStockholmError { + let annotations : Array[AlignStockholmAnnotation] = [] + let codes = [ + "ID", "AC", "DE", "AU", "SE", "SS", "GA", "TC", "NC", "BM", "SM", "TP", "PI", + "CL", "WK", "CB", "**", "CC", + ] + for code in codes { + let values : Array[String] = [] + for annotation in raw { + if annotation.code == code { + values.push(annotation.value) + } + } + if values.length() == 0 { + continue + } + if code == "AU" { + for value in values { + annotations.push(AlignStockholmAnnotation::{ + code, + feature: align_stockholm_gf_feature(code), + value, + }) + } + } else if code == "WK" { + let merged = align_stockholm_merge_wikipedia(values) + for value in merged { + annotations.push(AlignStockholmAnnotation::{ + code, + feature: align_stockholm_gf_feature(code), + value, + }) + } + } else if code == "SM" || code == "CC" || code == "**" { + annotations.push(AlignStockholmAnnotation::{ + code, + feature: align_stockholm_gf_feature(code), + value: align_stockholm_join(values, " "), + }) + } else { + if values.length() != 1 { + raise AlignStockholmError("GF " + code + " must occur at most once") + } + annotations.push(AlignStockholmAnnotation::{ + code, + feature: align_stockholm_gf_feature(code), + value: values[0], + }) + } + } + let sq_values : Array[String] = [] + for annotation in raw { + if annotation.code == "SQ" { + sq_values.push(annotation.value) + } + } + if sq_values.length() > 1 { + raise AlignStockholmError("GF SQ must occur at most once") + } + if sq_values.length() == 1 { + let declared = align_stockholm_parse_positive_int( + sq_values[0], + "Stockholm GF SQ", + ) + if declared != rows { + raise AlignStockholmError( + "Inconsistent number of sequences in Stockholm alignment", + ) + } + } + annotations +} + +///| +fn align_stockholm_build_references( + raw : Array[AlignStockholmRawAnnotation], +) -> Array[AlignStockholmReference] raise AlignStockholmError { + let builders : Array[AlignStockholmReferenceBuilder] = [] + let pending_comments : Array[String] = [] + for annotation in raw { + if annotation.code == "RC" { + pending_comments.push(annotation.value) + } else if annotation.code == "RN" { + let value = annotation.value + if value.length() < 3 || + value.unsafe_get(0).to_int() != '['.to_int() || + value.unsafe_get(value.length() - 1).to_int() != ']'.to_int() { + raise AlignStockholmError("Malformed Stockholm GF RN annotation") + } + let number = align_stockholm_parse_positive_int( + value[1:value.length() - 1].to_owned(), + "Stockholm reference number", + ) + builders.push(AlignStockholmReferenceBuilder::{ + number, + medline: "", + title: "", + author: "", + location: "", + comment: align_stockholm_join(pending_comments, " "), + }) + pending_comments.clear() + } else if annotation.code == "RM" || + annotation.code == "RT" || + annotation.code == "RA" || + annotation.code == "RL" { + if builders.length() == 0 { + raise AlignStockholmError( + "Stockholm GF " + annotation.code + " appears before GF RN", + ) + } + let last = builders.length() - 1 + if annotation.code == "RM" { + if builders[last].medline.length() > 0 { + raise AlignStockholmError("Duplicate Stockholm GF RM annotation") + } + builders[last].medline = annotation.value + } else if annotation.code == "RT" { + builders[last].title = align_stockholm_append_text( + builders[last].title, + annotation.value, + ) + } else if annotation.code == "RA" { + builders[last].author = align_stockholm_append_text( + builders[last].author, + annotation.value, + ) + } else { + builders[last].location = align_stockholm_append_text( + builders[last].location, + annotation.value, + ) + } + } + } + if pending_comments.length() > 0 { + raise AlignStockholmError( + "Stockholm GF RC annotation is not followed by GF RN", + ) + } + let references : Array[AlignStockholmReference] = [] + for builder in builders { + references.push(AlignStockholmReference::{ + number: builder.number, + medline: builder.medline, + title: builder.title, + author: builder.author, + location: builder.location, + comment: builder.comment, + }) + } + references +} + +///| +fn align_stockholm_build_database_references( + raw : Array[AlignStockholmRawAnnotation], +) -> Array[AlignStockholmDatabaseReference] raise AlignStockholmError { + let builders : Array[AlignStockholmDatabaseReferenceBuilder] = [] + for annotation in raw { + if annotation.code == "DR" { + builders.push(AlignStockholmDatabaseReferenceBuilder::{ + reference: annotation.value, + comment: "", + }) + } else if annotation.code == "DC" { + if builders.length() == 0 { + raise AlignStockholmError( + "Stockholm GF DC appears before a database reference", + ) + } + let last = builders.length() - 1 + if builders[last].comment.length() > 0 { + raise AlignStockholmError("Duplicate Stockholm GF DC annotation") + } + builders[last].comment = annotation.value + } + } + let references : Array[AlignStockholmDatabaseReference] = [] + for builder in builders { + references.push(AlignStockholmDatabaseReference::{ + reference: builder.reference, + comment: builder.comment, + }) + } + references +} + +///| +fn align_stockholm_build_nested_domains( + raw : Array[AlignStockholmRawAnnotation], +) -> Array[AlignStockholmNestedDomain] raise AlignStockholmError { + let builders : Array[AlignStockholmNestedDomainBuilder] = [] + for annotation in raw { + if annotation.code == "NE" { + builders.push(AlignStockholmNestedDomainBuilder::{ + accession: annotation.value, + location: "", + }) + } else if annotation.code == "NL" { + if builders.length() == 0 { + raise AlignStockholmError( + "Stockholm GF NL appears before a nested domain", + ) + } + let last = builders.length() - 1 + if builders[last].location.length() > 0 { + raise AlignStockholmError("Duplicate Stockholm GF NL annotation") + } + builders[last].location = annotation.value + } + } + let domains : Array[AlignStockholmNestedDomain] = [] + for builder in builders { + domains.push(AlignStockholmNestedDomain::{ + accession: builder.accession, + location: builder.location, + }) + } + domains +} + +///| +fn align_stockholm_build_gc( + raw : Array[AlignStockholmRawAnnotation], + source_width : Int, + removed : Array[Bool], +) -> Array[AlignStockholmColumnAnnotation] raise AlignStockholmError { + let annotations : Array[AlignStockholmColumnAnnotation] = [] + for annotation in raw { + if annotation.value.length() != source_width { + raise AlignStockholmError( + "GC " + + annotation.code + + " length is " + + annotation.value.length().to_string() + + ", expected " + + source_width.to_string(), + ) + } + annotations.push(AlignStockholmColumnAnnotation::{ + code: annotation.code, + feature: align_stockholm_gc_feature(annotation.code), + value: align_stockholm_remove_columns(annotation.value, removed), + }) + } + annotations +} + +///| +fn align_stockholm_prepare_rows( + rows : Array[String], +) -> (Array[String], String, Array[Bool]) raise AlignStockholmError { + if rows.length() == 0 { + raise AlignStockholmError( + "Stockholm alignment must contain at least one sequence", + ) + } + let width = rows[0].length() + let operations = Array::make(width, 'M'.to_int()) + let all_gap = Array::make(width, true) + for row in rows { + if row.length() != width { + raise AlignStockholmError("Stockholm aligned rows must have equal widths") + } + align_stockholm_validate_printed_row(row) + for column = 0; column < width; column = column + 1 { + let code = row.unsafe_get(column).to_int() + if code == '-'.to_int() { + if operations[column] == 'I'.to_int() { + raise AlignStockholmError( + "Stockholm column mixes insertion and deletion gap symbols", + ) + } + operations[column] = 'D'.to_int() + } else if code == '.'.to_int() { + if operations[column] == 'D'.to_int() { + raise AlignStockholmError( + "Stockholm column mixes insertion and deletion gap symbols", + ) + } + operations[column] = 'I'.to_int() + } else { + all_gap[column] = false + } + } + } + let normalized : Array[String] = [] + for row in rows { + let output = StringBuilder::new(size_hint=width) + for column = 0; column < width; column = column + 1 { + if !all_gap[column] { + let code = row.unsafe_get(column).to_int() + output.write_char( + (if code == '.'.to_int() { '-'.to_int() } else { code }).unsafe_to_char(), + ) + } + } + normalized.push(output.to_string()) + } + let operation_output = StringBuilder::new(size_hint=width) + for column = 0; column < width; column = column + 1 { + if !all_gap[column] { + operation_output.write_char(operations[column].unsafe_to_char()) + } + } + (normalized, operation_output.to_string(), all_gap) +} + +///| +fn align_stockholm_validate_alignment( + alignment : AlignStockholmAlignment, +) -> Unit raise AlignStockholmError { + if alignment.version != "1.0" { + raise AlignStockholmError("Only Stockholm version 1.0 is supported") + } + if alignment.sequences.length() == 0 { + raise AlignStockholmError( + "Stockholm alignment must contain at least one sequence", + ) + } + let width = alignment.sequences[0].aligned_sequence.length() + if width == 0 { + raise AlignStockholmError( + "Stockholm alignment must contain at least one column", + ) + } + let ids : Array[String] = [] + for sequence in alignment.sequences { + align_stockholm_validate_id(sequence.id) + if align_stockholm_find_string(ids, sequence.id) >= 0 { + raise AlignStockholmError( + "Duplicate Stockholm sequence identifier " + sequence.id, + ) + } + ids.push(sequence.id) + if sequence.aligned_sequence.length() != width { + raise AlignStockholmError("Stockholm aligned rows must have equal widths") + } + if sequence.sequence != + align_stockholm_remove_gaps(sequence.aligned_sequence) { + raise AlignStockholmError( + "Stockholm ungapped sequence does not match aligned row", + ) + } + align_stockholm_validate_sequence_annotations(sequence) + } + if alignment.operations.length() != width { + raise AlignStockholmError( + "Stockholm operations length must match alignment width", + ) + } + for column = 0; column < width; column = column + 1 { + let operation = alignment.operations.unsafe_get(column).to_int() + if operation != 'M'.to_int() && + operation != 'D'.to_int() && + operation != 'I'.to_int() { + raise AlignStockholmError( + "Stockholm operations may contain only M, D, and I", + ) + } + let mut all_gap = true + let mut has_gap = false + for sequence in alignment.sequences { + if sequence.aligned_sequence.unsafe_get(column).to_int() == '-'.to_int() { + has_gap = true + } else { + all_gap = false + } + } + if all_gap { + raise AlignStockholmError( + "Stockholm alignment must not retain all-gap columns", + ) + } + if operation == 'M'.to_int() && has_gap { + raise AlignStockholmError( + "Stockholm match operation cannot contain a gap", + ) + } + } + for annotation in alignment.column_annotations { + if annotation.code.length() == 0 { + raise AlignStockholmError("Stockholm GC code must not be empty") + } + if annotation.value.length() != width { + raise AlignStockholmError( + "Stockholm GC annotation length must match alignment width", + ) + } + } + if alignment.removed_all_gap_columns < 0 || + alignment.source_columns != width + alignment.removed_all_gap_columns { + raise AlignStockholmError("Invalid Stockholm source-column metadata") + } +} + +///| +fn align_stockholm_validate_sequence_annotations( + sequence : AlignStockholmSequence, +) -> Unit raise AlignStockholmError { + for annotation in sequence.annotations { + if annotation.code.length() == 0 { + raise AlignStockholmError("Stockholm GS code must not be empty") + } + } + for annotation in sequence.letter_annotations { + if annotation.code.length() == 0 { + raise AlignStockholmError("Stockholm GR code must not be empty") + } + if annotation.value.length() != sequence.sequence.length() { + raise AlignStockholmError( + "Stockholm GR residue annotation length must match sequence length", + ) + } + if annotation.aligned_value.length() != sequence.aligned_sequence.length() { + raise AlignStockholmError( + "Stockholm aligned GR annotation length must match alignment width", + ) + } + } +} + +///| +fn align_stockholm_count_pair( + alignment : AlignStockholmAlignment, + first_row : Int, + second_row : Int, +) -> AlignStockholmCounts { + let mut aligned = 0 + let mut identities = 0 + let mut mismatches = 0 + let mut gap_columns = 0 + let mut double_gap_columns = 0 + let mut gap_opens = 0 + let mut previous_gap_state = 0 + for column = 0; column < alignment.alignment_length(); column = column + 1 { + let first = alignment.sequences[first_row].aligned_sequence + .unsafe_get(column) + .to_int() + let second = alignment.sequences[second_row].aligned_sequence + .unsafe_get(column) + .to_int() + let first_gap = first == '-'.to_int() + let second_gap = second == '-'.to_int() + let gap_state = if first_gap && second_gap { + 3 + } else if first_gap { + 1 + } else if second_gap { + 2 + } else { + 0 + } + if gap_state == 0 { + aligned = aligned + 1 + if align_stockholm_upper_code(first) == align_stockholm_upper_code(second) { + identities = identities + 1 + } else { + mismatches = mismatches + 1 + } + } else { + if gap_state == 3 { + double_gap_columns = double_gap_columns + 1 + } else { + gap_columns = gap_columns + 1 + } + if gap_state != previous_gap_state { + gap_opens = gap_opens + 1 + } + } + previous_gap_state = gap_state + } + AlignStockholmCounts::{ + pairs: 1, + aligned, + identities, + mismatches, + gap_columns, + double_gap_columns, + gap_opens, + } +} + +///| +fn align_stockholm_movement_changes( + alignment : AlignStockholmAlignment, + first_column : Int, + second_column : Int, +) -> Bool { + for sequence in alignment.sequences { + let first_gap = sequence.aligned_sequence.unsafe_get(first_column).to_int() == + '-'.to_int() + let second_gap = sequence.aligned_sequence + .unsafe_get(second_column) + .to_int() == + '-'.to_int() + if first_gap != second_gap { + return true + } + } + false +} + +///| +fn align_stockholm_gf_feature(code : String) -> String { + match code { + "ID" => "identifier" + "AC" => "accession" + "DE" => "definition" + "AU" => "author" + "SE" => "source of seed" + "SS" => "source of structure" + "GA" => "gathering method" + "TC" => "trusted cutoff" + "NC" => "noise cutoff" + "BM" => "build method" + "SM" => "search method" + "TP" => "type" + "PI" => "previous identifier" + "CC" => "comment" + "CL" => "clan" + "WK" => "wikipedia" + "CB" => "calibration method" + "**" => "**" + _ => code + } +} + +///| +fn align_stockholm_gs_feature(code : String) -> String { + match code { + "AC" => "accession" + "OS" => "organism" + "OC" => "organism classification" + "LO" => "look" + _ => code + } +} + +///| +fn align_stockholm_gr_feature(code : String) -> String { + match code { + "SS" => "secondary structure" + "PP" => "posterior probability" + "CSA" => "Catalytic Site Atlas" + "SA" => "surface accessibility" + "TM" => "transmembrane" + "LI" => "ligand binding" + "AS" => "active site" + "pAS" => "active site - Pfam predicted" + "sAS" => "active site - from SwissProt" + "IN" => "intron" + _ => code + } +} + +///| +fn align_stockholm_gc_feature(code : String) -> String { + match code { + "RF" => "reference coordinate annotation" + "seq_cons" => "consensus sequence" + "scorecons" => "consensus score" + "scorecons_70" => "consensus score 70" + "scorecons_80" => "consensus score 80" + "scorecons_90" => "consensus score 90" + "MM" => "model mask" + "SS_cons" => "consensus secondary structure" + "PP_cons" => "consensus posterior probability" + "CSA_cons" => "consensus Catalytic Site Atlas" + "SA_cons" => "consensus surface accessibility" + "TM_cons" => "consensus transmembrane" + "LI_cons" => "consensus ligand binding" + "AS_cons" => "consensus active site" + "pAS_cons" => "consensus active site - Pfam predicted" + "sAS_cons" => "consensus active site - from SwissProt" + "IN_cons" => "consensus intron" + "RNA_elements" => "RNA elements" + "RNA_structural_element" => "RNA structural element" + "RNA_structural_elements" => "RNA structural elements" + "RNA_ligand_AdoCbl" => "RNA ligand AdoCbl" + "RNA_ligand_AqCbl" => "RNA ligand AqCbl" + "RNA_ligand_FMN" => "RNA ligand FMN" + "RNA_ligand_Guanidinium" => "RNA ligand Guanidinium" + "RNA_ligand_SAM" => "RNA ligand SAM" + "RNA_ligand_THF_1" => "RNA ligand THF 1" + "RNA_ligand_THF_2" => "RNA ligand THF 2" + "RNA_ligand_TPP" => "RNA ligand TPP" + "RNA_ligand_preQ1" => "RNA ligand preQ1" + "RNA_motif_k_turn" => "RNA motif k turn" + "Repeat_unit" => "Repeat unit" + "2L3J_B_SS" => "2L3J B SS" + "CORE" => "CORE" + "PK" => "PK" + "PK_SS" => "PK SS" + "cons" => "cons" + _ => code + } +} + +///| +fn align_stockholm_is_known_gf(code : String) -> Bool { + code == "ID" || + code == "AC" || + code == "DE" || + code == "AU" || + code == "SE" || + code == "SS" || + code == "GA" || + code == "TC" || + code == "NC" || + code == "BM" || + code == "SM" || + code == "TP" || + code == "PI" || + code == "CC" || + code == "CL" || + code == "WK" || + code == "CB" || + code == "**" +} + +///| +fn align_stockholm_infer_operations( + sequences : Array[AlignStockholmSequence], +) -> String { + let width = if sequences.length() == 0 { + 0 + } else { + sequences[0].aligned_sequence.length() + } + let output = StringBuilder::new(size_hint=width) + for column = 0; column < width; column = column + 1 { + let mut has_gap = false + for sequence in sequences { + if sequence.aligned_sequence.unsafe_get(column).to_int() == '-'.to_int() { + has_gap = true + break + } + } + output.write_char(if has_gap { 'D' } else { 'M' }) + } + output.to_string() +} + +///| +fn align_stockholm_render_row(row : String, operations : String) -> String { + let output = StringBuilder::new(size_hint=row.length()) + for column = 0; column < row.length(); column = column + 1 { + let code = row.unsafe_get(column).to_int() + if code == '-'.to_int() && + operations.unsafe_get(column).to_int() == 'I'.to_int() { + output.write_char('.') + } else { + output.write_char(code.unsafe_to_char()) + } + } + output.to_string() +} + +///| +fn align_stockholm_render_letter_annotation( + sequence : AlignStockholmSequence, + value : String, +) -> String { + let output = StringBuilder::new(size_hint=sequence.aligned_sequence.length()) + let mut residue = 0 + for column = 0 + column < sequence.aligned_sequence.length() + column = column + 1 { + if sequence.aligned_sequence.unsafe_get(column).to_int() == '-'.to_int() { + output.write_char('.') + } else { + output.write_char(value.unsafe_get(residue).unsafe_to_char()) + residue = residue + 1 + } + } + output.to_string() +} + +///| +fn align_stockholm_residue_annotation_value( + aligned_sequence : String, + aligned_value : String, +) -> String { + let output = StringBuilder::new() + for column = 0; column < aligned_sequence.length(); column = column + 1 { + if aligned_sequence.unsafe_get(column).to_int() != '-'.to_int() { + output.write_char(aligned_value.unsafe_get(column).unsafe_to_char()) + } + } + output.to_string() +} + +///| +fn align_stockholm_remove_columns( + value : String, + removed : Array[Bool], +) -> String { + let output = StringBuilder::new(size_hint=value.length()) + for index = 0; index < value.length(); index = index + 1 { + if !removed[index] { + output.write_char(value.unsafe_get(index).unsafe_to_char()) + } + } + output.to_string() +} + +///| +fn align_stockholm_count_true(values : Array[Bool]) -> Int { + let mut count = 0 + for value in values { + if value { + count = count + 1 + } + } + count +} + +///| +fn align_stockholm_remove_gaps(sequence : String) -> String { + let output = StringBuilder::new(size_hint=sequence.length()) + for index = 0; index < sequence.length(); index = index + 1 { + let code = sequence.unsafe_get(index).to_int() + if code != '-'.to_int() && code != '.'.to_int() { + output.write_char(code.unsafe_to_char()) + } + } + output.to_string() +} + +///| +fn align_stockholm_remove_character(value : String, target : Int) -> String { + let output = StringBuilder::new(size_hint=value.length()) + for index = 0; index < value.length(); index = index + 1 { + let code = value.unsafe_get(index).to_int() + if code != target { + output.write_char(code.unsafe_to_char()) + } + } + output.to_string() +} + +///| +fn align_stockholm_normalize_row( + row : String, +) -> String raise AlignStockholmError { + align_stockholm_validate_printed_row(row) + let output = StringBuilder::new(size_hint=row.length()) + for index = 0; index < row.length(); index = index + 1 { + let code = row.unsafe_get(index).to_int() + output.write_char( + (if code == '.'.to_int() { '-'.to_int() } else { code }).unsafe_to_char(), + ) + } + output.to_string() +} + +///| +fn align_stockholm_validate_printed_row( + row : String, +) -> Unit raise AlignStockholmError { + for index = 0; index < row.length(); index = index + 1 { + let code = row.unsafe_get(index).to_int() + if align_stockholm_is_whitespace(code) || code < 33 || code > 126 { + raise AlignStockholmError( + "Stockholm sequence rows may contain only printable non-space ASCII", + ) + } + } +} + +///| +fn align_stockholm_validate_id(id : String) -> Unit raise AlignStockholmError { + if id.length() == 0 { + raise AlignStockholmError("Stockholm sequence identifier must not be empty") + } + for index = 0; index < id.length(); index = index + 1 { + let code = id.unsafe_get(index).to_int() + if align_stockholm_is_whitespace(code) || code < 33 || code > 126 { + raise AlignStockholmError( + "Stockholm sequence identifiers may not contain whitespace", + ) + } + } +} + +///| +fn align_stockholm_validate_annotation_code( + code : String, +) -> Unit raise AlignStockholmError { + if code.length() == 0 { + raise AlignStockholmError("Stockholm annotation code must not be empty") + } + for index = 0; index < code.length(); index = index + 1 { + let value = code.unsafe_get(index).to_int() + if align_stockholm_is_whitespace(value) || value < 33 || value > 126 { + raise AlignStockholmError( + "Stockholm annotation codes may not contain whitespace", + ) + } + } +} + +///| +fn align_stockholm_validate_row( + alignment : AlignStockholmAlignment, + row : Int, +) -> Unit raise AlignStockholmError { + if row < 0 || row >= alignment.sequences.length() { + raise AlignStockholmError( + "Stockholm row index " + row.to_string() + " is out of range", + ) + } +} + +///| +fn align_stockholm_append_raw( + values : Array[AlignStockholmRawAnnotation], + code : String, + value : String, +) -> Unit { + for index = 0; index < values.length(); index = index + 1 { + if values[index].code == code { + values[index] = AlignStockholmRawAnnotation::{ + code, + value: values[index].value + value, + } + return + } + } + values.push(AlignStockholmRawAnnotation::{ code, value }) +} + +///| +fn align_stockholm_markup_rest( + line : String, + prefix : String, + line_index : Int, +) -> String raise AlignStockholmError { + if line.length() == prefix.length() || + !align_stockholm_is_whitespace(line.unsafe_get(prefix.length()).to_int()) { + raise AlignStockholmError( + "Malformed Stockholm markup at line " + (line_index + 1).to_string(), + ) + } + line[prefix.length():].to_owned().trim().to_owned() +} + +///| +fn align_stockholm_take_fields( + value : String, + count : Int, +) -> (Array[String], String) { + let fields : Array[String] = [] + let mut index = 0 + while fields.length() < count { + while index < value.length() && + align_stockholm_is_whitespace(value.unsafe_get(index).to_int()) { + index = index + 1 + } + if index >= value.length() { + break + } + let start = index + while index < value.length() && + !align_stockholm_is_whitespace(value.unsafe_get(index).to_int()) { + index = index + 1 + } + fields.push(value[start:index].to_owned()) + } + while index < value.length() && + align_stockholm_is_whitespace(value.unsafe_get(index).to_int()) { + index = index + 1 + } + (fields, if index < value.length() { value[index:].to_owned() } else { "" }) +} + +///| +fn align_stockholm_split_whitespace(value : String) -> Array[String] { + let fields : Array[String] = [] + let mut index = 0 + while index < value.length() { + while index < value.length() && + align_stockholm_is_whitespace(value.unsafe_get(index).to_int()) { + index = index + 1 + } + if index >= value.length() { + break + } + let start = index + while index < value.length() && + !align_stockholm_is_whitespace(value.unsafe_get(index).to_int()) { + index = index + 1 + } + fields.push(value[start:index].to_owned()) + } + fields +} + +///| +fn align_stockholm_merge_wikipedia(values : Array[String]) -> Array[String] { + let merged : Array[String] = [] + let mut index = 0 + while index < values.length() { + let output = StringBuilder::new() + let mut value = values[index] + while value.length() > 0 && + value.unsafe_get(value.length() - 1).to_int() == '/'.to_int() && + index + 1 < values.length() { + output.write_string(value[0:value.length() - 1].to_owned()) + index = index + 1 + value = values[index] + } + output.write_string(value) + merged.push(output.to_string()) + index = index + 1 + } + merged +} + +///| +fn align_stockholm_wrap_text(prefix : String, text : String) -> String { + if text.length() == 0 { + return prefix + "\n" + } + let words = align_stockholm_split_whitespace(text) + if words.length() == 0 { + return prefix + "\n" + } + let output = StringBuilder::new() + let mut line = prefix + for word in words { + let separator = if line.length() == prefix.length() { "" } else { " " } + if line.length() > prefix.length() && line.length() + 1 + word.length() > 79 { + output.write_string(line) + output.write_char('\n') + line = prefix + word + } else { + line = line + separator + word + } + } + output.write_string(line) + output.write_char('\n') + output.to_string() +} + +///| +fn align_stockholm_parse_positive_int( + text : String, + label : String, +) -> Int raise AlignStockholmError { + if text.length() == 0 { + raise AlignStockholmError(label + " is empty") + } + let mut value = 0 + for index = 0; index < text.length(); index = index + 1 { + let code = text.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + raise AlignStockholmError(label + " must be a positive integer") + } + let digit = code - '0'.to_int() + if value > 214748364 || (value == 214748364 && digit > 7) { + raise AlignStockholmError( + label + " is outside the supported integer range", + ) + } + value = value * 10 + digit + } + if value <= 0 { + raise AlignStockholmError(label + " must be positive") + } + value +} + +///| +fn align_stockholm_normalize_lines(text : String) -> Array[String] { + let lines : Array[String] = [] + for raw in text.split("\n") { + let owned = raw.to_owned() + if owned.length() > 0 && + owned.unsafe_get(owned.length() - 1).to_int() == '\r'.to_int() { + lines.push(owned[0:owned.length() - 1].to_owned()) + } else { + lines.push(owned) + } + } + lines +} + +///| +fn align_stockholm_find_string(values : Array[String], target : String) -> Int { + for index = 0; index < values.length(); index = index + 1 { + if values[index] == target { + return index + } + } + -1 +} + +///| +fn align_stockholm_join(values : Array[String], separator : String) -> String { + let output = StringBuilder::new() + for index = 0; index < values.length(); index = index + 1 { + if index > 0 { + output.write_string(separator) + } + output.write_string(values[index]) + } + output.to_string() +} + +///| +fn align_stockholm_append_text(existing : String, value : String) -> String { + if existing.length() == 0 { + value + } else { + existing + " " + value + } +} + +///| +fn align_stockholm_pad_right(value : String, width : Int) -> String { + if value.length() >= width { + return value + } + let output = StringBuilder::new(size_hint=width) + output.write_string(value) + for _index = value.length(); _index < width; _index = _index + 1 { + output.write_char(' ') + } + output.to_string() +} + +///| +fn align_stockholm_starts_with(value : String, prefix : String) -> Bool { + if prefix.length() > value.length() { + return false + } + for index = 0; index < prefix.length(); index = index + 1 { + if value.unsafe_get(index).to_int() != prefix.unsafe_get(index).to_int() { + return false + } + } + true +} + +///| +fn align_stockholm_is_whitespace(code : Int) -> Bool { + code == ' '.to_int() || + code == '\t'.to_int() || + code == '\n'.to_int() || + code == '\r'.to_int() +} + +///| +fn align_stockholm_upper_code(code : Int) -> Int { + if code >= 'a'.to_int() && code <= 'z'.to_int() { + code - 'a'.to_int() + 'A'.to_int() + } else { + code + } +} + +///| +fn align_stockholm_max(first : Int, second : Int) -> Int { + if first > second { + first + } else { + second + } +} diff --git a/src/msf.mbt b/src/msf.mbt new file mode 100644 index 00000000..a237b17d --- /dev/null +++ b/src/msf.mbt @@ -0,0 +1,1395 @@ +// Biopython-compatible Bio.Align.msf support. +// +// GCG MSF files contain one multiple sequence alignment with a free-form +// preamble, an MSF/Type/Check line, per-sequence metadata, and interleaved +// aligned rows. Dots, tildes, and hyphens are normalized to hyphen gaps. + +///| +/// Error raised for malformed GCG MSF data or invalid alignment operations. +pub suberror MsfError { + MsfError(String) +} + +///| +/// Sequence type declared by the GCG MSF header. +pub(all) enum MsfSequenceType { + MsfProtein + MsfNucleotide +} derive(Eq, Debug) + +///| +/// File-level metadata from one GCG MSF alignment. +/// +/// `declared_length` is retained even when a third-party file reports a value +/// different from the actual alignment width, matching Biopython's warning +/// behavior while making the discrepancy queryable. +pub struct MsfMetadata { + header : String + title : String + preamble : Array[String] + declared_length : Int + sequence_type : MsfSequenceType + date_text : String + checksum_label : String + declared_checksum : Int +} derive(Eq, Debug) + +///| +/// One row and its descriptor metadata in an MSF alignment. +/// +/// `aligned_sequence` uses `-` for every gap. `sequence` is the ungapped +/// residue string. `checksum` is the value declared in the file; zero means +/// that the producer did not provide a checksum. +pub struct MsfSequence { + id : String + sequence : String + aligned_sequence : String + length : Int + checksum : Int + weight : Double +} derive(Eq, Debug) + +///| +/// A coordinate-aware GCG MSF multiple sequence alignment. +pub struct MsfAlignment { + metadata : MsfMetadata + sequences : Array[MsfSequence] +} derive(Eq, Debug) + +///| +/// Pairwise statistics for two rows in an MSF alignment. +pub struct MsfPairCounts { + columns : Int + aligned : Int + identities : Int + mismatches : Int + gap_columns : Int + double_gap_columns : Int + gap_opens : Int +} derive(Eq, Debug) + +///| +/// Construct validated file-level MSF metadata. +pub fn MsfMetadata::create( + declared_length : Int, + sequence_type : MsfSequenceType, + header? : String = "", + title? : String = "", + preamble? : Array[String] = [], + date_text? : String = "", + checksum_label? : String = "Check:", + declared_checksum? : Int = 0, +) -> MsfMetadata raise MsfError { + if declared_length <= 0 { + raise MsfError("MSF declared alignment length must be positive") + } + if declared_checksum < 0 || declared_checksum > 9999 { + raise MsfError("MSF file checksum must be between 0 and 9999") + } + if checksum_label != "Check:" && checksum_label != "CompCheck:" { + raise MsfError("MSF checksum label must be Check: or CompCheck:") + } + let canonical_header = if header.length() == 0 { + match sequence_type { + MsfProtein => "!!AA_MULTIPLE_ALIGNMENT 1.0" + MsfNucleotide => "!!NA_MULTIPLE_ALIGNMENT 1.0" + } + } else { + header.trim().to_owned() + } + msf_validate_header(canonical_header, sequence_type) + msf_validate_plain_text(title, "MSF title") + msf_validate_plain_text(date_text, "MSF date text") + let copied_preamble : Array[String] = [] + for line in preamble { + msf_validate_plain_text(line, "MSF preamble line") + copied_preamble.push(line) + } + MsfMetadata::{ + header: canonical_header, + title, + preamble: copied_preamble, + declared_length, + sequence_type, + date_text, + checksum_label, + declared_checksum, + } +} + +///| +/// Construct a normalized MSF sequence row. +pub fn MsfSequence::create( + id : String, + aligned_sequence : String, + sequence_type : MsfSequenceType, + weight? : Double = 1.0, + checksum? : Int? = None, +) -> MsfSequence raise MsfError { + msf_validate_id(id) + if weight != weight || weight.abs() > 1.0e300 || weight < 0.0 { + raise MsfError("MSF sequence weight must be a finite non-negative value") + } + if aligned_sequence.length() == 0 { + raise MsfError("MSF aligned sequence must not be empty") + } + let normalized = msf_normalize_aligned_sequence( + aligned_sequence, sequence_type, + ) + let sequence = msf_remove_gaps(normalized) + if sequence.length() == 0 { + raise MsfError("MSF sequence row must contain at least one residue") + } + let declared_checksum = match checksum { + Some(value) => { + if value < 0 || value > 9999 { + raise MsfError("MSF sequence checksum must be between 0 and 9999") + } + value + } + None => msf_gcg_checksum(sequence) + } + MsfSequence::{ + id, + sequence, + aligned_sequence: normalized, + length: sequence.length(), + checksum: declared_checksum, + weight, + } +} + +///| +/// Construct a validated MSF alignment from normalized sequence rows. +pub fn MsfAlignment::create( + metadata : MsfMetadata, + sequences : Array[MsfSequence], +) -> MsfAlignment raise MsfError { + let copied : Array[MsfSequence] = [] + for sequence in sequences { + copied.push(sequence) + } + let alignment = MsfAlignment::{ metadata, sequences: copied } + msf_validate_alignment(alignment) + alignment +} + +///| +/// Construct an MSF alignment directly from row identifiers and aligned rows. +pub fn msf_from_aligned( + ids : Array[String], + aligned_sequences : Array[String], + sequence_type : MsfSequenceType, + weights? : Array[Double] = [], +) -> MsfAlignment raise MsfError { + if ids.length() == 0 { + raise MsfError("MSF alignment must contain at least one sequence") + } + if ids.length() != aligned_sequences.length() { + raise MsfError("MSF identifiers and aligned rows must have equal lengths") + } + if weights.length() != 0 && weights.length() != ids.length() { + raise MsfError("MSF weights must be empty or match the sequence count") + } + let sequences : Array[MsfSequence] = [] + for index = 0; index < ids.length(); index = index + 1 { + let weight = if weights.length() == 0 { 1.0 } else { weights[index] } + sequences.push( + MsfSequence::create( + ids[index], + aligned_sequences[index], + sequence_type, + weight~, + ), + ) + } + let width = sequences[0].aligned_sequence.length() + let metadata = MsfMetadata::create(width, sequence_type) + MsfAlignment::create(metadata, sequences) +} + +///| +/// Parse one GCG MSF alignment. +/// +/// The accepted leading headers are `!!NA_MULTIPLE_ALIGNMENT`, +/// `!!AA_MULTIPLE_ALIGNMENT`, and `PileUp`. The parser accepts `Check:` and +/// EMBOSS's `CompCheck:` spelling, interleaved rows, numeric coordinate lines, +/// CRLF input, and all three common gap characters. Setting +/// `verify_checksums` checks every non-zero sequence and file checksum. +pub fn msf_parse( + text : String, + verify_checksums? : Bool = true, +) -> MsfAlignment raise MsfError { + let lines = msf_normalize_lines(text) + if lines.length() == 0 || lines[0].trim().length() == 0 { + raise MsfError("Empty MSF input") + } + let header = lines[0].trim().to_owned() + let header_words = msf_split_whitespace(header) + if header_words.length() == 0 || !msf_is_known_header(header_words[0]) { + raise MsfError( + "Unknown GCG MSF header; expected !!NA_MULTIPLE_ALIGNMENT, " + + "!!AA_MULTIPLE_ALIGNMENT, or PileUp", + ) + } + + let preamble : Array[String] = [] + let mut index = 1 + let mut header_line = "" + while index < lines.length() { + let trimmed = lines[index].trim().to_owned() + if msf_contains_word(trimmed, "MSF:") && msf_ends_with(trimmed, "..") { + header_line = trimmed + index = index + 1 + break + } + if trimmed.length() > 0 { + preamble.push(lines[index]) + } + index = index + 1 + } + if header_line.length() == 0 { + raise MsfError("Reached end of file without an MSF/Type/Check header line") + } + let parsed_header = msf_parse_alignment_header(header_line) + msf_validate_header(header, parsed_header.2) + + let ids : Array[String] = [] + let lengths : Array[Int] = [] + let checksums : Array[Int] = [] + let weights : Array[Double] = [] + let mut found_terminator = false + while index < lines.length() { + let line = lines[index].trim().to_owned() + index = index + 1 + if line.length() == 0 { + continue + } + if line == "//" { + found_terminator = true + break + } + if !msf_starts_with(line, "Name:") { + raise MsfError( + "Unexpected MSF header line before // at line " + index.to_string(), + ) + } + let descriptor = msf_parse_name_line(line, index) + if msf_find_string(ids, descriptor.0) >= 0 { + raise MsfError( + "Duplicated MSF sequence identifier '" + descriptor.0 + "'", + ) + } + ids.push(descriptor.0) + lengths.push(descriptor.1) + checksums.push(descriptor.2) + weights.push(descriptor.3) + } + if !found_terminator { + raise MsfError("End of file while looking for MSF // header terminator") + } + if ids.length() == 0 { + raise MsfError("MSF header contains no Name descriptors") + } + if index >= lines.length() { + raise MsfError("End of file after // line; expected sequence data") + } + if lines[index].trim().length() != 0 { + raise MsfError("Expected a blank line after the MSF // header terminator") + } + index = index + 1 + + let rows = Array::make(ids.length(), "") + let residue_counts = Array::make(ids.length(), 0) + let mut body_rows = 0 + while index < lines.length() { + let line_number = index + 1 + let line = lines[index].trim().to_owned() + index = index + 1 + if line.length() == 0 { + continue + } + let words = msf_split_whitespace(line) + if msf_all_integer_words(words) { + continue + } + let row = msf_find_string(ids, words[0]) + if row < 0 { + raise MsfError( + "Unexpected MSF sequence identifier '" + + words[0] + + "' at line " + + line_number.to_string(), + ) + } + if words.length() < 2 { + raise MsfError( + "MSF sequence row has no residues at line " + line_number.to_string(), + ) + } + let fragment_builder = StringBuilder::new() + for word_index = 1; word_index < words.length(); word_index = word_index + 1 { + fragment_builder.write_string(words[word_index]) + } + let fragment = msf_normalize_aligned_sequence( + fragment_builder.to_string(), + parsed_header.2, + ) + let residues = msf_count_residues(fragment) + if residue_counts[row] + residues > lengths[row] { + raise MsfError( + "Received more residues than declared for MSF sequence '" + + ids[row] + + "'", + ) + } + rows[row] = rows[row] + fragment + residue_counts[row] = residue_counts[row] + residues + body_rows = body_rows + 1 + } + if body_rows == 0 { + raise MsfError("MSF body contains no sequence data") + } + + let mut actual_width = 0 + for row = 0; row < ids.length(); row = row + 1 { + if residue_counts[row] != lengths[row] { + raise MsfError( + "MSF sequence '" + + ids[row] + + "' contains " + + residue_counts[row].to_string() + + " residues but declares " + + lengths[row].to_string(), + ) + } + if rows[row].length() > actual_width { + actual_width = rows[row].length() + } + } + if actual_width == 0 { + raise MsfError("MSF alignment has zero columns") + } + + let sequences : Array[MsfSequence] = [] + for row = 0; row < ids.length(); row = row + 1 { + let padded = msf_pad_right(rows[row], actual_width, '-') + sequences.push( + MsfSequence::create( + ids[row], + padded, + parsed_header.2, + weight=weights[row], + checksum=Some(checksums[row]), + ), + ) + } + let metadata = MsfMetadata::create( + parsed_header.1, + parsed_header.2, + header~, + title=parsed_header.0, + preamble~, + date_text=parsed_header.3, + checksum_label=parsed_header.4, + declared_checksum=parsed_header.5, + ) + let alignment = MsfAlignment::create(metadata, sequences) + if verify_checksums { + msf_verify_checksums(alignment) + } + alignment +} + +///| +/// Serialize an alignment as canonical GCG MSF text. +/// +/// Rows are emitted in 50-column blocks by default and grouped every ten +/// columns. Sequence and file checksums are always recalculated. Gap output +/// may be `.`, `~`, or `-`. +pub fn msf_write( + alignment : MsfAlignment, + block_width? : Int = 50, + group_width? : Int = 10, + gap_character? : String = ".", +) -> String raise MsfError { + msf_validate_alignment(alignment) + if block_width <= 0 || group_width <= 0 || block_width % group_width != 0 { + raise MsfError( + "MSF block width must be positive and divisible by group width", + ) + } + if gap_character != "." && gap_character != "~" && gap_character != "-" { + raise MsfError("MSF output gap character must be '.', '~', or '-'") + } + let output = StringBuilder::new() + output.write_string(alignment.metadata.header) + output.write_char('\n') + for line in alignment.metadata.preamble { + output.write_string(line) + output.write_char('\n') + } + output.write_char('\n') + if alignment.metadata.title.length() > 0 { + output.write_string(alignment.metadata.title) + output.write_char(' ') + } + output.write_string("MSF: ") + output.write_string(alignment.alignment_length().to_string()) + output.write_string(" Type: ") + output.write_string(alignment.metadata.sequence_type.code()) + if alignment.metadata.date_text.length() > 0 { + output.write_char(' ') + output.write_string(alignment.metadata.date_text) + } + output.write_char(' ') + output.write_string(alignment.metadata.checksum_label) + output.write_char(' ') + output.write_string(alignment.computed_checksum().to_string()) + output.write_string(" ..\n\n") + for sequence in alignment.sequences { + output.write_string(" Name: ") + output.write_string(sequence.id) + output.write_string(" Len: ") + output.write_string(sequence.length.to_string()) + output.write_string(" Check: ") + output.write_string(msf_gcg_checksum(sequence.sequence).to_string()) + output.write_string(" Weight: ") + output.write_string(sequence.weight.to_string()) + output.write_char('\n') + } + output.write_string("//\n\n") + + let width = alignment.alignment_length() + let gap_code = gap_character.unsafe_get(0).to_int() + let mut block_start = 0 + while block_start < width { + let block_end = msf_min(block_start + block_width, width) + for sequence in alignment.sequences { + output.write_string(" ") + output.write_string(sequence.id) + output.write_string(" ") + let mut group_start = block_start + while group_start < block_end { + if group_start > block_start { + output.write_char(' ') + } + let group_end = msf_min(group_start + group_width, block_end) + for column = group_start; column < group_end; column = column + 1 { + let code = sequence.aligned_sequence.unsafe_get(column).to_int() + output.write_char( + (if code == '-'.to_int() { gap_code } else { code }).unsafe_to_char(), + ) + } + group_start = group_end + } + output.write_char('\n') + } + output.write_char('\n') + block_start = block_end + } + output.to_string() +} + +///| +/// Return `P` or `N`, as used in an MSF `Type:` field. +pub fn MsfSequenceType::code(self : MsfSequenceType) -> String { + match self { + MsfProtein => "P" + MsfNucleotide => "N" + } +} + +///| +/// Return the number of sequence rows. +pub fn MsfAlignment::num_sequences(self : MsfAlignment) -> Int { + self.sequences.length() +} + +///| +/// Return the alignment width including gaps. +pub fn MsfAlignment::alignment_length(self : MsfAlignment) -> Int { + if self.sequences.length() == 0 { + 0 + } else { + self.sequences[0].aligned_sequence.length() + } +} + +///| +/// Return true when the file-level MSF length differs from the actual width. +pub fn MsfAlignment::length_mismatch(self : MsfAlignment) -> Bool { + self.metadata.declared_length != self.alignment_length() +} + +///| +/// Locate a row by its exact identifier. +pub fn MsfAlignment::find_sequence(self : MsfAlignment, id : String) -> Int? { + let index = msf_find_string( + self.sequences.map(fn(sequence) { sequence.id }), + id, + ) + if index < 0 { + None + } else { + Some(index) + } +} + +///| +/// Return one alignment column, or `None` for an invalid column. +pub fn MsfAlignment::column(self : MsfAlignment, column : Int) -> String? { + if column < 0 || column >= self.alignment_length() { + return None + } + let result = StringBuilder::new(size_hint=self.sequences.length()) + for sequence in self.sequences { + result.write_char( + sequence.aligned_sequence.unsafe_get(column).unsafe_to_char(), + ) + } + Some(result.to_string()) +} + +///| +/// Map a zero-based ungapped row position to an alignment column. +pub fn MsfAlignment::sequence_position_to_column( + self : MsfAlignment, + row : Int, + position : Int, +) -> Int? { + if row < 0 || row >= self.sequences.length() || position < 0 { + return None + } + let aligned = self.sequences[row].aligned_sequence + let mut coordinate = 0 + for column = 0; column < aligned.length(); column = column + 1 { + if aligned.unsafe_get(column).to_int() != '-'.to_int() { + if coordinate == position { + return Some(column) + } + coordinate = coordinate + 1 + } + } + None +} + +///| +/// Map an alignment column to a zero-based ungapped row position. +/// +/// Gap columns and out-of-range coordinates return `None`. +pub fn MsfAlignment::column_to_sequence_position( + self : MsfAlignment, + row : Int, + column : Int, +) -> Int? { + if row < 0 || + row >= self.sequences.length() || + column < 0 || + column >= self.alignment_length() { + return None + } + let aligned = self.sequences[row].aligned_sequence + if aligned.unsafe_get(column).to_int() == '-'.to_int() { + return None + } + let mut coordinate = 0 + for index = 0; index < column; index = index + 1 { + if aligned.unsafe_get(index).to_int() != '-'.to_int() { + coordinate = coordinate + 1 + } + } + Some(coordinate) +} + +///| +/// Map one residue through the alignment to another row. +pub fn MsfAlignment::map_position( + self : MsfAlignment, + source_row : Int, + target_row : Int, + source_position : Int, +) -> Int? { + if target_row < 0 || target_row >= self.sequences.length() { + return None + } + match self.sequence_position_to_column(source_row, source_position) { + Some(column) => self.column_to_sequence_position(target_row, column) + None => None + } +} + +///| +/// Return per-column residue coordinates for two rows. +pub fn MsfAlignment::aligned_pairs( + self : MsfAlignment, + first_row : Int, + second_row : Int, +) -> Array[(Int?, Int?)] raise MsfError { + msf_validate_row(self, first_row) + msf_validate_row(self, second_row) + let result : Array[(Int?, Int?)] = [] + let mut first_position = 0 + let mut second_position = 0 + for column = 0; column < self.alignment_length(); column = column + 1 { + let first_gap = self.sequences[first_row].aligned_sequence + .unsafe_get(column) + .to_int() == + '-'.to_int() + let second_gap = self.sequences[second_row].aligned_sequence + .unsafe_get(column) + .to_int() == + '-'.to_int() + result.push( + ( + if first_gap { + None + } else { + Some(first_position) + }, + if second_gap { + None + } else { + Some(second_position) + }, + ), + ) + if !first_gap { + first_position = first_position + 1 + } + if !second_gap { + second_position = second_position + 1 + } + } + result +} + +///| +/// Return a compact Biopython-style coordinate path for all sequence rows. +/// +/// A boundary is emitted whenever the per-row residue/gap movement vector +/// changes, plus the initial and final boundaries. +pub fn MsfAlignment::coordinate_path(self : MsfAlignment) -> Array[Array[Int]] { + let paths : Array[Array[Int]] = [] + let coordinates = Array::make(self.sequences.length(), 0) + for _row = 0; _row < self.sequences.length(); _row = _row + 1 { + paths.push([0]) + } + let width = self.alignment_length() + for column = 0; column < width; column = column + 1 { + for row = 0; row < self.sequences.length(); row = row + 1 { + if self.sequences[row].aligned_sequence.unsafe_get(column).to_int() != + '-'.to_int() { + coordinates[row] = coordinates[row] + 1 + } + } + let boundary = if column + 1 == width { + true + } else { + msf_movement_changes(self, column, column + 1) + } + if boundary { + for row = 0; row < self.sequences.length(); row = row + 1 { + paths[row].push(coordinates[row]) + } + } + } + paths +} + +///| +/// Compute pairwise identity, mismatch, and gap statistics. +pub fn MsfAlignment::pair_counts( + self : MsfAlignment, + first_row : Int, + second_row : Int, +) -> MsfPairCounts raise MsfError { + msf_validate_row(self, first_row) + msf_validate_row(self, second_row) + let first = self.sequences[first_row].aligned_sequence + let second = self.sequences[second_row].aligned_sequence + let mut aligned = 0 + let mut identities = 0 + let mut mismatches = 0 + let mut gap_columns = 0 + let mut double_gap_columns = 0 + let mut gap_opens = 0 + let mut in_gap = false + for column = 0; column < self.alignment_length(); column = column + 1 { + let first_code = first.unsafe_get(column).to_int() + let second_code = second.unsafe_get(column).to_int() + let first_gap = first_code == '-'.to_int() + let second_gap = second_code == '-'.to_int() + if first_gap && second_gap { + double_gap_columns = double_gap_columns + 1 + in_gap = false + } else if first_gap || second_gap { + gap_columns = gap_columns + 1 + if !in_gap { + gap_opens = gap_opens + 1 + } + in_gap = true + } else { + aligned = aligned + 1 + if first_code == second_code { + identities = identities + 1 + } else { + mismatches = mismatches + 1 + } + in_gap = false + } + } + MsfPairCounts::{ + columns: self.alignment_length(), + aligned, + identities, + mismatches, + gap_columns, + double_gap_columns, + gap_opens, + } +} + +///| +/// Return exact identity over columns containing residues in both rows. +pub fn MsfPairCounts::identity(self : MsfPairCounts) -> Double { + if self.aligned == 0 { + 0.0 + } else { + self.identities.to_double() / self.aligned.to_double() + } +} + +///| +/// Calculate a majority consensus. Gaps do not vote. +pub fn MsfAlignment::consensus( + self : MsfAlignment, + minimum_fraction? : Double = 0.0, +) -> String raise MsfError { + if minimum_fraction != minimum_fraction || + minimum_fraction < 0.0 || + minimum_fraction > 1.0 { + raise MsfError("MSF consensus minimum fraction must be between 0 and 1") + } + let output = StringBuilder::new(size_hint=self.alignment_length()) + for column = 0; column < self.alignment_length(); column = column + 1 { + let counts = Array::make(128, 0) + let mut residues = 0 + for sequence in self.sequences { + let code = sequence.aligned_sequence.unsafe_get(column).to_int() + if code != '-'.to_int() { + if code >= 0 && code < counts.length() { + counts[code] = counts[code] + 1 + } + residues = residues + 1 + } + } + if residues == 0 { + output.write_char('-') + continue + } + let mut best_code = 'A'.to_int() + let mut best_count = -1 + for code = 0; code < counts.length(); code = code + 1 { + if counts[code] > best_count { + best_code = code + best_count = counts[code] + } + } + if best_count.to_double() / residues.to_double() < minimum_fraction { + output.write_char('X') + } else { + output.write_char(best_code.unsafe_to_char()) + } + } + output.to_string() +} + +///| +/// Return per-column residue occupancy as a fraction of all rows. +pub fn MsfAlignment::occupancy(self : MsfAlignment) -> Array[Double] { + let result : Array[Double] = [] + for column = 0; column < self.alignment_length(); column = column + 1 { + let mut residues = 0 + for sequence in self.sequences { + if sequence.aligned_sequence.unsafe_get(column).to_int() != '-'.to_int() { + residues = residues + 1 + } + } + result.push(residues.to_double() / self.sequences.length().to_double()) + } + result +} + +///| +/// Calculate the standard GCG checksum, cycling position weights from 1 to 57. +pub fn msf_gcg_checksum(sequence : String) -> Int { + let upper = sequence.to_upper() + let mut position = 0 + let mut checksum = 0 + for index = 0; index < upper.length(); index = index + 1 { + position = position + 1 + checksum = (checksum + position * upper.unsafe_get(index).to_int()) % 10000 + if position == 57 { + position = 0 + } + } + checksum +} + +///| +/// Return the sum-of-row-checksums file checksum. +pub fn MsfAlignment::computed_checksum(self : MsfAlignment) -> Int { + let mut checksum = 0 + for sequence in self.sequences { + checksum = (checksum + msf_gcg_checksum(sequence.sequence)) % 10000 + } + checksum +} + +///| +/// Return whether one row's declared checksum is absent or correct. +pub fn MsfSequence::checksum_valid(self : MsfSequence) -> Bool { + self.checksum == 0 || self.checksum == msf_gcg_checksum(self.sequence) +} + +///| +/// Return whether all non-zero row and file checksums are correct. +pub fn MsfAlignment::checksums_valid(self : MsfAlignment) -> Bool { + for sequence in self.sequences { + if !sequence.checksum_valid() { + return false + } + } + self.metadata.declared_checksum == 0 || + self.metadata.declared_checksum == self.computed_checksum() +} + +///| +/// Return a compact alignment summary. +pub fn MsfAlignment::summary(self : MsfAlignment) -> String { + "MsfAlignment(type=" + + self.metadata.sequence_type.code() + + ", sequences=" + + self.num_sequences().to_string() + + ", columns=" + + self.alignment_length().to_string() + + ", declared=" + + self.metadata.declared_length.to_string() + + ", checksum=" + + self.computed_checksum().to_string() + + ")" +} + +///| +/// Return a small interleaved nucleotide MSF example. +pub fn msf_example_text() -> String { + "!!NA_MULTIPLE_ALIGNMENT 1.0\n" + + "\n" + + "MoonBit example MSF: 12 Type: N Check: 0 ..\n" + + "\n" + + " Name: reference Len: 12 Check: 5688 Weight: 1.0\n" + + " Name: query_one Len: 10 Check: 3984 Weight: 0.75\n" + + " Name: query_two Len: 11 Check: 4901 Weight: 1.25\n" + + "//\n" + + "\n" + + " reference ACGTAC\n" + + " query_one ACG.AC\n" + + " query_two A.GTTC\n" + + "\n" + + " 7 12\n" + + " reference GTACGT\n" + + " query_one GTAC.T\n" + + " query_two GTACGT\n" +} + +///| +fn msf_validate_alignment(alignment : MsfAlignment) -> Unit raise MsfError { + if alignment.sequences.length() == 0 { + raise MsfError("MSF alignment must contain at least one sequence") + } + let width = alignment.sequences[0].aligned_sequence.length() + if width == 0 { + raise MsfError("MSF alignment must contain at least one column") + } + let ids : Array[String] = [] + for sequence in alignment.sequences { + msf_validate_id(sequence.id) + if msf_find_string(ids, sequence.id) >= 0 { + raise MsfError("Duplicated MSF sequence identifier '" + sequence.id + "'") + } + ids.push(sequence.id) + if sequence.aligned_sequence.length() != width { + raise MsfError("MSF aligned rows must have equal widths") + } + let normalized = msf_normalize_aligned_sequence( + sequence.aligned_sequence, + alignment.metadata.sequence_type, + ) + if normalized != sequence.aligned_sequence || + msf_remove_gaps(normalized) != sequence.sequence || + sequence.sequence.length() != sequence.length { + raise MsfError("MSF sequence row contains inconsistent derived fields") + } + if sequence.weight != sequence.weight || + sequence.weight.abs() > 1.0e300 || + sequence.weight < 0.0 { + raise MsfError("MSF sequence weight must be finite and non-negative") + } + if sequence.checksum < 0 || sequence.checksum > 9999 { + raise MsfError("MSF sequence checksum must be between 0 and 9999") + } + } + for column = 0; column < width; column = column + 1 { + let mut residues = 0 + for sequence in alignment.sequences { + if sequence.aligned_sequence.unsafe_get(column).to_int() != '-'.to_int() { + residues = residues + 1 + } + } + if residues == 0 { + raise MsfError( + "MSF alignment contains an all-gap column at " + column.to_string(), + ) + } + } +} + +///| +fn msf_verify_checksums(alignment : MsfAlignment) -> Unit raise MsfError { + for sequence in alignment.sequences { + if !sequence.checksum_valid() { + raise MsfError( + "MSF checksum mismatch for sequence '" + + sequence.id + + "': declared " + + sequence.checksum.to_string() + + ", calculated " + + msf_gcg_checksum(sequence.sequence).to_string(), + ) + } + } + if alignment.metadata.declared_checksum != 0 && + alignment.metadata.declared_checksum != alignment.computed_checksum() { + raise MsfError( + "MSF file checksum mismatch: declared " + + alignment.metadata.declared_checksum.to_string() + + ", calculated " + + alignment.computed_checksum().to_string(), + ) + } +} + +///| +fn msf_validate_row(alignment : MsfAlignment, row : Int) -> Unit raise MsfError { + if row < 0 || row >= alignment.sequences.length() { + raise MsfError("MSF row index is out of bounds") + } +} + +///| +fn msf_validate_header( + header : String, + sequence_type : MsfSequenceType, +) -> Unit raise MsfError { + let words = msf_split_whitespace(header) + if words.length() == 0 || !msf_is_known_header(words[0]) { + raise MsfError("Unknown GCG MSF file header") + } + if words[0] == "!!AA_MULTIPLE_ALIGNMENT" && sequence_type != MsfProtein { + raise MsfError("Amino-acid MSF header conflicts with Type: N") + } + if words[0] == "!!NA_MULTIPLE_ALIGNMENT" && sequence_type != MsfNucleotide { + raise MsfError("Nucleotide MSF header conflicts with Type: P") + } +} + +///| +fn msf_validate_id(id : String) -> Unit raise MsfError { + if id.length() == 0 { + raise MsfError("MSF sequence identifier must not be empty") + } + for index = 0; index < id.length(); index = index + 1 { + let code = id.unsafe_get(index).to_int() + if msf_is_whitespace(code) || code < 33 || code > 126 { + raise MsfError( + "MSF sequence identifier contains whitespace or a control character", + ) + } + } +} + +///| +fn msf_validate_plain_text( + value : String, + label : String, +) -> Unit raise MsfError { + for index = 0; index < value.length(); index = index + 1 { + let code = value.unsafe_get(index).to_int() + if code == '\n'.to_int() || code == '\r'.to_int() || code < 9 { + raise MsfError(label + " contains a line break or control character") + } + } +} + +///| +fn msf_parse_alignment_header( + line : String, +) -> (String, Int, MsfSequenceType, String, String, Int) raise MsfError { + let words = msf_split_whitespace(line) + let msf_index = msf_find_string(words, "MSF:") + if msf_index < 0 || + msf_index + 3 >= words.length() || + words[msf_index + 2] != "Type:" || + words[words.length() - 1] != ".." { + raise MsfError( + "Malformed MSF header; expected MSF: Type: ... Check: ..", + ) + } + let check_index = msf_find_last_checksum_label(words) + if check_index < msf_index + 4 || check_index + 2 != words.length() - 1 { + raise MsfError("Malformed MSF Check:/CompCheck: header fields") + } + let length = msf_parse_nonnegative_int(words[msf_index + 1], "MSF length") + if length == 0 { + raise MsfError("MSF declared alignment length must be positive") + } + let sequence_type = match words[msf_index + 3] { + "P" => MsfProtein + "N" => MsfNucleotide + value => raise MsfError("MSF Type must be P or N, not '" + value + "'") + } + let checksum = msf_parse_checksum(words[check_index + 1], "MSF file checksum") + let title = msf_join_words(words, 0, msf_index) + let date_text = msf_join_words(words, msf_index + 4, check_index) + (title, length, sequence_type, date_text, words[check_index], checksum) +} + +///| +fn msf_parse_name_line( + line : String, + line_number : Int, +) -> (String, Int, Int, Double) raise MsfError { + let words = msf_split_whitespace(line) + let name_index = msf_find_string(words, "Name:") + let length_index = msf_find_string(words, "Len:") + let checksum_index = msf_find_string(words, "Check:") + let weight_index = msf_find_string(words, "Weight:") + if name_index != 0 || + length_index < 2 || + checksum_index < length_index + 2 || + weight_index < checksum_index + 2 || + weight_index + 1 != words.length() - 1 { + raise MsfError( + "Malformed GCG MSF Name line at line " + line_number.to_string(), + ) + } + if length_index == 3 && words[2] != "oo" { + raise MsfError( + "Only optional 'oo' is allowed between MSF Name and Len fields", + ) + } + if length_index > 3 { + raise MsfError("Unexpected tokens before MSF Len field") + } + let id = words[1] + msf_validate_id(id) + let length = msf_parse_nonnegative_int( + words[length_index + 1], + "MSF sequence length", + ) + if length == 0 { + raise MsfError("MSF sequence length must be positive") + } + let checksum = msf_parse_checksum( + words[checksum_index + 1], + "MSF sequence checksum", + ) + let weight = match parse_double(words[weight_index + 1]) { + Some(value) => + if value != value || value.abs() > 1.0e300 || value < 0.0 { + raise MsfError("MSF sequence weight must be finite and non-negative") + } else { + value + } + None => raise MsfError("Invalid MSF sequence weight") + } + (id, length, checksum, weight) +} + +///| +fn msf_parse_nonnegative_int( + text : String, + label : String, +) -> Int raise MsfError { + if text.length() == 0 { + raise MsfError(label + " is empty") + } + let mut value = 0 + for index = 0; index < text.length(); index = index + 1 { + let code = text.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + raise MsfError(label + " must be a non-negative integer") + } + let digit = code - '0'.to_int() + if value > 214748364 || (value == 214748364 && digit > 7) { + raise MsfError(label + " is outside the supported integer range") + } + value = value * 10 + digit + } + value +} + +///| +fn msf_parse_checksum(text : String, label : String) -> Int raise MsfError { + let value = msf_parse_nonnegative_int(text, label) + if value > 9999 { + raise MsfError(label + " must be between 0 and 9999") + } + value +} + +///| +fn msf_normalize_aligned_sequence( + sequence : String, + sequence_type : MsfSequenceType, +) -> String raise MsfError { + let output = StringBuilder::new(size_hint=sequence.length()) + for index = 0; index < sequence.length(); index = index + 1 { + let original = sequence.unsafe_get(index).to_int() + let code = msf_upper_code(original) + if code == '-'.to_int() || code == '.'.to_int() || code == '~'.to_int() { + output.write_char('-') + } else if msf_valid_residue(code, sequence_type) { + output.write_char(code.unsafe_to_char()) + } else { + raise MsfError( + "Invalid " + + (match sequence_type { + MsfProtein => "protein" + MsfNucleotide => "nucleotide" + }) + + " residue in MSF aligned sequence", + ) + } + } + output.to_string() +} + +///| +fn msf_valid_residue(code : Int, sequence_type : MsfSequenceType) -> Bool { + match sequence_type { + MsfProtein => + (code >= 'A'.to_int() && code <= 'Z'.to_int()) || + code == '*'.to_int() || + code == '?'.to_int() + MsfNucleotide => msf_contains_code("ACGTURYSWKMBDHVNX", code) + } +} + +///| +fn msf_upper_code(code : Int) -> Int { + if code >= 'a'.to_int() && code <= 'z'.to_int() { + code - 'a'.to_int() + 'A'.to_int() + } else { + code + } +} + +///| +fn msf_remove_gaps(sequence : String) -> String { + let output = StringBuilder::new(size_hint=sequence.length()) + for index = 0; index < sequence.length(); index = index + 1 { + let code = sequence.unsafe_get(index).to_int() + if code != '-'.to_int() { + output.write_char(code.unsafe_to_char()) + } + } + output.to_string() +} + +///| +fn msf_count_residues(sequence : String) -> Int { + let mut count = 0 + for index = 0; index < sequence.length(); index = index + 1 { + if sequence.unsafe_get(index).to_int() != '-'.to_int() { + count = count + 1 + } + } + count +} + +///| +fn msf_movement_changes( + alignment : MsfAlignment, + first_column : Int, + second_column : Int, +) -> Bool { + for row = 0; row < alignment.sequences.length(); row = row + 1 { + let first = alignment.sequences[row].aligned_sequence + .unsafe_get(first_column) + .to_int() != + '-'.to_int() + let second = alignment.sequences[row].aligned_sequence + .unsafe_get(second_column) + .to_int() != + '-'.to_int() + if first != second { + return true + } + } + false +} + +///| +fn msf_normalize_lines(text : String) -> Array[String] { + let raw_lines = text.split("\n") + let lines : Array[String] = [] + for raw in raw_lines { + let owned = raw.to_owned() + if owned.length() > 0 && + owned.unsafe_get(owned.length() - 1).to_int() == '\r'.to_int() { + lines.push(owned[0:owned.length() - 1].to_owned()) + } else { + lines.push(owned) + } + } + lines +} + +///| +fn msf_split_whitespace(text : String) -> Array[String] { + let words : Array[String] = [] + let mut index = 0 + while index < text.length() { + while index < text.length() && + msf_is_whitespace(text.unsafe_get(index).to_int()) { + index = index + 1 + } + let start = index + while index < text.length() && + !msf_is_whitespace(text.unsafe_get(index).to_int()) { + index = index + 1 + } + if start < index { + words.push(text[start:index].to_owned()) + } + } + words +} + +///| +fn msf_is_whitespace(code : Int) -> Bool { + code == ' '.to_int() || + code == '\t'.to_int() || + code == '\n'.to_int() || + code == '\r'.to_int() +} + +///| +fn msf_is_known_header(value : String) -> Bool { + value == "!!NA_MULTIPLE_ALIGNMENT" || + value == "!!AA_MULTIPLE_ALIGNMENT" || + value == "PileUp" +} + +///| +fn msf_all_integer_words(words : Array[String]) -> Bool { + if words.length() == 0 { + return false + } + for word in words { + if word.length() == 0 { + return false + } + for index = 0; index < word.length(); index = index + 1 { + let code = word.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + return false + } + } + } + true +} + +///| +fn msf_contains_word(text : String, word : String) -> Bool { + msf_find_string(msf_split_whitespace(text), word) >= 0 +} + +///| +fn msf_find_string(values : Array[String], target : String) -> Int { + for index = 0; index < values.length(); index = index + 1 { + if values[index] == target { + return index + } + } + -1 +} + +///| +fn msf_find_last_checksum_label(words : Array[String]) -> Int { + let mut result = -1 + for index = 0; index < words.length(); index = index + 1 { + if words[index] == "Check:" || words[index] == "CompCheck:" { + result = index + } + } + result +} + +///| +fn msf_join_words(words : Array[String], start : Int, end : Int) -> String { + let output = StringBuilder::new() + for index = start; index < end; index = index + 1 { + if index > start { + output.write_char(' ') + } + output.write_string(words[index]) + } + output.to_string() +} + +///| +fn msf_pad_right(value : String, width : Int, character : Char) -> String { + if value.length() >= width { + return value + } + let output = StringBuilder::new(size_hint=width) + output.write_string(value) + for _index = value.length(); _index < width; _index = _index + 1 { + output.write_char(character) + } + output.to_string() +} + +///| +fn msf_contains_code(values : String, target : Int) -> Bool { + for index = 0; index < values.length(); index = index + 1 { + if values.unsafe_get(index).to_int() == target { + return true + } + } + false +} + +///| +fn msf_starts_with(value : String, prefix : String) -> Bool { + value.length() >= prefix.length() && + value[0:prefix.length()].to_owned() == prefix +} + +///| +fn msf_ends_with(value : String, suffix : String) -> Bool { + value.length() >= suffix.length() && + value[value.length() - suffix.length():].to_owned() == suffix +} + +///| +fn msf_min(first : Int, second : Int) -> Int { + if first < second { + first + } else { + second + } +} diff --git a/test/moonbit/align_bed_test.mbt b/test/moonbit/align_bed_test.mbt new file mode 100644 index 00000000..a73403ac --- /dev/null +++ b/test/moonbit/align_bed_test.mbt @@ -0,0 +1,1290 @@ +///| +fn align_bed_test_parse(text : String) -> @src.AlignBedDocument { + @src.align_bed_parse(text) catch { + AlignBedError(message) => abort("valid BED input failed: " + message) + } +} + +///| +fn align_bed_test_document() -> @src.AlignBedDocument { + align_bed_test_parse(@src.align_bed_example_text()) +} + +///| +fn align_bed_test_plus() -> @src.AlignBedAlignment { + align_bed_test_document().alignments[0] +} + +///| +fn align_bed_test_minus() -> @src.AlignBedAlignment { + align_bed_test_document().alignments[1] +} + +///| +fn align_bed_test_simple() -> @src.AlignBedAlignment { + align_bed_test_document().alignments[2] +} + +///| +fn align_bed_test_rejects(text : String) -> Bool { + try { + ignore(@src.align_bed_parse(text)) + false + } catch { + AlignBedError(_) => true + } +} + +///| +fn align_bed_test_coordinate( + target : Int, + query : Int, +) -> @src.AlignBedCoordinate { + @src.AlignBedCoordinate::create(target, query) catch { + AlignBedError(message) => abort("valid BED coordinate failed: " + message) + } +} + +///| +fn align_bed_test_construct( + coordinates : Array[@src.AlignBedCoordinate], +) -> @src.AlignBedAlignment { + @src.AlignBedAlignment::create("target", Some("query"), coordinates) catch { + AlignBedError(message) => abort("valid BED alignment failed: " + message) + } +} + +///| +fn align_bed_test_constructor_rejects( + coordinates : Array[@src.AlignBedCoordinate], +) -> Bool { + try { + ignore(@src.AlignBedAlignment::create("target", Some("query"), coordinates)) + false + } catch { + AlignBedError(_) => true + } +} + +///| +test "Bio.Align.bed parses three records" { + assert_eq(align_bed_test_document().alignments.length(), 3) +} + +///| +test "Bio.Align.bed parses an empty document" { + assert_eq(align_bed_test_parse("").alignments.length(), 0) +} + +///| +test "Bio.Align.bed parses a final newline" { + assert_eq(align_bed_test_parse("chr1\t0\t10\n").alignments.length(), 1) +} + +///| +test "Bio.Align.bed parses input without a final newline" { + assert_eq(align_bed_test_parse("chr1\t0\t10").alignments.length(), 1) +} + +///| +test "Bio.Align.bed accepts CRLF records" { + assert_eq( + align_bed_test_parse("chr1\t0\t10\r\nchr2\t5\t15\r\n").alignments.length(), + 2, + ) +} + +///| +test "Bio.Align.bed accepts whitespace-delimited fields" { + let alignment = align_bed_test_parse("chr1 10 20 tx1\n").alignments[0] + assert_eq(alignment.query_id, Some("tx1")) +} + +///| +test "Bio.Align.bed preserves target identifier" { + assert_eq(align_bed_test_plus().target_id, "chr22") +} + +///| +test "Bio.Align.bed preserves plus query identifier" { + assert_eq(align_bed_test_plus().query_id, Some("mRNA1")) +} + +///| +test "Bio.Align.bed preserves minus query identifier" { + assert_eq(align_bed_test_minus().query_id, Some("mRNA2")) +} + +///| +test "Bio.Align.bed BED3 query identifier is absent" { + assert_eq(align_bed_test_simple().query_id, None) +} + +///| +test "Bio.Align.bed records source column count" { + assert_eq(align_bed_test_plus().source_columns, 12) + assert_eq(align_bed_test_simple().source_columns, 3) +} + +///| +test "Bio.Align.bed parses numeric score" { + assert_eq(align_bed_test_plus().score.unwrap().number(), Some(960.0)) +} + +///| +test "Bio.Align.bed parses second numeric score" { + assert_eq(align_bed_test_minus().score.unwrap().number(), Some(900.0)) +} + +///| +test "Bio.Align.bed BED3 score is absent" { + assert_eq(align_bed_test_simple().score, None) +} + +///| +test "Bio.Align.bed parses floating score" { + let alignment = align_bed_test_parse("chr1\t0\t10\ttx\t2.5\n").alignments[0] + assert_eq(alignment.score.unwrap().number(), Some(2.5)) +} + +///| +test "Bio.Align.bed parses scientific score" { + let alignment = align_bed_test_parse("chr1\t0\t10\ttx\t1.25e2\n").alignments[0] + assert_eq(alignment.score.unwrap().number(), Some(125.0)) +} + +///| +test "Bio.Align.bed parses explicit positive score" { + let alignment = align_bed_test_parse("chr1\t0\t10\ttx\t+2.5\n").alignments[0] + assert_eq(alignment.score.unwrap().number(), Some(2.5)) +} + +///| +test "Bio.Align.bed preserves textual score" { + let alignment = align_bed_test_parse("chr1\t0\t10\ttx\tpass\n").alignments[0] + assert_eq(alignment.score.unwrap().text_value(), Some("pass")) +} + +///| +test "Bio.Align.bed parses thickStart" { + assert_eq(align_bed_test_plus().thick_start, Some(1200)) +} + +///| +test "Bio.Align.bed parses thickEnd" { + assert_eq(align_bed_test_plus().thick_end, Some(4900)) +} + +///| +test "Bio.Align.bed parses itemRgb" { + assert_eq(align_bed_test_plus().item_rgb, Some("255,0,0")) +} + +///| +test "Bio.Align.bed identifies plus strand" { + assert_eq(align_bed_test_plus().strand(), "+") +} + +///| +test "Bio.Align.bed identifies minus strand" { + assert_eq(align_bed_test_minus().strand(), "-") +} + +///| +test "Bio.Align.bed normalizes dot strand to plus" { + let alignment = align_bed_test_parse("chr1\t0\t10\ttx\t0\t.\n").alignments[0] + assert_eq(alignment.strand(), "+") +} + +///| +test "Bio.Align.bed plus coordinate count" { + assert_eq(align_bed_test_plus().coordinates.length(), 4) +} + +///| +test "Bio.Align.bed plus first coordinate" { + assert_eq( + align_bed_test_plus().coordinates[0], + align_bed_test_coordinate(1000, 0), + ) +} + +///| +test "Bio.Align.bed plus first block end" { + assert_eq( + align_bed_test_plus().coordinates[1], + align_bed_test_coordinate(1567, 567), + ) +} + +///| +test "Bio.Align.bed plus second block start" { + assert_eq( + align_bed_test_plus().coordinates[2], + align_bed_test_coordinate(4512, 567), + ) +} + +///| +test "Bio.Align.bed plus final coordinate" { + assert_eq( + align_bed_test_plus().coordinates[3], + align_bed_test_coordinate(5000, 1055), + ) +} + +///| +test "Bio.Align.bed minus coordinate count" { + assert_eq(align_bed_test_minus().coordinates.length(), 4) +} + +///| +test "Bio.Align.bed minus first coordinate" { + assert_eq( + align_bed_test_minus().coordinates[0], + align_bed_test_coordinate(2000, 832), + ) +} + +///| +test "Bio.Align.bed minus first block end" { + assert_eq( + align_bed_test_minus().coordinates[1], + align_bed_test_coordinate(2433, 399), + ) +} + +///| +test "Bio.Align.bed minus second block start" { + assert_eq( + align_bed_test_minus().coordinates[2], + align_bed_test_coordinate(5601, 399), + ) +} + +///| +test "Bio.Align.bed minus final coordinate" { + assert_eq( + align_bed_test_minus().coordinates[3], + align_bed_test_coordinate(6000, 0), + ) +} + +///| +test "Bio.Align.bed BED3 has one continuous coordinate step" { + assert_eq(align_bed_test_simple().coordinates.length(), 2) + assert_eq( + align_bed_test_simple().coordinates[0], + align_bed_test_coordinate(100, 0), + ) + assert_eq( + align_bed_test_simple().coordinates[1], + align_bed_test_coordinate(180, 80), + ) +} + +///| +test "Bio.Align.bed plus block count" { + assert_eq(align_bed_test_plus().blocks().length(), 2) +} + +///| +test "Bio.Align.bed plus first block geometry" { + let block = align_bed_test_plus().blocks()[0] + assert_eq(block.target_start, 1000) + assert_eq(block.target_end, 1567) + assert_eq(block.query_start, 0) + assert_eq(block.query_end, 567) +} + +///| +test "Bio.Align.bed plus second block geometry" { + let block = align_bed_test_plus().blocks()[1] + assert_eq(block.target_start, 4512) + assert_eq(block.target_end, 5000) + assert_eq(block.query_start, 567) + assert_eq(block.query_end, 1055) +} + +///| +test "Bio.Align.bed minus first block query interval" { + let block = align_bed_test_minus().blocks()[0] + assert_eq(block.query_start, 399) + assert_eq(block.query_end, 832) +} + +///| +test "Bio.Align.bed target interval" { + assert_eq(align_bed_test_plus().target_start(), 1000) + assert_eq(align_bed_test_plus().target_end(), 5000) +} + +///| +test "Bio.Align.bed plus query size" { + assert_eq(align_bed_test_plus().query_size(), 1055) +} + +///| +test "Bio.Align.bed minus query size" { + assert_eq(align_bed_test_minus().query_size(), 832) +} + +///| +test "Bio.Align.bed target span" { + assert_eq(align_bed_test_plus().target_span(), 4000) +} + +///| +test "Bio.Align.bed plus aligned bases" { + assert_eq(align_bed_test_plus().aligned_bases(), 1055) +} + +///| +test "Bio.Align.bed plus target skip count" { + let counts = align_bed_test_plus().counts() + assert_eq(counts.target_skip_bases, 2945) + assert_eq(counts.target_skip_opens, 1) +} + +///| +test "Bio.Align.bed minus target skip count" { + let counts = align_bed_test_minus().counts() + assert_eq(counts.target_skip_bases, 3168) + assert_eq(counts.target_skip_opens, 1) +} + +///| +test "Bio.Align.bed parsed records have no query skips" { + let counts = align_bed_test_plus().counts() + assert_eq(counts.query_skip_bases, 0) + assert_eq(counts.query_skip_opens, 0) +} + +///| +test "Bio.Align.bed alignment columns include target skips" { + assert_eq(align_bed_test_plus().counts().columns, 4000) +} + +///| +test "Bio.Align.bed maps plus target start" { + assert_eq(align_bed_test_plus().map_target_position(1000), Some(0)) +} + +///| +test "Bio.Align.bed maps plus first block end residue" { + assert_eq(align_bed_test_plus().map_target_position(1566), Some(566)) +} + +///| +test "Bio.Align.bed returns none inside target intron" { + assert_eq(align_bed_test_plus().map_target_position(2000), None) +} + +///| +test "Bio.Align.bed maps plus second block start" { + assert_eq(align_bed_test_plus().map_target_position(4512), Some(567)) +} + +///| +test "Bio.Align.bed maps plus final target residue" { + assert_eq(align_bed_test_plus().map_target_position(4999), Some(1054)) +} + +///| +test "Bio.Align.bed maps plus query start" { + assert_eq(align_bed_test_plus().map_query_position(0), Some(1000)) +} + +///| +test "Bio.Align.bed maps plus query final residue" { + assert_eq(align_bed_test_plus().map_query_position(1054), Some(4999)) +} + +///| +test "Bio.Align.bed maps minus first target residue" { + assert_eq(align_bed_test_minus().map_target_position(2000), Some(831)) +} + +///| +test "Bio.Align.bed maps minus first exon final residue" { + assert_eq(align_bed_test_minus().map_target_position(2432), Some(399)) +} + +///| +test "Bio.Align.bed maps minus second exon start" { + assert_eq(align_bed_test_minus().map_target_position(5601), Some(398)) +} + +///| +test "Bio.Align.bed maps minus final target residue" { + assert_eq(align_bed_test_minus().map_target_position(5999), Some(0)) +} + +///| +test "Bio.Align.bed maps reverse query zero" { + assert_eq(align_bed_test_minus().map_query_position(0), Some(5999)) +} + +///| +test "Bio.Align.bed maps reverse query final residue" { + assert_eq(align_bed_test_minus().map_query_position(831), Some(2000)) +} + +///| +test "Bio.Align.bed mapping rejects negative positions" { + assert_eq(align_bed_test_plus().map_target_position(-1), None) + assert_eq(align_bed_test_plus().map_query_position(-1), None) +} + +///| +test "Bio.Align.bed overlap uses half-open intervals" { + let alignment = align_bed_test_plus() + assert_true(alignment.overlaps("chr22", 999, 1001)) + assert_false(alignment.overlaps("chr22", 5000, 5001)) +} + +///| +test "Bio.Align.bed overlap requires matching target" { + assert_false(align_bed_test_plus().overlaps("chr7", 1000, 1001)) +} + +///| +test "Bio.Align.bed searches target intervals" { + let hits = align_bed_test_document().search("chr22", 1500, 2500) catch { + AlignBedError(message) => abort("valid BED search failed: " + message) + } + assert_eq(hits.length(), 2) +} + +///| +test "Bio.Align.bed search respects half-open end" { + let hits = align_bed_test_document().search("chr22", 6000, 6100) catch { + AlignBedError(message) => abort("valid BED search failed: " + message) + } + assert_eq(hits.length(), 0) +} + +///| +test "Bio.Align.bed search rejects empty interval" { + let document = align_bed_test_document() + assert_true( + try { + ignore(document.search("chr22", 10, 10)) + false + } catch { + AlignBedError(_) => true + }, + ) +} + +///| +test "Bio.Align.bed preserves distinct target order" { + assert_eq(align_bed_test_document().targets(), ["chr22", "chr7"]) +} + +///| +test "Bio.Align.bed preserves distinct query order" { + assert_eq(align_bed_test_document().queries(), ["mRNA1", "mRNA2"]) +} + +///| +test "Bio.Align.bed summary alignment count" { + assert_eq(align_bed_test_document().summary().alignment_count, 3) +} + +///| +test "Bio.Align.bed summary target and query counts" { + let summary = align_bed_test_document().summary() + assert_eq(summary.target_count, 2) + assert_eq(summary.query_count, 2) +} + +///| +test "Bio.Align.bed summary strand counts" { + let summary = align_bed_test_document().summary() + assert_eq(summary.plus_strand_count, 2) + assert_eq(summary.minus_strand_count, 1) +} + +///| +test "Bio.Align.bed summary aligned bases" { + assert_eq(align_bed_test_document().summary().aligned_bases, 1967) +} + +///| +test "Bio.Align.bed summary target skips" { + assert_eq(align_bed_test_document().summary().target_skip_bases, 6113) +} + +///| +test "Bio.Align.bed writes canonical BED12 plus record" { + let line = @src.align_bed_format(align_bed_test_plus()) catch { + AlignBedError(message) => abort("valid BED writing failed: " + message) + } + assert_eq( + line, + "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\t2\t567,488,\t0,3512,\n", + ) +} + +///| +test "Bio.Align.bed writes canonical BED12 minus record" { + let line = @src.align_bed_format(align_bed_test_minus()) catch { + AlignBedError(message) => abort("valid BED writing failed: " + message) + } + assert_eq( + line, + "chr22\t2000\t6000\tmRNA2\t900\t-\t2300\t5960\t0,255,0\t2\t433,399,\t0,3601,\n", + ) +} + +///| +test "Bio.Align.bed writes BED3" { + let line = @src.align_bed_format(align_bed_test_plus(), bed_columns=3) catch { + AlignBedError(message) => abort("valid BED3 writing failed: " + message) + } + assert_eq(line, "chr22\t1000\t5000\n") +} + +///| +test "Bio.Align.bed writes BED4" { + let line = @src.align_bed_format(align_bed_test_plus(), bed_columns=4) catch { + AlignBedError(message) => abort("valid BED4 writing failed: " + message) + } + assert_eq(line, "chr22\t1000\t5000\tmRNA1\n") +} + +///| +test "Bio.Align.bed writes BED5" { + let line = @src.align_bed_format(align_bed_test_plus(), bed_columns=5) catch { + AlignBedError(message) => abort("valid BED5 writing failed: " + message) + } + assert_eq(line, "chr22\t1000\t5000\tmRNA1\t960\n") +} + +///| +test "Bio.Align.bed writes BED6" { + let line = @src.align_bed_format(align_bed_test_plus(), bed_columns=6) catch { + AlignBedError(message) => abort("valid BED6 writing failed: " + message) + } + assert_eq(line, "chr22\t1000\t5000\tmRNA1\t960\t+\n") +} + +///| +test "Bio.Align.bed writes BED7" { + let line = @src.align_bed_format(align_bed_test_plus(), bed_columns=7) catch { + AlignBedError(message) => abort("valid BED7 writing failed: " + message) + } + assert_eq(line, "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\n") +} + +///| +test "Bio.Align.bed writes BED8" { + let line = @src.align_bed_format(align_bed_test_plus(), bed_columns=8) catch { + AlignBedError(message) => abort("valid BED8 writing failed: " + message) + } + assert_eq(line, "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\n") +} + +///| +test "Bio.Align.bed writes BED9" { + let line = @src.align_bed_format(align_bed_test_plus(), bed_columns=9) catch { + AlignBedError(message) => abort("valid BED9 writing failed: " + message) + } + assert_eq( + line, + "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\n", + ) +} + +///| +test "Bio.Align.bed writes BED10" { + let line = @src.align_bed_format(align_bed_test_plus(), bed_columns=10) catch { + AlignBedError(message) => abort("valid BED10 writing failed: " + message) + } + assert_eq( + line, + "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\t2\n", + ) +} + +///| +test "Bio.Align.bed writes BED11" { + let line = @src.align_bed_format(align_bed_test_plus(), bed_columns=11) catch { + AlignBedError(message) => abort("valid BED11 writing failed: " + message) + } + assert_eq( + line, + "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\t2\t567,488,\n", + ) +} + +///| +test "Bio.Align.bed BED12 round trip is stable" { + let line = @src.align_bed_format(align_bed_test_plus()) catch { + AlignBedError(message) => abort("valid BED writing failed: " + message) + } + let parsed = align_bed_test_parse(line).alignments[0] + let second = @src.align_bed_format(parsed) catch { + AlignBedError(message) => abort("valid BED writing failed: " + message) + } + assert_eq(second, line) +} + +///| +test "Bio.Align.bed writes complete document" { + let document = align_bed_test_document() + let output = @src.align_bed_write(document, bed_columns=3) catch { + AlignBedError(message) => abort("valid BED document writing failed: " + message) + } + assert_eq(output.split("\n").length(), 4) +} + +///| +test "Bio.Align.bed textual score writes unchanged" { + let alignment = align_bed_test_parse("chr1\t0\t10\ttx\tpass\n").alignments[0] + let output = @src.align_bed_format(alignment, bed_columns=5) catch { + AlignBedError(message) => abort("valid BED score writing failed: " + message) + } + assert_eq(output, "chr1\t0\t10\ttx\tpass\n") +} + +///| +test "Bio.Align.bed writer supplies default query name" { + let output = @src.align_bed_format( + align_bed_test_simple(), + bed_columns=4, + ) catch { + AlignBedError(message) => abort("valid BED writing failed: " + message) + } + assert_eq(output, "chr7\t100\t180\tquery\n") +} + +///| +test "Bio.Align.bed writer supplies default score" { + let output = @src.align_bed_format( + align_bed_test_simple(), + bed_columns=5, + ) catch { + AlignBedError(message) => abort("valid BED writing failed: " + message) + } + assert_eq(output, "chr7\t100\t180\tquery\t0\n") +} + +///| +test "Bio.Align.bed writer supplies default thick interval and color" { + let output = @src.align_bed_format( + align_bed_test_simple(), + bed_columns=9, + ) catch { + AlignBedError(message) => abort("valid BED writing failed: " + message) + } + assert_eq(output, "chr7\t100\t180\tquery\t0\t+\t100\t180\t0\n") +} + +///| +test "Bio.Align.bed reads BED4" { + let alignment = align_bed_test_parse("chr1\t10\t20\ttx\n").alignments[0] + assert_eq(alignment.source_columns, 4) + assert_eq(alignment.query_id, Some("tx")) +} + +///| +test "Bio.Align.bed reads BED5" { + let alignment = align_bed_test_parse("chr1\t10\t20\ttx\t7\n").alignments[0] + assert_eq(alignment.source_columns, 5) + assert_eq(alignment.score.unwrap().number(), Some(7.0)) +} + +///| +test "Bio.Align.bed reads BED6 reverse strand" { + let alignment = align_bed_test_parse("chr1\t10\t20\ttx\t7\t-\n").alignments[0] + assert_eq(alignment.coordinates[0].query, 10) + assert_eq(alignment.coordinates[1].query, 0) +} + +///| +test "Bio.Align.bed reads BED7" { + let alignment = align_bed_test_parse( + "chr1\t10\t20\ttx\t7\t+\t12\n", + ).alignments[0] + assert_eq(alignment.thick_start, Some(12)) + assert_eq(alignment.thick_end, None) +} + +///| +test "Bio.Align.bed reads BED8" { + let alignment = align_bed_test_parse( + "chr1\t10\t20\ttx\t7\t+\t12\t18\n", + ).alignments[0] + assert_eq(alignment.thick_end, Some(18)) +} + +///| +test "Bio.Align.bed reads BED9" { + let alignment = align_bed_test_parse( + "chr1\t10\t20\ttx\t7\t+\t12\t18\t10,20,30\n", + ).alignments[0] + assert_eq(alignment.item_rgb, Some("10,20,30")) +} + +///| +test "Bio.Align.bed reads lossless single-block BED10" { + let alignment = align_bed_test_parse( + "chr1\t10\t20\ttx\t7\t+\t12\t18\t0\t1\n", + ).alignments[0] + assert_eq(alignment.blocks().length(), 1) + assert_eq(alignment.source_columns, 10) +} + +///| +test "Bio.Align.bed reads inferable contiguous BED11" { + let alignment = align_bed_test_parse( + "chr1\t10\t20\ttx\t7\t+\t12\t18\t0\t2\t4,6,\n", + ).alignments[0] + assert_eq(alignment.blocks().length(), 2) + assert_eq(alignment.blocks()[1].target_start, 14) +} + +///| +test "Bio.Align.bed accepts BED12 lists without trailing commas" { + let alignment = align_bed_test_parse( + "chr1\t10\t20\ttx\t7\t+\t12\t18\t0\t2\t4,3\t0,7\n", + ).alignments[0] + assert_eq(alignment.query_size(), 7) +} + +///| +test "Bio.Align.bed rejects fewer than three columns" { + assert_true(align_bed_test_rejects("chr1\t0\n")) +} + +///| +test "Bio.Align.bed rejects more than twelve columns" { + assert_true( + align_bed_test_rejects( + "chr1\t0\t10\ttx\t0\t+\t0\t10\t0\t1\t10,\t0,\textra\n", + ), + ) +} + +///| +test "Bio.Align.bed rejects interior blank records" { + assert_true(align_bed_test_rejects("chr1\t0\t10\n\nchr2\t0\t10\n")) +} + +///| +test "Bio.Align.bed rejects comment records" { + assert_true(align_bed_test_rejects("# comment\nchr1\t0\t10\n")) +} + +///| +test "Bio.Align.bed rejects track records" { + assert_true(align_bed_test_rejects("track name=test\nchr1\t0\t10\n")) +} + +///| +test "Bio.Align.bed rejects negative chromStart" { + assert_true(align_bed_test_rejects("chr1\t-1\t10\n")) +} + +///| +test "Bio.Align.bed rejects reversed target interval" { + assert_true(align_bed_test_rejects("chr1\t20\t10\n")) +} + +///| +test "Bio.Align.bed rejects empty target interval" { + assert_true(align_bed_test_rejects("chr1\t10\t10\n")) +} + +///| +test "Bio.Align.bed rejects integer overflow" { + assert_true(align_bed_test_rejects("chr1\t0\t2147483648\n")) +} + +///| +test "Bio.Align.bed rejects invalid strand" { + assert_true(align_bed_test_rejects("chr1\t0\t10\ttx\t0\tx\n")) +} + +///| +test "Bio.Align.bed rejects thickStart before interval" { + assert_true(align_bed_test_rejects("chr1\t10\t20\ttx\t0\t+\t9\n")) +} + +///| +test "Bio.Align.bed rejects thickEnd after interval" { + assert_true( + align_bed_test_rejects("chr1\t10\t20\ttx\t0\t+\t10\t21\n"), + ) +} + +///| +test "Bio.Align.bed rejects reversed thick interval" { + assert_true( + align_bed_test_rejects("chr1\t10\t20\ttx\t0\t+\t18\t12\n"), + ) +} + +///| +test "Bio.Align.bed rejects multi-block BED10" { + assert_true( + align_bed_test_rejects( + "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\n", + ), + ) +} + +///| +test "Bio.Align.bed rejects BED11 block count mismatch" { + assert_true( + align_bed_test_rejects( + "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t20,\n", + ), + ) +} + +///| +test "Bio.Align.bed rejects ambiguous gapped BED11" { + assert_true( + align_bed_test_rejects( + "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\n", + ), + ) +} + +///| +test "Bio.Align.bed rejects zero block count" { + assert_true( + align_bed_test_rejects( + "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t0\t\t\n", + ), + ) +} + +///| +test "Bio.Align.bed rejects blockSizes count mismatch" { + assert_true( + align_bed_test_rejects( + "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,\t0,15,\n", + ), + ) +} + +///| +test "Bio.Align.bed rejects blockStarts count mismatch" { + assert_true( + align_bed_test_rejects( + "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\t0,\n", + ), + ) +} + +///| +test "Bio.Align.bed rejects empty block list item" { + assert_true( + align_bed_test_rejects( + "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,,5,\t0,15,\n", + ), + ) +} + +///| +test "Bio.Align.bed rejects noninteger block size" { + assert_true( + align_bed_test_rejects( + "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,x,\t0,15,\n", + ), + ) +} + +///| +test "Bio.Align.bed rejects zero block size" { + assert_true( + align_bed_test_rejects( + "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t0,5,\t0,15,\n", + ), + ) +} + +///| +test "Bio.Align.bed rejects first block after chromStart" { + assert_true( + align_bed_test_rejects( + "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\t1,15,\n", + ), + ) +} + +///| +test "Bio.Align.bed rejects overlapping blocks" { + assert_true( + align_bed_test_rejects( + "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t10,10,\t0,5,\n", + ), + ) +} + +///| +test "Bio.Align.bed rejects unsorted blocks" { + assert_true( + align_bed_test_rejects( + "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\t0,0,\n", + ), + ) +} + +///| +test "Bio.Align.bed rejects block beyond chromEnd" { + assert_true( + align_bed_test_rejects( + "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,10,\t0,15,\n", + ), + ) +} + +///| +test "Bio.Align.bed rejects final block before chromEnd" { + assert_true( + align_bed_test_rejects( + "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,4,\t0,15,\n", + ), + ) +} + +///| +test "Bio.Align.bed rejects block coordinate overflow" { + assert_true( + align_bed_test_rejects( + "chr1\t0\t2147483647\ttx\t0\t+\t0\t2147483647\t0\t1\t2147483647,\t1,\n", + ), + ) +} + +///| +test "Bio.Align.bed rejects invalid numeric score magnitude" { + assert_true( + try { + ignore(@src.AlignBedScore::numeric(1.0e301)) + false + } catch { + AlignBedError(_) => true + }, + ) +} + +///| +test "Bio.Align.bed rejects empty textual score" { + assert_true( + try { + ignore(@src.AlignBedScore::text("")) + false + } catch { + AlignBedError(_) => true + }, + ) +} + +///| +test "Bio.Align.bed rejects whitespace in textual score" { + assert_true( + try { + ignore(@src.AlignBedScore::text("not valid")) + false + } catch { + AlignBedError(_) => true + }, + ) +} + +///| +test "Bio.Align.bed coordinate constructor rejects negative target" { + assert_true( + try { + ignore(@src.AlignBedCoordinate::create(-1, 0)) + false + } catch { + AlignBedError(_) => true + }, + ) +} + +///| +test "Bio.Align.bed coordinate constructor rejects negative query" { + assert_true( + try { + ignore(@src.AlignBedCoordinate::create(0, -1)) + false + } catch { + AlignBedError(_) => true + }, + ) +} + +///| +test "Bio.Align.bed constructor rejects one coordinate" { + assert_true( + align_bed_test_constructor_rejects([align_bed_test_coordinate(0, 0)]), + ) +} + +///| +test "Bio.Align.bed constructor rejects zero-length segment" { + assert_true( + align_bed_test_constructor_rejects([ + align_bed_test_coordinate(0, 0), + align_bed_test_coordinate(0, 0), + ]), + ) +} + +///| +test "Bio.Align.bed constructor rejects nonmonotonic target" { + assert_true( + align_bed_test_constructor_rejects([ + align_bed_test_coordinate(0, 0), + align_bed_test_coordinate(5, 5), + align_bed_test_coordinate(3, 7), + ]), + ) +} + +///| +test "Bio.Align.bed constructor rejects nonmonotonic query" { + assert_true( + align_bed_test_constructor_rejects([ + align_bed_test_coordinate(0, 0), + align_bed_test_coordinate(5, 5), + align_bed_test_coordinate(10, 3), + ]), + ) +} + +///| +test "Bio.Align.bed constructor rejects unequal aligned steps" { + assert_true( + align_bed_test_constructor_rejects([ + align_bed_test_coordinate(0, 0), + align_bed_test_coordinate(5, 4), + ]), + ) +} + +///| +test "Bio.Align.bed constructor rejects gaps-only path" { + assert_true( + align_bed_test_constructor_rejects([ + align_bed_test_coordinate(0, 0), + align_bed_test_coordinate(5, 0), + ]), + ) +} + +///| +test "Bio.Align.bed constructor rejects empty target identifier" { + assert_true( + try { + ignore( + @src.AlignBedAlignment::create( + "", + Some("query"), + [align_bed_test_coordinate(0, 0), align_bed_test_coordinate(5, 5)], + ), + ) + false + } catch { + AlignBedError(_) => true + }, + ) +} + +///| +test "Bio.Align.bed constructor allows absent query identifier" { + let alignment = @src.AlignBedAlignment::create( + "target", + None, + [align_bed_test_coordinate(0, 0), align_bed_test_coordinate(5, 5)], + ) catch { + AlignBedError(message) => abort("valid BED alignment failed: " + message) + } + assert_eq(alignment.query_id, None) +} + +///| +test "Bio.Align.bed constructor rejects invalid source column count" { + assert_true( + try { + ignore( + @src.AlignBedAlignment::create( + "target", + Some("query"), + [align_bed_test_coordinate(0, 0), align_bed_test_coordinate(5, 5)], + source_columns=13, + ), + ) + false + } catch { + AlignBedError(_) => true + }, + ) +} + +///| +test "Bio.Align.bed constructor rejects thickStart outside interval" { + assert_true( + try { + ignore( + @src.AlignBedAlignment::create( + "target", + Some("query"), + [align_bed_test_coordinate(10, 0), align_bed_test_coordinate(20, 10)], + thick_start=Some(9), + ), + ) + false + } catch { + AlignBedError(_) => true + }, + ) +} + +///| +test "Bio.Align.bed constructor rejects itemRgb whitespace" { + assert_true( + try { + ignore( + @src.AlignBedAlignment::create( + "target", + Some("query"), + [align_bed_test_coordinate(10, 0), align_bed_test_coordinate(20, 10)], + item_rgb=Some("0 0 0"), + ), + ) + false + } catch { + AlignBedError(_) => true + }, + ) +} + +///| +test "Bio.Align.bed alignment constructor copies coordinate array" { + let coordinates = [ + align_bed_test_coordinate(0, 0), + align_bed_test_coordinate(5, 5), + ] + let alignment = align_bed_test_construct(coordinates) + ignore(coordinates.pop()) + assert_eq(alignment.coordinates.length(), 2) +} + +///| +test "Bio.Align.bed document constructor copies alignment array" { + let alignments = [align_bed_test_plus()] + let document = @src.AlignBedDocument::create(alignments) catch { + AlignBedError(message) => abort("valid BED document failed: " + message) + } + ignore(alignments.pop()) + assert_eq(document.alignments.length(), 1) +} + +///| +test "Bio.Align.bed writer rejects invalid bedN" { + assert_true( + try { + ignore(@src.align_bed_format(align_bed_test_plus(), bed_columns=2)) + false + } catch { + AlignBedError(_) => true + }, + ) +} + +///| +test "Bio.Align.bed normalizes reversed target path when writing" { + let alignment = align_bed_test_construct([ + align_bed_test_coordinate(20, 10), + align_bed_test_coordinate(10, 0), + ]) + let output = @src.align_bed_format(alignment, bed_columns=6) catch { + AlignBedError(message) => abort("valid BED writing failed: " + message) + } + assert_eq(output, "target\t10\t20\tquery\t0\t+\n") +} + +///| +test "Bio.Align.bed projects Biopython strand fixture into four blocks" { + let alignment = align_bed_test_construct([ + align_bed_test_coordinate(0, 11), + align_bed_test_coordinate(2, 11), + align_bed_test_coordinate(2, 9), + align_bed_test_coordinate(3, 8), + align_bed_test_coordinate(4, 8), + align_bed_test_coordinate(6, 6), + align_bed_test_coordinate(6, 5), + align_bed_test_coordinate(9, 2), + align_bed_test_coordinate(10, 2), + align_bed_test_coordinate(12, 0), + align_bed_test_coordinate(15, 0), + ]) + assert_eq(alignment.blocks().length(), 4) +} + +///| +test "Bio.Align.bed writes Biopython strand fixture" { + let score = @src.AlignBedScore::numeric(8.0) catch { + AlignBedError(message) => abort("valid BED score failed: " + message) + } + let alignment = @src.AlignBedAlignment::create( + "target", + Some("query"), + [ + align_bed_test_coordinate(0, 11), + align_bed_test_coordinate(2, 11), + align_bed_test_coordinate(2, 9), + align_bed_test_coordinate(3, 8), + align_bed_test_coordinate(4, 8), + align_bed_test_coordinate(6, 6), + align_bed_test_coordinate(6, 5), + align_bed_test_coordinate(9, 2), + align_bed_test_coordinate(10, 2), + align_bed_test_coordinate(12, 0), + align_bed_test_coordinate(15, 0), + ], + score=Some(score), + ) catch { + AlignBedError(message) => abort("valid BED fixture failed: " + message) + } + let output = @src.align_bed_format(alignment) catch { + AlignBedError(message) => abort("valid BED writing failed: " + message) + } + assert_eq( + output, + "target\t2\t12\tquery\t8\t-\t2\t12\t0\t4\t1,2,3,2,\t0,2,4,8,\n", + ) +} + +///| +test "Bio.Align.bed counts query-only skips in constructed path" { + let alignment = align_bed_test_construct([ + align_bed_test_coordinate(0, 0), + align_bed_test_coordinate(2, 2), + align_bed_test_coordinate(2, 4), + align_bed_test_coordinate(5, 7), + ]) + let counts = alignment.counts() + assert_eq(counts.query_skip_bases, 2) + assert_eq(counts.query_skip_opens, 1) +} + +///| +test "Bio.Align.bed stable document round trip by canonical text" { + let first = @src.align_bed_write(align_bed_test_document()) catch { + AlignBedError(message) => abort("valid BED writing failed: " + message) + } + let second = @src.align_bed_write(align_bed_test_parse(first)) catch { + AlignBedError(message) => abort("valid BED writing failed: " + message) + } + assert_eq(second, first) +} diff --git a/test/moonbit/align_chain_test.mbt b/test/moonbit/align_chain_test.mbt new file mode 100644 index 00000000..50c41ddc --- /dev/null +++ b/test/moonbit/align_chain_test.mbt @@ -0,0 +1,1340 @@ +///| +fn align_chain_test_parse(text : String) -> @src.AlignChainAlignment { + @src.align_chain_parse(text) catch { + AlignChainError(message) => abort("valid chain input failed: " + message) + } +} + +///| +fn align_chain_test_parse_all(text : String) -> Array[@src.AlignChainAlignment] { + @src.align_chain_parse_all(text) catch { + AlignChainError(message) => abort("valid chain input failed: " + message) + } +} + +///| +fn align_chain_test_raises(text : String) -> Bool { + try { + ignore(@src.align_chain_parse(text)) + false + } catch { + AlignChainError(_) => true + } +} + +///| +fn align_chain_test_all_raises(text : String) -> Bool { + try { + ignore(@src.align_chain_parse_all(text)) + false + } catch { + AlignChainError(_) => true + } +} + +///| +fn align_chain_test_example() -> @src.AlignChainAlignment { + let alignments = align_chain_test_parse_all(@src.align_chain_example_text()) + alignments[0] +} + +///| +fn align_chain_test_reverse() -> @src.AlignChainAlignment { + let alignments = align_chain_test_parse_all(@src.align_chain_example_text()) + alignments[1] +} + +///| +fn align_chain_test_coordinate( + target : Int, + query : Int, +) -> @src.AlignChainCoordinate { + @src.AlignChainCoordinate::create(target, query) catch { + AlignChainError(message) => abort("valid coordinate failed: " + message) + } +} + +///| +fn align_chain_test_block( + size : Int, + target_gap : Int, + query_gap : Int, +) -> @src.AlignChainBlock { + @src.AlignChainBlock::create(size, target_gap~, query_gap~) catch { + AlignChainError(message) => abort("valid block failed: " + message) + } +} + +///| +fn align_chain_test_constructor_raises( + target_size : Int, + query_size : Int, + coordinates : Array[@src.AlignChainCoordinate], +) -> Bool { + try { + ignore( + @src.AlignChainAlignment::create( + "target", target_size, "query", query_size, coordinates, + ), + ) + false + } catch { + AlignChainError(_) => true + } +} + +///| +fn align_chain_test_from_blocks_raises( + target_start : Int, + target_end : Int, + query_start : Int, + query_end : Int, + blocks : Array[@src.AlignChainBlock], +) -> Bool { + try { + ignore( + @src.align_chain_from_blocks( + "target", 100, "+", target_start, target_end, "query", 100, "+", query_start, + query_end, blocks, + ), + ) + false + } catch { + AlignChainError(_) => true + } +} + +///| +test "align_chain example contains two records" { + let alignments = align_chain_test_parse_all(@src.align_chain_example_text()) + assert_eq(alignments.length(), 2) +} + +///| +test "align_chain official target identifier" { + assert_eq(align_chain_test_example().target_id, "chr3") +} + +///| +test "align_chain official target size" { + assert_eq(align_chain_test_example().target_size, 198295559) +} + +///| +test "align_chain official query identifier" { + assert_eq(align_chain_test_example().query_id, "NR_046654.1") +} + +///| +test "align_chain official query size" { + assert_eq(align_chain_test_example().query_size, 181) +} + +///| +test "align_chain official score" { + assert_eq(align_chain_test_example().score, 176.0) +} + +///| +test "align_chain official chain identifier" { + assert_eq(align_chain_test_example().chain_id, "1") +} + +///| +test "align_chain official target strand" { + assert_eq(align_chain_test_example().target_strand(), "+") +} + +///| +test "align_chain official query strand" { + assert_eq(align_chain_test_example().query_strand(), "-") +} + +///| +test "align_chain official coordinate count" { + assert_eq(align_chain_test_example().coordinates.length(), 6) +} + +///| +test "align_chain official first coordinate" { + let coordinate = align_chain_test_example().coordinates[0] + assert_eq(coordinate.target, 42530895) + assert_eq(coordinate.query, 181) +} + +///| +test "align_chain official first exon end coordinate" { + let coordinate = align_chain_test_example().coordinates[1] + assert_eq(coordinate.target, 42530958) + assert_eq(coordinate.query, 118) +} + +///| +test "align_chain official second exon start coordinate" { + let coordinate = align_chain_test_example().coordinates[2] + assert_eq(coordinate.target, 42532020) + assert_eq(coordinate.query, 118) +} + +///| +test "align_chain official second exon end coordinate" { + let coordinate = align_chain_test_example().coordinates[3] + assert_eq(coordinate.target, 42532095) + assert_eq(coordinate.query, 43) +} + +///| +test "align_chain official third exon start coordinate" { + let coordinate = align_chain_test_example().coordinates[4] + assert_eq(coordinate.target, 42532563) + assert_eq(coordinate.query, 43) +} + +///| +test "align_chain official final coordinate" { + let coordinate = align_chain_test_example().coordinates[5] + assert_eq(coordinate.target, 42532606) + assert_eq(coordinate.query, 0) +} + +///| +test "align_chain official normalized target span" { + let alignment = align_chain_test_example() + assert_eq(alignment.target_start(), 42530895) + assert_eq(alignment.target_end(), 42532606) +} + +///| +test "align_chain official normalized query span" { + let alignment = align_chain_test_example() + assert_eq(alignment.query_start(), 0) + assert_eq(alignment.query_end(), 181) +} + +///| +test "align_chain official operation path" { + assert_eq(align_chain_test_example().operation_path(), "MDMDM") +} + +///| +test "align_chain official alignment length" { + assert_eq(align_chain_test_example().alignment_length(), 1711) +} + +///| +test "align_chain official aligned bases" { + assert_eq(align_chain_test_example().aligned_bases(), 181) +} + +///| +test "align_chain official block count" { + assert_eq(align_chain_test_example().blocks().length(), 3) +} + +///| +test "align_chain official first block" { + let block = align_chain_test_example().blocks()[0] + assert_eq(block.size, 63) + assert_eq(block.target_gap, 1062) + assert_eq(block.query_gap, 0) +} + +///| +test "align_chain official second block" { + let block = align_chain_test_example().blocks()[1] + assert_eq(block.size, 75) + assert_eq(block.target_gap, 468) + assert_eq(block.query_gap, 0) +} + +///| +test "align_chain official final block" { + let block = align_chain_test_example().blocks()[2] + assert_eq(block.size, 43) + assert_eq(block.target_gap, 0) + assert_eq(block.query_gap, 0) +} + +///| +test "align_chain official count aligned" { + assert_eq(align_chain_test_example().counts().aligned, 181) +} + +///| +test "align_chain official count target gaps" { + assert_eq(align_chain_test_example().counts().target_gap_bases, 1530) +} + +///| +test "align_chain official count query gaps" { + assert_eq(align_chain_test_example().counts().query_gap_bases, 0) +} + +///| +test "align_chain official count gap columns" { + assert_eq(align_chain_test_example().counts().gap_columns, 1530) +} + +///| +test "align_chain official count gap opens" { + let counts = align_chain_test_example().counts() + assert_eq(counts.target_gap_opens, 2) + assert_eq(counts.query_gap_opens, 0) +} + +///| +test "align_chain official count aligned blocks" { + assert_eq(align_chain_test_example().counts().aligned_blocks, 3) +} + +///| +test "align_chain official count path segments" { + assert_eq(align_chain_test_example().counts().path_segments, 5) +} + +///| +test "align_chain official map first target residue" { + assert_eq(align_chain_test_example().map_target_position(42530895), Some(180)) +} + +///| +test "align_chain official map first exon end residue" { + assert_eq(align_chain_test_example().map_target_position(42530957), Some(118)) +} + +///| +test "align_chain official target intron is unmapped" { + assert_eq(align_chain_test_example().map_target_position(42530958), None) +} + +///| +test "align_chain official map second exon start" { + assert_eq(align_chain_test_example().map_target_position(42532020), Some(117)) +} + +///| +test "align_chain official map second exon end" { + assert_eq(align_chain_test_example().map_target_position(42532094), Some(43)) +} + +///| +test "align_chain official second intron is unmapped" { + assert_eq(align_chain_test_example().map_target_position(42532095), None) +} + +///| +test "align_chain official map final exon start" { + assert_eq(align_chain_test_example().map_target_position(42532563), Some(42)) +} + +///| +test "align_chain official map final target residue" { + assert_eq(align_chain_test_example().map_target_position(42532605), Some(0)) +} + +///| +test "align_chain official map first query residue" { + assert_eq(align_chain_test_example().map_query_position(180), Some(42530895)) +} + +///| +test "align_chain official map last query residue" { + assert_eq(align_chain_test_example().map_query_position(0), Some(42532605)) +} + +///| +test "align_chain official outside target returns none" { + let alignment = align_chain_test_example() + assert_eq(alignment.map_target_position(-1), None) + assert_eq(alignment.map_target_position(alignment.target_size), None) +} + +///| +test "align_chain official outside query returns none" { + let alignment = align_chain_test_example() + assert_eq(alignment.map_query_position(-1), None) + assert_eq(alignment.map_query_position(181), None) +} + +///| +test "align_chain official target range first exon" { + let mappings = align_chain_test_example().map_target_range(42530890, 42530960) + assert_eq(mappings.length(), 1) + assert_eq(mappings[0].target_start, 42530895) + assert_eq(mappings[0].target_end, 42530958) + assert_eq(mappings[0].query_start, 118) + assert_eq(mappings[0].query_end, 181) +} + +///| +test "align_chain official target range all exons" { + let alignment = align_chain_test_example() + let mappings = alignment.map_target_range( + alignment.target_start(), + alignment.target_end(), + ) + assert_eq(mappings.length(), 3) +} + +///| +test "align_chain official query range all exons" { + let mappings = align_chain_test_example().map_query_range(0, 181) + assert_eq(mappings.length(), 3) +} + +///| +test "align_chain official aligned pairs endpoints" { + let pairs = align_chain_test_example().aligned_pairs() + assert_eq(pairs.length(), 181) + assert_eq(pairs[0].target, 42530895) + assert_eq(pairs[0].query, 180) + assert_eq(pairs[180].target, 42532605) + assert_eq(pairs[180].query, 0) +} + +///| +test "align_chain aligned pair limit" { + let raised = try { + ignore(align_chain_test_example().aligned_pairs(limit=180)) + false + } catch { + AlignChainError(_) => true + } + assert_true(raised) +} + +///| +test "align_chain official summary" { + let summary = align_chain_test_example().summary() + assert_true(summary.contains("chr3")) + assert_true(summary.contains("aligned=181")) + assert_true(summary.contains("gaps=1530")) +} + +///| +test "align_chain reverse target strand" { + assert_eq(align_chain_test_reverse().target_strand(), "-") +} + +///| +test "align_chain reverse query strand" { + assert_eq(align_chain_test_reverse().query_strand(), "+") +} + +///| +test "align_chain reverse absolute target span" { + let alignment = align_chain_test_reverse() + assert_eq(alignment.target_start(), 800) + assert_eq(alignment.target_end(), 900) +} + +///| +test "align_chain reverse query span" { + let alignment = align_chain_test_reverse() + assert_eq(alignment.query_start(), 20) + assert_eq(alignment.query_end(), 130) +} + +///| +test "align_chain reverse coordinates" { + let alignment = align_chain_test_reverse() + assert_eq(alignment.coordinates.length(), 5) + assert_eq(alignment.coordinates[0].target, 900) + assert_eq(alignment.coordinates[4].target, 800) + assert_eq(alignment.coordinates[0].query, 20) + assert_eq(alignment.coordinates[4].query, 130) +} + +///| +test "align_chain reverse operation path" { + assert_eq(align_chain_test_reverse().operation_path(), "MDIM") +} + +///| +test "align_chain reverse alignment length" { + assert_eq(align_chain_test_reverse().alignment_length(), 120) +} + +///| +test "align_chain reverse aligned bases" { + assert_eq(align_chain_test_reverse().aligned_bases(), 90) +} + +///| +test "align_chain reverse target gap bases" { + assert_eq(align_chain_test_reverse().counts().target_gap_bases, 10) +} + +///| +test "align_chain reverse query gap bases" { + assert_eq(align_chain_test_reverse().counts().query_gap_bases, 20) +} + +///| +test "align_chain reverse gap opens" { + let counts = align_chain_test_reverse().counts() + assert_eq(counts.target_gap_opens, 1) + assert_eq(counts.query_gap_opens, 1) +} + +///| +test "align_chain reverse first target mapping" { + assert_eq(align_chain_test_reverse().map_target_position(899), Some(20)) +} + +///| +test "align_chain reverse first block end mapping" { + assert_eq(align_chain_test_reverse().map_target_position(860), Some(59)) +} + +///| +test "align_chain reverse target gap mapping" { + assert_eq(align_chain_test_reverse().map_target_position(859), None) +} + +///| +test "align_chain reverse second block mapping" { + assert_eq(align_chain_test_reverse().map_target_position(849), Some(80)) +} + +///| +test "align_chain reverse final mapping" { + assert_eq(align_chain_test_reverse().map_target_position(800), Some(129)) +} + +///| +test "align_chain reverse inserted query is unmapped" { + assert_eq(align_chain_test_reverse().map_query_position(60), None) + assert_eq(align_chain_test_reverse().map_query_position(79), None) +} + +///| +test "align_chain reverse query mapping" { + assert_eq(align_chain_test_reverse().map_query_position(80), Some(849)) +} + +///| +test "align_chain reverse range strand metadata" { + let mappings = align_chain_test_reverse().map_target_range(800, 900) + assert_eq(mappings.length(), 2) + assert_eq(mappings[0].target_strand, "-") + assert_eq(mappings[0].query_strand, "+") +} + +///| +test "align_chain invert identifiers" { + let inverted = align_chain_test_reverse().invert() + assert_eq(inverted.target_id, "queryA") + assert_eq(inverted.query_id, "chr1") +} + +///| +test "align_chain invert coordinates" { + let original = align_chain_test_reverse() + let inverted = original.invert() + assert_eq(inverted.coordinates[0].target, original.coordinates[0].query) + assert_eq(inverted.coordinates[0].query, original.coordinates[0].target) +} + +///| +test "align_chain invert twice roundtrip" { + let original = align_chain_test_reverse() + assert_eq(original.invert().invert(), original) +} + +///| +test "align_chain official canonical writer" { + let output = @src.align_chain_write(align_chain_test_example()) + assert_eq( + output, + "chain 176 chr3 198295559 + 42530895 42532606 NR_046654.1 181 - 0 181 1\n" + + "63\t1062\t0\n" + + "75\t468\t0\n" + + "43\n\n", + ) +} + +///| +test "align_chain reverse canonical writer" { + let output = @src.align_chain_write(align_chain_test_reverse()) + assert_eq( + output, + "chain 500 chr1 1000 - 100 200 queryA 500 + 20 130 reverse-target\n" + + "40\t10\t20\n" + + "50\n\n", + ) +} + +///| +test "align_chain canonical single roundtrip" { + let original = align_chain_test_example() + let reparsed = align_chain_test_parse(@src.align_chain_write(original)) + assert_eq(reparsed, original) +} + +///| +test "align_chain canonical multiple roundtrip" { + let original = align_chain_test_parse_all(@src.align_chain_example_text()) + let reparsed = align_chain_test_parse_all( + @src.align_chain_write_all(original), + ) + assert_eq(reparsed, original) +} + +///| +test "align_chain no identifier header" { + let alignment = align_chain_test_parse( + "chain 10 target 100 + 10 20 query 100 + 30 40\n10\n", + ) + assert_eq(alignment.chain_id, "") + assert_true(@src.align_chain_write(alignment).contains("query 100 + 30 40\n")) +} + +///| +test "align_chain decimal score" { + let alignment = align_chain_test_parse( + "chain 10.5 target 100 + 10 20 query 100 + 30 40 id\n10\n", + ) + assert_eq(alignment.score, 10.5) +} + +///| +test "align_chain exponent score" { + let alignment = align_chain_test_parse( + "chain 1e2 target 100 + 10 20 query 100 + 30 40 id\n10\n", + ) + assert_eq(alignment.score, 100.0) +} + +///| +test "align_chain explicit positive score" { + let alignment = align_chain_test_parse( + "chain +10 target 100 + 10 20 query 100 + 30 40 id\n10\n", + ) + assert_eq(alignment.score, 10.0) +} + +///| +test "align_chain negative score preserved" { + let alignment = align_chain_test_parse( + "chain -10 target 100 + 10 20 query 100 + 30 40 id\n10\n", + ) + assert_eq(alignment.score, -10.0) +} + +///| +test "align_chain CRLF input" { + let alignment = align_chain_test_parse( + "chain 10 target 100 + 10 20 query 100 + 30 40 id\r\n10\r\n", + ) + assert_eq(alignment.aligned_bases(), 10) +} + +///| +test "align_chain tab separated input" { + let alignment = align_chain_test_parse( + "chain\t10\ttarget\t100\t+\t10\t20\tquery\t100\t+\t30\t40\tid\n10\n", + ) + assert_eq(alignment.chain_id, "id") +} + +///| +test "align_chain leading and trailing blank lines" { + let alignments = align_chain_test_parse_all( + "\n\nchain 10 target 100 + 10 20 query 100 + 30 40 id\n10\n\n", + ) + assert_eq(alignments.length(), 1) +} + +///| +test "align_chain records need no blank separator" { + let alignments = align_chain_test_parse_all( + "chain 10 target 100 + 10 20 query 100 + 30 40 one\n10\n" + + "chain 20 target 100 + 20 30 query 100 + 40 50 two\n10\n", + ) + assert_eq(alignments.length(), 2) +} + +///| +test "align_chain size zero before initial target gap" { + let alignment = align_chain_test_parse( + "chain 10 target 100 + 10 25 query 100 + 30 40 id\n" + "0\t5\t0\n" + "10\n", + ) + assert_eq(alignment.operation_path(), "DM") + assert_eq(alignment.blocks()[0].size, 0) +} + +///| +test "align_chain trailing target gap and zero final block" { + let alignment = align_chain_test_parse( + "chain 10 target 100 + 10 25 query 100 + 30 40 id\n" + "10\t5\t0\n" + "0\n", + ) + assert_eq(alignment.operation_path(), "MD") + assert_eq(alignment.blocks()[1].size, 0) +} + +///| +test "align_chain block with both gap directions" { + let alignment = align_chain_test_parse( + "chain 20 target 100 + 10 35 query 100 + 20 47 id\n" + "10\t5\t7\n" + "10\n", + ) + assert_eq(alignment.operation_path(), "MDIM") +} + +///| +test "align_chain all strand combinations plus plus" { + let alignment = align_chain_test_parse( + "chain 10 target 100 + 10 20 query 100 + 30 40 pp\n10\n", + ) + assert_eq(alignment.coordinates[0].target, 10) + assert_eq(alignment.coordinates[0].query, 30) +} + +///| +test "align_chain all strand combinations plus minus" { + let alignment = align_chain_test_parse( + "chain 10 target 100 + 10 20 query 100 - 30 40 pm\n10\n", + ) + assert_eq(alignment.coordinates[0].target, 10) + assert_eq(alignment.coordinates[0].query, 70) + assert_eq(alignment.coordinates[1].query, 60) +} + +///| +test "align_chain all strand combinations minus plus" { + let alignment = align_chain_test_parse( + "chain 10 target 100 - 10 20 query 100 + 30 40 mp\n10\n", + ) + assert_eq(alignment.coordinates[0].target, 90) + assert_eq(alignment.coordinates[1].target, 80) + assert_eq(alignment.coordinates[0].query, 30) +} + +///| +test "align_chain all strand combinations minus minus" { + let alignment = align_chain_test_parse( + "chain 10 target 100 - 10 20 query 100 - 30 40 mm\n10\n", + ) + assert_eq(alignment.coordinates[0].target, 90) + assert_eq(alignment.coordinates[0].query, 70) + assert_eq(alignment.map_target_position(89), Some(69)) +} + +///| +test "align_chain constructor copies coordinates" { + let coordinates : Array[@src.AlignChainCoordinate] = [ + align_chain_test_coordinate(10, 20), + align_chain_test_coordinate(20, 30), + ] + let alignment = @src.AlignChainAlignment::create( + "target", 100, "query", 100, coordinates, + ) + coordinates.push(align_chain_test_coordinate(30, 40)) + assert_eq(alignment.coordinates.length(), 2) +} + +///| +test "align_chain coordinate constructor" { + let coordinate = @src.AlignChainCoordinate::create(12, 34) + assert_eq(coordinate.target, 12) + assert_eq(coordinate.query, 34) +} + +///| +test "align_chain block constructor defaults" { + let block = @src.AlignChainBlock::create(10) + assert_eq(block.size, 10) + assert_eq(block.target_gap, 0) + assert_eq(block.query_gap, 0) +} + +///| +test "align_chain from blocks constructor" { + let alignment = @src.align_chain_from_blocks( + "target", + 100, + "+", + 10, + 35, + "query", + 100, + "+", + 20, + 47, + [align_chain_test_block(10, 5, 7), align_chain_test_block(10, 0, 0)], + score=42.0, + chain_id="made", + ) + assert_eq(alignment.operation_path(), "MDIM") + assert_eq(alignment.score, 42.0) + assert_eq(alignment.chain_id, "made") +} + +///| +test "align_chain adjacent match segments canonicalize" { + let alignment = @src.AlignChainAlignment::create( + "target", + 100, + "query", + 100, + [ + align_chain_test_coordinate(10, 20), + align_chain_test_coordinate(15, 25), + align_chain_test_coordinate(20, 30), + ], + ) + let blocks = alignment.blocks() + assert_eq(blocks.length(), 1) + assert_eq(blocks[0].size, 10) +} + +///| +test "align_chain find by identifier" { + let alignments = align_chain_test_parse_all(@src.align_chain_example_text()) + let found = @src.align_chain_find_by_id(alignments, "reverse-target") + assert_true(found is Some(_)) + match found { + Some(alignment) => assert_eq(alignment.target_id, "chr1") + None => () + } +} + +///| +test "align_chain missing identifier lookup" { + let alignments = align_chain_test_parse_all(@src.align_chain_example_text()) + assert_eq(@src.align_chain_find_by_id(alignments, "missing"), None) +} + +///| +test "align_chain target overlap query" { + let alignments = align_chain_test_parse_all(@src.align_chain_example_text()) + let matches = @src.align_chain_target_overlaps( + alignments, "chr3", 42532000, 42532100, + ) + assert_eq(matches.length(), 1) +} + +///| +test "align_chain target overlap excludes touching endpoint" { + let alignments = align_chain_test_parse_all(@src.align_chain_example_text()) + let matches = @src.align_chain_target_overlaps( + alignments, "chr3", 42532606, 42532607, + ) + assert_eq(matches.length(), 0) +} + +///| +test "align_chain empty parse all" { + assert_eq(align_chain_test_parse_all("").length(), 0) +} + +///| +test "align_chain whitespace parse all" { + assert_eq(align_chain_test_parse_all(" \n\t\n").length(), 0) +} + +///| +test "align_chain parse requires one record" { + assert_true(align_chain_test_raises("")) +} + +///| +test "align_chain parse rejects multiple records" { + assert_true(align_chain_test_raises(@src.align_chain_example_text())) +} + +///| +test "align_chain rejects content before header" { + assert_true( + align_chain_test_all_raises( + "comment\nchain 10 target 100 + 10 20 query 100 + 30 40 id\n10\n", + ), + ) +} + +///| +test "align_chain rejects short header" { + assert_true( + align_chain_test_raises("chain 10 target 100 + 10 20 query 100 + 30\n10\n"), + ) +} + +///| +test "align_chain rejects long header" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 20 query 100 + 30 40 id extra\n10\n", + ), + ) +} + +///| +test "align_chain rejects wrong keyword" { + assert_true( + align_chain_test_raises( + "chains 10 target 100 + 10 20 query 100 + 30 40 id\n10\n", + ), + ) +} + +///| +test "align_chain rejects invalid score" { + assert_true( + align_chain_test_raises( + "chain score target 100 + 10 20 query 100 + 30 40 id\n10\n", + ), + ) +} + +///| +test "align_chain rejects incomplete exponent score" { + assert_true( + align_chain_test_raises( + "chain 1e target 100 + 10 20 query 100 + 30 40 id\n10\n", + ), + ) +} + +///| +test "align_chain rejects non-finite score" { + assert_true( + align_chain_test_raises( + "chain 1e999 target 100 + 10 20 query 100 + 30 40 id\n10\n", + ), + ) +} + +///| +test "align_chain rejects invalid target size" { + assert_true( + align_chain_test_raises( + "chain 10 target size + 10 20 query 100 + 30 40 id\n10\n", + ), + ) +} + +///| +test "align_chain rejects integer overflow" { + assert_true( + align_chain_test_raises( + "chain 10 target 999999999999 + 10 20 query 100 + 30 40 id\n10\n", + ), + ) +} + +///| +test "align_chain rejects negative coordinate" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + -1 20 query 100 + 30 40 id\n10\n", + ), + ) +} + +///| +test "align_chain rejects target start after end" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 20 10 query 100 + 30 40 id\n10\n", + ), + ) +} + +///| +test "align_chain rejects target end beyond size" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 90 110 query 100 + 30 50 id\n20\n", + ), + ) +} + +///| +test "align_chain rejects query start after end" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 20 query 100 + 40 30 id\n10\n", + ), + ) +} + +///| +test "align_chain rejects query end beyond size" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 30 query 100 + 90 110 id\n20\n", + ), + ) +} + +///| +test "align_chain rejects target strand" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 ? 10 20 query 100 + 30 40 id\n10\n", + ), + ) +} + +///| +test "align_chain rejects query strand" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 20 query 100 ? 30 40 id\n10\n", + ), + ) +} + +///| +test "align_chain rejects missing block" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 20 query 100 + 30 40 id\n", + ), + ) +} + +///| +test "align_chain rejects blank before final block" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 20 query 100 + 30 40 id\n\n10\n", + ), + ) +} + +///| +test "align_chain rejects next header before final block" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 20 query 100 + 30 40 one\n" + + "chain 10 target 100 + 20 30 query 100 + 40 50 two\n10\n", + ), + ) +} + +///| +test "align_chain rejects two-field block" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 20 query 100 + 30 40 id\n5 5\n5\n", + ), + ) +} + +///| +test "align_chain rejects four-field block" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 20 query 100 + 30 40 id\n5 1 1 1\n5\n", + ), + ) +} + +///| +test "align_chain rejects invalid block integer" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 20 query 100 + 30 40 id\nfive\n", + ), + ) +} + +///| +test "align_chain rejects negative block integer" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 20 query 100 + 30 40 id\n-10\n", + ), + ) +} + +///| +test "align_chain rejects zero gaps on non-final block" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 20 query 100 + 30 40 id\n5 0 0\n5\n", + ), + ) +} + +///| +test "align_chain rejects target span mismatch" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 25 query 100 + 30 40 id\n10\n", + ), + ) +} + +///| +test "align_chain rejects query span mismatch" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 20 query 100 + 30 45 id\n10\n", + ), + ) +} + +///| +test "align_chain rejects blocks exceeding target span" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 20 query 100 + 30 40 id\n11\n", + ), + ) +} + +///| +test "align_chain rejects blocks exceeding query span" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 20 query 100 + 30 39 id\n10\n", + ), + ) +} + +///| +test "align_chain rejects all-gap record" { + assert_true( + align_chain_test_raises( + "chain 10 target 100 + 10 15 query 100 + 30 30 id\n0 5 0\n0\n", + ), + ) +} + +///| +test "align_chain coordinate constructor rejects negative target" { + let raised = try { + ignore(@src.AlignChainCoordinate::create(-1, 0)) + false + } catch { + AlignChainError(_) => true + } + assert_true(raised) +} + +///| +test "align_chain coordinate constructor rejects negative query" { + let raised = try { + ignore(@src.AlignChainCoordinate::create(0, -1)) + false + } catch { + AlignChainError(_) => true + } + assert_true(raised) +} + +///| +test "align_chain block constructor rejects negative size" { + let raised = try { + ignore(@src.AlignChainBlock::create(-1)) + false + } catch { + AlignChainError(_) => true + } + assert_true(raised) +} + +///| +test "align_chain block constructor rejects negative target gap" { + let raised = try { + ignore(@src.AlignChainBlock::create(1, target_gap=-1)) + false + } catch { + AlignChainError(_) => true + } + assert_true(raised) +} + +///| +test "align_chain constructor rejects empty target identifier" { + let raised = try { + ignore( + @src.AlignChainAlignment::create("", 100, "query", 100, [ + align_chain_test_coordinate(10, 20), + align_chain_test_coordinate(20, 30), + ]), + ) + false + } catch { + AlignChainError(_) => true + } + assert_true(raised) +} + +///| +test "align_chain constructor rejects identifier whitespace" { + let raised = try { + ignore( + @src.AlignChainAlignment::create("bad target", 100, "query", 100, [ + align_chain_test_coordinate(10, 20), + align_chain_test_coordinate(20, 30), + ]), + ) + false + } catch { + AlignChainError(_) => true + } + assert_true(raised) +} + +///| +test "align_chain constructor rejects negative target size" { + assert_true( + align_chain_test_constructor_raises(-1, 100, [ + align_chain_test_coordinate(0, 0), + align_chain_test_coordinate(10, 10), + ]), + ) +} + +///| +test "align_chain constructor rejects coordinate outside target" { + assert_true( + align_chain_test_constructor_raises(10, 100, [ + align_chain_test_coordinate(0, 0), + align_chain_test_coordinate(11, 11), + ]), + ) +} + +///| +test "align_chain constructor rejects coordinate outside query" { + assert_true( + align_chain_test_constructor_raises(100, 10, [ + align_chain_test_coordinate(0, 0), + align_chain_test_coordinate(11, 11), + ]), + ) +} + +///| +test "align_chain constructor rejects one point" { + assert_true( + align_chain_test_constructor_raises(100, 100, [ + align_chain_test_coordinate(0, 0), + ]), + ) +} + +///| +test "align_chain constructor rejects duplicate points" { + assert_true( + align_chain_test_constructor_raises(100, 100, [ + align_chain_test_coordinate(10, 10), + align_chain_test_coordinate(10, 10), + ]), + ) +} + +///| +test "align_chain constructor rejects unequal diagonal" { + assert_true( + align_chain_test_constructor_raises(100, 100, [ + align_chain_test_coordinate(10, 10), + align_chain_test_coordinate(20, 25), + ]), + ) +} + +///| +test "align_chain constructor rejects target direction change" { + assert_true( + align_chain_test_constructor_raises(100, 100, [ + align_chain_test_coordinate(10, 10), + align_chain_test_coordinate(20, 20), + align_chain_test_coordinate(15, 20), + ]), + ) +} + +///| +test "align_chain constructor rejects query direction change" { + assert_true( + align_chain_test_constructor_raises(100, 100, [ + align_chain_test_coordinate(10, 10), + align_chain_test_coordinate(20, 20), + align_chain_test_coordinate(20, 15), + ]), + ) +} + +///| +test "align_chain constructor rejects gaps-only path" { + assert_true( + align_chain_test_constructor_raises(100, 100, [ + align_chain_test_coordinate(10, 10), + align_chain_test_coordinate(20, 10), + align_chain_test_coordinate(20, 30), + ]), + ) +} + +///| +test "align_chain from blocks rejects empty blocks" { + assert_true(align_chain_test_from_blocks_raises(10, 20, 30, 40, [])) +} + +///| +test "align_chain from blocks rejects non-final zero gaps" { + assert_true( + align_chain_test_from_blocks_raises(10, 20, 30, 40, [ + align_chain_test_block(5, 0, 0), + align_chain_test_block(5, 0, 0), + ]), + ) +} + +///| +test "align_chain from blocks rejects final gaps" { + assert_true( + align_chain_test_from_blocks_raises(10, 20, 30, 40, [ + align_chain_test_block(5, 5, 0), + ]), + ) +} + +///| +test "align_chain invalid target range" { + let raised = try { + ignore(align_chain_test_example().map_target_range(10, 10)) + false + } catch { + AlignChainError(_) => true + } + assert_true(raised) +} + +///| +test "align_chain invalid query range" { + let raised = try { + ignore(align_chain_test_example().map_query_range(-1, 10)) + false + } catch { + AlignChainError(_) => true + } + assert_true(raised) +} + +///| +test "align_chain invalid overlap query" { + let raised = try { + ignore(@src.align_chain_target_overlaps([], "chr1", 10, 10)) + false + } catch { + AlignChainError(_) => true + } + assert_true(raised) +} + +///| +test "align_chain negative aligned pair limit" { + let raised = try { + ignore(align_chain_test_example().aligned_pairs(limit=-1)) + false + } catch { + AlignChainError(_) => true + } + assert_true(raised) +} diff --git a/test/moonbit/align_maf_test.mbt b/test/moonbit/align_maf_test.mbt new file mode 100644 index 00000000..83c5a515 --- /dev/null +++ b/test/moonbit/align_maf_test.mbt @@ -0,0 +1,1266 @@ +///| +fn align_maf_test_parse(text : String) -> @src.AlignMafDocument { + @src.align_maf_parse(text) catch { + AlignMafError(message) => abort("valid MAF input failed: " + message) + } +} + +///| +fn align_maf_test_document() -> @src.AlignMafDocument { + align_maf_test_parse(@src.align_maf_example_text()) +} + +///| +fn align_maf_test_index() -> @src.AlignMafIndex { + @src.AlignMafIndex::create(align_maf_test_document(), "hg38.chr7") catch { + AlignMafError(message) => abort("valid MAF index failed: " + message) + } +} + +///| +fn align_maf_test_rejects(text : String) -> Bool { + try { + ignore(@src.align_maf_parse(text)) + false + } catch { + AlignMafError(_) => true + } +} + +///| +fn align_maf_test_single(lines : String) -> String { + "##maf version=1\n\n" + lines +} + +///| +test "Bio.Align.maf parses the MAF version" { + assert_eq(align_maf_test_document().version, "1") +} + +///| +test "Bio.Align.maf parses scoring metadata" { + assert_eq(align_maf_test_document().scoring, Some("blastz")) +} + +///| +test "Bio.Align.maf parses program metadata" { + assert_eq(align_maf_test_document().program, Some("multiz")) +} + +///| +test "Bio.Align.maf parses header comments" { + let document = align_maf_test_document() + assert_eq(document.comments, ["generated fixture"]) +} + +///| +test "Bio.Align.maf parses three consecutive blocks" { + assert_eq(align_maf_test_document().blocks.length(), 3) +} + +///| +test "Bio.Align.maf parses a track line" { + assert_true(align_maf_test_document().track is Some(_)) +} + +///| +test "Bio.Align.maf preserves a quoted track name" { + let track = align_maf_test_document().track.unwrap() + assert_eq(track.name, Some("Multiz demo")) +} + +///| +test "Bio.Align.maf preserves a quoted track description" { + let track = align_maf_test_document().track.unwrap() + assert_eq(track.description, Some("MAF coordinate example")) +} + +///| +test "Bio.Align.maf preserves mafDot metadata" { + let track = align_maf_test_document().track.unwrap() + assert_eq(track.maf_dot, Some("on")) +} + +///| +test "Bio.Align.maf preserves visibility metadata" { + let track = align_maf_test_document().track.unwrap() + assert_eq(track.visibility, Some("pack")) +} + +///| +test "Bio.Align.maf splits speciesOrder metadata" { + let track = align_maf_test_document().track.unwrap() + assert_eq(track.species_order, ["hg38", "mm39", "rn7"]) +} + +///| +test "Bio.Align.maf accepts a header-only document" { + let document = align_maf_test_parse("##maf version=1\n") + assert_eq(document.blocks.length(), 0) +} + +///| +test "Bio.Align.maf accepts leading blank lines" { + let document = align_maf_test_parse("\n\n##maf version=1\n") + assert_eq(document.version, "1") +} + +///| +test "Bio.Align.maf accepts CRLF input" { + let text = "##maf version=1\r\n\r\na score=1\r\ns ref 0 2 + 10 AC\r\n" + assert_eq(align_maf_test_parse(text).blocks.length(), 1) +} + +///| +test "Bio.Align.maf accepts tab-separated component fields" { + let text = align_maf_test_single("a\ns\tref\t0\t2\t+\t10\tAC\n") + assert_eq(align_maf_test_parse(text).blocks[0].components.length(), 1) +} + +///| +test "Bio.Align.maf parses a floating point score" { + assert_eq(align_maf_test_document().blocks[0].score, Some(23262.0)) +} + +///| +test "Bio.Align.maf parses a positive pass annotation" { + assert_eq(align_maf_test_document().blocks[0].pass_number, Some(1)) +} + +///| +test "Bio.Align.maf parses scientific score notation" { + let text = align_maf_test_single("a score=1.25e2\ns ref 0 2 + 10 AC\n") + assert_eq(align_maf_test_parse(text).blocks[0].score, Some(125.0)) +} + +///| +test "Bio.Align.maf parses an explicit positive score" { + let text = align_maf_test_single("a score=+2.5\ns ref 0 2 + 10 AC\n") + assert_eq(align_maf_test_parse(text).blocks[0].score, Some(2.5)) +} + +///| +test "Bio.Align.maf parses a negative score" { + let text = align_maf_test_single("a score=-2.5\ns ref 0 2 + 10 AC\n") + assert_eq(align_maf_test_parse(text).blocks[0].score, Some(-2.5)) +} + +///| +test "Bio.Align.maf allows an alignment without score" { + let text = align_maf_test_single("a\ns ref 0 2 + 10 AC\n") + assert_eq(align_maf_test_parse(text).blocks[0].score, None) +} + +///| +test "Bio.Align.maf preserves aligned component fields" { + let component = align_maf_test_document().blocks[0].components[0] + assert_eq(component.source, "hg38.chr7") + assert_eq(component.start, 100) + assert_eq(component.size, 8) + assert_eq(component.strand, "+") + assert_eq(component.source_size, 1000) + assert_eq(component.text, "AC-TGCAAT") +} + +///| +test "Bio.Align.maf preserves a reverse component" { + let component = align_maf_test_document().blocks[0].components[1] + assert_eq(component.source, "mm39.chr5") + assert_eq(component.strand, "-") + assert_eq(component.forward_interval(), (442, 450)) +} + +///| +test "Bio.Align.maf attaches insertion context to the preceding component" { + let insertion = align_maf_test_document().blocks[0].components[0].insertion + assert_true(insertion is Some(_)) + assert_eq(insertion.unwrap().left_status, "C") + assert_eq(insertion.unwrap().right_status, "I") +} + +///| +test "Bio.Align.maf preserves insertion counts" { + let insertion = align_maf_test_document().blocks[0].components[0].insertion.unwrap() + assert_eq(insertion.left_count, 0) + assert_eq(insertion.right_count, 2) +} + +///| +test "Bio.Align.maf attaches aligned quality" { + let quality = align_maf_test_document().blocks[0].components[0].quality + assert_eq(quality, Some("98-765432")) +} + +///| +test "Bio.Align.maf parses empty components" { + let empty = align_maf_test_document().blocks[0].empty_components[0] + assert_eq(empty.source, "rn7.chr1") + assert_eq(empty.status, "I") +} + +///| +test "Bio.Align.maf computes empty reverse intervals" { + let text = align_maf_test_single("a\ns ref 0 2 + 10 AC\ne other 3 2 - 20 C\n") + let empty = align_maf_test_parse(text).blocks[0].empty_components[0] + assert_eq(empty.forward_interval(), (15, 17)) +} + +///| +test "Bio.Align.maf normalizes period gap characters" { + let text = align_maf_test_single("a\ns ref 0 2 + 10 A.C\n") + assert_eq(align_maf_test_parse(text).blocks[0].components[0].text, "A-C") +} + +///| +test "Bio.Align.maf normalizes equals gap characters" { + let text = align_maf_test_single("a\ns ref 0 2 + 10 A=C\n") + assert_eq(align_maf_test_parse(text).blocks[0].components[0].text, "A-C") +} + +///| +test "Bio.Align.maf normalizes underscore gap characters" { + let text = align_maf_test_single("a\ns ref 0 2 + 10 A_C\n") + assert_eq(align_maf_test_parse(text).blocks[0].components[0].text, "A-C") +} + +///| +test "Bio.Align.maf ignores comments inside blocks" { + let text = align_maf_test_single("a\n# block note\ns ref 0 2 + 10 AC\n") + assert_eq(align_maf_test_parse(text).blocks.length(), 1) +} + +///| +test "Bio.Align.maf preserves equal component widths" { + assert_eq(align_maf_test_document().blocks[0].aligned_columns(), 9) +} + +///| +test "Bio.Align.maf removes sequence gaps" { + let component = align_maf_test_document().blocks[0].components[0] + assert_eq(component.sequence(), "ACTGCAAT") +} + +///| +test "Bio.Align.maf reports block sources in file order" { + assert_eq(align_maf_test_document().blocks[0].sources(), [ + "hg38.chr7", "mm39.chr5", + ]) +} + +///| +test "Bio.Align.maf reports document sources in first-seen order" { + assert_eq(align_maf_test_document().sources(), [ + "hg38.chr7", "mm39.chr5", "rn7.chr1", + ]) +} + +///| +test "Bio.Align.maf summary counts blocks" { + assert_eq(align_maf_test_document().summary().block_count, 3) +} + +///| +test "Bio.Align.maf summary counts aligned components" { + assert_eq(align_maf_test_document().summary().component_count, 6) +} + +///| +test "Bio.Align.maf summary counts empty components" { + assert_eq(align_maf_test_document().summary().empty_component_count, 1) +} + +///| +test "Bio.Align.maf summary counts alignment columns" { + assert_eq(align_maf_test_document().summary().aligned_columns, 17) +} + +///| +test "Bio.Align.maf summary counts reference bases" { + assert_eq(align_maf_test_document().summary().reference_bases, 16) +} + +///| +test "Bio.Align.maf summary counts distinct sources" { + assert_eq(align_maf_test_document().summary().source_count, 3) +} + +///| +test "Bio.Align.maf builds compressed coordinate breakpoints" { + let path = @src.align_maf_coordinate_path(align_maf_test_document().blocks[0]) + assert_eq(path.length(), 6) + assert_eq(path[0].column, 0) + assert_eq(path[5].column, 9) +} + +///| +test "Bio.Align.maf coordinate path uses absolute starts" { + let path = @src.align_maf_coordinate_path(align_maf_test_document().blocks[0]) + assert_eq(path[0].positions, [100, 450]) +} + +///| +test "Bio.Align.maf coordinate path uses decreasing reverse coordinates" { + let path = @src.align_maf_coordinate_path(align_maf_test_document().blocks[0]) + assert_eq(path[path.length() - 1].positions, [108, 442]) +} + +///| +test "Bio.Align.maf coordinate path marks first gap-pattern change" { + let path = @src.align_maf_coordinate_path(align_maf_test_document().blocks[0]) + assert_eq(path[1].column, 2) + assert_eq(path[1].positions, [102, 448]) +} + +///| +test "Bio.Align.maf coordinate path marks reference insertion boundary" { + let path = @src.align_maf_coordinate_path(align_maf_test_document().blocks[0]) + assert_eq(path[2].column, 3) + assert_eq(path[2].positions, [102, 447]) +} + +///| +test "Bio.Align.maf maps a reference base to reverse source coordinates" { + let block = align_maf_test_document().blocks[0] + assert_eq( + @src.align_maf_map_position(block, "hg38.chr7", 100, "mm39.chr5"), + Some(449), + ) +} + +///| +test "Bio.Align.maf maps after a reference gap" { + let block = align_maf_test_document().blocks[0] + assert_eq( + @src.align_maf_map_position(block, "hg38.chr7", 102, "mm39.chr5"), + Some(446), + ) +} + +///| +test "Bio.Align.maf maps reverse source coordinates back to reference" { + let block = align_maf_test_document().blocks[0] + assert_eq( + @src.align_maf_map_position(block, "mm39.chr5", 449, "hg38.chr7"), + Some(100), + ) +} + +///| +test "Bio.Align.maf returns none when destination has a gap" { + let block = align_maf_test_document().blocks[0] + assert_eq( + @src.align_maf_map_position(block, "mm39.chr5", 447, "hg38.chr7"), + None, + ) + assert_eq( + @src.align_maf_map_position(block, "hg38.chr7", 104, "mm39.chr5"), + None, + ) +} + +///| +test "Bio.Align.maf returns none when source is absent" { + let block = align_maf_test_document().blocks[0] + assert_eq(@src.align_maf_map_position(block, "missing", 1, "hg38.chr7"), None) +} + +///| +test "Bio.Align.maf returns none when destination is absent" { + let block = align_maf_test_document().blocks[0] + assert_eq( + @src.align_maf_map_position(block, "hg38.chr7", 100, "missing"), + None, + ) +} + +///| +test "Bio.Align.maf returns none outside the source interval" { + let block = align_maf_test_document().blocks[0] + assert_eq( + @src.align_maf_map_position(block, "hg38.chr7", 99, "mm39.chr5"), + None, + ) +} + +///| +test "Bio.Align.maf writes canonical header metadata" { + let output = @src.align_maf_write(align_maf_test_document()) catch { + AlignMafError(message) => abort("valid MAF write failed: " + message) + } + assert_true(output.contains("##maf version=1 scoring=blastz program=multiz")) +} + +///| +test "Bio.Align.maf writes canonical track metadata" { + let output = @src.align_maf_write(align_maf_test_document()) catch { + AlignMafError(message) => abort("valid MAF write failed: " + message) + } + assert_true(output.has_prefix("track name=\"Multiz demo\"")) +} + +///| +test "Bio.Align.maf writes header comments" { + let output = @src.align_maf_write(align_maf_test_document()) catch { + AlignMafError(message) => abort("valid MAF write failed: " + message) + } + assert_true(output.contains("# generated fixture")) +} + +///| +test "Bio.Align.maf writes insertion lines" { + let output = @src.align_maf_write(align_maf_test_document()) catch { + AlignMafError(message) => abort("valid MAF write failed: " + message) + } + assert_true(output.contains("i hg38.chr7 C 0 I 2")) +} + +///| +test "Bio.Align.maf writes quality lines" { + let output = @src.align_maf_write(align_maf_test_document()) catch { + AlignMafError(message) => abort("valid MAF write failed: " + message) + } + assert_true(output.contains("q hg38.chr7 98-765432")) +} + +///| +test "Bio.Align.maf writes empty component lines" { + let output = @src.align_maf_write(align_maf_test_document()) catch { + AlignMafError(message) => abort("valid MAF write failed: " + message) + } + assert_true(output.contains("e rn7.chr1 80 6 + 700 I")) +} + +///| +test "Bio.Align.maf canonical output round-trips" { + let document = align_maf_test_document() + let output = @src.align_maf_write(document) catch { + AlignMafError(message) => abort("valid MAF write failed: " + message) + } + assert_eq(align_maf_test_parse(output), document) +} + +///| +test "Bio.Align.maf header-only output round-trips" { + let document = align_maf_test_parse("##maf version=1\n") + let output = @src.align_maf_write(document) catch { + AlignMafError(message) => abort("valid MAF write failed: " + message) + } + assert_eq(align_maf_test_parse(output), document) +} + +///| +test "Bio.Align.maf track writer escapes quotes" { + let track = @src.AlignMafTrack::create(description=Some("quoted \"value\"")) catch { + AlignMafError(message) => abort("valid track failed: " + message) + } + let document = @src.AlignMafDocument::create([], track=Some(track)) catch { + AlignMafError(message) => abort("valid document failed: " + message) + } + let output = @src.align_maf_write(document) catch { + AlignMafError(message) => abort("valid MAF write failed: " + message) + } + assert_eq(align_maf_test_parse(output), document) +} + +///| +test "Bio.Align.maf track constructor copies speciesOrder" { + let species = ["hg38"] + let track = @src.AlignMafTrack::create(species_order=species) catch { + AlignMafError(message) => abort("valid track failed: " + message) + } + species.push("mm39") + assert_eq(track.species_order, ["hg38"]) +} + +///| +test "Bio.Align.maf document constructor copies blocks" { + let blocks = align_maf_test_document().blocks.copy() + let document = @src.AlignMafDocument::create(blocks) catch { + AlignMafError(message) => abort("valid document failed: " + message) + } + ignore(blocks.pop()) + assert_eq(document.blocks.length(), 3) +} + +///| +test "Bio.Align.maf index stores one entry per block" { + assert_eq(align_maf_test_index().entry_count(), 3) +} + +///| +test "Bio.Align.maf index preserves reference metadata" { + let index = align_maf_test_index() + assert_eq(index.reference, "hg38.chr7") + assert_eq(index.source_size, 1000) + assert_eq(index.reference_strand, "+") +} + +///| +test "Bio.Align.maf index sorts reference intervals" { + let index = align_maf_test_index() + assert_eq(index.entries[0].start, 100) + assert_eq(index.entries[1].start, 110) + assert_eq(index.entries[2].start, 120) +} + +///| +test "Bio.Align.maf index search finds an overlapping block" { + let hits = align_maf_test_index().search(103, 104) catch { + AlignMafError(message) => abort("valid search failed: " + message) + } + assert_eq(hits.length(), 1) + assert_eq(hits[0].components[0].start, 100) +} + +///| +test "Bio.Align.maf index search uses half-open left boundary" { + let hits = align_maf_test_index().search(108, 110) catch { + AlignMafError(message) => abort("valid search failed: " + message) + } + assert_eq(hits.length(), 0) +} + +///| +test "Bio.Align.maf index search uses half-open right boundary" { + let hits = align_maf_test_index().search(107, 108) catch { + AlignMafError(message) => abort("valid search failed: " + message) + } + assert_eq(hits.length(), 1) +} + +///| +test "Bio.Align.maf index search spans multiple blocks" { + let hits = align_maf_test_index().search(107, 121) catch { + AlignMafError(message) => abort("valid search failed: " + message) + } + assert_eq(hits.length(), 3) +} + +///| +test "Bio.Align.maf index range search deduplicates blocks" { + let hits = align_maf_test_index().search_ranges([100, 102], [104, 106]) catch { + AlignMafError(message) => abort("valid range search failed: " + message) + } + assert_eq(hits.length(), 1) +} + +///| +test "Bio.Align.maf index range search returns file order" { + let hits = align_maf_test_index().search_ranges([120, 100], [121, 101]) catch { + AlignMafError(message) => abort("valid range search failed: " + message) + } + assert_eq(hits.length(), 2) + assert_eq(hits[0].components[0].start, 100) + assert_eq(hits[1].components[0].start, 120) +} + +///| +test "Bio.Align.maf splices two reference exons" { + let spliced = align_maf_test_index().get_spliced([102, 110], [106, 113]) catch { + AlignMafError(message) => abort("valid splice failed: " + message) + } + assert_eq(spliced.reference, "hg38.chr7") + assert_eq(spliced.columns, 7) + assert_eq(spliced.sequence("hg38.chr7"), Some("TGCAGGT")) +} + +///| +test "Bio.Align.maf splicing preserves target gaps" { + let spliced = align_maf_test_index().get_spliced([102, 110], [106, 113]) catch { + AlignMafError(message) => abort("valid splice failed: " + message) + } + assert_eq(spliced.sequence("mm39.chr5"), Some("TG-AG-T")) +} + +///| +test "Bio.Align.maf splicing fills missing species with gaps" { + let spliced = align_maf_test_index().get_spliced([120], [124]) catch { + AlignMafError(message) => abort("valid splice failed: " + message) + } + assert_eq(spliced.sequence("mm39.chr5"), Some("----")) + assert_eq(spliced.sequence("rn7.chr1"), Some("AATA")) +} + +///| +test "Bio.Align.maf splicing fills uncovered reference with N" { + let spliced = align_maf_test_index().get_spliced([106], [112]) catch { + AlignMafError(message) => abort("valid splice failed: " + message) + } + assert_eq(spliced.sequence("hg38.chr7"), Some("ATNNGG")) +} + +///| +test "Bio.Align.maf splicing fills uncovered targets with gaps" { + let spliced = align_maf_test_index().get_spliced([106], [112]) catch { + AlignMafError(message) => abort("valid splice failed: " + message) + } + assert_eq(spliced.sequence("mm39.chr5"), Some("AT--G-")) +} + +///| +test "Bio.Align.maf reverse-strand splicing reverse-complements output" { + let spliced = align_maf_test_index().get_spliced( + [102, 110], + [106, 113], + strand="-", + ) catch { + AlignMafError(message) => abort("valid splice failed: " + message) + } + assert_eq(spliced.sequence("hg38.chr7"), Some("ACCTGCA")) + assert_eq(spliced.strand, "-") +} + +///| +test "Bio.Align.maf spliced output records exon coordinates" { + let spliced = align_maf_test_index().get_spliced([102, 110], [106, 113]) catch { + AlignMafError(message) => abort("valid splice failed: " + message) + } + assert_eq(spliced.starts, [102, 110]) + assert_eq(spliced.ends, [106, 113]) +} + +///| +test "Bio.Align.maf spliced sequence lookup returns none for missing source" { + let spliced = align_maf_test_index().get_spliced([102], [106]) catch { + AlignMafError(message) => abort("valid splice failed: " + message) + } + assert_eq(spliced.sequence("missing"), None) +} + +///| +test "Bio.Align.maf reports spliced ungapped length" { + let spliced = align_maf_test_index().get_spliced([102, 110], [106, 113]) catch { + AlignMafError(message) => abort("valid splice failed: " + message) + } + assert_eq(spliced.ungapped_length("mm39.chr5"), Some(5)) +} + +///| +test "Bio.Align.maf excludes uncovered N from ungapped length" { + let spliced = align_maf_test_index().get_spliced([106], [112]) catch { + AlignMafError(message) => abort("valid splice failed: " + message) + } + assert_eq(spliced.ungapped_length("hg38.chr7"), Some(4)) +} + +///| +test "Bio.Align.maf rejects empty input" { + assert_true(align_maf_test_rejects("")) +} + +///| +test "Bio.Align.maf rejects input without a header" { + assert_true(align_maf_test_rejects("a\ns ref 0 2 + 10 AC\n")) +} + +///| +test "Bio.Align.maf rejects a header without version" { + assert_true(align_maf_test_rejects("##maf scoring=x\n")) +} + +///| +test "Bio.Align.maf rejects unsupported versions" { + assert_true(align_maf_test_rejects("##maf version=2\n")) +} + +///| +test "Bio.Align.maf rejects duplicate version metadata" { + assert_true(align_maf_test_rejects("##maf version=1 version=1\n")) +} + +///| +test "Bio.Align.maf rejects duplicate scoring metadata" { + assert_true(align_maf_test_rejects("##maf version=1 scoring=x scoring=y\n")) +} + +///| +test "Bio.Align.maf rejects duplicate program metadata" { + assert_true(align_maf_test_rejects("##maf version=1 program=x program=y\n")) +} + +///| +test "Bio.Align.maf rejects unknown header metadata" { + assert_true(align_maf_test_rejects("##maf version=1 unknown=x\n")) +} + +///| +test "Bio.Align.maf rejects malformed header metadata" { + assert_true(align_maf_test_rejects("##maf version\n")) +} + +///| +test "Bio.Align.maf rejects a data line before an alignment line" { + assert_true(align_maf_test_rejects("##maf version=1\ns ref 0 2 + 10 AC\n")) +} + +///| +test "Bio.Align.maf rejects an empty track line" { + assert_true(align_maf_test_rejects("track\n##maf version=1\n")) +} + +///| +test "Bio.Align.maf rejects unterminated track quotes" { + assert_true(align_maf_test_rejects("track name=\"broken\n##maf version=1\n")) +} + +///| +test "Bio.Align.maf rejects unknown track variables" { + assert_true(align_maf_test_rejects("track unknown=x\n##maf version=1\n")) +} + +///| +test "Bio.Align.maf rejects duplicate track names" { + assert_true(align_maf_test_rejects("track name=x name=y\n##maf version=1\n")) +} + +///| +test "Bio.Align.maf rejects invalid mafDot values" { + assert_true(align_maf_test_rejects("track mafDot=yes\n##maf version=1\n")) +} + +///| +test "Bio.Align.maf rejects invalid visibility values" { + assert_true( + align_maf_test_rejects("track visibility=hide\n##maf version=1\n"), + ) +} + +///| +test "Bio.Align.maf rejects empty speciesOrder" { + assert_true( + align_maf_test_rejects("track speciesOrder=\"\"\n##maf version=1\n"), + ) +} + +///| +test "Bio.Align.maf rejects duplicate speciesOrder" { + assert_true( + align_maf_test_rejects( + "track speciesOrder=x speciesOrder=y\n##maf version=1\n", + ), + ) +} + +///| +test "Bio.Align.maf rejects malformed alignment annotations" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a score\ns ref 0 2 + 10 AC\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects unknown alignment annotations" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a label=x\ns ref 0 2 + 10 AC\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects duplicate score annotations" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a score=1 score=2\ns ref 0 2 + 10 AC\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects duplicate pass annotations" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a pass=1 pass=2\ns ref 0 2 + 10 AC\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects zero pass annotations" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a pass=0\ns ref 0 2 + 10 AC\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects nonnumeric scores" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a score=abc\ns ref 0 2 + 10 AC\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects non-finite score magnitudes" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a score=1.0e301\ns ref 0 2 + 10 AC\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects malformed sequence rows" { + assert_true( + align_maf_test_rejects(align_maf_test_single("a\ns ref 0 2 + 10\n")), + ) +} + +///| +test "Bio.Align.maf rejects negative starts" { + assert_true( + align_maf_test_rejects(align_maf_test_single("a\ns ref -1 2 + 10 AC\n")), + ) +} + +///| +test "Bio.Align.maf rejects zero component sizes" { + assert_true( + align_maf_test_rejects(align_maf_test_single("a\ns ref 0 0 + 10 A\n")), + ) +} + +///| +test "Bio.Align.maf rejects zero source sizes" { + assert_true( + align_maf_test_rejects(align_maf_test_single("a\ns ref 0 1 + 0 A\n")), + ) +} + +///| +test "Bio.Align.maf rejects coordinates beyond source size" { + assert_true( + align_maf_test_rejects(align_maf_test_single("a\ns ref 9 2 + 10 AC\n")), + ) +} + +///| +test "Bio.Align.maf rejects integer overflow" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\ns ref 2147483648 1 + 2147483647 A\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects additive coordinate overflow" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\ns ref 2147483647 1 + 2147483647 A\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects invalid component strands" { + assert_true( + align_maf_test_rejects(align_maf_test_single("a\ns ref 0 2 ? 10 AC\n")), + ) +} + +///| +test "Bio.Align.maf rejects size and sequence disagreement" { + assert_true( + align_maf_test_rejects(align_maf_test_single("a\ns ref 0 3 + 10 AC\n")), + ) +} + +///| +test "Bio.Align.maf rejects unequal component widths" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\ns ref 0 2 + 10 AC\ns other 0 3 + 10 ACG\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects blocks without aligned components" { + assert_true( + align_maf_test_rejects(align_maf_test_single("a\ne other 0 2 + 10 C\n")), + ) +} + +///| +test "Bio.Align.maf rejects insertion rows before sequence rows" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\ni ref C 0 C 0\ns ref 0 2 + 10 AC\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects malformed insertion rows" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\ns ref 0 2 + 10 AC\ni ref C 0 C\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects insertion source mismatches" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\ns ref 0 2 + 10 AC\ni other C 0 C 0\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects unknown insertion status" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\ns ref 0 2 + 10 AC\ni ref X 0 C 0\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects duplicate insertion rows" { + assert_true( + align_maf_test_rejects( + align_maf_test_single( + "a\ns ref 0 2 + 10 AC\ni ref C 0 C 0\ni ref C 0 C 0\n", + ), + ), + ) +} + +///| +test "Bio.Align.maf rejects quality rows before sequence rows" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\nq ref 98\ns ref 0 2 + 10 AC\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects malformed quality rows" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\ns ref 0 2 + 10 AC\nq ref\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects quality source mismatches" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\ns ref 0 2 + 10 AC\nq other 98\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects quality width mismatches" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\ns ref 0 2 + 10 AC\nq ref 9\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects quality gap mismatches" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\ns ref 0 2 + 10 A-C\nq ref 999\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects duplicate quality rows" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\ns ref 0 2 + 10 AC\nq ref 98\nq ref 98\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects malformed empty rows" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\ns ref 0 2 + 10 AC\ne other 0 2 + 10\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects unknown empty status" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\ns ref 0 2 + 10 AC\ne other 0 2 + 10 X\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects empty coordinates beyond source size" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\ns ref 0 2 + 10 AC\ne other 9 2 + 10 C\n"), + ), + ) +} + +///| +test "Bio.Align.maf rejects unexpected line types" { + assert_true( + align_maf_test_rejects( + align_maf_test_single("a\ns ref 0 2 + 10 AC\nx invalid\n"), + ), + ) +} + +///| +test "Bio.Align.maf track constructor rejects invalid mafDot" { + let rejected = try { + ignore(@src.AlignMafTrack::create(maf_dot=Some("maybe"))) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf track constructor rejects invalid visibility" { + let rejected = try { + ignore(@src.AlignMafTrack::create(visibility=Some("hidden"))) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf document constructor rejects unsupported version" { + let rejected = try { + ignore(@src.AlignMafDocument::create([], version="2")) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf index rejects empty documents" { + let document = @src.AlignMafDocument::create([]) catch { + AlignMafError(message) => + abort("empty document should be valid: " + message) + } + let rejected = try { + ignore(@src.AlignMafIndex::create(document, "ref")) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf index rejects missing references" { + let rejected = try { + ignore(@src.AlignMafIndex::create(align_maf_test_document(), "missing")) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf index rejects inconsistent source sizes" { + let text = align_maf_test_single( + "a\ns ref 0 2 + 10 AC\n\na\ns ref 2 2 + 11 GT\n", + ) + let rejected = try { + ignore(@src.AlignMafIndex::create(align_maf_test_parse(text), "ref")) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf index rejects inconsistent reference strands" { + let text = align_maf_test_single( + "a\ns ref 0 2 + 10 AC\n\na\ns ref 2 2 - 10 GT\n", + ) + let rejected = try { + ignore(@src.AlignMafIndex::create(align_maf_test_parse(text), "ref")) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf index rejects duplicate references in one block" { + let text = align_maf_test_single("a\ns ref 0 2 + 10 AC\ns ref 2 2 + 10 GT\n") + let rejected = try { + ignore(@src.AlignMafIndex::create(align_maf_test_parse(text), "ref")) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf search rejects empty ranges" { + let rejected = try { + ignore(align_maf_test_index().search(100, 100)) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf search rejects negative ranges" { + let rejected = try { + ignore(align_maf_test_index().search(-1, 1)) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf search rejects ranges beyond source size" { + let rejected = try { + ignore(align_maf_test_index().search(999, 1001)) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf range search rejects empty arrays" { + let rejected = try { + ignore(align_maf_test_index().search_ranges([], [])) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf range search rejects mismatched arrays" { + let rejected = try { + ignore(align_maf_test_index().search_ranges([1], [2, 3])) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf splicing rejects empty exon arrays" { + let rejected = try { + ignore(align_maf_test_index().get_spliced([], [])) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf splicing rejects mismatched exon arrays" { + let rejected = try { + ignore(align_maf_test_index().get_spliced([100], [102, 104])) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf splicing rejects invalid strands" { + let rejected = try { + ignore(align_maf_test_index().get_spliced([100], [102], strand="?")) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf splicing rejects overlapping exons" { + let rejected = try { + ignore(align_maf_test_index().get_spliced([100, 103], [105, 106])) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf splicing rejects unsorted exons" { + let rejected = try { + ignore(align_maf_test_index().get_spliced([110, 100], [112, 102])) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf splicing rejects overlapping indexed blocks" { + let text = align_maf_test_single( + "a\ns ref 0 4 + 20 ACGT\n\na\ns ref 2 4 + 20 GTAA\n", + ) + let index = @src.AlignMafIndex::create(align_maf_test_parse(text), "ref") catch { + AlignMafError(message) => abort("overlap index should build: " + message) + } + let rejected = try { + ignore(index.get_spliced([0], [6])) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} + +///| +test "Bio.Align.maf splicing rejects reverse reference indexes" { + let text = align_maf_test_single("a\ns ref 0 4 - 20 ACGT\n") + let index = @src.AlignMafIndex::create(align_maf_test_parse(text), "ref") catch { + AlignMafError(message) => abort("reverse index should build: " + message) + } + let rejected = try { + ignore(index.get_spliced([16], [20])) + false + } catch { + AlignMafError(_) => true + } + assert_true(rejected) +} diff --git a/test/moonbit/align_nexus_test.mbt b/test/moonbit/align_nexus_test.mbt new file mode 100644 index 00000000..02ecd432 --- /dev/null +++ b/test/moonbit/align_nexus_test.mbt @@ -0,0 +1,1069 @@ +// Black-box tests for Biopython Bio.Align.nexus-compatible support. + +///| +fn align_nexus_test_parse(text : String) -> @src.AlignNexusAlignment { + @src.align_nexus_parse(text) catch { + AlignNexusError(message) => abort("valid NEXUS input failed: " + message) + } +} + +///| +fn align_nexus_test_raises(text : String) -> Bool { + try { + ignore(@src.align_nexus_parse(text)) + false + } catch { + AlignNexusError(_) => true + } +} + +///| +fn align_nexus_test_write( + alignment : @src.AlignNexusAlignment, + interleave : Bool?, + block_width : Int, +) -> String { + @src.align_nexus_write(alignment, interleave~, block_width~) catch { + AlignNexusError(message) => abort("NEXUS writing failed: " + message) + } +} + +///| +fn align_nexus_test_write_raises( + alignment : @src.AlignNexusAlignment, + block_width : Int, +) -> Bool { + try { + ignore(@src.align_nexus_write(alignment, block_width~)) + false + } catch { + AlignNexusError(_) => true + } +} + +///| +fn align_nexus_test_from_raises( + ids : Array[String], + rows : Array[String], +) -> Bool { + try { + ignore(@src.align_nexus_from_aligned(ids, rows, @src.AlignNexusDna)) + false + } catch { + AlignNexusError(_) => true + } +} + +///| +fn align_nexus_test_sample() -> @src.AlignNexusAlignment { + align_nexus_test_parse(@src.align_nexus_example_text()) +} + +///| +fn align_nexus_test_codon_text() -> String { + "#NEXUS\n" + + "[MacClade fixture]\n" + + "BEGIN DATA;\n" + + "DIMENSIONS NTAX=2 NCHAR=22;\n" + + "FORMAT DATATYPE=DNA MISSING=? GAP=-;\n" + + "MATRIX\n" + + "[ 10 20]\n" + + "Aegotheles AAAAAGGCATTGTGGTGGGAAT [22]\n" + + "Aerodramus ?????????TTGTGGTGGGAAT [13]\n" + + ";\n" + + "END;\n" + + "BEGIN CODONS;\n" + + "CODONPOSSET * CodonPositions = N: 1-10, 1: 11-22\\3;\n" + + "END;\n" +} + +///| +fn align_nexus_test_official_text() -> String { + "#NEXUS\n" + + "[ NEXUS test file. Weird, but NEXUS standard compatible.]\n" + + "begin data;\n" + + "dimensions ntax=9 nchar=48;\n" + + "format datatype=dna gap=- missing=? interleave=yes;\n" + + "options gapmode=newstate;\n" + + "taxlabels t1\n" + + "'t2 the name'\n" + + "'isn''that [a] strange name?' 'one should be punished, for (that)!'\n" + + "t5 t6 t7 t8 t9;\n" + + "charlabels 1 'a', 2 'b', 48 final;\n" + + "matrix\n" + + "[interleaved matrix]\n" + + "t1 A-C-G-Tc-gtgtgtgctct-t-t\n" + + "'t2 the name' A-C-GcTc-gtg-----tct-t-t\n" + + "'isn''that [a] strange name?' A-CcGcTc-gtgtgtgct------\n" + + "'one should be punished, for (that)!' A-C-G-T-----------------\n" + + "t5 A-C?G-T?--acgt??-???-???\n" + + "t6 AcCaGtTc-?--aaaaaaaa-a-a\n" + + "t7 A?C-GgTg-ggggggggggg-g-g\n" + + "t8 AtCtGtTt-ttttttttttt-?-?\n" + + "[last taxon of the matrix]\n" + + "t9 cccccccc-cccccccccccNc-c\n" + + "t1 ------ac-gtgtgtgctct-t-t\n" + + "t2_the_name ----acac-gtg-----tct-t-t\n" + + "'isn''that [a] strange name?' --acacac-gtgtgtgct------\n" + + "'one should be punished, for (that)!' ------------------------\n" + + "t5 --??---?--acgt??-???-???\n" + + "t6 acgactac-?--aaaaaaaa-a-a\n" + + "t7 ??--?ggg-ggggggggggg-g-g\n" + + "t8 tttttttt-ttttttttttt-?-?\n" + + "[last taxon of the matrix]\n" + + "t9 cccccccc-cccccccccccNc-c\n" + + ";\n" + + "end;\n" + + "[ this is a [nested ] comment]\n" + + "begin sets;\n" + + "charset c1=1-8;\n" + + "end;\n" + + "begin spam;\n" + + "this is an unknown block;\n" + + "end;\n" +} + +///| +fn align_nexus_test_official() -> @src.AlignNexusAlignment { + align_nexus_test_parse(align_nexus_test_official_text()) +} + +///| +test "Bio.Align.nexus parses interleaved example metadata" { + let alignment = align_nexus_test_sample() + assert_eq(alignment.metadata.block_name, "data") + assert_eq(alignment.metadata.declared_taxa, 3) + assert_eq(alignment.metadata.declared_characters, 12) + assert_eq(alignment.metadata.data_type, @src.AlignNexusDna) + assert_true(alignment.metadata.interleaved) + assert_eq(alignment.metadata.match_character, Some(".")) +} + +///| +test "Bio.Align.nexus resolves MATCHCHAR across interleaved blocks" { + let alignment = align_nexus_test_sample() + assert_eq(alignment.sequences[0].aligned_sequence, "ACGT--ACGTAC") + assert_eq(alignment.sequences[1].aligned_sequence, "ACGT??ACG-AC") + assert_eq(alignment.sequences[2].aligned_sequence, "AC-T--A-GTAC") +} + +///| +test "Bio.Align.nexus preserves quoted and escaped identifiers" { + let alignment = align_nexus_test_sample() + assert_eq(alignment.sequences[1].id, "query one") + assert_eq(alignment.sequences[2].id, "isn't_query") +} + +///| +test "Bio.Align.nexus treats underscores and spaces as interleave equivalents" { + let alignment = align_nexus_test_sample() + assert_eq(alignment.sequences[1].id, "query one") + assert_eq(alignment.sequences[1].sequence, "ACGT??ACGAC") +} + +///| +test "Bio.Align.nexus reports sample shape" { + let alignment = align_nexus_test_sample() + assert_eq(alignment.num_sequences(), 3) + assert_eq(alignment.alignment_length(), 12) + assert_eq(alignment.source_alignment_length(), 12) +} + +///| +test "Bio.Align.nexus reports sample summary" { + assert_eq( + align_nexus_test_sample().summary(), + "AlignNexusAlignment(type=dna, sequences=3, columns=12, " + + "source_columns=12, removed_all_gap=0)", + ) +} + +///| +test "Bio.Align.nexus exposes molecule type annotations" { + assert_eq(@src.AlignNexusDna.molecule_type(), "DNA") + assert_eq(@src.AlignNexusRna.molecule_type(), "RNA") + assert_eq(@src.AlignNexusProtein.molecule_type(), "protein") + assert_eq(@src.AlignNexusStandard.molecule_type(), "") +} + +///| +test "Bio.Align.nexus exposes canonical datatype codes" { + assert_eq(@src.AlignNexusDna.code(), "dna") + assert_eq(@src.AlignNexusRna.code(), "rna") + assert_eq(@src.AlignNexusProtein.code(), "protein") + assert_eq(@src.AlignNexusStandard.code(), "standard") +} + +///| +test "Bio.Align.nexus finds duplicate-safe row identifiers" { + let alignment = align_nexus_test_sample() + assert_eq(alignment.find_sequence("reference"), Some(0)) + assert_eq(alignment.find_sequence("query one"), Some(1)) + assert_eq(alignment.find_sequence("missing"), None) +} + +///| +test "Bio.Align.nexus returns printed columns" { + let alignment = align_nexus_test_sample() + assert_eq(alignment.column(0), Some("AAA")) + assert_eq(alignment.column(2), Some("GG-")) + assert_eq(alignment.column(4), Some("-?-")) + assert_eq(alignment.column(-1), None) + assert_eq(alignment.column(12), None) +} + +///| +test "Bio.Align.nexus maps sequence positions to columns" { + let alignment = align_nexus_test_sample() + assert_eq(alignment.sequence_position_to_column(1, 0), Some(0)) + assert_eq(alignment.sequence_position_to_column(1, 7), Some(7)) + assert_eq(alignment.sequence_position_to_column(1, 8), Some(8)) + assert_eq(alignment.sequence_position_to_column(1, 11), None) +} + +///| +test "Bio.Align.nexus maps columns to sequence positions" { + let alignment = align_nexus_test_sample() + assert_eq(alignment.column_to_sequence_position(1, 0), Some(0)) + assert_eq(alignment.column_to_sequence_position(1, 8), Some(8)) + assert_eq(alignment.column_to_sequence_position(1, 9), None) + assert_eq(alignment.column_to_sequence_position(1, 12), None) +} + +///| +test "Bio.Align.nexus maps residues between rows" { + let alignment = align_nexus_test_sample() + assert_eq(alignment.map_position(0, 1, 0), Some(0)) + assert_eq(alignment.map_position(0, 1, 5), Some(7)) + assert_eq(alignment.map_position(0, 1, 7), None) + assert_eq(alignment.map_position(0, 9, 0), None) +} + +///| +test "Bio.Align.nexus returns aligned coordinate pairs" { + let pairs = align_nexus_test_sample().aligned_pairs(0, 1) catch { + AlignNexusError(message) => abort(message) + } + assert_eq(pairs.length(), 12) + assert_eq(pairs[0], (Some(0), Some(0))) + assert_eq(pairs[4], (None, Some(4))) + assert_eq(pairs[9], (Some(7), None)) + assert_eq(pairs[11], (Some(9), Some(10))) +} + +///| +test "Bio.Align.nexus builds a compact coordinate path" { + let path = align_nexus_test_sample().coordinate_path() + assert_eq(path.length(), 3) + assert_eq(path[0], [0, 2, 3, 4, 4, 5, 6, 7, 8, 10]) + assert_eq(path[1], [0, 2, 3, 4, 6, 7, 8, 9, 9, 11]) + assert_eq(path[2], [0, 2, 2, 3, 3, 4, 4, 5, 6, 8]) +} + +///| +test "Bio.Align.nexus computes pair counts" { + let counts = align_nexus_test_sample().pair_counts(0, 1) catch { + AlignNexusError(message) => abort(message) + } + assert_eq(counts.pairs, 1) + assert_eq(counts.aligned, 9) + assert_eq(counts.identities, 9) + assert_eq(counts.mismatches, 0) + assert_eq(counts.gap_columns, 3) + assert_eq(counts.double_gap_columns, 0) + assert_eq(counts.gap_opens, 2) + assert_eq(counts.identity(), 1.0) +} + +///| +test "Bio.Align.nexus aggregates all unordered row pairs" { + let counts = align_nexus_test_sample().counts() + assert_eq(counts.pairs, 3) + assert_eq(counts.aligned, 24) + assert_eq(counts.identities, 24) + assert_eq(counts.mismatches, 0) + assert_eq(counts.gap_columns, 10) + assert_eq(counts.double_gap_columns, 2) +} + +///| +test "Bio.Align.nexus calculates consensus" { + let consensus = align_nexus_test_sample().consensus() catch { + AlignNexusError(message) => abort(message) + } + assert_eq(consensus, "ACGT??ACGTAC") +} + +///| +test "Bio.Align.nexus applies consensus threshold" { + let consensus = align_nexus_test_sample().consensus(minimum_fraction=0.75) catch { + AlignNexusError(message) => abort(message) + } + assert_eq(consensus, "ACGT??ACGTAC") +} + +///| +test "Bio.Align.nexus computes occupancy" { + let occupancy = align_nexus_test_sample().occupancy() + assert_eq(occupancy.length(), 12) + assert_eq(occupancy[0], 1.0) + assert_eq(occupancy[4], 1.0 / 3.0) + assert_eq(occupancy[6], 1.0) + assert_eq(occupancy[9], 2.0 / 3.0) +} + +///| +test "Bio.Align.nexus parses official codon fixture" { + let alignment = align_nexus_test_parse(align_nexus_test_codon_text()) + assert_eq(alignment.num_sequences(), 2) + assert_eq(alignment.alignment_length(), 22) + assert_eq(alignment.sequences[0].id, "Aegotheles") + assert_eq(alignment.sequences[1].id, "Aerodramus") +} + +///| +test "Bio.Align.nexus preserves codon fixture sequences" { + let alignment = align_nexus_test_parse(align_nexus_test_codon_text()) + assert_eq(alignment.sequences[0].sequence, "AAAAAGGCATTGTGGTGGGAAT") + assert_eq(alignment.sequences[1].sequence, "?????????TTGTGGTGGGAAT") + assert_eq(alignment.coordinate_path(), [[0, 22], [0, 22]]) +} + +///| +test "Bio.Align.nexus matches codon fixture counts" { + let counts = align_nexus_test_parse(align_nexus_test_codon_text()).counts() + assert_eq(counts.pairs, 1) + assert_eq(counts.aligned, 22) + assert_eq(counts.identities, 13) + assert_eq(counts.mismatches, 9) + assert_eq(counts.gap_columns, 0) +} + +///| +test "Bio.Align.nexus parses official nine-taxon fixture" { + let alignment = align_nexus_test_official() + assert_eq(alignment.num_sequences(), 9) + assert_eq(alignment.metadata.declared_characters, 48) + assert_eq(alignment.alignment_length(), 46) + assert_eq(alignment.metadata.removed_all_gap_columns, 2) +} + +///| +test "Bio.Align.nexus preserves official quoted identifiers" { + let alignment = align_nexus_test_official() + assert_eq(alignment.sequences[0].id, "t1") + assert_eq(alignment.sequences[1].id, "t2 the name") + assert_eq(alignment.sequences[2].id, "isn'that [a] strange name?") + assert_eq(alignment.sequences[3].id, "one should be punished, for (that)!") + assert_eq(alignment.sequences[8].id, "t9") +} + +///| +test "Bio.Align.nexus preserves official ungapped sequences" { + let alignment = align_nexus_test_official() + assert_eq( + alignment.sequences[0].sequence, + "ACGTcgtgtgtgctctttacgtgtgtgctcttt", + ) + assert_eq(alignment.sequences[1].sequence, "ACGcTcgtgtctttacacgtgtcttt") + assert_eq(alignment.sequences[2].sequence, "ACcGcTcgtgtgtgctacacacgtgtgtgct") + assert_eq(alignment.sequences[3].sequence, "ACGT") +} + +///| +test "Bio.Align.nexus preserves official missing data" { + let alignment = align_nexus_test_official() + assert_eq( + alignment.sequences[4].sequence, + "AC?GT?acgt???????????acgt????????", + ) + assert_eq( + alignment.sequences[8].sequence, + "cccccccccccccccccccNcccccccccccccccccccccNcc", + ) +} + +///| +test "Bio.Align.nexus removes official all-gap columns" { + let alignment = align_nexus_test_official() + assert_eq( + alignment.sequences[0].aligned_sequence, + "A-C-G-Tcgtgtgtgctct-t-t------acgtgtgtgctct-t-t", + ) + assert_eq( + alignment.sequences[3].aligned_sequence, + "A-C-G-T---------------------------------------", + ) +} + +///| +test "Bio.Align.nexus matches official first coordinate path" { + let path = align_nexus_test_official().coordinate_path() + assert_eq(path[0], [ + 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 8, 12, 13, 14, 16, 16, 17, 17, 18, 18, 18, 18, + 19, 20, 21, 23, 27, 28, 29, 31, 31, 32, 32, 33, + ]) +} + +///| +test "Bio.Align.nexus matches official sparse coordinate path" { + let path = align_nexus_test_official().coordinate_path() + assert_eq(path[3], [ + 0, 1, 1, 2, 2, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, + ]) +} + +///| +test "Bio.Align.nexus matches official final coordinate path" { + let path = align_nexus_test_official().coordinate_path() + assert_eq(path[8], [ + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 15, 16, 17, 19, 20, 21, 21, 22, 24, 26, 28, + 29, 30, 31, 33, 37, 38, 39, 41, 42, 43, 43, 44, + ]) +} + +///| +test "Bio.Align.nexus matches official aggregate counts" { + let counts = align_nexus_test_official().counts() + assert_eq(counts.pairs, 36) + assert_eq(counts.aligned, 862) + assert_eq(counts.identities, 256) + assert_eq(counts.mismatches, 606) + assert_eq(counts.gap_columns, 596) +} + +///| +test "Bio.Align.nexus writes official canonical dimensions" { + let output = align_nexus_test_write( + align_nexus_test_official(), + Some(false), + 70, + ) + assert_true(output.has_prefix("#NEXUS\nbegin data;\n")) + assert_true(output.contains("dimensions ntax=9 nchar=46;")) + assert_true(output.contains("format datatype=dna missing=? gap=-;")) +} + +///| +test "Bio.Align.nexus writer quotes official identifiers" { + let output = align_nexus_test_write( + align_nexus_test_official(), + Some(false), + 70, + ) + assert_true(output.contains("'t2 the name'")) + assert_true(output.contains("'isn''that [a] strange name?'")) + assert_true(output.contains("'one should be punished, for (that)!'")) +} + +///| +test "Bio.Align.nexus sequential writer round-trips" { + let alignment = align_nexus_test_official() + let output = align_nexus_test_write(alignment, Some(false), 70) + let reparsed = align_nexus_test_parse(output) + assert_eq(reparsed.metadata.declared_characters, 46) + assert_eq(reparsed.metadata.removed_all_gap_columns, 0) + assert_eq(reparsed.sequences, alignment.sequences) + assert_eq(reparsed.coordinate_path(), alignment.coordinate_path()) +} + +///| +test "Bio.Align.nexus interleaved writer round-trips" { + let alignment = align_nexus_test_sample() + let output = align_nexus_test_write(alignment, Some(true), 4) + assert_true(output.contains(" interleave;")) + let reparsed = align_nexus_test_parse(output) + assert_eq(reparsed.sequences, alignment.sequences) + assert_eq(reparsed.coordinate_path(), alignment.coordinate_path()) +} + +///| +test "Bio.Align.nexus sequential writer omits interleave" { + let output = align_nexus_test_write(align_nexus_test_sample(), Some(false), 4) + assert_false(output.contains(" interleave;")) +} + +///| +test "Bio.Align.nexus writer uses canonical terminator" { + let output = align_nexus_test_write( + align_nexus_test_sample(), + Some(false), + 70, + ) + assert_true(output.has_suffix(";\nend;\n")) +} + +///| +test "Bio.Align.nexus writer auto-interleaves above 1000 columns" { + let short_builder = StringBuilder::new(size_hint=1000) + let long_builder = StringBuilder::new(size_hint=1001) + for _index = 0; _index < 1000; _index = _index + 1 { + short_builder.write_char('A') + long_builder.write_char('A') + } + long_builder.write_char('A') + let short_alignment = @src.align_nexus_from_aligned( + ["alpha"], + [short_builder.to_string()], + @src.AlignNexusDna, + ) catch { + AlignNexusError(message) => abort(message) + } + let long_alignment = @src.align_nexus_from_aligned( + ["alpha"], + [long_builder.to_string()], + @src.AlignNexusDna, + ) catch { + AlignNexusError(message) => abort(message) + } + let short_output = @src.align_nexus_write(short_alignment) catch { + AlignNexusError(message) => abort(message) + } + let long_output = @src.align_nexus_write(long_alignment) catch { + AlignNexusError(message) => abort(message) + } + assert_false(short_output.contains(" interleave;")) + assert_true(long_output.contains(" interleave;")) +} + +///| +test "Bio.Align.nexus parses CHARACTERS with TAXA association" { + let text = "#NEXUS\n" + + "begin taxa;\n" + + "dimensions ntax=2;\n" + + "taxlabels 'taxon one' taxon_two;\n" + + "end;\n" + + "begin characters;\n" + + "dimensions nchar=4;\n" + + "format datatype=dna labels=no;\n" + + "matrix\nACGT\nA-GT\n;\n" + + "end;\n" + let alignment = align_nexus_test_parse(text) + assert_eq(alignment.metadata.block_name, "characters") + assert_eq(alignment.sequences[0].id, "taxon one") + assert_eq(alignment.sequences[1].id, "taxon_two") +} + +///| +test "Bio.Align.nexus parses wrapped sequential rows" { + let text = "#NEXUS\nbegin data;\n" + + "dimensions ntax=2 nchar=8;\nformat datatype=dna;\nmatrix\n" + + "alpha ACGT\nACGT\nbeta\nAC--\nACGT\n;\nend;\n" + let alignment = align_nexus_test_parse(text) + assert_eq(alignment.sequences[0].aligned_sequence, "ACGTACGT") + assert_eq(alignment.sequences[1].aligned_sequence, "AC--ACGT") +} + +///| +test "Bio.Align.nexus accepts CRLF input" { + let text = "#NEXUS\r\nBEGIN DATA;\r\n" + + "DIMENSIONS NTAX=1 NCHAR=4;\r\n" + + "FORMAT DATATYPE=DNA;\r\nMATRIX\r\nalpha ACGT\r\n;\r\nEND;\r\n" + let alignment = align_nexus_test_parse(text) + assert_eq(alignment.sequences[0].sequence, "ACGT") +} + +///| +test "Bio.Align.nexus preserves duplicate taxon names" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=2 nchar=4;\n" + + "format datatype=dna;\nmatrix\nalpha ACGT\nalpha A-GT\n;\nend;\n" + let alignment = align_nexus_test_parse(text) + assert_eq(alignment.sequences[0].id, "alpha") + assert_eq(alignment.sequences[1].id, "alpha") + assert_eq(alignment.find_sequence("alpha"), Some(0)) +} + +///| +test "Bio.Align.nexus preserves lower-case residues" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=6;\n" + + "format datatype=dna;\nmatrix\nalpha AcgTnN\n;\nend;\n" + let alignment = align_nexus_test_parse(text) + assert_eq(alignment.sequences[0].sequence, "AcgTnN") +} + +///| +test "Bio.Align.nexus parses RNA data" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=2 nchar=5;\n" + + "format datatype=rna;\nmatrix\nalpha ACGUN\nbeta A-GUN\n;\nend;\n" + let alignment = align_nexus_test_parse(text) + assert_eq(alignment.metadata.data_type, @src.AlignNexusRna) + assert_eq(alignment.sequences[1].sequence, "AGUN") +} + +///| +test "Bio.Align.nexus parses protein data" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=2 nchar=7;\n" + + "format datatype=protein;\nmatrix\nalpha ACDE*XZ\nbeta A-DEBXZ\n;\nend;\n" + let alignment = align_nexus_test_parse(text) + assert_eq(alignment.metadata.data_type, @src.AlignNexusProtein) + assert_eq(alignment.sequences[0].sequence, "ACDE*XZ") +} + +///| +test "Bio.Align.nexus parses STANDARD symbols" { + let text = "#NEXUS\nbegin characters;\ndimensions ntax=2 nchar=5;\n" + + "format datatype=standard symbols=\"01\" missing=? gap=-;\n" + + "matrix\nalpha 0101?\nbeta 0-11?\n;\nend;\n" + let alignment = align_nexus_test_parse(text) + assert_eq(alignment.metadata.data_type, @src.AlignNexusStandard) + assert_eq(alignment.metadata.symbols, "01") + assert_eq(alignment.sequences[1].sequence, "011?") +} + +///| +test "Bio.Align.nexus STANDARD is case-insensitive by default" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=4;\n" + + "format datatype=standard symbols=\"AB\";\nmatrix\nalpha AbBa\n;\nend;\n" + let alignment = align_nexus_test_parse(text) + assert_eq(alignment.sequences[0].sequence, "AbBa") +} + +///| +test "Bio.Align.nexus supports custom gap and missing symbols" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=2 nchar=5;\n" + + "format datatype=dna missing=X gap=~;\nmatrix\nalpha AC~TX\n" + + "beta A~~TX\n;\nend;\n" + let alignment = align_nexus_test_parse(text) + assert_eq(alignment.metadata.missing_character, "X") + assert_eq(alignment.metadata.gap_character, "~") + assert_eq(alignment.metadata.removed_all_gap_columns, 1) + assert_eq(alignment.sequences[0].aligned_sequence, "ACTX") + let output = align_nexus_test_write(alignment, Some(false), 70) + assert_true(output.contains("missing=X gap=~;")) + assert_true(output.contains("ACTX")) +} + +///| +test "Bio.Align.nexus removes constructor all-gap columns" { + let alignment = @src.align_nexus_from_aligned( + ["alpha", "beta"], + ["A-C--G", "ATC--G"], + @src.AlignNexusDna, + ) catch { + AlignNexusError(message) => abort(message) + } + assert_eq(alignment.metadata.declared_characters, 6) + assert_eq(alignment.metadata.removed_all_gap_columns, 2) + assert_eq(alignment.alignment_length(), 4) + assert_eq(alignment.sequences[0].aligned_sequence, "A-CG") +} + +///| +test "Bio.Align.nexus constructor supports all-gap row" { + let alignment = @src.align_nexus_from_aligned( + ["alpha", "empty"], + ["ACGT", "----"], + @src.AlignNexusDna, + ) catch { + AlignNexusError(message) => abort(message) + } + assert_eq(alignment.sequences[1].sequence, "") + assert_eq(alignment.sequences[1].aligned_sequence, "----") +} + +///| +test "Bio.Align.nexus row constructor normalizes custom gap" { + let sequence = @src.AlignNexusSequence::create( + "alpha", + "AC~GT", + @src.AlignNexusDna, + gap_character="~", + ) catch { + AlignNexusError(message) => abort(message) + } + assert_eq(sequence.aligned_sequence, "AC-GT") + assert_eq(sequence.sequence, "ACGT") +} + +///| +test "Bio.Align.nexus metadata constructor preserves source facts" { + let metadata = @src.AlignNexusMetadata::create( + 3, + 12, + @src.AlignNexusDna, + block_name="CHARACTERS", + match_character=Some("."), + interleaved=true, + removed_all_gap_columns=2, + ) catch { + AlignNexusError(message) => abort(message) + } + assert_eq(metadata.block_name, "characters") + assert_eq(metadata.match_character, Some(".")) + assert_eq(metadata.removed_all_gap_columns, 2) +} + +///| +test "Bio.Align.nexus rejects empty input" { + assert_true(align_nexus_test_raises("")) +} + +///| +test "Bio.Align.nexus rejects whitespace-only input" { + assert_true(align_nexus_test_raises(" \n\t")) +} + +///| +test "Bio.Align.nexus rejects missing header" { + assert_true( + align_nexus_test_raises( + "begin data; dimensions ntax=1 nchar=1; " + + "format datatype=dna; matrix alpha A; end;", + ), + ) +} + +///| +test "Bio.Align.nexus rejects wrong-case header" { + assert_true( + align_nexus_test_raises( + "#nexus\nbegin data; dimensions ntax=1 nchar=1; " + + "format datatype=dna; matrix alpha A; end;", + ), + ) +} + +///| +test "Bio.Align.nexus rejects missing matrix" { + assert_true( + align_nexus_test_raises( + "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=1;\n" + + "format datatype=dna;\nend;\n", + ), + ) +} + +///| +test "Bio.Align.nexus rejects missing semicolon" { + assert_true( + align_nexus_test_raises( + "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=1;\n" + + "format datatype=dna;\nmatrix\nalpha A\n;\nend\n", + ), + ) +} + +///| +test "Bio.Align.nexus rejects nested blocks" { + assert_true( + align_nexus_test_raises("#NEXUS\nbegin data;\nbegin taxa;\nend;\nend;\n"), + ) +} + +///| +test "Bio.Align.nexus rejects unmatched END" { + assert_true(align_nexus_test_raises("#NEXUS\nend;\n")) +} + +///| +test "Bio.Align.nexus rejects unterminated comment" { + assert_true(align_nexus_test_raises("#NEXUS\n[broken\nbegin data;\nend;\n")) +} + +///| +test "Bio.Align.nexus rejects unmatched comment close" { + assert_true(align_nexus_test_raises("#NEXUS\n]\n")) +} + +///| +test "Bio.Align.nexus rejects unterminated quote" { + assert_true( + align_nexus_test_raises( + "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=1;\n" + + "format datatype=dna;\nmatrix\n'alpha A\n;\nend;\n", + ), + ) +} + +///| +test "Bio.Align.nexus rejects missing NTAX" { + assert_true( + align_nexus_test_raises( + "#NEXUS\nbegin data;\ndimensions nchar=1;\n" + + "format datatype=dna;\nmatrix\nalpha A\n;\nend;\n", + ), + ) +} + +///| +test "Bio.Align.nexus rejects missing NCHAR" { + assert_true( + align_nexus_test_raises( + "#NEXUS\nbegin data;\ndimensions ntax=1;\n" + + "format datatype=dna;\nmatrix\nalpha A\n;\nend;\n", + ), + ) +} + +///| +test "Bio.Align.nexus rejects zero dimensions" { + assert_true( + align_nexus_test_raises( + "#NEXUS\nbegin data;\ndimensions ntax=0 nchar=1;\nend;\n", + ), + ) +} + +///| +test "Bio.Align.nexus rejects inconsistent TAXA dimensions" { + let text = "#NEXUS\nbegin taxa;\ndimensions ntax=3;\n" + + "taxlabels a b c;\nend;\nbegin characters;\n" + + "dimensions ntax=2 nchar=1;\nformat datatype=dna;\n" + + "matrix\na A\nb C\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects TAXLABELS count mismatch" { + let text = "#NEXUS\nbegin taxa;\ndimensions ntax=2;\n" + + "taxlabels alpha;\nend;\nbegin characters;\n" + + "dimensions nchar=1;\nformat datatype=dna labels=no;\n" + + "matrix\nA\nC\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects short sequential row" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=5;\n" + + "format datatype=dna;\nmatrix\nalpha ACGT\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects long sequential row" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=3;\n" + + "format datatype=dna;\nmatrix\nalpha ACGT\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects incomplete interleaved block" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=2 nchar=4;\n" + + "format datatype=dna interleave;\nmatrix\n" + + "alpha AC\nbeta AC\nalpha GT\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects unequal interleaved chunk widths" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=2 nchar=4;\n" + + "format datatype=dna interleave;\nmatrix\n" + + "alpha AC\nbeta A\nalpha GT\nbeta CGT\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects interleaved taxon reorder" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=2 nchar=4;\n" + + "format datatype=dna interleave;\nmatrix\n" + + "alpha AC\nbeta AC\nbeta GT\nalpha GT\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects DNA U" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=4;\n" + + "format datatype=dna;\nmatrix\nalpha ACGU\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects RNA T" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=4;\n" + + "format datatype=rna;\nmatrix\nalpha ACGT\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects illegal protein residue" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=4;\n" + + "format datatype=protein;\nmatrix\nalpha ACOU\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects STANDARD without symbols" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=2;\n" + + "format datatype=standard;\nmatrix\nalpha 01\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects illegal STANDARD state" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=2;\n" + + "format datatype=standard symbols=\"01\";\nmatrix\nalpha 02\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus respects case for STANDARD symbols" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=2;\n" + + "format datatype=standard symbols=\"AB\" respectcase;\n" + + "matrix\nalpha Ab\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects match character in reference" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=2 nchar=4;\n" + + "format datatype=dna matchchar=.;\nmatrix\n" + + "alpha A.GT\nbeta ....\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects all-gap matrix" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=2 nchar=4;\n" + + "format datatype=dna;\nmatrix\nalpha ----\nbeta ----\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects duplicate FORMAT character roles" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=1;\n" + + "format datatype=dna missing=- gap=-;\nmatrix\nalpha A\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects unsupported datatype" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=1;\n" + + "format datatype=continuous;\nmatrix\nalpha A\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects transpose matrices" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=1;\n" + + "format datatype=dna transpose;\nmatrix\nalpha A\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects tokenized matrices" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=1;\n" + + "format datatype=dna tokens;\nmatrix\nalpha A\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects labels=no without TAXLABELS" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=1;\n" + + "format datatype=dna labels=no;\nmatrix\nA\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects malformed DIMENSIONS" { + let text = "#NEXUS\nbegin data;\ndimensions ntax 1 nchar=1;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects unknown FORMAT option" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=1;\n" + + "format datatype=dna mystery=yes;\nmatrix\nalpha A\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects invalid INTERLEAVE value" { + let text = "#NEXUS\nbegin data;\ndimensions ntax=1 nchar=1;\n" + + "format datatype=dna interleave=maybe;\nmatrix\nalpha A\n;\nend;\n" + assert_true(align_nexus_test_raises(text)) +} + +///| +test "Bio.Align.nexus rejects mismatched constructor arrays" { + assert_true(align_nexus_test_from_raises(["alpha"], ["ACGT", "ACGT"])) +} + +///| +test "Bio.Align.nexus rejects empty constructor arrays" { + assert_true(align_nexus_test_from_raises([], [])) +} + +///| +test "Bio.Align.nexus rejects unequal constructor widths" { + assert_true(align_nexus_test_from_raises(["alpha", "beta"], ["ACGT", "ACG"])) +} + +///| +test "Bio.Align.nexus rejects all-gap constructor alignment" { + assert_true(align_nexus_test_from_raises(["alpha", "beta"], ["----", "----"])) +} + +///| +test "Bio.Align.nexus rejects empty row identifier" { + let failed = try { + ignore(@src.AlignNexusSequence::create("", "ACGT", @src.AlignNexusDna)) + false + } catch { + AlignNexusError(_) => true + } + assert_true(failed) +} + +///| +test "Bio.Align.nexus rejects invalid metadata block" { + let failed = try { + ignore( + @src.AlignNexusMetadata::create( + 1, + 4, + @src.AlignNexusDna, + block_name="trees", + ), + ) + false + } catch { + AlignNexusError(_) => true + } + assert_true(failed) +} + +///| +test "Bio.Align.nexus rejects invalid metadata removed count" { + let failed = try { + ignore( + @src.AlignNexusMetadata::create( + 1, + 4, + @src.AlignNexusDna, + removed_all_gap_columns=4, + ), + ) + false + } catch { + AlignNexusError(_) => true + } + assert_true(failed) +} + +///| +test "Bio.Align.nexus rejects invalid writer block width" { + assert_true(align_nexus_test_write_raises(align_nexus_test_sample(), 0)) +} + +///| +test "Bio.Align.nexus rejects invalid pair row" { + let failed = try { + ignore(align_nexus_test_sample().pair_counts(0, 9)) + false + } catch { + AlignNexusError(_) => true + } + assert_true(failed) +} + +///| +test "Bio.Align.nexus rejects invalid consensus threshold" { + let failed = try { + ignore(align_nexus_test_sample().consensus(minimum_fraction=1.1)) + false + } catch { + AlignNexusError(_) => true + } + assert_true(failed) +} diff --git a/test/moonbit/align_stockholm_test.mbt b/test/moonbit/align_stockholm_test.mbt new file mode 100644 index 00000000..d69d351b --- /dev/null +++ b/test/moonbit/align_stockholm_test.mbt @@ -0,0 +1,1569 @@ +// Black-box tests for Biopython Bio.Align.stockholm-compatible support. + +///| +fn align_stockholm_test_parse(text : String) -> @src.AlignStockholmAlignment { + @src.align_stockholm_parse(text) catch { + AlignStockholmError(message) => + abort("valid Stockholm input failed: " + message) + } +} + +///| +fn align_stockholm_test_parse_all( + text : String, +) -> Array[@src.AlignStockholmAlignment] { + @src.align_stockholm_parse_all(text) catch { + AlignStockholmError(message) => + abort("valid Stockholm input failed: " + message) + } +} + +///| +fn align_stockholm_test_raises(text : String) -> Bool { + try { + ignore(@src.align_stockholm_parse(text)) + false + } catch { + AlignStockholmError(_) => true + } +} + +///| +fn align_stockholm_test_parse_all_raises(text : String) -> Bool { + try { + ignore(@src.align_stockholm_parse_all(text)) + false + } catch { + AlignStockholmError(_) => true + } +} + +///| +fn align_stockholm_test_write( + alignment : @src.AlignStockholmAlignment, +) -> String { + @src.align_stockholm_write(alignment) catch { + AlignStockholmError(message) => + abort("Stockholm writing failed: " + message) + } +} + +///| +fn align_stockholm_test_write_raises( + alignment : @src.AlignStockholmAlignment, +) -> Bool { + try { + ignore(@src.align_stockholm_write(alignment)) + false + } catch { + AlignStockholmError(_) => true + } +} + +///| +fn align_stockholm_test_from( + ids : Array[String], + rows : Array[String], +) -> @src.AlignStockholmAlignment { + @src.align_stockholm_from_aligned(ids, rows) catch { + AlignStockholmError(message) => + abort("Stockholm construction failed: " + message) + } +} + +///| +fn align_stockholm_test_from_raises( + ids : Array[String], + rows : Array[String], +) -> Bool { + try { + ignore(@src.align_stockholm_from_aligned(ids, rows)) + false + } catch { + AlignStockholmError(_) => true + } +} + +///| +fn align_stockholm_test_sequence( + id : String, + row : String, +) -> @src.AlignStockholmSequence { + @src.AlignStockholmSequence::create(id, row) catch { + AlignStockholmError(message) => + abort("Stockholm sequence construction failed: " + message) + } +} + +///| +fn align_stockholm_test_sample() -> @src.AlignStockholmAlignment { + align_stockholm_test_parse(@src.align_stockholm_example_text()) +} + +///| +fn align_stockholm_test_custom_text() -> String { + "# STOCKHOLM 1.0\n" + + "# ordinary comment\n" + + "#=GF AU Alice;\n" + + "#=GF AU Bob;\n" + + "#=GF WK Long/\n" + + "#=GF WK Name\n" + + "#=GF SM first command\n" + + "#=GF SM second command\n" + + "#=GF XX ignored alignment annotation\n" + + "#=GF RC reference note\n" + + "#=GF RN [2]\n" + + "#=GF RM 12345\n" + + "#=GF RT title part one\n" + + "#=GF RT title part two\n" + + "#=GF RA Example Author;\n" + + "#=GF RL Example Journal.\n" + + "#=GF DR DB; ONE;\n" + + "#=GF DC database comment\n" + + "#=GF NE PF00001\n" + + "#=GF NL 1-4\n" + + "#=GF SQ 2\n" + + "#=GS alpha AC A1\n" + + "#=GS alpha OS organism one\n" + + "#=GS alpha ZZ custom sequence value\n" + + "#=GS alpha DE Alpha description\n" + + "#=GS alpha DR DBX; 1;\n" + + "#=GS alpha DR DBX; 2;\n" + + "alpha A.-C--G\n" + + "#=GR alpha SS x..y..z\n" + + "beta AT-C--G\n" + + "#=GR beta ZZ wx.y..z\n" + + "#=GC RF 1234567\n" + + "#=GC ZZ abcdefg\n" + + "//\n" +} + +///| +fn align_stockholm_test_custom() -> @src.AlignStockholmAlignment { + align_stockholm_test_parse(align_stockholm_test_custom_text()) +} + +///| +test "Bio.Align.stockholm parses official HAT shape" { + let alignment = align_stockholm_test_sample() + assert_eq(alignment.version, "1.0") + assert_eq(alignment.num_sequences(), 3) + assert_eq(alignment.alignment_length(), 33) + assert_eq(alignment.source_alignment_length(), 33) + assert_eq(alignment.removed_all_gap_columns, 0) +} + +///| +test "Bio.Align.stockholm reports official HAT summary" { + assert_eq( + align_stockholm_test_sample().summary(), + "AlignStockholmAlignment(version=1.0, sequences=3, columns=33, " + + "source_columns=33, removed_all_gap=0)", + ) +} + +///| +test "Bio.Align.stockholm preserves official HAT identifiers" { + let alignment = align_stockholm_test_sample() + assert_eq(alignment.sequences[0].id, "CRN_DROME/191-222") + assert_eq(alignment.sequences[1].id, "CLF1_SCHPO/185-216") + assert_eq(alignment.sequences[2].id, "O16376_CAEEL/201-233") +} + +///| +test "Bio.Align.stockholm normalizes official insertion gaps" { + let alignment = align_stockholm_test_sample() + assert_eq( + alignment.sequences[0].aligned_sequence, + "KEIDRAREIYERFVYVH-PDVKNWIKFARFEES", + ) + assert_eq( + alignment.sequences[1].aligned_sequence, + "HENERARGIYERFVVVH-PEVTNWLRWARFEEE", + ) + assert_eq( + alignment.sequences[2].aligned_sequence, + "KEIDRARSVYQRFLHVHGINVQNWIKYAKFEER", + ) +} + +///| +test "Bio.Align.stockholm stores official ungapped sequences" { + let alignment = align_stockholm_test_sample() + assert_eq(alignment.sequences[0].sequence, "KEIDRAREIYERFVYVHPDVKNWIKFARFEES") + assert_eq(alignment.sequences[1].sequence, "HENERARGIYERFVVVHPEVTNWLRWARFEEE") + assert_eq( + alignment.sequences[2].sequence, + "KEIDRARSVYQRFLHVHGINVQNWIKYAKFEER", + ) +} + +///| +test "Bio.Align.stockholm records official insertion operations" { + assert_eq( + align_stockholm_test_sample().operations, + "MMMMMMMMMMMMMMMMMIMMMMMMMMMMMMMMM", + ) +} + +///| +test "Bio.Align.stockholm maps official identifier annotation" { + let alignment = align_stockholm_test_sample() + assert_eq(alignment.annotation("ID"), Some("HAT")) + assert_eq(alignment.annotation("identifier"), Some("HAT")) +} + +///| +test "Bio.Align.stockholm maps official accession annotation" { + let alignment = align_stockholm_test_sample() + assert_eq(alignment.annotation("AC"), Some("PF02184.18")) + assert_eq(alignment.annotation("accession"), Some("PF02184.18")) +} + +///| +test "Bio.Align.stockholm maps official definition annotation" { + assert_eq( + align_stockholm_test_sample().annotation("definition"), + Some("HAT (Half-A-TPR) repeat"), + ) +} + +///| +test "Bio.Align.stockholm preserves repeated author values" { + assert_eq(align_stockholm_test_sample().annotation_values("author"), [ + "SMART;", + ]) +} + +///| +test "Bio.Align.stockholm maps official seed source" { + assert_eq( + align_stockholm_test_sample().annotation("source of seed"), + Some("Alignment kindly provided by SMART"), + ) +} + +///| +test "Bio.Align.stockholm maps official cutoff annotations" { + let alignment = align_stockholm_test_sample() + assert_eq(alignment.annotation("gathering method"), Some("21.00 21.00;")) + assert_eq(alignment.annotation("trusted cutoff"), Some("21.00 21.00;")) + assert_eq(alignment.annotation("noise cutoff"), Some("20.90 20.90;")) +} + +///| +test "Bio.Align.stockholm maps official build method" { + assert_eq( + align_stockholm_test_sample().annotation("build method"), + Some("hmmbuild HMM.ann SEED.ann"), + ) +} + +///| +test "Bio.Align.stockholm maps official search method" { + assert_eq( + align_stockholm_test_sample().annotation("search method"), + Some("hmmsearch -Z 57096847 -E 1000 --cpu 4 HMM pfamseq"), + ) +} + +///| +test "Bio.Align.stockholm maps official type and clan" { + let alignment = align_stockholm_test_sample() + assert_eq(alignment.annotation("type"), Some("Repeat")) + assert_eq(alignment.annotation("clan"), Some("CL0020")) +} + +///| +test "Bio.Align.stockholm joins official comments" { + assert_eq( + align_stockholm_test_sample().annotation("comment"), + Some( + "The HAT (Half A TPR) repeat is found in several RNA processing " + + "proteins [1].", + ), + ) +} + +///| +test "Bio.Align.stockholm parses official reference number and medline" { + let references = align_stockholm_test_sample().references + assert_eq(references.length(), 1) + assert_eq(references[0].number, 1) + assert_eq(references[0].medline, "9478129") + assert_eq(references[0].comment, "") +} + +///| +test "Bio.Align.stockholm parses official reference citation" { + let reference = align_stockholm_test_sample().references[0] + assert_eq( + reference.title, + "The HAT helix, a repetitive motif implicated in RNA processing.", + ) + assert_eq(reference.author, "Preker PJ, Keller W;") + assert_eq(reference.location, "Trends Biochem Sci 1998;23:15-16.") +} + +///| +test "Bio.Align.stockholm parses official database references" { + let references = align_stockholm_test_sample().database_references + assert_eq(references.length(), 3) + assert_eq(references[0].reference, "INTERPRO; IPR003107;") + assert_eq(references[1].reference, "SMART; HAT;") + assert_eq(references[2].reference, "SO; 0001068; polypeptide_repeat;") +} + +///| +test "Bio.Align.stockholm parses official sequence accessions" { + let sequences = align_stockholm_test_sample().sequences + assert_eq(sequences[0].annotation("accession"), Some("P17886.2")) + assert_eq(sequences[1].annotation("accession"), Some("P87312.1")) + assert_eq(sequences[2].annotation("accession"), Some("O16376.2")) +} + +///| +test "Bio.Align.stockholm parses official sequence database reference" { + assert_eq(align_stockholm_test_sample().sequences[1].dbxrefs, [ + "PDB; 3JB9 R; 185-216;", + ]) +} + +///| +test "Bio.Align.stockholm maps official GR secondary structure" { + let sequence = align_stockholm_test_sample().sequences[1] + assert_eq( + sequence.letter_annotation("secondary structure"), + Some("--HHHHHHHHHHHHHHS--HHHHHHHHHHHHH"), + ) +} + +///| +test "Bio.Align.stockholm preserves official aligned GR value" { + let annotation = align_stockholm_test_sample().sequences[1].letter_annotations[0] + assert_eq(annotation.code, "SS") + assert_eq(annotation.feature, "secondary structure") + assert_eq(annotation.aligned_value, "--HHHHHHHHHHHHHHS.--HHHHHHHHHHHHH") +} + +///| +test "Bio.Align.stockholm maps official GC secondary structure" { + assert_eq( + align_stockholm_test_sample().column_annotation( + "consensus secondary structure", + ), + Some("--HHHHHHHHHHHHHHS.--HHHHHHHHHHHHH"), + ) +} + +///| +test "Bio.Align.stockholm maps official GC consensus sequence" { + assert_eq( + align_stockholm_test_sample().column_annotation("consensus sequence"), + Some("KEIDRARuIYERFVaVH.P-VpNWIKaARFEEc"), + ) +} + +///| +test "Bio.Align.stockholm finds official rows" { + let alignment = align_stockholm_test_sample() + assert_eq(alignment.find_sequence("CRN_DROME/191-222"), Some(0)) + assert_eq(alignment.find_sequence("CLF1_SCHPO/185-216"), Some(1)) + assert_eq(alignment.find_sequence("missing"), None) +} + +///| +test "Bio.Align.stockholm returns official printed columns" { + let alignment = align_stockholm_test_sample() + assert_eq(alignment.column(0), Some("KHK")) + assert_eq(alignment.column(17), Some("--G")) + assert_eq(alignment.column(32), Some("SER")) + assert_eq(alignment.column(-1), None) + assert_eq(alignment.column(33), None) +} + +///| +test "Bio.Align.stockholm maps official sequence positions to columns" { + let alignment = align_stockholm_test_sample() + assert_eq(alignment.sequence_position_to_column(0, 0), Some(0)) + assert_eq(alignment.sequence_position_to_column(0, 16), Some(16)) + assert_eq(alignment.sequence_position_to_column(0, 17), Some(18)) + assert_eq(alignment.sequence_position_to_column(0, 32), None) +} + +///| +test "Bio.Align.stockholm maps official columns to sequence positions" { + let alignment = align_stockholm_test_sample() + assert_eq(alignment.column_to_sequence_position(0, 16), Some(16)) + assert_eq(alignment.column_to_sequence_position(0, 17), None) + assert_eq(alignment.column_to_sequence_position(0, 18), Some(17)) + assert_eq(alignment.column_to_sequence_position(2, 17), Some(17)) +} + +///| +test "Bio.Align.stockholm maps official residues between rows" { + let alignment = align_stockholm_test_sample() + assert_eq(alignment.map_position(0, 1, 0), Some(0)) + assert_eq(alignment.map_position(0, 2, 16), Some(16)) + assert_eq(alignment.map_position(2, 0, 17), None) + assert_eq(alignment.map_position(0, 9, 0), None) +} + +///| +test "Bio.Align.stockholm returns official aligned pairs" { + let pairs = align_stockholm_test_sample().aligned_pairs(0, 2) catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(pairs.length(), 33) + assert_eq(pairs[0], (Some(0), Some(0))) + assert_eq(pairs[17], (None, Some(17))) + assert_eq(pairs[18], (Some(17), Some(18))) + assert_eq(pairs[32], (Some(31), Some(32))) +} + +///| +test "Bio.Align.stockholm builds official compact coordinate path" { + assert_eq(align_stockholm_test_sample().coordinate_path(), [ + [0, 17, 17, 32], + [0, 17, 17, 32], + [0, 17, 18, 33], + ]) +} + +///| +test "Bio.Align.stockholm computes official first pair counts" { + let counts = align_stockholm_test_sample().pair_counts(0, 1) catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(counts.pairs, 1) + assert_eq(counts.aligned, 32) + assert_eq(counts.identities, 21) + assert_eq(counts.mismatches, 11) + assert_eq(counts.gap_columns, 0) + assert_eq(counts.double_gap_columns, 1) + assert_eq(counts.gap_opens, 1) +} + +///| +test "Bio.Align.stockholm computes official insertion pair counts" { + let counts = align_stockholm_test_sample().pair_counts(0, 2) catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(counts.aligned, 32) + assert_eq(counts.identities, 21) + assert_eq(counts.mismatches, 11) + assert_eq(counts.gap_columns, 1) + assert_eq(counts.double_gap_columns, 0) + assert_eq(counts.gap_opens, 1) +} + +///| +test "Bio.Align.stockholm aggregates official all-pair counts" { + let counts = align_stockholm_test_sample().counts() + assert_eq(counts.pairs, 3) + assert_eq(counts.aligned, 96) + assert_eq(counts.identities, 58) + assert_eq(counts.mismatches, 38) + assert_eq(counts.gap_columns, 2) + assert_eq(counts.double_gap_columns, 1) + assert_eq(counts.gap_opens, 3) +} + +///| +test "Bio.Align.stockholm calculates official majority consensus" { + let consensus = align_stockholm_test_sample().consensus() catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(consensus, "KEIDRARXIYERFVXVHGPXVXNWIKXARFEEX") +} + +///| +test "Bio.Align.stockholm computes official occupancy" { + let occupancy = align_stockholm_test_sample().occupancy() + assert_eq(occupancy.length(), 33) + assert_eq(occupancy[0], 1.0) + assert_eq(occupancy[17], 1.0 / 3.0) + assert_eq(occupancy[32], 1.0) +} + +///| +test "Bio.Align.stockholm writes canonical header and terminator" { + let output = align_stockholm_test_write(align_stockholm_test_sample()) + assert_true(output.has_prefix("# STOCKHOLM 1.0\n")) + assert_true(output.has_suffix("//\n")) + assert_true(output.contains("#=GF SQ 3\n")) +} + +///| +test "Bio.Align.stockholm writer restores insertion dots" { + let output = align_stockholm_test_write(align_stockholm_test_sample()) + assert_true(output.contains("KEIDRAREIYERFVYVH.PDVKNWIKFARFEES")) + assert_true(output.contains("HENERARGIYERFVVVH.PEVTNWLRWARFEEE")) +} + +///| +test "Bio.Align.stockholm writer expands residue GR annotations" { + let output = align_stockholm_test_write(align_stockholm_test_sample()) + assert_true(output.contains("#=GR CLF1_SCHPO/185-216")) + assert_true(output.contains("--HHHHHHHHHHHHHHS.--HHHHHHHHHHHHH")) +} + +///| +test "Bio.Align.stockholm canonical writer round-trips rows" { + let alignment = align_stockholm_test_sample() + let reparsed = align_stockholm_test_parse( + align_stockholm_test_write(alignment), + ) + assert_eq(reparsed.sequences, alignment.sequences) + assert_eq(reparsed.operations, alignment.operations) + assert_eq(reparsed.coordinate_path(), alignment.coordinate_path()) +} + +///| +test "Bio.Align.stockholm canonical writer round-trips metadata" { + let alignment = align_stockholm_test_sample() + let reparsed = align_stockholm_test_parse( + align_stockholm_test_write(alignment), + ) + assert_eq(reparsed.annotations, alignment.annotations) + assert_eq(reparsed.references, alignment.references) + assert_eq(reparsed.database_references, alignment.database_references) + assert_eq(reparsed.column_annotations, alignment.column_annotations) +} + +///| +test "Bio.Align.stockholm writes and parses multiple records" { + let alignments = [ + align_stockholm_test_sample(), + align_stockholm_test_custom(), + ] + let output = @src.align_stockholm_write_all(alignments) catch { + AlignStockholmError(message) => abort(message) + } + let reparsed = align_stockholm_test_parse_all(output) + assert_eq(reparsed.length(), 2) + assert_eq(reparsed[0].annotation("identifier"), Some("HAT")) + assert_eq(reparsed[1].num_sequences(), 2) +} + +///| +test "Bio.Align.stockholm parse rejects multiple records" { + let text = @src.align_stockholm_example_text() + + align_stockholm_test_custom_text() + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm parse_all accepts empty input" { + assert_eq(align_stockholm_test_parse_all("").length(), 0) + assert_eq(align_stockholm_test_parse_all("\n \n").length(), 0) +} + +///| +test "Bio.Align.stockholm write_all accepts an empty collection" { + let output = @src.align_stockholm_write_all([]) catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(output, "") +} + +///| +test "Bio.Align.stockholm accepts CRLF records" { + let text = "# STOCKHOLM 1.0\r\n#=GF SQ 1\r\nalpha A-C\r\n//\r\n" + let alignment = align_stockholm_test_parse(text) + assert_eq(alignment.sequences[0].aligned_sequence, "AC") + assert_eq(alignment.operations, "MM") + assert_eq(alignment.source_alignment_length(), 3) + assert_eq(alignment.removed_all_gap_columns, 1) +} + +///| +test "Bio.Align.stockholm ignores ordinary comments" { + let text = "# STOCKHOLM 1.0\n# first\nalpha ACG\n# second\n//\n" + let alignment = align_stockholm_test_parse(text) + assert_eq(alignment.sequences[0].sequence, "ACG") +} + +///| +test "Bio.Align.stockholm ignores unknown GF annotations" { + let alignment = align_stockholm_test_custom() + assert_eq(alignment.annotation("XX"), None) + assert_eq(alignment.annotation("ignored alignment annotation"), None) +} + +///| +test "Bio.Align.stockholm preserves custom GS annotations" { + let sequence = align_stockholm_test_custom().sequences[0] + assert_eq(sequence.annotation("ZZ"), Some("custom sequence value")) + assert_eq(sequence.annotations[2].feature, "ZZ") +} + +///| +test "Bio.Align.stockholm preserves custom GR annotations" { + let sequence = align_stockholm_test_custom().sequences[1] + assert_eq(sequence.letter_annotation("ZZ"), Some("wxyz")) + assert_eq(sequence.letter_annotations[0].aligned_value, "wxyz") +} + +///| +test "Bio.Align.stockholm preserves custom GC annotations" { + let alignment = align_stockholm_test_custom() + assert_eq(alignment.column_annotation("ZZ"), Some("abdg")) +} + +///| +test "Bio.Align.stockholm preserves repeated AU values in order" { + assert_eq(align_stockholm_test_custom().annotation_values("author"), [ + "Alice;", "Bob;", + ]) +} + +///| +test "Bio.Align.stockholm joins repeated search methods" { + assert_eq( + align_stockholm_test_custom().annotation("search method"), + Some("first command second command"), + ) +} + +///| +test "Bio.Align.stockholm joins continued wikipedia values" { + assert_eq(align_stockholm_test_custom().annotation_values("wikipedia"), [ + "LongName", + ]) +} + +///| +test "Bio.Align.stockholm parses GS description" { + assert_eq( + align_stockholm_test_custom().sequences[0].description, + "Alpha description", + ) +} + +///| +test "Bio.Align.stockholm preserves repeated GS database references" { + assert_eq(align_stockholm_test_custom().sequences[0].dbxrefs, [ + "DBX; 1;", "DBX; 2;", + ]) +} + +///| +test "Bio.Align.stockholm maps standard GS organism" { + let sequence = align_stockholm_test_custom().sequences[0] + assert_eq(sequence.annotation("organism"), Some("organism one")) +} + +///| +test "Bio.Align.stockholm parses nested domains" { + let domains = align_stockholm_test_custom().nested_domains + assert_eq(domains.length(), 1) + assert_eq(domains[0].accession, "PF00001") + assert_eq(domains[0].location, "1-4") +} + +///| +test "Bio.Align.stockholm parses database reference comments" { + let references = align_stockholm_test_custom().database_references + assert_eq(references.length(), 1) + assert_eq(references[0].reference, "DB; ONE;") + assert_eq(references[0].comment, "database comment") +} + +///| +test "Bio.Align.stockholm attaches pending reference comments" { + let reference = align_stockholm_test_custom().references[0] + assert_eq(reference.number, 2) + assert_eq(reference.comment, "reference note") + assert_eq(reference.medline, "12345") +} + +///| +test "Bio.Align.stockholm joins multiline reference fields" { + let reference = align_stockholm_test_custom().references[0] + assert_eq(reference.title, "title part one title part two") + assert_eq(reference.author, "Example Author;") + assert_eq(reference.location, "Example Journal.") +} + +///| +test "Bio.Align.stockholm removes all-gap source columns" { + let alignment = align_stockholm_test_custom() + assert_eq(alignment.source_alignment_length(), 7) + assert_eq(alignment.alignment_length(), 4) + assert_eq(alignment.removed_all_gap_columns, 3) + assert_eq(alignment.sequences[0].aligned_sequence, "A-CG") + assert_eq(alignment.sequences[1].aligned_sequence, "ATCG") +} + +///| +test "Bio.Align.stockholm preserves match and insertion operations" { + assert_eq(align_stockholm_test_custom().operations, "MIMM") +} + +///| +test "Bio.Align.stockholm compresses GC with removed columns" { + let alignment = align_stockholm_test_custom() + assert_eq(alignment.column_annotation("RF"), Some("1247")) + assert_eq(alignment.column_annotation("ZZ"), Some("abdg")) +} + +///| +test "Bio.Align.stockholm compresses aligned GR with removed columns" { + let annotation = align_stockholm_test_custom().sequences[0].letter_annotations[0] + assert_eq(annotation.value, "xyz") + assert_eq(annotation.aligned_value, "x.yz") +} + +///| +test "Bio.Align.stockholm maps custom compact coordinates" { + let alignment = align_stockholm_test_custom() + assert_eq(alignment.coordinate_path(), [[0, 1, 1, 3], [0, 1, 2, 4]]) + assert_eq(alignment.map_position(1, 0, 1), None) + assert_eq(alignment.map_position(1, 0, 2), Some(1)) +} + +///| +test "Bio.Align.stockholm computes custom compact pair counts" { + let counts = align_stockholm_test_custom().pair_counts(0, 1) catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(counts.aligned, 3) + assert_eq(counts.identities, 3) + assert_eq(counts.mismatches, 0) + assert_eq(counts.gap_columns, 1) + assert_eq(counts.gap_opens, 1) + assert_eq(counts.identity(), 1.0) +} + +///| +test "Bio.Align.stockholm computes custom compact occupancy" { + assert_eq(align_stockholm_test_custom().occupancy(), [1.0, 0.5, 1.0, 1.0]) +} + +///| +test "Bio.Align.stockholm computes custom compact consensus" { + let consensus = align_stockholm_test_custom().consensus() catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(consensus, "ATCG") +} + +///| +test "Bio.Align.stockholm slices rows and operations" { + let sliced = align_stockholm_test_custom().slice_columns(1, 4) catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(sliced.sequences[0].aligned_sequence, "-CG") + assert_eq(sliced.sequences[1].aligned_sequence, "TCG") + assert_eq(sliced.operations, "IMM") + assert_eq(sliced.source_alignment_length(), 3) +} + +///| +test "Bio.Align.stockholm slices GC annotations" { + let sliced = align_stockholm_test_custom().slice_columns(1, 4) catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(sliced.column_annotation("RF"), Some("247")) + assert_eq(sliced.column_annotation("ZZ"), Some("bdg")) +} + +///| +test "Bio.Align.stockholm slices GR annotations" { + let sliced = align_stockholm_test_custom().slice_columns(1, 4) catch { + AlignStockholmError(message) => abort(message) + } + let first = sliced.sequences[0].letter_annotations[0] + assert_eq(first.aligned_value, ".yz") + assert_eq(first.value, "yz") + assert_eq(sliced.sequences[1].letter_annotations[0].value, "xyz") +} + +///| +test "Bio.Align.stockholm preserves metadata across column slicing" { + let alignment = align_stockholm_test_custom() + let sliced = alignment.slice_columns(1, 4) catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(sliced.annotations, alignment.annotations) + assert_eq(sliced.references, alignment.references) + assert_eq(sliced.database_references, alignment.database_references) + assert_eq(sliced.nested_domains, alignment.nested_domains) +} + +///| +test "Bio.Align.stockholm constructs compact rows directly" { + let alignment = align_stockholm_test_from(["alpha", "beta"], [ + "A.-C--G", "AT-C--G", + ]) + assert_eq(alignment.operations, "MIMM") + assert_eq(alignment.source_alignment_length(), 7) + assert_eq(alignment.removed_all_gap_columns, 3) +} + +///| +test "Bio.Align.stockholm sequence constructor normalizes dots" { + let sequence = align_stockholm_test_sequence("alpha", "A.C-") + assert_eq(sequence.aligned_sequence, "A-C-") + assert_eq(sequence.sequence, "AC") +} + +///| +test "Bio.Align.stockholm annotation constructor defaults feature" { + let annotation = @src.AlignStockholmAnnotation::create("ZZ", "value") catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(annotation.code, "ZZ") + assert_eq(annotation.feature, "ZZ") + assert_eq(annotation.value, "value") +} + +///| +test "Bio.Align.stockholm annotation constructor accepts custom feature" { + let annotation = @src.AlignStockholmAnnotation::create( + "ZZ", + "value", + feature=Some("custom feature"), + ) catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(annotation.feature, "custom feature") +} + +///| +test "Bio.Align.stockholm column constructor maps standard feature" { + let annotation = @src.AlignStockholmColumnAnnotation::create( + "SS_cons", "<<>>", + ) catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(annotation.feature, "consensus secondary structure") +} + +///| +test "Bio.Align.stockholm letter constructor maps standard feature" { + let annotation = @src.AlignStockholmLetterAnnotation::create( + "PP", "999", "9.99", + ) catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(annotation.feature, "posterior probability") +} + +///| +test "Bio.Align.stockholm alignment constructor infers deletion operations" { + let sequences = [ + align_stockholm_test_sequence("alpha", "A-C"), + align_stockholm_test_sequence("beta", "ATC"), + ] + let alignment = @src.AlignStockholmAlignment::create(sequences) catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(alignment.operations, "MDM") + assert_eq(alignment.source_alignment_length(), 3) +} + +///| +test "Bio.Align.stockholm writer preserves custom GS GR and GC" { + let output = align_stockholm_test_write(align_stockholm_test_custom()) + assert_true(output.contains("#=GS alpha ZZ custom sequence value")) + assert_true(output.contains("#=GR beta ZZ ")) + assert_true(output.contains("#=GC ZZ ")) + let reparsed = align_stockholm_test_parse(output) + assert_eq( + reparsed.sequences[0].annotation("ZZ"), + Some("custom sequence value"), + ) + assert_eq(reparsed.sequences[1].letter_annotation("ZZ"), Some("wxyz")) + assert_eq(reparsed.column_annotation("ZZ"), Some("abdg")) +} + +///| +test "Bio.Align.stockholm writer rejects unknown GF annotations" { + let annotation = @src.AlignStockholmAnnotation::create("ZZ", "value") catch { + AlignStockholmError(message) => abort(message) + } + let sequence = align_stockholm_test_sequence("alpha", "ACG") + let alignment = @src.AlignStockholmAlignment::create([sequence], annotations=[ + annotation, + ]) catch { + AlignStockholmError(message) => abort(message) + } + assert_true(align_stockholm_test_write_raises(alignment)) +} + +///| +test "Bio.Align.stockholm writer wraps long comments at 79 columns" { + let comment = @src.AlignStockholmAnnotation::create( + "CC", + "This deliberately long Stockholm comment contains enough words to " + + "require canonical wrapping across multiple GF comment lines.", + feature=Some("comment"), + ) catch { + AlignStockholmError(message) => abort(message) + } + let alignment = @src.AlignStockholmAlignment::create( + [align_stockholm_test_sequence("alpha", "ACG")], + annotations=[comment], + ) catch { + AlignStockholmError(message) => abort(message) + } + let output = align_stockholm_test_write(alignment) + let mut comment_lines = 0 + for line in output.split("\n") { + if line.to_owned().has_prefix("#=GF CC") { + comment_lines = comment_lines + 1 + assert_true(line.length() <= 79) + } + } + assert_true(comment_lines >= 2) +} + +///| +test "Bio.Align.stockholm compares residues case-insensitively" { + let counts = align_stockholm_test_from(["alpha", "beta"], ["aCg", "AcG"]).counts() + assert_eq(counts.identities, 3) + assert_eq(counts.mismatches, 0) +} + +///| +test "Bio.Align.stockholm returns zero identity without aligned residues" { + let counts = align_stockholm_test_from(["alpha", "beta"], ["A-", "-B"]).counts() + assert_eq(counts.aligned, 0) + assert_eq(counts.gap_columns, 2) + assert_eq(counts.identity(), 0.0) +} + +///| +test "Bio.Align.stockholm consensus is case-insensitive" { + let alignment = align_stockholm_test_from(["alpha", "beta", "gamma"], [ + "aCG", "ACG", "tCG", + ]) + let consensus = alignment.consensus() catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(consensus, "ACG") +} + +///| +test "Bio.Align.stockholm consensus honors strict thresholds" { + let alignment = align_stockholm_test_from(["alpha", "beta", "gamma"], [ + "ACG", "TCG", "TCG", + ]) + let consensus = alignment.consensus(minimum_fraction=0.75) catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(consensus, "XCG") +} + +///| +test "Bio.Align.stockholm consensus accepts a custom ambiguous symbol" { + let alignment = align_stockholm_test_from(["alpha", "beta"], ["AC", "TC"]) + let consensus = alignment.consensus(minimum_fraction=0.75, ambiguous="?") catch { + AlignStockholmError(message) => abort(message) + } + assert_eq(consensus, "?C") +} + +///| +test "Bio.Align.stockholm rejects invalid aligned-pair row indexes" { + let alignment = align_stockholm_test_sample() + let low = try { + ignore(alignment.aligned_pairs(-1, 0)) + false + } catch { + AlignStockholmError(_) => true + } + let high = try { + ignore(alignment.aligned_pairs(0, 3)) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(low) + assert_true(high) +} + +///| +test "Bio.Align.stockholm rejects invalid pair-count row indexes" { + let alignment = align_stockholm_test_sample() + let low = try { + ignore(alignment.pair_counts(-1, 0)) + false + } catch { + AlignStockholmError(_) => true + } + let high = try { + ignore(alignment.pair_counts(0, 3)) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(low) + assert_true(high) +} + +///| +test "Bio.Align.stockholm returns None for invalid mappings" { + let alignment = align_stockholm_test_sample() + assert_eq(alignment.sequence_position_to_column(-1, 0), None) + assert_eq(alignment.sequence_position_to_column(3, 0), None) + assert_eq(alignment.sequence_position_to_column(0, -1), None) + assert_eq(alignment.column_to_sequence_position(-1, 0), None) + assert_eq(alignment.column_to_sequence_position(3, 0), None) + assert_eq(alignment.column_to_sequence_position(0, 33), None) +} + +///| +test "Bio.Align.stockholm rejects invalid column slices" { + let alignment = align_stockholm_test_sample() + let first = try { + ignore(alignment.slice_columns(-1, 2)) + false + } catch { + AlignStockholmError(_) => true + } + let second = try { + ignore(alignment.slice_columns(2, 2)) + false + } catch { + AlignStockholmError(_) => true + } + let third = try { + ignore(alignment.slice_columns(0, 34)) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(first) + assert_true(second) + assert_true(third) +} + +///| +test "Bio.Align.stockholm rejects a negative consensus threshold" { + let raised = try { + ignore(align_stockholm_test_sample().consensus(minimum_fraction=-0.1)) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.stockholm rejects a consensus threshold above one" { + let raised = try { + ignore(align_stockholm_test_sample().consensus(minimum_fraction=1.1)) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.stockholm rejects a multi-character ambiguous symbol" { + let raised = try { + ignore(align_stockholm_test_sample().consensus(ambiguous="NN")) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.stockholm rejects empty single-record input" { + assert_true(align_stockholm_test_raises("")) + assert_true(align_stockholm_test_raises("\n\n")) +} + +///| +test "Bio.Align.stockholm rejects an invalid header" { + assert_true(align_stockholm_test_raises("# STOCKHOLM 1.1\nalpha ACG\n//\n")) + assert_true(align_stockholm_test_raises("STOCKHOLM 1.0\nalpha ACG\n//\n")) +} + +///| +test "Bio.Align.stockholm rejects a missing terminator" { + assert_true( + align_stockholm_test_parse_all_raises("# STOCKHOLM 1.0\nalpha ACG\n"), + ) +} + +///| +test "Bio.Align.stockholm rejects a nested header without terminator" { + let text = "# STOCKHOLM 1.0\nalpha ACG\n" + "# STOCKHOLM 1.0\nbeta ACG\n//\n" + assert_true(align_stockholm_test_parse_all_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects an empty record" { + assert_true(align_stockholm_test_raises("# STOCKHOLM 1.0\n//\n")) + assert_true( + align_stockholm_test_raises("# STOCKHOLM 1.0\n#=GF ID empty\n//\n"), + ) +} + +///| +test "Bio.Align.stockholm rejects duplicate identifiers" { + let text = "# STOCKHOLM 1.0\nalpha ACG\nalpha ACG\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects wrapped sequence rows" { + let text = "# STOCKHOLM 1.0\nalpha ACG\nbeta ACG\nalpha TTT\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects unequal row widths" { + let text = "# STOCKHOLM 1.0\nalpha ACG\nbeta AC\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects malformed sequence lines" { + let text = "# STOCKHOLM 1.0\nalpha ACG extra\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects mixed insertion and deletion gaps" { + let text = "# STOCKHOLM 1.0\nalpha A.C\nbeta A-C\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects all-gap-only records" { + let text = "# STOCKHOLM 1.0\nalpha .--\nbeta .--\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects malformed GF annotations" { + assert_true( + align_stockholm_test_raises("# STOCKHOLM 1.0\n#=GF ID\nalpha ACG\n//\n"), + ) + assert_true( + align_stockholm_test_raises( + "# STOCKHOLM 1.0\n#=GFID value\nalpha ACG\n//\n", + ), + ) +} + +///| +test "Bio.Align.stockholm rejects malformed GS annotations" { + assert_true( + align_stockholm_test_raises("# STOCKHOLM 1.0\n#=GS alpha\nalpha ACG\n//\n"), + ) + assert_true( + align_stockholm_test_raises( + "# STOCKHOLM 1.0\n#=GSalpha AC A1\nalpha ACG\n//\n", + ), + ) +} + +///| +test "Bio.Align.stockholm rejects malformed GC annotations" { + assert_true( + align_stockholm_test_raises("# STOCKHOLM 1.0\nalpha ACG\n#=GC RF\n//\n"), + ) + assert_true( + align_stockholm_test_raises("# STOCKHOLM 1.0\nalpha ACG\n#=GCRF xxx\n//\n"), + ) +} + +///| +test "Bio.Align.stockholm rejects malformed GR annotations" { + assert_true( + align_stockholm_test_raises( + "# STOCKHOLM 1.0\nalpha ACG\n#=GR alpha SS\n//\n", + ), + ) + assert_true( + align_stockholm_test_raises( + "# STOCKHOLM 1.0\nalpha ACG\n#=GRalpha SS xxx\n//\n", + ), + ) +} + +///| +test "Bio.Align.stockholm requires GR after its row" { + let before = "# STOCKHOLM 1.0\n#=GR alpha SS xxx\nalpha ACG\n//\n" + let wrong = "# STOCKHOLM 1.0\nalpha ACG\nbeta ACG\n" + + "#=GR alpha SS xxx\n//\n" + assert_true(align_stockholm_test_raises(before)) + assert_true(align_stockholm_test_raises(wrong)) +} + +///| +test "Bio.Align.stockholm rejects duplicate GR annotations" { + let text = "# STOCKHOLM 1.0\nalpha ACG\n" + + "#=GR alpha SS xxx\n#=GR alpha SS yyy\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm validates GF SQ row count" { + let text = "# STOCKHOLM 1.0\n#=GF SQ 2\nalpha ACG\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects duplicate GF SQ" { + let text = "# STOCKHOLM 1.0\n#=GF SQ 1\n#=GF SQ 1\nalpha ACG\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects malformed GF SQ integers" { + let nonnumeric = "# STOCKHOLM 1.0\n#=GF SQ one\nalpha ACG\n//\n" + let zero = "# STOCKHOLM 1.0\n#=GF SQ 0\nalpha ACG\n//\n" + let overflow = "# STOCKHOLM 1.0\n#=GF SQ 2147483648\nalpha ACG\n//\n" + assert_true(align_stockholm_test_raises(nonnumeric)) + assert_true(align_stockholm_test_raises(zero)) + assert_true(align_stockholm_test_raises(overflow)) +} + +///| +test "Bio.Align.stockholm rejects duplicate single GF annotations" { + let text = "# STOCKHOLM 1.0\n#=GF ID one\n#=GF ID two\nalpha ACG\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects reference fields before RN" { + let rm = "# STOCKHOLM 1.0\n#=GF RM 123\nalpha ACG\n//\n" + let rt = "# STOCKHOLM 1.0\n#=GF RT title\nalpha ACG\n//\n" + assert_true(align_stockholm_test_raises(rm)) + assert_true(align_stockholm_test_raises(rt)) +} + +///| +test "Bio.Align.stockholm rejects dangling reference comments" { + let text = "# STOCKHOLM 1.0\n#=GF RC note\nalpha ACG\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects malformed reference numbers" { + let brackets = "# STOCKHOLM 1.0\n#=GF RN 1\nalpha ACG\n//\n" + let zero = "# STOCKHOLM 1.0\n#=GF RN [0]\nalpha ACG\n//\n" + assert_true(align_stockholm_test_raises(brackets)) + assert_true(align_stockholm_test_raises(zero)) +} + +///| +test "Bio.Align.stockholm rejects duplicate reference medline" { + let text = "# STOCKHOLM 1.0\n#=GF RN [1]\n" + + "#=GF RM 123\n#=GF RM 456\nalpha ACG\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects database comments before DR" { + let text = "# STOCKHOLM 1.0\n#=GF DC comment\nalpha ACG\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects duplicate database comments" { + let text = "# STOCKHOLM 1.0\n#=GF DR DB; ONE;\n" + + "#=GF DC first\n#=GF DC second\nalpha ACG\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects nested locations before NE" { + let text = "# STOCKHOLM 1.0\n#=GF NL 1-3\nalpha ACG\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects duplicate nested locations" { + let text = "# STOCKHOLM 1.0\n#=GF NE PF00001\n" + + "#=GF NL 1-3\n#=GF NL 2-4\nalpha ACG\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects GS for unknown rows" { + let text = "# STOCKHOLM 1.0\n#=GS missing AC A1\nalpha ACG\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects duplicate GS annotations" { + let text = "# STOCKHOLM 1.0\n#=GS alpha AC A1\n" + + "#=GS alpha AC A2\nalpha ACG\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm rejects duplicate GS descriptions" { + let text = "# STOCKHOLM 1.0\n#=GS alpha DE first\n" + + "#=GS alpha DE second\nalpha ACG\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm validates GC source width" { + let short = "# STOCKHOLM 1.0\nalpha ACG\n#=GC RF xx\n//\n" + let long = "# STOCKHOLM 1.0\nalpha ACG\n#=GC RF xxxx\n//\n" + assert_true(align_stockholm_test_raises(short)) + assert_true(align_stockholm_test_raises(long)) +} + +///| +test "Bio.Align.stockholm validates GR source width" { + let text = "# STOCKHOLM 1.0\nalpha ACG\n#=GR alpha SS xx\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm validates GR residue count" { + let text = "# STOCKHOLM 1.0\nalpha A-C\n#=GR alpha SS xyz\n//\n" + assert_true(align_stockholm_test_raises(text)) +} + +///| +test "Bio.Align.stockholm parses CSA residue annotations" { + let text = "# STOCKHOLM 1.0\nalpha A-C\n" + + "#=GR alpha CSA x-y\nbeta ATC\n//\n" + let alignment = align_stockholm_test_parse(text) + let annotation = alignment.sequences[0].letter_annotations[0] + assert_eq(annotation.feature, "Catalytic Site Atlas") + assert_eq(annotation.value, "xy") + assert_eq(annotation.aligned_value, "x-y") +} + +///| +test "Bio.Align.stockholm constructors reject missing identifiers" { + assert_true(align_stockholm_test_from_raises([], [])) + assert_true(align_stockholm_test_from_raises(["alpha"], [])) +} + +///| +test "Bio.Align.stockholm constructors reject unequal widths" { + assert_true( + align_stockholm_test_from_raises(["alpha", "beta"], ["ACG", "AC"]), + ) +} + +///| +test "Bio.Align.stockholm constructors reject empty rows" { + assert_true(align_stockholm_test_from_raises(["alpha"], [""])) +} + +///| +test "Bio.Align.stockholm constructors reject all-gap columns only" { + assert_true( + align_stockholm_test_from_raises(["alpha", "beta"], ["---", "..."]), + ) +} + +///| +test "Bio.Align.stockholm sequence constructor rejects empty rows" { + let raised = try { + ignore(@src.AlignStockholmSequence::create("alpha", "")) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.stockholm sequence constructor rejects whitespace IDs" { + let raised = try { + ignore(@src.AlignStockholmSequence::create("bad id", "ACG")) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.stockholm annotation constructors reject empty codes" { + let generic = try { + ignore(@src.AlignStockholmAnnotation::create("", "value")) + false + } catch { + AlignStockholmError(_) => true + } + let column = try { + ignore(@src.AlignStockholmColumnAnnotation::create("", "ACG")) + false + } catch { + AlignStockholmError(_) => true + } + let letter = try { + ignore(@src.AlignStockholmLetterAnnotation::create("", "xyz", "xyz")) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(generic) + assert_true(column) + assert_true(letter) +} + +///| +test "Bio.Align.stockholm annotation constructors reject whitespace codes" { + let raised = try { + ignore(@src.AlignStockholmAnnotation::create("bad code", "value")) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.stockholm alignment constructor rejects duplicate IDs" { + let sequences = [ + align_stockholm_test_sequence("alpha", "ACG"), + align_stockholm_test_sequence("alpha", "ACG"), + ] + let raised = try { + ignore(@src.AlignStockholmAlignment::create(sequences)) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.stockholm alignment constructor validates operations length" { + let sequence = align_stockholm_test_sequence("alpha", "ACG") + let raised = try { + ignore(@src.AlignStockholmAlignment::create([sequence], operations="MM")) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.stockholm alignment constructor validates operation symbols" { + let sequence = align_stockholm_test_sequence("alpha", "ACG") + let raised = try { + ignore(@src.AlignStockholmAlignment::create([sequence], operations="MXM")) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.stockholm alignment constructor rejects match gaps" { + let sequences = [ + align_stockholm_test_sequence("alpha", "A-C"), + align_stockholm_test_sequence("beta", "ATC"), + ] + let raised = try { + ignore(@src.AlignStockholmAlignment::create(sequences, operations="MMM")) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.stockholm alignment constructor validates source metadata" { + let sequence = align_stockholm_test_sequence("alpha", "ACG") + let first = try { + ignore( + @src.AlignStockholmAlignment::create( + [sequence], + source_columns=4, + removed_all_gap_columns=0, + ), + ) + false + } catch { + AlignStockholmError(_) => true + } + let second = try { + ignore( + @src.AlignStockholmAlignment::create( + [sequence], + source_columns=3, + removed_all_gap_columns=-1, + ), + ) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(first) + assert_true(second) +} + +///| +test "Bio.Align.stockholm alignment constructor validates GC width" { + let annotation = @src.AlignStockholmColumnAnnotation::create("RF", "xx") catch { + AlignStockholmError(message) => abort(message) + } + let raised = try { + ignore( + @src.AlignStockholmAlignment::create( + [align_stockholm_test_sequence("alpha", "ACG")], + column_annotations=[annotation], + ), + ) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.stockholm sequence constructor validates GR residue width" { + let annotation = @src.AlignStockholmLetterAnnotation::create( + "SS", "xx", "x.xx", + ) catch { + AlignStockholmError(message) => abort(message) + } + let raised = try { + ignore( + @src.AlignStockholmSequence::create("alpha", "A-CG", letter_annotations=[ + annotation, + ]), + ) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(raised) +} + +///| +test "Bio.Align.stockholm sequence constructor validates aligned GR width" { + let annotation = @src.AlignStockholmLetterAnnotation::create( + "SS", "xyz", "xyz", + ) catch { + AlignStockholmError(message) => abort(message) + } + let raised = try { + ignore( + @src.AlignStockholmSequence::create("alpha", "A-CG", letter_annotations=[ + annotation, + ]), + ) + false + } catch { + AlignStockholmError(_) => true + } + assert_true(raised) +} diff --git a/test/moonbit/msf_test.mbt b/test/moonbit/msf_test.mbt new file mode 100644 index 00000000..13987e9c --- /dev/null +++ b/test/moonbit/msf_test.mbt @@ -0,0 +1,1140 @@ +// Black-box tests for Biopython Bio.Align.msf-compatible support. + +///| +fn msf_test_parse(text : String) -> @src.MsfAlignment { + @src.msf_parse(text) catch { + MsfError(message) => abort("valid MSF input failed: " + message) + } +} + +///| +fn msf_test_parse_unchecked(text : String) -> @src.MsfAlignment { + @src.msf_parse(text, verify_checksums=false) catch { + MsfError(message) => abort("unchecked MSF input failed: " + message) + } +} + +///| +fn msf_test_raises(text : String) -> Bool { + try { + ignore(@src.msf_parse(text)) + false + } catch { + MsfError(_) => true + } +} + +///| +fn msf_test_write_raises( + alignment : @src.MsfAlignment, + block_width : Int, + group_width : Int, + gap_character : String, +) -> Bool { + try { + ignore( + @src.msf_write( + alignment, + block_width=block_width, + group_width=group_width, + gap_character=gap_character, + ), + ) + false + } catch { + MsfError(_) => true + } +} + +///| +fn msf_test_from_aligned_raises( + ids : Array[String], + rows : Array[String], + weights : Array[Double], +) -> Bool { + try { + ignore( + @src.msf_from_aligned( + ids, + rows, + @src.MsfNucleotide, + weights=weights, + ), + ) + false + } catch { + MsfError(_) => true + } +} + +///| +fn msf_test_sequence_raises( + id : String, + row : String, + sequence_type : @src.MsfSequenceType, + weight : Double, + checksum : Int, +) -> Bool { + try { + ignore( + @src.MsfSequence::create( + id, + row, + sequence_type, + weight=weight, + checksum=Some(checksum), + ), + ) + false + } catch { + MsfError(_) => true + } +} + +///| +fn msf_test_sample() -> @src.MsfAlignment { + msf_test_parse(@src.msf_example_text()) +} + +///| +fn msf_test_single_text() -> String { + "!!NA_MULTIPLE_ALIGNMENT 1.0\n" + + "\n" + + "Single MSF: 4 Type: N Check: 748 ..\n" + + "\n" + + " Name: alpha Len: 4 Check: 748 Weight: 1.0\n" + + "//\n" + + "\n" + + " alpha ACGT\n" +} + +///| +fn msf_test_protein_text() -> String { + "!!AA_MULTIPLE_ALIGNMENT 1.0\n" + + "\n" + + "Protein fixture MSF: 12 Type: P Check: 8342 ..\n" + + "\n" + + " Name: alpha Len: 12 Check: 5761 Weight: 1.0\n" + + " Name: beta Len: 8 Check: 2581 Weight: 0.5\n" + + "//\n" + + "\n" + + " alpha ACDEFG HIKLMN\n" + + " beta ACDFGH IK\n" +} + +///| +fn msf_test_doa_length_mismatch_text() -> String { + "!!AA_MULTIPLE_ALIGNMENT\n" + + "\n" + + "DOA-style MSF: 2 Type: P Check: 0 ..\n" + + "\n" + + " Name: full Len: 4 Check: 0 Weight: 1.0\n" + + " Name: short Len: 2 Check: 0 Weight: 1.0\n" + + "//\n" + + "\n" + + " full ACDE\n" + + " short AC\n" +} + +///| +fn msf_test_w_protein_text() -> String { + "!!AA_MULTIPLE_ALIGNMENT\n" + + " MSF: 99 Type: P Oct 18, 2017 11:35 Check: 0 ..\n" + + " Name: W*01:01:01:01 Len: 99 Check: 7236 Weight: 1.00\n" + + " Name: W*01:01:01:02 Len: 99 Check: 7236 Weight: 1.00\n" + + " Name: W*01:01:01:03 Len: 99 Check: 7236 Weight: 1.00\n" + + " Name: W*01:01:01:04 Len: 99 Check: 7236 Weight: 1.00\n" + + " Name: W*01:01:01:05 Len: 99 Check: 7236 Weight: 1.00\n" + + " Name: W*01:01:01:06 Len: 99 Check: 7236 Weight: 1.00\n" + + " Name: W*02:01 Len: 93 Check: 9483 Weight: 1.00\n" + + " Name: W*03:01:01:01 Len: 93 Check: 9974 Weight: 1.00\n" + + " Name: W*03:01:01:02 Len: 93 Check: 9974 Weight: 1.00\n" + + " Name: W*04:01 Len: 93 Check: 9169 Weight: 1.00\n" + + " Name: W*05:01 Len: 99 Check: 7331 Weight: 1.00\n" + + "//\n" + + "\n" + + " W*01:01:01:01 GLTPFNGYTA ATWTRTAVSS VGMNIPYHGA SYLVRNQELR SWTAADKAAQ\n" + + " W*01:01:01:02 GLTPFNGYTA ATWTRTAVSS VGMNIPYHGA SYLVRNQELR SWTAADKAAQ\n" + + " W*01:01:01:03 GLTPFNGYTA ATWTRTAVSS VGMNIPYHGA SYLVRNQELR SWTAADKAAQ\n" + + " W*01:01:01:04 GLTPFNGYTA ATWTRTAVSS VGMNIPYHGA SYLVRNQELR SWTAADKAAQ\n" + + " W*01:01:01:05 GLTPFNGYTA ATWTRTAVSS VGMNIPYHGA SYLVRNQELR SWTAADKAAQ\n" + + " W*01:01:01:06 GLTPFNGYTA ATWTRTAVSS VGMNIPYHGA SYLVRNQELR SWTAADKAAQ\n" + + " W*02:01 GLTPSNGYTA ATWTRTAASS VGMNIPYDGA SYLVRNQELR SWTAADKAAQ\n" + + " W*03:01:01:01 GLTPSSGYTA ATWTRTAVSS VGMNIPYHGA SYLVRNQELR SWTAADKAAQ\n" + + " W*03:01:01:02 GLTPSSGYTA ATWTRTAVSS VGMNIPYHGA SYLVRNQELR SWTAADKAAQ\n" + + " W*04:01 GLTPSNGYTA ATWTRTAASS VGMNIPYDGA SYLVRNQELR SWTAADKAAQ\n" + + " W*05:01 GLTPSSGYTA ATWTRTAVSS VGMNIPYHGA SYLVRNQELR SWTAADKAAQ\n" + + " W*01:01:01:01 MPWRRNRQSC SKPTCREGGR SGSAKSLRMG RRGCSAQNPK DSHDPPPHL\n" + + " W*01:01:01:02 MPWRRNRQSC SKPTCREGGR SGSAKSLRMG RRGCSAQNPK DSHDPPPHL\n" + + " W*01:01:01:03 MPWRRNRQSC SKPTCREGGR SGSAKSLRMG RRGCSAQNPK DSHDPPPHL\n" + + " W*01:01:01:04 MPWRRNRQSC SKPTCREGGR SGSAKSLRMG RRGCSAQNPK DSHDPPPHL\n" + + " W*01:01:01:05 MPWRRNRQSC SKPTCREGGR SGSAKSLRMG RRGCSAQNPK DSHDPPPHL\n" + + " W*01:01:01:06 MPWRRNRQSC SKPTCREGGR SGSAKSLRMG RRGCSAQNPK DSHDPPPHL\n" + + " W*02:01 MPWRRNMQSC SKPTCREGGR SGSAKSLRMG RRRCTAQNPK RLT\n" + + " W*03:01:01:01 MPWRRNRQSC SKPTCREGGR SGSAKSLRMG RRGCSAQNPK RLT\n" + + " W*03:01:01:02 MPWRRNRQSC SKPTCREGGR SGSAKSLRMG RRGCSAQNPK RLT\n" + + " W*04:01 MPWRRNMQSC SKPTCREGGR SGSAKSLRMG RRGCSAQNPK RLT\n" + + " W*05:01 MPWRRNRQSC SKPTCREGGR SGSAKSLRMG RRGCSAQNPK DSHDPPPHL\n" +} + +///| +test "Bio.Align.msf parses sample metadata" { + let alignment = msf_test_sample() + assert_eq(alignment.metadata.header, "!!NA_MULTIPLE_ALIGNMENT 1.0") + assert_eq(alignment.metadata.title, "MoonBit example") + assert_eq(alignment.metadata.declared_length, 12) + assert_eq(alignment.metadata.sequence_type, @src.MsfNucleotide) + assert_eq(alignment.metadata.checksum_label, "Check:") +} + +///| +test "Bio.Align.msf parses interleaved sample rows" { + let alignment = msf_test_sample() + assert_eq(alignment.num_sequences(), 3) + assert_eq(alignment.alignment_length(), 12) + assert_eq(alignment.sequences[0].aligned_sequence, "ACGTACGTACGT") + assert_eq(alignment.sequences[1].aligned_sequence, "ACG-ACGTAC-T") + assert_eq(alignment.sequences[2].aligned_sequence, "A-GTTCGTACGT") +} + +///| +test "Bio.Align.msf preserves ungapped sequences" { + let alignment = msf_test_sample() + assert_eq(alignment.sequences[0].sequence, "ACGTACGTACGT") + assert_eq(alignment.sequences[1].sequence, "ACGACGTACT") + assert_eq(alignment.sequences[2].sequence, "AGTTCGTACGT") +} + +///| +test "Bio.Align.msf preserves lengths and weights" { + let alignment = msf_test_sample() + assert_eq(alignment.sequences[0].length, 12) + assert_eq(alignment.sequences[1].length, 10) + assert_eq(alignment.sequences[2].length, 11) + assert_eq(alignment.sequences[1].weight, 0.75) + assert_eq(alignment.sequences[2].weight, 1.25) +} + +///| +test "Bio.Align.msf validates sample checksums" { + let alignment = msf_test_sample() + assert_true(alignment.sequences[0].checksum_valid()) + assert_true(alignment.sequences[1].checksum_valid()) + assert_true(alignment.sequences[2].checksum_valid()) + assert_true(alignment.checksums_valid()) + assert_eq(alignment.computed_checksum(), 4573) +} + +///| +test "Bio.Align.msf reports summary" { + assert_eq( + msf_test_sample().summary(), + "MsfAlignment(type=N, sequences=3, columns=12, declared=12, checksum=4573)", + ) +} + +///| +test "Bio.Align.msf finds rows by identifier" { + let alignment = msf_test_sample() + assert_eq(alignment.find_sequence("reference"), Some(0)) + assert_eq(alignment.find_sequence("query_two"), Some(2)) + assert_eq(alignment.find_sequence("missing"), None) +} + +///| +test "Bio.Align.msf returns alignment columns" { + let alignment = msf_test_sample() + assert_eq(alignment.column(0), Some("AAA")) + assert_eq(alignment.column(1), Some("CC-")) + assert_eq(alignment.column(3), Some("T-T")) + assert_eq(alignment.column(-1), None) + assert_eq(alignment.column(12), None) +} + +///| +test "Bio.Align.msf maps sequence positions to columns" { + let alignment = msf_test_sample() + assert_eq(alignment.sequence_position_to_column(1, 0), Some(0)) + assert_eq(alignment.sequence_position_to_column(1, 2), Some(2)) + assert_eq(alignment.sequence_position_to_column(1, 3), Some(4)) + assert_eq(alignment.sequence_position_to_column(1, 9), Some(11)) + assert_eq(alignment.sequence_position_to_column(1, 10), None) +} + +///| +test "Bio.Align.msf maps columns to sequence positions" { + let alignment = msf_test_sample() + assert_eq(alignment.column_to_sequence_position(1, 2), Some(2)) + assert_eq(alignment.column_to_sequence_position(1, 3), None) + assert_eq(alignment.column_to_sequence_position(1, 4), Some(3)) + assert_eq(alignment.column_to_sequence_position(1, 11), Some(9)) +} + +///| +test "Bio.Align.msf maps residues between rows" { + let alignment = msf_test_sample() + assert_eq(alignment.map_position(0, 1, 2), Some(2)) + assert_eq(alignment.map_position(0, 1, 3), None) + assert_eq(alignment.map_position(0, 1, 4), Some(3)) + assert_eq(alignment.map_position(1, 0, 3), Some(4)) + assert_eq(alignment.map_position(0, 3, 0), None) +} + +///| +test "Bio.Align.msf emits aligned coordinate pairs" { + let pairs = msf_test_sample().aligned_pairs(0, 1) catch { + MsfError(message) => abort(message) + } + assert_eq(pairs.length(), 12) + assert_eq(pairs[0], (Some(0), Some(0))) + assert_eq(pairs[3], (Some(3), None)) + assert_eq(pairs[4], (Some(4), Some(3))) + assert_eq(pairs[10], (Some(10), None)) + assert_eq(pairs[11], (Some(11), Some(9))) +} + +///| +test "Bio.Align.msf builds compact coordinate path" { + let path = msf_test_sample().coordinate_path() + assert_eq(path.length(), 3) + assert_eq(path[0], [0, 1, 2, 3, 4, 10, 11, 12]) + assert_eq(path[1], [0, 1, 2, 3, 3, 9, 9, 10]) + assert_eq(path[2], [0, 1, 1, 2, 3, 9, 10, 11]) +} + +///| +test "Bio.Align.msf counts identity and gaps" { + let counts = msf_test_sample().pair_counts(0, 1) catch { + MsfError(message) => abort(message) + } + assert_eq(counts.columns, 12) + assert_eq(counts.aligned, 10) + assert_eq(counts.identities, 10) + assert_eq(counts.mismatches, 0) + assert_eq(counts.gap_columns, 2) + assert_eq(counts.double_gap_columns, 0) + assert_eq(counts.gap_opens, 2) + assert_eq(counts.identity(), 1.0) +} + +///| +test "Bio.Align.msf counts mismatches" { + let counts = msf_test_sample().pair_counts(0, 2) catch { + MsfError(message) => abort(message) + } + assert_eq(counts.aligned, 11) + assert_eq(counts.identities, 10) + assert_eq(counts.mismatches, 1) + assert_eq(counts.gap_columns, 1) + assert_eq(counts.gap_opens, 1) +} + +///| +test "Bio.Align.msf counts double-gap columns" { + let alignment = @src.msf_from_aligned( + ["reference", "first", "second"], + ["ACGT", "A--T", "A--T"], + @src.MsfNucleotide, + ) catch { + MsfError(message) => abort(message) + } + let counts = alignment.pair_counts(1, 2) catch { + MsfError(message) => abort(message) + } + assert_eq(counts.aligned, 2) + assert_eq(counts.double_gap_columns, 2) + assert_eq(counts.gap_columns, 0) +} + +///| +test "Bio.Align.msf calculates majority consensus" { + let alignment = msf_test_sample() + assert_eq( + alignment.consensus() catch { + MsfError(message) => abort(message) + }, + "ACGTACGTACGT", + ) +} + +///| +test "Bio.Align.msf applies consensus threshold" { + let consensus = msf_test_sample().consensus(minimum_fraction=1.0) catch { + MsfError(message) => abort(message) + } + assert_eq(consensus, "ACGTXCGTACGT") +} + +///| +test "Bio.Align.msf calculates column occupancy" { + let occupancy = msf_test_sample().occupancy() + assert_eq(occupancy.length(), 12) + assert_eq(occupancy[0], 1.0) + assert_eq(occupancy[1], 2.0 / 3.0) + assert_eq(occupancy[3], 2.0 / 3.0) + assert_eq(occupancy[4], 1.0) + assert_eq(occupancy[10], 2.0 / 3.0) +} + +///| +test "Bio.Align.msf implements standard GCG checksum" { + assert_eq(@src.msf_gcg_checksum("ACGTACGTACGT"), 5688) + assert_eq(@src.msf_gcg_checksum("ACDEFGHIKLMN"), 5761) + assert_eq(@src.msf_gcg_checksum("ACDFGHIK"), 2581) +} + +///| +test "Bio.Align.msf checksum is case insensitive" { + assert_eq(@src.msf_gcg_checksum("acgt"), 748) + assert_eq(@src.msf_gcg_checksum("AcGt"), 748) +} + +///| +test "Bio.Align.msf checksum cycles position after 57" { + assert_eq( + @src.msf_gcg_checksum( + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + ), + 7510, + ) +} + +///| +test "Bio.Align.msf parses official W protein shape" { + let alignment = msf_test_parse(msf_test_w_protein_text()) + assert_eq(alignment.metadata.sequence_type, @src.MsfProtein) + assert_eq(alignment.num_sequences(), 11) + assert_eq(alignment.alignment_length(), 99) + assert_false(alignment.length_mismatch()) +} + +///| +test "Bio.Align.msf parses official W identifiers" { + let alignment = msf_test_parse(msf_test_w_protein_text()) + assert_eq(alignment.sequences[0].id, "W*01:01:01:01") + assert_eq(alignment.sequences[6].id, "W*02:01") + assert_eq(alignment.sequences[10].id, "W*05:01") +} + +///| +test "Bio.Align.msf parses official W sequence" { + let alignment = msf_test_parse(msf_test_w_protein_text()) + assert_eq( + alignment.sequences[0].sequence, + "GLTPFNGYTAATWTRTAVSSVGMNIPYHGASYLVRNQELRSWTAADKAAQMPWRRNRQSCSKPTCREGGRSGSAKSLRMGRRGCSAQNPKDSHDPPPHL", + ) + assert_eq(alignment.sequences[0].checksum, 7236) +} + +///| +test "Bio.Align.msf pads official W short rows" { + let alignment = msf_test_parse(msf_test_w_protein_text()) + assert_eq(alignment.sequences[6].length, 93) + assert_eq(alignment.sequences[6].aligned_sequence.length(), 99) + assert_true(alignment.sequences[6].aligned_sequence.ends_with("RLT------")) + assert_eq(alignment.sequences[6].checksum, 9483) +} + +///| +test "Bio.Align.msf builds official W coordinate path" { + let path = msf_test_parse(msf_test_w_protein_text()).coordinate_path() + assert_eq(path[0], [0, 93, 99]) + assert_eq(path[6], [0, 93, 93]) + assert_eq(path[10], [0, 93, 99]) +} + +///| +test "Bio.Align.msf preserves DOA-style declared length mismatch" { + let alignment = msf_test_parse(msf_test_doa_length_mismatch_text()) + assert_eq(alignment.metadata.declared_length, 2) + assert_eq(alignment.alignment_length(), 4) + assert_true(alignment.length_mismatch()) +} + +///| +test "Bio.Align.msf pads DOA-style completed rows" { + let alignment = msf_test_parse(msf_test_doa_length_mismatch_text()) + assert_eq(alignment.sequences[1].sequence, "AC") + assert_eq(alignment.sequences[1].aligned_sequence, "AC--") + assert_eq(alignment.coordinate_path()[1], [0, 2, 2]) +} + +///| +test "Bio.Align.msf parses PileUp header" { + let text = "PileUp\n\n" + + "PileUp sample MSF: 4 Type: N Check: 0 ..\n\n" + + " Name: alpha oo Len: 4 Check: 0 Weight: 1.0\n" + + "//\n\nalpha ACGT\n" + let alignment = msf_test_parse(text) + assert_eq(alignment.metadata.header, "PileUp") + assert_eq(alignment.metadata.sequence_type, @src.MsfNucleotide) +} + +///| +test "Bio.Align.msf parses EMBOSS CompCheck header" { + let text = "!!NA_MULTIPLE_ALIGNMENT 1.0\n\n" + + "stdout MSF: 4 Type: N 01/08/19 CompCheck: 748 ..\n\n" + + " Name: alpha Len: 4 Check: 748 Weight: 1.0\n" + + "//\n\nalpha ACGT\n" + let alignment = msf_test_parse(text) + assert_eq(alignment.metadata.checksum_label, "CompCheck:") + assert_eq(alignment.metadata.date_text, "01/08/19") +} + +///| +test "Bio.Align.msf preserves title date and preamble" { + let text = "PileUp\n" + + "Generated by MoonBit\n" + + "Project alpha MSF: 4 Type: N Jan 2 2026 Check: 0 ..\n\n" + + " Name: alpha Len: 4 Check: 0 Weight: 1.0\n" + + "//\n\nalpha ACGT\n" + let alignment = msf_test_parse(text) + assert_eq(alignment.metadata.preamble, ["Generated by MoonBit"]) + assert_eq(alignment.metadata.title, "Project alpha") + assert_eq(alignment.metadata.date_text, "Jan 2 2026") +} + +///| +test "Bio.Align.msf accepts CRLF and lowercase residues" { + let text = "!!NA_MULTIPLE_ALIGNMENT\r\n\r\n" + + "MSF: 4 Type: N Check: 0 ..\r\n\r\n" + + "Name: alpha Len: 4 Check: 0 Weight: 1.0\r\n" + + "//\r\n\r\nalpha acgt\r\n" + let alignment = msf_test_parse(text) + assert_eq(alignment.sequences[0].sequence, "ACGT") +} + +///| +test "Bio.Align.msf normalizes dot tilde and hyphen gaps" { + let text = "!!NA_MULTIPLE_ALIGNMENT\n" + + "MSF: 4 Type: N Check: 0 ..\n" + + "Name: dot Len: 3 Check: 0 Weight: 1.0\n" + + "Name: tilde Len: 3 Check: 0 Weight: 1.0\n" + + "Name: hyphen Len: 3 Check: 0 Weight: 1.0\n" + + "//\n\n" + + "dot A.CG\n" + + "tilde AT~G\n" + + "hyphen A-CG\n" + let alignment = msf_test_parse(text) + assert_eq(alignment.sequences[0].aligned_sequence, "A-CG") + assert_eq(alignment.sequences[1].aligned_sequence, "AT-G") + assert_eq(alignment.sequences[2].aligned_sequence, "A-CG") +} + +///| +test "Bio.Align.msf ignores numeric coordinate lines" { + let text = "!!NA_MULTIPLE_ALIGNMENT\n" + + "MSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 0 Weight: 1.0\n" + + "//\n\n" + + "1 2\nalpha AC\n\n3 4\nalpha GT\n" + assert_eq(msf_test_parse(text).sequences[0].sequence, "ACGT") +} + +///| +test "Bio.Align.msf writes canonical default format" { + let output = @src.msf_write(msf_test_sample()) catch { + MsfError(message) => abort(message) + } + assert_true(output.contains("MSF: 12 Type: N")) + assert_true(output.contains("Check: 4573 ..")) + assert_true(output.contains("Name: reference Len: 12 Check: 5688")) + assert_true(output.contains("query_one ACG.ACGTAC .T")) +} + +///| +test "Bio.Align.msf writes tilde gaps" { + let output = @src.msf_write( + msf_test_sample(), + block_width=12, + group_width=4, + gap_character="~", + ) catch { + MsfError(message) => abort(message) + } + assert_true(output.contains("ACG~ ACGT AC~T")) +} + +///| +test "Bio.Align.msf writes hyphen gaps" { + let output = @src.msf_write( + msf_test_sample(), + block_width=12, + group_width=6, + gap_character="-", + ) catch { + MsfError(message) => abort(message) + } + assert_true(output.contains("ACG-AC GTAC-T")) +} + +///| +test "Bio.Align.msf writes custom interleaved blocks" { + let output = @src.msf_write( + msf_test_sample(), + block_width=6, + group_width=3, + ) catch { + MsfError(message) => abort(message) + } + assert_true(output.contains("reference ACG TAC")) + assert_true(output.contains("reference GTA CGT")) +} + +///| +test "Bio.Align.msf round trips canonical output" { + let original = msf_test_sample() + let output = @src.msf_write(original) catch { + MsfError(message) => abort(message) + } + let parsed = msf_test_parse(output) + assert_eq(parsed.num_sequences(), original.num_sequences()) + assert_eq(parsed.alignment_length(), original.alignment_length()) + for index = 0; index < parsed.num_sequences(); index = index + 1 { + assert_eq( + parsed.sequences[index].aligned_sequence, + original.sequences[index].aligned_sequence, + ) + } +} + +///| +test "Bio.Align.msf round trip preserves weights" { + let output = @src.msf_write(msf_test_sample()) catch { + MsfError(message) => abort(message) + } + let parsed = msf_test_parse(output) + assert_eq(parsed.sequences[0].weight, 1.0) + assert_eq(parsed.sequences[1].weight, 0.75) + assert_eq(parsed.sequences[2].weight, 1.25) +} + +///| +test "Bio.Align.msf round trip recomputes checksums" { + let output = @src.msf_write(msf_test_sample()) catch { + MsfError(message) => abort(message) + } + let parsed = msf_test_parse(output) + assert_eq(parsed.metadata.declared_checksum, 4573) + assert_true(parsed.checksums_valid()) +} + +///| +test "Bio.Align.msf constructs alignment from rows" { + let alignment = @src.msf_from_aligned( + ["alpha", "beta"], + ["ACGT", "A-GT"], + @src.MsfNucleotide, + weights=[1.0, 0.5], + ) catch { + MsfError(message) => abort(message) + } + assert_eq(alignment.num_sequences(), 2) + assert_eq(alignment.sequences[1].sequence, "AGT") + assert_eq(alignment.sequences[1].weight, 0.5) + assert_eq(alignment.metadata.declared_length, 4) +} + +///| +test "Bio.Align.msf sequence type emits canonical code" { + assert_eq(@src.MsfProtein.code(), "P") + assert_eq(@src.MsfNucleotide.code(), "N") +} + +///| +test "Bio.Align.msf constructs normalized sequence" { + let sequence = @src.MsfSequence::create( + "alpha", + "acg.t", + @src.MsfNucleotide, + weight=0.25, + ) catch { + MsfError(message) => abort(message) + } + assert_eq(sequence.aligned_sequence, "ACG-T") + assert_eq(sequence.sequence, "ACGT") + assert_eq(sequence.length, 4) + assert_eq(sequence.checksum, 748) + assert_eq(sequence.weight, 0.25) +} + +///| +test "Bio.Align.msf constructs canonical metadata" { + let metadata = @src.MsfMetadata::create(4, @src.MsfProtein) catch { + MsfError(message) => abort(message) + } + assert_eq(metadata.header, "!!AA_MULTIPLE_ALIGNMENT 1.0") + assert_eq(metadata.declared_length, 4) + assert_eq(metadata.sequence_type, @src.MsfProtein) +} + +///| +test "Bio.Align.msf accepts protein wildcard residues" { + let sequence = @src.MsfSequence::create( + "protein", + "ACDX*?", + @src.MsfProtein, + ) catch { + MsfError(message) => abort(message) + } + assert_eq(sequence.sequence, "ACDX*?") +} + +///| +test "Bio.Align.msf accepts nucleotide ambiguity codes" { + let sequence = @src.MsfSequence::create( + "dna", + "ACGTURYSWKMBDHVNX", + @src.MsfNucleotide, + ) catch { + MsfError(message) => abort(message) + } + assert_eq(sequence.length, 17) +} + +///| +test "Bio.Align.msf treats zero checksums as unspecified" { + let alignment = msf_test_parse(msf_test_doa_length_mismatch_text()) + assert_true(alignment.sequences[0].checksum_valid()) + assert_true(alignment.checksums_valid()) +} + +///| +test "Bio.Align.msf rejects empty input" { + assert_true(msf_test_raises("")) +} + +///| +test "Bio.Align.msf rejects leading blank input" { + assert_true(msf_test_raises("\n" + msf_test_single_text())) +} + +///| +test "Bio.Align.msf rejects unknown header" { + assert_true( + msf_test_raises( + "CLUSTAL\nMSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 0 Weight: 1.0\n//\n\nalpha ACGT\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects missing alignment header" { + assert_true(msf_test_raises("!!NA_MULTIPLE_ALIGNMENT\nName: alpha\n")) +} + +///| +test "Bio.Align.msf rejects malformed alignment header" { + assert_true( + msf_test_raises( + "!!NA_MULTIPLE_ALIGNMENT\nMSF: 4 Kind: N Check: 0 ..\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects invalid sequence type" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 4 Type: X Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 0 Weight: 1.0\n//\n\nalpha ACGT\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects header type conflict" { + assert_true( + msf_test_raises( + "!!AA_MULTIPLE_ALIGNMENT\nMSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 0 Weight: 1.0\n//\n\nalpha ACGT\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects zero declared width" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 0 Type: N Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 0 Weight: 1.0\n//\n\nalpha ACGT\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects integer overflow" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 2147483648 Type: N Check: 0 ..\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects file checksum outside range" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 4 Type: N Check: 10000 ..\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects header without names" { + assert_true( + msf_test_raises("PileUp\nMSF: 4 Type: N Check: 0 ..\n//\n\nalpha ACGT\n"), + ) +} + +///| +test "Bio.Align.msf rejects duplicate names" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 0 Weight: 1.0\n" + + "Name: alpha Len: 4 Check: 0 Weight: 1.0\n" + + "//\n\nalpha ACGT\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects missing header terminator" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 0 Weight: 1.0\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects missing blank after terminator" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 0 Weight: 1.0\n//\nalpha ACGT\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects empty sequence body" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 0 Weight: 1.0\n//\n\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects unknown body row" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 0 Weight: 1.0\n//\n\nbeta ACGT\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects row without residues" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 0 Weight: 1.0\n//\n\nalpha\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects excess residues" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha Len: 3 Check: 0 Weight: 1.0\n//\n\nalpha ACGT\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects missing residues" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 0 Weight: 1.0\n//\n\nalpha ACG\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects invalid nucleotide residue" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 0 Weight: 1.0\n//\n\nalpha ACGZ\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects invalid protein residue" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 4 Type: P Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 0 Weight: 1.0\n//\n\nalpha ACD%\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects all-gap alignment column" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 3 Type: N Check: 0 ..\n" + + "Name: alpha Len: 2 Check: 0 Weight: 1.0\n" + + "Name: beta Len: 2 Check: 0 Weight: 1.0\n" + + "//\n\nalpha A.C\nbeta A-C\n", + ), + ) +} + +///| +test "Bio.Align.msf verifies sequence checksum by default" { + let text = "PileUp\nMSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 1 Weight: 1.0\n" + + "//\n\nalpha ACGT\n" + assert_true(msf_test_raises(text)) +} + +///| +test "Bio.Align.msf can disable checksum verification" { + let text = "PileUp\nMSF: 4 Type: N Check: 1 ..\n" + + "Name: alpha Len: 4 Check: 1 Weight: 1.0\n" + + "//\n\nalpha ACGT\n" + let alignment = msf_test_parse_unchecked(text) + assert_false(alignment.checksums_valid()) + assert_eq(alignment.sequences[0].sequence, "ACGT") +} + +///| +test "Bio.Align.msf verifies file checksum by default" { + let text = "PileUp\nMSF: 4 Type: N Check: 1 ..\n" + + "Name: alpha Len: 4 Check: 748 Weight: 1.0\n" + + "//\n\nalpha ACGT\n" + assert_true(msf_test_raises(text)) +} + +///| +test "Bio.Align.msf rejects malformed weight" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 0 Weight: heavy\n//\n\nalpha ACGT\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects negative weight" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha Len: 4 Check: 0 Weight: -1.0\n//\n\nalpha ACGT\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects malformed name descriptor" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha Length: 4 Check: 0 Weight: 1.0\n//\n\nalpha ACGT\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects unexpected descriptor token" { + assert_true( + msf_test_raises( + "PileUp\nMSF: 4 Type: N Check: 0 ..\n" + + "Name: alpha extra Len: 4 Check: 0 Weight: 1.0\n//\n\nalpha ACGT\n", + ), + ) +} + +///| +test "Bio.Align.msf rejects empty row constructor input" { + assert_true( + msf_test_from_aligned_raises([], [], []), + ) +} + +///| +test "Bio.Align.msf rejects mismatched row constructor input" { + assert_true( + msf_test_from_aligned_raises(["alpha"], ["ACGT", "ACGT"], []), + ) +} + +///| +test "Bio.Align.msf rejects mismatched weights" { + assert_true( + msf_test_from_aligned_raises( + ["alpha", "beta"], + ["ACGT", "ACGT"], + [1.0], + ), + ) +} + +///| +test "Bio.Align.msf rejects unequal row widths" { + assert_true( + msf_test_from_aligned_raises( + ["alpha", "beta"], + ["ACGT", "ACG"], + [], + ), + ) +} + +///| +test "Bio.Align.msf rejects duplicate constructor identifiers" { + assert_true( + msf_test_from_aligned_raises( + ["alpha", "alpha"], + ["ACGT", "ACGT"], + [], + ), + ) +} + +///| +test "Bio.Align.msf rejects whitespace in sequence identifier" { + assert_true( + msf_test_sequence_raises( + "bad id", + "ACGT", + @src.MsfNucleotide, + 1.0, + 748, + ), + ) +} + +///| +test "Bio.Align.msf rejects empty aligned sequence" { + assert_true( + msf_test_sequence_raises("", "", @src.MsfNucleotide, 1.0, 0), + ) +} + +///| +test "Bio.Align.msf rejects all-gap sequence" { + assert_true( + msf_test_sequence_raises( + "alpha", + "...", + @src.MsfNucleotide, + 1.0, + 0, + ), + ) +} + +///| +test "Bio.Align.msf rejects sequence checksum outside range" { + assert_true( + msf_test_sequence_raises( + "alpha", + "ACGT", + @src.MsfNucleotide, + 1.0, + 10000, + ), + ) +} + +///| +test "Bio.Align.msf rejects negative sequence weight" { + assert_true( + msf_test_sequence_raises( + "alpha", + "ACGT", + @src.MsfNucleotide, + -1.0, + 748, + ), + ) +} + +///| +test "Bio.Align.msf rejects invalid metadata width" { + let failed = try { + ignore(@src.MsfMetadata::create(0, @src.MsfNucleotide)) + false + } catch { + MsfError(_) => true + } + assert_true(failed) +} + +///| +test "Bio.Align.msf rejects invalid metadata checksum label" { + let failed = try { + ignore( + @src.MsfMetadata::create( + 4, + @src.MsfNucleotide, + checksum_label="Checksum:", + ), + ) + false + } catch { + MsfError(_) => true + } + assert_true(failed) +} + +///| +test "Bio.Align.msf rejects invalid writer block width" { + assert_true(msf_test_write_raises(msf_test_sample(), 0, 1, ".")) +} + +///| +test "Bio.Align.msf rejects indivisible writer groups" { + assert_true(msf_test_write_raises(msf_test_sample(), 10, 3, ".")) +} + +///| +test "Bio.Align.msf rejects invalid writer gap character" { + assert_true(msf_test_write_raises(msf_test_sample(), 10, 5, "_")) +} + +///| +test "Bio.Align.msf rejects invalid consensus threshold" { + let failed = try { + ignore(msf_test_sample().consensus(minimum_fraction=1.1)) + false + } catch { + MsfError(_) => true + } + assert_true(failed) +} + +///| +test "Bio.Align.msf rejects invalid pairwise row" { + let failed = try { + ignore(msf_test_sample().pair_counts(0, 3)) + false + } catch { + MsfError(_) => true + } + assert_true(failed) +} From 263503f926ac1b0226ea3905e9c17677c2f3bfc2 Mon Sep 17 00:00:00 2001 From: eda Date: Thu, 6 Aug 2026 14:13:44 +0800 Subject: [PATCH 34/41] =?UTF-8?q?#28=20pass:=2011572=20feat:=20spicyr?= =?UTF-8?q?=E3=80=81bluster=E3=80=81flowsom=E3=80=81muscat=E3=80=81droplet?= =?UTF-8?q?Utils=E3=80=81mast=E3=80=81singleR=E3=80=81tradeseq=E3=80=81spa?= =?UTF-8?q?tialdecon=E3=80=81scuttle=E3=80=81scDblFinder=E3=80=81slingshot?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 257 +- examples/bluster_demo/main.mbt | 160 ++ examples/bluster_demo/moon.pkg | 5 + examples/droplet_utils_demo/main.mbt | 151 +- examples/flowsom_demo/main.mbt | 189 ++ examples/flowsom_demo/moon.pkg | 5 + examples/lisaclust_demo/main.mbt | 142 ++ examples/lisaclust_demo/moon.pkg | 5 + examples/mast_demo/main.mbt | 222 +- examples/muscat_advanced_demo/main.mbt | 169 ++ examples/muscat_advanced_demo/moon.pkg | 5 + examples/sc_dbl_finder_demo/main.mbt | 143 +- examples/scuttle_demo/main.mbt | 124 + examples/scuttle_demo/moon.pkg | 5 + examples/single_r_demo/main.mbt | 213 +- examples/slingshot_advanced_demo/main.mbt | 163 ++ examples/slingshot_advanced_demo/moon.pkg | 5 + examples/spatialdecon_demo/main.mbt | 171 ++ examples/spatialdecon_demo/moon.pkg | 5 + examples/spicyr_demo/main.mbt | 141 ++ examples/spicyr_demo/moon.pkg | 5 + examples/tradeseq_advanced_demo/main.mbt | 290 +++ examples/tradeseq_advanced_demo/moon.pkg | 5 + src/bluster.mbt | 1931 +++++++++++++++ src/droplet_utils_advanced.mbt | 1679 +++++++++++++ src/flowsom.mbt | 1885 +++++++++++++++ src/lisaclust.mbt | 1443 ++++++++++++ src/mast_advanced.mbt | 1655 +++++++++++++ src/muscat_advanced.mbt | 1859 +++++++++++++++ src/sc_dbl_finder_advanced.mbt | 2209 ++++++++++++++++++ src/scuttle.mbt | 1310 +++++++++++ src/single_r_advanced.mbt | 1667 +++++++++++++ src/slingshot_advanced.mbt | 2153 +++++++++++++++++ src/spatialdecon.mbt | 2126 +++++++++++++++++ src/spicyr.mbt | 1503 ++++++++++++ src/tradeseq_advanced.mbt | 1656 +++++++++++++ test/moonbit/bluster_test.mbt | 1039 ++++++++ test/moonbit/droplet_utils_advanced_test.mbt | 1017 ++++++++ test/moonbit/flowsom_test.mbt | 1188 ++++++++++ test/moonbit/lisaclust_test.mbt | 1006 ++++++++ test/moonbit/mast_advanced_test.mbt | 913 ++++++++ test/moonbit/moon.pkg | 3 +- test/moonbit/muscat_advanced_test.mbt | 1274 ++++++++++ test/moonbit/sc_dbl_finder_advanced_test.mbt | 1223 ++++++++++ test/moonbit/scuttle_test.mbt | 966 ++++++++ test/moonbit/single_r_advanced_test.mbt | 985 ++++++++ test/moonbit/slingshot_advanced_test.mbt | 865 +++++++ test/moonbit/spatialdecon_test.mbt | 1492 ++++++++++++ test/moonbit/spicyr_test.mbt | 1025 ++++++++ test/moonbit/tradeseq_advanced_test.mbt | 993 ++++++++ 50 files changed, 39355 insertions(+), 290 deletions(-) create mode 100644 examples/bluster_demo/main.mbt create mode 100644 examples/bluster_demo/moon.pkg create mode 100644 examples/flowsom_demo/main.mbt create mode 100644 examples/flowsom_demo/moon.pkg create mode 100644 examples/lisaclust_demo/main.mbt create mode 100644 examples/lisaclust_demo/moon.pkg create mode 100644 examples/muscat_advanced_demo/main.mbt create mode 100644 examples/muscat_advanced_demo/moon.pkg create mode 100644 examples/scuttle_demo/main.mbt create mode 100644 examples/scuttle_demo/moon.pkg create mode 100644 examples/slingshot_advanced_demo/main.mbt create mode 100644 examples/slingshot_advanced_demo/moon.pkg create mode 100644 examples/spatialdecon_demo/main.mbt create mode 100644 examples/spatialdecon_demo/moon.pkg create mode 100644 examples/spicyr_demo/main.mbt create mode 100644 examples/spicyr_demo/moon.pkg create mode 100644 examples/tradeseq_advanced_demo/main.mbt create mode 100644 examples/tradeseq_advanced_demo/moon.pkg create mode 100644 src/bluster.mbt create mode 100644 src/droplet_utils_advanced.mbt create mode 100644 src/flowsom.mbt create mode 100644 src/lisaclust.mbt create mode 100644 src/mast_advanced.mbt create mode 100644 src/muscat_advanced.mbt create mode 100644 src/sc_dbl_finder_advanced.mbt create mode 100644 src/scuttle.mbt create mode 100644 src/single_r_advanced.mbt create mode 100644 src/slingshot_advanced.mbt create mode 100644 src/spatialdecon.mbt create mode 100644 src/spicyr.mbt create mode 100644 src/tradeseq_advanced.mbt create mode 100644 test/moonbit/bluster_test.mbt create mode 100644 test/moonbit/droplet_utils_advanced_test.mbt create mode 100644 test/moonbit/flowsom_test.mbt create mode 100644 test/moonbit/lisaclust_test.mbt create mode 100644 test/moonbit/mast_advanced_test.mbt create mode 100644 test/moonbit/muscat_advanced_test.mbt create mode 100644 test/moonbit/sc_dbl_finder_advanced_test.mbt create mode 100644 test/moonbit/scuttle_test.mbt create mode 100644 test/moonbit/single_r_advanced_test.mbt create mode 100644 test/moonbit/slingshot_advanced_test.mbt create mode 100644 test/moonbit/spatialdecon_test.mbt create mode 100644 test/moonbit/spicyr_test.mbt create mode 100644 test/moonbit/tradeseq_advanced_test.mbt diff --git a/README.md b/README.md index 09aef93e..15050c18 100644 --- a/README.md +++ b/README.md @@ -126,7 +126,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | GENIE3 | Bioconductor GENIE3基因调控网络推断: 回归树特征重要性、方差缩减、加权邻接矩阵、对称化网络 | | ✅ | decoupleR | Bioconductor decoupleR功能活性推断: WSum/WMean/Norm/ULM/MLM方法、先验知识网络(PKN)、调控子活性评分 | | ✅ | BayesSpace | Bioconductor BayesSpace空间转录组聚类: t分布混合模型、马尔可夫随机场(MRF)先验、EM算法、六边形/方形网格邻居 | -| ✅ | muscat | Bioconductor muscat单细胞差异状态分析: 伪批量聚合(Sum/Mean/Median)、EdgeR/DESeq2/Limma DS检验、BH-FDR校正、样本QC指标 | +| ✅ | muscat | Bioconductor muscat 1.27.4多样本多亚群差异状态分析: gene × cell严格合同、五类cluster-sample伪批量、任意满秩设计/多contrast、负二项IRLS、经验贝叶斯dispersion、DS/DD与局部/全局BH-FDR、两阶段确认及不可变SCE写回；保留基础聚合/QC兼容API | | ✅ | infercnv | Bioconductor infercnv单细胞拷贝数变异推断: 染色体位置排序基因、参考细胞比较、log2FC有界计算、金字塔权重基因组平滑、每细胞中位数中心化+噪声过滤、CNV分数+肿瘤细胞预测 | | ✅ | SCENIC | Bioconductor SCENIC单细胞调控网络推断与聚类: TF-target共表达模块(GENIE3风格)、Regulon构建(权重剪枝/cisTarget motif排名剪枝)、AUCell活性评分(recovery curve AUC)、二值化阈值(MeanStd/KMeans2/Median)、细胞状态聚类+主控调控因子识别 | | ✅ | CIBERSORT | 免疫细胞去卷积: 非负最小二乘(NNLS)求解细胞类型分数、投影梯度下降、LM22风格特征矩阵(40标记基因×10免疫细胞类型)、Pearson拟合优度+RMSE、分数归一化(Σ=1.0) | @@ -238,6 +238,9 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **dreamlet** | Bioconductor dreamlet | sample×cell-type pseudobulk、TMM、cell/sample/gene过滤、logCPM、Poisson/voom precision weights、分cell-type重复测量模型及study-wide FDR | ✅ | | **nnSVG** | Bioconductor nnSVG | nearest-neighbor Gaussian process、空间变异基因检验、gene-specific length scale、协变量设计、空间方差占比、BH-FDR及SpatialExperiment接入 | ✅ | | **Banksy** | Bioconductor Banksy | H0邻域均值与H1+方位harmonic、六类空间核、lambda联合特征、分组标准化、PCA、多起点k-means、标签平滑、参数扫描及SpatialExperiment接入 | ✅ | +| **spicyR** | Bioconductor spicyR | 有序细胞类型对cross-L曲线、矩形窗口边界校正、图像级共定位统计、precision weights、重复受试者随机截距、条件对比、BH-FDR及SpatialExperiment接入 | ✅ | +| **lisaClust** | Bioconductor lisaClust | 每细胞多类型local-K/centered local-L曲线、Gaussian KDE强度校正、矩形/凸包窗口、圆盘边界修正、确定性多起点k-means、silhouette、区域富集及SpatialExperiment写回 | ✅ | +| **SpatialDecon** | Bioconductor SpatialDecon | 背景感知加权log-normal非负回归、两阶段异常点重拟合、Hessian不确定度、细胞丰度/比例/计数尺度、cell-type collapse、reverse deconvolution、负探针背景、单细胞profile构建及SpatialExperiment写回 | ✅ | | **ALDEx2** | Bioconductor ALDEx2 | Dirichlet Monte Carlo组成型差异丰度、六类denominator、Welch/Wilcoxon与配对检验、effect/overlap、Aitchison距离及SummarizedExperiment接入 | ✅ | | **DirichletMultinomial** | Bioconductor DirichletMultinomial | Dirichlet-multinomial概率、有限混合EM/BFGS聚类、Laplace/AIC/BIC选K、生成式分组分类、分层交叉验证、ROC及SummarizedExperiment接入 | ✅ | | **SummarizedExperiment** | Bioconductor SummarizedExperiment | 多维基因组数据容器、Assays、行/列操作 | ✅ | @@ -331,20 +334,23 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **microbiome** | Bioconductor microbiome | 微生物组分析、Alpha多样性（Shannon/Simpson/Chao1/ACE/Fisher/Pielou）、Beta多样性（Bray-Curtis/Jaccard/JSD/weighted/unweighted UniFrac）、PCoA主坐标分析、差异丰度分析（Welch t检验/Wilcoxon秩和检验/BH校正） | ✅ | | **BiocParallel** | Bioconductor BiocParallel | 并行计算框架、任务分块、并行求和、均值计算、进度追踪 | ✅ | | **ensembldb** | Bioconductor ensembldb | Ensembl注释数据库接口、基因/转录本/外显子/CDS检索、染色体过滤、biotype过滤、基因长度计算 | ✅ | -| **DropletUtils** | Bioconductor DropletUtils | 空液滴检测、barcode排序、knee点检测、emptyDrops算法、细胞过滤 | ✅ | +| **DropletUtils** | Bioconductor DropletUtils 1.33.0 | 严格feature × barcode计数模型、Simple Good-Turing ambient profile、曲线追踪knee/inflection、multinomial/Dirichlet-multinomial概率、alpha估计、确定性Monte Carlo、Phipson–Smyth p值、BH-FDR、高计数保留及SingleCellExperiment写回 | ✅ | | **rhdf5** | Bioconductor rhdf5 | HDF5文件格式支持、数据集读写、组管理、属性操作、文件列表查看 | ✅ | | **Matrix** | Bioconductor Matrix | 稀疏矩阵操作、CSC/CSR格式、矩阵运算（加法、乘法、转置）、行列统计、范数计算 | ✅ | | **BiocGenerics** | Bioconductor BiocGenerics | Bioconductor通用函数、NA处理、排序、集合运算、匹配、表统计、序列生成 | ✅ | | **scran** | Bioconductor scran | 单细胞归一化(sum_factors)、SNN图构建、Leiden聚类、差异标志物分析 | ✅ | | **scrapper** | Bioconductor scrapper | 批次感知RNA QC、大小因子清洗与居中、log-normalization、LOWESS方差趋势、HVG选择、多因子pseudo-bulk、不可变SCE集成 | ✅ | +| **scuttle** | Bioconductor scuttle 1.23.1 | batch-aware median/MAD异常值、subset per-feature QC、重叠feature-set聚合、精确无放回count downsampling、batch/block coverage等化及不可变SCE集成 | ✅ | +| **bluster** | Bioconductor bluster 1.23.0 | 多起点K-means、精确KNN与三类加权SNN图、Louvain风格聚类、two-step量化聚类、Rand/ARI、silhouette、purity、RMSD、modularity、bootstrap稳定性及不可变SCE集成 | ✅ | +| **FlowSOM** | Bioconductor FlowSOM 2.21.0 | 规则网格SOM、KWSP/random/PCA初始化、四类距离、分阶段MST邻域、meta-clustering与自动elbow、节点MFI/CV/SD/MAD/阳性率、MAD outlier、新数据映射及FlowFrame/SCE集成 | ✅ | | **decontX** | Bioconductor decontX | cluster-aware ambient RNA混合模型、每细胞污染率、Beta/Dirichlet先验EM、empty-droplet profile、自动k-means、native/contaminant计数分解与SCE集成 | ✅ | | **celda** | Bioconductor celda | `celda_CG`细胞群/基因模块联合聚类、collapsed likelihood、EM/Gibbs、多链、K/L网格选择、新细胞预测与SCE集成 | ✅ | | **miloR** | Bioconductor miloR | 精确KNN图、精炼重叠邻域、邻域×样本计数、NB-GLM/Wald检验、BH与四种graph spatial FDR、SingleCellExperiment接入 | ✅ | | **monocle3** | Bioconductor monocle3 | 单细胞轨迹分析、PCA/UMAP降维、主图学习、拟时间排序、差异表达分析、分支点检测、分支特异性差异表达 | ✅ | | **ShortRead** | Bioconductor ShortRead | 短读序列质量控制、QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告生成 | ✅ | | **scater** | Bioconductor scater | 单细胞质量控制、QC指标计算、细胞/基因过滤、CPM/log-CPM标准化、HVG检测、PCA降维 | ✅ | -| **MAST** | Bioconductor MAST | 单细胞差异表达分析、Hurdle模型、离散/连续组分检验、BH-FDR校正、结果汇总 | ✅ | -| **SingleR** | Bioconductor SingleR | 细胞类型注释、Spearman/Pearson相关性、参考图谱匹配、精细调优(Fine-tuning)、Delta score置信度评估 | ✅ | +| **MAST** | Bioconductor MAST 1.39.0 | 严格feature × cell数据模型、任意设计矩阵与CDR、Bayesian logistic/Gaussian hurdle GLM、嵌套模型LRT、经验贝叶斯方差收缩、BH-FDR、边际logFC及SingleCellExperiment写回 | ✅ | +| **SingleR** | Bioconductor SingleR 2.15.2 | 严格gene × sample/cell模型、基因名对齐、成对classic markers、ties-aware Spearman、标签内相关分位数、迭代fine-tuning、delta/MAD剪枝、cluster注释、多参考重算及SingleCellExperiment写回 | ✅ | | **Cyclone** | Bioconductor cyclone | 细胞周期评分、基因对(Gene pairs)比较、G1/S/G2/M期相预测、相别分布统计、平均得分分析 | ✅ | | **dorothea** | Bioconductor dorothea | 转录因子活性预测、Regulon分析、VIPER算法、置换检验、Z-score评估、Top TF筛选 | ✅ | | **GenomicFiles** | Bioconductor GenomicFiles | 分布式基因组文件处理、按区间扫描BAM/BED/VCF、批量查询、归约、覆盖度计算 | ✅ | @@ -359,7 +365,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **DelayedArray** | Bioconductor DelayedArray | 延迟计算数组、懒加载操作、分块处理、行/列聚合、子集操作 | ✅ | | **SparseArray** | Bioconductor SparseArray | N维规范化COO稀疏数组、坐标/线性索引、稀疏切片、维度置换与绑定、不可变赋值、算术/统计、矩阵乘法 | ✅ | | **AnnotationFilter** | Bioconductor AnnotationFilter | 基因注释过滤、染色体筛选、生物类型过滤、区域重叠检测、符号模式匹配 | ✅ | -| **scDblFinder** | Bioconductor scDblFinder | 单细胞双细胞检测、Doublet评分计算、最近邻搜索、PCA降维、细胞过滤 | ✅ | +| **scDblFinder** | Bioconductor scDblFinder 1.27.6 | 严格cell × gene数据模型、top-variable特征选择、library normalization/PCA、随机或跨cluster人工doublet、精确kNN比例与来源推断、cxds互斥共表达分数、迭代正则化logistic分类、预期doublet rate阈值优化、capture分层、homotypic修正、pairwise来源富集及SingleCellExperiment写回 | ✅ | | **Batchelor** | Bioconductor batchelor | 单细胞批次校正、rescaleBatches缩放校正、mutual nearest neighbor、fastMNN多批次校正、批次混合评分 | ✅ | | **Seurat** | Bioconductor Seurat | 单细胞数据分析核心、LogNormalize标准化、高可变基因检测、PCA降维、图聚类、UMAP可视化、差异标志物分析、跨样本整合(FindIntegrationAnchors/IntegrateData) | ✅ | | **ChIPseeker** | Bioconductor ChIPseeker | ChIP-seq峰值注释、基因组区域分类(启动子/外显子/内含子/UTR/基因间区)、距离TSS分布、BED格式读取、peak2gene关联分析、注释可视化、统计分析 | ✅ | @@ -388,7 +394,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **bamsignals** | Bioconductor bamsignals | ChIP-seq信号提取（计数模式、RPM/RPKM归一化、基因组区域信号分析、染色质状态分析） | ✅ | | **nucleR** | Bioconductor nucleR | 核小体定位分析（信号平滑、峰值检测、核小体occupancy计算、位置比较、动态变化分析） | ✅ | | **csaw** | Bioconductor csaw | ChIP-seq窗口差异分析（滑动窗口计数、TMM归一化、窗口过滤、负二项GLM检验、差异区域检测） | ✅ | -| **slingshot** | Bioconductor slingshot | 单细胞轨迹推断（MST构建、主曲线拟合、拟时间计算、分支检测） | ✅ | +| **slingshot** | Bioconductor slingshot 2.21.0 | 保留基础MST/主曲线兼容API，并新增hard/soft cluster membership、协方差缩放距离、start/end约束、omega forest、root-to-leaf lineage、同时主曲线、rank重加权/重分配、Optional pseudotime、分支ID、新数据映射及不可变SCE写回 | ✅ | | **SCnorm** | Bioconductor SCnorm | 单细胞RNA-seq归一化（分位数回归、深度依赖偏差校正、基因特异性归一化） | ✅ | | **EDASeq** | Bioconductor EDASeq | RNA-seq探索性分析（GC含量归一化、基因长度校正（Loess）、样本间归一化、RPKM计算） | ✅ | | **Bio.phenotype** | Biopython `Bio.phenotype` | 表型微阵列分析（PlateRecord/WellRecord、logistic/Gompertz生长曲线拟合、CSV/JSON解析、控制减法） | ✅ | @@ -400,7 +406,8 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **destiny** | Bioconductor destiny | 单细胞扩散映射(Diffusion Maps)降维、距离矩阵计算、高斯核构建、特征分解、扩散分量计算 | ✅ | | **Rtsne** | Bioconductor Rtsne | t-SNE降维算法、成对距离计算、条件概率估计（perplexity优化）、联合概率矩阵构建、梯度下降优化（动量/early exaggeration）、Barnes-Hut近似 | ✅ | | **uwot** | Bioconductor uwot | UMAP降维算法、k近邻搜索、模糊单纯集构建、局部模糊集并集、低维嵌入优化（SGD/负采样）、min_dist/spread参数控制 | ✅ | -| **tradeSeq** | Bioconductor tradeSeq | 轨迹差异表达分析、GAM（广义可加模型）拟合、样条基函数、差异表达检验、BH-FDR校正 | ✅ | +| **tradeSeq** | Bioconductor tradeSeq 1.27.0 | 保留基础轨迹差异表达兼容API，并新增gene × cell计数合同、cell × lineage拟时间/权重、library offset、多lineage负二项GAM、惩罚B-spline、dispersion/AIC/协方差、五类Wald检验、log2FC阈值、平滑预测、knot评估、Slingshot直连及不可变SCE写回 | ✅ | +| **muscat advanced** | Bioconductor muscat 1.27.4 | cluster × sample伪批量、sum/mean/median/prop.detected/num.detected、任意设计与多contrast、NB-IRLS、dispersion收缩、CDR归一化DD、local/global FDR、DS/DD stagewise及SingleCellExperiment接入 | ✅ | | **PROGENy** | Bioconductor PROGENy | 通路活性推断、L2正则化线性回归（Ridge回归）、通路基因集权重矩阵、样本通路活性计算 | ✅ | | **AUCell** | Bioconductor AUCell | 单细胞基因集评分、AUC（曲线下面积）计算、基因排序、min-max归一化、细胞/基因集评分查询 | ✅ | | **ggtree** | Bioconductor ggtree | 系统发育树可视化布局算法、矩形布局（phylogram）、放射状布局、无根布局、节点坐标映射、边缘/标签数据生成 | ✅ | @@ -629,9 +636,13 @@ IvanAXu/BioSeqs/ │ ├── annotation_hub.mbt # AnnotationHub 中心化注释资源访问 (资源搜索、类型/提供者/基因组查询、资源管理) │ ├── genomic_features.mbt # GenomicFeatures 基因组注释功能 (Gene/Transcript/Exon数据结构、GTF解析、区域查询) │ ├── graph.mbt # graph 图数据结构 (有向/无向图、最短路径、连通分量、DOT输出) -│ ├── droplet_utils.mbt # DropletUtils 空液滴检测 (emptyDrops算法、knee点检测、细胞过滤) +│ ├── droplet_utils.mbt # DropletUtils 旧版空液滴检测兼容API +│ ├── droplet_utils_advanced.mbt # DropletUtils 1.33.0高级emptyDrops (Good-Turing、DM概率、Monte Carlo、knee/inflection与SCE接入) │ ├── scran.mbt # scran 单细胞归一化与聚类 (sum_factors、SNN图、Leiden聚类、标志物分析) │ ├── scrapper.mbt # scrapper 单细胞预处理 (批次感知RNA QC、大小因子、LOWESS/HVG、pseudo-bulk、SCE集成) +│ ├── scuttle.mbt # scuttle 1.23.1 batch MAD、per-feature QC、feature聚合、精确downsampling与SCE集成 +│ ├── bluster.mbt # bluster 1.23.0 K-means、KNN/SNN图聚类、two-step、聚类诊断、稳定性与SCE集成 +│ ├── flowsom.mbt # FlowSOM 2.21.0拓扑SOM、MST、meta-clustering、节点统计、outlier与容器集成 │ ├── decontx.mbt # decontX ambient RNA去污染 (Bayesian EM、background、自动聚类、计数分解、SCE集成) │ ├── celda.mbt # celda_CG 细胞群与基因模块联合聚类 (collapsed likelihood、EM/Gibbs、多链、模型选择、SCE集成) │ ├── milo.mbt # miloR KNN邻域差异丰度 (精炼采样、NB-GLM、graph spatial FDR、SCE接入) @@ -640,11 +651,15 @@ IvanAXu/BioSeqs/ │ ├── dreamlet.mbt # dreamlet pseudobulk、TMM/voom权重、分cell-type混合模型与study-wide FDR │ ├── nnsvg.mbt # nnSVG nearest-neighbor GP、空间变异检验、length scale与SpatialExperiment接入 │ ├── banksy.mbt # Banksy空间邻域harmonic、lambda联合特征、PCA、聚类、平滑与SpatialExperiment接入 +│ ├── spicyr.mbt # spicyR cross-L共定位、边界校正、加权/随机截距模型与SpatialExperiment接入 +│ ├── lisaclust.mbt # lisaClust local-K/L曲线、KDE、窗口边界修正、区域聚类与SpatialExperiment接入 +│ ├── spatialdecon.mbt # SpatialDecon背景感知log-normal解卷积、异常点重拟合、不确定度与容器接入 │ ├── monocle3.mbt # monocle3 单细胞轨迹分析 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read.mbt # ShortRead 短读序列质量控制 (QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告) │ ├── seq_quality_trim.mbt # NGS质量修剪与接头去除 (质量修剪、接头去除、poly-A修剪、长度/GC过滤、批量修剪) │ ├── scater.mbt # scater 单细胞质量控制 (QC指标计算、细胞/基因过滤、标准化、HVG检测、PCA) -│ ├── mast.mbt # MAST 单细胞差异表达分析 (Hurdle模型、离散/连续检验、BH-FDR校正) +│ ├── mast.mbt # MAST 兼容层 (检测率/Welch检验、BH-FDR与旧版结果API) +│ ├── mast_advanced.mbt # MAST 1.39.0 Bayesian hurdle GLM、嵌套LRT、eBayes与SCE接入 │ ├── genomic_files.mbt # GenomicFiles 分布式基因组文件处理 (BAM/BED/VCF扫描、区间查询、归约、覆盖度) │ ├── diffbind.mbt # DiffBind ChIP-seq差异结合分析 (峰值重叠、共识峰、TMM归一化、NB检验) │ ├── minfi.mbt # minfi DNA甲基化分析 (NOOB/Illumina/分位数/功能归一化、β/M值、DMP/DMR分析) @@ -671,6 +686,7 @@ IvanAXu/BioSeqs/ │ ├── delayed_array.mbt # DelayedArray 延迟计算数组 (懒加载操作、分块处理、行/列聚合、子集操作) │ ├── annotation_filter.mbt # AnnotationFilter 基因注释过滤 (染色体筛选、生物类型过滤、区域重叠检测、符号模式匹配) │ ├── sc_dbl_finder.mbt # scDblFinder 单细胞双细胞检测 (Doublet评分计算、最近邻搜索、PCA降维、细胞过滤) +│ ├── sc_dbl_finder_advanced.mbt # scDblFinder 1.27.6高级流程 (人工doublet、kNN/cxds特征、迭代分类、分层阈值、来源富集与SCE接入) │ ├── batchelor.mbt # Batchelor 单细胞批次校正 (rescaleBatches、mutual nearest neighbor、fastMNN、批次混合评分) │ ├── seurat.mbt # Seurat 单细胞数据分析核心 (标准化、高可变基因、PCA、聚类、UMAP、差异表达、跨样本整合) │ ├── variation.mbt # Bio.Variation 变异分析 (SNP分析、突变检测、氨基酸替换分析、BLOSUM62/Grantham矩阵) @@ -688,7 +704,8 @@ IvanAXu/BioSeqs/ │ ├── metagenomeseq.mbt # metagenomeSeq 零膨胀模型微生物组差异丰度分析 (归一化、零膨胀概率计算) │ ├── hilbertcurve.mbt # HilbertCurve Hilbert曲线坐标映射 (编码/解码、距离计算、基因组线性化) │ ├── taxonomy.mbt # Taxonomy 分类学分析 (Taxon/TaxonomyDatabase、谱系查询、共同祖先计算) -│ ├── single_r.mbt # SingleR 细胞类型注释 (参考图谱、Spearman/Pearson相关性、精细调优) +│ ├── single_r.mbt # SingleR 兼容层 (参考图谱、Spearman/Pearson相关性、旧版结果API) +│ ├── single_r_advanced.mbt # SingleR 2.15.2 marker训练、分位数分类、fine-tuning、剪枝、多参考与SCE接入 │ ├── cyclone.mbt # Cyclone 细胞周期评分 (基因对比较、G1/S/G2/M期相预测) │ ├── dorothea.mbt # dorothea 转录因子活性预测 (Regulon、VIPER、置换检验) │ ├── gff.mbt # GFF GFF3格式解析 (GFFFeature/GFFRecord、属性解析、特征提取) @@ -718,6 +735,7 @@ IvanAXu/BioSeqs/ │ ├── seq_complexity.mbt # 序列复杂度与组成分析 (Shannon熵、GC偏斜、混沌游戏表示) │ ├── csaw.mbt # csaw ChIP-seq窗口差异分析 (滑动窗口计数、TMM归一化、窗口过滤、负二项GLM检验、差异区域检测) │ ├── slingshot.mbt # slingshot 单细胞轨迹推断 (MST构建、主曲线拟合、拟时间计算、分支检测) +│ ├── slingshot_advanced.mbt # slingshot 2.21.0 soft membership、约束forest、同时主曲线、预测与SCE接入 │ ├── scnorm.mbt # SCnorm 单细胞RNA-seq归一化 (分位数回归、深度依赖偏差校正、基因特异性归一化) │ ├── edaseq.mbt # EDASeq RNA-seq探索性分析 (GC含量归一化、基因长度校正Loess、样本间归一化、RPKM计算) │ ├── searchio.mbt # Bio.SearchIO 统一搜索结果模型 (BLAST/HMMER解析、QueryResult/Hit/HSP层次结构、E-value过滤) @@ -731,6 +749,7 @@ IvanAXu/BioSeqs/ │ ├── rtsne.mbt # Rtsne t-SNE降维算法 (距离矩阵、条件概率、梯度下降、动量优化) │ ├── uwot.mbt # uwot UMAP降维算法 (k近邻、模糊单纯集、SGD优化、负采样) │ ├── tradeseq.mbt # tradeSeq 轨迹差异表达分析 (TrajectoryPoint、GAM拟合、样条基函数、差异检验) +│ ├── tradeseq_advanced.mbt # tradeSeq 1.27.0多lineage NB-GAM、Wald检验、预测、knot评估与容器接入 │ ├── progeny.mbt # PROGENy 通路活性推断 (L2正则化线性回归、Ridge回归、通路基因集权重矩阵) │ ├── aucell.mbt # AUCell 单细胞基因集评分 (AUC计算、基因排序、min-max归一化) │ ├── geoquery.mbt # GEO数据库查询 (GDS/GSE/GSM解析、数据下载、平台信息) @@ -763,6 +782,7 @@ IvanAXu/BioSeqs/ │ ├── karyoploter.mbt # karyoploteR 核型可视化 (染色体轨道、数据点、ASCII渲染) │ ├── system_piper.mbt # SystemPipeR 流水线编排 (步骤管理、依赖关系、进度追踪) │ ├── muscat.mbt # muscat 单细胞差异状态分析 (伪批量聚合、DS检验) +│ ├── muscat_advanced.mbt # muscat 1.27.4 NB-IRLS DS/DD、stagewise检验与SCE接入 │ ├── infercnv.mbt # infercnv 单细胞CNV推断 (基因组位置平滑、参考细胞比较、CNV评分) │ ├── scenic.mbt # SCENIC 单细胞调控网络推断 (共表达模块、Regulon构建、AUCell活性评分) │ ├── cibersort.mbt # CIBERSORT 免疫细胞去卷积 (NNLS求解、LM22风格特征矩阵、分数归一化) @@ -957,7 +977,7 @@ IvanAXu/BioSeqs/ │ ├── seqfeature_advanced_demo/ # Bio.SeqFeature CompoundLocation与LocationParser │ ├── rna_structure_demo/ # RNA二级结构预测示例 │ ├── single_cell_demo/ # SingleCell 单细胞数据分析示例 (QC指标、Log标准化、PCA降维、高变异基因) -│ ├── single_r_demo/ # SingleR 细胞类型注释示例 (参考图谱、Spearman/Pearson相关性、精细调优) +│ ├── single_r_demo/ # SingleR 2.15.2 markers、分位数分类、cluster、多参考与SCE写回示例 │ ├── smith_waterman_demo/ # Smith-Waterman 局部序列比对示例 │ ├── subsmat_demo/ # 替换矩阵示例 (BLOSUM62/45、PAM250/30矩阵查询、蛋白质比对打分) │ ├── substitution_matrices_demo/ # 现代替换矩阵示例 (矩阵注册表、频率矩阵计算、log-odds打分、Shannon熵、KL散度、NCBI解析) @@ -981,9 +1001,12 @@ IvanAXu/BioSeqs/ │ ├── annotation_hub_demo/ # AnnotationHub 中心化注释资源访问示例 (资源搜索、类型/提供者/基因组查询) │ ├── genomic_features_demo/ # GenomicFeatures 基因组注释示例 (GTF解析、基因/转录本/外显子查询、区域查询) │ ├── graph_demo/ # graph 图数据结构示例 (有向/无向图构建、最短路径、连通分量、DOT输出) -│ ├── droplet_utils_demo/ # DropletUtils 空液滴检测示例 (emptyDrops算法、knee点检测、细胞过滤) +│ ├── droplet_utils_demo/ # DropletUtils ambient profile、alpha估计、barcode-rank、emptyDrops、过滤与SCE写回示例 │ ├── scran_demo/ # scran 单细胞归一化与聚类示例 (sum_factors、SNN图、Leiden聚类、标志物分析) │ ├── scrapper_demo/ # scrapper 批次感知RNA QC、归一化、LOWESS/HVG、pseudo-bulk与SCE集成示例 +│ ├── scuttle_demo/ # scuttle batch MAD、subset QC、feature聚合、coverage等化与不可变SCE示例 +│ ├── bluster_demo/ # bluster K-means、SNN图、two-step、聚类诊断、bootstrap稳定性与不可变SCE示例 +│ ├── flowsom_demo/ # FlowSOM拓扑训练、MST、节点统计、outlier、新数据与FlowFrame/SCE示例 │ ├── decontx_demo/ # decontX cluster/background去污染、marker校正、诊断与SCE输出示例 │ ├── celda_demo/ # celda_CG联合聚类、module marker、细胞预测、模型选择与SCE输出示例 │ ├── milo_demo/ # miloR KNN图、精炼邻域、NB差异丰度、spatial FDR与SCE接入示例 @@ -995,10 +1018,13 @@ IvanAXu/BioSeqs/ │ ├── dreamlet_demo/ # dreamlet SCE pseudobulk、TMM/voom、donor随机截距与跨cell-type FDR示例 │ ├── nnsvg_demo/ # nnSVG空间变异基因、length scale、过滤与SpatialExperiment接入示例 │ ├── banksy_demo/ # Banksy H0/H1、lambda扫描、PCA聚类、平滑与SpatialExperiment接入示例 +│ ├── spicyr_demo/ # spicyR cross-L、条件对比、重复受试者模型与SpatialExperiment接入示例 +│ ├── lisaclust_demo/ # lisaClust local-K/L、区域聚类、富集与SpatialExperiment写回示例 +│ ├── spatialdecon_demo/ # SpatialDecon背景校正、丰度/计数、collapse、reverse与SpatialExperiment示例 │ ├── monocle3_demo/ # monocle3 单细胞轨迹分析示例 (PCA/UMAP降维、主图学习、拟时间排序) │ ├── short_read_demo/ # ShortRead 短读序列质量控制示例 (QA统计、adapter修剪、质量修剪、FastQC报告) │ ├── scater_demo/ # scater 单细胞质量控制示例 (QC指标计算、细胞/基因过滤、标准化、HVG检测、PCA) -│ ├── mast_demo/ # MAST 单细胞差异表达分析示例 (Hurdle模型、离散/连续检验、BH-FDR校正) +│ ├── mast_demo/ # MAST 1.39.0双组分GLM、LRT/eBayes、边际效应与SCE写回示例 │ ├── genomic_files_demo/ # GenomicFiles 分布式基因组文件处理示例 (BAM/BED/VCF扫描、区间查询、归约、覆盖度) │ ├── diffbind_demo/ # DiffBind ChIP-seq差异结合分析示例 (峰值重叠、共识峰、TMM归一化、NB检验) │ ├── minfi_demo/ # minfi DNA甲基化分析示例 (NOOB/Illumina/分位数/功能归一化、β/M值、DMP/DMR分析) @@ -1020,7 +1046,7 @@ IvanAXu/BioSeqs/ │ ├── sparse_array_demo/ # SparseArray N维稀疏张量、切片/置换、统计、算术与矩阵乘法示例 │ ├── annotation_filter_demo/ # AnnotationFilter 基因注释过滤示例 (染色体筛选、生物类型过滤、区域重叠检测、符号模式匹配) │ ├── sc3_demo/ # SC3 单细胞共识聚类示例 -│ ├── sc_dbl_finder_demo/ # scDblFinder 单细胞双细胞检测示例 (Doublet评分计算、最近邻搜索、PCA降维、细胞过滤) +│ ├── sc_dbl_finder_demo/ # scDblFinder高级流程示例 (capture分层、已知doublet、来源富集、自动聚类、过滤与SCE写回) │ ├── batchelor_demo/ # Batchelor 单细胞批次校正示例 (rescaleBatches、fastMNN、mutual nearest neighbor、批次混合评分) │ ├── seurat_demo/ # Seurat 单细胞数据分析示例 (标准化、高可变基因、PCA、聚类、UMAP、差异标志物分析、跨样本整合) │ ├── chipseeker_demo/ # ChIPseeker ChIP-seq峰值注释示例 (基因组区域分类(启动子/外显子/内含子/UTR/基因间区)、距离TSS分布、BED格式读取、peak2gene关联分析、注释可视化、统计分析) @@ -1060,6 +1086,7 @@ IvanAXu/BioSeqs/ │ ├── sff_io_demo/ # Bio.SeqIO.SffIO SFF二进制解析示例 (二进制编码/解码往返、质量修剪、按名称查找) │ ├── csaw_demo/ # csaw ChIP-seq窗口差异分析示例 (滑动窗口、TMM归一化、差异区域检测) │ ├── slingshot_demo/ # slingshot 单细胞轨迹推断示例 (MST构建、主曲线、拟时间计算) +│ ├── slingshot_advanced_demo/ # slingshot约束MST、同时主曲线、分支、预测及不可变SCE示例 │ ├── scnorm_demo/ # SCnorm 单细胞RNA-seq归一化示例 (分位数回归、深度依赖校正) │ ├── edaseq_demo/ # EDASeq RNA-seq探索性分析示例 (GC归一化、Loess校正、RPKM计算) │ ├── pdb_vectors_demo/ # Bio.PDB.vectors 3D向量与旋转矩阵示例 (Vector3运算、Kabsch叠合、二面角计算) @@ -1074,6 +1101,7 @@ IvanAXu/BioSeqs/ │ ├── rtsne_demo/ # Rtsne t-SNE降维示例 (距离矩阵、条件概率、梯度下降、动量优化) │ ├── uwot_demo/ # uwot UMAP降维示例 (k近邻、模糊单纯集、SGD优化、负采样) │ ├── tradeseq_demo/ # tradeSeq 轨迹差异表达示例 (GAM拟合、基因平滑、差异检验、可视化) +│ ├── tradeseq_advanced_demo/ # tradeSeq NB-GAM、五类检验、预测、knot、Slingshot与SCE示例 │ ├── progeny_demo/ # PROGENy 通路活性推断示例 (L2正则化回归、通路基因集、样本活性计算) │ ├── aucell_demo/ # AUCell 单细胞基因集评分示例 (AUC计算、归一化、细胞/基因集评分) │ ├── ggtree_demo/ # ggtree 系统发育树可视化示例 (矩形/放射状/无根布局、节点坐标) @@ -1105,6 +1133,7 @@ IvanAXu/BioSeqs/ │ ├── karyoploter_demo/ # karyoploteR 核型可视化示例 │ ├── system_piper_demo/ # SystemPipeR 流水线编排示例 │ ├── muscat_demo/ # muscat 单细胞差异状态分析示例 +│ ├── muscat_advanced_demo/ # muscat 1.27.4伪批量、NB-IRLS DS/DD、stagewise与SCE示例 │ ├── infercnv_demo/ # infercnv 单细胞拷贝数变异推断示例 │ ├── scenic_demo/ # SCENIC 单细胞调控网络推断示例 │ ├── cibersort_demo/ # CIBERSORT 免疫细胞去卷积示例 @@ -1277,6 +1306,7 @@ IvanAXu/BioSeqs/ │ │ ├── sequtils_test.mbt │ │ ├── single_cell_test.mbt │ │ ├── single_r_test.mbt +│ │ ├── single_r_advanced_test.mbt │ │ ├── smith_waterman_test.mbt │ │ ├── subsmat_test.mbt │ │ ├── substitution_matrices_test.mbt @@ -1343,6 +1373,7 @@ IvanAXu/BioSeqs/ │ │ ├── diffbind_test.mbt │ │ ├── dose_test.mbt │ │ ├── droplet_utils_test.mbt +│ │ ├── droplet_utils_advanced_test.mbt │ │ ├── dss_test.mbt │ │ ├── dssp_test.mbt │ │ ├── edaseq_test.mbt @@ -1368,6 +1399,7 @@ IvanAXu/BioSeqs/ │ │ ├── kmer_test.mbt │ │ ├── maftools_test.mbt │ │ ├── mast_test.mbt +│ │ ├── mast_advanced_test.mbt │ │ ├── matrix_test.mbt │ │ ├── medline_test.mbt │ │ ├── melting_temp_test.mbt @@ -1406,10 +1438,14 @@ IvanAXu/BioSeqs/ │ │ ├── s4vectors_test.mbt │ │ ├── sc3_test.mbt │ │ ├── sc_dbl_finder_test.mbt +│ │ ├── sc_dbl_finder_advanced_test.mbt │ │ ├── scater_test.mbt │ │ ├── scnorm_test.mbt │ │ ├── scran_test.mbt │ │ ├── scrapper_test.mbt +│ │ ├── scuttle_test.mbt +│ │ ├── bluster_test.mbt +│ │ ├── flowsom_test.mbt │ │ ├── decontx_test.mbt │ │ ├── celda_test.mbt │ │ ├── milo_test.mbt @@ -1448,12 +1484,14 @@ IvanAXu/BioSeqs/ │ │ ├── seq_quality_trim_test.mbt │ │ ├── single_cell_experiment_test.mbt │ │ ├── slingshot_test.mbt +│ │ ├── slingshot_advanced_test.mbt │ │ ├── spatial_experiment_test.mbt │ │ ├── statistics_test.mbt │ │ ├── structure_alignment_test.mbt │ │ ├── taxonomy_test.mbt │ │ ├── topgo_test.mbt │ │ ├── tradeseq_test.mbt +│ │ ├── tradeseq_advanced_test.mbt │ │ ├── tximport_test.mbt │ │ ├── universalmotif_test.mbt │ │ ├── variant_filtering_test.mbt @@ -1488,6 +1526,7 @@ IvanAXu/BioSeqs/ │ │ ├── karyoploter_test.mbt │ │ ├── system_piper_test.mbt │ │ ├── muscat_test.mbt +│ │ ├── muscat_advanced_test.mbt │ │ ├── infercnv_test.mbt │ │ ├── scenic_test.mbt │ │ ├── cibersort_test.mbt @@ -1615,7 +1654,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 10389 个测试全部通过 +moon test # ✅ 11572 个测试全部通过 ``` ### 模块对照表 @@ -1738,6 +1777,9 @@ moon test # ✅ 10389 个测试全 | `dreamlet.mbt` | Bioconductor dreamlet | sample×cell-type pseudobulk、完整TMM、CPM/logCPM、Poisson/voom权重、typed fixed/random design、分cell-type dream拟合及两级BH-FDR | | `nnsvg.mbt` | Bioconductor nnSVG | 坐标缩放与前驱kNN、指数协方差NNGP、协变量GLS、profile ML、空间/非空间LR检验、gene-specific length scale、BH-FDR及SpatialExperiment接入 | | `banksy.mbt` | Bioconductor Banksy | H0邻域均值、H1+方位Fourier/Gabor harmonic、六类空间核、lambda联合矩阵、分组标准化、PCA、多起点k-means、平滑、ARI与SpatialExperiment接入 | +| `spicyr.mbt` | Bioconductor spicyR | 图像内有序细胞类型对cross-L、矩形窗口边界校正、图像级统计、cell-count precision weights、加权固定/随机截距模型、条件对比、BH-FDR及SpatialExperiment接入 | +| `lisaclust.mbt` | Bioconductor lisaClust | 每图像local-K/centered local-L、Gaussian KDE密度权重、矩形/凸包窗口、圆盘可见面积边界修正、确定性多起点k-means、silhouette、区域富集及SpatialExperiment写回 | +| `spatialdecon.mbt` | Bioconductor SpatialDecon | 背景感知加权log-normal非负回归、两阶段异常点重拟合、observed/expected Hessian协方差、细胞丰度尺度、cell-type collapse、reverse deconvolution、负探针背景、单细胞profile与SpatialExperiment接入 | | `decontx.mbt` | Bioconductor decontX | cluster-native/contaminant多项式混合、Beta/Dirichlet先验EM、background、自动聚类、计数分解与SCE输出 | | `celda.mbt` | Bioconductor celda | `celda_CG`分层Dirichlet-multinomial、细胞群/基因模块联合推断、collapsed likelihood、EM/Gibbs、多链、K/L选择、预测与SCE输出 | | `summarized_experiment.mbt` | Bioconductor SummarizedExperiment | 多维数据容器 | @@ -1749,6 +1791,7 @@ moon test # ✅ 10389 个测试全 | `single_cell.mbt` | Bioconductor SingleCellExperiment | 单细胞数据分析 | | `csaw.mbt` | Bioconductor csaw | ChIP-seq窗口差异分析、TMM归一化、负二项GLM检验 | | `slingshot.mbt` | Bioconductor slingshot | 单细胞轨迹推断、MST构建、主曲线拟合、拟时间计算 | +| `slingshot_advanced.mbt` | Bioconductor slingshot 2.21.0 | soft membership、协方差缩放距离、约束MST/omega forest、root-to-leaf lineage、同时主曲线、Optional pseudotime、预测与SCE写回 | | `scnorm.mbt` | Bioconductor SCnorm | 单细胞RNA-seq归一化、分位数回归、深度依赖偏差校正 | | `edaseq.mbt` | Bioconductor EDASeq | RNA-seq探索性分析、GC含量归一化、基因长度校正 | | `glm_gampoi.mbt` | Bioconductor glmGamPoi | Gamma-Poisson GLM、size factors、伪批量聚合、IWLCS拟合、Wald检验、BH-FDR校正 | @@ -1862,6 +1905,15 @@ moon test # ✅ 10389 个测试全 | `geoquery.mbt` | Bioconductor GEOquery | GEO数据库数据获取、Series Matrix解析 | | `tximport.mbt` | Bioconductor tximport | 转录本量化数据导入、基因级别汇总 | | `single_cell_experiment.mbt` | Bioconductor SingleCellExperiment | 单细胞核心容器 (多assay、PCA/tSNE/UMAP降维、size factors) | +| `scuttle.mbt` | Bioconductor scuttle 1.23.1 | batch-aware MAD异常值、subset per-feature QC、feature-set/ID聚合、精确count downsampling、batch/block coverage等化与不可变SCE包装 | +| `bluster.mbt` | Bioconductor bluster 1.23.0 | observation × variable聚类、K-means++多起点、精确KNN、rank/number/Jaccard SNN、Louvain风格优化、two-step、诊断与SingleCellExperiment接入 | +| `flowsom.mbt` | Bioconductor FlowSOM 2.21.0 | cell × marker拓扑SOM、KWSP/PCA、分阶段MST、meta-clustering、节点统计、outlier、FlowFrame与SingleCellExperiment接入 | +| `mast.mbt` | Bioconductor MAST兼容层 | 检测比例与阳性表达的轻量双组分检验、BH-FDR及旧版结果API | +| `mast_advanced.mbt` | Bioconductor MAST 1.39.0 | 任意设计矩阵、Cauchy稳定化logistic/Gaussian hurdle GLM、嵌套LRT、eBayes方差收缩、边际logFC与SingleCellExperiment接入 | +| `single_r.mbt` | Bioconductor SingleR兼容层 | 参考profile、Spearman/Pearson相关性、旧版fine-tuning和结果API | +| `single_r_advanced.mbt` | Bioconductor SingleR 2.15.2 | 成对classic markers、标签内相关分位数、迭代fine-tuning、MAD剪枝、cluster与多参考注释及SingleCellExperiment接入 | +| `droplet_utils.mbt` | Bioconductor DropletUtils兼容层 | 旧版液滴统计、barcode排序、简化emptyDrops与细胞过滤API | +| `droplet_utils_advanced.mbt` | Bioconductor DropletUtils 1.33.0 | Simple Good-Turing ambient profile、curve-tracing knee/inflection、multinomial/Dirichlet-multinomial、alpha MLE、Monte Carlo、BH-FDR与SingleCellExperiment接入 | | `complex_heatmap.mbt` | Bioconductor ComplexHeatmap | 复杂热图可视化 (行/列聚类、颜色映射、热图注释) | | `pheatmap.mbt` | Bioconductor pheatmap | 增强型热图 (层次聚类、距离矩阵、行/列注释、颜色方案) | | `gsva.mbt` | Bioconductor GSVA | 基因集变异分析 (ssGSEA/zscore/PLAGE评分) | @@ -1869,7 +1921,8 @@ moon test # ✅ 10389 个测试全 | `delayed_array.mbt` | Bioconductor DelayedArray | 延迟计算数组 (懒加载操作、分块处理、行/列聚合) | | `sparse_array.mbt` | Bioconductor SparseArray | N维稀疏数组、规范化COO存储、切片/置换/绑定、稀疏算术、统计与矩阵乘法 | | `annotation_filter.mbt` | Bioconductor AnnotationFilter | 基因注释过滤 (染色体筛选、生物类型过滤、区域重叠检测) | -| `sc_dbl_finder.mbt` | Bioconductor scDblFinder | 单细胞双细胞检测 (Doublet评分、最近邻搜索、PCA降维) | +| `sc_dbl_finder.mbt` | Bioconductor scDblFinder兼容层 | 旧版Doublet评分、最近邻搜索、PCA降维与细胞过滤API | +| `sc_dbl_finder_advanced.mbt` | Bioconductor scDblFinder 1.27.6 | 人工doublet、共同归一化/PCA、精确kNN与cxds特征、迭代分类、分层阈值、来源富集及SingleCellExperiment接入 | | `seurat.mbt` | Bioconductor Seurat | 单细胞数据分析核心 (标准化、高可变基因、PCA、聚类、UMAP、差异表达、跨样本整合) | | `chipseeker.mbt` | Bioconductor ChIPseeker | ChIP-seq峰值注释 (基因组区域分类(启动子/外显子/内含子/UTR/基因间区)、距离TSS分布、BED格式读取、peak2gene关联分析、注释可视化) | | `topgo.mbt` | Bioconductor topGO | 拓扑GO富集分析 (TopGOTerm/TopGOGraph/TopGOEnrichmentResult数据结构、elim算法、weight01算法、Fisher精确检验、GO图构建) | @@ -1892,6 +1945,7 @@ moon test # ✅ 10389 个测试全 | `sff_io.mbt` | Biopython `Bio.SeqIO.SffIO` | SFF二进制格式解析 (SffHeader/SffRead/SffFile数据结构、大端字节序u16/u32/u64读写、二进制编码/解码、质量修剪、均值质量、按名称查找) | | `csaw.mbt` | Bioconductor csaw | ChIP-seq窗口差异分析 (CswWindow/CswDataSet/CswNormResult/CswResult数据结构、滑动窗口计数、TMM归一化、窗口过滤、负二项GLM检验、BH-FDR校正、差异区域检测) | | `slingshot.mbt` | Bioconductor slingshot | 单细胞轨迹推断 (SlingshotNode/SlingshotEdge/SlingshotCurve/SlingshotResult数据结构、MST构建、主曲线拟合、拟时间计算、分支检测) | +| `slingshot_advanced.mbt` | Bioconductor slingshot 2.21.0 | hard/soft cluster输入、weighted center/covariance、三类cluster距离、start/end约束Kruskal forest、自动omega、component root与lineage、同时主曲线、rank reweight/reassign、分支/预测及SingleCellExperiment接入 | | `scnorm.mbt` | Bioconductor SCnorm | 单细胞RNA-seq归一化 (SCnormQuantFit/SCnormGeneNormResult/SCnormResult数据结构、分位数回归、深度依赖偏差校正、基因特异性归一化) | | `edaseq.mbt` | Bioconductor EDASeq | RNA-seq探索性分析 (EDASeqGeneAnno/EDASeqDataSet/EDASeqWithinResult/EDASeqBetweenResult数据结构、GC含量归一化、基因长度Loess校正、样本间归一化、RPKM计算) | | `maftools.mbt` | Bioconductor maftools | 癌症基因组学MAF分析 (MAFMutation/MAFData/MutationSpectrum/TMBResult数据结构、SNV/Indel分类、TMB计算、突变谱分析、共现分析、Oncoplot数据生成、MAF文件解析) | @@ -1944,7 +1998,13 @@ moon test # ✅ 10389 个测试全 | `karyoploter.mbt` | `karyoploteR` | 核型可视化（染色体轨道、数据点、ASCII 渲染） | | `system_piper.mbt` | `SystemPipeR` | 流水线编排（步骤管理、依赖关系、进度追踪） | | `muscat.mbt` | `muscat` | 单细胞差异状态分析（伪批量聚合、DS 检验、QC） | +| `muscat_advanced.mbt` | `muscat` 1.27.4 | gene × cell合同、五类cluster-sample伪批量、任意设计/contrast、NB-IRLS与dispersion收缩、DS/DD、stagewise及不可变SCE写回 | +| `droplet_utils_advanced.mbt` | `DropletUtils` | feature × barcode严格计数、Simple Good-Turing、barcode-rank曲线追踪、multinomial/Dirichlet-multinomial及alpha MLE、确定性Monte Carlo、Phipson–Smyth校正、BH-FDR和不可变SCE写回 | | `scrapper.mbt` | `scrapper` | 批次感知RNA QC、大小因子清洗/居中、count与log归一化、LOWESS方差趋势、HVG选择、多因子pseudo-bulk、SingleCellExperiment不可变包装 | +| `scuttle.mbt` | `scuttle` | R风格batch median/MAD及阈值共享、cell-subset feature QC、任意重叠feature-set聚合、精确无放回downsampling、batch/block coverage等化与SingleCellExperiment不可变包装 | +| `bluster.mbt` | `bluster` | K-means++与多起点Lloyd、精确KNN、rank/number/Jaccard SNN、seed可复现的Louvain风格优化、two-step聚类、Rand/ARI与cluster diagnostics、bootstrap稳定性及SingleCellExperiment写回 | +| `flowsom.mbt` | `FlowSOM` | Manhattan/Euclidean/Chebyshev/cosine距离、random/KWSP/PCA码本、规则网格与MST拓扑训练、K-means meta-clustering/elbow、节点MFI/CV/SD/MAD、purity/F-measure、MAD outlier及不可变SCE写回 | +| `slingshot_advanced.mbt` | `slingshot` | soft cluster membership、weighted covariance/Mahalanobis距离、受约束Kruskal forest、固定/自动omega、同时主曲线、cosine共享前缀收缩、rank重加权/重分配、新数据投影及不可变SCE写回 | | `decontx.mbt` | `decontX` | 每细胞native/contaminant Bayesian mixture、确定性EM、empty-droplet ambient profile、自动k-means、诊断与SingleCellExperiment不可变包装 | | `celda.mbt` | `celda` | `celda_CG`细胞群/基因模块联合聚类、四层Dirichlet-multinomial、collapsed EM/Gibbs、多链诊断、K/L网格选择、预测与SingleCellExperiment不可变包装 | | `milo.mbt` | `miloR` | 精确KNN图、median精炼重叠邻域、邻域计数/表达、固定效应NB-GLM/Wald检验、graph spatial FDR与SCE接入 | @@ -1956,6 +2016,9 @@ moon test # ✅ 10389 个测试全 | `dreamlet.mbt` | `dreamlet` | SCE到sample×cluster pseudobulk、TMM/logCPM、两阶段voom precision weights、固定/随机效应筛选、逐cell-type dream和study-wide FDR | | `nnsvg.mbt` | `nnSVG` | AMMD/坐标和排序前驱kNN、指数协方差NNGP、covariate GLS、空间方差比例与length scale优化、LR/p-value/BH-FDR、过滤和SpatialExperiment rowData输出 | | `banksy.mbt` | `Banksy` | kNN/radius邻域核、H0/H1+空间harmonic、lambda加权BANKSY矩阵、global/group scaling、Gram-Jacobi PCA、确定性多起点聚类、平滑与SpatialExperiment输出 | +| `spicyr.mbt` | `spicyR` | ordered cell-type-pair cross-L、矩形窗口disc-intersection边界校正、图像级localization统计、precision weights、加权LMM、条件对比、BH-FDR与SpatialExperiment metadata输出 | +| `lisaclust.mbt` | `lisaClust` | 多细胞类型local-K/L特征、KDE intensity correction、矩形/凸包窗口、disc-window边界积分、确定性多起点k-means、regionMap observed/expected富集与SpatialExperiment region输出 | +| `spatialdecon.mbt` | `SpatialDecon` | background-aware weighted log-normal non-negative regression、algorithm2异常点重拟合、Hessian协方差、abundance/count scaling、cell-type collapse、reverseDecon、GeoMx background、profile构建与SpatialExperiment输出 | | `shared_reference_alignment.mbt` | `Bio.Align.Alignment` | 同参考PWA/MSA的reference-boundary insertion同步、原query投影、局部坐标、metadata、统计与格式转换 | | `alignment_map.mbt` | `Bio.Align.Alignment.map/mapall` | 两层alignment坐标组合、正反链与gap传播、PSL、批量映射及protein/nucleotide MSA投影 | | `alignment_counts.mbt` | `Bio.Align.Alignment.counts` | pairwise/MSA gap事件和composition汇总、正反链、wildcard、替换矩阵及完整affine评分 | @@ -2359,7 +2422,13 @@ moon test # ✅ 10389 个测试全 ### 81. DropletUtils 空液滴检测 (Bioconductor DropletUtils) -实现单细胞 RNA-seq 数据的空液滴检测功能，支持 barcode 排序、knee 点检测和 emptyDrops 算法。可以计算液滴统计指标（总计数、检测基因数），对液滴按总计数排序，找到 knee 点估计细胞数量。支持基于 Monte Carlo 模拟的空液滴检测，计算每个液滴为空的概率和 FDR 值，进行细胞过滤。 +保留 `droplet_utils.mbt` 的旧版液滴统计、barcode 排序和过滤 API；`droplet_utils_advanced.mbt` 对齐 Bioconductor `DropletUtils` 1.33.0 的核心 `emptyDrops` 工作流。`DropletCountMatrix` 固定采用 feature × barcode 方向，严格校验矩形、非负整数计数和唯一非空名称，并通过防御性复制保持输入不可变。 + +ambient profile 可由 `lower`、`by_rank` 或显式 known-empty mask 选择空液滴，聚合 feature counts 后使用 Simple Good-Turing count-of-counts 回归和平滑频率切换；对样本中存在但 ambient 计数为零的 feature，使用安全伪概率保护。barcode-rank 在 log10(rank)-log10(total) 曲线上按固定弧长窗口追踪，以平均 rank 处理 ties，并分别由最短上凸 chord 和最负 gradient 求 knee 与 inflection。 + +概率内核实现完整 multinomial 与 Dirichlet-multinomial 对数概率，后者可在 log-alpha 区间上通过 golden-section 最大似然估计 concentration。Monte Carlo 使用 Park–Miller RNG、Box–Muller 正态和 Marsaglia–Tsang Gamma 采样；相同 library size 共享递增抽样路径，尾部计数采用 Phipson–Smyth `(b+1)/(B+1)` 校正，并以 `Limited` 标记零极端次数。最终对普通 barcode 执行 BH-FDR，高计数 barcode 按显式阈值或自动 knee 无条件保留，未检验值通过 `Option` 保留上游 `NA` 语义。 + +`droplet_utils_empty_drops_sce` 从 `SingleCellExperiment` assay 读取计数，可解析 known-empty 列，并向副本写入 total、log-probability、p-value、Limited、FDR、class、retained、ambient profile 和运行元数据。可移植实现使用稠密矩阵和串行确定性 Monte Carlo；配置中 `alpha < 0` 表示普通 multinomial，`alpha > 0` 表示 Dirichlet-multinomial。上游的稀疏/延迟矩阵调度、BiocParallel 后端和磁盘支持不在当前范围内。 ### 82. scran 单细胞归一化与聚类 (Bioconductor scran) @@ -2379,7 +2448,19 @@ moon test # ✅ 10389 个测试全 ### 86. MAST 单细胞差异表达分析 (Bioconductor MAST) -实现单细胞差异表达分析功能，采用 Hurdle 模型（零膨胀模型）处理单细胞数据的零膨胀特性。模型包含两个组分：离散组分（Fisher 精确检验检测率差异）和连续组分（Welch t 检验表达水平差异）。支持使用卡叉分布合并两个 p 值得到联合检验结果，使用 Benjamini-Hochberg 方法进行 FDR 多重检验校正。支持计算 log2 倍数变化、检测率统计和结果汇总（差异基因计数、Top 基因列表）。适用于单细胞转录组差异表达分析。 +`mast.mbt` 保留原有检测比例、阳性表达 Welch 检验和结果汇总 API 作为兼容层。`mast_advanced.mbt` 参考 Bioconductor MAST 1.39.0 的 `zlm`、`bayesglm`、`lrTest`、`ebayes` 和 `logFC` 实现完整的可移植高级流程，输入统一采用 feature × cell 非负表达矩阵。`MastAdvancedData::create` 接受任意满秩设计矩阵，`mast_advanced_from_groups` 提供可指定 reference 的 treatment coding，并可自动追加每细胞检测率 `cngeneson`/CDR 协变量；构造阶段严格检查矩阵方向、矩形性、有限值、名称唯一性、设计维度和秩。 + +每个基因分别拟合检测事件的 logistic GLM 和仅使用阳性表达的 Gaussian GLM。离散组分使用 IRLS 与非截距系数 scale 2.5 的局部二次 Cauchy 稳定化，连续组分通过 Cholesky 正规方程求解。待检验设计列从完整模型中删除后重新拟合 reduced model，分别计算离散、连续 likelihood-ratio statistic，并将可检验组分的 statistic 与自由度相加形成 hurdle 检验；chi-square survival probability 由 regularized upper incomplete gamma 计算。不可拟合的全零、全阳性或阳性设计秩不足基因保留为 `Double?::None`，BH-FDR 只校正可检验条目。 + +经验贝叶斯层支持 MAST 默认 H0（按基因阳性表达中心化）和 H1（完整设计残差）两种 sufficient statistics，通过 inverse-gamma 边际似然估计先验方差和自由度，再对基因残差方差进行收缩。结果同时提供组分系数/标准误、收敛状态、LRT/FDR、检测率、moderated variance，以及 MAST 定义的离散概率 × 连续均值边际 logFC 和 delta-method 方差。`mast_advanced_zlm_sce` 从 `SingleCellExperiment` assay 和 group `col_data` 读取输入，在深复制的容器中写入检测率、组分/联合 p 值、FDR、logFC、分类、CDR 与运行元数据，不修改调用方对象。当前实现使用稠密数组和串行确定性求解，不包含上游并行后端、稀疏矩阵调度、混合效应模型或绘图接口。 + +### SingleR 2.15.2 参考驱动细胞类型注释 (Bioconductor SingleR) + +`single_r.mbt` 保留参考 profile、Spearman/Pearson 相关性和旧版结果 API 作为兼容层；`single_r_advanced.mbt` 对齐 Bioconductor SingleR 2.15.2 的训练、分类、fine-tuning、剪枝和多参考整合语义。参考矩阵固定为 gene × sample，测试矩阵固定为 gene × cell，构造阶段严格检查矩形性、有限值、名称唯一性和标签长度，并通过防御性复制保持输入不可变。训练按测试基因顺序对齐共享基因，保持标签首次出现顺序，对每个标签计算逐基因中位数，再按有向标签对的正中位数差选择 classic markers；自动 marker 数使用 `500 × (2/3)^log2(N)`。 + +分类对测试细胞和每个参考样本计算支持 ties 平均秩的 Spearman 相关，并以标签内相关分布的线性插值分位数作为 score，默认分位数为 0.8。fine-tuning 从距最高 score 不超过阈值的标签开始，重新合并候选标签间 markers、重算分位数并迭代收缩候选集合；结果同时保留初始 score、最终标签、`delta.next` 和相对所有标签中位数的 `delta.median`。剪枝按最终标签计算 `median(delta) - nmads × 1.4826 × MAD(delta)`，并支持硬 `delta.median`/`delta.next` 下限，未通过项使用 `Option::None` 保留上游 `NA` 语义。 + +高级入口还支持按 cluster 汇总基因表达后注释，以及对多个参考独立分类后，在所有参考和测试共享的 marker 空间中重算 score 并选择来源参考。`single_r_advanced_sce` 默认读取 `logcounts`，可选 cluster `col_data` 列，并向深复制的 `SingleCellExperiment` 写入 label、pruned label、score、delta、cluster 和运行元数据，不修改原容器。当前可移植实现使用稠密数组和串行相关计算，不包含上游 BiocNeighbors、DelayedArray、BiocParallel、HDF5 索引或 celldex 数据下载后端。 ### 87. GenomicFiles 分布式基因组文件处理 (Bioconductor GenomicFiles) @@ -2427,7 +2508,13 @@ moon test # ✅ 10389 个测试全 ### 98. scDblFinder 单细胞双细胞检测 (Bioconductor scDblFinder) -实现单细胞 RNA-seq 数据的双细胞（doublet）检测功能，支持 Doublet 评分计算和细胞过滤。可以创建 SingleCellData 对象（计数矩阵、细胞名称、基因名称）和 DoubletScore 对象（细胞名称、评分、是否为双细胞）。支持距离计算（scdf_compute_distance）、最近邻搜索（scdf_find_nearest_neighbors）、Doublet 评分计算（scdf_compute_doublet_score）、双细胞检测（scdf_detect_doublets）、结果汇总（scdf_doublet_summary）和细胞过滤（scdf_filter_doublets）。支持 PCA 降维（scdf_compute_pca）用于降维后距离计算。适用于单细胞数据的质量控制和双细胞去除。 +在保留 `sc_dbl_finder.mbt` 旧版 `SingleCellData`、`DoubletScore` 和 8 个兼容测试的基础上，`sc_dbl_finder_advanced.mbt` 实现 Bioconductor `scDblFinder` 1.27.6 的高级单细胞 RNA-seq doublet 检测流程。严格构造器要求矩形 cell × gene 非负有限计数、唯一非空标识和非零文库，并执行防御性复制；`ScDblFinderConfig` 对预期 doublet rate、人工样本数、特征数、维度、邻居数、迭代和分类器参数执行完整边界校验。 + +算法按 capture/sample 独立拟合。每批选择高方差基因，对真实和人工细胞共同进行 library normalization、log1p 转换和确定性 PCA；人工 doublet 可随机配对或按 cluster 跨群配对，并支持 half-size 缩放。精确 kNN 计算人工邻居比例、逆距离与 rank 加权比例、最近真实/人工距离、`nearestClass`、最可能来源和来源歧义度。额外计算 library size、检测基因数、`nAbove2` 及 cxds 风格互斥基因共表达 surprise 分数。 + +分类阶段使用确定性、类别平衡、L2 正则化 logistic gradient descent 代替上游 XGBoost，并在每轮重新训练前排除高疑似真实细胞和不可识别人工 doublet。阈值通过预期 doublet rate 偏差、假阳性率和人工 doublet 假阴性率的联合损失优化；cluster-aware 模式使用 `Σp_c²` 修正 homotypic 比例，并提供 Poisson 上尾与 BH-FDR 校正的 pairwise origin enrichment。结果支持按名称查询、top doublet 排序、摘要、singlet 过滤和自动快速聚类。 + +`sc_dbl_finder_single_cell_experiment` 接受 gene × cell assay，显式转置后拟合，并以不可变复制写回 `score`、`class`、邻居比例、加权比例、most likely origin、selected genes、PCA 和元数据。为控制 MoonBit 精确 kNN 的计算量，自动人工 doublet 数使用 `max(150, min(1500, 2 × nCells))`，不同于上游最少 1500 的默认策略；当前不复刻 XGBoost、BiocNeighbors 后端、Poisson resampling、meta-cell/triplet、scATAC Amulet、fragment overlap 和 feature aggregation。 ### 99. ChIPseeker ChIP-seq峰值注释 (Bioconductor ChIPseeker) @@ -3026,6 +3113,14 @@ moon test # ✅ 10389 个测试全 基因建模提供均值、sample variance、quarter-root LOWESS 局部线性趋势、左侧向原点外推、残差方差和带 ties/bound 控制的 HVG 选择。`scrapper_aggregate_across_cells` 可按一个或多个分类因子的唯一组合生成 pseudo-bulk sums、detected counts、means 和 medians，并返回组组合及每个细胞的组索引。`scrapper_normalize_rna_counts_sce` 与 `scrapper_quick_rna_qc_sce` 深复制 assay 和主要注释后写入结果，避免修改原 `SingleCellExperiment`。当前实现是无需 libscran C++ 的可移植 MoonBit 版本，不保证 LOWESS 与上游后端位级一致，也不覆盖 `scrapper` 的全部导出接口。 +### scuttle 1.23.1 单细胞基础工具 (Bioconductor scuttle) + +在避免复制 `scrapper.mbt` 已覆盖的细胞 QC、归一化、方差建模和 pseudo-bulk 功能的前提下，`scuttle.mbt` 对齐 Bioconductor `scuttle` 1.23.1 中仍缺失的复杂语义，所有矩阵统一采用 feature × cell 方向。`scuttle_is_outlier` 使用 R 的 `1.4826 × median absolute deviation`，支持 lower/higher/both tail、log2 空间、阈值估计 subset、逐 batch 估计、median/MAD 共享及缺失 batch 恢复；batch 名按因子式字典序输出，无法估计的阈值和状态分别由 validity 标记与 `Bool?::None` 保留。 + +per-feature QC 计算全体及命名 cell subset 的均值、严格检测百分比和 subset/global ratio。feature 聚合支持任意重叠集合、sum/average、检测计数及按字符串 ID 的字典序分组。downsampling 会先将数值 count 四舍五入并把负值截为零，再通过固定 seed 的 Park–Miller RNG 执行无放回抽样；逐列或全矩阵输出总量严格等于 `round(total × proportion)`。batch downsampling 可按 median、mean 或 `exp(mean(log(1+x)))` 汇总 coverage，并可在 block 内等化到最浅 batch。 + +`scuttle_per_feature_qc_sce`、`scuttle_aggregate_feature_sets_sce` 和 `scuttle_downsample_sce` 深复制 assay、row/column metadata、reduced dimensions、metadata 与 alternative experiments。QC 写入 row metadata，feature-set 聚合替换所选 assay 并清除失效的 gene-level metadata，downsampling 添加新 assay，均不修改输入容器。当前实现采用稠密数组和串行确定性抽样，不覆盖上游稀疏/延迟矩阵、BiocParallel 后端及已由 `scrapper` 提供的重叠接口。 + ### 245. BinaryCIF 二进制结构格式 (Bio.PDB.binary_cif) 实现与 Biopython `Bio.PDB.binary_cif` 对应的 BinaryCIF 解析与结构转换。`binary_cif_parse` 使用纯 MoonBit MessagePack 读取器解析 data block、category 和 column，并支持 `ByteArray`、`FixedPoint`、`IntervalQuantization`、`RunLength`、`Delta`、`IntegerPacking` 和 `StringArray` 七类 BinaryCIF 逆编码；编码流水线按规范逆序执行。列 API 提供整数、浮点、文本和原始 CIF token 查询，并将 mask 的 `0/1/2` 分别表示为 present、`.` 和 `?`。解析器严格检查 UTF-8、字节范围、数组长度、整数打包值域、字符串 offsets、MessagePack 嵌套深度及尾随数据。 @@ -3254,6 +3349,74 @@ component 坐标使用 zero-based half-open forward genomic axis；负链 MAF st 严格校验覆盖3-12列、非负32位整数、有限score、strand、thick interval、block count/list长度、正size、首尾span、排序/重叠/越界、坐标单调性、零长度segment和aligned step等长。writer可从一般target/query path生成canonical blocks，并按 `bed_columns` 输出 BED3-BED12；query-only segment按BED可表达能力被投影跳过，反向target path先规范化。该层处理文本pairwise alignment，`bigbed.mbt` 继续独立处理压缩二进制存储和索引。 +### 276. 差异空间细胞共定位分析 (Bioconductor spicyR) + +实现 Bioconductor `spicyR` 1.25.0 的图像级差异空间共定位核心。每张图像对有序细胞类型对计算 cross-K/cross-L 曲线，排除细胞自身匹配并保留上游同型对 `n²` intensity normalization；半径限制在最短窗口跨度约一半并折叠重复截断值。图像统计量按上游语义累加 `sum(L(r)-r)`，缺失类型对可省略或用 Poisson 基线补齐，单个同型细胞保留为可用基线。 + +坐标窗口由每张图像的范围和可选 padding 构造；边界校正使用以源细胞为圆心的可见圆面积倒数，因此有方向性。矩形与圆的交面积通过固定 96 分片 Simpson 积分确定性求解。图像 precision weights 由同型 `n(n-1)` 或异型 harmonic effective count 构造、归一化至均值一并应用 `weight_factor`；这是不依赖 R/scam 的可移植近似，不复刻上游 GAM 平滑。 + +无重复受试者时拟合加权线性模型，有重复受试者时复用 `variancePartition` 的 ML/REML 随机截距模型、数值 Satterthwaite 自由度和 Student-t 检验；支持数值协变量、多条件相对参考组对比及跨细胞类型对 BH-FDR。API 可直接分析细胞坐标、拟合预计算 association，或从 `SpatialExperiment` 的 `colData`/`spatialCoords` 提取输入并在不可变副本 metadata 中写回结果；另提供 pair/condition/image 查询、排序、显著性过滤、摘要和合成重复测量数据。 + +### 277. 局部空间关联曲线与组织区域聚类 (Bioconductor lisaClust) + +实现 Bioconductor `lisaClust` 1.21.0 的局部空间统计与区域发现核心。模块按图像独立处理每个源细胞，对所有目标细胞类型和半径累积排除自身匹配的局部邻居；目标类型强度为 `n/area`，期望值为 `πr² × visible_fraction × intensity`。标准化 local-K 输出 `(observed-expected)/sqrt(expected)`，centered local-L 输出 `sqrt(observed)-sqrt(expected)`，并通过 Gaussian KDE 的均值归一化逆密度权重校正不均匀采样，支持密度下限、有限值归零和按窗口短边约 `1/2.01` 截断半径。 + +空间窗口支持带 padding 的矩形和 monotonic-chain 凸包；圆盘位于凸窗口内的可见面积使用固定角度中点积分确定性计算。完整 cell × cell-type × radius 曲线矩阵进入确定性多起点 k-means，采用 farthest-first 初始化、空簇恢复和稳定标签规范化，同时输出 inertia、silhouette、cluster sizes、centroids 和收敛诊断。区域富集按 `observed / (cell_type_total × region_total / N)` 计算，并提供细胞区域查询、富集检索/排名、区域摘要及预计算曲线聚类入口。 + +`lisaclust_spatial_experiment` 从 `colData` 与 `spatialCoords` 提取图像、细胞类型和可选 cell ID，在深复制的 `SpatialExperiment` 中写入区域列及细胞数、特征数、区域数和 silhouette metadata，原容器保持不变。可移植实现不支持上游 concave window；KDE 在细胞位置直接计算而非复刻 `spatstat::density.ppp` 像素栅格；圆盘相交面积使用角度积分近似；不同图像截断后的 effective radii 单独记录，但保留用户请求半径对应的统一特征列。 + +### 278. 背景感知空间混合细胞解卷积 (Bioconductor SpatialDecon) + +实现 Bioconductor `SpatialDecon` 1.23.0 的核心混合细胞解卷积流程。输入为 gene × spot 表达矩阵、同维背景与 precision-weight 矩阵，以及 gene × cell-type profile；数据和 profile 按基因名对齐，并要求共享基因数不少于细胞类型数。profile 可按全矩阵指定分位数缩放至目标值，默认复刻上游 `2 / Q0.99(X)` 尺度。每个 spot 拟合非负丰度 `β`，最小化 `Σ wᵢ(log(yᵢ)-log(bᵢ+max(Xᵢβ,10⁻⁴)))²`，因此直接建模加性技术背景上的 log-normal 生物信号。 + +优化器使用确定性投影阻尼 Newton、partial-pivot Gaussian elimination 和 backtracking line search；observed Hessian 非正定、奇异或不产生下降方向时，回退到 expected-Hessian 缩放梯度。两阶段流程先拟合全部基因，再以 `log2(max(y,lower))-log2(max(fitted,lower))` 标记超过阈值的数据点并重拟合；保留数据不足以识别模型时自动取消剔除。协方差优先取带 ridge 的 observed Hessian 逆，在无效时回退 expected Hessian，由此输出标准误、t 统计量和正态近似双侧 p 值。 + +结果同时提供 abundance、spot 内 proportion、按最大 spot 总丰度归一化的 cells-per-100，以及结合 nuclei count 的细胞数尺度，并记录 fitted、log2 residual、outlier mask、RMSE、相关性、目标值和收敛诊断。`collapse_spatial_decon` 通过 `β'=Aβ` 与 `Σ'=AΣAᵀ` 合并细胞类型；`reverse_spatial_decon` 对每个 gene 拟合非负 intercept 与变化 cell scores；辅助 API 可按 probe pool 平均负探针推导 GeoMx 背景，也可从单细胞 count matrix 经细胞/基因过滤、可选 library normalization 和 cell-type 均值构建 profile。 + +`spatial_decon_spatial_experiment` 从 assay、rowData 和 colData 提取输入，在深复制容器的 colData 中写入 abundance/proportion，并保留原对象不变。MoonBit 版本以确定性投影 Newton 代替 R `optim(method="L-BFGS-B")`；不在线下载上游约 75 个 profile matrix，不内置 `safeTME` 数据，也不包含 pure-tumor profile 推断和 tumor clustering。不同 row 维度的细胞丰度不会作为 assay 写入，而以 spot 级 colData 字段保存。 + +### 279. 通用单细胞聚类与诊断 (Bioconductor bluster) + +实现 Bioconductor `bluster` 1.23.0 的通用聚类、图构建与诊断核心，矩阵统一采用 observation × variable 方向。精确近邻支持 Euclidean、Manhattan 和 cosine 距离，排除自身、按观察索引稳定处理距离 ties，并在 `k > n-1` 时截断。KNN 图可保持有向关系或对任一方向近邻边进行对称化；SNN 图把自身作为 rank 0 邻居，支持上游 rank 权重 `max(k-(rᵢ+rⱼ)/2,10⁻⁶)`、共享邻居数和 Jaccard 权重。 + +K-means 使用 K-means++ 初始化、多起点 Lloyd 迭代、空簇恢复和固定 seed 的 Park-Miller RNG，返回质心、逐簇/总 within-cluster sum of squares 与迭代诊断。图聚类使用无需 R、igraph 或 C++ 的 seed 可复现 Louvain 风格局部 modularity 优化，并支持 resolution；two-step 流程先以 K-means 向量量化观察，默认使用 `round(sqrt(n))` 个质心，再在质心 SNN 图上聚类并将标签映射回原观察。 + +诊断 API 覆盖 pairwise Rand 分解与 adjusted Rand index、RMS distance 的 approximate silhouette、cluster RMSD、以第 k 邻居距离中位数为半径的 neighbor purity、pairwise modularity、贪心 community merging、nested cluster mapping、minimum/maximum/union cluster correspondence，以及 bootstrap K-means stability。`bluster_cluster_sce` 从 `SingleCellExperiment.reduced_dims` 读取 cell × dimension 坐标，深复制 assays、row/column metadata、reduced dimensions、metadata 和 alternative experiments 后写入聚类标签，输入对象保持不变。当前实现使用稠密精确近邻和串行局部优化，不覆盖上游 BiocNeighbors 近似索引、igraph/cluster_leiden 后端或 BiocParallel 调度。 + +### 280. 拓扑自组织映射与meta-clustering (Bioconductor FlowSOM) + +实现 Bioconductor `FlowSOM` 2.21.0 的拓扑聚类核心，输入统一为 cell × marker。距离支持 Manhattan、Euclidean、Chebyshev 和 cosine，并定义零向量的稳定 cosine 语义；码本可由无放回 random、最远点迭代 KWSP 或 covariance/power-iteration PCA 网格初始化。训练从二维规则网格的 Chebyshev 邻域开始，按 stage 线性衰减学习率与半径，每个 stage 后以码本 Euclidean 距离构造确定性 Prim MST，并用无权最短路径重建下一阶段邻域。固定 seed 的 Park-Miller RNG 保证初始化、抽样和训练可复现。 + +训练结果包含 BMU 与距离、完整 MST、拓扑距离、quantization/topographic error，以及基于原始未加权 marker 值的节点 counts、percentages、median fluorescence intensity、sample SD、CV 和 R 风格 `1.4826 × MAD`。meta-clustering 复用 `bluster` 多起点 K-means；自动模式平滑不同 k 的 within-cluster SSE，并以双线性拟合残差选择 elbow。辅助 API 覆盖新数据投影、节点距离 MAD outlier、marker 级双侧 outlier、节点阳性比例、meta counts/medians、weighted/unweighted purity 和 F-measure。 + +`flowsom_train_flow_frame` 保持 flowCore event × marker 方向并支持 marker 子集；`flowsom_cluster_sce` 将 SingleCellExperiment 的 marker × cell assay 转置后训练，在递归深复制的容器中写入 1-based `FlowSOM.cluster` 和 `FlowSOM.metacluster`，不修改输入对象。实现不依赖 R、C/C++、igraph 或 ConsensusClusterPlus；当前采用稠密矩阵、串行在线更新和 K-means meta-clustering，不覆盖上游并行后端、共识聚类插件及可视化层。 + +### 281. 约束谱系与同时主曲线 (Bioconductor slingshot) + +实现 Bioconductor `slingshot` 2.21.0 的高级轨迹推断核心，坐标统一为 cell × dimension，并保留原 `slingshot.mbt` 兼容API。输入支持hard cluster label和逐行归一化的soft membership；cluster摘要支持weighted mean/median、有效样本分母协方差和ridge稳定化，cluster距离支持质心Euclidean、pooled diagonal缩放及full Mahalanobis，并在矩阵不可逆时回退到diagonal。 + +谱系推断使用稳定排序的确定性Kruskal，支持start cluster、end cluster叶节点约束、固定`omega`阈值和基于无限制MST边长中位数的自动`omega` forest。每个connected component独立选择root并枚举root-to-leaf lineage。曲线可使用none、line或endpoint cluster PC1扩展，通过arc-length重采样、折线投影和Gaussian-kernel local-linear smoother迭代拟合；cell × lineage距离秩用于`1-rank²`重加权和重新分配，共享cluster前缀使用cosine taper同时收缩。 + +结果提供cell × lineage Optional pseudotime、weights、平均pseudotime、1-based branch ID及收敛诊断。`slingshot_predict`将新cell投影到已拟合曲线并按训练距离90%分位数衰减权重；`slingshot_advanced_sce`递归深复制SingleCellExperiment及alternative experiments，再写入branch、pseudotime和weight字段，输入对象保持不变。当前实现采用稠密矩阵与串行平滑，不覆盖上游S4/PseudotimeOrdering容器、BiocParallel后端和可视化层。 + +### 282. 多谱系轨迹差异表达 (Bioconductor tradeSeq) + +实现 Bioconductor `tradeSeq` 1.27.0 的高级轨迹差异表达核心，并保留 `tradeseq.mbt` 的基础兼容API。输入遵循上游 gene × cell非负整数计数、cell × lineage pseudotime和weight方向；每个cell的lineage weight逐行归一化，正权重对应的拟时间必须有限且每条lineage必须覆盖非零范围。默认offset由文库大小的中心化log值生成，也可显式传入。上游随机cell-to-lineage分配被替换为确定性weighted expansion，使每个cell对所有活跃lineage的总贡献严格为1。 + +每条lineage使用独立open-uniform B-spline coefficient block，degree为`min(3, nKnots-1)`；联合负二项IRLS使用`Var(Y)=mu+phi*mu^2`，并加入二阶差分平滑惩罚与ridge稳定化。dispersion通过Pearson moment迭代更新并按配置截断；最终模型保留系数、penalized information逆矩阵协方差、gene × cell拟合值、NB log-likelihood、AIC、迭代次数及收敛状态。`tradeseq_evaluate_k_advanced`对候选knot数逐一重拟合，返回gene × candidate AIC及mean-AIC选择结果。 + +Wald contrast引擎通过Gram-Schmidt去除线性相关行，提供`associationTest`、`startVsEndTest`、`diffEndTest`、`patternTest`和`earlyDETest`，并统一支持log2 fold-change阈值、chi-square tail probability与gene-level BH-FDR。平滑预测返回各lineage原始拟时间网格、均值和delta-method标准误；`tradeseq_fit_from_slingshot`直接消费Slingshot Optional pseudotime/weight，`tradeseq_advanced_sce`递归深复制SingleCellExperiment及alternative experiments后写回拟合assay、检验p值/FDR、dispersion和metadata。当前实现采用稠密串行线性代数，不依赖R、mgcv、edgeR或BiocParallel，也不覆盖上游零膨胀模型和可视化层。 + +### 283. 多样本多亚群差异状态与检测 (Bioconductor muscat) + +实现 Bioconductor `muscat` 1.27.4 的高级多样本、多亚群分析核心，并保留 `muscat.mbt` 的基础兼容API。输入严格采用 gene × cell非负整数计数，验证sample、cluster和group元数据长度、非空ID、样本到组的一对一关系，以及gene/cell名称的数量和唯一性。cluster × sample伪批量支持sum、mean、median、proportion detected和number detected五类聚合；缺失组合补零，并同时保留cell count与library size。 + +设计层支持与伪批量样本顺序完全一致的任意有限满秩矩阵、默认reference-coded group design及多个contrast。差异状态（DS）模型使用cluster-sample library-size offset、负二项IRLS和gene-wise Pearson dispersion，并向cluster内median trend执行经验贝叶斯收缩。Wald检验支持log2 fold-change阈值；结果同时提供每个cluster/contrast内的local BH-FDR和每个contrast跨cluster的global BH-FDR。 + +差异检测（DD）遵循上游CDR归一化语义：先过滤median detection fraction达到阈值的普遍检测基因，再使用`log(nCells × mean detection fraction)` offset拟合检测计数。DS与DD结果可通过harmonic-mean screening和两假设confirmation组合为`DS`、`DD`、`both`、`screen_only`或`none`。`muscat_advanced_sce`从SingleCellExperiment读取assay和cell metadata，递归深复制assay、row/col data、reduced dimensions、metadata及alternative experiments后写回cluster级logFC、FDR和stagewise分类，不修改输入对象。 + +当前实现是无外部依赖的MoonBit NB-Wald流程，不调用或宣称复刻edgeR、DESeq2、limma、MAST及stageR的R后端；采用稠密串行线性代数，也不覆盖上游并行、随机效应模型和可视化层。 + ## 性能优化 ### 优化策略 @@ -3355,8 +3518,8 @@ component 坐标使用 zero-based half-open forward genomic axis；负链 MAF st | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 10852 | -| 通过数 | 10852 | +| 总测试数 | 11572 | +| 通过数 | 11572 | | 失败数 | 0 | | 通过率 | 100% | @@ -3492,9 +3655,13 @@ moon test --update | AnnotationHub | `annotation_hub_test.mbt` | 8 | | GenomicFeatures | `genomic_features_test.mbt` | 6 | | graph | `graph_test.mbt` | 8 | -| DropletUtils | `droplet_utils_test.mbt` | 6 | +| DropletUtils兼容层 | `droplet_utils_test.mbt` | 7 | +| Bioconductor DropletUtils高级流程 | `droplet_utils_advanced_test.mbt` | 58 | | scran | `scran_test.mbt` | 8 | | scrapper | `scrapper_test.mbt` | 35 | +| Bioconductor scuttle | `scuttle_test.mbt` | 64 | +| Bioconductor bluster | `bluster_test.mbt` | 58 | +| Bioconductor FlowSOM | `flowsom_test.mbt` | 66 | | decontX | `decontx_test.mbt` | 43 | | celda_CG | `celda_test.mbt` | 75 | | miloR | `milo_test.mbt` | 37 | @@ -3505,7 +3672,10 @@ moon test --update | monocle3 | `monocle3_test.mbt` | 10 | | ShortRead | `short_read_test.mbt` | 15 | | scater | `scater_test.mbt` | 17 | -| MAST | `mast_test.mbt` | 12 | +| MAST兼容层 | `mast_test.mbt` | 12 | +| Bioconductor MAST高级流程 | `mast_advanced_test.mbt` | 42 | +| SingleR兼容层 | `single_r_test.mbt` | 26 | +| Bioconductor SingleR高级流程 | `single_r_advanced_test.mbt` | 54 | | GenomicFiles | `genomic_files_test.mbt` | 28 | | DiffBind | `diffbind_test.mbt` | 36 | | minfi | `minfi_test.mbt` | 40 | @@ -3518,7 +3688,8 @@ moon test --update | ChromVAR | `chromvar_test.mbt` | 12 | | DelayedArray | `delayed_array_test.mbt` | 10 | | AnnotationFilter | `annotation_filter_test.mbt` | 10 | -| scDblFinder | `sc_dbl_finder_test.mbt` | 8 | +| scDblFinder兼容层 | `sc_dbl_finder_test.mbt` | 8 | +| Bioconductor scDblFinder高级流程 | `sc_dbl_finder_advanced_test.mbt` | 65 | | ChIPseeker | `chipseeker_test.mbt` | 14 | | Taxonomy | `taxonomy_test.mbt` | 7 | | GFF | `gff_test.mbt` | 5 | @@ -3531,6 +3702,8 @@ moon test --update | uwot | `uwot_test.mbt` | 9 | | microbiome | `microbiome_test.mbt` | 33 | | tradeSeq | `tradeseq_test.mbt` | 12 | +| Bioconductor tradeSeq高级流程 | `tradeseq_advanced_test.mbt` | 44 | +| Bioconductor muscat高级流程 | `muscat_advanced_test.mbt` | 62 | | QCP叠加 | `qcp_superimposer_test.mbt` | 8 | | CEAligner | `cealign_test.mbt` | 35 | | 残基深度 | `residue_depth_test.mbt` | 10 | @@ -3552,6 +3725,7 @@ moon test --update | SFF_IO | `sff_io_test.mbt` | 16 | | csaw | `csaw_test.mbt` | 9 | | slingshot | `slingshot_test.mbt` | 10 | +| slingshot高级流程 | `slingshot_advanced_test.mbt` | 57 | | SCnorm | `scnorm_test.mbt` | 8 | | EDASeq | `edaseq_test.mbt` | 10 | | SearchIO新 | `searchio_new_test.mbt` | 30 | @@ -3684,6 +3858,9 @@ moon test --update | Bioconductor dreamlet | `dreamlet_test.mbt` | 58 | | Bioconductor nnSVG | `nnsvg_test.mbt` | 67 | | Bioconductor Banksy | `banksy_test.mbt` | 78 | +| Bioconductor spicyR | `spicyr_test.mbt` | 39 | +| Bioconductor lisaClust | `lisaclust_test.mbt` | 51 | +| Bioconductor SpatialDecon | `spatialdecon_test.mbt` | 60 | | Bio.PopGen.GenePop | `gene_pop_test.mbt` | 34 | | Bioconductor stageR | `stage_r_test.mbt` | 25 | | Bioconductor EnrichedHeatmap | `enriched_heatmap_test.mbt` | 20 | @@ -3779,7 +3956,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 383 个示例程序，展示各模块的典型用法： +项目提供 388 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3870,6 +4047,13 @@ moon run cmd/bench/main.mbt | short_read_demo | ShortRead 短读序列质量控制（QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告生成） | `moon run examples/short_read_demo/main.mbt` | | scater_demo | scater 单细胞质量控制（QC指标计算、细胞/基因过滤、CPM/log-CPM标准化、HVG检测、PCA降维） | `moon run examples/scater_demo/main.mbt` | | scrapper_demo | 批次感知RNA QC、大小因子归一化、LOWESS/HVG、多因子pseudo-bulk和不可变SCE集成 | `moon run examples/scrapper_demo` | +| scuttle_demo | batch-aware MAD异常值、subset per-feature QC、重叠feature-set聚合、精确batch coverage等化和不可变SCE写回 | `moon run examples/scuttle_demo` | +| bluster_demo | 多起点K-means、SNN图、Louvain风格聚类、two-step、ARI/silhouette/purity/RMSD、bootstrap稳定性和不可变SCE写回 | `moon run examples/bluster_demo` | +| flowsom_demo | 规则网格与MST拓扑SOM、meta-clustering、节点MFI/CV/阳性率、MAD outlier、新数据映射及FlowFrame/SCE写回 | `moon run examples/flowsom_demo` | +| slingshot_advanced_demo | Y型轨迹、start/end约束MST、同时主曲线、pseudotime/branch weights、新数据投影及不可变SCE写回 | `moon run examples/slingshot_advanced_demo` | +| tradeseq_advanced_demo | 多lineage负二项GAM、五类Wald检验、平滑预测、AIC knot评估、Slingshot直连及不可变SCE写回 | `moon run examples/tradeseq_advanced_demo` | +| muscat_advanced_demo | cluster-sample伪批量、任意设计、NB-IRLS DS、CDR归一化DD、两阶段确认及不可变SCE写回 | `moon run examples/muscat_advanced_demo` | +| droplet_utils_demo | Simple Good-Turing ambient profile、alpha估计、barcode-rank knee/inflection、Dirichlet-multinomial emptyDrops、细胞过滤及不可变SCE写回 | `moon run examples/droplet_utils_demo` | | decontx_demo | cluster/background ambient RNA去污染、每细胞污染率、marker校正、cluster诊断和不可变SCE输出 | `moon run examples/decontx_demo` | | celda_demo | `celda_CG`细胞群/基因模块联合聚类、top markers、新细胞预测、BIC模型选择和不可变SCE输出 | `moon run examples/celda_demo` | | milo_demo | 精确KNN图、精炼重叠邻域、样本计数、NB-GLM差异丰度、graph spatial FDR和SCE接入 | `moon run examples/milo_demo` | @@ -3877,7 +4061,8 @@ moon run cmd/bench/main.mbt | apeglm_demo | NB-GLM MLE与自适应重尾MAP、FSR/s-value/FSOS、log2 TSV及不可变SummarizedExperiment输出 | `moon run examples/apeglm_demo` | | aldex2_demo | Dirichlet Monte Carlo、IQLR、posterior expected eBH、effect/overlap、Aitchison距离及不可变SummarizedExperiment输出 | `moon run examples/aldex2_demo` | | dirichlet_multinomial_demo | Dirichlet-multinomial混合聚类、Laplace选K、分组分类、分层交叉验证、ROC与SummarizedExperiment转置入口 | `moon run examples/dirichlet_multinomial_demo` | -| mast_demo | MAST 单细胞差异表达分析（Hurdle模型、离散/连续检验、BH-FDR校正、结果汇总） | `moon run examples/mast_demo/main.mbt` | +| mast_demo | MAST 1.39.0任意设计/CDR、Bayesian logistic与Gaussian hurdle GLM、嵌套LRT、eBayes、边际logFC和不可变SCE写回 | `moon run examples/mast_demo` | +| single_r_demo | SingleR 2.15.2成对classic markers、标签内相关分位数、fine-tuning/MAD剪枝、cluster、多参考重算和不可变SCE写回 | `moon run examples/single_r_demo` | | genomic_files_demo | GenomicFiles 分布式基因组文件处理（BAM/BED/VCF扫描、区间查询、归约、覆盖度计算） | `moon run examples/genomic_files_demo/main.mbt` | | diffbind_demo | DiffBind ChIP-seq差异结合分析（峰值重叠、共识峰识别、TMM归一化、负二项分布检验） | `moon run examples/diffbind_demo/main.mbt` | | minfi_demo | minfi DNA甲基化分析（NOOB/Illumina/分位数/功能归一化、β/M值计算、DMP/DMR分析） | `moon run examples/minfi_demo/main.mbt` | @@ -3891,7 +4076,7 @@ moon run cmd/bench/main.mbt | chromvar_demo | ChromVAR 染色质变异分析（TF motif富集、GC偏差校正、细胞聚类、变异性分析、偏差图） | `moon run examples/chromvar_demo/main.mbt` | | delayed_array_demo | DelayedArray 延迟计算数组（懒加载操作、分块处理、行/列聚合、转置、子集操作） | `moon run examples/delayed_array_demo/main.mbt` | | annotation_filter_demo | AnnotationFilter 基因注释过滤（染色体筛选、生物类型过滤、链过滤、区域重叠检测、符号模式匹配） | `moon run examples/annotation_filter_demo/main.mbt` | -| sc_dbl_finder_demo | scDblFinder 单细胞双细胞检测（Doublet评分计算、最近邻搜索、双细胞检测、PCA降维、细胞过滤） | `moon run examples/sc_dbl_finder_demo/main.mbt` | +| sc_dbl_finder_demo | scDblFinder 1.27.6高级流程（capture分层、已知doublet训练、人工doublet、kNN/cxds特征、迭代分类、来源富集、自动聚类、singlet过滤与SingleCellExperiment写回） | `moon run examples/sc_dbl_finder_demo/main.mbt` | | chipseeker_demo | ChIPseeker ChIP-seq峰值注释（基因组区域分类(启动子/外显子/内含子/UTR/基因间区)、距离TSS分布、BED格式读取、peak2gene关联分析、多峰值集重叠分析、Venn图、饼图可视化、统计分析） | `moon run examples/chipseeker_demo/main.mbt` | | taxonomy_demo | Taxonomy 分类学分析（分类数据库创建、谱系查询、共同祖先计算、分类单元管理） | `moon run examples/taxonomy_demo/main.mbt` | | gff_demo | GFF GFF3格式解析（基因注释特征提取、属性解析、基因/转录本/CDS/外显子结构分析） | `moon run examples/gff_demo/main.mbt` | @@ -3974,6 +4159,9 @@ moon run cmd/bench/main.mbt | dreamlet_demo | SingleCellExperiment pseudobulk、TMM/logCPM、Poisson/voom权重、donor随机截距和跨cell-type FDR | `moon run examples/dreamlet_demo` | | nnsvg_demo | nearest-neighbor GP空间变异基因检验、length scale、空间方差占比、基因过滤与SpatialExperiment接入 | `moon run examples/nnsvg_demo` | | banksy_demo | H0/H1空间邻域特征、cell-typing/domain lambda、PCA聚类、标签平滑、参数扫描与SpatialExperiment接入 | `moon run examples/banksy_demo` | +| spicyr_demo | 有序细胞类型对cross-L、矩形窗口边界校正、precision weights、重复受试者模型、条件对比与SpatialExperiment接入 | `moon run examples/spicyr_demo` | +| lisaclust_demo | 每细胞local-K/L曲线、KDE与边界校正、确定性区域聚类、silhouette、observed/expected富集及SpatialExperiment写回 | `moon run examples/lisaclust_demo` | +| spatialdecon_demo | 背景感知log-normal解卷积、丰度/比例/计数、cell-type collapse、reverse deconvolution、负探针背景、单细胞profile与SpatialExperiment写回 | `moon run examples/spatialdecon_demo` | | shared_reference_alignment_demo | 共享参考PWA/MSA合并、reference insertion同步、坐标映射、统计、MSA与aligned FASTA转换 | `moon run examples/shared_reference_alignment_demo` | | alignment_map_demo | chromosome→transcript→read坐标组合、intron gap、反链、坐标查询、PSL与protein-to-codon MSA投影 | `moon run examples/alignment_map_demo` | | alignment_counts_demo | left/internal/right gap与open/extend、affine/BLOSUM45评分、反向链和MSA逐对汇总 | `moon run examples/alignment_counts_demo` | @@ -4092,6 +4280,12 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bioconductor SparseArray N维稀疏数组（规范化COO、R列主序、切片/置换/绑定、稀疏算术、统计与矩阵乘法） - ✅ 实现 Bio.PDB.cealign CE组合扩展结构比对（CA/C4'引导原子、AFP路径、CE Z-score、QCP叠合、局部优化与全原子变换） - ✅ 实现 Bioconductor scrapper 单细胞预处理（批次感知RNA QC、大小因子与log-normalization、LOWESS/HVG、多因子pseudo-bulk、不可变SCE集成） +- ✅ 实现 Bioconductor scuttle 1.23.1基础工具（batch-aware MAD异常值、subset per-feature QC、重叠feature-set聚合、精确count/batch downsampling及不可变SCE集成） +- ✅ 实现 Bioconductor bluster 1.23.0通用聚类（K-means++、KNN/SNN图、Louvain风格优化、two-step、聚类诊断、bootstrap稳定性与SingleCellExperiment接入） +- ✅ 实现 Bioconductor FlowSOM 2.21.0拓扑自组织映射（KWSP/PCA、规则网格、多阶段MST、meta-clustering、节点统计、MAD outlier及FlowFrame/SingleCellExperiment接入） +- ✅ 实现 Bioconductor slingshot 2.21.0高级轨迹推断（soft membership、约束MST/omega forest、同时主曲线、重加权/重分配、预测及SingleCellExperiment接入） +- ✅ 实现 Bioconductor tradeSeq 1.27.0高级轨迹差异表达（确定性lineage权重、多lineage惩罚NB-GAM、dispersion/AIC/协方差、五类Wald检验、平滑预测、knot选择、Slingshot及SingleCellExperiment接入） +- ✅ 实现 Bioconductor muscat 1.27.4高级多样本多亚群分析（五类cluster-sample伪批量、任意设计/多contrast、NB-IRLS DS、CDR归一化DD、local/global FDR、两阶段确认及SingleCellExperiment接入） - ✅ 实现 Bio.PDB.binary_cif BinaryCIF解析（MessagePack、七类逆编码、三态mask、类别查询与PDB Structure转换） - ✅ 实现 Bioconductor miloR 单细胞邻域差异丰度（精确KNN图、median精炼采样、邻域计数、固定效应NB-GLM、graph spatial FDR与SCE接入） - ✅ 实现 Bio.SearchIO.InfernalIO Infernal cmscan/cmsearch输出解析（tabular 1/2/3、non-verbose文本、--noali、CM/HMM-only、local-end多片段与SearchIO转换） @@ -4123,6 +4317,10 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bioconductor DirichletMultinomial 混合聚类与分类（DMM概率、soft k-means、log-alpha BFGS/EM、Gamma prior、Laplace/AIC/BIC、dmngroup分类、分层CV、ROC与SummarizedExperiment接入） - ✅ 实现 Bioconductor nnSVG 空间变异基因检测（坐标缩放与前驱kNN、指数协方差NNGP、covariate GLS、gene-specific length scale、空间/非空间LR检验、BH-FDR与SpatialExperiment接入） - ✅ 实现 Bioconductor Banksy 空间邻域增强聚类（六类空间核、H0/H1+、lambda联合矩阵、分组标准化、PCA、多起点k-means、标签平滑、参数扫描与SpatialExperiment接入） +- ✅ 实现 Bioconductor spicyR 差异空间细胞共定位分析（有序细胞类型对cross-L、矩形边界校正、图像级统计、precision weights、加权/随机截距模型、多条件对比、BH-FDR与SpatialExperiment接入） +- ✅ 实现 Bioconductor lisaClust 局部空间区域发现（多细胞类型local-K/L、Gaussian KDE强度校正、矩形/凸包窗口、圆盘边界积分、确定性多起点k-means、silhouette、区域富集与SpatialExperiment写回） +- ✅ 实现 Bioconductor SpatialDecon 背景感知空间解卷积（加权log-normal非负回归、异常点重拟合、Hessian不确定度、丰度/计数尺度、cell-type collapse、reverse deconvolution、负探针背景、单细胞profile与SpatialExperiment写回） +- ✅ 实现 Bioconductor DropletUtils 1.33.0高级emptyDrops（Simple Good-Turing ambient profile、barcode-rank knee/inflection、multinomial/Dirichlet-multinomial、alpha MLE、确定性Monte Carlo、Phipson–Smyth p值、BH-FDR、高计数保留与SingleCellExperiment写回） - ✅ 实现 FGSEA 快速基因集富集分析（基因排名、富集分数、NES、p值、Leading Edge基因、BH校正） - ✅ 实现 SVA 替代变量分析与ComBat批次校正（经验贝叶斯方法、PCA分析、批次效应去除） - ✅ 实现 Ballgown 转录组水平差异表达分析（FPKM计算、t检验、转录本/基因水平DE分析） @@ -4135,7 +4333,8 @@ moon run cmd/bench/main.mbt - ✅ 实现 AnnotationDbi注释数据库、clusterProfiler富集框架、WGCNA共表达网络 - ✅ 实现 ShortRead 短读序列质量控制（QA统计、adapter修剪、质量修剪、读长过滤、FastQC报告生成） - ✅ 实现 scater 单细胞质量控制（QC指标计算、细胞/基因过滤、CPM/log-CPM标准化、HVG检测、PCA降维） -- ✅ 实现 MAST 单细胞差异表达分析（Hurdle模型、离散/连续检验、BH-FDR校正、结果汇总） +- ✅ 实现 Bioconductor MAST 1.39.0高级单细胞差异表达（任意设计/CDR、Bayesian logistic与Gaussian hurdle GLM、嵌套LRT、H0/H1 eBayes、NA/FDR、边际logFC及SingleCellExperiment写回） +- ✅ 实现 Bioconductor SingleR 2.15.2高级参考注释（严格基因对齐、成对classic markers、标签内相关分位数、迭代fine-tuning、delta/MAD剪枝、cluster、多参考重算及SingleCellExperiment写回） - ✅ 实现 GenomicFiles 分布式基因组文件处理（BAM/BED/VCF扫描、区间查询、归约、覆盖度计算） - ✅ 实现 DiffBind ChIP-seq差异结合分析（峰值重叠、共识峰识别、TMM归一化、负二项分布检验） - ✅ 实现 minfi DNA甲基化分析（NOOB/Illumina/分位数/功能归一化、β/M值计算、DMP/DMR分析） @@ -4147,7 +4346,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 ChromVAR 染色质变异分析（TF motif富集、GC偏差校正、细胞聚类、变异性分析、偏差图） - ✅ 实现 DelayedArray 延迟计算数组（懒加载操作、分块处理、行/列聚合、转置、子集操作） - ✅ 实现 AnnotationFilter 基因注释过滤（染色体筛选、生物类型过滤、链过滤、区域重叠检测、符号模式匹配） -- ✅ 实现 scDblFinder 单细胞双细胞检测（Doublet评分计算、最近邻搜索、双细胞检测、PCA降维、细胞过滤） +- ✅ 实现 Bioconductor scDblFinder 1.27.6高级双细胞检测（人工doublet、共同归一化/PCA、精确kNN与cxds特征、迭代正则化分类、capture分层阈值、homotypic修正、来源富集及SingleCellExperiment写回） - ✅ 实现 ChIPseeker ChIP-seq峰值注释（基因组区域分类、距离TSS分布、注释可视化、统计分析） - ✅ 实现 DESeq2 差异表达分析（size factors归一化、分散度估计、负二项GLM拟合、Wald检验、LFC收缩） - ✅ 实现 ChIPseeker峰注释、DOSE疾病富集、ReactomePA通路分析 diff --git a/examples/bluster_demo/main.mbt b/examples/bluster_demo/main.mbt new file mode 100644 index 00000000..86d16393 --- /dev/null +++ b/examples/bluster_demo/main.mbt @@ -0,0 +1,160 @@ +///| +fn bluster_demo_ints(values : Array[Int]) -> String { + values.map(fn(value) { value.to_string() }).join(", ") +} + +///| +fn bluster_demo_doubles(values : Array[Double]) -> String { + values.map(fn(value) { value.to_string() }).join(", ") +} + +///| +fn bluster_demo_optional(value : Double?) -> String { + match value { + Some(actual) => actual.to_string() + None => "NA" + } +} + +///| +fn main { + println("=== Bioconductor bluster 1.23.0 Demo ===") + + let coordinates = [ + [0.0, 0.0], + [0.1, 0.0], + [0.2, 0.1], + [0.3, 0.1], + [10.0, 10.0], + [10.1, 10.0], + [10.2, 10.1], + [10.3, 10.1], + ] + + let kmeans_config = @bio.BlusterKmeansConfig::create(2, starts=8, seed=101) catch { + _ => abort("failed to create the k-means configuration") + } + let kmeans = @bio.bluster_cluster_rows_kmeans(coordinates, kmeans_config) catch { + _ => abort("k-means clustering failed") + } + println("\n1. Deterministic multi-start K-means") + println(" clusters: " + bluster_demo_ints(kmeans.clusters)) + println( + " total within sum of squares: " + + kmeans.total_within_sum_squares.to_string(), + ) + + let graph = @bio.bluster_make_snn_graph( + coordinates, + k=2, + weighting=@bio.bluster_rank_weight(), + ) catch { + _ => abort("SNN graph construction failed") + } + let graph_config = @bio.BlusterGraphConfig::create( + k=2, + resolution=0.5, + seed=103, + ) catch { + _ => abort("failed to create the graph configuration") + } + let graph_clusters = @bio.bluster_cluster_rows_graph( + coordinates, graph_config, + ) catch { + _ => abort("graph clustering failed") + } + println("\n2. Exact SNN graph and Louvain-style optimization") + println(" graph edges: " + graph.edge_count().to_string()) + println(" clusters: " + bluster_demo_ints(graph_clusters.clusters)) + println(" modularity: " + graph_clusters.modularity.to_string()) + + let two_step_config = @bio.BlusterTwoStepConfig::create( + first_centers=4, + first_starts=5, + second_k=1, + resolution=0.5, + seed=107, + ) catch { + _ => abort("failed to create the two-step configuration") + } + let two_step = @bio.bluster_cluster_rows_two_step( + coordinates, two_step_config, + ) catch { + _ => abort("two-step clustering failed") + } + println("\n3. Two-step vector quantization") + println(" centroids: " + two_step.centroids.length().to_string()) + println(" clusters: " + bluster_demo_ints(two_step.clusters)) + + let rand = @bio.bluster_pairwise_rand( + kmeans.clusters, + graph_clusters.clusters, + ) catch { + _ => abort("Rand comparison failed") + } + let silhouette = @bio.bluster_approx_silhouette( + coordinates, + graph_clusters.clusters, + ) catch { + _ => abort("silhouette approximation failed") + } + let purity = @bio.bluster_neighbor_purity( + coordinates, + graph_clusters.clusters, + k=2, + ) catch { + _ => abort("neighbor purity failed") + } + let rmsd = @bio.bluster_cluster_rmsd(coordinates, graph_clusters.clusters) catch { + _ => abort("cluster RMSD failed") + } + println("\n4. Cluster diagnostics") + println(" adjusted Rand index: " + bluster_demo_optional(rand.index)) + println(" silhouette widths: " + bluster_demo_doubles(silhouette.widths)) + println(" neighbor purities: " + bluster_demo_doubles(purity.purity)) + println(" first cluster RMSD: " + bluster_demo_optional(rmsd.values[0])) + + let stability = @bio.bluster_bootstrap_kmeans_stability( + coordinates, + kmeans_config, + iterations=8, + seed=109, + ) catch { + _ => abort("bootstrap stability failed") + } + println("\n5. Bootstrap stability") + println( + " first cluster coherence: " + + bluster_demo_optional(stability.ratios[0][0]), + ) + println( + " cluster separation: " + bluster_demo_optional(stability.ratios[0][1]), + ) + + let experiment = @bio.SingleCellExperiment::new( + [ + [8.0, 7.0, 9.0, 8.0, 1.0, 2.0, 1.0, 2.0], + [1.0, 2.0, 1.0, 2.0, 8.0, 7.0, 9.0, 8.0], + ], + ["MarkerA", "MarkerB"], + ["C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8"], + ) + experiment.reduced_dims["PCA"] = coordinates + experiment.metadata["source"] = "bluster_demo" + let clustered = @bio.bluster_cluster_sce( + experiment, + graph_config, + output_column="community", + ) catch { + _ => abort("SCE clustering failed") + } + println("\n6. Immutable SingleCellExperiment integration") + println( + " written labels: " + clustered.experiment.col_data["community"].join(", "), + ) + println( + " original unchanged: " + + (!experiment.col_data.contains("community")).to_string(), + ) + println("\nbluster demo completed.") +} diff --git a/examples/bluster_demo/moon.pkg b/examples/bluster_demo/moon.pkg new file mode 100644 index 00000000..4ecfd216 --- /dev/null +++ b/examples/bluster_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src" @bio, +} + +pkgtype(kind: "executable") diff --git a/examples/droplet_utils_demo/main.mbt b/examples/droplet_utils_demo/main.mbt index a37e94b8..ae085f49 100644 --- a/examples/droplet_utils_demo/main.mbt +++ b/examples/droplet_utils_demo/main.mbt @@ -1,56 +1,125 @@ ///| fn main { - println("=== DropletUtils Demo ===") - - let (counts, barcodes) = @src.create_example_droplet_data() - - println("\n1. Calculate droplet statistics:") - let stats = @src.calculate_droplet_stats(counts, barcodes) - println(" Number of barcodes: " + stats.total_counts.length().to_string()) - let mut sum = 0.0 - let mut j = 0 - while j < 10 && j < stats.total_counts.length() { - sum = sum + stats.total_counts[j] - j = j + 1 - } - println(" Mean total counts: " + (sum / 10.0).to_string()) + let data = @src.droplet_utils_advanced_example() catch { + _ => abort("failed to create the DropletUtils example") + } + println( + "Droplet matrix: " + + data.n_features().to_string() + + " features x " + + data.n_barcodes().to_string() + + " barcodes", + ) - println("\n2. Barcode ranking:") - let ranked = @src.barcode_ranking(stats.total_counts) - println(" Top 5 barcodes by UMI count:") - let mut i = 0 - while i < 5 && i < ranked.length() { - println(" " + barcodes[ranked[i].1] + ": " + ranked[i].0.to_string()) - i = i + 1 + let ambient = @src.droplet_utils_ambient_profile(data, lower=15) catch { + _ => abort("failed to estimate the ambient profile") } + let alpha = @src.droplet_utils_estimate_alpha(data, ambient) catch { + _ => abort("failed to estimate Dirichlet-multinomial alpha") + } + println( + "Ambient droplets: " + + ambient.n_empty().to_string() + + ", ambient molecules: " + + ambient.total.to_string() + + ", estimated alpha: " + + alpha.to_string(), + ) - println("\n3. Find knee point:") - let knee = @src.find_knee_point(ranked) - println(" Knee point at index: " + knee.to_string()) + let ranks = @src.droplet_utils_barcode_ranks( + data, + lower=15, + exclude_from=0, + window=0.2, + ) catch { + _ => abort("failed to trace the barcode-rank curve") + } println( - " Estimated cell number: " + - @src.estimate_cell_number(stats.total_counts).to_string(), + "Barcode-rank knee: " + + ranks.knee.to_string() + + ", inflection: " + + ranks.inflection.to_string(), ) - println("\n4. Empty droplet detection (emptyDrops):") - let result = @src.empty_drops(counts, barcodes, 10, 100) - println(" Tested barcodes: " + result.barcode.length().to_string()) + let config = @src.DropletUtilsConfig::create( + lower=15, + iterations=499, + fdr_threshold=0.05, + retain=80.0, + alpha~, + rank_exclude=0, + rank_window=0.2, + seed=31, + ) catch { + _ => abort("failed to create the DropletUtils configuration") + } + let result = @src.droplet_utils_empty_drops(data, config~) catch { + _ => abort("emptyDrops failed") + } + println(result.summary()) - let mut n_cells = 0 - i = 0 - while i < result.is_cell.length() { - if result.is_cell[i] { - n_cells = n_cells + 1 + println("\nCalled barcodes") + for barcode in 0.. value.to_string() + None => "NA" + } + let fdr = match result.fdr[barcode] { + Some(value) => value.to_string() + None => "NA" + } + println( + result.barcodes[barcode] + + "\ttotal=" + + result.totals[barcode].to_string() + + "\tp=" + + p_value + + "\tFDR=" + + fdr + + "\tretained=" + + result.always_retained[barcode].to_string(), + ) } - i = i + 1 } - println(" Detected cells: " + n_cells.to_string()) - println("\n5. Filter cells by emptyDrops results:") - let (filtered_counts, filtered_barcodes) = @src.filter_cells_by_empty_drops( - counts, barcodes, result, + let filtered = result.filter(data) catch { + _ => abort("failed to filter called barcodes") + } + println( + "\nFiltered matrix: " + + filtered.n_features().to_string() + + " features x " + + filtered.n_barcodes().to_string() + + " called barcodes", ) - println(" Filtered barcodes: " + filtered_barcodes.length().to_string()) - println("\nDropletUtils demo completed!") + let assay : Array[Array[Double]] = [] + for feature in 0.. abort("DropletUtils SingleCellExperiment integration failed") + } + println( + "SingleCellExperiment write-back: class=" + + output.experiment.col_data["droplet.class"][40] + + ", ambient=" + + output.experiment.row_data["droplet.ambient"][0] + + ", original_unchanged=" + + (!experiment.col_data.contains("droplet.class")).to_string(), + ) } diff --git a/examples/flowsom_demo/main.mbt b/examples/flowsom_demo/main.mbt new file mode 100644 index 00000000..2c625bd7 --- /dev/null +++ b/examples/flowsom_demo/main.mbt @@ -0,0 +1,189 @@ +///| +fn flowsom_demo_ints(values : Array[Int]) -> String { + values.map(fn(value) { value.to_string() }).join(", ") +} + +///| +fn flowsom_demo_optional(value : Double?) -> String { + match value { + Some(actual) => actual.to_string() + None => "NA" + } +} + +///| +fn flowsom_demo_bool_count(values : Array[Bool]) -> Int { + let mut total = 0 + for value in values { + if value { + total = total + 1 + } + } + total +} + +///| +fn main { + println("=== Bioconductor FlowSOM 2.21.0 Demo ===") + + // FlowSOM uses cell x marker matrices. + let cells = [ + [8.0, 1.0, 5.0], + [8.2, 1.1, 5.1], + [7.8, 0.9, 4.9], + [8.1, 1.2, 5.0], + [1.0, 8.0, 5.0], + [1.1, 8.2, 5.2], + [0.9, 7.8, 4.8], + [1.2, 8.1, 5.1], + [4.0, 4.0, 9.0], + [4.2, 4.1, 9.2], + [3.8, 3.9, 8.8], + [4.1, 4.2, 9.1], + ] + let config = @bio.FlowSomConfig::create( + xdim=3, + ydim=2, + rlen=5, + mst_runs=2, + alpha_start=0.08, + alpha_end=0.01, + radius_start=2.0, + radius_end=0.0, + importance=[1.0, 1.0, 0.75], + metaclusters=3, + meta_starts=6, + outlier_mad=3.0, + seed=101, + ) catch { + _ => abort("failed to create the FlowSOM configuration") + } + let model = @bio.flowsom_train(cells, config, marker_names=[ + "CD3", "CD19", "CD45", + ]) catch { + _ => abort("FlowSOM training failed") + } + + println("\n1. Topology-aware SOM training") + println(@bio.flowsom_summary(model)) + println(" node counts: " + flowsom_demo_ints(model.node_counts)) + println( + " cell meta-clusters: " + + flowsom_demo_ints(model.cell_meta_clusters.map(fn(value) { value + 1 })), + ) + + println("\n2. Minimum spanning tree") + for edge in model.mst_edges { + println( + " node " + + (edge.from + 1).to_string() + + " -> " + + (edge.to + 1).to_string() + + ", weight=" + + edge.weight.to_string(), + ) + } + + let mut occupied = 0 + while occupied < model.node_counts.length() && + model.node_counts[occupied] == 0 { + occupied = occupied + 1 + } + println("\n3. Node statistics on unweighted marker values") + println(" first occupied node: " + (occupied + 1).to_string()) + println( + " CD3 median fluorescence: " + + flowsom_demo_optional(model.node_medians[occupied][0]), + ) + println( + " CD3 coefficient of variation: " + + flowsom_demo_optional(model.node_cvs[occupied][0]), + ) + let positive = @bio.flowsom_node_positive_percentages(model, [5.0, 5.0, 7.0]) catch { + _ => abort("node positivity calculation failed") + } + println( + " CD3-positive fraction: " + flowsom_demo_optional(positive[occupied][0]), + ) + println( + " training outliers: " + + flowsom_demo_bool_count(model.outliers.per_cell).to_string(), + ) + + let projected = @bio.flowsom_map_new(model, [ + [model.codes[0][0], model.codes[0][1], model.codes[0][2] / 0.75], + [20.0, 20.0, 20.0], + ]) catch { + _ => abort("new data projection failed") + } + println("\n4. New-data projection and MAD outliers") + println( + " mapped nodes: " + + flowsom_demo_ints(projected.mapping.clusters.map(fn(value) { value + 1 })), + ) + println( + " mapped meta-clusters: " + + flowsom_demo_ints(projected.meta_clusters.map(fn(value) { value + 1 })), + ) + println( + " outlier flags: " + + projected.outliers.map(fn(value) { value.to_string() }).join(", "), + ) + + let frame = @bio.FlowFrame::new(cells, [ + @bio.ParameterDescription::new("CD3", 25.0, 0.0, 25.0), + @bio.ParameterDescription::new("CD19", 25.0, 0.0, 25.0), + @bio.ParameterDescription::new("CD45", 25.0, 0.0, 25.0), + ]) + let frame_config = @bio.FlowSomConfig::create( + xdim=3, + ydim=2, + rlen=5, + mst_runs=2, + importance=[1.0, 0.75], + metaclusters=3, + meta_starts=6, + seed=103, + ) catch { + _ => abort("failed to create the FlowFrame configuration") + } + let frame_model = @bio.flowsom_train_flow_frame(frame, frame_config, marker_indices=[ + 0, 2, + ]) catch { + _ => abort("FlowFrame integration failed") + } + println("\n5. flowCore FlowFrame integration") + println(" selected markers: " + frame_model.marker_names.join(", ")) + println( + " mapped events: " + frame_model.mapping.clusters.length().to_string(), + ) + + // SingleCellExperiment assays use marker x cell orientation. + let experiment = @bio.SingleCellExperiment::new( + [ + [8.0, 8.2, 7.8, 8.1, 1.0, 1.1, 0.9, 1.2, 4.0, 4.2, 3.8, 4.1], + [1.0, 1.1, 0.9, 1.2, 8.0, 8.2, 7.8, 8.1, 4.0, 4.1, 3.9, 4.2], + [5.0, 5.1, 4.9, 5.0, 5.0, 5.2, 4.8, 5.1, 9.0, 9.2, 8.8, 9.1], + ], + ["CD3", "CD19", "CD45"], + ["C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9", "C10", "C11", "C12"], + ) + experiment.metadata["source"] = "flowsom_demo" + let clustered = @bio.flowsom_cluster_sce(experiment, config) catch { + _ => abort("SingleCellExperiment integration failed") + } + println("\n6. Immutable SingleCellExperiment integration") + println( + " SOM labels: " + + clustered.experiment.col_data["FlowSOM.cluster"].join(", "), + ) + println( + " meta-cluster labels: " + + clustered.experiment.col_data["FlowSOM.metacluster"].join(", "), + ) + println( + " original unchanged: " + + (!experiment.col_data.contains("FlowSOM.cluster")).to_string(), + ) + println("\nFlowSOM demo completed.") +} diff --git a/examples/flowsom_demo/moon.pkg b/examples/flowsom_demo/moon.pkg new file mode 100644 index 00000000..4ecfd216 --- /dev/null +++ b/examples/flowsom_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src" @bio, +} + +pkgtype(kind: "executable") diff --git a/examples/lisaclust_demo/main.mbt b/examples/lisaclust_demo/main.mbt new file mode 100644 index 00000000..b159c24a --- /dev/null +++ b/examples/lisaclust_demo/main.mbt @@ -0,0 +1,142 @@ +// Bioconductor lisaClust-inspired local spatial association and region discovery. + +///| +fn main { + let cells = @src.lisaclust_example_data() + let config = @src.LisaConfig::create( + radii=[2.5, 5.0], + curve_kind=@src.lisa_k_curve(), + window_kind=@src.lisa_rectangle_window(), + bandwidth=4.0, + min_density=0.05, + edge_correction=true, + window_padding=0.1, + edge_samples=96, + n_clusters=2, + n_starts=8, + seed=11, + ) catch { + LisaError(message) => abort("invalid lisaClust configuration: " + message) + } + let result = @src.lisaclust(cells, config~) catch { + LisaError(message) => abort("lisaClust analysis failed: " + message) + } + + println("=== Direct lisaClust analysis ===") + println(result.summary()) + println( + "iterations=" + + result.iterations.to_string() + + ", converged=" + + result.converged.to_string(), + ) + for image_radii in result.curves.effective_radii { + println( + image_radii.image_id + + " effective radii: " + + image_radii.radii.to_string(), + ) + } + + println("\n=== Region summaries ===") + println("region\tsize\tdominant cell type\tmaximum enrichment") + for summary in result.region_summaries { + println( + summary.region + + "\t" + + summary.size.to_string() + + "\t" + + summary.dominant_cell_type + + "\t" + + summary.maximum_enrichment.to_string(), + ) + } + + let top = result.top_enrichments(limit=6, minimum_relative_frequency=1.0) catch { + LisaError(message) => abort("enrichment ranking failed: " + message) + } + println("\n=== Top observed/expected enrichments ===") + println("region\tcell type\tobserved\texpected\tratio") + for entry in top { + println( + entry.region + + "\t" + + entry.cell_type + + "\t" + + entry.observed.to_string() + + "\t" + + entry.expected.to_string() + + "\t" + + entry.relative_frequency.to_string(), + ) + } + + let l_config = @src.LisaConfig::create( + radii=[2.5, 5.0], + curve_kind=@src.lisa_l_curve(), + window_kind=@src.lisa_rectangle_window(), + bandwidth=4.0, + min_density=0.05, + edge_correction=true, + window_padding=0.1, + edge_samples=96, + ) catch { + LisaError(message) => abort("invalid local-L configuration: " + message) + } + let l_curves = @src.lisa_curves(cells, config=l_config) catch { + LisaError(message) => abort("local-L curve computation failed: " + message) + } + println("\n=== Centered local-L curve for the first cell ===") + println("cell=" + l_curves.cell_ids[0]) + for feature in 0.. + abort("lisaClust SpatialExperiment integration failed: " + message) + } + println("\n=== SpatialExperiment integration ===") + println( + "cells=" + + integrated.experiment.metadata["lisaclust_cells"] + + ", features=" + + integrated.experiment.metadata["lisaclust_features"] + + ", regions=" + + integrated.experiment.metadata["lisaclust_regions"], + ) + println( + "first assigned tissueRegion=" + + integrated.experiment.col_data[0]["tissueRegion"] + + ", original unchanged=" + + (!experiment.col_data[0].contains("tissueRegion")).to_string(), + ) +} diff --git a/examples/lisaclust_demo/moon.pkg b/examples/lisaclust_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/lisaclust_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/examples/mast_demo/main.mbt b/examples/mast_demo/main.mbt index f2af296a..a5951ae0 100644 --- a/examples/mast_demo/main.mbt +++ b/examples/mast_demo/main.mbt @@ -1,145 +1,115 @@ ///| -fn main { - println("=== MAST Demo ===") +fn mast_demo_option(value : Double?) -> String { + match value { + Some(number) => number.to_string() + None => "NA" + } +} - let n_genes = 10 - let n_group1 = 6 - let n_group2 = 6 - let n_cells = n_group1 + n_group2 +///| +fn main { + println("=== Bioconductor MAST 1.39.0 Advanced Demo ===") - let expression : Array[Array[Double]] = Array::make( - n_cells, - Array::make(n_genes, 0.0), + let (data, tested) = @src.mast_advanced_example() catch { + _ => abort("failed to construct the MAST example") + } + println("\n1. Feature x cell model and treatment-coded design") + println( + " genes=" + + data.n_genes.to_string() + + ", cells=" + + data.n_cells.to_string() + + ", coefficients=" + + data.coefficient_names.join(", "), + ) + println( + " tested coefficient=" + + data.coefficient_names[tested[0]] + + ", first-cell CDR=" + + data.cdr[0].to_string(), ) - let gene_names : Array[String] = Array::make(n_genes, "") - let cell_names : Array[String] = Array::make(n_cells, "") - let groups : Array[Int] = Array::make(n_cells, 0) - let mut g = 0 - while g < n_genes { - gene_names[g] = "Gene" + g.to_string() - g = g + 1 + let config = @src.MastAdvancedConfig::create( + empirical_bayes=true, + ebayes_use_full_model=false, + fdr_threshold=0.05, + ) catch { + _ => abort("failed to construct the MAST configuration") } - - let mut i = 0 - while i < n_cells { - cell_names[i] = "Cell" + i.to_string() - groups[i] = if i < n_group1 { 0 } else { 1 } - - let row : Array[Double] = Array::make(n_genes, 0.0) - let mut j = 0 - while j < n_genes { - let base_expr = if j < 5 { - if i < n_group1 { - 10.0 - } else { - 50.0 - } - } else if i < n_group1 { - 30.0 - } else { - 25.0 - } - let noise = (i * 7 + j * 13).to_double() % 5.0 - let zero_prob = if j < 3 { - if i < n_group1 { - 0.4 - } else { - 0.1 - } - } else { - 0.2 - } - let is_zero = ((i * 31 + j * 17) % 100).to_double() / 100.0 < zero_prob - row[j] = if is_zero { 0.0 } else { base_expr + noise } - j = j + 1 - } - expression[i] = row - i = i + 1 + let result = @src.mast_advanced_zlm(data, tested, config~) catch { + _ => abort("advanced MAST zlm fit failed") } + println("\n2. Bayesian logistic + positive Gaussian hurdle fit") + println(" " + result.summary()) + println( + " eBayes prior variance=" + + result.prior_variance.to_string() + + ", prior df=" + + result.prior_df.to_string(), + ) - println("\n1. Create MAST Data:") - let data = @src.MastData::new(expression, gene_names, cell_names, groups) - println(" Number of cells: " + data.n_cells.to_string()) - println(" Number of genes: " + data.n_genes.to_string()) - println(" Number of groups: " + data.n_groups.to_string()) - - println("\n2. Detection rate (cngeneson) per cell:") - let mut c = 0 - while c < 5 && c < data.n_cells { + println("\n3. Component LRT, hurdle LRT, FDR and marginal logFC") + for gene in 0.. abort("advanced MAST SingleCellExperiment fit failed") } + println( + " original has mast39.hurdleFdr: " + + experiment.row_data.contains("mast39.hurdleFdr").to_string(), + ) + println( + " enriched row columns include hurdle FDR: " + + output.experiment.row_data.contains("mast39.hurdleFdr").to_string(), + ) + println( + " contrast metadata: " + + output.experiment.metadata["mast39.contrast"] + + ", tested genes=" + + output.experiment.metadata["mast39.tested"], + ) - println("\nMAST demo completed!") + println("\nMAST advanced demo completed.") } diff --git a/examples/muscat_advanced_demo/main.mbt b/examples/muscat_advanced_demo/main.mbt new file mode 100644 index 00000000..0eaca8c8 --- /dev/null +++ b/examples/muscat_advanced_demo/main.mbt @@ -0,0 +1,169 @@ +///| +fn muscat_demo_config() -> @bio.MuscatAdvancedConfig { + @bio.MuscatAdvancedConfig::create( + min_cells=3, + min_count=1.0, + min_samples=2, + max_iterations=100, + tolerance=1.0e-8, + dispersion_prior_df=10.0, + ridge=1.0e-6, + fdr_threshold=0.1, + detection_filter=0.9, + ) catch { + _ => abort("failed to create muscat advanced configuration") + } +} + +///| +fn muscat_demo_result( + result : @bio.MuscatAdvancedResults, + genes : Array[String], + clusters : Array[String], + contrast : String, +) -> Unit { + println("\n" + result.summary()) + for cluster in clusters { + println(" cluster " + cluster) + for gene in genes { + match result.get(gene, cluster, contrast) { + Some(value) => + println( + " " + + gene + + ": log2FC=" + + value.log_fc.to_string() + + ", Wald=" + + value.statistic.to_string() + + ", p=" + + value.p_value.to_string() + + ", local FDR=" + + value.local_fdr.to_string() + + ", global FDR=" + + value.global_fdr.to_string(), + ) + None => () + } + } + } +} + +///| +fn muscat_demo_sce(data : @bio.MuscatAdvancedData) -> @bio.SingleCellExperiment { + let experiment = @bio.SingleCellExperiment::new( + data.counts, + data.gene_names, + data.cell_names, + ) + experiment.col_data["sample"] = data.sample_ids.copy() + experiment.col_data["cluster"] = data.cluster_ids.copy() + experiment.col_data["group"] = data.group_ids.copy() + experiment.row_data["symbol"] = data.gene_names.copy() + experiment.metadata["source"] = "muscat advanced demo" + experiment +} + +///| +fn main { + println("=== Bioconductor muscat 1.27.4 Advanced Demo ===") + let data = @bio.muscat_advanced_example() catch { + _ => abort("failed to construct muscat example data") + } + let config = muscat_demo_config() + + println("\n1. Strict gene x cell data contract") + println( + " " + + data.gene_names.length().to_string() + + " genes, " + + data.cell_names.length().to_string() + + " cells, " + + data.sample_names.length().to_string() + + " samples, " + + data.cluster_names.length().to_string() + + " clusters", + ) + + let sums = @bio.muscat_aggregate_advanced( + data, + aggregation=@bio.muscat_sum_counts(), + ) catch { + _ => abort("sum-count aggregation failed") + } + let detections = @bio.muscat_aggregate_advanced( + data, + aggregation=@bio.muscat_number_detected(), + ) catch { + _ => abort("number-detected aggregation failed") + } + println("\n2. Cluster-sample pseudobulk aggregation") + for cluster in 0.. abort("group design construction failed") + } + let contrasts = @bio.muscat_default_contrasts_advanced(design) catch { + _ => abort("default contrast construction failed") + } + let contrast = contrasts[0].name + println("\n3. Replicated design and contrast") + println(" coefficients: " + design.coefficient_names.join(", ")) + println(" contrast: " + contrast) + + let ds = @bio.muscat_pbds_advanced(sums, design, contrasts, config~) catch { + _ => abort("differential-state model failed") + } + let dd = @bio.muscat_pbdd_advanced(detections, design, contrasts, config~) catch { + _ => abort("differential-detection model failed") + } + muscat_demo_result(ds, data.gene_names, data.cluster_names, contrast) + muscat_demo_result(dd, data.gene_names, data.cluster_names, contrast) + + let stagewise = @bio.muscat_stagewise_ds_dd(ds, dd, alpha=0.1) catch { + _ => abort("stagewise DS/DD testing failed") + } + println("\n4. Harmonic-mean screening and two-stage confirmation") + for result in stagewise.results { + if result.classification != "none" { + println( + " " + + result.cluster_name + + "/" + + result.gene_name + + ": " + + result.classification + + ", screen FDR=" + + result.screen_fdr.to_string(), + ) + } + } + + let sce_output = @bio.muscat_advanced_sce( + muscat_demo_sce(data), + "sample", + "cluster", + "group", + reference="ctrl", + output_prefix="muscat", + config~, + ) catch { + _ => abort("SingleCellExperiment integration failed") + } + println("\n5. Immutable SingleCellExperiment write-back") + println( + " metadata version: " + sce_output.experiment.metadata["muscat.version"], + ) + println( + " row annotations: muscat.A.dsLogFC, muscat.A.dsFdr, " + + "muscat.A.ddLogFC, muscat.A.ddFdr, muscat.A.stageClass", + ) +} diff --git a/examples/muscat_advanced_demo/moon.pkg b/examples/muscat_advanced_demo/moon.pkg new file mode 100644 index 00000000..4ecfd216 --- /dev/null +++ b/examples/muscat_advanced_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src" @bio, +} + +pkgtype(kind: "executable") diff --git a/examples/sc_dbl_finder_demo/main.mbt b/examples/sc_dbl_finder_demo/main.mbt index 3b727dd7..f6a035bb 100644 --- a/examples/sc_dbl_finder_demo/main.mbt +++ b/examples/sc_dbl_finder_demo/main.mbt @@ -1,31 +1,134 @@ ///| fn main { - let data = @bio.scdf_create_example_data() + let (data, clusters, samples, known_doublets) = @bio.scdf_create_advanced_example() catch { + _ => abort("failed to create the scDblFinder example") + } + let config = @bio.ScDblFinderConfig::create( + expected_doublet_rate=0.15, + artificial_doublets=48, + selected_features=18, + dimensions=5, + neighbors=8, + iterations=2, + classifier_steps=120, + seed=17, + ) catch { + _ => abort("failed to create the scDblFinder configuration") + } + let result = @bio.sc_dbl_finder( + data, + clusters~, + samples~, + known_doublets~, + config~, + ) catch { + _ => abort("scDblFinder fitting failed") + } - println( - "Single cell data: " + - data.cell_names.length().to_string() + - " cells, " + - data.gene_names.length().to_string() + - " genes", - ) + println(result.summary()) + println("\nCapture thresholds") + for capture in 0.. abort("failed to rank doublets") + } + for cell in top { + println( + cell.cell_name + + "\tscore=" + + cell.score.to_string() + + "\tclass=" + + (if cell.is_doublet { "doublet" } else { "singlet" }) + + "\torigin=" + + cell.origin, + ) + } + + println("\nPairwise origin enrichment") + let enrichment = @bio.scdf_pairwise_enrichment(result) catch { + _ => abort("failed to compute origin enrichment") + } + for row in enrichment { + println( + row.combination + + "\tobserved=" + + row.observed.to_string() + + "\texpected=" + + row.expected.to_string() + + "\tadjusted_p=" + + row.adjusted_p_value.to_string(), + ) + } - let scores = @bio.scdf_compute_doublet_score(data, 10) + let singlets = result.filter_singlets(data) catch { + _ => abort("failed to filter singlets") + } println( - "Doublet scores computed for " + scores.length().to_string() + " cells", + "\nRetained " + + singlets.cell_names.length().to_string() + + " singlets from " + + data.cell_names.length().to_string() + + " cells", ) - let doublets = @bio.scdf_detect_doublets(scores, 0.3) - println("Detected doublets: " + doublets.length().to_string()) - - let summary = @bio.scdf_doublet_summary(scores) - println(summary) + let automatic_clusters = @bio.scdf_fast_cluster( + data, + 3, + dimensions=5, + selected_features=18, + ) catch { + _ => abort("automatic clustering failed") + } + println("Automatic clusters for first five cells") + for cell in 0..<5 { + println(data.cell_names[cell] + "\t" + automatic_clusters[cell]) + } - let filtered = @bio.scdf_filter_doublets(data, scores) + let assay : Array[Array[Double]] = [] + for gene in 0.. abort("SingleCellExperiment integration failed") + } println( - "After filtering: " + filtered.cell_names.length().to_string() + " cells", + "\nSingleCellExperiment write-back: score=" + + output.experiment.col_data["scDblFinder.score"][0] + + ", original_unchanged=" + + (!experiment.col_data.contains("scDblFinder.score")).to_string(), ) - - let pca = @bio.scdf_compute_pca(data, 5) - println("PCA computed: " + pca.length().to_string() + " cells, 5 components") } diff --git a/examples/scuttle_demo/main.mbt b/examples/scuttle_demo/main.mbt new file mode 100644 index 00000000..fe33a1e2 --- /dev/null +++ b/examples/scuttle_demo/main.mbt @@ -0,0 +1,124 @@ +///| +fn scuttle_demo_doubles(values : Array[Double]) -> String { + values.map(fn(value) { value.to_string() }).join(", ") +} + +///| +fn main { + println("=== Bioconductor scuttle 1.23.1 Demo ===") + + let outlier_config = @bio.ScuttleOutlierConfig::create( + nmads=2.0, + direction=@bio.scuttle_outlier_higher(), + batches=["A", "A", "A", "B", "B", "B"], + ) catch { + _ => abort("failed to create the outlier configuration") + } + let outliers = @bio.scuttle_is_outlier( + [9.0, 10.0, 11.0, 98.0, 100.0, 150.0], + config=outlier_config, + ) catch { + _ => abort("batch-aware outlier detection failed") + } + println("\n1. Batch-aware MAD outlier detection") + println(" batches: " + outliers.batch_names.join(", ")) + println(" upper thresholds: " + scuttle_demo_doubles(outliers.higher)) + println(" discarded observations: " + outliers.discarded_count().to_string()) + + let counts = [ + [8.0, 4.0, 16.0, 8.0], + [2.0, 6.0, 4.0, 12.0], + [0.0, 2.0, 0.0, 4.0], + [10.0, 8.0, 20.0, 16.0], + ] + let controls = @bio.ScuttleNamedCellSubset::create("controls", [0, 1]) catch { + _ => abort("failed to create the control-cell subset") + } + let qc = @bio.scuttle_per_feature_qc(counts, subsets=[controls]) catch { + _ => abort("per-feature QC failed") + } + println("\n2. Per-feature QC with a named cell subset") + println(" means: " + scuttle_demo_doubles(qc.means)) + println( + " detected percentages: " + scuttle_demo_doubles(qc.detected_percent), + ) + println( + " control/global ratios: " + scuttle_demo_doubles(qc.subset_ratios[0]), + ) + + let pathway_a = @bio.ScuttleFeatureSet::create("PathwayA", [0, 1]) catch { + _ => abort("failed to create PathwayA") + } + let pathway_b = @bio.ScuttleFeatureSet::create("PathwayB", [1, 2, 3]) catch { + _ => abort("failed to create PathwayB") + } + let aggregated = @bio.scuttle_aggregate_feature_sets(counts, [ + pathway_a, pathway_b, + ]) catch { + _ => abort("feature-set aggregation failed") + } + println("\n3. Overlapping feature-set aggregation") + for index in 0.. abort("batch coverage equalization failed") + } + println("\n4. Exact batch coverage equalization") + println(" batch summaries: " + scuttle_demo_doubles(balanced.summaries)) + println(" proportions: " + scuttle_demo_doubles(balanced.proportions)) + + let experiment = @bio.SingleCellExperiment::new( + counts, + ["G1", "G2", "G3", "G4"], + ["C1", "C2", "C3", "C4"], + ) + experiment.col_data["batch"] = ["A", "A", "B", "B"] + experiment.metadata["source"] = "scuttle_demo" + let qc_output = @bio.scuttle_per_feature_qc_sce(experiment, subsets=[controls]) catch { + _ => abort("SCE per-feature QC failed") + } + let downsampled = @bio.scuttle_downsample_sce( + qc_output.experiment, + 0.5, + output_assay="half", + seed=42, + ) catch { + _ => abort("SCE downsampling failed") + } + let pathway_sce = @bio.scuttle_aggregate_feature_sets_sce( + downsampled, + [pathway_a, pathway_b], + assay_names=["counts", "half"], + ) catch { + _ => abort("SCE feature aggregation failed") + } + println("\n5. Immutable SingleCellExperiment integration") + println( + " QC rows written: " + + qc_output.experiment.row_data["scuttle.mean"].length().to_string(), + ) + println( + " downsampled assay rows: " + + downsampled.assays["half"].length().to_string(), + ) + println(" aggregated rows: " + pathway_sce.row_names.join(", ")) + println( + " original unchanged: " + + (!experiment.row_data.contains("scuttle.mean") && + !experiment.assays.contains("half")).to_string(), + ) + println("\nscuttle demo completed.") +} diff --git a/examples/scuttle_demo/moon.pkg b/examples/scuttle_demo/moon.pkg new file mode 100644 index 00000000..4ecfd216 --- /dev/null +++ b/examples/scuttle_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src" @bio, +} + +pkgtype(kind: "executable") diff --git a/examples/single_r_demo/main.mbt b/examples/single_r_demo/main.mbt index f179fd02..c40140d4 100644 --- a/examples/single_r_demo/main.mbt +++ b/examples/single_r_demo/main.mbt @@ -1,81 +1,148 @@ ///| -/// SingleR Demo - Cell type annotation by reference expression profiles. -/// Inspired by Bioconductor SingleR package. +fn single_r_demo_optional_label(value : String?) -> String { + match value { + Some(label) => label + None => "NA" + } +} ///| fn main { - println("=== SingleR Cell Type Annotation Demo ===") - println("Inspired by Bioconductor SingleR package") - println("") - - println("1. Creating reference dataset with known cell type profiles...") - let ref_data = @bio.single_r_create_reference_data() - println(" Reference profiles: \{ref_data.n_profiles.to_string()}") - println(" Cell types:") - for ct in ref_data.cell_types { - println(" - \{ct}") + println("=== Bioconductor SingleR 2.15.2 Advanced Demo ===") + let (reference, data) = @bio.single_r_advanced_example() catch { + _ => abort("failed to construct the SingleR example") + } + println( + "\n1. Gene x sample/cell inputs: reference=" + + reference.n_genes.to_string() + + "x" + + reference.n_samples.to_string() + + ", test=" + + data.n_genes.to_string() + + "x" + + data.n_cells.to_string(), + ) + + let training = @bio.single_r_advanced_train(reference, data.gene_names) catch { + _ => abort("SingleR marker training failed") + } + let t_vs_b = training.markers_between("T cell", "B cell") catch { + _ => abort("failed to query pairwise markers") + } + println("\n2. Directed classic marker training") + println( + " shared genes=" + + training.common_gene_names.length().to_string() + + ", selected markers=" + + training.marker_gene_names().length().to_string(), + ) + println(" T cell > B cell markers: " + t_vs_b.join(", ")) + + let config = @bio.SingleRAdvancedConfig::create( + quantile=0.8, + fine_tune=true, + prune=true, + nmads=3.0, + ) catch { + _ => abort("failed to construct the SingleR configuration") + } + let result = @bio.single_r_advanced_classify(data, training, config~) catch { + _ => abort("SingleR cell annotation failed") } - println(" Genes per profile: \{ref_data.n_genes.to_string()}") - println("") - - println("2. Creating synthetic single-cell data to annotate...") - let test_data = @bio.single_r_create_test_data() - println(" Cells: \{test_data.n_cells.to_string()}") - println(" Genes: \{test_data.n_genes.to_string()}") - println("") - - println("3. Running SingleR annotation (Spearman correlation)...") - let params = @bio.SingleRParams::new() - let result = @bio.single_r_annotate_cells(test_data, ref_data, params) - println(" Annotation completed for \{result.cell_ids.length().to_string()} cells") - println("") - - println("4. Annotation results summary:") - println(" First 10 annotations:") - let mut i = 0 - while i < 10 && i < result.cell_ids.length() { - println(" Cell \{result.cell_ids[i]}: \{result.labels[i]} (score: \{result.scores[i].to_string()})") - i = i + 1 + println("\n3. Quantile scores, iterative fine-tuning and pruning") + for cell in 0.. abort("SingleR cluster annotation failed") + } + println("\n4. Cluster-level annotation from summed profiles") + for cluster in 0.. abort("failed to construct the second reference") } - println("") - - println("6. Running SingleR with Pearson correlation...") - let params_pearson = @bio.SingleRParams::with_method("pearson") - let result_pearson = @bio.single_r_annotate_cells(test_data, ref_data, params_pearson) - println(" Pearson annotation completed") - println(" First 5 annotations (Pearson):") - let mut j = 0 - while j < 5 && j < result_pearson.cell_ids.length() { - println(" Cell \{result_pearson.cell_ids[j]}: \{result_pearson.labels[j]} (score: \{result_pearson.scores[j].to_string()})") - j = j + 1 + let combined = @bio.single_r_advanced_combine( + data, + [reference, alternate], + config~, + ) catch { + _ => abort("SingleR multi-reference integration failed") + } + println("\n5. Multi-reference marker-space recomputation") + for cell in 0.. abort("SingleR SingleCellExperiment integration failed") } - println("") - - println("7. Correlation analysis example:") - let t_cell_expr = ref_data.profiles[0].expression - let b_cell_expr = ref_data.profiles[1].expression - let t_vs_b_spearman = @bio.single_r_spearman_correlation(t_cell_expr, b_cell_expr) - let t_vs_self_spearman = @bio.single_r_spearman_correlation(t_cell_expr, t_cell_expr) - let t_vs_b_pearson = @bio.single_r_pearson_correlation(t_cell_expr, b_cell_expr) - println(" T cell vs B cell (Spearman): \{t_vs_b_spearman.to_string()}") - println(" T cell vs T cell (Spearman): \{t_vs_self_spearman.to_string()}") - println(" T cell vs B cell (Pearson): \{t_vs_b_pearson.to_string()}") - println("") - - println("=== Demo completed successfully! ===") - println("") - println("Key takeaways:") - println("- SingleR annotates cells by comparing expression profiles to reference datasets") - println("- Spearman correlation is robust to outliers; Pearson is sensitive to magnitude") - println("- Fine-tuning can resolve ambiguous assignments by comparing against related cell types") - println("- The delta score (difference between top and 2nd best) indicates annotation confidence") - println("- SingleR can be used with any reference dataset (bulk RNA-seq, sorted populations)") -} \ No newline at end of file + println("\n6. Immutable SingleCellExperiment write-back") + println( + " mode=" + + output.experiment.metadata["SingleR215.mode"] + + ", labels=" + + output.experiment.col_data["SingleR215.labels"].join(", "), + ) + println( + " original unchanged=" + + (!experiment.col_data.contains("SingleR215.labels")).to_string(), + ) + println("\nSingleR advanced demo completed.") +} diff --git a/examples/slingshot_advanced_demo/main.mbt b/examples/slingshot_advanced_demo/main.mbt new file mode 100644 index 00000000..af7837b8 --- /dev/null +++ b/examples/slingshot_advanced_demo/main.mbt @@ -0,0 +1,163 @@ +///| +fn slingshot_demo_coordinates() -> Array[Array[Double]] { + [ + [-0.1, 0.0], + [0.0, 0.1], + [0.1, -0.1], + [0.9, 0.0], + [1.0, 0.1], + [1.1, -0.1], + [1.9, 0.0], + [2.0, 0.1], + [2.1, -0.1], + [2.9, 0.9], + [3.0, 1.0], + [3.1, 1.1], + [2.9, -0.9], + [3.0, -1.0], + [3.1, -1.1], + ] +} + +///| +fn slingshot_demo_labels() -> Array[String] { + ["A", "A", "A", "B", "B", "B", "C", "C", "C", "D", "D", "D", "E", "E", "E"] +} + +///| +fn slingshot_demo_lineage( + lineage : Array[Int], + cluster_names : Array[String], +) -> String { + lineage.map(fn(index) { cluster_names[index] }).join(" -> ") +} + +///| +fn slingshot_demo_doubles(values : Array[Double]) -> String { + values.map(fn(value) { value.to_string() }).join(", ") +} + +///| +fn main { + println("=== Bioconductor slingshot 2.21.0 Advanced Demo ===") + let coordinates = slingshot_demo_coordinates() + let labels = slingshot_demo_labels() + let config = @bio.SlingshotAdvancedConfig::create( + start_clusters=["A"], + end_clusters=["D", "E"], + distance=@bio.slingshot_scaled_full(), + extension=@bio.slingshot_extend_line(), + shrink=1.0, + reweight=true, + reassign=true, + max_iterations=8, + tolerance=1.0e-4, + smoother_span=0.4, + curve_points=30, + ) catch { + _ => abort("failed to create the advanced slingshot configuration") + } + let result = @bio.slingshot_advanced(coordinates, labels, config) catch { + _ => abort("advanced slingshot fitting failed") + } + + println("\n1. Constrained cluster minimum spanning tree") + for edge in result.lineage_model.edges { + println( + " " + + result.lineage_model.cluster_names[edge.from] + + " -> " + + result.lineage_model.cluster_names[edge.to] + + ", distance=" + + edge.distance.to_string(), + ) + } + + println("\n2. Root-to-leaf lineages and simultaneous curves") + for index in 0.. abort("new-cell trajectory projection failed") + } + println("\n4. New-cell projection") + for cell in 0.. abort("SingleCellExperiment trajectory integration failed") + } + println("\n5. Immutable SingleCellExperiment integration") + println(" output columns: slingshot.branch, slingshot.pseudotime") + println( + " pseudotime matrix: " + + sce_output.experiment.reduced_dims["slingshot.pseudotime"] + .length() + .to_string() + + " cells x " + + sce_output.experiment.reduced_dims["slingshot.pseudotime"][0] + .length() + .to_string() + + " lineages", + ) + println( + " original unchanged: " + + (!experiment.col_data.contains("slingshot.branch")).to_string(), + ) + println("\n" + @bio.slingshot_advanced_summary(result)) +} diff --git a/examples/slingshot_advanced_demo/moon.pkg b/examples/slingshot_advanced_demo/moon.pkg new file mode 100644 index 00000000..4ecfd216 --- /dev/null +++ b/examples/slingshot_advanced_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src" @bio, +} + +pkgtype(kind: "executable") diff --git a/examples/spatialdecon_demo/main.mbt b/examples/spatialdecon_demo/main.mbt new file mode 100644 index 00000000..400d8f23 --- /dev/null +++ b/examples/spatialdecon_demo/main.mbt @@ -0,0 +1,171 @@ +// Bioconductor SpatialDecon-inspired background-aware spatial deconvolution. + +///| +fn main { + let (data, profile, nuclei_counts) = @src.spatial_decon_example_data() catch { + SpatialDeconError(message) => abort("example data failed: " + message) + } + let config = @src.SpatialDeconConfig::create( + rescale_profile=false, + tolerance=1.0e-9, + ) catch { + SpatialDeconError(message) => abort("invalid configuration: " + message) + } + let result = @src.spatial_decon(data, profile, nuclei_counts~, config~) catch { + SpatialDeconError(message) => abort("deconvolution failed: " + message) + } + + println("=== Background-aware spatial deconvolution ===") + println(result.summary()) + println("spot\tcell type\tabundance\tproportion\tcells") + for spot in 0.. abort("ranking failed: " + message) + } + for entry in ranked { + let cell_type = entry.cell_type + let mut cell_index = 0 + while result.cell_types[cell_index] != cell_type { + cell_index = cell_index + 1 + } + println( + entry.spot_id + + "\t" + + cell_type + + "\t" + + entry.abundance.to_string() + + "\t" + + entry.proportion.to_string() + + "\t" + + result.cell_counts[cell_index][spot].to_string(), + ) + } + } + println("fit diagnostics:") + for spot in 0.. abort("invalid cell merge: " + message) + } + let myeloid = @src.SpatialDeconCellMerge::create("Myeloid", ["Myeloid"]) catch { + SpatialDeconError(message) => abort("invalid cell merge: " + message) + } + let collapsed = @src.collapse_spatial_decon(result, [lymphoid, myeloid]) catch { + SpatialDeconError(message) => abort("cell-type collapse failed: " + message) + } + println("\n=== Collapsed cell types ===") + for group in 0.. + abort("reverse deconvolution failed: " + message) + } + println("\n=== Reverse deconvolution ===") + println("first-gene intercept=" + reverse.coefficients[0][0].to_string()) + for cell_type in 0.. + abort("background estimation failed: " + message) + } + println("\n=== Probe-pool background ===") + for row in background { + println(row[0].to_string() + "\t" + row[1].to_string()) + } + + let learned_profile = @src.create_spatial_decon_profile( + ["g1", "g2", "g3"], + ["a1", "a2", "b1", "b2"], + ["A", "A", "B", "B"], + [[10.0, 8.0, 1.0, 2.0], [1.0, 2.0, 9.0, 11.0], [2.0, 2.0, 2.0, 2.0]], + normalize=true, + scaling_factor=5.0, + min_cells=1, + min_genes=0, + ) catch { + SpatialDeconError(message) => + abort("profile construction failed: " + message) + } + println("\n=== Single-cell-derived profile ===") + println( + "genes=" + + learned_profile.n_genes().to_string() + + ", cell types=" + + learned_profile.n_cell_types().to_string(), + ) + for cell_type in learned_profile.cell_types { + println("profile cell type: " + cell_type) + } + + let experiment = @src.SpatialExperiment::new() + ignore(@src.se_add_assay(experiment, "counts", data.values)) + ignore(@src.se_add_assay(experiment, "background", data.background)) + for gene in data.gene_names { + ignore(@src.se_add_row(experiment, Map([("gene_id", gene)]))) + } + for spot in 0.. + abort("SpatialExperiment integration failed: " + message) + } + println("\n=== SpatialExperiment integration ===") + println( + "genes=" + + integrated.experiment.metadata["spatialdecon_genes"] + + ", spots=" + + integrated.experiment.metadata["spatialdecon_spots"] + + ", original unchanged=" + + (!experiment.col_data[0].contains("SpatialDecon:T_cell")).to_string(), + ) +} diff --git a/examples/spatialdecon_demo/moon.pkg b/examples/spatialdecon_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/spatialdecon_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/examples/spicyr_demo/main.mbt b/examples/spicyr_demo/main.mbt new file mode 100644 index 00000000..85d34925 --- /dev/null +++ b/examples/spicyr_demo/main.mbt @@ -0,0 +1,141 @@ +// Bioconductor spicyR-inspired differential spatial colocalization. + +///| +fn main { + let (cells, metadata, pairs) = @src.spicyr_example_data() + let config = @src.SpicyConfig::create( + radii=[0.5, 1.0, 2.0], + edge_correction=true, + use_weights=true, + reference_condition="control", + fdr_threshold=0.1, + tolerance=0.01, + ) catch { + SpicyError(message) => abort("invalid spicyR configuration: " + message) + } + + let result = @src.spicyr( + cells, + metadata, + pairs~, + covariate_names=["age"], + config~, + ) catch { + SpicyError(message) => abort("spicyR analysis failed: " + message) + } + + println("=== Direct spicyR analysis ===") + println(result.summary()) + println("pair\tcondition\testimate\tSE\tp-value\tFDR\tmodel") + for pair_result in result.pairs { + for condition in pair_result.conditions { + let model = if pair_result.model + is @src.SpicyModelKind::WeightedRandomIntercept { + "random-intercept" + } else { + "linear" + } + println( + pair_result.pair.label() + + "\t" + + condition.condition_level + + "\t" + + condition.estimate.to_string() + + "\t" + + condition.standard_error.to_string() + + "\t" + + condition.p_value.to_string() + + "\t" + + condition.adjusted_p_value.to_string() + + "\t" + + model, + ) + } + } + + let first_pair = result.pairs[0] + let first_image = first_pair.associations[0] + println("\n=== Per-image cross-L curve ===") + println( + "image=" + + first_image.image_id + + ", pair=" + + first_pair.pair.label() + + ", summary=" + + first_image.statistic.to_string() + + ", precision_weight=" + + first_image.weight.to_string(), + ) + for index in 0.. + abort("precomputed spicyR association fit failed: " + message) + } + println("\n=== Precomputed association input ===") + println(refitted.summary()) + + let experiment = @src.SpatialExperiment::new() + for cell in cells { + let mut image_index = -1 + for index in 0.. + abort("spicyR SpatialExperiment integration failed: " + message) + } + println("\n=== SpatialExperiment integration ===") + println( + "images=" + + integrated.experiment.metadata["spicyr_images"] + + ", pairs=" + + integrated.experiment.metadata["spicyr_pairs"] + + ", reference=" + + integrated.experiment.metadata["spicyr_reference"], + ) +} diff --git a/examples/spicyr_demo/moon.pkg b/examples/spicyr_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/spicyr_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/examples/tradeseq_advanced_demo/main.mbt b/examples/tradeseq_advanced_demo/main.mbt new file mode 100644 index 00000000..986a6a27 --- /dev/null +++ b/examples/tradeseq_advanced_demo/main.mbt @@ -0,0 +1,290 @@ +///| +fn tradeseq_demo_counts() -> Array[Array[Double]] { + let flat : Array[Double] = [] + let association : Array[Double] = [] + let endpoint : Array[Double] = [] + let early_branch : Array[Double] = [] + let zero : Array[Double] = [] + for cell in 0..<24 { + flat.push((10 + cell % 3).to_double()) + if cell < 8 { + association.push((3 + cell).to_double()) + endpoint.push((6 + cell % 2).to_double()) + early_branch.push((8 + cell % 2).to_double()) + } else if cell < 16 { + let step = cell - 8 + association.push((12 + 3 * step).to_double()) + endpoint.push((10 + 4 * step).to_double()) + early_branch.push( + if step < 4 { + (26 + step).to_double() + } else { + (14 + step % 2).to_double() + }, + ) + } else { + let step = cell - 16 + association.push((12 + 3 * step).to_double()) + endpoint.push((10 + step / 3).to_double()) + early_branch.push( + if step < 4 { + (4 + step).to_double() + } else { + (14 + step % 2).to_double() + }, + ) + } + zero.push(0.0) + } + [flat, association, endpoint, early_branch, zero] +} + +///| +fn tradeseq_demo_trajectory() -> (Array[Array[Double]], Array[Array[Double]]) { + let pseudotime : Array[Array[Double]] = [] + let weights : Array[Array[Double]] = [] + for cell in 0..<24 { + if cell < 8 { + let time = cell.to_double() * 0.05 + pseudotime.push([time, time]) + weights.push([0.5, 0.5]) + } else if cell < 16 { + let time = 0.4 + (cell - 8).to_double() * 0.08 + pseudotime.push([time, 0.0]) + weights.push([1.0, 0.0]) + } else { + let time = 0.4 + (cell - 16).to_double() * 0.08 + pseudotime.push([0.0, time]) + weights.push([0.0, 1.0]) + } + } + (pseudotime, weights) +} + +///| +fn tradeseq_demo_config() -> @bio.TradeSeqAdvancedConfig { + @bio.TradeSeqAdvancedConfig::create( + n_knots=4, + smoothing_penalty=1.0, + max_iterations=80, + tolerance=1.0e-5, + ridge=1.0e-6, + fdr_threshold=0.1, + test_points=6, + ) catch { + _ => abort("failed to create tradeSeq configuration") + } +} + +///| +fn tradeseq_demo_print_test(table : @bio.TradeSeqAdvancedTestTable) -> Unit { + println("\n" + table.test_name) + for result in table.results { + println( + " " + + result.gene_id + + ": Wald=" + + result.wald_statistic.to_string() + + ", df=" + + result.degrees_freedom.to_string() + + ", p=" + + result.p_value.to_string() + + ", FDR=" + + result.adjusted_p_value.to_string() + + ", max log2FC=" + + result.log2_fold_change.to_string(), + ) + } +} + +///| +fn tradeseq_demo_slingshot() -> @bio.SlingshotAdvancedResult { + let coordinates = [ + [-0.1, 0.0], + [0.0, 0.1], + [0.1, -0.1], + [0.9, 0.0], + [1.0, 0.1], + [1.1, -0.1], + [1.9, 0.0], + [2.0, 0.1], + [2.1, -0.1], + [2.9, 0.9], + [3.0, 1.0], + [3.1, 1.1], + [2.9, -0.9], + [3.0, -1.0], + [3.1, -1.1], + ] + let labels = [ + "A", "A", "A", "B", "B", "B", "C", "C", "C", "D", "D", "D", "E", "E", "E", + ] + let config = @bio.SlingshotAdvancedConfig::create( + start_clusters=["A"], + end_clusters=["D", "E"], + distance=@bio.slingshot_center_euclidean(), + extension=@bio.slingshot_extend_none(), + max_iterations=6, + curve_points=24, + ) catch { + _ => abort("failed to create Slingshot configuration") + } + @bio.slingshot_advanced(coordinates, labels, config) catch { + _ => abort("Slingshot fitting failed") + } +} + +///| +fn main { + println("=== Bioconductor tradeSeq 1.27.0 Advanced Demo ===") + let counts = tradeseq_demo_counts() + let (pseudotime, weights) = tradeseq_demo_trajectory() + let gene_names = ["flat", "association", "endpoint", "early", "zero"] + let config = tradeseq_demo_config() + let fit = @bio.tradeseq_fit_advanced( + counts, + pseudotime, + weights, + gene_names~, + lineage_names=["left", "right"], + offsets=Array::make(24, 0.0), + config~, + ) catch { + _ => abort("tradeSeq NB-GAM fitting failed") + } + + println("\n1. Multi-lineage negative-binomial GAM") + println(@bio.tradeseq_advanced_summary(fit)) + for model in fit.models { + println( + " " + + model.gene_id + + ": dispersion=" + + model.dispersion.to_string() + + ", AIC=" + + model.aic.to_string() + + ", converged=" + + model.converged.to_string(), + ) + } + + println("\n2. Trajectory Wald tests with BH-FDR") + let association = @bio.tradeseq_association_test_advanced(fit) catch { + _ => abort("associationTest failed") + } + let start_end = @bio.tradeseq_start_vs_end_test_advanced(fit) catch { + _ => abort("startVsEndTest failed") + } + let diff_end = @bio.tradeseq_diff_end_test_advanced(fit) catch { + _ => abort("diffEndTest failed") + } + let pattern = @bio.tradeseq_pattern_test_advanced(fit, n_points=5) catch { + _ => abort("patternTest failed") + } + let early = @bio.tradeseq_early_de_test_advanced(fit, 0.35, 0.75, n_points=5) catch { + _ => abort("earlyDETest failed") + } + tradeseq_demo_print_test(association) + tradeseq_demo_print_test(start_end) + tradeseq_demo_print_test(diff_end) + tradeseq_demo_print_test(pattern) + tradeseq_demo_print_test(early) + + let prediction = @bio.tradeseq_predict_smooth_advanced( + fit, + "endpoint", + n_points=8, + ) catch { + _ => abort("smooth prediction failed") + } + println("\n3. Smooth prediction with delta-method uncertainty") + for lineage in 0.. abort("knot evaluation failed") + } + println("\n4. AIC knot evaluation") + for index in 0.. abort("Slingshot to tradeSeq integration failed") + } + println("\n5. Direct Slingshot integration") + println( + " " + + slingshot_fit.n_cells.to_string() + + " cells, lineages=" + + slingshot_fit.lineage_names.join(","), + ) + + let cell_names : Array[String] = [] + for cell in 0..<24 { + cell_names.push("cell" + (cell + 1).to_string()) + } + let experiment = @bio.SingleCellExperiment::new( + counts, gene_names, cell_names, + ) + experiment.reduced_dims["slingshot.pseudotime"] = pseudotime + experiment.reduced_dims["slingshot.weights"] = weights + let sce_output = @bio.tradeseq_advanced_sce(experiment, config~) catch { + _ => abort("SingleCellExperiment tradeSeq integration failed") + } + println("\n6. Immutable SingleCellExperiment write-back") + println( + " fitted assay: " + + sce_output.experiment.assays["tradeSeq.fitted"].length().to_string() + + " genes x " + + sce_output.experiment.assays["tradeSeq.fitted"][0].length().to_string() + + " cells", + ) + println( + " original unchanged: " + + (!experiment.assays.contains("tradeSeq.fitted")).to_string(), + ) +} diff --git a/examples/tradeseq_advanced_demo/moon.pkg b/examples/tradeseq_advanced_demo/moon.pkg new file mode 100644 index 00000000..4ecfd216 --- /dev/null +++ b/examples/tradeseq_advanced_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src" @bio, +} + +pkgtype(kind: "executable") diff --git a/src/bluster.mbt b/src/bluster.mbt new file mode 100644 index 00000000..011c684b --- /dev/null +++ b/src/bluster.mbt @@ -0,0 +1,1931 @@ +///| +/// Portable clustering and diagnostics inspired by Bioconductor bluster 1.23.0. +/// All input matrices use observation x variable orientation. + +///| +pub suberror BlusterError { + BlusterError(String) +} + +///| +pub enum BlusterDistance { + BlusterEuclidean + BlusterManhattan + BlusterCosine +} derive(Eq, Debug) + +///| +pub enum BlusterSnnWeight { + BlusterRank + BlusterNumber + BlusterJaccard +} derive(Eq, Debug) + +///| +pub enum BlusterLinkDenominator { + BlusterLinkMinimum + BlusterLinkMaximum + BlusterLinkUnion +} derive(Eq, Debug) + +///| +pub fn bluster_euclidean_distance() -> BlusterDistance { + BlusterEuclidean +} + +///| +pub fn bluster_manhattan_distance() -> BlusterDistance { + BlusterManhattan +} + +///| +pub fn bluster_cosine_distance() -> BlusterDistance { + BlusterCosine +} + +///| +pub fn bluster_rank_weight() -> BlusterSnnWeight { + BlusterRank +} + +///| +pub fn bluster_number_weight() -> BlusterSnnWeight { + BlusterNumber +} + +///| +pub fn bluster_jaccard_weight() -> BlusterSnnWeight { + BlusterJaccard +} + +///| +pub fn bluster_link_minimum() -> BlusterLinkDenominator { + BlusterLinkMinimum +} + +///| +pub fn bluster_link_maximum() -> BlusterLinkDenominator { + BlusterLinkMaximum +} + +///| +pub fn bluster_link_union() -> BlusterLinkDenominator { + BlusterLinkUnion +} + +///| +pub struct BlusterGraph { + weights : Array[Array[Double]] + directed : Bool + k : Int + graph_kind : String +} derive(Debug) + +///| +pub fn BlusterGraph::node_count(self : BlusterGraph) -> Int { + self.weights.length() +} + +///| +pub fn BlusterGraph::edge_weight( + self : BlusterGraph, + left : Int, + right : Int, +) -> Double { + self.weights[left][right] +} + +///| +pub fn BlusterGraph::edge_count(self : BlusterGraph) -> Int { + let mut output = 0 + for left in 0.. 0.0 { + output = output + 1 + } + } + } + output +} + +///| +pub struct BlusterKmeansConfig { + centers : Int + max_iterations : Int + starts : Int + tolerance : Double + seed : Int +} derive(Eq, Debug) + +///| +pub fn BlusterKmeansConfig::create( + centers : Int, + max_iterations? : Int = 100, + starts? : Int = 10, + tolerance? : Double = 1.0e-8, + seed? : Int = 1, +) -> BlusterKmeansConfig raise BlusterError { + if centers <= 0 { + bluster_fail("bluster k-means centers must be positive") + } + if max_iterations <= 0 { + bluster_fail("bluster k-means max_iterations must be positive") + } + if starts <= 0 { + bluster_fail("bluster k-means starts must be positive") + } + if !bluster_is_finite(tolerance) || tolerance < 0.0 { + bluster_fail("bluster k-means tolerance must be finite and non-negative") + } + if seed <= 0 { + bluster_fail("bluster random seed must be positive") + } + BlusterKmeansConfig::{ centers, max_iterations, starts, tolerance, seed } +} + +///| +pub struct BlusterKmeansResult { + clusters : Array[Int] + centers : Array[Array[Double]] + within_sum_squares : Array[Double] + total_within_sum_squares : Double + iterations : Int +} derive(Debug) + +///| +pub struct BlusterGraphConfig { + k : Int + shared : Bool + snn_weight : BlusterSnnWeight + distance : BlusterDistance + resolution : Double + max_iterations : Int + seed : Int +} derive(Eq, Debug) + +///| +pub fn BlusterGraphConfig::create( + k? : Int = 10, + shared? : Bool = true, + snn_weight? : BlusterSnnWeight = BlusterRank, + distance? : BlusterDistance = BlusterEuclidean, + resolution? : Double = 1.0, + max_iterations? : Int = 100, + seed? : Int = 1, +) -> BlusterGraphConfig raise BlusterError { + if k <= 0 { + bluster_fail("bluster graph k must be positive") + } + if !bluster_is_finite(resolution) || resolution <= 0.0 { + bluster_fail("bluster graph resolution must be finite and positive") + } + if max_iterations <= 0 { + bluster_fail("bluster graph max_iterations must be positive") + } + if seed <= 0 { + bluster_fail("bluster random seed must be positive") + } + BlusterGraphConfig::{ + k, + shared, + snn_weight, + distance, + resolution, + max_iterations, + seed, + } +} + +///| +pub struct BlusterGraphClusterResult { + clusters : Array[Int] + graph : BlusterGraph + modularity : Double + iterations : Int +} derive(Debug) + +///| +pub struct BlusterTwoStepConfig { + first_centers : Int + first_starts : Int + first_max_iterations : Int + second_k : Int + snn_weight : BlusterSnnWeight + distance : BlusterDistance + resolution : Double + second_max_iterations : Int + seed : Int +} derive(Eq, Debug) + +///| +pub fn BlusterTwoStepConfig::create( + first_centers? : Int = 0, + first_starts? : Int = 5, + first_max_iterations? : Int = 100, + second_k? : Int = 10, + snn_weight? : BlusterSnnWeight = BlusterRank, + distance? : BlusterDistance = BlusterEuclidean, + resolution? : Double = 1.0, + second_max_iterations? : Int = 100, + seed? : Int = 1, +) -> BlusterTwoStepConfig raise BlusterError { + if first_centers < 0 { + bluster_fail("bluster two-step first_centers cannot be negative") + } + if first_starts <= 0 || + first_max_iterations <= 0 || + second_k <= 0 || + second_max_iterations <= 0 { + bluster_fail( + "bluster two-step iteration, start and k values must be positive", + ) + } + if !bluster_is_finite(resolution) || resolution <= 0.0 { + bluster_fail("bluster two-step resolution must be finite and positive") + } + if seed <= 0 { + bluster_fail("bluster random seed must be positive") + } + BlusterTwoStepConfig::{ + first_centers, + first_starts, + first_max_iterations, + second_k, + snn_weight, + distance, + resolution, + second_max_iterations, + seed, + } +} + +///| +pub struct BlusterTwoStepResult { + clusters : Array[Int] + first : BlusterKmeansResult + centroids : Array[Array[Double]] + centroid_clusters : Array[Int] + graph : BlusterGraph + modularity : Double +} derive(Debug) + +///| +pub struct BlusterRandResult { + cluster_names : Array[Int] + correct : Array[Array[Double?]] + totals : Array[Array[Double?]] + ratios : Array[Array[Double?]] + index : Double? + adjusted : Bool +} derive(Debug) + +///| +pub struct BlusterSilhouetteResult { + clusters : Array[Int] + other_clusters : Array[Int] + widths : Array[Double] +} derive(Debug) + +///| +pub struct BlusterClusterMetric { + cluster_names : Array[Int] + values : Array[Double?] +} derive(Debug) + +///| +pub struct BlusterPurityResult { + purity : Array[Double] + maximum_clusters : Array[Int] + radius : Double +} derive(Debug) + +///| +pub struct BlusterModularityResult { + cluster_names : Array[Int] + observed : Array[Array[Double?]] + expected : Array[Array[Double?]] + modularity : Array[Array[Double?]] + ratios : Array[Array[Double?]] + total_weight : Double +} derive(Debug) + +///| +pub struct BlusterNestedResult { + reference_names : Array[Int] + alternative_names : Array[Int] + proportions : Array[Array[Double]] + alternative_mapping : Array[Int] + alternative_maximum : Array[Double] + reference_scores : Array[Double] +} derive(Debug) + +///| +pub struct BlusterStabilityResult { + cluster_names : Array[Int] + ratios : Array[Array[Double?]] + adjusted_indices : Array[Double?] +} derive(Debug) + +///| +pub struct BlusterSceOutput { + experiment : SingleCellExperiment + clustering : BlusterGraphClusterResult +} + +///| +fn bluster_fail(message : String) -> Unit raise BlusterError { + raise BlusterError::BlusterError(message) +} + +///| +fn bluster_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn bluster_matrix_shape( + data : Array[Array[Double]], + allow_empty? : Bool = false, +) -> (Int, Int) raise BlusterError { + let observations = data.length() + if observations == 0 { + if allow_empty { + return (0, 0) + } + bluster_fail("bluster data must contain at least one observation") + } + let variables = data[0].length() + if variables == 0 && !allow_empty { + bluster_fail("bluster data must contain at least one variable") + } + for row in data { + if row.length() != variables { + bluster_fail("bluster data must be rectangular") + } + for value in row { + if !bluster_is_finite(value) { + bluster_fail("bluster data must contain only finite values") + } + } + } + (observations, variables) +} + +///| +fn bluster_validate_labels( + labels : Array[Int], + expected : Int, +) -> Unit raise BlusterError { + if labels.length() != expected { + bluster_fail("bluster cluster labels must match the number of observations") + } +} + +///| +fn bluster_copy_matrix(data : Array[Array[Double]]) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in data { + output.push(row.copy()) + } + output +} + +///| +fn bluster_double_matrix( + rows : Int, + columns : Int, + value : Double, +) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for _ in 0.. Array[Array[Int]] { + let output : Array[Array[Int]] = [] + for _ in 0.. Array[Array[Double?]] { + let output : Array[Array[Double?]] = [] + for _ in 0.. SingleCellExperiment { + let assays : Map[String, Array[Array[Double]]] = Map([]) + for key in source.assays.keys() { + assays[key] = bluster_copy_matrix(source.assays[key]) + } + let row_data : Map[String, Array[String]] = Map([]) + for key in source.row_data.keys() { + row_data[key] = source.row_data[key].copy() + } + let col_data : Map[String, Array[String]] = Map([]) + for key in source.col_data.keys() { + col_data[key] = source.col_data[key].copy() + } + let reduced_dims : Map[String, Array[Array[Double]]] = Map([]) + for key in source.reduced_dims.keys() { + reduced_dims[key] = bluster_copy_matrix(source.reduced_dims[key]) + } + let alternatives : Map[String, SingleCellExperiment] = Map([]) + for key in source.alternative_experiments.keys() { + alternatives[key] = bluster_copy_sce(source.alternative_experiments[key]) + } + let metadata : Map[String, String] = Map([]) + for key in source.metadata.keys() { + metadata[key] = source.metadata[key] + } + SingleCellExperiment::{ + assays, + row_data, + col_data, + reduced_dims, + alternative_experiments: alternatives, + metadata, + row_names: source.row_names.copy(), + col_names: source.col_names.copy(), + } +} + +///| +fn bluster_lcg(state : Int) -> (Int, Double) { + let normalized = (state - 1) % 2147483646 + 1 + let quotient = normalized / 44488 + let remainder = normalized % 44488 + let candidate = 48271 * remainder - 3399 * quotient + let next = if candidate > 0 { candidate } else { candidate + 2147483647 } + (next, next.to_double() / 2147483647.0) +} + +///| +fn bluster_distance_value( + left : Array[Double], + right : Array[Double], + distance_kind : BlusterDistance, +) -> Double { + match distance_kind { + BlusterEuclidean => { + let mut total = 0.0 + for variable in 0.. { + let mut total = 0.0 + for variable in 0.. { + let mut product = 0.0 + let mut left_norm = 0.0 + let mut right_norm = 0.0 + for variable in 0.. -1.0e-12 { + 0.0 + } else { + raw + } + } + } + } +} + +///| +fn bluster_squared_euclidean( + left : Array[Double], + right : Array[Double], +) -> Double { + let mut output = 0.0 + for variable in 0.. Array[Int] { + let output : Array[Int] = [] + for label in labels { + let mut present = false + for existing in output { + if existing == label { + present = true + break + } + } + if !present { + let mut position = output.length() + while position > 0 && output[position - 1] > label { + position = position - 1 + } + output.push(label) + let mut index = output.length() - 1 + while index > position { + output[index] = output[index - 1] + index = index - 1 + } + output[position] = label + } + } + output +} + +///| +fn bluster_label_position(labels : Array[Int], target : Int) -> Int { + for index in 0.. Array[Int] { + let names = bluster_sorted_unique(clusters) + clusters.map(fn(label) { bluster_label_position(names, label) }) +} + +///| +fn bluster_neighbor_lists( + data : Array[Array[Double]], + k : Int, + distance_kind : BlusterDistance, +) -> (Array[Array[Int]], Array[Array[Double]]) { + let observations = data.length() + let effective_k = k.min((observations - 1).max(0)) + let indices : Array[Array[Int]] = [] + let distances : Array[Array[Double]] = [] + for observation in 0.. 0 && + ( + candidates[position - 1].0 > value.0 || + ( + candidates[position - 1].0 == value.0 && + candidates[position - 1].1 > value.1 + ) + ) { + candidates[position] = candidates[position - 1] + position = position - 1 + } + candidates[position] = value + } + let local_indices : Array[Int] = [] + let local_distances : Array[Double] = [] + for position in 0.. Int { + if observation == target { + return 0 + } + for position in 0.. BlusterGraph raise BlusterError { + let (observations, _) = bluster_matrix_shape(data) + if k <= 0 { + bluster_fail("bluster SNN k must be positive") + } + let effective_k = k.min((observations - 1).max(0)) + let (neighbors, _) = bluster_neighbor_lists(data, effective_k, distance) + let weights = bluster_double_matrix(observations, observations, 0.0) + for left in 0..= 0 { + let right_rank = bluster_neighbor_rank( + right, + candidate, + neighbors[right], + ) + if right_rank >= 0 { + shared = shared + 1 + let score = effective_k.to_double() - + (left_rank + right_rank).to_double() / 2.0 + if score > rank_weight { + rank_weight = score + } + } + } + } + if shared > 0 { + let weight = match weighting { + BlusterRank => rank_weight.max(1.0e-6) + BlusterNumber => shared.to_double() + BlusterJaccard => { + let union = 2 * (effective_k + 1) - shared + shared.to_double() / union.to_double() + } + } + weights[left][right] = weight + weights[right][left] = weight + } + } + } + BlusterGraph::{ weights, directed: false, k: effective_k, graph_kind: "SNN" } +} + +///| +pub fn bluster_make_knn_graph( + data : Array[Array[Double]], + k? : Int = 10, + directed? : Bool = false, + distance? : BlusterDistance = BlusterEuclidean, +) -> BlusterGraph raise BlusterError { + let (observations, _) = bluster_matrix_shape(data) + if k <= 0 { + bluster_fail("bluster KNN k must be positive") + } + let effective_k = k.min((observations - 1).max(0)) + let (neighbors, _) = bluster_neighbor_lists(data, effective_k, distance) + let weights = bluster_double_matrix(observations, observations, 0.0) + for observation in 0.. (Array[Array[Double]], Int) { + let observations = data.length() + let selected = Array::make(observations, false) + let output : Array[Array[Double]] = [] + let mut state = seed + let (next, first_uniform) = bluster_lcg(state) + state = next + let first = (first_uniform * observations.to_double()) + .to_int() + .min(observations - 1) + output.push(data[first].copy()) + selected[first] = true + while output.length() < centers { + let nearest = Array::make(observations, 0.0) + let mut total = 0.0 + for observation in 0.. 0.0 { + let (following, uniform) = bluster_lcg(state) + state = following + let target = uniform * total + let mut cumulative = 0.0 + for observation in 0..= target && !selected[observation] { + chosen = observation + } + } + } + if chosen < 0 { + for observation in 0.. Array[Int] { + let output = Array::make(data.length(), 0) + for observation in 0.. Array[Array[Double]] { + let centers = previous.length() + let variables = data[0].length() + let output = bluster_double_matrix(centers, variables, 0.0) + let sizes = Array::make(centers, 0) + for observation in 0.. 0 { + for variable in 0.. (Array[Double], Double) { + let within = Array::make(centers.length(), 0.0) + let mut total = 0.0 + for observation in 0.. BlusterKmeansResult { + let (initial, _) = bluster_initialize_centers(data, config.centers, seed) + let mut centers = initial + let mut clusters = Array::make(data.length(), 0) + let mut iterations = 0 + for iteration in 0.. maximum_shift { + maximum_shift = shift + } + } + centers = updated + iterations = iteration + 1 + if maximum_shift <= config.tolerance { + break + } + } + clusters = bluster_assign_centers(data, centers) + let (within, total) = bluster_kmeans_statistics(data, clusters, centers) + BlusterKmeansResult::{ + clusters, + centers, + within_sum_squares: within, + total_within_sum_squares: total, + iterations, + } +} + +///| +pub fn bluster_cluster_rows_kmeans( + data : Array[Array[Double]], + config : BlusterKmeansConfig, +) -> BlusterKmeansResult raise BlusterError { + let (observations, _) = bluster_matrix_shape(data) + if config.centers > observations { + bluster_fail("bluster k-means centers cannot exceed observations") + } + let mut best : BlusterKmeansResult? = None + for start in 0.. best = Some(candidate) + Some(current) => + if candidate.total_within_sum_squares < current.total_within_sum_squares { + best = Some(candidate) + } + } + } + match best { + Some(output) => output + None => { + bluster_fail("bluster k-means did not produce a result") + bluster_kmeans_once(data, config, config.seed) + } + } +} + +///| +fn bluster_undirected_weight( + graph : BlusterGraph, + left : Int, + right : Int, +) -> Double { + if graph.directed { + graph.weights[left][right] + graph.weights[right][left] + } else { + graph.weights[left][right] + } +} + +///| +fn bluster_graph_total_weight(graph : BlusterGraph) -> Double { + let mut total = 0.0 + for left in 0.. Double { + let observations = graph.weights.length() + let total = bluster_graph_total_weight(graph) + if total <= 0.0 { + return 0.0 + } + let strengths = Array::make(observations, 0.0) + for left in 0.. (Array[Int], Int) { + let output = Array::make(length, 0) + for index in 0.. 0 { + let (next, uniform) = bluster_lcg(state) + state = next + let selected = (uniform * (position + 1).to_double()).to_int().min(position) + let temporary = output[position] + output[position] = output[selected] + output[selected] = temporary + position = position - 1 + } + (output, state) +} + +///| +fn bluster_louvain( + graph : BlusterGraph, + resolution : Double, + max_iterations : Int, + seed : Int, +) -> (Array[Int], Double, Int) { + let observations = graph.weights.length() + let clusters = Array::make(observations, 0) + for observation in 0.. 0.0 { + let candidate = clusters[other] + let mut present = false + for existing in candidates { + if existing == candidate { + present = true + break + } + } + if !present { + candidates.push(candidate) + } + } + } + let mut best_cluster = original + let mut best_modularity = current_modularity + for candidate in candidates { + if candidate != original { + clusters[observation] = candidate + let value = bluster_global_modularity(graph, clusters, resolution) + if value > best_modularity + 1.0e-12 || + ( + (value - best_modularity).abs() <= 1.0e-12 && + candidate < best_cluster + ) { + best_modularity = value + best_cluster = candidate + } + } + } + clusters[observation] = best_cluster + if best_cluster != original { + changed = true + current_modularity = best_modularity + } + } + completed = iteration + 1 + if !changed { + break + } + } + let relabeled = bluster_relabel(clusters) + ( + relabeled, + bluster_global_modularity(graph, relabeled, resolution), + completed, + ) +} + +///| +pub fn bluster_cluster_rows_graph( + data : Array[Array[Double]], + config : BlusterGraphConfig, +) -> BlusterGraphClusterResult raise BlusterError { + ignore(bluster_matrix_shape(data)) + let graph = if config.shared { + bluster_make_snn_graph( + data, + k=config.k, + weighting=config.snn_weight, + distance=config.distance, + ) + } else { + bluster_make_knn_graph( + data, + k=config.k, + directed=false, + distance=config.distance, + ) + } + let (clusters, modularity, iterations) = bluster_louvain( + graph, + config.resolution, + config.max_iterations, + config.seed, + ) + BlusterGraphClusterResult::{ clusters, graph, modularity, iterations } +} + +///| +pub fn bluster_cluster_rows_two_step( + data : Array[Array[Double]], + config : BlusterTwoStepConfig, +) -> BlusterTwoStepResult raise BlusterError { + let (observations, _) = bluster_matrix_shape(data) + let automatic = observations.to_double().sqrt().round().to_int().max(1) + let first_centers = (if config.first_centers == 0 { + automatic + } else { + config.first_centers + }).min(observations) + let first_config = BlusterKmeansConfig::create( + first_centers, + max_iterations=config.first_max_iterations, + starts=config.first_starts, + seed=config.seed, + ) + let first = bluster_cluster_rows_kmeans(data, first_config) + let centroids = bluster_copy_matrix(first.centers) + let second_config = BlusterGraphConfig::create( + k=config.second_k, + shared=true, + snn_weight=config.snn_weight, + distance=config.distance, + resolution=config.resolution, + max_iterations=config.second_max_iterations, + seed=config.seed, + ) + let second = bluster_cluster_rows_graph(first.centers, second_config) + let clusters = first.clusters.map(fn(cluster) { second.clusters[cluster] }) + BlusterTwoStepResult::{ + clusters: bluster_relabel(clusters), + first, + centroids, + centroid_clusters: second.clusters, + graph: second.graph, + modularity: second.modularity, + } +} + +///| +fn bluster_choose_two(value : Int) -> Double { + if value < 2 { + 0.0 + } else { + value.to_double() * (value - 1).to_double() / 2.0 + } +} + +///| +fn bluster_pairwise_rand_levels( + reference : Array[Int], + alternative : Array[Int], + levels : Array[Int], + adjusted : Bool, +) -> BlusterRandResult raise BlusterError { + if reference.length() != alternative.length() { + bluster_fail("bluster Rand inputs must have equal lengths") + } + let cluster_count = levels.length() + let correct = bluster_optional_double_matrix(cluster_count, cluster_count) + let totals = bluster_optional_double_matrix(cluster_count, cluster_count) + let ratios = bluster_optional_double_matrix(cluster_count, cluster_count) + let alternative_names = bluster_sorted_unique(alternative) + let reference_sizes = Array::make(cluster_count, 0) + let alternative_sizes = Array::make(alternative_names.length(), 0) + let table = bluster_int_matrix(cluster_count, alternative_names.length(), 0) + for observation in 0..= 0 { + reference_sizes[reference_position] = reference_sizes[reference_position] + + 1 + if alternative_position >= 0 { + table[reference_position][alternative_position] = table[reference_position][alternative_position] + + 1 + } + } + if alternative_position >= 0 { + alternative_sizes[alternative_position] = alternative_sizes[alternative_position] + + 1 + } + } + let all_pairs = bluster_choose_two(reference.length()) + let mut same_alternative = 0.0 + for size in alternative_sizes { + same_alternative = same_alternative + bluster_choose_two(size) + } + let same_probability = if all_pairs > 0.0 { + same_alternative / all_pairs + } else { + 0.0 + } + let mut index_correct = 0.0 + let mut index_total = 0.0 + for right in 0.. 1.0e-15 { + ratios[left][right] = Some(adjusted_correct / adjusted_total) + index_correct = index_correct + adjusted_correct + index_total = index_total + adjusted_total + } + } + } + let index = if index_total.abs() > 1.0e-15 { + Some(index_correct / index_total) + } else { + None + } + BlusterRandResult::{ + cluster_names: levels.copy(), + correct, + totals, + ratios, + index, + adjusted, + } +} + +///| +pub fn bluster_pairwise_rand( + reference : Array[Int], + alternative : Array[Int], + adjusted? : Bool = true, +) -> BlusterRandResult raise BlusterError { + bluster_pairwise_rand_levels( + reference, + alternative, + bluster_sorted_unique(reference), + adjusted, + ) +} + +///| +pub fn bluster_compare_clusterings( + clusterings : Array[Array[Int]], + adjusted? : Bool = true, +) -> Array[Array[Double?]] raise BlusterError { + if clusterings.length() == 0 { + return [] + } + let observations = clusterings[0].length() + for clustering in clusterings { + if clustering.length() != observations { + bluster_fail("bluster clusterings must have equal lengths") + } + } + let output = bluster_optional_double_matrix( + clusterings.length(), + clusterings.length(), + ) + for left in 0.. BlusterSilhouetteResult raise BlusterError { + let (observations, variables) = bluster_matrix_shape(data) + bluster_validate_labels(clusters, observations) + let names = bluster_sorted_unique(clusters) + let centroids = bluster_double_matrix(names.length(), variables, 0.0) + let sizes = Array::make(names.length(), 0) + for observation in 0.. 0.0 { + (other_distance - self_distance) / denominator + } else { + 0.0 + } + } + } + BlusterSilhouetteResult::{ clusters: clusters.copy(), other_clusters, widths } +} + +///| +pub fn bluster_cluster_rmsd( + data : Array[Array[Double]], + clusters : Array[Int], + sum_squares? : Bool = false, +) -> BlusterClusterMetric raise BlusterError { + let (observations, variables) = bluster_matrix_shape(data, allow_empty=true) + bluster_validate_labels(clusters, observations) + let names = bluster_sorted_unique(clusters) + let values : Array[Double?] = Array::make(names.length(), None) + for cluster in 0..= 2 { + let means = Array::make(variables, 0.0) + for observation in indices { + for variable in 0.. Double { + if values.length() == 0 { + return 0.0 + } + let sorted = values.copy() + for current in 1.. 0 && sorted[position - 1] > value { + sorted[position] = sorted[position - 1] + position = position - 1 + } + sorted[position] = value + } + if sorted.length() % 2 == 1 { + sorted[sorted.length() / 2] + } else { + (sorted[sorted.length() / 2 - 1] + sorted[sorted.length() / 2]) / 2.0 + } +} + +///| +pub fn bluster_neighbor_purity( + data : Array[Array[Double]], + clusters : Array[Int], + k? : Int = 50, + balanced? : Bool = true, + custom_weights? : Array[Double]? = None, + distance? : BlusterDistance = BlusterEuclidean, +) -> BlusterPurityResult raise BlusterError { + let (observations, _) = bluster_matrix_shape(data) + bluster_validate_labels(clusters, observations) + if k <= 0 { + bluster_fail("bluster neighbor purity k must be positive") + } + let effective_k = k.min((observations - 1).max(0)) + let (_, neighbor_distances) = bluster_neighbor_lists( + data, effective_k, distance, + ) + let kth : Array[Double] = [] + if effective_k > 0 { + for neighbor_row in neighbor_distances { + kth.push(neighbor_row[effective_k - 1]) + } + } + let radius = bluster_median(kth) + let names = bluster_sorted_unique(clusters) + let sizes = Array::make(names.length(), 0) + for label in clusters { + let position = bluster_label_position(names, label) + sizes[position] = sizes[position] + 1 + } + let weights = Array::make(observations, 1.0) + match custom_weights { + Some(given) => { + if given.length() != observations { + bluster_fail("bluster custom purity weights must match observations") + } + for observation in 0.. + if balanced { + for observation in 0.. totals[maximum] { + maximum = position + } + } + purity[observation] = if total > 0.0 { totals[own] / total } else { 0.0 } + maximum_clusters[observation] = names[maximum] + } + BlusterPurityResult::{ purity, maximum_clusters, radius } +} + +///| +pub fn bluster_pairwise_modularity( + graph : BlusterGraph, + clusters : Array[Int], +) -> BlusterModularityResult raise BlusterError { + let observations = graph.weights.length() + bluster_validate_labels(clusters, observations) + let names = bluster_sorted_unique(clusters) + let cluster_count = names.length() + let observed = bluster_optional_double_matrix(cluster_count, cluster_count) + let expected = bluster_optional_double_matrix(cluster_count, cluster_count) + let modularity = bluster_optional_double_matrix(cluster_count, cluster_count) + let ratios = bluster_optional_double_matrix(cluster_count, cluster_count) + let total_weight = bluster_graph_total_weight(graph) + let strengths = Array::make(cluster_count, 0.0) + for observation in 0.. 0.0 { + if left == right { + strengths[left] * strengths[right] / (4.0 * total_weight) + } else { + strengths[left] * strengths[right] / (2.0 * total_weight) + } + } else { + 0.0 + } + observed[left][right] = Some(actual) + expected[left][right] = Some(null_weight) + modularity[left][right] = if total_weight > 0.0 { + Some((actual - null_weight) / total_weight) + } else { + None + } + ratios[left][right] = if null_weight > 0.0 { + Some(actual / null_weight) + } else { + None + } + } + } + BlusterModularityResult::{ + cluster_names: names, + observed, + expected, + modularity, + ratios, + total_weight, + } +} + +///| +pub fn bluster_merge_communities( + graph : BlusterGraph, + clusters : Array[Int], + number : Int, +) -> Array[Int] raise BlusterError { + bluster_validate_labels(clusters, graph.weights.length()) + if number <= 0 { + bluster_fail("bluster merged community number must be positive") + } + let output = clusters.copy() + while bluster_sorted_unique(output).length() > number { + let names = bluster_sorted_unique(output) + let mut best_labels = output.copy() + let mut best_modularity = -1.0e300 + for left in 0.. best_modularity { + best_modularity = value + best_labels = candidate + } + } + } + for observation in 0.. BlusterNestedResult raise BlusterError { + if reference.length() != alternative.length() { + bluster_fail("bluster nested clusterings must have equal lengths") + } + let reference_names = bluster_sorted_unique(reference) + let alternative_names = bluster_sorted_unique(alternative) + let table = bluster_int_matrix( + alternative_names.length(), + reference_names.length(), + 0, + ) + for observation in 0.. 0 { + reference_names[0] + } else { + 0 + }, + ) + let alternative_maximum = Array::make(alternative_names.length(), 0.0) + for alternative_position in 0.. 0 { + table[alternative_position][reference_position].to_double() / + total.to_double() + } else { + 0.0 + } + if proportions[alternative_position][reference_position] > + proportions[alternative_position][maximum] { + maximum = reference_position + } + } + if reference_names.length() > 0 { + alternative_mapping[alternative_position] = reference_names[maximum] + alternative_maximum[alternative_position] = proportions[alternative_position][maximum] + } + } + let reference_scores = Array::make(reference_names.length(), 0.0) + for reference_position in 0.. 0 { + numerator / denominator.to_double() + } else { + 0.0 + } + } + BlusterNestedResult::{ + reference_names, + alternative_names, + proportions, + alternative_mapping, + alternative_maximum, + reference_scores, + } +} + +///| +pub fn bluster_link_clusters_matrix( + left : Array[Int], + right : Array[Int], + denominator? : BlusterLinkDenominator = BlusterLinkUnion, +) -> Array[Array[Double]] raise BlusterError { + if left.length() != right.length() { + bluster_fail("bluster linked clusterings must have equal lengths") + } + let left_names = bluster_sorted_unique(left) + let right_names = bluster_sorted_unique(right) + let left_sizes = Array::make(left_names.length(), 0) + let right_sizes = Array::make(right_names.length(), 0) + let overlap = bluster_int_matrix(left_names.length(), right_names.length(), 0) + for observation in 0.. + left_sizes[left_position].min(right_sizes[right_position]) + BlusterLinkMaximum => + left_sizes[left_position].max(right_sizes[right_position]) + BlusterLinkUnion => + left_sizes[left_position] + right_sizes[right_position] - common + } + output[left_position][right_position] = if scale > 0 { + common.to_double() / scale.to_double() + } else { + 0.0 + } + } + } + output +} + +///| +fn bluster_average_optional( + values : Array[Double?], + use_mean : Bool, +) -> Double? { + let retained : Array[Double] = [] + for value in values { + match value { + Some(actual) => if bluster_is_finite(actual) { retained.push(actual) } + None => () + } + } + if retained.length() == 0 { + None + } else if use_mean { + let mut total = 0.0 + for value in retained { + total = total + value + } + Some(total / retained.length().to_double()) + } else { + Some(bluster_median(retained)) + } +} + +///| +pub fn bluster_bootstrap_kmeans_stability( + data : Array[Array[Double]], + config : BlusterKmeansConfig, + iterations? : Int = 20, + use_mean? : Bool = false, + seed? : Int = 1, +) -> BlusterStabilityResult raise BlusterError { + let (observations, _) = bluster_matrix_shape(data) + if iterations <= 0 { + bluster_fail("bluster bootstrap iterations must be positive") + } + if seed <= 0 { + bluster_fail("bluster random seed must be positive") + } + let original = bluster_cluster_rows_kmeans(data, config) + let names = bluster_sorted_unique(original.clusters) + let collated : Array[Array[Array[Double?]]] = [] + let indices : Array[Double?] = [] + let mut state = seed + for iteration in 0.. BlusterSceOutput raise BlusterError { + if reduced_dim_name.length() == 0 || output_column.length() == 0 { + bluster_fail("bluster SCE names cannot be empty") + } + let coordinates = match experiment.reduced_dims.get(reduced_dim_name) { + Some(value) => value + None => { + bluster_fail( + "bluster reduced dimension '" + reduced_dim_name + "' was not found", + ) + [] + } + } + let (observations, _) = bluster_matrix_shape(coordinates) + if observations != experiment.col_names.length() { + bluster_fail("bluster reduced dimension rows must match SCE column names") + } + let clustering = bluster_cluster_rows_graph(coordinates, config) + let output = bluster_copy_sce(experiment) + output.col_data[output_column] = clustering.clusters.map(fn(cluster) { + (cluster + 1).to_string() + }) + output.metadata["bluster.reduced_dim"] = reduced_dim_name + output.metadata["bluster.graph"] = clustering.graph.graph_kind + output.metadata["bluster.modularity"] = clustering.modularity.to_string() + BlusterSceOutput::{ experiment: output, clustering } +} diff --git a/src/droplet_utils_advanced.mbt b/src/droplet_utils_advanced.mbt new file mode 100644 index 00000000..1127f6b8 --- /dev/null +++ b/src/droplet_utils_advanced.mbt @@ -0,0 +1,1679 @@ +///| +/// Advanced, portable implementation of the core DropletUtils 1.33.0 +/// emptyDrops workflow. Matrices use the Bioconductor feature x barcode +/// convention. + +///| +pub suberror DropletUtilsAdvancedError { + DropletUtilsAdvancedError(String) +} + +///| +pub struct DropletCountMatrix { + counts : Array[Array[Int]] + feature_names : Array[String] + barcodes : Array[String] +} derive(Debug) + +///| +pub struct DropletUtilsConfig { + lower : Int + iterations : Int + fdr_threshold : Double + retain : Double + by_rank : Int + ignore : Int + test_ambient : Bool + alpha : Double + estimate_alpha : Bool + rank_exclude : Int + rank_window : Double + gradient_threshold : Double + round_counts : Bool + seed : Int +} derive(Debug) + +///| +pub struct DropletAmbientProfile { + raw_counts : Array[Int] + proportions : Array[Double] + assumed_empty : Array[Bool] + lower : Int + total : Int +} derive(Debug) + +///| +pub struct DropletBarcodeRanks { + barcodes : Array[String] + ranks : Array[Double] + totals : Array[Int] + knee : Double + inflection : Double +} derive(Debug) + +///| +pub struct DropletEmptyDropsResult { + barcodes : Array[String] + totals : Array[Int] + log_probabilities : Array[Double?] + p_values : Array[Double?] + limited : Array[Bool?] + fdr : Array[Double?] + calls : Array[Bool] + always_retained : Array[Bool] + ambient : DropletAmbientProfile + lower : Int + retain : Double + alpha : Double + alpha_estimated : Bool + iterations : Int + fdr_threshold : Double +} derive(Debug) + +///| +pub struct DropletUtilsSingleCellExperimentOutput { + experiment : SingleCellExperiment + result : DropletEmptyDropsResult +} + +///| +fn dua_fail(message : String) -> Unit raise DropletUtilsAdvancedError { + raise DropletUtilsAdvancedError::DropletUtilsAdvancedError(message) +} + +///| +fn dua_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn dua_copy_int_matrix(values : Array[Array[Int]]) -> Array[Array[Int]] { + let output : Array[Array[Int]] = [] + for row in values { + output.push(row.copy()) + } + output +} + +///| +fn dua_copy_double_matrix( + values : Array[Array[Double]], +) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in values { + output.push(row.copy()) + } + output +} + +///| +fn dua_default_names(prefix : String, count : Int) -> Array[String] { + let output : Array[String] = [] + for index in 0.. Array[String] raise DropletUtilsAdvancedError { + let names = if supplied.length() == 0 { + dua_default_names(prefix, count) + } else { + if supplied.length() != count { + dua_fail( + "DropletUtils " + prefix + " names must match the matrix dimension", + ) + } + supplied.copy() + } + let seen : Map[String, Bool] = Map([]) + for name in names { + if name == "" { + dua_fail("DropletUtils " + prefix + " names cannot be empty") + } + if seen.contains(name) { + dua_fail("DropletUtils " + prefix + " names must be unique") + } + seen[name] = true + } + names +} + +///| +pub fn DropletCountMatrix::create( + counts : Array[Array[Int]], + feature_names? : Array[String] = [], + barcodes? : Array[String] = [], +) -> DropletCountMatrix raise DropletUtilsAdvancedError { + if counts.length() == 0 { + dua_fail("DropletUtils count matrix must contain at least one feature") + } + if counts[0].length() == 0 { + dua_fail("DropletUtils count matrix must contain at least one barcode") + } + let barcode_count = counts[0].length() + let copied : Array[Array[Int]] = [] + for row in counts { + if row.length() != barcode_count { + dua_fail("DropletUtils count matrix must be rectangular") + } + let output_row : Array[Int] = [] + for value in row { + if value < 0 { + dua_fail("DropletUtils counts must be non-negative integers") + } + output_row.push(value) + } + copied.push(output_row) + } + DropletCountMatrix::{ + counts: copied, + feature_names: dua_prepare_names(feature_names, counts.length(), "feature"), + barcodes: dua_prepare_names(barcodes, barcode_count, "barcode"), + } +} + +///| +pub fn DropletCountMatrix::n_features(self : DropletCountMatrix) -> Int { + self.counts.length() +} + +///| +pub fn DropletCountMatrix::n_barcodes(self : DropletCountMatrix) -> Int { + if self.counts.length() == 0 { + 0 + } else { + self.counts[0].length() + } +} + +///| +pub fn DropletCountMatrix::copy_counts( + self : DropletCountMatrix, +) -> Array[Array[Int]] { + dua_copy_int_matrix(self.counts) +} + +///| +pub fn DropletCountMatrix::barcode_totals( + self : DropletCountMatrix, +) -> Array[Int] { + let totals = Array::make(self.n_barcodes(), 0) + for feature in 0.. Array[Int] { + let totals = Array::make(self.n_features(), 0) + for feature in 0.. DropletUtilsConfig raise DropletUtilsAdvancedError { + if lower < 0 { + dua_fail("DropletUtils lower threshold must be non-negative") + } + if iterations <= 0 { + dua_fail("DropletUtils iterations must be positive") + } + if !dua_is_finite(fdr_threshold) || + fdr_threshold <= 0.0 || + fdr_threshold > 1.0 { + dua_fail("DropletUtils FDR threshold must be in (0, 1]") + } + if !dua_is_finite(retain) || (retain != -1.0 && retain <= 0.0) { + dua_fail("DropletUtils retain must be -1 for automatic or positive") + } + if by_rank < 0 { + dua_fail("DropletUtils by_rank must be non-negative") + } + if ignore < -1 { + dua_fail("DropletUtils ignore must be -1 or non-negative") + } + if !dua_is_finite(alpha) || alpha == 0.0 { + dua_fail( + "DropletUtils alpha must be negative for multinomial or positive for Dirichlet-multinomial", + ) + } + if rank_exclude < 0 { + dua_fail("DropletUtils rank exclusion must be non-negative") + } + if !dua_is_finite(rank_window) || rank_window <= 0.0 { + dua_fail("DropletUtils rank window must be positive") + } + if !dua_is_finite(gradient_threshold) { + dua_fail("DropletUtils gradient threshold must be finite") + } + if seed <= 0 { + dua_fail("DropletUtils random seed must be positive") + } + DropletUtilsConfig::{ + lower, + iterations, + fdr_threshold, + retain, + by_rank, + ignore, + test_ambient, + alpha, + estimate_alpha, + rank_exclude, + rank_window, + gradient_threshold, + round_counts, + seed, + } +} + +///| +pub fn DropletUtilsConfig::default() -> DropletUtilsConfig { + DropletUtilsConfig::{ + lower: 100, + iterations: 10000, + fdr_threshold: 0.001, + retain: -1.0, + by_rank: 0, + ignore: -1, + test_ambient: false, + alpha: -1.0, + estimate_alpha: false, + rank_exclude: 50, + rank_window: 1.0, + gradient_threshold: -1.0, + round_counts: true, + seed: 1, + } +} + +///| +fn dua_log_gamma(value : Double) -> Double { + let coefficients = [ + 0.9999999999998099, 676.5203681218851, -1259.1392167224028, 771.3234287776531, + -176.6150291621406, 12.507343278686905, -0.13857109526572012, 9.984369578019572e-6, + 1.5056327351493116e-7, + ] + if value < 0.5 { + let pi = 3.141592653589793 + return @math.ln(pi) - + @math.ln(@math.sin(pi * value).abs()) - + dua_log_gamma(1.0 - value) + } + let shifted = value - 1.0 + let mut series = coefficients[0] + for index in 1.. Double { + dua_log_gamma(value.to_double() + 1.0) +} + +///| +pub fn droplet_utils_good_turing( + counts : Array[Int], +) -> Array[Double] raise DropletUtilsAdvancedError { + if counts.length() == 0 { + dua_fail("DropletUtils Good-Turing input cannot be empty") + } + let positive : Array[Int] = [] + let mut zero_count = 0 + let mut grand_total = 0 + for count in counts { + if count < 0 { + dua_fail("DropletUtils Good-Turing counts must be non-negative") + } + grand_total = grand_total + count + if count == 0 { + zero_count = zero_count + 1 + } else { + positive.push(count) + } + } + if grand_total == 0 { + dua_fail("DropletUtils Good-Turing requires at least one count") + } + positive.sort_by(fn(left : Int, right : Int) -> Int { left - right }) + let observed : Array[Int] = [] + let frequencies : Array[Int] = [] + for count in positive { + if observed.length() == 0 || observed[observed.length() - 1] != count { + observed.push(count) + frequencies.push(1) + } else { + let last = frequencies.length() - 1 + frequencies[last] = frequencies[last] + 1 + } + } + let point_count = observed.length() + let log_observed : Array[Double] = [] + let log_z : Array[Double] = [] + for index in 0.. 1 { + let mut mean_x = 0.0 + let mut mean_y = 0.0 + for index in 0.. 1.0e-15 { + slope = cross / squares + } + } + let p_zero = if observed[0] == 1 { + frequencies[0].to_double() / grand_total.to_double() + } else { + 0.0 + } + let adjusted : Array[Double] = Array::make(point_count, 0.0) + let mut use_smoothed = false + let mut adjusted_total = 0.0 + for index in 0.. 0.0 { + (1.0 - p_zero) / adjusted_total + } else { + 0.0 + } + let lookup : Map[Int, Double] = Map([]) + for index in 0.. 0 { + p_zero / zero_count.to_double() + } else { + 0.0 + } + for index in 0.. 0 { + let pseudo_probability = (1.0 / grand_total.to_double()).min(0.5) + for index in 0.. (Array[Bool], Int) raise DropletUtilsAdvancedError { + if known_empty.length() > 0 { + if known_empty.length() != totals.length() { + dua_fail( + "DropletUtils known-empty mask must match the number of barcodes", + ) + } + let output = known_empty.copy() + let mut found = false + for value in output { + if value { + found = true + } + } + if !found { + dua_fail("DropletUtils known-empty mask must select at least one barcode") + } + return (output, lower) + } + if by_rank > 0 { + if by_rank >= totals.length() { + dua_fail("DropletUtils by_rank must be smaller than barcode count") + } + let order : Array[Int] = [] + for index in 0.. Int { + if totals[left] > totals[right] { + -1 + } else if totals[left] < totals[right] { + 1 + } else { + left - right + } + }) + let output = Array::make(totals.length(), false) + let mut actual_lower = 0 + for rank in by_rank.. actual_lower { + actual_lower = totals[index] + } + } + return (output, actual_lower) + } + let output = Array::make(totals.length(), false) + for index in 0.. DropletAmbientProfile raise DropletUtilsAdvancedError { + if lower < 0 || by_rank < 0 { + dua_fail("DropletUtils ambient thresholds must be non-negative") + } + let totals = data.barcode_totals() + let (empty, actual_lower) = dua_empty_mask( + totals, lower, by_rank, known_empty, + ) + let raw = Array::make(data.n_features(), 0) + let all_feature_totals = data.feature_totals() + let mut ambient_total = 0 + for feature in 0.. 0 { + active_indices.push(feature) + active_counts.push(raw[feature]) + } + } + let active_probabilities = droplet_utils_good_turing(active_counts) + let proportions = Array::make(data.n_features(), 0.0) + for index in 0.. Int { + let mut count = 0 + for value in self.assumed_empty { + if value { + count = count + 1 + } + } + count +} + +///| +fn dua_log10(value : Double) -> Double { + @math.ln(value) / 2.302585092994046 +} + +///| +fn dua_pow10(value : Double) -> Double { + @math.exp(value * 2.302585092994046) +} + +///| +fn dua_interpolate_curve( + target : Double, + cumulative : Array[Double], + step : Array[Double], + x : Array[Double], + y : Array[Double], +) -> (Double, Double) { + let mut left = 0 + while left + 1 < cumulative.length() && cumulative[left + 1] < target { + left = left + 1 + } + if left + 1 >= cumulative.length() { + return (x[x.length() - 1], y[y.length() - 1]) + } + let proportion = if step[left + 1] > 0.0 { + (target - cumulative[left]) / step[left + 1] + } else { + 0.0 + } + ( + x[left] + proportion * (x[left + 1] - x[left]), + y[left] + proportion * (y[left + 1] - y[left]), + ) +} + +///| +pub fn droplet_utils_barcode_ranks( + data : DropletCountMatrix, + lower? : Int = 100, + exclude_from? : Int = 50, + window? : Double = 1.0, + gradient_threshold? : Double = -1.0, +) -> DropletBarcodeRanks raise DropletUtilsAdvancedError { + if lower < 0 || exclude_from < 0 { + dua_fail("DropletUtils barcode-rank thresholds must be non-negative") + } + if !dua_is_finite(window) || window <= 0.0 { + dua_fail("DropletUtils barcode-rank window must be positive") + } + if !dua_is_finite(gradient_threshold) { + dua_fail("DropletUtils barcode-rank gradient must be finite") + } + let totals = data.barcode_totals() + let order : Array[Int] = [] + for index in 0.. Int { + if totals[left] > totals[right] { + -1 + } else if totals[left] < totals[right] { + 1 + } else { + left - right + } + }) + let ranks = Array::make(totals.length(), 0.0) + let run_totals : Array[Int] = [] + let run_ranks : Array[Double] = [] + let mut position = 0 + while position < order.length() { + let start = position + let current_total = totals[order[position]] + while position < order.length() && totals[order[position]] == current_total { + position = position + 1 + } + let length = position - start + let mid_rank = start.to_double() + (length + 1).to_double() / 2.0 + run_totals.push(current_total) + run_ranks.push(mid_rank) + for sorted_position in start.. lower && run_ranks[run] > exclude_from.to_double() { + x.push(dua_log10(run_ranks[run])) + y.push(dua_log10(run_totals[run].to_double())) + } + } + if x.length() < 2 { + dua_fail( + "DropletUtils has insufficient unique points for knee/inflection detection", + ) + } + let step = Array::make(x.length(), 0.0) + let cumulative = Array::make(x.length(), 0.0) + for index in 1.. 0 { + let left_x : Array[Double] = [] + let right_x : Array[Double] = [] + let right_y : Array[Double] = [] + let mid_x : Array[Double] = [] + let mid_y : Array[Double] = [] + let gaps : Array[Double] = [] + let gradients : Array[Double] = [] + let mid_above : Array[Bool] = [] + for scan_index in scan { + let lx = x[scan_index] + let ly = y[scan_index] + let (rx, ry) = dua_interpolate_curve( + cumulative[scan_index] + window, + cumulative, + step, + x, + y, + ) + let (mx, my) = dua_interpolate_curve( + cumulative[scan_index] + window / 2.0, + cumulative, + step, + x, + y, + ) + let gradient = (ry - ly) / (rx - lx) + let intercept = ry - gradient * rx + let dx = lx - rx + let dy = ly - ry + left_x.push(lx) + right_x.push(rx) + right_y.push(ry) + mid_x.push(mx) + mid_y.push(my) + gaps.push((dx * dx + dy * dy).sqrt()) + gradients.push(gradient) + mid_above.push(my > gradient * mx + intercept) + } + let mut first_elbow = -1 + for index in 0..= 0 { + inflection_limit = 0 + while inflection_limit < left_x.length() && + left_x[inflection_limit] <= mid_x[first_elbow] { + inflection_limit = inflection_limit + 1 + } + if inflection_limit == 0 { + inflection_limit = 1 + } + } + let mut inflection_index = 0 + for index in 1..= 0 { + first_elbow + 1 + } else { + scan.length() + } + let mut knee_index = -1 + for index in 0.. Unit raise DropletUtilsAdvancedError { + if counts.length() == 0 || counts.length() != proportions.length() { + dua_fail( + "DropletUtils counts and ambient proportions must have equal non-zero length", + ) + } + if !dua_is_finite(alpha) || alpha == 0.0 { + dua_fail("DropletUtils alpha must be negative or positive") + } + let mut total_probability = 0.0 + for index in 0.. 0 { + dua_fail( + "DropletUtils positive counts cannot have zero ambient probability", + ) + } + total_probability = total_probability + probability + } + if (total_probability - 1.0).abs() > 1.0e-8 { + dua_fail("DropletUtils ambient proportions must sum to one") + } +} + +///| +fn dua_probability_data_component( + counts : Array[Int], + proportions : Array[Double], + alpha : Double, +) -> Double { + let mut output = 0.0 + for index in 0.. 0 { + if alpha < 0.0 { + output = output + + count.to_double() * @math.ln(proportions[index]) - + dua_log_factorial(count) + } else { + let scaled = alpha * proportions[index] + output = output + + dua_log_gamma(scaled + count.to_double()) - + dua_log_factorial(count) - + dua_log_gamma(scaled) + } + } + } + output +} + +///| +pub fn droplet_utils_log_probability( + counts : Array[Int], + proportions : Array[Double], + alpha? : Double = -1.0, +) -> Double raise DropletUtilsAdvancedError { + dua_validate_probability_input(counts, proportions, alpha) + let mut total = 0 + for count in counts { + total = total + count + } + let data_component = dua_probability_data_component( + counts, proportions, alpha, + ) + if alpha < 0.0 { + data_component + dua_log_factorial(total) + } else { + data_component + + dua_log_factorial(total) + + dua_log_gamma(alpha) - + dua_log_gamma(total.to_double() + alpha) + } +} + +///| +priv struct DropletUtilsRng { + mut state : Int +} + +///| +fn DropletUtilsRng::new(seed : Int) -> DropletUtilsRng { + let normalized = (seed - 1) % 2147483646 + 1 + DropletUtilsRng::{ state: normalized } +} + +///| +fn DropletUtilsRng::uniform(self : DropletUtilsRng) -> Double { + let quotient = self.state / 44488 + let remainder = self.state % 44488 + let candidate = 48271 * remainder - 3399 * quotient + self.state = if candidate > 0 { candidate } else { candidate + 2147483647 } + self.state.to_double() / 2147483647.0 +} + +///| +fn DropletUtilsRng::normal(self : DropletUtilsRng) -> Double { + let first = self.uniform().max(1.0e-15) + let second = self.uniform() + (-2.0 * @math.ln(first)).sqrt() * @math.cos(6.283185307179586 * second) +} + +///| +fn DropletUtilsRng::gamma(self : DropletUtilsRng, shape : Double) -> Double { + if shape < 1.0 { + let uniform = self.uniform().max(1.0e-15) + return self.gamma(shape + 1.0) * @math.exp(@math.ln(uniform) / shape) + } + let d = shape - 1.0 / 3.0 + let c = 1.0 / (9.0 * d).sqrt() + while true { + let normal = self.normal() + let base = 1.0 + c * normal + if base > 0.0 { + let volume = base * base * base + let uniform = self.uniform().max(1.0e-15) + if uniform < 1.0 - 0.0331 * normal * normal * normal * normal { + return d * volume + } + if @math.ln(uniform) < + 0.5 * normal * normal + d * (1.0 - volume + @math.ln(volume)) { + return d * volume + } + } + } + shape +} + +///| +fn DropletUtilsRng::categorical( + self : DropletUtilsRng, + weights : Array[Double], +) -> Int { + let mut total = 0.0 + for weight in weights { + total = total + weight + } + if total <= 0.0 { + return 0 + } + let target = self.uniform() * total + let mut cumulative = 0.0 + for index in 0.. Array[Int] { + let order : Array[Int] = [] + for index in 0.. Int { + if totals[left] < totals[right] { + -1 + } else if totals[left] > totals[right] { + 1 + } else if observed[left] < observed[right] { + -1 + } else if observed[left] > observed[right] { + 1 + } else { + left - right + } + }) + let extreme = Array::make(totals.length(), 0) + let rng = DropletUtilsRng::new(seed) + for _ in 0.. 0.0 { + sampled[feature] = rng.gamma(ambient[feature] * alpha) + sampled_total = sampled_total + sampled[feature] + } + } + if sampled_total <= 0.0 { + ambient.copy() + } else { + sampled + } + } + let tracker = Array::make(ambient.length(), 0) + let mut current_total = 0 + let mut current_probability = 0.0 + let mut position = 0 + while position < order.length() { + let target_total = totals[order[position]] + while current_total < target_total { + let feature = rng.categorical(weights) + let previous = tracker[feature] + if alpha < 0.0 { + current_probability = current_probability + @math.ln(ambient[feature]) + } else { + current_probability = current_probability + + @math.ln(alpha * ambient[feature] + previous.to_double()) + } + tracker[feature] = previous + 1 + current_probability = current_probability - + @math.ln(tracker[feature].to_double()) + current_total = current_total + 1 + } + let mut end = position + 1 + while end < order.length() && totals[order[end]] == target_total { + end = end + 1 + } + for grouped in position.. (Double, Bool) raise DropletUtilsAdvancedError { + if iterations <= 0 || seed <= 0 { + dua_fail("DropletUtils Monte Carlo iterations and seed must be positive") + } + dua_validate_probability_input(counts, proportions, alpha) + let mut total = 0 + for value in counts { + total = total + value + } + if total <= 0 { + dua_fail("DropletUtils Monte Carlo count vector must have positive total") + } + let observed = dua_probability_data_component(counts, proportions, alpha) + let extreme = dua_monte_carlo_extreme( + [total], + [observed], + proportions, + iterations, + alpha, + seed, + )[0] + ((extreme + 1).to_double() / (iterations + 1).to_double(), extreme == 0) +} + +///| +fn dua_alpha_log_likelihood( + data : DropletCountMatrix, + empty : Array[Bool], + proportions : Array[Double], + alpha : Double, +) -> Double { + let mut output = 0.0 + for barcode in 0.. 0 && proportions[feature] > 0.0 { + let scaled = alpha * proportions[feature] + output = output + + dua_log_gamma(count.to_double() + scaled) - + dua_log_gamma(scaled) + } + } + } + } + output +} + +///| +pub fn droplet_utils_estimate_alpha( + data : DropletCountMatrix, + ambient : DropletAmbientProfile, +) -> Double raise DropletUtilsAdvancedError { + if ambient.assumed_empty.length() != data.n_barcodes() || + ambient.proportions.length() != data.n_features() { + dua_fail("DropletUtils ambient profile dimensions do not match counts") + } + let ratio = 0.6180339887498949 + let mut left = @math.ln(0.01) + let mut right = @math.ln(10000.0) + let mut first = right - ratio * (right - left) + let mut second = left + ratio * (right - left) + let mut first_value = dua_alpha_log_likelihood( + data, + ambient.assumed_empty, + ambient.proportions, + @math.exp(first), + ) + let mut second_value = dua_alpha_log_likelihood( + data, + ambient.assumed_empty, + ambient.proportions, + @math.exp(second), + ) + for _ in 0..<80 { + if first_value < second_value { + left = first + first = second + first_value = second_value + second = left + ratio * (right - left) + second_value = dua_alpha_log_likelihood( + data, + ambient.assumed_empty, + ambient.proportions, + @math.exp(second), + ) + } else { + right = second + second = first + second_value = first_value + first = right - ratio * (right - left) + first_value = dua_alpha_log_likelihood( + data, + ambient.assumed_empty, + ambient.proportions, + @math.exp(first), + ) + } + } + @math.exp((left + right) / 2.0) +} + +///| +fn dua_bh_adjust(values : Array[Double?]) -> Array[Double?] { + let indexed : Array[(Double, Int)] = [] + for index in 0.. indexed.push((value.max(0.0).min(1.0), index)) + None => () + } + } + indexed.sort_by(fn(left : (Double, Int), right : (Double, Int)) -> Int { + if left.0 < right.0 { + -1 + } else if left.0 > right.0 { + 1 + } else { + left.1 - right.1 + } + }) + let output : Array[Double?] = Array::make(values.length(), None) + let count = indexed.length() + let mut running = 1.0 + let mut position = count - 1 + while position >= 0 { + let candidate = (indexed[position].0 * + count.to_double() / + (position + 1).to_double()).min(1.0) + running = running.min(candidate) + output[indexed[position].1] = Some(running) + position = position - 1 + } + output +} + +///| +fn dua_barcode_counts(data : DropletCountMatrix, barcode : Int) -> Array[Int] { + let output : Array[Int] = [] + for feature in 0.. DropletEmptyDropsResult raise DropletUtilsAdvancedError { + let ambient = droplet_utils_ambient_profile( + data, + lower=config.lower, + by_rank=config.by_rank, + known_empty~, + ) + let alpha = if config.estimate_alpha { + droplet_utils_estimate_alpha(data, ambient) + } else { + config.alpha + } + let totals = data.barcode_totals() + let tested_indices : Array[Int] = [] + let tested_totals : Array[Int] = [] + let observed_components : Array[Double] = [] + let log_probabilities : Array[Double?] = Array::make(data.n_barcodes(), None) + for barcode in 0.. 0 + } else { + !ambient.assumed_empty[barcode] + } + if eligible && (config.ignore < 0 || totals[barcode] > config.ignore) { + let barcode_counts = dua_barcode_counts(data, barcode) + dua_validate_probability_input(barcode_counts, ambient.proportions, alpha) + let component = dua_probability_data_component( + barcode_counts, + ambient.proportions, + alpha, + ) + let rest = if alpha < 0.0 { + dua_log_factorial(totals[barcode]) + } else { + dua_log_factorial(totals[barcode]) + + dua_log_gamma(alpha) - + dua_log_gamma(totals[barcode].to_double() + alpha) + } + tested_indices.push(barcode) + tested_totals.push(totals[barcode]) + observed_components.push(component) + log_probabilities[barcode] = Some(component + rest) + } + } + let extreme = dua_monte_carlo_extreme( + tested_totals, + observed_components, + ambient.proportions, + config.iterations, + alpha, + config.seed, + ) + let p_values : Array[Double?] = Array::make(data.n_barcodes(), None) + let limited : Array[Bool?] = Array::make(data.n_barcodes(), None) + for tested in 0.. 0.0 { + config.retain + } else { + droplet_utils_barcode_ranks( + data, + lower=ambient.lower, + exclude_from=config.rank_exclude, + window=config.rank_window, + gradient_threshold=config.gradient_threshold, + ).knee + } + let always_retained = Array::make(data.n_barcodes(), false) + let correction_values = p_values.copy() + for barcode in 0..= retain { + always_retained[barcode] = true + correction_values[barcode] = Some(0.0) + } + } + if config.test_ambient { + for barcode in 0.. if value <= config.fdr_threshold { calls[barcode] = true } + None => () + } + } + DropletEmptyDropsResult::{ + barcodes: data.barcodes.copy(), + totals, + log_probabilities, + p_values, + limited, + fdr, + calls, + always_retained, + ambient, + lower: ambient.lower, + retain, + alpha, + alpha_estimated: config.estimate_alpha, + iterations: config.iterations, + fdr_threshold: config.fdr_threshold, + } +} + +///| +pub fn DropletEmptyDropsResult::n_called(self : DropletEmptyDropsResult) -> Int { + let mut count = 0 + for call in self.calls { + if call { + count = count + 1 + } + } + count +} + +///| +pub fn DropletEmptyDropsResult::n_tested(self : DropletEmptyDropsResult) -> Int { + let mut count = 0 + for value in self.p_values { + match value { + Some(_) => count = count + 1 + None => () + } + } + count +} + +///| +pub fn DropletEmptyDropsResult::index_of( + self : DropletEmptyDropsResult, + barcode : String, +) -> Int? { + for index in 0.. Array[String] { + let output : Array[String] = [] + for index in 0.. String { + "DropletUtils emptyDrops: " + + self.barcodes.length().to_string() + + " barcodes, " + + self.ambient.n_empty().to_string() + + " assumed empty, " + + self.n_tested().to_string() + + " tested, " + + self.n_called().to_string() + + " called; lower=" + + self.lower.to_string() + + ", retain=" + + self.retain.to_string() + + ", iterations=" + + self.iterations.to_string() +} + +///| +pub fn DropletEmptyDropsResult::filter( + self : DropletEmptyDropsResult, + data : DropletCountMatrix, +) -> DropletCountMatrix raise DropletUtilsAdvancedError { + if self.barcodes.length() != data.n_barcodes() { + dua_fail("DropletUtils result does not match the count matrix") + } + for index in 0.. SingleCellExperiment { + let assays : Map[String, Array[Array[Double]]] = Map([]) + for key in source.assays.keys() { + assays[key] = dua_copy_double_matrix(source.assays[key]) + } + let row_data : Map[String, Array[String]] = Map([]) + for key in source.row_data.keys() { + row_data[key] = source.row_data[key].copy() + } + let col_data : Map[String, Array[String]] = Map([]) + for key in source.col_data.keys() { + col_data[key] = source.col_data[key].copy() + } + let reduced_dims : Map[String, Array[Array[Double]]] = Map([]) + for key in source.reduced_dims.keys() { + reduced_dims[key] = dua_copy_double_matrix(source.reduced_dims[key]) + } + let alternatives : Map[String, SingleCellExperiment] = Map([]) + for key in source.alternative_experiments.keys() { + alternatives[key] = source.alternative_experiments[key] + } + let metadata : Map[String, String] = Map([]) + for key in source.metadata.keys() { + metadata[key] = source.metadata[key] + } + SingleCellExperiment::{ + assays, + row_data, + col_data, + reduced_dims, + alternative_experiments: alternatives, + metadata, + row_names: source.row_names.copy(), + col_names: source.col_names.copy(), + } +} + +///| +fn dua_option_double_string(value : Double?) -> String { + match value { + Some(number) => number.to_string() + None => "NA" + } +} + +///| +pub fn droplet_utils_empty_drops_sce( + experiment : SingleCellExperiment, + assay_name? : String = "counts", + output_prefix? : String = "emptyDrops", + known_empty_column? : String = "", + config? : DropletUtilsConfig = DropletUtilsConfig::default(), +) -> DropletUtilsSingleCellExperimentOutput raise DropletUtilsAdvancedError { + if assay_name == "" || output_prefix == "" { + dua_fail("DropletUtils assay name and output prefix cannot be empty") + } + if !experiment.assays.contains(assay_name) { + dua_fail("DropletUtils assay not found: " + assay_name) + } + let assay = experiment.assays[assay_name] + if assay.length() == 0 || assay[0].length() == 0 { + dua_fail("DropletUtils assay cannot be empty") + } + if experiment.row_names.length() != assay.length() || + experiment.col_names.length() != assay[0].length() { + dua_fail( + "DropletUtils SingleCellExperiment names must match assay dimensions", + ) + } + let counts : Array[Array[Int]] = [] + for row in assay { + if row.length() != experiment.col_names.length() { + dua_fail("DropletUtils SingleCellExperiment assay must be rectangular") + } + let output_row : Array[Int] = [] + for value in row { + if !dua_is_finite(value) || value < 0.0 { + dua_fail( + "DropletUtils SingleCellExperiment counts must be finite and non-negative", + ) + } + if !config.round_counts && (value - value.round()).abs() > 1.0e-8 { + dua_fail( + "DropletUtils SingleCellExperiment counts must be integer-valued when rounding is disabled", + ) + } + output_row.push(value.round().to_int()) + } + counts.push(output_row) + } + let data = DropletCountMatrix::create( + counts, + feature_names=experiment.row_names, + barcodes=experiment.col_names, + ) + let known_empty : Array[Bool] = if known_empty_column == "" { + [] + } else { + if !experiment.col_data.contains(known_empty_column) { + dua_fail( + "DropletUtils known-empty column not found: " + known_empty_column, + ) + } + let source = experiment.col_data[known_empty_column] + if source.length() != data.n_barcodes() { + dua_fail("DropletUtils known-empty column must match the barcode count") + } + let parsed : Array[Bool] = [] + for value in source { + if value == "true" || value == "empty" || value == "1" { + parsed.push(true) + } else if value == "false" || value == "cell" || value == "0" { + parsed.push(false) + } else { + dua_fail( + "DropletUtils known-empty column contains invalid value: " + value, + ) + } + } + parsed + } + let result = droplet_utils_empty_drops(data, known_empty~, config~) + let output = dua_copy_sce(experiment) + let total_values : Array[String] = [] + let log_values : Array[String] = [] + let p_values : Array[String] = [] + let limited_values : Array[String] = [] + let fdr_values : Array[String] = [] + let class_values : Array[String] = [] + let retained_values : Array[String] = [] + for barcode in 0.. value.to_string() + None => "NA" + }, + ) + fdr_values.push(dua_option_double_string(result.fdr[barcode])) + class_values.push(if result.calls[barcode] { "cell" } else { "empty" }) + retained_values.push(result.always_retained[barcode].to_string()) + } + output.col_data[output_prefix + ".total"] = total_values + output.col_data[output_prefix + ".logProb"] = log_values + output.col_data[output_prefix + ".pValue"] = p_values + output.col_data[output_prefix + ".limited"] = limited_values + output.col_data[output_prefix + ".fdr"] = fdr_values + output.col_data[output_prefix + ".class"] = class_values + output.col_data[output_prefix + ".retained"] = retained_values + let ambient_values : Array[String] = [] + let ambient_count_values : Array[String] = [] + for feature in 0.. DropletCountMatrix raise DropletUtilsAdvancedError { + let feature_count = 12 + let barcode_count = 64 + let counts : Array[Array[Int]] = [] + for _ in 0.. FlowSomDistance { + FlowSomManhattan +} + +///| +pub fn flowsom_euclidean_distance() -> FlowSomDistance { + FlowSomEuclidean +} + +///| +pub fn flowsom_chebyshev_distance() -> FlowSomDistance { + FlowSomChebyshev +} + +///| +pub fn flowsom_cosine_distance() -> FlowSomDistance { + FlowSomCosine +} + +///| +pub fn flowsom_random_initialization() -> FlowSomInitialization { + FlowSomRandom +} + +///| +pub fn flowsom_kwsp_initialization() -> FlowSomInitialization { + FlowSomKwsp +} + +///| +pub fn flowsom_pca_initialization() -> FlowSomInitialization { + FlowSomPca +} + +///| +pub struct FlowSomConfig { + xdim : Int + ydim : Int + rlen : Int + mst_runs : Int + alpha_start : Double + alpha_end : Double + radius_start : Double + radius_end : Double + distance : FlowSomDistance + initialization : FlowSomInitialization + importance : Array[Double] + metaclusters : Int + meta_starts : Int + outlier_mad : Double + seed : Int +} derive(Debug) + +///| +pub fn FlowSomConfig::create( + xdim? : Int = 10, + ydim? : Int = 10, + rlen? : Int = 10, + mst_runs? : Int = 1, + alpha_start? : Double = 0.05, + alpha_end? : Double = 0.01, + radius_start? : Double = -1.0, + radius_end? : Double = 0.0, + distance? : FlowSomDistance = FlowSomEuclidean, + initialization? : FlowSomInitialization = FlowSomKwsp, + importance? : Array[Double] = [], + metaclusters? : Int = 0, + meta_starts? : Int = 10, + outlier_mad? : Double = 4.0, + seed? : Int = 1, +) -> FlowSomConfig raise FlowSomError { + if xdim <= 0 || ydim <= 0 { + flowsom_fail("FlowSOM grid dimensions must be positive") + } + if rlen <= 0 || mst_runs <= 0 { + flowsom_fail("FlowSOM rlen and mst_runs must be positive") + } + if !flowsom_is_finite(alpha_start) || + !flowsom_is_finite(alpha_end) || + alpha_start <= 0.0 || + alpha_end < 0.0 || + alpha_start < alpha_end { + flowsom_fail( + "FlowSOM learning rates must be finite, non-negative and decreasing", + ) + } + if !flowsom_is_finite(radius_start) || + !flowsom_is_finite(radius_end) || + radius_start < -1.0 || + radius_end < 0.0 || + (radius_start >= 0.0 && radius_start < radius_end) { + flowsom_fail("FlowSOM radii must be finite, non-negative and decreasing") + } + if metaclusters < 0 || metaclusters > xdim * ydim { + flowsom_fail("FlowSOM metaclusters must be between zero and node count") + } + if meta_starts <= 0 { + flowsom_fail("FlowSOM meta-clustering starts must be positive") + } + if !flowsom_is_finite(outlier_mad) || outlier_mad < 0.0 { + flowsom_fail("FlowSOM outlier MAD multiplier must be non-negative") + } + if seed <= 0 { + flowsom_fail("FlowSOM random seed must be positive") + } + for value in importance { + if !flowsom_is_finite(value) || value <= 0.0 { + flowsom_fail("FlowSOM marker importance values must be positive") + } + } + FlowSomConfig::{ + xdim, + ydim, + rlen, + mst_runs, + alpha_start, + alpha_end, + radius_start, + radius_end, + distance, + initialization, + importance: importance.copy(), + metaclusters, + meta_starts, + outlier_mad, + seed, + } +} + +///| +pub struct FlowSomMstEdge { + from : Int + to : Int + weight : Double +} derive(Eq, Debug) + +///| +pub struct FlowSomMapping { + clusters : Array[Int] + distances : Array[Double] +} derive(Debug) + +///| +pub struct FlowSomOutlierReport { + median_distances : Array[Double?] + mad_distances : Array[Double?] + thresholds : Array[Double?] + counts : Array[Int] + maximum_distances : Array[Double?] + per_cell : Array[Bool] +} derive(Debug) + +///| +pub struct FlowSomModel { + data : Array[Array[Double]] + marker_names : Array[String] + codes : Array[Array[Double]] + grid : Array[(Int, Int)] + mapping : FlowSomMapping + mst_edges : Array[FlowSomMstEdge] + topology_distances : Array[Array[Int]] + node_counts : Array[Int] + node_percentages : Array[Double] + node_medians : Array[Array[Double?]] + node_cvs : Array[Array[Double?]] + node_sds : Array[Array[Double?]] + node_mads : Array[Array[Double?]] + meta_clusters : Array[Int] + cell_meta_clusters : Array[Int] + outliers : FlowSomOutlierReport + quantization_error : Double + topographic_error : Double + iterations : Int + config : FlowSomConfig +} derive(Debug) + +///| +pub struct FlowSomMappedData { + mapping : FlowSomMapping + meta_clusters : Array[Int] + outliers : Array[Bool] +} derive(Debug) + +///| +pub struct FlowSomPurity { + mean : Double + worst : Double + below_075 : Int +} derive(Debug) + +///| +pub struct FlowSomSceOutput { + experiment : SingleCellExperiment + model : FlowSomModel +} + +///| +fn flowsom_fail(message : String) -> Unit raise FlowSomError { + raise FlowSomError(message) +} + +///| +fn flowsom_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn flowsom_double_matrix( + rows : Int, + columns : Int, + value : Double, +) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for _ in 0.. Array[Array[Int]] { + let output : Array[Array[Int]] = [] + for _ in 0.. Array[Array[Double?]] { + let output : Array[Array[Double?]] = [] + for _ in 0.. Array[Array[Double]] { + data.map(fn(row) { row.copy() }) +} + +///| +fn flowsom_matrix_shape( + data : Array[Array[Double]], +) -> (Int, Int) raise FlowSomError { + if data.length() == 0 { + flowsom_fail("FlowSOM data must contain at least one cell") + } + let markers = data[0].length() + if markers == 0 { + flowsom_fail("FlowSOM data must contain at least one marker") + } + for row in data { + if row.length() != markers { + flowsom_fail("FlowSOM data must be rectangular") + } + for value in row { + if !flowsom_is_finite(value) { + flowsom_fail("FlowSOM data must contain only finite values") + } + } + } + (data.length(), markers) +} + +///| +fn flowsom_lcg(state : Int) -> (Int, Double) { + let normalized = (state - 1) % 2147483646 + 1 + let quotient = normalized / 44488 + let remainder = normalized % 44488 + let candidate = 48271 * remainder - 3399 * quotient + let next = if candidate > 0 { candidate } else { candidate + 2147483647 } + (next, next.to_double() / 2147483647.0) +} + +///| +pub fn flowsom_distance( + left : Array[Double], + right : Array[Double], + distance : FlowSomDistance, +) -> Double raise FlowSomError { + if left.length() == 0 || left.length() != right.length() { + flowsom_fail("FlowSOM distance vectors must be non-empty and equal-length") + } + for value in left { + if !flowsom_is_finite(value) { + flowsom_fail("FlowSOM distance vectors must be finite") + } + } + for value in right { + if !flowsom_is_finite(value) { + flowsom_fail("FlowSOM distance vectors must be finite") + } + } + flowsom_distance_unchecked(left, right, distance) +} + +///| +fn flowsom_distance_unchecked( + left : Array[Double], + right : Array[Double], + distance : FlowSomDistance, +) -> Double { + match distance { + FlowSomManhattan => { + let mut total = 0.0 + for index in 0.. { + let mut total = 0.0 + for index in 0.. { + let mut maximum = 0.0 + for index in 0.. { + let mut dot = 0.0 + let mut left_norm = 0.0 + let mut right_norm = 0.0 + for index in 0.. Array[Array[Double]] { + if importance.length() == 0 { + return flowsom_copy_matrix(data) + } + data.map(fn(row) { row.mapi(fn(index, value) { value * importance[index] }) }) +} + +///| +fn flowsom_grid(xdim : Int, ydim : Int) -> Array[(Int, Int)] { + let grid : Array[(Int, Int)] = [] + for y in 0.. Array[Array[Int]] { + let distances = flowsom_int_matrix(grid.length(), grid.length(), 0) + for left in 0.. Double { + let distances : Array[Double] = [] + for left in 0.. Int { + if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + let position = (0.67 * (distances.length() - 1).to_double()).to_int() + distances[position] +} + +///| +pub fn flowsom_initialize_kwsp( + data : Array[Array[Double]], + nodes : Int, + seed? : Int = 1, +) -> Array[Array[Double]] raise FlowSomError { + let (cells, _) = flowsom_matrix_shape(data) + if nodes <= 0 || nodes > cells { + flowsom_fail("FlowSOM KWSP nodes must be between one and cell count") + } + if seed <= 0 { + flowsom_fail("FlowSOM random seed must be positive") + } + let (_, first_draw) = flowsom_lcg(seed) + let first = (first_draw * cells.to_double()).to_int().min(cells - 1) + let selected : Array[Int] = [first] + let distances : Array[Double] = [] + for cell in 0.. best_distance || + (distances[cell] == best_distance && (best < 0 || cell < best)) + ) { + best = cell + best_distance = distances[cell] + } + } + selected.push(best) + for cell in 0.. Array[Array[Double]] raise FlowSomError { + let (cells, _) = flowsom_matrix_shape(data) + if nodes <= 0 || nodes > cells { + flowsom_fail("FlowSOM random initialization requires nodes <= cell count") + } + let indices = Array::make(cells, 0) + for index in 0.. Array[Double] { + let means = Array::make(data[0].length(), 0.0) + for row in data { + for marker in 0.. Array[Array[Double]] { + let markers = means.length() + let covariance = flowsom_double_matrix(markers, markers, 0.0) + let denominator = (data.length() - 1).max(1).to_double() + for left in 0.. Double { + let mut total = 0.0 + for value in values { + total = total + value * value + } + total.sqrt() +} + +///| +fn flowsom_power_component( + covariance : Array[Array[Double]], + excluded : Array[Double]?, +) -> (Array[Double], Double) { + let size = covariance.length() + let vector = Array::make(size, 0.0) + for index in 0.. { + let mut projection = 0.0 + for index in 0.. () + } + let initial_norm = flowsom_vector_norm(vector) + if initial_norm > 0.0 { + for index in 0.. { + let mut projection = 0.0 + for index in 0.. () + } + let norm = flowsom_vector_norm(next) + if norm <= 1.0e-12 { + break + } + let mut difference = 0.0 + for index in 0.. Array[Array[Double]] raise FlowSomError { + let (_, markers) = flowsom_matrix_shape(data) + if xdim <= 0 || ydim <= 0 { + flowsom_fail("FlowSOM PCA grid dimensions must be positive") + } + let means = flowsom_column_means(data) + let covariance = flowsom_covariance(data, means) + let first = flowsom_power_component(covariance, None) + let second = if markers > 1 { + flowsom_power_component(covariance, Some(first.0)) + } else { + (Array::make(markers, 0.0), 0.0) + } + let first_scale = 5.0 * first.1.sqrt() + let second_scale = 5.0 * second.1.sqrt() + let codes : Array[Array[Double]] = [] + for y in 0.. Array[FlowSomMstEdge] { + let nodes = codes.length() + if nodes <= 1 { + return [] + } + let included = Array::make(nodes, false) + let best = Array::make(nodes, 1.0e300) + let parents = Array::make(nodes, -1) + best[0] = 0.0 + let edges : Array[FlowSomMstEdge] = [] + for _ in 0..= 0 { + edges.push(FlowSomMstEdge::{ + from: parents[selected], + to: selected, + weight: best[selected], + }) + } + for candidate in 0.. Array[FlowSomMstEdge] raise FlowSomError { + ignore(flowsom_matrix_shape(codes)) + flowsom_mst_unchecked(codes) +} + +///| +fn flowsom_topology_from_mst( + nodes : Int, + edges : Array[FlowSomMstEdge], +) -> Array[Array[Int]] { + let infinity = nodes + 1 + let distances = flowsom_int_matrix(nodes, nodes, infinity) + for node in 0.. Array[Array[Int]] raise FlowSomError { + ignore(flowsom_matrix_shape(codes)) + flowsom_topology_from_mst(codes.length(), flowsom_mst_unchecked(codes)) +} + +///| +fn flowsom_map_unchecked( + codes : Array[Array[Double]], + data : Array[Array[Double]], + distance : FlowSomDistance, +) -> FlowSomMapping { + let clusters : Array[Int] = [] + let distances : Array[Double] = [] + for row in data { + let mut best = 0 + let mut best_distance = flowsom_distance_unchecked(row, codes[0], distance) + for node in 1.. FlowSomMapping raise FlowSomError { + let (_, code_markers) = flowsom_matrix_shape(codes) + let (_, data_markers) = flowsom_matrix_shape(data) + if code_markers != data_markers { + flowsom_fail("FlowSOM codes and data must have equal marker counts") + } + flowsom_map_unchecked(codes, data, distance) +} + +///| +fn flowsom_training_stage( + data : Array[Array[Double]], + codes : Array[Array[Double]], + topology : Array[Array[Int]], + alpha_start : Double, + alpha_end : Double, + radius_start : Double, + radius_end : Double, + rlen : Int, + distance : FlowSomDistance, + initial_state : Int, +) -> (Int, Int) { + let total_iterations = rlen * data.length() + let radius_step = (radius_start - radius_end) / total_iterations.to_double() + let mut radius = radius_start + let mut state = initial_state + let mut completed = 0 + let mut epoch_change = 1.0 + let mut stop = false + for iteration in 0.. Double { + let sorted = values.copy() + sorted.sort_by(fn(left : Double, right : Double) -> Int { + if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + let middle = sorted.length() / 2 + if sorted.length() % 2 == 0 { + (sorted[middle - 1] + sorted[middle]) / 2.0 + } else { + sorted[middle] + } +} + +///| +fn flowsom_mad(values : Array[Double], center : Double) -> Double { + let deviations = values.map(fn(value) { (value - center).abs() }) + 1.4826 * flowsom_median(deviations) +} + +///| +priv struct FlowSomNodeSummary { + counts : Array[Int] + percentages : Array[Double] + medians : Array[Array[Double?]] + cvs : Array[Array[Double?]] + sds : Array[Array[Double?]] + mads : Array[Array[Double?]] +} + +///| +fn flowsom_node_summary( + data : Array[Array[Double]], + clusters : Array[Int], + nodes : Int, +) -> FlowSomNodeSummary { + let markers = data[0].length() + let counts = Array::make(nodes, 0) + for cluster in clusters { + counts[cluster] = counts[cluster] + 1 + } + let percentages = counts.map(fn(count) { + count.to_double() / data.length().to_double() + }) + let medians = flowsom_optional_matrix(nodes, markers) + let cvs = flowsom_optional_matrix(nodes, markers) + let sds = flowsom_optional_matrix(nodes, markers) + let mads = flowsom_optional_matrix(nodes, markers) + for node in 0.. 0 { + for marker in 0.. 1 { + (variance / (values.length() - 1).to_double()).sqrt() + } else { + 0.0 + } + medians[node][marker] = Some(median) + sds[node][marker] = Some(sd) + mads[node][marker] = Some(flowsom_mad(values, median)) + if mean != 0.0 { + cvs[node][marker] = Some(sd / mean) + } + } + } + } + FlowSomNodeSummary::{ counts, percentages, medians, cvs, sds, mads } +} + +///| +fn flowsom_outlier_report( + mapping : FlowSomMapping, + nodes : Int, + mad_allowed : Double, +) -> FlowSomOutlierReport { + let medians : Array[Double?] = Array::make(nodes, None) + let mads : Array[Double?] = Array::make(nodes, None) + let thresholds : Array[Double?] = Array::make(nodes, None) + let maximums : Array[Double?] = Array::make(nodes, None) + let counts = Array::make(nodes, 0) + for node in 0.. 0 { + let median = flowsom_median(values) + let mad = flowsom_mad(values, median) + let mut maximum = values[0] + for value in values { + maximum = maximum.max(value) + } + medians[node] = Some(median) + mads[node] = Some(mad) + thresholds[node] = Some(median + mad_allowed * mad) + maximums[node] = Some(maximum) + } + } + let per_cell = Array::make(mapping.clusters.length(), false) + for cell in 0.. + if mapping.distances[cell] > threshold { + per_cell[cell] = true + counts[node] = counts[node] + 1 + } + None => () + } + } + FlowSomOutlierReport::{ + median_distances: medians, + mad_distances: mads, + thresholds, + counts, + maximum_distances: maximums, + per_cell, + } +} + +///| +pub fn flowsom_meta_cluster_codes( + codes : Array[Array[Double]], + clusters : Int, + starts? : Int = 10, + seed? : Int = 1, +) -> Array[Int] raise FlowSomError { + let (nodes, _) = flowsom_matrix_shape(codes) + if clusters <= 0 || clusters > nodes { + flowsom_fail( + "FlowSOM meta-cluster count must be between one and node count", + ) + } + if starts <= 0 || seed <= 0 { + flowsom_fail("FlowSOM meta-clustering starts and seed must be positive") + } + if clusters == 1 { + return Array::make(nodes, 0) + } + let config = BlusterKmeansConfig::create(clusters, starts~, seed~) catch { + BlusterError(message) => + raise FlowSomError("FlowSOM meta-clustering setup failed: " + message) + } + let result = bluster_cluster_rows_kmeans(codes, config) catch { + BlusterError(message) => + raise FlowSomError("FlowSOM meta-clustering failed: " + message) + } + result.clusters +} + +///| +fn flowsom_line_residual( + values : Array[Double], + start : Int, + end : Int, +) -> Double { + let count = end - start + if count <= 1 { + return 0.0 + } + let mut mean_x = 0.0 + let mut mean_y = 0.0 + for index in start.. 0.0 { numerator / denominator } else { 0.0 } + let intercept = mean_y - slope * mean_x + let mut residual = 0.0 + for index in start.. Int raise FlowSomError { + let (nodes, _) = flowsom_matrix_shape(codes) + if maximum <= 0 || maximum > nodes { + flowsom_fail("FlowSOM maximum meta-clusters must be within node count") + } + if starts <= 0 || seed <= 0 { + flowsom_fail("FlowSOM meta-clustering starts and seed must be positive") + } + if maximum <= 2 { + return maximum + } + let sse = Array::make(maximum, 0.0) + for count in 1..<=maximum { + if count == 1 { + let means = flowsom_column_means(codes) + let mut total = 0.0 + for code in codes { + for marker in 0.. + raise FlowSomError( + "FlowSOM automatic meta-clustering setup failed: " + message, + ) + } + let result = bluster_cluster_rows_kmeans(codes, config) catch { + BlusterError(message) => + raise FlowSomError( + "FlowSOM automatic meta-clustering failed: " + message, + ) + } + sse[count - 1] = result.total_within_sum_squares + } + } + let smoothed = sse.copy() + for index in 1..<(maximum - 1) { + smoothed[index] = 0.8 * sse[index] + + 0.1 * sse[index - 1] + + 0.1 * sse[index + 1] + } + let mut optimum = 2 + let mut best_residual = 1.0e300 + for split in 1..<(maximum - 1) { + let residual = flowsom_line_residual(smoothed, 0, split) + + flowsom_line_residual(smoothed, split, maximum) + if residual < best_residual { + best_residual = residual + optimum = split + 1 + } + } + optimum +} + +///| +fn flowsom_quality( + data : Array[Array[Double]], + codes : Array[Array[Double]], + mapping : FlowSomMapping, + topology : Array[Array[Int]], + distance : FlowSomDistance, +) -> (Double, Double) { + let mut quantization = 0.0 + let mut topographic_errors = 0 + for cell in 0.. 1 { + let first = mapping.clusters[cell] + let mut second = if first == 0 { 1 } else { 0 } + let mut second_distance = flowsom_distance_unchecked( + data[cell], + codes[second], + distance, + ) + for node in 0.. 1 { + topographic_errors = topographic_errors + 1 + } + } + } + ( + quantization / data.length().to_double(), + topographic_errors.to_double() / data.length().to_double(), + ) +} + +///| +pub fn flowsom_train( + data : Array[Array[Double]], + config : FlowSomConfig, + marker_names? : Array[String] = [], +) -> FlowSomModel raise FlowSomError { + let (cells, markers) = flowsom_matrix_shape(data) + let nodes = config.xdim * config.ydim + if marker_names.length() != 0 && marker_names.length() != markers { + flowsom_fail("FlowSOM marker names must match the data columns") + } + if config.importance.length() != 0 && config.importance.length() != markers { + flowsom_fail("FlowSOM importance must contain one value per marker") + } + if config.initialization != FlowSomPca && nodes > cells { + flowsom_fail( + "FlowSOM random and KWSP initialization require at least one cell per node", + ) + } + let names = if marker_names.length() == 0 { + let generated : Array[String] = [] + for marker in 0.. flowsom_initialize_random(weighted, nodes, config.seed) + FlowSomKwsp => flowsom_initialize_kwsp(weighted, nodes, seed=config.seed) + FlowSomPca => flowsom_initialize_pca(weighted, config.xdim, config.ydim) + } + let mut topology = flowsom_grid_distances(grid) + let resolved_radius = if config.radius_start < 0.0 { + flowsom_default_radius(grid) + } else { + config.radius_start + } + let mut state = config.seed + let mut iterations = 0 + for stage in 0.. 0 { + flowsom_meta_cluster_codes( + codes, + config.metaclusters, + starts=config.meta_starts, + seed=config.seed + 104729, + ) + } else { + [] + } + let cell_meta_clusters = if meta_clusters.length() > 0 { + mapping.clusters.map(fn(cluster) { meta_clusters[cluster] }) + } else { + [] + } + let outliers = flowsom_outlier_report(mapping, nodes, config.outlier_mad) + let quality = flowsom_quality( + weighted, + codes, + mapping, + topology, + config.distance, + ) + FlowSomModel::{ + data: flowsom_copy_matrix(data), + marker_names: names, + codes: flowsom_copy_matrix(codes), + grid, + mapping, + mst_edges, + topology_distances: topology, + node_counts: summary.counts, + node_percentages: summary.percentages, + node_medians: summary.medians, + node_cvs: summary.cvs, + node_sds: summary.sds, + node_mads: summary.mads, + meta_clusters, + cell_meta_clusters, + outliers, + quantization_error: quality.0, + topographic_error: quality.1, + iterations, + config, + } +} + +///| +pub fn flowsom_map_new( + model : FlowSomModel, + data : Array[Array[Double]], +) -> FlowSomMappedData raise FlowSomError { + let (_, markers) = flowsom_matrix_shape(data) + if markers != model.marker_names.length() { + flowsom_fail("FlowSOM new data marker count does not match the model") + } + let weighted = flowsom_weight_data(data, model.config.importance) + let mapping = flowsom_map_unchecked( + model.codes, + weighted, + model.config.distance, + ) + let meta_clusters = if model.meta_clusters.length() > 0 { + mapping.clusters.map(fn(cluster) { model.meta_clusters[cluster] }) + } else { + [] + } + let outliers = Array::make(data.length(), false) + for cell in 0.. outliers[cell] = mapping.distances[cell] > threshold + None => () + } + } + FlowSomMappedData::{ mapping, meta_clusters, outliers } +} + +///| +pub fn flowsom_marker_outliers( + model : FlowSomModel, + data : Array[Array[Double]], + mad_allowed? : Double = 4.0, +) -> Array[Array[Int]] raise FlowSomError { + let (_, markers) = flowsom_matrix_shape(data) + if markers != model.marker_names.length() { + flowsom_fail("FlowSOM marker outlier data does not match the model") + } + if !flowsom_is_finite(mad_allowed) || mad_allowed < 0.0 { + flowsom_fail("FlowSOM marker outlier MAD multiplier must be non-negative") + } + let mapped = flowsom_map_new(model, data) + let output = flowsom_int_matrix(data.length(), markers, 0) + for cell in 0.. { + let upper = median + mad_allowed * mad + let lower = median - mad_allowed * mad + if data[cell][marker] > upper { + output[cell][marker] = 1 + } else if data[cell][marker] < lower { + output[cell][marker] = -1 + } + } + _ => () + } + } + } + output +} + +///| +pub fn flowsom_node_positive_percentages( + model : FlowSomModel, + cutoffs : Array[Double], +) -> Array[Array[Double?]] raise FlowSomError { + if cutoffs.length() != model.marker_names.length() { + flowsom_fail("FlowSOM positive cutoffs must match marker count") + } + for cutoff in cutoffs { + if !flowsom_is_finite(cutoff) { + flowsom_fail("FlowSOM positive cutoffs must be finite") + } + } + let nodes = model.codes.length() + let markers = model.marker_names.length() + let output = flowsom_optional_matrix(nodes, markers) + for node in 0.. 0 { + for marker in 0.. cutoffs[marker] { + positive = positive + 1 + } + } + output[node][marker] = Some( + positive.to_double() / model.node_counts[node].to_double(), + ) + } + } + } + output +} + +///| +pub fn flowsom_meta_counts( + model : FlowSomModel, +) -> Array[Int] raise FlowSomError { + if model.meta_clusters.length() == 0 { + flowsom_fail("FlowSOM model does not contain meta-clusters") + } + let mut groups = 0 + for cluster in model.meta_clusters { + groups = groups.max(cluster + 1) + } + let counts = Array::make(groups, 0) + for cluster in model.cell_meta_clusters { + counts[cluster] = counts[cluster] + 1 + } + counts +} + +///| +pub fn flowsom_meta_medians( + model : FlowSomModel, +) -> Array[Array[Double?]] raise FlowSomError { + if model.cell_meta_clusters.length() == 0 { + flowsom_fail("FlowSOM model does not contain meta-clusters") + } + let mut groups = 0 + for cluster in model.meta_clusters { + groups = groups.max(cluster + 1) + } + flowsom_node_summary(model.data, model.cell_meta_clusters, groups).medians +} + +///| +fn flowsom_unique_labels(labels : Array[Int]) -> Array[Int] { + let output : Array[Int] = [] + for label in labels { + if !output.contains(label) { + output.push(label) + } + } + output.sort_by(fn(left : Int, right : Int) -> Int { + if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + output +} + +///| +fn flowsom_label_index(labels : Array[Int], value : Int) -> Int { + for index in 0.. FlowSomPurity raise FlowSomError { + if real_clusters.length() == 0 || + real_clusters.length() != predicted_clusters.length() { + flowsom_fail( + "FlowSOM purity cluster vectors must be non-empty and equal-length", + ) + } + let real = flowsom_unique_labels(real_clusters) + let predicted = flowsom_unique_labels(predicted_clusters) + let table = flowsom_int_matrix(predicted.length(), real.length(), 0) + for index in 0.. Double raise FlowSomError { + if real_clusters.length() == 0 || + real_clusters.length() != predicted_clusters.length() { + flowsom_fail( + "FlowSOM F-measure cluster vectors must be non-empty and equal-length", + ) + } + let real = flowsom_unique_labels(real_clusters) + let predicted = flowsom_unique_labels(predicted_clusters) + let table = flowsom_int_matrix(real.length(), predicted.length(), 0) + for index in 0.. 0 { + table[row][column].to_double() / column_sums[column].to_double() + } else { + 0.0 + } + let recall = table[row][column].to_double() / row_sums[row].to_double() + let value = if precision + recall > 0.0 { + 2.0 * precision * recall / (precision + recall) + } else { + 0.0 + } + best = best.max(value) + } + score = score + + best * row_sums[row].to_double() / real_clusters.length().to_double() + } + score +} + +///| +fn flowsom_config_with_metaclusters( + config : FlowSomConfig, + metaclusters : Int, +) -> FlowSomConfig { + FlowSomConfig::{ + xdim: config.xdim, + ydim: config.ydim, + rlen: config.rlen, + mst_runs: config.mst_runs, + alpha_start: config.alpha_start, + alpha_end: config.alpha_end, + radius_start: config.radius_start, + radius_end: config.radius_end, + distance: config.distance, + initialization: config.initialization, + importance: config.importance.copy(), + metaclusters, + meta_starts: config.meta_starts, + outlier_mad: config.outlier_mad, + seed: config.seed, + } +} + +///| +pub fn flowsom_with_metaclusters( + model : FlowSomModel, + clusters : Int, + starts? : Int = 10, + seed? : Int = 1, +) -> FlowSomModel raise FlowSomError { + let meta_clusters = flowsom_meta_cluster_codes( + model.codes, + clusters, + starts~, + seed~, + ) + let cell_meta_clusters = model.mapping.clusters.map(fn(cluster) { + meta_clusters[cluster] + }) + FlowSomModel::{ + data: flowsom_copy_matrix(model.data), + marker_names: model.marker_names.copy(), + codes: flowsom_copy_matrix(model.codes), + grid: model.grid.copy(), + mapping: FlowSomMapping::{ + clusters: model.mapping.clusters.copy(), + distances: model.mapping.distances.copy(), + }, + mst_edges: model.mst_edges.copy(), + topology_distances: model.topology_distances.map(fn(row) { row.copy() }), + node_counts: model.node_counts.copy(), + node_percentages: model.node_percentages.copy(), + node_medians: model.node_medians.map(fn(row) { row.copy() }), + node_cvs: model.node_cvs.map(fn(row) { row.copy() }), + node_sds: model.node_sds.map(fn(row) { row.copy() }), + node_mads: model.node_mads.map(fn(row) { row.copy() }), + meta_clusters, + cell_meta_clusters, + outliers: FlowSomOutlierReport::{ + median_distances: model.outliers.median_distances.copy(), + mad_distances: model.outliers.mad_distances.copy(), + thresholds: model.outliers.thresholds.copy(), + counts: model.outliers.counts.copy(), + maximum_distances: model.outliers.maximum_distances.copy(), + per_cell: model.outliers.per_cell.copy(), + }, + quantization_error: model.quantization_error, + topographic_error: model.topographic_error, + iterations: model.iterations, + config: flowsom_config_with_metaclusters(model.config, clusters), + } +} + +///| +pub fn flowsom_with_automatic_metaclusters( + model : FlowSomModel, + maximum : Int, + starts? : Int = 10, + seed? : Int = 1, +) -> FlowSomModel raise FlowSomError { + let clusters = flowsom_determine_meta_clusters( + model.codes, + maximum, + starts~, + seed~, + ) + flowsom_with_metaclusters(model, clusters, starts~, seed~) +} + +///| +fn flowsom_resolve_marker_indices( + marker_count : Int, + marker_indices : Array[Int], +) -> Array[Int] raise FlowSomError { + if marker_count <= 0 { + flowsom_fail("FlowSOM input must contain at least one marker") + } + if marker_indices.length() == 0 { + let all = Array::make(marker_count, 0) + for marker in 0..= marker_count { + flowsom_fail("FlowSOM marker index is outside the input matrix") + } + if selected.contains(marker) { + flowsom_fail("FlowSOM marker indices must be unique") + } + selected.push(marker) + } + selected +} + +///| +pub fn flowsom_train_flow_frame( + frame : FlowFrame, + config : FlowSomConfig, + marker_indices? : Array[Int] = [], +) -> FlowSomModel raise FlowSomError { + let (_, markers) = flowsom_matrix_shape(frame.exprs) + let selected = flowsom_resolve_marker_indices(markers, marker_indices) + let available_names = flow_core_get_markers(frame) + let names : Array[String] = [] + let data : Array[Array[Double]] = [] + for marker in selected { + if marker < available_names.length() && available_names[marker].length() > 0 { + names.push(available_names[marker]) + } else { + names.push("marker." + (marker + 1).to_string()) + } + } + for source in frame.exprs { + let row : Array[Double] = [] + for marker in selected { + row.push(source[marker]) + } + data.push(row) + } + flowsom_train(data, config, marker_names=names) +} + +///| +fn flowsom_copy_sce(source : SingleCellExperiment) -> SingleCellExperiment { + let assays : Map[String, Array[Array[Double]]] = Map([]) + for key in source.assays.keys() { + assays[key] = flowsom_copy_matrix(source.assays[key]) + } + let row_data : Map[String, Array[String]] = Map([]) + for key in source.row_data.keys() { + row_data[key] = source.row_data[key].copy() + } + let col_data : Map[String, Array[String]] = Map([]) + for key in source.col_data.keys() { + col_data[key] = source.col_data[key].copy() + } + let reduced_dims : Map[String, Array[Array[Double]]] = Map([]) + for key in source.reduced_dims.keys() { + reduced_dims[key] = flowsom_copy_matrix(source.reduced_dims[key]) + } + let alternatives : Map[String, SingleCellExperiment] = Map([]) + for key in source.alternative_experiments.keys() { + alternatives[key] = flowsom_copy_sce(source.alternative_experiments[key]) + } + let metadata : Map[String, String] = Map([]) + for key in source.metadata.keys() { + metadata[key] = source.metadata[key] + } + SingleCellExperiment::{ + assays, + row_data, + col_data, + reduced_dims, + alternative_experiments: alternatives, + metadata, + row_names: source.row_names.copy(), + col_names: source.col_names.copy(), + } +} + +///| +pub fn flowsom_cluster_sce( + experiment : SingleCellExperiment, + config : FlowSomConfig, + assay_name? : String = "counts", + marker_indices? : Array[Int] = [], + cluster_column? : String = "FlowSOM.cluster", + meta_column? : String = "FlowSOM.metacluster", +) -> FlowSomSceOutput raise FlowSomError { + if assay_name.length() == 0 || + cluster_column.length() == 0 || + meta_column.length() == 0 { + flowsom_fail("FlowSOM SCE assay and output names must be non-empty") + } + if cluster_column == meta_column { + flowsom_fail("FlowSOM SCE cluster and meta-cluster columns must differ") + } + let assay = match experiment.assays.get(assay_name) { + Some(value) => value + None => { + flowsom_fail("FlowSOM SCE assay '" + assay_name + "' was not found") + [] + } + } + if assay.length() == 0 { + flowsom_fail("FlowSOM SCE assay must contain at least one marker") + } + if experiment.row_names.length() != assay.length() { + flowsom_fail("FlowSOM SCE assay rows must match row names") + } + let cells = experiment.col_names.length() + if cells == 0 { + flowsom_fail("FlowSOM SCE must contain at least one cell") + } + for row in assay { + if row.length() != cells { + flowsom_fail("FlowSOM SCE assay columns must match column names") + } + } + let selected = flowsom_resolve_marker_indices(assay.length(), marker_indices) + let names = selected.map(fn(marker) { experiment.row_names[marker] }) + let data : Array[Array[Double]] = [] + for cell in 0.. 0 { + output.col_data[meta_column] = model.cell_meta_clusters.map(fn(cluster) { + (cluster + 1).to_string() + }) + } + output.metadata["FlowSOM.assay"] = assay_name + output.metadata["FlowSOM.grid"] = config.xdim.to_string() + + "x" + + config.ydim.to_string() + output.metadata["FlowSOM.quantization_error"] = model.quantization_error.to_string() + output.metadata["FlowSOM.topographic_error"] = model.topographic_error.to_string() + FlowSomSceOutput::{ experiment: output, model } +} + +///| +pub fn flowsom_summary(model : FlowSomModel) -> String { + let mut occupied = 0 + for count in model.node_counts { + if count > 0 { + occupied = occupied + 1 + } + } + let meta = if model.meta_clusters.length() == 0 { + "none" + } else { + let mut groups = 0 + for cluster in model.meta_clusters { + groups = groups.max(cluster + 1) + } + groups.to_string() + } + "FlowSOM model\n" + + " cells: " + + model.data.length().to_string() + + "\n markers: " + + model.marker_names.length().to_string() + + "\n nodes: " + + model.codes.length().to_string() + + "\n occupied nodes: " + + occupied.to_string() + + "\n metaclusters: " + + meta + + "\n quantization error: " + + model.quantization_error.to_string() + + "\n topographic error: " + + model.topographic_error.to_string() +} diff --git a/src/lisaclust.mbt b/src/lisaclust.mbt new file mode 100644 index 00000000..579f513a --- /dev/null +++ b/src/lisaclust.mbt @@ -0,0 +1,1443 @@ +// Local indicators of spatial association inspired by Bioconductor lisaClust. +// +// Curves are generated independently per image. Each row describes one source +// cell across every target cell type and radius, then deterministic multi-start +// k-means identifies tissue regions with similar local spatial organisation. + +///| +pub suberror LisaError { + LisaError(String) +} + +///| +pub enum LisaCurveKind { + LisaStandardizedK + LisaCenteredL +} derive(Eq, Debug) + +///| +pub fn lisa_k_curve() -> LisaCurveKind { + LisaStandardizedK +} + +///| +pub fn lisa_l_curve() -> LisaCurveKind { + LisaCenteredL +} + +///| +pub enum LisaWindowKind { + LisaRectangle + LisaConvexHull +} derive(Eq, Debug) + +///| +pub fn lisa_rectangle_window() -> LisaWindowKind { + LisaRectangle +} + +///| +pub fn lisa_convex_window() -> LisaWindowKind { + LisaConvexHull +} + +///| +fn lisa_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +pub struct LisaCell { + cell_id : String + image_id : String + cell_type : String + x : Double + y : Double +} derive(Eq, Debug) + +///| +pub fn LisaCell::create( + cell_id : String, + image_id : String, + cell_type : String, + x : Double, + y : Double, +) -> LisaCell raise LisaError { + if cell_id == "" { + raise LisaError("lisaClust cell ID must not be empty") + } + if image_id == "" { + raise LisaError("lisaClust image ID must not be empty") + } + if cell_type == "" { + raise LisaError("lisaClust cell type must not be empty") + } + if !lisa_is_finite(x) || !lisa_is_finite(y) { + raise LisaError("lisaClust coordinates must be finite") + } + LisaCell::{ cell_id, image_id, cell_type, x, y } +} + +///| +pub struct LisaConfig { + radii : Array[Double] + curve_kind : LisaCurveKind + window_kind : LisaWindowKind + bandwidth : Double + min_density : Double + edge_correction : Bool + window_padding : Double + edge_samples : Int + n_clusters : Int + n_starts : Int + max_iterations : Int + tolerance : Double + seed : Int + region_prefix : String +} derive(Debug) + +///| +pub fn LisaConfig::create( + radii? : Array[Double] = [20.0, 50.0, 100.0], + curve_kind? : LisaCurveKind = LisaStandardizedK, + window_kind? : LisaWindowKind = LisaConvexHull, + bandwidth? : Double = 100000.0, + min_density? : Double = 0.05, + edge_correction? : Bool = true, + window_padding? : Double = 0.01, + edge_samples? : Int = 360, + n_clusters? : Int = 2, + n_starts? : Int = 10, + max_iterations? : Int = 100, + tolerance? : Double = 1.0e-8, + seed? : Int = 51773, + region_prefix? : String = "region", +) -> LisaConfig raise LisaError { + if radii.length() == 0 { + raise LisaError("lisaClust radii must not be empty") + } + let checked_radii = radii.copy() + let mut previous = 0.0 + for index in 0.. 0 && radius <= previous { + raise LisaError("lisaClust radii must be strictly increasing") + } + previous = radius + } + if !lisa_is_finite(bandwidth) || bandwidth <= 0.0 { + raise LisaError("lisaClust bandwidth must be finite and positive") + } + if !lisa_is_finite(min_density) || min_density <= 0.0 { + raise LisaError("lisaClust minimum density must be finite and positive") + } + if !lisa_is_finite(window_padding) || window_padding < 0.0 { + raise LisaError("lisaClust window padding must be finite and non-negative") + } + if edge_samples < 32 { + raise LisaError("lisaClust edge integration requires at least 32 samples") + } + if n_clusters < 1 { + raise LisaError("lisaClust cluster count must be positive") + } + if n_starts < 1 || max_iterations < 1 { + raise LisaError("lisaClust k-means controls must be positive") + } + if !lisa_is_finite(tolerance) || tolerance <= 0.0 || tolerance >= 1.0 { + raise LisaError("lisaClust tolerance must be finite and in (0, 1)") + } + if seed < 0 { + raise LisaError("lisaClust seed must be non-negative") + } + if region_prefix == "" { + raise LisaError("lisaClust region prefix must not be empty") + } + LisaConfig::{ + radii: checked_radii, + curve_kind, + window_kind, + bandwidth, + min_density, + edge_correction, + window_padding, + edge_samples, + n_clusters, + n_starts, + max_iterations, + tolerance, + seed, + region_prefix, + } +} + +///| +pub fn LisaConfig::default() -> LisaConfig { + LisaConfig::{ + radii: [20.0, 50.0, 100.0], + curve_kind: LisaStandardizedK, + window_kind: LisaConvexHull, + bandwidth: 100000.0, + min_density: 0.05, + edge_correction: true, + window_padding: 0.01, + edge_samples: 360, + n_clusters: 2, + n_starts: 10, + max_iterations: 100, + tolerance: 1.0e-8, + seed: 51773, + region_prefix: "region", + } +} + +///| +pub struct LisaImageWindow { + image_id : String + vertices : Array[(Double, Double)] + area : Double + max_radius : Double +} derive(Debug) + +///| +pub struct LisaImageRadii { + image_id : String + radii : Array[Double] +} derive(Debug) + +///| +pub struct LisaCurveSet { + cell_ids : Array[String] + image_ids : Array[String] + cell_types : Array[String] + target_cell_types : Array[String] + radii : Array[Double] + feature_names : Array[String] + values : Array[Array[Double]] + effective_radii : Array[LisaImageRadii] + windows : Array[LisaImageWindow] + curve_kind : LisaCurveKind +} derive(Debug) + +///| +pub fn LisaCurveSet::n_cells(self : LisaCurveSet) -> Int { + self.cell_ids.length() +} + +///| +pub fn LisaCurveSet::n_features(self : LisaCurveSet) -> Int { + self.feature_names.length() +} + +///| +pub fn LisaCurveSet::feature_index( + self : LisaCurveSet, + target_cell_type : String, + radius : Double, +) -> Int { + let mut type_index = -1 + for index in 0.. Array[Double]? { + for index in 0.. Array[Double]? { + for entry in self.effective_radii { + if entry.image_id == image_id { + return Some(entry.radii.copy()) + } + } + None +} + +///| +pub struct LisaRegionEnrichment { + cell_type : String + region : String + observed : Int + expected : Double + relative_frequency : Double +} derive(Debug) + +///| +pub struct LisaRegionSummary { + region : String + size : Int + dominant_cell_type : String + maximum_enrichment : Double +} derive(Debug) + +///| +pub struct LisaResult { + curves : LisaCurveSet + labels : Array[Int] + regions : Array[String] + centroids : Array[Array[Double]] + cluster_sizes : Array[Int] + inertia : Double + silhouette : Double + iterations : Int + converged : Bool + enrichment : Array[LisaRegionEnrichment] + region_summaries : Array[LisaRegionSummary] + config : LisaConfig +} derive(Debug) + +///| +pub fn LisaResult::n_cells(self : LisaResult) -> Int { + self.curves.n_cells() +} + +///| +pub fn LisaResult::n_regions(self : LisaResult) -> Int { + self.cluster_sizes.length() +} + +///| +pub fn LisaResult::region_for_cell( + self : LisaResult, + cell_id : String, +) -> String? { + for index in 0.. LisaRegionEnrichment? { + for entry in self.enrichment { + if entry.cell_type == cell_type && entry.region == region { + return Some(entry) + } + } + None +} + +///| +pub fn LisaResult::top_enrichments( + self : LisaResult, + limit? : Int = 10, + minimum_relative_frequency? : Double = 0.0, +) -> Array[LisaRegionEnrichment] raise LisaError { + if limit < 0 { + raise LisaError("lisaClust enrichment limit must be non-negative") + } + if !lisa_is_finite(minimum_relative_frequency) || + minimum_relative_frequency < 0.0 { + raise LisaError("lisaClust enrichment threshold must be non-negative") + } + let selected : Array[LisaRegionEnrichment] = [] + for entry in self.enrichment { + if entry.relative_frequency >= minimum_relative_frequency { + selected.push(entry) + } + } + selected.sort_by( + fn( + left : LisaRegionEnrichment, + right : LisaRegionEnrichment, + ) -> Int { + if left.relative_frequency > right.relative_frequency { + -1 + } else if left.relative_frequency < right.relative_frequency { + 1 + } else if left.region < right.region { + -1 + } else if left.region > right.region { + 1 + } else if left.cell_type < right.cell_type { + -1 + } else if left.cell_type > right.cell_type { + 1 + } else { + 0 + } + }, + ) + let output : Array[LisaRegionEnrichment] = [] + for index in 0.. String { + "lisaClust(cells=" + + self.n_cells().to_string() + + ", features=" + + self.curves.n_features().to_string() + + ", regions=" + + self.n_regions().to_string() + + ", inertia=" + + self.inertia.to_string() + + ", silhouette=" + + self.silhouette.to_string() + + ")" +} + +///| +pub struct LisaSpatialExperimentOutput { + experiment : SpatialExperiment + result : LisaResult +} + +///| +fn lisa_unique_strings(values : Array[String]) -> Array[String] { + let output : Array[String] = [] + let seen : Map[String, Bool] = Map([]) + for value in values { + if !seen.contains(value) { + seen[value] = true + output.push(value) + } + } + output +} + +///| +fn lisa_group_images( + cells : Array[LisaCell], +) -> (Array[String], Map[String, Array[Int]]) { + let image_ids : Array[String] = [] + let groups : Map[String, Array[Int]] = Map([]) + for index in 0.. indices.push(index) + None => { + image_ids.push(image_id) + groups[image_id] = [index] + } + } + } + (image_ids, groups) +} + +///| +fn lisa_validate_cells(cells : Array[LisaCell]) -> Unit raise LisaError { + if cells.length() < 2 { + raise LisaError("lisaClust requires at least two cells") + } + let identifiers : Map[String, Bool] = Map([]) + for cell in cells { + if identifiers.contains(cell.cell_id) { + raise LisaError("lisaClust cell IDs must be unique") + } + identifiers[cell.cell_id] = true + if cell.image_id == "" || cell.cell_type == "" || cell.cell_id == "" { + raise LisaError("lisaClust cell identifiers must not be empty") + } + if !lisa_is_finite(cell.x) || !lisa_is_finite(cell.y) { + raise LisaError("lisaClust coordinates must be finite") + } + } +} + +///| +fn lisa_cross( + origin : (Double, Double), + first : (Double, Double), + second : (Double, Double), +) -> Double { + (first.0 - origin.0) * (second.1 - origin.1) - + (first.1 - origin.1) * (second.0 - origin.0) +} + +///| +fn lisa_convex_hull( + points : Array[(Double, Double)], +) -> Array[(Double, Double)] { + let sorted = points.copy() + sorted.sort_by( + fn(left : (Double, Double), right : (Double, Double)) -> Int { + if left.0 < right.0 { + -1 + } else if left.0 > right.0 { + 1 + } else if left.1 < right.1 { + -1 + } else if left.1 > right.1 { + 1 + } else { + 0 + } + }, + ) + let unique : Array[(Double, Double)] = [] + for point in sorted { + if unique.length() == 0 || unique[unique.length() - 1] != point { + unique.push(point) + } + } + if unique.length() < 3 { + return unique + } + let lower : Array[(Double, Double)] = [] + for point in unique { + while lower.length() >= 2 && + lisa_cross( + lower[lower.length() - 2], + lower[lower.length() - 1], + point, + ) <= 0.0 { + ignore(lower.pop()) + } + lower.push(point) + } + let upper : Array[(Double, Double)] = [] + let mut index = unique.length() - 1 + while index >= 0 { + let point = unique[index] + while upper.length() >= 2 && + lisa_cross( + upper[upper.length() - 2], + upper[upper.length() - 1], + point, + ) <= 0.0 { + ignore(upper.pop()) + } + upper.push(point) + index = index - 1 + } + ignore(lower.pop()) + ignore(upper.pop()) + for point in upper { + lower.push(point) + } + lower +} + +///| +fn lisa_polygon_area(vertices : Array[(Double, Double)]) -> Double { + let mut twice_area = 0.0 + for index in 0.. Array[(Double, Double)] { + if padding <= 0.0 { + return vertices.copy() + } + let mut center_x = 0.0 + let mut center_y = 0.0 + for vertex in vertices { + center_x = center_x + vertex.0 + center_y = center_y + vertex.1 + } + center_x = center_x / vertices.length().to_double() + center_y = center_y / vertices.length().to_double() + let output : Array[(Double, Double)] = [] + for vertex in vertices { + let dx = vertex.0 - center_x + let dy = vertex.1 - center_y + let distance = (dx * dx + dy * dy).sqrt() + if distance > 1.0e-14 { + let scale = (distance + padding) / distance + output.push((center_x + dx * scale, center_y + dy * scale)) + } else { + output.push(vertex) + } + } + output +} + +///| +fn lisa_image_window( + image_id : String, + cells : Array[LisaCell], + indices : Array[Int], + config : LisaConfig, +) -> LisaImageWindow raise LisaError { + if indices.length() < 2 { + raise LisaError("lisaClust images must contain at least two cells") + } + let mut min_x = cells[indices[0]].x + let mut max_x = min_x + let mut min_y = cells[indices[0]].y + let mut max_y = min_y + let points : Array[(Double, Double)] = [] + for index in indices { + let cell = cells[index] + min_x = min_x.min(cell.x) + max_x = max_x.max(cell.x) + min_y = min_y.min(cell.y) + max_y = max_y.max(cell.y) + points.push((cell.x, cell.y)) + } + let width = max_x - min_x + let height = max_y - min_y + if width <= 1.0e-14 || height <= 1.0e-14 { + raise LisaError("lisaClust image windows must have positive width and height") + } + let vertices = match config.window_kind { + LisaRectangle => [ + (min_x - config.window_padding, min_y - config.window_padding), + (max_x + config.window_padding, min_y - config.window_padding), + (max_x + config.window_padding, max_y + config.window_padding), + (min_x - config.window_padding, max_y + config.window_padding), + ] + LisaConvexHull => { + let hull = lisa_convex_hull(points) + if hull.length() < 3 { + raise LisaError("lisaClust convex windows require non-collinear cells") + } + lisa_expand_polygon(hull, config.window_padding) + } + } + let area = lisa_polygon_area(vertices) + if !lisa_is_finite(area) || area <= 1.0e-14 { + raise LisaError("lisaClust image window area must be positive") + } + let mut vertex_min_x = vertices[0].0 + let mut vertex_max_x = vertices[0].0 + let mut vertex_min_y = vertices[0].1 + let mut vertex_max_y = vertices[0].1 + for vertex in vertices { + vertex_min_x = vertex_min_x.min(vertex.0) + vertex_max_x = vertex_max_x.max(vertex.0) + vertex_min_y = vertex_min_y.min(vertex.1) + vertex_max_y = vertex_max_y.max(vertex.1) + } + let max_radius = ((vertex_max_x - vertex_min_x).min( + vertex_max_y - vertex_min_y, + )) / + 2.01 + LisaImageWindow::{ image_id, vertices, area, max_radius } +} + +///| +fn lisa_ray_boundary_distance( + x : Double, + y : Double, + dx : Double, + dy : Double, + vertices : Array[(Double, Double)], +) -> Double { + let mut closest = 1.0e300 + for index in 0..= 0.0 && + segment >= -1.0e-10 && + segment <= 1.0 + 1.0e-10 { + closest = closest.min(distance) + } + } + closest +} + +///| +fn lisa_visible_disc_fraction( + cell : LisaCell, + radius : Double, + window : LisaImageWindow, + samples : Int, +) -> Double { + let angle_step = 2.0 * @math.PI / samples.to_double() + let mut area = 0.0 + for sample in 0.. Array[Double] { + let density = Array::make(indices.length(), 0.0) + let denominator = 2.0 * bandwidth * bandwidth + for target in 0.. Array[String] { + let output : Array[String] = [] + for cell_type in target_cell_types { + for radius in radii { + output.push(radius.to_string() + "_" + cell_type) + } + } + output +} + +///| +pub fn lisa_curves( + cells : Array[LisaCell], + config? : LisaConfig = LisaConfig::default(), +) -> LisaCurveSet raise LisaError { + lisa_validate_cells(cells) + let all_types : Array[String] = [] + for cell in cells { + all_types.push(cell.cell_type) + } + let target_cell_types = lisa_unique_strings(all_types) + let (image_order, groups) = lisa_group_images(cells) + let values : Array[Array[Double]] = [] + for _ in cells { + values.push( + Array::make(target_cell_types.length() * config.radii.length(), 0.0), + ) + } + let windows : Array[LisaImageWindow] = [] + let effective_radii : Array[LisaImageRadii] = [] + for image_id in image_order { + let indices = groups[image_id] + let window = lisa_image_window(image_id, cells, indices, config) + windows.push(window) + let image_radii : Array[Double] = [] + for radius in config.radii { + image_radii.push(radius.min(window.max_radius)) + } + effective_radii.push( + LisaImageRadii::{ image_id, radii: image_radii.copy() }, + ) + let density_weights = lisa_density_weights( + cells, + indices, + config.bandwidth, + config.min_density, + ) + let local_by_global : Map[Int, Int] = Map([]) + for local in 0.. (observed - expected) / expected.sqrt() + LisaCenteredL => observed.sqrt() - expected.sqrt() + } + } + } + } + } + } + let cell_ids : Array[String] = [] + let image_ids : Array[String] = [] + let cell_types : Array[String] = [] + for cell in cells { + cell_ids.push(cell.cell_id) + image_ids.push(cell.image_id) + cell_types.push(cell.cell_type) + } + LisaCurveSet::{ + cell_ids, + image_ids, + cell_types, + target_cell_types, + radii: config.radii.copy(), + feature_names: lisa_feature_names(target_cell_types, config.radii), + values, + effective_radii, + windows, + curve_kind: config.curve_kind, + } +} + +///| +fn lisa_squared_distance( + left : Array[Double], + right : Array[Double], +) -> Double { + let mut output = 0.0 + for index in 0.. Array[Array[Double]] { + let centroids : Array[Array[Double]] = [data[first].copy()] + let selected = Array::make(data.length(), false) + selected[first] = true + while centroids.length() < clusters { + let mut best_index = -1 + let mut best_distance = -1.0 + for point in 0.. best_distance { + best_distance = nearest + best_index = point + } + } + if best_index < 0 { + break + } + selected[best_index] = true + centroids.push(data[best_index].copy()) + } + centroids +} + +///| +fn lisa_assign_clusters( + data : Array[Array[Double]], + centroids : Array[Array[Double]], +) -> (Array[Int], Double) { + let labels = Array::make(data.length(), 0) + let mut inertia = 0.0 + for point in 0.. Array[Array[Double]] { + let clusters = old_centroids.length() + let dimensions = data[0].length() + let output : Array[Array[Double]] = [] + for _ in 0.. 0 { + for dimension in 0.. farthest_distance { + farthest = point + farthest_distance = distance + } + } + output[cluster] = data[farthest].copy() + } + } + output +} + +///| +struct LisaKmeansFit { + labels : Array[Int] + centroids : Array[Array[Double]] + inertia : Double + iterations : Int + converged : Bool +} + +///| +fn lisa_kmeans_once( + data : Array[Array[Double]], + config : LisaConfig, + start : Int, +) -> LisaKmeansFit { + let first = (config.seed + start * 9973) % data.length() + let mut centroids = lisa_initialize_centroids( + data, + config.n_clusters, + first, + ) + let mut labels = Array::make(data.length(), -1) + let mut iterations = 0 + let mut converged = false + for iteration in 0.. LisaKmeansFit { + let mapping = Array::make(fit.centroids.length(), -1) + let order : Array[Int] = [] + for label in fit.labels { + if mapping[label] < 0 { + mapping[label] = order.length() + order.push(label) + } + } + for label in 0.. Double { + if clusters <= 1 || data.length() <= 1 { + return 0.0 + } + let mut total = 0.0 + for point in 0.. 0 { + nearest = nearest.min(sums[cluster] / counts[cluster].to_double()) + } + } + if nearest < 1.0e299 { + let denominator = within.max(nearest) + if denominator > 0.0 { + total = total + (nearest - within) / denominator + } + } + } + total / data.length().to_double() +} + +///| +fn lisa_enrichment( + curves : LisaCurveSet, + labels : Array[Int], + config : LisaConfig, +) -> (Array[LisaRegionEnrichment], Array[LisaRegionSummary]) { + let cell_types = lisa_unique_strings(curves.cell_types) + let counts : Array[Array[Int]] = [] + for _ in cell_types { + counts.push(Array::make(config.n_clusters, 0)) + } + let type_totals = Array::make(cell_types.length(), 0) + let region_totals = Array::make(config.n_clusters, 0) + for cell in 0.. 0.0 { + counts[type_index][region].to_double() / expected + } else { + 0.0 + } + enrichment.push( + LisaRegionEnrichment::{ + cell_type: cell_types[type_index], + region: config.region_prefix + "_" + (region + 1).to_string(), + observed: counts[type_index][region], + expected, + relative_frequency, + }, + ) + } + } + let summaries : Array[LisaRegionSummary] = [] + for region in 0.. maximum { + dominant = entry.cell_type + maximum = entry.relative_frequency + } + } + summaries.push( + LisaRegionSummary::{ + region: config.region_prefix + "_" + (region + 1).to_string(), + size: region_totals[region], + dominant_cell_type: dominant, + maximum_enrichment: maximum.max(0.0), + }, + ) + } + (enrichment, summaries) +} + +///| +pub fn lisaclust_from_curves( + curves : LisaCurveSet, + config? : LisaConfig = LisaConfig::default(), +) -> LisaResult raise LisaError { + if curves.n_cells() == 0 || curves.n_features() == 0 { + raise LisaError("lisaClust clustering requires non-empty curves") + } + if curves.values.length() != curves.n_cells() { + raise LisaError("lisaClust curve rows must match cells") + } + if config.n_clusters > curves.n_cells() { + raise LisaError("lisaClust cluster count must not exceed the cell count") + } + for row in curves.values { + if row.length() != curves.n_features() { + raise LisaError("lisaClust curve matrix must be rectangular") + } + for value in row { + if !lisa_is_finite(value) { + raise LisaError("lisaClust curves must be finite") + } + } + } + let mut best : LisaKmeansFit? = None + for start in 0.. Some(fit) + Some(current) => + if fit.inertia < current.inertia { + Some(fit) + } else { + Some(current) + } + } + } + let fit = lisa_canonicalize_fit( + match best { + Some(value) => value + None => raise LisaError("lisaClust k-means did not produce a fit") + }, + ) + let cluster_sizes = Array::make(config.n_clusters, 0) + let regions : Array[String] = [] + for label in fit.labels { + cluster_sizes[label] = cluster_sizes[label] + 1 + regions.push(config.region_prefix + "_" + (label + 1).to_string()) + } + let silhouette = lisa_silhouette( + curves.values, + fit.labels, + config.n_clusters, + ) + let (enrichment, region_summaries) = lisa_enrichment( + curves, + fit.labels, + config, + ) + LisaResult::{ + curves, + labels: fit.labels, + regions, + centroids: fit.centroids, + cluster_sizes, + inertia: fit.inertia, + silhouette, + iterations: fit.iterations, + converged: fit.converged, + enrichment, + region_summaries, + config, + } +} + +///| +pub fn lisaclust( + cells : Array[LisaCell], + config? : LisaConfig = LisaConfig::default(), +) -> LisaResult raise LisaError { + let curves = lisa_curves(cells, config~) + lisaclust_from_curves(curves, config~) +} + +///| +fn lisa_copy_string_map(input : Map[String, String]) -> Map[String, String] { + let output : Map[String, String] = Map([], capacity=input.length()) + for key in input.keys() { + output[key] = input[key] + } + output +} + +///| +fn lisa_copy_spatial_experiment( + experiment : SpatialExperiment, +) -> SpatialExperiment { + let output = SpatialExperiment::new() + for assay_name in experiment.assay.keys() { + let matrix : Array[Array[Double]] = [] + for row in experiment.assay[assay_name] { + matrix.push(row.copy()) + } + output.assay[assay_name] = matrix + } + for row in experiment.row_data { + output.row_data.push(lisa_copy_string_map(row)) + } + for column in experiment.col_data { + output.col_data.push(lisa_copy_string_map(column)) + } + for coordinate in experiment.spatial_coords { + output.spatial_coords.push(coordinate) + } + for image in experiment.images { + output.images.push(image) + } + for key in experiment.metadata.keys() { + output.metadata[key] = experiment.metadata[key] + } + output +} + +///| +fn lisa_required_column( + column : Map[String, String], + key : String, + row : Int, +) -> String raise LisaError { + match column.get(key) { + Some(value) => + if value == "" { + raise LisaError( + "lisaClust SpatialExperiment column '" + + key + + "' is empty at cell " + + row.to_string(), + ) + } else { + value + } + None => + raise LisaError( + "lisaClust SpatialExperiment is missing column '" + key + "'", + ) + } +} + +///| +pub fn lisaclust_spatial_experiment( + experiment : SpatialExperiment, + image_id_key? : String = "imageID", + cell_type_key? : String = "cellType", + cell_id_key? : String = "", + region_key? : String = "region", + config? : LisaConfig = LisaConfig::default(), +) -> LisaSpatialExperimentOutput raise LisaError { + if experiment.col_data.length() == 0 { + raise LisaError("lisaClust SpatialExperiment col_data must not be empty") + } + if experiment.col_data.length() != experiment.spatial_coords.length() { + raise LisaError( + "lisaClust SpatialExperiment coordinates must match col_data rows", + ) + } + if image_id_key == "" || cell_type_key == "" || region_key == "" { + raise LisaError("lisaClust SpatialExperiment key names must not be empty") + } + let cells : Array[LisaCell] = [] + for row in 0.. Array[LisaCell] { + let cells : Array[LisaCell] = [] + for image in 0..<2 { + for column in 0..<8 { + for row in 0..<4 { + let left = column < 4 + let cell_type = if left { + if (column + row + image) % 3 == 0 { "B_cell" } else { "T_cell" } + } else if (column + row + image) % 3 == 0 { + "Stroma" + } else { + "Tumour" + } + let cell_id = "img" + + (image + 1).to_string() + + "_c" + + column.to_string() + + "_r" + + row.to_string() + let cell = LisaCell::create( + cell_id, + "image_" + (image + 1).to_string(), + cell_type, + column.to_double() * 2.0 + image.to_double() * 0.1, + row.to_double() * 2.0 + (column % 2).to_double() * 0.15, + ) catch { + _ => abort("lisaClust example cell should be valid") + } + cells.push(cell) + } + } + } + cells +} diff --git a/src/mast_advanced.mbt b/src/mast_advanced.mbt new file mode 100644 index 00000000..ea90f823 --- /dev/null +++ b/src/mast_advanced.mbt @@ -0,0 +1,1655 @@ +// Advanced single-cell hurdle models inspired by Bioconductor MAST 1.39.0. +// +// Expression matrices use the Bioconductor feature x cell convention. Each +// feature is fitted with a Bayesian logistic model for detection and a +// Gaussian model for the positive expression values. + +///| +pub suberror MastAdvancedError { + MastAdvancedError(String) +} + +///| +pub struct MastAdvancedConfig { + max_iterations : Int + tolerance : Double + cauchy_prior_scale : Double + ridge : Double + empirical_bayes : Bool + ebayes_use_full_model : Bool + maximum_prior_df : Double + minimum_detected : Int + minimum_probability : Double + fdr_threshold : Double +} derive(Debug) + +///| +pub fn MastAdvancedConfig::create( + max_iterations? : Int = 100, + tolerance? : Double = 1.0e-8, + cauchy_prior_scale? : Double = 2.5, + ridge? : Double = 1.0e-8, + empirical_bayes? : Bool = true, + ebayes_use_full_model? : Bool = false, + maximum_prior_df? : Double = 1000.0, + minimum_detected? : Int = 2, + minimum_probability? : Double = 1.0e-9, + fdr_threshold? : Double = 0.05, +) -> MastAdvancedConfig raise MastAdvancedError { + if max_iterations < 1 { + raise MastAdvancedError("max_iterations must be positive") + } + if tolerance <= 0.0 || !mast_adv_is_finite(tolerance) { + raise MastAdvancedError("tolerance must be finite and positive") + } + if cauchy_prior_scale <= 0.0 || !mast_adv_is_finite(cauchy_prior_scale) { + raise MastAdvancedError("cauchy_prior_scale must be finite and positive") + } + if ridge < 0.0 || !mast_adv_is_finite(ridge) { + raise MastAdvancedError("ridge must be finite and non-negative") + } + if maximum_prior_df <= 0.0 || !mast_adv_is_finite(maximum_prior_df) { + raise MastAdvancedError("maximum_prior_df must be finite and positive") + } + if minimum_detected < 1 { + raise MastAdvancedError("minimum_detected must be positive") + } + if minimum_probability <= 0.0 || minimum_probability >= 0.5 { + raise MastAdvancedError("minimum_probability must be in (0, 0.5)") + } + if fdr_threshold <= 0.0 || fdr_threshold > 1.0 { + raise MastAdvancedError("fdr_threshold must be in (0, 1]") + } + MastAdvancedConfig::{ + max_iterations, + tolerance, + cauchy_prior_scale, + ridge, + empirical_bayes, + ebayes_use_full_model, + maximum_prior_df, + minimum_detected, + minimum_probability, + fdr_threshold, + } +} + +///| +pub fn MastAdvancedConfig::default() -> MastAdvancedConfig { + MastAdvancedConfig::{ + max_iterations: 100, + tolerance: 1.0e-8, + cauchy_prior_scale: 2.5, + ridge: 1.0e-8, + empirical_bayes: true, + ebayes_use_full_model: false, + maximum_prior_df: 1000.0, + minimum_detected: 2, + minimum_probability: 1.0e-9, + fdr_threshold: 0.05, + } +} + +///| +pub struct MastAdvancedData { + expression : Array[Array[Double]] + gene_names : Array[String] + cell_names : Array[String] + design : Array[Array[Double]] + coefficient_names : Array[String] + cdr : Array[Double] + detection_limit : Double + n_genes : Int + n_cells : Int + n_coefficients : Int +} derive(Debug) + +///| +pub struct MastAdvancedResult { + gene_names : Array[String] + coefficient_names : Array[String] + tested_coefficients : Array[Int] + tested_names : Array[String] + detection_rates : Array[Double] + n_detected : Array[Int] + discrete_coefficients : Array[Array[Double]] + continuous_coefficients : Array[Array[Double]] + discrete_standard_errors : Array[Array[Double]] + continuous_standard_errors : Array[Array[Double]] + discrete_statistics : Array[Double?] + continuous_statistics : Array[Double?] + hurdle_statistics : Array[Double?] + discrete_p_values : Array[Double?] + continuous_p_values : Array[Double?] + hurdle_p_values : Array[Double?] + discrete_fdr : Array[Double?] + continuous_fdr : Array[Double?] + hurdle_fdr : Array[Double?] + marginal_log_fc : Array[Double?] + marginal_log_fc_variance : Array[Double?] + continuous_variance : Array[Double?] + moderated_variance : Array[Double?] + discrete_converged : Array[Bool] + continuous_converged : Array[Bool] + prior_variance : Double + prior_df : Double + empirical_bayes : Bool + fdr_threshold : Double +} derive(Debug) + +///| +pub struct MastAdvancedSCEOutput { + experiment : SingleCellExperiment + result : MastAdvancedResult +} + +///| +priv struct MastAdvCoreFit { + coefficients : Array[Double] + covariance : Array[Array[Double]] + log_likelihood : Double + residual_df : Int + raw_variance : Double + moderated_variance : Double + converged : Bool + fitted : Bool +} + +///| +fn mast_adv_is_finite(value : Double) -> Bool { + value == value && value.abs() < 1.0e300 +} + +///| +fn mast_adv_clamp(value : Double, lower : Double, upper : Double) -> Double { + if value < lower { + lower + } else if value > upper { + upper + } else { + value + } +} + +///| +fn mast_adv_zero_matrix(rows : Int, columns : Int) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for _ in 0.. Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in matrix { + output.push(row.copy()) + } + output +} + +///| +fn mast_adv_copy_string_map( + source : Map[String, Array[String]], +) -> Map[String, Array[String]] { + let output : Map[String, Array[String]] = Map([]) + let keys = source.keys().collect() + for key in keys { + output[key] = source[key].copy() + } + output +} + +///| +fn mast_adv_prepare_names( + supplied : Array[String], + length : Int, + prefix : String, +) -> Array[String] raise MastAdvancedError { + if supplied.length() != 0 && supplied.length() != length { + raise MastAdvancedError(prefix + " names do not match the matrix dimension") + } + let output : Array[String] = [] + for index in 0.. (Int, Int) raise MastAdvancedError { + if expression.length() == 0 { + raise MastAdvancedError("expression must contain at least one gene") + } + let cells = expression[0].length() + if cells == 0 { + raise MastAdvancedError("expression must contain at least one cell") + } + for row in expression { + if row.length() != cells { + raise MastAdvancedError("expression must be rectangular") + } + for value in row { + if !mast_adv_is_finite(value) || value < 0.0 { + raise MastAdvancedError( + "expression must contain finite non-negative values", + ) + } + } + } + (expression.length(), cells) +} + +///| +fn mast_adv_matrix_rank(matrix : Array[Array[Double]]) -> Int { + if matrix.length() == 0 || matrix[0].length() == 0 { + return 0 + } + let work = mast_adv_copy_matrix(matrix) + let rows = work.length() + let columns = work[0].length() + let mut rank = 0 + let mut column = 0 + while column < columns && rank < rows { + let mut pivot = rank + let mut pivot_value = work[pivot][column].abs() + for candidate in (rank + 1).. pivot_value { + pivot = candidate + pivot_value = value + } + } + if pivot_value > 1.0e-10 { + if pivot != rank { + let temporary = work[rank] + work[rank] = work[pivot] + work[pivot] = temporary + } + let divisor = work[rank][column] + for current in column.. Array[Double] { + let genes = expression.length() + let cells = expression[0].length() + let output = Array::make(cells, 0.0) + for cell in 0.. detection_limit { + detected = detected + 1 + } + } + output[cell] = detected.to_double() / genes.to_double() + } + output +} + +///| +pub fn MastAdvancedData::create( + expression : Array[Array[Double]], + design : Array[Array[Double]], + coefficient_names : Array[String], + gene_names? : Array[String] = [], + cell_names? : Array[String] = [], + detection_limit? : Double = 0.0, + include_cdr? : Bool = true, + cdr_name? : String = "cngeneson", +) -> MastAdvancedData raise MastAdvancedError { + let (genes, cells) = mast_adv_validate_expression(expression) + if !mast_adv_is_finite(detection_limit) || detection_limit < 0.0 { + raise MastAdvancedError("detection_limit must be finite and non-negative") + } + if design.length() != cells { + raise MastAdvancedError("design rows must match expression cells") + } + if design.length() == 0 || design[0].length() == 0 { + raise MastAdvancedError("design must contain at least one coefficient") + } + let supplied_coefficients = design[0].length() + if coefficient_names.length() != supplied_coefficients { + raise MastAdvancedError("coefficient_names must match the design columns") + } + let prepared_coefficient_names = mast_adv_prepare_names( + coefficient_names, supplied_coefficients, "coefficient", + ) + for row in design { + if row.length() != supplied_coefficients { + raise MastAdvancedError("design must be rectangular") + } + for value in row { + if !mast_adv_is_finite(value) { + raise MastAdvancedError("design must contain finite values") + } + } + } + let cdr = mast_adv_calculate_cdr(expression, detection_limit) + let prepared_design : Array[Array[Double]] = [] + for cell in 0.. MastAdvancedData raise MastAdvancedError { + let (_, cells) = mast_adv_validate_expression(expression) + if groups.length() != cells { + raise MastAdvancedError("groups must match expression cells") + } + let levels : Array[String] = [] + for group in groups { + if group.trim().length() == 0 { + raise MastAdvancedError("group labels cannot be empty") + } + if !levels.contains(group) { + levels.push(group) + } + } + if levels.length() < 2 { + raise MastAdvancedError("at least two group levels are required") + } + let selected_reference = if reference == "" { levels[0] } else { reference } + if !levels.contains(selected_reference) { + raise MastAdvancedError("reference group is absent") + } + let encoded_levels : Array[String] = [] + for level in levels { + if level != selected_reference { + encoded_levels.push(level) + } + } + let design : Array[Array[Double]] = [] + for group in groups { + let row = Array::make(encoded_levels.length() + 1, 0.0) + row[0] = 1.0 + for level in 0.. Array[Array[Double]]? { + let size = matrix.length() + if size == 0 { + return None + } + let lower = mast_adv_zero_matrix(size, size) + for row in 0.. Array[Double] { + let size = lower.length() + let forward = Array::make(size, 0.0) + for row in 0..= 0 { + let mut value = forward[row] + for column in (row + 1).. Array[Array[Double]] { + let size = lower.length() + let inverse = mast_adv_zero_matrix(size, size) + for column in 0.. Array[Array[Double]]? { + let mut added = ridge + for attempt in 0..<14 { + let candidate = mast_adv_copy_matrix(matrix) + for index in 0.. return Some(lower) + None => + added = if attempt == 0 && added == 0.0 { + 1.0e-10 + } else if added == 0.0 { + 1.0e-10 + } else { + added * 10.0 + } + } + } + None +} + +///| +fn mast_adv_logistic(value : Double) -> Double { + if value >= 0.0 { + let inverse = @math.exp(-value) + 1.0 / (1.0 + inverse) + } else { + let exponential = @math.exp(value) + exponential / (1.0 + exponential) + } +} + +///| +fn mast_adv_linear_predictor( + design : Array[Array[Double]], + coefficients : Array[Double], +) -> Array[Double] { + let output = Array::make(design.length(), 0.0) + for row in 0.. MastAdvCoreFit { + let observations = design.length() + let parameters = design[0].length() + let coefficients = Array::make(parameters, 0.0) + let mut positives = 0 + for value in detected { + if value { + positives = positives + 1 + } + } + if positives == 0 || positives == observations { + return MastAdvCoreFit::{ + coefficients, + covariance: mast_adv_zero_matrix(parameters, parameters), + log_likelihood: 0.0, + residual_df: 0, + raw_variance: 0.0, + moderated_variance: 0.0, + converged: true, + fitted: false, + } + } + coefficients[0] = @math.ln( + positives.to_double() / (observations - positives).to_double(), + ) + let scale_squared = config.cauchy_prior_scale * config.cauchy_prior_scale + let mut converged = false + for _ in 0.. value + None => break + } + let updated = mast_adv_cholesky_solve(lower, right_hand_side) + let mut maximum_change = 0.0 + for parameter in 0.. mast_adv_cholesky_inverse(lower) + None => mast_adv_zero_matrix(parameters, parameters) + } + MastAdvCoreFit::{ + coefficients, + covariance, + log_likelihood, + residual_df: (positives.min(observations - positives) - parameters).max(0), + raw_variance: 1.0, + moderated_variance: 1.0, + converged, + fitted: converged, + } +} + +///| +fn mast_adv_positive_data( + expression : Array[Double], + design : Array[Array[Double]], + detection_limit : Double, +) -> (Array[Double], Array[Array[Double]]) { + let response : Array[Double] = [] + let positive_design : Array[Array[Double]] = [] + for cell in 0.. detection_limit { + response.push(expression[cell]) + positive_design.push(design[cell].copy()) + } + } + (response, positive_design) +} + +///| +fn mast_adv_continuous_fit( + expression : Array[Double], + design : Array[Array[Double]], + detection_limit : Double, + prior_variance : Double, + prior_df : Double, + config : MastAdvancedConfig, +) -> MastAdvCoreFit { + let parameters = design[0].length() + let (response, positive_design) = mast_adv_positive_data( + expression, design, detection_limit, + ) + let observations = response.length() + if observations <= parameters || + observations < config.minimum_detected || + mast_adv_matrix_rank(positive_design) != parameters { + return MastAdvCoreFit::{ + coefficients: Array::make(parameters, 0.0), + covariance: mast_adv_zero_matrix(parameters, parameters), + log_likelihood: 0.0, + residual_df: 0, + raw_variance: 0.0, + moderated_variance: 0.0, + converged: false, + fitted: false, + } + } + let information = mast_adv_zero_matrix(parameters, parameters) + let right_hand_side = Array::make(parameters, 0.0) + for observation in 0.. value + None => + return MastAdvCoreFit::{ + coefficients: Array::make(parameters, 0.0), + covariance: mast_adv_zero_matrix(parameters, parameters), + log_likelihood: 0.0, + residual_df: 0, + raw_variance: 0.0, + moderated_variance: 0.0, + converged: false, + fitted: false, + } + } + let coefficients = mast_adv_cholesky_solve(lower, right_hand_side) + let fitted = mast_adv_linear_predictor(positive_design, coefficients) + let mut residual_sum_squares = 0.0 + for observation in 0.. 0.0 { + (residual_sum_squares + prior_variance * prior_df) / + (residual_df.to_double() + prior_df) + } else { + raw_variance + } + let likelihood_variance = (if prior_df > 0.0 { + (residual_sum_squares + prior_variance * prior_df) / + (observations.to_double() + prior_df) + } else { + residual_sum_squares / observations.to_double() + }).max(1.0e-15) + let covariance = mast_adv_cholesky_inverse(lower) + for row in 0.. Double { + let coefficients = [ + 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, + -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, + 1.5056327351493116e-7, + ] + let shifted = value - 1.0 + let mut sum = coefficients[0] + for index in 1.. Double { + let a = @math.exp(log_a) + let b = @math.exp(log_b) + let mut value = 0.0 + for index in 0.. (Array[Double], Array[Double]) { + let residual_df : Array[Double] = [] + let residual_ss : Array[Double] = [] + for gene in 0.. parameters && + mast_adv_matrix_rank(positive_design) == parameters { + let information = mast_adv_zero_matrix(parameters, parameters) + let right_hand_side = Array::make(parameters, 0.0) + for observation in 0.. { + let coefficients = mast_adv_cholesky_solve(lower, right_hand_side) + let fitted = mast_adv_linear_predictor( + positive_design, coefficients, + ) + let mut sum_squares = 0.0 + for observation in 0.. 1.0e-15 { + residual_df.push((observations - parameters).to_double()) + residual_ss.push(sum_squares) + } + } + None => () + } + } + } else if observations > 1 { + let mut mean = 0.0 + for value in response { + mean = mean + value + } + mean = mean / observations.to_double() + let mut sum_squares = 0.0 + for value in response { + let residual = value - mean + sum_squares = sum_squares + residual * residual + } + if sum_squares > 1.0e-15 { + residual_df.push((observations - 1).to_double()) + residual_ss.push(sum_squares) + } + } + } + (residual_df, residual_ss) +} + +///| +fn mast_adv_estimate_ebayes( + data : MastAdvancedData, + config : MastAdvancedConfig, +) -> (Double, Double) { + if !config.empirical_bayes { + return (0.0, 0.0) + } + let (residual_df, residual_ss) = mast_adv_ebayes_sufficient( + data, + config.ebayes_use_full_model, + ) + if residual_df.length() < 2 { + return (0.0, 0.0) + } + let mut mean_variance = 0.0 + for index in 0.. best { + best = likelihood + log_a = candidate_a + log_b = candidate_b + improved = true + } + } + if !improved { + step_a = step_a * 0.7 + step_b = step_b * 0.7 + } + if step_a < 1.0e-5 && step_b < 1.0e-5 { + break + } + } + let a = @math.exp(log_a) + let b = @math.exp(log_b) + ((b / a).max(1.0e-12), (2.0 * a).min(config.maximum_prior_df)) +} + +///| +fn mast_adv_select_columns( + design : Array[Array[Double]], + keep : Array[Int], +) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in design { + let selected : Array[Double] = [] + for column in keep { + selected.push(row[column]) + } + output.push(selected) + } + output +} + +///| +fn mast_adv_chi_square_q(degrees : Double, statistic : Double) -> Double { + if statistic <= 0.0 { + return 1.0 + } + mast_adv_upper_gamma_q(0.5 * degrees, 0.5 * statistic) +} + +///| +fn mast_adv_upper_gamma_q(a : Double, x : Double) -> Double { + if x <= 0.0 { + return 1.0 + } + if x < a + 1.0 { + let mut term = 1.0 / a + let mut sum = term + let mut index = 1 + while index < 300 { + term = term * x / (a + index.to_double()) + sum = sum + term + if term.abs() < sum.abs() * 1.0e-12 { + break + } + index = index + 1 + } + return mast_adv_clamp( + 1.0 - sum * @math.exp(-x + a * @math.ln(x) - mast_adv_log_gamma(a)), + 0.0, + 1.0, + ) + } + let tiny = 1.0e-300 + let mut b = x + 1.0 - a + let mut c = 1.0 / tiny + let mut d = 1.0 / b + let mut value = d + let mut index = 1 + while index < 300 { + let an = -index.to_double() * (index.to_double() - a) + b = b + 2.0 + d = an * d + b + if d.abs() < tiny { + d = tiny + } + c = b + an / c + if c.abs() < tiny { + c = tiny + } + d = 1.0 / d + let delta = d * c + value = value * delta + if (delta - 1.0).abs() < 1.0e-12 { + break + } + index = index + 1 + } + mast_adv_clamp( + value * @math.exp(-x + a * @math.ln(x) - mast_adv_log_gamma(a)), + 0.0, + 1.0, + ) +} + +///| +fn mast_adv_bh(values : Array[Double?]) -> Array[Double?] { + let indices : Array[Int] = [] + for index in 0..= 0 { + let index = indices[position] + let adjusted = (values[index].unwrap_or(1.0) * + count.to_double() / + (position + 1).to_double()).min(1.0) + running = running.min(adjusted) + output[index] = Some(running) + position = position - 1 + } + output +} + +///| +fn mast_adv_standard_errors(covariance : Array[Array[Double]]) -> Array[Double] { + let output = Array::make(covariance.length(), 0.0) + for index in 0.. (Double, Double)? { + if !discrete.fitted || + !continuous.fitted || + tested <= 0 || + tested >= discrete.coefficients.length() { + return None + } + let continuous_baseline = continuous.coefficients[0] + let continuous_comparison = continuous_baseline + + continuous.coefficients[tested] + let discrete_baseline = mast_adv_logistic(discrete.coefficients[0]) + let discrete_comparison = mast_adv_logistic( + discrete.coefficients[0] + discrete.coefficients[tested], + ) + let effect = continuous_comparison * discrete_comparison - + continuous_baseline * discrete_baseline + let continuous_gradient = Array::make(continuous.coefficients.length(), 0.0) + continuous_gradient[0] = discrete_comparison - discrete_baseline + continuous_gradient[tested] = discrete_comparison + let discrete_gradient = Array::make(discrete.coefficients.length(), 0.0) + discrete_gradient[0] = continuous_comparison * + discrete_comparison * + (1.0 - discrete_comparison) - + continuous_baseline * discrete_baseline * (1.0 - discrete_baseline) + discrete_gradient[tested] = continuous_comparison * + discrete_comparison * + (1.0 - discrete_comparison) + let mut variance = 0.0 + for left in 0.. MastAdvancedResult raise MastAdvancedError { + if tested_coefficients.length() == 0 { + raise MastAdvancedError("tested_coefficients cannot be empty") + } + let tested = tested_coefficients.copy() + for index in 0..= data.n_coefficients { + raise MastAdvancedError( + "tested coefficients must be non-intercept design columns", + ) + } + for previous in 0.. data.detection_limit + if detected[cell] { + detected_count = detected_count + 1 + } + } + n_detected[gene] = detected_count + detection_rates[gene] = detected_count.to_double() / + data.n_cells.to_double() + let discrete_full = mast_adv_logistic_fit(data.design, detected, config) + let discrete_reduced = mast_adv_logistic_fit( + reduced_design, detected, config, + ) + let continuous_full = mast_adv_continuous_fit( + data.expression[gene], + data.design, + data.detection_limit, + prior_variance, + prior_df, + config, + ) + let continuous_reduced = mast_adv_continuous_fit( + data.expression[gene], + reduced_design, + data.detection_limit, + prior_variance, + prior_df, + config, + ) + discrete_coefficients.push(discrete_full.coefficients) + continuous_coefficients.push(continuous_full.coefficients) + discrete_standard_errors.push( + mast_adv_standard_errors(discrete_full.covariance), + ) + continuous_standard_errors.push( + mast_adv_standard_errors(continuous_full.covariance), + ) + discrete_converged[gene] = discrete_full.converged + continuous_converged[gene] = continuous_full.converged + if continuous_full.fitted { + continuous_variance[gene] = Some(continuous_full.raw_variance) + moderated_variance[gene] = Some(continuous_full.moderated_variance) + } + let discrete_testable = discrete_full.fitted && discrete_reduced.fitted + let continuous_testable = continuous_full.fitted && + continuous_reduced.fitted && + continuous_full.residual_df > 0 && + continuous_reduced.residual_df > 0 + let mut combined_statistic = 0.0 + let mut combined_degrees = 0 + if discrete_testable { + let statistic = (2.0 * + (discrete_full.log_likelihood - discrete_reduced.log_likelihood)).max(0.0) + discrete_statistics[gene] = Some(statistic) + discrete_p_values[gene] = Some( + mast_adv_chi_square_q(tested.length().to_double(), statistic), + ) + combined_statistic = combined_statistic + statistic + combined_degrees = combined_degrees + tested.length() + } + if continuous_testable { + let statistic = (2.0 * + (continuous_full.log_likelihood - continuous_reduced.log_likelihood)).max( + 0.0, + ) + continuous_statistics[gene] = Some(statistic) + continuous_p_values[gene] = Some( + mast_adv_chi_square_q(tested.length().to_double(), statistic), + ) + combined_statistic = combined_statistic + statistic + combined_degrees = combined_degrees + tested.length() + } + if combined_degrees > 0 { + hurdle_statistics[gene] = Some(combined_statistic) + hurdle_p_values[gene] = Some( + mast_adv_chi_square_q(combined_degrees.to_double(), combined_statistic), + ) + } + match mast_adv_marginal_effect(discrete_full, continuous_full, tested[0]) { + Some(effect) => { + marginal_log_fc[gene] = Some(effect.0) + marginal_log_fc_variance[gene] = Some(effect.1) + } + None => () + } + } + let tested_names : Array[String] = [] + for coefficient in tested { + tested_names.push(data.coefficient_names[coefficient]) + } + MastAdvancedResult::{ + gene_names: data.gene_names.copy(), + coefficient_names: data.coefficient_names.copy(), + tested_coefficients: tested, + tested_names, + detection_rates, + n_detected, + discrete_coefficients, + continuous_coefficients, + discrete_standard_errors, + continuous_standard_errors, + discrete_statistics, + continuous_statistics, + hurdle_statistics, + discrete_p_values, + continuous_p_values, + hurdle_p_values, + discrete_fdr: mast_adv_bh(discrete_p_values), + continuous_fdr: mast_adv_bh(continuous_p_values), + hurdle_fdr: mast_adv_bh(hurdle_p_values), + marginal_log_fc, + marginal_log_fc_variance, + continuous_variance, + moderated_variance, + discrete_converged, + continuous_converged, + prior_variance, + prior_df, + empirical_bayes: config.empirical_bayes && prior_df > 0.0, + fdr_threshold: config.fdr_threshold, + } +} + +///| +pub fn MastAdvancedResult::index_of( + self : MastAdvancedResult, + gene_name : String, +) -> Int? { + for index in 0.. Int { + let mut count = 0 + for value in self.hurdle_p_values { + if value is Some(_) { + count = count + 1 + } + } + count +} + +///| +pub fn MastAdvancedResult::n_significant( + self : MastAdvancedResult, + threshold? : Double = -1.0, +) -> Int { + let selected = if threshold < 0.0 { self.fdr_threshold } else { threshold } + let mut count = 0 + for value in self.hurdle_fdr { + match value { + Some(adjusted) => if adjusted <= selected { count = count + 1 } + None => () + } + } + count +} + +///| +pub fn MastAdvancedResult::significant_genes( + self : MastAdvancedResult, + threshold? : Double = -1.0, +) -> Array[String] { + let selected = if threshold < 0.0 { self.fdr_threshold } else { threshold } + let output : Array[String] = [] + for index in 0.. + if adjusted <= selected { + output.push(self.gene_names[index]) + } + None => () + } + } + output +} + +///| +pub fn MastAdvancedResult::top_genes( + self : MastAdvancedResult, + number : Int, +) -> Array[String] { + if number <= 0 { + return [] + } + let indices : Array[Int] = [] + for index in 0.. String { + "MAST advanced zlm: " + + self.gene_names.length().to_string() + + " genes, " + + self.n_tested().to_string() + + " tested, " + + self.n_significant().to_string() + + " significant at FDR " + + self.fdr_threshold.to_string() + + "; contrast=" + + self.tested_names.join(",") + + "; prior_df=" + + self.prior_df.to_string() +} + +///| +fn mast_adv_option_string(value : Double?) -> String { + match value { + Some(number) => number.to_string() + None => "NA" + } +} + +///| +fn mast_adv_copy_sce(experiment : SingleCellExperiment) -> SingleCellExperiment { + let assays : Map[String, Array[Array[Double]]] = Map([]) + let assay_names = experiment.assays.keys().collect() + for name in assay_names { + assays[name] = mast_adv_copy_matrix(experiment.assays[name]) + } + let reduced_dims : Map[String, Array[Array[Double]]] = Map([]) + let reduced_names = experiment.reduced_dims.keys().collect() + for name in reduced_names { + reduced_dims[name] = mast_adv_copy_matrix(experiment.reduced_dims[name]) + } + let alternatives : Map[String, SingleCellExperiment] = Map([]) + let alternative_names = experiment.alternative_experiments.keys().collect() + for name in alternative_names { + alternatives[name] = mast_adv_copy_sce( + experiment.alternative_experiments[name], + ) + } + let metadata : Map[String, String] = Map([]) + let metadata_names = experiment.metadata.keys().collect() + for name in metadata_names { + metadata[name] = experiment.metadata[name] + } + SingleCellExperiment::{ + assays, + row_data: mast_adv_copy_string_map(experiment.row_data), + col_data: mast_adv_copy_string_map(experiment.col_data), + reduced_dims, + alternative_experiments: alternatives, + metadata, + row_names: experiment.row_names.copy(), + col_names: experiment.col_names.copy(), + } +} + +///| +pub fn mast_advanced_zlm_sce( + experiment : SingleCellExperiment, + group_column : String, + assay_name? : String = "logcounts", + reference? : String = "", + output_prefix? : String = "mast", + detection_limit? : Double = 0.0, + include_cdr? : Bool = true, + config? : MastAdvancedConfig = MastAdvancedConfig::default(), +) -> MastAdvancedSCEOutput raise MastAdvancedError { + if output_prefix.trim().length() == 0 { + raise MastAdvancedError("output_prefix cannot be empty") + } + let expression = match experiment.assays.get(assay_name) { + Some(value) => value + None => raise MastAdvancedError("SCE assay not found: " + assay_name) + } + let groups = match experiment.col_data.get(group_column) { + Some(value) => value + None => + raise MastAdvancedError("SCE column data not found: " + group_column) + } + let data = mast_advanced_from_groups( + expression, + groups, + reference~, + gene_names=experiment.row_names, + cell_names=experiment.col_names, + detection_limit~, + include_cdr~, + ) + let tested : Array[Int] = [] + let upper = if include_cdr { + data.n_coefficients - 1 + } else { + data.n_coefficients + } + for coefficient in 1.. + if value <= config.fdr_threshold { + "significant" + } else { + "not_significant" + } + None => "not_tested" + }, + ) + } + enriched.row_data[output_prefix + ".detectionRate"] = detection_rate + enriched.row_data[output_prefix + ".nDetected"] = detected + enriched.row_data[output_prefix + ".discreteP"] = discrete_p + enriched.row_data[output_prefix + ".continuousP"] = continuous_p + enriched.row_data[output_prefix + ".hurdleP"] = hurdle_p + enriched.row_data[output_prefix + ".hurdleFdr"] = hurdle_fdr + enriched.row_data[output_prefix + ".logFC"] = marginal_log_fc + enriched.row_data[output_prefix + ".class"] = classification + enriched.col_data[output_prefix + ".cdr"] = data.cdr.map(fn(value) { + value.to_string() + }) + enriched.metadata[output_prefix + ".assay"] = assay_name + enriched.metadata[output_prefix + ".group"] = group_column + enriched.metadata[output_prefix + ".reference"] = if reference == "" { + groups[0] + } else { + reference + } + enriched.metadata[output_prefix + ".contrast"] = result.tested_names.join(",") + enriched.metadata[output_prefix + ".priorVariance"] = result.prior_variance.to_string() + enriched.metadata[output_prefix + ".priorDf"] = result.prior_df.to_string() + enriched.metadata[output_prefix + ".tested"] = result.n_tested().to_string() + enriched.metadata[output_prefix + ".significant"] = result + .n_significant() + .to_string() + MastAdvancedSCEOutput::{ experiment: enriched, result } +} + +///| +pub fn mast_advanced_example() -> (MastAdvancedData, Array[Int]) raise MastAdvancedError { + let genes = 8 + let cells = 48 + let expression = mast_adv_zero_matrix(genes, cells) + let groups : Array[String] = [] + for cell in 0..= 24 + groups.push(if treatment { "stimulated" } else { "control" }) + for gene in 0.. MuscatAdvancedAggregation { + SumCounts +} + +///| +pub fn muscat_mean_expression() -> MuscatAdvancedAggregation { + MeanExpression +} + +///| +pub fn muscat_median_expression() -> MuscatAdvancedAggregation { + MedianExpression +} + +///| +pub fn muscat_proportion_detected() -> MuscatAdvancedAggregation { + ProportionDetected +} + +///| +pub fn muscat_number_detected() -> MuscatAdvancedAggregation { + NumberDetected +} + +///| +pub struct MuscatAdvancedConfig { + min_cells : Int + min_count : Double + min_samples : Int + max_iterations : Int + tolerance : Double + minimum_dispersion : Double + maximum_dispersion : Double + dispersion_prior_df : Double + ridge : Double + fdr_threshold : Double + lfc_threshold : Double + detection_filter : Double +} derive(Debug) + +///| +pub fn MuscatAdvancedConfig::create( + min_cells? : Int = 10, + min_count? : Double = 1.0, + min_samples? : Int = 2, + max_iterations? : Int = 100, + tolerance? : Double = 1.0e-8, + minimum_dispersion? : Double = 1.0e-8, + maximum_dispersion? : Double = 100.0, + dispersion_prior_df? : Double = 10.0, + ridge? : Double = 1.0e-8, + fdr_threshold? : Double = 0.05, + lfc_threshold? : Double = 0.0, + detection_filter? : Double = 0.9, +) -> MuscatAdvancedConfig raise MuscatAdvancedError { + if min_cells < 0 { + raise MuscatAdvancedError("min_cells must be non-negative") + } + if !muscat_adv_finite(min_count) || min_count < 0.0 { + raise MuscatAdvancedError("min_count must be finite and non-negative") + } + if min_samples < 1 { + raise MuscatAdvancedError("min_samples must be positive") + } + if max_iterations < 1 { + raise MuscatAdvancedError("max_iterations must be positive") + } + if !muscat_adv_finite(tolerance) || tolerance <= 0.0 { + raise MuscatAdvancedError("tolerance must be finite and positive") + } + if !muscat_adv_finite(minimum_dispersion) || minimum_dispersion <= 0.0 { + raise MuscatAdvancedError("minimum_dispersion must be finite and positive") + } + if !muscat_adv_finite(maximum_dispersion) || + maximum_dispersion < minimum_dispersion { + raise MuscatAdvancedError( + "maximum_dispersion must be finite and no smaller than the minimum", + ) + } + if !muscat_adv_finite(dispersion_prior_df) || dispersion_prior_df < 0.0 { + raise MuscatAdvancedError( + "dispersion_prior_df must be finite and non-negative", + ) + } + if !muscat_adv_finite(ridge) || ridge < 0.0 { + raise MuscatAdvancedError("ridge must be finite and non-negative") + } + if !muscat_adv_finite(fdr_threshold) || + fdr_threshold <= 0.0 || + fdr_threshold > 1.0 { + raise MuscatAdvancedError("fdr_threshold must be in (0, 1]") + } + if !muscat_adv_finite(lfc_threshold) || lfc_threshold < 0.0 { + raise MuscatAdvancedError("lfc_threshold must be finite and non-negative") + } + if !muscat_adv_finite(detection_filter) || + detection_filter <= 0.0 || + detection_filter > 1.0 { + raise MuscatAdvancedError("detection_filter must be in (0, 1]") + } + MuscatAdvancedConfig::{ + min_cells, + min_count, + min_samples, + max_iterations, + tolerance, + minimum_dispersion, + maximum_dispersion, + dispersion_prior_df, + ridge, + fdr_threshold, + lfc_threshold, + detection_filter, + } +} + +///| +pub fn MuscatAdvancedConfig::default() -> MuscatAdvancedConfig { + MuscatAdvancedConfig::{ + min_cells: 10, + min_count: 1.0, + min_samples: 2, + max_iterations: 100, + tolerance: 1.0e-8, + minimum_dispersion: 1.0e-8, + maximum_dispersion: 100.0, + dispersion_prior_df: 10.0, + ridge: 1.0e-8, + fdr_threshold: 0.05, + lfc_threshold: 0.0, + detection_filter: 0.9, + } +} + +///| +pub struct MuscatAdvancedData { + counts : Array[Array[Double]] + gene_names : Array[String] + cell_names : Array[String] + sample_ids : Array[String] + cluster_ids : Array[String] + group_ids : Array[String] + sample_names : Array[String] + sample_groups : Array[String] + cluster_names : Array[String] + group_names : Array[String] +} derive(Debug) + +///| +pub struct MuscatAdvancedPseudoBulk { + values : Array[Array[Array[Double]]] + gene_names : Array[String] + sample_names : Array[String] + sample_groups : Array[String] + cluster_names : Array[String] + cell_counts : Array[Array[Int]] + library_sizes : Array[Array[Double]] + aggregation : MuscatAdvancedAggregation + scaled_cpm : Bool +} derive(Debug) + +///| +pub struct MuscatAdvancedDesign { + matrix : Array[Array[Double]] + sample_names : Array[String] + coefficient_names : Array[String] +} derive(Debug) + +///| +pub struct MuscatAdvancedContrast { + values : Array[Double] + name : String +} derive(Debug) + +///| +pub struct MuscatAdvancedGeneResult { + gene_name : String + cluster_name : String + contrast_name : String + mode : String + tested : Bool + log_fc : Double + log_cpm : Double + statistic : Double + p_value : Double + mut local_fdr : Double + mut global_fdr : Double + raw_dispersion : Double + dispersion : Double + mean_count : Double + n_samples : Int + converged : Bool +} derive(Debug) + +///| +pub struct MuscatAdvancedResults { + results : Array[MuscatAdvancedGeneResult] + gene_names : Array[String] + cluster_names : Array[String] + contrast_names : Array[String] + mode : String + fdr_threshold : Double +} derive(Debug) + +///| +pub struct MuscatStagewiseGeneResult { + gene_name : String + cluster_name : String + contrast_name : String + screen_p_value : Double + mut screen_fdr : Double + ds_p_value : Double + dd_p_value : Double + mut ds_confirmation : Double + mut dd_confirmation : Double + mut classification : String +} derive(Debug) + +///| +pub struct MuscatStagewiseResults { + results : Array[MuscatStagewiseGeneResult] + gene_names : Array[String] + cluster_names : Array[String] + contrast_names : Array[String] + alpha : Double +} derive(Debug) + +///| +pub struct MuscatAdvancedSCEOutput { + experiment : SingleCellExperiment + sum_pseudobulk : MuscatAdvancedPseudoBulk + detection_pseudobulk : MuscatAdvancedPseudoBulk + ds_result : MuscatAdvancedResults + dd_result : MuscatAdvancedResults + stagewise_result : MuscatStagewiseResults +} + +///| +priv struct MuscatAdvCoreFit { + coefficients : Array[Double] + covariance : Array[Array[Double]] + fitted_values : Array[Double] + converged : Bool + fitted : Bool +} + +///| +fn muscat_adv_finite(value : Double) -> Bool { + value == value && value.abs() < 1.0e300 +} + +///| +fn muscat_adv_clamp(value : Double, lower : Double, upper : Double) -> Double { + if value < lower { + lower + } else if value > upper { + upper + } else { + value + } +} + +///| +fn muscat_adv_zero_matrix(rows : Int, columns : Int) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for _ in 0.. Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in matrix { + output.push(row.copy()) + } + output +} + +///| +fn muscat_adv_levels( + values : Array[String], + label : String, +) -> Array[String] raise MuscatAdvancedError { + let output : Array[String] = [] + for value in values { + if value.trim().length() == 0 { + raise MuscatAdvancedError(label + " must not contain empty values") + } + if !output.contains(value) { + output.push(value) + } + } + output +} + +///| +fn muscat_adv_names( + supplied : Array[String], + length : Int, + prefix : String, +) -> Array[String] raise MuscatAdvancedError { + if supplied.length() != 0 && supplied.length() != length { + raise MuscatAdvancedError(prefix + " names do not match the data dimension") + } + let output : Array[String] = [] + for index in 0.. MuscatAdvancedData raise MuscatAdvancedError { + if counts.length() == 0 { + raise MuscatAdvancedError("counts must contain at least one gene") + } + let cells = counts[0].length() + if cells == 0 { + raise MuscatAdvancedError("counts must contain at least one cell") + } + for row in counts { + if row.length() != cells { + raise MuscatAdvancedError("counts must be rectangular") + } + for value in row { + if !muscat_adv_finite(value) || + value < 0.0 || + (value - value.round()).abs() > 1.0e-8 { + raise MuscatAdvancedError( + "counts must contain finite non-negative integer values", + ) + } + } + } + if sample_ids.length() != cells || + cluster_ids.length() != cells || + group_ids.length() != cells { + raise MuscatAdvancedError( + "sample, cluster and group identifiers must match the number of cells", + ) + } + let sample_names = muscat_adv_levels(sample_ids, "sample identifiers") + let cluster_names = muscat_adv_levels(cluster_ids, "cluster identifiers") + let group_names = muscat_adv_levels(group_ids, "group identifiers") + if sample_names.length() < 2 { + raise MuscatAdvancedError("at least two biological samples are required") + } + if group_names.length() < 2 { + raise MuscatAdvancedError("at least two experimental groups are required") + } + let sample_groups : Array[String] = [] + for sample in sample_names { + let mut assigned = "" + for cell in 0.. Double { + if values.length() == 0 { + return 0.0 + } + let sorted = values.copy() + sorted.sort_by(fn(left : Double, right : Double) -> Int { + if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + if sorted.length() % 2 == 0 { + (sorted[sorted.length() / 2 - 1] + sorted[sorted.length() / 2]) / 2.0 + } else { + sorted[sorted.length() / 2] + } +} + +///| +pub fn muscat_aggregate_advanced( + data : MuscatAdvancedData, + aggregation? : MuscatAdvancedAggregation = SumCounts, + scale_cpm? : Bool = false, +) -> MuscatAdvancedPseudoBulk raise MuscatAdvancedError { + if scale_cpm && aggregation == NumberDetected { + raise MuscatAdvancedError( + "number-detected pseudobulks cannot be CPM scaled", + ) + } + let clusters = data.cluster_names.length() + let samples = data.sample_names.length() + let genes = data.gene_names.length() + let values : Array[Array[Array[Double]]] = [] + let cell_counts : Array[Array[Int]] = [] + let library_sizes : Array[Array[Double]] = [] + for cluster in 0.. 0.0 { + detected = detected + 1 + } + } + library_size = library_size + sum + cluster_values[gene][sample] = match aggregation { + SumCounts => sum + MeanExpression => + if selected.length() == 0 { + 0.0 + } else { + sum / selected.length().to_double() + } + MedianExpression => muscat_adv_median(observations) + ProportionDetected => + if selected.length() == 0 { + 0.0 + } else { + detected.to_double() / selected.length().to_double() + } + NumberDetected => detected.to_double() + } + } + cluster_libraries[sample] = library_size + } + if scale_cpm { + for sample in 0.. 0.0 { + for gene in 0.. Int { + if matrix.length() == 0 || matrix[0].length() == 0 { + return 0 + } + let work = muscat_adv_copy_matrix(matrix) + let rows = work.length() + let columns = work[0].length() + let mut rank = 0 + let mut column = 0 + while column < columns && rank < rows { + let mut pivot = rank + let mut maximum = work[pivot][column].abs() + for candidate in (rank + 1).. maximum { + pivot = candidate + maximum = work[candidate][column].abs() + } + } + if maximum > 1.0e-10 { + if pivot != rank { + let temporary = work[rank] + work[rank] = work[pivot] + work[pivot] = temporary + } + let divisor = work[rank][column] + for inner in column.. MuscatAdvancedDesign raise MuscatAdvancedError { + if matrix.length() == 0 || matrix.length() != sample_names.length() { + raise MuscatAdvancedError( + "design rows and sample names must be non-empty and have equal length", + ) + } + if matrix[0].length() == 0 || matrix[0].length() != coefficient_names.length() { + raise MuscatAdvancedError( + "design columns and coefficient names must be non-empty and have equal length", + ) + } + ignore(muscat_adv_names(sample_names, sample_names.length(), "Sample")) + ignore( + muscat_adv_names( + coefficient_names, + coefficient_names.length(), + "Coefficient", + ), + ) + for row in matrix { + if row.length() != coefficient_names.length() { + raise MuscatAdvancedError("design matrix must be rectangular") + } + for value in row { + if !muscat_adv_finite(value) { + raise MuscatAdvancedError("design matrix must contain finite values") + } + } + } + if matrix.length() <= coefficient_names.length() { + raise MuscatAdvancedError("design must have more samples than coefficients") + } + if muscat_adv_matrix_rank(matrix) != coefficient_names.length() { + raise MuscatAdvancedError("design matrix must have full column rank") + } + MuscatAdvancedDesign::{ + matrix: muscat_adv_copy_matrix(matrix), + sample_names: sample_names.copy(), + coefficient_names: coefficient_names.copy(), + } +} + +///| +pub fn muscat_group_design_advanced( + pseudobulk : MuscatAdvancedPseudoBulk, + reference? : String = "", +) -> MuscatAdvancedDesign raise MuscatAdvancedError { + let groups = muscat_adv_levels( + pseudobulk.sample_groups, + "pseudobulk sample groups", + ) + let selected_reference = if reference == "" { groups[0] } else { reference } + if !groups.contains(selected_reference) { + raise MuscatAdvancedError("reference group is not present") + } + let encoded : Array[String] = [] + for group in groups { + if group != selected_reference { + encoded.push(group) + } + } + let matrix : Array[Array[Double]] = [] + for group in pseudobulk.sample_groups { + let row = Array::make(encoded.length() + 1, 0.0) + row[0] = 1.0 + for index in 0.. MuscatAdvancedContrast raise MuscatAdvancedError { + if values.length() != design.coefficient_names.length() { + raise MuscatAdvancedError( + "contrast length must match the number of design coefficients", + ) + } + if name.trim().length() == 0 { + raise MuscatAdvancedError("contrast name must not be empty") + } + let mut magnitude = 0.0 + for value in values { + if !muscat_adv_finite(value) { + raise MuscatAdvancedError("contrast must contain finite values") + } + magnitude = magnitude + value.abs() + } + if magnitude == 0.0 { + raise MuscatAdvancedError("contrast must contain a non-zero coefficient") + } + MuscatAdvancedContrast::{ values: values.copy(), name } +} + +///| +pub fn muscat_default_contrasts_advanced( + design : MuscatAdvancedDesign, +) -> Array[MuscatAdvancedContrast] raise MuscatAdvancedError { + if design.coefficient_names.length() < 2 { + raise MuscatAdvancedError( + "default contrasts require at least one non-intercept coefficient", + ) + } + let output : Array[MuscatAdvancedContrast] = [] + for coefficient in 1.. Array[Array[Double]]? { + let size = matrix.length() + if size == 0 { + return None + } + let lower = muscat_adv_zero_matrix(size, size) + for row in 0.. Array[Double] { + let size = lower.length() + let forward = Array::make(size, 0.0) + for row in 0..= 0 { + let mut value = forward[row] + for column in (row + 1).. Array[Array[Double]] { + let size = lower.length() + let output = muscat_adv_zero_matrix(size, size) + for column in 0.. Array[Array[Double]]? { + let mut added = ridge + for attempt in 0..<14 { + let candidate = muscat_adv_copy_matrix(matrix) + for index in 0.. return Some(lower) + None => + added = if attempt == 0 && added == 0.0 { + 1.0e-10 + } else { + added.max(1.0e-10) * 10.0 + } + } + } + None +} + +///| +fn muscat_adv_fit_gene( + response : Array[Double], + design : Array[Array[Double]], + offsets : Array[Double], + dispersion : Double, + config : MuscatAdvancedConfig, +) -> MuscatAdvCoreFit { + let observations = response.length() + let parameters = design[0].length() + let coefficients = Array::make(parameters, 0.0) + let mut total_response = 0.0 + let mut total_exposure = 0.0 + for observation in 0.. value + None => break + } + let updated = muscat_adv_solve(lower, right_hand_side) + let mut maximum_change = 0.0 + for parameter in 0.. muscat_adv_inverse(lower) + None => muscat_adv_zero_matrix(parameters, parameters) + } + MuscatAdvCoreFit::{ + coefficients, + covariance, + fitted_values, + converged, + fitted: true, + } +} + +///| +fn muscat_adv_raw_dispersion( + response : Array[Double], + fitted : Array[Double], + residual_df : Int, + config : MuscatAdvancedConfig, +) -> Double { + if residual_df <= 0 { + return config.minimum_dispersion + } + let mut numerator = 0.0 + for observation in 0.. Double { + let absolute = value.abs() + let t = 1.0 / (1.0 + 0.2316419 * absolute) + let density = 0.3989422804014327 * @math.exp(-0.5 * absolute * absolute) + let polynomial = t * + ( + 0.319381530 + + t * + (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))) + ) + let upper = density * polynomial + if value >= 0.0 { + 1.0 - upper + } else { + upper + } +} + +///| +fn muscat_adv_bh(values : Array[Double]) -> Array[Double] { + if values.length() == 0 { + return [] + } + let order : Array[Int] = [] + for index in 0.. Int { + if values[left] < values[right] { + -1 + } else if values[left] > values[right] { + 1 + } else { + left - right + } + }) + let output = Array::make(values.length(), 1.0) + let mut running = 1.0 + let mut position = values.length() - 1 + while position >= 0 { + let adjusted = values[order[position]] * + values.length().to_double() / + (position + 1).to_double() + running = running.min(adjusted).min(1.0) + output[order[position]] = running + position = position - 1 + } + output +} + +///| +fn muscat_adv_validate_fit_inputs( + pseudobulk : MuscatAdvancedPseudoBulk, + design : MuscatAdvancedDesign, + contrasts : Array[MuscatAdvancedContrast], +) -> Unit raise MuscatAdvancedError { + if pseudobulk.sample_names != design.sample_names { + raise MuscatAdvancedError( + "design sample names must exactly match pseudobulk sample order", + ) + } + if contrasts.length() == 0 { + raise MuscatAdvancedError("at least one contrast is required") + } + let names : Array[String] = [] + for contrast in contrasts { + if contrast.values.length() != design.coefficient_names.length() { + raise MuscatAdvancedError( + "all contrasts must match the design coefficient count", + ) + } + if contrast.name.trim().length() == 0 || names.contains(contrast.name) { + raise MuscatAdvancedError("contrast names must be non-empty and unique") + } + names.push(contrast.name) + let mut magnitude = 0.0 + for value in contrast.values { + if !muscat_adv_finite(value) { + raise MuscatAdvancedError("contrasts must contain finite values") + } + magnitude = magnitude + value.abs() + } + if magnitude == 0.0 { + raise MuscatAdvancedError("contrasts must be non-zero") + } + } +} + +///| +fn muscat_adv_offsets( + pseudobulk : MuscatAdvancedPseudoBulk, + cluster : Int, + active : Array[Int], + detection : Bool, + config : MuscatAdvancedConfig, +) -> Array[Double] { + let exposures = Array::make(active.length(), 1.0) + if detection { + let eligible : Array[Int] = [] + for gene in 0.. 0 { + for gene in eligible { + fraction = fraction + + pseudobulk.values[cluster][gene][sample] / cells.max(1.0) + } + fraction = fraction / eligible.length().to_double() + } else { + fraction = 1.0 + } + exposures[position] = (cells * fraction.max(1.0e-6)).max(1.0e-8) + } + } else { + for position in 0.. Double { + let mut normalized = 0.0 + for index in 0.. MuscatAdvancedResults raise MuscatAdvancedError { + muscat_adv_validate_fit_inputs(pseudobulk, design, contrasts) + if pseudobulk.scaled_cpm { + raise MuscatAdvancedError( + "differential testing requires unscaled pseudobulk values", + ) + } + if detection { + if pseudobulk.aggregation != NumberDetected { + raise MuscatAdvancedError( + "differential detection requires number-detected pseudobulks", + ) + } + } else if pseudobulk.aggregation != SumCounts { + raise MuscatAdvancedError( + "differential state testing requires sum-count pseudobulks", + ) + } + let results : Array[MuscatAdvancedGeneResult] = [] + let mode = if detection { "DD" } else { "DS" } + let parameters = design.coefficient_names.length() + let mut any_tested = false + for cluster in 0..= config.min_cells && + pseudobulk.library_sizes[cluster][sample] > 0.0 { + active.push(sample) + } + } + let active_design : Array[Array[Double]] = [] + for sample in active { + active_design.push(design.matrix[sample].copy()) + } + let design_valid = active.length() > parameters && + muscat_adv_matrix_rank(active_design) == parameters + let offsets = if design_valid { + muscat_adv_offsets(pseudobulk, cluster, active, detection, config) + } else { + [] + } + let first_fits : Array[MuscatAdvCoreFit] = [] + let raw_dispersions = Array::make( + pseudobulk.gene_names.length(), + config.minimum_dispersion, + ) + let filtered = Array::make(pseudobulk.gene_names.length(), true) + let trend_candidates : Array[Double] = [] + for gene in 0..= config.min_count { + passing = passing + 1 + } + } + let ubiquitous_detection = detection && + muscat_adv_median(detection_fractions) >= config.detection_filter + filtered[gene] = !design_valid || + passing < config.min_samples || + ubiquitous_detection + if filtered[gene] { + first_fits.push(MuscatAdvCoreFit::{ + coefficients: Array::make(parameters, 0.0), + covariance: muscat_adv_zero_matrix(parameters, parameters), + fitted_values: Array::make(active.length(), 0.0), + converged: false, + fitted: false, + }) + } else { + let fit = muscat_adv_fit_gene( + response, + active_design, + offsets, + config.minimum_dispersion, + config, + ) + first_fits.push(fit) + let raw = if fit.fitted { + muscat_adv_raw_dispersion( + response, + fit.fitted_values, + active.length() - parameters, + config, + ) + } else { + config.minimum_dispersion + } + raw_dispersions[gene] = raw + if fit.fitted { + trend_candidates.push(raw) + } + } + } + let trend = if trend_candidates.length() == 0 { + config.minimum_dispersion + } else { + muscat_adv_median(trend_candidates) + } + for gene in 0.. 0 { + mean_count = mean_count / active.length().to_double() + } + let residual_df = (active.length() - parameters).max(0).to_double() + let dispersion = if filtered[gene] { + config.minimum_dispersion + } else { + muscat_adv_clamp( + ( + residual_df * raw_dispersions[gene] + + config.dispersion_prior_df * trend + ) / + (residual_df + config.dispersion_prior_df).max(1.0), + config.minimum_dispersion, + config.maximum_dispersion, + ) + } + let fit = if filtered[gene] { + first_fits[gene] + } else { + muscat_adv_fit_gene( + response, active_design, offsets, dispersion, config, + ) + } + for contrast in contrasts { + let mut effect = 0.0 + let mut variance = 0.0 + if fit.fitted { + for left in 0.. threshold { + effect - threshold + } else if effect < -threshold { + effect + threshold + } else { + 0.0 + } + let tested = !filtered[gene] && + fit.fitted && + fit.converged && + muscat_adv_finite(variance) && + variance > 0.0 + let statistic = if tested { + adjusted_effect * adjusted_effect / variance + } else { + 0.0 + } + let p_value = if tested { + muscat_adv_clamp( + 2.0 * (1.0 - muscat_adv_normal_cdf(statistic.sqrt())), + 0.0, + 1.0, + ) + } else { + 1.0 + } + if tested { + any_tested = true + } + results.push(MuscatAdvancedGeneResult::{ + gene_name: pseudobulk.gene_names[gene], + cluster_name: pseudobulk.cluster_names[cluster], + contrast_name: contrast.name, + mode, + tested, + log_fc: if fit.fitted { + effect / @math.ln(2.0) + } else { + 0.0 + }, + log_cpm: if active.length() > 0 { + muscat_adv_log_cpm(response, offsets) + } else { + 0.0 + }, + statistic, + p_value, + local_fdr: 1.0, + global_fdr: 1.0, + raw_dispersion: raw_dispersions[gene], + dispersion, + mean_count, + n_samples: active.length(), + converged: fit.converged, + }) + } + } + } + if !any_tested { + raise MuscatAdvancedError( + "no genes could be tested; relax filtering or provide more replicated samples", + ) + } + for contrast in contrasts { + for cluster in pseudobulk.cluster_names { + let indices : Array[Int] = [] + let p_values : Array[Double] = [] + for index in 0.. MuscatAdvancedResults raise MuscatAdvancedError { + muscat_adv_test(pseudobulk, design, contrasts, false, config) +} + +///| +pub fn muscat_pbdd_advanced( + pseudobulk : MuscatAdvancedPseudoBulk, + design : MuscatAdvancedDesign, + contrasts : Array[MuscatAdvancedContrast], + config? : MuscatAdvancedConfig = MuscatAdvancedConfig::default(), +) -> MuscatAdvancedResults raise MuscatAdvancedError { + muscat_adv_test(pseudobulk, design, contrasts, true, config) +} + +///| +pub fn MuscatAdvancedResults::get( + self : MuscatAdvancedResults, + gene_name : String, + cluster_name : String, + contrast_name : String, +) -> MuscatAdvancedGeneResult? { + for result in self.results { + if result.gene_name == gene_name && + result.cluster_name == cluster_name && + result.contrast_name == contrast_name { + return Some(result) + } + } + None +} + +///| +pub fn MuscatAdvancedResults::n_tested(self : MuscatAdvancedResults) -> Int { + let mut count = 0 + for result in self.results { + if result.tested { + count = count + 1 + } + } + count +} + +///| +pub fn MuscatAdvancedResults::n_significant( + self : MuscatAdvancedResults, + global? : Bool = false, +) -> Int { + let mut count = 0 + for result in self.results { + let adjusted = if global { result.global_fdr } else { result.local_fdr } + if result.tested && adjusted <= self.fdr_threshold { + count = count + 1 + } + } + count +} + +///| +pub fn MuscatAdvancedResults::summary(self : MuscatAdvancedResults) -> String { + "muscat advanced " + + self.mode + + ": " + + self.gene_names.length().to_string() + + " genes x " + + self.cluster_names.length().to_string() + + " clusters x " + + self.contrast_names.length().to_string() + + " contrasts; " + + self.n_tested().to_string() + + " tested, " + + self.n_significant().to_string() + + " locally significant" +} + +///| +pub fn muscat_stagewise_ds_dd( + ds_result : MuscatAdvancedResults, + dd_result : MuscatAdvancedResults, + alpha? : Double = 0.05, +) -> MuscatStagewiseResults raise MuscatAdvancedError { + if !muscat_adv_finite(alpha) || alpha <= 0.0 || alpha > 1.0 { + raise MuscatAdvancedError("stagewise alpha must be in (0, 1]") + } + if ds_result.mode != "DS" || dd_result.mode != "DD" { + raise MuscatAdvancedError("stagewise testing requires DS and DD results") + } + if ds_result.gene_names != dd_result.gene_names || + ds_result.cluster_names != dd_result.cluster_names || + ds_result.contrast_names != dd_result.contrast_names { + raise MuscatAdvancedError( + "DS and DD results must have matching genes, clusters and contrasts", + ) + } + let output : Array[MuscatStagewiseGeneResult] = [] + for contrast in ds_result.contrast_names { + for cluster in ds_result.cluster_names { + for gene in ds_result.gene_names { + let ds = match ds_result.get(gene, cluster, contrast) { + Some(value) => value + None => raise MuscatAdvancedError("missing DS result") + } + let dd = match dd_result.get(gene, cluster, contrast) { + Some(value) => value + None => raise MuscatAdvancedError("missing DD result") + } + let ds_p = if ds.tested { ds.p_value } else { 1.0 } + let dd_p = if dd.tested { dd.p_value } else { 1.0 } + let screen = if ds_p == 0.0 || dd_p == 0.0 { + 0.0 + } else { + 2.0 / (1.0 / ds_p + 1.0 / dd_p) + } + output.push(MuscatStagewiseGeneResult::{ + gene_name: gene, + cluster_name: cluster, + contrast_name: contrast, + screen_p_value: screen, + screen_fdr: 1.0, + ds_p_value: ds_p, + dd_p_value: dd_p, + ds_confirmation: 1.0, + dd_confirmation: 1.0, + classification: "none", + }) + } + } + } + for contrast in ds_result.contrast_names { + let indices : Array[Int] = [] + let p_values : Array[Double] = [] + for index in 0.. MuscatStagewiseGeneResult? { + for result in self.results { + if result.gene_name == gene_name && + result.cluster_name == cluster_name && + result.contrast_name == contrast_name { + return Some(result) + } + } + None +} + +///| +pub fn MuscatStagewiseResults::n_confirmed( + self : MuscatStagewiseResults, +) -> Int { + let mut count = 0 + for result in self.results { + if result.classification == "DS" || + result.classification == "DD" || + result.classification == "both" { + count = count + 1 + } + } + count +} + +///| +fn muscat_adv_copy_string_map( + source : Map[String, Array[String]], +) -> Map[String, Array[String]] { + let output : Map[String, Array[String]] = Map([]) + for key in source.keys() { + output[key] = source[key].copy() + } + output +} + +///| +fn muscat_adv_copy_sce(source : SingleCellExperiment) -> SingleCellExperiment { + let assays : Map[String, Array[Array[Double]]] = Map([]) + for key in source.assays.keys() { + assays[key] = muscat_adv_copy_matrix(source.assays[key]) + } + let reduced_dims : Map[String, Array[Array[Double]]] = Map([]) + for key in source.reduced_dims.keys() { + reduced_dims[key] = muscat_adv_copy_matrix(source.reduced_dims[key]) + } + let alternatives : Map[String, SingleCellExperiment] = Map([]) + for key in source.alternative_experiments.keys() { + alternatives[key] = muscat_adv_copy_sce(source.alternative_experiments[key]) + } + let metadata : Map[String, String] = Map([]) + for key in source.metadata.keys() { + metadata[key] = source.metadata[key] + } + SingleCellExperiment::{ + assays, + row_data: muscat_adv_copy_string_map(source.row_data), + col_data: muscat_adv_copy_string_map(source.col_data), + reduced_dims, + alternative_experiments: alternatives, + metadata, + row_names: source.row_names.copy(), + col_names: source.col_names.copy(), + } +} + +///| +fn muscat_adv_result_string(value : MuscatAdvancedGeneResult?) -> String { + match value { + Some(result) => result.global_fdr.to_string() + None => "NA" + } +} + +///| +pub fn muscat_advanced_sce( + experiment : SingleCellExperiment, + sample_column : String, + cluster_column : String, + group_column : String, + assay_name? : String = "counts", + reference? : String = "", + output_prefix? : String = "muscat", + config? : MuscatAdvancedConfig = MuscatAdvancedConfig::default(), +) -> MuscatAdvancedSCEOutput raise MuscatAdvancedError { + if output_prefix.trim().length() == 0 { + raise MuscatAdvancedError("output_prefix must not be empty") + } + let counts = match experiment.assays.get(assay_name) { + Some(value) => value + None => raise MuscatAdvancedError("SCE assay not found: " + assay_name) + } + let sample_ids = match experiment.col_data.get(sample_column) { + Some(value) => value + None => + raise MuscatAdvancedError("SCE column data not found: " + sample_column) + } + let cluster_ids = match experiment.col_data.get(cluster_column) { + Some(value) => value + None => + raise MuscatAdvancedError("SCE column data not found: " + cluster_column) + } + let group_ids = match experiment.col_data.get(group_column) { + Some(value) => value + None => + raise MuscatAdvancedError("SCE column data not found: " + group_column) + } + let data = MuscatAdvancedData::create( + counts, + sample_ids, + cluster_ids, + group_ids, + gene_names=experiment.row_names, + cell_names=experiment.col_names, + ) + let sum_pseudobulk = muscat_aggregate_advanced(data, aggregation=SumCounts) + let detection_pseudobulk = muscat_aggregate_advanced( + data, + aggregation=NumberDetected, + ) + let design = muscat_group_design_advanced(sum_pseudobulk, reference~) + let contrasts = muscat_default_contrasts_advanced(design) + let ds_result = muscat_pbds_advanced( + sum_pseudobulk, + design, + contrasts, + config~, + ) + let dd_result = muscat_pbdd_advanced( + detection_pseudobulk, + design, + contrasts, + config~, + ) + let stagewise_result = muscat_stagewise_ds_dd( + ds_result, + dd_result, + alpha=config.fdr_threshold, + ) + let enriched = muscat_adv_copy_sce(experiment) + let contrast = contrasts[0].name + for cluster in data.cluster_names { + let ds_log_fc : Array[String] = [] + let ds_fdr : Array[String] = [] + let dd_log_fc : Array[String] = [] + let dd_fdr : Array[String] = [] + let stage_class : Array[String] = [] + for gene in data.gene_names { + let ds = ds_result.get(gene, cluster, contrast) + let dd = dd_result.get(gene, cluster, contrast) + ds_log_fc.push( + match ds { + Some(result) => result.log_fc.to_string() + None => "NA" + }, + ) + ds_fdr.push(muscat_adv_result_string(ds)) + dd_log_fc.push( + match dd { + Some(result) => result.log_fc.to_string() + None => "NA" + }, + ) + dd_fdr.push(muscat_adv_result_string(dd)) + stage_class.push( + match stagewise_result.get(gene, cluster, contrast) { + Some(result) => result.classification + None => "none" + }, + ) + } + let stem = output_prefix + "." + cluster + enriched.row_data[stem + ".dsLogFC"] = ds_log_fc + enriched.row_data[stem + ".dsFdr"] = ds_fdr + enriched.row_data[stem + ".ddLogFC"] = dd_log_fc + enriched.row_data[stem + ".ddFdr"] = dd_fdr + enriched.row_data[stem + ".stageClass"] = stage_class + } + enriched.col_data[output_prefix + ".sample_id"] = sample_ids.copy() + enriched.col_data[output_prefix + ".cluster_id"] = cluster_ids.copy() + enriched.col_data[output_prefix + ".group_id"] = group_ids.copy() + enriched.metadata[output_prefix + ".version"] = "muscat 1.27.4" + enriched.metadata[output_prefix + ".assay"] = assay_name + enriched.metadata[output_prefix + ".reference"] = if reference == "" { + data.group_names[0] + } else { + reference + } + enriched.metadata[output_prefix + ".contrast"] = contrast + enriched.metadata[output_prefix + ".clusters"] = data.cluster_names.join(",") + enriched.metadata[output_prefix + ".dsTested"] = ds_result + .n_tested() + .to_string() + enriched.metadata[output_prefix + ".ddTested"] = dd_result + .n_tested() + .to_string() + enriched.metadata[output_prefix + ".stageConfirmed"] = stagewise_result + .n_confirmed() + .to_string() + MuscatAdvancedSCEOutput::{ + experiment: enriched, + sum_pseudobulk, + detection_pseudobulk, + ds_result, + dd_result, + stagewise_result, + } +} + +///| +pub fn muscat_advanced_example() -> MuscatAdvancedData raise MuscatAdvancedError { + let genes = [ + "stable", "ds_a", "dd_b", "both_a", "sparse", "zero", "cdr1", "cdr2", "cdr3", + "cdr4", + ] + let samples = ["C1", "C2", "C3", "C4", "T1", "T2", "T3", "T4"] + let cells_per_stratum = 10 + let counts = muscat_adv_zero_matrix( + genes.length(), + samples.length() * 2 * cells_per_stratum, + ) + let sample_ids : Array[String] = [] + let cluster_ids : Array[String] = [] + let group_ids : Array[String] = [] + let cell_names : Array[String] = [] + let mut cell = 0 + for sample_index in 0..= 4 + for cluster_index in 0..<2 { + for replicate in 0.. Unit raise ScDblFinderError { + raise ScDblFinderError(message) +} + +///| +fn scdfa_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn scdfa_copy_matrix(values : Array[Array[Double]]) -> Array[Array[Double]] { + let result = [] + for row in values { + result.push(row.copy()) + } + result +} + +///| +fn scdfa_contains_string(values : Array[String], query : String) -> Bool { + for value in values { + if value == query { + return true + } + } + false +} + +///| +fn scdfa_string_index(values : Array[String], query : String) -> Int { + for index in 0.. Array[String] { + let result = [] + for value in values { + if !scdfa_contains_string(result, value) { + result.push(value) + } + } + result +} + +///| +fn scdfa_zero_matrix(rows : Int, columns : Int) -> Array[Array[Double]] { + let result = [] + for _ in 0.. Double { + if values.length() == 0 { + return 0.0 + } + let sorted = values.copy() + for index in 1.. 0 && sorted[position - 1] > value { + sorted[position] = sorted[position - 1] + position = position - 1 + } + sorted[position] = value + } + let middle = sorted.length() / 2 + if sorted.length() % 2 == 0 { + (sorted[middle - 1] + sorted[middle]) / 2.0 + } else { + sorted[middle] + } +} + +///| +fn scdfa_quantile(values : Array[Double], probability : Double) -> Double { + if values.length() == 0 { + return 0.0 + } + let sorted = values.copy() + for index in 1.. 0 && sorted[position - 1] > value { + sorted[position] = sorted[position - 1] + position = position - 1 + } + sorted[position] = value + } + if sorted.length() == 1 { + return sorted[0] + } + let location = probability * (sorted.length() - 1).to_double() + let lower = location.to_int() + let upper = if lower + 1 < sorted.length() { lower + 1 } else { lower } + let fraction = location - lower.to_double() + sorted[lower] * (1.0 - fraction) + sorted[upper] * fraction +} + +///| +fn scdfa_log2(value : Double) -> Double { + @math.ln(value) / 0.6931471805599453 +} + +///| +fn scdfa_sigmoid(value : Double) -> Double { + if value >= 35.0 { + 1.0 + } else if value <= -35.0 { + 0.0 + } else { + 1.0 / (1.0 + @math.exp(-value)) + } +} + +///| +fn scdfa_validate_names( + values : Array[String], + expected : Int, + label : String, +) -> Unit raise ScDblFinderError { + if values.length() != expected { + scdfa_fail( + "scDblFinder " + label + " length must be " + expected.to_string(), + ) + } + let seen : Array[String] = [] + for value in values { + if value == "" { + scdfa_fail("scDblFinder " + label + " cannot contain empty names") + } + if scdfa_contains_string(seen, value) { + scdfa_fail("scDblFinder " + label + " contains duplicate: " + value) + } + seen.push(value) + } +} + +///| +fn scdfa_validate_data(data : SingleCellData) -> Unit raise ScDblFinderError { + let cells = data.counts.length() + if cells < 3 { + scdfa_fail("scDblFinder requires at least three cells") + } + if data.gene_names.length() < 2 { + scdfa_fail("scDblFinder requires at least two genes") + } + scdfa_validate_names(data.cell_names, cells, "cell names") + scdfa_validate_names(data.gene_names, data.gene_names.length(), "gene names") + for cell in 0.. SingleCellData raise ScDblFinderError { + let result = SingleCellData::new( + scdfa_copy_matrix(counts), + cell_names.copy(), + gene_names.copy(), + ) + scdfa_validate_data(result) + result +} + +///| +pub fn ScDblFinderConfig::create( + expected_doublet_rate? : Double = -1.0, + doublet_rate_per_1000? : Double = 0.008, + rate_uncertainty? : Double = -1.0, + artificial_doublets? : Int = 0, + selected_features? : Int = 1000, + dimensions? : Int = 20, + neighbors? : Int = 15, + iterations? : Int = 3, + classifier_steps? : Int = 300, + learning_rate? : Double = 0.15, + regularization? : Double = 0.01, + stringency? : Double = 0.5, + random_fraction? : Double = 0.1, + half_size_fraction? : Double = 0.25, + unidentifiable_threshold? : Double = 0.1, + cluster_count? : Int = 0, + seed? : Int = 1, +) -> ScDblFinderConfig raise ScDblFinderError { + if !scdfa_finite(expected_doublet_rate) || + expected_doublet_rate > 1.0 || + (expected_doublet_rate < 0.0 && expected_doublet_rate != -1.0) { + scdfa_fail("scDblFinder expected_doublet_rate must be -1 or in [0, 1]") + } + if !scdfa_finite(doublet_rate_per_1000) || + doublet_rate_per_1000 < 0.0 || + doublet_rate_per_1000 > 1.0 { + scdfa_fail("scDblFinder doublet_rate_per_1000 must be in [0, 1]") + } + if !scdfa_finite(rate_uncertainty) || + rate_uncertainty > 1.0 || + (rate_uncertainty < 0.0 && rate_uncertainty != -1.0) { + scdfa_fail("scDblFinder rate_uncertainty must be -1 or in [0, 1]") + } + if artificial_doublets < 0 { + scdfa_fail("scDblFinder artificial_doublets cannot be negative") + } + if selected_features < 2 || dimensions < 1 || neighbors < 1 { + scdfa_fail( + "scDblFinder selected_features, dimensions, and neighbors must be positive", + ) + } + if iterations < 1 || classifier_steps < 1 { + scdfa_fail("scDblFinder iterations and classifier_steps must be positive") + } + if !scdfa_finite(learning_rate) || learning_rate <= 0.0 || learning_rate > 1.0 { + scdfa_fail("scDblFinder learning_rate must be in (0, 1]") + } + if !scdfa_finite(regularization) || regularization < 0.0 { + scdfa_fail("scDblFinder regularization cannot be negative") + } + if !scdfa_finite(stringency) || stringency <= 0.0 || stringency >= 1.0 { + scdfa_fail("scDblFinder stringency must be in (0, 1)") + } + if !scdfa_finite(random_fraction) || + random_fraction < 0.0 || + random_fraction > 1.0 { + scdfa_fail("scDblFinder random_fraction must be in [0, 1]") + } + if !scdfa_finite(half_size_fraction) || + half_size_fraction < 0.0 || + half_size_fraction > 1.0 { + scdfa_fail("scDblFinder half_size_fraction must be in [0, 1]") + } + if !scdfa_finite(unidentifiable_threshold) || + unidentifiable_threshold < 0.0 || + unidentifiable_threshold > 1.0 { + scdfa_fail("scDblFinder unidentifiable_threshold must be in [0, 1]") + } + if cluster_count < 0 || cluster_count == 1 { + scdfa_fail("scDblFinder cluster_count must be 0 or at least 2") + } + ScDblFinderConfig::{ + expected_doublet_rate, + doublet_rate_per_1000, + rate_uncertainty, + artificial_doublets, + selected_features, + dimensions, + neighbors, + iterations, + classifier_steps, + learning_rate, + regularization, + stringency, + random_fraction, + half_size_fraction, + unidentifiable_threshold, + cluster_count, + seed, + } +} + +///| +pub fn ScDblFinderConfig::default() -> ScDblFinderConfig { + ScDblFinderConfig::{ + expected_doublet_rate: -1.0, + doublet_rate_per_1000: 0.008, + rate_uncertainty: -1.0, + artificial_doublets: 0, + selected_features: 1000, + dimensions: 20, + neighbors: 15, + iterations: 3, + classifier_steps: 300, + learning_rate: 0.15, + regularization: 0.01, + stringency: 0.5, + random_fraction: 0.1, + half_size_fraction: 0.25, + unidentifiable_threshold: 0.1, + cluster_count: 0, + seed: 1, + } +} + +///| +pub fn scdf_expected_doublet_rate( + cells : Int, + rate_per_1000? : Double = 0.008, +) -> Double raise ScDblFinderError { + if cells < 1 { + scdfa_fail("scDblFinder cell count must be positive") + } + if !scdfa_finite(rate_per_1000) || rate_per_1000 < 0.0 || rate_per_1000 > 1.0 { + scdfa_fail("scDblFinder rate_per_1000 must be in [0, 1]") + } + let result = rate_per_1000 * cells.to_double() / 1000.0 + if result > 1.0 { + 1.0 + } else { + result + } +} + +///| +pub fn scdf_homotypic_proportion( + clusters : Array[String], +) -> Double raise ScDblFinderError { + if clusters.length() == 0 { + scdfa_fail("scDblFinder clusters cannot be empty") + } + for cluster in clusters { + if cluster == "" { + scdfa_fail("scDblFinder clusters cannot contain empty labels") + } + } + let labels = scdfa_unique_strings(clusters) + let mut result = 0.0 + for label in labels { + let mut count = 0 + for cluster in clusters { + if cluster == label { + count = count + 1 + } + } + let proportion = count.to_double() / clusters.length().to_double() + result = result + proportion * proportion + } + result +} + +///| +fn scdfa_library_sizes(counts : Array[Array[Double]]) -> Array[Double] { + let result = [] + for row in counts { + let mut total = 0.0 + for value in row { + total = total + value + } + result.push(total) + } + result +} + +///| +fn scdfa_detected_features( + counts : Array[Array[Double]], + threshold : Double, +) -> Array[Int] { + let result = [] + for row in counts { + let mut total = 0 + for value in row { + if value > threshold { + total = total + 1 + } + } + result.push(total) + } + result +} + +///| +fn scdfa_selected_features( + counts : Array[Array[Double]], + number : Int, +) -> Array[Int] { + let cells = counts.length() + let genes = counts[0].length() + let libraries = scdfa_library_sizes(counts) + let positive = [] + for value in libraries { + if value > 0.0 { + positive.push(value) + } + } + let median_library = scdfa_median(positive) + let variances = Array::make(genes, 0.0) + for gene in 0.. 0 && + ( + variances[indices[position - 1]] < variances[value] || + ( + variances[indices[position - 1]] == variances[value] && + indices[position - 1] > value + ) + ) { + indices[position] = indices[position - 1] + position = position - 1 + } + indices[position] = value + } + let limit = if number < genes { number } else { genes } + let selected = [] + for index in 0.. Array[Array[Double]] { + let libraries = scdfa_library_sizes(counts) + let real_libraries = [] + for cell in 0.. selected.length() { + components = selected.length() + } + if components >= counts.length() { + components = counts.length() - 1 + } + if components < 1 { + components = 1 + } + sce_compute_pca(logcounts, components).coordinates +} + +///| +fn scdfa_origin_name( + first : String, + second : String, + labels : Array[String], +) -> String { + let left = scdfa_string_index(labels, first) + let right = scdfa_string_index(labels, second) + if left <= right { + first + "+" + second + } else { + second + "+" + first + } +} + +///| +pub fn scdf_generate_artificial_doublets( + data : SingleCellData, + number : Int, + clusters? : Array[String] = [], + random_fraction? : Double = 0.1, + half_size_fraction? : Double = 0.25, + seed? : Int = 1, +) -> ScDblFinderArtificialData raise ScDblFinderError { + scdfa_validate_data(data) + if number < 1 { + scdfa_fail("scDblFinder artificial doublet number must be positive") + } + if clusters.length() > 0 && clusters.length() != data.counts.length() { + scdfa_fail("scDblFinder cluster length must match cells") + } + if !scdfa_finite(random_fraction) || + random_fraction < 0.0 || + random_fraction > 1.0 { + scdfa_fail("scDblFinder random_fraction must be in [0, 1]") + } + if !scdfa_finite(half_size_fraction) || + half_size_fraction < 0.0 || + half_size_fraction > 1.0 { + scdfa_fail("scDblFinder half_size_fraction must be in [0, 1]") + } + let libraries = scdfa_library_sizes(data.counts) + let eligible : Array[Int] = [] + let lower = if libraries.length() >= 10 { + scdfa_quantile(libraries, 0.05) + } else { + 0.0 + } + let upper = if libraries.length() >= 10 { + scdfa_quantile(libraries, 0.95) + } else { + 1.0e300 + } + for cell in 0.. 0.0 && + libraries[cell] >= lower && + libraries[cell] <= upper { + eligible.push(cell) + } + } + if eligible.length() < 2 { + scdfa_fail("scDblFinder has fewer than two eligible cells") + } + let random_candidates : Array[(Int, Int)] = [] + let cross_candidates : Array[(Int, Int)] = [] + for left in 0.. 0 && clusters[pair.0] != clusters[pair.1] { + cross_candidates.push(pair) + } + } + } + let use_clusters = clusters.length() > 0 && cross_candidates.length() > 0 + let labels = if use_clusters { scdfa_unique_strings(clusters) } else { [] } + let random_number = if use_clusters { + (number.to_double() * random_fraction).to_int() + } else { + number + } + let half_number = (number.to_double() * half_size_fraction).to_int() + let counts = [] + let names = [] + let parent_one = [] + let parent_two = [] + let origins = [] + let offset = if seed < 0 { -seed } else { seed } + for artificial in 0.. Double { + let mut total = 0.0 + for index in 0.. Unit { + let mut position = distances.length() + for current in 0.. position { + distances[cursor] = distances[cursor - 1] + indices[cursor] = indices[cursor - 1] + cursor = cursor - 1 + } + distances[position] = distance + indices[position] = index + } +} + +///| +fn scdfa_knn_metrics( + coordinates : Array[Array[Double]], + real_cells : Int, + artificial_origins : Array[String], + neighbors : Int, +) -> ScdfaKnnMetrics { + let total = coordinates.length() + let k = if neighbors < total - 1 { neighbors } else { total - 1 } + let weighted = Array::make(total, 0.0) + let ratios = Array::make(total, 0.0) + let nearest = Array::make(total, 0.0) + let nearest_doublet = Array::make(total, 0.0) + let nearest_real = Array::make(total, 0.0) + let nearest_class = Array::make(total, "") + let origins = Array::make(total, "") + let ambiguities = Array::make(total, 1.0) + let origin_labels = scdfa_unique_strings(artificial_origins) + for cell in 0..= real_cells { + "artificialDoublet" + } else { + "cell" + } + let votes = Array::make(origin_labels.length(), 0.0) + let mut artificial_count = 0 + let mut weighted_artificial = 0.0 + let mut total_weight = 0.0 + let mut origin_total = 0.0 + for rank in 0.. 1.0e-12 { + distances[rank] + } else { + 1.0e-12 + } + let rank_weight = (k - rank).to_double().sqrt() / distance + total_weight = total_weight + rank_weight + if indices[rank] >= real_cells { + artificial_count = artificial_count + 1 + weighted_artificial = weighted_artificial + rank_weight + let origin = artificial_origins[indices[rank] - real_cells] + let origin_index = scdfa_string_index(origin_labels, origin) + if origin_index >= 0 && origin != "" { + votes[origin_index] = votes[origin_index] + rank_weight + origin_total = origin_total + rank_weight + } + } + } + ratios[cell] = artificial_count.to_double() / k.to_double() + weighted[cell] = if total_weight > 0.0 { + weighted_artificial / total_weight + } else { + 0.0 + } + if origin_total > 0.0 { + let mut best = 0 + for origin in 1.. votes[best] { + best = origin + } + } + origins[cell] = origin_labels[best] + ambiguities[cell] = 1.0 - votes[best] / origin_total + } + } + ScdfaKnnMetrics::{ + weighted, + ratios, + nearest, + nearest_doublet, + nearest_real, + nearest_class, + origins, + ambiguities, + } +} + +///| +fn scdfa_cxds_scores( + counts : Array[Array[Double]], + real_cells : Int, + selected : Array[Int], +) -> Array[Double] { + let feature_count = if selected.length() < 64 { + selected.length() + } else { + 64 + } + let probabilities = Array::make(feature_count, 0.0) + for feature in 0..= 1.0 { + expressed = expressed + 1 + } + } + probabilities[feature] = expressed.to_double() / real_cells.to_double() + } + let pair_scores = scdfa_zero_matrix(feature_count, feature_count) + for left in 0..= 1.0 && + counts[cell][selected[right]] >= 1.0 { + observed = observed + 1 + } + } + let observed_rate = (observed.to_double() + 0.5) / + (real_cells.to_double() + 1.0) + let expected_rate = probabilities[left] * probabilities[right] + let surprise = if expected_rate > observed_rate { + @math.ln((expected_rate + 1.0e-12) / (observed_rate + 1.0e-12)) + } else { + 0.0 + } + pair_scores[left][right] = surprise + pair_scores[right][left] = surprise + } + } + let raw = Array::make(counts.length(), 0.0) + for cell in 0..= 1.0 { + for right in (left + 1)..= 1.0 { + total = total + pair_scores[left][right] + } + } + } + } + raw[cell] = total + } + let mut minimum = raw[0] + let mut maximum = raw[0] + for value in raw { + if value < minimum { + minimum = value + } + if value > maximum { + maximum = value + } + } + if maximum > minimum { + for index in 0.. Array[Array[Double]] { + let libraries = scdfa_library_sizes(counts) + let detected = scdfa_detected_features(counts, 0.0) + let above_two = scdfa_detected_features(counts, 2.0) + let extra_pcs = if coordinates[0].length() < 5 { + coordinates[0].length() + } else { + 5 + } + let features = [] + for cell in 0.. Array[Array[Double]] { + let rows = features.length() + let columns = features[0].length() + let means = Array::make(columns, 0.0) + let scales = Array::make(columns, 0.0) + for column in 0.. Array[Double] { + let columns = features[0].length() + let coefficients = Array::make(columns, 0.0) + let mut intercept = 0.0 + let mut positives = 0 + let mut negatives = 0 + for row in 0.. ScDblFinderThreshold { + let mut called_real = 0 + for score in real_scores { + if score >= threshold { + called_real = called_real + 1 + } + } + let mut missed_artificial = 0 + for score in artificial_scores { + if score < threshold { + missed_artificial = missed_artificial + 1 + } + } + let called_rate = called_real.to_double() / real_scores.length().to_double() + let lower = if expected_rate > uncertainty { + expected_rate - uncertainty + } else { + 0.0 + } + let upper = if expected_rate + uncertainty < 1.0 { + expected_rate + uncertainty + } else { + 1.0 + } + let deviation = if called_rate >= lower && called_rate <= upper { + 0.0 + } else if called_rate < lower { + (lower - called_rate) / (lower + 1.0 / real_scores.length().to_double()) + } else { + (called_rate - upper) / (upper + 1.0 / real_scores.length().to_double()) + } + let false_positive_rate = called_rate + let false_negative_rate = missed_artificial.to_double() / + artificial_scores.length().to_double() + ScDblFinderThreshold::{ + threshold, + cost: deviation * deviation + + 2.0 * stringency * false_positive_rate + + 2.0 * (1.0 - stringency) * false_negative_rate, + false_positive_rate, + false_negative_rate, + called_rate, + } +} + +///| +pub fn scdf_optimize_threshold( + real_scores : Array[Double], + artificial_scores : Array[Double], + expected_rate : Double, + uncertainty? : Double = -1.0, + stringency? : Double = 0.5, +) -> ScDblFinderThreshold raise ScDblFinderError { + if real_scores.length() == 0 || artificial_scores.length() == 0 { + scdfa_fail("scDblFinder thresholding requires both score classes") + } + if !scdfa_finite(expected_rate) || expected_rate < 0.0 || expected_rate > 1.0 { + scdfa_fail("scDblFinder expected rate must be in [0, 1]") + } + if !scdfa_finite(uncertainty) || + uncertainty > 1.0 || + (uncertainty < 0.0 && uncertainty != -1.0) { + scdfa_fail("scDblFinder uncertainty must be -1 or in [0, 1]") + } + if !scdfa_finite(stringency) || stringency <= 0.0 || stringency >= 1.0 { + scdfa_fail("scDblFinder stringency must be in (0, 1)") + } + let all_scores = [] + for score in real_scores { + if !scdfa_finite(score) || score < 0.0 || score > 1.0 { + scdfa_fail("scDblFinder scores must be finite and in [0, 1]") + } + all_scores.push(score) + } + for score in artificial_scores { + if !scdfa_finite(score) || score < 0.0 || score > 1.0 { + scdfa_fail("scDblFinder scores must be finite and in [0, 1]") + } + all_scores.push(score) + } + for index in 1.. 0 && all_scores[position - 1] > value { + all_scores[position] = all_scores[position - 1] + position = position - 1 + } + all_scores[position] = value + } + let effective_uncertainty = if uncertainty >= 0.0 { + uncertainty + } else { + 0.3 * expected_rate + 0.025 + } + let mut best = scdfa_threshold_cost( + real_scores, artificial_scores, 0.0, expected_rate, effective_uncertainty, stringency, + ) + for index in 0.. best.threshold) { + best = current + } + } + best +} + +///| +fn scdfa_top_indices( + values : Array[Double], + candidates : Array[Int], + limit : Int, + descending : Bool, +) -> Array[Int] { + let ordered = candidates.copy() + for index in 1.. 0 && + (if descending { + values[ordered[position - 1]] < values[value] + } else { + values[ordered[position - 1]] > values[value] + }) { + ordered[position] = ordered[position - 1] + position = position - 1 + } + ordered[position] = value + } + let result = [] + let count = if limit < ordered.length() { limit } else { ordered.length() } + for index in 0.. ScdfaCaptureFit raise ScDblFinderError { + let local_counts = [] + let local_names = [] + let local_clusters = [] + let local_known = [] + for index in global_indices { + local_counts.push(data.counts[index].copy()) + local_names.push(data.cell_names[index]) + if clusters.length() > 0 { + local_clusters.push(clusters[index]) + } + if known_doublets.length() > 0 { + local_known.push(known_doublets[index]) + } else { + local_known.push(false) + } + } + let local_data = SingleCellData::create( + local_counts, + local_names, + data.gene_names, + ) + let selected = scdfa_selected_features( + local_data.counts, + config.selected_features, + ) + let artificial_number = if config.artificial_doublets > 0 { + config.artificial_doublets + } else { + let proposed = local_data.counts.length() * 2 + if proposed < 150 { + 150 + } else if proposed > 1500 { + 1500 + } else { + proposed + } + } + let artificial = scdf_generate_artificial_doublets( + local_data, + artificial_number, + clusters=local_clusters, + random_fraction=config.random_fraction, + half_size_fraction=config.half_size_fraction, + seed=config.seed + global_indices[0], + ) + let combined = scdfa_copy_matrix(local_data.counts) + for row in artificial.counts { + combined.push(row.copy()) + } + let real_cells = local_data.counts.length() + let coordinates = scdfa_processed_coordinates( + combined, + real_cells, + selected, + config.dimensions, + ) + let metrics = scdfa_knn_metrics( + coordinates, + real_cells, + artificial.origins, + config.neighbors, + ) + let cxds = scdfa_cxds_scores(combined, real_cells, selected) + let raw_features = scdfa_classifier_features( + combined, coordinates, metrics, cxds, + ) + let features = scdfa_standardize(raw_features) + let labels = Array::make(combined.length(), false) + let included = Array::make(combined.length(), true) + for cell in 0..= 0.0 { + config.expected_doublet_rate + } else { + scdf_expected_doublet_rate( + real_cells, + rate_per_1000=config.doublet_rate_per_1000, + ) + } + let heterotypic_rate = if local_clusters.length() > 0 { + expected_rate * (1.0 - scdf_homotypic_proportion(local_clusters)) + } else { + expected_rate + } + let mut scores = Array::make(combined.length(), 0.0) + let mut threshold = ScDblFinderThreshold::{ + threshold: 0.5, + cost: 0.0, + false_positive_rate: 0.0, + false_negative_rate: 0.0, + called_rate: 0.0, + } + for iteration in 0..= threshold.threshold && !local_known[cell] { + suspect_real.push(cell) + } + } + let real_limit = (real_cells.to_double() * 0.2).to_int() + let excluded_real = scdfa_top_indices( + scores, suspect_real, real_limit, true, + ) + for cell in excluded_real { + included[cell] = false + } + let weak_artificial = [] + for cell in real_cells..= threshold.threshold + } + let libraries = scdfa_library_sizes(local_data.counts) + let detected = scdfa_detected_features(local_data.counts, 0.0) + let above_two = scdfa_detected_features(local_data.counts, 2.0) + let real_scores = [] + let real_weighted = [] + let real_ratios = [] + let real_cxds = [] + let real_nearest = [] + let real_doublet_distance = [] + let real_real_distance = [] + let real_nearest_class = [] + let real_origins = [] + let real_ambiguities = [] + let real_pca = [] + for cell in 0.. Array[String] { + let selected = scdfa_selected_features(data.counts, config.selected_features) + let coordinates = scdfa_processed_coordinates( + data.counts, + data.counts.length(), + selected, + config.dimensions, + ) + let clusters = if count < data.counts.length() { + count + } else { + data.counts.length() + } + let centroids = [] + centroids.push(coordinates[0].copy()) + while centroids.length() < clusters { + let mut best_index = 0 + let mut best_distance = -1.0 + for cell in 0.. best_distance { + best_distance = nearest + best_index = cell + } + } + centroids.push(coordinates[best_index].copy()) + } + let assignments = Array::make(coordinates.length(), 0) + for _ in 0..<50 { + let mut changed = false + for cell in 0.. 0 { + for component in 0.. Array[String] raise ScDblFinderError { + scdfa_validate_data(data) + if cluster_count < 2 || cluster_count > data.counts.length() { + scdfa_fail( + "scDblFinder cluster_count must be between 2 and the number of cells", + ) + } + let config = ScDblFinderConfig::create( + cluster_count~, + dimensions~, + selected_features~, + ) + scdfa_auto_clusters(data, cluster_count, config) +} + +///| +pub fn sc_dbl_finder( + data : SingleCellData, + clusters? : Array[String] = [], + samples? : Array[String] = [], + known_doublets? : Array[Bool] = [], + config? : ScDblFinderConfig = ScDblFinderConfig::default(), +) -> ScDblFinderResult raise ScDblFinderError { + scdfa_validate_data(data) + let cells = data.counts.length() + if clusters.length() > 0 && clusters.length() != cells { + scdfa_fail("scDblFinder cluster length must match cells") + } + if samples.length() > 0 && samples.length() != cells { + scdfa_fail("scDblFinder sample length must match cells") + } + if known_doublets.length() > 0 && known_doublets.length() != cells { + scdfa_fail("scDblFinder known_doublets length must match cells") + } + for cluster in clusters { + if cluster == "" { + scdfa_fail("scDblFinder clusters cannot contain empty labels") + } + } + let effective_samples = if samples.length() > 0 { + samples.copy() + } else { + Array::make(cells, "all") + } + for sample in effective_samples { + if sample == "" { + scdfa_fail("scDblFinder samples cannot contain empty labels") + } + } + let effective_clusters = if clusters.length() > 0 { + clusters.copy() + } else if config.cluster_count > 1 { + scdfa_auto_clusters(data, config.cluster_count, config) + } else { + [] + } + let effective_known = if known_doublets.length() > 0 { + known_doublets.copy() + } else { + Array::make(cells, false) + } + let sample_ids = scdfa_unique_strings(effective_samples) + let scores = Array::make(cells, 0.0) + let calls = Array::make(cells, false) + let weighted = Array::make(cells, 0.0) + let ratios = Array::make(cells, 0.0) + let cxds = Array::make(cells, 0.0) + let nearest = Array::make(cells, 0.0) + let nearest_doublet = Array::make(cells, 0.0) + let nearest_real = Array::make(cells, 0.0) + let nearest_classes = Array::make(cells, "") + let origins = Array::make(cells, "") + let ambiguities = Array::make(cells, 1.0) + let libraries = Array::make(cells, 0.0) + let detected = Array::make(cells, 0) + let above_two = Array::make(cells, 0) + let pca : Array[Array[Double]] = Array::make(cells, []) + let thresholds = [] + let expected_rates = [] + let selected_indices : Array[Int] = [] + let mut artificial_total = 0 + for sample_id in sample_ids { + let indices = [] + for cell in 0.. Int { + self.cell_names.length() +} + +///| +pub fn ScDblFinderResult::n_doublets(self : ScDblFinderResult) -> Int { + let mut total = 0 + for call in self.calls { + if call { + total = total + 1 + } + } + total +} + +///| +pub fn ScDblFinderResult::doublet_rate(self : ScDblFinderResult) -> Double { + self.n_doublets().to_double() / self.n_cells().to_double() +} + +///| +pub fn ScDblFinderResult::cell( + self : ScDblFinderResult, + cell_name : String, +) -> ScDblFinderCellResult? { + let index = scdfa_string_index(self.cell_names, cell_name) + if index < 0 { + return None + } + Some(ScDblFinderCellResult::{ + cell_name, + sample: self.samples[index], + cluster: if self.clusters.length() > 0 { + self.clusters[index] + } else { + "" + }, + score: self.scores[index], + is_doublet: self.calls[index], + weighted_ratio: self.weighted_ratios[index], + neighbor_ratio: self.neighbor_ratios[index], + cxds_score: self.cxds_scores[index], + nearest_class: self.nearest_classes[index], + origin: self.origins[index], + origin_ambiguity: self.origin_ambiguities[index], + }) +} + +///| +pub fn ScDblFinderResult::top_doublets( + self : ScDblFinderResult, + limit? : Int = 10, +) -> Array[ScDblFinderCellResult] raise ScDblFinderError { + if limit < 1 { + scdfa_fail("scDblFinder top-doublet limit must be positive") + } + let candidates = [] + for index in 0.. result.push(value) + None => () + } + } + result +} + +///| +pub fn ScDblFinderResult::summary(self : ScDblFinderResult) -> String { + "scDblFinder Result\n" + + "cells=" + + self.n_cells().to_string() + + ", doublets=" + + self.n_doublets().to_string() + + ", rate=" + + self.doublet_rate().to_string() + + "\nsamples=" + + self.sample_ids.length().to_string() + + ", selected_genes=" + + self.selected_gene_names.length().to_string() + + ", artificial_doublets=" + + self.artificial_doublets.to_string() + + ", iterations=" + + self.classifier_iterations.to_string() +} + +///| +pub fn ScDblFinderResult::filter_singlets( + self : ScDblFinderResult, + data : SingleCellData, +) -> SingleCellData raise ScDblFinderError { + scdfa_validate_data(data) + if data.cell_names != self.cell_names || data.gene_names != self.gene_names { + scdfa_fail("scDblFinder result and data identifiers do not match") + } + let counts = [] + let names = [] + for cell in 0.. Double { + let sign = if value < 0.0 { -1.0 } else { 1.0 } + let x = value.abs() + let t = 1.0 / (1.0 + 0.3275911 * x) + let polynomial = ( + (((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * + t + + 0.254829592 + ) * + t + sign * (1.0 - polynomial * @math.exp(-x * x)) +} + +///| +fn scdfa_normal_cdf(value : Double) -> Double { + 0.5 * (1.0 + scdfa_erf(value / 1.4142135623730951)) +} + +///| +fn scdfa_poisson_upper(observed : Int, expected : Double) -> Double { + if observed <= 0 { + return 1.0 + } + if expected <= 0.0 { + return 0.0 + } + if expected > 100.0 { + let z = (observed.to_double() - 0.5 - expected) / expected.sqrt() + return 1.0 - scdfa_normal_cdf(z) + } + let mut term = @math.exp(-expected) + let mut cumulative = term + for count in 1.. 1.0 { + 1.0 + } else { + result + } +} + +///| +fn scdfa_bh_adjust(values : Array[Double]) -> Array[Double] { + let indices = [] + for index in 0.. 0 && values[indices[position - 1]] > values[value] { + indices[position] = indices[position - 1] + position = position - 1 + } + indices[position] = value + } + let adjusted = Array::make(values.length(), 1.0) + let mut running = 1.0 + let mut rank = values.length() + while rank > 0 { + let index = indices[rank - 1] + let candidate = values[index] * + values.length().to_double() / + rank.to_double() + if candidate < running { + running = candidate + } + adjusted[index] = if running > 1.0 { 1.0 } else { running } + rank = rank - 1 + } + adjusted +} + +///| +pub fn scdf_pairwise_enrichment( + result : ScDblFinderResult, +) -> Array[ScDblFinderEnrichment] raise ScDblFinderError { + if result.clusters.length() == 0 { + scdfa_fail("scDblFinder enrichment requires cluster-aware fitting") + } + let labels = scdfa_unique_strings(result.clusters) + if labels.length() < 2 { + scdfa_fail("scDblFinder enrichment requires at least two clusters") + } + let proportions = Array::make(labels.length(), 0.0) + for cluster in result.clusters { + let index = scdfa_string_index(labels, cluster) + proportions[index] = proportions[index] + 1.0 + } + for index in 0..= 0 { + observed[index] = observed[index] + 1 + } + } + } + let heterotypic_probability = { + let mut total = 0.0 + for weight in pair_weights { + total = total + weight + } + total + } + let global_rate = if result.expected_doublet_rates.length() > 0 { + let mut weighted = 0.0 + for sample in 0.. 0.0 { + global_rate * + result.n_cells().to_double() * + pair_weights[pair] / + heterotypic_probability + } else { + 0.0 + } + expected_values.push(expected) + p_values.push(scdfa_poisson_upper(observed[pair], expected)) + } + let adjusted = scdfa_bh_adjust(p_values) + let enrichment = [] + for pair in 0.. 0 && enrichment[position - 1].p_value > value.p_value { + enrichment[position] = enrichment[position - 1] + position = position - 1 + } + enrichment[position] = value + } + enrichment +} + +///| +fn scdfa_copy_sce(source : SingleCellExperiment) -> SingleCellExperiment { + let assays : Map[String, Array[Array[Double]]] = Map([]) + for key in source.assays.keys() { + assays[key] = scdfa_copy_matrix(source.assays[key]) + } + let row_data : Map[String, Array[String]] = Map([]) + for key in source.row_data.keys() { + row_data[key] = source.row_data[key].copy() + } + let col_data : Map[String, Array[String]] = Map([]) + for key in source.col_data.keys() { + col_data[key] = source.col_data[key].copy() + } + let reduced_dims : Map[String, Array[Array[Double]]] = Map([]) + for key in source.reduced_dims.keys() { + reduced_dims[key] = scdfa_copy_matrix(source.reduced_dims[key]) + } + let alternatives : Map[String, SingleCellExperiment] = Map([]) + for key in source.alternative_experiments.keys() { + alternatives[key] = source.alternative_experiments[key] + } + let metadata : Map[String, String] = Map([]) + for key in source.metadata.keys() { + metadata[key] = source.metadata[key] + } + SingleCellExperiment::{ + assays, + row_data, + col_data, + reduced_dims, + alternative_experiments: alternatives, + metadata, + row_names: source.row_names.copy(), + col_names: source.col_names.copy(), + } +} + +///| +pub fn sc_dbl_finder_single_cell_experiment( + experiment : SingleCellExperiment, + assay_name? : String = "counts", + cluster_column? : String = "", + sample_column? : String = "", + known_doublet_column? : String = "", + output_prefix? : String = "scDblFinder", + config? : ScDblFinderConfig = ScDblFinderConfig::default(), +) -> ScDblFinderSingleCellExperimentOutput raise ScDblFinderError { + if assay_name == "" || output_prefix == "" { + scdfa_fail("scDblFinder assay name and output prefix cannot be empty") + } + if !experiment.assays.contains(assay_name) { + scdfa_fail("scDblFinder assay not found: " + assay_name) + } + let matrix = experiment.assays[assay_name] + if matrix.length() == 0 || matrix[0].length() == 0 { + scdfa_fail("scDblFinder assay cannot be empty") + } + let genes = matrix.length() + let cells = matrix[0].length() + if experiment.row_names.length() != genes || + experiment.col_names.length() != cells { + scdfa_fail( + "scDblFinder SingleCellExperiment names must match assay dimensions", + ) + } + let counts = scdfa_zero_matrix(cells, genes) + for gene in 0.. ( + SingleCellData, + Array[String], + Array[String], + Array[Bool], +) raise ScDblFinderError { + let genes : Array[String] = [] + for gene in 0..<24 { + genes.push("gene_" + (gene + 1).to_string()) + } + let counts : Array[Array[Double]] = [] + let names : Array[String] = [] + let clusters : Array[String] = [] + let samples : Array[String] = [] + let truth : Array[Bool] = [] + for cluster in 0..<3 { + for cell in 0..<12 { + let row : Array[Double] = [] + for gene in 0..<24 { + let block = gene / 8 + let base = if block == cluster { 14.0 } else { 1.0 } + let variation = ((cell * 3 + gene * 5 + cluster) % 5).to_double() * 0.4 + row.push(base + variation) + } + counts.push(row) + names.push("singlet_" + (cluster * 12 + cell + 1).to_string()) + clusters.push("type_" + (cluster + 1).to_string()) + samples.push(if cell % 2 == 0 { "capture_A" } else { "capture_B" }) + truth.push(false) + } + } + let doublet_pairs = [(0, 1), (0, 2), (1, 2), (0, 1), (0, 2), (1, 2)] + for doublet in 0.. Unit raise ScuttleError { + raise ScuttleError(message) +} + +///| +fn scuttle_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn scuttle_copy_matrix(matrix : Array[Array[Double]]) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in matrix { + output.push(row.copy()) + } + output +} + +///| +fn scuttle_matrix_shape( + matrix : Array[Array[Double]], + require_nonnegative : Bool, +) -> (Int, Int) raise ScuttleError { + let rows = matrix.length() + let columns = if rows > 0 { matrix[0].length() } else { 0 } + for row in 0.. Unit raise ScuttleError { + if name.trim().length() == 0 { + scuttle_fail("scuttle " + kind + " names must not be empty") + } +} + +///| +fn scuttle_validate_unique_names( + names : Array[String], + kind : String, +) -> Unit raise ScuttleError { + for index in 0.. Double { + if values.length() == 0 { + return 0.0 + } + let sorted = values.copy() + sorted.sort_by(fn(left : Double, right : Double) -> Int { + if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + let middle = sorted.length() / 2 + if sorted.length() % 2 == 1 { + sorted[middle] + } else { + (sorted[middle - 1] + sorted[middle]) / 2.0 + } +} + +///| +fn scuttle_mad(values : Array[Double], center : Double) -> Double { + if values.length() == 0 { + return 0.0 + } + let deviations : Array[Double] = [] + for value in values { + if value <= -1.0e299 && center <= -1.0e299 { + deviations.push(0.0) + } else { + deviations.push((value - center).abs()) + } + } + scuttle_median(deviations) * 1.4826 +} + +///| +fn scuttle_mean(values : Array[Double]) -> Double { + if values.length() == 0 { + return 0.0 + } + let mut total = 0.0 + for value in values { + total = total + value + } + total / values.length().to_double() +} + +///| +fn scuttle_string_index(values : Array[String], target : String) -> Int { + for index in 0.. Array[String] { + let output : Array[String] = [] + for value in values { + if scuttle_string_index(output, value) < 0 { + output.push(value) + } + } + output.sort_by(fn(left : String, right : String) -> Int { + if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + output +} + +///| +pub fn scuttle_outlier_both() -> ScuttleOutlierDirection { + ScuttleBoth +} + +///| +pub fn scuttle_outlier_lower() -> ScuttleOutlierDirection { + ScuttleLower +} + +///| +pub fn scuttle_outlier_higher() -> ScuttleOutlierDirection { + ScuttleHigher +} + +///| +pub fn scuttle_batch_median() -> ScuttleBatchSummary { + ScuttleBatchMedian +} + +///| +pub fn scuttle_batch_mean() -> ScuttleBatchSummary { + ScuttleBatchMean +} + +///| +pub fn scuttle_batch_geometric_mean() -> ScuttleBatchSummary { + ScuttleBatchGeometricMean +} + +///| +pub fn ScuttleOutlierConfig::create( + nmads? : Double = 3.0, + direction? : ScuttleOutlierDirection = ScuttleBoth, + log_transform? : Bool = false, + subset? : Array[Int]? = None, + batches? : Array[String] = [], + share_medians? : Bool = false, + share_mads? : Bool = false, + share_missing? : Bool = true, + min_diff? : Double? = None, +) -> ScuttleOutlierConfig raise ScuttleError { + if !scuttle_is_finite(nmads) || nmads < 0.0 { + scuttle_fail("scuttle nmads must be finite and non-negative") + } + match min_diff { + Some(value) => + if !scuttle_is_finite(value) || value < 0.0 { + scuttle_fail("scuttle min_diff must be finite and non-negative") + } + None => () + } + let copied_subset = match subset { + Some(values) => Some(values.copy()) + None => None + } + ScuttleOutlierConfig::{ + nmads, + direction, + log_transform, + subset: copied_subset, + batches: batches.copy(), + share_medians, + share_mads, + share_missing, + min_diff, + } +} + +///| +pub fn ScuttleOutlierConfig::default() -> ScuttleOutlierConfig { + ScuttleOutlierConfig::{ + nmads: 3.0, + direction: ScuttleBoth, + log_transform: false, + subset: None, + batches: [], + share_medians: false, + share_mads: false, + share_missing: true, + min_diff: None, + } +} + +///| +fn scuttle_log2_value(value : Double) -> Double { + if value == 0.0 { + -1.0e300 + } else { + @math.log2(value) + } +} + +///| +fn scuttle_restore_log2_threshold(value : Double) -> Double { + if value <= -1.0e299 { + 0.0 + } else if value >= 1.0e299 { + 1.0e300 + } else { + @math.exp(value * 0.6931471805599453) + } +} + +///| +/// Identify median/MAD outliers with scuttle-compatible batch sharing. +/// +/// Batch names are sorted as R factor levels. When a threshold cannot be +/// estimated, affected output entries are `None` and `threshold_valid` is +/// false for that batch. +pub fn scuttle_is_outlier( + metric : Array[Double], + config? : ScuttleOutlierConfig = ScuttleOutlierConfig::default(), +) -> ScuttleOutlierResult raise ScuttleError { + for value in metric { + if !scuttle_is_finite(value) { + scuttle_fail("scuttle outlier metrics must contain finite values") + } + if config.log_transform && value < 0.0 { + scuttle_fail( + "scuttle log-transformed outlier metrics must be non-negative", + ) + } + } + if config.batches.length() > 0 && config.batches.length() != metric.length() { + scuttle_fail("scuttle batch length must equal metric length") + } + for batch in config.batches { + scuttle_validate_name(batch, "batch") + } + let effective_batches = if config.batches.length() == 0 { + Array::make(metric.length(), "1") + } else { + config.batches.copy() + } + let batch_names = if effective_batches.length() == 0 { + ["1"] + } else { + scuttle_sorted_unique(effective_batches) + } + let selected : Array[Int] = match config.subset { + Some(indices) => { + for index in indices { + if index < 0 || index >= metric.length() { + scuttle_fail("scuttle outlier subset index is out of bounds") + } + } + indices.copy() + } + None => { + let indices : Array[Int] = [] + for index in 0.. 0 + let global_median = if has_global { + scuttle_median(all_selected) + } else { + 0.0 + } + let medians = Array::make(batch_names.length(), 0.0) + let median_valid = Array::make(batch_names.length(), false) + for batch in 0.. 0 + if !config.share_medians && has_batch { + medians[batch] = scuttle_median(selected_by_batch[batch]) + median_valid[batch] = true + } + let use_shared = if config.share_medians && config.share_missing { + true + } else if config.share_missing { + !has_batch + } else if config.share_medians { + has_batch + } else { + false + } + if use_shared && has_global { + medians[batch] = global_median + median_valid[batch] = true + } + } + let mads = Array::make(batch_names.length(), 0.0) + let mad_valid = Array::make(batch_names.length(), false) + for batch in 0.. 0 && + median_valid[batch] && + !config.share_mads { + mads[batch] = scuttle_mad(selected_by_batch[batch], medians[batch]) + mad_valid[batch] = true + } + } + let shared_deviations : Array[Double] = [] + if has_global { + for index in selected { + let batch = scuttle_string_index(batch_names, effective_batches[index]) + if median_valid[batch] { + let value = transformed[index] + if value <= -1.0e299 && medians[batch] <= -1.0e299 { + shared_deviations.push(0.0) + } else { + shared_deviations.push((value - medians[batch]).abs()) + } + } + } + } + let has_shared_mad = shared_deviations.length() > 0 + let shared_mad = if has_shared_mad { + scuttle_median(shared_deviations) * 1.4826 + } else { + 0.0 + } + for batch in 0.. 0 + let use_shared = if config.share_mads && config.share_missing { + true + } else if config.share_missing { + !has_batch + } else if config.share_mads { + has_batch + } else { + false + } + if use_shared && median_valid[batch] && has_shared_mad { + mads[batch] = shared_mad + mad_valid[batch] = true + } + } + let lower = Array::make(batch_names.length(), 0.0) + let higher = Array::make(batch_names.length(), 0.0) + let threshold_valid = Array::make(batch_names.length(), false) + for batch in 0.. value.max(mad_difference) + None => mad_difference + } + lower[batch] = match config.direction { + ScuttleHigher => -1.0e300 + _ => medians[batch] - difference + } + higher[batch] = match config.direction { + ScuttleLower => 1.0e300 + _ => medians[batch] + difference + } + threshold_valid[batch] = true + } + } + let outliers : Array[Bool?] = [] + for index in 0.. higher[batch], + ), + ) + } else { + outliers.push(None) + } + } + if config.log_transform { + for batch in 0.. Int { + let mut count = 0 + for value in self.outliers { + match value { + Some(true) => count = count + 1 + _ => () + } + } + count +} + +///| +pub fn ScuttleNamedCellSubset::create( + name : String, + indices : Array[Int], +) -> ScuttleNamedCellSubset raise ScuttleError { + scuttle_validate_name(name, "cell subset") + ScuttleNamedCellSubset::{ name, indices: indices.copy() } +} + +///| +/// Compute per-feature means and detection percentages, including optional +/// subsets of cells and subset/global mean ratios. +pub fn scuttle_per_feature_qc( + counts : Array[Array[Double]], + subsets? : Array[ScuttleNamedCellSubset] = [], + detection_limit? : Double = 0.0, +) -> ScuttleFeatureQcMetrics raise ScuttleError { + let (features, cells) = scuttle_matrix_shape(counts, true) + if !scuttle_is_finite(detection_limit) { + scuttle_fail("scuttle detection_limit must be finite") + } + let subset_names : Array[String] = [] + for subset in subsets { + subset_names.push(subset.name) + } + scuttle_validate_unique_names(subset_names, "cell subset") + for subset in subsets { + for index in subset.indices { + if index < 0 || index >= cells { + scuttle_fail("scuttle cell subset index is out of bounds") + } + } + } + let means = Array::make(features, 0.0) + let detected_percent = Array::make(features, 0.0) + for feature in 0.. detection_limit { + detected = detected + 1 + } + } + if cells > 0 { + means[feature] = total / cells.to_double() + detected_percent[feature] = detected.to_double() * + 100.0 / + cells.to_double() + } + } + let subset_means : Array[Array[Double]] = [] + let subset_detected_percent : Array[Array[Double]] = [] + let subset_ratios : Array[Array[Double]] = [] + for subset in subsets { + let current_means = Array::make(features, 0.0) + let current_detected = Array::make(features, 0.0) + let current_ratios = Array::make(features, 0.0) + for feature in 0.. detection_limit { + detected = detected + 1 + } + } + if subset.indices.length() > 0 { + current_means[feature] = total / subset.indices.length().to_double() + current_detected[feature] = detected.to_double() * + 100.0 / + subset.indices.length().to_double() + } + if means[feature] != 0.0 { + current_ratios[feature] = current_means[feature] / means[feature] + } + } + subset_means.push(current_means) + subset_detected_percent.push(current_detected) + subset_ratios.push(current_ratios) + } + ScuttleFeatureQcMetrics::{ + means, + detected_percent, + subset_names, + subset_means, + subset_detected_percent, + subset_ratios, + } +} + +///| +pub fn ScuttleFeatureSet::create( + name : String, + indices : Array[Int], +) -> ScuttleFeatureSet raise ScuttleError { + scuttle_validate_name(name, "feature set") + ScuttleFeatureSet::{ name, indices: indices.copy() } +} + +///| +fn scuttle_validate_feature_sets( + feature_sets : Array[ScuttleFeatureSet], + features : Int, +) -> Unit raise ScuttleError { + let names : Array[String] = [] + for feature_set in feature_sets { + names.push(feature_set.name) + } + scuttle_validate_unique_names(names, "feature set") + for feature_set in feature_sets { + for index in feature_set.indices { + if index < 0 || index >= features { + scuttle_fail("scuttle feature set index is out of bounds") + } + } + } +} + +///| +/// Aggregate arbitrary, potentially overlapping feature sets. +pub fn scuttle_aggregate_feature_sets( + expression : Array[Array[Double]], + feature_sets : Array[ScuttleFeatureSet], + average? : Bool = false, + detection_limit? : Double? = None, +) -> ScuttleFeatureAggregation raise ScuttleError { + let (features, cells) = scuttle_matrix_shape(expression, false) + scuttle_validate_feature_sets(feature_sets, features) + match detection_limit { + Some(value) => + if !scuttle_is_finite(value) { + scuttle_fail("scuttle detection_limit must be finite") + } + None => () + } + let names : Array[String] = [] + let values : Array[Array[Double]] = [] + let sizes : Array[Int] = [] + for feature_set in feature_sets { + names.push(feature_set.name) + sizes.push(feature_set.indices.length()) + let row = Array::make(cells, 0.0) + for feature in feature_set.indices { + for cell in 0.. + if expression[feature][cell] > limit { + 1.0 + } else { + 0.0 + } + None => expression[feature][cell] + } + row[cell] = row[cell] + contribution + } + } + if average && feature_set.indices.length() > 0 { + for cell in 0.. ScuttleFeatureAggregation raise ScuttleError { + let (features, _) = scuttle_matrix_shape(expression, false) + if ids.length() != features { + scuttle_fail("scuttle feature ids must match the number of rows") + } + let names = scuttle_sorted_unique(ids) + let retained : Array[String] = [] + for name in names { + if name.length() > 0 { + retained.push(name) + } + } + let feature_sets : Array[ScuttleFeatureSet] = [] + for name in retained { + let indices : Array[Int] = [] + for feature in 0.. Array[Array[Int]] raise ScuttleError { + let (features, cells) = scuttle_matrix_shape(counts, false) + let output : Array[Array[Int]] = [] + let mut total = 0 + for feature in 0.. 2147483646 - total { + scuttle_fail( + "scuttle count total exceeds reproducible integer precision", + ) + } + total = total + value + row.push(value) + } + output.push(row) + } + output +} + +///| +fn scuttle_lcg(state : Int) -> (Int, Double) { + let normalized = (state - 1) % 2147483646 + 1 + let quotient = normalized / 44488 + let remainder = normalized % 44488 + let candidate = 48271 * remainder - 3399 * quotient + let next = if candidate > 0 { candidate } else { candidate + 2147483647 } + (next, next.to_double() / 2147483647.0) +} + +///| +fn scuttle_sample_categories( + counts : Array[Int], + required : Int, + seed : Int, +) -> (Array[Int], Int) { + let mut total = 0 + for value in counts { + total = total + value + } + if required <= 0 { + return (Array::make(counts.length(), 0), seed) + } + if required >= total { + return (counts.copy(), seed) + } + let sample_kept = required <= total - required + let draws = if sample_kept { required } else { total - required } + let pool = counts.copy() + let sampled = Array::make(counts.length(), 0) + let mut remaining = total + let mut state = seed + for _ in 0.. Unit raise ScuttleError { + if !scuttle_is_finite(value) || value < 0.0 || value > 1.0 { + scuttle_fail("scuttle downsampling proportions must lie in [0, 1]") + } +} + +///| +/// Downsample each cell without replacement to an exact rounded total. +pub fn scuttle_downsample_columns( + counts : Array[Array[Double]], + proportions : Array[Double], + seed? : Int = 1, +) -> Array[Array[Double]] raise ScuttleError { + if seed <= 0 { + scuttle_fail("scuttle random seed must be positive") + } + let sanitized = scuttle_sanitize_counts(counts) + let features = sanitized.length() + let cells = if features > 0 { sanitized[0].length() } else { 0 } + if proportions.length() != cells { + scuttle_fail("scuttle proportion count must equal the number of cells") + } + for proportion in proportions { + scuttle_validate_proportion(proportion) + } + let output : Array[Array[Double]] = [] + for _ in 0.. Array[Array[Double]] raise ScuttleError { + if seed <= 0 { + scuttle_fail("scuttle random seed must be positive") + } + scuttle_validate_proportion(proportion) + let sanitized = scuttle_sanitize_counts(counts) + let features = sanitized.length() + let cells = if features > 0 { sanitized[0].length() } else { 0 } + if by_column { + return scuttle_downsample_columns( + counts, + Array::make(cells, proportion), + seed~, + ) + } + let flattened : Array[Int] = [] + let mut total = 0 + for cell in 0.. Array[Double] { + let cells = if matrix.length() > 0 { matrix[0].length() } else { 0 } + let sums = Array::make(cells, 0.0) + for row in matrix { + for cell in 0.. Double { + match summary_method { + ScuttleBatchMean => scuttle_mean(values) + ScuttleBatchMedian => scuttle_median(values) + ScuttleBatchGeometricMean => { + if values.length() == 0 { + return 0.0 + } + let mut total = 0.0 + for value in values { + total = total + @math.ln(value + 1.0) + } + @math.exp(total / values.length().to_double()) + } + } +} + +///| +/// Equalize average coverage across batches, optionally within blocks. +pub fn scuttle_downsample_batches( + counts : Array[Array[Double]], + batches : Array[String], + blocks? : Array[String] = [], + summary_method? : ScuttleBatchSummary = ScuttleBatchMedian, + by_column? : Bool = true, + seed? : Int = 1, +) -> ScuttleBatchDownsampleResult raise ScuttleError { + if seed <= 0 { + scuttle_fail("scuttle random seed must be positive") + } + let (_, cells) = scuttle_matrix_shape(counts, false) + if batches.length() != cells { + scuttle_fail("scuttle batch length must equal the number of cells") + } + if blocks.length() > 0 && blocks.length() != cells { + scuttle_fail("scuttle block length must equal the number of cells") + } + for batch in batches { + scuttle_validate_name(batch, "batch") + } + for block in blocks { + scuttle_validate_name(block, "block") + } + let effective_blocks = if blocks.length() == 0 { + Array::make(cells, "1") + } else { + blocks.copy() + } + let group_names : Array[String] = [] + let group_blocks : Array[String] = [] + let group_indices : Array[Array[Int]] = [] + let group_index = Array::make(cells, 0) + for cell in 0.. 0.0 { + target / summaries[group] + } else { + 1.0 + } + } + let sanitized = scuttle_sanitize_counts(counts) + let features = sanitized.length() + let output : Array[Array[Double]] = [] + for _ in 0.. SingleCellExperiment { + let assays : Map[String, Array[Array[Double]]] = Map([]) + for key in source.assays.keys() { + assays[key] = scuttle_copy_matrix(source.assays[key]) + } + let row_data : Map[String, Array[String]] = Map([]) + for key in source.row_data.keys() { + row_data[key] = source.row_data[key].copy() + } + let col_data : Map[String, Array[String]] = Map([]) + for key in source.col_data.keys() { + col_data[key] = source.col_data[key].copy() + } + let reduced_dims : Map[String, Array[Array[Double]]] = Map([]) + for key in source.reduced_dims.keys() { + reduced_dims[key] = scuttle_copy_matrix(source.reduced_dims[key]) + } + let alternatives : Map[String, SingleCellExperiment] = Map([]) + for key in source.alternative_experiments.keys() { + alternatives[key] = scuttle_copy_sce(source.alternative_experiments[key]) + } + let metadata : Map[String, String] = Map([]) + for key in source.metadata.keys() { + metadata[key] = source.metadata[key] + } + SingleCellExperiment::{ + assays, + row_data, + col_data, + reduced_dims, + alternative_experiments: alternatives, + metadata, + row_names: source.row_names.copy(), + col_names: source.col_names.copy(), + } +} + +///| +fn scuttle_doubles_to_strings(values : Array[Double]) -> Array[String] { + let output : Array[String] = [] + for value in values { + output.push(value.to_string()) + } + output +} + +///| +/// Compute per-feature QC metrics from an SCE assay and write them to a deep +/// copy of row_data. +pub fn scuttle_per_feature_qc_sce( + experiment : SingleCellExperiment, + assay_name? : String = "counts", + subsets? : Array[ScuttleNamedCellSubset] = [], + detection_limit? : Double = 0.0, + output_prefix? : String = "scuttle", +) -> ScuttleFeatureQcSceOutput raise ScuttleError { + scuttle_validate_name(output_prefix, "output prefix") + let counts = match experiment.assays.get(assay_name) { + Some(value) => value + None => { + scuttle_fail("scuttle assay '" + assay_name + "' was not found") + [] + } + } + let (features, cells) = scuttle_matrix_shape(counts, true) + if experiment.row_names.length() != features || + experiment.col_names.length() != cells { + scuttle_fail("scuttle SCE dimensions do not match row or column names") + } + let metrics = scuttle_per_feature_qc(counts, subsets~, detection_limit~) + let output = scuttle_copy_sce(experiment) + output.row_data[output_prefix + ".mean"] = scuttle_doubles_to_strings( + metrics.means, + ) + output.row_data[output_prefix + ".detected"] = scuttle_doubles_to_strings( + metrics.detected_percent, + ) + for subset in 0.. SingleCellExperiment raise ScuttleError { + if assay_names.length() == 0 { + scuttle_fail("scuttle SCE aggregation requires at least one assay") + } + scuttle_validate_unique_names(assay_names, "assay") + let assays : Map[String, Array[Array[Double]]] = Map([]) + let mut expected_features = -1 + let mut expected_cells = -1 + for assay_name in assay_names { + let matrix = match experiment.assays.get(assay_name) { + Some(value) => value + None => { + scuttle_fail("scuttle assay '" + assay_name + "' was not found") + [] + } + } + let (features, cells) = scuttle_matrix_shape(matrix, false) + if expected_features < 0 { + expected_features = features + expected_cells = cells + scuttle_validate_feature_sets(feature_sets, features) + } else if features != expected_features || cells != expected_cells { + scuttle_fail("scuttle SCE assays must have identical dimensions") + } + assays[assay_name] = scuttle_aggregate_feature_sets( + matrix, + feature_sets, + average~, + ).values + } + if experiment.row_names.length() != expected_features || + experiment.col_names.length() != expected_cells { + scuttle_fail("scuttle SCE dimensions do not match row or column names") + } + let col_data : Map[String, Array[String]] = Map([]) + for key in experiment.col_data.keys() { + col_data[key] = experiment.col_data[key].copy() + } + let reduced_dims : Map[String, Array[Array[Double]]] = Map([]) + for key in experiment.reduced_dims.keys() { + reduced_dims[key] = scuttle_copy_matrix(experiment.reduced_dims[key]) + } + let alternatives : Map[String, SingleCellExperiment] = Map([]) + for key in experiment.alternative_experiments.keys() { + alternatives[key] = scuttle_copy_sce( + experiment.alternative_experiments[key], + ) + } + let metadata : Map[String, String] = Map([]) + for key in experiment.metadata.keys() { + metadata[key] = experiment.metadata[key] + } + metadata["scuttle.aggregate.average"] = average.to_string() + let names : Array[String] = [] + for feature_set in feature_sets { + names.push(feature_set.name) + } + SingleCellExperiment::{ + assays, + row_data: Map([]), + col_data, + reduced_dims, + alternative_experiments: alternatives, + metadata, + row_names: names, + col_names: experiment.col_names.copy(), + } +} + +///| +/// Add an exactly downsampled assay to a deep copy of an SCE. +pub fn scuttle_downsample_sce( + experiment : SingleCellExperiment, + proportion : Double, + assay_name? : String = "counts", + output_assay? : String = "downsampled", + by_column? : Bool = true, + seed? : Int = 1, +) -> SingleCellExperiment raise ScuttleError { + scuttle_validate_name(output_assay, "output assay") + let counts = match experiment.assays.get(assay_name) { + Some(value) => value + None => { + scuttle_fail("scuttle assay '" + assay_name + "' was not found") + [] + } + } + let (features, cells) = scuttle_matrix_shape(counts, false) + if experiment.row_names.length() != features || + experiment.col_names.length() != cells { + scuttle_fail("scuttle SCE dimensions do not match row or column names") + } + let downsampled = scuttle_downsample_matrix( + counts, + proportion, + by_column~, + seed~, + ) + let output = scuttle_copy_sce(experiment) + output.assays[output_assay] = downsampled + output.metadata["scuttle.downsample.source"] = assay_name + output.metadata["scuttle.downsample.proportion"] = proportion.to_string() + output.metadata["scuttle.downsample.by_column"] = by_column.to_string() + output.metadata["scuttle.downsample.seed"] = seed.to_string() + output +} diff --git a/src/single_r_advanced.mbt b/src/single_r_advanced.mbt new file mode 100644 index 00000000..05aac80b --- /dev/null +++ b/src/single_r_advanced.mbt @@ -0,0 +1,1667 @@ +// Portable implementation of the core Bioconductor SingleR 2.15.2 workflow. +// +// Expression matrices follow the Bioconductor gene x sample/cell convention. +// The compatibility API remains in single_r.mbt; this module provides strict +// training, iterative fine-tuning, pruning, cluster annotation, multi-reference +// recomputation, and SingleCellExperiment integration. + +///| +pub suberror SingleRAdvancedError { + SingleRAdvancedError(String) +} + +///| +pub struct SingleRAdvancedConfig { + quantile : Double + fine_tune : Bool + tune_threshold : Double + prune : Bool + nmads : Double + minimum_delta_median : Double + minimum_delta_next : Double + marker_count : Int + combine_marker_count : Int +} derive(Debug) + +///| +pub fn SingleRAdvancedConfig::create( + quantile? : Double = 0.8, + fine_tune? : Bool = true, + tune_threshold? : Double = 0.05, + prune? : Bool = true, + nmads? : Double = 3.0, + minimum_delta_median? : Double = -1.0e300, + minimum_delta_next? : Double = 0.0, + marker_count? : Int = 0, + combine_marker_count? : Int = 10, +) -> SingleRAdvancedConfig raise SingleRAdvancedError { + if !single_r_adv_is_finite(quantile) || quantile < 0.0 || quantile > 1.0 { + raise SingleRAdvancedError("quantile must be finite and in [0, 1]") + } + if !single_r_adv_is_finite(tune_threshold) || tune_threshold < 0.0 { + raise SingleRAdvancedError("tune_threshold must be finite and non-negative") + } + if !single_r_adv_is_finite(nmads) || nmads < 0.0 { + raise SingleRAdvancedError("nmads must be finite and non-negative") + } + if !single_r_adv_is_finite(minimum_delta_median) { + raise SingleRAdvancedError("minimum_delta_median must be finite") + } + if !single_r_adv_is_finite(minimum_delta_next) { + raise SingleRAdvancedError("minimum_delta_next must be finite") + } + if marker_count < 0 { + raise SingleRAdvancedError("marker_count must be non-negative") + } + if combine_marker_count < 1 { + raise SingleRAdvancedError("combine_marker_count must be positive") + } + SingleRAdvancedConfig::{ + quantile, + fine_tune, + tune_threshold, + prune, + nmads, + minimum_delta_median, + minimum_delta_next, + marker_count, + combine_marker_count, + } +} + +///| +pub fn SingleRAdvancedConfig::default() -> SingleRAdvancedConfig { + SingleRAdvancedConfig::{ + quantile: 0.8, + fine_tune: true, + tune_threshold: 0.05, + prune: true, + nmads: 3.0, + minimum_delta_median: -1.0e300, + minimum_delta_next: 0.0, + marker_count: 0, + combine_marker_count: 10, + } +} + +///| +pub struct SingleRAdvancedReference { + expression : Array[Array[Double]] + labels : Array[String] + gene_names : Array[String] + sample_names : Array[String] + label_names : Array[String] + reference_name : String + n_genes : Int + n_samples : Int +} derive(Debug) + +///| +pub struct SingleRAdvancedData { + expression : Array[Array[Double]] + gene_names : Array[String] + cell_names : Array[String] + n_genes : Int + n_cells : Int +} derive(Debug) + +///| +pub struct SingleRAdvancedTraining { + reference : SingleRAdvancedReference + test_gene_names : Array[String] + common_gene_names : Array[String] + reference_gene_indices : Array[Int] + test_gene_indices : Array[Int] + label_names : Array[String] + sample_label_indices : Array[Int] + pairwise_markers : Array[Array[Array[Int]]] + common_markers : Array[Int] + marker_count : Int +} derive(Debug) + +///| +pub struct SingleRAdvancedResult { + cell_names : Array[String] + label_names : Array[String] + scores : Array[Array[Double]] + labels : Array[String] + first_labels : Array[String] + delta_next : Array[Double] + delta_median : Array[Double] + pruned_labels : Array[String?] + fine_tuned : Array[Bool] + pruning_thresholds : Array[Double?] + common_gene_names : Array[String] + marker_gene_names : Array[String] + reference_name : String + quantile : Double +} derive(Debug) + +///| +pub struct SingleRAdvancedCombinedResult { + cell_names : Array[String] + labels : Array[String] + pruned_labels : Array[String?] + references : Array[String] + selected_references : Array[String] + scores : Array[Array[Double]] + delta_next : Array[Double] + per_reference : Array[SingleRAdvancedResult] + marker_gene_names : Array[String] +} derive(Debug) + +///| +pub struct SingleRAdvancedSCEOutput { + experiment : SingleCellExperiment + result : SingleRAdvancedResult +} + +///| +fn single_r_adv_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn single_r_adv_copy_matrix( + matrix : Array[Array[Double]], +) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in matrix { + output.push(row.copy()) + } + output +} + +///| +fn single_r_adv_prepare_names( + supplied : Array[String], + count : Int, + prefix : String, +) -> Array[String] raise SingleRAdvancedError { + if supplied.length() != 0 && supplied.length() != count { + raise SingleRAdvancedError( + prefix + " names must match the matrix dimension", + ) + } + let output : Array[String] = [] + let seen : Map[String, Bool] = Map([]) + for index in 0.. (Int, Int) raise SingleRAdvancedError { + if expression.length() == 0 { + raise SingleRAdvancedError("expression must contain at least one gene") + } + let columns = expression[0].length() + if columns == 0 { + raise SingleRAdvancedError( + "expression must contain at least one " + column_name, + ) + } + for row in expression { + if row.length() != columns { + raise SingleRAdvancedError("expression must be rectangular") + } + for value in row { + if !single_r_adv_is_finite(value) { + raise SingleRAdvancedError("expression values must be finite") + } + } + } + (expression.length(), columns) +} + +///| +fn single_r_adv_unique_labels(labels : Array[String]) -> Array[String] { + let output : Array[String] = [] + for label in labels { + if !output.contains(label) { + output.push(label) + } + } + output +} + +///| +pub fn SingleRAdvancedReference::create( + expression : Array[Array[Double]], + labels : Array[String], + gene_names? : Array[String] = [], + sample_names? : Array[String] = [], + reference_name? : String = "reference", +) -> SingleRAdvancedReference raise SingleRAdvancedError { + let (n_genes, n_samples) = single_r_adv_validate_matrix( + expression, "reference sample", + ) + if labels.length() != n_samples { + raise SingleRAdvancedError( + "labels must contain one value per reference sample", + ) + } + let copied_labels : Array[String] = [] + for label in labels { + if label.trim().length() == 0 { + raise SingleRAdvancedError("reference labels cannot be empty") + } + copied_labels.push(label) + } + if reference_name.trim().length() == 0 { + raise SingleRAdvancedError("reference_name cannot be empty") + } + let prepared_genes = single_r_adv_prepare_names(gene_names, n_genes, "gene") + let prepared_samples = single_r_adv_prepare_names( + sample_names, n_samples, "reference sample", + ) + SingleRAdvancedReference::{ + expression: single_r_adv_copy_matrix(expression), + labels: copied_labels, + gene_names: prepared_genes, + sample_names: prepared_samples, + label_names: single_r_adv_unique_labels(copied_labels), + reference_name, + n_genes, + n_samples, + } +} + +///| +pub fn SingleRAdvancedData::create( + expression : Array[Array[Double]], + gene_names? : Array[String] = [], + cell_names? : Array[String] = [], +) -> SingleRAdvancedData raise SingleRAdvancedError { + let (n_genes, n_cells) = single_r_adv_validate_matrix(expression, "cell") + SingleRAdvancedData::{ + expression: single_r_adv_copy_matrix(expression), + gene_names: single_r_adv_prepare_names(gene_names, n_genes, "gene"), + cell_names: single_r_adv_prepare_names(cell_names, n_cells, "cell"), + n_genes, + n_cells, + } +} + +///| +pub fn SingleRAdvancedReference::copy_expression( + self : SingleRAdvancedReference, +) -> Array[Array[Double]] { + single_r_adv_copy_matrix(self.expression) +} + +///| +pub fn SingleRAdvancedData::copy_expression( + self : SingleRAdvancedData, +) -> Array[Array[Double]] { + single_r_adv_copy_matrix(self.expression) +} + +///| +fn single_r_adv_label_index(labels : Array[String], query : String) -> Int { + for index in 0.. Array[Double] { + let output = values.copy() + for index in 1.. 0 && output[position - 1] > value { + output[position] = output[position - 1] + position = position - 1 + } + output[position] = value + } + output +} + +///| +fn single_r_adv_quantile( + values : Array[Double], + probability : Double, +) -> Double { + if values.length() == 0 { + return 0.0 + } + let sorted = single_r_adv_sorted_values(values) + if sorted.length() == 1 { + return sorted[0] + } + let position = probability * (sorted.length() - 1).to_double() + let lower = position.to_int() + let upper = if lower + 1 < sorted.length() { lower + 1 } else { lower } + let fraction = position - lower.to_double() + sorted[lower] * (1.0 - fraction) + sorted[upper] * fraction +} + +///| +fn single_r_adv_median(values : Array[Double]) -> Double { + single_r_adv_quantile(values, 0.5) +} + +///| +fn single_r_adv_rank(values : Array[Double]) -> Array[Double] { + let ordered : Array[(Double, Int)] = [] + for index in 0.. 0 && + ( + ordered[position - 1].0 > value.0 || + ( + ordered[position - 1].0 == value.0 && + ordered[position - 1].1 > value.1 + ) + ) { + ordered[position] = ordered[position - 1] + position = position - 1 + } + ordered[position] = value + } + let ranks = Array::make(values.length(), 0.0) + let mut start = 0 + while start < ordered.length() { + let mut end = start + 1 + while end < ordered.length() && ordered[end].0 == ordered[start].0 { + end = end + 1 + } + let average = (start + 1 + end).to_double() / 2.0 + for position in start.. Double raise SingleRAdvancedError { + if left.length() != right.length() { + raise SingleRAdvancedError( + "Spearman correlation vectors must have equal length", + ) + } + if left.length() < 2 { + return 0.0 + } + for value in left { + if !single_r_adv_is_finite(value) { + raise SingleRAdvancedError("Spearman correlation vectors must be finite") + } + } + for value in right { + if !single_r_adv_is_finite(value) { + raise SingleRAdvancedError("Spearman correlation vectors must be finite") + } + } + let left_rank = single_r_adv_rank(left) + let right_rank = single_r_adv_rank(right) + let mean = (left.length() + 1).to_double() / 2.0 + let mut cross = 0.0 + let mut left_square = 0.0 + let mut right_square = 0.0 + for index in 0.. Int { + if label_count <= 1 { + return 500 + } + let exponent = @math.ln(label_count.to_double()) / @math.ln(2.0) + let value = 500.0 * @math.pow(2.0 / 3.0, exponent) + let converted = value.to_int() + if converted < 1 { + 1 + } else { + converted + } +} + +///| +fn single_r_adv_build_gene_index(names : Array[String]) -> Map[String, Int] { + let output : Map[String, Int] = Map([]) + for index in 0.. (Array[String], Array[Int], Array[Int]) raise SingleRAdvancedError { + let test_names = single_r_adv_prepare_names( + test_gene_names, + test_gene_names.length(), + "test gene", + ) + if test_names.length() == 0 { + raise SingleRAdvancedError("test_gene_names cannot be empty") + } + let reference_index = single_r_adv_build_gene_index(reference.gene_names) + let restriction : Map[String, Bool] = Map([]) + for name in restrict_genes { + if name.trim().length() == 0 { + raise SingleRAdvancedError("restrict_genes cannot contain empty names") + } + restriction[name] = true + } + let common : Array[String] = [] + let reference_indices : Array[Int] = [] + let test_indices : Array[Int] = [] + for test_index in 0.. Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for label in 0.. Array[(Int, Double)] { + let output = effects.copy() + for index in 1.. 0 && + ( + output[position - 1].1 < value.1 || + ( + output[position - 1].1 == value.1 && + output[position - 1].0 > value.0 + ) + ) { + output[position] = output[position - 1] + position = position - 1 + } + output[position] = value + } + output +} + +///| +fn single_r_adv_select_markers( + medians : Array[Array[Double]], + marker_count : Int, +) -> Array[Array[Array[Int]]] { + let label_count = medians.length() + let gene_count = if label_count == 0 { 0 } else { medians[0].length() } + let pairwise : Array[Array[Array[Int]]] = [] + for target in 0.. 0.0 { + effects.push((gene, effect)) + } + } + let sorted = single_r_adv_sort_gene_effects(effects) + let limit = if marker_count < sorted.length() { + marker_count + } else { + sorted.length() + } + for index in 0.. Array[Int] { + let selected = Array::make(gene_count, false) + for target in pairwise { + for comparison in target { + for gene in comparison { + selected[gene] = true + } + } + } + let output : Array[Int] = [] + for gene in 0.. SingleRAdvancedTraining raise SingleRAdvancedError { + if marker_count < 0 { + raise SingleRAdvancedError("marker_count must be non-negative") + } + let (common, reference_indices, test_indices) = single_r_adv_common_genes( + reference, test_gene_names, restrict_genes, + ) + let label_names = reference.label_names.copy() + let sample_label_indices : Array[Int] = [] + for label in reference.labels { + let index = single_r_adv_label_index(label_names, label) + if index < 0 { + raise SingleRAdvancedError("internal reference label mismatch") + } + sample_label_indices.push(index) + } + let selected_count = if marker_count == 0 { + single_r_adv_default_marker_count(label_names.length()) + } else { + marker_count + } + let medians = single_r_adv_label_medians( + reference, reference_indices, label_names, sample_label_indices, + ) + let pairwise = single_r_adv_select_markers(medians, selected_count) + let common_markers = single_r_adv_union_markers(pairwise, common.length()) + SingleRAdvancedTraining::{ + reference, + test_gene_names: test_gene_names.copy(), + common_gene_names: common, + reference_gene_indices: reference_indices, + test_gene_indices: test_indices, + label_names, + sample_label_indices, + pairwise_markers: pairwise, + common_markers, + marker_count: selected_count, + } +} + +///| +pub fn SingleRAdvancedTraining::marker_gene_names( + self : SingleRAdvancedTraining, +) -> Array[String] { + let output : Array[String] = [] + for index in self.common_markers { + output.push(self.common_gene_names[index]) + } + output +} + +///| +pub fn SingleRAdvancedTraining::markers_between( + self : SingleRAdvancedTraining, + target : String, + other : String, +) -> Array[String] raise SingleRAdvancedError { + let target_index = single_r_adv_label_index(self.label_names, target) + let other_index = single_r_adv_label_index(self.label_names, other) + if target_index < 0 || other_index < 0 { + raise SingleRAdvancedError("unknown label in marker query") + } + let output : Array[String] = [] + for index in self.pairwise_markers[target_index][other_index] { + output.push(self.common_gene_names[index]) + } + output +} + +///| +fn single_r_adv_same_strings( + left : Array[String], + right : Array[String], +) -> Bool { + if left.length() != right.length() { + return false + } + for index in 0.. Double raise SingleRAdvancedError { + let test_values : Array[Double] = [] + let reference_values : Array[Double] = [] + for feature in features { + test_values.push(data.expression[training.test_gene_indices[feature]][cell]) + reference_values.push( + training.reference.expression[training.reference_gene_indices[feature]][sample], + ) + } + single_r_advanced_spearman(test_values, reference_values) +} + +///| +fn single_r_adv_score_labels( + data : SingleRAdvancedData, + cell : Int, + training : SingleRAdvancedTraining, + features : Array[Int], + labels : Array[Int], + quantile : Double, +) -> Array[Double] raise SingleRAdvancedError { + let output : Array[Double] = [] + for label in labels { + let correlations : Array[Double] = [] + for sample in 0.. (Int, Double, Double) { + if labels.length() == 0 { + return (-1, 0.0, 0.0) + } + let mut best_position = 0 + let mut second = -2.0 + for position in 1.. scores[best_position] { + second = scores[best_position].max(second) + best_position = position + } else if scores[position] > second { + second = scores[position] + } + } + if scores.length() == 1 { + second = scores[best_position] + } + (labels[best_position], scores[best_position], scores[best_position] - second) +} + +///| +fn single_r_adv_candidates( + labels : Array[Int], + scores : Array[Double], + threshold : Double, +) -> Array[Int] { + if labels.length() == 0 { + return [] + } + let mut maximum = scores[0] + for score in scores { + if score > maximum { + maximum = score + } + } + let output : Array[Int] = [] + for position in 0..= maximum - threshold { + output.push(labels[position]) + } + } + output +} + +///| +fn single_r_adv_candidate_markers( + training : SingleRAdvancedTraining, + candidates : Array[Int], +) -> Array[Int] { + let chosen = Array::make(training.common_gene_names.length(), false) + for target in candidates { + for other in candidates { + if target != other { + for gene in training.pairwise_markers[target][other] { + chosen[gene] = true + } + } + } + } + let output : Array[Int] = [] + for gene in 0.. Bool { + if left.length() != right.length() { + return false + } + for index in 0.. (Int, Double, Bool) raise SingleRAdvancedError { + let all_labels : Array[Int] = [] + for label in 0.. 1 && iteration <= training.label_names.length() { + let features = single_r_adv_candidate_markers(training, candidates) + let scores = single_r_adv_score_labels( + data, + cell, + training, + features, + candidates, + config.quantile, + ) + let (current_best, _, current_delta) = single_r_adv_best_score( + candidates, scores, + ) + best = current_best + delta = current_delta + let next = single_r_adv_candidates( + candidates, + scores, + config.tune_threshold, + ) + if single_r_adv_same_ints(candidates, next) { + break + } + candidates = next + iteration = iteration + 1 + } + (best, delta, true) +} + +///| +fn single_r_adv_row_median(values : Array[Double]) -> Double { + single_r_adv_median(values) +} + +///| +fn single_r_adv_mad(values : Array[Double]) -> Double { + if values.length() == 0 { + return 0.0 + } + let center = single_r_adv_median(values) + let deviations : Array[Double] = [] + for value in values { + deviations.push((value - center).abs()) + } + 1.482602218505602 * single_r_adv_median(deviations) +} + +///| +fn single_r_adv_apply_pruning( + labels : Array[String], + label_names : Array[String], + delta_median : Array[Double], + delta_next : Array[Double], + config : SingleRAdvancedConfig, +) -> (Array[String?], Array[Double?]) { + let output : Array[String?] = [] + for label in labels { + output.push(Some(label)) + } + let thresholds : Array[Double?] = Array::make(label_names.length(), None) + if !config.prune { + return (output, thresholds) + } + let keep = Array::make(labels.length(), true) + for cell in 0.. 0 { + let threshold = single_r_adv_median(values) - + config.nmads * single_r_adv_mad(values) + thresholds[label] = Some(threshold) + for cell in 0.. SingleRAdvancedResult raise SingleRAdvancedError { + if !single_r_adv_same_strings(data.gene_names, training.test_gene_names) { + raise SingleRAdvancedError( + "test gene names must exactly match those used during training", + ) + } + let all_labels : Array[Int] = [] + for label in 0.. SingleRAdvancedResult raise SingleRAdvancedError { + let training = single_r_advanced_train( + reference, + data.gene_names, + restrict_genes~, + marker_count=config.marker_count, + ) + single_r_advanced_classify(data, training, config~) +} + +///| +pub fn SingleRAdvancedResult::n_cells(self : SingleRAdvancedResult) -> Int { + self.cell_names.length() +} + +///| +pub fn SingleRAdvancedResult::n_pruned(self : SingleRAdvancedResult) -> Int { + let mut count = 0 + for value in self.pruned_labels { + if value is None { + count = count + 1 + } + } + count +} + +///| +pub fn SingleRAdvancedResult::label_index( + self : SingleRAdvancedResult, + label : String, +) -> Int { + single_r_adv_label_index(self.label_names, label) +} + +///| +pub fn SingleRAdvancedResult::assigned_score( + self : SingleRAdvancedResult, + cell : Int, +) -> Double raise SingleRAdvancedError { + if cell < 0 || cell >= self.n_cells() { + raise SingleRAdvancedError("cell index is out of range") + } + let label = self.label_index(self.labels[cell]) + if label < 0 { + raise SingleRAdvancedError("assigned label is missing from score columns") + } + self.scores[cell][label] +} + +///| +pub fn SingleRAdvancedResult::summary( + self : SingleRAdvancedResult, +) -> Map[String, Int] { + let output : Map[String, Int] = Map([]) + for name in self.label_names { + output[name] = 0 + } + for label in self.labels { + output[label] = output.get(label).unwrap_or(0) + 1 + } + output["pruned"] = self.n_pruned() + output["total"] = self.n_cells() + output +} + +///| +fn single_r_adv_aggregate_clusters( + data : SingleRAdvancedData, + clusters : Array[String], +) -> SingleRAdvancedData raise SingleRAdvancedError { + if clusters.length() != data.n_cells { + raise SingleRAdvancedError("clusters must contain one value per cell") + } + let cluster_names : Array[String] = [] + for cluster in clusters { + if cluster.trim().length() == 0 { + raise SingleRAdvancedError("cluster names cannot be empty") + } + if !cluster_names.contains(cluster) { + cluster_names.push(cluster) + } + } + let expression : Array[Array[Double]] = [] + for gene in 0.. SingleRAdvancedResult raise SingleRAdvancedError { + let aggregated = single_r_adv_aggregate_clusters(data, clusters) + single_r_advanced(aggregated, reference, restrict_genes~, config~) +} + +///| +fn single_r_adv_marker_names_for_label( + training : SingleRAdvancedTraining, + label : Int, + top : Int, +) -> Array[String] { + let output : Array[String] = [] + for other in 0.. Array[String] { + let reference_maps : Array[Map[String, Int]] = [] + for reference in references { + reference_maps.push(single_r_adv_build_gene_index(reference.gene_names)) + } + let output : Array[String] = [] + for name in data.gene_names { + let mut present = true + for index in reference_maps { + if !index.contains(name) { + present = false + } + } + if present { + output.push(name) + } + } + output +} + +///| +fn single_r_adv_named_correlation( + data : SingleRAdvancedData, + cell : Int, + reference : SingleRAdvancedReference, + sample : Int, + genes : Array[String], +) -> Double raise SingleRAdvancedError { + let data_index = single_r_adv_build_gene_index(data.gene_names) + let reference_index = single_r_adv_build_gene_index(reference.gene_names) + let left : Array[Double] = [] + let right : Array[Double] = [] + for gene in genes { + if data_index.contains(gene) && reference_index.contains(gene) { + left.push(data.expression[data_index[gene]][cell]) + right.push(reference.expression[reference_index[gene]][sample]) + } + } + single_r_advanced_spearman(left, right) +} + +///| +fn single_r_adv_recomputed_score( + data : SingleRAdvancedData, + cell : Int, + reference : SingleRAdvancedReference, + label : String, + genes : Array[String], + quantile : Double, +) -> Double raise SingleRAdvancedError { + let correlations : Array[Double] = [] + for sample in 0.. SingleRAdvancedCombinedResult raise SingleRAdvancedError { + if references.length() < 2 { + raise SingleRAdvancedError( + "multi-reference integration requires at least two references", + ) + } + let reference_names : Array[String] = [] + for reference in references { + if reference_names.contains(reference.reference_name) { + raise SingleRAdvancedError("reference names must be unique") + } + reference_names.push(reference.reference_name) + } + let global_common = single_r_adv_global_common_genes(data, references) + if global_common.length() < 2 { + raise SingleRAdvancedError( + "all references and test data must share at least two genes", + ) + } + let effective_restriction : Array[String] = [] + if restrict_genes.length() == 0 { + for name in global_common { + effective_restriction.push(name) + } + } else { + for name in global_common { + if restrict_genes.contains(name) { + effective_restriction.push(name) + } + } + } + if effective_restriction.length() < 2 { + raise SingleRAdvancedError( + "gene restriction leaves fewer than two globally shared genes", + ) + } + let trainings : Array[SingleRAdvancedTraining] = [] + let per_reference : Array[SingleRAdvancedResult] = [] + for reference in references { + let training = single_r_advanced_train( + reference, + data.gene_names, + restrict_genes=effective_restriction, + marker_count=config.marker_count, + ) + trainings.push(training) + per_reference.push(single_r_advanced_classify(data, training, config~)) + } + let combined_scores : Array[Array[Double]] = [] + let labels : Array[String] = [] + let pruned_labels : Array[String?] = [] + let selected_references : Array[String] = [] + let delta_next : Array[Double] = [] + let all_markers : Array[String] = [] + for cell in 0.. Int { + self.cell_names.length() +} + +///| +pub fn SingleRAdvancedCombinedResult::reference_summary( + self : SingleRAdvancedCombinedResult, +) -> Map[String, Int] { + let output : Map[String, Int] = Map([]) + for reference in self.references { + output[reference] = 0 + } + for reference in self.selected_references { + output[reference] = output.get(reference).unwrap_or(0) + 1 + } + output +} + +///| +fn single_r_adv_copy_sce(source : SingleCellExperiment) -> SingleCellExperiment { + let assays : Map[String, Array[Array[Double]]] = Map([]) + for key in source.assays.keys() { + assays[key] = single_r_adv_copy_matrix(source.assays[key]) + } + let row_data : Map[String, Array[String]] = Map([]) + for key in source.row_data.keys() { + row_data[key] = source.row_data[key].copy() + } + let col_data : Map[String, Array[String]] = Map([]) + for key in source.col_data.keys() { + col_data[key] = source.col_data[key].copy() + } + let reduced_dims : Map[String, Array[Array[Double]]] = Map([]) + for key in source.reduced_dims.keys() { + reduced_dims[key] = single_r_adv_copy_matrix(source.reduced_dims[key]) + } + let alternatives : Map[String, SingleCellExperiment] = Map([]) + for key in source.alternative_experiments.keys() { + alternatives[key] = single_r_adv_copy_sce( + source.alternative_experiments[key], + ) + } + let metadata : Map[String, String] = Map([]) + for key in source.metadata.keys() { + metadata[key] = source.metadata[key] + } + SingleCellExperiment::{ + assays, + row_data, + col_data, + reduced_dims, + alternative_experiments: alternatives, + metadata, + row_names: source.row_names.copy(), + col_names: source.col_names.copy(), + } +} + +///| +fn single_r_adv_expand_cluster_strings( + clusters : Array[String], + cluster_names : Array[String], + values : Array[String], +) -> Array[String] { + let output : Array[String] = [] + for cluster in clusters { + let index = single_r_adv_label_index(cluster_names, cluster) + output.push(values[index]) + } + output +} + +///| +fn single_r_adv_expand_cluster_doubles( + clusters : Array[String], + cluster_names : Array[String], + values : Array[Double], +) -> Array[Double] { + let output : Array[Double] = [] + for cluster in clusters { + let index = single_r_adv_label_index(cluster_names, cluster) + output.push(values[index]) + } + output +} + +///| +fn single_r_adv_expand_cluster_options( + clusters : Array[String], + cluster_names : Array[String], + values : Array[String?], +) -> Array[String?] { + let output : Array[String?] = [] + for cluster in clusters { + let index = single_r_adv_label_index(cluster_names, cluster) + output.push(values[index]) + } + output +} + +///| +fn single_r_adv_option_string(value : String?) -> String { + match value { + Some(label) => label + None => "NA" + } +} + +///| +pub fn single_r_advanced_sce( + experiment : SingleCellExperiment, + reference : SingleRAdvancedReference, + assay_name? : String = "logcounts", + cluster_column? : String = "", + output_prefix? : String = "SingleR", + restrict_genes? : Array[String] = [], + config? : SingleRAdvancedConfig = SingleRAdvancedConfig::default(), +) -> SingleRAdvancedSCEOutput raise SingleRAdvancedError { + if assay_name.trim().length() == 0 || output_prefix.trim().length() == 0 { + raise SingleRAdvancedError("assay_name and output_prefix cannot be empty") + } + let assay = match experiment.assays.get(assay_name) { + Some(value) => value + None => + raise SingleRAdvancedError( + "SingleCellExperiment assay not found: " + assay_name, + ) + } + let data = SingleRAdvancedData::create( + assay, + gene_names=experiment.row_names, + cell_names=experiment.col_names, + ) + let clusters = if cluster_column == "" { + [] + } else { + match experiment.col_data.get(cluster_column) { + Some(values) => { + if values.length() != data.n_cells { + raise SingleRAdvancedError( + "cluster column length must match the number of cells", + ) + } + values.copy() + } + None => + raise SingleRAdvancedError( + "SingleCellExperiment cluster column not found: " + cluster_column, + ) + } + } + let result = if clusters.length() == 0 { + single_r_advanced(data, reference, restrict_genes~, config~) + } else { + single_r_advanced_clusters( + data, + clusters, + reference, + restrict_genes~, + config~, + ) + } + let labels = if clusters.length() == 0 { + result.labels.copy() + } else { + single_r_adv_expand_cluster_strings( + clusters, + result.cell_names, + result.labels, + ) + } + let pruned = if clusters.length() == 0 { + result.pruned_labels.copy() + } else { + single_r_adv_expand_cluster_options( + clusters, + result.cell_names, + result.pruned_labels, + ) + } + let next_delta = if clusters.length() == 0 { + result.delta_next.copy() + } else { + single_r_adv_expand_cluster_doubles( + clusters, + result.cell_names, + result.delta_next, + ) + } + let median_delta = if clusters.length() == 0 { + result.delta_median.copy() + } else { + single_r_adv_expand_cluster_doubles( + clusters, + result.cell_names, + result.delta_median, + ) + } + let scores : Array[String] = [] + for cell in 0.. 0 { + enriched.col_data[output_prefix + ".cluster"] = clusters + } + enriched.metadata[output_prefix + ".assay"] = assay_name + enriched.metadata[output_prefix + ".reference"] = reference.reference_name + enriched.metadata[output_prefix + ".quantile"] = config.quantile.to_string() + enriched.metadata[output_prefix + ".fineTune"] = config.fine_tune.to_string() + enriched.metadata[output_prefix + ".markers"] = result.marker_gene_names + .length() + .to_string() + enriched.metadata[output_prefix + ".pruned"] = result.n_pruned().to_string() + enriched.metadata[output_prefix + ".mode"] = if clusters.length() == 0 { + "cell" + } else { + "cluster" + } + SingleRAdvancedSCEOutput::{ experiment: enriched, result } +} + +///| +pub fn single_r_advanced_example() -> ( + SingleRAdvancedReference, + SingleRAdvancedData, +) raise SingleRAdvancedError { + let genes = [ + "CD3D", "CD3E", "TRAC", "MS4A1", "CD79A", "CD74", "LYZ", "S100A8", "FCGR3A", + "NKG7", "KLRD1", "GNLY", + ] + let reference = SingleRAdvancedReference::create( + [ + [8.0, 7.5, 0.5, 0.4, 0.5, 0.4, 0.3, 0.2], + [7.5, 8.0, 0.4, 0.5, 0.4, 0.5, 0.3, 0.2], + [7.0, 7.2, 0.8, 0.7, 0.6, 0.5, 0.5, 0.4], + [0.4, 0.5, 8.0, 7.5, 0.4, 0.3, 0.2, 0.2], + [0.5, 0.4, 7.4, 7.8, 0.5, 0.4, 0.2, 0.3], + [0.7, 0.6, 7.0, 7.2, 0.8, 0.7, 0.3, 0.3], + [0.5, 0.6, 0.8, 0.7, 8.0, 7.5, 0.5, 0.4], + [0.3, 0.4, 0.3, 0.4, 7.5, 8.0, 0.3, 0.2], + [0.4, 0.5, 0.4, 0.3, 6.8, 7.2, 0.7, 0.6], + [0.8, 0.7, 0.3, 0.3, 0.5, 0.4, 8.0, 7.5], + [0.7, 0.8, 0.2, 0.3, 0.4, 0.5, 7.5, 8.0], + [0.6, 0.7, 0.2, 0.2, 0.3, 0.4, 7.2, 7.8], + ], + [ + "T cell", "T cell", "B cell", "B cell", "Monocyte", "Monocyte", "NK cell", + "NK cell", + ], + gene_names=genes, + sample_names=["T1", "T2", "B1", "B2", "M1", "M2", "NK1", "NK2"], + reference_name="immune_reference", + ) + let data = SingleRAdvancedData::create( + [ + [7.8, 0.4, 0.5, 0.7, 4.0], + [7.4, 0.5, 0.4, 0.6, 3.8], + [7.0, 0.7, 0.5, 0.5, 3.6], + [0.4, 7.8, 0.5, 0.3, 4.1], + [0.5, 7.5, 0.4, 0.3, 3.9], + [0.6, 7.0, 0.7, 0.3, 3.7], + [0.5, 0.8, 7.8, 0.5, 0.7], + [0.3, 0.4, 7.5, 0.3, 0.4], + [0.4, 0.4, 7.0, 0.7, 0.5], + [0.7, 0.3, 0.5, 7.8, 0.5], + [0.8, 0.2, 0.4, 7.5, 0.4], + [0.6, 0.2, 0.3, 7.2, 0.3], + ], + gene_names=genes, + cell_names=["cell_T", "cell_B", "cell_M", "cell_NK", "cell_ambiguous"], + ) + (reference, data) +} diff --git a/src/slingshot_advanced.mbt b/src/slingshot_advanced.mbt new file mode 100644 index 00000000..d067f445 --- /dev/null +++ b/src/slingshot_advanced.mbt @@ -0,0 +1,2153 @@ +///| +/// Portable advanced core of Bioconductor slingshot 2.21.0. +/// Coordinates use cell x dimension orientation. + +///| +pub suberror SlingshotAdvancedError { + SlingshotAdvancedError(String) +} + +///| +pub enum SlingshotClusterDistance { + SlingshotCenterEuclidean + SlingshotScaledDiagonal + SlingshotScaledFull +} derive(Eq, Debug) + +///| +pub enum SlingshotCurveExtension { + SlingshotExtendNone + SlingshotExtendLine + SlingshotExtendPc1 +} derive(Eq, Debug) + +///| +pub fn slingshot_center_euclidean() -> SlingshotClusterDistance { + SlingshotCenterEuclidean +} + +///| +pub fn slingshot_scaled_diagonal() -> SlingshotClusterDistance { + SlingshotScaledDiagonal +} + +///| +pub fn slingshot_scaled_full() -> SlingshotClusterDistance { + SlingshotScaledFull +} + +///| +pub fn slingshot_extend_none() -> SlingshotCurveExtension { + SlingshotExtendNone +} + +///| +pub fn slingshot_extend_line() -> SlingshotCurveExtension { + SlingshotExtendLine +} + +///| +pub fn slingshot_extend_pc1() -> SlingshotCurveExtension { + SlingshotExtendPc1 +} + +///| +pub struct SlingshotAdvancedConfig { + start_clusters : Array[String] + end_clusters : Array[String] + distance : SlingshotClusterDistance + use_median : Bool + omega : Double + automatic_omega : Bool + omega_scale : Double + shrink : Double + extension : SlingshotCurveExtension + reweight : Bool + reassign : Bool + max_iterations : Int + tolerance : Double + smoother_span : Double + curve_points : Int + covariance_ridge : Double +} derive(Debug) + +///| +pub fn SlingshotAdvancedConfig::create( + start_clusters? : Array[String] = [], + end_clusters? : Array[String] = [], + distance? : SlingshotClusterDistance = SlingshotScaledFull, + use_median? : Bool = false, + omega? : Double = -1.0, + automatic_omega? : Bool = false, + omega_scale? : Double = 1.5, + shrink? : Double = 1.0, + extension? : SlingshotCurveExtension = SlingshotExtendLine, + reweight? : Bool = true, + reassign? : Bool = true, + max_iterations? : Int = 15, + tolerance? : Double = 0.001, + smoother_span? : Double = 0.3, + curve_points? : Int = 100, + covariance_ridge? : Double = 1.0e-6, +) -> SlingshotAdvancedConfig raise SlingshotAdvancedError { + if !slingshot_adv_is_finite(omega) || omega < -1.0 { + slingshot_adv_fail("slingshot omega must be -1 or non-negative") + } + if !slingshot_adv_is_finite(omega_scale) || omega_scale <= 0.0 { + slingshot_adv_fail("slingshot omega scale must be positive") + } + if !slingshot_adv_is_finite(shrink) || shrink < 0.0 || shrink > 1.0 { + slingshot_adv_fail("slingshot shrink must be between zero and one") + } + if max_iterations <= 0 { + slingshot_adv_fail("slingshot iteration limit must be positive") + } + if !slingshot_adv_is_finite(tolerance) || tolerance <= 0.0 { + slingshot_adv_fail("slingshot tolerance must be positive") + } + if !slingshot_adv_is_finite(smoother_span) || + smoother_span <= 0.0 || + smoother_span > 1.0 { + slingshot_adv_fail("slingshot smoother span must be in (0, 1]") + } + if curve_points < 2 { + slingshot_adv_fail("slingshot curve point count must be at least two") + } + if !slingshot_adv_is_finite(covariance_ridge) || covariance_ridge <= 0.0 { + slingshot_adv_fail("slingshot covariance ridge must be positive") + } + for name in start_clusters { + if name.length() == 0 { + slingshot_adv_fail("slingshot start cluster names cannot be empty") + } + } + for name in end_clusters { + if name.length() == 0 { + slingshot_adv_fail("slingshot end cluster names cannot be empty") + } + } + SlingshotAdvancedConfig::{ + start_clusters: start_clusters.copy(), + end_clusters: end_clusters.copy(), + distance, + use_median, + omega, + automatic_omega, + omega_scale, + shrink, + extension, + reweight, + reassign, + max_iterations, + tolerance, + smoother_span, + curve_points, + covariance_ridge, + } +} + +///| +pub struct SlingshotClusterSummary { + name : String + center : Array[Double] + covariance : Array[Array[Double]] + size : Double +} derive(Debug) + +///| +pub struct SlingshotLineageEdge { + from : Int + to : Int + distance : Double +} derive(Eq, Debug) + +///| +pub struct SlingshotLineageModel { + coordinates : Array[Array[Double]] + cluster_names : Array[String] + cluster_weights : Array[Array[Double]] + clusters : Array[SlingshotClusterSummary] + distance_matrix : Array[Array[Double]] + edges : Array[SlingshotLineageEdge] + components : Array[Int] + roots : Array[Int] + lineages : Array[Array[Int]] + initial_weights : Array[Array[Double]] + omega_threshold : Double +} derive(Debug) + +///| +pub struct SlingshotAdvancedCurve { + name : String + lineage : Array[Int] + points : Array[Array[Double]] + pseudotime : Array[Double] + distances : Array[Double] + weights : Array[Double] + length : Double +} derive(Debug) + +///| +pub struct SlingshotAdvancedResult { + lineage_model : SlingshotLineageModel + curves : Array[SlingshotAdvancedCurve] + pseudotime : Array[Array[Double?]] + weights : Array[Array[Double]] + average_pseudotime : Array[Double] + branch_ids : Array[String] + iterations : Int + converged : Bool + total_distance : Double + config : SlingshotAdvancedConfig +} derive(Debug) + +///| +pub struct SlingshotProjection { + pseudotime : Array[Array[Double?]] + weights : Array[Array[Double]] + distances : Array[Array[Double]] + average_pseudotime : Array[Double] + branch_ids : Array[String] +} derive(Debug) + +///| +pub struct SlingshotAdvancedSceOutput { + experiment : SingleCellExperiment + result : SlingshotAdvancedResult +} + +///| +fn slingshot_adv_fail(message : String) -> Unit raise SlingshotAdvancedError { + raise SlingshotAdvancedError(message) +} + +///| +fn slingshot_adv_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn slingshot_adv_double_matrix( + rows : Int, + columns : Int, + value : Double, +) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for _ in 0.. Array[Array[Double?]] { + let output : Array[Array[Double?]] = [] + for _ in 0.. Array[Array[Double]] { + matrix.map(fn(row) { row.copy() }) +} + +///| +fn slingshot_adv_shape( + matrix : Array[Array[Double]], + name : String, +) -> (Int, Int) raise SlingshotAdvancedError { + if matrix.length() == 0 { + slingshot_adv_fail(name + " must contain at least one row") + } + let columns = matrix[0].length() + if columns == 0 { + slingshot_adv_fail(name + " must contain at least one column") + } + for row in matrix { + if row.length() != columns { + slingshot_adv_fail(name + " must be rectangular") + } + for value in row { + if !slingshot_adv_is_finite(value) { + slingshot_adv_fail(name + " must contain only finite values") + } + } + } + (matrix.length(), columns) +} + +///| +fn slingshot_adv_unique_labels(labels : Array[String]) -> Array[String] { + let output : Array[String] = [] + for label in labels { + if label != "-1" && !output.contains(label) { + output.push(label) + } + } + output +} + +///| +fn slingshot_adv_label_index(names : Array[String], name : String) -> Int { + for index in 0.. Unit raise SlingshotAdvancedError { + if cluster_names.length() == 0 { + slingshot_adv_fail("slingshot must contain at least one cluster") + } + for index in 0.. Array[Array[Double]] raise SlingshotAdvancedError { + if weights.length() != cells { + slingshot_adv_fail("slingshot cluster weights must have one row per cell") + } + let output = slingshot_adv_double_matrix(cells, cluster_names.length(), 0.0) + let totals = Array::make(cluster_names.length(), 0.0) + for cell in 0.. 0.0 { + for cluster in 0.. Array[Double] { + let dimensions = coordinates[0].length() + let center = Array::make(dimensions, 0.0) + let mut total = 0.0 + for cell in 0.. Array[Double] { + let dimensions = coordinates[0].length() + let center : Array[Double] = [] + for dimension in 0.. 0.0 { + entries.push((coordinates[cell][dimension], weight, cell)) + total = total + weight + } + } + entries.sort_by(fn( + left : (Double, Double, Int), + right : (Double, Double, Int), + ) -> Int { + if left.0 < right.0 { + -1 + } else if left.0 > right.0 { + 1 + } else if left.2 < right.2 { + -1 + } else if left.2 > right.2 { + 1 + } else { + 0 + } + }) + let mut cumulative = 0.0 + let mut selected = entries[entries.length() - 1].0 + for entry in entries { + cumulative = cumulative + entry.1 + if cumulative >= 0.5 * total { + selected = entry.0 + break + } + } + center.push(selected) + } + center +} + +///| +fn slingshot_adv_covariance( + coordinates : Array[Array[Double]], + weights : Array[Array[Double]], + cluster : Int, + center : Array[Double], + ridge : Double, +) -> Array[Array[Double]] { + let dimensions = center.length() + let output = slingshot_adv_double_matrix(dimensions, dimensions, 0.0) + let mut total = 0.0 + let mut sum_squares = 0.0 + for cell in 0.. Array[SlingshotClusterSummary] { + let output : Array[SlingshotClusterSummary] = [] + for cluster in 0.. Array[Array[Double]]? { + let size = matrix.length() + if size == 0 { + return None + } + let augmented = slingshot_adv_double_matrix(size, size * 2, 0.0) + for row in 0.. augmented[best][pivot].abs() { + best = row + } + } + if augmented[best][pivot].abs() < 1.0e-12 { + return None + } + if best != pivot { + let temporary = augmented[pivot] + augmented[pivot] = augmented[best] + augmented[best] = temporary + } + let scale = augmented[pivot][pivot] + for column in 0..<(size * 2) { + augmented[pivot][column] = augmented[pivot][column] / scale + } + for row in 0.. Double { + let mut squared = 0.0 + for dimension in 0.. Double { + let dimensions = left.center.length() + if kind == SlingshotCenterEuclidean { + return slingshot_adv_euclidean(left.center, right.center) + } + let delta = Array::make(dimensions, 0.0) + for dimension in 0.. { + let mut squared = 0.0 + for row in 0.. + slingshot_adv_cluster_distance( + left, + right, + SlingshotScaledDiagonal, + ridge, + ) + } +} + +///| +fn slingshot_adv_distance_matrix( + clusters : Array[SlingshotClusterSummary], + config : SlingshotAdvancedConfig, +) -> Array[Array[Double]] { + let output = slingshot_adv_double_matrix( + clusters.length(), + clusters.length(), + 0.0, + ) + for left in 0.. Int { + let mut current = node + while parent[current] != current { + current = parent[current] + } + current +} + +///| +fn slingshot_adv_union( + parent : Array[Int], + ranks : Array[Int], + left : Int, + right : Int, +) -> Unit { + let left_root = slingshot_adv_find(parent, left) + let right_root = slingshot_adv_find(parent, right) + if left_root == right_root { + return + } + if ranks[left_root] < ranks[right_root] { + parent[left_root] = right_root + } else if ranks[left_root] > ranks[right_root] { + parent[right_root] = left_root + } else { + parent[right_root] = left_root + ranks[left_root] = ranks[left_root] + 1 + } +} + +///| +fn slingshot_adv_sorted_edges( + distances : Array[Array[Double]], +) -> Array[SlingshotLineageEdge] { + let output : Array[SlingshotLineageEdge] = [] + for left in 0.. Int { + if left.distance < right.distance { + -1 + } else if left.distance > right.distance { + 1 + } else if left.from < right.from { + -1 + } else if left.from > right.from { + 1 + } else if left.to < right.to { + -1 + } else if left.to > right.to { + 1 + } else { + 0 + } + }) + output +} + +///| +fn slingshot_adv_endpoint_mask( + cluster_names : Array[String], + config : SlingshotAdvancedConfig, +) -> Array[Bool] raise SlingshotAdvancedError { + let output = Array::make(cluster_names.length(), false) + for name in config.start_clusters { + if slingshot_adv_label_index(cluster_names, name) < 0 { + slingshot_adv_fail("slingshot start cluster '" + name + "' was not found") + } + } + for name in config.end_clusters { + let index = slingshot_adv_label_index(cluster_names, name) + if index < 0 { + slingshot_adv_fail("slingshot end cluster '" + name + "' was not found") + } + output[index] = true + } + output +} + +///| +fn slingshot_adv_kruskal( + distances : Array[Array[Double]], + endpoints : Array[Bool], + threshold : Double, +) -> Array[SlingshotLineageEdge] { + let size = distances.length() + let parent = Array::make(size, 0) + let ranks = Array::make(size, 0) + let degrees = Array::make(size, 0) + for index in 0..= 0.0 && edge.distance > threshold { + continue + } + if slingshot_adv_find(parent, edge.from) == + slingshot_adv_find(parent, edge.to) { + continue + } + if (endpoints[edge.from] && degrees[edge.from] >= 1) || + (endpoints[edge.to] && degrees[edge.to] >= 1) { + continue + } + output.push(edge) + degrees[edge.from] = degrees[edge.from] + 1 + degrees[edge.to] = degrees[edge.to] + 1 + slingshot_adv_union(parent, ranks, edge.from, edge.to) + } + output +} + +///| +fn slingshot_adv_median(values : Array[Double]) -> Double { + if values.length() == 0 { + return 0.0 + } + let sorted = values.copy() + sorted.sort_by(fn(left : Double, right : Double) -> Int { + if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + let middle = sorted.length() / 2 + if sorted.length() % 2 == 0 { + 0.5 * (sorted[middle - 1] + sorted[middle]) + } else { + sorted[middle] + } +} + +///| +fn slingshot_adv_resolve_omega( + distances : Array[Array[Double]], + endpoints : Array[Bool], + config : SlingshotAdvancedConfig, +) -> Double { + if config.automatic_omega { + let unrestricted = slingshot_adv_kruskal(distances, endpoints, -1.0) + let lengths = unrestricted.map(fn(edge) { edge.distance }) + return slingshot_adv_median(lengths) * config.omega_scale + } + config.omega +} + +///| +fn slingshot_adv_components( + nodes : Int, + edges : Array[SlingshotLineageEdge], +) -> Array[Int] { + let parent = Array::make(nodes, 0) + let ranks = Array::make(nodes, 0) + for node in 0.. output[node] = component + None => { + root_to_component[root] = next + output[node] = next + next = next + 1 + } + } + } + output +} + +///| +fn slingshot_adv_adjacency( + nodes : Int, + edges : Array[SlingshotLineageEdge], +) -> Array[Array[Int]] { + let output : Array[Array[Int]] = [] + for _ in 0.. Array[Int] { + let previous = Array::make(adjacency.length(), -1) + let visited = Array::make(adjacency.length(), false) + let queue : Array[Int] = [start] + visited[start] = true + let mut head = 0 + while head < queue.length() { + let current = queue[head] + head = head + 1 + if current == end { + break + } + for neighbor in adjacency[current] { + if !visited[neighbor] { + visited[neighbor] = true + previous[neighbor] = current + queue.push(neighbor) + } + } + } + if !visited[end] { + return [] + } + let reverse : Array[Int] = [] + let mut current = end + while current >= 0 { + reverse.push(current) + if current == start { + break + } + current = previous[current] + } + let output : Array[Int] = [] + let mut index = reverse.length() - 1 + while index >= 0 { + output.push(reverse[index]) + index = index - 1 + } + output +} + +///| +fn slingshot_adv_choose_root( + nodes : Array[Int], + adjacency : Array[Array[Int]], + cluster_names : Array[String], + starts : Array[String], +) -> Int { + for name in starts { + let index = slingshot_adv_label_index(cluster_names, name) + if nodes.contains(index) { + return index + } + } + if nodes.length() == 1 { + return nodes[0] + } + let leaves = nodes.filter(fn(node) { adjacency[node].length() <= 1 }) + let candidates = if leaves.length() > 0 { leaves } else { nodes } + let mut best = candidates[0] + let mut best_mean = -1.0 + for candidate in candidates { + let mut total = 0.0 + let mut comparisons = 0 + for leaf in leaves { + if leaf != candidate { + total = total + + slingshot_adv_path(adjacency, candidate, leaf).length().to_double() + comparisons = comparisons + 1 + } + } + let mean = if comparisons > 0 { + total / comparisons.to_double() + } else { + 0.0 + } + if mean > best_mean || (mean == best_mean && candidate < best) { + best = candidate + best_mean = mean + } + } + best +} + +///| +fn slingshot_adv_lineages( + cluster_names : Array[String], + edges : Array[SlingshotLineageEdge], + components : Array[Int], + config : SlingshotAdvancedConfig, +) -> (Array[Int], Array[Array[Int]]) { + let adjacency = slingshot_adv_adjacency(cluster_names.length(), edges) + let mut component_count = 0 + for component in components { + component_count = component_count.max(component + 1) + } + let roots : Array[Int] = [] + let lineages : Array[Array[Int]] = [] + for component in 0.. 0 { + lineages.push(path) + } + } + } + } + lineages.sort_by(fn(left : Array[Int], right : Array[Int]) -> Int { + if left.length() > right.length() { + -1 + } else if left.length() < right.length() { + 1 + } else { + for index in 0.. right[index] { + return 1 + } + } + 0 + } + }) + (roots, lineages) +} + +///| +fn slingshot_adv_initial_weights( + cluster_weights : Array[Array[Double]], + lineages : Array[Array[Int]], +) -> Array[Array[Double]] { + let output = slingshot_adv_double_matrix( + cluster_weights.length(), + lineages.length(), + 0.0, + ) + for cell in 0.. SlingshotLineageModel raise SlingshotAdvancedError { + let (cells, _) = slingshot_adv_shape(coordinates, "slingshot coordinates") + slingshot_adv_validate_cluster_names(cluster_names) + let normalized = slingshot_adv_normalize_weights( + cluster_weights, cluster_names, cells, + ) + let clusters = slingshot_adv_cluster_summaries( + coordinates, normalized, cluster_names, config, + ) + let distances = slingshot_adv_distance_matrix(clusters, config) + let endpoints = slingshot_adv_endpoint_mask(cluster_names, config) + let omega_threshold = slingshot_adv_resolve_omega( + distances, endpoints, config, + ) + let edges = slingshot_adv_kruskal(distances, endpoints, omega_threshold) + let components = slingshot_adv_components(cluster_names.length(), edges) + let (roots, lineages) = slingshot_adv_lineages( + cluster_names, edges, components, config, + ) + let initial_weights = slingshot_adv_initial_weights(normalized, lineages) + SlingshotLineageModel::{ + coordinates: slingshot_adv_copy_matrix(coordinates), + cluster_names: cluster_names.copy(), + cluster_weights: normalized, + clusters, + distance_matrix: distances, + edges, + components, + roots, + lineages, + initial_weights, + omega_threshold, + } +} + +///| +pub fn slingshot_infer_lineages( + coordinates : Array[Array[Double]], + cluster_labels : Array[String], + config : SlingshotAdvancedConfig, +) -> SlingshotLineageModel raise SlingshotAdvancedError { + let (cells, _) = slingshot_adv_shape(coordinates, "slingshot coordinates") + if cluster_labels.length() != cells { + slingshot_adv_fail("slingshot labels must have one value per cell") + } + let cluster_names = slingshot_adv_unique_labels(cluster_labels) + slingshot_adv_validate_cluster_names(cluster_names) + let weights = slingshot_adv_double_matrix(cells, cluster_names.length(), 0.0) + for cell in 0.. Double { + let mut total = 0.0 + for index in 1.. Array[Double] { + let output = Array::make(left.length(), 0.0) + for dimension in 0.. Array[Array[Double]] { + if count == 1 { + return [points[0].copy()] + } + if points.length() == 1 { + let output : Array[Array[Double]] = [] + for _ in 0.. 0.0 { + (target - cumulative[segment]) / width + } else { + 0.0 + } + output.push( + slingshot_adv_interpolate(points[segment], points[segment + 1], fraction), + ) + } + output +} + +///| +fn slingshot_adv_first_pc(covariance : Array[Array[Double]]) -> Array[Double] { + let dimensions = covariance.length() + let mut vector = Array::make(dimensions, 1.0) + let norm0 = dimensions.to_double().sqrt() + for dimension in 0.. Double { + let mut output = 0.0 + for index in 0.. Array[Array[Double]] { + let points : Array[Array[Double]] = [] + for cluster in lineage { + points.push(model.clusters[cluster].center.copy()) + } + if lineage.length() == 1 { + let cluster = model.clusters[lineage[0]] + let direction = slingshot_adv_first_pc(cluster.covariance) + let scale = cluster.covariance[0][0].max(config.covariance_ridge).sqrt() + let before = cluster.center.copy() + let after = cluster.center.copy() + for dimension in 0..= 0.0 { + 1.0 + } else { + -1.0 + } + let end_sign = if slingshot_adv_dot(end_pc, end_leg) >= 0.0 { + 1.0 + } else { + -1.0 + } + let start_scale = slingshot_adv_euclidean(first, second) + let end_scale = slingshot_adv_euclidean(last, penultimate) + for dimension in 0.. (Double, Double) { + if curve.length() == 1 { + return (0.0, slingshot_adv_euclidean(point, curve[0])) + } + let cumulative = Array::make(curve.length(), 0.0) + for index in 1.. 0.0 { + (numerator / length_squared).max(0.0).min(1.0) + } else { + 0.0 + } + let projected = slingshot_adv_interpolate(left, right, fraction) + let distance = slingshot_adv_euclidean(point, projected) + let segment_length = length_squared.sqrt() + let time = cumulative[segment] + fraction * segment_length + if distance < best_distance || + (distance == best_distance && time < best_time) { + best_distance = distance + best_time = time + } + } + (best_time, best_distance) +} + +///| +fn slingshot_adv_project_all( + coordinates : Array[Array[Double]], + curve : Array[Array[Double]], +) -> (Array[Double], Array[Double]) { + let pseudotime = Array::make(coordinates.length(), 0.0) + let distances = Array::make(coordinates.length(), 0.0) + for cell in 0.. Double { + let mut s0 = 0.0 + let mut s1 = 0.0 + let mut s2 = 0.0 + let mut t0 = 0.0 + let mut t1 = 0.0 + for index in 0.. 0.0 { + let centered = times[index] - target + let scaled = centered / bandwidth + let kernel = @math.exp(-0.5 * scaled * scaled) * weights[index] + s0 = s0 + kernel + s1 = s1 + kernel * centered + s2 = s2 + kernel * centered * centered + t0 = t0 + kernel * values[index] + t1 = t1 + kernel * centered * values[index] + } + } + let determinant = s0 * s2 - s1 * s1 + if determinant.abs() > 1.0e-12 { + (t0 * s2 - t1 * s1) / determinant + } else if s0 > 0.0 { + t0 / s0 + } else { + 0.0 + } +} + +///| +fn slingshot_adv_smooth_curve( + coordinates : Array[Array[Double]], + pseudotime : Array[Double], + weights : Array[Double], + points : Int, + span : Double, +) -> Array[Array[Double]] { + let dimensions = coordinates[0].length() + let mut minimum = 1.0e300 + let mut maximum = -1.0e300 + for cell in 0.. 0.0 { + minimum = minimum.min(pseudotime[cell]) + maximum = maximum.max(pseudotime[cell]) + } + } + if minimum > maximum { + minimum = 0.0 + maximum = 1.0 + } + let range = (maximum - minimum).max(1.0e-8) + let bandwidth = (range * span).max(1.0e-8) + let output : Array[Array[Double]] = [] + for index in 0.. Array[Array[Double]] { + let cells = distances.length() + let lineages = if cells > 0 { distances[0].length() } else { 0 } + let entries : Array[(Double, Int, Int, Double)] = [] + let mut total = 0.0 + for cell in 0.. 0.0 { + for lineage in 0.. 0.0 { + let probability = weights[cell][lineage] / row_total + entries.push((distances[cell][lineage], cell, lineage, probability)) + total = total + probability + } + } + } + } + entries.sort_by(fn( + left : (Double, Int, Int, Double), + right : (Double, Int, Int, Double), + ) -> Int { + if left.0 < right.0 { + -1 + } else if left.0 > right.0 { + 1 + } else if left.1 < right.1 { + -1 + } else if left.1 > right.1 { + 1 + } else if left.2 < right.2 { + -1 + } else if left.2 > right.2 { + 1 + } else { + 0 + } + }) + let output = slingshot_adv_double_matrix(cells, lineages, 1.0) + let mut cumulative = 0.0 + for entry in entries { + cumulative = cumulative + entry.3 + output[entry.1][entry.2] = if total > 0.0 { + cumulative / total + } else { + 1.0 + } + } + output +} + +///| +fn slingshot_adv_update_weights( + distances : Array[Array[Double]], + current : Array[Array[Double]], + reweight : Bool, + reassign : Bool, +) -> Array[Array[Double]] { + if !reweight && !reassign { + return slingshot_adv_copy_matrix(current) + } + let cells = distances.length() + let lineages = distances[0].length() + let ranks = slingshot_adv_distance_ranks(distances, current) + let output = slingshot_adv_copy_matrix(current) + if reweight { + for cell in 0.. 0.0 { + let candidate = 1.0 - ranks[cell][lineage] * ranks[cell][lineage] + output[cell][lineage] = candidate.max(0.0) + maximum = maximum.max(output[cell][lineage]) + } else { + output[cell][lineage] = 0.0 + } + } + if maximum > 0.0 { + for lineage in 0.. 0.9 && output[cell][lineage] < 0.1 { + output[cell][lineage] = 0.0 + } + } + let mut total = 0.0 + for lineage in 0.. Int { + let limit = left.length().min(right.length()) + let mut shared = 0 + while shared < limit && left[shared] == right[shared] { + shared = shared + 1 + } + shared +} + +///| +fn slingshot_adv_shrink_curves( + curves : Array[Array[Array[Double]]], + lineages : Array[Array[Int]], + shrink : Double, +) -> Array[Array[Array[Double]]] { + if shrink <= 0.0 || curves.length() <= 1 { + return curves.map(fn(curve) { slingshot_adv_copy_matrix(curve) }) + } + let output = curves.map(fn(curve) { slingshot_adv_copy_matrix(curve) }) + for lineage in 0.. 0 { + let left_denominator = (lineages[lineage].length() - 1).max(1) + let right_denominator = (lineages[other].length() - 1).max(1) + let threshold = ((shared - 1).to_double() / + left_denominator.to_double()).min( + (shared - 1).to_double() / right_denominator.to_double(), + ) + if fraction <= threshold.max(1.0e-12) { + partners.push(other) + thresholds.push(threshold.max(1.0e-12)) + } + } + } + } + if partners.length() > 1 { + let average = Array::make(curves[lineage][point].length(), 0.0) + for partner in partners { + let partner_point = (fraction * + (curves[partner].length() - 1).to_double()) + .round() + .to_int() + .max(0) + .min(curves[partner].length() - 1) + for dimension in 0.. Array[Array[Double]] { + let cells = curves[0].distances.length() + let output = slingshot_adv_double_matrix(cells, curves.length(), 0.0) + for lineage in 0.. Double { + let mut output = 0.0 + for cell in 0.. 0.0 { + output = output + distances[cell][lineage] + } + } + } + output +} + +///| +fn slingshot_adv_build_output( + model : SlingshotLineageModel, + curves : Array[SlingshotAdvancedCurve], + weights : Array[Array[Double]], + iterations : Int, + converged : Bool, + total_distance : Double, + config : SlingshotAdvancedConfig, +) -> SlingshotAdvancedResult { + let cells = model.coordinates.length() + let pseudotime = slingshot_adv_optional_matrix(cells, curves.length()) + let average = Array::make(cells, 0.0) + for cell in 0.. 0.0 { + pseudotime[cell][lineage] = Some(curves[lineage].pseudotime[cell]) + average[cell] = average[cell] + + weights[cell][lineage] * curves[lineage].pseudotime[cell] + weight_total = weight_total + weights[cell][lineage] + } + } + if weight_total > 0.0 { + average[cell] = average[cell] / weight_total + } + } + let branch_ids = slingshot_adv_branch_ids_from_weights(weights, -1.0) + SlingshotAdvancedResult::{ + lineage_model: model, + curves, + pseudotime, + weights, + average_pseudotime: average, + branch_ids, + iterations, + converged, + total_distance, + config, + } +} + +///| +pub fn slingshot_fit_simultaneous_curves( + model : SlingshotLineageModel, + config : SlingshotAdvancedConfig, +) -> SlingshotAdvancedResult raise SlingshotAdvancedError { + if model.lineages.length() == 0 { + slingshot_adv_fail("slingshot lineage model contains no lineages") + } + let raw_curves : Array[Array[Array[Double]]] = [] + for lineage in model.lineages { + raw_curves.push( + slingshot_adv_resample( + slingshot_adv_endpoint_extension(model, lineage, config), + config.curve_points, + ), + ) + } + let curves : Array[SlingshotAdvancedCurve] = [] + for lineage in 0.. SlingshotAdvancedResult raise SlingshotAdvancedError { + slingshot_fit_simultaneous_curves( + slingshot_infer_lineages(coordinates, cluster_labels, config), + config, + ) +} + +///| +pub fn slingshot_advanced_weighted( + coordinates : Array[Array[Double]], + cluster_weights : Array[Array[Double]], + cluster_names : Array[String], + config : SlingshotAdvancedConfig, +) -> SlingshotAdvancedResult raise SlingshotAdvancedError { + slingshot_fit_simultaneous_curves( + slingshot_infer_weighted_lineages( + coordinates, cluster_weights, cluster_names, config, + ), + config, + ) +} + +///| +fn slingshot_adv_branch_ids_from_weights( + weights : Array[Array[Double]], + threshold : Double, +) -> Array[String] { + let lineages = if weights.length() > 0 { weights[0].length() } else { 0 } + let cutoff = if threshold < 0.0 && lineages > 0 { + 1.0 / lineages.to_double() + } else { + threshold + } + let output : Array[String] = [] + for row in weights { + let mut label = "" + for lineage in 0..= cutoff { + if label.length() > 0 { + label = label + "," + } + label = label + (lineage + 1).to_string() + } + } + output.push(label) + } + output +} + +///| +pub fn slingshot_branch_ids( + result : SlingshotAdvancedResult, + threshold? : Double = -1.0, +) -> Array[String] raise SlingshotAdvancedError { + if !slingshot_adv_is_finite(threshold) || threshold > 1.0 || threshold < -1.0 { + slingshot_adv_fail("slingshot branch threshold must be in [0, 1]") + } + slingshot_adv_branch_ids_from_weights(result.weights, threshold) +} + +///| +pub fn slingshot_curve_weight_probabilities( + result : SlingshotAdvancedResult, +) -> Array[Array[Double]] { + let output = slingshot_adv_copy_matrix(result.weights) + for row in output { + let mut total = 0.0 + for value in row { + total = total + value + } + if total > 0.0 { + for lineage in 0.. Double { + if values.length() == 0 { + return 1.0 + } + let sorted = values.copy() + sorted.sort_by(fn(left : Double, right : Double) -> Int { + if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + let position = probability * (sorted.length() - 1).to_double() + let lower = position.floor().to_int() + let upper = position.ceil().to_int() + let fraction = position - lower.to_double() + sorted[lower] * (1.0 - fraction) + sorted[upper] * fraction +} + +///| +pub fn slingshot_predict( + result : SlingshotAdvancedResult, + new_coordinates : Array[Array[Double]], +) -> SlingshotProjection raise SlingshotAdvancedError { + let (cells, dimensions) = slingshot_adv_shape( + new_coordinates, "slingshot prediction coordinates", + ) + if dimensions != result.lineage_model.coordinates[0].length() { + slingshot_adv_fail( + "slingshot prediction dimensions must match the fitted model", + ) + } + let lineages = result.curves.length() + let times = slingshot_adv_double_matrix(cells, lineages, 0.0) + let distances = slingshot_adv_double_matrix(cells, lineages, 0.0) + let weights = slingshot_adv_double_matrix(cells, lineages, 0.0) + let thresholds = Array::make(lineages, 1.0) + for lineage in 0.. 0.0 { + active.push(result.curves[lineage].distances[cell]) + } + } + thresholds[lineage] = slingshot_adv_quantile(active, 0.9).max(1.0e-8) + for cell in 0.. 0.0 { + for lineage in 0.. 0.0 { + pseudotime[cell][lineage] = Some(times[cell][lineage]) + average[cell] = average[cell] + + weights[cell][lineage] * times[cell][lineage] + total = total + weights[cell][lineage] + } + } + if total > 0.0 { + average[cell] = average[cell] / total + } + } + SlingshotProjection::{ + pseudotime, + weights, + distances, + average_pseudotime: average, + branch_ids: slingshot_adv_branch_ids_from_weights(weights, -1.0), + } +} + +///| +fn slingshot_adv_copy_sce( + source : SingleCellExperiment, +) -> SingleCellExperiment { + let assays : Map[String, Array[Array[Double]]] = Map([]) + for key in source.assays.keys() { + assays[key] = slingshot_adv_copy_matrix(source.assays[key]) + } + let row_data : Map[String, Array[String]] = Map([]) + for key in source.row_data.keys() { + row_data[key] = source.row_data[key].copy() + } + let col_data : Map[String, Array[String]] = Map([]) + for key in source.col_data.keys() { + col_data[key] = source.col_data[key].copy() + } + let reduced_dims : Map[String, Array[Array[Double]]] = Map([]) + for key in source.reduced_dims.keys() { + reduced_dims[key] = slingshot_adv_copy_matrix(source.reduced_dims[key]) + } + let alternatives : Map[String, SingleCellExperiment] = Map([]) + for key in source.alternative_experiments.keys() { + alternatives[key] = slingshot_adv_copy_sce( + source.alternative_experiments[key], + ) + } + let metadata : Map[String, String] = Map([]) + for key in source.metadata.keys() { + metadata[key] = source.metadata[key] + } + SingleCellExperiment::{ + assays, + row_data, + col_data, + reduced_dims, + alternative_experiments: alternatives, + metadata, + row_names: source.row_names.copy(), + col_names: source.col_names.copy(), + } +} + +///| +pub fn slingshot_advanced_sce( + experiment : SingleCellExperiment, + config : SlingshotAdvancedConfig, + reduced_dim_name? : String = "PCA", + cluster_column? : String = "cluster", + output_prefix? : String = "slingshot", +) -> SlingshotAdvancedSceOutput raise SlingshotAdvancedError { + if reduced_dim_name.length() == 0 || + cluster_column.length() == 0 || + output_prefix.length() == 0 { + slingshot_adv_fail("slingshot SCE names must be non-empty") + } + let coordinates = match experiment.reduced_dims.get(reduced_dim_name) { + Some(value) => value + None => { + slingshot_adv_fail( + "slingshot reduced dimension '" + reduced_dim_name + "' was not found", + ) + [] + } + } + let labels = match experiment.col_data.get(cluster_column) { + Some(value) => value + None => { + slingshot_adv_fail( + "slingshot cluster column '" + cluster_column + "' was not found", + ) + [] + } + } + if coordinates.length() != experiment.col_names.length() || + labels.length() != experiment.col_names.length() { + slingshot_adv_fail( + "slingshot SCE coordinates and labels must match the cell count", + ) + } + let result = slingshot_advanced(coordinates, labels, config) + let output = slingshot_adv_copy_sce(experiment) + output.col_data[output_prefix + ".branch"] = result.branch_ids.copy() + output.col_data[output_prefix + ".pseudotime"] = result.average_pseudotime.map(fn( + value, + ) { + value.to_string() + }, + ) + let pseudotime_numeric = slingshot_adv_double_matrix( + result.pseudotime.length(), + result.curves.length(), + -1.0, + ) + for cell in 0.. pseudotime_numeric[cell][lineage] = value + None => () + } + } + } + output.reduced_dims[output_prefix + ".pseudotime"] = pseudotime_numeric + output.reduced_dims[output_prefix + ".weights"] = slingshot_adv_copy_matrix( + result.weights, + ) + output.metadata[output_prefix + ".reduced_dim"] = reduced_dim_name + output.metadata[output_prefix + ".cluster_column"] = cluster_column + output.metadata[output_prefix + ".lineages"] = result.curves + .length() + .to_string() + output.metadata[output_prefix + ".converged"] = result.converged.to_string() + SlingshotAdvancedSceOutput::{ experiment: output, result } +} + +///| +pub fn slingshot_advanced_summary(result : SlingshotAdvancedResult) -> String { + let mut occupied = 0 + for row in result.lineage_model.cluster_weights { + let mut total = 0.0 + for weight in row { + total = total + weight + } + if total > 0.0 { + occupied = occupied + 1 + } + } + "Slingshot 2.21.0 advanced result\n" + + "cells: " + + result.lineage_model.coordinates.length().to_string() + + "\nclustered cells: " + + occupied.to_string() + + "\nclusters: " + + result.lineage_model.cluster_names.length().to_string() + + "\nlineages: " + + result.curves.length().to_string() + + "\nforest components: " + + result.lineage_model.roots.length().to_string() + + "\niterations: " + + result.iterations.to_string() + + "\nconverged: " + + result.converged.to_string() +} diff --git a/src/spatialdecon.mbt b/src/spatialdecon.mbt new file mode 100644 index 00000000..872530db --- /dev/null +++ b/src/spatialdecon.mbt @@ -0,0 +1,2126 @@ +// SpatialDecon-inspired mixed-cell deconvolution for spatial expression data. + +///| +pub suberror SpatialDeconError { + SpatialDeconError(String) +} + +///| +pub struct SpatialDeconProfile { + gene_names : Array[String] + cell_types : Array[String] + values : Array[Array[Double]] +} derive(Debug) + +///| +pub struct SpatialDeconData { + gene_names : Array[String] + spot_ids : Array[String] + values : Array[Array[Double]] + background : Array[Array[Double]] + weights : Array[Array[Double]] +} derive(Debug) + +///| +pub struct SpatialDeconConfig { + residual_threshold : Double + lower_threshold : Double + signal_floor : Double + rescale_profile : Bool + profile_quantile : Double + profile_target : Double + refit_outliers : Bool + max_iterations : Int + line_search_steps : Int + tolerance : Double + ridge : Double +} derive(Debug) + +///| +pub struct SpatialDeconAbundance { + cell_type : String + spot_id : String + abundance : Double + proportion : Double + standard_error : Double + p_value : Double +} derive(Debug) + +///| +pub struct SpatialDeconResult { + gene_names : Array[String] + spot_ids : Array[String] + cell_types : Array[String] + beta : Array[Array[Double]] + standard_errors : Array[Array[Double]] + t_statistics : Array[Array[Double]] + p_values : Array[Array[Double]] + proportions : Array[Array[Double]] + cells_per_100 : Array[Array[Double]] + cell_counts : Array[Array[Double]] + fitted : Array[Array[Double]] + residuals : Array[Array[Double]] + outliers : Array[Array[Bool]] + covariances : Array[Array[Array[Double]]] + objectives : Array[Double] + rmse : Array[Double] + correlations : Array[Double] + iterations : Array[Int] + converged : Array[Bool] + config : SpatialDeconConfig +} derive(Debug) + +///| +pub struct SpatialDeconCellMerge { + name : String + members : Array[String] +} derive(Debug) + +///| +pub struct SpatialDeconReverseResult { + gene_names : Array[String] + spot_ids : Array[String] + cell_types : Array[String] + coefficients : Array[Array[Double]] + fitted : Array[Array[Double]] + residuals : Array[Array[Double]] + correlations : Array[Double] + residual_sds : Array[Double] + objectives : Array[Double] + iterations : Array[Int] + converged : Array[Bool] +} derive(Debug) + +///| +pub struct SpatialDeconSpatialExperimentOutput { + experiment : SpatialExperiment + result : SpatialDeconResult +} + +///| +priv struct SdAlignedData { + gene_names : Array[String] + values : Array[Array[Double]] + background : Array[Array[Double]] + weights : Array[Array[Double]] + profile : Array[Array[Double]] +} + +///| +priv struct SdDerivatives { + objective : Double + gradient : Array[Double] + hessian : Array[Array[Double]] + expected_hessian : Array[Array[Double]] + fitted : Array[Double] +} + +///| +priv struct SdSolve { + beta : Array[Double] + covariance : Array[Array[Double]] + fitted : Array[Double] + objective : Double + iterations : Int + converged : Bool +} + +///| +fn sd_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn sd_copy_matrix(matrix : Array[Array[Double]]) -> Array[Array[Double]] { + let copied : Array[Array[Double]] = [] + for row in matrix { + copied.push(row.copy()) + } + copied +} + +///| +fn sd_copy_bool_matrix(matrix : Array[Array[Bool]]) -> Array[Array[Bool]] { + let copied : Array[Array[Bool]] = [] + for row in matrix { + copied.push(row.copy()) + } + copied +} + +///| +fn sd_zero_matrix(rows : Int, columns : Int) -> Array[Array[Double]] { + let matrix : Array[Array[Double]] = [] + for _ in 0.. Array[Array[Bool]] { + let matrix : Array[Array[Bool]] = [] + for _ in 0.. Bool { + for value in values { + if value == target { + return true + } + } + false +} + +///| +fn sd_string_index(values : Array[String], target : String) -> Int { + for index in 0.. Unit raise SpatialDeconError { + if values.length() == 0 { + raise SpatialDeconError(label + " must not be empty") + } + for index in 0.. Unit raise SpatialDeconError { + if matrix.length() != rows { + raise SpatialDeconError(label + " row count does not match gene names") + } + for row in matrix { + if row.length() != columns { + raise SpatialDeconError(label + " must be a rectangular matrix") + } + for value in row { + if !sd_is_finite(value) { + raise SpatialDeconError(label + " must contain only finite values") + } + if value < 0.0 || (!allow_zero && value <= 0.0) { + raise SpatialDeconError( + label + " contains an invalid non-positive value", + ) + } + } + } +} + +///| +pub fn SpatialDeconProfile::create( + gene_names : Array[String], + cell_types : Array[String], + values : Array[Array[Double]], +) -> SpatialDeconProfile raise SpatialDeconError { + sd_validate_names(gene_names, "SpatialDecon profile gene names") + sd_validate_names(cell_types, "SpatialDecon profile cell types") + sd_validate_matrix( + values, + gene_names.length(), + cell_types.length(), + "SpatialDecon profile", + true, + ) + for cell_type in 0.. SpatialDeconData raise SpatialDeconError { + sd_validate_names(gene_names, "SpatialDecon data gene names") + sd_validate_names(spot_ids, "SpatialDecon spot identifiers") + sd_validate_matrix( + values, + gene_names.length(), + spot_ids.length(), + "SpatialDecon expression", + true, + ) + let final_background = if background.length() == 0 { + sd_zero_matrix(gene_names.length(), spot_ids.length()) + } else { + sd_validate_matrix( + background, + gene_names.length(), + spot_ids.length(), + "SpatialDecon background", + true, + ) + sd_copy_matrix(background) + } + let final_weights = if weights.length() == 0 { + let output = sd_zero_matrix(gene_names.length(), spot_ids.length()) + for gene in 0.. SpatialDeconData raise SpatialDeconError { + if !sd_is_finite(background) || background < 0.0 { + raise SpatialDeconError( + "SpatialDecon scalar background must be finite and non-negative", + ) + } + let matrix = sd_zero_matrix(gene_names.length(), spot_ids.length()) + for gene in 0.. SpatialDeconConfig { + SpatialDeconConfig::{ + residual_threshold: 3.0, + lower_threshold: 0.5, + signal_floor: 1.0e-4, + rescale_profile: true, + profile_quantile: 0.99, + profile_target: 2.0, + refit_outliers: true, + max_iterations: 1000, + line_search_steps: 30, + tolerance: 1.0e-8, + ridge: 1.0e-8, + } +} + +///| +pub fn SpatialDeconConfig::create( + residual_threshold? : Double = 3.0, + lower_threshold? : Double = 0.5, + signal_floor? : Double = 1.0e-4, + rescale_profile? : Bool = true, + profile_quantile? : Double = 0.99, + profile_target? : Double = 2.0, + refit_outliers? : Bool = true, + max_iterations? : Int = 1000, + line_search_steps? : Int = 30, + tolerance? : Double = 1.0e-8, + ridge? : Double = 1.0e-8, +) -> SpatialDeconConfig raise SpatialDeconError { + if !sd_is_finite(residual_threshold) || residual_threshold <= 0.0 { + raise SpatialDeconError( + "SpatialDecon residual threshold must be finite and positive", + ) + } + if !sd_is_finite(lower_threshold) || lower_threshold <= 0.0 { + raise SpatialDeconError( + "SpatialDecon lower threshold must be finite and positive", + ) + } + if !sd_is_finite(signal_floor) || signal_floor <= 0.0 { + raise SpatialDeconError( + "SpatialDecon signal floor must be finite and positive", + ) + } + if !sd_is_finite(profile_quantile) || + profile_quantile <= 0.0 || + profile_quantile > 1.0 { + raise SpatialDeconError("SpatialDecon profile quantile must be in (0, 1]") + } + if !sd_is_finite(profile_target) || profile_target <= 0.0 { + raise SpatialDeconError( + "SpatialDecon profile target must be finite and positive", + ) + } + if max_iterations <= 0 { + raise SpatialDeconError("SpatialDecon maximum iterations must be positive") + } + if line_search_steps <= 0 { + raise SpatialDeconError("SpatialDecon line-search steps must be positive") + } + if !sd_is_finite(tolerance) || tolerance <= 0.0 || tolerance >= 1.0 { + raise SpatialDeconError("SpatialDecon tolerance must be in (0, 1)") + } + if !sd_is_finite(ridge) || ridge <= 0.0 { + raise SpatialDeconError("SpatialDecon ridge must be finite and positive") + } + SpatialDeconConfig::{ + residual_threshold, + lower_threshold, + signal_floor, + rescale_profile, + profile_quantile, + profile_target, + refit_outliers, + max_iterations, + line_search_steps, + tolerance, + ridge, + } +} + +///| +pub fn SpatialDeconCellMerge::create( + name : String, + members : Array[String], +) -> SpatialDeconCellMerge raise SpatialDeconError { + if name.length() == 0 { + raise SpatialDeconError( + "SpatialDecon merged cell type name must not be empty", + ) + } + sd_validate_names(members, "SpatialDecon merge members") + SpatialDeconCellMerge::{ name, members: members.copy() } +} + +///| +pub fn SpatialDeconProfile::n_genes(self : SpatialDeconProfile) -> Int { + self.gene_names.length() +} + +///| +pub fn SpatialDeconProfile::n_cell_types(self : SpatialDeconProfile) -> Int { + self.cell_types.length() +} + +///| +pub fn SpatialDeconData::n_genes(self : SpatialDeconData) -> Int { + self.gene_names.length() +} + +///| +pub fn SpatialDeconData::n_spots(self : SpatialDeconData) -> Int { + self.spot_ids.length() +} + +///| +fn sd_quantile(values : Array[Double], probability : Double) -> Double { + if values.length() == 0 { + return 0.0 + } + let sorted = values.copy() + for index in 1.. 0 && sorted[position - 1] > value { + sorted[position] = sorted[position - 1] + position = position - 1 + } + sorted[position] = value + } + if sorted.length() == 1 { + return sorted[0] + } + let location = (sorted.length() - 1).to_double() * probability + let lower = location.to_int() + let fraction = location - lower.to_double() + if lower + 1 >= sorted.length() { + sorted[sorted.length() - 1] + } else { + sorted[lower] * (1.0 - fraction) + sorted[lower + 1] * fraction + } +} + +///| +fn sd_profile_scale( + profile : Array[Array[Double]], + config : SpatialDeconConfig, +) -> Array[Array[Double]] raise SpatialDeconError { + let output = sd_copy_matrix(profile) + if !config.rescale_profile { + return output + } + let flattened : Array[Double] = [] + for row in profile { + for value in row { + flattened.push(value) + } + } + let reference = sd_quantile(flattened, config.profile_quantile) + if reference <= 0.0 { + raise SpatialDeconError( + "SpatialDecon profile quantile is zero and cannot be rescaled", + ) + } + let factor = config.profile_target / reference + for gene in 0.. SdAlignedData raise SpatialDeconError { + let genes : Array[String] = [] + let values : Array[Array[Double]] = [] + let background : Array[Array[Double]] = [] + let weights : Array[Array[Double]] = [] + let profile_rows : Array[Array[Double]] = [] + for data_index in 0..= 0 { + genes.push(data.gene_names[data_index]) + values.push(data.values[data_index].copy()) + background.push(data.background[data_index].copy()) + weights.push(data.weights[data_index].copy()) + profile_rows.push(profile.values[profile_index].copy()) + } + } + if genes.length() == 0 { + raise SpatialDeconError( + "SpatialDecon data and profile have no shared gene names", + ) + } + if genes.length() < profile.cell_types.length() { + raise SpatialDeconError( + "SpatialDecon requires at least as many shared genes as cell types", + ) + } + SdAlignedData::{ + gene_names: genes, + values, + background, + weights, + profile: sd_profile_scale(profile_rows, config), + } +} + +///| +fn sd_dot(left : Array[Double], right : Array[Double]) -> Double { + let mut total = 0.0 + for index in 0.. SdDerivatives { + let cell_types = beta.length() + let gradient = Array::make(cell_types, 0.0) + let hessian = sd_zero_matrix(cell_types, cell_types) + let expected_hessian = sd_zero_matrix(cell_types, cell_types) + let fitted = Array::make(y.length(), 0.0) + let mut objective = 0.0 + for gene in 0.. Array[Double]? { + let size = values.length() + if size == 0 || matrix.length() != size { + return None + } + let a = sd_copy_matrix(matrix) + let b = values.copy() + for column in 0.. pivot_value { + pivot = row + pivot_value = a[row][column].abs() + } + } + if pivot_value <= 1.0e-14 || !sd_is_finite(pivot_value) { + return None + } + if pivot != column { + let temporary_row = a[column] + a[column] = a[pivot] + a[pivot] = temporary_row + let temporary_value = b[column] + b[column] = b[pivot] + b[pivot] = temporary_value + } + let diagonal = a[column][column] + for row in (column + 1)..= 0 { + let mut value = b[row] + for column in (row + 1).. Array[Array[Double]]? { + let size = matrix.length() + if size == 0 { + return None + } + let augmented : Array[Array[Double]] = [] + for row in 0.. pivot_value { + pivot = row + pivot_value = augmented[row][column].abs() + } + } + if pivot_value <= 1.0e-14 || !sd_is_finite(pivot_value) { + return None + } + if pivot != column { + let temporary = augmented[column] + augmented[column] = augmented[pivot] + augmented[pivot] = temporary + } + let diagonal = augmented[column][column] + for entry in 0..<(size * 2) { + augmented[column][entry] = augmented[column][entry] / diagonal + } + for row in 0.. Array[Array[Double]] { + let size = derivatives.gradient.length() + let observed = sd_copy_matrix(derivatives.hessian) + for index in 0.. { + let mut valid = true + for index in 0.. () + } + let expected = sd_copy_matrix(derivatives.expected_hessian) + for index in 0.. inverse + None => { + let fallback = sd_zero_matrix(size, size) + for index in 0.. ridge { + expected[index][index] + } else { + ridge + }) + } + fallback + } + } +} + +///| +fn sd_projected_gradient_norm( + beta : Array[Double], + gradient : Array[Double], + tolerance : Double, +) -> Double { + let mut maximum = 0.0 + for index in 0.. 0.0 { + 0.0 + } else { + gradient[index].abs() + } + if value > maximum { + maximum = value + } + } + maximum +} + +///| +fn sd_solve_one( + y : Array[Double], + background : Array[Double], + weights : Array[Double], + profile : Array[Array[Double]], + included : Array[Bool], + epsilon : Double, + config : SpatialDeconConfig, + initial : Array[Double], +) -> SdSolve { + let cell_types = if profile.length() == 0 { 0 } else { profile[0].length() } + let beta = if initial.length() == cell_types { + initial.copy() + } else { + let mut mean_signal = 0.0 + let mut mean_profile = 0.0 + let mut points = 0 + for gene in 0.. 0.0 { signal } else { 0.0 }) + for cell_type in 0.. 0 { + mean_profile / points.to_double() + } else { + 0.0 + } + let start = if denominator > 0.0 && points > 0 { + mean_signal / points.to_double() / (denominator * cell_types.to_double()) + } else { + epsilon + } + Array::make(cell_types, if start > 0.0 { start } else { epsilon }) + } + let mut iterations = 0 + let mut converged = false + let mut derivatives = sd_derivatives( + y, + background, + weights, + profile, + included, + beta, + epsilon, + config.signal_floor, + ) + while iterations < config.max_iterations && !converged { + if sd_projected_gradient_norm(beta, derivatives.gradient, config.tolerance) <= + config.tolerance { + converged = true + break + } + let system = sd_copy_matrix(derivatives.hessian) + for index in 0.. candidate + None => negative_gradient.copy() + } + let mut directional_derivative = sd_dot(derivatives.gradient, direction) + if !sd_is_finite(directional_derivative) || directional_derivative >= 0.0 { + let mut scale = config.ridge + for index in 0.. scale { + scale = derivatives.expected_hessian[index][index] + } + } + for index in 0.. 0.0 { proposed } else { 0.0 } + } + candidate_derivatives = sd_derivatives( + y, + background, + weights, + profile, + included, + candidate, + epsilon, + config.signal_floor, + ) + if candidate_derivatives.objective < + derivatives.objective - + config.tolerance * step * directional_derivative.abs() { + accepted = true + break + } + step = step * 0.5 + } + if !accepted { + break + } + let mut maximum_change = 0.0 + let mut maximum_value = 0.0 + for index in 0.. maximum_change { + maximum_change = change + } + beta[index] = candidate[index] + if beta[index].abs() > maximum_value { + maximum_value = beta[index].abs() + } + } + derivatives = candidate_derivatives + iterations = iterations + 1 + if maximum_change <= config.tolerance * (1.0 + maximum_value) { + converged = true + } + } + let final_derivatives = sd_derivatives( + y, + background, + weights, + profile, + included, + beta, + epsilon, + config.signal_floor, + ) + SdSolve::{ + beta, + covariance: sd_covariance(final_derivatives, config.ridge), + fitted: final_derivatives.fitted, + objective: final_derivatives.objective, + iterations, + converged, + } +} + +///| +fn sd_erf(value : Double) -> Double { + let sign = if value < 0.0 { -1.0 } else { 1.0 } + let x = value.abs() + let t = 1.0 / (1.0 + 0.3275911 * x) + let polynomial = ( + (((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * + t + + 0.254829592 + ) * + t + sign * (1.0 - polynomial * @math.exp(-x * x)) +} + +///| +fn sd_normal_cdf(value : Double) -> Double { + 0.5 * (1.0 + sd_erf(value / 1.4142135623730951)) +} + +///| +fn sd_mean(values : Array[Double]) -> Double { + if values.length() == 0 { + return 0.0 + } + let mut total = 0.0 + for value in values { + total = total + value + } + total / values.length().to_double() +} + +///| +fn sd_correlation(left : Array[Double], right : Array[Double]) -> Double { + if left.length() == 0 || left.length() != right.length() { + return 0.0 + } + let left_mean = sd_mean(left) + let right_mean = sd_mean(right) + let mut covariance = 0.0 + let mut left_variance = 0.0 + let mut right_variance = 0.0 + for index in 0.. Double { + if values.length() <= 1 { + return 0.0 + } + let mean = sd_mean(values) + let mut total = 0.0 + for value in values { + let delta = value - mean + total = total + delta * delta + } + (total / (values.length() - 1).to_double()).sqrt() +} + +///| +fn sd_proportions(beta : Array[Array[Double]]) -> Array[Array[Double]] { + let cell_types = beta.length() + let spots = if cell_types == 0 { 0 } else { beta[0].length() } + let output = sd_zero_matrix(cell_types, spots) + for spot in 0.. 0.0 { + for cell_type in 0.. Array[Array[Double]] { + let cell_types = beta.length() + let spots = if cell_types == 0 { 0 } else { beta[0].length() } + let output = sd_zero_matrix(cell_types, spots) + let mut maximum_total = 0.0 + for spot in 0.. maximum_total { + maximum_total = total + } + } + if maximum_total > 0.0 { + for cell_type in 0.. Array[Array[Double]] { + if nuclei_counts.length() == 0 { + return [] + } + let cell_types = cells_per_100.length() + let spots = if cell_types == 0 { 0 } else { cells_per_100[0].length() } + let output = sd_zero_matrix(cell_types, spots) + for cell_type in 0.. SpatialDeconResult raise SpatialDeconError { + if nuclei_counts.length() != 0 && + nuclei_counts.length() != data.spot_ids.length() { + raise SpatialDeconError( + "SpatialDecon nuclei counts must match the number of spots", + ) + } + for count in nuclei_counts { + if !sd_is_finite(count) || count < 0.0 { + raise SpatialDeconError( + "SpatialDecon nuclei counts must be finite and non-negative", + ) + } + } + let aligned = sd_align_data(data, profile, config) + let genes = aligned.gene_names.length() + let spots = data.spot_ids.length() + let cell_types = profile.cell_types.length() + let mut epsilon = 1.0e300 + for gene in 0.. 0.0 && value < epsilon { + epsilon = value + } + } + } + if epsilon > 1.0e299 { + raise SpatialDeconError( + "SpatialDecon expression must contain at least one positive value", + ) + } + let outliers = sd_bool_matrix(genes, spots) + let initial_solutions : Array[SdSolve] = [] + for spot in 0.. config.lower_threshold { + y[gene] + } else { + config.lower_threshold + } + let fitted = if solution.fitted[gene] > config.lower_threshold { + solution.fitted[gene] + } else { + config.lower_threshold + } + let residual = @math.ln(observed) / @math.ln(2.0) - + @math.ln(fitted) / @math.ln(2.0) + outliers[gene][spot] = residual.abs() > config.residual_threshold + if !outliers[gene][spot] { + retained = retained + 1 + } + } + if retained <= cell_types { + for gene in 0.. 0.0 { + solution.beta[cell_type] + } else { + 0.0 + } + let variance = solution.covariance[cell_type][cell_type] + let se = if variance > 0.0 { variance.sqrt() } else { 0.0 } + standard_errors[cell_type][spot] = se + let statistic = if se > 1.0e-14 { + beta[cell_type][spot] / se + } else { + 0.0 + } + t_statistics[cell_type][spot] = statistic + let probability = if statistic <= 0.0 { + 1.0 + } else { + 2.0 * (1.0 - sd_normal_cdf(statistic)) + } + p_values[cell_type][spot] = if probability < 0.0 { + 0.0 + } else if probability > 1.0 { + 1.0 + } else { + probability + } + } + let observed_for_correlation = Array::make(genes, 0.0) + let fitted_for_correlation = Array::make(genes, 0.0) + let mut squared_error = 0.0 + let mut retained = 0 + for gene in 0.. config.lower_threshold { + y[gene] + } else { + config.lower_threshold + } + let expected = if solution.fitted[gene] > config.lower_threshold { + solution.fitted[gene] + } else { + config.lower_threshold + } + let residual = @math.ln(observed) / @math.ln(2.0) - + @math.ln(expected) / @math.ln(2.0) + residuals[gene][spot] = residual + squared_error = squared_error + residual * residual + retained = retained + 1 + } + } + rmse[spot] = if retained > 0 { + (squared_error / retained.to_double()).sqrt() + } else { + 0.0 + } + correlations[spot] = sd_correlation( + observed_for_correlation, fitted_for_correlation, + ) + } + let proportions = sd_proportions(beta) + let cells_per_100 = sd_cells_per_100(beta) + SpatialDeconResult::{ + gene_names: aligned.gene_names.copy(), + spot_ids: data.spot_ids.copy(), + cell_types: profile.cell_types.copy(), + beta, + standard_errors, + t_statistics, + p_values, + proportions, + cells_per_100, + cell_counts: sd_scaled_cell_counts(cells_per_100, nuclei_counts), + fitted, + residuals, + outliers, + covariances, + objectives, + rmse, + correlations, + iterations, + converged, + config, + } +} + +///| +pub fn SpatialDeconResult::n_genes(self : SpatialDeconResult) -> Int { + self.gene_names.length() +} + +///| +pub fn SpatialDeconResult::n_spots(self : SpatialDeconResult) -> Int { + self.spot_ids.length() +} + +///| +pub fn SpatialDeconResult::n_cell_types(self : SpatialDeconResult) -> Int { + self.cell_types.length() +} + +///| +pub fn SpatialDeconResult::abundance_for( + self : SpatialDeconResult, + cell_type : String, + spot_id : String, +) -> Double? { + let cell_index = sd_string_index(self.cell_types, cell_type) + let spot_index = sd_string_index(self.spot_ids, spot_id) + if cell_index < 0 || spot_index < 0 { + None + } else { + Some(self.beta[cell_index][spot_index]) + } +} + +///| +pub fn SpatialDeconResult::top_cell_types( + self : SpatialDeconResult, + spot_id : String, + limit? : Int = 5, +) -> Array[SpatialDeconAbundance] raise SpatialDeconError { + if limit <= 0 { + raise SpatialDeconError("SpatialDecon ranking limit must be positive") + } + let spot = sd_string_index(self.spot_ids, spot_id) + if spot < 0 { + raise SpatialDeconError("SpatialDecon spot not found: " + spot_id) + } + let values : Array[SpatialDeconAbundance] = [] + for cell_type in 0.. 0 && + ( + values[position - 1].abundance < value.abundance || + ( + values[position - 1].abundance == value.abundance && + values[position - 1].cell_type > value.cell_type + ) + ) { + values[position] = values[position - 1] + position = position - 1 + } + values[position] = value + } + let count = if limit < values.length() { limit } else { values.length() } + let top = [] + for index in 0.. String { + let mut converged_count = 0 + let mut outlier_count = 0 + for value in self.converged { + if value { + converged_count = converged_count + 1 + } + } + for row in self.outliers { + for value in row { + if value { + outlier_count = outlier_count + 1 + } + } + } + "SpatialDeconResult(genes=" + + self.n_genes().to_string() + + ", spots=" + + self.n_spots().to_string() + + ", cell_types=" + + self.n_cell_types().to_string() + + ", converged=" + + converged_count.to_string() + + "/" + + self.n_spots().to_string() + + ", outliers=" + + outlier_count.to_string() + + ")" +} + +///| +pub fn collapse_spatial_decon( + result : SpatialDeconResult, + merges : Array[SpatialDeconCellMerge], +) -> SpatialDeconResult raise SpatialDeconError { + if merges.length() == 0 { + raise SpatialDeconError("SpatialDecon cell-type merges must not be empty") + } + let merged_names : Array[String] = [] + let used_members : Array[String] = [] + for merge in merges { + if sd_contains_string(merged_names, merge.name) { + raise SpatialDeconError( + "SpatialDecon duplicate merged cell type: " + merge.name, + ) + } + merged_names.push(merge.name) + for source_type in merge.members { + if !sd_contains_string(result.cell_types, source_type) { + raise SpatialDeconError( + "SpatialDecon merge member not found: " + source_type, + ) + } + if sd_contains_string(used_members, source_type) { + raise SpatialDeconError( + "SpatialDecon merge member appears more than once: " + source_type, + ) + } + used_members.push(source_type) + } + } + let groups = merges.length() + let spots = result.spot_ids.length() + let beta = sd_zero_matrix(groups, spots) + let covariances : Array[Array[Array[Double]]] = [] + for spot in 0.. 0.0 { variance.sqrt() } else { 0.0 } + standard_errors[group][spot] = se + let statistic = if se > 1.0e-14 { beta[group][spot] / se } else { 0.0 } + t_statistics[group][spot] = statistic + p_values[group][spot] = if statistic <= 0.0 { + 1.0 + } else { + let probability = 2.0 * (1.0 - sd_normal_cdf(statistic)) + if probability < 0.0 { + 0.0 + } else { + probability + } + } + } + } + let proportions = sd_proportions(beta) + let cells_per_100 = sd_cells_per_100(beta) + let cell_counts = if result.cell_counts.length() == 0 { + [] + } else { + let output = sd_zero_matrix(groups, spots) + for group in 0.. Array[Array[Double]] raise SpatialDeconError { + sd_validate_names(gene_names, "SpatialDecon background gene names") + sd_validate_names(spot_ids, "SpatialDecon background spot identifiers") + sd_validate_names(negative_genes, "SpatialDecon negative-probe names") + sd_validate_matrix( + values, + gene_names.length(), + spot_ids.length(), + "SpatialDecon background expression", + true, + ) + if probe_pools.length() != gene_names.length() { + raise SpatialDeconError( + "SpatialDecon probe pools must match the number of genes", + ) + } + for pool in probe_pools { + if pool.length() == 0 { + raise SpatialDeconError("SpatialDecon probe pool names must not be empty") + } + } + let pools : Array[String] = [] + for pool in probe_pools { + if !sd_contains_string(pools, pool) { + pools.push(pool) + } + } + let output = sd_zero_matrix(gene_names.length(), spot_ids.length()) + for pool in pools { + let negatives : Array[Int] = [] + for gene in 0.. SpatialDeconProfile raise SpatialDeconError { + sd_validate_names(gene_names, "SpatialDecon single-cell gene names") + sd_validate_names(cell_ids, "SpatialDecon single-cell identifiers") + if cell_types.length() != cell_ids.length() { + raise SpatialDeconError( + "SpatialDecon cell types must match single-cell identifiers", + ) + } + for cell_type in cell_types { + if cell_type.length() == 0 { + raise SpatialDeconError( + "SpatialDecon single-cell types must not be empty", + ) + } + } + sd_validate_matrix( + counts, + gene_names.length(), + cell_ids.length(), + "SpatialDecon single-cell counts", + true, + ) + if !sd_is_finite(scaling_factor) || scaling_factor <= 0.0 { + raise SpatialDeconError( + "SpatialDecon profile scaling factor must be finite and positive", + ) + } + if min_cells < 0 || min_genes < 0 { + raise SpatialDeconError( + "SpatialDecon profile filtering thresholds must be non-negative", + ) + } + if gene_filter.length() > 0 { + sd_validate_names(gene_filter, "SpatialDecon profile gene filter") + } + let libraries = Array::make(cell_ids.length(), 0.0) + let expressed = Array::make(cell_ids.length(), 0) + for cell in 0.. 0.0 { + expressed[cell] = expressed[cell] + 1 + } + } + } + let positive_libraries : Array[Double] = [] + for library in libraries { + if library > 0.0 { + positive_libraries.push(library) + } + } + if positive_libraries.length() == 0 { + raise SpatialDeconError( + "SpatialDecon single-cell counts contain no positive library", + ) + } + let median_library = sd_quantile(positive_libraries, 0.5) + let ordered_types : Array[String] = [] + for cell_type in cell_types { + if !sd_contains_string(ordered_types, cell_type) { + ordered_types.push(cell_type) + } + } + let retained_types : Array[String] = [] + let retained_cells : Array[Array[Int]] = [] + for cell_type in ordered_types { + let indices : Array[Int] = [] + for cell in 0.. min_genes && + libraries[cell] > 0.0 { + indices.push(cell) + } + } + if indices.length() > min_cells { + retained_types.push(cell_type) + retained_cells.push(indices) + } + } + if retained_types.length() == 0 { + raise SpatialDeconError( + "SpatialDecon profile filtering removed every cell type", + ) + } + let selected_genes : Array[Int] = [] + for gene in 0.. 0.0 { + positive = true + } + } + } + if positive { + selected_genes.push(gene) + } + } + } + if selected_genes.length() == 0 { + raise SpatialDeconError( + "SpatialDecon profile gene filtering removed every gene", + ) + } + let output_genes : Array[String] = [] + let values : Array[Array[Double]] = [] + for gene in selected_genes { + output_genes.push(gene_names[gene]) + let row = Array::make(retained_types.length(), 0.0) + for cell_type in 0.. SpatialDeconReverseResult raise SpatialDeconError { + if data.spot_ids != result.spot_ids { + raise SpatialDeconError( + "SpatialDecon reverse analysis requires matching spot identifiers", + ) + } + if epsilon < 0.0 || !sd_is_finite(epsilon) { + raise SpatialDeconError( + "SpatialDecon reverse epsilon must be finite and non-negative", + ) + } + let active_types : Array[String] = [] + let active_indices : Array[Int] = [] + for cell_type in 0.. 1.0e-14 { + active_types.push(result.cell_types[cell_type]) + active_indices.push(cell_type) + } + } + if active_types.length() == 0 { + raise SpatialDeconError( + "SpatialDecon reverse analysis requires a varying cell score", + ) + } + let positive : Array[Double] = [] + for row in data.values { + for value in row { + if value > 0.0 { + positive.push(value) + } + } + } + if positive.length() == 0 { + raise SpatialDeconError( + "SpatialDecon reverse expression must contain positive values", + ) + } + let effective_epsilon = if epsilon > 0.0 { + epsilon + } else { + sd_quantile(positive, 0.01) + } + let spots = data.spot_ids.length() + let design : Array[Array[Double]] = [] + for spot in 0.. effective_epsilon { + data.values[gene][spot] + } else { + effective_epsilon + } + let expected = if fitted[gene][spot] > effective_epsilon { + fitted[gene][spot] + } else { + effective_epsilon + } + gene_residuals[spot] = @math.ln(observed) / @math.ln(2.0) - + @math.ln(expected) / @math.ln(2.0) + residuals[gene][spot] = gene_residuals[spot] + } + correlations[gene] = sd_correlation(data.values[gene], fitted[gene]) + residual_sds[gene] = sd_sample_sd(gene_residuals) + } + SpatialDeconReverseResult::{ + gene_names: data.gene_names.copy(), + spot_ids: data.spot_ids.copy(), + cell_types: active_types, + coefficients, + fitted, + residuals, + correlations, + residual_sds, + objectives, + iterations, + converged, + } +} + +///| +fn sd_copy_string_map(source : Map[String, String]) -> Map[String, String] { + let output : Map[String, String] = Map([], capacity=source.length()) + for key in source.keys() { + output[key] = source[key] + } + output +} + +///| +fn sd_copy_spatial_experiment( + experiment : SpatialExperiment, +) -> SpatialExperiment { + let output = SpatialExperiment::new() + for key in experiment.assay.keys() { + output.assay[key] = sd_copy_matrix(experiment.assay[key]) + } + for row in experiment.row_data { + output.row_data.push(sd_copy_string_map(row)) + } + for column in experiment.col_data { + output.col_data.push(sd_copy_string_map(column)) + } + for coordinate in experiment.spatial_coords { + output.spatial_coords.push(coordinate) + } + for image in experiment.images { + output.images.push( + SpatialImage::new( + image.id, + sd_copy_matrix(image.data), + image.scale_factor, + ), + ) + } + for key in experiment.metadata.keys() { + output.metadata[key] = experiment.metadata[key] + } + output +} + +///| +fn sd_experiment_gene_names( + experiment : SpatialExperiment, + rows : Int, + key : String, +) -> Array[String] raise SpatialDeconError { + if experiment.row_data.length() != 0 && experiment.row_data.length() != rows { + raise SpatialDeconError( + "SpatialDecon SpatialExperiment row data must match assay rows", + ) + } + let names : Array[String] = [] + for row in 0.. + if value.length() == 0 { + raise SpatialDeconError( + "SpatialDecon SpatialExperiment gene identifier is empty", + ) + } else { + names.push(value) + } + None => + raise SpatialDeconError( + "SpatialDecon SpatialExperiment gene field not found: " + key, + ) + } + } + } + names +} + +///| +fn sd_experiment_spot_ids( + experiment : SpatialExperiment, + columns : Int, + key : String, +) -> Array[String] raise SpatialDeconError { + if experiment.col_data.length() != 0 && + experiment.col_data.length() != columns { + raise SpatialDeconError( + "SpatialDecon SpatialExperiment column data must match assay columns", + ) + } + let names : Array[String] = [] + for column in 0.. + if value.length() == 0 { + raise SpatialDeconError( + "SpatialDecon SpatialExperiment spot identifier is empty", + ) + } else { + names.push(value) + } + None => + raise SpatialDeconError( + "SpatialDecon SpatialExperiment spot field not found: " + key, + ) + } + } + } + names +} + +///| +pub fn spatial_decon_spatial_experiment( + experiment : SpatialExperiment, + profile : SpatialDeconProfile, + assay_name? : String = "counts", + background_assay_name? : String = "", + weight_assay_name? : String = "", + gene_id_key? : String = "gene_id", + spot_id_key? : String = "spot_id", + abundance_prefix? : String = "SpatialDecon:", + proportion_prefix? : String = "SpatialDeconProp:", + scalar_background? : Double = 0.0, + nuclei_counts? : Array[Double] = [], + config? : SpatialDeconConfig = SpatialDeconConfig::default(), +) -> SpatialDeconSpatialExperimentOutput raise SpatialDeconError { + if assay_name.length() == 0 || + abundance_prefix.length() == 0 || + proportion_prefix.length() == 0 { + raise SpatialDeconError( + "SpatialDecon SpatialExperiment names and prefixes must not be empty", + ) + } + if !sd_is_finite(scalar_background) || scalar_background < 0.0 { + raise SpatialDeconError( + "SpatialDecon SpatialExperiment background must be non-negative", + ) + } + let values = match experiment.assay.get(assay_name) { + Some(matrix) => matrix + None => + raise SpatialDeconError( + "SpatialDecon SpatialExperiment assay not found: " + assay_name, + ) + } + if values.length() == 0 || values[0].length() == 0 { + raise SpatialDeconError( + "SpatialDecon SpatialExperiment assay must not be empty", + ) + } + let rows = values.length() + let columns = values[0].length() + let gene_names = sd_experiment_gene_names(experiment, rows, gene_id_key) + let spot_ids = sd_experiment_spot_ids(experiment, columns, spot_id_key) + let background = if background_assay_name.length() == 0 { + let output = sd_zero_matrix(rows, columns) + for row in 0.. sd_copy_matrix(matrix) + None => + raise SpatialDeconError( + "SpatialDecon background assay not found: " + background_assay_name, + ) + } + } + let weights = if weight_assay_name.length() == 0 { + [] + } else { + match experiment.assay.get(weight_assay_name) { + Some(matrix) => sd_copy_matrix(matrix) + None => + raise SpatialDeconError( + "SpatialDecon weight assay not found: " + weight_assay_name, + ) + } + } + let data = SpatialDeconData::create( + gene_names, + spot_ids, + values, + background~, + weights~, + ) + let result = spatial_decon(data, profile, nuclei_counts~, config~) + let enriched = sd_copy_spatial_experiment(experiment) + if enriched.col_data.length() == 0 { + for _ in 0.. ( + SpatialDeconData, + SpatialDeconProfile, + Array[Double], +) raise SpatialDeconError { + let genes = ["T1", "T2", "T3", "B1", "B2", "B3", "M1", "M2", "M3"] + let spots = ["region_1", "region_2", "region_3", "region_4", "region_5"] + let cell_types = ["T_cell", "B_cell", "Myeloid"] + let profile_values = [ + [8.0, 0.5, 0.3], + [6.0, 0.6, 0.4], + [5.0, 0.4, 0.5], + [0.4, 8.0, 0.5], + [0.5, 6.0, 0.4], + [0.3, 5.0, 0.6], + [0.5, 0.4, 8.0], + [0.4, 0.6, 6.0], + [0.6, 0.5, 5.0], + ] + let true_beta = [ + [4.0, 1.0, 2.0, 0.5, 3.0], + [1.0, 4.0, 2.0, 1.0, 0.5], + [0.5, 1.0, 2.0, 4.0, 3.0], + ] + let background = sd_zero_matrix(genes.length(), spots.length()) + let values = sd_zero_matrix(genes.length(), spots.length()) + for gene in 0.. SpicyCell raise SpicyError { + if image_id == "" { + raise SpicyError("spicyR cell image ID must not be empty") + } + if cell_type == "" { + raise SpicyError("spicyR cell type must not be empty") + } + if !spicy_is_finite(x) || !spicy_is_finite(y) { + raise SpicyError("spicyR cell coordinates must be finite") + } + SpicyCell::{ image_id, cell_type, x, y } +} + +///| +pub struct SpicyImageMetadata { + image_id : String + condition : String + subject : String + covariates : Map[String, Double] +} derive(Debug) + +///| +pub fn SpicyImageMetadata::create( + image_id : String, + condition : String, + subject? : String = "", + covariates? : Map[String, Double] = Map([]), +) -> SpicyImageMetadata raise SpicyError { + if image_id == "" { + raise SpicyError("spicyR metadata image ID must not be empty") + } + if condition == "" { + raise SpicyError("spicyR condition must not be empty") + } + let copied : Map[String, Double] = Map([], capacity=covariates.length()) + for name in covariates.keys() { + if name == "" { + raise SpicyError("spicyR covariate names must not be empty") + } + let value = covariates[name] + if !spicy_is_finite(value) { + raise SpicyError("spicyR covariates must be finite") + } + copied[name] = value + } + SpicyImageMetadata::{ image_id, condition, subject, covariates: copied } +} + +///| +pub struct SpicyPair { + from_cell_type : String + to_cell_type : String +} derive(Eq, Debug) + +///| +pub fn SpicyPair::create( + from_cell_type : String, + to_cell_type : String, +) -> SpicyPair raise SpicyError { + if from_cell_type == "" || to_cell_type == "" { + raise SpicyError("spicyR pair cell types must not be empty") + } + SpicyPair::{ from_cell_type, to_cell_type } +} + +///| +pub fn SpicyPair::label(self : SpicyPair) -> String { + self.from_cell_type + "__" + self.to_cell_type +} + +///| +pub struct SpicyConfig { + radii : Array[Double] + edge_correction : Bool + include_zero_cells : Bool + use_weights : Bool + weight_factor : Double + window_padding : Double + fdr_threshold : Double + reference_condition : String + max_iterations : Int + tolerance : Double +} derive(Debug) + +///| +pub fn SpicyConfig::create( + radii? : Array[Double] = [20.0, 50.0, 100.0], + edge_correction? : Bool = true, + include_zero_cells? : Bool = false, + use_weights? : Bool = true, + weight_factor? : Double = 1.0, + window_padding? : Double = 0.0, + fdr_threshold? : Double = 0.05, + reference_condition? : String = "", + max_iterations? : Int = 100, + tolerance? : Double = 0.005, +) -> SpicyConfig raise SpicyError { + if radii.length() == 0 { + raise SpicyError("spicyR radii must not be empty") + } + let copied = radii.copy() + let mut previous = 0.0 + for index in 0.. 0 && radius <= previous { + raise SpicyError("spicyR radii must be strictly increasing") + } + previous = radius + } + if !spicy_is_finite(weight_factor) || weight_factor < 0.0 { + raise SpicyError("spicyR weight factor must be finite and non-negative") + } + if !spicy_is_finite(window_padding) || window_padding < 0.0 { + raise SpicyError("spicyR window padding must be finite and non-negative") + } + if !spicy_is_finite(fdr_threshold) || + fdr_threshold <= 0.0 || + fdr_threshold > 1.0 { + raise SpicyError("spicyR FDR threshold must be in (0, 1]") + } + if max_iterations <= 0 { + raise SpicyError("spicyR max_iterations must be positive") + } + if !spicy_is_finite(tolerance) || tolerance <= 0.0 || tolerance >= 1.0 { + raise SpicyError("spicyR tolerance must be in (0, 1)") + } + SpicyConfig::{ + radii: copied, + edge_correction, + include_zero_cells, + use_weights, + weight_factor, + window_padding, + fdr_threshold, + reference_condition, + max_iterations, + tolerance, + } +} + +///| +pub fn SpicyConfig::default() -> SpicyConfig { + SpicyConfig::{ + radii: [20.0, 50.0, 100.0], + edge_correction: true, + include_zero_cells: false, + use_weights: true, + weight_factor: 1.0, + window_padding: 0.0, + fdr_threshold: 0.05, + reference_condition: "", + max_iterations: 100, + tolerance: 0.005, + } +} + +///| +pub struct SpicyAssociation { + image_id : String + from_cell_type : String + to_cell_type : String + radii : Array[Double] + l_values : Array[Double] + statistic : Double + from_count : Int + to_count : Int + observed : Bool + available : Bool + weight : Double +} derive(Debug) + +///| +pub fn SpicyAssociation::create( + image_id : String, + from_cell_type : String, + to_cell_type : String, + statistic : Double, + from_count? : Int = 1, + to_count? : Int = 1, + observed? : Bool = true, + available? : Bool = true, +) -> SpicyAssociation raise SpicyError { + if image_id == "" { + raise SpicyError("spicyR association image ID must not be empty") + } + if from_cell_type == "" || to_cell_type == "" { + raise SpicyError("spicyR association cell types must not be empty") + } + if !spicy_is_finite(statistic) { + raise SpicyError("spicyR association statistic must be finite") + } + if from_count < 0 || to_count < 0 { + raise SpicyError("spicyR association cell counts must be non-negative") + } + SpicyAssociation::{ + image_id, + from_cell_type, + to_cell_type, + radii: [], + l_values: [], + statistic, + from_count, + to_count, + observed, + available, + weight: 1.0, + } +} + +///| +pub struct SpicyConditionResult { + condition_level : String + estimate : Double + standard_error : Double + statistic : Double + degrees_of_freedom : Double + p_value : Double + adjusted_p_value : Double + converged : Bool +} derive(Debug) + +///| +pub struct SpicyPairResult { + pair : SpicyPair + model : SpicyModelKind + intercept : Double + conditions : Array[SpicyConditionResult] + random_intercept_variance : Double + residual_variance : Double + associations : Array[SpicyAssociation] +} derive(Debug) + +///| +pub struct SpicyResult { + reference_condition : String + condition_levels : Array[String] + image_ids : Array[String] + pairs : Array[SpicyPairResult] + config : SpicyConfig +} derive(Debug) + +///| +pub struct SpicySpatialExperimentOutput { + experiment : SpatialExperiment + result : SpicyResult +} + +///| +priv struct SpicyWindow { + min_x : Double + max_x : Double + min_y : Double + max_y : Double + area : Double +} + +///| +fn spicy_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn spicy_find_string(values : Array[String], target : String) -> Int { + for index in 0.. Map[String, String] { + let output : Map[String, String] = Map([], capacity=source.length()) + for key in source.keys() { + output[key] = source[key] + } + output +} + +///| +fn spicy_copy_config(config : SpicyConfig) -> SpicyConfig { + SpicyConfig::{ + radii: config.radii.copy(), + edge_correction: config.edge_correction, + include_zero_cells: config.include_zero_cells, + use_weights: config.use_weights, + weight_factor: config.weight_factor, + window_padding: config.window_padding, + fdr_threshold: config.fdr_threshold, + reference_condition: config.reference_condition, + max_iterations: config.max_iterations, + tolerance: config.tolerance, + } +} + +///| +fn spicy_copy_association( + value : SpicyAssociation, + weight : Double, +) -> SpicyAssociation { + SpicyAssociation::{ + image_id: value.image_id, + from_cell_type: value.from_cell_type, + to_cell_type: value.to_cell_type, + radii: value.radii.copy(), + l_values: value.l_values.copy(), + statistic: value.statistic, + from_count: value.from_count, + to_count: value.to_count, + observed: value.observed, + available: value.available, + weight, + } +} + +///| +fn spicy_image_cells( + cells : Array[SpicyCell], + image_id : String, +) -> Array[SpicyCell] { + let output : Array[SpicyCell] = [] + for cell in cells { + if cell.image_id == image_id { + output.push(cell) + } + } + output +} + +///| +fn spicy_window( + cells : Array[SpicyCell], + padding : Double, +) -> SpicyWindow raise SpicyError { + if cells.length() == 0 { + raise SpicyError("spicyR image must contain cells") + } + let mut min_x = cells[0].x + let mut max_x = cells[0].x + let mut min_y = cells[0].y + let mut max_y = cells[0].y + for index in 1.. Array[Double] { + let width = window.max_x - window.min_x + let height = window.max_y - window.min_y + let maximum = width.min(height) / 2.01 + let output : Array[Double] = [] + for radius in config.radii { + let effective = radius.min(maximum) + if effective > 0.0 { + if output.length() == 0 || + (output[output.length() - 1] - effective).abs() > 1.0e-12 { + output.push(effective) + } + } + } + output +} + +///| +fn spicy_circle_vertical_length( + relative_x : Double, + center_y : Double, + radius : Double, + window : SpicyWindow, +) -> Double { + let squared = radius * radius - relative_x * relative_x + if squared <= 0.0 { + return 0.0 + } + let half_height = squared.sqrt() + let lower = (center_y - half_height).max(window.min_y) + let upper = (center_y + half_height).min(window.max_y) + (upper - lower).max(0.0) +} + +///| +fn spicy_circle_window_fraction( + x : Double, + y : Double, + radius : Double, + window : SpicyWindow, +) -> Double { + let left = (-radius).max(window.min_x - x) + let right = radius.min(window.max_x - x) + if right <= left { + return 1.0e-8 + } + // Simpson integration gives a deterministic rectangle/disc intersection. + let slices = 96 + let step = (right - left) / slices.to_double() + let mut total = 0.0 + for index in 0..<=slices { + let relative_x = left + index.to_double() * step + let height = spicy_circle_vertical_length(relative_x, y, radius, window) + let coefficient = if index == 0 || index == slices { + 1.0 + } else if index % 2 == 0 { + 2.0 + } else { + 4.0 + } + total = total + coefficient * height + } + let intersection = total * step / 3.0 + (intersection / (3.141592653589793 * radius * radius)).max(1.0e-8).min(1.0) +} + +///| +fn spicy_pair_indices( + cells : Array[SpicyCell], + cell_type : String, +) -> Array[Int] { + let output : Array[Int] = [] + for index in 0.. SpicyAssociation raise SpicyError { + let window = spicy_window(cells, config.window_padding) + let radii = spicy_effective_radii(config, window) + if radii.length() == 0 { + raise SpicyError("spicyR effective radii must not be empty") + } + let from_indices = spicy_pair_indices(cells, pair.from_cell_type) + let to_indices = spicy_pair_indices(cells, pair.to_cell_type) + let same_type = pair.from_cell_type == pair.to_cell_type + let present = from_indices.length() > 0 && to_indices.length() > 0 + let observed = present && (!same_type || from_indices.length() > 1) + let available = present || config.include_zero_cells + let l_values = Array::make(radii.length(), 0.0) + if observed { + let denominator = from_indices.length().to_double() * + to_indices.length().to_double() + for radius_index in 0.. Unit raise SpicyError { + if cells.length() == 0 { + raise SpicyError("spicyR cells must not be empty") + } + if metadata.length() < 3 { + raise SpicyError("spicyR requires at least three images") + } + let seen : Map[String, Bool] = Map([], capacity=metadata.length()) + for image in metadata { + if seen.contains(image.image_id) { + raise SpicyError("spicyR image metadata IDs must be unique") + } + seen[image.image_id] = true + let mut found = false + for cell in cells { + if cell.image_id == image.image_id { + found = true + break + } + } + if !found { + raise SpicyError("spicyR metadata image has no cells: " + image.image_id) + } + } + for cell in cells { + if !seen.contains(cell.image_id) { + raise SpicyError("spicyR cell references unknown image: " + cell.image_id) + } + } +} + +///| +fn spicy_cell_types(cells : Array[SpicyCell]) -> Array[String] { + let output : Array[String] = [] + for cell in cells { + if !output.contains(cell.cell_type) { + output.push(cell.cell_type) + } + } + output +} + +///| +fn spicy_resolve_pairs( + cells : Array[SpicyCell], + requested : Array[SpicyPair], +) -> Array[SpicyPair] raise SpicyError { + let cell_types = spicy_cell_types(cells) + let output : Array[SpicyPair] = [] + if requested.length() == 0 { + for to_type in cell_types { + for from_type in cell_types { + output.push(SpicyPair::{ + from_cell_type: from_type, + to_cell_type: to_type, + }) + } + } + return output + } + let labels : Array[String] = [] + for pair in requested { + if !cell_types.contains(pair.from_cell_type) || + !cell_types.contains(pair.to_cell_type) { + raise SpicyError("spicyR pair cell type is absent from the data") + } + let label = pair.label() + if labels.contains(label) { + raise SpicyError("spicyR pairs must not contain duplicates") + } + labels.push(label) + output.push(pair) + } + output +} + +///| +pub fn spicy_pairwise( + cells : Array[SpicyCell], + metadata : Array[SpicyImageMetadata], + pair : SpicyPair, + config? : SpicyConfig = SpicyConfig::default(), +) -> Array[SpicyAssociation] raise SpicyError { + spicy_validate_metadata(cells, metadata) + let types = spicy_cell_types(cells) + if !types.contains(pair.from_cell_type) || !types.contains(pair.to_cell_type) { + raise SpicyError("spicyR pair cell type is absent from the data") + } + let output : Array[SpicyAssociation] = [] + for image in metadata { + output.push( + spicy_pair_association_for_image( + image, + spicy_image_cells(cells, image.image_id), + pair, + config, + ), + ) + } + output +} + +///| +fn spicy_pair_key(association : SpicyAssociation) -> String { + association.from_cell_type + "__" + association.to_cell_type +} + +///| +fn spicy_effective_count(association : SpicyAssociation) -> Double { + let from_count = association.from_count.to_double() + let to_count = association.to_count.to_double() + if association.from_cell_type == association.to_cell_type { + (from_count * (from_count - 1.0)).max(1.0) + } else if from_count + to_count <= 0.0 { + 1.0 + } else { + (2.0 * from_count * to_count / (from_count + to_count)).max(1.0) + } +} + +///| +fn spicy_weight_associations( + associations : Array[SpicyAssociation], + config : SpicyConfig, +) -> Array[SpicyAssociation] { + if !config.use_weights { + let output : Array[SpicyAssociation] = [] + for value in associations { + output.push(spicy_copy_association(value, 1.0)) + } + return output + } + let raw = Array::make(associations.length(), 1.0) + let mut total = 0.0 + let mut count = 0 + for index in 0.. SpicyImageMetadata? { + for value in metadata { + if value.image_id == image_id { + return Some(value) + } + } + None +} + +///| +fn spicy_condition_levels( + metadata : Array[SpicyImageMetadata], +) -> Array[String] { + let output : Array[String] = [] + for image in metadata { + if !output.contains(image.condition) { + output.push(image.condition) + } + } + output +} + +///| +fn spicy_model_kind(metadata : Array[SpicyImageMetadata]) -> SpicyModelKind { + let subjects : Array[String] = [] + let mut all_present = true + for image in metadata { + if image.subject == "" { + all_present = false + } else if !subjects.contains(image.subject) { + subjects.push(image.subject) + } + } + if all_present && + subjects.length() >= 2 && + subjects.length() < metadata.length() { + WeightedRandomIntercept + } else { + WeightedLinear + } +} + +///| +fn spicy_build_design( + metadata : Array[SpicyImageMetadata], + covariate_names : Array[String], + reference : String, + model : SpicyModelKind, +) -> VariancePartitionDesign raise SpicyError { + let sample_names : Array[String] = [] + let conditions : Array[String] = [] + for image in metadata { + sample_names.push(image.image_id) + conditions.push(image.condition) + } + let fixed : Array[VariancePartitionFixedEffect] = [] + let condition_effect = vp_categorical_effect( + "condition", + conditions, + reference~, + ) catch { + VariancePartitionError(message) => + raise SpicyError("spicyR condition design failed: " + message) + } + fixed.push(condition_effect) + let seen_covariates : Array[String] = [] + for name in covariate_names { + if name == "" || seen_covariates.contains(name) { + raise SpicyError("spicyR covariate names must be non-empty and unique") + } + seen_covariates.push(name) + let values : Array[Double] = [] + for image in metadata { + match image.covariates.get(name) { + Some(value) => values.push(value) + None => + raise SpicyError( + "spicyR covariate '" + + name + + "' is missing for image " + + image.image_id, + ) + } + } + let effect = vp_numeric_effect(name, values) catch { + VariancePartitionError(message) => + raise SpicyError("spicyR covariate design failed: " + message) + } + fixed.push(effect) + } + let random : Array[VariancePartitionRandomEffect] = [] + if model == WeightedRandomIntercept { + let subjects : Array[String] = [] + for image in metadata { + subjects.push(image.subject) + } + let effect = vp_random_effect("subject", subjects) catch { + VariancePartitionError(message) => + raise SpicyError("spicyR subject design failed: " + message) + } + random.push(effect) + } + vp_design(sample_names, fixed, random) catch { + VariancePartitionError(message) => + raise SpicyError("spicyR model design failed: " + message) + } +} + +///| +fn spicy_bh_adjust(p_values : Array[Double]) -> Array[Double] { + let count = p_values.length() + let order : Array[Int] = [] + for index in 0.. Int { + if p_values[left] < p_values[right] { + -1 + } else if p_values[left] > p_values[right] { + 1 + } else if left < right { + -1 + } else if left > right { + 1 + } else { + 0 + } + }) + let adjusted = Array::make(count, 1.0) + let mut running = 1.0 + let mut rank = count + while rank > 0 { + let original = order[rank - 1] + let candidate = (p_values[original] * count.to_double() / rank.to_double()).min( + 1.0, + ) + running = running.min(candidate) + adjusted[original] = running.max(p_values[original]) + rank = rank - 1 + } + adjusted +} + +///| +fn spicy_fit_pair( + pair : SpicyPair, + associations : Array[SpicyAssociation], + metadata : Array[SpicyImageMetadata], + covariate_names : Array[String], + condition_levels : Array[String], + reference : String, + config : SpicyConfig, +) -> SpicyPairResult raise SpicyError { + let weighted = spicy_weight_associations(associations, config) + let selected_metadata : Array[SpicyImageMetadata] = [] + let values : Array[Double] = [] + let weights : Array[Double] = [] + let selected_associations : Array[SpicyAssociation] = [] + for association in weighted { + if association.available { + let image = match + spicy_metadata_for_image(metadata, association.image_id) { + Some(value) => value + None => + raise SpicyError( + "spicyR association references unknown image: " + + association.image_id, + ) + } + selected_metadata.push(image) + values.push(association.statistic) + weights.push(association.weight) + selected_associations.push(association) + } + } + if selected_associations.length() < 3 { + raise SpicyError( + "spicyR pair " + pair.label() + " has fewer than three usable images", + ) + } + let model = spicy_model_kind(selected_metadata) + let design = spicy_build_design( + selected_metadata, covariate_names, reference, model, + ) + let fit = vp_fit_gene( + values, + design, + gene_name=pair.label(), + weights~, + reml=true, + max_iterations=config.max_iterations, + tolerance=config.tolerance, + ) catch { + VariancePartitionError(message) => + raise SpicyError( + "spicyR model fit failed for " + pair.label() + ": " + message, + ) + } + let intercept_index = spicy_find_string(fit.coefficient_names, "(Intercept)") + let intercept = if intercept_index < 0 { + 0.0 + } else { + fit.coefficients[intercept_index] + } + let condition_results : Array[SpicyConditionResult] = [] + for level in condition_levels { + if level != reference { + let coefficient_name = "condition:" + level + let contrast = vp_coefficient_contrast( + design, + level + "-" + reference, + coefficient_name, + ) catch { + VariancePartitionError(message) => + raise SpicyError( + "spicyR condition contrast failed for " + + pair.label() + + ": " + + message, + ) + } + let result = dream( + [values], + design, + contrast, + gene_names=[pair.label()], + weights=[weights], + reml=true, + max_iterations=config.max_iterations, + tolerance=config.tolerance, + ) catch { + VariancePartitionError(message) => + raise SpicyError( + "spicyR condition test failed for " + pair.label() + ": " + message, + ) + } + let tested = result.genes[0] + condition_results.push(SpicyConditionResult::{ + condition_level: level, + estimate: tested.estimate, + standard_error: tested.standard_error, + statistic: tested.statistic, + degrees_of_freedom: tested.degrees_of_freedom, + p_value: tested.p_value, + adjusted_p_value: tested.p_value, + converged: tested.converged, + }) + } + } + let random_variance = if fit.random_variances.length() == 0 { + 0.0 + } else { + fit.random_variances[0] + } + SpicyPairResult::{ + pair, + model, + intercept, + conditions: condition_results, + random_intercept_variance: random_variance, + residual_variance: fit.residual_variance, + associations: weighted, + } +} + +///| +fn spicy_adjust_pair_results( + pairs : Array[SpicyPairResult], + condition_levels : Array[String], + reference : String, +) -> Array[SpicyPairResult] { + let adjusted_by_level : Map[String, Array[Double]] = Map([]) + for level in condition_levels { + if level != reference { + let p_values : Array[Double] = [] + for pair in pairs { + let mut found = 1.0 + for condition in pair.conditions { + if condition.condition_level == level { + found = condition.p_value + break + } + } + p_values.push(found) + } + adjusted_by_level[level] = spicy_bh_adjust(p_values) + } + } + let output : Array[SpicyPairResult] = [] + for pair_index in 0.. SpicyResult raise SpicyError { + if associations.length() == 0 { + raise SpicyError("spicyR associations must not be empty") + } + if metadata.length() < 3 { + raise SpicyError("spicyR requires at least three images") + } + let metadata_ids : Array[String] = [] + for image in metadata { + if metadata_ids.contains(image.image_id) { + raise SpicyError("spicyR image metadata IDs must be unique") + } + metadata_ids.push(image.image_id) + } + let condition_levels = spicy_condition_levels(metadata) + if condition_levels.length() < 2 { + raise SpicyError("spicyR requires at least two condition levels") + } + let reference = if config.reference_condition == "" { + condition_levels[0] + } else { + config.reference_condition + } + if !condition_levels.contains(reference) { + raise SpicyError("spicyR reference condition is absent from metadata") + } + let pair_labels : Array[String] = [] + let pairs : Array[SpicyPair] = [] + for association in associations { + if !metadata_ids.contains(association.image_id) { + raise SpicyError( + "spicyR association references unknown image: " + association.image_id, + ) + } + let key = spicy_pair_key(association) + if !pair_labels.contains(key) { + pair_labels.push(key) + pairs.push(SpicyPair::{ + from_cell_type: association.from_cell_type, + to_cell_type: association.to_cell_type, + }) + } + } + let raw_results : Array[SpicyPairResult] = [] + for pair_index in 0.. SpicyResult raise SpicyError { + spicy_validate_metadata(cells, metadata) + let selected_pairs = spicy_resolve_pairs(cells, pairs) + let associations : Array[SpicyAssociation] = [] + for pair in selected_pairs { + for image in metadata { + associations.push( + spicy_pair_association_for_image( + image, + spicy_image_cells(cells, image.image_id), + pair, + config, + ), + ) + } + } + spicy_fit_associations(associations, metadata, covariate_names~, config~) +} + +///| +pub fn SpicyPairResult::condition( + self : SpicyPairResult, + level : String, +) -> SpicyConditionResult? { + for value in self.conditions { + if value.condition_level == level { + return Some(value) + } + } + None +} + +///| +pub fn SpicyPairResult::association( + self : SpicyPairResult, + image_id : String, +) -> SpicyAssociation? { + for value in self.associations { + if value.image_id == image_id { + return Some(value) + } + } + None +} + +///| +pub fn SpicyResult::pair( + self : SpicyResult, + from_cell_type : String, + to_cell_type : String, +) -> SpicyPairResult? { + for pair in self.pairs { + if pair.pair.from_cell_type == from_cell_type && + pair.pair.to_cell_type == to_cell_type { + return Some(pair) + } + } + None +} + +///| +pub fn SpicyResult::n_pairs(self : SpicyResult) -> Int { + self.pairs.length() +} + +///| +pub fn SpicyResult::n_images(self : SpicyResult) -> Int { + self.image_ids.length() +} + +///| +pub fn SpicyResult::significant( + self : SpicyResult, + condition_level : String, + threshold? : Double = -1.0, +) -> Array[SpicyPairResult] raise SpicyError { + let selected_threshold = if threshold < 0.0 { + self.config.fdr_threshold + } else { + threshold + } + if !spicy_is_finite(selected_threshold) || + selected_threshold < 0.0 || + selected_threshold > 1.0 { + raise SpicyError("spicyR significance threshold must be in [0, 1]") + } + if condition_level == self.reference_condition || + !self.condition_levels.contains(condition_level) { + raise SpicyError("spicyR requested condition contrast is absent") + } + let output : Array[SpicyPairResult] = [] + for pair in self.pairs { + match pair.condition(condition_level) { + Some(value) => + if value.adjusted_p_value <= selected_threshold { + output.push(pair) + } + None => () + } + } + output +} + +///| +pub fn SpicyResult::top( + self : SpicyResult, + condition_level : String, + limit? : Int = 10, +) -> Array[SpicyPairResult] raise SpicyError { + if limit < 0 { + raise SpicyError("spicyR top-pair limit must be non-negative") + } + if condition_level == self.reference_condition || + !self.condition_levels.contains(condition_level) { + raise SpicyError("spicyR requested condition contrast is absent") + } + let output = self.pairs.copy() + output.sort_by(fn(left : SpicyPairResult, right : SpicyPairResult) -> Int { + let left_p = match left.condition(condition_level) { + Some(value) => value.p_value + None => 1.0 + } + let right_p = match right.condition(condition_level) { + Some(value) => value.p_value + None => 1.0 + } + if left_p < right_p { + -1 + } else if left_p > right_p { + 1 + } else { + left.pair.label().compare(right.pair.label()) + } + }) + let count = limit.min(output.length()) + let selected : Array[SpicyPairResult] = [] + for index in 0.. String { + let mut significant = 0 + for pair in self.pairs { + for condition in pair.conditions { + if condition.adjusted_p_value <= self.config.fdr_threshold { + significant = significant + 1 + } + } + } + "spicyR(images=" + + self.n_images().to_string() + + ", pairs=" + + self.n_pairs().to_string() + + ", reference=" + + self.reference_condition + + ", significant_contrasts=" + + significant.to_string() + + ")" +} + +///| +fn spicy_copy_spatial_experiment( + experiment : SpatialExperiment, +) -> SpatialExperiment { + let output = SpatialExperiment::new() + for assay_name in experiment.assay.keys() { + let matrix : Array[Array[Double]] = [] + for row in experiment.assay[assay_name] { + matrix.push(row.copy()) + } + output.assay[assay_name] = matrix + } + for row in experiment.row_data { + output.row_data.push(spicy_copy_string_map(row)) + } + for column in experiment.col_data { + output.col_data.push(spicy_copy_string_map(column)) + } + for coordinate in experiment.spatial_coords { + output.spatial_coords.push(coordinate) + } + for image in experiment.images { + output.images.push(image) + } + for key in experiment.metadata.keys() { + output.metadata[key] = experiment.metadata[key] + } + output +} + +///| +fn spicy_required_column( + column : Map[String, String], + key : String, + row : Int, +) -> String raise SpicyError { + match column.get(key) { + Some(value) => + if value == "" { + raise SpicyError( + "spicyR SpatialExperiment column '" + + key + + "' is empty at cell " + + row.to_string(), + ) + } else { + value + } + None => + raise SpicyError( + "spicyR SpatialExperiment is missing column '" + key + "'", + ) + } +} + +///| +pub fn spicyr_spatial_experiment( + experiment : SpatialExperiment, + image_id_key? : String = "imageID", + cell_type_key? : String = "cellType", + condition_key? : String = "condition", + subject_key? : String = "", + covariate_keys? : Array[String] = [], + pairs? : Array[SpicyPair] = [], + config? : SpicyConfig = SpicyConfig::default(), +) -> SpicySpatialExperimentOutput raise SpicyError { + if experiment.col_data.length() == 0 { + raise SpicyError("spicyR SpatialExperiment col_data must not be empty") + } + if experiment.col_data.length() != experiment.spatial_coords.length() { + raise SpicyError( + "spicyR SpatialExperiment coordinates must match col_data rows", + ) + } + if image_id_key == "" || cell_type_key == "" || condition_key == "" { + raise SpicyError("spicyR SpatialExperiment key names must not be empty") + } + let cells : Array[SpicyCell] = [] + let metadata : Array[SpicyImageMetadata] = [] + let metadata_indices : Map[String, Int] = Map([]) + for row in 0.. parsed + None => + raise SpicyError( + "spicyR SpatialExperiment covariate '" + key + "' must be numeric", + ) + } + if !spicy_is_finite(value) { + raise SpicyError("spicyR SpatialExperiment covariates must be finite") + } + covariates[key] = value + } + cells.push( + SpicyCell::create( + image_id, + cell_type, + experiment.spatial_coords[row].x, + experiment.spatial_coords[row].y, + ), + ) + match metadata_indices.get(image_id) { + Some(index) => { + let existing = metadata[index] + if existing.condition != condition || existing.subject != subject { + raise SpicyError( + "spicyR image metadata must be constant within each image", + ) + } + for key in covariate_keys { + match existing.covariates.get(key) { + Some(value) => + if value != covariates[key] { + raise SpicyError( + "spicyR covariates must be constant within each image", + ) + } + None => + raise SpicyError( + "spicyR covariate is missing from existing image metadata", + ) + } + } + } + None => { + metadata_indices[image_id] = metadata.length() + metadata.push( + SpicyImageMetadata::create(image_id, condition, subject~, covariates~), + ) + } + } + } + let result = spicyr( + cells, + metadata, + pairs~, + covariate_names=covariate_keys, + config~, + ) + let enriched = spicy_copy_spatial_experiment(experiment) + enriched.metadata["spicyr_images"] = result.n_images().to_string() + enriched.metadata["spicyr_pairs"] = result.n_pairs().to_string() + enriched.metadata["spicyr_reference"] = result.reference_condition + let mut significant = 0 + for pair in result.pairs { + for condition in pair.conditions { + if condition.adjusted_p_value <= config.fdr_threshold { + significant = significant + 1 + } + } + } + enriched.metadata["spicyr_significant_contrasts"] = significant.to_string() + SpicySpatialExperimentOutput::{ experiment: enriched, result } +} + +///| +pub fn spicyr_example_data() -> ( + Array[SpicyCell], + Array[SpicyImageMetadata], + Array[SpicyPair], +) { + let cells : Array[SpicyCell] = [] + let metadata : Array[SpicyImageMetadata] = [] + let anchors = [ + (2.0, 2.0), + (2.4, 2.0), + (2.0, 2.4), + (2.4, 2.4), + (1.8, 2.2), + (2.6, 2.2), + (0.0, 0.0), + (10.0, 10.0), + ] + for subject_index in 0..<6 { + let condition = if subject_index < 3 { "control" } else { "treated" } + let subject = "subject_" + (subject_index + 1).to_string() + for field in 0..<2 { + let image_id = subject + "_field_" + (field + 1).to_string() + let covariates : Map[String, Double] = Map([ + ("age", 40.0 + subject_index.to_double() * 3.0), + ]) + metadata.push(SpicyImageMetadata::{ + image_id, + condition, + subject, + covariates, + }) + let jitter = subject_index.to_double() * 0.025 + field.to_double() * 0.015 + for point in anchors { + cells.push(SpicyCell::{ + image_id, + cell_type: "T_cell", + x: point.0 + jitter, + y: point.1, + }) + let shift = if condition == "control" { 4.0 } else { 0.35 } + cells.push(SpicyCell::{ + image_id, + cell_type: "Tumour", + x: (point.0 + shift).min(10.0) + jitter, + y: (point.1 + shift).min(10.0), + }) + } + } + } + let pairs = [SpicyPair::{ from_cell_type: "T_cell", to_cell_type: "Tumour" }] + (cells, metadata, pairs) +} diff --git a/src/tradeseq_advanced.mbt b/src/tradeseq_advanced.mbt new file mode 100644 index 00000000..9b9a79e9 --- /dev/null +++ b/src/tradeseq_advanced.mbt @@ -0,0 +1,1656 @@ +// Advanced trajectory differential expression inspired by tradeSeq 1.27.0. +// +// Count matrices use feature x cell orientation. Pseudotime and lineage +// weights use cell x lineage orientation, matching slingshot output. + +///| +pub suberror TradeSeqAdvancedError { + TradeSeqAdvancedError(String) +} + +///| +pub struct TradeSeqAdvancedConfig { + n_knots : Int + smoothing_penalty : Double + max_iterations : Int + tolerance : Double + minimum_dispersion : Double + maximum_dispersion : Double + ridge : Double + fdr_threshold : Double + test_points : Int +} derive(Debug) + +///| +pub fn TradeSeqAdvancedConfig::create( + n_knots? : Int = 6, + smoothing_penalty? : Double = 1.0, + max_iterations? : Int = 60, + tolerance? : Double = 1.0e-6, + minimum_dispersion? : Double = 1.0e-4, + maximum_dispersion? : Double = 100.0, + ridge? : Double = 1.0e-8, + fdr_threshold? : Double = 0.05, + test_points? : Int = 12, +) -> TradeSeqAdvancedConfig raise TradeSeqAdvancedError { + if n_knots < 3 { + raise TradeSeqAdvancedError("n_knots must be at least 3") + } + if !tradeseq_adv_is_finite(smoothing_penalty) || smoothing_penalty < 0.0 { + raise TradeSeqAdvancedError( + "smoothing_penalty must be finite and non-negative", + ) + } + if max_iterations < 1 { + raise TradeSeqAdvancedError("max_iterations must be positive") + } + if !tradeseq_adv_is_finite(tolerance) || tolerance <= 0.0 { + raise TradeSeqAdvancedError("tolerance must be finite and positive") + } + if !tradeseq_adv_is_finite(minimum_dispersion) || minimum_dispersion <= 0.0 { + raise TradeSeqAdvancedError( + "minimum_dispersion must be finite and positive", + ) + } + if !tradeseq_adv_is_finite(maximum_dispersion) || + maximum_dispersion < minimum_dispersion { + raise TradeSeqAdvancedError( + "maximum_dispersion must be finite and at least minimum_dispersion", + ) + } + if !tradeseq_adv_is_finite(ridge) || ridge <= 0.0 { + raise TradeSeqAdvancedError("ridge must be finite and positive") + } + if !tradeseq_adv_is_finite(fdr_threshold) || + fdr_threshold <= 0.0 || + fdr_threshold > 1.0 { + raise TradeSeqAdvancedError("fdr_threshold must be in (0, 1]") + } + if test_points < 2 { + raise TradeSeqAdvancedError("test_points must be at least 2") + } + TradeSeqAdvancedConfig::{ + n_knots, + smoothing_penalty, + max_iterations, + tolerance, + minimum_dispersion, + maximum_dispersion, + ridge, + fdr_threshold, + test_points, + } +} + +///| +pub fn TradeSeqAdvancedConfig::default() -> TradeSeqAdvancedConfig { + TradeSeqAdvancedConfig::{ + n_knots: 6, + smoothing_penalty: 1.0, + max_iterations: 60, + tolerance: 1.0e-6, + minimum_dispersion: 1.0e-4, + maximum_dispersion: 100.0, + ridge: 1.0e-8, + fdr_threshold: 0.05, + test_points: 12, + } +} + +///| +pub struct TradeSeqGeneModel { + gene_id : String + coefficients : Array[Double] + covariance : Array[Array[Double]] + fitted_values : Array[Double] + dispersion : Double + log_likelihood : Double + aic : Double + effective_df : Double + converged : Bool + iterations : Int +} derive(Debug) + +///| +pub struct TradeSeqAdvancedFit { + gene_names : Array[String] + lineage_names : Array[String] + models : Array[TradeSeqGeneModel] + pseudotime : Array[Array[Double]] + cell_weights : Array[Array[Double]] + offsets : Array[Double] + lineage_minimum : Array[Double] + lineage_maximum : Array[Double] + config : TradeSeqAdvancedConfig + n_genes : Int + n_cells : Int + n_lineages : Int +} derive(Debug) + +///| +pub struct TradeSeqAdvancedTestResult { + gene_id : String + wald_statistic : Double + degrees_freedom : Int + p_value : Double + adjusted_p_value : Double + log2_fold_change : Double + significant : Bool +} derive(Debug) + +///| +pub struct TradeSeqAdvancedTestTable { + test_name : String + results : Array[TradeSeqAdvancedTestResult] + fdr_threshold : Double +} derive(Debug) + +///| +pub struct TradeSeqKnotEvaluation { + candidates : Array[Int] + gene_aic : Array[Array[Double]] + mean_aic : Array[Double] + selected_n_knots : Int +} derive(Debug) + +///| +pub struct TradeSeqSmoothPrediction { + gene_id : String + pseudotime : Array[Array[Double]] + fitted : Array[Array[Double]] + standard_errors : Array[Array[Double]] +} derive(Debug) + +///| +pub struct TradeSeqAdvancedSceOutput { + experiment : SingleCellExperiment + fit : TradeSeqAdvancedFit +} + +///| +priv struct TradeSeqAdvObservation { + cell : Int + lineage : Int + weight : Double + basis : Array[Double] +} + +///| +fn tradeseq_adv_is_finite(value : Double) -> Bool { + value == value && value.abs() < 1.0e300 +} + +///| +fn tradeseq_adv_clamp(value : Double, lower : Double, upper : Double) -> Double { + if value < lower { + lower + } else if value > upper { + upper + } else { + value + } +} + +///| +fn tradeseq_adv_zero_matrix(rows : Int, columns : Int) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for _ in 0.. Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in matrix { + output.push(row.copy()) + } + output +} + +///| +fn tradeseq_adv_prepare_names( + supplied : Array[String], + length : Int, + prefix : String, +) -> Array[String] raise TradeSeqAdvancedError { + if supplied.length() != 0 && supplied.length() != length { + raise TradeSeqAdvancedError( + prefix + " names do not match the matrix dimension", + ) + } + let output : Array[String] = [] + for index in 0.. (Int, Int) raise TradeSeqAdvancedError { + if counts.length() == 0 { + raise TradeSeqAdvancedError("counts must contain at least one gene") + } + let cells = counts[0].length() + if cells == 0 { + raise TradeSeqAdvancedError("counts must contain at least one cell") + } + for row in counts { + if row.length() != cells { + raise TradeSeqAdvancedError("counts must be rectangular") + } + for value in row { + if !tradeseq_adv_is_finite(value) || value < 0.0 { + raise TradeSeqAdvancedError( + "counts must contain finite non-negative values", + ) + } + if (value - value.round()).abs() > 1.0e-8 { + raise TradeSeqAdvancedError("counts must contain integer values") + } + } + } + (counts.length(), cells) +} + +///| +fn tradeseq_adv_prepare_trajectory( + pseudotime : Array[Array[Double]], + cell_weights : Array[Array[Double]], + cells : Int, +) -> (Array[Array[Double]], Array[Array[Double]], Array[Double], Array[Double]) raise TradeSeqAdvancedError { + if pseudotime.length() != cells || cell_weights.length() != cells { + raise TradeSeqAdvancedError( + "pseudotime and cell_weights rows must match count cells", + ) + } + if cells == 0 || pseudotime[0].length() == 0 { + raise TradeSeqAdvancedError("at least one lineage is required") + } + let lineages = pseudotime[0].length() + if cell_weights[0].length() != lineages { + raise TradeSeqAdvancedError( + "pseudotime and cell_weights must have identical dimensions", + ) + } + let prepared_time = tradeseq_adv_copy_matrix(pseudotime) + let prepared_weights = tradeseq_adv_zero_matrix(cells, lineages) + for cell in 0.. 0.0 && !tradeseq_adv_is_finite(pseudotime[cell][lineage]) { + raise TradeSeqAdvancedError("active lineage pseudotime must be finite") + } + total = total + weight + } + if total <= 0.0 { + raise TradeSeqAdvancedError( + "every cell must have at least one positive lineage weight", + ) + } + for lineage in 0.. 0.0 { + let value = prepared_time[cell][lineage] + if value < minimum[lineage] { + minimum[lineage] = value + } + if value > maximum[lineage] { + maximum[lineage] = value + } + } + } + } + for lineage in 0.. 1.0e299 { + raise TradeSeqAdvancedError("every lineage must contain active cells") + } + if maximum[lineage] - minimum[lineage] <= 1.0e-12 { + raise TradeSeqAdvancedError( + "every lineage must span more than one pseudotime value", + ) + } + } + (prepared_time, prepared_weights, minimum, maximum) +} + +///| +fn tradeseq_adv_prepare_offsets( + counts : Array[Array[Double]], + supplied : Array[Double], +) -> Array[Double] raise TradeSeqAdvancedError { + let cells = counts[0].length() + if supplied.length() != 0 { + if supplied.length() != cells { + raise TradeSeqAdvancedError("offsets must match count cells") + } + for value in supplied { + if !tradeseq_adv_is_finite(value) { + raise TradeSeqAdvancedError("offsets must contain finite values") + } + } + return supplied.copy() + } + let offsets = Array::make(cells, 0.0) + let mut mean_log_library = 0.0 + for cell in 0.. Array[Double] { + let x = tradeseq_adv_clamp(x_value, 0.0, 1.0) + let degree = (count - 1).min(3) + if x >= 1.0 { + let output = Array::make(count, 0.0) + output[count - 1] = 1.0 + return output + } + let knot_count = count + degree + 1 + let knots = Array::make(knot_count, 0.0) + for index in 0..= count { + knots[index] = 1.0 + } else { + knots[index] = (index - degree).to_double() / (count - degree).to_double() + } + } + let mut previous = Array::make(knot_count - 1, 0.0) + for index in 0..<(knot_count - 1) { + if x >= knots[index] && x < knots[index + 1] { + previous[index] = 1.0 + } + } + let mut level = 1 + while level <= degree { + let current = Array::make(knot_count - level - 1, 0.0) + for index in 0.. 0.0 { + (x - knots[index]) / left_denominator * previous[index] + } else { + 0.0 + } + let right = if right_denominator > 0.0 { + (knots[index + level + 1] - x) / right_denominator * previous[index + 1] + } else { + 0.0 + } + current[index] = left + right + } + previous = current + level = level + 1 + } + let output : Array[Double] = [] + for index in 0.. Double { + tradeseq_adv_clamp((value - minimum) / (maximum - minimum), 0.0, 1.0) +} + +///| +fn tradeseq_adv_observations( + pseudotime : Array[Array[Double]], + weights : Array[Array[Double]], + minimum : Array[Double], + maximum : Array[Double], + n_knots : Int, +) -> Array[TradeSeqAdvObservation] { + let output : Array[TradeSeqAdvObservation] = [] + for cell in 0.. 1.0e-12 { + let normalized = tradeseq_adv_normalized_time( + pseudotime[cell][lineage], + minimum[lineage], + maximum[lineage], + ) + output.push(TradeSeqAdvObservation::{ + cell, + lineage, + weight: weights[cell][lineage], + basis: tradeseq_adv_bspline_basis(normalized, n_knots), + }) + } + } + } + output +} + +///| +fn tradeseq_adv_add_penalty( + matrix : Array[Array[Double]], + lineages : Int, + n_knots : Int, + penalty : Double, + ridge : Double, +) -> Unit { + let parameters = lineages * n_knots + for parameter in 0.. Array[Array[Double]]? { + if matrix.length() == 0 || matrix[0].length() != matrix.length() { + return None + } + let size = matrix.length() + let augmented = tradeseq_adv_zero_matrix(size, size * 2) + for row in 0.. pivot_value { + pivot = row + pivot_value = value + } + } + if pivot_value < 1.0e-14 || !tradeseq_adv_is_finite(pivot_value) { + return None + } + if pivot != column { + let temporary = augmented[column] + augmented[column] = augmented[pivot] + augmented[pivot] = temporary + } + let divisor = augmented[column][column] + for current in 0..<(size * 2) { + augmented[column][current] = augmented[column][current] / divisor + } + for row in 0.. 0.0 { + for current in 0..<(size * 2) { + augmented[row][current] = augmented[row][current] - + factor * augmented[column][current] + } + } + } + } + } + let output = tradeseq_adv_zero_matrix(size, size) + for row in 0.. Array[Double] { + let output = Array::make(matrix.length(), 0.0) + for row in 0.. Double { + let coefficients = [ + 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, + -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, + 1.5056327351493116e-7, + ] + let shifted = value - 1.0 + let mut sum = coefficients[0] + for index in 1.. Double { + let size = 1.0 / dispersion + let mut result = 0.0 + for index in 0.. Array[Double] { + let weighted_sum = Array::make(lineages, 0.0) + let weight_sum = Array::make(lineages, 0.0) + for observation in observations { + weighted_sum[observation.lineage] = weighted_sum[observation.lineage] + + observation.weight * + response[observation.cell] * + @math.exp(-offsets[observation.cell]) + weight_sum[observation.lineage] = weight_sum[observation.lineage] + + observation.weight + } + let coefficients = Array::make(lineages * n_knots, 0.0) + for lineage in 0.. 0.0 { + weighted_sum[lineage] / weight_sum[lineage] + } else { + 0.0 + } + let value = @math.ln(mean.max(1.0e-8)) + for knot in 0.. Double { + let start = observation.lineage * n_knots + let mut value = offset + for knot in 0.. TradeSeqGeneModel { + let n_knots = config.n_knots + let parameters = lineages * n_knots + let coefficients = tradeseq_adv_initial_coefficients( + response, offsets, observations, lineages, n_knots, + ) + let mut dispersion = 0.1 + let mut converged = false + let mut iterations = 0 + let expanded_fitted = Array::make(observations.length(), 0.0) + let mut final_information = tradeseq_adv_zero_matrix(parameters, parameters) + let mut iteration = 0 + while iteration < config.max_iterations { + let information = tradeseq_adv_zero_matrix(parameters, parameters) + let right_hand_side = Array::make(parameters, 0.0) + let mut dispersion_numerator = 0.0 + let mut dispersion_denominator = 0.0 + for index in 0.. 0 && dispersion_denominator > 0.0 { + let estimate = tradeseq_adv_clamp( + dispersion_numerator / dispersion_denominator, + config.minimum_dispersion, + config.maximum_dispersion, + ) + dispersion = 0.7 * dispersion + 0.3 * estimate + } + for index in 0.. value + None => { + iterations = iteration + 1 + break + } + } + let updated = tradeseq_adv_matrix_vector(inverse, right_hand_side) + let mut maximum_change = 0.0 + for parameter in 0.. maximum_change { + maximum_change = change + } + coefficients[parameter] = updated[parameter] + } + final_information = information + iterations = iteration + 1 + let mut coefficient_scale = 0.0 + for value in coefficients { + coefficient_scale = coefficient_scale.max(value.abs()) + } + if maximum_change <= config.tolerance * (1.0 + coefficient_scale) { + converged = true + break + } + iteration = iteration + 1 + } + for index in 0.. value + None => { + let fallback = tradeseq_adv_zero_matrix(parameters, parameters) + for parameter in 0.. TradeSeqAdvancedFit raise TradeSeqAdvancedError { + let (genes, cells) = tradeseq_adv_validate_counts(counts) + let (prepared_time, prepared_weights, minimum, maximum) = tradeseq_adv_prepare_trajectory( + pseudotime, cell_weights, cells, + ) + let lineages = prepared_time[0].length() + let prepared_gene_names = tradeseq_adv_prepare_names( + gene_names, genes, "Gene", + ) + let prepared_lineage_names = tradeseq_adv_prepare_names( + lineage_names, lineages, "Lineage", + ) + let prepared_offsets = tradeseq_adv_prepare_offsets(counts, offsets) + let observations = tradeseq_adv_observations( + prepared_time, + prepared_weights, + minimum, + maximum, + config.n_knots, + ) + let models : Array[TradeSeqGeneModel] = [] + for gene in 0.. Array[Double] { + let output = Array::make(lineages * n_knots, 0.0) + let first_basis = tradeseq_adv_bspline_basis(first, n_knots) + let second_basis = tradeseq_adv_bspline_basis(second, n_knots) + for knot in 0.. Array[Double] { + let output = Array::make(lineages * n_knots, 0.0) + let basis = tradeseq_adv_bspline_basis(position, n_knots) + for knot in 0.. Array[Array[Double]] { + let selected : Array[Array[Double]] = [] + let orthonormal : Array[Array[Double]] = [] + for row in rows { + let residual = row.copy() + for direction in orthonormal { + let mut projection = 0.0 + for column in 0.. 1.0e-12 { + let norm = norm_squared.sqrt() + for column in 0.. Double { + if x <= 0.0 { + return 1.0 + } + if x < a + 1.0 { + let mut term = 1.0 / a + let mut sum = term + let mut index = 1 + while index < 300 { + term = term * x / (a + index.to_double()) + sum = sum + term + if term.abs() < sum.abs() * 1.0e-12 { + break + } + index = index + 1 + } + return tradeseq_adv_clamp( + 1.0 - sum * @math.exp(-x + a * @math.ln(x) - tradeseq_adv_log_gamma(a)), + 0.0, + 1.0, + ) + } + let tiny = 1.0e-300 + let mut b = x + 1.0 - a + let mut c = 1.0 / tiny + let mut d = 1.0 / b + let mut value = d + let mut index = 1 + while index < 300 { + let an = -index.to_double() * (index.to_double() - a) + b = b + 2.0 + d = an * d + b + if d.abs() < tiny { + d = tiny + } + c = b + an / c + if c.abs() < tiny { + c = tiny + } + d = 1.0 / d + let delta = d * c + value = value * delta + if (delta - 1.0).abs() < 1.0e-12 { + break + } + index = index + 1 + } + tradeseq_adv_clamp( + value * @math.exp(-x + a * @math.ln(x) - tradeseq_adv_log_gamma(a)), + 0.0, + 1.0, + ) +} + +///| +fn tradeseq_adv_chi_square_q(degrees : Int, statistic : Double) -> Double { + if statistic <= 0.0 || degrees <= 0 { + return 1.0 + } + tradeseq_adv_log_gamma_q(0.5 * degrees.to_double(), 0.5 * statistic) +} + +///| +fn tradeseq_adv_wald( + model : TradeSeqGeneModel, + raw_contrasts : Array[Array[Double]], + l2fc : Double, +) -> (Double, Int, Double, Double) { + let contrasts = tradeseq_adv_independent_rows(raw_contrasts) + let degrees = contrasts.length() + if degrees == 0 { + return (0.0, 0, 1.0, 0.0) + } + let effects = Array::make(degrees, 0.0) + let adjusted_effects = Array::make(degrees, 0.0) + let threshold = l2fc.max(0.0) * @math.ln(2.0) + let mut maximum_effect = 0.0 + for contrast in 0.. threshold { + effect - threshold + } else if effect < -threshold { + effect + threshold + } else { + 0.0 + } + if effect.abs() > maximum_effect.abs() { + maximum_effect = effect + } + } + let variance = tradeseq_adv_zero_matrix(degrees, degrees) + for left in 0.. value + None => return (0.0, degrees, 1.0, maximum_effect / @math.ln(2.0)) + } + let projected = tradeseq_adv_matrix_vector(inverse, adjusted_effects) + let mut statistic = 0.0 + for index in 0.. Array[Double] { + let indices : Array[Int] = [] + for index in 0..= 0 { + let index = indices[position] + let adjusted = (values[index] * + indices.length().to_double() / + (position + 1).to_double()).min(1.0) + running = running.min(adjusted) + output[index] = running + position = position - 1 + } + output +} + +///| +fn tradeseq_adv_test_table( + fit : TradeSeqAdvancedFit, + test_name : String, + contrasts : Array[Array[Double]], + l2fc : Double, +) -> TradeSeqAdvancedTestTable { + let statistics = Array::make(fit.n_genes, 0.0) + let degrees = Array::make(fit.n_genes, 0) + let p_values = Array::make(fit.n_genes, 1.0) + let fold_changes = Array::make(fit.n_genes, 0.0) + for gene in 0.. TradeSeqAdvancedTestTable raise TradeSeqAdvancedError { + if !tradeseq_adv_is_finite(l2fc) || l2fc < 0.0 { + raise TradeSeqAdvancedError("l2fc must be finite and non-negative") + } + let contrasts : Array[Array[Double]] = [] + for lineage in 0.. TradeSeqAdvancedTestTable raise TradeSeqAdvancedError { + if !tradeseq_adv_is_finite(l2fc) || l2fc < 0.0 { + raise TradeSeqAdvancedError("l2fc must be finite and non-negative") + } + let contrasts : Array[Array[Double]] = [] + for lineage in 0.. TradeSeqAdvancedTestTable raise TradeSeqAdvancedError { + if fit.n_lineages < 2 { + raise TradeSeqAdvancedError("diffEndTest requires at least two lineages") + } + if !tradeseq_adv_is_finite(l2fc) || l2fc < 0.0 { + raise TradeSeqAdvancedError("l2fc must be finite and non-negative") + } + let contrasts : Array[Array[Double]] = [] + for first in 0.. TradeSeqAdvancedTestTable raise TradeSeqAdvancedError { + if fit.n_lineages < 2 { + raise TradeSeqAdvancedError("patternTest requires at least two lineages") + } + let points = if n_points == 0 { fit.config.test_points } else { n_points } + if points < 2 { + raise TradeSeqAdvancedError("n_points must be at least 2") + } + if !tradeseq_adv_is_finite(l2fc) || l2fc < 0.0 { + raise TradeSeqAdvancedError("l2fc must be finite and non-negative") + } + let contrasts : Array[Array[Double]] = [] + for first in 0.. TradeSeqAdvancedTestTable raise TradeSeqAdvancedError { + if fit.n_lineages < 2 { + raise TradeSeqAdvancedError("earlyDETest requires at least two lineages") + } + if !tradeseq_adv_is_finite(start_fraction) || + !tradeseq_adv_is_finite(end_fraction) || + start_fraction < 0.0 || + end_fraction > 1.0 || + end_fraction <= start_fraction { + raise TradeSeqAdvancedError( + "earlyDE interval must satisfy 0 <= start < end <= 1", + ) + } + let points = if n_points == 0 { fit.config.test_points } else { n_points } + if points < 2 { + raise TradeSeqAdvancedError("n_points must be at least 2") + } + if !tradeseq_adv_is_finite(l2fc) || l2fc < 0.0 { + raise TradeSeqAdvancedError("l2fc must be finite and non-negative") + } + let contrasts : Array[Array[Double]] = [] + for first in 0.. TradeSeqSmoothPrediction raise TradeSeqAdvancedError { + if n_points < 2 { + raise TradeSeqAdvancedError("n_points must be at least 2") + } + let mut gene = -1 + for index in 0.. TradeSeqKnotEvaluation raise TradeSeqAdvancedError { + if candidates.length() < 2 { + raise TradeSeqAdvancedError("at least two knot candidates are required") + } + let unique : Array[Int] = [] + for candidate in candidates { + if candidate < 3 { + raise TradeSeqAdvancedError("knot candidates must be at least 3") + } + if unique.contains(candidate) { + raise TradeSeqAdvancedError("knot candidates must be unique") + } + unique.push(candidate) + } + let genes = counts.length() + let gene_aic = tradeseq_adv_zero_matrix(genes, candidates.length()) + let mean_aic = Array::make(candidates.length(), 0.0) + for candidate_index in 0.. TradeSeqAdvancedFit raise TradeSeqAdvancedError { + let cells = slingshot.weights.length() + if cells == 0 { + raise TradeSeqAdvancedError("slingshot result contains no cells") + } + let lineages = slingshot.weights[0].length() + let pseudotime = tradeseq_adv_zero_matrix(cells, lineages) + let weights = tradeseq_adv_zero_matrix(cells, lineages) + for cell in 0.. { + pseudotime[cell][lineage] = value + weights[cell][lineage] = slingshot.weights[cell][lineage] + } + None => { + pseudotime[cell][lineage] = 0.0 + weights[cell][lineage] = 0.0 + } + } + } + } + let lineage_names : Array[String] = [] + for lineage in 0.. Map[String, Array[String]] { + let output : Map[String, Array[String]] = Map([]) + for key in source.keys() { + output[key] = source[key].copy() + } + output +} + +///| +fn tradeseq_adv_copy_sce(source : SingleCellExperiment) -> SingleCellExperiment { + let assays : Map[String, Array[Array[Double]]] = Map([]) + for key in source.assays.keys() { + assays[key] = tradeseq_adv_copy_matrix(source.assays[key]) + } + let reduced_dims : Map[String, Array[Array[Double]]] = Map([]) + for key in source.reduced_dims.keys() { + reduced_dims[key] = tradeseq_adv_copy_matrix(source.reduced_dims[key]) + } + let alternatives : Map[String, SingleCellExperiment] = Map([]) + for key in source.alternative_experiments.keys() { + alternatives[key] = tradeseq_adv_copy_sce( + source.alternative_experiments[key], + ) + } + let metadata : Map[String, String] = Map([]) + for key in source.metadata.keys() { + metadata[key] = source.metadata[key] + } + SingleCellExperiment::{ + assays, + row_data: tradeseq_adv_copy_string_map(source.row_data), + col_data: tradeseq_adv_copy_string_map(source.col_data), + reduced_dims, + alternative_experiments: alternatives, + metadata, + row_names: source.row_names.copy(), + col_names: source.col_names.copy(), + } +} + +///| +fn tradeseq_adv_test_column( + table : TradeSeqAdvancedTestTable, + adjusted : Bool, +) -> Array[String] { + table.results.map(fn(result) { + if adjusted { + result.adjusted_p_value.to_string() + } else { + result.p_value.to_string() + } + }) +} + +///| +pub fn tradeseq_advanced_sce( + experiment : SingleCellExperiment, + assay_name? : String = "counts", + pseudotime_name? : String = "slingshot.pseudotime", + weights_name? : String = "slingshot.weights", + output_prefix? : String = "tradeSeq", + config? : TradeSeqAdvancedConfig = TradeSeqAdvancedConfig::default(), +) -> TradeSeqAdvancedSceOutput raise TradeSeqAdvancedError { + if output_prefix.trim().length() == 0 { + raise TradeSeqAdvancedError("output_prefix cannot be empty") + } + let counts = match experiment.assays.get(assay_name) { + Some(value) => value + None => raise TradeSeqAdvancedError("SCE assay not found: " + assay_name) + } + let pseudotime = match experiment.reduced_dims.get(pseudotime_name) { + Some(value) => value + None => + raise TradeSeqAdvancedError( + "SCE pseudotime matrix not found: " + pseudotime_name, + ) + } + let weights = match experiment.reduced_dims.get(weights_name) { + Some(value) => value + None => + raise TradeSeqAdvancedError( + "SCE lineage weight matrix not found: " + weights_name, + ) + } + let fit = tradeseq_fit_advanced( + counts, + pseudotime, + weights, + gene_names=experiment.row_names, + config~, + ) + let association = tradeseq_association_test_advanced(fit) + let start_end = tradeseq_start_vs_end_test_advanced(fit) + let output = tradeseq_adv_copy_sce(experiment) + let fitted : Array[Array[Double]] = [] + for model in fit.models { + fitted.push(model.fitted_values.copy()) + } + output.assays[output_prefix + ".fitted"] = fitted + output.row_data[output_prefix + ".association.pvalue"] = tradeseq_adv_test_column( + association, false, + ) + output.row_data[output_prefix + ".association.padj"] = tradeseq_adv_test_column( + association, true, + ) + output.row_data[output_prefix + ".startVsEnd.pvalue"] = tradeseq_adv_test_column( + start_end, false, + ) + output.row_data[output_prefix + ".startVsEnd.padj"] = tradeseq_adv_test_column( + start_end, true, + ) + output.row_data[output_prefix + ".dispersion"] = fit.models.map(fn(model) { + model.dispersion.to_string() + }) + output.row_data[output_prefix + ".converged"] = fit.models.map(fn(model) { + model.converged.to_string() + }) + output.metadata[output_prefix + ".nKnots"] = fit.config.n_knots.to_string() + output.metadata[output_prefix + ".lineages"] = fit.lineage_names.join(",") + TradeSeqAdvancedSceOutput::{ experiment: output, fit } +} + +///| +pub fn tradeseq_advanced_summary(fit : TradeSeqAdvancedFit) -> String { + let mut converged = 0 + let mut mean_dispersion = 0.0 + for model in fit.models { + if model.converged { + converged = converged + 1 + } + mean_dispersion = mean_dispersion + model.dispersion + } + mean_dispersion = mean_dispersion / fit.n_genes.to_double() + "tradeSeq 1.27.0 advanced fit\n" + + "genes: " + + fit.n_genes.to_string() + + "\n" + + "cells: " + + fit.n_cells.to_string() + + "\n" + + "lineages: " + + fit.n_lineages.to_string() + + "\n" + + "knots: " + + fit.config.n_knots.to_string() + + "\n" + + "converged genes: " + + converged.to_string() + + "/" + + fit.n_genes.to_string() + + "\n" + + "mean dispersion: " + + mean_dispersion.to_string() +} diff --git a/test/moonbit/bluster_test.mbt b/test/moonbit/bluster_test.mbt new file mode 100644 index 00000000..8b906c56 --- /dev/null +++ b/test/moonbit/bluster_test.mbt @@ -0,0 +1,1039 @@ +///| +fn bluster_test_close( + left : Double, + right : Double, + tolerance : Double, +) -> Bool { + (left - right).abs() <= tolerance +} + +///| +fn bluster_test_some(value : Double?) -> Double { + match value { + Some(actual) => actual + None => abort("expected a numeric value") + } +} + +///| +fn bluster_test_unique_count(values : Array[Int]) -> Int { + let unique : Array[Int] = [] + for value in values { + let mut found = false + for existing in unique { + if existing == value { + found = true + break + } + } + if !found { + unique.push(value) + } + } + unique.length() +} + +///| +fn bluster_test_two_groups() -> Array[Array[Double]] { + [[0.0, 0.0], [0.1, 0.0], [0.2, 0.1], [10.0, 10.0], [10.1, 10.0], [10.2, 10.1]] +} + +///| +fn bluster_test_sce() -> @src.SingleCellExperiment { + let experiment = @src.SingleCellExperiment::new( + [[1.0, 2.0, 3.0, 4.0], [4.0, 3.0, 2.0, 1.0]], + ["G1", "G2"], + ["C1", "C2", "C3", "C4"], + ) + experiment.row_data["symbol"] = ["A", "B"] + experiment.col_data["batch"] = ["A", "A", "B", "B"] + experiment.reduced_dims["PCA"] = [ + [0.0, 0.0], + [0.1, 0.0], + [10.0, 10.0], + [10.1, 10.0], + ] + experiment.metadata["project"] = "bluster-test" + experiment.alternative_experiments["spike"] = @src.SingleCellExperiment::new( + [[5.0, 6.0, 7.0, 8.0]], + ["Spike1"], + ["C1", "C2", "C3", "C4"], + ) + experiment +} + +///| +test "bluster: distance and weighting accessors expose enum values" { + assert_true( + @src.bluster_euclidean_distance() != @src.bluster_manhattan_distance(), + ) + assert_true( + @src.bluster_manhattan_distance() != @src.bluster_cosine_distance(), + ) + assert_true(@src.bluster_rank_weight() != @src.bluster_number_weight()) + assert_true(@src.bluster_number_weight() != @src.bluster_jaccard_weight()) +} + +///| +test "bluster: link denominator accessors expose enum values" { + assert_true(@src.bluster_link_minimum() != @src.bluster_link_maximum()) + assert_true(@src.bluster_link_maximum() != @src.bluster_link_union()) +} + +///| +test "bluster: k-means configuration preserves explicit settings" { + let config = @src.BlusterKmeansConfig::create( + 3, + max_iterations=25, + starts=4, + tolerance=1.0e-6, + seed=17, + ) catch { + _ => abort("valid k-means configuration should build") + } + assert_eq(config.centers, 3) + assert_eq(config.max_iterations, 25) + assert_eq(config.starts, 4) + assert_eq(config.tolerance, 1.0e-6) + assert_eq(config.seed, 17) +} + +///| +test "bluster: k-means configuration rejects invalid controls" { + let mut failures = 0 + ignore(@src.BlusterKmeansConfig::create(0)) catch { + _ => failures = failures + 1 + } + ignore(@src.BlusterKmeansConfig::create(2, starts=0)) catch { + _ => failures = failures + 1 + } + ignore(@src.BlusterKmeansConfig::create(2, max_iterations=0)) catch { + _ => failures = failures + 1 + } + ignore(@src.BlusterKmeansConfig::create(2, tolerance=-1.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.BlusterKmeansConfig::create(2, seed=0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 5) +} + +///| +test "bluster: graph configuration preserves explicit settings" { + let config = @src.BlusterGraphConfig::create( + k=7, + shared=false, + snn_weight=@src.bluster_jaccard_weight(), + distance=@src.bluster_manhattan_distance(), + resolution=0.5, + max_iterations=30, + seed=19, + ) catch { + _ => abort("valid graph configuration should build") + } + assert_eq(config.k, 7) + assert_false(config.shared) + assert_true(config.snn_weight == @src.bluster_jaccard_weight()) + assert_true(config.distance == @src.bluster_manhattan_distance()) + assert_eq(config.resolution, 0.5) + assert_eq(config.max_iterations, 30) + assert_eq(config.seed, 19) +} + +///| +test "bluster: graph configuration rejects invalid controls" { + let mut failures = 0 + ignore(@src.BlusterGraphConfig::create(k=0)) catch { + _ => failures = failures + 1 + } + ignore(@src.BlusterGraphConfig::create(resolution=0.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.BlusterGraphConfig::create(max_iterations=0)) catch { + _ => failures = failures + 1 + } + ignore(@src.BlusterGraphConfig::create(seed=0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 4) +} + +///| +test "bluster: two-step configuration validates both stages" { + let valid = @src.BlusterTwoStepConfig::create( + first_centers=4, + first_starts=2, + second_k=3, + seed=23, + ) catch { + _ => abort("valid two-step configuration should build") + } + assert_eq(valid.first_centers, 4) + assert_eq(valid.first_starts, 2) + assert_eq(valid.second_k, 3) + let mut failures = 0 + ignore(@src.BlusterTwoStepConfig::create(first_centers=-1)) catch { + _ => failures = failures + 1 + } + ignore(@src.BlusterTwoStepConfig::create(first_starts=0)) catch { + _ => failures = failures + 1 + } + ignore(@src.BlusterTwoStepConfig::create(second_k=0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "bluster: directed KNN uses exact nearest neighbors" { + let graph = @src.bluster_make_knn_graph( + [[0.0], [1.0], [3.0], [10.0]], + k=1, + directed=true, + ) catch { + _ => abort("valid directed KNN graph should build") + } + assert_true(graph.directed) + assert_eq(graph.k, 1) + assert_eq(graph.graph_kind, "KNN") + assert_eq(graph.node_count(), 4) + assert_eq(graph.edge_count(), 4) + assert_eq(graph.edge_weight(0, 1), 1.0) + assert_eq(graph.edge_weight(1, 0), 1.0) + assert_eq(graph.edge_weight(2, 1), 1.0) + assert_eq(graph.edge_weight(3, 2), 1.0) + assert_eq(graph.edge_weight(1, 2), 0.0) +} + +///| +test "bluster: KNN tie ordering is deterministic by observation index" { + let graph = @src.bluster_make_knn_graph( + [[0.0], [2.0], [-2.0]], + k=1, + directed=true, + ) catch { + _ => abort("tied KNN graph should build") + } + assert_eq(graph.edge_weight(0, 1), 1.0) + assert_eq(graph.edge_weight(0, 2), 0.0) +} + +///| +test "bluster: undirected KNN symmetrizes one-way relationships" { + let graph = @src.bluster_make_knn_graph([[0.0], [1.0], [3.0], [10.0]], k=1) catch { + _ => abort("valid undirected KNN graph should build") + } + assert_false(graph.directed) + assert_eq(graph.edge_count(), 3) + assert_eq(graph.edge_weight(1, 2), 1.0) + assert_eq(graph.edge_weight(2, 1), 1.0) +} + +///| +test "bluster: KNN caps k at the available observation count" { + let graph = @src.bluster_make_knn_graph([[0.0], [1.0], [2.0]], k=20) catch { + _ => abort("oversized k should be capped") + } + assert_eq(graph.k, 2) + assert_eq(graph.edge_count(), 3) +} + +///| +test "bluster: rank SNN weighting includes self at rank zero" { + let graph = @src.bluster_make_snn_graph( + [[0.0], [1.0], [10.0]], + k=1, + weighting=@src.bluster_rank_weight(), + ) catch { + _ => abort("rank SNN graph should build") + } + assert_eq(graph.graph_kind, "SNN") + assert_eq(graph.edge_count(), 3) + assert_true(bluster_test_close(graph.edge_weight(0, 1), 0.5, 1.0e-12)) + assert_true(bluster_test_close(graph.edge_weight(0, 2), 1.0e-6, 1.0e-15)) + assert_true(bluster_test_close(graph.edge_weight(1, 2), 0.5, 1.0e-12)) +} + +///| +test "bluster: number SNN weighting counts shared neighborhoods" { + let graph = @src.bluster_make_snn_graph( + [[0.0], [1.0], [10.0]], + k=1, + weighting=@src.bluster_number_weight(), + ) catch { + _ => abort("number SNN graph should build") + } + assert_eq(graph.edge_weight(0, 1), 2.0) + assert_eq(graph.edge_weight(0, 2), 1.0) + assert_eq(graph.edge_weight(1, 2), 1.0) +} + +///| +test "bluster: Jaccard SNN weighting uses neighborhood unions" { + let graph = @src.bluster_make_snn_graph( + [[0.0], [1.0], [10.0]], + k=1, + weighting=@src.bluster_jaccard_weight(), + ) catch { + _ => abort("Jaccard SNN graph should build") + } + assert_eq(graph.edge_weight(0, 1), 1.0) + assert_true(bluster_test_close(graph.edge_weight(0, 2), 1.0 / 3.0, 1.0e-12)) + assert_true(bluster_test_close(graph.edge_weight(1, 2), 1.0 / 3.0, 1.0e-12)) +} + +///| +test "bluster: SNN caps k and forms complete full-neighborhood graph" { + let graph = @src.bluster_make_snn_graph( + [[0.0], [1.0], [2.0]], + k=20, + weighting=@src.bluster_number_weight(), + ) catch { + _ => abort("oversized SNN k should be capped") + } + assert_eq(graph.k, 2) + assert_eq(graph.edge_count(), 3) + assert_eq(graph.edge_weight(0, 2), 3.0) +} + +///| +test "bluster: graph constructors reject invalid matrices and k" { + let mut failures = 0 + ignore(@src.bluster_make_snn_graph([], k=1)) catch { + _ => failures = failures + 1 + } + ignore(@src.bluster_make_knn_graph([[1.0], [1.0, 2.0]], k=1)) catch { + _ => failures = failures + 1 + } + ignore(@src.bluster_make_snn_graph([[1.0e301]], k=1)) catch { + _ => failures = failures + 1 + } + ignore(@src.bluster_make_knn_graph([[1.0]], k=0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 4) +} + +///| +test "bluster: k-means separates clear groups and reports WSS" { + let config = @src.BlusterKmeansConfig::create(2, starts=5, seed=31) catch { + _ => abort("valid k-means configuration should build") + } + let result = @src.bluster_cluster_rows_kmeans( + [[0.0, 0.0], [0.0, 1.0], [10.0, 10.0], [10.0, 11.0]], + config, + ) catch { + _ => abort("k-means should cluster valid data") + } + assert_eq(result.clusters.length(), 4) + assert_eq(result.centers.length(), 2) + assert_true(result.clusters[0] == result.clusters[1]) + assert_true(result.clusters[2] == result.clusters[3]) + assert_true(result.clusters[0] != result.clusters[2]) + assert_true(bluster_test_close(result.total_within_sum_squares, 1.0, 1.0e-12)) + assert_true( + bluster_test_close( + result.within_sum_squares[0] + result.within_sum_squares[1], + result.total_within_sum_squares, + 1.0e-12, + ), + ) +} + +///| +test "bluster: k-means is reproducible for a fixed seed" { + let config = @src.BlusterKmeansConfig::create(2, starts=4, seed=37) catch { + _ => abort("valid k-means configuration should build") + } + let data = bluster_test_two_groups() + let first = @src.bluster_cluster_rows_kmeans(data, config) catch { + _ => abort("first k-means run should work") + } + let second = @src.bluster_cluster_rows_kmeans(data, config) catch { + _ => abort("second k-means run should work") + } + assert_eq(first.clusters, second.clusters) + assert_eq(first.centers, second.centers) + assert_eq(first.total_within_sum_squares, second.total_within_sum_squares) +} + +///| +test "bluster: multiple starts cannot worsen the selected WSS" { + let one = @src.BlusterKmeansConfig::create(3, starts=1, seed=41) catch { + _ => abort("single-start configuration should build") + } + let many = @src.BlusterKmeansConfig::create(3, starts=8, seed=41) catch { + _ => abort("multi-start configuration should build") + } + let data = [ + [0.0, 0.0], + [0.2, 0.0], + [5.0, 5.0], + [5.2, 5.0], + [10.0, 0.0], + [10.2, 0.0], + ] + let first = @src.bluster_cluster_rows_kmeans(data, one) catch { + _ => abort("single-start k-means should work") + } + let second = @src.bluster_cluster_rows_kmeans(data, many) catch { + _ => abort("multi-start k-means should work") + } + assert_true( + second.total_within_sum_squares <= first.total_within_sum_squares + 1.0e-12, + ) +} + +///| +test "bluster: k-means rejects more centers than observations" { + let config = @src.BlusterKmeansConfig::create(3) catch { + _ => abort("configuration validation is independent of data") + } + let mut raised = false + ignore(@src.bluster_cluster_rows_kmeans([[0.0], [1.0]], config)) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "bluster: graph clustering separates disconnected populations" { + let config = @src.BlusterGraphConfig::create(k=1, resolution=0.5, seed=43) catch { + _ => abort("valid graph configuration should build") + } + let result = @src.bluster_cluster_rows_graph( + bluster_test_two_groups(), + config, + ) catch { + _ => abort("graph clustering should work") + } + assert_eq(result.clusters.length(), 6) + assert_true(result.clusters[0] == result.clusters[1]) + assert_true(result.clusters[1] == result.clusters[2]) + assert_true(result.clusters[3] == result.clusters[4]) + assert_true(result.clusters[4] == result.clusters[5]) + assert_true(result.clusters[0] != result.clusters[3]) + assert_eq(bluster_test_unique_count(result.clusters), 2) +} + +///| +test "bluster: KNN graph clustering uses the non-shared path" { + let config = @src.BlusterGraphConfig::create( + k=1, + shared=false, + resolution=0.5, + seed=47, + ) catch { + _ => abort("valid KNN graph configuration should build") + } + let result = @src.bluster_cluster_rows_graph( + bluster_test_two_groups(), + config, + ) catch { + _ => abort("KNN graph clustering should work") + } + assert_eq(result.graph.graph_kind, "KNN") + assert_true(result.clusters[0] != result.clusters[3]) +} + +///| +test "bluster: graph clustering is reproducible for a fixed seed" { + let config = @src.BlusterGraphConfig::create(k=1, seed=53) catch { + _ => abort("valid graph configuration should build") + } + let first = @src.bluster_cluster_rows_graph(bluster_test_two_groups(), config) catch { + _ => abort("first graph clustering should work") + } + let second = @src.bluster_cluster_rows_graph( + bluster_test_two_groups(), + config, + ) catch { + _ => abort("second graph clustering should work") + } + assert_eq(first.clusters, second.clusters) + assert_eq(first.modularity, second.modularity) +} + +///| +test "bluster: higher resolution does not coarsen this graph" { + let low = @src.BlusterGraphConfig::create(k=1, resolution=0.2, seed=59) catch { + _ => abort("low-resolution configuration should build") + } + let high = @src.BlusterGraphConfig::create(k=1, resolution=3.0, seed=59) catch { + _ => abort("high-resolution configuration should build") + } + let data = bluster_test_two_groups() + let low_result = @src.bluster_cluster_rows_graph(data, low) catch { + _ => abort("low-resolution clustering should work") + } + let high_result = @src.bluster_cluster_rows_graph(data, high) catch { + _ => abort("high-resolution clustering should work") + } + assert_true( + bluster_test_unique_count(high_result.clusters) >= + bluster_test_unique_count(low_result.clusters), + ) +} + +///| +test "bluster: a one-node graph remains one cluster" { + let config = @src.BlusterGraphConfig::create(k=10) catch { + _ => abort("valid graph configuration should build") + } + let result = @src.bluster_cluster_rows_graph([[1.0, 2.0]], config) catch { + _ => abort("one-node graph clustering should work") + } + assert_eq(result.clusters, [0]) + assert_eq(result.graph.k, 0) + assert_eq(result.modularity, 0.0) +} + +///| +test "bluster: two-step clustering maps centroid labels to observations" { + let config = @src.BlusterTwoStepConfig::create( + first_centers=4, + first_starts=4, + second_k=1, + resolution=0.5, + seed=61, + ) catch { + _ => abort("valid two-step configuration should build") + } + let data = [ + [0.0, 0.0], + [0.1, 0.0], + [0.2, 0.1], + [0.3, 0.1], + [10.0, 10.0], + [10.1, 10.0], + [10.2, 10.1], + [10.3, 10.1], + ] + let result = @src.bluster_cluster_rows_two_step(data, config) catch { + _ => abort("two-step clustering should work") + } + assert_eq(result.clusters.length(), data.length()) + assert_eq(result.centroids.length(), 4) + assert_eq(result.centroids, result.first.centers) + assert_eq(result.centroid_clusters.length(), 4) + for observation in 0.. abort("automatic two-step configuration should build") + } + let result = @src.bluster_cluster_rows_two_step( + [[0.0], [1.0], [2.0], [10.0], [11.0], [12.0], [20.0], [21.0], [22.0]], + config, + ) catch { + _ => abort("automatic two-step clustering should work") + } + assert_eq(result.centroids.length(), 3) +} + +///| +test "bluster: unadjusted pairwise Rand decomposes correct pairs" { + let result = @src.bluster_pairwise_rand( + [0, 0, 1, 1], + [0, 1, 0, 1], + adjusted=false, + ) catch { + _ => abort("pairwise Rand should work") + } + assert_eq(result.cluster_names, [0, 1]) + assert_eq(bluster_test_some(result.correct[0][0]), 0.0) + assert_eq(bluster_test_some(result.totals[0][0]), 1.0) + assert_eq(bluster_test_some(result.correct[0][1]), 2.0) + assert_eq(bluster_test_some(result.totals[0][1]), 4.0) + assert_true( + bluster_test_close(bluster_test_some(result.index), 1.0 / 3.0, 1.0e-12), + ) + assert_true(result.ratios[1][0] is None) +} + +///| +test "bluster: adjusted pairwise Rand matches the standard ARI" { + let result = @src.bluster_pairwise_rand([0, 0, 1, 1], [0, 1, 0, 1]) catch { + _ => abort("adjusted pairwise Rand should work") + } + assert_true( + bluster_test_close(bluster_test_some(result.index), -0.5, 1.0e-12), + ) + assert_true( + bluster_test_close(bluster_test_some(result.ratios[0][0]), -0.5, 1.0e-12), + ) + assert_true( + bluster_test_close(bluster_test_some(result.ratios[0][1]), -0.5, 1.0e-12), + ) +} + +///| +test "bluster: identical clusterings have Rand index one" { + let result = @src.bluster_pairwise_rand([2, 2, 5, 5, 9, 9], [2, 2, 5, 5, 9, 9]) catch { + _ => abort("identical pairwise Rand should work") + } + assert_true(bluster_test_close(bluster_test_some(result.index), 1.0, 1.0e-12)) + for right in 0.. abort("clustering comparison should work") + } + assert_eq(bluster_test_some(compared[0][0]), 1.0) + assert_eq(bluster_test_some(compared[2][2]), 1.0) + assert_eq(compared[0][1], compared[1][0]) + assert_eq(compared[0][2], compared[2][0]) + assert_eq(bluster_test_some(compared[0][2]), 1.0) +} + +///| +test "bluster: Rand and comparison validate equal lengths" { + let mut failures = 0 + ignore(@src.bluster_pairwise_rand([0], [0, 1])) catch { + _ => failures = failures + 1 + } + ignore(@src.bluster_compare_clusterings([[0], [0, 1]])) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "bluster: approximate silhouette is one for pure duplicates" { + let result = @src.bluster_approx_silhouette([[0.0], [0.0], [10.0], [10.0]], [ + 0, 0, 1, 1, + ]) catch { + _ => abort("silhouette approximation should work") + } + assert_eq(result.other_clusters, [1, 1, 0, 0]) + for width in result.widths { + assert_eq(width, 1.0) + } +} + +///| +test "bluster: approximate silhouette is zero for identical distributions" { + let result = @src.bluster_approx_silhouette([[0.0], [10.0], [0.0], [10.0]], [ + 0, 0, 1, 1, + ]) catch { + _ => abort("silhouette approximation should work") + } + for width in result.widths { + assert_true(bluster_test_close(width, 0.0, 1.0e-12)) + } +} + +///| +test "bluster: approximate silhouette handles one cluster" { + let result = @src.bluster_approx_silhouette([[0.0], [1.0], [2.0]], [7, 7, 7]) catch { + _ => abort("one-cluster silhouette should work") + } + assert_eq(result.other_clusters, [7, 7, 7]) + assert_eq(result.widths, [0.0, 0.0, 0.0]) +} + +///| +test "bluster: cluster RMSD uses sample variances" { + let result = @src.bluster_cluster_rmsd([[0.0], [2.0], [10.0]], [0, 0, 1]) catch { + _ => abort("cluster RMSD should work") + } + assert_eq(result.cluster_names, [0, 1]) + assert_true( + bluster_test_close(bluster_test_some(result.values[0]), 2.0.sqrt(), 1.0e-12), + ) + assert_true(result.values[1] is None) +} + +///| +test "bluster: cluster RMSD sum mode returns within-cluster sums" { + let result = @src.bluster_cluster_rmsd( + [[0.0], [2.0], [10.0], [14.0]], + [0, 0, 1, 1], + sum_squares=true, + ) catch { + _ => abort("cluster RMSD sum mode should work") + } + assert_eq(bluster_test_some(result.values[0]), 2.0) + assert_eq(bluster_test_some(result.values[1]), 8.0) +} + +///| +test "bluster: neighbor purity is one for separated duplicates" { + let result = @src.bluster_neighbor_purity( + [[0.0], [0.0], [10.0], [10.0]], + [0, 0, 1, 1], + k=1, + ) catch { + _ => abort("neighbor purity should work") + } + assert_eq(result.radius, 0.0) + assert_eq(result.purity, [1.0, 1.0, 1.0, 1.0]) + assert_eq(result.maximum_clusters, [0, 0, 1, 1]) +} + +///| +test "bluster: balanced purity removes cluster frequency effects" { + let result = @src.bluster_neighbor_purity( + [[0.0], [0.0], [0.0]], + [0, 0, 1], + k=1, + ) catch { + _ => abort("balanced neighbor purity should work") + } + assert_eq(result.purity, [0.5, 0.5, 0.5]) + assert_eq(result.maximum_clusters, [0, 0, 0]) +} + +///| +test "bluster: unbalanced purity retains cluster frequency effects" { + let result = @src.bluster_neighbor_purity( + [[0.0], [0.0], [0.0]], + [0, 0, 1], + k=1, + balanced=false, + ) catch { + _ => abort("unbalanced neighbor purity should work") + } + assert_true(bluster_test_close(result.purity[0], 2.0 / 3.0, 1.0e-12)) + assert_true(bluster_test_close(result.purity[2], 1.0 / 3.0, 1.0e-12)) +} + +///| +test "bluster: custom purity weights override frequency balancing" { + let result = @src.bluster_neighbor_purity( + [[0.0], [0.0], [0.0]], + [0, 0, 1], + k=1, + custom_weights=Some([1.0, 1.0, 2.0]), + ) catch { + _ => abort("custom-weight neighbor purity should work") + } + assert_eq(result.purity, [0.5, 0.5, 0.5]) +} + +///| +test "bluster: neighbor purity validates labels and custom weights" { + let mut failures = 0 + ignore(@src.bluster_neighbor_purity([[0.0]], [], k=1)) catch { + _ => failures = failures + 1 + } + ignore( + @src.bluster_neighbor_purity( + [[0.0], [1.0]], + [0, 1], + custom_weights=Some([1.0]), + ), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.bluster_neighbor_purity( + [[0.0], [1.0]], + [0, 1], + custom_weights=Some([1.0, -1.0]), + ), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "bluster: pairwise modularity decomposes observed and expected weights" { + let graph = @src.bluster_make_snn_graph([[0.0], [1.0], [10.0], [11.0]], k=1) catch { + _ => abort("SNN graph should build") + } + let result = @src.bluster_pairwise_modularity(graph, [0, 0, 1, 1]) catch { + _ => abort("pairwise modularity should work") + } + assert_true(bluster_test_close(result.total_weight, 1.0, 1.0e-12)) + assert_true( + bluster_test_close(bluster_test_some(result.observed[0][0]), 0.5, 1.0e-12), + ) + assert_eq(bluster_test_some(result.observed[0][1]), 0.0) + assert_true( + bluster_test_close(bluster_test_some(result.expected[0][0]), 0.25, 1.0e-12), + ) + assert_true( + bluster_test_close(bluster_test_some(result.expected[0][1]), 0.5, 1.0e-12), + ) + assert_true( + bluster_test_close( + bluster_test_some(result.modularity[0][0]), + 0.25, + 1.0e-12, + ), + ) + assert_eq(bluster_test_some(result.ratios[0][0]), 2.0) + assert_eq(bluster_test_some(result.ratios[0][1]), 0.0) +} + +///| +test "bluster: pairwise modularity upper triangle sums to zero" { + let graph = @src.bluster_make_knn_graph([[0.0], [1.0], [3.0], [10.0]], k=1) catch { + _ => abort("KNN graph should build") + } + let result = @src.bluster_pairwise_modularity(graph, [0, 0, 1, 1]) catch { + _ => abort("pairwise modularity should work") + } + let mut total = 0.0 + for right in 0.. abort("SNN graph should build") + } + let merged = @src.bluster_merge_communities(graph, [10, 11, 20, 21], 2) catch { + _ => abort("community merging should work") + } + assert_eq(bluster_test_unique_count(merged), 2) + assert_true(merged[0] == merged[1]) + assert_true(merged[2] == merged[3]) + assert_true(merged[0] != merged[2]) +} + +///| +test "bluster: community merging preserves labels when no merge is needed" { + let graph = @src.bluster_make_knn_graph([[0.0], [1.0], [10.0], [11.0]], k=1) catch { + _ => abort("KNN graph should build") + } + let labels = [10, 10, 20, 20] + let merged = @src.bluster_merge_communities(graph, labels, 5) catch { + _ => abort("no-op community merging should work") + } + assert_eq(merged, labels) +} + +///| +test "bluster: nested clusters identify perfect one-to-many mappings" { + let result = @src.bluster_nested_clusters([0, 0, 1, 1], [10, 11, 20, 20]) catch { + _ => abort("nested cluster mapping should work") + } + assert_eq(result.reference_names, [0, 1]) + assert_eq(result.alternative_names, [10, 11, 20]) + assert_eq(result.proportions[0], [1.0, 0.0]) + assert_eq(result.proportions[1], [1.0, 0.0]) + assert_eq(result.proportions[2], [0.0, 1.0]) + assert_eq(result.alternative_mapping, [0, 0, 1]) + assert_eq(result.alternative_maximum, [1.0, 1.0, 1.0]) + assert_eq(result.reference_scores, [1.0, 1.0]) +} + +///| +test "bluster: nested cluster mapping reports imperfect mixtures" { + let result = @src.bluster_nested_clusters([0, 0, 1, 1], [10, 10, 10, 10]) catch { + _ => abort("mixed nested cluster mapping should work") + } + assert_eq(result.proportions[0], [0.5, 0.5]) + assert_eq(result.alternative_mapping, [0]) + assert_eq(result.reference_scores, [0.5, 0.5]) +} + +///| +test "bluster: minimum link denominator favors nested clusters" { + let result = @src.bluster_link_clusters_matrix( + [0, 0, 1, 1], + [0, 1, 1, 1], + denominator=@src.bluster_link_minimum(), + ) catch { + _ => abort("minimum-denominator linking should work") + } + assert_eq(result, [[1.0, 0.5], [0.0, 1.0]]) +} + +///| +test "bluster: maximum link denominator requires similar sizes" { + let result = @src.bluster_link_clusters_matrix( + [0, 0, 1, 1], + [0, 1, 1, 1], + denominator=@src.bluster_link_maximum(), + ) catch { + _ => abort("maximum-denominator linking should work") + } + assert_true(bluster_test_close(result[0][0], 0.5, 1.0e-12)) + assert_true(bluster_test_close(result[0][1], 1.0 / 3.0, 1.0e-12)) + assert_true(bluster_test_close(result[1][1], 2.0 / 3.0, 1.0e-12)) +} + +///| +test "bluster: union link denominator computes Jaccard correspondence" { + let result = @src.bluster_link_clusters_matrix([0, 0, 1, 1], [0, 1, 1, 1]) catch { + _ => abort("union-denominator linking should work") + } + assert_true(bluster_test_close(result[0][0], 0.5, 1.0e-12)) + assert_true(bluster_test_close(result[0][1], 0.25, 1.0e-12)) + assert_true(bluster_test_close(result[1][1], 2.0 / 3.0, 1.0e-12)) +} + +///| +test "bluster: nested and linked mappings validate equal lengths" { + let mut failures = 0 + ignore(@src.bluster_nested_clusters([0], [0, 1])) catch { + _ => failures = failures + 1 + } + ignore(@src.bluster_link_clusters_matrix([0], [0, 1])) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "bluster: bootstrap k-means stability is reproducible" { + let config = @src.BlusterKmeansConfig::create(2, starts=4, seed=71) catch { + _ => abort("bootstrap k-means configuration should build") + } + let data = [[0.0], [0.1], [0.2], [0.3], [10.0], [10.1], [10.2], [10.3]] + let first = @src.bluster_bootstrap_kmeans_stability( + data, + config, + iterations=8, + seed=73, + ) catch { + _ => abort("first bootstrap stability run should work") + } + let second = @src.bluster_bootstrap_kmeans_stability( + data, + config, + iterations=8, + seed=73, + ) catch { + _ => abort("second bootstrap stability run should work") + } + assert_eq(first.cluster_names, [0, 1]) + assert_eq(first.ratios, second.ratios) + assert_eq(first.adjusted_indices, second.adjusted_indices) + assert_eq(first.adjusted_indices.length(), 8) + assert_true(bluster_test_some(first.ratios[0][0]) > 0.5) + assert_true(bluster_test_some(first.ratios[0][1]) > 0.5) + assert_true(bluster_test_some(first.ratios[1][1]) > 0.5) +} + +///| +test "bluster: bootstrap mean aggregation returns the full matrix shape" { + let config = @src.BlusterKmeansConfig::create(2, starts=3, seed=79) catch { + _ => abort("bootstrap k-means configuration should build") + } + let result = @src.bluster_bootstrap_kmeans_stability( + [[0.0], [0.1], [0.2], [10.0], [10.1], [10.2]], + config, + iterations=5, + use_mean=true, + seed=83, + ) catch { + _ => abort("mean bootstrap stability should work") + } + assert_eq(result.ratios.length(), 2) + assert_eq(result.ratios[0].length(), 2) + assert_true(result.ratios[1][0] is None) +} + +///| +test "bluster: bootstrap stability rejects non-positive iterations" { + let config = @src.BlusterKmeansConfig::create(2) catch { + _ => abort("valid k-means configuration should build") + } + let mut raised = false + ignore( + @src.bluster_bootstrap_kmeans_stability( + [[0.0], [1.0]], + config, + iterations=0, + ), + ) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "bluster: SCE clustering writes labels without mutating the input" { + let experiment = bluster_test_sce() + let config = @src.BlusterGraphConfig::create(k=1, resolution=0.5, seed=89) catch { + _ => abort("valid SCE graph configuration should build") + } + let result = @src.bluster_cluster_sce( + experiment, + config, + output_column="community", + ) catch { + _ => abort("SCE graph clustering should work") + } + assert_false(experiment.col_data.contains("community")) + assert_true(result.experiment.col_data.contains("community")) + assert_eq(result.experiment.col_data["community"].length(), 4) + assert_eq(result.experiment.metadata["bluster.reduced_dim"], "PCA") + assert_eq(result.experiment.metadata["bluster.graph"], "SNN") + assert_eq(result.clustering.clusters.length(), 4) +} + +///| +test "bluster: SCE clustering deep-copies nested containers" { + let experiment = bluster_test_sce() + let config = @src.BlusterGraphConfig::create(k=1, seed=97) catch { + _ => abort("valid SCE graph configuration should build") + } + let result = @src.bluster_cluster_sce(experiment, config) catch { + _ => abort("SCE graph clustering should work") + } + result.experiment.assays["counts"][0][0] = 999.0 + result.experiment.row_data["symbol"][0] = "changed" + result.experiment.reduced_dims["PCA"][0][0] = 999.0 + result.experiment.alternative_experiments["spike"].assays["counts"][0][0] = 999.0 + assert_eq(experiment.assays["counts"][0][0], 1.0) + assert_eq(experiment.row_data["symbol"][0], "A") + assert_eq(experiment.reduced_dims["PCA"][0][0], 0.0) + assert_eq( + experiment.alternative_experiments["spike"].assays["counts"][0][0], + 5.0, + ) +} + +///| +test "bluster: SCE clustering validates reduced dimensions" { + let config = @src.BlusterGraphConfig::create(k=1) catch { + _ => abort("valid SCE graph configuration should build") + } + let missing = @src.SingleCellExperiment::new([[1.0, 2.0]], ["G1"], [ + "C1", "C2", + ]) + let mut failures = 0 + ignore(@src.bluster_cluster_sce(missing, config)) catch { + _ => failures = failures + 1 + } + missing.reduced_dims["PCA"] = [[0.0]] + ignore(@src.bluster_cluster_sce(missing, config)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} diff --git a/test/moonbit/droplet_utils_advanced_test.mbt b/test/moonbit/droplet_utils_advanced_test.mbt new file mode 100644 index 00000000..dad9f1ad --- /dev/null +++ b/test/moonbit/droplet_utils_advanced_test.mbt @@ -0,0 +1,1017 @@ +///| +fn dua_test_small_data() -> @src.DropletCountMatrix { + @src.DropletCountMatrix::create( + [ + [3, 2, 4, 3, 2, 3, 20, 18], + [2, 3, 1, 2, 3, 4, 0, 0], + [0, 0, 0, 0, 0, 0, 15, 0], + [0, 0, 0, 0, 0, 0, 0, 15], + ], + feature_names=["ambient_a", "ambient_b", "marker_a", "marker_b"], + barcodes=[ + "empty_1", "empty_2", "empty_3", "empty_4", "empty_5", "empty_6", "cell_a", + "cell_b", + ], + ) catch { + _ => abort("valid DropletUtils test data should build") + } +} + +///| +fn dua_test_config() -> @src.DropletUtilsConfig { + @src.DropletUtilsConfig::create( + lower=5, + iterations=199, + fdr_threshold=0.1, + retain=30.0, + rank_exclude=0, + rank_window=0.25, + seed=23, + ) catch { + _ => abort("valid DropletUtils configuration should build") + } +} + +///| +fn dua_test_result() -> @src.DropletEmptyDropsResult { + @src.droplet_utils_empty_drops( + dua_test_small_data(), + config=dua_test_config(), + ) catch { + _ => abort("valid DropletUtils workflow should run") + } +} + +///| +fn dua_test_sce() -> @src.SingleCellExperiment { + let data = dua_test_small_data() + let assay : Array[Array[Double]] = [] + for feature in 0.. abort("valid matrix should build") + } + assert_eq(data.feature_names, ["feature1", "feature2"]) + assert_eq(data.barcodes, ["barcode1", "barcode2"]) + assert_eq(data.n_features(), 2) + assert_eq(data.n_barcodes(), 2) +} + +///| +test "DropletUtils advanced constructor copies matrix and names" { + let counts = [[1, 2], [3, 4]] + let features = ["g1", "g2"] + let barcodes = ["b1", "b2"] + let data = @src.DropletCountMatrix::create( + counts, + feature_names=features, + barcodes~, + ) catch { + _ => abort("valid matrix should build") + } + counts[0][0] = 99 + features[0] = "changed" + barcodes[0] = "changed" + assert_eq(data.counts[0][0], 1) + assert_eq(data.feature_names[0], "g1") + assert_eq(data.barcodes[0], "b1") +} + +///| +test "DropletUtils advanced copy_counts is defensive" { + let data = dua_test_small_data() + let copied = data.copy_counts() + copied[0][0] = 999 + assert_eq(data.counts[0][0], 3) +} + +///| +test "DropletUtils advanced computes feature and barcode totals" { + let data = dua_test_small_data() + assert_eq(data.barcode_totals(), [5, 5, 5, 5, 5, 7, 35, 33]) + assert_eq(data.feature_totals(), [55, 15, 15, 15]) +} + +///| +test "DropletUtils advanced rejects an empty matrix" { + let raised = try { + ignore(@src.DropletCountMatrix::create([])) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "DropletUtils advanced rejects an empty barcode dimension" { + let raised = try { + ignore(@src.DropletCountMatrix::create([[]])) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "DropletUtils advanced rejects ragged matrices" { + let raised = try { + ignore(@src.DropletCountMatrix::create([[1, 2], [3]])) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "DropletUtils advanced rejects negative counts" { + let raised = try { + ignore(@src.DropletCountMatrix::create([[1, -1], [3, 4]])) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "DropletUtils advanced validates identifier lengths" { + let raised = try { + ignore( + @src.DropletCountMatrix::create([[1, 2], [3, 4]], feature_names=["g1"], barcodes=[ + "b1", "b2", + ]), + ) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "DropletUtils advanced rejects empty and duplicate identifiers" { + let empty = try { + ignore( + @src.DropletCountMatrix::create([[1, 2], [3, 4]], feature_names=["g1", ""]), + ) + false + } catch { + _ => true + } + let duplicate = try { + ignore( + @src.DropletCountMatrix::create([[1, 2], [3, 4]], barcodes=["b1", "b1"]), + ) + false + } catch { + _ => true + } + assert_true(empty && duplicate) +} + +///| +test "DropletUtils advanced default configuration matches portable workflow" { + let config = @src.DropletUtilsConfig::default() + assert_eq(config.lower, 100) + assert_eq(config.iterations, 10000) + assert_eq(config.fdr_threshold, 0.001) + assert_eq(config.retain, -1.0) + assert_eq(config.by_rank, 0) + assert_eq(config.ignore, -1) + assert_eq(config.alpha, -1.0) + assert_eq(config.estimate_alpha, false) + assert_eq(config.seed, 1) +} + +///| +test "DropletUtils advanced configuration preserves explicit options" { + let config = @src.DropletUtilsConfig::create( + lower=12, + iterations=75, + fdr_threshold=0.2, + retain=50.0, + by_rank=3, + ignore=2, + test_ambient=true, + alpha=4.0, + estimate_alpha=true, + rank_exclude=2, + rank_window=0.5, + gradient_threshold=-0.5, + round_counts=false, + seed=19, + ) catch { + _ => abort("valid explicit configuration should build") + } + assert_eq(config.lower, 12) + assert_eq(config.alpha, 4.0) + assert_true(config.test_ambient && config.estimate_alpha) + assert_eq(config.round_counts, false) + assert_eq(config.seed, 19) +} + +///| +test "DropletUtils advanced rejects invalid count thresholds" { + let lower = try { + ignore(@src.DropletUtilsConfig::create(lower=-1)) + false + } catch { + _ => true + } + let iterations = try { + ignore(@src.DropletUtilsConfig::create(iterations=0)) + false + } catch { + _ => true + } + let by_rank = try { + ignore(@src.DropletUtilsConfig::create(by_rank=-1)) + false + } catch { + _ => true + } + let ignore_value = try { + ignore(@src.DropletUtilsConfig::create(ignore=-2)) + false + } catch { + _ => true + } + assert_true(lower && iterations && by_rank && ignore_value) +} + +///| +test "DropletUtils advanced rejects invalid probability configuration" { + let fdr = try { + ignore(@src.DropletUtilsConfig::create(fdr_threshold=1.1)) + false + } catch { + _ => true + } + let retain = try { + ignore(@src.DropletUtilsConfig::create(retain=0.0)) + false + } catch { + _ => true + } + let alpha = try { + ignore(@src.DropletUtilsConfig::create(alpha=0.0)) + false + } catch { + _ => true + } + let seed = try { + ignore(@src.DropletUtilsConfig::create(seed=0)) + false + } catch { + _ => true + } + assert_true(fdr && retain && alpha && seed) +} + +///| +test "DropletUtils advanced Good-Turing profile is normalized and positive" { + let profile = @src.droplet_utils_good_turing([1, 1, 2, 3, 0, 0]) catch { + _ => abort("Good-Turing profile should fit") + } + let mut total = 0.0 + for value in profile { + assert_true(value > 0.0) + total = total + value + } + assert_true((total - 1.0).abs() < 1.0e-10) + assert_true((profile[0] - profile[1]).abs() < 1.0e-12) + assert_true((profile[4] - profile[5]).abs() < 1.0e-12) +} + +///| +test "DropletUtils advanced Good-Turing protects unobserved active features" { + let profile = @src.droplet_utils_good_turing([17, 15, 0, 0]) catch { + _ => abort("safe Good-Turing profile should fit") + } + assert_true(profile[2] > 0.0) + assert_true(profile[3] > 0.0) + assert_true((profile[2] - profile[3]).abs() < 1.0e-12) +} + +///| +test "DropletUtils advanced Good-Turing rejects invalid inputs" { + let empty = try { + ignore(@src.droplet_utils_good_turing([])) + false + } catch { + _ => true + } + let all_zero = try { + ignore(@src.droplet_utils_good_turing([0, 0])) + false + } catch { + _ => true + } + let negative = try { + ignore(@src.droplet_utils_good_turing([1, -1])) + false + } catch { + _ => true + } + assert_true(empty && all_zero && negative) +} + +///| +test "DropletUtils advanced ambient profile uses lower threshold" { + let ambient = @src.droplet_utils_ambient_profile( + dua_test_small_data(), + lower=5, + ) catch { + _ => abort("ambient profile should fit") + } + assert_eq(ambient.assumed_empty, [ + true, true, true, true, true, false, false, false, + ]) + assert_eq(ambient.n_empty(), 5) + assert_eq(ambient.total, 25) + assert_eq(ambient.raw_counts, [14, 11, 0, 0]) +} + +///| +test "DropletUtils advanced ambient profile honors known-empty mask" { + let mask = [true, false, true, false, true, false, false, false] + let ambient = @src.droplet_utils_ambient_profile( + dua_test_small_data(), + lower=0, + known_empty=mask, + ) catch { + _ => abort("known-empty ambient profile should fit") + } + assert_eq(ambient.assumed_empty, mask) + assert_eq(ambient.n_empty(), 3) + assert_eq(ambient.total, 15) +} + +///| +test "DropletUtils advanced ambient profile supports by-rank selection" { + let data = @src.DropletCountMatrix::create([[50, 40, 30, 20, 10]], barcodes=[ + "b1", "b2", "b3", "b4", "b5", + ]) catch { + _ => abort("valid rank data should build") + } + let ambient = @src.droplet_utils_ambient_profile(data, by_rank=2) catch { + _ => abort("by-rank ambient profile should fit") + } + assert_eq(ambient.assumed_empty, [false, false, true, true, true]) + assert_eq(ambient.lower, 30) + assert_eq(ambient.total, 60) +} + +///| +test "DropletUtils advanced ambient profile rejects invalid masks" { + let wrong_length = try { + ignore( + @src.droplet_utils_ambient_profile(dua_test_small_data(), known_empty=[ + true, + ]), + ) + false + } catch { + _ => true + } + let none_selected = try { + ignore( + @src.droplet_utils_ambient_profile( + dua_test_small_data(), + known_empty=Array::make(8, false), + ), + ) + false + } catch { + _ => true + } + assert_true(wrong_length && none_selected) +} + +///| +test "DropletUtils advanced ambient profile rejects empty ambient counts" { + let raised = try { + ignore(@src.droplet_utils_ambient_profile(dua_test_small_data(), lower=0)) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "DropletUtils advanced barcode ranks average ties" { + let data = @src.DropletCountMatrix::create([[100, 100, 60, 60, 30, 15, 7, 3]]) catch { + _ => abort("valid rank data should build") + } + let ranks = @src.droplet_utils_barcode_ranks( + data, + lower=0, + exclude_from=0, + window=0.2, + ) catch { + _ => abort("barcode ranks should fit") + } + assert_eq(ranks.ranks[0], 1.5) + assert_eq(ranks.ranks[1], 1.5) + assert_eq(ranks.ranks[2], 3.5) + assert_eq(ranks.ranks[3], 3.5) +} + +///| +test "DropletUtils advanced barcode ranks return finite knees" { + let data = @src.DropletCountMatrix::create([ + [1000, 800, 600, 350, 180, 90, 45, 20, 8, 3], + ]) catch { + _ => abort("valid rank curve should build") + } + let ranks = @src.droplet_utils_barcode_ranks( + data, + lower=0, + exclude_from=0, + window=0.25, + ) catch { + _ => abort("barcode-rank curve should fit") + } + assert_true(ranks.knee > 0.0 && ranks.knee <= 1000.0) + assert_true(ranks.inflection > 0.0 && ranks.inflection <= 1000.0) + assert_eq(ranks.totals[0], 1000) +} + +///| +test "DropletUtils advanced barcode ranks reject insufficient curves" { + let data = @src.DropletCountMatrix::create([[10, 10, 10]]) catch { + _ => abort("valid tied rank data should build") + } + let raised = try { + ignore( + @src.droplet_utils_barcode_ranks( + data, + lower=0, + exclude_from=0, + window=0.2, + ), + ) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "DropletUtils advanced multinomial log probability is exact" { + let value = @src.droplet_utils_log_probability([2, 1], [0.25, 0.75]) catch { + _ => abort("multinomial probability should compute") + } + assert_true((@math.exp(value) - 0.140625).abs() < 1.0e-10) +} + +///| +test "DropletUtils advanced Dirichlet-multinomial probability is exact" { + let value = @src.droplet_utils_log_probability([1, 1], [0.5, 0.5], alpha=2.0) catch { + _ => abort("Dirichlet-multinomial probability should compute") + } + assert_true((@math.exp(value) - 1.0 / 3.0).abs() < 1.0e-10) +} + +///| +test "DropletUtils advanced multinomial and overdispersed models differ" { + let multinomial = @src.droplet_utils_log_probability([5, 0], [0.5, 0.5]) catch { + _ => abort("multinomial probability should compute") + } + let overdispersed = @src.droplet_utils_log_probability( + [5, 0], + [0.5, 0.5], + alpha=2.0, + ) catch { + _ => abort("Dirichlet-multinomial probability should compute") + } + assert_true(overdispersed > multinomial) +} + +///| +test "DropletUtils advanced probability validates dimensions and counts" { + let dimensions = try { + ignore(@src.droplet_utils_log_probability([1], [0.5, 0.5])) + false + } catch { + _ => true + } + let negative = try { + ignore(@src.droplet_utils_log_probability([-1, 2], [0.5, 0.5])) + false + } catch { + _ => true + } + assert_true(dimensions && negative) +} + +///| +test "DropletUtils advanced probability validates ambient proportions" { + let sum = try { + ignore(@src.droplet_utils_log_probability([1, 1], [0.4, 0.4])) + false + } catch { + _ => true + } + let negative = try { + ignore(@src.droplet_utils_log_probability([1, 1], [-0.1, 1.1])) + false + } catch { + _ => true + } + let impossible = try { + ignore(@src.droplet_utils_log_probability([1, 0], [0.0, 1.0])) + false + } catch { + _ => true + } + assert_true(sum && negative && impossible) +} + +///| +test "DropletUtils advanced Monte Carlo p-value is reproducible" { + let first = @src.droplet_utils_monte_carlo_p_value( + [8, 2], + [0.5, 0.5], + iterations=199, + seed=17, + ) catch { + _ => abort("Monte Carlo test should run") + } + let second = @src.droplet_utils_monte_carlo_p_value( + [8, 2], + [0.5, 0.5], + iterations=199, + seed=17, + ) catch { + _ => abort("Monte Carlo test should repeat") + } + assert_eq(first, second) + assert_true(first.0 >= 1.0 / 200.0 && first.0 <= 1.0) +} + +///| +test "DropletUtils advanced Monte Carlo uses Phipson-Smyth correction" { + let result = @src.droplet_utils_monte_carlo_p_value( + [30, 0], + [0.5, 0.5], + iterations=99, + seed=5, + ) catch { + _ => abort("extreme Monte Carlo test should run") + } + assert_eq(result.1, true) + assert_true((result.0 - 0.01).abs() < 1.0e-12) +} + +///| +test "DropletUtils advanced Monte Carlo supports Dirichlet-multinomial null" { + let result = @src.droplet_utils_monte_carlo_p_value( + [7, 3], + [0.5, 0.5], + iterations=99, + alpha=3.0, + seed=7, + ) catch { + _ => abort("Dirichlet-multinomial Monte Carlo test should run") + } + assert_true(result.0 >= 0.01 && result.0 <= 1.0) +} + +///| +test "DropletUtils advanced Monte Carlo rejects invalid controls" { + let iterations = try { + ignore( + @src.droplet_utils_monte_carlo_p_value([1, 1], [0.5, 0.5], iterations=0), + ) + false + } catch { + _ => true + } + let zero_total = try { + ignore(@src.droplet_utils_monte_carlo_p_value([0, 0], [0.5, 0.5])) + false + } catch { + _ => true + } + assert_true(iterations && zero_total) +} + +///| +test "DropletUtils advanced alpha estimation is finite and positive" { + let data = dua_test_small_data() + let ambient = @src.droplet_utils_ambient_profile(data, lower=5) catch { + _ => abort("ambient profile should fit") + } + let alpha = @src.droplet_utils_estimate_alpha(data, ambient) catch { + _ => abort("alpha should fit") + } + assert_true(alpha >= 0.01 && alpha <= 10000.0) + assert_true(alpha == alpha && alpha.abs() < 1.0e300) +} + +///| +test "DropletUtils advanced alpha estimation validates dimensions" { + let ambient = @src.droplet_utils_ambient_profile( + dua_test_small_data(), + lower=5, + ) catch { + _ => abort("ambient profile should fit") + } + let mismatched = @src.DropletCountMatrix::create([[1, 2]]) catch { + _ => abort("mismatched matrix should build") + } + let raised = try { + ignore(@src.droplet_utils_estimate_alpha(mismatched, ambient)) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "DropletUtils advanced emptyDrops preserves upstream NA semantics" { + let result = dua_test_result() + for barcode in 0..<5 { + assert_true(result.p_values[barcode] is None) + assert_true(result.log_probabilities[barcode] is None) + assert_true(result.limited[barcode] is None) + assert_true(result.fdr[barcode] is None) + } + assert_true(result.p_values[5] is Some(_)) + assert_true(result.p_values[6] is Some(_)) + assert_true(result.p_values[7] is Some(_)) +} + +///| +test "DropletUtils advanced emptyDrops retains high-count barcodes" { + let result = dua_test_result() + assert_eq(result.always_retained, [ + false, false, false, false, false, false, true, true, + ]) + assert_eq(result.calls[6], true) + assert_eq(result.calls[7], true) + match result.fdr[6] { + Some(value) => assert_eq(value, 0.0) + None => abort("retained barcode should have FDR") + } +} + +///| +test "DropletUtils advanced emptyDrops records Limited flags" { + let result = dua_test_result() + match result.limited[6] { + Some(value) => assert_eq(value, true) + None => abort("tested barcode should have Limited flag") + } + match result.p_values[6] { + Some(value) => assert_true(value >= 1.0 / 200.0 && value <= 1.0) + None => abort("tested barcode should have p-value") + } +} + +///| +test "DropletUtils advanced emptyDrops reports model diagnostics" { + let result = dua_test_result() + assert_eq(result.lower, 5) + assert_eq(result.retain, 30.0) + assert_eq(result.alpha, -1.0) + assert_eq(result.alpha_estimated, false) + assert_eq(result.iterations, 199) + assert_eq(result.fdr_threshold, 0.1) + assert_eq(result.ambient.n_empty(), 5) +} + +///| +test "DropletUtils advanced emptyDrops supports ambient diagnostics" { + let config = @src.DropletUtilsConfig::create( + lower=5, + iterations=49, + fdr_threshold=0.2, + retain=30.0, + test_ambient=true, + seed=11, + ) catch { + _ => abort("diagnostic configuration should build") + } + let result = @src.droplet_utils_empty_drops(dua_test_small_data(), config~) catch { + _ => abort("diagnostic workflow should run") + } + assert_eq(result.n_tested(), 8) + assert_true(result.p_values[0] is Some(_)) + assert_true(result.fdr[0] is None) + assert_eq(result.calls[0], false) +} + +///| +test "DropletUtils advanced emptyDrops supports ignore threshold" { + let config = @src.DropletUtilsConfig::create( + lower=5, + iterations=49, + fdr_threshold=0.2, + retain=100.0, + ignore=33, + seed=11, + ) catch { + _ => abort("ignore configuration should build") + } + let result = @src.droplet_utils_empty_drops(dua_test_small_data(), config~) catch { + _ => abort("ignore workflow should run") + } + assert_eq(result.n_tested(), 1) + assert_true(result.p_values[6] is Some(_)) + assert_true(result.p_values[7] is None) +} + +///| +test "DropletUtils advanced emptyDrops supports alpha estimation" { + let config = @src.DropletUtilsConfig::create( + lower=5, + iterations=29, + fdr_threshold=0.2, + retain=30.0, + estimate_alpha=true, + seed=13, + ) catch { + _ => abort("estimated-alpha configuration should build") + } + let result = @src.droplet_utils_empty_drops(dua_test_small_data(), config~) catch { + _ => abort("estimated-alpha workflow should run") + } + assert_eq(result.alpha_estimated, true) + assert_true(result.alpha > 0.0) +} + +///| +test "DropletUtils advanced emptyDrops supports known-empty droplets" { + let mask = [true, true, true, true, true, false, false, false] + let result = @src.droplet_utils_empty_drops( + dua_test_small_data(), + known_empty=mask, + config=dua_test_config(), + ) catch { + _ => abort("known-empty workflow should run") + } + assert_eq(result.ambient.assumed_empty, mask) + assert_eq(result.ambient.n_empty(), 5) +} + +///| +test "DropletUtils advanced emptyDrops computes automatic knee retention" { + let data = @src.droplet_utils_advanced_example() catch { + _ => abort("advanced example should build") + } + let config = @src.DropletUtilsConfig::create( + lower=15, + iterations=19, + fdr_threshold=0.2, + rank_exclude=0, + rank_window=0.2, + seed=3, + ) catch { + _ => abort("automatic-retain configuration should build") + } + let result = @src.droplet_utils_empty_drops(data, config~) catch { + _ => abort("automatic-retain workflow should run") + } + assert_true(result.retain > 0.0) + let mut retained = 0 + for value in result.always_retained { + if value { + retained = retained + 1 + } + } + assert_true(retained > 0 && retained < data.n_barcodes()) +} + +///| +test "DropletUtils advanced result query helpers are consistent" { + let result = dua_test_result() + assert_eq(result.n_called(), 2) + assert_eq(result.n_tested(), 3) + assert_eq(result.index_of("cell_a"), Some(6)) + assert_eq(result.index_of("missing"), None) + assert_eq(result.called_barcodes(), ["cell_a", "cell_b"]) + assert_true(result.summary().has_prefix("DropletUtils emptyDrops:")) +} + +///| +test "DropletUtils advanced result filters called barcodes" { + let filtered = dua_test_result().filter(dua_test_small_data()) catch { + _ => abort("called barcodes should filter") + } + assert_eq(filtered.n_features(), 4) + assert_eq(filtered.n_barcodes(), 2) + assert_eq(filtered.barcodes, ["cell_a", "cell_b"]) + assert_eq(filtered.barcode_totals(), [35, 33]) +} + +///| +test "DropletUtils advanced result rejects mismatched filtering data" { + let other = @src.DropletCountMatrix::create( + [[1, 2], [3, 4]], + feature_names=["g1", "g2"], + barcodes=["x", "y"], + ) catch { + _ => abort("other matrix should build") + } + let raised = try { + ignore(dua_test_result().filter(other)) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "DropletUtils advanced example has ambient and cell populations" { + let data = @src.droplet_utils_advanced_example() catch { + _ => abort("advanced example should build") + } + assert_eq(data.n_features(), 12) + assert_eq(data.n_barcodes(), 64) + let totals = data.barcode_totals() + assert_true(totals[0] < 20) + assert_true(totals[40] > 80) + assert_true(totals[52] > 80) +} + +///| +test "DropletUtils advanced SingleCellExperiment writes result columns" { + let output = @src.droplet_utils_empty_drops_sce( + dua_test_sce(), + output_prefix="droplet", + config=dua_test_config(), + ) catch { + _ => abort("SingleCellExperiment workflow should run") + } + assert_true(output.experiment.col_data.contains("droplet.total")) + assert_true(output.experiment.col_data.contains("droplet.pValue")) + assert_true(output.experiment.col_data.contains("droplet.limited")) + assert_true(output.experiment.col_data.contains("droplet.fdr")) + assert_true(output.experiment.col_data.contains("droplet.class")) + assert_true(output.experiment.col_data.contains("droplet.retained")) + assert_eq(output.experiment.col_data["droplet.class"][6], "cell") +} + +///| +test "DropletUtils advanced SingleCellExperiment writes ambient rows and metadata" { + let output = @src.droplet_utils_empty_drops_sce( + dua_test_sce(), + output_prefix="droplet", + config=dua_test_config(), + ) catch { + _ => abort("SingleCellExperiment workflow should run") + } + assert_eq(output.experiment.row_data["droplet.ambient"].length(), 4) + assert_eq(output.experiment.row_data["droplet.ambientCount"].length(), 4) + assert_eq(output.experiment.metadata["droplet.lower"], "5") + assert_eq(output.experiment.metadata["droplet.called"], "2") +} + +///| +test "DropletUtils advanced SingleCellExperiment does not mutate input" { + let input = dua_test_sce() + let output = @src.droplet_utils_empty_drops_sce( + input, + output_prefix="droplet", + config=dua_test_config(), + ) catch { + _ => abort("SingleCellExperiment workflow should run") + } + assert_eq(input.col_data.contains("droplet.class"), false) + output.experiment.assays["counts"][0][0] = 999.0 + assert_eq(input.assays["counts"][0][0], 3.0) +} + +///| +test "DropletUtils advanced SingleCellExperiment parses known-empty column" { + let input = dua_test_sce() + input.col_data["known"] = [ + "empty", "empty", "empty", "empty", "empty", "cell", "cell", "cell", + ] + let output = @src.droplet_utils_empty_drops_sce( + input, + known_empty_column="known", + config=dua_test_config(), + ) catch { + _ => abort("known-empty SingleCellExperiment workflow should run") + } + assert_eq(output.result.ambient.n_empty(), 5) + assert_eq(output.result.ambient.assumed_empty[5], false) +} + +///| +test "DropletUtils advanced SingleCellExperiment rounds counts by default" { + let input = dua_test_sce() + input.assays["counts"][0][0] = 3.4 + let output = @src.droplet_utils_empty_drops_sce( + input, + config=dua_test_config(), + ) catch { + _ => abort("rounded SingleCellExperiment workflow should run") + } + assert_eq(output.result.totals[0], 5) +} + +///| +test "DropletUtils advanced SingleCellExperiment can require integer counts" { + let input = dua_test_sce() + input.assays["counts"][0][0] = 3.4 + let config = @src.DropletUtilsConfig::create( + lower=5, + iterations=19, + fdr_threshold=0.2, + retain=30.0, + round_counts=false, + ) catch { + _ => abort("strict integer configuration should build") + } + let raised = try { + ignore(@src.droplet_utils_empty_drops_sce(input, config~)) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "DropletUtils advanced SingleCellExperiment rejects missing assay" { + let raised = try { + ignore( + @src.droplet_utils_empty_drops_sce( + dua_test_sce(), + assay_name="missing", + config=dua_test_config(), + ), + ) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "DropletUtils advanced SingleCellExperiment validates known-empty values" { + let input = dua_test_sce() + input.col_data["known"] = [ + "empty", "empty", "empty", "empty", "empty", "unknown", "cell", "cell", + ] + let raised = try { + ignore( + @src.droplet_utils_empty_drops_sce( + input, + known_empty_column="known", + config=dua_test_config(), + ), + ) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "DropletUtils advanced SingleCellExperiment validates assay values" { + let negative = dua_test_sce() + negative.assays["counts"][0][0] = -1.0 + let negative_raised = try { + ignore( + @src.droplet_utils_empty_drops_sce(negative, config=dua_test_config()), + ) + false + } catch { + _ => true + } + let non_finite = dua_test_sce() + non_finite.assays["counts"][0][0] = Double::nan() + let finite_raised = try { + ignore( + @src.droplet_utils_empty_drops_sce(non_finite, config=dua_test_config()), + ) + false + } catch { + _ => true + } + assert_true(negative_raised && finite_raised) +} diff --git a/test/moonbit/flowsom_test.mbt b/test/moonbit/flowsom_test.mbt new file mode 100644 index 00000000..b7689a57 --- /dev/null +++ b/test/moonbit/flowsom_test.mbt @@ -0,0 +1,1188 @@ +///| +fn flowsom_test_close( + left : Double, + right : Double, + tolerance : Double, +) -> Bool { + (left - right).abs() <= tolerance +} + +///| +fn flowsom_test_some(value : Double?) -> Double { + match value { + Some(actual) => actual + None => abort("expected a numeric value") + } +} + +///| +fn flowsom_test_unique_count(values : Array[Int]) -> Int { + let unique : Array[Int] = [] + for value in values { + if !unique.contains(value) { + unique.push(value) + } + } + unique.length() +} + +///| +fn flowsom_test_sum(values : Array[Int]) -> Int { + let mut total = 0 + for value in values { + total = total + value + } + total +} + +///| +fn flowsom_test_data() -> Array[Array[Double]] { + [ + [0.0, 0.0], + [0.1, 0.2], + [0.2, 0.1], + [0.3, 0.2], + [9.8, 10.0], + [10.0, 9.9], + [10.1, 10.2], + [10.3, 10.1], + ] +} + +///| +fn flowsom_test_config( + metaclusters? : Int = 0, + seed? : Int = 31, +) -> @src.FlowSomConfig { + @src.FlowSomConfig::create( + xdim=2, + ydim=2, + rlen=3, + mst_runs=2, + alpha_start=0.1, + alpha_end=0.02, + radius_start=1.0, + radius_end=0.0, + metaclusters~, + meta_starts=3, + seed~, + ) catch { + _ => abort("valid FlowSOM test configuration should build") + } +} + +///| +fn flowsom_test_model( + metaclusters? : Int = 0, + seed? : Int = 31, +) -> @src.FlowSomModel { + @src.flowsom_train( + flowsom_test_data(), + flowsom_test_config(metaclusters~, seed~), + marker_names=["CD3", "CD19"], + ) catch { + _ => abort("valid FlowSOM test model should train") + } +} + +///| +fn flowsom_test_one_node_model(metaclusters? : Int = 0) -> @src.FlowSomModel { + let config = @src.FlowSomConfig::create( + xdim=1, + ydim=1, + rlen=2, + alpha_start=0.1, + alpha_end=0.02, + radius_start=0.0, + radius_end=0.0, + metaclusters~, + seed=41, + ) catch { + _ => abort("valid one-node FlowSOM configuration should build") + } + @src.flowsom_train([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], config, marker_names=[ + "A", "B", + ]) catch { + _ => abort("valid one-node FlowSOM model should train") + } +} + +///| +fn flowsom_test_sce() -> @src.SingleCellExperiment { + let experiment = @src.SingleCellExperiment::new( + [ + [0.0, 0.1, 0.2, 10.0, 10.1, 10.2], + [1.0, 1.1, 1.2, 11.0, 11.1, 11.2], + [2.0, 2.1, 2.2, 12.0, 12.1, 12.2], + ], + ["CD3", "CD19", "CD45"], + ["C1", "C2", "C3", "C4", "C5", "C6"], + ) + experiment.row_data["symbol"] = ["T", "B", "pan"] + experiment.col_data["batch"] = ["A", "A", "A", "B", "B", "B"] + experiment.reduced_dims["PCA"] = [ + [0.0, 0.0], + [0.1, 0.0], + [0.2, 0.1], + [10.0, 10.0], + [10.1, 10.0], + [10.2, 10.1], + ] + experiment.metadata["project"] = "flowsom-test" + experiment.alternative_experiments["spike"] = @src.SingleCellExperiment::new( + [[5.0, 6.0, 7.0, 8.0, 9.0, 10.0]], + ["Spike1"], + ["C1", "C2", "C3", "C4", "C5", "C6"], + ) + experiment +} + +///| +test "FlowSOM: distance and initialization accessors expose enum values" { + assert_true( + @src.flowsom_manhattan_distance() != @src.flowsom_euclidean_distance(), + ) + assert_true( + @src.flowsom_euclidean_distance() != @src.flowsom_chebyshev_distance(), + ) + assert_true( + @src.flowsom_chebyshev_distance() != @src.flowsom_cosine_distance(), + ) + assert_true( + @src.flowsom_random_initialization() != @src.flowsom_kwsp_initialization(), + ) + assert_true( + @src.flowsom_kwsp_initialization() != @src.flowsom_pca_initialization(), + ) +} + +///| +test "FlowSOM: configuration defaults match the upstream workflow" { + let config = @src.FlowSomConfig::create() catch { + _ => abort("default FlowSOM configuration should build") + } + assert_eq(config.xdim, 10) + assert_eq(config.ydim, 10) + assert_eq(config.rlen, 10) + assert_eq(config.mst_runs, 1) + assert_eq(config.alpha_start, 0.05) + assert_eq(config.alpha_end, 0.01) + assert_eq(config.radius_start, -1.0) + assert_eq(config.radius_end, 0.0) + assert_true(config.distance == @src.flowsom_euclidean_distance()) + assert_true(config.initialization == @src.flowsom_kwsp_initialization()) + assert_eq(config.metaclusters, 0) + assert_eq(config.seed, 1) +} + +///| +test "FlowSOM: configuration preserves explicit controls" { + let config = @src.FlowSomConfig::create( + xdim=3, + ydim=2, + rlen=7, + mst_runs=3, + alpha_start=0.2, + alpha_end=0.03, + radius_start=2.0, + radius_end=0.5, + distance=@src.flowsom_cosine_distance(), + initialization=@src.flowsom_pca_initialization(), + importance=[2.0, 0.5], + metaclusters=3, + meta_starts=4, + outlier_mad=2.5, + seed=17, + ) catch { + _ => abort("explicit FlowSOM configuration should build") + } + assert_eq(config.xdim, 3) + assert_eq(config.ydim, 2) + assert_eq(config.rlen, 7) + assert_eq(config.mst_runs, 3) + assert_eq(config.importance, [2.0, 0.5]) + assert_eq(config.metaclusters, 3) + assert_eq(config.meta_starts, 4) + assert_eq(config.outlier_mad, 2.5) + assert_eq(config.seed, 17) +} + +///| +test "FlowSOM: configuration rejects invalid grid and run controls" { + let mut failures = 0 + ignore(@src.FlowSomConfig::create(xdim=0)) catch { + _ => failures = failures + 1 + } + ignore(@src.FlowSomConfig::create(ydim=-1)) catch { + _ => failures = failures + 1 + } + ignore(@src.FlowSomConfig::create(rlen=0)) catch { + _ => failures = failures + 1 + } + ignore(@src.FlowSomConfig::create(mst_runs=0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 4) +} + +///| +test "FlowSOM: configuration rejects invalid learning schedules" { + let mut failures = 0 + ignore(@src.FlowSomConfig::create(alpha_start=0.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.FlowSomConfig::create(alpha_start=0.01, alpha_end=0.02)) catch { + _ => failures = failures + 1 + } + ignore(@src.FlowSomConfig::create(alpha_end=-0.01)) catch { + _ => failures = failures + 1 + } + ignore(@src.FlowSomConfig::create(alpha_start=1.0e301)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 4) +} + +///| +test "FlowSOM: configuration rejects invalid radius schedules" { + let mut failures = 0 + ignore(@src.FlowSomConfig::create(radius_start=-2.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.FlowSomConfig::create(radius_end=-0.1)) catch { + _ => failures = failures + 1 + } + ignore(@src.FlowSomConfig::create(radius_start=1.0, radius_end=2.0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "FlowSOM: configuration rejects invalid meta, outlier and seed controls" { + let mut failures = 0 + ignore(@src.FlowSomConfig::create(xdim=2, ydim=2, metaclusters=5)) catch { + _ => failures = failures + 1 + } + ignore(@src.FlowSomConfig::create(meta_starts=0)) catch { + _ => failures = failures + 1 + } + ignore(@src.FlowSomConfig::create(outlier_mad=-1.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.FlowSomConfig::create(seed=0)) catch { + _ => failures = failures + 1 + } + ignore(@src.FlowSomConfig::create(importance=[1.0, 0.0])) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 5) +} + +///| +test "FlowSOM: four distances follow their definitions" { + let left = [1.0, -2.0, 3.0] + let right = [4.0, 2.0, 3.0] + assert_eq( + @src.flowsom_distance(left, right, @src.flowsom_manhattan_distance()), + 7.0, + ) + assert_eq( + @src.flowsom_distance(left, right, @src.flowsom_euclidean_distance()), + 5.0, + ) + assert_eq( + @src.flowsom_distance(left, right, @src.flowsom_chebyshev_distance()), + 4.0, + ) + let cosine = @src.flowsom_distance( + [1.0, 0.0], + [0.0, 1.0], + @src.flowsom_cosine_distance(), + ) + assert_true(flowsom_test_close(cosine, 1.0, 1.0e-12)) +} + +///| +test "FlowSOM: cosine distance handles zero vectors" { + let cosine = @src.flowsom_cosine_distance() + assert_eq(@src.flowsom_distance([0.0, 0.0], [0.0, 0.0], cosine), 0.0) + assert_eq(@src.flowsom_distance([0.0, 0.0], [1.0, 0.0], cosine), 1.0) + assert_true( + flowsom_test_close( + @src.flowsom_distance([1.0, 1.0], [2.0, 2.0], cosine), + 0.0, + 1.0e-12, + ), + ) +} + +///| +test "FlowSOM: distance validates vector dimensions and values" { + let mut failures = 0 + ignore(@src.flowsom_distance([], [], @src.flowsom_euclidean_distance())) catch { + _ => failures = failures + 1 + } + ignore( + @src.flowsom_distance([1.0], [1.0, 2.0], @src.flowsom_euclidean_distance()), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.flowsom_distance([1.0e301], [0.0], @src.flowsom_euclidean_distance()), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "FlowSOM: KWSP initialization repeatedly selects the farthest cell" { + let codes = @src.flowsom_initialize_kwsp([[0.0], [1.0], [10.0]], 3, seed=1) catch { + _ => abort("KWSP initialization should work") + } + assert_eq(codes, [[0.0], [10.0], [1.0]]) +} + +///| +test "FlowSOM: KWSP initialization is reproducible and copies rows" { + let data = [[0.0, 0.0], [1.0, 1.0], [5.0, 5.0], [10.0, 10.0]] + let first = @src.flowsom_initialize_kwsp(data, 3, seed=23) catch { + _ => abort("first KWSP initialization should work") + } + let second = @src.flowsom_initialize_kwsp(data, 3, seed=23) catch { + _ => abort("second KWSP initialization should work") + } + assert_eq(first, second) + first[0][0] = 999.0 + assert_true(data[0][0] != 999.0) + assert_true(data[1][0] != 999.0) + assert_true(data[2][0] != 999.0) + assert_true(data[3][0] != 999.0) +} + +///| +test "FlowSOM: KWSP initialization validates nodes and seed" { + let data = [[0.0], [1.0]] + let mut failures = 0 + ignore(@src.flowsom_initialize_kwsp(data, 0)) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_initialize_kwsp(data, 3)) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_initialize_kwsp(data, 1, seed=0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "FlowSOM: one-node PCA initialization returns the column means" { + let codes = @src.flowsom_initialize_pca( + [[1.0, 2.0], [3.0, 6.0], [5.0, 10.0]], + 1, + 1, + ) catch { + _ => abort("one-node PCA initialization should work") + } + assert_eq(codes.length(), 1) + assert_true(flowsom_test_close(codes[0][0], 3.0, 1.0e-12)) + assert_true(flowsom_test_close(codes[0][1], 6.0, 1.0e-12)) +} + +///| +test "FlowSOM: PCA grid is symmetric around the data mean" { + let codes = @src.flowsom_initialize_pca( + [[0.0, 0.0], [2.0, 1.0], [4.0, 2.0]], + 2, + 1, + ) catch { + _ => abort("PCA grid initialization should work") + } + assert_eq(codes.length(), 2) + assert_eq(codes[0].length(), 2) + assert_true( + flowsom_test_close((codes[0][0] + codes[1][0]) / 2.0, 2.0, 1.0e-9), + ) + assert_true( + flowsom_test_close((codes[0][1] + codes[1][1]) / 2.0, 1.0, 1.0e-9), + ) +} + +///| +test "FlowSOM: PCA initialization validates grid dimensions" { + let mut failures = 0 + ignore(@src.flowsom_initialize_pca([[1.0]], 0, 1)) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_initialize_pca([[1.0]], 1, 0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "FlowSOM: MST connects a one-dimensional chain with minimum weight" { + let edges = @src.flowsom_build_mst([[0.0], [1.0], [3.0], [7.0]]) catch { + _ => abort("MST construction should work") + } + assert_eq(edges.length(), 3) + assert_eq(edges[0].from, 0) + assert_eq(edges[0].to, 1) + assert_eq(edges[0].weight, 1.0) + assert_eq(edges[1].from, 1) + assert_eq(edges[1].to, 2) + assert_eq(edges[1].weight, 2.0) + assert_eq(edges[2].from, 2) + assert_eq(edges[2].to, 3) + assert_eq(edges[2].weight, 4.0) +} + +///| +test "FlowSOM: MST tie breaking is stable by node index" { + let edges = @src.flowsom_build_mst([[0.0], [1.0], [-1.0]]) catch { + _ => abort("tied MST construction should work") + } + assert_eq(edges.length(), 2) + assert_eq(edges[0].from, 0) + assert_eq(edges[0].to, 1) + assert_eq(edges[1].from, 0) + assert_eq(edges[1].to, 2) +} + +///| +test "FlowSOM: one-node MST has no edges" { + let edges = @src.flowsom_build_mst([[2.0, 3.0]]) catch { + _ => abort("one-node MST construction should work") + } + assert_eq(edges.length(), 0) +} + +///| +test "FlowSOM: MST topology reports unweighted path lengths" { + let distances = @src.flowsom_mst_distances([[0.0], [1.0], [3.0], [7.0]]) catch { + _ => abort("MST topology should work") + } + assert_eq(distances.length(), 4) + assert_eq(distances[0], [0, 1, 2, 3]) + assert_eq(distances[3], [3, 2, 1, 0]) +} + +///| +test "FlowSOM: MST validates rectangular finite codebooks" { + let mut failures = 0 + ignore(@src.flowsom_build_mst([])) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_build_mst([[1.0], [1.0, 2.0]])) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_build_mst([[1.0e301]])) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "FlowSOM: data mapping returns nearest nodes and distances" { + let mapping = @src.flowsom_map_data([[0.0, 0.0], [10.0, 10.0]], [ + [1.0, 0.0], + [9.0, 10.0], + ]) catch { + _ => abort("FlowSOM mapping should work") + } + assert_eq(mapping.clusters, [0, 1]) + assert_eq(mapping.distances, [1.0, 1.0]) +} + +///| +test "FlowSOM: data mapping resolves nearest-node ties by index" { + let mapping = @src.flowsom_map_data([[0.0], [2.0]], [[1.0]]) catch { + _ => abort("tied FlowSOM mapping should work") + } + assert_eq(mapping.clusters, [0]) + assert_eq(mapping.distances, [1.0]) +} + +///| +test "FlowSOM: data mapping supports non-Euclidean distance" { + let mapping = @src.flowsom_map_data( + [[0.0, 0.0], [4.0, 4.0]], + [[3.0, 0.0]], + distance=@src.flowsom_manhattan_distance(), + ) catch { + _ => abort("Manhattan FlowSOM mapping should work") + } + assert_eq(mapping.clusters, [0]) + assert_eq(mapping.distances, [3.0]) +} + +///| +test "FlowSOM: data mapping validates marker dimensions" { + let mut raised = false + ignore(@src.flowsom_map_data([[0.0, 1.0]], [[0.0]])) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "FlowSOM: training returns a complete grid, MST and mapping" { + let model = flowsom_test_model() + assert_eq(model.data.length(), 8) + assert_eq(model.marker_names, ["CD3", "CD19"]) + assert_eq(model.codes.length(), 4) + assert_eq(model.grid.length(), 4) + assert_eq(model.grid[0], (0, 0)) + assert_eq(model.grid[3], (1, 1)) + assert_eq(model.mapping.clusters.length(), 8) + assert_eq(model.mapping.distances.length(), 8) + assert_eq(model.mst_edges.length(), 3) + assert_eq(model.topology_distances.length(), 4) + assert_eq(flowsom_test_sum(model.node_counts), 8) +} + +///| +test "FlowSOM: fixed seeds make training reproducible" { + let first = flowsom_test_model(seed=37) + let second = flowsom_test_model(seed=37) + assert_eq(first.codes, second.codes) + assert_eq(first.mapping.clusters, second.mapping.clusters) + assert_eq(first.mapping.distances, second.mapping.distances) + assert_eq(first.iterations, second.iterations) +} + +///| +test "FlowSOM: random initialization training path is available" { + let config = @src.FlowSomConfig::create( + xdim=2, + ydim=2, + rlen=2, + initialization=@src.flowsom_random_initialization(), + seed=43, + ) catch { + _ => abort("random FlowSOM configuration should build") + } + let model = @src.flowsom_train(flowsom_test_data(), config) catch { + _ => abort("random-initialized FlowSOM should train") + } + assert_eq(model.codes.length(), 4) + assert_eq(model.mapping.clusters.length(), 8) +} + +///| +test "FlowSOM: PCA training permits more nodes than cells" { + let config = @src.FlowSomConfig::create( + xdim=2, + ydim=2, + rlen=1, + initialization=@src.flowsom_pca_initialization(), + seed=47, + ) catch { + _ => abort("PCA FlowSOM configuration should build") + } + let model = @src.flowsom_train([[0.0, 0.0], [1.0, 1.0]], config) catch { + _ => abort("PCA FlowSOM with extra nodes should train") + } + assert_eq(model.codes.length(), 4) + assert_eq(model.mapping.clusters.length(), 2) +} + +///| +test "FlowSOM: multi-stage training tracks iterations and final topology" { + let model = flowsom_test_model() + assert_true(model.iterations > 0) + assert_true(model.iterations <= 3 * 8 * 2) + for node in 0.. abort("FlowSOM with generated marker names should train") + } + assert_eq(model.marker_names, ["marker.1", "marker.2"]) +} + +///| +test "FlowSOM: training validates marker names" { + let config = flowsom_test_config() + let mut failures = 0 + ignore(@src.flowsom_train(flowsom_test_data(), config, marker_names=["only"])) catch { + _ => failures = failures + 1 + } + ignore( + @src.flowsom_train(flowsom_test_data(), config, marker_names=["A", "A"]), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.flowsom_train(flowsom_test_data(), config, marker_names=["A", ""]), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "FlowSOM: training validates importance dimensions" { + let config = @src.FlowSomConfig::create(xdim=1, ydim=1, importance=[1.0]) catch { + _ => abort("importance configuration should build before data validation") + } + let mut raised = false + ignore(@src.flowsom_train([[1.0, 2.0]], config)) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "FlowSOM: training rejects empty, ragged and non-finite data" { + let config = flowsom_test_config() + let mut failures = 0 + ignore(@src.flowsom_train([], config)) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_train([[1.0], [1.0, 2.0]], config)) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_train([[1.0e301, 0.0]], config)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "FlowSOM: non-PCA initialization requires one cell per node" { + let config = @src.FlowSomConfig::create(xdim=2, ydim=2) catch { + _ => abort("valid FlowSOM configuration should build") + } + let mut raised = false + ignore(@src.flowsom_train([[0.0], [1.0]], config)) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "FlowSOM: node summaries use medians, sample SD, CV and R-style MAD" { + let model = flowsom_test_one_node_model() + assert_eq(model.node_counts, [3]) + assert_eq(model.node_percentages, [1.0]) + assert_eq(flowsom_test_some(model.node_medians[0][0]), 3.0) + assert_eq(flowsom_test_some(model.node_medians[0][1]), 4.0) + assert_true( + flowsom_test_close(flowsom_test_some(model.node_sds[0][0]), 2.0, 1.0e-12), + ) + assert_true( + flowsom_test_close( + flowsom_test_some(model.node_cvs[0][0]), + 2.0 / 3.0, + 1.0e-12, + ), + ) + assert_true( + flowsom_test_close(flowsom_test_some(model.node_cvs[0][1]), 0.5, 1.0e-12), + ) + assert_true( + flowsom_test_close( + flowsom_test_some(model.node_mads[0][0]), + 2.9652, + 1.0e-12, + ), + ) +} + +///| +test "FlowSOM: empty nodes retain missing optional statistics" { + let config = @src.FlowSomConfig::create( + xdim=3, + ydim=1, + rlen=1, + initialization=@src.flowsom_pca_initialization(), + seed=53, + ) catch { + _ => abort("PCA FlowSOM configuration should build") + } + let model = @src.flowsom_train([[0.0], [10.0]], config) catch { + _ => abort("PCA FlowSOM should train") + } + let mut empty = -1 + for node in 0..= 0) + assert_true(model.node_medians[empty][0] is None) + assert_true(model.node_sds[empty][0] is None) + assert_true(model.node_mads[empty][0] is None) +} + +///| +test "FlowSOM: outlier report is aligned to nodes and cells" { + let model = flowsom_test_model() + assert_eq(model.outliers.median_distances.length(), 4) + assert_eq(model.outliers.mad_distances.length(), 4) + assert_eq(model.outliers.thresholds.length(), 4) + assert_eq(model.outliers.counts.length(), 4) + assert_eq(model.outliers.maximum_distances.length(), 4) + assert_eq(model.outliers.per_cell.length(), 8) + let mut flagged = 0 + for value in model.outliers.per_cell { + if value { + flagged = flagged + 1 + } + } + assert_eq(flowsom_test_sum(model.outliers.counts), flagged) +} + +///| +test "FlowSOM: quantization and topographic errors are bounded" { + let model = flowsom_test_model() + assert_true(model.quantization_error >= 0.0) + assert_true(model.topographic_error >= 0.0) + assert_true(model.topographic_error <= 1.0) +} + +///| +test "FlowSOM: node positive percentages use strict cutoffs" { + let model = flowsom_test_one_node_model() + let percentages = @src.flowsom_node_positive_percentages(model, [2.0, 4.0]) catch { + _ => abort("node positive percentages should work") + } + assert_true( + flowsom_test_close(flowsom_test_some(percentages[0][0]), 2.0 / 3.0, 1.0e-12), + ) + assert_true( + flowsom_test_close(flowsom_test_some(percentages[0][1]), 1.0 / 3.0, 1.0e-12), + ) +} + +///| +test "FlowSOM: node positive percentages validate cutoffs" { + let model = flowsom_test_one_node_model() + let mut failures = 0 + ignore(@src.flowsom_node_positive_percentages(model, [1.0])) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_node_positive_percentages(model, [1.0, 1.0e301])) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "FlowSOM: one meta-cluster assigns every code to zero" { + let labels = @src.flowsom_meta_cluster_codes([[0.0], [1.0], [10.0]], 1) catch { + _ => abort("one FlowSOM meta-cluster should work") + } + assert_eq(labels, [0, 0, 0]) +} + +///| +test "FlowSOM: k-means meta-clustering separates distant code groups" { + let labels = @src.flowsom_meta_cluster_codes( + [[0.0], [0.1], [0.2], [10.0], [10.1], [10.2]], + 2, + starts=4, + seed=59, + ) catch { + _ => abort("FlowSOM meta-clustering should work") + } + assert_eq(flowsom_test_unique_count(labels), 2) + assert_true(labels[0] == labels[1] && labels[1] == labels[2]) + assert_true(labels[3] == labels[4] && labels[4] == labels[5]) + assert_true(labels[0] != labels[3]) +} + +///| +test "FlowSOM: meta-clustering validates cluster controls" { + let codes = [[0.0], [1.0]] + let mut failures = 0 + ignore(@src.flowsom_meta_cluster_codes(codes, 0)) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_meta_cluster_codes(codes, 3)) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_meta_cluster_codes(codes, 2, starts=0)) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_meta_cluster_codes(codes, 2, seed=0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 4) +} + +///| +test "FlowSOM: automatic meta-clustering returns small maxima directly" { + assert_eq(@src.flowsom_determine_meta_clusters([[0.0]], 1), 1) + assert_eq(@src.flowsom_determine_meta_clusters([[0.0], [1.0]], 2), 2) + let mut failures = 0 + ignore(@src.flowsom_determine_meta_clusters([[0.0], [1.0]], 2, starts=0)) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_determine_meta_clusters([[0.0], [1.0]], 2, seed=0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "FlowSOM: automatic meta-clustering selects an internal elbow" { + let selected = @src.flowsom_determine_meta_clusters( + [[0.0], [0.1], [0.2], [10.0], [10.1], [10.2]], + 5, + starts=3, + seed=61, + ) catch { + _ => abort("automatic FlowSOM meta-clustering should work") + } + assert_true(selected >= 2) + assert_true(selected < 5) +} + +///| +test "FlowSOM: automatic meta-clustering validates its maximum" { + let mut failures = 0 + ignore(@src.flowsom_determine_meta_clusters([[0.0]], 0)) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_determine_meta_clusters([[0.0]], 2)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "FlowSOM: configured meta-clusters propagate to cells" { + let model = flowsom_test_model(metaclusters=2) + assert_eq(model.meta_clusters.length(), 4) + assert_eq(model.cell_meta_clusters.length(), 8) + assert_eq(flowsom_test_unique_count(model.meta_clusters), 2) + assert_eq( + @src.flowsom_meta_medians(model).length(), + @src.flowsom_meta_counts(model).length(), + ) + for cell in 0.. failures = failures + 1 + } + ignore(@src.flowsom_meta_medians(model)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "FlowSOM: post-hoc meta-clustering leaves the original model unchanged" { + let model = flowsom_test_model() + let updated = @src.flowsom_with_metaclusters(model, 2, starts=3, seed=67) catch { + _ => abort("post-hoc FlowSOM meta-clustering should work") + } + assert_eq(model.meta_clusters.length(), 0) + assert_eq(updated.meta_clusters.length(), 4) + assert_eq(updated.cell_meta_clusters.length(), 8) + assert_eq(updated.config.metaclusters, 2) + updated.codes[0][0] = 999.0 + assert_true(model.codes[0][0] != 999.0) +} + +///| +test "FlowSOM: automatic post-hoc meta-clustering updates the model" { + let model = flowsom_test_model() + let updated = @src.flowsom_with_automatic_metaclusters( + model, + 3, + starts=3, + seed=71, + ) catch { + _ => abort("automatic post-hoc meta-clustering should work") + } + assert_true(updated.config.metaclusters >= 2) + assert_true(updated.config.metaclusters <= 3) + assert_eq(updated.meta_clusters.length(), 4) + assert_eq(updated.cell_meta_clusters.length(), 8) +} + +///| +test "FlowSOM: new data mapping applies node and meta-cluster labels" { + let model = flowsom_test_model(metaclusters=2) + let mapped = @src.flowsom_map_new(model, [[0.05, 0.1], [10.2, 10.0]]) catch { + _ => abort("new FlowSOM data should map") + } + assert_eq(mapped.mapping.clusters.length(), 2) + assert_eq(mapped.mapping.distances.length(), 2) + assert_eq(mapped.meta_clusters.length(), 2) + assert_eq(mapped.outliers.length(), 2) + for cell in 0..<2 { + assert_eq( + mapped.meta_clusters[cell], + model.meta_clusters[mapped.mapping.clusters[cell]], + ) + } +} + +///| +test "FlowSOM: new data mapping validates marker dimensions" { + let model = flowsom_test_model() + let mut raised = false + ignore(@src.flowsom_map_new(model, [[1.0]])) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "FlowSOM: marker outliers classify low and high observations" { + let model = flowsom_test_one_node_model() + let outliers = @src.flowsom_marker_outliers( + model, + [[0.0, 4.0], [3.0, 4.0], [7.0, 8.0]], + mad_allowed=0.0, + ) catch { + _ => abort("marker-level FlowSOM outliers should work") + } + assert_eq(outliers, [[-1, 0], [0, 0], [1, 1]]) +} + +///| +test "FlowSOM: marker outliers validate dimensions and MAD control" { + let model = flowsom_test_one_node_model() + let mut failures = 0 + ignore(@src.flowsom_marker_outliers(model, [[1.0]])) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_marker_outliers(model, [[1.0, 2.0]], mad_allowed=-1.0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "FlowSOM: weighted and unweighted purity follow contingency counts" { + let real = [0, 0, 1, 1] + let predicted = [0, 0, 0, 1] + let weighted = @src.flowsom_purity(real, predicted) catch { + _ => abort("weighted FlowSOM purity should work") + } + let unweighted = @src.flowsom_purity(real, predicted, weighted=false) catch { + _ => abort("unweighted FlowSOM purity should work") + } + assert_true(flowsom_test_close(weighted.mean, 0.75, 1.0e-12)) + assert_true(flowsom_test_close(weighted.worst, 2.0 / 3.0, 1.0e-12)) + assert_eq(weighted.below_075, 1) + assert_true(flowsom_test_close(unweighted.mean, 5.0 / 6.0, 1.0e-12)) +} + +///| +test "FlowSOM: F-measure weights best matches by real-cluster size" { + let score = @src.flowsom_f_measure([0, 0, 1, 1], [0, 0, 0, 1]) catch { + _ => abort("FlowSOM F-measure should work") + } + assert_true(flowsom_test_close(score, 11.0 / 15.0, 1.0e-12)) +} + +///| +test "FlowSOM: purity and F-measure validate label vectors" { + let mut failures = 0 + ignore(@src.flowsom_purity([], [])) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_purity([0], [0, 1])) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_f_measure([], [])) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_f_measure([0], [0, 1])) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 4) +} + +///| +test "FlowSOM: summary reports model dimensions and quality" { + let summary = @src.flowsom_summary(flowsom_test_model(metaclusters=2)) + assert_true(summary.contains("FlowSOM model")) + assert_true(summary.contains("cells: 8")) + assert_true(summary.contains("markers: 2")) + assert_true(summary.contains("nodes: 4")) + assert_true(summary.contains("metaclusters: 2")) + assert_true(summary.contains("quantization error:")) + assert_true(summary.contains("topographic error:")) +} + +///| +test "FlowSOM: FlowFrame adapter selects markers in requested order" { + let frame = @src.FlowFrame::new( + [[0.0, 1.0, 2.0], [0.1, 1.1, 2.1], [10.0, 11.0, 12.0], [10.1, 11.1, 12.1]], + [ + @src.ParameterDescription::new("CD3", 20.0, 0.0, 20.0), + @src.ParameterDescription::new("CD19", 20.0, 0.0, 20.0), + @src.ParameterDescription::new("CD45", 20.0, 0.0, 20.0), + ], + ) + let config = @src.FlowSomConfig::create(xdim=2, ydim=1, rlen=2, seed=73) catch { + _ => abort("FlowFrame FlowSOM configuration should build") + } + let model = @src.flowsom_train_flow_frame(frame, config, marker_indices=[2, 0]) catch { + _ => abort("FlowFrame FlowSOM training should work") + } + assert_eq(model.marker_names, ["CD45", "CD3"]) + assert_eq(model.data[0], [2.0, 0.0]) + assert_eq(model.data[3], [12.1, 10.1]) +} + +///| +test "FlowSOM: FlowFrame adapter validates marker selection" { + let frame = @src.FlowFrame::new([[0.0, 1.0], [2.0, 3.0]], [ + @src.ParameterDescription::new("A", 10.0, 0.0, 10.0), + @src.ParameterDescription::new("B", 10.0, 0.0, 10.0), + ]) + let config = @src.FlowSomConfig::create(xdim=1, ydim=1) catch { + _ => abort("FlowFrame FlowSOM configuration should build") + } + let mut failures = 0 + ignore(@src.flowsom_train_flow_frame(frame, config, marker_indices=[0, 0])) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_train_flow_frame(frame, config, marker_indices=[2])) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "FlowSOM: SCE adapter writes one-based labels without mutating input" { + let experiment = flowsom_test_sce() + let config = @src.FlowSomConfig::create( + xdim=2, + ydim=1, + rlen=2, + metaclusters=2, + meta_starts=3, + seed=79, + ) catch { + _ => abort("SCE FlowSOM configuration should build") + } + let result = @src.flowsom_cluster_sce(experiment, config) catch { + _ => abort("SCE FlowSOM clustering should work") + } + assert_false(experiment.col_data.contains("FlowSOM.cluster")) + assert_false(experiment.col_data.contains("FlowSOM.metacluster")) + assert_true(result.experiment.col_data.contains("FlowSOM.cluster")) + assert_true(result.experiment.col_data.contains("FlowSOM.metacluster")) + assert_eq(result.experiment.col_data["FlowSOM.cluster"].length(), 6) + assert_eq(result.experiment.col_data["FlowSOM.metacluster"].length(), 6) + for label in result.experiment.col_data["FlowSOM.cluster"] { + assert_true(label == "1" || label == "2") + } + assert_eq(result.experiment.metadata["FlowSOM.assay"], "counts") + assert_eq(result.experiment.metadata["FlowSOM.grid"], "2x1") +} + +///| +test "FlowSOM: SCE adapter transposes assays and honors marker subsets" { + let experiment = flowsom_test_sce() + let config = @src.FlowSomConfig::create(xdim=2, ydim=1, rlen=2, seed=83) catch { + _ => abort("SCE FlowSOM configuration should build") + } + let result = @src.flowsom_cluster_sce( + experiment, + config, + marker_indices=[2, 0], + cluster_column="som", + meta_column="meta", + ) catch { + _ => abort("subset SCE FlowSOM clustering should work") + } + assert_eq(result.model.marker_names, ["CD45", "CD3"]) + assert_eq(result.model.data[0], [2.0, 0.0]) + assert_eq(result.model.data[5], [12.2, 10.2]) + assert_true(result.experiment.col_data.contains("som")) + assert_false(result.experiment.col_data.contains("meta")) + assert_eq(result.experiment.assays["counts"].length(), 3) + assert_eq(result.experiment.assays["counts"][0].length(), 6) +} + +///| +test "FlowSOM: SCE adapter recursively deep-copies nested containers" { + let experiment = flowsom_test_sce() + let config = @src.FlowSomConfig::create(xdim=2, ydim=1, rlen=2, seed=89) catch { + _ => abort("SCE FlowSOM configuration should build") + } + let result = @src.flowsom_cluster_sce(experiment, config) catch { + _ => abort("SCE FlowSOM clustering should work") + } + result.experiment.assays["counts"][0][0] = 999.0 + result.experiment.row_data["symbol"][0] = "changed" + result.experiment.col_data["batch"][0] = "changed" + result.experiment.reduced_dims["PCA"][0][0] = 999.0 + result.experiment.metadata["project"] = "changed" + result.experiment.alternative_experiments["spike"].assays["counts"][0][0] = 999.0 + assert_eq(experiment.assays["counts"][0][0], 0.0) + assert_eq(experiment.row_data["symbol"][0], "T") + assert_eq(experiment.col_data["batch"][0], "A") + assert_eq(experiment.reduced_dims["PCA"][0][0], 0.0) + assert_eq(experiment.metadata["project"], "flowsom-test") + assert_eq( + experiment.alternative_experiments["spike"].assays["counts"][0][0], + 5.0, + ) +} + +///| +test "FlowSOM: SCE adapter validates assay, marker and output names" { + let experiment = flowsom_test_sce() + let config = @src.FlowSomConfig::create(xdim=2, ydim=1) catch { + _ => abort("SCE FlowSOM configuration should build") + } + let mut failures = 0 + ignore(@src.flowsom_cluster_sce(experiment, config, assay_name="missing")) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_cluster_sce(experiment, config, marker_indices=[0, 0])) catch { + _ => failures = failures + 1 + } + ignore(@src.flowsom_cluster_sce(experiment, config, cluster_column="")) catch { + _ => failures = failures + 1 + } + ignore( + @src.flowsom_cluster_sce( + experiment, + config, + cluster_column="same", + meta_column="same", + ), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 4) +} diff --git a/test/moonbit/lisaclust_test.mbt b/test/moonbit/lisaclust_test.mbt new file mode 100644 index 00000000..9cc5cef2 --- /dev/null +++ b/test/moonbit/lisaclust_test.mbt @@ -0,0 +1,1006 @@ +// Black-box tests for the Bioconductor lisaClust-inspired workflow. + +///| +fn lisa_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "lisaClust value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn lisa_test_cell( + cell_id : String, + image_id : String, + cell_type : String, + x : Double, + y : Double, +) -> @src.LisaCell { + @src.LisaCell::create(cell_id, image_id, cell_type, x, y) catch { + _ => abort("lisaClust test cell should be valid") + } +} + +///| +fn lisa_test_config( + curve_kind? : @src.LisaCurveKind = @src.lisa_k_curve(), + edge_correction? : Bool = false, + window_kind? : @src.LisaWindowKind = @src.lisa_rectangle_window(), + n_clusters? : Int = 2, + region_prefix? : String = "region", +) -> @src.LisaConfig { + @src.LisaConfig::create( + radii=[1.5, 4.0], + curve_kind~, + window_kind~, + bandwidth=1000.0, + min_density=0.05, + edge_correction~, + window_padding=0.0, + edge_samples=128, + n_clusters~, + n_starts=4, + max_iterations=100, + tolerance=1.0e-9, + seed=7, + region_prefix~, + ) catch { + _ => abort("lisaClust test configuration should be valid") + } +} + +///| +fn lisa_test_cells() -> Array[@src.LisaCell] { + [ + lisa_test_cell("a1", "image_1", "A", 0.0, 0.0), + lisa_test_cell("a2", "image_1", "A", 1.0, 1.0), + lisa_test_cell("a3", "image_1", "A", 2.0, 0.5), + lisa_test_cell("b1", "image_1", "B", 8.0, 8.0), + lisa_test_cell("b2", "image_1", "B", 9.0, 9.0), + lisa_test_cell("b3", "image_1", "B", 10.0, 8.5), + lisa_test_cell("c1", "image_1", "C", 0.0, 10.0), + lisa_test_cell("c2", "image_1", "C", 10.0, 0.0), + ] +} + +///| +fn lisa_test_exact_cells() -> Array[@src.LisaCell] { + [ + lisa_test_cell("source", "image_1", "A", 2.0, 2.0), + lisa_test_cell("near", "image_1", "B", 3.0, 2.0), + lisa_test_cell("far", "image_1", "B", 8.0, 8.0), + lisa_test_cell("corner_1", "image_1", "C", 0.0, 0.0), + lisa_test_cell("corner_2", "image_1", "C", 10.0, 10.0), + ] +} + +///| +fn lisa_test_result() -> @src.LisaResult { + @src.lisaclust(lisa_test_cells(), config=lisa_test_config()) catch { + _ => abort("lisaClust test workflow should succeed") + } +} + +///| +fn lisa_test_experiment() -> @src.SpatialExperiment { + let experiment = @src.SpatialExperiment::new() + for cell in lisa_test_cells() { + ignore( + @src.se_add_col( + experiment, + Map( + [ + ("cellID", cell.cell_id), + ("imageID", cell.image_id), + ("cellType", cell.cell_type), + ], + ), + ), + ) + ignore( + @src.se_add_spatial_coord( + experiment, + @src.SpatialCoord::new_2d(cell.x, cell.y), + ), + ) + } + experiment +} + +///| +test "lisaClust: curve and window helpers expose both modes" { + assert_true( + @src.lisa_k_curve() is @src.LisaCurveKind::LisaStandardizedK, + ) + assert_true(@src.lisa_l_curve() is @src.LisaCurveKind::LisaCenteredL) + assert_true( + @src.lisa_rectangle_window() is @src.LisaWindowKind::LisaRectangle, + ) + assert_true( + @src.lisa_convex_window() is @src.LisaWindowKind::LisaConvexHull, + ) +} + +///| +test "lisaClust: default configuration follows upstream defaults" { + let config = @src.LisaConfig::default() + assert_eq(config.radii, [20.0, 50.0, 100.0]) + assert_true(config.curve_kind is @src.LisaCurveKind::LisaStandardizedK) + assert_true(config.window_kind is @src.LisaWindowKind::LisaConvexHull) + assert_eq(config.bandwidth, 100000.0) + assert_eq(config.min_density, 0.05) + assert_eq(config.edge_correction, true) + assert_eq(config.n_clusters, 2) + assert_eq(config.region_prefix, "region") +} + +///| +test "lisaClust: custom configuration preserves controls" { + let config = @src.LisaConfig::create( + radii=[1.0, 3.0], + curve_kind=@src.lisa_l_curve(), + window_kind=@src.lisa_rectangle_window(), + bandwidth=2.5, + min_density=0.2, + edge_correction=false, + window_padding=1.0, + edge_samples=64, + n_clusters=3, + n_starts=5, + max_iterations=40, + tolerance=1.0e-6, + seed=9, + region_prefix="domain", + ) catch { + _ => abort("custom lisaClust configuration should be valid") + } + assert_eq(config.radii, [1.0, 3.0]) + assert_true(config.curve_kind is @src.LisaCurveKind::LisaCenteredL) + assert_eq(config.bandwidth, 2.5) + assert_eq(config.edge_correction, false) + assert_eq(config.n_clusters, 3) + assert_eq(config.region_prefix, "domain") +} + +///| +test "lisaClust: configuration defensively copies radii" { + let radii = [1.0, 2.0] + let config = @src.LisaConfig::create(radii~) catch { + _ => abort("lisaClust radii should be valid") + } + radii[0] = 99.0 + assert_eq(config.radii, [1.0, 2.0]) +} + +///| +test "lisaClust: configuration rejects empty radii" { + let failed = try { + ignore(@src.LisaConfig::create(radii=[])) + false + } catch { + LisaError(_) => true + } + assert_true(failed) +} + +///| +test "lisaClust: configuration rejects non-increasing radii" { + let failed = try { + ignore(@src.LisaConfig::create(radii=[2.0, 2.0])) + false + } catch { + LisaError(_) => true + } + assert_true(failed) +} + +///| +test "lisaClust: configuration rejects non-finite radii" { + let failed = try { + ignore(@src.LisaConfig::create(radii=[1.0, @double.not_a_number])) + false + } catch { + LisaError(_) => true + } + assert_true(failed) +} + +///| +test "lisaClust: configuration rejects invalid density controls" { + let bad_bandwidth = try { + ignore(@src.LisaConfig::create(bandwidth=0.0)) + false + } catch { + LisaError(_) => true + } + let bad_minimum = try { + ignore(@src.LisaConfig::create(min_density=0.0)) + false + } catch { + LisaError(_) => true + } + assert_true(bad_bandwidth) + assert_true(bad_minimum) +} + +///| +test "lisaClust: configuration rejects invalid edge controls" { + let bad_padding = try { + ignore(@src.LisaConfig::create(window_padding=-1.0)) + false + } catch { + LisaError(_) => true + } + let bad_samples = try { + ignore(@src.LisaConfig::create(edge_samples=16)) + false + } catch { + LisaError(_) => true + } + assert_true(bad_padding) + assert_true(bad_samples) +} + +///| +test "lisaClust: configuration rejects invalid clustering controls" { + let bad_clusters = try { + ignore(@src.LisaConfig::create(n_clusters=0)) + false + } catch { + LisaError(_) => true + } + let bad_starts = try { + ignore(@src.LisaConfig::create(n_starts=0)) + false + } catch { + LisaError(_) => true + } + let bad_iterations = try { + ignore(@src.LisaConfig::create(max_iterations=0)) + false + } catch { + LisaError(_) => true + } + assert_true(bad_clusters) + assert_true(bad_starts) + assert_true(bad_iterations) +} + +///| +test "lisaClust: configuration rejects invalid tolerance seed and prefix" { + let bad_tolerance = try { + ignore(@src.LisaConfig::create(tolerance=1.0)) + false + } catch { + LisaError(_) => true + } + let bad_seed = try { + ignore(@src.LisaConfig::create(seed=-1)) + false + } catch { + LisaError(_) => true + } + let bad_prefix = try { + ignore(@src.LisaConfig::create(region_prefix="")) + false + } catch { + LisaError(_) => true + } + assert_true(bad_tolerance) + assert_true(bad_seed) + assert_true(bad_prefix) +} + +///| +test "lisaClust: cell constructor validates identifiers" { + let bad_cell = try { + ignore(@src.LisaCell::create("", "image", "A", 0.0, 0.0)) + false + } catch { + LisaError(_) => true + } + let bad_image = try { + ignore(@src.LisaCell::create("cell", "", "A", 0.0, 0.0)) + false + } catch { + LisaError(_) => true + } + let bad_type = try { + ignore(@src.LisaCell::create("cell", "image", "", 0.0, 0.0)) + false + } catch { + LisaError(_) => true + } + assert_true(bad_cell) + assert_true(bad_image) + assert_true(bad_type) +} + +///| +test "lisaClust: cell constructor rejects non-finite coordinates" { + let failed = try { + ignore( + @src.LisaCell::create( + "cell", + "image", + "A", + @double.not_a_number, + 0.0, + ), + ) + false + } catch { + LisaError(_) => true + } + assert_true(failed) +} + +///| +test "lisaClust: curve matrix exposes stable dimensions and names" { + let curves = @src.lisa_curves( + lisa_test_cells(), + config=lisa_test_config(), + ) catch { + _ => abort("lisaClust curves should compute") + } + assert_eq(curves.n_cells(), 8) + assert_eq(curves.target_cell_types, ["A", "B", "C"]) + assert_eq(curves.radii, [1.5, 4.0]) + assert_eq(curves.n_features(), 6) + assert_eq(curves.feature_names[0], "1.5_A") + assert_eq(curves.feature_names[5], "4_C") +} + +///| +test "lisaClust: feature lookup follows target-major radius order" { + let curves = @src.lisa_curves( + lisa_test_cells(), + config=lisa_test_config(), + ) catch { + _ => abort("lisaClust curves should compute") + } + assert_eq(curves.feature_index("A", 1.5), 0) + assert_eq(curves.feature_index("B", 4.0), 3) + assert_eq(curves.feature_index("missing", 1.5), -1) + assert_eq(curves.feature_index("A", 99.0), -1) +} + +///| +test "lisaClust: exact standardized K uses observed-minus-expected scaling" { + let config = @src.LisaConfig::create( + radii=[2.0], + window_kind=@src.lisa_rectangle_window(), + bandwidth=1000000.0, + edge_correction=false, + window_padding=0.0, + edge_samples=64, + ) catch { + _ => abort("exact K configuration should be valid") + } + let curves = @src.lisa_curves(lisa_test_exact_cells(), config~) catch { + _ => abort("exact K curves should compute") + } + let feature = curves.feature_index("B", 2.0) + let expected = @math.PI * 4.0 * 2.0 / 100.0 + let target = (1.0 - expected) / expected.sqrt() + lisa_test_close(curves.values[0][feature], target, 1.0e-5) +} + +///| +test "lisaClust: centered L uses square-root observed and expected counts" { + let config = @src.LisaConfig::create( + radii=[2.0], + curve_kind=@src.lisa_l_curve(), + window_kind=@src.lisa_rectangle_window(), + bandwidth=1000000.0, + edge_correction=false, + window_padding=0.0, + edge_samples=64, + ) catch { + _ => abort("exact L configuration should be valid") + } + let curves = @src.lisa_curves(lisa_test_exact_cells(), config~) catch { + _ => abort("exact L curves should compute") + } + let feature = curves.feature_index("B", 2.0) + let expected = @math.PI * 4.0 * 2.0 / 100.0 + lisa_test_close(curves.values[0][feature], 1.0 - expected.sqrt(), 1.0e-5) +} + +///| +test "lisaClust: local curves exclude self matches" { + let config = @src.LisaConfig::create( + radii=[0.5], + window_kind=@src.lisa_rectangle_window(), + bandwidth=1000000.0, + edge_correction=false, + window_padding=0.0, + ) catch { + _ => abort("self exclusion configuration should be valid") + } + let curves = @src.lisa_curves(lisa_test_exact_cells(), config~) catch { + _ => abort("self exclusion curves should compute") + } + let feature = curves.feature_index("A", 0.5) + let expected = @math.PI * 0.25 / 100.0 + lisa_test_close(curves.values[0][feature], -expected.sqrt(), 1.0e-6) +} + +///| +test "lisaClust: rectangle window area follows coordinate extent" { + let curves = @src.lisa_curves( + lisa_test_exact_cells(), + config=lisa_test_config(), + ) catch { + _ => abort("rectangle lisaClust curves should compute") + } + assert_eq(curves.windows.length(), 1) + lisa_test_close(curves.windows[0].area, 100.0, 1.0e-12) +} + +///| +test "lisaClust: convex window uses hull area" { + let cells = [ + lisa_test_cell("p1", "image", "A", 0.0, 0.0), + lisa_test_cell("p2", "image", "A", 10.0, 0.0), + lisa_test_cell("p3", "image", "B", 0.0, 10.0), + lisa_test_cell("inside", "image", "B", 2.0, 2.0), + ] + let config = @src.LisaConfig::create( + radii=[1.0], + window_kind=@src.lisa_convex_window(), + window_padding=0.0, + edge_correction=false, + ) catch { + _ => abort("convex lisaClust configuration should be valid") + } + let curves = @src.lisa_curves(cells, config~) catch { + _ => abort("convex lisaClust curves should compute") + } + lisa_test_close(curves.windows[0].area, 50.0, 1.0e-12) + assert_eq(curves.windows[0].vertices.length(), 3) +} + +///| +test "lisaClust: radii are capped at half the shortest window span" { + let config = @src.LisaConfig::create( + radii=[1.0, 100.0], + window_kind=@src.lisa_rectangle_window(), + window_padding=0.0, + edge_correction=false, + ) catch { + _ => abort("radius cap configuration should be valid") + } + let curves = @src.lisa_curves(lisa_test_exact_cells(), config~) catch { + _ => abort("radius capped curves should compute") + } + let radii = match curves.effective_radii_for_image("image_1") { + Some(values) => values + None => abort("effective radii should exist") + } + assert_eq(radii[0], 1.0) + lisa_test_close(radii[1], 10.0 / 2.01, 1.0e-12) +} + +///| +test "lisaClust: edge correction changes corner-cell expectation" { + let cells = [ + lisa_test_cell("source", "image", "A", 0.0, 0.0), + lisa_test_cell("near", "image", "B", 1.0, 1.0), + lisa_test_cell("far", "image", "B", 8.0, 8.0), + lisa_test_cell("corner", "image", "C", 10.0, 10.0), + ] + let without = @src.lisa_curves( + cells, + config=@src.LisaConfig::create( + radii=[2.0], + window_kind=@src.lisa_rectangle_window(), + bandwidth=1000000.0, + edge_correction=false, + window_padding=0.0, + edge_samples=720, + ) catch { + _ => abort("uncorrected edge configuration should be valid") + }, + ) catch { + _ => abort("uncorrected curves should compute") + } + let with_edge = @src.lisa_curves( + cells, + config=@src.LisaConfig::create( + radii=[2.0], + window_kind=@src.lisa_rectangle_window(), + bandwidth=1000000.0, + edge_correction=true, + window_padding=0.0, + edge_samples=720, + ) catch { + _ => abort("corrected edge configuration should be valid") + }, + ) catch { + _ => abort("corrected curves should compute") + } + let feature = without.feature_index("B", 2.0) + assert_true(with_edge.values[0][feature] > without.values[0][feature]) +} + +///| +test "lisaClust: KDE weighting changes curves under inhomogeneous density" { + let narrow = @src.LisaConfig::create( + radii=[2.0], + window_kind=@src.lisa_rectangle_window(), + bandwidth=0.25, + min_density=0.05, + edge_correction=false, + window_padding=0.0, + ) catch { + _ => abort("narrow KDE configuration should be valid") + } + let broad = @src.LisaConfig::create( + radii=[2.0], + window_kind=@src.lisa_rectangle_window(), + bandwidth=1000000.0, + min_density=0.05, + edge_correction=false, + window_padding=0.0, + ) catch { + _ => abort("broad KDE configuration should be valid") + } + let narrow_curves = @src.lisa_curves( + lisa_test_exact_cells(), + config=narrow, + ) catch { + _ => abort("narrow KDE curves should compute") + } + let broad_curves = @src.lisa_curves( + lisa_test_exact_cells(), + config=broad, + ) catch { + _ => abort("broad KDE curves should compute") + } + let feature = narrow_curves.feature_index("B", 2.0) + assert_true( + (narrow_curves.values[0][feature] - broad_curves.values[0][feature]).abs() > + 1.0e-6, + ) +} + +///| +test "lisaClust: generated curves are finite" { + let curves = @src.lisa_curves( + lisa_test_cells(), + config=lisa_test_config(edge_correction=true), + ) catch { + _ => abort("edge corrected curves should compute") + } + for row in curves.values { + for value in row { + assert_true(value == value) + assert_true(value.abs() <= 1.0e300) + } + } +} + +///| +test "lisaClust: curve lookup returns a defensive copy" { + let curves = @src.lisa_curves( + lisa_test_cells(), + config=lisa_test_config(), + ) catch { + _ => abort("lisaClust curves should compute") + } + let curve = match curves.curve_for_cell("a1") { + Some(value) => value + None => abort("cell curve should exist") + } + curve[0] = 999.0 + assert_true(curves.values[0][0] != 999.0) + assert_true(curves.curve_for_cell("missing") is None) +} + +///| +test "lisaClust: duplicate cell IDs are rejected" { + let cells = lisa_test_cells() + cells.push(lisa_test_cell("a1", "image_1", "A", 4.0, 4.0)) + let failed = try { + ignore(@src.lisa_curves(cells, config=lisa_test_config())) + false + } catch { + LisaError(_) => true + } + assert_true(failed) +} + +///| +test "lisaClust: fewer than two cells are rejected" { + let failed = try { + ignore( + @src.lisa_curves( + [lisa_test_cell("only", "image", "A", 0.0, 0.0)], + config=lisa_test_config(), + ), + ) + false + } catch { + LisaError(_) => true + } + assert_true(failed) +} + +///| +test "lisaClust: one-cell images are rejected" { + let cells = lisa_test_cells() + cells.push(lisa_test_cell("single", "image_2", "A", 2.0, 2.0)) + let failed = try { + ignore(@src.lisa_curves(cells, config=lisa_test_config())) + false + } catch { + LisaError(_) => true + } + assert_true(failed) +} + +///| +test "lisaClust: degenerate rectangular windows are rejected" { + let cells = [ + lisa_test_cell("one", "image", "A", 0.0, 0.0), + lisa_test_cell("two", "image", "B", 1.0, 0.0), + ] + let failed = try { + ignore(@src.lisa_curves(cells, config=lisa_test_config())) + false + } catch { + LisaError(_) => true + } + assert_true(failed) +} + +///| +test "lisaClust: collinear convex windows are rejected" { + let cells = [ + lisa_test_cell("one", "image", "A", 0.0, 0.0), + lisa_test_cell("two", "image", "B", 1.0, 1.0), + lisa_test_cell("three", "image", "B", 2.0, 2.0), + ] + let config = @src.LisaConfig::create( + radii=[1.0], + window_kind=@src.lisa_convex_window(), + ) catch { + _ => abort("convex configuration should be valid") + } + let failed = try { + ignore(@src.lisa_curves(cells, config~)) + false + } catch { + LisaError(_) => true + } + assert_true(failed) +} + +///| +test "lisaClust: complete workflow returns deterministic regions" { + let first = lisa_test_result() + let second = lisa_test_result() + assert_eq(first.labels, second.labels) + assert_eq(first.regions, second.regions) + assert_eq(first.cluster_sizes, second.cluster_sizes) + assert_eq(first.centroids, second.centroids) +} + +///| +test "lisaClust: complete workflow reports fit diagnostics" { + let result = lisa_test_result() + assert_eq(result.n_cells(), 8) + assert_eq(result.n_regions(), 2) + assert_eq(result.labels.length(), 8) + assert_eq(result.centroids.length(), 2) + assert_eq(result.cluster_sizes[0] + result.cluster_sizes[1], 8) + assert_true(result.inertia >= 0.0) + assert_true(result.silhouette >= -1.0) + assert_true(result.silhouette <= 1.0) + assert_true(result.iterations > 0) + assert_true(result.converged) +} + +///| +test "lisaClust: custom region prefix is propagated" { + let result = @src.lisaclust( + lisa_test_cells(), + config=lisa_test_config(region_prefix="domain"), + ) catch { + _ => abort("custom prefix workflow should succeed") + } + for region in result.regions { + assert_true(region.has_prefix("domain_")) + } +} + +///| +test "lisaClust: cell-to-region lookup handles known and unknown IDs" { + let result = lisa_test_result() + assert_true(result.region_for_cell("a1") is Some(_)) + assert_true(result.region_for_cell("missing") is None) +} + +///| +test "lisaClust: region enrichment covers every type-region combination" { + let result = lisa_test_result() + assert_eq(result.enrichment.length(), 6) + assert_eq(result.region_summaries.length(), 2) + for summary in result.region_summaries { + assert_true(summary.size > 0) + assert_true(summary.dominant_cell_type != "") + assert_true(summary.maximum_enrichment >= 0.0) + } +} + +///| +test "lisaClust: region enrichment uses observed over independence expectation" { + let result = lisa_test_result() + let entry = result.enrichment[0] + if entry.expected > 0.0 { + lisa_test_close( + entry.relative_frequency, + entry.observed.to_double() / entry.expected, + 1.0e-12, + ) + } + assert_true( + result.region_enrichment(entry.cell_type, entry.region) is Some(_), + ) + assert_true(result.region_enrichment("missing", entry.region) is None) +} + +///| +test "lisaClust: top enrichments are sorted and filtered" { + let result = lisa_test_result() + let top = result.top_enrichments( + limit=3, + minimum_relative_frequency=0.0, + ) catch { + _ => abort("top enrichments should succeed") + } + assert_eq(top.length(), 3) + assert_true(top[0].relative_frequency >= top[1].relative_frequency) + assert_true(top[1].relative_frequency >= top[2].relative_frequency) +} + +///| +test "lisaClust: top enrichment validates query controls" { + let result = lisa_test_result() + let bad_limit = try { + ignore(result.top_enrichments(limit=-1)) + false + } catch { + LisaError(_) => true + } + let bad_threshold = try { + ignore(result.top_enrichments(minimum_relative_frequency=-1.0)) + false + } catch { + LisaError(_) => true + } + assert_true(bad_limit) + assert_true(bad_threshold) +} + +///| +test "lisaClust: summary reports cells features and regions" { + let summary = lisa_test_result().summary() + assert_true(summary.contains("lisaClust")) + assert_true(summary.contains("cells=8")) + assert_true(summary.contains("features=6")) + assert_true(summary.contains("regions=2")) +} + +///| +test "lisaClust: cluster count cannot exceed cells" { + let curves = @src.lisa_curves( + lisa_test_cells(), + config=lisa_test_config(), + ) catch { + _ => abort("lisaClust curves should compute") + } + let config = lisa_test_config(n_clusters=9) + let failed = try { + ignore(@src.lisaclust_from_curves(curves, config~)) + false + } catch { + LisaError(_) => true + } + assert_true(failed) +} + +///| +test "lisaClust: one-region clustering is supported" { + let result = @src.lisaclust( + lisa_test_cells(), + config=lisa_test_config(n_clusters=1), + ) catch { + _ => abort("single-region lisaClust should succeed") + } + assert_eq(result.n_regions(), 1) + assert_eq(result.cluster_sizes, [8]) + assert_eq(result.silhouette, 0.0) +} + +///| +test "lisaClust: example data has two balanced images and four types" { + let cells = @src.lisaclust_example_data() + assert_eq(cells.length(), 64) + let images : Map[String, Int] = Map([]) + let types : Map[String, Bool] = Map([]) + for cell in cells { + images[cell.image_id] = match images.get(cell.image_id) { + Some(count) => count + 1 + None => 1 + } + types[cell.cell_type] = true + } + assert_eq(images["image_1"], 32) + assert_eq(images["image_2"], 32) + assert_eq(types.length(), 4) +} + +///| +test "lisaClust: example data separates spatial compartments" { + let config = @src.LisaConfig::create( + radii=[2.5, 5.0], + window_kind=@src.lisa_rectangle_window(), + bandwidth=4.0, + edge_correction=true, + window_padding=0.1, + edge_samples=64, + n_clusters=2, + n_starts=5, + seed=11, + ) catch { + _ => abort("example lisaClust configuration should be valid") + } + let result = @src.lisaclust(@src.lisaclust_example_data(), config~) catch { + _ => abort("example lisaClust workflow should succeed") + } + assert_eq(result.n_cells(), 64) + assert_eq(result.n_regions(), 2) + assert_true(result.silhouette > 0.0) +} + +///| +test "lisaClust: SpatialExperiment adapter writes regions to a copy" { + let experiment = lisa_test_experiment() + let output = @src.lisaclust_spatial_experiment( + experiment, + cell_id_key="cellID", + config=lisa_test_config(), + ) catch { + _ => abort("lisaClust SpatialExperiment integration should succeed") + } + assert_eq(output.result.n_cells(), 8) + assert_eq(output.experiment.col_data.length(), 8) + assert_true(output.experiment.col_data[0].contains("region")) + assert_true(!experiment.col_data[0].contains("region")) + assert_eq(output.experiment.metadata["lisaclust_regions"], "2") + assert_eq(output.experiment.metadata["lisaclust_features"], "6") +} + +///| +test "lisaClust: SpatialExperiment adapter supports generated cell IDs" { + let output = @src.lisaclust_spatial_experiment( + lisa_test_experiment(), + config=lisa_test_config(), + ) catch { + _ => abort("generated lisaClust IDs should succeed") + } + assert_eq(output.result.curves.cell_ids[0], "cell_1") + assert_eq(output.result.curves.cell_ids[7], "cell_8") +} + +///| +test "lisaClust: SpatialExperiment adapter supports custom region key" { + let output = @src.lisaclust_spatial_experiment( + lisa_test_experiment(), + cell_id_key="cellID", + region_key="microenvironment", + config=lisa_test_config(), + ) catch { + _ => abort("custom lisaClust region key should succeed") + } + assert_true(output.experiment.col_data[0].contains("microenvironment")) + assert_true(!output.experiment.col_data[0].contains("region")) +} + +///| +test "lisaClust: SpatialExperiment rejects empty col_data" { + let failed = try { + ignore( + @src.lisaclust_spatial_experiment( + @src.SpatialExperiment::new(), + config=lisa_test_config(), + ), + ) + false + } catch { + LisaError(_) => true + } + assert_true(failed) +} + +///| +test "lisaClust: SpatialExperiment rejects coordinate mismatch" { + let experiment = lisa_test_experiment() + ignore(experiment.spatial_coords.pop()) + let failed = try { + ignore( + @src.lisaclust_spatial_experiment( + experiment, + config=lisa_test_config(), + ), + ) + false + } catch { + LisaError(_) => true + } + assert_true(failed) +} + +///| +test "lisaClust: SpatialExperiment rejects missing required columns" { + let experiment = lisa_test_experiment() + ignore(experiment.col_data[0].remove("cellType")) + let failed = try { + ignore( + @src.lisaclust_spatial_experiment( + experiment, + config=lisa_test_config(), + ), + ) + false + } catch { + LisaError(_) => true + } + assert_true(failed) +} + +///| +test "lisaClust: SpatialExperiment rejects duplicate supplied cell IDs" { + let experiment = lisa_test_experiment() + experiment.col_data[1]["cellID"] = experiment.col_data[0]["cellID"] + let failed = try { + ignore( + @src.lisaclust_spatial_experiment( + experiment, + cell_id_key="cellID", + config=lisa_test_config(), + ), + ) + false + } catch { + LisaError(_) => true + } + assert_true(failed) +} + +///| +test "lisaClust: SpatialExperiment validates key names" { + let failed = try { + ignore( + @src.lisaclust_spatial_experiment( + lisa_test_experiment(), + region_key="", + config=lisa_test_config(), + ), + ) + false + } catch { + LisaError(_) => true + } + assert_true(failed) +} diff --git a/test/moonbit/mast_advanced_test.mbt b/test/moonbit/mast_advanced_test.mbt new file mode 100644 index 00000000..86e1fe76 --- /dev/null +++ b/test/moonbit/mast_advanced_test.mbt @@ -0,0 +1,913 @@ +///| +fn mast_adv_test_group_data() -> @src.MastAdvancedData { + @src.mast_advanced_from_groups( + [ + [0.0, 1.0, 0.0, 1.1, 0.0, 2.0, 0.0, 2.1], + [0.0, 0.0, 1.0, 1.1, 2.0, 2.1, 2.2, 2.3], + [1.0, 1.1, 0.9, 1.2, 1.0, 1.1, 0.9, 1.2], + ], + ["A", "A", "A", "A", "B", "B", "B", "B"], + reference="A", + gene_names=["continuous", "detection", "stable"], + cell_names=["c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8"], + include_cdr=false, + ) catch { + _ => abort("valid grouped MAST data should build") + } +} + +///| +fn mast_adv_test_example_result() -> @src.MastAdvancedResult { + let (data, tested) = @src.mast_advanced_example() catch { + _ => abort("MAST advanced example should build") + } + @src.mast_advanced_zlm(data, tested) catch { + _ => abort("MAST advanced example should fit") + } +} + +///| +fn mast_adv_test_sce() -> @src.SingleCellExperiment { + let (data, _) = @src.mast_advanced_example() catch { + _ => abort("MAST advanced example should build") + } + let experiment = @src.SingleCellExperiment::new( + data.expression, + data.gene_names, + data.cell_names, + ) + experiment.assays["logcounts"] = data.expression.map(fn(row) { row.copy() }) + let groups : Array[String] = [] + for cell in 0.. @src.MastAdvancedResult { + let data = @src.mast_advanced_from_groups( + [ + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [1.0, 1.1, 0.9, 1.2, 1.0, 1.1, 2.0, 2.1, 1.9, 2.2, 2.0, 2.1], + [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 1.1, 0.0, 1.2, 2.0, 0.0, 2.1, 0.0, 2.2, 0.0], + ], + ["A", "A", "A", "A", "A", "A", "B", "B", "B", "B", "B", "B"], + reference="A", + gene_names=["zero", "all_positive", "sparse", "mixed"], + include_cdr=false, + ) catch { + _ => abort("valid MAST NA test data should build") + } + let config = @src.MastAdvancedConfig::create(empirical_bayes=false) catch { + _ => abort("valid MAST configuration should build") + } + @src.mast_advanced_zlm(data, [1], config~) catch { + _ => abort("MAST NA test data should fit") + } +} + +///| +test "MAST advanced default configuration matches zlm workflow" { + let config = @src.MastAdvancedConfig::default() + assert_eq(config.max_iterations, 100) + assert_eq(config.cauchy_prior_scale, 2.5) + assert_true(config.empirical_bayes) + assert_eq(config.ebayes_use_full_model, false) + assert_eq(config.minimum_detected, 2) + assert_eq(config.fdr_threshold, 0.05) +} + +///| +test "MAST advanced configuration preserves explicit controls" { + let config = @src.MastAdvancedConfig::create( + max_iterations=25, + tolerance=1.0e-6, + cauchy_prior_scale=1.5, + ridge=1.0e-5, + empirical_bayes=false, + ebayes_use_full_model=true, + maximum_prior_df=50.0, + minimum_detected=3, + minimum_probability=1.0e-7, + fdr_threshold=0.1, + ) catch { + _ => abort("valid explicit MAST configuration should build") + } + assert_eq(config.max_iterations, 25) + assert_eq(config.tolerance, 1.0e-6) + assert_eq(config.cauchy_prior_scale, 1.5) + assert_eq(config.ridge, 1.0e-5) + assert_eq(config.empirical_bayes, false) + assert_true(config.ebayes_use_full_model) + assert_eq(config.maximum_prior_df, 50.0) + assert_eq(config.minimum_detected, 3) + assert_eq(config.minimum_probability, 1.0e-7) + assert_eq(config.fdr_threshold, 0.1) +} + +///| +test "MAST advanced rejects invalid iteration and tolerance controls" { + let iterations = try { + ignore(@src.MastAdvancedConfig::create(max_iterations=0)) + false + } catch { + _ => true + } + let tolerance = try { + ignore(@src.MastAdvancedConfig::create(tolerance=0.0)) + false + } catch { + _ => true + } + assert_true(iterations) + assert_true(tolerance) +} + +///| +test "MAST advanced rejects invalid prior and ridge controls" { + let scale = try { + ignore(@src.MastAdvancedConfig::create(cauchy_prior_scale=0.0)) + false + } catch { + _ => true + } + let ridge = try { + ignore(@src.MastAdvancedConfig::create(ridge=-1.0)) + false + } catch { + _ => true + } + let prior_df = try { + ignore(@src.MastAdvancedConfig::create(maximum_prior_df=0.0)) + false + } catch { + _ => true + } + assert_true(scale) + assert_true(ridge) + assert_true(prior_df) +} + +///| +test "MAST advanced rejects invalid probability controls" { + let minimum = try { + ignore(@src.MastAdvancedConfig::create(minimum_probability=0.5)) + false + } catch { + _ => true + } + let fdr = try { + ignore(@src.MastAdvancedConfig::create(fdr_threshold=1.1)) + false + } catch { + _ => true + } + let detected = try { + ignore(@src.MastAdvancedConfig::create(minimum_detected=0)) + false + } catch { + _ => true + } + assert_true(minimum) + assert_true(fdr) + assert_true(detected) +} + +///| +test "MAST advanced grouped constructor uses feature by cell orientation" { + let data = mast_adv_test_group_data() + assert_eq(data.n_genes, 3) + assert_eq(data.n_cells, 8) + assert_eq(data.expression[0].length(), 8) + assert_eq(data.gene_names, ["continuous", "detection", "stable"]) + assert_eq(data.cell_names[7], "c8") +} + +///| +test "MAST advanced grouped constructor uses treatment coding" { + let data = mast_adv_test_group_data() + assert_eq(data.coefficient_names, ["(Intercept)", "group:B"]) + assert_eq(data.design[0], [1.0, 0.0]) + assert_eq(data.design[4], [1.0, 1.0]) +} + +///| +test "MAST advanced grouped constructor honors reference level" { + let data = @src.mast_advanced_from_groups( + [[1.0, 2.0, 3.0, 4.0]], + ["A", "A", "B", "B"], + reference="B", + include_cdr=false, + ) catch { + _ => abort("valid reference level should build") + } + assert_eq(data.coefficient_names, ["(Intercept)", "group:A"]) + assert_eq(data.design[0], [1.0, 1.0]) + assert_eq(data.design[2], [1.0, 0.0]) +} + +///| +test "MAST advanced constructor appends cell detection rate" { + let data = @src.MastAdvancedData::create( + [[1.0, 1.0, 1.0, 1.0], [0.0, 1.0, 0.0, 1.0], [0.0, 0.0, 1.0, 1.0]], + [[1.0], [1.0], [1.0], [1.0]], + ["(Intercept)"], + ) catch { + _ => abort("variable CDR should produce a full-rank design") + } + assert_eq(data.coefficient_names, ["(Intercept)", "cngeneson"]) + assert_eq(data.cdr, [1.0 / 3.0, 2.0 / 3.0, 2.0 / 3.0, 1.0]) + assert_eq(data.design[3], [1.0, 1.0]) +} + +///| +test "MAST advanced constructor supports arbitrary design matrices" { + let data = @src.MastAdvancedData::create( + [[1.0, 1.2, 1.4, 2.0, 2.2, 2.4]], + [ + [1.0, 0.0, -1.0], + [1.0, 0.0, 0.0], + [1.0, 0.0, 1.0], + [1.0, 1.0, -1.0], + [1.0, 1.0, 0.0], + [1.0, 1.0, 1.0], + ], + ["(Intercept)", "condition", "batch_score"], + include_cdr=false, + ) catch { + _ => abort("full-rank arbitrary design should build") + } + assert_eq(data.n_coefficients, 3) + assert_eq(data.design[5][2], 1.0) +} + +///| +test "MAST advanced constructor defensively copies inputs" { + let expression = [[1.0, 0.0, 2.0, 0.0]] + let design = [[1.0], [1.0], [1.0], [1.0]] + let genes = ["g1"] + let cells = ["c1", "c2", "c3", "c4"] + let data = @src.MastAdvancedData::create( + expression, + design, + ["(Intercept)"], + gene_names=genes, + cell_names=cells, + include_cdr=false, + ) catch { + _ => abort("valid MAST data should build") + } + expression[0][0] = 99.0 + design[0][0] = 99.0 + genes[0] = "changed" + cells[0] = "changed" + assert_eq(data.expression[0][0], 1.0) + assert_eq(data.design[0][0], 1.0) + assert_eq(data.gene_names[0], "g1") + assert_eq(data.cell_names[0], "c1") +} + +///| +test "MAST advanced constructor rejects empty and ragged expression" { + let empty = try { + ignore(@src.MastAdvancedData::create([], [], [], include_cdr=false)) + false + } catch { + _ => true + } + let ragged = try { + ignore( + @src.MastAdvancedData::create( + [[1.0, 2.0], [3.0]], + [[1.0], [1.0]], + ["intercept"], + include_cdr=false, + ), + ) + false + } catch { + _ => true + } + assert_true(empty) + assert_true(ragged) +} + +///| +test "MAST advanced constructor rejects invalid expression values" { + let negative = try { + ignore( + @src.MastAdvancedData::create( + [[1.0, -1.0]], + [[1.0], [1.0]], + ["intercept"], + include_cdr=false, + ), + ) + false + } catch { + _ => true + } + let non_finite = try { + ignore( + @src.MastAdvancedData::create( + [[1.0, Double::nan()]], + [[1.0], [1.0]], + ["intercept"], + include_cdr=false, + ), + ) + false + } catch { + _ => true + } + assert_true(negative) + assert_true(non_finite) +} + +///| +test "MAST advanced constructor validates design dimensions" { + let rows = try { + ignore( + @src.MastAdvancedData::create( + [[1.0, 2.0]], + [[1.0]], + ["intercept"], + include_cdr=false, + ), + ) + false + } catch { + _ => true + } + let columns = try { + ignore( + @src.MastAdvancedData::create( + [[1.0, 2.0]], + [[1.0], [1.0, 0.0]], + ["intercept"], + include_cdr=false, + ), + ) + false + } catch { + _ => true + } + let names = try { + ignore( + @src.MastAdvancedData::create( + [[1.0, 2.0]], + [[1.0], [1.0]], + [], + include_cdr=false, + ), + ) + false + } catch { + _ => true + } + assert_true(rows) + assert_true(columns) + assert_true(names) +} + +///| +test "MAST advanced constructor rejects rank deficient designs" { + let raised = try { + ignore( + @src.MastAdvancedData::create( + [[1.0, 2.0, 3.0]], + [[1.0, 2.0], [1.0, 2.0], [1.0, 2.0]], + ["intercept", "constant"], + include_cdr=false, + ), + ) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "MAST advanced constructor validates identifiers" { + let length = try { + ignore( + @src.MastAdvancedData::create( + [[1.0, 2.0]], + [[1.0], [1.0]], + ["intercept"], + gene_names=["g1", "g2"], + include_cdr=false, + ), + ) + false + } catch { + _ => true + } + let duplicate = try { + ignore( + @src.MastAdvancedData::create( + [[1.0, 2.0], [2.0, 3.0]], + [[1.0], [1.0]], + ["intercept"], + gene_names=["g1", "g1"], + include_cdr=false, + ), + ) + false + } catch { + _ => true + } + let empty = try { + ignore( + @src.MastAdvancedData::create( + [[1.0, 2.0]], + [[1.0], [1.0]], + [" "], + include_cdr=false, + ), + ) + false + } catch { + _ => true + } + assert_true(length) + assert_true(duplicate) + assert_true(empty) +} + +///| +test "MAST advanced grouped constructor validates groups and reference" { + let length = try { + ignore( + @src.mast_advanced_from_groups([[1.0, 2.0]], ["A"], include_cdr=false), + ) + false + } catch { + _ => true + } + let one_level = try { + ignore( + @src.mast_advanced_from_groups( + [[1.0, 2.0]], + ["A", "A"], + include_cdr=false, + ), + ) + false + } catch { + _ => true + } + let reference = try { + ignore( + @src.mast_advanced_from_groups( + [[1.0, 2.0]], + ["A", "B"], + reference="C", + include_cdr=false, + ), + ) + false + } catch { + _ => true + } + assert_true(length) + assert_true(one_level) + assert_true(reference) +} + +///| +test "MAST advanced example exposes intended dimensions and contrast" { + let (data, tested) = @src.mast_advanced_example() catch { + _ => abort("MAST advanced example should build") + } + assert_eq(data.n_genes, 8) + assert_eq(data.n_cells, 48) + assert_eq(data.coefficient_names[1], "group:stimulated") + assert_eq(tested, [1]) +} + +///| +test "MAST advanced zlm returns aligned result matrices" { + let result = mast_adv_test_example_result() + assert_eq(result.gene_names.length(), 8) + assert_eq(result.discrete_coefficients.length(), 8) + assert_eq(result.continuous_coefficients.length(), 8) + assert_eq( + result.discrete_coefficients[0].length(), + result.coefficient_names.length(), + ) + assert_eq(result.tested_names, ["group:stimulated"]) +} + +///| +test "MAST advanced recovers discrete and continuous effect directions" { + let result = mast_adv_test_example_result() + assert_true(result.discrete_coefficients[0][1] > 0.0) + assert_true(result.continuous_coefficients[0][1] > 0.0) + assert_true(result.continuous_coefficients[1][1] > 0.0) +} + +///| +test "MAST advanced computes valid component and hurdle probabilities" { + let result = mast_adv_test_example_result() + for gene in 0.. assert_true(value >= 0.0 && value <= 1.0) + None => () + } + match result.hurdle_fdr[gene] { + Some(value) => assert_true(value >= 0.0 && value <= 1.0) + None => () + } + } + assert_true(result.n_tested() > 0) +} + +///| +test "MAST advanced hurdle statistic sums testable components" { + let result = mast_adv_test_example_result() + let discrete = result.discrete_statistics[0].unwrap_or(-1.0) + let continuous = result.continuous_statistics[0].unwrap_or(-1.0) + let hurdle = result.hurdle_statistics[0].unwrap_or(-1.0) + assert_true(discrete >= 0.0) + assert_true(continuous >= 0.0) + assert_true((hurdle - discrete - continuous).abs() < 1.0e-8) +} + +///| +test "MAST advanced empirical Bayes estimates a finite variance prior" { + let result = mast_adv_test_example_result() + assert_true(result.empirical_bayes) + assert_true(result.prior_variance > 0.0) + assert_true(result.prior_variance < 1.0e300) + assert_true(result.prior_df > 0.0) + assert_true(result.prior_df <= 1000.0) +} + +///| +test "MAST advanced empirical Bayes supports full-model residuals" { + let (data, tested) = @src.mast_advanced_example() catch { + _ => abort("MAST advanced example should build") + } + let config = @src.MastAdvancedConfig::create( + ebayes_use_full_model=true, + maximum_prior_df=80.0, + ) catch { + _ => abort("valid H1 eBayes configuration should build") + } + let result = @src.mast_advanced_zlm(data, tested, config~) catch { + _ => abort("full-model eBayes workflow should fit") + } + assert_true(result.empirical_bayes) + assert_true(result.prior_variance > 0.0) + assert_true(result.prior_df > 0.0 && result.prior_df <= 80.0) +} + +///| +test "MAST advanced can disable empirical Bayes moderation" { + let (data, tested) = @src.mast_advanced_example() catch { + _ => abort("MAST advanced example should build") + } + let config = @src.MastAdvancedConfig::create(empirical_bayes=false) catch { + _ => abort("valid unmoderated configuration should build") + } + let result = @src.mast_advanced_zlm(data, tested, config~) catch { + _ => abort("unmoderated MAST workflow should fit") + } + assert_eq(result.empirical_bayes, false) + assert_eq(result.prior_variance, 0.0) + assert_eq(result.prior_df, 0.0) + for gene in 0.. + assert_true((raw - moderated).abs() < 1.0e-10) + _ => () + } + } +} + +///| +test "MAST advanced moderated variances are finite and positive" { + let result = mast_adv_test_example_result() + for value in result.moderated_variance { + match value { + Some(variance) => { + assert_true(variance > 0.0) + assert_true(variance < 1.0e300) + } + None => () + } + } +} + +///| +test "MAST advanced preserves NA semantics for untestable genes" { + let result = mast_adv_test_na_result() + assert_true(result.discrete_p_values[0] is None) + assert_true(result.continuous_p_values[0] is None) + assert_true(result.hurdle_p_values[0] is None) + assert_true(result.discrete_p_values[1] is None) + assert_true(result.continuous_p_values[1] is Some(_)) + assert_true(result.continuous_p_values[2] is None) +} + +///| +test "MAST advanced combines whichever hurdle components are testable" { + let result = mast_adv_test_na_result() + assert_true(result.hurdle_p_values[1] is Some(_)) + assert_true(result.hurdle_p_values[2] is Some(_)) + assert_true(result.hurdle_p_values[3] is Some(_)) +} + +///| +test "MAST advanced BH correction preserves missing values" { + let result = mast_adv_test_na_result() + assert_true(result.hurdle_fdr[0] is None) + for gene in 1.. assert_true(fdr + 1.0e-12 >= p) + _ => () + } + } +} + +///| +test "MAST advanced marginal effects and delta variances are finite" { + let result = mast_adv_test_example_result() + assert_true(result.marginal_log_fc[0].unwrap_or(0.0) > 0.0) + assert_true(result.marginal_log_fc[1] is Some(_)) + assert_true(result.marginal_log_fc[1].unwrap_or(1.0e300).abs() < 1.0e300) + assert_true(result.marginal_log_fc_variance[0].unwrap_or(-1.0) >= 0.0) +} + +///| +test "MAST advanced fitting is deterministic" { + let first = mast_adv_test_example_result() + let second = mast_adv_test_example_result() + assert_eq(first.discrete_coefficients, second.discrete_coefficients) + assert_eq(first.continuous_coefficients, second.continuous_coefficients) + assert_eq(first.hurdle_p_values, second.hurdle_p_values) + assert_eq(first.hurdle_fdr, second.hurdle_fdr) +} + +///| +test "MAST advanced supports joint deletion of design columns" { + let data = @src.MastAdvancedData::create( + [[1.0, 1.1, 1.2, 1.3, 2.0, 2.1, 2.2, 2.3, 3.0, 3.1, 3.2, 3.3]], + [ + [1.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [1.0, 1.0, 0.0], + [1.0, 1.0, 0.0], + [1.0, 1.0, 0.0], + [1.0, 1.0, 0.0], + [1.0, 0.0, 1.0], + [1.0, 0.0, 1.0], + [1.0, 0.0, 1.0], + [1.0, 0.0, 1.0], + ], + ["(Intercept)", "group:B", "group:C"], + include_cdr=false, + ) catch { + _ => abort("valid multi-level design should build") + } + let config = @src.MastAdvancedConfig::create(empirical_bayes=false) catch { + _ => abort("valid MAST configuration should build") + } + let result = @src.mast_advanced_zlm(data, [1, 2], config~) catch { + _ => abort("joint reduced-model test should fit") + } + assert_eq(result.tested_names, ["group:B", "group:C"]) + assert_true(result.continuous_p_values[0] is Some(_)) + assert_true(result.hurdle_statistics[0].unwrap_or(-1.0) >= 0.0) +} + +///| +test "MAST advanced validates tested coefficient indices" { + let data = mast_adv_test_group_data() + let empty = try { + ignore(@src.mast_advanced_zlm(data, [])) + false + } catch { + _ => true + } + let intercept = try { + ignore(@src.mast_advanced_zlm(data, [0])) + false + } catch { + _ => true + } + let range = try { + ignore(@src.mast_advanced_zlm(data, [2])) + false + } catch { + _ => true + } + let duplicate = try { + ignore(@src.mast_advanced_zlm(data, [1, 1])) + false + } catch { + _ => true + } + assert_true(empty) + assert_true(intercept) + assert_true(range) + assert_true(duplicate) +} + +///| +test "MAST advanced result query helpers are consistent" { + let result = mast_adv_test_example_result() + assert_eq(result.index_of("both_components"), Some(0)) + assert_true(result.index_of("missing") is None) + assert_true(result.n_tested() <= result.gene_names.length()) + assert_eq(result.significant_genes().length(), result.n_significant()) + assert_true(result.top_genes(3).length() <= 3) + assert_eq(result.top_genes(0), []) +} + +///| +test "MAST advanced result summary reports contrast and tested count" { + let result = mast_adv_test_example_result() + let summary = result.summary() + assert_true(summary.contains("MAST advanced zlm")) + assert_true(summary.contains("group:stimulated")) + assert_true(summary.contains(result.n_tested().to_string())) +} + +///| +test "MAST advanced SingleCellExperiment writes row and cell results" { + let output = @src.mast_advanced_zlm_sce( + mast_adv_test_sce(), + "condition", + reference="control", + output_prefix="mast39", + ) catch { + _ => abort("valid MAST SCE workflow should fit") + } + assert_eq(output.experiment.row_data["mast39.detectionRate"].length(), 8) + assert_eq(output.experiment.row_data["mast39.nDetected"].length(), 8) + assert_eq(output.experiment.row_data["mast39.hurdleP"].length(), 8) + assert_eq(output.experiment.row_data["mast39.hurdleFdr"].length(), 8) + assert_eq(output.experiment.row_data["mast39.class"].length(), 8) + assert_eq(output.experiment.col_data["mast39.cdr"].length(), 48) +} + +///| +test "MAST advanced SingleCellExperiment records provenance metadata" { + let output = @src.mast_advanced_zlm_sce( + mast_adv_test_sce(), + "condition", + reference="control", + output_prefix="mast39", + ) catch { + _ => abort("valid MAST SCE workflow should fit") + } + assert_eq(output.experiment.metadata["mast39.assay"], "logcounts") + assert_eq(output.experiment.metadata["mast39.group"], "condition") + assert_eq(output.experiment.metadata["mast39.reference"], "control") + assert_eq(output.experiment.metadata["mast39.contrast"], "group:stimulated") + assert_eq(output.experiment.metadata["source"], "test") +} + +///| +test "MAST advanced SingleCellExperiment does not mutate input" { + let input = mast_adv_test_sce() + let output = @src.mast_advanced_zlm_sce( + input, + "condition", + reference="control", + output_prefix="mast39", + ) catch { + _ => abort("valid MAST SCE workflow should fit") + } + assert_eq(input.row_data.contains("mast39.hurdleP"), false) + assert_eq(input.col_data.contains("mast39.cdr"), false) + output.experiment.assays["logcounts"][0][0] = 999.0 + output.experiment.row_data["symbol"][0] = "changed" + output.experiment.reduced_dims["PCA"][0][0] = 999.0 + output.experiment.alternative_experiments["spike"].assays["counts"][0][0] = 999.0 + assert_true(input.assays["logcounts"][0][0] != 999.0) + assert_eq(input.row_data["symbol"][0], "both_components") + assert_eq(input.reduced_dims["PCA"][0][0], 0.0) + assert_eq(input.alternative_experiments["spike"].assays["counts"][0][0], 1.0) +} + +///| +test "MAST advanced SingleCellExperiment supports custom assay and prefix" { + let input = mast_adv_test_sce() + let output = @src.mast_advanced_zlm_sce( + input, + "condition", + assay_name="counts", + reference="control", + output_prefix="custom", + include_cdr=false, + ) catch { + _ => abort("custom MAST SCE workflow should fit") + } + assert_true(output.experiment.row_data.contains("custom.logFC")) + assert_eq(output.experiment.metadata["custom.assay"], "counts") + assert_eq(output.result.coefficient_names, ["(Intercept)", "group:stimulated"]) +} + +///| +test "MAST advanced SingleCellExperiment writes NA for untestable values" { + let result = mast_adv_test_na_result() + let experiment = @src.SingleCellExperiment::new( + [ + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + [1.0, 1.1, 0.9, 1.2, 1.0, 1.1, 2.0, 2.1, 1.9, 2.2, 2.0, 2.1], + [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 1.1, 0.0, 1.2, 2.0, 0.0, 2.1, 0.0, 2.2, 0.0], + ], + result.gene_names, + ["c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10", "c11", "c12"], + ) + experiment.assays["logcounts"] = experiment.assays["counts"] + experiment.col_data["condition"] = [ + "A", "A", "A", "A", "A", "A", "B", "B", "B", "B", "B", "B", + ] + let config = @src.MastAdvancedConfig::create(empirical_bayes=false) catch { + _ => abort("valid MAST configuration should build") + } + let output = @src.mast_advanced_zlm_sce( + experiment, + "condition", + reference="A", + include_cdr=false, + config~, + ) catch { + _ => abort("MAST NA SCE workflow should fit") + } + assert_eq(output.experiment.row_data["mast.hurdleP"][0], "NA") + assert_eq(output.experiment.row_data["mast.class"][0], "not_tested") +} + +///| +test "MAST advanced SingleCellExperiment rejects missing inputs" { + let assay = try { + ignore( + @src.mast_advanced_zlm_sce( + mast_adv_test_sce(), + "condition", + assay_name="missing", + ), + ) + false + } catch { + _ => true + } + let group = try { + ignore(@src.mast_advanced_zlm_sce(mast_adv_test_sce(), "missing")) + false + } catch { + _ => true + } + assert_true(assay) + assert_true(group) +} + +///| +test "MAST advanced SingleCellExperiment validates prefix and reference" { + let prefix = try { + ignore( + @src.mast_advanced_zlm_sce( + mast_adv_test_sce(), + "condition", + output_prefix=" ", + ), + ) + false + } catch { + _ => true + } + let reference = try { + ignore( + @src.mast_advanced_zlm_sce( + mast_adv_test_sce(), + "condition", + reference="absent", + ), + ) + false + } catch { + _ => true + } + assert_true(prefix) + assert_true(reference) +} diff --git a/test/moonbit/moon.pkg b/test/moonbit/moon.pkg index 67883269..956590ee 100644 --- a/test/moonbit/moon.pkg +++ b/test/moonbit/moon.pkg @@ -3,4 +3,5 @@ import { "IvanAXu/BioSeqs/src" @src, "moonbitlang/core/hashmap", "moonbitlang/core/double", -} \ No newline at end of file + "moonbitlang/core/math", +} diff --git a/test/moonbit/muscat_advanced_test.mbt b/test/moonbit/muscat_advanced_test.mbt new file mode 100644 index 00000000..f428aeb6 --- /dev/null +++ b/test/moonbit/muscat_advanced_test.mbt @@ -0,0 +1,1274 @@ +///| +fn muscat_adv_test_data() -> @src.MuscatAdvancedData { + @src.muscat_advanced_example() catch { + _ => abort("valid muscat advanced example should build") + } +} + +///| +fn muscat_adv_test_config() -> @src.MuscatAdvancedConfig { + @src.MuscatAdvancedConfig::create( + min_cells=10, + min_count=1.0, + min_samples=2, + max_iterations=100, + tolerance=1.0e-8, + minimum_dispersion=1.0e-8, + maximum_dispersion=50.0, + dispersion_prior_df=10.0, + ridge=1.0e-6, + fdr_threshold=0.1, + detection_filter=0.9, + ) catch { + _ => abort("valid muscat advanced configuration should build") + } +} + +///| +fn muscat_adv_test_sum() -> @src.MuscatAdvancedPseudoBulk { + @src.muscat_aggregate_advanced( + muscat_adv_test_data(), + aggregation=@src.muscat_sum_counts(), + ) catch { + _ => abort("sum-count pseudobulk should build") + } +} + +///| +fn muscat_adv_test_detection() -> @src.MuscatAdvancedPseudoBulk { + @src.muscat_aggregate_advanced( + muscat_adv_test_data(), + aggregation=@src.muscat_number_detected(), + ) catch { + _ => abort("number-detected pseudobulk should build") + } +} + +///| +fn muscat_adv_test_design() -> @src.MuscatAdvancedDesign { + @src.muscat_group_design_advanced(muscat_adv_test_sum(), reference="ctrl") catch { + _ => abort("valid muscat group design should build") + } +} + +///| +fn muscat_adv_test_contrasts() -> Array[@src.MuscatAdvancedContrast] { + @src.muscat_default_contrasts_advanced(muscat_adv_test_design()) catch { + _ => abort("valid muscat contrast should build") + } +} + +///| +fn muscat_adv_test_ds() -> @src.MuscatAdvancedResults { + @src.muscat_pbds_advanced( + muscat_adv_test_sum(), + muscat_adv_test_design(), + muscat_adv_test_contrasts(), + config=muscat_adv_test_config(), + ) catch { + _ => abort("valid muscat DS model should fit") + } +} + +///| +fn muscat_adv_test_dd() -> @src.MuscatAdvancedResults { + @src.muscat_pbdd_advanced( + muscat_adv_test_detection(), + muscat_adv_test_design(), + muscat_adv_test_contrasts(), + config=muscat_adv_test_config(), + ) catch { + _ => abort("valid muscat DD model should fit") + } +} + +///| +fn muscat_adv_test_stagewise() -> @src.MuscatStagewiseResults { + @src.muscat_stagewise_ds_dd( + muscat_adv_test_ds(), + muscat_adv_test_dd(), + alpha=0.1, + ) catch { + _ => abort("valid muscat stagewise analysis should run") + } +} + +///| +fn muscat_adv_test_finite(value : Double) -> Bool { + value == value && value.abs() < 1.0e299 +} + +///| +fn muscat_adv_test_sce() -> @src.SingleCellExperiment { + let data = muscat_adv_test_data() + let experiment = @src.SingleCellExperiment::new( + data.counts, + data.gene_names, + data.cell_names, + ) + experiment.col_data["sample"] = data.sample_ids.copy() + experiment.col_data["cluster"] = data.cluster_ids.copy() + experiment.col_data["group"] = data.group_ids.copy() + experiment.col_data["batch"] = Array::make(data.cell_names.length(), "one") + experiment.row_data["symbol"] = data.gene_names.copy() + experiment.reduced_dims["PCA"] = [[1.0, 2.0], [3.0, 4.0]] + experiment.metadata["source"] = "test" + experiment.alternative_experiments["spike"] = @src.SingleCellExperiment::new( + [[1.0, 2.0]], + ["spike1"], + ["s1", "s2"], + ) + experiment +} + +///| +test "muscat advanced default configuration follows pseudobulk defaults" { + let config = @src.MuscatAdvancedConfig::default() + assert_eq(config.min_cells, 10) + assert_eq(config.min_count, 1.0) + assert_eq(config.min_samples, 2) + assert_eq(config.max_iterations, 100) + assert_eq(config.tolerance, 1.0e-8) + assert_eq(config.minimum_dispersion, 1.0e-8) + assert_eq(config.maximum_dispersion, 100.0) + assert_eq(config.dispersion_prior_df, 10.0) + assert_eq(config.ridge, 1.0e-8) + assert_eq(config.fdr_threshold, 0.05) + assert_eq(config.lfc_threshold, 0.0) + assert_eq(config.detection_filter, 0.9) +} + +///| +test "muscat advanced configuration preserves explicit controls" { + let config = @src.MuscatAdvancedConfig::create( + min_cells=3, + min_count=2.0, + min_samples=3, + max_iterations=40, + tolerance=1.0e-5, + minimum_dispersion=1.0e-4, + maximum_dispersion=20.0, + dispersion_prior_df=5.0, + ridge=1.0e-5, + fdr_threshold=0.2, + lfc_threshold=1.0, + detection_filter=0.8, + ) catch { + _ => abort("explicit muscat controls should be valid") + } + assert_eq(config.min_cells, 3) + assert_eq(config.min_count, 2.0) + assert_eq(config.min_samples, 3) + assert_eq(config.max_iterations, 40) + assert_eq(config.maximum_dispersion, 20.0) + assert_eq(config.dispersion_prior_df, 5.0) + assert_eq(config.fdr_threshold, 0.2) + assert_eq(config.lfc_threshold, 1.0) + assert_eq(config.detection_filter, 0.8) +} + +///| +test "muscat advanced rejects invalid filtering controls" { + let mut failures = 0 + ignore(@src.MuscatAdvancedConfig::create(min_cells=-1)) catch { + _ => failures = failures + 1 + } + ignore(@src.MuscatAdvancedConfig::create(min_count=-1.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.MuscatAdvancedConfig::create(min_count=0.0 / 0.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.MuscatAdvancedConfig::create(min_samples=0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 4) +} + +///| +test "muscat advanced rejects invalid iteration controls" { + let mut failures = 0 + ignore(@src.MuscatAdvancedConfig::create(max_iterations=0)) catch { + _ => failures = failures + 1 + } + ignore(@src.MuscatAdvancedConfig::create(tolerance=0.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.MuscatAdvancedConfig::create(tolerance=0.0 / 0.0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "muscat advanced rejects invalid dispersion controls" { + let mut failures = 0 + ignore(@src.MuscatAdvancedConfig::create(minimum_dispersion=0.0)) catch { + _ => failures = failures + 1 + } + ignore( + @src.MuscatAdvancedConfig::create( + minimum_dispersion=2.0, + maximum_dispersion=1.0, + ), + ) catch { + _ => failures = failures + 1 + } + ignore(@src.MuscatAdvancedConfig::create(dispersion_prior_df=-1.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.MuscatAdvancedConfig::create(ridge=-1.0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 4) +} + +///| +test "muscat advanced rejects invalid testing controls" { + let mut failures = 0 + ignore(@src.MuscatAdvancedConfig::create(fdr_threshold=0.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.MuscatAdvancedConfig::create(fdr_threshold=1.1)) catch { + _ => failures = failures + 1 + } + ignore(@src.MuscatAdvancedConfig::create(lfc_threshold=-1.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.MuscatAdvancedConfig::create(detection_filter=0.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.MuscatAdvancedConfig::create(detection_filter=1.1)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 5) +} + +///| +test "muscat advanced aggregation helpers expose all upstream statistics" { + assert_eq(@src.muscat_sum_counts(), @src.muscat_sum_counts()) + assert_eq(@src.muscat_mean_expression(), @src.muscat_mean_expression()) + assert_eq(@src.muscat_median_expression(), @src.muscat_median_expression()) + assert_eq( + @src.muscat_proportion_detected(), + @src.muscat_proportion_detected(), + ) + assert_eq(@src.muscat_number_detected(), @src.muscat_number_detected()) + assert_true(@src.muscat_sum_counts() != @src.muscat_mean_expression()) +} + +///| +test "muscat advanced example exposes gene by cell metadata contract" { + let data = muscat_adv_test_data() + assert_eq(data.counts.length(), 10) + assert_eq(data.counts[0].length(), 160) + assert_eq(data.gene_names.length(), 10) + assert_eq(data.cell_names.length(), 160) + assert_eq(data.sample_names, ["C1", "C2", "C3", "C4", "T1", "T2", "T3", "T4"]) + assert_eq(data.cluster_names, ["A", "B"]) + assert_eq(data.group_names, ["ctrl", "stim"]) + assert_eq(data.sample_groups, [ + "ctrl", "ctrl", "ctrl", "ctrl", "stim", "stim", "stim", "stim", + ]) +} + +///| +test "muscat advanced validates count matrix dimensions" { + let mut failures = 0 + ignore(@src.MuscatAdvancedData::create([], [], [], [])) catch { + _ => failures = failures + 1 + } + ignore(@src.MuscatAdvancedData::create([[]], [], [], [])) catch { + _ => failures = failures + 1 + } + ignore( + @src.MuscatAdvancedData::create( + [[1.0, 2.0], [1.0]], + ["s1", "s2"], + ["A", "A"], + ["c", "t"], + ), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "muscat advanced validates count values" { + let mut failures = 0 + ignore( + @src.MuscatAdvancedData::create([[-1.0, 2.0]], ["s1", "s2"], ["A", "A"], [ + "c", "t", + ]), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.MuscatAdvancedData::create([[1.5, 2.0]], ["s1", "s2"], ["A", "A"], [ + "c", "t", + ]), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.MuscatAdvancedData::create( + [[0.0 / 0.0, 2.0]], + ["s1", "s2"], + ["A", "A"], + ["c", "t"], + ), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "muscat advanced validates cell metadata dimensions and values" { + let mut failures = 0 + ignore( + @src.MuscatAdvancedData::create([[1.0, 2.0]], ["s1"], ["A", "A"], ["c", "t"]), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.MuscatAdvancedData::create([[1.0, 2.0]], ["s1", "s2"], ["A", " "], [ + "c", "t", + ]), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "muscat advanced requires replicated sample and group identities" { + let mut failures = 0 + ignore( + @src.MuscatAdvancedData::create([[1.0, 2.0]], ["s1", "s1"], ["A", "A"], [ + "c", "t", + ]), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.MuscatAdvancedData::create([[1.0, 2.0]], ["s1", "s2"], ["A", "A"], [ + "c", "c", + ]), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "muscat advanced requires each sample to have one group" { + let failed = try { + ignore( + @src.MuscatAdvancedData::create( + [[1.0, 2.0, 3.0, 4.0]], + ["s1", "s1", "s2", "s2"], + ["A", "A", "A", "A"], + ["c", "t", "t", "t"], + ), + ) + false + } catch { + _ => true + } + assert_true(failed) +} + +///| +test "muscat advanced validates gene and cell names" { + let mut failures = 0 + ignore( + @src.MuscatAdvancedData::create( + [[1.0, 2.0], [2.0, 3.0]], + ["s1", "s2"], + ["A", "A"], + ["c", "t"], + gene_names=["one"], + ), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.MuscatAdvancedData::create( + [[1.0, 2.0]], + ["s1", "s2"], + ["A", "A"], + ["c", "t"], + gene_names=[" "], + ), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.MuscatAdvancedData::create( + [[1.0, 2.0]], + ["s1", "s2"], + ["A", "A"], + ["c", "t"], + cell_names=["cell", "cell"], + ), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "muscat advanced data owns copies of caller arrays" { + let counts = [[1.0, 2.0]] + let samples = ["s1", "s2"] + let clusters = ["A", "A"] + let groups = ["c", "t"] + let data = @src.MuscatAdvancedData::create(counts, samples, clusters, groups) catch { + _ => abort("valid copied data should build") + } + data.counts[0][0] = 99.0 + data.sample_ids[0] = "changed" + assert_eq(counts[0][0], 1.0) + assert_eq(samples[0], "s1") +} + +///| +test "muscat advanced sum pseudobulk has cluster gene sample orientation" { + let pseudobulk = muscat_adv_test_sum() + assert_eq(pseudobulk.values.length(), 2) + assert_eq(pseudobulk.values[0].length(), 10) + assert_eq(pseudobulk.values[0][0].length(), 8) + assert_eq(pseudobulk.cluster_names, ["A", "B"]) + assert_eq(pseudobulk.cell_counts[0], [10, 10, 10, 10, 10, 10, 10, 10]) + assert_eq(pseudobulk.aggregation, @src.muscat_sum_counts()) + assert_false(pseudobulk.scaled_cpm) +} + +///| +test "muscat advanced sum aggregation preserves designed signals" { + let pseudobulk = muscat_adv_test_sum() + assert_eq(pseudobulk.values[0][0][0], 1009.0) + assert_eq(pseudobulk.values[0][1][0], 39.0) + assert_eq(pseudobulk.values[0][1][4], 189.0) + assert_eq(pseudobulk.values[1][2][0], 100.0) + assert_eq(pseudobulk.values[1][2][4], 100.0) + assert_eq(pseudobulk.values[0][3][0], 30.0) + assert_eq(pseudobulk.values[0][3][4], 100.0) +} + +///| +test "muscat advanced mean aggregation divides by cluster sample cells" { + let pseudobulk = @src.muscat_aggregate_advanced( + muscat_adv_test_data(), + aggregation=@src.muscat_mean_expression(), + ) + assert_true((pseudobulk.values[0][0][0] - 100.9).abs() < 1.0e-12) + assert_eq(pseudobulk.values[1][2][0], 10.0) + assert_eq(pseudobulk.values[1][2][4], 10.0) +} + +///| +test "muscat advanced median aggregation handles even cell counts" { + let pseudobulk = @src.muscat_aggregate_advanced( + muscat_adv_test_data(), + aggregation=@src.muscat_median_expression(), + ) + assert_eq(pseudobulk.values[0][0][0], 101.0) + assert_eq(pseudobulk.values[1][2][0], 0.0) + assert_eq(pseudobulk.values[1][2][4], 10.0) +} + +///| +test "muscat advanced proportion detected stays on unit interval" { + let pseudobulk = @src.muscat_aggregate_advanced( + muscat_adv_test_data(), + aggregation=@src.muscat_proportion_detected(), + ) + assert_eq(pseudobulk.values[0][0][0], 1.0) + assert_eq(pseudobulk.values[1][2][0], 0.1) + assert_eq(pseudobulk.values[1][2][4], 1.0) + for cluster in pseudobulk.values { + for gene in cluster { + for value in gene { + assert_true(value >= 0.0 && value <= 1.0) + } + } + } +} + +///| +test "muscat advanced number detected counts positive cells" { + let pseudobulk = muscat_adv_test_detection() + assert_eq(pseudobulk.values[0][0][0], 10.0) + assert_eq(pseudobulk.values[1][2][0], 1.0) + assert_eq(pseudobulk.values[1][2][4], 10.0) + assert_eq(pseudobulk.values[0][3][0], 1.0) + assert_eq(pseudobulk.values[0][3][4], 10.0) +} + +///| +test "muscat advanced aggregation fills missing cluster sample combinations" { + let data = @src.MuscatAdvancedData::create( + [[1.0, 2.0]], + ["s1", "s2"], + ["A", "B"], + ["ctrl", "stim"], + gene_names=["g"], + ) + let pseudobulk = @src.muscat_aggregate_advanced(data) + assert_eq(pseudobulk.values[0][0], [1.0, 0.0]) + assert_eq(pseudobulk.values[1][0], [0.0, 2.0]) + assert_eq(pseudobulk.cell_counts[0], [1, 0]) + assert_eq(pseudobulk.cell_counts[1], [0, 1]) +} + +///| +test "muscat advanced library sizes retain raw sum counts" { + let sums = muscat_adv_test_sum() + let means = @src.muscat_aggregate_advanced( + muscat_adv_test_data(), + aggregation=@src.muscat_mean_expression(), + ) + assert_eq(sums.library_sizes[0][0], 1107.0) + assert_eq(sums.library_sizes[1][0], 1177.0) + assert_eq(means.library_sizes, sums.library_sizes) +} + +///| +test "muscat advanced CPM scaling uses raw cluster sample library size" { + let pseudobulk = @src.muscat_aggregate_advanced( + muscat_adv_test_data(), + aggregation=@src.muscat_sum_counts(), + scale_cpm=true, + ) + assert_true(pseudobulk.scaled_cpm) + assert_true( + (pseudobulk.values[0][0][0] - 1009.0 / 1107.0 * 1.0e6).abs() < 1.0e-8, + ) +} + +///| +test "muscat advanced rejects CPM scaling of detection counts" { + let failed = try { + ignore( + @src.muscat_aggregate_advanced( + muscat_adv_test_data(), + aggregation=@src.muscat_number_detected(), + scale_cpm=true, + ), + ) + false + } catch { + _ => true + } + assert_true(failed) +} + +///| +test "muscat advanced group design uses reference coding" { + let design = muscat_adv_test_design() + assert_eq(design.matrix.length(), 8) + assert_eq(design.matrix[0], [1.0, 0.0]) + assert_eq(design.matrix[3], [1.0, 0.0]) + assert_eq(design.matrix[4], [1.0, 1.0]) + assert_eq(design.coefficient_names, ["(Intercept)", "stim-ctrl"]) + assert_eq(design.sample_names, muscat_adv_test_sum().sample_names) +} + +///| +test "muscat advanced group design supports alternate reference" { + let design = @src.muscat_group_design_advanced( + muscat_adv_test_sum(), + reference="stim", + ) + assert_eq(design.matrix[0], [1.0, 1.0]) + assert_eq(design.matrix[4], [1.0, 0.0]) + assert_eq(design.coefficient_names, ["(Intercept)", "ctrl-stim"]) +} + +///| +test "muscat advanced group design rejects absent reference" { + let failed = try { + ignore( + @src.muscat_group_design_advanced( + muscat_adv_test_sum(), + reference="missing", + ), + ) + false + } catch { + _ => true + } + assert_true(failed) +} + +///| +test "muscat advanced custom design preserves arbitrary covariates" { + let design = @src.MuscatAdvancedDesign::create( + [[1.0, 0.0], [1.0, 0.0], [1.0, 1.0], [1.0, 1.0]], + ["s1", "s2", "s3", "s4"], + ["intercept", "treatment"], + ) + assert_eq(design.matrix[2], [1.0, 1.0]) + assert_eq(design.coefficient_names, ["intercept", "treatment"]) +} + +///| +test "muscat advanced validates design dimensions and names" { + let mut failures = 0 + ignore(@src.MuscatAdvancedDesign::create([], [], [])) catch { + _ => failures = failures + 1 + } + ignore(@src.MuscatAdvancedDesign::create([[1.0], [1.0]], ["s1"], ["i"])) catch { + _ => failures = failures + 1 + } + ignore(@src.MuscatAdvancedDesign::create([[1.0], [1.0]], ["s1", "s1"], ["i"])) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "muscat advanced requires finite full-rank residual design" { + let mut failures = 0 + ignore( + @src.MuscatAdvancedDesign::create([[1.0, 0.0], [0.0, 1.0]], ["s1", "s2"], [ + "a", "b", + ]), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.MuscatAdvancedDesign::create( + [[1.0, 1.0], [1.0, 1.0], [1.0, 1.0]], + ["s1", "s2", "s3"], + ["a", "b"], + ), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.MuscatAdvancedDesign::create([[1.0], [0.0 / 0.0]], ["s1", "s2"], ["a"]), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "muscat advanced contrast preserves coefficient vector" { + let contrast = @src.muscat_contrast_advanced( + muscat_adv_test_design(), + [0.0, 1.0], + "stimulus", + ) + assert_eq(contrast.values, [0.0, 1.0]) + assert_eq(contrast.name, "stimulus") +} + +///| +test "muscat advanced validates contrast dimensions values and name" { + let design = muscat_adv_test_design() + let mut failures = 0 + ignore(@src.muscat_contrast_advanced(design, [1.0], "short")) catch { + _ => failures = failures + 1 + } + ignore(@src.muscat_contrast_advanced(design, [0.0, 0.0], "zero")) catch { + _ => failures = failures + 1 + } + ignore(@src.muscat_contrast_advanced(design, [0.0, 0.0 / 0.0], "nan")) catch { + _ => failures = failures + 1 + } + ignore(@src.muscat_contrast_advanced(design, [0.0, 1.0], " ")) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 4) +} + +///| +test "muscat advanced default contrasts cover all non-intercept coefficients" { + let design = @src.MuscatAdvancedDesign::create( + [ + [1.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [1.0, 1.0, 0.0], + [1.0, 1.0, 0.0], + [1.0, 0.0, 1.0], + [1.0, 0.0, 1.0], + ], + ["s1", "s2", "s3", "s4", "s5", "s6"], + ["intercept", "B-A", "C-A"], + ) + let contrasts = @src.muscat_default_contrasts_advanced(design) + assert_eq(contrasts.length(), 2) + assert_eq(contrasts[0].name, "B-A") + assert_eq(contrasts[0].values, [0.0, 1.0, 0.0]) + assert_eq(contrasts[1].values, [0.0, 0.0, 1.0]) +} + +///| +test "muscat advanced testing requires exact pseudobulk sample order" { + let design = muscat_adv_test_design() + let reversed = @src.MuscatAdvancedDesign::create( + design.matrix, + ["T4", "T3", "T2", "T1", "C4", "C3", "C2", "C1"], + design.coefficient_names, + ) + let failed = try { + ignore( + @src.muscat_pbds_advanced( + muscat_adv_test_sum(), + reversed, + muscat_adv_test_contrasts(), + config=muscat_adv_test_config(), + ), + ) + false + } catch { + _ => true + } + assert_true(failed) +} + +///| +test "muscat advanced testing validates contrast collection" { + let design = muscat_adv_test_design() + let contrast = muscat_adv_test_contrasts()[0] + let mut failures = 0 + ignore( + @src.muscat_pbds_advanced( + muscat_adv_test_sum(), + design, + [], + config=muscat_adv_test_config(), + ), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.muscat_pbds_advanced( + muscat_adv_test_sum(), + design, + [contrast, contrast], + config=muscat_adv_test_config(), + ), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "muscat advanced DS requires unscaled sum counts" { + let mean = @src.muscat_aggregate_advanced( + muscat_adv_test_data(), + aggregation=@src.muscat_mean_expression(), + ) + let scaled = @src.muscat_aggregate_advanced( + muscat_adv_test_data(), + scale_cpm=true, + ) + let mut failures = 0 + ignore( + @src.muscat_pbds_advanced( + mean, + muscat_adv_test_design(), + muscat_adv_test_contrasts(), + config=muscat_adv_test_config(), + ), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.muscat_pbds_advanced( + scaled, + muscat_adv_test_design(), + muscat_adv_test_contrasts(), + config=muscat_adv_test_config(), + ), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "muscat advanced DD requires number-detected pseudobulk" { + let failed = try { + ignore( + @src.muscat_pbdd_advanced( + muscat_adv_test_sum(), + muscat_adv_test_design(), + muscat_adv_test_contrasts(), + config=muscat_adv_test_config(), + ), + ) + false + } catch { + _ => true + } + assert_true(failed) +} + +///| +test "muscat advanced reports when filtering removes every model" { + let failed = try { + ignore( + @src.muscat_pbds_advanced( + muscat_adv_test_sum(), + muscat_adv_test_design(), + muscat_adv_test_contrasts(), + config=@src.MuscatAdvancedConfig::create(min_cells=11), + ), + ) + false + } catch { + _ => true + } + assert_true(failed) +} + +///| +test "muscat advanced DS returns cluster gene contrast results" { + let result = muscat_adv_test_ds() + assert_eq(result.mode, "DS") + assert_eq(result.results.length(), 20) + assert_eq(result.gene_names, muscat_adv_test_data().gene_names) + assert_eq(result.cluster_names, ["A", "B"]) + assert_eq(result.contrast_names, ["stim-ctrl"]) + assert_eq(result.n_tested(), 18) + assert_true(result.summary().contains("10 genes x 2 clusters x 1 contrasts")) +} + +///| +test "muscat advanced DS detects cluster-specific abundance signal" { + let result = muscat_adv_test_ds() + let signal = match result.get("ds_a", "A", "stim-ctrl") { + Some(value) => value + None => abort("DS signal result should exist") + } + let inactive = match result.get("ds_a", "B", "stim-ctrl") { + Some(value) => value + None => abort("inactive DS result should exist") + } + assert_true(signal.tested) + assert_true(signal.log_fc > 1.5) + assert_true(signal.statistic > inactive.statistic) + assert_true(signal.p_value < inactive.p_value) + assert_true(signal.local_fdr <= 0.1) +} + +///| +test "muscat advanced DS leaves equal-sum DD signal unchanged" { + let result = muscat_adv_test_ds() + let pure_dd = match result.get("dd_b", "B", "stim-ctrl") { + Some(value) => value + None => abort("pure DD result should exist") + } + assert_true(pure_dd.tested) + assert_true(pure_dd.log_fc.abs() < 1.0e-5) + assert_true(pure_dd.p_value > 0.9) +} + +///| +test "muscat advanced DS statistics and dispersion are finite" { + let result = muscat_adv_test_ds() + let config = muscat_adv_test_config() + for value in result.results { + assert_true(muscat_adv_test_finite(value.log_fc)) + assert_true(muscat_adv_test_finite(value.log_cpm)) + assert_true(muscat_adv_test_finite(value.statistic)) + assert_true(value.p_value >= 0.0 && value.p_value <= 1.0) + assert_true(value.local_fdr >= value.p_value - 1.0e-12) + assert_true(value.global_fdr >= value.p_value - 1.0e-12) + assert_true(value.dispersion >= config.minimum_dispersion) + assert_true(value.dispersion <= config.maximum_dispersion) + assert_eq(value.n_samples, 8) + } +} + +///| +test "muscat advanced filters all-zero genes without nonfinite values" { + let result = muscat_adv_test_ds() + let zero = match result.get("zero", "A", "stim-ctrl") { + Some(value) => value + None => abort("zero-gene result should exist") + } + assert_false(zero.tested) + assert_eq(zero.statistic, 0.0) + assert_eq(zero.p_value, 1.0) + assert_eq(zero.local_fdr, 1.0) + assert_eq(zero.global_fdr, 1.0) +} + +///| +test "muscat advanced fold-change threshold cannot increase Wald evidence" { + let baseline = muscat_adv_test_ds() + let thresholded = @src.muscat_pbds_advanced( + muscat_adv_test_sum(), + muscat_adv_test_design(), + muscat_adv_test_contrasts(), + config=@src.MuscatAdvancedConfig::create( + min_cells=10, + ridge=1.0e-6, + fdr_threshold=0.1, + lfc_threshold=1.0, + ), + ) + for index in 0..= + baseline.results[index].p_value, + ) + } +} + +///| +test "muscat advanced DD filters ubiquitously detected genes" { + let result = muscat_adv_test_dd() + let stable = match result.get("stable", "A", "stim-ctrl") { + Some(value) => value + None => abort("stable DD result should exist") + } + let ds = match result.get("ds_a", "A", "stim-ctrl") { + Some(value) => value + None => abort("ubiquitous DS gene result should exist") + } + assert_false(stable.tested) + assert_false(ds.tested) + assert_eq(stable.p_value, 1.0) + assert_eq(ds.p_value, 1.0) +} + +///| +test "muscat advanced DD detects equal-sum detection signal" { + let result = muscat_adv_test_dd() + let signal = match result.get("dd_b", "B", "stim-ctrl") { + Some(value) => value + None => abort("DD signal result should exist") + } + let inactive = match result.get("dd_b", "A", "stim-ctrl") { + Some(value) => value + None => abort("inactive DD result should exist") + } + assert_true(signal.tested) + assert_false(inactive.tested) + assert_true(signal.log_fc > 1.5) + assert_true(signal.p_value < 0.01) + assert_true(signal.local_fdr < 0.1) + assert_true(signal.global_fdr < 0.1) +} + +///| +test "muscat advanced DD detects combined abundance and detection signal" { + let result = muscat_adv_test_dd() + let signal = match result.get("both_a", "A", "stim-ctrl") { + Some(value) => value + None => abort("combined DD signal result should exist") + } + assert_true(signal.tested) + assert_true(signal.log_fc > 1.5) + assert_true(signal.statistic > 5.0) + assert_true(signal.local_fdr < 0.1) +} + +///| +test "muscat advanced DD statistics remain finite after CDR normalization" { + let result = muscat_adv_test_dd() + assert_eq(result.mode, "DD") + assert_eq(result.results.length(), 20) + assert_eq(result.n_tested(), 12) + for value in result.results { + assert_true(muscat_adv_test_finite(value.log_fc)) + assert_true(muscat_adv_test_finite(value.statistic)) + assert_true(muscat_adv_test_finite(value.dispersion)) + assert_true(value.p_value >= 0.0 && value.p_value <= 1.0) + } +} + +///| +test "muscat advanced local and global BH adjustments are bounded" { + for result in [muscat_adv_test_ds(), muscat_adv_test_dd()] { + for value in result.results { + assert_true(value.local_fdr >= 0.0 && value.local_fdr <= 1.0) + assert_true(value.global_fdr >= 0.0 && value.global_fdr <= 1.0) + if value.tested { + assert_true(value.local_fdr + 1.0e-12 >= value.p_value) + assert_true(value.global_fdr + 1.0e-12 >= value.p_value) + } + } + } +} + +///| +test "muscat advanced stagewise output aligns DS and DD hypotheses" { + let result = muscat_adv_test_stagewise() + assert_eq(result.results.length(), 20) + assert_eq(result.gene_names, muscat_adv_test_data().gene_names) + assert_eq(result.cluster_names, ["A", "B"]) + assert_eq(result.contrast_names, ["stim-ctrl"]) + assert_eq(result.alpha, 0.1) + for value in result.results { + assert_true(value.screen_p_value >= 0.0 && value.screen_p_value <= 1.0) + assert_true(value.screen_fdr >= 0.0 && value.screen_fdr <= 1.0) + assert_true(value.ds_confirmation >= 0.0 && value.ds_confirmation <= 1.0) + assert_true(value.dd_confirmation >= 0.0 && value.dd_confirmation <= 1.0) + } +} + +///| +test "muscat advanced stagewise classifies DS DD and combined signals" { + let result = muscat_adv_test_stagewise() + let ds = match result.get("ds_a", "A", "stim-ctrl") { + Some(value) => value + None => abort("stagewise DS result should exist") + } + let dd = match result.get("dd_b", "B", "stim-ctrl") { + Some(value) => value + None => abort("stagewise DD result should exist") + } + let both = match result.get("both_a", "A", "stim-ctrl") { + Some(value) => value + None => abort("stagewise combined result should exist") + } + assert_eq(ds.classification, "DS") + assert_eq(dd.classification, "DD") + assert_eq(both.classification, "both") + assert_true(result.n_confirmed() >= 3) +} + +///| +test "muscat advanced stagewise screening uses harmonic mean p-value" { + let ds = muscat_adv_test_ds() + let dd = muscat_adv_test_dd() + let result = @src.muscat_stagewise_ds_dd(ds, dd, alpha=0.1) + let ds_gene = match ds.get("dd_b", "B", "stim-ctrl") { + Some(value) => value + None => abort("DS component should exist") + } + let dd_gene = match dd.get("dd_b", "B", "stim-ctrl") { + Some(value) => value + None => abort("DD component should exist") + } + let combined = match result.get("dd_b", "B", "stim-ctrl") { + Some(value) => value + None => abort("stagewise component should exist") + } + let expected = 2.0 / (1.0 / ds_gene.p_value + 1.0 / dd_gene.p_value) + assert_true((combined.screen_p_value - expected).abs() < 1.0e-12) +} + +///| +test "muscat advanced stagewise validates alpha and result modes" { + let ds = muscat_adv_test_ds() + let dd = muscat_adv_test_dd() + let mut failures = 0 + ignore(@src.muscat_stagewise_ds_dd(ds, dd, alpha=0.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.muscat_stagewise_ds_dd(ds, dd, alpha=1.1)) catch { + _ => failures = failures + 1 + } + ignore(@src.muscat_stagewise_ds_dd(ds, ds)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "muscat advanced result lookup returns none for absent keys" { + assert_true(muscat_adv_test_ds().get("missing", "A", "stim-ctrl") is None) + assert_true( + muscat_adv_test_stagewise().get("missing", "A", "stim-ctrl") is None, + ) +} + +///| +test "muscat advanced result summaries report mode and significance" { + let ds = muscat_adv_test_ds() + let dd = muscat_adv_test_dd() + assert_true(ds.summary().contains("muscat advanced DS")) + assert_true(dd.summary().contains("muscat advanced DD")) + assert_true(ds.n_significant() >= 2) + assert_true(ds.n_significant(global=true) >= 2) + assert_eq(dd.n_significant(), 2) + assert_eq(dd.n_significant(global=true), 2) +} + +///| +test "muscat advanced SCE writes DS DD and stagewise annotations" { + let output = @src.muscat_advanced_sce( + muscat_adv_test_sce(), + "sample", + "cluster", + "group", + reference="ctrl", + config=muscat_adv_test_config(), + ) catch { + _ => abort("valid muscat SCE should analyze") + } + assert_eq(output.sum_pseudobulk.values.length(), 2) + assert_eq(output.detection_pseudobulk.values.length(), 2) + assert_eq(output.ds_result.mode, "DS") + assert_eq(output.dd_result.mode, "DD") + assert_eq(output.experiment.row_data["muscat.A.dsLogFC"].length(), 10) + assert_eq(output.experiment.row_data["muscat.A.dsFdr"].length(), 10) + assert_eq(output.experiment.row_data["muscat.B.ddLogFC"].length(), 10) + assert_eq(output.experiment.row_data["muscat.B.stageClass"].length(), 10) + assert_eq(output.experiment.metadata["muscat.version"], "muscat 1.27.4") + assert_eq(output.experiment.metadata["muscat.reference"], "ctrl") + assert_eq(output.experiment.metadata["muscat.contrast"], "stim-ctrl") +} + +///| +test "muscat advanced SCE preserves input immutability" { + let experiment = muscat_adv_test_sce() + let output = @src.muscat_advanced_sce( + experiment, + "sample", + "cluster", + "group", + config=muscat_adv_test_config(), + ) + output.experiment.assays["counts"][0][0] = 999.0 + output.experiment.row_data["symbol"][0] = "changed" + output.experiment.col_data["batch"][0] = "changed" + output.experiment.reduced_dims["PCA"][0][0] = 999.0 + output.experiment.metadata["source"] = "changed" + assert_eq(experiment.assays["counts"][0][0], 100.0) + assert_eq(experiment.row_data["symbol"][0], "stable") + assert_eq(experiment.col_data["batch"][0], "one") + assert_eq(experiment.reduced_dims["PCA"][0][0], 1.0) + assert_eq(experiment.metadata["source"], "test") + assert_false(experiment.row_data.contains("muscat.A.dsLogFC")) +} + +///| +test "muscat advanced SCE recursively copies alternative experiments" { + let experiment = muscat_adv_test_sce() + let output = @src.muscat_advanced_sce( + experiment, + "sample", + "cluster", + "group", + config=muscat_adv_test_config(), + ) + output.experiment.alternative_experiments["spike"].assays["counts"][0][0] = 8.0 + assert_eq( + experiment.alternative_experiments["spike"].assays["counts"][0][0], + 1.0, + ) +} + +///| +test "muscat advanced SCE supports custom assay and output prefix" { + let experiment = muscat_adv_test_sce() + experiment.assays["raw"] = experiment.assays["counts"].map(fn(row) { + row.copy() + }) + let output = @src.muscat_advanced_sce( + experiment, + "sample", + "cluster", + "group", + assay_name="raw", + reference="ctrl", + output_prefix="mx", + config=muscat_adv_test_config(), + ) + assert_true(output.experiment.row_data.contains("mx.A.dsLogFC")) + assert_true(output.experiment.row_data.contains("mx.B.stageClass")) + assert_true(output.experiment.col_data.contains("mx.sample_id")) + assert_eq(output.experiment.metadata["mx.assay"], "raw") + assert_eq(output.experiment.metadata["mx.clusters"], "A,B") +} + +///| +test "muscat advanced SCE validates assay columns and prefix" { + let experiment = muscat_adv_test_sce() + let mut failures = 0 + ignore( + @src.muscat_advanced_sce( + experiment, + "sample", + "cluster", + "group", + assay_name="missing", + config=muscat_adv_test_config(), + ), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.muscat_advanced_sce( + experiment, + "missing", + "cluster", + "group", + config=muscat_adv_test_config(), + ), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.muscat_advanced_sce( + experiment, + "sample", + "missing", + "group", + config=muscat_adv_test_config(), + ), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.muscat_advanced_sce( + experiment, + "sample", + "cluster", + "missing", + config=muscat_adv_test_config(), + ), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.muscat_advanced_sce( + experiment, + "sample", + "cluster", + "group", + output_prefix=" ", + config=muscat_adv_test_config(), + ), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 5) +} + +///| +test "muscat advanced SCE validates reference group" { + let failed = try { + ignore( + @src.muscat_advanced_sce( + muscat_adv_test_sce(), + "sample", + "cluster", + "group", + reference="missing", + config=muscat_adv_test_config(), + ), + ) + false + } catch { + _ => true + } + assert_true(failed) +} diff --git a/test/moonbit/sc_dbl_finder_advanced_test.mbt b/test/moonbit/sc_dbl_finder_advanced_test.mbt new file mode 100644 index 00000000..37b4c6e3 --- /dev/null +++ b/test/moonbit/sc_dbl_finder_advanced_test.mbt @@ -0,0 +1,1223 @@ +///| +fn scdfa_test_small_data() -> @src.SingleCellData { + @src.SingleCellData::create( + [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0], [2.0, 4.0, 6.0]], + ["c1", "c2", "c3", "c4"], + ["g1", "g2", "g3"], + ) catch { + _ => abort("valid small scDblFinder data should build") + } +} + +///| +fn scdfa_test_config() -> @src.ScDblFinderConfig { + @src.ScDblFinderConfig::create( + expected_doublet_rate=0.15, + artificial_doublets=48, + selected_features=18, + dimensions=5, + neighbors=8, + iterations=2, + classifier_steps=120, + seed=17, + ) catch { + _ => abort("valid scDblFinder configuration should build") + } +} + +///| +fn scdfa_test_result() -> @src.ScDblFinderResult { + let (data, clusters, samples, truth) = @src.scdf_create_advanced_example() catch { + _ => abort("valid scDblFinder example should build") + } + @src.sc_dbl_finder( + data, + clusters~, + samples~, + known_doublets=truth, + config=scdfa_test_config(), + ) catch { + _ => abort("valid scDblFinder workflow should fit") + } +} + +///| +fn scdfa_test_experiment() -> @src.SingleCellExperiment { + let (data, clusters, samples, truth) = @src.scdf_create_advanced_example() catch { + _ => abort("valid scDblFinder example should build") + } + let assay : Array[Array[Double]] = [] + for gene in 0.. abort("advanced example should build") + } + assert_eq(data.counts.length(), 42) + assert_eq(data.gene_names.length(), 24) + assert_eq(clusters.length(), 42) + assert_eq(samples.length(), 42) + assert_eq(truth.length(), 42) + let mut doublets = 0 + for value in truth { + if value { + doublets = doublets + 1 + } + } + assert_eq(doublets, 6) +} + +///| +test "scDblFinder SingleCellData constructor copies inputs" { + let counts = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]] + let cells = ["a", "b", "c"] + let genes = ["x", "y"] + let data = @src.SingleCellData::create(counts, cells, genes) catch { + _ => abort("valid data should build") + } + counts[0][0] = 99.0 + cells[0] = "changed" + genes[0] = "changed" + assert_eq(data.counts[0][0], 1.0) + assert_eq(data.cell_names[0], "a") + assert_eq(data.gene_names[0], "x") +} + +///| +test "scDblFinder rejects fewer than three cells" { + let raised = try { + ignore( + @src.SingleCellData::create([[1.0, 2.0], [3.0, 4.0]], ["a", "b"], [ + "x", "y", + ]), + ) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "scDblFinder rejects fewer than two genes" { + let raised = try { + ignore( + @src.SingleCellData::create([[1.0], [2.0], [3.0]], ["a", "b", "c"], ["x"]), + ) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "scDblFinder rejects a ragged count matrix" { + let raised = try { + ignore( + @src.SingleCellData::create( + [[1.0, 2.0], [3.0], [4.0, 5.0]], + ["a", "b", "c"], + ["x", "y"], + ), + ) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "scDblFinder validates cell and gene identifiers" { + let wrong_length = try { + ignore( + @src.SingleCellData::create( + [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], + ["a", "b"], + ["x", "y"], + ), + ) + false + } catch { + _ => true + } + let empty_name = try { + ignore( + @src.SingleCellData::create( + [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], + ["a", "", "c"], + ["x", "y"], + ), + ) + false + } catch { + _ => true + } + let duplicate_gene = try { + ignore( + @src.SingleCellData::create( + [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], + ["a", "b", "c"], + ["x", "x"], + ), + ) + false + } catch { + _ => true + } + assert_true(wrong_length && empty_name && duplicate_gene) +} + +///| +test "scDblFinder rejects non-finite and negative counts" { + let negative = try { + ignore( + @src.SingleCellData::create( + [[1.0, -1.0], [3.0, 4.0], [5.0, 6.0]], + ["a", "b", "c"], + ["x", "y"], + ), + ) + false + } catch { + _ => true + } + let nan = try { + ignore( + @src.SingleCellData::create( + [[1.0, Double::nan()], [3.0, 4.0], [5.0, 6.0]], + ["a", "b", "c"], + ["x", "y"], + ), + ) + false + } catch { + _ => true + } + let infinite = try { + ignore( + @src.SingleCellData::create( + [[1.0, 1.0e301], [3.0, 4.0], [5.0, 6.0]], + ["a", "b", "c"], + ["x", "y"], + ), + ) + false + } catch { + _ => true + } + assert_true(negative && nan && infinite) +} + +///| +test "scDblFinder rejects zero-library cells" { + let raised = try { + ignore( + @src.SingleCellData::create( + [[0.0, 0.0], [3.0, 4.0], [5.0, 6.0]], + ["a", "b", "c"], + ["x", "y"], + ), + ) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "scDblFinder default configuration matches portable workflow" { + let config = @src.ScDblFinderConfig::default() + assert_eq(config.expected_doublet_rate, -1.0) + assert_eq(config.doublet_rate_per_1000, 0.008) + assert_eq(config.selected_features, 1000) + assert_eq(config.dimensions, 20) + assert_eq(config.neighbors, 15) + assert_eq(config.iterations, 3) + assert_eq(config.classifier_steps, 300) + assert_eq(config.cluster_count, 0) +} + +///| +test "scDblFinder configuration preserves custom values" { + let config = @src.ScDblFinderConfig::create( + expected_doublet_rate=0.12, + rate_uncertainty=0.03, + artificial_doublets=40, + selected_features=12, + dimensions=4, + neighbors=7, + iterations=2, + classifier_steps=50, + random_fraction=0.2, + half_size_fraction=0.4, + cluster_count=3, + seed=9, + ) catch { + _ => abort("valid custom configuration should build") + } + assert_eq(config.expected_doublet_rate, 0.12) + assert_eq(config.artificial_doublets, 40) + assert_eq(config.dimensions, 4) + assert_eq(config.cluster_count, 3) + assert_eq(config.seed, 9) +} + +///| +test "scDblFinder configuration rejects invalid rates" { + let expected = try { + ignore(@src.ScDblFinderConfig::create(expected_doublet_rate=1.1)) + false + } catch { + _ => true + } + let per_thousand = try { + ignore(@src.ScDblFinderConfig::create(doublet_rate_per_1000=-0.1)) + false + } catch { + _ => true + } + let uncertainty = try { + ignore(@src.ScDblFinderConfig::create(rate_uncertainty=-0.2)) + false + } catch { + _ => true + } + assert_true(expected && per_thousand && uncertainty) +} + +///| +test "scDblFinder configuration rejects invalid dimensions" { + let features = try { + ignore(@src.ScDblFinderConfig::create(selected_features=1)) + false + } catch { + _ => true + } + let dimensions = try { + ignore(@src.ScDblFinderConfig::create(dimensions=0)) + false + } catch { + _ => true + } + let neighbors = try { + ignore(@src.ScDblFinderConfig::create(neighbors=0)) + false + } catch { + _ => true + } + assert_true(features && dimensions && neighbors) +} + +///| +test "scDblFinder configuration validates classifier controls" { + let iterations = try { + ignore(@src.ScDblFinderConfig::create(iterations=0)) + false + } catch { + _ => true + } + let steps = try { + ignore(@src.ScDblFinderConfig::create(classifier_steps=0)) + false + } catch { + _ => true + } + let learning_rate = try { + ignore(@src.ScDblFinderConfig::create(learning_rate=1.1)) + false + } catch { + _ => true + } + let regularization = try { + ignore(@src.ScDblFinderConfig::create(regularization=-0.01)) + false + } catch { + _ => true + } + assert_true(iterations && steps && learning_rate && regularization) +} + +///| +test "scDblFinder configuration validates threshold and mixing fractions" { + let stringency = try { + ignore(@src.ScDblFinderConfig::create(stringency=1.0)) + false + } catch { + _ => true + } + let random_fraction = try { + ignore(@src.ScDblFinderConfig::create(random_fraction=-0.1)) + false + } catch { + _ => true + } + let half_fraction = try { + ignore(@src.ScDblFinderConfig::create(half_size_fraction=1.1)) + false + } catch { + _ => true + } + let unidentifiable = try { + ignore(@src.ScDblFinderConfig::create(unidentifiable_threshold=1.1)) + false + } catch { + _ => true + } + assert_true(stringency && random_fraction && half_fraction && unidentifiable) +} + +///| +test "scDblFinder configuration rejects a single requested cluster" { + let raised = try { + ignore(@src.ScDblFinderConfig::create(cluster_count=1)) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "scDblFinder expected rate follows cells per thousand" { + let rate = @src.scdf_expected_doublet_rate(5000) catch { + _ => abort("valid expected rate should compute") + } + assert_true((rate - 0.04).abs() < 1.0e-12) +} + +///| +test "scDblFinder expected rate is capped and validated" { + let capped = @src.scdf_expected_doublet_rate(2000, rate_per_1000=1.0) catch { + _ => abort("valid capped rate should compute") + } + assert_eq(capped, 1.0) + let raised = try { + ignore(@src.scdf_expected_doublet_rate(0)) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "scDblFinder homotypic proportion uses squared cluster frequencies" { + let proportion = @src.scdf_homotypic_proportion(["A", "A", "B", "B"]) catch { + _ => abort("valid homotypic proportion should compute") + } + assert_true((proportion - 0.5).abs() < 1.0e-12) +} + +///| +test "scDblFinder homotypic proportion validates labels" { + let empty = try { + ignore(@src.scdf_homotypic_proportion([])) + false + } catch { + _ => true + } + let blank = try { + ignore(@src.scdf_homotypic_proportion(["A", ""])) + false + } catch { + _ => true + } + assert_true(empty && blank) +} + +///| +test "scDblFinder random artificial doublets have requested dimensions" { + let artificial = @src.scdf_generate_artificial_doublets( + scdfa_test_small_data(), + 7, + random_fraction=1.0, + half_size_fraction=0.0, + seed=3, + ) catch { + _ => abort("valid artificial doublets should build") + } + assert_eq(artificial.counts.length(), 7) + assert_eq(artificial.names.length(), 7) + assert_eq(artificial.parent_one.length(), 7) + assert_eq(artificial.origins, ["", "", "", "", "", "", ""]) + for row in artificial.counts { + assert_eq(row.length(), 3) + } +} + +///| +test "scDblFinder artificial counts sum parent profiles" { + let data = scdfa_test_small_data() + let artificial = @src.scdf_generate_artificial_doublets( + data, + 5, + half_size_fraction=0.0, + seed=4, + ) catch { + _ => abort("valid artificial doublets should build") + } + for index in 0.. abort("valid half-size artificial doublets should build") + } + for index in 0..<4 { + let expected_scale = if index < 2 { 0.5 } else { 1.0 } + let expected = ( + data.counts[artificial.parent_one[index]][0] + + data.counts[artificial.parent_two[index]][0] + ) * + expected_scale + assert_eq(artificial.counts[index][0], expected) + } +} + +///| +test "scDblFinder artificial parents are distinct and in bounds" { + let artificial = @src.scdf_generate_artificial_doublets( + scdfa_test_small_data(), + 20, + seed=8, + ) catch { + _ => abort("valid artificial doublets should build") + } + for index in 0..= 0) + assert_true(artificial.parent_two[index] < 4) + assert_true(artificial.parent_one[index] != artificial.parent_two[index]) + } +} + +///| +test "scDblFinder cluster-aware artificial doublets use cross-cluster pairs" { + let data = scdfa_test_small_data() + let clusters = ["A", "A", "B", "B"] + let artificial = @src.scdf_generate_artificial_doublets( + data, + 12, + clusters~, + random_fraction=0.0, + half_size_fraction=0.0, + ) catch { + _ => abort("valid cluster-aware artificial doublets should build") + } + for index in 0.. abort("valid artificial doublets should build") + } + let second = @src.scdf_generate_artificial_doublets(data, 10, seed=5) catch { + _ => abort("valid artificial doublets should build") + } + assert_eq(first.counts, second.counts) + assert_eq(first.parent_one, second.parent_one) + assert_eq(first.parent_two, second.parent_two) +} + +///| +test "scDblFinder artificial generation responds to its seed" { + let data = scdfa_test_small_data() + let first = @src.scdf_generate_artificial_doublets(data, 10, seed=1) catch { + _ => abort("valid artificial doublets should build") + } + let second = @src.scdf_generate_artificial_doublets(data, 10, seed=2) catch { + _ => abort("valid artificial doublets should build") + } + assert_true( + first.parent_one != second.parent_one || + first.parent_two != second.parent_two, + ) +} + +///| +test "scDblFinder artificial generation validates arguments" { + let data = scdfa_test_small_data() + let number = try { + ignore(@src.scdf_generate_artificial_doublets(data, 0)) + false + } catch { + _ => true + } + let clusters = try { + ignore(@src.scdf_generate_artificial_doublets(data, 2, clusters=["A", "B"])) + false + } catch { + _ => true + } + let fraction = try { + ignore(@src.scdf_generate_artificial_doublets(data, 2, random_fraction=1.1)) + false + } catch { + _ => true + } + assert_true(number && clusters && fraction) +} + +///| +test "scDblFinder threshold separates ideal score classes" { + let threshold = @src.scdf_optimize_threshold( + [0.05, 0.10, 0.15, 0.20], + [0.80, 0.90, 0.95], + 0.0, + uncertainty=0.0, + ) catch { + _ => abort("valid threshold should optimize") + } + assert_true(threshold.threshold > 0.20) + assert_true(threshold.threshold < 0.80) + assert_eq(threshold.false_positive_rate, 0.0) + assert_eq(threshold.false_negative_rate, 0.0) +} + +///| +test "scDblFinder threshold diagnostics remain bounded with overlap" { + let threshold = @src.scdf_optimize_threshold( + [0.1, 0.3, 0.6, 0.8], + [0.4, 0.5, 0.7, 0.9], + 0.25, + ) catch { + _ => abort("valid threshold should optimize") + } + assert_true(threshold.threshold >= 0.0 && threshold.threshold <= 1.0) + assert_true(threshold.called_rate >= 0.0 && threshold.called_rate <= 1.0) + assert_true( + threshold.false_negative_rate >= 0.0 && threshold.false_negative_rate <= 1.0, + ) + assert_true(threshold.cost >= 0.0) +} + +///| +test "scDblFinder threshold optimization is deterministic" { + let first = @src.scdf_optimize_threshold( + [0.1, 0.2, 0.7], + [0.4, 0.8, 0.9], + 0.2, + ) catch { + _ => abort("valid threshold should optimize") + } + let second = @src.scdf_optimize_threshold( + [0.1, 0.2, 0.7], + [0.4, 0.8, 0.9], + 0.2, + ) catch { + _ => abort("valid threshold should optimize") + } + assert_eq(first.threshold, second.threshold) + assert_eq(first.cost, second.cost) +} + +///| +test "scDblFinder threshold requires both classes" { + let raised = try { + ignore(@src.scdf_optimize_threshold([], [0.8], 0.1)) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "scDblFinder threshold rejects invalid scores" { + let nan = try { + ignore(@src.scdf_optimize_threshold([Double::nan()], [0.8], 0.1)) + false + } catch { + _ => true + } + let outside = try { + ignore(@src.scdf_optimize_threshold([0.2], [1.1], 0.1)) + false + } catch { + _ => true + } + assert_true(nan && outside) +} + +///| +test "scDblFinder threshold validates rate and stringency" { + let rate = try { + ignore(@src.scdf_optimize_threshold([0.2], [0.8], 1.1)) + false + } catch { + _ => true + } + let stringency = try { + ignore(@src.scdf_optimize_threshold([0.2], [0.8], 0.1, stringency=0.0)) + false + } catch { + _ => true + } + assert_true(rate && stringency) +} + +///| +test "scDblFinder fast clustering labels every cell" { + let (data, _, _, _) = @src.scdf_create_advanced_example() catch { + _ => abort("advanced example should build") + } + let clusters = @src.scdf_fast_cluster( + data, + 3, + dimensions=5, + selected_features=18, + ) catch { + _ => abort("valid fast clustering should run") + } + assert_eq(clusters.length(), data.cell_names.length()) + for label in clusters { + assert_true(label.has_prefix("cluster_")) + } +} + +///| +test "scDblFinder fast clustering is deterministic" { + let (data, _, _, _) = @src.scdf_create_advanced_example() catch { + _ => abort("advanced example should build") + } + let first = @src.scdf_fast_cluster(data, 3) catch { + _ => abort("valid fast clustering should run") + } + let second = @src.scdf_fast_cluster(data, 3) catch { + _ => abort("valid fast clustering should run") + } + assert_eq(first, second) +} + +///| +test "scDblFinder fast clustering validates cluster count" { + let data = scdfa_test_small_data() + let one = try { + ignore(@src.scdf_fast_cluster(data, 1)) + false + } catch { + _ => true + } + let too_many = try { + ignore(@src.scdf_fast_cluster(data, 5)) + false + } catch { + _ => true + } + assert_true(one && too_many) +} + +///| +test "scDblFinder workflow returns aligned cell-level arrays" { + let result = scdfa_test_result() + assert_eq(result.n_cells(), 42) + assert_eq(result.scores.length(), 42) + assert_eq(result.calls.length(), 42) + assert_eq(result.weighted_ratios.length(), 42) + assert_eq(result.neighbor_ratios.length(), 42) + assert_eq(result.cxds_scores.length(), 42) + assert_eq(result.origins.length(), 42) + assert_eq(result.library_sizes.length(), 42) +} + +///| +test "scDblFinder classifier scores are finite probabilities" { + let result = scdfa_test_result() + for score in result.scores { + assert_true(score == score) + assert_true(score >= 0.0 && score <= 1.0) + } +} + +///| +test "scDblFinder neighborhood and cxds features are bounded" { + let result = scdfa_test_result() + for cell in 0..= 0.0 && result.weighted_ratios[cell] <= 1.0, + ) + assert_true( + result.neighbor_ratios[cell] >= 0.0 && result.neighbor_ratios[cell] <= 1.0, + ) + assert_true( + result.cxds_scores[cell] >= 0.0 && result.cxds_scores[cell] <= 1.0, + ) + assert_true( + result.origin_ambiguities[cell] >= 0.0 && + result.origin_ambiguities[cell] <= 1.0, + ) + } +} + +///| +test "scDblFinder kNN distances and classes are populated" { + let result = scdfa_test_result() + for cell in 0..= 0.0) + assert_true(result.distances_to_doublet[cell] >= 0.0) + assert_true(result.distances_to_real[cell] >= 0.0) + assert_true( + result.nearest_classes[cell] == "cell" || + result.nearest_classes[cell] == "artificialDoublet", + ) + } +} + +///| +test "scDblFinder PCA has requested portable dimensions" { + let result = scdfa_test_result() + assert_eq(result.pca.length(), 42) + for coordinates in result.pca { + assert_eq(coordinates.length(), 5) + for value in coordinates { + assert_true(value == value && value.abs() <= 1.0e300) + } + } +} + +///| +test "scDblFinder feature selection records selected genes" { + let result = scdfa_test_result() + assert_true(result.selected_gene_names.length() > 0) + assert_true(result.selected_gene_names.length() <= result.gene_names.length()) + for gene in result.selected_gene_names { + assert_true(result.gene_names.contains(gene)) + } +} + +///| +test "scDblFinder performs independent capture fits" { + let result = scdfa_test_result() + assert_eq(result.sample_ids, ["capture_A", "capture_B"]) + assert_eq(result.thresholds.length(), 2) + assert_eq(result.expected_doublet_rates.length(), 2) + assert_eq(result.artificial_doublets, 96) + for threshold in result.thresholds { + assert_true(threshold.threshold >= 0.0 && threshold.threshold <= 1.0) + } +} + +///| +test "scDblFinder preserves known labels and workflow configuration" { + let result = scdfa_test_result() + let mut known = 0 + for value in result.known_doublets { + if value { + known = known + 1 + } + } + assert_eq(known, 6) + assert_eq(result.classifier_iterations, 2) + assert_eq(result.config.seed, 17) +} + +///| +test "scDblFinder ranks top cells by descending score" { + let result = scdfa_test_result() + let top = result.top_doublets(limit=7) catch { + _ => abort("valid top-doublet query should run") + } + assert_eq(top.length(), 7) + for index in 1..= top[index].score) + } +} + +///| +test "scDblFinder cell lookup returns typed diagnostics" { + let result = scdfa_test_result() + match result.cell("known_doublet_1") { + Some(cell) => { + assert_eq(cell.cell_name, "known_doublet_1") + assert_true(cell.score >= 0.0 && cell.score <= 1.0) + assert_true(cell.origin != "") + } + None => abort("known cell should be found") + } + assert_true(result.cell("missing") is None) +} + +///| +test "scDblFinder summary reports workflow metadata" { + let summary = scdfa_test_result().summary() + assert_true(summary.contains("scDblFinder Result")) + assert_true(summary.contains("cells=42")) + assert_true(summary.contains("samples=2")) + assert_true(summary.contains("iterations=2")) +} + +///| +test "scDblFinder singlet filtering follows calls" { + let (data, _, _, _) = @src.scdf_create_advanced_example() catch { + _ => abort("advanced example should build") + } + let result = scdfa_test_result() + let filtered = result.filter_singlets(data) catch { + _ => abort("valid singlet filtering should run") + } + assert_eq( + filtered.cell_names.length(), + result.n_cells() - result.n_doublets(), + ) + assert_eq(filtered.gene_names, data.gene_names) +} + +///| +test "scDblFinder synthetic classification exceeds baseline accuracy" { + let (_, _, _, truth) = @src.scdf_create_advanced_example() catch { + _ => abort("advanced example should build") + } + let result = scdfa_test_result() + let mut correct = 0 + for cell in 0..= 0.75) +} + +///| +test "scDblFinder workflow is deterministic" { + let first = scdfa_test_result() + let second = scdfa_test_result() + assert_eq(first.scores, second.scores) + assert_eq(first.calls, second.calls) + assert_eq(first.origins, second.origins) + assert_eq(first.pca, second.pca) +} + +///| +test "scDblFinder supports a single combined capture" { + let (data, clusters, _, truth) = @src.scdf_create_advanced_example() catch { + _ => abort("advanced example should build") + } + let result = @src.sc_dbl_finder( + data, + clusters~, + known_doublets=truth, + config=scdfa_test_config(), + ) catch { + _ => abort("single-capture workflow should fit") + } + assert_eq(result.sample_ids, ["all"]) + assert_eq(result.thresholds.length(), 1) + assert_eq(result.artificial_doublets, 48) +} + +///| +test "scDblFinder can infer clusters before fitting" { + let (data, _, _, truth) = @src.scdf_create_advanced_example() catch { + _ => abort("advanced example should build") + } + let config = @src.ScDblFinderConfig::create( + expected_doublet_rate=0.15, + artificial_doublets=36, + selected_features=18, + dimensions=5, + neighbors=8, + iterations=1, + classifier_steps=80, + cluster_count=3, + ) catch { + _ => abort("valid auto-cluster configuration should build") + } + let result = @src.sc_dbl_finder(data, known_doublets=truth, config~) catch { + _ => abort("auto-cluster workflow should fit") + } + assert_eq(result.clusters.length(), 42) + for cluster in result.clusters { + assert_true(cluster != "") + } +} + +///| +test "scDblFinder workflow validates metadata lengths" { + let data = scdfa_test_small_data() + let clusters = try { + ignore(@src.sc_dbl_finder(data, clusters=["A", "B"])) + false + } catch { + _ => true + } + let samples = try { + ignore(@src.sc_dbl_finder(data, samples=["one"])) + false + } catch { + _ => true + } + let known = try { + ignore(@src.sc_dbl_finder(data, known_doublets=[true])) + false + } catch { + _ => true + } + assert_true(clusters && samples && known) +} + +///| +test "scDblFinder rejects captures with fewer than three cells" { + let data = scdfa_test_small_data() + let raised = try { + ignore( + @src.sc_dbl_finder(data, samples=["small", "small", "other", "other"]), + ) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "scDblFinder cluster-aware fitting assigns origins" { + let result = scdfa_test_result() + for origin in result.origins { + assert_true(origin != "") + assert_true(origin.contains("+")) + } +} + +///| +test "scDblFinder pairwise enrichment covers cluster pairs" { + let enrichment = @src.scdf_pairwise_enrichment(scdfa_test_result()) catch { + _ => abort("valid enrichment should compute") + } + assert_eq(enrichment.length(), 3) + for index in 0..= 0) + assert_true(row.expected >= 0.0) + assert_true(row.p_value >= 0.0 && row.p_value <= 1.0) + assert_true( + row.adjusted_p_value >= row.p_value && row.adjusted_p_value <= 1.0, + ) + if index > 0 { + assert_true(enrichment[index - 1].p_value <= row.p_value) + } + } +} + +///| +test "scDblFinder enrichment requires cluster-aware fitting" { + let (data, _, _, truth) = @src.scdf_create_advanced_example() catch { + _ => abort("advanced example should build") + } + let result = @src.sc_dbl_finder( + data, + known_doublets=truth, + config=scdfa_test_config(), + ) catch { + _ => abort("valid cluster-free workflow should fit") + } + let raised = try { + ignore(@src.scdf_pairwise_enrichment(result)) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "scDblFinder SingleCellExperiment writes cell diagnostics" { + let output = @src.sc_dbl_finder_single_cell_experiment( + scdfa_test_experiment(), + cluster_column="cluster", + sample_column="capture", + known_doublet_column="known", + config=scdfa_test_config(), + ) catch { + _ => abort("valid SingleCellExperiment workflow should fit") + } + assert_eq(output.result.n_cells(), 42) + assert_eq(output.experiment.col_data["scDblFinder.score"].length(), 42) + assert_eq(output.experiment.col_data["scDblFinder.class"].length(), 42) + assert_eq( + output.experiment.col_data["scDblFinder.mostLikelyOrigin"].length(), + 42, + ) +} + +///| +test "scDblFinder SingleCellExperiment writes feature and PCA diagnostics" { + let output = @src.sc_dbl_finder_single_cell_experiment( + scdfa_test_experiment(), + cluster_column="cluster", + sample_column="capture", + known_doublet_column="known", + config=scdfa_test_config(), + ) catch { + _ => abort("valid SingleCellExperiment workflow should fit") + } + assert_eq(output.experiment.row_data["scDblFinder.selected"].length(), 24) + assert_eq(output.experiment.reduced_dims["scDblFinder.PCA"].length(), 42) + assert_true(output.experiment.metadata.contains("scDblFinder.doublets")) + assert_true(output.experiment.metadata.contains("scDblFinder.rate")) + assert_true(output.experiment.metadata.contains("scDblFinder.artificial")) +} + +///| +test "scDblFinder SingleCellExperiment leaves the input unchanged" { + let experiment = scdfa_test_experiment() + let output = @src.sc_dbl_finder_single_cell_experiment( + experiment, + cluster_column="cluster", + sample_column="capture", + known_doublet_column="known", + config=scdfa_test_config(), + ) catch { + _ => abort("valid SingleCellExperiment workflow should fit") + } + assert_true(!experiment.col_data.contains("scDblFinder.score")) + output.experiment.col_data["capture"][0] = "changed" + assert_eq(experiment.col_data["capture"][0], "capture_A") +} + +///| +test "scDblFinder SingleCellExperiment supports a custom output prefix" { + let output = @src.sc_dbl_finder_single_cell_experiment( + scdfa_test_experiment(), + cluster_column="cluster", + sample_column="capture", + known_doublet_column="known", + output_prefix="doublet", + config=scdfa_test_config(), + ) catch { + _ => abort("valid custom-prefix workflow should fit") + } + assert_true(output.experiment.col_data.contains("doublet.score")) + assert_true(output.experiment.row_data.contains("doublet.selected")) + assert_true(output.experiment.reduced_dims.contains("doublet.PCA")) + assert_true(!output.experiment.col_data.contains("scDblFinder.score")) +} + +///| +test "scDblFinder SingleCellExperiment transposes gene-by-cell assays" { + let experiment = scdfa_test_experiment() + let output = @src.sc_dbl_finder_single_cell_experiment( + experiment, + cluster_column="cluster", + sample_column="capture", + known_doublet_column="known", + config=scdfa_test_config(), + ) catch { + _ => abort("valid SingleCellExperiment workflow should fit") + } + let mut expected_library = 0.0 + for gene in 0.. true + } + let column = try { + ignore( + @src.sc_dbl_finder_single_cell_experiment( + experiment, + cluster_column="missing", + ), + ) + false + } catch { + _ => true + } + assert_true(assay && column) +} + +///| +test "scDblFinder SingleCellExperiment rejects invalid known labels" { + let experiment = scdfa_test_experiment() + experiment.col_data["known"][0] = "unknown" + let raised = try { + ignore( + @src.sc_dbl_finder_single_cell_experiment( + experiment, + known_doublet_column="known", + ), + ) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "scDblFinder SingleCellExperiment validates assay dimensions" { + let experiment = @src.SingleCellExperiment::new( + [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], + ["only_one_name"], + ["c1", "c2", "c3"], + ) + let raised = try { + ignore(@src.sc_dbl_finder_single_cell_experiment(experiment)) + false + } catch { + _ => true + } + assert_true(raised) +} diff --git a/test/moonbit/scuttle_test.mbt b/test/moonbit/scuttle_test.mbt new file mode 100644 index 00000000..e0d3b1b8 --- /dev/null +++ b/test/moonbit/scuttle_test.mbt @@ -0,0 +1,966 @@ +///| +fn scuttle_test_close( + left : Double, + right : Double, + tolerance : Double, +) -> Bool { + (left - right).abs() <= tolerance +} + +///| +fn scuttle_test_column_sums(matrix : Array[Array[Double]]) -> Array[Double] { + let cells = if matrix.length() > 0 { matrix[0].length() } else { 0 } + let output = Array::make(cells, 0.0) + for row in matrix { + for cell in 0.. Double { + let mut output = 0.0 + for row in matrix { + for value in row { + output = output + value + } + } + output +} + +///| +fn scuttle_test_outlier_value(value : Bool?) -> Bool { + match value { + Some(result) => result + None => abort("expected an estimated outlier status") + } +} + +///| +fn scuttle_test_counts() -> Array[Array[Double]] { + [ + [8.0, 4.0, 16.0, 8.0], + [2.0, 6.0, 4.0, 12.0], + [0.0, 2.0, 0.0, 4.0], + [10.0, 8.0, 20.0, 16.0], + ] +} + +///| +fn scuttle_test_sce() -> @src.SingleCellExperiment { + let counts = scuttle_test_counts() + let sce = @src.SingleCellExperiment::new(counts, ["G1", "G2", "G3", "G4"], [ + "C1", "C2", "C3", "C4", + ]) + sce.assays["logcounts"] = [ + [3.0, 2.0, 4.0, 3.0], + [1.0, 2.5, 2.0, 3.5], + [0.0, 1.0, 0.0, 2.0], + [3.5, 3.0, 4.5, 4.0], + ] + sce.row_data["symbol"] = ["A", "B", "C", "D"] + sce.col_data["batch"] = ["A", "A", "B", "B"] + sce.reduced_dims["PCA"] = [[1.0, 0.0], [2.0, 0.0], [3.0, 1.0], [4.0, 1.0]] + sce.metadata["project"] = "scuttle-test" + sce.alternative_experiments["spike"] = @src.SingleCellExperiment::new( + [[1.0, 2.0, 3.0, 4.0]], + ["Spike1"], + ["C1", "C2", "C3", "C4"], + ) + sce +} + +///| +test "scuttle: default outlier configuration matches upstream defaults" { + let config = @src.ScuttleOutlierConfig::default() + assert_eq(config.nmads, 3.0) + assert_true(config.direction == @src.scuttle_outlier_both()) + assert_false(config.log_transform) + assert_false(config.share_medians) + assert_false(config.share_mads) + assert_true(config.share_missing) + assert_true(config.subset is None) + assert_true(config.min_diff is None) +} + +///| +test "scuttle: outlier configuration rejects negative nmads" { + let mut raised = false + ignore(@src.ScuttleOutlierConfig::create(nmads=-1.0)) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "scuttle: outlier configuration rejects negative min diff" { + let mut raised = false + ignore(@src.ScuttleOutlierConfig::create(min_diff=Some(-1.0))) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "scuttle: vanilla outlier thresholds use R MAD scaling" { + let result = @src.scuttle_is_outlier([1.0, 2.0, 2.0, 3.0, 100.0]) catch { + _ => abort("valid outlier detection should work") + } + assert_eq(result.batch_names, ["1"]) + assert_true(scuttle_test_close(result.medians[0], 2.0, 1.0e-12)) + assert_true(scuttle_test_close(result.mads[0], 1.4826, 1.0e-12)) + assert_true(scuttle_test_close(result.lower[0], -2.4478, 1.0e-10)) + assert_true(scuttle_test_close(result.higher[0], 6.4478, 1.0e-10)) + assert_false(scuttle_test_outlier_value(result.outliers[0])) + assert_true(scuttle_test_outlier_value(result.outliers[4])) + assert_eq(result.discarded_count(), 1) +} + +///| +test "scuttle: lower-tail direction only calls small observations" { + let config = @src.ScuttleOutlierConfig::create( + nmads=1.0, + direction=@src.scuttle_outlier_lower(), + ) catch { + _ => abort("valid lower-tail configuration should build") + } + let result = @src.scuttle_is_outlier([0.0, 10.0, 10.0, 11.0, 100.0], config~) catch { + _ => abort("lower-tail outlier detection should work") + } + assert_true(scuttle_test_outlier_value(result.outliers[0])) + assert_false(scuttle_test_outlier_value(result.outliers[4])) + assert_true(result.higher[0] >= 1.0e299) +} + +///| +test "scuttle: higher-tail direction only calls large observations" { + let config = @src.ScuttleOutlierConfig::create( + nmads=1.0, + direction=@src.scuttle_outlier_higher(), + ) catch { + _ => abort("valid higher-tail configuration should build") + } + let result = @src.scuttle_is_outlier([0.0, 10.0, 10.0, 11.0, 100.0], config~) catch { + _ => abort("higher-tail outlier detection should work") + } + assert_false(scuttle_test_outlier_value(result.outliers[0])) + assert_true(scuttle_test_outlier_value(result.outliers[4])) + assert_true(result.lower[0] <= -1.0e299) +} + +///| +test "scuttle: nmads changes the outlier thresholds" { + let config = @src.ScuttleOutlierConfig::create(nmads=5.0) catch { + _ => abort("valid nmads configuration should build") + } + let result = @src.scuttle_is_outlier([1.0, 2.0, 2.0, 3.0, 100.0], config~) catch { + _ => abort("outlier detection should work") + } + assert_true(scuttle_test_close(result.lower[0], -5.413, 1.0e-10)) + assert_true(scuttle_test_close(result.higher[0], 9.413, 1.0e-10)) +} + +///| +test "scuttle: min diff dominates a small MAD" { + let config = @src.ScuttleOutlierConfig::create(nmads=1.0, min_diff=Some(10.0)) catch { + _ => abort("valid min-diff configuration should build") + } + let result = @src.scuttle_is_outlier([1.0, 2.0, 2.0, 3.0, 20.0], config~) catch { + _ => abort("outlier detection should work") + } + assert_eq(result.lower[0], -8.0) + assert_eq(result.higher[0], 12.0) + assert_true(scuttle_test_outlier_value(result.outliers[4])) +} + +///| +test "scuttle: threshold subset is applied to all observations" { + let config = @src.ScuttleOutlierConfig::create( + nmads=1.0, + subset=Some([0, 1, 2]), + ) catch { + _ => abort("valid subset configuration should build") + } + let result = @src.scuttle_is_outlier([1.0, 2.0, 3.0, 50.0], config~) catch { + _ => abort("subset outlier detection should work") + } + assert_eq(result.medians[0], 2.0) + assert_true(scuttle_test_outlier_value(result.outliers[3])) +} + +///| +test "scuttle: explicit empty threshold subset yields missing statuses" { + let config = @src.ScuttleOutlierConfig::create(subset=Some([])) catch { + _ => abort("empty subset is a valid explicit subset") + } + let result = @src.scuttle_is_outlier([1.0, 2.0, 3.0], config~) catch { + _ => abort("empty-subset detection should return missing statuses") + } + assert_false(result.threshold_valid[0]) + assert_true(result.outliers[0] is None) + assert_true(result.outliers[2] is None) +} + +///| +test "scuttle: threshold subset indices are validated" { + let config = @src.ScuttleOutlierConfig::create(subset=Some([3])) catch { + _ => abort("subset bounds are checked when data are available") + } + let mut raised = false + ignore(@src.scuttle_is_outlier([1.0, 2.0, 3.0], config~)) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "scuttle: batch-specific thresholds are independent" { + let config = @src.ScuttleOutlierConfig::create(nmads=1.0, batches=[ + "A", "A", "A", "B", "B", "B", + ]) catch { + _ => abort("valid batch configuration should build") + } + let result = @src.scuttle_is_outlier( + [1.0, 2.0, 3.0, 100.0, 101.0, 102.0], + config~, + ) catch { + _ => abort("batch-aware detection should work") + } + assert_eq(result.batch_names, ["A", "B"]) + assert_eq(result.medians, [2.0, 101.0]) + assert_false(scuttle_test_outlier_value(result.outliers[0])) + assert_false(scuttle_test_outlier_value(result.outliers[5])) +} + +///| +test "scuttle: batch names use sorted factor order" { + let config = @src.ScuttleOutlierConfig::create(batches=["z", "a", "m", "z"]) catch { + _ => abort("valid batches should build") + } + let result = @src.scuttle_is_outlier([1.0, 2.0, 3.0, 4.0], config~) catch { + _ => abort("batch-aware detection should work") + } + assert_eq(result.batch_names, ["a", "m", "z"]) +} + +///| +test "scuttle: shared medians and MADs reproduce global thresholds" { + let config = @src.ScuttleOutlierConfig::create( + batches=["A", "A", "B", "B", "B"], + share_medians=true, + share_mads=true, + ) catch { + _ => abort("valid sharing configuration should build") + } + let result = @src.scuttle_is_outlier([1.0, 2.0, 3.0, 4.0, 100.0], config~) catch { + _ => abort("shared outlier detection should work") + } + let global = @src.scuttle_is_outlier([1.0, 2.0, 3.0, 4.0, 100.0]) catch { + _ => abort("global outlier detection should work") + } + assert_eq(result.medians, [global.medians[0], global.medians[0]]) + assert_eq(result.mads, [global.mads[0], global.mads[0]]) + assert_eq(result.lower, [global.lower[0], global.lower[0]]) +} + +///| +test "scuttle: shared median retains batch-specific MADs" { + let config = @src.ScuttleOutlierConfig::create( + nmads=1.0, + batches=["A", "A", "A", "B", "B", "B"], + share_medians=true, + ) catch { + _ => abort("valid median-sharing configuration should build") + } + let result = @src.scuttle_is_outlier( + [1.0, 2.0, 3.0, 10.0, 20.0, 30.0], + config~, + ) catch { + _ => abort("shared-median detection should work") + } + assert_eq(result.medians[0], result.medians[1]) + assert_true(result.mads[1] > result.mads[0]) +} + +///| +test "scuttle: shared MAD retains batch-specific medians" { + let config = @src.ScuttleOutlierConfig::create( + batches=["A", "A", "A", "B", "B", "B"], + share_mads=true, + ) catch { + _ => abort("valid MAD-sharing configuration should build") + } + let result = @src.scuttle_is_outlier( + [1.0, 2.0, 3.0, 100.0, 101.0, 102.0], + config~, + ) catch { + _ => abort("shared-MAD detection should work") + } + assert_eq(result.medians, [2.0, 101.0]) + assert_eq(result.mads[0], result.mads[1]) +} + +///| +test "scuttle: missing batch thresholds are recovered by default" { + let config = @src.ScuttleOutlierConfig::create( + batches=["A", "A", "B", "B"], + subset=Some([0, 1]), + ) catch { + _ => abort("valid missing-batch configuration should build") + } + let result = @src.scuttle_is_outlier([1.0, 3.0, 100.0, 200.0], config~) catch { + _ => abort("missing batch should borrow thresholds") + } + assert_true(result.threshold_valid[0]) + assert_true(result.threshold_valid[1]) + assert_eq(result.lower[0], result.lower[1]) + assert_eq(result.higher[0], result.higher[1]) +} + +///| +test "scuttle: missing batch statuses can remain missing" { + let config = @src.ScuttleOutlierConfig::create( + batches=["A", "A", "B", "B"], + subset=Some([0, 1]), + share_missing=false, + ) catch { + _ => abort("valid no-sharing configuration should build") + } + let result = @src.scuttle_is_outlier([1.0, 3.0, 100.0, 200.0], config~) catch { + _ => abort("missing batch should remain missing") + } + assert_true(result.threshold_valid[0]) + assert_false(result.threshold_valid[1]) + assert_true(result.outliers[2] is None) +} + +///| +test "scuttle: batch vector length is validated" { + let config = @src.ScuttleOutlierConfig::create(batches=["A"]) catch { + _ => abort("configuration construction does not know metric length") + } + let mut raised = false + ignore(@src.scuttle_is_outlier([1.0, 2.0], config~)) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "scuttle: log thresholds are returned on the original scale" { + let config = @src.ScuttleOutlierConfig::create(nmads=1.0, log_transform=true) catch { + _ => abort("valid log configuration should build") + } + let result = @src.scuttle_is_outlier([1.0, 2.0, 4.0, 8.0, 1024.0], config~) catch { + _ => abort("log outlier detection should work") + } + assert_true(scuttle_test_close(result.medians[0], 4.0, 1.0e-10)) + assert_true(result.lower[0] > 1.0) + assert_true(result.higher[0] < 16.0) + assert_true(scuttle_test_outlier_value(result.outliers[4])) +} + +///| +test "scuttle: zero can participate in log outlier detection" { + let config = @src.ScuttleOutlierConfig::create(log_transform=true) catch { + _ => abort("valid log configuration should build") + } + let result = @src.scuttle_is_outlier([0.0, 8.0, 8.0, 8.0, 8.0], config~) catch { + _ => abort("zero should be represented on the log scale") + } + assert_true(scuttle_test_outlier_value(result.outliers[0])) + assert_true(scuttle_test_close(result.medians[0], 8.0, 1.0e-10)) +} + +///| +test "scuttle: negative log metrics are rejected" { + let config = @src.ScuttleOutlierConfig::create(log_transform=true) catch { + _ => abort("valid log configuration should build") + } + let mut raised = false + ignore(@src.scuttle_is_outlier([-1.0, 2.0], config~)) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "scuttle: empty metric returns an empty filter" { + let result = @src.scuttle_is_outlier([]) catch { + _ => abort("empty metrics should be supported") + } + assert_eq(result.outliers.length(), 0) + assert_false(result.threshold_valid[0]) +} + +///| +test "scuttle: per-feature QC computes means and detection percentages" { + let metrics = @src.scuttle_per_feature_qc([ + [0.0, 2.0, 4.0, 6.0], + [1.0, 0.0, 0.0, 3.0], + ]) catch { + _ => abort("valid feature QC should work") + } + assert_eq(metrics.means, [3.0, 1.0]) + assert_eq(metrics.detected_percent, [75.0, 50.0]) +} + +///| +test "scuttle: feature detection limit is strict" { + let metrics = @src.scuttle_per_feature_qc( + [[0.0, 2.0, 4.0, 6.0]], + detection_limit=2.0, + ) catch { + _ => abort("feature QC with a limit should work") + } + assert_eq(metrics.detected_percent, [50.0]) +} + +///| +test "scuttle: per-feature QC computes subset statistics" { + let subset = @src.ScuttleNamedCellSubset::create("controls", [0, 1]) catch { + _ => abort("valid subset should build") + } + let metrics = @src.scuttle_per_feature_qc( + [[0.0, 2.0, 4.0, 6.0], [1.0, 0.0, 0.0, 3.0]], + subsets=[subset], + ) catch { + _ => abort("subset feature QC should work") + } + assert_eq(metrics.subset_names, ["controls"]) + assert_eq(metrics.subset_means[0], [1.0, 0.5]) + assert_eq(metrics.subset_detected_percent[0], [50.0, 50.0]) + assert_true( + scuttle_test_close(metrics.subset_ratios[0][0], 1.0 / 3.0, 1.0e-12), + ) +} + +///| +test "scuttle: per-feature QC supports multiple cell subsets" { + let first = @src.ScuttleNamedCellSubset::create("first", [0, 1]) catch { + _ => abort("valid subset should build") + } + let last = @src.ScuttleNamedCellSubset::create("last", [2, 3]) catch { + _ => abort("valid subset should build") + } + let metrics = @src.scuttle_per_feature_qc([[0.0, 2.0, 4.0, 6.0]], subsets=[ + first, last, + ]) catch { + _ => abort("multiple-subset feature QC should work") + } + assert_eq(metrics.subset_names, ["first", "last"]) + assert_eq(metrics.subset_means[0], [1.0]) + assert_eq(metrics.subset_means[1], [5.0]) +} + +///| +test "scuttle: zero feature mean has a finite zero subset ratio" { + let subset = @src.ScuttleNamedCellSubset::create("empty", []) catch { + _ => abort("empty named subset should build") + } + let metrics = @src.scuttle_per_feature_qc([[0.0, 0.0]], subsets=[subset]) catch { + _ => abort("zero feature QC should work") + } + assert_eq(metrics.subset_ratios[0], [0.0]) +} + +///| +test "scuttle: repeated cell subset indices retain R indexing weights" { + let subset = @src.ScuttleNamedCellSubset::create("weighted", [0, 0, 1]) catch { + _ => abort("repeated indices are valid") + } + let metrics = @src.scuttle_per_feature_qc([[3.0, 9.0]], subsets=[subset]) catch { + _ => abort("weighted subset QC should work") + } + assert_eq(metrics.subset_means[0], [5.0]) +} + +///| +test "scuttle: duplicate cell subset names are rejected" { + let first = @src.ScuttleNamedCellSubset::create("same", [0]) catch { + _ => abort("valid subset should build") + } + let second = @src.ScuttleNamedCellSubset::create("same", [1]) catch { + _ => abort("valid subset should build") + } + let mut raised = false + ignore(@src.scuttle_per_feature_qc([[1.0, 2.0]], subsets=[first, second])) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "scuttle: cell subset bounds are validated" { + let subset = @src.ScuttleNamedCellSubset::create("bad", [2]) catch { + _ => abort("bounds are checked with data") + } + let mut raised = false + ignore(@src.scuttle_per_feature_qc([[1.0, 2.0]], subsets=[subset])) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "scuttle: per-feature QC rejects ragged matrices" { + let mut raised = false + ignore(@src.scuttle_per_feature_qc([[1.0, 2.0], [3.0]])) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "scuttle: per-feature QC rejects negative counts" { + let mut raised = false + ignore(@src.scuttle_per_feature_qc([[1.0, -1.0]])) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "scuttle: arbitrary feature sets are summed per cell" { + let first = @src.ScuttleFeatureSet::create("first", [0, 2]) catch { + _ => abort("valid feature set should build") + } + let second = @src.ScuttleFeatureSet::create("second", [1]) catch { + _ => abort("valid feature set should build") + } + let result = @src.scuttle_aggregate_feature_sets( + [[1.0, 2.0], [10.0, 20.0], [3.0, 4.0]], + [first, second], + ) catch { + _ => abort("feature aggregation should work") + } + assert_eq(result.names, ["first", "second"]) + assert_eq(result.sizes, [2, 1]) + assert_eq(result.values, [[4.0, 6.0], [10.0, 20.0]]) +} + +///| +test "scuttle: overlapping feature sets are independent" { + let left = @src.ScuttleFeatureSet::create("left", [0, 1]) catch { + _ => abort("valid feature set should build") + } + let right = @src.ScuttleFeatureSet::create("right", [1, 2]) catch { + _ => abort("valid feature set should build") + } + let result = @src.scuttle_aggregate_feature_sets([[1.0], [2.0], [4.0]], [ + left, right, + ]) catch { + _ => abort("overlapping aggregation should work") + } + assert_eq(result.values, [[3.0], [6.0]]) +} + +///| +test "scuttle: feature-set averages divide by set size" { + let set = @src.ScuttleFeatureSet::create("mean", [0, 1]) catch { + _ => abort("valid feature set should build") + } + let result = @src.scuttle_aggregate_feature_sets( + [[2.0, 4.0], [4.0, 8.0]], + [set], + average=true, + ) catch { + _ => abort("average aggregation should work") + } + assert_eq(result.values, [[3.0, 6.0]]) +} + +///| +test "scuttle: detected features can be aggregated across sets" { + let set = @src.ScuttleFeatureSet::create("detected", [0, 1, 2]) catch { + _ => abort("valid feature set should build") + } + let result = @src.scuttle_aggregate_feature_sets( + [[0.0, 2.0], [3.0, 1.0], [4.0, 0.0]], + [set], + detection_limit=Some(1.0), + ) catch { + _ => abort("detection aggregation should work") + } + assert_eq(result.values, [[2.0, 1.0]]) +} + +///| +test "scuttle: feature identifiers are aggregated in factor order" { + let result = @src.scuttle_aggregate_features_by_ids( + [[1.0], [2.0], [4.0], [8.0]], + ["z", "a", "z", "m"], + ) catch { + _ => abort("identifier aggregation should work") + } + assert_eq(result.names, ["a", "m", "z"]) + assert_eq(result.values, [[2.0], [8.0], [5.0]]) +} + +///| +test "scuttle: empty feature identifiers are ignored" { + let result = @src.scuttle_aggregate_features_by_ids([[1.0], [2.0], [4.0]], [ + "A", "", "A", + ]) catch { + _ => abort("empty identifiers should be ignored") + } + assert_eq(result.names, ["A"]) + assert_eq(result.values, [[5.0]]) +} + +///| +test "scuttle: feature identifier length is validated" { + let mut raised = false + ignore(@src.scuttle_aggregate_features_by_ids([[1.0], [2.0]], ["A"])) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "scuttle: duplicate feature-set names are rejected" { + let first = @src.ScuttleFeatureSet::create("same", [0]) catch { + _ => abort("valid feature set should build") + } + let second = @src.ScuttleFeatureSet::create("same", [1]) catch { + _ => abort("valid feature set should build") + } + let mut raised = false + ignore(@src.scuttle_aggregate_feature_sets([[1.0], [2.0]], [first, second])) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "scuttle: feature-set bounds are validated" { + let set = @src.ScuttleFeatureSet::create("bad", [2]) catch { + _ => abort("bounds are checked with data") + } + let mut raised = false + ignore(@src.scuttle_aggregate_feature_sets([[1.0], [2.0]], [set])) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "scuttle: per-column downsampling has exact rounded totals" { + let counts = scuttle_test_counts() + let output = @src.scuttle_downsample_matrix(counts, 0.5, seed=42) catch { + _ => abort("downsampling should work") + } + assert_eq(scuttle_test_column_sums(output), [10.0, 10.0, 20.0, 20.0]) +} + +///| +test "scuttle: downsampled entries never exceed sanitized inputs" { + let counts = scuttle_test_counts() + let output = @src.scuttle_downsample_matrix(counts, 0.75, seed=11) catch { + _ => abort("downsampling should work") + } + for feature in 0..= 0.0) + } + } +} + +///| +test "scuttle: per-cell proportions can differ" { + let counts = scuttle_test_counts() + let output = @src.scuttle_downsample_columns( + counts, + [0.0, 0.25, 0.5, 1.0], + seed=7, + ) catch { + _ => abort("vector downsampling should work") + } + assert_eq(scuttle_test_column_sums(output), [0.0, 5.0, 20.0, 40.0]) +} + +///| +test "scuttle: global downsampling has an exact matrix total" { + let counts = scuttle_test_counts() + let output = @src.scuttle_downsample_matrix( + counts, + 0.3, + by_column=false, + seed=9, + ) catch { + _ => abort("global downsampling should work") + } + assert_eq(scuttle_test_total(output), 36.0) +} + +///| +test "scuttle: downsampling rounds and clamps numeric inputs" { + let output = @src.scuttle_downsample_matrix([[-2.0, 1.4], [3.6, 2.6]], 1.0) catch { + _ => abort("input sanitization should work") + } + assert_eq(output, [[0.0, 1.0], [4.0, 3.0]]) +} + +///| +test "scuttle: equal seeds produce identical samples" { + let counts = scuttle_test_counts() + let first = @src.scuttle_downsample_matrix(counts, 0.45, seed=123) catch { + _ => abort("first downsampling should work") + } + let second = @src.scuttle_downsample_matrix(counts, 0.45, seed=123) catch { + _ => abort("second downsampling should work") + } + assert_eq(first, second) +} + +///| +test "scuttle: different seeds change nontrivial samples" { + let counts = scuttle_test_counts() + let first = @src.scuttle_downsample_matrix(counts, 0.45, seed=1) catch { + _ => abort("first downsampling should work") + } + let second = @src.scuttle_downsample_matrix(counts, 0.45, seed=2) catch { + _ => abort("second downsampling should work") + } + assert_true(first != second) +} + +///| +test "scuttle: zero and unit proportions are exact boundaries" { + let counts = scuttle_test_counts() + let zero = @src.scuttle_downsample_matrix(counts, 0.0) catch { + _ => abort("zero downsampling should work") + } + let one = @src.scuttle_downsample_matrix(counts, 1.0) catch { + _ => abort("unit downsampling should work") + } + assert_eq(scuttle_test_total(zero), 0.0) + assert_eq(one, counts) +} + +///| +test "scuttle: invalid downsampling proportions are rejected" { + let mut raised = false + ignore(@src.scuttle_downsample_matrix([[1.0]], 1.1)) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "scuttle: downsampling validates vector length and seed" { + let mut bad_length = false + ignore(@src.scuttle_downsample_columns([[1.0, 2.0]], [0.5])) catch { + _ => bad_length = true + } + assert_true(bad_length) + let mut bad_seed = false + ignore(@src.scuttle_downsample_matrix([[1.0]], 0.5, seed=0)) catch { + _ => bad_seed = true + } + assert_true(bad_seed) +} + +///| +test "scuttle: batch downsampling targets the shallowest median" { + let counts = [[5.0, 5.0, 10.0, 10.0], [5.0, 5.0, 10.0, 10.0]] + let result = @src.scuttle_downsample_batches( + counts, + ["A", "A", "B", "B"], + seed=4, + ) catch { + _ => abort("batch downsampling should work") + } + assert_eq(result.group_names, ["A", "B"]) + assert_eq(result.summaries, [10.0, 20.0]) + assert_eq(result.proportions, [1.0, 0.5]) + assert_eq(scuttle_test_column_sums(result.matrix), [10.0, 10.0, 10.0, 10.0]) +} + +///| +test "scuttle: global batch downsampling equalizes group totals" { + let counts = [[5.0, 5.0, 10.0, 10.0], [5.0, 5.0, 10.0, 10.0]] + let result = @src.scuttle_downsample_batches( + counts, + ["A", "A", "B", "B"], + by_column=false, + seed=4, + ) catch { + _ => abort("global batch downsampling should work") + } + let sums = scuttle_test_column_sums(result.matrix) + assert_eq(sums[0] + sums[1], 20.0) + assert_eq(sums[2] + sums[3], 20.0) +} + +///| +test "scuttle: blocking equalizes batches only within each block" { + let counts = [[10.0, 20.0, 100.0, 200.0]] + let result = @src.scuttle_downsample_batches( + counts, + ["A", "B", "A", "B"], + blocks=["sample1", "sample1", "sample2", "sample2"], + seed=8, + ) catch { + _ => abort("blocked batch downsampling should work") + } + assert_eq(result.group_names, [ + "sample1|A", "sample1|B", "sample2|A", "sample2|B", + ]) + assert_eq(result.proportions, [1.0, 0.5, 1.0, 0.5]) + assert_eq(scuttle_test_column_sums(result.matrix), [10.0, 10.0, 100.0, 100.0]) +} + +///| +test "scuttle: batch mean summary is selectable" { + let counts = [[2.0, 10.0, 12.0, 24.0]] + let result = @src.scuttle_downsample_batches( + counts, + ["A", "A", "B", "B"], + summary_method=@src.scuttle_batch_mean(), + seed=10, + ) catch { + _ => abort("mean batch downsampling should work") + } + assert_eq(result.summaries, [6.0, 18.0]) + assert_true(scuttle_test_close(result.proportions[1], 1.0 / 3.0, 1.0e-12)) +} + +///| +test "scuttle: geometric batch summary uses a pseudocount" { + let counts = [[0.0, 3.0, 8.0, 8.0]] + let result = @src.scuttle_downsample_batches( + counts, + ["A", "A", "B", "B"], + summary_method=@src.scuttle_batch_geometric_mean(), + seed=10, + ) catch { + _ => abort("geometric batch downsampling should work") + } + assert_eq(result.summaries[0], 2.0) + assert_true(scuttle_test_close(result.summaries[1], 9.0, 1.0e-10)) +} + +///| +test "scuttle: batch downsampling validates annotations" { + let mut bad_batch = false + ignore(@src.scuttle_downsample_batches([[1.0, 2.0]], ["A"])) catch { + _ => bad_batch = true + } + assert_true(bad_batch) + let mut bad_block = false + ignore( + @src.scuttle_downsample_batches([[1.0, 2.0]], ["A", "B"], blocks=["one"]), + ) catch { + _ => bad_block = true + } + assert_true(bad_block) +} + +///| +test "scuttle: feature QC SCE wrapper writes row metadata immutably" { + let sce = scuttle_test_sce() + let controls = @src.ScuttleNamedCellSubset::create("controls", [0, 1]) catch { + _ => abort("valid subset should build") + } + let output = @src.scuttle_per_feature_qc_sce(sce, subsets=[controls]) catch { + _ => abort("SCE feature QC should work") + } + assert_eq(@src.sce_get_row_data(sce, "scuttle.mean").length(), 0) + assert_eq( + @src.sce_get_row_data(output.experiment, "scuttle.mean").length(), + 4, + ) + assert_eq( + @src.sce_get_row_data(output.experiment, "scuttle.subsets.controls.ratio").length(), + 4, + ) + output.experiment.assays["counts"][0][0] = 999.0 + assert_eq(sce.assays["counts"][0][0], 8.0) +} + +///| +test "scuttle: feature QC SCE wrapper validates assay names" { + let sce = scuttle_test_sce() + let mut raised = false + ignore(@src.scuttle_per_feature_qc_sce(sce, assay_name="missing")) catch { + _ => raised = true + } + assert_true(raised) +} + +///| +test "scuttle: SCE feature aggregation handles multiple assays" { + let sce = scuttle_test_sce() + let first = @src.ScuttleFeatureSet::create("PathwayA", [0, 1]) catch { + _ => abort("valid feature set should build") + } + let second = @src.ScuttleFeatureSet::create("PathwayB", [2, 3]) catch { + _ => abort("valid feature set should build") + } + let output = @src.scuttle_aggregate_feature_sets_sce(sce, [first, second], assay_names=[ + "counts", "logcounts", + ]) catch { + _ => abort("SCE feature aggregation should work") + } + assert_eq(output.row_names, ["PathwayA", "PathwayB"]) + assert_eq(output.assays["counts"], [ + [10.0, 10.0, 20.0, 20.0], + [10.0, 10.0, 20.0, 20.0], + ]) + assert_eq(output.assays["logcounts"].length(), 2) + assert_eq(output.col_data["batch"], ["A", "A", "B", "B"]) + assert_eq(output.reduced_dims["PCA"].length(), 4) + assert_eq(output.alternative_experiments["spike"].row_names, ["Spike1"]) + assert_eq(output.metadata["project"], "scuttle-test") +} + +///| +test "scuttle: SCE feature aggregation discards gene metadata and deep copies" { + let sce = scuttle_test_sce() + let set = @src.ScuttleFeatureSet::create("all", [0, 1, 2, 3]) catch { + _ => abort("valid feature set should build") + } + let output = @src.scuttle_aggregate_feature_sets_sce(sce, [set]) catch { + _ => abort("SCE feature aggregation should work") + } + assert_eq(output.row_data.keys().collect().length(), 0) + output.col_data["batch"][0] = "changed" + output.reduced_dims["PCA"][0][0] = 999.0 + assert_eq(sce.col_data["batch"][0], "A") + assert_eq(sce.reduced_dims["PCA"][0][0], 1.0) +} + +///| +test "scuttle: SCE downsampling adds an assay without mutating input" { + let sce = scuttle_test_sce() + let output = @src.scuttle_downsample_sce( + sce, + 0.5, + output_assay="half", + seed=42, + ) catch { + _ => abort("SCE downsampling should work") + } + assert_eq(@src.sce_get_assay(sce, "half").length(), 0) + assert_eq(scuttle_test_column_sums(@src.sce_get_assay(output, "half")), [ + 10.0, 10.0, 20.0, 20.0, + ]) + assert_eq(output.metadata["scuttle.downsample.source"], "counts") + output.assays["counts"][0][0] = 999.0 + assert_eq(sce.assays["counts"][0][0], 8.0) + assert_eq(output.alternative_experiments["spike"].row_names, ["Spike1"]) +} + +///| +test "scuttle: SCE downsampling validates source assay" { + let sce = scuttle_test_sce() + let mut raised = false + ignore(@src.scuttle_downsample_sce(sce, 0.5, assay_name="missing")) catch { + _ => raised = true + } + assert_true(raised) +} diff --git a/test/moonbit/single_r_advanced_test.mbt b/test/moonbit/single_r_advanced_test.mbt new file mode 100644 index 00000000..399aa56b --- /dev/null +++ b/test/moonbit/single_r_advanced_test.mbt @@ -0,0 +1,985 @@ +///| +fn single_r_adv_test_example() -> ( + @src.SingleRAdvancedReference, + @src.SingleRAdvancedData, +) { + @src.single_r_advanced_example() catch { + _ => abort("valid SingleR advanced example should build") + } +} + +///| +fn single_r_adv_test_result() -> @src.SingleRAdvancedResult { + let (reference, data) = single_r_adv_test_example() + @src.single_r_advanced(data, reference) catch { + _ => abort("valid SingleR advanced example should classify") + } +} + +///| +fn single_r_adv_test_sce() -> @src.SingleCellExperiment { + let (_, data) = single_r_adv_test_example() + let experiment = @src.SingleCellExperiment::new( + data.expression.map(fn(row) { row.copy() }), + data.gene_names.copy(), + data.cell_names.copy(), + ) + experiment.assays["logcounts"] = data.expression.map(fn(row) { row.copy() }) + experiment.col_data["batch"] = ["x", "x", "y", "y", "y"] + experiment.row_data["symbol"] = data.gene_names.copy() + experiment.reduced_dims["PCA"] = [ + [0.0, 1.0], + [1.0, 0.0], + [0.5, 0.5], + [0.2, 0.8], + [0.8, 0.2], + ] + experiment.metadata["source"] = "test" + experiment.alternative_experiments["spike"] = @src.SingleCellExperiment::new( + [[1.0, 2.0, 3.0, 4.0, 5.0]], + ["spike1"], + data.cell_names.copy(), + ) + experiment +} + +///| +fn single_r_adv_test_second_reference() -> @src.SingleRAdvancedReference { + let (reference, _) = single_r_adv_test_example() + @src.SingleRAdvancedReference::create( + reference.expression, + [ + "T lymphocyte", "T lymphocyte", "B lymphocyte", "B lymphocyte", "Myeloid", + "Myeloid", "Cytotoxic", "Cytotoxic", + ], + gene_names=reference.gene_names, + sample_names=reference.sample_names, + reference_name="immune_reference_two", + ) catch { + _ => abort("valid second SingleR reference should build") + } +} + +///| +test "SingleR advanced default configuration matches upstream controls" { + let config = @src.SingleRAdvancedConfig::default() + assert_eq(config.quantile, 0.8) + assert_true(config.fine_tune) + assert_eq(config.tune_threshold, 0.05) + assert_true(config.prune) + assert_eq(config.nmads, 3.0) + assert_eq(config.minimum_delta_next, 0.0) + assert_eq(config.marker_count, 0) + assert_eq(config.combine_marker_count, 10) +} + +///| +test "SingleR advanced configuration preserves explicit controls" { + let config = @src.SingleRAdvancedConfig::create( + quantile=0.6, + fine_tune=false, + tune_threshold=0.1, + prune=false, + nmads=2.0, + minimum_delta_median=0.05, + minimum_delta_next=0.02, + marker_count=3, + combine_marker_count=4, + ) catch { + _ => abort("valid SingleR advanced configuration should build") + } + assert_eq(config.quantile, 0.6) + assert_eq(config.fine_tune, false) + assert_eq(config.tune_threshold, 0.1) + assert_eq(config.prune, false) + assert_eq(config.nmads, 2.0) + assert_eq(config.minimum_delta_median, 0.05) + assert_eq(config.minimum_delta_next, 0.02) + assert_eq(config.marker_count, 3) + assert_eq(config.combine_marker_count, 4) +} + +///| +test "SingleR advanced rejects invalid quantiles" { + let lower = try { + ignore(@src.SingleRAdvancedConfig::create(quantile=-0.1)) + false + } catch { + _ => true + } + let upper = try { + ignore(@src.SingleRAdvancedConfig::create(quantile=1.1)) + false + } catch { + _ => true + } + assert_true(lower) + assert_true(upper) +} + +///| +test "SingleR advanced rejects invalid tuning and pruning controls" { + let tuning = try { + ignore(@src.SingleRAdvancedConfig::create(tune_threshold=-0.1)) + false + } catch { + _ => true + } + let nmads = try { + ignore(@src.SingleRAdvancedConfig::create(nmads=-1.0)) + false + } catch { + _ => true + } + assert_true(tuning) + assert_true(nmads) +} + +///| +test "SingleR advanced rejects invalid marker controls" { + let markers = try { + ignore(@src.SingleRAdvancedConfig::create(marker_count=-1)) + false + } catch { + _ => true + } + let combine = try { + ignore(@src.SingleRAdvancedConfig::create(combine_marker_count=0)) + false + } catch { + _ => true + } + assert_true(markers) + assert_true(combine) +} + +///| +test "SingleR advanced reference uses gene by sample orientation" { + let (reference, _) = single_r_adv_test_example() + assert_eq(reference.n_genes, 12) + assert_eq(reference.n_samples, 8) + assert_eq(reference.expression[0].length(), 8) + assert_eq(reference.gene_names[0], "CD3D") + assert_eq(reference.sample_names[7], "NK2") +} + +///| +test "SingleR advanced preserves first occurrence label order" { + let (reference, _) = single_r_adv_test_example() + assert_eq(reference.label_names, ["T cell", "B cell", "Monocyte", "NK cell"]) +} + +///| +test "SingleR advanced reference defensively copies inputs" { + let expression = [[1.0, 2.0], [3.0, 4.0]] + let labels = ["A", "B"] + let genes = ["g1", "g2"] + let reference = @src.SingleRAdvancedReference::create( + expression, + labels, + gene_names=genes, + ) catch { + _ => abort("valid reference should build") + } + expression[0][0] = 99.0 + labels[0] = "changed" + genes[0] = "changed" + assert_eq(reference.expression[0][0], 1.0) + assert_eq(reference.labels[0], "A") + assert_eq(reference.gene_names[0], "g1") +} + +///| +test "SingleR advanced accepts finite negative normalized expression" { + let reference = @src.SingleRAdvancedReference::create( + [[-2.0, 1.0], [0.0, -1.0]], + ["A", "B"], + ) catch { + _ => abort("finite normalized expression may be negative") + } + assert_eq(reference.expression[0][0], -2.0) +} + +///| +test "SingleR advanced data uses gene by cell orientation" { + let (_, data) = single_r_adv_test_example() + assert_eq(data.n_genes, 12) + assert_eq(data.n_cells, 5) + assert_eq(data.expression[0].length(), 5) + assert_eq(data.cell_names[4], "cell_ambiguous") +} + +///| +test "SingleR advanced data defensively copies inputs" { + let expression = [[1.0, 2.0], [3.0, 4.0]] + let data = @src.SingleRAdvancedData::create( + expression, + gene_names=["g1", "g2"], + cell_names=["c1", "c2"], + ) catch { + _ => abort("valid data should build") + } + expression[0][0] = 99.0 + let copied = data.copy_expression() + copied[0][0] = 77.0 + assert_eq(data.expression[0][0], 1.0) +} + +///| +test "SingleR advanced constructors reject empty matrices" { + let reference = try { + ignore(@src.SingleRAdvancedReference::create([], [])) + false + } catch { + _ => true + } + let data = try { + ignore(@src.SingleRAdvancedData::create([[]])) + false + } catch { + _ => true + } + assert_true(reference) + assert_true(data) +} + +///| +test "SingleR advanced constructors reject ragged matrices" { + let reference = try { + ignore( + @src.SingleRAdvancedReference::create([[1.0, 2.0], [3.0]], ["A", "B"]), + ) + false + } catch { + _ => true + } + let data = try { + ignore(@src.SingleRAdvancedData::create([[1.0, 2.0], [3.0]])) + false + } catch { + _ => true + } + assert_true(reference) + assert_true(data) +} + +///| +test "SingleR advanced constructors reject non-finite values" { + let reference = try { + ignore( + @src.SingleRAdvancedReference::create([[1.0, 1.0e301], [2.0, 3.0]], [ + "A", "B", + ]), + ) + false + } catch { + _ => true + } + let data = try { + ignore(@src.SingleRAdvancedData::create([[0.0 / 0.0, 1.0]])) + false + } catch { + _ => true + } + assert_true(reference) + assert_true(data) +} + +///| +test "SingleR advanced reference validates label dimensions and content" { + let dimensions = try { + ignore( + @src.SingleRAdvancedReference::create([[1.0, 2.0], [3.0, 4.0]], ["A"]), + ) + false + } catch { + _ => true + } + let content = try { + ignore( + @src.SingleRAdvancedReference::create([[1.0, 2.0], [3.0, 4.0]], ["A", " "]), + ) + false + } catch { + _ => true + } + assert_true(dimensions) + assert_true(content) +} + +///| +test "SingleR advanced constructors validate name dimensions" { + let genes = try { + ignore( + @src.SingleRAdvancedData::create([[1.0, 2.0], [3.0, 4.0]], gene_names=[ + "g1", + ]), + ) + false + } catch { + _ => true + } + let samples = try { + ignore( + @src.SingleRAdvancedReference::create( + [[1.0, 2.0], [3.0, 4.0]], + ["A", "B"], + sample_names=["s1"], + ), + ) + false + } catch { + _ => true + } + assert_true(genes) + assert_true(samples) +} + +///| +test "SingleR advanced constructors reject duplicate names" { + let genes = try { + ignore( + @src.SingleRAdvancedData::create([[1.0, 2.0], [3.0, 4.0]], gene_names=[ + "g", "g", + ]), + ) + false + } catch { + _ => true + } + let cells = try { + ignore( + @src.SingleRAdvancedData::create([[1.0, 2.0], [3.0, 4.0]], cell_names=[ + "c", "c", + ]), + ) + false + } catch { + _ => true + } + assert_true(genes) + assert_true(cells) +} + +///| +test "SingleR advanced Spearman handles positive negative and tied ranks" { + let positive = @src.single_r_advanced_spearman([1.0, 2.0, 2.0, 4.0], [ + 10.0, 20.0, 20.0, 40.0, + ]) catch { + _ => abort("valid tied Spearman vectors should work") + } + let negative = @src.single_r_advanced_spearman([1.0, 2.0, 3.0, 4.0], [ + 4.0, 3.0, 2.0, 1.0, + ]) catch { + _ => abort("valid Spearman vectors should work") + } + assert_true(positive > 0.999) + assert_true(negative < -0.999) +} + +///| +test "SingleR advanced Spearman validates dimensions and finite values" { + let dimensions = try { + ignore(@src.single_r_advanced_spearman([1.0], [1.0, 2.0])) + false + } catch { + _ => true + } + let finite = try { + ignore(@src.single_r_advanced_spearman([1.0, 1.0e301], [1.0, 2.0])) + false + } catch { + _ => true + } + assert_true(dimensions) + assert_true(finite) +} + +///| +test "SingleR advanced training aligns genes in test order" { + let (reference, _) = single_r_adv_test_example() + let training = @src.single_r_advanced_train( + reference, + ["GNLY", "missing", "CD3D", "MS4A1"], + marker_count=1, + ) catch { + _ => abort("gene intersection should train") + } + assert_eq(training.common_gene_names, ["GNLY", "CD3D", "MS4A1"]) + assert_eq(training.test_gene_indices, [0, 2, 3]) + assert_eq(training.reference_gene_indices, [11, 0, 3]) +} + +///| +test "SingleR advanced training honors gene restrictions" { + let (reference, data) = single_r_adv_test_example() + let training = @src.single_r_advanced_train( + reference, + data.gene_names, + restrict_genes=["CD3D", "MS4A1", "LYZ", "NKG7"], + marker_count=1, + ) catch { + _ => abort("restricted training should work") + } + assert_eq(training.common_gene_names, ["CD3D", "MS4A1", "LYZ", "NKG7"]) +} + +///| +test "SingleR advanced training rejects insufficient shared genes" { + let (reference, _) = single_r_adv_test_example() + let raised = try { + ignore(@src.single_r_advanced_train(reference, ["missing", "CD3D"])) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "SingleR advanced training computes automatic marker count" { + let (reference, data) = single_r_adv_test_example() + let training = @src.single_r_advanced_train(reference, data.gene_names) catch { + _ => abort("automatic marker training should work") + } + assert_true(training.marker_count > 0) + assert_true(training.common_markers.length() >= 2) +} + +///| +test "SingleR advanced classic markers are directional" { + let (reference, data) = single_r_adv_test_example() + let training = @src.single_r_advanced_train( + reference, + data.gene_names, + marker_count=2, + ) catch { + _ => abort("marker training should work") + } + let t_markers = training.markers_between("T cell", "B cell") catch { + _ => abort("known labels should have markers") + } + let b_markers = training.markers_between("B cell", "T cell") catch { + _ => abort("known labels should have markers") + } + assert_true(t_markers.contains("CD3D") || t_markers.contains("CD3E")) + assert_true(b_markers.contains("MS4A1") || b_markers.contains("CD79A")) +} + +///| +test "SingleR advanced self comparison has no markers" { + let (reference, data) = single_r_adv_test_example() + let training = @src.single_r_advanced_train(reference, data.gene_names) catch { + _ => abort("marker training should work") + } + assert_eq( + training.markers_between("T cell", "T cell") catch { + _ => abort("known labels should query") + }, + [], + ) +} + +///| +test "SingleR advanced marker query rejects unknown labels" { + let (reference, data) = single_r_adv_test_example() + let training = @src.single_r_advanced_train(reference, data.gene_names) catch { + _ => abort("marker training should work") + } + let raised = try { + ignore(training.markers_between("missing", "T cell")) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "SingleR advanced classification locks training gene order" { + let (reference, data) = single_r_adv_test_example() + let training = @src.single_r_advanced_train(reference, data.gene_names) catch { + _ => abort("training should work") + } + let reordered = @src.SingleRAdvancedData::create( + data.expression, + gene_names=[ + "CD3E", "CD3D", "TRAC", "MS4A1", "CD79A", "CD74", "LYZ", "S100A8", "FCGR3A", + "NKG7", "KLRD1", "GNLY", + ], + cell_names=data.cell_names, + ) catch { + _ => abort("reordered data should build") + } + let raised = try { + ignore(@src.single_r_advanced_classify(reordered, training)) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "SingleR advanced classification reports cell by label scores" { + let result = single_r_adv_test_result() + assert_eq(result.n_cells(), 5) + assert_eq(result.scores.length(), 5) + assert_eq(result.scores[0].length(), 4) + assert_eq(result.label_names.length(), 4) +} + +///| +test "SingleR advanced classifies canonical immune profiles" { + let result = single_r_adv_test_result() + assert_eq(result.labels[0], "T cell") + assert_eq(result.labels[1], "B cell") + assert_eq(result.labels[2], "Monocyte") + assert_eq(result.labels[3], "NK cell") +} + +///| +test "SingleR advanced preserves pre-fine-tuning assignments" { + let result = single_r_adv_test_result() + assert_eq(result.first_labels[0], "T cell") + assert_eq(result.first_labels[1], "B cell") + assert_eq(result.first_labels[2], "Monocyte") + assert_eq(result.first_labels[3], "NK cell") +} + +///| +test "SingleR advanced quantile controls label aggregation" { + let (reference, data) = single_r_adv_test_example() + let low = @src.SingleRAdvancedConfig::create( + quantile=0.0, + fine_tune=false, + prune=false, + ) catch { + _ => abort("low quantile configuration should build") + } + let high = @src.SingleRAdvancedConfig::create( + quantile=1.0, + fine_tune=false, + prune=false, + ) catch { + _ => abort("high quantile configuration should build") + } + let low_result = @src.single_r_advanced(data, reference, config=low) catch { + _ => abort("low quantile classification should work") + } + let high_result = @src.single_r_advanced(data, reference, config=high) catch { + _ => abort("high quantile classification should work") + } + assert_true(high_result.scores[0][0] >= low_result.scores[0][0]) + assert_true(high_result.scores[1][1] >= low_result.scores[1][1]) +} + +///| +test "SingleR advanced fine tuning is active for ambiguous candidates" { + let (reference, data) = single_r_adv_test_example() + let config = @src.SingleRAdvancedConfig::create( + tune_threshold=2.0, + prune=false, + ) catch { + _ => abort("wide fine-tuning configuration should build") + } + let result = @src.single_r_advanced(data, reference, config~) catch { + _ => abort("fine-tuned classification should work") + } + assert_true(result.fine_tuned[4]) + assert_true(result.delta_next[4] >= 0.0) +} + +///| +test "SingleR advanced can disable fine tuning" { + let (reference, data) = single_r_adv_test_example() + let config = @src.SingleRAdvancedConfig::create(fine_tune=false, prune=false) catch { + _ => abort("no-fine-tune configuration should build") + } + let result = @src.single_r_advanced(data, reference, config~) catch { + _ => abort("classification without fine tuning should work") + } + for value in result.fine_tuned { + assert_eq(value, false) + } + assert_eq(result.labels, result.first_labels) +} + +///| +test "SingleR advanced delta from median matches score matrix" { + let result = single_r_adv_test_result() + let label = result.label_index(result.labels[0]) + let sorted = result.scores[0] + let median = if sorted.length() == 4 { + let values = sorted.copy() + for index in 1.. 0 && values[position - 1] > current { + values[position] = values[position - 1] + position = position - 1 + } + values[position] = current + } + (values[1] + values[2]) / 2.0 + } else { + 0.0 + } + assert_true( + (result.delta_median[0] - (result.scores[0][label] - median)).abs() < + 1.0e-12, + ) +} + +///| +test "SingleR advanced hard delta pruning uses NA semantics" { + let (reference, data) = single_r_adv_test_example() + let config = @src.SingleRAdvancedConfig::create(minimum_delta_next=3.0) catch { + _ => abort("strict pruning configuration should build") + } + let result = @src.single_r_advanced(data, reference, config~) catch { + _ => abort("strict pruning classification should work") + } + assert_eq(result.n_pruned(), data.n_cells) + for value in result.pruned_labels { + assert_true(value is None) + } +} + +///| +test "SingleR advanced can disable pruning" { + let (reference, data) = single_r_adv_test_example() + let config = @src.SingleRAdvancedConfig::create(prune=false) catch { + _ => abort("unpruned configuration should build") + } + let result = @src.single_r_advanced(data, reference, config~) catch { + _ => abort("unpruned classification should work") + } + assert_eq(result.n_pruned(), 0) + for value in result.pruned_labels { + assert_true(value is Some(_)) + } +} + +///| +test "SingleR advanced computes per-label MAD thresholds" { + let result = single_r_adv_test_result() + let mut observed = 0 + for threshold in result.pruning_thresholds { + if threshold is Some(_) { + observed = observed + 1 + } + } + assert_true(observed > 0) +} + +///| +test "SingleR advanced result query helpers are consistent" { + let result = single_r_adv_test_result() + assert_eq(result.label_index("T cell"), 0) + assert_eq(result.label_index("missing"), -1) + assert_true(result.assigned_score(0) > 0.0) + let summary = result.summary() + assert_eq(summary["total"], 5) + assert_eq( + summary["T cell"] + + summary["B cell"] + + summary["Monocyte"] + + summary["NK cell"], + 5, + ) +} + +///| +test "SingleR advanced assigned score validates cell indices" { + let result = single_r_adv_test_result() + let raised = try { + ignore(result.assigned_score(99)) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "SingleR advanced cluster annotation sums member profiles" { + let (reference, data) = single_r_adv_test_example() + let config = @src.SingleRAdvancedConfig::create(prune=false) catch { + _ => abort("cluster configuration should build") + } + let result = @src.single_r_advanced_clusters( + data, + ["lymphoid", "lymphoid", "myeloid", "cytotoxic", "mixed"], + reference, + config~, + ) catch { + _ => abort("cluster annotation should work") + } + assert_eq(result.cell_names, ["lymphoid", "myeloid", "cytotoxic", "mixed"]) + assert_eq(result.n_cells(), 4) + assert_eq(result.labels[1], "Monocyte") + assert_eq(result.labels[2], "NK cell") +} + +///| +test "SingleR advanced cluster annotation preserves first occurrence order" { + let (reference, data) = single_r_adv_test_example() + let result = @src.single_r_advanced_clusters( + data, + ["z", "a", "z", "b", "a"], + reference, + ) catch { + _ => abort("cluster annotation should work") + } + assert_eq(result.cell_names, ["z", "a", "b"]) +} + +///| +test "SingleR advanced cluster annotation validates assignments" { + let (reference, data) = single_r_adv_test_example() + let dimensions = try { + ignore(@src.single_r_advanced_clusters(data, ["a"], reference)) + false + } catch { + _ => true + } + let names = try { + ignore( + @src.single_r_advanced_clusters(data, ["a", "a", "b", "b", ""], reference), + ) + false + } catch { + _ => true + } + assert_true(dimensions) + assert_true(names) +} + +///| +test "SingleR advanced multi-reference recomputation returns comparable scores" { + let (reference, data) = single_r_adv_test_example() + let second = single_r_adv_test_second_reference() + let result = @src.single_r_advanced_combine(data, [reference, second]) catch { + _ => abort("multi-reference classification should work") + } + assert_eq(result.n_cells(), 5) + assert_eq(result.scores.length(), 5) + assert_eq(result.scores[0].length(), 2) + assert_eq(result.per_reference.length(), 2) + assert_true(result.marker_gene_names.length() >= 2) +} + +///| +test "SingleR advanced multi-reference records selected provenance" { + let (reference, data) = single_r_adv_test_example() + let second = single_r_adv_test_second_reference() + let result = @src.single_r_advanced_combine(data, [reference, second]) catch { + _ => abort("multi-reference classification should work") + } + assert_eq(result.references, ["immune_reference", "immune_reference_two"]) + for selected in result.selected_references { + assert_true(result.references.contains(selected)) + } + let summary = result.reference_summary() + assert_eq(summary["immune_reference"] + summary["immune_reference_two"], 5) +} + +///| +test "SingleR advanced multi-reference rejects too few references" { + let (reference, data) = single_r_adv_test_example() + let raised = try { + ignore(@src.single_r_advanced_combine(data, [reference])) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "SingleR advanced multi-reference rejects duplicate names" { + let (reference, data) = single_r_adv_test_example() + let duplicate = @src.SingleRAdvancedReference::create( + reference.expression, + reference.labels, + gene_names=reference.gene_names, + sample_names=reference.sample_names, + reference_name=reference.reference_name, + ) catch { + _ => abort("duplicate-name reference should build independently") + } + let raised = try { + ignore(@src.single_r_advanced_combine(data, [reference, duplicate])) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "SingleR advanced multi-reference requires global gene intersection" { + let (reference, data) = single_r_adv_test_example() + let other = @src.SingleRAdvancedReference::create( + [[1.0, 2.0], [2.0, 1.0]], + ["X", "Y"], + gene_names=["other1", "other2"], + reference_name="other", + ) catch { + _ => abort("disjoint reference should build") + } + let raised = try { + ignore(@src.single_r_advanced_combine(data, [reference, other])) + false + } catch { + _ => true + } + assert_true(raised) +} + +///| +test "SingleR advanced SingleCellExperiment writes annotation columns" { + let (reference, _) = single_r_adv_test_example() + let output = @src.single_r_advanced_sce( + single_r_adv_test_sce(), + reference, + output_prefix="singler215", + ) catch { + _ => abort("SingleR SCE annotation should work") + } + assert_true(output.experiment.col_data.contains("singler215.labels")) + assert_true(output.experiment.col_data.contains("singler215.pruned.labels")) + assert_true(output.experiment.col_data.contains("singler215.score")) + assert_true(output.experiment.col_data.contains("singler215.delta.next")) + assert_true(output.experiment.col_data.contains("singler215.delta.median")) + assert_eq(output.experiment.col_data["singler215.labels"][0], "T cell") +} + +///| +test "SingleR advanced SingleCellExperiment records provenance metadata" { + let (reference, _) = single_r_adv_test_example() + let output = @src.single_r_advanced_sce( + single_r_adv_test_sce(), + reference, + output_prefix="singler215", + ) catch { + _ => abort("SingleR SCE annotation should work") + } + assert_eq(output.experiment.metadata["singler215.assay"], "logcounts") + assert_eq( + output.experiment.metadata["singler215.reference"], + "immune_reference", + ) + assert_eq(output.experiment.metadata["singler215.quantile"], "0.8") + assert_eq(output.experiment.metadata["singler215.mode"], "cell") + assert_eq(output.experiment.metadata["source"], "test") +} + +///| +test "SingleR advanced SingleCellExperiment does not mutate input" { + let (reference, _) = single_r_adv_test_example() + let input = single_r_adv_test_sce() + let output = @src.single_r_advanced_sce( + input, + reference, + output_prefix="singler215", + ) catch { + _ => abort("SingleR SCE annotation should work") + } + assert_eq(input.col_data.contains("singler215.labels"), false) + output.experiment.assays["logcounts"][0][0] = 999.0 + output.experiment.row_data["symbol"][0] = "changed" + output.experiment.reduced_dims["PCA"][0][0] = 999.0 + output.experiment.alternative_experiments["spike"].assays["counts"][0][0] = 999.0 + assert_true(input.assays["logcounts"][0][0] != 999.0) + assert_eq(input.row_data["symbol"][0], "CD3D") + assert_eq(input.reduced_dims["PCA"][0][0], 0.0) + assert_eq(input.alternative_experiments["spike"].assays["counts"][0][0], 1.0) +} + +///| +test "SingleR advanced SingleCellExperiment expands cluster labels to cells" { + let (reference, _) = single_r_adv_test_example() + let input = single_r_adv_test_sce() + input.col_data["cluster"] = ["a", "b", "c", "d", "a"] + let output = @src.single_r_advanced_sce( + input, + reference, + cluster_column="cluster", + output_prefix="singler215", + ) catch { + _ => abort("cluster SCE annotation should work") + } + assert_eq(output.result.n_cells(), 4) + assert_eq(output.experiment.col_data["singler215.labels"].length(), 5) + assert_eq( + output.experiment.col_data["singler215.labels"][0], + output.experiment.col_data["singler215.labels"][4], + ) + assert_eq(output.experiment.metadata["singler215.mode"], "cluster") +} + +///| +test "SingleR advanced SingleCellExperiment supports custom assay" { + let (reference, _) = single_r_adv_test_example() + let output = @src.single_r_advanced_sce( + single_r_adv_test_sce(), + reference, + assay_name="counts", + output_prefix="custom", + ) catch { + _ => abort("custom assay SCE annotation should work") + } + assert_true(output.experiment.col_data.contains("custom.labels")) + assert_eq(output.experiment.metadata["custom.assay"], "counts") +} + +///| +test "SingleR advanced SingleCellExperiment rejects missing inputs" { + let (reference, _) = single_r_adv_test_example() + let assay = try { + ignore( + @src.single_r_advanced_sce( + single_r_adv_test_sce(), + reference, + assay_name="missing", + ), + ) + false + } catch { + _ => true + } + let cluster = try { + ignore( + @src.single_r_advanced_sce( + single_r_adv_test_sce(), + reference, + cluster_column="missing", + ), + ) + false + } catch { + _ => true + } + assert_true(assay) + assert_true(cluster) +} + +///| +test "SingleR advanced SingleCellExperiment validates prefix" { + let (reference, _) = single_r_adv_test_example() + let raised = try { + ignore( + @src.single_r_advanced_sce( + single_r_adv_test_sce(), + reference, + output_prefix=" ", + ), + ) + false + } catch { + _ => true + } + assert_true(raised) +} diff --git a/test/moonbit/slingshot_advanced_test.mbt b/test/moonbit/slingshot_advanced_test.mbt new file mode 100644 index 00000000..f9b13316 --- /dev/null +++ b/test/moonbit/slingshot_advanced_test.mbt @@ -0,0 +1,865 @@ +///| +fn sling_adv_test_coordinates() -> Array[Array[Double]] { + [ + [-0.1, 0.0], + [0.0, 0.1], + [0.1, -0.1], + [0.9, 0.0], + [1.0, 0.1], + [1.1, -0.1], + [1.9, 0.0], + [2.0, 0.1], + [2.1, -0.1], + [2.9, 0.9], + [3.0, 1.0], + [3.1, 1.1], + [2.9, -0.9], + [3.0, -1.0], + [3.1, -1.1], + ] +} + +///| +fn sling_adv_test_labels() -> Array[String] { + ["A", "A", "A", "B", "B", "B", "C", "C", "C", "D", "D", "D", "E", "E", "E"] +} + +///| +fn sling_adv_test_config() -> @src.SlingshotAdvancedConfig raise @src.SlingshotAdvancedError { + @src.SlingshotAdvancedConfig::create( + start_clusters=["A"], + end_clusters=["D", "E"], + distance=@src.slingshot_center_euclidean(), + extension=@src.slingshot_extend_none(), + max_iterations=8, + tolerance=1.0e-4, + smoother_span=0.4, + curve_points=30, + ) +} + +///| +fn sling_adv_test_result() -> @src.SlingshotAdvancedResult raise @src.SlingshotAdvancedError { + @src.slingshot_advanced( + sling_adv_test_coordinates(), + sling_adv_test_labels(), + sling_adv_test_config(), + ) +} + +///| +fn sling_adv_close(left : Double, right : Double, tolerance : Double) -> Bool { + (left - right).abs() <= tolerance +} + +///| +test "slingshot advanced distance accessors" { + assert_true( + @src.slingshot_center_euclidean() != @src.slingshot_scaled_diagonal(), + ) + assert_true(@src.slingshot_scaled_diagonal() != @src.slingshot_scaled_full()) + assert_true(@src.slingshot_scaled_full() != @src.slingshot_center_euclidean()) +} + +///| +test "slingshot advanced extension accessors" { + assert_true(@src.slingshot_extend_none() != @src.slingshot_extend_line()) + assert_true(@src.slingshot_extend_line() != @src.slingshot_extend_pc1()) + assert_true(@src.slingshot_extend_pc1() != @src.slingshot_extend_none()) +} + +///| +test "slingshot advanced config defaults" { + let config = @src.SlingshotAdvancedConfig::create() + assert_eq(config.distance, @src.slingshot_scaled_full()) + assert_eq(config.extension, @src.slingshot_extend_line()) + assert_eq(config.max_iterations, 15) + assert_eq(config.curve_points, 100) + assert_true(config.reweight) + assert_true(config.reassign) +} + +///| +test "slingshot advanced config explicit values" { + let config = @src.SlingshotAdvancedConfig::create( + start_clusters=["root"], + end_clusters=["leaf"], + use_median=true, + omega=2.0, + omega_scale=2.5, + shrink=0.25, + reweight=false, + reassign=false, + max_iterations=3, + tolerance=0.01, + smoother_span=0.5, + curve_points=12, + covariance_ridge=0.001, + ) + assert_eq(config.start_clusters, ["root"]) + assert_eq(config.end_clusters, ["leaf"]) + assert_true(config.use_median) + assert_eq(config.omega, 2.0) + assert_eq(config.shrink, 0.25) + assert_false(config.reweight) +} + +///| +test "slingshot advanced rejects invalid omega" { + let mut failures = 0 + ignore(@src.SlingshotAdvancedConfig::create(omega=-2.0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 1) +} + +///| +test "slingshot advanced rejects invalid omega scale" { + let mut failures = 0 + ignore(@src.SlingshotAdvancedConfig::create(omega_scale=0.0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 1) +} + +///| +test "slingshot advanced rejects invalid shrink" { + let mut failures = 0 + ignore(@src.SlingshotAdvancedConfig::create(shrink=1.1)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 1) +} + +///| +test "slingshot advanced rejects invalid iterations" { + let mut failures = 0 + ignore(@src.SlingshotAdvancedConfig::create(max_iterations=0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 1) +} + +///| +test "slingshot advanced rejects invalid tolerance" { + let mut failures = 0 + ignore(@src.SlingshotAdvancedConfig::create(tolerance=0.0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 1) +} + +///| +test "slingshot advanced rejects invalid smoother span" { + let mut failures = 0 + ignore(@src.SlingshotAdvancedConfig::create(smoother_span=1.1)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 1) +} + +///| +test "slingshot advanced rejects invalid curve points" { + let mut failures = 0 + ignore(@src.SlingshotAdvancedConfig::create(curve_points=1)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 1) +} + +///| +test "slingshot advanced rejects invalid covariance ridge" { + let mut failures = 0 + ignore(@src.SlingshotAdvancedConfig::create(covariance_ridge=0.0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 1) +} + +///| +test "slingshot advanced rejects empty constraint names" { + let mut failures = 0 + ignore(@src.SlingshotAdvancedConfig::create(start_clusters=[""])) catch { + _ => failures = failures + 1 + } + ignore(@src.SlingshotAdvancedConfig::create(end_clusters=[""])) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "slingshot advanced validates coordinate shape" { + let mut failures = 0 + ignore(@src.slingshot_infer_lineages([], [], sling_adv_test_config())) catch { + _ => failures = failures + 1 + } + ignore( + @src.slingshot_infer_lineages( + [[0.0], [1.0, 2.0]], + ["A", "B"], + sling_adv_test_config(), + ), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "slingshot advanced validates label count" { + let mut failures = 0 + ignore( + @src.slingshot_infer_lineages( + [[0.0], [1.0]], + ["A"], + sling_adv_test_config(), + ), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 1) +} + +///| +test "slingshot advanced validates finite coordinates" { + let mut failures = 0 + ignore( + @src.slingshot_infer_lineages( + [[0.0], [0.0 / 0.0]], + ["A", "B"], + sling_adv_test_config(), + ), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 1) +} + +///| +test "slingshot advanced validates start and end clusters" { + let mut failures = 0 + let start_config = @src.SlingshotAdvancedConfig::create(start_clusters=[ + "missing", + ]) + ignore( + @src.slingshot_infer_lineages([[0.0], [1.0]], ["A", "B"], start_config), + ) catch { + _ => failures = failures + 1 + } + let end_config = @src.SlingshotAdvancedConfig::create(end_clusters=["missing"]) + ignore(@src.slingshot_infer_lineages([[0.0], [1.0]], ["A", "B"], end_config)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "slingshot advanced hard labels preserve first occurrence order" { + let model = @src.slingshot_infer_lineages( + sling_adv_test_coordinates(), + sling_adv_test_labels(), + sling_adv_test_config(), + ) + assert_eq(model.cluster_names, ["A", "B", "C", "D", "E"]) +} + +///| +test "slingshot advanced cluster centers are correct" { + let model = @src.slingshot_infer_lineages( + sling_adv_test_coordinates(), + sling_adv_test_labels(), + sling_adv_test_config(), + ) + assert_true(sling_adv_close(model.clusters[0].center[0], 0.0, 1.0e-12)) + assert_true(sling_adv_close(model.clusters[2].center[0], 2.0, 1.0e-12)) + assert_true(sling_adv_close(model.clusters[3].center[1], 1.0, 1.0e-12)) + assert_eq(model.clusters[0].size, 3.0) +} + +///| +test "slingshot advanced covariance is finite and regularized" { + let model = @src.slingshot_infer_lineages( + sling_adv_test_coordinates(), + sling_adv_test_labels(), + sling_adv_test_config(), + ) + assert_true(model.clusters[0].covariance[0][0] > 0.0) + assert_true(model.clusters[0].covariance[1][1] > 0.0) + assert_true( + sling_adv_close( + model.clusters[0].covariance[0][1], + model.clusters[0].covariance[1][0], + 1.0e-12, + ), + ) +} + +///| +test "slingshot advanced euclidean cluster distances" { + let model = @src.slingshot_infer_lineages( + sling_adv_test_coordinates(), + sling_adv_test_labels(), + sling_adv_test_config(), + ) + assert_true(sling_adv_close(model.distance_matrix[0][1], 1.0, 1.0e-12)) + assert_true(sling_adv_close(model.distance_matrix[2][3], 2.0.sqrt(), 1.0e-12)) + assert_eq(model.distance_matrix[1][0], model.distance_matrix[0][1]) +} + +///| +test "slingshot advanced scaled diagonal distance" { + let config = @src.SlingshotAdvancedConfig::create( + start_clusters=["A"], + distance=@src.slingshot_scaled_diagonal(), + ) + let model = @src.slingshot_infer_lineages( + sling_adv_test_coordinates(), + sling_adv_test_labels(), + config, + ) + assert_true(model.distance_matrix[0][1] > 1.0) +} + +///| +test "slingshot advanced scaled full distance" { + let config = @src.SlingshotAdvancedConfig::create( + start_clusters=["A"], + distance=@src.slingshot_scaled_full(), + ) + let model = @src.slingshot_infer_lineages( + sling_adv_test_coordinates(), + sling_adv_test_labels(), + config, + ) + assert_true(model.distance_matrix[0][1] > 0.0) + assert_eq(model.distance_matrix[0][0], 0.0) +} + +///| +test "slingshot advanced constrained mst has expected size" { + let model = @src.slingshot_infer_lineages( + sling_adv_test_coordinates(), + sling_adv_test_labels(), + sling_adv_test_config(), + ) + assert_eq(model.edges.length(), 4) + assert_eq(model.roots.length(), 1) +} + +///| +test "slingshot advanced forced endpoints are leaves" { + let model = @src.slingshot_infer_lineages( + sling_adv_test_coordinates(), + sling_adv_test_labels(), + sling_adv_test_config(), + ) + let degrees = Array::make(model.cluster_names.length(), 0) + for edge in model.edges { + degrees[edge.from] = degrees[edge.from] + 1 + degrees[edge.to] = degrees[edge.to] + 1 + } + assert_eq(degrees[3], 1) + assert_eq(degrees[4], 1) +} + +///| +test "slingshot advanced root honors start cluster" { + let model = @src.slingshot_infer_lineages( + sling_adv_test_coordinates(), + sling_adv_test_labels(), + sling_adv_test_config(), + ) + assert_eq(model.roots, [0]) +} + +///| +test "slingshot advanced enumerates root to leaf lineages" { + let model = @src.slingshot_infer_lineages( + sling_adv_test_coordinates(), + sling_adv_test_labels(), + sling_adv_test_config(), + ) + assert_eq(model.lineages.length(), 2) + assert_eq(model.lineages[0][0], 0) + assert_eq(model.lineages[1][0], 0) + let ends = [model.lineages[0][3], model.lineages[1][3]] + ends.sort() + assert_eq(ends, [3, 4]) +} + +///| +test "slingshot advanced initial weights share common trunk" { + let model = @src.slingshot_infer_lineages( + sling_adv_test_coordinates(), + sling_adv_test_labels(), + sling_adv_test_config(), + ) + assert_eq(model.initial_weights[0], [1.0, 1.0]) + assert_eq(model.initial_weights[9], [1.0, 0.0]) + assert_eq(model.initial_weights[12], [0.0, 1.0]) +} + +///| +test "slingshot advanced treats minus one as unclustered" { + let coordinates = [[0.0], [1.0], [2.0]] + let labels = ["A", "-1", "B"] + let config = @src.SlingshotAdvancedConfig::create( + start_clusters=["A"], + distance=@src.slingshot_center_euclidean(), + curve_points=10, + max_iterations=2, + ) + let model = @src.slingshot_infer_lineages(coordinates, labels, config) + assert_eq(model.cluster_names, ["A", "B"]) + assert_eq(model.cluster_weights[1], [0.0, 0.0]) + assert_eq(model.initial_weights[1], [0.0]) +} + +///| +test "slingshot advanced weighted memberships normalize rows" { + let model = @src.slingshot_infer_weighted_lineages( + [[0.0], [1.0], [2.0]], + [[2.0, 0.0], [1.0, 1.0], [0.0, 3.0]], + ["A", "B"], + @src.SlingshotAdvancedConfig::create( + start_clusters=["A"], + distance=@src.slingshot_center_euclidean(), + ), + ) + assert_eq(model.cluster_weights[0], [1.0, 0.0]) + assert_eq(model.cluster_weights[1], [0.5, 0.5]) + assert_eq(model.cluster_weights[2], [0.0, 1.0]) +} + +///| +test "slingshot advanced rejects invalid weighted memberships" { + let mut failures = 0 + let config = @src.SlingshotAdvancedConfig::create() + ignore( + @src.slingshot_infer_weighted_lineages( + [[0.0], [1.0]], + [[1.0], [-1.0]], + ["A"], + config, + ), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.slingshot_infer_weighted_lineages( + [[0.0], [1.0]], + [[1.0, 0.0], [1.0]], + ["A", "B"], + config, + ), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "slingshot advanced rejects empty weighted clusters" { + let mut failures = 0 + ignore( + @src.slingshot_infer_weighted_lineages( + [[0.0], [1.0]], + [[1.0, 0.0], [1.0, 0.0]], + ["A", "B"], + @src.SlingshotAdvancedConfig::create(), + ), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 1) +} + +///| +test "slingshot advanced fixed omega creates forest" { + let config = @src.SlingshotAdvancedConfig::create( + start_clusters=["A"], + distance=@src.slingshot_center_euclidean(), + omega=0.5, + ) + let model = @src.slingshot_infer_lineages( + sling_adv_test_coordinates(), + sling_adv_test_labels(), + config, + ) + assert_eq(model.edges.length(), 0) + assert_eq(model.roots.length(), 5) + assert_eq(model.lineages.length(), 5) +} + +///| +test "slingshot advanced automatic omega uses mst median" { + let config = @src.SlingshotAdvancedConfig::create( + start_clusters=["A"], + distance=@src.slingshot_center_euclidean(), + automatic_omega=true, + omega_scale=1.0, + ) + let model = @src.slingshot_infer_lineages( + sling_adv_test_coordinates(), + sling_adv_test_labels(), + config, + ) + assert_true(model.omega_threshold > 0.0) + assert_true(model.omega_threshold < 2.0) +} + +///| +test "slingshot advanced single cluster lineage" { + let config = @src.SlingshotAdvancedConfig::create( + distance=@src.slingshot_center_euclidean(), + curve_points=12, + max_iterations=2, + ) + let result = @src.slingshot_advanced( + [[0.0, 0.0], [1.0, 0.1], [2.0, -0.1]], + ["A", "A", "A"], + config, + ) + assert_eq(result.curves.length(), 1) + assert_eq(result.curves[0].points.length(), 12) + assert_eq(result.lineage_model.lineages[0], [0]) +} + +///| +test "slingshot advanced fits one curve per lineage" { + let result = sling_adv_test_result() + assert_eq(result.curves.length(), 2) + assert_eq(result.curves[0].points.length(), 30) + assert_eq(result.curves[1].points.length(), 30) +} + +///| +test "slingshot advanced pseudotime matrix dimensions" { + let result = sling_adv_test_result() + assert_eq(result.pseudotime.length(), 15) + assert_eq(result.pseudotime[0].length(), 2) + assert_eq(result.weights.length(), 15) + assert_eq(result.weights[0].length(), 2) +} + +///| +test "slingshot advanced pseudotime begins near root" { + let result = sling_adv_test_result() + let root_time = result.average_pseudotime[0] + assert_true(root_time < result.average_pseudotime[7]) + assert_true(root_time < result.average_pseudotime[10]) + assert_true(root_time < result.average_pseudotime[13]) +} + +///| +test "slingshot advanced optional pseudotime follows weights" { + let result = sling_adv_test_result() + for cell in 0.. assert_true(result.weights[cell][lineage] > 0.0) + None => assert_eq(result.weights[cell][lineage], 0.0) + } + } + } +} + +///| +test "slingshot advanced reports bounded iterations" { + let result = sling_adv_test_result() + assert_true(result.iterations >= 1) + assert_true(result.iterations <= result.config.max_iterations) + assert_true(result.total_distance >= 0.0) +} + +///| +test "slingshot advanced no reweight preserves memberships" { + let config = @src.SlingshotAdvancedConfig::create( + start_clusters=["A"], + end_clusters=["D", "E"], + distance=@src.slingshot_center_euclidean(), + extension=@src.slingshot_extend_none(), + reweight=false, + reassign=false, + max_iterations=2, + curve_points=20, + ) + let result = @src.slingshot_advanced( + sling_adv_test_coordinates(), + sling_adv_test_labels(), + config, + ) + assert_eq(result.weights, result.lineage_model.initial_weights) +} + +///| +test "slingshot advanced shrink aligns shared origin" { + let result = sling_adv_test_result() + let first = result.curves[0].points[0] + let second = result.curves[1].points[0] + assert_true(sling_adv_close(first[0], second[0], 1.0e-8)) + assert_true(sling_adv_close(first[1], second[1], 1.0e-8)) +} + +///| +test "slingshot advanced supports all extension modes" { + let lengths : Array[Double] = [] + for + extension in [ + @src.slingshot_extend_none(), + @src.slingshot_extend_line(), + @src.slingshot_extend_pc1(), + ] { + let config = @src.SlingshotAdvancedConfig::create( + start_clusters=["A"], + end_clusters=["D", "E"], + distance=@src.slingshot_center_euclidean(), + extension~, + reweight=false, + reassign=false, + max_iterations=1, + curve_points=15, + ) + let result = @src.slingshot_advanced( + sling_adv_test_coordinates(), + sling_adv_test_labels(), + config, + ) + lengths.push(result.curves[0].length) + } + assert_eq(lengths.length(), 3) + assert_true(lengths[0] > 0.0) + assert_true(lengths[1] > 0.0) + assert_true(lengths[2] > 0.0) +} + +///| +test "slingshot advanced probability weights sum to one" { + let probabilities = @src.slingshot_curve_weight_probabilities( + sling_adv_test_result(), + ) + for row in probabilities { + let mut total = 0.0 + for value in row { + total = total + value + } + assert_true(sling_adv_close(total, 1.0, 1.0e-10)) + } +} + +///| +test "slingshot advanced branch ids use one based labels" { + let result = sling_adv_test_result() + let ids = @src.slingshot_branch_ids(result) + assert_true(ids[0].contains("1")) + assert_true(ids[0].contains("2")) + assert_true(ids[10].contains("1")) + assert_true(ids[13].contains("2")) +} + +///| +test "slingshot advanced branch ids validate threshold" { + let mut failures = 0 + ignore(@src.slingshot_branch_ids(sling_adv_test_result(), threshold=1.1)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 1) +} + +///| +test "slingshot advanced prediction dimensions" { + let prediction = @src.slingshot_predict(sling_adv_test_result(), [ + [0.0, 0.0], + [3.0, 1.0], + [3.0, -1.0], + ]) + assert_eq(prediction.pseudotime.length(), 3) + assert_eq(prediction.weights[0].length(), 2) + assert_eq(prediction.distances[0].length(), 2) + assert_eq(prediction.average_pseudotime.length(), 3) +} + +///| +test "slingshot advanced prediction maps branch endpoints" { + let prediction = @src.slingshot_predict(sling_adv_test_result(), [ + [3.0, 1.0], + [3.0, -1.0], + ]) + assert_true(prediction.branch_ids[0].contains("1")) + assert_true(prediction.branch_ids[1].contains("2")) +} + +///| +test "slingshot advanced prediction assigns distant cells" { + let prediction = @src.slingshot_predict(sling_adv_test_result(), [ + [100.0, 100.0], + ]) + let mut total = 0.0 + for weight in prediction.weights[0] { + total = total + weight + } + assert_true(total > 0.0) + assert_true(prediction.branch_ids[0].length() > 0) +} + +///| +test "slingshot advanced prediction validates dimensions" { + let mut failures = 0 + ignore(@src.slingshot_predict(sling_adv_test_result(), [[0.0, 1.0, 2.0]])) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 1) +} + +///| +test "slingshot advanced weighted full pipeline" { + let coordinates = [[0.0], [0.5], [1.0], [1.5], [2.0]] + let weights = [[1.0, 0.0], [0.75, 0.25], [0.5, 0.5], [0.25, 0.75], [0.0, 1.0]] + let config = @src.SlingshotAdvancedConfig::create( + start_clusters=["A"], + distance=@src.slingshot_center_euclidean(), + extension=@src.slingshot_extend_none(), + curve_points=15, + max_iterations=3, + ) + let result = @src.slingshot_advanced_weighted( + coordinates, + weights, + ["A", "B"], + config, + ) + assert_eq(result.curves.length(), 1) + assert_true(result.average_pseudotime[0] < result.average_pseudotime[4]) +} + +///| +test "slingshot advanced summary reports model dimensions" { + let summary = @src.slingshot_advanced_summary(sling_adv_test_result()) + assert_true(summary.contains("Slingshot 2.21.0")) + assert_true(summary.contains("cells: 15")) + assert_true(summary.contains("clusters: 5")) + assert_true(summary.contains("lineages: 2")) +} + +///| +test "slingshot advanced sce writes trajectory outputs" { + let experiment = @src.SingleCellExperiment::new( + [ + [ + 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, + 15.0, + ], + ], + ["gene"], + [ + "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10", "c11", "c12", + "c13", "c14", "c15", + ], + ) + experiment.reduced_dims["PCA"] = sling_adv_test_coordinates() + experiment.col_data["cluster"] = sling_adv_test_labels() + let output = @src.slingshot_advanced_sce(experiment, sling_adv_test_config()) + assert_eq(output.result.curves.length(), 2) + assert_eq(output.experiment.col_data["slingshot.branch"].length(), 15) + assert_eq( + output.experiment.reduced_dims["slingshot.pseudotime"][0].length(), + 2, + ) + assert_eq(output.experiment.reduced_dims["slingshot.weights"][0].length(), 2) +} + +///| +test "slingshot advanced sce preserves input immutability" { + let experiment = @src.SingleCellExperiment::new( + [ + [ + 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, + 15.0, + ], + ], + ["gene"], + [ + "c1", "c2", "c3", "c4", "c5", "c6", "c7", "c8", "c9", "c10", "c11", "c12", + "c13", "c14", "c15", + ], + ) + experiment.reduced_dims["PCA"] = sling_adv_test_coordinates() + experiment.col_data["cluster"] = sling_adv_test_labels() + experiment.metadata["source"] = "original" + let output = @src.slingshot_advanced_sce(experiment, sling_adv_test_config()) + output.experiment.assays["counts"][0][0] = 99.0 + output.experiment.reduced_dims["PCA"][0][0] = 99.0 + output.experiment.col_data["cluster"][0] = "changed" + assert_eq(experiment.assays["counts"][0][0], 1.0) + assert_eq(experiment.reduced_dims["PCA"][0][0], -0.1) + assert_eq(experiment.col_data["cluster"][0], "A") + assert_eq(experiment.metadata["source"], "original") +} + +///| +test "slingshot advanced sce recursively copies alternatives" { + let experiment = @src.SingleCellExperiment::new([[1.0, 2.0]], ["gene"], [ + "c1", "c2", + ]) + experiment.reduced_dims["PCA"] = [[0.0], [1.0]] + experiment.col_data["cluster"] = ["A", "B"] + experiment.alternative_experiments["alt"] = @src.SingleCellExperiment::new( + [[3.0, 4.0]], + ["feature"], + ["c1", "c2"], + ) + let config = @src.SlingshotAdvancedConfig::create( + start_clusters=["A"], + distance=@src.slingshot_center_euclidean(), + curve_points=10, + max_iterations=2, + ) + let output = @src.slingshot_advanced_sce(experiment, config) + output.experiment.alternative_experiments["alt"].assays["counts"][0][0] = 8.0 + assert_eq( + experiment.alternative_experiments["alt"].assays["counts"][0][0], + 3.0, + ) +} + +///| +test "slingshot advanced sce supports custom output prefix" { + let experiment = @src.SingleCellExperiment::new([[1.0, 2.0]], ["gene"], [ + "c1", "c2", + ]) + experiment.reduced_dims["UMAP"] = [[0.0], [1.0]] + experiment.col_data["group"] = ["A", "B"] + let config = @src.SlingshotAdvancedConfig::create( + start_clusters=["A"], + distance=@src.slingshot_center_euclidean(), + curve_points=10, + max_iterations=2, + ) + let output = @src.slingshot_advanced_sce( + experiment, + config, + reduced_dim_name="UMAP", + cluster_column="group", + output_prefix="trajectory", + ) + assert_true(output.experiment.col_data.contains("trajectory.branch")) + assert_true(output.experiment.reduced_dims.contains("trajectory.pseudotime")) + assert_eq(output.experiment.metadata["trajectory.reduced_dim"], "UMAP") +} + +///| +test "slingshot advanced sce validates names and inputs" { + let experiment = @src.SingleCellExperiment::new([[1.0, 2.0]], ["gene"], [ + "c1", "c2", + ]) + let config = @src.SlingshotAdvancedConfig::create() + let mut failures = 0 + ignore(@src.slingshot_advanced_sce(experiment, config, reduced_dim_name="")) catch { + _ => failures = failures + 1 + } + ignore(@src.slingshot_advanced_sce(experiment, config)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} diff --git a/test/moonbit/spatialdecon_test.mbt b/test/moonbit/spatialdecon_test.mbt new file mode 100644 index 00000000..4d5d3df2 --- /dev/null +++ b/test/moonbit/spatialdecon_test.mbt @@ -0,0 +1,1492 @@ +// Black-box tests for the Bioconductor SpatialDecon-inspired workflow. + +///| +fn sd_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "SpatialDecon value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn sd_test_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn sd_test_config( + rescale_profile? : Bool = false, + refit_outliers? : Bool = false, + residual_threshold? : Double = 3.0, +) -> @src.SpatialDeconConfig { + @src.SpatialDeconConfig::create( + residual_threshold~, + rescale_profile~, + refit_outliers~, + tolerance=1.0e-9, + ) catch { + _ => abort("SpatialDecon test configuration should be valid") + } +} + +///| +fn sd_test_exact_profile() -> @src.SpatialDeconProfile { + @src.SpatialDeconProfile::create(["g1", "g2", "g3"], ["Type_A"], [ + [1.0], + [2.0], + [3.0], + ]) catch { + _ => abort("SpatialDecon exact profile should be valid") + } +} + +///| +fn sd_test_exact_data() -> @src.SpatialDeconData { + @src.SpatialDeconData::create( + ["g1", "g2", "g3"], + ["spot_1", "spot_2"], + [[7.0, 9.0], [9.0, 13.0], [11.0, 17.0]], + background=[[5.0, 5.0], [5.0, 5.0], [5.0, 5.0]], + ) catch { + _ => abort("SpatialDecon exact data should be valid") + } +} + +///| +fn sd_test_exact_result( + nuclei_counts? : Array[Double] = [], +) -> @src.SpatialDeconResult { + @src.spatial_decon( + sd_test_exact_data(), + sd_test_exact_profile(), + nuclei_counts~, + config=sd_test_config(), + ) catch { + _ => abort("SpatialDecon exact fit should succeed") + } +} + +///| +fn sd_test_example_result() -> @src.SpatialDeconResult { + let (data, profile, nuclei_counts) = @src.spatial_decon_example_data() catch { + _ => abort("SpatialDecon example data should be valid") + } + @src.spatial_decon( + data, + profile, + nuclei_counts~, + config=sd_test_config(refit_outliers=true), + ) catch { + _ => abort("SpatialDecon example fit should succeed") + } +} + +///| +fn sd_test_experiment() -> ( + @src.SpatialExperiment, + @src.SpatialDeconProfile, + Array[Double], +) { + let (data, profile, nuclei_counts) = @src.spatial_decon_example_data() catch { + _ => abort("SpatialDecon example data should be valid") + } + let experiment = @src.SpatialExperiment::new() + ignore(@src.se_add_assay(experiment, "counts", data.values)) + ignore(@src.se_add_assay(experiment, "background", data.background)) + ignore(@src.se_add_assay(experiment, "weights", data.weights)) + for gene in data.gene_names { + ignore( + @src.se_add_row( + experiment, + Map([("gene_id", gene), ("feature_type", "target")]), + ), + ) + } + for spot in 0.. abort("SpatialDecon custom configuration should be valid") + } + assert_eq(config.residual_threshold, 2.0) + assert_eq(config.lower_threshold, 0.25) + assert_eq(config.rescale_profile, false) + assert_eq(config.profile_target, 3.0) + assert_eq(config.refit_outliers, false) + assert_eq(config.max_iterations, 200) +} + +///| +test "SpatialDecon: configuration rejects invalid thresholds" { + let residual_failed = try { + ignore(@src.SpatialDeconConfig::create(residual_threshold=0.0)) + false + } catch { + SpatialDeconError(_) => true + } + let lower_failed = try { + ignore(@src.SpatialDeconConfig::create(lower_threshold=0.0)) + false + } catch { + SpatialDeconError(_) => true + } + let floor_failed = try { + ignore(@src.SpatialDeconConfig::create(signal_floor=0.0)) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(residual_failed && lower_failed && floor_failed) +} + +///| +test "SpatialDecon: configuration rejects invalid profile scaling" { + let quantile_failed = try { + ignore(@src.SpatialDeconConfig::create(profile_quantile=1.1)) + false + } catch { + SpatialDeconError(_) => true + } + let target_failed = try { + ignore(@src.SpatialDeconConfig::create(profile_target=0.0)) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(quantile_failed && target_failed) +} + +///| +test "SpatialDecon: configuration rejects invalid solver controls" { + let iterations_failed = try { + ignore(@src.SpatialDeconConfig::create(max_iterations=0)) + false + } catch { + SpatialDeconError(_) => true + } + let search_failed = try { + ignore(@src.SpatialDeconConfig::create(line_search_steps=0)) + false + } catch { + SpatialDeconError(_) => true + } + let tolerance_failed = try { + ignore(@src.SpatialDeconConfig::create(tolerance=1.0)) + false + } catch { + SpatialDeconError(_) => true + } + let ridge_failed = try { + ignore(@src.SpatialDeconConfig::create(ridge=0.0)) + false + } catch { + SpatialDeconError(_) => true + } + assert_true( + iterations_failed && search_failed && tolerance_failed && ridge_failed, + ) +} + +///| +test "SpatialDecon: profile constructor exposes dimensions" { + let profile = sd_test_exact_profile() + assert_eq(profile.n_genes(), 3) + assert_eq(profile.n_cell_types(), 1) + assert_eq(profile.gene_names, ["g1", "g2", "g3"]) + assert_eq(profile.cell_types, ["Type_A"]) +} + +///| +test "SpatialDecon: profile constructor defensively copies inputs" { + let genes = ["g1", "g2"] + let cell_types = ["A"] + let values = [[1.0], [2.0]] + let profile = @src.SpatialDeconProfile::create(genes, cell_types, values) catch { + _ => abort("SpatialDecon profile should be valid") + } + genes[0] = "changed" + cell_types[0] = "changed" + values[0][0] = 99.0 + assert_eq(profile.gene_names, ["g1", "g2"]) + assert_eq(profile.cell_types, ["A"]) + assert_eq(profile.values, [[1.0], [2.0]]) +} + +///| +test "SpatialDecon: profile rejects duplicate and empty names" { + let duplicate_failed = try { + ignore( + @src.SpatialDeconProfile::create(["g1", "g1"], ["A"], [[1.0], [2.0]]), + ) + false + } catch { + SpatialDeconError(_) => true + } + let empty_failed = try { + ignore(@src.SpatialDeconProfile::create(["g1"], [""], [[1.0]])) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(duplicate_failed && empty_failed) +} + +///| +test "SpatialDecon: profile rejects malformed and negative matrices" { + let shape_failed = try { + ignore( + @src.SpatialDeconProfile::create(["g1", "g2"], ["A", "B"], [ + [1.0, 2.0], + [3.0], + ]), + ) + false + } catch { + SpatialDeconError(_) => true + } + let negative_failed = try { + ignore(@src.SpatialDeconProfile::create(["g1"], ["A"], [[-1.0]])) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(shape_failed && negative_failed) +} + +///| +test "SpatialDecon: profile rejects non-finite and empty cell-type signals" { + let finite_failed = try { + ignore( + @src.SpatialDeconProfile::create(["g1"], ["A"], [[@double.not_a_number]]), + ) + false + } catch { + SpatialDeconError(_) => true + } + let signal_failed = try { + ignore( + @src.SpatialDeconProfile::create(["g1", "g2"], ["A", "B"], [ + [1.0, 0.0], + [2.0, 0.0], + ]), + ) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(finite_failed && signal_failed) +} + +///| +test "SpatialDecon: data constructor supplies background and weights" { + let data = @src.SpatialDeconData::create(["g1", "g2"], ["s1"], [[2.0], [3.0]]) catch { + _ => abort("SpatialDecon data should be valid") + } + assert_eq(data.n_genes(), 2) + assert_eq(data.n_spots(), 1) + assert_eq(data.background, [[0.0], [0.0]]) + assert_eq(data.weights, [[1.0], [1.0]]) +} + +///| +test "SpatialDecon: data constructor defensively copies all matrices" { + let genes = ["g1", "g2"] + let spots = ["s1"] + let values = [[2.0], [3.0]] + let background = [[0.5], [0.6]] + let weights = [[1.0], [2.0]] + let data = @src.SpatialDeconData::create( + genes, + spots, + values, + background~, + weights~, + ) catch { + _ => abort("SpatialDecon data should be valid") + } + genes[0] = "changed" + spots[0] = "changed" + values[0][0] = 99.0 + background[0][0] = 99.0 + weights[0][0] = 99.0 + assert_eq(data.gene_names, ["g1", "g2"]) + assert_eq(data.spot_ids, ["s1"]) + assert_eq(data.values[0][0], 2.0) + assert_eq(data.background[0][0], 0.5) + assert_eq(data.weights[0][0], 1.0) +} + +///| +test "SpatialDecon: scalar background fills every observation" { + let data = @src.SpatialDeconData::with_scalar_background( + ["g1", "g2"], + ["s1", "s2"], + [[2.0, 3.0], [4.0, 5.0]], + 0.75, + ) catch { + _ => abort("SpatialDecon scalar background should be valid") + } + assert_eq(data.background, [[0.75, 0.75], [0.75, 0.75]]) +} + +///| +test "SpatialDecon: data rejects duplicate spots and invalid shapes" { + let duplicate_failed = try { + ignore(@src.SpatialDeconData::create(["g1"], ["s1", "s1"], [[1.0, 2.0]])) + false + } catch { + SpatialDeconError(_) => true + } + let shape_failed = try { + ignore( + @src.SpatialDeconData::create(["g1", "g2"], ["s1"], [[1.0], [2.0, 3.0]]), + ) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(duplicate_failed && shape_failed) +} + +///| +test "SpatialDecon: data rejects invalid expression and background" { + let expression_failed = try { + ignore(@src.SpatialDeconData::create(["g1"], ["s1"], [[-1.0]])) + false + } catch { + SpatialDeconError(_) => true + } + let background_failed = try { + ignore( + @src.SpatialDeconData::create(["g1"], ["s1"], [[1.0]], background=[ + [@double.not_a_number], + ]), + ) + false + } catch { + SpatialDeconError(_) => true + } + let scalar_failed = try { + ignore( + @src.SpatialDeconData::with_scalar_background( + ["g1"], + ["s1"], + [[1.0]], + -1.0, + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(expression_failed && background_failed && scalar_failed) +} + +///| +test "SpatialDecon: data requires strictly positive finite weights" { + let zero_failed = try { + ignore( + @src.SpatialDeconData::create(["g1"], ["s1"], [[1.0]], weights=[[0.0]]), + ) + false + } catch { + SpatialDeconError(_) => true + } + let finite_failed = try { + ignore( + @src.SpatialDeconData::create(["g1"], ["s1"], [[1.0]], weights=[ + [@double.not_a_number], + ]), + ) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(zero_failed && finite_failed) +} + +///| +test "SpatialDecon: exact single-cell-type mixture is recovered" { + let result = sd_test_exact_result() + sd_test_close(result.beta[0][0], 2.0, 1.0e-6) + sd_test_close(result.beta[0][1], 4.0, 1.0e-6) + assert_eq(result.converged, [true, true]) + assert_true(result.objectives[0] < 1.0e-12) + assert_true(result.objectives[1] < 1.0e-12) +} + +///| +test "SpatialDecon: background-aware fit differs from uncorrected fit" { + let corrected = sd_test_exact_result() + let uncorrected_data = @src.SpatialDeconData::create( + ["g1", "g2", "g3"], + ["spot_1", "spot_2"], + [[7.0, 9.0], [9.0, 13.0], [11.0, 17.0]], + ) catch { + _ => abort("SpatialDecon uncorrected data should be valid") + } + let uncorrected = @src.spatial_decon( + uncorrected_data, + sd_test_exact_profile(), + config=sd_test_config(), + ) catch { + _ => abort("SpatialDecon uncorrected fit should succeed") + } + sd_test_close(corrected.beta[0][0], 2.0, 1.0e-6) + assert_true(uncorrected.beta[0][0] > 3.0) +} + +///| +test "SpatialDecon: profile rescaling inversely rescales abundance" { + let profile = @src.SpatialDeconProfile::create(["g1", "g2"], ["A"], [ + [2.0], + [4.0], + ]) catch { + _ => abort("SpatialDecon scaling profile should be valid") + } + let data = @src.SpatialDeconData::create(["g1", "g2"], ["s1"], [[6.0], [12.0]]) catch { + _ => abort("SpatialDecon scaling data should be valid") + } + let plain = @src.spatial_decon(data, profile, config=sd_test_config()) catch { + _ => abort("SpatialDecon unscaled fit should succeed") + } + let scaled_config = @src.SpatialDeconConfig::create( + rescale_profile=true, + profile_quantile=1.0, + profile_target=2.0, + refit_outliers=false, + tolerance=1.0e-9, + ) catch { + _ => abort("SpatialDecon scaling configuration should be valid") + } + let scaled = @src.spatial_decon(data, profile, config=scaled_config) catch { + _ => abort("SpatialDecon scaled fit should succeed") + } + sd_test_close(plain.beta[0][0], 3.0, 1.0e-6) + sd_test_close(scaled.beta[0][0], 6.0, 1.0e-6) +} + +///| +test "SpatialDecon: zero profile quantile is rejected during rescaling" { + let profile = @src.SpatialDeconProfile::create(["g1", "g2", "g3"], ["A"], [ + [0.0], + [0.0], + [1.0], + ]) catch { + _ => abort("SpatialDecon sparse profile should be valid") + } + let data = @src.SpatialDeconData::create(["g1", "g2", "g3"], ["s1"], [ + [1.0], + [1.0], + [1.0], + ]) catch { + _ => abort("SpatialDecon sparse data should be valid") + } + let config = @src.SpatialDeconConfig::create(profile_quantile=0.5) catch { + _ => abort("SpatialDecon sparse configuration should be valid") + } + let failed = try { + ignore(@src.spatial_decon(data, profile, config~)) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(failed) +} + +///| +test "SpatialDecon: precision weights favor high-confidence genes" { + let profile = @src.SpatialDeconProfile::create(["g1", "g2"], ["A"], [ + [1.0], + [1.0], + ]) catch { + _ => abort("SpatialDecon weighted profile should be valid") + } + let plain_data = @src.SpatialDeconData::create(["g1", "g2"], ["s1"], [ + [2.0], + [8.0], + ]) catch { + _ => abort("SpatialDecon unweighted data should be valid") + } + let weighted_data = @src.SpatialDeconData::create( + ["g1", "g2"], + ["s1"], + [[2.0], [8.0]], + weights=[[100.0], [1.0]], + ) catch { + _ => abort("SpatialDecon weighted data should be valid") + } + let plain = @src.spatial_decon(plain_data, profile, config=sd_test_config()) catch { + _ => abort("SpatialDecon unweighted fit should succeed") + } + let weighted = @src.spatial_decon( + weighted_data, + profile, + config=sd_test_config(), + ) catch { + _ => abort("SpatialDecon weighted fit should succeed") + } + sd_test_close(plain.beta[0][0], 4.0, 1.0e-5) + assert_true(weighted.beta[0][0] < 2.1) + assert_true(weighted.beta[0][0] > 2.0) +} + +///| +test "SpatialDecon: two-stage fitting flags and removes a log outlier" { + let profile = @src.SpatialDeconProfile::create( + ["g1", "g2", "g3", "g4", "g5"], + ["A"], + [[1.0], [1.0], [1.0], [1.0], [1.0]], + ) catch { + _ => abort("SpatialDecon outlier profile should be valid") + } + let data = @src.SpatialDeconData::create( + ["g1", "g2", "g3", "g4", "g5"], + ["s1"], + [[2.0], [2.0], [2.0], [2.0], [1024.0]], + ) catch { + _ => abort("SpatialDecon outlier data should be valid") + } + let result = @src.spatial_decon( + data, + profile, + config=sd_test_config(refit_outliers=true), + ) catch { + _ => abort("SpatialDecon outlier fit should succeed") + } + sd_test_close(result.beta[0][0], 2.0, 1.0e-6) + assert_eq(result.outliers[4][0], true) + assert_eq(result.outliers[0][0], false) + assert_true(result.residuals[4][0] != result.residuals[4][0]) +} + +///| +test "SpatialDecon: disabling refit preserves every observation" { + let profile = @src.SpatialDeconProfile::create( + ["g1", "g2", "g3", "g4", "g5"], + ["A"], + [[1.0], [1.0], [1.0], [1.0], [1.0]], + ) catch { + _ => abort("SpatialDecon outlier profile should be valid") + } + let data = @src.SpatialDeconData::create( + ["g1", "g2", "g3", "g4", "g5"], + ["s1"], + [[2.0], [2.0], [2.0], [2.0], [1024.0]], + ) catch { + _ => abort("SpatialDecon outlier data should be valid") + } + let result = @src.spatial_decon(data, profile, config=sd_test_config()) catch { + _ => abort("SpatialDecon non-refit fit should succeed") + } + for row in result.outliers { + assert_eq(row[0], false) + } + assert_true(result.beta[0][0] > 2.0) +} + +///| +test "SpatialDecon: synthetic multi-cell mixtures recover known abundances" { + let result = sd_test_example_result() + let expected = [ + [4.0, 1.0, 2.0, 0.5, 3.0], + [1.0, 4.0, 2.0, 1.0, 0.5], + [0.5, 1.0, 2.0, 4.0, 3.0], + ] + for cell_type in 0..= 0.0) + assert_true(result.rmse[spot] < 0.03) + assert_true(result.correlations[spot] > 0.99) + for cell_type in 0.. 0.0) + assert_true(sd_test_finite(result.t_statistics[cell_type][spot])) + assert_true(result.p_values[cell_type][spot] >= 0.0) + assert_true(result.p_values[cell_type][spot] <= 1.0) + assert_true(result.covariances[spot][cell_type][cell_type] > 0.0) + } + } +} + +///| +test "SpatialDecon: proportions sum to one per spot" { + let result = sd_test_example_result() + for spot in 0.. maximum { + maximum = total + } + } + sd_test_close(maximum, 100.0, 1.0e-10) +} + +///| +test "SpatialDecon: nuclei counts scale cells-per-100 by spot" { + let result = sd_test_exact_result(nuclei_counts=[100.0, 80.0]) + sd_test_close(result.cells_per_100[0][0], 50.0, 1.0e-5) + sd_test_close(result.cells_per_100[0][1], 100.0, 1.0e-5) + sd_test_close(result.cell_counts[0][0], 50.0, 1.0e-5) + sd_test_close(result.cell_counts[0][1], 80.0, 1.0e-5) +} + +///| +test "SpatialDecon: omitted nuclei counts leave cell counts empty" { + let result = sd_test_exact_result() + assert_eq(result.cell_counts.length(), 0) +} + +///| +test "SpatialDecon: nuclei counts are strictly validated" { + let length_failed = try { + ignore( + @src.spatial_decon( + sd_test_exact_data(), + sd_test_exact_profile(), + nuclei_counts=[1.0], + config=sd_test_config(), + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + let value_failed = try { + ignore( + @src.spatial_decon( + sd_test_exact_data(), + sd_test_exact_profile(), + nuclei_counts=[1.0, -1.0], + config=sd_test_config(), + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(length_failed && value_failed) +} + +///| +test "SpatialDecon: data and profile align by gene name and data order" { + let profile = @src.SpatialDeconProfile::create(["extra", "g2", "g1"], ["A"], [ + [5.0], + [2.0], + [1.0], + ]) catch { + _ => abort("SpatialDecon reordered profile should be valid") + } + let data = @src.SpatialDeconData::create(["g1", "g2"], ["s1"], [[3.0], [6.0]]) catch { + _ => abort("SpatialDecon reordered data should be valid") + } + let result = @src.spatial_decon(data, profile, config=sd_test_config()) catch { + _ => abort("SpatialDecon reordered fit should succeed") + } + assert_eq(result.gene_names, ["g1", "g2"]) + sd_test_close(result.beta[0][0], 3.0, 1.0e-6) +} + +///| +test "SpatialDecon: fitting rejects insufficient shared genes" { + let no_shared_profile = @src.SpatialDeconProfile::create(["other"], ["A"], [ + [1.0], + ]) catch { + _ => abort("SpatialDecon disjoint profile should be valid") + } + let no_shared_failed = try { + ignore( + @src.spatial_decon( + sd_test_exact_data(), + no_shared_profile, + config=sd_test_config(), + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + let underdetermined_profile = @src.SpatialDeconProfile::create( + ["g1", "other"], + ["A", "B"], + [[1.0, 1.0], [1.0, 2.0]], + ) catch { + _ => abort("SpatialDecon underdetermined profile should be valid") + } + let underdetermined_failed = try { + ignore( + @src.spatial_decon( + sd_test_exact_data(), + underdetermined_profile, + config=sd_test_config(), + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(no_shared_failed && underdetermined_failed) +} + +///| +test "SpatialDecon: fitting rejects all-zero expression" { + let data = @src.SpatialDeconData::create(["g1", "g2", "g3"], ["s1"], [ + [0.0], + [0.0], + [0.0], + ]) catch { + _ => abort("SpatialDecon zero data constructor should succeed") + } + let failed = try { + ignore( + @src.spatial_decon(data, sd_test_exact_profile(), config=sd_test_config()), + ) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(failed) +} + +///| +test "SpatialDecon: abundance query and ranking expose fitted values" { + let result = sd_test_example_result() + match result.abundance_for("T_cell", "region_1") { + Some(value) => sd_test_close(value, result.beta[0][0], 0.0) + None => abort("SpatialDecon known abundance should exist") + } + assert_eq(result.abundance_for("missing", "region_1"), None) + let ranked = result.top_cell_types("region_1", limit=2) catch { + _ => abort("SpatialDecon ranking should succeed") + } + assert_eq(ranked.length(), 2) + assert_eq(ranked[0].cell_type, "T_cell") + assert_true(ranked[0].abundance >= ranked[1].abundance) +} + +///| +test "SpatialDecon: ranking validates spot and limit" { + let result = sd_test_example_result() + let spot_failed = try { + ignore(result.top_cell_types("missing")) + false + } catch { + SpatialDeconError(_) => true + } + let limit_failed = try { + ignore(result.top_cell_types("region_1", limit=0)) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(spot_failed && limit_failed) +} + +///| +test "SpatialDecon: summary reports dimensions and convergence" { + let summary = sd_test_example_result().summary() + assert_true(summary.contains("genes=9")) + assert_true(summary.contains("spots=5")) + assert_true(summary.contains("cell_types=3")) + assert_true(summary.contains("converged=5/5")) +} + +///| +test "SpatialDecon: cell merge constructor defensively copies members" { + let members = ["A", "B"] + let merge = @src.SpatialDeconCellMerge::create("AB", members) catch { + _ => abort("SpatialDecon merge should be valid") + } + members[0] = "changed" + assert_eq(merge.name, "AB") + assert_eq(merge.members, ["A", "B"]) +} + +///| +test "SpatialDecon: collapse sums abundance proportions and counts" { + let result = sd_test_example_result() + let lymphoid = @src.SpatialDeconCellMerge::create("Lymphoid", [ + "T_cell", "B_cell", + ]) catch { + _ => abort("SpatialDecon lymphoid merge should be valid") + } + let myeloid = @src.SpatialDeconCellMerge::create("Myeloid", ["Myeloid"]) catch { + _ => abort("SpatialDecon myeloid merge should be valid") + } + let collapsed = @src.collapse_spatial_decon(result, [lymphoid, myeloid]) catch { + _ => abort("SpatialDecon collapse should succeed") + } + assert_eq(collapsed.cell_types, ["Lymphoid", "Myeloid"]) + for spot in 0.. abort("SpatialDecon lymphoid merge should be valid") + } + let collapsed = @src.collapse_spatial_decon(result, [lymphoid]) catch { + _ => abort("SpatialDecon covariance collapse should succeed") + } + let expected = result.covariances[0][0][0] + + result.covariances[0][0][1] + + result.covariances[0][1][0] + + result.covariances[0][1][1] + sd_test_close(collapsed.covariances[0][0][0], expected, 1.0e-10) + sd_test_close(collapsed.standard_errors[0][0], expected.sqrt(), 1.0e-10) +} + +///| +test "SpatialDecon: collapse preserves gene-level fit diagnostics" { + let result = sd_test_example_result() + let all = @src.SpatialDeconCellMerge::create("All", [ + "T_cell", "B_cell", "Myeloid", + ]) catch { + _ => abort("SpatialDecon complete merge should be valid") + } + let collapsed = @src.collapse_spatial_decon(result, [all]) catch { + _ => abort("SpatialDecon complete collapse should succeed") + } + assert_eq(collapsed.fitted, result.fitted) + assert_eq(collapsed.residuals, result.residuals) + assert_eq(collapsed.objectives, result.objectives) + assert_eq(collapsed.converged, result.converged) +} + +///| +test "SpatialDecon: collapse rejects empty unknown and repeated members" { + let result = sd_test_example_result() + let empty_failed = try { + ignore(@src.collapse_spatial_decon(result, [])) + false + } catch { + SpatialDeconError(_) => true + } + let unknown = @src.SpatialDeconCellMerge::create("Unknown", ["missing"]) catch { + _ => abort("SpatialDecon unknown merge constructor should succeed") + } + let unknown_failed = try { + ignore(@src.collapse_spatial_decon(result, [unknown])) + false + } catch { + SpatialDeconError(_) => true + } + let first = @src.SpatialDeconCellMerge::create("First", ["T_cell"]) catch { + _ => abort("SpatialDecon first merge should be valid") + } + let second = @src.SpatialDeconCellMerge::create("Second", ["T_cell"]) catch { + _ => abort("SpatialDecon second merge should be valid") + } + let repeated_failed = try { + ignore(@src.collapse_spatial_decon(result, [first, second])) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(empty_failed && unknown_failed && repeated_failed) +} + +///| +test "SpatialDecon: merge constructor rejects invalid names and members" { + let name_failed = try { + ignore(@src.SpatialDeconCellMerge::create("", ["A"])) + false + } catch { + SpatialDeconError(_) => true + } + let members_failed = try { + ignore(@src.SpatialDeconCellMerge::create("AB", ["A", "A"])) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(name_failed && members_failed) +} + +///| +test "SpatialDecon: probe-pool background averages negative probes" { + let background = @src.spatial_decon_background( + ["Neg_A1", "Neg_A2", "Marker_A", "Neg_B", "Marker_B"], + ["s1", "s2"], + [[1.0, 3.0], [3.0, 5.0], [10.0, 12.0], [2.0, 4.0], [20.0, 24.0]], + ["A", "A", "A", "B", "B"], + ["Neg_A1", "Neg_A2", "Neg_B"], + ) catch { + _ => abort("SpatialDecon background estimation should succeed") + } + assert_eq(background[0], [2.0, 4.0]) + assert_eq(background[2], [2.0, 4.0]) + assert_eq(background[3], [2.0, 4.0]) + assert_eq(background[4], [2.0, 4.0]) +} + +///| +test "SpatialDecon: probe-pool background validates pool coverage" { + let length_failed = try { + ignore( + @src.spatial_decon_background( + ["Neg", "Marker"], + ["s1"], + [[1.0], [2.0]], + ["A"], + ["Neg"], + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + let coverage_failed = try { + ignore( + @src.spatial_decon_background( + ["Neg", "Marker"], + ["s1"], + [[1.0], [2.0]], + ["A", "B"], + ["Neg"], + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(length_failed && coverage_failed) +} + +///| +test "SpatialDecon: single-cell counts create mean cell-type profiles" { + let profile = @src.create_spatial_decon_profile( + ["g1", "g2"], + ["a1", "a2", "b1", "b2"], + ["A", "A", "B", "B"], + [[10.0, 8.0, 1.0, 2.0], [1.0, 2.0, 9.0, 11.0]], + scaling_factor=2.0, + min_cells=1, + min_genes=0, + ) catch { + _ => abort("SpatialDecon profile construction should succeed") + } + assert_eq(profile.gene_names, ["g1", "g2"]) + assert_eq(profile.cell_types, ["A", "B"]) + assert_eq(profile.values, [[18.0, 3.0], [3.0, 20.0]]) +} + +///| +test "SpatialDecon: single-cell profile supports normalization and gene filter" { + let profile = @src.create_spatial_decon_profile( + ["g1", "g2", "g3"], + ["a1", "a2", "b1", "b2"], + ["A", "A", "B", "B"], + [[10.0, 8.0, 1.0, 2.0], [1.0, 2.0, 9.0, 11.0], [2.0, 2.0, 2.0, 2.0]], + normalize=true, + min_cells=1, + min_genes=0, + gene_filter=["g1", "g2"], + ) catch { + _ => abort("SpatialDecon normalized profile should succeed") + } + assert_eq(profile.gene_names, ["g1", "g2"]) + for row in profile.values { + for value in row { + assert_true(sd_test_finite(value) && value > 0.0) + } + } +} + +///| +test "SpatialDecon: single-cell profile filters undersized cell types" { + let failed = try { + ignore( + @src.create_spatial_decon_profile( + ["g1", "g2"], + ["a1", "a2"], + ["A", "A"], + [[1.0, 2.0], [2.0, 1.0]], + min_cells=2, + min_genes=0, + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(failed) +} + +///| +test "SpatialDecon: single-cell profile rejects invalid metadata and controls" { + let metadata_failed = try { + ignore( + @src.create_spatial_decon_profile( + ["g1"], + ["c1", "c2"], + ["A"], + [[1.0, 2.0]], + min_cells=0, + min_genes=0, + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + let scaling_failed = try { + ignore( + @src.create_spatial_decon_profile( + ["g1"], + ["c1"], + ["A"], + [[1.0]], + scaling_factor=0.0, + min_cells=0, + min_genes=0, + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + let threshold_failed = try { + ignore( + @src.create_spatial_decon_profile( + ["g1"], + ["c1"], + ["A"], + [[1.0]], + min_cells=-1, + min_genes=0, + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(metadata_failed && scaling_failed && threshold_failed) +} + +///| +test "SpatialDecon: single-cell profile rejects empty libraries and gene filters" { + let library_failed = try { + ignore( + @src.create_spatial_decon_profile( + ["g1"], + ["c1"], + ["A"], + [[0.0]], + min_cells=0, + min_genes=0, + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + let gene_failed = try { + ignore( + @src.create_spatial_decon_profile( + ["g1"], + ["c1"], + ["A"], + [[1.0]], + min_cells=0, + min_genes=0, + gene_filter=["missing"], + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(library_failed && gene_failed) +} + +///| +test "SpatialDecon: reverse deconvolution fits genes from varying scores" { + let (data, _, _) = @src.spatial_decon_example_data() catch { + _ => abort("SpatialDecon reverse data should be valid") + } + let result = sd_test_example_result() + let reverse = @src.reverse_spatial_decon(data, result) catch { + _ => abort("SpatialDecon reverse fit should succeed") + } + assert_eq(reverse.gene_names, data.gene_names) + assert_eq(reverse.spot_ids, data.spot_ids) + assert_eq(reverse.cell_types, result.cell_types) + assert_eq(reverse.coefficients.length(), data.n_genes()) + assert_eq(reverse.coefficients[0].length(), result.n_cell_types() + 1) + for row in reverse.coefficients { + for value in row { + assert_true(value >= 0.0 && sd_test_finite(value)) + } + } +} + +///| +test "SpatialDecon: reverse deconvolution returns residual diagnostics" { + let (data, _, _) = @src.spatial_decon_example_data() catch { + _ => abort("SpatialDecon reverse data should be valid") + } + let reverse = @src.reverse_spatial_decon(data, sd_test_example_result()) catch { + _ => abort("SpatialDecon reverse diagnostics should succeed") + } + assert_eq(reverse.fitted.length(), data.n_genes()) + assert_eq(reverse.fitted[0].length(), data.n_spots()) + for gene in 0..= 0.0) + assert_true(sd_test_finite(reverse.correlations[gene])) + assert_true(reverse.objectives[gene] >= 0.0) + } +} + +///| +test "SpatialDecon: reverse deconvolution validates spot identity and epsilon" { + let result = sd_test_example_result() + let (source, _, _) = @src.spatial_decon_example_data() catch { + _ => abort("SpatialDecon reverse source should be valid") + } + let mismatched = @src.SpatialDeconData::create( + source.gene_names, + ["x1", "x2", "x3", "x4", "x5"], + source.values, + background=source.background, + ) catch { + _ => abort("SpatialDecon mismatched reverse data should be valid") + } + let spots_failed = try { + ignore(@src.reverse_spatial_decon(mismatched, result)) + false + } catch { + SpatialDeconError(_) => true + } + let epsilon_failed = try { + ignore(@src.reverse_spatial_decon(source, result, epsilon=-1.0)) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(spots_failed && epsilon_failed) +} + +///| +test "SpatialDecon: reverse deconvolution requires varying cell scores" { + let result = sd_test_exact_result() + let constant_data = @src.SpatialDeconData::create( + ["g1", "g2", "g3"], + ["spot_1", "spot_2"], + [[7.0, 7.0], [9.0, 9.0], [11.0, 11.0]], + background=[[5.0, 5.0], [5.0, 5.0], [5.0, 5.0]], + ) catch { + _ => abort("SpatialDecon constant data should be valid") + } + let constant_result = @src.spatial_decon( + constant_data, + sd_test_exact_profile(), + config=sd_test_config(), + ) catch { + _ => abort("SpatialDecon constant fit should succeed") + } + let failed = try { + ignore(@src.reverse_spatial_decon(constant_data, constant_result)) + false + } catch { + SpatialDeconError(_) => true + } + ignore(result) + assert_true(failed) +} + +///| +test "SpatialDecon: SpatialExperiment wrapper writes scores and metadata" { + let (experiment, profile, nuclei_counts) = sd_test_experiment() + let output = @src.spatial_decon_spatial_experiment( + experiment, + profile, + background_assay_name="background", + weight_assay_name="weights", + nuclei_counts~, + config=sd_test_config(refit_outliers=true), + ) catch { + _ => abort("SpatialDecon SpatialExperiment wrapper should succeed") + } + assert_eq(output.experiment.metadata["spatialdecon_genes"], "9") + assert_eq(output.experiment.metadata["spatialdecon_spots"], "5") + assert_eq(output.experiment.metadata["spatialdecon_cell_types"], "3") + assert_true(output.experiment.col_data[0].contains("SpatialDecon:T_cell")) + assert_true( + output.experiment.col_data[0].contains("SpatialDeconProp:Myeloid"), + ) + assert_eq(output.result.cell_counts.length(), 3) +} + +///| +test "SpatialDecon: SpatialExperiment wrapper does not mutate input" { + let (experiment, profile, nuclei_counts) = sd_test_experiment() + let original_value = experiment.assay["counts"][0][0] + let output = @src.spatial_decon_spatial_experiment( + experiment, + profile, + background_assay_name="background", + nuclei_counts~, + config=sd_test_config(), + ) catch { + _ => abort("SpatialDecon immutable wrapper should succeed") + } + assert_true(!experiment.col_data[0].contains("SpatialDecon:T_cell")) + assert_true(!experiment.metadata.contains("spatialdecon_genes")) + output.experiment.assay["counts"][0][0] = 999.0 + output.experiment.col_data[0]["sample"] = "changed" + output.experiment.metadata["owner"] = "changed" + assert_eq(experiment.assay["counts"][0][0], original_value) + assert_eq(experiment.col_data[0]["sample"], "sample_1") + assert_eq(experiment.metadata["owner"], "input") +} + +///| +test "SpatialDecon: SpatialExperiment wrapper generates missing identifiers" { + let experiment = @src.SpatialExperiment::new() + ignore(@src.se_add_assay(experiment, "counts", [[2.0, 4.0], [4.0, 8.0]])) + let profile = @src.SpatialDeconProfile::create(["gene_1", "gene_2"], ["A"], [ + [1.0], + [2.0], + ]) catch { + _ => abort("SpatialDecon generated-name profile should be valid") + } + let output = @src.spatial_decon_spatial_experiment( + experiment, + profile, + config=sd_test_config(), + ) catch { + _ => abort("SpatialDecon generated identifiers should succeed") + } + assert_eq(output.result.gene_names, ["gene_1", "gene_2"]) + assert_eq(output.result.spot_ids, ["spot_1", "spot_2"]) + assert_eq(output.experiment.col_data.length(), 2) +} + +///| +test "SpatialDecon: SpatialExperiment wrapper validates assay names" { + let (experiment, profile, _) = sd_test_experiment() + let assay_failed = try { + ignore( + @src.spatial_decon_spatial_experiment( + experiment, + profile, + assay_name="missing", + config=sd_test_config(), + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + let background_failed = try { + ignore( + @src.spatial_decon_spatial_experiment( + experiment, + profile, + background_assay_name="missing", + config=sd_test_config(), + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + let weights_failed = try { + ignore( + @src.spatial_decon_spatial_experiment( + experiment, + profile, + weight_assay_name="missing", + config=sd_test_config(), + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(assay_failed && background_failed && weights_failed) +} + +///| +test "SpatialDecon: SpatialExperiment wrapper validates annotations" { + let (experiment, profile, _) = sd_test_experiment() + let broken_rows = @src.SpatialExperiment::new() + ignore(@src.se_add_assay(broken_rows, "counts", experiment.assay["counts"])) + ignore(@src.se_add_row(broken_rows, Map([("gene_id", "g1")]))) + let rows_failed = try { + ignore( + @src.spatial_decon_spatial_experiment( + broken_rows, + profile, + config=sd_test_config(), + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + let missing_key = @src.SpatialExperiment::new() + ignore(@src.se_add_assay(missing_key, "counts", experiment.assay["counts"])) + for _ in 0..<9 { + ignore(@src.se_add_row(missing_key, Map([("symbol", "x")]))) + } + let key_failed = try { + ignore( + @src.spatial_decon_spatial_experiment( + missing_key, + profile, + config=sd_test_config(), + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(rows_failed && key_failed) +} + +///| +test "SpatialDecon: SpatialExperiment wrapper validates prefixes and background" { + let (experiment, profile, _) = sd_test_experiment() + let prefix_failed = try { + ignore( + @src.spatial_decon_spatial_experiment( + experiment, + profile, + abundance_prefix="", + config=sd_test_config(), + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + let background_failed = try { + ignore( + @src.spatial_decon_spatial_experiment( + experiment, + profile, + scalar_background=-1.0, + config=sd_test_config(), + ), + ) + false + } catch { + SpatialDeconError(_) => true + } + assert_true(prefix_failed && background_failed) +} + +///| +test "SpatialDecon: example fixture contains deterministic spatial mixtures" { + let (data, profile, nuclei_counts) = @src.spatial_decon_example_data() catch { + _ => abort("SpatialDecon example fixture should succeed") + } + assert_eq(data.n_genes(), 9) + assert_eq(data.n_spots(), 5) + assert_eq(profile.n_cell_types(), 3) + assert_eq(profile.cell_types, ["T_cell", "B_cell", "Myeloid"]) + assert_eq(nuclei_counts, [100.0, 120.0, 110.0, 90.0, 105.0]) + assert_true(data.background[0][4] > data.background[0][0]) +} diff --git a/test/moonbit/spicyr_test.mbt b/test/moonbit/spicyr_test.mbt new file mode 100644 index 00000000..16b8cf7e --- /dev/null +++ b/test/moonbit/spicyr_test.mbt @@ -0,0 +1,1025 @@ +// Tests for the Bioconductor spicyR-inspired spatial association model. + +///| +fn spicyr_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "spicyR value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn spicyr_test_config( + edge_correction : Bool, + include_zero_cells : Bool, +) -> @src.SpicyConfig { + @src.SpicyConfig::create( + radii=[1.0], + edge_correction~, + include_zero_cells~, + window_padding=0.0, + tolerance=0.01, + ) catch { + _ => abort("spicyR test configuration should be valid") + } +} + +///| +fn spicyr_test_cell( + image_id : String, + cell_type : String, + x : Double, + y : Double, +) -> @src.SpicyCell { + @src.SpicyCell::create(image_id, cell_type, x, y) catch { + _ => abort("spicyR test cell should be valid") + } +} + +///| +fn spicyr_test_image_metadata( + image_id : String, + condition : String, + subject : String, + covariates : Map[String, Double], +) -> @src.SpicyImageMetadata { + @src.SpicyImageMetadata::create(image_id, condition, subject~, covariates~) catch { + _ => abort("spicyR test metadata should be valid") + } +} + +///| +fn spicyr_test_pair( + from_cell_type : String, + to_cell_type : String, +) -> @src.SpicyPair { + @src.SpicyPair::create(from_cell_type, to_cell_type) catch { + _ => abort("spicyR test pair should be valid") + } +} + +///| +fn spicyr_test_metadata( + count : Int, + split : Int, +) -> Array[@src.SpicyImageMetadata] { + let metadata : Array[@src.SpicyImageMetadata] = [] + for index in 0.. Array[@src.SpicyCell] { + let cells : Array[@src.SpicyCell] = [] + for image in metadata { + cells.push(spicyr_test_cell(image.image_id, "A", source_x, source_y)) + cells.push(spicyr_test_cell(image.image_id, "B", target_x, target_y)) + cells.push(spicyr_test_cell(image.image_id, "Frame", 0.0, 0.0)) + cells.push(spicyr_test_cell(image.image_id, "Frame", 10.0, 10.0)) + } + cells +} + +///| +fn spicyr_test_association( + image_id : String, + from_type : String, + to_type : String, + statistic : Double, + count : Int, +) -> @src.SpicyAssociation { + @src.SpicyAssociation::create( + image_id, + from_type, + to_type, + statistic, + from_count=count, + to_count=count, + ) catch { + _ => abort("spicyR test association should be valid") + } +} + +///| +fn spicyr_test_linear_input() -> ( + Array[@src.SpicyImageMetadata], + Array[@src.SpicyAssociation], +) { + let metadata = spicyr_test_metadata(8, 4) + let associations : Array[@src.SpicyAssociation] = [] + let noise = [-0.2, 0.1, 0.0, 0.15, -0.1, 0.2, -0.05, 0.1] + for index in 0.. ( + Array[@src.SpicyImageMetadata], + Array[@src.SpicyAssociation], +) { + let metadata : Array[@src.SpicyImageMetadata] = [] + let associations : Array[@src.SpicyAssociation] = [] + let subject_effects = [-1.0, -0.25, 0.5, 1.25, 2.0] + for subject_index in 0.. @src.SpicyResult { + let (metadata, first) = spicyr_test_linear_input() + let associations = first.copy() + let weak = [0.1, -0.2, 0.05, 0.0, -0.1, 0.2, -0.05, 0.1] + for index in 0.. abort("spicyR two-pair fit should succeed") + } +} + +///| +fn spicyr_test_spatial_experiment() -> @src.SpatialExperiment { + let experiment = @src.SpatialExperiment::new() + for image_index in 0..<6 { + let image_id = "image_" + (image_index + 1).to_string() + let condition = if image_index < 3 { "control" } else { "treated" } + let target_x = if condition == "control" { 9.0 } else { 5.5 } + let cell_types = ["A", "B", "Frame", "Frame"] + let xs = [5.0, target_x, 0.0, 10.0] + let ys = [5.0, if condition == "control" { 9.0 } else { 5.0 }, 0.0, 10.0] + for cell_index in 0.. abort("custom spicyR configuration should be valid") + } + radii[0] = 9.0 + assert_eq(config.radii[0], 1.0) + assert_true(!config.edge_correction) + assert_true(config.include_zero_cells) + assert_true(!config.use_weights) + assert_eq(config.reference_condition, "control") +} + +///| +test "spicyR: constructors preserve typed values" { + let cell = @src.SpicyCell::create("image", "T_cell", 1.5, 2.5) catch { + _ => abort("spicyR cell should be valid") + } + let pair = @src.SpicyPair::create("T_cell", "Tumour") catch { + _ => abort("spicyR pair should be valid") + } + let association = @src.SpicyAssociation::create( + "image", + "T_cell", + "Tumour", + 1.25, + from_count=4, + to_count=6, + ) catch { + _ => abort("spicyR association should be valid") + } + assert_eq(cell.image_id, "image") + assert_eq(cell.x, 1.5) + assert_eq(pair.label(), "T_cell__Tumour") + assert_eq(association.statistic, 1.25) + assert_eq(association.from_count, 4) +} + +///| +test "spicyR: metadata constructor copies covariates" { + let covariates : Map[String, Double] = Map([("age", 52.0)]) + let metadata = @src.SpicyImageMetadata::create( + "image", + "control", + subject="subject_1", + covariates~, + ) catch { + _ => abort("spicyR metadata should be valid") + } + covariates["age"] = 90.0 + assert_eq(metadata.subject, "subject_1") + assert_eq(metadata.covariates["age"], 52.0) +} + +///| +test "spicyR: constructors reject empty and non-finite values" { + let bad_cell = try { + ignore(@src.SpicyCell::create("", "A", 0.0, 0.0)) + false + } catch { + SpicyError(_) => true + } + let bad_coordinate = try { + ignore(@src.SpicyCell::create("image", "A", @double.not_a_number, 0.0)) + false + } catch { + SpicyError(_) => true + } + let bad_pair = try { + ignore(@src.SpicyPair::create("A", "")) + false + } catch { + SpicyError(_) => true + } + let bad_association = try { + ignore(@src.SpicyAssociation::create("image", "A", "B", 0.0, from_count=-1)) + false + } catch { + SpicyError(_) => true + } + assert_true(bad_cell) + assert_true(bad_coordinate) + assert_true(bad_pair) + assert_true(bad_association) +} + +///| +test "spicyR: configuration rejects invalid radii" { + let empty = try { + ignore(@src.SpicyConfig::create(radii=[])) + false + } catch { + SpicyError(_) => true + } + let non_positive = try { + ignore(@src.SpicyConfig::create(radii=[0.0, 1.0])) + false + } catch { + SpicyError(_) => true + } + let unsorted = try { + ignore(@src.SpicyConfig::create(radii=[2.0, 1.0])) + false + } catch { + SpicyError(_) => true + } + assert_true(empty) + assert_true(non_positive) + assert_true(unsorted) +} + +///| +test "spicyR: configuration rejects invalid fitting controls" { + let bad_fdr = try { + ignore(@src.SpicyConfig::create(fdr_threshold=1.1)) + false + } catch { + SpicyError(_) => true + } + let bad_weight = try { + ignore(@src.SpicyConfig::create(weight_factor=-1.0)) + false + } catch { + SpicyError(_) => true + } + let bad_iterations = try { + ignore(@src.SpicyConfig::create(max_iterations=0)) + false + } catch { + SpicyError(_) => true + } + let bad_tolerance = try { + ignore(@src.SpicyConfig::create(tolerance=1.0)) + false + } catch { + SpicyError(_) => true + } + assert_true(bad_fdr) + assert_true(bad_weight) + assert_true(bad_iterations) + assert_true(bad_tolerance) +} + +///| +test "spicyR: cross-L matches a deterministic rectangular window" { + let metadata = spicyr_test_metadata(3, 1) + let cells = spicyr_test_geometry_cells(metadata, 5.0, 5.0, 5.5, 5.0) + let pair = spicyr_test_pair("A", "B") + let associations = @src.spicy_pairwise( + cells, + metadata, + pair, + config=spicyr_test_config(false, false), + ) catch { + _ => abort("spicyR pairwise geometry should succeed") + } + let expected_l = (100.0 / 3.141592653589793).sqrt() + assert_eq(associations.length(), 3) + spicyr_test_close(associations[0].l_values[0], expected_l, 1.0e-10) + spicyr_test_close(associations[0].statistic, expected_l - 1.0, 1.0e-10) + assert_true(associations[0].observed) + assert_true(associations[0].available) +} + +///| +test "spicyR: edge correction increases boundary-source cross-L" { + let metadata = spicyr_test_metadata(3, 1) + let cells = spicyr_test_geometry_cells(metadata, 0.0, 0.0, 0.5, 0.0) + let pair = spicyr_test_pair("A", "B") + let plain = @src.spicy_pairwise( + cells, + metadata, + pair, + config=spicyr_test_config(false, false), + ) catch { + _ => abort("uncorrected spicyR pairwise fit should succeed") + } + let corrected = @src.spicy_pairwise( + cells, + metadata, + pair, + config=spicyr_test_config(true, false), + ) catch { + _ => abort("edge-corrected spicyR pairwise fit should succeed") + } + assert_true(corrected[0].l_values[0] > plain[0].l_values[0] * 1.9) +} + +///| +test "spicyR: ordered pairs retain directional edge correction" { + let metadata = spicyr_test_metadata(3, 1) + let cells = spicyr_test_geometry_cells(metadata, 0.0, 0.0, 0.5, 0.0) + let forward = @src.spicy_pairwise( + cells, + metadata, + spicyr_test_pair("A", "B"), + config=spicyr_test_config(true, false), + ) catch { + _ => abort("forward spicyR pair should succeed") + } + let reverse = @src.spicy_pairwise( + cells, + metadata, + spicyr_test_pair("B", "A"), + config=spicyr_test_config(true, false), + ) catch { + _ => abort("reverse spicyR pair should succeed") + } + assert_true(forward[0].l_values[0] > reverse[0].l_values[0]) +} + +///| +test "spicyR: same-type cross-L excludes each cell from itself" { + let metadata = spicyr_test_metadata(3, 1) + let cells : Array[@src.SpicyCell] = [] + for image in metadata { + cells.push(spicyr_test_cell(image.image_id, "A", 5.0, 5.0)) + cells.push(spicyr_test_cell(image.image_id, "A", 5.5, 5.0)) + cells.push(spicyr_test_cell(image.image_id, "Frame", 0.0, 0.0)) + cells.push(spicyr_test_cell(image.image_id, "Frame", 10.0, 10.0)) + } + let associations = @src.spicy_pairwise( + cells, + metadata, + spicyr_test_pair("A", "A"), + config=spicyr_test_config(false, false), + ) catch { + _ => abort("same-type spicyR pair should succeed") + } + let expected_l = (50.0 / 3.141592653589793).sqrt() + spicyr_test_close(associations[0].l_values[0], expected_l, 1.0e-10) +} + +///| +test "spicyR: a single same-type cell retains the Poisson baseline" { + let metadata = spicyr_test_metadata(3, 1) + let cells : Array[@src.SpicyCell] = [] + for image in metadata { + cells.push(spicyr_test_cell(image.image_id, "A", 5.0, 5.0)) + cells.push(spicyr_test_cell(image.image_id, "Frame", 0.0, 0.0)) + cells.push(spicyr_test_cell(image.image_id, "Frame", 10.0, 10.0)) + } + let associations = @src.spicy_pairwise( + cells, + metadata, + spicyr_test_pair("A", "A"), + config=spicyr_test_config(false, false), + ) catch { + _ => abort("single-cell same-type pair should succeed") + } + assert_true(!associations[0].observed) + assert_true(associations[0].available) + assert_eq(associations[0].l_values[0], 0.0) + assert_eq(associations[0].statistic, -1.0) +} + +///| +test "spicyR: absent cell types follow include-zero-cells policy" { + let metadata = spicyr_test_metadata(3, 1) + let cells : Array[@src.SpicyCell] = [] + for index in 0.. 0 { + cells.push(spicyr_test_cell(image_id, "B", 5.5, 5.0)) + } + cells.push(spicyr_test_cell(image_id, "Frame", 0.0, 0.0)) + cells.push(spicyr_test_cell(image_id, "Frame", 10.0, 10.0)) + } + let pair = spicyr_test_pair("A", "B") + let omitted = @src.spicy_pairwise( + cells, + metadata, + pair, + config=spicyr_test_config(false, false), + ) catch { + _ => abort("spicyR missing-pair calculation should succeed") + } + let retained = @src.spicy_pairwise( + cells, + metadata, + pair, + config=spicyr_test_config(false, true), + ) catch { + _ => abort("spicyR zero-cell calculation should succeed") + } + assert_true(!omitted[0].available) + assert_true(retained[0].available) + assert_eq(retained[0].statistic, -1.0) +} + +///| +test "spicyR: radii are capped and duplicate caps collapse" { + let metadata = spicyr_test_metadata(3, 1) + let cells : Array[@src.SpicyCell] = [] + for image in metadata { + cells.push(spicyr_test_cell(image.image_id, "A", 0.5, 2.0)) + cells.push(spicyr_test_cell(image.image_id, "B", 1.0, 2.0)) + cells.push(spicyr_test_cell(image.image_id, "Frame", 0.0, 0.0)) + cells.push(spicyr_test_cell(image.image_id, "Frame", 2.0, 4.0)) + } + let config = @src.SpicyConfig::create( + radii=[0.5, 5.0, 10.0], + edge_correction=false, + ) catch { + _ => abort("radius-cap configuration should be valid") + } + let associations = @src.spicy_pairwise( + cells, + metadata, + spicyr_test_pair("A", "B"), + config~, + ) catch { + _ => abort("radius-cap calculation should succeed") + } + assert_eq(associations[0].radii.length(), 2) + spicyr_test_close(associations[0].radii[1], 2.0 / 2.01, 1.0e-12) +} + +///| +test "spicyR: pairwise validation rejects unknown cell types" { + let metadata = spicyr_test_metadata(3, 1) + let cells = spicyr_test_geometry_cells(metadata, 5.0, 5.0, 5.5, 5.0) + let failed = try { + ignore( + @src.spicy_pairwise(cells, metadata, spicyr_test_pair("A", "missing")), + ) + false + } catch { + SpicyError(_) => true + } + assert_true(failed) +} + +///| +test "spicyR: pairwise validation rejects duplicate image metadata" { + let metadata = spicyr_test_metadata(3, 1) + metadata[2] = metadata[1] + let cells = spicyr_test_geometry_cells(metadata, 5.0, 5.0, 5.5, 5.0) + let failed = try { + ignore(@src.spicy_pairwise(cells, metadata, spicyr_test_pair("A", "B"))) + false + } catch { + SpicyError(_) => true + } + assert_true(failed) +} + +///| +test "spicyR: weighted linear model estimates a condition contrast" { + let (metadata, associations) = spicyr_test_linear_input() + let result = @src.spicy_fit_associations(associations, metadata) catch { + _ => abort("spicyR weighted linear fit should succeed") + } + let pair = match result.pair("A", "B") { + Some(value) => value + None => abort("spicyR pair should be present") + } + let condition = match pair.condition("treated") { + Some(value) => value + None => abort("spicyR treated contrast should be present") + } + assert_true(pair.model is @src.SpicyModelKind::WeightedLinear) + spicyr_test_close(condition.estimate, 2.0, 0.25) + assert_true(condition.standard_error > 0.0) + assert_true(condition.p_value >= 0.0 && condition.p_value <= 1.0) +} + +///| +test "spicyR: count-derived precision weights normalize to mean one" { + let (metadata, associations) = spicyr_test_linear_input() + let result = @src.spicy_fit_associations(associations, metadata) catch { + _ => abort("spicyR weighted fit should succeed") + } + let pair = result.pairs[0] + let mut total = 0.0 + for association in pair.associations { + total = total + association.weight + } + spicyr_test_close( + total / pair.associations.length().to_double(), + 1.0, + 1.0e-12, + ) + assert_true(pair.associations[0].weight < pair.associations[7].weight) +} + +///| +test "spicyR: disabling precision weights assigns unit weights" { + let (metadata, associations) = spicyr_test_linear_input() + let config = @src.SpicyConfig::create(use_weights=false) catch { + _ => abort("unweighted spicyR configuration should be valid") + } + let result = @src.spicy_fit_associations(associations, metadata, config~) catch { + _ => abort("unweighted spicyR fit should succeed") + } + for association in result.pairs[0].associations { + assert_eq(association.weight, 1.0) + } +} + +///| +test "spicyR: numeric covariates enter the fixed-effect design" { + let (metadata, associations) = spicyr_test_linear_input() + let result = @src.spicy_fit_associations(associations, metadata, covariate_names=[ + "age", + ]) catch { + _ => abort("spicyR covariate fit should succeed") + } + let condition = result.pairs[0].conditions[0] + assert_true(condition.estimate == condition.estimate) + assert_true(condition.standard_error > 0.0) +} + +///| +test "spicyR: repeated subjects select the random-intercept model" { + let (metadata, associations) = spicyr_test_random_input() + let result = @src.spicy_fit_associations(associations, metadata) catch { + _ => abort("spicyR random-intercept fit should succeed") + } + let pair = result.pairs[0] + let condition = pair.conditions[0] + assert_true(pair.model is @src.SpicyModelKind::WeightedRandomIntercept) + spicyr_test_close(condition.estimate, 1.5, 0.15) + assert_true(pair.random_intercept_variance > 0.1) + assert_true(pair.residual_variance >= 0.0) +} + +///| +test "spicyR: multiple conditions produce reference contrasts" { + let metadata : Array[@src.SpicyImageMetadata] = [] + let associations : Array[@src.SpicyAssociation] = [] + let levels = ["control", "drug_a", "drug_b"] + for level_index in 0.. abort("multi-condition spicyR configuration should be valid") + } + let result = @src.spicy_fit_associations(associations, metadata, config~) catch { + _ => abort("multi-condition spicyR fit should succeed") + } + assert_eq(result.pairs[0].conditions.length(), 2) + let drug_a = match result.pairs[0].condition("drug_a") { + Some(value) => value + None => abort("drug_a contrast should be present") + } + let drug_b = match result.pairs[0].condition("drug_b") { + Some(value) => value + None => abort("drug_b contrast should be present") + } + spicyr_test_close(drug_a.estimate, 1.0, 0.05) + spicyr_test_close(drug_b.estimate, 2.0, 0.05) +} + +///| +test "spicyR: BH correction is bounded and rank monotone" { + let result = spicyr_test_two_pair_result() + let first = result.pairs[0].conditions[0] + let second = result.pairs[1].conditions[0] + assert_true(first.adjusted_p_value >= first.p_value) + assert_true(second.adjusted_p_value >= second.p_value) + assert_true(first.adjusted_p_value <= 1.0) + assert_true(second.adjusted_p_value <= 1.0) + if first.p_value <= second.p_value { + assert_true(first.adjusted_p_value <= second.adjusted_p_value) + } else { + assert_true(second.adjusted_p_value <= first.adjusted_p_value) + } +} + +///| +test "spicyR: pair and association lookup preserve identities" { + let result = spicyr_test_two_pair_result() + let pair = match result.pair("A", "B") { + Some(value) => value + None => abort("spicyR A__B pair should exist") + } + let association = match pair.association("image_3") { + Some(value) => value + None => abort("spicyR image association should exist") + } + assert_eq(association.image_id, "image_3") + assert_true(result.pair("missing", "B") is None) + assert_true(pair.association("missing") is None) +} + +///| +test "spicyR: top ranks pairs and handles zero limits" { + let result = spicyr_test_two_pair_result() + let top = result.top("treated", limit=2) catch { + _ => abort("spicyR top query should succeed") + } + let first_p = top[0].conditions[0].p_value + let second_p = top[1].conditions[0].p_value + assert_true(first_p <= second_p) + let empty = result.top("treated", limit=0) catch { + _ => abort("spicyR empty top query should succeed") + } + assert_eq(empty.length(), 0) +} + +///| +test "spicyR: significant filtering and summary use configured FDR" { + let result = spicyr_test_two_pair_result() + let all = result.significant("treated", threshold=1.0) catch { + _ => abort("spicyR significant query should succeed") + } + assert_eq(all.length(), result.n_pairs()) + assert_eq(result.n_images(), 8) + assert_true(result.summary().contains("spicyR(images=8, pairs=2")) +} + +///| +test "spicyR: result queries reject absent contrasts and invalid limits" { + let result = spicyr_test_two_pair_result() + let bad_level = try { + ignore(result.top("control")) + false + } catch { + SpicyError(_) => true + } + let bad_limit = try { + ignore(result.top("treated", limit=-1)) + false + } catch { + SpicyError(_) => true + } + let bad_threshold = try { + ignore(result.significant("treated", threshold=1.1)) + false + } catch { + SpicyError(_) => true + } + assert_true(bad_level) + assert_true(bad_limit) + assert_true(bad_threshold) +} + +///| +test "spicyR: fitting rejects a single condition" { + let (metadata, associations) = spicyr_test_linear_input() + for index in 0.. true + } + assert_true(failed) +} + +///| +test "spicyR: fitting rejects duplicate pair-image associations" { + let (metadata, associations) = spicyr_test_linear_input() + associations.push(associations[0]) + let failed = try { + ignore(@src.spicy_fit_associations(associations, metadata)) + false + } catch { + SpicyError(_) => true + } + assert_true(failed) +} + +///| +test "spicyR: fitting rejects missing covariates" { + let (metadata, associations) = spicyr_test_linear_input() + let failed = try { + ignore( + @src.spicy_fit_associations(associations, metadata, covariate_names=[ + "missing", + ]), + ) + false + } catch { + SpicyError(_) => true + } + assert_true(failed) +} + +///| +test "spicyR: direct cell analysis returns requested pairs" { + let (cells, metadata, pairs) = @src.spicyr_example_data() + let config = @src.SpicyConfig::create( + radii=[0.5, 1.0, 2.0], + edge_correction=true, + reference_condition="control", + tolerance=0.01, + ) catch { + _ => abort("spicyR example configuration should be valid") + } + let result = @src.spicyr( + cells, + metadata, + pairs~, + covariate_names=["age"], + config~, + ) catch { + _ => abort("spicyR example analysis should succeed") + } + assert_eq(result.n_images(), 12) + assert_eq(result.n_pairs(), 1) + assert_true( + result.pairs[0].model is @src.SpicyModelKind::WeightedRandomIntercept, + ) + assert_true(result.pairs[0].conditions[0].estimate > 0.0) +} + +///| +test "spicyR: automatic pair generation includes ordered pairs" { + let (cells, metadata, _) = @src.spicyr_example_data() + let config = @src.SpicyConfig::create( + radii=[1.0], + edge_correction=false, + include_zero_cells=true, + use_weights=false, + tolerance=0.01, + ) catch { + _ => abort("automatic-pair configuration should be valid") + } + let result = @src.spicyr(cells, metadata, config~) catch { + _ => abort("automatic spicyR analysis should succeed") + } + assert_eq(result.n_pairs(), 4) + assert_true(result.pair("T_cell", "Tumour") is Some(_)) + assert_true(result.pair("Tumour", "T_cell") is Some(_)) +} + +///| +test "spicyR: direct analysis rejects duplicate requested pairs" { + let (cells, metadata, pairs) = @src.spicyr_example_data() + let duplicate = [pairs[0], pairs[0]] + let failed = try { + ignore(@src.spicyr(cells, metadata, pairs=duplicate)) + false + } catch { + SpicyError(_) => true + } + assert_true(failed) +} + +///| +test "spicyR: SpatialExperiment integration preserves and enriches input" { + let experiment = spicyr_test_spatial_experiment() + experiment.metadata["source"] = "fixture" + let pair = spicyr_test_pair("A", "B") + let output = @src.spicyr_spatial_experiment( + experiment, + pairs=[pair], + config=spicyr_test_config(false, false), + ) catch { + _ => abort("spicyR SpatialExperiment integration should succeed") + } + assert_eq(output.result.n_images(), 6) + assert_eq(output.result.n_pairs(), 1) + assert_eq(output.experiment.metadata["source"], "fixture") + assert_eq(output.experiment.metadata["spicyr_images"], "6") + assert_eq(output.experiment.metadata["spicyr_pairs"], "1") + assert_true(!experiment.metadata.contains("spicyr_images")) +} + +///| +test "spicyR: SpatialExperiment supports subject and numeric covariate keys" { + let experiment = spicyr_test_spatial_experiment() + let pair = spicyr_test_pair("A", "B") + let output = @src.spicyr_spatial_experiment( + experiment, + subject_key="subject", + covariate_keys=["age"], + pairs=[pair], + config=spicyr_test_config(false, false), + ) catch { + _ => abort("spicyR keyed SpatialExperiment fit should succeed") + } + assert_true( + output.result.pairs[0].model is @src.SpicyModelKind::WeightedRandomIntercept, + ) +} + +///| +test "spicyR: SpatialExperiment rejects coordinate mismatch" { + let experiment = spicyr_test_spatial_experiment() + ignore(experiment.spatial_coords.pop()) + let failed = try { + ignore(@src.spicyr_spatial_experiment(experiment)) + false + } catch { + SpicyError(_) => true + } + assert_true(failed) +} + +///| +test "spicyR: SpatialExperiment rejects missing required columns" { + let experiment = spicyr_test_spatial_experiment() + experiment.col_data[0].remove("cellType") + let failed = try { + ignore(@src.spicyr_spatial_experiment(experiment)) + false + } catch { + SpicyError(_) => true + } + assert_true(failed) +} + +///| +test "spicyR: SpatialExperiment rejects image-varying metadata" { + let experiment = spicyr_test_spatial_experiment() + experiment.col_data[1]["condition"] = "other" + let failed = try { + ignore(@src.spicyr_spatial_experiment(experiment)) + false + } catch { + SpicyError(_) => true + } + assert_true(failed) +} + +///| +test "spicyR: SpatialExperiment rejects nonnumeric covariates" { + let experiment = spicyr_test_spatial_experiment() + experiment.col_data[0]["age"] = "unknown" + let failed = try { + ignore(@src.spicyr_spatial_experiment(experiment, covariate_keys=["age"])) + false + } catch { + SpicyError(_) => true + } + assert_true(failed) +} diff --git a/test/moonbit/tradeseq_advanced_test.mbt b/test/moonbit/tradeseq_advanced_test.mbt new file mode 100644 index 00000000..dee249ae --- /dev/null +++ b/test/moonbit/tradeseq_advanced_test.mbt @@ -0,0 +1,993 @@ +///| +fn tradeseq_adv_test_counts() -> Array[Array[Double]] { + let flat : Array[Double] = [] + let association : Array[Double] = [] + let endpoint : Array[Double] = [] + let early_branch : Array[Double] = [] + let zero : Array[Double] = [] + for cell in 0..<24 { + flat.push((10 + cell % 3).to_double()) + if cell < 8 { + association.push((3 + cell).to_double()) + endpoint.push((6 + cell % 2).to_double()) + early_branch.push((8 + cell % 2).to_double()) + } else if cell < 16 { + let step = cell - 8 + association.push((12 + 3 * step).to_double()) + endpoint.push((10 + 4 * step).to_double()) + early_branch.push( + if step < 4 { + (26 + step).to_double() + } else { + (14 + step % 2).to_double() + }, + ) + } else { + let step = cell - 16 + association.push((12 + 3 * step).to_double()) + endpoint.push((10 + step / 3).to_double()) + early_branch.push( + if step < 4 { + (4 + step).to_double() + } else { + (14 + step % 2).to_double() + }, + ) + } + zero.push(0.0) + } + [flat, association, endpoint, early_branch, zero] +} + +///| +fn tradeseq_adv_test_trajectory() -> ( + Array[Array[Double]], + Array[Array[Double]], +) { + let pseudotime : Array[Array[Double]] = [] + let weights : Array[Array[Double]] = [] + for cell in 0..<24 { + if cell < 8 { + let time = cell.to_double() * 0.05 + pseudotime.push([time, time]) + weights.push([2.0, 2.0]) + } else if cell < 16 { + let time = 0.4 + (cell - 8).to_double() * 0.08 + pseudotime.push([time, 0.0]) + weights.push([3.0, 0.0]) + } else { + let time = 0.4 + (cell - 16).to_double() * 0.08 + pseudotime.push([0.0, time]) + weights.push([0.0, 4.0]) + } + } + (pseudotime, weights) +} + +///| +fn tradeseq_adv_test_config() -> @src.TradeSeqAdvancedConfig { + @src.TradeSeqAdvancedConfig::create( + n_knots=4, + smoothing_penalty=1.0, + max_iterations=80, + tolerance=1.0e-5, + minimum_dispersion=1.0e-4, + maximum_dispersion=20.0, + ridge=1.0e-6, + fdr_threshold=0.1, + test_points=6, + ) catch { + _ => abort("valid tradeSeq advanced configuration should build") + } +} + +///| +fn tradeseq_adv_test_fit() -> @src.TradeSeqAdvancedFit { + let (pseudotime, weights) = tradeseq_adv_test_trajectory() + @src.tradeseq_fit_advanced( + tradeseq_adv_test_counts(), + pseudotime, + weights, + gene_names=["flat", "association", "endpoint", "early", "zero"], + lineage_names=["left", "right"], + offsets=Array::make(24, 0.0), + config=tradeseq_adv_test_config(), + ) catch { + _ => abort("valid tradeSeq advanced data should fit") + } +} + +///| +fn tradeseq_adv_test_single_lineage_fit() -> @src.TradeSeqAdvancedFit { + let pseudotime : Array[Array[Double]] = [] + let weights : Array[Array[Double]] = [] + let counts : Array[Double] = [] + for cell in 0..<12 { + pseudotime.push([cell.to_double()]) + weights.push([1.0]) + counts.push((cell + 1).to_double()) + } + @src.tradeseq_fit_advanced( + [counts], + pseudotime, + weights, + gene_names=["gene"], + offsets=Array::make(12, 0.0), + config=@src.TradeSeqAdvancedConfig::create( + n_knots=3, + max_iterations=40, + ridge=1.0e-5, + test_points=4, + ), + ) catch { + _ => abort("valid single-lineage tradeSeq data should fit") + } +} + +///| +fn tradeseq_adv_test_sce() -> @src.SingleCellExperiment { + let names : Array[String] = [] + for cell in 0..<24 { + names.push("cell" + (cell + 1).to_string()) + } + let experiment = @src.SingleCellExperiment::new( + tradeseq_adv_test_counts(), + ["flat", "association", "endpoint", "early", "zero"], + names, + ) + let (pseudotime, weights) = tradeseq_adv_test_trajectory() + experiment.reduced_dims["slingshot.pseudotime"] = pseudotime + experiment.reduced_dims["slingshot.weights"] = weights + experiment.row_data["symbol"] = ["F", "A", "E", "B", "Z"] + experiment.col_data["batch"] = Array::make(24, "one") + experiment.metadata["source"] = "test" + experiment.alternative_experiments["spike"] = @src.SingleCellExperiment::new( + [[1.0, 2.0]], + ["spike1"], + ["s1", "s2"], + ) + experiment +} + +///| +fn tradeseq_adv_test_finite(value : Double) -> Bool { + value == value && value.abs() < 1.0e299 +} + +///| +fn tradeseq_adv_test_slingshot_result() -> @src.SlingshotAdvancedResult { + let coordinates = [ + [-0.1, 0.0], + [0.0, 0.1], + [0.1, -0.1], + [0.9, 0.0], + [1.0, 0.1], + [1.1, -0.1], + [1.9, 0.0], + [2.0, 0.1], + [2.1, -0.1], + [2.9, 0.9], + [3.0, 1.0], + [3.1, 1.1], + [2.9, -0.9], + [3.0, -1.0], + [3.1, -1.1], + ] + let labels = [ + "A", "A", "A", "B", "B", "B", "C", "C", "C", "D", "D", "D", "E", "E", "E", + ] + let config = @src.SlingshotAdvancedConfig::create( + start_clusters=["A"], + end_clusters=["D", "E"], + distance=@src.slingshot_center_euclidean(), + extension=@src.slingshot_extend_none(), + max_iterations=6, + tolerance=1.0e-4, + smoother_span=0.4, + curve_points=24, + ) catch { + _ => abort("valid Slingshot configuration should build") + } + @src.slingshot_advanced(coordinates, labels, config) catch { + _ => abort("valid Slingshot data should fit") + } +} + +///| +test "tradeSeq advanced default configuration matches fitGAM workflow" { + let config = @src.TradeSeqAdvancedConfig::default() + assert_eq(config.n_knots, 6) + assert_eq(config.smoothing_penalty, 1.0) + assert_eq(config.max_iterations, 60) + assert_eq(config.tolerance, 1.0e-6) + assert_eq(config.minimum_dispersion, 1.0e-4) + assert_eq(config.maximum_dispersion, 100.0) + assert_eq(config.ridge, 1.0e-8) + assert_eq(config.fdr_threshold, 0.05) + assert_eq(config.test_points, 12) +} + +///| +test "tradeSeq advanced configuration preserves explicit controls" { + let config = tradeseq_adv_test_config() + assert_eq(config.n_knots, 4) + assert_eq(config.smoothing_penalty, 1.0) + assert_eq(config.max_iterations, 80) + assert_eq(config.tolerance, 1.0e-5) + assert_eq(config.maximum_dispersion, 20.0) + assert_eq(config.ridge, 1.0e-6) + assert_eq(config.fdr_threshold, 0.1) + assert_eq(config.test_points, 6) +} + +///| +test "tradeSeq advanced rejects invalid knots and smoothing penalty" { + let mut failures = 0 + ignore(@src.TradeSeqAdvancedConfig::create(n_knots=2)) catch { + _ => failures = failures + 1 + } + ignore(@src.TradeSeqAdvancedConfig::create(smoothing_penalty=-1.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.TradeSeqAdvancedConfig::create(smoothing_penalty=0.0 / 0.0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "tradeSeq advanced rejects invalid iteration controls" { + let mut failures = 0 + ignore(@src.TradeSeqAdvancedConfig::create(max_iterations=0)) catch { + _ => failures = failures + 1 + } + ignore(@src.TradeSeqAdvancedConfig::create(tolerance=0.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.TradeSeqAdvancedConfig::create(tolerance=0.0 / 0.0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "tradeSeq advanced rejects invalid dispersion and ridge controls" { + let mut failures = 0 + ignore(@src.TradeSeqAdvancedConfig::create(minimum_dispersion=0.0)) catch { + _ => failures = failures + 1 + } + ignore( + @src.TradeSeqAdvancedConfig::create( + minimum_dispersion=2.0, + maximum_dispersion=1.0, + ), + ) catch { + _ => failures = failures + 1 + } + ignore(@src.TradeSeqAdvancedConfig::create(ridge=0.0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "tradeSeq advanced rejects invalid testing controls" { + let mut failures = 0 + ignore(@src.TradeSeqAdvancedConfig::create(fdr_threshold=0.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.TradeSeqAdvancedConfig::create(fdr_threshold=1.1)) catch { + _ => failures = failures + 1 + } + ignore(@src.TradeSeqAdvancedConfig::create(test_points=1)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "tradeSeq advanced validates count matrix shape and values" { + let (pseudotime, weights) = tradeseq_adv_test_trajectory() + let mut failures = 0 + ignore(@src.tradeseq_fit_advanced([], pseudotime, weights)) catch { + _ => failures = failures + 1 + } + ignore(@src.tradeseq_fit_advanced([[]], pseudotime, weights)) catch { + _ => failures = failures + 1 + } + ignore( + @src.tradeseq_fit_advanced([[1.0, 2.0], [1.0]], [[0.0], [1.0]], [ + [1.0], + [1.0], + ]), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.tradeseq_fit_advanced([[-1.0, 2.0]], [[0.0], [1.0]], [[1.0], [1.0]]), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.tradeseq_fit_advanced([[1.5, 2.0]], [[0.0], [1.0]], [[1.0], [1.0]]), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.tradeseq_fit_advanced([[0.0 / 0.0, 2.0]], [[0.0], [1.0]], [ + [1.0], + [1.0], + ]), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 6) +} + +///| +test "tradeSeq advanced validates trajectory row dimensions" { + let mut failures = 0 + ignore(@src.tradeseq_fit_advanced([[1.0, 2.0]], [[0.0]], [[1.0]])) catch { + _ => failures = failures + 1 + } + ignore(@src.tradeseq_fit_advanced([[1.0, 2.0]], [[], []], [[], []])) catch { + _ => failures = failures + 1 + } + ignore( + @src.tradeseq_fit_advanced([[1.0, 2.0]], [[0.0], [1.0, 2.0]], [[1.0], [1.0]]), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "tradeSeq advanced validates lineage weight semantics" { + let mut failures = 0 + ignore( + @src.tradeseq_fit_advanced([[1.0, 2.0]], [[0.0], [1.0]], [[-1.0], [1.0]]), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.tradeseq_fit_advanced([[1.0, 2.0]], [[0.0], [1.0]], [[0.0], [1.0]]), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.tradeseq_fit_advanced([[1.0, 2.0]], [[0.0], [1.0]], [ + [0.0 / 0.0], + [1.0], + ]), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "tradeSeq advanced requires finite pseudotime for active lineages" { + let failed = try { + ignore( + @src.tradeseq_fit_advanced([[1.0, 2.0]], [[0.0 / 0.0], [1.0]], [ + [1.0], + [1.0], + ]), + ) + false + } catch { + _ => true + } + assert_true(failed) +} + +///| +test "tradeSeq advanced permits nonfinite inactive pseudotime" { + let fit = @src.tradeseq_fit_advanced( + [[1.0, 2.0, 3.0, 4.0]], + [[0.0, 0.0 / 0.0], [1.0, 0.0 / 0.0], [0.0 / 0.0, 3.0], [0.0 / 0.0, 4.0]], + [[1.0, 0.0], [1.0, 0.0], [0.0, 1.0], [0.0, 1.0]], + offsets=[0.0, 0.0, 0.0, 0.0], + config=@src.TradeSeqAdvancedConfig::create(n_knots=3), + ) catch { + _ => abort("inactive nonfinite pseudotime should be ignored") + } + assert_eq(fit.n_lineages, 2) +} + +///| +test "tradeSeq advanced requires pseudotime range in every lineage" { + let failed = try { + ignore( + @src.tradeseq_fit_advanced([[1.0, 2.0]], [[0.0], [0.0]], [[1.0], [1.0]]), + ) + false + } catch { + _ => true + } + assert_true(failed) +} + +///| +test "tradeSeq advanced validates gene and lineage name counts" { + let (pseudotime, weights) = tradeseq_adv_test_trajectory() + let mut failures = 0 + ignore( + @src.tradeseq_fit_advanced( + tradeseq_adv_test_counts(), + pseudotime, + weights, + gene_names=["one"], + ), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.tradeseq_fit_advanced( + tradeseq_adv_test_counts(), + pseudotime, + weights, + lineage_names=["one"], + ), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "tradeSeq advanced validates nonempty unique names" { + let mut failures = 0 + ignore( + @src.tradeseq_fit_advanced( + [[1.0, 2.0], [2.0, 3.0]], + [[0.0], [1.0]], + [[1.0], [1.0]], + gene_names=["gene", "gene"], + ), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.tradeseq_fit_advanced([[1.0, 2.0]], [[0.0], [1.0]], [[1.0], [1.0]], lineage_names=[ + " ", + ]), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "tradeSeq advanced validates supplied offsets" { + let mut failures = 0 + ignore( + @src.tradeseq_fit_advanced([[1.0, 2.0]], [[0.0], [1.0]], [[1.0], [1.0]], offsets=[ + 0.0, + ]), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.tradeseq_fit_advanced([[1.0, 2.0]], [[0.0], [1.0]], [[1.0], [1.0]], offsets=[ + 0.0, + 0.0 / 0.0, + ]), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "tradeSeq advanced fit exposes feature by cell dimensions" { + let fit = tradeseq_adv_test_fit() + assert_eq(fit.n_genes, 5) + assert_eq(fit.n_cells, 24) + assert_eq(fit.n_lineages, 2) + assert_eq(fit.gene_names, ["flat", "association", "endpoint", "early", "zero"]) + assert_eq(fit.lineage_names, ["left", "right"]) + assert_eq(fit.models.length(), 5) + assert_eq(fit.models[0].fitted_values.length(), 24) +} + +///| +test "tradeSeq advanced normalizes each cell lineage weight row" { + let fit = tradeseq_adv_test_fit() + assert_eq(fit.cell_weights[0], [0.5, 0.5]) + assert_eq(fit.cell_weights[8], [1.0, 0.0]) + assert_eq(fit.cell_weights[16], [0.0, 1.0]) + for row in fit.cell_weights { + let mut total = 0.0 + for value in row { + total = total + value + } + assert_true((total - 1.0).abs() < 1.0e-12) + } +} + +///| +test "tradeSeq advanced derives centered library size offsets" { + let (pseudotime, weights) = tradeseq_adv_test_trajectory() + let fit = @src.tradeseq_fit_advanced( + tradeseq_adv_test_counts(), + pseudotime, + weights, + config=tradeseq_adv_test_config(), + ) catch { + _ => abort("valid automatic offsets should fit") + } + let mut total = 0.0 + for value in fit.offsets { + total = total + value + } + assert_true(total.abs() < 1.0e-10) +} + +///| +test "tradeSeq advanced preserves caller matrices" { + let (pseudotime, weights) = tradeseq_adv_test_trajectory() + let fit = @src.tradeseq_fit_advanced( + tradeseq_adv_test_counts(), + pseudotime, + weights, + config=tradeseq_adv_test_config(), + ) catch { + _ => abort("valid caller matrices should fit") + } + fit.pseudotime[0][0] = 99.0 + fit.cell_weights[0][0] = 0.0 + assert_eq(pseudotime[0][0], 0.0) + assert_eq(weights[0][0], 2.0) +} + +///| +test "tradeSeq advanced models have finite penalized NB statistics" { + let fit = tradeseq_adv_test_fit() + for model in fit.models { + assert_eq(model.coefficients.length(), 8) + assert_eq(model.covariance.length(), 8) + assert_eq(model.covariance[0].length(), 8) + assert_true(model.dispersion >= fit.config.minimum_dispersion) + assert_true(model.dispersion <= fit.config.maximum_dispersion) + assert_true(tradeseq_adv_test_finite(model.log_likelihood)) + assert_true(tradeseq_adv_test_finite(model.aic)) + assert_eq(model.effective_df, 8.0) + assert_true(model.iterations >= 1) + for value in model.coefficients { + assert_true(tradeseq_adv_test_finite(value)) + } + for value in model.fitted_values { + assert_true(tradeseq_adv_test_finite(value)) + assert_true(value >= 0.0) + } + } +} + +///| +test "tradeSeq advanced handles an all-zero gene" { + let fit = tradeseq_adv_test_fit() + let model = fit.models[4] + assert_eq(model.gene_id, "zero") + assert_true(model.dispersion >= fit.config.minimum_dispersion) + for value in model.fitted_values { + assert_true(value < 1.0e-5) + } +} + +///| +test "tradeSeq advanced fitted trend follows increasing counts" { + let fit = tradeseq_adv_test_fit() + let fitted = fit.models[1].fitted_values + assert_true(fitted[15] > fitted[0]) + assert_true(fitted[23] > fitted[0]) +} + +///| +test "tradeSeq advanced associationTest returns gene-level Wald results" { + let table = @src.tradeseq_association_test_advanced(tradeseq_adv_test_fit()) + assert_eq(table.test_name, "associationTest") + assert_eq(table.results.length(), 5) + assert_eq(table.fdr_threshold, 0.1) + for result in table.results { + assert_true(result.degrees_freedom > 0) + assert_true(result.wald_statistic >= 0.0) + assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) + assert_true( + result.adjusted_p_value >= 0.0 && result.adjusted_p_value <= 1.0, + ) + assert_true(result.adjusted_p_value + 1.0e-12 >= result.p_value) + } +} + +///| +test "tradeSeq advanced associationTest ranks temporal signal above flat gene" { + let table = @src.tradeseq_association_test_advanced(tradeseq_adv_test_fit()) + assert_true(table.results[1].wald_statistic > table.results[0].wald_statistic) + assert_true(table.results[1].p_value < table.results[0].p_value) +} + +///| +test "tradeSeq advanced startVsEndTest detects endpoint change" { + let table = @src.tradeseq_start_vs_end_test_advanced(tradeseq_adv_test_fit()) + assert_eq(table.test_name, "startVsEndTest") + assert_eq(table.results.length(), 5) + assert_eq(table.results[0].degrees_freedom, 2) + assert_true(table.results[1].wald_statistic > table.results[0].wald_statistic) +} + +///| +test "tradeSeq advanced diffEndTest detects lineage endpoint separation" { + let table = @src.tradeseq_diff_end_test_advanced(tradeseq_adv_test_fit()) + assert_eq(table.test_name, "diffEndTest") + assert_eq(table.results[0].degrees_freedom, 1) + assert_true(table.results[2].wald_statistic > table.results[0].wald_statistic) +} + +///| +test "tradeSeq advanced patternTest compares complete lineage smooths" { + let table = @src.tradeseq_pattern_test_advanced( + tradeseq_adv_test_fit(), + n_points=5, + ) + assert_eq(table.test_name, "patternTest") + assert_eq(table.results.length(), 5) + assert_true(table.results[2].degrees_freedom >= 2) + assert_true(table.results[2].wald_statistic > table.results[0].wald_statistic) +} + +///| +test "tradeSeq advanced earlyDETest restricts the comparison interval" { + let table = @src.tradeseq_early_de_test_advanced( + tradeseq_adv_test_fit(), + 0.35, + 0.75, + n_points=5, + ) + assert_eq(table.test_name, "earlyDETest") + assert_eq(table.results.length(), 5) + assert_true(table.results[3].degrees_freedom >= 2) + assert_true(table.results[3].wald_statistic > table.results[0].wald_statistic) +} + +///| +test "tradeSeq advanced fold-change threshold shrinks Wald evidence" { + let fit = tradeseq_adv_test_fit() + let unthresholded = @src.tradeseq_start_vs_end_test_advanced(fit) + let thresholded = @src.tradeseq_start_vs_end_test_advanced(fit, l2fc=2.0) + for gene in 0..= + unthresholded.results[gene].p_value, + ) + } +} + +///| +test "tradeSeq advanced tests validate fold-change threshold" { + let fit = tradeseq_adv_test_fit() + let mut failures = 0 + ignore(@src.tradeseq_association_test_advanced(fit, l2fc=-1.0)) catch { + _ => failures = failures + 1 + } + ignore(@src.tradeseq_start_vs_end_test_advanced(fit, l2fc=0.0 / 0.0)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "tradeSeq advanced lineage comparisons require multiple lineages" { + let fit = tradeseq_adv_test_single_lineage_fit() + let mut failures = 0 + ignore(@src.tradeseq_diff_end_test_advanced(fit)) catch { + _ => failures = failures + 1 + } + ignore(@src.tradeseq_pattern_test_advanced(fit)) catch { + _ => failures = failures + 1 + } + ignore(@src.tradeseq_early_de_test_advanced(fit, 0.0, 0.5)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "tradeSeq advanced validates pattern and earlyDE grids" { + let fit = tradeseq_adv_test_fit() + let mut failures = 0 + ignore(@src.tradeseq_pattern_test_advanced(fit, n_points=1)) catch { + _ => failures = failures + 1 + } + ignore(@src.tradeseq_early_de_test_advanced(fit, -0.1, 0.5)) catch { + _ => failures = failures + 1 + } + ignore(@src.tradeseq_early_de_test_advanced(fit, 0.5, 0.5)) catch { + _ => failures = failures + 1 + } + ignore(@src.tradeseq_early_de_test_advanced(fit, 0.5, 1.1)) catch { + _ => failures = failures + 1 + } + ignore(@src.tradeseq_early_de_test_advanced(fit, 0.0, 0.5, n_points=1)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 5) +} + +///| +test "tradeSeq advanced predicts smooths on each lineage" { + let prediction = @src.tradeseq_predict_smooth_advanced( + tradeseq_adv_test_fit(), + "association", + n_points=9, + ) + assert_eq(prediction.gene_id, "association") + assert_eq(prediction.pseudotime.length(), 2) + assert_eq(prediction.pseudotime[0].length(), 9) + assert_eq(prediction.fitted.length(), 2) + assert_eq(prediction.standard_errors[1].length(), 9) + assert_eq(prediction.pseudotime[0][0], 0.0) + assert_true((prediction.pseudotime[0][8] - 0.96).abs() < 1.0e-12) +} + +///| +test "tradeSeq advanced smooth predictions are finite and ordered" { + let prediction = @src.tradeseq_predict_smooth_advanced( + tradeseq_adv_test_fit(), + "association", + n_points=9, + ) + for lineage in 0..<2 { + assert_true(prediction.fitted[lineage][8] > prediction.fitted[lineage][0]) + for point in 0..<9 { + assert_true(tradeseq_adv_test_finite(prediction.fitted[lineage][point])) + assert_true( + tradeseq_adv_test_finite(prediction.standard_errors[lineage][point]), + ) + assert_true(prediction.standard_errors[lineage][point] >= 0.0) + } + } +} + +///| +test "tradeSeq advanced smooth prediction validates gene and grid" { + let fit = tradeseq_adv_test_fit() + let mut failures = 0 + ignore(@src.tradeseq_predict_smooth_advanced(fit, "missing")) catch { + _ => failures = failures + 1 + } + ignore(@src.tradeseq_predict_smooth_advanced(fit, "flat", n_points=1)) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 2) +} + +///| +test "tradeSeq advanced evaluateK returns gene by candidate AIC" { + let (pseudotime, weights) = tradeseq_adv_test_trajectory() + let counts = tradeseq_adv_test_counts() + let evaluation = @src.tradeseq_evaluate_k_advanced( + [counts[0], counts[1]], + pseudotime, + weights, + [3, 4], + gene_names=["flat", "association"], + offsets=Array::make(24, 0.0), + config=tradeseq_adv_test_config(), + ) catch { + _ => abort("valid knot candidates should be evaluated") + } + assert_eq(evaluation.candidates, [3, 4]) + assert_eq(evaluation.gene_aic.length(), 2) + assert_eq(evaluation.gene_aic[0].length(), 2) + assert_eq(evaluation.mean_aic.length(), 2) + assert_true( + evaluation.selected_n_knots == 3 || evaluation.selected_n_knots == 4, + ) + for value in evaluation.mean_aic { + assert_true(tradeseq_adv_test_finite(value)) + } +} + +///| +test "tradeSeq advanced evaluateK validates candidate set" { + let (pseudotime, weights) = tradeseq_adv_test_trajectory() + let counts = tradeseq_adv_test_counts() + let mut failures = 0 + ignore(@src.tradeseq_evaluate_k_advanced(counts, pseudotime, weights, [3])) catch { + _ => failures = failures + 1 + } + ignore(@src.tradeseq_evaluate_k_advanced(counts, pseudotime, weights, [2, 3])) catch { + _ => failures = failures + 1 + } + ignore(@src.tradeseq_evaluate_k_advanced(counts, pseudotime, weights, [3, 3])) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 3) +} + +///| +test "tradeSeq advanced fits directly from Slingshot optional pseudotime" { + let slingshot = tradeseq_adv_test_slingshot_result() + let first : Array[Double] = [] + let second : Array[Double] = [] + for cell in 0..<15 { + first.push((cell + 2).to_double()) + second.push((5 + cell % 4).to_double()) + } + let fit = @src.tradeseq_fit_from_slingshot( + [first, second], + ["trend", "stable"], + slingshot, + offsets=Array::make(15, 0.0), + config=@src.TradeSeqAdvancedConfig::create( + n_knots=3, + max_iterations=50, + ridge=1.0e-5, + test_points=4, + ), + ) catch { + _ => abort("Slingshot output should feed tradeSeq directly") + } + assert_eq(fit.n_cells, 15) + assert_eq(fit.n_lineages, slingshot.curves.length()) + assert_eq(fit.lineage_names[0], slingshot.curves[0].name) + for row in fit.cell_weights { + let mut total = 0.0 + for value in row { + total = total + value + } + assert_true((total - 1.0).abs() < 1.0e-10) + } +} + +///| +test "tradeSeq advanced SCE writes fitted assays and row statistics" { + let output = @src.tradeseq_advanced_sce( + tradeseq_adv_test_sce(), + config=tradeseq_adv_test_config(), + ) catch { + _ => abort("valid SCE trajectory should fit") + } + assert_eq(output.fit.n_genes, 5) + assert_eq(output.experiment.assays["tradeSeq.fitted"].length(), 5) + assert_eq(output.experiment.assays["tradeSeq.fitted"][0].length(), 24) + assert_eq( + output.experiment.row_data["tradeSeq.association.pvalue"].length(), + 5, + ) + assert_eq(output.experiment.row_data["tradeSeq.startVsEnd.padj"].length(), 5) + assert_eq(output.experiment.row_data["tradeSeq.dispersion"].length(), 5) + assert_eq(output.experiment.metadata["tradeSeq.nKnots"], "4") + assert_eq( + output.experiment.metadata["tradeSeq.lineages"], + "Lineage1,Lineage2", + ) +} + +///| +test "tradeSeq advanced SCE preserves input immutability" { + let experiment = tradeseq_adv_test_sce() + let output = @src.tradeseq_advanced_sce( + experiment, + config=tradeseq_adv_test_config(), + ) catch { + _ => abort("valid SCE trajectory should fit") + } + output.experiment.assays["counts"][0][0] = 99.0 + output.experiment.reduced_dims["slingshot.pseudotime"][0][0] = 99.0 + output.experiment.row_data["symbol"][0] = "changed" + output.experiment.col_data["batch"][0] = "changed" + assert_eq(experiment.assays["counts"][0][0], 10.0) + assert_eq(experiment.reduced_dims["slingshot.pseudotime"][0][0], 0.0) + assert_eq(experiment.row_data["symbol"][0], "F") + assert_eq(experiment.col_data["batch"][0], "one") + assert_false(experiment.assays.contains("tradeSeq.fitted")) +} + +///| +test "tradeSeq advanced SCE recursively copies alternative experiments" { + let experiment = tradeseq_adv_test_sce() + let output = @src.tradeseq_advanced_sce( + experiment, + config=tradeseq_adv_test_config(), + ) catch { + _ => abort("valid SCE trajectory should fit") + } + output.experiment.alternative_experiments["spike"].assays["counts"][0][0] = 8.0 + assert_eq( + experiment.alternative_experiments["spike"].assays["counts"][0][0], + 1.0, + ) +} + +///| +test "tradeSeq advanced SCE supports custom input and output names" { + let experiment = tradeseq_adv_test_sce() + experiment.assays["raw"] = experiment.assays["counts"].map(fn(row) { + row.copy() + }) + experiment.reduced_dims["ptime"] = experiment.reduced_dims["slingshot.pseudotime"].map(fn( + row, + ) { + row.copy() + }, + ) + experiment.reduced_dims["lineageWeight"] = experiment.reduced_dims["slingshot.weights"].map(fn( + row, + ) { + row.copy() + }, + ) + let output = @src.tradeseq_advanced_sce( + experiment, + assay_name="raw", + pseudotime_name="ptime", + weights_name="lineageWeight", + output_prefix="ts", + config=tradeseq_adv_test_config(), + ) catch { + _ => abort("custom SCE names should be supported") + } + assert_true(output.experiment.assays.contains("ts.fitted")) + assert_true(output.experiment.row_data.contains("ts.association.padj")) + assert_eq(output.experiment.metadata["ts.nKnots"], "4") +} + +///| +test "tradeSeq advanced SCE validates required entries and output prefix" { + let experiment = tradeseq_adv_test_sce() + let mut failures = 0 + ignore( + @src.tradeseq_advanced_sce( + experiment, + assay_name="missing", + config=tradeseq_adv_test_config(), + ), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.tradeseq_advanced_sce( + experiment, + pseudotime_name="missing", + config=tradeseq_adv_test_config(), + ), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.tradeseq_advanced_sce( + experiment, + weights_name="missing", + config=tradeseq_adv_test_config(), + ), + ) catch { + _ => failures = failures + 1 + } + ignore( + @src.tradeseq_advanced_sce( + experiment, + output_prefix=" ", + config=tradeseq_adv_test_config(), + ), + ) catch { + _ => failures = failures + 1 + } + assert_eq(failures, 4) +} + +///| +test "tradeSeq advanced summary reports fit dimensions" { + let summary = @src.tradeseq_advanced_summary(tradeseq_adv_test_fit()) + assert_true(summary.contains("tradeSeq 1.27.0 advanced fit")) + assert_true(summary.contains("genes: 5")) + assert_true(summary.contains("cells: 24")) + assert_true(summary.contains("lineages: 2")) + assert_true(summary.contains("knots: 4")) + assert_true(summary.contains("mean dispersion:")) +} From 8d650c90ff771672bd2ca94c6119b3deac608efc Mon Sep 17 00:00:00 2001 From: eda Date: Thu, 6 Aug 2026 18:30:14 +0800 Subject: [PATCH 35/41] #28 pass: 12093 feat: BLAST XML & CLUSTAL & PHYLIP & Mauve & PAML BASEML/CODEML/YN00 & Exonerate --- README.md | 183 +- examples/align_clustal_demo/main.mbt | 104 + examples/align_clustal_demo/moon.pkg | 5 + examples/align_mauve_demo/main.mbt | 106 + examples/align_mauve_demo/moon.pkg | 5 + examples/align_phylip_demo/main.mbt | 101 + examples/align_phylip_demo/moon.pkg | 5 + examples/blast_xml_advanced_demo/main.mbt | 167 ++ examples/blast_xml_advanced_demo/moon.pkg | 5 + examples/exonerate_text_demo/main.mbt | 91 + examples/exonerate_text_demo/moon.pkg | 5 + examples/paml_baseml_demo/main.mbt | 127 + examples/paml_baseml_demo/moon.pkg | 5 + examples/paml_codeml_demo/main.mbt | 114 + examples/paml_codeml_demo/moon.pkg | 5 + examples/paml_yn00_demo/main.mbt | 122 + examples/paml_yn00_demo/moon.pkg | 5 + src/align_clustal.mbt | 1363 +++++++++ src/align_mauve.mbt | 2107 ++++++++++++++ src/align_phylip.mbt | 1161 ++++++++ src/blast_xml_advanced.mbt | 3204 +++++++++++++++++++++ src/exonerate_text.mbt | 2217 ++++++++++++++ src/moon.pkg | 1 + src/paml_baseml.mbt | 1322 +++++++++ src/paml_codeml.mbt | 2497 ++++++++++++++++ src/paml_yn00.mbt | 1309 +++++++++ test/moonbit/align_clustal_test.mbt | 831 ++++++ test/moonbit/align_mauve_test.mbt | 717 +++++ test/moonbit/align_phylip_test.mbt | 740 +++++ test/moonbit/blast_xml_advanced_test.mbt | 987 +++++++ test/moonbit/exonerate_text_test.mbt | 861 ++++++ test/moonbit/paml_baseml_test.mbt | 691 +++++ test/moonbit/paml_codeml_test.mbt | 652 +++++ test/moonbit/paml_yn00_test.mbt | 782 +++++ 34 files changed, 22581 insertions(+), 16 deletions(-) create mode 100644 examples/align_clustal_demo/main.mbt create mode 100644 examples/align_clustal_demo/moon.pkg create mode 100644 examples/align_mauve_demo/main.mbt create mode 100644 examples/align_mauve_demo/moon.pkg create mode 100644 examples/align_phylip_demo/main.mbt create mode 100644 examples/align_phylip_demo/moon.pkg create mode 100644 examples/blast_xml_advanced_demo/main.mbt create mode 100644 examples/blast_xml_advanced_demo/moon.pkg create mode 100644 examples/exonerate_text_demo/main.mbt create mode 100644 examples/exonerate_text_demo/moon.pkg create mode 100644 examples/paml_baseml_demo/main.mbt create mode 100644 examples/paml_baseml_demo/moon.pkg create mode 100644 examples/paml_codeml_demo/main.mbt create mode 100644 examples/paml_codeml_demo/moon.pkg create mode 100644 examples/paml_yn00_demo/main.mbt create mode 100644 examples/paml_yn00_demo/moon.pkg create mode 100644 src/align_clustal.mbt create mode 100644 src/align_mauve.mbt create mode 100644 src/align_phylip.mbt create mode 100644 src/blast_xml_advanced.mbt create mode 100644 src/exonerate_text.mbt create mode 100644 src/paml_baseml.mbt create mode 100644 src/paml_codeml.mbt create mode 100644 src/paml_yn00.mbt create mode 100644 test/moonbit/align_clustal_test.mbt create mode 100644 test/moonbit/align_mauve_test.mbt create mode 100644 test/moonbit/align_phylip_test.mbt create mode 100644 test/moonbit/blast_xml_advanced_test.mbt create mode 100644 test/moonbit/exonerate_text_test.mbt create mode 100644 test/moonbit/paml_baseml_test.mbt create mode 100644 test/moonbit/paml_codeml_test.mbt create mode 100644 test/moonbit/paml_yn00_test.mbt diff --git a/README.md b/README.md index 15050c18..b7b29bb4 100644 --- a/README.md +++ b/README.md @@ -29,7 +29,8 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **序列处理** | Biopython `Bio.Seq` | 序列对象、**MutableSeq可变序列**、互补、转录、翻译、序列特征 | ✅ | | **序列 I/O** | Biopython `Bio.SeqIO` | FASTA/FASTQ/GenBank 解析与写入 | ✅ | | **序列比对** | Biopython / scikit-bio | Needleman-Wunsch、Smith-Waterman、多序列比对、替换矩阵(BLOSUM/PAM) | ✅ | -| **BLAST解析** | Biopython `Bio.Blast` | BLAST结果解析、tabular/xml格式、HSP过滤、最佳匹配 | ✅ | +| **BLAST基础解析** | BioSeqs compatibility API | 历史tabular/XML标签解析、HSP过滤与最佳匹配 | ✅ | +| **现代BLAST XML** | Biopython `Bio.Blast` | XML1/XML2严格解析与规范写回、多query/report、参数/统计、描述与taxonomy、八类程序的链向/translated坐标路径 | ✅ | | **SearchIO** | Biopython `Bio.SearchIO` | 统一搜索结果模型、HMMER3/Infernal解析、BLAT PSL解析、BLAST转换 | ✅ | | **HH-suite HHR** | Biopython `Bio.Align.hhr` | HHsearch/HHblits HHR解析、profile-profile比对、命中筛选、坐标映射、序列化往返 | ✅ | | **共享参考比对合并** | Biopython `Bio.Align.Alignment` | 合并共享同一参考序列的PWA/MSA、同步insertion slots、保留局部坐标与metadata、双向坐标映射 | ✅ | @@ -39,6 +40,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **A2M状态感知多序列比对** | Biopython `Bio.Align.a2m` | match/insertion列状态、大小写与点语义、严格读写、坐标映射、插入槽、统计、共识及match-only投影 | ✅ | | **EMBOSS alignment输出** | Biopython `Bio.Align.emboss` | srspair/pair/simple报告、多alignment与多序列、局部/反向坐标、consensus统计、坐标路径及规范往返 | ✅ | | **Exonerate alignment输出** | Biopython `Bio.Align.exonerate` | cigar/vulgar严格读写、完整operation path、正反链与protein strand、3:1 translated坐标、双向映射及规范往返 | ✅ | +| **Exonerate C4文本报告** | Biopython `Bio.SearchIO.ExonerateIO.exonerate_text` | C4层次结果、3/4/5行模型、wrapped blocks、intron/NER/split codon/frameshift、蛋白质翻译与链感知坐标 | ✅ | | **GCG MSF多序列比对** | Biopython `Bio.Align.msf` | AA/NA/PileUp严格解析、interleaved rows、标准GCG checksum、gap规范化、坐标路径、统计及canonical writer | ✅ | | **NEXUS多序列比对** | Biopython `Bio.Align.nexus` | DATA/CHARACTERS/TAXA、nested comments、quoted taxa、sequential/interleaved MATRIX、MATCHCHAR、坐标统计及canonical writer | ✅ | | **Stockholm注释型多序列比对** | Biopython `Bio.Align.stockholm` | 多记录严格读写、GF/GS/GR/GC、reference与database reference、insertion/deletion列、all-gap压缩、坐标统计及canonical writer | ✅ | @@ -88,7 +90,10 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | Bio.Align.MAF | 宽松MAF块解析、选择/过滤、百分比一致性、统计分析与格式转换 | | ✅ | Bio.Align.maf | 现代MAF document/track、严格a/s/i/e/q、绝对坐标路径、component映射、参考区间索引、多外显子拼接与规范往返 | | ✅ | Bio.Align.bed | BED3-BED12 pairwise alignment、双轴链向坐标、block投影、双向residue映射、区间搜索与分级写回 | -| ✅ | Bio.Align.Mauve | Mauve 基因组比对格式解析、LCB(共线性块)检测、倒位检测、断点检测、基因组覆盖率、BED导出 | +| ✅ | Bio.Align.Mauve (legacy) | 历史 MAF-like 块的 LCB 重排摘要、倒位/断点检测、覆盖率与 BED 导出 | +| ✅ | Bio.Align.mauve | 现代 XMFA header/LCB 严格读写、combined/separate source、正负链坐标路径、索引、跨序列投影、统计与序列重建 | +| ✅ | Bio.Align.clustal | 现代CLUSTAL metadata与interleaved block严格读写、累计残基数、consensus、坐标路径、跨行投影、统计与规范写回 | +| ✅ | Bio.Blast XML | XML1/XML2 document/record/hit/HSP模型、多描述与taxonomy、Karlin-Altschul统计、frame/strand及1:1/3:1坐标路径、规范往返 | | ✅ | Bio.Stockholm | Stockholm 格式解析 (Pfam/Rfam比对格式)、二级结构注释、百分比一致性、保守性分析、FASTA转换 | | ✅ | Bio.PopGen (advanced) | 高级群体遗传学统计: Tajima's D, Fu & Li's D/F, McDonald-Kreitman检验, 等位基因频率谱, 中性分析 | | ✅ | Bio.SeqUtils.CodonUsage (advanced) | 高级密码子分析: CAI密码子适应指数、RSCU相对同义密码子使用、ENC有效密码子数、GC3偏斜、最优/稀有密码子检测 | @@ -168,6 +173,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | ✅ | velociraptor | 单细胞RNA velocity分析: 稳态线性回归(gamma/beta比估计)、EM算法动力学模型(alpha/beta/gamma参数估计)、velocity向量计算、KNN加权嵌入投影、根细胞识别 | | ✅ | Bio.Compass | COMPASS profile-profile比对输出解析: 版本提取、多记录解析(SW分数/E值/百分比一致性/比对序列)、E值与一致性过滤、比对长度统计、摘要生成 | | ✅ | Bio.SearchIO.ExonerateIO | Exonerate比对输出解析: vulgar格式解析(比对块三元组)、cigar格式解析、格式自动检测、分数过滤、内含子统计、vulgar/cigar字符串重建 | +| ✅ | Bio.SearchIO.ExonerateIO.exonerate_text | Exonerate C4人类可读报告: Document/Query/Hit/HSP/Fragment层次、3/4/5行模型、wrapped block拼接、intron/NER/split codon/frameshift、翻译与坐标投影 | | ✅ | Bio.PDB.mmcifio | mmCIF文件写入: Structure对象序列化(data block/header/atom_site loop)、20列原子坐标格式化、HETATM支持、值转义、round-trip验证 | | ✅ | Bio.SearchIO.InterproscanIO | InterProScan输出解析: TSV 14列格式解析(蛋白质ID/分析数据库/签名/位置/分数/IPR/GO)、按数据库/蛋白质过滤、GO条目提取、按蛋白质分组 | | ✅ | Bio.SearchIO.InfernalIO | Infernal cmscan/cmsearch解析: tabular格式1/2/3自动检测、non-verbose文本与--noali、CM/HMM-only、Query/Hit/HSP/Fragment层次、正负链坐标、local-end多片段、过滤与SearchIO转换 | @@ -259,6 +265,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **A2M状态感知比对** | Biopython `Bio.Align.a2m` | D/I列状态、大小写与点gap编码、wrapped/CRLF读写、坐标互映、插入槽、统计、共识与match投影 | ✅ | | **EMBOSS alignment报告** | Biopython `Bio.Align.emboss` | srspair/pair/simple元数据、固定列block、多alignment/多序列、正反向绝对坐标、pair counts与canonical writer | ✅ | | **Exonerate alignment报告** | Biopython `Bio.Align.exonerate` | header/footer与cigar/vulgar、operation normalization、链感知绝对路径、protein-DNA 3:1映射、统计与canonical writer | ✅ | +| **Exonerate C4 SearchIO报告** | Biopython `Bio.SearchIO.ExonerateIO.exonerate_text` | metadata与查询层次、固定列alignment body、剪接/NER/frameshift语义、phase/frame及双轴区间 | ✅ | | **GCG MSF alignment** | Biopython `Bio.Align.msf` | AA/NA/PileUp header、Name metadata、interleaved blocks、GCG checksum、三类gap、coordinate path、pair counts与writer | ✅ | | **NEXUS alignment** | Biopython `Bio.Align.nexus` | DATA/CHARACTERS/TAXA block、quote/comment词法、sequential/interleaved rows、DNA/RNA/protein/standard校验、MATCHCHAR、坐标与writer | ✅ | | **Stockholm alignment** | Biopython `Bio.Align.stockholm` | 严格header/terminator与多记录、GF/GS/GR/GC映射、M/D/I操作、all-gap列压缩、reference、坐标、统计与writer | ✅ | @@ -271,7 +278,10 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **zinbwave** | Bioconductor zinbwave | 零膨胀负二项低维模型、cell/gene协变量与offset、确定性latent factors、dispersion shrinkage、observational weights、残差/归一化/插补及SCE集成 | ✅ | | **apeglm** | Bioconductor apeglm | 负二项GLM、自适应经验贝叶斯Cauchy/Student-t先验、确定性多起点MAP、Laplace后验SD/区间、FSR/FSOS/s-value、DESeq2与SummarizedExperiment接入 | ✅ | | **Prosite** | Biopython `Bio.Prosite` | 蛋白质模体数据库搜索、Prosite模式解析、模体匹配算法、模体得分计算 | ✅ | -| **PAML** | Biopython `Bio.PAML` | 分子进化分析、dN/dS计算（Nei-Gojobori方法）、Jukes-Cantor校正、密码子使用分析 | ✅ | +| **PAML内置近似兼容层** | BioSeqs compatibility API | Nei-Gojobori风格dN/dS、Jukes-Cantor校正和密码子使用分析；不解析PAML控制文件或原生输出 | ✅ | +| **CODEML控制与结果分析** | Biopython `Bio.Phylo.PAML.codeml` | 严格control读写、CODONML/AAML、多NSsites/branch-site/clade/free-ratio、pairwise、距离矩阵、多基因、BEB/NEB及AIC/BIC/LRT | ✅ | +| **BASEML核苷酸模型分析** | Biopython `Bio.Phylo.PAML.baseml` | 严格control读写、JC69至UNRESTu、参数/SE、kappa、REV/UNREST Q矩阵、rate-class、auto-dGamma、nhomo节点及AIC/BIC/LRT | ✅ | +| **YN00成对密码子替换分析** | Biopython `Bio.Phylo.PAML.yn00` | 严格control读写、NG86/YN00/LWL85/LWL85m/LPB93、PAML 4.1-4.9i兼容、非有限值、对称矩阵及统计汇总 | ✅ | | **Graphics** | Biopython `Bio.Graphics` | 生物信息学可视化、序列Logo绘制、序列比对可视化、基因组特征绘图 | ✅ | | **BSgenome** | Bioconductor BSgenome | 基因组序列数据库、染色体序列检索、子序列提取、链特异性基因提取 | ✅ | | **biomaRt** | Bioconductor biomaRt | 基因ID映射、基因注释查询、批量查询、外部数据库映射 | ✅ | @@ -426,6 +436,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **A2M状态感知MSA** | Biopython `Bio.Align.a2m` | match/deletion与insertion列、canonical大小写/点编码、严格往返、坐标映射、插入槽、统计与共识 | ✅ | | **EMBOSS alignment output** | Biopython `Bio.Align.emboss` | water/needle/stretcher/matcher/alignret输出、srspair/pair/simple、metadata、consensus、局部/反向坐标与严格诊断 | ✅ | | **Exonerate alignment output** | Biopython `Bio.Align.exonerate` | cigar/vulgar报告、M/5/I/3/C/G/N/S/F路径、正反链与protein strand、translated coordinates、严格诊断与双格式写回 | ✅ | +| **Exonerate C4 text output** | Biopython `Bio.SearchIO.ExonerateIO.exonerate_text` | C4 alignment text、query/hit/HSP/fragment聚合、intron/NER/split codon/frameshift、translated coordinates与严格诊断 | ✅ | | **GCG MSF alignment format** | Biopython `Bio.Align.msf` | protein/nucleotide MSF、PileUp与EMBOSS变体、interleaved MSA、GCG checksum、坐标和统计、严格读写 | ✅ | | **NEXUS alignment format** | Biopython `Bio.Align.nexus` | NEXUS header与block、nested comments、quoted taxa、sequential/interleaved MATRIX、MATCHCHAR、all-gap压缩、坐标统计与严格读写 | ✅ | | **Stockholm alignment format** | Biopython `Bio.Align.stockholm` | 多记录严格解析、GF/GS/GR/GC与自定义注释、reference与database reference、insertion/deletion列、all-gap压缩、坐标统计与严格写回 | ✅ | @@ -437,7 +448,9 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **GenomicRanges gaps/reduce/disjoin** | Bioconductor GenomicRanges | gaps检测、reduce合并、disjoin拆分、setdiff/交集/并集集合运算、coverage计算、promoters提取、trim | ✅ | | **GenomicRanges GRangesList** | Bioconductor GenomicRanges | 命名复合基因组特征、split/unlist/relist、逐组区间变换、并行集合运算、特征级重叠/最近邻/覆盖度 | ✅ | | **NGS质量修剪与接头去除** | Bioconductor ShortRead | 质量修剪(滑动窗口)、接头去除、poly-A修剪、长度/GC含量过滤、批量修剪、Fastq解析与序列化、统计计算 | ✅ | -| **Mauve基因组比对** | Biopython `Bio.Align` | Mauve基因组比对格式、LCB检测、倒位/断点检测、覆盖率分析、BED导出、基因组重排率 | ✅ | +| **Mauve重排分析（legacy）** | BioSeqs compatibility API | 历史 MAF-like 块、LCB检测、倒位/断点检测、覆盖率、BED导出与重排率 | ✅ | +| **XMFA多基因组比对** | Biopython `Bio.Align.mauve` | `#SequenceN*` metadata、LCB、正负链坐标、区间索引、跨序列位置/区间投影、统计、重建与规范写回 | ✅ | +| **BLAST XML1/XML2** | Biopython `Bio.Blast` | 严格XML树解析、多query与XML2多report、HitDescr/taxonomy、参数与统计、八类BLAST坐标语义、canonical writer与显式跨格式转换 | ✅ | | **Stockholm格式** | Biopython `Bio.Stockholm` | Stockholm/Pfam格式解析、二级结构注释、百分比一致性、保守性、FASTA/Stockholm互转 | ✅ | | **高级群体遗传学** | Biopython `Bio.PopGen` | Tajima's D中性检验、Fu & Li's D/F、McDonald-Kreitman检验、等位基因频率谱、综合中性分析 | ✅ | | **高级密码子分析** | Biopython `Bio.SeqUtils.CodonUsage` | CAI密码子适应指数、RSCU相对同义密码子使用、ENC有效密码子数、GC3偏斜、最优/稀有密码子、物种特异性参考表 | ✅ | @@ -501,6 +514,9 @@ IvanAXu/BioSeqs/ │ ├── align_stockholm.mbt # Bio.Align.stockholm GF/GS/GR/GC、多记录、列操作、坐标统计与写回 │ ├── align_chain.mbt # Bio.Align.chain严格读写、双轴链向绝对路径、block重建与坐标映射 │ ├── align_maf.mbt # Bio.Align.maf严格文档读写、绝对坐标、MafIndex查询与多外显子拼接 +│ ├── align_mauve.mbt # Bio.Align.mauve现代XMFA文档、LCB、双向坐标、索引、投影与规范写回 +│ ├── align_clustal.mbt # Bio.Align.clustal现代MSA metadata、consensus、坐标、统计与规范写回 +│ ├── align_phylip.mbt # Bio.Align.phylip现代sequential/interleaved MSA、坐标、统计与规范写回 │ ├── align_bed.mbt # Bio.Align.bed BED3-BED12、双轴路径、block投影、坐标映射与分级写回 │ ├── bigbed.mbt # Bio.Align.bigbed v4、BED/AutoSQL、多级B+ tree/R-tree与DEFLATE │ ├── bigmaf.mbt # Bio.Align.bigmaf bedMaf、MAF注释、链向坐标映射与索引查询 @@ -517,6 +533,7 @@ IvanAXu/BioSeqs/ │ ├── phylo.mbt # 系统发育树 (Clade/Tree) │ ├── tree_io.mbt # 进化树格式解析 (Newick、NHX格式解析、树操作) │ ├── blast.mbt # BLAST结果解析 (tabular/xml格式、HSP、Hit、Record、过滤) +│ ├── blast_xml_advanced.mbt # Bio.Blast XML1/XML2严格解析、坐标路径、查询分析与规范写回 │ ├── searchio.mbt # SearchIO 统一搜索结果模型 (HSPFragment、HSP、Hit、QueryResult、HMMER3/BLAT解析) │ ├── search_io.mbt # SearchIO 统一搜索结果模型 (HMMER3解析、BLAT PSL解析、BLAST转换) │ ├── subsmat.mbt # 替换矩阵 (BLOSUM62/45、PAM250/30、矩阵解析、分数查询) @@ -580,7 +597,10 @@ IvanAXu/BioSeqs/ │ ├── de_bruijn.mbt # De Bruijn Graph (k-mer节点、欧拉路径、序列组装、图简化) │ ├── suffix_array_tree.mbt # Suffix Array & Suffix Tree (前缀倍增、LCP数组、模式匹配、最长重复子串) │ ├── olc.mbt # Overlap-Layout-Consensus (重叠检测、哈密顿路径、一致性序列生成) -│ ├── paml.mbt # Bio.PAML 分子进化分析 (dN/dS、Jukes-Cantor校正) +│ ├── paml.mbt # 历史内置近似API (Nei-Gojobori风格dN/dS、Jukes-Cantor校正) +│ ├── paml_codeml.mbt # Bio.Phylo.PAML.codeml control/CODONML/AAML解析与模型比较 +│ ├── paml_baseml.mbt # Bio.Phylo.PAML.baseml control/核苷酸模型结果与统计比较 +│ ├── paml_yn00.mbt # Bio.Phylo.PAML.yn00 control与五种成对密码子替换估计 │ ├── hmm.mbt # Hidden Markov Model (前向/后向算法、维特比算法、Baum-Welch训练、基因预测) │ ├── kmeans.mbt # K-means Clustering (距离计算、K-means++初始化、聚类、轮廓系数评估) │ ├── kmer.mbt # Bio.Kmer k-mer计数与频率分析 @@ -756,7 +776,7 @@ IvanAXu/BioSeqs/ │ ├── ggtree.mbt # ggtree 系统发育树可视化布局 (矩形/放射状/无根布局、节点坐标映射) │ ├── mix_omics.mbt # mixOmics 多组学整合 (PLS/sPLS/DIABLO) │ ├── maf.mbt # 早期宽松MAF块解析、选择、过滤与统计分析 -│ ├── mauve.mbt # Mauve 基因组比对格式解析与重排分析 +│ ├── mauve.mbt # 历史MAF-like块兼容解析与LCB重排分析（非现代XMFA） │ ├── stockholm.mbt # Stockholm 格式解析 (Pfam/Rfam比对) 与二级结构分析 │ ├── popgen_advanced.mbt # 高级群体遗传学统计 (Tajima's D, Fu & Li's D/F, MK检验) │ ├── codon_advanced.mbt # 高级密码子分析 (CAI, RSCU, ENC, GC3) @@ -838,6 +858,7 @@ IvanAXu/BioSeqs/ │ ├── velociraptor.mbt # velociraptor 单细胞RNA velocity (稳态回归、EM动力学模型、velocity向量、KNN嵌入投影) │ ├── compass.mbt # Bio.Compass COMPASS profile-profile比对输出解析 (版本提取、多记录解析、E值/一致性过滤、摘要) │ ├── exonerate.mbt # Bio.SearchIO.ExonerateIO Exonerate输出解析 (vulgar/cigar格式、比对块解析、内含子统计、字符串重建) +│ ├── exonerate_text.mbt # Bio.SearchIO.ExonerateIO C4文本报告、层次结果、剪接/翻译语义与坐标投影 │ ├── mmcifio.mbt # Bio.PDB.mmcifio mmCIF文件写入 (Structure序列化、20列atom_site loop、HETATM支持、值转义) │ ├── interproscan.mbt # Bio.SearchIO.InterproscanIO InterProScan输出解析 (TSV 14列、数据库/蛋白质过滤、GO提取、分组) │ ├── sasa.mbt # Bio.PDB.SASA 溶剂可及表面积 (Shrake-Rupley滚动球、Fibonacci球面采样、VDW半径、骨架/侧链拆分) @@ -953,7 +974,11 @@ IvanAXu/BioSeqs/ │ ├── neighbor_search_demo/ # NeighborSearch KD树近邻搜索示例 (半径搜索、最近邻、原子对搜索) │ ├── nexus_demo/ # Nexus格式解析示例 (数据矩阵、系统发育树、距离矩阵) │ ├── olc_demo/ # Overlap-Layout-Consensus 序列组装示例 -│ ├── paml_demo/ # Bio.PAML 分子进化分析示例 +│ ├── paml_demo/ # 历史内置近似dN/dS示例 +│ ├── paml_codeml_demo/ # CODEML control/result解析、BEB与模型比较示例 +│ ├── paml_baseml_demo/ # BASEML control、REV矩阵、离散gamma与LRT示例 +│ ├── paml_yn00_demo/ # YN00 control、五种估计、对称矩阵与汇总示例 +│ ├── blast_xml_advanced_demo/ # BLAST XML1/XML2、命中/HSP、translated坐标与规范往返示例 │ ├── pdb_analysis_demo/ # PDB 高级结构分析示例 (主链二面角、氢键检测、二级结构分配、Ramachandran图、SASA计算、疏水性分析) │ ├── pdb_demo/ # PDB 结构解析示例 │ ├── pdb_list_demo/ # Bio.PDB.PDBList PDB结构下载管理示例 @@ -1107,7 +1132,7 @@ IvanAXu/BioSeqs/ │ ├── ggtree_demo/ # ggtree 系统发育树可视化示例 (矩形/放射状/无根布局、节点坐标) │ ├── mix_omics_demo/ # mixOmics 多组学整合演示 │ ├── maf_demo/ # MAF 格式解析与分析示例 (解析、统计、选择、过滤、写回) -│ ├── mauve_demo/ # Mauve 基因组比对分析示例 (倒位检测、断点检测、覆盖率、BED导出) +│ ├── mauve_demo/ # 历史MAF-like块重排分析示例 (倒位检测、断点检测、覆盖率、BED导出) │ ├── stockholm_demo/ # Stockholm 格式解析示例 (Pfam/Rfam格式、二级结构、保守性分析) │ ├── popgen_advanced_demo/ # 高级群体遗传学示例 (Tajima's D、Fu & Li、MK检验、中性分析) │ ├── codon_advanced_demo/ # 高级密码子分析示例 (CAI、RSCU、ENC、最优/稀有密码子) @@ -1195,6 +1220,7 @@ IvanAXu/BioSeqs/ │ ├── velociraptor_demo/ # velociraptor RNA velocity示例 (稳态/动力学模型、velocity向量、嵌入投影、根细胞识别) │ ├── compass_demo/ # Bio.Compass COMPASS比对输出解析示例 (profile-profile比对解析、E值过滤、摘要) │ ├── exonerate_demo/ # Bio.SearchIO.ExonerateIO Exonerate输出解析示例 (vulgar/cigar解析、内含子统计、字符串重建) +│ ├── exonerate_text_demo/ # Exonerate C4层次结果、fragment坐标、intron区间与统计的离线示例 │ ├── mmcifio_demo/ # Bio.PDB.mmcifio mmCIF写入示例 (Structure序列化、atom_site loop、round-trip验证) │ ├── interproscan_demo/ # Bio.SearchIO.InterproscanIO InterProScan解析示例 (TSV解析、数据库过滤、GO条目、分组) │ ├── sasa_demo/ # Bio.PDB.SASA 溶剂可及表面积示例 (Shrake-Rupley算法、逐原子/残基SASA、骨架/侧链拆分) @@ -1239,6 +1265,9 @@ IvanAXu/BioSeqs/ │ ├── align_stockholm_demo/ # Stockholm GF/GS/GR/GC、insertion列、坐标统计、all-gap压缩与规范往返示例 │ ├── align_chain_demo/ # Chain多记录、正反链路径、block/counts、坐标映射、反转与规范往返示例 │ ├── align_maf_demo/ # MAF track/a/s/i/e/q、绝对路径、component映射、索引、拼接与规范往返示例 +│ ├── align_mauve_demo/ # XMFA metadata/LCB、正负链路径、统计、索引、投影、重建与规范往返示例 +│ ├── align_clustal_demo/ # CLUSTAL metadata、consensus、坐标路径、投影、统计与累计计数往返示例 +│ ├── align_phylip_demo/ # PHYLIP布局识别、名称规范化、坐标、统计及两种布局往返示例 │ ├── align_bed_demo/ # BED3-BED12、正负链路径、block、坐标映射、搜索、统计与规范往返示例 │ ├── bigbed_demo/ # BigBed写入/解析、索引查询、负链exon坐标、BED导出与损坏诊断 │ ├── bigmaf_demo/ # BigMaf压缩写入、bedMaf schema、区间查询、负链映射与MAF导出 @@ -1263,6 +1292,7 @@ IvanAXu/BioSeqs/ │ │ ├── bio_seq_wb_test.mbt │ │ ├── biostrings_test.mbt │ │ ├── blast_test.mbt +│ │ ├── blast_xml_advanced_test.mbt │ │ ├── bloom_filter_test.mbt │ │ ├── bwt_fm_test.mbt │ │ ├── cluster_test.mbt @@ -1411,6 +1441,9 @@ IvanAXu/BioSeqs/ │ │ ├── nexus_test.mbt │ │ ├── nucle_r_test.mbt │ │ ├── paml_test.mbt +│ │ ├── paml_codeml_test.mbt +│ │ ├── paml_baseml_test.mbt +│ │ ├── paml_yn00_test.mbt │ │ ├── pathway_test.mbt │ │ ├── pdb_analysis_test.mbt │ │ ├── pdb_dice_test.mbt @@ -1466,11 +1499,15 @@ IvanAXu/BioSeqs/ │ │ ├── a2m_test.mbt │ │ ├── align_emboss_test.mbt │ │ ├── align_exonerate_test.mbt +│ │ ├── exonerate_text_test.mbt │ │ ├── msf_test.mbt │ │ ├── align_nexus_test.mbt │ │ ├── align_stockholm_test.mbt │ │ ├── align_chain_test.mbt │ │ ├── align_maf_test.mbt +│ │ ├── align_mauve_test.mbt +│ │ ├── align_clustal_test.mbt +│ │ ├── align_phylip_test.mbt │ │ ├── align_bed_test.mbt │ │ ├── bigbed_test.mbt │ │ ├── bigmaf_test.mbt @@ -1654,7 +1691,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 11572 个测试全部通过 +moon test # ✅ 12093 个测试全部通过 ``` ### 模块对照表 @@ -1691,13 +1728,17 @@ moon test # ✅ 11572 个测试全 | `alignio.mbt` | BioPython `Bio.AlignIO` | 比对文件 I/O | | `align_io.mbt` | BioPython `Bio.AlignIO` | ClustalW/FASTA/Stockholm 解析 | | `clustal_io.mbt` | BioPython `Bio.AlignIO.ClustalIO` | Clustal 格式 | +| `align_clustal.mbt` | BioPython `Bio.Align.clustal` | 现代CLUSTAL generator metadata、严格interleaved blocks、consensus、coordinate path、统计与canonical writer | | `phylip_io.mbt` | BioPython `Bio.AlignIO.PhylipIO` | PHYLIP 格式 | +| `align_phylip.mbt` | BioPython `Bio.Align.phylip` | 现代PHYLIP严格header与固定宽度名称、sequential/interleaved自动识别、coordinate path、统计及canonical writer | | `subsmat.mbt` | BioPython `Bio.SubsMat` | BLOSUM/PAM 替换矩阵 | | `substitution_matrices.mbt` | BioPython `Bio.Align.substitution_matrices` | 现代替换矩阵基础设施 (ArrayData、矩阵注册表、频率矩阵、log-odds、Shannon熵、KL散度) | | `align_info.mbt` | BioPython `Bio.Align.AlignInfo` | 比对统计与一致性序列 | | `align_abstract.mbt` | BioPython `Bio.Align.AlignAbstract` | 抽象比对类型、Shannon熵、同一性矩阵、简约信息位点 | | `codon_align.mbt` | BioPython `Bio.codonalign` | 密码子比对与 dN/dS 分析 | | `searchio.mbt` | BioPython `Bio.SearchIO` | 统一搜索结果模型、BLAST/HMMER解析、E-value过滤 | +| `blast_xml_advanced.mbt` | BioPython `Bio.Blast` | XML1/XML2类型化文档、严格parser/writer、多query/report、parameters/statistics、description/taxonomy及链向/translated HSP坐标 | +| `exonerate_text.mbt` | BioPython `Bio.SearchIO.ExonerateIO.exonerate_text` | C4文本Document/Query/Hit/HSP/Fragment层次、3/4/5行模型、剪接/NER/frameshift和链感知坐标 | | `hhr.mbt` | BioPython `Bio.Align.hhr` | HHsearch/HHblits HHR解析、profile比对注释、命中筛选、坐标映射与规范序列化 | | `shared_reference_alignment.mbt` | BioPython `Bio.Align.Alignment.from_alignments_with_same_reference` | 共享参考PWA/MSA合并、insertion slot同步、局部坐标、双向映射、统计、MSA与FASTA转换 | | `alignment_map.mbt` | BioPython `Bio.Align.Alignment.map/mapall` | alignment path组合、local clipping、gap与链向传播、双向坐标查询、PSL、map_many及codon-aware MSA投影 | @@ -1713,6 +1754,7 @@ moon test # ✅ 11572 个测试全 | `align_stockholm.mbt` | BioPython `Bio.Align.stockholm` | 严格多记录Stockholm读写、GF/GS/GR/GC映射、reference与database reference、M/D/I列、all-gap压缩、坐标统计和canonical writer | | `align_chain.mbt` | BioPython `Bio.Align.chain` | UCSC Chain 12/13字段header与size/dt/dq严格读写、双轴正反链absolute path、坐标映射、反转、ID/overlap查询与canonical writer | | `align_maf.mbt` | BioPython `Bio.Align.maf` | MAF document/track与a/s/i/e/q严格读写、链感知absolute path、component映射、MafIndex半开查询、多外显子拼接与canonical writer | +| `align_mauve.mbt` | BioPython `Bio.Align.mauve` | 现代XMFA header与LCB严格读写、combined/separate source、正负链coordinate path、区间索引、位置/区间投影、统计及重建 | | `align_bed.mbt` | BioPython `Bio.Align.bed` | BED3-BED12 pairwise alignment读写、numeric/text score、链感知target/query path、blocks、双向映射、区间查询与分级writer | | `bigbed.mbt` | BioPython `Bio.Align.bigbed` | BigBed v4读写、BED3-BED12、AutoSQL、多级chromosome B+ tree/R-tree、zlib/DEFLATE及索引查询 | | `bigmaf.mbt` | BioPython `Bio.Align.bigmaf` | bedMaf bed3+1读写、MAF a/s/i/e/q、正负链坐标映射、压缩索引查询、摘要和MAF导出 | @@ -1726,6 +1768,10 @@ moon test # ✅ 11572 个测试全 | `tree_io.mbt` | BioPython `Bio.TreeIO` | Newick/NHX 格式解析 | | `tree_construction.mbt` | BioPython `Bio.Phylo.TreeConstruction` | UPGMA/WPGMA/NJ 建树算法 | | `phylo_xml.mbt` | BioPython `Bio.Phylo.PhyloXML` | PhyloXML格式解析、序列化、Newick双向转换、分类单元注释 | +| `paml.mbt` | BioSeqs compatibility API | 内置Nei-Gojobori风格dN/dS与Jukes-Cantor近似；不运行或解析PAML | +| `paml_codeml.mbt` | BioPython `Bio.Phylo.PAML.codeml` | CODEML control规范读写、CODONML/AAML结果、分支/位点/多基因模型与AIC/BIC/LRT | +| `paml_baseml.mbt` | BioPython `Bio.Phylo.PAML.baseml` | BASEML control规范读写、11类核苷酸模型、Q/率类别/非齐次节点结果与AIC/BIC/LRT | +| `paml_yn00.mbt` | BioPython `Bio.Phylo.PAML.yn00` | YN00 control规范读写、五种成对估计、跨版本解析、对称矩阵与均值 | #### 结构生物学 @@ -1823,7 +1869,8 @@ moon test # ✅ 11572 个测试全 | MoonBit 文件 | 对应 Python 库 | 核心功能 | | :--- | :--- | :--- | -| `blast.mbt` | BioPython `Bio.Blast` | BLAST 结果解析 | +| `blast.mbt` | BioSeqs compatibility API | 历史BLAST tabular/XML基础解析 | +| `blast_xml_advanced.mbt` | BioPython `Bio.Blast` | BLAST XML1/XML2严格解析、八类程序坐标语义、多report与规范写回 | | `search_io.mbt` | BioPython `Bio.SearchIO` | 统一搜索结果模型 | | `kegg.mbt` | BioPython `Bio.KEGG` | KEGG 数据库解析 | | `medline.mbt` | BioPython `Bio.Medline` | Medline/PubMed 解析 | @@ -1958,7 +2005,13 @@ moon test # ✅ 11572 个测试全 | `maf.mbt` | BioPython `Bio.Align` | 早期宽松MAF块解析与分析 (块处理、百分比一致性、统计分析、选择/过滤) | | `align_maf.mbt` | BioPython `Bio.Align.maf` | 现代MAF文档、严格a/s/i/e/q、绝对坐标路径、reference index、多外显子拼接与规范写回 | | `align_bed.mbt` | BioPython `Bio.Align.bed` | 现代BED pairwise alignment、正负链transcript路径、exon block、坐标映射、搜索、统计与BED3-BED12写回 | -| `mauve.mbt` | BioPython `Bio.Align` | Mauve基因组比对格式解析 (LCB检测、倒位/断点、覆盖率、BED导出) | +| `mauve.mbt` | BioSeqs compatibility API | 历史MAF-like块解析与LCB重排分析（倒位/断点、覆盖率、BED导出；不解析现代XMFA） | +| `align_mauve.mbt` | BioPython `Bio.Align.mauve` | 现代XMFA文档、严格header/LCB、双向坐标路径、索引、跨序列投影、统计、重建与规范写回 | +| `align_clustal.mbt` | BioPython `Bio.Align.clustal` | 现代CLUSTAL alignment、严格block顺序和累计计数、列注释、坐标映射、统计与规范写回 | +| `align_phylip.mbt` | BioPython `Bio.Align.phylip` | 现代PHYLIP alignment、wrapped sequential/interleaved blocks、10列名称规范化、坐标映射、统计与规范写回 | +| `exonerate_text.mbt` | BioPython `Bio.SearchIO.ExonerateIO.exonerate_text` | Exonerate C4固定列alignment text、层次聚合、wrapped blocks、intron/NER/split codon/frameshift及坐标投影 | +| `blast.mbt` | BioSeqs compatibility API | 历史BLAST tabular/XML标签解析、HSP过滤与最佳匹配 | +| `blast_xml_advanced.mbt` | BioPython `Bio.Blast` | XML1/XML2 document/record/hit/HSP模型、严格结构与数值校验、1:1/3:1坐标、查询分析及canonical writer | | `stockholm.mbt` | BioPython `Bio.Stockholm` | Stockholm格式解析与分析 (Pfam/Rfam格式、二级结构、保守性、FASTA转换) | | `popgen_advanced.mbt` | BioPython `Bio.PopGen` | 高级群体遗传学统计 (Tajima's D、Fu & Li's D/F、MK检验、等位基因频率谱) | | `codon_advanced.mbt` | BioPython `Bio.SeqUtils.CodonUsage` | 高级密码子分析 (CAI、RSCU、ENC、GC3、物种特异性参考表) | @@ -2028,15 +2081,24 @@ moon test # ✅ 11572 个测试全 | `a2m.mbt` | `Bio.Align.a2m` | match/insertion状态模型、canonical字符编码、wrapped/CRLF解析、行/列坐标互映、插入槽、统计、共识、切片和match-only投影 | | `align_emboss.mbt` | `Bio.Align.emboss` | EMBOSS文件与alignment类型模型、固定21列body、多alignment/多序列、纯gap block、链感知绝对坐标、consensus统计和canonical writer | | `align_exonerate.mbt` | `Bio.Align.exonerate` | Exonerate document/alignment/operation模型、cigar/vulgar、正反链/protein坐标、3:1 translated mapping、双向查询、统计和canonical writer | +| `exonerate_text.mbt` | `Bio.SearchIO.ExonerateIO.exonerate_text` | C4 document/query/hit/HSP/fragment模型、固定列3/4/5行parser、剪接/翻译/phase/frame、区间查询与防御复制 | | `msf.mbt` | `Bio.Align.msf` | GCG MSF metadata/sequence/alignment模型、标准checksum、interleaved parser、短行补齐、coordinate path、pair counts、consensus和writer | | `align_nexus.mbt` | `Bio.Align.nexus` | 独立alignment metadata/sequence模型、nested comment与quoted token lexer、sequential/interleaved parser、MATCHCHAR、all-gap压缩、坐标查询、统计和writer | | `align_stockholm.mbt` | `Bio.Align.stockholm` | 有序GF/GS/GR/GC与reference模型、多记录parser、M/D/I列语义、all-gap压缩、annotation-aware切片、坐标查询、统计和writer | | `align_chain.mbt` | `Bio.Align.chain` | 不可变alignment/block/counts模型、严格多记录parser、链感知absolute coordinate path、block重建、双向位置/区间映射、pairs、invert和writer | | `align_maf.mbt` | `Bio.Align.maf` | 不可变document/track/index/spliced模型、严格a/s/i/e/q parser、链感知absolute path、任意component映射、区间查询、拼接和writer | +| `align_mauve.mbt` | `Bio.Align.mauve` | XMFA document/source/block/row模型、严格metadata与wrapped-row parser、正负链boundary path、pair counts、half-open index、跨序列投影、重建和writer | +| `align_clustal.mbt` | `Bio.Align.clustal` | metadata/sequence/alignment/counts模型、六类generator header、严格interleaved parser、consensus、coordinate path、投影、统计和writer | +| `align_phylip.mbt` | `Bio.Align.phylip` | sequence/alignment/counts模型、严格sequential/interleaved parser、固定10列名称、coordinate path、投影、统计和writer | | `align_bed.mbt` | `Bio.Align.bed` | 不可变alignment/document/score/block模型、BED3-BED12 parser、双轴路径校验、block投影、双向residue mapping、search、summary和writer | | `bigbed.mbt` | `Bio.Align.bigbed` | BigBed v4二进制读写、BED/AutoSQL、平衡B+ tree/R-tree、完整DEFLATE块解码、区间/名称查询与BED导出 | | `bigmaf.mbt` | `Bio.Align.bigmaf` | bedMaf AutoSQL与MAF块往返、a/s/i/e/q注释、链感知坐标映射、BigBed索引查询和普通MAF导出 | | `bigpsl.mbt` | `Bio.Align.bigpsl` | 标准bigPsl AutoSQL、核酸与translated DNA-protein坐标、链感知映射、match分类、BigBed索引和PSL导出 | +| `paml.mbt` | BioSeqs compatibility API | 内置Nei-Gojobori风格dN/dS和Jukes-Cantor近似，保留历史调用兼容性 | +| `paml_codeml.mbt` | `Bio.Phylo.PAML.codeml` | 类型化control/CODONML/AAML模型、NSsites/branch-site/clade/free-ratio、pairwise/距离矩阵、多基因、BEB/NEB和模型比较 | +| `paml_baseml.mbt` | `Bio.Phylo.PAML.baseml` | 类型化control与BASEML 4.x结果、JC69-UNRESTu、参数/SE、kappa/Q矩阵、nparK/auto-dGamma、nhomo节点和模型比较 | +| `paml_yn00.mbt` | `Bio.Phylo.PAML.yn00` | 类型化control与PAML 4.1-4.9i结果、NG86/YN00/LWL85/LWL85m/LPB93、矩阵和统计汇总 | +| `blast_xml_advanced.mbt` | `Bio.Blast` | XML1/XML2类型化文档、多query/report、HitDescr/taxonomy、参数/统计、strand/frame/translated path、过滤与同/跨dialect写回 | | `infercnv.mbt` | `infercnv` | 单细胞拷贝数变异推断（基因组位置排序、参考细胞有界 LFC 计算、金字塔权重平滑、CNV 分数与恶性细胞预测） | | `scenic.mbt` | `SCENIC` | 单细胞调控网络推断与聚类（TF-target 共表达模块、Regulon 构建、AUCell 活性评分、二值化阈值、细胞状态与主控调控因子） | | `cibersort.mbt` | `CIBERSORT` | 免疫细胞去卷积（NNLS 求解、LM22 风格特征矩阵、Pearson 拟合优度、分数归一化） | @@ -2062,6 +2124,7 @@ moon test # ✅ 11572 个测试全 | `velociraptor.mbt` | `velociraptor` | 单细胞RNA velocity分析（稳态线性回归gamma/beta比、EM动力学模型alpha/beta/gamma估计、velocity向量计算、KNN加权嵌入投影、根细胞识别、转移矩阵） | | `compass.mbt` | `Bio.Compass` | COMPASS profile-profile比对输出解析（版本提取、多记录解析SW分数/E值/百分比一致性/比对序列/共识行、E值与一致性过滤、比对长度统计、摘要生成） | | `exonerate.mbt` | `Bio.SearchIO.ExonerateIO` | Exonerate比对输出解析（vulgar格式三元组比对块解析M/I/5/3/S/G/U/V、cigar格式解析、格式自动检测、分数过滤、内含子统计、vulgar/cigar字符串重建） | +| `exonerate_text.mbt` | `Bio.SearchIO.ExonerateIO.exonerate_text` | Exonerate C4人类可读文本严格解析（多query/hit/HSP聚合、wrapped body、intron/NER/split codon/frameshift、三字母氨基酸和链感知坐标） | | `mmcifio.mbt` | `Bio.PDB.mmcifio` | mmCIF文件写入（Structure对象序列化data block/header/atom_site loop、20列原子坐标格式化、HETATM支持、值转义、round-trip验证） | | `interproscan.mbt` | `Bio.SearchIO.InterproscanIO` | InterProScan输出解析（TSV 14列格式解析蛋白质ID/MD5/长度/分析数据库/签名/位置/分数/IPR/GO、按数据库/蛋白质过滤、GO条目提取、按蛋白质分组、摘要） | | `sasa.mbt` | `Bio.PDB.SASA` | 溶剂可及表面积计算（Shrake-Rupley滚动球算法、Fibonacci球面采样、范德华半径查表H/C/N/O/S/P、逐原子/残基SASA、骨架/侧链拆分、总量统计） | @@ -2180,9 +2243,9 @@ moon test # ✅ 11572 个测试全 提供统一的搜索结果模型，支持 HMMER3 tabular 格式和 BLAT PSL 格式的解析。可以获取查询 ID、命中数、top hits（按 E-value 排序）和 HSP 数量统计。支持 BLAST 结果转换为 SearchIO 模型，便于不同搜索工具结果的统一处理。 -### 21. BLAST 结果解析 (Bio.Blast) +### 21. BLAST 基础解析兼容层 -支持 BLAST tabular 和 XML 格式的解析，提供丰富的结果过滤和访问接口。可以按 E-value 和 identity 过滤 hits，获取最佳匹配和最佳 HSP。支持所有 HSPs 的获取和查询序列长度的访问。 +`blast.mbt`保留早期BLAST tabular和简单XML标签解析API，支持按E-value和identity过滤、最佳命中/HSP及基础汇总。完整的Biopython `Bio.Blast` XML1/XML2文档语义、严格校验、链向/translated坐标和规范写回由第288节的`blast_xml_advanced.mbt`提供。 ### 22. 替换矩阵 (Bio.SubsMat) @@ -3417,6 +3480,70 @@ Wald contrast引擎通过Gram-Schmidt去除线性相关行，提供`associationT 当前实现是无外部依赖的MoonBit NB-Wald流程，不调用或宣称复刻edgeR、DESeq2、limma、MAST及stageR的R后端；采用稠密串行线性代数，也不覆盖上游并行、随机效应模型和可视化层。 +### 284. 现代 XMFA 多基因组比对读写与坐标投影 (Biopython Bio.Align.mauve) + +实现 Biopython 1.86 `Bio.Align.mauve` 的现代 XMFA 文档语义，并将历史 `mauve.mbt` 明确保留为 MAF-like 重排分析兼容层。严格 parser 支持 `#FormatVersion`、有序 `#SequenceNFile/Entry/Format` metadata、combined-file 与 separate-file identifier、`> N:start-end strand description` 行、wrapped alignment、CRLF、`=` 块终止符及多个 locally collinear block；同时校验 source 编号、entry、名称唯一性、比对宽度、IUPAC 字符和 `0-0` 全 gap 行。 + +文件中的 1-based inclusive 区间统一转换为内部 0-based half-open 区间。每行保留完整 boundary coordinate path：正链递增，负链递减；compact path 在任一行 residue/gap movement 状态变化时保留边界，与 Biopython printed-alignment 坐标一致。API 提供边界/残基/列查询、LCB 与文档级 pairwise identity/mismatch/gap/gap-open 统计、half-open interval index，以及跨序列位置和区间投影；区间映射会在 gap、列不连续或坐标步长变化处拆分，并保留目标链方向。 + +序列重建将各 LCB 的 source-oriented segment 写回 forward coordinates，未覆盖位置使用可配置字符填充，重叠冲突会返回类型化错误。canonical writer 支持固定宽度折行并可稳定 round-trip；公开数组访问器递归复制 block、row 与 coordinate path，避免调用方修改文档内部状态。专项测试采用 Biopython 官方 `combined.xmfa`、`separate.xmfa` 和 simple fixtures 的 metadata、负链坐标及 compact path 语义，并覆盖 wrapped/CRLF、统计、索引、投影、重建、写回和错误边界。 + +### 285. CODEML控制文件、原生输出与模型比较 (Biopython Bio.Phylo.PAML.codeml) + +实现 Biopython 1.86 `Bio.Phylo.PAML.codeml` 中不依赖外部可执行文件的完整离线工作流，并保留旧 `paml.mbt` 作为明确标注的内置近似兼容层。control parser 支持 `seqfile`、`outfile`、`treefile` 和 Biopython Codeml option集合，处理星号行尾注释、CRLF与多值`NSsites`；严格拒绝缺失路径、重复键、未知option、空值、错误数值类型及负NSsites，并提供稳定的canonical writer。 + +结果解析器识别CODONML和AAML header、PAML版本、模型与codon-frequency metadata、序列/位点数量，以及多个NSsites或gene结果。类型化模型覆盖lnL/np/参数/SE、主树与dN/dS/omega树、kappa/omega、branch表、site-class比例、branch-site A前景/背景类别、clade model C branch types、free-ratio、多基因relative rates和gene-wise参数；同时支持pairwise dN/dS、AAML raw/ML下三角距离矩阵以及BEB/NEB阳性位点。 + +分析层提供AIC、BIC、最小AIC选择和嵌套模型似然比检验。LRT使用Lanczos log-gamma与regularized incomplete gamma Q计算chi-square尾概率，并验证参数嵌套、似然单调性、显著性阈值及观测数边界。PAML输出中的`nan`分支量以`Double?`保留，公开数组访问器执行深复制。本模块只解析和分析已有artifact，不启动、捆绑或伪装外部`codeml`二进制；60项黑盒测试改编自Biopython PAML 4.1-4.9 fixtures，覆盖成功路径、数值信号、复制语义和严格错误边界。 + +### 286. BASEML核苷酸替换模型、非齐次频率与率类别 (Biopython Bio.Phylo.PAML.baseml) + +实现 Biopython 1.86 `Bio.Phylo.PAML.baseml` 中可确定性测试的离线工作流。control parser覆盖`seqfile`、`outfile`、`treefile`和全部Baseml option，支持星号注释、CRLF以及model 9/10附加rate-group定义；规范化整数和浮点表示，严格拒绝缺失路径、重复/未知键、空值、非法model、错误类型、无效`ncatG/nparK/nhomo`及越界二元开关。`baseml_model_name`提供JC69、K80、F81、F84、HKY85、T92、TN93、REV、UNREST、REVu和UNRESTu的完整编号映射。 + +结果解析器兼容PAML 4.1-4.7 header与base-frequency布局，提取unconstrained/fitted lnL、np、完整参数向量、SE、tree length和branch-length Newick。类型化结果进一步覆盖单值/多值/branch-specific kappa、REV/UNREST rate parameters与4x4 Q矩阵、平均Ts/Tv、离散gamma alpha/rates/frequencies、auto-dGamma rho与rate-category transition matrix，以及`nhomo`节点frequency parameters、可选realized T/C/A/G频率和root标记。矩阵维度、参数/SE长度、节点唯一性和必需估计均执行严格验证，所有公开数组和嵌套矩阵访问器均返回深复制。 + +分析层提供AIC、BIC和嵌套模型LRT，复用经过CODEML测试的Lanczos log-gamma与regularized incomplete gamma Q实现chi-square尾概率，同时校验参数自由度、似然单调性、观测数和alpha边界。本模块不启动或捆绑外部`baseml`二进制；64项黑盒测试改编自Biopython官方model、SE、alpha1rho1、nparK、nhomo及4.1-4.7 fixtures，覆盖control round-trip、数值信号、复制语义和错误边界。 + +### 287. YN00成对密码子替换估计与跨版本结果解析 (Biopython Bio.Phylo.PAML.yn00) + +实现 Biopython 1.86 `Bio.Phylo.PAML.yn00` 的离线control和结果工作流。control parser覆盖`seqfile`、`outfile`、`verbose`、`icode`、`weighting`、`commonf3x4`和`ndata`，支持星号注释及CRLF；严格拒绝缺失路径、重复或未知键、空值、多重等号、非整数option、越界开关和非法遗传密码编号，并提供稳定的canonical writer。 + +结果状态机兼容PAML 4.1-4.9i输出差异，解析NG86、Yang-Nielsen 2000、LWL85、modified LWL85和LPB93五种方法。类型化结果保留dN、dS、omega、kappa、时间、同义/非同义位点、标准误和rho；支持旧式无空格NG86矩阵、相邻负值、长名称及带点数字名称，并将`nan`、`inf`和Windows `-1.#IND`安全映射为未定义值。解析过程验证序列索引和名称一致性、名称唯一性、三角pair数量、方法完整性、重复记录及矩阵维度。 + +分析API提供无序序列对查询、任意方法/统计量的对称矩阵和跳过未定义值的pair均值；公开名称、pair和嵌套矩阵访问器均执行防御复制。本模块只解析和分析已有YN00 artifact，不启动或捆绑外部`yn00`二进制；80项黑盒测试覆盖Biopython官方跨版本fixture语义、数值信号、名称边界、非有限值、复制语义和严格错误路径。 + +### 288. 现代BLAST XML1/XML2解析、坐标路径与规范写回 (Biopython Bio.Blast) + +实现 Biopython 1.86 `Bio.Blast` 的现代离线XML工作流，并保留`blast.mbt`作为历史基础解析兼容层。递归XML parser支持declaration、comment、DOCTYPE、CDATA、自闭合元素、namespace和entity，严格检查标签配对、尾随数据、唯一header、query/report一致性及必需字段。类型化文档覆盖XML1和XML2、多query、普通XML2多report、PSI-BLAST iterations、多个HitDescr、taxonomy、Parameters及Karlin-Altschul Statistics。 + +HSP层将BLAST的1-based inclusive字段转换为0-based boundary coordinate path。`blastn`和`megablast`按strand/frame递增或递减；`blastp`、`rpsblast`和`psiblast`使用蛋白质1:1轴；`blastx`、`tblastn`和`tblastx`在翻译的核酸轴上按每个氨基酸3个碱基移动，并保留`coded_by`正向或`complement(...)`位置。路径在match、query gap或target gap状态切换处压缩，同时校验alignment长度、midline、gap/identity/positive计数、raw span、frame范围、方向和序列边界。 + +canonical writer支持同dialect写回和显式XML1/XML2转换；XML2普通多query按XSD生成多个`BlastOutput2` report，PSI-BLAST使用`Results/iterations/Iteration`。无法无损表达的转换会返回类型化错误，writer结果在返回前由严格parser复验。公开record/hit/HSP、描述、mask和坐标数组执行防御复制，并提供query查找、best hit/HSP、E-value过滤和文档汇总。61项黑盒测试覆盖八类BLAST程序、XML实体、多描述、反链和双翻译坐标、规范往返、跨dialect转换、`NaN`/Infinity及结构错误；模块不访问NCBI网络，也不启动本地BLAST可执行文件。 + +### 289. 现代CLUSTAL多序列比对、列注释与坐标模型 (Biopython Bio.Align.clustal) + +实现 Biopython 1.86 `Bio.Align.clustal` 的现代单MSA工作流，并保留`clustal_io.mbt`作为历史`Bio.AlignIO.ClustalIO`兼容层。parser识别CLUSTAL、PROBCONS、MUSCLE、MSAPROBS、Kalign和Biopython generator header，支持CRLF、interleaved blocks、可选累计ungapped residue count以及稀疏、全空格或缺失的consensus。第一块建立唯一identifier顺序，后续块必须严格复现该顺序和等宽片段；累计计数、字符集、列宽、全gap行与全gap列均执行类型化校验。 + +`AlignClustalAlignment`保留原始generator/version、ungapped和aligned row以及`*`、`:`、`.`列注释。坐标API提供零起始residue/column双向查询、跨行位置投影、逐列aligned pairs和按movement vector压缩的Biopython风格多行coordinate path；分析层提供pair/all-pairs identity与gap-open统计、occupancy、majority consensus，并按标准ClustalW strong/weak蛋白质保守组计算列符号，核酸则只标记无gap完全一致列。 + +canonical writer支持配置block/name width、累计残基数和consensus，拒绝静默截断长identifier，并在返回前用严格parser复验输出。构造器和数组结果执行防御复制。75项黑盒测试覆盖官方fixture风格header、block和计数语义、坐标/统计信号、规范往返、复制语义及失败边界；离线示例不启动CLUSTAL、MUSCLE或其他外部aligner。 + +### 290. 现代PHYLIP布局识别、固定宽度名称与坐标模型 (Biopython Bio.Align.phylip) + +实现 Biopython 1.86 `Bio.Align.phylip` 的现代单MSA工作流，并保留`phylip_io.mbt`作为历史`Bio.AlignIO.PhylipIO`兼容层。parser严格读取两个正整数header字段和首块固定10列identifier，支持CRLF、wrapped sequential、interleaved blocks及片段内分组空格，并按Biopython首块规则自动识别布局。每块行数、片段宽度、累计列数、尾部数据和声明维度都会校验；`.`、全gap列、不完整block和溢出维度返回类型化错误，同时保留空、内部空格或重复identifier的合法fixed-width语义。 + +`AlignPhylipAlignment`同时保存aligned与ungapped rows及来源布局。坐标API提供零起始residue/column双向查询、跨行位置投影、逐列aligned pairs和按movement vector压缩的多行coordinate path；统计层提供pair/all-pairs identities、mismatches、gap columns、double-gap columns、gap opens、occupancy和majority consensus。 + +writer默认生成与现代Biopython一致的单行sequential格式，也可配置wrapped sequential或interleaved blocks及分组宽度。identifier写出前执行trim、标点替换和10字符截断，允许上游兼容的规范化碰撞；输出返回前由严格parser复验。构造器及公开数组执行防御复制。72项黑盒测试覆盖官方fixture风格布局、名称边界、坐标/统计、稳定往返、复制语义和失败路径；离线示例不启动外部PHYLIP程序或aligner。 + +### 291. Exonerate C4文本结果、剪接语义与坐标投影 (Biopython Bio.SearchIO.ExonerateIO.exonerate_text) + +实现 Biopython 1.86 `Bio.SearchIO.ExonerateIO.exonerate_text` 的 C4 人类可读报告层，并与既有`exonerate.mbt` vulgar/cigar摘要兼容API及`align_exonerate.mbt` operation path模型并存。严格parser读取`Command line`、`Hostname`、`C4 Alignment` header和completion marker，将多query、hit及HSP聚合为不可变`Document -> QueryResult -> Hit -> HSP -> Fragment`层次；query/target描述、model、raw score、header boundary和alignment body均保留类型语义。 + +alignment body通过coordinate row的冒号位置确定固定列宽，支持跨physical block拼接及3、4、5行模型。translated模型解析protein/DNA annotation、三字母氨基酸、leading/trailing partial triplet和codon flip；特殊区域识别target/query/joint/reverse intron、NER、split codon与frameshift，并分别生成双轴fragment及inter-range。坐标统一为0-based half-open区间，保留forward/reverse/protein strand、phase、frame及每轴step，支持fragment residue位置投影、HSP区间/计数、query/hit查找和best-HSP选择。 + +parser严格检查metadata顺序、固定列行宽、坐标方向与终点、模型维度、splice/NER长度、split codon配对和frameshift归属；公开层次查询与数组结果执行深层防御复制。42项黑盒测试覆盖wrapped blocks、正反链intron、joint intron、NER、protein/DNA翻译、5行coding模型、partial phase、特殊氨基酸、聚合及畸形输入；示例完全离线，不调用外部`exonerate`程序。 + ## 性能优化 ### 优化策略 @@ -3518,8 +3645,8 @@ Wald contrast引擎通过Gram-Schmidt去除线性相关行，提供`associationT | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 11572 | -| 通过数 | 11572 | +| 总测试数 | 12093 | +| 通过数 | 12093 | | 失败数 | 0 | | 通过率 | 100% | @@ -3635,6 +3762,14 @@ moon test --update | Bio.Align.stockholm | `align_stockholm_test.mbt` | 148 | | Bio.Align.chain | `align_chain_test.mbt` | 156 | | Bio.Align.maf | `align_maf_test.mbt` | 155 | +| Bio.Align.mauve | `align_mauve_test.mbt` | 67 | +| Bio.Align.clustal | `align_clustal_test.mbt` | 75 | +| Bio.Align.phylip | `align_phylip_test.mbt` | 72 | +| Bio.SearchIO.ExonerateIO.exonerate_text | `exonerate_text_test.mbt` | 42 | +| Bio.Phylo.PAML.codeml | `paml_codeml_test.mbt` | 60 | +| Bio.Phylo.PAML.baseml | `paml_baseml_test.mbt` | 64 | +| Bio.Phylo.PAML.yn00 | `paml_yn00_test.mbt` | 80 | +| Bio.Blast XML1/XML2 | `blast_xml_advanced_test.mbt` | 61 | | Bio.Align.bed | `align_bed_test.mbt` | 152 | | Bio.Align.bigbed | `bigbed_test.mbt` | 64 | | Bio.Align.bigmaf | `bigmaf_test.mbt` | 79 | @@ -3956,7 +4091,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 388 个示例程序，展示各模块的典型用法： +项目提供 400 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -3964,6 +4099,13 @@ moon run cmd/bench/main.mbt | seqio_demo | 序列 I/O（FASTA/FASTQ/GenBank 解析与写入、FASTA 索引） | `moon run examples/seqio_demo/main.mbt` | | alignment_demo | 序列比对（Needleman-Wunsch、Smith-Waterman、Clustal/Phylip） | `moon run examples/alignment_demo/main.mbt` | | phylo_demo | 系统发育树（Newick 解析、遍历、距离计算、ASCII 可视化） | `moon run examples/phylo_demo/main.mbt` | +| paml_codeml_demo | CODEML control规范往返、CODONML多模型、branch/site class、BEB、AIC/BIC与LRT | `moon run examples/paml_codeml_demo` | +| paml_baseml_demo | BASEML control规范往返、参数/SE、REV Q矩阵、离散gamma及AIC/BIC/LRT | `moon run examples/paml_baseml_demo` | +| paml_yn00_demo | YN00 control规范往返、五种成对估计、未定义值、对称矩阵与均值 | `moon run examples/paml_yn00_demo` | +| blast_xml_advanced_demo | XML1/XML2解析、多描述/taxonomy、最佳命中/HSP、负translated frame、坐标路径及canonical/cross-dialect往返 | `moon run examples/blast_xml_advanced_demo` | +| align_clustal_demo | CLUSTAL generator metadata、interleaved rows、consensus、coordinate path、跨行投影、pair counts及累计计数canonical往返 | `moon run examples/align_clustal_demo` | +| align_phylip_demo | PHYLIP sequential/interleaved识别、名称规范化、coordinate path、跨行投影、pair counts及canonical往返 | `moon run examples/align_phylip_demo` | +| exonerate_text_demo | C4 metadata与层次结果、fragment/内含子区间、phase、统计及residue位置投影 | `moon run examples/exonerate_text_demo` | | pdb_demo | PDB 结构解析（原子/残基/链访问、距离计算） | `moon run examples/pdb_demo/main.mbt` | | sam_vcf_demo | SAM/VCF 解析（比对记录、变异检测、基因型查询） | `moon run examples/sam_vcf_demo/main.mbt` | | faidx_demo | FASTA 索引（pyfaidx 风格随机访问、.fai 序列化） | `moon run examples/faidx_demo/main.mbt` | @@ -4176,6 +4318,7 @@ moon run cmd/bench/main.mbt | align_stockholm_demo | Stockholm GF/GS/GR/GC与reference、insertion operation、coordinate path、residue mapping、统计、all-gap压缩与canonical往返 | `moon run examples/align_stockholm_demo` | | align_chain_demo | UCSC Chain连续记录、正反双轴绝对路径、block/counts、双向位置与区间映射、反转及canonical往返 | `moon run examples/align_chain_demo` | | align_maf_demo | MAF track/header、a/s/i/e/q、plus/minus绝对路径、component映射、MafIndex查询、多外显子拼接与canonical往返 | `moon run examples/align_maf_demo` | +| align_mauve_demo | XMFA source metadata与LCB、正负链coordinate path、pair counts、区间索引、跨序列投影、forward重建与wrapped canonical往返 | `moon run examples/align_mauve_demo` | | align_bed_demo | BED3/BED12、numeric/text score、正负链双轴路径、exon blocks、双向mapping、搜索、统计、BED3-BED12分级写回与canonical往返 | `moon run examples/align_bed_demo` | | bigbed_demo | BigBed v4压缩写入/解析、AutoSQL、多级索引查询、负链exon坐标、BED导出及损坏文件诊断 | `moon run examples/bigbed_demo` | | bigmaf_demo | BigMaf压缩bed3+1写入、bedMaf schema、R-tree区间查询、负链物种坐标映射和MAF a/s/i/e/q导出 | `moon run examples/bigmaf_demo` | @@ -4305,6 +4448,14 @@ moon run cmd/bench/main.mbt - ✅ 实现 Bio.Align.stockholm Stockholm多序列比对（严格多记录、GF/GS/GR/GC、reference/database/nested-domain、M/D/I列、all-gap压缩、坐标统计与canonical writer） - ✅ 实现 Bio.Align.chain UCSC Chain成对比对（12/13字段严格多记录、float score、正反双轴absolute path、size/dt/dq、坐标映射、反转、查询与canonical writer） - ✅ 实现 Bio.Align.maf MAF多基因组比对（track/header、严格a/s/i/e/q、正负链absolute path、component映射、MafIndex半开查询、多外显子拼接与canonical writer） +- ✅ 实现 Bio.Align.mauve 现代XMFA多基因组比对（严格metadata/LCB、combined/separate source、正负链coordinate path、区间索引、跨序列投影、统计、重建与canonical writer） +- ✅ 实现 Bio.Align.clustal 现代CLUSTAL多序列比对（六类generator header、严格interleaved blocks、累计残基数、consensus、坐标投影、统计与canonical writer） +- ✅ 实现 Bio.Align.phylip 现代PHYLIP多序列比对（固定10列名称、sequential/interleaved自动识别、wrapped/grouped blocks、坐标投影、统计与canonical writer） +- ✅ 实现 Bio.SearchIO.ExonerateIO.exonerate_text C4人类可读报告（层次聚合、3/4/5行模型、wrapped blocks、intron/NER/split codon/frameshift、翻译与链感知坐标） +- ✅ 实现 Bio.Phylo.PAML.codeml 离线工作流（严格control读写、CODONML/AAML、NSsites/branch-site/clade/free-ratio、pairwise/距离矩阵、多基因、BEB/NEB与AIC/BIC/LRT） +- ✅ 实现 Bio.Phylo.PAML.baseml 离线工作流（严格control读写、JC69-UNRESTu、参数/SE、kappa/Q矩阵、nparK/auto-dGamma、nhomo节点与AIC/BIC/LRT） +- ✅ 实现 Bio.Phylo.PAML.yn00 离线工作流（严格control读写、NG86/YN00/LWL85/LWL85m/LPB93、PAML 4.1-4.9i、非有限值、对称矩阵与均值） +- ✅ 实现 Bio.Blast现代XML1/XML2离线工作流（严格XML树、多query/report、HitDescr/taxonomy、参数/统计、八类程序链向/translated坐标及canonical writer） - ✅ 实现 Bio.Align.bed BED成对比对（BED3-BED12严格读写、numeric/text score、正负链双轴路径、block投影、双向residue映射、区间查询、统计与分级writer） - ✅ 实现 Bio.Align.bigbed BigBed v4二进制区间格式（BED3-BED12、AutoSQL、多级B+ tree/R-tree、DEFLATE、区间/名称查询与BED导出） - ✅ 实现 Bio.Align.bigmaf BigMaf多物种比对索引（标准bedMaf、MAF a/s/i/e/q、正负链坐标映射、压缩BigBed查询与MAF导出） diff --git a/examples/align_clustal_demo/main.mbt b/examples/align_clustal_demo/main.mbt new file mode 100644 index 00000000..24c9acc8 --- /dev/null +++ b/examples/align_clustal_demo/main.mbt @@ -0,0 +1,104 @@ +///| +fn clustal_demo_parse(text : String) -> @bio.AlignClustalAlignment { + @bio.align_clustal_parse(text) catch { + AlignClustalError(message) => abort("CLUSTAL parse failed: " + message) + } +} + +///| +fn clustal_demo_write(alignment : @bio.AlignClustalAlignment) -> String { + @bio.align_clustal_write( + alignment, + block_width=5, + name_width=16, + include_counts=true, + include_consensus=true, + ) catch { + AlignClustalError(message) => abort("CLUSTAL write failed: " + message) + } +} + +///| +fn clustal_demo_path(path : Array[Int]) -> String { + let output = StringBuilder::new() + output.write_char('[') + for index = 0; index < path.length(); index = index + 1 { + if index > 0 { + output.write_string(", ") + } + output.write_string(path[index].to_string()) + } + output.write_char(']') + output.to_string() +} + +///| +fn main { + println("=== Biopython Bio.Align.clustal Offline Demo ===") + let alignment = clustal_demo_parse(@bio.align_clustal_example_text()) + + println("\n1. Generator metadata and interleaved rows") + println(" " + alignment.summary()) + for sequence in alignment.sequences { + println( + " " + + sequence.id + + ": aligned=" + + sequence.aligned_sequence + + ", ungapped=" + + sequence.sequence, + ) + } + println( + " stored consensus=" + alignment.consensus.unwrap_or(""), + ) + println(" calculated consensus=" + alignment.calculated_consensus()) + + println("\n2. Compressed coordinate path") + let paths = alignment.coordinate_path() + for row = 0; row < paths.length(); row = row + 1 { + println( + " " + alignment.sequences[row].id + ": " + clustal_demo_path(paths[row]), + ) + } + println( + " reference residue 3 -> query_one residue " + + alignment.map_position(0, 1, 3).unwrap_or(-1).to_string(), + ) + + println("\n3. Pairwise statistics and majority residues") + let counts = alignment.pair_counts(0, 1) catch { + AlignClustalError(message) => abort("CLUSTAL counting failed: " + message) + } + let majority = alignment.majority_consensus(minimum_fraction=0.5) catch { + AlignClustalError(message) => abort("CLUSTAL consensus failed: " + message) + } + println( + " aligned=" + + counts.aligned.to_string() + + ", identities=" + + counts.identities.to_string() + + ", gap opens=" + + counts.gap_opens.to_string() + + ", identity=" + + counts.identity().to_string(), + ) + println(" majority=" + majority) + + println("\n4. Canonical writing with cumulative residue counts") + let canonical = clustal_demo_write(alignment) + let reparsed = clustal_demo_parse(canonical) + println( + " canonical generator=" + + reparsed.metadata.program + + " " + + reparsed.metadata.version, + ) + println( + " stable round-trip=" + + (clustal_demo_write(reparsed) == canonical).to_string(), + ) + println( + "\nThe demo parses and writes existing artifacts; it does not launch an aligner.", + ) +} diff --git a/examples/align_clustal_demo/moon.pkg b/examples/align_clustal_demo/moon.pkg new file mode 100644 index 00000000..4ecfd216 --- /dev/null +++ b/examples/align_clustal_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src" @bio, +} + +pkgtype(kind: "executable") diff --git a/examples/align_mauve_demo/main.mbt b/examples/align_mauve_demo/main.mbt new file mode 100644 index 00000000..e1d7cb73 --- /dev/null +++ b/examples/align_mauve_demo/main.mbt @@ -0,0 +1,106 @@ +///| +fn align_mauve_demo_document() -> @bio.AlignMauveDocument { + @bio.align_mauve_parse(@bio.align_mauve_example_text()) catch { + AlignMauveError(message) => + abort("failed to parse XMFA example: " + message) + } +} + +///| +fn align_mauve_demo_path(values : Array[Int]) -> String { + "[" + values.map(fn(value) { value.to_string() }).join(", ") + "]" +} + +///| +fn main { + println("=== Biopython Bio.Align.mauve XMFA Demo ===") + let document = align_mauve_demo_document() + let summary = @bio.align_mauve_summary(document) + println("\n1. Strict document and locally collinear blocks") + println( + " format=" + + document.format_version() + + ", identifiers=" + + document.identifiers().join(", "), + ) + println( + " sources=" + + summary.sources().to_string() + + ", blocks=" + + summary.blocks().to_string() + + ", rows=" + + summary.rows().to_string(), + ) + + let first = document.blocks()[0] + let compact = first.compact_coordinates() + println("\n2. Forward and reverse coordinate paths") + println( + " first block: " + + first.row_count().to_string() + + " rows x " + + first.width().to_string() + + " columns", + ) + println(" reverse row compact path: " + align_mauve_demo_path(compact[0])) + println(" forward row compact path: " + align_mauve_demo_path(compact[2])) + + let counts = first.counts() + println("\n3. Pairwise alignment statistics") + println( + " aligned=" + + counts.aligned().to_string() + + ", identities=" + + counts.identities().to_string() + + ", mismatches=" + + counts.mismatches().to_string() + + ", gaps=" + + counts.gaps().to_string() + + ", gap opens=" + + counts.gap_opens().to_string(), + ) + + let index = @bio.align_mauve_index(document) + let overlaps = index.query("0", 1, 10) catch { + AlignMauveError(message) => abort("interval query failed: " + message) + } + let positions = @bio.align_mauve_map_position(document, "0", "2", 48) catch { + AlignMauveError(message) => abort("position projection failed: " + message) + } + println("\n4. Interval index and cross-sequence projection") + println(" source 0 [1,10) overlaps: " + overlaps.length().to_string()) + if positions.length() > 0 { + println( + " source 0 position 48 -> source 2 position " + + positions[0].target_position().to_string() + + " in block " + + positions[0].block_index().to_string(), + ) + } + + let reconstructed = @bio.align_mauve_reconstruct_sequence(document, "0") catch { + AlignMauveError(message) => + abort("sequence reconstruction failed: " + message) + } + println("\n5. Forward source reconstruction") + println( + " source 0 length=" + + reconstructed.length().to_string() + + ", sequence=" + + reconstructed, + ) + + let written = @bio.align_mauve_write(document, line_width=20) catch { + AlignMauveError(message) => abort("XMFA write failed: " + message) + } + let reparsed = @bio.align_mauve_parse(written) catch { + AlignMauveError(message) => abort("XMFA round-trip failed: " + message) + } + println("\n6. Canonical wrapped writer") + println( + " round-trip blocks=" + + reparsed.block_count().to_string() + + ", equivalent=" + + (reparsed == document).to_string(), + ) +} diff --git a/examples/align_mauve_demo/moon.pkg b/examples/align_mauve_demo/moon.pkg new file mode 100644 index 00000000..4ecfd216 --- /dev/null +++ b/examples/align_mauve_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src" @bio, +} + +pkgtype(kind: "executable") diff --git a/examples/align_phylip_demo/main.mbt b/examples/align_phylip_demo/main.mbt new file mode 100644 index 00000000..0cf00789 --- /dev/null +++ b/examples/align_phylip_demo/main.mbt @@ -0,0 +1,101 @@ +///| +fn phylip_demo_parse(text : String) -> @bio.AlignPhylipAlignment { + @bio.align_phylip_parse(text) catch { + AlignPhylipError(message) => abort("PHYLIP parse failed: " + message) + } +} + +///| +fn phylip_demo_write( + alignment : @bio.AlignPhylipAlignment, + layout : @bio.AlignPhylipLayout, +) -> String { + @bio.align_phylip_write(alignment, layout~, block_width=4, group_width=0) catch { + AlignPhylipError(message) => abort("PHYLIP write failed: " + message) + } +} + +///| +fn phylip_demo_path(path : Array[Int]) -> String { + let output = StringBuilder::new() + output.write_char('[') + for index = 0; index < path.length(); index = index + 1 { + if index > 0 { + output.write_string(", ") + } + output.write_string(path[index].to_string()) + } + output.write_char(']') + output.to_string() +} + +///| +fn main { + println("=== Biopython Bio.Align.phylip Offline Demo ===") + let alignment = phylip_demo_parse(@bio.align_phylip_example_text()) + + println("\n1. Automatic layout detection and fixed-width rows") + println(" " + alignment.summary()) + for sequence in alignment.sequences { + println( + " " + + sequence.id + + ": aligned=" + + sequence.aligned_sequence + + ", ungapped=" + + sequence.sequence, + ) + } + + println("\n2. Biopython-compatible identifier normalization") + let normalized = @bio.align_phylip_normalize_id("Taxon[1]:extra") catch { + AlignPhylipError(message) => + abort("PHYLIP name normalization failed: " + message) + } + println(" Taxon[1]:extra -> " + normalized) + + println("\n3. Coordinate path and cross-row projection") + let paths = alignment.coordinate_path() + for row = 0; row < paths.length(); row = row + 1 { + println( + " " + alignment.sequences[row].id + ": " + phylip_demo_path(paths[row]), + ) + } + println( + " reference residue 3 -> query_one residue " + + alignment.map_position(0, 1, 3).unwrap_or(-1).to_string(), + ) + + println("\n4. Pairwise statistics and majority consensus") + let counts = alignment.pair_counts(0, 1) catch { + AlignPhylipError(message) => abort("PHYLIP counting failed: " + message) + } + let consensus = alignment.majority_consensus(minimum_fraction=0.5) catch { + AlignPhylipError(message) => abort("PHYLIP consensus failed: " + message) + } + println( + " aligned=" + + counts.aligned.to_string() + + ", identities=" + + counts.identities.to_string() + + ", gap opens=" + + counts.gap_opens.to_string() + + ", identity=" + + counts.identity().to_string(), + ) + println(" majority=" + consensus) + + println("\n5. Canonical sequential and interleaved writing") + let sequential = phylip_demo_write(alignment, @bio.PhylipSequential) + let interleaved = phylip_demo_write(alignment, @bio.PhylipInterleaved) + let reparsed = phylip_demo_parse(interleaved) + let sequential_lines = sequential.split("\n").to_array() + println(" sequential first row=" + sequential_lines[1].to_owned()) + println( + " stable interleaved round-trip=" + + (phylip_demo_write(reparsed, @bio.PhylipInterleaved) == interleaved).to_string(), + ) + println( + "\nThe demo parses and writes existing artifacts; it does not launch an aligner.", + ) +} diff --git a/examples/align_phylip_demo/moon.pkg b/examples/align_phylip_demo/moon.pkg new file mode 100644 index 00000000..4ecfd216 --- /dev/null +++ b/examples/align_phylip_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src" @bio, +} + +pkgtype(kind: "executable") diff --git a/examples/blast_xml_advanced_demo/main.mbt b/examples/blast_xml_advanced_demo/main.mbt new file mode 100644 index 00000000..01b7aeb7 --- /dev/null +++ b/examples/blast_xml_advanced_demo/main.mbt @@ -0,0 +1,167 @@ +///| +fn blast_demo_parse(text : String) -> @bio.BlastXmlDocument { + @bio.blast_xml_parse(text) catch { + BlastXmlError(message) => abort("BLAST XML parse failed: " + message) + } +} + +///| +fn blast_demo_write(document : @bio.BlastXmlDocument) -> String { + @bio.blast_xml_write(document) catch { + BlastXmlError(message) => abort("BLAST XML write failed: " + message) + } +} + +///| +fn blast_demo_write_xml2(document : @bio.BlastXmlDocument) -> String { + @bio.blast_xml_write_as(document, @bio.BlastXmlFormat::Xml2) catch { + BlastXmlError(message) => abort("BLAST XML conversion failed: " + message) + } +} + +///| +fn blast_demo_xml1() -> String { + "\n" + + "\n" + + "" + + "blastp" + + "BLASTP 2.15.0+" + + "offline demo" + + "swissprot" + + "Query_1" + + "protein query" + + "12" + + "" + + "BLOSUM62" + + "0.001" + + "11" + + "1" + + "" + + "" + + "1" + + "Query_1" + + "protein query" + + "12" + + "" + + "1sp|DEMO.1|" + + "demonstration targetDEMO" + + "20" + + "142.5" + + "1002e-12" + + "17" + + "18" + + "00" + + "77" + + "18" + + "MKKL-AAAMKKLTAAA" + + "MKKL AAA" + + "482816" + + "183558113" + + "72" + + "4627826878" + + "0.041" + + "0.267" + + "0.14" + + "" + + "\n" +} + +///| +fn blast_demo_xml2() -> String { + "\n" + + "" + + "blastxBLASTX 2.15.0+" + + "offline demoswissprot" + + "BLOSUM62" + + "0.001111" + + "2" + + "translated_querynegative frame query" + + "301" + + "sp|PRIMARY.1|PRIMARY" + + "primary target83333" + + "sp|SECONDARY.1|SECONDARY" + + "secondary target224308" + + "Bacillus subtilis10" + + "13060" + + "1e-83" + + "157-1" + + "243" + + "0MKTMKT" + + "" + + "\n" +} + +///| +fn main { + println("=== Biopython Bio.Blast XML1/XML2 Offline Demo ===") + let xml1 = blast_demo_parse(blast_demo_xml1()) + let record = xml1.records()[0] + let best = record.best_hit().unwrap() + let hsp = best.best_hsp().unwrap() + let statistics = record.statistics().unwrap() + println("\n1. XML1 records, best hit, and statistics") + println( + " program=" + + xml1.program() + + ", records=" + + xml1.records().length().to_string() + + ", hits=" + + xml1.total_hits().to_string(), + ) + println( + " best=" + + best.primary_description().accession() + + ", E-value=" + + hsp.evalue().to_string() + + ", identity=" + + hsp.identity_fraction().to_string(), + ) + println( + " database sequences=" + + statistics.database_sequences().to_string() + + ", letters=" + + statistics.database_letters().to_string(), + ) + + println("\n2. Compressed alignment path") + for coordinate in hsp.coordinates() { + println( + " target=" + + coordinate.target().to_string() + + ", query=" + + coordinate.query().to_string(), + ) + } + + let xml2 = blast_demo_parse(blast_demo_xml2()) + let translated_hit = xml2.records()[0].hits()[0] + let translated_hsp = translated_hit.hsps()[0] + println("\n3. XML2 descriptions and translated coordinates") + println( + " descriptions=" + + translated_hit.descriptions().length().to_string() + + ", secondary taxon=" + + translated_hit.descriptions()[1].scientific_name().unwrap_or("unknown"), + ) + println( + " query frame=" + + translated_hsp.query_frame().unwrap().to_string() + + ", coded_by=" + + translated_hsp.query_coded_by().unwrap_or("undefined"), + ) + + let canonical = blast_demo_write(xml2) + let converted = blast_demo_write_xml2(xml1) + println("\n4. Canonical writing and dialect conversion") + println( + " XML2 round-trip stable: " + + (blast_demo_write(blast_demo_parse(canonical)) == canonical).to_string(), + ) + println( + " XML1 -> XML2 records: " + + blast_demo_parse(converted).records().length().to_string(), + ) + println( + "\nThe demo parses and writes existing artifacts; it does not use NCBI or launch BLAST.", + ) +} diff --git a/examples/blast_xml_advanced_demo/moon.pkg b/examples/blast_xml_advanced_demo/moon.pkg new file mode 100644 index 00000000..4ecfd216 --- /dev/null +++ b/examples/blast_xml_advanced_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src" @bio, +} + +pkgtype(kind: "executable") diff --git a/examples/exonerate_text_demo/main.mbt b/examples/exonerate_text_demo/main.mbt new file mode 100644 index 00000000..9721d5a9 --- /dev/null +++ b/examples/exonerate_text_demo/main.mbt @@ -0,0 +1,91 @@ +///| +fn exonerate_text_demo_parse(text : String) -> @bio.ExonerateTextDocument { + @bio.exonerate_text_parse(text) catch { + ExonerateTextError(message) => { + println("Exonerate text parse failed: " + message) + abort(message) + } + } +} + +///| +fn exonerate_text_demo_range(range : @bio.ExonerateTextRange) -> String { + "[" + range.start.to_string() + ", " + range.end.to_string() + ")" +} + +///| +fn main { + println("=== Biopython Bio.SearchIO.ExonerateIO Offline Demo ===") + let document = exonerate_text_demo_parse(@bio.exonerate_text_example()) + println("\n1. Report metadata and SearchIO hierarchy") + println(" command=" + document.metadata.command_line) + println(" host=" + document.metadata.hostname) + println(" " + document.summary()) + + let query = document.queries[0] + let hit = query.hits[0] + let hsp = hit.hsps[0] + println( + " query=" + + query.id + + ", target=" + + hit.id + + ", model=" + + hsp.model + + ", score=" + + hsp.score.to_string(), + ) + + println("\n2. Spliced fragments and normalized coordinates") + let query_ranges = hsp.query_ranges() + let hit_ranges = hsp.hit_ranges() + for index = 0; index < hsp.fragments.length(); index = index + 1 { + let fragment = hsp.fragments[index] + println( + " fragment " + + (index + 1).to_string() + + ": query=" + + exonerate_text_demo_range(query_ranges[index]) + + ", target=" + + exonerate_text_demo_range(hit_ranges[index]) + + ", phase=" + + fragment.phase.to_string(), + ) + println( + " " + + fragment.query_sequence + + "\n " + + fragment.similarity + + "\n " + + fragment.hit_sequence, + ) + } + + println("\n3. Inter-fragment intron ranges") + println( + " query=" + + exonerate_text_demo_range(hsp.query_inter_ranges()[0]) + + ", target=" + + exonerate_text_demo_range(hsp.hit_inter_ranges()[0]), + ) + + let counts = hsp.counts() + println("\n4. Alignment statistics and position projection") + println( + " columns=" + + counts.alignment_columns.to_string() + + ", identities=" + + counts.identities.to_string() + + ", gaps=" + + counts.gap_columns.to_string() + + ", intervening gaps=" + + counts.introns_or_ner_gaps.to_string(), + ) + println( + " first aligned query base -> " + + hsp.fragments[0].query_position(0).unwrap_or(-1).to_string(), + ) + println( + "\nThe demo parses an existing report artifact; it does not launch Exonerate.", + ) +} diff --git a/examples/exonerate_text_demo/moon.pkg b/examples/exonerate_text_demo/moon.pkg new file mode 100644 index 00000000..4ecfd216 --- /dev/null +++ b/examples/exonerate_text_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src" @bio, +} + +pkgtype(kind: "executable") diff --git a/examples/paml_baseml_demo/main.mbt b/examples/paml_baseml_demo/main.mbt new file mode 100644 index 00000000..31452251 --- /dev/null +++ b/examples/paml_baseml_demo/main.mbt @@ -0,0 +1,127 @@ +///| +fn baseml_demo_control() -> @bio.BasemlControl { + @bio.baseml_parse_control(@bio.baseml_example_control_text()) catch { + BasemlError(message) => abort("failed to parse BASEML control: " + message) + } +} + +///| +fn baseml_demo_results() -> @bio.BasemlResults { + @bio.baseml_parse_results(@bio.baseml_example_results_text()) catch { + BasemlError(message) => abort("failed to parse BASEML results: " + message) + } +} + +///| +fn baseml_demo_null_model() -> @bio.BasemlResults { + @bio.baseml_parse_results( + "BASEML (in paml version 4.7, January 2013) alignment.phylip JC69 dGamma\n" + + "lnL(ntime: 7 np: 8): -330.000000 +0.000000\n" + + "0.01 0.01 0.01 0.01 0.01 0.01 0.01 1.0\n" + + "tree length = 0.018\n" + + "((A:0.004,B:0.004):0.002,C:0.008);\n", + ) catch { + BasemlError(message) => abort("failed to parse null model: " + message) + } +} + +///| +fn main { + println("=== Biopython Bio.Phylo.PAML.baseml Offline Demo ===") + let control = baseml_demo_control() + let model = match control.model_number() { + Some(value) => value + None => abort("control has no model") + } + println("\n1. Strict BASEML control parsing") + println(" sequence file: " + control.sequence_file()) + println(" tree file: " + control.tree_file()) + println( + " model: " + + model.to_string() + + " (" + + (@bio.baseml_model_name(model) catch { + BasemlError(message) => abort(message) + }) + + ")", + ) + let canonical = @bio.baseml_write_control(control) + let reparsed = @bio.baseml_parse_control(canonical) catch { + BasemlError(message) => abort("control round-trip failed: " + message) + } + println(" canonical round-trip: " + (reparsed == control).to_string()) + + let result = baseml_demo_results() + println("\n2. PAML result, parameters, and standard errors") + println( + " PAML=" + + result.version() + + ", model=" + + result.model_description() + + ", lnL=" + + result.ln_likelihood().to_string(), + ) + println( + " parameters=" + + result.parameter_count().to_string() + + ", SE values=" + + result.standard_errors().length().to_string() + + ", tree length=" + + result.tree_length().to_string(), + ) + + println("\n3. REV rate matrix and discrete gamma") + match result.q_matrix() { + Some(matrix) => { + let average = match matrix.average_ts_tv() { + Some(value) => value.to_string() + None => "not reported" + } + println( + " Q dimensions=" + + matrix.rows().length().to_string() + + "x" + + matrix.rows()[0].length().to_string() + + ", average Ts/Tv=" + + average, + ) + } + None => abort("result has no Q matrix") + } + let alpha_text = match result.alpha() { + Some(value) => value.to_string() + None => "not reported" + } + println( + " rate categories=" + + result.rates().length().to_string() + + ", alpha=" + + alpha_text, + ) + + let comparison = @bio.baseml_likelihood_ratio( + baseml_demo_null_model(), + result, + ) catch { + BasemlError(message) => abort("likelihood-ratio test failed: " + message) + } + let bic = result.bic(222) catch { + BasemlError(message) => abort("BIC calculation failed: " + message) + } + println("\n4. Information criteria and nested-model LRT") + println(" REV AIC=" + result.aic().to_string() + ", BIC=" + bic.to_string()) + println( + " statistic=" + + comparison.statistic().to_string() + + ", df=" + + comparison.degrees_of_freedom().to_string() + + ", p=" + + comparison.p_value().to_string() + + ", significant=" + + comparison.significant().to_string(), + ) + + println( + "\nThe demo parses existing BASEML artifacts; it does not launch PAML.", + ) +} diff --git a/examples/paml_baseml_demo/moon.pkg b/examples/paml_baseml_demo/moon.pkg new file mode 100644 index 00000000..4ecfd216 --- /dev/null +++ b/examples/paml_baseml_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src" @bio, +} + +pkgtype(kind: "executable") diff --git a/examples/paml_codeml_demo/main.mbt b/examples/paml_codeml_demo/main.mbt new file mode 100644 index 00000000..3343b774 --- /dev/null +++ b/examples/paml_codeml_demo/main.mbt @@ -0,0 +1,114 @@ +///| +fn codeml_demo_control() -> @bio.CodemlControl { + @bio.codeml_parse_control(@bio.codeml_example_control_text()) catch { + CodemlError(message) => abort("failed to parse CODEML control: " + message) + } +} + +///| +fn codeml_demo_results() -> @bio.CodemlResults { + @bio.codeml_parse_results(@bio.codeml_example_results_text()) catch { + CodemlError(message) => abort("failed to parse CODEML results: " + message) + } +} + +///| +fn codeml_demo_ints(values : Array[Int]) -> String { + "[" + values.map(fn(value) { value.to_string() }).join(", ") + "]" +} + +///| +fn main { + println("=== Biopython Bio.Phylo.PAML.codeml Offline Demo ===") + let control = codeml_demo_control() + println("\n1. Strict CODEML control parsing") + println(" sequence file: " + control.sequence_file()) + println(" tree file: " + control.tree_file()) + println(" NSsites: " + codeml_demo_ints(control.ns_sites())) + let written = @bio.codeml_write_control(control) + let reparsed = @bio.codeml_parse_control(written) catch { + CodemlError(message) => abort("control round-trip failed: " + message) + } + println( + " canonical round-trip: " + + (reparsed.ns_sites() == control.ns_sites()).to_string(), + ) + + let results = codeml_demo_results() + let models = results.models() + let null_model = models[0] + let selection_model = models[1] + println("\n2. CODONML metadata and multiple NSsites models") + println( + " program=" + + results.program() + + ", PAML=" + + results.version() + + ", sequences=" + + results.sequence_count().to_string() + + ", sites=" + + results.site_count().to_string(), + ) + println( + " M0 lnL=" + + null_model.ln_likelihood().to_string() + + ", parameters=" + + null_model.parameter_count().to_string(), + ) + println( + " M2 lnL=" + + selection_model.ln_likelihood().to_string() + + ", parameters=" + + selection_model.parameter_count().to_string(), + ) + + let branches = null_model.branches() + let site_classes = selection_model.site_classes() + let positive_sites = selection_model.positive_sites() + println("\n3. Branch, site-class, and BEB estimates") + println( + " branches=" + + branches.length().to_string() + + ", first branch=" + + branches[0].branch(), + ) + println( + " site classes=" + + site_classes.length().to_string() + + ", selected class proportion=" + + site_classes[2].proportion().to_string(), + ) + println( + " BEB site " + + positive_sites[0].position().to_string() + + positive_sites[0].amino_acid() + + ", probability=" + + positive_sites[0].probability().to_string() + + positive_sites[0].significance(), + ) + + let bic = selection_model.bic(results.site_count()) catch { + CodemlError(message) => abort("BIC calculation failed: " + message) + } + let comparison = @bio.codeml_likelihood_ratio(null_model, selection_model) catch { + CodemlError(message) => abort("likelihood-ratio test failed: " + message) + } + println("\n4. Information criteria and nested-model LRT") + println( + " M2 AIC=" + selection_model.aic().to_string() + ", BIC=" + bic.to_string(), + ) + println( + " statistic=" + + comparison.statistic().to_string() + + ", df=" + + comparison.degrees_of_freedom().to_string() + + ", p=" + + comparison.p_value().to_string() + + ", significant=" + + comparison.significant().to_string(), + ) + + println( + "\nThe demo parses existing CODEML artifacts; it does not launch PAML.", + ) +} diff --git a/examples/paml_codeml_demo/moon.pkg b/examples/paml_codeml_demo/moon.pkg new file mode 100644 index 00000000..4ecfd216 --- /dev/null +++ b/examples/paml_codeml_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src" @bio, +} + +pkgtype(kind: "executable") diff --git a/examples/paml_yn00_demo/main.mbt b/examples/paml_yn00_demo/main.mbt new file mode 100644 index 00000000..73da807c --- /dev/null +++ b/examples/paml_yn00_demo/main.mbt @@ -0,0 +1,122 @@ +///| +fn optional_value(value : Double?) -> String { + match value { + Some(number) => number.to_string() + None => "undefined" + } +} + +///| +fn yn00_demo_control(text : String) -> @bio.Yn00Control { + @bio.yn00_parse_control(text) catch { + Yn00Error(message) => abort("failed to parse YN00 control: " + message) + } +} + +///| +fn yn00_demo_results() -> @bio.Yn00Results { + @bio.yn00_parse_results(@bio.yn00_example_results_text()) catch { + Yn00Error(message) => abort("failed to parse YN00 results: " + message) + } +} + +///| +fn yn00_demo_matrix(results : @bio.Yn00Results) -> @bio.Yn00DistanceMatrix { + results.matrix("YN00", "dS") catch { + Yn00Error(message) => abort("failed to build YN00 matrix: " + message) + } +} + +///| +fn yn00_demo_mean(results : @bio.Yn00Results) -> Double { + results.mean("YN00", "dS") catch { + Yn00Error(message) => abort("failed to calculate YN00 mean: " + message) + } +} + +///| +fn main { + println("=== Biopython Bio.Phylo.PAML.yn00 Offline Demo ===") + let control = yn00_demo_control(@bio.yn00_example_control_text()) + let canonical = @bio.yn00_write_control(control) + println("\n1. Strict YN00 control parsing") + println(" sequence file: " + control.sequence_file()) + println(" output file: " + control.output_file()) + println(" genetic code: " + control.option("icode").unwrap_or("default")) + println( + " canonical round-trip: " + + (@bio.yn00_write_control(yn00_demo_control(canonical)) == canonical).to_string(), + ) + + let results = yn00_demo_results() + println("\n2. Complete pairwise result") + println( + " alignment=" + + results.alignment_file() + + ", sequences=" + + results.sequence_count().to_string() + + ", codons=" + + results.codon_count().to_string() + + ", pairs=" + + results.pairs().length().to_string(), + ) + println(" names: " + results.sequence_names().join(", ")) + + let pair = results.pair("Homo_sapie", "Pan_troglo").unwrap() + let yn = pair.yang_nielsen() + println("\n3. Five methods for Homo_sapie vs Pan_troglo") + println( + " NG86: omega=" + + pair.ng86().omega().to_string() + + ", dN=" + + pair.ng86().dn().to_string() + + ", dS=" + + pair.ng86().ds().to_string(), + ) + println( + " YN00: kappa=" + + yn.kappa().to_string() + + ", omega=" + + yn.omega().to_string() + + ", dN=" + + yn.dn().to_string() + + " +- " + + yn.dn_standard_error().to_string() + + ", dS=" + + yn.ds().to_string() + + " +- " + + yn.ds_standard_error().to_string(), + ) + println( + " LWL85: omega=" + + optional_value(pair.lwl85().omega()) + + ", dS=" + + optional_value(pair.lwl85().ds()), + ) + println( + " LWL85m: omega=" + + optional_value(pair.lwl85_modified().omega()) + + ", rho=" + + optional_value(pair.lwl85_modified().rho()), + ) + println( + " LPB93: omega=" + + optional_value(pair.lpb93().omega()) + + ", dS=" + + optional_value(pair.lpb93().ds()), + ) + + let matrix = yn00_demo_matrix(results) + println("\n4. Symmetric Yang-Nielsen dS matrix") + let names = matrix.names() + for first in names { + let row : Array[String] = [] + for second in names { + row.push(optional_value(matrix.value(first, second))) + } + println(" " + first + ": " + row.join(", ")) + } + println(" mean pairwise dS: " + yn00_demo_mean(results).to_string()) + + println("\nThe demo parses existing YN00 artifacts; it does not launch PAML.") +} diff --git a/examples/paml_yn00_demo/moon.pkg b/examples/paml_yn00_demo/moon.pkg new file mode 100644 index 00000000..4ecfd216 --- /dev/null +++ b/examples/paml_yn00_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src" @bio, +} + +pkgtype(kind: "executable") diff --git a/src/align_clustal.mbt b/src/align_clustal.mbt new file mode 100644 index 00000000..0bccc917 --- /dev/null +++ b/src/align_clustal.mbt @@ -0,0 +1,1363 @@ +// Biopython-compatible Bio.Align.clustal support. +// +// This module is separate from clustal_io.mbt. The older module exposes the +// historical AlignIO-style MultipleSeqAlignment API, while this file retains +// modern file metadata, column annotations, and coordinate-aware rows. + +///| +/// Error raised for malformed CLUSTAL data or invalid alignment operations. +pub suberror AlignClustalError { + AlignClustalError(String) +} + +///| +/// File-level metadata from a CLUSTAL alignment. +/// +/// Known generators follow Biopython 1.86: CLUSTAL, PROBCONS, MUSCLE, +/// MSAPROBS, Kalign, and Biopython. +pub struct AlignClustalMetadata { + program : String + version : String + header : String +} derive(Eq, Debug) + +///| +/// One coordinate-bearing row in a CLUSTAL alignment. +pub struct AlignClustalSequence { + id : String + sequence : String + aligned_sequence : String +} derive(Eq, Debug) + +///| +/// A modern CLUSTAL multiple sequence alignment. +/// +/// `consensus` retains the `*`, `:`, `.`, and space column annotation when it +/// is present. Sparse source annotations are padded with spaces. +pub struct AlignClustalAlignment { + metadata : AlignClustalMetadata + sequences : Array[AlignClustalSequence] + consensus : String? +} derive(Eq, Debug) + +///| +/// Pairwise or all-pairs alignment statistics. +pub struct AlignClustalCounts { + pairs : Int + aligned : Int + identities : Int + mismatches : Int + gap_columns : Int + double_gap_columns : Int + gap_opens : Int +} derive(Eq, Debug) + +///| +/// One parsed interleaved block. +priv struct AlignClustalBlock { + ids : Array[String] + segments : Array[String] + residue_counts : Array[Int?] + consensus : String? + width : Int +} + +///| +/// Construct validated CLUSTAL file metadata. +pub fn AlignClustalMetadata::create( + program : String, + version? : String = "", + header? : String = "", +) -> AlignClustalMetadata raise AlignClustalError { + align_clustal_validate_program(program) + align_clustal_validate_version(version) + let canonical_header = if header.length() == 0 { + align_clustal_canonical_header(program, version) + } else { + align_clustal_validate_plain_text(header, "CLUSTAL header") + header + } + AlignClustalMetadata::{ program, version, header: canonical_header } +} + +///| +/// Construct one validated CLUSTAL row. +pub fn AlignClustalSequence::create( + id : String, + aligned_sequence : String, +) -> AlignClustalSequence raise AlignClustalError { + align_clustal_validate_id(id) + if aligned_sequence.length() == 0 { + raise AlignClustalError("CLUSTAL aligned sequence must not be empty") + } + align_clustal_validate_segment(aligned_sequence) + let sequence = align_clustal_remove_gaps(aligned_sequence) + if sequence.length() == 0 { + raise AlignClustalError( + "CLUSTAL sequence row must contain at least one residue", + ) + } + AlignClustalSequence::{ id, sequence, aligned_sequence } +} + +///| +/// Construct a validated modern CLUSTAL alignment. +pub fn AlignClustalAlignment::create( + metadata : AlignClustalMetadata, + sequences : Array[AlignClustalSequence], + consensus? : String? = None, +) -> AlignClustalAlignment raise AlignClustalError { + let copied : Array[AlignClustalSequence] = [] + for sequence in sequences { + copied.push(sequence) + } + let alignment = AlignClustalAlignment::{ + metadata, + sequences: copied, + consensus, + } + align_clustal_validate_alignment(alignment) + alignment +} + +///| +/// Construct a coordinate-aware alignment from printed rows. +pub fn align_clustal_from_aligned( + ids : Array[String], + aligned_sequences : Array[String], + program? : String = "Biopython", + version? : String = "", + consensus? : String? = None, +) -> AlignClustalAlignment raise AlignClustalError { + if ids.length() == 0 { + raise AlignClustalError( + "CLUSTAL alignment must contain at least one sequence", + ) + } + if ids.length() != aligned_sequences.length() { + raise AlignClustalError( + "CLUSTAL identifiers and aligned rows must have equal lengths", + ) + } + let sequences : Array[AlignClustalSequence] = [] + for index = 0; index < ids.length(); index = index + 1 { + sequences.push( + AlignClustalSequence::create(ids[index], aligned_sequences[index]), + ) + } + let metadata = AlignClustalMetadata::create(program, version~) + AlignClustalAlignment::create(metadata, sequences, consensus~) +} + +///| +/// Parse one CLUSTAL alignment. +/// +/// Blocks must repeat the first block's unique identifiers in the same order. +/// Optional right-hand residue counts are validated as cumulative ungapped +/// counts. Consensus lines may be absent from some blocks; missing portions +/// are represented by spaces in the retained column annotation. +pub fn align_clustal_parse( + text : String, +) -> AlignClustalAlignment raise AlignClustalError { + let lines = align_clustal_lines(text) + if lines.length() == 0 || lines[0].trim().length() == 0 { + raise AlignClustalError("Empty CLUSTAL input") + } + let metadata = align_clustal_parse_header(lines[0]) + let blocks : Array[AlignClustalBlock] = [] + let mut block_lines : Array[String] = [] + for line_index = 1; line_index < lines.length(); line_index = line_index + 1 { + let line = lines[line_index] + if line.trim().length() == 0 { + if line.length() >= 10 && block_lines.length() > 0 { + block_lines.push(line) + } else if block_lines.length() > 0 { + blocks.push(align_clustal_parse_block(block_lines)) + block_lines = [] + } + } else { + block_lines.push(line) + } + } + if block_lines.length() > 0 { + blocks.push(align_clustal_parse_block(block_lines)) + } + if blocks.length() == 0 { + raise AlignClustalError("CLUSTAL input contains no alignment rows") + } + + let ids = blocks[0].ids + let builders : Array[StringBuilder] = [] + let cumulative = Array::make(ids.length(), 0) + let seen_ids : Array[String] = [] + for id in ids { + align_clustal_validate_id(id) + if align_clustal_find_string(seen_ids, id) >= 0 { + raise AlignClustalError( + "Duplicated CLUSTAL sequence identifier '" + id + "'", + ) + } + seen_ids.push(id) + builders.push(StringBuilder::new()) + } + + let consensus_builder = StringBuilder::new() + let mut has_consensus = false + for block_index = 0 + block_index < blocks.length() + block_index = block_index + 1 { + let block = blocks[block_index] + if block.ids.length() != ids.length() { + raise AlignClustalError( + "CLUSTAL block sequence count differs from the first block", + ) + } + for row = 0; row < ids.length(); row = row + 1 { + if block.ids[row] != ids[row] { + raise AlignClustalError( + "CLUSTAL block identifiers must repeat in the same order", + ) + } + builders[row].write_string(block.segments[row]) + cumulative[row] = cumulative[row] + + align_clustal_residue_count(block.segments[row]) + match block.residue_counts[row] { + Some(declared) => + if declared != cumulative[row] { + raise AlignClustalError( + "CLUSTAL cumulative residue count mismatch for '" + ids[row] + "'", + ) + } + None => () + } + } + match block.consensus { + Some(annotation) => { + has_consensus = true + consensus_builder.write_string(annotation) + } + None => consensus_builder.write_string(" ".repeat(block.width)) + } + } + + let sequences : Array[AlignClustalSequence] = [] + for row = 0; row < ids.length(); row = row + 1 { + sequences.push( + AlignClustalSequence::create(ids[row], builders[row].to_string()), + ) + } + let consensus : String? = if has_consensus { + Some(consensus_builder.to_string()) + } else { + None + } + AlignClustalAlignment::create(metadata, sequences, consensus~) +} + +///| +/// Write canonical CLUSTAL text. +/// +/// Biopython-compatible defaults use 50 alignment columns and a 36-character +/// name field. Identifiers are never silently truncated; names longer than 30 +/// characters require a larger `name_width`. +pub fn align_clustal_write( + alignment : AlignClustalAlignment, + block_width? : Int = 50, + name_width? : Int = 36, + include_counts? : Bool = false, + include_consensus? : Bool = true, +) -> String raise AlignClustalError { + align_clustal_validate_alignment(alignment) + if block_width <= 0 { + raise AlignClustalError("CLUSTAL block width must be positive") + } + if name_width <= 1 { + raise AlignClustalError("CLUSTAL name width must be greater than one") + } + for sequence in alignment.sequences { + if sequence.id.length() >= name_width { + raise AlignClustalError( + "CLUSTAL name width must exceed every identifier length", + ) + } + if name_width == 36 && sequence.id.length() > 30 { + raise AlignClustalError( + "CLUSTAL canonical writer does not silently truncate identifiers " + + "longer than 30 characters", + ) + } + } + let output = StringBuilder::new() + output.write_string( + align_clustal_canonical_header( + alignment.metadata.program, + alignment.metadata.version, + ), + ) + output.write_string("\n\n\n") + let cumulative = Array::make(alignment.num_sequences(), 0) + let width = alignment.alignment_length() + let mut start = 0 + while start < width { + let stop = if start + block_width < width { + start + block_width + } else { + width + } + for row = 0; row < alignment.num_sequences(); row = row + 1 { + let sequence = alignment.sequences[row] + let segment = sequence.aligned_sequence[start:stop].to_owned() + output.write_string(sequence.id) + output.write_string(" ".repeat(name_width - sequence.id.length())) + output.write_string(segment) + cumulative[row] = cumulative[row] + align_clustal_residue_count(segment) + if include_counts { + output.write_char(' ') + output.write_string(cumulative[row].to_string()) + } + output.write_char('\n') + } + if include_consensus { + match alignment.consensus { + Some(consensus) => { + output.write_string(" ".repeat(name_width)) + output.write_string(consensus[start:stop].to_owned()) + output.write_char('\n') + } + None => () + } + } + output.write_char('\n') + start = stop + } + output.write_char('\n') + let result = output.to_string() + ignore(align_clustal_parse(result)) + result +} + +///| +/// Return the number of sequence rows. +pub fn AlignClustalAlignment::num_sequences( + self : AlignClustalAlignment, +) -> Int { + self.sequences.length() +} + +///| +/// Return the alignment width including gaps. +pub fn AlignClustalAlignment::alignment_length( + self : AlignClustalAlignment, +) -> Int { + if self.sequences.length() == 0 { + 0 + } else { + self.sequences[0].aligned_sequence.length() + } +} + +///| +/// Locate a row by exact identifier. +pub fn AlignClustalAlignment::find_sequence( + self : AlignClustalAlignment, + id : String, +) -> Int? { + for index = 0; index < self.sequences.length(); index = index + 1 { + if self.sequences[index].id == id { + return Some(index) + } + } + None +} + +///| +/// Return one printed alignment column. +pub fn AlignClustalAlignment::column( + self : AlignClustalAlignment, + column : Int, +) -> String? { + if column < 0 || column >= self.alignment_length() { + return None + } + let result = StringBuilder::new(size_hint=self.sequences.length()) + for sequence in self.sequences { + result.write_char( + sequence.aligned_sequence.unsafe_get(column).unsafe_to_char(), + ) + } + Some(result.to_string()) +} + +///| +/// Map a zero-based ungapped row position to an alignment column. +pub fn AlignClustalAlignment::sequence_position_to_column( + self : AlignClustalAlignment, + row : Int, + position : Int, +) -> Int? { + if row < 0 || + row >= self.sequences.length() || + position < 0 || + position >= self.sequences[row].sequence.length() { + return None + } + let aligned = self.sequences[row].aligned_sequence + let mut coordinate = 0 + for column = 0; column < aligned.length(); column = column + 1 { + if aligned.unsafe_get(column).to_int() != '-'.to_int() { + if coordinate == position { + return Some(column) + } + coordinate = coordinate + 1 + } + } + None +} + +///| +/// Map one alignment column to a zero-based ungapped row position. +pub fn AlignClustalAlignment::column_to_sequence_position( + self : AlignClustalAlignment, + row : Int, + column : Int, +) -> Int? { + if row < 0 || + row >= self.sequences.length() || + column < 0 || + column >= self.alignment_length() { + return None + } + let aligned = self.sequences[row].aligned_sequence + if aligned.unsafe_get(column).to_int() == '-'.to_int() { + return None + } + let mut coordinate = 0 + for index = 0; index < column; index = index + 1 { + if aligned.unsafe_get(index).to_int() != '-'.to_int() { + coordinate = coordinate + 1 + } + } + Some(coordinate) +} + +///| +/// Project one row position through the alignment to another row. +pub fn AlignClustalAlignment::map_position( + self : AlignClustalAlignment, + source_row : Int, + target_row : Int, + source_position : Int, +) -> Int? { + if target_row < 0 || target_row >= self.sequences.length() { + return None + } + match self.sequence_position_to_column(source_row, source_position) { + Some(column) => self.column_to_sequence_position(target_row, column) + None => None + } +} + +///| +/// Return per-column residue positions for two rows. +pub fn AlignClustalAlignment::aligned_pairs( + self : AlignClustalAlignment, + first_row : Int, + second_row : Int, +) -> Array[(Int?, Int?)] raise AlignClustalError { + align_clustal_validate_row(self, first_row) + align_clustal_validate_row(self, second_row) + let result : Array[(Int?, Int?)] = [] + let mut first_position = 0 + let mut second_position = 0 + for column = 0; column < self.alignment_length(); column = column + 1 { + let first_gap = self.sequences[first_row].aligned_sequence + .unsafe_get(column) + .to_int() == + '-'.to_int() + let second_gap = self.sequences[second_row].aligned_sequence + .unsafe_get(column) + .to_int() == + '-'.to_int() + result.push( + ( + if first_gap { + None + } else { + Some(first_position) + }, + if second_gap { + None + } else { + Some(second_position) + }, + ), + ) + if !first_gap { + first_position = first_position + 1 + } + if !second_gap { + second_position = second_position + 1 + } + } + result +} + +///| +/// Return a compact Biopython-style coordinate path for all rows. +pub fn AlignClustalAlignment::coordinate_path( + self : AlignClustalAlignment, +) -> Array[Array[Int]] { + let paths : Array[Array[Int]] = [] + let coordinates = Array::make(self.sequences.length(), 0) + for _row = 0; _row < self.sequences.length(); _row = _row + 1 { + paths.push([0]) + } + let width = self.alignment_length() + for column = 0; column < width; column = column + 1 { + for row = 0; row < self.sequences.length(); row = row + 1 { + if self.sequences[row].aligned_sequence.unsafe_get(column).to_int() != + '-'.to_int() { + coordinates[row] = coordinates[row] + 1 + } + } + let boundary = if column + 1 == width { + true + } else { + align_clustal_movement_changes(self, column, column + 1) + } + if boundary { + for row = 0; row < self.sequences.length(); row = row + 1 { + paths[row].push(coordinates[row]) + } + } + } + paths +} + +///| +/// Compute statistics for one pair of rows. +pub fn AlignClustalAlignment::pair_counts( + self : AlignClustalAlignment, + first_row : Int, + second_row : Int, +) -> AlignClustalCounts raise AlignClustalError { + align_clustal_validate_row(self, first_row) + align_clustal_validate_row(self, second_row) + align_clustal_count_pair(self, first_row, second_row) +} + +///| +/// Aggregate statistics across every unordered pair. +pub fn AlignClustalAlignment::counts( + self : AlignClustalAlignment, +) -> AlignClustalCounts { + let mut pairs = 0 + let mut aligned = 0 + let mut identities = 0 + let mut mismatches = 0 + let mut gap_columns = 0 + let mut double_gap_columns = 0 + let mut gap_opens = 0 + for first = 0; first < self.sequences.length(); first = first + 1 { + for second = first + 1 + second < self.sequences.length() + second = second + 1 { + let counts = align_clustal_count_pair(self, first, second) + pairs = pairs + 1 + aligned = aligned + counts.aligned + identities = identities + counts.identities + mismatches = mismatches + counts.mismatches + gap_columns = gap_columns + counts.gap_columns + double_gap_columns = double_gap_columns + counts.double_gap_columns + gap_opens = gap_opens + counts.gap_opens + } + } + AlignClustalCounts::{ + pairs, + aligned, + identities, + mismatches, + gap_columns, + double_gap_columns, + gap_opens, + } +} + +///| +/// Return exact identity over columns containing residues in both rows. +pub fn AlignClustalCounts::identity(self : AlignClustalCounts) -> Double { + if self.aligned == 0 { + 0.0 + } else { + self.identities.to_double() / self.aligned.to_double() + } +} + +///| +/// Return per-column non-gap occupancy. +pub fn AlignClustalAlignment::occupancy( + self : AlignClustalAlignment, +) -> Array[Double] { + let result : Array[Double] = [] + for column = 0; column < self.alignment_length(); column = column + 1 { + let mut residues = 0 + for sequence in self.sequences { + if sequence.aligned_sequence.unsafe_get(column).to_int() != '-'.to_int() { + residues = residues + 1 + } + } + result.push(residues.to_double() / self.sequences.length().to_double()) + } + result +} + +///| +/// Calculate a majority residue consensus. Gaps do not vote. +pub fn AlignClustalAlignment::majority_consensus( + self : AlignClustalAlignment, + minimum_fraction? : Double = 0.0, +) -> String raise AlignClustalError { + if minimum_fraction != minimum_fraction || + minimum_fraction < 0.0 || + minimum_fraction > 1.0 { + raise AlignClustalError( + "CLUSTAL consensus minimum fraction must be between 0 and 1", + ) + } + let output = StringBuilder::new(size_hint=self.alignment_length()) + for column = 0; column < self.alignment_length(); column = column + 1 { + let frequencies = Array::make(128, 0) + let mut residues = 0 + for sequence in self.sequences { + let code = sequence.aligned_sequence.unsafe_get(column).to_int() + if code != '-'.to_int() { + let upper = align_clustal_upper_code(code) + if upper >= 0 && upper < frequencies.length() { + frequencies[upper] = frequencies[upper] + 1 + } + residues = residues + 1 + } + } + if residues == 0 { + output.write_char('-') + continue + } + let mut best_code = 0 + let mut best_count = -1 + for code = 0; code < frequencies.length(); code = code + 1 { + if frequencies[code] > best_count { + best_code = code + best_count = frequencies[code] + } + } + if best_count.to_double() / residues.to_double() < minimum_fraction { + output.write_char('X') + } else { + output.write_char(best_code.unsafe_to_char()) + } + } + output.to_string() +} + +///| +/// Calculate CLUSTAL `*`, `:`, `.`, and space conservation symbols. +/// +/// Nucleotide alignments receive `*` only for exact fully occupied columns. +/// Protein alignments additionally use the standard strong and weak ClustalW +/// residue groups. +pub fn AlignClustalAlignment::calculated_consensus( + self : AlignClustalAlignment, +) -> String { + let output = StringBuilder::new(size_hint=self.alignment_length()) + let nucleotide = align_clustal_is_nucleotide(self) + let strong_groups = [ + "STA", "NEQK", "NHQK", "NDEQ", "QHRK", "MILV", "MILF", "HY", "FYW", + ] + let weak_groups = [ + "CSA", "ATV", "SAG", "STNK", "STPA", "SGND", "SNDEQK", "NDEQHK", "NEQHRK", "FVLIM", + "HFY", + ] + for column = 0; column < self.alignment_length(); column = column + 1 { + if align_clustal_column_has_gap(self, column) { + output.write_char(' ') + } else if align_clustal_column_identical(self, column) { + output.write_char('*') + } else if !nucleotide && + align_clustal_column_in_any_group(self, column, strong_groups) { + output.write_char(':') + } else if !nucleotide && + align_clustal_column_in_any_group(self, column, weak_groups) { + output.write_char('.') + } else { + output.write_char(' ') + } + } + output.to_string() +} + +///| +/// Return a compact alignment summary. +pub fn AlignClustalAlignment::summary(self : AlignClustalAlignment) -> String { + "AlignClustalAlignment(program=" + + self.metadata.program + + ", version=" + + self.metadata.version + + ", sequences=" + + self.num_sequences().to_string() + + ", columns=" + + self.alignment_length().to_string() + + ", consensus=" + + (match self.consensus { + Some(_) => "yes" + None => "no" + }) + + ")" +} + +///| +/// Return a compact interleaved CLUSTAL example with counts and consensus. +pub fn align_clustal_example_text() -> String { + "CLUSTAL W (2.1) multiple sequence alignment\n" + + "\n" + + "\n" + + "reference MKT--AI 5\n" + + "query_one M-TQQAI 6\n" + + "query_two MKT--AV 5\n" + + " * * *:\n" + + "\n" + + "reference LGH 8\n" + + "query_one LG- 8\n" + + "query_two LGH 8\n" + + " ** \n" +} + +///| +fn align_clustal_validate_alignment( + alignment : AlignClustalAlignment, +) -> Unit raise AlignClustalError { + align_clustal_validate_program(alignment.metadata.program) + align_clustal_validate_version(alignment.metadata.version) + align_clustal_validate_plain_text(alignment.metadata.header, "CLUSTAL header") + if alignment.sequences.length() == 0 { + raise AlignClustalError( + "CLUSTAL alignment must contain at least one sequence", + ) + } + let width = alignment.sequences[0].aligned_sequence.length() + if width == 0 { + raise AlignClustalError( + "CLUSTAL alignment must contain at least one column", + ) + } + let ids : Array[String] = [] + for sequence in alignment.sequences { + align_clustal_validate_id(sequence.id) + if align_clustal_find_string(ids, sequence.id) >= 0 { + raise AlignClustalError( + "Duplicated CLUSTAL sequence identifier '" + sequence.id + "'", + ) + } + ids.push(sequence.id) + if sequence.aligned_sequence.length() != width { + raise AlignClustalError("CLUSTAL aligned rows must have equal widths") + } + align_clustal_validate_segment(sequence.aligned_sequence) + if align_clustal_remove_gaps(sequence.aligned_sequence) != sequence.sequence { + raise AlignClustalError( + "CLUSTAL sequence row has inconsistent derived fields", + ) + } + } + for column = 0; column < width; column = column + 1 { + let mut residues = 0 + for sequence in alignment.sequences { + if sequence.aligned_sequence.unsafe_get(column).to_int() != '-'.to_int() { + residues = residues + 1 + } + } + if residues == 0 { + raise AlignClustalError( + "CLUSTAL alignment contains an all-gap column at " + column.to_string(), + ) + } + } + match alignment.consensus { + Some(consensus) => { + if consensus.length() != width { + raise AlignClustalError( + "CLUSTAL consensus length must equal the alignment width", + ) + } + align_clustal_validate_consensus(consensus) + } + None => () + } +} + +///| +fn align_clustal_parse_header( + line : String, +) -> AlignClustalMetadata raise AlignClustalError { + let words = align_clustal_split_whitespace(line) + if words.length() == 0 { + raise AlignClustalError("Empty CLUSTAL header") + } + let program = words[0] + align_clustal_validate_program(program) + let mut version = "" + for index = 1; index < words.length(); index = index + 1 { + let word = align_clustal_strip_parentheses(words[index]) + if word.length() > 0 { + let first = word.unsafe_get(0).to_int() + if first >= '0'.to_int() && first <= '9'.to_int() { + version = word + break + } + } + } + AlignClustalMetadata::create(program, version~, header=line) +} + +///| +fn align_clustal_parse_block( + lines : Array[String], +) -> AlignClustalBlock raise AlignClustalError { + let ids : Array[String] = [] + let segments : Array[String] = [] + let residue_counts : Array[Int?] = [] + let mut segment_start = -1 + let mut width = -1 + let mut consensus : String? = None + let mut saw_consensus = false + for line in lines { + if line.length() == 0 { + continue + } + let first = line.unsafe_get(0).to_int() + if align_clustal_is_whitespace(first) { + if ids.length() == 0 { + raise AlignClustalError( + "CLUSTAL consensus line appears before sequence rows", + ) + } + if saw_consensus { + raise AlignClustalError( + "CLUSTAL block contains multiple consensus lines", + ) + } + saw_consensus = true + let annotation = align_clustal_extract_consensus( + line, segment_start, width, + ) + consensus = Some(annotation) + } else { + if saw_consensus { + raise AlignClustalError( + "CLUSTAL sequence row appears after a consensus line", + ) + } + let fields = align_clustal_split_whitespace(line) + if fields.length() < 2 || fields.length() > 3 { + raise AlignClustalError( + "CLUSTAL sequence line must contain two or three fields", + ) + } + let id = fields[0] + let segment = fields[1] + align_clustal_validate_id(id) + align_clustal_validate_segment(segment) + if segment_start < 0 { + segment_start = align_clustal_segment_start(line) + } + if width < 0 { + width = segment.length() + } else if segment.length() != width { + raise AlignClustalError( + "CLUSTAL rows in one block must have equal widths", + ) + } + ids.push(id) + segments.push(segment) + if fields.length() == 3 { + residue_counts.push( + Some( + align_clustal_parse_nonnegative_int( + fields[2], + "CLUSTAL residue count", + ), + ), + ) + } else { + residue_counts.push(None) + } + } + } + if ids.length() == 0 || width <= 0 { + raise AlignClustalError("CLUSTAL block contains no sequence rows") + } + AlignClustalBlock::{ ids, segments, residue_counts, consensus, width } +} + +///| +fn align_clustal_extract_consensus( + line : String, + start : Int, + width : Int, +) -> String raise AlignClustalError { + if start < 0 || width <= 0 { + raise AlignClustalError("Invalid CLUSTAL consensus position") + } + for index = 0; index < start && index < line.length(); index = index + 1 { + if !align_clustal_is_whitespace(line.unsafe_get(index).to_int()) { + raise AlignClustalError( + "CLUSTAL consensus line is not aligned with sequence data", + ) + } + } + let output = StringBuilder::new(size_hint=width) + for offset = 0; offset < width; offset = offset + 1 { + let index = start + offset + if index >= line.length() { + output.write_char(' ') + } else { + let code = line.unsafe_get(index).to_int() + if code == ' '.to_int() { + output.write_char(' ') + } else if code == '*'.to_int() || + code == ':'.to_int() || + code == '.'.to_int() { + output.write_char(code.unsafe_to_char()) + } else { + raise AlignClustalError("CLUSTAL consensus contains an invalid symbol") + } + } + } + for index = start + width; index < line.length(); index = index + 1 { + if !align_clustal_is_whitespace(line.unsafe_get(index).to_int()) { + raise AlignClustalError( + "CLUSTAL consensus has non-whitespace trailing data", + ) + } + } + output.to_string() +} + +///| +fn align_clustal_count_pair( + alignment : AlignClustalAlignment, + first_row : Int, + second_row : Int, +) -> AlignClustalCounts { + let first = alignment.sequences[first_row].aligned_sequence + let second = alignment.sequences[second_row].aligned_sequence + let mut aligned = 0 + let mut identities = 0 + let mut mismatches = 0 + let mut gap_columns = 0 + let mut double_gap_columns = 0 + let mut gap_opens = 0 + let mut in_gap = false + for column = 0; column < alignment.alignment_length(); column = column + 1 { + let first_code = first.unsafe_get(column).to_int() + let second_code = second.unsafe_get(column).to_int() + let first_gap = first_code == '-'.to_int() + let second_gap = second_code == '-'.to_int() + if first_gap && second_gap { + double_gap_columns = double_gap_columns + 1 + in_gap = false + } else if first_gap || second_gap { + gap_columns = gap_columns + 1 + if !in_gap { + gap_opens = gap_opens + 1 + } + in_gap = true + } else { + aligned = aligned + 1 + if first_code == second_code { + identities = identities + 1 + } else { + mismatches = mismatches + 1 + } + in_gap = false + } + } + AlignClustalCounts::{ + pairs: 1, + aligned, + identities, + mismatches, + gap_columns, + double_gap_columns, + gap_opens, + } +} + +///| +fn align_clustal_movement_changes( + alignment : AlignClustalAlignment, + first_column : Int, + second_column : Int, +) -> Bool { + for sequence in alignment.sequences { + let first_moves = sequence.aligned_sequence + .unsafe_get(first_column) + .to_int() != + '-'.to_int() + let second_moves = sequence.aligned_sequence + .unsafe_get(second_column) + .to_int() != + '-'.to_int() + if first_moves != second_moves { + return true + } + } + false +} + +///| +fn align_clustal_column_has_gap( + alignment : AlignClustalAlignment, + column : Int, +) -> Bool { + for sequence in alignment.sequences { + if sequence.aligned_sequence.unsafe_get(column).to_int() == '-'.to_int() { + return true + } + } + false +} + +///| +fn align_clustal_column_identical( + alignment : AlignClustalAlignment, + column : Int, +) -> Bool { + let first = align_clustal_upper_code( + alignment.sequences[0].aligned_sequence.unsafe_get(column).to_int(), + ) + for index = 1; index < alignment.sequences.length(); index = index + 1 { + let code = align_clustal_upper_code( + alignment.sequences[index].aligned_sequence.unsafe_get(column).to_int(), + ) + if code != first { + return false + } + } + true +} + +///| +fn align_clustal_column_in_any_group( + alignment : AlignClustalAlignment, + column : Int, + groups : Array[String], +) -> Bool { + for group in groups { + let mut all_present = true + for sequence in alignment.sequences { + let code = align_clustal_upper_code( + sequence.aligned_sequence.unsafe_get(column).to_int(), + ) + if !align_clustal_string_has_code(group, code) { + all_present = false + break + } + } + if all_present { + return true + } + } + false +} + +///| +fn align_clustal_is_nucleotide(alignment : AlignClustalAlignment) -> Bool { + let symbols = "ACGTUNRYKMSWBDHV" + for sequence in alignment.sequences { + for index = 0; index < sequence.sequence.length(); index = index + 1 { + let code = align_clustal_upper_code( + sequence.sequence.unsafe_get(index).to_int(), + ) + if code != '?'.to_int() && !align_clustal_string_has_code(symbols, code) { + return false + } + } + } + true +} + +///| +fn align_clustal_validate_program( + program : String, +) -> Unit raise AlignClustalError { + if program != "CLUSTAL" && + program != "PROBCONS" && + program != "MUSCLE" && + program != "MSAPROBS" && + program != "Kalign" && + program != "Biopython" { + raise AlignClustalError( + "Unknown CLUSTAL generator '" + + program + + "'; expected CLUSTAL, PROBCONS, MUSCLE, MSAPROBS, Kalign, or Biopython", + ) + } +} + +///| +fn align_clustal_validate_version( + version : String, +) -> Unit raise AlignClustalError { + for index = 0; index < version.length(); index = index + 1 { + let code = version.unsafe_get(index).to_int() + if align_clustal_is_whitespace(code) || code < 33 || code > 126 { + raise AlignClustalError("CLUSTAL version must be one printable token") + } + } +} + +///| +fn align_clustal_validate_id(id : String) -> Unit raise AlignClustalError { + if id.length() == 0 { + raise AlignClustalError("CLUSTAL sequence identifier must not be empty") + } + for index = 0; index < id.length(); index = index + 1 { + let code = id.unsafe_get(index).to_int() + if align_clustal_is_whitespace(code) || code < 33 || code > 126 { + raise AlignClustalError( + "CLUSTAL sequence identifier contains whitespace or a control character", + ) + } + } +} + +///| +fn align_clustal_validate_segment( + segment : String, +) -> Unit raise AlignClustalError { + if segment.length() == 0 { + raise AlignClustalError("CLUSTAL sequence segment must not be empty") + } + for index = 0; index < segment.length(); index = index + 1 { + let code = segment.unsafe_get(index).to_int() + let letter = (code >= 'A'.to_int() && code <= 'Z'.to_int()) || + (code >= 'a'.to_int() && code <= 'z'.to_int()) + if !letter && + code != '-'.to_int() && + code != '?'.to_int() && + code != '*'.to_int() { + raise AlignClustalError( + "CLUSTAL sequence contains an invalid residue or gap symbol", + ) + } + } +} + +///| +fn align_clustal_validate_consensus( + consensus : String, +) -> Unit raise AlignClustalError { + for index = 0; index < consensus.length(); index = index + 1 { + let code = consensus.unsafe_get(index).to_int() + if code != ' '.to_int() && + code != '*'.to_int() && + code != ':'.to_int() && + code != '.'.to_int() { + raise AlignClustalError("CLUSTAL consensus contains an invalid symbol") + } + } +} + +///| +fn align_clustal_validate_plain_text( + value : String, + label : String, +) -> Unit raise AlignClustalError { + for index = 0; index < value.length(); index = index + 1 { + let code = value.unsafe_get(index).to_int() + if code == '\n'.to_int() || code == '\r'.to_int() || code < 32 { + raise AlignClustalError( + label + " contains a line break or control character", + ) + } + } +} + +///| +fn align_clustal_validate_row( + alignment : AlignClustalAlignment, + row : Int, +) -> Unit raise AlignClustalError { + if row < 0 || row >= alignment.sequences.length() { + raise AlignClustalError("CLUSTAL row index is out of bounds") + } +} + +///| +fn align_clustal_canonical_header(program : String, version : String) -> String { + if version.length() == 0 { + program + " multiple sequence alignment" + } else { + program + " " + version + " multiple sequence alignment" + } +} + +///| +fn align_clustal_lines(text : String) -> Array[String] { + let raw = text.split("\n").to_array() + let lines : Array[String] = [] + for line in raw { + if line.length() > 0 && + line.unsafe_get(line.length() - 1).to_int() == '\r'.to_int() { + lines.push(line[0:line.length() - 1].to_owned()) + } else { + lines.push(line.to_owned()) + } + } + lines +} + +///| +fn align_clustal_split_whitespace(value : String) -> Array[String] { + let fields : Array[String] = [] + let mut start = 0 + let mut in_field = false + for index = 0; index < value.length(); index = index + 1 { + let whitespace = align_clustal_is_whitespace( + value.unsafe_get(index).to_int(), + ) + if whitespace { + if in_field { + fields.push(value[start:index].to_owned()) + in_field = false + } + } else if !in_field { + start = index + in_field = true + } + } + if in_field { + fields.push(value[start:value.length()].to_owned()) + } + fields +} + +///| +fn align_clustal_segment_start(line : String) -> Int raise AlignClustalError { + let mut index = 0 + while index < line.length() && + !align_clustal_is_whitespace(line.unsafe_get(index).to_int()) { + index = index + 1 + } + while index < line.length() && + align_clustal_is_whitespace(line.unsafe_get(index).to_int()) { + index = index + 1 + } + if index >= line.length() { + raise AlignClustalError("CLUSTAL sequence line has no sequence segment") + } + index +} + +///| +fn align_clustal_parse_nonnegative_int( + text : String, + label : String, +) -> Int raise AlignClustalError { + if text.length() == 0 { + raise AlignClustalError(label + " is empty") + } + let mut value = 0 + for index = 0; index < text.length(); index = index + 1 { + let code = text.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + raise AlignClustalError(label + " must be a non-negative integer") + } + let digit = code - '0'.to_int() + if value > 214748364 || (value == 214748364 && digit > 7) { + raise AlignClustalError(label + " is outside the supported integer range") + } + value = value * 10 + digit + } + value +} + +///| +fn align_clustal_residue_count(segment : String) -> Int { + let mut count = 0 + for index = 0; index < segment.length(); index = index + 1 { + if segment.unsafe_get(index).to_int() != '-'.to_int() { + count = count + 1 + } + } + count +} + +///| +fn align_clustal_remove_gaps(value : String) -> String { + let output = StringBuilder::new(size_hint=value.length()) + for index = 0; index < value.length(); index = index + 1 { + let code = value.unsafe_get(index).to_int() + if code != '-'.to_int() { + output.write_char(code.unsafe_to_char()) + } + } + output.to_string() +} + +///| +fn align_clustal_strip_parentheses(value : String) -> String { + if value.length() >= 2 && + value.unsafe_get(0).to_int() == '('.to_int() && + value.unsafe_get(value.length() - 1).to_int() == ')'.to_int() { + value[1:value.length() - 1].to_owned() + } else { + value + } +} + +///| +fn align_clustal_upper_code(code : Int) -> Int { + if code >= 'a'.to_int() && code <= 'z'.to_int() { + code - 'a'.to_int() + 'A'.to_int() + } else { + code + } +} + +///| +fn align_clustal_string_has_code(value : String, code : Int) -> Bool { + for index = 0; index < value.length(); index = index + 1 { + if value.unsafe_get(index).to_int() == code { + return true + } + } + false +} + +///| +fn align_clustal_find_string(values : Array[String], target : String) -> Int { + align_clustal_find_string_from(values, target, 0) +} + +///| +fn align_clustal_find_string_from( + values : Array[String], + target : String, + start : Int, +) -> Int { + for index = start; index < values.length(); index = index + 1 { + if values[index] == target { + return index + } + } + -1 +} + +///| +fn align_clustal_is_whitespace(code : Int) -> Bool { + code == ' '.to_int() || + code == '\t'.to_int() || + code == '\r'.to_int() || + code == '\n'.to_int() +} diff --git a/src/align_mauve.mbt b/src/align_mauve.mbt new file mode 100644 index 00000000..7f1d2eb7 --- /dev/null +++ b/src/align_mauve.mbt @@ -0,0 +1,2107 @@ +// Biopython-compatible Bio.Align.mauve support. +// +// This module is intentionally separate from mauve.mbt. The older module +// provides MAF-like rearrangement summaries, while this file models genuine +// Mauve/ProgressiveMauve XMFA documents, aligned rows, and coordinate paths. + +///| +/// Error raised for malformed XMFA data or invalid coordinate operations. +pub suberror AlignMauveError { + AlignMauveError(String) +} + +///| +/// One non-sequence file-level XMFA metadata entry. +pub struct AlignMauveMetadataEntry { + key : String + value : String +} derive(Eq, Debug) + +///| +/// One sequence declared by `#SequenceN*` header fields. +/// +/// `number` and `entry` retain XMFA's one-based values. `entry == None` +/// denotes separate-file input without a `SequenceNEntry` line. +pub struct AlignMauveSource { + number : Int + file : String + entry : Int? + format : String + identifier : String +} derive(Eq, Debug) + +///| +/// One aligned row in a locally collinear XMFA block. +/// +/// `start` and `end` are zero-based forward-axis half-open coordinates. +/// Reverse rows have a decreasing `coordinates` path from `end` to `start`. +/// `source_sequence` is always stored in the forward source orientation. +pub struct AlignMauveRow { + source_number : Int + identifier : String + start : Int + end : Int + strand : String + description : String + aligned_sequence : String + source_sequence : String + coordinates : Array[Int] +} derive(Eq, Debug) + +///| +/// One Mauve locally collinear block. +pub struct AlignMauveBlock { + rows : Array[AlignMauveRow] + width : Int +} derive(Eq, Debug) + +///| +/// A complete XMFA document. +pub struct AlignMauveDocument { + format_version : String + sources : Array[AlignMauveSource] + metadata : Array[AlignMauveMetadataEntry] + blocks : Array[AlignMauveBlock] +} derive(Eq, Debug) + +///| +/// Pairwise statistics summed over all unordered row pairs in one or more +/// blocks. Columns where both rows contain gaps are reported separately and +/// do not contribute to gap counts. +pub struct AlignMauveCounts { + pair_count : Int + columns : Int + aligned : Int + identities : Int + mismatches : Int + gaps : Int + gap_opens : Int + double_gap_columns : Int +} derive(Eq, Debug) + +///| +/// One interval-index entry for an aligned source segment. +pub struct AlignMauveIndexEntry { + identifier : String + start : Int + end : Int + block_index : Int + row_index : Int + strand : String +} derive(Eq, Debug) + +///| +/// In-memory interval index over all non-empty XMFA rows. +pub struct AlignMauveIndex { + identifiers : Array[String] + entries : Array[AlignMauveIndexEntry] +} derive(Eq, Debug) + +///| +/// One exact residue-to-residue coordinate projection. +pub struct AlignMauvePositionMapping { + block_index : Int + column : Int + source_position : Int + target_position : Int +} derive(Eq, Debug) + +///| +/// One contiguous aligned part of a projected source interval. +/// +/// Source and target intervals are zero-based forward-axis half-open ranges. +/// `column_start` and `column_end` identify the shared alignment columns. +pub struct AlignMauveRangeMapping { + block_index : Int + column_start : Int + column_end : Int + source_start : Int + source_end : Int + target_start : Int + target_end : Int + source_strand : String + target_strand : String +} derive(Eq, Debug) + +///| +/// Aggregate document summary. +pub struct AlignMauveSummary { + sources : Int + blocks : Int + rows : Int + alignment_columns : Int + aligned_pairs : Int + identities : Int + mismatches : Int + gaps : Int +} derive(Eq, Debug) + +///| +priv struct AlignMauvePendingRow { + source_number : Int + start : Int + end : Int + strand : String + description : String + mut aligned_sequence : String +} + +///| +fn align_mauve_fail(message : String) -> Unit raise AlignMauveError { + raise AlignMauveError(message) +} + +///| +fn align_mauve_copy_sources( + values : Array[AlignMauveSource], +) -> Array[AlignMauveSource] { + let copied : Array[AlignMauveSource] = [] + for value in values { + copied.push(value) + } + copied +} + +///| +fn align_mauve_clone_row(value : AlignMauveRow) -> AlignMauveRow { + let coordinates : Array[Int] = [] + for coordinate in value.coordinates { + coordinates.push(coordinate) + } + AlignMauveRow::{ + source_number: value.source_number, + identifier: value.identifier, + start: value.start, + end: value.end, + strand: value.strand, + description: value.description, + aligned_sequence: value.aligned_sequence, + source_sequence: value.source_sequence, + coordinates, + } +} + +///| +fn align_mauve_copy_rows(values : Array[AlignMauveRow]) -> Array[AlignMauveRow] { + let copied : Array[AlignMauveRow] = [] + for value in values { + copied.push(align_mauve_clone_row(value)) + } + copied +} + +///| +fn align_mauve_clone_block(value : AlignMauveBlock) -> AlignMauveBlock { + AlignMauveBlock::{ + rows: align_mauve_copy_rows(value.rows), + width: value.width, + } +} + +///| +fn align_mauve_copy_blocks( + values : Array[AlignMauveBlock], +) -> Array[AlignMauveBlock] { + let copied : Array[AlignMauveBlock] = [] + for value in values { + copied.push(align_mauve_clone_block(value)) + } + copied +} + +///| +fn align_mauve_copy_metadata( + values : Array[AlignMauveMetadataEntry], +) -> Array[AlignMauveMetadataEntry] { + let copied : Array[AlignMauveMetadataEntry] = [] + for value in values { + copied.push(value) + } + copied +} + +///| +fn align_mauve_copy_ints(values : Array[Int]) -> Array[Int] { + let copied : Array[Int] = [] + for value in values { + copied.push(value) + } + copied +} + +///| +fn align_mauve_copy_index_entries( + values : Array[AlignMauveIndexEntry], +) -> Array[AlignMauveIndexEntry] { + let copied : Array[AlignMauveIndexEntry] = [] + for value in values { + copied.push(value) + } + copied +} + +///| +fn align_mauve_starts_with(value : String, prefix : String) -> Bool { + if prefix.length() > value.length() { + return false + } + for index in 0.. Bool { + if suffix.length() > value.length() { + return false + } + let offset = value.length() - suffix.length() + for index in 0.. Bool { + code == ' '.to_int() || + code == '\t'.to_int() || + code == '\r'.to_int() || + code == '\n'.to_int() +} + +///| +fn align_mauve_trim_line(value : String) -> String { + let mut start = 0 + let mut end = value.length() + while start < end && align_mauve_is_space(value.unsafe_get(start).to_int()) { + start = start + 1 + } + while end > start && align_mauve_is_space(value.unsafe_get(end - 1).to_int()) { + end = end - 1 + } + value[start:end].to_owned() +} + +///| +fn align_mauve_validate_plain_text( + value : String, + label : String, + allow_empty : Bool, +) -> Unit raise AlignMauveError { + if !allow_empty && value.length() == 0 { + align_mauve_fail(label + " must not be empty") + } + for index in 0.. Int raise AlignMauveError { + if text.length() == 0 { + align_mauve_fail(label + " must not be empty") + } + let mut value = 0 + for index in 0.. '9'.to_int() { + align_mauve_fail(label + " must be a decimal integer") + } + let digit = code - '0'.to_int() + if value > 214748364 || (value == 214748364 && digit > 7) { + align_mauve_fail(label + " exceeds the supported integer range") + } + value = value * 10 + digit + } + value +} + +///| +fn align_mauve_index_of_char(value : String, wanted : Int, start : Int) -> Int { + let mut index = start + while index < value.length() { + if value.unsafe_get(index).to_int() == wanted { + return index + } + index = index + 1 + } + -1 +} + +///| +fn align_mauve_header_parts( + line : String, + line_number : Int, +) -> (String, String) raise AlignMauveError { + let body = align_mauve_trim_line(line[1:line.length()].to_owned()) + let mut split = 0 + while split < body.length() && + !align_mauve_is_space(body.unsafe_get(split).to_int()) { + split = split + 1 + } + if split == 0 || split == body.length() { + align_mauve_fail( + "XMFA header line " + + line_number.to_string() + + " must contain a key and value", + ) + } + let key = body[0:split].to_owned() + let value = align_mauve_trim_line(body[split:body.length()].to_owned()) + if value.length() == 0 { + align_mauve_fail( + "XMFA header line " + line_number.to_string() + " has an empty value", + ) + } + (key, value) +} + +///| +fn align_mauve_find_metadata( + values : Array[AlignMauveMetadataEntry], + key : String, +) -> String? { + for value in values { + if value.key == key { + return Some(value.value) + } + } + None +} + +///| +fn align_mauve_find_source_property( + values : Array[AlignMauveMetadataEntry], + number : Int, + suffix : String, +) -> String? { + align_mauve_find_metadata(values, "Sequence" + number.to_string() + suffix) +} + +///| +fn align_mauve_parse_sequence_key( + key : String, +) -> (Int, String)? raise AlignMauveError { + if !align_mauve_starts_with(key, "Sequence") { + return None + } + let suffix = if align_mauve_ends_with(key, "File") { + "File" + } else if align_mauve_ends_with(key, "Entry") { + "Entry" + } else if align_mauve_ends_with(key, "Format") { + "Format" + } else { + align_mauve_fail("Unexpected XMFA sequence header keyword '" + key + "'") + "" + } + let start = "Sequence".length() + let end = key.length() - suffix.length() + if end <= start { + align_mauve_fail("Malformed XMFA sequence header keyword '" + key + "'") + } + let number = align_mauve_parse_positive_int( + key[start:end].to_owned(), + "XMFA sequence number", + ) + if number <= 0 { + align_mauve_fail("XMFA sequence numbers are one-based and must be positive") + } + Some((number, suffix)) +} + +///| +fn align_mauve_find_source( + sources : Array[AlignMauveSource], + number : Int, +) -> AlignMauveSource? { + for source in sources { + if source.number == number { + return Some(source) + } + } + None +} + +///| +fn align_mauve_find_source_by_identifier( + sources : Array[AlignMauveSource], + identifier : String, +) -> AlignMauveSource? { + for source in sources { + if source.identifier == identifier { + return Some(source) + } + } + None +} + +///| +fn align_mauve_validate_strand(strand : String) -> Unit raise AlignMauveError { + if strand != "+" && strand != "-" { + align_mauve_fail("XMFA strand must be '+' or '-'") + } +} + +///| +fn align_mauve_complement(base : Char) -> Char raise AlignMauveError { + match base { + 'A' => 'T' + 'C' => 'G' + 'G' => 'C' + 'T' => 'A' + 'U' => 'A' + 'R' => 'Y' + 'Y' => 'R' + 'S' => 'S' + 'W' => 'W' + 'K' => 'M' + 'M' => 'K' + 'B' => 'V' + 'D' => 'H' + 'H' => 'D' + 'V' => 'B' + 'N' => 'N' + 'X' => 'X' + 'a' => 't' + 'c' => 'g' + 'g' => 'c' + 't' => 'a' + 'u' => 'a' + 'r' => 'y' + 'y' => 'r' + 's' => 's' + 'w' => 'w' + 'k' => 'm' + 'm' => 'k' + 'b' => 'v' + 'd' => 'h' + 'h' => 'd' + 'v' => 'b' + 'n' => 'n' + 'x' => 'x' + _ => { + align_mauve_fail( + "XMFA sequence contains non-IUPAC residue '" + base.to_string() + "'", + ) + 'N' + } + } +} + +///| +fn align_mauve_validate_aligned_sequence( + sequence : String, +) -> Unit raise AlignMauveError { + if sequence.length() == 0 { + align_mauve_fail("XMFA aligned sequence must not be empty") + } + for index in 0.. String { + let output = StringBuilder::new(size_hint=sequence.length()) + for index in 0.. String raise AlignMauveError { + let output = StringBuilder::new(size_hint=sequence.length()) + let mut index = sequence.length() - 1 + while index >= 0 { + output.write_char( + align_mauve_complement(sequence.unsafe_get(index).unsafe_to_char()), + ) + index = index - 1 + } + output.to_string() +} + +///| +fn align_mauve_make_coordinates( + aligned_sequence : String, + start : Int, + end : Int, + strand : String, +) -> Array[Int] raise AlignMauveError { + let coordinates : Array[Int] = [] + let mut current = if strand == "+" { start } else { end } + coordinates.push(current) + for column in 0.. AlignMauvePendingRow raise AlignMauveError { + let body = align_mauve_trim_line(line[1:line.length()].to_owned()) + let mut first_end = 0 + while first_end < body.length() && + !align_mauve_is_space(body.unsafe_get(first_end).to_int()) { + first_end = first_end + 1 + } + if first_end == 0 || first_end == body.length() { + align_mauve_fail( + "Malformed XMFA row description at line " + line_number.to_string(), + ) + } + let locus = body[0:first_end].to_owned() + let mut strand_start = first_end + while strand_start < body.length() && + align_mauve_is_space(body.unsafe_get(strand_start).to_int()) { + strand_start = strand_start + 1 + } + let mut strand_end = strand_start + while strand_end < body.length() && + !align_mauve_is_space(body.unsafe_get(strand_end).to_int()) { + strand_end = strand_end + 1 + } + if strand_start == strand_end || strand_end == body.length() { + align_mauve_fail( + "XMFA row description at line " + + line_number.to_string() + + " must include strand and description", + ) + } + let strand = body[strand_start:strand_end].to_owned() + align_mauve_validate_strand(strand) + let description = align_mauve_trim_line( + body[strand_end:body.length()].to_owned(), + ) + align_mauve_validate_plain_text(description, "XMFA row description", false) + let colon = align_mauve_index_of_char(locus, ':'.to_int(), 0) + if colon <= 0 || + colon + 1 >= locus.length() || + align_mauve_index_of_char(locus, ':'.to_int(), colon + 1) >= 0 { + align_mauve_fail( + "Malformed XMFA sequence locus at line " + line_number.to_string(), + ) + } + let dash = align_mauve_index_of_char(locus, '-'.to_int(), colon + 1) + if dash <= colon + 1 || + dash + 1 >= locus.length() || + align_mauve_index_of_char(locus, '-'.to_int(), dash + 1) >= 0 { + align_mauve_fail( + "Malformed XMFA coordinate range at line " + line_number.to_string(), + ) + } + let source_number = align_mauve_parse_positive_int( + locus[0:colon].to_owned(), + "XMFA row sequence number", + ) + if source_number <= 0 { + align_mauve_fail("XMFA row sequence number must be positive") + } + let file_start = align_mauve_parse_positive_int( + locus[colon + 1:dash].to_owned(), + "XMFA row start", + ) + let file_end = align_mauve_parse_positive_int( + locus[dash + 1:locus.length()].to_owned(), + "XMFA row end", + ) + let (start, end) = if file_start == 0 { + if file_end != 0 { + align_mauve_fail("XMFA start coordinate zero is only valid for 0-0 rows") + } + (0, 0) + } else { + if file_end < file_start { + align_mauve_fail("XMFA row end must not precede its start") + } + (file_start - 1, file_end) + } + AlignMauvePendingRow::{ + source_number, + start, + end, + strand, + description, + aligned_sequence: "", + } +} + +///| +fn align_mauve_finalize_block( + pending : Array[AlignMauvePendingRow], + sources : Array[AlignMauveSource], +) -> AlignMauveBlock raise AlignMauveError { + if pending.length() == 0 { + align_mauve_fail("XMFA alignment block must contain at least one row") + } + let rows : Array[AlignMauveRow] = [] + let mut width = -1 + let mut has_residue = false + for item in pending { + for row in rows { + if row.source_number == item.source_number { + align_mauve_fail( + "XMFA alignment block contains a duplicated sequence number", + ) + } + } + let source = match align_mauve_find_source(sources, item.source_number) { + Some(value) => value + None => { + align_mauve_fail( + "XMFA row refers to undeclared sequence " + + item.source_number.to_string(), + ) + sources[0] + } + } + let row = AlignMauveRow::create( + source, + item.start, + item.end, + item.strand, + item.description, + item.aligned_sequence, + ) + if width < 0 { + width = row.aligned_sequence.length() + } else if row.aligned_sequence.length() != width { + align_mauve_fail("XMFA rows in one block must have equal widths") + } + if row.end > row.start { + has_residue = true + } + rows.push(row) + } + if width <= 0 { + align_mauve_fail("XMFA alignment block width must be positive") + } + if !has_residue { + align_mauve_fail("XMFA alignment block must contain at least one residue") + } + AlignMauveBlock::{ rows, width } +} + +///| +/// Construct one validated metadata entry. +pub fn AlignMauveMetadataEntry::create( + key : String, + value : String, +) -> AlignMauveMetadataEntry raise AlignMauveError { + align_mauve_validate_plain_text(key, "XMFA metadata key", false) + align_mauve_validate_plain_text(value, "XMFA metadata value", false) + for index in 0.. AlignMauveSource raise AlignMauveError { + if number <= 0 { + align_mauve_fail("XMFA source number must be positive") + } + align_mauve_validate_plain_text(file, "XMFA source file", false) + align_mauve_validate_plain_text(format, "XMFA source format", false) + if entry < 0 { + align_mauve_fail("XMFA source entry must be non-negative") + } + let resolved_identifier = if identifier.length() > 0 { + identifier + } else if entry > 0 { + (entry - 1).to_string() + } else { + file + } + align_mauve_validate_plain_text( + resolved_identifier, "XMFA source identifier", false, + ) + AlignMauveSource::{ + number, + file, + entry: if entry == 0 { + None + } else { + Some(entry) + }, + format, + identifier: resolved_identifier, + } +} + +///| +/// Construct one validated aligned XMFA row. +pub fn AlignMauveRow::create( + source : AlignMauveSource, + start : Int, + end : Int, + strand : String, + description : String, + aligned_sequence : String, +) -> AlignMauveRow raise AlignMauveError { + if start < 0 || end < start { + align_mauve_fail("XMFA row interval must satisfy 0 <= start <= end") + } + align_mauve_validate_strand(strand) + align_mauve_validate_plain_text(description, "XMFA row description", false) + align_mauve_validate_aligned_sequence(aligned_sequence) + let displayed_sequence = align_mauve_remove_gaps(aligned_sequence) + if displayed_sequence.length() != end - start { + align_mauve_fail( + "XMFA row coordinate span must equal its ungapped sequence length", + ) + } + if start == end && displayed_sequence.length() != 0 { + align_mauve_fail("XMFA 0-0 row must contain gaps only") + } + let source_sequence = if strand == "+" { + displayed_sequence + } else { + align_mauve_reverse_complement(displayed_sequence) + } + let coordinates = align_mauve_make_coordinates( + aligned_sequence, start, end, strand, + ) + AlignMauveRow::{ + source_number: source.number, + identifier: source.identifier, + start, + end, + strand, + description, + aligned_sequence, + source_sequence, + coordinates, + } +} + +///| +/// Construct one validated XMFA block. +pub fn AlignMauveBlock::create( + rows : Array[AlignMauveRow], +) -> AlignMauveBlock raise AlignMauveError { + if rows.length() == 0 { + align_mauve_fail("XMFA block must contain at least one row") + } + let copied = align_mauve_copy_rows(rows) + let width = copied[0].aligned_sequence.length() + let mut has_residue = false + for index in 0.. row.start { + has_residue = true + } + for other in 0.. AlignMauveDocument raise AlignMauveError { + if text.length() == 0 { + align_mauve_fail("Empty XMFA input") + } + let raw_lines = text.split("\n").to_array() + let lines : Array[String] = [] + for raw in raw_lines { + let owned = raw.to_owned() + let line = if owned.length() > 0 && + owned.unsafe_get(owned.length() - 1).to_int() == '\r'.to_int() { + owned[0:owned.length() - 1].to_owned() + } else { + owned + } + lines.push(line) + } + let all_metadata : Array[AlignMauveMetadataEntry] = [] + let mut index = 0 + while index < lines.length() { + let trimmed = align_mauve_trim_line(lines[index]) + if trimmed.length() == 0 { + index = index + 1 + continue + } + if !align_mauve_starts_with(trimmed, "#") { + break + } + let (key, value) = align_mauve_header_parts(trimmed, index + 1) + if align_mauve_find_metadata(all_metadata, key) is Some(_) { + align_mauve_fail("Duplicated XMFA header keyword '" + key + "'") + } + all_metadata.push(AlignMauveMetadataEntry::create(key, value)) + index = index + 1 + } + if all_metadata.length() == 0 { + align_mauve_fail("XMFA input must begin with metadata header lines") + } + let format_version = match + align_mauve_find_metadata(all_metadata, "FormatVersion") { + Some(value) => value + None => { + align_mauve_fail("XMFA header is missing FormatVersion") + "" + } + } + let mut maximum_source = 0 + for entry in all_metadata { + match align_mauve_parse_sequence_key(entry.key) { + Some((number, _)) => + if number > maximum_source { + maximum_source = number + } + None => () + } + } + if maximum_source == 0 { + align_mauve_fail("XMFA header declares no source sequences") + } + let source_files : Array[String] = [] + let source_formats : Array[String] = [] + let source_entries : Array[Int] = [] + for number = 1; number <= maximum_source; number = number + 1 { + let file = match + align_mauve_find_source_property(all_metadata, number, "File") { + Some(value) => value + None => { + align_mauve_fail( + "XMFA header is missing Sequence" + number.to_string() + "File", + ) + "" + } + } + let format = match + align_mauve_find_source_property(all_metadata, number, "Format") { + Some(value) => value + None => { + align_mauve_fail( + "XMFA header is missing Sequence" + number.to_string() + "Format", + ) + "" + } + } + let source_entry = match + align_mauve_find_source_property(all_metadata, number, "Entry") { + Some(value) => { + let parsed = align_mauve_parse_positive_int(value, "XMFA source entry") + if parsed <= 0 { + align_mauve_fail("XMFA source entry must be positive") + } + parsed + } + None => 0 + } + source_files.push(file) + source_formats.push(format) + source_entries.push(source_entry) + } + let mut combined = true + for source_index in 1..") { + pending.push(align_mauve_parse_description(trimmed, line_number)) + continue + } + if pending.length() == 0 { + align_mauve_fail( + "XMFA sequence data at line " + + line_number.to_string() + + " appears before a row description", + ) + } + for char_index in 0.. 0 { + align_mauve_fail("XMFA final alignment block is missing its '=' terminator") + } + AlignMauveDocument::{ format_version, sources, metadata, blocks } +} + +///| +/// Serialize an XMFA document in canonical Mauve form. +/// +/// `line_width == 0` writes one physical line per aligned row, matching +/// Biopython's writer. Positive widths wrap sequence rows deterministically. +pub fn align_mauve_write( + document : AlignMauveDocument, + line_width? : Int = 0, +) -> String raise AlignMauveError { + if line_width < 0 { + align_mauve_fail("XMFA line width must be non-negative") + } + if document.sources.length() == 0 { + align_mauve_fail("XMFA document must declare at least one source") + } + let output = StringBuilder::new() + output.write_string("#FormatVersion ") + output.write_string(document.format_version) + output.write_char('\n') + for source in document.sources { + output.write_string("#Sequence") + output.write_string(source.number.to_string()) + output.write_string("File\t") + output.write_string(source.file) + output.write_char('\n') + match source.entry { + Some(entry) => { + output.write_string("#Sequence") + output.write_string(source.number.to_string()) + output.write_string("Entry\t") + output.write_string(entry.to_string()) + output.write_char('\n') + } + None => () + } + output.write_string("#Sequence") + output.write_string(source.number.to_string()) + output.write_string("Format\t") + output.write_string(source.format) + output.write_char('\n') + } + for entry in document.metadata { + if entry.key != "FormatVersion" { + output.write_char('#') + output.write_string(entry.key) + output.write_char('\t') + output.write_string(entry.value) + output.write_char('\n') + } + } + for block in document.blocks { + for row in block.rows { + output.write_string("> ") + output.write_string(row.source_number.to_string()) + output.write_char(':') + if row.start == 0 && row.end == 0 { + output.write_string("0-0") + } else { + output.write_string((row.start + 1).to_string()) + output.write_char('-') + output.write_string(row.end.to_string()) + } + output.write_char(' ') + output.write_string(row.strand) + output.write_char(' ') + output.write_string(row.description) + output.write_char('\n') + if line_width == 0 { + output.write_string(row.aligned_sequence) + output.write_char('\n') + } else { + let mut offset = 0 + while offset < row.aligned_sequence.length() { + let end = if offset + line_width < row.aligned_sequence.length() { + offset + line_width + } else { + row.aligned_sequence.length() + } + output.write_string(row.aligned_sequence[offset:end].to_owned()) + output.write_char('\n') + offset = end + } + } + } + output.write_string("=\n") + } + output.to_string() +} + +///| +pub fn AlignMauveMetadataEntry::key(self : AlignMauveMetadataEntry) -> String { + self.key +} + +///| +pub fn AlignMauveMetadataEntry::value(self : AlignMauveMetadataEntry) -> String { + self.value +} + +///| +pub fn AlignMauveSource::number(self : AlignMauveSource) -> Int { + self.number +} + +///| +pub fn AlignMauveSource::file(self : AlignMauveSource) -> String { + self.file +} + +///| +pub fn AlignMauveSource::entry(self : AlignMauveSource) -> Int? { + self.entry +} + +///| +pub fn AlignMauveSource::format(self : AlignMauveSource) -> String { + self.format +} + +///| +pub fn AlignMauveSource::identifier(self : AlignMauveSource) -> String { + self.identifier +} + +///| +pub fn AlignMauveRow::source_number(self : AlignMauveRow) -> Int { + self.source_number +} + +///| +pub fn AlignMauveRow::identifier(self : AlignMauveRow) -> String { + self.identifier +} + +///| +pub fn AlignMauveRow::start(self : AlignMauveRow) -> Int { + self.start +} + +///| +pub fn AlignMauveRow::end(self : AlignMauveRow) -> Int { + self.end +} + +///| +pub fn AlignMauveRow::strand(self : AlignMauveRow) -> String { + self.strand +} + +///| +pub fn AlignMauveRow::description(self : AlignMauveRow) -> String { + self.description +} + +///| +pub fn AlignMauveRow::aligned_sequence(self : AlignMauveRow) -> String { + self.aligned_sequence +} + +///| +pub fn AlignMauveRow::source_sequence(self : AlignMauveRow) -> String { + self.source_sequence +} + +///| +pub fn AlignMauveRow::coordinates(self : AlignMauveRow) -> Array[Int] { + align_mauve_copy_ints(self.coordinates) +} + +///| +/// Return the source boundary at one alignment-column boundary. +pub fn AlignMauveRow::coordinate_at_boundary( + self : AlignMauveRow, + column : Int, +) -> Int raise AlignMauveError { + if column < 0 || column >= self.coordinates.length() { + align_mauve_fail("XMFA alignment-column boundary is out of range") + } + self.coordinates[column] +} + +///| +/// Return the zero-based forward source coordinate represented by one residue +/// column, or `None` when this row has a gap in that column. +pub fn AlignMauveRow::residue_coordinate( + self : AlignMauveRow, + column : Int, +) -> Int? raise AlignMauveError { + if column < 0 || column >= self.aligned_sequence.length() { + align_mauve_fail("XMFA alignment column is out of range") + } + if self.aligned_sequence.unsafe_get(column).to_int() == '-'.to_int() { + return None + } + if self.strand == "+" { + Some(self.coordinates[column]) + } else { + Some(self.coordinates[column] - 1) + } +} + +///| +/// Locate one forward-axis source residue in this aligned row. +pub fn AlignMauveRow::column_for_coordinate( + self : AlignMauveRow, + coordinate : Int, +) -> Int? raise AlignMauveError { + if coordinate < 0 { + align_mauve_fail("XMFA source coordinate must be non-negative") + } + for column in 0.. if value == coordinate { return Some(column) } + None => () + } + } + None +} + +///| +pub fn AlignMauveBlock::rows(self : AlignMauveBlock) -> Array[AlignMauveRow] { + align_mauve_copy_rows(self.rows) +} + +///| +pub fn AlignMauveBlock::row_count(self : AlignMauveBlock) -> Int { + self.rows.length() +} + +///| +pub fn AlignMauveBlock::width(self : AlignMauveBlock) -> Int { + self.width +} + +///| +pub fn AlignMauveBlock::row_by_identifier( + self : AlignMauveBlock, + identifier : String, +) -> AlignMauveRow? { + for row in self.rows { + if row.identifier == identifier { + return Some(row) + } + } + None +} + +///| +pub fn AlignMauveBlock::row_by_source_number( + self : AlignMauveBlock, + source_number : Int, +) -> AlignMauveRow? { + for row in self.rows { + if row.source_number == source_number { + return Some(row) + } + } + None +} + +///| +/// Return Biopython-style compact coordinate rows. +/// +/// A boundary is retained whenever any row changes between residue movement +/// and gap movement, plus the first and final boundaries. +pub fn AlignMauveBlock::compact_coordinates( + self : AlignMauveBlock, +) -> Array[Array[Int]] { + let boundaries : Array[Int] = [0] + for column = 1; column < self.width; column = column + 1 { + let mut changed = false + for row in self.rows { + let previous = row.coordinates[column] - row.coordinates[column - 1] + let next = row.coordinates[column + 1] - row.coordinates[column] + if previous != next { + changed = true + } + } + if changed { + boundaries.push(column) + } + } + boundaries.push(self.width) + let compact : Array[Array[Int]] = [] + for row in self.rows { + let coordinates : Array[Int] = [] + for boundary in boundaries { + coordinates.push(row.coordinates[boundary]) + } + compact.push(coordinates) + } + compact +} + +///| +/// Project one source residue to a target residue through a shared block +/// column. A gap in either row yields `None`. +pub fn AlignMauveBlock::map_position( + self : AlignMauveBlock, + source_identifier : String, + target_identifier : String, + source_position : Int, +) -> Int? raise AlignMauveError { + if source_position < 0 { + align_mauve_fail("XMFA source position must be non-negative") + } + let source = match self.row_by_identifier(source_identifier) { + Some(row) => row + None => return None + } + let target = match self.row_by_identifier(target_identifier) { + Some(row) => row + None => return None + } + let column = match source.column_for_coordinate(source_position) { + Some(value) => value + None => return None + } + target.residue_coordinate(column) +} + +///| +/// Calculate pairwise alignment counts over all unordered row pairs. +pub fn AlignMauveBlock::counts(self : AlignMauveBlock) -> AlignMauveCounts { + let mut pair_count = 0 + let mut columns = 0 + let mut aligned = 0 + let mut identities = 0 + let mut mismatches = 0 + let mut gaps = 0 + let mut gap_opens = 0 + let mut double_gap_columns = 0 + for left = 0; left < self.rows.length(); left = left + 1 { + for right = left + 1; right < self.rows.length(); right = right + 1 { + pair_count = pair_count + 1 + columns = columns + self.width + let mut active_gap = 0 + for column in 0.. String { + self.format_version +} + +///| +pub fn AlignMauveDocument::sources( + self : AlignMauveDocument, +) -> Array[AlignMauveSource] { + align_mauve_copy_sources(self.sources) +} + +///| +pub fn AlignMauveDocument::blocks( + self : AlignMauveDocument, +) -> Array[AlignMauveBlock] { + align_mauve_copy_blocks(self.blocks) +} + +///| +pub fn AlignMauveDocument::metadata_entries( + self : AlignMauveDocument, +) -> Array[AlignMauveMetadataEntry] { + align_mauve_copy_metadata(self.metadata) +} + +///| +pub fn AlignMauveDocument::metadata_value( + self : AlignMauveDocument, + key : String, +) -> String? { + align_mauve_find_metadata(self.metadata, key) +} + +///| +pub fn AlignMauveDocument::source_count(self : AlignMauveDocument) -> Int { + self.sources.length() +} + +///| +pub fn AlignMauveDocument::block_count(self : AlignMauveDocument) -> Int { + self.blocks.length() +} + +///| +pub fn AlignMauveDocument::identifiers( + self : AlignMauveDocument, +) -> Array[String] { + let identifiers : Array[String] = [] + for source in self.sources { + identifiers.push(source.identifier) + } + identifiers +} + +///| +pub fn AlignMauveDocument::source( + self : AlignMauveDocument, + identifier : String, +) -> AlignMauveSource? { + align_mauve_find_source_by_identifier(self.sources, identifier) +} + +///| +/// Sum pairwise counts over all XMFA blocks. +pub fn AlignMauveDocument::counts( + self : AlignMauveDocument, +) -> AlignMauveCounts { + let mut pair_count = 0 + let mut columns = 0 + let mut aligned = 0 + let mut identities = 0 + let mut mismatches = 0 + let mut gaps = 0 + let mut gap_opens = 0 + let mut double_gap_columns = 0 + for block in self.blocks { + let counts = block.counts() + pair_count = pair_count + counts.pair_count + columns = columns + counts.columns + aligned = aligned + counts.aligned + identities = identities + counts.identities + mismatches = mismatches + counts.mismatches + gaps = gaps + counts.gaps + gap_opens = gap_opens + counts.gap_opens + double_gap_columns = double_gap_columns + counts.double_gap_columns + } + AlignMauveCounts::{ + pair_count, + columns, + aligned, + identities, + mismatches, + gaps, + gap_opens, + double_gap_columns, + } +} + +///| +pub fn AlignMauveCounts::pair_count(self : AlignMauveCounts) -> Int { + self.pair_count +} + +///| +pub fn AlignMauveCounts::columns(self : AlignMauveCounts) -> Int { + self.columns +} + +///| +pub fn AlignMauveCounts::aligned(self : AlignMauveCounts) -> Int { + self.aligned +} + +///| +pub fn AlignMauveCounts::identities(self : AlignMauveCounts) -> Int { + self.identities +} + +///| +pub fn AlignMauveCounts::mismatches(self : AlignMauveCounts) -> Int { + self.mismatches +} + +///| +pub fn AlignMauveCounts::gaps(self : AlignMauveCounts) -> Int { + self.gaps +} + +///| +pub fn AlignMauveCounts::gap_opens(self : AlignMauveCounts) -> Int { + self.gap_opens +} + +///| +pub fn AlignMauveCounts::double_gap_columns(self : AlignMauveCounts) -> Int { + self.double_gap_columns +} + +///| +/// Build an in-memory interval index over all non-empty rows. +pub fn align_mauve_index(document : AlignMauveDocument) -> AlignMauveIndex { + let entries : Array[AlignMauveIndexEntry] = [] + for block_index in 0.. row.start { + entries.push(AlignMauveIndexEntry::{ + identifier: row.identifier, + start: row.start, + end: row.end, + block_index, + row_index, + strand: row.strand, + }) + } + } + } + AlignMauveIndex::{ identifiers: document.identifiers(), entries } +} + +///| +pub fn AlignMauveIndex::entries( + self : AlignMauveIndex, +) -> Array[AlignMauveIndexEntry] { + align_mauve_copy_index_entries(self.entries) +} + +///| +/// Find rows overlapping one zero-based half-open source interval. +pub fn AlignMauveIndex::query( + self : AlignMauveIndex, + identifier : String, + start : Int, + end : Int, +) -> Array[AlignMauveIndexEntry] raise AlignMauveError { + if start < 0 || end <= start { + align_mauve_fail("XMFA index query must satisfy 0 <= start < end") + } + if !self.identifiers.contains(identifier) { + align_mauve_fail("Unknown XMFA source identifier '" + identifier + "'") + } + let matches : Array[AlignMauveIndexEntry] = [] + for entry in self.entries { + if entry.identifier == identifier && entry.start < end && entry.end > start { + matches.push(entry) + } + } + matches +} + +///| +pub fn AlignMauveIndexEntry::identifier(self : AlignMauveIndexEntry) -> String { + self.identifier +} + +///| +pub fn AlignMauveIndexEntry::start(self : AlignMauveIndexEntry) -> Int { + self.start +} + +///| +pub fn AlignMauveIndexEntry::end(self : AlignMauveIndexEntry) -> Int { + self.end +} + +///| +pub fn AlignMauveIndexEntry::block_index(self : AlignMauveIndexEntry) -> Int { + self.block_index +} + +///| +pub fn AlignMauveIndexEntry::row_index(self : AlignMauveIndexEntry) -> Int { + self.row_index +} + +///| +pub fn AlignMauveIndexEntry::strand(self : AlignMauveIndexEntry) -> String { + self.strand +} + +///| +/// Project one source residue through every block containing both sequences. +pub fn align_mauve_map_position( + document : AlignMauveDocument, + source_identifier : String, + target_identifier : String, + source_position : Int, +) -> Array[AlignMauvePositionMapping] raise AlignMauveError { + if align_mauve_find_source_by_identifier(document.sources, source_identifier) + is None { + align_mauve_fail( + "Unknown XMFA source identifier '" + source_identifier + "'", + ) + } + if align_mauve_find_source_by_identifier(document.sources, target_identifier) + is None { + align_mauve_fail( + "Unknown XMFA target identifier '" + target_identifier + "'", + ) + } + if source_position < 0 { + align_mauve_fail("XMFA source position must be non-negative") + } + let mappings : Array[AlignMauvePositionMapping] = [] + for block_index in 0.. row + None => continue + } + let target = match block.row_by_identifier(target_identifier) { + Some(row) => row + None => continue + } + let column = match source.column_for_coordinate(source_position) { + Some(value) => value + None => continue + } + match target.residue_coordinate(column) { + Some(target_position) => + mappings.push(AlignMauvePositionMapping::{ + block_index, + column, + source_position, + target_position, + }) + None => () + } + } + mappings +} + +///| +pub fn AlignMauvePositionMapping::block_index( + self : AlignMauvePositionMapping, +) -> Int { + self.block_index +} + +///| +pub fn AlignMauvePositionMapping::column( + self : AlignMauvePositionMapping, +) -> Int { + self.column +} + +///| +pub fn AlignMauvePositionMapping::source_position( + self : AlignMauvePositionMapping, +) -> Int { + self.source_position +} + +///| +pub fn AlignMauvePositionMapping::target_position( + self : AlignMauvePositionMapping, +) -> Int { + self.target_position +} + +///| +fn align_mauve_append_range_mapping( + mappings : Array[AlignMauveRangeMapping], + block_index : Int, + column_start : Int, + column_end : Int, + first_source : Int, + last_source : Int, + first_target : Int, + last_target : Int, + source_strand : String, + target_strand : String, +) -> Unit { + let source_start = if first_source < last_source { + first_source + } else { + last_source + } + let source_end = if first_source > last_source { + first_source + 1 + } else { + last_source + 1 + } + let target_start = if first_target < last_target { + first_target + } else { + last_target + } + let target_end = if first_target > last_target { + first_target + 1 + } else { + last_target + 1 + } + mappings.push(AlignMauveRangeMapping::{ + block_index, + column_start, + column_end, + source_start, + source_end, + target_start, + target_end, + source_strand, + target_strand, + }) +} + +///| +/// Project a source interval through all shared, residue-aligned block runs. +/// +/// Gaps split the result into separate mappings. Reverse rows retain their +/// strand labels while returned coordinate intervals remain forward-axis. +pub fn align_mauve_map_range( + document : AlignMauveDocument, + source_identifier : String, + target_identifier : String, + start : Int, + end : Int, +) -> Array[AlignMauveRangeMapping] raise AlignMauveError { + if start < 0 || end <= start { + align_mauve_fail("XMFA source interval must satisfy 0 <= start < end") + } + if align_mauve_find_source_by_identifier(document.sources, source_identifier) + is None { + align_mauve_fail( + "Unknown XMFA source identifier '" + source_identifier + "'", + ) + } + if align_mauve_find_source_by_identifier(document.sources, target_identifier) + is None { + align_mauve_fail( + "Unknown XMFA target identifier '" + target_identifier + "'", + ) + } + let mappings : Array[AlignMauveRangeMapping] = [] + for block_index in 0.. row + None => continue + } + let target = match block.row_by_identifier(target_identifier) { + Some(row) => row + None => continue + } + let source_step = if source.strand == "+" { 1 } else { -1 } + let target_step = if target.strand == "+" { 1 } else { -1 } + let mut active = false + let mut column_start = 0 + let mut first_source = 0 + let mut last_source = 0 + let mut first_target = 0 + let mut last_target = 0 + let mut previous_column = -2 + for column in 0.. + source_value >= start && source_value < end + _ => false + } + if usable { + let source_value = source_position.unwrap() + let target_value = target_position.unwrap() + let contiguous = active && + column == previous_column + 1 && + source_value == last_source + source_step && + target_value == last_target + target_step + if !contiguous { + if active { + align_mauve_append_range_mapping( + mappings, + block_index, + column_start, + previous_column + 1, + first_source, + last_source, + first_target, + last_target, + source.strand, + target.strand, + ) + } + active = true + column_start = column + first_source = source_value + first_target = target_value + } + last_source = source_value + last_target = target_value + previous_column = column + } else if active { + align_mauve_append_range_mapping( + mappings, + block_index, + column_start, + previous_column + 1, + first_source, + last_source, + first_target, + last_target, + source.strand, + target.strand, + ) + active = false + } + } + if active { + align_mauve_append_range_mapping( + mappings, + block_index, + column_start, + previous_column + 1, + first_source, + last_source, + first_target, + last_target, + source.strand, + target.strand, + ) + } + } + mappings +} + +///| +pub fn AlignMauveRangeMapping::block_index( + self : AlignMauveRangeMapping, +) -> Int { + self.block_index +} + +///| +pub fn AlignMauveRangeMapping::column_start( + self : AlignMauveRangeMapping, +) -> Int { + self.column_start +} + +///| +pub fn AlignMauveRangeMapping::column_end(self : AlignMauveRangeMapping) -> Int { + self.column_end +} + +///| +pub fn AlignMauveRangeMapping::source_start( + self : AlignMauveRangeMapping, +) -> Int { + self.source_start +} + +///| +pub fn AlignMauveRangeMapping::source_end(self : AlignMauveRangeMapping) -> Int { + self.source_end +} + +///| +pub fn AlignMauveRangeMapping::target_start( + self : AlignMauveRangeMapping, +) -> Int { + self.target_start +} + +///| +pub fn AlignMauveRangeMapping::target_end(self : AlignMauveRangeMapping) -> Int { + self.target_end +} + +///| +pub fn AlignMauveRangeMapping::source_strand( + self : AlignMauveRangeMapping, +) -> String { + self.source_strand +} + +///| +pub fn AlignMauveRangeMapping::target_strand( + self : AlignMauveRangeMapping, +) -> String { + self.target_strand +} + +///| +/// Reconstruct the known forward source sequence from all XMFA blocks. +/// +/// Unknown positions up to the largest observed endpoint use `fill`, which +/// must be exactly one non-gap IUPAC character. Conflicting overlapping rows +/// are rejected. +pub fn align_mauve_reconstruct_sequence( + document : AlignMauveDocument, + identifier : String, + fill? : String = "N", +) -> String raise AlignMauveError { + if align_mauve_find_source_by_identifier(document.sources, identifier) is None { + align_mauve_fail("Unknown XMFA source identifier '" + identifier + "'") + } + if fill.length() != 1 || fill == "-" { + align_mauve_fail( + "XMFA reconstruction fill must be one non-gap IUPAC character", + ) + } + let fill_char = fill.unsafe_get(0).unsafe_to_char() + ignore(align_mauve_complement(fill_char)) + let mut length = 0 + for block in document.blocks { + for row in block.rows { + if row.identifier == identifier && row.end > length { + length = row.end + } + } + } + let sequence : Array[Char] = [] + for _ in 0.. AlignMauveSummary { + let counts = document.counts() + let mut rows = 0 + let mut alignment_columns = 0 + for block in document.blocks { + rows = rows + block.rows.length() + alignment_columns = alignment_columns + block.width + } + AlignMauveSummary::{ + sources: document.sources.length(), + blocks: document.blocks.length(), + rows, + alignment_columns, + aligned_pairs: counts.aligned, + identities: counts.identities, + mismatches: counts.mismatches, + gaps: counts.gaps, + } +} + +///| +pub fn AlignMauveSummary::sources(self : AlignMauveSummary) -> Int { + self.sources +} + +///| +pub fn AlignMauveSummary::blocks(self : AlignMauveSummary) -> Int { + self.blocks +} + +///| +pub fn AlignMauveSummary::rows(self : AlignMauveSummary) -> Int { + self.rows +} + +///| +pub fn AlignMauveSummary::alignment_columns(self : AlignMauveSummary) -> Int { + self.alignment_columns +} + +///| +pub fn AlignMauveSummary::aligned_pairs(self : AlignMauveSummary) -> Int { + self.aligned_pairs +} + +///| +pub fn AlignMauveSummary::identities(self : AlignMauveSummary) -> Int { + self.identities +} + +///| +pub fn AlignMauveSummary::mismatches(self : AlignMauveSummary) -> Int { + self.mismatches +} + +///| +pub fn AlignMauveSummary::gaps(self : AlignMauveSummary) -> Int { + self.gaps +} + +///| +/// Small deterministic XMFA fixture adapted from Biopython's official Mauve +/// combined-file test data. +pub fn align_mauve_example_text() -> String { + "#FormatVersion Mauve1\n" + + "#Sequence1File\tcombined.fa\n" + + "#Sequence1Entry\t1\n" + + "#Sequence1Format\tFastA\n" + + "#Sequence2File\tcombined.fa\n" + + "#Sequence2Entry\t2\n" + + "#Sequence2Format\tFastA\n" + + "#Sequence3File\tcombined.fa\n" + + "#Sequence3Entry\t3\n" + + "#Sequence3Format\tFastA\n" + + "#BackboneFile\tcombined.xmfa.bbcols\n" + + "> 1:2-49 - combined.fa\n" + + "AAGCCCTCCTAGCACACACCCGGAGTGG-CCGGGCCGTACTTTCCTTTT\n" + + "> 2:0-0 + combined.fa\n" + + "-------------------------------------------------\n" + + "> 3:2-48 + combined.fa\n" + + "AAGCCCTGC--GCGCTCAGCCGGAGTGTCCCGGGCCCTGCTTTCCTTTT\n" + + "=\n" + + "> 1:1-1 + combined.fa\n" + + "G\n" + + "=\n" + + "> 1:50-50 + combined.fa\n" + + "A\n" + + "=\n" + + "> 2:1-41 + combined.fa\n" + + "GAAGAGGAAAAGTAGATCCCTGGCGTCCGGAGCTGGGACGT\n" + + "=\n" + + "> 3:1-1 + combined.fa\n" + + "C\n" + + "=\n" + + "> 3:49-49 + combined.fa\n" + + "C\n" + + "=\n" +} diff --git a/src/align_phylip.mbt b/src/align_phylip.mbt new file mode 100644 index 00000000..061a3c77 --- /dev/null +++ b/src/align_phylip.mbt @@ -0,0 +1,1161 @@ +// Biopython-compatible Bio.Align.phylip support. +// +// This module is separate from phylip_io.mbt. The older module exposes the +// historical AlignIO-style MultipleSeqAlignment API, while this file models +// the modern coordinate-bearing Alignment representation and strict PHYLIP +// sequential/interleaved parsing semantics. + +///| +/// Error raised for malformed PHYLIP data or invalid alignment operations. +pub suberror AlignPhylipError { + AlignPhylipError(String) +} + +///| +/// Physical layout detected in or requested for a PHYLIP document. +pub(all) enum AlignPhylipLayout { + PhylipSequential + PhylipInterleaved +} derive(Eq, Debug) + +///| +/// One coordinate-bearing PHYLIP row. +pub struct AlignPhylipSequence { + id : String + sequence : String + aligned_sequence : String +} derive(Eq, Debug) + +///| +/// A modern PHYLIP multiple sequence alignment. +/// +/// PHYLIP identifiers read from files are the trimmed fixed-width 10-column +/// fields. Programmatically constructed rows may retain longer identifiers; +/// the writer applies Biopython's PHYLIP normalization when serializing them. +pub struct AlignPhylipAlignment { + sequences : Array[AlignPhylipSequence] + source_layout : AlignPhylipLayout +} derive(Eq, Debug) + +///| +/// Pairwise or all-pairs alignment statistics. +pub struct AlignPhylipCounts { + pairs : Int + aligned : Int + identities : Int + mismatches : Int + gap_columns : Int + double_gap_columns : Int + gap_opens : Int +} derive(Eq, Debug) + +///| +/// Construct one validated PHYLIP row from its printed aligned sequence. +pub fn AlignPhylipSequence::create( + id : String, + aligned_sequence : String, +) -> AlignPhylipSequence raise AlignPhylipError { + align_phylip_validate_id(id) + if aligned_sequence.length() == 0 { + raise AlignPhylipError("PHYLIP aligned sequence must not be empty") + } + align_phylip_validate_segment(aligned_sequence) + AlignPhylipSequence::{ + id, + sequence: align_phylip_remove_gaps(aligned_sequence), + aligned_sequence, + } +} + +///| +/// Construct a validated modern PHYLIP alignment. +pub fn AlignPhylipAlignment::create( + sequences : Array[AlignPhylipSequence], + source_layout? : AlignPhylipLayout = PhylipSequential, +) -> AlignPhylipAlignment raise AlignPhylipError { + let copied : Array[AlignPhylipSequence] = [] + for sequence in sequences { + copied.push(sequence) + } + let alignment = AlignPhylipAlignment::{ sequences: copied, source_layout } + align_phylip_validate_alignment(alignment) + alignment +} + +///| +/// Construct a coordinate-aware PHYLIP alignment from printed rows. +pub fn align_phylip_from_aligned( + ids : Array[String], + aligned_sequences : Array[String], + source_layout? : AlignPhylipLayout = PhylipSequential, +) -> AlignPhylipAlignment raise AlignPhylipError { + if ids.length() == 0 { + raise AlignPhylipError( + "PHYLIP alignment must contain at least one sequence", + ) + } + if ids.length() != aligned_sequences.length() { + raise AlignPhylipError( + "PHYLIP identifiers and aligned rows must have equal lengths", + ) + } + let sequences : Array[AlignPhylipSequence] = [] + for index = 0; index < ids.length(); index = index + 1 { + sequences.push( + AlignPhylipSequence::create(ids[index], aligned_sequences[index]), + ) + } + AlignPhylipAlignment::create(sequences, source_layout~) +} + +///| +/// Parse one strict PHYLIP alignment. +/// +/// The first line must contain the declared row and column counts. Identifiers +/// occupy exactly the first 10 columns of each first-block or first-row line. +/// As in Biopython 1.86, a blank line after the first `n` physical rows selects +/// interleaved parsing; otherwise wrapped sequential parsing is used. A file +/// containing exactly `n` complete rows is treated as sequential. +pub fn align_phylip_parse( + text : String, +) -> AlignPhylipAlignment raise AlignPhylipError { + let lines = align_phylip_lines(text) + if lines.length() == 0 || lines[0].trim().length() == 0 { + raise AlignPhylipError("Empty PHYLIP input") + } + let header = align_phylip_split_whitespace(lines[0]) + if header.length() != 2 { + raise AlignPhylipError("PHYLIP header must contain exactly two integers") + } + let number_of_sequences = align_phylip_parse_positive_int( + header[0], + "PHYLIP sequence count", + ) + let number_of_columns = align_phylip_parse_positive_int( + header[1], + "PHYLIP column count", + ) + let mut last = lines.length() - 1 + while last > 0 && lines[last].trim().length() == 0 { + last = last - 1 + } + if last < number_of_sequences { + raise AlignPhylipError( + "PHYLIP input has fewer rows than declared in its header", + ) + } + for index = 1; index <= number_of_sequences; index = index + 1 { + if lines[index].trim().length() == 0 { + raise AlignPhylipError( + "PHYLIP first block contains an empty sequence row", + ) + } + } + let marker = number_of_sequences + 1 + let layout = if marker > last { + PhylipSequential + } else if lines[marker].trim().length() == 0 { + PhylipInterleaved + } else { + PhylipSequential + } + let sequences = match layout { + PhylipSequential => + align_phylip_parse_sequential( + lines, last, number_of_sequences, number_of_columns, + ) + PhylipInterleaved => + align_phylip_parse_interleaved( + lines, last, number_of_sequences, number_of_columns, + ) + } + AlignPhylipAlignment::create(sequences, source_layout=layout) +} + +///| +/// Serialize a PHYLIP alignment. +/// +/// Defaults match Biopython's modern writer: sequential rows, no wrapping, +/// fixed 10-column normalized identifiers, and no grouping whitespace. +/// `block_width` and `group_width` enable canonical wrapped or interleaved +/// presentation without changing alignment coordinates. +pub fn align_phylip_write( + alignment : AlignPhylipAlignment, + layout? : AlignPhylipLayout = PhylipSequential, + block_width? : Int = 0, + group_width? : Int = 0, +) -> String raise AlignPhylipError { + align_phylip_validate_alignment(alignment) + if block_width < 0 { + raise AlignPhylipError("PHYLIP block width must be non-negative") + } + if group_width < 0 { + raise AlignPhylipError("PHYLIP group width must be non-negative") + } + let width = alignment.alignment_length() + let effective_block_width = if block_width == 0 { + if layout == PhylipInterleaved { + 60 + } else { + width + } + } else { + block_width + } + if effective_block_width <= 0 { + raise AlignPhylipError("PHYLIP block width must be positive") + } + let names : Array[String] = [] + for sequence in alignment.sequences { + names.push(align_phylip_normalize_id(sequence.id)) + } + let output = StringBuilder::new() + output.write_string(alignment.num_sequences().to_string()) + output.write_char(' ') + output.write_string(width.to_string()) + output.write_char('\n') + match layout { + PhylipSequential => + for row = 0; row < alignment.num_sequences(); row = row + 1 { + let aligned = alignment.sequences[row].aligned_sequence + let mut start = 0 + while start < width { + let stop = if start + effective_block_width < width { + start + effective_block_width + } else { + width + } + if start == 0 { + align_phylip_write_name(output, names[row]) + } else { + output.write_string(" ".repeat(10)) + } + align_phylip_write_grouped( + output, + aligned[start:stop].to_owned(), + group_width, + ) + output.write_char('\n') + start = stop + } + } + PhylipInterleaved => { + let mut start = 0 + while start < width { + let stop = if start + effective_block_width < width { + start + effective_block_width + } else { + width + } + if start > 0 { + output.write_char('\n') + } + for row = 0; row < alignment.num_sequences(); row = row + 1 { + if start == 0 { + align_phylip_write_name(output, names[row]) + } else { + output.write_string(" ".repeat(10)) + } + align_phylip_write_grouped( + output, + alignment.sequences[row].aligned_sequence[start:stop].to_owned(), + group_width, + ) + output.write_char('\n') + } + start = stop + } + } + } + let result = output.to_string() + let reparsed = align_phylip_parse(result) + if reparsed.num_sequences() != alignment.num_sequences() || + reparsed.alignment_length() != alignment.alignment_length() { + raise AlignPhylipError("PHYLIP writer self-validation failed") + } + for row = 0; row < alignment.num_sequences(); row = row + 1 { + if reparsed.sequences[row].id != names[row] || + reparsed.sequences[row].aligned_sequence != + alignment.sequences[row].aligned_sequence { + raise AlignPhylipError("PHYLIP writer self-validation failed") + } + } + result +} + +///| +/// Apply Biopython's strict PHYLIP identifier normalization. +/// +/// Outer whitespace is removed, `[](),` are deleted, `:;` become `|`, and +/// the result is truncated to the fixed 10-column identifier field. +pub fn align_phylip_normalize_id(id : String) -> String raise AlignPhylipError { + align_phylip_validate_id(id) + let trimmed = id.trim().to_owned() + let output = StringBuilder::new(size_hint=trimmed.length()) + for index = 0; index < trimmed.length(); index = index + 1 { + let code = trimmed.unsafe_get(index).to_int() + if code == '['.to_int() || + code == ']'.to_int() || + code == '('.to_int() || + code == ')'.to_int() || + code == ','.to_int() { + continue + } + if code == ':'.to_int() || code == ';'.to_int() { + output.write_char('|') + } else { + output.write_char(code.unsafe_to_char()) + } + } + let normalized = output.to_string() + if normalized.length() > 10 { + normalized[0:10].to_owned() + } else { + normalized + } +} + +///| +/// Return serialized identifiers in row order. +pub fn AlignPhylipAlignment::normalized_ids( + self : AlignPhylipAlignment, +) -> Array[String] { + let result : Array[String] = [] + for sequence in self.sequences { + result.push( + align_phylip_normalize_id(sequence.id) catch { + AlignPhylipError(_) => "" + }, + ) + } + result +} + +///| +/// Return whether PHYLIP normalization maps two rows to the same identifier. +pub fn AlignPhylipAlignment::has_normalized_id_collisions( + self : AlignPhylipAlignment, +) -> Bool { + let names = self.normalized_ids() + for first = 0; first < names.length(); first = first + 1 { + for second = first + 1; second < names.length(); second = second + 1 { + if names[first] == names[second] { + return true + } + } + } + false +} + +///| +/// Return the number of sequence rows. +pub fn AlignPhylipAlignment::num_sequences(self : AlignPhylipAlignment) -> Int { + self.sequences.length() +} + +///| +/// Return the alignment width including gaps. +pub fn AlignPhylipAlignment::alignment_length( + self : AlignPhylipAlignment, +) -> Int { + if self.sequences.length() == 0 { + 0 + } else { + self.sequences[0].aligned_sequence.length() + } +} + +///| +/// Locate every row with an exact identifier. Duplicate strict identifiers +/// are legal in PHYLIP and therefore all matches are returned. +pub fn AlignPhylipAlignment::find_sequences( + self : AlignPhylipAlignment, + id : String, +) -> Array[Int] { + let result : Array[Int] = [] + for index = 0; index < self.sequences.length(); index = index + 1 { + if self.sequences[index].id == id { + result.push(index) + } + } + result +} + +///| +/// Return one printed alignment column. +pub fn AlignPhylipAlignment::column( + self : AlignPhylipAlignment, + column : Int, +) -> String? { + if column < 0 || column >= self.alignment_length() { + return None + } + let result = StringBuilder::new(size_hint=self.sequences.length()) + for sequence in self.sequences { + result.write_char( + sequence.aligned_sequence.unsafe_get(column).unsafe_to_char(), + ) + } + Some(result.to_string()) +} + +///| +/// Map a zero-based ungapped row position to an alignment column. +pub fn AlignPhylipAlignment::sequence_position_to_column( + self : AlignPhylipAlignment, + row : Int, + position : Int, +) -> Int? { + if row < 0 || + row >= self.sequences.length() || + position < 0 || + position >= self.sequences[row].sequence.length() { + return None + } + let aligned = self.sequences[row].aligned_sequence + let mut coordinate = 0 + for column = 0; column < aligned.length(); column = column + 1 { + if aligned.unsafe_get(column).to_int() != '-'.to_int() { + if coordinate == position { + return Some(column) + } + coordinate = coordinate + 1 + } + } + None +} + +///| +/// Map one alignment column to a zero-based ungapped row position. +pub fn AlignPhylipAlignment::column_to_sequence_position( + self : AlignPhylipAlignment, + row : Int, + column : Int, +) -> Int? { + if row < 0 || + row >= self.sequences.length() || + column < 0 || + column >= self.alignment_length() { + return None + } + let aligned = self.sequences[row].aligned_sequence + if aligned.unsafe_get(column).to_int() == '-'.to_int() { + return None + } + let mut coordinate = 0 + for index = 0; index < column; index = index + 1 { + if aligned.unsafe_get(index).to_int() != '-'.to_int() { + coordinate = coordinate + 1 + } + } + Some(coordinate) +} + +///| +/// Project one row position through the alignment to another row. +pub fn AlignPhylipAlignment::map_position( + self : AlignPhylipAlignment, + source_row : Int, + target_row : Int, + source_position : Int, +) -> Int? { + if target_row < 0 || target_row >= self.sequences.length() { + return None + } + match self.sequence_position_to_column(source_row, source_position) { + Some(column) => self.column_to_sequence_position(target_row, column) + None => None + } +} + +///| +/// Return per-column residue positions for two rows. +pub fn AlignPhylipAlignment::aligned_pairs( + self : AlignPhylipAlignment, + first_row : Int, + second_row : Int, +) -> Array[(Int?, Int?)] raise AlignPhylipError { + align_phylip_validate_row(self, first_row) + align_phylip_validate_row(self, second_row) + let result : Array[(Int?, Int?)] = [] + let mut first_position = 0 + let mut second_position = 0 + for column = 0; column < self.alignment_length(); column = column + 1 { + let first_gap = self.sequences[first_row].aligned_sequence + .unsafe_get(column) + .to_int() == + '-'.to_int() + let second_gap = self.sequences[second_row].aligned_sequence + .unsafe_get(column) + .to_int() == + '-'.to_int() + result.push( + ( + if first_gap { + None + } else { + Some(first_position) + }, + if second_gap { + None + } else { + Some(second_position) + }, + ), + ) + if !first_gap { + first_position = first_position + 1 + } + if !second_gap { + second_position = second_position + 1 + } + } + result +} + +///| +/// Return a compact Biopython-style coordinate path for all rows. +pub fn AlignPhylipAlignment::coordinate_path( + self : AlignPhylipAlignment, +) -> Array[Array[Int]] { + let paths : Array[Array[Int]] = [] + let coordinates = Array::make(self.sequences.length(), 0) + for _row = 0; _row < self.sequences.length(); _row = _row + 1 { + paths.push([0]) + } + let width = self.alignment_length() + for column = 0; column < width; column = column + 1 { + for row = 0; row < self.sequences.length(); row = row + 1 { + if self.sequences[row].aligned_sequence.unsafe_get(column).to_int() != + '-'.to_int() { + coordinates[row] = coordinates[row] + 1 + } + } + let boundary = if column + 1 == width { + true + } else { + align_phylip_movement_changes(self, column, column + 1) + } + if boundary { + for row = 0; row < self.sequences.length(); row = row + 1 { + paths[row].push(coordinates[row]) + } + } + } + paths +} + +///| +/// Compute statistics for one pair of rows. +pub fn AlignPhylipAlignment::pair_counts( + self : AlignPhylipAlignment, + first_row : Int, + second_row : Int, +) -> AlignPhylipCounts raise AlignPhylipError { + align_phylip_validate_row(self, first_row) + align_phylip_validate_row(self, second_row) + align_phylip_count_pair(self, first_row, second_row) +} + +///| +/// Aggregate statistics across every unordered pair. +pub fn AlignPhylipAlignment::counts( + self : AlignPhylipAlignment, +) -> AlignPhylipCounts { + let mut pairs = 0 + let mut aligned = 0 + let mut identities = 0 + let mut mismatches = 0 + let mut gap_columns = 0 + let mut double_gap_columns = 0 + let mut gap_opens = 0 + for first = 0; first < self.sequences.length(); first = first + 1 { + for second = first + 1 + second < self.sequences.length() + second = second + 1 { + let counts = align_phylip_count_pair(self, first, second) + pairs = pairs + 1 + aligned = aligned + counts.aligned + identities = identities + counts.identities + mismatches = mismatches + counts.mismatches + gap_columns = gap_columns + counts.gap_columns + double_gap_columns = double_gap_columns + counts.double_gap_columns + gap_opens = gap_opens + counts.gap_opens + } + } + AlignPhylipCounts::{ + pairs, + aligned, + identities, + mismatches, + gap_columns, + double_gap_columns, + gap_opens, + } +} + +///| +/// Return exact identity over columns containing residues in both rows. +pub fn AlignPhylipCounts::identity(self : AlignPhylipCounts) -> Double { + if self.aligned == 0 { + 0.0 + } else { + self.identities.to_double() / self.aligned.to_double() + } +} + +///| +/// Return per-column non-gap occupancy. +pub fn AlignPhylipAlignment::occupancy( + self : AlignPhylipAlignment, +) -> Array[Double] { + let result : Array[Double] = [] + for column = 0; column < self.alignment_length(); column = column + 1 { + let mut residues = 0 + for sequence in self.sequences { + if sequence.aligned_sequence.unsafe_get(column).to_int() != '-'.to_int() { + residues = residues + 1 + } + } + result.push(residues.to_double() / self.sequences.length().to_double()) + } + result +} + +///| +/// Calculate a majority residue consensus. Gaps do not vote. +pub fn AlignPhylipAlignment::majority_consensus( + self : AlignPhylipAlignment, + minimum_fraction? : Double = 0.0, +) -> String raise AlignPhylipError { + if minimum_fraction != minimum_fraction || + minimum_fraction < 0.0 || + minimum_fraction > 1.0 { + raise AlignPhylipError( + "PHYLIP consensus minimum fraction must be between 0 and 1", + ) + } + let output = StringBuilder::new(size_hint=self.alignment_length()) + for column = 0; column < self.alignment_length(); column = column + 1 { + let frequencies = Array::make(128, 0) + let mut residues = 0 + for sequence in self.sequences { + let code = sequence.aligned_sequence.unsafe_get(column).to_int() + if code != '-'.to_int() { + let upper = align_phylip_upper_code(code) + if upper >= 0 && upper < frequencies.length() { + frequencies[upper] = frequencies[upper] + 1 + } + residues = residues + 1 + } + } + if residues == 0 { + output.write_char('-') + continue + } + let mut best_code = 0 + let mut best_count = -1 + for code = 0; code < frequencies.length(); code = code + 1 { + if frequencies[code] > best_count { + best_code = code + best_count = frequencies[code] + } + } + if best_count.to_double() / residues.to_double() < minimum_fraction { + output.write_char('X') + } else { + output.write_char(best_code.unsafe_to_char()) + } + } + output.to_string() +} + +///| +/// Return a compact alignment summary. +pub fn AlignPhylipAlignment::summary(self : AlignPhylipAlignment) -> String { + "AlignPhylipAlignment(layout=" + + (match self.source_layout { + PhylipSequential => "sequential" + PhylipInterleaved => "interleaved" + }) + + ", sequences=" + + self.num_sequences().to_string() + + ", columns=" + + self.alignment_length().to_string() + + ", normalized_collisions=" + + self.has_normalized_id_collisions().to_string() + + ")" +} + +///| +/// Return a compact official-style interleaved PHYLIP fixture. +pub fn align_phylip_example_text() -> String { + "3 12\n" + + "Reference MKT--AIL\n" + + "Query_one M-TQQAIL\n" + + "Query_two MKT--AVL\n" + + "\n" + + " GHAA\n" + + " G-AA\n" + + " GHAA\n" +} + +///| +fn align_phylip_parse_sequential( + lines : Array[String], + last : Int, + number_of_sequences : Int, + number_of_columns : Int, +) -> Array[AlignPhylipSequence] raise AlignPhylipError { + let result : Array[AlignPhylipSequence] = [] + let mut line_index = 1 + for _row = 0; _row < number_of_sequences; _row = _row + 1 { + if line_index > last || lines[line_index].trim().length() == 0 { + raise AlignPhylipError( + "PHYLIP sequential data ended before all rows were read", + ) + } + let (id, first_segment) = align_phylip_parse_named_row(lines[line_index]) + line_index = line_index + 1 + let output = StringBuilder::new(size_hint=number_of_columns) + output.write_string(first_segment) + let mut length = first_segment.length() + if length > number_of_columns { + raise AlignPhylipError( + "PHYLIP sequential row exceeds the declared column count", + ) + } + while length < number_of_columns { + if line_index > last || lines[line_index].trim().length() == 0 { + raise AlignPhylipError( + "PHYLIP sequential row ended before its declared length", + ) + } + let segment = align_phylip_compact_segment(lines[line_index]) + align_phylip_validate_segment(segment) + if length + segment.length() > number_of_columns { + raise AlignPhylipError( + "PHYLIP sequential row exceeds the declared column count", + ) + } + output.write_string(segment) + length = length + segment.length() + line_index = line_index + 1 + } + result.push(AlignPhylipSequence::create(id, output.to_string())) + } + while line_index <= last { + if lines[line_index].trim().length() != 0 { + raise AlignPhylipError( + "PHYLIP input contains trailing non-whitespace data", + ) + } + line_index = line_index + 1 + } + result +} + +///| +fn align_phylip_parse_interleaved( + lines : Array[String], + last : Int, + number_of_sequences : Int, + number_of_columns : Int, +) -> Array[AlignPhylipSequence] raise AlignPhylipError { + let ids : Array[String] = [] + let builders : Array[StringBuilder] = [] + let lengths = Array::make(number_of_sequences, 0) + let mut first_width = -1 + for row = 0; row < number_of_sequences; row = row + 1 { + let (id, segment) = align_phylip_parse_named_row(lines[row + 1]) + if first_width < 0 { + first_width = segment.length() + } else if segment.length() != first_width { + raise AlignPhylipError( + "PHYLIP rows in an interleaved block must have equal widths", + ) + } + if segment.length() > number_of_columns { + raise AlignPhylipError( + "PHYLIP interleaved row exceeds the declared column count", + ) + } + ids.push(id) + let output = StringBuilder::new(size_hint=number_of_columns) + output.write_string(segment) + builders.push(output) + lengths[row] = segment.length() + } + let mut line_index = number_of_sequences + 1 + while lengths[0] < number_of_columns { + while line_index <= last && lines[line_index].trim().length() == 0 { + line_index = line_index + 1 + } + if line_index > last { + raise AlignPhylipError( + "PHYLIP interleaved data ended before its declared length", + ) + } + let segments : Array[String] = [] + let mut block_width = -1 + for _row = 0; _row < number_of_sequences; _row = _row + 1 { + if line_index > last || lines[line_index].trim().length() == 0 { + raise AlignPhylipError( + "PHYLIP interleaved block has fewer rows than declared", + ) + } + let segment = align_phylip_compact_segment(lines[line_index]) + align_phylip_validate_segment(segment) + if block_width < 0 { + block_width = segment.length() + } else if segment.length() != block_width { + raise AlignPhylipError( + "PHYLIP rows in an interleaved block must have equal widths", + ) + } + segments.push(segment) + line_index = line_index + 1 + } + for row = 0; row < number_of_sequences; row = row + 1 { + if lengths[row] + segments[row].length() > number_of_columns { + raise AlignPhylipError( + "PHYLIP interleaved row exceeds the declared column count", + ) + } + builders[row].write_string(segments[row]) + lengths[row] = lengths[row] + segments[row].length() + } + } + for row = 0; row < number_of_sequences; row = row + 1 { + if lengths[row] != number_of_columns { + raise AlignPhylipError( + "PHYLIP row length differs from the declared column count", + ) + } + } + while line_index <= last { + if lines[line_index].trim().length() != 0 { + raise AlignPhylipError( + "PHYLIP input contains trailing non-whitespace data", + ) + } + line_index = line_index + 1 + } + let result : Array[AlignPhylipSequence] = [] + for row = 0; row < number_of_sequences; row = row + 1 { + result.push( + AlignPhylipSequence::create(ids[row], builders[row].to_string()), + ) + } + result +} + +///| +fn align_phylip_parse_named_row( + line : String, +) -> (String, String) raise AlignPhylipError { + if line.length() < 10 { + raise AlignPhylipError( + "PHYLIP sequence row is shorter than the 10-column identifier field", + ) + } + let id = line[0:10].trim().to_owned() + align_phylip_validate_id(id) + let segment = align_phylip_compact_segment(line[10:line.length()].to_owned()) + align_phylip_validate_segment(segment) + (id, segment) +} + +///| +fn align_phylip_validate_alignment( + alignment : AlignPhylipAlignment, +) -> Unit raise AlignPhylipError { + if alignment.sequences.length() == 0 { + raise AlignPhylipError( + "PHYLIP alignment must contain at least one sequence", + ) + } + let width = alignment.sequences[0].aligned_sequence.length() + if width == 0 { + raise AlignPhylipError("PHYLIP alignment must contain at least one column") + } + for sequence in alignment.sequences { + align_phylip_validate_id(sequence.id) + if sequence.aligned_sequence.length() != width { + raise AlignPhylipError("PHYLIP aligned rows must have equal widths") + } + align_phylip_validate_segment(sequence.aligned_sequence) + if align_phylip_remove_gaps(sequence.aligned_sequence) != sequence.sequence { + raise AlignPhylipError( + "PHYLIP sequence row has inconsistent derived fields", + ) + } + } + for column = 0; column < width; column = column + 1 { + let mut residues = 0 + for sequence in alignment.sequences { + if sequence.aligned_sequence.unsafe_get(column).to_int() != '-'.to_int() { + residues = residues + 1 + } + } + if residues == 0 { + raise AlignPhylipError( + "PHYLIP alignment contains an all-gap column at " + column.to_string(), + ) + } + } +} + +///| +fn align_phylip_count_pair( + alignment : AlignPhylipAlignment, + first_row : Int, + second_row : Int, +) -> AlignPhylipCounts { + let first = alignment.sequences[first_row].aligned_sequence + let second = alignment.sequences[second_row].aligned_sequence + let mut aligned = 0 + let mut identities = 0 + let mut mismatches = 0 + let mut gap_columns = 0 + let mut double_gap_columns = 0 + let mut gap_opens = 0 + let mut in_gap = false + for column = 0; column < alignment.alignment_length(); column = column + 1 { + let first_code = first.unsafe_get(column).to_int() + let second_code = second.unsafe_get(column).to_int() + let first_gap = first_code == '-'.to_int() + let second_gap = second_code == '-'.to_int() + if first_gap && second_gap { + double_gap_columns = double_gap_columns + 1 + in_gap = false + } else if first_gap || second_gap { + gap_columns = gap_columns + 1 + if !in_gap { + gap_opens = gap_opens + 1 + } + in_gap = true + } else { + aligned = aligned + 1 + if first_code == second_code { + identities = identities + 1 + } else { + mismatches = mismatches + 1 + } + in_gap = false + } + } + AlignPhylipCounts::{ + pairs: 1, + aligned, + identities, + mismatches, + gap_columns, + double_gap_columns, + gap_opens, + } +} + +///| +fn align_phylip_movement_changes( + alignment : AlignPhylipAlignment, + first_column : Int, + second_column : Int, +) -> Bool { + for sequence in alignment.sequences { + let first_moves = sequence.aligned_sequence + .unsafe_get(first_column) + .to_int() != + '-'.to_int() + let second_moves = sequence.aligned_sequence + .unsafe_get(second_column) + .to_int() != + '-'.to_int() + if first_moves != second_moves { + return true + } + } + false +} + +///| +fn align_phylip_write_name(output : StringBuilder, name : String) -> Unit { + output.write_string(name) + if name.length() < 10 { + output.write_string(" ".repeat(10 - name.length())) + } +} + +///| +fn align_phylip_write_grouped( + output : StringBuilder, + segment : String, + group_width : Int, +) -> Unit { + if group_width == 0 || group_width >= segment.length() { + output.write_string(segment) + return + } + let mut start = 0 + while start < segment.length() { + let stop = if start + group_width < segment.length() { + start + group_width + } else { + segment.length() + } + if start > 0 { + output.write_char(' ') + } + output.write_string(segment[start:stop].to_owned()) + start = stop + } +} + +///| +fn align_phylip_validate_id(id : String) -> Unit raise AlignPhylipError { + for index = 0; index < id.length(); index = index + 1 { + let code = id.unsafe_get(index).to_int() + if code < 32 || code > 126 || code == '\n'.to_int() || code == '\r'.to_int() { + raise AlignPhylipError( + "PHYLIP sequence identifier contains a control or non-ASCII character", + ) + } + } +} + +///| +fn align_phylip_validate_segment( + segment : String, +) -> Unit raise AlignPhylipError { + if segment.length() == 0 { + raise AlignPhylipError("PHYLIP sequence segment must not be empty") + } + for index = 0; index < segment.length(); index = index + 1 { + let code = segment.unsafe_get(index).to_int() + if code == '.'.to_int() { + raise AlignPhylipError("PHYLIP format no longer allows dots in sequences") + } + if code <= 32 || code > 126 { + raise AlignPhylipError( + "PHYLIP sequence contains whitespace or a non-ASCII character", + ) + } + } +} + +///| +fn align_phylip_validate_row( + alignment : AlignPhylipAlignment, + row : Int, +) -> Unit raise AlignPhylipError { + if row < 0 || row >= alignment.sequences.length() { + raise AlignPhylipError("PHYLIP row index is out of bounds") + } +} + +///| +fn align_phylip_compact_segment(value : String) -> String { + let output = StringBuilder::new(size_hint=value.length()) + for index = 0; index < value.length(); index = index + 1 { + let code = value.unsafe_get(index).to_int() + if code != ' '.to_int() && code != '\t'.to_int() { + output.write_char(code.unsafe_to_char()) + } + } + output.to_string() +} + +///| +fn align_phylip_remove_gaps(value : String) -> String { + let output = StringBuilder::new(size_hint=value.length()) + for index = 0; index < value.length(); index = index + 1 { + let code = value.unsafe_get(index).to_int() + if code != '-'.to_int() { + output.write_char(code.unsafe_to_char()) + } + } + output.to_string() +} + +///| +fn align_phylip_upper_code(code : Int) -> Int { + if code >= 'a'.to_int() && code <= 'z'.to_int() { + code - 'a'.to_int() + 'A'.to_int() + } else { + code + } +} + +///| +fn align_phylip_lines(text : String) -> Array[String] { + let raw = text.split("\n").to_array() + let lines : Array[String] = [] + for line in raw { + if line.length() > 0 && + line.unsafe_get(line.length() - 1).to_int() == '\r'.to_int() { + lines.push(line[0:line.length() - 1].to_owned()) + } else { + lines.push(line.to_owned()) + } + } + lines +} + +///| +fn align_phylip_split_whitespace(value : String) -> Array[String] { + let fields : Array[String] = [] + let mut start = 0 + let mut in_field = false + for index = 0; index < value.length(); index = index + 1 { + let whitespace = align_phylip_is_whitespace( + value.unsafe_get(index).to_int(), + ) + if whitespace { + if in_field { + fields.push(value[start:index].to_owned()) + in_field = false + } + } else if !in_field { + start = index + in_field = true + } + } + if in_field { + fields.push(value[start:value.length()].to_owned()) + } + fields +} + +///| +fn align_phylip_parse_positive_int( + text : String, + label : String, +) -> Int raise AlignPhylipError { + if text.length() == 0 { + raise AlignPhylipError(label + " is empty") + } + let mut value = 0 + for index = 0; index < text.length(); index = index + 1 { + let code = text.unsafe_get(index).to_int() + if code < '0'.to_int() || code > '9'.to_int() { + raise AlignPhylipError(label + " must be a positive integer") + } + let digit = code - '0'.to_int() + if value > 214748364 || (value == 214748364 && digit > 7) { + raise AlignPhylipError(label + " is outside the supported integer range") + } + value = value * 10 + digit + } + if value <= 0 { + raise AlignPhylipError(label + " must be positive") + } + value +} + +///| +fn align_phylip_is_whitespace(code : Int) -> Bool { + code == ' '.to_int() || + code == '\t'.to_int() || + code == '\r'.to_int() || + code == '\n'.to_int() +} diff --git a/src/blast_xml_advanced.mbt b/src/blast_xml_advanced.mbt new file mode 100644 index 00000000..0caacf52 --- /dev/null +++ b/src/blast_xml_advanced.mbt @@ -0,0 +1,3204 @@ +// Biopython-compatible modern Bio.Blast XML support. +// +// This module parses and writes NCBI BLAST XML1 and XML2 artifacts. It does +// not submit remote BLAST jobs or launch local BLAST executables. + +///| +/// Error raised for malformed or inconsistent BLAST XML. +pub suberror BlastXmlError { + BlastXmlError(String) +} + +///| +/// NCBI BLAST XML dialect. +pub(all) enum BlastXmlFormat { + Xml1 + Xml2 +} derive(Eq, Debug) + +///| +/// One masked interval on the query, using zero-based half-open coordinates. +pub struct BlastXmlMask { + start : Int + end : Int +} derive(Eq, Debug) + +///| +/// Query metadata for one BLAST record. +pub struct BlastXmlQuery { + id : String + description : String + length : Int + sequence : String? + masks : Array[BlastXmlMask] +} derive(Eq, Debug) + +///| +/// Search parameters stored in a BLAST XML header. +pub struct BlastXmlParameters { + matrix : String? + expect : Double + inclusion_threshold : Double? + score_match : Int? + score_mismatch : Int? + gap_open : Int? + gap_extend : Int? + filter : String? + pattern : String? + entrez_query : String? + composition_based_statistics : Int? + query_genetic_code : Int? + database_genetic_code : Int? + bl2seq_mode : Int? +} derive(Eq, Debug) + +///| +/// Database and Karlin-Altschul statistics for one query. +/// +/// `database_letters` is a `Double` because BLAST databases can exceed the +/// platform `Int` range. Integer values below 2^53 remain exactly represented. +pub struct BlastXmlStatistics { + database_sequences : Int + database_letters : Double + effective_hsp_length : Int + effective_search_space : Double + kappa : Double + lambda : Double + entropy : Double +} derive(Eq, Debug) + +///| +/// One target description. XML2 can attach several descriptions to one hit. +pub struct BlastXmlDescription { + id : String + accession : String + title : String + taxid : Int? + scientific_name : String? +} derive(Eq, Debug) + +///| +/// One breakpoint in an HSP coordinate path. +/// +/// Coordinates are zero-based boundaries. Reverse-strand axes decrease. +/// Translated nucleotide axes move in steps of three. +pub struct BlastXmlCoordinate { + target : Int + query : Int +} derive(Eq, Debug) + +///| +/// One high-scoring segment pair. +pub struct BlastXmlHsp { + number : Int + bit_score : Double + score : Double + evalue : Double + query_from : Int + query_to : Int + target_from : Int + target_to : Int + query_frame : Int? + target_frame : Int? + query_strand : String? + target_strand : String? + identity : Int + positive : Int? + gaps : Int? + alignment_length : Int? + density : Int? + pattern_from : Int? + pattern_to : Int? + query_sequence : String + target_sequence : String + midline : String? + coordinates : Array[BlastXmlCoordinate] + query_coded_by : String? + target_coded_by : String? +} derive(Eq, Debug) + +///| +/// One BLAST database hit and its HSPs. +pub struct BlastXmlHit { + number : Int + descriptions : Array[BlastXmlDescription] + length : Int + hsps : Array[BlastXmlHsp] +} derive(Eq, Debug) + +///| +/// Results for one query. +pub struct BlastXmlRecord { + number : Int + query : BlastXmlQuery + hits : Array[BlastXmlHit] + statistics : BlastXmlStatistics? + message : String? +} derive(Eq, Debug) + +///| +/// A complete BLAST XML1 or XML2 document. +pub struct BlastXmlDocument { + format : BlastXmlFormat + program : String + version : String + reference : String + database : String + global_query : BlastXmlQuery? + parameters : BlastXmlParameters + records : Array[BlastXmlRecord] + megablast_statistics : BlastXmlStatistics? +} derive(Eq, Debug) + +///| +priv struct BlastXmlNode { + name : String + text : String + children : Array[BlastXmlNode] +} + +///| +fn blast_xml_fail(message : String) -> Unit raise BlastXmlError { + raise BlastXmlError(message) +} + +///| +fn blast_xml_copy_masks(values : Array[BlastXmlMask]) -> Array[BlastXmlMask] { + let copied : Array[BlastXmlMask] = [] + for value in values { + copied.push(value) + } + copied +} + +///| +fn blast_xml_copy_descriptions( + values : Array[BlastXmlDescription], +) -> Array[BlastXmlDescription] { + let copied : Array[BlastXmlDescription] = [] + for value in values { + copied.push(value) + } + copied +} + +///| +fn blast_xml_copy_coordinates( + values : Array[BlastXmlCoordinate], +) -> Array[BlastXmlCoordinate] { + let copied : Array[BlastXmlCoordinate] = [] + for value in values { + copied.push(value) + } + copied +} + +///| +fn blast_xml_copy_hsps(values : Array[BlastXmlHsp]) -> Array[BlastXmlHsp] { + let copied : Array[BlastXmlHsp] = [] + for value in values { + copied.push(value) + } + copied +} + +///| +fn blast_xml_copy_hits(values : Array[BlastXmlHit]) -> Array[BlastXmlHit] { + let copied : Array[BlastXmlHit] = [] + for value in values { + copied.push(value) + } + copied +} + +///| +fn blast_xml_copy_records( + values : Array[BlastXmlRecord], +) -> Array[BlastXmlRecord] { + let copied : Array[BlastXmlRecord] = [] + for value in values { + copied.push(value) + } + copied +} + +///| +fn blast_xml_copy_query(query : BlastXmlQuery) -> BlastXmlQuery { + BlastXmlQuery::{ + id: query.id, + description: query.description, + length: query.length, + sequence: query.sequence, + masks: blast_xml_copy_masks(query.masks), + } +} + +///| +pub fn BlastXmlMask::start(self : BlastXmlMask) -> Int { + self.start +} + +///| +pub fn BlastXmlMask::end(self : BlastXmlMask) -> Int { + self.end +} + +///| +pub fn BlastXmlQuery::id(self : BlastXmlQuery) -> String { + self.id +} + +///| +pub fn BlastXmlQuery::description(self : BlastXmlQuery) -> String { + self.description +} + +///| +pub fn BlastXmlQuery::length(self : BlastXmlQuery) -> Int { + self.length +} + +///| +pub fn BlastXmlQuery::sequence(self : BlastXmlQuery) -> String? { + self.sequence +} + +///| +pub fn BlastXmlQuery::masks(self : BlastXmlQuery) -> Array[BlastXmlMask] { + blast_xml_copy_masks(self.masks) +} + +///| +pub fn BlastXmlParameters::matrix(self : BlastXmlParameters) -> String? { + self.matrix +} + +///| +pub fn BlastXmlParameters::expect(self : BlastXmlParameters) -> Double { + self.expect +} + +///| +pub fn BlastXmlParameters::inclusion_threshold( + self : BlastXmlParameters, +) -> Double? { + self.inclusion_threshold +} + +///| +pub fn BlastXmlParameters::score_match(self : BlastXmlParameters) -> Int? { + self.score_match +} + +///| +pub fn BlastXmlParameters::score_mismatch(self : BlastXmlParameters) -> Int? { + self.score_mismatch +} + +///| +pub fn BlastXmlParameters::gap_open(self : BlastXmlParameters) -> Int? { + self.gap_open +} + +///| +pub fn BlastXmlParameters::gap_extend(self : BlastXmlParameters) -> Int? { + self.gap_extend +} + +///| +pub fn BlastXmlParameters::filter(self : BlastXmlParameters) -> String? { + self.filter +} + +///| +pub fn BlastXmlParameters::pattern(self : BlastXmlParameters) -> String? { + self.pattern +} + +///| +pub fn BlastXmlParameters::entrez_query(self : BlastXmlParameters) -> String? { + self.entrez_query +} + +///| +pub fn BlastXmlParameters::composition_based_statistics( + self : BlastXmlParameters, +) -> Int? { + self.composition_based_statistics +} + +///| +pub fn BlastXmlParameters::query_genetic_code( + self : BlastXmlParameters, +) -> Int? { + self.query_genetic_code +} + +///| +pub fn BlastXmlParameters::database_genetic_code( + self : BlastXmlParameters, +) -> Int? { + self.database_genetic_code +} + +///| +pub fn BlastXmlParameters::bl2seq_mode(self : BlastXmlParameters) -> Int? { + self.bl2seq_mode +} + +///| +pub fn BlastXmlStatistics::database_sequences(self : BlastXmlStatistics) -> Int { + self.database_sequences +} + +///| +pub fn BlastXmlStatistics::database_letters( + self : BlastXmlStatistics, +) -> Double { + self.database_letters +} + +///| +pub fn BlastXmlStatistics::effective_hsp_length( + self : BlastXmlStatistics, +) -> Int { + self.effective_hsp_length +} + +///| +pub fn BlastXmlStatistics::effective_search_space( + self : BlastXmlStatistics, +) -> Double { + self.effective_search_space +} + +///| +pub fn BlastXmlStatistics::kappa(self : BlastXmlStatistics) -> Double { + self.kappa +} + +///| +pub fn BlastXmlStatistics::lambda(self : BlastXmlStatistics) -> Double { + self.lambda +} + +///| +pub fn BlastXmlStatistics::entropy(self : BlastXmlStatistics) -> Double { + self.entropy +} + +///| +pub fn BlastXmlDescription::id(self : BlastXmlDescription) -> String { + self.id +} + +///| +pub fn BlastXmlDescription::accession(self : BlastXmlDescription) -> String { + self.accession +} + +///| +pub fn BlastXmlDescription::title(self : BlastXmlDescription) -> String { + self.title +} + +///| +pub fn BlastXmlDescription::taxid(self : BlastXmlDescription) -> Int? { + self.taxid +} + +///| +pub fn BlastXmlDescription::scientific_name( + self : BlastXmlDescription, +) -> String? { + self.scientific_name +} + +///| +pub fn BlastXmlCoordinate::target(self : BlastXmlCoordinate) -> Int { + self.target +} + +///| +pub fn BlastXmlCoordinate::query(self : BlastXmlCoordinate) -> Int { + self.query +} + +///| +pub fn BlastXmlHsp::number(self : BlastXmlHsp) -> Int { + self.number +} + +///| +pub fn BlastXmlHsp::bit_score(self : BlastXmlHsp) -> Double { + self.bit_score +} + +///| +pub fn BlastXmlHsp::score(self : BlastXmlHsp) -> Double { + self.score +} + +///| +pub fn BlastXmlHsp::evalue(self : BlastXmlHsp) -> Double { + self.evalue +} + +///| +pub fn BlastXmlHsp::query_from(self : BlastXmlHsp) -> Int { + self.query_from +} + +///| +pub fn BlastXmlHsp::query_to(self : BlastXmlHsp) -> Int { + self.query_to +} + +///| +pub fn BlastXmlHsp::target_from(self : BlastXmlHsp) -> Int { + self.target_from +} + +///| +pub fn BlastXmlHsp::target_to(self : BlastXmlHsp) -> Int { + self.target_to +} + +///| +pub fn BlastXmlHsp::query_frame(self : BlastXmlHsp) -> Int? { + self.query_frame +} + +///| +pub fn BlastXmlHsp::target_frame(self : BlastXmlHsp) -> Int? { + self.target_frame +} + +///| +pub fn BlastXmlHsp::query_strand(self : BlastXmlHsp) -> String? { + self.query_strand +} + +///| +pub fn BlastXmlHsp::target_strand(self : BlastXmlHsp) -> String? { + self.target_strand +} + +///| +pub fn BlastXmlHsp::identity(self : BlastXmlHsp) -> Int { + self.identity +} + +///| +pub fn BlastXmlHsp::positive(self : BlastXmlHsp) -> Int? { + self.positive +} + +///| +pub fn BlastXmlHsp::gaps(self : BlastXmlHsp) -> Int? { + self.gaps +} + +///| +pub fn BlastXmlHsp::alignment_length(self : BlastXmlHsp) -> Int? { + self.alignment_length +} + +///| +pub fn BlastXmlHsp::density(self : BlastXmlHsp) -> Int? { + self.density +} + +///| +pub fn BlastXmlHsp::query_sequence(self : BlastXmlHsp) -> String { + self.query_sequence +} + +///| +pub fn BlastXmlHsp::target_sequence(self : BlastXmlHsp) -> String { + self.target_sequence +} + +///| +pub fn BlastXmlHsp::midline(self : BlastXmlHsp) -> String? { + self.midline +} + +///| +pub fn BlastXmlHsp::coordinates( + self : BlastXmlHsp, +) -> Array[BlastXmlCoordinate] { + blast_xml_copy_coordinates(self.coordinates) +} + +///| +pub fn BlastXmlHsp::query_coded_by(self : BlastXmlHsp) -> String? { + self.query_coded_by +} + +///| +pub fn BlastXmlHsp::target_coded_by(self : BlastXmlHsp) -> String? { + self.target_coded_by +} + +///| +pub fn BlastXmlHsp::identity_fraction(self : BlastXmlHsp) -> Double { + match self.alignment_length { + Some(length) => + if length == 0 { + 0.0 + } else { + self.identity.to_double() / length.to_double() + } + None => 0.0 + } +} + +///| +pub fn BlastXmlHit::number(self : BlastXmlHit) -> Int { + self.number +} + +///| +pub fn BlastXmlHit::descriptions( + self : BlastXmlHit, +) -> Array[BlastXmlDescription] { + blast_xml_copy_descriptions(self.descriptions) +} + +///| +pub fn BlastXmlHit::primary_description( + self : BlastXmlHit, +) -> BlastXmlDescription { + self.descriptions[0] +} + +///| +pub fn BlastXmlHit::length(self : BlastXmlHit) -> Int { + self.length +} + +///| +pub fn BlastXmlHit::hsps(self : BlastXmlHit) -> Array[BlastXmlHsp] { + blast_xml_copy_hsps(self.hsps) +} + +///| +pub fn BlastXmlHit::best_hsp(self : BlastXmlHit) -> BlastXmlHsp? { + if self.hsps.length() == 0 { + return None + } + let mut best = self.hsps[0] + for i = 1; i < self.hsps.length(); i = i + 1 { + let candidate = self.hsps[i] + if candidate.evalue < best.evalue || + (candidate.evalue == best.evalue && candidate.bit_score > best.bit_score) { + best = candidate + } + } + Some(best) +} + +///| +pub fn BlastXmlRecord::number(self : BlastXmlRecord) -> Int { + self.number +} + +///| +pub fn BlastXmlRecord::query(self : BlastXmlRecord) -> BlastXmlQuery { + blast_xml_copy_query(self.query) +} + +///| +pub fn BlastXmlRecord::hits(self : BlastXmlRecord) -> Array[BlastXmlHit] { + blast_xml_copy_hits(self.hits) +} + +///| +pub fn BlastXmlRecord::statistics(self : BlastXmlRecord) -> BlastXmlStatistics? { + self.statistics +} + +///| +pub fn BlastXmlRecord::message(self : BlastXmlRecord) -> String? { + self.message +} + +///| +pub fn BlastXmlRecord::hit( + self : BlastXmlRecord, + identifier : String, +) -> BlastXmlHit? { + for hit in self.hits { + for description in hit.descriptions { + if description.id == identifier || description.accession == identifier { + return Some(hit) + } + } + } + None +} + +///| +pub fn BlastXmlRecord::best_hit(self : BlastXmlRecord) -> BlastXmlHit? { + if self.hits.length() == 0 { + return None + } + let mut best_hit = self.hits[0] + let mut best_hsp = best_hit.best_hsp() + for i = 1; i < self.hits.length(); i = i + 1 { + let candidate_hsp = self.hits[i].best_hsp() + match (best_hsp, candidate_hsp) { + (None, Some(value)) => { + best_hit = self.hits[i] + best_hsp = Some(value) + } + (Some(current), Some(candidate)) => + if candidate.evalue < current.evalue || + ( + candidate.evalue == current.evalue && + candidate.bit_score > current.bit_score + ) { + best_hit = self.hits[i] + best_hsp = Some(candidate) + } + _ => () + } + } + Some(best_hit) +} + +///| +pub fn BlastXmlRecord::filter_evalue( + self : BlastXmlRecord, + maximum : Double, +) -> BlastXmlRecord raise BlastXmlError { + if maximum < 0.0 || maximum.abs() > 1.0e300 { + blast_xml_fail("BLAST XML E-value threshold must be finite and nonnegative") + } + let hits : Array[BlastXmlHit] = [] + for hit in self.hits { + let hsps : Array[BlastXmlHsp] = [] + for hsp in hit.hsps { + if hsp.evalue <= maximum { + hsps.push(hsp) + } + } + if hsps.length() > 0 { + hits.push(BlastXmlHit::{ + number: hit.number, + descriptions: blast_xml_copy_descriptions(hit.descriptions), + length: hit.length, + hsps, + }) + } + } + BlastXmlRecord::{ + number: self.number, + query: blast_xml_copy_query(self.query), + hits, + statistics: self.statistics, + message: self.message, + } +} + +///| +pub fn BlastXmlDocument::format(self : BlastXmlDocument) -> BlastXmlFormat { + self.format +} + +///| +pub fn BlastXmlDocument::program(self : BlastXmlDocument) -> String { + self.program +} + +///| +pub fn BlastXmlDocument::version(self : BlastXmlDocument) -> String { + self.version +} + +///| +pub fn BlastXmlDocument::reference(self : BlastXmlDocument) -> String { + self.reference +} + +///| +pub fn BlastXmlDocument::database(self : BlastXmlDocument) -> String { + self.database +} + +///| +pub fn BlastXmlDocument::global_query( + self : BlastXmlDocument, +) -> BlastXmlQuery? { + match self.global_query { + Some(query) => Some(blast_xml_copy_query(query)) + None => None + } +} + +///| +pub fn BlastXmlDocument::parameters( + self : BlastXmlDocument, +) -> BlastXmlParameters { + self.parameters +} + +///| +pub fn BlastXmlDocument::records( + self : BlastXmlDocument, +) -> Array[BlastXmlRecord] { + blast_xml_copy_records(self.records) +} + +///| +pub fn BlastXmlDocument::megablast_statistics( + self : BlastXmlDocument, +) -> BlastXmlStatistics? { + self.megablast_statistics +} + +///| +pub fn BlastXmlDocument::record( + self : BlastXmlDocument, + query_id : String, +) -> BlastXmlRecord? { + for record in self.records { + if record.query.id == query_id { + return Some(record) + } + } + None +} + +///| +pub fn BlastXmlDocument::total_hits(self : BlastXmlDocument) -> Int { + let mut total = 0 + for record in self.records { + total = total + record.hits.length() + } + total +} + +///| +pub fn BlastXmlDocument::total_hsps(self : BlastXmlDocument) -> Int { + let mut total = 0 + for record in self.records { + for hit in record.hits { + total = total + hit.hsps.length() + } + } + total +} + +///| +fn blast_xml_is_space(code : Int) -> Bool { + code == 32 || code == 9 || code == 10 || code == 13 +} + +///| +fn blast_xml_trim(value : String) -> String { + let mut start = 0 + let mut end = value.length() + while start < end && blast_xml_is_space(value.unsafe_get(start).to_int()) { + start = start + 1 + } + while end > start && blast_xml_is_space(value.unsafe_get(end - 1).to_int()) { + end = end - 1 + } + value[start:end].to_owned() +} + +///| +fn blast_xml_starts_at(text : String, index : Int, token : String) -> Bool { + if index < 0 || index + token.length() > text.length() { + return false + } + for i = 0; i < token.length(); i = i + 1 { + if text.unsafe_get(index + i) != token.unsafe_get(i) { + return false + } + } + true +} + +///| +fn blast_xml_find(text : String, token : String, start : Int) -> Int { + if token.length() == 0 { + return start + } + let mut index = start + while index + token.length() <= text.length() { + if blast_xml_starts_at(text, index, token) { + return index + } + index = index + 1 + } + -1 +} + +///| +fn blast_xml_parse_radix_digits(value : String, radix : Int) -> Int? { + if value.length() == 0 { + return None + } + let mut result = 0 + for i = 0; i < value.length(); i = i + 1 { + let code = value.unsafe_get(i).to_int() + let digit = if code >= 48 && code <= 57 { + code - 48 + } else if code >= 65 && code <= 70 { + code - 55 + } else if code >= 97 && code <= 102 { + code - 87 + } else { + return None + } + if digit >= radix { + return None + } + result = result * radix + digit + } + Some(result) +} + +///| +fn blast_xml_character(code : Int) -> Char { + code.unsafe_to_char() +} + +///| +fn blast_xml_entity_character(entity : String) -> Char? { + match entity { + "lt" => Some('<') + "gt" => Some('>') + "amp" => Some('&') + "quot" => Some('"') + "apos" => Some('\'') + "nbsp" => Some(blast_xml_character(160)) + "Auml" => Some(blast_xml_character(196)) + "auml" => Some(blast_xml_character(228)) + "Ouml" => Some(blast_xml_character(214)) + "ouml" => Some(blast_xml_character(246)) + "Uuml" => Some(blast_xml_character(220)) + "uuml" => Some(blast_xml_character(252)) + "szlig" => Some(blast_xml_character(223)) + "eacute" => Some(blast_xml_character(233)) + _ => + if entity.length() > 1 && entity.unsafe_get(0).to_int() == 35 { + let digits = entity[1:].to_owned() + let parsed = if digits.length() > 1 && + ( + digits.unsafe_get(0).to_int() == 120 || + digits.unsafe_get(0).to_int() == 88 + ) { + blast_xml_parse_radix_digits(digits[1:].to_owned(), 16) + } else { + blast_xml_parse_radix_digits(digits, 10) + } + match parsed { + Some(code) => + if code > 0 && code <= 0x10ffff { + Some(code.unsafe_to_char()) + } else { + None + } + None => None + } + } else { + None + } + } +} + +///| +fn blast_xml_unescape_once(value : String) -> String { + let output = StringBuilder::new() + let mut index = 0 + while index < value.length() { + if value.unsafe_get(index).to_int() == 38 { + let semicolon = blast_xml_find(value, ";", index + 1) + if semicolon >= 0 { + let entity = value[index + 1:semicolon].to_owned() + match blast_xml_entity_character(entity) { + Some(character) => { + output.write_char(character) + index = semicolon + 1 + continue + } + None => () + } + } + } + output.write_char(value.unsafe_get(index).unsafe_to_char()) + index = index + 1 + } + output.to_string() +} + +///| +fn blast_xml_unescape(value : String) -> String { + blast_xml_unescape_once(blast_xml_unescape_once(value)) +} + +///| +fn blast_xml_normalize_tag(raw : String) -> String { + let mut value = raw + let colon = blast_xml_find(value, ":", 0) + if colon >= 0 { + value = value[colon + 1:].to_owned() + } + let mut last_underscore = -1 + for i = 0; i < value.length(); i = i + 1 { + if value.unsafe_get(i).to_int() == 95 { + last_underscore = i + } + } + if last_underscore >= 0 { + value = value[last_underscore + 1:].to_owned() + } + value.to_lower() +} + +///| +fn blast_xml_open_end(text : String, start : Int) -> Int raise BlastXmlError { + let mut quote = 0 + let mut index = start + while index < text.length() { + let code = text.unsafe_get(index).to_int() + if quote == 0 && (code == 34 || code == 39) { + quote = code + } else if quote == code { + quote = 0 + } else if quote == 0 && code == 62 { + return index + } + index = index + 1 + } + blast_xml_fail("Unterminated BLAST XML opening tag") + 0 +} + +///| +fn blast_xml_tag_name(opening : String) -> String raise BlastXmlError { + let trimmed = blast_xml_trim(opening) + let mut end = 0 + while end < trimmed.length() && + !blast_xml_is_space(trimmed.unsafe_get(end).to_int()) && + trimmed.unsafe_get(end).to_int() != 47 { + end = end + 1 + } + if end == 0 { + blast_xml_fail("BLAST XML contains an empty tag name") + } + blast_xml_normalize_tag(trimmed[0:end].to_owned()) +} + +///| +fn blast_xml_skip_declaration( + text : String, + start : Int, +) -> Int raise BlastXmlError { + if blast_xml_starts_at(text, start, "", start + 4) + if end < 0 { + blast_xml_fail("Unterminated BLAST XML comment") + } + return end + 3 + } + if blast_xml_starts_at(text, start, "", start + 2) + if end < 0 { + blast_xml_fail("Unterminated BLAST XML processing instruction") + } + return end + 2 + } + if blast_xml_starts_at(text, start, " (BlastXmlNode, Int) raise BlastXmlError { + if start >= text.length() || text.unsafe_get(start).to_int() != 60 { + blast_xml_fail("Expected a BLAST XML opening tag") + } + if blast_xml_starts_at(text, start, " 0 && + trimmed_opening.unsafe_get(trimmed_opening.length() - 1).to_int() == 47 + if self_closing { + return (BlastXmlNode::{ name, text: "", children: [] }, open_end + 1) + } + let children : Array[BlastXmlNode] = [] + let content = StringBuilder::new() + let mut index = open_end + 1 + while index < text.length() { + if blast_xml_starts_at(text, index, "", index + 9) + if end < 0 { + blast_xml_fail("Unterminated BLAST XML CDATA section") + } + content.write_string(text[index + 9:end].to_owned()) + index = end + 3 + continue + } + if blast_xml_starts_at(text, index, "", + ) + assert_eq(blast_xml_test_parse(text).version(), "BLASTP 2.15.0+") +} diff --git a/test/moonbit/exonerate_text_test.mbt b/test/moonbit/exonerate_text_test.mbt new file mode 100644 index 00000000..d0590ddc --- /dev/null +++ b/test/moonbit/exonerate_text_test.mbt @@ -0,0 +1,861 @@ +// Black-box tests for Bio.SearchIO.ExonerateIO.exonerate_text support. + +///| +fn exonerate_text_test_parse(text : String) -> @src.ExonerateTextDocument { + @src.exonerate_text_parse(text) catch { + ExonerateTextError(message) => + abort("valid Exonerate text failed: " + message) + } +} + +///| +fn exonerate_text_test_rejects(text : String) -> Bool { + try { + ignore(@src.exonerate_text_parse(text)) + false + } catch { + ExonerateTextError(_) => true + } +} + +///| +fn exonerate_text_test_wrap( + query : String, + query_description : String, + target : String, + target_description : String, + model : String, + score : Int, + query_start : Int, + query_end : Int, + target_start : Int, + target_end : Int, + body : String, +) -> String { + "Command line: [exonerate -m " + + model + + " query.fa target.fa]\n" + + "Hostname: [test-host]\n\n" + + exonerate_text_test_alignment( + query, query_description, target, target_description, model, score, query_start, + query_end, target_start, target_end, body, + ) + + "-- completed exonerate analysis\n" +} + +///| +fn exonerate_text_test_alignment( + query : String, + query_description : String, + target : String, + target_description : String, + model : String, + score : Int, + query_start : Int, + query_end : Int, + target_start : Int, + target_end : Int, + body : String, +) -> String { + "C4 Alignment:\n" + + "------------\n" + + " Query: " + + query + + (if query_description.length() > 0 { " " + query_description } else { "" }) + + "\n" + + " Target: " + + target + + (if target_description.length() > 0 { " " + target_description } else { "" }) + + "\n" + + " Model: " + + model + + "\n" + + " Raw score: " + + score.to_string() + + "\n" + + " Query range: " + + query_start.to_string() + + " -> " + + query_end.to_string() + + "\n" + + " Target range: " + + target_start.to_string() + + " -> " + + target_end.to_string() + + "\n\n" + + body + + "\n" +} + +///| +fn exonerate_text_test_dna_report() -> String { + exonerate_text_test_wrap( + "query1", + "demo query", + "target1", + "demo target", + "affine:local:dna2dna", + 31, + 0, + 6, + 100, + 107, + " 1 : ACGT-AC : 6\n" + " |||| ||\n" + " 101 : ACGTTAC : 107\n", + ) +} + +///| +fn exonerate_text_test_reverse_report() -> String { + exonerate_text_test_wrap( + "query1", + "", + "target1", + "reverse target:[revcomp]", + "ungapped:dna2dna", + 18, + 0, + 6, + 200, + 193, + " 1 : ACGTAC- : 6\n" + " |||||| \n" + " 200 : ACGTACT : 194\n", + ) +} + +///| +fn exonerate_text_test_center(value : String, width : Int) -> String { + let left = (width - value.length()) / 2 + " ".repeat(left) + value + " ".repeat(width - value.length() - left) +} + +///| +fn exonerate_text_test_intron_report() -> String { + let marker = " >>>> Target Intron 1 >>>> " + let splice = "gt" + ".".repeat(marker.length() - 4) + "ag" + let query_row = "ACG" + marker + "TAC" + let hit_row = "ACG" + splice + "TAC" + let similarity = "|||" + + exonerate_text_test_center("7 bp", marker.length()) + + "|||" + exonerate_text_test_wrap( + "transcript", + "", + "chromosome", + "", + "est2genome", + 42, + 0, + 6, + 100, + 113, + " 1 : " + + query_row + + " : 6\n" + + " " + + similarity + + "\n" + + " 101 : " + + hit_row + + " : 113\n", + ) +} + +///| +fn exonerate_text_test_ner_report() -> String { + let query_marker = "--< 4 >--" + let hit_marker = "--< 6 >--" + exonerate_text_test_wrap( + "query", + "", + "target", + "", + "NER:affine:local:dna2dna", + 25, + 0, + 10, + 100, + 112, + " 1 : AAA" + + query_marker + + "CCC : 10\n" + + " |||--< NER 1 >--|||\n" + + " 101 : AAA" + + hit_marker + + "CCC : 112\n", + ) +} + +///| +fn exonerate_text_test_protein_report() -> String { + exonerate_text_test_wrap( + "protein_query", + "", + "dna_target", + "", + "protein2dna:local", + 55, + 0, + 3, + 100, + 109, + " 1 : MetGly<->Lys : 3\n" + + " |||||| |||\n" + + " MetGly<->Lys\n" + + " 101 : ATGGGC---AAA : 109\n", + ) +} + +///| +fn exonerate_text_test_dna_to_protein_report() -> String { + exonerate_text_test_wrap( + "dna_query", + "", + "protein_target", + "", + "ungapped:dna2protein", + 44, + 0, + 9, + 10, + 13, + " 1 : ATGGGCAAA : 9\n" + + " MetGlyLys\n" + + " |||||||||\n" + + " 11 : MetGlyLys : 13\n", + ) +} + +///| +fn exonerate_text_test_frameshift_report() -> String { + exonerate_text_test_wrap( + "protein_query", + "", + "dna_target", + "", + "protein2dna:local", + 27, + 0, + 2, + 100, + 108, + " 1 : Asp--Ile : 2\n" + + " |||##|||\n" + + " Asp##Ile\n" + + " 101 : GATCCATT : 108\n", + ) +} + +///| +fn exonerate_text_test_wrapped_report() -> String { + exonerate_text_test_wrap( + "wrapped_query", + "", + "wrapped_target", + "", + "affine:local:dna2dna", + 36, + 0, + 8, + 100, + 108, + " 1 : ACGT : 4\n" + + " ||||\n" + + " 101 : ACGT : 104\n\n" + + " 5 : TGCA : 8\n" + + " ||||\n" + + " 105 : TGCA : 108\n", + ) +} + +///| +fn exonerate_text_test_joint_intron_report() -> String { + let marker = " >>>> Joint Intron 1 >>>> " + let similarity = "|||" + + exonerate_text_test_center("5 bp // 7 bp", marker.length()) + + "|||" + exonerate_text_test_wrap( + "joint_query", + "", + "joint_target", + "", + "est2genome", + 48, + 0, + 11, + 100, + 113, + " 1 : AAA" + + marker + + "CCC : 11\n" + + " " + + similarity + + "\n" + + " 101 : AAA" + + marker + + "CCC : 113\n", + ) +} + +///| +fn exonerate_text_test_reverse_intron_report() -> String { + let marker = " >>>> Target Intron 1 >>>> " + let splice = "gt" + ".".repeat(marker.length() - 4) + "ag" + let similarity = "|||" + + exonerate_text_test_center("7 bp", marker.length()) + + "|||" + exonerate_text_test_wrap( + "reverse_query", + "query strand:[revcomp]", + "reverse_target", + "target strand:[revcomp]", + "est2genome", + 41, + 10, + 4, + 200, + 187, + " 10 : ACG" + + marker + + "TAC : 5\n" + + " " + + similarity + + "\n" + + " 200 : ACG" + + splice + + "TAC : 188\n", + ) +} + +///| +fn exonerate_text_test_split_codon_report() -> String { + let marker = " >>>> Target Intron 1 >>>> " + let splice = "gt" + ".".repeat(marker.length() - 4) + "ag" + let similarity = "|||{||}" + + exonerate_text_test_center("7 bp", marker.length()) + + "{|}|||" + exonerate_text_test_wrap( + "protein_query", + "", + "genome_target", + "", + "protein2genome:local", + 73, + 0, + 3, + 100, + 116, + " 1 : Gly{Th}" + + marker + + "{r}Ala : 3\n" + + " " + + similarity + + "\n" + + " Gly{Th}" + + " ".repeat(marker.length()) + + "{r}Ala\n" + + " 101 : GGT{AC}" + + splice + + "{G}GCT : 116\n", + ) +} + +///| +fn exonerate_text_test_coding_report() -> String { + exonerate_text_test_wrap( + "coding_query", + "", + "coding_target", + "", + "coding2coding", + 52, + 0, + 6, + 100, + 106, + " 1 : ATGGAA : 6\n" + + " MetGlu\n" + + " ||||||\n" + + " MetGlu\n" + + " 101 : ATGGAA : 106\n", + ) +} + +///| +fn exonerate_text_test_coding_frameshift_report() -> String { + exonerate_text_test_wrap( + "coding_query", + "", + "coding_target", + "", + "coding2coding", + 39, + 0, + 6, + 100, + 106, + " 1 : ATGAC-A : 6\n" + + " Met#Thr\n" + + " |||#|||\n" + + " Met-Thr\n" + + " 101 : ATG-CTA : 106\n", + ) +} + +///| +fn exonerate_text_test_special_protein_report() -> String { + exonerate_text_test_wrap( + "special_protein", + "", + "special_dna", + "", + "protein2dna:local", + 29, + 0, + 3, + 100, + 109, + " 1 : ***UnkSec : 3\n" + + " |||||||||\n" + + " ***UnkSec\n" + + " 101 : TAANNNUGA : 109\n", + ) +} + +///| +fn exonerate_text_test_multi_report() -> String { + "Command line: [exonerate -m affine:local:dna2dna queries.fa targets.fa]\n" + + "Hostname: [aggregate-host]\n\n" + + exonerate_text_test_alignment( + "query1", "first query", "target1", "first target", "affine:local:dna2dna", 10, + 0, 3, 100, 103, " 1 : AAA : 3\n |||\n 101 : AAA : 103\n", + ) + + exonerate_text_test_alignment( + "query1", "first query", "target1", "first target", "affine:local:dna2dna", 20, + 3, 6, 200, 203, " 4 : CCC : 6\n |||\n 201 : CCC : 203\n", + ) + + exonerate_text_test_alignment( + "query1", "first query", "target2", "second target", "affine:local:dna2dna", + 15, 0, 3, 300, 303, " 1 : GGG : 3\n |||\n 301 : GGG : 303\n", + ) + + exonerate_text_test_alignment( + "query2", "second query", "target3", "third target", "affine:local:dna2dna", + 30, 0, 3, 400, 403, " 1 : TTT : 3\n |||\n 401 : TTT : 403\n", + ) + + "-- completed exonerate analysis\n" +} + +///| +test "Bio.SearchIO.ExonerateIO text parses metadata" { + let document = exonerate_text_test_parse(exonerate_text_test_dna_report()) + assert_eq(document.metadata.program, "exonerate") + assert_eq(document.metadata.hostname, "test-host") + assert_true(document.metadata.command_line.contains("affine:local:dna2dna")) +} + +///| +test "Bio.SearchIO.ExonerateIO text aggregates document shape" { + let document = exonerate_text_test_parse(exonerate_text_test_dna_report()) + assert_eq(document.num_queries(), 1) + assert_eq(document.num_hits(), 1) + assert_eq(document.num_hsps(), 1) +} + +///| +test "Bio.SearchIO.ExonerateIO text preserves identifiers and descriptions" { + let query = exonerate_text_test_parse(exonerate_text_test_dna_report()).queries[0] + assert_eq(query.id, "query1") + assert_eq(query.description, "demo query") + assert_eq(query.hits[0].id, "target1") + assert_eq(query.hits[0].description, "demo target") +} + +///| +test "Bio.SearchIO.ExonerateIO text parses DNA alignment rows" { + let fragment = exonerate_text_test_parse(exonerate_text_test_dna_report()).queries[0].hits[0].hsps[0].fragments[0] + assert_eq(fragment.query_sequence, "ACGT-AC") + assert_eq(fragment.similarity, "|||| ||") + assert_eq(fragment.hit_sequence, "ACGTTAC") +} + +///| +test "Bio.SearchIO.ExonerateIO text computes DNA coordinates" { + let hsp = exonerate_text_test_parse(exonerate_text_test_dna_report()).queries[0].hits[0].hsps[0] + assert_eq(hsp.query_start, 0) + assert_eq(hsp.query_end, 6) + assert_eq(hsp.hit_start, 100) + assert_eq(hsp.hit_end, 107) + assert_eq(hsp.fragments[0].query_start, 0) + assert_eq(hsp.fragments[0].query_end, 6) +} + +///| +test "Bio.SearchIO.ExonerateIO text reports strands" { + let hsp = exonerate_text_test_parse(exonerate_text_test_dna_report()).queries[0].hits[0].hsps[0] + assert_eq(hsp.query_strand, @src.ExonerateTextForward) + assert_eq(hsp.hit_strand, @src.ExonerateTextForward) +} + +///| +test "Bio.SearchIO.ExonerateIO text recognizes reverse complement suffix" { + let query = exonerate_text_test_parse(exonerate_text_test_reverse_report()).queries[0] + let hsp = query.hits[0].hsps[0] + assert_eq(query.hits[0].description, "reverse target") + assert_eq(hsp.hit_strand, @src.ExonerateTextReverse) + assert_eq(hsp.hit_start, 193) + assert_eq(hsp.hit_end, 200) +} + +///| +test "Bio.SearchIO.ExonerateIO text maps forward positions" { + let fragment = exonerate_text_test_parse(exonerate_text_test_dna_report()).queries[0].hits[0].hsps[0].fragments[0] + assert_eq(fragment.query_position(0), Some(0)) + assert_eq(fragment.query_position(4), None) + assert_eq(fragment.query_position(5), Some(4)) + assert_eq(fragment.hit_position(6), Some(106)) +} + +///| +test "Bio.SearchIO.ExonerateIO text maps reverse positions" { + let fragment = exonerate_text_test_parse(exonerate_text_test_reverse_report()).queries[0].hits[0].hsps[0].fragments[0] + assert_eq(fragment.hit_position(0), Some(199)) + assert_eq(fragment.hit_position(5), Some(194)) +} + +///| +test "Bio.SearchIO.ExonerateIO text splits target introns" { + let hsp = exonerate_text_test_parse(exonerate_text_test_intron_report()).queries[0].hits[0].hsps[0] + assert_eq(hsp.num_fragments(), 2) + assert_eq(hsp.fragments[0].query_sequence, "ACG") + assert_eq(hsp.fragments[1].query_sequence, "TAC") +} + +///| +test "Bio.SearchIO.ExonerateIO text computes intron ranges" { + let hsp = exonerate_text_test_parse(exonerate_text_test_intron_report()).queries[0].hits[0].hsps[0] + let query_ranges = hsp.query_ranges() + let hit_ranges = hsp.hit_ranges() + assert_eq(query_ranges[0], @src.ExonerateTextRange::create(0, 3)) + assert_eq(query_ranges[1], @src.ExonerateTextRange::create(3, 6)) + assert_eq(hit_ranges[0], @src.ExonerateTextRange::create(100, 103)) + assert_eq(hit_ranges[1], @src.ExonerateTextRange::create(110, 113)) +} + +///| +test "Bio.SearchIO.ExonerateIO text exposes intron inter-ranges" { + let hsp = exonerate_text_test_parse(exonerate_text_test_intron_report()).queries[0].hits[0].hsps[0] + assert_eq(hsp.query_inter_ranges()[0], @src.ExonerateTextRange::create(3, 3)) + assert_eq( + hsp.hit_inter_ranges()[0], + @src.ExonerateTextRange::create(103, 110), + ) +} + +///| +test "Bio.SearchIO.ExonerateIO text splits NER blocks" { + let hsp = exonerate_text_test_parse(exonerate_text_test_ner_report()).queries[0].hits[0].hsps[0] + assert_eq(hsp.num_fragments(), 2) + assert_eq(hsp.fragments[0].query_sequence, "AAA") + assert_eq(hsp.fragments[1].hit_sequence, "CCC") +} + +///| +test "Bio.SearchIO.ExonerateIO text applies independent NER lengths" { + let hsp = exonerate_text_test_parse(exonerate_text_test_ner_report()).queries[0].hits[0].hsps[0] + assert_eq(hsp.query_inter_ranges()[0], @src.ExonerateTextRange::create(3, 7)) + assert_eq( + hsp.hit_inter_ranges()[0], + @src.ExonerateTextRange::create(103, 109), + ) +} + +///| +test "Bio.SearchIO.ExonerateIO text converts protein2dna triplets" { + let fragment = exonerate_text_test_parse(exonerate_text_test_protein_report()).queries[0].hits[0].hsps[0].fragments[0] + assert_eq(fragment.query_sequence, "MG-K") + assert_eq(fragment.hit_sequence, "MG-K") + assert_eq(fragment.query_strand, @src.ExonerateTextProtein) + assert_eq(fragment.hit_strand, @src.ExonerateTextForward) +} + +///| +test "Bio.SearchIO.ExonerateIO text retains translated DNA annotation" { + let fragment = exonerate_text_test_parse(exonerate_text_test_protein_report()).queries[0].hits[0].hsps[0].fragments[0] + assert_eq(fragment.hit_annotation, Some("ATGGGC---AAA")) + assert_eq(fragment.query_step, 1) + assert_eq(fragment.hit_step, 3) +} + +///| +test "Bio.SearchIO.ExonerateIO text converts dna2protein triplets" { + let fragment = exonerate_text_test_parse( + exonerate_text_test_dna_to_protein_report(), + ).queries[0].hits[0].hsps[0].fragments[0] + assert_eq(fragment.query_sequence, "MGK") + assert_eq(fragment.hit_sequence, "MGK") + assert_eq(fragment.query_annotation, Some("ATGGGCAAA")) + assert_eq(fragment.hit_strand, @src.ExonerateTextProtein) +} + +///| +test "Bio.SearchIO.ExonerateIO text splits frameshifts" { + let hsp = exonerate_text_test_parse(exonerate_text_test_frameshift_report()).queries[0].hits[0].hsps[0] + assert_eq(hsp.num_fragments(), 2) + assert_eq(hsp.fragments[0].query_sequence, "D") + assert_eq(hsp.fragments[1].query_sequence, "I") + assert_eq(hsp.fragments[0].hit_sequence, "D") + assert_eq(hsp.fragments[1].hit_sequence, "I") +} + +///| +test "Bio.SearchIO.ExonerateIO text records frameshift coordinate gap" { + let hsp = exonerate_text_test_parse(exonerate_text_test_frameshift_report()).queries[0].hits[0].hsps[0] + assert_eq(hsp.query_inter_ranges()[0], @src.ExonerateTextRange::create(1, 1)) + assert_eq( + hsp.hit_inter_ranges()[0], + @src.ExonerateTextRange::create(103, 105), + ) + assert_eq(hsp.fragments[0].hit_frame, 2) + assert_eq(hsp.fragments[1].hit_frame, 1) +} + +///| +test "Bio.SearchIO.ExonerateIO text computes summary counts" { + let hsp = exonerate_text_test_parse(exonerate_text_test_dna_report()).queries[0].hits[0].hsps[0] + let counts = hsp.counts() + assert_eq(counts.fragments, 1) + assert_eq(counts.alignment_columns, 7) + assert_eq(counts.identities, 6) + assert_eq(counts.gap_columns, 1) + assert_eq(counts.query_gap_opens, 1) +} + +///| +test "Bio.SearchIO.ExonerateIO text stitches wrapped physical blocks" { + let hsp = exonerate_text_test_parse(exonerate_text_test_wrapped_report()).queries[0].hits[0].hsps[0] + assert_eq(hsp.num_fragments(), 1) + assert_eq(hsp.fragments[0].query_sequence, "ACGTTGCA") + assert_eq(hsp.fragments[0].hit_sequence, "ACGTTGCA") + assert_eq(hsp.counts().alignment_columns, 8) +} + +///| +test "Bio.SearchIO.ExonerateIO text parses joint intron lengths" { + let hsp = exonerate_text_test_parse(exonerate_text_test_joint_intron_report()).queries[0].hits[0].hsps[0] + assert_eq(hsp.num_fragments(), 2) + assert_eq(hsp.query_inter_ranges()[0], @src.ExonerateTextRange::create(3, 8)) + assert_eq( + hsp.hit_inter_ranges()[0], + @src.ExonerateTextRange::create(103, 110), + ) +} + +///| +test "Bio.SearchIO.ExonerateIO text computes reverse intron coordinates" { + let hsp = exonerate_text_test_parse( + exonerate_text_test_reverse_intron_report(), + ).queries[0].hits[0].hsps[0] + assert_eq(hsp.query_strand, @src.ExonerateTextReverse) + assert_eq(hsp.hit_strand, @src.ExonerateTextReverse) + assert_eq(hsp.query_ranges(), [ + @src.ExonerateTextRange::create(7, 10), + @src.ExonerateTextRange::create(4, 7), + ]) + assert_eq( + hsp.hit_inter_ranges()[0], + @src.ExonerateTextRange::create(190, 197), + ) +} + +///| +test "Bio.SearchIO.ExonerateIO text handles split protein codons" { + let hsp = exonerate_text_test_parse(exonerate_text_test_split_codon_report()).queries[0].hits[0].hsps[0] + assert_eq(hsp.num_fragments(), 2) + assert_eq(hsp.fragments[0].query_sequence, "GX") + assert_eq(hsp.fragments[1].query_sequence, "XA") + assert_eq(hsp.fragments[0].phase, 0) + assert_eq(hsp.fragments[1].phase, 1) + assert_eq(hsp.query_ranges(), [ + @src.ExonerateTextRange::create(0, 1), + @src.ExonerateTextRange::create(2, 3), + ]) + assert_eq(hsp.hit_ranges(), [ + @src.ExonerateTextRange::create(100, 105), + @src.ExonerateTextRange::create(112, 116), + ]) + assert_eq(hsp.hit_split_codons, [ + @src.ExonerateTextRange::create(103, 105), + @src.ExonerateTextRange::create(112, 113), + ]) +} + +///| +test "Bio.SearchIO.ExonerateIO text flips five-row coding alignments" { + let fragment = exonerate_text_test_parse(exonerate_text_test_coding_report()).queries[0].hits[0].hsps[0].fragments[0] + assert_eq(fragment.query_sequence, "ATGGAA") + assert_eq(fragment.hit_sequence, "ATGGAA") + assert_eq(fragment.query_annotation, Some("MetGlu")) + assert_eq(fragment.hit_annotation, Some("MetGlu")) +} + +///| +test "Bio.SearchIO.ExonerateIO text assigns five-row frameshifts" { + let hsp = exonerate_text_test_parse( + exonerate_text_test_coding_frameshift_report(), + ).queries[0].hits[0].hsps[0] + assert_eq(hsp.num_fragments(), 2) + assert_eq(hsp.fragments[0].query_sequence, "ATG") + assert_eq(hsp.fragments[1].query_sequence, "C-A") + assert_eq(hsp.query_inter_ranges()[0], @src.ExonerateTextRange::create(3, 4)) + assert_eq( + hsp.hit_inter_ranges()[0], + @src.ExonerateTextRange::create(103, 103), + ) +} + +///| +test "Bio.SearchIO.ExonerateIO text maps special amino acids" { + let fragment = exonerate_text_test_parse( + exonerate_text_test_special_protein_report(), + ).queries[0].hits[0].hsps[0].fragments[0] + assert_eq(fragment.query_sequence, "*XU") + assert_eq(fragment.hit_sequence, "*XU") +} + +///| +test "Bio.SearchIO.ExonerateIO text aggregates query hit and HSP levels" { + let document = exonerate_text_test_parse(exonerate_text_test_multi_report()) + assert_eq(document.num_queries(), 2) + assert_eq(document.num_hits(), 3) + assert_eq(document.num_hsps(), 4) + assert_eq(document.queries[0].hits.length(), 2) + assert_eq(document.queries[0].hits[0].hsps.length(), 2) + assert_eq(document.best_hsp().unwrap().score, 30) +} + +///| +test "Bio.SearchIO.ExonerateIO text returns defensive hit copies" { + let document = exonerate_text_test_parse(exonerate_text_test_multi_report()) + let hit = document.queries[0].find_hit("target1").unwrap() + hit.hsps.clear() + assert_eq(document.queries[0].hits[0].hsps.length(), 2) +} + +///| +test "Bio.SearchIO.ExonerateIO text bundled example parses offline" { + let document = exonerate_text_test_parse(@src.exonerate_text_example()) + assert_eq(document.num_queries(), 1) + assert_eq(document.num_hsps(), 1) + assert_eq(document.queries[0].hits[0].hsps[0].num_fragments(), 2) +} + +///| +test "Bio.SearchIO.ExonerateIO text supports no-result reports" { + let document = exonerate_text_test_parse( + "Command line: [exonerate query.fa target.fa]\n" + + "Hostname: [none]\n\n" + + "-- completed exonerate analysis\n", + ) + assert_eq(document.num_queries(), 0) + assert_eq(document.num_hits(), 0) + assert_eq(document.best_hsp(), None) +} + +///| +test "Bio.SearchIO.ExonerateIO text supports CRLF" { + let text = exonerate_text_test_dna_report().replace_all(old="\n", new="\r\n") + assert_eq(exonerate_text_test_parse(text).num_hsps(), 1) +} + +///| +test "Bio.SearchIO.ExonerateIO text returns defensive query copies" { + let document = exonerate_text_test_parse(exonerate_text_test_dna_report()) + let copy = document.find_query("query1").unwrap() + copy.hits.clear() + assert_eq(document.queries[0].hits.length(), 1) +} + +///| +test "Bio.SearchIO.ExonerateIO text returns defensive best-HSP copies" { + let document = exonerate_text_test_parse(exonerate_text_test_dna_report()) + let copy = document.best_hsp().unwrap() + copy.fragments.clear() + assert_eq(document.queries[0].hits[0].hsps[0].fragments.length(), 1) +} + +///| +test "Bio.SearchIO.ExonerateIO text summarizes report shape" { + let summary = exonerate_text_test_parse(exonerate_text_test_dna_report()).summary() + assert_true(summary.contains("queries=1")) + assert_true(summary.contains("hits=1")) + assert_true(summary.contains("hsps=1")) +} + +///| +test "Bio.SearchIO.ExonerateIO text rejects missing metadata" { + assert_true(exonerate_text_test_rejects("-- completed exonerate analysis\n")) +} + +///| +test "Bio.SearchIO.ExonerateIO text rejects unfinished reports" { + assert_true( + exonerate_text_test_rejects( + exonerate_text_test_dna_report().replace_all( + old="-- completed exonerate analysis", + new="", + ), + ), + ) +} + +///| +test "Bio.SearchIO.ExonerateIO text rejects incomplete C4 headers" { + assert_true( + exonerate_text_test_rejects( + exonerate_text_test_dna_report().replace_all( + old=" Model: affine:local:dna2dna\n", + new="", + ), + ), + ) +} + +///| +test "Bio.SearchIO.ExonerateIO text rejects malformed ranges" { + assert_true( + exonerate_text_test_rejects( + exonerate_text_test_dna_report().replace_all(old="0 -> 6", new="0 to 6"), + ), + ) +} + +///| +test "Bio.SearchIO.ExonerateIO text rejects inconsistent range spans" { + assert_true( + exonerate_text_test_rejects( + exonerate_text_test_dna_report().replace_all(old="0 -> 6", new="0 -> 7"), + ), + ) +} + +///| +test "Bio.SearchIO.ExonerateIO text rejects reverse orientation mismatch" { + assert_true( + exonerate_text_test_rejects( + exonerate_text_test_reverse_report().replace_all( + old="200 -> 193", + new="193 -> 200", + ), + ), + ) +} + +///| +test "Bio.SearchIO.ExonerateIO text rejects truncated physical rows" { + assert_true( + exonerate_text_test_rejects( + exonerate_text_test_dna_report().replace_all( + old=" |||| ||\n", + new=" |||\n", + ), + ), + ) +} diff --git a/test/moonbit/paml_baseml_test.mbt b/test/moonbit/paml_baseml_test.mbt new file mode 100644 index 00000000..81423bc8 --- /dev/null +++ b/test/moonbit/paml_baseml_test.mbt @@ -0,0 +1,691 @@ +///| +fn baseml_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "BASEML value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn baseml_test_expect_control_error(text : String) -> Unit { + let raised = try { + ignore(@src.baseml_parse_control(text)) + false + } catch { + @src.BasemlError(_) => true + } + if !raised { + abort("expected BasemlError") + } +} + +///| +fn baseml_test_expect_result_error(text : String) -> Unit { + let raised = try { + ignore(@src.baseml_parse_results(text)) + false + } catch { + @src.BasemlError(_) => true + } + if !raised { + abort("expected BasemlError") + } +} + +///| +fn baseml_test_minimal_result() -> String { + "BASEML (in paml version 4.1, August 2008) alignment.phy K80\n" + + "lnL(ntime: 1 np: 2): -12.5 +0.0\n" + + "0.1 2.5\n" + + "tree length = 0.25\n" + + "(A:0.10,B:0.15);\n" +} + +///| +fn baseml_test_kappa_result() -> String { + baseml_test_minimal_result() + + "Parameters (kappa) in the rate matrix (TN93):\n" + + "3.25 0.75\n" +} + +///| +fn baseml_test_branch_result() -> String { + baseml_test_minimal_result() + + "Parameters (kappa) in the rate matrix (F84):\n" + + "1..2 0.10 2.50 3.50 1.25\n" + + "2..3 0.20 4.50 5.50 2.25\n" +} + +///| +fn baseml_test_auto_gamma_result() -> String { + baseml_test_minimal_result() + + "Parameters (kappa) in the rate matrix (K80):\n" + + "2.5\n" + + "alpha (gamma, K=2) = 0.25\n" + + "rate: 0.5 1.5\n" + + "freq: 0.4 0.6\n" + + "rho for the auto-discrete-gamma model: 0.9\n" + + "transition probabilities between rate categories:\n" + + "0.8 0.2\n" + + "0.1 0.9\n" +} + +///| +fn baseml_test_node_result() -> String { + baseml_test_minimal_result() + + "(frequency parameters for branches) [frequencies at nodes]\n" + + "Node #1 ( 0.10 0.20 0.30 0.40 )\n" + + "Node #2 ( 0.11 0.21 0.31 0.37 0.25 0.25 0.30 0.20 )\n" + + "Note: node 2 is root.\n" +} + +///| +fn baseml_test_old_frequency_result() -> String { + baseml_test_minimal_result() + + "base frequency parameters\n" + + "0.20 0.30 0.10 0.40\n" +} + +///| +fn baseml_test_null_result() -> String { + "BASEML (in paml version 4.7, January 2013) alignment.phy JC69\n" + + "lnL(ntime: 1 np: 2): -105.0 +0.0\n" + + "0.1 0.2\n" + + "tree length = 0.2\n" + + "(A:0.1,B:0.1);\n" +} + +///| +fn baseml_test_alternative_result() -> String { + "BASEML (in paml version 4.7, January 2013) alignment.phy HKY85\n" + + "lnL(ntime: 1 np: 4): -100.0 +0.0\n" + + "0.1 0.2 0.3 0.4\n" + + "tree length = 0.2\n" + + "(A:0.1,B:0.1);\n" +} + +///| +test "baseml control parses required paths" { + let control = @src.baseml_parse_control(@src.baseml_example_control_text()) + assert_eq(control.sequence_file(), "alignment.phylip") + assert_eq(control.output_file(), "baseml.out") + assert_eq(control.tree_file(), "species.tree") +} + +///| +test "baseml control parses all official options" { + let control = @src.baseml_parse_control(@src.baseml_example_control_text()) + assert_eq(control.options().length(), 21) + assert_eq(control.option("runmode"), Some("0")) + assert_eq(control.option("Small_Diff"), Some("0.000007")) +} + +///| +test "baseml control exposes model number" { + let control = @src.baseml_parse_control(@src.baseml_example_control_text()) + assert_eq(control.model_number(), Some(7)) + assert_eq(control.model_options(), "") +} + +///| +test "baseml control parses model 9 options" { + let control = @src.baseml_parse_control( + "seqfile=a\noutfile=b\ntreefile=c\nmodel=9 [1 (TC CT AG GA)]\n", + ) + assert_eq(control.model_number(), Some(9)) + assert_eq(control.model_options(), "[1 (TC CT AG GA)]") +} + +///| +test "baseml control parses model 10 options" { + let control = @src.baseml_parse_control( + "seqfile=a\noutfile=b\ntreefile=c\nmodel=10 [5 (AC CA) (AG GA)]\n", + ) + assert_eq(control.model_number(), Some(10)) + assert_eq(control.model_options(), "[5 (AC CA) (AG GA)]") +} + +///| +test "baseml control strips comments and CRLF" { + let control = @src.baseml_parse_control( + "seqfile = a.phy * alignment\r\noutfile = out\r\ntreefile = t.nwk\r\nmodel = 6 * TN93\r\n", + ) + assert_eq(control.sequence_file(), "a.phy") + assert_eq(control.option("model"), Some("6")) +} + +///| +test "baseml control canonical round trip" { + let first = @src.baseml_parse_control(@src.baseml_example_control_text()) + let written = @src.baseml_write_control(first) + let second = @src.baseml_parse_control(written) + assert_eq(first, second) + assert_true(written.has_prefix("seqfile = alignment.phylip\n")) +} + +///| +test "baseml control preserves option order" { + let control = @src.baseml_parse_control( + "seqfile=a\noutfile=b\ntreefile=c\nalpha=0.5\nmodel=4\n", + ) + let options = control.options() + assert_eq(options[0].name(), "alpha") + assert_eq(options[1].name(), "model") +} + +///| +test "baseml control options are defensive copies" { + let control = @src.baseml_parse_control(@src.baseml_example_control_text()) + let options = control.options() + ignore(options.pop()) + assert_eq(control.options().length(), 21) +} + +///| +test "baseml maps all model names" { + let names : Array[String] = [] + for model in 0..<=10 { + names.push(@src.baseml_model_name(model)) + } + assert_eq(names, [ + "JC69", "K80", "F81", "F84", "HKY85", "T92", "TN93", "REV", "UNREST", "REVu", + "UNRESTu", + ]) +} + +///| +test "baseml control rejects missing seqfile" { + baseml_test_expect_control_error("outfile=b\ntreefile=c\n") +} + +///| +test "baseml control rejects missing outfile" { + baseml_test_expect_control_error("seqfile=a\ntreefile=c\n") +} + +///| +test "baseml control rejects missing treefile" { + baseml_test_expect_control_error("seqfile=a\noutfile=b\n") +} + +///| +test "baseml control rejects malformed lines" { + baseml_test_expect_control_error( + "seqfile=a\noutfile=b\ntreefile=c\nmodel 7\n", + ) +} + +///| +test "baseml control rejects multiple equals signs" { + baseml_test_expect_control_error( + "seqfile=a\noutfile=b\ntreefile=c\nmodel=7=8\n", + ) +} + +///| +test "baseml control rejects duplicate keys" { + baseml_test_expect_control_error( + "seqfile=a\noutfile=b\ntreefile=c\nmodel=7\nmodel=8\n", + ) +} + +///| +test "baseml control rejects unknown options" { + baseml_test_expect_control_error( + "seqfile=a\noutfile=b\ntreefile=c\nunknown=1\n", + ) +} + +///| +test "baseml control rejects empty values" { + baseml_test_expect_control_error("seqfile=a\noutfile=b\ntreefile=c\nmodel=\n") +} + +///| +test "baseml control rejects invalid integers" { + baseml_test_expect_control_error( + "seqfile=a\noutfile=b\ntreefile=c\nncatG=five\n", + ) +} + +///| +test "baseml control rejects invalid doubles" { + baseml_test_expect_control_error( + "seqfile=a\noutfile=b\ntreefile=c\nalpha=fast\n", + ) +} + +///| +test "baseml control rejects unsupported model" { + baseml_test_expect_control_error( + "seqfile=a\noutfile=b\ntreefile=c\nmodel=11\n", + ) +} + +///| +test "baseml control rejects options on standard model" { + baseml_test_expect_control_error( + "seqfile=a\noutfile=b\ntreefile=c\nmodel=8 [custom]\n", + ) +} + +///| +test "baseml control rejects non-positive ncatG" { + baseml_test_expect_control_error( + "seqfile=a\noutfile=b\ntreefile=c\nncatG=0\n", + ) +} + +///| +test "baseml control rejects invalid nparK" { + baseml_test_expect_control_error( + "seqfile=a\noutfile=b\ntreefile=c\nnparK=5\n", + ) +} + +///| +test "baseml control rejects invalid nhomo" { + baseml_test_expect_control_error( + "seqfile=a\noutfile=b\ntreefile=c\nnhomo=-1\n", + ) +} + +///| +test "baseml control rejects invalid binary option" { + baseml_test_expect_control_error( + "seqfile=a\noutfile=b\ntreefile=c\ngetSE=2\n", + ) +} + +///| +test "baseml model name rejects out of range value" { + let raised = try { + ignore(@src.baseml_model_name(-1)) + false + } catch { + @src.BasemlError(_) => true + } + assert_true(raised) +} + +///| +test "baseml result parses version and model description" { + let result = @src.baseml_parse_results(@src.baseml_example_results_text()) + assert_eq(result.version(), "4.7") + assert_eq(result.model_description(), "REV dGamma (ncatG=5)") +} + +///| +test "baseml result parses likelihoods" { + let result = @src.baseml_parse_results(@src.baseml_example_results_text()) + baseml_test_close(result.ln_likelihood(), -319.774741, 1.0e-9) + match result.ln_l_max() { + Some(value) => baseml_test_close(value, -316.049385, 1.0e-9) + None => abort("missing ln Lmax") + } +} + +///| +test "baseml result parses parameter vector" { + let result = @src.baseml_parse_results(@src.baseml_example_results_text()) + assert_eq(result.parameter_count(), 13) + assert_eq(result.parameter_list().length(), 13) + baseml_test_close(result.parameter_list()[7], 998.99998, 1.0e-8) +} + +///| +test "baseml result parses standard errors" { + let result = @src.baseml_parse_results(@src.baseml_example_results_text()) + assert_eq(result.standard_errors().length(), 13) + baseml_test_close(result.standard_errors()[12], 4.0, 1.0e-12) +} + +///| +test "baseml result parses tree" { + let result = @src.baseml_parse_results(@src.baseml_example_results_text()) + baseml_test_close(result.tree_length(), 0.01826, 1.0e-12) + assert_true(result.tree().has_prefix("(((Homo_sapie:")) +} + +///| +test "baseml result parses REV rate parameters" { + let result = @src.baseml_parse_results(@src.baseml_example_results_text()) + assert_eq(result.rate_parameters().length(), 5) + baseml_test_close(result.rate_parameters()[1], 130.94908, 1.0e-8) +} + +///| +test "baseml result parses base frequencies" { + let result = @src.baseml_parse_results(@src.baseml_example_results_text()) + match result.base_frequencies() { + Some(frequencies) => { + baseml_test_close(frequencies.thymine(), 0.20090, 1.0e-12) + baseml_test_close(frequencies.cytosine(), 0.16306, 1.0e-12) + baseml_test_close(frequencies.adenine(), 0.37027, 1.0e-12) + baseml_test_close(frequencies.guanine(), 0.26577, 1.0e-12) + } + None => abort("missing base frequencies") + } +} + +///| +test "baseml result parses Q matrix" { + let result = @src.baseml_parse_results(@src.baseml_example_results_text()) + match result.q_matrix() { + Some(matrix) => { + assert_eq(matrix.rows().length(), 4) + assert_eq(matrix.rows()[0].length(), 4) + baseml_test_close(matrix.rows()[2][3], 0.003044, 1.0e-12) + match matrix.average_ts_tv() { + Some(value) => baseml_test_close(value, 3.3698, 1.0e-12) + None => abort("missing average Ts/Tv") + } + } + None => abort("missing Q matrix") + } +} + +///| +test "baseml result parses gamma rates" { + let result = @src.baseml_parse_results(@src.baseml_example_results_text()) + match result.alpha() { + Some(value) => baseml_test_close(value, 200.95753, 1.0e-8) + None => abort("missing alpha") + } + assert_eq(result.rates().length(), 5) + assert_eq(result.rate_frequencies(), [0.2, 0.2, 0.2, 0.2, 0.2]) +} + +///| +test "baseml result parses scalar and multiple kappas" { + let result = @src.baseml_parse_results(baseml_test_kappa_result()) + assert_eq(result.kappas(), [3.25, 0.75]) +} + +///| +test "baseml result parses branch-specific kappas" { + let result = @src.baseml_parse_results(baseml_test_branch_result()) + let branches = result.branch_parameters() + assert_eq(branches.length(), 2) + assert_eq(branches[0].branch(), "1..2") + baseml_test_close(branches[0].time(), 0.10, 1.0e-12) + baseml_test_close(branches[0].kappa(), 2.50, 1.0e-12) + baseml_test_close(branches[0].transitions(), 3.50, 1.0e-12) + baseml_test_close(branches[0].transversions(), 1.25, 1.0e-12) +} + +///| +test "baseml result parses auto discrete gamma" { + let result = @src.baseml_parse_results(baseml_test_auto_gamma_result()) + match result.rho() { + Some(value) => baseml_test_close(value, 0.9, 1.0e-12) + None => abort("missing rho") + } + assert_eq(result.rates(), [0.5, 1.5]) + assert_eq(result.rate_frequencies(), [0.4, 0.6]) + assert_eq(result.transition_probabilities().length(), 2) + baseml_test_close(result.transition_probabilities()[1][1], 0.9, 1.0e-12) +} + +///| +test "baseml result parses nonhomogeneous nodes" { + let result = @src.baseml_parse_results(baseml_test_node_result()) + let nodes = result.nodes() + assert_eq(nodes.length(), 2) + assert_eq(nodes[0].node(), 1) + assert_false(nodes[0].is_root()) + assert_true(nodes[1].is_root()) + assert_eq(nodes[0].frequency_parameters(), [0.1, 0.2, 0.3, 0.4]) +} + +///| +test "baseml result parses realized node base frequencies" { + let result = @src.baseml_parse_results(baseml_test_node_result()) + match result.nodes()[1].base_frequencies() { + Some(frequencies) => { + baseml_test_close(frequencies.thymine(), 0.25, 1.0e-12) + baseml_test_close(frequencies.guanine(), 0.20, 1.0e-12) + } + None => abort("missing node base frequencies") + } +} + +///| +test "baseml result parses PAML 4.1 base frequency heading" { + let result = @src.baseml_parse_results(baseml_test_old_frequency_result()) + match result.base_frequencies() { + Some(frequencies) => + baseml_test_close(frequencies.cytosine(), 0.30, 1.0e-12) + None => abort("missing old-style base frequencies") + } +} + +///| +test "baseml result arrays are defensive copies" { + let result = @src.baseml_parse_results(@src.baseml_example_results_text()) + let parameters = result.parameter_list() + parameters[0] = 999.0 + let rates = result.rates() + ignore(rates.pop()) + baseml_test_close(result.parameter_list()[0], 0.000004, 1.0e-12) + assert_eq(result.rates().length(), 5) +} + +///| +test "baseml Q matrix rows are defensive copies" { + let result = @src.baseml_parse_results(@src.baseml_example_results_text()) + match result.q_matrix() { + Some(matrix) => { + let rows = matrix.rows() + rows[0][0] = 100.0 + match result.q_matrix() { + Some(again) => baseml_test_close(again.rows()[0][0], -2.483179, 1.0e-12) + None => abort("missing copied Q matrix") + } + } + None => abort("missing Q matrix") + } +} + +///| +test "baseml node arrays are defensive copies" { + let result = @src.baseml_parse_results(baseml_test_node_result()) + let nodes = result.nodes() + let parameters = nodes[0].frequency_parameters() + parameters[0] = 9.0 + baseml_test_close(result.nodes()[0].frequency_parameters()[0], 0.1, 1.0e-12) +} + +///| +test "baseml result rejects empty input" { + baseml_test_expect_result_error("") +} + +///| +test "baseml result rejects missing header" { + baseml_test_expect_result_error( + "lnL(ntime: 1 np: 1): -1\n0.1\ntree length = 0.1\n(A:0.1);\n", + ) +} + +///| +test "baseml result rejects missing likelihood" { + baseml_test_expect_result_error( + "BASEML (in paml version 4.7, January 2013) a.phy JC69\n", + ) +} + +///| +test "baseml result rejects malformed likelihood" { + baseml_test_expect_result_error( + "BASEML (in paml version 4.7, January 2013) a.phy JC69\n" + + "lnL(ntime: 1 np: x): bad\n", + ) +} + +///| +test "baseml result rejects parameter vector mismatch" { + baseml_test_expect_result_error( + "BASEML (in paml version 4.7, January 2013) a.phy JC69\n" + + "lnL(ntime: 1 np: 2): -1\n" + + "0.1\n" + + "tree length = 0.1\n" + + "(A:0.1);\n", + ) +} + +///| +test "baseml result rejects standard error mismatch" { + baseml_test_expect_result_error( + baseml_test_minimal_result() + "SEs for parameters:\n0.1\n", + ) +} + +///| +test "baseml result rejects missing tree length" { + baseml_test_expect_result_error( + "BASEML (in paml version 4.7, January 2013) a.phy JC69\n" + + "lnL(ntime: 1 np: 1): -1\n" + + "0.1\n" + + "(A:0.1);\n", + ) +} + +///| +test "baseml result rejects missing branch-length tree" { + baseml_test_expect_result_error( + "BASEML (in paml version 4.7, January 2013) a.phy JC69\n" + + "lnL(ntime: 1 np: 1): -1\n" + + "0.1\n" + + "tree length = 0.1\n" + + "(A,B);\n", + ) +} + +///| +test "baseml result rejects incomplete Q matrix" { + baseml_test_expect_result_error( + baseml_test_minimal_result() + + "Rate matrix Q, Average Ts/Tv = 2.0\n" + + "1.0 0.0 0.0 0.0\n", + ) +} + +///| +test "baseml result rejects transition matrix row count mismatch" { + baseml_test_expect_result_error( + baseml_test_minimal_result() + + "rate: 0.5 1.5\n" + + "transition probabilities between rate categories:\n" + + "0.8 0.2\n", + ) +} + +///| +test "baseml result rejects transition matrix column mismatch" { + baseml_test_expect_result_error( + baseml_test_minimal_result() + + "rate: 0.5 1.5\n" + + "transition probabilities between rate categories:\n" + + "0.8 0.2\n" + + "1.0\n", + ) +} + +///| +test "baseml result rejects duplicate nodes" { + baseml_test_expect_result_error( + baseml_test_minimal_result() + + "Node #1 ( 0.1 0.2 0.3 0.4 )\n" + + "Node #1 ( 0.2 0.2 0.2 0.4 )\n", + ) +} + +///| +test "baseml computes AIC" { + let result = @src.baseml_parse_results(baseml_test_null_result()) + baseml_test_close(result.aic(), 214.0, 1.0e-12) +} + +///| +test "baseml computes BIC" { + let result = @src.baseml_parse_results(baseml_test_null_result()) + baseml_test_close(result.bic(100), 2.0 * @math.ln(100.0) + 210.0, 1.0e-12) +} + +///| +test "baseml BIC rejects non-positive observations" { + let result = @src.baseml_parse_results(baseml_test_null_result()) + let raised = try { + ignore(result.bic(0)) + false + } catch { + @src.BasemlError(_) => true + } + assert_true(raised) +} + +///| +test "baseml computes nested likelihood ratio" { + let null_model = @src.baseml_parse_results(baseml_test_null_result()) + let alternative = @src.baseml_parse_results(baseml_test_alternative_result()) + let comparison = @src.baseml_likelihood_ratio(null_model, alternative) + baseml_test_close(comparison.statistic(), 10.0, 1.0e-12) + assert_eq(comparison.degrees_of_freedom(), 2) + baseml_test_close(comparison.p_value(), 0.006737946999, 1.0e-9) + assert_eq(comparison.alpha(), 0.05) + assert_true(comparison.significant()) +} + +///| +test "baseml LRT rejects reversed nesting" { + let null_model = @src.baseml_parse_results(baseml_test_null_result()) + let alternative = @src.baseml_parse_results(baseml_test_alternative_result()) + let raised = try { + ignore(@src.baseml_likelihood_ratio(alternative, null_model)) + false + } catch { + @src.BasemlError(_) => true + } + assert_true(raised) +} + +///| +test "baseml LRT rejects lower alternative likelihood" { + let null_model = @src.baseml_parse_results(baseml_test_minimal_result()) + let alternative = @src.baseml_parse_results( + "BASEML (in paml version 4.7, January 2013) a.phy HKY85\n" + + "lnL(ntime: 1 np: 3): -20.0\n" + + "0.1 0.2 0.3\n" + + "tree length = 0.2\n" + + "(A:0.1,B:0.1);\n", + ) + let raised = try { + ignore(@src.baseml_likelihood_ratio(null_model, alternative)) + false + } catch { + @src.BasemlError(_) => true + } + assert_true(raised) +} + +///| +test "baseml LRT rejects invalid alpha" { + let null_model = @src.baseml_parse_results(baseml_test_null_result()) + let alternative = @src.baseml_parse_results(baseml_test_alternative_result()) + let raised = try { + ignore(@src.baseml_likelihood_ratio(null_model, alternative, alpha=1.0)) + false + } catch { + @src.BasemlError(_) => true + } + assert_true(raised) +} diff --git a/test/moonbit/paml_codeml_test.mbt b/test/moonbit/paml_codeml_test.mbt new file mode 100644 index 00000000..080dc360 --- /dev/null +++ b/test/moonbit/paml_codeml_test.mbt @@ -0,0 +1,652 @@ +///| +fn codeml_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "CODEML value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn codeml_test_expect_control_error(text : String) -> Unit { + let raised = try { + ignore(@src.codeml_parse_control(text)) + false + } catch { + @src.CodemlError(_) => true + } + if !raised { + abort("expected CodemlError") + } +} + +///| +fn codeml_test_expect_result_error(text : String) -> Unit { + let raised = try { + ignore(@src.codeml_parse_results(text)) + false + } catch { + @src.CodemlError(_) => true + } + if !raised { + abort("expected CodemlError") + } +} + +///| +fn codeml_test_branch_site_text() -> String { + "CODONML (in paml version 4.7, January 2013) alignment.phylip\n" + + "Model: branch-site model A\n" + + "Codon frequency model: F3x4\n" + + "Site-class models: PositiveSelection\n" + + "ns = 5 ls = 74\n" + + "lnL(ntime: 7 np: 12): -308.031579 +0.000000\n" + + "0.1 0.2 0.3 0.4 0.5 0.6 0.7 1.5 0.9 0.1 0.2 2.0\n" + + "tree length = 0.05472\n" + + "((A:0.01, B:0.02):0.03, C:0.04);\n" + + "proportion 0.70000 0.10000 0.15000 0.05000\n" + + "background w 0.10000 1.00000 0.10000 1.00000\n" + + "foreground w 0.10000 1.00000 4.50000 4.50000\n" + + "Bayes Empirical Bayes (BEB) analysis\n" + + " 21 R 0.981* 3.750 +- 0.820\n" + + " 45 K 0.999** 8.250 +- 1.400\n" +} + +///| +fn codeml_test_clade_text() -> String { + "CODONML (in paml version 4.9j, February 2020) alignment.phylip\n" + + "Model: Clade model C\n" + + "Codon frequency model: F3x4\n" + + "Site-class models: PositiveSelection\n" + + "ns = 5 ls = 74\n" + + "lnL(ntime: 7 np: 13): -307.500000 +0.000000\n" + + "0.1 0.2 0.3 0.4 0.5 0.6 0.7 1.5 0.9 0.1 0.2 2.0 3.0\n" + + "proportion 0.60000 0.30000 0.10000\n" + + "branch type 0: 0.10000 1.00000 2.50000\n" + + "branch type 1: 0.20000 1.00000 4.00000\n" +} + +///| +fn codeml_test_free_ratio_text() -> String { + "CODONML (in paml version 4.7, January 2013) alignment.phylip\n" + + "Model: free ratios for branches\n" + + "Codon frequency model: F3x4\n" + + "ns = 3 ls = 90\n" + + "lnL(ntime: 4 np: 8): -120.500000 +0.000000\n" + + "0.1 0.2 0.3 0.4 1.1 0.8 0.4 0.2\n" + + "tree length = 0.12000\n" + + "((A:0.01, B:0.02):0.03, C:0.04);\n" + + "kappa (ts/tv) = 2.10000\n" + + "w (dN/dS) for branches: 1.10000 0.80000 0.40000 0.20000\n" + + " 4..5 0.010 100.0 50.0 1.1000 0.0050 0.0045 0.5 0.2\n" + + " 5..1 0.020 100.0 50.0 0.8000 0.0040 0.0050 0.4 0.3\n" + + "dS tree:\n" + + "((A:0.004, B:0.005):0.006, C:0.007);\n" + + "dN tree:\n" + + "((A:0.005, B:0.004):0.003, C:0.002);\n" + + "w ratios as labels for TreeView:\n" + + "((A #1.1, B #0.8) #0.4, C #0.2);\n" +} + +///| +fn codeml_test_pairwise_text() -> String { + "CODONML (in paml version 4.7, January 2013) alignment.phylip\n" + + "Model: One dN/dS ratio for branches,\n" + + "Codon frequency model: F3x4\n" + + "ns = 3 ls = 74\n" + + "2 (Pan_troglo) ... 1 (Homo_sapie)\n" + + "lnL = -291.465693\n" + + "0.01262 999.00000 0.00100\n" + + "t= 0.0126 S=81.4 N=140.6 dN/dS=0.0010 dN=0.0000 dS=0.0115\n" + + "3 (Gorilla_go) ... 1 (Homo_sapie)\n" + + "lnL = -290.441129\n" + + "0.01265 999.00000 0.00100\n" + + "t=0.0127 S=81.7 N=140.3 dN/dS=0.0010 dN=0.0000 dS=0.0114\n" + + "3 (Gorilla_go) ... 2 (Pan_troglo)\n" + + "lnL = -296.416525\n" + + "0.02582 999.00000 0.00100\n" + + "t=0.0258 S=81.5 N=140.5 dN/dS=0.0010 dN=0.0000 dS=0.0234\n" +} + +///| +fn codeml_test_aaml_text() -> String { + "AAML (in paml version 4.7, January 2013) aa_alignment.phylip\n" + + "Model: Poisson for branches, ns = 3 ls = 74\n" + + "ln Lmax (unconstrained) = -192.057157\n" + + "AA distances (raw proportions of different sites)\n" + + "Human\n" + + "Chimp 0.0100\n" + + "Gorilla 0.0200 0.0300\n" + + "\n" + + "ML distances of aa seqs.\n" + + "Human\n" + + "Chimp 0.0110\n" + + "Gorilla 0.0220 0.0330\n" + + "\n" +} + +///| +fn codeml_test_se_text() -> String { + "CODONML (in paml version 4.6, August 2010) alignment.phylip\n" + + "Model: one-ratio\n" + + "Codon frequency model: F3x4\n" + + "ns = 3 ls = 60\n" + + "lnL(ntime: 4 np: 6): -100.000000 +0.000000\n" + + "0.1 0.2 0.3 0.4 2.0 0.5\n" + + "SEs for parameters:\n" + + "0.01 0.02 0.03 0.04 0.20 0.05\n" +} + +///| +fn codeml_test_multigene_text() -> String { + "CODONML (in paml version 4.7, January 2013) genes.phylip\n" + + "Model: One dN/dS ratio for branches, (2 genes: separate data)\n" + + "Codon frequency model: F3x4\n" + + "Site-class models: one-ratio\n" + + "ns = 4 ls = 120\n" + + "Gene 1\n" + + "lnL(ntime: 3 np: 5): -80.000000 +0.000000\n" + + "0.1 0.2 0.3 2.0 0.4\n" + + "tree length = 0.10\n" + + "Gene 2\n" + + "lnL(ntime: 3 np: 5): -90.000000 +0.000000\n" + + "0.1 0.2 0.3 2.1 0.5\n" + + "tree length = 0.20\n" +} + +///| +fn codeml_test_joint_gene_text() -> String { + "CODONML (in paml version 4.7, January 2013) genes.phylip\n" + + "Model: One dN/dS ratio for branches, (2 genes: joint data)\n" + + "Codon frequency model: F3x4\n" + + "ns = 4 ls = 120\n" + + "lnL(ntime: 7 np: 10): -170.000000 +0.000000\n" + + "0.1 0.2 0.3 0.4 0.5 0.6 2.0 0.3 1.0 2.5\n" + + "rates for 2 genes: 1 2.50000\n" + + "gene # 1: kappa = 1.70000 omega = 0.30000\n" + + "gene # 2: kappa = 1.90000 omega = 1.20000\n" +} + +///| +test "codeml control parses required paths" { + let control = @src.codeml_parse_control(@src.codeml_example_control_text()) + assert_eq(control.sequence_file(), "alignment.phylip") + assert_eq(control.output_file(), "codeml.out") + assert_eq(control.tree_file(), "species.tree") +} + +///| +test "codeml control parses options" { + let control = @src.codeml_parse_control(@src.codeml_example_control_text()) + assert_eq(control.option("CodonFreq"), Some("2")) + assert_eq(control.option("missing"), None) +} + +///| +test "codeml control parses NSsites integer list" { + let control = @src.codeml_parse_control(@src.codeml_example_control_text()) + assert_eq(control.ns_sites(), [0, 1, 2]) +} + +///| +test "codeml control strips star comments" { + let control = @src.codeml_parse_control( + "seqfile=a.phy * alignment\noutfile=x.out\ntreefile=t.tree\nomega=1 * start\n", + ) + assert_eq(control.sequence_file(), "a.phy") + assert_eq(control.option("omega"), Some("1")) +} + +///| +test "codeml control accepts CRLF" { + let control = @src.codeml_parse_control( + "seqfile=a.phy\r\noutfile=x.out\r\ntreefile=t.tree\r\nrunmode=-2\r\n", + ) + assert_eq(control.option("runmode"), Some("-2")) +} + +///| +test "codeml control canonical round trip" { + let control = @src.codeml_parse_control(@src.codeml_example_control_text()) + let written = @src.codeml_write_control(control) + let reparsed = @src.codeml_parse_control(written) + assert_eq(reparsed, control) +} + +///| +test "codeml control preserves option order" { + let control = @src.codeml_parse_control( + "seqfile=a\noutfile=b\ntreefile=c\nomega=1\nkappa=2\nmodel=0\n", + ) + let options = control.options() + assert_eq(options[0].name(), "omega") + assert_eq(options[1].name(), "kappa") + assert_eq(options[2].name(), "model") +} + +///| +test "codeml control option accessor is defensive" { + let control = @src.codeml_parse_control(@src.codeml_example_control_text()) + let options = control.options() + options[0] = options[1] + assert_eq(control.options()[0].name(), "verbose") +} + +///| +test "codeml control rejects missing seqfile" { + codeml_test_expect_control_error("outfile=x\ntreefile=t\n") +} + +///| +test "codeml control rejects missing outfile" { + codeml_test_expect_control_error("seqfile=a\ntreefile=t\n") +} + +///| +test "codeml control rejects missing treefile" { + codeml_test_expect_control_error("seqfile=a\noutfile=x\n") +} + +///| +test "codeml control rejects malformed line" { + codeml_test_expect_control_error( + "seqfile=a\noutfile=x\ntreefile=t\nmodel 0\n", + ) +} + +///| +test "codeml control rejects unknown option" { + codeml_test_expect_control_error( + "seqfile=a\noutfile=x\ntreefile=t\nunknown=1\n", + ) +} + +///| +test "codeml control rejects duplicate path" { + codeml_test_expect_control_error( + "seqfile=a\nseqfile=b\noutfile=x\ntreefile=t\n", + ) +} + +///| +test "codeml control rejects duplicate option" { + codeml_test_expect_control_error( + "seqfile=a\noutfile=x\ntreefile=t\nomega=1\nomega=2\n", + ) +} + +///| +test "codeml control rejects invalid integer" { + codeml_test_expect_control_error( + "seqfile=a\noutfile=x\ntreefile=t\nmodel=zero\n", + ) +} + +///| +test "codeml control rejects invalid double" { + codeml_test_expect_control_error( + "seqfile=a\noutfile=x\ntreefile=t\nomega=one\n", + ) +} + +///| +test "codeml control rejects negative NSsites" { + codeml_test_expect_control_error( + "seqfile=a\noutfile=x\ntreefile=t\nNSsites=0 -1\n", + ) +} + +///| +test "codeml results parse header metadata" { + let results = @src.codeml_parse_results(@src.codeml_example_results_text()) + assert_eq(results.program(), "CODONML") + assert_eq(results.version(), "4.7") + assert_eq(results.codon_frequency_model(), "F3x4") + assert_eq(results.sequence_count(), 5) + assert_eq(results.site_count(), 74) +} + +///| +test "codeml results parse multiple NSsites models" { + let results = @src.codeml_parse_results(@src.codeml_example_results_text()) + assert_eq(results.models().length(), 2) + assert_eq(results.models()[0].number(), 0) + assert_eq(results.models()[1].number(), 2) +} + +///| +test "codeml model parses likelihood and parameter count" { + let model = @src.codeml_parse_results(@src.codeml_example_results_text()).models()[0] + codeml_test_close(model.ln_likelihood(), -308.032865, 1.0e-9) + assert_eq(model.parameter_count(), 9) + assert_true(model.parameter_list().length() > 0) +} + +///| +test "codeml model parses tree and length" { + let model = @src.codeml_parse_results(@src.codeml_example_results_text()).models()[0] + codeml_test_close(model.tree_length().unwrap(), 0.05472, 1.0e-10) + assert_true(model.tree().length() > 20) +} + +///| +test "codeml model parses kappa and omega" { + let model = @src.codeml_parse_results(@src.codeml_example_results_text()).models()[0] + codeml_test_close(model.kappa().unwrap(), 1.51919, 1.0e-10) + codeml_test_close(model.omegas()[0], 0.00010, 1.0e-10) +} + +///| +test "codeml model parses branch table" { + let model = @src.codeml_parse_results(@src.codeml_example_results_text()).models()[0] + assert_eq(model.branches().length(), 2) + assert_eq(model.branches()[1].branch(), "8..2") + codeml_test_close(model.branches()[1].ds().unwrap(), 0.0183, 1.0e-10) +} + +///| +test "codeml model parses dN and dS tree lengths" { + let model = @src.codeml_parse_results(@src.codeml_example_results_text()).models()[0] + codeml_test_close(model.dn_tree_length().unwrap(), 0.0, 1.0e-12) + codeml_test_close(model.ds_tree_length().unwrap(), 0.0746, 1.0e-10) +} + +///| +test "codeml model parses site classes" { + let model = @src.codeml_parse_results(@src.codeml_example_results_text()).models()[1] + assert_eq(model.site_classes().length(), 3) + codeml_test_close(model.site_classes()[2].proportion(), 0.02, 1.0e-10) + codeml_test_close(model.site_classes()[2].omega().unwrap(), 5.0, 1.0e-10) +} + +///| +test "codeml model parses BEB positive site" { + let model = @src.codeml_parse_results(@src.codeml_example_results_text()).models()[1] + let sites = model.positive_sites() + assert_eq(sites.length(), 1) + assert_eq(sites[0].analysis_method(), "BEB") + assert_eq(sites[0].position(), 42) + assert_eq(sites[0].amino_acid(), "K") + assert_eq(sites[0].significance(), "**") + codeml_test_close(sites[0].probability(), 0.997, 1.0e-10) + codeml_test_close(sites[0].posterior_mean_omega().unwrap(), 5.2, 1.0e-10) +} + +///| +test "codeml model lookup finds requested NSsites class" { + let results = @src.codeml_parse_results(@src.codeml_example_results_text()) + assert_eq(results.model_by_number(2).unwrap().number(), 2) + assert_eq(results.model_by_number(8), None) +} + +///| +test "codeml result model accessor is deeply defensive" { + let results = @src.codeml_parse_results(@src.codeml_example_results_text()) + let models = results.models() + let classes = models[1].site_classes() + classes[0] = classes[1] + assert_eq(results.models()[1].site_classes()[0].index(), 0) +} + +///| +test "codeml branch-site A parses four classes" { + let model = @src.codeml_parse_results(codeml_test_branch_site_text()).models()[0] + assert_eq(model.number(), 2) + assert_eq(model.site_classes().length(), 4) +} + +///| +test "codeml branch-site A parses foreground and background omega" { + let classes = @src.codeml_parse_results(codeml_test_branch_site_text()).models()[0].site_classes() + assert_eq(classes[2].branch_types().length(), 2) + assert_eq(classes[2].branch_types()[0].name(), "background") + codeml_test_close(classes[2].branch_types()[1].value(), 4.5, 1.0e-10) +} + +///| +test "codeml branch-site A parses multiple selected sites" { + let sites = @src.codeml_parse_results(codeml_test_branch_site_text()).models()[0].positive_sites() + assert_eq(sites.length(), 2) + assert_eq(sites[0].significance(), "*") + assert_eq(sites[1].significance(), "**") +} + +///| +test "codeml clade model C parses branch types" { + let classes = @src.codeml_parse_results(codeml_test_clade_text()).models()[0].site_classes() + assert_eq(classes.length(), 3) + assert_eq(classes[0].branch_types()[0].name(), "0") + assert_eq(classes[0].branch_types()[1].name(), "1") + codeml_test_close(classes[2].branch_types()[1].value(), 4.0, 1.0e-10) +} + +///| +test "codeml free-ratio parses branch omegas" { + let model = @src.codeml_parse_results(codeml_test_free_ratio_text()).models()[0] + assert_eq(model.omegas().length(), 4) + codeml_test_close(model.omegas()[0], 1.1, 1.0e-10) +} + +///| +test "codeml free-ratio parses specialized trees" { + let model = @src.codeml_parse_results(codeml_test_free_ratio_text()).models()[0] + assert_true(model.dn_tree().length() > 0) + assert_true(model.ds_tree().length() > 0) + assert_true(model.omega_tree().length() > 0) +} + +///| +test "codeml free-ratio parses branch rows" { + let branches = @src.codeml_parse_results(codeml_test_free_ratio_text()).models()[0].branches() + assert_eq(branches.length(), 2) + codeml_test_close(branches[0].omega().unwrap(), 1.1, 1.0e-10) +} + +///| +test "codeml pairwise parses all unordered comparisons" { + let pairwise = @src.codeml_parse_results(codeml_test_pairwise_text()).pairwise() + assert_eq(pairwise.length(), 3) + assert_eq(pairwise[0].first(), "Pan_troglo") + assert_eq(pairwise[0].second(), "Homo_sapie") +} + +///| +test "codeml pairwise parses likelihood" { + let pair = @src.codeml_parse_results(codeml_test_pairwise_text()).pairwise()[0] + codeml_test_close(pair.ln_likelihood(), -291.465693, 1.0e-9) +} + +///| +test "codeml pairwise parses site counts and rates" { + let pair = @src.codeml_parse_results(codeml_test_pairwise_text()).pairwise()[0] + codeml_test_close(pair.time(), 0.0126, 1.0e-10) + codeml_test_close(pair.synonymous_sites(), 81.4, 1.0e-10) + codeml_test_close(pair.nonsynonymous_sites(), 140.6, 1.0e-10) + codeml_test_close(pair.omega(), 0.001, 1.0e-10) + codeml_test_close(pair.dn(), 0.0, 1.0e-10) + codeml_test_close(pair.ds(), 0.0115, 1.0e-10) +} + +///| +test "codeml AAML parses program and unconstrained likelihood" { + let results = @src.codeml_parse_results(codeml_test_aaml_text()) + assert_eq(results.program(), "AAML") + codeml_test_close(results.ln_l_max().unwrap(), -192.057157, 1.0e-9) +} + +///| +test "codeml AAML parses raw distance triangle" { + let distances = @src.codeml_parse_results(codeml_test_aaml_text()).distances() + assert_eq(distances.length(), 6) + assert_eq(distances[0].kind(), "raw") + assert_eq(distances[0].first(), "Chimp") + assert_eq(distances[0].second(), "Human") + codeml_test_close(distances[0].value(), 0.01, 1.0e-10) +} + +///| +test "codeml AAML parses ML distance triangle" { + let distances = @src.codeml_parse_results(codeml_test_aaml_text()).distances() + assert_eq(distances[3].kind(), "ml") + codeml_test_close(distances[5].value(), 0.033, 1.0e-10) +} + +///| +test "codeml parses parameter standard errors" { + let model = @src.codeml_parse_results(codeml_test_se_text()).models()[0] + assert_true(model.standard_errors().length() > 0) + assert_eq(model.parameter_count(), 6) +} + +///| +test "codeml parses separate multi-gene sections" { + let models = @src.codeml_parse_results(codeml_test_multigene_text()).models() + assert_eq(models.length(), 2) + assert_eq(models[0].gene(), 1) + assert_eq(models[1].gene(), 2) + codeml_test_close(models[1].tree_length().unwrap(), 0.2, 1.0e-10) +} + +///| +test "codeml parses joint multi-gene relative rates" { + let model = @src.codeml_parse_results(codeml_test_joint_gene_text()).models()[0] + assert_eq(model.rates(), [1.0, 2.5]) +} + +///| +test "codeml parses joint multi-gene kappa and omega" { + let genes = @src.codeml_parse_results(codeml_test_joint_gene_text()).models()[0].gene_parameters() + assert_eq(genes.length(), 2) + assert_eq(genes[1].gene(), 2) + codeml_test_close(genes[1].kappa(), 1.9, 1.0e-10) + codeml_test_close(genes[1].omega(), 1.2, 1.0e-10) +} + +///| +test "codeml AIC matches definition" { + let model = @src.codeml_parse_results(@src.codeml_example_results_text()).models()[0] + codeml_test_close(model.aic(), 634.06573, 1.0e-6) +} + +///| +test "codeml BIC matches definition" { + let model = @src.codeml_parse_results(@src.codeml_example_results_text()).models()[0] + let expected = 9.0 * @math.ln(74.0) + 616.06573 + codeml_test_close(model.bic(74), expected, 1.0e-6) +} + +///| +test "codeml likelihood-ratio statistic and degrees" { + let models = @src.codeml_parse_results(@src.codeml_example_results_text()).models() + let comparison = @src.codeml_likelihood_ratio(models[0], models[1]) + codeml_test_close(comparison.statistic(), 12.002572, 1.0e-6) + assert_eq(comparison.degrees_of_freedom(), 3) +} + +///| +test "codeml likelihood-ratio chi-square tail" { + let models = @src.codeml_parse_results(@src.codeml_example_results_text()).models() + let comparison = @src.codeml_likelihood_ratio(models[0], models[1]) + assert_true(comparison.p_value() > 0.007) + assert_true(comparison.p_value() < 0.008) + assert_true(comparison.significant()) + codeml_test_close(comparison.alpha(), 0.05, 1.0e-12) +} + +///| +test "codeml best AIC selects improved model" { + let models = @src.codeml_parse_results(@src.codeml_example_results_text()).models() + assert_eq(@src.codeml_best_aic(models).number(), 2) +} + +///| +test "codeml BIC rejects non-positive observations" { + let model = @src.codeml_parse_results(@src.codeml_example_results_text()).models()[0] + let raised = try { + ignore(model.bic(0)) + false + } catch { + @src.CodemlError(_) => true + } + assert_true(raised) +} + +///| +test "codeml LRT rejects reversed nesting" { + let models = @src.codeml_parse_results(@src.codeml_example_results_text()).models() + let raised = try { + ignore(@src.codeml_likelihood_ratio(models[1], models[0])) + false + } catch { + @src.CodemlError(_) => true + } + assert_true(raised) +} + +///| +test "codeml LRT rejects invalid alpha" { + let models = @src.codeml_parse_results(@src.codeml_example_results_text()).models() + let raised = try { + ignore(@src.codeml_likelihood_ratio(models[0], models[1], alpha=1.0)) + false + } catch { + @src.CodemlError(_) => true + } + assert_true(raised) +} + +///| +test "codeml best AIC rejects empty input" { + let raised = try { + ignore(@src.codeml_best_aic([])) + false + } catch { + @src.CodemlError(_) => true + } + assert_true(raised) +} + +///| +test "codeml results reject empty text" { + codeml_test_expect_result_error("") +} + +///| +test "codeml results reject missing PAML header" { + codeml_test_expect_result_error( + "Model: one-ratio\nlnL(ntime: 1 np: 1): -1.0\n", + ) +} + +///| +test "codeml results reject header without estimates" { + codeml_test_expect_result_error( + "CODONML (in paml version 4.7, January 2013) a.phy\nModel: x\n", + ) +} + +///| +test "codeml results reject malformed model likelihood" { + codeml_test_expect_result_error( + "CODONML (in paml version 4.7, January 2013) a.phy\n" + + "Model 0: one-ratio\n" + + "lnL(ntime: 1 np: 1): not-a-number\n", + ) +} + +///| +test "codeml results reject incomplete pairwise estimate" { + codeml_test_expect_result_error( + "CODONML (in paml version 4.7, January 2013) a.phy\n" + + "2 (B) ... 1 (A)\n" + + "lnL = -1.0\n" + + "t=0.1 S=10 N=20 dN/dS=0.5 dN=0.01\n", + ) +} diff --git a/test/moonbit/paml_yn00_test.mbt b/test/moonbit/paml_yn00_test.mbt new file mode 100644 index 00000000..8e4c8578 --- /dev/null +++ b/test/moonbit/paml_yn00_test.mbt @@ -0,0 +1,782 @@ +///| +fn yn00_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "YN00 value " + + actual.to_string() + + " differs from " + + expected.to_string(), + ) + } +} + +///| +fn yn00_test_expect_control_error(text : String) -> Unit { + let raised = try { + ignore(@src.yn00_parse_control(text)) + false + } catch { + @src.Yn00Error(_) => true + } + if !raised { + abort("expected Yn00Error") + } +} + +///| +fn yn00_test_expect_result_error(text : String) -> Unit { + let raised = try { + ignore(@src.yn00_parse_results(text)) + false + } catch { + @src.Yn00Error(_) => true + } + if !raised { + abort("expected Yn00Error") + } +} + +///| +fn yn00_test_two_sequence_result( + first : String, + second : String, + ng_row : String, + lwl85_omega : String, + modified_ds : String, +) -> String { + "YN00 pairwise.phy\n" + + "ns = 2 ls = 100\n" + + "(A) Nei-Gojobori (1986) method\n" + + first + + "\n" + + ng_row + + "\n" + + "(B) Yang & Nielsen (2000) method\n" + + "2 1 30.0 70.0 0.1 2.0 0.5 0.01 +- 0.001 0.02 +- 0.002\n" + + "(C) LWL85, LPB93 & LWLm methods\n" + + "2 (" + + second + + ") vs. 1 (" + + first + + ")\n" + + "LWL85: dS = 0.0200 dN = 0.0100 w = " + + lwl85_omega + + " S = 30.0 N = 70.0\n" + + "LWL85m: dS = " + + modified_ds + + " dN = -nan w = -nan S = -nan N = -nan (rho = -nan)\n" + + "LPB93: dS = 0.0200 dN = 0.0100 w = 0.5000\n" +} + +///| +test "yn00 control parses required paths" { + let control = @src.yn00_parse_control(@src.yn00_example_control_text()) + assert_eq(control.sequence_file(), "alignment.phylip") + assert_eq(control.output_file(), "yn00.out") +} + +///| +test "yn00 control parses all official options" { + let control = @src.yn00_parse_control(@src.yn00_example_control_text()) + assert_eq(control.option("verbose"), Some("1")) + assert_eq(control.option("icode"), Some("0")) + assert_eq(control.option("weighting"), Some("0")) + assert_eq(control.option("commonf3x4"), Some("0")) + assert_eq(control.option("ndata"), Some("1")) +} + +///| +test "yn00 control ignores comments and blank lines" { + let control = @src.yn00_parse_control( + "* header\n\nseqfile = a.phy * input\noutfile = out.txt * output\n", + ) + assert_eq(control.sequence_file(), "a.phy") + assert_eq(control.output_file(), "out.txt") +} + +///| +test "yn00 control accepts CRLF" { + let text = @src.yn00_example_control_text().replace_all(old="\n", new="\r\n") + let control = @src.yn00_parse_control(text) + assert_eq(control.options().length(), 5) +} + +///| +test "yn00 control canonical round trip" { + let control = @src.yn00_parse_control(@src.yn00_example_control_text()) + let canonical = @src.yn00_write_control(control) + assert_eq( + @src.yn00_write_control(@src.yn00_parse_control(canonical)), + canonical, + ) +} + +///| +test "yn00 control preserves option order" { + let control = @src.yn00_parse_control( + "seqfile=a\noutfile=b\nndata=2\nverbose=0\nicode=3\n", + ) + let options = control.options() + assert_eq(options[0].name(), "ndata") + assert_eq(options[1].name(), "verbose") + assert_eq(options[2].name(), "icode") +} + +///| +test "yn00 control options are defensive copies" { + let control = @src.yn00_parse_control(@src.yn00_example_control_text()) + let options = control.options() + ignore(options.pop()) + assert_eq(control.options().length(), 5) +} + +///| +test "yn00 control reports absent option" { + let control = @src.yn00_parse_control("seqfile=a\noutfile=b\n") + assert_eq(control.option("icode"), None) +} + +///| +test "yn00 control normalizes integers" { + let control = @src.yn00_parse_control( + "seqfile=a\noutfile=b\nverbose=+1\nicode=03\nndata=002\n", + ) + assert_eq(control.option("verbose"), Some("1")) + assert_eq(control.option("icode"), Some("3")) + assert_eq(control.option("ndata"), Some("2")) +} + +///| +test "yn00 control rejects missing seqfile" { + yn00_test_expect_control_error("outfile=out\n") +} + +///| +test "yn00 control rejects missing outfile" { + yn00_test_expect_control_error("seqfile=in\n") +} + +///| +test "yn00 control rejects line without equals" { + yn00_test_expect_control_error("seqfile=in\noutfile out\n") +} + +///| +test "yn00 control rejects multiple equals" { + yn00_test_expect_control_error("seqfile=in=x\noutfile=out\n") +} + +///| +test "yn00 control rejects empty key" { + yn00_test_expect_control_error("=in\noutfile=out\n") +} + +///| +test "yn00 control rejects empty value" { + yn00_test_expect_control_error("seqfile=\noutfile=out\n") +} + +///| +test "yn00 control rejects duplicate key" { + yn00_test_expect_control_error("seqfile=in\noutfile=out\nseqfile=again\n") +} + +///| +test "yn00 control rejects unknown option" { + yn00_test_expect_control_error("seqfile=in\noutfile=out\nunknown=1\n") +} + +///| +test "yn00 control rejects non-integer option" { + yn00_test_expect_control_error("seqfile=in\noutfile=out\nicode=1.5\n") +} + +///| +test "yn00 control rejects verbose outside binary range" { + yn00_test_expect_control_error("seqfile=in\noutfile=out\nverbose=2\n") +} + +///| +test "yn00 control rejects weighting outside binary range" { + yn00_test_expect_control_error("seqfile=in\noutfile=out\nweighting=-1\n") +} + +///| +test "yn00 control rejects commonf3x4 outside binary range" { + yn00_test_expect_control_error("seqfile=in\noutfile=out\ncommonf3x4=3\n") +} + +///| +test "yn00 control rejects negative genetic code" { + yn00_test_expect_control_error("seqfile=in\noutfile=out\nicode=-1\n") +} + +///| +test "yn00 control rejects unsupported genetic code" { + yn00_test_expect_control_error("seqfile=in\noutfile=out\nicode=11\n") +} + +///| +test "yn00 control rejects non-positive data count" { + yn00_test_expect_control_error("seqfile=in\noutfile=out\nndata=0\n") +} + +///| +test "yn00 results parse alignment metadata" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + assert_eq(result.alignment_file(), "alignment.phylip") + assert_eq(result.sequence_count(), 3) + assert_eq(result.codon_count(), 74) +} + +///| +test "yn00 results preserve sequence order" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + assert_eq(result.sequence_names(), ["Homo_sapie", "Pan_troglo", "Gorilla_go"]) +} + +///| +test "yn00 results contain complete triangular pairs" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + assert_eq(result.pairs().length(), 3) +} + +///| +test "yn00 pair lookup is symmetric" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + let forward = result.pair("Homo_sapie", "Pan_troglo").unwrap() + let reverse = result.pair("Pan_troglo", "Homo_sapie").unwrap() + assert_eq(forward, reverse) +} + +///| +test "yn00 pair lookup rejects diagonal" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + assert_eq(result.pair("Homo_sapie", "Homo_sapie"), None) +} + +///| +test "yn00 pair lookup reports unknown names" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + assert_eq(result.pair("Homo_sapie", "Unknown"), None) +} + +///| +test "yn00 parses NG86 estimate" { + let pair = @src.yn00_parse_results(@src.yn00_example_results_text()) + .pair("Homo_sapie", "Pan_troglo") + .unwrap() + yn00_test_close(pair.ng86().omega(), -1.0, 1.0e-12) + yn00_test_close(pair.ng86().dn(), 0.0, 1.0e-12) + yn00_test_close(pair.ng86().ds(), 0.0207, 1.0e-12) +} + +///| +test "yn00 parses Yang-Nielsen site counts" { + let estimate = @src.yn00_parse_results(@src.yn00_example_results_text()) + .pair("Homo_sapie", "Pan_troglo") + .unwrap() + .yang_nielsen() + yn00_test_close(estimate.synonymous_sites(), 67.3, 1.0e-12) + yn00_test_close(estimate.nonsynonymous_sites(), 154.7, 1.0e-12) +} + +///| +test "yn00 parses Yang-Nielsen model parameters" { + let estimate = @src.yn00_parse_results(@src.yn00_example_results_text()) + .pair("Homo_sapie", "Pan_troglo") + .unwrap() + .yang_nielsen() + yn00_test_close(estimate.time(), 0.0136, 1.0e-12) + yn00_test_close(estimate.kappa(), 3.6564, 1.0e-12) + yn00_test_close(estimate.omega(), 0.0, 1.0e-12) +} + +///| +test "yn00 parses Yang-Nielsen rates and errors" { + let estimate = @src.yn00_parse_results(@src.yn00_example_results_text()) + .pair("Homo_sapie", "Pan_troglo") + .unwrap() + .yang_nielsen() + yn00_test_close(estimate.dn(), 0.0, 1.0e-12) + yn00_test_close(estimate.dn_standard_error(), 0.0, 1.0e-12) + yn00_test_close(estimate.ds(), 0.015, 1.0e-12) + yn00_test_close(estimate.ds_standard_error(), 0.0151, 1.0e-12) +} + +///| +test "yn00 parses LWL85 estimate" { + let estimate = @src.yn00_parse_results(@src.yn00_example_results_text()) + .pair("Homo_sapie", "Pan_troglo") + .unwrap() + .lwl85() + assert_eq(estimate.method_name(), "LWL85") + yn00_test_close(estimate.ds().unwrap(), 0.0227, 1.0e-12) + assert_eq(estimate.dn(), Some(0.0)) + assert_eq(estimate.omega(), Some(0.0)) + assert_eq(estimate.synonymous_sites(), Some(45.0)) + assert_eq(estimate.nonsynonymous_sites(), Some(177.0)) +} + +///| +test "yn00 maps undefined modified LWL85 values to none" { + let estimate = @src.yn00_parse_results(@src.yn00_example_results_text()) + .pair("Homo_sapie", "Pan_troglo") + .unwrap() + .lwl85_modified() + assert_eq(estimate.ds(), None) + assert_eq(estimate.dn(), None) + assert_eq(estimate.omega(), None) + assert_eq(estimate.synonymous_sites(), None) + assert_eq(estimate.nonsynonymous_sites(), None) + assert_eq(estimate.rho(), None) +} + +///| +test "yn00 parses defined modified LWL85 values" { + let estimate = @src.yn00_parse_results(@src.yn00_example_results_text()) + .pair("Homo_sapie", "Gorilla_go") + .unwrap() + .lwl85_modified() + yn00_test_close(estimate.ds().unwrap(), 0.018, 1.0e-12) + assert_eq(estimate.dn(), Some(0.011)) + assert_eq(estimate.omega(), Some(0.6111)) + assert_eq(estimate.rho(), Some(0.507)) +} + +///| +test "yn00 parses LPB93 estimate without site counts" { + let estimate = @src.yn00_parse_results(@src.yn00_example_results_text()) + .pair("Homo_sapie", "Pan_troglo") + .unwrap() + .lpb93() + assert_eq(estimate.method_name(), "LPB93") + assert_eq(estimate.ds(), Some(0.0129)) + assert_eq(estimate.dn(), Some(0.0)) + assert_eq(estimate.omega(), Some(0.0)) + assert_eq(estimate.synonymous_sites(), None) + assert_eq(estimate.nonsynonymous_sites(), None) +} + +///| +test "yn00 parses PAML 4.1 compact NG86 rows" { + let text = yn00_test_two_sequence_result( + "Alpha", "Beta", "Beta0.5000(0.0100 0.0200)", "0.5000", "-nan", + ) + let pair = @src.yn00_parse_results(text).pair("Alpha", "Beta").unwrap() + assert_eq(pair.ng86().omega(), 0.5) + assert_eq(pair.ng86().dn(), 0.01) +} + +///| +test "yn00 parses PAML 4.8 long names glued to negative omega" { + let first = "patient1_1000_326|1M|XXX|XXX|2" + let second = "patient1_1000_16|1M|XXX|XXX|20" + let text = yn00_test_two_sequence_result( + first, + second, + second + "-1.0000 (0.0028 0.0000)", + "inf", + "-nan", + ) + let result = @src.yn00_parse_results(text) + assert_eq(result.sequence_names(), [first, second]) + assert_eq(result.pair(first, second).unwrap().ng86().dn(), 0.0028) +} + +///| +test "yn00 parses PAML 4.9i dotted numeric names" { + let first = "patient1.1000.326" + let second = "patient1.1000.16" + let text = yn00_test_two_sequence_result( + first, + second, + second + " -1.0000 (0.0028 0.0000)", + "inf", + "-nan", + ) + let result = @src.yn00_parse_results(text) + assert_eq(result.sequence_names(), [first, second]) +} + +///| +test "yn00 maps infinity to none" { + let text = yn00_test_two_sequence_result( + "Alpha", "Beta", "Beta -1.0000 (0.0100 0.0000)", "inf", "-nan", + ) + let estimate = @src.yn00_parse_results(text) + .pair("Alpha", "Beta") + .unwrap() + .lwl85() + assert_eq(estimate.omega(), None) +} + +///| +test "yn00 maps Windows indefinite values to none" { + let text = yn00_test_two_sequence_result( + "Alpha", "Beta", "Beta -1.0000 (0.0100 0.0000)", "0.5000", "-1.#IND", + ) + let estimate = @src.yn00_parse_results(text) + .pair("Alpha", "Beta") + .unwrap() + .lwl85_modified() + assert_eq(estimate.ds(), None) +} + +///| +test "yn00 results accept CRLF" { + let text = @src.yn00_example_results_text().replace_all(old="\n", new="\r\n") + assert_eq(@src.yn00_parse_results(text).pairs().length(), 3) +} + +///| +test "yn00 sequence names are defensive copies" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + let names = result.sequence_names() + names[0] = "Changed" + assert_eq(result.sequence_names()[0], "Homo_sapie") +} + +///| +test "yn00 pairs are defensive copies" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + let pairs = result.pairs() + ignore(pairs.pop()) + assert_eq(result.pairs().length(), 3) +} + +///| +test "yn00 builds symmetric NG86 matrix" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + let matrix = result.matrix("NG86", "dS") + assert_eq(matrix.names(), result.sequence_names()) + assert_eq(matrix.value("Homo_sapie", "Pan_troglo"), Some(0.0207)) + assert_eq(matrix.value("Pan_troglo", "Homo_sapie"), Some(0.0207)) + assert_eq(matrix.value("Homo_sapie", "Homo_sapie"), None) +} + +///| +test "yn00 builds Yang-Nielsen standard error matrix" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + let matrix = result.matrix("YN00", "dS SE") + yn00_test_close( + matrix.value("Homo_sapie", "Pan_troglo").unwrap(), + 0.0151, + 1.0e-12, + ) +} + +///| +test "yn00 matrix preserves undefined values" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + let matrix = result.matrix("LWL85m", "dS") + assert_eq(matrix.value("Homo_sapie", "Pan_troglo"), None) + yn00_test_close( + matrix.value("Homo_sapie", "Gorilla_go").unwrap(), + 0.018, + 1.0e-12, + ) +} + +///| +test "yn00 matrix values are defensive copies" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + let matrix = result.matrix("NG86", "dS") + let values = matrix.values() + values[0][1] = None + assert_eq(matrix.value("Homo_sapie", "Pan_troglo"), Some(0.0207)) +} + +///| +test "yn00 matrix reports unknown name" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + let matrix = result.matrix("NG86", "dS") + assert_eq(matrix.value("Unknown", "Homo_sapie"), None) +} + +///| +test "yn00 computes mean over all pairs" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + yn00_test_close( + result.mean("YN00", "dS"), + (0.015 + 0.02 + 0.0303) / 3.0, + 1.0e-12, + ) +} + +///| +test "yn00 mean skips undefined estimates" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + yn00_test_close(result.mean("LWL85m", "dS"), 0.018, 1.0e-12) +} + +///| +test "yn00 matrix rejects unknown method" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + let raised = try { + ignore(result.matrix("UNKNOWN", "dS")) + false + } catch { + @src.Yn00Error(_) => true + } + assert_true(raised) +} + +///| +test "yn00 matrix rejects unknown statistic" { + let result = @src.yn00_parse_results(@src.yn00_example_results_text()) + let raised = try { + ignore(result.matrix("YN00", "bad")) + false + } catch { + @src.Yn00Error(_) => true + } + assert_true(raised) +} + +///| +test "yn00 mean rejects wholly undefined statistic" { + let text = yn00_test_two_sequence_result( + "Alpha", "Beta", "Beta -1.0000 (0.0100 0.0000)", "0.5000", "-nan", + ) + let result = @src.yn00_parse_results(text) + let raised = try { + ignore(result.mean("LWL85m", "rho")) + false + } catch { + @src.Yn00Error(_) => true + } + assert_true(raised) +} + +///| +test "yn00 rejects empty results" { + yn00_test_expect_result_error("") +} + +///| +test "yn00 rejects missing NG86 section" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="(A) Nei-Gojobori (1986) method", + new="", + ), + ) +} + +///| +test "yn00 rejects missing Yang-Nielsen section" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="(B) Yang & Nielsen (2000) method", + new="", + ), + ) +} + +///| +test "yn00 rejects missing counting section" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="(C) LWL85, LPB93 & LWLm methods", + new="", + ), + ) +} + +///| +test "yn00 rejects duplicate method section" { + yn00_test_expect_result_error( + @src.yn00_example_results_text() + "(A) Nei-Gojobori (1986) method\n", + ) +} + +///| +test "yn00 rejects missing alignment header" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="YN00 alignment.phylip\n", + new="", + ), + ) +} + +///| +test "yn00 rejects duplicate alignment header" { + yn00_test_expect_result_error( + "YN00 duplicate.phy\n" + @src.yn00_example_results_text(), + ) +} + +///| +test "yn00 rejects malformed dimensions" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="ns = 3 ls = 74", + new="ns = bad ls = 74", + ), + ) +} + +///| +test "yn00 rejects fewer than two sequences" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="ns = 3 ls = 74", + new="ns = 1 ls = 74", + ), + ) +} + +///| +test "yn00 rejects non-positive codon count" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="ns = 3 ls = 74", + new="ns = 3 ls = 0", + ), + ) +} + +///| +test "yn00 rejects invalid comparison index" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="2 (Pan_troglo) vs. 1 (Homo_sapie)", + new="4 (Pan_troglo) vs. 1 (Homo_sapie)", + ), + ) +} + +///| +test "yn00 rejects inconsistent indexed name" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="3 (Gorilla_go) vs. 2 (Pan_troglo)", + new="3 (Different) vs. 2 (Pan_troglo)", + ), + ) +} + +///| +test "yn00 rejects duplicate sequence names" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="2 (Pan_troglo) vs. 1 (Homo_sapie)", + new="2 (Homo_sapie) vs. 1 (Homo_sapie)", + ), + ) +} + +///| +test "yn00 rejects duplicate pair header" { + let duplicate = "2 (Pan_troglo) vs. 1 (Homo_sapie)\n" + yn00_test_expect_result_error(@src.yn00_example_results_text() + duplicate) +} + +///| +test "yn00 rejects counting estimate before pair header" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="(C) LWL85, LPB93 & LWLm methods\n", + new="(C) LWL85, LPB93 & LWLm methods\n" + + "LWL85: dS = 0.1 dN = 0.1 w = 1.0 S = 1.0 N = 1.0\n", + ), + ) +} + +///| +test "yn00 rejects missing counting method" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="LPB93: dS = 0.0129 dN = 0.0000 w = 0.0000\n", + new="", + ), + ) +} + +///| +test "yn00 rejects missing counting statistic" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="LWL85: dS = 0.0227 dN = 0.0000 w = 0.0000 S = 45.0 N = 177.0", + new="LWL85: dS = 0.0227 dN = 0.0000 S = 45.0 N = 177.0", + ), + ) +} + +///| +test "yn00 rejects duplicate counting estimate" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="LWL85: dS = 0.0227 dN = 0.0000 w = 0.0000 S = 45.0 N = 177.0\n", + new="LWL85: dS = 0.0227 dN = 0.0000 w = 0.0000 S = 45.0 N = 177.0\n" + + "LWL85: dS = 0.0227 dN = 0.0000 w = 0.0000 S = 45.0 N = 177.0\n", + ), + ) +} + +///| +test "yn00 rejects malformed Yang-Nielsen row" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="2 1 67.3 154.7 0.0136 3.6564 0.0000 0.0000 +- 0.0000 0.0150 +- 0.0151", + new="2 1 67.3 154.7 0.0136 3.6564", + ), + ) +} + +///| +test "yn00 rejects invalid Yang-Nielsen index" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="2 1 67.3 154.7", + new="4 1 67.3 154.7", + ), + ) +} + +///| +test "yn00 rejects duplicate Yang-Nielsen pair" { + let row = "2 1 67.3 154.7 0.0136 3.6564 0.0000 0.0000 +- 0.0000 0.0150 +- 0.0151\n" + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="(C) LWL85, LPB93 & LWLm methods", + new=row + "(C) LWL85, LPB93 & LWLm methods", + ), + ) +} + +///| +test "yn00 rejects missing NG86 row" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="Gorilla_go 0.5000 (0.0100 0.0200)-1.0000 (0.0000 0.0421)\n", + new="", + ), + ) +} + +///| +test "yn00 rejects incomplete NG86 row" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="Gorilla_go 0.5000 (0.0100 0.0200)-1.0000 (0.0000 0.0421)", + new="Gorilla_go 0.5000 (0.0100 0.0200)", + ), + ) +} + +///| +test "yn00 rejects malformed NG86 estimate" { + yn00_test_expect_result_error( + @src.yn00_example_results_text().replace_all( + old="Pan_troglo -1.0000 (0.0000 0.0207)", + new="Pan_troglo -1.0000 (0.0000)", + ), + ) +} From 69efe133b033a47e17fde3a9e835eab14afff6f9 Mon Sep 17 00:00:00 2001 From: eda Date: Fri, 7 Aug 2026 01:05:51 +0800 Subject: [PATCH 36/41] #38 pass: 12151 refactor: more format --- README.md | 11 +- examples/voyager_demo/main.mbt | 266 ++ examples/voyager_demo/moon.pkg | 5 + src/abi.mbt | 38 +- src/ace.mbt | 113 +- src/aldex2.mbt | 5 +- src/align_abstract.mbt | 199 +- src/align_analysis.mbt | 235 +- src/align_applications.mbt | 162 +- src/align_bed.mbt | 31 +- src/align_cluster.mbt | 74 +- src/alignace.mbt | 93 +- src/alignment_map.mbt | 15 +- src/alphabet.mbt | 57 +- src/ancombc.mbt | 86 +- src/application.mbt | 47 +- src/bamsignals.mbt | 379 ++- src/batchelor.mbt | 57 +- src/bayes_space.mbt | 73 +- src/bayseq.mbt | 109 +- src/beachmat.mbt | 91 +- src/binary_cif.mbt | 386 ++- src/bioc_generics.mbt | 94 +- src/bioc_neighbors.mbt | 253 +- src/bioc_parallel.mbt | 124 +- src/bioc_singular.mbt | 56 +- src/biostrings.mbt | 202 +- src/biostrings_matchdict.mbt | 114 +- src/blast_applications.mbt | 404 ++- src/bumphunter.mbt | 61 +- src/caps.mbt | 9 +- src/cellchat.mbt | 114 +- src/chain_liftover.mbt | 197 +- src/checksum.mbt | 126 +- src/chem_utils.mbt | 405 ++- src/chemminer.mbt | 92 +- src/chipseeker.mbt | 261 +- src/chromosome_visualization.mbt | 689 +++-- src/cibersort.mbt | 118 +- src/circ_seq.mbt | 162 +- src/cluster_experiment.mbt | 64 +- src/cnvkit.mbt | 240 +- src/codon_advanced.mbt | 134 +- src/compass.mbt | 72 +- src/compound.mbt | 238 +- src/consensus_cluster_plus.mbt | 133 +- src/cram_wbtest.mbt | 49 +- src/crystal.mbt | 96 +- src/csaw.mbt | 216 +- src/cyclone.mbt | 41 +- src/data.mbt | 196 +- src/decoupler.mbt | 129 +- src/delayed_matrix_stats.mbt | 6 +- src/deseq2.mbt | 182 +- src/deseq2_advanced.mbt | 25 +- src/destiny.mbt | 250 +- src/dexseq.mbt | 126 +- src/diffbind.mbt | 277 +- src/diffcyt.mbt | 83 +- src/dnashape.mbt | 5 +- src/dorothea.mbt | 67 +- src/drimseq.mbt | 422 ++- src/droplet_utils.mbt | 3 +- src/dss.mbt | 403 ++- src/dssp.mbt | 128 +- src/edaseq.mbt | 219 +- src/edger_advanced.mbt | 137 +- src/embl_io.mbt | 31 +- src/enhanced_volcano.mbt | 96 +- src/enriched_heatmap.mbt | 125 +- src/enrichplot.mbt | 343 ++- src/ensembldb.mbt | 198 +- src/estimate_score.mbt | 104 +- src/exonerate.mbt | 34 +- src/expasy.mbt | 194 +- src/factoextra.mbt | 254 +- src/fasta_search_io.mbt | 22 +- src/feature_counts.mbt | 312 +- src/file.mbt | 43 +- src/fishpond.mbt | 63 +- src/fragment_mapper.mbt | 79 +- src/freq_analysis.mbt | 92 +- src/freq_table.mbt | 34 +- src/fssp.mbt | 24 +- src/ga.mbt | 185 +- src/gage.mbt | 33 +- src/gck_io.mbt | 45 +- src/gcrma.mbt | 97 +- src/genbank_io.mbt | 9 +- src/gene_pop.mbt | 71 +- src/genefilter.mbt | 164 +- src/genesis.mbt | 135 +- src/genie3.mbt | 61 +- src/genome_diagram.mbt | 355 ++- src/genomic_ranges.mbt | 52 +- src/genomic_ranges_advanced.mbt | 33 +- src/genomic_ranges_gaps.mbt | 123 +- src/geo.mbt | 31 +- src/gfa_io.mbt | 18 +- src/gff.mbt | 171 +- src/ggtree.mbt | 118 +- src/glm_gampoi.mbt | 71 +- src/goa.mbt | 24 +- src/gosemsim.mbt | 199 +- src/graphics.mbt | 170 +- src/gsea_base.mbt | 240 +- src/gsva.mbt | 122 +- src/gviz.mbt | 246 +- src/harmony.mbt | 133 +- src/hicdc.mbt | 79 +- src/hilbertcurve.mbt | 72 +- src/hmisc.mbt | 117 +- src/hmmcopy.mbt | 66 +- src/hmmer_io.mbt | 81 +- src/hs_exposure.mbt | 62 +- src/htsfilter.mbt | 81 +- src/ig_io.mbt | 25 +- src/ihw.mbt | 60 +- src/imgt_io.mbt | 145 +- src/impute.mbt | 247 +- src/infercnv.mbt | 321 +- src/insdc_io.mbt | 108 +- src/internal_coords.mbt | 624 +++- src/interproscan.mbt | 258 +- src/iranges.mbt | 43 +- src/isoform_switch_analyze_r.mbt | 362 ++- src/jaspar.mbt | 35 +- src/karyoploter.mbt | 173 +- src/kgml.mbt | 80 +- src/kmer.mbt | 67 +- src/limma.mbt | 80 +- src/lisaclust.mbt | 194 +- src/logistic_regression.mbt | 39 +- src/lowess.mbt | 18 +- src/ma_align.mbt | 228 +- src/maf.mbt | 181 +- src/maftools.mbt | 278 +- src/markov.mbt | 69 +- src/mast_motif.mbt | 13 +- src/matrix.mbt | 151 +- src/matrix_generics.mbt | 12 +- src/mauve.mbt | 218 +- src/max_entropy.mbt | 43 +- src/mcp_counter.mbt | 61 +- src/melting_temp.mbt | 25 +- src/meme.mbt | 37 +- src/metagenomeseq.mbt | 117 +- src/methyl_seekr.mbt | 61 +- src/methylkit.mbt | 66 +- src/microbiome.mbt | 300 +- src/missmethyl.mbt | 73 +- src/mix_omics.mbt | 49 +- src/mmcifio.mbt | 18 +- src/mmtf.mbt | 244 +- src/mofa2.mbt | 193 +- src/mol_wt.mbt | 66 +- src/monocle3.mbt | 69 +- src/motif_scan.mbt | 79 +- src/motifs.mbt | 107 +- src/motifs_advanced.mbt | 185 +- src/ms_core_utils.mbt | 28 +- src/msnbase.mbt | 276 +- src/msstats.mbt | 134 +- src/muscat.mbt | 63 +- src/mutational_patterns.mbt | 53 +- src/naccess.mbt | 154 +- src/naive_bayes.mbt | 81 +- src/nanostring.mbt | 146 +- src/neural_network.mbt | 34 +- src/nib_io.mbt | 17 +- src/nmr.mbt | 101 +- src/noiseq.mbt | 76 +- src/nucle_r.mbt | 311 +- src/open_cyto.mbt | 80 +- src/pairaligner.mbt | 140 +- src/pairwise2.mbt | 79 +- src/paml.mbt | 214 +- src/parsimony.mbt | 40 +- src/pathway.mbt | 56 +- src/pcatools.mbt | 231 +- src/pcd.mbt | 116 +- src/pdb_analysis.mbt | 79 +- src/pdb_dice.mbt | 174 +- src/pdb_header.mbt | 99 +- src/pdb_list.mbt | 51 +- src/pdb_packing.mbt | 71 +- src/pdb_seqio.mbt | 45 +- src/pdb_vectors.mbt | 388 ++- src/peak_calling.mbt | 63 +- src/phd.mbt | 43 +- src/pheatmap.mbt | 312 +- src/phenotype.mbt | 254 +- src/phylo_cdao.mbt | 121 +- src/phylo_consensus.mbt | 235 +- src/phylo_nexml.mbt | 179 +- src/phylo_xml.mbt | 126 +- src/phyloseq.mbt | 116 +- src/pir_io.mbt | 14 +- src/plyranges.mbt | 308 +- src/polypeptide.mbt | 324 ++- src/popgen_advanced.mbt | 261 +- src/preprocess_core.mbt | 136 +- src/primer3.mbt | 171 +- src/prosite.mbt | 208 +- src/prot_dao.mbt | 181 +- src/protein_analysis.mbt | 86 +- src/proteomics.mbt | 226 +- src/psea.mbt | 105 +- src/qcp_superimposer.mbt | 283 +- src/qfeatures.mbt | 81 +- src/qvalue.mbt | 36 +- src/ragged_experiment.mbt | 210 +- src/reduced.mbt | 35 +- src/reference.mbt | 91 +- src/reporting_tools.mbt | 86 +- src/residue_depth.mbt | 201 +- src/rhdf5.mbt | 105 +- src/rna_structure.mbt | 125 +- src/rstatix.mbt | 329 ++- src/rtsne.mbt | 160 +- src/s4vectors.mbt | 99 +- src/sasa.mbt | 4 +- src/sc3.mbt | 186 +- src/sc_dbl_finder.mbt | 8 +- src/scenic.mbt | 311 +- src/scmap.mbt | 62 +- src/scnorm.mbt | 218 +- src/scop.mbt | 37 +- src/searchio.mbt | 445 ++- src/seq.mbt | 10 +- src/seq_approx.mbt | 63 +- src/seq_complexity.mbt | 2 +- src/seq_location.mbt | 163 +- src/seq_quality_trim.mbt | 98 +- src/seq_utils.mbt | 81 +- src/seqfeature_advanced.mbt | 86 +- src/seqlogo.mbt | 87 +- src/seqxml_io.mbt | 65 +- src/seurat.mbt | 273 +- src/sff_io.mbt | 96 +- src/sgseq.mbt | 165 +- src/single_r.mbt | 267 +- src/singscore.mbt | 96 +- src/slingshot.mbt | 360 ++- src/smart.mbt | 85 +- src/snapgene_io.mbt | 114 +- src/spatial_experiment.mbt | 119 +- src/spia.mbt | 83 +- src/stage_r.mbt | 38 +- src/statistics.mbt | 543 +++- src/stockholm.mbt | 78 +- src/structural_variant.mbt | 110 +- src/structure_alignment.mbt | 299 +- src/substitution_matrices.mbt | 477 +-- src/survival.mbt | 74 +- src/system_piper.mbt | 151 +- src/tab_io.mbt | 14 +- src/taxonomy.mbt | 252 +- src/topgo.mbt | 207 +- src/tradeseq.mbt | 367 ++- src/transfac.mbt | 35 +- src/trie.mbt | 46 +- src/twobit_io.mbt | 46 +- src/uniprot_io.mbt | 23 +- src/universalmotif.mbt | 27 +- src/utils.mbt | 4 +- src/uwot.mbt | 221 +- src/variance_partition.mbt | 14 +- src/variant_filtering.mbt | 397 ++- src/variation.mbt | 342 ++- src/vcf.mbt | 4 +- src/velociraptor.mbt | 37 +- src/venn_diagram.mbt | 99 +- src/voyager.mbt | 2581 +++++++++++++++++ src/vsn.mbt | 213 +- src/wise.mbt | 160 +- src/xcell.mbt | 415 +-- src/xdna_io.mbt | 20 +- test/moonbit/ace_test.mbt | 92 +- test/moonbit/align_abstract_test.mbt | 154 +- test/moonbit/align_analysis_test.mbt | 15 + test/moonbit/align_applications_test.mbt | 8 +- test/moonbit/align_bed_test.mbt | 151 +- test/moonbit/align_cluster_test.mbt | 2 +- test/moonbit/alignace_test.mbt | 156 +- test/moonbit/alphabet_test.mbt | 8 + test/moonbit/ancombc_test.mbt | 12 +- test/moonbit/apeglm_test.mbt | 248 +- test/moonbit/application_test.mbt | 7 +- test/moonbit/aucell_test.mbt | 16 +- test/moonbit/bamsignals_test.mbt | 4 +- test/moonbit/batchelor_test.mbt | 95 +- test/moonbit/bayes_space_test.mbt | 145 +- test/moonbit/bayseq_test.mbt | 19 +- test/moonbit/beachmat_test.mbt | 76 +- test/moonbit/binary_cif_test.mbt | 146 +- test/moonbit/bio_seq_test.mbt | 16 + test/moonbit/bioc_generics_test.mbt | 30 +- test/moonbit/bioc_neighbors_test.mbt | 225 +- test/moonbit/bioc_parallel_test.mbt | 12 +- test/moonbit/bioc_singular_test.mbt | 9 +- test/moonbit/biostrings_matchdict_test.mbt | 83 +- test/moonbit/blast_applications_test.mbt | 4 +- test/moonbit/bsseq_test.mbt | 5 +- test/moonbit/bumphunter_test.mbt | 54 +- test/moonbit/caps_test.mbt | 45 +- test/moonbit/cellchat_test.mbt | 129 +- test/moonbit/chain_liftover_test.mbt | 18 +- test/moonbit/checksum_test.mbt | 2 +- .../moonbit/chromosome_visualization_test.mbt | 85 +- test/moonbit/cibersort_test.mbt | 33 +- test/moonbit/circ_seq_test.mbt | 2 +- test/moonbit/cluster_experiment_test.mbt | 24 +- test/moonbit/cnvkit_test.mbt | 127 +- test/moonbit/codon_advanced_test.mbt | 35 +- test/moonbit/compass_test.mbt | 70 +- test/moonbit/compound_test.mbt | 4 +- test/moonbit/consensus_cluster_plus_test.mbt | 39 +- test/moonbit/crystal_test.mbt | 32 +- test/moonbit/csaw_test.mbt | 10 +- test/moonbit/cyclone_test.mbt | 36 +- test/moonbit/decoupler_test.mbt | 134 +- test/moonbit/delayed_matrix_stats_test.mbt | 100 +- test/moonbit/deseq2_test.mbt | 42 +- test/moonbit/destiny_test.mbt | 48 +- test/moonbit/dexseq_test.mbt | 5 +- test/moonbit/diffcyt_test.mbt | 26 +- test/moonbit/dnashape_test.mbt | 10 +- test/moonbit/dorothea_test.mbt | 80 +- test/moonbit/drimseq_test.mbt | 154 +- test/moonbit/dss_test.mbt | 2 +- test/moonbit/dssp_test.mbt | 2 +- test/moonbit/edaseq_test.mbt | 28 +- test/moonbit/edger_advanced_test.mbt | 14 +- test/moonbit/enhanced_volcano_test.mbt | 138 +- test/moonbit/enriched_heatmap_test.mbt | 7 +- test/moonbit/enrichplot_test.mbt | 103 +- test/moonbit/ensembldb_test.mbt | 8 +- test/moonbit/estimate_score_test.mbt | 101 +- test/moonbit/exonerate_test.mbt | 4 +- test/moonbit/expasy_test.mbt | 18 +- test/moonbit/factoextra_test.mbt | 91 +- test/moonbit/feature_counts_test.mbt | 119 +- test/moonbit/file_test.mbt | 6 +- test/moonbit/fishpond_test.mbt | 131 +- test/moonbit/fragment_mapper_test.mbt | 16 +- test/moonbit/freq_analysis_test.mbt | 21 +- test/moonbit/freq_table_test.mbt | 5 +- test/moonbit/fssp_test.mbt | 36 +- test/moonbit/ga_test.mbt | 30 +- test/moonbit/gck_io_test.mbt | 97 +- test/moonbit/gcrma_test.mbt | 63 +- test/moonbit/genefilter_test.mbt | 43 +- test/moonbit/genesis_test.mbt | 30 +- test/moonbit/genie3_test.mbt | 18 +- test/moonbit/genome_diagram_test.mbt | 174 +- test/moonbit/genomic_ranges_advanced_test.mbt | 35 +- test/moonbit/genomic_ranges_gaps_test.mbt | 136 +- test/moonbit/geo_test.mbt | 40 +- test/moonbit/gfa_io_test.mbt | 191 +- test/moonbit/gff_test.mbt | 27 +- test/moonbit/ggtree_test.mbt | 16 +- test/moonbit/glm_gampoi_test.mbt | 377 +-- test/moonbit/goa_test.mbt | 99 +- test/moonbit/gosemsim_test.mbt | 98 +- test/moonbit/graphics_test.mbt | 15 +- test/moonbit/gsea_base_test.mbt | 7 +- test/moonbit/gsva_test.mbt | 8 +- test/moonbit/gviz_test.mbt | 142 +- test/moonbit/harmony_test.mbt | 34 +- test/moonbit/hicdc_test.mbt | 47 +- test/moonbit/hilbertcurve_test.mbt | 6 +- test/moonbit/hmisc_test.mbt | 140 +- test/moonbit/hmmcopy_test.mbt | 28 +- test/moonbit/hs_exposure_test.mbt | 10 +- test/moonbit/htsfilter_test.mbt | 19 +- test/moonbit/ig_io_test.mbt | 4 +- test/moonbit/ihw_test.mbt | 27 +- test/moonbit/imgt_io_test.mbt | 189 +- test/moonbit/impute_test.mbt | 43 +- test/moonbit/infercnv_test.mbt | 107 +- test/moonbit/insdc_io_test.mbt | 25 +- test/moonbit/internal_coords_test.mbt | 36 +- test/moonbit/interproscan_test.mbt | 311 +- .../moonbit/isoform_switch_analyze_r_test.mbt | 137 +- test/moonbit/karyoploter_test.mbt | 84 +- test/moonbit/kgml_test.mbt | 20 + test/moonbit/kmer_test.mbt | 11 +- test/moonbit/limma_test.mbt | 21 +- test/moonbit/lisaclust_test.mbt | 73 +- test/moonbit/lowess_test.mbt | 14 +- test/moonbit/ma_align_test.mbt | 104 +- test/moonbit/maf_test.mbt | 62 +- test/moonbit/maftools_test.mbt | 298 +- test/moonbit/markov_test.mbt | 37 +- test/moonbit/matrix_generics_test.mbt | 208 +- test/moonbit/matrix_test.mbt | 33 +- test/moonbit/mauve_test.mbt | 142 +- test/moonbit/mcp_counter_test.mbt | 96 +- test/moonbit/melting_temp_test.mbt | 2 +- test/moonbit/meme_test.mbt | 21 +- test/moonbit/metagenomeseq_test.mbt | 9 +- test/moonbit/methyl_seekr_test.mbt | 95 +- test/moonbit/methylkit_test.mbt | 20 +- test/moonbit/microbiome_test.mbt | 68 +- test/moonbit/missmethyl_test.mbt | 50 +- test/moonbit/mix_omics_test.mbt | 114 +- test/moonbit/mmcifio_test.mbt | 126 +- test/moonbit/mmtf_test.mbt | 25 +- test/moonbit/mofa2_test.mbt | 46 +- test/moonbit/monocle3_test.mbt | 64 +- test/moonbit/moon.pkg | 2 +- test/moonbit/motif_scan_test.mbt | 51 +- test/moonbit/motifs_advanced_test.mbt | 62 +- test/moonbit/ms_core_utils_test.mbt | 121 +- test/moonbit/msf_test.mbt | 108 +- test/moonbit/msnbase_test.mbt | 204 +- test/moonbit/msstats_test.mbt | 123 +- test/moonbit/muscat_test.mbt | 23 +- test/moonbit/naccess_test.mbt | 51 +- test/moonbit/naive_bayes_test.mbt | 41 +- test/moonbit/nanostring_test.mbt | 26 +- test/moonbit/nib_io_test.mbt | 8 +- test/moonbit/nmr_test.mbt | 8 +- test/moonbit/noiseq_test.mbt | 17 +- test/moonbit/nucle_r_test.mbt | 15 +- test/moonbit/open_cyto_test.mbt | 55 +- test/moonbit/pairaligner_test.mbt | 42 +- test/moonbit/pairwise2_test.mbt | 6 +- test/moonbit/paml_test.mbt | 17 +- test/moonbit/parsimony_test.mbt | 10 +- test/moonbit/pathway_test.mbt | 14 +- test/moonbit/pcatools_test.mbt | 47 +- test/moonbit/pcd_test.mbt | 14 + test/moonbit/pdb_analysis_test.mbt | 4 +- test/moonbit/pdb_dice_test.mbt | 136 +- test/moonbit/pdb_header_test.mbt | 19 +- test/moonbit/pdb_list_test.mbt | 7 +- test/moonbit/pdb_packing_test.mbt | 84 +- test/moonbit/pdb_seqio_test.mbt | 27 +- test/moonbit/pdb_vectors_test.mbt | 62 +- test/moonbit/peak_calling_test.mbt | 255 +- test/moonbit/phd_test.mbt | 28 +- test/moonbit/pheatmap_test.mbt | 78 +- test/moonbit/phylo_cdao_test.mbt | 21 +- test/moonbit/phylo_consensus_test.mbt | 18 +- test/moonbit/phylo_nexml_test.mbt | 7 +- test/moonbit/phylo_xml_debug_test.mbt | 3 +- test/moonbit/phylo_xml_test.mbt | 95 +- test/moonbit/phyloseq_test.mbt | 7 +- test/moonbit/plyranges_test.mbt | 54 +- test/moonbit/polypeptide_test.mbt | 6 +- test/moonbit/popgen_advanced_test.mbt | 42 +- test/moonbit/preprocess_core_test.mbt | 80 +- test/moonbit/progeny_test.mbt | 57 +- test/moonbit/prosite_test.mbt | 22 +- test/moonbit/prot_dao_test.mbt | 151 +- test/moonbit/protein_analysis_test.mbt | 19 + test/moonbit/proteomics_test.mbt | 8 +- test/moonbit/psea_test.mbt | 2 +- test/moonbit/qfeatures_test.mbt | 125 +- test/moonbit/qvalue_test.mbt | 11 +- test/moonbit/ragged_experiment_test.mbt | 335 ++- .../ranged_summarized_experiment_test.mbt | 145 +- test/moonbit/reference_test.mbt | 150 +- test/moonbit/reporting_tools_test.mbt | 67 +- test/moonbit/residue_depth_test.mbt | 10 +- test/moonbit/rhdf5_test.mbt | 36 +- test/moonbit/rna_structure_test.mbt | 16 +- test/moonbit/rstatix_test.mbt | 128 +- test/moonbit/rtsne_test.mbt | 31 +- test/moonbit/s4vectors_test.mbt | 22 +- test/moonbit/sasa_test.mbt | 20 +- test/moonbit/sc3_test.mbt | 63 +- test/moonbit/scenic_test.mbt | 213 +- test/moonbit/scmap_test.mbt | 27 +- test/moonbit/scnorm_test.mbt | 6 +- test/moonbit/scop_test.mbt | 46 +- test/moonbit/searchio_new_test.mbt | 383 ++- test/moonbit/seq_complexity_test.mbt | 12 +- test/moonbit/seq_location_test.mbt | 220 +- test/moonbit/seq_quality_trim_test.mbt | 85 +- test/moonbit/seqfeature_advanced_test.mbt | 2 +- test/moonbit/seqio_advanced_test.mbt | 46 +- test/moonbit/seqlogo_test.mbt | 176 +- test/moonbit/seqxml_io_test.mbt | 87 +- test/moonbit/seurat_test.mbt | 57 +- test/moonbit/sff_io_test.mbt | 9 +- test/moonbit/sgseq_test.mbt | 18 +- test/moonbit/single_r_test.mbt | 79 +- test/moonbit/singscore_test.mbt | 12 +- test/moonbit/slingshot_test.mbt | 14 +- test/moonbit/smart_test.mbt | 17 +- test/moonbit/snapgene_io_test.mbt | 28 +- test/moonbit/spatial_experiment_test.mbt | 6 +- test/moonbit/spia_test.mbt | 6 +- test/moonbit/stage_r_test.mbt | 70 +- test/moonbit/statistics_test.mbt | 54 +- test/moonbit/stockholm_test.mbt | 62 +- test/moonbit/structural_variant_test.mbt | 102 +- test/moonbit/structure_alignment_test.mbt | 8 +- test/moonbit/substitution_matrices_test.mbt | 102 +- test/moonbit/survival_test.mbt | 9 +- test/moonbit/system_piper_test.mbt | 31 +- test/moonbit/taxonomy_test.mbt | 18 +- test/moonbit/topgo_test.mbt | 24 +- test/moonbit/tradeseq_test.mbt | 85 +- test/moonbit/trie_test.mbt | 4 +- test/moonbit/twobit_io_test.mbt | 8 +- test/moonbit/uniprot_io_test.mbt | 16 +- test/moonbit/universalmotif_test.mbt | 18 +- test/moonbit/uwot_test.mbt | 34 +- test/moonbit/variant_filtering_test.mbt | 102 +- test/moonbit/variation_test.mbt | 2 +- test/moonbit/velociraptor_test.mbt | 57 +- test/moonbit/venn_diagram_test.mbt | 250 +- test/moonbit/voyager_test.mbt | 1130 ++++++++ test/moonbit/vsn_test.mbt | 24 +- test/moonbit/wise_test.mbt | 88 +- test/moonbit/xcell_test.mbt | 98 +- test/moonbit/xdna_io_test.mbt | 123 +- 521 files changed, 38202 insertions(+), 18779 deletions(-) create mode 100644 examples/voyager_demo/main.mbt create mode 100644 examples/voyager_demo/moon.pkg create mode 100644 src/voyager.mbt create mode 100644 test/moonbit/voyager_test.mbt diff --git a/README.md b/README.md index b7b29bb4..554b275d 100644 --- a/README.md +++ b/README.md @@ -244,6 +244,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **dreamlet** | Bioconductor dreamlet | sample×cell-type pseudobulk、TMM、cell/sample/gene过滤、logCPM、Poisson/voom precision weights、分cell-type重复测量模型及study-wide FDR | ✅ | | **nnSVG** | Bioconductor nnSVG | nearest-neighbor Gaussian process、空间变异基因检验、gene-specific length scale、协变量设计、空间方差占比、BH-FDR及SpatialExperiment接入 | ✅ | | **Banksy** | Bioconductor Banksy | H0邻域均值与H1+方位harmonic、六类空间核、lambda联合特征、分组标准化、PCA、多起点k-means、标签平滑、参数扫描及SpatialExperiment接入 | ✅ | +| **Voyager** | Bioconductor Voyager | kNN/distance-band/inverse-distance空间权重(W/B/C/S编码)、全局Moran's I与Geary's c(Cliff-Ord随机化期望/方差/正态p)、局部Moran's I(LISA象限+置换推断)、局部Geary's c、Getis-Ord Gi/Gi*(Ord-Getis z)、Lee's L(全局+局部)、多元局部Geary、经验变差函数与spherical/exponential/gaussian拟合、Moran correlogram、确定性splitmix64置换、BH-FDR及SpatialExperiment不可变写回 | ✅ | | **spicyR** | Bioconductor spicyR | 有序细胞类型对cross-L曲线、矩形窗口边界校正、图像级共定位统计、precision weights、重复受试者随机截距、条件对比、BH-FDR及SpatialExperiment接入 | ✅ | | **lisaClust** | Bioconductor lisaClust | 每细胞多类型local-K/centered local-L曲线、Gaussian KDE强度校正、矩形/凸包窗口、圆盘边界修正、确定性多起点k-means、silhouette、区域富集及SpatialExperiment写回 | ✅ | | **SpatialDecon** | Bioconductor SpatialDecon | 背景感知加权log-normal非负回归、两阶段异常点重拟合、Hessian不确定度、细胞丰度/比例/计数尺度、cell-type collapse、reverse deconvolution、负探针背景、单细胞profile构建及SpatialExperiment写回 | ✅ | @@ -671,6 +672,7 @@ IvanAXu/BioSeqs/ │ ├── dreamlet.mbt # dreamlet pseudobulk、TMM/voom权重、分cell-type混合模型与study-wide FDR │ ├── nnsvg.mbt # nnSVG nearest-neighbor GP、空间变异检验、length scale与SpatialExperiment接入 │ ├── banksy.mbt # Banksy空间邻域harmonic、lambda联合特征、PCA、聚类、平滑与SpatialExperiment接入 +│ ├── voyager.mbt # Voyager空间自相关：kNN/distance-band/inverse-distance权重、Moran's I/Geary's c(全局+局部)、Getis-Ord Gi*、Lee's L、变差函数拟合、Moran correlogram、置换检验BH-FDR与SpatialExperiment接入 │ ├── spicyr.mbt # spicyR cross-L共定位、边界校正、加权/随机截距模型与SpatialExperiment接入 │ ├── lisaclust.mbt # lisaClust local-K/L曲线、KDE、窗口边界修正、区域聚类与SpatialExperiment接入 │ ├── spatialdecon.mbt # SpatialDecon背景感知log-normal解卷积、异常点重拟合、不确定度与容器接入 @@ -1043,6 +1045,7 @@ IvanAXu/BioSeqs/ │ ├── dreamlet_demo/ # dreamlet SCE pseudobulk、TMM/voom、donor随机截距与跨cell-type FDR示例 │ ├── nnsvg_demo/ # nnSVG空间变异基因、length scale、过滤与SpatialExperiment接入示例 │ ├── banksy_demo/ # Banksy H0/H1、lambda扫描、PCA聚类、平滑与SpatialExperiment接入示例 +│ ├── voyager_demo/ # Voyager空间权重、Moran/Geary/Getis-Ord/Lee's L、变差函数、correlogram与SpatialExperiment接入示例 │ ├── spicyr_demo/ # spicyR cross-L、条件对比、重复受试者模型与SpatialExperiment接入示例 │ ├── lisaclust_demo/ # lisaClust local-K/L、区域聚类、富集与SpatialExperiment写回示例 │ ├── spatialdecon_demo/ # SpatialDecon背景校正、丰度/计数、collapse、reverse与SpatialExperiment示例 @@ -1490,6 +1493,7 @@ IvanAXu/BioSeqs/ │ │ ├── dreamlet_test.mbt │ │ ├── nnsvg_test.mbt │ │ ├── banksy_test.mbt +│ │ ├── voyager_test.mbt │ │ ├── shared_reference_alignment_test.mbt │ │ ├── alignment_map_test.mbt │ │ ├── alignment_counts_test.mbt @@ -1691,7 +1695,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 12093 个测试全部通过 +moon test # ✅ 12151 个测试全部通过 ``` ### 模块对照表 @@ -1823,6 +1827,7 @@ moon test # ✅ 12093 个测试全 | `dreamlet.mbt` | Bioconductor dreamlet | sample×cell-type pseudobulk、完整TMM、CPM/logCPM、Poisson/voom权重、typed fixed/random design、分cell-type dream拟合及两级BH-FDR | | `nnsvg.mbt` | Bioconductor nnSVG | 坐标缩放与前驱kNN、指数协方差NNGP、协变量GLS、profile ML、空间/非空间LR检验、gene-specific length scale、BH-FDR及SpatialExperiment接入 | | `banksy.mbt` | Bioconductor Banksy | H0邻域均值、H1+方位Fourier/Gabor harmonic、六类空间核、lambda联合矩阵、分组标准化、PCA、多起点k-means、平滑、ARI与SpatialExperiment接入 | +| `voyager.mbt` | Bioconductor Voyager | kNN/distance-band/inverse-distance权重(W/B/C/S编码)、全局Moran's I与Geary's c(Cliff-Ord随机化期望/方差/正态p)、局部Moran's I(LISA象限分类+置换推断)、局部Geary's c、Getis-Ord Gi/Gi*(Ord-Getis z)、Lee's L(全局+局部)、多元局部Geary、经验变差函数与spherical/exponential/gaussian拟合、Moran correlogram、确定性splitmix64置换、BH-FDR与SpatialExperiment不可变写回 | | `spicyr.mbt` | Bioconductor spicyR | 图像内有序细胞类型对cross-L、矩形窗口边界校正、图像级统计、cell-count precision weights、加权固定/随机截距模型、条件对比、BH-FDR及SpatialExperiment接入 | | `lisaclust.mbt` | Bioconductor lisaClust | 每图像local-K/centered local-L、Gaussian KDE密度权重、矩形/凸包窗口、圆盘可见面积边界修正、确定性多起点k-means、silhouette、区域富集及SpatialExperiment写回 | | `spatialdecon.mbt` | Bioconductor SpatialDecon | 背景感知加权log-normal非负回归、两阶段异常点重拟合、observed/expected Hessian协方差、细胞丰度尺度、cell-type collapse、reverse deconvolution、负探针背景、单细胞profile与SpatialExperiment接入 | @@ -2069,6 +2074,7 @@ moon test # ✅ 12093 个测试全 | `dreamlet.mbt` | `dreamlet` | SCE到sample×cluster pseudobulk、TMM/logCPM、两阶段voom precision weights、固定/随机效应筛选、逐cell-type dream和study-wide FDR | | `nnsvg.mbt` | `nnSVG` | AMMD/坐标和排序前驱kNN、指数协方差NNGP、covariate GLS、空间方差比例与length scale优化、LR/p-value/BH-FDR、过滤和SpatialExperiment rowData输出 | | `banksy.mbt` | `Banksy` | kNN/radius邻域核、H0/H1+空间harmonic、lambda加权BANKSY矩阵、global/group scaling、Gram-Jacobi PCA、确定性多起点聚类、平滑与SpatialExperiment输出 | +| `voyager.mbt` | `Voyager` | kNN/distance-band/inverse-distance权重(W/B/C/S)、全局Moran's I与Geary's c(Cliff-Ord随机化方差+正态p)、局部Moran's I(象限+置换推断)、局部Geary's c、Getis-Ord Gi/Gi*(Ord-Getis z)、Lee's L(全局+局部)、多元局部Geary、经验变差函数+spherical/exponential/gaussian拟合、Moran correlogram、splitmix64置换、BH-FDR与SpatialExperiment不可变写回 | | `spicyr.mbt` | `spicyR` | ordered cell-type-pair cross-L、矩形窗口disc-intersection边界校正、图像级localization统计、precision weights、加权LMM、条件对比、BH-FDR与SpatialExperiment metadata输出 | | `lisaclust.mbt` | `lisaClust` | 多细胞类型local-K/L特征、KDE intensity correction、矩形/凸包窗口、disc-window边界积分、确定性多起点k-means、regionMap observed/expected富集与SpatialExperiment region输出 | | `spatialdecon.mbt` | `SpatialDecon` | background-aware weighted log-normal non-negative regression、algorithm2异常点重拟合、Hessian协方差、abundance/count scaling、cell-type collapse、reverseDecon、GeoMx background、profile构建与SpatialExperiment输出 | @@ -4091,7 +4097,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 400 个示例程序，展示各模块的典型用法： +项目提供 406 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -4301,6 +4307,7 @@ moon run cmd/bench/main.mbt | dreamlet_demo | SingleCellExperiment pseudobulk、TMM/logCPM、Poisson/voom权重、donor随机截距和跨cell-type FDR | `moon run examples/dreamlet_demo` | | nnsvg_demo | nearest-neighbor GP空间变异基因检验、length scale、空间方差占比、基因过滤与SpatialExperiment接入 | `moon run examples/nnsvg_demo` | | banksy_demo | H0/H1空间邻域特征、cell-typing/domain lambda、PCA聚类、标签平滑、参数扫描与SpatialExperiment接入 | `moon run examples/banksy_demo` | +| voyager_demo | kNN/distance-band/inverse-distance权重、全局Moran/Geary、局部Moran LISA、Getis-Ord Gi*、Lee's L、变差函数拟合、correlogram与SpatialExperiment接入 | `moon run examples/voyager_demo` | | spicyr_demo | 有序细胞类型对cross-L、矩形窗口边界校正、precision weights、重复受试者模型、条件对比与SpatialExperiment接入 | `moon run examples/spicyr_demo` | | lisaclust_demo | 每细胞local-K/L曲线、KDE与边界校正、确定性区域聚类、silhouette、observed/expected富集及SpatialExperiment写回 | `moon run examples/lisaclust_demo` | | spatialdecon_demo | 背景感知log-normal解卷积、丰度/比例/计数、cell-type collapse、reverse deconvolution、负探针背景、单细胞profile与SpatialExperiment写回 | `moon run examples/spatialdecon_demo` | diff --git a/examples/voyager_demo/main.mbt b/examples/voyager_demo/main.mbt new file mode 100644 index 00000000..a2d79b3c --- /dev/null +++ b/examples/voyager_demo/main.mbt @@ -0,0 +1,266 @@ +// Bioconductor Voyager-inspired spatial autocorrelation workflow. +// +// Exercises the full univariate pipeline on a synthetic SpatialExperiment: +// 1. Spatial weight construction (kNN, distance-band, inverse-distance). +// 2. Global Moran's I and Geary's c with analytical inference. +// 3. Local Moran's I (LISA) with permutation inference and quadrants. +// 4. Local Getis–Ord Gi* hotspot detection. +// 5. Bivariate Lee's L spatial association. +// 6. Empirical variogram and spherical model fitting. +// 7. Moran correlogram over distance bins. +// 8. Immutable SpatialExperiment write-back of local statistics. + +///| +fn voyager_demo_coords(se : @src.SpatialExperiment) -> Array[Array[Double]] { + let coords : Array[Array[Double]] = [] + for sc in se.spatial_coords { + coords.push([sc.x, sc.y]) + } + coords +} + +///| +fn voyager_demo_round(value : Double, digits : Int) -> Double { + let scale = @math.pow(10.0, digits.to_double()) + (value * scale).round() / scale +} + +///| +fn voyager_demo_print_row(label : String, value : Double) -> Unit { + println(" " + label + ": " + voyager_demo_round(value, 4).to_string()) +} + +///| +fn main { + let se = @src.voyager_example_spatial_experiment() + let coords = voyager_demo_coords(se) + // assay[feature][spot]; the example ships 4 features on a 6x6 grid. + let assay = se.assay["logcounts"] + let gradient = assay[0] + let hotspot = assay[1] + let anti = assay[3] + println("=== Bioconductor Voyager Demo ===") + println( + "SpatialExperiment: " + + se.col_data.length().to_string() + + " spots, " + + assay.length().to_string() + + " features, platform=" + + se.metadata["platform"], + ) + + // ----------------------------------------------------------------------- + // 1. Spatial weight construction + // ----------------------------------------------------------------------- + println("\n1. Spatial weight construction") + let knn = @src.voyager_weights_knn(coords, 4) catch { + VoyagerError(message) => abort("kNN weights failed: " + message) + } + println( + " kNN k=4: style=" + + knn.style + + ", S0=" + + voyager_demo_round(@src.voyager_weights_s0(knn), 4).to_string(), + ) + let dband = @src.voyager_weights_distance_band(coords, 1.0) catch { + VoyagerError(message) => abort("distance-band weights failed: " + message) + } + println( + " distance-band 1.0: centre spot neighbours=" + + dband.neighbors[18].length().to_string(), + ) + let idw = @src.voyager_weights_inverse_distance(coords, 1.0) catch { + VoyagerError(message) => + abort("inverse-distance weights failed: " + message) + } + println( + " inverse-distance power=1: centre spot neighbours=" + + idw.neighbors[18].length().to_string(), + ) + + // ----------------------------------------------------------------------- + // 2. Global Moran's I and Geary's c + // ----------------------------------------------------------------------- + println("\n2. Global spatial autocorrelation (gene_gradient)") + let moran = @src.voyager_global_morans_i(gradient, knn) catch { + VoyagerError(message) => abort("global Moran's I failed: " + message) + } + voyager_demo_print_row("Moran's I estimate", moran.estimate) + voyager_demo_print_row("Moran's I expectation", moran.expectation) + voyager_demo_print_row("Moran's I z-score", moran.z_score) + voyager_demo_print_row("Moran's I p-value", moran.p_value) + let geary = @src.voyager_global_gearys_c(gradient, knn) catch { + VoyagerError(message) => abort("global Geary's c failed: " + message) + } + voyager_demo_print_row("Geary's c estimate", geary.estimate) + voyager_demo_print_row("Geary's c p-value", geary.p_value) + + // ----------------------------------------------------------------------- + // 3. Local Moran's I (LISA) with permutation inference + // ----------------------------------------------------------------------- + println("\n3. Local Moran's I (LISA) with permutation inference") + let lisa = @src.voyager_local_morans_i( + gradient, + knn, + permutations=199, + seed=20240501, + fdr_threshold=0.1, + ) catch { + VoyagerError(message) => abort("local Moran's I failed: " + message) + } + let mut hh = 0 + let mut ll = 0 + let mut sig = 0 + for i in 0.. abort("Getis–Ord failed: " + message) + } + let mut max_z = -1.0e300 + let mut max_spot = 0 + for i in 0.. max_z { + max_z = getis.z_scores[i] + max_spot = i + } + } + println( + " peak Gi* z-score=" + + voyager_demo_round(max_z, 4).to_string() + + " at spot " + + max_spot.to_string() + + " (" + + getis.classifications[max_spot] + + ")", + ) + + // ----------------------------------------------------------------------- + // 5. Bivariate Lee's L + // ----------------------------------------------------------------------- + println("\n5. Bivariate Lee's L (gene_gradient vs gene_anti)") + let lees = @src.voyager_lees_l( + gradient, + anti, + knn, + permutations=199, + seed=20240501, + fdr_threshold=0.1, + ) catch { + VoyagerError(message) => abort("Lee's L failed: " + message) + } + voyager_demo_print_row("global Lee's L", lees.global_l) + + // ----------------------------------------------------------------------- + // 6. Empirical variogram and spherical model fit + // ----------------------------------------------------------------------- + println("\n6. Empirical variogram and spherical model fit (gene_hotspot)") + let empirical = @src.voyager_empirical_variogram(coords, hotspot, n_lags=8) catch { + VoyagerError(message) => abort("empirical variogram failed: " + message) + } + println(" empirical points=" + empirical.length().to_string()) + let model = @src.voyager_fit_variogram(empirical, model_type="spherical") catch { + VoyagerError(message) => abort("variogram fit failed: " + message) + } + println( + " spherical: nugget=" + + voyager_demo_round(model.nugget, 4).to_string() + + ", sill=" + + voyager_demo_round(model.sill, 4).to_string() + + ", range=" + + voyager_demo_round(model.range, 4).to_string() + + ", SSE=" + + voyager_demo_round(model.fitted_sse, 4).to_string(), + ) + voyager_demo_print_row( + "variogram predicted semivariance at range", + @src.voyager_variogram_predict(model, model.range), + ) + + // ----------------------------------------------------------------------- + // 7. Moran correlogram + // ----------------------------------------------------------------------- + println("\n7. Moran correlogram over distance bins") + let corr = @src.voyager_correlogram(coords, gradient, n_lags=5) catch { + VoyagerError(message) => abort("correlogram failed: " + message) + } + println(" bins=" + corr.length().to_string()) + for point in corr { + println( + " lag=" + + voyager_demo_round(point.lag, 3).to_string() + + ", Moran's I=" + + voyager_demo_round(point.morans_i, 4).to_string() + + ", npairs=" + + point.npairs.to_string(), + ) + } + + // ----------------------------------------------------------------------- + // 8. Immutable SpatialExperiment write-back + // ----------------------------------------------------------------------- + println("\n8. Immutable SpatialExperiment write-back") + let output = @src.voyager_run_univariate_sfe( + se, + [0, 1], + assay_name="logcounts", + stat_method="moran", + permutations=99, + seed=2024, + fdr_threshold=0.1, + output_prefix="voyager", + ) catch { + VoyagerError(message) => + abort("Voyager SpatialExperiment integration failed: " + message) + } + println( + " features analyzed=" + + output.results.length().to_string() + + ", method=" + + output.results[0].stat_method, + ) + println( + " input unchanged: " + + (!se.col_data[0].contains("voyager.moran.local.gene_gradient")).to_string(), + ) + println( + " output colData carries local Moran: " + + output.experiment.col_data[0] + .contains("voyager.moran.local.gene_gradient") + .to_string(), + ) + println( + " metadata method=" + + output.experiment.metadata["voyager.method"] + + ", n_features=" + + output.experiment.metadata["voyager.n_features"], + ) + println("=== Demo Complete ===") +} diff --git a/examples/voyager_demo/moon.pkg b/examples/voyager_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/voyager_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/abi.mbt b/src/abi.mbt index 2ca30206..0addc721 100644 --- a/src/abi.mbt +++ b/src/abi.mbt @@ -245,15 +245,27 @@ pub fn AbiTrace::quality_at(self : AbiTrace, index : Int) -> Int { ///| /// Format an ABIF date as "YYYY-MM-DD". pub fn AbiDate::to_string(self : AbiDate) -> String { - let m = if self.month < 10 { "0" + self.month.to_string() } else { self.month.to_string() } - let d = if self.day < 10 { "0" + self.day.to_string() } else { self.day.to_string() } + let m = if self.month < 10 { + "0" + self.month.to_string() + } else { + self.month.to_string() + } + let d = if self.day < 10 { + "0" + self.day.to_string() + } else { + self.day.to_string() + } self.year.to_string() + "-" + m + "-" + d } ///| /// Format an ABIF time as "HH:MM:SS". pub fn AbiTime::to_string(self : AbiTime) -> String { - let h = if self.hours < 10 { "0" + self.hours.to_string() } else { self.hours.to_string() } + let h = if self.hours < 10 { + "0" + self.hours.to_string() + } else { + self.hours.to_string() + } let mi = if self.minutes < 10 { "0" + self.minutes.to_string() } else { @@ -275,7 +287,10 @@ fn abi_read_u32(bytes : Array[Int], pos : Int) -> Int { if pos + 3 >= bytes.length() { return 0 } - bytes[pos] * 16777216 + bytes[pos + 1] * 65536 + bytes[pos + 2] * 256 + bytes[pos + 3] + bytes[pos] * 16777216 + + bytes[pos + 1] * 65536 + + bytes[pos + 2] * 256 + + bytes[pos + 3] } ///| @@ -428,10 +443,7 @@ fn abi_find_entry( ///| /// Read raw data bytes for a directory entry from the file bytes. -fn abi_read_entry_data( - bytes : Array[Int], - entry : AbiDirEntry, -) -> Array[Int] { +fn abi_read_entry_data(bytes : Array[Int], entry : AbiDirEntry) -> Array[Int] { let data : Array[Int] = Array::new() // If data fits inline (data_size <= 4), use inline_data if entry.data_size <= 4 { @@ -459,10 +471,7 @@ fn abi_read_entry_data( ///| /// Read trace data (array of Int) for a directory entry. /// Trace data is typically 2-byte (word) values. -fn abi_read_trace_data( - bytes : Array[Int], - entry : AbiDirEntry, -) -> Array[Int] { +fn abi_read_trace_data(bytes : Array[Int], entry : AbiDirEntry) -> Array[Int] { let data : Array[Int] = Array::new() let raw = abi_read_entry_data(bytes, entry) // If element type is word (3) or short (4), read as 2-byte values @@ -492,10 +501,7 @@ fn abi_read_trace_data( ///| /// Read integer array data for a directory entry (e.g., base positions). -fn abi_read_int_array( - bytes : Array[Int], - entry : AbiDirEntry, -) -> Array[Int] { +fn abi_read_int_array(bytes : Array[Int], entry : AbiDirEntry) -> Array[Int] { let data : Array[Int] = Array::new() let raw = abi_read_entry_data(bytes, entry) // For PLOC (base positions), element type is short (4), size 2 diff --git a/src/ace.mbt b/src/ace.mbt index 2f0e716d..7cb075c8 100644 --- a/src/ace.mbt +++ b/src/ace.mbt @@ -260,9 +260,7 @@ pub fn ace_parse(content : String) -> AceData { reads_map[r.read_id] = r i = ace_skip_read_block(lines, i) } - None => { - i = i + 1 - } + None => i = i + 1 } continue } @@ -274,9 +272,7 @@ pub fn ace_parse(content : String) -> AceData { contigs.push(contig) i = new_idx } - None => { - i = i + 1 - } + None => i = i + 1 } continue } @@ -301,7 +297,7 @@ pub fn ace_parse_reads(content : String) -> Array[AceRead] { let read = ace_parse_read_block(lines, i) match read { Some(r) => reads.push(r) - None => { () } + None => () } i = ace_skip_read_block(lines, i) } else { @@ -330,9 +326,7 @@ pub fn ace_parse_contigs(content : String) -> Array[AceContig] { reads_map[r.read_id] = r i = ace_skip_read_block(lines, i) } - None => { - i = i + 1 - } + None => i = i + 1 } } else if trimmed.has_prefix("CT ") { let contig_and_new_idx = ace_parse_contig_block(lines, i, reads_map) @@ -341,9 +335,7 @@ pub fn ace_parse_contigs(content : String) -> Array[AceContig] { contigs.push(contig) i = new_idx } - None => { - i = i + 1 - } + None => i = i + 1 } } else { i = i + 1 @@ -354,10 +346,7 @@ pub fn ace_parse_contigs(content : String) -> Array[AceContig] { ///| /// Parse a single RD block starting at the given line index. -fn ace_parse_read_block( - lines : Array[String], - start_idx : Int, -) -> AceRead? { +fn ace_parse_read_block(lines : Array[String], start_idx : Int) -> AceRead? { if start_idx >= lines.length() { return None } @@ -394,7 +383,8 @@ fn ace_parse_read_block( } if (first_char >= 'A'.to_int() && first_char <= 'Z'.to_int()) || (first_char >= 'a'.to_int() && first_char <= 'z'.to_int()) || - first_char == '-'.to_int() || first_char == '.'.to_int() { + first_char == '-'.to_int() || + first_char == '.'.to_int() { let remaining = read_len - sequence.length() let chunk = if trimmed.length() > remaining { trimmed[0:remaining].to_owned() @@ -412,17 +402,11 @@ fn ace_parse_read_block( let (quality, new_idx) = ace_parse_quality_lines(lines, idx, read_len) idx = new_idx - Some(AceRead::new( - read_id, - sequence, - quality, - 1, - read_len, - "+", - "", - chemistry, - dye, - )) + Some( + AceRead::new( + read_id, sequence, quality, 1, read_len, "+", "", chemistry, dye, + ), + ) } ///| @@ -454,12 +438,13 @@ fn ace_skip_read_block(lines : Array[String], start_idx : Int) -> Int { idx = idx + 1 break } - if (first_char >= '0'.to_int() && first_char <= '9'.to_int()) { + if first_char >= '0'.to_int() && first_char <= '9'.to_int() { break } if (first_char >= 'A'.to_int() && first_char <= 'Z'.to_int()) || (first_char >= 'a'.to_int() && first_char <= 'z'.to_int()) || - first_char == '-'.to_int() || first_char == '.'.to_int() { + first_char == '-'.to_int() || + first_char == '.'.to_int() { seq_chars = seq_chars + trimmed.length() idx = idx + 1 } else { @@ -528,7 +513,8 @@ fn ace_parse_contig_block( } if (first_char >= 'A'.to_int() && first_char <= 'Z'.to_int()) || (first_char >= 'a'.to_int() && first_char <= 'z'.to_int()) || - first_char == '-'.to_int() || first_char == '.'.to_int() { + first_char == '-'.to_int() || + first_char == '.'.to_int() { let remaining = contig_len - sequence.length() let chunk = if trimmed.length() > remaining { trimmed[0:remaining].to_owned() @@ -543,12 +529,17 @@ fn ace_parse_contig_block( } // Parse base qualities - let (base_qualities, new_idx) = ace_parse_quality_lines(lines, idx, contig_len) + let (base_qualities, new_idx) = ace_parse_quality_lines( + lines, idx, contig_len, + ) idx = new_idx // Parse AF alignment lines let reads : Array[AceRead] = Array::new() - let alignment_positions : Map[String, (Int, Int, Int, Int, Int, Int, String)] = Map([], capacity=32) + let alignment_positions : Map[String, (Int, Int, Int, Int, Int, Int, String)] = Map( + [], + capacity=32, + ) while idx < lines.length() { let line = lines[idx].to_string() @@ -571,13 +562,7 @@ fn ace_parse_contig_block( let strand = if af_tokens.length() >= 9 { af_tokens[8] } else { "+" } alignment_positions[read_name] = ( - contig_start, - contig_end, - read_start, - read_end, - qual_start, - qual_end, - strand, + contig_start, contig_end, read_start, read_end, qual_start, qual_end, strand, ) } idx = idx + 1 @@ -640,17 +625,12 @@ fn ace_parse_contig_block( ri = ri + 1 } - Some(( - AceContig::new( - contig_name, - sequence, - reads, - base_qualities, - "", - false, + Some( + ( + AceContig::new(contig_name, sequence, reads, base_qualities, "", false), + idx, ), - idx, - )) + ) } // ===== Serialization ===== @@ -784,7 +764,11 @@ pub fn ace_read_coverage(contig : AceContig) -> Map[Int, Int] { let read = contig.reads[ri] let start = if read.clip_start > 0 { read.clip_start } else { 1 } let end = if read.clip_end > 0 { - if read.clip_end > contig.length { contig.length } else { read.clip_end } + if read.clip_end > contig.length { + contig.length + } else { + read.clip_end + } } else { contig.length } @@ -839,19 +823,20 @@ pub fn ace_contig_gc_content(contig : AceContig) -> Double { /// Create sample ACE content for testing. pub fn sample_ace_content() -> String { "AF contig1 60\n" + - "RD read1 60 chemistry1 dye1\n" + - "ATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCG\n" + - "q 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30\n" + - "RD read2 60 chemistry2 dye2\n" + - "GCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTA\n" + - "q 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25\n" + - "CT contig1 60 0 60\n" + - "ATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCG\n" + - "q 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40\n" + - "AF read1 1 60 1 60 1 60 +\n" + - "AF read2 1 60 1 60 1 60 -\n" + "RD read1 60 chemistry1 dye1\n" + + "ATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCG\n" + + "q 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30\n" + + "RD read2 60 chemistry2 dye2\n" + + "GCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTA\n" + + "q 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25\n" + + "CT contig1 60 0 60\n" + + "ATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCG\n" + + "q 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40\n" + + "AF read1 1 60 1 60 1 60 +\n" + + "AF read2 1 60 1 60 1 60 -\n" } +///| pub fn sample_ace_data() -> AceData { ace_parse(sample_ace_content()) -} \ No newline at end of file +} diff --git a/src/aldex2.mbt b/src/aldex2.mbt index fbb3c849..c95c961e 100644 --- a/src/aldex2.mbt +++ b/src/aldex2.mbt @@ -716,10 +716,7 @@ pub fn aldex2_clr( config } let denominators = aldex2_denominators( - filtered_counts, - group_indices, - conditions, - denominator_config, + filtered_counts, group_indices, conditions, denominator_config, ) let feature_count = filtered_counts.length() let dirichlet : Array[Array[Array[Double]]] = [] diff --git a/src/align_abstract.mbt b/src/align_abstract.mbt index 3f1160dc..7491f610 100644 --- a/src/align_abstract.mbt +++ b/src/align_abstract.mbt @@ -54,8 +54,12 @@ pub fn AbstractAlignment::new( let n_seqs = sequences.length() let alignment_length = if n_seqs > 0 { sequences[0].length() } else { 0 } AbstractAlignment::{ - sequences, identifiers, alignment_type, - validated: false, n_seqs, alignment_length + sequences, + identifiers, + alignment_type, + validated: false, + n_seqs, + alignment_length, } } @@ -88,7 +92,9 @@ pub fn AbstractAlignment::validate(self : AbstractAlignment) -> (Bool, String) { ///| /// Validate characters in the alignment. -pub fn AbstractAlignment::validate_characters(self : AbstractAlignment) -> (Bool, String) { +pub fn AbstractAlignment::validate_characters( + self : AbstractAlignment, +) -> (Bool, String) { let valid_chars = get_valid_chars(self.alignment_type) let mut seq_idx = 0 @@ -101,7 +107,12 @@ pub fn AbstractAlignment::validate_characters(self : AbstractAlignment) -> (Bool let ch = c.to_string() let pos = i.to_string() let id = self.identifiers[seq_idx] - let msg = "Invalid character " + ch + " at position " + pos + " in sequence " + id + let msg = "Invalid character " + + ch + + " at position " + + pos + + " in sequence " + + id return (false, msg) } i = i + 1 @@ -111,25 +122,20 @@ pub fn AbstractAlignment::validate_characters(self : AbstractAlignment) -> (Bool (true, "") } +///| fn get_valid_chars(align_type : AlignAbstractType) -> Array[UInt16] { let nucleotide_chars : Array[UInt16] = [ - 65, 84, 71, 67, 85, 78, 45, 46, - 82, 89, 83, 87, 75, 77, 66, 86, 68, 72 + 65, 84, 71, 67, 85, 78, 45, 46, 82, 89, 83, 87, 75, 77, 66, 86, 68, 72, ] let protein_chars : Array[UInt16] = [ - 65, 82, 78, 68, 67, 81, 69, 71, 72, 73, - 76, 75, 77, 70, 80, 83, 84, 87, 89, 86, - 66, 90, 88, 45, 46, 85, 79 + 65, 82, 78, 68, 67, 81, 69, 71, 72, 73, 76, 75, 77, 70, 80, 83, 84, 87, 89, 86, + 66, 90, 88, 45, 46, 85, 79, ] let generic_chars : Array[UInt16] = [ - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 45, 46, 42 + 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 46, 42, ] match align_type { @@ -139,14 +145,25 @@ fn get_valid_chars(align_type : AlignAbstractType) -> Array[UInt16] { } } +///| fn char_to_upper(c : UInt16) -> UInt16 { - if c >= 97 && c <= 122 { c - 32 } else { c } + if c >= 97 && c <= 122 { + c - 32 + } else { + c + } } +///| fn char_to_lower(c : UInt16) -> UInt16 { - if c >= 65 && c <= 90 { c + 32 } else { c } + if c >= 65 && c <= 90 { + c + 32 + } else { + c + } } +///| /// Convert a UInt16 character code to its 1-character String representation. fn u16_to_str(c : UInt16) -> String { match c { @@ -221,6 +238,7 @@ fn u16_to_str(c : UInt16) -> String { } } +///| fn char_in_array(c : UInt16, arr : Array[UInt16]) -> Bool { for ch in arr { if ch == c { @@ -238,13 +256,18 @@ pub fn AbstractAlignment::abstract_n_seqs(self : AbstractAlignment) -> Int { ///| /// Get alignment length. -pub fn AbstractAlignment::abstract_alignment_length(self : AbstractAlignment) -> Int { +pub fn AbstractAlignment::abstract_alignment_length( + self : AbstractAlignment, +) -> Int { self.alignment_length } ///| /// Get a sequence by index. -pub fn AbstractAlignment::abstract_get_seq(self : AbstractAlignment, idx : Int) -> String { +pub fn AbstractAlignment::abstract_get_seq( + self : AbstractAlignment, + idx : Int, +) -> String { if idx >= 0 && idx < self.n_seqs { self.sequences[idx] } else { @@ -254,7 +277,10 @@ pub fn AbstractAlignment::abstract_get_seq(self : AbstractAlignment, idx : Int) ///| /// Get sequence identifier by index. -pub fn AbstractAlignment::abstract_get_id(self : AbstractAlignment, idx : Int) -> String { +pub fn AbstractAlignment::abstract_get_id( + self : AbstractAlignment, + idx : Int, +) -> String { if idx >= 0 && idx < self.n_seqs { self.identifiers[idx] } else { @@ -264,7 +290,10 @@ pub fn AbstractAlignment::abstract_get_id(self : AbstractAlignment, idx : Int) - ///| /// Get a column from the alignment (array of characters). -pub fn AbstractAlignment::abstract_get_column(self : AbstractAlignment, col_idx : Int) -> Array[UInt16] { +pub fn AbstractAlignment::abstract_get_column( + self : AbstractAlignment, + col_idx : Int, +) -> Array[UInt16] { let column : Array[UInt16] = Array::new() if col_idx >= 0 && col_idx < self.alignment_length { for seq in self.sequences { @@ -276,7 +305,9 @@ pub fn AbstractAlignment::abstract_get_column(self : AbstractAlignment, col_idx ///| /// Get the alignment type. -pub fn AbstractAlignment::abstract_type(self : AbstractAlignment) -> AlignAbstractType { +pub fn AbstractAlignment::abstract_type( + self : AbstractAlignment, +) -> AlignAbstractType { self.alignment_type } @@ -295,13 +326,20 @@ pub struct AlignAbstractColumnStats { ///| /// Compute column statistics for a given alignment column. -pub fn abstract_column_stats(alignment : AbstractAlignment, col_idx : Int) -> AlignAbstractColumnStats { +pub fn abstract_column_stats( + alignment : AbstractAlignment, + col_idx : Int, +) -> AlignAbstractColumnStats { let column = alignment.abstract_get_column(col_idx) let n = column.length() if n == 0 { return AlignAbstractColumnStats::{ - column_index: col_idx, conservation: 0.0, diversity: 0.0, - gap_fraction: 0.0, n_unique_chars: 0, consensus_char: 45 + column_index: col_idx, + conservation: 0.0, + diversity: 0.0, + gap_fraction: 0.0, + n_unique_chars: 0, + consensus_char: 45, } } @@ -357,13 +395,15 @@ pub fn abstract_column_stats(alignment : AbstractAlignment, col_idx : Int) -> Al diversity: entropy, gap_fraction, n_unique_chars: counts.length(), - consensus_char: consensus + consensus_char: consensus, } } ///| /// Get an array of all column statistics for the alignment. -pub fn abstract_all_column_stats(alignment : AbstractAlignment) -> Array[AlignAbstractColumnStats] { +pub fn abstract_all_column_stats( + alignment : AbstractAlignment, +) -> Array[AlignAbstractColumnStats] { let stats : Array[AlignAbstractColumnStats] = Array::new() let mut i = 0 while i < alignment.alignment_length { @@ -375,7 +415,10 @@ pub fn abstract_all_column_stats(alignment : AbstractAlignment) -> Array[AlignAb ///| /// Get the consensus sequence of the alignment (using most common character per column). -pub fn abstract_consensus_sequence(alignment : AbstractAlignment, threshold? : Double = 0.5) -> String { +pub fn abstract_consensus_sequence( + alignment : AbstractAlignment, + threshold? : Double = 0.5, +) -> String { let mut consensus = "" let mut i = 0 while i < alignment.alignment_length { @@ -392,7 +435,9 @@ pub fn abstract_consensus_sequence(alignment : AbstractAlignment, threshold? : D ///| /// Calculate sequence identity matrix (pairwise). -pub fn abstract_identity_matrix(alignment : AbstractAlignment) -> Array[Array[Double]] { +pub fn abstract_identity_matrix( + alignment : AbstractAlignment, +) -> Array[Array[Double]] { let n = alignment.n_seqs let matrix : Array[Array[Double]] = Array::new() let mut i = 0 @@ -400,7 +445,10 @@ pub fn abstract_identity_matrix(alignment : AbstractAlignment) -> Array[Array[Do let row : Array[Double] = Array::new() let mut j = 0 while j < n { - let identity = seq_identity(alignment.sequences[i], alignment.sequences[j]) + let identity = seq_identity( + alignment.sequences[i], + alignment.sequences[j], + ) row.push(identity) j = j + 1 } @@ -410,6 +458,7 @@ pub fn abstract_identity_matrix(alignment : AbstractAlignment) -> Array[Array[Do matrix } +///| fn seq_identity(seq1 : String, seq2 : String) -> Double { if seq1.length() != seq2.length() { return 0.0 @@ -493,6 +542,7 @@ pub fn abstract_parsimony_sites(alignment : AbstractAlignment) -> Int { count } +///| fn is_parsimony_informative(alignment : AbstractAlignment, col : Int) -> Bool { let column = alignment.abstract_get_column(col) let counts : Map[UInt16, Int] = Map([], capacity=20) @@ -529,6 +579,7 @@ pub fn abstract_variable_sites(alignment : AbstractAlignment) -> Int { count } +///| fn is_variable_site(alignment : AbstractAlignment, col : Int) -> Bool { let column = alignment.abstract_get_column(col) if column.length() == 0 { @@ -557,6 +608,7 @@ pub fn abstract_singleton_sites(alignment : AbstractAlignment) -> Int { count } +///| fn is_singleton_site(alignment : AbstractAlignment, col : Int) -> Bool { let column = alignment.abstract_get_column(col) let counts : Map[UInt16, Int] = Map([], capacity=20) @@ -588,7 +640,9 @@ fn is_singleton_site(alignment : AbstractAlignment, col : Int) -> Bool { ///| /// Calculate alignment distance matrix (using simple p-distance). -pub fn abstract_distance_matrix(alignment : AbstractAlignment) -> Array[Array[Double]] { +pub fn abstract_distance_matrix( + alignment : AbstractAlignment, +) -> Array[Array[Double]] { let n = alignment.n_seqs let matrix : Array[Array[Double]] = Array::new() let mut i = 0 @@ -596,7 +650,10 @@ pub fn abstract_distance_matrix(alignment : AbstractAlignment) -> Array[Array[Do let row : Array[Double] = Array::new() let mut j = 0 while j < n { - let dist = pairwise_distance(alignment.sequences[i], alignment.sequences[j]) + let dist = pairwise_distance( + alignment.sequences[i], + alignment.sequences[j], + ) row.push(dist) j = j + 1 } @@ -606,6 +663,7 @@ pub fn abstract_distance_matrix(alignment : AbstractAlignment) -> Array[Array[Do matrix } +///| fn pairwise_distance(seq1 : String, seq2 : String) -> Double { if seq1.length() != seq2.length() { return 1.0 @@ -629,7 +687,10 @@ fn pairwise_distance(seq1 : String, seq2 : String) -> Double { ///| /// Filter alignment columns by gap fraction. -pub fn abstract_filter_gaps(alignment : AbstractAlignment, max_gap_fraction : Double) -> AbstractAlignment { +pub fn abstract_filter_gaps( + alignment : AbstractAlignment, + max_gap_fraction : Double, +) -> AbstractAlignment { let keep_columns : Array[Int] = Array::new() let mut col = 0 while col < alignment.alignment_length { @@ -655,12 +716,19 @@ pub fn abstract_filter_gaps(alignment : AbstractAlignment, max_gap_fraction : Do seq_idx = seq_idx + 1 } - AbstractAlignment::new(sequences=new_seqs, identifiers=alignment.identifiers.copy(), alignment_type=alignment.alignment_type) + AbstractAlignment::new( + sequences=new_seqs, + identifiers=alignment.identifiers.copy(), + alignment_type=alignment.alignment_type, + ) } ///| /// Filter alignment sequences by minimum coverage. -pub fn abstract_filter_coverage(alignment : AbstractAlignment, min_coverage : Double) -> AbstractAlignment { +pub fn abstract_filter_coverage( + alignment : AbstractAlignment, + min_coverage : Double, +) -> AbstractAlignment { let keep_seqs : Array[Int] = Array::new() let mut idx = 0 while idx < alignment.n_seqs { @@ -688,14 +756,26 @@ pub fn abstract_filter_coverage(alignment : AbstractAlignment, min_coverage : Do new_ids.push(alignment.identifiers[idx2]) } - AbstractAlignment::new(sequences=new_seqs, identifiers=new_ids, alignment_type=alignment.alignment_type) + AbstractAlignment::new( + sequences=new_seqs, + identifiers=new_ids, + alignment_type=alignment.alignment_type, + ) } ///| /// Trim alignment to include only the region between start and end columns. -pub fn abstract_trim(alignment : AbstractAlignment, start : Int, end : Int) -> AbstractAlignment { +pub fn abstract_trim( + alignment : AbstractAlignment, + start : Int, + end : Int, +) -> AbstractAlignment { let s = if start > 0 { start } else { 0 } - let e = if end < alignment.alignment_length - 1 { end } else { alignment.alignment_length - 1 } + let e = if end < alignment.alignment_length - 1 { + end + } else { + alignment.alignment_length - 1 + } let new_seqs : Array[String] = Array::new() for seq in alignment.sequences { @@ -703,7 +783,11 @@ pub fn abstract_trim(alignment : AbstractAlignment, start : Int, end : Int) -> A new_seqs.push(trimmed) } - AbstractAlignment::new(sequences=new_seqs, identifiers=alignment.identifiers.copy(), alignment_type=alignment.alignment_type) + AbstractAlignment::new( + sequences=new_seqs, + identifiers=alignment.identifiers.copy(), + alignment_type=alignment.alignment_type, + ) } ///| @@ -720,16 +804,33 @@ pub fn abstract_summary(alignment : AbstractAlignment) -> String { let tstr = alignment_type_str(alignment.alignment_type) "Alignment Summary:\n" + - " Sequences: " + n_seqs + "\n" + - " Length: " + alen + "\n" + - " Type: " + tstr + "\n" + - " Valid: " + vstr + "\n" + - " Coverage: " + coverage + "\n" + - " Overall identity: " + identity + "\n" + - " Variable sites: " + variable + "\n" + - " Parsimony-informative sites: " + parsimony + "\n" + " Sequences: " + + n_seqs + + "\n" + + " Length: " + + alen + + "\n" + + " Type: " + + tstr + + "\n" + + " Valid: " + + vstr + + "\n" + + " Coverage: " + + coverage + + "\n" + + " Overall identity: " + + identity + + "\n" + + " Variable sites: " + + variable + + "\n" + + " Parsimony-informative sites: " + + parsimony + + "\n" } +///| pub fn alignment_type_str(t : AlignAbstractType) -> String { match t { AlignAbstractType::Nucleotide => "Nucleotide" diff --git a/src/align_analysis.mbt b/src/align_analysis.mbt index 1ca5b877..8cc56540 100644 --- a/src/align_analysis.mbt +++ b/src/align_analysis.mbt @@ -22,56 +22,67 @@ pub fn AlnAnalysisResult::new( dn_ds_ratio : Double, dn_ds_ratio_sem : Double, n_synonymous : Int, - n_nonsynonymous : Int + n_nonsynonymous : Int, ) -> AlnAnalysisResult { - AlnAnalysisResult::{ dn, ds, dn_ds_ratio, dn_ds_ratio_sem, n_synonymous, n_nonsynonymous } + AlnAnalysisResult::{ + dn, + ds, + dn_ds_ratio, + dn_ds_ratio_sem, + n_synonymous, + n_nonsynonymous, + } } ///| /// Get dn (non-synonymous substitution rate). -pub fn aln_get_dn(self : AlnAnalysisResult) -> Double { +pub fn AlnAnalysisResult::aln_get_dn(self : AlnAnalysisResult) -> Double { self.dn } ///| /// Get ds (synonymous substitution rate). -pub fn aln_get_ds(self : AlnAnalysisResult) -> Double { +pub fn AlnAnalysisResult::aln_get_ds(self : AlnAnalysisResult) -> Double { self.ds } ///| /// Get dn/ds ratio (omega). -pub fn aln_get_ratio(self : AlnAnalysisResult) -> Double { +pub fn AlnAnalysisResult::aln_get_ratio(self : AlnAnalysisResult) -> Double { self.dn_ds_ratio } ///| /// Get standard error of mean for dn/ds ratio. -pub fn aln_get_ratio_sem(self : AlnAnalysisResult) -> Double { +pub fn AlnAnalysisResult::aln_get_ratio_sem(self : AlnAnalysisResult) -> Double { self.dn_ds_ratio_sem } ///| /// Get number of synonymous substitutions. -pub fn aln_get_n_syn(self : AlnAnalysisResult) -> Int { +pub fn AlnAnalysisResult::aln_get_n_syn(self : AlnAnalysisResult) -> Int { self.n_synonymous } ///| /// Get number of non-synonymous substitutions. -pub fn aln_get_n_nonsyn(self : AlnAnalysisResult) -> Int { +pub fn AlnAnalysisResult::aln_get_n_nonsyn(self : AlnAnalysisResult) -> Int { self.n_nonsynonymous } ///| /// Check if the result indicates positive selection (omega > 1). -pub fn aln_has_positive_selection(self : AlnAnalysisResult) -> Bool { +pub fn AlnAnalysisResult::aln_has_positive_selection( + self : AlnAnalysisResult, +) -> Bool { self.dn_ds_ratio > 1.0 } ///| /// Check if the result indicates purifying selection (omega < 1). -pub fn aln_has_purifying_selection(self : AlnAnalysisResult) -> Bool { +pub fn AlnAnalysisResult::aln_has_purifying_selection( + self : AlnAnalysisResult, +) -> Bool { self.dn_ds_ratio < 1.0 } @@ -79,31 +90,57 @@ pub fn aln_has_purifying_selection(self : AlnAnalysisResult) -> Bool { /// Simple genetic code table (standard code 1). /// Returns amino acid for a codon. pub fn aln_aa_from_codon(codon : String) -> String { - if codon == "TTT" || codon == "TTC" { "F" } - else if codon == "TTA" || codon == "TTG" { "L" } - else if codon == "CTT" || codon == "CTC" || codon == "CTA" || codon == "CTG" { "L" } - else if codon == "ATT" || codon == "ATC" || codon == "ATA" { "I" } - else if codon == "ATG" { "M" } - else if codon == "GTT" || codon == "GTC" || codon == "GTA" || codon == "GTG" { "V" } - else if codon == "TCT" || codon == "TCC" || codon == "TCA" || codon == "TCG" { "S" } - else if codon == "CCT" || codon == "CCC" || codon == "CCA" || codon == "CCG" { "P" } - else if codon == "ACT" || codon == "ACC" || codon == "ACA" || codon == "ACG" { "T" } - else if codon == "GCT" || codon == "GCC" || codon == "GCA" || codon == "GCG" { "A" } - else if codon == "TAT" || codon == "TAC" { "Y" } - else if codon == "TAA" || codon == "TAG" || codon == "TGA" { "*" } - else if codon == "CAT" || codon == "CAC" { "H" } - else if codon == "CAA" || codon == "CAG" { "Q" } - else if codon == "AAT" || codon == "AAC" { "N" } - else if codon == "AAA" || codon == "AAG" { "K" } - else if codon == "GAT" || codon == "GAC" { "D" } - else if codon == "GAA" || codon == "GAG" { "E" } - else if codon == "TGT" || codon == "TGC" { "C" } - else if codon == "TGG" { "W" } - else if codon == "CGT" || codon == "CGC" || codon == "CGA" || codon == "CGG" { "R" } - else if codon == "AGT" || codon == "AGC" { "S" } - else if codon == "AGA" || codon == "AGG" { "R" } - else if codon == "GGT" || codon == "GGC" || codon == "GGA" || codon == "GGG" { "G" } - else { "?" } + if codon == "TTT" || codon == "TTC" { + "F" + } else if codon == "TTA" || codon == "TTG" { + "L" + } else if codon == "CTT" || codon == "CTC" || codon == "CTA" || codon == "CTG" { + "L" + } else if codon == "ATT" || codon == "ATC" || codon == "ATA" { + "I" + } else if codon == "ATG" { + "M" + } else if codon == "GTT" || codon == "GTC" || codon == "GTA" || codon == "GTG" { + "V" + } else if codon == "TCT" || codon == "TCC" || codon == "TCA" || codon == "TCG" { + "S" + } else if codon == "CCT" || codon == "CCC" || codon == "CCA" || codon == "CCG" { + "P" + } else if codon == "ACT" || codon == "ACC" || codon == "ACA" || codon == "ACG" { + "T" + } else if codon == "GCT" || codon == "GCC" || codon == "GCA" || codon == "GCG" { + "A" + } else if codon == "TAT" || codon == "TAC" { + "Y" + } else if codon == "TAA" || codon == "TAG" || codon == "TGA" { + "*" + } else if codon == "CAT" || codon == "CAC" { + "H" + } else if codon == "CAA" || codon == "CAG" { + "Q" + } else if codon == "AAT" || codon == "AAC" { + "N" + } else if codon == "AAA" || codon == "AAG" { + "K" + } else if codon == "GAT" || codon == "GAC" { + "D" + } else if codon == "GAA" || codon == "GAG" { + "E" + } else if codon == "TGT" || codon == "TGC" { + "C" + } else if codon == "TGG" { + "W" + } else if codon == "CGT" || codon == "CGC" || codon == "CGA" || codon == "CGG" { + "R" + } else if codon == "AGT" || codon == "AGC" { + "S" + } else if codon == "AGA" || codon == "AGG" { + "R" + } else if codon == "GGT" || codon == "GGC" || codon == "GGA" || codon == "GGG" { + "G" + } else { + "?" + } } ///| @@ -111,7 +148,11 @@ pub fn aln_aa_from_codon(codon : String) -> String { /// Returns true if the substitution is synonymous (doesn't change amino acid). pub fn aln_is_synonymous(codon : String, pos : Int, new_base : String) -> Bool { let first_part = if pos > 0 { substring(codon, 0, pos) } else { "" } - let second_part = if pos < 2 { substring(codon, pos + 1, 3 - pos - 1) } else { "" } + let second_part = if pos < 2 { + substring(codon, pos + 1, 3 - pos - 1) + } else { + "" + } let new_codon = first_part + new_base + second_part let old_aa = aln_aa_from_codon(codon) let new_aa = aln_aa_from_codon(new_codon) @@ -123,17 +164,17 @@ pub fn aln_is_synonymous(codon : String, pos : Int, new_base : String) -> Bool { pub fn aln_count_sites(sequence : String) -> Array[Int] { let seq_len = sequence.length() let n_codons = seq_len / 3 - + let mut n_syn = 0 let mut n_nonsyn = 0 - + let bases = ["A", "C", "G", "T"] - + let mut codon_idx = 0 while codon_idx < n_codons { let codon_start = codon_idx * 3 let codon = substring(sequence, codon_start, 3) - + // Check each position in the codon let mut pos = 0 while pos < 3 { @@ -154,7 +195,7 @@ pub fn aln_count_sites(sequence : String) -> Array[Int] { } codon_idx = codon_idx + 1 } - + // Each site has 3 possible changes (excluding the original), so divide by 3 let sites = [n_syn / 3, n_nonsyn / 3] sites @@ -164,32 +205,36 @@ pub fn aln_count_sites(sequence : String) -> Array[Int] { /// Calculate dn/ds ratio between two sequences using the NG86 method. /// Nei-Gojobori method for estimating dn and ds. pub fn aln_analyze_dn_ds(seq1 : String, seq2 : String) -> AlnAnalysisResult { - let len = if seq1.length() < seq2.length() { seq1.length() } else { seq2.length() } + let len = if seq1.length() < seq2.length() { + seq1.length() + } else { + seq2.length() + } let n_codons = len / 3 - + let sites = aln_count_sites(seq1) let total_syn_sites = sites[0].to_double() let total_nonsyn_sites = sites[1].to_double() - + if total_syn_sites == 0.0 || total_nonsyn_sites == 0.0 { return AlnAnalysisResult::new(0.0, 0.0, 0.0, 0.0, 0, 0) } - + let mut n_syn_changes = 0.0 let mut n_nonsyn_changes = 0.0 - + let mut codon_idx = 0 while codon_idx < n_codons { let codon_start = codon_idx * 3 let codon1 = substring(seq1, codon_start, 3) let codon2 = substring(seq2, codon_start, 3) - + // Check each position in the codon let mut pos = 0 while pos < 3 { let base1 = substring(codon1, pos, 1) let base2 = substring(codon2, pos, 1) - + if base1 != base2 { if aln_is_synonymous(codon1, pos, base2) { n_syn_changes = n_syn_changes + 1.0 @@ -201,47 +246,49 @@ pub fn aln_analyze_dn_ds(seq1 : String, seq2 : String) -> AlnAnalysisResult { } codon_idx = codon_idx + 1 } - + // Calculate rates let ds = if total_syn_sites > 0.0 { n_syn_changes / total_syn_sites } else { 0.0 } - + let dn = if total_nonsyn_sites > 0.0 { n_nonsyn_changes / total_nonsyn_sites } else { 0.0 } - + // Calculate ratio let ratio = if ds > 0.0 { dn / ds } else { 0.0 } - + // Calculate SEM (simplified) let variance = if total_syn_sites > 0.0 && total_nonsyn_sites > 0.0 { - (1.0 / total_syn_sites) + (1.0 / total_nonsyn_sites) + 1.0 / total_syn_sites + 1.0 / total_nonsyn_sites } else { 1.0 } let sem = ratio * variance.sqrt() - + AlnAnalysisResult::new( dn, ds, ratio, sem, n_syn_changes.to_int(), - n_nonsyn_changes.to_int() + n_nonsyn_changes.to_int(), ) } ///| /// Calculate dn/ds matrix for multiple sequence comparisons. -pub fn aln_calculate_dn_ds_matrix(sequences : Array[String]) -> Array[Array[AlnAnalysisResult]] { +pub fn aln_calculate_dn_ds_matrix( + sequences : Array[String], +) -> Array[Array[AlnAnalysisResult]] { let n = sequences.length() let matrix : Array[Array[AlnAnalysisResult]] = Array::new() - + let mut i = 0 while i < n { let row : Array[AlnAnalysisResult] = Array::new() @@ -262,7 +309,7 @@ pub fn aln_calculate_dn_ds_matrix(sequences : Array[String]) -> Array[Array[AlnA matrix.push(row) i = i + 1 } - + // Fill symmetric entries let mut x = 0 while x < n { @@ -273,15 +320,19 @@ pub fn aln_calculate_dn_ds_matrix(sequences : Array[String]) -> Array[Array[AlnA } x = x + 1 } - + matrix } ///| /// Calculate Jukes-Cantor distance between two sequences. pub fn aln_jukes_cantor_distance(seq1 : String, seq2 : String) -> Double { - let len = if seq1.length() < seq2.length() { seq1.length() } else { seq2.length() } - + let len = if seq1.length() < seq2.length() { + seq1.length() + } else { + seq2.length() + } + let mut diffs = 0 let mut i = 0 while i < len { @@ -290,13 +341,13 @@ pub fn aln_jukes_cantor_distance(seq1 : String, seq2 : String) -> Double { } i = i + 1 } - + let p = diffs.to_double() / len.to_double() if p >= 0.75 { // Distance is too large for JC correction 10.0 } else { - let arg = 1.0 - (4.0 / 3.0) * p + let arg = 1.0 - 4.0 / 3.0 * p if arg > 0.0 { -0.75 * @math.ln(arg) } else { @@ -308,20 +359,32 @@ pub fn aln_jukes_cantor_distance(seq1 : String, seq2 : String) -> Double { ///| /// Calculate Kimura 2-parameter distance. pub fn aln_kimura_2p_distance(seq1 : String, seq2 : String) -> Double { - let len = if seq1.length() < seq2.length() { seq1.length() } else { seq2.length() } - + let len = if seq1.length() < seq2.length() { + seq1.length() + } else { + seq2.length() + } + let mut transitions = 0 let mut transversions = 0 - + let mut i = 0 while i < len { let base1 = substring(seq1, i, 1) let base2 = substring(seq2, i, 1) - + if base1 != base2 { - let is_base1_purine = if base1 == "A" || base1 == "G" { true } else { false } - let is_base2_purine = if base2 == "A" || base2 == "G" { true } else { false } - + let is_base1_purine = if base1 == "A" || base1 == "G" { + true + } else { + false + } + let is_base2_purine = if base2 == "A" || base2 == "G" { + true + } else { + false + } + if is_base1_purine == is_base2_purine { // Same type (both purine or both pyrimidine) = transition transitions = transitions + 1 @@ -332,13 +395,13 @@ pub fn aln_kimura_2p_distance(seq1 : String, seq2 : String) -> Double { } i = i + 1 } - + let p = transitions.to_double() / len.to_double() let q = transversions.to_double() / len.to_double() - + let arg1 = 1.0 - 2.0 * p - q let arg2 = 1.0 - 2.0 * q - + if arg1 <= 0.0 || arg2 <= 0.0 { 10.0 } else { @@ -348,10 +411,12 @@ pub fn aln_kimura_2p_distance(seq1 : String, seq2 : String) -> Double { ///| /// Calculate distance matrix using Jukes-Cantor method. -pub fn aln_jukes_cantor_matrix(sequences : Array[String]) -> Array[Array[Double]] { +pub fn aln_jukes_cantor_matrix( + sequences : Array[String], +) -> Array[Array[Double]] { let n = sequences.length() let matrix : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let row : Array[Double] = Array::make(n, 0.0) @@ -364,7 +429,7 @@ pub fn aln_jukes_cantor_matrix(sequences : Array[String]) -> Array[Array[Double] matrix.push(row) i = i + 1 } - + // Fill symmetric part let mut x = 0 while x < n { @@ -375,7 +440,7 @@ pub fn aln_jukes_cantor_matrix(sequences : Array[String]) -> Array[Array[Double] } x = x + 1 } - + matrix } @@ -384,7 +449,7 @@ pub fn aln_jukes_cantor_matrix(sequences : Array[String]) -> Array[Array[Double] pub fn aln_kimura_2p_matrix(sequences : Array[String]) -> Array[Array[Double]] { let n = sequences.length() let matrix : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let row : Array[Double] = Array::make(n, 0.0) @@ -397,7 +462,7 @@ pub fn aln_kimura_2p_matrix(sequences : Array[String]) -> Array[Array[Double]] { matrix.push(row) i = i + 1 } - + // Fill symmetric part let mut x = 0 while x < n { @@ -408,15 +473,19 @@ pub fn aln_kimura_2p_matrix(sequences : Array[String]) -> Array[Array[Double]] { } x = x + 1 } - + matrix } ///| /// Calculate number of substitutions per site (simple p-distance). pub fn aln_p_distance(seq1 : String, seq2 : String) -> Double { - let len = if seq1.length() < seq2.length() { seq1.length() } else { seq2.length() } - + let len = if seq1.length() < seq2.length() { + seq1.length() + } else { + seq2.length() + } + let mut diffs = 0 let mut i = 0 while i < len { @@ -425,6 +494,6 @@ pub fn aln_p_distance(seq1 : String, seq2 : String) -> Double { } i = i + 1 } - + diffs.to_double() / len.to_double() } diff --git a/src/align_applications.mbt b/src/align_applications.mbt index e45734fc..65b1fc66 100644 --- a/src/align_applications.mbt +++ b/src/align_applications.mbt @@ -12,33 +12,63 @@ pub fn ClustalwCommandline::new(executable : String) -> ClustalwCommandline { } ///| -pub fn ClustalwCommandline::set_input(self : ClustalwCommandline, infile : String) -> ClustalwCommandline { - ClustalwCommandline::{ commandline: self.commandline.add_arg("-infile", Some(infile)) } +pub fn ClustalwCommandline::set_input( + self : ClustalwCommandline, + infile : String, +) -> ClustalwCommandline { + ClustalwCommandline::{ + commandline: self.commandline.add_arg("-infile", Some(infile)), + } } ///| -pub fn ClustalwCommandline::set_output(self : ClustalwCommandline, outfile : String) -> ClustalwCommandline { - ClustalwCommandline::{ commandline: self.commandline.add_arg("-outfile", Some(outfile)) } +pub fn ClustalwCommandline::set_output( + self : ClustalwCommandline, + outfile : String, +) -> ClustalwCommandline { + ClustalwCommandline::{ + commandline: self.commandline.add_arg("-outfile", Some(outfile)), + } } ///| -pub fn ClustalwCommandline::set_output_format(self : ClustalwCommandline, format : String) -> ClustalwCommandline { - ClustalwCommandline::{ commandline: self.commandline.add_arg("-output", Some(format)) } +pub fn ClustalwCommandline::set_output_format( + self : ClustalwCommandline, + format : String, +) -> ClustalwCommandline { + ClustalwCommandline::{ + commandline: self.commandline.add_arg("-output", Some(format)), + } } ///| -pub fn ClustalwCommandline::set_matrix(self : ClustalwCommandline, matrix : String) -> ClustalwCommandline { - ClustalwCommandline::{ commandline: self.commandline.add_arg("-matrix", Some(matrix)) } +pub fn ClustalwCommandline::set_matrix( + self : ClustalwCommandline, + matrix : String, +) -> ClustalwCommandline { + ClustalwCommandline::{ + commandline: self.commandline.add_arg("-matrix", Some(matrix)), + } } ///| -pub fn ClustalwCommandline::set_gap_open(self : ClustalwCommandline, penalty : Double) -> ClustalwCommandline { - ClustalwCommandline::{ commandline: self.commandline.add_arg("-gapopen", Some(penalty.to_string())) } +pub fn ClustalwCommandline::set_gap_open( + self : ClustalwCommandline, + penalty : Double, +) -> ClustalwCommandline { + ClustalwCommandline::{ + commandline: self.commandline.add_arg("-gapopen", Some(penalty.to_string())), + } } ///| -pub fn ClustalwCommandline::set_gap_extend(self : ClustalwCommandline, penalty : Double) -> ClustalwCommandline { - ClustalwCommandline::{ commandline: self.commandline.add_arg("-gapext", Some(penalty.to_string())) } +pub fn ClustalwCommandline::set_gap_extend( + self : ClustalwCommandline, + penalty : Double, +) -> ClustalwCommandline { + ClustalwCommandline::{ + commandline: self.commandline.add_arg("-gapext", Some(penalty.to_string())), + } } ///| @@ -52,33 +82,59 @@ pub struct ClustalOmegaCommandline { } ///| -pub fn ClustalOmegaCommandline::new(executable : String) -> ClustalOmegaCommandline { +pub fn ClustalOmegaCommandline::new( + executable : String, +) -> ClustalOmegaCommandline { ClustalOmegaCommandline::{ commandline: AbstractCommandline::new(executable) } } ///| -pub fn ClustalOmegaCommandline::set_input(self : ClustalOmegaCommandline, infile : String) -> ClustalOmegaCommandline { - ClustalOmegaCommandline::{ commandline: self.commandline.add_arg("-i", Some(infile)) } +pub fn ClustalOmegaCommandline::set_input( + self : ClustalOmegaCommandline, + infile : String, +) -> ClustalOmegaCommandline { + ClustalOmegaCommandline::{ + commandline: self.commandline.add_arg("-i", Some(infile)), + } } ///| -pub fn ClustalOmegaCommandline::set_output(self : ClustalOmegaCommandline, outfile : String) -> ClustalOmegaCommandline { - ClustalOmegaCommandline::{ commandline: self.commandline.add_arg("-o", Some(outfile)) } +pub fn ClustalOmegaCommandline::set_output( + self : ClustalOmegaCommandline, + outfile : String, +) -> ClustalOmegaCommandline { + ClustalOmegaCommandline::{ + commandline: self.commandline.add_arg("-o", Some(outfile)), + } } ///| -pub fn ClustalOmegaCommandline::set_output_format(self : ClustalOmegaCommandline, format : String) -> ClustalOmegaCommandline { - ClustalOmegaCommandline::{ commandline: self.commandline.add_arg("--outfmt", Some(format)) } +pub fn ClustalOmegaCommandline::set_output_format( + self : ClustalOmegaCommandline, + format : String, +) -> ClustalOmegaCommandline { + ClustalOmegaCommandline::{ + commandline: self.commandline.add_arg("--outfmt", Some(format)), + } } ///| -pub fn ClustalOmegaCommandline::set_iterations(self : ClustalOmegaCommandline, n : Int) -> ClustalOmegaCommandline { - ClustalOmegaCommandline::{ commandline: self.commandline.add_arg("--iterations", Some(n.to_string())) } +pub fn ClustalOmegaCommandline::set_iterations( + self : ClustalOmegaCommandline, + n : Int, +) -> ClustalOmegaCommandline { + ClustalOmegaCommandline::{ + commandline: self.commandline.add_arg("--iterations", Some(n.to_string())), + } } ///| -pub fn ClustalOmegaCommandline::set_full_matrix(self : ClustalOmegaCommandline) -> ClustalOmegaCommandline { - ClustalOmegaCommandline::{ commandline: self.commandline.add_arg("--full", None) } +pub fn ClustalOmegaCommandline::set_full_matrix( + self : ClustalOmegaCommandline, +) -> ClustalOmegaCommandline { + ClustalOmegaCommandline::{ + commandline: self.commandline.add_arg("--full", None), + } } ///| @@ -97,23 +153,40 @@ pub fn MuscleCommandline::new(executable : String) -> MuscleCommandline { } ///| -pub fn MuscleCommandline::set_input(self : MuscleCommandline, infile : String) -> MuscleCommandline { - MuscleCommandline::{ commandline: self.commandline.add_arg("-in", Some(infile)) } +pub fn MuscleCommandline::set_input( + self : MuscleCommandline, + infile : String, +) -> MuscleCommandline { + MuscleCommandline::{ + commandline: self.commandline.add_arg("-in", Some(infile)), + } } ///| -pub fn MuscleCommandline::set_output(self : MuscleCommandline, outfile : String) -> MuscleCommandline { - MuscleCommandline::{ commandline: self.commandline.add_arg("-out", Some(outfile)) } +pub fn MuscleCommandline::set_output( + self : MuscleCommandline, + outfile : String, +) -> MuscleCommandline { + MuscleCommandline::{ + commandline: self.commandline.add_arg("-out", Some(outfile)), + } } ///| -pub fn MuscleCommandline::set_diags(self : MuscleCommandline) -> MuscleCommandline { +pub fn MuscleCommandline::set_diags( + self : MuscleCommandline, +) -> MuscleCommandline { MuscleCommandline::{ commandline: self.commandline.add_arg("-diags", None) } } ///| -pub fn MuscleCommandline::set_max_iterations(self : MuscleCommandline, n : Int) -> MuscleCommandline { - MuscleCommandline::{ commandline: self.commandline.add_arg("-maxiters", Some(n.to_string())) } +pub fn MuscleCommandline::set_max_iterations( + self : MuscleCommandline, + n : Int, +) -> MuscleCommandline { + MuscleCommandline::{ + commandline: self.commandline.add_arg("-maxiters", Some(n.to_string())), + } } ///| @@ -132,13 +205,23 @@ pub fn MAFFTCommandline::new(executable : String) -> MAFFTCommandline { } ///| -pub fn MAFFTCommandline::set_input(self : MAFFTCommandline, infile : String) -> MAFFTCommandline { - MAFFTCommandline::{ commandline: self.commandline.add_arg("--input", Some(infile)) } +pub fn MAFFTCommandline::set_input( + self : MAFFTCommandline, + infile : String, +) -> MAFFTCommandline { + MAFFTCommandline::{ + commandline: self.commandline.add_arg("--input", Some(infile)), + } } ///| -pub fn MAFFTCommandline::set_output(self : MAFFTCommandline, outfile : String) -> MAFFTCommandline { - MAFFTCommandline::{ commandline: self.commandline.add_arg("--output", Some(outfile)) } +pub fn MAFFTCommandline::set_output( + self : MAFFTCommandline, + outfile : String, +) -> MAFFTCommandline { + MAFFTCommandline::{ + commandline: self.commandline.add_arg("--output", Some(outfile)), + } } ///| @@ -147,8 +230,13 @@ pub fn MAFFTCommandline::set_auto(self : MAFFTCommandline) -> MAFFTCommandline { } ///| -pub fn MAFFTCommandline::set_threads(self : MAFFTCommandline, n : Int) -> MAFFTCommandline { - MAFFTCommandline::{ commandline: self.commandline.add_arg("--thread", Some(n.to_string())) } +pub fn MAFFTCommandline::set_threads( + self : MAFFTCommandline, + n : Int, +) -> MAFFTCommandline { + MAFFTCommandline::{ + commandline: self.commandline.add_arg("--thread", Some(n.to_string())), + } } ///| @@ -194,4 +282,4 @@ pub fn create_example_mafft() -> MAFFTCommandline { let cmd = cmd.set_auto() let cmd = cmd.set_threads(4) cmd -} \ No newline at end of file +} diff --git a/src/align_bed.mbt b/src/align_bed.mbt index ae36eace..805d4fb7 100644 --- a/src/align_bed.mbt +++ b/src/align_bed.mbt @@ -170,8 +170,7 @@ fn align_bed_validate_score(score : AlignBedScore) -> Unit raise AlignBedError { if value.is_nan() || value.abs() > 1.0e300 { align_bed_fail("BED score must be finite") } - AlignBedText(value) => - align_bed_validate_token(value, "BED score", false) + AlignBedText(value) => align_bed_validate_token(value, "BED score", false) } } @@ -351,9 +350,7 @@ pub fn AlignBedScore::numeric( ///| /// Construct a non-empty textual BED score token. -pub fn AlignBedScore::text( - value : String, -) -> AlignBedScore raise AlignBedError { +pub fn AlignBedScore::text(value : String) -> AlignBedScore raise AlignBedError { let score = AlignBedText(value) align_bed_validate_score(score) score @@ -699,10 +696,7 @@ fn align_bed_coordinates_from_blocks( let coordinates : Array[AlignBedCoordinate] = [] let mut query_position = 0 let mut target_position = chrom_start - coordinates.push(AlignBedCoordinate::{ - target: chrom_start, - query: 0, - }) + coordinates.push(AlignBedCoordinate::{ target: chrom_start, query: 0 }) for index in 0.. AlignBedDocument raise AlignBedError { +pub fn align_bed_parse(text : String) -> AlignBedDocument raise AlignBedError { if text.length() == 0 { return AlignBedDocument::create([]) } @@ -861,9 +854,7 @@ pub fn align_bed_parse( if index + 1 == lines.length() { continue } - align_bed_fail( - "blank BED record at line " + (index + 1).to_string(), - ) + align_bed_fail("blank BED record at line " + (index + 1).to_string()) } alignments.push(align_bed_parse_line(line, index + 1)) } diff --git a/src/align_cluster.mbt b/src/align_cluster.mbt index b92a5060..6340b954 100644 --- a/src/align_cluster.mbt +++ b/src/align_cluster.mbt @@ -106,19 +106,27 @@ pub fn MSADistanceMatrix::new( ///| /// Get the distance matrix as a 2D array. -pub fn MSADistanceMatrix::get_matrix(self : MSADistanceMatrix) -> Array[Array[Double]] { +pub fn MSADistanceMatrix::get_matrix( + self : MSADistanceMatrix, +) -> Array[Array[Double]] { self.matrix } ///| /// Get the sequence IDs. -pub fn MSADistanceMatrix::get_sequence_ids(self : MSADistanceMatrix) -> Array[String] { +pub fn MSADistanceMatrix::get_sequence_ids( + self : MSADistanceMatrix, +) -> Array[String] { self.sequence_ids } ///| /// Get the distance between two sequences by index. -pub fn MSADistanceMatrix::get(self : MSADistanceMatrix, i : Int, j : Int) -> Double { +pub fn MSADistanceMatrix::get( + self : MSADistanceMatrix, + i : Int, + j : Int, +) -> Double { self.matrix[i][j] } @@ -169,7 +177,7 @@ pub struct GuideTree { ///| /// Create a new GuideTree from an array of nodes. pub fn GuideTree::new(nodes : Array[GuideTreeNode]) -> GuideTree { - GuideTree::{ nodes } + GuideTree::{ nodes, } } ///| @@ -308,11 +316,7 @@ pub fn upgma_tree(distance_matrix : MSADistanceMatrix) -> GuideTree { let size_i = count_leaves_in_node(nodes, i_idx) let size_j = count_leaves_in_node(nodes, j_idx) - let new_node = guide_tree_internal( - next_id, - [i_idx, j_idx], - height, - ) + let new_node = guide_tree_internal(next_id, [i_idx, j_idx], height) nodes.push(new_node) let new_node_idx = next_id next_id = next_id + 1 @@ -321,9 +325,10 @@ pub fn upgma_tree(distance_matrix : MSADistanceMatrix) -> GuideTree { for k = 0; k < m; k = k + 1 { if k != min_i && k != min_j { let d = ( - size_i.to_double() * dist[min_i][k] + - size_j.to_double() * dist[min_j][k] - ) / (size_i.to_double() + size_j.to_double()) + size_i.to_double() * dist[min_i][k] + + size_j.to_double() * dist[min_j][k] + ) / + (size_i.to_double() + size_j.to_double()) new_dists_row.push(d) } } @@ -356,15 +361,12 @@ pub fn upgma_tree(distance_matrix : MSADistanceMatrix) -> GuideTree { dist = new_dist } - GuideTree::{ nodes } + GuideTree::{ nodes, } } ///| /// Count the number of leaf nodes under a given node. -fn count_leaves_in_node( - nodes : Array[GuideTreeNode], - node_idx : Int, -) -> Int { +fn count_leaves_in_node(nodes : Array[GuideTreeNode], node_idx : Int) -> Int { let node = nodes[node_idx] if node.is_leaf { 1 @@ -379,9 +381,7 @@ fn count_leaves_in_node( ///| /// Copy a distance matrix. -fn copy_distance_matrix( - matrix : Array[Array[Double]], -) -> Array[Array[Double]] { +fn copy_distance_matrix(matrix : Array[Array[Double]]) -> Array[Array[Double]] { let result : Array[Array[Double]] = Array::new() for row in matrix { let new_row : Array[Double] = Array::new() @@ -400,18 +400,8 @@ fn copy_distance_matrix( /// `seq2` — second sequence string. /// /// Returns a tuple of (aligned_seq1, aligned_seq2, alignment_score). -pub fn align_pairwise( - seq1 : String, - seq2 : String, -) -> (String, String, Double) { - align_pairwise_with_scoring( - seq1, - seq2, - 2.0, - -1.0, - -2.0, - -0.5, - ) +pub fn align_pairwise(seq1 : String, seq2 : String) -> (String, String, Double) { + align_pairwise_with_scoring(seq1, seq2, 2.0, -1.0, -2.0, -0.5) } ///| @@ -469,11 +459,7 @@ pub fn align_pairwise_with_scoring( for j = 1; j <= m; j = j + 1 { let c1 = seq1.unsafe_get(i - 1) let c2 = seq2.unsafe_get(j - 1) - let sub_score = if c1 == c2 { - match_score - } else { - mismatch_score - } + let sub_score = if c1 == c2 { match_score } else { mismatch_score } let diag = dp[i - 1][j - 1] + sub_score let up = dp[i - 1][j] + @@ -784,12 +770,11 @@ pub fn progressive_alignment( let mut all_processed = true for child_idx in node.children { match processed.get(child_idx) { - Some(true) => { + Some(true) => match alignment_map.get(child_idx) { Some(profile) => child_results.push(profile) None => all_processed = false } - } _ => all_processed = false } } @@ -797,8 +782,7 @@ pub fn progressive_alignment( let left_profile = child_results[0] let right_profile = child_results[1] let (aligned_left, aligned_right, _) = align_profiles( - left_profile, - right_profile, + left_profile, right_profile, ) let left_aligned_profile : Array[String] = Array::new() let right_aligned_profile : Array[String] = Array::new() @@ -867,7 +851,7 @@ pub fn progressive_alignment( } else { "seq_" + seq_id_idx.to_string() } - records.push(SeqRecord::new(Seq::new(s), id=id)) + records.push(SeqRecord::new(Seq::new(s), id~)) seq_id_idx = seq_id_idx + 1 } create_msa_safe(records) @@ -881,9 +865,7 @@ fn create_msa_safe(records : Array[SeqRecord]) -> MultipleSeqAlignment { annotations: Map([], capacity=0), column_annotations: Map([], capacity=0), } - try { - MultipleSeqAlignment::new(records) - } catch { + MultipleSeqAlignment::new(records) catch { _ => empty } } @@ -988,4 +970,4 @@ fn repeat_char(c : Char, n : Int) -> String { buf.write_char(c) } buf.to_string() -} \ No newline at end of file +} diff --git a/src/alignace.mbt b/src/alignace.mbt index c8225bd2..7b1ec010 100644 --- a/src/alignace.mbt +++ b/src/alignace.mbt @@ -45,7 +45,11 @@ pub struct AlignAceMotif { ///| /// Construct an AlignAceMotif from a count matrix. pub fn AlignAceMotif::new(count_matrix : Array[Array[Int]]) -> AlignAceMotif { - let width = if count_matrix.length() > 0 { count_matrix[0].length() } else { 0 } + let width = if count_matrix.length() > 0 { + count_matrix[0].length() + } else { + 0 + } let mut total = 0 if width > 0 { for base_idx in 0..<4 { @@ -124,7 +128,10 @@ pub fn AlignAceMotif::add_site(self : AlignAceMotif, s : AlignAceSite) -> Unit { ///| /// Add a motif to the record. -pub fn AlignAceRecord::add_motif(self : AlignAceRecord, m : AlignAceMotif) -> Unit { +pub fn AlignAceRecord::add_motif( + self : AlignAceRecord, + m : AlignAceMotif, +) -> Unit { self.motifs.push(m) } @@ -218,10 +225,7 @@ pub fn alignace_parse(text : String) -> AlignAceRecord { ///| /// Parse a motif matrix starting at the given line index. /// Returns Some(motif) if successful, None otherwise. -fn alignace_parse_motif( - lines : Array[String], - start : Int, -) -> AlignAceMotif? { +fn alignace_parse_motif(lines : Array[String], start : Int) -> AlignAceMotif? { // Line 0: "i T G A C T C G A T" (consensus letters) // Line 1: " 0 1 2 3 4 5 6 7 8 9" (column indices) // Line 2: "A 1 0 8 0 0 0 0 0 0 0" @@ -269,23 +273,13 @@ fn alignace_parse_site(text : String) -> AlignAceSite? { let strand = parts[2] let sequence = parts[3] return Some( - AlignAceSite::new( - sequence_id=seq_id, - position=pos, - strand=strand, - sequence=sequence, - ), + AlignAceSite::new(sequence_id=seq_id, position=pos, strand~, sequence~), ) } // No strand field, assume "+" let sequence = parts[2] Some( - AlignAceSite::new( - sequence_id=seq_id, - position=pos, - strand="+", - sequence=sequence, - ), + AlignAceSite::new(sequence_id=seq_id, position=pos, strand="+", sequence~), ) } @@ -360,7 +354,8 @@ pub fn alignace_to_pwm(motif : AlignAceMotif) -> Array[Array[Double]] { motif.count_matrix[2][col] + motif.count_matrix[3][col] if total > 0 { - freq_row[col] = motif.count_matrix[row][col].to_double() / total.to_double() + freq_row[col] = motif.count_matrix[row][col].to_double() / + total.to_double() } else { freq_row[col] = 0.25 } @@ -474,8 +469,15 @@ fn alignace_write_motif(motif : AlignAceMotif) -> String { sb.write_string("# Sites:\n") for site in motif.sites { sb.write_string( - "# " + site.sequence_id + "\t" + site.position.to_string() + "\t" + - site.strand + "\t" + site.sequence + "\n", + "# " + + site.sequence_id + + "\t" + + site.position.to_string() + + "\t" + + site.strand + + "\t" + + site.sequence + + "\n", ) } sb.write_string("#\n") @@ -495,7 +497,10 @@ pub fn alignace_num_motifs(record : AlignAceRecord) -> Int { ///| /// Get a motif by index (0-based). Returns None if out of range. -pub fn alignace_get_motif(record : AlignAceRecord, index : Int) -> AlignAceMotif? { +pub fn alignace_get_motif( + record : AlignAceRecord, + index : Int, +) -> AlignAceMotif? { if index >= 0 && index < record.motifs.length() { Some(record.motifs[index]) } else { @@ -510,7 +515,9 @@ pub fn alignace_summary(record : AlignAceRecord) -> String { sb.write_string("AlignACE Record Summary:\n") sb.write_string(" Version: " + record.version + "\n") sb.write_string(" Command: " + record.command + "\n") - sb.write_string(" Parameters: " + record.parameters.size().to_string() + "\n") + sb.write_string( + " Parameters: " + record.parameters.size().to_string() + "\n", + ) let keys = record.parameters.keys() for k in keys { sb.write_string(" " + k + " = " + record.parameters[k] + "\n") @@ -519,9 +526,15 @@ pub fn alignace_summary(record : AlignAceRecord) -> String { for i in 0.. AlignAceRecord { record.parameters["numcols"] = "10" record.parameters["expect"] = "10" // Motif 1: TGACTCGAT - let m1 = AlignAceMotif::new( - [ - [1, 0, 8, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 1, 0, 8, 0, 0, 1], - [0, 8, 0, 0, 0, 0, 0, 8, 0, 0], - [7, 0, 0, 8, 7, 8, 0, 0, 8, 7], - ], - ) + let m1 = AlignAceMotif::new([ + [1, 0, 8, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 1, 0, 8, 0, 0, 1], + [0, 8, 0, 0, 0, 0, 0, 8, 0, 0], + [7, 0, 0, 8, 7, 8, 0, 0, 8, 7], + ]) m1.sites.push( AlignAceSite::new( sequence_id="seq1", @@ -563,14 +574,12 @@ pub fn alignace_sample() -> AlignAceRecord { ) record.motifs.push(m1) // Motif 2: AATAAACAAA - let m2 = AlignAceMotif::new( - [ - [8, 8, 1, 8, 8, 8, 0, 8, 8, 8], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [1, 1, 8, 1, 1, 1, 9, 1, 1, 1], - ], - ) + let m2 = AlignAceMotif::new([ + [8, 8, 1, 8, 8, 8, 0, 8, 8, 8], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [1, 1, 8, 1, 1, 1, 9, 1, 1, 1], + ]) record.motifs.push(m2) record } diff --git a/src/alignment_map.mbt b/src/alignment_map.mbt index be14bede..88f6219e 100644 --- a/src/alignment_map.mbt +++ b/src/alignment_map.mbt @@ -437,15 +437,12 @@ pub fn CoordinatePairwiseAlignment::map( let (reversed_target, reversed_query) = if relationship2 > 0 { alignment_map_transform_against_reverse_middle(next) } else { - let reversed_middle = alignment_map_reverse(next.target_coordinates) - let normalized_middle : Array[Int] = [] - for value in reversed_middle { - normalized_middle.push(next.target_length - value) - } - ( - normalized_middle, - alignment_map_reverse(next.query_coordinates), - ) + let reversed_middle = alignment_map_reverse(next.target_coordinates) + let normalized_middle : Array[Int] = [] + for value in reversed_middle { + normalized_middle.push(next.target_length - value) + } + (normalized_middle, alignment_map_reverse(next.query_coordinates)) } coordinates2_target = reversed_target coordinates2_query = reversed_query diff --git a/src/alphabet.mbt b/src/alphabet.mbt index a9fde8f0..a6b26035 100644 --- a/src/alphabet.mbt +++ b/src/alphabet.mbt @@ -13,31 +13,35 @@ pub struct Alphabet { ///| /// Create a new alphabet. -pub fn Alphabet::new(name : String, letters : Array[String], is_gapped : Bool) -> Alphabet { +pub fn Alphabet::new( + name : String, + letters : Array[String], + is_gapped : Bool, +) -> Alphabet { Alphabet::{ name, letters, is_gapped } } ///| /// Get alphabet name. -pub fn get_name(self : Alphabet) -> String { +pub fn Alphabet::get_name(self : Alphabet) -> String { self.name } ///| /// Get alphabet letters. -pub fn get_letters(self : Alphabet) -> Array[String] { +pub fn Alphabet::get_letters(self : Alphabet) -> Array[String] { self.letters } ///| /// Check if alphabet is gapped. -pub fn is_gapped(self : Alphabet) -> Bool { +pub fn Alphabet::is_gapped(self : Alphabet) -> Bool { self.is_gapped } ///| /// Check if a character is valid in this alphabet. -pub fn is_valid(self : Alphabet, c : String) -> Bool { +pub fn Alphabet::is_valid(self : Alphabet, c : String) -> Bool { let mut i = 0 while i < self.letters.length() { if self.letters[i] == c { @@ -51,18 +55,14 @@ pub fn is_valid(self : Alphabet, c : String) -> Bool { ///| /// IUPAC unambiguous DNA alphabet (A, C, G, T). pub fn iupac_unambiguous_dna() -> Alphabet { - let letters = [ - "A", "C", "G", "T" - ] + let letters = ["A", "C", "G", "T"] Alphabet::new("IUPACUnambiguousDNA", letters, false) } ///| /// IUPAC unambiguous RNA alphabet (A, C, G, U). pub fn iupac_unambiguous_rna() -> Alphabet { - let letters = [ - "A", "C", "G", "U" - ] + let letters = ["A", "C", "G", "U"] Alphabet::new("IUPACUnambiguousRNA", letters, false) } @@ -70,9 +70,7 @@ pub fn iupac_unambiguous_rna() -> Alphabet { /// IUPAC ambiguous DNA alphabet (A, C, G, T, R, Y, S, W, K, M, B, D, H, V, N). pub fn iupac_ambiguous_dna() -> Alphabet { let letters = [ - "A", "C", "G", "T", - "R", "Y", "S", "W", "K", "M", - "B", "D", "H", "V", "N" + "A", "C", "G", "T", "R", "Y", "S", "W", "K", "M", "B", "D", "H", "V", "N", ] Alphabet::new("IUPACAmbiguousDNA", letters, false) } @@ -81,9 +79,7 @@ pub fn iupac_ambiguous_dna() -> Alphabet { /// IUPAC ambiguous RNA alphabet (A, C, G, U, R, Y, S, W, K, M, B, D, H, V, N). pub fn iupac_ambiguous_rna() -> Alphabet { let letters = [ - "A", "C", "G", "U", - "R", "Y", "S", "W", "K", "M", - "B", "D", "H", "V", "N" + "A", "C", "G", "U", "R", "Y", "S", "W", "K", "M", "B", "D", "H", "V", "N", ] Alphabet::new("IUPACAmbiguousRNA", letters, false) } @@ -92,9 +88,8 @@ pub fn iupac_ambiguous_rna() -> Alphabet { /// IUPAC protein alphabet (20 standard amino acids + B, Z, X). pub fn iupac_protein() -> Alphabet { let letters = [ - "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", - "M", "N", "P", "Q", "R", "S", "T", "V", "W", "Y", - "B", "Z", "X" + "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", "M", "N", "P", "Q", "R", "S", + "T", "V", "W", "Y", "B", "Z", "X", ] Alphabet::new("IUPACProtein", letters, false) } @@ -103,9 +98,8 @@ pub fn iupac_protein() -> Alphabet { /// Extended IUPAC protein alphabet (20 standard + B, Z, X, U, O). pub fn iupac_extended_protein() -> Alphabet { let letters = [ - "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", - "M", "N", "P", "Q", "R", "S", "T", "V", "W", "Y", - "B", "Z", "X", "U", "O" + "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", "M", "N", "P", "Q", "R", "S", + "T", "V", "W", "Y", "B", "Z", "X", "U", "O", ] Alphabet::new("IUPACExtendedProtein", letters, false) } @@ -113,18 +107,14 @@ pub fn iupac_extended_protein() -> Alphabet { ///| /// Gapped DNA alphabet (includes gap character '-'). pub fn gapped_dna() -> Alphabet { - let letters = [ - "A", "C", "G", "T", "-" - ] + let letters = ["A", "C", "G", "T", "-"] Alphabet::new("GappedDNA", letters, true) } ///| /// Gapped RNA alphabet (includes gap character '-'). pub fn gapped_rna() -> Alphabet { - let letters = [ - "A", "C", "G", "U", "-" - ] + let letters = ["A", "C", "G", "U", "-"] Alphabet::new("GappedRNA", letters, true) } @@ -132,9 +122,8 @@ pub fn gapped_rna() -> Alphabet { /// Gapped protein alphabet (includes gap character '-'). pub fn gapped_protein() -> Alphabet { let letters = [ - "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", - "M", "N", "P", "Q", "R", "S", "T", "V", "W", "Y", - "-" + "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", "M", "N", "P", "Q", "R", "S", + "T", "V", "W", "Y", "-", ] Alphabet::new("GappedProtein", letters, true) } @@ -144,8 +133,8 @@ pub fn gapped_protein() -> Alphabet { /// Grouped by chemical properties. pub fn reduced_protein() -> Alphabet { let letters = [ - "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", - "M", "N", "P", "Q", "R", "S", "T", "V", "W", "Y" + "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", "M", "N", "P", "Q", "R", "S", + "T", "V", "W", "Y", ] Alphabet::new("ReducedProtein", letters, false) } diff --git a/src/ancombc.mbt b/src/ancombc.mbt index be2433a2..77a57deb 100644 --- a/src/ancombc.mbt +++ b/src/ancombc.mbt @@ -62,7 +62,7 @@ fn abc_variance(arr : Array[Double]) -> Double { /// Welch-Satterthwaite degrees of freedom. fn abc_welch_t( group1 : Array[Double], - group2 : Array[Double] + group2 : Array[Double], ) -> (Double, Double) { let n1 = group1.length() let n2 = group2.length() @@ -79,9 +79,13 @@ fn abc_welch_t( } let t = (m1 - m2) / se // Welch-Satterthwaite df. - let num = (v1 / n1.to_double() + v2 / n2.to_double()) - let denom1 = v1 * v1 / ((n1.to_double() - 1.0) * n1.to_double() * n1.to_double()) - let denom2 = v2 * v2 / ((n2.to_double() - 1.0) * n2.to_double() * n2.to_double()) + let num = v1 / n1.to_double() + v2 / n2.to_double() + let denom1 = v1 * + v1 / + ((n1.to_double() - 1.0) * n1.to_double() * n1.to_double()) + let denom2 = v2 * + v2 / + ((n2.to_double() - 1.0) * n2.to_double() * n2.to_double()) let df = if denom1 + denom2 > 0.0 { num * num / (denom1 + denom2) } else { @@ -120,11 +124,12 @@ fn abc_normal_cdf(z : Double) -> Double { let t = 1.0 / (1.0 + 0.3275911 * x) let exp_val = @math.exp(0.0 - x * x / 2.0) let y2 = 1.0 - - (((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - - 0.284496736) * - t + - 0.254829592) * - t) * + ( + (((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * + t + + 0.254829592 + ) * + t * exp_val 0.5 * (1.0 + sign * y2) } @@ -143,7 +148,13 @@ fn abc_bh_fdr(pvalues : Array[Double]) -> Array[Double] { indexed.push((i, pvalues[i])) } indexed.sort_by(fn(a : (Int, Double), b : (Int, Double)) -> Int { - if a.1 < b.1 { -1 } else if a.1 > b.1 { 1 } else { 0 } + if a.1 < b.1 { + -1 + } else if a.1 > b.1 { + 1 + } else { + 0 + } }) // Compute adjusted p-values from largest to smallest. let adjusted : Array[Double] = Array::make(m, 0.0) @@ -174,7 +185,10 @@ pub struct AncombcFeature { ///| /// Construct an AncombcFeature. -pub fn AncombcFeature::new(name : String, counts : Array[Int]) -> AncombcFeature { +pub fn AncombcFeature::new( + name : String, + counts : Array[Int], +) -> AncombcFeature { AncombcFeature::{ name, counts } } @@ -237,7 +251,7 @@ pub fn AncombcData::new( sample_names : Array[String], sample_groups : Array[String], feature_names : Array[String], - counts : Array[Array[Int]] + counts : Array[Array[Int]], ) -> AncombcData { AncombcData::{ sample_names, sample_groups, feature_names, counts } } @@ -277,7 +291,7 @@ pub fn AncombcData::counts(self : AncombcData) -> Array[Array[Int]] { pub fn AncombcData::get_count( self : AncombcData, feature_idx : Int, - sample_idx : Int + sample_idx : Int, ) -> Int { self.counts[feature_idx][sample_idx] } @@ -344,9 +358,7 @@ pub fn ancombc_sampling_fractions(data : AncombcData) -> Array[Double] { /// y[i,j] = log(count[i,j] + 0.5) - log(s_j * N + 0.5) /// where s_j is the sampling fraction and N is the number of features. /// This adjusts for differences in sequencing depth (library size). -pub fn ancombc_bias_corrected_log( - data : AncombcData -) -> Array[Array[Double]] { +pub fn ancombc_bias_corrected_log(data : AncombcData) -> Array[Array[Double]] { let n_features = data.n_features() let n_samples = data.n_samples() let fracs = ancombc_sampling_fractions(data) @@ -412,9 +424,16 @@ pub fn AncombcResult::new( w_stat : Int, p_value : Double, q_value : Double, - significant : Bool + significant : Bool, ) -> AncombcResult { - AncombcResult::{ feature, log_fold_change, w_stat, p_value, q_value, significant } + AncombcResult::{ + feature, + log_fold_change, + w_stat, + p_value, + q_value, + significant, + } } ///| @@ -461,14 +480,14 @@ pub struct AncombcTestResult { } ///| -pub fn AncombcTestResult::results(self : AncombcTestResult) -> Array[AncombcResult] { +pub fn AncombcTestResult::results( + self : AncombcTestResult, +) -> Array[AncombcResult] { self.results } ///| -pub fn AncombcTestResult::reference_feature( - self : AncombcTestResult -) -> String { +pub fn AncombcTestResult::reference_feature(self : AncombcTestResult) -> String { self.reference_feature } @@ -517,7 +536,7 @@ pub fn ancombc_test( data : AncombcData, group1 : String, group2 : String, - alpha : Double + alpha : Double, ) -> AncombcTestResult { let n_features = data.n_features() let n_samples = data.n_samples() @@ -535,11 +554,7 @@ pub fn ancombc_test( let log_data = ancombc_bias_corrected_log(data) // Select reference feature. let ref_idx = ancombc_reference_feature(data) - let ref_name = if ref_idx >= 0 { - data.feature_names[ref_idx] - } else { - "" - } + let ref_name = if ref_idx >= 0 { data.feature_names[ref_idx] } else { "" } // Compute log-ratios relative to reference: y_i - y_ref for each sample. let log_ratios : Array[Array[Double]] = Array::new() for i in 0.. String { sb.write_string(result.n_significant().to_string()) sb.write_char('\n') sb.write_string("--- Per-feature results ---\n") - sb.write_string( - "feature\tlogFC\tW\tp_value\tq_value\tsignificant\n", - ) + sb.write_string("feature\tlogFC\tW\tp_value\tq_value\tsignificant\n") for r in result.results { sb.write_string(r.feature) sb.write_char('\t') @@ -689,10 +702,13 @@ pub fn ancombc_result_summary(result : AncombcTestResult) -> String { pub fn ancombc_sample_data() -> AncombcData { let sample_names = ["S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8"] let sample_groups = [ - "control", "control", "control", "control", "treatment", "treatment", - "treatment", "treatment", + "control", "control", "control", "control", "treatment", "treatment", "treatment", + "treatment", + ] + let feature_names = [ + "Bacteroides", "Prevotella", "Faecalibacterium", "Roseburia", "Eubacterium", + "Ruminococcus", ] - let feature_names = ["Bacteroides", "Prevotella", "Faecalibacterium", "Roseburia", "Eubacterium", "Ruminococcus"] // Counts: [feature][sample] // Features 0,1 are elevated in treatment; features 2-5 are similar. let counts = [ diff --git a/src/application.mbt b/src/application.mbt index d4287a84..7c604cf2 100644 --- a/src/application.mbt +++ b/src/application.mbt @@ -19,12 +19,16 @@ pub fn AbstractCommandline::new(executable : String) -> AbstractCommandline { stdin: "", stdout: "", stderr: "", - env: Map([], capacity=0) + env: Map([], capacity=0), } } ///| -pub fn AbstractCommandline::add_arg(self : AbstractCommandline, arg : String, value : String?) -> AbstractCommandline { +pub fn AbstractCommandline::add_arg( + self : AbstractCommandline, + arg : String, + value : String?, +) -> AbstractCommandline { let args = self.arguments.copy() args.push(arg) if value is Some(_) { @@ -36,12 +40,16 @@ pub fn AbstractCommandline::add_arg(self : AbstractCommandline, arg : String, va stdin: self.stdin, stdout: self.stdout, stderr: self.stderr, - env: self.env + env: self.env, } } ///| -pub fn AbstractCommandline::set_parameter(self : AbstractCommandline, param : String, value : String) -> AbstractCommandline { +pub fn AbstractCommandline::set_parameter( + self : AbstractCommandline, + param : String, + value : String, +) -> AbstractCommandline { let args = self.arguments.copy() args.push(param) args.push(value) @@ -51,43 +59,52 @@ pub fn AbstractCommandline::set_parameter(self : AbstractCommandline, param : St stdin: self.stdin, stdout: self.stdout, stderr: self.stderr, - env: self.env + env: self.env, } } ///| -pub fn AbstractCommandline::set_stdout(self : AbstractCommandline, path : String) -> AbstractCommandline { +pub fn AbstractCommandline::set_stdout( + self : AbstractCommandline, + path : String, +) -> AbstractCommandline { AbstractCommandline::{ executable: self.executable, arguments: self.arguments, stdin: self.stdin, stdout: path, stderr: self.stderr, - env: self.env + env: self.env, } } ///| -pub fn AbstractCommandline::set_stderr(self : AbstractCommandline, path : String) -> AbstractCommandline { +pub fn AbstractCommandline::set_stderr( + self : AbstractCommandline, + path : String, +) -> AbstractCommandline { AbstractCommandline::{ executable: self.executable, arguments: self.arguments, stdin: self.stdin, stdout: self.stdout, stderr: path, - env: self.env + env: self.env, } } ///| -pub fn AbstractCommandline::set_stdin(self : AbstractCommandline, path : String) -> AbstractCommandline { +pub fn AbstractCommandline::set_stdin( + self : AbstractCommandline, + path : String, +) -> AbstractCommandline { AbstractCommandline::{ executable: self.executable, arguments: self.arguments, stdin: path, stdout: self.stdout, stderr: self.stderr, - env: self.env + env: self.env, } } @@ -115,7 +132,11 @@ pub struct CommandlineError { } ///| -pub fn CommandlineError::new(message : String, exit_code : Int, command : String) -> CommandlineError { +pub fn CommandlineError::new( + message : String, + exit_code : Int, + command : String, +) -> CommandlineError { CommandlineError::{ message, exit_code, command } } @@ -142,4 +163,4 @@ pub fn create_example_commandline() -> AbstractCommandline { cmd = cmd.add_arg("-out", Some("results.txt")) cmd = cmd.add_arg("-evalue", Some("1e-5")) cmd -} \ No newline at end of file +} diff --git a/src/bamsignals.mbt b/src/bamsignals.mbt index ae702a29..c71b5678 100644 --- a/src/bamsignals.mbt +++ b/src/bamsignals.mbt @@ -3,6 +3,7 @@ /// Provides functions for extracting and analyzing signals from BAM files. /// Supports signal counting and normalization for ChIP-seq and other sequencing data. +///| /// Count mode for signal extraction pub enum BamsigCountMode { /// Count all reads @@ -15,6 +16,7 @@ pub enum BamsigCountMode { PairedEnd } derive(Eq) +///| /// Normalization method for signal pub enum BamsigNormMethod { /// No normalization @@ -27,6 +29,7 @@ pub enum BamsigNormMethod { CPM } +///| /// Signal extraction parameters pub struct BamsigParams { /// Count mode @@ -41,31 +44,79 @@ pub struct BamsigParams { extend_len : Int } +///| /// Create default parameters pub fn BamsigParams::new() -> BamsigParams { - BamsigParams::{ count_mode: BamsigCountMode::All, filter_dup: false, min_mapq: 10, single_end: false, extend_len: 150 } + BamsigParams::{ + count_mode: BamsigCountMode::All, + filter_dup: false, + min_mapq: 10, + single_end: false, + extend_len: 150, + } } +///| /// Set count mode -pub fn BamsigParams::bamsig_set_count_mode(self : BamsigParams, mode : BamsigCountMode) -> BamsigParams { - BamsigParams::{ count_mode: mode, filter_dup: self.filter_dup, min_mapq: self.min_mapq, single_end: self.single_end, extend_len: self.extend_len } +pub fn BamsigParams::bamsig_set_count_mode( + self : BamsigParams, + mode : BamsigCountMode, +) -> BamsigParams { + BamsigParams::{ + count_mode: mode, + filter_dup: self.filter_dup, + min_mapq: self.min_mapq, + single_end: self.single_end, + extend_len: self.extend_len, + } } +///| /// Set filter duplicates -pub fn BamsigParams::bamsig_set_filter_dup(self : BamsigParams, filter : Bool) -> BamsigParams { - BamsigParams::{ count_mode: self.count_mode, filter_dup: filter, min_mapq: self.min_mapq, single_end: self.single_end, extend_len: self.extend_len } +pub fn BamsigParams::bamsig_set_filter_dup( + self : BamsigParams, + filter : Bool, +) -> BamsigParams { + BamsigParams::{ + count_mode: self.count_mode, + filter_dup: filter, + min_mapq: self.min_mapq, + single_end: self.single_end, + extend_len: self.extend_len, + } } +///| /// Set minimum mapping quality -pub fn BamsigParams::bamsig_set_min_mapq(self : BamsigParams, mapq : Int) -> BamsigParams { - BamsigParams::{ count_mode: self.count_mode, filter_dup: self.filter_dup, min_mapq: mapq, single_end: self.single_end, extend_len: self.extend_len } +pub fn BamsigParams::bamsig_set_min_mapq( + self : BamsigParams, + mapq : Int, +) -> BamsigParams { + BamsigParams::{ + count_mode: self.count_mode, + filter_dup: self.filter_dup, + min_mapq: mapq, + single_end: self.single_end, + extend_len: self.extend_len, + } } +///| /// Set extend length -pub fn BamsigParams::bamsig_set_extend(self : BamsigParams, extend_len : Int) -> BamsigParams { - BamsigParams::{ count_mode: self.count_mode, filter_dup: self.filter_dup, min_mapq: self.min_mapq, single_end: self.single_end, extend_len: extend_len } +pub fn BamsigParams::bamsig_set_extend( + self : BamsigParams, + extend_len : Int, +) -> BamsigParams { + BamsigParams::{ + count_mode: self.count_mode, + filter_dup: self.filter_dup, + min_mapq: self.min_mapq, + single_end: self.single_end, + extend_len, + } } +///| /// Genomic region for signal extraction pub struct BamsigRegion { /// Chromosome @@ -78,36 +129,48 @@ pub struct BamsigRegion { id : String } +///| /// Create new region -pub fn BamsigRegion::new(chrom : String, start : Int, end : Int, id : String) -> BamsigRegion { +pub fn BamsigRegion::new( + chrom : String, + start : Int, + end : Int, + id : String, +) -> BamsigRegion { BamsigRegion::{ chrom, start, end, id } } +///| /// Get chromosome pub fn BamsigRegion::bamsig_chrom(self : BamsigRegion) -> String { self.chrom } +///| /// Get start position pub fn BamsigRegion::bamsig_start(self : BamsigRegion) -> Int { self.start } +///| /// Get end position pub fn BamsigRegion::bamsig_end(self : BamsigRegion) -> Int { self.end } +///| /// Get width pub fn BamsigRegion::bamsig_width(self : BamsigRegion) -> Int { self.end - self.start } +///| /// Get ID pub fn BamsigRegion::bamsig_id(self : BamsigRegion) -> String { self.id } +///| /// BAM record for signal extraction pub struct BamsigRecord { /// Chromosome @@ -128,23 +191,39 @@ pub struct BamsigRecord { is_first : Bool } +///| /// Create new record -pub fn BamsigRecord::new(chrom : String, pos : Int, cigar : String, strand : Bool, mapq : Int, is_dup : Bool, is_paired : Bool, is_first : Bool) -> BamsigRecord { +pub fn BamsigRecord::new( + chrom : String, + pos : Int, + cigar : String, + strand : Bool, + mapq : Int, + is_dup : Bool, + is_paired : Bool, + is_first : Bool, +) -> BamsigRecord { BamsigRecord::{ chrom, pos, cigar, strand, mapq, is_dup, is_paired, is_first } } +///| /// Get alignment length from CIGAR pub fn BamsigRecord::bamsig_align_length(self : BamsigRecord) -> Int { parse_cigar_length(self.cigar) } +///| /// Get end position pub fn BamsigRecord::bamsig_end(self : BamsigRecord) -> Int { self.pos + self.bamsig_align_length() } +///| /// Check if record passes filter -pub fn BamsigRecord::bamsig_passes_filter(self : BamsigRecord, params : BamsigParams) -> Bool { +pub fn BamsigRecord::bamsig_passes_filter( + self : BamsigRecord, + params : BamsigParams, +) -> Bool { if self.is_dup && params.filter_dup { return false } @@ -157,6 +236,7 @@ pub fn BamsigRecord::bamsig_passes_filter(self : BamsigRecord, params : BamsigPa true } +///| /// Signal counts for regions pub struct BamsigSignal { /// Region IDs @@ -169,39 +249,68 @@ pub struct BamsigSignal { total_reads : Array[Double] } +///| /// Create new signal -pub fn BamsigSignal::new(region_ids : Array[String], counts : Array[Array[Double]], - norm_counts : Array[Array[Double]], total_reads : Array[Double]) -> BamsigSignal { +pub fn BamsigSignal::new( + region_ids : Array[String], + counts : Array[Array[Double]], + norm_counts : Array[Array[Double]], + total_reads : Array[Double], +) -> BamsigSignal { BamsigSignal::{ region_ids, counts, norm_counts, total_reads } } +///| /// Get number of regions pub fn BamsigSignal::bamsig_n_regions(self : BamsigSignal) -> Int { self.region_ids.length() } +///| /// Get number of samples pub fn BamsigSignal::bamsig_n_samples(self : BamsigSignal) -> Int { - if self.counts.length() > 0 { self.counts[0].length() } else { 0 } + if self.counts.length() > 0 { + self.counts[0].length() + } else { + 0 + } } +///| /// Get count for region and sample -pub fn BamsigSignal::bamsig_get_count(self : BamsigSignal, region_idx : Int, sample_idx : Int) -> Double { +pub fn BamsigSignal::bamsig_get_count( + self : BamsigSignal, + region_idx : Int, + sample_idx : Int, +) -> Double { self.counts[region_idx][sample_idx] } +///| /// Get normalized count -pub fn BamsigSignal::bamsig_get_norm_count(self : BamsigSignal, region_idx : Int, sample_idx : Int) -> Double { +pub fn BamsigSignal::bamsig_get_norm_count( + self : BamsigSignal, + region_idx : Int, + sample_idx : Int, +) -> Double { self.norm_counts[region_idx][sample_idx] } +///| /// Get region ID -pub fn BamsigSignal::bamsig_get_region_id(self : BamsigSignal, idx : Int) -> String { +pub fn BamsigSignal::bamsig_get_region_id( + self : BamsigSignal, + idx : Int, +) -> String { self.region_ids[idx] } +///| /// Sum counts across samples for a region -pub fn BamsigSignal::bamsig_row_sum(self : BamsigSignal, region_idx : Int) -> Double { +pub fn BamsigSignal::bamsig_row_sum( + self : BamsigSignal, + region_idx : Int, +) -> Double { let row = self.counts[region_idx] let mut sum = 0.0 let mut i = 0 @@ -212,8 +321,12 @@ pub fn BamsigSignal::bamsig_row_sum(self : BamsigSignal, region_idx : Int) -> Do sum } +///| /// Sum counts across regions for a sample -pub fn BamsigSignal::bamsig_col_sum(self : BamsigSignal, sample_idx : Int) -> Double { +pub fn BamsigSignal::bamsig_col_sum( + self : BamsigSignal, + sample_idx : Int, +) -> Double { let mut sum = 0.0 let mut i = 0 while i < self.counts.length() { @@ -223,17 +336,22 @@ pub fn BamsigSignal::bamsig_col_sum(self : BamsigSignal, sample_idx : Int) -> Do sum } +///| /// Filter regions by count threshold -pub fn BamsigSignal::bamsig_filter(self : BamsigSignal, min_count : Double, min_samples : Int) -> BamsigSignal { +pub fn BamsigSignal::bamsig_filter( + self : BamsigSignal, + min_count : Double, + min_samples : Int, +) -> BamsigSignal { let new_region_ids : Array[String] = Array::new() let new_counts : Array[Array[Double]] = Array::new() let new_norm_counts : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < self.region_ids.length() { let count_row = self.counts[i] let mut passing_samples = 0 - + let mut j = 0 while j < count_row.length() { if count_row[j] >= min_count { @@ -241,19 +359,25 @@ pub fn BamsigSignal::bamsig_filter(self : BamsigSignal, min_count : Double, min_ } j = j + 1 } - + if passing_samples >= min_samples { new_region_ids.push(self.region_ids[i]) new_counts.push(count_row) new_norm_counts.push(self.norm_counts[i]) } - + i = i + 1 } - - BamsigSignal::new(new_region_ids, new_counts, new_norm_counts, self.total_reads) + + BamsigSignal::new( + new_region_ids, + new_counts, + new_norm_counts, + self.total_reads, + ) } +///| /// Chromatin state analysis result pub struct BamsigChromState { /// State labels @@ -270,43 +394,73 @@ pub struct BamsigChromState { repressed_pct : Double } +///| /// Create new chromatin state result -pub fn BamsigChromState::new(labels : Array[String], colors : Array[String], frequencies : Array[Double], - active_promoter_pct : Double, active_enhancer_pct : Double, - repressed_pct : Double) -> BamsigChromState { - BamsigChromState::{ labels, colors, frequencies, active_promoter_pct, active_enhancer_pct, repressed_pct } +pub fn BamsigChromState::new( + labels : Array[String], + colors : Array[String], + frequencies : Array[Double], + active_promoter_pct : Double, + active_enhancer_pct : Double, + repressed_pct : Double, +) -> BamsigChromState { + BamsigChromState::{ + labels, + colors, + frequencies, + active_promoter_pct, + active_enhancer_pct, + repressed_pct, + } } +///| /// Get number of states pub fn BamsigChromState::bamsig_n_states(self : BamsigChromState) -> Int { self.labels.length() } +///| /// Get state label -pub fn BamsigChromState::bamsig_get_label(self : BamsigChromState, idx : Int) -> String { +pub fn BamsigChromState::bamsig_get_label( + self : BamsigChromState, + idx : Int, +) -> String { self.labels[idx] } +///| /// Get state frequency -pub fn BamsigChromState::bamsig_get_frequency(self : BamsigChromState, idx : Int) -> Double { +pub fn BamsigChromState::bamsig_get_frequency( + self : BamsigChromState, + idx : Int, +) -> Double { self.frequencies[idx] } +///| /// Get active promoter percentage -pub fn BamsigChromState::bamsig_active_promoter(self : BamsigChromState) -> Double { +pub fn BamsigChromState::bamsig_active_promoter( + self : BamsigChromState, +) -> Double { self.active_promoter_pct } +///| /// Get active enhancer percentage -pub fn BamsigChromState::bamsig_active_enhancer(self : BamsigChromState) -> Double { +pub fn BamsigChromState::bamsig_active_enhancer( + self : BamsigChromState, +) -> Double { self.active_enhancer_pct } +///| /// Get repressed percentage pub fn BamsigChromState::bamsig_repressed(self : BamsigChromState) -> Double { self.repressed_pct } +///| /// Parse CIGAR string to get alignment length fn parse_cigar_length(cigar : String) -> Int { let mut total = 0 @@ -335,6 +489,7 @@ fn parse_cigar_length(cigar : String) -> Int { total } +///| /// Create example records for testing pub fn bamsig_create_example_records() -> Array[BamsigRecord] { [ @@ -347,6 +502,7 @@ pub fn bamsig_create_example_records() -> Array[BamsigRecord] { ] } +///| /// Create example regions pub fn bamsig_create_example_regions() -> Array[BamsigRegion] { [ @@ -357,18 +513,21 @@ pub fn bamsig_create_example_regions() -> Array[BamsigRegion] { ] } +///| /// Count signals in regions -pub fn bamsig_count_signals(regions : Array[BamsigRegion], - records_by_chrom : Map[String, Array[BamsigRecord]], - params : BamsigParams) -> Array[Array[Double]] { +pub fn bamsig_count_signals( + regions : Array[BamsigRegion], + records_by_chrom : Map[String, Array[BamsigRecord]], + params : BamsigParams, +) -> Array[Array[Double]] { let n_regions = regions.length() let counts : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_regions { let region = regions[i] let mut region_count = 0.0 - + let chrom_records = records_by_chrom.get(region.chrom) if chrom_records is Some(records) { let recs = records @@ -378,15 +537,28 @@ pub fn bamsig_count_signals(regions : Array[BamsigRegion], if rec.bamsig_passes_filter(params) { let rec_end = rec.pos + rec.bamsig_align_length() if rec.pos < region.end && rec_end > region.start { - let overlap_start = if rec.pos > region.start { rec.pos } else { region.start } - let overlap_end = if rec_end < region.end { rec_end } else { region.end } - let _overlap = if overlap_end > overlap_start { overlap_end - overlap_start } else { 0 } - + let overlap_start = if rec.pos > region.start { + rec.pos + } else { + region.start + } + let overlap_end = if rec_end < region.end { + rec_end + } else { + region.end + } + let _overlap = if overlap_end > overlap_start { + overlap_end - overlap_start + } else { + 0 + } + if params.count_mode == BamsigCountMode::All { region_count = region_count + 1.0 } else if params.count_mode == BamsigCountMode::Sense && rec.strand { region_count = region_count + 1.0 - } else if params.count_mode == BamsigCountMode::Antisense && !rec.strand { + } else if params.count_mode == BamsigCountMode::Antisense && + !rec.strand { region_count = region_count + 1.0 } } @@ -394,77 +566,98 @@ pub fn bamsig_count_signals(regions : Array[BamsigRegion], j = j + 1 } } - + counts.push([region_count]) i = i + 1 } - + counts } +///| /// Normalize signals -pub fn bamsig_normalize_signals(counts : Array[Array[Double]], - total_reads : Array[Double], - norm_method : BamsigNormMethod) -> Array[Array[Double]] { +pub fn bamsig_normalize_signals( + counts : Array[Array[Double]], + total_reads : Array[Double], + norm_method : BamsigNormMethod, +) -> Array[Array[Double]] { let norm_counts : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < counts.length() { let row = counts[i] let norm_row : Array[Double] = Array::new() - + let mut j = 0 while j < row.length() { let c = row[j] let total = if j < total_reads.length() { total_reads[j] } else { 1.0 } - + let norm_val = match norm_method { BamsigNormMethod::None => c - BamsigNormMethod::RPM => if total > 0.0 { c / total * 1000000.0 } else { 0.0 } - BamsigNormMethod::CPM => if total > 0.0 { c / total * 1000000.0 } else { 0.0 } - BamsigNormMethod::RPKM => if total > 0.0 { c / total * 1000000.0 / 1000.0 } else { 0.0 } + BamsigNormMethod::RPM => + if total > 0.0 { + c / total * 1000000.0 + } else { + 0.0 + } + BamsigNormMethod::CPM => + if total > 0.0 { + c / total * 1000000.0 + } else { + 0.0 + } + BamsigNormMethod::RPKM => + if total > 0.0 { + c / total * 1000000.0 / 1000.0 + } else { + 0.0 + } } - + norm_row.push(norm_val) j = j + 1 } - + norm_counts.push(norm_row) i = i + 1 } - + norm_counts } +///| /// Analyze chromatin states -pub fn bamsig_analyze_chromatin_states(signal : BamsigSignal, - promoter_regions : Array[Int], - enhancer_regions : Array[Int], - repressed_regions : Array[Int]) -> BamsigChromState { +pub fn bamsig_analyze_chromatin_states( + signal : BamsigSignal, + promoter_regions : Array[Int], + enhancer_regions : Array[Int], + repressed_regions : Array[Int], +) -> BamsigChromState { let n_regions = signal.bamsig_n_regions() let n_states = 4 - + let labels = ["Active Promoter", "Active Enhancer", "Repressed", "Inactive"] let colors = ["#FF0000", "#00FF00", "#0000FF", "#CCCCCC"] let frequencies = Array::make(n_states, 0.0) - + let n_promoter = promoter_regions.length().to_double() let n_enhancer = enhancer_regions.length().to_double() let n_repressed = repressed_regions.length().to_double() - + let mut active_promoter = 0.0 let mut active_enhancer = 0.0 let mut repressed = 0.0 - + let mut i = 0 while i < n_regions { let total_count = signal.bamsig_row_sum(i) let is_active = total_count > 0.0 - + let is_promoter = promoter_regions.contains(i) let is_enhancer = enhancer_regions.contains(i) let is_repressed = repressed_regions.contains(i) - + if is_active { if is_promoter { active_promoter = active_promoter + 1.0 @@ -472,37 +665,51 @@ pub fn bamsig_analyze_chromatin_states(signal : BamsigSignal, active_enhancer = active_enhancer + 1.0 } } - + if is_repressed { repressed = repressed + 1.0 } - + i = i + 1 } - + let _total_annotated = n_promoter + n_enhancer + n_repressed - let total_promoter_pct = if n_promoter > 0.0 { active_promoter / n_promoter * 100.0 } else { 0.0 } - let enhancer_pct = if n_enhancer > 0.0 { active_enhancer / n_enhancer * 100.0 } else { 0.0 } - let repressed_pct = if n_repressed > 0.0 { repressed / n_repressed * 100.0 } else { 0.0 } - + let total_promoter_pct = if n_promoter > 0.0 { + active_promoter / n_promoter * 100.0 + } else { + 0.0 + } + let enhancer_pct = if n_enhancer > 0.0 { + active_enhancer / n_enhancer * 100.0 + } else { + 0.0 + } + let repressed_pct = if n_repressed > 0.0 { + repressed / n_repressed * 100.0 + } else { + 0.0 + } + frequencies[0] = total_promoter_pct frequencies[1] = enhancer_pct frequencies[2] = repressed_pct frequencies[3] = 100.0 - total_promoter_pct - enhancer_pct - repressed_pct - - BamsigChromState::new(labels, colors, frequencies, - total_promoter_pct, enhancer_pct, repressed_pct) + + BamsigChromState::new( + labels, colors, frequencies, total_promoter_pct, enhancer_pct, repressed_pct, + ) } +///| /// Create example signal data pub fn bamsig_create_example_signal() -> BamsigSignal { let regions = bamsig_create_example_regions() let n_regions = regions.length() let _n_samples = 2 - + let region_ids : Array[String] = Array::new() let counts : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_regions { region_ids.push(regions[i].id) @@ -512,9 +719,13 @@ pub fn bamsig_create_example_signal() -> BamsigSignal { counts.push(row) i = i + 1 } - + let total_reads = [10000.0, 9500.0] - let norm_counts = bamsig_normalize_signals(counts, total_reads, BamsigNormMethod::RPM) - + let norm_counts = bamsig_normalize_signals( + counts, + total_reads, + BamsigNormMethod::RPM, + ) + BamsigSignal::new(region_ids, counts, norm_counts, total_reads) } diff --git a/src/batchelor.mbt b/src/batchelor.mbt index e8dc839b..a13a61be 100644 --- a/src/batchelor.mbt +++ b/src/batchelor.mbt @@ -18,12 +18,7 @@ pub fn BatchCorrectionResult::new( mnn_pairs : Array[(Int, Int)], var_explained : Array[Double], ) -> BatchCorrectionResult { - BatchCorrectionResult::{ - corrected, - batch_indices, - mnn_pairs, - var_explained, - } + BatchCorrectionResult::{ corrected, batch_indices, mnn_pairs, var_explained } } ///| @@ -307,7 +302,10 @@ pub fn fast_mnn( nn = nn + 1 } - let cov_matrix : Array[Array[Double]] = Array::make(n_genes, Array::make(n_genes, 0.0)) + let cov_matrix : Array[Array[Double]] = Array::make( + n_genes, + Array::make(n_genes, 0.0), + ) let mut pp = 0 while pp < n_cells { let cell = centered[pp] @@ -333,7 +331,10 @@ pub fn fast_mnn( } let eigenvalues : Array[Double] = Array::make(n_genes, 0.0) - let eigenvectors : Array[Array[Double]] = Array::make(n_genes, Array::make(n_genes, 0.0)) + let eigenvectors : Array[Array[Double]] = Array::make( + n_genes, + Array::make(n_genes, 0.0), + ) let mut uu = 0 while uu < n_genes { eigenvalues[uu] = cov_matrix[uu][uu] @@ -350,11 +351,7 @@ pub fn fast_mnn( while xx < n_genes { let p = cov_matrix[ww][xx] let d_val = eigenvalues[xx] - eigenvalues[ww] - let c = if d_val.abs() < 0.000001 { - 0.000001 - } else { - d_val - } + let c = if d_val.abs() < 0.000001 { 0.000001 } else { d_val } let t = p / c let cos_val = 1.0 / (1.0 + t * t).sqrt() let sin_val = t * cos_val @@ -480,7 +477,10 @@ pub fn fast_mnn( kk = kk + 1 } - let correction_vectors : Array[Array[Double]] = Array::make(n_cells, Array::make(top_components, 0.0)) + let correction_vectors : Array[Array[Double]] = Array::make( + n_cells, + Array::make(top_components, 0.0), + ) let mut mm = 0 while mm < n_batches - 1 { @@ -542,7 +542,9 @@ pub fn fast_mnn( let mut dist = 0.0 let mut uu = 0 while uu < top_components { - dist = dist + (pca_result[ss][uu] - pca_result[mnn_idx][uu]) * (pca_result[ss][uu] - pca_result[mnn_idx][uu]) + dist = dist + + (pca_result[ss][uu] - pca_result[mnn_idx][uu]) * + (pca_result[ss][uu] - pca_result[mnn_idx][uu]) uu = uu + 1 } let weight = @math.exp(-dist / (2.0 * sigma * sigma)) @@ -559,7 +561,8 @@ pub fn fast_mnn( if weight_sum > 0.0 { let mut ww = 0 while ww < top_components { - correction_vectors[ss][ww] = correction_vectors[ss][ww] + weighted_delta[ww] / weight_sum + correction_vectors[ss][ww] = correction_vectors[ss][ww] + + weighted_delta[ww] / weight_sum ww = ww + 1 } } @@ -583,7 +586,9 @@ pub fn fast_mnn( xx = xx + 1 } - BatchCorrectionResult::new(corrected, batch_indices, all_mnn_pairs, var_explained) + BatchCorrectionResult::new( + corrected, batch_indices, all_mnn_pairs, var_explained, + ) } ///| @@ -619,7 +624,11 @@ pub fn batchelor_create_example_data( x = x - 6.0 let base_expression = @math.exp(x) - let batch_factor = 1.0 + i.to_double() * batch_effect * (if k < n_genes / 2 { 1.0 } else { -1.0 }) * 0.1 + let batch_factor = 1.0 + + i.to_double() * + batch_effect * + (if k < n_genes / 2 { 1.0 } else { -1.0 }) * + 0.1 cell.push(base_expression * batch_factor) k = k + 1 @@ -637,7 +646,10 @@ pub fn batchelor_create_example_data( } ///| -pub fn compute_batch_mixing_score(corrected : Array[Array[Double]], batch_indices : Array[Int]) -> Double { +pub fn compute_batch_mixing_score( + corrected : Array[Array[Double]], + batch_indices : Array[Int], +) -> Double { let n_cells = corrected.length() let n_dims = if n_cells > 0 { corrected[0].length() } else { 0 } @@ -670,7 +682,9 @@ pub fn compute_batch_mixing_score(corrected : Array[Array[Double]], batch_indice let mut dist = 0.0 let mut k = 0 while k < n_dims { - dist = dist + (corrected[i][k] - corrected[j][k]) * (corrected[i][k] - corrected[j][k]) + dist = dist + + (corrected[i][k] - corrected[j][k]) * + (corrected[i][k] - corrected[j][k]) k = k + 1 } distances.push((dist.sqrt(), j)) @@ -703,7 +717,8 @@ pub fn compute_batch_mixing_score(corrected : Array[Array[Double]], batch_indice n = n + 1 } - score = score + (1.0 - same_batch_count.to_double() / n_neighbors.to_double()) + score = score + + (1.0 - same_batch_count.to_double() / n_neighbors.to_double()) i = i + 1 } diff --git a/src/bayes_space.mbt b/src/bayes_space.mbt index 4a042441..37f3e3d6 100644 --- a/src/bayes_space.mbt +++ b/src/bayes_space.mbt @@ -21,10 +21,10 @@ /// Spatial coordinates for a single spot. pub struct SpotCoord { spot_id : String - row : Int // array row index - col : Int // array column index - x : Double // continuous x coordinate (e.g. pixel) - y : Double // continuous y coordinate + row : Int // array row index + col : Int // array column index + x : Double // continuous x coordinate (e.g. pixel) + y : Double // continuous y coordinate } ///| @@ -43,10 +43,10 @@ pub fn spot_coord( /// BayesSpace clustering result. pub struct BayesSpaceResult { spot_ids : Array[String] - clusters : Array[Int] // cluster assignment per spot (0..q-1) - q : Int // number of clusters - cluster_centers : Array[Array[Double]] // q × n_features matrix - responsibilities : Array[Array[Double]] // n_spots × q soft assignments + clusters : Array[Int] // cluster assignment per spot (0..q-1) + q : Int // number of clusters + cluster_centers : Array[Array[Double]] // q × n_features matrix + responsibilities : Array[Array[Double]] // n_spots × q soft assignments n_iterations : Int log_likelihood : Double converged : Bool @@ -59,9 +59,7 @@ pub struct BayesSpaceResult { /// For square-grid compatibility we also include (r±1, c±1) as neighbors. /// /// Returns neighbor_indices[i] = list of spot indices that are neighbors of spot i. -pub fn bayes_space_hex_neighbors( - spots : Array[SpotCoord], -) -> Array[Array[Int]] { +pub fn bayes_space_hex_neighbors(spots : Array[SpotCoord]) -> Array[Array[Int]] { let n = spots.length() // Build a map from (row, col) to spot index let coord_map : Map[String, Int] = Map::new() @@ -353,7 +351,12 @@ pub fn bayes_space_run( while i < n_spots { let mut k = 0 while k < q { - let log_t = bayes_space_log_t_density(expression[i], centers[k], scales[k], d_df) + let log_t = bayes_space_log_t_density( + expression[i], + centers[k], + scales[k], + d_df, + ) let mut spatial = 0.0 let mut ni = 0 while ni < neighbors[i].length() { @@ -454,7 +457,12 @@ pub fn bayes_space_run( let mut max_lp = -1.0e18 let mut k = 0 while k < q { - let log_t = bayes_space_log_t_density(expression[i], centers[k], scales[k], d_df) + let log_t = bayes_space_log_t_density( + expression[i], + centers[k], + scales[k], + d_df, + ) let lp = @math.ln(pis[k]) + log_t if lp > max_lp { max_lp = lp @@ -464,7 +472,12 @@ pub fn bayes_space_run( let mut sum_exp = 0.0 k = 0 while k < q { - let log_t = bayes_space_log_t_density(expression[i], centers[k], scales[k], d_df) + let log_t = bayes_space_log_t_density( + expression[i], + centers[k], + scales[k], + d_df, + ) sum_exp = sum_exp + @math.exp(@math.ln(pis[k]) + log_t - max_lp) k = k + 1 } @@ -575,10 +588,18 @@ pub fn bayes_space_render_clusters( let mut max_c = spots[0].col let mut i = 1 while i < spots.length() { - if spots[i].row < min_r { min_r = spots[i].row } - if spots[i].row > max_r { max_r = spots[i].row } - if spots[i].col < min_c { min_c = spots[i].col } - if spots[i].col > max_c { max_c = spots[i].col } + if spots[i].row < min_r { + min_r = spots[i].row + } + if spots[i].row > max_r { + max_r = spots[i].row + } + if spots[i].col < min_c { + min_c = spots[i].col + } + if spots[i].col > max_c { + max_c = spots[i].col + } i = i + 1 } let label_chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" @@ -638,8 +659,20 @@ pub fn bayes_space_sample_data() -> (Array[Array[Double]], Array[SpotCoord]) { 2.0 } // 3-feature expression vector per spot - expression.push([base + noise, base * 0.8 + noise * 0.5, base * 1.2 + noise * 0.3]) - spots.push(spot_coord("spot_" + r.to_string() + "_" + c.to_string(), r, c, c.to_double(), r.to_double())) + expression.push([ + base + noise, + base * 0.8 + noise * 0.5, + base * 1.2 + noise * 0.3, + ]) + spots.push( + spot_coord( + "spot_" + r.to_string() + "_" + c.to_string(), + r, + c, + c.to_double(), + r.to_double(), + ), + ) c = c + 1 } r = r + 1 diff --git a/src/bayseq.mbt b/src/bayseq.mbt index 673a0ba0..bbd7bcf2 100644 --- a/src/bayseq.mbt +++ b/src/bayseq.mbt @@ -33,7 +33,10 @@ pub struct BayesResult { /// Estimate the dispersion parameter for a single gene using the method of moments. /// For Negative Binomial: Var = mean + mean^2 / dispersion /// => dispersion = mean^2 / (var - mean) -pub fn bayseq_estimate_dispersion_gene(counts_a : Array[Double], counts_b : Array[Double]) -> Double { +pub fn bayseq_estimate_dispersion_gene( + counts_a : Array[Double], + counts_b : Array[Double], +) -> Double { let n_a = counts_a.length() let n_b = counts_b.length() if n_a < 2 || n_b < 2 { @@ -86,12 +89,21 @@ pub fn bayseq_estimate_dispersion_gene(counts_a : Array[Double], counts_b : Arra } // Bound dispersion to reasonable range - if disp < 0.01 { 0.01 } else if disp > 100.0 { 100.0 } else { disp } + if disp < 0.01 { + 0.01 + } else if disp > 100.0 { + 100.0 + } else { + disp + } } ///| /// Estimate dispersion prior parameters (shape, rate) from all genes. -pub fn bayseq_estimate_prior(counts : Array[Array[Double]], groups : Array[Int]) -> (Double, Double) { +pub fn bayseq_estimate_prior( + counts : Array[Array[Double]], + groups : Array[Int], +) -> (Double, Double) { let n_genes = counts.length() if n_genes == 0 { return (2.0, 0.5) @@ -103,8 +115,11 @@ pub fn bayseq_estimate_prior(counts : Array[Array[Double]], groups : Array[Int]) let mut n_group_1 = 0 let mut gi = 0 while gi < groups.length() { - if groups[gi] == 0 { n_group_0 = n_group_0 + 1 } - else if groups[gi] == 1 { n_group_1 = n_group_1 + 1 } + if groups[gi] == 0 { + n_group_0 = n_group_0 + 1 + } else if groups[gi] == 1 { + n_group_1 = n_group_1 + 1 + } gi = gi + 1 } @@ -164,7 +179,9 @@ pub fn hts_count_group(groups : Array[Int], group_id : Int) -> Int { let mut count = 0 let mut i = 0 while i < groups.length() { - if groups[i] == group_id { count = count + 1 } + if groups[i] == group_id { + count = count + 1 + } i = i + 1 } count @@ -217,7 +234,11 @@ pub fn bayseq_log_likelihood_ratio( ///| /// Negative Binomial log-likelihood for a set of counts given mean and dispersion. -pub fn bayseq_nb_log_likelihood(counts : Array[Double], mean : Double, disp : Double) -> Double { +pub fn bayseq_nb_log_likelihood( + counts : Array[Double], + mean : Double, + disp : Double, +) -> Double { if mean <= 0.0 || disp <= 0.0 { return 0.0 } @@ -234,7 +255,11 @@ pub fn bayseq_nb_log_likelihood(counts : Array[Double], mean : Double, disp : Do let lgamma_x1 = bayseq_lgamma(x + 1.0) let lgamma_r = bayseq_lgamma(r) let ln_p = if p > 0.0 { @math.ln(p) } else { -10000000000.0 } - let ln_1mp = if (1.0 - p) > 0.0 { @math.ln(1.0 - p) } else { -10000000000.0 } + let ln_1mp = if 1.0 - p > 0.0 { + @math.ln(1.0 - p) + } else { + -10000000000.0 + } ll = ll + lgamma_xr - lgamma_x1 - lgamma_r + r * ln_p + x * ln_1mp } else { let lgamma_r = bayseq_lgamma(r) @@ -268,12 +293,8 @@ pub fn bayseq_lgamma(x : Double) -> Double { // Lanczos approximation for x >= 2 // Coefficients for g=5 let c = [ - 76.18009172947146, - -86.50532032941677, - 24.01409824083091, - -1.231739572450155, - 0.1208650973866179e-2, - -0.5395239384953e-5 + 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, + 0.1208650973866179e-2, -0.5395239384953e-5, ] let y = x let mut tmp = x + 5.5 @@ -326,9 +347,15 @@ pub fn bayseq_test( let mut sum_a = 0.0 let mut sum_b = 0.0 let mut i = 0 - while i < c_a.length() { sum_a = sum_a + c_a[i]; i = i + 1 } + while i < c_a.length() { + sum_a = sum_a + c_a[i] + i = i + 1 + } i = 0 - while i < c_b.length() { sum_b = sum_b + c_b[i]; i = i + 1 } + while i < c_b.length() { + sum_b = sum_b + c_b[i] + i = i + 1 + } let mean_a = sum_a / n_group_0.to_double() let mean_b = sum_b / n_group_1.to_double() @@ -349,9 +376,15 @@ pub fn bayseq_test( let prob_de = 1.0 / (1.0 + @math.exp(-llr)) let is_de = prob_de >= alpha - if is_de { de_count = de_count + 1 } + if is_de { + de_count = de_count + 1 + } - let name = if g < gene_names.length() { gene_names[g] } else { "Gene" + (g + 1).to_string() } + let name = if g < gene_names.length() { + gene_names[g] + } else { + "Gene" + (g + 1).to_string() + } results.push(BayesGeneResult::{ gene_index: g, @@ -361,7 +394,7 @@ pub fn bayseq_test( posterior_prob_de: prob_de, map_expression_a: mean_a, map_expression_b: mean_b, - is_de: is_de, + is_de, }) g = g + 1 } @@ -391,15 +424,26 @@ pub fn bayseq_get_de_genes(result : BayesResult) -> Array[BayesGeneResult] { ///| /// Get top DE genes sorted by absolute log fold change. -pub fn bayseq_get_top_de(result : BayesResult, n : Int) -> Array[BayesGeneResult] { +pub fn bayseq_get_top_de( + result : BayesResult, + n : Int, +) -> Array[BayesGeneResult] { let all = result.gene_results // Sort by absolute log_fold_change descending (bubble sort) let mut i = 0 while i < all.length() { let mut j = i + 1 while j < all.length() { - let abs_i = if all[i].log_fold_change >= 0.0 { all[i].log_fold_change } else { -all[i].log_fold_change } - let abs_j = if all[j].log_fold_change >= 0.0 { all[j].log_fold_change } else { -all[j].log_fold_change } + let abs_i = if all[i].log_fold_change >= 0.0 { + all[i].log_fold_change + } else { + -all[i].log_fold_change + } + let abs_j = if all[j].log_fold_change >= 0.0 { + all[j].log_fold_change + } else { + -all[j].log_fold_change + } if abs_j > abs_i { let tmp = all[i] all[i] = all[j] @@ -437,7 +481,7 @@ pub fn bayseq_sample_data() -> (Array[Array[Double]], Array[Int], Array[String]) let base_a = 500.0 let base_b = if g < 8 { 1500.0 } else if g < 16 { 200.0 } else { 500.0 } let base = if groups[s] == 0 { base_a } else { base_b } - let noise = (((g * 7 + s * 17) % 100).to_double() / 100.0) * base * 0.3 + let noise = ((g * 7 + s * 17) % 100).to_double() / 100.0 * base * 0.3 let val = base + noise row.push(val) s = s + 1 @@ -453,10 +497,17 @@ pub fn bayseq_sample_data() -> (Array[Array[Double]], Array[Int], Array[String]) /// Summarize the baySeq result. pub fn bayseq_summary(result : BayesResult) -> String { "baySeq Analysis Summary:\n" + - " Total genes: " + result.gene_results.length().to_string() + "\n" + - " DE genes (posterior >= " + result.alpha_level.to_string() + "): " + - result.n_de_genes.to_string() + "\n" + - " Dispersion prior: Gamma(shape=" + - result.dispersion_prior_shape.to_string() + - ", rate=" + result.dispersion_prior_rate.to_string() + ")" + " Total genes: " + + result.gene_results.length().to_string() + + "\n" + + " DE genes (posterior >= " + + result.alpha_level.to_string() + + "): " + + result.n_de_genes.to_string() + + "\n" + + " Dispersion prior: Gamma(shape=" + + result.dispersion_prior_shape.to_string() + + ", rate=" + + result.dispersion_prior_rate.to_string() + + ")" } diff --git a/src/beachmat.mbt b/src/beachmat.mbt index 7f52927a..11dba5b8 100644 --- a/src/beachmat.mbt +++ b/src/beachmat.mbt @@ -37,25 +37,45 @@ pub struct BmatParam { ///| /// Create default parameters. pub fn BmatParam::new() -> BmatParam { - { row_block_size: 0, col_block_size: 0, cache_data: true, storage_mode: BmatStorageMode::Dense } + { + row_block_size: 0, + col_block_size: 0, + cache_data: true, + storage_mode: BmatStorageMode::Dense, + } } ///| /// Create parameters with specific block sizes. pub fn BmatParam::with_blocks(row_block : Int, col_block : Int) -> BmatParam { - { row_block_size: row_block, col_block_size: col_block, cache_data: true, storage_mode: BmatStorageMode::Dense } + { + row_block_size: row_block, + col_block_size: col_block, + cache_data: true, + storage_mode: BmatStorageMode::Dense, + } } ///| /// Create parameters for column-wise access. pub fn BmatParam::column_param(block_size : Int) -> BmatParam { - { row_block_size: 0, col_block_size: block_size, cache_data: true, storage_mode: BmatStorageMode::Dense } + { + row_block_size: 0, + col_block_size: block_size, + cache_data: true, + storage_mode: BmatStorageMode::Dense, + } } ///| /// Create parameters for row-wise access. pub fn BmatParam::row_param(block_size : Int) -> BmatParam { - { row_block_size: block_size, col_block_size: 0, cache_data: true, storage_mode: BmatStorageMode::Dense } + { + row_block_size: block_size, + col_block_size: 0, + cache_data: true, + storage_mode: BmatStorageMode::Dense, + } } ///| @@ -217,7 +237,11 @@ pub fn bmat_apply_col_blocks( let n_cols = bmat.dim_cols let mut col = 0 while col < n_cols { - let end = if col + col_block_size < n_cols { col + col_block_size } else { n_cols } + let end = if col + col_block_size < n_cols { + col + col_block_size + } else { + n_cols + } let block_data : Array[Array[Double]] = [] let mut i = 0 while i < bmat.dim_rows { @@ -230,7 +254,13 @@ pub fn bmat_apply_col_blocks( block_data.push(row_data) i = i + 1 } - let block = BmatBlock::{ row_start: 0, row_end: bmat.dim_rows, col_start: col, col_end: end, block_data } + let block = BmatBlock::{ + row_start: 0, + row_end: bmat.dim_rows, + col_start: col, + col_end: end, + block_data, + } apply_fn(block) col = end } @@ -246,7 +276,11 @@ pub fn bmat_apply_row_blocks( let n_rows = bmat.dim_rows let mut row = 0 while row < n_rows { - let end = if row + row_block_size < n_rows { row + row_block_size } else { n_rows } + let end = if row + row_block_size < n_rows { + row + row_block_size + } else { + n_rows + } let block_data : Array[Array[Double]] = [] let mut i = row while i < end { @@ -259,7 +293,13 @@ pub fn bmat_apply_row_blocks( block_data.push(row_data) i = i + 1 } - let block = BmatBlock::{ row_start: row, row_end: end, col_start: 0, col_end: bmat.dim_cols, block_data } + let block = BmatBlock::{ + row_start: row, + row_end: end, + col_start: 0, + col_end: bmat.dim_cols, + block_data, + } apply_fn(block) row = end } @@ -267,10 +307,7 @@ pub fn bmat_apply_row_blocks( ///| /// Iterate over the full matrix and apply a function. -pub fn bmat_foreach( - bmat : Bmat, - iter_fn : (Int, Int, Double) -> Unit, -) -> Unit { +pub fn bmat_foreach(bmat : Bmat, iter_fn : (Int, Int, Double) -> Unit) -> Unit { let mut i = 0 while i < bmat.dim_rows { let mut j = 0 @@ -298,7 +335,12 @@ pub struct BmatIterator { ///| /// Create a new iterator. pub fn BmatIterator::new(bmat : Bmat) -> BmatIterator { - { data: bmat.data, total_cols: bmat.dim_cols, total: bmat.dim_rows * bmat.dim_cols, pos: 0 } + { + data: bmat.data, + total_cols: bmat.dim_cols, + total: bmat.dim_rows * bmat.dim_cols, + pos: 0, + } } ///| @@ -321,13 +363,21 @@ pub fn BmatIterator::next(self : BmatIterator) -> Double? { ///| /// Get current row index. pub fn BmatIterator::cur_row(self : BmatIterator) -> Int { - if self.total_cols == 0 { 0 } else { self.pos / self.total_cols } + if self.total_cols == 0 { + 0 + } else { + self.pos / self.total_cols + } } ///| /// Get current column index. pub fn BmatIterator::cur_col(self : BmatIterator) -> Int { - if self.total_cols == 0 { 0 } else { self.pos % self.total_cols } + if self.total_cols == 0 { + 0 + } else { + self.pos % self.total_cols + } } // ============================================================================ @@ -454,10 +504,7 @@ pub fn bmat_bind_rows(top : Bmat, bottom : Bmat) -> Bmat { ///| /// Apply a function to each element. -pub fn bmat_apply_elementwise( - bmat : Bmat, - map_fn : (Double) -> Double, -) -> Bmat { +pub fn bmat_apply_elementwise(bmat : Bmat, map_fn : (Double) -> Double) -> Bmat { let new_data : Array[Array[Double]] = [] let mut i = 0 while i < bmat.dim_rows { @@ -476,7 +523,11 @@ pub fn bmat_apply_elementwise( ///| /// Pretty-print a Bmat. pub fn Bmat::to_string(self : Bmat) -> String { - let mut s = "Bmat (" + self.dim_rows.to_string() + " x " + self.dim_cols.to_string() + "):\n" + let mut s = "Bmat (" + + self.dim_rows.to_string() + + " x " + + self.dim_cols.to_string() + + "):\n" let mut i = 0 while i < self.dim_rows { let mut j = 0 diff --git a/src/binary_cif.mbt b/src/binary_cif.mbt index c8a6fa2a..6b897458 100644 --- a/src/binary_cif.mbt +++ b/src/binary_cif.mbt @@ -174,9 +174,11 @@ pub fn BinaryCifDataBlock::get_category( ) -> BinaryCifCategory? { for category in self.categories { if category.name == name || - (name.length() > 0 && - name.unsafe_get(0).to_int() != '_'.to_int() && - category.name == "_" + name) { + ( + name.length() > 0 && + name.unsafe_get(0).to_int() != '_'.to_int() && + category.name == "_" + name + ) { return Some(category) } } @@ -218,6 +220,7 @@ pub fn BinaryCifFile::summary(self : BinaryCifFile) -> String { // MessagePack model and decoder. +///| priv enum BcifMessage { BcifNil BcifBoolean(Bool) @@ -229,11 +232,13 @@ priv enum BcifMessage { BcifMapValue(Map[String, BcifMessage]) } +///| priv struct BcifReader { data : Array[Int] mut position : Int } +///| fn bcif_read_byte(reader : BcifReader) -> Int raise BinaryCifError { if reader.position >= reader.data.length() { raise BinaryCifError("Truncated MessagePack input") @@ -243,6 +248,7 @@ fn bcif_read_byte(reader : BcifReader) -> Int raise BinaryCifError { value } +///| fn bcif_read_unsigned( reader : BcifReader, byte_count : Int, @@ -264,6 +270,7 @@ fn bcif_read_unsigned( value } +///| fn bcif_read_signed( reader : BcifReader, byte_count : Int, @@ -282,6 +289,7 @@ fn bcif_read_signed( value } +///| fn bcif_read_u64(reader : BcifReader) -> Int raise BinaryCifError { for _ in 0..<4 { if bcif_read_byte(reader) != 0 { @@ -291,6 +299,7 @@ fn bcif_read_u64(reader : BcifReader) -> Int raise BinaryCifError { bcif_read_unsigned(reader, 4) } +///| fn bcif_read_i64(reader : BcifReader) -> Int raise BinaryCifError { if reader.position + 8 > reader.data.length() { raise BinaryCifError("Truncated MessagePack int64") @@ -309,6 +318,7 @@ fn bcif_read_i64(reader : BcifReader) -> Int raise BinaryCifError { bcif_read_signed(reader, 4) } +///| fn bcif_pow2(exponent : Int) -> Double { let mut power = if exponent < 0 { -exponent } else { exponent } let mut base = 2.0 @@ -320,9 +330,14 @@ fn bcif_pow2(exponent : Int) -> Double { base = base * base power = power / 2 } - if exponent < 0 { 1.0 / result } else { result } + if exponent < 0 { + 1.0 / result + } else { + result + } } +///| fn bcif_float32_from_bytes( b0 : Int, b1 : Int, @@ -338,12 +353,11 @@ fn bcif_float32_from_bytes( if exponent == 0 { sign * mantissa.to_double() * bcif_pow2(-149) } else { - sign * - (1.0 + mantissa.to_double() / 8388608.0) * - bcif_pow2(exponent - 127) + sign * (1.0 + mantissa.to_double() / 8388608.0) * bcif_pow2(exponent - 127) } } +///| fn bcif_float64_from_bytes( bytes : Array[Int], offset : Int, @@ -375,6 +389,7 @@ fn bcif_float64_from_bytes( } } +///| fn bcif_read_float32(reader : BcifReader) -> Double raise BinaryCifError { let b0 = bcif_read_byte(reader) let b1 = bcif_read_byte(reader) @@ -383,6 +398,7 @@ fn bcif_read_float32(reader : BcifReader) -> Double raise BinaryCifError { bcif_float32_from_bytes(b0, b1, b2, b3) } +///| fn bcif_read_float64(reader : BcifReader) -> Double raise BinaryCifError { if reader.position + 8 > reader.data.length() { raise BinaryCifError("Truncated MessagePack float64") @@ -392,6 +408,7 @@ fn bcif_read_float64(reader : BcifReader) -> Double raise BinaryCifError { value } +///| fn bcif_read_utf8( reader : BcifReader, length : Int, @@ -413,7 +430,9 @@ fn bcif_read_utf8( if second < 0x80 || second > 0xBF { raise BinaryCifError("Invalid UTF-8 continuation byte") } - output.write_char(((first & 0x1F) * 64 + (second & 0x3F)).unsafe_to_char()) + output.write_char( + ((first & 0x1F) * 64 + (second & 0x3F)).unsafe_to_char(), + ) } else if first >= 0xE0 && first <= 0xEF { if reader.position + 2 > end { raise BinaryCifError("Truncated UTF-8 sequence") @@ -429,11 +448,7 @@ fn bcif_read_utf8( raise BinaryCifError("Invalid UTF-8 sequence") } output.write_char( - ( - (first & 0x0F) * 4096 + - (second & 0x3F) * 64 + - (third & 0x3F) - ).unsafe_to_char(), + ((first & 0x0F) * 4096 + (second & 0x3F) * 64 + (third & 0x3F)).unsafe_to_char(), ) } else if first >= 0xF0 && first <= 0xF4 { if reader.position + 3 > end { @@ -453,12 +468,10 @@ fn bcif_read_utf8( raise BinaryCifError("Invalid UTF-8 sequence") } output.write_char( - ( - (first & 0x07) * 262144 + - (second & 0x3F) * 4096 + - (third & 0x3F) * 64 + - (fourth & 0x3F) - ).unsafe_to_char(), + ((first & 0x07) * 262144 + + (second & 0x3F) * 4096 + + (third & 0x3F) * 64 + + (fourth & 0x3F)).unsafe_to_char(), ) } else { raise BinaryCifError("Invalid UTF-8 leading byte") @@ -467,6 +480,7 @@ fn bcif_read_utf8( output.to_string() } +///| fn bcif_read_binary( reader : BcifReader, length : Int, @@ -481,6 +495,7 @@ fn bcif_read_binary( result } +///| fn bcif_parse_message( reader : BcifReader, depth : Int, @@ -513,9 +528,12 @@ fn bcif_parse_message( 0xC0 => BcifNil 0xC2 => BcifBoolean(false) 0xC3 => BcifBoolean(true) - 0xC4 => BcifBinaryValue(bcif_read_binary(reader, bcif_read_unsigned(reader, 1))) - 0xC5 => BcifBinaryValue(bcif_read_binary(reader, bcif_read_unsigned(reader, 2))) - 0xC6 => BcifBinaryValue(bcif_read_binary(reader, bcif_read_unsigned(reader, 4))) + 0xC4 => + BcifBinaryValue(bcif_read_binary(reader, bcif_read_unsigned(reader, 1))) + 0xC5 => + BcifBinaryValue(bcif_read_binary(reader, bcif_read_unsigned(reader, 2))) + 0xC6 => + BcifBinaryValue(bcif_read_binary(reader, bcif_read_unsigned(reader, 4))) 0xCA => BcifFloatValue(bcif_read_float32(reader)) 0xCB => BcifFloatValue(bcif_read_float64(reader)) 0xCC => BcifIntegerValue(bcif_read_unsigned(reader, 1)) @@ -547,12 +565,14 @@ fn bcif_parse_message( } 0xDE => bcif_parse_map(reader, bcif_read_unsigned(reader, 2), depth + 1) 0xDF => bcif_parse_map(reader, bcif_read_unsigned(reader, 4), depth + 1) - _ => raise BinaryCifError( - "Unsupported MessagePack marker " + marker.to_string(), - ) + _ => + raise BinaryCifError( + "Unsupported MessagePack marker " + marker.to_string(), + ) } } +///| fn bcif_parse_map( reader : BcifReader, length : Int, @@ -569,6 +589,7 @@ fn bcif_parse_map( BcifMapValue(values) } +///| fn bcif_as_map( value : BcifMessage, context : String, @@ -579,6 +600,7 @@ fn bcif_as_map( } } +///| fn bcif_as_array( value : BcifMessage, context : String, @@ -589,6 +611,7 @@ fn bcif_as_array( } } +///| fn bcif_as_string( value : BcifMessage, context : String, @@ -599,6 +622,7 @@ fn bcif_as_string( } } +///| fn bcif_as_int( value : BcifMessage, context : String, @@ -609,6 +633,7 @@ fn bcif_as_int( } } +///| fn bcif_as_double( value : BcifMessage, context : String, @@ -620,6 +645,7 @@ fn bcif_as_double( } } +///| fn bcif_as_bool( value : BcifMessage, context : String, @@ -630,6 +656,7 @@ fn bcif_as_bool( } } +///| fn bcif_as_binary( value : BcifMessage, context : String, @@ -640,6 +667,7 @@ fn bcif_as_binary( } } +///| fn bcif_required( values : Map[String, BcifMessage], key : String, @@ -651,6 +679,7 @@ fn bcif_required( } } +///| fn bcif_encoding_int( values : Map[String, BcifMessage], key : String, @@ -659,6 +688,7 @@ fn bcif_encoding_int( bcif_as_int(bcif_required(values, key, context), context + "." + key) } +///| fn bcif_encoding_double( values : Map[String, BcifMessage], key : String, @@ -669,15 +699,18 @@ fn bcif_encoding_double( // BinaryCIF encoding decoders. +///| fn bcif_read_i16_le(data : Array[Int], offset : Int) -> Int { let high = data[offset + 1] (if high >= 128 { high - 256 } else { high }) * 256 + data[offset] } +///| fn bcif_read_u16_le(data : Array[Int], offset : Int) -> Int { data[offset] + data[offset + 1] * 256 } +///| fn bcif_read_i32_le(data : Array[Int], offset : Int) -> Int { let high = data[offset + 3] (if high >= 128 { high - 256 } else { high }) * 16777216 + @@ -686,6 +719,7 @@ fn bcif_read_i32_le(data : Array[Int], offset : Int) -> Int { data[offset] } +///| fn bcif_read_u32_le( data : Array[Int], offset : Int, @@ -699,6 +733,7 @@ fn bcif_read_u32_le( data[offset] } +///| fn bcif_validate_bytes(data : Array[Int]) -> Unit raise BinaryCifError { for value in data { if value < 0 || value > 255 { @@ -728,7 +763,11 @@ pub fn binary_cif_decode_int_bytes( let value = match type_code { 1 => { let raw = data[offset] - if raw >= 128 { raw - 256 } else { raw } + if raw >= 128 { + raw - 256 + } else { + raw + } } 2 => bcif_read_i16_le(data, offset) 3 => bcif_read_i32_le(data, offset) @@ -752,10 +791,13 @@ pub fn binary_cif_decode_float_bytes( let width = match type_code { 32 => 4 33 => 8 - _ => raise BinaryCifError("BinaryCIF type is not a floating-point byte array") + _ => + raise BinaryCifError("BinaryCIF type is not a floating-point byte array") } if data.length() % width != 0 { - raise BinaryCifError("BinaryCIF floating-point byte array has an invalid length") + raise BinaryCifError( + "BinaryCIF floating-point byte array has an invalid length", + ) } let result = Array::new(capacity=data.length() / width) let mut offset = 0 @@ -791,7 +833,11 @@ pub fn binary_cif_decode_integer_packing( raise BinaryCifError("BinaryCIF integer packing source size is negative") } let upper = if is_unsigned { - if byte_count == 1 { 255 } else { 65535 } + if byte_count == 1 { + 255 + } else { + 65535 + } } else if byte_count == 1 { 127 } else { @@ -808,7 +854,9 @@ pub fn binary_cif_decode_integer_packing( let mut accumulator = 0 for value in data { if value < lower || value > upper { - raise BinaryCifError("BinaryCIF integer packing value is outside its byte range") + raise BinaryCifError( + "BinaryCIF integer packing value is outside its byte range", + ) } accumulator = accumulator + value let continuation = value == upper || (!is_unsigned && value == lower) @@ -851,10 +899,7 @@ pub fn binary_cif_decode_run_length( } ///| -pub fn binary_cif_decode_delta( - data : Array[Int], - origin : Int, -) -> Array[Int] { +pub fn binary_cif_decode_delta(data : Array[Int], origin : Int) -> Array[Int] { let result = Array::new(capacity=data.length()) let mut current = origin for value in data { @@ -870,7 +915,9 @@ pub fn binary_cif_decode_fixed_point( factor : Double, ) -> Array[Double] raise BinaryCifError { if factor == 0.0 || factor.abs() > 1.0e300 { - raise BinaryCifError("BinaryCIF fixed-point factor must be finite and non-zero") + raise BinaryCifError( + "BinaryCIF fixed-point factor must be finite and non-zero", + ) } let result = Array::new(capacity=data.length()) for value in data { @@ -918,13 +965,13 @@ pub fn binary_cif_decode_string_array( } } if offsets[offsets.length() - 1] != string_data.length() { - raise BinaryCifError("BinaryCIF string offsets do not cover the string data") + raise BinaryCifError( + "BinaryCIF string offsets do not cover the string data", + ) } let dictionary = Array::new(capacity=offsets.length() - 1) for i in 0..<(offsets.length() - 1) { - dictionary.push( - string_data[offsets[i]:offsets[i + 1]].to_owned(), - ) + dictionary.push(string_data[offsets[i]:offsets[i + 1]].to_owned()) } let result = Array::new(capacity=indices.length()) for index in indices { @@ -936,6 +983,7 @@ pub fn binary_cif_decode_string_array( result } +///| fn bcif_decoded_length(data : BinaryCifColumnData) -> Int { match data { BinaryCifIntegers(values) => values.length() @@ -944,6 +992,7 @@ fn bcif_decoded_length(data : BinaryCifColumnData) -> Int { } } +///| fn bcif_decode_raw( bytes : Array[Int], encodings : Array[BcifMessage], @@ -961,7 +1010,10 @@ fn bcif_decode_raw( "ByteArray" => { let source = match raw_bytes { Some(value) => value - None => raise BinaryCifError("ByteArray must be the final BinaryCIF encoding") + None => + raise BinaryCifError( + "ByteArray must be the final BinaryCIF encoding", + ) } let type_code = bcif_encoding_int(encoding, "type", "ByteArray") decoded = Some( @@ -978,8 +1030,12 @@ fn bcif_decode_raw( Some(BinaryCifIntegers(value)) => value _ => raise BinaryCifError("IntegerPacking requires integer input") } - let byte_count = bcif_encoding_int(encoding, "byteCount", "IntegerPacking") - let source_size = bcif_encoding_int(encoding, "srcSize", "IntegerPacking") + let byte_count = bcif_encoding_int( + encoding, "byteCount", "IntegerPacking", + ) + let source_size = bcif_encoding_int( + encoding, "srcSize", "IntegerPacking", + ) let is_unsigned = bcif_as_bool( bcif_required(encoding, "isUnsigned", "IntegerPacking"), "IntegerPacking.isUnsigned", @@ -987,10 +1043,7 @@ fn bcif_decode_raw( decoded = Some( BinaryCifIntegers( binary_cif_decode_integer_packing( - values, - byte_count, - is_unsigned, - source_size, + values, byte_count, is_unsigned, source_size, ), ), ) @@ -1040,7 +1093,8 @@ fn bcif_decode_raw( "IntervalQuantization" => { let values = match decoded { Some(BinaryCifIntegers(value)) => value - _ => raise BinaryCifError("IntervalQuantization requires integer input") + _ => + raise BinaryCifError("IntervalQuantization requires integer input") } let steps = match encoding.get("numSteps") { Some(value) => bcif_as_int(value, "IntervalQuantization.numSteps") @@ -1080,11 +1134,15 @@ fn bcif_decode_raw( ) let indices = match bcif_decode_raw(source, data_encodings) { BinaryCifIntegers(value) => value - _ => raise BinaryCifError("StringArray lookup data must decode to integers") + _ => + raise BinaryCifError( + "StringArray lookup data must decode to integers", + ) } let offsets = match bcif_decode_raw(offsets_bytes, offset_encodings) { BinaryCifIntegers(value) => value - _ => raise BinaryCifError("StringArray offsets must decode to integers") + _ => + raise BinaryCifError("StringArray offsets must decode to integers") } decoded = Some( BinaryCifStrings( @@ -1110,6 +1168,7 @@ fn bcif_decode_raw( } } +///| fn bcif_decode_data( value : BcifMessage, context : String, @@ -1126,6 +1185,7 @@ fn bcif_decode_data( bcif_decode_raw(bytes, encodings) } +///| fn bcif_parse_column( value : BcifMessage, row_count : Int, @@ -1150,7 +1210,9 @@ fn bcif_parse_column( match bcif_decode_data(mask_value, "BinaryCIF column mask") { BinaryCifIntegers(values) => { if values.length() != row_count { - raise BinaryCifError("BinaryCIF mask length does not match rowCount") + raise BinaryCifError( + "BinaryCIF mask length does not match rowCount", + ) } for item in values { if item < 0 || item > 2 { @@ -1165,6 +1227,7 @@ fn bcif_parse_column( BinaryCifColumn::{ name, data, mask } } +///| fn bcif_parse_category( value : BcifMessage, ) -> BinaryCifCategory raise BinaryCifError { @@ -1197,6 +1260,7 @@ fn bcif_parse_category( BinaryCifCategory::{ name, row_count, columns } } +///| fn bcif_parse_block( value : BcifMessage, ) -> BinaryCifDataBlock raise BinaryCifError { @@ -1214,7 +1278,9 @@ fn bcif_parse_block( for raw_category in raw_categories { let category = bcif_parse_category(raw_category) if seen.contains(category.name) { - raise BinaryCifError("Duplicate BinaryCIF category '" + category.name + "'") + raise BinaryCifError( + "Duplicate BinaryCIF category '" + category.name + "'", + ) } seen[category.name] = true categories.push(category) @@ -1235,13 +1301,12 @@ pub fn binary_cif_parse( } } if input.length() >= 2 && input[0] == 0x1F && input[1] == 0x8B { - raise BinaryCifError("Gzip-compressed BinaryCIF input must be decompressed first") + raise BinaryCifError( + "Gzip-compressed BinaryCIF input must be decompressed first", + ) } let reader = BcifReader::{ data: input, position: 0 } - let root = bcif_as_map( - bcif_parse_message(reader, 0), - "BinaryCIF document", - ) + let root = bcif_as_map(bcif_parse_message(reader, 0), "BinaryCIF document") if reader.position != input.length() { raise BinaryCifError("Additional bytes follow the BinaryCIF document") } @@ -1269,6 +1334,7 @@ pub fn binary_cif_parse( // PDB Structure conversion. +///| priv struct BcifResidueBuilder { resname : String chain_id : Char @@ -1278,65 +1344,80 @@ priv struct BcifResidueBuilder { atoms : Array[Atom] } +///| priv struct BcifChainBuilder { full_id : String chain_id : Char residues : Array[BcifResidueBuilder] } +///| priv struct BcifModelBuilder { model_number : Int chains : Array[BcifChainBuilder] } +///| fn bcif_require_column( category : BinaryCifCategory, name : String, ) -> BinaryCifColumn raise BinaryCifError { match category.get_column(name) { Some(column) => column - None => raise BinaryCifError( - "BinaryCIF category '" + category.name + "' is missing column '" + name + "'", - ) + None => + raise BinaryCifError( + "BinaryCIF category '" + + category.name + + "' is missing column '" + + name + + "'", + ) } } +///| fn bcif_required_string( column : BinaryCifColumn, row : Int, ) -> String raise BinaryCifError { match column.string_at(row) { Some(value) => value - None => raise BinaryCifError( - "Required BinaryCIF value '" + column.name + "' is missing", - ) + None => + raise BinaryCifError( + "Required BinaryCIF value '" + column.name + "' is missing", + ) } } +///| fn bcif_required_int( column : BinaryCifColumn, row : Int, ) -> Int raise BinaryCifError { match column.int_at(row) { Some(value) => value - None => raise BinaryCifError( - "Required BinaryCIF value '" + column.name + "' is missing", - ) + None => + raise BinaryCifError( + "Required BinaryCIF value '" + column.name + "' is missing", + ) } } +///| fn bcif_required_double( column : BinaryCifColumn, row : Int, ) -> Double raise BinaryCifError { match column.double_at(row) { Some(value) => value - None => raise BinaryCifError( - "Required BinaryCIF value '" + column.name + "' is missing", - ) + None => + raise BinaryCifError( + "Required BinaryCIF value '" + column.name + "' is missing", + ) } } +///| fn bcif_optional_string( category : BinaryCifCategory, name : String, @@ -1353,6 +1434,7 @@ fn bcif_optional_string( } } +///| fn bcif_optional_int( category : BinaryCifCategory, name : String, @@ -1369,6 +1451,7 @@ fn bcif_optional_int( } } +///| fn bcif_optional_double( category : BinaryCifCategory, name : String, @@ -1385,6 +1468,7 @@ fn bcif_optional_double( } } +///| fn bcif_first_char_or_space(value : String) -> Char { if value.length() == 0 || value == "." || value == "?" { ' ' @@ -1393,14 +1477,20 @@ fn bcif_first_char_or_space(value : String) -> Char { } } +///| fn bcif_hetero_field(group : String, component : String) -> String { if group == "HETATM" { - if component == "HOH" || component == "WAT" { "W" } else { "H" } + if component == "HOH" || component == "WAT" { + "W" + } else { + "H" + } } else { " " } } +///| fn bcif_entry_id(file : BinaryCifFile) -> String raise BinaryCifError { let block = file.data_blocks[0] match block.get_category("_entry") { @@ -1440,10 +1530,7 @@ pub fn binary_cif_to_structure( let builders : Array[BcifModelBuilder] = [] for row in 0.. BcifMessage { let values : Map[String, BcifMessage] = Map([], capacity=entries.length()) for entry in entries { @@ -1577,15 +1663,18 @@ fn bcif_message_map(entries : Array[(String, BcifMessage)]) -> BcifMessage { BcifMapValue(values) } +///| fn bcif_message_array(values : Array[BcifMessage]) -> BcifMessage { BcifArrayValue(values) } +///| fn bcif_write_u16_be(output : Array[Int], value : Int) -> Unit { output.push((value >> 8) & 0xFF) output.push(value & 0xFF) } +///| fn bcif_write_u32_be(output : Array[Int], value : Int) -> Unit { output.push((value >> 24) & 0xFF) output.push((value >> 16) & 0xFF) @@ -1593,6 +1682,7 @@ fn bcif_write_u32_be(output : Array[Int], value : Int) -> Unit { output.push(value & 0xFF) } +///| fn bcif_write_i32_le(output : Array[Int], value : Int) -> Unit { output.push(value & 0xFF) output.push((value >> 8) & 0xFF) @@ -1600,6 +1690,7 @@ fn bcif_write_i32_le(output : Array[Int], value : Int) -> Unit { output.push((value >> 24) & 0xFF) } +///| fn bcif_pack_length( output : Array[Int], small_base : Int, @@ -1618,6 +1709,7 @@ fn bcif_pack_length( } } +///| fn bcif_pack_string(output : Array[Int], value : String) -> Unit { let length = value.length() if length < 32 { @@ -1637,6 +1729,7 @@ fn bcif_pack_string(output : Array[Int], value : String) -> Unit { } } +///| fn bcif_pack_float64(output : Array[Int], value : Double) -> Unit { output.push(0xCB) if value == 0.0 { @@ -1671,6 +1764,7 @@ fn bcif_pack_float64(output : Array[Int], value : Double) -> Unit { } } +///| fn bcif_pack_message(output : Array[Int], value : BcifMessage) -> Unit { match value { BcifNil => output.push(0xC0) @@ -1719,6 +1813,7 @@ fn bcif_pack_message(output : Array[Int], value : BcifMessage) -> Unit { } } +///| fn bcif_byte_array_encoding(type_code : Int) -> BcifMessage { bcif_message_map([ ("kind", BcifTextValue("ByteArray")), @@ -1726,10 +1821,8 @@ fn bcif_byte_array_encoding(type_code : Int) -> BcifMessage { ]) } -fn bcif_sample_int_column( - name : String, - values : Array[Int], -) -> BcifMessage { +///| +fn bcif_sample_int_column(name : String, values : Array[Int]) -> BcifMessage { let bytes = Array::new(capacity=values.length() * 4) for value in values { bcif_write_i32_le(bytes, value) @@ -1746,6 +1839,7 @@ fn bcif_sample_int_column( ]) } +///| fn bcif_sample_fixed_column( name : String, scaled_values : Array[Int], @@ -1788,6 +1882,7 @@ fn bcif_sample_fixed_column( ]) } +///| fn bcif_sample_string_column( name : String, values : Array[String], @@ -1867,32 +1962,27 @@ fn bcif_sample_string_column( pub fn binary_cif_sample_bytes() -> Array[Int] { let atom_count = 8 let atom_columns = [ - bcif_sample_string_column( - "group_PDB", - ["ATOM", "ATOM", "ATOM", "ATOM", "ATOM", "HETATM", "ATOM", "ATOM"], - ), + bcif_sample_string_column("group_PDB", [ + "ATOM", "ATOM", "ATOM", "ATOM", "ATOM", "HETATM", "ATOM", "ATOM", + ]), bcif_sample_int_column("id", [1, 2, 3, 4, 5, 6, 7, 8]), - bcif_sample_string_column( - "type_symbol", - ["N", "C", "C", "N", "C", "O", "N", "C"], - ), - bcif_sample_string_column( - "label_atom_id", - ["N", "CA", "C", "N", "CA", "O", "N", "CA"], - ), + bcif_sample_string_column("type_symbol", [ + "N", "C", "C", "N", "C", "O", "N", "C", + ]), + bcif_sample_string_column("label_atom_id", [ + "N", "CA", "C", "N", "CA", "O", "N", "CA", + ]), bcif_sample_string_column( "label_alt_id", ["", "", "", "A", "A", "", "", ""], mask=[1, 1, 1, 0, 0, 1, 2, 1], ), - bcif_sample_string_column( - "label_comp_id", - ["GLY", "GLY", "GLY", "ALA", "ALA", "HOH", "SER", "SER"], - ), - bcif_sample_string_column( - "label_asym_id", - ["A", "A", "A", "A", "A", "B", "A", "A"], - ), + bcif_sample_string_column("label_comp_id", [ + "GLY", "GLY", "GLY", "ALA", "ALA", "HOH", "SER", "SER", + ]), + bcif_sample_string_column("label_asym_id", [ + "A", "A", "A", "A", "A", "B", "A", "A", + ]), bcif_sample_int_column("auth_seq_id", [1, 1, 1, 2, 2, 10, 1, 1]), bcif_sample_string_column( "pdbx_PDB_ins_code", @@ -1942,9 +2032,7 @@ pub fn binary_cif_sample_bytes() -> Array[Int] { ("rowCount", BcifIntegerValue(1)), ( "columns", - bcif_message_array([ - bcif_sample_string_column("id", ["BCIF"]), - ]), + bcif_message_array([bcif_sample_string_column("id", ["BCIF"])]), ), ]), bcif_message_map([ diff --git a/src/bioc_generics.mbt b/src/bioc_generics.mbt index 6e010b0a..970297e7 100644 --- a/src/bioc_generics.mbt +++ b/src/bioc_generics.mbt @@ -164,7 +164,7 @@ pub fn order_int(arr : Array[Int]) -> Array[Int] { indices.push(i) i = i + 1 } - + let mut sorted = false while !sorted { sorted = true @@ -180,7 +180,7 @@ pub fn order_int(arr : Array[Int]) -> Array[Int] { i = i + 1 } } - + indices } @@ -193,7 +193,7 @@ pub fn order_double(arr : Array[Double]) -> Array[Int] { indices.push(i) i = i + 1 } - + let mut sorted = false while !sorted { sorted = true @@ -209,7 +209,7 @@ pub fn order_double(arr : Array[Double]) -> Array[Int] { i = i + 1 } } - + indices } @@ -241,7 +241,7 @@ pub fn sort_double(arr : Array[Double]) -> Array[Double] { pub fn unique_int(arr : Array[Int]) -> Array[Int] { let result : Array[Int] = Array::new() let seen = Map([], capacity=arr.length()) - + let mut i = 0 while i < arr.length() { if !seen.contains(arr[i].to_string()) { @@ -250,7 +250,7 @@ pub fn unique_int(arr : Array[Int]) -> Array[Int] { } i = i + 1 } - + result } @@ -258,7 +258,7 @@ pub fn unique_int(arr : Array[Int]) -> Array[Int] { pub fn unique_double(arr : Array[Double]) -> Array[Double] { let result : Array[Double] = Array::new() let seen = Map([], capacity=arr.length()) - + let mut i = 0 while i < arr.length() { if !seen.contains(arr[i].to_string()) { @@ -267,7 +267,7 @@ pub fn unique_double(arr : Array[Double]) -> Array[Double] { } i = i + 1 } - + result } @@ -275,7 +275,7 @@ pub fn unique_double(arr : Array[Double]) -> Array[Double] { pub fn unique_string(arr : Array[String]) -> Array[String] { let result : Array[String] = Array::new() let seen = Map([], capacity=arr.length()) - + let mut i = 0 while i < arr.length() { if !seen.contains(arr[i]) { @@ -284,7 +284,7 @@ pub fn unique_string(arr : Array[String]) -> Array[String] { } i = i + 1 } - + result } @@ -292,13 +292,13 @@ pub fn unique_string(arr : Array[String]) -> Array[String] { pub fn match_int(x : Array[Int], table : Array[Int]) -> Array[Int] { let result : Array[Int] = Array::new() let table_map = Map([], capacity=table.length()) - + let mut i = 0 while i < table.length() { table_map.set(table[i].to_string(), i) i = i + 1 } - + i = 0 while i < x.length() { if table_map.contains(x[i].to_string()) { @@ -308,7 +308,7 @@ pub fn match_int(x : Array[Int], table : Array[Int]) -> Array[Int] { } i = i + 1 } - + result } @@ -316,13 +316,13 @@ pub fn match_int(x : Array[Int], table : Array[Int]) -> Array[Int] { pub fn match_string(x : Array[String], table : Array[String]) -> Array[Int] { let result : Array[Int] = Array::new() let table_map = Map([], capacity=table.length()) - + let mut i = 0 while i < table.length() { table_map.set(table[i], i) i = i + 1 } - + i = 0 while i < x.length() { if table_map.contains(x[i]) { @@ -332,7 +332,7 @@ pub fn match_string(x : Array[String], table : Array[String]) -> Array[Int] { } i = i + 1 } - + result } @@ -340,13 +340,13 @@ pub fn match_string(x : Array[String], table : Array[String]) -> Array[Int] { pub fn intersect_int(x : Array[Int], y : Array[Int]) -> Array[Int] { let result : Array[Int] = Array::new() let y_set = Map([], capacity=y.length()) - + let mut i = 0 while i < y.length() { y_set.set(y[i].to_string(), true) i = i + 1 } - + i = 0 while i < x.length() { if y_set.contains(x[i].to_string()) { @@ -354,7 +354,7 @@ pub fn intersect_int(x : Array[Int], y : Array[Int]) -> Array[Int] { } i = i + 1 } - + result } @@ -362,13 +362,13 @@ pub fn intersect_int(x : Array[Int], y : Array[Int]) -> Array[Int] { pub fn intersect_string(x : Array[String], y : Array[String]) -> Array[String] { let result : Array[String] = Array::new() let y_set = Map([], capacity=y.length()) - + let mut i = 0 while i < y.length() { y_set.set(y[i], true) i = i + 1 } - + i = 0 while i < x.length() { if y_set.contains(x[i]) { @@ -376,7 +376,7 @@ pub fn intersect_string(x : Array[String], y : Array[String]) -> Array[String] { } i = i + 1 } - + result } @@ -384,7 +384,7 @@ pub fn intersect_string(x : Array[String], y : Array[String]) -> Array[String] { pub fn union_int(x : Array[Int], y : Array[Int]) -> Array[Int] { let result : Array[Int] = Array::new() let seen = Map([], capacity=x.length() + y.length()) - + let mut i = 0 while i < x.length() { if !seen.contains(x[i].to_string()) { @@ -393,7 +393,7 @@ pub fn union_int(x : Array[Int], y : Array[Int]) -> Array[Int] { } i = i + 1 } - + i = 0 while i < y.length() { if !seen.contains(y[i].to_string()) { @@ -402,7 +402,7 @@ pub fn union_int(x : Array[Int], y : Array[Int]) -> Array[Int] { } i = i + 1 } - + result } @@ -410,7 +410,7 @@ pub fn union_int(x : Array[Int], y : Array[Int]) -> Array[Int] { pub fn union_string(x : Array[String], y : Array[String]) -> Array[String] { let result : Array[String] = Array::new() let seen = Map([], capacity=x.length() + y.length()) - + let mut i = 0 while i < x.length() { if !seen.contains(x[i]) { @@ -419,7 +419,7 @@ pub fn union_string(x : Array[String], y : Array[String]) -> Array[String] { } i = i + 1 } - + i = 0 while i < y.length() { if !seen.contains(y[i]) { @@ -428,7 +428,7 @@ pub fn union_string(x : Array[String], y : Array[String]) -> Array[String] { } i = i + 1 } - + result } @@ -436,13 +436,13 @@ pub fn union_string(x : Array[String], y : Array[String]) -> Array[String] { pub fn setdiff_int(x : Array[Int], y : Array[Int]) -> Array[Int] { let result : Array[Int] = Array::new() let y_set = Map([], capacity=y.length()) - + let mut i = 0 while i < y.length() { y_set.set(y[i].to_string(), true) i = i + 1 } - + i = 0 while i < x.length() { if !y_set.contains(x[i].to_string()) { @@ -450,7 +450,7 @@ pub fn setdiff_int(x : Array[Int], y : Array[Int]) -> Array[Int] { } i = i + 1 } - + result } @@ -458,13 +458,13 @@ pub fn setdiff_int(x : Array[Int], y : Array[Int]) -> Array[Int] { pub fn setdiff_string(x : Array[String], y : Array[String]) -> Array[String] { let result : Array[String] = Array::new() let y_set = Map([], capacity=y.length()) - + let mut i = 0 while i < y.length() { y_set.set(y[i], true) i = i + 1 } - + i = 0 while i < x.length() { if !y_set.contains(x[i]) { @@ -472,14 +472,14 @@ pub fn setdiff_string(x : Array[String], y : Array[String]) -> Array[String] { } i = i + 1 } - + result } ///| pub fn table_int(arr : Array[Int]) -> Map[String, Int] { let result = Map([], capacity=arr.length()) - + let mut i = 0 while i < arr.length() { let key = arr[i].to_string() @@ -490,14 +490,14 @@ pub fn table_int(arr : Array[Int]) -> Map[String, Int] { } i = i + 1 } - + result } ///| pub fn table_string(arr : Array[String]) -> Map[String, Int] { let result = Map([], capacity=arr.length()) - + let mut i = 0 while i < arr.length() { let key = arr[i] @@ -508,7 +508,7 @@ pub fn table_string(arr : Array[String]) -> Map[String, Int] { } i = i + 1 } - + result } @@ -582,7 +582,7 @@ pub fn rep_string(x : String, times : Int) -> Array[String] { pub fn seq_int(from : Int, to : Int, by? : Int) -> Array[Int] { let step = if by is Some(_) { by.unwrap() } else { 1 } let result : Array[Int] = Array::new() - + if step > 0 { let mut i = from while i <= to { @@ -596,7 +596,7 @@ pub fn seq_int(from : Int, to : Int, by? : Int) -> Array[Int] { i = i + step } } - + result } @@ -604,7 +604,7 @@ pub fn seq_int(from : Int, to : Int, by? : Int) -> Array[Int] { pub fn seq_double(from : Double, to : Double, by? : Double) -> Array[Double] { let step = if by is Some(_) { by.unwrap() } else { 1.0 } let result : Array[Double] = Array::new() - + if step > 0.0 { let mut i = from while i <= to { @@ -618,7 +618,7 @@ pub fn seq_double(from : Double, to : Double, by? : Double) -> Array[Double] { i = i + step } } - + result } @@ -740,10 +740,10 @@ pub fn cbind(arrays : Array[Array[Double]]) -> Array[Array[Double]] { if arrays.length() == 0 { return [] } - + let nrow = arrays[0].length() let result : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < nrow { let row : Array[Double] = Array::new() @@ -759,19 +759,19 @@ pub fn cbind(arrays : Array[Array[Double]]) -> Array[Array[Double]] { result.push(row) i = i + 1 } - + result } ///| pub fn rbind(arrays : Array[Array[Double]]) -> Array[Array[Double]] { let result : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < arrays.length() { result.push(arrays[i].copy()) i = i + 1 } - + result } diff --git a/src/bioc_neighbors.mbt b/src/bioc_neighbors.mbt index a0ce946d..91b07ca2 100644 --- a/src/bioc_neighbors.mbt +++ b/src/bioc_neighbors.mbt @@ -166,7 +166,13 @@ fn km_init_centroids( let (new_lcg, rand_val) = lcg_next_double(lcg) lcg = new_lcg let idx = (rand_val * n_points.to_double()).to_int() - let actual_idx = if idx >= n_points { n_points - 1 } else { if idx < 0 { 0 } else { idx } } + let actual_idx = if idx >= n_points { + n_points - 1 + } else if idx < 0 { + 0 + } else { + idx + } if !used_indices[actual_idx] { centroids.push(data[actual_idx].copy()) used_indices[actual_idx] = true @@ -249,12 +255,20 @@ fn km_kmeans( if n_points == 0 { return ([], []) } - let actual_clusters = if n_clusters > n_points { n_points } else { n_clusters } + let actual_clusters = if n_clusters > n_points { + n_points + } else { + n_clusters + } let mut centroids = km_init_centroids(data, n_points, n_dim, actual_clusters) let mut assignments = Array::make(n_points, 0) for iter = 0; iter < max_iter; iter = iter + 1 { - let new_assignments = km_assign_points(data, centroids, n_points, n_dim, actual_clusters) - let new_centroids = km_update_centroids(data, new_assignments, n_points, n_dim, actual_clusters) + let new_assignments = km_assign_points( + data, centroids, n_points, n_dim, actual_clusters, + ) + let new_centroids = km_update_centroids( + data, new_assignments, n_points, n_dim, actual_clusters, + ) let mut max_shift = 0.0 for c = 0; c < actual_clusters; c = c + 1 { let shift = euclidean_distance(centroids[c], new_centroids[c]) @@ -282,7 +296,7 @@ pub fn build_knn_index( match options.method { KMKNN => build_kmknn_index(data, n_points, n_dim, options) Annoy => build_annoy_index(data, n_points, n_dim, options) - BruteForce => { + BruteForce => IndexResult::{ method: BruteForce, n_points, @@ -291,7 +305,6 @@ pub fn build_knn_index( centroids: [], tree_nodes: [], } - } } } @@ -317,8 +330,12 @@ pub fn build_kmknn_index( let n_clusters = if n_points <= 10 { 1 } else { - let sqrt_val = ((n_points.to_double()).sqrt()).to_int() - if sqrt_val < 2 { 2 } else { sqrt_val } + let sqrt_val = n_points.to_double().sqrt().to_int() + if sqrt_val < 2 { + 2 + } else { + sqrt_val + } } let (centroids, _) = km_kmeans(data, n_points, n_dim, n_clusters, 20) IndexResult::{ @@ -368,7 +385,13 @@ fn build_single_annoy_tree( let (new_lcg, rand_dim) = lcg_next_double(current_lcg) current_lcg = new_lcg let split_dim = (rand_dim * n_dim.to_double()).to_int() - let actual_dim = if split_dim >= n_dim { n_dim - 1 } else { if split_dim < 0 { 0 } else { split_dim } } + let actual_dim = if split_dim >= n_dim { + n_dim - 1 + } else if split_dim < 0 { + 0 + } else { + split_dim + } let (new_lcg2, rand_val) = lcg_next_double(current_lcg) current_lcg = new_lcg2 @@ -377,8 +400,12 @@ fn build_single_annoy_tree( let mut max_val = data[point_indices[0]][actual_dim] for i = 1; i < n; i = i + 1 { let v = data[point_indices[i]][actual_dim] - if v < min_val { min_val = v } - if v > max_val { max_val = v } + if v < min_val { + min_val = v + } + if v > max_val { + max_val = v + } } let split_val = min_val + rand_val * (max_val - min_val) @@ -446,7 +473,9 @@ fn build_single_annoy_tree( point_indices: [], } - let idx = nodes_copy.length() - (nodes_after_right.length() - nodes_after_left.length()) - 1 + let idx = nodes_copy.length() - + (nodes_after_right.length() - nodes_after_left.length()) - + 1 nodes_copy[idx] = node (nodes_copy, node_id, current_lcg) @@ -476,7 +505,13 @@ pub fn build_annoy_index( 5 } else { let d = (@math.log2(n_points.to_double()) + 1.0).to_int() - if d > 20 { 20 } else { if d < 3 { 3 } else { d } } + if d > 20 { + 20 + } else if d < 3 { + 3 + } else { + d + } } let mut all_nodes : Array[AnnoyNode] = [] @@ -496,7 +531,13 @@ pub fn build_annoy_index( let (new_lcg2, rand_val) = lcg_next_double(shuf_lcg) shuf_lcg = new_lcg2 let idx = (rand_val * indices_left.length().to_double()).to_int() - let actual_idx = if idx >= indices_left.length() { indices_left.length() - 1 } else { if idx < 0 { 0 } else { idx } } + let actual_idx = if idx >= indices_left.length() { + indices_left.length() - 1 + } else if idx < 0 { + 0 + } else { + idx + } shuffled.push(indices_left[actual_idx]) let new_left : Array[Int] = [] for i = 0; i < indices_left.length(); i = i + 1 { @@ -509,14 +550,7 @@ pub fn build_annoy_index( let tree_start_id = all_nodes.length() let (tree_nodes, _, final_lcg) = build_single_annoy_tree( - data, - shuffled, - n_dim, - all_nodes, - tree_start_id, - 0, - max_depth, - lcg, + data, shuffled, n_dim, all_nodes, tree_start_id, 0, max_depth, lcg, ) all_nodes = tree_nodes lcg = final_lcg @@ -549,8 +583,14 @@ pub fn knn_quick_sort( let pivot = sorted_distances[pivot_idx] let pivot_index = sorted_indices[pivot_idx] while i <= j { - while sorted_distances[i] < pivot || (sorted_distances[i] == pivot && sorted_indices[i] < pivot_index) { i = i + 1 } - while sorted_distances[j] > pivot || (sorted_distances[j] == pivot && sorted_indices[j] > pivot_index) { j = j - 1 } + while sorted_distances[i] < pivot || + (sorted_distances[i] == pivot && sorted_indices[i] < pivot_index) { + i = i + 1 + } + while sorted_distances[j] > pivot || + (sorted_distances[j] == pivot && sorted_indices[j] > pivot_index) { + j = j - 1 + } if i <= j { let tmp_idx = sorted_indices[i] sorted_indices[i] = sorted_indices[j] @@ -574,14 +614,13 @@ pub fn knn_quick_sort( ///| /// Find indices of the k smallest distances. -pub fn knn_find_k_smallest( - distances : Array[Double], - k : Int, -) -> Array[Int] { +pub fn knn_find_k_smallest(distances : Array[Double], k : Int) -> Array[Int] { let n = distances.length() if k >= n { let result = Array::make(n, 0) - for i = 0; i < n; i = i + 1 { result[i] = i } + for i = 0; i < n; i = i + 1 { + result[i] = i + } return result } let indices : Array[Int] = [] @@ -610,12 +649,7 @@ pub fn knn_brute_force( ) -> KNNResult { if n_query == 0 || n_points == 0 || k == 0 { let actual_k = if k > n_points { n_points } else { k } - return KNNResult::{ - indices: [], - distances: [], - n_query, - k: actual_k, - } + return KNNResult::{ indices: [], distances: [], n_query, k: actual_k } } let actual_k = if k > n_points { n_points } else { k } let all_indices : Array[Array[Int]] = [] @@ -628,7 +662,12 @@ pub fn knn_brute_force( dists[i] = knn_compute_distance(query_point, data[i], distance) indices[i] = i } - let (sorted_indices, sorted_distances) = knn_quick_sort(dists, indices, 0, n_points - 1) + let (sorted_indices, sorted_distances) = knn_quick_sort( + dists, + indices, + 0, + n_points - 1, + ) let top_indices = Array::make(actual_k, 0) let top_distances = Array::make(actual_k, 0.0) for i = 0; i < actual_k; i = i + 1 { @@ -638,7 +677,12 @@ pub fn knn_brute_force( all_indices.push(top_indices) all_distances.push(top_distances) } - KNNResult::{ indices: all_indices, distances: all_distances, n_query, k: actual_k } + KNNResult::{ + indices: all_indices, + distances: all_distances, + n_query, + k: actual_k, + } } ///| @@ -652,15 +696,16 @@ pub fn run_knn( match index.method { KMKNN => knn_kmknn(index, query_data, n_query, options) Annoy => knn_annoy(index, query_data, n_query, options) - BruteForce => knn_brute_force( - index.data, - index.n_points, - index.n_dim, - query_data, - n_query, - options.k, - options.distance, - ) + BruteForce => + knn_brute_force( + index.data, + index.n_points, + index.n_dim, + query_data, + n_query, + options.k, + options.distance, + ) } } @@ -674,15 +719,18 @@ pub fn knn_kmknn( options : KNNOptions, ) -> KNNResult { if n_query == 0 || index.n_points == 0 || options.k == 0 { - let actual_k = if options.k > index.n_points { index.n_points } else { options.k } - return KNNResult::{ - indices: [], - distances: [], - n_query, - k: actual_k, + let actual_k = if options.k > index.n_points { + index.n_points + } else { + options.k } + return KNNResult::{ indices: [], distances: [], n_query, k: actual_k } + } + let actual_k = if options.k > index.n_points { + index.n_points + } else { + options.k } - let actual_k = if options.k > index.n_points { index.n_points } else { options.k } let n_clusters = index.centroids.length() let all_indices : Array[Array[Int]] = [] let all_distances : Array[Array[Double]] = [] @@ -716,8 +764,15 @@ pub fn knn_kmknn( centroid_dists[c] = euclidean_distance(query, index.centroids[c]) } let sorted_centroid_indices = Array::make(n_clusters, 0) - for c = 0; c < n_clusters; c = c + 1 { sorted_centroid_indices[c] = c } - let (sorted_c_idx, _) = knn_quick_sort(centroid_dists, sorted_centroid_indices, 0, n_clusters - 1) + for c = 0; c < n_clusters; c = c + 1 { + sorted_centroid_indices[c] = c + } + let (sorted_c_idx, _) = knn_quick_sort( + centroid_dists, + sorted_centroid_indices, + 0, + n_clusters - 1, + ) let candidates : Array[Int] = [] let mut cluster_idx = 0 @@ -733,7 +788,10 @@ pub fn knn_kmknn( for i = 0; i < index.n_points; i = i + 1 { let mut found = false for c = 0; c < candidates.length(); c = c + 1 { - if candidates[c] == i { found = true; break } + if candidates[c] == i { + found = true + break + } } if !found { candidates.push(i) @@ -743,9 +801,18 @@ pub fn knn_kmknn( let cand_dists = Array::make(candidates.length(), 0.0) for i = 0; i < candidates.length(); i = i + 1 { - cand_dists[i] = knn_compute_distance(query, index.data[candidates[i]], options.distance) + cand_dists[i] = knn_compute_distance( + query, + index.data[candidates[i]], + options.distance, + ) } - let (sorted_idx, sorted_dist) = knn_quick_sort(cand_dists, candidates, 0, candidates.length() - 1) + let (sorted_idx, sorted_dist) = knn_quick_sort( + cand_dists, + candidates, + 0, + candidates.length() - 1, + ) let top_indices = Array::make(actual_k, 0) let top_distances = Array::make(actual_k, 0.0) @@ -757,7 +824,12 @@ pub fn knn_kmknn( all_distances.push(top_distances) } - KNNResult::{ indices: all_indices, distances: all_distances, n_query, k: actual_k } + KNNResult::{ + indices: all_indices, + distances: all_distances, + n_query, + k: actual_k, + } } ///| @@ -770,17 +842,24 @@ pub fn knn_annoy( options : KNNOptions, ) -> KNNResult { if n_query == 0 || index.n_points == 0 || options.k == 0 { - let actual_k = if options.k > index.n_points { index.n_points } else { options.k } - return KNNResult::{ - indices: [], - distances: [], - n_query, - k: actual_k, + let actual_k = if options.k > index.n_points { + index.n_points + } else { + options.k } + return KNNResult::{ indices: [], distances: [], n_query, k: actual_k } + } + let actual_k = if options.k > index.n_points { + index.n_points + } else { + options.k } - let actual_k = if options.k > index.n_points { index.n_points } else { options.k } let n_trees = options.n_trees - let nodes_per_tree = if n_trees > 0 { index.tree_nodes.length() / n_trees } else { 0 } + let nodes_per_tree = if n_trees > 0 { + index.tree_nodes.length() / n_trees + } else { + 0 + } let all_indices : Array[Array[Int]] = [] let all_distances : Array[Array[Double]] = [] @@ -822,7 +901,10 @@ pub fn knn_annoy( let point_idx = node.point_indices[pi] let mut already = false for c = 0; c < candidates.length(); c = c + 1 { - if candidates[c] == point_idx { already = true; break } + if candidates[c] == point_idx { + already = true + break + } } if !already { candidates.push(point_idx) @@ -879,9 +961,18 @@ pub fn knn_annoy( if candidates.length() > actual_k { let cand_dists = Array::make(candidates.length(), 0.0) for i = 0; i < candidates.length(); i = i + 1 { - cand_dists[i] = knn_compute_distance(query, index.data[candidates[i]], options.distance) + cand_dists[i] = knn_compute_distance( + query, + index.data[candidates[i]], + options.distance, + ) } - let (sorted_idx, sorted_dist) = knn_quick_sort(cand_dists, candidates, 0, candidates.length() - 1) + let (sorted_idx, sorted_dist) = knn_quick_sort( + cand_dists, + candidates, + 0, + candidates.length() - 1, + ) let top_indices = Array::make(actual_k, 0) let top_distances = Array::make(actual_k, 0.0) for i = 0; i < actual_k; i = i + 1 { @@ -893,9 +984,18 @@ pub fn knn_annoy( } else if candidates.length() > 0 { let cand_dists = Array::make(candidates.length(), 0.0) for i = 0; i < candidates.length(); i = i + 1 { - cand_dists[i] = knn_compute_distance(query, index.data[candidates[i]], options.distance) + cand_dists[i] = knn_compute_distance( + query, + index.data[candidates[i]], + options.distance, + ) } - let (sorted_idx, sorted_dist) = knn_quick_sort(cand_dists, candidates, 0, candidates.length() - 1) + let (sorted_idx, sorted_dist) = knn_quick_sort( + cand_dists, + candidates, + 0, + candidates.length() - 1, + ) let top_indices = Array::make(sorted_idx.length(), 0) let top_distances = Array::make(sorted_dist.length(), 0.0) for i = 0; i < sorted_idx.length(); i = i + 1 { @@ -910,5 +1010,10 @@ pub fn knn_annoy( } } - KNNResult::{ indices: all_indices, distances: all_distances, n_query, k: actual_k } -} \ No newline at end of file + KNNResult::{ + indices: all_indices, + distances: all_distances, + n_query, + k: actual_k, + } +} diff --git a/src/bioc_parallel.mbt b/src/bioc_parallel.mbt index d9704c60..d184e113 100644 --- a/src/bioc_parallel.mbt +++ b/src/bioc_parallel.mbt @@ -10,12 +10,21 @@ pub struct BPPARAM { } ///| -pub fn BPPARAM::new(workers : Int, progressbar : Bool, timeout : Int) -> BPPARAM { +pub fn BPPARAM::new( + workers : Int, + progressbar : Bool, + timeout : Int, +) -> BPPARAM { BPPARAM::{ workers, progressbar, timeout, log_file: "" } } ///| -pub fn BPPARAM::new_with_log(workers : Int, progressbar : Bool, timeout : Int, log_file : String) -> BPPARAM { +pub fn BPPARAM::new_with_log( + workers : Int, + progressbar : Bool, + timeout : Int, + log_file : String, +) -> BPPARAM { BPPARAM::{ workers, progressbar, timeout, log_file } } @@ -70,13 +79,13 @@ pub fn bp_add_task(job : BPJob, task : Task) -> BPJob { ///| pub fn bp_sum(data : Array[Array[Double]], params : BPPARAM) -> Double { let mut total = 0.0 - + let chunk_size = if data.length() % params.workers == 0 { data.length() / params.workers } else { data.length() / params.workers + 1 } - + let mut start = 0 while start < data.length() { let end = if start + chunk_size < data.length() { @@ -84,7 +93,7 @@ pub fn bp_sum(data : Array[Array[Double]], params : BPPARAM) -> Double { } else { data.length() } - + let mut i = start while i < end { let mut j = 0 @@ -94,10 +103,10 @@ pub fn bp_sum(data : Array[Array[Double]], params : BPPARAM) -> Double { } i = i + 1 } - + start = end } - + total } @@ -105,14 +114,18 @@ pub fn bp_sum(data : Array[Array[Double]], params : BPPARAM) -> Double { pub fn bp_mean(data : Array[Array[Double]], params : BPPARAM) -> Double { let total = bp_sum(data, params) let mut count = 0.0 - + let mut i = 0 while i < data.length() { count = count + data[i].length().to_double() i = i + 1 } - - if count > 0.0 { total / count } else { 0.0 } + + if count > 0.0 { + total / count + } else { + 0.0 + } } ///| @@ -123,14 +136,17 @@ pub fn bp_mean_simple(data : Array[Double], workers : Int) -> Double { } ///| -pub fn bp_colsum(data : Array[Array[Double]], params : BPPARAM) -> Array[Double] { +pub fn bp_colsum( + data : Array[Array[Double]], + params : BPPARAM, +) -> Array[Double] { if data.length() == 0 { return Array::new() } - + let col_count = data[0].length() let results : Array[Double] = Array::new() - + let mut j = 0 while j < col_count { let mut sum = 0.0 @@ -144,14 +160,17 @@ pub fn bp_colsum(data : Array[Array[Double]], params : BPPARAM) -> Array[Double] results.push(sum) j = j + 1 } - + results } ///| -pub fn bp_rowsum(data : Array[Array[Double]], params : BPPARAM) -> Array[Double] { +pub fn bp_rowsum( + data : Array[Array[Double]], + params : BPPARAM, +) -> Array[Double] { let results : Array[Double] = Array::new() - + let mut i = 0 while i < data.length() { let mut sum = 0.0 @@ -163,20 +182,23 @@ pub fn bp_rowsum(data : Array[Array[Double]], params : BPPARAM) -> Array[Double] results.push(sum) i = i + 1 } - + results } ///| -pub fn bp_parallelize(data : Array[Double], workers : Int) -> Array[Array[Double]] { +pub fn bp_parallelize( + data : Array[Double], + workers : Int, +) -> Array[Array[Double]] { let chunks : Array[Array[Double]] = Array::new() - + let chunk_size = if data.length() % workers == 0 { data.length() / workers } else { data.length() / workers + 1 } - + let mut start = 0 while start < data.length() { let chunk : Array[Double] = Array::new() @@ -185,24 +207,24 @@ pub fn bp_parallelize(data : Array[Double], workers : Int) -> Array[Array[Double } else { data.length() } - + let mut i = start while i < end { chunk.push(data[i]) i = i + 1 } - + chunks.push(chunk) start = end } - + chunks } ///| pub fn bp_run(job : BPJob) -> Array[BPResult] { let results : Array[BPResult] = Array::new() - + let mut i = 0 while i < job.tasks.length() { let task = job.tasks[i] @@ -215,30 +237,33 @@ pub fn bp_run(job : BPJob) -> Array[BPResult] { results.push(BPResult::success(sum, i % job.params.workers)) i = i + 1 } - + results } ///| -pub fn bp_map_sum(data : Array[Array[Double]], params : BPPARAM) -> Array[BPResult] { +pub fn bp_map_sum( + data : Array[Array[Double]], + params : BPPARAM, +) -> Array[BPResult] { let results : Array[BPResult] = Array::new() - + let chunk_size = if data.length() % params.workers == 0 { data.length() / params.workers } else { data.length() / params.workers + 1 } - + let mut worker_id = 0 let mut start = 0 - + while start < data.length() { let end = if start + chunk_size < data.length() { start + chunk_size } else { data.length() } - + let mut i = start while i < end { let mut sum = 0.0 @@ -250,34 +275,37 @@ pub fn bp_map_sum(data : Array[Array[Double]], params : BPPARAM) -> Array[BPResu results.push(BPResult::success(sum, worker_id)) i = i + 1 } - + worker_id = worker_id + 1 start = end } - + results } ///| -pub fn bp_map_mean(data : Array[Array[Double]], params : BPPARAM) -> Array[BPResult] { +pub fn bp_map_mean( + data : Array[Array[Double]], + params : BPPARAM, +) -> Array[BPResult] { let results : Array[BPResult] = Array::new() - + let chunk_size = if data.length() % params.workers == 0 { data.length() / params.workers } else { data.length() / params.workers + 1 } - + let mut worker_id = 0 let mut start = 0 - + while start < data.length() { let end = if start + chunk_size < data.length() { start + chunk_size } else { data.length() } - + let mut i = start while i < end { let mut sum = 0.0 @@ -286,15 +314,19 @@ pub fn bp_map_mean(data : Array[Array[Double]], params : BPPARAM) -> Array[BPRes sum = sum + data[i][j] j = j + 1 } - let mean = if data[i].length() > 0 { sum / data[i].length().to_double() } else { 0.0 } + let mean = if data[i].length() > 0 { + sum / data[i].length().to_double() + } else { + 0.0 + } results.push(BPResult::success(mean, worker_id)) i = i + 1 } - + worker_id = worker_id + 1 start = end } - + results } @@ -307,7 +339,7 @@ pub fn create_example_bpparam() -> BPPARAM { pub fn create_example_bpjob() -> BPJob { let params = BPPARAM::new(2, false, 120) let job = BPJob::new("example_job", params) - + let task1_data : Array[Double] = Array::new() task1_data.push(1.0) task1_data.push(2.0) @@ -315,7 +347,7 @@ pub fn create_example_bpjob() -> BPJob { task1_data.push(4.0) task1_data.push(5.0) job.tasks.push(Task::new("task1", task1_data, 1)) - + let task2_data : Array[Double] = Array::new() task2_data.push(6.0) task2_data.push(7.0) @@ -323,7 +355,7 @@ pub fn create_example_bpjob() -> BPJob { task2_data.push(9.0) task2_data.push(10.0) job.tasks.push(Task::new("task2", task2_data, 1)) - + let task3_data : Array[Double] = Array::new() task3_data.push(11.0) task3_data.push(12.0) @@ -331,7 +363,7 @@ pub fn create_example_bpjob() -> BPJob { task3_data.push(14.0) task3_data.push(15.0) job.tasks.push(Task::new("task3", task3_data, 2)) - + let task4_data : Array[Double] = Array::new() task4_data.push(16.0) task4_data.push(17.0) @@ -339,6 +371,6 @@ pub fn create_example_bpjob() -> BPJob { task4_data.push(19.0) task4_data.push(20.0) job.tasks.push(Task::new("task4", task4_data, 2)) - + job -} \ No newline at end of file +} diff --git a/src/bioc_singular.mbt b/src/bioc_singular.mbt index 62682826..719ec424 100644 --- a/src/bioc_singular.mbt +++ b/src/bioc_singular.mbt @@ -25,15 +25,21 @@ pub enum SVDMethod { ///| /// Create ExactSVD method variant. -pub fn exact_svd_method() -> SVDMethod { ExactSVD } +pub fn exact_svd_method() -> SVDMethod { + ExactSVD +} ///| /// Create IRLBA method variant. -pub fn irlba_method() -> SVDMethod { IRLBA } +pub fn irlba_method() -> SVDMethod { + IRLBA +} ///| /// Create Randomized method variant. -pub fn randomized_method() -> SVDMethod { Randomized } +pub fn randomized_method() -> SVDMethod { + Randomized +} ///| /// Options for SVD computation. @@ -558,13 +564,7 @@ pub fn svd_options_full( n_oversamples : Int, method : SVDMethod, ) -> SVDOptions { - SVDOptions::{ - method, - rank, - tol, - max_iter, - n_oversamples, - } + SVDOptions::{ method, rank, tol, max_iter, n_oversamples } } // ============================================================================ @@ -598,7 +598,9 @@ pub fn run_exact_svd( if ncol <= nrow { let ata = svd_ata(matrix, nrow, ncol) let (eigenvalues, eigenvectors) = eigh_symmetric(ata, ncol) - let (sorted_evals, sorted_evecs) = sort_eigen(eigenvalues, eigenvectors, ncol) + let (sorted_evals, sorted_evecs) = sort_eigen( + eigenvalues, eigenvectors, ncol, + ) let d = Array::make(effective_rank, 0.0) let v : Array[Array[Double]] = Array::new() @@ -634,7 +636,9 @@ pub fn run_exact_svd( } else { let aat = svd_aat(matrix, nrow, ncol) let (eigenvalues, eigenvectors) = eigh_symmetric(aat, nrow) - let (sorted_evals, sorted_evecs) = sort_eigen(eigenvalues, eigenvectors, nrow) + let (sorted_evals, sorted_evecs) = sort_eigen( + eigenvalues, eigenvectors, nrow, + ) let d = Array::make(effective_rank, 0.0) let u : Array[Array[Double]] = Array::new() @@ -706,11 +710,7 @@ fn svd_bidiagonal_small( let u : Array[Array[Double]] = Array::new() for i = 0; i < n; i = i + 1 { - let sigma = if sorted_evals[i] > 0.0 { - sorted_evals[i].sqrt() - } else { - 0.0 - } + let sigma = if sorted_evals[i] > 0.0 { sorted_evals[i].sqrt() } else { 0.0 } d[i] = sigma let v_col = Array::make(n, 0.0) @@ -818,7 +818,8 @@ pub fn run_irlba( for j = 0; j < l; j = j + 1 { let u_new = svd_mat_vec(matrix, nrow, ncol, v_prev) for k = 0; k < nrow; k = k + 1 { - u_new[k] = u_new[k] - beta_prev * u_vecs[if j > 0 { j - 1 } else { 0 }][k] + u_new[k] = u_new[k] - + beta_prev * u_vecs[if j > 0 { j - 1 } else { 0 }][k] } let mut alpha = 0.0 @@ -1092,15 +1093,9 @@ pub fn run_svd( options : SVDOptions, ) -> SVResult { match options.method { - ExactSVD => { - run_exact_svd(matrix, nrow, ncol, options.rank) - } - IRLBA => { - run_irlba(matrix, nrow, ncol, options.rank, options) - } - Randomized => { - run_randomized_svd(matrix, nrow, ncol, options.rank, options) - } + ExactSVD => run_exact_svd(matrix, nrow, ncol, options.rank) + IRLBA => run_irlba(matrix, nrow, ncol, options.rank, options) + Randomized => run_randomized_svd(matrix, nrow, ncol, options.rank, options) } } @@ -1159,10 +1154,7 @@ pub fn create_test_matrix() -> (Array[Double], Int, Int) { let nrow = 5 let ncol = 4 let data = [ - 1.0, 2.0, 3.0, 4.0, - 2.0, 3.0, 4.0, 5.0, - 3.0, 4.0, 5.0, 6.0, - 4.0, 5.0, 6.0, 7.0, + 1.0, 2.0, 3.0, 4.0, 2.0, 3.0, 4.0, 5.0, 3.0, 4.0, 5.0, 6.0, 4.0, 5.0, 6.0, 7.0, 5.0, 6.0, 7.0, 8.0, ] (data, nrow, ncol) @@ -1178,4 +1170,4 @@ pub fn run_svd_truncated( ) -> SVResult { let opts = svd_options_full(k, 1.0e-7, 1000, 10, ExactSVD) run_svd(matrix, nrow, ncol, opts) -} \ No newline at end of file +} diff --git a/src/biostrings.mbt b/src/biostrings.mbt index 2eb195cb..e22de889 100644 --- a/src/biostrings.mbt +++ b/src/biostrings.mbt @@ -703,7 +703,9 @@ pub fn MatchPatternResult::widths(self : MatchPatternResult) -> Array[Int] { ///| /// Get all mismatch counts. -pub fn MatchPatternResult::mismatch_counts(self : MatchPatternResult) -> Array[Int] { +pub fn MatchPatternResult::mismatch_counts( + self : MatchPatternResult, +) -> Array[Int] { self.hits.map(fn(h) { h.mismatches }) } @@ -723,7 +725,13 @@ pub fn match_pattern( let hits : Array[MatchHit] = Array::new() if n == 0 || m == 0 { - return MatchPatternResult::{ hits, pattern, subject, max_mismatches, with_indels } + return MatchPatternResult::{ + hits, + pattern, + subject, + max_mismatches, + with_indels, + } } let max_errors = if with_indels { max_mismatches } else { max_mismatches } @@ -772,7 +780,7 @@ pub fn vmatch_pattern( with_indels? : Bool = false, ) -> Array[MatchPatternResult] { subjects.map(fn(subj) { - match_pattern(pattern=pattern, subject=subj, max_mismatches=max_mismatches, with_indels=with_indels) + match_pattern(pattern~, subject=subj, max_mismatches~, with_indels~) }) } @@ -870,10 +878,7 @@ pub fn find_inverted_repeats( ///| /// Find all occurrences of a motif allowing IUPAC ambiguity codes. -pub fn find_motif_iupac( - pattern : String, - subject : String, -) -> Array[Int] { +pub fn find_motif_iupac(pattern : String, subject : String) -> Array[Int] { let n = pattern.length() let m = subject.length() let positions : Array[Int] = Array::new() @@ -967,7 +972,9 @@ pub fn letter_frequency_matrix(seq : String) -> Map[String, Array[Int]] { let matrix : Map[String, Array[Int]] = Map([], capacity=8) // Initialize for DNA alphabet - let bases = ["A", "C", "G", "T", "U", "N", "R", "Y", "S", "W", "K", "M", "B", "D", "H", "V"] + let bases = [ + "A", "C", "G", "T", "U", "N", "R", "Y", "S", "W", "K", "M", "B", "D", "H", "V", + ] for base in bases { matrix.set(base, Array::make(n, 0)) } @@ -1007,7 +1014,9 @@ pub fn letter_frequency_matrix(seq : String) -> Map[String, Array[Int]] { /// Compute consensus sequence from a multiple sequence alignment. /// Returns the most frequent nucleotide at each position. pub fn biostrings_consensus_sequence(alignment : Array[String]) -> String { - if alignment.length() == 0 { return "" } + if alignment.length() == 0 { + return "" + } let n_seqs = alignment.length() let seq_len = alignment[0].length() @@ -1048,24 +1057,75 @@ pub fn biostrings_translate(seq : String, frame? : Int = 0) -> String { let aa_count = (n - offset) / 3 let result : FixedArray[UInt16] = FixedArray::make(aa_count, 0) - let codon_table : Map[String, UInt16] = Map([ - ("TTT", 70), ("TTC", 70), ("TTA", 76), ("TTG", 76), - ("CTT", 76), ("CTC", 76), ("CTA", 76), ("CTG", 76), - ("ATT", 73), ("ATC", 73), ("ATA", 73), ("ATG", 77), - ("GTT", 86), ("GTC", 86), ("GTA", 86), ("GTG", 86), - ("TCT", 83), ("TCC", 83), ("TCA", 83), ("TCG", 83), - ("CCT", 80), ("CCC", 80), ("CCA", 80), ("CCG", 80), - ("ACT", 65), ("ACC", 65), ("ACA", 65), ("ACG", 65), - ("GCT", 65), ("GCC", 65), ("GCA", 65), ("GCG", 65), - ("TAT", 89), ("TAC", 89), ("TAA", 42), ("TAG", 42), - ("CAT", 72), ("CAC", 72), ("CAA", 81), ("CAG", 81), - ("AAT", 78), ("AAC", 78), ("AAA", 75), ("AAG", 75), - ("GAT", 68), ("GAC", 68), ("GAA", 69), ("GAG", 69), - ("TGT", 67), ("TGC", 67), ("TGA", 42), ("TGG", 87), - ("CGT", 82), ("CGC", 82), ("CGA", 82), ("CGG", 82), - ("AGT", 83), ("AGC", 83), ("AGA", 82), ("AGG", 82), - ("GGT", 71), ("GGC", 71), ("GGA", 71), ("GGG", 71), - ], capacity=64) + let codon_table : Map[String, UInt16] = Map( + [ + ("TTT", 70), + ("TTC", 70), + ("TTA", 76), + ("TTG", 76), + ("CTT", 76), + ("CTC", 76), + ("CTA", 76), + ("CTG", 76), + ("ATT", 73), + ("ATC", 73), + ("ATA", 73), + ("ATG", 77), + ("GTT", 86), + ("GTC", 86), + ("GTA", 86), + ("GTG", 86), + ("TCT", 83), + ("TCC", 83), + ("TCA", 83), + ("TCG", 83), + ("CCT", 80), + ("CCC", 80), + ("CCA", 80), + ("CCG", 80), + ("ACT", 65), + ("ACC", 65), + ("ACA", 65), + ("ACG", 65), + ("GCT", 65), + ("GCC", 65), + ("GCA", 65), + ("GCG", 65), + ("TAT", 89), + ("TAC", 89), + ("TAA", 42), + ("TAG", 42), + ("CAT", 72), + ("CAC", 72), + ("CAA", 81), + ("CAG", 81), + ("AAT", 78), + ("AAC", 78), + ("AAA", 75), + ("AAG", 75), + ("GAT", 68), + ("GAC", 68), + ("GAA", 69), + ("GAG", 69), + ("TGT", 67), + ("TGC", 67), + ("TGA", 42), + ("TGG", 87), + ("CGT", 82), + ("CGC", 82), + ("CGA", 82), + ("CGG", 82), + ("AGT", 83), + ("AGC", 83), + ("AGA", 82), + ("AGG", 82), + ("GGT", 71), + ("GGC", 71), + ("GGA", 71), + ("GGG", 71), + ], + capacity=64, + ) let mut i = offset let mut out_idx = 0 @@ -1160,7 +1220,11 @@ pub fn expected_matches( // Expected number: (seq_length - pattern_length + 1) * probability let n_positions = (seq_length - n + 1).to_double() - if prob.is_nan() || prob < 0.0 { 0.0 } else { n_positions * prob } + if prob.is_nan() || prob < 0.0 { + 0.0 + } else { + n_positions * prob + } } ///| @@ -1203,7 +1267,8 @@ pub fn sequence_complexity(seq : String, word_size : Int) -> Double { entropy } -///| Test match_pattern with exact matching +///| +/// Test match_pattern with exact matching test "match_pattern_exact" { let result = match_pattern(pattern="ATG", subject="ATGATGATG") assert_eq(result.hits.length(), 3) @@ -1212,29 +1277,38 @@ test "match_pattern_exact" { assert_eq(result.hits[0].mismatches, 0) } -///| Test match_pattern with mismatches +///| +/// Test match_pattern with mismatches test "match_pattern_mismatch" { let result = match_pattern(pattern="ATG", subject="AAGATG", max_mismatches=1) assert_true(result.hits.length() >= 1) } -///| Test match_pattern with indels +///| +/// Test match_pattern with indels test "match_pattern_indels" { - let result = match_pattern(pattern="ATG", subject="ATGC", max_mismatches=1, with_indels=true) + let result = match_pattern( + pattern="ATG", + subject="ATGC", + max_mismatches=1, + with_indels=true, + ) assert_true(result.hits.length() >= 1) } -///| Test vmatch_pattern +///| +/// Test vmatch_pattern test "vmatch_pattern" { let subjects = ["ATGATG", "ATGCAT", "CCCCCC"] - let result = vmatch_pattern(pattern="ATG", subjects=subjects) + let result = vmatch_pattern(pattern="ATG", subjects~) assert_eq(result.length(), 3) assert_eq(result[0].hits.length(), 2) assert_eq(result[1].hits.length(), 1) assert_eq(result[2].hits.length(), 0) } -///| Test find_palindromes +///| +/// Test find_palindromes test "find_palindromes" { let result = find_palindromes(seq="ATAT", min_length=4) assert_eq(result.length(), 1) @@ -1242,76 +1316,93 @@ test "find_palindromes" { assert_eq(result[0].1, 4) } -///| Test find_palindromes_empty +///| +/// Test find_palindromes_empty test "find_palindromes_empty" { let result = find_palindromes(seq="ATGC", min_length=4) assert_eq(result.length(), 0) } -///| Test find_direct_repeats +///| +/// Test find_direct_repeats test "find_direct_repeats" { - let result = find_direct_repeats(seq="ATGATGATG", min_unit_length=3, max_unit_length=3, min_copies=2) + let result = find_direct_repeats( + seq="ATGATGATG", + min_unit_length=3, + max_unit_length=3, + min_copies=2, + ) assert_true(result.length() >= 1) } -///| Test find_inverted_repeats +///| +/// Test find_inverted_repeats test "find_inverted_repeats" { let result = find_inverted_repeats(seq="ATGCAT", min_length=3) assert_true(result.length() >= 0) } -///| Test biostrings_translate with standard genetic code +///| +/// Test biostrings_translate with standard genetic code test "biostrings_translate_basic" { // ATG = M, GCT = A, TAA = * let protein = biostrings_translate("ATGGCTTAA") assert_eq(protein, "MA*") } -///| Test biostrings_translate with different reading frame +///| +/// Test biostrings_translate with different reading frame test "biostrings_translate_frame1" { // Frame 1: TGG = W, CTT = L let protein = biostrings_translate("ATGGCTTAA", frame=1) assert_eq(protein, "WL") } -///| Test biostrings_translate with lowercase input +///| +/// Test biostrings_translate with lowercase input test "biostrings_translate_lowercase" { let protein = biostrings_translate("atggcttaa") assert_eq(protein, "MA*") } -///| Test biostrings_translate empty sequence +///| +/// Test biostrings_translate empty sequence test "biostrings_translate_empty" { let protein = biostrings_translate("") assert_eq(protein, "") } -///| Test biostrings_reverse_complement basic +///| +/// Test biostrings_reverse_complement basic test "biostrings_reverse_complement_basic" { let rc = biostrings_reverse_complement("ATGC") assert_eq(rc, "GCAT") } -///| Test biostrings_reverse_complement with IUPAC +///| +/// Test biostrings_reverse_complement with IUPAC test "biostrings_reverse_complement_iupac" { let rc = biostrings_reverse_complement("AR") assert_eq(rc, "YT") } -///| Test biostrings_reverse_complement with empty string +///| +/// Test biostrings_reverse_complement with empty string test "biostrings_reverse_complement_empty" { let rc = biostrings_reverse_complement("") assert_eq(rc, "") } -///| Test biostrings_reverse_complement palindrome +///| +/// Test biostrings_reverse_complement palindrome test "biostrings_reverse_complement_palindrome" { // ACGT's reverse complement is also ACGT let rc = biostrings_reverse_complement("ACGT") assert_eq(rc, "ACGT") } -///| Test letter_frequency_matrix basic +///| +/// Test letter_frequency_matrix basic test "letter_frequency_matrix_basic" { let matrix = letter_frequency_matrix("ACGT") let a_counts = matrix.get_or_default("A", Array::make(4, 0)) @@ -1324,7 +1415,8 @@ test "letter_frequency_matrix_basic" { assert_eq(t_counts[3], 1) } -///| Test biostrings_consensus_sequence +///| +/// Test biostrings_consensus_sequence test "biostrings_consensus_sequence_basic" { let alignment = ["ACGT", "ACGT", "TCGA"] let consensus = biostrings_consensus_sequence(alignment) @@ -1335,26 +1427,30 @@ test "biostrings_consensus_sequence_basic" { assert_eq(consensus, "ACGT") } -///| Test biostrings_consensus_sequence empty +///| +/// Test biostrings_consensus_sequence empty test "biostrings_consensus_sequence_empty" { let alignment : Array[String] = [] let consensus = biostrings_consensus_sequence(alignment) assert_eq(consensus, "") } -///| Test expected_matches +///| +/// Test expected_matches test "expected_matches_basic" { let n = expected_matches("ACGT", 12, 0.5) assert_true(n > 0.0) } -///| Test sequence_complexity +///| +/// Test sequence_complexity test "sequence_complexity_basic" { let entropy = sequence_complexity("ACGTACGTACGT", 2) assert_true(entropy > 0.0) } -///| Test sequence_complexity with degenerate sequence +///| +/// Test sequence_complexity with degenerate sequence test "sequence_complexity_degenerate" { let entropy = sequence_complexity("AAAA", 2) assert_true(entropy >= 0.0) diff --git a/src/biostrings_matchdict.mbt b/src/biostrings_matchdict.mbt index 828235f6..fa3dfeb2 100644 --- a/src/biostrings_matchdict.mbt +++ b/src/biostrings_matchdict.mbt @@ -60,11 +60,7 @@ pub fn bmd_create_pdict( max_mismatches? : Int = 0, with_indels? : Bool = false, ) -> PDict { - PDict::{ - patterns, - max_mismatches, - with_indels, - } + PDict::{ patterns, max_mismatches, with_indels } } ///| @@ -80,11 +76,7 @@ pub fn bmd_match_pdict(pdict~ : PDict, subject~ : String) -> MatchPDictResult { let hits : Array[MatchPDictHit] = Array::new() if subject.length() == 0 || pdict.patterns.length() == 0 { - return MatchPDictResult::{ - hits, - pdict, - subject_length: subject.length(), - } + return MatchPDictResult::{ hits, pdict, subject_length: subject.length() } } let mut p_idx = 0 @@ -129,11 +121,7 @@ pub fn bmd_match_pdict(pdict~ : PDict, subject~ : String) -> MatchPDictResult { p_idx = p_idx + 1 } - MatchPDictResult::{ - hits, - pdict, - subject_length: subject.length(), - } + MatchPDictResult::{ hits, pdict, subject_length: subject.length() } } ///| @@ -161,11 +149,7 @@ pub fn bmd_vcount_pattern( counts.push(0) i = i + 1 } - return CountPatternResult::{ - pattern, - counts, - total: 0, - } + return CountPatternResult::{ pattern, counts, total: 0 } } let mut i = 0 @@ -203,11 +187,7 @@ pub fn bmd_vcount_pattern( i = i + 1 } - CountPatternResult::{ - pattern, - counts, - total, - } + CountPatternResult::{ pattern, counts, total } } ///| @@ -231,8 +211,8 @@ pub fn bmd_vmatch_pattern( while i < patterns.length() { let result = bmd_vcount_pattern( pattern=patterns[i], - subjects=subjects, - max_mismatches=max_mismatches, + subjects~, + max_mismatches~, ) results.push(result) i = i + 1 @@ -303,7 +283,7 @@ pub fn bmd_which(pdict~ : PDict, subjects~ : Array[String]) -> Array[Bool] { /// @param subjects Array of subject sequences to test. /// @return An array of Int indices indicating matching subjects. pub fn bmd_which_index(pdict~ : PDict, subjects~ : Array[String]) -> Array[Int] { - let which_result = bmd_which(pdict=pdict, subjects=subjects) + let which_result = bmd_which(pdict~, subjects~) let indices : Array[Int] = Array::new() let mut i = 0 @@ -327,7 +307,7 @@ pub fn bmd_which_index(pdict~ : PDict, subjects~ : Array[String]) -> Array[Int] /// @param subject The subject sequence string to search. /// @return Total number of pattern occurrences found. pub fn bmd_count_occurrences(pdict~ : PDict, subject~ : String) -> Int { - let result = bmd_match_pdict(pdict=pdict, subject=subject) + let result = bmd_match_pdict(pdict~, subject~) result.hits.length() } @@ -341,7 +321,7 @@ pub fn bmd_count_occurrences(pdict~ : PDict, subject~ : String) -> Int { /// @param subject The subject sequence string to search. /// @return The best MatchPDictHit, or None if no matches found. pub fn bmd_find_best_match(pdict~ : PDict, subject~ : String) -> MatchPDictHit? { - let result = bmd_match_pdict(pdict=pdict, subject=subject) + let result = bmd_match_pdict(pdict~, subject~) if result.hits.length() == 0 { return None @@ -389,7 +369,11 @@ test "bmd_create_pdict_empty" { ///| test "bmd_create_pdict_with_indels" { - let pdict = bmd_create_pdict(patterns=["ATG"], max_mismatches=1, with_indels=true) + let pdict = bmd_create_pdict( + patterns=["ATG"], + max_mismatches=1, + with_indels=true, + ) assert_eq(pdict.with_indels, true) assert_eq(pdict.max_mismatches, 1) } @@ -397,7 +381,7 @@ test "bmd_create_pdict_with_indels" { ///| test "bmd_match_pdict_single_pattern" { let pdict = bmd_create_pdict(patterns=["ATG"]) - let result = bmd_match_pdict(pdict=pdict, subject="AATGCTAG") + let result = bmd_match_pdict(pdict~, subject="AATGCTAG") assert_eq(result.hits.length(), 1) assert_eq(result.hits[0].pattern, "ATG") assert_eq(result.hits[0].start, 2) @@ -408,7 +392,7 @@ test "bmd_match_pdict_single_pattern" { ///| test "bmd_match_pdict_multiple_patterns" { let pdict = bmd_create_pdict(patterns=["ATG", "GCT"]) - let result = bmd_match_pdict(pdict=pdict, subject="ATGGCT") + let result = bmd_match_pdict(pdict~, subject="ATGGCT") assert_eq(result.hits.length(), 2) assert_eq(result.hits[0].pattern, "ATG") assert_eq(result.hits[1].pattern, "GCT") @@ -417,21 +401,21 @@ test "bmd_match_pdict_multiple_patterns" { ///| test "bmd_match_pdict_overlapping_hits" { let pdict = bmd_create_pdict(patterns=["AAA"]) - let result = bmd_match_pdict(pdict=pdict, subject="AAAA") + let result = bmd_match_pdict(pdict~, subject="AAAA") assert_eq(result.hits.length(), 2) } ///| test "bmd_match_pdict_no_match" { let pdict = bmd_create_pdict(patterns=["XYZ"]) - let result = bmd_match_pdict(pdict=pdict, subject="ATGC") + let result = bmd_match_pdict(pdict~, subject="ATGC") assert_eq(result.hits.length(), 0) } ///| test "bmd_match_pdict_empty_subject" { let pdict = bmd_create_pdict(patterns=["ATG"]) - let result = bmd_match_pdict(pdict=pdict, subject="") + let result = bmd_match_pdict(pdict~, subject="") assert_eq(result.hits.length(), 0) assert_eq(result.subject_length, 0) } @@ -439,14 +423,14 @@ test "bmd_match_pdict_empty_subject" { ///| test "bmd_match_pdict_empty_patterns" { let pdict = bmd_create_pdict(patterns=[]) - let result = bmd_match_pdict(pdict=pdict, subject="ATGC") + let result = bmd_match_pdict(pdict~, subject="ATGC") assert_eq(result.hits.length(), 0) } ///| test "bmd_match_pdict_with_mismatches" { let pdict = bmd_create_pdict(patterns=["ATG"], max_mismatches=1) - let result = bmd_match_pdict(pdict=pdict, subject="AXG") + let result = bmd_match_pdict(pdict~, subject="AXG") assert_eq(result.hits.length(), 1) assert_eq(result.hits[0].mismatches, 1) } @@ -454,21 +438,21 @@ test "bmd_match_pdict_with_mismatches" { ///| test "bmd_match_pdict_mismatch_too_many" { let pdict = bmd_create_pdict(patterns=["ATG"], max_mismatches=1) - let result = bmd_match_pdict(pdict=pdict, subject="XYZ") + let result = bmd_match_pdict(pdict~, subject="XYZ") assert_eq(result.hits.length(), 0) } ///| test "bmd_match_pdict_pattern_longer_than_subject" { let pdict = bmd_create_pdict(patterns=["ATGCT"]) - let result = bmd_match_pdict(pdict=pdict, subject="AT") + let result = bmd_match_pdict(pdict~, subject="AT") assert_eq(result.hits.length(), 0) } ///| test "bmd_vcount_pattern_basic" { let subjects = ["ATGATG", "ATGCAT", "CCCCCC"] - let result = bmd_vcount_pattern(pattern="ATG", subjects=subjects) + let result = bmd_vcount_pattern(pattern="ATG", subjects~) assert_eq(result.pattern, "ATG") assert_eq(result.counts.length(), 3) assert_eq(result.counts[0], 2) @@ -480,7 +464,7 @@ test "bmd_vcount_pattern_basic" { ///| test "bmd_vcount_pattern_no_match" { let subjects = ["CCCC", "GGGG", "TTTT"] - let result = bmd_vcount_pattern(pattern="AAAA", subjects=subjects) + let result = bmd_vcount_pattern(pattern="AAAA", subjects~) assert_eq(result.total, 0) assert_eq(result.counts[0], 0) assert_eq(result.counts[1], 0) @@ -490,7 +474,7 @@ test "bmd_vcount_pattern_no_match" { ///| test "bmd_vcount_pattern_with_mismatches" { let subjects = ["AXG", "AYG", "AZG", "ATG"] - let result = bmd_vcount_pattern(pattern="ATG", subjects=subjects, max_mismatches=1) + let result = bmd_vcount_pattern(pattern="ATG", subjects~, max_mismatches=1) assert_eq(result.counts[0], 1) assert_eq(result.counts[1], 1) assert_eq(result.counts[2], 1) @@ -501,7 +485,7 @@ test "bmd_vcount_pattern_with_mismatches" { ///| test "bmd_vcount_pattern_empty_pattern" { let subjects = ["ATGC", "GCAT"] - let result = bmd_vcount_pattern(pattern="", subjects=subjects) + let result = bmd_vcount_pattern(pattern="", subjects~) assert_eq(result.total, 0) assert_eq(result.counts.length(), 2) } @@ -509,7 +493,7 @@ test "bmd_vcount_pattern_empty_pattern" { ///| test "bmd_vcount_pattern_empty_subjects" { let subjects : Array[String] = [] - let result = bmd_vcount_pattern(pattern="ATG", subjects=subjects) + let result = bmd_vcount_pattern(pattern="ATG", subjects~) assert_eq(result.total, 0) assert_eq(result.counts.length(), 0) } @@ -518,7 +502,7 @@ test "bmd_vcount_pattern_empty_subjects" { test "bmd_vmatch_pattern_basic" { let patterns = ["ATG", "CCC"] let subjects = ["ATGATG", "CCCCCC"] - let results = bmd_vmatch_pattern(patterns=patterns, subjects=subjects) + let results = bmd_vmatch_pattern(patterns~, subjects~) assert_eq(results.length(), 2) assert_eq(results[0].pattern, "ATG") assert_eq(results[0].total, 2) @@ -530,7 +514,7 @@ test "bmd_vmatch_pattern_basic" { test "bmd_vmatch_pattern_multiple_subjects" { let patterns = ["ATG"] let subjects = ["ATGATG", "ATXATG", "TTTTTT"] - let results = bmd_vmatch_pattern(patterns=patterns, subjects=subjects) + let results = bmd_vmatch_pattern(patterns~, subjects~) assert_eq(results.length(), 1) assert_eq(results[0].counts[0], 2) assert_eq(results[0].counts[2], 0) @@ -546,7 +530,7 @@ test "bmd_vmatch_pattern_empty" { test "bmd_which_basic" { let pdict = bmd_create_pdict(patterns=["ATG"]) let subjects = ["ATGCTA", "TTTTTT", "ATGCAT"] - let result = bmd_which(pdict=pdict, subjects=subjects) + let result = bmd_which(pdict~, subjects~) assert_eq(result.length(), 3) assert_eq(result[0], true) assert_eq(result[1], false) @@ -557,7 +541,7 @@ test "bmd_which_basic" { test "bmd_which_no_match" { let pdict = bmd_create_pdict(patterns=["ZZZZZ"]) let subjects = ["ATGC", "GCAT"] - let result = bmd_which(pdict=pdict, subjects=subjects) + let result = bmd_which(pdict~, subjects~) assert_eq(result[0], false) assert_eq(result[1], false) } @@ -566,7 +550,7 @@ test "bmd_which_no_match" { test "bmd_which_empty_pdict" { let pdict = bmd_create_pdict(patterns=[]) let subjects = ["ATGC", "GCAT"] - let result = bmd_which(pdict=pdict, subjects=subjects) + let result = bmd_which(pdict~, subjects~) assert_eq(result[0], false) assert_eq(result[1], false) } @@ -575,7 +559,7 @@ test "bmd_which_empty_pdict" { test "bmd_which_index_basic" { let pdict = bmd_create_pdict(patterns=["ATG"]) let subjects = ["TTTT", "ATGC", "GGGG", "ATGG"] - let indices = bmd_which_index(pdict=pdict, subjects=subjects) + let indices = bmd_which_index(pdict~, subjects~) assert_eq(indices.length(), 2) assert_eq(indices[0], 1) assert_eq(indices[1], 3) @@ -585,42 +569,42 @@ test "bmd_which_index_basic" { test "bmd_which_index_no_match" { let pdict = bmd_create_pdict(patterns=["ZZZZ"]) let subjects = ["ATGC", "GCAT"] - let indices = bmd_which_index(pdict=pdict, subjects=subjects) + let indices = bmd_which_index(pdict~, subjects~) assert_eq(indices.length(), 0) } ///| test "bmd_count_occurrences_basic" { let pdict = bmd_create_pdict(patterns=["ATG"]) - let count = bmd_count_occurrences(pdict=pdict, subject="ATGATGATG") + let count = bmd_count_occurrences(pdict~, subject="ATGATGATG") assert_eq(count, 3) } ///| test "bmd_count_occurrences_multiple_patterns" { let pdict = bmd_create_pdict(patterns=["AT", "TG"]) - let count = bmd_count_occurrences(pdict=pdict, subject="ATGATG") + let count = bmd_count_occurrences(pdict~, subject="ATGATG") assert_eq(count, 4) } ///| test "bmd_count_occurrences_no_match" { let pdict = bmd_create_pdict(patterns=["ZZZZ"]) - let count = bmd_count_occurrences(pdict=pdict, subject="ATGC") + let count = bmd_count_occurrences(pdict~, subject="ATGC") assert_eq(count, 0) } ///| test "bmd_count_occurrences_empty" { let pdict = bmd_create_pdict(patterns=[""]) - let count = bmd_count_occurrences(pdict=pdict, subject="ATGC") + let count = bmd_count_occurrences(pdict~, subject="ATGC") assert_eq(count, 0) } ///| test "bmd_find_best_match_exact" { let pdict = bmd_create_pdict(patterns=["ATG"]) - let best = bmd_find_best_match(pdict=pdict, subject="AATGCT") + let best = bmd_find_best_match(pdict~, subject="AATGCT") assert_true(best is Some(_)) assert_eq(best.unwrap().pattern, "ATG") assert_eq(best.unwrap().start, 2) @@ -629,7 +613,7 @@ test "bmd_find_best_match_exact" { ///| test "bmd_find_best_match_with_mismatches" { let pdict = bmd_create_pdict(patterns=["ATG", "AXG", "AYG"], max_mismatches=1) - let best = bmd_find_best_match(pdict=pdict, subject="AAAG") + let best = bmd_find_best_match(pdict~, subject="AAAG") assert_true(best is Some(_)) assert_eq(best.unwrap().mismatches, 1) assert_eq(best.unwrap().pattern, "ATG") @@ -638,14 +622,14 @@ test "bmd_find_best_match_with_mismatches" { ///| test "bmd_find_best_match_no_hit" { let pdict = bmd_create_pdict(patterns=["ZZZZZ"]) - let best = bmd_find_best_match(pdict=pdict, subject="ATGC") + let best = bmd_find_best_match(pdict~, subject="ATGC") assert_true(best is None) } ///| test "bmd_find_best_match_multiple_hits" { let pdict = bmd_create_pdict(patterns=["ATG"], max_mismatches=2) - let best = bmd_find_best_match(pdict=pdict, subject="AATGCTXG") + let best = bmd_find_best_match(pdict~, subject="AATGCTXG") assert_true(best is Some(_)) assert_eq(best.unwrap().pattern, "ATG") assert_eq(best.unwrap().mismatches, 0) @@ -655,7 +639,7 @@ test "bmd_find_best_match_multiple_hits" { test "bmd_which_with_mismatches" { let pdict = bmd_create_pdict(patterns=["ATG"], max_mismatches=1) let subjects = ["AXGCTA", "TTTTTT", "AYGCAT"] - let result = bmd_which(pdict=pdict, subjects=subjects) + let result = bmd_which(pdict~, subjects~) assert_eq(result[0], true) assert_eq(result[1], false) assert_eq(result[2], true) @@ -664,7 +648,7 @@ test "bmd_which_with_mismatches" { ///| test "bmd_vcount_pattern_single_subject" { let subjects = ["AAAA"] - let result = bmd_vcount_pattern(pattern="AA", subjects=subjects) + let result = bmd_vcount_pattern(pattern="AA", subjects~) assert_eq(result.counts.length(), 1) assert_eq(result.counts[0], 3) assert_eq(result.total, 3) @@ -673,7 +657,7 @@ test "bmd_vcount_pattern_single_subject" { ///| test "bmd_match_pdict_hit_properties" { let pdict = bmd_create_pdict(patterns=["ATG", "TGC"]) - let result = bmd_match_pdict(pdict=pdict, subject="ATGC") + let result = bmd_match_pdict(pdict~, subject="ATGC") assert_eq(result.hits.length(), 2) assert_eq(result.hits[0].pattern_idx, 0) assert_eq(result.hits[0].width, 3) @@ -686,7 +670,7 @@ test "bmd_match_pdict_hit_properties" { ///| test "bmd_count_occurrences_overlapping" { let pdict = bmd_create_pdict(patterns=["AA"]) - let count = bmd_count_occurrences(pdict=pdict, subject="AAAA") + let count = bmd_count_occurrences(pdict~, subject="AAAA") assert_eq(count, 3) } @@ -694,7 +678,7 @@ test "bmd_count_occurrences_overlapping" { test "bmd_vmatch_pattern_multiple_mismatches" { let patterns = ["ATG", "CCC"] let subjects = ["AXGATG", "CXCCCX"] - let results = bmd_vmatch_pattern(patterns=patterns, subjects=subjects, max_mismatches=1) + let results = bmd_vmatch_pattern(patterns~, subjects~, max_mismatches=1) assert_eq(results.length(), 2) assert_eq(results[0].counts[0], 2) assert_eq(results[1].counts[1], 4) diff --git a/src/blast_applications.mbt b/src/blast_applications.mbt index b67b476c..920cfad1 100644 --- a/src/blast_applications.mbt +++ b/src/blast_applications.mbt @@ -23,7 +23,13 @@ pub struct BlastParamSpec { ///| /// Create a parameter specification. -pub fn BlastParamSpec::new(name : String, description : String, takes_value : Bool, default_value : String, required : Bool) -> BlastParamSpec { +pub fn BlastParamSpec::new( + name : String, + description : String, + takes_value : Bool, + default_value : String, + required : Bool, +) -> BlastParamSpec { BlastParamSpec::{ name, description, takes_value, default_value, required } } @@ -32,25 +38,45 @@ pub fn BlastParamSpec::new(name : String, description : String, takes_value : Bo fn blastapp_common_params() -> Array[BlastParamSpec] { [ BlastParamSpec::new("-query", "Query sequence file", true, "", false), - BlastParamSpec::new("-query_loc", "Query location (start-stop)", true, "", false), + BlastParamSpec::new( + "-query_loc", "Query location (start-stop)", true, "", false, + ), BlastParamSpec::new("-db", "BLAST database name", true, "", false), BlastParamSpec::new("-out", "Output file name", true, "", false), - BlastParamSpec::new("-evalue", "Expectation value threshold", true, "10.0", false), - BlastParamSpec::new("-word_size", "Word size for initial match", true, "0", false), + BlastParamSpec::new( + "-evalue", "Expectation value threshold", true, "10.0", false, + ), + BlastParamSpec::new( + "-word_size", "Word size for initial match", true, "0", false, + ), BlastParamSpec::new("-gapopen", "Cost to open a gap", true, "0", false), BlastParamSpec::new("-gapextend", "Cost to extend a gap", true, "0", false), BlastParamSpec::new("-matrix", "Scoring matrix", true, "", false), BlastParamSpec::new("-threshold", "Minimum word score", true, "0", false), - BlastParamSpec::new("-comp_based_stats", "Composition-based stats", true, "0", false), - BlastParamSpec::new("-num_descriptions", "Number of descriptions", true, "500", false), - BlastParamSpec::new("-num_alignments", "Number of alignments", true, "250", false), - BlastParamSpec::new("-num_threads", "Number of CPU threads", true, "1", false), - BlastParamSpec::new("-max_target_seqs", "Max target sequences", true, "500", false), + BlastParamSpec::new( + "-comp_based_stats", "Composition-based stats", true, "0", false, + ), + BlastParamSpec::new( + "-num_descriptions", "Number of descriptions", true, "500", false, + ), + BlastParamSpec::new( + "-num_alignments", "Number of alignments", true, "250", false, + ), + BlastParamSpec::new( + "-num_threads", "Number of CPU threads", true, "1", false, + ), + BlastParamSpec::new( + "-max_target_seqs", "Max target sequences", true, "500", false, + ), BlastParamSpec::new("-dust", "DUST filter setting", true, "", false), BlastParamSpec::new("-seg", "SEG filter setting", true, "", false), BlastParamSpec::new("-soft_masking", "Soft masking", true, "false", false), - BlastParamSpec::new("-lcase_masking", "Use lowercase masking", false, "", false), - BlastParamSpec::new("-show_gis", "Show NCBI GIs in output", false, "", false), + BlastParamSpec::new( + "-lcase_masking", "Use lowercase masking", false, "", false, + ), + BlastParamSpec::new( + "-show_gis", "Show NCBI GIs in output", false, "", false, + ), BlastParamSpec::new("-html", "Produce HTML output", false, "", false), ] } @@ -61,7 +87,9 @@ fn blastapp_output_params() -> Array[BlastParamSpec] { [ BlastParamSpec::new("-outfmt", "Output format (0-18)", true, "0", false), BlastParamSpec::new("-max_hsps", "Max HSPs per subject", true, "0", false), - BlastParamSpec::new("-max_intron_length", "Max intron length", true, "0", false), + BlastParamSpec::new( + "-max_intron_length", "Max intron length", true, "0", false, + ), ] } @@ -82,18 +110,25 @@ pub struct BlastCommandline { ///| /// Create a new BLAST commandline wrapper. -pub fn BlastCommandline::new(executable : String, param_specs : Array[BlastParamSpec]) -> BlastCommandline { +pub fn BlastCommandline::new( + executable : String, + param_specs : Array[BlastParamSpec], +) -> BlastCommandline { BlastCommandline::{ executable, parameters: Map([], capacity=32), flags: Map([], capacity=16), - param_specs + param_specs, } } ///| /// Set a parameter value. -pub fn BlastCommandline::blastapp_set_parameter(self : BlastCommandline, name : String, value : String) -> BlastCommandline { +pub fn BlastCommandline::blastapp_set_parameter( + self : BlastCommandline, + name : String, + value : String, +) -> BlastCommandline { let new_params = Map([], capacity=32) let keys = self.parameters.keys().collect() let mut i = 0 @@ -106,13 +141,17 @@ pub fn BlastCommandline::blastapp_set_parameter(self : BlastCommandline, name : executable: self.executable, parameters: new_params, flags: self.flags, - param_specs: self.param_specs + param_specs: self.param_specs, } } ///| /// Set a flag (boolean parameter). -pub fn BlastCommandline::blastapp_set_flag(self : BlastCommandline, name : String, on : Bool) -> BlastCommandline { +pub fn BlastCommandline::blastapp_set_flag( + self : BlastCommandline, + name : String, + on : Bool, +) -> BlastCommandline { let new_flags = Map([], capacity=16) let keys = self.flags.keys().collect() let mut i = 0 @@ -125,25 +164,33 @@ pub fn BlastCommandline::blastapp_set_flag(self : BlastCommandline, name : Strin executable: self.executable, parameters: self.parameters, flags: new_flags, - param_specs: self.param_specs + param_specs: self.param_specs, } } ///| /// Get a parameter value (returns Option). -pub fn BlastCommandline::blastapp_get_parameter(self : BlastCommandline, name : String) -> String? { +pub fn BlastCommandline::blastapp_get_parameter( + self : BlastCommandline, + name : String, +) -> String? { self.parameters.get(name) } ///| /// Get a flag value (returns Option). -pub fn BlastCommandline::blastapp_get_flag(self : BlastCommandline, name : String) -> Bool? { +pub fn BlastCommandline::blastapp_get_flag( + self : BlastCommandline, + name : String, +) -> Bool? { self.flags.get(name) } ///| /// Build the full command-line string. -pub fn BlastCommandline::blastapp_build_command(self : BlastCommandline) -> String { +pub fn BlastCommandline::blastapp_build_command( + self : BlastCommandline, +) -> String { let mut cmd = self.executable // Add value parameters let keys = self.parameters.keys().collect() @@ -166,7 +213,9 @@ pub fn BlastCommandline::blastapp_build_command(self : BlastCommandline) -> Stri ///| /// Validate that all required parameters are set. -pub fn BlastCommandline::blastapp_validate(self : BlastCommandline) -> Array[String] { +pub fn BlastCommandline::blastapp_validate( + self : BlastCommandline, +) -> Array[String] { let errors : Array[String] = Array::new() let mut i = 0 while i < self.param_specs.length() { @@ -184,7 +233,9 @@ pub fn BlastCommandline::blastapp_validate(self : BlastCommandline) -> Array[Str ///| /// List all available parameter specifications. -pub fn BlastCommandline::blastapp_available_params(self : BlastCommandline) -> Array[BlastParamSpec] { +pub fn BlastCommandline::blastapp_available_params( + self : BlastCommandline, +) -> Array[BlastParamSpec] { self.param_specs.copy() } @@ -201,9 +252,15 @@ pub fn ncbi_blastp_commandline() -> BlastCommandline { i = i + 1 } // blastp-specific params - specs.push(BlastParamSpec::new("-remote", "Execute search remotely", false, "", false)) - specs.push(BlastParamSpec::new("-subject", "Subject sequence file", true, "", false)) - specs.push(BlastParamSpec::new("-subject_loc", "Subject location", true, "", false)) + specs.push( + BlastParamSpec::new("-remote", "Execute search remotely", false, "", false), + ) + specs.push( + BlastParamSpec::new("-subject", "Subject sequence file", true, "", false), + ) + specs.push( + BlastParamSpec::new("-subject_loc", "Subject location", true, "", false), + ) BlastCommandline::new("blastp", specs) } @@ -218,11 +275,26 @@ pub fn ncbi_blastn_commandline() -> BlastCommandline { i = i + 1 } // blastn-specific params - specs.push(BlastParamSpec::new("-strand", "Query strand (both/minus/plus)", true, "both", false)) - specs.push(BlastParamSpec::new("-task", "Task (blastn/blastn-short/dc-megablast/etc.)", true, "megablast", false)) - specs.push(BlastParamSpec::new("-remote", "Execute search remotely", false, "", false)) - specs.push(BlastParamSpec::new("-subject", "Subject sequence file", true, "", false)) - specs.push(BlastParamSpec::new("-subject_loc", "Subject location", true, "", false)) + specs.push( + BlastParamSpec::new( + "-strand", "Query strand (both/minus/plus)", true, "both", false, + ), + ) + specs.push( + BlastParamSpec::new( + "-task", "Task (blastn/blastn-short/dc-megablast/etc.)", true, "megablast", + false, + ), + ) + specs.push( + BlastParamSpec::new("-remote", "Execute search remotely", false, "", false), + ) + specs.push( + BlastParamSpec::new("-subject", "Subject sequence file", true, "", false), + ) + specs.push( + BlastParamSpec::new("-subject_loc", "Subject location", true, "", false), + ) BlastCommandline::new("blastn", specs) } @@ -236,12 +308,30 @@ pub fn ncbi_blastx_commandline() -> BlastCommandline { specs.push(out_specs[i]) i = i + 1 } - specs.push(BlastParamSpec::new("-strand", "Query strand (both/minus/plus)", true, "both", false)) - specs.push(BlastParamSpec::new("-query_gencode", "Query genetic code", true, "1", false)) - specs.push(BlastParamSpec::new("-max_intron_length", "Max intron length", true, "0", false)) - specs.push(BlastParamSpec::new("-remote", "Execute search remotely", false, "", false)) - specs.push(BlastParamSpec::new("-subject", "Subject sequence file", true, "", false)) - specs.push(BlastParamSpec::new("-subject_loc", "Subject location", true, "", false)) + specs.push( + BlastParamSpec::new( + "-strand", "Query strand (both/minus/plus)", true, "both", false, + ), + ) + specs.push( + BlastParamSpec::new( + "-query_gencode", "Query genetic code", true, "1", false, + ), + ) + specs.push( + BlastParamSpec::new( + "-max_intron_length", "Max intron length", true, "0", false, + ), + ) + specs.push( + BlastParamSpec::new("-remote", "Execute search remotely", false, "", false), + ) + specs.push( + BlastParamSpec::new("-subject", "Subject sequence file", true, "", false), + ) + specs.push( + BlastParamSpec::new("-subject_loc", "Subject location", true, "", false), + ) BlastCommandline::new("blastx", specs) } @@ -255,11 +345,25 @@ pub fn ncbi_tblastn_commandline() -> BlastCommandline { specs.push(out_specs[i]) i = i + 1 } - specs.push(BlastParamSpec::new("-db_gencode", "Database genetic code", true, "1", false)) - specs.push(BlastParamSpec::new("-frame_shift_penalty", "Frame shift penalty", true, "0", false)) - specs.push(BlastParamSpec::new("-remote", "Execute search remotely", false, "", false)) - specs.push(BlastParamSpec::new("-subject", "Subject sequence file", true, "", false)) - specs.push(BlastParamSpec::new("-subject_loc", "Subject location", true, "", false)) + specs.push( + BlastParamSpec::new( + "-db_gencode", "Database genetic code", true, "1", false, + ), + ) + specs.push( + BlastParamSpec::new( + "-frame_shift_penalty", "Frame shift penalty", true, "0", false, + ), + ) + specs.push( + BlastParamSpec::new("-remote", "Execute search remotely", false, "", false), + ) + specs.push( + BlastParamSpec::new("-subject", "Subject sequence file", true, "", false), + ) + specs.push( + BlastParamSpec::new("-subject_loc", "Subject location", true, "", false), + ) BlastCommandline::new("tblastn", specs) } @@ -273,12 +377,30 @@ pub fn ncbi_tblastx_commandline() -> BlastCommandline { specs.push(out_specs[i]) i = i + 1 } - specs.push(BlastParamSpec::new("-strand", "Query strand (both/minus/plus)", true, "both", false)) - specs.push(BlastParamSpec::new("-query_gencode", "Query genetic code", true, "1", false)) - specs.push(BlastParamSpec::new("-db_gencode", "Database genetic code", true, "1", false)) - specs.push(BlastParamSpec::new("-remote", "Execute search remotely", false, "", false)) - specs.push(BlastParamSpec::new("-subject", "Subject sequence file", true, "", false)) - specs.push(BlastParamSpec::new("-subject_loc", "Subject location", true, "", false)) + specs.push( + BlastParamSpec::new( + "-strand", "Query strand (both/minus/plus)", true, "both", false, + ), + ) + specs.push( + BlastParamSpec::new( + "-query_gencode", "Query genetic code", true, "1", false, + ), + ) + specs.push( + BlastParamSpec::new( + "-db_gencode", "Database genetic code", true, "1", false, + ), + ) + specs.push( + BlastParamSpec::new("-remote", "Execute search remotely", false, "", false), + ) + specs.push( + BlastParamSpec::new("-subject", "Subject sequence file", true, "", false), + ) + specs.push( + BlastParamSpec::new("-subject_loc", "Subject location", true, "", false), + ) BlastCommandline::new("tblastx", specs) } @@ -292,15 +414,44 @@ pub fn ncbi_psiblast_commandline() -> BlastCommandline { specs.push(out_specs[i]) i = i + 1 } - specs.push(BlastParamSpec::new("-num_iterations", "Number of iterations", true, "1", false)) - specs.push(BlastParamSpec::new("-in_pssm", "Input PSSM file", true, "", false)) - specs.push(BlastParamSpec::new("-out_pssm", "Output PSSM file", true, "", false)) - specs.push(BlastParamSpec::new("-out_ascii_pssm", "Output ASCII PSSM file", true, "", false)) - specs.push(BlastParamSpec::new("-save_pssm_after_last_round", "Save PSSM after last iteration", false, "", false)) - specs.push(BlastParamSpec::new("-save_each_pssm", "Save PSSM after each iteration", false, "", false)) - specs.push(BlastParamSpec::new("-pseudocount", "Pseudocount", true, "0", false)) - specs.push(BlastParamSpec::new("-inclusion_ethresh", "Inclusion e-value threshold", true, "0.002", false)) - specs.push(BlastParamSpec::new("-remote", "Execute search remotely", false, "", false)) + specs.push( + BlastParamSpec::new( + "-num_iterations", "Number of iterations", true, "1", false, + ), + ) + specs.push( + BlastParamSpec::new("-in_pssm", "Input PSSM file", true, "", false), + ) + specs.push( + BlastParamSpec::new("-out_pssm", "Output PSSM file", true, "", false), + ) + specs.push( + BlastParamSpec::new( + "-out_ascii_pssm", "Output ASCII PSSM file", true, "", false, + ), + ) + specs.push( + BlastParamSpec::new( + "-save_pssm_after_last_round", "Save PSSM after last iteration", false, "", + false, + ), + ) + specs.push( + BlastParamSpec::new( + "-save_each_pssm", "Save PSSM after each iteration", false, "", false, + ), + ) + specs.push( + BlastParamSpec::new("-pseudocount", "Pseudocount", true, "0", false), + ) + specs.push( + BlastParamSpec::new( + "-inclusion_ethresh", "Inclusion e-value threshold", true, "0.002", false, + ), + ) + specs.push( + BlastParamSpec::new("-remote", "Execute search remotely", false, "", false), + ) BlastCommandline::new("psiblast", specs) } @@ -308,9 +459,15 @@ pub fn ncbi_psiblast_commandline() -> BlastCommandline { /// NCBI rpsblast command line (reverse position-specific BLAST). pub fn ncbi_rpsblast_commandline() -> BlastCommandline { let specs = blastapp_common_params() - specs.push(BlastParamSpec::new("-outfmt", "Output format (0-18)", true, "0", false)) - specs.push(BlastParamSpec::new("-max_hsps", "Max HSPs per subject", true, "0", false)) - specs.push(BlastParamSpec::new("-remote", "Execute search remotely", false, "", false)) + specs.push( + BlastParamSpec::new("-outfmt", "Output format (0-18)", true, "0", false), + ) + specs.push( + BlastParamSpec::new("-max_hsps", "Max HSPs per subject", true, "0", false), + ) + specs.push( + BlastParamSpec::new("-remote", "Execute search remotely", false, "", false), + ) BlastCommandline::new("rpsblast", specs) } @@ -319,21 +476,34 @@ pub fn ncbi_rpsblast_commandline() -> BlastCommandline { pub fn ncbi_makeblastdb_commandline() -> BlastCommandline { let specs : Array[BlastParamSpec] = [ BlastParamSpec::new("-in", "Input FASTA file", true, "", false), - BlastParamSpec::new("-input_type", "Input file type (fasta/asn1_bin/asn1_txt)", true, "fasta", false), - BlastParamSpec::new("-dbtype", "Database type (nucl/prot)", true, "nucl", false), + BlastParamSpec::new( + "-input_type", "Input file type (fasta/asn1_bin/asn1_txt)", true, "fasta", + false, + ), + BlastParamSpec::new( + "-dbtype", "Database type (nucl/prot)", true, "nucl", false, + ), BlastParamSpec::new("-title", "Database title", true, "", false), BlastParamSpec::new("-parse_seqids", "Parse sequence IDs", false, "", false), BlastParamSpec::new("-hash_index", "Create hash index", false, "", false), - BlastParamSpec::new("-mask_data", "Masking algorithm data file", true, "", false), + BlastParamSpec::new( + "-mask_data", "Masking algorithm data file", true, "", false, + ), BlastParamSpec::new("-mask_algo", "Masking algorithm ID", true, "", false), BlastParamSpec::new("-gilist", "GI list file", true, "", false), BlastParamSpec::new("-seqidlist", "Sequence ID list file", true, "", false), - BlastParamSpec::new("-negative_gilist", "Negative GI list file", true, "", false), + BlastParamSpec::new( + "-negative_gilist", "Negative GI list file", true, "", false, + ), BlastParamSpec::new("-taxid", "Taxonomy ID", true, "", false), BlastParamSpec::new("-taxid_map", "Taxonomy ID map file", true, "", false), BlastParamSpec::new("-out", "Output database name", true, "", false), - BlastParamSpec::new("-blastdb_version", "BLAST database version (4 or 5)", true, "5", false), - BlastParamSpec::new("-max_file_sz", "Maximum file size", true, "1000000000", false), + BlastParamSpec::new( + "-blastdb_version", "BLAST database version (4 or 5)", true, "5", false, + ), + BlastParamSpec::new( + "-max_file_sz", "Maximum file size", true, "1000000000", false, + ), ] BlastCommandline::new("makeblastdb", specs) } @@ -342,47 +512,67 @@ pub fn ncbi_makeblastdb_commandline() -> BlastCommandline { ///| /// Build a typical blastp query against a local database. -pub fn blastapp_quick_blastp(query_file : String, db_name : String, evalue : String) -> BlastCommandline { +pub fn blastapp_quick_blastp( + query_file : String, + db_name : String, + evalue : String, +) -> BlastCommandline { ncbi_blastp_commandline() - .blastapp_set_parameter("-query", query_file) - .blastapp_set_parameter("-db", db_name) - .blastapp_set_parameter("-evalue", evalue) + .blastapp_set_parameter("-query", query_file) + .blastapp_set_parameter("-db", db_name) + .blastapp_set_parameter("-evalue", evalue) } ///| /// Build a typical blastn query against a local database. -pub fn blastapp_quick_blastn(query_file : String, db_name : String, evalue : String) -> BlastCommandline { +pub fn blastapp_quick_blastn( + query_file : String, + db_name : String, + evalue : String, +) -> BlastCommandline { ncbi_blastn_commandline() - .blastapp_set_parameter("-query", query_file) - .blastapp_set_parameter("-db", db_name) - .blastapp_set_parameter("-evalue", evalue) + .blastapp_set_parameter("-query", query_file) + .blastapp_set_parameter("-db", db_name) + .blastapp_set_parameter("-evalue", evalue) } ///| /// Build a typical blastx query against a local protein database. -pub fn blastapp_quick_blastx(query_file : String, db_name : String, evalue : String) -> BlastCommandline { +pub fn blastapp_quick_blastx( + query_file : String, + db_name : String, + evalue : String, +) -> BlastCommandline { ncbi_blastx_commandline() - .blastapp_set_parameter("-query", query_file) - .blastapp_set_parameter("-db", db_name) - .blastapp_set_parameter("-evalue", evalue) + .blastapp_set_parameter("-query", query_file) + .blastapp_set_parameter("-db", db_name) + .blastapp_set_parameter("-evalue", evalue) } ///| /// Build a typical tblastn query against a local nucleotide database. -pub fn blastapp_quick_tblastn(query_file : String, db_name : String, evalue : String) -> BlastCommandline { +pub fn blastapp_quick_tblastn( + query_file : String, + db_name : String, + evalue : String, +) -> BlastCommandline { ncbi_tblastn_commandline() - .blastapp_set_parameter("-query", query_file) - .blastapp_set_parameter("-db", db_name) - .blastapp_set_parameter("-evalue", evalue) + .blastapp_set_parameter("-query", query_file) + .blastapp_set_parameter("-db", db_name) + .blastapp_set_parameter("-evalue", evalue) } ///| /// Build a makeblastdb command for a given input file. -pub fn blastapp_quick_makeblastdb(input_file : String, dbtype : String, db_title : String) -> BlastCommandline { +pub fn blastapp_quick_makeblastdb( + input_file : String, + dbtype : String, + db_title : String, +) -> BlastCommandline { ncbi_makeblastdb_commandline() - .blastapp_set_parameter("-in", input_file) - .blastapp_set_parameter("-dbtype", dbtype) - .blastapp_set_parameter("-title", db_title) + .blastapp_set_parameter("-in", input_file) + .blastapp_set_parameter("-dbtype", dbtype) + .blastapp_set_parameter("-title", db_title) } // ===== Example data generators ===== @@ -391,37 +581,37 @@ pub fn blastapp_quick_makeblastdb(input_file : String, dbtype : String, db_title /// Create a sample blastp commandline for demonstration. pub fn blastapp_create_example_blastp() -> BlastCommandline { ncbi_blastp_commandline() - .blastapp_set_parameter("-query", "query.fasta") - .blastapp_set_parameter("-db", "nr") - .blastapp_set_parameter("-evalue", "0.001") - .blastapp_set_parameter("-out", "results.txt") - .blastapp_set_parameter("-outfmt", "7") - .blastapp_set_parameter("-num_threads", "4") - .blastapp_set_parameter("-max_target_seqs", "10") - .blastapp_set_flag("-show_gis", true) + .blastapp_set_parameter("-query", "query.fasta") + .blastapp_set_parameter("-db", "nr") + .blastapp_set_parameter("-evalue", "0.001") + .blastapp_set_parameter("-out", "results.txt") + .blastapp_set_parameter("-outfmt", "7") + .blastapp_set_parameter("-num_threads", "4") + .blastapp_set_parameter("-max_target_seqs", "10") + .blastapp_set_flag("-show_gis", true) } ///| /// Create a sample blastn commandline for demonstration. pub fn blastapp_create_example_blastn() -> BlastCommandline { ncbi_blastn_commandline() - .blastapp_set_parameter("-query", "gene.fasta") - .blastapp_set_parameter("-db", "nt") - .blastapp_set_parameter("-evalue", "1e-50") - .blastapp_set_parameter("-task", "megablast") - .blastapp_set_parameter("-out", "blastn_results.xml") - .blastapp_set_parameter("-outfmt", "5") - .blastapp_set_parameter("-num_descriptions", "100") - .blastapp_set_flag("-html", false) + .blastapp_set_parameter("-query", "gene.fasta") + .blastapp_set_parameter("-db", "nt") + .blastapp_set_parameter("-evalue", "1e-50") + .blastapp_set_parameter("-task", "megablast") + .blastapp_set_parameter("-out", "blastn_results.xml") + .blastapp_set_parameter("-outfmt", "5") + .blastapp_set_parameter("-num_descriptions", "100") + .blastapp_set_flag("-html", false) } ///| /// Create a sample makeblastdb commandline for demonstration. pub fn blastapp_create_example_makeblastdb() -> BlastCommandline { ncbi_makeblastdb_commandline() - .blastapp_set_parameter("-in", "genome.fa") - .blastapp_set_parameter("-dbtype", "nucl") - .blastapp_set_parameter("-title", "ExampleGenome") - .blastapp_set_flag("-parse_seqids", true) - .blastapp_set_flag("-hash_index", true) + .blastapp_set_parameter("-in", "genome.fa") + .blastapp_set_parameter("-dbtype", "nucl") + .blastapp_set_parameter("-title", "ExampleGenome") + .blastapp_set_flag("-parse_seqids", true) + .blastapp_set_flag("-hash_index", true) } diff --git a/src/bumphunter.mbt b/src/bumphunter.mbt index add02597..2ddae5b9 100644 --- a/src/bumphunter.mbt +++ b/src/bumphunter.mbt @@ -159,17 +159,7 @@ pub fn BumpResult::new( index_start : Int, index_end : Int, ) -> BumpResult { - { - chrom, - start, - end_, - value, - area, - p_value, - fdr, - index_start, - index_end, - } + { chrom, start, end_, value, area, p_value, fdr, index_start, index_end } } ///| @@ -278,7 +268,7 @@ pub fn bump_smooth_test(stats : Array[Double], k : Int) -> Array[Double] { let hi = if i + k >= n { n - 1 } else { i + k } let mut sum = 0.0 let mut cnt = 0 - for j in lo..=hi { + for j in lo..<=hi { sum = sum + stats[j] cnt = cnt + 1 } @@ -309,8 +299,8 @@ pub fn bump_find_candidates_test( let mut area = 0.0 let mut signed_max = smoothed[i] while i < n && - bump_abs(smoothed[i]) > cutoff && - positions[i].chrom == chrom { + bump_abs(smoothed[i]) > cutoff && + positions[i].chrom == chrom { area = area + smoothed[i] if bump_abs(smoothed[i]) > max_val { max_val = bump_abs(smoothed[i]) @@ -383,7 +373,9 @@ fn bump_permutation_count( shuffled_vals[j] = shuffled_vals[swap_idx] shuffled_vals[swap_idx] = tmp } - shuffled.push(BumpPosition::new(positions[i].chrom, positions[i].pos, shuffled_vals)) + shuffled.push( + BumpPosition::new(positions[i].chrom, positions[i].pos, shuffled_vals), + ) } let perm_stats = bump_compute_t_statistics_test(shuffled, group1_size) let perm_smoothed = bump_smooth_test(perm_stats, k) @@ -435,12 +427,7 @@ pub fn bump_hunt( for p in 0.. Array[BumpPosition] { /// Format a BumpResult as a readable string. pub fn BumpResult::to_string(self : BumpResult) -> String { let sign = if self.value >= 0.0 { "+" } else { "-" } - "chr=" + self.chrom + " start=" + self.start.to_string() + " end=" + self.end_.to_string() + " value=" + sign + bump_abs(self.value).to_string() + " p=" + self.p_value.to_string() + " fdr=" + self.fdr.to_string() + "chr=" + + self.chrom + + " start=" + + self.start.to_string() + + " end=" + + self.end_.to_string() + + " value=" + + sign + + bump_abs(self.value).to_string() + + " p=" + + self.p_value.to_string() + + " fdr=" + + self.fdr.to_string() } ///| /// Format all results as a table. pub fn bump_results_to_string(results : Array[BumpResult]) -> String { - let mut s = "Bumphunter Results (" + results.length().to_string() + " bumps)\n" + let mut s = "Bumphunter Results (" + + results.length().to_string() + + " bumps)\n" s = s + "chrom\tstart\tend\tvalue\tp_value\tfdr\n" for r in results { - s = s + r.chrom + "\t" + r.start.to_string() + "\t" + r.end_.to_string() + "\t" + r.value.to_string() + "\t" + r.p_value.to_string() + "\t" + r.fdr.to_string() + "\n" + s = s + + r.chrom + + "\t" + + r.start.to_string() + + "\t" + + r.end_.to_string() + + "\t" + + r.value.to_string() + + "\t" + + r.p_value.to_string() + + "\t" + + r.fdr.to_string() + + "\n" } s } diff --git a/src/caps.mbt b/src/caps.mbt index a7ffb5f0..be5f49cf 100644 --- a/src/caps.mbt +++ b/src/caps.mbt @@ -133,12 +133,7 @@ pub fn caps_map( // Validate equal lengths let n = sequences.length() if n == 0 { - return { - sequences, - sequence_names: [], - enzymes, - dcuts: [], - } + return { sequences, sequence_names: [], enzymes, dcuts: [] } } let expected_len = sequences[0].length() let names : Array[String] = [] @@ -375,7 +370,7 @@ pub fn caps_sample_sequences() -> Array[String] { // seq1 has GAATTT (not cut by EcoRI) [ "AAAAAAAAGAGAATTCAAAAAAAAAAAAAA", // has GAATTC at pos 10 - "AAAAAAAAGAGAATTTAAAAAAAAAAAAAA", // has GAATTT at pos 10 (no cut) + "AAAAAAAAGAGAATTTAAAAAAAAAAAAAA", // has GAATTT at pos 10 (no cut) ] } diff --git a/src/cellchat.mbt b/src/cellchat.mbt index 9d66ec56..bec037bc 100644 --- a/src/cellchat.mbt +++ b/src/cellchat.mbt @@ -46,11 +46,7 @@ pub struct CellChatResult { ///| /// Create a ligand-receptor pair. pub fn lr_pair(ligand : String, receptor : String) -> LRPair { - LRPair::{ - ligand: ligand, - receptor: receptor, - key: ligand + "_" + receptor, - } + LRPair::{ ligand, receptor, key: ligand + "_" + receptor } } ///| @@ -110,7 +106,11 @@ pub fn cellchat_mean_expr( } i = i + 1 } - if count > 0 { sum / count.to_double() } else { 0.0 } + if count > 0 { + sum / count.to_double() + } else { + 0.0 + } } ///| @@ -143,10 +143,15 @@ pub fn cellchat_analyze( let mut found = false let mut j = 0 while j < unique_ct.length() { - if unique_ct[j] == ct { found = true; break } + if unique_ct[j] == ct { + found = true + break + } j = j + 1 } - if !found { unique_ct.push(ct) } + if !found { + unique_ct.push(ct) + } i = i + 1 } @@ -219,8 +224,12 @@ pub fn cellchat_analyze( let tgt_ct = unique_ct[tgt] // Observed score - let mean_lig = cellchat_mean_expr(expression, cell_types, src_ct, lig_idx) - let mean_rec = cellchat_mean_expr(expression, cell_types, tgt_ct, rec_idx) + let mean_lig = cellchat_mean_expr( + expression, cell_types, src_ct, lig_idx, + ) + let mean_rec = cellchat_mean_expr( + expression, cell_types, tgt_ct, rec_idx, + ) let obs_score = mean_lig * mean_rec // Permutation null distribution @@ -228,8 +237,12 @@ pub fn cellchat_analyze( let mut pm = 0 while pm < n_perm { let perm_labels = permuted_labels_list[pm] - let perm_lig = cellchat_mean_expr(expression, perm_labels, src_ct, lig_idx) - let perm_rec = cellchat_mean_expr(expression, perm_labels, tgt_ct, rec_idx) + let perm_lig = cellchat_mean_expr( + expression, perm_labels, src_ct, lig_idx, + ) + let perm_rec = cellchat_mean_expr( + expression, perm_labels, tgt_ct, rec_idx, + ) let perm_score = perm_lig * perm_rec perm_scores.push(perm_score) pm = pm + 1 @@ -258,7 +271,9 @@ pub fn cellchat_analyze( let mut n_ge = 0 pm = 0 while pm < n_perm { - if perm_scores[pm] >= obs_score { n_ge = n_ge + 1 } + if perm_scores[pm] >= obs_score { + n_ge = n_ge + 1 + } pm = pm + 1 } let p_val = (n_ge + 1).to_double() / (n_perm + 1).to_double() @@ -274,11 +289,11 @@ pub fn cellchat_analyze( source_celltype: src_ct, target_celltype: tgt_ct, score: obs_score, - perm_mean: perm_mean, - perm_std: perm_std, + perm_mean, + perm_std, p_value: p_val, p_adj: p_adj_raw, - significant: significant, + significant, }) } tgt = tgt + 1 @@ -289,8 +304,8 @@ pub fn cellchat_analyze( } CellChatResult::{ - scores: scores, - lr_pairs: lr_pairs, + scores, + lr_pairs, cell_types: unique_ct, n_permutations: n_perm, seed: seed_val, @@ -300,7 +315,9 @@ pub fn cellchat_analyze( ///| /// Get significant interactions from a CellChatResult. -pub fn cellchat_get_significant(result : CellChatResult) -> Array[InteractionScore] { +pub fn cellchat_get_significant( + result : CellChatResult, +) -> Array[InteractionScore] { let sig : Array[InteractionScore] = [] let mut i = 0 while i < result.scores.length() { @@ -338,10 +355,17 @@ pub fn cellchat_aggregate(result : CellChatResult) -> Map[String, Double] { ///| /// Generate sample single-cell expression data for CellChat testing. /// Returns (expression, cell_types, gene_names) with 3 cell types and known LR pairs. -pub fn cellchat_sample_data() -> (Array[Array[Double]], Array[String], Array[String]) { +pub fn cellchat_sample_data() -> ( + Array[Array[Double]], + Array[String], + Array[String], +) { let n_cells = 30 // Express 10 genes: TNF, TNFR1, IL6, IL6R, VEGFA, VEGFR1, TGFB1, TGFBR1, CXCL12, CXCR4 - let gene_names = ["TNF", "TNFR1", "IL6", "IL6R", "VEGFA", "VEGFR1", "TGFB1", "TGFBR1", "CXCL12", "CXCR4"] + let gene_names = [ + "TNF", "TNFR1", "IL6", "IL6R", "VEGFA", "VEGFR1", "TGFB1", "TGFBR1", "CXCL12", + "CXCR4", + ] let cell_types : Array[String] = [] // 10 cells per cell type let types = ["TypeA", "TypeB", "TypeC"] @@ -359,13 +383,23 @@ pub fn cellchat_sample_data() -> (Array[Array[Double]], Array[String], Array[Str let mut gi = 0 while gi < gene_names.length() { let base = if ct == "TypeA" { - if gene_names[gi] == "TNF" || gene_names[gi] == "IL6" { 15.0 } else { 2.0 } + if gene_names[gi] == "TNF" || gene_names[gi] == "IL6" { + 15.0 + } else { + 2.0 + } } else if ct == "TypeB" { - if gene_names[gi] == "TNFR1" || gene_names[gi] == "IL6R" { 12.0 } else { 2.5 } + if gene_names[gi] == "TNFR1" || gene_names[gi] == "IL6R" { + 12.0 + } else { + 2.5 + } + } else if gene_names[gi] == "VEGFA" || gene_names[gi] == "TGFB1" { + 18.0 } else { - if gene_names[gi] == "VEGFA" || gene_names[gi] == "TGFB1" { 18.0 } else { 3.0 } + 3.0 } - let noise = (((ci * 7 + gi * 11) % 100).to_double() / 100.0) * base * 0.4 + let noise = ((ci * 7 + gi * 11) % 100).to_double() / 100.0 * base * 0.4 row.push(base + noise) gi = gi + 1 } @@ -381,20 +415,36 @@ pub fn cellchat_summary(result : CellChatResult) -> String { let mut n_sig = 0 let mut i = 0 while i < result.scores.length() { - if result.scores[i].significant { n_sig = n_sig + 1 } + if result.scores[i].significant { + n_sig = n_sig + 1 + } i = i + 1 } "CellChat Analysis Summary:\n" + - " Cell types: " + result.cell_types.length().to_string() + "\n" + - " LR pairs tested: " + result.lr_pairs.length().to_string() + "\n" + - " Total interactions: " + result.scores.length().to_string() + "\n" + - " Significant (FDR<" + result.fdr.to_string() + "): " + n_sig.to_string() + "\n" + - " Permutations: " + result.n_permutations.to_string() + " Cell types: " + + result.cell_types.length().to_string() + + "\n" + + " LR pairs tested: " + + result.lr_pairs.length().to_string() + + "\n" + + " Total interactions: " + + result.scores.length().to_string() + + "\n" + + " Significant (FDR<" + + result.fdr.to_string() + + "): " + + n_sig.to_string() + + "\n" + + " Permutations: " + + result.n_permutations.to_string() } ///| /// Get the top interactions by score. -pub fn cellchat_get_top(result : CellChatResult, n : Int) -> Array[InteractionScore] { +pub fn cellchat_get_top( + result : CellChatResult, + n : Int, +) -> Array[InteractionScore] { let all = result.scores // Sort by score descending let mut i = 0 diff --git a/src/chain_liftover.mbt b/src/chain_liftover.mbt index cd5065ae..c3f4ef4e 100644 --- a/src/chain_liftover.mbt +++ b/src/chain_liftover.mbt @@ -195,7 +195,7 @@ pub fn cl_liftover_range( } match (mapped_start, mapped_end) { - (Some(ms), Some(me)) => { + (Some(ms), Some(me)) => if ch.q_strand == "-" { let qs = ch.q_size - me let qe = ch.q_size - ms @@ -204,14 +204,11 @@ pub fn cl_liftover_range( } else { Some((qe, qs)) } + } else if ms < me { + Some((ms, me)) } else { - if ms < me { - Some((ms, me)) - } else { - Some((me, ms)) - } + Some((me, ms)) } - } _ => None } } @@ -313,11 +310,7 @@ fn cl_split_lines(s : String) -> Array[String] { let mut i = 0 while i < s.length() { if s.unsafe_get(i).to_int() == '\n'.to_int() { - let line = if start < i { - s[start:i].to_owned() - } else { - "" - } + let line = if start < i { s[start:i].to_owned() } else { "" } result.push(line) start = i + 1 } @@ -423,16 +416,36 @@ fn cl_parse_chain_header( let score = if fields.length() > 1 { cl_parse_int_safe(fields[1]) } else { 0 } let t_name = if fields.length() > 2 { fields[2] } else { "" } - let t_size = if fields.length() > 3 { cl_parse_int_safe(fields[3]) } else { 0 } + let t_size = if fields.length() > 3 { + cl_parse_int_safe(fields[3]) + } else { + 0 + } let t_strand = if fields.length() > 4 { fields[4] } else { "+" } let t_plus = t_strand == "+" - let t_start = if fields.length() > 5 { cl_parse_int_safe(fields[5]) } else { 0 } + let t_start = if fields.length() > 5 { + cl_parse_int_safe(fields[5]) + } else { + 0 + } let t_end = if fields.length() > 6 { cl_parse_int_safe(fields[6]) } else { 0 } let q_name = if fields.length() > 7 { fields[7] } else { "" } - let q_size = if fields.length() > 8 { cl_parse_int_safe(fields[8]) } else { 0 } + let q_size = if fields.length() > 8 { + cl_parse_int_safe(fields[8]) + } else { + 0 + } let q_strand = if fields.length() > 9 { fields[9] } else { "+" } - let q_start = if fields.length() > 10 { cl_parse_int_safe(fields[10]) } else { 0 } - let q_end = if fields.length() > 11 { cl_parse_int_safe(fields[11]) } else { 0 } + let q_start = if fields.length() > 10 { + cl_parse_int_safe(fields[10]) + } else { + 0 + } + let q_end = if fields.length() > 11 { + cl_parse_int_safe(fields[11]) + } else { + 0 + } let id = if fields.length() > 12 { cl_parse_int_safe(fields[12]) } else { 0 } let header = ChainHeader::{ @@ -593,8 +606,7 @@ test "cl_parse_chain_single_header" { ///| test "cl_parse_chain_with_blocks" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 400 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 400 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments.length(), 1) assert_eq(cf.alignments[0].blocks.length(), 2) @@ -608,8 +620,7 @@ test "cl_parse_chain_with_blocks" { ///| test "cl_parse_chain_multiple_records" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 300 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 300 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments.length(), 2) assert_eq(cf.alignments[0].id, 5) @@ -620,8 +631,7 @@ test "cl_parse_chain_multiple_records" { ///| test "cl_parse_chain_multiple_blocks" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 300 5 15\n 200 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 300 5 15\n 200 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments[0].blocks.length(), 3) assert_eq(cf.alignments[0].blocks[0].size, 500) @@ -631,8 +641,7 @@ test "cl_parse_chain_multiple_blocks" { ///| test "cl_parse_chain_negative_query_strand" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments[0].q_strand, "-") assert_eq(cf.alignments[0].q_start, 5000) @@ -641,8 +650,7 @@ test "cl_parse_chain_negative_query_strand" { ///| test "cl_parse_chain_negative_target_strand" { - let content = - "chain 5000 chr1 249250621 - 5000 1 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 - 5000 1 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments[0].t_plus, false) assert_eq(cf.alignments[0].t_start, 5000) @@ -651,8 +659,7 @@ test "cl_parse_chain_negative_target_strand" { ///| test "cl_parse_chain_complex" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 400 30 40\n 300 0 0\nchain 3000 chr5 181538259 + 100 200 chr7 159345973 + 300 500 6\n 100 0 0\nchain 2000 chr12 133275309 + 500 800 chr14 107043718 + 700 1000 7\n 200 5 10\n 100 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 400 30 40\n 300 0 0\nchain 3000 chr5 181538259 + 100 200 chr7 159345973 + 300 500 6\n 100 0 0\nchain 2000 chr12 133275309 + 500 800 chr14 107043718 + 700 1000 7\n 200 5 10\n 100 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments.length(), 3) assert_eq(cf.alignments[0].blocks.length(), 3) @@ -662,23 +669,19 @@ test "cl_parse_chain_complex" { ///| test "cl_find_chain_for_pos_valid" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_find_chain_for_pos(cf, "chr1", 100) assert_true(result is Some(_)) match result { - Some(ch) => { - assert_eq(ch.id, 5) - } + Some(ch) => assert_eq(ch.id, 5) None => () } } ///| test "cl_find_chain_for_pos_first_block" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 4500 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 4500 0 0" let cf = cl_parse_chain(content) let result = cl_find_chain_for_pos(cf, "chr1", 100) assert_true(result is Some(_)) @@ -686,8 +689,7 @@ test "cl_find_chain_for_pos_first_block" { ///| test "cl_find_chain_for_pos_second_block" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 4500 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 4500 0 0" let cf = cl_parse_chain(content) let result = cl_find_chain_for_pos(cf, "chr1", 600) assert_true(result is Some(_)) @@ -695,8 +697,7 @@ test "cl_find_chain_for_pos_second_block" { ///| test "cl_find_chain_for_pos_wrong_chrom" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_find_chain_for_pos(cf, "chrX", 100) assert_true(result is None) @@ -704,8 +705,7 @@ test "cl_find_chain_for_pos_wrong_chrom" { ///| test "cl_find_chain_for_pos_out_of_range" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_find_chain_for_pos(cf, "chr1", 6000) assert_true(result is None) @@ -713,19 +713,14 @@ test "cl_find_chain_for_pos_out_of_range" { ///| test "cl_find_chain_for_pos_empty_chains" { - let cf = ChainFile::{ - alignments: [], - target_name: "", - query_name: "", - } + let cf = ChainFile::{ alignments: [], target_name: "", query_name: "" } let result = cl_find_chain_for_pos(cf, "chr1", 100) assert_true(result is None) } ///| test "cl_liftover_pos_basic" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 100) assert_eq(result, Some(100)) @@ -733,8 +728,7 @@ test "cl_liftover_pos_basic" { ///| test "cl_liftover_pos_first_block" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 100) assert_eq(result, Some(100)) @@ -742,8 +736,7 @@ test "cl_liftover_pos_first_block" { ///| test "cl_liftover_pos_second_block" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 600) assert_eq(result, Some(610)) @@ -751,8 +744,7 @@ test "cl_liftover_pos_second_block" { ///| test "cl_liftover_pos_last_block" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 4999) assert_eq(result, Some(5009)) @@ -760,8 +752,7 @@ test "cl_liftover_pos_last_block" { ///| test "cl_liftover_pos_at_chain_start" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 1) assert_eq(result, Some(1)) @@ -769,8 +760,7 @@ test "cl_liftover_pos_at_chain_start" { ///| test "cl_liftover_pos_at_chain_end" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 4999) assert_eq(result, Some(4999)) @@ -778,8 +768,7 @@ test "cl_liftover_pos_at_chain_end" { ///| test "cl_liftover_pos_out_of_range_before" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 0) assert_true(result is None) @@ -787,8 +776,7 @@ test "cl_liftover_pos_out_of_range_before" { ///| test "cl_liftover_pos_out_of_range_after" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 6000) assert_true(result is None) @@ -796,8 +784,7 @@ test "cl_liftover_pos_out_of_range_after" { ///| test "cl_liftover_pos_wrong_chrom" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chrX", 100) assert_true(result is None) @@ -805,8 +792,7 @@ test "cl_liftover_pos_wrong_chrom" { ///| test "cl_liftover_pos_in_gap" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 501) assert_true(result is None) @@ -814,8 +800,7 @@ test "cl_liftover_pos_in_gap" { ///| test "cl_liftover_pos_reverse_query_strand" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 100) assert_eq(result, Some(4901)) @@ -823,8 +808,7 @@ test "cl_liftover_pos_reverse_query_strand" { ///| test "cl_liftover_pos_reverse_query_at_start" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 1) assert_eq(result, Some(5000)) @@ -832,8 +816,7 @@ test "cl_liftover_pos_reverse_query_at_start" { ///| test "cl_liftover_pos_reverse_query_at_end" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 4999) assert_eq(result, Some(2)) @@ -841,19 +824,14 @@ test "cl_liftover_pos_reverse_query_at_end" { ///| test "cl_liftover_pos_empty_chains" { - let cf = ChainFile::{ - alignments: [], - target_name: "", - query_name: "", - } + let cf = ChainFile::{ alignments: [], target_name: "", query_name: "" } let result = cl_liftover_pos(cf, "chr1", 100) assert_true(result is None) } ///| test "cl_liftover_range_basic" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_range(cf, "chr1", 100, 200) assert_eq(result, Some((100, 200))) @@ -861,8 +839,7 @@ test "cl_liftover_range_basic" { ///| test "cl_liftover_range_across_blocks" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_range(cf, "chr1", 400, 700) assert_eq(result, Some((400, 710))) @@ -870,8 +847,7 @@ test "cl_liftover_range_across_blocks" { ///| test "cl_liftover_range_out_of_range" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_range(cf, "chr1", 4900, 6000) assert_true(result is None) @@ -879,8 +855,7 @@ test "cl_liftover_range_out_of_range" { ///| test "cl_liftover_range_reverse_strand" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_range(cf, "chr1", 100, 200) assert_eq(result, Some((4801, 4901))) @@ -888,8 +863,7 @@ test "cl_liftover_range_reverse_strand" { ///| test "cl_liftover_range_empty" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_range(cf, "chr1", 200, 100) assert_true(result is None) @@ -935,8 +909,7 @@ test "cl_get_chain_summary_single_block" { ///| test "cl_chain_to_string_roundtrip" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 400 0 0\n" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 400 0 0\n" let cf = cl_parse_chain(content) assert_eq(cf.alignments.length(), 1) let serialized = cl_chain_to_string(cf.alignments[0]) @@ -967,16 +940,14 @@ test "cl_chain_to_string_contains_blocks" { ///| test "cl_parse_chain_with_blank_lines" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n\n 5000 0 0\n\nchain 3000 chr5 181538259 + 100 200 chr7 159345973 + 300 500 6\n\n 100 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n\n 5000 0 0\n\nchain 3000 chr5 181538259 + 100 200 chr7 159345973 + 300 500 6\n\n 100 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments.length(), 2) } ///| test "cl_liftover_pos_multi_chain" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 3000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 3000 0 0" let cf = cl_parse_chain(content) let result1 = cl_liftover_pos(cf, "chr1", 100) assert_eq(result1, Some(100)) @@ -986,8 +957,7 @@ test "cl_liftover_pos_multi_chain" { ///| test "cl_liftover_range_multi_chain" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 3000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 3000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_range(cf, "chr1", 100, 200) assert_eq(result, Some((100, 200))) @@ -995,8 +965,7 @@ test "cl_liftover_range_multi_chain" { ///| test "cl_liftover_range_spans_multiple_chains" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 3000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 3000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_range(cf, "chr1", 4900, 7000) assert_true(result is None) @@ -1004,8 +973,7 @@ test "cl_liftover_range_spans_multiple_chains" { ///| test "cl_parse_chain_single_nucleotide_block" { - let content = - "chain 100 chr1 1000 + 100 200 chr2 500 + 50 150 1\n 1 0 0" + let content = "chain 100 chr1 1000 + 100 200 chr2 500 + 50 150 1\n 1 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments[0].blocks.length(), 1) assert_eq(cf.alignments[0].blocks[0].size, 1) @@ -1015,8 +983,7 @@ test "cl_parse_chain_single_nucleotide_block" { ///| test "cl_liftover_pos_chain_boundary_start" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 1) assert_true(result is Some(_)) @@ -1024,8 +991,7 @@ test "cl_liftover_pos_chain_boundary_start" { ///| test "cl_liftover_pos_chain_boundary_end" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 4999) assert_true(result is Some(_)) @@ -1033,8 +999,7 @@ test "cl_liftover_pos_chain_boundary_end" { ///| test "cl_find_chain_for_pos_multiple_chains" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 3000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 3000 0 0" let cf = cl_parse_chain(content) let r1 = cl_find_chain_for_pos(cf, "chr1", 100) match r1 { @@ -1050,8 +1015,7 @@ test "cl_find_chain_for_pos_multiple_chains" { ///| test "cl_parse_chain_whitespace_tabs" { - let content = - "chain\t5000\tchr1\t249250621\t+\t1\t5000\tchr2\t10000\t+\t1\t100\t5\n\t5000\t0\t0" + let content = "chain\t5000\tchr1\t249250621\t+\t1\t5000\tchr2\t10000\t+\t1\t100\t5\n\t5000\t0\t0" let cf = cl_parse_chain(content) assert_eq(cf.alignments.length(), 1) assert_eq(cf.alignments[0].blocks.length(), 1) @@ -1059,8 +1023,7 @@ test "cl_parse_chain_whitespace_tabs" { ///| test "cl_liftover_pos_block_boundary_alignment" { - let content = - "chain 5000 chr1 249250621 + 1 1100 chr2 10000 + 1 1100 5\n 500 10 20\n 500 0 0" + let content = "chain 5000 chr1 249250621 + 1 1100 chr2 10000 + 1 1100 5\n 500 10 20\n 500 0 0" let cf = cl_parse_chain(content) let r1 = cl_liftover_pos(cf, "chr1", 500) assert_eq(r1, Some(500)) @@ -1074,16 +1037,14 @@ test "cl_liftover_pos_block_boundary_alignment" { ///| test "cl_parse_chain_id_preserved" { - let content = - "chain 100 chr1 1000 + 100 200 chr2 500 + 50 150 99\n 100 0 0" + let content = "chain 100 chr1 1000 + 100 200 chr2 500 + 50 150 99\n 100 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments[0].id, 99) } ///| test "cl_chain_to_string_score_preserved" { - let content = - "chain 7777 chr1 1000 + 100 200 chr2 500 + 50 150 1\n 100 0 0" + let content = "chain 7777 chr1 1000 + 100 200 chr2 500 + 50 150 1\n 100 0 0" let cf = cl_parse_chain(content) let s = cl_chain_to_string(cf.alignments[0]) assert_true(cl_starts_with(s, "chain 7777")) @@ -1091,8 +1052,7 @@ test "cl_chain_to_string_score_preserved" { ///| test "cl_liftover_range_sub_block" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_range(cf, "chr1", 50, 150) assert_eq(result, Some((50, 150))) @@ -1113,8 +1073,7 @@ test "cl_get_chain_summary_gaps" { ///| test "cl_liftover_pos_complex_chain" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 1000 50 100\n 2000 30 40\n 2000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 1000 50 100\n 2000 30 40\n 2000 0 0" let cf = cl_parse_chain(content) let r1 = cl_liftover_pos(cf, "chr1", 500) assert_eq(r1, Some(500)) @@ -1124,4 +1083,4 @@ test "cl_liftover_pos_complex_chain" { assert_eq(r3, Some(3560)) let r4 = cl_liftover_pos(cf, "chr1", 4500) assert_eq(r4, Some(4560)) -} \ No newline at end of file +} diff --git a/src/checksum.mbt b/src/checksum.mbt index d643f106..c3b514ad 100644 --- a/src/checksum.mbt +++ b/src/checksum.mbt @@ -8,49 +8,79 @@ pub struct CheckSumResult { } ///| -pub fn CheckSumResult::new(checksum : String, method : String) -> CheckSumResult { +pub fn CheckSumResult::new( + checksum : String, + method : String, +) -> CheckSumResult { CheckSumResult::{ checksum, method } } ///| pub fn checksum_gcg(seq : String) -> CheckSumResult { let seq_upper = seq.to_upper() - + let mut checksum = 0 let mut idx = 0 while idx < seq_upper.length() { let c = substring(seq_upper, idx, 1) - if c == "A" { checksum = (checksum + 1) * 11 } - else if c == "B" { checksum = (checksum + 2) * 11 } - else if c == "C" { checksum = (checksum + 3) * 11 } - else if c == "D" { checksum = (checksum + 4) * 11 } - else if c == "E" { checksum = (checksum + 5) * 11 } - else if c == "F" { checksum = (checksum + 6) * 11 } - else if c == "G" { checksum = (checksum + 7) * 11 } - else if c == "H" { checksum = (checksum + 8) * 11 } - else if c == "I" { checksum = (checksum + 9) * 11 } - else if c == "J" { checksum = (checksum + 10) * 11 } - else if c == "K" { checksum = (checksum + 11) * 11 } - else if c == "L" { checksum = (checksum + 12) * 11 } - else if c == "M" { checksum = (checksum + 13) * 11 } - else if c == "N" { checksum = (checksum + 14) * 11 } - else if c == "O" { checksum = (checksum + 15) * 11 } - else if c == "P" { checksum = (checksum + 16) * 11 } - else if c == "Q" { checksum = (checksum + 17) * 11 } - else if c == "R" { checksum = (checksum + 18) * 11 } - else if c == "S" { checksum = (checksum + 19) * 11 } - else if c == "T" { checksum = (checksum + 20) * 11 } - else if c == "U" { checksum = (checksum + 21) * 11 } - else if c == "V" { checksum = (checksum + 22) * 11 } - else if c == "W" { checksum = (checksum + 23) * 11 } - else if c == "X" { checksum = (checksum + 24) * 11 } - else if c == "Y" { checksum = (checksum + 25) * 11 } - else if c == "Z" { checksum = (checksum + 26) * 11 } + if c == "A" { + checksum = (checksum + 1) * 11 + } else if c == "B" { + checksum = (checksum + 2) * 11 + } else if c == "C" { + checksum = (checksum + 3) * 11 + } else if c == "D" { + checksum = (checksum + 4) * 11 + } else if c == "E" { + checksum = (checksum + 5) * 11 + } else if c == "F" { + checksum = (checksum + 6) * 11 + } else if c == "G" { + checksum = (checksum + 7) * 11 + } else if c == "H" { + checksum = (checksum + 8) * 11 + } else if c == "I" { + checksum = (checksum + 9) * 11 + } else if c == "J" { + checksum = (checksum + 10) * 11 + } else if c == "K" { + checksum = (checksum + 11) * 11 + } else if c == "L" { + checksum = (checksum + 12) * 11 + } else if c == "M" { + checksum = (checksum + 13) * 11 + } else if c == "N" { + checksum = (checksum + 14) * 11 + } else if c == "O" { + checksum = (checksum + 15) * 11 + } else if c == "P" { + checksum = (checksum + 16) * 11 + } else if c == "Q" { + checksum = (checksum + 17) * 11 + } else if c == "R" { + checksum = (checksum + 18) * 11 + } else if c == "S" { + checksum = (checksum + 19) * 11 + } else if c == "T" { + checksum = (checksum + 20) * 11 + } else if c == "U" { + checksum = (checksum + 21) * 11 + } else if c == "V" { + checksum = (checksum + 22) * 11 + } else if c == "W" { + checksum = (checksum + 23) * 11 + } else if c == "X" { + checksum = (checksum + 24) * 11 + } else if c == "Y" { + checksum = (checksum + 25) * 11 + } else if c == "Z" { + checksum = (checksum + 26) * 11 + } idx = idx + 1 } - + checksum = checksum % 10000 - + let checksum_str = if checksum < 10 { "000" + checksum.to_string() } else if checksum < 100 { @@ -60,28 +90,34 @@ pub fn checksum_gcg(seq : String) -> CheckSumResult { } else { checksum.to_string() } - + CheckSumResult::new(checksum_str, "gcg") } ///| pub fn checksum_seguid(seq : String) -> CheckSumResult { let seq_upper = seq.to_upper() - + let mut hash_val = 0 let mut idx = 0 while idx < seq_upper.length() { let c = substring(seq_upper, idx, 1) - if c == "A" { hash_val = hash_val * 31 + 65 } - else if c == "T" { hash_val = hash_val * 31 + 84 } - else if c == "C" { hash_val = hash_val * 31 + 67 } - else if c == "G" { hash_val = hash_val * 31 + 71 } - else { hash_val = hash_val * 31 + 78 } + if c == "A" { + hash_val = hash_val * 31 + 65 + } else if c == "T" { + hash_val = hash_val * 31 + 84 + } else if c == "C" { + hash_val = hash_val * 31 + 67 + } else if c == "G" { + hash_val = hash_val * 31 + 71 + } else { + hash_val = hash_val * 31 + 78 + } idx = idx + 1 } - + let table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" - + let mut result = "" let mut h = hash_val while h > 0 { @@ -96,7 +132,7 @@ pub fn checksum_seguid(seq : String) -> CheckSumResult { } h = h / 64 } - + CheckSumResult::new(result, "seguid") } @@ -106,12 +142,16 @@ pub fn create_example_sequence() -> String { } ///| -pub fn verify_checksum(seq : String, expected_checksum : String, method : String) -> Bool { +pub fn verify_checksum( + seq : String, + expected_checksum : String, + method : String, +) -> Bool { let result = if method == "gcg" { checksum_gcg(seq) } else { checksum_seguid(seq) } - + result.checksum == expected_checksum -} \ No newline at end of file +} diff --git a/src/chem_utils.mbt b/src/chem_utils.mbt index f2ac8a09..8c5f2099 100644 --- a/src/chem_utils.mbt +++ b/src/chem_utils.mbt @@ -12,26 +12,47 @@ /// Values from Mantina et al. (2008) J. Phys. Chem. A. pub fn chem_vdw_radius(element : String) -> Double { let el = element.to_upper() - if el == "H" { 1.20 } - else if el == "C" { 1.70 } - else if el == "N" { 1.55 } - else if el == "O" { 1.52 } - else if el == "F" { 1.47 } - else if el == "S" { 1.80 } - else if el == "P" { 1.80 } - else if el == "CL" || el == "Cl" { 1.75 } - else if el == "BR" || el == "Br" { 1.85 } - else if el == "I" { 1.98 } - else if el == "FE" || el == "Fe" { 1.94 } - else if el == "ZN" || el == "Zn" { 1.39 } - else if el == "MG" || el == "Mg" { 1.73 } - else if el == "CA" || el == "Ca" { 2.31 } - else if el == "MN" || el == "Mn" { 1.97 } - else if el == "CU" || el == "Cu" { 1.40 } - else if el == "NA" || el == "Na" { 2.27 } - else if el == "K" { 2.75 } - else if el == "BR" { 1.85 } - else { 1.70 } // Default to carbon + if el == "H" { + 1.20 + } else if el == "C" { + 1.70 + } else if el == "N" { + 1.55 + } else if el == "O" { + 1.52 + } else if el == "F" { + 1.47 + } else if el == "S" { + 1.80 + } else if el == "P" { + 1.80 + } else if el == "CL" || el == "Cl" { + 1.75 + } else if el == "BR" || el == "Br" { + 1.85 + } else if el == "I" { + 1.98 + } else if el == "FE" || el == "Fe" { + 1.94 + } else if el == "ZN" || el == "Zn" { + 1.39 + } else if el == "MG" || el == "Mg" { + 1.73 + } else if el == "CA" || el == "Ca" { + 2.31 + } else if el == "MN" || el == "Mn" { + 1.97 + } else if el == "CU" || el == "Cu" { + 1.40 + } else if el == "NA" || el == "Na" { + 2.27 + } else if el == "K" { + 2.75 + } else if el == "BR" { + 1.85 + } else { + 1.70 + } // Default to carbon } ///| @@ -39,64 +60,116 @@ pub fn chem_vdw_radius(element : String) -> Double { /// Values from Cordero et al. (2008) Dalton Trans. pub fn chem_covalent_radius(element : String) -> Double { let el = element.to_upper() - if el == "H" { 0.31 } - else if el == "C" { 0.76 } - else if el == "N" { 0.71 } - else if el == "O" { 0.66 } - else if el == "F" { 0.57 } - else if el == "S" { 1.05 } - else if el == "P" { 1.07 } - else if el == "CL" || el == "Cl" { 1.02 } - else if el == "BR" || el == "Br" { 1.2 } - else if el == "I" { 1.39 } - else if el == "FE" || el == "Fe" { 1.32 } - else if el == "ZN" || el == "Zn" { 1.22 } - else if el == "MG" || el == "Mg" { 1.41 } - else if el == "CA" || el == "Ca" { 1.76 } - else if el == "MN" || el == "Mn" { 1.39 } - else if el == "CU" || el == "Cu" { 1.32 } - else if el == "NA" || el == "Na" { 1.66 } - else if el == "K" { 2.0 } - else { 0.77 } // Default to carbon + if el == "H" { + 0.31 + } else if el == "C" { + 0.76 + } else if el == "N" { + 0.71 + } else if el == "O" { + 0.66 + } else if el == "F" { + 0.57 + } else if el == "S" { + 1.05 + } else if el == "P" { + 1.07 + } else if el == "CL" || el == "Cl" { + 1.02 + } else if el == "BR" || el == "Br" { + 1.2 + } else if el == "I" { + 1.39 + } else if el == "FE" || el == "Fe" { + 1.32 + } else if el == "ZN" || el == "Zn" { + 1.22 + } else if el == "MG" || el == "Mg" { + 1.41 + } else if el == "CA" || el == "Ca" { + 1.76 + } else if el == "MN" || el == "Mn" { + 1.39 + } else if el == "CU" || el == "Cu" { + 1.32 + } else if el == "NA" || el == "Na" { + 1.66 + } else if el == "K" { + 2.0 + } else { + 0.77 + } // Default to carbon } ///| /// Ionic radii by element (in Angstroms) for common oxidation states. /// Returns a tuple of (radius, oxidation_state). -pub fn chem_ionic_radius(element : String, oxidation_state? : Int = 0) -> Double { +pub fn chem_ionic_radius( + element : String, + oxidation_state? : Int = 0, +) -> Double { let el = element.to_upper() - if el == "H" { 0.0 } - else if el == "C" { 0.08 } - else if el == "N" { 0.12 } - else if el == "O" { 1.40 } - else if el == "F" { 1.33 } - else if el == "S" { 1.84 } - else if el == "P" { 0.17 } - else if el == "CL" || el == "Cl" { 1.81 } - else if el == "BR" || el == "Br" { 1.96 } - else if el == "I" { 2.20 } - else if el == "FE" || el == "Fe" { - if oxidation_state == 2 { 0.78 } else { 0.65 } - } - else if el == "ZN" || el == "Zn" { 0.74 } - else if el == "MG" || el == "Mg" { 0.72 } - else if el == "CA" || el == "Ca" { 1.00 } - else if el == "MN" || el == "Mn" { - if oxidation_state == 2 { 0.80 } else { 0.67 } - } - else if el == "CU" || el == "Cu" { - if oxidation_state == 1 { 0.77 } else { 0.73 } + if el == "H" { + 0.0 + } else if el == "C" { + 0.08 + } else if el == "N" { + 0.12 + } else if el == "O" { + 1.40 + } else if el == "F" { + 1.33 + } else if el == "S" { + 1.84 + } else if el == "P" { + 0.17 + } else if el == "CL" || el == "Cl" { + 1.81 + } else if el == "BR" || el == "Br" { + 1.96 + } else if el == "I" { + 2.20 + } else if el == "FE" || el == "Fe" { + if oxidation_state == 2 { + 0.78 + } else { + 0.65 + } + } else if el == "ZN" || el == "Zn" { + 0.74 + } else if el == "MG" || el == "Mg" { + 0.72 + } else if el == "CA" || el == "Ca" { + 1.00 + } else if el == "MN" || el == "Mn" { + if oxidation_state == 2 { + 0.80 + } else { + 0.67 + } + } else if el == "CU" || el == "Cu" { + if oxidation_state == 1 { + 0.77 + } else { + 0.73 + } + } else if el == "NA" || el == "Na" { + 1.02 + } else if el == "K" { + 1.38 + } else { + 0.0 } - else if el == "NA" || el == "Na" { 1.02 } - else if el == "K" { 1.38 } - else { 0.0 } } ///| /// Calculate bond length between two atoms given their coordinates. /// atom1_coords: [x, y, z] of first atom /// atom2_coords: [x, y, z] of second atom -pub fn chem_bond_length(atom1_coords : Array[Double], atom2_coords : Array[Double]) -> Double { +pub fn chem_bond_length( + atom1_coords : Array[Double], + atom2_coords : Array[Double], +) -> Double { let dx = atom1_coords[0] - atom2_coords[0] let dy = atom1_coords[1] - atom2_coords[1] let dz = atom1_coords[2] - atom2_coords[2] @@ -125,7 +198,13 @@ pub fn chem_bond_angle( return 0.0 } let cos_angle = dot / (mag1 * mag2) - let clamped = if cos_angle > 1.0 { 1.0 } else if cos_angle < -1.0 { -1.0 } else { cos_angle } + let clamped = if cos_angle > 1.0 { + 1.0 + } else if cos_angle < -1.0 { + -1.0 + } else { + cos_angle + } // acos approximation acos_approx(clamped) * 180.0 / 3.141592653589793 } @@ -264,8 +343,8 @@ pub fn chem_empirical_formula(element_counts : Map[String, Int]) -> String { /// Calculate molecular weight from element counts and atomic weights. pub fn chem_molecular_weight(element_counts : Map[String, Int]) -> Double { let atomic_weights_elements = [ - "H", "C", "N", "O", "F", "P", "S", "CL", "BR", "I", - "FE", "ZN", "MG", "CA", "MN", "CU", "NA", "K", + "H", "C", "N", "O", "F", "P", "S", "CL", "BR", "I", "FE", "ZN", "MG", "CA", "MN", + "CU", "NA", "K", ] let atomic_weights_values = [ 1.008, 12.011, 14.007, 15.999, 18.998, 30.974, 32.06, 35.45, 79.904, 126.904, @@ -298,8 +377,12 @@ pub fn chem_molecular_weight(element_counts : Map[String, Int]) -> Double { /// Approximate arccosine function. /// Uses the identity: acos(x) = atan2(sqrt(1-x^2), x) fn acos_approx(x : Double) -> Double { - if x >= 1.0 { return 0.0 } - if x <= -1.0 { return 3.141592653589793 } + if x >= 1.0 { + return 0.0 + } + if x <= -1.0 { + return 3.141592653589793 + } atan2_approx((1.0 - x * x).sqrt(), x) } @@ -314,10 +397,12 @@ fn atan2_approx(y : Double, x : Double) -> Double { } else { atan_approx(y / x) - 3.141592653589793 } + } else if y > 0.0 { + 3.141592653589793 / 2.0 + } else if y < 0.0 { + -3.141592653589793 / 2.0 } else { - if y > 0.0 { 3.141592653589793 / 2.0 } - else if y < 0.0 { -3.141592653589793 / 2.0 } - else { 0.0 } + 0.0 } } @@ -345,45 +430,107 @@ pub fn chem_amino_acid_elements(aa_name : String) -> Map[String, Int] { let name = aa_name.to_upper() let elements : Map[String, Int] = Map([], capacity=16) if name == "ALA" || name == "A" { - elements.set("C", 3); elements.set("H", 7); elements.set("N", 1); elements.set("O", 2) + elements.set("C", 3) + elements.set("H", 7) + elements.set("N", 1) + elements.set("O", 2) } else if name == "ARG" || name == "R" { - elements.set("C", 6); elements.set("H", 14); elements.set("N", 4); elements.set("O", 2) + elements.set("C", 6) + elements.set("H", 14) + elements.set("N", 4) + elements.set("O", 2) } else if name == "ASN" || name == "N" { - elements.set("C", 4); elements.set("H", 8); elements.set("N", 2); elements.set("O", 3) + elements.set("C", 4) + elements.set("H", 8) + elements.set("N", 2) + elements.set("O", 3) } else if name == "ASP" || name == "D" { - elements.set("C", 4); elements.set("H", 7); elements.set("N", 1); elements.set("O", 4) + elements.set("C", 4) + elements.set("H", 7) + elements.set("N", 1) + elements.set("O", 4) } else if name == "CYS" || name == "C" { - elements.set("C", 3); elements.set("H", 7); elements.set("N", 1); elements.set("O", 2); elements.set("S", 1) + elements.set("C", 3) + elements.set("H", 7) + elements.set("N", 1) + elements.set("O", 2) + elements.set("S", 1) } else if name == "GLN" || name == "Q" { - elements.set("C", 5); elements.set("H", 10); elements.set("N", 2); elements.set("O", 3) + elements.set("C", 5) + elements.set("H", 10) + elements.set("N", 2) + elements.set("O", 3) } else if name == "GLU" || name == "E" { - elements.set("C", 5); elements.set("H", 9); elements.set("N", 1); elements.set("O", 4) + elements.set("C", 5) + elements.set("H", 9) + elements.set("N", 1) + elements.set("O", 4) } else if name == "GLY" || name == "G" { - elements.set("C", 2); elements.set("H", 5); elements.set("N", 1); elements.set("O", 2) + elements.set("C", 2) + elements.set("H", 5) + elements.set("N", 1) + elements.set("O", 2) } else if name == "HIS" || name == "H" { - elements.set("C", 6); elements.set("H", 9); elements.set("N", 3); elements.set("O", 2) + elements.set("C", 6) + elements.set("H", 9) + elements.set("N", 3) + elements.set("O", 2) } else if name == "ILE" || name == "I" { - elements.set("C", 6); elements.set("H", 13); elements.set("N", 1); elements.set("O", 2) + elements.set("C", 6) + elements.set("H", 13) + elements.set("N", 1) + elements.set("O", 2) } else if name == "LEU" || name == "L" { - elements.set("C", 6); elements.set("H", 13); elements.set("N", 1); elements.set("O", 2) + elements.set("C", 6) + elements.set("H", 13) + elements.set("N", 1) + elements.set("O", 2) } else if name == "LYS" || name == "K" { - elements.set("C", 6); elements.set("H", 14); elements.set("N", 2); elements.set("O", 2) + elements.set("C", 6) + elements.set("H", 14) + elements.set("N", 2) + elements.set("O", 2) } else if name == "MET" || name == "M" { - elements.set("C", 5); elements.set("H", 11); elements.set("N", 1); elements.set("O", 2); elements.set("S", 1) + elements.set("C", 5) + elements.set("H", 11) + elements.set("N", 1) + elements.set("O", 2) + elements.set("S", 1) } else if name == "PHE" || name == "F" { - elements.set("C", 9); elements.set("H", 11); elements.set("N", 1); elements.set("O", 2) + elements.set("C", 9) + elements.set("H", 11) + elements.set("N", 1) + elements.set("O", 2) } else if name == "PRO" || name == "P" { - elements.set("C", 5); elements.set("H", 9); elements.set("N", 1); elements.set("O", 2) + elements.set("C", 5) + elements.set("H", 9) + elements.set("N", 1) + elements.set("O", 2) } else if name == "SER" || name == "S" { - elements.set("C", 3); elements.set("H", 7); elements.set("N", 1); elements.set("O", 3) + elements.set("C", 3) + elements.set("H", 7) + elements.set("N", 1) + elements.set("O", 3) } else if name == "THR" || name == "T" { - elements.set("C", 4); elements.set("H", 9); elements.set("N", 1); elements.set("O", 3) + elements.set("C", 4) + elements.set("H", 9) + elements.set("N", 1) + elements.set("O", 3) } else if name == "TRP" || name == "W" { - elements.set("C", 11); elements.set("H", 12); elements.set("N", 2); elements.set("O", 2) + elements.set("C", 11) + elements.set("H", 12) + elements.set("N", 2) + elements.set("O", 2) } else if name == "TYR" || name == "Y" { - elements.set("C", 9); elements.set("H", 11); elements.set("N", 1); elements.set("O", 3) + elements.set("C", 9) + elements.set("H", 11) + elements.set("N", 1) + elements.set("O", 3) } else if name == "VAL" || name == "V" { - elements.set("C", 5); elements.set("H", 11); elements.set("N", 1); elements.set("O", 2) + elements.set("C", 5) + elements.set("H", 11) + elements.set("N", 1) + elements.set("O", 2) } elements } @@ -417,9 +564,13 @@ pub fn chem_extinction_coefficient(sequence : String) -> Double { let mut i = 0 while i < upper_seq.length() { let ch = upper_seq.unsafe_get(i).unsafe_to_char() - if ch == 'W' { trp_count = trp_count + 1 } - else if ch == 'Y' { tyr_count = tyr_count + 1 } - else if ch == 'C' { cys_count = cys_count + 1 } + if ch == 'W' { + trp_count = trp_count + 1 + } else if ch == 'Y' { + tyr_count = tyr_count + 1 + } else if ch == 'C' { + cys_count = cys_count + 1 + } i = i + 1 } // Pace et al. values @@ -427,7 +578,9 @@ pub fn chem_extinction_coefficient(sequence : String) -> Double { let ext_tyr = 1490.0 let ext_cystine = 125.0 // per disulfide bond (divide Cys by 2) let n_cystine = cys_count / 2 - ext_trp * trp_count.to_double() + ext_tyr * tyr_count.to_double() + ext_cystine * n_cystine.to_double() + ext_trp * trp_count.to_double() + + ext_tyr * tyr_count.to_double() + + ext_cystine * n_cystine.to_double() } ///| @@ -469,15 +622,22 @@ pub fn chem_isoelectric_point( neg_charge = 0.0 // Positive charges pos_charge = pos_charge + 1.0 / (1.0 + chem_pow10(pH - p_nterm)) // N-term - pos_charge = pos_charge + arg_count.to_double() / (1.0 + chem_pow10(pH - pka_arg)) - pos_charge = pos_charge + lys_count.to_double() / (1.0 + chem_pow10(pH - pka_lys)) - pos_charge = pos_charge + his_count.to_double() / (1.0 + chem_pow10(pH - pka_his)) + pos_charge = pos_charge + + arg_count.to_double() / (1.0 + chem_pow10(pH - pka_arg)) + pos_charge = pos_charge + + lys_count.to_double() / (1.0 + chem_pow10(pH - pka_lys)) + pos_charge = pos_charge + + his_count.to_double() / (1.0 + chem_pow10(pH - pka_his)) // Negative charges neg_charge = neg_charge + 1.0 / (1.0 + chem_pow10(p_cterm - pH)) // C-term - neg_charge = neg_charge + asp_count.to_double() / (1.0 + chem_pow10(pka_asp - pH)) - neg_charge = neg_charge + glu_count.to_double() / (1.0 + chem_pow10(pka_glu - pH)) - neg_charge = neg_charge + cys_count.to_double() / (1.0 + chem_pow10(pka_cys - pH)) - neg_charge = neg_charge + tyr_count.to_double() / (1.0 + chem_pow10(pka_tyr - pH)) + neg_charge = neg_charge + + asp_count.to_double() / (1.0 + chem_pow10(pka_asp - pH)) + neg_charge = neg_charge + + glu_count.to_double() / (1.0 + chem_pow10(pka_glu - pH)) + neg_charge = neg_charge + + cys_count.to_double() / (1.0 + chem_pow10(pka_cys - pH)) + neg_charge = neg_charge + + tyr_count.to_double() / (1.0 + chem_pow10(pka_tyr - pH)) let net = pos_charge - neg_charge if net > 0.0 { low = pH @@ -537,8 +697,8 @@ pub fn chem_count_atoms(sequence : String) -> Int { /// Parses formulas like "H2O", "C6H12O6", "NaCl", etc. pub fn chem_formula_weight(formula : String) -> Double { let atomic_weights_elements = [ - "H", "C", "N", "O", "F", "P", "S", "CL", "BR", "I", - "FE", "ZN", "MG", "CA", "MN", "CU", "NA", "K", + "H", "C", "N", "O", "F", "P", "S", "CL", "BR", "I", "FE", "ZN", "MG", "CA", "MN", + "CU", "NA", "K", ] let atomic_weights_values = [ 1.008, 12.011, 14.007, 15.999, 18.998, 30.974, 32.06, 35.45, 79.904, 126.904, @@ -565,7 +725,8 @@ pub fn chem_formula_weight(formula : String) -> Double { let next_ch = upper.unsafe_get(pos).to_int() if next_ch >= 65 && next_ch <= 90 { // Check if two-letter combination is in weight map - let two_letter = el + upper.unsafe_get(pos).unsafe_to_char().to_string() + let two_letter = el + + upper.unsafe_get(pos).unsafe_to_char().to_string() if weight_map.contains(two_letter) { el = two_letter pos = pos + 1 @@ -603,17 +764,29 @@ pub fn chem_formula_weight(formula : String) -> Double { ///| /// Calculate typical hydrogen bond length between two atom types. /// Returns approximate distance in Angstroms. -pub fn chem_hydrogen_bond_length(donor_type : String, acceptor_type : String) -> Double { +pub fn chem_hydrogen_bond_length( + donor_type : String, + acceptor_type : String, +) -> Double { let donor = donor_type.to_upper() let acceptor = acceptor_type.to_upper() let key = donor + "..." + acceptor // Typical hydrogen bond distances (Angstroms) - if key == "OH...OH" || key == "OH...O" { 2.72 } - else if key == "NH...OH" || key == "NH...O" { 2.93 } - else if key == "SH...SH" { 3.45 } - else if key == "OH...NH" || key == "O...HN" { 2.88 } - else if key == "NH...N" { 3.10 } - else if key == "OH...S" { 3.40 } - else if key == "NH...S" { 3.45 } - else { 2.90 } // Default + if key == "OH...OH" || key == "OH...O" { + 2.72 + } else if key == "NH...OH" || key == "NH...O" { + 2.93 + } else if key == "SH...SH" { + 3.45 + } else if key == "OH...NH" || key == "O...HN" { + 2.88 + } else if key == "NH...N" { + 3.10 + } else if key == "OH...S" { + 3.40 + } else if key == "NH...S" { + 3.45 + } else { + 2.90 + } // Default } diff --git a/src/chemminer.mbt b/src/chemminer.mbt index 8c0c35df..82704138 100644 --- a/src/chemminer.mbt +++ b/src/chemminer.mbt @@ -80,7 +80,7 @@ pub fn SdfAtom::new( x : Double, y : Double, z : Double, - charge : Int + charge : Int, ) -> SdfAtom { SdfAtom::{ symbol, x, y, z, charge } } @@ -179,7 +179,7 @@ pub struct SdfMolecule { pub fn SdfMolecule::new( name : String, atoms : Array[SdfAtom], - bonds : Array[SdfBond] + bonds : Array[SdfBond], ) -> SdfMolecule { SdfMolecule::{ name, atoms, bonds, properties: Map([], capacity=8) } } @@ -218,10 +218,7 @@ pub fn SdfMolecule::n_bonds(self : SdfMolecule) -> Int { ///| /// Get a property value by key. Returns empty string if missing. -pub fn SdfMolecule::get_property( - self : SdfMolecule, - key : String -) -> String { +pub fn SdfMolecule::get_property(self : SdfMolecule, key : String) -> String { self.properties.get_or_default(key, "") } @@ -230,17 +227,14 @@ pub fn SdfMolecule::get_property( pub fn SdfMolecule::set_property( self : SdfMolecule, key : String, - value : String + value : String, ) -> Unit { self.properties[key] = value } ///| /// Whether the molecule has a property. -pub fn SdfMolecule::has_property( - self : SdfMolecule, - key : String -) -> Bool { +pub fn SdfMolecule::has_property(self : SdfMolecule, key : String) -> Bool { self.properties.contains(key) } @@ -293,7 +287,13 @@ pub fn chem_molecular_formula(mol : SdfMolecule) -> String { remaining.push(k) } remaining.sort_by(fn(a : String, b : String) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) for elem in remaining { let c = counts[elem] @@ -374,7 +374,11 @@ pub fn chem_ring_count(mol : SdfMolecule) -> Int { } // Cyclomatic number. let rings = n_bonds - n_atoms + n_components - if rings < 0 { 0 } else { rings } + if rings < 0 { + 0 + } else { + rings + } } // ============================================================================ @@ -417,11 +421,7 @@ fn chem_atom_degrees(mol : SdfMolecule) -> Array[Int] { ///| /// BFS shortest-path distance between two atom indices in the molecular /// graph. Returns -1 if unreachable. -fn chem_bfs_distance( - mol : SdfMolecule, - start : Int, - end : Int -) -> Int { +fn chem_bfs_distance(mol : SdfMolecule, start : Int, end : Int) -> Int { if start == end { return 0 } @@ -499,7 +499,13 @@ pub fn chem_atom_pair_fingerprint(mol : SdfMolecule) -> Array[Int] { result.push(k) } result.sort_by(fn(a : Int, b : Int) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) result } @@ -570,7 +576,7 @@ fn chem_substructure_try_match( t_adj : Array[Array[(Int, Int)]], mapping : Array[Int], used : Array[Bool], - i : Int + i : Int, ) -> Bool { if i == qn { return true @@ -616,8 +622,15 @@ fn chem_substructure_try_match( mapping[i] = t used[t] = true if chem_substructure_try_match( - qn, query, target, q_adj, t_adj, mapping, used, i + 1 - ) { + qn, + query, + target, + q_adj, + t_adj, + mapping, + used, + i + 1, + ) { return true } else { mapping[i] = -1 @@ -638,7 +651,7 @@ fn chem_substructure_try_match( /// greedy backtracking search. pub fn chem_substructure_match( query : SdfMolecule, - target : SdfMolecule + target : SdfMolecule, ) -> Bool { let qn = query.n_atoms() let tn = target.n_atoms() @@ -682,7 +695,7 @@ fn chem_trim(s : StringView) -> String { let n = s.length() let mut start = 0 while start < n { - let ch = s[start : start + 1] + let ch = s[start:start + 1] if ch == " " || ch == "\t" || ch == "\r" || ch == "\n" { start = start + 1 } else { @@ -691,7 +704,7 @@ fn chem_trim(s : StringView) -> String { } let mut end = n while end > start { - let ch = s[end - 1 : end] + let ch = s[end - 1:end] if ch == " " || ch == "\t" || ch == "\r" || ch == "\n" { end = end - 1 } else { @@ -763,8 +776,8 @@ pub fn chem_parse_sdf(content : String) -> Array[SdfMolecule] { // Line 4: counts line. let counts_line = lines[idx] idx = idx + 1 - let n_atoms = chem_parse_int_field(counts_line[0 : 3]) - let n_bonds = chem_parse_int_field(counts_line[3 : 6]) + let n_atoms = chem_parse_int_field(counts_line[0:3]) + let n_bonds = chem_parse_int_field(counts_line[3:6]) // Parse atom block. let atoms : Array[SdfAtom] = Array::new() for _ in 0.. Array[SdfMolecule] { let line = lines[idx] idx = idx + 1 // SDF atom line: xxxx.xxxxyyyy.yyyyzzzz.zzzz aaaddcccssshhhbbbvvvHHHrrriiimmmnnneee - let x = chem_parse_double_field(line[0 : 10]) - let y = chem_parse_double_field(line[10 : 20]) - let z = chem_parse_double_field(line[20 : 30]) - let symbol = chem_trim(line[31 : 34]) + let x = chem_parse_double_field(line[0:10]) + let y = chem_parse_double_field(line[10:20]) + let z = chem_parse_double_field(line[20:30]) + let symbol = chem_trim(line[31:34]) // Charge field is at columns 36-38 (0-based from 36). let charge = if line.length() >= 39 { - let c = chem_parse_int_field(line[36 : 39]) + let c = chem_parse_int_field(line[36:39]) // SDF charge encoding: 0=0, 1=+3, 2=+2, 3=+1, 4=0, 5=-1, 6=-2, 7=-3 match c { 1 => 3 @@ -804,9 +817,9 @@ pub fn chem_parse_sdf(content : String) -> Array[SdfMolecule] { } let line = lines[idx] idx = idx + 1 - let a1 = chem_parse_int_field(line[0 : 3]) - 1 // convert 1-based to 0-based - let a2 = chem_parse_int_field(line[3 : 6]) - 1 - let bt = chem_parse_int_field(line[6 : 9]) + let a1 = chem_parse_int_field(line[0:3]) - 1 // convert 1-based to 0-based + let a2 = chem_parse_int_field(line[3:6]) - 1 + let bt = chem_parse_int_field(line[6:9]) bonds.push(SdfBond::new(a1, a2, bt)) } let mol = SdfMolecule::new(name, atoms, bonds) @@ -819,7 +832,7 @@ pub fn chem_parse_sdf(content : String) -> Array[SdfMolecule] { break } // Property line: "> " (or "> " with extra spaces). - if trimmed.length() > 3 && trimmed[0 : 1] == ">" { + if trimmed.length() > 3 && trimmed[0:1] == ">" { // Find the first '<' and the last '>'. let lt_pos = trimmed.find("<") // Find the last '>' by scanning from the end. @@ -827,20 +840,19 @@ pub fn chem_parse_sdf(content : String) -> Array[SdfMolecule] { let tn = trimmed.length() let mut k = tn - 1 while k >= 0 { - if trimmed[k : k + 1] == ">" { + if trimmed[k:k + 1] == ">" { gt_idx = k break } k = k - 1 } let prop_name = match lt_pos { - Some(lt) => { + Some(lt) => if gt_idx > lt + 1 { - trimmed[lt + 1 : gt_idx].to_owned() + trimmed[lt + 1:gt_idx].to_owned() } else { "" } - } None => "" } idx = idx + 1 diff --git a/src/chipseeker.mbt b/src/chipseeker.mbt index 69b8bcaf..8075defe 100644 --- a/src/chipseeker.mbt +++ b/src/chipseeker.mbt @@ -9,16 +9,20 @@ /// Feature assignment uses the ChIPseeker priority order: /// Promoter > 5'UTR > 3'UTR > Exon > Intron > Downstream > Distal Intergenic -///| Length of the 5'UTR / 3'UTR approximation (in bp). +///| +/// Length of the 5'UTR / 3'UTR approximation (in bp). const CS_UTR_LENGTH : Int = 500 -///| Size of each implicit "exon" segment inside the gene body (in bp). +///| +/// Size of each implicit "exon" segment inside the gene body (in bp). const CS_EXON_SIZE : Int = 1000 -///| Size of the downstream region past the gene body (in bp). +///| +/// Size of the downstream region past the gene body (in bp). const CS_DOWNSTREAM_WINDOW : Int = 3000 -///| A ChIP-seq peak (genomic interval). +///| +/// A ChIP-seq peak (genomic interval). pub struct Peak { chr : String start : Int @@ -29,7 +33,9 @@ pub struct Peak { } ///| Construct a Peak. `chr` and `start` are required; all other fields -///| are optional and default to zero (summit=0 means "use peak center"). + +///| +/// are optional and default to zero (summit=0 means "use peak center"). pub fn Peak::new( chr~ : String, start~ : Int, @@ -41,42 +47,50 @@ pub fn Peak::new( Peak::{ chr, start, end, summit, fold_enrichment, p_value } } -///| Get the chromosome of the peak. +///| +/// Get the chromosome of the peak. pub fn Peak::get_chr(self : Peak) -> String { self.chr } -///| Get the start position of the peak. +///| +/// Get the start position of the peak. pub fn Peak::get_start(self : Peak) -> Int { self.start } -///| Get the end position of the peak. +///| +/// Get the end position of the peak. pub fn Peak::get_end(self : Peak) -> Int { self.end } -///| Set the end position of the peak. +///| +/// Set the end position of the peak. pub fn Peak::set_end(self : Peak, new_end : Int) -> Unit { self.end = new_end } -///| Get the summit position of the peak. +///| +/// Get the summit position of the peak. pub fn Peak::get_summit(self : Peak) -> Int { self.summit } -///| Get the fold enrichment of the peak. +///| +/// Get the fold enrichment of the peak. pub fn Peak::get_fold_enrichment(self : Peak) -> Double { self.fold_enrichment } -///| Get the p-value of the peak. +///| +/// Get the p-value of the peak. pub fn Peak::get_p_value(self : Peak) -> Double { self.p_value } -///| A gene annotation record used for peak annotation. +///| +/// A gene annotation record used for peak annotation. pub struct GeneAnnotation { gene_id : String gene_name : String @@ -88,8 +102,11 @@ pub struct GeneAnnotation { } ///| Construct a GeneAnnotation. The TSS is auto-computed from the strand: + ///| "+" strand -> tss = gene_start -///| "-" strand -> tss = gene_end + +///| +/// "-" strand -> tss = gene_end pub fn GeneAnnotation::new( gene_id~ : String, gene_name~ : String, @@ -102,42 +119,50 @@ pub fn GeneAnnotation::new( GeneAnnotation::{ gene_id, gene_name, chr, gene_start, gene_end, strand, tss } } -///| Get the gene id. +///| +/// Get the gene id. pub fn GeneAnnotation::get_gene_id(self : GeneAnnotation) -> String { self.gene_id } -///| Get the gene name. +///| +/// Get the gene name. pub fn GeneAnnotation::get_gene_name(self : GeneAnnotation) -> String { self.gene_name } -///| Get the chromosome. +///| +/// Get the chromosome. pub fn GeneAnnotation::get_chr(self : GeneAnnotation) -> String { self.chr } -///| Get the gene start. +///| +/// Get the gene start. pub fn GeneAnnotation::get_gene_start(self : GeneAnnotation) -> Int { self.gene_start } -///| Get the gene end. +///| +/// Get the gene end. pub fn GeneAnnotation::get_gene_end(self : GeneAnnotation) -> Int { self.gene_end } -///| Get the strand. +///| +/// Get the strand. pub fn GeneAnnotation::get_strand(self : GeneAnnotation) -> String { self.strand } -///| Get the transcription start site (TSS). +///| +/// Get the transcription start site (TSS). pub fn GeneAnnotation::get_tss(self : GeneAnnotation) -> Int { self.tss } -///| The result of annotating a single peak. +///| +/// The result of annotating a single peak. pub struct PeakAnnotation { peak : Peak gene_id : String @@ -149,7 +174,8 @@ pub struct PeakAnnotation { annotation : String // detailed annotation string } -///| Construct a PeakAnnotation. +///| +/// Construct a PeakAnnotation. pub fn PeakAnnotation::new( peak~ : Peak, gene_id~ : String, @@ -172,47 +198,56 @@ pub fn PeakAnnotation::new( } } -///| Get the peak. +///| +/// Get the peak. pub fn PeakAnnotation::get_peak(self : PeakAnnotation) -> Peak { self.peak } -///| Get the gene id. +///| +/// Get the gene id. pub fn PeakAnnotation::get_gene_id(self : PeakAnnotation) -> String { self.gene_id } -///| Get the gene name. +///| +/// Get the gene name. pub fn PeakAnnotation::get_gene_name(self : PeakAnnotation) -> String { self.gene_name } -///| Get the chromosome. +///| +/// Get the chromosome. pub fn PeakAnnotation::get_chr(self : PeakAnnotation) -> String { self.chr } -///| Get the TSS. +///| +/// Get the TSS. pub fn PeakAnnotation::get_tss(self : PeakAnnotation) -> Int { self.tss } -///| Get the signed distance to TSS. +///| +/// Get the signed distance to TSS. pub fn PeakAnnotation::get_distance_to_tss(self : PeakAnnotation) -> Int { self.distance_to_tss } -///| Get the assigned feature string. +///| +/// Get the assigned feature string. pub fn PeakAnnotation::get_feature(self : PeakAnnotation) -> String { self.feature } -///| Get the detailed annotation string. +///| +/// Get the detailed annotation string. pub fn PeakAnnotation::get_annotation(self : PeakAnnotation) -> String { self.annotation } -///| Summary counts of peaks assigned to each feature type. +///| +/// Summary counts of peaks assigned to each feature type. pub struct AnnotationSummary { total_peaks : Int promoter : Int @@ -224,7 +259,8 @@ pub struct AnnotationSummary { distal_intergenic : Int } -///| Construct an AnnotationSummary. +///| +/// Construct an AnnotationSummary. pub fn AnnotationSummary::new( total_peaks~ : Int, promoter~ : Int, @@ -247,48 +283,60 @@ pub fn AnnotationSummary::new( } } -///| Get total peaks. +///| +/// Get total peaks. pub fn AnnotationSummary::get_total_peaks(self : AnnotationSummary) -> Int { self.total_peaks } -///| Get promoter count. +///| +/// Get promoter count. pub fn AnnotationSummary::get_promoter(self : AnnotationSummary) -> Int { self.promoter } -///| Get 5'UTR count. +///| +/// Get 5'UTR count. pub fn AnnotationSummary::get_utr5(self : AnnotationSummary) -> Int { self.utr5 } -///| Get 3'UTR count. +///| +/// Get 3'UTR count. pub fn AnnotationSummary::get_utr3(self : AnnotationSummary) -> Int { self.utr3 } -///| Get exon count. +///| +/// Get exon count. pub fn AnnotationSummary::get_exon(self : AnnotationSummary) -> Int { self.exon } -///| Get intron count. +///| +/// Get intron count. pub fn AnnotationSummary::get_intron(self : AnnotationSummary) -> Int { self.intron } -///| Get downstream count. +///| +/// Get downstream count. pub fn AnnotationSummary::get_downstream(self : AnnotationSummary) -> Int { self.downstream } -///| Get distal intergenic count. -pub fn AnnotationSummary::get_distal_intergenic(self : AnnotationSummary) -> Int { +///| +/// Get distal intergenic count. +pub fn AnnotationSummary::get_distal_intergenic( + self : AnnotationSummary, +) -> Int { self.distal_intergenic } ///| Compute the effective single position used for a peak. Uses the summit -///| if it is non-zero, otherwise the midpoint of [start, end]. + +///| +/// if it is non-zero, otherwise the midpoint of [start, end]. pub fn cs_peak_position(peak : Peak) -> Int { if peak.summit != 0 { peak.summit @@ -298,7 +346,9 @@ pub fn cs_peak_position(peak : Peak) -> Int { } ///| Build a sentinel "no gene" annotation. Used when no gene is found on -///| the same chromosome as the peak. + +///| +/// the same chromosome as the peak. fn cs_na_gene(chr : String) -> GeneAnnotation { GeneAnnotation::{ gene_id: "", @@ -312,10 +362,15 @@ fn cs_na_gene(chr : String) -> GeneAnnotation { } ///| Compute the signed distance from a peak to a gene's TSS. + ///| + ///| Positive distance means the peak is downstream of the TSS (in the + ///| transcription direction); negative means upstream. For "-" strand -///| genes the orientation is flipped so the sign convention still holds. + +///| +/// genes the orientation is flipped so the sign convention still holds. pub fn compute_tss_distance(peak : Peak, gene : GeneAnnotation) -> Int { if gene.gene_id == "" { return 0 @@ -329,8 +384,11 @@ pub fn compute_tss_distance(peak : Peak, gene : GeneAnnotation) -> Int { } ///| Find the gene whose TSS is closest to the peak. Only genes on the same + ///| chromosome as the peak are considered. If no such gene exists, a -///| sentinel annotation with empty `gene_id` is returned. + +///| +/// sentinel annotation with empty `gene_id` is returned. pub fn find_nearest_gene( peak : Peak, genes : Array[GeneAnnotation], @@ -354,8 +412,11 @@ pub fn find_nearest_gene( } ///| Assign a genomic feature to a peak relative to a gene, following the + ///| ChIPseeker priority: -///| Promoter > 5'UTR > 3'UTR > Exon > Intron > Downstream > Distal Intergenic + +///| +/// Promoter > 5'UTR > 3'UTR > Exon > Intron > Downstream > Distal Intergenic pub fn assign_feature( peak : Peak, gene : GeneAnnotation, @@ -377,7 +438,20 @@ pub fn assign_feature( // the middle of the gene body. let utr_len = CS_UTR_LENGTH let exon_size = CS_EXON_SIZE - let (utr5_start, utr5_end, utr3_start, utr3_end, exon1_start, exon1_end, exon2_start, exon2_end, intron_start, intron_end, down_start, down_end) = if gene.strand == "-" { + let ( + utr5_start, + utr5_end, + utr3_start, + utr3_end, + exon1_start, + exon1_end, + exon2_start, + exon2_end, + intron_start, + intron_end, + down_start, + down_end, + ) = if gene.strand == "-" { // "-" strand: TSS = gene_end; transcription proceeds toward gene_start. let utr5_s = gene.gene_end - utr_len let utr5_e = gene.gene_end @@ -392,18 +466,8 @@ pub fn assign_feature( let down_s = gene.gene_start - CS_DOWNSTREAM_WINDOW let down_e = gene.gene_start ( - utr5_s, - utr5_e, - utr3_s, - utr3_e, - exon1_s, - exon1_e, - exon2_s, - exon2_e, - intron_s, - intron_e, - down_s, - down_e, + utr5_s, utr5_e, utr3_s, utr3_e, exon1_s, exon1_e, exon2_s, exon2_e, intron_s, + intron_e, down_s, down_e, ) } else { // "+" strand: TSS = gene_start; transcription proceeds toward gene_end. @@ -420,18 +484,8 @@ pub fn assign_feature( let down_s = gene.gene_end let down_e = gene.gene_end + CS_DOWNSTREAM_WINDOW ( - utr5_s, - utr5_e, - utr3_s, - utr3_e, - exon1_s, - exon1_e, - exon2_s, - exon2_e, - intron_s, - intron_e, - down_s, - down_e, + utr5_s, utr5_e, utr3_s, utr3_e, exon1_s, exon1_e, exon2_s, exon2_e, intron_s, + intron_e, down_s, down_e, ) } // 2. 5'UTR @@ -444,7 +498,7 @@ pub fn assign_feature( } // 4. Exon (either of the two implicit exon segments) if (peak_pos >= exon1_start && peak_pos <= exon1_end) || - (peak_pos >= exon2_start && peak_pos <= exon2_end) { + (peak_pos >= exon2_start && peak_pos <= exon2_end) { return "Exon" } // 5. Intron @@ -459,7 +513,8 @@ pub fn assign_feature( "Distal Intergenic" } -///| Format the detailed annotation string for a peak/gene/feature triple. +///| +/// Format the detailed annotation string for a peak/gene/feature triple. fn cs_format_annotation( gene : GeneAnnotation, distance : Int, @@ -475,19 +530,21 @@ fn cs_format_annotation( "Intron" => "Intron of \{gene.gene_name}" "Downstream" => "Downstream (<=\{CS_DOWNSTREAM_WINDOW}bp) of \{gene.gene_name}" - _ => { + _ => if gene.gene_id == "" { "Distal Intergenic (no nearby gene on same chromosome)" } else { "Distal Intergenic (nearest gene: \{gene.gene_name}, distance to TSS: \{distance})" } - } } } ///| Annotate a single peak: find the nearest gene, compute the signed + ///| distance to its TSS, assign a genomic feature, and build the detailed -///| annotation string. + +///| +/// annotation string. pub fn annotate_peak( peak : Peak, genes : Array[GeneAnnotation], @@ -496,20 +553,23 @@ pub fn annotate_peak( let gene = find_nearest_gene(peak, genes) let distance = compute_tss_distance(peak, gene) let feature = assign_feature(peak, gene, promoter_window) - let annotation = cs_format_annotation(gene, distance, feature, promoter_window) + let annotation = cs_format_annotation( + gene, distance, feature, promoter_window, + ) PeakAnnotation::new( - peak=peak, + peak~, gene_id=gene.gene_id, gene_name=gene.gene_name, chr=peak.chr, tss=gene.tss, distance_to_tss=distance, - feature=feature, - annotation=annotation, + feature~, + annotation~, ) } -///| Annotate a collection of peaks against a set of gene annotations. +///| +/// Annotate a collection of peaks against a set of gene annotations. pub fn annotate_peaks( peaks : Array[Peak], genes : Array[GeneAnnotation], @@ -522,7 +582,8 @@ pub fn annotate_peaks( result } -///| Tally the feature assignments of a list of peak annotations. +///| +/// Tally the feature assignments of a list of peak annotations. pub fn annotation_summary( annotations : Array[PeakAnnotation], ) -> AnnotationSummary { @@ -547,17 +608,18 @@ pub fn annotation_summary( } AnnotationSummary::new( total_peaks=annotations.length(), - promoter=promoter, - utr5=utr5, - utr3=utr3, - exon=exon, - intron=intron, - downstream=downstream, - distal_intergenic=distal_intergenic, + promoter~, + utr5~, + utr3~, + exon~, + intron~, + downstream~, + distal_intergenic~, ) } -///| Return only those annotations whose feature matches `feature`. +///| +/// Return only those annotations whose feature matches `feature`. pub fn filter_by_feature( annotations : Array[PeakAnnotation], feature : String, @@ -572,7 +634,9 @@ pub fn filter_by_feature( } ///| Return only those annotations whose absolute distance to TSS is at -///| most `max_distance`. + +///| +/// most `max_distance`. pub fn filter_by_distance( annotations : Array[PeakAnnotation], max_distance : Int, @@ -586,7 +650,8 @@ pub fn filter_by_distance( result } -///| Format an AnnotationSummary as a human-readable string. +///| +/// Format an AnnotationSummary as a human-readable string. pub fn chipseeker_summary_string(summary : AnnotationSummary) -> String { let mut s = "ChIPseeker Annotation Summary\n" s = s + "=============================\n" @@ -602,10 +667,15 @@ pub fn chipseeker_summary_string(summary : AnnotationSummary) -> String { } ///| Sample ChIP-seq peaks for testing and demonstration. The peaks are + ///| laid out so that, when annotated against `chipseeker_sample_genes()` + ///| with the default promoter window (3000), they exercise every feature + ///| type except 5'UTR (which is only reachable with a smaller window -///| because the 5'UTR sits inside the default promoter window). + +///| +/// because the 5'UTR sits inside the default promoter window). pub fn chipseeker_sample_peaks() -> Array[Peak] { [ // chr1, GeneA (+ strand, TSS=10000, gene_end=25000) @@ -629,7 +699,8 @@ pub fn chipseeker_sample_peaks() -> Array[Peak] { ] } -///| Sample gene annotations for testing and demonstration. +///| +/// Sample gene annotations for testing and demonstration. pub fn chipseeker_sample_genes() -> Array[GeneAnnotation] { [ GeneAnnotation::new( diff --git a/src/chromosome_visualization.mbt b/src/chromosome_visualization.mbt index b8c5521a..9b4fc22c 100644 --- a/src/chromosome_visualization.mbt +++ b/src/chromosome_visualization.mbt @@ -20,15 +20,21 @@ pub enum ChrOrientation { ///| /// Create a Forward orientation. -pub fn chr_orientation_forward() -> ChrOrientation { Forward } +pub fn chr_orientation_forward() -> ChrOrientation { + Forward +} ///| /// Create a Reverse orientation. -pub fn chr_orientation_reverse() -> ChrOrientation { Reverse } +pub fn chr_orientation_reverse() -> ChrOrientation { + Reverse +} ///| /// Create a None orientation. -pub fn chr_orientation_none() -> ChrOrientation { None } +pub fn chr_orientation_none() -> ChrOrientation { + None +} ///| /// Type of a genomic feature. @@ -47,27 +53,39 @@ pub enum ChrFeatureType { ///| /// Create a Gene feature type. -pub fn chr_feature_type_gene() -> ChrFeatureType { Gene } +pub fn chr_feature_type_gene() -> ChrFeatureType { + Gene +} ///| /// Create an Exon feature type. -pub fn chr_feature_type_exon() -> ChrFeatureType { Exon } +pub fn chr_feature_type_exon() -> ChrFeatureType { + Exon +} ///| /// Create an Intron feature type. -pub fn chr_feature_type_intron() -> ChrFeatureType { Intron } +pub fn chr_feature_type_intron() -> ChrFeatureType { + Intron +} ///| /// Create a CDS feature type. -pub fn chr_feature_type_cds() -> ChrFeatureType { CDS } +pub fn chr_feature_type_cds() -> ChrFeatureType { + CDS +} ///| /// Create a UTR feature type. -pub fn chr_feature_type_utr() -> ChrFeatureType { UTR } +pub fn chr_feature_type_utr() -> ChrFeatureType { + UTR +} ///| /// Create a Promoter feature type. -pub fn chr_feature_type_promoter() -> ChrFeatureType { Promoter } +pub fn chr_feature_type_promoter() -> ChrFeatureType { + Promoter +} ///| /// A genomic feature on a chromosome. @@ -172,7 +190,11 @@ pub fn ChrFeature::new( orientation, feature_type, color, - label: if label.length() > 0 { label } else { name }, + label: if label.length() > 0 { + label + } else { + name + }, height, } } @@ -193,7 +215,11 @@ pub fn ChrRegion::new( end, color, opacity, - label: if label.length() > 0 { label } else { name }, + label: if label.length() > 0 { + label + } else { + name + }, } } @@ -255,12 +281,7 @@ pub fn ChrDiagram::new( layout? : ChrLayout = ChrLayout::new(), title? : String = "", ) -> ChrDiagram { - ChrDiagram::{ - chromosomes, - layout, - title, - svg_elements: [], - } + ChrDiagram::{ chromosomes, layout, title, svg_elements: [] } } // ============================================================================ @@ -269,7 +290,10 @@ pub fn ChrDiagram::new( ///| /// Add a feature to a chromosome. -pub fn Chromosome::add_feature(self : Chromosome, feature : ChrFeature) -> Chromosome { +pub fn Chromosome::add_feature( + self : Chromosome, + feature : ChrFeature, +) -> Chromosome { let new_features = self.features.copy() new_features.push(feature) Chromosome::{ @@ -285,7 +309,10 @@ pub fn Chromosome::add_feature(self : Chromosome, feature : ChrFeature) -> Chrom ///| /// Add a region to a chromosome. -pub fn Chromosome::add_region(self : Chromosome, region : ChrRegion) -> Chromosome { +pub fn Chromosome::add_region( + self : Chromosome, + region : ChrRegion, +) -> Chromosome { let new_regions = self.regions.copy() new_regions.push(region) Chromosome::{ @@ -375,24 +402,38 @@ pub fn chr_band_color(stain : String) -> String { ///| /// Helper: max of two doubles. fn chr_max(a : Double, b : Double) -> Double { - if a > b { a } else { b } + if a > b { + a + } else { + b + } } ///| /// Helper: min of two doubles. fn chr_min(a : Double, b : Double) -> Double { - if a < b { a } else { b } + if a < b { + a + } else { + b + } } ///| /// Helper: abs of double. fn chr_abs(x : Double) -> Double { - if x < 0.0 { -x } else { x } + if x < 0.0 { + -x + } else { + x + } } ///| /// Helper: PI constant. -fn chr_pi() -> Double { 3.14159265358979323846 } +fn chr_pi() -> Double { + 3.14159265358979323846 +} ///| /// Helper: create SVG attributes map. @@ -417,12 +458,7 @@ fn chr_svg_elem( content : String, children : Array[ChrSVGElement], ) -> ChrSVGElement { - ChrSVGElement::{ - element_type, - attributes, - content, - children, - } + ChrSVGElement::{ element_type, attributes, content, children } } ///| @@ -440,32 +476,42 @@ pub fn chr_chromosome_to_svg( let chrom_length = chr.length * scale // Chromosome body - let body_rect = chr_svg_elem("rect", chr_svg_attrs([ - ("x", (x_offset).to_string()), - ("y", (y_offset - thickness / 2.0).to_string()), - ("width", chrom_length.to_string()), - ("height", thickness.to_string()), - ("fill", "#E0E0E0"), - ("stroke", "#333333"), - ("stroke-width", "1"), - ("rx", "3"), - ("ry", "3"), - ]), "", []) + let body_rect = chr_svg_elem( + "rect", + chr_svg_attrs([ + ("x", x_offset.to_string()), + ("y", (y_offset - thickness / 2.0).to_string()), + ("width", chrom_length.to_string()), + ("height", thickness.to_string()), + ("fill", "#E0E0E0"), + ("stroke", "#333333"), + ("stroke-width", "1"), + ("rx", "3"), + ("ry", "3"), + ]), + "", + [], + ) elements.push(body_rect) // Centromere if layout.show_centromere && chr.centromere_pos > 0.0 { let cen_x = x_offset + chr.centromere_pos * scale let cen_width = thickness * 1.5 - let centromere = chr_svg_elem("ellipse", chr_svg_attrs([ - ("cx", cen_x.to_string()), - ("cy", y_offset.to_string()), - ("rx", (cen_width / 2.0).to_string()), - ("ry", (thickness / 2.0 + 2.0).to_string()), - ("fill", "#CC0000"), - ("stroke", "#990000"), - ("stroke-width", "1"), - ]), "", []) + let centromere = chr_svg_elem( + "ellipse", + chr_svg_attrs([ + ("cx", cen_x.to_string()), + ("cy", y_offset.to_string()), + ("rx", (cen_width / 2.0).to_string()), + ("ry", (thickness / 2.0 + 2.0).to_string()), + ("fill", "#CC0000"), + ("stroke", "#990000"), + ("stroke-width", "1"), + ]), + "", + [], + ) elements.push(centromere) } @@ -476,14 +522,19 @@ pub fn chr_chromosome_to_svg( let bx = x_offset + bstart * scale let bw = (bend - bstart) * scale let color = chr_band_color(stain) - let band_elem = chr_svg_elem("rect", chr_svg_attrs([ - ("x", bx.to_string()), - ("y", (y_offset - thickness / 2.0).to_string()), - ("width", bw.to_string()), - ("height", thickness.to_string()), - ("fill", color), - ("stroke", "none"), - ]), "", []) + let band_elem = chr_svg_elem( + "rect", + chr_svg_attrs([ + ("x", bx.to_string()), + ("y", (y_offset - thickness / 2.0).to_string()), + ("width", bw.to_string()), + ("height", thickness.to_string()), + ("fill", color), + ("stroke", "none"), + ]), + "", + [], + ) elements.push(band_elem) } } @@ -501,51 +552,70 @@ pub fn chr_chromosome_to_svg( if feat.orientation == Forward { // Arrow pointing right let poly_points = [ - (fx).to_string() + "," + (y_offset - fh / 2.0).to_string(), - (fx + fw - arrow_size).to_string() + "," + (y_offset - fh / 2.0).to_string(), - (fx + fw).to_string() + "," + (y_offset).to_string(), - (fx + fw - arrow_size).to_string() + "," + (y_offset + fh / 2.0).to_string(), - (fx).to_string() + "," + (y_offset + fh / 2.0).to_string(), + fx.to_string() + "," + (y_offset - fh / 2.0).to_string(), + (fx + fw - arrow_size).to_string() + + "," + + (y_offset - fh / 2.0).to_string(), + (fx + fw).to_string() + "," + y_offset.to_string(), + (fx + fw - arrow_size).to_string() + + "," + + (y_offset + fh / 2.0).to_string(), + fx.to_string() + "," + (y_offset + fh / 2.0).to_string(), ] let points_str = poly_points.join(" ") - let feat_elem = chr_svg_elem("polygon", chr_svg_attrs([ - ("points", points_str), - ("fill", feat_color), - ("stroke", "#333333"), - ("stroke-width", "0.5"), - ("opacity", "0.8"), - ]), "", []) + let feat_elem = chr_svg_elem( + "polygon", + chr_svg_attrs([ + ("points", points_str), + ("fill", feat_color), + ("stroke", "#333333"), + ("stroke-width", "0.5"), + ("opacity", "0.8"), + ]), + "", + [], + ) elements.push(feat_elem) } else if feat.orientation == Reverse { // Arrow pointing left let poly_points = [ (fx + fw).to_string() + "," + (y_offset - fh / 2.0).to_string(), (fx + arrow_size).to_string() + "," + (y_offset - fh / 2.0).to_string(), - (fx).to_string() + "," + (y_offset).to_string(), + fx.to_string() + "," + y_offset.to_string(), (fx + arrow_size).to_string() + "," + (y_offset + fh / 2.0).to_string(), (fx + fw).to_string() + "," + (y_offset + fh / 2.0).to_string(), ] let points_str = poly_points.join(" ") - let feat_elem = chr_svg_elem("polygon", chr_svg_attrs([ - ("points", points_str), - ("fill", feat_color), - ("stroke", "#333333"), - ("stroke-width", "0.5"), - ("opacity", "0.8"), - ]), "", []) + let feat_elem = chr_svg_elem( + "polygon", + chr_svg_attrs([ + ("points", points_str), + ("fill", feat_color), + ("stroke", "#333333"), + ("stroke-width", "0.5"), + ("opacity", "0.8"), + ]), + "", + [], + ) elements.push(feat_elem) } else { // No orientation - rectangle - let feat_elem = chr_svg_elem("rect", chr_svg_attrs([ - ("x", fx.to_string()), - ("y", (y_offset - fh / 2.0).to_string()), - ("width", fw.to_string()), - ("height", fh.to_string()), - ("fill", feat_color), - ("stroke", "#333333"), - ("stroke-width", "0.5"), - ("opacity", "0.8"), - ]), "", []) + let feat_elem = chr_svg_elem( + "rect", + chr_svg_attrs([ + ("x", fx.to_string()), + ("y", (y_offset - fh / 2.0).to_string()), + ("width", fw.to_string()), + ("height", fh.to_string()), + ("fill", feat_color), + ("stroke", "#333333"), + ("stroke-width", "0.5"), + ("opacity", "0.8"), + ]), + "", + [], + ) elements.push(feat_elem) } @@ -553,13 +623,18 @@ pub fn chr_chromosome_to_svg( if layout.show_labels && feat.label.length() > 0 { let label_x = fx + fw / 2.0 let label_y = y_offset - thickness / 2.0 - 4.0 - let text_elem = chr_svg_elem("text", chr_svg_attrs([ - ("x", label_x.to_string()), - ("y", label_y.to_string()), - ("font-size", layout.label_font_size.to_string()), - ("text-anchor", "middle"), - ("fill", "#333333"), - ]), feat.label, []) + let text_elem = chr_svg_elem( + "text", + chr_svg_attrs([ + ("x", label_x.to_string()), + ("y", label_y.to_string()), + ("font-size", layout.label_font_size.to_string()), + ("text-anchor", "middle"), + ("fill", "#333333"), + ]), + feat.label, + [], + ) elements.push(text_elem) } } @@ -568,30 +643,40 @@ pub fn chr_chromosome_to_svg( for region in chr.regions { let rx = x_offset + region.start * scale let rw = (region.end - region.start) * scale - let region_elem = chr_svg_elem("rect", chr_svg_attrs([ - ("x", rx.to_string()), - ("y", (y_offset - thickness / 2.0 - 15.0).to_string()), - ("width", rw.to_string()), - ("height", (thickness + 30.0 + 15.0).to_string()), - ("fill", region.color), - ("opacity", region.opacity.to_string()), - ("stroke", region.color), - ("stroke-width", "2"), - ("rx", "2"), - ("ry", "2"), - ]), "", []) + let region_elem = chr_svg_elem( + "rect", + chr_svg_attrs([ + ("x", rx.to_string()), + ("y", (y_offset - thickness / 2.0 - 15.0).to_string()), + ("width", rw.to_string()), + ("height", (thickness + 30.0 + 15.0).to_string()), + ("fill", region.color), + ("opacity", region.opacity.to_string()), + ("stroke", region.color), + ("stroke-width", "2"), + ("rx", "2"), + ("ry", "2"), + ]), + "", + [], + ) elements.push(region_elem) if layout.show_labels && region.label.length() > 0 { let label_x = rx + rw / 2.0 let label_y = y_offset - thickness / 2.0 - 8.0 - let text_elem = chr_svg_elem("text", chr_svg_attrs([ - ("x", label_x.to_string()), - ("y", label_y.to_string()), - ("font-size", (layout.label_font_size - 2.0).to_string()), - ("text-anchor", "middle"), - ("fill", "#666666"), - ]), region.label, []) + let text_elem = chr_svg_elem( + "text", + chr_svg_attrs([ + ("x", label_x.to_string()), + ("y", label_y.to_string()), + ("font-size", (layout.label_font_size - 2.0).to_string()), + ("text-anchor", "middle"), + ("fill", "#666666"), + ]), + region.label, + [], + ) elements.push(text_elem) } } @@ -599,14 +684,19 @@ pub fn chr_chromosome_to_svg( // Chromosome name label let name_x = x_offset - 10.0 let name_y = y_offset + 4.0 - let name_elem = chr_svg_elem("text", chr_svg_attrs([ - ("x", name_x.to_string()), - ("y", name_y.to_string()), - ("font-size", (layout.label_font_size + 2.0).to_string()), - ("text-anchor", "end"), - ("font-weight", "bold"), - ("fill", "#333333"), - ]), chr.name, []) + let name_elem = chr_svg_elem( + "text", + chr_svg_attrs([ + ("x", name_x.to_string()), + ("y", name_y.to_string()), + ("font-size", (layout.label_font_size + 2.0).to_string()), + ("text-anchor", "end"), + ("font-weight", "bold"), + ("fill", "#333333"), + ]), + chr.name, + [], + ) elements.push(name_elem) elements @@ -627,20 +717,25 @@ pub fn chr_circular_chromosome_to_svg( // Chromosome circle let _circumference = chr.length * scale let r = radius - let chr_circle = chr_svg_elem("circle", chr_svg_attrs([ - ("cx", cx.to_string()), - ("cy", cy.to_string()), - ("r", r.to_string()), - ("fill", "none"), - ("stroke", "#E0E0E0"), - ("stroke-width", (layout.chromosome_thickness).to_string()), - ]), "", []) + let chr_circle = chr_svg_elem( + "circle", + chr_svg_attrs([ + ("cx", cx.to_string()), + ("cy", cy.to_string()), + ("r", r.to_string()), + ("fill", "none"), + ("stroke", "#E0E0E0"), + ("stroke-width", layout.chromosome_thickness.to_string()), + ]), + "", + [], + ) elements.push(chr_circle) // Features as arcs for feat in chr.features { - let start_angle = (feat.start / chr.length) * 2.0 * chr_pi() - let end_angle = (feat.end / chr.length) * 2.0 * chr_pi() + let start_angle = feat.start / chr.length * 2.0 * chr_pi() + let end_angle = feat.end / chr.length * 2.0 * chr_pi() let x1 = cx + r * @math.cos(start_angle) let y1 = cy + r * @math.sin(start_angle) @@ -650,45 +745,75 @@ pub fn chr_circular_chromosome_to_svg( let large_arc = if end_angle - start_angle > chr_pi() { 1 } else { 0 } let sweep = 1 - let d = "M " + x1.to_string() + " " + y1.to_string() + - " A " + r.to_string() + " " + r.to_string() + - " 0 " + large_arc.to_string() + " " + sweep.to_string() + - " " + x2.to_string() + " " + y2.to_string() - - let arc_elem = chr_svg_elem("path", chr_svg_attrs([ - ("d", d), - ("fill", "none"), - ("stroke", feat.color), - ("stroke-width", (layout.chromosome_thickness * feat.height).to_string()), - ("opacity", "0.8"), - ]), "", []) + let d = "M " + + x1.to_string() + + " " + + y1.to_string() + + " A " + + r.to_string() + + " " + + r.to_string() + + " 0 " + + large_arc.to_string() + + " " + + sweep.to_string() + + " " + + x2.to_string() + + " " + + y2.to_string() + + let arc_elem = chr_svg_elem( + "path", + chr_svg_attrs([ + ("d", d), + ("fill", "none"), + ("stroke", feat.color), + ( + "stroke-width", + (layout.chromosome_thickness * feat.height).to_string(), + ), + ("opacity", "0.8"), + ]), + "", + [], + ) elements.push(arc_elem) } // Centromere if chr.centromere_pos > 0.0 { - let cen_angle = (chr.centromere_pos / chr.length) * 2.0 * chr_pi() + let cen_angle = chr.centromere_pos / chr.length * 2.0 * chr_pi() let cen_x = cx + r * @math.cos(cen_angle) let cen_y = cy + r * @math.sin(cen_angle) - let cen_elem = chr_svg_elem("circle", chr_svg_attrs([ - ("cx", cen_x.to_string()), - ("cy", cen_y.to_string()), - ("r", (layout.chromosome_thickness / 2.0 + 3.0).to_string()), - ("fill", "#CC0000"), - ]), "", []) + let cen_elem = chr_svg_elem( + "circle", + chr_svg_attrs([ + ("cx", cen_x.to_string()), + ("cy", cen_y.to_string()), + ("r", (layout.chromosome_thickness / 2.0 + 3.0).to_string()), + ("fill", "#CC0000"), + ]), + "", + [], + ) elements.push(cen_elem) } // Chromosome name at center if layout.show_labels { - let name_elem = chr_svg_elem("text", chr_svg_attrs([ - ("x", cx.to_string()), - ("y", cy.to_string()), - ("font-size", (layout.label_font_size + 4.0).to_string()), - ("text-anchor", "middle"), - ("font-weight", "bold"), - ("fill", "#333333"), - ]), chr.name, []) + let name_elem = chr_svg_elem( + "text", + chr_svg_attrs([ + ("x", cx.to_string()), + ("y", cy.to_string()), + ("font-size", (layout.label_font_size + 4.0).to_string()), + ("text-anchor", "middle"), + ("font-weight", "bold"), + ("fill", "#333333"), + ]), + chr.name, + [], + ) elements.push(name_elem) } @@ -708,7 +833,9 @@ pub fn ChrSVGElement::to_svg(self : ChrSVGElement) -> String { } let mut result = "<" + self.element_type + attrs - if self.element_type == "text" || self.element_type == "title" || self.element_type == "desc" { + if self.element_type == "text" || + self.element_type == "title" || + self.element_type == "desc" { result = result + ">" + self.content + "" } else if self.children.length() > 0 { result = result + ">" @@ -734,23 +861,35 @@ pub fn ChrDiagram::to_svg(self : ChrDiagram) -> String { let scale = if max_length > 0.0 { available_width / max_length } else { 1.0 } // Calculate spacing - let total_height_needed = n_chr.to_double() * (layout.chromosome_thickness + 80.0) - let available_height = layout.height - layout.margin_top - layout.margin_bottom - let y_spacing = if n_chr > 0 { available_height / (n_chr + 1).to_double() } else { 50.0 } + let total_height_needed = n_chr.to_double() * + (layout.chromosome_thickness + 80.0) + let available_height = layout.height - + layout.margin_top - + layout.margin_bottom + let y_spacing = if n_chr > 0 { + available_height / (n_chr + 1).to_double() + } else { + 50.0 + } // Build SVG elements let svg_children : Array[ChrSVGElement] = [] // Title if self.title.length() > 0 { - let title_elem = chr_svg_elem("text", chr_svg_attrs([ - ("x", (layout.width / 2.0).to_string()), - ("y", (25.0).to_string()), - ("font-size", "18"), - ("text-anchor", "middle"), - ("font-weight", "bold"), - ("fill", "#333333"), - ]), self.title, []) + let title_elem = chr_svg_elem( + "text", + chr_svg_attrs([ + ("x", (layout.width / 2.0).to_string()), + ("y", 25.0.to_string()), + ("font-size", "18"), + ("text-anchor", "middle"), + ("font-weight", "bold"), + ("fill", "#333333"), + ]), + self.title, + [], + ) svg_children.push(title_elem) } @@ -765,12 +904,16 @@ pub fn ChrDiagram::to_svg(self : ChrDiagram) -> String { let radius = layout.chromosome_thickness * 8.0 let cx = x_offset + radius + 20.0 let cy = y_offset - let chr_elements = chr_circular_chromosome_to_svg(chr, layout, cx, cy, radius, scale) + let chr_elements = chr_circular_chromosome_to_svg( + chr, layout, cx, cy, radius, scale, + ) for elem in chr_elements { svg_children.push(elem) } } else { - let chr_elements = chr_chromosome_to_svg(chr, layout, x_offset, y_offset, scale) + let chr_elements = chr_chromosome_to_svg( + chr, layout, x_offset, y_offset, scale, + ) for elem in chr_elements { svg_children.push(elem) } @@ -780,10 +923,14 @@ pub fn ChrDiagram::to_svg(self : ChrDiagram) -> String { // SVG root element let svg_open = "" + layout.width.to_string() + + "\" height=\"" + + layout.height.to_string() + + "\" viewBox=\"0 0 " + + layout.width.to_string() + + " " + + layout.height.to_string() + + "\">" let mut svg_content = "" for child in svg_children { @@ -823,25 +970,106 @@ pub fn chr_create_human_karyotype() -> ChrDiagram { let chromosomes : Array[Chromosome] = [] // Add a sample chromosome 1 - let chr1 = Chromosome::new(name="chr1", length=248956422.0, centromere_pos=121535434.0) - let chr1 = chr1.add_feature(ChrFeature::new(name="BRCA2", start=32300000.0, end=32400268.0, orientation=Forward, feature_type=ChrFeatureType::Gene, color="#FF6B6B", label="BRCA2")) - let chr1 = chr1.add_feature(ChrFeature::new(name="DMD", start=31100000.0, end=33300000.0, orientation=Forward, feature_type=ChrFeatureType::Gene, color="#4ECDC4", label="DMD")) - let chr1 = chr1.add_region(ChrRegion::new(name="BRCA1 region", start=43000000.0, end=43200000.0, color="#FFE66D", opacity=0.3, label="BRCA1 locus")) + let chr1 = Chromosome::new( + name="chr1", + length=248956422.0, + centromere_pos=121535434.0, + ) + let chr1 = chr1.add_feature( + ChrFeature::new( + name="BRCA2", + start=32300000.0, + end=32400268.0, + orientation=Forward, + feature_type=ChrFeatureType::Gene, + color="#FF6B6B", + label="BRCA2", + ), + ) + let chr1 = chr1.add_feature( + ChrFeature::new( + name="DMD", + start=31100000.0, + end=33300000.0, + orientation=Forward, + feature_type=ChrFeatureType::Gene, + color="#4ECDC4", + label="DMD", + ), + ) + let chr1 = chr1.add_region( + ChrRegion::new( + name="BRCA1 region", + start=43000000.0, + end=43200000.0, + color="#FFE66D", + opacity=0.3, + label="BRCA1 locus", + ), + ) chromosomes.push(chr1) // Add chromosome 7 - let chr7 = Chromosome::new(name="chr7", length=159345973.0, centromere_pos=54495348.0) - let chr7 = chr7.add_feature(ChrFeature::new(name="EGFR", start=55086714.0, end=55275019.0, orientation=Forward, feature_type=ChrFeatureType::Gene, color="#95E1D3", label="EGFR")) - let chr7 = chr7.add_feature(ChrFeature::new(name="CFTR", start=117287160.0, end=117595905.0, orientation=Reverse, feature_type=ChrFeatureType::Gene, color="#F38181", label="CFTR")) + let chr7 = Chromosome::new( + name="chr7", + length=159345973.0, + centromere_pos=54495348.0, + ) + let chr7 = chr7.add_feature( + ChrFeature::new( + name="EGFR", + start=55086714.0, + end=55275019.0, + orientation=Forward, + feature_type=ChrFeatureType::Gene, + color="#95E1D3", + label="EGFR", + ), + ) + let chr7 = chr7.add_feature( + ChrFeature::new( + name="CFTR", + start=117287160.0, + end=117595905.0, + orientation=Reverse, + feature_type=ChrFeatureType::Gene, + color="#F38181", + label="CFTR", + ), + ) chromosomes.push(chr7) // Add chromosome 11 - let chr11 = Chromosome::new(name="chr11", length=135086622.0, centromere_pos=51000000.0) - let chr11 = chr11.add_feature(ChrFeature::new(name="INS", start=2159000.0, end=2164000.0, orientation=Forward, feature_type=ChrFeatureType::Gene, color="#AA96DA", label="INS")) - let chr11 = chr11.add_feature(ChrFeature::new(name="MYCN", start=1590000.0, end=1595000.0, orientation=Forward, feature_type=ChrFeatureType::Gene, color="#FCBAD3", label="MYCN")) + let chr11 = Chromosome::new( + name="chr11", + length=135086622.0, + centromere_pos=51000000.0, + ) + let chr11 = chr11.add_feature( + ChrFeature::new( + name="INS", + start=2159000.0, + end=2164000.0, + orientation=Forward, + feature_type=ChrFeatureType::Gene, + color="#AA96DA", + label="INS", + ), + ) + let chr11 = chr11.add_feature( + ChrFeature::new( + name="MYCN", + start=1590000.0, + end=1595000.0, + orientation=Forward, + feature_type=ChrFeatureType::Gene, + color="#FCBAD3", + label="MYCN", + ), + ) chromosomes.push(chr11) - ChrDiagram::new(chromosomes=chromosomes, layout=layout, title="Human Chromosome Map") + ChrDiagram::new(chromosomes~, layout~, title="Human Chromosome Map") } ///| @@ -854,14 +1082,72 @@ pub fn chr_create_bacterial_chromosome() -> ChrDiagram { show_labels=true, ) - let ecoli = Chromosome::new(name="E. coli K-12", length=4600000.0, centromere_pos=2300000.0, is_circular=true) - let ecoli = ecoli.add_feature(ChrFeature::new(name="rrl", start=404000.0, end=405000.0, orientation=Forward, feature_type=ChrFeatureType::Gene, color="#FF6B6B", label="rrl")) - let ecoli = ecoli.add_feature(ChrFeature::new(name="rpoB", start=430000.0, end=435000.0, orientation=Forward, feature_type=ChrFeatureType::Gene, color="#4ECDC4", label="rpoB")) - let ecoli = ecoli.add_feature(ChrFeature::new(name="lacZ", start=3600000.0, end=3603000.0, orientation=Forward, feature_type=ChrFeatureType::Gene, color="#95E1D3", label="lacZ")) - let ecoli = ecoli.add_feature(ChrFeature::new(name="trpA", start=4000000.0, end=4001000.0, orientation=Reverse, feature_type=ChrFeatureType::Gene, color="#F38181", label="trpA")) - let ecoli = ecoli.add_region(ChrRegion::new(name="Pathogenicity Island", start=1000000.0, end=1200000.0, color="#FFE66D", opacity=0.2, label="PAI-1")) + let ecoli = Chromosome::new( + name="E. coli K-12", + length=4600000.0, + centromere_pos=2300000.0, + is_circular=true, + ) + let ecoli = ecoli.add_feature( + ChrFeature::new( + name="rrl", + start=404000.0, + end=405000.0, + orientation=Forward, + feature_type=ChrFeatureType::Gene, + color="#FF6B6B", + label="rrl", + ), + ) + let ecoli = ecoli.add_feature( + ChrFeature::new( + name="rpoB", + start=430000.0, + end=435000.0, + orientation=Forward, + feature_type=ChrFeatureType::Gene, + color="#4ECDC4", + label="rpoB", + ), + ) + let ecoli = ecoli.add_feature( + ChrFeature::new( + name="lacZ", + start=3600000.0, + end=3603000.0, + orientation=Forward, + feature_type=ChrFeatureType::Gene, + color="#95E1D3", + label="lacZ", + ), + ) + let ecoli = ecoli.add_feature( + ChrFeature::new( + name="trpA", + start=4000000.0, + end=4001000.0, + orientation=Reverse, + feature_type=ChrFeatureType::Gene, + color="#F38181", + label="trpA", + ), + ) + let ecoli = ecoli.add_region( + ChrRegion::new( + name="Pathogenicity Island", + start=1000000.0, + end=1200000.0, + color="#FFE66D", + opacity=0.2, + label="PAI-1", + ), + ) - ChrDiagram::new(chromosomes=[ecoli], layout=layout, title="E. coli K-12 Circular Chromosome") + ChrDiagram::new( + chromosomes=[ecoli], + layout~, + title="E. coli K-12 Circular Chromosome", + ) } // ============================================================================ @@ -899,9 +1185,18 @@ pub fn ChrDiagram::features_by_type(self : ChrDiagram) -> Map[String, Int] { /// Get chromosome summary as string. pub fn ChrDiagram::summary(self : ChrDiagram) -> String { let mut result = "Chromosome Diagram: " + self.title + "\n" - result = result + "Chromosomes: " + self.chromosomes.length().to_string() + "\n" - result = result + "Total features: " + self.total_features().to_string() + "\n" - result = result + "Max length: " + chr_max_length(self.chromosomes).to_string() + " bp\n" + result = result + + "Chromosomes: " + + self.chromosomes.length().to_string() + + "\n" + result = result + + "Total features: " + + self.total_features().to_string() + + "\n" + result = result + + "Max length: " + + chr_max_length(self.chromosomes).to_string() + + " bp\n" result } diff --git a/src/cibersort.mbt b/src/cibersort.mbt index 1ed2f3cb..f9245461 100644 --- a/src/cibersort.mbt +++ b/src/cibersort.mbt @@ -35,10 +35,10 @@ pub struct CibMixtureMatrix { /// Deconvolution result for a single sample. pub struct CibResult { sample_id : String - fractions : Array[Double] // cell type fractions (sum ≈ 1.0) + fractions : Array[Double] // cell type fractions (sum ≈ 1.0) cell_types : Array[String] - pearson_r : Double // correlation between fitted and observed - rmse : Double // root mean squared error + pearson_r : Double // correlation between fitted and observed + rmse : Double // root mean squared error } ///| @@ -65,19 +65,25 @@ pub fn CibSignatureMatrix::new( ///| /// Get gene names. -pub fn CibSignatureMatrix::gene_names(self : CibSignatureMatrix) -> Array[String] { +pub fn CibSignatureMatrix::gene_names( + self : CibSignatureMatrix, +) -> Array[String] { self.gene_names } ///| /// Get cell type names. -pub fn CibSignatureMatrix::cell_types(self : CibSignatureMatrix) -> Array[String] { +pub fn CibSignatureMatrix::cell_types( + self : CibSignatureMatrix, +) -> Array[String] { self.cell_types } ///| /// Get the raw matrix (rows=genes, cols=cell_types). -pub fn CibSignatureMatrix::matrix(self : CibSignatureMatrix) -> Array[Array[Double]] { +pub fn CibSignatureMatrix::matrix( + self : CibSignatureMatrix, +) -> Array[Array[Double]] { self.matrix } @@ -105,7 +111,9 @@ pub fn CibMixtureMatrix::gene_names(self : CibMixtureMatrix) -> Array[String] { ///| /// Get the raw matrix (rows=genes, cols=samples). -pub fn CibMixtureMatrix::matrix(self : CibMixtureMatrix) -> Array[Array[Double]] { +pub fn CibMixtureMatrix::matrix( + self : CibMixtureMatrix, +) -> Array[Array[Double]] { self.matrix } @@ -165,9 +173,13 @@ pub fn CibDeconvolution::sample_names(self : CibDeconvolution) -> Array[String] /// Compute the mean of an array. fn cib_mean(arr : Array[Double]) -> Double { let n = arr.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut s = 0.0 - for v in arr { s = s + v } + for v in arr { + s = s + v + } s / n.to_double() } @@ -175,7 +187,9 @@ fn cib_mean(arr : Array[Double]) -> Double { /// Compute Pearson correlation between two arrays. fn cib_pearson(a : Array[Double], b : Array[Double]) -> Double { let n = a.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let ma = cib_mean(a) let mb = cib_mean(b) let mut cov = 0.0 @@ -189,14 +203,20 @@ fn cib_pearson(a : Array[Double], b : Array[Double]) -> Double { vb = vb + db * db } let denom = (va * vb).sqrt() - if denom < 1.0e-15 { 0.0 } else { cov / denom } + if denom < 1.0e-15 { + 0.0 + } else { + cov / denom + } } ///| /// Compute RMSE between observed and fitted. fn cib_rmse(observed : Array[Double], fitted : Array[Double]) -> Double { let n = observed.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut sse = 0.0 for i in 0.. Array[Double] { let m = b.length() let n = if a.length() > 0 { a[0].length() } else { 0 } - if m == 0 || n == 0 { return [] } + if m == 0 || n == 0 { + return [] + } // Initialize x = 0 let x : Array[Double] = [] - for _j in 0.. max_diag { max_diag = ata[j][j] } + if ata[j][j] > max_diag { + max_diag = ata[j][j] + } } let lr = 1.0 / max_diag // Update and project @@ -272,10 +302,14 @@ fn cib_nnls( let new_x = x[j] - lr * grad[j] let projected = if new_x < 0.0 { 0.0 } else { new_x } let change = (projected - x[j]).abs() - if change > max_change { max_change = change } + if change > max_change { + max_change = change + } x[j] = projected } - if max_change < tol { converged = true } + if max_change < tol { + converged = true + } iter = iter + 1 } x @@ -345,12 +379,18 @@ pub fn cib_run( let x = cib_nnls(a, b, max_iters, tol) // Normalize to sum to 1.0 let mut sum_x = 0.0 - for v in x { sum_x = sum_x + v } + for v in x { + sum_x = sum_x + v + } let fractions : Array[Double] = [] if sum_x > 1.0e-15 { - for v in x { fractions.push(v / sum_x) } + for v in x { + fractions.push(v / sum_x) + } } else { - for _v in x { fractions.push(0.0) } + for _v in x { + fractions.push(0.0) + } } // Compute fitted values: fitted = A * x let fitted : Array[Double] = [] @@ -383,9 +423,8 @@ pub fn cib_run( /// signature. pub fn cib_cell_type_names() -> Array[String] { [ - "B cells", "T cells CD8", "T cells CD4", "NK cells", "Monocytes", - "Macrophages M1", "Macrophages M2", "Dendritic cells", "Neutrophils", - "Mast cells", + "B cells", "T cells CD8", "T cells CD4", "NK cells", "Monocytes", "Macrophages M1", + "Macrophages M2", "Dendritic cells", "Neutrophils", "Mast cells", ] } @@ -394,15 +433,15 @@ pub fn cib_cell_type_names() -> Array[String] { pub fn cib_marker_genes() -> Array[String] { [ "CD19", "MS4A1", "CD79A", "CD79B", // B cells - "CD8A", "CD8B", "GZMK", "GZMA", // T cells CD8 - "CD4", "IL7R", "LEF1", "TCF7", // T cells CD4 - "NKG7", "GNLY", "KLRD1", "NCAM1", // NK cells - "CD14", "LYZ", "S100A8", "S100A9", // Monocytes - "NOS2", "IL1B", "TNF", "CXCL9", // Macrophages M1 - "CD163", "MRC1", "ARG1", "IL10", // Macrophages M2 - "ITGAX", "CD1C", "CLEC10A", "FCER1A", // Dendritic cells - "FCGR3A", "CSF3R", "FPR1", "CEACAM3", // Neutrophils - "TPSAB1", "CPA3", "MS4A2", "KIT", // Mast cells + "CD8A", "CD8B", "GZMK", "GZMA", // T cells CD8 + "CD4", "IL7R", "LEF1", "TCF7", // T cells CD4 + "NKG7", "GNLY", "KLRD1", "NCAM1", // NK cells + "CD14", "LYZ", "S100A8", "S100A9", // Monocytes + "NOS2", "IL1B", "TNF", "CXCL9", // Macrophages M1 + "CD163", "MRC1", "ARG1", "IL10", // Macrophages M2 + "ITGAX", "CD1C", "CLEC10A", "FCER1A", // Dendritic cells + "FCGR3A", "CSF3R", "FPR1", "CEACAM3", // Neutrophils + "TPSAB1", "CPA3", "MS4A2", "KIT", // Mast cells ] } @@ -508,7 +547,9 @@ pub fn cib_sample_mixture() -> CibMixtureMatrix { /// Get the fraction of a specific cell type in a result. pub fn CibResult::get_fraction(self : CibResult, cell_type : String) -> Double { for i in 0.. String { for f in r.fractions { result = result + "\t" + f.to_string() } - result = result + "\t" + r.pearson_r.to_string() + "\t" + r.rmse.to_string() + "\n" + result = result + + "\t" + + r.pearson_r.to_string() + + "\t" + + r.rmse.to_string() + + "\n" } result } diff --git a/src/circ_seq.mbt b/src/circ_seq.mbt index bf4dd0cb..9bb80f91 100644 --- a/src/circ_seq.mbt +++ b/src/circ_seq.mbt @@ -36,6 +36,7 @@ pub fn CircSeq::with_name(sequence~ : String, name~ : String) -> CircSeq { CircSeq::{ sequence, length, gc_content: gc, name } } +///| fn compute_gc_content(seq : String) -> Double { let n = seq.length() if n == 0 { @@ -129,9 +130,15 @@ pub fn CircSeq::circ_rotate(self : CircSeq, new_origin : Int) -> CircSeq { return self } // New sequence: seq[wrapped:] + seq[:wrapped] - let new_seq = self.sequence.substring(start=wrapped) + self.sequence.substring(start=0, end=wrapped) + let new_seq = self.sequence.substring(start=wrapped) + + self.sequence.substring(start=0, end=wrapped) let gc = compute_gc_content(new_seq) - CircSeq::{ sequence: new_seq, length: self.length, gc_content: gc, name: self.name } + CircSeq::{ + sequence: new_seq, + length: self.length, + gc_content: gc, + name: self.name, + } } ///| @@ -139,32 +146,38 @@ pub fn CircSeq::circ_rotate(self : CircSeq, new_origin : Int) -> CircSeq { pub fn CircSeq::circ_reverse_complement(self : CircSeq) -> CircSeq { let rc = circ_rev_comp(self.sequence) let gc = compute_gc_content(rc) - CircSeq::{ sequence: rc, length: self.length, gc_content: gc, name: self.name } + CircSeq::{ + sequence: rc, + length: self.length, + gc_content: gc, + name: self.name, + } } +///| fn circ_rev_comp(seq : String) -> String { let mut result = "" let mut i = seq.length() - 1 while i >= 0 { let c = char_to_upper(seq.unsafe_get(i)) let comp : UInt16 = match c { - 65 => 84 // 'A' => 'T' - 84 => 65 // 'T' => 'A' - 71 => 67 // 'G' => 'C' - 67 => 71 // 'C' => 'G' - 85 => 65 // 'U' => 'A' - 78 => 78 // 'N' => 'N' - 82 => 89 // 'R' => 'Y' - 89 => 82 // 'Y' => 'R' - 83 => 83 // 'S' => 'S' - 87 => 87 // 'W' => 'W' - 75 => 77 // 'K' => 'M' - 77 => 75 // 'M' => 'K' - 66 => 86 // 'B' => 'V' - 86 => 66 // 'V' => 'B' - 68 => 72 // 'D' => 'H' - 72 => 68 // 'H' => 'D' - _ => 78 // 'N' default + 65 => 84 // 'A' => 'T' + 84 => 65 // 'T' => 'A' + 71 => 67 // 'G' => 'C' + 67 => 71 // 'C' => 'G' + 85 => 65 // 'U' => 'A' + 78 => 78 // 'N' => 'N' + 82 => 89 // 'R' => 'Y' + 89 => 82 // 'Y' => 'R' + 83 => 83 // 'S' => 'S' + 87 => 87 // 'W' => 'W' + 75 => 77 // 'K' => 'M' + 77 => 75 // 'M' => 'K' + 66 => 86 // 'B' => 'V' + 86 => 66 // 'V' => 'B' + 68 => 72 // 'D' => 'H' + 72 => 68 // 'H' => 'D' + _ => 78 // 'N' default } result = result + u16_to_str(comp) i = i - 1 @@ -184,7 +197,7 @@ pub fn CircSeq::circ_find_all(self : CircSeq, pattern : String) -> Array[Int] { // Search the doubled sequence to handle circular wrapping let doubled = self.sequence + self.sequence - let search_len = self.length // Only search up to the original length to avoid duplicates + let search_len = self.length // Only search up to the original length to avoid duplicates let mut i = 0 while i <= search_len - plen { @@ -236,7 +249,10 @@ pub fn CircSeq::circ_has_site(self : CircSeq, site : String) -> Bool { ///| /// Find all restriction enzyme cut sites on both strands. /// Returns an array of (position, strand) tuples. -pub fn CircSeq::circ_find_sites(self : CircSeq, site : String) -> Array[(Int, String)] { +pub fn CircSeq::circ_find_sites( + self : CircSeq, + site : String, +) -> Array[(Int, String)] { let results : Array[(Int, String)] = Array::new() let fwd = self.circ_find_all(site) for pos in fwd { @@ -252,7 +268,10 @@ pub fn CircSeq::circ_find_sites(self : CircSeq, site : String) -> Array[(Int, St ///| /// Simulate a restriction digest on the circular sequence. /// Returns an array of fragment sizes (in bp). -pub fn CircSeq::circ_digest(self : CircSeq, sites : Array[String]) -> Array[Int] { +pub fn CircSeq::circ_digest( + self : CircSeq, + sites : Array[String], +) -> Array[Int] { let cut_positions : Array[Int] = Array::new() // Collect all cut positions from both strands for all enzymes @@ -308,7 +327,10 @@ pub fn CircSeq::circ_digest(self : CircSeq, sites : Array[String]) -> Array[Int] ///| /// Calculate fragment sizes from a circular digest using specific enzymes. -pub fn CircSeq::circ_digest_enzymes(self : CircSeq, enzymes : Array[String]) -> Array[Int] { +pub fn CircSeq::circ_digest_enzymes( + self : CircSeq, + enzymes : Array[String], +) -> Array[Int] { self.circ_digest(enzymes) } @@ -343,19 +365,30 @@ pub fn CircSeq::circ_design_primers( (fwd_start, rev_start, product_len) } +///| fn calc_gc(seq : String) -> Double { - if seq.length() == 0 { return 0.0 } + if seq.length() == 0 { + return 0.0 + } let mut gc = 0 let mut i = 0 while i < seq.length() { let c = char_to_upper(seq.unsafe_get(i)) - if c == 71 || c == 67 { gc = gc + 1 } + if c == 71 || c == 67 { + gc = gc + 1 + } i = i + 1 } gc.to_double() / seq.length().to_double() } -fn adjust_primer_length(circ : CircSeq, start : Int, target_len : Int, gc_target : Double) -> Int { +///| +fn adjust_primer_length( + circ : CircSeq, + start : Int, + target_len : Int, + gc_target : Double, +) -> Int { let mut len = target_len let max_len = if circ.length < 40 { circ.length } else { 40 } while len < max_len { @@ -371,12 +404,23 @@ fn adjust_primer_length(circ : CircSeq, start : Int, target_len : Int, gc_target ///| /// Insert a sequence at a specific position in the circular sequence. -pub fn CircSeq::circ_insert(self : CircSeq, pos : Int, insert_seq : String) -> CircSeq { +pub fn CircSeq::circ_insert( + self : CircSeq, + pos : Int, + insert_seq : String, +) -> CircSeq { let wrapped = modulo_pos(pos, self.length) - let new_seq = self.sequence.substring(start=0, end=wrapped) + insert_seq + self.sequence.substring(start=wrapped) + let new_seq = self.sequence.substring(start=0, end=wrapped) + + insert_seq + + self.sequence.substring(start=wrapped) let new_length = new_seq.length() let gc = compute_gc_content(new_seq) - CircSeq::{ sequence: new_seq, length: new_length, gc_content: gc, name: self.name } + CircSeq::{ + sequence: new_seq, + length: new_length, + gc_content: gc, + name: self.name, + } } ///| @@ -385,16 +429,23 @@ pub fn CircSeq::circ_delete(self : CircSeq, start : Int, end : Int) -> CircSeq { let new_seq = circular_delete(self.sequence, start, end) let new_length = new_seq.length() let gc = compute_gc_content(new_seq) - CircSeq::{ sequence: new_seq, length: new_length, gc_content: gc, name: self.name } + CircSeq::{ + sequence: new_seq, + length: new_length, + gc_content: gc, + name: self.name, + } } +///| fn circular_delete(seq : String, start : Int, end : Int) -> String { let wrapped_start = modulo_pos(start, seq.length()) let wrapped_end = modulo_pos(end, seq.length()) if wrapped_start <= wrapped_end { // Linear delete - return seq.substring(start=0, end=wrapped_start) + seq.substring(start=wrapped_end + 1) + return seq.substring(start=0, end=wrapped_start) + + seq.substring(start=wrapped_end + 1) } else { // Wraps around: delete from wrapped_start to end, and from start to wrapped_end return seq.substring(start=wrapped_end + 1, end=wrapped_start) @@ -428,7 +479,12 @@ pub fn linear_to_circular(linear_pos : Int, length : Int) -> Int { ///| /// Check if a position is within a range on the circular sequence. -pub fn is_within_circular_range(pos : Int, range_start : Int, range_end : Int, length : Int) -> Bool { +pub fn is_within_circular_range( + pos : Int, + range_start : Int, + range_end : Int, + length : Int, +) -> Bool { let p = modulo_pos(pos, length) let rs = modulo_pos(range_start, length) let re = modulo_pos(range_end, length) @@ -445,7 +501,13 @@ pub fn is_within_circular_range(pos : Int, range_start : Int, range_end : Int, l ///| /// Compute the overlap between two ranges on the circular sequence. /// Returns the number of overlapping bases. -pub fn circular_overlap(start1 : Int, end1 : Int, start2 : Int, end2 : Int, length : Int) -> Int { +pub fn circular_overlap( + start1 : Int, + end1 : Int, + start2 : Int, + end2 : Int, + length : Int, +) -> Int { let s1 = modulo_pos(start1, length) let e1 = modulo_pos(end1, length) let s2 = modulo_pos(start2, length) @@ -465,6 +527,7 @@ pub fn circular_overlap(start1 : Int, end1 : Int, start2 : Int, end2 : Int, leng count } +///| fn expand_range(start : Int, end : Int, length : Int) -> Array[Int] { let result : Array[Int] = Array::new() if start <= end { @@ -491,6 +554,7 @@ fn expand_range(start : Int, end : Int, length : Int) -> Array[Int] { // --- Utility Functions --- +///| fn modulo_pos(pos : Int, length : Int) -> Int { if length <= 0 { return 0 @@ -503,6 +567,7 @@ fn modulo_pos(pos : Int, length : Int) -> Int { } } +///| fn sort_positions(positions : Array[Int]) -> Array[Int] { let result = positions.copy() let n = result.length() @@ -524,7 +589,11 @@ fn sort_positions(positions : Array[Int]) -> Array[Int] { ///| /// Generate a random circular sequence of given length and GC content. -pub fn circ_random_sequence(length : Int, gc_content : Double, seed? : Int = 42) -> CircSeq { +pub fn circ_random_sequence( + length : Int, + gc_content : Double, + seed? : Int = 42, +) -> CircSeq { let bases = ["A", "T", "G", "C"] // Adjust probabilities based on GC content let at_prob = (1.0 - gc_content) / 2.0 @@ -546,8 +615,14 @@ pub fn circ_random_sequence(length : Int, gc_content : Double, seed? : Int = 42) CircSeq::new(sequence=seq) } +///| fn pick_base(rand_val : Double, probs : Array[Double]) -> Int { - let cumulative = [probs[0], probs[0] + probs[1], probs[0] + probs[1] + probs[2], 1.0] + let cumulative = [ + probs[0], + probs[0] + probs[1], + probs[0] + probs[1] + probs[2], + 1.0, + ] if rand_val <= cumulative[0] { return 0 } else if rand_val <= cumulative[1] { @@ -562,14 +637,23 @@ fn pick_base(rand_val : Double, probs : Array[Double]) -> Int { ///| /// Simulate a ligation reaction on two circular sequences. /// Returns the concatenated circular product. -pub fn circ_ligate(linear_fragment : String, vector : CircSeq, insert_pos : Int) -> CircSeq { +pub fn circ_ligate( + linear_fragment : String, + vector : CircSeq, + insert_pos : Int, +) -> CircSeq { vector.circ_insert(insert_pos, linear_fragment) } ///| /// Compute Tm (melting temperature) for a primer on a circular template. /// Uses the nearest-neighbor method approximation. -pub fn circ_tm(template : CircSeq, start : Int, len : Int, oligo_conc? : Double = 5.0e-8) -> Double { +pub fn circ_tm( + template : CircSeq, + start : Int, + len : Int, + oligo_conc? : Double = 5.0e-8, +) -> Double { let seq = template.circ_slice(start, len) let gc = calc_gc(seq) let at = 1.0 - gc @@ -611,7 +695,7 @@ pub fn circ_common_restriction_sites() -> Array[(String, String)] { ("ScaI", "AGTACT"), ("SmaI", "CCCGGG"), ("StuI", "AGGCCT"), - ("XmaI", "CCCGGG") + ("XmaI", "CCCGGG"), ] } diff --git a/src/cluster_experiment.mbt b/src/cluster_experiment.mbt index 54c6154d..67ae0c48 100644 --- a/src/cluster_experiment.mbt +++ b/src/cluster_experiment.mbt @@ -505,7 +505,10 @@ fn ce_kmeans_single( ///| /// k-means++ seeding using a deterministic pseudo-random pick based on indices /// (the project avoids real RNG; this gives reproducible spreads). -fn ce_kmeans_pp_init(data : Array[Array[Double]], k : Int) -> Array[Array[Double]] { +fn ce_kmeans_pp_init( + data : Array[Array[Double]], + k : Int, +) -> Array[Array[Double]] { let n = data.length() let centroids : Array[Array[Double]] = Array::new() // pick the point closest to the global centroid as first seed @@ -582,14 +585,19 @@ pub fn ce_cluster_many( copy } let subset = ce_subsample(work, ss) - let (labels_full, _) = ce_kmeans(subset.data, k, params.n_init, params.max_iter) + let (labels_full, _) = ce_kmeans( + subset.data, + k, + params.n_init, + params.max_iter, + ) // map subsample labels back to full data let labels = Array::make(data.length(), -1) for idx in 0.. 0 && counts[j] > 0 { - let denom = (if counts[i] < counts[j] { - counts[i] - } else { - counts[j] - }).to_double() + let denom = (if counts[i] < counts[j] { counts[i] } else { counts[j] }).to_double() if denom > 0.0 { m[i][j] = m[i][j] / denom } @@ -844,7 +848,9 @@ pub fn ce_make_dendrogram( let nodes : Array[CeDendroNode] = Array::new() for i in 0.. merge_cutoff if merged { // union the two clusters @@ -979,12 +988,12 @@ pub fn ce_merge_clusters( } info.push( CeMergeInfo::new( - node_id=node_id, - left_cluster=left_cluster, - right_cluster=right_cluster, + node_id~, + left_cluster~, + right_cluster~, proportion=prop, q_value=qval, - merged=merged, + merged~, ), ) node_id = node_id + 1 @@ -1153,10 +1162,11 @@ pub fn ce_normal_cdf(z : Double) -> Double { let t = 1.0 / (1.0 + 0.2316419 * x) let d = 0.3989423 * @math.exp(-x * x / 2.0) let p = t * - (0.319381530 + + ( + 0.319381530 + t * - (-0.356563782 + - t * (1.781477937 + t * (-1.821255978 + t * 1.330274429)))) + (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))) + ) 1.0 - d * p } @@ -1230,13 +1240,13 @@ pub fn ce_sequential_cluster( let ids : Array[Int] = Array::new() for l in labels { let mut found = false - for id in ids { - if id == l { - found = true - break - } + for id in ids { + if id == l { + found = true + break } - if !found && l >= 0 { + } + if !found && l >= 0 { ids.push(l) } } @@ -1425,11 +1435,11 @@ pub fn ce_rsec( } ClusterExperiment::new( labels=final_labels, - cocluster=cocluster, - dendro=dendro, + cocluster~, + dendro~, n_clusters=ids.length(), merge_cutoff=params.merge_cutoff, - merge_info=merge_info, + merge_info~, ) } diff --git a/src/cnvkit.mbt b/src/cnvkit.mbt index c91e8673..724e3725 100644 --- a/src/cnvkit.mbt +++ b/src/cnvkit.mbt @@ -63,16 +63,9 @@ pub fn CNVProbe::new( start : Int, end : Int, log2_ratio : Double, - weight : Double + weight : Double, ) -> CNVProbe { - CNVProbe::{ - probe_id, - chromosome, - start, - end, - log2_ratio, - weight - } + CNVProbe::{ probe_id, chromosome, start, end, log2_ratio, weight } } ///| @@ -82,16 +75,9 @@ pub fn CNVSegment::new( end : Int, probes : Int, mean_log2 : Double, - state : String + state : String, ) -> CNVSegment { - CNVSegment::{ - chromosome, - start, - end, - probes, - mean_log2, - state - } + CNVSegment::{ chromosome, start, end, probes, mean_log2, state } } ///| @@ -99,7 +85,7 @@ pub fn CNVDataset::new() -> CNVDataset { CNVDataset::{ probes: Array::new(), segments: Array::new(), - chromosomes: Array::new() + chromosomes: Array::new(), } } @@ -107,16 +93,16 @@ pub fn CNVDataset::new() -> CNVDataset { pub fn CNVDataset::add_probe(self : CNVDataset, probe : CNVProbe) -> CNVDataset { let new_probes = self.probes new_probes.push(probe) - + let new_chroms = self.chromosomes if !cnvkit_contains_string(new_chroms, probe.chromosome) { new_chroms.push(probe.chromosome) } - + CNVDataset::{ probes: new_probes, segments: self.segments, - chromosomes: new_chroms + chromosomes: new_chroms, } } @@ -131,7 +117,10 @@ pub fn CNVDataset::count_segments(self : CNVDataset) -> Int { } ///| -pub fn CNVDataset::filter_chromosome(self : CNVDataset, chrom : String) -> CNVDataset { +pub fn CNVDataset::filter_chromosome( + self : CNVDataset, + chrom : String, +) -> CNVDataset { let filtered : Array[CNVProbe] = Array::new() let mut i = 0 while i < self.probes.length() { @@ -140,7 +129,7 @@ pub fn CNVDataset::filter_chromosome(self : CNVDataset, chrom : String) -> CNVDa } i = i + 1 } - + let segments : Array[CNVSegment] = Array::new() let mut j = 0 while j < self.segments.length() { @@ -149,12 +138,8 @@ pub fn CNVDataset::filter_chromosome(self : CNVDataset, chrom : String) -> CNVDa } j = j + 1 } - - CNVDataset::{ - probes: filtered, - segments, - chromosomes: [chrom] - } + + CNVDataset::{ probes: filtered, segments, chromosomes: [chrom] } } ///| @@ -164,10 +149,10 @@ pub fn cbs_segment(probes : Array[CNVProbe], alpha : Double) -> CBSResult { return CBSResult::{ segments: Array::new(), breakpoints: Array::new(), - n_segments: 0 + n_segments: 0, } } - + // Extract log2 ratios let log2ratios : Array[Double] = Array::new() let mut i = 0 @@ -175,47 +160,43 @@ pub fn cbs_segment(probes : Array[CNVProbe], alpha : Double) -> CBSResult { log2ratios.push(probes[i].log2_ratio) i = i + 1 } - + // Perform CBS segmentation let breakpoints = cbs_find_breakpoints(log2ratios, alpha) - + // Create segments from breakpoints let segments = cbs_create_segments(probes, breakpoints) - - CBSResult::{ - segments, - breakpoints, - n_segments: segments.length() - } + + CBSResult::{ segments, breakpoints, n_segments: segments.length() } } ///| fn cbs_find_breakpoints(data : Array[Double], alpha : Double) -> Array[Int] { let n = data.length() let breakpoints : Array[Int] = Array::new() - + if n == 0 { return breakpoints } - + if n < 3 { breakpoints.push(0) breakpoints.push(n) return breakpoints } - + // Find change points using t-statistic let mut i = 1 while i < n - 1 { let t_stat = cbs_calculate_t_statistic(data, i) let p_value = cbs_approximate_p_value(t_stat, n) - + if p_value < alpha { breakpoints.push(i) } i = i + 1 } - + // Ensure breakpoints include start and end if breakpoints.length() > 0 { if breakpoints[0] != 0 { @@ -228,7 +209,7 @@ fn cbs_find_breakpoints(data : Array[Double], alpha : Double) -> Array[Int] { breakpoints.push(0) breakpoints.push(n) } - + breakpoints } @@ -237,11 +218,11 @@ fn cbs_calculate_t_statistic(data : Array[Double], breakpoint : Int) -> Double { let n = data.length() let n_left = breakpoint let n_right = n - breakpoint - + if n_left < 1 || n_right < 1 { return 0.0 } - + // Calculate means let mut sum_left = 0.0 let mut i = 0 @@ -250,7 +231,7 @@ fn cbs_calculate_t_statistic(data : Array[Double], breakpoint : Int) -> Double { i = i + 1 } let mean_left = sum_left / n_left.to_double() - + let mut sum_right = 0.0 let mut j = n_left while j < n { @@ -258,7 +239,7 @@ fn cbs_calculate_t_statistic(data : Array[Double], breakpoint : Int) -> Double { j = j + 1 } let mean_right = sum_right / n_right.to_double() - + // Calculate variances let mut var_left = 0.0 i = 0 @@ -268,7 +249,7 @@ fn cbs_calculate_t_statistic(data : Array[Double], breakpoint : Int) -> Double { i = i + 1 } var_left = var_left / n_left.to_double() - + let mut var_right = 0.0 j = n_left while j < n { @@ -277,11 +258,13 @@ fn cbs_calculate_t_statistic(data : Array[Double], breakpoint : Int) -> Double { j = j + 1 } var_right = var_right / n_right.to_double() - - let pooled_var = (n_left.to_double() * var_left + n_right.to_double() * var_right) / + + let pooled_var = ( + n_left.to_double() * var_left + n_right.to_double() * var_right + ) / (n_left.to_double() + n_right.to_double()) let se = (pooled_var * (1.0 / n_left.to_double() + 1.0 / n_right.to_double())).sqrt() - + if se == 0.0 { 0.0 } else { @@ -294,7 +277,7 @@ fn cbs_approximate_p_value(t : Double, n : Int) -> Double { // Approximate p-value using normal distribution let abs_t = if t >= 0.0 { t } else { -t } let df = n.to_double() - 2.0 - + // Simple approximation let x = abs_t / (1.0 + abs_t / (2.0 * df)) 2.0 * (1.0 - cbs_normal_cdf(x)) @@ -306,7 +289,12 @@ fn cbs_normal_cdf(x : Double) -> Double { let abs_x = if x >= 0.0 { x } else { -x } let t = 1.0 / (1.0 + 0.2316419 * abs_x) let d = 0.3989422804014327 * @math.exp(-abs_x * abs_x / 2.0) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))) + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))) + ) if x >= 0.0 { 1.0 - p } else { @@ -315,19 +303,22 @@ fn cbs_normal_cdf(x : Double) -> Double { } ///| -fn cbs_create_segments(probes : Array[CNVProbe], breakpoints : Array[Int]) -> Array[CNVSegment] { +fn cbs_create_segments( + probes : Array[CNVProbe], + breakpoints : Array[Int], +) -> Array[CNVSegment] { let segments : Array[CNVSegment] = Array::new() let n = breakpoints.length() - + if n < 2 { return segments } - + let mut i = 0 while i < n - 1 { let start_idx = breakpoints[i] let end_idx = breakpoints[i + 1] - + if start_idx < end_idx && start_idx < probes.length() { let chrom = probes[start_idx].chromosome let start_pos = probes[start_idx].start @@ -337,7 +328,7 @@ fn cbs_create_segments(probes : Array[CNVProbe], breakpoints : Array[Int]) -> Ar probes[probes.length() - 1].end } let count = end_idx - start_idx - + // Calculate mean log2 ratio let mut sum = 0.0 let mut j = start_idx @@ -346,22 +337,17 @@ fn cbs_create_segments(probes : Array[CNVProbe], breakpoints : Array[Int]) -> Ar j = j + 1 } let mean_log2 = if count > 0 { sum / count.to_double() } else { 0.0 } - + // Determine state let state = cbs_call_state(mean_log2) - - segments.push(CNVSegment::new( - chrom, - start_pos, - end_pos, - count, - mean_log2, - state - )) + + segments.push( + CNVSegment::new(chrom, start_pos, end_pos, count, mean_log2, state), + ) } i = i + 1 } - + segments } @@ -377,15 +363,18 @@ pub fn cbs_call_state(mean_log2 : Double) -> String { } ///| -pub fn smooth_log2_ratios(probes : Array[CNVProbe], window_size : Int) -> Array[CNVProbe] { +pub fn smooth_log2_ratios( + probes : Array[CNVProbe], + window_size : Int, +) -> Array[CNVProbe] { let n = probes.length() let smoothed : Array[CNVProbe] = Array::new() - + let mut i = 0 while i < n { let start = if i - window_size / 2 >= 0 { i - window_size / 2 } else { 0 } let end = if i + window_size / 2 < n { i + window_size / 2 } else { n - 1 } - + let mut sum = 0.0 let mut count = 0 let mut j = start @@ -394,68 +383,71 @@ pub fn smooth_log2_ratios(probes : Array[CNVProbe], window_size : Int) -> Array[ count = count + 1 j = j + 1 } - - let smoothed_ratio = if count > 0 { sum / count.to_double() } else { probes[i].log2_ratio } - - smoothed.push(CNVProbe::{ - ..probes[i], - log2_ratio: smoothed_ratio - }) + + let smoothed_ratio = if count > 0 { + sum / count.to_double() + } else { + probes[i].log2_ratio + } + + smoothed.push(CNVProbe::{ ..probes[i], log2_ratio: smoothed_ratio }) i = i + 1 } - + smoothed } ///| -pub fn detect_breakpoints(segments : Array[CNVSegment], threshold : Double) -> Array[(Int, String)] { +pub fn detect_breakpoints( + segments : Array[CNVSegment], + threshold : Double, +) -> Array[(Int, String)] { let breakpoints : Array[(Int, String)] = Array::new() let n = segments.length() - + if n < 2 { return breakpoints } - + let mut i = 1 while i < n { let prev = segments[i - 1] let curr = segments[i] - + // Check for state change if prev.state != curr.state { breakpoints.push((curr.start, curr.state)) } - + // Check for significant mean change let mean_diff = (prev.mean_log2 - curr.mean_log2).abs() if mean_diff > threshold { breakpoints.push((curr.start, "change")) } - + i = i + 1 } - + breakpoints } ///| -pub fn call_copy_numbers(segments : Array[CNVSegment], ploidy : Int) -> Array[CopyNumberCall] { +pub fn call_copy_numbers( + segments : Array[CNVSegment], + ploidy : Int, +) -> Array[CopyNumberCall] { let calls : Array[CopyNumberCall] = Array::new() - + let mut i = 0 while i < segments.length() { let segment = segments[i] let copy_number = cbs_log2_to_copynumber(segment.mean_log2, ploidy) let state = cbs_call_state(segment.mean_log2) - - calls.push(CopyNumberCall::{ - segment, - copy_number, - state - }) + + calls.push(CopyNumberCall::{ segment, copy_number, state }) i = i + 1 } - + calls } @@ -470,17 +462,17 @@ fn cbs_log2_to_copynumber(log2_ratio : Double, ploidy : Int) -> Double { pub fn summarize_cnv(dataset : CNVDataset) -> CNVSummary { let total_probes = dataset.count_probes() let total_segments = dataset.count_segments() - + let avg_segment_size = if total_segments > 0 { total_probes.to_double() / total_segments.to_double() } else { 0.0 } - + let mut deletion_count = 0 let mut amplification_count = 0 let mut neutral_count = 0 - + let segments = dataset.segments let mut i = 0 while i < segments.length() { @@ -491,49 +483,57 @@ pub fn summarize_cnv(dataset : CNVDataset) -> CNVSummary { } i = i + 1 } - + CNVSummary::{ total_probes, total_segments, avg_segment_size, deletion_count, amplification_count, - neutral_count + neutral_count, } } ///| pub fn create_example_cnv_dataset() -> CNVDataset { let mut dataset = CNVDataset::new() - + // Create a dataset with 100 probes showing a copy number change let mut i = 0 while i < 100 { let chrom = if i < 50 { "chr1" } else { "chr2" } - let start = if chrom == "chr1" { 1000000 + i * 10000 } else { 2000000 + (i - 50) * 10000 } - + let start = if chrom == "chr1" { + 1000000 + i * 10000 + } else { + 2000000 + (i - 50) * 10000 + } + // Create a deletion in the middle of chr1 let log2_ratio = if chrom == "chr1" && i >= 20 && i < 35 { -0.8 } else if chrom == "chr1" && i >= 50 && i < 65 { 0.8 + } else if i % 3 == 0 { + 0.05 + } else if i % 3 == 1 { + -0.03 } else { - if i % 3 == 0 { 0.05 } else if i % 3 == 1 { -0.03 } else { 0.02 } + 0.02 } - + let probe = CNVProbe::new( "probe_" + i.to_string(), chrom, start, start + 1000, log2_ratio, - 1.0 + 1.0, ) - + dataset = dataset.add_probe(probe) i = i + 1 } - + dataset } @@ -543,16 +543,26 @@ pub fn cbs_summarize_dataset(dataset : CNVDataset) -> String { let mut result = "\nCNV Dataset Summary\n" result = result + "==============================\n" result = result + "Total probes: " + summary.total_probes.to_string() + "\n" - result = result + "Total segments: " + summary.total_segments.to_string() + "\n" - result = result + "Avg segment size: " + summary.avg_segment_size.to_string() + "\n" + result = result + + "Total segments: " + + summary.total_segments.to_string() + + "\n" + result = result + + "Avg segment size: " + + summary.avg_segment_size.to_string() + + "\n" result = result + "Deletions: " + summary.deletion_count.to_string() + "\n" - result = result + "Amplifications: " + summary.amplification_count.to_string() + "\n" + result = result + + "Amplifications: " + + summary.amplification_count.to_string() + + "\n" result = result + "Neutral: " + summary.neutral_count.to_string() + "\n" result } // Helper functions +///| fn cnvkit_contains_string(arr : Array[String], value : String) -> Bool { let mut i = 0 while i < arr.length() { diff --git a/src/codon_advanced.mbt b/src/codon_advanced.mbt index 1bc885a3..6d906326 100644 --- a/src/codon_advanced.mbt +++ b/src/codon_advanced.mbt @@ -169,9 +169,7 @@ pub struct CodonUsageTable { ///| /// Create a new CodonUsageTable from raw counts. -pub fn CodonUsageTable::new( - codon_counts : Map[String, Int], -) -> CodonUsageTable { +pub fn CodonUsageTable::new(codon_counts : Map[String, Int]) -> CodonUsageTable { let frequencies = compute_frequencies(codon_counts.copy()) let mut total = 0 let keys = codon_counts.keys().collect() @@ -215,7 +213,9 @@ pub fn CodonUsageTable::counts(usage : CodonUsageTable) -> Map[String, Int] { ///| /// Get all codon frequencies as a Map. -pub fn CodonUsageTable::frequencies(usage : CodonUsageTable) -> Map[String, Double] { +pub fn CodonUsageTable::frequencies( + usage : CodonUsageTable, +) -> Map[String, Double] { usage.frequencies.copy() } @@ -428,10 +428,7 @@ pub fn compute_codon_adaptiveness( /// CAI = exp( (1/L) * sum(ln(w_i)) ) for each codon, /// where w_i is the relative adaptiveness of codon i. /// Returns a value between 0 and 1, where 1 indicates optimal codon usage. -pub fn calculate_cai( - seq : String, - reference_table : CodonUsageTable, -) -> Double { +pub fn calculate_cai(seq : String, reference_table : CodonUsageTable) -> Double { let seq_upper = seq.to_upper() let len = seq_upper.length() let adaptiveness = compute_codon_adaptiveness(reference_table) @@ -641,7 +638,13 @@ pub fn calculate_enc(usage : CodonUsageTable) -> Double { enc = enc + 3.0 * (f6_contrib / f6_count.to_double()) } - if enc > 61.0 { 61.0 } else if enc < 20.0 { 20.0 } else { enc } + if enc > 61.0 { + 61.0 + } else if enc < 20.0 { + 20.0 + } else { + enc + } } ///| @@ -673,7 +676,11 @@ pub fn calculate_gc3(seq : String) -> Double { ///| /// Calculate a composite bias score (0-1 scale). /// Higher values indicate stronger codon usage bias. -fn calculate_bias_score(enc : Double, gc3 : Double, optimal_frac : Double) -> Double { +fn calculate_bias_score( + enc : Double, + gc3 : Double, + optimal_frac : Double, +) -> Double { let enc_score = (61.0 - enc) / 41.0 let gc3_score = if gc3 > 0.5 { gc3 } else { 1.0 - gc3 } let opt_score = optimal_frac @@ -701,9 +708,7 @@ fn count_stop_codons(seq : String) -> Int { /// Identify optimal codons for each amino acid. /// Returns an array of (amino_acid, codon) tuples where the codon /// has the highest frequency for that amino acid. -pub fn optimal_codons( - usage : CodonUsageTable, -) -> Array[(String, String)] { +pub fn optimal_codons(usage : CodonUsageTable) -> Array[(String, String)] { let result = Array::make(0, ("", "")) let aa_list = aa_to_codons.keys().collect() @@ -846,13 +851,7 @@ pub fn codon_bias_analysis(seq : String) -> CodonBiasResult { let bias_score = calculate_bias_score(enc_val, gc3_val, optimal_frac) CodonBiasResult::new( - enc_val, - cai_val, - gc3_val, - bias_score, - optimal_frac, - rare_frac, - non_stop_total, + enc_val, cai_val, gc3_val, bias_score, optimal_frac, rare_frac, non_stop_total, ) } @@ -862,36 +861,17 @@ pub fn codon_bias_analysis(seq : String) -> CodonBiasResult { pub fn get_high_gc_reference() -> Map[String, Double] { let ref_table = Map([], capacity=64) let gc_codons = [ - "GCA", "GCC", "GCG", "GCT", - "CGA", "CGC", "CGG", "CGT", - "GAC", "GAT", "GAA", "GAG", - "GGA", "GGC", "GGG", "GGT", - "CAC", "CAT", "CAA", "CAG", - "ATA", "ATC", "ATT", "ATG", - "CTA", "CTC", "CTG", "CTT", - "AAA", "AAG", "TTA", "TTG", - "TTC", "TTT", "CCA", "CCC", - "CCG", "CCT", "AGC", "AGT", - "TCA", "TCC", "TCG", "TCT", - "ACA", "ACC", "ACG", "ACT", - "GTA", "GTC", "GTG", "GTT", - "TGC", "TGT", "TGG", + "GCA", "GCC", "GCG", "GCT", "CGA", "CGC", "CGG", "CGT", "GAC", "GAT", "GAA", + "GAG", "GGA", "GGC", "GGG", "GGT", "CAC", "CAT", "CAA", "CAG", "ATA", "ATC", + "ATT", "ATG", "CTA", "CTC", "CTG", "CTT", "AAA", "AAG", "TTA", "TTG", "TTC", + "TTT", "CCA", "CCC", "CCG", "CCT", "AGC", "AGT", "TCA", "TCC", "TCG", "TCT", + "ACA", "ACC", "ACG", "ACT", "GTA", "GTC", "GTG", "GTT", "TGC", "TGT", "TGG", ] let gc_bias = [ - 0.7, 1.0, 0.9, 0.6, - 0.8, 1.0, 0.9, 0.6, - 0.8, 0.5, 0.9, 1.0, - 0.6, 1.0, 0.8, 0.5, - 0.8, 0.5, 0.7, 1.0, - 0.4, 0.8, 0.5, 1.0, - 0.6, 0.9, 1.0, 0.5, - 0.5, 1.0, 0.4, 0.3, - 0.5, 0.3, 0.7, 1.0, - 0.9, 0.6, 0.8, 0.5, - 0.4, 0.8, 1.0, 0.6, - 0.7, 1.0, 0.9, 0.5, - 0.5, 0.9, 1.0, 0.6, - 0.5, 0.6, 1.0, + 0.7, 1.0, 0.9, 0.6, 0.8, 1.0, 0.9, 0.6, 0.8, 0.5, 0.9, 1.0, 0.6, 1.0, 0.8, 0.5, + 0.8, 0.5, 0.7, 1.0, 0.4, 0.8, 0.5, 1.0, 0.6, 0.9, 1.0, 0.5, 0.5, 1.0, 0.4, 0.3, + 0.5, 0.3, 0.7, 1.0, 0.9, 0.6, 0.8, 0.5, 0.4, 0.8, 1.0, 0.6, 0.7, 1.0, 0.9, 0.5, + 0.5, 0.9, 1.0, 0.6, 0.5, 0.6, 1.0, ] let mut i = 0 while i < gc_codons.length() { @@ -907,36 +887,17 @@ pub fn get_high_gc_reference() -> Map[String, Double] { pub fn get_low_gc_reference() -> Map[String, Double] { let ref_table = Map([], capacity=64) let at_codons = [ - "GCT", "GCA", "GCC", "GCG", - "CGT", "CGA", "CGC", "CGG", - "GAT", "GAC", "GAA", "GAG", - "GTT", "GTA", "GTC", "GTG", - "CAT", "CAC", "CAA", "CAG", - "ATT", "ATA", "ATC", "ATG", - "CTT", "CTA", "CTC", "CTG", - "AAA", "AAG", "TTA", "TTG", - "TTT", "TTC", "CCT", "CCA", - "CCC", "CCG", "AGT", "AGC", - "TCT", "TCA", "TCC", "TCG", - "ACT", "ACA", "ACC", "ACG", - "GGT", "GGA", "GGC", "GGG", - "TGT", "TGC", "TGG", + "GCT", "GCA", "GCC", "GCG", "CGT", "CGA", "CGC", "CGG", "GAT", "GAC", "GAA", + "GAG", "GTT", "GTA", "GTC", "GTG", "CAT", "CAC", "CAA", "CAG", "ATT", "ATA", + "ATC", "ATG", "CTT", "CTA", "CTC", "CTG", "AAA", "AAG", "TTA", "TTG", "TTT", + "TTC", "CCT", "CCA", "CCC", "CCG", "AGT", "AGC", "TCT", "TCA", "TCC", "TCG", + "ACT", "ACA", "ACC", "ACG", "GGT", "GGA", "GGC", "GGG", "TGT", "TGC", "TGG", ] let at_bias = [ - 1.0, 0.5, 0.4, 0.3, - 1.0, 0.5, 0.4, 0.3, - 1.0, 0.5, 0.6, 0.5, - 1.0, 0.8, 0.5, 0.4, - 1.0, 0.4, 0.8, 0.6, - 1.0, 0.7, 0.4, 1.0, - 1.0, 0.8, 0.5, 0.4, - 1.0, 0.6, 0.9, 0.7, - 1.0, 0.6, 0.5, 0.3, - 1.0, 0.8, 0.7, 0.5, - 1.0, 0.8, 0.5, 0.4, - 1.0, 0.9, 0.6, 0.4, - 1.0, 0.9, 0.6, 0.4, - 1.0, 0.5, 1.0, + 1.0, 0.5, 0.4, 0.3, 1.0, 0.5, 0.4, 0.3, 1.0, 0.5, 0.6, 0.5, 1.0, 0.8, 0.5, 0.4, + 1.0, 0.4, 0.8, 0.6, 1.0, 0.7, 0.4, 1.0, 1.0, 0.8, 0.5, 0.4, 1.0, 0.6, 0.9, 0.7, + 1.0, 0.6, 0.5, 0.3, 1.0, 0.8, 0.7, 0.5, 1.0, 0.8, 0.5, 0.4, 1.0, 0.9, 0.6, 0.4, + 1.0, 0.9, 0.6, 0.4, 1.0, 0.5, 1.0, ] let mut i = 0 while i < at_codons.length() { @@ -977,10 +938,7 @@ pub fn get_reference_table(org : String) -> Map[String, Double] { ///| /// Calculate CAI using a named organism reference table. -pub fn calculate_cai_with_org( - seq : String, - org : String, -) -> Double { +pub fn calculate_cai_with_org(seq : String, org : String) -> Double { let seq_upper = seq.to_upper() let len = seq_upper.length() let ref_table = get_reference_table(org) @@ -1065,8 +1023,13 @@ pub fn codon_usage_to_string(usage : CodonUsageTable) -> String { let codon = codons[j] let count = CodonUsageTable::get_count(usage, codon) let freq = CodonUsageTable::get_frequency(usage, codon) - result = result + codon + "(" + count.to_string() + - "/" + freq.to_string() + ")" + result = result + + codon + + "(" + + count.to_string() + + "/" + + freq.to_string() + + ")" if j < codons.length() - 1 { result = result + ", " } @@ -1081,10 +1044,7 @@ pub fn codon_usage_to_string(usage : CodonUsageTable) -> String { ///| /// Count codons of a specific amino acid in a sequence. -pub fn count_amino_acid_codons( - seq : String, - aa : String, -) -> Int { +pub fn count_amino_acid_codons(seq : String, aa : String) -> Int { let seq_upper = seq.to_upper() let len = seq_upper.length() let codons = aa_to_codons.get(aa).unwrap_or([]) @@ -1183,4 +1143,4 @@ pub fn gc_second_fraction(seq : String) -> Double { } gc_count.to_double() / total.to_double() -} \ No newline at end of file +} diff --git a/src/compass.mbt b/src/compass.mbt index 36e82c3c..96721052 100644 --- a/src/compass.mbt +++ b/src/compass.mbt @@ -282,21 +282,9 @@ pub fn parse_compass(content : String) -> Array[CompassRecord] { if has_record { records.push( CompassRecord::new( - query_name, - template_name, - query_n_seqs, - template_n_seqs, - query_n_cols, - template_n_cols, - sw_score, - e_value, - percentage_identity, - query_start, - query_end, - template_start, - template_end, - aligned_query, - aligned_template, + query_name, template_name, query_n_seqs, template_n_seqs, query_n_cols, + template_n_cols, sw_score, e_value, percentage_identity, query_start, + query_end, template_start, template_end, aligned_query, aligned_template, consensus_line, ), ) @@ -323,29 +311,27 @@ pub fn parse_compass(content : String) -> Array[CompassRecord] { query_name = compass_extract_after(trimmed, "Query alignment:") } else if starts_with(trimmed, 0, "Template alignment:") { template_name = compass_extract_after(trimmed, "Template alignment:") - } else if starts_with( - trimmed, 0, "Number of sequences in query alignment:", - ) { + } else if starts_with(trimmed, 0, "Number of sequences in query alignment:") { query_n_seqs = parse_int( - compass_extract_after(trimmed, "Number of sequences in query alignment:"), + compass_extract_after( + trimmed, "Number of sequences in query alignment:", + ), ) } else if starts_with( - trimmed, 0, "Number of sequences in template alignment:", - ) { + trimmed, 0, "Number of sequences in template alignment:", + ) { template_n_seqs = parse_int( compass_extract_after( trimmed, "Number of sequences in template alignment:", ), ) - } else if starts_with( - trimmed, 0, "Number of columns in query alignment:", - ) { + } else if starts_with(trimmed, 0, "Number of columns in query alignment:") { query_n_cols = parse_int( compass_extract_after(trimmed, "Number of columns in query alignment:"), ) } else if starts_with( - trimmed, 0, "Number of columns in template alignment:", - ) { + trimmed, 0, "Number of columns in template alignment:", + ) { template_n_cols = parse_int( compass_extract_after( trimmed, "Number of columns in template alignment:", @@ -356,9 +342,9 @@ pub fn parse_compass(content : String) -> Array[CompassRecord] { compass_extract_after(trimmed, "Smith-Waterman score:"), ).unwrap_or(0.0) } else if starts_with(trimmed, 0, "E-value:") { - e_value = parse_double( - compass_extract_after(trimmed, "E-value:"), - ).unwrap_or(0.0) + e_value = parse_double(compass_extract_after(trimmed, "E-value:")).unwrap_or( + 0.0, + ) } else if starts_with(trimmed, 0, "Percentage identity:") { percentage_identity = parse_double( compass_extract_after(trimmed, "Percentage identity:"), @@ -383,22 +369,9 @@ pub fn parse_compass(content : String) -> Array[CompassRecord] { if has_record { records.push( CompassRecord::new( - query_name, - template_name, - query_n_seqs, - template_n_seqs, - query_n_cols, - template_n_cols, - sw_score, - e_value, - percentage_identity, - query_start, - query_end, - template_start, - template_end, - aligned_query, - aligned_template, - consensus_line, + query_name, template_name, query_n_seqs, template_n_seqs, query_n_cols, template_n_cols, + sw_score, e_value, percentage_identity, query_start, query_end, template_start, + template_end, aligned_query, aligned_template, consensus_line, ), ) } @@ -476,7 +449,8 @@ pub fn compass_summary(records : Array[CompassRecord]) -> String { s = s + " SW score: " + r.sw_score.to_string() + "\n" s = s + " E-value: " + r.e_value.to_string() + "\n" s = s + " Identity: " + r.percentage_identity.to_string() + "%\n" - s = s + " Alignment length: " + + s = s + + " Alignment length: " + compass_alignment_length(r).to_string() + "\n\n" } @@ -491,11 +465,13 @@ pub fn CompassRecord::to_string(self : CompassRecord) -> String { s = s + ", sw_score=" + self.sw_score.to_string() s = s + ", e_value=" + self.e_value.to_string() s = s + ", identity=" + self.percentage_identity.to_string() - s = s + ", query_range=" + + s = s + + ", query_range=" + self.query_start.to_string() + "-" + self.query_end.to_string() - s = s + ", template_range=" + + s = s + + ", template_range=" + self.template_start.to_string() + "-" + self.template_end.to_string() diff --git a/src/compound.mbt b/src/compound.mbt index 120d28dc..743e933b 100644 --- a/src/compound.mbt +++ b/src/compound.mbt @@ -83,7 +83,19 @@ pub fn Compound::get_formula(self : Compound) -> String { /// Set molecular formula. pub fn Compound::set_formula(self : Compound, formula : String) -> Compound { let c = self - Compound::{ id: c.id, name: c.name, formula, charge: c.charge, smiles: c.smiles, inchikey: c.inchikey, inchi: c.inchi, aliases: c.aliases, pathways: c.pathways, reactions: c.reactions, comment: c.comment } + Compound::{ + id: c.id, + name: c.name, + formula, + charge: c.charge, + smiles: c.smiles, + inchikey: c.inchikey, + inchi: c.inchi, + aliases: c.aliases, + pathways: c.pathways, + reactions: c.reactions, + comment: c.comment, + } } ///| @@ -96,7 +108,19 @@ pub fn Compound::get_charge(self : Compound) -> Int { /// Set charge. pub fn Compound::set_charge(self : Compound, charge : Int) -> Compound { let c = self - Compound::{ id: c.id, name: c.name, formula: c.formula, charge, smiles: c.smiles, inchikey: c.inchikey, inchi: c.inchi, aliases: c.aliases, pathways: c.pathways, reactions: c.reactions, comment: c.comment } + Compound::{ + id: c.id, + name: c.name, + formula: c.formula, + charge, + smiles: c.smiles, + inchikey: c.inchikey, + inchi: c.inchi, + aliases: c.aliases, + pathways: c.pathways, + reactions: c.reactions, + comment: c.comment, + } } ///| @@ -109,7 +133,19 @@ pub fn Compound::get_smiles(self : Compound) -> String { /// Set SMILES string. pub fn Compound::set_smiles(self : Compound, smiles : String) -> Compound { let c = self - Compound::{ id: c.id, name: c.name, formula: c.formula, charge: c.charge, smiles, inchikey: c.inchikey, inchi: c.inchi, aliases: c.aliases, pathways: c.pathways, reactions: c.reactions, comment: c.comment } + Compound::{ + id: c.id, + name: c.name, + formula: c.formula, + charge: c.charge, + smiles, + inchikey: c.inchikey, + inchi: c.inchi, + aliases: c.aliases, + pathways: c.pathways, + reactions: c.reactions, + comment: c.comment, + } } ///| @@ -124,7 +160,19 @@ pub fn Compound::add_alias(self : Compound, alias : String) -> Compound { let c = self let new_aliases = c.aliases.copy() new_aliases.push(alias) - Compound::{ id: c.id, name: c.name, formula: c.formula, charge: c.charge, smiles: c.smiles, inchikey: c.inchikey, inchi: c.inchi, aliases: new_aliases, pathways: c.pathways, reactions: c.reactions, comment: c.comment } + Compound::{ + id: c.id, + name: c.name, + formula: c.formula, + charge: c.charge, + smiles: c.smiles, + inchikey: c.inchikey, + inchi: c.inchi, + aliases: new_aliases, + pathways: c.pathways, + reactions: c.reactions, + comment: c.comment, + } } ///| @@ -153,7 +201,19 @@ pub fn Compound::add_pathway(self : Compound, pathway : String) -> Compound { let c = self let new_pathways = c.pathways.copy() new_pathways.push(pathway) - Compound::{ id: c.id, name: c.name, formula: c.formula, charge: c.charge, smiles: c.smiles, inchikey: c.inchikey, inchi: c.inchi, aliases: c.aliases, pathways: new_pathways, reactions: c.reactions, comment: c.comment } + Compound::{ + id: c.id, + name: c.name, + formula: c.formula, + charge: c.charge, + smiles: c.smiles, + inchikey: c.inchikey, + inchi: c.inchi, + aliases: c.aliases, + pathways: new_pathways, + reactions: c.reactions, + comment: c.comment, + } } ///| @@ -168,7 +228,19 @@ pub fn Compound::add_reaction(self : Compound, reaction : String) -> Compound { let c = self let new_reactions = c.reactions.copy() new_reactions.push(reaction) - Compound::{ id: c.id, name: c.name, formula: c.formula, charge: c.charge, smiles: c.smiles, inchikey: c.inchikey, inchi: c.inchi, aliases: c.aliases, pathways: c.pathways, reactions: new_reactions, comment: c.comment } + Compound::{ + id: c.id, + name: c.name, + formula: c.formula, + charge: c.charge, + smiles: c.smiles, + inchikey: c.inchikey, + inchi: c.inchi, + aliases: c.aliases, + pathways: c.pathways, + reactions: new_reactions, + comment: c.comment, + } } ///| @@ -190,7 +262,9 @@ pub fn Compound::to_string(self : Compound) -> String { result = result + ", aliases: [" let mut i = 0 while i < self.aliases.length() { - if i > 0 { result = result + ", " } + if i > 0 { + result = result + ", " + } result = result + "'\{self.aliases[i]}'" i = i + 1 } @@ -251,20 +325,21 @@ pub fn parse_formula(formula : String) -> Map[String, Int] { /// Get molecular formula as a string from parsed counts. pub fn formula_to_string(counts : Map[String, Int]) -> String { let mut result = "" - let elements = ["C", "H", "N", "O", "S", "P", "Fe", "Mg", "Ca", "K", "Na", "Cl", "Br", "I"] + let elements = [ + "C", "H", "N", "O", "S", "P", "Fe", "Mg", "Ca", "K", "Na", "Cl", "Br", "I", + ] let mut i = 0 while i < elements.length() { let el = elements[i] match counts.get(el) { - Some(n) => { + Some(n) => if n > 0 { result = result + el if n > 1 { result = result + n.to_string() } } - } None => () } i = i + 1 @@ -284,14 +359,13 @@ pub fn formula_to_string(counts : Map[String, Int]) -> String { } if !found { match counts.get(el) { - Some(n) => { + Some(n) => if n > 0 { result = result + el if n > 1 { result = result + n.to_string() } } - } None => () } } @@ -324,12 +398,11 @@ pub fn compound_molecular_weight(formula : String) -> Double { let mut total = 0.0 for el in counts.keys() { match counts.get(el) { - Some(count) => { + Some(count) => match weights.get(el) { Some(w) => total = total + w * count.to_double() None => () } - } None => () } } @@ -379,17 +452,31 @@ pub fn ChemicalReaction::get_name(self : ChemicalReaction) -> String { ///| /// Get substrates (reactants). -pub fn ChemicalReaction::get_substrates(self : ChemicalReaction) -> Array[String] { +pub fn ChemicalReaction::get_substrates( + self : ChemicalReaction, +) -> Array[String] { self.substrates } ///| /// Add a substrate. -pub fn ChemicalReaction::add_substrate(self : ChemicalReaction, substrate : String) -> ChemicalReaction { +pub fn ChemicalReaction::add_substrate( + self : ChemicalReaction, + substrate : String, +) -> ChemicalReaction { let r = self let new_subs = r.substrates.copy() new_subs.push(substrate) - ChemicalReaction::{ id: r.id, name: r.name, substrates: new_subs, products: r.products, enzymes: r.enzymes, direction: r.direction, pathway: r.pathway, comment: r.comment } + ChemicalReaction::{ + id: r.id, + name: r.name, + substrates: new_subs, + products: r.products, + enzymes: r.enzymes, + direction: r.direction, + pathway: r.pathway, + comment: r.comment, + } } ///| @@ -400,11 +487,23 @@ pub fn ChemicalReaction::get_products(self : ChemicalReaction) -> Array[String] ///| /// Add a product. -pub fn ChemicalReaction::add_product(self : ChemicalReaction, product : String) -> ChemicalReaction { +pub fn ChemicalReaction::add_product( + self : ChemicalReaction, + product : String, +) -> ChemicalReaction { let r = self let new_prods = r.products.copy() new_prods.push(product) - ChemicalReaction::{ id: r.id, name: r.name, substrates: r.substrates, products: new_prods, enzymes: r.enzymes, direction: r.direction, pathway: r.pathway, comment: r.comment } + ChemicalReaction::{ + id: r.id, + name: r.name, + substrates: r.substrates, + products: new_prods, + enzymes: r.enzymes, + direction: r.direction, + pathway: r.pathway, + comment: r.comment, + } } ///| @@ -415,11 +514,23 @@ pub fn ChemicalReaction::get_enzymes(self : ChemicalReaction) -> Array[String] { ///| /// Add an enzyme. -pub fn ChemicalReaction::add_enzyme(self : ChemicalReaction, enzyme : String) -> ChemicalReaction { +pub fn ChemicalReaction::add_enzyme( + self : ChemicalReaction, + enzyme : String, +) -> ChemicalReaction { let r = self let new_enzymes = r.enzymes.copy() new_enzymes.push(enzyme) - ChemicalReaction::{ id: r.id, name: r.name, substrates: r.substrates, products: r.products, enzymes: new_enzymes, direction: r.direction, pathway: r.pathway, comment: r.comment } + ChemicalReaction::{ + id: r.id, + name: r.name, + substrates: r.substrates, + products: r.products, + enzymes: new_enzymes, + direction: r.direction, + pathway: r.pathway, + comment: r.comment, + } } ///| @@ -430,9 +541,21 @@ pub fn ChemicalReaction::get_direction(self : ChemicalReaction) -> String { ///| /// Set reaction direction ("forward", "reverse", "reversible"). -pub fn ChemicalReaction::set_direction(self : ChemicalReaction, direction : String) -> ChemicalReaction { +pub fn ChemicalReaction::set_direction( + self : ChemicalReaction, + direction : String, +) -> ChemicalReaction { let r = self - ChemicalReaction::{ id: r.id, name: r.name, substrates: r.substrates, products: r.products, enzymes: r.enzymes, direction, pathway: r.pathway, comment: r.comment } + ChemicalReaction::{ + id: r.id, + name: r.name, + substrates: r.substrates, + products: r.products, + enzymes: r.enzymes, + direction, + pathway: r.pathway, + comment: r.comment, + } } ///| @@ -441,7 +564,9 @@ pub fn ChemicalReaction::get_equation(self : ChemicalReaction) -> String { let mut lhs = "" let mut i = 0 while i < self.substrates.length() { - if i > 0 { lhs = lhs + " + " } + if i > 0 { + lhs = lhs + " + " + } lhs = lhs + self.substrates[i] i = i + 1 } @@ -449,7 +574,9 @@ pub fn ChemicalReaction::get_equation(self : ChemicalReaction) -> String { let mut rhs = "" i = 0 while i < self.products.length() { - if i > 0 { rhs = rhs + " + " } + if i > 0 { + rhs = rhs + " + " + } rhs = rhs + self.products[i] i = i + 1 } @@ -472,7 +599,9 @@ pub fn ChemicalReaction::to_string(self : ChemicalReaction) -> String { result = result + " Enzymes: " let mut i = 0 while i < self.enzymes.length() { - if i > 0 { result = result + ", " } + if i > 0 { + result = result + ", " + } result = result + self.enzymes[i] i = i + 1 } @@ -508,37 +637,60 @@ pub fn CompoundPathwayMap::get_name(self : CompoundPathwayMap) -> String { ///| /// Add a compound to the pathway. -pub fn CompoundPathwayMap::add_compound(self : CompoundPathwayMap, compound : Compound) -> CompoundPathwayMap { +pub fn CompoundPathwayMap::add_compound( + self : CompoundPathwayMap, + compound : Compound, +) -> CompoundPathwayMap { let p = self let new_compounds = p.compounds.copy() new_compounds.push(compound) - CompoundPathwayMap::{ name: p.name, compounds: new_compounds, reactions: p.reactions, description: p.description } + CompoundPathwayMap::{ + name: p.name, + compounds: new_compounds, + reactions: p.reactions, + description: p.description, + } } ///| /// Add a reaction to the pathway. -pub fn CompoundPathwayMap::add_reaction(self : CompoundPathwayMap, reaction : ChemicalReaction) -> CompoundPathwayMap { +pub fn CompoundPathwayMap::add_reaction( + self : CompoundPathwayMap, + reaction : ChemicalReaction, +) -> CompoundPathwayMap { let p = self let new_reactions = p.reactions.copy() new_reactions.push(reaction) - CompoundPathwayMap::{ name: p.name, compounds: p.compounds, reactions: new_reactions, description: p.description } + CompoundPathwayMap::{ + name: p.name, + compounds: p.compounds, + reactions: new_reactions, + description: p.description, + } } ///| /// Get all compounds. -pub fn CompoundPathwayMap::get_compounds(self : CompoundPathwayMap) -> Array[Compound] { +pub fn CompoundPathwayMap::get_compounds( + self : CompoundPathwayMap, +) -> Array[Compound] { self.compounds } ///| /// Get all reactions. -pub fn CompoundPathwayMap::get_reactions(self : CompoundPathwayMap) -> Array[ChemicalReaction] { +pub fn CompoundPathwayMap::get_reactions( + self : CompoundPathwayMap, +) -> Array[ChemicalReaction] { self.reactions } ///| /// Find a compound by ID. -pub fn CompoundPathwayMap::find_compound(self : CompoundPathwayMap, id : String) -> Option[Compound] { +pub fn CompoundPathwayMap::find_compound( + self : CompoundPathwayMap, + id : String, +) -> Compound? { let mut i = 0 while i < self.compounds.length() { if self.compounds[i].id == id { @@ -551,7 +703,10 @@ pub fn CompoundPathwayMap::find_compound(self : CompoundPathwayMap, id : String) ///| /// Find a reaction by ID. -pub fn CompoundPathwayMap::find_reaction(self : CompoundPathwayMap, id : String) -> Option[ChemicalReaction] { +pub fn CompoundPathwayMap::find_reaction( + self : CompoundPathwayMap, + id : String, +) -> ChemicalReaction? { let mut i = 0 while i < self.reactions.length() { if self.reactions[i].id == id { @@ -586,7 +741,8 @@ pub fn CompoundPathwayMap::summary(self : CompoundPathwayMap) -> String { result = result + "\nReactions:\n" let mut i = 0 while i < self.reactions.length() { - result = result + " - \{self.reactions[i].id}: \{self.reactions[i].get_equation()}\n" + result = result + + " - \{self.reactions[i].id}: \{self.reactions[i].get_equation()}\n" i = i + 1 } } @@ -597,13 +753,17 @@ pub fn CompoundPathwayMap::summary(self : CompoundPathwayMap) -> String { ///| /// Create common known compound templates. pub fn compound_glucose() -> Compound { - Compound::with_chemical("C0003", "D-Glucose", "C6H12O6", 0, "C(C1C(C(C(C(O1)O)O)O)O)O") + Compound::with_chemical( + "C0003", "D-Glucose", "C6H12O6", 0, "C(C1C(C(C(C(O1)O)O)O)O)O", + ) } ///| /// Create fructose compound. pub fn compound_fructose() -> Compound { - Compound::with_chemical("C0005", "D-Fructose", "C6H12O6", 0, "C(=O)C1(C(C(C(O1)O)O)O)O") + Compound::with_chemical( + "C0005", "D-Fructose", "C6H12O6", 0, "C(=O)C1(C(C(C(O1)O)O)O)O", + ) } ///| @@ -621,5 +781,7 @@ pub fn compound_acetate() -> Compound { ///| /// Create citrate compound. pub fn compound_citrate() -> Compound { - Compound::with_chemical("C0015", "Citrate", "C6H5O7", -3, "OC(=O)C(CC(=O)[O-])(O)CC(=O)[O-]") + Compound::with_chemical( + "C0015", "Citrate", "C6H5O7", -3, "OC(=O)C(CC(=O)[O-])(O)CC(=O)[O-]", + ) } diff --git a/src/consensus_cluster_plus.mbt b/src/consensus_cluster_plus.mbt index b188d0d5..553ec08f 100644 --- a/src/consensus_cluster_plus.mbt +++ b/src/consensus_cluster_plus.mbt @@ -19,9 +19,15 @@ pub fn CCPResult::new( cluster_labels : Array[Int], k : Int, consensus_score : Double, - stability_scores : Array[Double] + stability_scores : Array[Double], ) -> CCPResult { - CCPResult::{ consensus_matrix, cluster_labels, k, consensus_score, stability_scores } + CCPResult::{ + consensus_matrix, + cluster_labels, + k, + consensus_score, + stability_scores, + } } ///| @@ -30,10 +36,10 @@ pub fn ccp_calculate_consensus_matrix( data : Array[Array[Double]], k : Int, n_iterations : Int, - sample_fraction : Double + sample_fraction : Double, ) -> Array[Array[Double]] { let n = data.length() - + let consensus : Array[Array[Double]] = Array::new() let mut i = 0 while i < n { @@ -46,7 +52,7 @@ pub fn ccp_calculate_consensus_matrix( consensus.push(row) i = i + 1 } - + let counts : Array[Array[Int]] = Array::new() let mut m = 0 while m < n { @@ -59,21 +65,21 @@ pub fn ccp_calculate_consensus_matrix( counts.push(row) m = m + 1 } - + let mut iter = 0 while iter < n_iterations { let sample_size = (n.to_double() * sample_fraction).to_int() let sample_indices = ccp_deterministic_sample(n, sample_size, iter) - + let sample_data : Array[Array[Double]] = Array::new() let mut idx = 0 while idx < sample_indices.length() { sample_data.push(data[sample_indices[idx]]) idx = idx + 1 } - + let labels = ccp_kmeans_cluster(sample_data, k) - + let mut a = 0 while a < sample_indices.length() { let mut b = 0 @@ -88,10 +94,10 @@ pub fn ccp_calculate_consensus_matrix( } a = a + 1 } - + iter = iter + 1 } - + let mut x = 0 while x < n { let mut y = 0 @@ -105,7 +111,7 @@ pub fn ccp_calculate_consensus_matrix( } x = x + 1 } - + consensus } @@ -118,7 +124,7 @@ pub fn ccp_deterministic_sample(n : Int, size : Int, seed : Int) -> Array[Int] { indices.push(i) i = i + 1 } - + let mut state = seed let mut j = n - 1 while j > 0 { @@ -130,14 +136,14 @@ pub fn ccp_deterministic_sample(n : Int, size : Int, seed : Int) -> Array[Int] { indices.set(idx, temp) j = j - 1 } - + let result : Array[Int] = Array::new() let mut m = 0 while m < size && m < n { result.push(indices[m]) m = m + 1 } - + result } @@ -146,31 +152,31 @@ pub fn ccp_deterministic_sample(n : Int, size : Int, seed : Int) -> Array[Int] { pub fn ccp_kmeans_cluster(data : Array[Array[Double]], k : Int) -> Array[Int] { let n = data.length() let dim = if n > 0 { data[0].length() } else { 0 } - + let centroids : Array[Array[Double]] = Array::new() let mut c = 0 while c < k && c < n { centroids.push(data[c]) c = c + 1 } - + let labels : Array[Int] = Array::new() let mut j = 0 while j < n { labels.push(0) j = j + 1 } - + let mut changed = true let mut iterations = 0 while changed && iterations < 100 { changed = false - + let mut p = 0 while p < n { let mut min_dist = 10000000000.0 let mut best_cluster = 0 - + let mut q = 0 while q < centroids.length() { let dist = ccp_euclidean_distance(data[p], centroids[q]) @@ -180,14 +186,14 @@ pub fn ccp_kmeans_cluster(data : Array[Array[Double]], k : Int) -> Array[Int] { } q = q + 1 } - + if labels[p] != best_cluster { labels.set(p, best_cluster) changed = true } p = p + 1 } - + let mut r = 0 while r < centroids.length() { let sum : Array[Double] = Array::new() @@ -196,7 +202,7 @@ pub fn ccp_kmeans_cluster(data : Array[Array[Double]], k : Int) -> Array[Int] { sum.push(0.0) s = s + 1 } - + let mut count = 0 let mut t = 0 while t < n { @@ -210,7 +216,7 @@ pub fn ccp_kmeans_cluster(data : Array[Array[Double]], k : Int) -> Array[Int] { } t = t + 1 } - + if count > 0 { let mut v = 0 while v < dim { @@ -220,10 +226,10 @@ pub fn ccp_kmeans_cluster(data : Array[Array[Double]], k : Int) -> Array[Int] { } r = r + 1 } - + iterations = iterations + 1 } - + labels } @@ -242,15 +248,17 @@ pub fn ccp_euclidean_distance(v1 : Array[Double], v2 : Array[Double]) -> Double ///| /// Calculate consensus score from consensus matrix. -pub fn ccp_calculate_consensus_score(consensus_matrix : Array[Array[Double]]) -> Double { +pub fn ccp_calculate_consensus_score( + consensus_matrix : Array[Array[Double]], +) -> Double { let n = consensus_matrix.length() if n == 0 { return 0.0 } - + let mut sum = 0.0 let mut count = 0 - + let mut i = 0 while i < n { let mut j = i + 1 @@ -261,16 +269,24 @@ pub fn ccp_calculate_consensus_score(consensus_matrix : Array[Array[Double]]) -> } i = i + 1 } - - if count > 0 { sum / count.to_double() } else { 0.0 } + + if count > 0 { + sum / count.to_double() + } else { + 0.0 + } } ///| /// Calculate stability scores for each cluster. -pub fn ccp_calculate_stability_scores(consensus_matrix : Array[Array[Double]], cluster_labels : Array[Int], k : Int) -> Array[Double] { +pub fn ccp_calculate_stability_scores( + consensus_matrix : Array[Array[Double]], + cluster_labels : Array[Int], + k : Int, +) -> Array[Double] { let n = consensus_matrix.length() let scores : Array[Double] = Array::new() - + let mut c = 0 while c < k { let members : Array[Int] = Array::new() @@ -281,13 +297,13 @@ pub fn ccp_calculate_stability_scores(consensus_matrix : Array[Array[Double]], c } i = i + 1 } - + if members.length() < 2 { scores.push(0.0) c = c + 1 continue } - + let mut sum = 0.0 let mut count = 0 let mut a = 0 @@ -300,11 +316,11 @@ pub fn ccp_calculate_stability_scores(consensus_matrix : Array[Array[Double]], c } a = a + 1 } - + scores.push(if count > 0 { sum / count.to_double() } else { 0.0 }) c = c + 1 } - + scores } @@ -314,14 +330,20 @@ pub fn ccp_consensus_cluster( data : Array[Array[Double]], k : Int, n_iterations? : Int = 100, - sample_fraction? : Double = 0.8 + sample_fraction? : Double = 0.8, ) -> CCPResult { - let consensus_matrix = ccp_calculate_consensus_matrix(data, k, n_iterations, sample_fraction) + let consensus_matrix = ccp_calculate_consensus_matrix( + data, k, n_iterations, sample_fraction, + ) let cluster_labels = ccp_kmeans_cluster(data, k) let consensus_score = ccp_calculate_consensus_score(consensus_matrix) - let stability_scores = ccp_calculate_stability_scores(consensus_matrix, cluster_labels, k) - - CCPResult::new(consensus_matrix, cluster_labels, k, consensus_score, stability_scores) + let stability_scores = ccp_calculate_stability_scores( + consensus_matrix, cluster_labels, k, + ) + + CCPResult::new( + consensus_matrix, cluster_labels, k, consensus_score, stability_scores, + ) } ///| @@ -331,39 +353,46 @@ pub fn ccp_find_optimal_k( min_k : Int, max_k : Int, n_iterations? : Int = 100, - sample_fraction? : Double = 0.8 + sample_fraction? : Double = 0.8, ) -> (Int, Array[Double]) { let scores : Array[Double] = Array::new() let mut best_k = min_k let mut best_score = 0.0 - + let mut k = min_k while k <= max_k { - let result = ccp_consensus_cluster(data, k, n_iterations = n_iterations, sample_fraction = sample_fraction) + let result = ccp_consensus_cluster(data, k, n_iterations~, sample_fraction~) scores.push(result.consensus_score) - + if result.consensus_score > best_score { best_score = result.consensus_score best_k = k } - + k = k + 1 } - + (best_k, scores) } ///| /// Bio API functions. - pub fn bio_consensus_cluster(data : Array[Array[Double]], k : Int) -> CCPResult { ccp_consensus_cluster(data, k) } -pub fn bio_consensus_cluster_find_optimal_k(data : Array[Array[Double]], min_k : Int, max_k : Int) -> (Int, Array[Double]) { +///| +pub fn bio_consensus_cluster_find_optimal_k( + data : Array[Array[Double]], + min_k : Int, + max_k : Int, +) -> (Int, Array[Double]) { ccp_find_optimal_k(data, min_k, max_k) } -pub fn bio_consensus_cluster_consensus_score(consensus_matrix : Array[Array[Double]]) -> Double { +///| +pub fn bio_consensus_cluster_consensus_score( + consensus_matrix : Array[Array[Double]], +) -> Double { ccp_calculate_consensus_score(consensus_matrix) -} \ No newline at end of file +} diff --git a/src/cram_wbtest.mbt b/src/cram_wbtest.mbt index d65e3416..947908a0 100644 --- a/src/cram_wbtest.mbt +++ b/src/cram_wbtest.mbt @@ -11,7 +11,7 @@ test "cram_magic" { test "cram_record_is_paired" { let cigar : Array[BamCigarElement] = Array::new() cigar.push(BamCigarElement::{ op: BamCigarOp::Match, length: 100 }) - + let read_features = CramReadFeatures::{ read_group: 0, flags: 1, @@ -22,7 +22,7 @@ test "cram_record_is_paired" { quality: "!!!!", tags: Array::new(), } - + let record = CramRecord::{ ref_id: 0, pos: 100, read_features } assert_true((record.read_features.flags & 1) != 0) } @@ -30,7 +30,7 @@ test "cram_record_is_paired" { ///| test "cram_record_is_mapped" { let cigar : Array[BamCigarElement] = Array::new() - + let read_features = CramReadFeatures::{ read_group: 0, flags: 0, @@ -41,7 +41,7 @@ test "cram_record_is_mapped" { quality: "!!!!", tags: Array::new(), } - + let record = CramRecord::{ ref_id: 0, pos: 100, read_features } assert_true((record.read_features.flags & 4) == 0) } @@ -49,7 +49,7 @@ test "cram_record_is_mapped" { ///| test "cram_record_is_unmapped" { let cigar : Array[BamCigarElement] = Array::new() - + let read_features = CramReadFeatures::{ read_group: 0, flags: 4, @@ -60,7 +60,7 @@ test "cram_record_is_unmapped" { quality: "!!!!", tags: Array::new(), } - + let record = CramRecord::{ ref_id: -1, pos: 0, read_features } assert_true((record.read_features.flags & 4) != 0) } @@ -68,7 +68,7 @@ test "cram_record_is_unmapped" { ///| test "cram_record_is_reverse" { let cigar : Array[BamCigarElement] = Array::new() - + let read_features = CramReadFeatures::{ read_group: 0, flags: 16, @@ -79,7 +79,7 @@ test "cram_record_is_reverse" { quality: "!!!!", tags: Array::new(), } - + let record = CramRecord::{ ref_id: 0, pos: 100, read_features } assert_true((record.read_features.flags & 16) != 0) } @@ -87,10 +87,25 @@ test "cram_record_is_reverse" { ///| test "cram_file_num_references" { let references : Array[CramReference] = Array::new() - references.push(CramReference::{ name: "chr1", length: 1000, md5: "", uri: "" }) - references.push(CramReference::{ name: "chr2", length: 2000, md5: "", uri: "" }) - references.push(CramReference::{ name: "chr3", length: 3000, md5: "", uri: "" }) - + references.push(CramReference::{ + name: "chr1", + length: 1000, + md5: "", + uri: "", + }) + references.push(CramReference::{ + name: "chr2", + length: 2000, + md5: "", + uri: "", + }) + references.push(CramReference::{ + name: "chr3", + length: 3000, + md5: "", + uri: "", + }) + let header = CramHeader::{ version: CramVersion::{ major: 3, minor: 0 }, reference_count: 3, @@ -108,7 +123,7 @@ test "cram_file_num_references" { test "cram_record_to_bam_record" { let cigar : Array[BamCigarElement] = Array::new() cigar.push(BamCigarElement::{ op: BamCigarOp::Match, length: 100 }) - + let read_features = CramReadFeatures::{ read_group: 0, flags: 0, @@ -119,10 +134,10 @@ test "cram_record_to_bam_record" { quality: "!!!!", tags: Array::new(), } - + let record = CramRecord::{ ref_id: 0, pos: 100, read_features } let bam_record = record.to_bam_record() - + assert_eq(bam_record.ref_id, 0) assert_eq(bam_record.pos, 100) assert_eq(bam_record.mapq, 60) @@ -143,7 +158,7 @@ fn read_itf8(data : String, pos : Int) -> (Int, Int) { ///| fn read_ltf8(data : String, pos : Int) -> (Int, Int) { let byte = data[pos].to_int() & 0xFF - ((byte >> 1), pos + 1) + (byte >> 1, pos + 1) } ///| @@ -168,4 +183,4 @@ test "read_ltf8" { let (val, pos) = read_ltf8(data, 0) assert_eq(val, 1) assert_eq(pos, 1) -} \ No newline at end of file +} diff --git a/src/crystal.mbt b/src/crystal.mbt index c739b380..0ebb1c4d 100644 --- a/src/crystal.mbt +++ b/src/crystal.mbt @@ -78,7 +78,7 @@ pub fn crystal_density( } let v_cm3 = v_ang3 * 1.0e-24 let n_a = 6.02214076e23 - (z.to_double() * molecular_weight) / (v_cm3 * n_a) + z.to_double() * molecular_weight / (v_cm3 * n_a) } ///| @@ -127,11 +127,7 @@ pub fn orthogonalization_matrix(cell : UnitCell) -> Array[Array[Double]] { // Build with the corrected entries (matches Rupp's textbook). let _ = m02 let _ = m12 - [ - [m00, m01, b * sg * cb], - [m10, m11, b * sg * m12_clean], - [m20, m21, m22], - ] + [[m00, m01, b * sg * cb], [m10, m11, b * sg * m12_clean], [m20, m21, m22]] } ///| @@ -238,7 +234,7 @@ pub fn lookup_space_group(number : Int) -> SpaceGroup { 194 => SpaceGroup::new(number=194, symbol="P 63/m m c") 225 => SpaceGroup::new(number=225, symbol="F m -3 m") 227 => SpaceGroup::new(number=227, symbol="F d -3 m") - _ => SpaceGroup::new(number=number, symbol="") + _ => SpaceGroup::new(number~, symbol="") } } @@ -316,21 +312,27 @@ pub fn CrystalStructure::new( z? : Int = 1, molecular_weight? : Double = 0.0, ) -> CrystalStructure { - CrystalStructure::{ name, cell, space_group, atoms, bonds, z, molecular_weight } + CrystalStructure::{ + name, + cell, + space_group, + atoms, + bonds, + z, + molecular_weight, + } } ///| /// Convert all atoms in a crystal structure to fractional coordinates /// (in place-style: returns a new array of atoms). -pub fn atoms_to_fractional( - structure : CrystalStructure -) -> Array[CrystalAtom] { +pub fn atoms_to_fractional(structure : CrystalStructure) -> Array[CrystalAtom] { let out : Array[CrystalAtom] = Array::new() for a in structure.atoms { if a.is_fractional { out.push(a) } else { - let(fx, fy, fz) = cartesian_to_fractional(structure.cell, a.x, a.y, a.z) + let (fx, fy, fz) = cartesian_to_fractional(structure.cell, a.x, a.y, a.z) out.push( CrystalAtom::new( label=a.label, @@ -349,15 +351,13 @@ pub fn atoms_to_fractional( ///| /// Convert all atoms in a crystal structure to Cartesian coordinates. -pub fn atoms_to_cartesian( - structure : CrystalStructure -) -> Array[CrystalAtom] { +pub fn atoms_to_cartesian(structure : CrystalStructure) -> Array[CrystalAtom] { let out : Array[CrystalAtom] = Array::new() for a in structure.atoms { if !a.is_fractional { out.push(a) } else { - let(cx, cy, cz) = fractional_to_cartesian(structure.cell, a.x, a.y, a.z) + let (cx, cy, cz) = fractional_to_cartesian(structure.cell, a.x, a.y, a.z) out.push( CrystalAtom::new( label=a.label, @@ -416,9 +416,7 @@ pub fn crystal_atom_distance( ///| /// Compute the center of mass of the atoms in Cartesian coordinates. -pub fn center_of_mass( - structure : CrystalStructure -) -> (Double, Double, Double) { +pub fn center_of_mass(structure : CrystalStructure) -> (Double, Double, Double) { let cart = atoms_to_cartesian(structure) if cart.length() == 0 { return (0.0, 0.0, 0.0) @@ -467,7 +465,11 @@ pub fn CifBlock::new(name~ : String) -> CifBlock { ///| /// Add a scalar data item to a CifBlock. -pub fn CifBlock::set_scalar(self : CifBlock, name : String, value : String) -> Unit { +pub fn CifBlock::set_scalar( + self : CifBlock, + name : String, + value : String, +) -> Unit { self.items[name] = CifDataItem::CifScalar(value) } @@ -536,7 +538,7 @@ pub fn parse_cif(text : String) -> Array[CifBlock] { if t.length() >= 5 && t[0:5].to_owned() == "data_" { // Start a new block. let name = t[5:t.length()].to_owned() - let block = CifBlock::new(name=name) + let block = CifBlock::new(name~) blocks.push(block) current = Some(block) i = i + 1 @@ -565,8 +567,7 @@ pub fn parse_cif(text : String) -> Array[CifBlock] { let rows : Array[Array[String]] = Array::new() while i < tokens.length() { let r = tokens[i] - if r == "loop_" || - (r.length() >= 5 && r[0:5].to_owned() == "data_") { + if r == "loop_" || (r.length() >= 5 && r[0:5].to_owned() == "data_") { break } if r.length() > 0 && r[0:1].to_owned() == "_" { @@ -637,14 +638,7 @@ pub fn cif_block_to_crystal(block : CifBlock) -> CrystalStructure { let alpha = cif_get_scalar_double(block, "_cell_angle_alpha") let beta = cif_get_scalar_double(block, "_cell_angle_beta") let gamma = cif_get_scalar_double(block, "_cell_angle_gamma") - let cell = UnitCell::new( - a=a, - b=b, - c=c, - alpha=alpha, - beta=beta, - gamma=gamma, - ) + let cell = UnitCell::new(a~, b~, c~, alpha~, beta~, gamma~) // Space group. let sg_symbol = block.get_scalar("_space_group_name_H-M") let sg_number = cif_get_scalar_int(block, "_space_group_IT_number") @@ -698,11 +692,11 @@ pub fn cif_block_to_crystal(block : CifBlock) -> CrystalStructure { } atoms.push( CrystalAtom::new( - label=label, + label~, element=elem, - x=x, - y=y, - z=z, + x~, + y~, + z~, occupancy=occ, is_fractional=true, ), @@ -739,12 +733,12 @@ pub fn cif_block_to_crystal(block : CifBlock) -> CrystalStructure { let z = cif_get_scalar_int(block, "_cell_formula_units_Z") let mw = cif_get_scalar_double(block, "_chemical_formula_weight") CrystalStructure::new( - name=name, - cell=cell, - space_group=space_group, - atoms=atoms, - bonds=bonds, - z=z, + name~, + cell~, + space_group~, + atoms~, + bonds~, + z~, molecular_weight=mw, ) } @@ -782,7 +776,11 @@ pub fn format_crystal_structure(structure : CrystalStructure) -> String { s = s + "Z = " + structure.z.to_string() + "\n" s = s + "Molecular weight: " + cif_fmt(structure.molecular_weight) + "\n" if structure.molecular_weight > 0.0 && structure.z > 0 { - let rho = crystal_density(structure.cell, structure.z, structure.molecular_weight) + let rho = crystal_density( + structure.cell, + structure.z, + structure.molecular_weight, + ) s = s + "Density: " + cif_fmt(rho) + " g/cm^3\n" } s = s + "Atoms (" + structure.atoms.length().to_string() + "):\n" @@ -806,13 +804,7 @@ pub fn format_crystal_structure(structure : CrystalStructure) -> String { s = s + "Bonds (" + structure.bonds.length().to_string() + "):\n" s = s + "atom1\tatom2\tdistance\n" for b in structure.bonds { - s = s + - b.atom1 + - "\t" + - b.atom2 + - "\t" + - cif_fmt(b.distance) + - "\n" + s = s + b.atom1 + "\t" + b.atom2 + "\t" + cif_fmt(b.distance) + "\n" } } s @@ -919,10 +911,10 @@ pub fn crystal_sample_structure() -> CrystalStructure { ] CrystalStructure::new( name="benzene", - cell=cell, + cell~, space_group=sg, - atoms=atoms, - bonds=bonds, + atoms~, + bonds~, z=2, molecular_weight=78.11, ) diff --git a/src/csaw.mbt b/src/csaw.mbt index f502a53c..a5df47ce 100644 --- a/src/csaw.mbt +++ b/src/csaw.mbt @@ -4,6 +4,7 @@ /// Supports sliding window counting, normalization, filtering, /// and negative binomial GLM-based differential testing. +///| /// Normalization method for window counts pub enum CswNormMethod { /// TMM (trimmed mean of M-values) @@ -16,6 +17,7 @@ pub enum CswNormMethod { None } +///| /// Filtering status for a window pub enum CswFilterStatus { /// Window passes filter @@ -28,6 +30,7 @@ pub enum CswFilterStatus { Excluded } derive(Eq) +///| /// A single genomic window pub struct CswWindow { /// Window ID @@ -46,6 +49,7 @@ pub struct CswWindow { filter_abundance : Double } +///| /// Collection of windows across samples pub struct CswDataSet { /// Windows @@ -62,6 +66,7 @@ pub struct CswDataSet { bin_indices : Array[Int] } +///| /// Normalization result pub struct CswNormResult { /// Normalization factors per sample @@ -74,6 +79,7 @@ pub struct CswNormResult { log_ratios : Array[Array[Double]] } +///| /// Differential binding result pub struct CswResult { /// Window indices @@ -92,6 +98,7 @@ pub struct CswResult { significant : Array[Bool] } +///| /// Region result (merged adjacent significant windows) pub struct CswRegion { /// Region ID @@ -114,8 +121,15 @@ pub struct CswRegion { // ===== Window methods ===== +///| /// Create a new window -pub fn CswWindow::new(id : String, chrom : String, start : Int, end : Int, counts : Array[Double]) -> CswWindow { +pub fn CswWindow::new( + id : String, + chrom : String, + start : Int, + end : Int, + counts : Array[Double], +) -> CswWindow { CswWindow::{ id, chrom, @@ -123,24 +137,29 @@ pub fn CswWindow::new(id : String, chrom : String, start : Int, end : Int, count end, counts, filter_status: CswFilterStatus::Pass, - filter_abundance: 0.0 + filter_abundance: 0.0, } } +///| /// Get window width pub fn CswWindow::csw_width(self : CswWindow) -> Int { self.end - self.start } +///| /// Get count for a sample index pub fn CswWindow::csw_count(self : CswWindow, sample_idx : Int) -> Double { self.counts[sample_idx] } +///| /// Get mean count across samples pub fn CswWindow::csw_mean_count(self : CswWindow) -> Double { let n = self.counts.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut sum = 0.0 let mut i = 0 while i < n { @@ -152,8 +171,13 @@ pub fn CswWindow::csw_mean_count(self : CswWindow) -> Double { // ===== DataSet methods ===== +///| /// Create a new CswDataSet -pub fn CswDataSet::new(windows : Array[CswWindow], samples : Array[String], lib_sizes : Array[Double]) -> CswDataSet { +pub fn CswDataSet::new( + windows : Array[CswWindow], + samples : Array[String], + lib_sizes : Array[Double], +) -> CswDataSet { let n_samples = samples.length() let norm_factors : Array[Double] = Array::new() let mut i = 0 @@ -167,25 +191,29 @@ pub fn CswDataSet::new(windows : Array[CswWindow], samples : Array[String], lib_ lib_sizes, norm_factors, filtered_windows: windows.copy(), - bin_indices: Array::new() + bin_indices: Array::new(), } } +///| /// Get number of windows pub fn CswDataSet::csw_n_windows(self : CswDataSet) -> Int { self.windows.length() } +///| /// Get number of samples pub fn CswDataSet::csw_n_samples(self : CswDataSet) -> Int { self.samples.length() } +///| /// Get a window by index pub fn CswDataSet::csw_get_window(self : CswDataSet, idx : Int) -> CswWindow { self.windows[idx] } +///| /// Get filtered windows pub fn CswDataSet::csw_get_filtered(self : CswDataSet) -> Array[CswWindow] { self.filtered_windows.copy() @@ -195,7 +223,13 @@ pub fn CswDataSet::csw_get_filtered(self : CswDataSet) -> Array[CswWindow] { ///| /// Generate sliding windows across a chromosome. -pub fn csw_make_windows(chrom : String, start : Int, end : Int, width : Int, shift : Int) -> Array[CswWindow] { +pub fn csw_make_windows( + chrom : String, + start : Int, + end : Int, + width : Int, + shift : Int, +) -> Array[CswWindow] { let windows : Array[CswWindow] = Array::new() let mut pos = start while pos + width <= end { @@ -204,7 +238,7 @@ pub fn csw_make_windows(chrom : String, start : Int, end : Int, width : Int, shi chrom, pos, pos + width, - Array::new() + Array::new(), ) windows.push(w) pos = pos + shift @@ -214,7 +248,10 @@ pub fn csw_make_windows(chrom : String, start : Int, end : Int, width : Int, shi ///| /// Assign counts to windows from read positions. -pub fn csw_assign_counts(windows : Array[CswWindow], read_positions : Array[Int]) -> Array[CswWindow] { +pub fn csw_assign_counts( + windows : Array[CswWindow], + read_positions : Array[Int], +) -> Array[CswWindow] { let result : Array[CswWindow] = Array::new() let mut i = 0 while i < windows.length() { @@ -267,7 +304,11 @@ pub fn csw_norm_tmm(data : CswDataSet) -> CswNormResult { let mut min_diff = 1.0e30 let mut s = 0 while s < n_samples { - let diff_val = if lib_sizes[s] > 0.0 { (lib_sizes[s] - mean_lib).abs() } else { 1.0e30 } + let diff_val = if lib_sizes[s] > 0.0 { + (lib_sizes[s] - mean_lib).abs() + } else { + 1.0e30 + } if diff_val < min_diff { min_diff = diff_val ref_idx = s @@ -291,8 +332,16 @@ pub fn csw_norm_tmm(data : CswDataSet) -> CswNormResult { while k < n_windows { let ref_count = data.windows[k].counts[ref_idx] let obs_count = data.windows[k].counts[i] - let ref_norm = if lib_sizes[ref_idx] > 0.0 { ref_count / lib_sizes[ref_idx] } else { 0.0 } - let obs_norm = if lib_sizes[i] > 0.0 { obs_count / lib_sizes[i] } else { 0.0 } + let ref_norm = if lib_sizes[ref_idx] > 0.0 { + ref_count / lib_sizes[ref_idx] + } else { + 0.0 + } + let obs_norm = if lib_sizes[i] > 0.0 { + obs_count / lib_sizes[i] + } else { + 0.0 + } if ref_norm > 0.0 && obs_norm > 0.0 { let m_val = @math.ln(obs_norm / ref_norm) / @math.ln(2.0) sample_log_ratios.push(m_val) @@ -301,7 +350,11 @@ pub fn csw_norm_tmm(data : CswDataSet) -> CswNormResult { } k = k + 1 } - let trimmed_m = if m_count > 0 { m_vals_sum / m_count.to_double() } else { 0.0 } + let trimmed_m = if m_count > 0 { + m_vals_sum / m_count.to_double() + } else { + 0.0 + } let factor = @math.exp(-trimmed_m * @math.ln(2.0)) factors.push(factor) log_ratios.push(sample_log_ratios) @@ -311,13 +364,16 @@ pub fn csw_norm_tmm(data : CswDataSet) -> CswNormResult { norm_factors: factors, norm_method: CswNormMethod::TMM, ref_sample: ref_idx, - log_ratios + log_ratios, } } ///| /// Apply normalization factors to window counts. -pub fn csw_apply_normalization(data : CswDataSet, norm_factors : Array[Double]) -> CswDataSet { +pub fn csw_apply_normalization( + data : CswDataSet, + norm_factors : Array[Double], +) -> CswDataSet { let n_samples = data.samples.length() let n_windows = data.windows.length() let new_windows : Array[CswWindow] = Array::new() @@ -327,7 +383,11 @@ pub fn csw_apply_normalization(data : CswDataSet, norm_factors : Array[Double]) let new_counts : Array[Double] = Array::new() let mut j = 0 while j < n_samples { - let lib_adj = if data.lib_sizes[j] > 0.0 { 1.0 / data.lib_sizes[j] } else { 1.0 } + let lib_adj = if data.lib_sizes[j] > 0.0 { + 1.0 / data.lib_sizes[j] + } else { + 1.0 + } let norm_count = w.counts[j] * lib_adj * norm_factors[j] new_counts.push(norm_count) j = j + 1 @@ -339,7 +399,7 @@ pub fn csw_apply_normalization(data : CswDataSet, norm_factors : Array[Double]) end: w.end, counts: new_counts, filter_status: w.filter_status, - filter_abundance: w.filter_abundance + filter_abundance: w.filter_abundance, }) i = i + 1 } @@ -349,7 +409,7 @@ pub fn csw_apply_normalization(data : CswDataSet, norm_factors : Array[Double]) lib_sizes: data.lib_sizes, norm_factors, filtered_windows: new_windows.copy(), - bin_indices: Array::new() + bin_indices: Array::new(), } } @@ -357,15 +417,26 @@ pub fn csw_apply_normalization(data : CswDataSet, norm_factors : Array[Double]) ///| /// Filter windows by abundance (log2 CPB threshold). -pub fn csw_filter_abundance(data : CswDataSet, log2_cpb_threshold : Double) -> CswDataSet { +pub fn csw_filter_abundance( + data : CswDataSet, + log2_cpb_threshold : Double, +) -> CswDataSet { let n_windows = data.windows.length() let filtered : Array[CswWindow] = Array::new() let mut i = 0 while i < n_windows { let w = data.windows[i] let total_cpb = csw_total_cpb(w.counts, data.lib_sizes) - let log2_cpb = if total_cpb > 0.0 { @math.ln(total_cpb) / @math.ln(2.0) } else { -1.0e9 } - let status = if log2_cpb >= log2_cpb_threshold { CswFilterStatus::Pass } else { CswFilterStatus::LowAbundance } + let log2_cpb = if total_cpb > 0.0 { + @math.ln(total_cpb) / @math.ln(2.0) + } else { + -1.0e9 + } + let status = if log2_cpb >= log2_cpb_threshold { + CswFilterStatus::Pass + } else { + CswFilterStatus::LowAbundance + } let fw = CswWindow::{ id: w.id, chrom: w.chrom, @@ -373,7 +444,7 @@ pub fn csw_filter_abundance(data : CswDataSet, log2_cpb_threshold : Double) -> C end: w.end, counts: w.counts, filter_status: status, - filter_abundance: log2_cpb + filter_abundance: log2_cpb, } filtered.push(fw) i = i + 1 @@ -384,7 +455,7 @@ pub fn csw_filter_abundance(data : CswDataSet, log2_cpb_threshold : Double) -> C lib_sizes: data.lib_sizes, norm_factors: data.norm_factors, filtered_windows: filtered, - bin_indices: data.bin_indices + bin_indices: data.bin_indices, } } @@ -413,7 +484,7 @@ pub fn csw_filter_merged(data : CswDataSet, tol : Double) -> CswDataSet { end: filtered[j].end, counts: filtered[j].counts, filter_status: CswFilterStatus::Merged, - filter_abundance: filtered[j].filter_abundance + filter_abundance: filtered[j].filter_abundance, } } j = j + 1 @@ -427,7 +498,7 @@ pub fn csw_filter_merged(data : CswDataSet, tol : Double) -> CswDataSet { lib_sizes: data.lib_sizes, norm_factors: data.norm_factors, filtered_windows: filtered, - bin_indices: data.bin_indices + bin_indices: data.bin_indices, } } @@ -447,7 +518,7 @@ pub fn csw_test_differential( data : CswDataSet, group1_indices : Array[Int], group2_indices : Array[Int], - dispersion : Double + dispersion : Double, ) -> CswResult { let filtered = data.filtered_windows let n_windows = filtered.length() @@ -473,7 +544,11 @@ pub fn csw_test_differential( } let disp = if dispersion > 0.0 { dispersion } else { 0.1 } let se = if variance1 > 0.0 || variance2 > 0.0 { - (disp * (mean1 / csw_mean_int(group1_indices) + mean2 / csw_mean_int(group2_indices))).sqrt() + (disp * + ( + mean1 / csw_mean_int(group1_indices) + + mean2 / csw_mean_int(group2_indices) + )).sqrt() } else { 1.0 } @@ -502,13 +577,17 @@ pub fn csw_test_differential( wald_stat, p_values, adj_p_values: adj_p, - significant + significant, } } ///| /// Find regions by merging adjacent significant windows. -pub fn csw_find_regions(data : CswDataSet, result : CswResult, merge_tol : Int) -> Array[CswRegion] { +pub fn csw_find_regions( + data : CswDataSet, + result : CswResult, + merge_tol : Int, +) -> Array[CswRegion] { let regions : Array[CswRegion] = Array::new() let n = result.window_indices.length() let mut i = 0 @@ -521,7 +600,12 @@ pub fn csw_find_regions(data : CswDataSet, result : CswResult, merge_tol : Int) let mut end_idx = i while end_idx + 1 < n && result.significant[end_idx + 1] && - csw_can_merge_windows(data, result.window_indices[end_idx], result.window_indices[end_idx + 1], merge_tol) { + csw_can_merge_windows( + data, + result.window_indices[end_idx], + result.window_indices[end_idx + 1], + merge_tol, + ) { end_idx = end_idx + 1 } let region = csw_build_region(data, result, start_idx, end_idx) @@ -533,17 +617,29 @@ pub fn csw_find_regions(data : CswDataSet, result : CswResult, merge_tol : Int) ///| /// Check if two windows can be merged into a region. -fn csw_can_merge_windows(data : CswDataSet, idx1 : Int, idx2 : Int, tol : Int) -> Bool { +fn csw_can_merge_windows( + data : CswDataSet, + idx1 : Int, + idx2 : Int, + tol : Int, +) -> Bool { let w1 = data.filtered_windows[idx1] let w2 = data.filtered_windows[idx2] - if w1.chrom != w2.chrom { return false } + if w1.chrom != w2.chrom { + return false + } let gap = w2.start - w1.end gap >= 0 && gap <= tol } ///| /// Build a region from merged windows. -fn csw_build_region(data : CswDataSet, result : CswResult, start : Int, end : Int) -> CswRegion { +fn csw_build_region( + data : CswDataSet, + result : CswResult, + start : Int, + end : Int, +) -> CswRegion { let win_indices : Array[Int] = Array::new() let mut i = start let mut combined_chi2 = 0.0 @@ -560,8 +656,12 @@ fn csw_build_region(data : CswDataSet, result : CswResult, start : Int, end : In } let w = data.filtered_windows[wi] chrom = w.chrom - if w.start.to_double() < rstart { rstart = w.start.to_double() } - if w.end.to_double() > rend { rend = w.end.to_double() } + if w.start.to_double() < rstart { + rstart = w.start.to_double() + } + if w.end.to_double() > rend { + rend = w.end.to_double() + } i = i + 1 } let n_windows = end - start + 1 @@ -578,15 +678,18 @@ fn csw_build_region(data : CswDataSet, result : CswResult, start : Int, end : In combined_p_value: combined_p, max_log_fc: max_lfc, n_windows, - window_indices: win_indices + window_indices: win_indices, } } // ===== Helper functions ===== +///| fn csw_mean_double(arr : Array[Double]) -> Double { let n = arr.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut sum = 0.0 let mut i = 0 while i < n { @@ -596,9 +699,12 @@ fn csw_mean_double(arr : Array[Double]) -> Double { sum / n.to_double() } +///| fn csw_mean_int(arr : Array[Int]) -> Double { let n = arr.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut sum = 0.0 let mut i = 0 while i < n { @@ -608,6 +714,7 @@ fn csw_mean_int(arr : Array[Int]) -> Double { sum / n.to_double() } +///| fn csw_total_cpb(counts : Array[Double], lib_sizes : Array[Double]) -> Double { let mut total = 0.0 let mut i = 0 @@ -619,9 +726,15 @@ fn csw_total_cpb(counts : Array[Double], lib_sizes : Array[Double]) -> Double { total } -fn csw_mean_var_group(counts : Array[Double], indices : Array[Int]) -> (Double, Double) { +///| +fn csw_mean_var_group( + counts : Array[Double], + indices : Array[Int], +) -> (Double, Double) { let n = indices.length() - if n == 0 { return (0.0, 0.0) } + if n == 0 { + return (0.0, 0.0) + } let mut sum = 0.0 let mut i = 0 while i < n { @@ -645,7 +758,11 @@ fn csw_mean_var_group(counts : Array[Double], indices : Array[Int]) -> (Double, fn csw_norm_p_value(z : Double) -> Double { let abs_z = z.abs() let p_approx = 2.0 * (1.0 - csw_norm_cdf(abs_z)) - if p_approx < 1.0e-300 { 1.0e-300 } else { p_approx } + if p_approx < 1.0e-300 { + 1.0e-300 + } else { + p_approx + } } ///| @@ -653,7 +770,12 @@ fn csw_norm_p_value(z : Double) -> Double { fn csw_norm_cdf(x : Double) -> Double { let t = 1.0 / (1.0 + 0.2316419 * x) let d = 0.3989422804014327 * @math.exp(-0.5 * x * x) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.3302744)))) + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.3302744))) + ) 1.0 - p } @@ -661,7 +783,9 @@ fn csw_norm_cdf(x : Double) -> Double { /// Benjamini-Hochberg correction. fn csw_bh_correction(p_values : Array[Double]) -> Array[Double] { let n = p_values.length() - if n == 0 { return Array::new() } + if n == 0 { + return Array::new() + } let indexed : Array[(Double, Int)] = Array::new() let mut i = 0 while i < n { @@ -718,8 +842,12 @@ fn csw_bh_correction(p_values : Array[Double]) -> Array[Double] { ///| /// Chi-squared survival function approximation. fn csw_chi2_sf(x : Double, df : Double) -> Double { - if x <= 0.0 { return 1.0 } - if df <= 0.0 { return 1.0 } + if x <= 0.0 { + return 1.0 + } + if df <= 0.0 { + return 1.0 + } // Wilson-Hilferty approximation let z = @math.pow(x / df, 1.0 / 3.0) let mu = 1.0 - 2.0 / (9.0 * df) diff --git a/src/cyclone.mbt b/src/cyclone.mbt index cd0205d8..04f29a1f 100644 --- a/src/cyclone.mbt +++ b/src/cyclone.mbt @@ -42,15 +42,15 @@ pub struct CycloneParams { ///| /// Create default Cyclone parameters. pub fn CycloneParams::new() -> CycloneParams { - CycloneParams::{ - min_score: 0.0, - n_top_pairs: 1, - } + CycloneParams::{ min_score: 0.0, n_top_pairs: 1 } } ///| /// Create custom Cyclone parameters. -pub fn CycloneParams::with_params(min_score : Double, n_top_pairs : Int) -> CycloneParams { +pub fn CycloneParams::with_params( + min_score : Double, + n_top_pairs : Int, +) -> CycloneParams { CycloneParams::{ min_score, n_top_pairs } } @@ -122,7 +122,9 @@ pub fn cyclone_get_phases(gene_pairs : Array[GenePair]) -> Array[String] { ///| /// Count gene pairs for each phase. -pub fn cyclone_count_pairs_by_phase(gene_pairs : Array[GenePair]) -> Map[String, Int] { +pub fn cyclone_count_pairs_by_phase( + gene_pairs : Array[GenePair], +) -> Map[String, Int] { let counts : Map[String, Int] = Map([]) for pair in gene_pairs { let current = counts.get(pair.phase).unwrap_or(0) @@ -178,7 +180,9 @@ pub fn cyclone_score_cell( let scores : Map[String, Double] = Map([], capacity=phases.length()) for phase in phases { - let score = cyclone_score_phase(cell_expression, gene_names, gene_pairs, phase) + let score = cyclone_score_phase( + cell_expression, gene_names, gene_pairs, phase, + ) scores.set(phase, score) } @@ -261,7 +265,12 @@ pub fn cyclone_score_cells( cell_expr.push(counts[j][i]) j = j + 1 } - let result = cyclone_score_single_cell(cell_expr, cell_ids[i], gene_names, gene_pairs) + let result = cyclone_score_single_cell( + cell_expr, + cell_ids[i], + gene_names, + gene_pairs, + ) results.push(result) i = i + 1 } @@ -271,7 +280,9 @@ pub fn cyclone_score_cells( ///| /// Get a summary of cell cycle phase distribution. -pub fn cyclone_phase_distribution(results : Array[CycloneResult]) -> Map[String, Double] { +pub fn cyclone_phase_distribution( + results : Array[CycloneResult], +) -> Map[String, Double] { let n = results.length() if n == 0 { return Map([]) @@ -295,7 +306,11 @@ pub fn cyclone_phase_distribution(results : Array[CycloneResult]) -> Map[String, ///| /// Create synthetic test data for Cyclone testing. -pub fn cyclone_create_test_data() -> (Array[Array[Double]], Array[String], Array[String]) { +pub fn cyclone_create_test_data() -> ( + Array[Array[Double]], + Array[String], + Array[String], +) { let gene_pairs = cyclone_get_gene_pairs() // Collect all unique gene names from pairs @@ -369,7 +384,9 @@ pub fn cyclone_create_test_data() -> (Array[Array[Double]], Array[String], Array ///| /// Get the average scores for each phase across all cells. -pub fn cyclone_average_scores(results : Array[CycloneResult]) -> Map[String, Double] { +pub fn cyclone_average_scores( + results : Array[CycloneResult], +) -> Map[String, Double] { if results.length() == 0 { return Map([]) } @@ -386,4 +403,4 @@ pub fn cyclone_average_scores(results : Array[CycloneResult]) -> Map[String, Dou } avg_scores -} \ No newline at end of file +} diff --git a/src/data.mbt b/src/data.mbt index c19077a5..d0b5851b 100644 --- a/src/data.mbt +++ b/src/data.mbt @@ -172,27 +172,174 @@ pub struct AminoAcidProperty { pub fn amino_acid_properties(aa : String) -> AminoAcidProperty { let upper = aa.to_upper() match upper { - "A" => AminoAcidProperty::{ amino_acid: "A", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: 1.8 } - "R" => AminoAcidProperty::{ amino_acid: "R", property: "positive", polarity: "polar", charge: 1.0, hydropathy: -4.5 } - "N" => AminoAcidProperty::{ amino_acid: "N", property: "polar", polarity: "polar", charge: 0.0, hydropathy: -3.5 } - "D" => AminoAcidProperty::{ amino_acid: "D", property: "negative", polarity: "polar", charge: -1.0, hydropathy: -3.5 } - "C" => AminoAcidProperty::{ amino_acid: "C", property: "polar", polarity: "polar", charge: 0.0, hydropathy: 2.5 } - "Q" => AminoAcidProperty::{ amino_acid: "Q", property: "polar", polarity: "polar", charge: 0.0, hydropathy: -3.5 } - "E" => AminoAcidProperty::{ amino_acid: "E", property: "negative", polarity: "polar", charge: -1.0, hydropathy: -3.5 } - "G" => AminoAcidProperty::{ amino_acid: "G", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: -0.4 } - "H" => AminoAcidProperty::{ amino_acid: "H", property: "positive", polarity: "polar", charge: 1.0, hydropathy: -3.2 } - "I" => AminoAcidProperty::{ amino_acid: "I", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: 4.5 } - "L" => AminoAcidProperty::{ amino_acid: "L", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: 3.8 } - "K" => AminoAcidProperty::{ amino_acid: "K", property: "positive", polarity: "polar", charge: 1.0, hydropathy: -3.9 } - "M" => AminoAcidProperty::{ amino_acid: "M", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: 1.9 } - "F" => AminoAcidProperty::{ amino_acid: "F", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: 2.8 } - "P" => AminoAcidProperty::{ amino_acid: "P", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: -1.6 } - "S" => AminoAcidProperty::{ amino_acid: "S", property: "polar", polarity: "polar", charge: 0.0, hydropathy: -0.8 } - "T" => AminoAcidProperty::{ amino_acid: "T", property: "polar", polarity: "polar", charge: 0.0, hydropathy: -0.7 } - "W" => AminoAcidProperty::{ amino_acid: "W", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: -0.9 } - "Y" => AminoAcidProperty::{ amino_acid: "Y", property: "polar", polarity: "polar", charge: 0.0, hydropathy: -1.3 } - "V" => AminoAcidProperty::{ amino_acid: "V", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: 4.2 } - _ => AminoAcidProperty::{ amino_acid: "?", property: "unknown", polarity: "unknown", charge: 0.0, hydropathy: 0.0 } + "A" => + AminoAcidProperty::{ + amino_acid: "A", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: 1.8, + } + "R" => + AminoAcidProperty::{ + amino_acid: "R", + property: "positive", + polarity: "polar", + charge: 1.0, + hydropathy: -4.5, + } + "N" => + AminoAcidProperty::{ + amino_acid: "N", + property: "polar", + polarity: "polar", + charge: 0.0, + hydropathy: -3.5, + } + "D" => + AminoAcidProperty::{ + amino_acid: "D", + property: "negative", + polarity: "polar", + charge: -1.0, + hydropathy: -3.5, + } + "C" => + AminoAcidProperty::{ + amino_acid: "C", + property: "polar", + polarity: "polar", + charge: 0.0, + hydropathy: 2.5, + } + "Q" => + AminoAcidProperty::{ + amino_acid: "Q", + property: "polar", + polarity: "polar", + charge: 0.0, + hydropathy: -3.5, + } + "E" => + AminoAcidProperty::{ + amino_acid: "E", + property: "negative", + polarity: "polar", + charge: -1.0, + hydropathy: -3.5, + } + "G" => + AminoAcidProperty::{ + amino_acid: "G", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: -0.4, + } + "H" => + AminoAcidProperty::{ + amino_acid: "H", + property: "positive", + polarity: "polar", + charge: 1.0, + hydropathy: -3.2, + } + "I" => + AminoAcidProperty::{ + amino_acid: "I", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: 4.5, + } + "L" => + AminoAcidProperty::{ + amino_acid: "L", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: 3.8, + } + "K" => + AminoAcidProperty::{ + amino_acid: "K", + property: "positive", + polarity: "polar", + charge: 1.0, + hydropathy: -3.9, + } + "M" => + AminoAcidProperty::{ + amino_acid: "M", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: 1.9, + } + "F" => + AminoAcidProperty::{ + amino_acid: "F", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: 2.8, + } + "P" => + AminoAcidProperty::{ + amino_acid: "P", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: -1.6, + } + "S" => + AminoAcidProperty::{ + amino_acid: "S", + property: "polar", + polarity: "polar", + charge: 0.0, + hydropathy: -0.8, + } + "T" => + AminoAcidProperty::{ + amino_acid: "T", + property: "polar", + polarity: "polar", + charge: 0.0, + hydropathy: -0.7, + } + "W" => + AminoAcidProperty::{ + amino_acid: "W", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: -0.9, + } + "Y" => + AminoAcidProperty::{ + amino_acid: "Y", + property: "polar", + polarity: "polar", + charge: 0.0, + hydropathy: -1.3, + } + "V" => + AminoAcidProperty::{ + amino_acid: "V", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: 4.2, + } + _ => + AminoAcidProperty::{ + amino_acid: "?", + property: "unknown", + polarity: "unknown", + charge: 0.0, + hydropathy: 0.0, + } } } @@ -285,18 +432,15 @@ pub fn reverse_codon_table() -> Map[String, Array[String]] { for codon in forward.keys() { match forward.get(codon) { - Some(aa) => { + Some(aa) => match result.get(aa) { Some(arr) => { let new_arr = arr.copy() new_arr.push(codon) result[aa] = new_arr } - None => { - result[aa] = [codon] - } + None => result[aa] = [codon] } - } None => () } } diff --git a/src/decoupler.mbt b/src/decoupler.mbt index 9802d9d7..c30ba280 100644 --- a/src/decoupler.mbt +++ b/src/decoupler.mbt @@ -21,17 +21,17 @@ ///| /// A single directed interaction in the prior knowledge network. pub struct PKNEdge { - source : String // regulator (TF) name - target : String // target gene name - weight : Double // mode of regulation: >0 activation, <0 inhibition + source : String // regulator (TF) name + target : String // target gene name + weight : Double // mode of regulation: >0 activation, <0 inhibition } ///| /// Prior knowledge network: collection of regulator→target edges. pub struct PriorKnowledgeNetwork { edges : Array[PKNEdge] - regulators : Array[String] // unique regulator names - targets : Array[String] // unique target names + regulators : Array[String] // unique regulator names + targets : Array[String] // unique target names } ///| @@ -63,7 +63,7 @@ pub struct ActivityScore { regulator : String sample : String score : Double - p_value : Double // only meaningful for ulm/mlm; 1.0 otherwise + p_value : Double // only meaningful for ulm/mlm; 1.0 otherwise } ///| @@ -71,8 +71,8 @@ pub struct ActivityScore { pub struct DecoupleRResult { regulators : Array[String] samples : Array[String] - matrix : Array[Array[Double]] // matrix[i][j] = activity of regulator i in sample j - scores : Array[ActivityScore] // flat list of scores + matrix : Array[Array[Double]] // matrix[i][j] = activity of regulator i in sample j + scores : Array[ActivityScore] // flat list of scores method : String } @@ -172,7 +172,9 @@ fn decoupler_wsum( gene_names : Array[String], pkn : PriorKnowledgeNetwork, ) -> DecoupleRResult { - let (reg_list, tgt_indices, w) = decoupler_build_weight_matrix(pkn, gene_names) + let (reg_list, tgt_indices, w) = decoupler_build_weight_matrix( + pkn, gene_names, + ) let n_reg = reg_list.length() let n_samples = expression.length() let matrix : Array[Array[Double]] = Array::new() @@ -209,7 +211,9 @@ fn decoupler_wmean( gene_names : Array[String], pkn : PriorKnowledgeNetwork, ) -> DecoupleRResult { - let (reg_list, tgt_indices, w) = decoupler_build_weight_matrix(pkn, gene_names) + let (reg_list, tgt_indices, w) = decoupler_build_weight_matrix( + pkn, gene_names, + ) let n_reg = reg_list.length() let n_samples = expression.length() let matrix : Array[Array[Double]] = Array::new() @@ -362,7 +366,8 @@ fn decoupler_normal_cdf(x : Double) -> Double { let sign = if x < 0.0 { -1.0 } else { 1.0 } let xa = x.abs() / 2.0.sqrt() let t = 1.0 / (1.0 + p * xa) - let y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * @math.exp(-xa * xa) + let y = 1.0 - + ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * @math.exp(-xa * xa) 0.5 * (1.0 + sign * y) } @@ -395,7 +400,9 @@ fn decoupler_ulm( gene_names : Array[String], pkn : PriorKnowledgeNetwork, ) -> DecoupleRResult { - let (reg_list, tgt_indices, w) = decoupler_build_weight_matrix(pkn, gene_names) + let (reg_list, tgt_indices, w) = decoupler_build_weight_matrix( + pkn, gene_names, + ) let n_reg = reg_list.length() let n_samples = expression.length() let matrix : Array[Array[Double]] = Array::new() @@ -459,21 +466,25 @@ fn decoupler_ulm( // Not meaningful; we set p_value to 1.0 since per-sample scores are unitless z-scores. let mut j = 0 while j < n_samples { - scores.push( - ActivityScore::{ - regulator: reg_list[i], - sample: sample_names[j], - score: matrix[i][j], - p_value: 1.0, - }, - ) + scores.push(ActivityScore::{ + regulator: reg_list[i], + sample: sample_names[j], + score: matrix[i][j], + p_value: 1.0, + }) j = j + 1 } i = i + 1 } // Use original t-stat style only if we have at least one target (avoid empty) // Use the standardized score as the activity; method tag is "ulm". - DecoupleRResult::{ regulators: reg_list, samples: sample_names, matrix, scores, method: "ulm" } + DecoupleRResult::{ + regulators: reg_list, + samples: sample_names, + matrix, + scores, + method: "ulm", + } } ///| @@ -495,7 +506,9 @@ fn decoupler_mlm( gene_names : Array[String], pkn : PriorKnowledgeNetwork, ) -> DecoupleRResult { - let (reg_list, tgt_indices, w) = decoupler_build_weight_matrix(pkn, gene_names) + let (reg_list, tgt_indices, w) = decoupler_build_weight_matrix( + pkn, gene_names, + ) let n_reg = reg_list.length() let n_samples = expression.length() let matrix : Array[Array[Double]] = Array::new() @@ -530,19 +543,23 @@ fn decoupler_mlm( } let (_, slope, _, _, _) = decoupler_simple_linear_regression(x, y) matrix[i][j] = slope - scores.push( - ActivityScore::{ - regulator: reg_list[i], - sample: sample_names[j], - score: slope, - p_value: 1.0, - }, - ) + scores.push(ActivityScore::{ + regulator: reg_list[i], + sample: sample_names[j], + score: slope, + p_value: 1.0, + }) j = j + 1 } i = i + 1 } - DecoupleRResult::{ regulators: reg_list, samples: sample_names, matrix, scores, method: "mlm" } + DecoupleRResult::{ + regulators: reg_list, + samples: sample_names, + matrix, + scores, + method: "mlm", + } } ///| @@ -610,14 +627,12 @@ fn decoupler_pack_result( while i < regulators.length() { let mut j = 0 while j < samples.length() { - scores.push( - ActivityScore::{ - regulator: regulators[i], - sample: samples[j], - score: matrix[i][j], - p_value: 1.0, - }, - ) + scores.push(ActivityScore::{ + regulator: regulators[i], + sample: samples[j], + score: matrix[i][j], + p_value: 1.0, + }) j = j + 1 } i = i + 1 @@ -642,11 +657,16 @@ pub fn decoupler_run( method? : DecoupleRMethod = DecoupleRMethod::ULM, ) -> DecoupleRResult { match method { - DecoupleRMethod::WSum => decoupler_wsum(expression, sample_names, gene_names, pkn) - DecoupleRMethod::WMean => decoupler_wmean(expression, sample_names, gene_names, pkn) - DecoupleRMethod::Norm => decoupler_norm(expression, sample_names, gene_names, pkn) - DecoupleRMethod::ULM => decoupler_ulm(expression, sample_names, gene_names, pkn) - DecoupleRMethod::MLM => decoupler_mlm(expression, sample_names, gene_names, pkn) + DecoupleRMethod::WSum => + decoupler_wsum(expression, sample_names, gene_names, pkn) + DecoupleRMethod::WMean => + decoupler_wmean(expression, sample_names, gene_names, pkn) + DecoupleRMethod::Norm => + decoupler_norm(expression, sample_names, gene_names, pkn) + DecoupleRMethod::ULM => + decoupler_ulm(expression, sample_names, gene_names, pkn) + DecoupleRMethod::MLM => + decoupler_mlm(expression, sample_names, gene_names, pkn) } } @@ -675,14 +695,12 @@ pub fn decoupler_top_regulators( let arr : Array[ActivityScore] = [] let mut i = 0 while i < result.regulators.length() { - arr.push( - ActivityScore::{ - regulator: result.regulators[i], - sample: sample_name, - score: result.matrix[i][s_idx], - p_value: 1.0, - }, - ) + arr.push(ActivityScore::{ + regulator: result.regulators[i], + sample: sample_name, + score: result.matrix[i][s_idx], + p_value: 1.0, + }) i = i + 1 } // Sort by absolute score descending @@ -729,7 +747,12 @@ pub fn decoupler_filter_scores( ///| /// Generate a small sample dataset for testing and demos. /// Returns (expression, sample_names, gene_names, pkn) where 3 TFs regulate 8 targets. -pub fn decoupler_sample_data() -> (Array[Array[Double]], Array[String], Array[String], PriorKnowledgeNetwork) { +pub fn decoupler_sample_data() -> ( + Array[Array[Double]], + Array[String], + Array[String], + PriorKnowledgeNetwork, +) { let gene_names = [ "TF1", "TF2", "TF3", "G1", "G2", "G3", "G4", "G5", "G6", "G7", "G8", ] diff --git a/src/delayed_matrix_stats.mbt b/src/delayed_matrix_stats.mbt index 2ff40599..04a4a36b 100644 --- a/src/delayed_matrix_stats.mbt +++ b/src/delayed_matrix_stats.mbt @@ -208,9 +208,7 @@ fn compute_single_stat(values : Array[Double], stat : String) -> Double { let variance = compute_single_stat(valid, "var") variance.sqrt() } - "n" | "nna" | "nn" => { - nv.to_double() - } + "n" | "nna" | "nn" => nv.to_double() _ => 0.0 } } @@ -312,4 +310,4 @@ pub fn col_n(matrix : DelayedMatrix) -> Array[Int] { j = j + 1 } result -} \ No newline at end of file +} diff --git a/src/deseq2.mbt b/src/deseq2.mbt index f0abc278..6e2f6cfa 100644 --- a/src/deseq2.mbt +++ b/src/deseq2.mbt @@ -21,7 +21,7 @@ pub fn DESeqDataSet::new( ) -> DESeqDataSet { let n_genes = counts.length() let n_samples = if counts.length() > 0 { counts[0].length() } else { 0 } - + DESeqDataSet::{ counts, row_names, @@ -68,7 +68,7 @@ pub fn DESeqResults::new( pub fn estimate_size_factors(dds : DESeqDataSet) -> DESeqDataSet { let n_genes = dds.counts.length() let n_samples = dds.col_names.length() - + let geo_means : Array[Double] = Array::new() for i = 0; i < n_genes; i = i + 1 { let gene_counts : Array[Double] = Array::new() @@ -77,7 +77,7 @@ pub fn estimate_size_factors(dds : DESeqDataSet) -> DESeqDataSet { } geo_means.push(stat_geometric_mean(gene_counts)) } - + let size_factors : Array[Double] = Array::new() for j = 0; j < n_samples; j = j + 1 { let ratios : Array[Double] = Array::new() @@ -86,26 +86,22 @@ pub fn estimate_size_factors(dds : DESeqDataSet) -> DESeqDataSet { ratios.push(dds.counts[i][j].to_double() / geo_means[i]) } } - - let median_val = if ratios.length() > 0 { - stat_median(ratios) - } else { - 1.0 - } + + let median_val = if ratios.length() > 0 { stat_median(ratios) } else { 1.0 } size_factors.push(median_val) } - + let mut mean_sf = 0.0 for sf in size_factors { mean_sf = mean_sf + sf } mean_sf = mean_sf / n_samples.to_double() - + let norm_sf : Array[Double] = Array::new() for sf in size_factors { norm_sf.push(sf / mean_sf) } - + DESeqDataSet::{ counts: dds.counts, row_names: dds.row_names, @@ -120,7 +116,7 @@ pub fn estimate_size_factors(dds : DESeqDataSet) -> DESeqDataSet { pub fn normalize_counts(dds : DESeqDataSet) -> Array[Array[Double]] { let n_genes = dds.counts.length() let n_samples = dds.col_names.length() - + let normalized : Array[Array[Double]] = Array::new() for i = 0; i < n_genes; i = i + 1 { let row : Array[Double] = Array::new() @@ -140,9 +136,9 @@ pub fn normalize_counts(dds : DESeqDataSet) -> Array[Array[Double]] { pub fn log2_cpm(dds : DESeqDataSet) -> Array[Array[Double]] { let n_genes = dds.counts.length() let n_samples = dds.col_names.length() - + let normalized = normalize_counts(dds) - + let lib_sizes : Array[Double] = Array::new() for j = 0; j < n_samples; j = j + 1 { let mut sum = 0.0 @@ -151,7 +147,7 @@ pub fn log2_cpm(dds : DESeqDataSet) -> Array[Array[Double]] { } lib_sizes.push(sum) } - + let log2_cpm : Array[Array[Double]] = Array::new() for i = 0; i < n_genes; i = i + 1 { let row : Array[Double] = Array::new() @@ -172,25 +168,31 @@ pub fn log2_cpm(dds : DESeqDataSet) -> Array[Array[Double]] { pub fn estimate_dispersions(dds : DESeqDataSet) -> DESeqDataSet { let n_genes = dds.counts.length() let n_samples = dds.col_names.length() - + let normalized = normalize_counts(dds) - + let log_means : Array[Double] = Array::new() for i = 0; i < n_genes; i = i + 1 { let mut sum = 0.0 for j = 0; j < n_samples; j = j + 1 { sum = sum + normalized[i][j] } - log_means.push(if sum > 0.0 { @math.ln(sum / n_samples.to_double()) } else { -10.0 }) + log_means.push( + if sum > 0.0 { + @math.ln(sum / n_samples.to_double()) + } else { + -10.0 + }, + ) } - + let dispersions : Array[Double] = Array::new() for i = 0; i < n_genes; i = i + 1 { let mut sum_counts = 0.0 for j = 0; j < n_samples; j = j + 1 { sum_counts = sum_counts + dds.counts[i][j].to_double() } - + if sum_counts > 0.0 { let mu_hat = sum_counts / n_samples.to_double() let mut var_obs = 0.0 @@ -199,7 +201,7 @@ pub fn estimate_dispersions(dds : DESeqDataSet) -> DESeqDataSet { var_obs = var_obs + diff * diff } var_obs = var_obs / (n_samples - 1).to_double() - + if mu_hat > 0.0 { let disp_est = (var_obs / mu_hat - 1.0) / mu_hat dispersions.push(if disp_est > 0.001 { disp_est } else { 0.001 }) @@ -210,10 +212,10 @@ pub fn estimate_dispersions(dds : DESeqDataSet) -> DESeqDataSet { dispersions.push(0.1) } } - + let alpha = 0.1 let beta = 0.5 - + let final_dispersions : Array[Double] = Array::new() for i = 0; i < n_genes; i = i + 1 { let raw_disp = dispersions[i] @@ -221,7 +223,7 @@ pub fn estimate_dispersions(dds : DESeqDataSet) -> DESeqDataSet { let weight = 1.0 / (1.0 / n_samples.to_double() + 1.0) final_dispersions.push((1.0 - weight) * prior_disp + weight * raw_disp) } - + DESeqDataSet::{ counts: dds.counts, row_names: dds.row_names, @@ -236,7 +238,12 @@ pub fn estimate_dispersions(dds : DESeqDataSet) -> DESeqDataSet { fn pnorm(x : Double) -> Double { let t = 1.0 / (1.0 + 0.2316419 * x.abs()) let d = 0.3989423 * @math.exp(-x * x / 2.0) - let prob = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))) + let prob = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))) + ) if x >= 0.0 { 1.0 - prob } else { @@ -249,71 +256,79 @@ pub fn deseq(dds : DESeqDataSet) -> DESeqResults { let n_genes = dds.counts.length() let n_samples = dds.col_names.length() let n_coefs = if dds.design.length() > 0 { dds.design[0].length() } else { 0 } - + let base_mean : Array[Double] = Array::new() let log2_fold_change : Array[Double] = Array::new() let lfc_se : Array[Double] = Array::new() let stat : Array[Double] = Array::new() let p_value : Array[Double] = Array::new() - + let normalized = normalize_counts(dds) - + for i = 0; i < n_genes; i = i + 1 { let mut sum_x = 0.0 let mut sum_y = 0.0 let mut sum_xy = 0.0 let mut sum_x2 = 0.0 let mut n = 0.0 - + for j = 0; j < n_samples; j = j + 1 { let x = dds.design[j][1] - let y = if normalized[i][j] > 0.0 { @math.ln(normalized[i][j]) } else { 0.0 } + let y = if normalized[i][j] > 0.0 { + @math.ln(normalized[i][j]) + } else { + 0.0 + } sum_x = sum_x + x sum_y = sum_y + y sum_xy = sum_xy + x * y sum_x2 = sum_x2 + x * x n = n + 1.0 } - + let denom = n * sum_x2 - sum_x * sum_x - let b1 = if denom != 0.0 { (n * sum_xy - sum_x * sum_y) / denom } else { 0.0 } + let b1 = if denom != 0.0 { + (n * sum_xy - sum_x * sum_y) / denom + } else { + 0.0 + } let b0 = (sum_y - b1 * sum_x) / n - + let mut sse = 0.0 for j = 0; j < n_samples; j = j + 1 { let x = dds.design[j][1] - let y = if normalized[i][j] > 0.0 { @math.ln(normalized[i][j]) } else { 0.0 } + let y = if normalized[i][j] > 0.0 { + @math.ln(normalized[i][j]) + } else { + 0.0 + } let pred = b0 + b1 * x sse = sse + (y - pred) * (y - pred) } - + let disp = dds.dispersions[i] let eff_var = sse / (n - 2.0) + disp * @math.exp(2.0 * b0) - - let se_b1 = if denom != 0.0 { - (eff_var / denom).sqrt() - } else { - 1.0 - } - + + let se_b1 = if denom != 0.0 { (eff_var / denom).sqrt() } else { 1.0 } + let mut sum_fitted = 0.0 for j = 0; j < n_samples; j = j + 1 { let x = dds.design[j][1] sum_fitted = sum_fitted + @math.exp(b0 + b1 * x) } base_mean.push(sum_fitted / n) - + log2_fold_change.push(b1 * @math.ln(2.0)) lfc_se.push(se_b1 * @math.ln(2.0)) - + let t_stat = if se_b1 > 0.0 { b1 / se_b1 } else { 0.0 } stat.push(t_stat) - + p_value.push(2.0 * (1.0 - pnorm(t_stat.abs()))) } - + let padj = deseq2_adjust_p_values(p_value) - + DESeqResults::new( dds.row_names, base_mean, @@ -336,12 +351,12 @@ fn deseq2_adjust_p_values(p_values : Array[Double]) -> Array[Double] { if n == 0 { return [] } - + let indices : Array[Int] = Array::new() for i = 0; i < n; i = i + 1 { indices.push(i) } - + let sorted_indices = Array::new() for idx in indices { sorted_indices.push(idx) @@ -355,9 +370,9 @@ fn deseq2_adjust_p_values(p_values : Array[Double]) -> Array[Double] { } } } - + let padj : Array[Double] = Array::make(n, 1.0) - + let mut min_padj = 1.0 let mut i = n - 1 while i >= 0 { @@ -369,7 +384,7 @@ fn deseq2_adjust_p_values(p_values : Array[Double]) -> Array[Double] { padj[sorted_indices[i]] = min_padj i = i - 1 } - + let final_padj : Array[Double] = Array::new() for p in padj { final_padj.push(if p > 1.0 { 1.0 } else { p }) @@ -378,25 +393,29 @@ fn deseq2_adjust_p_values(p_values : Array[Double]) -> Array[Double] { } ///| -pub fn lfc_shrink(dds : DESeqDataSet, res : DESeqResults, coef? : Int = -1) -> DESeqResults { +pub fn lfc_shrink( + dds : DESeqDataSet, + res : DESeqResults, + coef? : Int = -1, +) -> DESeqResults { let n_genes = dds.counts.length() - + let shrunk_lfc : Array[Double] = Array::new() let shrunk_se : Array[Double] = Array::new() - + let prior_var = 0.5 - + for i = 0; i < n_genes; i = i + 1 { let raw_lfc = res.log2_fold_change[i] let raw_se = res.lfc_se[i] - + let se2 = raw_se * raw_se let weight = se2 / (se2 + prior_var) - + shrunk_lfc.push(weight * raw_lfc) shrunk_se.push((se2 * prior_var / (se2 + prior_var)).sqrt()) } - + DESeqResults::new( res.row_names, res.base_mean, @@ -416,7 +435,8 @@ pub fn significant_genes( ) -> Array[String] { let genes : Array[String] = Array::new() for i = 0; i < results.row_names.length(); i = i + 1 { - if results.padj[i] < alpha && results.log2_fold_change[i].abs() > lfc_threshold { + if results.padj[i] < alpha && + results.log2_fold_change[i].abs() > lfc_threshold { genes.push(results.row_names[i]) } } @@ -424,15 +444,18 @@ pub fn significant_genes( } ///| -pub fn top_genes(results : DESeqResults, n? : Int = 10) -> Array[(String, Double, Double)] { +pub fn top_genes( + results : DESeqResults, + n? : Int = 10, +) -> Array[(String, Double, Double)] { let n_genes = results.row_names.length() let actual_n = if n < n_genes { n } else { n_genes } - + let indices : Array[Int] = Array::new() for i = 0; i < n_genes; i = i + 1 { indices.push(i) } - + let sorted_indices = Array::new() for idx in indices { sorted_indices.push(idx) @@ -446,11 +469,13 @@ pub fn top_genes(results : DESeqResults, n? : Int = 10) -> Array[(String, Double } } } - + let top : Array[(String, Double, Double)] = Array::new() for i = 0; i < actual_n; i = i + 1 { let idx = sorted_indices[i] - top.push((results.row_names[idx], results.log2_fold_change[idx], results.padj[idx])) + top.push( + (results.row_names[idx], results.log2_fold_change[idx], results.padj[idx]), + ) } top } @@ -458,34 +483,39 @@ pub fn top_genes(results : DESeqResults, n? : Int = 10) -> Array[(String, Double ///| pub fn sample_deseq_dataset() -> DESeqDataSet { let genes = [ - "GeneA", "GeneB", "GeneC", "GeneD", "GeneE", "GeneF", "GeneG", "GeneH", "GeneI", "GeneJ", - "GeneK", "GeneL", "GeneM", "GeneN", "GeneO", "GeneP", "GeneQ", "GeneR", "GeneS", "GeneT", + "GeneA", "GeneB", "GeneC", "GeneD", "GeneE", "GeneF", "GeneG", "GeneH", "GeneI", + "GeneJ", "GeneK", "GeneL", "GeneM", "GeneN", "GeneO", "GeneP", "GeneQ", "GeneR", + "GeneS", "GeneT", ] let samples = ["Ctrl1", "Ctrl2", "Ctrl3", "Treat1", "Treat2", "Treat3"] - + let counts : Array[Array[Int]] = Array::new() for i = 0; i < 20; i = i + 1 { let row : Array[Int] = Array::new() let base = 100.0 + i.to_double() * 50.0 - + for j = 0; j < 3; j = j + 1 { let noise = ((i * 7 + j * 13) % 20 - 10).to_double() * 0.1 row.push((base * (1.0 + noise)).to_int()) } - + for j = 3; j < 6; j = j + 1 { let fold_change = if i < 5 { 2.5 } else if i >= 15 { 0.4 } else { 1.0 } let noise = ((i * 7 + j * 13) % 20 - 10).to_double() * 0.1 row.push((base * fold_change * (1.0 + noise)).to_int()) } - + counts.push(row) } - + let design : Array[Array[Double]] = [ - [1.0, 0.0], [1.0, 0.0], [1.0, 0.0], - [1.0, 1.0], [1.0, 1.0], [1.0, 1.0], + [1.0, 0.0], + [1.0, 0.0], + [1.0, 0.0], + [1.0, 1.0], + [1.0, 1.0], + [1.0, 1.0], ] - + DESeqDataSet::new(counts, genes, samples, design) } diff --git a/src/deseq2_advanced.mbt b/src/deseq2_advanced.mbt index 2a073116..03a79ea3 100644 --- a/src/deseq2_advanced.mbt +++ b/src/deseq2_advanced.mbt @@ -139,11 +139,7 @@ pub fn vst(dds : DESeqDataSet, nsub? : Int = 1000) -> VSTResult { let mut sum_var_minus_mu = 0.0 let mut n_valid = 0 - let step = if n_genes > actual_nsub { - n_genes / actual_nsub - } else { - 1 - } + let step = if n_genes > actual_nsub { n_genes / actual_nsub } else { 1 } let mut i = 0 while i < n_genes && n_valid < actual_nsub { @@ -176,7 +172,13 @@ pub fn vst(dds : DESeqDataSet, nsub? : Int = 1000) -> VSTResult { let est_disp = if n_valid > 0 && sum_mu_sq > 0.0 { let d = sum_var_minus_mu / sum_mu_sq // Clamp to reasonable range - if d < 0.001 { 0.001 } else if d > 10.0 { 10.0 } else { d } + if d < 0.001 { + 0.001 + } else if d > 10.0 { + 10.0 + } else { + d + } } else { 0.1 } @@ -272,7 +274,10 @@ pub fn plot_pca(vst_result : VSTResult, ntop? : Int = 500) -> PCAResult { } // Compute covariance matrix (n_samples x n_samples) = X * X^T / (n_cols - 1) - let cov : Array[Array[Double]] = Array::make(n_samples, Array::make(n_samples, 0.0)) + let cov : Array[Array[Double]] = Array::make( + n_samples, + Array::make(n_samples, 0.0), + ) for i = 0; i < n_samples; i = i + 1 { for j = 0; j < n_samples; j = j + 1 { let mut dot = 0.0 @@ -431,7 +436,11 @@ fn normalize_vector(v : Array[Double], n : Int) -> Array[Double] { ///| /// Orthogonalize v against u (Gram-Schmidt). -fn orthogonalize(v : Array[Double], u : Array[Double], n : Int) -> Array[Double] { +fn orthogonalize( + v : Array[Double], + u : Array[Double], + n : Int, +) -> Array[Double] { let mut dot = 0.0 for i = 0; i < n; i = i + 1 { dot = dot + v[i] * u[i] diff --git a/src/destiny.mbt b/src/destiny.mbt index a15c438e..34014a50 100644 --- a/src/destiny.mbt +++ b/src/destiny.mbt @@ -48,45 +48,43 @@ pub struct DiffusionResult { pub fn CellData::new( cell_id : String, expression : Array[Double], - cluster : String + cluster : String, ) -> CellData { - CellData::{ - cell_id, - expression, - cluster - } + CellData::{ cell_id, expression, cluster } } ///| -pub fn DistanceMatrix::new(cells : Array[String], distances : Array[Array[Double]]) -> DistanceMatrix { +pub fn DistanceMatrix::new( + cells : Array[String], + distances : Array[Array[Double]], +) -> DistanceMatrix { let n = cells.length() - DistanceMatrix::{ - cells, - distances, - n_cells: n - } + DistanceMatrix::{ cells, distances, n_cells: n } } ///| -pub fn KernelMatrix::new(cells : Array[String], kernel : Array[Array[Double]], bandwidth : Double) -> KernelMatrix { - KernelMatrix::{ - cells, - kernel, - bandwidth - } +pub fn KernelMatrix::new( + cells : Array[String], + kernel : Array[Array[Double]], + bandwidth : Double, +) -> KernelMatrix { + KernelMatrix::{ cells, kernel, bandwidth } } ///| -pub fn compute_distance_matrix(cells : Array[CellData], metric : String) -> DistanceMatrix { +pub fn compute_distance_matrix( + cells : Array[CellData], + metric : String, +) -> DistanceMatrix { let n = cells.length() let cell_ids : Array[String] = Array::new() - + let mut i = 0 while i < n { cell_ids.push(cells[i].cell_id) i = i + 1 } - + // Compute pairwise distances let distances : Array[Array[Double]] = Array::new() i = 0 @@ -94,21 +92,29 @@ pub fn compute_distance_matrix(cells : Array[CellData], metric : String) -> Dist let row : Array[Double] = Array::new() let mut j = 0 while j < n { - let dist = destiny_compute_distance(cells[i].expression, cells[j].expression, metric) + let dist = destiny_compute_distance( + cells[i].expression, + cells[j].expression, + metric, + ) row.push(dist) j = j + 1 } distances.push(row) i = i + 1 } - + DistanceMatrix::new(cell_ids, distances) } ///| -fn destiny_compute_distance(a : Array[Double], b : Array[Double], metric : String) -> Double { +fn destiny_compute_distance( + a : Array[Double], + b : Array[Double], + metric : String, +) -> Double { let n = a.length() - + match metric { "euclidean" => { let mut sum = 0.0 @@ -145,10 +151,13 @@ fn destiny_compute_distance(a : Array[Double], b : Array[Double], metric : Strin } ///| -pub fn compute_gaussian_kernel(dist_matrix : DistanceMatrix, sigma : Double) -> KernelMatrix { +pub fn compute_gaussian_kernel( + dist_matrix : DistanceMatrix, + sigma : Double, +) -> KernelMatrix { let n = dist_matrix.n_cells let cells = dist_matrix.cells - + let kernel : Array[Array[Double]] = Array::new() let mut i = 0 while i < n { @@ -163,7 +172,7 @@ pub fn compute_gaussian_kernel(dist_matrix : DistanceMatrix, sigma : Double) -> kernel.push(row) i = i + 1 } - + KernelMatrix::new(cells, kernel, sigma) } @@ -173,7 +182,7 @@ pub fn find_sigma_automatic(dist_matrix : DistanceMatrix) -> Double { if n < 2 { return 1.0 } - + // Calculate pairwise distances and use median let distances : Array[Double] = Array::new() let mut i = 0 @@ -185,52 +194,64 @@ pub fn find_sigma_automatic(dist_matrix : DistanceMatrix) -> Double { } i = i + 1 } - + // Sort and get median let sorted = destiny_sort_array(distances) let len = sorted.length() if len == 0 { return 1.0 } - + let median_idx = len / 2 let median = if len % 2 == 0 { (sorted[median_idx - 1] + sorted[median_idx]) / 2.0 } else { sorted[median_idx] } - + // Use median as sigma - if median < 0.001 { 1.0 } else { median } + if median < 0.001 { + 1.0 + } else { + median + } } ///| -pub fn compute_diffusion_map(cells : Array[CellData], n_components : Int, sigma : Double) -> DiffusionResult { +pub fn compute_diffusion_map( + cells : Array[CellData], + n_components : Int, + sigma : Double, +) -> DiffusionResult { let n = cells.length() let cell_ids : Array[String] = Array::new() - + let mut i = 0 while i < n { cell_ids.push(cells[i].cell_id) i = i + 1 } - + // Step 1: Compute distance matrix let dist_matrix = compute_distance_matrix(cells, "euclidean") - + // Step 2: Compute kernel let kernel = compute_gaussian_kernel(dist_matrix, sigma) - + // Step 3: Normalize kernel (markov matrix) let markov = destiny_normalize_kernel(kernel) - + // Step 4: Compute eigendecomposition let n_comp = if n_components > n - 1 { n - 1 } else { n_components } let eigen_result = destiny_eigen_decomposition(markov.kernel, n_comp) - + // Step 5: Compute diffusion components - let embedding = destiny_compute_embedding(eigen_result.eigen_vectors, eigen_result.eigen_values, n_comp) - + let embedding = destiny_compute_embedding( + eigen_result.eigen_vectors, + eigen_result.eigen_values, + n_comp, + ) + // Calculate explained variance let total_var = destiny_sum_array(eigen_result.eigen_values) let explained_variance : Array[Double] = Array::new() @@ -244,12 +265,12 @@ pub fn compute_diffusion_map(cells : Array[CellData], n_components : Int, sigma explained_variance.push(var) j = j + 1 } - + DiffusionResult::{ embedding, eigenvalues: eigen_result.eigen_values, cell_ids, - explained_variance + explained_variance, } } @@ -257,27 +278,23 @@ pub fn compute_diffusion_map(cells : Array[CellData], n_components : Int, sigma fn destiny_normalize_kernel(kernel : KernelMatrix) -> KernelMatrix { let n = kernel.cells.length() let normalized : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let row = kernel.kernel[i] let row_sum = destiny_sum_array(row) - + let normalized_row : Array[Double] = Array::new() let mut j = 0 while j < n { - let val = if row_sum > 0.0 { - row[j] / row_sum - } else { - 0.0 - } + let val = if row_sum > 0.0 { row[j] / row_sum } else { 0.0 } normalized_row.push(val) j = j + 1 } normalized.push(normalized_row) i = i + 1 } - + KernelMatrix::new(kernel.cells, normalized, kernel.bandwidth) } @@ -288,26 +305,31 @@ struct EigenResult { } ///| -fn destiny_eigen_decomposition(matrix : Array[Array[Double]], n_components : Int) -> EigenResult { +fn destiny_eigen_decomposition( + matrix : Array[Array[Double]], + n_components : Int, +) -> EigenResult { let n = matrix.length() - + // Use power iteration for eigenvalue computation let eigen_values : Array[Double] = Array::new() let eigen_vectors : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_components { // Initialize random vector let mut vector : Array[Double] = Array::new() let mut j = 0 while j < n { - vector.push(destiny_random_vector_component(j.to_double() + i.to_double() * 100.0)) + vector.push( + destiny_random_vector_component(j.to_double() + i.to_double() * 100.0), + ) j = j + 1 } - + // Normalize vector = destiny_normalize_vector(vector) - + let mut lambda = 0.0 let mut iteration = 0 while iteration < 50 { @@ -324,15 +346,15 @@ fn destiny_eigen_decomposition(matrix : Array[Array[Double]], n_components : Int new_vector.push(sum) k = k + 1 } - + lambda = destiny_vector_norm(new_vector) vector = destiny_normalize_vector(new_vector) - + iteration = iteration + 1 } - + eigen_values.push(lambda) - + // Store eigenvector let ev : Array[Double] = Array::new() let mut m = 0 @@ -341,7 +363,7 @@ fn destiny_eigen_decomposition(matrix : Array[Array[Double]], n_components : Int m = m + 1 } eigen_vectors.push(ev) - + // Deflate matrix let deflated : Array[Array[Double]] = Array::new() let mut p = 0 @@ -356,29 +378,34 @@ fn destiny_eigen_decomposition(matrix : Array[Array[Double]], n_components : Int deflated.push(row) p = p + 1 } - + // Update matrix for next iteration // Note: This modifies the original - in production would need copy // For simplicity, we re-assign - let _ = deflated // Just for reference - + let _ = deflated // Just for reference + i = i + 1 } - - EigenResult::{ - eigen_values, - eigen_vectors - } + + EigenResult::{ eigen_values, eigen_vectors } } ///| -fn destiny_compute_embedding(eigen_vectors : Array[Array[Double]], eigen_values : Array[Double], n_components : Int) -> Array[Array[Double]] { +fn destiny_compute_embedding( + eigen_vectors : Array[Array[Double]], + eigen_values : Array[Double], + n_components : Int, +) -> Array[Array[Double]] { // eigen_vectors has shape [n_components][n_cells] let n_components_actual = eigen_vectors.length() - let n_cells = if n_components_actual > 0 { eigen_vectors[0].length() } else { 0 } - + let n_cells = if n_components_actual > 0 { + eigen_vectors[0].length() + } else { + 0 + } + let embedding : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_cells { let cell_embedding : Array[Double] = Array::new() @@ -395,25 +422,32 @@ fn destiny_compute_embedding(eigen_vectors : Array[Array[Double]], eigen_values embedding.push(cell_embedding) i = i + 1 } - + embedding } ///| -pub fn destiny_create_embedding(cells : Array[CellData], n_components : Int) -> DiffusionResult { +pub fn destiny_create_embedding( + cells : Array[CellData], + n_components : Int, +) -> DiffusionResult { // Find optimal sigma let dist_matrix = compute_distance_matrix(cells, "euclidean") let sigma = find_sigma_automatic(dist_matrix) - + // Compute diffusion map compute_diffusion_map(cells, n_components, sigma) } ///| -pub fn destiny_plot_coordinates(result : DiffusionResult, component_x : Int, component_y : Int) -> Array[(String, Double, Double)] { +pub fn destiny_plot_coordinates( + result : DiffusionResult, + component_x : Int, + component_y : Int, +) -> Array[(String, Double, Double)] { let coordinates : Array[(String, Double, Double)] = Array::new() let n = result.cell_ids.length() - + let mut i = 0 while i < n { let x = result.embedding[i][component_x] @@ -421,7 +455,7 @@ pub fn destiny_plot_coordinates(result : DiffusionResult, component_x : Int, com coordinates.push((result.cell_ids[i], x, y)) i = i + 1 } - + coordinates } @@ -429,24 +463,35 @@ pub fn destiny_plot_coordinates(result : DiffusionResult, component_x : Int, com pub fn destiny_summary(result : DiffusionResult) -> String { let mut summary = "\nDiffusion Map Summary\n" summary = summary + "==============================\n" - summary = summary + "Number of cells: " + result.cell_ids.length().to_string() + "\n" - summary = summary + "Number of components: " + result.eigenvalues.length().to_string() + "\n" - + summary = summary + + "Number of cells: " + + result.cell_ids.length().to_string() + + "\n" + summary = summary + + "Number of components: " + + result.eigenvalues.length().to_string() + + "\n" + let mut i = 0 while i < result.eigenvalues.length() { - summary = summary + "Component " + (i + 1).to_string() + - ": eigenvalue = " + result.eigenvalues[i].to_string() + - ", explained variance = " + (result.explained_variance[i] * 100.0).to_string() + "%\n" + summary = summary + + "Component " + + (i + 1).to_string() + + ": eigenvalue = " + + result.eigenvalues[i].to_string() + + ", explained variance = " + + (result.explained_variance[i] * 100.0).to_string() + + "%\n" i = i + 1 } - + summary } ///| pub fn create_example_sc_data(n_cells : Int, n_genes : Int) -> Array[CellData] { let cells : Array[CellData] = Array::new() - + let mut i = 0 while i < n_cells { let expression : Array[Double] = Array::new() @@ -459,22 +504,27 @@ pub fn create_example_sc_data(n_cells : Int, n_genes : Int) -> Array[CellData] { expression.push(base + noise) j = j + 1 } - + let cell = CellData::new( "cell_" + i.to_string(), expression, - if i < n_cells / 2 { "cluster_1" } else { "cluster_2" } + if i < n_cells / 2 { + "cluster_1" + } else { + "cluster_2" + }, ) - + cells.push(cell) i = i + 1 } - + cells } // Helper functions +///| fn destiny_sort_array(arr : Array[Double]) -> Array[Double] { let sorted = arr // Simple bubble sort for small arrays @@ -495,6 +545,7 @@ fn destiny_sort_array(arr : Array[Double]) -> Array[Double] { sorted } +///| fn destiny_sum_array(arr : Array[Double]) -> Double { let mut sum = 0.0 let mut i = 0 @@ -505,6 +556,7 @@ fn destiny_sum_array(arr : Array[Double]) -> Double { sum } +///| fn destiny_normalize_vector(v : Array[Double]) -> Array[Double] { let norm = destiny_vector_norm(v) if norm == 0.0 { @@ -516,7 +568,7 @@ fn destiny_normalize_vector(v : Array[Double]) -> Array[Double] { } return result } - + let normalized : Array[Double] = Array::new() let mut i = 0 while i < v.length() { @@ -526,6 +578,7 @@ fn destiny_normalize_vector(v : Array[Double]) -> Array[Double] { normalized } +///| fn destiny_vector_norm(v : Array[Double]) -> Double { let mut sum = 0.0 let mut i = 0 @@ -536,9 +589,16 @@ fn destiny_vector_norm(v : Array[Double]) -> Double { sum.sqrt() } +///| fn destiny_random_vector_component(seed : Double) -> Double { // Simple deterministic pseudo-random generator let raw = seed * 99991.0 let x = (raw - raw.floor()) * 2.0 - 1.0 - if x < -1.0 { -1.0 } else if x > 1.0 { 1.0 } else { x } + if x < -1.0 { + -1.0 + } else if x > 1.0 { + 1.0 + } else { + x + } } diff --git a/src/dexseq.mbt b/src/dexseq.mbt index d1137602..7cad1226 100644 --- a/src/dexseq.mbt +++ b/src/dexseq.mbt @@ -9,7 +9,11 @@ pub struct ExonCount { } ///| -pub fn ExonCount::new(gene_id : String, exon_id : String, counts : Array[Int]) -> ExonCount { +pub fn ExonCount::new( + gene_id : String, + exon_id : String, + counts : Array[Int], +) -> ExonCount { ExonCount::{ gene_id, exon_id, counts } } @@ -21,17 +25,20 @@ pub struct DEXSeqDataSet { } ///| -pub fn DEXSeqDataSet::new(exon_counts : Array[ExonCount], sample_groups : Array[String]) -> DEXSeqDataSet { +pub fn DEXSeqDataSet::new( + exon_counts : Array[ExonCount], + sample_groups : Array[String], +) -> DEXSeqDataSet { let gene_ids : Array[String] = Array::new() let seen : Map[String, Bool] = Map([], capacity=100) - + for ec in exon_counts { if !seen.contains(ec.gene_id) { seen.set(ec.gene_id, true) gene_ids.push(ec.gene_id) } } - + DEXSeqDataSet::{ exon_counts, sample_groups, gene_ids } } @@ -48,14 +55,32 @@ pub struct DEXSeqResult { } ///| -pub fn DEXSeqResult::new(gene_id : String, exon_id : String, base_mean : Double, log2_fold_change : Double, lfc_se : Double, stat : Double, p_value : Double, adjusted_p_value : Double) -> DEXSeqResult { - DEXSeqResult::{ gene_id, exon_id, base_mean, log2_fold_change, lfc_se, stat, p_value, adjusted_p_value } +pub fn DEXSeqResult::new( + gene_id : String, + exon_id : String, + base_mean : Double, + log2_fold_change : Double, + lfc_se : Double, + stat : Double, + p_value : Double, + adjusted_p_value : Double, +) -> DEXSeqResult { + DEXSeqResult::{ + gene_id, + exon_id, + base_mean, + log2_fold_change, + lfc_se, + stat, + p_value, + adjusted_p_value, + } } ///| pub fn dexseq_normalize_counts(dataset : DEXSeqDataSet) -> DEXSeqDataSet { let normalized : Array[ExonCount] = Array::new() - + for ec in dataset.exon_counts { let mut total = 0 let mut i = 0 @@ -66,24 +91,30 @@ pub fn dexseq_normalize_counts(dataset : DEXSeqDataSet) -> DEXSeqDataSet { if total > 0 { let norm_counts : Array[Int] = Array::new() for count in ec.counts { - norm_counts.push((count * 1000000 / total)) + norm_counts.push(count * 1000000 / total) } normalized.push(ExonCount::new(ec.gene_id, ec.exon_id, norm_counts)) } else { normalized.push(ec) } } - - DEXSeqDataSet::{ exon_counts: normalized, sample_groups: dataset.sample_groups, gene_ids: dataset.gene_ids } + + DEXSeqDataSet::{ + exon_counts: normalized, + sample_groups: dataset.sample_groups, + gene_ids: dataset.gene_ids, + } } ///| -pub fn dexseq_test_for_exon_usage(dataset : DEXSeqDataSet) -> Array[DEXSeqResult] { +pub fn dexseq_test_for_exon_usage( + dataset : DEXSeqDataSet, +) -> Array[DEXSeqResult] { let results : Array[DEXSeqResult] = Array::new() - + let group0_indices : Array[Int] = Array::new() let group1_indices : Array[Int] = Array::new() - + let mut i = 0 while i < dataset.sample_groups.length() { if dataset.sample_groups[i] == "control" { @@ -93,39 +124,47 @@ pub fn dexseq_test_for_exon_usage(dataset : DEXSeqDataSet) -> Array[DEXSeqResult } i = i + 1 } - + for ec in dataset.exon_counts { let mut group0_sum = 0 for idx in group0_indices { group0_sum = group0_sum + ec.counts[idx] } - + let mut group1_sum = 0 for idx in group1_indices { group1_sum = group1_sum + ec.counts[idx] } - + let n0 = group0_indices.length() let n1 = group1_indices.length() - - let mean0 = if n0 > 0 { group0_sum.to_double() / n0.to_double() } else { 0.0 } - let mean1 = if n1 > 0 { group1_sum.to_double() / n1.to_double() } else { 0.0 } - + + let mean0 = if n0 > 0 { + group0_sum.to_double() / n0.to_double() + } else { + 0.0 + } + let mean1 = if n1 > 0 { + group1_sum.to_double() / n1.to_double() + } else { + 0.0 + } + let base_mean = (mean0 + mean1) / 2.0 - + let log2_fc = if mean0 > 0.0 && mean1 > 0.0 { - @math.log2(mean1 / mean0) - } else { - 0.0 - } - + @math.log2(mean1 / mean0) + } else { + 0.0 + } + let lfc_se = 0.1 let stat = log2_fc / lfc_se - + let p_value = 1.0 / (1.0 + stat * stat) - + let adjusted_p = p_value * 0.1 - + let result = DEXSeqResult::new( ec.gene_id, ec.exon_id, @@ -134,38 +173,45 @@ pub fn dexseq_test_for_exon_usage(dataset : DEXSeqDataSet) -> Array[DEXSeqResult lfc_se, stat, p_value, - adjusted_p + adjusted_p, ) results.push(result) } - + results } ///| -pub fn dexseq_filter_results(results : Array[DEXSeqResult], min_log2fc : Double, max_padj : Double) -> Array[DEXSeqResult] { +pub fn dexseq_filter_results( + results : Array[DEXSeqResult], + min_log2fc : Double, + max_padj : Double, +) -> Array[DEXSeqResult] { let filtered : Array[DEXSeqResult] = Array::new() - + for result in results { - if result.log2_fold_change.abs() >= min_log2fc && result.adjusted_p_value <= max_padj { + if result.log2_fold_change.abs() >= min_log2fc && + result.adjusted_p_value <= max_padj { filtered.push(result) } } - + filtered } ///| pub fn create_example_dexseq_dataset() -> DEXSeqDataSet { let exon_counts : Array[ExonCount] = Array::new() - + exon_counts.push(ExonCount::new("gene1", "exon1", [10, 12, 15, 8, 25, 30])) exon_counts.push(ExonCount::new("gene1", "exon2", [5, 6, 7, 4, 10, 12])) exon_counts.push(ExonCount::new("gene1", "exon3", [20, 22, 25, 18, 15, 12])) exon_counts.push(ExonCount::new("gene2", "exon1", [8, 10, 12, 6, 8, 10])) exon_counts.push(ExonCount::new("gene2", "exon2", [15, 18, 20, 12, 25, 30])) - - let sample_groups = ["control", "control", "control", "treatment", "treatment", "treatment"] - + + let sample_groups = [ + "control", "control", "control", "treatment", "treatment", "treatment", + ] + DEXSeqDataSet::new(exon_counts, sample_groups) -} \ No newline at end of file +} diff --git a/src/diffbind.mbt b/src/diffbind.mbt index fd0e3c02..ed1f9ac1 100644 --- a/src/diffbind.mbt +++ b/src/diffbind.mbt @@ -1411,7 +1411,10 @@ fn diffbind_transpose(matrix : Array[Array[Double]]) -> Array[Array[Double]] { } let n_rows = matrix.length() let n_cols = matrix[0].length() - let transposed : Array[Array[Double]] = Array::make(n_cols, Array::make(n_rows, 0.0)) + let transposed : Array[Array[Double]] = Array::make( + n_cols, + Array::make(n_rows, 0.0), + ) let mut i = 0 while i < n_rows { let mut j = 0 @@ -1441,7 +1444,10 @@ fn diffbind_mean(arr : Array[Double]) -> Double { ///| /// Extract column from matrix. -fn diffbind_extract_column(matrix : Array[Array[Double]], col_idx : Int) -> Array[Double] { +fn diffbind_extract_column( + matrix : Array[Array[Double]], + col_idx : Int, +) -> Array[Double] { let n_rows = matrix.length() let col : Array[Double] = Array::make(n_rows, 0.0) let mut i = 0 @@ -1502,15 +1508,20 @@ fn diffbind_correlation(x : Array[Double], y : Array[Double]) -> Double { ///| /// Compute PCA on a matrix (samples x peaks). /// Returns principal components (samples x components) and explained variance ratios. -fn diffbind_pca(matrix : Array[Array[Double]]) -> (Array[Array[Double]], Array[Double]) { +fn diffbind_pca( + matrix : Array[Array[Double]], +) -> (Array[Array[Double]], Array[Double]) { if matrix.length() == 0 || matrix[0].length() == 0 { return (Array::new(), Array::new()) } let n_samples = matrix.length() let n_peaks = matrix[0].length() let k = if n_samples < n_peaks { n_samples - 1 } else { 3 } - - let centered : Array[Array[Double]] = Array::make(n_samples, Array::make(n_peaks, 0.0)) + + let centered : Array[Array[Double]] = Array::make( + n_samples, + Array::make(n_peaks, 0.0), + ) let mut p = 0 while p < n_peaks { let peak_values : Array[Double] = Array::make(n_samples, 0.0) @@ -1527,8 +1538,11 @@ fn diffbind_pca(matrix : Array[Array[Double]]) -> (Array[Array[Double]], Array[D } p = p + 1 } - - let cov_matrix : Array[Array[Double]] = Array::make(n_peaks, Array::make(n_peaks, 0.0)) + + let cov_matrix : Array[Array[Double]] = Array::make( + n_peaks, + Array::make(n_peaks, 0.0), + ) let mut i = 0 while i < n_peaks { let mut j = i @@ -1542,15 +1556,15 @@ fn diffbind_pca(matrix : Array[Array[Double]]) -> (Array[Array[Double]], Array[D } i = i + 1 } - + let eigvals : Array[Double] = Array::make(k, 0.0) let eigvecs : Array[Array[Double]] = Array::make(k, Array::make(n_peaks, 0.0)) - + let mut comp = 0 while comp < k { let init_val = 1.0 / diffbind_sqrt(n_peaks.to_double()) let mut vec : Array[Double] = Array::make(n_peaks, init_val) - + let mut val = 0.0 let mut iter = 0 while iter < 100 { @@ -1566,16 +1580,16 @@ fn diffbind_pca(matrix : Array[Array[Double]]) -> (Array[Array[Double]], Array[D new_vec[p2] = sum p2 = p2 + 1 } - + let mut sum_sq = 0.0 let mut idx = 0 while idx < new_vec.length() { sum_sq = sum_sq + new_vec[idx] * new_vec[idx] idx = idx + 1 } - + let norm = diffbind_sqrt(sum_sq) - + let new_vec_norm : Array[Double] = Array::make(n_peaks, 0.0) if norm > 0.0 { let mut n_idx = 0 @@ -1584,12 +1598,12 @@ fn diffbind_pca(matrix : Array[Array[Double]]) -> (Array[Array[Double]], Array[D n_idx = n_idx + 1 } } - + vec = new_vec_norm val = sum_sq iter = iter + 1 } - + eigvals[comp] = val let mut v_idx = 0 while v_idx < n_peaks { @@ -1598,7 +1612,7 @@ fn diffbind_pca(matrix : Array[Array[Double]]) -> (Array[Array[Double]], Array[D } comp = comp + 1 } - + let mut total_var = 0.0 let mut r_idx = 0 while r_idx < cov_matrix.length() { @@ -1609,15 +1623,22 @@ fn diffbind_pca(matrix : Array[Array[Double]]) -> (Array[Array[Double]], Array[D } r_idx = r_idx + 1 } - + let explained_var : Array[Double] = Array::make(k, 0.0) let mut ev_idx = 0 while ev_idx < k { - explained_var[ev_idx] = if total_var > 0.0 { eigvals[ev_idx] / total_var } else { 0.0 } + explained_var[ev_idx] = if total_var > 0.0 { + eigvals[ev_idx] / total_var + } else { + 0.0 + } ev_idx = ev_idx + 1 } - - let pc_scores : Array[Array[Double]] = Array::make(n_samples, Array::make(k, 0.0)) + + let pc_scores : Array[Array[Double]] = Array::make( + n_samples, + Array::make(k, 0.0), + ) let mut s2 = 0 while s2 < n_samples { let mut comp2 = 0 @@ -1633,7 +1654,7 @@ fn diffbind_pca(matrix : Array[Array[Double]]) -> (Array[Array[Double]], Array[D } s2 = s2 + 1 } - + (pc_scores, explained_var) } @@ -1646,54 +1667,77 @@ pub fn diffbind_plot_pca(config : DBAConfig, method : String) -> String { } let counts = diffbind_normalize(config, method) let matrix = diffbind_transpose(counts) - + let (pc_scores, explained_var) = diffbind_pca(matrix) if pc_scores.length() == 0 || explained_var.length() < 2 { return "PCA Plot: Insufficient data for PCA\n" } - + let mut plot = "PCA Plot\n" plot = plot + "========\n\n" - plot = plot + "PC1: " + (explained_var[0] * 100.0).to_string() + "% variance\n" - plot = plot + "PC2: " + (explained_var[1] * 100.0).to_string() + "% variance\n\n" - + plot = plot + + "PC1: " + + (explained_var[0] * 100.0).to_string() + + "% variance\n" + plot = plot + + "PC2: " + + (explained_var[1] * 100.0).to_string() + + "% variance\n\n" + let mut min_x = pc_scores[0][0] let mut max_x = pc_scores[0][0] let mut min_y = pc_scores[0][1] let mut max_y = pc_scores[0][1] let mut i = 1 while i < pc_scores.length() { - if pc_scores[i][0] < min_x { min_x = pc_scores[i][0] } - if pc_scores[i][0] > max_x { max_x = pc_scores[i][0] } - if pc_scores[i][1] < min_y { min_y = pc_scores[i][1] } - if pc_scores[i][1] > max_y { max_y = pc_scores[i][1] } + if pc_scores[i][0] < min_x { + min_x = pc_scores[i][0] + } + if pc_scores[i][0] > max_x { + max_x = pc_scores[i][0] + } + if pc_scores[i][1] < min_y { + min_y = pc_scores[i][1] + } + if pc_scores[i][1] > max_y { + max_y = pc_scores[i][1] + } i = i + 1 } - + let padding = 0.1 min_x = min_x - (max_x - min_x) * padding max_x = max_x + (max_x - min_x) * padding min_y = min_y - (max_y - min_y) * padding max_y = max_y + (max_y - min_y) * padding - + let width = 40 let height = 20 - - let canvas : Array[Array[String]] = Array::make(height, Array::make(width, " ")) - + + let canvas : Array[Array[String]] = Array::make( + height, + Array::make(width, " "), + ) + let mut s = 0 while s < pc_scores.length() { let x = pc_scores[s][0] let y = pc_scores[s][1] let px = ((x - min_x) / (max_x - min_x) * (width - 1).to_double()).to_int() - let py = height - 1 - ((y - min_y) / (max_y - min_y) * (height - 1).to_double()).to_int() + let py = height - + 1 - + ((y - min_y) / (max_y - min_y) * (height - 1).to_double()).to_int() if px >= 0 && px < width && py >= 0 && py < height { let sample = config.samples[s] - canvas[py][px] = if sample.condition == config.conditions[0] { "A" } else { "B" } + canvas[py][px] = if sample.condition == config.conditions[0] { + "A" + } else { + "B" + } } s = s + 1 } - + plot = plot + "Y\n" let mut row = height - 1 while row >= 0 { @@ -1708,7 +1752,7 @@ pub fn diffbind_plot_pca(config : DBAConfig, method : String) -> String { } plot = plot + "+" + "-".repeat(width) + "+\n" plot = plot + "X\n\n" - + let colors : Map[String, String] = Map([], capacity=2) let mut cond_idx = 0 while cond_idx < config.conditions.length() { @@ -1722,7 +1766,7 @@ pub fn diffbind_plot_pca(config : DBAConfig, method : String) -> String { } cond_idx = cond_idx + 1 } - + plot = plot + "Legend:\n" let keys = colors.keys().collect() let mut k = 0 @@ -1730,7 +1774,7 @@ pub fn diffbind_plot_pca(config : DBAConfig, method : String) -> String { plot = plot + " " + colors[keys[k]] + " = " + keys[k] + "\n" k = k + 1 } - + plot } @@ -1740,26 +1784,34 @@ pub fn diffbind_plot_heatmap(result : DBAResult, top_n : Int) -> String { if result.peaks.length() == 0 { return "Heatmap: No peaks in result\n" } - - let n = if top_n < result.peaks.length() { top_n } else { result.peaks.length() } - + + let n = if top_n < result.peaks.length() { + top_n + } else { + result.peaks.length() + } + let mut heatmap = "Differential Binding Heatmap\n" heatmap = heatmap + "============================\n\n" heatmap = heatmap + "Top " + n.to_string() + " peaks\n\n" - + let width = if n > 30 { 30 } else { n } let height = 10 - + let mut min_fc = result.fold_changes[0] let mut max_fc = result.fold_changes[0] let mut i = 1 while i < result.fold_changes.length() { let fc = result.fold_changes[i] - if fc < min_fc { min_fc = fc } - if fc > max_fc { max_fc = fc } + if fc < min_fc { + min_fc = fc + } + if fc > max_fc { + max_fc = fc + } i = i + 1 } - + let mut row = 0 while row < height { heatmap = heatmap + "|" @@ -1768,17 +1820,35 @@ pub fn diffbind_plot_heatmap(result : DBAResult, top_n : Int) -> String { let idx = col % result.fold_changes.length() let fc = result.fold_changes[idx] let norm = (fc - min_fc) / (max_fc - min_fc + 0.0001) - let char = if norm < 0.2 { " " } else if norm < 0.4 { "." } else if norm < 0.6 { "+" } else if norm < 0.8 { "*" } else { "#" } + let char = if norm < 0.2 { + " " + } else if norm < 0.4 { + "." + } else if norm < 0.6 { + "+" + } else if norm < 0.8 { + "*" + } else { + "#" + } heatmap = heatmap + char col = col + 1 } heatmap = heatmap + "|\n" row = row + 1 } - + heatmap = heatmap + "\nColor scale (log2 fold change):\n" - heatmap = heatmap + " " + min_fc.to_string() + " <-" + " ".repeat(8) + ". + * #" + "-> " + max_fc.to_string() + "\n" - + heatmap = heatmap + + " " + + min_fc.to_string() + + " <-" + + " ".repeat(8) + + ". + * #" + + "-> " + + max_fc.to_string() + + "\n" + heatmap } @@ -1789,33 +1859,44 @@ pub fn diffbind_plot_volcano(result : DBAResult) -> String { if data.length() == 0 { return "Volcano Plot: No data\n" } - + let mut min_fc = data[0].0 let mut max_fc = data[0].0 let mut max_neg_log_p = data[0].1 let mut i = 1 while i < data.length() { - if data[i].0 < min_fc { min_fc = data[i].0 } - if data[i].0 > max_fc { max_fc = data[i].0 } - if data[i].1 > max_neg_log_p { max_neg_log_p = data[i].1 } + if data[i].0 < min_fc { + min_fc = data[i].0 + } + if data[i].0 > max_fc { + max_fc = data[i].0 + } + if data[i].1 > max_neg_log_p { + max_neg_log_p = data[i].1 + } i = i + 1 } - + let padding = 0.1 min_fc = min_fc - (max_fc - min_fc) * padding max_fc = max_fc + (max_fc - min_fc) * padding max_neg_log_p = max_neg_log_p + max_neg_log_p * padding - + let width = 50 let height = 20 - - let canvas : Array[Array[String]] = Array::make(height, Array::make(width, " ")) - + + let canvas : Array[Array[String]] = Array::make( + height, + Array::make(width, " "), + ) + let mut j = 0 while j < data.length() { let (fc, neg_log_p) = data[j] let px = ((fc - min_fc) / (max_fc - min_fc) * (width - 1).to_double()).to_int() - let py = height - 1 - (neg_log_p / max_neg_log_p * (height - 1).to_double()).to_int() + let py = height - + 1 - + (neg_log_p / max_neg_log_p * (height - 1).to_double()).to_int() if px >= 0 && px < width && py >= 0 && py < height { let idx = j let fdr = result.fdrs[idx] @@ -1823,7 +1904,7 @@ pub fn diffbind_plot_volcano(result : DBAResult) -> String { } j = j + 1 } - + let mid_x = ((0.0 - min_fc) / (max_fc - min_fc) * (width - 1).to_double()).to_int() let mut row = height - 1 while row >= 0 { @@ -1834,12 +1915,12 @@ pub fn diffbind_plot_volcano(result : DBAResult) -> String { } row = row - 1 } - + let mut plot = "Volcano Plot\n" plot = plot + "============\n\n" plot = plot + "Y: -log10(p-value)\n" plot = plot + "X: log2(fold change)\n\n" - + row = height - 1 while row >= 0 { plot = plot + "|" @@ -1851,13 +1932,18 @@ pub fn diffbind_plot_volcano(result : DBAResult) -> String { plot = plot + "|\n" row = row - 1 } - plot = plot + "+" + "-".repeat(mid_x) + "+" + "-".repeat(width - mid_x - 1) + "+\n" + plot = plot + + "+" + + "-".repeat(mid_x) + + "+" + + "-".repeat(width - mid_x - 1) + + "+\n" plot = plot + "X\n\n" - + plot = plot + "Legend:\n" plot = plot + " * = Significant (FDR < 0.05)\n" plot = plot + " . = Not significant\n\n" - + let mut sig_count = 0 let mut up_count = 0 let mut down_count = 0 @@ -1873,13 +1959,13 @@ pub fn diffbind_plot_volcano(result : DBAResult) -> String { } k = k + 1 } - + plot = plot + "Summary:\n" plot = plot + " Total peaks: " + result.peaks.length().to_string() + "\n" plot = plot + " Significant (FDR < 0.05): " + sig_count.to_string() + "\n" plot = plot + " Up-regulated: " + up_count.to_string() + "\n" plot = plot + " Down-regulated: " + down_count.to_string() + "\n" - + plot } @@ -1890,36 +1976,51 @@ pub fn diffbind_plot_ma(result : DBAResult) -> String { if data.length() == 0 { return "MA Plot: No data\n" } - + let mut min_mean = data[0].0 let mut max_mean = data[0].0 let mut min_fc = data[0].1 let mut max_fc = data[0].1 let mut i = 1 while i < data.length() { - if data[i].0 < min_mean { min_mean = data[i].0 } - if data[i].0 > max_mean { max_mean = data[i].0 } - if data[i].1 < min_fc { min_fc = data[i].1 } - if data[i].1 > max_fc { max_fc = data[i].1 } + if data[i].0 < min_mean { + min_mean = data[i].0 + } + if data[i].0 > max_mean { + max_mean = data[i].0 + } + if data[i].1 < min_fc { + min_fc = data[i].1 + } + if data[i].1 > max_fc { + max_fc = data[i].1 + } i = i + 1 } - + let padding = 0.1 min_mean = min_mean - (max_mean - min_mean) * padding max_mean = max_mean + (max_mean - min_mean) * padding min_fc = min_fc - (max_fc - min_fc) * padding max_fc = max_fc + (max_fc - min_fc) * padding - + let width = 50 let height = 20 - - let canvas : Array[Array[String]] = Array::make(height, Array::make(width, " ")) - + + let canvas : Array[Array[String]] = Array::make( + height, + Array::make(width, " "), + ) + let mut j = 0 while j < data.length() { let (mean_log2, fc) = data[j] - let px = ((mean_log2 - min_mean) / (max_mean - min_mean) * (width - 1).to_double()).to_int() - let py = height - 1 - ((fc - min_fc) / (max_fc - min_fc) * (height - 1).to_double()).to_int() + let px = ((mean_log2 - min_mean) / + (max_mean - min_mean) * + (width - 1).to_double()).to_int() + let py = height - + 1 - + ((fc - min_fc) / (max_fc - min_fc) * (height - 1).to_double()).to_int() if px >= 0 && px < width && py >= 0 && py < height { let idx = j let fdr = result.fdrs[idx] @@ -1927,7 +2028,7 @@ pub fn diffbind_plot_ma(result : DBAResult) -> String { } j = j + 1 } - + let mid_y = ((0.0 - min_fc) / (max_fc - min_fc) * (height - 1).to_double()).to_int() let mut row = height - 1 while row >= 0 { @@ -1940,12 +2041,12 @@ pub fn diffbind_plot_ma(result : DBAResult) -> String { } row = row - 1 } - + let mut plot = "MA Plot\n" plot = plot + "=======\n\n" plot = plot + "Y: log2(fold change)\n" plot = plot + "X: log2(mean expression)\n\n" - + row = height - 1 while row >= 0 { plot = plot + "|" @@ -1959,11 +2060,11 @@ pub fn diffbind_plot_ma(result : DBAResult) -> String { } plot = plot + "+" + "-".repeat(width) + "+\n" plot = plot + "X\n\n" - + plot = plot + "Legend:\n" plot = plot + " * = Significant (FDR < 0.05)\n" plot = plot + " . = Not significant\n" - + plot } diff --git a/src/diffcyt.mbt b/src/diffcyt.mbt index 6d36648d..3f3d6b3c 100644 --- a/src/diffcyt.mbt +++ b/src/diffcyt.mbt @@ -32,7 +32,7 @@ pub fn CytometryCell::new( cell_id : String, sample_id : String, condition : String, - marker_values : Array[Double] + marker_values : Array[Double], ) -> CytometryCell { CytometryCell::{ cell_id, @@ -289,7 +289,12 @@ fn dc_normal_cdf(x : Double) -> Double { } let t = 1.0 / (1.0 + 0.2316419 * dc_abs(x)) let d = 0.3989423 * @math.exp(-x * x / 2.0) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))) + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))) + ) if x >= 0.0 { 1.0 - p } else { @@ -336,7 +341,7 @@ fn dc_lcg_rand(state : Int) -> (Int, Double) { pub fn diffcyt_cluster_cells( cells : Array[CytometryCell], n_clusters : Int, - n_iterations : Int + n_iterations : Int, ) -> Array[Array[Double]] { let n_cells = cells.length() if n_cells == 0 || n_clusters <= 0 { @@ -375,7 +380,8 @@ pub fn diffcyt_cluster_cells( } // Update BMU toward the cell. for j in 0.. Unit { let n_clusters = codebooks.length() for ci in 0.. Array[Array[Int]] { let n_samples = sample_ids.length() // counts[sample_idx][cluster_idx] @@ -461,7 +467,7 @@ pub fn diffcyt_calc_medians_by_cluster_marker( cells : Array[CytometryCell], n_clusters : Int, n_markers : Int, - sample_ids : Array[String] + sample_ids : Array[String], ) -> Array[Array[Double]] { let n_samples = sample_ids.length() // Collect expression values per (sample, cluster, marker). @@ -541,7 +547,7 @@ fn dc_median(arr : Array[Double]) -> Double { /// indicator columns. Returns design[sample_idx][col_idx]. pub fn diffcyt_create_design_matrix( sample_ids : Array[String], - conditions : Array[String] + conditions : Array[String], ) -> Array[Array[Double]] { let n = sample_ids.length() // Collect unique conditions preserving order. @@ -609,7 +615,7 @@ pub fn diffcyt_testDA( counts : Array[Array[Int]], design : Array[Array[Double]], contrast_col : Int, - n_clusters : Int + n_clusters : Int, ) -> Array[DiffcytDAResult] { let n_samples = counts.length() let results : Array[DiffcytDAResult] = Array::new() @@ -736,7 +742,13 @@ pub fn diffcyt_testDA( // Wald test. let wald_stat = beta[contrast_col] / se let p_value = 2.0 * (1.0 - dc_normal_cdf(dc_abs(wald_stat))) - let p_value = if p_value < 0.0 { 0.0 } else if p_value > 1.0 { 1.0 } else { p_value } + let p_value = if p_value < 0.0 { + 0.0 + } else if p_value > 1.0 { + 1.0 + } else { + p_value + } results.push(DiffcytDAResult::{ cluster_id: cluster, log_fc: beta[contrast_col], @@ -770,12 +782,12 @@ pub fn diffcyt_testDS( conditions : Array[String], n_clusters : Int, n_markers : Int, - marker_names : Array[String] + marker_names : Array[String], ) -> Array[DiffcytDSResult] { let n_samples = sample_ids.length() // Collect per-sample-per-cluster-per-marker median expression. let medians = diffcyt_calc_medians_by_cluster_marker( - cells, n_clusters, n_markers, sample_ids + cells, n_clusters, n_markers, sample_ids, ) // Collect unique conditions. let unique_conditions : Array[String] = Array::new() @@ -820,15 +832,12 @@ pub fn diffcyt_testDS( let mut total_df = 0.0 for ci in 0.. 1 { - pooled_var = pooled_var + group_vars[ci] * (group_ns[ci] - 1).to_double() + pooled_var = pooled_var + + group_vars[ci] * (group_ns[ci] - 1).to_double() total_df = total_df + (group_ns[ci] - 1).to_double() } } - let pooled_var = if total_df > 0.0 { - pooled_var / total_df - } else { - 1.0 - } + let pooled_var = if total_df > 0.0 { pooled_var / total_df } else { 1.0 } if pooled_var > 0.0 { all_variances.push(pooled_var) all_df.push(total_df) @@ -841,7 +850,11 @@ pub fn diffcyt_testDS( } else { 1.0 } - let prior_mean_var = if prior_mean_var < 0.0000001 { 0.0000001 } else { prior_mean_var } + let prior_mean_var = if prior_mean_var < 0.0000001 { + 0.0000001 + } else { + prior_mean_var + } // Moderate variances: shrink toward prior. let prior_d0 = 10.0 // prior degrees of freedom for cluster in 0..= 2 && group_ns[0] > 0 && group_ns[1] > 0 { let mean_diff = group_means[1] - group_means[0] - let se = dc_sqrt(mod_var * (1.0 / group_ns[0].to_double() + 1.0 / group_ns[1].to_double())) + let se = dc_sqrt( + mod_var * + (1.0 / group_ns[0].to_double() + 1.0 / group_ns[1].to_double()), + ) let se = if se < 0.0000001 { 0.0000001 } else { se } let t_stat = mean_diff / se let df = prior_d0 + d0 // Convert t to p-value using normal approximation for large df. let p_value = 2.0 * (1.0 - dc_normal_cdf(dc_abs(t_stat))) - let p_value = if p_value < 0.0 { 0.0 } else if p_value > 1.0 { 1.0 } else { p_value } + let p_value = if p_value < 0.0 { + 0.0 + } else if p_value > 1.0 { + 1.0 + } else { + p_value + } let mname = if marker < marker_names.length() { marker_names[marker] } else { @@ -1008,7 +1030,7 @@ fn dc_bh_fdr_ds(results : Array[DiffcytDSResult]) -> Array[DiffcytDSResult] { pub fn diffcyt_mark_significant( da_results : Array[DiffcytDAResult], ds_results : Array[DiffcytDSResult], - fdr_threshold : Double + fdr_threshold : Double, ) -> (Array[DiffcytDAResult], Array[DiffcytDSResult]) { for r in da_results { r.significant = r.fdr < fdr_threshold @@ -1182,7 +1204,7 @@ fn dc_variance(arr : Array[Double]) -> Double { /// Extract top DA clusters sorted by p-value. pub fn diffcyt_top_clusters_da( da_results : Array[DiffcytDAResult], - n_top : Int + n_top : Int, ) -> Array[DiffcytDAResult] { // Copy and sort by p-value. let sorted : Array[DiffcytDAResult] = Array::new() @@ -1213,7 +1235,7 @@ pub fn diffcyt_top_clusters_da( /// Extract top DS cluster-marker pairs sorted by p-value. pub fn diffcyt_top_table_ds( ds_results : Array[DiffcytDSResult], - n_top : Int + n_top : Int, ) -> Array[DiffcytDSResult] { let sorted : Array[DiffcytDSResult] = Array::new() for r in ds_results { @@ -1253,11 +1275,14 @@ pub fn diffcyt_top_table_ds( pub fn diffcyt_run( cells : Array[CytometryCell], n_clusters : Int, - fdr_threshold : Double + fdr_threshold : Double, ) -> DiffcytSummary { let sample_ids = diffcyt_unique_samples(cells) let conditions_arr : Array[String] = Array::new() - let sample_condition_map : Map[String, String] = Map([], capacity=sample_ids.length()) + let sample_condition_map : Map[String, String] = Map( + [], + capacity=sample_ids.length(), + ) for cell in cells { sample_condition_map.set(cell.sample_id, cell.condition) } @@ -1282,11 +1307,11 @@ pub fn diffcyt_run( marker_names.push("marker_" + i.to_string()) } let ds_results = diffcyt_testDS( - cells, sample_ids, conditions_arr, n_clusters, n_markers, marker_names + cells, sample_ids, conditions_arr, n_clusters, n_markers, marker_names, ) // 7. Mark significant. let (da_results, ds_results) = diffcyt_mark_significant( - da_results, ds_results, fdr_threshold + da_results, ds_results, fdr_threshold, ) DiffcytSummary::{ n_cells: cells.length(), @@ -1333,7 +1358,7 @@ pub fn diffcyt_sample_data() -> Array[CytometryCell] { "cell_" + cell_counter.to_string(), samples[si], conditions[si], - marker_vals + marker_vals, ) cells.push(cell) cell_counter = cell_counter + 1 diff --git a/src/dnashape.mbt b/src/dnashape.mbt index fe314acc..2c2ddc46 100644 --- a/src/dnashape.mbt +++ b/src/dnashape.mbt @@ -374,10 +374,7 @@ pub fn dnashape_get_ep_table() -> Map[Int, Double] { ///| /// Look up a dinucleotide value from the appropriate table. -fn dnashape_lookup_dinuc( - dinuc_idx : Int, - feature : DnaShapeFeature, -) -> Double { +fn dnashape_lookup_dinuc(dinuc_idx : Int, feature : DnaShapeFeature) -> Double { match feature { ShapeMGW => { let t = dnashape_get_mgw_table() diff --git a/src/dorothea.mbt b/src/dorothea.mbt index 9df0c314..b0ef3261 100644 --- a/src/dorothea.mbt +++ b/src/dorothea.mbt @@ -47,21 +47,17 @@ pub struct DorotheaParams { ///| /// Create default dorothea parameters. pub fn DorotheaParams::new() -> DorotheaParams { - DorotheaParams::{ - n_permutations: 1000, - min_targets: 5, - significance: 0.05, - } + DorotheaParams::{ n_permutations: 1000, min_targets: 5, significance: 0.05 } } ///| /// Create custom dorothea parameters. -pub fn DorotheaParams::with_params(n_perms : Int, min_targets : Int, alpha : Double) -> DorotheaParams { - DorotheaParams::{ - n_permutations: n_perms, - min_targets, - significance: alpha, - } +pub fn DorotheaParams::with_params( + n_perms : Int, + min_targets : Int, + alpha : Double, +) -> DorotheaParams { + DorotheaParams::{ n_permutations: n_perms, min_targets, significance: alpha } } ///| @@ -322,8 +318,16 @@ pub fn dorothea_compute_viper_activity( } } - let activation_mean = if n_activation > 0 { activation_sum / n_activation.to_double() } else { 0.0 } - let repression_mean = if n_repression > 0 { repression_sum / n_repression.to_double() } else { 0.0 } + let activation_mean = if n_activation > 0 { + activation_sum / n_activation.to_double() + } else { + 0.0 + } + let repression_mean = if n_repression > 0 { + repression_sum / n_repression.to_double() + } else { + 0.0 + } // VIPER score: difference between activation and repression means activation_mean - repression_mean @@ -337,7 +341,9 @@ pub fn dorothea_permutation_test( regulon : Regulon, n_permutations : Int, ) -> (Double, Double) { - let observed = dorothea_compute_viper_activity(cell_expression, gene_names, regulon) + let observed = dorothea_compute_viper_activity( + cell_expression, gene_names, regulon, + ) // Generate null distribution by shuffling gene labels let null_scores : Array[Double] = Array::new() @@ -363,7 +369,9 @@ pub fn dorothea_permutation_test( j = j - 1 } - let null_score = dorothea_compute_viper_activity(shuffled, gene_names, regulon) + let null_score = dorothea_compute_viper_activity( + shuffled, gene_names, regulon, + ) null_scores.push(null_score) perm = perm + 1 } @@ -442,7 +450,9 @@ pub fn dorothea_analyze_cell( continue } - let activity = dorothea_compute_viper_activity(cell_expression, gene_names, regulon) + let activity = dorothea_compute_viper_activity( + cell_expression, gene_names, regulon, + ) let (p_value, z_score) = dorothea_permutation_test( cell_expression, gene_names, @@ -497,7 +507,9 @@ pub fn dorothea_analyze_cells( for regulon in regulons { if regulon.targets.length() >= params.min_targets { - let activity = dorothea_compute_viper_activity(cell_expr, gene_names, regulon) + let activity = dorothea_compute_viper_activity( + cell_expr, gene_names, regulon, + ) let current = tf_activities.get(regulon.tf).unwrap_or([]) let updated = current.copy() updated.push(activity) @@ -561,7 +573,9 @@ pub fn dorothea_filter_results( ///| /// Sort TF activity results by absolute z-score (descending). -pub fn dorothea_sort_by_activity(results : Array[TFActivityResult]) -> Array[TFActivityResult] { +pub fn dorothea_sort_by_activity( + results : Array[TFActivityResult], +) -> Array[TFActivityResult] { // Simple bubble sort by abs(z_score) descending let n = results.length() let sorted = results.copy() @@ -569,7 +583,7 @@ pub fn dorothea_sort_by_activity(results : Array[TFActivityResult]) -> Array[TFA while i < n - 1 { let mut j = 0 while j < n - i - 1 { - if (sorted[j].z_score).abs() < (sorted[j + 1].z_score).abs() { + if sorted[j].z_score.abs() < sorted[j + 1].z_score.abs() { let temp = sorted[j] sorted[j] = sorted[j + 1] sorted[j + 1] = temp @@ -583,7 +597,11 @@ pub fn dorothea_sort_by_activity(results : Array[TFActivityResult]) -> Array[TFA ///| /// Create synthetic test data for dorothea testing. -pub fn dorothea_create_test_data() -> (Array[Array[Double]], Array[String], Array[String]) { +pub fn dorothea_create_test_data() -> ( + Array[Array[Double]], + Array[String], + Array[String], +) { let regulons = dorothea_get_regulons() // Collect all unique genes from regulons @@ -611,7 +629,7 @@ pub fn dorothea_create_test_data() -> (Array[Array[Double]], Array[String], Arra // Vary expression across cells with some structure let base = 5.0 let variation = (c.to_double() + 1.0) * 0.5 - let expr = base + variation + (g.to_double() * 0.01) + let expr = base + variation + g.to_double() * 0.01 col.push(expr) c = c + 1 } @@ -631,7 +649,10 @@ pub fn dorothea_create_test_data() -> (Array[Array[Double]], Array[String], Arra ///| /// Get top TF results by absolute activity. -pub fn dorothea_get_top_tfs(results : Array[TFActivityResult], n : Int) -> Array[TFActivityResult] { +pub fn dorothea_get_top_tfs( + results : Array[TFActivityResult], + n : Int, +) -> Array[TFActivityResult] { let sorted = dorothea_sort_by_activity(results) let top : Array[TFActivityResult] = Array::new() let limit = if n < sorted.length() { n } else { sorted.length() } @@ -641,4 +662,4 @@ pub fn dorothea_get_top_tfs(results : Array[TFActivityResult], n : Int) -> Array i = i + 1 } top -} \ No newline at end of file +} diff --git a/src/drimseq.mbt b/src/drimseq.mbt index 1b550fae..9b2ab392 100644 --- a/src/drimseq.mbt +++ b/src/drimseq.mbt @@ -74,7 +74,11 @@ pub fn TranscriptCount::new( ///| /// Calculate the proportion (count / gene_count). pub fn TranscriptCount::proportion(self : TranscriptCount) -> Double { - if self.gene_count > 0.0 { self.count / self.gene_count } else { 0.0 } + if self.gene_count > 0.0 { + self.count / self.gene_count + } else { + 0.0 + } } ///| @@ -142,7 +146,9 @@ pub struct DRIMSeqResult { ///| /// Get significant results. -pub fn DRIMSeqResult::get_significant(self : DRIMSeqResult) -> Array[DRIMSeqGeneResult] { +pub fn DRIMSeqResult::get_significant( + self : DRIMSeqResult, +) -> Array[DRIMSeqGeneResult] { let sig : Array[DRIMSeqGeneResult] = Array::new() let mut i = 0 while i < self.gene_results.length() { @@ -192,7 +198,12 @@ pub fn DRIMSeqResult::summary(self : DRIMSeqResult) -> String { let mut s = "=== DRIMSeq Differential Transcript Usage ===" + "\n" s = s + "Total genes tested: " + self.n_genes_tested.to_string() + "\n" s = s + "Genes passing filter: " + self.n_genes_filtered.to_string() + "\n" - s = s + "Significant genes (alpha=" + self.alpha.to_string() + "): " + self.n_significant.to_string() + "\n" + s = s + + "Significant genes (alpha=" + + self.alpha.to_string() + + "): " + + self.n_significant.to_string() + + "\n" s = s + "Converged: " + self.converged.to_string() + "\n" s = s + "Iterations: " + self.iterations.to_string() + "\n" s @@ -288,7 +299,9 @@ pub fn drimseq_aggregate_by_gene( let mut found = false let mut j = 0 while j < result.length() { - if result[j].gene_id == c.gene_id && result[j].sample_id == c.sample_id && result[j].condition == c.condition { + if result[j].gene_id == c.gene_id && + result[j].sample_id == c.sample_id && + result[j].condition == c.condition { result[j].count = result[j].count + c.count found = true break @@ -296,9 +309,15 @@ pub fn drimseq_aggregate_by_gene( j = j + 1 } if !found { - result.push(TranscriptCount::new( - transcript_id="__gene_total__", gene_id=c.gene_id, sample_id=c.sample_id, condition=c.condition, count=c.count, - )) + result.push( + TranscriptCount::new( + transcript_id="__gene_total__", + gene_id=c.gene_id, + sample_id=c.sample_id, + condition=c.condition, + count=c.count, + ), + ) } i = i + 1 } @@ -318,16 +337,23 @@ pub fn drimseq_compute_proportions( let mut gene_total = 0.0 let mut j = 0 while j < gene_counts.length() { - if gene_counts[j].gene_id == c.gene_id && gene_counts[j].sample_id == c.sample_id { + if gene_counts[j].gene_id == c.gene_id && + gene_counts[j].sample_id == c.sample_id { gene_total = gene_counts[j].count break } j = j + 1 } - result.push(TranscriptCount::new( - transcript_id=c.transcript_id, gene_id=c.gene_id, sample_id=c.sample_id, condition=c.condition, count=c.count, - gene_count=gene_total, - )) + result.push( + TranscriptCount::new( + transcript_id=c.transcript_id, + gene_id=c.gene_id, + sample_id=c.sample_id, + condition=c.condition, + count=c.count, + gene_count=gene_total, + ), + ) i = i + 1 } result @@ -362,11 +388,17 @@ pub fn drimseq_dirichlet_multinomial( proportions~ : Array[Double], ) -> Double { let n = counts.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let sum_counts = array_sum(counts) - if sum_counts <= 0.0 { return 0.0 } + if sum_counts <= 0.0 { + return 0.0 + } let sum_props = array_sum(proportions) - if sum_props <= 0.0 { return 0.0 } + if sum_props <= 0.0 { + return 0.0 + } let mut loglik = 0.0 // Log-gamma(sum(counts) + 1) - sum(log-gamma(count_i + 1)) @@ -387,7 +419,9 @@ pub fn drimseq_dirichlet_multinomial( loglik = loglik - drimseq_log_gamma(alpha_j) j = j + 1 } - loglik = loglik - drimseq_log_gamma(alpha_sum + sum_counts) + drimseq_log_gamma(alpha_sum) + loglik = loglik - + drimseq_log_gamma(alpha_sum + sum_counts) + + drimseq_log_gamma(alpha_sum) loglik } @@ -400,7 +434,9 @@ pub fn drimseq_wald_test( proportions_b : Array[Double], ) -> (Double, Double, Array[Double]) { let n = proportions_a.length() - if n == 0 { return (0.0, 1.0, Array::new()) } + if n == 0 { + return (0.0, 1.0, Array::new()) + } let delta = array_sub(proportions_a, proportions_b) let mut stat = 0.0 let mut i = 0 @@ -427,7 +463,7 @@ pub fn drimseq_test_differential( ) -> DRIMSeqResult { let gene_counts = drimseq_aggregate_by_gene(counts) let props = drimseq_compute_proportions(counts, gene_counts) - let filtered = drimseq_filter_counts(props, config=config) + let filtered = drimseq_filter_counts(props, config~) let gene_results : Array[DRIMSeqGeneResult] = Array::new() @@ -463,9 +499,15 @@ pub fn drimseq_test_differential( let (stat, pval, delta) = drimseq_wald_test(pa, pb) - gene_results.push(DRIMSeqGeneResult::new( - gene_id=gene_id, delta=delta, p_value=pval, df=n_transcripts - 1, lr_stat=stat, - )) + gene_results.push( + DRIMSeqGeneResult::new( + gene_id~, + delta~, + p_value=pval, + df=n_transcripts - 1, + lr_stat=stat, + ), + ) gi = gi + 1 } @@ -483,7 +525,9 @@ pub fn drimseq_test_differential( let mut n_sig = 0 let mut j = 0 while j < gene_results.length() { - if gene_results[j].significant { n_sig = n_sig + 1 } + if gene_results[j].significant { + n_sig = n_sig + 1 + } j = j + 1 } @@ -514,80 +558,255 @@ pub fn drimseq_sample_data() -> Array[TranscriptCount] { let counts : Array[TranscriptCount] = Array::new() // GeneA: 2 transcripts, condition_a (3 samples) - counts.push(TranscriptCount::new(transcript_id="tx_A1", gene_id="GeneA", sample_id="s1", condition="cond_a", count=100.0, gene_count=150.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A2", gene_id="GeneA", sample_id="s1", condition="cond_a", count=50.0, gene_count=150.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A1", gene_id="GeneA", sample_id="s2", condition="cond_a", count=120.0, gene_count=180.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A2", gene_id="GeneA", sample_id="s2", condition="cond_a", count=60.0, gene_count=180.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A1", gene_id="GeneA", sample_id="s3", condition="cond_a", count=110.0, gene_count=170.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A2", gene_id="GeneA", sample_id="s3", condition="cond_a", count=60.0, gene_count=170.0)) + counts.push( + TranscriptCount::new( + transcript_id="tx_A1", + gene_id="GeneA", + sample_id="s1", + condition="cond_a", + count=100.0, + gene_count=150.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A2", + gene_id="GeneA", + sample_id="s1", + condition="cond_a", + count=50.0, + gene_count=150.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A1", + gene_id="GeneA", + sample_id="s2", + condition="cond_a", + count=120.0, + gene_count=180.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A2", + gene_id="GeneA", + sample_id="s2", + condition="cond_a", + count=60.0, + gene_count=180.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A1", + gene_id="GeneA", + sample_id="s3", + condition="cond_a", + count=110.0, + gene_count=170.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A2", + gene_id="GeneA", + sample_id="s3", + condition="cond_a", + count=60.0, + gene_count=170.0, + ), + ) // GeneA: 2 transcripts, condition_b (3 samples) - DIFFERENT proportions - counts.push(TranscriptCount::new(transcript_id="tx_A1", gene_id="GeneA", sample_id="s4", condition="cond_b", count=50.0, gene_count=180.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A2", gene_id="GeneA", sample_id="s4", condition="cond_b", count=130.0, gene_count=180.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A1", gene_id="GeneA", sample_id="s5", condition="cond_b", count=45.0, gene_count=170.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A2", gene_id="GeneA", sample_id="s5", condition="cond_b", count=125.0, gene_count=170.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A1", gene_id="GeneA", sample_id="s6", condition="cond_b", count=55.0, gene_count=175.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A2", gene_id="GeneA", sample_id="s6", condition="cond_b", count=120.0, gene_count=175.0)) + counts.push( + TranscriptCount::new( + transcript_id="tx_A1", + gene_id="GeneA", + sample_id="s4", + condition="cond_b", + count=50.0, + gene_count=180.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A2", + gene_id="GeneA", + sample_id="s4", + condition="cond_b", + count=130.0, + gene_count=180.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A1", + gene_id="GeneA", + sample_id="s5", + condition="cond_b", + count=45.0, + gene_count=170.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A2", + gene_id="GeneA", + sample_id="s5", + condition="cond_b", + count=125.0, + gene_count=170.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A1", + gene_id="GeneA", + sample_id="s6", + condition="cond_b", + count=55.0, + gene_count=175.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A2", + gene_id="GeneA", + sample_id="s6", + condition="cond_b", + count=120.0, + gene_count=175.0, + ), + ) // GeneB: 1 transcript, no difference - counts.push(TranscriptCount::new(transcript_id="tx_B1", gene_id="GeneB", sample_id="s1", condition="cond_a", count=200.0, gene_count=200.0)) - counts.push(TranscriptCount::new(transcript_id="tx_B1", gene_id="GeneB", sample_id="s2", condition="cond_a", count=210.0, gene_count=210.0)) - counts.push(TranscriptCount::new(transcript_id="tx_B1", gene_id="GeneB", sample_id="s3", condition="cond_a", count=195.0, gene_count=195.0)) - counts.push(TranscriptCount::new(transcript_id="tx_B1", gene_id="GeneB", sample_id="s4", condition="cond_b", count=205.0, gene_count=205.0)) - counts.push(TranscriptCount::new(transcript_id="tx_B1", gene_id="GeneB", sample_id="s5", condition="cond_b", count=215.0, gene_count=215.0)) - counts.push(TranscriptCount::new(transcript_id="tx_B1", gene_id="GeneB", sample_id="s6", condition="cond_b", count=200.0, gene_count=200.0)) + counts.push( + TranscriptCount::new( + transcript_id="tx_B1", + gene_id="GeneB", + sample_id="s1", + condition="cond_a", + count=200.0, + gene_count=200.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_B1", + gene_id="GeneB", + sample_id="s2", + condition="cond_a", + count=210.0, + gene_count=210.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_B1", + gene_id="GeneB", + sample_id="s3", + condition="cond_a", + count=195.0, + gene_count=195.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_B1", + gene_id="GeneB", + sample_id="s4", + condition="cond_b", + count=205.0, + gene_count=205.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_B1", + gene_id="GeneB", + sample_id="s5", + condition="cond_b", + count=215.0, + gene_count=215.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_B1", + gene_id="GeneB", + sample_id="s6", + condition="cond_b", + count=200.0, + gene_count=200.0, + ), + ) counts } // --- Helper functions --- +///| fn array_sum(arr : Array[Double]) -> Double { let mut s = 0.0 let mut i = 0 - while i < arr.length() { s = s + arr[i]; i = i + 1 } + while i < arr.length() { + s = s + arr[i] + i = i + 1 + } s } +///| fn array_sub(a : Array[Double], b : Array[Double]) -> Array[Double] { let len = min_int(a.length(), b.length()) let result : Array[Double] = Array::new() let mut i = 0 - while i < len { result.push(a[i] - b[i]); i = i + 1 } + while i < len { + result.push(a[i] - b[i]) + i = i + 1 + } result } +///| fn array_dot(a : Array[Double], b : Array[Double]) -> Double { let len = min_int(a.length(), b.length()) let mut s = 0.0 let mut i = 0 - while i < len { s = s + a[i] * b[i]; i = i + 1 } + while i < len { + s = s + a[i] * b[i] + i = i + 1 + } s } +///| fn slice_array(arr : Array[Double], start : Int, end : Int) -> Array[Double] { let result : Array[Double] = Array::new() let i = start let j = if end > arr.length() { arr.length() } else { end } let mut k = i - while k < j { result.push(arr[k]); k = k + 1 } + while k < j { + result.push(arr[k]) + k = k + 1 + } result } +///| /// Log-gamma function (Lanczos approximation). fn drimseq_log_gamma(x : Double) -> Double { - if x <= 0.0 { return 0.0 } + if x <= 0.0 { + return 0.0 + } if x < 1.0 { let g = 7.0 let c = [ - 0.99999999999980993, - 676.5203681218851, - -1259.1392167224028, - 771.32342877765313, - -176.61502916214059, - 12.507343278686905, - -0.13857109526572012, - 9.9843695780195716e-6, + 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, + -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7, ] let xx = x @@ -606,14 +825,23 @@ fn drimseq_log_gamma(x : Double) -> Double { } else { // Stirling's approximation for x >= 1 let pi = 3.141592653589793 - 0.5 * @math.ln(2.0 * pi / x) + @math.ln(x) * (x - 0.5) - x + 1.0 / (12.0 * x) - 1.0 / (360.0 * x * x * x) + 0.5 * @math.ln(2.0 * pi / x) + + @math.ln(x) * (x - 0.5) - + x + + 1.0 / (12.0 * x) - + 1.0 / (360.0 * x * x * x) } } +///| /// Chi-square p-value approximation. fn chi_square_p_value(stat : Double, df : Int) -> Double { - if stat <= 0.0 { return 1.0 } - if df <= 0 { return 1.0 } + if stat <= 0.0 { + return 1.0 + } + if df <= 0 { + return 1.0 + } // Use Wilson-Hilferty approximation let df_d = df.to_double() let x = stat / df_d @@ -621,27 +849,47 @@ fn chi_square_p_value(stat : Double, df : Int) -> Double { let x1_3 = @math.pow(x, 1.0 / 3.0) let z = (x1_3 - (1.0 - 2.0 / (9.0 * df_d))) / (2.0 / (9.0 * df_d)).sqrt() let p = normal_sf(z) - if p < 0.0 { 0.0 } else { p } + if p < 0.0 { + 0.0 + } else { + p + } } +///| /// Normal distribution survival function (1 - CDF). fn normal_sf(z : Double) -> Double { // Abramowitz and Stegun approximation let t = 1.0 / (1.0 + 0.2316419 * z.abs()) let d = 0.3989422804014327 * @math.exp(-0.5 * z * z) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))) - if z > 0.0 { p } else { 1.0 - p } + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))) + ) + if z > 0.0 { + p + } else { + 1.0 - p + } } +///| /// Benjamini-Hochberg p-value correction. fn benjamini_hochberg_correct(pvalues : Array[Double]) -> Array[Double] { let n = pvalues.length() - if n == 0 { return Array::new() } + if n == 0 { + return Array::new() + } // Create index array and sort by p-value let indices : Array[Int] = Array::new() let mut i = 0 - while i < n { indices.push(i); i = i + 1 } + while i < n { + indices.push(i) + i = i + 1 + } // Simple bubble sort let sorted_p = pvalues @@ -670,18 +918,27 @@ fn benjamini_hochberg_correct(pvalues : Array[Double]) -> Array[Double] { let rank = (idx + 1).to_double() let val = sorted_p[idx] * (n.to_double() / rank) if idx < n - 1 { - if val > adj[idx + 1] { adj[idx] = adj[idx + 1] } else { adj[idx] = val } + if val > adj[idx + 1] { + adj[idx] = adj[idx + 1] + } else { + adj[idx] = val + } } else { adj[idx] = val } - if adj[idx] > 1.0 { adj[idx] = 1.0 } + if adj[idx] > 1.0 { + adj[idx] = 1.0 + } idx = idx - 1 } // Map back to original order let result : Array[Double] = Array::new() let mut m = 0 - while m < n { result.push(0.0); m = m + 1 } + while m < n { + result.push(0.0) + m = m + 1 + } let mut r = 0 while r < n { @@ -692,6 +949,7 @@ fn benjamini_hochberg_correct(pvalues : Array[Double]) -> Array[Double] { result } +///| fn get_unique_genes(counts : Array[TranscriptCount]) -> Array[String] { let genes : Array[String] = Array::new() let mut i = 0 @@ -700,25 +958,37 @@ fn get_unique_genes(counts : Array[TranscriptCount]) -> Array[String] { let mut found = false let mut j = 0 while j < genes.length() { - if genes[j] == id { found = true; break } + if genes[j] == id { + found = true + break + } j = j + 1 } - if !found { genes.push(id) } + if !found { + genes.push(id) + } i = i + 1 } genes } -fn get_gene_data(counts : Array[TranscriptCount], gene_id : String) -> Array[TranscriptCount] { +///| +fn get_gene_data( + counts : Array[TranscriptCount], + gene_id : String, +) -> Array[TranscriptCount] { let result : Array[TranscriptCount] = Array::new() let mut i = 0 while i < counts.length() { - if counts[i].gene_id == gene_id { result.push(counts[i]) } + if counts[i].gene_id == gene_id { + result.push(counts[i]) + } i = i + 1 } result } +///| fn get_unique_conditions(data : Array[TranscriptCount]) -> Array[String] { let conds : Array[String] = Array::new() let mut i = 0 @@ -727,16 +997,25 @@ fn get_unique_conditions(data : Array[TranscriptCount]) -> Array[String] { let mut found = false let mut j = 0 while j < conds.length() { - if conds[j] == c { found = true; break } + if conds[j] == c { + found = true + break + } j = j + 1 } - if !found { conds.push(c) } + if !found { + conds.push(c) + } i = i + 1 } conds } -fn get_condition_proportions(data : Array[TranscriptCount], condition : String) -> Array[Double] { +///| +fn get_condition_proportions( + data : Array[TranscriptCount], + condition : String, +) -> Array[Double] { let props : Array[Double] = Array::new() let mut i = 0 while i < data.length() { @@ -748,6 +1027,7 @@ fn get_condition_proportions(data : Array[TranscriptCount], condition : String) props } +///| fn extract_pvalues(results : Array[DRIMSeqGeneResult]) -> Array[Double] { let pvals : Array[Double] = Array::new() let mut i = 0 diff --git a/src/droplet_utils.mbt b/src/droplet_utils.mbt index ee8e18b2..ff7737f0 100644 --- a/src/droplet_utils.mbt +++ b/src/droplet_utils.mbt @@ -407,7 +407,8 @@ pub fn create_example_droplet_data() -> (Array[Array[Int]], Array[String]) { let mut count = 0 if i < 30 { if (j * 7 + i * 13).to_double() % 10.0 / 10.0 < 0.3 { - count = ((j * 7 + i * 13).to_double() % 10.0 / 10.0 * 20.0).to_int() + 1 + count = ((j * 7 + i * 13).to_double() % 10.0 / 10.0 * 20.0).to_int() + + 1 } } else if (j * 7 + i * 13).to_double() % 10.0 / 10.0 < 0.05 { count = ((j * 7 + i * 13).to_double() % 10.0 / 10.0 * 5.0).to_int() diff --git a/src/dss.mbt b/src/dss.mbt index 5755afd9..1e2e1fea 100644 --- a/src/dss.mbt +++ b/src/dss.mbt @@ -4,6 +4,7 @@ /// Supports RNA-seq differential expression analysis with dispersion estimation, /// and differential methylation analysis for bisulfite sequencing data. +///| /// Dispersion estimation methods pub enum DSSDispMethod { /// Maximum likelihood estimation @@ -12,6 +13,7 @@ pub enum DSSDispMethod { Shrink } +///| /// Result of dispersion estimation pub struct DSSDispResult { /// Dispersion values for each gene/probe @@ -24,6 +26,7 @@ pub struct DSSDispResult { prior_var : Double } +///| /// Gene count data structure pub struct DSSCountData { /// Gene IDs @@ -36,6 +39,7 @@ pub struct DSSCountData { lib_sizes : Array[Double] } +///| /// Result of differential expression analysis pub struct DSSDEResult { /// Gene IDs @@ -56,6 +60,7 @@ pub struct DSSDEResult { significant : Array[Bool] } +///| /// CpG site methylation data pub struct DSSMethylData { /// CpG site IDs @@ -72,6 +77,7 @@ pub struct DSSMethylData { groups : Array[String] } +///| /// Result of differential methylation analysis pub struct DSSDMResult { /// CpG site IDs @@ -92,6 +98,7 @@ pub struct DSSDMResult { significant : Array[Bool] } +///| /// Result of DMR detection pub struct DSSDMRResult { /// DMR IDs @@ -114,75 +121,110 @@ pub struct DSSDMRResult { // ===== DSSDispResult methods ===== +///| /// Create new dispersion result -pub fn DSSDispResult::new(dispersions : Array[Double], shrunken_dispersions : Array[Double], prior_df : Double, prior_var : Double) -> DSSDispResult { +pub fn DSSDispResult::new( + dispersions : Array[Double], + shrunken_dispersions : Array[Double], + prior_df : Double, + prior_var : Double, +) -> DSSDispResult { DSSDispResult::{ dispersions, shrunken_dispersions, prior_df, prior_var } } +///| /// Get dispersion values -pub fn DSSDispResult::dss_get_dispersions(self : DSSDispResult) -> Array[Double] { +pub fn DSSDispResult::dss_get_dispersions( + self : DSSDispResult, +) -> Array[Double] { self.dispersions } +///| /// Get shrunken dispersion values -pub fn DSSDispResult::dss_get_shrunken_dispersions(self : DSSDispResult) -> Array[Double] { +pub fn DSSDispResult::dss_get_shrunken_dispersions( + self : DSSDispResult, +) -> Array[Double] { self.shrunken_dispersions } // ===== DSSCountData methods ===== +///| /// Create new count data -pub fn DSSCountData::new(gene_ids : Array[String], counts : Array[Array[Double]], groups : Array[String], lib_sizes : Array[Double]) -> DSSCountData { +pub fn DSSCountData::new( + gene_ids : Array[String], + counts : Array[Array[Double]], + groups : Array[String], + lib_sizes : Array[Double], +) -> DSSCountData { DSSCountData::{ gene_ids, counts, groups, lib_sizes } } +///| /// Get gene count for specific gene and sample -pub fn DSSCountData::dss_get_count(self : DSSCountData, gene_idx : Int, sample_idx : Int) -> Double { +pub fn DSSCountData::dss_get_count( + self : DSSCountData, + gene_idx : Int, + sample_idx : Int, +) -> Double { self.counts[gene_idx][sample_idx] } +///| /// Get number of genes pub fn DSSCountData::dss_n_genes(self : DSSCountData) -> Int { self.gene_ids.length() } +///| /// Get number of samples pub fn DSSCountData::dss_n_samples(self : DSSCountData) -> Int { self.groups.length() } +///| /// Normalize counts by library size pub fn DSSCountData::dss_normalize(self : DSSCountData) -> Array[Array[Double]] { let n_genes = self.counts.length() let n_samples = if n_genes > 0 { self.counts[0].length() } else { 0 } let normalized : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_genes { let row : Array[Double] = Array::new() let mut j = 0 while j < n_samples { - let lib_size = if j < self.lib_sizes.length() { self.lib_sizes[j] } else { 1.0 } + let lib_size = if j < self.lib_sizes.length() { + self.lib_sizes[j] + } else { + 1.0 + } row.push(self.counts[i][j] / lib_size * 1000000.0) j = j + 1 } normalized.push(row) i = i + 1 } - + normalized } +///| /// Filter low count genes -pub fn DSSCountData::dss_filter_low_counts(self : DSSCountData, min_count : Double, min_samples : Int) -> DSSCountData { +pub fn DSSCountData::dss_filter_low_counts( + self : DSSCountData, + min_count : Double, + min_samples : Int, +) -> DSSCountData { let new_gene_ids : Array[String] = Array::new() let new_counts : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < self.gene_ids.length() { let count_row = self.counts[i] let mut passing_samples = 0 - + let mut j = 0 while j < count_row.length() { if count_row[j] >= min_count { @@ -190,33 +232,51 @@ pub fn DSSCountData::dss_filter_low_counts(self : DSSCountData, min_count : Doub } j = j + 1 } - + if passing_samples >= min_samples { new_gene_ids.push(self.gene_ids[i]) new_counts.push(count_row) } - + i = i + 1 } - + DSSCountData::new(new_gene_ids, new_counts, self.groups, self.lib_sizes) } // ===== DSSDEResult methods ===== +///| /// Create new DSR result -pub fn DSSDEResult::new(gene_ids : Array[String], mean1 : Array[Double], mean2 : Array[Double], - dispersion : Array[Double], wald_stat : Array[Double], - p_values : Array[Double], adj_p_values : Array[Double], - significant : Array[Bool]) -> DSSDEResult { - DSSDEResult::{ gene_ids, mean1, mean2, dispersion, wald_stat, p_values, adj_p_values, significant } +pub fn DSSDEResult::new( + gene_ids : Array[String], + mean1 : Array[Double], + mean2 : Array[Double], + dispersion : Array[Double], + wald_stat : Array[Double], + p_values : Array[Double], + adj_p_values : Array[Double], + significant : Array[Bool], +) -> DSSDEResult { + DSSDEResult::{ + gene_ids, + mean1, + mean2, + dispersion, + wald_stat, + p_values, + adj_p_values, + significant, + } } +///| /// Get number of genes pub fn DSSDEResult::dss_n_genes(self : DSSDEResult) -> Int { self.gene_ids.length() } +///| /// Get significant gene count pub fn DSSDEResult::dss_n_significant(self : DSSDEResult) -> Int { let mut count = 0 @@ -230,21 +290,25 @@ pub fn DSSDEResult::dss_n_significant(self : DSSDEResult) -> Int { count } +///| /// Get gene ID at index pub fn DSSDEResult::dss_get_gene_id(self : DSSDEResult, idx : Int) -> String { self.gene_ids[idx] } +///| /// Get p-value at index pub fn DSSDEResult::dss_get_pvalue(self : DSSDEResult, idx : Int) -> Double { self.p_values[idx] } +///| /// Get adjusted p-value at index pub fn DSSDEResult::dss_get_adj_pvalue(self : DSSDEResult, idx : Int) -> Double { self.adj_p_values[idx] } +///| /// Get fold change at index (log2 scale) pub fn DSSDEResult::dss_get_logfc(self : DSSDEResult, idx : Int) -> Double { if self.mean1[idx] > 0.0 && self.mean2[idx] > 0.0 { @@ -256,25 +320,38 @@ pub fn DSSDEResult::dss_get_logfc(self : DSSDEResult, idx : Int) -> Double { // ===== DSSMethylData methods ===== +///| /// Create new methylation data -pub fn DSSMethylData::new(cpg_ids : Array[String], chrom : Array[String], pos : Array[Int], - meth_counts : Array[Array[Double]], total_counts : Array[Array[Double]], - groups : Array[String]) -> DSSMethylData { +pub fn DSSMethylData::new( + cpg_ids : Array[String], + chrom : Array[String], + pos : Array[Int], + meth_counts : Array[Array[Double]], + total_counts : Array[Array[Double]], + groups : Array[String], +) -> DSSMethylData { DSSMethylData::{ cpg_ids, chrom, pos, meth_counts, total_counts, groups } } +///| /// Get number of CpG sites pub fn DSSMethylData::dss_n_cpgs(self : DSSMethylData) -> Int { self.cpg_ids.length() } +///| /// Get number of samples pub fn DSSMethylData::dss_n_samples(self : DSSMethylData) -> Int { self.groups.length() } +///| /// Calculate methylation proportion for a site and sample -pub fn DSSMethylData::dss_get_meth_prop(self : DSSMethylData, cpg_idx : Int, sample_idx : Int) -> Double { +pub fn DSSMethylData::dss_get_meth_prop( + self : DSSMethylData, + cpg_idx : Int, + sample_idx : Int, +) -> Double { let total = self.total_counts[cpg_idx][sample_idx] if total > 0.0 { self.meth_counts[cpg_idx][sample_idx] / total @@ -285,19 +362,37 @@ pub fn DSSMethylData::dss_get_meth_prop(self : DSSMethylData, cpg_idx : Int, sam // ===== DSSDMResult methods ===== +///| /// Create new DM result -pub fn DSSDMResult::new(cpg_ids : Array[String], meth_mean1 : Array[Double], meth_mean2 : Array[Double], - delta_meth : Array[Double], stats : Array[Double], - p_values : Array[Double], adj_p_values : Array[Double], - significant : Array[Bool]) -> DSSDMResult { - DSSDMResult::{ cpg_ids, meth_mean1, meth_mean2, delta_meth, stats, p_values, adj_p_values, significant } +pub fn DSSDMResult::new( + cpg_ids : Array[String], + meth_mean1 : Array[Double], + meth_mean2 : Array[Double], + delta_meth : Array[Double], + stats : Array[Double], + p_values : Array[Double], + adj_p_values : Array[Double], + significant : Array[Bool], +) -> DSSDMResult { + DSSDMResult::{ + cpg_ids, + meth_mean1, + meth_mean2, + delta_meth, + stats, + p_values, + adj_p_values, + significant, + } } +///| /// Get number of sites pub fn DSSDMResult::dss_n_sites(self : DSSDMResult) -> Int { self.cpg_ids.length() } +///| /// Get significant site count pub fn DSSDMResult::dss_n_significant(self : DSSDMResult) -> Int { let mut count = 0 @@ -311,6 +406,7 @@ pub fn DSSDMResult::dss_n_significant(self : DSSDMResult) -> Int { count } +///| /// Get delta methylation at index pub fn DSSDMResult::dss_get_delta_meth(self : DSSDMResult, idx : Int) -> Double { self.delta_meth[idx] @@ -318,26 +414,55 @@ pub fn DSSDMResult::dss_get_delta_meth(self : DSSDMResult, idx : Int) -> Double // ===== DSSDMRResult methods ===== +///| /// Create new DMR result -pub fn DSSDMRResult::new(dmr_ids : Array[String], chrom : Array[String], start : Array[Int], - end : Array[Int], n_cpgs : Array[Int], mean_delta : Array[Double], - stats : Array[Double], p_values : Array[Double]) -> DSSDMRResult { - DSSDMRResult::{ dmr_ids, chrom, start, end, n_cpgs, mean_delta, stats, p_values } +pub fn DSSDMRResult::new( + dmr_ids : Array[String], + chrom : Array[String], + start : Array[Int], + end : Array[Int], + n_cpgs : Array[Int], + mean_delta : Array[Double], + stats : Array[Double], + p_values : Array[Double], +) -> DSSDMRResult { + DSSDMRResult::{ + dmr_ids, + chrom, + start, + end, + n_cpgs, + mean_delta, + stats, + p_values, + } } +///| /// Get number of DMRs pub fn DSSDMRResult::dss_n_dmrs(self : DSSDMRResult) -> Int { self.dmr_ids.length() } +///| /// Get DMR at index -pub fn DSSDMRResult::dss_get_dmr(self : DSSDMRResult, idx : Int) -> (String, String, Int, Int, Int, Double) { - (self.dmr_ids[idx], self.chrom[idx], self.start[idx], self.end[idx], - self.n_cpgs[idx], self.mean_delta[idx]) +pub fn DSSDMRResult::dss_get_dmr( + self : DSSDMRResult, + idx : Int, +) -> (String, String, Int, Int, Int, Double) { + ( + self.dmr_ids[idx], + self.chrom[idx], + self.start[idx], + self.end[idx], + self.n_cpgs[idx], + self.mean_delta[idx], + ) } // ===== Helper functions ===== +///| /// Calculate mean of array fn dss_mean(arr : Array[Double]) -> Double { if arr.length() == 0 { @@ -352,6 +477,7 @@ fn dss_mean(arr : Array[Double]) -> Double { sum / arr.length().to_double() } +///| /// Calculate variance of array fn dss_var(arr : Array[Double]) -> Double { if arr.length() < 2 { @@ -369,64 +495,66 @@ fn dss_var(arr : Array[Double]) -> Double { // ===== Public API functions ===== +///| /// Estimate per-gene dispersion using method of moments pub fn dss_estimate_dispersion(counts_data : DSSCountData) -> DSSDispResult { let n_genes = counts_data.dss_n_genes() let n_samples = counts_data.dss_n_samples() - + let dispersions : Array[Double] = Array::new() let norm_counts = counts_data.dss_normalize() - + let mut i = 0 while i < n_genes { let expr = norm_counts[i] let m = dss_mean(expr) let v = dss_var(expr) - - let disp = if m > 0.0 { - v / m.pow(2.0) - } else { - 0.0000000001 - } - + + let disp = if m > 0.0 { v / m.pow(2.0) } else { 0.0000000001 } + dispersions.push(disp) i = i + 1 } - + // Shrinkage estimation let mean_disp = dss_mean(dispersions) let var_disp = dss_var(dispersions) - + let prior_df = if var_disp > 0.0 { 2.0 * mean_disp.pow(2.0) / var_disp } else { 10.0 } let prior_var = mean_disp - + let shrunken : Array[Double] = Array::new() i = 0 while i < n_genes { let disp = dispersions[i] // Empirical Bayes shrinkage let post_df = prior_df + n_samples.to_double() - let post_var = (prior_df * prior_var + (n_samples.to_double() - 1.0) * disp) / post_df + let post_var = (prior_df * prior_var + (n_samples.to_double() - 1.0) * disp) / + post_df shrunken.push(post_var) i = i + 1 } - + DSSDispResult::new(dispersions, shrunken, prior_df, prior_var) } +///| /// Perform differential expression analysis using Wald test -pub fn dss_deseq(counts_data : DSSCountData, disp_result : DSSDispResult) -> DSSDEResult { +pub fn dss_deseq( + counts_data : DSSCountData, + disp_result : DSSDispResult, +) -> DSSDEResult { let n_genes = counts_data.dss_n_genes() let n_samples = counts_data.dss_n_samples() let norm_counts = counts_data.dss_normalize() - + let group1_idx : Array[Int] = Array::new() let group2_idx : Array[Int] = Array::new() - + let mut j = 0 while j < n_samples { if counts_data.groups[j] == "group1" { @@ -436,21 +564,21 @@ pub fn dss_deseq(counts_data : DSSCountData, disp_result : DSSDispResult) -> DSS } j = j + 1 } - + let n1 = group1_idx.length().to_double() let n2 = group2_idx.length().to_double() - + let mean1_arr : Array[Double] = Array::new() let mean2_arr : Array[Double] = Array::new() let disp_arr : Array[Double] = Array::new() let wald_stat_arr : Array[Double] = Array::new() let p_values_arr : Array[Double] = Array::new() let gene_ids_arr : Array[String] = Array::new() - + let mut i = 0 while i < n_genes { let expr = norm_counts[i] - + let sum1 = if n1 > 0.0 { let mut s = 0.0 let mut k = 0 @@ -462,7 +590,7 @@ pub fn dss_deseq(counts_data : DSSCountData, disp_result : DSSDispResult) -> DSS } else { 0.0 } - + let sum2 = if n2 > 0.0 { let mut s = 0.0 let mut k = 0 @@ -474,44 +602,40 @@ pub fn dss_deseq(counts_data : DSSCountData, disp_result : DSSDispResult) -> DSS } else { 0.0 } - + let m1 = if n1 > 0.0 { sum1 / n1 } else { 0.0 } let m2 = if n2 > 0.0 { sum2 / n2 } else { 0.0 } - + let disp = if i < disp_result.shrunken_dispersions.length() { disp_result.shrunken_dispersions[i] } else { 0.1 } - + // Wald statistic let se = (disp * (m1 / n1 + m2 / n2)).sqrt() - let wald = if se > 0.0000000001 { - (m2 - m1) / se - } else { - 0.0 - } - + let wald = if se > 0.0000000001 { (m2 - m1) / se } else { 0.0 } + // Two-sided p-value approximation let p_val = if wald.abs() < 37.0 { 2.0 * (1.0 - dss_normal_cdf(wald.abs())) } else { 0.0 } - + mean1_arr.push(m1) mean2_arr.push(m2) disp_arr.push(disp) wald_stat_arr.push(wald) p_values_arr.push(p_val) gene_ids_arr.push(counts_data.gene_ids[i]) - + i = i + 1 } - + // Multiple testing correction (Benjamini-Hochberg) let adj_p_values = dss_benjamini_hochberg(p_values_arr) - + // Determine significance (FDR < 0.05) let significant : Array[Bool] = Array::new() let mut k = 0 @@ -519,19 +643,22 @@ pub fn dss_deseq(counts_data : DSSCountData, disp_result : DSSDispResult) -> DSS significant.push(adj_p_values[k] < 0.05) k = k + 1 } - - DSSDEResult::new(gene_ids_arr, mean1_arr, mean2_arr, disp_arr, wald_stat_arr, - p_values_arr, adj_p_values, significant) + + DSSDEResult::new( + gene_ids_arr, mean1_arr, mean2_arr, disp_arr, wald_stat_arr, p_values_arr, adj_p_values, + significant, + ) } +///| /// Perform differential methylation analysis pub fn dss_dml(methyl_data : DSSMethylData) -> DSSDMResult { let n_sites = methyl_data.dss_n_cpgs() let n_samples = methyl_data.dss_n_samples() - + let group1_idx : Array[Int] = Array::new() let group2_idx : Array[Int] = Array::new() - + let mut j = 0 while j < n_samples { if methyl_data.groups[j] == "group1" { @@ -541,24 +668,24 @@ pub fn dss_dml(methyl_data : DSSMethylData) -> DSSDMResult { } j = j + 1 } - + let n1 = group1_idx.length().to_double() let n2 = group2_idx.length().to_double() - + let meth_mean1_arr : Array[Double] = Array::new() let meth_mean2_arr : Array[Double] = Array::new() let delta_meth_arr : Array[Double] = Array::new() let stats_arr : Array[Double] = Array::new() let p_values_arr : Array[Double] = Array::new() let cpg_ids_arr : Array[String] = Array::new() - + let mut i = 0 while i < n_sites { let mut sum1 = 0.0 let mut total1 = 0.0 let mut sum2 = 0.0 let mut total2 = 0.0 - + let mut k = 0 while k < group1_idx.length() { let idx = group1_idx[k] @@ -566,7 +693,7 @@ pub fn dss_dml(methyl_data : DSSMethylData) -> DSSDMResult { total1 = total1 + methyl_data.total_counts[i][idx] k = k + 1 } - + k = 0 while k < group2_idx.length() { let idx = group2_idx[k] @@ -574,51 +701,59 @@ pub fn dss_dml(methyl_data : DSSMethylData) -> DSSDMResult { total2 = total2 + methyl_data.total_counts[i][idx] k = k + 1 } - + let m1 = if total1 > 0.0 { sum1 / total1 } else { 0.0 } let m2 = if total2 > 0.0 { sum2 / total2 } else { 0.0 } let delta = m2 - m1 - + // Test statistic (approximation) let se = if total1 + total2 > 0.0 { (m1 * (1.0 - m1) / total1 + m2 * (1.0 - m2) / total2).sqrt() } else { 1.0 } - + let stat = if se > 0.0000000001 { delta / se } else { 0.0 } let p_val = if stat.abs() < 37.0 { 2.0 * (1.0 - dss_normal_cdf(stat.abs())) } else { 0.0 } - + meth_mean1_arr.push(m1) meth_mean2_arr.push(m2) delta_meth_arr.push(delta) stats_arr.push(stat) p_values_arr.push(p_val) cpg_ids_arr.push(methyl_data.cpg_ids[i]) - + i = i + 1 } - + // Multiple testing correction let adj_p_values = dss_benjamini_hochberg(p_values_arr) - + let significant : Array[Bool] = Array::new() let mut s = 0 while s < n_sites { significant.push(adj_p_values[s] < 0.05) s = s + 1 } - - DSSDMResult::new(cpg_ids_arr, meth_mean1_arr, meth_mean2_arr, delta_meth_arr, - stats_arr, p_values_arr, adj_p_values, significant) + + DSSDMResult::new( + cpg_ids_arr, meth_mean1_arr, meth_mean2_arr, delta_meth_arr, stats_arr, p_values_arr, + adj_p_values, significant, + ) } +///| /// Detect differentially methylated regions -pub fn dss_dmr(methyl_data : DSSMethylData, dm_result : DSSDMResult, min_cpgs : Int, min_delta : Double) -> DSSDMRResult { +pub fn dss_dmr( + methyl_data : DSSMethylData, + dm_result : DSSDMResult, + min_cpgs : Int, + min_delta : Double, +) -> DSSDMRResult { let dmr_ids : Array[String] = Array::new() let chrom_arr : Array[String] = Array::new() let start_arr : Array[Int] = Array::new() @@ -627,26 +762,43 @@ pub fn dss_dmr(methyl_data : DSSMethylData, dm_result : DSSDMResult, min_cpgs : let mean_delta_arr : Array[Double] = Array::new() let stats_arr : Array[Double] = Array::new() let p_values_arr : Array[Double] = Array::new() - + let mut i = 0 while i < dm_result.cpg_ids.length() { if dm_result.significant[i] && dm_result.delta_meth[i].abs() >= min_delta { // Start of potential DMR - let current_chrom = if i < methyl_data.chrom.length() { methyl_data.chrom[i] } else { "chr1" } - let current_pos = if i < methyl_data.pos.length() { methyl_data.pos[i] } else { i } - + let current_chrom = if i < methyl_data.chrom.length() { + methyl_data.chrom[i] + } else { + "chr1" + } + let current_pos = if i < methyl_data.pos.length() { + methyl_data.pos[i] + } else { + i + } + let mut j = i + 1 let mut cpgs = 1 let mut total_delta = dm_result.delta_meth[i] let mut total_stat = dm_result.stats[i] let max_gap = 10000 let mut last_pos = current_pos - + while j < dm_result.cpg_ids.length() && j < i + 100 { - if dm_result.significant[j] && dm_result.delta_meth[j].abs() >= min_delta { - let next_chrom = if j < methyl_data.chrom.length() { methyl_data.chrom[j] } else { current_chrom } - let next_pos = if j < methyl_data.pos.length() { methyl_data.pos[j] } else { last_pos + 100 } - + if dm_result.significant[j] && + dm_result.delta_meth[j].abs() >= min_delta { + let next_chrom = if j < methyl_data.chrom.length() { + methyl_data.chrom[j] + } else { + current_chrom + } + let next_pos = if j < methyl_data.pos.length() { + methyl_data.pos[j] + } else { + last_pos + 100 + } + if next_chrom == current_chrom && next_pos - last_pos <= max_gap { cpgs = cpgs + 1 total_delta = total_delta + dm_result.delta_meth[j] @@ -660,7 +812,7 @@ pub fn dss_dmr(methyl_data : DSSMethylData, dm_result : DSSDMResult, min_cpgs : break } } - + if cpgs >= min_cpgs { let dmr_id = "DMR_" + (dmr_ids.length() + 1).to_string() dmr_ids.push(dmr_id) @@ -672,46 +824,59 @@ pub fn dss_dmr(methyl_data : DSSMethylData, dm_result : DSSDMResult, min_cpgs : stats_arr.push(total_stat) p_values_arr.push(0.0) } - + i = j } else { i = i + 1 } } - - DSSDMRResult::new(dmr_ids, chrom_arr, start_arr, end_arr, n_cpgs_arr, - mean_delta_arr, stats_arr, p_values_arr) + + DSSDMRResult::new( + dmr_ids, chrom_arr, start_arr, end_arr, n_cpgs_arr, mean_delta_arr, stats_arr, + p_values_arr, + ) } +///| /// Standard normal CDF approximation (renamed to avoid conflict with ballgown) fn dss_normal_cdf(x : Double) -> Double { // Abramowitz and Stegun approximation let t = 1.0 / (1.0 + 0.2316419 * x.abs()) let d = 0.3989422804014327 * @math.exp(-x * x / 2.0) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))) - if x > 0.0 { 1.0 - p } else { p } + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))) + ) + if x > 0.0 { + 1.0 - p + } else { + p + } } +///| /// Benjamini-Hochberg multiple testing correction (renamed to avoid conflict with ballgown) fn dss_benjamini_hochberg(p_values : Array[Double]) -> Array[Double] { let n = p_values.length() let result = Array::make(n, 1.0) - + if n == 0 { return result } - + // Create index array and sort by p-value let indices : Array[Int] = Array::new() let sorted_pvals : Array[Double] = Array::new() - + let mut i = 0 while i < n { indices.push(i) sorted_pvals.push(p_values[i]) i = i + 1 } - + // Simple bubble sort let mut j = 0 while j < n { @@ -721,7 +886,7 @@ fn dss_benjamini_hochberg(p_values : Array[Double]) -> Array[Double] { let tmp_p = sorted_pvals[j] sorted_pvals[j] = sorted_pvals[k] sorted_pvals[k] = tmp_p - + let tmp_i = indices[j] indices[j] = indices[k] indices[k] = tmp_i @@ -730,11 +895,11 @@ fn dss_benjamini_hochberg(p_values : Array[Double]) -> Array[Double] { } j = j + 1 } - + // Apply BH correction let adj = Array::make(n, 1.0) let mut last = 1.0 - + i = n - 1 while i >= 0 { let rank = (i + 1).to_double() @@ -743,17 +908,18 @@ fn dss_benjamini_hochberg(p_values : Array[Double]) -> Array[Double] { adj[i] = if last <= 1.0 { last } else { 1.0 } i = i - 1 } - + // Map back to original order i = 0 while i < n { result[indices[i]] = adj[i] i = i + 1 } - + result } +///| /// Create example count data for testing pub fn dss_create_example_counts() -> DSSCountData { let gene_ids = ["GeneA", "GeneB", "GeneC", "GeneD", "GeneE"] @@ -766,10 +932,11 @@ pub fn dss_create_example_counts() -> DSSCountData { ] let groups = ["group1", "group1", "group1", "group2", "group2", "group2"] let lib_sizes = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0] - + DSSCountData::new(gene_ids, counts, groups, lib_sizes) } +///| /// Create example methylation data for testing pub fn dss_create_example_methylation() -> DSSMethylData { let cpg_ids = ["CpG1", "CpG2", "CpG3", "CpG4", "CpG5"] @@ -790,6 +957,6 @@ pub fn dss_create_example_methylation() -> DSSMethylData { [25.0, 26.0, 24.0, 25.0, 24.0, 26.0], ] let groups = ["group1", "group1", "group1", "group2", "group2", "group2"] - + DSSMethylData::new(cpg_ids, chrom, pos, meth_counts, total_counts, groups) } diff --git a/src/dssp.mbt b/src/dssp.mbt index de1ea351..303a6932 100644 --- a/src/dssp.mbt +++ b/src/dssp.mbt @@ -25,7 +25,16 @@ pub fn DSSPRecord::new( phi : Double, psi : Double, ) -> DSSPRecord { - DSSPRecord::{ chain_id, residue_number, insertion_code, amino_acid, secondary_structure, solvent_accessibility, phi, psi } + DSSPRecord::{ + chain_id, + residue_number, + insertion_code, + amino_acid, + secondary_structure, + solvent_accessibility, + phi, + psi, + } } ///| @@ -35,16 +44,16 @@ pub struct DSSPResult { ///| pub fn DSSPResult::new(records : Array[DSSPRecord]) -> DSSPResult { - DSSPResult::{ records } + DSSPResult::{ records, } } ///| pub fn parse_dssp(data : String) -> DSSPResult { let records : Array[DSSPRecord] = Array::new() - + let lines = split_by_char(data, '\n'.to_int()) let mut i = 0 - + while i < lines.length() { let line = lines[i] if line.length() >= 14 && char_at(line, 0) != "#" { @@ -56,27 +65,29 @@ pub fn parse_dssp(data : String) -> DSSPResult { let acc_str = substring(line, 34, 3) let phi_str = substring(line, 104, 6) let psi_str = substring(line, 111, 6) - + let residue_number = parse_int(trim(resnum_str)) let solvent_accessibility = parse_int(trim(acc_str)) let phi = parse_double(trim(phi_str)).unwrap_or(0.0) let psi = parse_double(trim(psi_str)).unwrap_or(0.0) - - records.push(DSSPRecord::new( - chain_id, residue_number, insertion_code, - amino_acid, ss, solvent_accessibility, phi, psi, - )) + + records.push( + DSSPRecord::new( + chain_id, residue_number, insertion_code, amino_acid, ss, solvent_accessibility, + phi, psi, + ), + ) } i = i + 1 } - + DSSPResult::new(records) } ///| pub fn predict_secondary_structure(sequence : String) -> String { let mut result = "" - + let mut i = 0 while i < sequence.length() { let aa = char_at(sequence, i) @@ -84,7 +95,7 @@ pub fn predict_secondary_structure(sequence : String) -> String { result = result + ss i = i + 1 } - + result } @@ -93,7 +104,7 @@ fn classify_secondary_structure(amino_acid : String) -> String { let helix_formers = ["E", "D", "L", "M", "K", "R", "H"] let sheet_formers = ["V", "I", "Y", "F", "W", "T"] let coil_formers = ["G", "A", "S", "P", "N", "C", "Q"] - + let mut i = 0 while i < helix_formers.length() { if helix_formers[i] == amino_acid { @@ -101,7 +112,7 @@ fn classify_secondary_structure(amino_acid : String) -> String { } i = i + 1 } - + i = 0 while i < sheet_formers.length() { if sheet_formers[i] == amino_acid { @@ -109,7 +120,7 @@ fn classify_secondary_structure(amino_acid : String) -> String { } i = i + 1 } - + i = 0 while i < coil_formers.length() { if coil_formers[i] == amino_acid { @@ -117,7 +128,7 @@ fn classify_secondary_structure(amino_acid : String) -> String { } i = i + 1 } - + "-" } @@ -127,18 +138,18 @@ pub fn calculate_solvent_accessibility( structure : String, ) -> Array[Int] { let result : Array[Int] = Array::new() - + let mut i = 0 while i < sequence.length() { let aa = char_at(sequence, i) let ss = if i < structure.length() { char_at(structure, i) } else { "-" } - + let accessibility = estimate_accessibility(aa, ss, i, sequence.length()) result.push(accessibility) - + i = i + 1 } - + result } @@ -149,17 +160,36 @@ fn estimate_accessibility( position : Int, total_length : Int, ) -> Int { - let max_accessibility = Map([ - ("A", 129), ("R", 274), ("N", 195), ("D", 193), ("C", 167), - ("Q", 225), ("E", 223), ("G", 104), ("H", 224), ("I", 197), - ("L", 201), ("K", 236), ("M", 224), ("F", 240), ("P", 159), - ("S", 155), ("T", 172), ("W", 285), ("Y", 263), ("V", 174), - ], capacity=20) - + let max_accessibility = Map( + [ + ("A", 129), + ("R", 274), + ("N", 195), + ("D", 193), + ("C", 167), + ("Q", 225), + ("E", 223), + ("G", 104), + ("H", 224), + ("I", 197), + ("L", 201), + ("K", 236), + ("M", 224), + ("F", 240), + ("P", 159), + ("S", 155), + ("T", 172), + ("W", 285), + ("Y", 263), + ("V", 174), + ], + capacity=20, + ) + let max_acc = max_accessibility.get(amino_acid).unwrap_or(150) - + let mut accessibility = max_acc - + if secondary_structure == "H" { accessibility = (max_acc.to_double() * 0.3).to_int() } else if secondary_structure == "E" { @@ -167,11 +197,11 @@ fn estimate_accessibility( } else { accessibility = (max_acc.to_double() * 0.6).to_int() } - + if position < 5 || position > total_length - 5 { accessibility = (accessibility.to_double() * 0.5).to_int() } - + accessibility } @@ -180,22 +210,34 @@ pub fn calculate_ramachandran_plot( records : Array[DSSPRecord], ) -> Array[(Double, Double)] { let result : Array[(Double, Double)] = Array::new() - + let mut i = 0 while i < records.length() { result.push((records[i].phi, records[i].psi)) i = i + 1 } - + result } ///| -pub fn analyze_structure_composition(records : Array[DSSPRecord]) -> Map[String, Int] { - let composition : Map[String, Int] = Map([ - ("H", 0), ("B", 0), ("E", 0), ("G", 0), ("I", 0), ("T", 0), ("S", 0), ("-", 0), - ], capacity=8) - +pub fn analyze_structure_composition( + records : Array[DSSPRecord], +) -> Map[String, Int] { + let composition : Map[String, Int] = Map( + [ + ("H", 0), + ("B", 0), + ("E", 0), + ("G", 0), + ("I", 0), + ("T", 0), + ("S", 0), + ("-", 0), + ], + capacity=8, + ) + let mut i = 0 while i < records.length() { let ss = records[i].secondary_structure @@ -203,14 +245,14 @@ pub fn analyze_structure_composition(records : Array[DSSPRecord]) -> Map[String, composition.set(ss, count + 1) i = i + 1 } - + composition } ///| pub fn create_example_dssp_data() -> DSSPResult { let records : Array[DSSPRecord] = Array::new() - + records.push(DSSPRecord::new("A", 1, "", "M", "-", 100, -60.0, -40.0)) records.push(DSSPRecord::new("A", 2, "", "S", "H", 50, -57.0, -47.0)) records.push(DSSPRecord::new("A", 3, "", "G", "H", 40, -59.0, -47.0)) @@ -219,6 +261,6 @@ pub fn create_example_dssp_data() -> DSSPResult { records.push(DSSPRecord::new("A", 6, "", "V", "E", 30, -139.0, 135.0)) records.push(DSSPRecord::new("A", 7, "", "A", "E", 25, -139.0, 135.0)) records.push(DSSPRecord::new("A", 8, "", "L", "-", 60, -60.0, -40.0)) - + DSSPResult::new(records) -} \ No newline at end of file +} diff --git a/src/edaseq.mbt b/src/edaseq.mbt index b76af3b3..fe80e8cf 100644 --- a/src/edaseq.mbt +++ b/src/edaseq.mbt @@ -3,6 +3,7 @@ /// Provides RNA-seq exploratory data analysis with GC-content and /// gene length normalization, plus between/within-lane normalization. +///| /// Normalization type pub enum EDASeqNormType { /// Within-lane normalization (GC content or gene length) @@ -13,6 +14,7 @@ pub enum EDASeqNormType { Full } +///| /// Within-lane normalization method pub enum EDASeqWithinMethod { /// GC content normalization @@ -23,6 +25,7 @@ pub enum EDASeqWithinMethod { Both } +///| /// Between-lane normalization method pub enum EDASeqBetweenMethod { /// Median ratio normalization @@ -33,6 +36,7 @@ pub enum EDASeqBetweenMethod { Library } +///| /// Gene annotation for normalization pub struct EDASeqGeneAnno { /// Gene ID @@ -45,6 +49,7 @@ pub struct EDASeqGeneAnno { effective_length : Double } +///| /// Expression set for EDASeq pub struct EDASeqDataSet { /// Gene IDs @@ -59,6 +64,7 @@ pub struct EDASeqDataSet { lib_sizes : Array[Double] } +///| /// Result of within-lane normalization pub struct EDASeqWithinResult { /// Normalized counts @@ -71,6 +77,7 @@ pub struct EDASeqWithinResult { norm_method : EDASeqWithinMethod } +///| /// A loess fit result pub struct EDASeqFit { /// Smoothing span @@ -83,6 +90,7 @@ pub struct EDASeqFit { converged : Bool } +///| /// Result of between-lane normalization pub struct EDASeqBetweenResult { /// Normalized counts @@ -93,6 +101,7 @@ pub struct EDASeqBetweenResult { norm_method : EDASeqBetweenMethod } +///| /// Complete EDASeq normalization result pub struct EDASeqResult { /// Within-lane normalized counts (if applied) @@ -109,6 +118,7 @@ pub struct EDASeqResult { sample_ids : Array[String] } +///| /// Parameters for EDASeq normalization pub struct EDASeqParams { /// Normalization type @@ -125,6 +135,7 @@ pub struct EDASeqParams { log_transform : Bool } +///| /// Create default parameters pub fn EDASeqParams::new() -> EDASeqParams { EDASeqParams::{ @@ -133,23 +144,24 @@ pub fn EDASeqParams::new() -> EDASeqParams { between_method: EDASeqBetweenMethod::MedianRatio, loess_span: 0.75, min_count: 0.5, - log_transform: true + log_transform: true, } } // ===== Gene annotation ===== +///| /// Create a new gene annotation -pub fn EDASeqGeneAnno::new(gene_id : String, gc_content : Double, length : Double) -> EDASeqGeneAnno { +pub fn EDASeqGeneAnno::new( + gene_id : String, + gc_content : Double, + length : Double, +) -> EDASeqGeneAnno { let eff_len = if length > 200.0 { length } else { 200.0 } - EDASeqGeneAnno::{ - gene_id, - gc_content, - length, - effective_length: eff_len - } + EDASeqGeneAnno::{ gene_id, gc_content, length, effective_length: eff_len } } +///| /// Compute RPKM scaling factor (1000/gene_length) pub fn EDASeqGeneAnno::eda_rpkm_scale(self : EDASeqGeneAnno) -> Double { if self.effective_length > 0.0 { @@ -161,12 +173,13 @@ pub fn EDASeqGeneAnno::eda_rpkm_scale(self : EDASeqGeneAnno) -> Double { // ===== DataSet methods ===== +///| /// Create a new EDASeqDataSet pub fn EDASeqDataSet::new( gene_ids : Array[String], sample_ids : Array[String], counts : Array[Array[Double]], - annotations : Array[EDASeqGeneAnno] + annotations : Array[EDASeqGeneAnno], ) -> EDASeqDataSet { let n_samples = sample_ids.length() let lib_sizes : Array[Double] = Array::new() @@ -181,32 +194,36 @@ pub fn EDASeqDataSet::new( lib_sizes.push(sum) s = s + 1 } - EDASeqDataSet::{ - gene_ids, - sample_ids, - counts, - annotations, - lib_sizes - } + EDASeqDataSet::{ gene_ids, sample_ids, counts, annotations, lib_sizes } } +///| /// Get number of genes pub fn EDASeqDataSet::eda_n_genes(self : EDASeqDataSet) -> Int { self.gene_ids.length() } +///| /// Get number of samples pub fn EDASeqDataSet::eda_n_samples(self : EDASeqDataSet) -> Int { self.sample_ids.length() } +///| /// Get a gene's counts across samples -pub fn EDASeqDataSet::eda_gene_counts(self : EDASeqDataSet, gene_idx : Int) -> Array[Double] { +pub fn EDASeqDataSet::eda_gene_counts( + self : EDASeqDataSet, + gene_idx : Int, +) -> Array[Double] { self.counts[gene_idx].copy() } +///| /// Get a sample's counts across genes -pub fn EDASeqDataSet::eda_sample_counts(self : EDASeqDataSet, sample_idx : Int) -> Array[Double] { +pub fn EDASeqDataSet::eda_sample_counts( + self : EDASeqDataSet, + sample_idx : Int, +) -> Array[Double] { let result : Array[Double] = Array::new() let mut i = 0 while i < self.counts.length() { @@ -220,7 +237,10 @@ pub fn EDASeqDataSet::eda_sample_counts(self : EDASeqDataSet, sample_idx : Int) ///| /// Compute GC content-based within-lane normalization. -pub fn eda_normalize_within_lane(data : EDASeqDataSet, params : EDASeqParams) -> EDASeqWithinResult { +pub fn eda_normalize_within_lane( + data : EDASeqDataSet, + params : EDASeqParams, +) -> EDASeqWithinResult { let n_genes = data.gene_ids.length() let n_samples = data.sample_ids.length() let gc_fits : Array[EDASeqFit] = Array::new() @@ -235,7 +255,11 @@ pub fn eda_normalize_within_lane(data : EDASeqDataSet, params : EDASeqParams) -> let length_values : Array[Double] = Array::new() let mut g = 0 while g < n_genes { - let c = if sample_counts[g] > 0.0 { sample_counts[g] } else { params.min_count } + let c = if sample_counts[g] > 0.0 { + sample_counts[g] + } else { + params.min_count + } log_counts.push(@math.ln(c)) gc_values.push(data.annotations[g].gc_content) length_values.push(data.annotations[g].effective_length) @@ -243,7 +267,11 @@ pub fn eda_normalize_within_lane(data : EDASeqDataSet, params : EDASeqParams) -> } // Apply within-lane normalization let (norm_sample_log, gc_fit, len_fit) = eda_apply_within_norm( - log_counts, gc_values, length_values, data.lib_sizes[s], params + log_counts, + gc_values, + length_values, + data.lib_sizes[s], + params, ) gc_fits.push(gc_fit) length_fits.push(len_fit) @@ -275,7 +303,7 @@ pub fn eda_normalize_within_lane(data : EDASeqDataSet, params : EDASeqParams) -> norm_counts: result, gc_fits, length_fits, - norm_method: params.within_method + norm_method: params.within_method, } } @@ -286,20 +314,20 @@ fn eda_apply_within_norm( gc_values : Array[Double], length_values : Array[Double], lib_size : Double, - params : EDASeqParams + params : EDASeqParams, ) -> (Array[Double], EDASeqFit, EDASeqFit) { let n = log_counts.length() let gc_fit_default = EDASeqFit::{ span: params.loess_span, fitted: Array::new(), residuals: Array::new(), - converged: false + converged: false, } let len_fit_default = EDASeqFit::{ span: params.loess_span, fitted: Array::new(), residuals: Array::new(), - converged: false + converged: false, } let lib_adj = if lib_size > 0.0 { lib_size } else { 1.0 } let log_lib = @math.ln(lib_adj) @@ -311,19 +339,36 @@ fn eda_apply_within_norm( i = i + 1 } // Apply GC correction - let (gc_corrected, gc_fit) = eda_gc_correction(base_norm, gc_values, params.loess_span) + let (gc_corrected, gc_fit) = eda_gc_correction( + base_norm, + gc_values, + params.loess_span, + ) // Apply length correction - let (final_norm, len_fit) = eda_length_correction(gc_corrected, length_values, params.loess_span) + let (final_norm, len_fit) = eda_length_correction( + gc_corrected, + length_values, + params.loess_span, + ) (final_norm, gc_fit, len_fit) } ///| /// GC content-based loess correction. -fn eda_gc_correction(log_counts : Array[Double], gc_values : Array[Double], span : Double) -> (Array[Double], EDASeqFit) { +fn eda_gc_correction( + log_counts : Array[Double], + gc_values : Array[Double], + span : Double, +) -> (Array[Double], EDASeqFit) { let n = log_counts.length() if n < 4 { let result = log_counts.copy() - let fit = EDASeqFit::{ span, fitted: Array::new(), residuals: Array::new(), converged: false } + let fit = EDASeqFit::{ + span, + fitted: Array::new(), + residuals: Array::new(), + converged: false, + } return (result, fit) } // Apply loess smoothing @@ -351,11 +396,20 @@ fn eda_gc_correction(log_counts : Array[Double], gc_values : Array[Double], span ///| /// Gene length-based loess correction. -fn eda_length_correction(log_counts : Array[Double], length_values : Array[Double], span : Double) -> (Array[Double], EDASeqFit) { +fn eda_length_correction( + log_counts : Array[Double], + length_values : Array[Double], + span : Double, +) -> (Array[Double], EDASeqFit) { let n = log_counts.length() if n < 4 { let result = log_counts.copy() - let fit = EDASeqFit::{ span, fitted: Array::new(), residuals: Array::new(), converged: false } + let fit = EDASeqFit::{ + span, + fitted: Array::new(), + residuals: Array::new(), + converged: false, + } return (result, fit) } // Use log-length for smoothing @@ -388,9 +442,15 @@ fn eda_length_correction(log_counts : Array[Double], length_values : Array[Doubl ///| /// Simple loess smoothing (locally weighted regression). -fn eda_loess_smooth(x : Array[Double], y : Array[Double], span : Double) -> Array[Double] { +fn eda_loess_smooth( + x : Array[Double], + y : Array[Double], + span : Double, +) -> Array[Double] { let n = x.length() - if n < 3 { return y.copy() } + if n < 3 { + return y.copy() + } let result : Array[Double] = Array::new() let half_span = span * 0.5 let mut i = 0 @@ -448,7 +508,10 @@ fn eda_loess_smooth(x : Array[Double], y : Array[Double], span : Double) -> Arra ///| /// Compute between-lane normalization. -pub fn eda_normalize_between_lane(data : EDASeqDataSet, params : EDASeqParams) -> EDASeqBetweenResult { +pub fn eda_normalize_between_lane( + data : EDASeqDataSet, + params : EDASeqParams, +) -> EDASeqBetweenResult { let n_genes = data.gene_ids.length() let n_samples = data.sample_ids.length() // Compute size factors @@ -470,17 +533,22 @@ pub fn eda_normalize_between_lane(data : EDASeqDataSet, params : EDASeqParams) - EDASeqBetweenResult::{ norm_counts, size_factors, - norm_method: params.between_method + norm_method: params.between_method, } } ///| /// Compute size factors for between-lane normalization. -fn eda_compute_size_factors(counts : Array[Array[Double]], params : EDASeqParams) -> Array[Double] { +fn eda_compute_size_factors( + counts : Array[Array[Double]], + params : EDASeqParams, +) -> Array[Double] { let n_genes = counts.length() let n_samples = if n_genes > 0 { counts[0].length() } else { 0 } let size_factors : Array[Double] = Array::new() - if n_samples == 0 { return size_factors } + if n_samples == 0 { + return size_factors + } match params.between_method { EDASeqBetweenMethod::MedianRatio => { @@ -506,7 +574,11 @@ fn eda_compute_size_factors(counts : Array[Array[Double]], params : EDASeqParams let ratios : Array[Double] = Array::new() let mut g2 = 0 while g2 < n_genes { - let c = if counts[g2][s2] > 0.0 { counts[g2][s2] } else { params.min_count } + let c = if counts[g2][s2] > 0.0 { + counts[g2][s2] + } else { + params.min_count + } if geo_means[g2] > 0.0 { ratios.push(c / geo_means[g2]) } @@ -556,18 +628,28 @@ fn eda_compute_size_factors(counts : Array[Array[Double]], params : EDASeqParams size_factors } +///| /// Compute median fn eda_median(arr : Array[Double]) -> Double { let n = arr.length() - if n == 0 { return 1.0 } + if n == 0 { + return 1.0 + } let sorted = eda_sort(arr) - if n % 2 == 1 { sorted[n / 2] } else { (sorted[n / 2 - 1] + sorted[n / 2]) / 2.0 } + if n % 2 == 1 { + sorted[n / 2] + } else { + (sorted[n / 2 - 1] + sorted[n / 2]) / 2.0 + } } +///| /// Compute mean fn eda_mean(arr : Array[Double]) -> Double { let n = arr.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut sum = 0.0 let mut i = 0 while i < n { @@ -577,6 +659,7 @@ fn eda_mean(arr : Array[Double]) -> Double { sum / n.to_double() } +///| /// Sort array fn eda_sort(arr : Array[Double]) -> Array[Double] { let result = arr.copy() @@ -614,7 +697,7 @@ pub fn eda_run(data : EDASeqDataSet, params : EDASeqParams) -> EDASeqResult { norm_counts: within.norm_counts, norm_type: params.norm_type, gene_ids: data.gene_ids, - sample_ids: data.sample_ids + sample_ids: data.sample_ids, } } EDASeqNormType::BetweenLane => { @@ -625,7 +708,7 @@ pub fn eda_run(data : EDASeqDataSet, params : EDASeqParams) -> EDASeqResult { norm_counts: between.norm_counts, norm_type: params.norm_type, gene_ids: data.gene_ids, - sample_ids: data.sample_ids + sample_ids: data.sample_ids, } } EDASeqNormType::Full => { @@ -635,7 +718,7 @@ pub fn eda_run(data : EDASeqDataSet, params : EDASeqParams) -> EDASeqResult { data.gene_ids, data.sample_ids, within.norm_counts, - data.annotations + data.annotations, ) let between = eda_normalize_between_lane(within_data, params) EDASeqResult::{ @@ -644,7 +727,7 @@ pub fn eda_run(data : EDASeqDataSet, params : EDASeqParams) -> EDASeqResult { norm_counts: between.norm_counts, norm_type: params.norm_type, gene_ids: data.gene_ids, - sample_ids: data.sample_ids + sample_ids: data.sample_ids, } } } @@ -654,7 +737,11 @@ pub fn eda_run(data : EDASeqDataSet, params : EDASeqParams) -> EDASeqResult { ///| /// Compute RPKM (Reads Per Kilobase per Million) normalization. -pub fn eda_rpkm(counts : Array[Array[Double]], annotations : Array[EDASeqGeneAnno], lib_sizes : Array[Double]) -> Array[Array[Double]] { +pub fn eda_rpkm( + counts : Array[Array[Double]], + annotations : Array[EDASeqGeneAnno], + lib_sizes : Array[Double], +) -> Array[Array[Double]] { let n_genes = counts.length() let n_samples = if n_genes > 0 { counts[0].length() } else { 0 } let rpkm : Array[Array[Double]] = Array::new() @@ -665,7 +752,11 @@ pub fn eda_rpkm(counts : Array[Array[Double]], annotations : Array[EDASeqGeneAnn let scale = anno.eda_rpkm_scale() let mut s = 0 while s < n_samples { - let lib_scale = if lib_sizes[s] > 0.0 { 1.0e6 / lib_sizes[s] } else { 0.0 } + let lib_scale = if lib_sizes[s] > 0.0 { + 1.0e6 / lib_sizes[s] + } else { + 0.0 + } let val = counts[g][s] * scale * lib_scale row.push(val) s = s + 1 @@ -678,7 +769,11 @@ pub fn eda_rpkm(counts : Array[Array[Double]], annotations : Array[EDASeqGeneAnn ///| /// Compute TPM (Transcripts Per Million) normalization. -pub fn eda_tpm(counts : Array[Array[Double]], annotations : Array[EDASeqGeneAnno], lib_sizes : Array[Double]) -> Array[Array[Double]] { +pub fn eda_tpm( + counts : Array[Array[Double]], + annotations : Array[EDASeqGeneAnno], + lib_sizes : Array[Double], +) -> Array[Array[Double]] { let n_genes = counts.length() let n_samples = if n_genes > 0 { counts[0].length() } else { 0 } let tpm : Array[Array[Double]] = Array::new() @@ -734,18 +829,31 @@ pub fn eda_tpm(counts : Array[Array[Double]], annotations : Array[EDASeqGeneAnno // ===== Accessor methods ===== +///| /// Get a normalized count -pub fn EDASeqResult::eda_get_count(self : EDASeqResult, gene_idx : Int, sample_idx : Int) -> Double { +pub fn EDASeqResult::eda_get_count( + self : EDASeqResult, + gene_idx : Int, + sample_idx : Int, +) -> Double { self.norm_counts[gene_idx][sample_idx] } +///| /// Get normalized counts for a gene -pub fn EDASeqResult::eda_get_gene(self : EDASeqResult, gene_idx : Int) -> Array[Double] { +pub fn EDASeqResult::eda_get_gene( + self : EDASeqResult, + gene_idx : Int, +) -> Array[Double] { self.norm_counts[gene_idx].copy() } +///| /// Get normalized counts for a sample -pub fn EDASeqResult::eda_get_sample(self : EDASeqResult, sample_idx : Int) -> Array[Double] { +pub fn EDASeqResult::eda_get_sample( + self : EDASeqResult, + sample_idx : Int, +) -> Array[Double] { let result : Array[Double] = Array::new() let mut i = 0 while i < self.norm_counts.length() { @@ -755,22 +863,29 @@ pub fn EDASeqResult::eda_get_sample(self : EDASeqResult, sample_idx : Int) -> Ar result } +///| /// Get number of genes pub fn EDASeqResult::eda_n_genes(self : EDASeqResult) -> Int { self.gene_ids.length() } +///| /// Get number of samples pub fn EDASeqResult::eda_n_samples(self : EDASeqResult) -> Int { self.sample_ids.length() } +///| /// Get gene ID pub fn EDASeqResult::eda_get_gene_id(self : EDASeqResult, idx : Int) -> String { self.gene_ids[idx] } +///| /// Get sample ID -pub fn EDASeqResult::eda_get_sample_id(self : EDASeqResult, idx : Int) -> String { +pub fn EDASeqResult::eda_get_sample_id( + self : EDASeqResult, + idx : Int, +) -> String { self.sample_ids[idx] } diff --git a/src/edger_advanced.mbt b/src/edger_advanced.mbt index c3c663d5..58060489 100644 --- a/src/edger_advanced.mbt +++ b/src/edger_advanced.mbt @@ -116,8 +116,18 @@ pub fn glm_qlf_fit(dge : DGEList) -> QLFData { // QL dispersion = deviance / residual_df let residual_df = n_samples - n_coef let ql_disp = if residual_df > 0 { - let d = if deviance.is_nan() || deviance.abs() > 1.0e300 { 1.0 } else { deviance / residual_df.to_double() } - if d < 0.0 { 0.001 } else if d > 100.0 { 100.0 } else { d } + let d = if deviance.is_nan() || deviance.abs() > 1.0e300 { + 1.0 + } else { + deviance / residual_df.to_double() + } + if d < 0.0 { + 0.001 + } else if d > 100.0 { + 100.0 + } else { + d + } } else { 1.0 } @@ -154,10 +164,18 @@ pub fn glm_qlf_fit(dge : DGEList) -> QLFData { let residual_df = (n_samples - n_coef).to_double() let shrunk_ql_disp : Array[Double] = Array::new() for i = 0; i < n_genes; i = i + 1 { - let raw = if raw_ql_disp[i].is_nan() || raw_ql_disp[i].abs() > 1.0e300 { 1.0 } else { raw_ql_disp[i] } + let raw = if raw_ql_disp[i].is_nan() || raw_ql_disp[i].abs() > 1.0e300 { + 1.0 + } else { + raw_ql_disp[i] + } let shrunk = (residual_df * raw + prior_df * trend) / (residual_df + prior_df) - let shrunk_safe = if shrunk.is_nan() || shrunk.abs() > 1.0e300 { 1.0 } else { shrunk } + let shrunk_safe = if shrunk.is_nan() || shrunk.abs() > 1.0e300 { + 1.0 + } else { + shrunk + } shrunk_ql_disp.push(if shrunk_safe < 0.001 { 0.001 } else { shrunk_safe }) } @@ -192,11 +210,7 @@ fn fit_nb_glm( total = total + counts[j].to_double() } let mean_count = total / n_samples.to_double() - let init_log_mu = if mean_count > 0.0 { - @math.ln(mean_count) - } else { - 0.0 - } + let init_log_mu = if mean_count > 0.0 { @math.ln(mean_count) } else { 0.0 } for k = 0; k < n_coef; k = k + 1 { coefs[k] = if k == 0 { init_log_mu } else { 0.0 } } @@ -217,8 +231,12 @@ fn fit_nb_glm( eta = eta + design[j][k] * coefs[k] } // Cap eta to prevent overflow in exp() - if eta > 500.0 { eta = 500.0 } - if eta < -500.0 { eta = -500.0 } + if eta > 500.0 { + eta = 500.0 + } + if eta < -500.0 { + eta = -500.0 + } let exp_eta = @math.exp(eta) if exp_eta.is_nan() || exp_eta.abs() > 1.0e300 { fitted[j] = 1000000.0 @@ -277,7 +295,9 @@ fn fit_nb_glm( let y = counts[j].to_double() let mu = fitted[j] if y > 0.0 && mu > 0.0 && !mu.is_nan() && mu.abs() <= 1.0e300 { - let term = y * @math.ln(y / mu) - (y + 1.0 / nb_disp) * @math.ln((1.0 + nb_disp * y) / (1.0 + nb_disp * mu)) + let term = y * @math.ln(y / mu) - + (y + 1.0 / nb_disp) * + @math.ln((1.0 + nb_disp * y) / (1.0 + nb_disp * mu)) let contrib = 2.0 * term if contrib.is_nan() || contrib < 0.0 { // Numerical issues, use a small positive value @@ -410,17 +430,32 @@ pub fn glm_qlf_test(qlf_data : QLFData, coef? : Int = 1) -> QLFResult { if mu > 0.0 && !mu.is_nan() && mu.abs() <= 1.0e300 { let w = mu / (1.0 + ql * mu) // Design matrix: [1, x_j] - let x_coef = if coef == 0 { 1.0 } else { if qlf_data.group[j] == qlf_data.group[0] { 0.0 } else { 1.0 } } + let x_coef = if coef == 0 { + 1.0 + } else if qlf_data.group[j] == qlf_data.group[0] { + 0.0 + } else { + 1.0 + } info_coef = info_coef + w * x_coef * x_coef } } let var_beta = if info_coef > 0.0 { 1.0 / info_coef } else { 1.0 } - let f = if ql.is_nan() || ql.abs() > 1.0e300 || var_beta.is_nan() || var_beta.abs() > 1.0e300 || beta.is_nan() || beta.abs() > 1.0e300 { + let f = if ql.is_nan() || + ql.abs() > 1.0e300 || + var_beta.is_nan() || + var_beta.abs() > 1.0e300 || + beta.is_nan() || + beta.abs() > 1.0e300 { 0.0 } else if ql * var_beta > 0.0 { let f_raw = beta * beta / (ql * var_beta) - if f_raw.is_nan() || f_raw.abs() > 1.0e300 { 0.0 } else { f_raw } + if f_raw.is_nan() || f_raw.abs() > 1.0e300 { + 0.0 + } else { + f_raw + } } else { 0.0 } @@ -468,7 +503,13 @@ fn f_distribution_pvalue(f : Double, df1 : Int, df2 : Int) -> Double { let b = df1.to_double() / 2.0 let p = regularized_incomplete_beta(x, a, b) - if p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p } + if p < 0.0 { + 0.0 + } else if p > 1.0 { + 1.0 + } else { + p + } } ///| @@ -516,7 +557,10 @@ fn edger_betacf(x : Double, a : Double, b : Double) -> Double { let mut m = 1 while m <= max_iter { let m2 = 2 * m - let aa = m.to_double() * (m.to_double() - qam) * x / ((qam + m2.to_double()) * (a + m2.to_double())) + let aa = m.to_double() * + (m.to_double() - qam) * + x / + ((qam + m2.to_double()) * (a + m2.to_double())) d = 1.0 + aa * d if d.abs() < eps { d = eps @@ -528,7 +572,10 @@ fn edger_betacf(x : Double, a : Double, b : Double) -> Double { d = 1.0 / d h = h * d * c - let aa2 = -(a + m.to_double()) * (qab + m.to_double()) * x / ((a + m2.to_double()) * (qap + m2.to_double())) + let aa2 = -(a + m.to_double()) * + (qab + m.to_double()) * + x / + ((a + m2.to_double()) * (qap + m2.to_double())) d = 1.0 + aa2 * d if d.abs() < eps { d = eps @@ -580,20 +627,15 @@ fn edger_sin(x : Double) -> Double { fn log_gamma(x : Double) -> Double { if x < 0.5 { // Use reflection formula: Gamma(x)Gamma(1-x) = pi/sin(pi*x) - return @math.ln(3.141592653589793 / edger_sin(3.141592653589793 * x)) - log_gamma(1.0 - x) + return @math.ln(3.141592653589793 / edger_sin(3.141592653589793 * x)) - + log_gamma(1.0 - x) } let g = 7.0 // Lanczos coefficients let c = [ - 0.99999999999980993, - 676.5203681218851, - -1259.1392167224028, - 771.32342877765313, - -176.61502916214059, - 12.507343278686905, - -0.13857109526572012, - 9.9843695780195716e-6, + 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, + -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7, ] @@ -606,7 +648,10 @@ fn log_gamma(x : Double) -> Double { i = i + 1 } - 0.5 * @math.ln(2.0 * 3.141592653589793) + (y + 0.5) * @math.ln(tmp) - tmp + @math.ln(sum) + 0.5 * @math.ln(2.0 * 3.141592653589793) + + (y + 0.5) * @math.ln(tmp) - + tmp + + @math.ln(sum) } ///| @@ -769,16 +814,13 @@ pub fn camera( let n_unset = unset_stats.length() // Camera statistic: two-sample t-test comparing set vs unset - let pooled_var = ((n_set - 1).to_double() * set_var + - (n_unset - 1).to_double() * unset_var) / + let pooled_var = ( + (n_set - 1).to_double() * set_var + (n_unset - 1).to_double() * unset_var + ) / (n_set + n_unset - 2).to_double() let se = (pooled_var * (1.0 / n_set.to_double() + 1.0 / n_unset.to_double())).sqrt() - let t_stat = if se > 0.0 { - (set_mean - unset_mean) / se - } else { - 0.0 - } + let t_stat = if se > 0.0 { (set_mean - unset_mean) / se } else { 0.0 } // Two-sided p-value from t-distribution (approximate using normal) let p_val = 2.0 * (1.0 - edger_normal_cdf(t_stat.abs())) @@ -827,7 +869,8 @@ pub fn roast( // Z-score let n_set = set_stats.length() let z = if n_set > 0 { - (mean_stat - expected_mean) / (expected_mean * 2.0 / n_set.to_double()).sqrt() + (mean_stat - expected_mean) / + (expected_mean * 2.0 / n_set.to_double()).sqrt() } else { 0.0 } @@ -849,9 +892,18 @@ fn edger_normal_cdf(x : Double) -> Double { /// Error function (Abramowitz and Stegun approximation). fn erf(x : Double) -> Double { let t = 1.0 / (1.0 + 0.3275911 * x.abs()) - let poly = t * (0.254829592 + t * (-0.284496736 + t * (1.421413741 + t * (-1.453152027 + t * 1.061405429)))) + let poly = t * + ( + 0.254829592 + + t * + (-0.284496736 + t * (1.421413741 + t * (-1.453152027 + t * 1.061405429))) + ) let result = 1.0 - poly * @math.exp(-x * x) - if x >= 0.0 { result } else { -result } + if x >= 0.0 { + result + } else { + -result + } } ///| @@ -912,7 +964,14 @@ pub fn qlf_top_genes( let top : Array[(String, Double, Double, Double)] = Array::new() for i = 0; i < actual_n; i = i + 1 { let idx = indices[i] - top.push((result.genes[idx], result.log_fc[idx], result.f_stat[idx], result.fdr[idx])) + top.push( + ( + result.genes[idx], + result.log_fc[idx], + result.f_stat[idx], + result.fdr[idx], + ), + ) } top } diff --git a/src/embl_io.mbt b/src/embl_io.mbt index 71f9aa6d..ba9d810c 100644 --- a/src/embl_io.mbt +++ b/src/embl_io.mbt @@ -56,6 +56,7 @@ fn uppercase_string(s : String) -> String { buf.to_string() } +///| pub fn parse_embl(content : String) -> Array[SeqRecord] { let records = Array::new() let lines = content.split("\n").to_array() @@ -92,7 +93,9 @@ pub fn parse_embl(content : String) -> Array[SeqRecord] { } let mut name_end = j let semi : UInt16 = ';'.to_int().to_uint16() - while name_end < rl && id_rest.unsafe_get(name_end) != semi && id_rest.unsafe_get(name_end) != sp { + while name_end < rl && + id_rest.unsafe_get(name_end) != semi && + id_rest.unsafe_get(name_end) != sp { name_end = name_end + 1 } name = id_rest[j:name_end].to_owned() @@ -123,7 +126,8 @@ pub fn parse_embl(content : String) -> Array[SeqRecord] { } // AC line: "AC ACC1; ACC2;" - if !have_ac && lt >= 2 && + if !have_ac && + lt >= 2 && l.unsafe_get(0) == 'A'.to_int().to_uint16() && l.unsafe_get(1) == 'C'.to_int().to_uint16() && (lt == 2 || l.unsafe_get(2) == sp) { @@ -136,7 +140,9 @@ pub fn parse_embl(content : String) -> Array[SeqRecord] { } let mut ac_end = aj let semi : UInt16 = ';'.to_int().to_uint16() - while ac_end < apl && ac_part.unsafe_get(ac_end) != semi && ac_part.unsafe_get(ac_end) != sp { + while ac_end < apl && + ac_part.unsafe_get(ac_end) != semi && + ac_part.unsafe_get(ac_end) != sp { ac_end = ac_end + 1 } if ac_end > aj { @@ -173,8 +179,8 @@ pub fn parse_embl(content : String) -> Array[SeqRecord] { } if ct < 2 || !(cont.unsafe_get(0) == 'D'.to_int().to_uint16() && - cont.unsafe_get(1) == 'E'.to_int().to_uint16() && - (ct == 2 || cont.unsafe_get(2) == sp)) { + cont.unsafe_get(1) == 'E'.to_int().to_uint16() && + (ct == 2 || cont.unsafe_get(2) == sp)) { break } def_buf.write_char(' ') @@ -210,8 +216,7 @@ pub fn parse_embl(content : String) -> Array[SeqRecord] { while k < lt { let c = l.unsafe_get(k) let ci = c.to_int() - let is_base = - (ci >= 'A'.to_int() && ci <= 'Z'.to_int()) || + let is_base = (ci >= 'A'.to_int() && ci <= 'Z'.to_int()) || (ci >= 'a'.to_int() && ci <= 'z'.to_int()) || c == '-'.to_int().to_uint16() if is_base { @@ -224,8 +229,7 @@ pub fn parse_embl(content : String) -> Array[SeqRecord] { for j = 0; j < lt; j = j + 1 { let c = l.unsafe_get(j) let ci = c.to_int() - let is_base = - (ci >= 'A'.to_int() && ci <= 'Z'.to_int()) || + let is_base = (ci >= 'A'.to_int() && ci <= 'Z'.to_int()) || (ci >= 'a'.to_int() && ci <= 'z'.to_int()) || c == '-'.to_int().to_uint16() if is_base { @@ -247,12 +251,9 @@ pub fn parse_embl(content : String) -> Array[SeqRecord] { // Uppercase the sequence for consistency with GenBank parser let seq_str = seq_buf.to_string() let seq_uppercased = uppercase_string(seq_str) - records.push(SeqRecord::new( - Seq::new(seq_uppercased), - id=id, - name=name, - description=description, - )) + records.push( + SeqRecord::new(Seq::new(seq_uppercased), id~, name~, description~), + ) continue } diff --git a/src/enhanced_volcano.mbt b/src/enhanced_volcano.mbt index 924dd9b0..845c881f 100644 --- a/src/enhanced_volcano.mbt +++ b/src/enhanced_volcano.mbt @@ -192,7 +192,9 @@ pub fn VolcanoResult::get_genes(self : VolcanoResult) -> Array[VolcanoGene] { ///| /// Get significant genes only. -pub fn VolcanoResult::get_significant_genes(self : VolcanoResult) -> Array[VolcanoGene] { +pub fn VolcanoResult::get_significant_genes( + self : VolcanoResult, +) -> Array[VolcanoGene] { let sig : Array[VolcanoGene] = Array::new() let mut i = 0 while i < self.genes.length() { @@ -206,7 +208,10 @@ pub fn VolcanoResult::get_significant_genes(self : VolcanoResult) -> Array[Volca ///| /// Get top significant genes by p-value. -pub fn VolcanoResult::get_top_genes(self : VolcanoResult, n : Int) -> Array[VolcanoGene] { +pub fn VolcanoResult::get_top_genes( + self : VolcanoResult, + n : Int, +) -> Array[VolcanoGene] { let sig = self.get_significant_genes() let sorted = sig.copy() let len = sorted.length() @@ -250,7 +255,9 @@ pub fn VolcanoResult::get_up_genes(self : VolcanoResult) -> Array[VolcanoGene] { ///| /// Get down-regulated genes. -pub fn VolcanoResult::get_down_genes(self : VolcanoResult) -> Array[VolcanoGene] { +pub fn VolcanoResult::get_down_genes( + self : VolcanoResult, +) -> Array[VolcanoGene] { let down : Array[VolcanoGene] = Array::new() let mut i = 0 while i < self.genes.length() { @@ -271,7 +278,11 @@ pub fn neg_log10_p(p_val : Double) -> Double { ///| /// Format the volcano result as an ASCII visualization. -pub fn VolcanoResult::to_ascii(self : VolcanoResult, width? : Int = 60, height? : Int = 20) -> String { +pub fn VolcanoResult::to_ascii( + self : VolcanoResult, + width? : Int = 60, + height? : Int = 20, +) -> String { let w = if width < 20 { 60 } else { width } let h = if height < 10 { 20 } else { height } @@ -283,10 +294,16 @@ pub fn VolcanoResult::to_ascii(self : VolcanoResult, width? : Int = 60, height? let mut i = 0 while i < self.genes.length() { let g = self.genes[i] - if g.log2fc < min_lfc { min_lfc = g.log2fc } - if g.log2fc > max_lfc { max_lfc = g.log2fc } + if g.log2fc < min_lfc { + min_lfc = g.log2fc + } + if g.log2fc > max_lfc { + max_lfc = g.log2fc + } let nlp = neg_log10_p(g.p_val) - if nlp > max_neglog { max_neglog = nlp } + if nlp > max_neglog { + max_neglog = nlp + } i = i + 1 } @@ -315,7 +332,9 @@ pub fn VolcanoResult::to_ascii(self : VolcanoResult, width? : Int = 60, height? // Mark significant cutoffs let x_zero = ((0.0 - min_lfc) / (max_lfc - min_lfc) * (w.to_double() - 1.0)).to_int() let y_cutoff_val = neg_log10_p(self.p_cutoff) - let y_cutoff_row = h - 1 - ((y_cutoff_val / nlp_range) * (h.to_double() - 1.0)).to_int() + let y_cutoff_row = h - + 1 - + (y_cutoff_val / nlp_range * (h.to_double() - 1.0)).to_int() // Draw vertical dashed line at x=0 let mut r2 = 0 @@ -341,9 +360,11 @@ pub fn VolcanoResult::to_ascii(self : VolcanoResult, width? : Int = 60, height? let mut i2 = 0 while i2 < self.genes.length() { let g = self.genes[i2] - let x_pos = ((g.log2fc - min_lfc) / (max_lfc - min_lfc) * (w.to_double() - 1.0)).to_int() + let x_pos = ((g.log2fc - min_lfc) / + (max_lfc - min_lfc) * + (w.to_double() - 1.0)).to_int() let nlp = neg_log10_p(g.p_val) - let y_pos = h - 1 - ((nlp / nlp_range) * (h.to_double() - 1.0)).to_int() + let y_pos = h - 1 - (nlp / nlp_range * (h.to_double() - 1.0)).to_int() if x_pos >= 0 && x_pos < w && y_pos >= 0 && y_pos < h { let ch = if g.classification is VolcanoClassification::Up { @@ -370,8 +391,20 @@ pub fn VolcanoResult::to_ascii(self : VolcanoResult, width? : Int = 60, height? } result = result + self.y_label + "\n" - result = result + "Cutoffs: p < " + self.p_cutoff.to_string() + ", |log2FC| >= " + self.fc_cutoff.to_string() + "\n" - result = result + "Up: " + self.n_up.to_string() + ", Down: " + self.n_down.to_string() + ", NS: " + self.n_nonsig.to_string() + "\n" + result = result + + "Cutoffs: p < " + + self.p_cutoff.to_string() + + ", |log2FC| >= " + + self.fc_cutoff.to_string() + + "\n" + result = result + + "Up: " + + self.n_up.to_string() + + ", Down: " + + self.n_down.to_string() + + ", NS: " + + self.n_nonsig.to_string() + + "\n" result } @@ -381,7 +414,12 @@ pub fn VolcanoResult::summary(self : VolcanoResult) -> String { let mut s = "=== Volcano Plot Summary ===\n".to_string() s = s + "Title: " + self.title + "\n" s = s + "Total genes: " + self.genes.length().to_string() + "\n" - s = s + "Significant (p < " + self.p_cutoff.to_string() + "): " + (self.n_up + self.n_down).to_string() + "\n" + s = s + + "Significant (p < " + + self.p_cutoff.to_string() + + "): " + + (self.n_up + self.n_down).to_string() + + "\n" s = s + " Up-regulated: " + self.n_up.to_string() + "\n" s = s + " Down-regulated: " + self.n_down.to_string() + "\n" s = s + " Non-significant: " + self.n_nonsig.to_string() + "\n" @@ -398,8 +436,11 @@ pub fn volcano_sample(n_genes : Int) -> VolcanoResult { let pvals : Array[Double] = Array::new() // Generate deterministic sample data - let names = ["TP53", "BRCA1", "BRCA2", "MYC", "KRAS", "EGFR", "PTEN", "APC", "RB1", "VHL", - "STAT3", "AKT1", "MTOR", "JAK2", "NOTCH1", "WNT3", "CTNNB1", "SMAD4", "NFKB1", "BCL2"] + let names = [ + "TP53", "BRCA1", "BRCA2", "MYC", "KRAS", "EGFR", "PTEN", "APC", "RB1", "VHL", + "STAT3", "AKT1", "MTOR", "JAK2", "NOTCH1", "WNT3", "CTNNB1", "SMAD4", "NFKB1", + "BCL2", + ] let mut i = 0 while i < n { @@ -407,14 +448,23 @@ pub fn volcano_sample(n_genes : Int) -> VolcanoResult { ids.push(names[idx] + "_" + i.to_string()) // Create varied log2FC and p-values - let lfc_val = if i % 4 == 0 { 2.5 + (i.to_double() * 0.1) } - else if i % 4 == 1 { -2.8 - (i.to_double() * 0.1) } - else if i % 4 == 2 { 0.3 + (i.to_double() * 0.05) } - else { -0.2 - (i.to_double() * 0.03) } + let lfc_val = if i % 4 == 0 { + 2.5 + i.to_double() * 0.1 + } else if i % 4 == 1 { + -2.8 - i.to_double() * 0.1 + } else if i % 4 == 2 { + 0.3 + i.to_double() * 0.05 + } else { + -0.2 - i.to_double() * 0.03 + } - let p_val = if i % 3 == 0 { 0.001 / (1.0 + i.to_double()) } - else if i % 3 == 1 { 0.01 + (i.to_double() * 0.005) } - else { 0.05 + (i.to_double() * 0.02) } + let p_val = if i % 3 == 0 { + 0.001 / (1.0 + i.to_double()) + } else if i % 3 == 1 { + 0.01 + i.to_double() * 0.005 + } else { + 0.05 + i.to_double() * 0.02 + } lfcs.push(lfc_val) pvals.push(p_val) @@ -422,4 +472,4 @@ pub fn volcano_sample(n_genes : Int) -> VolcanoResult { } volcano_plot_default(ids, lfcs, pvals) -} \ No newline at end of file +} diff --git a/src/enriched_heatmap.mbt b/src/enriched_heatmap.mbt index e4383910..01ad82bf 100644 --- a/src/enriched_heatmap.mbt +++ b/src/enriched_heatmap.mbt @@ -222,16 +222,14 @@ fn make_windows( let w_end = w_start + config.w - 1 // For minus strand, reverse the window index. let actual_wi = if is_minus { n_up - 1 - wi } else { wi } - windows.push( - Window::{ - chr: t.chr, - start: w_start, - end_: w_end, - targetIndex: ti, - windowIndex: actual_wi, - isTarget: false, - }, - ) + windows.push(Window::{ + chr: t.chr, + start: w_start, + end_: w_end, + targetIndex: ti, + windowIndex: actual_wi, + isTarget: false, + }) wi = wi + 1 } // Target body windows (if includeTarget and k > 0). @@ -245,22 +243,16 @@ fn make_windows( let mut ki = 0 while ki < config.k { let w_start = tStart + ki * kw - let w_end = if ki == config.k - 1 { - tEnd - } else { - w_start + kw - 1 - } + let w_end = if ki == config.k - 1 { tEnd } else { w_start + kw - 1 } let actual_ki = if is_minus { config.k - 1 - ki } else { ki } - windows.push( - Window::{ - chr: t.chr, - start: w_start, - end_: w_end, - targetIndex: ti, - windowIndex: n_up + actual_ki, - isTarget: true, - }, - ) + windows.push(Window::{ + chr: t.chr, + start: w_start, + end_: w_end, + targetIndex: ti, + windowIndex: n_up + actual_ki, + isTarget: true, + }) ki = ki + 1 } } @@ -274,17 +266,16 @@ fn make_windows( } let w_end = w_start + config.w - 1 let actual_di = if is_minus { n_down - 1 - di } else { di } - let base_idx = n_up + (if config.includeTarget && config.k > 0 { config.k } else { 0 }) - windows.push( - Window::{ - chr: t.chr, - start: w_start, - end_: w_end, - targetIndex: ti, - windowIndex: base_idx + actual_di, - isTarget: false, - }, - ) + let base_idx = n_up + + (if config.includeTarget && config.k > 0 { config.k } else { 0 }) + windows.push(Window::{ + chr: t.chr, + start: w_start, + end_: w_end, + targetIndex: ti, + windowIndex: base_idx + actual_di, + isTarget: false, + }) di = di + 1 } ti = ti + 1 @@ -333,7 +324,8 @@ fn compute_window_mean( let mut si = 0 while si < signals.length() { let s = signals[si] - if s.chr == window.chr && overlaps(s.start, s.end_, window.start, window.end_) { + if s.chr == window.chr && + overlaps(s.start, s.end_, window.start, window.end_) { let ow = overlap_width(s.start, s.end_, window.start, window.end_) values.push(s.value) widths.push(ow) @@ -366,7 +358,11 @@ fn compute_window_mean( wtot = wtot + w i = i + 1 } - if wtot > 0.0 { wsum / wtot } else { background } + if wtot > 0.0 { + wsum / wtot + } else { + background + } } W0 => { // Like weighted, but denominator includes non-covered bp. @@ -381,7 +377,11 @@ fn compute_window_mean( } let non_overlap = w_width.to_double() - total_overlap.to_double() let denom = wtot + non_overlap - if denom > 0.0 { wsum / denom } else { background } + if denom > 0.0 { + wsum / denom + } else { + background + } } Coverage => { // Weighted sum divided by total window width. @@ -393,7 +393,11 @@ fn compute_window_mean( i = i + 1 } let denom = w_width.to_double() - if denom > 0.0 { wsum / denom } else { background } + if denom > 0.0 { + wsum / denom + } else { + background + } } } } @@ -594,7 +598,12 @@ pub fn normalize_to_matrix( let mut wi = 0 while wi < windows.length() { let win = windows[wi] - let mean_val = compute_window_mean(win, signals, config.meanMode, config.background) + let mean_val = compute_window_mean( + win, + signals, + config.meanMode, + config.background, + ) matrix[win.targetIndex][win.windowIndex] = mean_val wi = wi + 1 } @@ -692,13 +701,27 @@ pub fn enriched_heatmap_summary(mat : NormalizedMatrix) -> String { buf.write_string("EnrichedHeatmap Normalized Matrix Summary\n") buf.write_string(" Rows (targets): " + mat.nRows.to_string() + "\n") buf.write_string(" Columns (windows): " + mat.nCols.to_string() + "\n") - buf.write_string(" Upstream windows: " + mat.upstreamIndex.length().to_string() + "\n") - buf.write_string(" Target body windows: " + mat.targetIndex.length().to_string() + "\n") - buf.write_string(" Downstream windows: " + mat.downstreamIndex.length().to_string() + "\n") - buf.write_string(" Extension: " + mat.extend.0.to_string() + " up, " + mat.extend.1.to_string() + " down\n") + buf.write_string( + " Upstream windows: " + mat.upstreamIndex.length().to_string() + "\n", + ) + buf.write_string( + " Target body windows: " + mat.targetIndex.length().to_string() + "\n", + ) + buf.write_string( + " Downstream windows: " + mat.downstreamIndex.length().to_string() + "\n", + ) + buf.write_string( + " Extension: " + + mat.extend.0.to_string() + + " up, " + + mat.extend.1.to_string() + + " down\n", + ) buf.write_string(" Smoothed: " + mat.smooth.to_string() + "\n") buf.write_string(" Background: " + mat.background.to_string() + "\n") - buf.write_string(" Failed rows: " + mat.failedRows.length().to_string() + "\n") + buf.write_string( + " Failed rows: " + mat.failedRows.length().to_string() + "\n", + ) let profile = enrichment_profile(mat) if profile.length() > 0 { let mut minVal = profile[0] @@ -716,7 +739,15 @@ pub fn enriched_heatmap_summary(mat : NormalizedMatrix) -> String { i = i + 1 } let mean = sum / profile.length().to_double() - buf.write_string(" Enrichment profile: min=" + minVal.to_string() + " max=" + maxVal.to_string() + " mean=" + mean.to_string() + "\n") + buf.write_string( + " Enrichment profile: min=" + + minVal.to_string() + + " max=" + + maxVal.to_string() + + " mean=" + + mean.to_string() + + "\n", + ) } buf.to_string() } diff --git a/src/enrichplot.mbt b/src/enrichplot.mbt index 872f088e..58ee7829 100644 --- a/src/enrichplot.mbt +++ b/src/enrichplot.mbt @@ -1,5 +1,4 @@ ///| - pub struct EnrichTerm { term_id : String term_name : String @@ -11,21 +10,46 @@ pub struct EnrichTerm { genes : Array[String] } +///| pub struct EnrichResult { terms : Array[EnrichTerm] gene_set_name : String organism : String } -pub fn EnrichTerm::new(term_id : String, term_name : String, pvalue : Double, adjusted_pvalue : Double, - enrichment_score : Double, nes : Double, gene_count : Int, genes : Array[String]) -> EnrichTerm { - EnrichTerm::{ term_id, term_name, pvalue, adjusted_pvalue, enrichment_score, nes, gene_count, genes } +///| +pub fn EnrichTerm::new( + term_id : String, + term_name : String, + pvalue : Double, + adjusted_pvalue : Double, + enrichment_score : Double, + nes : Double, + gene_count : Int, + genes : Array[String], +) -> EnrichTerm { + EnrichTerm::{ + term_id, + term_name, + pvalue, + adjusted_pvalue, + enrichment_score, + nes, + gene_count, + genes, + } } -pub fn EnrichResult::new(terms : Array[EnrichTerm], gene_set_name : String, organism : String) -> EnrichResult { +///| +pub fn EnrichResult::new( + terms : Array[EnrichTerm], + gene_set_name : String, + organism : String, +) -> EnrichResult { EnrichResult::{ terms, gene_set_name, organism } } +///| fn copy_enrich_term_array(arr : Array[EnrichTerm]) -> Array[EnrichTerm] { let len = arr.length() let result : Array[EnrichTerm] = Array::new() @@ -37,7 +61,12 @@ fn copy_enrich_term_array(arr : Array[EnrichTerm]) -> Array[EnrichTerm] { result } -fn set_enrich_term_array(arr : Array[EnrichTerm], index : Int, value : EnrichTerm) -> Array[EnrichTerm] { +///| +fn set_enrich_term_array( + arr : Array[EnrichTerm], + index : Int, + value : EnrichTerm, +) -> Array[EnrichTerm] { let len = arr.length() let result : Array[EnrichTerm] = Array::new() let mut i = 0 @@ -52,6 +81,7 @@ fn set_enrich_term_array(arr : Array[EnrichTerm], index : Int, value : EnrichTer result } +///| fn sort_terms_by_padj(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { let len = terms.length() let mut result : Array[EnrichTerm] = Array::new() @@ -60,7 +90,7 @@ fn sort_terms_by_padj(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { result.push(terms[i]) i = i + 1 } - + let mut j = 0 while j < len { let mut k = j + 1 @@ -76,10 +106,11 @@ fn sort_terms_by_padj(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { } j = j + 1 } - + result } +///| fn sort_terms_by_pvalue(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { let len = terms.length() let mut result : Array[EnrichTerm] = Array::new() @@ -88,7 +119,7 @@ fn sort_terms_by_pvalue(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { result.push(terms[i]) i = i + 1 } - + let mut j = 0 while j < len { let mut k = j + 1 @@ -104,10 +135,11 @@ fn sort_terms_by_pvalue(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { } j = j + 1 } - + result } +///| fn sort_terms_by_es(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { let len = terms.length() let mut result : Array[EnrichTerm] = Array::new() @@ -116,7 +148,7 @@ fn sort_terms_by_es(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { result.push(terms[i]) i = i + 1 } - + let mut j = 0 while j < len { let mut k = j + 1 @@ -132,10 +164,11 @@ fn sort_terms_by_es(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { } j = j + 1 } - + result } +///| fn sort_terms_by_nes(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { let len = terms.length() let mut result : Array[EnrichTerm] = Array::new() @@ -144,7 +177,7 @@ fn sort_terms_by_nes(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { result.push(terms[i]) i = i + 1 } - + let mut j = 0 while j < len { let mut k = j + 1 @@ -160,91 +193,160 @@ fn sort_terms_by_nes(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { } j = j + 1 } - + result } -pub fn bio_enrichplot_barplot(data : EnrichResult, top_n : Int, value_type : String, title : String) -> String { +///| +pub fn bio_enrichplot_barplot( + data : EnrichResult, + top_n : Int, + value_type : String, + title : String, +) -> String { let terms = copy_enrich_term_array(data.terms) - let sorted = if value_type == "padj" { sort_terms_by_padj(terms) } - else if value_type == "pvalue" { sort_terms_by_pvalue(terms) } - else if value_type == "es" { sort_terms_by_es(terms) } - else { sort_terms_by_nes(terms) } - + let sorted = if value_type == "padj" { + sort_terms_by_padj(terms) + } else if value_type == "pvalue" { + sort_terms_by_pvalue(terms) + } else if value_type == "es" { + sort_terms_by_es(terms) + } else { + sort_terms_by_nes(terms) + } + let n = if sorted.length() < top_n { sorted.length() } else { top_n } - + let mut result = "\n" + title + "\n" result = result + "=".repeat(80) + "\n" result = result + "Term\tValue\tBar\n" result = result + "-".repeat(80) + "\n" - + let mut i = 0 while i < n { let term = sorted[i] - let value = if value_type == "padj" { -@math.log10(term.adjusted_pvalue) } - else if value_type == "pvalue" { -@math.log10(term.pvalue) } - else if value_type == "es" { term.enrichment_score } - else { term.nes } - + let value = if value_type == "padj" { + -@math.log10(term.adjusted_pvalue) + } else if value_type == "pvalue" { + -@math.log10(term.pvalue) + } else if value_type == "es" { + term.enrichment_score + } else { + term.nes + } + let max_val = 10.0 - let bar_len = if value > max_val { 50 } else { (@math.floor(value / max_val * 50.0)).to_int() } + let bar_len = if value > max_val { + 50 + } else { + @math.floor(value / max_val * 50.0).to_int() + } let bar = "█".repeat(if bar_len > 0 { bar_len } else { 0 }) - - let term_display = if term.term_name.length() > 30 { substring(term.term_name, 0, 30) + "..." } else { term.term_name } - result = result + term_display + "\t" + value.to_string() + "\t" + bar + "\n" + + let term_display = if term.term_name.length() > 30 { + substring(term.term_name, 0, 30) + "..." + } else { + term.term_name + } + result = result + + term_display + + "\t" + + value.to_string() + + "\t" + + bar + + "\n" i = i + 1 } - + result = result + "\nLegend: bar length proportional to " + value_type + "\n" result } -pub fn bio_enrichplot_dotplot(data : EnrichResult, top_n : Int, title : String) -> String { +///| +pub fn bio_enrichplot_dotplot( + data : EnrichResult, + top_n : Int, + title : String, +) -> String { let terms = copy_enrich_term_array(data.terms) let sorted = sort_terms_by_padj(terms) - + let n = if sorted.length() < top_n { sorted.length() } else { top_n } let mut result = "\n" + title + "\n" result = result + "=".repeat(80) + "\n" result = result + "Term\tES\tpadj\tGeneCount\tBubble\n" result = result + "-".repeat(80) + "\n" - + let mut i = 0 while i < n { let term = sorted[i] - let bubble_size = if term.gene_count < 5 { 1 } else if term.gene_count < 10 { 2 } else if term.gene_count < 20 { 3 } else if term.gene_count < 50 { 4 } else { 5 } + let bubble_size = if term.gene_count < 5 { + 1 + } else if term.gene_count < 10 { + 2 + } else if term.gene_count < 20 { + 3 + } else if term.gene_count < 50 { + 4 + } else { + 5 + } let bubble = "*".repeat(bubble_size) - let term_display = if term.term_name.length() > 30 { substring(term.term_name, 0, 30) + "..." } else { term.term_name } - result = result + term_display + "\t" + term.enrichment_score.to_string() + "\t" + term.adjusted_pvalue.to_string() + "\t" + term.gene_count.to_string() + "\t" + bubble + "\n" + let term_display = if term.term_name.length() > 30 { + substring(term.term_name, 0, 30) + "..." + } else { + term.term_name + } + result = result + + term_display + + "\t" + + term.enrichment_score.to_string() + + "\t" + + term.adjusted_pvalue.to_string() + + "\t" + + term.gene_count.to_string() + + "\t" + + bubble + + "\n" i = i + 1 } - + result = result + "\nLegend: * = small, *** = medium, ***** = large\n" result } -pub fn bio_enrichplot_heatmap(data : EnrichResult, top_n : Int, gene_count : Int, title : String) -> String { +///| +pub fn bio_enrichplot_heatmap( + data : EnrichResult, + top_n : Int, + gene_count : Int, + title : String, +) -> String { let terms = copy_enrich_term_array(data.terms) let sorted = sort_terms_by_padj(terms) - + let n = if sorted.length() < top_n { sorted.length() } else { top_n } - + let gene_count_map : Map[String, Int] = Map([], capacity=0) let gene_counts = gene_count_map - + let mut i = 0 while i < n { let term = sorted[i] let mut j = 0 while j < term.genes.length() { let gene = term.genes[j] - let current = if gene_counts.contains(gene) { gene_counts.get(gene).unwrap() } else { 0 } + let current = if gene_counts.contains(gene) { + gene_counts.get(gene).unwrap() + } else { + 0 + } gene_counts.set(gene, current + 1) j = j + 1 } i = i + 1 } - + let gene_entries = gene_counts.iter().collect() let gene_len = gene_entries.length() let mut selected_genes : Array[String] = Array::new() @@ -264,15 +366,20 @@ pub fn bio_enrichplot_heatmap(data : EnrichResult, top_n : Int, gene_count : Int } k = k + 1 } - + let sg_len = selected_genes.length() if sg_len == 0 { - return "\n" + title + "\n" + "=".repeat(80) + "\n" + "No genes shared between at least 2 terms\n" + return "\n" + + title + + "\n" + + "=".repeat(80) + + "\n" + + "No genes shared between at least 2 terms\n" } - + let mut result = "\n" + title + "\n" result = result + "=".repeat(80) + "\n" - + result = result + "\t" let mut l = 0 while l < sg_len { @@ -280,12 +387,16 @@ pub fn bio_enrichplot_heatmap(data : EnrichResult, top_n : Int, gene_count : Int l = l + 1 } result = result + "\n" - + let mut p = 0 while p < n { let term = sorted[p] - let term_display = if term.term_name.length() > 20 { substring(term.term_name, 0, 20) + "..." } else { term.term_name } - + let term_display = if term.term_name.length() > 20 { + substring(term.term_name, 0, 20) + "..." + } else { + term.term_name + } + let mut row = term_display + "\t" let mut q = 0 while q < sg_len { @@ -298,11 +409,12 @@ pub fn bio_enrichplot_heatmap(data : EnrichResult, top_n : Int, gene_count : Int result = result + row + "\n" p = p + 1 } - + result = result + "\nLegend: █ = gene in term, ░ = gene not in term\n" result } +///| fn copy_tuple_array(arr : Array[(String, Int)]) -> Array[(String, Int)] { let len = arr.length() let result : Array[(String, Int)] = Array::new() @@ -314,7 +426,12 @@ fn copy_tuple_array(arr : Array[(String, Int)]) -> Array[(String, Int)] { result } -fn set_tuple_array(arr : Array[(String, Int)], index : Int, value : (String, Int)) -> Array[(String, Int)] { +///| +fn set_tuple_array( + arr : Array[(String, Int)], + index : Int, + value : (String, Int), +) -> Array[(String, Int)] { let len = arr.length() let result : Array[(String, Int)] = Array::new() let mut i = 0 @@ -329,6 +446,7 @@ fn set_tuple_array(arr : Array[(String, Int)], index : Int, value : (String, Int result } +///| fn contains_gene(genes : Array[String], gene : String) -> Bool { let mut i = 0 while i < genes.length() { @@ -340,27 +458,34 @@ fn contains_gene(genes : Array[String], gene : String) -> Bool { false } -pub fn bio_enrichplot_cnetplot(data : EnrichResult, top_n : Int, title : String) -> String { +///| +pub fn bio_enrichplot_cnetplot( + data : EnrichResult, + top_n : Int, + title : String, +) -> String { let terms = copy_enrich_term_array(data.terms) let sorted = sort_terms_by_padj(terms) - + let n = if sorted.length() < top_n { sorted.length() } else { top_n } - - let colors = ["red", "blue", "green", "purple", "orange", "cyan", "magenta", "yellow"] - + + let colors = [ + "red", "blue", "green", "purple", "orange", "cyan", "magenta", "yellow", + ] + let term_colors : Map[String, String] = Map([], capacity=0) let color_map = term_colors - + let mut term_nodes : Array[String] = Array::new() let mut gene_nodes : Array[String] = Array::new() let mut edges : Array[(String, String)] = Array::new() - + let mut i = 0 while i < n { let term = sorted[i] let term_node = term.term_name let color = colors[i % colors.length()] - + let tn_len = term_nodes.length() let new_tn : Array[String] = Array::new() let mut j = 0 @@ -370,9 +495,9 @@ pub fn bio_enrichplot_cnetplot(data : EnrichResult, top_n : Int, title : String) } new_tn.push(term_node) term_nodes = new_tn - + color_map.set(term_node, color) - + let mut k = 0 while k < term.genes.length() && k < 10 { let gene = term.genes[k] @@ -397,7 +522,7 @@ pub fn bio_enrichplot_cnetplot(data : EnrichResult, top_n : Int, title : String) new_gn.push(gene) gene_nodes = new_gn } - + let e_len = edges.length() let new_e : Array[(String, String)] = Array::new() let mut n = 0 @@ -407,31 +532,35 @@ pub fn bio_enrichplot_cnetplot(data : EnrichResult, top_n : Int, title : String) } new_e.push((term_node, gene)) edges = new_e - + k = k + 1 } i = i + 1 } - + let mut result = "\n" + title + "\n" result = result + "=".repeat(80) + "\n" result = result + "Nodes:\n" - + let mut p = 0 while p < term_nodes.length() { let term = term_nodes[p] - let col = if color_map.contains(term) { color_map.get(term).unwrap() } else { "gray" } + let col = if color_map.contains(term) { + color_map.get(term).unwrap() + } else { + "gray" + } result = result + " [" + col + "] " + term + "\n" p = p + 1 } - + result = result + "\nGenes:\n" let mut q = 0 while q < gene_nodes.length() { result = result + " ○ " + gene_nodes[q] + "\n" q = q + 1 } - + result = result + "\nEdges (Term → Gene):\n" let mut r = 0 while r < edges.length() { @@ -439,20 +568,24 @@ pub fn bio_enrichplot_cnetplot(data : EnrichResult, top_n : Int, title : String) result = result + " " + term + " → " + gene + "\n" r = r + 1 } - + result - } -pub fn bio_enrichplot_emapplot(data : EnrichResult, similarity_threshold : Double, title : String) -> String { +///| +pub fn bio_enrichplot_emapplot( + data : EnrichResult, + similarity_threshold : Double, + title : String, +) -> String { let terms = copy_enrich_term_array(data.terms) let sorted = sort_terms_by_padj(terms) - + let n = sorted.length() - + let mut term_sets : Array[Map[String, Bool]] = Array::new() let mut term_names : Array[String] = Array::new() - + let mut i = 0 while i < n { let term = sorted[i] @@ -465,7 +598,7 @@ pub fn bio_enrichplot_emapplot(data : EnrichResult, similarity_threshold : Doubl } new_ts.push(create_gene_hashmap(term.genes)) term_sets = new_ts - + let tn_len = term_names.length() let new_tn : Array[String] = Array::new() let mut k = 0 @@ -475,22 +608,26 @@ pub fn bio_enrichplot_emapplot(data : EnrichResult, similarity_threshold : Doubl } new_tn.push(term.term_name) term_names = new_tn - + i = i + 1 } - + let mut result = "\n" + title + "\n" result = result + "=".repeat(80) + "\n" result = result + "Enrichment Map (terms connected by shared genes):\n\n" - + let mut l = 0 while l < n { let mut m = l + 1 while m < n { let overlap = count_intersection(term_sets[l], term_sets[m]) let union = calculate_union_size(term_sets[l], term_sets[m]) - let jaccard = if union > 0 { overlap.to_double() / union.to_double() } else { 0.0 } - + let jaccard = if union > 0 { + overlap.to_double() / union.to_double() + } else { + 0.0 + } + if jaccard > similarity_threshold { result = result + term_names[l] + " ↔ " + term_names[m] result = result + " (Jaccard: " + jaccard.to_string() + ")\n" @@ -499,11 +636,13 @@ pub fn bio_enrichplot_emapplot(data : EnrichResult, similarity_threshold : Doubl } l = l + 1 } - - result = result + "\nLegend: edges represent Jaccard similarity > 0.1 between term gene sets\n" + + result = result + + "\nLegend: edges represent Jaccard similarity > 0.1 between term gene sets\n" result } +///| fn create_gene_hashmap(genes : Array[String]) -> Map[String, Bool] { let map : Map[String, Bool] = Map([], capacity=0) let result = map @@ -516,7 +655,11 @@ fn create_gene_hashmap(genes : Array[String]) -> Map[String, Bool] { result } -fn count_intersection(set1 : Map[String, Bool], set2 : Map[String, Bool]) -> Int { +///| +fn count_intersection( + set1 : Map[String, Bool], + set2 : Map[String, Bool], +) -> Int { let entries = set1.iter().collect() let len = entries.length() let mut count = 0 @@ -531,24 +674,29 @@ fn count_intersection(set1 : Map[String, Bool], set2 : Map[String, Bool]) -> Int count } -fn calculate_union_size(set1 : Map[String, Bool], set2 : Map[String, Bool]) -> Int { +///| +fn calculate_union_size( + set1 : Map[String, Bool], + set2 : Map[String, Bool], +) -> Int { let entries1 = set1.iter().collect() let entries2 = set2.iter().collect() - + let set1_len = entries1.length() let set2_len = entries2.length() let intersection = count_intersection(set1, set2) - + set1_len + set2_len - intersection } +///| pub fn bio_enrichplot_summary(data : EnrichResult) -> String { let total = data.terms.length() - + let mut sig_count = 0 let mut avg_es = 0.0 let mut avg_nes = 0.0 - + let mut i = 0 while i < total { let term = data.terms[i] @@ -559,18 +707,21 @@ pub fn bio_enrichplot_summary(data : EnrichResult) -> String { avg_nes = avg_nes + term.nes i = i + 1 } - + let mean_es = if total > 0 { avg_es / total.to_double() } else { 0.0 } let mean_nes = if total > 0 { avg_nes / total.to_double() } else { 0.0 } - + let mut result = "\nEnrichment Result Summary\n" result = result + "=".repeat(60) + "\n" result = result + "Gene Set: " + data.gene_set_name + "\n" result = result + "Organism: " + data.organism + "\n" result = result + "Total Terms: " + total.to_string() + "\n" - result = result + "Significant Terms (padj < 0.05): " + sig_count.to_string() + "\n" + result = result + + "Significant Terms (padj < 0.05): " + + sig_count.to_string() + + "\n" result = result + "Average Enrichment Score: " + mean_es.to_string() + "\n" result = result + "Average NES: " + mean_nes.to_string() + "\n" - + result -} \ No newline at end of file +} diff --git a/src/ensembldb.mbt b/src/ensembldb.mbt index 0ce4e86f..8674dfc5 100644 --- a/src/ensembldb.mbt +++ b/src/ensembldb.mbt @@ -13,7 +13,15 @@ pub struct EnsDbExon { } ///| -pub fn EnsDbExon::new(exon_id : String, gene_id : String, tx_id : String, exon_rank : Int, seq_start : Int, seq_end : Int, strand : Int) -> EnsDbExon { +pub fn EnsDbExon::new( + exon_id : String, + gene_id : String, + tx_id : String, + exon_rank : Int, + seq_start : Int, + seq_end : Int, + strand : Int, +) -> EnsDbExon { EnsDbExon::{ exon_id, gene_id, tx_id, exon_rank, seq_start, seq_end, strand } } @@ -30,8 +38,26 @@ pub struct EnsDbCDS { } ///| -pub fn EnsDbCDS::new(cds_id : String, gene_id : String, tx_id : String, cds_rank : Int, seq_start : Int, seq_end : Int, strand : Int, codon_start : Int) -> EnsDbCDS { - EnsDbCDS::{ cds_id, gene_id, tx_id, cds_rank, seq_start, seq_end, strand, codon_start } +pub fn EnsDbCDS::new( + cds_id : String, + gene_id : String, + tx_id : String, + cds_rank : Int, + seq_start : Int, + seq_end : Int, + strand : Int, + codon_start : Int, +) -> EnsDbCDS { + EnsDbCDS::{ + cds_id, + gene_id, + tx_id, + cds_rank, + seq_start, + seq_end, + strand, + codon_start, + } } ///| @@ -47,8 +73,26 @@ pub struct EnsDbTranscript { } ///| -pub fn EnsDbTranscript::new(tx_id : String, gene_id : String, tx_name : String, biotype : String, seq_start : Int, seq_end : Int, strand : Int, chromosome : String) -> EnsDbTranscript { - EnsDbTranscript::{ tx_id, gene_id, tx_name, biotype, seq_start, seq_end, strand, chromosome } +pub fn EnsDbTranscript::new( + tx_id : String, + gene_id : String, + tx_name : String, + biotype : String, + seq_start : Int, + seq_end : Int, + strand : Int, + chromosome : String, +) -> EnsDbTranscript { + EnsDbTranscript::{ + tx_id, + gene_id, + tx_name, + biotype, + seq_start, + seq_end, + strand, + chromosome, + } } ///| @@ -63,8 +107,24 @@ pub struct EnsDbGene { } ///| -pub fn EnsDbGene::new(gene_id : String, gene_name : String, biotype : String, seq_start : Int, seq_end : Int, strand : Int, chromosome : String) -> EnsDbGene { - EnsDbGene::{ gene_id, gene_name, biotype, seq_start, seq_end, strand, chromosome } +pub fn EnsDbGene::new( + gene_id : String, + gene_name : String, + biotype : String, + seq_start : Int, + seq_end : Int, + strand : Int, + chromosome : String, +) -> EnsDbGene { + EnsDbGene::{ + gene_id, + gene_name, + biotype, + seq_start, + seq_end, + strand, + chromosome, + } } ///| @@ -87,7 +147,7 @@ pub fn EnsDb::new(version : String, species : String) -> EnsDb { transcripts: Array::new(), exons: Array::new(), cds: Array::new(), - metadata: Map([], capacity=0) + metadata: Map([], capacity=0), } } @@ -156,7 +216,7 @@ pub fn edb_get_gene_by_id(db : EnsDb, gene_id : String) -> EnsDbGene? { ///| pub fn edb_get_gene_by_name(db : EnsDb, gene_name : String) -> Array[EnsDbGene] { let results : Array[EnsDbGene] = Array::new() - + let mut i = 0 while i < db.genes.length() { if db.genes[i].gene_name == gene_name { @@ -164,14 +224,17 @@ pub fn edb_get_gene_by_name(db : EnsDb, gene_name : String) -> Array[EnsDbGene] } i = i + 1 } - + results } ///| -pub fn edb_get_transcripts_by_gene(db : EnsDb, gene_id : String) -> Array[EnsDbTranscript] { +pub fn edb_get_transcripts_by_gene( + db : EnsDb, + gene_id : String, +) -> Array[EnsDbTranscript] { let results : Array[EnsDbTranscript] = Array::new() - + let mut i = 0 while i < db.transcripts.length() { if db.transcripts[i].gene_id == gene_id { @@ -179,14 +242,17 @@ pub fn edb_get_transcripts_by_gene(db : EnsDb, gene_id : String) -> Array[EnsDbT } i = i + 1 } - + results } ///| -pub fn edb_get_exons_by_transcript(db : EnsDb, tx_id : String) -> Array[EnsDbExon] { +pub fn edb_get_exons_by_transcript( + db : EnsDb, + tx_id : String, +) -> Array[EnsDbExon] { let results : Array[EnsDbExon] = Array::new() - + let mut i = 0 while i < db.exons.length() { if db.exons[i].tx_id == tx_id { @@ -194,14 +260,14 @@ pub fn edb_get_exons_by_transcript(db : EnsDb, tx_id : String) -> Array[EnsDbExo } i = i + 1 } - + results } ///| pub fn edb_get_cds_by_transcript(db : EnsDb, tx_id : String) -> Array[EnsDbCDS] { let results : Array[EnsDbCDS] = Array::new() - + let mut i = 0 while i < db.cds.length() { if db.cds[i].tx_id == tx_id { @@ -209,14 +275,14 @@ pub fn edb_get_cds_by_transcript(db : EnsDb, tx_id : String) -> Array[EnsDbCDS] } i = i + 1 } - + results } ///| pub fn edb_filter_by_chromosome(db : EnsDb, chromosome : String) -> EnsDb { let filtered = EnsDb::new(db.version, db.species) - + let mut i = 0 while i < db.genes.length() { if db.genes[i].chromosome == chromosome { @@ -224,7 +290,7 @@ pub fn edb_filter_by_chromosome(db : EnsDb, chromosome : String) -> EnsDb { } i = i + 1 } - + let mut j = 0 while j < db.transcripts.length() { if db.transcripts[j].chromosome == chromosome { @@ -232,14 +298,14 @@ pub fn edb_filter_by_chromosome(db : EnsDb, chromosome : String) -> EnsDb { } j = j + 1 } - + filtered } ///| pub fn edb_filter_by_biotype(db : EnsDb, biotype : String) -> EnsDb { let filtered = EnsDb::new(db.version, db.species) - + let mut i = 0 while i < db.genes.length() { if db.genes[i].biotype == biotype { @@ -247,7 +313,7 @@ pub fn edb_filter_by_biotype(db : EnsDb, biotype : String) -> EnsDb { } i = i + 1 } - + let mut j = 0 while j < db.transcripts.length() { if db.transcripts[j].biotype == biotype { @@ -255,7 +321,7 @@ pub fn edb_filter_by_biotype(db : EnsDb, biotype : String) -> EnsDb { } j = j + 1 } - + filtered } @@ -286,44 +352,82 @@ pub fn create_example_ensdb() -> EnsDb { let db = EnsDb::new("109", "Homo sapiens") let _ = db.metadata.set("source", "Ensembl") let _ = db.metadata.set("build", "GRCh38") - - let gene1 = EnsDbGene::new("ENSG000001", "ACTB", "protein_coding", 5566659, 5572915, 1, "17") - let gene2 = EnsDbGene::new("ENSG000002", "GAPDH", "protein_coding", 653207, 674323, 1, "12") - let gene3 = EnsDbGene::new("ENSG000003", "TP53", "protein_coding", 7661779, 7687550, -1, "17") + + let gene1 = EnsDbGene::new( + "ENSG000001", "ACTB", "protein_coding", 5566659, 5572915, 1, "17", + ) + let gene2 = EnsDbGene::new( + "ENSG000002", "GAPDH", "protein_coding", 653207, 674323, 1, "12", + ) + let gene3 = EnsDbGene::new( + "ENSG000003", "TP53", "protein_coding", 7661779, 7687550, -1, "17", + ) db.genes.push(gene1) db.genes.push(gene2) db.genes.push(gene3) - - let tx1 = EnsDbTranscript::new("ENST000001", "ENSG000001", "ACTB-201", "protein_coding", 5566659, 5572915, 1, "17") - let tx2 = EnsDbTranscript::new("ENST000002", "ENSG000001", "ACTB-202", "protein_coding", 5566659, 5572915, 1, "17") - let tx3 = EnsDbTranscript::new("ENST000003", "ENSG000002", "GAPDH-201", "protein_coding", 653207, 674323, 1, "12") - let tx4 = EnsDbTranscript::new("ENST000004", "ENSG000003", "TP53-201", "protein_coding", 7661779, 7687550, -1, "17") + + let tx1 = EnsDbTranscript::new( + "ENST000001", "ENSG000001", "ACTB-201", "protein_coding", 5566659, 5572915, 1, + "17", + ) + let tx2 = EnsDbTranscript::new( + "ENST000002", "ENSG000001", "ACTB-202", "protein_coding", 5566659, 5572915, 1, + "17", + ) + let tx3 = EnsDbTranscript::new( + "ENST000003", "ENSG000002", "GAPDH-201", "protein_coding", 653207, 674323, 1, + "12", + ) + let tx4 = EnsDbTranscript::new( + "ENST000004", "ENSG000003", "TP53-201", "protein_coding", 7661779, 7687550, -1, + "17", + ) db.transcripts.push(tx1) db.transcripts.push(tx2) db.transcripts.push(tx3) db.transcripts.push(tx4) - - let exon1 = EnsDbExon::new("ENSE000001", "ENSG000001", "ENST000001", 1, 5566659, 5566743, 1) - let exon2 = EnsDbExon::new("ENSE000002", "ENSG000001", "ENST000001", 2, 5567108, 5567231, 1) - let exon3 = EnsDbExon::new("ENSE000003", "ENSG000001", "ENST000001", 3, 5567332, 5567420, 1) - let exon4 = EnsDbExon::new("ENSE000004", "ENSG000002", "ENST000003", 1, 653207, 653322, 1) - let exon5 = EnsDbExon::new("ENSE000005", "ENSG000002", "ENST000003", 2, 654417, 654536, 1) + + let exon1 = EnsDbExon::new( + "ENSE000001", "ENSG000001", "ENST000001", 1, 5566659, 5566743, 1, + ) + let exon2 = EnsDbExon::new( + "ENSE000002", "ENSG000001", "ENST000001", 2, 5567108, 5567231, 1, + ) + let exon3 = EnsDbExon::new( + "ENSE000003", "ENSG000001", "ENST000001", 3, 5567332, 5567420, 1, + ) + let exon4 = EnsDbExon::new( + "ENSE000004", "ENSG000002", "ENST000003", 1, 653207, 653322, 1, + ) + let exon5 = EnsDbExon::new( + "ENSE000005", "ENSG000002", "ENST000003", 2, 654417, 654536, 1, + ) db.exons.push(exon1) db.exons.push(exon2) db.exons.push(exon3) db.exons.push(exon4) db.exons.push(exon5) - - let cds1 = EnsDbCDS::new("ENSC000001", "ENSG000001", "ENST000001", 1, 5566680, 5566743, 1, 1) - let cds2 = EnsDbCDS::new("ENSC000002", "ENSG000001", "ENST000001", 2, 5567108, 5567231, 1, 1) - let cds3 = EnsDbCDS::new("ENSC000003", "ENSG000001", "ENST000001", 3, 5567332, 5567420, 1, 1) - let cds4 = EnsDbCDS::new("ENSC000004", "ENSG000002", "ENST000003", 1, 653247, 653322, 1, 1) - let cds5 = EnsDbCDS::new("ENSC000005", "ENSG000002", "ENST000003", 2, 654417, 654536, 1, 1) + + let cds1 = EnsDbCDS::new( + "ENSC000001", "ENSG000001", "ENST000001", 1, 5566680, 5566743, 1, 1, + ) + let cds2 = EnsDbCDS::new( + "ENSC000002", "ENSG000001", "ENST000001", 2, 5567108, 5567231, 1, 1, + ) + let cds3 = EnsDbCDS::new( + "ENSC000003", "ENSG000001", "ENST000001", 3, 5567332, 5567420, 1, 1, + ) + let cds4 = EnsDbCDS::new( + "ENSC000004", "ENSG000002", "ENST000003", 1, 653247, 653322, 1, 1, + ) + let cds5 = EnsDbCDS::new( + "ENSC000005", "ENSG000002", "ENST000003", 2, 654417, 654536, 1, 1, + ) db.cds.push(cds1) db.cds.push(cds2) db.cds.push(cds3) db.cds.push(cds4) db.cds.push(cds5) - + db -} \ No newline at end of file +} diff --git a/src/estimate_score.mbt b/src/estimate_score.mbt index a4d2b0d4..d03ef7b1 100644 --- a/src/estimate_score.mbt +++ b/src/estimate_score.mbt @@ -46,8 +46,8 @@ pub struct EstSampleScore { sample_id : String stromal_score : Double immune_score : Double - estimate_score : Double // stromal + immune - tumor_purity : Double // inferred purity in [0, 1] (NaN if undefined) + estimate_score : Double // stromal + immune + tumor_purity : Double // inferred purity in [0, 1] (NaN if undefined) } ///| @@ -187,10 +187,14 @@ fn est_sort_indices_desc(values : Array[Double]) -> Array[Int] { /// Returns the proportion of values in `sample` that are <= x. fn est_ecdf(x : Double, sample : Array[Double]) -> Double { let n = sample.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut count = 0 for v in sample { - if v <= x { count = count + 1 } + if v <= x { + count = count + 1 + } } count.to_double() / n.to_double() } @@ -199,10 +203,14 @@ fn est_ecdf(x : Double, sample : Array[Double]) -> Double { /// Check if all values in an array are identical (degenerate case). fn est_all_equal(arr : Array[Double]) -> Bool { let n = arr.length() - if n <= 1 { return true } + if n <= 1 { + return true + } let first = arr[0] for i in 1.. 1.0e-15 { return false } + if (arr[i] - first).abs() > 1.0e-15 { + return false + } } true } @@ -227,7 +235,9 @@ fn est_ssgsea_score( gene_set : Array[String], ) -> Double { let n = gene_names.length() - if n == 0 || gene_set.length() == 0 { return 0.0 } + if n == 0 || gene_set.length() == 0 { + return 0.0 + } // Build membership set let gene_member : Map[String, Unit] = Map([], capacity=gene_set.length()) let mut set_size = 0 @@ -246,7 +256,9 @@ fn est_ssgsea_score( sum_in_set = sum_in_set + expression[i].abs() } } - if sum_in_set < 1.0e-15 { return 0.0 } + if sum_in_set < 1.0e-15 { + return 0.0 + } // Walk down the ranked list let n_not_set = (n - set_size).to_double() let incr_in = 1.0 / sum_in_set @@ -264,14 +276,22 @@ fn est_ssgsea_score( } else { running = running - decr_out } - if running > max_val { max_val = running } - if running < min_val { min_val = running } - if running > 0.0 { pos_acc = pos_acc + running } + if running > max_val { + max_val = running + } + if running < min_val { + min_val = running + } + if running > 0.0 { + pos_acc = pos_acc + running + } } // Standard ssGSEA normalization: integrate positive area and divide by // total range, then subtract 0.5 to center let range = max_val - min_val - if range < 1.0e-15 { return 0.0 } + if range < 1.0e-15 { + return 0.0 + } // The classic ssGSEA score uses sum of positive running sums (weighted) // normalized by (n_set * n_not_set) is NOT appropriate here; we follow // the integration-style score: pos_acc / n (average positive excursion) @@ -346,8 +366,16 @@ pub fn est_run( let scores : Array[EstSampleScore] = [] for s in 0.. Array[String] { [ - "ACTA2", "ADAM12", "ADAMDEC1", "ADAMTS2", "AEBP1", "ANGPTL2", "ANGPTL4", - "APBB1IP", "APLP1", "ARCHN1", "ASPN", "BGN", "BMP1", "C1QA", "C1QB", - "C1QC", "C3", "CADM1", "CALD1", "CCDC80", "CD248", "CD55", "CDH11", - "CDH19", "COL10A1", "COL11A1", "COL12A1", "COL14A1", "COL1A1", "COL1A2", - "COL3A1", "COL4A1", "COL4A2", "COL5A1", "COL5A2", "COL6A3", "COPZ2", - "CRLF1", "CXCL1", "CXCL12", "DCN", "DPT", "ECM2", "EDIL3", "EGR2", - "FAP", "FBLN1", "FBN1", "FBN2", "FGF7", + "ACTA2", "ADAM12", "ADAMDEC1", "ADAMTS2", "AEBP1", "ANGPTL2", "ANGPTL4", "APBB1IP", + "APLP1", "ARCHN1", "ASPN", "BGN", "BMP1", "C1QA", "C1QB", "C1QC", "C3", "CADM1", + "CALD1", "CCDC80", "CD248", "CD55", "CDH11", "CDH19", "COL10A1", "COL11A1", "COL12A1", + "COL14A1", "COL1A1", "COL1A2", "COL3A1", "COL4A1", "COL4A2", "COL5A1", "COL5A2", + "COL6A3", "COPZ2", "CRLF1", "CXCL1", "CXCL12", "DCN", "DPT", "ECM2", "EDIL3", + "EGR2", "FAP", "FBLN1", "FBN1", "FBN2", "FGF7", ] } @@ -389,10 +416,10 @@ pub fn est_stromal_genes() -> Array[String] { /// (2013) Supplementary Table S2 (subset). pub fn est_immune_genes() -> Array[String] { [ - "AIF1", "APOBEC3G", "ARHGAP25", "BCL6", "BLK", "BST1", "BST2", "C1orf162", - "C2orf88", "C3orf14", "CCL3", "CD164L1", "CD2", "CD247", "CD3D", "CD3E", - "CD3G", "CD52", "CD53", "CD69", "CD7", "CEBPD", "CLEC2B", "CMKLR1", - "CPEB2", "CRIP1", "CXCL9", "CXCR6", "CYBB", "DOCK2", + "AIF1", "APOBEC3G", "ARHGAP25", "BCL6", "BLK", "BST1", "BST2", "C1orf162", "C2orf88", + "C3orf14", "CCL3", "CD164L1", "CD2", "CD247", "CD3D", "CD3E", "CD3G", "CD52", + "CD53", "CD69", "CD7", "CEBPD", "CLEC2B", "CMKLR1", "CPEB2", "CRIP1", "CXCL9", + "CXCR6", "CYBB", "DOCK2", ] } @@ -437,21 +464,14 @@ pub fn est_sample_data() -> EstExpression { gene_names.push("BACKGRD" + bi.to_string()) } let n_genes = gene_names.length() - let sample_names = [ - "HighStromal", "HighImmune", "HighBoth", "LowBoth", - ] + let sample_names = ["HighStromal", "HighImmune", "HighBoth", "LowBoth"] // Define infiltration profiles: (stromal_add, immune_add) // HighStromal: stromal genes up-regulated, immune slightly up // HighImmune: immune genes up-regulated, stromal slightly up // HighBoth: both stromal and immune up-regulated // LowBoth: both stromal and immune DOWN-regulated (below background), // representing a tumor-dominant sample with little infiltration - let profiles = [ - (8.0, 1.0), - (1.0, 8.0), - (8.0, 8.0), - (-2.0, -2.0), - ] + let profiles = [(8.0, 1.0), (1.0, 8.0), (8.0, 8.0), (-2.0, -2.0)] // Build matrix (rows=genes, cols=samples) let matrix : Array[Array[Double]] = [] for gi in 0.. EstExpression { val = val + i_level } // Clamp to non-negative (expression cannot be negative) - if val < 0.1 { val = 0.1 } + if val < 0.1 { + val = 0.1 + } // Add small per-gene jitter to break ties val = val + 0.01 * (gi % 7).to_double() row.push(val) @@ -482,9 +504,14 @@ pub fn est_sample_data() -> EstExpression { ///| /// Get the score for a specific sample. -pub fn EstResult::get_score(self : EstResult, sample_id : String) -> EstSampleScore { +pub fn EstResult::get_score( + self : EstResult, + sample_id : String, +) -> EstSampleScore { for s in self.scores { - if s.sample_id == sample_id { return s } + if s.sample_id == sample_id { + return s + } } // Return a default empty score if not found { @@ -500,7 +527,8 @@ pub fn EstResult::get_score(self : EstResult, sample_id : String) -> EstSampleSc /// Format ESTIMATE results as a string table. pub fn EstResult::to_string(self : EstResult) -> String { let mut result = "ESTIMATE Results:\n" - result = result + "Sample\tStromalScore\tImmuneScore\tESTIMATEScore\tTumorPurity\n" + result = result + + "Sample\tStromalScore\tImmuneScore\tESTIMATEScore\tTumorPurity\n" for s in self.scores { let purity_str = if s.tumor_purity.is_nan() { "NA" diff --git a/src/exonerate.mbt b/src/exonerate.mbt index 6e6c0db5..4cdd2e3a 100644 --- a/src/exonerate.mbt +++ b/src/exonerate.mbt @@ -165,7 +165,7 @@ pub fn ExonerateRecord::score(self : ExonerateRecord) -> Double { ///| /// Get the list of alignment blocks. pub fn ExonerateRecord::alignment_blocks( - self : ExonerateRecord + self : ExonerateRecord, ) -> Array[AlignmentBlock] { self.alignment_blocks } @@ -394,8 +394,7 @@ fn exo_parse_vulgar_blocks(tokens : Array[String]) -> Array[AlignmentBlock] { if i + 2 < n { let qlen = exo_parse_int(tokens[i + 1]) let tlen = exo_parse_int(tokens[i + 2]) - let (score, advance) = if i + 3 < n && - exo_is_numeric_token(tokens[i + 3]) { + let (score, advance) = if i + 3 < n && exo_is_numeric_token(tokens[i + 3]) { (exo_parse_double(tokens[i + 3]), 4) } else { (0.0, 3) @@ -438,16 +437,8 @@ fn exo_parse_vulgar_line(line : String) -> ExonerateRecord? { let blocks = exo_parse_vulgar_blocks(block_tokens) Some( ExonerateRecord::new( - query_name, - query_start, - query_end, - query_strand, - target_name, - target_start, - target_end, - target_strand, - score, - blocks, + query_name, query_start, query_end, query_strand, target_name, target_start, + target_end, target_strand, score, blocks, ), ) } @@ -482,10 +473,7 @@ pub fn parse_exonerate_vulgar(content : String) -> Array[ExonerateRecord] { /// operation code and the single length value. For most operations both /// sequences consume the length; introns (I) consume neither; gaps (U/V/D) /// consume only one side. -fn exo_cigar_lengths( - code : String, - length : Int, -) -> (Int, Int, Double) { +fn exo_cigar_lengths(code : String, length : Int) -> (Int, Int, Double) { match code { "I" => (0, 0, length.to_double()) "D" => (length, 0, 0.0) @@ -540,16 +528,8 @@ fn exo_parse_cigar_line(line : String) -> ExonerateRecord? { let blocks = exo_parse_cigar_blocks(block_tokens) Some( ExonerateRecord::new( - query_name, - query_start, - query_end, - query_strand, - target_name, - target_start, - target_end, - target_strand, - score, - blocks, + query_name, query_start, query_end, query_strand, target_name, target_start, + target_end, target_strand, score, blocks, ), ) } diff --git a/src/expasy.mbt b/src/expasy.mbt index 17f0d393..d51f4bb6 100644 --- a/src/expasy.mbt +++ b/src/expasy.mbt @@ -13,19 +13,23 @@ pub struct ExPASyRecord { ///| pub fn ExPASyRecord::new(id : String, database : String) -> ExPASyRecord { - ExPASyRecord::{ - id, - database, - status: "ok", - data: Map([], capacity=10) - } + ExPASyRecord::{ id, database, status: "ok", data: Map([], capacity=10) } } ///| -pub fn ExPASyRecord::add_field(self : ExPASyRecord, key : String, value : String) -> ExPASyRecord { +pub fn ExPASyRecord::add_field( + self : ExPASyRecord, + key : String, + value : String, +) -> ExPASyRecord { let data = self.data.copy() data.set(key, value) - ExPASyRecord::{ id: self.id, database: self.database, status: self.status, data: data } + ExPASyRecord::{ + id: self.id, + database: self.database, + status: self.status, + data, + } } ///| @@ -59,28 +63,34 @@ pub fn ExPASyEntry::new(accession : String, name : String) -> ExPASyEntry { sequence: "", length: 0, ec_numbers: Array::new(), - references: Array::new() + references: Array::new(), } } ///| -pub fn ExPASyEntry::add_keyword(self : ExPASyEntry, keyword : String) -> ExPASyEntry { +pub fn ExPASyEntry::add_keyword( + self : ExPASyEntry, + keyword : String, +) -> ExPASyEntry { let keywords = self.keywords.copy() keywords.push(keyword) ExPASyEntry::{ accession: self.accession, name: self.name, description: self.description, - keywords: keywords, + keywords, sequence: self.sequence, length: self.length, ec_numbers: self.ec_numbers, - references: self.references + references: self.references, } } ///| -pub fn ExPASyEntry::add_ec_number(self : ExPASyEntry, ec : String) -> ExPASyEntry { +pub fn ExPASyEntry::add_ec_number( + self : ExPASyEntry, + ec : String, +) -> ExPASyEntry { let ec_numbers = self.ec_numbers.copy() ec_numbers.push(ec) ExPASyEntry::{ @@ -90,8 +100,8 @@ pub fn ExPASyEntry::add_ec_number(self : ExPASyEntry, ec : String) -> ExPASyEntr keywords: self.keywords, sequence: self.sequence, length: self.length, - ec_numbers: ec_numbers, - references: self.references + ec_numbers, + references: self.references, } } @@ -117,7 +127,7 @@ pub fn EnzymeEntry::new(ec_number : String, name : String) -> EnzymeEntry { cofactors: Array::new(), substrates: Array::new(), products: Array::new(), - comments: "" + comments: "", } } @@ -137,12 +147,12 @@ pub fn enzyme_parse_ec(ec_string : String) -> (String, String, String, String) { i = i + 1 } parts.push(current) - + let class = if parts.length() > 0 { parts[0] } else { "" } let subclass = if parts.length() > 1 { parts[1] } else { "" } let subsubclass = if parts.length() > 2 { parts[2] } else { "" } let serial = if parts.length() > 3 { parts[3] } else { "" } - + (class, subclass, subsubclass, serial) } @@ -166,13 +176,16 @@ pub fn expasy_get_prosite_ids(sequence : String) -> Array[String] { ///| pub fn expasy_get_swissprot_entry(accession : String) -> ExPASyEntry? { - let entries = Map([ - ("P04637", ("TP53", "Tumor protein p53")), - ("P38398", ("BRCA1", "BRCA1 DNA repair associated")), - ("P51587", ("BRCA2", "BRCA2 DNA repair associated")), - ("P00533", ("EGFR", "Epidermal growth factor receptor")) - ], capacity=4) - + let entries = Map( + [ + ("P04637", ("TP53", "Tumor protein p53")), + ("P38398", ("BRCA1", "BRCA1 DNA repair associated")), + ("P51587", ("BRCA2", "BRCA2 DNA repair associated")), + ("P00533", ("EGFR", "Epidermal growth factor receptor")), + ], + capacity=4, + ) + if entries.contains(accession) { let entry = entries.get(accession).unwrap() let ex_entry = ExPASyEntry::new(accession, entry.0) @@ -184,13 +197,28 @@ pub fn expasy_get_swissprot_entry(accession : String) -> ExPASyEntry? { ///| pub fn expasy_get_enzyme(ec_number : String) -> EnzymeEntry? { - let enzymes = Map([ - ("1.1.1.1", ("Alcohol dehydrogenase", ["Alcohol:NAD+ oxidoreductase"])), - ("1.2.1.12", ("Glyceraldehyde-3-phosphate dehydrogenase", ["D-glyceraldehyde 3-phosphate:NAD+ oxidoreductase (phosphorylating)"])), - ("2.7.1.1", ("Hexokinase", ["ATP:D-hexose 6-phosphotransferase"])), - ("3.1.3.11", ("Fructose-bisphosphatase", ["D-fructose 1,6-bisphosphate 1-phosphatase"])) - ], capacity=4) - + let enzymes = Map( + [ + ("1.1.1.1", ("Alcohol dehydrogenase", ["Alcohol:NAD+ oxidoreductase"])), + ( + "1.2.1.12", + ( + "Glyceraldehyde-3-phosphate dehydrogenase", + ["D-glyceraldehyde 3-phosphate:NAD+ oxidoreductase (phosphorylating)"], + ), + ), + ("2.7.1.1", ("Hexokinase", ["ATP:D-hexose 6-phosphotransferase"])), + ( + "3.1.3.11", + ( + "Fructose-bisphosphatase", + ["D-fructose 1,6-bisphosphate 1-phosphatase"], + ), + ), + ], + capacity=4, + ) + if enzymes.contains(ec_number) { let enzyme = enzymes.get(ec_number).unwrap() let mut entry = EnzymeEntry::new(ec_number, enzyme.0) @@ -206,7 +234,7 @@ pub fn expasy_get_enzyme(ec_number : String) -> EnzymeEntry? { cofactors: entry.cofactors, substrates: entry.substrates, products: entry.products, - comments: entry.comments + comments: entry.comments, } i = i + 1 } @@ -219,16 +247,34 @@ pub fn expasy_get_enzyme(ec_number : String) -> EnzymeEntry? { ///| pub fn expasy_analyze_protein(sequence : String) -> Map[String, Double] { let result = Map([], capacity=5) - + let mut mw = 0.0 - let aa_weights = Map([ - ("A", 89.09), ("R", 174.20), ("N", 132.12), ("D", 133.10), - ("C", 121.15), ("E", 147.13), ("Q", 146.15), ("G", 75.07), - ("H", 155.16), ("I", 131.17), ("L", 131.17), ("K", 146.19), - ("M", 149.21), ("F", 165.19), ("P", 115.13), ("S", 105.09), - ("T", 119.12), ("W", 204.23), ("Y", 181.19), ("V", 117.15) - ], capacity=20) - + let aa_weights = Map( + [ + ("A", 89.09), + ("R", 174.20), + ("N", 132.12), + ("D", 133.10), + ("C", 121.15), + ("E", 147.13), + ("Q", 146.15), + ("G", 75.07), + ("H", 155.16), + ("I", 131.17), + ("L", 131.17), + ("K", 146.19), + ("M", 149.21), + ("F", 165.19), + ("P", 115.13), + ("S", 105.09), + ("T", 119.12), + ("W", 204.23), + ("Y", 181.19), + ("V", 117.15), + ], + capacity=20, + ) + let mut i = 0 while i < sequence.length() { let aa = char_at(sequence, i) @@ -238,19 +284,37 @@ pub fn expasy_analyze_protein(sequence : String) -> Map[String, Double] { } i = i + 1 } - + mw = mw - (sequence.length() - 1).to_double() * 18.015 result.set("molecular_weight", mw) - + let mut gravy = 0.0 - let hydropathy = Map([ - ("A", 1.8), ("R", -4.5), ("N", -3.5), ("D", -3.5), - ("C", 2.5), ("E", -3.5), ("Q", -3.5), ("G", -0.4), - ("H", -3.2), ("I", 4.5), ("L", 3.8), ("K", -3.9), - ("M", 1.9), ("F", 2.8), ("P", -1.6), ("S", -0.8), - ("T", -0.7), ("W", -0.9), ("Y", -1.3), ("V", 4.2) - ], capacity=20) - + let hydropathy = Map( + [ + ("A", 1.8), + ("R", -4.5), + ("N", -3.5), + ("D", -3.5), + ("C", 2.5), + ("E", -3.5), + ("Q", -3.5), + ("G", -0.4), + ("H", -3.2), + ("I", 4.5), + ("L", 3.8), + ("K", -3.9), + ("M", 1.9), + ("F", 2.8), + ("P", -1.6), + ("S", -0.8), + ("T", -0.7), + ("W", -0.9), + ("Y", -1.3), + ("V", 4.2), + ], + capacity=20, + ) + i = 0 while i < sequence.length() { let aa = char_at(sequence, i) @@ -264,7 +328,7 @@ pub fn expasy_analyze_protein(sequence : String) -> Map[String, Double] { gravy = gravy / sequence.length().to_double() } result.set("gravy", gravy) - + let mut instability = 0.0 i = 0 while i < sequence.length() - 1 { @@ -275,30 +339,30 @@ pub fn expasy_analyze_protein(sequence : String) -> Map[String, Double] { instability = instability / (sequence.length() - 1).to_double() } result.set("instability_index", instability) - + let charge_at_7 = expasy_calculate_charge(sequence, 7.0) result.set("charge_at_pH7", charge_at_7) - + let pi = expasy_calculate_isoelectric_point(sequence) result.set("isoelectric_point", pi) - + result } ///| fn expasy_calculate_charge(sequence : String, ph : Double) -> Double { let mut charge = 0.0 - + let mut n_terminal = 0.0 if sequence.length() > 0 { n_terminal = 1.0 / (1.0 + @math.exp(ph - 7.4)) } - + let mut c_terminal = 0.0 if sequence.length() > 0 { c_terminal = -1.0 / (1.0 + @math.exp(2.2 - ph)) } - + let mut i = 0 while i < sequence.length() { let aa = char_at(sequence, i) @@ -316,7 +380,7 @@ fn expasy_calculate_charge(sequence : String, ph : Double) -> Double { } i = i + 1 } - + charge + n_terminal + c_terminal } @@ -325,12 +389,12 @@ fn expasy_calculate_isoelectric_point(sequence : String) -> Double { let mut min_pi = 2.0 let mut max_pi = 12.0 let mut mid_pi = 7.0 - + let mut i = 0 while i < 50 { mid_pi = (min_pi + max_pi) / 2.0 let charge = expasy_calculate_charge(sequence, mid_pi) - + if charge > 0.001 { min_pi = mid_pi } else if charge < -0.001 { @@ -340,7 +404,7 @@ fn expasy_calculate_isoelectric_point(sequence : String) -> Double { } i = i + 1 } - + mid_pi } @@ -363,6 +427,6 @@ pub fn create_example_enzyme_entry() -> EnzymeEntry { cofactors: enzyme.cofactors, substrates: enzyme.substrates, products: enzyme.products, - comments: enzyme.comments + comments: enzyme.comments, } -} \ No newline at end of file +} diff --git a/src/factoextra.mbt b/src/factoextra.mbt index 0deda9ff..4b91e4a2 100644 --- a/src/factoextra.mbt +++ b/src/factoextra.mbt @@ -84,15 +84,14 @@ pub fn facto_pca( let mut ii = 0 while ii < p { let mut jj = 0 - while jj < p { cov[ii][jj] = cov[ii][jj] * scale_factor; jj = jj + 1 } + while jj < p { + cov[ii][jj] = cov[ii][jj] * scale_factor + jj = jj + 1 + } ii = ii + 1 } // Compute eigenvalues via power iteration - let n_components = if ncp > 0 { - if ncp > p { p } else { ncp } - } else { - p - } + let n_components = if ncp > 0 { if ncp > p { p } else { ncp } } else { p } let (eigenvalues, eigenvectors) = facto_power_iteration(cov, n_components) // Sort by descending eigenvalue let sorted = facto_sort_eigen(eigenvalues, eigenvectors) @@ -100,23 +99,34 @@ pub fn facto_pca( let eig_vecs = sorted.1 // Compute explained variance let mut tv = 0.0 - for ev in eig_vals { tv = tv + ev } + for ev in eig_vals { + tv = tv + ev + } // Compute individual scores: centered %*% eigenvectors - let ind_coord : Array[Array[Double]] = Array::make(n, Array::make(n_components, 0.0)) + let ind_coord : Array[Array[Double]] = Array::make( + n, + Array::make(n_components, 0.0), + ) let mut si = 0 while si < n { let mut sj = 0 while sj < n_components { let mut s = 0.0 let mut sk = 0 - while sk < p { s = s + centered[si][sk] * eig_vecs[sk][sj]; sk = sk + 1 } + while sk < p { + s = s + centered[si][sk] * eig_vecs[sk][sj] + sk = sk + 1 + } ind_coord[si][sj] = s sj = sj + 1 } si = si + 1 } // Variable coordinates: eigenvectors * sqrt(eigenvalues) - let var_coord : Array[Array[Double]] = Array::make(p, Array::make(n_components, 0.0)) + let var_coord : Array[Array[Double]] = Array::make( + p, + Array::make(n_components, 0.0), + ) let mut vi = 0 while vi < p { let mut vj = 0 @@ -154,21 +164,32 @@ pub fn facto_pca( let var_contrib = facto_contrib_var(var_coord, eig_vals) PcaResult::{ eigenvalues: eigenvalues_list, - ind: PcaIndResult::{ coord: ind_coord, cos2: ind_cos2, contrib: ind_contrib }, - var: PcaVarResult::{ coord: var_coord, cos2: var_cos2, contrib: var_contrib }, + ind: PcaIndResult::{ + coord: ind_coord, + cos2: ind_cos2, + contrib: ind_contrib, + }, + var: PcaVarResult::{ + coord: var_coord, + cos2: var_cos2, + contrib: var_contrib, + }, n_ind: n, n_var: p, n_dims: n_components, } } +///| fn facto_center_scale( data : Array[Array[Double]], center : Bool, scale : Bool, ) -> Array[Array[Double]] { let n = data.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let p = data[0].length() let means : Array[Double] = Array::make(p, 0.0) let sds : Array[Double] = Array::make(p, 1.0) @@ -176,7 +197,10 @@ fn facto_center_scale( while j < p { let mut s = 0.0 let mut i = 0 - while i < n { s = s + data[i][j]; i = i + 1 } + while i < n { + s = s + data[i][j] + i = i + 1 + } means[j] = if center { s / n.to_double() } else { 0.0 } if scale { let mut s2 = 0.0 @@ -204,16 +228,22 @@ fn facto_center_scale( result } +///| fn facto_power_iteration( a : Array[Array[Double]], n_components : Int, ) -> (Array[Double], Array[Array[Double]]) { let n = a.length() - if n == 0 { return ([], []) } + if n == 0 { + return ([], []) + } let max_iter = 200 let tol = 1.0e-10 let eigenvalues : Array[Double] = Array::make(n_components, 0.0) - let eigenvectors : Array[Array[Double]] = Array::make(n, Array::make(n_components, 0.0)) + let eigenvectors : Array[Array[Double]] = Array::make( + n, + Array::make(n_components, 0.0), + ) let mut i = 0 while i < n_components { // Initialize vector @@ -229,7 +259,10 @@ fn facto_power_iteration( while j < n { let mut s = 0.0 let mut k = 0 - while k < n { s = s + a[j][k] * v[k]; k = k + 1 } + while k < n { + s = s + a[j][k] * v[k] + k = k + 1 + } v_new[j] = s j = j + 1 } @@ -238,14 +271,19 @@ fn facto_power_iteration( let mut mj = 0 while mj < n { let av = if v_new[mj] < 0.0 { -v_new[mj] } else { v_new[mj] } - if av > max_val { max_val = av } + if av > max_val { + max_val = av + } mj = mj + 1 } lambda = max_val // Normalize if max_val > 0.0 { let mut nj = 0 - while nj < n { v[nj] = v_new[nj] / max_val; nj = nj + 1 } + while nj < n { + v[nj] = v_new[nj] / max_val + nj = nj + 1 + } } // Check convergence if iter > 0 && max_val > 0.0 { @@ -254,16 +292,23 @@ fn facto_power_iteration( while dj < n { let d = v_new[dj] / max_val - eigenvectors[dj][i] let ad = if d < 0.0 { -d } else { d } - if ad > diff { diff = ad } + if ad > diff { + diff = ad + } dj = dj + 1 } - if diff < tol { break } + if diff < tol { + break + } } iter = iter + 1 } eigenvalues[i] = lambda let mut ei = 0 - while ei < n { eigenvectors[ei][i] = v[ei]; ei = ei + 1 } + while ei < n { + eigenvectors[ei][i] = v[ei] + ei = ei + 1 + } // Deflation: subtract contribution of found eigenvector if lambda > 0.0 { let mut di = 0 @@ -282,6 +327,7 @@ fn facto_power_iteration( (eigenvalues, eigenvectors) } +///| fn facto_sort_eigen( eigenvalues : Array[Double], eigenvectors : Array[Array[Double]], @@ -289,7 +335,10 @@ fn facto_sort_eigen( let n = eigenvalues.length() let indices : Array[Int] = Array::make(n, 0) let mut i = 0 - while i < n { indices[i] = i; i = i + 1 } + while i < n { + indices[i] = i + i = i + 1 + } // Bubble sort by eigenvalue descending let mut iter = 0 while iter < n - 1 { @@ -304,11 +353,16 @@ fn facto_sort_eigen( } j = j + 1 } - if !swapped { break } + if !swapped { + break + } iter = iter + 1 } let sorted_eigenvalues : Array[Double] = Array::make(n, 0.0) - let sorted_eigenvectors : Array[Array[Double]] = Array::make(eigenvectors.length(), Array::make(n, 0.0)) + let sorted_eigenvectors : Array[Array[Double]] = Array::make( + eigenvectors.length(), + Array::make(n, 0.0), + ) let mut k = 0 while k < n { sorted_eigenvalues[k] = eigenvalues[indices[k]] @@ -322,19 +376,29 @@ fn facto_sort_eigen( (sorted_eigenvalues, sorted_eigenvectors) } +///| fn facto_cos2(coords : Array[Array[Double]]) -> Array[Array[Double]] { let n = coords.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let ncp = coords[0].length() let cos2 : Array[Array[Double]] = Array::make(n, Array::make(ncp, 0.0)) let mut i = 0 while i < n { let mut total = 0.0 let mut j = 0 - while j < ncp { total = total + coords[i][j] * coords[i][j]; j = j + 1 } + while j < ncp { + total = total + coords[i][j] * coords[i][j] + j = j + 1 + } let mut k = 0 while k < ncp { - cos2[i][k] = if total > 0.0 { coords[i][k] * coords[i][k] / total } else { 0.0 } + cos2[i][k] = if total > 0.0 { + coords[i][k] * coords[i][k] / total + } else { + 0.0 + } k = k + 1 } i = i + 1 @@ -342,11 +406,12 @@ fn facto_cos2(coords : Array[Array[Double]]) -> Array[Array[Double]] { cos2 } -fn facto_contrib_ind( - coords : Array[Array[Double]], -) -> Array[Array[Double]] { +///| +fn facto_contrib_ind(coords : Array[Array[Double]]) -> Array[Array[Double]] { let n = coords.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let ncp = coords[0].length() let contrib : Array[Array[Double]] = Array::make(n, Array::make(ncp, 0.0)) let total_contrib : Array[Double] = Array::make(ncp, 0.0) @@ -365,19 +430,25 @@ fn facto_contrib_ind( while k < ncp { if total_contrib[k] > 0.0 { let mut l = 0 - while l < n { contrib[l][k] = contrib[l][k] / total_contrib[k] * 100.0; l = l + 1 } + while l < n { + contrib[l][k] = contrib[l][k] / total_contrib[k] * 100.0 + l = l + 1 + } } k = k + 1 } contrib } +///| fn facto_contrib_var( coords : Array[Array[Double]], eigenvalues : Array[Double], ) -> Array[Array[Double]] { let n = coords.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let ncp = coords[0].length() let contrib : Array[Array[Double]] = Array::make(n, Array::make(ncp, 0.0)) let mut i = 0 @@ -385,7 +456,11 @@ fn facto_contrib_var( let mut j = 0 while j < ncp { let eig = eigenvalues[j] - let c = if eig > 0.0 { coords[i][j] * coords[i][j] / eig * 100.0 } else { 0.0 } + let c = if eig > 0.0 { + coords[i][j] * coords[i][j] / eig * 100.0 + } else { + 0.0 + } contrib[i][j] = c j = j + 1 } @@ -414,9 +489,14 @@ pub fn facto_get_pca_var(result : PcaResult) -> PcaVarResult { ///| /// Get contribution of variables to a specific dimension. -pub fn facto_var_contrib_dim(result : PcaResult, dim : Int) -> Array[(String, Double)] { +pub fn facto_var_contrib_dim( + result : PcaResult, + dim : Int, +) -> Array[(String, Double)] { let d = dim - 1 - if d < 0 || d >= result.n_dims { return [] } + if d < 0 || d >= result.n_dims { + return [] + } let contribs : Array[(String, Double)] = Array::new() let mut i = 0 while i < result.n_var { @@ -438,7 +518,9 @@ pub fn facto_var_contrib_dim(result : PcaResult, dim : Int) -> Array[(String, Do } j = j + 1 } - if !swapped { break } + if !swapped { + break + } iter = iter + 1 } contribs @@ -446,9 +528,14 @@ pub fn facto_var_contrib_dim(result : PcaResult, dim : Int) -> Array[(String, Do ///| /// Get contribution of individuals to a specific dimension. -pub fn facto_ind_contrib_dim(result : PcaResult, dim : Int) -> Array[(String, Double)] { +pub fn facto_ind_contrib_dim( + result : PcaResult, + dim : Int, +) -> Array[(String, Double)] { let d = dim - 1 - if d < 0 || d >= result.n_dims { return [] } + if d < 0 || d >= result.n_dims { + return [] + } let contribs : Array[(String, Double)] = Array::new() let mut i = 0 while i < result.n_ind { @@ -469,7 +556,9 @@ pub fn facto_ind_contrib_dim(result : PcaResult, dim : Int) -> Array[(String, Do } j = j + 1 } - if !swapped { break } + if !swapped { + break + } iter = iter + 1 } contribs @@ -477,9 +566,14 @@ pub fn facto_ind_contrib_dim(result : PcaResult, dim : Int) -> Array[(String, Do ///| /// Get cosine quality of representation for variables on a specific dimension. -pub fn facto_var_cos2_dim(result : PcaResult, dim : Int) -> Array[(String, Double)] { +pub fn facto_var_cos2_dim( + result : PcaResult, + dim : Int, +) -> Array[(String, Double)] { let d = dim - 1 - if d < 0 || d >= result.n_dims { return [] } + if d < 0 || d >= result.n_dims { + return [] + } let cos2s : Array[(String, Double)] = Array::new() let mut i = 0 while i < result.n_var { @@ -491,9 +585,14 @@ pub fn facto_var_cos2_dim(result : PcaResult, dim : Int) -> Array[(String, Doubl ///| /// Get cosine quality of representation for individuals on a specific dimension. -pub fn facto_ind_cos2_dim(result : PcaResult, dim : Int) -> Array[(String, Double)] { +pub fn facto_ind_cos2_dim( + result : PcaResult, + dim : Int, +) -> Array[(String, Double)] { let d = dim - 1 - if d < 0 || d >= result.n_dims { return [] } + if d < 0 || d >= result.n_dims { + return [] + } let cos2s : Array[(String, Double)] = Array::new() let mut i = 0 while i < result.n_ind { @@ -518,21 +617,33 @@ pub fn facto_dimdesc( dim : Int, ) -> Array[DimDesc] { let d = dim - 1 - if d < 0 || d >= result.n_dims { return [] } + if d < 0 || d >= result.n_dims { + return [] + } let n = data.length() let p = data[0].length() let desc : Array[DimDesc] = Array::new() let pc_scores : Array[Double] = Array::make(n, 0.0) let mut i = 0 - while i < n { pc_scores[i] = result.ind.coord[i][d]; i = i + 1 } + while i < n { + pc_scores[i] = result.ind.coord[i][d] + i = i + 1 + } let mut j = 0 while j < p { let var_vals : Array[Double] = Array::make(n, 0.0) let mut k = 0 - while k < n { var_vals[k] = data[k][j]; k = k + 1 } + while k < n { + var_vals[k] = data[k][j] + k = k + 1 + } let corr = facto_pearson_correlation(pc_scores, var_vals) let denom_base = 1.0 - corr * corr - let t_stat = if denom_base > 0.0 { corr * ((n.to_double() - 2.0) / denom_base).sqrt() } else { 0.0 } + let t_stat = if denom_base > 0.0 { + corr * ((n.to_double() - 2.0) / denom_base).sqrt() + } else { + 0.0 + } let p_val = if t_stat >= 0.0 { @math.exp(-t_stat) } else { 1.0 } desc.push(DimDesc::{ dimension: dim, @@ -548,8 +659,16 @@ pub fn facto_dimdesc( let mut swapped = false let mut l = 0 while l < n_desc - iter - 1 { - let abs_a = if desc[l].correlation < 0.0 { -desc[l].correlation } else { desc[l].correlation } - let abs_b = if desc[l + 1].correlation < 0.0 { -desc[l + 1].correlation } else { desc[l + 1].correlation } + let abs_a = if desc[l].correlation < 0.0 { + -desc[l].correlation + } else { + desc[l].correlation + } + let abs_b = if desc[l + 1].correlation < 0.0 { + -desc[l + 1].correlation + } else { + desc[l + 1].correlation + } if abs_a < abs_b { let tmp = desc[l] desc[l] = desc[l + 1] @@ -558,19 +677,28 @@ pub fn facto_dimdesc( } l = l + 1 } - if !swapped { break } + if !swapped { + break + } iter = iter + 1 } desc } +///| fn facto_pearson_correlation(x : Array[Double], y : Array[Double]) -> Double { let n = x.length() - if n < 3 { return 0.0 } + if n < 3 { + return 0.0 + } let mut mx = 0.0 let mut my = 0.0 let mut i = 0 - while i < n { mx = mx + x[i]; my = my + y[i]; i = i + 1 } + while i < n { + mx = mx + x[i] + my = my + y[i] + i = i + 1 + } mx = mx / n.to_double() my = my / n.to_double() let mut num = 0.0 @@ -586,7 +714,9 @@ fn facto_pearson_correlation(x : Array[Double], y : Array[Double]) -> Double { j = j + 1 } let denom = (dx * dy).sqrt() - if denom == 0.0 { return 0.0 } + if denom == 0.0 { + return 0.0 + } num / denom } @@ -607,7 +737,9 @@ pub fn facto_nb_dim(result : PcaResult, threshold : Double) -> Int { let mut i = 0 while i < result.eigenvalues.length() { cum = cum + result.eigenvalues[i].variance_explained - if cum >= threshold { return i + 1 } + if cum >= threshold { + return i + 1 + } i = i + 1 } result.eigenvalues.length() @@ -625,7 +757,11 @@ pub struct PcaSummary { ///| pub fn facto_summary(result : PcaResult) -> PcaSummary { let total = facto_total_inertia(result) - let first_var = if result.eigenvalues.length() > 0 { result.eigenvalues[0].variance_explained } else { 0.0 } + let first_var = if result.eigenvalues.length() > 0 { + result.eigenvalues[0].variance_explained + } else { + 0.0 + } PcaSummary::{ n_individuals: result.n_ind, n_variables: result.n_var, @@ -655,7 +791,9 @@ pub fn facto_print_summary(result : PcaResult) -> String { lines.push("") lines.push("Eigenvalues:") for ev in result.eigenvalues { - lines.push(" Dim \{ev.dimension}: eigenvalue=\{ev.eigenvalue}, var=\{ev.variance_explained}%, cum=\{ev.cumulative_variance}%") + lines.push( + " Dim \{ev.dimension}: eigenvalue=\{ev.eigenvalue}, var=\{ev.variance_explained}%, cum=\{ev.cumulative_variance}%", + ) } lines.join("\n") } diff --git a/src/fasta_search_io.mbt b/src/fasta_search_io.mbt index 94ec3442..6ee9a69a 100644 --- a/src/fasta_search_io.mbt +++ b/src/fasta_search_io.mbt @@ -281,9 +281,7 @@ pub fn parse_fasta_m8(content : String) -> Array[QueryResult] { hits.push(Hit::new(sid, "", "", hsps, tbs, mev)) ti = ti + 1 } - results.push( - QueryResult::new(qid, "", 0, hits, "fasta", "36", ""), - ) + results.push(QueryResult::new(qid, "", 0, hits, "fasta", "36", "")) qi = qi + 1 } @@ -476,8 +474,8 @@ fn fasta_sio_parse_row(ln : String) -> FastaRow { /// Generate a small FASTA `-m 8` (compact tabular) sample for tests and demos. pub fn fasta_m8_sample() -> String { "query1\tsubject1\t95.0\t100\t5\t0\t1\t100\t1\t100\t1e-50\t200.3\n" + - "query1\tsubject2\t80.0\t80\t16\t2\t1\t80\t10\t90\t1e-30\t150.1\n" + - "query2\tsubject1\t70.0\t60\t18\t3\t1\t60\t5\t65\t1e-20\t100.5\n" + "query1\tsubject2\t80.0\t80\t16\t2\t1\t80\t10\t90\t1e-30\t150.1\n" + + "query2\tsubject1\t70.0\t60\t18\t3\t1\t60\t5\t65\t1e-20\t100.5\n" } ///| @@ -485,11 +483,11 @@ pub fn fasta_m8_sample() -> String { /// for tests and demos. pub fn fasta_m9_sample() -> String { "# FASTA 36.3.8h May 10, 2023\n" + - "# Query: query1 - example query 1\n" + - "# Database: uniprot_sprot.fasta\n" + - "# Fields: query id, subject id, % identity, alignment length, mismatches, gap openings, q.start, q.end, s.start, s.end, e-value, bit score\n" + - "query1\tsubject1\t95.0\t100\t5\t0\t1\t100\t1\t100\t1e-50\t200.3\n" + - "query1\tsubject2\t80.0\t80\t16\t2\t1\t80\t10\t90\t1e-30\t150.1\n" + - "# Query: query2 - example query 2\n" + - "query2\tsubject1\t70.0\t60\t18\t3\t1\t60\t5\t65\t1e-20\t100.5\n" + "# Query: query1 - example query 1\n" + + "# Database: uniprot_sprot.fasta\n" + + "# Fields: query id, subject id, % identity, alignment length, mismatches, gap openings, q.start, q.end, s.start, s.end, e-value, bit score\n" + + "query1\tsubject1\t95.0\t100\t5\t0\t1\t100\t1\t100\t1e-50\t200.3\n" + + "query1\tsubject2\t80.0\t80\t16\t2\t1\t80\t10\t90\t1e-30\t150.1\n" + + "# Query: query2 - example query 2\n" + + "query2\tsubject1\t70.0\t60\t18\t3\t1\t60\t5\t65\t1e-20\t100.5\n" } diff --git a/src/feature_counts.mbt b/src/feature_counts.mbt index f94734f4..31d71869 100644 --- a/src/feature_counts.mbt +++ b/src/feature_counts.mbt @@ -73,8 +73,13 @@ pub fn FeatureAnnotation::new( feature_id } FeatureAnnotation::{ - chr, start, end_, strand, gene_id, - transcript_id, feature_type, + chr, + start, + end_, + strand, + gene_id, + transcript_id, + feature_type, feature_id: fid, } } @@ -82,7 +87,11 @@ pub fn FeatureAnnotation::new( ///| /// Get the length of the feature. pub fn FeatureAnnotation::length(self : FeatureAnnotation) -> Int { - if self.end_ > self.start { self.end_ - self.start + 1 } else { 0 } + if self.end_ > self.start { + self.end_ - self.start + 1 + } else { + 0 + } } ///| @@ -93,7 +102,9 @@ pub fn FeatureAnnotation::overlaps( start~ : Int, end_~ : Int, ) -> Bool { - if self.chr != chr { return false } + if self.chr != chr { + return false + } self.start <= end_ && self.end_ >= start } @@ -105,10 +116,16 @@ pub fn FeatureAnnotation::overlap_length( start~ : Int, end_~ : Int, ) -> Int { - if self.chr != chr { return 0 } + if self.chr != chr { + return 0 + } let ov_start = if self.start > start { self.start } else { start } let ov_end = if self.end_ < end_ { self.end_ } else { end_ } - if ov_end >= ov_start { ov_end - ov_start + 1 } else { 0 } + if ov_end >= ov_start { + ov_end - ov_start + 1 + } else { + 0 + } } ///| @@ -149,7 +166,12 @@ pub fn ReadAlignment::new( mapq? : Int = 60, ) -> ReadAlignment { ReadAlignment::{ - read_id, chr, start, end_, strand, mapq, + read_id, + chr, + start, + end_, + strand, + mapq, n_alignments: 1, is_paired: false, mate_chr: "", @@ -171,15 +193,28 @@ pub fn ReadAlignment::new_paired( mate_start? : Int = 0, ) -> ReadAlignment { let frag_len = if mate_start > 0 { - if mate_start > end_ { mate_start - start + 1 } else { end_ - mate_start + 1 } + if mate_start > end_ { + mate_start - start + 1 + } else { + end_ - mate_start + 1 + } } else { 0 } ReadAlignment::{ - read_id, chr, start, end_, strand, mapq, + read_id, + chr, + start, + end_, + strand, + mapq, n_alignments: 1, is_paired: true, - mate_chr: if mate_chr == "" { chr } else { mate_chr }, + mate_chr: if mate_chr == "" { + chr + } else { + mate_chr + }, mate_start, fragment_length: frag_len, } @@ -192,8 +227,16 @@ pub fn ReadAlignment::fragment_span(self : ReadAlignment) -> (String, Int, Int) return (self.chr, self.start, self.end_) } if self.chr == self.mate_chr { - let f_start = if self.start < self.mate_start { self.start } else { self.mate_start } - let f_end = if self.end_ > self.mate_start { self.end_ } else { self.mate_start } + let f_start = if self.start < self.mate_start { + self.start + } else { + self.mate_start + } + let f_end = if self.end_ > self.mate_start { + self.end_ + } else { + self.mate_start + } (self.chr, f_start, f_end) } else { (self.chr, self.start, self.end_) @@ -244,7 +287,10 @@ pub fn FeatureCountsConfig::new() -> FeatureCountsConfig { ///| /// Set minimum overlap (returns new config). -pub fn FeatureCountsConfig::set_min_overlap(self : FeatureCountsConfig, val~ : Int) -> FeatureCountsConfig { +pub fn FeatureCountsConfig::set_min_overlap( + self : FeatureCountsConfig, + val~ : Int, +) -> FeatureCountsConfig { FeatureCountsConfig::{ min_overlap: val, min_overlap_total: self.min_overlap_total, @@ -261,7 +307,10 @@ pub fn FeatureCountsConfig::set_min_overlap(self : FeatureCountsConfig, val~ : I ///| /// Set strand mode (returns new config). -pub fn FeatureCountsConfig::set_strand_mode(self : FeatureCountsConfig, mode~ : StrandMode) -> FeatureCountsConfig { +pub fn FeatureCountsConfig::set_strand_mode( + self : FeatureCountsConfig, + mode~ : StrandMode, +) -> FeatureCountsConfig { FeatureCountsConfig::{ min_overlap: self.min_overlap, min_overlap_total: self.min_overlap_total, @@ -278,7 +327,10 @@ pub fn FeatureCountsConfig::set_strand_mode(self : FeatureCountsConfig, mode~ : ///| /// Set minimum mapping quality (returns new config). -pub fn FeatureCountsConfig::set_min_mapq(self : FeatureCountsConfig, val~ : Int) -> FeatureCountsConfig { +pub fn FeatureCountsConfig::set_min_mapq( + self : FeatureCountsConfig, + val~ : Int, +) -> FeatureCountsConfig { FeatureCountsConfig::{ min_overlap: self.min_overlap, min_overlap_total: self.min_overlap_total, @@ -295,7 +347,10 @@ pub fn FeatureCountsConfig::set_min_mapq(self : FeatureCountsConfig, val~ : Int) ///| /// Set count fragments flag (returns new config). -pub fn FeatureCountsConfig::set_count_fragments(self : FeatureCountsConfig, val~ : Bool) -> FeatureCountsConfig { +pub fn FeatureCountsConfig::set_count_fragments( + self : FeatureCountsConfig, + val~ : Bool, +) -> FeatureCountsConfig { FeatureCountsConfig::{ min_overlap: self.min_overlap, min_overlap_total: self.min_overlap_total, @@ -312,7 +367,10 @@ pub fn FeatureCountsConfig::set_count_fragments(self : FeatureCountsConfig, val~ ///| /// Set multi-count flag (returns new config). -pub fn fcfg_set_multi_count(cfg : FeatureCountsConfig, val~ : Bool) -> FeatureCountsConfig { +pub fn fcfg_set_multi_count( + cfg : FeatureCountsConfig, + val~ : Bool, +) -> FeatureCountsConfig { FeatureCountsConfig::{ min_overlap: cfg.min_overlap, min_overlap_total: cfg.min_overlap_total, @@ -374,8 +432,12 @@ pub fn FeatureCountsResult::get_count( sample_idx~ : Int, ) -> Double { let fi = fc_feature_index(self, feature_id) - if fi < 0 { return 0.0 } - if sample_idx < 0 || sample_idx >= self.counts.length() { return 0.0 } + if fi < 0 { + return 0.0 + } + if sample_idx < 0 || sample_idx >= self.counts.length() { + return 0.0 + } self.counts[sample_idx][fi] } @@ -385,7 +447,9 @@ pub fn FeatureCountsResult::library_size( self : FeatureCountsResult, sample_idx~ : Int, ) -> Double { - if sample_idx < 0 || sample_idx >= self.counts.length() { return 0.0 } + if sample_idx < 0 || sample_idx >= self.counts.length() { + return 0.0 + } let mut total = 0.0 let mut i = 0 while i < self.counts[sample_idx].length() { @@ -402,9 +466,13 @@ pub fn FeatureCountsResult::cpm( feature_id~ : String, sample_idx~ : Int, ) -> Double { - let raw = self.get_count(feature_id=feature_id, sample_idx=sample_idx) - let lib = self.library_size(sample_idx=sample_idx) - if lib == 0.0 { 0.0 } else { raw / lib * 1_000_000.0 } + let raw = self.get_count(feature_id~, sample_idx~) + let lib = self.library_size(sample_idx~) + if lib == 0.0 { + 0.0 + } else { + raw / lib * 1_000_000.0 + } } ///| @@ -414,7 +482,9 @@ pub fn FeatureCountsResult::get_feature_total( feature_id~ : String, ) -> Double { let fi = fc_feature_index(self, feature_id) - if fi < 0 { return 0.0 } + if fi < 0 { + return 0.0 + } let mut total = 0.0 let mut i = 0 while i < self.counts.length() { @@ -437,9 +507,23 @@ pub fn FeatureCountsResult::summary(self : FeatureCountsResult) -> String { let assigned = self.assigned_reads[i] let pct = if total > 0 { (assigned.to_double() / total.to_double() * 100.0).to_string() + "%" - } else { "0.0%" } - s = s + " " + name + ": total=" + total.to_string() + ", assigned=" + assigned.to_string() + " (" + pct + ")" + "\n" - s = s + " Unassigned: no_features=" + self.unassigned_no_features[i].to_string() + } else { + "0.0%" + } + s = s + + " " + + name + + ": total=" + + total.to_string() + + ", assigned=" + + assigned.to_string() + + " (" + + pct + + ")" + + "\n" + s = s + + " Unassigned: no_features=" + + self.unassigned_no_features[i].to_string() s = s + ", ambiguous=" + self.unassigned_ambiguous[i].to_string() s = s + ", multi=" + self.unassigned_multi[i].to_string() s = s + ", low_quality=" + self.unassigned_low_quality[i].to_string() + "\n" @@ -453,7 +537,11 @@ pub fn FeatureCountsResult::summary(self : FeatureCountsResult) -> String { pub fn FeatureCountsResult::to_string(self : FeatureCountsResult) -> String { let mut s = self.summary() s = s + "\n=== Count Matrix (first 10 features) ===" + "\n" - let n_features = if self.feature_ids.length() < 10 { self.feature_ids.length() } else { 10 } + let n_features = if self.feature_ids.length() < 10 { + self.feature_ids.length() + } else { + 10 + } let mut i = 0 while i < n_features { let fid = self.feature_ids[i] @@ -479,7 +567,11 @@ pub fn feature_counts_count( ) -> FeatureCountsResult { let n_features = features.length() let n_reads = reads.length() - let n_samples = if sample_names.length() > 0 { sample_names.length() } else { 1 } + let n_samples = if sample_names.length() > 0 { + sample_names.length() + } else { + 1 + } let feat_ids : Array[String] = Array::new() let gene_ids : Array[String] = Array::new() @@ -539,7 +631,8 @@ pub fn feature_counts_count( total_reads[sample_idx] = total_reads[sample_idx] + 1 if read.mapq < config.min_mapq { - unassigned_low_quality[sample_idx] = unassigned_low_quality[sample_idx] + 1 + unassigned_low_quality[sample_idx] = unassigned_low_quality[sample_idx] + + 1 r = r + 1 continue } @@ -556,19 +649,35 @@ pub fn feature_counts_count( let mut fi = 0 while fi < n_features { let feat = features[fi] - if feat.chr != f_chr { fi = fi + 1; continue } + if feat.chr != f_chr { + fi = fi + 1 + continue + } let ov_len = feat.overlap_length(chr=f_chr, start=f_start, end_=f_end) - if ov_len < config.min_overlap { fi = fi + 1; continue } + if ov_len < config.min_overlap { + fi = fi + 1 + continue + } if config.frac_overlap > 0.0 { let frac = ov_len.to_double() / read_len.to_double() - if frac < config.frac_overlap { fi = fi + 1; continue } + if frac < config.frac_overlap { + fi = fi + 1 + continue + } } if !config.ignore_strand { - let strand_match = fc_check_strand_match(feat.strand, read.strand, config.strand_mode) - if !strand_match { fi = fi + 1; continue } + let strand_match = fc_check_strand_match( + feat.strand, + read.strand, + config.strand_mode, + ) + if !strand_match { + fi = fi + 1 + continue + } } overlapping.push((fi, ov_len)) @@ -576,7 +685,8 @@ pub fn feature_counts_count( } if overlapping.length() == 0 { - unassigned_no_features[sample_idx] = unassigned_no_features[sample_idx] + 1 + unassigned_no_features[sample_idx] = unassigned_no_features[sample_idx] + + 1 r = r + 1 continue } @@ -608,7 +718,7 @@ pub fn feature_counts_count( FeatureCountsResult::{ feature_ids: feat_ids, - gene_ids: gene_ids, + gene_ids, counts, sample_names: sn, total_reads, @@ -623,33 +733,87 @@ pub fn feature_counts_count( ///| /// Create sample data for testing. -pub fn feature_counts_sample_data() -> (Array[FeatureAnnotation], Array[ReadAlignment], Array[String]) { +pub fn feature_counts_sample_data() -> ( + Array[FeatureAnnotation], + Array[ReadAlignment], + Array[String], +) { let features : Array[FeatureAnnotation] = Array::new() - features.push(FeatureAnnotation::new( - chr="chr1", start=1000, end_=2000, strand="+", gene_id="GeneA", - feature_id="exon_A1", - )) - features.push(FeatureAnnotation::new( - chr="chr1", start=3000, end_=5000, strand="+", gene_id="GeneA", - feature_id="exon_A2", - )) - features.push(FeatureAnnotation::new( - chr="chr1", start=6000, end_=8000, strand="-", gene_id="GeneB", - feature_id="exon_B1", - )) - features.push(FeatureAnnotation::new( - chr="chr2", start=1000, end_=3000, strand="+", gene_id="GeneC", - feature_id="exon_C1", - )) + features.push( + FeatureAnnotation::new( + chr="chr1", + start=1000, + end_=2000, + strand="+", + gene_id="GeneA", + feature_id="exon_A1", + ), + ) + features.push( + FeatureAnnotation::new( + chr="chr1", + start=3000, + end_=5000, + strand="+", + gene_id="GeneA", + feature_id="exon_A2", + ), + ) + features.push( + FeatureAnnotation::new( + chr="chr1", + start=6000, + end_=8000, + strand="-", + gene_id="GeneB", + feature_id="exon_B1", + ), + ) + features.push( + FeatureAnnotation::new( + chr="chr2", + start=1000, + end_=3000, + strand="+", + gene_id="GeneC", + feature_id="exon_C1", + ), + ) let reads : Array[ReadAlignment] = Array::new() - reads.push(ReadAlignment::new(read_id="read1", chr="chr1", start=1500, end_=1600)) - reads.push(ReadAlignment::new(read_id="read2", chr="chr1", start=3500, end_=3600)) - reads.push(ReadAlignment::new(read_id="read3", chr="chr1", start=6500, end_=6600, strand="-")) - reads.push(ReadAlignment::new(read_id="read4", chr="chr2", start=1500, end_=1600)) - reads.push(ReadAlignment::new(read_id="read5", chr="chr1", start=1500, end_=1600, mapq=30)) - reads.push(ReadAlignment::new(read_id="read6", chr="chr3", start=1000, end_=1100)) - reads.push(ReadAlignment::new(read_id="read7", chr="chr1", start=1700, end_=1800)) + reads.push( + ReadAlignment::new(read_id="read1", chr="chr1", start=1500, end_=1600), + ) + reads.push( + ReadAlignment::new(read_id="read2", chr="chr1", start=3500, end_=3600), + ) + reads.push( + ReadAlignment::new( + read_id="read3", + chr="chr1", + start=6500, + end_=6600, + strand="-", + ), + ) + reads.push( + ReadAlignment::new(read_id="read4", chr="chr2", start=1500, end_=1600), + ) + reads.push( + ReadAlignment::new( + read_id="read5", + chr="chr1", + start=1500, + end_=1600, + mapq=30, + ), + ) + reads.push( + ReadAlignment::new(read_id="read6", chr="chr3", start=1000, end_=1100), + ) + reads.push( + ReadAlignment::new(read_id="read7", chr="chr1", start=1700, end_=1800), + ) let sample_names : Array[String] = Array::new() sample_names.push("sample_1") @@ -659,23 +823,35 @@ pub fn feature_counts_sample_data() -> (Array[FeatureAnnotation], Array[ReadAlig // --- Internal helpers --- +///| fn fc_feature_index(result : FeatureCountsResult, feature_id : String) -> Int { let mut i = 0 while i < result.feature_ids.length() { - if result.feature_ids[i] == feature_id { return i } + if result.feature_ids[i] == feature_id { + return i + } i = i + 1 } -1 } -fn fc_check_strand_match(feature_strand : String, read_strand : String, mode : StrandMode) -> Bool { - if feature_strand == "*" { return true } +///| +fn fc_check_strand_match( + feature_strand : String, + read_strand : String, + mode : StrandMode, +) -> Bool { + if feature_strand == "*" { + return true + } match mode { StrandMode::Unstranded => true StrandMode::Stranded => feature_strand == read_strand - StrandMode::Reversed => { - if feature_strand == "+" { read_strand == "-" } - else { read_strand == "+" } - } + StrandMode::Reversed => + if feature_strand == "+" { + read_strand == "-" + } else { + read_strand == "+" + } } } diff --git a/src/file.mbt b/src/file.mbt index bec5b40d..3f3bee37 100644 --- a/src/file.mbt +++ b/src/file.mbt @@ -13,9 +13,12 @@ ///| /// Supported file compression formats. pub enum CompressionFormat { - Plain /// No compression (plain text) - Gzip /// gzip compression (.gz) - Bzip2 /// bzip2 compression (.bz2) + /// No compression (plain text) + /// gzip compression (.gz) + /// bzip2 compression (.bz2) + Plain + Gzip + Bzip2 } ///| @@ -45,16 +48,21 @@ pub fn CompressionFormat::to_string(self : CompressionFormat) -> String { CompressionFormat::Bzip2 => "bzip2" } } + ///| /// A smart file handle with automatic compression detection. pub struct SmartFile { path : String format : CompressionFormat - mode : String /// "r" for read, "w" for write + /// "r" for read, "w" for write + mode : String is_open : Bool - lines : Array[String] /// buffered lines for reading - pos : Int /// current read position - written_content : String /// accumulated content for writing + /// buffered lines for reading + /// current read position + /// accumulated content for writing + lines : Array[String] + pos : Int + written_content : String } ///| @@ -251,7 +259,10 @@ pub fn SmartFile::get_written_content(self : SmartFile) -> String { ///| /// Set pre-loaded lines (for testing/simulation purposes). /// In a real implementation, this would be handled by open() reading the file. -pub fn SmartFile::set_lines(self : SmartFile, lines : Array[String]) -> SmartFile { +pub fn SmartFile::set_lines( + self : SmartFile, + lines : Array[String], +) -> SmartFile { SmartFile::{ path: self.path, format: self.format, @@ -284,7 +295,10 @@ pub fn smart_file_from_lines(path : String, lines : Array[String]) -> SmartFile ///| /// Create a write-mode SmartFile. -pub fn smart_file_writer(path : String, format? : CompressionFormat = CompressionFormat::Plain) -> SmartFile { +pub fn smart_file_writer( + path : String, + format? : CompressionFormat = CompressionFormat::Plain, +) -> SmartFile { SmartFile::with_format(path, format, mode="w") } @@ -295,7 +309,16 @@ pub fn SmartFile::summary(self : SmartFile) -> String { let mode_str = self.mode let state = if self.is_open { "open" } else { "closed" } let n_lines = self.lines.length() - "SmartFile: " + self.path + " | format=" + format_str + " | mode=" + mode_str + " | " + state + " | lines=" + n_lines.to_string() + "SmartFile: " + + self.path + + " | format=" + + format_str + + " | mode=" + + mode_str + + " | " + + state + + " | lines=" + + n_lines.to_string() } ///| diff --git a/src/fishpond.mbt b/src/fishpond.mbt index ed2fe3e3..10220b0b 100644 --- a/src/fishpond.mbt +++ b/src/fishpond.mbt @@ -202,7 +202,11 @@ pub fn fish_log2fc_test( let control_mean = stat_mean(control_vals) // Add pseudocount of 1 to avoid log(0) let case_log = if case_mean > 0.0 { @math.log2(case_mean + 1.0) } else { 0.0 } - let control_log = if control_mean > 0.0 { @math.log2(control_mean + 1.0) } else { 0.0 } + let control_log = if control_mean > 0.0 { + @math.log2(control_mean + 1.0) + } else { + 0.0 + } case_log - control_log } @@ -331,14 +335,19 @@ pub fn fish_swish( perm_count = perm_count + 1 } } - p_values[t] = (perm_count.to_double() + 1.0) / (n_permutations.to_double() + 1.0) + p_values[t] = (perm_count.to_double() + 1.0) / + (n_permutations.to_double() + 1.0) } // BH-FDR correction let fdrs = stat_bh(p_values) // Build results for t in 0.. 0.0 { "up" } else { "down" } + if log2fcs[t] > 0.0 { + "up" + } else { + "down" + } } else { "ns" } @@ -378,12 +387,12 @@ pub fn fish_sample_counts() -> FishCounts { "TX1", "TX2", "TX3", "TX4", "TX5", "TX6", "TX7", "TX8", "TX9", "TX10", ] let sample_names = [ - "case1", "case2", "case3", "case4", "case5", "case6", "case7", "case8", - "ctrl1", "ctrl2", "ctrl3", "ctrl4", "ctrl5", "ctrl6", "ctrl7", "ctrl8", + "case1", "case2", "case3", "case4", "case5", "case6", "case7", "case8", "ctrl1", + "ctrl2", "ctrl3", "ctrl4", "ctrl5", "ctrl6", "ctrl7", "ctrl8", ] let condition = [ - "case", "case", "case", "case", "case", "case", "case", "case", - "control", "control", "control", "control", "control", "control", "control", "control", + "case", "case", "case", "case", "case", "case", "case", "case", "control", "control", + "control", "control", "control", "control", "control", "control", ] // transcript × sample counts (10 × 16) let counts : Array[Array[Double]] = [] @@ -391,7 +400,11 @@ pub fn fish_sample_counts() -> FishCounts { for t in 0..<3 { let row : Array[Double] = [] for s in 0..<16 { - let val = if s < 8 { 50.0 + t.to_double() * 10.0 + s.to_double() * 2.0 } else { 10.0 + (s - 8).to_double() * 1.0 } + let val = if s < 8 { + 50.0 + t.to_double() * 10.0 + s.to_double() * 2.0 + } else { + 10.0 + (s - 8).to_double() * 1.0 + } row.push(val) } counts.push(row) @@ -400,7 +413,11 @@ pub fn fish_sample_counts() -> FishCounts { for t in 0..<3 { let row : Array[Double] = [] for s in 0..<16 { - let val = if s < 8 { 10.0 + s.to_double() * 1.0 } else { 50.0 + t.to_double() * 10.0 + (s - 8).to_double() * 2.0 } + let val = if s < 8 { + 10.0 + s.to_double() * 1.0 + } else { + 50.0 + t.to_double() * 10.0 + (s - 8).to_double() * 2.0 + } row.push(val) } counts.push(row) @@ -441,16 +458,38 @@ pub fn fish_significant( ///| /// Format a FishResult as a readable string. pub fn FishResult::to_string(self : FishResult) -> String { - self.transcript + " log2FC=" + self.log2_fold_change.to_string() + " p=" + self.p_value.to_string() + " fdr=" + self.fdr.to_string() + " dir=" + self.direction + self.transcript + + " log2FC=" + + self.log2_fold_change.to_string() + + " p=" + + self.p_value.to_string() + + " fdr=" + + self.fdr.to_string() + + " dir=" + + self.direction } ///| /// Format all results as a table. pub fn fish_results_to_string(results : Array[FishResult]) -> String { - let mut s = "Swish Results (" + results.length().to_string() + " transcripts)\n" + let mut s = "Swish Results (" + + results.length().to_string() + + " transcripts)\n" s = s + "transcript\tstatistic\tlog2FC\tp_value\tfdr\tdirection\n" for r in results { - s = s + r.transcript + "\t" + r.statistic.to_string() + "\t" + r.log2_fold_change.to_string() + "\t" + r.p_value.to_string() + "\t" + r.fdr.to_string() + "\t" + r.direction + "\n" + s = s + + r.transcript + + "\t" + + r.statistic.to_string() + + "\t" + + r.log2_fold_change.to_string() + + "\t" + + r.p_value.to_string() + + "\t" + + r.fdr.to_string() + + "\t" + + r.direction + + "\n" } s } diff --git a/src/fragment_mapper.mbt b/src/fragment_mapper.mbt index d740209e..777a1cd3 100644 --- a/src/fragment_mapper.mbt +++ b/src/fragment_mapper.mbt @@ -17,18 +17,41 @@ pub enum FragmentType { Turn } derive(Eq, Debug) -///| Construct a Helix FragmentType. -pub fn ft_helix() -> FragmentType { Helix } -///| Construct a Sheet FragmentType. -pub fn ft_sheet() -> FragmentType { Sheet } -///| Construct a Loop FragmentType. -pub fn ft_loop() -> FragmentType { Loop } -///| Construct a Coil FragmentType. -pub fn ft_coil() -> FragmentType { Coil } -///| Construct a Bridge FragmentType. -pub fn ft_bridge() -> FragmentType { Bridge } -///| Construct a Turn FragmentType. -pub fn ft_turn() -> FragmentType { Turn } +///| +/// Construct a Helix FragmentType. +pub fn ft_helix() -> FragmentType { + Helix +} + +///| +/// Construct a Sheet FragmentType. +pub fn ft_sheet() -> FragmentType { + Sheet +} + +///| +/// Construct a Loop FragmentType. +pub fn ft_loop() -> FragmentType { + Loop +} + +///| +/// Construct a Coil FragmentType. +pub fn ft_coil() -> FragmentType { + Coil +} + +///| +/// Construct a Bridge FragmentType. +pub fn ft_bridge() -> FragmentType { + Bridge +} + +///| +/// Construct a Turn FragmentType. +pub fn ft_turn() -> FragmentType { + Turn +} ///| /// A single residue within a fragment. @@ -273,11 +296,7 @@ pub fn fm_assign_fragments( let residues : Array[FragmentResidue] = Array::new() let mut j = start while j <= end { - let res_name = if j < seq_len { - char_at(sequence, j) - } else { - "X" - } + let res_name = if j < seq_len { char_at(sequence, j) } else { "X" } residues.push(FragmentResidue::{ res_name, res_num: j + 1, @@ -354,7 +373,7 @@ pub fn fm_parse_fragments(content : String) -> FragmentMapperResult { atom_count: prev.atom_count + 1, is_c_alpha: prev.is_c_alpha || atom_name == "CA", is_sidechain: prev.is_sidechain || - !(atom_name == "N" || atom_name == "CA" || atom_name == "C"), + !(atom_name == "N" || atom_name == "CA" || atom_name == "C"), } residue_map[key] = updated let chain_res = chain_map.get(chain_id) @@ -376,7 +395,9 @@ pub fn fm_parse_fragments(content : String) -> FragmentMapperResult { } None => { let is_ca = atom_name == "CA" - let is_sc = !(atom_name == "N" || atom_name == "CA" || atom_name == "C") + let is_sc = !(atom_name == "N" || + atom_name == "CA" || + atom_name == "C") let new_res = FragmentResidue::{ res_name, res_num, @@ -393,9 +414,7 @@ pub fn fm_parse_fragments(content : String) -> FragmentMapperResult { new_arr.push(new_res) chain_map[chain_id] = new_arr } - None => { - chain_map[chain_id] = [new_res] - } + None => chain_map[chain_id] = [new_res] } sequence = sequence + _three_to_one(res_name) @@ -465,10 +484,7 @@ fn _sort_by_resnum(residues : Array[FragmentResidue]) -> Array[FragmentResidue] ///| /// Get a fragment by its ID string. Returns None if not found. -pub fn fm_get_fragment( - result : FragmentMapperResult, - id : String, -) -> Fragment? { +pub fn fm_get_fragment(result : FragmentMapperResult, id : String) -> Fragment? { for frag in result.fragments { if frag.id == id { return Some(frag) @@ -556,10 +572,11 @@ fn _sort_fragments_by_position(fragments : Array[Fragment]) -> Array[Fragment] { let key = result[i] let mut j = i - 1 while j >= 0 { - let should_swap = - result[j].start_residue > key.start_residue || - (result[j].start_residue == key.start_residue && - result[j].chain_id > key.chain_id) + let should_swap = result[j].start_residue > key.start_residue || + ( + result[j].start_residue == key.start_residue && + result[j].chain_id > key.chain_id + ) if should_swap { result[j + 1] = result[j] j = j - 1 @@ -603,4 +620,4 @@ pub fn fm_filter_by_length( } } result -} \ No newline at end of file +} diff --git a/src/freq_analysis.mbt b/src/freq_analysis.mbt index db334e1c..2b0c0fb7 100644 --- a/src/freq_analysis.mbt +++ b/src/freq_analysis.mbt @@ -16,32 +16,40 @@ pub struct FreqAnalysisResult { pub fn FreqAnalysisResult::new( frequencies : Map[String, Double], counts : Map[String, Int], - total_count : Int + total_count : Int, ) -> FreqAnalysisResult { FreqAnalysisResult::{ frequencies, counts, total_count } } ///| /// Get frequency for a given pattern. -pub fn fa_get_frequency(self : FreqAnalysisResult, pattern : String) -> Double { +pub fn FreqAnalysisResult::fa_get_frequency( + self : FreqAnalysisResult, + pattern : String, +) -> Double { self.frequencies.get_or_default(pattern, 0.0) } ///| /// Get count for a given pattern. -pub fn fa_get_count(self : FreqAnalysisResult, pattern : String) -> Int { +pub fn FreqAnalysisResult::fa_get_count( + self : FreqAnalysisResult, + pattern : String, +) -> Int { self.counts.get_or_default(pattern, 0) } ///| /// Get total count. -pub fn fa_get_total_count(self : FreqAnalysisResult) -> Int { +pub fn FreqAnalysisResult::fa_get_total_count(self : FreqAnalysisResult) -> Int { self.total_count } ///| /// Get all patterns. -pub fn fa_get_patterns(self : FreqAnalysisResult) -> Array[String] { +pub fn FreqAnalysisResult::fa_get_patterns( + self : FreqAnalysisResult, +) -> Array[String] { let patterns : Array[String] = Array::new() for key in self.frequencies.keys() { patterns.push(key) @@ -56,7 +64,7 @@ pub fn fa_count_pattern(sequence : String, pattern : String) -> Int { if pattern_len == 0 || sequence.length() < pattern_len { return 0 } - + let mut count = 0 let mut pos = 0 while pos <= sequence.length() - pattern_len { @@ -74,11 +82,11 @@ pub fn fa_count_pattern(sequence : String, pattern : String) -> Int { pub fn fa_count_kmers(sequence : String, k : Int) -> FreqAnalysisResult { let counts : Map[String, Int] = Map([], capacity=100) let seq_len = sequence.length() - + if seq_len < k { return FreqAnalysisResult::new(Map([], capacity=0), Map([], capacity=0), 0) } - + let mut total = 0 let mut pos = 0 while pos <= seq_len - k { @@ -88,13 +96,13 @@ pub fn fa_count_kmers(sequence : String, k : Int) -> FreqAnalysisResult { total = total + 1 pos = pos + 1 } - + let frequencies : Map[String, Double] = Map([], capacity=counts.length()) for key in counts.keys() { let count = counts.get_or_default(key, 0) frequencies.set(key, count.to_double() / total.to_double()) } - + FreqAnalysisResult::new(frequencies, counts, total) } @@ -121,7 +129,7 @@ pub fn fa_trinucleotide_frequency(sequence : String) -> FreqAnalysisResult { /// Expected dinucleotide frequency = freq(A) * freq(B) pub fn fa_expected_dinucleotide_freq( mono_freqs : FreqAnalysisResult, - dinuc : String + dinuc : String, ) -> Double { if dinuc.length() != 2 { return 0.0 @@ -140,20 +148,18 @@ pub fn fa_dinucleotide_oe_ratio(sequence : String) -> Map[String, Double] { let mono = fa_nucleotide_frequency(sequence) let dinuc = fa_dinucleotide_frequency(sequence) let ratios : Map[String, Double] = Map([], capacity=16) - + let dinucleotides = [ - "AA", "AC", "AG", "AT", - "CA", "CC", "CG", "CT", - "GA", "GC", "GG", "GT", - "TA", "TC", "TG", "TT" + "AA", "AC", "AG", "AT", "CA", "CC", "CG", "CT", "GA", "GC", "GG", "GT", "TA", + "TC", "TG", "TT", ] - + let mut i = 0 while i < dinucleotides.length() { let dinuc_name = dinucleotides[i] let obs_freq = dinuc.fa_get_frequency(dinuc_name) let exp_freq = fa_expected_dinucleotide_freq(mono, dinuc_name) - + if exp_freq > 0.0 { ratios.set(dinuc_name, obs_freq / exp_freq) } else { @@ -161,7 +167,7 @@ pub fn fa_dinucleotide_oe_ratio(sequence : String) -> Map[String, Double] { } i = i + 1 } - + ratios } @@ -170,11 +176,11 @@ pub fn fa_dinucleotide_oe_ratio(sequence : String) -> Map[String, Double] { pub fn fa_codon_usage(sequence : String) -> FreqAnalysisResult { let counts : Map[String, Int] = Map([], capacity=64) let seq_len = sequence.length() - + if seq_len < 3 { return FreqAnalysisResult::new(Map([], capacity=0), Map([], capacity=0), 0) } - + let mut total = 0 let mut pos = 0 while pos <= seq_len - 3 { @@ -184,59 +190,65 @@ pub fn fa_codon_usage(sequence : String) -> FreqAnalysisResult { total = total + 1 pos = pos + 3 } - + let frequencies : Map[String, Double] = Map([], capacity=counts.length()) for key in counts.keys() { let count = counts.get_or_default(key, 0) frequencies.set(key, count.to_double() / total.to_double()) } - + FreqAnalysisResult::new(frequencies, counts, total) } ///| /// Calculate chi-square statistic comparing observed and expected frequencies. -pub fn fa_chi_square_test(observed : FreqAnalysisResult, expected : FreqAnalysisResult) -> Double { +pub fn fa_chi_square_test( + observed : FreqAnalysisResult, + expected : FreqAnalysisResult, +) -> Double { let patterns = observed.fa_get_patterns() let df = patterns.length() - 1 - + if df <= 0 { return 0.0 } - + let total_obs = observed.fa_get_total_count().to_double() let total_exp = expected.fa_get_total_count().to_double() - + let mut chi2 = 0.0 let mut i = 0 while i < patterns.length() { let pattern = patterns[i] let obs_freq = observed.fa_get_frequency(pattern) let exp_freq = expected.fa_get_frequency(pattern) - + let obs_count = obs_freq * total_obs let exp_count = exp_freq * total_exp - + if exp_count > 0.0 { let diff = obs_count - exp_count chi2 = chi2 + diff * diff / exp_count } i = i + 1 } - + chi2 } ///| /// Find the most overrepresented k-mer in a sequence. -pub fn fa_find_overrepresented(sequence : String, k : Int) -> Map[String, Double] { +pub fn fa_find_overrepresented( + sequence : String, + k : Int, +) -> Map[String, Double] { let counts : Map[String, Int] = Map([], capacity=100) let seq_len = sequence.length() - + if seq_len < k { return Map([], capacity=0) } - + let mut total = 0 let mut pos = 0 while pos <= seq_len - k { @@ -246,7 +258,7 @@ pub fn fa_find_overrepresented(sequence : String, k : Int) -> Map[String, Double total = total + 1 pos = pos + 1 } - + // Calculate expected frequency (1/4^k for uniform distribution) let mut expected_freq = 1.0 let mut i = 0 @@ -254,7 +266,7 @@ pub fn fa_find_overrepresented(sequence : String, k : Int) -> Map[String, Double expected_freq = expected_freq / 4.0 i = i + 1 } - + let results : Map[String, Double] = Map([], capacity=counts.length()) for key in counts.keys() { let count = counts.get_or_default(key, 0) @@ -264,7 +276,7 @@ pub fn fa_find_overrepresented(sequence : String, k : Int) -> Map[String, Double results.set(key, ratio) } } - + results } @@ -274,11 +286,11 @@ pub fn fa_find_motif(sequence : String, motif : String) -> Array[Int] { let positions : Array[Int] = Array::new() let motif_len = motif.length() let seq_len = sequence.length() - + if motif_len == 0 || seq_len < motif_len { return positions } - + let mut pos = 0 while pos <= seq_len - motif_len { let substr = substring(sequence, pos, motif_len) @@ -287,7 +299,7 @@ pub fn fa_find_motif(sequence : String, motif : String) -> Array[Int] { } pos = pos + 1 } - + positions } @@ -315,7 +327,7 @@ pub fn fa_sequence_complexity(sequence : String) -> Double { let counts = fa_count_kmers(sequence, 1) let mut entropy = 0.0 let patterns = counts.fa_get_patterns() - + let mut i = 0 while i < patterns.length() { let freq = counts.fa_get_frequency(patterns[i]) diff --git a/src/freq_table.mbt b/src/freq_table.mbt index 5d1cb4ee..cf5e5da5 100644 --- a/src/freq_table.mbt +++ b/src/freq_table.mbt @@ -63,7 +63,7 @@ pub struct FreqTable { pub fn FreqTable::new( in_dict : Map[String, Double], dict_type : FreqTableType, - alphabet : Array[String]? + alphabet : Array[String]?, ) -> FreqTable { let data : Map[String, Double] = Map([], capacity=16) let count : Map[String, Int] = Map([], capacity=16) @@ -74,13 +74,20 @@ pub fn FreqTable::new( for ch in a { alph.push(ch) } - None => for k in in_dict.keys() { - alph.push(k) - } + None => + for k in in_dict.keys() { + alph.push(k) + } } // Sort alphabet for deterministic order. alph.sort_by(fn(a : String, b : String) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) match dict_type { COUNT => { @@ -310,9 +317,7 @@ pub fn freq_table_read_freq(text : String) -> FreqTable { ///| /// Build a `FreqTable` from a count dictionary (Map[String, Int]). -pub fn freq_table_from_counts( - counts : Map[String, Int] -) -> FreqTable { +pub fn freq_table_from_counts(counts : Map[String, Int]) -> FreqTable { let in_dict : Map[String, Double] = Map([], capacity=counts.size()) for k in counts.keys() { in_dict[k] = counts[k].to_double() @@ -322,9 +327,7 @@ pub fn freq_table_from_counts( ///| /// Build a `FreqTable` from a frequency dictionary (Map[String, Double]). -pub fn freq_table_from_freqs( - freqs : Map[String, Double] -) -> FreqTable { +pub fn freq_table_from_freqs(freqs : Map[String, Double]) -> FreqTable { FreqTable::new(freqs, FreqTableType::FREQ, None) } @@ -335,7 +338,7 @@ pub fn freq_table_from_freqs( /// restrict counting). pub fn freq_table_from_sequence( sequence : String, - alphabet : Array[String]? + alphabet : Array[String]?, ) -> FreqTable { let counts : Map[String, Int] = Map([], capacity=16) let restrict : Map[String, Bool] = Map([], capacity=0) @@ -387,7 +390,7 @@ pub fn freq_table_entropy(table : FreqTable) -> Double { /// 0 * log(0/0) is taken as 0). pub fn freq_table_relative_entropy( table : FreqTable, - other : FreqTable + other : FreqTable, ) -> Double { let mut d = 0.0 for k in table.data.keys() { @@ -436,10 +439,7 @@ pub fn freq_table_normalize(table : FreqTable) -> FreqTable { /// distribution M = 0.5 * (P + Q). Returns JS = 0.5 * KL(P||M) + 0.5 * KL(Q||M). /// Both tables should share the same alphabet; letters missing from one are /// treated as 0 in the other. -pub fn freq_table_js_distance( - table : FreqTable, - other : FreqTable -) -> Double { +pub fn freq_table_js_distance(table : FreqTable, other : FreqTable) -> Double { // Build the union of letters. let letters : Map[String, Bool] = Map([], capacity=32) for k in table.data.keys() { diff --git a/src/fssp.mbt b/src/fssp.mbt index 162bb231..03e2c299 100644 --- a/src/fssp.mbt +++ b/src/fssp.mbt @@ -367,14 +367,7 @@ fn fssp_parse_header(lines : Array[String]) -> (FsspHeader, Int) { } ( FsspHeader::new( - pdbid, - pdbid_date, - title, - compound, - source, - author, - seq_length, - n_alignments, + pdbid, pdbid_date, title, compound, source, author, seq_length, n_alignments, threshold, ), idx, @@ -413,14 +406,7 @@ fn fssp_parse_alignment_line(line : String) -> FsspAlignment? { } Some( FsspAlignment::new( - pdbid, - pdbid, - start_pos, - aligned_seq, - zscore, - rmsd, - lali, - pid, + pdbid, pdbid, start_pos, aligned_seq, zscore, rmsd, lali, pid, ), ) } @@ -440,7 +426,8 @@ pub fn fssp_parse(text : String) -> FsspData { continue } // Check for section markers - if starts_with(line, 0, "## ALIGNMENTS") || starts_with(line, 0, "##ALIGNMENTS") { + if starts_with(line, 0, "## ALIGNMENTS") || + starts_with(line, 0, "##ALIGNMENTS") { in_alignment_section = true idx = idx + 1 continue @@ -475,7 +462,8 @@ pub fn fssp_parse(text : String) -> FsspData { pub fn fssp_sample_text() -> String { let mut s = "" s = s + "HEADER \\_1dfa_A 1 30-jul-1998\n" - s = s + "TITLE crystal structure of human type i 17beta-hydroxysteroid dehydrogenase\n" + s = s + + "TITLE crystal structure of human type i 17beta-hydroxysteroid dehydrogenase\n" s = s + "COMPND 17beta-hsd\n" s = s + "SOURCE human\n" s = s + "AUTHOR holm\n" diff --git a/src/ga.mbt b/src/ga.mbt index a3a2e017..2181434c 100644 --- a/src/ga.mbt +++ b/src/ga.mbt @@ -121,7 +121,11 @@ pub fn GAPopulation::new(individuals~ : Array[GAIndividual]) -> GAPopulation { } sum = sum + ind.fitness } - let avg = if individuals.length() > 0 { sum / individuals.length().to_double() } else { 0.0 } + let avg = if individuals.length() > 0 { + sum / individuals.length().to_double() + } else { + 0.0 + } GAPopulation::{ individuals, generation: 0, @@ -196,8 +200,8 @@ pub fn ga_random_sequence(length : Int, alphabet : String) -> String { let mut i = 0 while i < length { let idx = (ga_pseudo_random() * n.to_double()).to_int() - let safe_idx = if idx >= n { n - 1 } else { if idx < 0 { 0 } else { idx } } - result = result + alphabet[safe_idx : safe_idx + 1].to_string() + let safe_idx = if idx >= n { n - 1 } else if idx < 0 { 0 } else { idx } + result = result + alphabet[safe_idx:safe_idx + 1].to_string() i = i + 1 } result @@ -249,14 +253,18 @@ pub fn ga_rand_int(max : Int) -> Int { pub fn ga_fitness_match(target : String) -> (GAIndividual) -> Double { fn(individual : GAIndividual) -> Double { let seq = individual.sequence - let n = if seq.length() < target.length() { seq.length() } else { target.length() } + let n = if seq.length() < target.length() { + seq.length() + } else { + target.length() + } if n == 0 { return 0.0 } let mut matches = 0 let mut i = 0 while i < n { - if seq[i : i + 1].to_string() == target[i : i + 1].to_string() { + if seq[i:i + 1].to_string() == target[i:i + 1].to_string() { matches = matches + 1 } i = i + 1 @@ -278,14 +286,18 @@ pub fn ga_fitness_gc_content(target_gc : Double) -> (GAIndividual) -> Double { let mut gc_count = 0 let mut i = 0 while i < n { - let base = seq[i : i + 1].to_string() + let base = seq[i:i + 1].to_string() if base == "G" || base == "C" { gc_count = gc_count + 1 } i = i + 1 } let gc_content = gc_count.to_double() / n.to_double() - let diff = if gc_content - target_gc < 0.0 { target_gc - gc_content } else { gc_content - target_gc } + let diff = if gc_content - target_gc < 0.0 { + target_gc - gc_content + } else { + gc_content - target_gc + } 1.0 - diff } } @@ -303,12 +315,14 @@ pub fn ga_evaluate_population( let result : Array[GAIndividual] = Array::new() for ind in individuals { let fit = fitness_fn(ind) - result.push(GAIndividual::new( - sequence=ind.sequence, - fitness=fit, - generation=ind.generation, - id=ind.id, - )) + result.push( + GAIndividual::new( + sequence=ind.sequence, + fitness=fit, + generation=ind.generation, + id=ind.id, + ), + ) } result } @@ -406,20 +420,38 @@ pub fn ga_single_point_crossover( ) -> (GAIndividual, GAIndividual) { let seq1 = parent1.sequence let seq2 = parent2.sequence - let n = if seq1.length() < seq2.length() { seq1.length() } else { seq2.length() } + let n = if seq1.length() < seq2.length() { + seq1.length() + } else { + seq2.length() + } if n < 2 { return (parent1, parent2) } - let actual_point = if point > 0 && point < n { point } else { 1 + ga_rand_int(n - 1) } + let actual_point = if point > 0 && point < n { + point + } else { + 1 + ga_rand_int(n - 1) + } - let child1_seq = (seq1[0 : actual_point] + seq2[actual_point : n]).to_string() - let child2_seq = (seq2[0 : actual_point] + seq1[actual_point : n]).to_string() + let child1_seq = (seq1[0:actual_point] + seq2[actual_point:n]).to_string() + let child2_seq = (seq2[0:actual_point] + seq1[actual_point:n]).to_string() ( - GAIndividual::new(sequence=child1_seq, fitness=0.0, generation=parent1.generation + 1, id=0), - GAIndividual::new(sequence=child2_seq, fitness=0.0, generation=parent1.generation + 1, id=0), + GAIndividual::new( + sequence=child1_seq, + fitness=0.0, + generation=parent1.generation + 1, + id=0, + ), + GAIndividual::new( + sequence=child2_seq, + fitness=0.0, + generation=parent1.generation + 1, + id=0, + ), ) } @@ -431,7 +463,11 @@ pub fn ga_two_point_crossover( ) -> (GAIndividual, GAIndividual) { let seq1 = parent1.sequence let seq2 = parent2.sequence - let n = if seq1.length() < seq2.length() { seq1.length() } else { seq2.length() } + let n = if seq1.length() < seq2.length() { + seq1.length() + } else { + seq2.length() + } if n < 3 { return ga_single_point_crossover(parent1, parent2) @@ -440,12 +476,22 @@ pub fn ga_two_point_crossover( let p1 = ga_rand_int(n - 1) + 1 let p2 = p1 + 1 + ga_rand_int(n - p1 - 1) - let child1_seq = (seq1[0 : p1] + seq2[p1 : p2] + seq1[p2 : n]).to_string() - let child2_seq = (seq2[0 : p1] + seq1[p1 : p2] + seq2[p2 : n]).to_string() + let child1_seq = (seq1[0:p1] + seq2[p1:p2] + seq1[p2:n]).to_string() + let child2_seq = (seq2[0:p1] + seq1[p1:p2] + seq2[p2:n]).to_string() ( - GAIndividual::new(sequence=child1_seq, fitness=0.0, generation=parent1.generation + 1, id=0), - GAIndividual::new(sequence=child2_seq, fitness=0.0, generation=parent1.generation + 1, id=0), + GAIndividual::new( + sequence=child1_seq, + fitness=0.0, + generation=parent1.generation + 1, + id=0, + ), + GAIndividual::new( + sequence=child2_seq, + fitness=0.0, + generation=parent1.generation + 1, + id=0, + ), ) } @@ -458,7 +504,11 @@ pub fn ga_uniform_crossover( ) -> (GAIndividual, GAIndividual) { let seq1 = parent1.sequence let seq2 = parent2.sequence - let n = if seq1.length() < seq2.length() { seq1.length() } else { seq2.length() } + let n = if seq1.length() < seq2.length() { + seq1.length() + } else { + seq2.length() + } let mut child1_seq = "" let mut child2_seq = "" @@ -466,18 +516,28 @@ pub fn ga_uniform_crossover( let mut i = 0 while i < n { if ga_pseudo_random() < swap_prob { - child1_seq = child1_seq + seq2[i : i + 1].to_string() - child2_seq = child2_seq + seq1[i : i + 1].to_string() + child1_seq = child1_seq + seq2[i:i + 1].to_string() + child2_seq = child2_seq + seq1[i:i + 1].to_string() } else { - child1_seq = child1_seq + seq1[i : i + 1].to_string() - child2_seq = child2_seq + seq2[i : i + 1].to_string() + child1_seq = child1_seq + seq1[i:i + 1].to_string() + child2_seq = child2_seq + seq2[i:i + 1].to_string() } i = i + 1 } ( - GAIndividual::new(sequence=child1_seq, fitness=0.0, generation=parent1.generation + 1, id=0), - GAIndividual::new(sequence=child2_seq, fitness=0.0, generation=parent1.generation + 1, id=0), + GAIndividual::new( + sequence=child1_seq, + fitness=0.0, + generation=parent1.generation + 1, + id=0, + ), + GAIndividual::new( + sequence=child2_seq, + fitness=0.0, + generation=parent1.generation + 1, + id=0, + ), ) } @@ -503,15 +563,20 @@ pub fn ga_point_mutate( while i < n { if ga_pseudo_random() < mutation_rate { let alphabet_idx = ga_rand_int(alphabet.length()) - let new_base = alphabet[alphabet_idx : alphabet_idx + 1].to_string() + let new_base = alphabet[alphabet_idx:alphabet_idx + 1].to_string() new_seq = new_seq + new_base } else { - new_seq = new_seq + seq[i : i + 1].to_string() + new_seq = new_seq + seq[i:i + 1].to_string() } i = i + 1 } - GAIndividual::new(sequence=new_seq, fitness=individual.fitness, generation=individual.generation, id=individual.id) + GAIndividual::new( + sequence=new_seq, + fitness=individual.fitness, + generation=individual.generation, + id=individual.id, + ) } ///| @@ -528,11 +593,16 @@ pub fn ga_insertion_mutate( let pos = ga_rand_int(n + 1) let new_base_idx = ga_rand_int(alphabet.length()) - let new_base = alphabet[new_base_idx : new_base_idx + 1].to_string() + let new_base = alphabet[new_base_idx:new_base_idx + 1].to_string() - let new_seq = (seq[0 : pos] + new_base + seq[pos : n]).to_string() + let new_seq = (seq[0:pos] + new_base + seq[pos:n]).to_string() - GAIndividual::new(sequence=new_seq, fitness=individual.fitness, generation=individual.generation, id=individual.id) + GAIndividual::new( + sequence=new_seq, + fitness=individual.fitness, + generation=individual.generation, + id=individual.id, + ) } ///| @@ -545,9 +615,14 @@ pub fn ga_deletion_mutate(individual : GAIndividual) -> GAIndividual { } let pos = ga_rand_int(n) - let new_seq = (seq[0 : pos] + seq[pos + 1 : n]).to_string() + let new_seq = (seq[0:pos] + seq[pos + 1:n]).to_string() - GAIndividual::new(sequence=new_seq, fitness=individual.fitness, generation=individual.generation, id=individual.id) + GAIndividual::new( + sequence=new_seq, + fitness=individual.fitness, + generation=individual.generation, + id=individual.id, + ) } // ============================================================================ @@ -573,7 +648,7 @@ pub fn ga_evolve( // Evaluate initial fitness individuals = ga_evaluate_population(individuals, fitness_fn) - let mut pop = GAPopulation::new(individuals=individuals) + let mut pop = GAPopulation::new(individuals~) let best_fitness_history : Array[Double] = [pop.best_fitness] let avg_fitness_history : Array[Double] = [pop.avg_fitness] let mut best_individual = ga_find_best(pop) @@ -592,7 +667,10 @@ pub fn ga_evolve( // Fill rest of offspring while offspring.length() < config.population_size { - let parent1 = ga_tournament_select(pop.individuals, config.tournament_size) + let parent1 = ga_tournament_select( + pop.individuals, + config.tournament_size, + ) let parent2 = ga_roulette_select(pop.individuals) let (child1, child2) = if ga_pseudo_random() < config.crossover_rate { @@ -603,11 +681,19 @@ pub fn ga_evolve( // Add offspring with mutation if offspring.length() < config.population_size { - let mutated1 = ga_point_mutate(child1, config.mutation_rate, config.alphabet) + let mutated1 = ga_point_mutate( + child1, + config.mutation_rate, + config.alphabet, + ) offspring.push(mutated1) } if offspring.length() < config.population_size { - let mutated2 = ga_point_mutate(child2, config.mutation_rate, config.alphabet) + let mutated2 = ga_point_mutate( + child2, + config.mutation_rate, + config.alphabet, + ) offspring.push(mutated2) } } @@ -631,18 +717,19 @@ pub fn ga_evolve( let prev_best = best_fitness_history[best_fitness_history.length() - 2] let curr_best = best_fitness_history[best_fitness_history.length() - 1] let improvement = curr_best - prev_best - if improvement.abs() < config.convergence_threshold || curr_best >= config.target_fitness { + if improvement.abs() < config.convergence_threshold || + curr_best >= config.target_fitness { converged = true } } } GAResult::new( - best_individual=best_individual, - best_fitness_history=best_fitness_history, - avg_fitness_history=avg_fitness_history, + best_individual~, + best_fitness_history~, + avg_fitness_history~, generation_reached=generation, - converged=converged, + converged~, ) } @@ -672,4 +759,4 @@ fn ga_sort_indices(individuals : Array[GAIndividual]) -> Array[Int] { j = j + 1 } arr -} \ No newline at end of file +} diff --git a/src/gage.mbt b/src/gage.mbt index c425c0dd..a301e464 100644 --- a/src/gage.mbt +++ b/src/gage.mbt @@ -51,7 +51,11 @@ pub struct GageGeneSet { ///| /// Create a GageGeneSet. -pub fn GageGeneSet::new(id : String, name : String, gene_ids : Array[String]) -> GageGeneSet { +pub fn GageGeneSet::new( + id : String, + name : String, + gene_ids : Array[String], +) -> GageGeneSet { GageGeneSet::{ id, name, gene_ids } } @@ -180,7 +184,13 @@ fn gage_pvalue_from_z(z : Double) -> Double { // p = 2 * (1 - Phi(|z|)) = erfc(|z| / sqrt(2)) let x = abs_z / 1.4142135623730951 let p = erfc_approx(x) - if p > 1.0 { 1.0 } else if p < 0.0 { 0.0 } else { p } + if p > 1.0 { + 1.0 + } else if p < 0.0 { + 0.0 + } else { + p + } } ///| @@ -195,7 +205,12 @@ fn erfc_approx(x : Double) -> Double { let t3 = t2 * t let t4 = t3 * t let t5 = t4 * t - let poly = 1.0 + 0.254829592 * t + -0.284496736 * t2 + 1.421413741 * t3 + -1.453152027 * t4 + 1.061405429 * t5 + let poly = 1.0 + + 0.254829592 * t + + -0.284496736 * t2 + + 1.421413741 * t3 + + -1.453152027 * t4 + + 1.061405429 * t5 @math.exp(-x * x) * poly } @@ -297,7 +312,10 @@ pub fn GageResults::get_downregulated(self : GageResults) -> Array[GageResult] { ///| /// Get top N gene sets by adjusted p-value. -pub fn GageResults::get_top_sets(self : GageResults, n : Int) -> Array[GageResult] { +pub fn GageResults::get_top_sets( + self : GageResults, + n : Int, +) -> Array[GageResult] { let sorted = self.results.copy() let len = sorted.length() let mut i = 0 @@ -328,7 +346,12 @@ pub fn GageResults::get_top_sets(self : GageResults, n : Int) -> Array[GageResul pub fn GageResults::summary(self : GageResults) -> String { let mut s = "=== GAGE Analysis Summary ===\n".to_string() s = s + "Gene sets tested: " + self.n_gene_sets.to_string() + "\n" - s = s + "Significant (FDR < " + self.fdr_threshold.to_string() + "): " + self.n_significant.to_string() + "\n" + s = s + + "Significant (FDR < " + + self.fdr_threshold.to_string() + + "): " + + self.n_significant.to_string() + + "\n" s = s + "Paired test: " + self.paired.to_string() + "\n" s } diff --git a/src/gck_io.mbt b/src/gck_io.mbt index 45df3880..2f95391f 100644 --- a/src/gck_io.mbt +++ b/src/gck_io.mbt @@ -325,12 +325,7 @@ pub fn gck_from_bytes(data : Array[Int]) -> GckFile { offset = offset + 8 } file.features.push( - GckFeature::new( - name=name, - type_=type_, - direction=direction, - segments=segs, - ), + GckFeature::new(name~, type_~, direction~, segments=segs), ) } // Parse sequence @@ -439,7 +434,7 @@ pub fn gck_to_seqrecord(file : GckFile) -> SeqRecord { let id = "gck" let topo = if file.is_circular { " circular" } else { " linear" } let desc = file.seq_type.to_string() + topo - SeqRecord::new(Seq::new(file.sequence), id=id, name=id, description=desc) + SeqRecord::new(Seq::new(file.sequence), id~, name=id, description=desc) } ///| @@ -482,7 +477,9 @@ pub fn gck_summary(file : GckFile) -> String { sb.write_string(" Type: " + file.seq_type.to_string() + "\n") let topo = if file.is_circular { "circular" } else { "linear" } sb.write_string(" Topology: " + topo + "\n") - sb.write_string(" Sequence Length: " + gck_seq_length(file).to_string() + " bp\n") + sb.write_string( + " Sequence Length: " + gck_seq_length(file).to_string() + " bp\n", + ) sb.write_string(" Features: " + file.features.length().to_string() + "\n") if file.features.length() > 0 { sb.write_string(" Feature List:\n") @@ -495,8 +492,15 @@ pub fn gck_summary(file : GckFile) -> String { "none" } sb.write_string( - " " + f.name + " (" + f.type_ + ", " + dir_str + ") - " + - f.segments.length().to_string() + " segment(s)\n", + " " + + f.name + + " (" + + f.type_ + + ", " + + dir_str + + ") - " + + f.segments.length().to_string() + + " segment(s)\n", ) } } @@ -512,28 +516,13 @@ pub fn gck_sample() -> GckFile { file.is_circular = true file.sequence = "ATGGCTAGCAATGGGTCGCGATAGCGATAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAA" file.features.push( - GckFeature::new( - name="AmpR", - type_="CDS", - direction=1, - segments=[(0, 19)], - ), + GckFeature::new(name="AmpR", type_="CDS", direction=1, segments=[(0, 19)]), ) file.features.push( - GckFeature::new( - name="lacZ", - type_="CDS", - direction=1, - segments=[(30, 49)], - ), + GckFeature::new(name="lacZ", type_="CDS", direction=1, segments=[(30, 49)]), ) file.features.push( - GckFeature::new( - name="MCS", - type_="misc", - direction=0, - segments=[(50, 63)], - ), + GckFeature::new(name="MCS", type_="misc", direction=0, segments=[(50, 63)]), ) file } diff --git a/src/gcrma.mbt b/src/gcrma.mbt index bab62e40..8fc01731 100644 --- a/src/gcrma.mbt +++ b/src/gcrma.mbt @@ -22,8 +22,8 @@ pub struct GCRMAConfig { ///| /// Create a new GCRMAConfig with default settings. pub fn GCRMAConfig::new( - background_method~ : String = "IdealMM", - normalize~ : Bool = true, + background_method? : String = "IdealMM", + normalize? : Bool = true, ) -> GCRMAConfig { GCRMAConfig::{ background_method, @@ -53,10 +53,7 @@ pub struct ProbeInfo { ///| /// Create a new ProbeInfo from a probe ID and sequence. /// GC count and affinity are computed automatically. -pub fn ProbeInfo::new( - probe_id : String, - sequence : String, -) -> ProbeInfo { +pub fn ProbeInfo::new(probe_id : String, sequence : String) -> ProbeInfo { let gc_count = oligo_gc_count(sequence) let affinity = estimate_affinity(sequence) ProbeInfo::{ probe_id, gc_count, sequence, affinity } @@ -85,8 +82,10 @@ pub fn oligo_gc_count(sequence : String) -> Int { let mut i = 0 while i < n { let c = sequence.unsafe_get(i).to_int() - if c == 'G'.to_int() || c == 'C'.to_int() || - c == 'g'.to_int() || c == 'c'.to_int() { + if c == 'G'.to_int() || + c == 'C'.to_int() || + c == 'g'.to_int() || + c == 'c'.to_int() { count = count + 1 } i = i + 1 @@ -125,14 +124,30 @@ pub fn estimate_affinity(sequence : String) -> Double { while i < n - 1 { let c1 = sequence.unsafe_get(i).to_int() let c2 = sequence.unsafe_get(i + 1).to_int() - let is_gc = (c1 == 'G'.to_int() || c1 == 'g'.to_int() || - c1 == 'C'.to_int() || c1 == 'c'.to_int()) && - (c2 == 'G'.to_int() || c2 == 'g'.to_int() || - c2 == 'C'.to_int() || c2 == 'c'.to_int()) - let is_at = (c1 == 'A'.to_int() || c1 == 'a'.to_int() || - c1 == 'T'.to_int() || c1 == 't'.to_int()) && - (c2 == 'A'.to_int() || c2 == 'a'.to_int() || - c2 == 'T'.to_int() || c2 == 't'.to_int()) + let is_gc = ( + c1 == 'G'.to_int() || + c1 == 'g'.to_int() || + c1 == 'C'.to_int() || + c1 == 'c'.to_int() + ) && + ( + c2 == 'G'.to_int() || + c2 == 'g'.to_int() || + c2 == 'C'.to_int() || + c2 == 'c'.to_int() + ) + let is_at = ( + c1 == 'A'.to_int() || + c1 == 'a'.to_int() || + c1 == 'T'.to_int() || + c1 == 't'.to_int() + ) && + ( + c2 == 'A'.to_int() || + c2 == 'a'.to_int() || + c2 == 'T'.to_int() || + c2 == 't'.to_int() + ) if is_gc { gc_energy = gc_energy + 3.0 } else if is_at { @@ -183,6 +198,7 @@ pub fn compute_gc_lookup_table( // Internal statistical helpers // --------------------------------------------------------------------------- +///| fn _median(arr : Array[Double]) -> Double { let n = arr.length() if n == 0 { @@ -197,6 +213,7 @@ fn _median(arr : Array[Double]) -> Double { } } +///| fn _mean(arr : Array[Double]) -> Double { let n = arr.length() if n == 0 { @@ -211,9 +228,8 @@ fn _mean(arr : Array[Double]) -> Double { sum / n.to_double() } -fn _quantile_normalize( - data : Array[Array[Double]], -) -> Array[Array[Double]] { +///| +fn _quantile_normalize(data : Array[Array[Double]]) -> Array[Array[Double]] { let n_rows = data.length() if n_rows == 0 { return data @@ -361,18 +377,10 @@ pub fn gcrma_gc_correction( let result : Array[Double] = Array::new() let mut i = 0 while i < n { - let gc = if i < gc_counts.length() { - gc_counts[i] - } else { - 0 - } + let gc = if i < gc_counts.length() { gc_counts[i] } else { 0 } let pm_val = pm_values[i] let affinity = gc_lookup.get_or_default(gc, 1.0) - let corrected = if affinity > 0.0 { - pm_val / affinity - } else { - pm_val - } + let corrected = if affinity > 0.0 { pm_val / affinity } else { pm_val } result.push(corrected) i = i + 1 } @@ -408,7 +416,10 @@ pub fn gcrma_summarize( expression : Array[Array[Double]], probe_sets : Map[String, Array[Int]], ) -> Map[String, Array[Double]] { - let result : Map[String, Array[Double]] = Map([], capacity=probe_sets.keys().length()) + let result : Map[String, Array[Double]] = Map( + [], + capacity=probe_sets.keys().length(), + ) for probe_set_id in probe_sets.keys() { let indices = probe_sets.get_or_default(probe_set_id, []) let n_samples = if expression.length() > 0 { @@ -444,9 +455,7 @@ pub fn gcrma_summarize( ///| /// Apply median polish to a matrix (rows = probes, cols = samples). /// Returns the column effects (sample-level expression values). -fn _median_polish( - matrix : Array[Array[Double]], -) -> Array[Double] { +fn _median_polish(matrix : Array[Array[Double]]) -> Array[Double] { let n_rows = matrix.length() if n_rows == 0 { return [] @@ -579,7 +588,7 @@ pub fn gcrma_process_with_config( if n_probes == 0 { return GCRMAResult::{ expression_matrix: [], - probe_info: probe_info, + probe_info, gc_correction_params: Map([], capacity=0), } } @@ -590,11 +599,11 @@ pub fn gcrma_process_with_config( while i < n_probes { let gc = if i < probe_info.length() { probe_info[i].gc_count.to_double() / - (if probe_info[i].sequence.length() > 0 { - probe_info[i].sequence.length().to_double() - } else { - 1.0 - }) + (if probe_info[i].sequence.length() > 0 { + probe_info[i].sequence.length().to_double() + } else { + 1.0 + }) } else { 0.0 } @@ -626,7 +635,7 @@ pub fn gcrma_process_with_config( params.set("gc_correction_applied", 1.0) GCRMAResult::{ expression_matrix: normalized, - probe_info: probe_info, + probe_info, gc_correction_params: params, } } @@ -645,11 +654,7 @@ fn _gc_correction_logged( let mut i = 0 while i < n_probes { let row = log_intensities[i] - let gc = if i < probe_info.length() { - probe_info[i].gc_count - } else { - 0 - } + let gc = if i < probe_info.length() { probe_info[i].gc_count } else { 0 } let seq_len = if i < probe_info.length() { probe_info[i].sequence.length() } else { @@ -671,4 +676,4 @@ fn _gc_correction_logged( i = i + 1 } result -} \ No newline at end of file +} diff --git a/src/genbank_io.mbt b/src/genbank_io.mbt index 06fc6768..817868a5 100644 --- a/src/genbank_io.mbt +++ b/src/genbank_io.mbt @@ -226,7 +226,11 @@ pub fn write_genbank(records : Array[SeqRecord]) -> String { // Fields (fixed positions): 0-5 LOCUS, 6-11 spaces, 12-27 locus name, 28-39 length+bp, // 40-47 mol_type, 48-54 topology, 55-57 division, 58- date let seq_len = rec.seq.length() - let locus_name = if rec.name.length() > 16 { rec.name[0:16].to_owned() } else { rec.name } + let locus_name = if rec.name.length() > 16 { + rec.name[0:16].to_owned() + } else { + rec.name + } buf.write_string("LOCUS ") buf.write_string(locus_name) // Pad to position 28 (12 + 16 = 28) @@ -315,7 +319,8 @@ fn build_wrapped(text : String, indent : Int, width : Int) -> String { buf.write_string(" ") cur_indent = 12 // Skip space if we broke at one - if break_at < total && text.unsafe_get(break_at) == ' '.to_int().to_uint16() { + if break_at < total && + text.unsafe_get(break_at) == ' '.to_int().to_uint16() { pos = break_at + 1 } else { pos = break_at diff --git a/src/gene_pop.mbt b/src/gene_pop.mbt index 80f83fe3..defe967d 100644 --- a/src/gene_pop.mbt +++ b/src/gene_pop.mbt @@ -45,7 +45,10 @@ pub fn GenePopGenotype::new(allele1 : Int, allele2 : Int?) -> GenePopGenotype { ///| /// A diploid genotype (both alleles present). -pub fn GenePopGenotype::diploid(allele1 : Int, allele2 : Int) -> GenePopGenotype { +pub fn GenePopGenotype::diploid( + allele1 : Int, + allele2 : Int, +) -> GenePopGenotype { let missing = allele1 == 0 && allele2 == 0 GenePopGenotype::{ allele1, allele2: Some(allele2), is_missing: missing } } @@ -104,12 +107,7 @@ pub fn GenePopRecord::new( populations : Array[GenePopPopulation], locus_digit_size : Int, ) -> GenePopRecord { - GenePopRecord::{ - title, - loci_names, - populations, - locus_digit_size, - } + GenePopRecord::{ title, loci_names, populations, locus_digit_size } } // ============================================================================ @@ -145,16 +143,8 @@ fn gp_iequals(a : String, b : String) -> Bool { while i < na { let ca = a.unsafe_get(i).to_int() let cb = b.unsafe_get(i).to_int() - let la = if ca >= 'A'.to_int() && ca <= 'Z'.to_int() { - ca + 32 - } else { - ca - } - let lb = if cb >= 'A'.to_int() && cb <= 'Z'.to_int() { - cb + 32 - } else { - cb - } + let la = if ca >= 'A'.to_int() && ca <= 'Z'.to_int() { ca + 32 } else { ca } + let lb = if cb >= 'A'.to_int() && cb <= 'Z'.to_int() { cb + 32 } else { cb } if la != lb { return false } @@ -364,7 +354,10 @@ pub fn parse_genepop(content : String) -> GenePopRecord { if cur_individuals.length() > 0 { pop_count = pop_count + 1 populations.push( - GenePopPopulation::new("Pop_" + pop_count.to_string(), cur_individuals), + GenePopPopulation::new( + "Pop_" + pop_count.to_string(), + cur_individuals, + ), ) cur_individuals = [] } else if populations.length() == 0 { @@ -442,10 +435,7 @@ fn gp_detect_digit_size_from_ind(ind : GenePopIndividual) -> Int { max_allele = g.allele1 } match g.allele2 { - Some(a2) => - if a2 > max_allele { - max_allele = a2 - } + Some(a2) => if a2 > max_allele { max_allele = a2 } None => () } k = k + 1 @@ -462,7 +452,10 @@ fn gp_parse_individual(line : String) -> GenePopIndividual { // Split on the first comma to separate name from genotype data. let comma_pos = gp_find_char(line, ',') let (name_str, geno_str) = if comma_pos >= 0 { - (gp_trim(line[0:comma_pos].to_string()), gp_trim(line[comma_pos + 1:line.length()].to_string())) + ( + gp_trim(line[0:comma_pos].to_string()), + gp_trim(line[comma_pos + 1:line.length()].to_string()), + ) } else { // No comma: treat the whole line as genotype data with empty name. ("", line) @@ -699,9 +692,7 @@ pub fn genepop_observed_heterozygosity( if !g.is_missing { total = total + 1 match g.allele2 { - Some(a2) => if a2 != g.allele1 { - het = het + 1 - } + Some(a2) => if a2 != g.allele1 { het = het + 1 } None => () } } @@ -738,10 +729,16 @@ pub fn genepop_summary(record : GenePopRecord) -> String { let buf = StringBuilder::new() buf.write_string("GenePop Record Summary\n") buf.write_string(" Title: " + record.title + "\n") - buf.write_string(" Populations: " + record.populations.length().to_string() + "\n") + buf.write_string( + " Populations: " + record.populations.length().to_string() + "\n", + ) buf.write_string(" Loci: " + record.loci_names.length().to_string() + "\n") - buf.write_string(" Individuals: " + genepop_total_individuals(record).to_string() + "\n") - buf.write_string(" Digit size: " + record.locus_digit_size.to_string() + "\n") + buf.write_string( + " Individuals: " + genepop_total_individuals(record).to_string() + "\n", + ) + buf.write_string( + " Digit size: " + record.locus_digit_size.to_string() + "\n", + ) let mut i = 0 while i < record.populations.length() { let pop = record.populations[i] @@ -766,12 +763,12 @@ pub fn genepop_summary(record : GenePopRecord) -> String { /// and 2-digit allele encoding, for tests and demos. pub fn genepop_sample() -> String { "Sample GenePop File\n" + - "Pop\n" + - "ind1, 0102 0304 0101\n" + - "ind2, 0202 0303 0102\n" + - "ind3, 0101 0404 0202\n" + - "Pop\n" + - "ind4, 0102 0304 0101\n" + - "ind5, 0202 0303 0102\n" + - "ind6, 0101 0000 0202\n" + "Pop\n" + + "ind1, 0102 0304 0101\n" + + "ind2, 0202 0303 0102\n" + + "ind3, 0101 0404 0202\n" + + "Pop\n" + + "ind4, 0102 0304 0101\n" + + "ind5, 0202 0303 0102\n" + + "ind6, 0101 0000 0202\n" } diff --git a/src/genefilter.mbt b/src/genefilter.mbt index 07c316e7..38b64205 100644 --- a/src/genefilter.mbt +++ b/src/genefilter.mbt @@ -25,13 +25,13 @@ fn gf_sqrt(x : Double) -> Double { fn gf_sort_double(arr : Array[Double]) -> Array[Double] { let n = arr.length() let result = Array::make(n, 0.0) - + let mut i = 0 while i < n { result[i] = arr[i] i = i + 1 } - + i = 0 while i < n { let mut j = i + 1 @@ -45,7 +45,7 @@ fn gf_sort_double(arr : Array[Double]) -> Array[Double] { } i = i + 1 } - + result } @@ -57,7 +57,11 @@ pub struct FilterResult { } ///| -pub fn FilterResult::new(passing_genes : Array[String], statistics : Array[Double], p_values : Array[Double]) -> FilterResult { +pub fn FilterResult::new( + passing_genes : Array[String], + statistics : Array[Double], + p_values : Array[Double], +) -> FilterResult { FilterResult::{ passing_genes, statistics, p_values } } @@ -69,23 +73,31 @@ pub struct GeneExpression { } ///| -pub fn GeneExpression::new(gene_ids : Array[String], expression : Array[Array[Double]], groups : Array[String]) -> GeneExpression { +pub fn GeneExpression::new( + gene_ids : Array[String], + expression : Array[Array[Double]], + groups : Array[String], +) -> GeneExpression { GeneExpression::{ gene_ids, expression, groups } } ///| -pub fn row_ttest(expression : GeneExpression, group1 : String, group2 : String) -> FilterResult { +pub fn row_ttest( + expression : GeneExpression, + group1 : String, + group2 : String, +) -> FilterResult { let passing_genes : Array[String] = Array::new() let statistics : Array[Double] = Array::new() let p_values : Array[Double] = Array::new() - + let mut i = 0 while i < expression.gene_ids.length() { let expr = expression.expression[i] - + let group1_vals : Array[Double] = Array::new() let group2_vals : Array[Double] = Array::new() - + let mut j = 0 while j < expression.groups.length() { if expression.groups[j] == group1 { @@ -95,45 +107,49 @@ pub fn row_ttest(expression : GeneExpression, group1 : String, group2 : String) } j = j + 1 } - + if group1_vals.length() >= 2 && group2_vals.length() >= 2 { let n1 = group1_vals.length().to_double() let n2 = group2_vals.length().to_double() - + let mean1 = calc_mean(group1_vals) let mean2 = calc_mean(group2_vals) - + let var1 = calc_variance(group1_vals) let var2 = calc_variance(group2_vals) - + let se = gf_sqrt(var1 / n1 + var2 / n2) - + let t_stat = if se == 0.0 { 0.0 } else { (mean1 - mean2) / se } - + statistics.push(t_stat) p_values.push(0.0) passing_genes.push(expression.gene_ids[i]) } - + i = i + 1 } - + FilterResult::new(passing_genes, statistics, p_values) } ///| -pub fn row_wilcoxon(expression : GeneExpression, group1 : String, group2 : String) -> FilterResult { +pub fn row_wilcoxon( + expression : GeneExpression, + group1 : String, + group2 : String, +) -> FilterResult { let passing_genes : Array[String] = Array::new() let statistics : Array[Double] = Array::new() let p_values : Array[Double] = Array::new() - + let mut i = 0 while i < expression.gene_ids.length() { let expr = expression.expression[i] - + let group1_vals : Array[Double] = Array::new() let group2_vals : Array[Double] = Array::new() - + let mut j = 0 while j < expression.groups.length() { if expression.groups[j] == group1 { @@ -143,18 +159,18 @@ pub fn row_wilcoxon(expression : GeneExpression, group1 : String, group2 : Strin } j = j + 1 } - + if group1_vals.length() >= 2 && group2_vals.length() >= 2 { let w_stat = wilcoxon_statistic(group1_vals, group2_vals) - + statistics.push(w_stat) p_values.push(0.0) passing_genes.push(expression.gene_ids[i]) } - + i = i + 1 } - + FilterResult::new(passing_genes, statistics, p_values) } @@ -162,13 +178,13 @@ pub fn row_wilcoxon(expression : GeneExpression, group1 : String, group2 : Strin fn wilcoxon_statistic(group1 : Array[Double], group2 : Array[Double]) -> Double { let n1 = group1.length() let n2 = group2.length() - + let mut rank_sum = 0.0 let mut i = 0 while i < n1 { let x = group1[i] let mut rank = 1.0 - + let mut j = 0 while j < n1 { if j != i && group1[j] < x { @@ -178,7 +194,7 @@ fn wilcoxon_statistic(group1 : Array[Double], group2 : Array[Double]) -> Double } j = j + 1 } - + j = 0 while j < n2 { if group2[j] < x { @@ -188,59 +204,69 @@ fn wilcoxon_statistic(group1 : Array[Double], group2 : Array[Double]) -> Double } j = j + 1 } - + rank_sum = rank_sum + rank i = i + 1 } - + rank_sum } ///| -pub fn variance_filter(expression : GeneExpression, threshold : Double) -> Array[String] { +pub fn variance_filter( + expression : GeneExpression, + threshold : Double, +) -> Array[String] { let passing_genes : Array[String] = Array::new() - + let mut i = 0 while i < expression.gene_ids.length() { let expr = expression.expression[i] let var = calc_variance(expr) - + if var >= threshold { passing_genes.push(expression.gene_ids[i]) } - + i = i + 1 } - + passing_genes } ///| -pub fn cv_filter(expression : GeneExpression, threshold : Double) -> Array[String] { +pub fn cv_filter( + expression : GeneExpression, + threshold : Double, +) -> Array[String] { let passing_genes : Array[String] = Array::new() - + let mut i = 0 while i < expression.gene_ids.length() { let expr = expression.expression[i] let m = calc_mean(expr) let cv_val = if m == 0.0 { 0.0 } else { gf_sqrt(calc_variance(expr)) / m } - + if cv_val >= threshold { passing_genes.push(expression.gene_ids[i]) } - + i = i + 1 } - + passing_genes } ///| -pub fn row_quantile_filter(expression : GeneExpression, q_low : Double, q_high : Double) -> Array[String] { +pub fn row_quantile_filter( + expression : GeneExpression, + q_low : Double, + q_high : Double, +) -> Array[String] { let passing_genes : Array[String] = Array::new() - + let all_vals : Array[Double] = Array::new() - + let mut i = 0 while i < expression.expression.length() { let mut j = 0 @@ -250,28 +276,36 @@ pub fn row_quantile_filter(expression : GeneExpression, q_low : Double, q_high : } i = i + 1 } - + let sorted_vals = gf_sort_double(all_vals) - + let low_idx = (all_vals.length().to_double() * q_low).to_int() let high_idx = (all_vals.length().to_double() * q_high).to_int() - - let low_threshold = if low_idx < sorted_vals.length() { sorted_vals[low_idx] } else { 0.0 } - let high_threshold = if high_idx < sorted_vals.length() { sorted_vals[high_idx] } else { 0.0 } - + + let low_threshold = if low_idx < sorted_vals.length() { + sorted_vals[low_idx] + } else { + 0.0 + } + let high_threshold = if high_idx < sorted_vals.length() { + sorted_vals[high_idx] + } else { + 0.0 + } + let mut i = 0 while i < expression.gene_ids.length() { let expr = expression.expression[i] let gene_min = calc_min(expr) let gene_max = calc_max(expr) - + if gene_min >= low_threshold && gene_max <= high_threshold { passing_genes.push(expression.gene_ids[i]) } - + i = i + 1 } - + passing_genes } @@ -280,14 +314,14 @@ fn calc_mean(vals : Array[Double]) -> Double { if vals.length() == 0 { return 0.0 } - + let mut sum = 0.0 let mut i = 0 while i < vals.length() { sum = sum + vals[i] i = i + 1 } - + sum / vals.length().to_double() } @@ -296,16 +330,16 @@ fn calc_variance(vals : Array[Double]) -> Double { if vals.length() < 2 { return 0.0 } - + let m = calc_mean(vals) let mut sum_sq = 0.0 - + let mut i = 0 while i < vals.length() { sum_sq = sum_sq + @math.pow(vals[i] - m, 2.0) i = i + 1 } - + sum_sq / (vals.length() - 1).to_double() } @@ -314,7 +348,7 @@ fn calc_min(vals : Array[Double]) -> Double { if vals.length() == 0 { return 0.0 } - + let mut m = vals[0] let mut i = 1 while i < vals.length() { @@ -323,7 +357,7 @@ fn calc_min(vals : Array[Double]) -> Double { } i = i + 1 } - + m } @@ -332,7 +366,7 @@ fn calc_max(vals : Array[Double]) -> Double { if vals.length() == 0 { return 0.0 } - + let mut m = vals[0] let mut i = 1 while i < vals.length() { @@ -341,7 +375,7 @@ fn calc_max(vals : Array[Double]) -> Double { } i = i + 1 } - + m } @@ -355,7 +389,9 @@ pub fn create_example_gene_expression() -> GeneExpression { [15.7, 16.2, 15.9, 14.8, 15.2, 14.5], [3.2, 3.5, 3.1, 3.0, 3.3, 2.9], ] - let groups = ["control", "control", "control", "treatment", "treatment", "treatment"] - + let groups = [ + "control", "control", "control", "treatment", "treatment", "treatment", + ] + GeneExpression::new(gene_ids, expression, groups) -} \ No newline at end of file +} diff --git a/src/genesis.mbt b/src/genesis.mbt index b10bbf0b..c22501b6 100644 --- a/src/genesis.mbt +++ b/src/genesis.mbt @@ -15,7 +15,7 @@ pub struct GSKinshipResult { pub fn GSKinshipResult::new( kinship_matrix : Array[Array[Double]], sample_ids : Array[String], - n_samples : Int + n_samples : Int, ) -> GSKinshipResult { GSKinshipResult::{ kinship_matrix, sample_ids, n_samples } } @@ -35,7 +35,7 @@ pub fn GSPcaResult::new( eigenvalues : Array[Double], eigenvectors : Array[Array[Double]], var_explained : Array[Double], - sample_ids : Array[String] + sample_ids : Array[String], ) -> GSPcaResult { GSPcaResult::{ eigenvalues, eigenvectors, var_explained, sample_ids } } @@ -53,7 +53,7 @@ pub struct GSDistanceResult { pub fn GSDistanceResult::new( distance_matrix : Array[Array[Double]], sample_ids : Array[String], - distance_type : String + distance_type : String, ) -> GSDistanceResult { GSDistanceResult::{ distance_matrix, sample_ids, distance_type } } @@ -63,14 +63,14 @@ pub fn GSDistanceResult::new( pub fn gs_estimate_kinship(genotypes : Array[Array[Double]]) -> GSKinshipResult { let n = genotypes.length() let m = if n > 0 { genotypes[0].length() } else { 0 } - + let sample_ids : Array[String] = Array::new() let mut i = 0 while i < n { sample_ids.push("Sample" + i.to_string()) i = i + 1 } - + let kinship : Array[Array[Double]] = Array::new() let mut j = 0 while j < n { @@ -83,7 +83,7 @@ pub fn gs_estimate_kinship(genotypes : Array[Array[Double]]) -> GSKinshipResult kinship.push(row) j = j + 1 } - + let allele_freqs : Array[Double] = Array::new() let mut l = 0 while l < m { @@ -97,10 +97,16 @@ pub fn gs_estimate_kinship(genotypes : Array[Array[Double]]) -> GSKinshipResult } p = p + 1 } - allele_freqs.push(if n_valid > 0 { sum / (2.0 * n_valid.to_double()) } else { 0.5 }) + allele_freqs.push( + if n_valid > 0 { + sum / (2.0 * n_valid.to_double()) + } else { + 0.5 + }, + ) l = l + 1 } - + let mut a = 0 while a < n { let mut b = a @@ -112,7 +118,9 @@ pub fn gs_estimate_kinship(genotypes : Array[Array[Double]]) -> GSKinshipResult if genotypes[a][c] >= 0.0 && genotypes[b][c] >= 0.0 { let freq = allele_freqs[c] if freq > 0.0 && freq < 1.0 { - let term = (genotypes[a][c] - 2.0 * freq) * (genotypes[b][c] - 2.0 * freq) / (2.0 * freq * (1.0 - freq)) + let term = (genotypes[a][c] - 2.0 * freq) * + (genotypes[b][c] - 2.0 * freq) / + (2.0 * freq * (1.0 - freq)) sum = sum + term count = count + 1 } @@ -126,23 +134,26 @@ pub fn gs_estimate_kinship(genotypes : Array[Array[Double]]) -> GSKinshipResult } a = a + 1 } - + GSKinshipResult::new(kinship, sample_ids, n) } ///| /// Perform PCA on genotype data. -pub fn gs_pca(genotypes : Array[Array[Double]], n_components : Int) -> GSPcaResult { +pub fn gs_pca( + genotypes : Array[Array[Double]], + n_components : Int, +) -> GSPcaResult { let n = genotypes.length() let m = if n > 0 { genotypes[0].length() } else { 0 } - + let sample_ids : Array[String] = Array::new() let mut i = 0 while i < n { sample_ids.push("Sample" + i.to_string()) i = i + 1 } - + let allele_freqs : Array[Double] = Array::new() let mut j = 0 while j < m { @@ -156,10 +167,16 @@ pub fn gs_pca(genotypes : Array[Array[Double]], n_components : Int) -> GSPcaResu } k = k + 1 } - allele_freqs.push(if n_valid > 0 { sum / (2.0 * n_valid.to_double()) } else { 0.5 }) + allele_freqs.push( + if n_valid > 0 { + sum / (2.0 * n_valid.to_double()) + } else { + 0.5 + }, + ) j = j + 1 } - + let standardized : Array[Array[Double]] = Array::new() let mut l = 0 while l < n { @@ -169,7 +186,9 @@ pub fn gs_pca(genotypes : Array[Array[Double]], n_components : Int) -> GSPcaResu if genotypes[l][p] >= 0.0 { let freq = allele_freqs[p] if freq > 0.0 && freq < 1.0 { - row.push((genotypes[l][p] - 2.0 * freq) / (2.0 * freq * (1.0 - freq)).sqrt()) + row.push( + (genotypes[l][p] - 2.0 * freq) / (2.0 * freq * (1.0 - freq)).sqrt(), + ) } else { row.push(0.0) } @@ -181,7 +200,7 @@ pub fn gs_pca(genotypes : Array[Array[Double]], n_components : Int) -> GSPcaResu standardized.push(row) l = l + 1 } - + let covariance : Array[Array[Double]] = Array::new() let mut q = 0 while q < n { @@ -200,9 +219,9 @@ pub fn gs_pca(genotypes : Array[Array[Double]], n_components : Int) -> GSPcaResu covariance.push(row) q = q + 1 } - + let components = gs_power_iteration(covariance, n_components) - + let eigenvalues : Array[Double] = Array::new() let mut t = 0 while t < components.length() { @@ -215,39 +234,48 @@ pub fn gs_pca(genotypes : Array[Array[Double]], n_components : Int) -> GSPcaResu eigenvalues.push(sum) t = t + 1 } - + let mut total_var = 0.0 let mut idx = 0 while idx < eigenvalues.length() { total_var = total_var + eigenvalues[idx] idx = idx + 1 } - + let var_explained : Array[Double] = Array::new() let mut v = 0 while v < eigenvalues.length() { - var_explained.push(if total_var > 0.0 { eigenvalues[v] / total_var } else { 0.0 }) + var_explained.push( + if total_var > 0.0 { + eigenvalues[v] / total_var + } else { + 0.0 + }, + ) v = v + 1 } - + GSPcaResult::new(eigenvalues, components, var_explained, sample_ids) } ///| /// Power iteration for eigenvalue decomposition. -pub fn gs_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> Array[Array[Double]] { +pub fn gs_power_iteration( + matrix : Array[Array[Double]], + n_components : Int, +) -> Array[Array[Double]] { let n = matrix.length() let components : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_components { let v : Array[Double] = Array::new() let mut j = 0 while j < n { - v.push(((i + 1).to_double() / (j + 1).to_double()) - 0.5) + v.push((i + 1).to_double() / (j + 1).to_double() - 0.5) j = j + 1 } - + let mut iter = 0 while iter < 100 { let v_new : Array[Double] = Array::new() @@ -262,7 +290,7 @@ pub fn gs_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> v_new.push(sum) k = k + 1 } - + let mut norm = 0.0 let mut m = 0 while m < n { @@ -270,18 +298,18 @@ pub fn gs_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> m = m + 1 } norm = norm.sqrt() - + let mut p = 0 while p < n { v.set(p, v_new[p] / norm) p = p + 1 } - + iter = iter + 1 } - + components.push(v) - + let mut q = 0 while q < n { let mut r = 0 @@ -297,10 +325,10 @@ pub fn gs_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> } q = q + 1 } - + i = i + 1 } - + components } @@ -308,19 +336,19 @@ pub fn gs_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> /// Calculate genetic distance matrix. pub fn gs_calculate_genetic_distance( genotypes : Array[Array[Double]], - distance_type? : String = "euclidean" + distance_type? : String = "euclidean", ) -> GSDistanceResult { let n = genotypes.length() - + let dt = distance_type - + let sample_ids : Array[String] = Array::new() let mut i = 0 while i < n { sample_ids.push("Sample" + i.to_string()) i = i + 1 } - + let distance : Array[Array[Double]] = Array::new() let mut j = 0 while j < n { @@ -333,7 +361,7 @@ pub fn gs_calculate_genetic_distance( distance.push(row) j = j + 1 } - + let mut a = 0 while a < n { let mut b = a + 1 @@ -347,14 +375,14 @@ pub fn gs_calculate_genetic_distance( } else { gs_euclidean_distance(genotypes[a], genotypes[b]) } - + distance[a].set(b, dist) distance[b].set(a, dist) b = b + 1 } a = a + 1 } - + GSDistanceResult::new(distance, sample_ids, dt) } @@ -401,20 +429,33 @@ pub fn gs_ibs_distance(v1 : Array[Double], v2 : Array[Double]) -> Double { } i = i + 1 } - if count > 0 { sum / count.to_double() } else { 0.0 } + if count > 0 { + sum / count.to_double() + } else { + 0.0 + } } ///| /// Bio API functions. - -pub fn bio_estimate_kinship(genotypes : Array[Array[Double]]) -> GSKinshipResult { +pub fn bio_estimate_kinship( + genotypes : Array[Array[Double]], +) -> GSKinshipResult { gs_estimate_kinship(genotypes) } -pub fn bio_pca(genotypes : Array[Array[Double]], n_components : Int) -> GSPcaResult { +///| +pub fn bio_pca( + genotypes : Array[Array[Double]], + n_components : Int, +) -> GSPcaResult { gs_pca(genotypes, n_components) } -pub fn bio_genetic_distance(genotypes : Array[Array[Double]], distance_type? : String) -> GSDistanceResult { +///| +pub fn bio_genetic_distance( + genotypes : Array[Array[Double]], + distance_type? : String, +) -> GSDistanceResult { gs_calculate_genetic_distance(genotypes) -} \ No newline at end of file +} diff --git a/src/genie3.mbt b/src/genie3.mbt index a430d7b3..dd071472 100644 --- a/src/genie3.mbt +++ b/src/genie3.mbt @@ -19,14 +19,14 @@ /// Stored by index in a shared array (avoids recursive type issues). pub struct Genie3TreeNode { // For internal nodes: - feature : Int // index of splitting feature (-1 for leaf) - threshold : Double // split threshold (feature <= threshold goes left) - left_idx : Int // index into shared node array (-1 for leaf) - right_idx : Int // index into shared node array (-1 for leaf) + feature : Int // index of splitting feature (-1 for leaf) + threshold : Double // split threshold (feature <= threshold goes left) + left_idx : Int // index into shared node array (-1 for leaf) + right_idx : Int // index into shared node array (-1 for leaf) // For leaf nodes: - value : Double // leaf prediction value + value : Double // leaf prediction value is_leaf : Bool - importance_gain : Double // variance reduction at this split + importance_gain : Double // variance reduction at this split } ///| @@ -71,7 +71,10 @@ pub struct RegressionTree { ///| /// Predict a value for a single sample by traversing the tree. -pub fn RegressionTree::predict(self : RegressionTree, sample : Array[Double]) -> Double { +pub fn RegressionTree::predict( + self : RegressionTree, + sample : Array[Double], +) -> Double { let mut node_idx = 0 while true { let node = self.nodes[node_idx] @@ -316,11 +319,7 @@ fn genie3_build_recursive( // Now fill in the placeholder slot tree.nodes[current_idx] = genie3_tree_split( - best_feature, - best_threshold, - left_idx, - right_idx, - best_gain, + best_feature, best_threshold, left_idx, right_idx, best_gain, ) current_idx } @@ -344,12 +343,7 @@ pub fn genie3_build_tree( ) -> RegressionTree { let tree : RegressionTree = { nodes: [] } let _ = genie3_build_recursive( - tree, - features_matrix, - target, - feature_indices, - max_depth, - min_samples_split, + tree, features_matrix, target, feature_indices, max_depth, min_samples_split, 0, ) tree @@ -358,17 +352,17 @@ pub fn genie3_build_tree( ///| /// A weighted directed edge in the inferred regulatory network. pub struct RegulatoryEdge { - regulator : String // source gene (predictor) - target : String // target gene - weight : Double // importance weight + regulator : String // source gene (predictor) + target : String // target gene + weight : Double // importance weight } ///| /// GENIE3 inference result: weighted adjacency matrix and edges. pub struct Genie3Result { gene_names : Array[String] - matrix : Array[Array[Double]] // matrix[i][j] = importance of gene i for gene j - edges : Array[RegulatoryEdge] // sorted edges (descending weight) + matrix : Array[Array[Double]] // matrix[i][j] = importance of gene i for gene j + edges : Array[RegulatoryEdge] // sorted edges (descending weight) n_trees : Int symmetrized : Bool } @@ -499,9 +493,11 @@ pub fn genie3_run( let mut j = 0 while j < n_genes { if i != j && matrix[i][j] > 0.0 { - edges.push( - RegulatoryEdge::{ regulator: gene_names[i], target: gene_names[j], weight: matrix[i][j] }, - ) + edges.push(RegulatoryEdge::{ + regulator: gene_names[i], + target: gene_names[j], + weight: matrix[i][j], + }) } j = j + 1 } @@ -522,12 +518,21 @@ pub fn genie3_run( ei = ei + 1 } - Genie3Result::{ gene_names, matrix, edges, n_trees: n_genes, symmetrized: sym } + Genie3Result::{ + gene_names, + matrix, + edges, + n_trees: n_genes, + symmetrized: sym, + } } ///| /// Get the top-K regulatory edges by weight. -pub fn genie3_top_edges(result : Genie3Result, k : Int) -> Array[RegulatoryEdge] { +pub fn genie3_top_edges( + result : Genie3Result, + k : Int, +) -> Array[RegulatoryEdge] { let n = if k < result.edges.length() { k } else { result.edges.length() } let top : Array[RegulatoryEdge] = [] let mut i = 0 diff --git a/src/genome_diagram.mbt b/src/genome_diagram.mbt index b96d5e2e..a758a849 100644 --- a/src/genome_diagram.mbt +++ b/src/genome_diagram.mbt @@ -38,23 +38,33 @@ pub fn FeatureShape::from_string(s : String) -> FeatureShape { ///| /// Helper to create a Rectangle shape. -pub fn gd_rectangle_shape() -> FeatureShape { Rectangle } +pub fn gd_rectangle_shape() -> FeatureShape { + Rectangle +} ///| /// Helper to create an Arrow shape. -pub fn gd_arrow_shape() -> FeatureShape { Arrow } +pub fn gd_arrow_shape() -> FeatureShape { + Arrow +} ///| /// Helper to create a Diamond shape. -pub fn gd_diamond_shape() -> FeatureShape { Diamond } +pub fn gd_diamond_shape() -> FeatureShape { + Diamond +} ///| /// Helper to create a CrossedArrow shape. -pub fn gd_crossed_arrow_shape() -> FeatureShape { CrossedArrow } +pub fn gd_crossed_arrow_shape() -> FeatureShape { + CrossedArrow +} ///| /// Helper to create a Terminators shape. -pub fn gd_terminators_shape() -> FeatureShape { Terminators } +pub fn gd_terminators_shape() -> FeatureShape { + Terminators +} ///| /// DiagramStyle: styling options for the diagram. @@ -78,22 +88,35 @@ pub fn DiagramStyle::new( } ///| -pub fn DiagramStyle::circular(self : DiagramStyle) -> Bool { self.circular } +pub fn DiagramStyle::circular(self : DiagramStyle) -> Bool { + self.circular +} ///| -pub fn DiagramStyle::linear(self : DiagramStyle) -> Bool { self.linear } +pub fn DiagramStyle::linear(self : DiagramStyle) -> Bool { + self.linear +} ///| -pub fn DiagramStyle::scale(self : DiagramStyle) -> Double { self.scale } +pub fn DiagramStyle::scale(self : DiagramStyle) -> Double { + self.scale +} ///| -pub fn DiagramStyle::border(self : DiagramStyle) -> Bool { self.border } +pub fn DiagramStyle::border(self : DiagramStyle) -> Bool { + self.border +} ///| -pub fn DiagramStyle::color_scheme(self : DiagramStyle) -> String { self.color_scheme } +pub fn DiagramStyle::color_scheme(self : DiagramStyle) -> String { + self.color_scheme +} ///| -pub fn DiagramStyle::set_circular(self : DiagramStyle, v : Bool) -> DiagramStyle { +pub fn DiagramStyle::set_circular( + self : DiagramStyle, + v : Bool, +) -> DiagramStyle { DiagramStyle::{ ..self, circular: v, linear: !v } } @@ -113,7 +136,10 @@ pub fn DiagramStyle::set_border(self : DiagramStyle, v : Bool) -> DiagramStyle { } ///| -pub fn DiagramStyle::set_color_scheme(self : DiagramStyle, v : String) -> DiagramStyle { +pub fn DiagramStyle::set_color_scheme( + self : DiagramStyle, + v : String, +) -> DiagramStyle { DiagramStyle::{ ..self, color_scheme: v } } @@ -143,50 +169,81 @@ pub fn DiagramFeature::new( } ///| -pub fn DiagramFeature::start(self : DiagramFeature) -> Int { self.start } +pub fn DiagramFeature::start(self : DiagramFeature) -> Int { + self.start +} ///| -pub fn DiagramFeature::end(self : DiagramFeature) -> Int { self.end } +pub fn DiagramFeature::end(self : DiagramFeature) -> Int { + self.end +} ///| -pub fn DiagramFeature::strand(self : DiagramFeature) -> String { self.strand } +pub fn DiagramFeature::strand(self : DiagramFeature) -> String { + self.strand +} ///| -pub fn DiagramFeature::label(self : DiagramFeature) -> String { self.label } +pub fn DiagramFeature::label(self : DiagramFeature) -> String { + self.label +} ///| -pub fn DiagramFeature::color(self : DiagramFeature) -> String { self.color } +pub fn DiagramFeature::color(self : DiagramFeature) -> String { + self.color +} ///| -pub fn DiagramFeature::shape(self : DiagramFeature) -> FeatureShape { self.shape } +pub fn DiagramFeature::shape(self : DiagramFeature) -> FeatureShape { + self.shape +} ///| -pub fn DiagramFeature::depth(self : DiagramFeature) -> Int { self.depth } +pub fn DiagramFeature::depth(self : DiagramFeature) -> Int { + self.depth +} ///| -pub fn DiagramFeature::with_color(self : DiagramFeature, color : String) -> DiagramFeature { - DiagramFeature::{ ..self, color } +pub fn DiagramFeature::with_color( + self : DiagramFeature, + color : String, +) -> DiagramFeature { + DiagramFeature::{ ..self, color, } } ///| -pub fn DiagramFeature::with_label(self : DiagramFeature, label : String) -> DiagramFeature { - DiagramFeature::{ ..self, label } +pub fn DiagramFeature::with_label( + self : DiagramFeature, + label : String, +) -> DiagramFeature { + DiagramFeature::{ ..self, label, } } ///| -pub fn DiagramFeature::with_depth(self : DiagramFeature, depth : Int) -> DiagramFeature { - DiagramFeature::{ ..self, depth } +pub fn DiagramFeature::with_depth( + self : DiagramFeature, + depth : Int, +) -> DiagramFeature { + DiagramFeature::{ ..self, depth, } } ///| -pub fn DiagramFeature::overlaps(self : DiagramFeature, start : Int, end : Int) -> Bool { +pub fn DiagramFeature::overlaps( + self : DiagramFeature, + start : Int, + end : Int, +) -> Bool { self.start < end && self.end > start } ///| pub fn DiagramFeature::length(self : DiagramFeature) -> Int { let diff = self.end - self.start - if diff > 0 { diff } else { -diff } + if diff > 0 { + diff + } else { + -diff + } } ///| @@ -213,37 +270,59 @@ pub fn TrackFeature::new( } ///| -pub fn TrackFeature::start(self : TrackFeature) -> Int { self.start } +pub fn TrackFeature::start(self : TrackFeature) -> Int { + self.start +} ///| -pub fn TrackFeature::end(self : TrackFeature) -> Int { self.end } +pub fn TrackFeature::end(self : TrackFeature) -> Int { + self.end +} ///| -pub fn TrackFeature::strand(self : TrackFeature) -> String { self.strand } +pub fn TrackFeature::strand(self : TrackFeature) -> String { + self.strand +} ///| -pub fn TrackFeature::label(self : TrackFeature) -> String { self.label } +pub fn TrackFeature::label(self : TrackFeature) -> String { + self.label +} ///| -pub fn TrackFeature::color(self : TrackFeature) -> String { self.color } +pub fn TrackFeature::color(self : TrackFeature) -> String { + self.color +} ///| -pub fn TrackFeature::shape(self : TrackFeature) -> FeatureShape { self.shape } +pub fn TrackFeature::shape(self : TrackFeature) -> FeatureShape { + self.shape +} ///| -pub fn TrackFeature::with_color(self : TrackFeature, color : String) -> TrackFeature { - TrackFeature::{ ..self, color } +pub fn TrackFeature::with_color( + self : TrackFeature, + color : String, +) -> TrackFeature { + TrackFeature::{ ..self, color, } } ///| -pub fn TrackFeature::with_label(self : TrackFeature, label : String) -> TrackFeature { - TrackFeature::{ ..self, label } +pub fn TrackFeature::with_label( + self : TrackFeature, + label : String, +) -> TrackFeature { + TrackFeature::{ ..self, label, } } ///| pub fn TrackFeature::length(self : TrackFeature) -> Int { let diff = self.end - self.start - if diff > 0 { diff } else { -diff } + if diff > 0 { + diff + } else { + -diff + } } ///| @@ -265,16 +344,24 @@ pub fn Track::new( } ///| -pub fn Track::name(self : Track) -> String { self.name } +pub fn Track::name(self : Track) -> String { + self.name +} ///| -pub fn Track::features(self : Track) -> Array[TrackFeature] { self.features } +pub fn Track::features(self : Track) -> Array[TrackFeature] { + self.features +} ///| -pub fn Track::is_labeled(self : Track) -> Bool { self.is_labeled } +pub fn Track::is_labeled(self : Track) -> Bool { + self.is_labeled +} ///| -pub fn Track::color_scheme(self : Track) -> String { self.color_scheme } +pub fn Track::color_scheme(self : Track) -> String { + self.color_scheme +} ///| pub fn Track::feature_count(self : Track) -> Int { @@ -313,11 +400,7 @@ pub struct Diagram { } ///| -pub fn Diagram::new( - name : String, - start : Int, - end : Int, -) -> Diagram { +pub fn Diagram::new(name : String, start : Int, end : Int) -> Diagram { Diagram::{ tracks: [], features: [], @@ -329,27 +412,43 @@ pub fn Diagram::new( } ///| -pub fn Diagram::name(self : Diagram) -> String { self.name } +pub fn Diagram::name(self : Diagram) -> String { + self.name +} ///| -pub fn Diagram::start(self : Diagram) -> Int { self.start } +pub fn Diagram::start(self : Diagram) -> Int { + self.start +} ///| -pub fn Diagram::end(self : Diagram) -> Int { self.end } +pub fn Diagram::end(self : Diagram) -> Int { + self.end +} ///| -pub fn Diagram::style(self : Diagram) -> DiagramStyle { self.style } +pub fn Diagram::style(self : Diagram) -> DiagramStyle { + self.style +} ///| -pub fn Diagram::tracks(self : Diagram) -> Array[Track] { self.tracks } +pub fn Diagram::tracks(self : Diagram) -> Array[Track] { + self.tracks +} ///| -pub fn Diagram::features(self : Diagram) -> Array[DiagramFeature] { self.features } +pub fn Diagram::features(self : Diagram) -> Array[DiagramFeature] { + self.features +} ///| pub fn Diagram::length(self : Diagram) -> Int { let diff = self.end - self.start - if diff > 0 { diff } else { -diff } + if diff > 0 { + diff + } else { + -diff + } } ///| @@ -368,7 +467,7 @@ pub fn Diagram::feature_count(self : Diagram) -> Int { ///| pub fn Diagram::with_style(self : Diagram, style : DiagramStyle) -> Diagram { - Diagram::{ ..self, style } + Diagram::{ ..self, style, } } ///| @@ -391,9 +490,7 @@ pub fn Diagram::add_feature_to_diagram( label : String, shape : FeatureShape, ) -> Diagram { - let feature = DiagramFeature::new( - start, end, strand=strand, label=label, shape=shape, - ) + let feature = DiagramFeature::new(start, end, strand~, label~, shape~) let new_features : Array[DiagramFeature] = [] for f in self.features { new_features.push(f) @@ -411,9 +508,7 @@ pub fn Diagram::add_feature_to_track( strand : String, label : String, ) -> Diagram { - let feature = TrackFeature::new( - start, end, strand=strand, label=label, - ) + let feature = TrackFeature::new(start, end, strand~, label~) let new_tracks : Array[Track] = [] for track in self.tracks { if track.name == track_name { @@ -426,7 +521,10 @@ pub fn Diagram::add_feature_to_track( } ///| -pub fn Diagram::get_track_features(self : Diagram, track_name : String) -> Array[TrackFeature] { +pub fn Diagram::get_track_features( + self : Diagram, + track_name : String, +) -> Array[TrackFeature] { for track in self.tracks { if track.name == track_name { return track.features @@ -476,9 +574,7 @@ pub fn Diagram::to_svg(self : Diagram, width : Int, height : Int) -> String { let scale = usable_w / len.to_double() let svg = StringBuilder::new() - svg.write_string( - " String { svg.write_string("\">\n") if self.style.border { - svg.write_string( - "\n", - ) + svg.write_string("\" fill=\"none\" stroke=\"#333\" stroke-width=\"2\"/>\n") } let name_y = 18.0 - svg.write_string( - " String { svg.write_string("\n") let backbone_y = height.to_double() - pad - svg.write_string( - " String { svg.write_string((w - pad).to_string()) svg.write_string("\" y2=\"") svg.write_string(backbone_y.to_string()) - svg.write_string( - "\" stroke=\"#666\" stroke-width=\"2\"/>\n", - ) + svg.write_string("\" stroke=\"#666\" stroke-width=\"2\"/>\n") let tick_count = 5 let tick_width = usable_w / tick_count.to_double() let mut ti = 0 while ti <= tick_count { let x = pad + ti.to_double() * tick_width - let pos = self.start + (ti.to_double() * len.to_double() / tick_count.to_double()).to_int() - svg.write_string( - " String { svg.write_string(x.to_string()) svg.write_string("\" y2=\"") svg.write_string((backbone_y + 5.0).to_string()) - svg.write_string( - "\" stroke=\"#666\" stroke-width=\"1\"/>\n", - ) - svg.write_string( - "\n") + svg.write_string(" String { let mut track_idx = 0 for track in self.tracks { let ty = top_tracks_y + track_idx.to_double() * (track_height + track_gap) - svg.write_string( - " String { for feat in track.features { let fx = pad + (feat.start - self.start).to_double() * scale let mut fw = (feat.end - feat.start).to_double() * scale - if fw < 1.0 { fw = 1.0 } + if fw < 1.0 { + fw = 1.0 + } let fy = ty + 2.0 let fh = track_height - 4.0 let color = feat.color match feat.shape { Arrow => { let tip_x = fx + fw - svg.write_string( - " String { svg.write_string("\" stroke=\"#333\" stroke-width=\"0.5\"/>\n") } _ => { - svg.write_string( - " String { } if feat.label.length() > 0 && track.is_labeled { let label_x = fx + fw / 2.0 - svg.write_string( - " String { track_idx = track_idx + 1 } - let feat_start_y = top_tracks_y + track_idx.to_double() * (track_height + track_gap) + 10.0 + let feat_start_y = top_tracks_y + + track_idx.to_double() * (track_height + track_gap) + + 10.0 let mut fi = 0 for feat in self.features { let fx = pad + (feat.start - self.start).to_double() * scale let mut fw = (feat.end - feat.start).to_double() * scale - if fw < 1.0 { fw = 1.0 } - let fy = feat_start_y + (fi.to_double() * 18.0) + if fw < 1.0 { + fw = 1.0 + } + let fy = feat_start_y + fi.to_double() * 18.0 let fh = 14.0 let color = feat.color let depth_offset = feat.depth.to_double() * 3.0 match feat.shape { Arrow => { let tip_x = fx + fw - svg.write_string( - " String { Diamond => { let cx = fx + fw / 2.0 let cy = fy + fh / 2.0 + depth_offset - svg.write_string( - " String { } CrossedArrow => { let tip_x = fx + fw - svg.write_string( - " String { svg.write_string(tip_x.to_string()) svg.write_string("\" y2=\"") svg.write_string((fy + fh / 2.0 + depth_offset).to_string()) - svg.write_string( - "\" stroke=\"", - ) + svg.write_string("\" stroke=\"") svg.write_string(color) svg.write_string("\" stroke-width=\"2\"/>\n") - svg.write_string( - " String { svg.write_string(tip_x.to_string()) svg.write_string("\" y2=\"") svg.write_string((fy + fh / 2.0 + depth_offset).to_string()) - svg.write_string( - "\" stroke=\"", - ) + svg.write_string("\" stroke=\"") svg.write_string(color) svg.write_string("\" stroke-width=\"2\"/>\n") } Terminators => { - svg.write_string( - " String { svg.write_string(fx.to_string()) svg.write_string("\" y2=\"") svg.write_string((fy + fh + depth_offset).to_string()) - svg.write_string( - "\" stroke=\"", - ) + svg.write_string("\" stroke=\"") svg.write_string(color) svg.write_string("\" stroke-width=\"3\"/>\n") - svg.write_string( - " String { svg.write_string((fx + fw).to_string()) svg.write_string("\" y2=\"") svg.write_string((fy + fh + depth_offset).to_string()) - svg.write_string( - "\" stroke=\"", - ) + svg.write_string("\" stroke=\"") svg.write_string(color) svg.write_string("\" stroke-width=\"3\"/>\n") } Rectangle => { - svg.write_string( - " String { } if feat.label.length() > 0 { let label_x = fx + fw / 2.0 - svg.write_string( - " Diagram { ///| /// Get all track features for a named track. -pub fn gd_get_features(diagram : Diagram, track_name : String) -> Array[TrackFeature] { +pub fn gd_get_features( + diagram : Diagram, + track_name : String, +) -> Array[TrackFeature] { diagram.get_track_features(track_name) } @@ -902,7 +960,10 @@ pub fn gd_to_svg_string(diagram : Diagram, width : Int, height : Int) -> String ///| /// Set the color of a diagram feature. -pub fn gd_set_feature_color(feature : DiagramFeature, color : String) -> DiagramFeature { +pub fn gd_set_feature_color( + feature : DiagramFeature, + color : String, +) -> DiagramFeature { feature.with_color(color) } @@ -910,4 +971,4 @@ pub fn gd_set_feature_color(feature : DiagramFeature, color : String) -> Diagram /// Auto-label features larger than min_size that have no label. pub fn gd_label_features(diagram : Diagram, min_size : Int) -> Diagram { diagram.label_features_auto(min_size) -} \ No newline at end of file +} diff --git a/src/genomic_ranges.mbt b/src/genomic_ranges.mbt index 8cbb7e2a..09ef8710 100644 --- a/src/genomic_ranges.mbt +++ b/src/genomic_ranges.mbt @@ -734,7 +734,10 @@ pub fn follow(gr1 : GRanges, gr2 : GRanges) -> Array[Int] { ///| /// Calculate coverage of genomic ranges. /// Returns a map of seqname to coverage array. -pub fn coverage_granges(gr : GRanges, seqlengths : Map[String, Int]) -> Map[String, Array[Int]] { +pub fn coverage_granges( + gr : GRanges, + seqlengths : Map[String, Int], +) -> Map[String, Array[Int]] { let result : Map[String, Array[Int]] = Map([], capacity=10) let seqnames = gr.seqnames @@ -772,7 +775,10 @@ pub fn coverage_granges(gr : GRanges, seqlengths : Map[String, Int]) -> Map[Stri ///| /// Calculate coverage as a GRanges object (run-length encoding). -pub fn coverage_as_granges(gr : GRanges, seqlengths : Map[String, Int]) -> GRanges { +pub fn coverage_as_granges( + gr : GRanges, + seqlengths : Map[String, Int], +) -> GRanges { let result_seqnames : Array[String] = Array::new() let result_starts : Array[Int] = Array::new() let result_ends : Array[Int] = Array::new() @@ -854,7 +860,11 @@ pub fn distance_to_nearest(gr : GRanges) -> Array[Int] { j = j + 1 } - distances[i] = if min_dist < @double.infinity { min_dist.to_int() } else { -1 } + distances[i] = if min_dist < @double.infinity { + min_dist.to_int() + } else { + -1 + } i = i + 1 } @@ -952,6 +962,7 @@ pub fn granges_sort(gr : GRanges) -> GRanges { } } +///| fn compare_granges_pos(gr : GRanges, idx1 : Int, idx2 : Int) -> Int { if gr.seqnames[idx1] < gr.seqnames[idx2] { -1 @@ -966,9 +977,13 @@ fn compare_granges_pos(gr : GRanges, idx1 : Int, idx2 : Int) -> Int { } } -///| Test precede function +///| +/// Test precede function test "precede" { - let gr1 = granges(["chr1", "chr1"], [(10, 20), (30, 40)], [strand_plus(), strand_plus()]) + let gr1 = granges(["chr1", "chr1"], [(10, 20), (30, 40)], [ + strand_plus(), + strand_plus(), + ]) let gr2 = granges(["chr1"], [(5, 8)], [strand_plus()]) let result = precede(gr1, gr2) assert_eq(result.length(), 2) @@ -976,9 +991,13 @@ test "precede" { assert_eq(result[0], 0) } -///| Test follow function +///| +/// Test follow function test "follow" { - let gr1 = granges(["chr1", "chr1"], [(10, 20), (30, 40)], [strand_plus(), strand_plus()]) + let gr1 = granges(["chr1", "chr1"], [(10, 20), (30, 40)], [ + strand_plus(), + strand_plus(), + ]) let gr2 = granges(["chr1"], [(50, 60)], [strand_plus()]) let result = follow(gr1, gr2) assert_eq(result.length(), 2) @@ -986,9 +1005,13 @@ test "follow" { assert_eq(result[1], 0) } -///| Test coverage_granges function +///| +/// Test coverage_granges function test "coverage_granges" { - let gr = granges(["chr1", "chr1"], [(1, 5), (3, 8)], [strand_plus(), strand_plus()]) + let gr = granges(["chr1", "chr1"], [(1, 5), (3, 8)], [ + strand_plus(), + strand_plus(), + ]) let seqlengths : Map[String, Int] = Map([], capacity=1) seqlengths["chr1"] = 10 let result = coverage_granges(gr, seqlengths) @@ -1003,7 +1026,8 @@ test "coverage_granges" { assert_eq(cov[5], 1) } -///| Test distance_to_nearest function +///| +/// Test distance_to_nearest function test "distance_to_nearest" { let gr = granges(["chr1", "chr1", "chr1"], [(1, 5), (15, 20), (30, 35)], [ strand_plus(), @@ -1016,9 +1040,13 @@ test "distance_to_nearest" { assert_eq(result[0], 9) } -///| Test coverage_as_granges function +///| +/// Test coverage_as_granges function test "coverage_as_granges" { - let gr = granges(["chr1", "chr1"], [(1, 5), (3, 8)], [strand_plus(), strand_plus()]) + let gr = granges(["chr1", "chr1"], [(1, 5), (3, 8)], [ + strand_plus(), + strand_plus(), + ]) let seqlengths : Map[String, Int] = Map([], capacity=1) seqlengths["chr1"] = 10 let result = coverage_as_granges(gr, seqlengths) diff --git a/src/genomic_ranges_advanced.mbt b/src/genomic_ranges_advanced.mbt index 0f96b48c..ed4906c6 100644 --- a/src/genomic_ranges_advanced.mbt +++ b/src/genomic_ranges_advanced.mbt @@ -20,11 +20,7 @@ /// /// If both n and width are specified, width takes precedence. /// Returns a new GRanges with the tiled sub-ranges. -pub fn granges_tile( - gr : GRanges, - n? : Int = 0, - width? : Int = 0, -) -> GRanges { +pub fn granges_tile(gr : GRanges, n? : Int = 0, width? : Int = 0) -> GRanges { let n_ranges = gr.seqnames.length() let result_seqnames : Array[String] = Array::new() let result_ranges : Array[(Int, Int)] = Array::new() @@ -41,11 +37,7 @@ pub fn granges_tile( // Tile by fixed width let mut pos = start while pos <= end { - let tile_end = if pos + width - 1 < end { - pos + width - 1 - } else { - end - } + let tile_end = if pos + width - 1 < end { pos + width - 1 } else { end } result_seqnames.push(seqname) result_ranges.push((pos, tile_end)) result_strands.push(strand) @@ -107,11 +99,7 @@ pub fn granges_sliding_windows( let mut pos = start while pos <= end { - let win_end = if pos + width - 1 < end { - pos + width - 1 - } else { - end - } + let win_end = if pos + width - 1 < end { pos + width - 1 } else { end } // Only add windows that are at least half the width let actual_width = win_end - pos + 1 if actual_width >= width / 2 || pos == start { @@ -136,10 +124,7 @@ pub fn granges_sliding_windows( /// - width: Width of each tile /// /// Returns a GRanges with tiles covering the entire genome. -pub fn tile_genome( - seqlengths : Array[(String, Int)], - width : Int, -) -> GRanges { +pub fn tile_genome(seqlengths : Array[(String, Int)], width : Int) -> GRanges { let result_seqnames : Array[String] = Array::new() let result_ranges : Array[(Int, Int)] = Array::new() let result_strands : Array[Strand] = Array::new() @@ -274,7 +259,10 @@ pub fn bin_genome( let result : Array[(String, Int, Int, Int, Double)] = Array::new() // Group ranges by chromosome - let chrom_map : Map[String, Array[(Int, Int)]] = Map([], capacity=seqlengths.length()) + let chrom_map : Map[String, Array[(Int, Int)]] = Map( + [], + capacity=seqlengths.length(), + ) for i = 0; i < gr.seqnames.length(); i = i + 1 { let chrom = gr.seqnames[i] let ranges = chrom_map.get(chrom) @@ -517,10 +505,7 @@ fn sort_ranges(ranges : Array[(Int, Int)]) -> Array[(Int, Int)] { ///| /// Subtract ranges: find regions in gr1 not covered by gr2. -pub fn granges_subtract( - gr1 : GRanges, - gr2 : GRanges, -) -> GRanges { +pub fn granges_subtract(gr1 : GRanges, gr2 : GRanges) -> GRanges { let result_seqnames : Array[String] = Array::new() let result_ranges : Array[(Int, Int)] = Array::new() let result_strands : Array[Strand] = Array::new() diff --git a/src/genomic_ranges_gaps.mbt b/src/genomic_ranges_gaps.mbt index 2ebf5cb2..9f89e694 100644 --- a/src/genomic_ranges_gaps.mbt +++ b/src/genomic_ranges_gaps.mbt @@ -61,7 +61,7 @@ pub fn grg_granges( let n = seqnames.length() let final_strands : Array[String] = Array::make(n, "+") match strands { - Some(s) => { + Some(s) => if s.length() == n { let mut i = 0 while i < n { @@ -69,7 +69,6 @@ pub fn grg_granges( i = i + 1 } } - } None => () } GRangesLocal::{ seqnames, starts, ends, strands: final_strands } @@ -161,7 +160,11 @@ pub fn grg_gaps(gr : GRangesLocal, seqlengths : Map[String, Int]) -> GapResult { if !seen.contains(seqname) { seen[seqname] = () - let seqlen : Int = if seqlengths.contains(seqname) { seqlengths[seqname] } else { 0 } + let seqlen : Int = if seqlengths.contains(seqname) { + seqlengths[seqname] + } else { + 0 + } if seqlen > 0 { let ranges : Array[(Int, Int)] = [] @@ -205,7 +208,11 @@ pub fn grg_gaps(gr : GRangesLocal, seqlengths : Map[String, Int]) -> GapResult { m = m + 1 } - let last_end = if merged.length() == 0 { 0 } else { merged[merged.length() - 1].1 } + let last_end = if merged.length() == 0 { + 0 + } else { + merged[merged.length() - 1].1 + } let final_gap_start = last_end + 1 let final_gap_end = seqlen if final_gap_start <= final_gap_end { @@ -289,10 +296,15 @@ pub fn grg_reduce(gr : GRangesLocal, min_gap? : Int) -> GrgReduceResult { } else { let last_end = merged_ends[merged_ends.length() - 1] if current.0 <= last_end + gap + 1 { - let new_end = if current.1 > last_end { current.1 } else { last_end } + let new_end = if current.1 > last_end { + current.1 + } else { + last_end + } merged_ends[merged_ends.length() - 1] = new_end - merged_counts[merged_counts.length() - 1] = - merged_counts[merged_counts.length() - 1] + cnt + merged_counts[merged_counts.length() - 1] = merged_counts[merged_counts.length() - + 1] + + cnt } else { merged_starts.push(current.0) merged_ends.push(current.1) @@ -566,7 +578,10 @@ pub fn grg_union(gr1 : GRangesLocal, gr2 : GRangesLocal) -> GRangesLocal { /// /// Returns a Map from seqname to Array[Int] of length seqlength, /// where index i contains the number of ranges covering position i+1. -pub fn grg_compute_coverage(gr : GRangesLocal, seqlengths : Map[String, Int]) -> Map[String, Array[Int]] { +pub fn grg_compute_coverage( + gr : GRangesLocal, + seqlengths : Map[String, Int], +) -> Map[String, Array[Int]] { let result : Map[String, Array[Int]] = Map([], capacity=10) let keys = seqlengths.keys().collect() @@ -609,7 +624,10 @@ pub fn grg_compute_coverage(gr : GRangesLocal, seqlengths : Map[String, Int]) -> /// Returns a GRangesLocal where ranges that extend beyond the /// chromosome boundaries are clipped to [1, seqlength]. Ranges /// that fall entirely outside are removed. -pub fn grg_trim(gr : GRangesLocal, seqlengths : Map[String, Int]) -> GRangesLocal { +pub fn grg_trim( + gr : GRangesLocal, + seqlengths : Map[String, Int], +) -> GRangesLocal { let seqnames : Array[String] = [] let starts : Array[Int] = [] let ends : Array[Int] = [] @@ -743,11 +761,7 @@ test "grg_gaps_no_gaps_single_range" { ///| test "grg_gaps_finds_gaps_between_ranges" { - let gr = grg_granges( - ["chr1", "chr1"], - [1, 30], - [10, 50], - ) + let gr = grg_granges(["chr1", "chr1"], [1, 30], [10, 50]) let sl : Map[String, Int] = Map([], capacity=1) sl["chr1"] = 100 let gaps = grg_gaps(gr, sl) @@ -772,11 +786,7 @@ test "grg_gaps_empty_input" { ///| test "grg_gaps_overlapping_ranges_merged" { - let gr = grg_granges( - ["chr1", "chr1", "chr1"], - [1, 5, 20], - [10, 15, 30], - ) + let gr = grg_granges(["chr1", "chr1", "chr1"], [1, 5, 20], [10, 15, 30]) let sl : Map[String, Int] = Map([], capacity=1) sl["chr1"] = 50 let gaps = grg_gaps(gr, sl) @@ -789,11 +799,7 @@ test "grg_gaps_overlapping_ranges_merged" { ///| test "grg_reduce_merges_overlapping" { - let gr = grg_granges( - ["chr1", "chr1"], - [1, 5], - [10, 15], - ) + let gr = grg_granges(["chr1", "chr1"], [1, 5], [10, 15]) let result = grg_reduce(gr) assert_eq(result.seqnames.length(), 1) assert_eq(result.starts[0], 1) @@ -803,11 +809,7 @@ test "grg_reduce_merges_overlapping" { ///| test "grg_reduce_merges_adjacent" { - let gr = grg_granges( - ["chr1", "chr1"], - [1, 11], - [10, 20], - ) + let gr = grg_granges(["chr1", "chr1"], [1, 11], [10, 20]) let result = grg_reduce(gr) assert_eq(result.seqnames.length(), 1) assert_eq(result.starts[0], 1) @@ -816,11 +818,7 @@ test "grg_reduce_merges_adjacent" { ///| test "grg_reduce_no_overlap" { - let gr = grg_granges( - ["chr1", "chr1"], - [1, 30], - [10, 50], - ) + let gr = grg_granges(["chr1", "chr1"], [1, 30], [10, 50]) let result = grg_reduce(gr) assert_eq(result.seqnames.length(), 2) assert_eq(result.starts[0], 1) @@ -838,11 +836,7 @@ test "grg_reduce_empty_input" { ///| test "grg_disjoin_splits_overlapping" { - let gr = grg_granges( - ["chr1", "chr1"], - [1, 5], - [10, 15], - ) + let gr = grg_granges(["chr1", "chr1"], [1, 5], [10, 15]) let result = grg_disjoin(gr) assert_eq(result.seqnames.length(), 3) assert_eq(result.starts[0], 1) @@ -855,11 +849,7 @@ test "grg_disjoin_splits_overlapping" { ///| test "grg_disjoin_no_overlap" { - let gr = grg_granges( - ["chr1", "chr1"], - [1, 20], - [10, 30], - ) + let gr = grg_granges(["chr1", "chr1"], [1, 20], [10, 30]) let result = grg_disjoin(gr) assert_eq(result.seqnames.length(), 3) assert_eq(result.starts[0], 1) @@ -945,11 +935,7 @@ test "grg_union_disjoint_ranges" { ///| test "grg_compute_coverage_basic" { - let gr = grg_granges( - ["chr1", "chr1"], - [1, 3], - [5, 8], - ) + let gr = grg_granges(["chr1", "chr1"], [1, 3], [5, 8]) let sl : Map[String, Int] = Map([], capacity=1) sl["chr1"] = 10 let cov = grg_compute_coverage(gr, sl) @@ -975,11 +961,7 @@ test "grg_compute_coverage_no_ranges" { ///| test "grg_trim_clips_beyond_chromosome" { - let gr = grg_granges( - ["chr1", "chr1"], - [-5, 8], - [10, 30], - ) + let gr = grg_granges(["chr1", "chr1"], [-5, 8], [10, 30]) let sl : Map[String, Int] = Map([], capacity=1) sl["chr1"] = 20 let result = grg_trim(gr, sl) @@ -992,11 +974,7 @@ test "grg_trim_clips_beyond_chromosome" { ///| test "grg_trim_removes_completely_outside" { - let gr = grg_granges( - ["chr1", "chr1"], - [1, 25], - [10, 30], - ) + let gr = grg_granges(["chr1", "chr1"], [1, 25], [10, 30]) let sl : Map[String, Int] = Map([], capacity=1) sl["chr1"] = 20 let result = grg_trim(gr, sl) @@ -1007,12 +985,7 @@ test "grg_trim_removes_completely_outside" { ///| test "grg_promoters_plus_strand" { - let gr = grg_granges( - ["chr1"], - [100], - [200], - strands=["+"], - ) + let gr = grg_granges(["chr1"], [100], [200], strands=["+"]) let result = grg_promoters(gr, upstream=50, downstream=20) assert_eq(result.seqnames.length(), 1) assert_eq(result.starts[0], 50) @@ -1021,12 +994,7 @@ test "grg_promoters_plus_strand" { ///| test "grg_promoters_minus_strand" { - let gr = grg_granges( - ["chr1"], - [100], - [200], - strands=["-"], - ) + let gr = grg_granges(["chr1"], [100], [200], strands=["-"]) let result = grg_promoters(gr, upstream=50, downstream=20) assert_eq(result.seqnames.length(), 1) assert_eq(result.starts[0], 181) @@ -1035,12 +1003,7 @@ test "grg_promoters_minus_strand" { ///| test "grg_promoters_star_strand_two_outputs" { - let gr = grg_granges( - ["chr1"], - [100], - [200], - strands=["*"], - ) + let gr = grg_granges(["chr1"], [100], [200], strands=["*"]) let result = grg_promoters(gr, upstream=50, downstream=20) assert_eq(result.seqnames.length(), 2) assert_eq(result.strands[0], "+") @@ -1063,11 +1026,7 @@ test "grg_setdiff_different_chromosomes" { ///| test "grg_gaps_multiple_chromosomes" { - let gr = grg_granges( - ["chr1", "chr2"], - [1, 1], - [10, 10], - ) + let gr = grg_granges(["chr1", "chr2"], [1, 1], [10, 10]) let sl : Map[String, Int] = Map([], capacity=2) sl["chr1"] = 20 sl["chr2"] = 30 diff --git a/src/geo.mbt b/src/geo.mbt index 871456bd..f1ce2d99 100644 --- a/src/geo.mbt +++ b/src/geo.mbt @@ -278,7 +278,7 @@ pub struct GeoFile { ///| /// Create a GeoFile. pub fn GeoFile::new(records : Array[GeoRecord]) -> GeoFile { - { records } + { records, } } ///| @@ -417,12 +417,7 @@ pub fn geo_parse(text : String) -> GeoFile { let keyword = trim(rest[0:eq_pos].to_string()) let accession = trim(rest[eq_pos + 1:rest.length()].to_string()) let etype = geo_entity_type_from_keyword(keyword) - let (record, next) = geo_parse_record( - lines, - idx + 1, - etype, - accession, - ) + let (record, next) = geo_parse_record(lines, idx + 1, etype, accession) records.push(record) idx = next } else { @@ -473,12 +468,10 @@ fn geo_parse_record( None => () } in_table = true - } else { // Data row (if we're in a table section with columns defined) - if in_table && columns.length() > 0 { - let fields = geo_split_tab(line) - rows.push(fields) - } + } else if in_table && columns.length() > 0 { + let fields = geo_split_tab(line) + rows.push(fields) } idx = idx + 1 } @@ -543,8 +536,11 @@ pub fn GeoAttribute::to_string(self : GeoAttribute) -> String { ///| /// Format a GeoDataTable as a readable string. pub fn GeoDataTable::to_string(self : GeoDataTable) -> String { - let mut s = "DataTable(" + self.n_columns().to_string() + " cols, " + - self.n_rows().to_string() + " rows)\n" + let mut s = "DataTable(" + + self.n_columns().to_string() + + " cols, " + + self.n_rows().to_string() + + " rows)\n" // Column headers s = s + " " for i in 0.. String { ///| /// Format a GeoRecord as a readable string. pub fn GeoRecord::to_string(self : GeoRecord) -> String { - let mut s = "GeoRecord(type=" + self.entity_type.to_string() + ", accession=" + - self.accession + ")\n" + let mut s = "GeoRecord(type=" + + self.entity_type.to_string() + + ", accession=" + + self.accession + + ")\n" s = s + "Attributes (" + self.attributes.length().to_string() + "):\n" for attr in self.attributes { s = s + " " + attr.to_string() + "\n" diff --git a/src/gfa_io.mbt b/src/gfa_io.mbt index 37ecf2ee..0e3d796b 100644 --- a/src/gfa_io.mbt +++ b/src/gfa_io.mbt @@ -172,14 +172,7 @@ pub fn GfaLink::new( overlap : String, tags : Array[GfaTag], ) -> GfaLink { - GfaLink::{ - from_segment, - from_orient, - to_segment, - to_orient, - overlap, - tags, - } + GfaLink::{ from_segment, from_orient, to_segment, to_orient, overlap, tags } } ///| @@ -530,14 +523,7 @@ pub fn gfa_parse_link(fields : Array[String]) -> GfaLink { let to_orient = if n > 4 { fields[4] } else { "+" } let overlap = if n > 5 { fields[5] } else { "*" } let tags = if n > 6 { gfa_parse_tags(fields, 6) } else { Array::new() } - GfaLink::{ - from_segment, - from_orient, - to_segment, - to_orient, - overlap, - tags, - } + GfaLink::{ from_segment, from_orient, to_segment, to_orient, overlap, tags } } ///| diff --git a/src/gff.mbt b/src/gff.mbt index db221e53..580ebd36 100644 --- a/src/gff.mbt +++ b/src/gff.mbt @@ -23,7 +23,7 @@ pub fn GFFFeature::new( feature_type : String, start : Int, end : Int, - strand : String + strand : String, ) -> GFFFeature { GFFFeature::{ seqid, @@ -34,7 +34,7 @@ pub fn GFFFeature::new( score: None, strand, phase: None, - attributes: Map([], capacity=0) + attributes: Map([], capacity=0), } } @@ -49,7 +49,7 @@ pub fn GFFFeature::set_score(self : GFFFeature, score : Double) -> GFFFeature { score: Some(score), strand: self.strand, phase: self.phase, - attributes: self.attributes + attributes: self.attributes, } } @@ -64,12 +64,16 @@ pub fn GFFFeature::set_phase(self : GFFFeature, phase : Int) -> GFFFeature { score: self.score, strand: self.strand, phase: Some(phase), - attributes: self.attributes + attributes: self.attributes, } } ///| -pub fn GFFFeature::add_attribute(self : GFFFeature, key : String, value : String) -> GFFFeature { +pub fn GFFFeature::add_attribute( + self : GFFFeature, + key : String, + value : String, +) -> GFFFeature { let new_attrs = self.attributes new_attrs.set(key, value) GFFFeature::{ @@ -81,7 +85,7 @@ pub fn GFFFeature::add_attribute(self : GFFFeature, key : String, value : String score: self.score, strand: self.strand, phase: self.phase, - attributes: new_attrs + attributes: new_attrs, } } @@ -116,7 +120,9 @@ pub fn GFFFeature::length(self : GFFFeature) -> Int { ///| pub fn GFFFeature::is_coding(self : GFFFeature) -> Bool { - self.feature_type == "CDS" || self.feature_type == "mRNA" || self.feature_type == "gene" + self.feature_type == "CDS" || + self.feature_type == "mRNA" || + self.feature_type == "gene" } ///| @@ -141,34 +147,37 @@ pub fn GFFRecord::new() -> GFFRecord { GFFRecord::{ features: Array::new(), sequences: Map([], capacity=0), - version: "3" + version: "3", } } ///| -pub fn GFFRecord::add_feature(self : GFFRecord, feature : GFFFeature) -> GFFRecord { +pub fn GFFRecord::add_feature( + self : GFFRecord, + feature : GFFFeature, +) -> GFFRecord { let new_features = self.features new_features.push(feature) GFFRecord::{ features: new_features, sequences: self.sequences, - version: self.version + version: self.version, } } ///| -pub fn GFFRecord::add_sequence(self : GFFRecord, seqid : String, sequence : String) -> GFFRecord { +pub fn GFFRecord::add_sequence( + self : GFFRecord, + seqid : String, + sequence : String, +) -> GFFRecord { self.sequences.set(seqid, sequence) self } ///| pub fn GFFRecord::set_version(self : GFFRecord, version : String) -> GFFRecord { - GFFRecord::{ - features: self.features, - sequences: self.sequences, - version: version - } + GFFRecord::{ features: self.features, sequences: self.sequences, version } } ///| @@ -181,7 +190,10 @@ pub fn GFFRecord::get_sequence(self : GFFRecord, seqid : String) -> String? { } ///| -pub fn GFFRecord::get_features_by_type(self : GFFRecord, feature_type : String) -> Array[GFFFeature] { +pub fn GFFRecord::get_features_by_type( + self : GFFRecord, + feature_type : String, +) -> Array[GFFFeature] { let result : Array[GFFFeature] = Array::new() let mut i = 0 while i < self.features.length() { @@ -194,7 +206,10 @@ pub fn GFFRecord::get_features_by_type(self : GFFRecord, feature_type : String) } ///| -pub fn GFFRecord::get_features_by_seqid(self : GFFRecord, seqid : String) -> Array[GFFFeature] { +pub fn GFFRecord::get_features_by_seqid( + self : GFFRecord, + seqid : String, +) -> Array[GFFFeature] { let result : Array[GFFFeature] = Array::new() let mut i = 0 while i < self.features.length() { @@ -207,16 +222,15 @@ pub fn GFFRecord::get_features_by_seqid(self : GFFRecord, seqid : String) -> Arr } ///| -pub fn GFFRecord::get_features_by_id(self : GFFRecord, id : String) -> Array[GFFFeature] { +pub fn GFFRecord::get_features_by_id( + self : GFFRecord, + id : String, +) -> Array[GFFFeature] { let result : Array[GFFFeature] = Array::new() let mut i = 0 while i < self.features.length() { match self.features[i].get_id() { - Some(feature_id) => { - if feature_id == id { - result.push(self.features[i]) - } - } + Some(feature_id) => if feature_id == id { result.push(self.features[i]) } None => () } i = i + 1 @@ -225,7 +239,10 @@ pub fn GFFRecord::get_features_by_id(self : GFFRecord, id : String) -> Array[GFF } ///| -pub fn GFFRecord::get_child_features(self : GFFRecord, parent_id : String) -> Array[GFFFeature] { +pub fn GFFRecord::get_child_features( + self : GFFRecord, + parent_id : String, +) -> Array[GFFFeature] { let result : Array[GFFFeature] = Array::new() let mut i = 0 while i < self.features.length() { @@ -270,15 +287,21 @@ pub fn GFFRecord::get_exons(self : GFFRecord) -> Array[GFFFeature] { } ///| -pub fn GFFRecord::get_transcripts_for_gene(self : GFFRecord, gene_id : String) -> Array[GFFFeature] { +pub fn GFFRecord::get_transcripts_for_gene( + self : GFFRecord, + gene_id : String, +) -> Array[GFFFeature] { self.get_child_features(gene_id) } ///| -pub fn GFFRecord::get_cds_for_transcript(self : GFFRecord, transcript_id : String) -> Array[GFFFeature] { +pub fn GFFRecord::get_cds_for_transcript( + self : GFFRecord, + transcript_id : String, +) -> Array[GFFFeature] { let result : Array[GFFFeature] = Array::new() let children = self.get_child_features(transcript_id) - + let mut i = 0 while i < children.length() { if children[i].feature_type == "CDS" { @@ -299,7 +322,7 @@ pub fn GFFRecord::get_cds_for_transcript(self : GFFRecord, transcript_id : Strin } i = i + 1 } - + result } @@ -307,7 +330,7 @@ pub fn GFFRecord::get_cds_for_transcript(self : GFFRecord, transcript_id : Strin pub fn parse_attributes(attr_str : String) -> Map[String, String] { let attrs = Map([], capacity=0) let pairs = split_by_char(attr_str, ';'.to_int()) - + let mut i = 0 while i < pairs.length() { let pair = trim(pairs[i]) @@ -321,7 +344,7 @@ pub fn parse_attributes(attr_str : String) -> Map[String, String] { } i = i + 1 } - + attrs } @@ -342,7 +365,7 @@ fn string_replace(s : String, from : String, to : String) -> String { if m == 0 || m > n { return s } - + let mut result = "" let mut i = 0 while i < n { @@ -361,12 +384,12 @@ fn string_replace(s : String, from : String, to : String) -> String { ///| pub fn bio_parse_gff(content : String) -> GFFRecord { let mut record = GFFRecord::new() - + let lines = split_by_char(content, '\n'.to_int()) let mut i = 0 while i < lines.length() { let line = trim(lines[i]) - + if line == "" || starts_with(line, 0, "#") { if starts_with(line, 0, "##gff-version") { let parts = split_by_char(line, ' '.to_int()) @@ -377,7 +400,7 @@ pub fn bio_parse_gff(content : String) -> GFFRecord { i = i + 1 continue } - + let fields = split_by_char(line, '\t'.to_int()) if fields.length() >= 8 { let seqid = trim(fields[0]) @@ -386,21 +409,23 @@ pub fn bio_parse_gff(content : String) -> GFFRecord { let start = parse_int(trim(fields[3])) let end = parse_int(trim(fields[4])) let strand = trim(fields[6]) - - let mut feature = GFFFeature::new(seqid, source, feature_type, start, end, strand) - + + let mut feature = GFFFeature::new( + seqid, source, feature_type, start, end, strand, + ) + if fields.length() > 5 && trim(fields[5]) != "." { match parse_double(trim(fields[5])) { Some(score) => feature = feature.set_score(score) None => () } } - + if fields.length() > 7 && trim(fields[7]) != "." { let phase = parse_int(trim(fields[7])) feature = feature.set_phase(phase) } - + if fields.length() > 8 { let attrs = parse_attributes(trim(fields[8])) let entries = attrs.iter().collect() @@ -411,20 +436,20 @@ pub fn bio_parse_gff(content : String) -> GFFRecord { j = j + 1 } } - + ignore(record.add_feature(feature)) } - + i = i + 1 } - + record } ///| pub fn GFFRecord::to_gff(self : GFFRecord) -> String { let mut result = "##gff-version ".to_string() + self.version + "\n" - + let mut i = 0 while i < self.features.length() { let f = self.features[i] @@ -433,19 +458,19 @@ pub fn GFFRecord::to_gff(self : GFFRecord) -> String { result = result + f.feature_type + "\t" result = result + f.start.to_string() + "\t" result = result + f.end.to_string() + "\t" - + match f.score { Some(s) => result = result + s.to_string() + "\t" None => result = result + ".\t" } - + result = result + f.strand + "\t" - + match f.phase { Some(p) => result = result + p.to_string() + "\t" None => result = result + ".\t" } - + let attrs = f.attributes.iter().collect() let mut j = 0 while j < attrs.length() { @@ -457,10 +482,10 @@ pub fn GFFRecord::to_gff(self : GFFRecord) -> String { j = j + 1 } result = result + "\n" - + i = i + 1 } - + result } @@ -477,59 +502,61 @@ fn escape_attribute_value(value : String) -> String { ///| pub fn create_example_gff() -> GFFRecord { let record = GFFRecord::new() - + let gene = GFFFeature::new("chr1", "Ensembl", "gene", 10000, 15000, "+") .add_attribute("ID", "gene:ENSG00000130203") .add_attribute("Name", "TP53") .add_attribute("biotype", "protein_coding") ignore(record.add_feature(gene)) - + let mrna = GFFFeature::new("chr1", "Ensembl", "mRNA", 10100, 14800, "+") .add_attribute("ID", "transcript:ENST00000335137") .add_attribute("Parent", "gene:ENSG00000130203") .add_attribute("biotype", "protein_coding") .add_attribute("transcript_id", "ENST00000335137") ignore(record.add_feature(mrna)) - + let exon1 = GFFFeature::new("chr1", "Ensembl", "exon", 10100, 10200, "+") .add_attribute("ID", "exon:ENST00000335137:1") .add_attribute("Parent", "transcript:ENST00000335137") ignore(record.add_feature(exon1)) - + let exon2 = GFFFeature::new("chr1", "Ensembl", "exon", 10500, 10600, "+") .add_attribute("ID", "exon:ENST00000335137:2") .add_attribute("Parent", "transcript:ENST00000335137") ignore(record.add_feature(exon2)) - + let exon3 = GFFFeature::new("chr1", "Ensembl", "exon", 11000, 11500, "+") .add_attribute("ID", "exon:ENST00000335137:3") .add_attribute("Parent", "transcript:ENST00000335137") ignore(record.add_feature(exon3)) - + let cds1 = GFFFeature::new("chr1", "Ensembl", "CDS", 10100, 10200, "+") .add_attribute("ID", "cds:ENST00000335137:1") .add_attribute("Parent", "transcript:ENST00000335137") .set_phase(0) ignore(record.add_feature(cds1)) - + let cds2 = GFFFeature::new("chr1", "Ensembl", "CDS", 10500, 10600, "+") .add_attribute("ID", "cds:ENST00000335137:2") .add_attribute("Parent", "transcript:ENST00000335137") .set_phase(0) ignore(record.add_feature(cds2)) - + let cds3 = GFFFeature::new("chr1", "Ensembl", "CDS", 11000, 11450, "+") .add_attribute("ID", "cds:ENST00000335137:3") .add_attribute("Parent", "transcript:ENST00000335137") .set_phase(0) ignore(record.add_feature(cds3)) - - let gene2 = GFFFeature::new("chr17", "Ensembl", "gene", 43044295, 43125370, "-") + + let gene2 = GFFFeature::new( + "chr17", "Ensembl", "gene", 43044295, 43125370, "-", + ) .add_attribute("ID", "gene:ENSG00000141510") .add_attribute("Name", "BRCA1") .add_attribute("biotype", "protein_coding") ignore(record.add_feature(gene2)) - + record } @@ -542,7 +569,7 @@ pub fn GFFRecord::count_features(self : GFFRecord) -> Int { pub fn GFFRecord::get_unique_seqids(self : GFFRecord) -> Array[String] { let result : Array[String] = Array::new() let seen : Map[String, Bool] = Map([], capacity=0) - + let mut i = 0 while i < self.features.length() { let seqid = self.features[i].seqid @@ -552,7 +579,7 @@ pub fn GFFRecord::get_unique_seqids(self : GFFRecord) -> Array[String] { } i = i + 1 } - + result } @@ -560,7 +587,7 @@ pub fn GFFRecord::get_unique_seqids(self : GFFRecord) -> Array[String] { pub fn GFFRecord::get_unique_feature_types(self : GFFRecord) -> Array[String] { let result : Array[String] = Array::new() let seen : Map[String, Bool] = Map([], capacity=0) - + let mut i = 0 while i < self.features.length() { let ftype = self.features[i].feature_type @@ -570,12 +597,17 @@ pub fn GFFRecord::get_unique_feature_types(self : GFFRecord) -> Array[String] { } i = i + 1 } - + result } ///| -pub fn GFFRecord::get_features_in_range(self : GFFRecord, seqid : String, start : Int, end : Int) -> Array[GFFFeature] { +pub fn GFFRecord::get_features_in_range( + self : GFFRecord, + seqid : String, + start : Int, + end : Int, +) -> Array[GFFFeature] { let result : Array[GFFFeature] = Array::new() let mut i = 0 while i < self.features.length() { @@ -589,7 +621,10 @@ pub fn GFFRecord::get_features_in_range(self : GFFRecord, seqid : String, start } ///| -pub fn GFFRecord::calculate_gene_length(self : GFFRecord, gene_id : String) -> Int { +pub fn GFFRecord::calculate_gene_length( + self : GFFRecord, + gene_id : String, +) -> Int { let cds_features = self.get_cds_for_transcript(gene_id) let mut total_length = 0 let mut i = 0 @@ -598,4 +633,4 @@ pub fn GFFRecord::calculate_gene_length(self : GFFRecord, gene_id : String) -> I i = i + 1 } total_length -} \ No newline at end of file +} diff --git a/src/ggtree.mbt b/src/ggtree.mbt index afe13dae..a0334efe 100644 --- a/src/ggtree.mbt +++ b/src/ggtree.mbt @@ -20,13 +20,7 @@ pub fn LayoutNode::new( branch_length : Double, is_leaf : Bool, ) -> LayoutNode { - LayoutNode::{ - id, - label, - branch_length, - is_leaf, - children: [], - } + LayoutNode::{ id, label, branch_length, is_leaf, children: [] } } ///| @@ -117,7 +111,9 @@ pub fn create_test_tree() -> Array[LayoutNode] { children: children_a, } - let children_root : Array[LayoutNode] = [a_with_children, d_with_children, node_g] + let children_root : Array[LayoutNode] = [ + a_with_children, d_with_children, node_g, + ] let root_with_children = LayoutNode::{ id: root.id, label: root.label, @@ -162,7 +158,11 @@ pub fn ggtree_compute_y_positions( let mut current_y = y_pos let mut i = 0 while i < node.children.length() { - current_y = ggtree_compute_y_positions(node.children[i], current_y, positions) + current_y = ggtree_compute_y_positions( + node.children[i], + current_y, + positions, + ) i = i + 1 } // Center the internal node between its children @@ -203,7 +203,10 @@ pub fn ggtree_collect_leaf_ids(node : LayoutNode) -> Array[String] { } ///| -fn ggtree_collect_leaf_ids_recursive(node : LayoutNode, result : Array[String]) -> Unit { +fn ggtree_collect_leaf_ids_recursive( + node : LayoutNode, + result : Array[String], +) -> Unit { if node.children.length() == 0 { result.push(node.id) } else { @@ -224,7 +227,10 @@ pub fn ggtree_collect_internal_ids(node : LayoutNode) -> Array[String] { } ///| -fn ggtree_collect_internal_ids_recursive(node : LayoutNode, result : Array[String]) -> Unit { +fn ggtree_collect_internal_ids_recursive( + node : LayoutNode, + result : Array[String], +) -> Unit { let mut i = 0 while i < node.children.length() { ggtree_collect_internal_ids_recursive(node.children[i], result) @@ -267,11 +273,22 @@ fn ggtree_compute_bounds( // Recursively check children let mut i = 0 while i < node.children.length() { - let (child_min_x, child_max_x, child_min_y, child_max_y) = ggtree_compute_bounds([node.children[i]], positions) - if child_min_x < min_x { min_x = child_min_x } - if child_max_x > max_x { max_x = child_max_x } - if child_min_y < min_y { min_y = child_min_y } - if child_max_y > max_y { max_y = child_max_y } + let (child_min_x, child_max_x, child_min_y, child_max_y) = ggtree_compute_bounds( + [node.children[i]], + positions, + ) + if child_min_x < min_x { + min_x = child_min_x + } + if child_max_x > max_x { + max_x = child_max_x + } + if child_min_y < min_y { + min_y = child_min_y + } + if child_max_y > max_y { + max_y = child_max_y + } i = i + 1 } } @@ -315,10 +332,18 @@ fn ggtree_compute_bounds_flat( let mut i = 1 while i < all_ids.length() { let pos = positions[all_ids[i]] - if pos.0 < min_x { min_x = pos.0 } - if pos.0 > max_x { max_x = pos.0 } - if pos.1 < min_y { min_y = pos.1 } - if pos.1 > max_y { max_y = pos.1 } + if pos.0 < min_x { + min_x = pos.0 + } + if pos.0 > max_x { + max_x = pos.0 + } + if pos.1 < min_y { + min_y = pos.1 + } + if pos.1 > max_y { + max_y = pos.1 + } i = i + 1 } @@ -343,10 +368,14 @@ pub fn layout_rectangular(tree_data : TreeData) -> TreeLayout { } let root = tree_data.nodes[0] - let n_nodes = ggtree_count_leaves(root) + (ggtree_collect_internal_ids(root).length()) + let n_nodes = ggtree_count_leaves(root) + + ggtree_collect_internal_ids(root).length() // Initialize positions map - let positions : Map[String, (Double, Double, Double)] = Map([], capacity=n_nodes) + let positions : Map[String, (Double, Double, Double)] = Map( + [], + capacity=n_nodes, + ) // Step 1: Assign y positions let _ = ggtree_compute_y_positions(root, 0.0, positions) @@ -360,7 +389,9 @@ pub fn layout_rectangular(tree_data : TreeData) -> TreeLayout { // Step 4: Compute bounds let all_ids = ggtree_collect_all_ids(root) - let (min_x, max_x, min_y, max_y) = ggtree_compute_bounds_flat(positions, all_ids) + let (min_x, max_x, min_y, max_y) = ggtree_compute_bounds_flat( + positions, all_ids, + ) TreeLayout::{ nodes: tree_data.nodes.copy(), @@ -396,7 +427,10 @@ pub fn layout_radial(tree_data : TreeData) -> TreeLayout { let rect_layout = layout_rectangular(tree_data) // Convert to radial - let radial_positions : Map[String, (Double, Double, Double)] = Map([], capacity=rect_layout.positions.length()) + let radial_positions : Map[String, (Double, Double, Double)] = Map( + [], + capacity=rect_layout.positions.length(), + ) let y_range = rect_layout.max_y - rect_layout.min_y let angle_scale = if y_range > 0.0 { 360.0 / y_range } else { 1.0 } @@ -412,7 +446,9 @@ pub fn layout_radial(tree_data : TreeData) -> TreeLayout { } let all_ids = ggtree_collect_all_ids(tree_data.nodes[0]) - let (min_x, max_x, min_y, max_y) = ggtree_compute_bounds_flat(radial_positions, all_ids) + let (min_x, max_x, min_y, max_y) = ggtree_compute_bounds_flat( + radial_positions, all_ids, + ) TreeLayout::{ nodes: tree_data.nodes.copy(), @@ -451,14 +487,19 @@ pub fn layout_unrooted(tree_data : TreeData) -> TreeLayout { let center_x = (rect_layout.min_x + rect_layout.max_x) / 2.0 let center_y = (rect_layout.min_y + rect_layout.max_y) / 2.0 - let shifted_positions : Map[String, (Double, Double, Double)] = Map([], capacity=rect_layout.positions.length()) + let shifted_positions : Map[String, (Double, Double, Double)] = Map( + [], + capacity=rect_layout.positions.length(), + ) for id in rect_layout.positions.keys() { let pos = rect_layout.positions[id] shifted_positions.set(id, (pos.0 - center_x, pos.1 - center_y, pos.2)) } let all_ids = ggtree_collect_all_ids(tree_data.nodes[0]) - let (min_x, max_x, min_y, max_y) = ggtree_compute_bounds_flat(shifted_positions, all_ids) + let (min_x, max_x, min_y, max_y) = ggtree_compute_bounds_flat( + shifted_positions, all_ids, + ) TreeLayout::{ nodes: tree_data.nodes.copy(), @@ -475,7 +516,10 @@ pub fn layout_unrooted(tree_data : TreeData) -> TreeLayout { ///| /// Get position for a node from layout. -pub fn ggtree_get_position(layout : TreeLayout, node_id : String) -> (Double, Double, Double) { +pub fn ggtree_get_position( + layout : TreeLayout, + node_id : String, +) -> (Double, Double, Double) { if layout.positions.contains(node_id) { layout.positions[node_id] } else { @@ -507,11 +551,19 @@ fn ggtree_generate_edges_recursive( edges : Array[String], ) -> Unit { if node.children.length() > 0 { - let node_pos = if positions.contains(node.id) { positions[node.id] } else { (0.0, 0.0, 0.0) } + let node_pos = if positions.contains(node.id) { + positions[node.id] + } else { + (0.0, 0.0, 0.0) + } let mut i = 0 while i < node.children.length() { let child = node.children[i] - let child_pos = if positions.contains(child.id) { positions[child.id] } else { (0.0, 0.0, 0.0) } + let child_pos = if positions.contains(child.id) { + positions[child.id] + } else { + (0.0, 0.0, 0.0) + } let edge = "(\{node.id} -> \{child.id}: [\{node_pos.0}, \{node_pos.1}] -> [\{child_pos.0}, \{child_pos.1}])" edges.push(edge) ggtree_generate_edges_recursive(child, positions, edges) @@ -537,7 +589,11 @@ fn ggtree_generate_labels_recursive( labels : Array[String], ) -> Unit { if node.is_leaf { - let pos = if positions.contains(node.id) { positions[node.id] } else { (0.0, 0.0, 0.0) } + let pos = if positions.contains(node.id) { + positions[node.id] + } else { + (0.0, 0.0, 0.0) + } let label = "(\{node.id}, '\{node.label}', \{pos.0}, \{pos.1})" labels.push(label) } diff --git a/src/glm_gampoi.mbt b/src/glm_gampoi.mbt index 3c0b40aa..784763c0 100644 --- a/src/glm_gampoi.mbt +++ b/src/glm_gampoi.mbt @@ -159,9 +159,20 @@ pub fn GlmTestResult::adj_p_value(self : GlmTestResult) -> Double { /// Format a test result as a string. pub fn GlmTestResult::to_string(self : GlmTestResult) -> String { let sig = if self.is_significant { "*" } else { "" } - self.gene + " " + self.coef_name + " est=" + self.estimate.to_string() + - " se=" + self.std_error.to_string() + " z=" + self.z_value.to_string() + - " p=" + self.p_value.to_string() + " adj=" + self.adj_p_value.to_string() + sig + self.gene + + " " + + self.coef_name + + " est=" + + self.estimate.to_string() + + " se=" + + self.std_error.to_string() + + " z=" + + self.z_value.to_string() + + " p=" + + self.p_value.to_string() + + " adj=" + + self.adj_p_value.to_string() + + sig } ///| @@ -374,9 +385,15 @@ pub fn glm_fit_one_gene( let std_errors = glm_compute_se(design, dispersion, coefs, size_factors) let df_residual = n - n_coefs - let df_dispersion = if df_residual > 0 { df_residual.to_double() } else { 1.0 } + let df_dispersion = if df_residual > 0 { + df_residual.to_double() + } else { + 1.0 + } - GlmFit::new(gene_name, coefs, std_errors, dispersion, df_residual, df_dispersion) + GlmFit::new( + gene_name, coefs, std_errors, dispersion, df_residual, df_dispersion, + ) } ///| @@ -415,7 +432,9 @@ pub fn glm_test_de( let z = if se > 0.0 { estimate / se } else { 0.0 } let pval = glm_normal_pvalue_two_sided(z) let coef_name = design.coef_names[test_coef_index] - results.push(GlmTestResult::new(gene_names[g], coef_name, estimate, se, z, pval)) + results.push( + GlmTestResult::new(gene_names[g], coef_name, estimate, se, z, pval), + ) } results @@ -676,7 +695,11 @@ pub fn glm_normal_pvalue_two_sided(z : Double) -> Double { // Simple approximation of the survival function let p = 2.0 * (1.0 - glm_phi(abs_z)) // Clamp to avoid zero - if p < 1.0e-15 { 1.0e-15 } else { p } + if p < 1.0e-15 { + 1.0e-15 + } else { + p + } } ///| @@ -689,10 +712,21 @@ pub fn glm_phi(x : Double) -> Double { // Horner form approximation let t = 1.0 / (1.0 + 0.2316419 * abs_x) let d = 0.3989422804014327 * @math.exp(-abs_x * abs_x / 2.0) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.3302744)))) + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.3302744))) + ) let result = if sign > 0.0 { 1.0 - p } else { p } // Clamp - if result < 0.0 { 0.0 } else if result > 1.0 { 1.0 } else { result } + if result < 0.0 { + 0.0 + } else if result > 1.0 { + 1.0 + } else { + result + } } ///| @@ -727,7 +761,7 @@ pub fn glm_bh_correct_array(pvalues : Array[Double]) -> Array[Double] { for j in 0.. Unit { ///| /// Solve a linear system Ax = b using Gaussian elimination with /// partial pivoting. A is modified in place. -pub fn glm_solve_linear_system(a : Array[Array[Double]], b : Array[Double], n : Int) -> Array[Double] { +pub fn glm_solve_linear_system( + a : Array[Array[Double]], + b : Array[Double], + n : Int, +) -> Array[Double] { // Augmented matrix let aug : Array[Array[Double]] = [] for i in 0.. Array[Array[Double]] { +pub fn glm_invert_matrix( + a : Array[Array[Double]], + n : Int, +) -> Array[Array[Double]] { // Build augmented matrix [A | I] let aug : Array[Array[Double]] = [] for i in 0.. Double { min_val = data[i] } } - if min_val < 1.0e30 { min_val } else { 0.0 } + if min_val < 1.0e30 { + min_val + } else { + 0.0 + } } diff --git a/src/goa.mbt b/src/goa.mbt index 67e0da81..95311bbd 100644 --- a/src/goa.mbt +++ b/src/goa.mbt @@ -453,13 +453,12 @@ pub fn goa_parse(content : String) -> GoaDatabase { } if starts_with(line, 0, "!") { match goa_parse_header_line(line) { - Some((key, value)) => { + Some((key, value)) => if key == "gaf-version" { version = value } else if key == "generated-by" { created_by = value } - } None => () } i = i + 1 @@ -480,7 +479,10 @@ pub fn goa_parse(content : String) -> GoaDatabase { ///| /// Return all records matching the given GO ID (e.g. "GO:0003674"). -pub fn goa_filter_by_go_id(db : GoaDatabase, go_id : String) -> Array[GafRecord] { +pub fn goa_filter_by_go_id( + db : GoaDatabase, + go_id : String, +) -> Array[GafRecord] { let result : Array[GafRecord] = Array::new() let recs = db.records let mut i = 0 @@ -708,10 +710,18 @@ pub fn goa_to_summary(db : GoaDatabase) -> String { s = s + " " + code + ": " + count.to_string() + "\n" j = j + 1 } - s = s + "\nUnique GO IDs: " + goa_unique_go_ids(db).length().to_string() + "\n" - s = s + "Unique evidence codes: " + - goa_unique_evidence_codes(db).length().to_string() + "\n" - s = s + "Unique taxon IDs: " + goa_unique_taxon_ids(db).length().to_string() + "\n" + s = s + + "\nUnique GO IDs: " + + goa_unique_go_ids(db).length().to_string() + + "\n" + s = s + + "Unique evidence codes: " + + goa_unique_evidence_codes(db).length().to_string() + + "\n" + s = s + + "Unique taxon IDs: " + + goa_unique_taxon_ids(db).length().to_string() + + "\n" s } diff --git a/src/gosemsim.mbt b/src/gosemsim.mbt index f15f656a..b18aa407 100644 --- a/src/gosemsim.mbt +++ b/src/gosemsim.mbt @@ -16,23 +16,33 @@ pub enum SimMeasure { ///| /// Construct Resnik measure. -pub fn resnik_measure() -> SimMeasure { Resnik } +pub fn resnik_measure() -> SimMeasure { + Resnik +} ///| /// Construct Lin measure. -pub fn lin_measure() -> SimMeasure { Lin } +pub fn lin_measure() -> SimMeasure { + Lin +} ///| /// Construct Rel measure. -pub fn rel_measure() -> SimMeasure { Rel } +pub fn rel_measure() -> SimMeasure { + Rel +} ///| /// Construct Jiang measure. -pub fn jiang_measure() -> SimMeasure { Jiang } +pub fn jiang_measure() -> SimMeasure { + Jiang +} ///| /// Construct Wang measure. -pub fn wang_measure() -> SimMeasure { Wang } +pub fn wang_measure() -> SimMeasure { + Wang +} ///| /// A node in the GO graph. @@ -116,7 +126,7 @@ pub fn GOGraph::add_term(self : GOGraph, node : GOTermNode) -> GOGraph { self.terms.set(node.go_id, node) // Update parent's children list match self.terms.get(node.go_id) { - Some(_) => { + Some(_) => for parent_id in node.parents { match self.terms.get(parent_id) { Some(parent) => { @@ -137,7 +147,6 @@ pub fn GOGraph::add_term(self : GOGraph, node : GOTermNode) -> GOGraph { None => () } } - } None => () } GOGraph::{ root_id: self.root_id, terms: self.terms } @@ -165,22 +174,21 @@ pub fn gosemsim_term_sim( let (mica_id, mica_ic) = gosemsim_mica_ic(graph, id1, id2) match measure { Resnik => mica_ic - Lin => { + Lin => if t1.ic + t2.ic > 1.0e-10 { 2.0 * mica_ic / (t1.ic + t2.ic) } else { 0.0 } - } - Rel => { + Rel => if t1.ic + t2.ic > 1.0e-10 { let lin = 2.0 * mica_ic / (t1.ic + t2.ic) - let rel = lin * (1.0 - mica_ic / (if t1.ic > t2.ic { t1.ic } else { t2.ic })) + let rel = lin * + (1.0 - mica_ic / (if t1.ic > t2.ic { t1.ic } else { t2.ic })) rel } else { 0.0 } - } Jiang => { let common_ancestors = gosemsim_ancestors(graph, id1) let d1 = gosemsim_distance_to(graph, id1, common_ancestors) @@ -231,7 +239,7 @@ pub fn gosemsim_gen_sim( sim_matrix.push(row) i = i + 1 } - + match combine { "max" => gosemsim_matrix_max(sim_matrix) "avg" => gosemsim_matrix_avg(sim_matrix) @@ -240,16 +248,20 @@ pub fn gosemsim_gen_sim( } } +///| fn gosemsim_matrix_max(matrix : Array[Array[Double]]) -> Double { let mut max_val = 0.0 for row in matrix { for v in row { - if v > max_val { max_val = v } + if v > max_val { + max_val = v + } } } max_val } +///| fn gosemsim_matrix_avg(matrix : Array[Array[Double]]) -> Double { let mut sum = 0.0 let mut count = 0 @@ -259,13 +271,18 @@ fn gosemsim_matrix_avg(matrix : Array[Array[Double]]) -> Double { count = count + 1 } } - if count > 0 { sum / count.to_double() } else { 0.0 } + if count > 0 { + sum / count.to_double() + } else { + 0.0 + } } +///| fn gosemsim_matrix_rcmax(matrix : Array[Array[Double]]) -> Double { let n_rows = matrix.length() let n_cols = if n_rows > 0 { matrix[0].length() } else { 0 } - + // Row-wise max and column-wise max, average of the larger set let mut row_max_sum = 0.0 let mut i = 0 @@ -273,26 +290,30 @@ fn gosemsim_matrix_rcmax(matrix : Array[Array[Double]]) -> Double { let mut row_max = 0.0 let mut j = 0 while j < n_cols { - if matrix[i][j] > row_max { row_max = matrix[i][j] } + if matrix[i][j] > row_max { + row_max = matrix[i][j] + } j = j + 1 } row_max_sum = row_max_sum + row_max i = i + 1 } - + let mut col_max_sum = 0.0 let mut j = 0 while j < n_cols { let mut col_max = 0.0 let mut i2 = 0 while i2 < n_rows { - if matrix[i2][j] > col_max { col_max = matrix[i2][j] } + if matrix[i2][j] > col_max { + col_max = matrix[i2][j] + } i2 = i2 + 1 } col_max_sum = col_max_sum + col_max j = j + 1 } - + let n = if n_rows > n_cols { n_rows } else { n_cols } if n > 0 { (row_max_sum + col_max_sum) / (2.0 * n.to_double()) @@ -303,33 +324,36 @@ fn gosemsim_matrix_rcmax(matrix : Array[Array[Double]]) -> Double { ///| /// Find the Most Informative Common Ancestor (MICA) and its IC. -fn gosemsim_mica_ic(graph : GOGraph, id1 : String, id2 : String) -> (String, Double) { +fn gosemsim_mica_ic( + graph : GOGraph, + id1 : String, + id2 : String, +) -> (String, Double) { let anc1 = gosemsim_ancestors(graph, id1) let anc2 = gosemsim_ancestors(graph, id2) - + // Find common ancestors let seen : Map[String, Bool] = Map([], capacity=anc1.length()) for a in anc1 { seen.set(a, true) } - + let mut best_id = "" let mut best_ic = -1.0 - + for a in anc2 { if seen.get_or_default(a, false) { match graph.get_term(a) { - Some(term) => { + Some(term) => if term.ic > best_ic { best_ic = term.ic best_id = a } - } None => () } } } - + if best_ic < 0.0 { (graph.root_id, 0.0) } else { @@ -346,6 +370,7 @@ fn gosemsim_ancestors(graph : GOGraph, go_id : String) -> Array[String] { ancestors } +///| fn gosemsim_ancestors_recursive( graph : GOGraph, go_id : String, @@ -359,33 +384,36 @@ fn gosemsim_ancestors_recursive( ancestors.push(go_id) match graph.get_term(go_id) { - Some(term) => { + Some(term) => for parent in term.parents { gosemsim_ancestors_recursive(graph, parent, ancestors, visited) } - } None => () } } ///| /// Compute path distance to a common ancestor set. -fn gosemsim_distance_to(graph : GOGraph, go_id : String, ancestors : Array[String]) -> Double { +fn gosemsim_distance_to( + graph : GOGraph, + go_id : String, + ancestors : Array[String], +) -> Double { // Simple BFS to find shortest path to any ancestor if ancestors.length() == 0 { return 0.0 } - + let target_set : Map[String, Bool] = Map([], capacity=ancestors.length()) for a in ancestors { target_set.set(a, true) } - + let mut current : Array[(String, Double)] = Array::new() let visited : Map[String, Bool] = Map([], capacity=64) current.push((go_id, 0.0)) visited.set(go_id, true) - + let mut found = false while current.length() > 0 { let (node_id, dist) = current[0] @@ -396,26 +424,29 @@ fn gosemsim_distance_to(graph : GOGraph, go_id : String, ancestors : Array[Strin i = i + 1 } current = rest - + if target_set.get_or_default(node_id, false) { found = true return dist } - + match graph.get_term(node_id) { - Some(term) => { + Some(term) => for parent in term.parents { if !visited.get_or_default(parent, false) { visited.set(parent, true) current.push((parent, dist + 1.0)) } } - } None => () } } - - if found { 0.0 } else { 100.0 } + + if found { + 0.0 + } else { + 100.0 + } } ///| @@ -429,7 +460,9 @@ fn gosemsim_wang_score(graph : GOGraph, go_id : String) -> Double { // Score based on depth from root score = score + 1.0 let mut parent_count = term.parents.length().to_double() - if parent_count < 1.0 { parent_count = 1.0 } + if parent_count < 1.0 { + parent_count = 1.0 + } score = score + 1.0 / parent_count } None => () @@ -440,15 +473,19 @@ fn gosemsim_wang_score(graph : GOGraph, go_id : String) -> Double { ///| /// Compute Wang common score (overlap of ancestor sets). -fn gosemsim_wang_common_score(graph : GOGraph, id1 : String, id2 : String) -> Double { +fn gosemsim_wang_common_score( + graph : GOGraph, + id1 : String, + id2 : String, +) -> Double { let anc1 = gosemsim_ancestors(graph, id1) let anc2 = gosemsim_ancestors(graph, id2) - + let set1 : Map[String, Bool] = Map([], capacity=anc1.length()) for a in anc1 { set1.set(a, true) } - + let mut score = 0.0 for anc_id in anc2 { if set1.get_or_default(anc_id, false) { @@ -456,7 +493,9 @@ fn gosemsim_wang_common_score(graph : GOGraph, id1 : String, id2 : String) -> Do match graph.get_term(anc_id) { Some(term) => { let mut parent_count = term.parents.length().to_double() - if parent_count < 1.0 { parent_count = 1.0 } + if parent_count < 1.0 { + parent_count = 1.0 + } score = score + 1.0 / parent_count } None => () @@ -471,13 +510,69 @@ fn gosemsim_wang_common_score(graph : GOGraph, id1 : String, id2 : String) -> Do pub fn gosemsim_example_graph() -> GOGraph { let g = GOGraph::new() let g1 = g.add_root("GO:0008150") - let g2 = g1.add_term(GOTermNode::new("GO:0008150", ic=0.0, parents=[], term_name="biological_process")) - let g3 = g2.add_term(GOTermNode::new("GO:0050896", ic=0.3, parents=["GO:0008150"], term_name="response to stimulus")) - let g4 = g3.add_term(GOTermNode::new("GO:0009987", ic=0.5, parents=["GO:0050896"], term_name="cellular process")) - let g5 = g4.add_term(GOTermNode::new("GO:0006810", ic=0.7, parents=["GO:0009987"], term_name="transport")) - let g6 = g3.add_term(GOTermNode::new("GO:0023046", ic=0.4, parents=["GO:0050896"], term_name="signaling")) - let g7 = g6.add_term(GOTermNode::new("GO:0007165", ic=0.6, parents=["GO:0023046"], term_name="signal transduction")) - let g8 = g2.add_term(GOTermNode::new("GO:0009058", ic=0.2, parents=["GO:0008150"], term_name="biosynthetic process")) - let g9 = g8.add_term(GOTermNode::new("GO:0010467", ic=0.35, parents=["GO:0009058"], term_name="gene expression")) + let g2 = g1.add_term( + GOTermNode::new( + "GO:0008150", + ic=0.0, + parents=[], + term_name="biological_process", + ), + ) + let g3 = g2.add_term( + GOTermNode::new( + "GO:0050896", + ic=0.3, + parents=["GO:0008150"], + term_name="response to stimulus", + ), + ) + let g4 = g3.add_term( + GOTermNode::new( + "GO:0009987", + ic=0.5, + parents=["GO:0050896"], + term_name="cellular process", + ), + ) + let g5 = g4.add_term( + GOTermNode::new( + "GO:0006810", + ic=0.7, + parents=["GO:0009987"], + term_name="transport", + ), + ) + let g6 = g3.add_term( + GOTermNode::new( + "GO:0023046", + ic=0.4, + parents=["GO:0050896"], + term_name="signaling", + ), + ) + let g7 = g6.add_term( + GOTermNode::new( + "GO:0007165", + ic=0.6, + parents=["GO:0023046"], + term_name="signal transduction", + ), + ) + let g8 = g2.add_term( + GOTermNode::new( + "GO:0009058", + ic=0.2, + parents=["GO:0008150"], + term_name="biosynthetic process", + ), + ) + let g9 = g8.add_term( + GOTermNode::new( + "GO:0010467", + ic=0.35, + parents=["GO:0009058"], + term_name="gene expression", + ), + ) g9 } diff --git a/src/graphics.mbt b/src/graphics.mbt index 8d8b496d..4ffbb7e9 100644 --- a/src/graphics.mbt +++ b/src/graphics.mbt @@ -13,12 +13,7 @@ pub struct SeqLogo { ///| pub fn SeqLogo::new(sequences : Array[String]) -> SeqLogo { - SeqLogo::{ - sequences, - height: 50, - width: 400, - colors: get_default_colors() - } + SeqLogo::{ sequences, height: 50, width: 400, colors: get_default_colors() } } ///| @@ -35,7 +30,7 @@ pub fn LogoColumn::new(position : Int) -> LogoColumn { position, letter_frequencies: Map([], capacity=4), information_content: 0.0, - letters: Array::new() + letters: Array::new(), } } @@ -53,7 +48,7 @@ pub fn AlignmentPlot::new(sequences : Array[(String, String)]) -> AlignmentPlot sequences, highlight_regions: Array::new(), consensus: "", - show_consensus: true + show_consensus: true, } } @@ -65,26 +60,25 @@ pub struct FeaturePlot { } ///| -pub fn FeaturePlot::new(features : Array[(String, Int, Int, String, String)], sequence_length : Int) -> FeaturePlot { - FeaturePlot::{ - features, - sequence_length, - colors: get_feature_colors() - } +pub fn FeaturePlot::new( + features : Array[(String, Int, Int, String, String)], + sequence_length : Int, +) -> FeaturePlot { + FeaturePlot::{ features, sequence_length, colors: get_feature_colors() } } ///| pub fn get_default_colors() -> Map[String, String] { let colors = Map([], capacity=20) - + colors.set("A", "#FF0000") colors.set("T", "#0000FF") colors.set("C", "#00FF00") colors.set("G", "#FFA500") - + colors.set("N", "#808080") colors.set("-", "#CCCCCC") - + colors.set("R", "#FF0000") colors.set("K", "#FF0000") colors.set("D", "#0000FF") @@ -105,14 +99,14 @@ pub fn get_default_colors() -> Map[String, String] { colors.set("F", "#808080") colors.set("W", "#808080") colors.set("C", "#808080") - + colors } ///| pub fn get_feature_colors() -> Map[String, String] { let colors = Map([], capacity=10) - + colors.set("exon", "#FF6B6B") colors.set("intron", "#4ECDC4") colors.set("CDS", "#45B7D1") @@ -123,30 +117,33 @@ pub fn get_feature_colors() -> Map[String, String] { colors.set("repeat", "#98D8C8") colors.set("gene", "#F7DC6F") colors.set("misc", "#BB8FCE") - + colors } ///| -pub fn seqlogo_calculate_columns(sequences : Array[String]) -> Array[LogoColumn] { +pub fn seqlogo_calculate_columns( + sequences : Array[String], +) -> Array[LogoColumn] { let columns : Array[LogoColumn] = Array::new() - + if sequences.length() == 0 { return columns } - + let seq_len = sequences[0].length() let n_seqs = sequences.length() - + let mut pos = 0 while pos < seq_len { let col = LogoColumn::new(pos + 1) let freqs = col.letter_frequencies.copy() - - let counts = Map([ - ("A", 0), ("T", 0), ("C", 0), ("G", 0), ("N", 0) - ], capacity=5) - + + let counts = Map( + [("A", 0), ("T", 0), ("C", 0), ("G", 0), ("N", 0)], + capacity=5, + ) + let mut seq_idx = 0 while seq_idx < n_seqs { if pos < sequences[seq_idx].length() { @@ -159,7 +156,7 @@ pub fn seqlogo_calculate_columns(sequences : Array[String]) -> Array[LogoColumn] } seq_idx = seq_idx + 1 } - + let mut total = 0 let count_keys = counts.keys().collect() let mut i = 0 @@ -167,26 +164,26 @@ pub fn seqlogo_calculate_columns(sequences : Array[String]) -> Array[LogoColumn] total = total + counts.get(count_keys[i]).unwrap() i = i + 1 } - + if total > 0 { let mut ic = 0.0 let ic_max = @math.log2(n_seqs.to_double()) - + let mut j = 0 while j < count_keys.length() { let key = count_keys[j] let count = counts.get(key).unwrap() let freq = count.to_double() / total.to_double() freqs.set(key, freq) - + if freq > 0.0 { ic = ic - freq * @math.log2(freq) } j = j + 1 } - + let info_content = ic / ic_max * ic_max - + let sorted_letters : Array[(String, Double)] = Array::new() let mut k = 0 while k < count_keys.length() { @@ -196,7 +193,7 @@ pub fn seqlogo_calculate_columns(sequences : Array[String]) -> Array[LogoColumn] } k = k + 1 } - + let mut l = 0 while l < sorted_letters.length() - 1 { let mut m = l + 1 @@ -210,7 +207,7 @@ pub fn seqlogo_calculate_columns(sequences : Array[String]) -> Array[LogoColumn] } l = l + 1 } - + let letters : Array[(String, Double, Double)] = Array::new() let mut cum_height = 0.0 let mut n = 0 @@ -220,30 +217,30 @@ pub fn seqlogo_calculate_columns(sequences : Array[String]) -> Array[LogoColumn] cum_height = cum_height + height n = n + 1 } - + columns.push(LogoColumn::{ position: pos + 1, letter_frequencies: freqs, information_content: info_content, - letters: letters + letters, }) } - + pos = pos + 1 } - + columns } ///| pub fn seqlogo_generate_ascii(logo : SeqLogo) -> String { let columns = seqlogo_calculate_columns(logo.sequences) - + let mut output = "" - + let max_ic = @math.log2(logo.sequences.length().to_double()) let scale = logo.height.to_double() / max_ic - + let mut row = logo.height - 1 while row >= 0 { let mut line = "" @@ -256,8 +253,9 @@ pub fn seqlogo_generate_ascii(logo : SeqLogo) -> String { let (letter, start, height) = col.letters[letter_idx] let scaled_start = start * scale let scaled_height = height * scale - - if row.to_double() >= scaled_start && row.to_double() < scaled_start + scaled_height { + + if row.to_double() >= scaled_start && + row.to_double() < scaled_start + scaled_height { line = line + letter found = true break @@ -274,7 +272,7 @@ pub fn seqlogo_generate_ascii(logo : SeqLogo) -> String { } row = row - 1 } - + output = output + "Position: " let mut pos = 0 while pos < columns.length() { @@ -282,23 +280,23 @@ pub fn seqlogo_generate_ascii(logo : SeqLogo) -> String { pos = pos + 1 } output = output + "\n" - + output } ///| pub fn alignment_plot_generate_ascii(plot : AlignmentPlot) -> String { let mut output = "" - + if plot.show_consensus { let consensus = graphics_calculate_consensus(plot.sequences) output = output + "Consensus: " + consensus + "\n\n" } - + let mut seq_idx = 0 while seq_idx < plot.sequences.length() { let (name, seq) = plot.sequences[seq_idx] - + let mut line = "" if name.length() > 12 { line = line + substring(name, 0, 12) @@ -312,10 +310,10 @@ pub fn alignment_plot_generate_ascii(plot : AlignmentPlot) -> String { } line = line + " " + seq + "\n" output = output + line - + seq_idx = seq_idx + 1 } - + output } @@ -324,18 +322,19 @@ fn graphics_calculate_consensus(sequences : Array[(String, String)]) -> String { if sequences.length() == 0 { return "" } - + let seq_len = sequences[0].1.length() let n_seqs = sequences.length() - + let mut consensus = "" - + let mut pos = 0 while pos < seq_len { - let counts = Map([ - ("A", 0), ("T", 0), ("C", 0), ("G", 0), ("-", 0) - ], capacity=5) - + let counts = Map( + [("A", 0), ("T", 0), ("C", 0), ("G", 0), ("-", 0)], + capacity=5, + ) + let mut seq_idx = 0 while seq_idx < n_seqs { if pos < sequences[seq_idx].1.length() { @@ -346,7 +345,7 @@ fn graphics_calculate_consensus(sequences : Array[(String, String)]) -> String { } seq_idx = seq_idx + 1 } - + let mut max_count = 0 let mut max_base = "N" let count_keys = counts.keys().collect() @@ -360,20 +359,23 @@ fn graphics_calculate_consensus(sequences : Array[(String, String)]) -> String { } i = i + 1 } - + consensus = consensus + max_base pos = pos + 1 } - + consensus } ///| pub fn feature_plot_generate_ascii(plot : FeaturePlot) -> String { let mut output = "" - - output = output + "Sequence length: " + plot.sequence_length.to_string() + "\n\n" - + + output = output + + "Sequence length: " + + plot.sequence_length.to_string() + + "\n\n" + output = output + "Legend:\n" let color_keys = plot.colors.keys().collect() let mut i = 0 @@ -383,7 +385,7 @@ pub fn feature_plot_generate_ascii(plot : FeaturePlot) -> String { i = i + 1 } output = output + "\n" - + output = output + "Feature track:\n" output = output + "|" let mut pos = 0 @@ -396,11 +398,11 @@ pub fn feature_plot_generate_ascii(plot : FeaturePlot) -> String { pos = pos + 1 } output = output + "|\n" - + let mut feat_idx = 0 while feat_idx < plot.features.length() { let (name, start, end, feat_type, strand) = plot.features[feat_idx] - + let mut line = "" let mut pos = 0 while pos < plot.sequence_length { @@ -411,39 +413,33 @@ pub fn feature_plot_generate_ascii(plot : FeaturePlot) -> String { } pos = pos + 1 } - + let strand_sym = if strand == "-" { "<-" } else { "->" } output = output + strand_sym + " [" + name + "] " + line + "\n" - + feat_idx = feat_idx + 1 } - + output = output + "\nPositions: 0" pos = 0 while pos <= plot.sequence_length { if pos % 20 == 0 && pos > 0 { - output = output + " ".repeat(pos.to_string().length() - 1) + pos.to_string() + output = output + + " ".repeat(pos.to_string().length() - 1) + + pos.to_string() } pos = pos + 1 } output = output + "\n" - + output } ///| pub fn create_example_seqlogo() -> SeqLogo { let seqs = [ - "ATGCCGTAA", - "ATGCCGTAA", - "ATGCCGTAA", - "ATGCCGTAA", - "ATGCCGTAA", - "ATGCCGTAA", - "ATGCCGTAA", - "ATGCCGTAA", - "ATGCCGTAA", - "ATGCCGTAA" + "ATGCCGTAA", "ATGCCGTAA", "ATGCCGTAA", "ATGCCGTAA", "ATGCCGTAA", "ATGCCGTAA", + "ATGCCGTAA", "ATGCCGTAA", "ATGCCGTAA", "ATGCCGTAA", ] SeqLogo::new(seqs) } @@ -454,7 +450,7 @@ pub fn create_example_alignment_plot() -> AlignmentPlot { ("Human", "ATGGCCGGTAAATGA"), ("Mouse", "ATGGCCGGTAAATGA"), ("Rat", "ATGGCCGGTAATAGA"), - ("Chicken", "ATGGCCGGTAATGGA") + ("Chicken", "ATGGCCGGTAATGGA"), ] AlignmentPlot::new(seqs) } @@ -468,7 +464,7 @@ pub fn create_example_feature_plot() -> FeaturePlot { ("Exon2", 70, 100, "exon", "+"), ("Promoter", -20, 0, "promoter", "+"), ("GeneB", 150, 250, "gene", "-"), - ("CDS", 160, 240, "CDS", "-") + ("CDS", 160, 240, "CDS", "-"), ] FeaturePlot::new(features, 300) -} \ No newline at end of file +} diff --git a/src/gsea_base.mbt b/src/gsea_base.mbt index 69ecbfbe..774a9f09 100644 --- a/src/gsea_base.mbt +++ b/src/gsea_base.mbt @@ -21,13 +21,14 @@ fn gs_str_lower(s : String) -> String { None => () } } else { - result = result + s[i:i+1].to_owned() + result = result + s[i:i + 1].to_owned() } i = i + 1 } result } +///| fn gs_str_upper(s : String) -> String { let mut result = "" let mut i = 0 @@ -41,13 +42,14 @@ fn gs_str_upper(s : String) -> String { None => () } } else { - result = result + s[i:i+1].to_owned() + result = result + s[i:i + 1].to_owned() } i = i + 1 } result } +///| fn gs_trim(s : String) -> String { let mut start = 0 let n = s.length() @@ -68,9 +70,14 @@ fn gs_trim(s : String) -> String { break } } - if start == 0 && end == n { s } else { s[start:end].to_owned() } + if start == 0 && end == n { + s + } else { + s[start:end].to_owned() + } } +///| fn gs_split(s : String, sep_u16 : UInt16) -> Array[String] { let out : Array[String] = Array::new() let mut buf = StringBuilder::new() @@ -96,6 +103,7 @@ fn gs_split(s : String, sep_u16 : UInt16) -> Array[String] { // ---- types ----------------------------------------------------------------- +///| pub enum GeneSetCollectionType { GO_BiologicalProcess GO_MolecularFunction @@ -110,13 +118,20 @@ pub enum GeneSetCollectionType { Other } +///| pub fn GeneSetCollectionType::from_string(s : String) -> GeneSetCollectionType { let sl = gs_str_lower(s) - if sl.has_prefix("go_bp") || sl.has_prefix("bp") || sl.contains("biological_process") { + if sl.has_prefix("go_bp") || + sl.has_prefix("bp") || + sl.contains("biological_process") { GO_BiologicalProcess - } else if sl.has_prefix("go_mf") || sl.has_prefix("mf") || sl.contains("molecular_function") { + } else if sl.has_prefix("go_mf") || + sl.has_prefix("mf") || + sl.contains("molecular_function") { GO_MolecularFunction - } else if sl.has_prefix("go_cc") || sl.has_prefix("cc") || sl.contains("cellular_component") { + } else if sl.has_prefix("go_cc") || + sl.has_prefix("cc") || + sl.contains("cellular_component") { GO_CellularComponent } else if sl.has_prefix("kegg") { KEGG @@ -137,6 +152,7 @@ pub fn GeneSetCollectionType::from_string(s : String) -> GeneSetCollectionType { } } +///| pub fn GeneSetCollectionType::show(self : GeneSetCollectionType) -> String { let s = match self { GO_BiologicalProcess => "GO_BiologicalProcess" @@ -154,6 +170,7 @@ pub fn GeneSetCollectionType::show(self : GeneSetCollectionType) -> String { s.to_string() } +///| pub struct GmtGeneSet { pub name : String pub description : String @@ -163,6 +180,7 @@ pub struct GmtGeneSet { pub mut id : String } +///| pub fn GmtGeneSet::new( name : String, description : String, @@ -172,11 +190,16 @@ pub fn GmtGeneSet::new( let seen : Array[String] = Array::new() for x in gene_ids { let t = gs_trim(x) - if t.length() == 0 { continue } + if t.length() == 0 { + continue + } let mut already = false let upper = gs_str_upper(t) for s in seen { - if s == upper { already = true; break } + if s == upper { + already = true + break + } } if !already { seen.push(upper) @@ -184,8 +207,8 @@ pub fn GmtGeneSet::new( } } GmtGeneSet::{ - name: name, - description: description, + name, + description, gene_ids: uniq, collection_type: Other, organism: "unknown".to_string(), @@ -193,6 +216,7 @@ pub fn GmtGeneSet::new( } } +///| pub fn GmtGeneSet::with_annotation( name : String, description : String, @@ -208,44 +232,64 @@ pub fn GmtGeneSet::with_annotation( gs } +///| pub fn GmtGeneSet::size(self : GmtGeneSet) -> Int { self.gene_ids.length() } +///| pub fn GmtGeneSet::has_gene(self : GmtGeneSet, gene : String) -> Bool { let gu = gs_str_upper(gs_trim(gene)) for g in self.gene_ids { - if gs_str_upper(g) == gu { return true } + if gs_str_upper(g) == gu { + return true + } } false } // ---- set math -------------------------------------------------------------- +///| pub fn gene_set_overlap(a : GmtGeneSet, b : GmtGeneSet) -> Int { let mut cnt = 0 for g in a.gene_ids { - if b.has_gene(g) { cnt = cnt + 1 } + if b.has_gene(g) { + cnt = cnt + 1 + } } cnt } +///| pub fn gene_set_jaccard(a : GmtGeneSet, b : GmtGeneSet) -> Double { let ov = gene_set_overlap(a, b).to_double() let asz = a.gene_ids.length().to_double() let bsz = b.gene_ids.length().to_double() let un = asz + bsz - ov - if un == 0.0 { 0.0 } else { ov / un } + if un == 0.0 { + 0.0 + } else { + ov / un + } } +///| pub fn gene_set_overlap_coef(a : GmtGeneSet, b : GmtGeneSet) -> Double { let ov = gene_set_overlap(a, b) let mut asz = a.gene_ids.length() let bsz = b.gene_ids.length() - if asz > bsz { asz = bsz } - if asz == 0 { 0.0 } else { ov.to_double() / asz.to_double() } + if asz > bsz { + asz = bsz + } + if asz == 0 { + 0.0 + } else { + ov.to_double() / asz.to_double() + } } +///| pub fn gene_set_union_arr(a : GmtGeneSet, b : GmtGeneSet) -> Array[String] { let out : Array[String] = Array::new() let seen : Array[String] = Array::new() @@ -253,7 +297,10 @@ pub fn gene_set_union_arr(a : GmtGeneSet, b : GmtGeneSet) -> Array[String] { let u = gs_str_upper(g) let mut f = false for s in seen { - if s == u { f = true; break } + if s == u { + f = true + break + } } if !f { seen.push(u) @@ -264,7 +311,10 @@ pub fn gene_set_union_arr(a : GmtGeneSet, b : GmtGeneSet) -> Array[String] { let u = gs_str_upper(g) let mut f = false for s in seen { - if s == u { f = true; break } + if s == u { + f = true + break + } } if !f { seen.push(u) @@ -274,68 +324,88 @@ pub fn gene_set_union_arr(a : GmtGeneSet, b : GmtGeneSet) -> Array[String] { out } +///| pub fn gene_set_intersect_arr(a : GmtGeneSet, b : GmtGeneSet) -> Array[String] { let out : Array[String] = Array::new() for g in a.gene_ids { - if b.has_gene(g) { out.push(g) } + if b.has_gene(g) { + out.push(g) + } } out } +///| pub fn gene_set_setdiff(a : GmtGeneSet, b : GmtGeneSet) -> Array[String] { let out : Array[String] = Array::new() for g in a.gene_ids { - if !b.has_gene(g) { out.push(g) } + if !b.has_gene(g) { + out.push(g) + } } out } // ---- collection ------------------------------------------------------------ +///| pub struct GmtGeneSetCollection { pub sets : Array[GmtGeneSet] pub names : Array[String] pub mut size : Int } -pub fn GmtGeneSetCollection::new(sets : Array[GmtGeneSet]) -> GmtGeneSetCollection { +///| +pub fn GmtGeneSetCollection::new( + sets : Array[GmtGeneSet], +) -> GmtGeneSetCollection { let names : Array[String] = Array::new() for s in sets { names.push(s.name) } - GmtGeneSetCollection::{ - sets: sets, - names: names, - size: sets.length(), - } + GmtGeneSetCollection::{ sets, names, size: sets.length() } } +///| pub fn GmtGeneSetCollection::by_name( self : GmtGeneSetCollection, name : String, -) -> Option[GmtGeneSet] { +) -> GmtGeneSet? { let n = self.sets.length() let mut i = 0 while i < n { - if self.sets[i].name == name { return Some(self.sets[i]) } + if self.sets[i].name == name { + return Some(self.sets[i]) + } i = i + 1 } None } +///| pub fn GmtGeneSetCollection::at( self : GmtGeneSetCollection, i : Int, -) -> Option[GmtGeneSet] { - if i < 0 || i >= self.sets.length() { None } else { Some(self.sets[i]) } +) -> GmtGeneSet? { + if i < 0 || i >= self.sets.length() { + None + } else { + Some(self.sets[i]) + } } -pub fn GmtGeneSetCollection::all_sizes(self : GmtGeneSetCollection) -> Array[Int] { +///| +pub fn GmtGeneSetCollection::all_sizes( + self : GmtGeneSetCollection, +) -> Array[Int] { let out : Array[Int] = Array::new() - for s in self.sets { out.push(s.size()) } + for s in self.sets { + out.push(s.size()) + } out } +///| pub fn GmtGeneSetCollection::push_s( self : GmtGeneSetCollection, gs : GmtGeneSet, @@ -347,17 +417,24 @@ pub fn GmtGeneSetCollection::push_s( col } +///| pub fn GmtGeneSetCollection::summary(self : GmtGeneSetCollection) -> String { let buf = StringBuilder::new() buf.write_string("GmtGeneSetCollection: \{self.size} sets\n") - if self.size == 0 { return buf.to_string() } + if self.size == 0 { + return buf.to_string() + } let mut min_sz = self.sets[0].size() let mut max_sz = self.sets[0].size() let mut sum_sz = 0 for s in self.sets { let sz = s.size() - if sz < min_sz { min_sz = sz } - if sz > max_sz { max_sz = sz } + if sz < min_sz { + min_sz = sz + } + if sz > max_sz { + max_sz = sz + } sum_sz = sum_sz + sz } let avg = sum_sz.to_double() / self.size.to_double() @@ -375,6 +452,7 @@ pub fn GmtGeneSetCollection::summary(self : GmtGeneSetCollection) -> String { buf.to_string() } +///| pub fn collection_filter_by_size( col : GmtGeneSetCollection, min_size : Int, @@ -383,11 +461,14 @@ pub fn collection_filter_by_size( let kept : Array[GmtGeneSet] = Array::new() for s in col.sets { let sz = s.size() - if sz >= min_size && sz <= max_size { kept.push(s) } + if sz >= min_size && sz <= max_size { + kept.push(s) + } } GmtGeneSetCollection::new(kept) } +///| pub fn collection_filter_by_gene( col : GmtGeneSetCollection, gene_universe : Array[String], @@ -419,6 +500,7 @@ pub fn collection_filter_by_gene( GmtGeneSetCollection::new(kept) } +///| pub fn collection_gene_union(col : GmtGeneSetCollection) -> Array[String] { let out : Array[String] = Array::new() let seen : Array[String] = Array::new() @@ -427,7 +509,10 @@ pub fn collection_gene_union(col : GmtGeneSetCollection) -> Array[String] { let u = gs_str_upper(g) let mut f = false for s2 in seen { - if s2 == u { f = true; break } + if s2 == u { + f = true + break + } } if !f { seen.push(u) @@ -438,6 +523,7 @@ pub fn collection_gene_union(col : GmtGeneSetCollection) -> Array[String] { out } +///| pub fn collection_pairwise_jaccard( col : GmtGeneSetCollection, ) -> Array[Array[Double]] { @@ -464,6 +550,7 @@ pub fn collection_pairwise_jaccard( // ---- GMT I/O --------------------------------------------------------------- +///| pub fn parse_gmt(content : String) -> GmtGeneSetCollection { let lines = gs_split(content, '\n'.to_int().to_uint16()) let result : Array[GmtGeneSet] = Array::new() @@ -472,11 +559,23 @@ pub fn parse_gmt(content : String) -> GmtGeneSetCollection { while idx < n { let raw_line = lines[idx] let line = gs_trim(raw_line) - if line.length() == 0 { idx = idx + 1; continue } - if line.has_prefix("#") { idx = idx + 1; continue } - if line.has_prefix("!") { idx = idx + 1; continue } + if line.length() == 0 { + idx = idx + 1 + continue + } + if line.has_prefix("#") { + idx = idx + 1 + continue + } + if line.has_prefix("!") { + idx = idx + 1 + continue + } let parts = gs_split(line, '\t'.to_int().to_uint16()) - if parts.length() < 3 { idx = idx + 1; continue } + if parts.length() < 3 { + idx = idx + 1 + continue + } let name = gs_trim(parts[0]) let desc = gs_trim(parts[1]) let genes : Array[String] = Array::new() @@ -484,7 +583,9 @@ pub fn parse_gmt(content : String) -> GmtGeneSetCollection { let mut i = 2 while i < plen { let g = gs_trim(parts[i]) - if g.length() > 0 { genes.push(g) } + if g.length() > 0 { + genes.push(g) + } i = i + 1 } if name.length() > 0 && genes.length() > 0 { @@ -495,6 +596,7 @@ pub fn parse_gmt(content : String) -> GmtGeneSetCollection { GmtGeneSetCollection::new(result) } +///| pub fn write_gmt(col : GmtGeneSetCollection) -> String { let buf = StringBuilder::new() for gs in col.sets { @@ -512,17 +614,24 @@ pub fn write_gmt(col : GmtGeneSetCollection) -> String { // ---- GMX I/O --------------------------------------------------------------- +///| pub fn parse_gmx(content : String) -> GmtGeneSetCollection { let tab16 = '\t'.to_int().to_uint16() let lines = gs_split(content, '\n'.to_int().to_uint16()) let nonblank : Array[Array[String]] = Array::new() for raw in lines { let line = gs_trim(raw) - if line.length() == 0 { continue } - if line.has_prefix("#") { continue } + if line.length() == 0 { + continue + } + if line.has_prefix("#") { + continue + } nonblank.push(gs_split(line, tab16)) } - if nonblank.length() < 2 { return GmtGeneSetCollection::new([]) } + if nonblank.length() < 2 { + return GmtGeneSetCollection::new([]) + } let headers = nonblank[0] let descs = nonblank[1] let n_sets = headers.length() @@ -537,9 +646,15 @@ pub fn parse_gmx(content : String) -> GmtGeneSetCollection { let row = nonblank[row_i] let mut j = 0 while j < n_sets { - if j >= row.length() { j = j + 1; continue } + if j >= row.length() { + j = j + 1 + continue + } let cell = gs_trim(row[j]) - if cell.length() == 0 { j = j + 1; continue } + if cell.length() == 0 { + j = j + 1 + continue + } set_genes[j].push(cell) j = j + 1 } @@ -549,42 +664,60 @@ pub fn parse_gmx(content : String) -> GmtGeneSetCollection { let mut j = 0 while j < n_sets { let nm = gs_trim(headers[j]) - if nm.length() == 0 { j = j + 1; continue } - let desc = if j < descs.length() { gs_trim(descs[j]) } else { "".to_string() } + if nm.length() == 0 { + j = j + 1 + continue + } + let desc = if j < descs.length() { + gs_trim(descs[j]) + } else { + "".to_string() + } result.push(GmtGeneSet::new(nm, desc, set_genes[j])) j = j + 1 } GmtGeneSetCollection::new(result) } +///| pub fn write_gmx(col : GmtGeneSetCollection) -> String { let buf = StringBuilder::new() let n = col.sets.length() let mut i = 0 while i < n { - if i > 0 { buf.write_char('\t') } + if i > 0 { + buf.write_char('\t') + } buf.write_string(col.sets[i].name) i = i + 1 } buf.write_char('\n') let mut i2 = 0 while i2 < n { - if i2 > 0 { buf.write_char('\t') } + if i2 > 0 { + buf.write_char('\t') + } buf.write_string(col.sets[i2].description) i2 = i2 + 1 } buf.write_char('\n') let mut max_len = 0 for s in col.sets { - if s.gene_ids.length() > max_len { max_len = s.gene_ids.length() } + if s.gene_ids.length() > max_len { + max_len = s.gene_ids.length() + } } let mut r = 0 while r < max_len { let mut i3 = 0 while i3 < n { - if i3 > 0 { buf.write_char('\t') } + if i3 > 0 { + buf.write_char('\t') + } let genes = col.sets[i3].gene_ids - if r < genes.length() { buf.write_string(genes[r]) } + if r < genes.length() { + buf.write_string(genes[r]) + } i3 = i3 + 1 } buf.write_char('\n') @@ -595,6 +728,7 @@ pub fn write_gmx(col : GmtGeneSetCollection) -> String { // ---- interop helper: build simple name+genes pair record (plain data) ----- +///| pub fn gsea_as_plain_name_genes(gs : GmtGeneSet) -> (String, Array[String]) { (gs.name, gs.gene_ids) } diff --git a/src/gsva.mbt b/src/gsva.mbt index f5bb55f0..4ab8717e 100644 --- a/src/gsva.mbt +++ b/src/gsva.mbt @@ -1318,23 +1318,23 @@ pub fn gsva_create_example_data() -> GSVAData { let genes : Array[String] = Array::new() let samples : Array[String] = Array::new() let expression : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < 100 { - genes.push(("Gene".to_string() + i.to_string())) + genes.push("Gene".to_string() + i.to_string()) let row : Array[Double] = Array::new() let mut j = 0 while j < 10 { - row.push(((i % 10) - 5).to_double() + j.to_double() * 0.1) + row.push((i % 10 - 5).to_double() + j.to_double() * 0.1) j = j + 1 } expression.push(row) i = i + 1 } - + i = 0 while i < 10 { - samples.push(("Sample".to_string() + i.to_string())) + samples.push("Sample".to_string() + i.to_string()) i = i + 1 } @@ -1347,27 +1347,42 @@ pub fn gsva_create_example_gene_sets() -> Array[GSVAGeneSet] { [ GSVAGeneSet::new( "CELL_CYCLE", - ["Gene0", "Gene1", "Gene2", "Gene3", "Gene4", "Gene5", "Gene6", "Gene7", "Gene8", "Gene9"], + [ + "Gene0", "Gene1", "Gene2", "Gene3", "Gene4", "Gene5", "Gene6", "Gene7", "Gene8", + "Gene9", + ], "Cell cycle related genes", ), GSVAGeneSet::new( "APOPTOSIS", - ["Gene10", "Gene11", "Gene12", "Gene13", "Gene14", "Gene15", "Gene16", "Gene17", "Gene18", "Gene19"], + [ + "Gene10", "Gene11", "Gene12", "Gene13", "Gene14", "Gene15", "Gene16", "Gene17", + "Gene18", "Gene19", + ], "Apoptosis related genes", ), GSVAGeneSet::new( "METABOLISM", - ["Gene20", "Gene21", "Gene22", "Gene23", "Gene24", "Gene25", "Gene26", "Gene27", "Gene28", "Gene29"], + [ + "Gene20", "Gene21", "Gene22", "Gene23", "Gene24", "Gene25", "Gene26", "Gene27", + "Gene28", "Gene29", + ], "Metabolism related genes", ), GSVAGeneSet::new( "IMMUNE", - ["Gene30", "Gene31", "Gene32", "Gene33", "Gene34", "Gene35", "Gene36", "Gene37", "Gene38", "Gene39"], + [ + "Gene30", "Gene31", "Gene32", "Gene33", "Gene34", "Gene35", "Gene36", "Gene37", + "Gene38", "Gene39", + ], "Immune related genes", ), GSVAGeneSet::new( "STEM", - ["Gene40", "Gene41", "Gene42", "Gene43", "Gene44", "Gene45", "Gene46", "Gene47", "Gene48", "Gene49"], + [ + "Gene40", "Gene41", "Gene42", "Gene43", "Gene44", "Gene45", "Gene46", "Gene47", + "Gene48", "Gene49", + ], "Stem cell related genes", ), ] @@ -1439,8 +1454,25 @@ pub fn gsva_enrichment_map( map = map + "------------------\n" i = 0 while i < n_sets { - let color = if avg_scores[i] > 0.5 { "#" } else if avg_scores[i] > 0.0 { "*" } else if avg_scores[i] > -0.5 { "." } else { "o" } - map = map + " " + color + " " + gene_sets[i].name + " (avg=" + avg_scores[i].to_string() + ", genes=" + gene_sets[i].genes.length().to_string() + ")\n" + let color = if avg_scores[i] > 0.5 { + "#" + } else if avg_scores[i] > 0.0 { + "*" + } else if avg_scores[i] > -0.5 { + "." + } else { + "o" + } + map = map + + " " + + color + + " " + + gene_sets[i].name + + " (avg=" + + avg_scores[i].to_string() + + ", genes=" + + gene_sets[i].genes.length().to_string() + + ")\n" i = i + 1 } @@ -1453,7 +1485,14 @@ pub fn gsva_enrichment_map( while j < n_sets { let overlap = gsva_gene_set_overlap(gene_sets[i], gene_sets[j]) if overlap > threshold { - map = map + " " + gene_sets[i].name + " ---" + overlap.to_string() + "--- " + gene_sets[j].name + "\n" + map = map + + " " + + gene_sets[i].name + + " ---" + + overlap.to_string() + + "--- " + + gene_sets[j].name + + "\n" edge_count = edge_count + 1 } j = j + 1 @@ -1499,7 +1538,9 @@ fn gsva_pearson_correlation(x : Array[Double], y : Array[Double]) -> Double { } let numerator = n * sum_xy - sum_x * sum_y - let denominator = gsva_sqrt((n * sum_x2 - sum_x * sum_x) * (n * sum_y2 - sum_y * sum_y)) + let denominator = gsva_sqrt( + (n * sum_x2 - sum_x * sum_x) * (n * sum_y2 - sum_y * sum_y), + ) if denominator == 0.0 { 0.0 @@ -1521,7 +1562,10 @@ pub fn gsva_phenotype_correlation( while i < n_sets { let corr = gsva_pearson_correlation(scores.scores[i], phenotypes) let p_value = if corr.abs() > 0.0 { - let t_stat = corr * gsva_sqrt((scores.scores[i].length() - 2).to_double() / (1.0 - corr * corr)) + let t_stat = corr * + gsva_sqrt( + (scores.scores[i].length() - 2).to_double() / (1.0 - corr * corr), + ) let df = scores.scores[i].length() - 2 if df < 1 { 1.0 @@ -1548,12 +1592,18 @@ pub fn gsva_phenotype_report( let mut report = "GSVA Phenotype Correlation Report\n" report = report + "=================================\n\n" report = report + "Phenotype: " + phenotype_name + "\n" - report = report + "Samples: " + scores.sample_names.length().to_string() + "\n\n" + report = report + + "Samples: " + + scores.sample_names.length().to_string() + + "\n\n" let correlations = gsva_phenotype_correlation(scores, phenotypes) let n_sets = correlations.length() - let sorted : Array[(String, Double, Double)] = Array::make(n_sets, ("", 0.0, 0.0)) + let sorted : Array[(String, Double, Double)] = Array::make( + n_sets, + ("", 0.0, 0.0), + ) let mut i = 0 while i < n_sets { sorted[i] = correlations[i] @@ -1584,7 +1634,13 @@ pub fn gsva_phenotype_report( i = 0 while i < sorted.length() && i < 10 { let (name, corr, pval) = sorted[i] - report = report + name + "\t" + corr.to_string() + "\t" + pval.to_string() + "\n" + report = report + + name + + "\t" + + corr.to_string() + + "\t" + + pval.to_string() + + "\n" i = i + 1 } @@ -1659,9 +1715,13 @@ pub fn gsva_survival_analysis( j = 0 while j < n { - cov = cov + (set_scores[j] - mean_score) * (event[j].to_double() - mean_event) - var_score = var_score + (set_scores[j] - mean_score) * (set_scores[j] - mean_score) - var_event = var_event + (event[j].to_double() - mean_event) * (event[j].to_double() - mean_event) + cov = cov + + (set_scores[j] - mean_score) * (event[j].to_double() - mean_event) + var_score = var_score + + (set_scores[j] - mean_score) * (set_scores[j] - mean_score) + var_event = var_event + + (event[j].to_double() - mean_event) * + (event[j].to_double() - mean_event) j = j + 1 } @@ -1703,7 +1763,10 @@ pub fn gsva_survival_report( ) -> String { let mut report = "GSVA Survival Analysis Report\n" report = report + "=============================\n\n" - report = report + "Samples: " + scores.sample_names.length().to_string() + "\n" + report = report + + "Samples: " + + scores.sample_names.length().to_string() + + "\n" let mut event_sum = 0 let mut ev_idx = 0 while ev_idx < event.length() { @@ -1744,7 +1807,17 @@ pub fn gsva_survival_report( i = 0 while i < sorted.length() && i < 10 { let res = sorted[i] - report = report + res.gene_set_name + "\t" + res.hazard_ratio.to_string() + "\t[" + res.ci_lower.to_string() + "," + res.ci_upper.to_string() + "]\t" + res.p_value.to_string() + "\n" + report = report + + res.gene_set_name + + "\t" + + res.hazard_ratio.to_string() + + "\t[" + + res.ci_lower.to_string() + + "," + + res.ci_upper.to_string() + + "]\t" + + res.p_value.to_string() + + "\n" i = i + 1 } @@ -1813,7 +1886,8 @@ pub fn gsva_score_distribution(scores : GSVAScores) -> String { i = bin_count - 1 while i >= 0 { - let threshold = min_val + range * i.to_double() / (bin_count - 1).to_double() + let threshold = min_val + + range * i.to_double() / (bin_count - 1).to_double() let mut bar = "" let mut j = 0 while j < bins[i] && max_freq > 0 { diff --git a/src/gviz.mbt b/src/gviz.mbt index 2a2e9e8a..ae4e5650 100644 --- a/src/gviz.mbt +++ b/src/gviz.mbt @@ -170,7 +170,15 @@ pub fn gviz_feature( feature_type : String, label : String, ) -> GvizFeature { - GvizFeature::{ feature_id, chromosome, start, end_, strand, feature_type, label } + GvizFeature::{ + feature_id, + chromosome, + start, + end_, + strand, + feature_type, + label, + } } ///| @@ -215,7 +223,11 @@ pub fn GvizTrack::add_feature(self : GvizTrack, feature : GvizFeature) -> Unit { ///| /// Add a data point to a DataTrack. -pub fn GvizTrack::add_data_point(self : GvizTrack, position : Int, value : Double) -> Unit { +pub fn GvizTrack::add_data_point( + self : GvizTrack, + position : Int, + value : Double, +) -> Unit { self.data_values.push((position, value)) } @@ -233,7 +245,11 @@ pub fn GvizTrack::get_n_data_points(self : GvizTrack) -> Int { ///| /// Get features within a specific region. -pub fn GvizTrack::get_features_in_region(self : GvizTrack, start : Int, end_ : Int) -> Array[GvizFeature] { +pub fn GvizTrack::get_features_in_region( + self : GvizTrack, + start : Int, + end_ : Int, +) -> Array[GvizFeature] { let result : Array[GvizFeature] = Array::new() let mut i = 0 while i < self.features.length() { @@ -248,7 +264,11 @@ pub fn GvizTrack::get_features_in_region(self : GvizTrack, start : Int, end_ : I ///| /// Get data values within a specific region. -pub fn GvizTrack::get_data_in_region(self : GvizTrack, start : Int, end_ : Int) -> Array[(Int, Double)] { +pub fn GvizTrack::get_data_in_region( + self : GvizTrack, + start : Int, + end_ : Int, +) -> Array[(Int, Double)] { let result : Array[(Int, Double)] = Array::new() let mut i = 0 while i < self.data_values.length() { @@ -275,13 +295,7 @@ pub fn gviz_plot( width? : Int = 80, height? : Int = 25, ) -> GvizPlot { - GvizPlot::{ - tracks: Array::new(), - region, - title, - width, - height, - } + GvizPlot::{ tracks: Array::new(), region, title, width, height } } ///| @@ -315,33 +329,48 @@ pub fn GvizPlot::to_ascii(self : GvizPlot) -> String { let mut result = "" result = result + self.title + "\n" - result = result + "Chromosome: " + self.region.chromosome + " [" + region_start.to_string() + " - " + region_end.to_string() + "]\n" + result = result + + "Chromosome: " + + self.region.chromosome + + " [" + + region_start.to_string() + + " - " + + region_end.to_string() + + "]\n" result = result + gviz_repeat("=", w) + "\n" // Process each track let mut ti = 0 while ti < self.tracks.length() { let track = self.tracks[ti] - result = result + "[" + track.track_type.to_string() + "] " + track.display_label + "\n" + result = result + + "[" + + track.track_type.to_string() + + "] " + + track.display_label + + "\n" // Render track content match track.track_type { - GvizTrackType::GenomeAxisTrack => { + GvizTrackType::GenomeAxisTrack => // Draw axis with position labels result = result + gviz_render_axis(region_start, region_end, w) + "\n" - } - GvizTrackType::AnnotationTrack | GvizTrackType::GeneRegionTrack => { - result = result + gviz_render_features(track, region_start, region_end, w) + "\n" - } - GvizTrackType::DataTrack => { - result = result + gviz_render_data(track, region_start, region_end, w) + "\n" - } - GvizTrackType::IdeogramTrack => { - result = result + gviz_render_ideogram(track, region_start, region_end, w) + "\n" - } - GvizTrackType::SequenceTrack => { - result = result + gviz_render_sequence(track, region_start, region_end, w) + "\n" - } + GvizTrackType::AnnotationTrack | GvizTrackType::GeneRegionTrack => + result = result + + gviz_render_features(track, region_start, region_end, w) + + "\n" + GvizTrackType::DataTrack => + result = result + + gviz_render_data(track, region_start, region_end, w) + + "\n" + GvizTrackType::IdeogramTrack => + result = result + + gviz_render_ideogram(track, region_start, region_end, w) + + "\n" + GvizTrackType::SequenceTrack => + result = result + + gviz_render_sequence(track, region_start, region_end, w) + + "\n" } result = result + "\n" ti = ti + 1 @@ -391,7 +420,12 @@ fn gviz_render_axis(start : Int, end_ : Int, width : Int) -> String { ///| /// Render features as boxes. -fn gviz_render_features(track : GvizTrack, region_start : Int, region_end : Int, width : Int) -> String { +fn gviz_render_features( + track : GvizTrack, + region_start : Int, + region_end : Int, + width : Int, +) -> String { let region_len = (region_end - region_start).to_double() if region_len <= 0.0 { return "" @@ -412,8 +446,12 @@ fn gviz_render_features(track : GvizTrack, region_start : Int, region_end : Int, if f.end_ < region_start || f.start > region_end { fi = fi + 1 } else { - let rel_start = ((f.start - region_start).to_double() / region_len * (width - 1).to_double()).to_int() - let rel_end = ((f.end_ - region_start).to_double() / region_len * (width - 1).to_double()).to_int() + let rel_start = ((f.start - region_start).to_double() / + region_len * + (width - 1).to_double()).to_int() + let rel_end = ((f.end_ - region_start).to_double() / + region_len * + (width - 1).to_double()).to_int() let s = if rel_start < 0 { 0 } else { rel_start } let e = if rel_end >= width { width - 1 } else { rel_end } @@ -461,7 +499,12 @@ fn gviz_render_features(track : GvizTrack, region_start : Int, region_end : Int, ///| /// Render feature labels. -fn gviz_render_labels(track : GvizTrack, region_start : Int, region_end : Int, width : Int) -> String { +fn gviz_render_labels( + track : GvizTrack, + region_start : Int, + region_end : Int, + width : Int, +) -> String { let region_len = (region_end - region_start).to_double() if region_len <= 0.0 { return "" @@ -481,7 +524,9 @@ fn gviz_render_labels(track : GvizTrack, region_start : Int, region_end : Int, w fi = fi + 1 } else { let mid_pos = (f.start + f.end_) / 2 - let rel_mid = ((mid_pos - region_start).to_double() / region_len * (width - 1).to_double()).to_int() + let rel_mid = ((mid_pos - region_start).to_double() / + region_len * + (width - 1).to_double()).to_int() if rel_mid >= 0 && rel_mid < width && f.label.length() > 0 { let label = f.label let mut li = 0 @@ -499,7 +544,12 @@ fn gviz_render_labels(track : GvizTrack, region_start : Int, region_end : Int, w ///| /// Render data track as a simple bar plot. -fn gviz_render_data(track : GvizTrack, region_start : Int, region_end : Int, width : Int) -> String { +fn gviz_render_data( + track : GvizTrack, + region_start : Int, + region_end : Int, + width : Int, +) -> String { let data = track.get_data_in_region(region_start, region_end) if data.length() == 0 { return "(no data)" @@ -510,8 +560,12 @@ fn gviz_render_data(track : GvizTrack, region_start : Int, region_end : Int, wid let mut max_val = data[0].1 let mut i = 1 while i < data.length() { - if data[i].1 < min_val { min_val = data[i].1 } - if data[i].1 > max_val { max_val = data[i].1 } + if data[i].1 < min_val { + min_val = data[i].1 + } + if data[i].1 > max_val { + max_val = data[i].1 + } i = i + 1 } @@ -541,7 +595,9 @@ fn gviz_render_data(track : GvizTrack, region_start : Int, region_end : Int, wid let mut di = 0 while di < data.length() { let (pos, val) = data[di] - let rel_pos = ((pos - region_start).to_double() / region_len * (width - 1).to_double()).to_int() + let rel_pos = ((pos - region_start).to_double() / + region_len * + (width - 1).to_double()).to_int() let normalized = (val - min_val) / val_range let bar_h = (normalized * bar_height.to_double()).to_int() @@ -562,13 +618,22 @@ fn gviz_render_data(track : GvizTrack, region_start : Int, region_end : Int, wid rri = rri + 1 } - result = result + "min: " + min_val.to_string() + ", max: " + max_val.to_string() + result = result + + "min: " + + min_val.to_string() + + ", max: " + + max_val.to_string() result } ///| /// Render ideogram track. -fn gviz_render_ideogram(track : GvizTrack, region_start : Int, region_end : Int, width : Int) -> String { +fn gviz_render_ideogram( + track : GvizTrack, + region_start : Int, + region_end : Int, + width : Int, +) -> String { // Simplified ideogram: draw a chromosome bar with centromere marker let mut s = "" let mut i = 0 @@ -583,13 +648,23 @@ fn gviz_render_ideogram(track : GvizTrack, region_start : Int, region_end : Int, i = i + 1 } s = s + "\n" - s = s + "p" + gviz_repeat(" ", width / 2 - 2) + "cen" + gviz_repeat(" ", width / 2 - 2) + "q" + s = s + + "p" + + gviz_repeat(" ", width / 2 - 2) + + "cen" + + gviz_repeat(" ", width / 2 - 2) + + "q" s } ///| /// Render sequence track. -fn gviz_render_sequence(track : GvizTrack, region_start : Int, region_end : Int, width : Int) -> String { +fn gviz_render_sequence( + track : GvizTrack, + region_start : Int, + region_end : Int, + width : Int, +) -> String { let region_len = region_end - region_start if region_len <= 0 { return "" @@ -614,12 +689,30 @@ fn gviz_render_sequence(track : GvizTrack, region_start : Int, region_end : Int, pub fn GvizPlot::summary(self : GvizPlot) -> String { let mut s = "=== Gviz Plot Summary ===\n".to_string() s = s + "Title: " + self.title + "\n" - s = s + "Region: " + self.region.chromosome + ":" + self.region.start.to_string() + "-" + self.region.end_.to_string() + "\n" + s = s + + "Region: " + + self.region.chromosome + + ":" + + self.region.start.to_string() + + "-" + + self.region.end_.to_string() + + "\n" s = s + "Tracks: " + self.tracks.length().to_string() + "\n" let mut i = 0 while i < self.tracks.length() { - s = s + " [" + (i + 1).to_string() + "] " + self.tracks[i].track_type.to_string() + ": " + self.tracks[i].display_label - s = s + " (" + self.tracks[i].get_n_features().to_string() + " features, " + self.tracks[i].get_n_data_points().to_string() + " data points)\n" + s = s + + " [" + + (i + 1).to_string() + + "] " + + self.tracks[i].track_type.to_string() + + ": " + + self.tracks[i].display_label + s = s + + " (" + + self.tracks[i].get_n_features().to_string() + + " features, " + + self.tracks[i].get_n_data_points().to_string() + + " data points)\n" i = i + 1 } s @@ -629,20 +722,67 @@ pub fn GvizPlot::summary(self : GvizPlot) -> String { /// Create sample data for testing. pub fn gviz_sample_plot() -> GvizPlot { let region = gviz_region("chr1", 1000, 5000) - let plot = gviz_plot(region, title="Sample Genome Region", width=80, height=25) + let plot = gviz_plot( + region, + title="Sample Genome Region", + width=80, + height=25, + ) // Axis track - let axis_track = gviz_track("axis", track_type_genome_axis(), "chr1", 1000, 5000) + let axis_track = gviz_track( + "axis", + track_type_genome_axis(), + "chr1", + 1000, + 5000, + ) axis_track.set_label("Genome Axis") plot.add_track(axis_track) // Gene region track - let gene_track = gviz_track("genes", track_type_gene_region(), "chr1", 1000, 5000) + let gene_track = gviz_track( + "genes", + track_type_gene_region(), + "chr1", + 1000, + 5000, + ) gene_track.set_label("Gene Annotations") gene_track.set_color("blue") - gene_track.add_feature(gviz_feature("g1", "chr1", 1200, 1800, track_strand_forward(), "exon", "BRCA1")) - gene_track.add_feature(gviz_feature("g2", "chr1", 2000, 3500, track_strand_reverse(), "exon", "TP53")) - gene_track.add_feature(gviz_feature("g3", "chr1", 4000, 4500, track_strand_forward(), "exon", "EGFR")) + gene_track.add_feature( + gviz_feature( + "g1", + "chr1", + 1200, + 1800, + track_strand_forward(), + "exon", + "BRCA1", + ), + ) + gene_track.add_feature( + gviz_feature( + "g2", + "chr1", + 2000, + 3500, + track_strand_reverse(), + "exon", + "TP53", + ), + ) + gene_track.add_feature( + gviz_feature( + "g3", + "chr1", + 4000, + 4500, + track_strand_forward(), + "exon", + "EGFR", + ), + ) plot.add_track(gene_track) // Data track @@ -659,7 +799,13 @@ pub fn gviz_sample_plot() -> GvizPlot { plot.add_track(data_track) // Ideogram track - let ideo_track = gviz_track("ideogram", gviz_track_type_ideogram(), "chr1", 1000, 5000) + let ideo_track = gviz_track( + "ideogram", + gviz_track_type_ideogram(), + "chr1", + 1000, + 5000, + ) ideo_track.set_label("Ideogram") plot.add_track(ideo_track) diff --git a/src/harmony.mbt b/src/harmony.mbt index f019e8a4..96f86c8f 100644 --- a/src/harmony.mbt +++ b/src/harmony.mbt @@ -77,13 +77,13 @@ pub fn HarmonyParams::create( seed? : Int = 42, ) -> HarmonyParams { HarmonyParams::{ - n_clusters: n_clusters, - max_iterations: max_iterations, - tolerance: tolerance, - lambda: lambda, - sigma: sigma, - ridge_penalty: ridge_penalty, - seed: seed, + n_clusters, + max_iterations, + tolerance, + lambda, + sigma, + ridge_penalty, + seed, } } @@ -100,19 +100,25 @@ pub struct HarmonyResult { ///| /// Get corrected embeddings. -pub fn HarmonyResult::get_corrected(self : HarmonyResult) -> Array[Array[Double]] { +pub fn HarmonyResult::get_corrected( + self : HarmonyResult, +) -> Array[Array[Double]] { self.corrected } ///| /// Get soft cluster membership matrix. -pub fn HarmonyResult::get_membership(self : HarmonyResult) -> Array[Array[Double]] { +pub fn HarmonyResult::get_membership( + self : HarmonyResult, +) -> Array[Array[Double]] { self.membership } ///| /// Get cluster centroids. -pub fn HarmonyResult::get_centroids(self : HarmonyResult) -> Array[Array[Double]] { +pub fn HarmonyResult::get_centroids( + self : HarmonyResult, +) -> Array[Array[Double]] { self.centroids } @@ -134,29 +140,49 @@ pub fn harmony_run(data : HarmonyData, params : HarmonyParams) -> HarmonyResult let n_cells = data.embeddings.length() let n_dims = if n_cells > 0 { data.embeddings[0].length() } else { 0 } let n_clusters = if params.n_clusters > 0 { params.n_clusters } else { 1 } - + let centroids = harmony_init_centroids(data, n_clusters, params.seed) - let membership = harmony_compute_membership(data.embeddings, centroids, params.lambda) + let membership = harmony_compute_membership( + data.embeddings, + centroids, + params.lambda, + ) let mut corrected = data.embeddings - + let mut iter = 0 let mut converged = false let mut prev_obj = harmony_objective(data.embeddings, centroids, membership) - + while iter < params.max_iterations { - let new_centroids = harmony_update_centroids(corrected, membership, n_clusters) + let new_centroids = harmony_update_centroids( + corrected, membership, n_clusters, + ) let corrections = harmony_batch_corrections( - HarmonyData::{ embeddings: corrected, batch_labels: data.batch_labels, cell_ids: data.cell_ids }, + HarmonyData::{ + embeddings: corrected, + batch_labels: data.batch_labels, + cell_ids: data.cell_ids, + }, membership, new_centroids, n_clusters, params.ridge_penalty, ) - corrected = harmony_apply_correction(corrected, membership, corrections, n_clusters) - let new_membership = harmony_compute_membership(corrected, new_centroids, params.lambda) + corrected = harmony_apply_correction( + corrected, membership, corrections, n_clusters, + ) + let new_membership = harmony_compute_membership( + corrected, + new_centroids, + params.lambda, + ) let obj = harmony_objective(corrected, new_centroids, new_membership) - let delta = if prev_obj.abs() > 1.0e-10 { (prev_obj - obj).abs() / prev_obj.abs() } else { 0.0 } - + let delta = if prev_obj.abs() > 1.0e-10 { + (prev_obj - obj).abs() / prev_obj.abs() + } else { + 0.0 + } + if delta < params.tolerance { converged = true break @@ -164,7 +190,7 @@ pub fn harmony_run(data : HarmonyData, params : HarmonyParams) -> HarmonyResult prev_obj = obj iter = iter + 1 } - + HarmonyResult::{ corrected, membership, @@ -177,20 +203,24 @@ pub fn harmony_run(data : HarmonyData, params : HarmonyParams) -> HarmonyResult ///| /// Initialize cluster centroids using k-means++ style seeding. -fn harmony_init_centroids(data : HarmonyData, n_clusters : Int, seed : Int) -> Array[Array[Double]] { +fn harmony_init_centroids( + data : HarmonyData, + n_clusters : Int, + seed : Int, +) -> Array[Array[Double]] { let n_cells = data.embeddings.length() if n_cells == 0 { return Array::make(n_clusters, Array::make(0, 0.0)) } let n_dims = data.embeddings[0].length() - + let centroids : Array[Array[Double]] = Array::new() let mut rng_state = seed - + let first_idx = harmony_next_rand(rng_state) % n_cells rng_state = harmony_next_rand(rng_state) centroids.push(data.embeddings[first_idx]) - + let mut c = 1 while c < n_clusters { let dists : Array[Double] = Array::make(n_cells, 0.0) @@ -208,10 +238,12 @@ fn harmony_init_centroids(data : HarmonyData, n_clusters : Int, seed : Int) -> A dists[i] = min_dist i = i + 1 } - + let total_dist = harmony_sum(dists) if total_dist > 0.0 { - let r = harmony_next_rand(rng_state).to_double() / 2147483647.0 * total_dist + let r = harmony_next_rand(rng_state).to_double() / + 2147483647.0 * + total_dist rng_state = harmony_next_rand(rng_state) let mut best_idx = 0 let mut cum = 0.0 @@ -245,7 +277,7 @@ fn harmony_compute_membership( let n_cells = embeddings.length() let n_clusters = centroids.length() let membership : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_cells { let responsibilities : Array[Double] = Array::make(n_clusters, 0.0) @@ -260,7 +292,7 @@ fn harmony_compute_membership( responsibilities[j] = logit j = j + 1 } - + let mut sum_exp = 0.0 let mut k = 0 while k < n_clusters { @@ -268,7 +300,7 @@ fn harmony_compute_membership( sum_exp = sum_exp + responsibilities[k] k = k + 1 } - + if sum_exp > 0.0 { let mut m = 0 while m < n_clusters { @@ -276,7 +308,7 @@ fn harmony_compute_membership( m = m + 1 } } - + membership.push(responsibilities) i = i + 1 } @@ -293,7 +325,7 @@ fn harmony_update_centroids( let n_cells = embeddings.length() let n_dims = if n_cells > 0 { embeddings[0].length() } else { 0 } let centroids : Array[Array[Double]] = Array::new() - + let mut k = 0 while k < n_clusters { let mut weight_sum = 0.0 @@ -333,7 +365,7 @@ fn harmony_batch_corrections( ) -> Array[Array[Array[Double]]] { let n_cells = data.embeddings.length() let n_dims = if n_cells > 0 { data.embeddings[0].length() } else { 0 } - + // Get unique batches let unique_batches : Array[String] = Array::new() { @@ -348,10 +380,13 @@ fn harmony_batch_corrections( i = i + 1 } } - + let n_batches = unique_batches.length() - let corrections : Array[Array[Array[Double]]] = Array::make(n_clusters, Array::make(n_batches, Array::make(n_dims, 0.0))) - + let corrections : Array[Array[Array[Double]]] = Array::make( + n_clusters, + Array::make(n_batches, Array::make(n_dims, 0.0)), + ) + let mut k = 0 while k < n_clusters { let mut b = 0 @@ -362,7 +397,7 @@ fn harmony_batch_corrections( let batch_mean : Array[Double] = Array::make(n_dims, 0.0) let global_mean : Array[Double] = Array::make(n_dims, 0.0) let mut gw = 0.0 - + let mut i = 0 while i < n_cells { let w = membership[i][k] @@ -382,7 +417,7 @@ fn harmony_batch_corrections( } i = i + 1 } - + if weight_sum > 0.0 { let mut d = 0 while d < n_dims { @@ -397,7 +432,7 @@ fn harmony_batch_corrections( d = d + 1 } } - + // Correction = batch_mean - global_mean (with ridge penalty) let correction : Array[Double] = Array::make(n_dims, 0.0) let effective_weight = weight_sum / (weight_sum + ridge_penalty) @@ -425,7 +460,7 @@ fn harmony_apply_correction( let n_cells = embeddings.length() let n_dims = if n_cells > 0 { embeddings[0].length() } else { 0 } let n_batches = if n_clusters > 0 { corrections[0].length() } else { 0 } - + // Get unique batches from correction dimensions let corrected : Array[Array[Double]] = Array::new() let mut i = 0 @@ -436,7 +471,7 @@ fn harmony_apply_correction( new_cell[d] = embeddings[i][d] d = d + 1 } - + let mut k = 0 while k < n_clusters { let w = membership[i][k] @@ -514,20 +549,24 @@ fn harmony_next_rand(seed : Int) -> Int { ///| /// Create example data for Harmony testing. -pub fn harmony_create_example(n_cells : Int, n_batches : Int, n_dims : Int) -> HarmonyData { +pub fn harmony_create_example( + n_cells : Int, + n_batches : Int, + n_dims : Int, +) -> HarmonyData { let embeddings : Array[Array[Double]] = Array::new() let batch_labels : Array[String] = Array::new() let cell_ids : Array[String] = Array::new() let mut rng = 42 - + let mut i = 0 while i < n_cells { let batch_idx = i * n_batches / n_cells let batch_id = "batch_" + batch_idx.to_string() - + // Simulate batch effect let batch_effect = batch_idx.to_double() * 2.0 - + let cell : Array[Double] = Array::make(n_dims, 0.0) let mut d = 0 while d < n_dims { @@ -536,12 +575,12 @@ pub fn harmony_create_example(n_cells : Int, n_batches : Int, n_dims : Int) -> H cell[d] = batch_effect + noise d = d + 1 } - + embeddings.push(cell) batch_labels.push(batch_id) cell_ids.push("cell_" + i.to_string()) i = i + 1 } - + HarmonyData::{ embeddings, batch_labels, cell_ids } } diff --git a/src/hicdc.mbt b/src/hicdc.mbt index 4e20b44f..e43507bd 100644 --- a/src/hicdc.mbt +++ b/src/hicdc.mbt @@ -35,7 +35,7 @@ pub fn HiCContact::new( bin1 : Int, bin2 : Int, count : Int, - bin_size : Int + bin_size : Int, ) -> HiCContact { let distance = if bin2 > bin1 { bin2 - bin1 } else { bin1 - bin2 } HiCContact::{ @@ -234,6 +234,7 @@ pub fn CompartmentCall::compartment(self : CompartmentCall) -> String { // Internal helpers // =========================================================================== +///| fn hc_abs(x : Double) -> Double { if x < 0.0 { -x @@ -242,6 +243,7 @@ fn hc_abs(x : Double) -> Double { } } +///| fn hc_sqrt(x : Double) -> Double { if x <= 0.0 { return 0.0 @@ -261,6 +263,7 @@ fn hc_sqrt(x : Double) -> Double { guess } +///| fn hc_log(x : Double) -> Double { if x <= 0.0 { return -700.0 @@ -268,6 +271,7 @@ fn hc_log(x : Double) -> Double { @math.ln(x) } +///| fn hc_exp(x : Double) -> Double { if x > 700.0 { return 1.7976931348623157e+308 @@ -289,7 +293,12 @@ fn hc_normal_cdf(x : Double) -> Double { } let t = 1.0 / (1.0 + 0.2316419 * hc_abs(x)) let d = 0.3989423 * hc_exp(-x * x / 2.0) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))) + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))) + ) if x >= 0.0 { 1.0 - p } else { @@ -336,7 +345,7 @@ fn hc_upper_gamma_q(a : Double, x : Double) -> Double { let mut h = d let mut i = 1 while i < 200 { - let an = -(i.to_double()) * (i.to_double() - a) + let an = -i.to_double() * (i.to_double() - a) b = b + 2.0 d = an * d + b if hc_abs(d) < tiny { @@ -361,18 +370,15 @@ fn hc_upper_gamma_q(a : Double, x : Double) -> Double { /// Log-gamma function via Lanczos approximation. fn hc_log_gamma(x : Double) -> Double { if x < 0.5 { - return hc_log(3.141592653589793 / (hc_sin(3.141592653589793 * x) * hc_exp(hc_log_gamma(1.0 - x)))) + return hc_log( + 3.141592653589793 / + (hc_sin(3.141592653589793 * x) * hc_exp(hc_log_gamma(1.0 - x))), + ) } let g = 7.0 let c = [ - 0.99999999999980993, - 676.5203681218851, - -1259.1392167224028, - 771.32342877765313, - -176.61502916214059, - 12.507343278686905, - -0.13857109526572012, - 9.9843695780195716e-6, + 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, + -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7, ] let mut a = c[0] @@ -423,7 +429,7 @@ fn hc_sin(x : Double) -> Double { /// /// Returns the fitted parameters: (intercept, beta_dist, beta_gc, beta_map, dispersion). pub fn hicdc_fit_background( - contacts : Array[HiCContact] + contacts : Array[HiCContact], ) -> (Double, Double, Double, Double, Double) { let n = contacts.length() if n == 0 { @@ -526,7 +532,7 @@ pub fn hicdc_predict_expected( intercept : Double, beta_dist : Double, beta_gc : Double, - beta_map : Double + beta_map : Double, ) -> Array[Double] { let expected : Array[Double] = Array::new() for c in contacts { @@ -555,7 +561,7 @@ pub fn hicdc_test_significance( beta_dist : Double, beta_gc : Double, beta_map : Double, - dispersion : Double + dispersion : Double, ) -> Array[HiCDCResult] { let n = contacts.length() let results : Array[HiCDCResult] = Array::new() @@ -572,7 +578,13 @@ pub fn hicdc_test_significance( let z = (c.count.to_double() - mu) / std_dev // One-sided p-value (test for enrichment). let p_value = 1.0 - hc_normal_cdf(z) - let p_value = if p_value < 0.0 { 0.0 } else if p_value > 1.0 { 1.0 } else { p_value } + let p_value = if p_value < 0.0 { + 0.0 + } else if p_value > 1.0 { + 1.0 + } else { + p_value + } let log_fc = hc_log(c.count.to_double() / mu) results.push(HiCDCResult::{ chr: c.chr, @@ -638,7 +650,7 @@ fn hc_bh_fdr(results : Array[HiCDCResult]) -> Array[HiCDCResult] { /// Mark significant results at given FDR threshold. pub fn hicdc_mark_significant( results : Array[HiCDCResult], - fdr_threshold : Double + fdr_threshold : Double, ) -> Array[HiCDCResult] { for r in results { r.significant = r.fdr < fdr_threshold @@ -661,7 +673,7 @@ pub fn hicdc_mark_significant( pub fn hicdc_directionality_index( contacts : Array[HiCContact], n_bins : Int, - window : Int + window : Int, ) -> Array[Double] { // Build per-bin downstream and upstream contact sums. let downstream = Array::make(n_bins, 0.0) @@ -702,7 +714,7 @@ pub fn hicdc_call_tads( contacts : Array[HiCContact], n_bins : Int, window : Int, - chr : String + chr : String, ) -> Array[TADBoundary] { let di = hicdc_directionality_index(contacts, n_bins, window) let boundaries : Array[TADBoundary] = Array::new() @@ -731,7 +743,7 @@ pub fn hicdc_call_tads( pub fn hicdc_call_compartments( contacts : Array[HiCContact], n_bins : Int, - chr : String + chr : String, ) -> Array[CompartmentCall] { // Build contact matrix. let matrix : Array[Array[Double]] = Array::new() @@ -784,7 +796,7 @@ pub fn hicdc_call_compartments( fn hc_power_iteration( matrix : Array[Array[Double]], n : Int, - max_iter : Int + max_iter : Int, ) -> Array[Double] { let v = Array::make(n, 1.0) // Normalize initial vector. @@ -833,6 +845,7 @@ fn hc_power_iteration( v } +///| fn hc_mean(arr : Array[Double]) -> Double { let n = arr.length() if n == 0 { @@ -845,6 +858,7 @@ fn hc_mean(arr : Array[Double]) -> Double { s / n.to_double() } +///| fn hc_std(arr : Array[Double], mean : Double) -> Double { let n = arr.length() if n == 0 { @@ -862,6 +876,7 @@ fn hc_std(arr : Array[Double], mean : Double) -> Double { // Linear algebra helper // =========================================================================== +///| fn hc_solve(matrix : Array[Array[Double]], b : Array[Double]) -> Array[Double]? { let n = matrix.length() if n == 0 { @@ -934,7 +949,7 @@ fn hc_solve(matrix : Array[Array[Double]], b : Array[Double]) -> Array[Double]? pub fn hicdc_differential( contacts1 : Array[HiCContact], contacts2 : Array[HiCContact], - fdr_threshold : Double + fdr_threshold : Double, ) -> Array[HiCDCResult] { // Build lookup for condition 2 contacts. let map2 : Map[String, HiCContact] = Map([], capacity=contacts2.length()) @@ -950,7 +965,9 @@ pub fn hicdc_differential( for c in contacts2 { pooled.push(c) } - let (intercept, beta_dist, beta_gc, beta_map, dispersion) = hicdc_fit_background(pooled) + let (intercept, beta_dist, beta_gc, beta_map, dispersion) = hicdc_fit_background( + pooled, + ) // Test each contact from condition 1 for differential enrichment. let results : Array[HiCDCResult] = Array::new() for c1 in contacts1 { @@ -969,7 +986,13 @@ pub fn hicdc_differential( let diff = (c1.count - c2.count).to_double() let z = diff / (std_dev * hc_sqrt(2.0)) let p_value = 2.0 * (1.0 - hc_normal_cdf(hc_abs(z))) - let p_value = if p_value < 0.0 { 0.0 } else if p_value > 1.0 { 1.0 } else { p_value } + let p_value = if p_value < 0.0 { + 0.0 + } else if p_value > 1.0 { + 1.0 + } else { + p_value + } let c2_count = c2.count.to_double() let denom = if c2_count > 0.0000001 { c2_count } else { 0.0000001 } let log_fc = hc_log(c1.count.to_double() / denom) @@ -1000,11 +1023,13 @@ pub fn hicdc_differential( /// and mark significant interactions. pub fn hicdc_run( contacts : Array[HiCContact], - fdr_threshold : Double + fdr_threshold : Double, ) -> Array[HiCDCResult] { - let (intercept, beta_dist, beta_gc, beta_map, dispersion) = hicdc_fit_background(contacts) + let (intercept, beta_dist, beta_gc, beta_map, dispersion) = hicdc_fit_background( + contacts, + ) let results = hicdc_test_significance( - contacts, intercept, beta_dist, beta_gc, beta_map, dispersion + contacts, intercept, beta_dist, beta_gc, beta_map, dispersion, ) hicdc_mark_significant(results, fdr_threshold) } diff --git a/src/hilbertcurve.mbt b/src/hilbertcurve.mbt index cba0ed58..3d23a421 100644 --- a/src/hilbertcurve.mbt +++ b/src/hilbertcurve.mbt @@ -18,10 +18,10 @@ pub fn HilbertCurve::new(levels : Int, dimension : Int) -> HilbertCurve { pub fn hilbert_encode(hc : HilbertCurve, coordinates : Array[Int]) -> Int { let mut result = 0 let mut s = 1 << (hc.levels - 1) - + let x : Array[Int] = coordinates.copy() let n = hc.dimension - + while s > 0 { let mut region = 0 let mut i = 0 @@ -31,15 +31,15 @@ pub fn hilbert_encode(hc : HilbertCurve, coordinates : Array[Int]) -> Int { } i = i + 1 } - + let shift_amount = n * (hc.levels - log2_int(s)) result = result | (region << shift_amount) - + hilbert_inverse(hc, x, s) - + s = s >> 1 } - + result } @@ -62,7 +62,7 @@ fn log2_int(x : Int) -> Int { ///| fn hilbert_inverse(hc : HilbertCurve, x : Array[Int], s : Int) -> Unit { let n = hc.dimension - + let shift_amount = log2_int(s) let bits = (x[0] >> shift_amount) & 1 let mut i = 1 @@ -71,7 +71,7 @@ fn hilbert_inverse(hc : HilbertCurve, x : Array[Int], s : Int) -> Unit { x[0] = x[0] ^ (bit_i << shift_amount) i = i + 1 } - + let mut j = 1 while j < n { let mut k = j + 1 @@ -93,17 +93,17 @@ pub fn hilbert_decode(hc : HilbertCurve, index : Int) -> Array[Int] { x.push(0) i = i + 1 } - + let mut s = 1 let mut t = index - + let n = hc.dimension - + while s <= hc.max_coordinate { let region = t & ((1 << n) - 1) - + hilbert_inverse(hc, x, s) - + let mut i = 0 while i < n { if bit_is_set(region, 1 << i) { @@ -111,18 +111,22 @@ pub fn hilbert_decode(hc : HilbertCurve, index : Int) -> Array[Int] { } i = i + 1 } - + t = t >> n s = s << 1 } - + x } ///| -pub fn hilbert_point_to_segment(hc : HilbertCurve, start : Int, end : Int) -> Array[(Int, Int)] { +pub fn hilbert_point_to_segment( + hc : HilbertCurve, + start : Int, + end : Int, +) -> Array[(Int, Int)] { let segments : Array[(Int, Int)] = Array::new() - + let mut i = start while i <= end { let coords = hilbert_decode(hc, i) @@ -131,44 +135,54 @@ pub fn hilbert_point_to_segment(hc : HilbertCurve, start : Int, end : Int) -> Ar } i = i + 1 } - + segments } ///| -pub fn hilbert_distance(hc : HilbertCurve, coord1 : Array[Int], coord2 : Array[Int]) -> Int { +pub fn hilbert_distance( + hc : HilbertCurve, + coord1 : Array[Int], + coord2 : Array[Int], +) -> Int { let idx1 = hilbert_encode(hc, coord1) let idx2 = hilbert_encode(hc, coord2) - + let diff = if idx1 > idx2 { idx1 - idx2 } else { idx2 - idx1 } diff } ///| -pub fn hilbert_linearize_genome(genome_length : Int, levels : Int) -> Array[(Int, Int)] { +pub fn hilbert_linearize_genome( + genome_length : Int, + levels : Int, +) -> Array[(Int, Int)] { let hc = HilbertCurve::new(levels, 2) let max_coord = (1 << levels) - 1 - + let segments : Array[(Int, Int)] = Array::new() - + let mut i = 0 while i < genome_length { let x = i % (max_coord + 1) let y = i / (max_coord + 1) - + let idx = hilbert_encode(hc, [x, y]) segments.push((i, idx)) i = i + 1 } - + segments } ///| -pub fn hilbert_map_to_grid(hc : HilbertCurve, values : Array[Double]) -> Array[Array[Double]] { +pub fn hilbert_map_to_grid( + hc : HilbertCurve, + values : Array[Double], +) -> Array[Array[Double]] { let size = hc.max_coordinate + 1 let grid : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < size { let row : Array[Double] = Array::new() @@ -180,7 +194,7 @@ pub fn hilbert_map_to_grid(hc : HilbertCurve, values : Array[Double]) -> Array[A grid.push(row) i = i + 1 } - + let mut idx = 0 while idx < values.length() { let coords = hilbert_decode(hc, idx) @@ -193,7 +207,7 @@ pub fn hilbert_map_to_grid(hc : HilbertCurve, values : Array[Double]) -> Array[A } idx = idx + 1 } - + grid } diff --git a/src/hmisc.mbt b/src/hmisc.mbt index a916c54e..ee2cb936 100644 --- a/src/hmisc.mbt +++ b/src/hmisc.mbt @@ -11,6 +11,7 @@ pub enum HmiscCorType { HC_Spearman } +///| /// Convert correlation type to string. pub fn hmisc_cor_type_to_string(ct : HmiscCorType) -> String { match ct { @@ -90,7 +91,10 @@ pub struct HmiscSomersResult { ///| /// Compute descriptive statistics for an array of values. /// Missing values (NaN) are automatically excluded. -pub fn hmisc_describe(values : Array[Double], name? : String = "") -> HmiscDescriptiveStats { +pub fn hmisc_describe( + values : Array[Double], + name? : String = "", +) -> HmiscDescriptiveStats { let valid : Array[Double] = Array::new() let mut n_missing = 0 let mut i = 0 @@ -233,7 +237,15 @@ fn hmisc_rank_array(data : Array[Double]) -> Array[Double] { indices[i] = i i = i + 1 } - indices.sort_by(fn(a : Int, b : Int) -> Int { if data[a] < data[b] { -1 } else if data[a] > data[b] { 1 } else { 0 } }) + indices.sort_by(fn(a : Int, b : Int) -> Int { + if data[a] < data[b] { + -1 + } else if data[a] > data[b] { + 1 + } else { + 0 + } + }) let ranks = Array::make(n, 0.0) i = 0 while i < n { @@ -241,7 +253,7 @@ fn hmisc_rank_array(data : Array[Double]) -> Array[Double] { while j < n - 1 && data[indices[j]] == data[indices[j + 1]] { j = j + 1 } - let avg = ((i + j).to_double() / 2.0) + 1.0 + let avg = (i + j).to_double() / 2.0 + 1.0 let mut k = i while k <= j { ranks[indices[k]] = avg @@ -309,7 +321,7 @@ pub fn hmisc_rcorr( } let p = if n_pair > 2 && !r.is_nan() { let t_stat = r * ((n_pair.to_double() - 2.0) / (1.0 - r * r)).sqrt() - 2.0 * hmisc_t_dist_p((t_stat.abs()), n_pair - 2) + 2.0 * hmisc_t_dist_p(t_stat.abs(), n_pair - 2) } else { @double.not_a_number } @@ -324,13 +336,7 @@ pub fn hmisc_rcorr( } i = i + 1 } - HmiscCorrResult::{ - matrix, - p_values, - n: n_matrix, - names: var_names, - cor_type, - } + HmiscCorrResult::{ matrix, p_values, n: n_matrix, names: var_names, cor_type } } ///| @@ -366,18 +372,32 @@ fn hmisc_ibeta(a : Double, b : Double, x : Double) -> Double { f = d let mut m = 1 while m <= max_iter { - let num = m.to_double() * (b - m.to_double()) * x / ((a + 2.0 * m.to_double() - 1.0) * (a + 2.0 * m.to_double())) + let num = m.to_double() * + (b - m.to_double()) * + x / + ((a + 2.0 * m.to_double() - 1.0) * (a + 2.0 * m.to_double())) d = 1.0 + num * d - if d.abs() < 1.0e-30 { d = 1.0e-30 } + if d.abs() < 1.0e-30 { + d = 1.0e-30 + } c_val = 1.0 + num / c_val - if c_val.abs() < 1.0e-30 { c_val = 1.0e-30 } + if c_val.abs() < 1.0e-30 { + c_val = 1.0e-30 + } d = 1.0 / d f = f * d * c_val - let num2 = -(a + m.to_double()) * (a + b + m.to_double()) * x / ((a + 2.0 * m.to_double()) * (a + 2.0 * m.to_double() + 1.0)) + let num2 = -(a + m.to_double()) * + (a + b + m.to_double()) * + x / + ((a + 2.0 * m.to_double()) * (a + 2.0 * m.to_double() + 1.0)) d = 1.0 + num2 * d - if d.abs() < 1.0e-30 { d = 1.0e-30 } + if d.abs() < 1.0e-30 { + d = 1.0e-30 + } c_val = 1.0 + num2 / c_val - if c_val.abs() < 1.0e-30 { c_val = 1.0e-30 } + if c_val.abs() < 1.0e-30 { + c_val = 1.0e-30 + } d = 1.0 / d let del = d * c_val f = f * del @@ -397,14 +417,8 @@ fn hmisc_log_gamma(x : Double) -> Double { } let g = 7.0 let c = [ - 0.99999999999980993, - 676.5203681218851, - -1259.1392167224028, - 771.32342877765313, - -176.61502916214059, - 12.507343278686905, - -0.13857109526572012, - 9.9843695780195716e-6, + 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, + -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7, ] let pi = 3.14159265358979323846 @@ -455,7 +469,11 @@ pub fn hmisc_varclus( names: var_names, } } - let cor_result = hmisc_rcorr(data, names=var_names, cor_type=HmiscCorType::HC_Pearson) + let cor_result = hmisc_rcorr( + data, + names=var_names, + cor_type=HmiscCorType::HC_Pearson, + ) let assignments = Array::make(n_vars, 0) let mut i = 0 while i < n_vars { @@ -533,7 +551,11 @@ fn hmisc_max_cluster_count(n_vars : Int, min_size : Int) -> Int { return 1 } let n_clusters = n_vars / min_size - if n_clusters < 1 { 1 } else { n_clusters } + if n_clusters < 1 { + 1 + } else { + n_clusters + } } ///| @@ -573,7 +595,11 @@ fn hmisc_cluster_similarity( } i = i + 1 } - if count > 0.0 { sum / count } else { 0.0 } + if count > 0.0 { + sum / count + } else { + 0.0 + } } ///| @@ -594,7 +620,10 @@ fn hmisc_unique_values(arr : Array[Int]) -> Array[Int] { ///| /// Compute Somers' d statistic for comparing two groups. -pub fn hmisc_somers_d(group1 : Array[Double], group2 : Array[Double]) -> HmiscSomersResult { +pub fn hmisc_somers_d( + group1 : Array[Double], + group2 : Array[Double], +) -> HmiscSomersResult { let n1 = group1.length() let n2 = group2.length() if n1 == 0 || n2 == 0 { @@ -621,11 +650,7 @@ pub fn hmisc_somers_d(group1 : Array[Double], group2 : Array[Double]) -> HmiscSo i = i + 1 } let total = (n1 * n2).to_double() - let d = if total > 0.0 { - (concordant - discordant) / total - } else { - 0.0 - } + let d = if total > 0.0 { (concordant - discordant) / total } else { 0.0 } let se = (4.0 * concordant * discordant / (total * total * total)).sqrt() HmiscSomersResult::{ d, @@ -691,7 +716,11 @@ fn hmisc_array_mean(data : Array[Double]) -> Double { } i = i + 1 } - if count > 0 { sum / count.to_double() } else { 0.0 } + if count > 0 { + sum / count.to_double() + } else { + 0.0 + } } ///| @@ -759,9 +788,13 @@ fn hmisc_fmt_dbl(value : Double, decimals : Int) -> String { if value.is_nan() { return " NA" } - let rounded = (value * @math.pow(10.0, decimals.to_double())).round() / @math.pow(10.0, decimals.to_double()) + let rounded = (value * @math.pow(10.0, decimals.to_double())).round() / + @math.pow(10.0, decimals.to_double()) let int_part = rounded.to_int() - let dec_part = ((rounded - int_part.to_double()) * @math.pow(10.0, decimals.to_double())).round().to_int() + let dec_part = ((rounded - int_part.to_double()) * + @math.pow(10.0, decimals.to_double())) + .round() + .to_int() if decimals == 0 { return "\{int_part}" } @@ -787,11 +820,17 @@ fn hmisc_pad_zeros(value : Int, length : Int) -> String { result + s } +///| /// Create a Pearson correlation type. -pub fn hmisc_cor_type_pearson() -> HmiscCorType { HmiscCorType::HC_Pearson } +pub fn hmisc_cor_type_pearson() -> HmiscCorType { + HmiscCorType::HC_Pearson +} +///| /// Create a Spearman correlation type. -pub fn hmisc_cor_type_spearman() -> HmiscCorType { HmiscCorType::HC_Spearman } +pub fn hmisc_cor_type_spearman() -> HmiscCorType { + HmiscCorType::HC_Spearman +} ///| /// Sample data for testing. diff --git a/src/hmmcopy.mbt b/src/hmmcopy.mbt index d8a2c306..aa18daf7 100644 --- a/src/hmmcopy.mbt +++ b/src/hmmcopy.mbt @@ -37,8 +37,8 @@ pub fn HMMcopyBin::new( start~ : Int, end~ : Int, reads~ : Int, - gc~ : Double = 0.5, - mappability~ : Double = 1.0, + gc? : Double = 0.5, + mappability? : Double = 1.0, ) -> HMMcopyBin { HMMcopyBin::{ chr, @@ -103,8 +103,8 @@ pub struct HMMcopyModel { /// Construct a new HMMcopyModel with default parameters. /// States: CN0, CN1, CN2, CN3, CN4, CN5, CN6 (7 states). pub fn HMMcopyModel::new( - num_states~ : Int = 7, - ploidy~ : Int = 2, + num_states? : Int = 7, + ploidy? : Int = 2, ) -> HMMcopyModel { // Default emission means: 0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0 (in CN2 units) let emissions = Array::make(num_states, 0.0) @@ -224,15 +224,7 @@ pub fn HMMcopySegment::new( num_bins~ : Int, mean_reads~ : Double, ) -> HMMcopySegment { - HMMcopySegment::{ - chr, - start, - end, - copy, - state, - num_bins, - mean_reads, - } + HMMcopySegment::{ chr, start, end, copy, state, num_bins, mean_reads } } // =========================================================================== @@ -244,7 +236,7 @@ pub fn HMMcopySegment::new( /// Bins are grouped by GC content and scaled to the global mean. pub fn hmmcopy_correct_gc( bins : Array[HMMcopyBin], - num_gc_bins~ : Int = 20, + num_gc_bins? : Int = 20, ) -> Array[HMMcopyBin] { let n = bins.length() if n == 0 { @@ -260,7 +252,13 @@ pub fn hmmcopy_correct_gc( let gc_bins = Array::make(num_gc_bins, Array::new()) for b in bins { let gc_idx = (b.gc * num_gc_bins.to_double()).to_int() - let clamped = if gc_idx < 0 { 0 } else if gc_idx >= num_gc_bins { num_gc_bins - 1 } else { gc_idx } + let clamped = if gc_idx < 0 { + 0 + } else if gc_idx >= num_gc_bins { + num_gc_bins - 1 + } else { + gc_idx + } gc_bins[clamped].push(b) } // Compute mean reads per GC bin @@ -323,8 +321,7 @@ fn hmmcopy_log_gaussian(x : Double, mean : Double, variance : Double) -> Double let diff = x - mean let log_2pi = 1.8378770664093453 let result = -0.5 * (log_2pi + @math.ln(variance)) - - diff * diff / - (2.0 * variance) + diff * diff / (2.0 * variance) result } @@ -453,9 +450,7 @@ pub fn hmmcopy_call_cnv( ///| /// Segment bins by merging consecutive bins with the same copy number. -pub fn hmmcopy_segment( - bins : Array[HMMcopyBin], -) -> Array[HMMcopySegment] { +pub fn hmmcopy_segment(bins : Array[HMMcopyBin]) -> Array[HMMcopySegment] { let segments = Array::new() let n = bins.length() if n == 0 { @@ -476,15 +471,17 @@ pub fn hmmcopy_segment( count = count + 1 j = j + 1 } - segments.push(HMMcopySegment::new( - chr=cur_chr, - start=start, - end=end, - copy=cur_copy, - state=bins[i].state, - num_bins=count, - mean_reads=sum_reads / count.to_double(), - )) + segments.push( + HMMcopySegment::new( + chr=cur_chr, + start~, + end~, + copy=cur_copy, + state=bins[i].state, + num_bins=count, + mean_reads=sum_reads / count.to_double(), + ), + ) i = j } segments @@ -588,21 +585,22 @@ pub fn hmmcopy_sample_bins() -> Array[HMMcopyBin] { while i < 100 { let reads = if i >= 10 && i < 20 { // CN0 region: very low reads - 2 + (i % 3) + 2 + i % 3 } else if i >= 60 && i < 70 { // CN3 region: elevated reads - 90 + (i % 10) + 90 + i % 10 } else { + 60 + // CN2 region: normal - 60 + (i % 10) + i % 10 } let gc = 0.4 + (i % 10).to_double() * 0.02 let bin = HMMcopyBin::new( chr="chr1", start=i * 100000, end=(i + 1) * 100000, - reads=reads, - gc=gc, + reads~, + gc~, mappability=0.95, ) bins.push(bin) diff --git a/src/hmmer_io.mbt b/src/hmmer_io.mbt index 80e0afbd..51e53a99 100644 --- a/src/hmmer_io.mbt +++ b/src/hmmer_io.mbt @@ -259,7 +259,14 @@ pub fn parse_hmmer3_domtab(content : String) -> Array[QueryResult] { ) let frags : Array[HSPFragment] = [frag] hsps.push( - HSP::new(tname, dh.description, frags, dh.score_dom, dh.i_evalue, dh.score_dom), + HSP::new( + tname, + dh.description, + frags, + dh.score_dom, + dh.i_evalue, + dh.score_dom, + ), ) tbs = tbs + dh.score_dom if dh.i_evalue < mev { @@ -386,12 +393,7 @@ pub fn parse_hmmer3_text(content : String) -> Array[QueryResult] { if cur_query_id.length() > 0 { results.push( QueryResult::new( - cur_query_id, - cur_query_desc, - cur_query_len, - cur_hits, - "hmmscan", - "3.0", + cur_query_id, cur_query_desc, cur_query_len, cur_hits, "hmmscan", "3.0", "", ), ) @@ -536,12 +538,7 @@ pub fn parse_hmmer3_text(content : String) -> Array[QueryResult] { if cur_query_id.length() > 0 { results.push( QueryResult::new( - cur_query_id, - cur_query_desc, - cur_query_len, - cur_hits, - "hmmscan", - "3.0", + cur_query_id, cur_query_desc, cur_query_len, cur_hits, "hmmscan", "3.0", "", ), ) @@ -619,41 +616,41 @@ fn hmmer_io_extract_double_after(s : String, marker : String) -> Double { /// Generate a small HMMER3 domtblout-format sample for tests and demos. pub fn hmmer3_domtab_sample() -> String { "# hmmsearch :: search profile(s) against a sequence database\n" + - "# HMMER 3.3.2 (Nov 2020)\n" + - "#\n" + - "# target name accession query name accession E-value score bias # of c-Evalue i-Evalue score bias from to from to exp reg clu ov env dom rep inc description of target\n" + - "#------------------- ---------- -------------------- ---------- --------- ------ ------ --- --- --------- --------- ------ ----- ----- ----- ----- ----- ----- ---- ---- ---- ---- ---- ---- ---- ---------------------\n" + - "sp|Q9Y2W8|A1BG_HUMAN Q9Y2W8 PF00001.28 PF00001 1.2e-50 200.3 5.1 1 1 1.2e-50 1.5e-53 200.3 5.1 1 150 1 150 1.0 1 0 0 1 1 1 1 Alpha-1-B glycoprotein\n" + - "sp|P12345|ABC_HUMAN P12345 PF00001.28 PF00001 3.4e-30 150.1 2.0 1 2 3.4e-30 4.0e-33 150.1 2.0 1 120 1 120 1.0 1 0 0 1 1 1 1 ABC transporter\n" + - "sp|P12345|ABC_HUMAN P12345 PF00001.28 PF00001 3.4e-30 150.1 2.0 2 2 5.0e-20 6.0e-23 100.5 1.0 1 90 1 90 1.0 1 0 0 1 1 1 1 ABC transporter C-term\n" + "# HMMER 3.3.2 (Nov 2020)\n" + + "#\n" + + "# target name accession query name accession E-value score bias # of c-Evalue i-Evalue score bias from to from to exp reg clu ov env dom rep inc description of target\n" + + "#------------------- ---------- -------------------- ---------- --------- ------ ------ --- --- --------- --------- ------ ----- ----- ----- ----- ----- ----- ---- ---- ---- ---- ---- ---- ---- ---------------------\n" + + "sp|Q9Y2W8|A1BG_HUMAN Q9Y2W8 PF00001.28 PF00001 1.2e-50 200.3 5.1 1 1 1.2e-50 1.5e-53 200.3 5.1 1 150 1 150 1.0 1 0 0 1 1 1 1 Alpha-1-B glycoprotein\n" + + "sp|P12345|ABC_HUMAN P12345 PF00001.28 PF00001 3.4e-30 150.1 2.0 1 2 3.4e-30 4.0e-33 150.1 2.0 1 120 1 120 1.0 1 0 0 1 1 1 1 ABC transporter\n" + + "sp|P12345|ABC_HUMAN P12345 PF00001.28 PF00001 3.4e-30 150.1 2.0 2 2 5.0e-20 6.0e-23 100.5 1.0 1 90 1 90 1.0 1 0 0 1 1 1 1 ABC transporter C-term\n" } ///| /// Generate a small HMMER3 text-format sample for tests and demos. pub fn hmmer3_text_sample() -> String { "# hmmsearch :: search profile(s) against a sequence database\n" + - "# HMMER 3.3.2 (Nov 2020)\n" + - "#\n" + - "Query: PF00001.28 7tm_1\n" + - "Query length: 150\n" + - "Scores for complete sequences (score includes all domains):\n" + - " E-value score bias E-value score bias exp N Domain Description\n" + - " ------- ------ ----- ------- ------ ----- ---- --- ------ -----------\n" + - "sp|Q9Y2W8|A1BG_HUMAN 1.2e-50 200.3 5.1 1.5e-53 200.3 5.1 1.0 1 1 Alpha-1-B glycoprotein\n" + - "sp|P12345|ABC_HUMAN 3.4e-30 150.1 2.0 4.0e-33 150.1 2.0 1.0 1 1 ABC transporter\n" + - "\n" + - "Domain annotation for each sequence (and alignments):\n" + - ">> sp|Q9Y2W8|A1BG_HUMAN Alpha-1-B glycoprotein\n" + - " # score bias c-Evalue i-Evalue hmmfrom hmm to alifrom ali to envfrom env to acc\n" + - " --- ------ ----- --------- --------- ------- ------- ------- ------- ------- ------- ----\n" + - " 1 200.3 5.1 1.2e-50 1.5e-53 1 150 1 150 1 150 0.90\n" + - " == domain 1 score: 200.3 bits; conditional E-value: 1.5e-53\n" + - "\n" + - ">> sp|P12345|ABC_HUMAN ABC transporter\n" + - " # score bias c-Evalue i-Evalue hmmfrom hmm to alifrom ali to envfrom env to acc\n" + - " --- ------ ----- --------- --------- ------- ------- ------- ------- ------- ------- ----\n" + - " 1 150.1 2.0 3.4e-30 4.0e-33 1 120 1 120 1 120 0.88\n" + - " == domain 1 score: 150.1 bits; conditional E-value: 4.0e-33\n" + "# HMMER 3.3.2 (Nov 2020)\n" + + "#\n" + + "Query: PF00001.28 7tm_1\n" + + "Query length: 150\n" + + "Scores for complete sequences (score includes all domains):\n" + + " E-value score bias E-value score bias exp N Domain Description\n" + + " ------- ------ ----- ------- ------ ----- ---- --- ------ -----------\n" + + "sp|Q9Y2W8|A1BG_HUMAN 1.2e-50 200.3 5.1 1.5e-53 200.3 5.1 1.0 1 1 Alpha-1-B glycoprotein\n" + + "sp|P12345|ABC_HUMAN 3.4e-30 150.1 2.0 4.0e-33 150.1 2.0 1.0 1 1 ABC transporter\n" + + "\n" + + "Domain annotation for each sequence (and alignments):\n" + + ">> sp|Q9Y2W8|A1BG_HUMAN Alpha-1-B glycoprotein\n" + + " # score bias c-Evalue i-Evalue hmmfrom hmm to alifrom ali to envfrom env to acc\n" + + " --- ------ ----- --------- --------- ------- ------- ------- ------- ------- ------- ----\n" + + " 1 200.3 5.1 1.2e-50 1.5e-53 1 150 1 150 1 150 0.90\n" + + " == domain 1 score: 200.3 bits; conditional E-value: 1.5e-53\n" + + "\n" + + ">> sp|P12345|ABC_HUMAN ABC transporter\n" + + " # score bias c-Evalue i-Evalue hmmfrom hmm to alifrom ali to envfrom env to acc\n" + + " --- ------ ----- --------- --------- ------- ------- ------- ------- ------- ------- ----\n" + + " 1 150.1 2.0 3.4e-30 4.0e-33 1 120 1 120 1 120 0.88\n" + + " == domain 1 score: 150.1 bits; conditional E-value: 4.0e-33\n" } ///| diff --git a/src/hs_exposure.mbt b/src/hs_exposure.mbt index dd43cc00..5846c551 100644 --- a/src/hs_exposure.mbt +++ b/src/hs_exposure.mbt @@ -29,7 +29,12 @@ pub struct PDBAtom { } ///| -pub fn PDBAtom::new(name : String, x : Double, y : Double, z : Double) -> PDBAtom { +pub fn PDBAtom::new( + name : String, + x : Double, + y : Double, + z : Double, +) -> PDBAtom { PDBAtom::{ name, x, y, z } } @@ -42,7 +47,12 @@ pub struct HSExposureResult { } ///| -pub fn HSExposureResult::new(residue_name : String, hse_up : Double, hse_down : Double, hse_total : Double) -> HSExposureResult { +pub fn HSExposureResult::new( + residue_name : String, + hse_up : Double, + hse_down : Double, + hse_total : Double, +) -> HSExposureResult { HSExposureResult::{ residue_name, hse_up, hse_down, hse_total } } @@ -51,74 +61,84 @@ fn atom_distance(a1 : PDBAtom, a2 : PDBAtom) -> Double { let dx = a1.x - a2.x let dy = a1.y - a2.y let dz = a1.z - a2.z - + hse_sqrt(dx * dx + dy * dy + dz * dz) } ///| -pub fn calculate_hse(ca_atom : PDBAtom, cb_atom : PDBAtom, n_atom : PDBAtom, all_ca_atoms : Array[PDBAtom]) -> HSExposureResult { +pub fn calculate_hse( + ca_atom : PDBAtom, + cb_atom : PDBAtom, + n_atom : PDBAtom, + all_ca_atoms : Array[PDBAtom], +) -> HSExposureResult { let mut hse_up = 0 let mut hse_down = 0 - + let mut i = 0 while i < all_ca_atoms.length() { let other_ca = all_ca_atoms[i] - + if other_ca.name == ca_atom.name { i = i + 1 continue } - + let dist = atom_distance(ca_atom, other_ca) - + if dist <= 10.0 && dist > 0.0 { let dx = other_ca.x - ca_atom.x let dy = other_ca.y - ca_atom.y let dz = other_ca.z - ca_atom.z - + let cb_dx = cb_atom.x - ca_atom.x let cb_dy = cb_atom.y - ca_atom.y let cb_dz = cb_atom.z - ca_atom.z - + let n_dx = n_atom.x - ca_atom.x let n_dy = n_atom.y - ca_atom.y let n_dz = n_atom.z - ca_atom.z - + let nx = cb_dy * n_dz - cb_dz * n_dy let ny = cb_dz * n_dx - cb_dx * n_dz let nz = cb_dx * n_dy - cb_dy * n_dx - + let dot = dx * nx + dy * ny + dz * nz - + if dot > 0.0 { hse_up = hse_up + 1 } else if dot < 0.0 { hse_down = hse_down + 1 } } - + i = i + 1 } - - HSExposureResult::new(ca_atom.name, hse_up.to_double(), hse_down.to_double(), (hse_up + hse_down).to_double()) + + HSExposureResult::new( + ca_atom.name, + hse_up.to_double(), + hse_down.to_double(), + (hse_up + hse_down).to_double(), + ) } ///| pub fn create_example_atoms() -> Array[PDBAtom] { let atoms : Array[PDBAtom] = Array::new() - + atoms.push(PDBAtom::new("CA1", 0.0, 0.0, 0.0)) atoms.push(PDBAtom::new("CB1", 1.5, 0.0, 0.0)) atoms.push(PDBAtom::new("N1", 0.0, 1.5, 0.0)) - + atoms.push(PDBAtom::new("CA2", 3.0, 0.0, 0.0)) atoms.push(PDBAtom::new("CB2", 4.5, 0.0, 0.0)) atoms.push(PDBAtom::new("N2", 3.0, 1.5, 0.0)) - + atoms.push(PDBAtom::new("CA3", 0.0, 3.0, 0.0)) atoms.push(PDBAtom::new("CB3", 1.5, 3.0, 0.0)) atoms.push(PDBAtom::new("N3", 0.0, 4.5, 0.0)) - + atoms } @@ -131,4 +151,4 @@ pub fn classify_exposure(hse_total : Double) -> String { } else { "exposed" } -} \ No newline at end of file +} diff --git a/src/htsfilter.mbt b/src/htsfilter.mbt index 5fc151ce..d7e68fc0 100644 --- a/src/htsfilter.mbt +++ b/src/htsfilter.mbt @@ -23,7 +23,10 @@ pub struct HTSFilterResult { /// Compute CPM (Counts Per Million) matrix from raw counts and library sizes. /// counts: genes × samples /// Returns: genes × samples CPM values -pub fn hts_filter_cpm(counts : Array[Array[Double]], library_sizes : Array[Double]) -> Array[Array[Double]] { +pub fn hts_filter_cpm( + counts : Array[Array[Double]], + library_sizes : Array[Double], +) -> Array[Array[Double]] { let n_genes = counts.length() if n_genes == 0 { return [] @@ -93,9 +96,9 @@ pub fn hts_filter( let n_genes = counts.length() if n_genes == 0 { return HTSFilterResult::{ - cpm_threshold: cpm_threshold, - min_samples_per_group: min_samples_per_group, - groups: groups, + cpm_threshold, + min_samples_per_group, + groups, cpm_matrix: [], keep: [], n_genes_input: 0, @@ -115,10 +118,15 @@ pub fn hts_filter( let mut found = false let mut j = 0 while j < unique_groups.length() { - if unique_groups[j] == g { found = true; break } + if unique_groups[j] == g { + found = true + break + } j = j + 1 } - if !found { unique_groups.push(g) } + if !found { + unique_groups.push(g) + } i = i + 1 } @@ -145,16 +153,18 @@ pub fn hts_filter( ug = ug + 1 } keep.push(gene_kept) - if gene_kept { kept = kept + 1 } + if gene_kept { + kept = kept + 1 + } g = g + 1 } HTSFilterResult::{ - cpm_threshold: cpm_threshold, - min_samples_per_group: min_samples_per_group, - groups: groups, + cpm_threshold, + min_samples_per_group, + groups, cpm_matrix: cpm_mat, - keep: keep, + keep, n_genes_input: n_genes, n_genes_kept: kept, n_genes_removed: n_genes - kept, @@ -164,7 +174,10 @@ pub fn hts_filter( ///| /// Apply a keep mask to filter a count matrix. /// Returns only the rows (genes) where keep[i] is true. -pub fn hts_filter_apply(counts : Array[Array[Double]], keep : Array[Bool]) -> Array[Array[Double]] { +pub fn hts_filter_apply( + counts : Array[Array[Double]], + keep : Array[Bool], +) -> Array[Array[Double]] { let result : Array[Array[Double]] = [] let mut i = 0 while i < counts.length() { @@ -178,7 +191,10 @@ pub fn hts_filter_apply(counts : Array[Array[Double]], keep : Array[Bool]) -> Ar ///| /// Apply keep mask to a gene name list. -pub fn hts_filter_apply_names(gene_names : Array[String], keep : Array[Bool]) -> Array[String] { +pub fn hts_filter_apply_names( + gene_names : Array[String], + keep : Array[Bool], +) -> Array[String] { let result : Array[String] = [] let mut i = 0 while i < gene_names.length() { @@ -194,21 +210,38 @@ pub fn hts_filter_apply_names(gene_names : Array[String], keep : Array[Bool]) -> /// Summarize the filtering result as a string. pub fn hts_filter_summary(result : HTSFilterResult) -> String { "HTSFilter Summary:\n" + - " CPM threshold: " + result.cpm_threshold.to_string() + "\n" + - " Min samples per group: " + result.min_samples_per_group.to_string() + "\n" + - " Input genes: " + result.n_genes_input.to_string() + "\n" + - " Genes kept: " + result.n_genes_kept.to_string() + "\n" + - " Genes removed: " + result.n_genes_removed.to_string() + "\n" + - " Retention rate: " + - (if result.n_genes_input > 0 { - (result.n_genes_kept.to_double() / result.n_genes_input.to_double() * 100.0).to_string() - } else { "0.0" }) + "%" + " CPM threshold: " + + result.cpm_threshold.to_string() + + "\n" + + " Min samples per group: " + + result.min_samples_per_group.to_string() + + "\n" + + " Input genes: " + + result.n_genes_input.to_string() + + "\n" + + " Genes kept: " + + result.n_genes_kept.to_string() + + "\n" + + " Genes removed: " + + result.n_genes_removed.to_string() + + "\n" + + " Retention rate: " + + (if result.n_genes_input > 0 { + (result.n_genes_kept.to_double() / result.n_genes_input.to_double() * 100.0).to_string() + } else { + "0.0" + }) + + "%" } ///| /// Generate sample RNA-seq count data for testing. /// Returns tuple of (counts, groups, gene_names). -pub fn hts_filter_sample_data() -> (Array[Array[Double]], Array[Int], Array[String]) { +pub fn hts_filter_sample_data() -> ( + Array[Array[Double]], + Array[Int], + Array[String], +) { // 20 genes x 6 samples (3 control + 3 treatment) let n_genes = 20 let n_samples = 6 @@ -225,7 +258,7 @@ pub fn hts_filter_sample_data() -> (Array[Array[Double]], Array[Int], Array[Stri // Next 5 genes: moderate expression (~50-200 CPM) // Last 5 genes: low expression (~1-10 CPM) let base = if g < 10 { 2000.0 } else if g < 15 { 100.0 } else { 5.0 } - let noise = (((g * 7 + s * 13) % 100).to_double() / 100.0) * base * 0.5 + let noise = ((g * 7 + s * 13) % 100).to_double() / 100.0 * base * 0.5 let val = base + noise row.push(val) s = s + 1 diff --git a/src/ig_io.mbt b/src/ig_io.mbt index 494d4606..abecc961 100644 --- a/src/ig_io.mbt +++ b/src/ig_io.mbt @@ -37,7 +37,7 @@ pub struct IgRecord { pub fn IgRecord::new( title : String, comment : String, - sequence : String + sequence : String, ) -> IgRecord { IgRecord::{ title, comment, sequence } } @@ -136,7 +136,7 @@ fn ig_starts_with2(line : String, c1 : UInt16, c2 : UInt16) -> Bool { fn ig_strip_cr(line : String) -> String { let n = line.length() if n > 0 && line.unsafe_get(n - 1) == ig_char_code('\r') { - line[0 : n - 1].to_owned() + line[0:n - 1].to_owned() } else { line } @@ -171,7 +171,7 @@ fn ig_strip(s : String) -> String { if start == 0 && end == n { s } else { - s[start : end].to_owned() + s[start:end].to_owned() } } @@ -293,7 +293,7 @@ pub fn ig_parse(content : String) -> Array[IgRecord] { // Strip an optional trailing "1" terminator. let sn = seq_str.length() if sn > 0 && seq_str.unsafe_get(sn - 1) == one { - seq_str = seq_str[0 : sn - 1].to_owned() + seq_str = seq_str[0:sn - 1].to_owned() } let comment = ig_join_lines(comment_parts) records.push(IgRecord::new(title, comment, seq_str)) @@ -349,10 +349,7 @@ pub fn ig_record_to_string(record : IgRecord) -> String { ///| /// Render an `IgRecord` with a custom sequence line width. A width <= 0 /// disables wrapping (the sequence is emitted on a single line). -pub fn ig_record_to_string_width( - record : IgRecord, - width : Int -) -> String { +pub fn ig_record_to_string_width(record : IgRecord, width : Int) -> String { let buf = StringBuilder::new() // Comment lines. if record.comment.length() > 0 { @@ -385,7 +382,7 @@ pub fn ig_record_to_string_width( let mut i = 0 while i < n { let end = if i + width < n { i + width } else { n } - buf.write_string(seq[i : end].to_owned()) + buf.write_string(seq[i:end].to_owned()) buf.write_char('\n') i = end } @@ -403,7 +400,7 @@ pub fn ig_record_to_string_width( /// does not already start with one. pub fn ig_records_to_string( records : Array[IgRecord], - file_header : Array[String]? + file_header : Array[String]?, ) -> String { let buf = StringBuilder::new() // Optional file header. @@ -517,9 +514,7 @@ pub fn ig_sample_file_header() -> Array[String] { /// Build a sample `IgRecord` for testing. pub fn ig_sample_record() -> IgRecord { IgRecord::new( - "A_U455", - "HIV-1 group M subtype A", - "ATGGCAGCTGTGATGAAGCAGAGACGGGTAAGAGCTC", + "A_U455", "HIV-1 group M subtype A", "ATGGCAGCTGTGATGAAGCAGAGACGGGTAAGAGCTC", ) } @@ -527,8 +522,6 @@ pub fn ig_sample_record() -> IgRecord { /// Build a second sample `IgRecord` for testing. pub fn ig_sample_record_2() -> IgRecord { IgRecord::new( - "B_HXB2R", - "HIV-1 group M subtype B", - "ATGGGTGCTGTGATGAAGCAGAGACGGGTAAGAGCTC", + "B_HXB2R", "HIV-1 group M subtype B", "ATGGGTGCTGTGATGAAGCAGAGACGGGTAAGAGCTC", ) } diff --git a/src/ihw.mbt b/src/ihw.mbt index 77bbacb8..2e8ab724 100644 --- a/src/ihw.mbt +++ b/src/ihw.mbt @@ -156,7 +156,11 @@ fn ihw_storey_pi0( let weight = if i < covariates.length() { let c = covariates[i] let w = 1.0 - (c - 0.5) * (c - 0.5) * 2.0 - if w < 0.1 { 0.1 } else { w } + if w < 0.1 { + 0.1 + } else { + w + } } else { 1.0 } @@ -170,7 +174,11 @@ fn ihw_storey_pi0( return 1.0 } let pi0 = count / ((1.0 - lambda) * total_weight) - if pi0 > 1.0 { 1.0 } else { pi0 } + if pi0 > 1.0 { + 1.0 + } else { + pi0 + } } ///| @@ -243,10 +251,7 @@ fn ihw_sum_weights(weights : Array[Double]) -> Double { ///| /// Assign hypotheses to bins based on covariate quantiles. /// Returns bin indices (0 to n_bins-1) for each hypothesis. -fn bin_covariates( - covariates : Array[Double], - n_bins : Int, -) -> Array[Int] { +fn bin_covariates(covariates : Array[Double], n_bins : Int) -> Array[Int] { let n = covariates.length() let result : Array[Int] = Array::make(n, 0) if n <= n_bins || n_bins <= 1 { @@ -258,8 +263,14 @@ fn bin_covariates( indexed[i] = [covariates[i], i.to_double()] i = i + 1 } - indexed.sort_by(fn(a: Array[Double], b: Array[Double]) -> Int { - if a[0] < b[0] { -1 } else if a[0] > b[0] { 1 } else { 0 } + indexed.sort_by(fn(a : Array[Double], b : Array[Double]) -> Int { + if a[0] < b[0] { + -1 + } else if a[0] > b[0] { + 1 + } else { + 0 + } }) let bin_size = (n.to_double() / n_bins.to_double()).ceil().to_int() i = 0 @@ -387,7 +398,7 @@ pub fn ihw( covariates : Array[Double], alpha : Double, ) -> IHWResult { - let config = IHWConfig::new(alpha=alpha, n_attempts=10, scale_type="local") + let config = IHWConfig::new(alpha~, n_attempts=10, scale_type="local") ihw_with_config(p_values, covariates, config) } @@ -411,17 +422,18 @@ pub fn ihw_with_config( let effective_n = if n < n_cov { n } else { n_cov } if effective_n == 0 { - return IHWResult::new( - [], - [], - [], - [], - config.alpha, - 0, - ) + return IHWResult::new([], [], [], [], config.alpha, 0) } - let n_bins = if effective_n > 20 { 20 } else { if effective_n > 10 { 10 } else { if effective_n > 5 { 5 } else { 1 } } } + let n_bins = if effective_n > 20 { + 20 + } else if effective_n > 10 { + 10 + } else if effective_n > 5 { + 5 + } else { + 1 + } let mut weights = initialize_weights(covariates, config.scale_type) let bins = bin_covariates(covariates, n_bins) @@ -623,8 +635,14 @@ pub fn storey_ihw( temp[i] = [p_values[i], i.to_double()] i = i + 1 } - temp.sort_by(fn(a: Array[Double], b: Array[Double]) -> Int { - if a[0] < b[0] { -1 } else if a[0] > b[0] { 1 } else { 0 } + temp.sort_by(fn(a : Array[Double], b : Array[Double]) -> Int { + if a[0] < b[0] { + -1 + } else if a[0] > b[0] { + 1 + } else { + 0 + } }) i = n - 1 @@ -651,4 +669,4 @@ pub fn storey_ihw( /// Array of weights used in the correction pub fn ihw_weights(result : IHWResult) -> Array[Double] { result.weights -} \ No newline at end of file +} diff --git a/src/imgt_io.mbt b/src/imgt_io.mbt index c9ad4d07..c80558c1 100644 --- a/src/imgt_io.mbt +++ b/src/imgt_io.mbt @@ -308,23 +308,21 @@ pub fn imgt_parse_header(line : String) -> ImgtHeader? { let sl = imgt_field_or_empty(fields, count, 10) let st = imgt_field_or_empty(fields, count, 11) let cm = imgt_field_or_empty(fields, count, 12) - Some( - ImgtHeader::{ - accession: acc, - seq_id: sid, - official_name: on, - region: reg, - date_update: du, - date_creation: dc, - species: sp, - gene: gn, - imgt_group: ig, - locus: lo, - seq_length: sl, - seq_type: st, - comments: cm, - }, - ) + Some(ImgtHeader::{ + accession: acc, + seq_id: sid, + official_name: on, + region: reg, + date_update: du, + date_creation: dc, + species: sp, + gene: gn, + imgt_group: ig, + locus: lo, + seq_length: sl, + seq_type: st, + comments: cm, + }) } ///| @@ -362,7 +360,10 @@ pub fn imgt_parse(content : String) -> Array[ImgtRecord] { if line.unsafe_get(0) == gt { match current_header { Some(h) => - records.push(ImgtRecord::{ header: h, sequence: current_seq.to_string() }) + records.push(ImgtRecord::{ + header: h, + sequence: current_seq.to_string(), + }) None => () } match imgt_parse_header(line[0:trimmed_len].to_owned()) { @@ -621,68 +622,62 @@ pub fn imgt_from_seq_records(records : Array[SeqRecord]) -> Array[ImgtRecord] { pub fn imgt_sample_records() -> Array[ImgtRecord] { let out = Array::new() // HLA-A*01:01:01:01 (human) - out.push( - ImgtRecord::{ - header: ImgtHeader::{ - accession: "HLA00001", - seq_id: "A*01:01:01:01", - official_name: "A*01:01:01:01", - region: "ORF", - date_update: "2015-03-31", - date_creation: "1996-01-19", - species: "human", - gene: "HLA-A", - imgt_group: "I", - locus: "MHC", - seq_length: "2703 bp", - seq_type: " genomic-DNA", - comments: "", - }, - sequence: "ATGGCCGTCATGGCGCCCCGAACCCTCCTCCTC", + out.push(ImgtRecord::{ + header: ImgtHeader::{ + accession: "HLA00001", + seq_id: "A*01:01:01:01", + official_name: "A*01:01:01:01", + region: "ORF", + date_update: "2015-03-31", + date_creation: "1996-01-19", + species: "human", + gene: "HLA-A", + imgt_group: "I", + locus: "MHC", + seq_length: "2703 bp", + seq_type: " genomic-DNA", + comments: "", }, - ) + sequence: "ATGGCCGTCATGGCGCCCCGAACCCTCCTCCTC", + }) // HLA-A*02:01:01:01 (human) - out.push( - ImgtRecord::{ - header: ImgtHeader::{ - accession: "HLA00002", - seq_id: "A*02:01:01:01", - official_name: "A*02:01:01:01", - region: "ORF", - date_update: "2016-05-12", - date_creation: "1996-01-19", - species: "human", - gene: "HLA-A", - imgt_group: "I", - locus: "MHC", - seq_length: "2709 bp", - seq_type: " genomic-DNA", - comments: "", - }, - sequence: "ATGGCCGTCATGGCGCCCCGAACCCTCCTCCTG", + out.push(ImgtRecord::{ + header: ImgtHeader::{ + accession: "HLA00002", + seq_id: "A*02:01:01:01", + official_name: "A*02:01:01:01", + region: "ORF", + date_update: "2016-05-12", + date_creation: "1996-01-19", + species: "human", + gene: "HLA-A", + imgt_group: "I", + locus: "MHC", + seq_length: "2709 bp", + seq_type: " genomic-DNA", + comments: "", }, - ) + sequence: "ATGGCCGTCATGGCGCCCCGAACCCTCCTCCTG", + }) // HLA-B*07:02:01 (human) - out.push( - ImgtRecord::{ - header: ImgtHeader::{ - accession: "HLA00003", - seq_id: "B*07:02:01", - official_name: "B*07:02:01", - region: "ORF", - date_update: "2017-07-18", - date_creation: "1996-01-19", - species: "human", - gene: "HLA-B", - imgt_group: "I", - locus: "MHC", - seq_length: "2711 bp", - seq_type: " genomic-DNA", - comments: "", - }, - sequence: "ATGGCGCCCCGAACCCTCCTCCTGCTGCTCTC", + out.push(ImgtRecord::{ + header: ImgtHeader::{ + accession: "HLA00003", + seq_id: "B*07:02:01", + official_name: "B*07:02:01", + region: "ORF", + date_update: "2017-07-18", + date_creation: "1996-01-19", + species: "human", + gene: "HLA-B", + imgt_group: "I", + locus: "MHC", + seq_length: "2711 bp", + seq_type: " genomic-DNA", + comments: "", }, - ) + sequence: "ATGGCGCCCCGAACCCTCCTCCTGCTGCTCTC", + }) out } diff --git a/src/impute.mbt b/src/impute.mbt index c2b9bb86..8ab0f079 100644 --- a/src/impute.mbt +++ b/src/impute.mbt @@ -19,12 +19,18 @@ /// * apply_value_clamp - Post-impute min/max clamping to preserve physiological range // ---- utility: MoonBit does not expose a Double::INFINITY constant in core ---- -fn impute_infinity() -> Double { 1.7976931348623157e+308 } +fn impute_infinity() -> Double { + 1.7976931348623157e+308 +} -fn impute_is_na(x : Double) -> Bool { x.is_nan() } +///| +fn impute_is_na(x : Double) -> Bool { + x.is_nan() +} // ---- struct definitions ----------------------------------------------------- +///| pub struct ImputeNAStats { total_rows : Int total_cols : Int @@ -36,26 +42,38 @@ pub struct ImputeNAStats { col_na_counts : Array[Int] } +///| pub struct KNNImputeParam { pub mut k : Int pub by_row : Bool pub eps : Double - pub max_value : Option[Double] - pub min_value : Option[Double] + pub max_value : Double? + pub min_value : Double? } +///| pub fn KNNImputeParam::new() -> KNNImputeParam { - KNNImputeParam::{ k: 10, by_row: true, eps: 0.000001, max_value: None, min_value: None, } + KNNImputeParam::{ + k: 10, + by_row: true, + eps: 0.000001, + max_value: None, + min_value: None, + } } +///| pub fn KNNImputeParam::with_k(k : Int) -> KNNImputeParam { let p = KNNImputeParam::new() - if k >= 1 { p.k = k } + if k >= 1 { + p.k = k + } p } // ---- generic helpers -------------------------------------------------------- +///| fn impute_copy_matrix(mat : Array[Array[Double]]) -> Array[Array[Double]] { let n = mat.length() let out : Array[Array[Double]] = Array::new() @@ -71,8 +89,11 @@ fn impute_copy_matrix(mat : Array[Array[Double]]) -> Array[Array[Double]] { out } +///| fn impute_transpose(mat : Array[Array[Double]]) -> Array[Array[Double]] { - if mat.length() == 0 { return Array::new() } + if mat.length() == 0 { + return Array::new() + } let rows = mat.length() let cols = mat[0].length() let out : Array[Array[Double]] = Array::new() @@ -86,6 +107,7 @@ fn impute_transpose(mat : Array[Array[Double]]) -> Array[Array[Double]] { out } +///| /// Mark which positions are missing (NA). True => NA. pub fn make_na_mask(mat : Array[Array[Double]]) -> Array[Array[Bool]] { let out : Array[Array[Bool]] = Array::new() @@ -99,6 +121,7 @@ pub fn make_na_mask(mat : Array[Array[Double]]) -> Array[Array[Bool]] { out } +///| /// Compute summary of missing data. pub fn impute_na_stats(mat : Array[Array[Double]]) -> ImputeNAStats { let rows = mat.length() @@ -117,17 +140,17 @@ pub fn impute_na_stats(mat : Array[Array[Double]]) -> ImputeNAStats { } } row_counts.push(rc) - if rc > 0 { r_na = r_na + 1 } + if rc > 0 { + r_na = r_na + 1 + } } let mut c_na = 0 for j = 0; j < cols; j = j + 1 { - if col_counts[j] > 0 { c_na = c_na + 1 } - } - let denom = if rows * cols == 0 { - 1.0 - } else { - (rows * cols).to_double() + if col_counts[j] > 0 { + c_na = c_na + 1 + } } + let denom = if rows * cols == 0 { 1.0 } else { (rows * cols).to_double() } ImputeNAStats::{ total_rows: rows, total_cols: cols, @@ -140,16 +163,24 @@ pub fn impute_na_stats(mat : Array[Array[Double]]) -> ImputeNAStats { } } +///| pub fn impute_na_summary(stats : ImputeNAStats) -> String { let buf = StringBuilder::new() - buf.write_string("ImputeNAStats [\{stats.total_rows} x \{stats.total_cols}]\n") + buf.write_string( + "ImputeNAStats [\{stats.total_rows} x \{stats.total_cols}]\n", + ) let pct = stats.na_fraction * 100.0 buf.write_string(" total NAs: \{stats.total_na} (\{pct}%)\n") - buf.write_string(" rows with NA: \{stats.rows_with_na} / \{stats.total_rows}\n") - buf.write_string(" cols with NA: \{stats.cols_with_na} / \{stats.total_cols}\n") + buf.write_string( + " rows with NA: \{stats.rows_with_na} / \{stats.total_rows}\n", + ) + buf.write_string( + " cols with NA: \{stats.cols_with_na} / \{stats.total_cols}\n", + ) buf.to_string() } +///| fn impute_mean_clean(arr : Array[Double]) -> Double { let mut s = 0.0 let mut c = 0 @@ -159,19 +190,34 @@ fn impute_mean_clean(arr : Array[Double]) -> Double { c = c + 1 } } - if c == 0 { 0.0 } else { s / c.to_double() } + if c == 0 { + 0.0 + } else { + s / c.to_double() + } } +///| fn impute_median_clean(arr : Array[Double]) -> Double { let clean : Array[Double] = Array::new() for x in arr { - if !impute_is_na(x) { clean.push(x) } + if !impute_is_na(x) { + clean.push(x) + } } clean.sort_by(fn(a : Double, b : Double) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) let n = clean.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mid = n / 2 if n % 2 == 0 { (clean[mid - 1] + clean[mid]) / 2.0 @@ -180,14 +226,22 @@ fn impute_median_clean(arr : Array[Double]) -> Double { } } +///| fn impute_min_clean(arr : Array[Double]) -> Double { let mut m = impute_infinity() for x in arr { - if !impute_is_na(x) && x < m { m = x } + if !impute_is_na(x) && x < m { + m = x + } + } + if impute_is_na(m) || m == impute_infinity() { + 0.0 + } else { + m } - if impute_is_na(m) || m == impute_infinity() { 0.0 } else { m } } +///| fn clamp_value(v : Double, p : KNNImputeParam) -> Double { let mut out = v match p.max_value { @@ -203,115 +257,152 @@ fn clamp_value(v : Double, p : KNNImputeParam) -> Double { // ---- simple column-wise imputers ------------------------------------------- +///| pub fn impute_na_by_mean(mat : Array[Array[Double]]) -> Array[Array[Double]] { impute_by_col_mean(mat) } +///| pub fn impute_na_by_median(mat : Array[Array[Double]]) -> Array[Array[Double]] { impute_by_col_median(mat) } +///| pub fn impute_na_by_min(mat : Array[Array[Double]]) -> Array[Array[Double]] { impute_by_col_min(mat) } +///| pub fn impute_na_by_zero(mat : Array[Array[Double]]) -> Array[Array[Double]] { let out = impute_copy_matrix(mat) for i = 0; i < out.length(); i = i + 1 { for j = 0; j < out[i].length(); j = j + 1 { - if impute_is_na(out[i][j]) { out[i][j] = 0.0 } + if impute_is_na(out[i][j]) { + out[i][j] = 0.0 + } } } out } +///| pub fn impute_by_row_mean(mat : Array[Array[Double]]) -> Array[Array[Double]] { let out = impute_copy_matrix(mat) for i = 0; i < out.length(); i = i + 1 { let mu = impute_mean_clean(out[i]) for j = 0; j < out[i].length(); j = j + 1 { - if impute_is_na(out[i][j]) { out[i][j] = mu } + if impute_is_na(out[i][j]) { + out[i][j] = mu + } } } out } +///| pub fn impute_by_col_mean(mat : Array[Array[Double]]) -> Array[Array[Double]] { - if mat.length() == 0 { return Array::new() } + if mat.length() == 0 { + return Array::new() + } let cols = mat[0].length() let means : Array[Double] = Array::new() for j = 0; j < cols; j = j + 1 { let c : Array[Double] = Array::new() - for i = 0; i < mat.length(); i = i + 1 { c.push(mat[i][j]) } + for i = 0; i < mat.length(); i = i + 1 { + c.push(mat[i][j]) + } means.push(impute_mean_clean(c)) } let out = impute_copy_matrix(mat) for i = 0; i < out.length(); i = i + 1 { for j = 0; j < cols; j = j + 1 { - if impute_is_na(out[i][j]) { out[i][j] = means[j] } + if impute_is_na(out[i][j]) { + out[i][j] = means[j] + } } } out } +///| pub fn impute_by_row_median(mat : Array[Array[Double]]) -> Array[Array[Double]] { let out = impute_copy_matrix(mat) for i = 0; i < out.length(); i = i + 1 { let med = impute_median_clean(out[i]) for j = 0; j < out[i].length(); j = j + 1 { - if impute_is_na(out[i][j]) { out[i][j] = med } + if impute_is_na(out[i][j]) { + out[i][j] = med + } } } out } +///| pub fn impute_by_col_median(mat : Array[Array[Double]]) -> Array[Array[Double]] { - if mat.length() == 0 { return Array::new() } + if mat.length() == 0 { + return Array::new() + } let cols = mat[0].length() let meds : Array[Double] = Array::new() for j = 0; j < cols; j = j + 1 { let c : Array[Double] = Array::new() - for i = 0; i < mat.length(); i = i + 1 { c.push(mat[i][j]) } + for i = 0; i < mat.length(); i = i + 1 { + c.push(mat[i][j]) + } meds.push(impute_median_clean(c)) } let out = impute_copy_matrix(mat) for i = 0; i < out.length(); i = i + 1 { for j = 0; j < cols; j = j + 1 { - if impute_is_na(out[i][j]) { out[i][j] = meds[j] } + if impute_is_na(out[i][j]) { + out[i][j] = meds[j] + } } } out } +///| pub fn impute_by_row_min(mat : Array[Array[Double]]) -> Array[Array[Double]] { let out = impute_copy_matrix(mat) for i = 0; i < out.length(); i = i + 1 { let mn = impute_min_clean(out[i]) for j = 0; j < out[i].length(); j = j + 1 { - if impute_is_na(out[i][j]) { out[i][j] = mn } + if impute_is_na(out[i][j]) { + out[i][j] = mn + } } } out } +///| pub fn impute_by_col_min(mat : Array[Array[Double]]) -> Array[Array[Double]] { - if mat.length() == 0 { return Array::new() } + if mat.length() == 0 { + return Array::new() + } let cols = mat[0].length() let mins : Array[Double] = Array::new() for j = 0; j < cols; j = j + 1 { let c : Array[Double] = Array::new() - for i = 0; i < mat.length(); i = i + 1 { c.push(mat[i][j]) } + for i = 0; i < mat.length(); i = i + 1 { + c.push(mat[i][j]) + } mins.push(impute_min_clean(c)) } let out = impute_copy_matrix(mat) for i = 0; i < out.length(); i = i + 1 { for j = 0; j < cols; j = j + 1 { - if impute_is_na(out[i][j]) { out[i][j] = mins[j] } + if impute_is_na(out[i][j]) { + out[i][j] = mins[j] + } } } out } +///| pub fn apply_value_clamp( mat : Array[Array[Double]], min_v : Double, @@ -320,9 +411,15 @@ pub fn apply_value_clamp( let out = impute_copy_matrix(mat) for i = 0; i < out.length(); i = i + 1 { for j = 0; j < out[i].length(); j = j + 1 { - if impute_is_na(out[i][j]) { continue } - if out[i][j] < min_v { out[i][j] = min_v } - if out[i][j] > max_v { out[i][j] = max_v } + if impute_is_na(out[i][j]) { + continue + } + if out[i][j] < min_v { + out[i][j] = min_v + } + if out[i][j] > max_v { + out[i][j] = max_v + } } } out @@ -330,7 +427,11 @@ pub fn apply_value_clamp( // ---- LOCF / NOCB ------------------------------------------------------------ -pub fn impute_locf(mat : Array[Array[Double]], by_row? : Bool = true) -> Array[Array[Double]] { +///| +pub fn impute_locf( + mat : Array[Array[Double]], + by_row? : Bool = true, +) -> Array[Array[Double]] { let base = if by_row { impute_copy_matrix(mat) } else { @@ -340,16 +441,26 @@ pub fn impute_locf(mat : Array[Array[Double]], by_row? : Bool = true) -> Array[A let mut last = 0.0 / 0.0 // NaN for j = 0; j < base[i].length(); j = j + 1 { if impute_is_na(base[i][j]) { - if !impute_is_na(last) { base[i][j] = last } + if !impute_is_na(last) { + base[i][j] = last + } } else { last = base[i][j] } } } - if by_row { base } else { impute_transpose(base) } + if by_row { + base + } else { + impute_transpose(base) + } } -pub fn impute_nocb(mat : Array[Array[Double]], by_row? : Bool = true) -> Array[Array[Double]] { +///| +pub fn impute_nocb( + mat : Array[Array[Double]], + by_row? : Bool = true, +) -> Array[Array[Double]] { let base = if by_row { impute_copy_matrix(mat) } else { @@ -362,19 +473,27 @@ pub fn impute_nocb(mat : Array[Array[Double]], by_row? : Bool = true) -> Array[A for j0 = 0; j0 < n; j0 = j0 + 1 { let j = n - 1 - j0 if impute_is_na(row[j]) { - if !impute_is_na(nxt) { row[j] = nxt } + if !impute_is_na(nxt) { + row[j] = nxt + } } else { nxt = row[j] } } } - if by_row { base } else { impute_transpose(base) } + if by_row { + base + } else { + impute_transpose(base) + } } // ---- KNN imputation --------------------------------------------------------- // Euclidean distance on coordinates where BOTH vectors have non-NA values. // Returns infinity when no valid overlap exists. + +///| fn impute_pairwise_dist_ignore_na( a : Array[Double], b : Array[Double], @@ -397,6 +516,7 @@ fn impute_pairwise_dist_ignore_na( } } +///| fn impute_compute_all_pair_distances( m : Array[Array[Double]], eps : Double, @@ -418,6 +538,7 @@ fn impute_compute_all_pair_distances( out } +///| fn impute_choose_k_neighbors( dist_row : Array[Double], k : Int, @@ -426,11 +547,19 @@ fn impute_choose_k_neighbors( let pairs : Array[(Int, Double)] = Array::new() let n = dist_row.length() for i = 0; i < n; i = i + 1 { - if i == self_i { continue } + if i == self_i { + continue + } pairs.push((i, dist_row[i])) } pairs.sort_by(fn(p : (Int, Double), q : (Int, Double)) -> Int { - if p.1 < q.1 { -1 } else if p.1 > q.1 { 1 } else { 0 } + if p.1 < q.1 { + -1 + } else if p.1 > q.1 { + 1 + } else { + 0 + } }) let m = if k < pairs.length() { k } else { pairs.length() } let out : Array[(Int, Double)] = Array::new() @@ -440,6 +569,7 @@ fn impute_choose_k_neighbors( out } +///| fn impute_weighted_average( neighbors : Array[(Int, Double)], m : Array[Array[Double]], @@ -453,14 +583,21 @@ fn impute_weighted_average( let ni = neighbors[idx].0 let d = neighbors[idx].1 let v = m[ni][j] - if impute_is_na(v) { continue } + if impute_is_na(v) { + continue + } let w = 1.0 / (d + eps) num = num + w * v den = den + w } - if den == 0.0 { 0.0 } else { num / den } + if den == 0.0 { + 0.0 + } else { + num / den + } } +///| pub fn impute_by_knn( mat : Array[Array[Double]], param : KNNImputeParam, @@ -480,10 +617,18 @@ pub fn impute_by_knn( } } } - if param.by_row { m } else { impute_transpose(m) } + if param.by_row { + m + } else { + impute_transpose(m) + } } -pub fn impute_by_knn_simple(mat : Array[Array[Double]], k : Int) -> Array[Array[Double]] { +///| +pub fn impute_by_knn_simple( + mat : Array[Array[Double]], + k : Int, +) -> Array[Array[Double]] { let p = KNNImputeParam::new() p.k = k impute_by_knn(mat, p) diff --git a/src/infercnv.mbt b/src/infercnv.mbt index bd8f665d..97fbc619 100644 --- a/src/infercnv.mbt +++ b/src/infercnv.mbt @@ -78,18 +78,13 @@ pub fn gene_position( start : Int, end : Int, ) -> GenePosition { - { - gene_id: gene_id, - chromosome: chromosome, - start: start, - end: end, - } + { gene_id, chromosome, start, end } } ///| /// An ordered gene set together with per-gene genomic positions. pub struct OrderedGenes { - gene_order : Array[GenePosition] // sorted by chr, then start position + gene_order : Array[GenePosition] // sorted by chr, then start position n_genes : Int } derive(Debug, Default) @@ -105,7 +100,11 @@ pub fn ordered_genes(raw : Array[GenePosition]) -> OrderedGenes { for j in 0..<(n - 1 - i) { let ca = natural_chrom_key(arr[j].chromosome) let cb = natural_chrom_key(arr[j + 1].chromosome) - let should_swap = if ca != cb { ca > cb } else { arr[j].start > arr[j + 1].start } + let should_swap = if ca != cb { + ca > cb + } else { + arr[j].start > arr[j + 1].start + } if should_swap { let tmp = arr[j] arr[j] = arr[j + 1] @@ -113,30 +112,40 @@ pub fn ordered_genes(raw : Array[GenePosition]) -> OrderedGenes { } } } - { - gene_order: arr, - n_genes: arr.length(), - } + { gene_order: arr, n_genes: arr.length() } } +///| fn natural_chrom_key(chr : String) -> String { // Trim optional "chr" prefix, then: // numeric chromosomes 1..22 -> "01" .. "22" // X -> "A0", Y -> "A1", M/MT -> "A2" (excluded by default anyway) // other -> "B" + original let s = chr.to_lower() - let base = if s.starts_with("chr") { s.substring(start=3, end=s.length()) } else { s } + let base = if s.starts_with("chr") { + s.substring(start=3, end=s.length()) + } else { + s + } match parse_double(base) { Some(v) => { let n = v.to_int() - if n < 10 { "0" + n.to_string() } else { n.to_string() } - } - None => { - if base == "x" { "A0" } - else if base == "y" { "A1" } - else if base == "m" || base == "mt" { "A2" } - else { "B" + base } + if n < 10 { + "0" + n.to_string() + } else { + n.to_string() + } } + None => + if base == "x" { + "A0" + } else if base == "y" { + "A1" + } else if base == "m" || base == "mt" { + "A2" + } else { + "B" + base + } } } @@ -146,8 +155,8 @@ pub fn exclude_chromosomes( og : OrderedGenes, excluded : Array[String], ) -> OrderedGenes { - let lower_excluded = excluded.map(fn (s) -> String { s.to_lower() }) - let kept = og.gene_order.filter(fn (gp : GenePosition) -> Bool { + let lower_excluded = excluded.map(fn(s) -> String { s.to_lower() }) + let kept = og.gene_order.filter(fn(gp : GenePosition) -> Bool { let c = gp.chromosome.to_lower() not(lower_excluded.contains(c)) }) @@ -162,13 +171,13 @@ pub fn exclude_chromosomes( /// Cell metadata record. pub struct CellAnnotation { cell_id : String - category : String // e.g. cell type / sample label + category : String // e.g. cell type / sample label } derive(Debug, Default) ///| /// Create a cell annotation. pub fn cell_annotation(cell_id : String, category : String) -> CellAnnotation { - { cell_id: cell_id, category: category } + { cell_id, category } } ///| @@ -179,8 +188,8 @@ pub fn cell_annotation(cell_id : String, category : String) -> CellAnnotation { pub struct InferCNVInput { n_cells : Int n_genes : Int - expression : Array[Array[Double]] // cell x gene (ordered) - annotations : Array[CellAnnotation] // length n_cells + expression : Array[Array[Double]] // cell x gene (ordered) + annotations : Array[CellAnnotation] // length n_cells ordered_genes : OrderedGenes } derive(Debug, Default) @@ -203,7 +212,9 @@ pub fn log_normalize_counts( let n_genes = row.length() let norm_row : Array[Double] = [] if total <= 0.0 { - for _j in 0.. Double { let mut sum = 0.0 - for v in arr { sum += v } + for v in arr { + sum += v + } sum } @@ -230,22 +244,22 @@ fn infercnv_array_sum(arr : Array[Double]) -> Double { pub struct CNVResult { n_cells : Int n_genes : Int - cnv_matrix : Array[Array[Double]] // cell x gene (ordered) + cnv_matrix : Array[Array[Double]] // cell x gene (ordered) cell_ids : Array[String] gene_ids : Array[String] - chromosome_boundaries : Array[(String, Int, Int)] // (chr, start_idx, end_idx) per chromosome - per_cell_cnv_score : Array[Double] // mean |CNV| of each cell across all genes + chromosome_boundaries : Array[(String, Int, Int)] // (chr, start_idx, end_idx) per chromosome + per_cell_cnv_score : Array[Double] // mean |CNV| of each cell across all genes per_cluster_cnv_score : Array[(String, Double)] // (category, mean score) } ///| /// Parameters exposed to the user for controlling the infercnv pipeline. pub struct CNVParams { - window_size : Int // number of adjacent genes in smoothing window - lfc_cap : Double // clip fold changes to +/- lfc_cap - noise_threshold : Double // values with |x| < noise are set to 0 + window_size : Int // number of adjacent genes in smoothing window + lfc_cap : Double // clip fold changes to +/- lfc_cap + noise_threshold : Double // values with |x| < noise are set to 0 reference_method : ReferenceMethod - reference_categories : Array[String] // used with ReferenceCategories method + reference_categories : Array[String] // used with ReferenceCategories method } ///| @@ -270,11 +284,11 @@ pub fn make_cnv_params( reference_categories : Array[String], ) -> CNVParams { { - window_size: window_size, - lfc_cap: lfc_cap, - noise_threshold: noise_threshold, - reference_method: reference_method, - reference_categories: reference_categories, + window_size, + lfc_cap, + noise_threshold, + reference_method, + reference_categories, } } @@ -282,31 +296,38 @@ pub fn make_cnv_params( // Reference profile computation // ============================================================================ +///| fn compute_reference_profile( input : InferCNVInput, params : CNVParams, -) -> Array[Array[Double]] { // returns array of reference profiles; single ref = 1 profile +) -> Array[Array[Double]] { // returns array of reference profiles; single ref = 1 profile match params.reference_method { ReferenceMethod::Custom(ref_profile) => { // ensure length matches n_genes let n = input.n_genes let arr = ref_profile.copy() - while arr.length() < n { arr.push(0.0) } + while arr.length() < n { + arr.push(0.0) + } // truncate to n genes let truncated : Array[Double] = [] - for i in 0.. { - [mean_per_gene(input.expression)] - } + ReferenceMethod::GlobalMean => [mean_per_gene(input.expression)] ReferenceMethod::ReferenceCategories => { let profiles : Array[Array[Double]] = [] for cat in params.reference_categories { let indices = cells_in_category(input.annotations, cat) - if indices.length() == 0 { continue } + if indices.length() == 0 { + continue + } let subset : Array[Array[Double]] = [] - for idx in indices { subset.push(input.expression[idx]) } + for idx in indices { + subset.push(input.expression[idx]) + } profiles.push(mean_per_gene(subset)) } if profiles.length() == 0 { @@ -319,26 +340,31 @@ fn compute_reference_profile( } } +///| fn mean_per_gene(matrix : Array[Array[Double]]) -> Array[Double] { let n_cells = matrix.length() - if n_cells == 0 { return [] } + if n_cells == 0 { + return [] + } let n_genes = matrix[0].length() let out : Array[Double] = [] for j in 0.. Array[Int] { +///| +fn cells_in_category(ann : Array[CellAnnotation], cat : String) -> Array[Int] { let out : Array[Int] = [] for i in 0.. lfc_cap { lfc_cap } else if v < -lfc_cap { -lfc_cap } else { v } + let clipped = if v > lfc_cap { + lfc_cap + } else if v < -lfc_cap { + -lfc_cap + } else { + v + } out.push(clipped) } } else { @@ -372,16 +405,28 @@ fn compute_lfc( let mut max_r = references[0][j] for r in 1.. max_r { max_r = v } + if v < min_r { + min_r = v + } + if v > max_r { + max_r = v + } } let c = cell_expr[j] - let lfc = if c > max_r { c - max_r } - else if c < min_r { c - min_r } - else { 0.0 } - let clipped = if lfc > lfc_cap { lfc_cap } - else if lfc < -lfc_cap { -lfc_cap } - else { lfc } + let lfc = if c > max_r { + c - max_r + } else if c < min_r { + c - min_r + } else { + 0.0 + } + let clipped = if lfc > lfc_cap { + lfc_cap + } else if lfc < -lfc_cap { + -lfc_cap + } else { + lfc + } out.push(clipped) } } @@ -392,11 +437,12 @@ fn compute_lfc( // Genomic smoothing per chromosome (pyramidal-weighted running mean) // ============================================================================ -fn chromosome_boundaries( - og : OrderedGenes, -) -> Array[(String, Int, Int)] { +///| +fn chromosome_boundaries(og : OrderedGenes) -> Array[(String, Int, Int)] { let result : Array[(String, Int, Int)] = [] - if og.n_genes == 0 { return result } + if og.n_genes == 0 { + return result + } let mut current_chr = og.gene_order[0].chromosome let mut start_idx = 0 for i in 1.. Array[Double] { let denom = (half + 1).to_double() for i in 0.. Double { let mut sum = 0.0 - for i in 0.. Array[Double] { let n = vec.length() - if half_window <= 0 || n <= 1 { return vec.copy() } + if half_window <= 0 || n <= 1 { + return vec.copy() + } let w = pyramidal_weights(half_window) let w_total = infercnv_array_sum(w) let out : Array[Double] = [] @@ -456,6 +509,7 @@ fn smooth_vector(vec : Array[Double], half_window : Int) -> Array[Double] { out } +///| fn smooth_per_chromosome( vec : Array[Double], boundaries : Array[(String, Int, Int)], @@ -467,10 +521,14 @@ fn smooth_per_chromosome( let (chr, s, e) = entry let len = e - s + 1 let segment : Array[Double] = [] - for i in s..=e { segment.push(result[i]) } + for i in s..<=e { + segment.push(result[i]) + } let smoothed = smooth_vector(segment, half) - for i in 0.. Double { let n = arr.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let sorted = arr.copy() // simple insertion sort for Double for i in 1.. Double { } sorted[j + 1] = key } - if n % 2 == 1 { sorted[n / 2] } - else { + if n % 2 == 1 { + sorted[n / 2] + } else { (sorted[n / 2 - 1] + sorted[n / 2]) / 2.0 } } +///| fn center_by_median(vec : Array[Double]) -> Array[Double] { let m = median_of(vec) - vec.map(fn (x) -> Double { x - m }) + vec.map(fn(x) -> Double { x - m }) } +///| fn apply_noise_threshold(vec : Array[Double], noise : Double) -> Array[Double] { - vec.map(fn (x) -> Double { if x.abs() < noise { 0.0 } else { x } }) + vec.map(fn(x) -> Double { if x.abs() < noise { 0.0 } else { x } }) } // ============================================================================ // Mean absolute per-cell CNV score // ============================================================================ +///| fn per_cell_cnv_scores(matrix : Array[Array[Double]]) -> Array[Double] { let n_cells = matrix.length() let out : Array[Double] = [] @@ -521,13 +586,16 @@ fn per_cell_cnv_scores(matrix : Array[Array[Double]]) -> Array[Double] { out.push(0.0) } else { let mut sum_abs = 0.0 - for x in row { sum_abs += x.abs() } - out.push(sum_abs / (row.length().to_double())) + for x in row { + sum_abs += x.abs() + } + out.push(sum_abs / row.length().to_double()) } } out } +///| fn per_category_scores( scores : Array[Double], ann : Array[CellAnnotation], @@ -585,8 +653,10 @@ pub fn run_infercnv( // Step 1b: keep only expression columns whose genes survived the filter. // Reorder input expression to match the filtered gene order by gene_id lookup. - let keep_gene_ids = filtered.gene_order.map(fn (g) -> String { g.gene_id }) - let original_gene_ids = input.ordered_genes.gene_order.map(fn (g) -> String { g.gene_id }) + let keep_gene_ids = filtered.gene_order.map(fn(g) -> String { g.gene_id }) + let original_gene_ids = input.ordered_genes.gene_order.map(fn(g) -> String { + g.gene_id + }) // build index map let orig_keys : Array[String] = [] let orig_vals : Array[Int] = [] @@ -600,7 +670,10 @@ pub fn run_infercnv( for gid in keep_gene_ids { let mut found_idx = -1 for k in 0..= 0 { new_row.push(input.expression[i][found_idx]) @@ -635,18 +708,23 @@ pub fn run_infercnv( cnv_matrix.push(denoised) } - let cell_ids = effective_input.annotations.map(fn (a) -> String { a.cell_id }) - let gene_ids = effective_input.ordered_genes.gene_order.map(fn (g) -> String { g.gene_id }) + let cell_ids = effective_input.annotations.map(fn(a) -> String { a.cell_id }) + let gene_ids = effective_input.ordered_genes.gene_order.map(fn(g) -> String { + g.gene_id + }) let cell_scores = per_cell_cnv_scores(cnv_matrix) - let cluster_scores = per_category_scores(cell_scores, effective_input.annotations) + let cluster_scores = per_category_scores( + cell_scores, + effective_input.annotations, + ) { n_cells: effective_input.n_cells, n_genes: effective_input.n_genes, - cnv_matrix: cnv_matrix, - cell_ids: cell_ids, - gene_ids: gene_ids, + cnv_matrix, + cell_ids, + gene_ids, chromosome_boundaries: boundaries, per_cell_cnv_score: cell_scores, per_cluster_cnv_score: cluster_scores, @@ -673,10 +751,10 @@ pub fn infercnv_sample_data( seed? : Int = 42, ) -> (InferCNVInput, Array[String], Array[String]) { let mut rng_state = seed - let next_rand = fn () -> Double { + let next_rand = fn() -> Double { // simple LCG rng_state = (rng_state * 1103515245 + 12345) & 0x7fffffff - ((rng_state & 0xffffff).to_double()) / 16777215.0 + (rng_state & 0xffffff).to_double() / 16777215.0 } let normal_mean = 3.0 let n_genes = n_chr * n_genes_per_chr @@ -693,7 +771,7 @@ pub fn infercnv_sample_data( let og = ordered_genes(positions) // helper: generate one cell with optional CNV effect - let make_cell = fn (is_tumour : Bool) -> Array[Double] { + let make_cell = fn(is_tumour : Bool) -> Array[Double] { let expr : Array[Double] = [] for c in 0.. Double { for entry in self.per_cluster_cnv_score { let (cat, score) = entry - if cat == category { return score } + if cat == category { + return score + } } 0.0 } ///| /// Return the list of chromosome boundaries as triples (chr, start, end). -pub fn CNVResult::chromosome_list(self : CNVResult) -> Array[(String, Int, Int)] { +pub fn CNVResult::chromosome_list( + self : CNVResult, +) -> Array[(String, Int, Int)] { self.chromosome_boundaries.copy() } @@ -765,25 +849,40 @@ pub fn CNVResult::chromosome_list(self : CNVResult) -> Array[(String, Int, Int)] pub fn CNVResult::summary(self : CNVResult) -> String { let total = self.per_cell_cnv_score.length() let mut sum = 0.0 - for v in self.per_cell_cnv_score { sum += v } - let mean = if total == 0 { 0.0 } else { sum / (total.to_double()) } + for v in self.per_cell_cnv_score { + sum += v + } + let mean = if total == 0 { 0.0 } else { sum / total.to_double() } let mut max_cat = "" let mut max_score = 0.0 for entry in self.per_cluster_cnv_score { let (cat, score) = entry - if score > max_score { max_cat = cat; max_score = score } + if score > max_score { + max_cat = cat + max_score = score + } } - "CNVResult(cells=" + total.to_string() + - ", genes=" + self.n_genes.to_string() + - ", mean_score=" + mean.to_string() + - ", top_cluster=" + max_cat + "=" + max_score.to_string() + ")" + "CNVResult(cells=" + + total.to_string() + + ", genes=" + + self.n_genes.to_string() + + ", mean_score=" + + mean.to_string() + + ", top_cluster=" + + max_cat + + "=" + + max_score.to_string() + + ")" } ///| /// Return CNV matrix value at cell index i, gene index j. pub fn CNVResult::at(self : CNVResult, i : Int, j : Int) -> Double { - if i < 0 || i >= self.n_cells || j < 0 || j >= self.n_genes { 0.0 } - else { self.cnv_matrix[i][j] } + if i < 0 || i >= self.n_cells || j < 0 || j >= self.n_genes { + 0.0 + } else { + self.cnv_matrix[i][j] + } } ///| @@ -799,7 +898,9 @@ pub fn CNVResult::predict_tumour_cells( let threshold = base * threshold_factor let out : Array[Int] = [] for i in 0.. threshold { out.push(i) } + if self.per_cell_cnv_score[i] > threshold { + out.push(i) + } } out } diff --git a/src/insdc_io.mbt b/src/insdc_io.mbt index 9bc28219..80973537 100644 --- a/src/insdc_io.mbt +++ b/src/insdc_io.mbt @@ -553,9 +553,7 @@ pub fn parse_genbank_record(content : String) -> InsdcRecord { let ll = line.length() // Record terminator. - if ll >= 2 && - line.unsafe_get(0) == slash && - line.unsafe_get(1) == slash { + if ll >= 2 && line.unsafe_get(0) == slash && line.unsafe_get(1) == slash { i = i + 1 break } @@ -764,29 +762,37 @@ pub fn write_genbank_record(record : InsdcRecord) -> String { } buf.write_string(len_str) buf.write_string(" ") - buf.write_string(if record.molecule_type.length() > 0 { - record.molecule_type - } else { - "DNA" - }) + buf.write_string( + if record.molecule_type.length() > 0 { + record.molecule_type + } else { + "DNA" + }, + ) buf.write_string(" ") - buf.write_string(if record.topology.length() > 0 { - record.topology - } else { - "linear" - }) + buf.write_string( + if record.topology.length() > 0 { + record.topology + } else { + "linear" + }, + ) buf.write_string(" ") - buf.write_string(if record.division.length() > 0 { - record.division - } else { - "UNK" - }) + buf.write_string( + if record.division.length() > 0 { + record.division + } else { + "UNK" + }, + ) buf.write_string(" ") - buf.write_string(if record.date.length() > 0 { - record.date - } else { - "01-JAN-2024" - }) + buf.write_string( + if record.date.length() > 0 { + record.date + } else { + "01-JAN-2024" + }, + ) buf.write_char('\n') // --- DEFINITION --- @@ -907,9 +913,7 @@ pub fn parse_embl_record(content : String) -> InsdcRecord { let ll = line.length() // Record terminator. - if ll >= 2 && - line.unsafe_get(0) == slash && - line.unsafe_get(1) == slash { + if ll >= 2 && line.unsafe_get(0) == slash && line.unsafe_get(1) == slash { i = i + 1 break } @@ -1019,8 +1023,8 @@ pub fn parse_embl_record(content : String) -> InsdcRecord { } if ct < 2 || !(cont.unsafe_get(0) == 'D'.to_int().to_uint16() && - cont.unsafe_get(1) == 'E'.to_int().to_uint16() && - (ct == 2 || cont.unsafe_get(2) == sp)) { + cont.unsafe_get(1) == 'E'.to_int().to_uint16() && + (ct == 2 || cont.unsafe_get(2) == sp)) { break } def_buf.write_char(' ') @@ -1056,8 +1060,8 @@ pub fn parse_embl_record(content : String) -> InsdcRecord { } if ct < 2 || !(cont.unsafe_get(0) == 'O'.to_int().to_uint16() && - cont.unsafe_get(1) == 'S'.to_int().to_uint16() && - (ct == 2 || cont.unsafe_get(2) == sp)) { + cont.unsafe_get(1) == 'S'.to_int().to_uint16() && + (ct == 2 || cont.unsafe_get(2) == sp)) { break } org_buf.write_char(' ') @@ -1094,7 +1098,7 @@ pub fn parse_embl_record(content : String) -> InsdcRecord { // A non-FT line ends the feature table. if ll < 2 || !(line.unsafe_get(0) == 'F'.to_int().to_uint16() && - line.unsafe_get(1) == 'T'.to_int().to_uint16()) { + line.unsafe_get(1) == 'T'.to_int().to_uint16()) { in_ft = false // Fall through to other section checks below. } @@ -1186,23 +1190,29 @@ pub fn write_embl_record(record : InsdcRecord) -> String { } buf.write_string(sv_num) buf.write_string("; ") - buf.write_string(if record.topology.length() > 0 { - record.topology - } else { - "linear" - }) + buf.write_string( + if record.topology.length() > 0 { + record.topology + } else { + "linear" + }, + ) buf.write_string("; ") - buf.write_string(if record.molecule_type.length() > 0 { - record.molecule_type - } else { - "DNA" - }) + buf.write_string( + if record.molecule_type.length() > 0 { + record.molecule_type + } else { + "DNA" + }, + ) buf.write_string("; STD; ") - buf.write_string(if record.division.length() > 0 { - record.division - } else { - "UNK" - }) + buf.write_string( + if record.division.length() > 0 { + record.division + } else { + "UNK" + }, + ) buf.write_string("; ") buf.write_string(record.sequence_length.to_string()) buf.write_string(" BP.") @@ -1237,11 +1247,7 @@ pub fn write_embl_record(record : InsdcRecord) -> String { for l in lines { // Convert the GenBank-style 5-space indent into "FT " by replacing // the first two spaces with the literal "FT". - let l_to_write = if l.length() >= 2 { - "FT" + l[2:].to_owned() - } else { - l - } + let l_to_write = if l.length() >= 2 { "FT" + l[2:].to_owned() } else { l } buf.write_string(l_to_write) buf.write_char('\n') } diff --git a/src/internal_coords.mbt b/src/internal_coords.mbt index a994532f..e919c59d 100644 --- a/src/internal_coords.mbt +++ b/src/internal_coords.mbt @@ -186,23 +186,33 @@ pub fn RotamerLibraryEntry::new( ///| /// Standard peptide bond length (C-N). -pub fn ic_peptide_bond_length() -> Double { 1.33 } +pub fn ic_peptide_bond_length() -> Double { + 1.33 +} ///| /// Standard CA-C bond length. -pub fn ic_ca_c_bond_length() -> Double { 1.52 } +pub fn ic_ca_c_bond_length() -> Double { + 1.52 +} ///| /// Standard N-CA bond length. -pub fn ic_n_ca_bond_length() -> Double { 1.47 } +pub fn ic_n_ca_bond_length() -> Double { + 1.47 +} ///| /// Standard omega bond angle (CA-C-N-CA), ~180 degrees. -pub fn ic_omega_angle() -> Double { 180.0 } +pub fn ic_omega_angle() -> Double { + 180.0 +} ///| /// Standard tau angle (N-CA-C), ~110 degrees. -pub fn ic_tau_angle() -> Double { 110.0 } +pub fn ic_tau_angle() -> Double { + 110.0 +} // ============================================================================ // Torsion angle calculations @@ -245,15 +255,21 @@ pub fn ic_dihedral_angle( ///| /// PI constant. -pub fn ic_pi() -> Double { 3.14159265358979323846 } +pub fn ic_pi() -> Double { + 3.14159265358979323846 +} ///| /// Convert radians to degrees. -pub fn ic_rad_to_deg(rad : Double) -> Double { rad * 180.0 / ic_pi() } +pub fn ic_rad_to_deg(rad : Double) -> Double { + rad * 180.0 / ic_pi() +} ///| /// Convert degrees to radians. -pub fn ic_deg_to_rad(deg : Double) -> Double { deg * ic_pi() / 180.0 } +pub fn ic_deg_to_rad(deg : Double) -> Double { + deg * ic_pi() / 180.0 +} ///| /// Compute phi angle for a residue (C(i-1) - N(i) - CA(i) - C(i)). @@ -307,9 +323,7 @@ pub fn ic_compute_chi1( /// Build a simple extended polypeptide chain from internal coordinates. /// Uses standard bond lengths and angles. /// Returns the ICToCartesianResult with atom positions. -pub fn ic_build_extended_chain( - sequence : Array[String], -) -> ICToCartesianResult { +pub fn ic_build_extended_chain(sequence : Array[String]) -> ICToCartesianResult { let result = ICToCartesianResult::new() // Standard bond parameters @@ -383,7 +397,13 @@ pub fn ic_build_extended_chain( let next_n = ic_rotate_around_bond(prev_c, prev_ca, prev_n, psi, bond_c_n) // Place next CA atom using phi rotation on next residue - let next_ca = ic_rotate_around_bond(next_n, prev_c, prev_ca, phi + ic_pi(), bond_n_ca) + let next_ca = ic_rotate_around_bond( + next_n, + prev_c, + prev_ca, + phi + ic_pi(), + bond_n_ca, + ) // Place next C atom let next_c = ic_build_carbonyl(next_n, next_ca, prev_c) @@ -451,11 +471,7 @@ pub fn ic_rotate_around_bond( } // Vector from origin to point - let v = [ - point[0] - origin[0], - point[1] - origin[1], - point[2] - origin[2], - ] + let v = [point[0] - origin[0], point[1] - origin[1], point[2] - origin[2]] // Decompose v into parallel and perpendicular components let v_par = ic_dot(v, bond_unit) @@ -522,7 +538,11 @@ pub fn ic_build_carbonyl( [1.0, 0.0, 0.0] } let v2 = if pc_norm > 1.0e-10 { - [v_ca_prev_c[0] / pc_norm, v_ca_prev_c[1] / pc_norm, v_ca_prev_c[2] / pc_norm] + [ + v_ca_prev_c[0] / pc_norm, + v_ca_prev_c[1] / pc_norm, + v_ca_prev_c[2] / pc_norm, + ] } else { [0.0, 1.0, 0.0] } @@ -566,11 +586,7 @@ pub fn ic_oxygen_position( ca_pos[1] - c_pos[1], ca_pos[2] - c_pos[2], ] - let v_c_n = [ - n_pos[0] - c_pos[0], - n_pos[1] - c_pos[1], - n_pos[2] - c_pos[2], - ] + let v_c_n = [n_pos[0] - c_pos[0], n_pos[1] - c_pos[1], n_pos[2] - c_pos[2]] let ca_norm = ic_vec_norm(v_c_ca) let n_norm = ic_vec_norm(v_c_n) @@ -587,11 +603,7 @@ pub fn ic_oxygen_position( } // Bisector direction (CA-C-N angle ~121°, so bisector is between them) - let bisector = [ - u_ca[0] + u_n[0], - u_ca[1] + u_n[1], - u_ca[2] + u_n[2], - ] + let bisector = [u_ca[0] + u_n[0], u_ca[1] + u_n[1], u_ca[2] + u_n[2]] let bis_norm = ic_vec_norm(bisector) let bis_unit = if bis_norm > 1.0e-10 { [bisector[0] / bis_norm, bisector[1] / bis_norm, bisector[2] / bis_norm] @@ -725,103 +737,420 @@ pub fn ic_distance(a : Array[Double], b : Array[Double]) -> Double { /// Get common chi1 angle values for different amino acids. pub fn ic_chi1_rotamers(resname : String) -> Array[Rotamer] { match resname { - "LEU" => [ - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(-60.0)], probability: 0.25 }, - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(-60.0)], probability: 0.55 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(-60.0)], probability: 0.20 }, - ] - "VAL" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0)], probability: 0.45 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0)], probability: 0.35 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0)], probability: 0.20 }, - ] - "PHE" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.60 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(90.0)], probability: 0.25 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(-90.0)], probability: 0.15 }, - ] - "TYR" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.60 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(90.0)], probability: 0.25 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(-90.0)], probability: 0.15 }, - ] - "TRP" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.50 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.30 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(-90.0)], probability: 0.20 }, - ] - "SER" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0)], probability: 0.35 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0)], probability: 0.40 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0)], probability: 0.25 }, - ] - "THR" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0)], probability: 0.25 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0)], probability: 0.40 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0)], probability: 0.35 }, - ] - "CYS" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0)], probability: 0.35 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0)], probability: 0.40 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0)], probability: 0.25 }, - ] - "MET" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.50 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.25 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(-90.0)], probability: 0.25 }, - ] - "LYS" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0)], probability: 0.40 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0)], probability: 0.30 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0)], probability: 0.30 }, - ] - "ARG" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.35 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.35 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.30 }, - ] - "ASP" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0)], probability: 0.60 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0)], probability: 0.20 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0)], probability: 0.20 }, - ] - "GLU" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0)], probability: 0.45 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0)], probability: 0.30 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0)], probability: 0.25 }, - ] - "ASN" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.55 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(90.0)], probability: 0.25 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(-90.0)], probability: 0.20 }, - ] - "GLN" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.50 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.25 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(-90.0)], probability: 0.25 }, - ] - "HIS" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(0.0)], probability: 0.45 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(0.0)], probability: 0.30 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0)], probability: 0.25 }, - ] - "ALA" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0)], probability: 1.0 }, - ] - "GLY" => [ - Rotamer::{ name: "t", chi_angles: [], probability: 1.0 }, - ] - "PRO" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(-60.0)], probability: 1.0 }, - ] - "ILE" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(-60.0)], probability: 0.60 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(-60.0)], probability: 0.20 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0)], probability: 0.20 }, - ] - _ => [ - Rotamer::{ name: "t", chi_angles: [], probability: 1.0 }, - ] + "LEU" => + [ + Rotamer::{ + name: "g+", + chi_angles: [ + ic_deg_to_rad(-60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(-60.0), + ], + probability: 0.25, + }, + Rotamer::{ + name: "t", + chi_angles: [ + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(-60.0), + ], + probability: 0.55, + }, + Rotamer::{ + name: "g-", + chi_angles: [ + ic_deg_to_rad(60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(-60.0), + ], + probability: 0.20, + }, + ] + "VAL" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0)], + probability: 0.45, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0)], + probability: 0.35, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0)], + probability: 0.20, + }, + ] + "PHE" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], + probability: 0.60, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(90.0)], + probability: 0.25, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(-90.0)], + probability: 0.15, + }, + ] + "TYR" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], + probability: 0.60, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(90.0)], + probability: 0.25, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(-90.0)], + probability: 0.15, + }, + ] + "TRP" => + [ + Rotamer::{ + name: "t", + chi_angles: [ + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.50, + }, + Rotamer::{ + name: "g+", + chi_angles: [ + ic_deg_to_rad(-60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.30, + }, + Rotamer::{ + name: "g-", + chi_angles: [ + ic_deg_to_rad(60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(-90.0), + ], + probability: 0.20, + }, + ] + "SER" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0)], + probability: 0.35, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0)], + probability: 0.40, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0)], + probability: 0.25, + }, + ] + "THR" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0)], + probability: 0.25, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0)], + probability: 0.40, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0)], + probability: 0.35, + }, + ] + "CYS" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0)], + probability: 0.35, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0)], + probability: 0.40, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0)], + probability: 0.25, + }, + ] + "MET" => + [ + Rotamer::{ + name: "t", + chi_angles: [ + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.50, + }, + Rotamer::{ + name: "g+", + chi_angles: [ + ic_deg_to_rad(-60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.25, + }, + Rotamer::{ + name: "g-", + chi_angles: [ + ic_deg_to_rad(60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(-90.0), + ], + probability: 0.25, + }, + ] + "LYS" => + [ + Rotamer::{ + name: "t", + chi_angles: [ + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ], + probability: 0.40, + }, + Rotamer::{ + name: "g+", + chi_angles: [ + ic_deg_to_rad(-60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ], + probability: 0.30, + }, + Rotamer::{ + name: "g-", + chi_angles: [ + ic_deg_to_rad(60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ], + probability: 0.30, + }, + ] + "ARG" => + [ + Rotamer::{ + name: "t", + chi_angles: [ + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.35, + }, + Rotamer::{ + name: "g+", + chi_angles: [ + ic_deg_to_rad(-60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.35, + }, + Rotamer::{ + name: "g-", + chi_angles: [ + ic_deg_to_rad(60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.30, + }, + ] + "ASP" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0)], + probability: 0.60, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0)], + probability: 0.20, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0)], + probability: 0.20, + }, + ] + "GLU" => + [ + Rotamer::{ + name: "t", + chi_angles: [ + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ], + probability: 0.45, + }, + Rotamer::{ + name: "g+", + chi_angles: [ + ic_deg_to_rad(-60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ], + probability: 0.30, + }, + Rotamer::{ + name: "g-", + chi_angles: [ + ic_deg_to_rad(60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ], + probability: 0.25, + }, + ] + "ASN" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], + probability: 0.55, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(90.0)], + probability: 0.25, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(-90.0)], + probability: 0.20, + }, + ] + "GLN" => + [ + Rotamer::{ + name: "t", + chi_angles: [ + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.50, + }, + Rotamer::{ + name: "g+", + chi_angles: [ + ic_deg_to_rad(-60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.25, + }, + Rotamer::{ + name: "g-", + chi_angles: [ + ic_deg_to_rad(60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(-90.0), + ], + probability: 0.25, + }, + ] + "HIS" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(0.0)], + probability: 0.45, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(0.0)], + probability: 0.30, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0)], + probability: 0.25, + }, + ] + "ALA" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0)], + probability: 1.0, + }, + ] + "GLY" => [Rotamer::{ name: "t", chi_angles: [], probability: 1.0 }] + "PRO" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(-60.0)], + probability: 1.0, + }, + ] + "ILE" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(-60.0)], + probability: 0.60, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(-60.0)], + probability: 0.20, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0)], + probability: 0.20, + }, + ] + _ => [Rotamer::{ name: "t", chi_angles: [], probability: 1.0 }] } } @@ -854,12 +1183,34 @@ pub fn ic_validate_coords(ic : InternalCoordChain) -> Array[(Int, String)] { let res = ic.residues[i] for bl in res.bond_lengths { if bl.length < 0.5 || bl.length > 3.0 { - issues.push((res.resseq, "Bond length " + bl.atom1 + "-" + bl.atom2 + " out of range: " + bl.length.to_string())) + issues.push( + ( + res.resseq, + "Bond length " + + bl.atom1 + + "-" + + bl.atom2 + + " out of range: " + + bl.length.to_string(), + ), + ) } } for ba in res.bond_angles { if ba.angle < 60.0 || ba.angle > 180.0 { - issues.push((res.resseq, "Bond angle " + ba.atom1 + "-" + ba.atom2 + "-" + ba.atom3 + " out of range: " + ba.angle.to_string())) + issues.push( + ( + res.resseq, + "Bond angle " + + ba.atom1 + + "-" + + ba.atom2 + + "-" + + ba.atom3 + + " out of range: " + + ba.angle.to_string(), + ), + ) } } i = i + 1 @@ -875,9 +1226,13 @@ pub fn ic_chain_summary(ic : InternalCoordChain) -> String { for res in ic.residues { total_torsions = total_torsions + res.torsions.length() } - "Chain " + ic.chain_id.to_string() + - ": " + n_res.to_string() + " residues, " + - total_torsions.to_string() + " torsion angles" + "Chain " + + ic.chain_id.to_string() + + ": " + + n_res.to_string() + + " residues, " + + total_torsions.to_string() + + " torsion angles" } ///| @@ -888,10 +1243,7 @@ pub fn InternalCoordChain::add_residue( ) -> InternalCoordChain { let new_residues = self.residues.copy() new_residues.push(res) - InternalCoordChain::{ - chain_id: self.chain_id, - residues: new_residues, - } + InternalCoordChain::{ chain_id: self.chain_id, residues: new_residues } } ///| @@ -956,7 +1308,9 @@ pub fn InternalCoordChain::n_residues(self : InternalCoordChain) -> Int { ///| /// Get residue names. -pub fn InternalCoordChain::residue_names(self : InternalCoordChain) -> Array[String] { +pub fn InternalCoordChain::residue_names( + self : InternalCoordChain, +) -> Array[String] { self.residues.map(fn(r) { r.resname }) } diff --git a/src/interproscan.mbt b/src/interproscan.mbt index 65f29dfc..24aa1707 100644 --- a/src/interproscan.mbt +++ b/src/interproscan.mbt @@ -297,24 +297,22 @@ fn ips_parse_line(line : String) -> InterproScanRecord? { let ipr_acc = ips_normalize(fields[11]) let ipr_desc = ips_normalize(fields[12]) let go_terms = ips_split_go_terms(fields[13]) - Some( - InterproScanRecord::{ - protein_id, - md5, - seq_length, - analysis, - signature_acc, - signature_desc, - start_pos, - stop_pos, - score, - status, - date, - ipr_acc, - ipr_desc, - go_terms, - }, - ) + Some(InterproScanRecord::{ + protein_id, + md5, + seq_length, + analysis, + signature_acc, + signature_desc, + start_pos, + stop_pos, + score, + status, + date, + ipr_acc, + ipr_desc, + go_terms, + }) } // ============================================================================ @@ -354,14 +352,222 @@ pub fn interproscan_sample_data() -> String { let t = "\t" "# InterProScan output (sample)\n" + "# version 5.0\n" + - "sp|P12345|PROT_HUMAN" + t + "abc123def456" + t + "500" + t + "Pfam" + t + "PF00001" + t + "p53 DNA-binding domain" + t + "1" + t + "100" + t + "150.5" + t + "T" + t + "01-Jan-2024" + t + "IPR000001" + t + "p53, DNA-binding domain" + t + "GO:0003674|GO:0008150\n" + - "sp|P12345|PROT_HUMAN" + t + "abc123def456" + t + "500" + t + "SMART" + t + "SM00100" + t + "p53 domain" + t + "1" + t + "100" + t + "120.0" + t + "T" + t + "01-Jan-2024" + t + "IPR000001" + t + "p53, DNA-binding domain" + t + "GO:0003674\n" + - "sp|P12345|PROT_HUMAN" + t + "abc123def456" + t + "500" + t + "PROSITEPATTERNS" + t + "PS00001" + t + "p53 pattern" + t + "50" + t + "60" + t + "0.0" + t + "T" + t + "01-Jan-2024" + t + "-" + t + "-" + t + "-\n" + - "sp|Q9Y6K9|XYZ_HUMAN" + t + "def789ghi012" + t + "300" + t + "Profile" + t + "PS50122" + t + "Helicase C-terminal" + t + "10" + t + "250" + t + "200.3" + t + "T" + t + "02-Jan-2024" + t + "IPR000002" + t + "Helicase, C-terminal" + t + "GO:0005524|GO:0006280|GO:0003676\n" + - "sp|Q9Y6K9|XYZ_HUMAN" + t + "def789ghi012" + t + "300" + t + "Pfam" + t + "PF00002" + t + "Kinase domain" + t + "5" + t + "150" + t + "180.0" + t + "T" + t + "02-Jan-2024" + t + "IPR000003" + t + "Kinase domain" + t + "GO:0004672\n" + - "sp|O15143|ABC_HUMAN" + t + "ghi345jkl678" + t + "600" + t + "Pfam" + t + "PF00003" + t + "ABC transporter" + t + "100" + t + "300" + t + "110.5" + t + "T" + t + "03-Jan-2024" + t + "IPR000004" + t + "ABC transporter-like" + t + "GO:0005524|GO:0016887\n" + - "sp|O15143|ABC_HUMAN" + t + "ghi345jkl678" + t + "600" + t + "HAMMER" + t + "HM00001" + t + "Hammerhead ribozyme" + t + "1" + t + "50" + t + "90.0" + t + "T" + t + "03-Jan-2024" + t + "IPR000005" + t + "Hammerhead ribozyme" + t + "-\n" + - "sp|O15143|ABC_HUMAN" + t + "ghi345jkl678" + t + "600" + t + "SMART" + t + "SM00150" + t + "DnaJ domain" + t + "400" + t + "500" + t + "85.0" + t + "T" + t + "03-Jan-2024" + t + "IPR000006" + t + "DnaJ domain" + t + "GO:0044183\n" + "sp|P12345|PROT_HUMAN" + + t + + "abc123def456" + + t + + "500" + + t + + "Pfam" + + t + + "PF00001" + + t + + "p53 DNA-binding domain" + + t + + "1" + + t + + "100" + + t + + "150.5" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "IPR000001" + + t + + "p53, DNA-binding domain" + + t + + "GO:0003674|GO:0008150\n" + + "sp|P12345|PROT_HUMAN" + + t + + "abc123def456" + + t + + "500" + + t + + "SMART" + + t + + "SM00100" + + t + + "p53 domain" + + t + + "1" + + t + + "100" + + t + + "120.0" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "IPR000001" + + t + + "p53, DNA-binding domain" + + t + + "GO:0003674\n" + + "sp|P12345|PROT_HUMAN" + + t + + "abc123def456" + + t + + "500" + + t + + "PROSITEPATTERNS" + + t + + "PS00001" + + t + + "p53 pattern" + + t + + "50" + + t + + "60" + + t + + "0.0" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "-" + + t + + "-" + + t + + "-\n" + + "sp|Q9Y6K9|XYZ_HUMAN" + + t + + "def789ghi012" + + t + + "300" + + t + + "Profile" + + t + + "PS50122" + + t + + "Helicase C-terminal" + + t + + "10" + + t + + "250" + + t + + "200.3" + + t + + "T" + + t + + "02-Jan-2024" + + t + + "IPR000002" + + t + + "Helicase, C-terminal" + + t + + "GO:0005524|GO:0006280|GO:0003676\n" + + "sp|Q9Y6K9|XYZ_HUMAN" + + t + + "def789ghi012" + + t + + "300" + + t + + "Pfam" + + t + + "PF00002" + + t + + "Kinase domain" + + t + + "5" + + t + + "150" + + t + + "180.0" + + t + + "T" + + t + + "02-Jan-2024" + + t + + "IPR000003" + + t + + "Kinase domain" + + t + + "GO:0004672\n" + + "sp|O15143|ABC_HUMAN" + + t + + "ghi345jkl678" + + t + + "600" + + t + + "Pfam" + + t + + "PF00003" + + t + + "ABC transporter" + + t + + "100" + + t + + "300" + + t + + "110.5" + + t + + "T" + + t + + "03-Jan-2024" + + t + + "IPR000004" + + t + + "ABC transporter-like" + + t + + "GO:0005524|GO:0016887\n" + + "sp|O15143|ABC_HUMAN" + + t + + "ghi345jkl678" + + t + + "600" + + t + + "HAMMER" + + t + + "HM00001" + + t + + "Hammerhead ribozyme" + + t + + "1" + + t + + "50" + + t + + "90.0" + + t + + "T" + + t + + "03-Jan-2024" + + t + + "IPR000005" + + t + + "Hammerhead ribozyme" + + t + + "-\n" + + "sp|O15143|ABC_HUMAN" + + t + + "ghi345jkl678" + + t + + "600" + + t + + "SMART" + + t + + "SM00150" + + t + + "DnaJ domain" + + t + + "400" + + t + + "500" + + t + + "85.0" + + t + + "T" + + t + + "03-Jan-2024" + + t + + "IPR000006" + + t + + "DnaJ domain" + + t + + "GO:0044183\n" } // ============================================================================ diff --git a/src/iranges.mbt b/src/iranges.mbt index bc04e050..40d42c10 100644 --- a/src/iranges.mbt +++ b/src/iranges.mbt @@ -642,7 +642,11 @@ pub fn ir_distance_to_nearest(ir : IRanges) -> Array[Int] { j = j + 1 } - distances[i] = if min_dist < @double.infinity { min_dist.to_int() } else { -1 } + distances[i] = if min_dist < @double.infinity { + min_dist.to_int() + } else { + -1 + } i = i + 1 } @@ -744,23 +748,26 @@ pub fn ir_gap_width(ir : IRanges) -> Int { total_gap } -///| Test find_overlaps_advanced with "any" type +///| +/// Test find_overlaps_advanced with "any" type test "find_overlaps_advanced_any" { let query = iranges([1, 10], [5, 15]) let subject = iranges([3, 8, 12], [8, 14, 18]) - let result = find_overlaps_advanced(query=query, subject=subject, type_="any") + let result = find_overlaps_advanced(query~, subject~, type_="any") assert_true(result.length() >= 1) } -///| Test find_overlaps_advanced with "within" type +///| +/// Test find_overlaps_advanced with "within" type test "find_overlaps_advanced_within" { let query = iranges([1, 10], [5, 15]) let subject = iranges([0, 5], [10, 20]) - let result = find_overlaps_advanced(query=query, subject=subject, type_="within") + let result = find_overlaps_advanced(query~, subject~, type_="within") assert_true(result.length() >= 0) } -///| Test ir_nearest function +///| +/// Test ir_nearest function test "ir_nearest" { let query = iranges([1, 20, 40], [5, 25, 45]) let subject = iranges([10, 30], [15, 35]) @@ -770,7 +777,8 @@ test "ir_nearest" { assert_eq(result[0], 0) } -///| Test ir_coverage function +///| +/// Test ir_coverage function test "ir_coverage" { let ir = iranges([1, 5, 10], [8, 15, 20]) let result = ir_coverage(ir, 25) @@ -781,14 +789,16 @@ test "ir_coverage" { assert_eq(result[4], 2) } -///| Test ir_coverage_rle function +///| +/// Test ir_coverage_rle function test "ir_coverage_rle" { let ir = iranges([1, 5], [3, 8]) let result = ir_coverage_rle(ir, 10) assert_true(result.length() >= 1) } -///| Test ir_distance function +///| +/// Test ir_distance function test "ir_distance" { let ir1 = iranges([1, 15], [5, 20]) let ir2 = iranges([10, 30], [12, 35]) @@ -797,7 +807,8 @@ test "ir_distance" { assert_eq(result[0].length(), 2) } -///| Test ir_distance_to_nearest function +///| +/// Test ir_distance_to_nearest function test "ir_distance_to_nearest" { let ir = iranges([1, 10, 25], [5, 15, 30]) let result = ir_distance_to_nearest(ir) @@ -806,7 +817,8 @@ test "ir_distance_to_nearest" { assert_eq(result[0], 4) } -///| Test ir_precede function +///| +/// Test ir_precede function test "ir_precede" { let query = iranges([10, 30], [15, 35]) let subject = iranges([1, 20], [5, 25]) @@ -816,7 +828,8 @@ test "ir_precede" { assert_eq(result[0], 0) } -///| Test ir_follow function +///| +/// Test ir_follow function test "ir_follow" { let query = iranges([1, 10], [5, 15]) let subject = iranges([20, 30], [25, 35]) @@ -826,7 +839,8 @@ test "ir_follow" { assert_eq(result[1], 0) } -///| Test ir_subset function +///| +/// Test ir_subset function test "ir_subset" { let ir = iranges([1, 5, 10], [3, 8, 15]) let keep = [true, false, true] @@ -836,7 +850,8 @@ test "ir_subset" { assert_eq(result.starts[1], 10) } -///| Test ir_sort function +///| +/// Test ir_sort function test "ir_sort" { let ir = iranges([10, 1, 5], [15, 3, 8]) let result = ir_sort(ir) diff --git a/src/isoform_switch_analyze_r.mbt b/src/isoform_switch_analyze_r.mbt index c6d5dc1c..db3ae3b3 100644 --- a/src/isoform_switch_analyze_r.mbt +++ b/src/isoform_switch_analyze_r.mbt @@ -1,5 +1,4 @@ ///| - pub struct IsoformExpression { isoform_id : String gene_id : String @@ -8,6 +7,7 @@ pub struct IsoformExpression { fpkm : Array[Double] } +///| pub struct IsoformSwitch { gene_id : String gene_name : String @@ -21,6 +21,7 @@ pub struct IsoformSwitch { consequence_type : Array[String] } +///| pub struct SwitchAnalyzeRlist { isoform_expression : Array[IsoformExpression] isoform_switches : Array[IsoformSwitch] @@ -29,29 +30,63 @@ pub struct SwitchAnalyzeRlist { gene_annotation : Map[String, String] } -pub fn IsoformExpression::new(isoform_id : String, gene_id : String, counts : Array[Double], - tpm : Array[Double], fpkm : Array[Double]) -> IsoformExpression { +///| +pub fn IsoformExpression::new( + isoform_id : String, + gene_id : String, + counts : Array[Double], + tpm : Array[Double], + fpkm : Array[Double], +) -> IsoformExpression { IsoformExpression::{ isoform_id, gene_id, counts, tpm, fpkm } } -pub fn IsoformSwitch::new(gene_id : String, gene_name : String, isoform_id_1 : String, - isoform_id_2 : String, dpsi : Double, dif : Double, - pvalue : Double, adjusted_pvalue : Double, - switch_direction : String, consequence_type : Array[String]) -> IsoformSwitch { - IsoformSwitch::{ gene_id, gene_name, isoform_id_1, isoform_id_2, dpsi, dif, pvalue, adjusted_pvalue, switch_direction, consequence_type } +///| +pub fn IsoformSwitch::new( + gene_id : String, + gene_name : String, + isoform_id_1 : String, + isoform_id_2 : String, + dpsi : Double, + dif : Double, + pvalue : Double, + adjusted_pvalue : Double, + switch_direction : String, + consequence_type : Array[String], +) -> IsoformSwitch { + IsoformSwitch::{ + gene_id, + gene_name, + isoform_id_1, + isoform_id_2, + dpsi, + dif, + pvalue, + adjusted_pvalue, + switch_direction, + consequence_type, + } } -pub fn SwitchAnalyzeRlist::new(samples : Array[String], conditions : Array[String]) -> SwitchAnalyzeRlist { - SwitchAnalyzeRlist::{ - isoform_expression: Array::new(), - isoform_switches: Array::new(), - samples: samples, - conditions: conditions, - gene_annotation: Map([], capacity=0) +///| +pub fn SwitchAnalyzeRlist::new( + samples : Array[String], + conditions : Array[String], +) -> SwitchAnalyzeRlist { + SwitchAnalyzeRlist::{ + isoform_expression: Array::new(), + isoform_switches: Array::new(), + samples, + conditions, + gene_annotation: Map([], capacity=0), } } -pub fn SwitchAnalyzeRlist::add_isoform(self : SwitchAnalyzeRlist, isoform : IsoformExpression) -> SwitchAnalyzeRlist { +///| +pub fn SwitchAnalyzeRlist::add_isoform( + self : SwitchAnalyzeRlist, + isoform : IsoformExpression, +) -> SwitchAnalyzeRlist { let expr_len = self.isoform_expression.length() let new_expr : Array[IsoformExpression] = Array::new() let mut i = 0 @@ -63,13 +98,21 @@ pub fn SwitchAnalyzeRlist::add_isoform(self : SwitchAnalyzeRlist, isoform : Isof SwitchAnalyzeRlist::{ ..self, isoform_expression: new_expr } } -pub fn SwitchAnalyzeRlist::add_gene_annotation(self : SwitchAnalyzeRlist, gene_id : String, gene_name : String) -> SwitchAnalyzeRlist { +///| +pub fn SwitchAnalyzeRlist::add_gene_annotation( + self : SwitchAnalyzeRlist, + gene_id : String, + gene_name : String, +) -> SwitchAnalyzeRlist { let annot = self.gene_annotation annot.set(gene_id, gene_name) SwitchAnalyzeRlist::{ ..self, gene_annotation: annot } } -pub fn bio_isoform_calculate_usage(expression : IsoformExpression) -> Array[Double] { +///| +pub fn bio_isoform_calculate_usage( + expression : IsoformExpression, +) -> Array[Double] { let len = expression.tpm.length() let usage : Array[Double] = Array::new() let mut i = 0 @@ -80,16 +123,21 @@ pub fn bio_isoform_calculate_usage(expression : IsoformExpression) -> Array[Doub usage } -pub fn bio_isoform_calculate_dpsi(isoform1 : IsoformExpression, isoform2 : IsoformExpression, - condition1_indices : Array[Int], condition2_indices : Array[Int]) -> Double { +///| +pub fn bio_isoform_calculate_dpsi( + isoform1 : IsoformExpression, + isoform2 : IsoformExpression, + condition1_indices : Array[Int], + condition2_indices : Array[Int], +) -> Double { let usage1 = bio_isoform_calculate_usage(isoform1) let usage2 = bio_isoform_calculate_usage(isoform2) - + let mut sum_usage1_cond1 = 0.0 let mut sum_usage1_cond2 = 0.0 let mut sum_usage2_cond1 = 0.0 let mut sum_usage2_cond2 = 0.0 - + let len1 = condition1_indices.length() let mut i = 0 while i < len1 { @@ -100,7 +148,7 @@ pub fn bio_isoform_calculate_dpsi(isoform1 : IsoformExpression, isoform2 : Isofo } i = i + 1 } - + let len2 = condition2_indices.length() let mut j = 0 while j < len2 { @@ -111,26 +159,39 @@ pub fn bio_isoform_calculate_dpsi(isoform1 : IsoformExpression, isoform2 : Isofo } j = j + 1 } - + let total_cond1 = sum_usage1_cond1 + sum_usage2_cond1 let total_cond2 = sum_usage1_cond2 + sum_usage2_cond2 - - let psi1_cond1 = if total_cond1 > 0.0001 { sum_usage1_cond1 / total_cond1 } else { 0.5 } - let psi1_cond2 = if total_cond2 > 0.0001 { sum_usage1_cond2 / total_cond2 } else { 0.5 } - + + let psi1_cond1 = if total_cond1 > 0.0001 { + sum_usage1_cond1 / total_cond1 + } else { + 0.5 + } + let psi1_cond2 = if total_cond2 > 0.0001 { + sum_usage1_cond2 / total_cond2 + } else { + 0.5 + } + psi1_cond2 - psi1_cond1 } -pub fn bio_isoform_calculate_dif(isoform1 : IsoformExpression, isoform2 : IsoformExpression, - condition1_indices : Array[Int], condition2_indices : Array[Int]) -> Double { +///| +pub fn bio_isoform_calculate_dif( + isoform1 : IsoformExpression, + isoform2 : IsoformExpression, + condition1_indices : Array[Int], + condition2_indices : Array[Int], +) -> Double { let usage1 = bio_isoform_calculate_usage(isoform1) let usage2 = bio_isoform_calculate_usage(isoform2) - + let mut sum_psi_cond1 = 0.0 let mut count_psi_cond1 = 0 let mut sum_psi_cond2 = 0.0 let mut count_psi_cond2 = 0 - + let len1 = condition1_indices.length() let mut i = 0 while i < len1 { @@ -143,7 +204,7 @@ pub fn bio_isoform_calculate_dif(isoform1 : IsoformExpression, isoform2 : Isofor } i = i + 1 } - + let len2 = condition2_indices.length() let mut j = 0 while j < len2 { @@ -156,23 +217,42 @@ pub fn bio_isoform_calculate_dif(isoform1 : IsoformExpression, isoform2 : Isofor } j = j + 1 } - - let mean_cond1 = if count_psi_cond1 > 0 { sum_psi_cond1 / count_psi_cond1.to_double() } else { 0.5 } - let mean_cond2 = if count_psi_cond2 > 0 { sum_psi_cond2 / count_psi_cond2.to_double() } else { 0.5 } - + + let mean_cond1 = if count_psi_cond1 > 0 { + sum_psi_cond1 / count_psi_cond1.to_double() + } else { + 0.5 + } + let mean_cond2 = if count_psi_cond2 > 0 { + sum_psi_cond2 / count_psi_cond2.to_double() + } else { + 0.5 + } + mean_cond2 - mean_cond1 } -pub fn bio_isoform_find_switches(data : SwitchAnalyzeRlist, dpsi_threshold : Double, - pvalue_threshold : Double) -> Array[IsoformSwitch] { - let gene_to_isoforms : Map[String, Array[IsoformExpression]] = Map([], capacity=0) +///| +pub fn bio_isoform_find_switches( + data : SwitchAnalyzeRlist, + dpsi_threshold : Double, + pvalue_threshold : Double, +) -> Array[IsoformSwitch] { + let gene_to_isoforms : Map[String, Array[IsoformExpression]] = Map( + [], + capacity=0, + ) let gene_map = gene_to_isoforms - + let expr_len = data.isoform_expression.length() let mut i = 0 while i < expr_len { let isoform = data.isoform_expression[i] - let existing = if gene_map.contains(isoform.gene_id) { gene_map.get(isoform.gene_id).unwrap() } else { Array::new() } + let existing = if gene_map.contains(isoform.gene_id) { + gene_map.get(isoform.gene_id).unwrap() + } else { + Array::new() + } let ex_len = existing.length() let updated : Array[IsoformExpression] = Array::new() let mut j = 0 @@ -184,7 +264,7 @@ pub fn bio_isoform_find_switches(data : SwitchAnalyzeRlist, dpsi_threshold : Dou gene_map.set(isoform.gene_id, updated) i = i + 1 } - + let cond_len = data.conditions.length() let condition1_indices : Array[Int] = Array::new() let condition2_indices : Array[Int] = Array::new() @@ -197,15 +277,15 @@ pub fn bio_isoform_find_switches(data : SwitchAnalyzeRlist, dpsi_threshold : Dou } k = k + 1 } - + let mut all_switches : Array[IsoformSwitch] = Array::new() - + let entries = gene_map.iter().collect() let entries_len = entries.length() let mut l = 0 while l < entries_len { let (gene_id, isoforms) = entries[l] - + if isoforms.length() >= 2 { let iso_len = isoforms.length() let mut m = 0 @@ -214,19 +294,33 @@ pub fn bio_isoform_find_switches(data : SwitchAnalyzeRlist, dpsi_threshold : Dou while n < iso_len { let iso1 = isoforms[m] let iso2 = isoforms[n] - - let dpsi = bio_isoform_calculate_dpsi(iso1, iso2, condition1_indices, condition2_indices) - let dif = bio_isoform_calculate_dif(iso1, iso2, condition1_indices, condition2_indices) - - let pvalue = calculate_pvalue(dpsi, iso1, iso2, condition1_indices, condition2_indices) + + let dpsi = bio_isoform_calculate_dpsi( + iso1, iso2, condition1_indices, condition2_indices, + ) + let dif = bio_isoform_calculate_dif( + iso1, iso2, condition1_indices, condition2_indices, + ) + + let pvalue = calculate_pvalue( + dpsi, iso1, iso2, condition1_indices, condition2_indices, + ) let adjusted_pvalue = pvalue * entries_len.to_double() - + if dpsi.abs() >= dpsi_threshold && adjusted_pvalue <= pvalue_threshold { - let direction = if dpsi > 0.0 { "isoform1_up" } else { "isoform2_up" } + let direction = if dpsi > 0.0 { + "isoform1_up" + } else { + "isoform2_up" + } let consequences = predict_consequence(dpsi) - - let gene_name = if data.gene_annotation.contains(gene_id) { data.gene_annotation.get(gene_id).unwrap() } else { gene_id } - + + let gene_name = if data.gene_annotation.contains(gene_id) { + data.gene_annotation.get(gene_id).unwrap() + } else { + gene_id + } + let switch_len = all_switches.length() let new_switches : Array[IsoformSwitch] = Array::new() let mut o = 0 @@ -234,22 +328,32 @@ pub fn bio_isoform_find_switches(data : SwitchAnalyzeRlist, dpsi_threshold : Dou new_switches.push(all_switches[o]) o = o + 1 } - new_switches.push(IsoformSwitch::new( - gene_id, gene_name, iso1.isoform_id, iso2.isoform_id, - dpsi, dif, pvalue, adjusted_pvalue, direction, consequences - )) + new_switches.push( + IsoformSwitch::new( + gene_id, + gene_name, + iso1.isoform_id, + iso2.isoform_id, + dpsi, + dif, + pvalue, + adjusted_pvalue, + direction, + consequences, + ), + ) all_switches = new_switches } - + n = n + 1 } m = m + 1 } } - + l = l + 1 } - + let sw_len = all_switches.length() let mut sorted : Array[IsoformSwitch] = Array::new() let mut p = 0 @@ -257,7 +361,7 @@ pub fn bio_isoform_find_switches(data : SwitchAnalyzeRlist, dpsi_threshold : Dou sorted.push(all_switches[p]) p = p + 1 } - + let mut q = 0 while q < sw_len { let mut r = q + 1 @@ -282,20 +386,26 @@ pub fn bio_isoform_find_switches(data : SwitchAnalyzeRlist, dpsi_threshold : Dou } q = q + 1 } - + sorted } -fn calculate_pvalue(dpsi : Double, iso1 : IsoformExpression, iso2 : IsoformExpression, - cond1 : Array[Int], cond2 : Array[Int]) -> Double { +///| +fn calculate_pvalue( + dpsi : Double, + iso1 : IsoformExpression, + iso2 : IsoformExpression, + cond1 : Array[Int], + cond2 : Array[Int], +) -> Double { let usage1 = bio_isoform_calculate_usage(iso1) let usage2 = bio_isoform_calculate_usage(iso2) - + let mut sum_psi_cond1 = 0.0 let mut count_psi_cond1 = 0 let mut sum_psi_cond2 = 0.0 let mut count_psi_cond2 = 0 - + let len1 = cond1.length() let mut i = 0 while i < len1 { @@ -308,7 +418,7 @@ fn calculate_pvalue(dpsi : Double, iso1 : IsoformExpression, iso2 : IsoformExpre } i = i + 1 } - + let len2 = cond2.length() let mut j = 0 while j < len2 { @@ -321,14 +431,14 @@ fn calculate_pvalue(dpsi : Double, iso1 : IsoformExpression, iso2 : IsoformExpre } j = j + 1 } - + if count_psi_cond1 == 0 || count_psi_cond2 == 0 { return 1.0 } - + let mean1 = sum_psi_cond1 / count_psi_cond1.to_double() let mean2 = sum_psi_cond2 / count_psi_cond2.to_double() - + let mut var_sum1 = 0.0 let mut k = 0 while k < len1 { @@ -341,7 +451,7 @@ fn calculate_pvalue(dpsi : Double, iso1 : IsoformExpression, iso2 : IsoformExpre k = k + 1 } let var1 = var_sum1 / count_psi_cond1.to_double() - + let mut var_sum2 = 0.0 let mut l = 0 while l < len2 { @@ -354,23 +464,26 @@ fn calculate_pvalue(dpsi : Double, iso1 : IsoformExpression, iso2 : IsoformExpre l = l + 1 } let var2 = var_sum2 / count_psi_cond2.to_double() - - let variance_sum = var1 / count_psi_cond1.to_double() + var2 / count_psi_cond2.to_double() + + let variance_sum = var1 / count_psi_cond1.to_double() + + var2 / count_psi_cond2.to_double() let se = if variance_sum > 0.0 { variance_sum.sqrt() } else { 0.0 } - + if se < 0.0001 { let diff = mean2 - mean1 return if diff.abs() > 0.1 { 0.001 } else { 1.0 } } - + let t_stat = (mean2 - mean1) / se 2.0 * (1.0 - isoform_normal_cdf(t_stat.abs())) } +///| fn isoform_normal_cdf(x : Double) -> Double { 0.5 * (1.0 + isoform_erf(x / 2.0.sqrt())) } +///| fn isoform_erf(x : Double) -> Double { let a1 = 0.254829592 let a2 = -0.284496736 @@ -378,21 +491,25 @@ fn isoform_erf(x : Double) -> Double { let a4 = -1.453152027 let a5 = 1.061405429 let p = 0.3275911 - + let sign = if x < 0.0 { -1.0 } else { 1.0 } let abs_x = x.abs() - + let t = 1.0 / (1.0 + p * abs_x) - let y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * @math.exp(-abs_x * abs_x) - + let y = 1.0 - + ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * + t * + @math.exp(-abs_x * abs_x) + sign * y } +///| fn predict_consequence(dpsi : Double) -> Array[String] { let mut consequences : Array[String] = Array::new() - + let usage_diff = dpsi.abs() - + if usage_diff > 0.2 { let len = consequences.length() let new_arr : Array[String] = Array::new() @@ -404,7 +521,7 @@ fn predict_consequence(dpsi : Double) -> Array[String] { new_arr.push("significant_isoform_switch") consequences = new_arr } - + if dpsi > 0.3 { let len = consequences.length() let new_arr : Array[String] = Array::new() @@ -426,7 +543,7 @@ fn predict_consequence(dpsi : Double) -> Array[String] { new_arr.push("isoform2_increased") consequences = new_arr } - + let len = consequences.length() let new_arr : Array[String] = Array::new() let mut i = 0 @@ -438,16 +555,17 @@ fn predict_consequence(dpsi : Double) -> Array[String] { new_arr } +///| pub fn bio_isoform_switch_summary(switches : Array[IsoformSwitch]) -> String { let mut summary = "\nIsoform Switch Summary\n" summary = summary + "=".repeat(60) + "\n" - + let total = switches.length() let mut up_switches = 0 let mut down_switches = 0 let mut sum_dpsi = 0.0 let mut sum_padj = 0.0 - + let mut i = 0 while i < total { let s = switches[i] @@ -460,26 +578,31 @@ pub fn bio_isoform_switch_summary(switches : Array[IsoformSwitch]) -> String { sum_padj = sum_padj + s.adjusted_pvalue i = i + 1 } - + summary = summary + "Total switches: " + total.to_string() + "\n" summary = summary + "Isoform1 up: " + up_switches.to_string() + "\n" summary = summary + "Isoform2 up: " + down_switches.to_string() + "\n" - + let avg_dpsi = if total > 0 { sum_dpsi / total.to_double() } else { 0.0 } let avg_padj = if total > 0 { sum_padj / total.to_double() } else { 0.0 } - + summary = summary + "Average |dPSI|: " + avg_dpsi.to_string() + "\n" summary = summary + "Average adjusted p-value: " + avg_padj.to_string() + "\n" - + summary = summary + "\nTop 5 switches by significance:\n" summary = summary + "-".repeat(60) + "\n" - + let n = if total < 5 { total } else { 5 } let mut j = 0 while j < n { let s = switches[j] summary = summary + s.gene_name + "\n" - summary = summary + " dPSI: " + s.dpsi.to_string() + ", DIF: " + s.dif.to_string() + "\n" + summary = summary + + " dPSI: " + + s.dpsi.to_string() + + ", DIF: " + + s.dif.to_string() + + "\n" summary = summary + " padj: " + s.adjusted_pvalue.to_string() + "\n" summary = summary + " Direction: " + s.switch_direction + "\n" let consequences = s.consequence_type @@ -496,19 +619,30 @@ pub fn bio_isoform_switch_summary(switches : Array[IsoformSwitch]) -> String { summary = summary + " Consequences: " + c_str + "\n" j = j + 1 } - + summary } -pub fn bio_isoform_plot_psi(data : SwitchAnalyzeRlist, gene_id : String) -> String { - let gene_to_isoforms : Map[String, Array[IsoformExpression]] = Map([], capacity=0) +///| +pub fn bio_isoform_plot_psi( + data : SwitchAnalyzeRlist, + gene_id : String, +) -> String { + let gene_to_isoforms : Map[String, Array[IsoformExpression]] = Map( + [], + capacity=0, + ) let gene_map = gene_to_isoforms - + let expr_len = data.isoform_expression.length() let mut i = 0 while i < expr_len { let isoform = data.isoform_expression[i] - let existing = if gene_map.contains(isoform.gene_id) { gene_map.get(isoform.gene_id).unwrap() } else { Array::new() } + let existing = if gene_map.contains(isoform.gene_id) { + gene_map.get(isoform.gene_id).unwrap() + } else { + Array::new() + } let ex_len = existing.length() let updated : Array[IsoformExpression] = Array::new() let mut j = 0 @@ -520,32 +654,36 @@ pub fn bio_isoform_plot_psi(data : SwitchAnalyzeRlist, gene_id : String) -> Stri gene_map.set(isoform.gene_id, updated) i = i + 1 } - + if !gene_map.contains(gene_id) { return "\nGene " + gene_id + " not found\n" } - + let isoforms = gene_map.get(gene_id).unwrap() - let gene_name = if data.gene_annotation.contains(gene_id) { data.gene_annotation.get(gene_id).unwrap() } else { gene_id } - + let gene_name = if data.gene_annotation.contains(gene_id) { + data.gene_annotation.get(gene_id).unwrap() + } else { + gene_id + } + let mut plot = "\nPSI Plot for " + gene_name + " (" + gene_id + ")\n" plot = plot + "=".repeat(80) + "\n" - + let sample_len = data.samples.length() let mut k = 0 while k < sample_len { let sample = data.samples[k] let condition = data.conditions[k] - + plot = plot + sample + " (" + condition + "): " - + let iso_len = isoforms.length() let mut l = 0 while l < iso_len { let isoform = isoforms[l] let usage = bio_isoform_calculate_usage(isoform) let psi = if k < usage.length() { usage[k] } else { 0.0 } - + let mut total = 0.0 let mut m = 0 while m < iso_len { @@ -553,16 +691,16 @@ pub fn bio_isoform_plot_psi(data : SwitchAnalyzeRlist, gene_id : String) -> Stri total = total + (if k < u.length() { u[k] } else { 0.0 }) m = m + 1 } - + let norm_psi = if total > 0.0001 { psi / total * 100.0 } else { 0.0 } - + plot = plot + isoform.isoform_id + ": " + norm_psi.to_string() + "% " l = l + 1 } - + plot = plot + "\n" k = k + 1 } - + plot -} \ No newline at end of file +} diff --git a/src/jaspar.mbt b/src/jaspar.mbt index e3a440a4..3a9d617d 100644 --- a/src/jaspar.mbt +++ b/src/jaspar.mbt @@ -189,7 +189,10 @@ fn j_index_of(s : String, sub : String) -> Int { ///| /// Convert PFM to a position weight matrix (PWM) with log-odds scoring. /// Uses background frequency of 0.25 for each base. -pub fn JasparMatrix::to_pwm(self : JasparMatrix, pseudocount? : Double = 0.01) -> Array[Array[Double]] { +pub fn JasparMatrix::to_pwm( + self : JasparMatrix, + pseudocount? : Double = 0.01, +) -> Array[Array[Double]] { let pwm = Array::new() let bg = 0.25 let mut row = 0 @@ -198,7 +201,8 @@ pub fn JasparMatrix::to_pwm(self : JasparMatrix, pseudocount? : Double = 0.01) - let mut col = 0 while col < self.width { let total = get_col_total(self, col).to_double() - let freq = (self.pfm[row][col].to_double() + pseudocount) / (total + pseudocount * 4.0) + let freq = (self.pfm[row][col].to_double() + pseudocount) / + (total + pseudocount * 4.0) let score = @math.ln(freq / bg) / @math.ln(2.0) col_scores.push(score) col = col + 1 @@ -225,7 +229,8 @@ pub fn JasparMatrix::information_content(self : JasparMatrix) -> Array[Double] { } row = row + 1 } - let max_entropy = @math.ln(self.alphabet.length().to_double()) / @math.ln(2.0) + let max_entropy = @math.ln(self.alphabet.length().to_double()) / + @math.ln(2.0) ic.push(max_entropy - entropy) col = col + 1 } @@ -245,7 +250,10 @@ pub fn JasparMatrix::total_information(self : JasparMatrix) -> Double { ///| /// Scan a sequence with the PWM and return the best score. -pub fn JasparMatrix::scan_sequence(self : JasparMatrix, sequence : String) -> Array[(Int, Double, String)] { +pub fn JasparMatrix::scan_sequence( + self : JasparMatrix, + sequence : String, +) -> Array[(Int, Double, String)] { let pwm = self.to_pwm() let upper_seq = sequence.to_upper() let seq_len = upper_seq.length() @@ -294,7 +302,9 @@ fn find_base_index(matrix : JasparMatrix, base : String) -> Int { ///| /// Sort scanning results by score (descending). -pub fn jaspar_sort_results(results : Array[(Int, Double, String)]) -> Array[(Int, Double, String)] { +pub fn jaspar_sort_results( + results : Array[(Int, Double, String)], +) -> Array[(Int, Double, String)] { let sorted = results let mut i = 0 while i < sorted.length() - 1 { @@ -429,7 +439,10 @@ fn parse_int_array(s : String) -> Array[Int] { ///| /// Get a specific matrix by ID from an array of matrices. -pub fn jaspar_get_matrix(matrices : Array[JasparMatrix], id : String) -> JasparMatrix { +pub fn jaspar_get_matrix( + matrices : Array[JasparMatrix], + id : String, +) -> JasparMatrix { for m in matrices { if m.id == id { return m @@ -442,7 +455,10 @@ pub fn jaspar_get_matrix(matrices : Array[JasparMatrix], id : String) -> JasparM ///| /// Filter matrices by collection. -pub fn jaspar_filter_by_collection(matrices : Array[JasparMatrix], collection : String) -> Array[JasparMatrix] { +pub fn jaspar_filter_by_collection( + matrices : Array[JasparMatrix], + collection : String, +) -> Array[JasparMatrix] { let result : Array[JasparMatrix] = Array::new() for m in matrices { if m.collection == collection { @@ -454,7 +470,10 @@ pub fn jaspar_filter_by_collection(matrices : Array[JasparMatrix], collection : ///| /// Filter matrices by name pattern (case-insensitive substring match). -pub fn jaspar_filter_by_name(matrices : Array[JasparMatrix], pattern : String) -> Array[JasparMatrix] { +pub fn jaspar_filter_by_name( + matrices : Array[JasparMatrix], + pattern : String, +) -> Array[JasparMatrix] { let result : Array[JasparMatrix] = Array::new() let upper_pattern = pattern.to_upper() for m in matrices { diff --git a/src/karyoploter.mbt b/src/karyoploter.mbt index b2a20f17..f6bf1990 100644 --- a/src/karyoploter.mbt +++ b/src/karyoploter.mbt @@ -126,13 +126,17 @@ pub fn KaryotypePlot::new(genome : String) -> KaryotypePlot { // Set up default human chromosomes if genome == "hg38" || genome == "hg19" || genome == "human" { - let chroms = ["chr1", "chr2", "chr3", "chr4", "chr5", "chr6", "chr7", "chr8", - "chr9", "chr10", "chr11", "chr12", "chr13", "chr14", "chr15", "chr16", - "chr17", "chr18", "chr19", "chr20", "chr21", "chr22", "chrX", "chrY"] - let sizes = [248956422, 242193529, 198295559, 190214555, 181538259, 170805979, - 159345973, 145138636, 138394717, 133797422, 135086622, 133275309, - 114364328, 107043718, 101991189, 90338345, 83257441, 80373285, 58617616, - 64444167, 46709983, 50818468, 156040895, 57227415] + let chroms = [ + "chr1", "chr2", "chr3", "chr4", "chr5", "chr6", "chr7", "chr8", "chr9", "chr10", + "chr11", "chr12", "chr13", "chr14", "chr15", "chr16", "chr17", "chr18", "chr19", + "chr20", "chr21", "chr22", "chrX", "chrY", + ] + let sizes = [ + 248956422, 242193529, 198295559, 190214555, 181538259, 170805979, 159345973, + 145138636, 138394717, 133797422, 135086622, 133275309, 114364328, 107043718, + 101991189, 90338345, 83257441, 80373285, 58617616, 64444167, 46709983, 50818468, + 156040895, 57227415, + ] let mut i = 0 while i < chroms.length() { @@ -167,7 +171,10 @@ pub fn KaryotypePlot::get_chromosomes(plot : KaryotypePlot) -> Array[String] { ///| /// Get chromosome size. -pub fn KaryotypePlot::get_chromosome_size(plot : KaryotypePlot, chr : String) -> Int { +pub fn KaryotypePlot::get_chromosome_size( + plot : KaryotypePlot, + chr : String, +) -> Int { match plot.chromosome_sizes.get(chr) { Some(s) => s None => 0 @@ -188,7 +195,10 @@ pub fn KaryotypePlot::get_n_regions(plot : KaryotypePlot) -> Int { ///| /// Add a track to the karyotype plot. -pub fn KaryotypePlot::add_track(plot : KaryotypePlot, track : KaryotypeTrack) -> KaryotypePlot { +pub fn KaryotypePlot::add_track( + plot : KaryotypePlot, + track : KaryotypeTrack, +) -> KaryotypePlot { let tracks = plot.tracks.copy() tracks.push(track) KaryotypePlot::{ @@ -204,7 +214,10 @@ pub fn KaryotypePlot::add_track(plot : KaryotypePlot, track : KaryotypeTrack) -> ///| /// Add a region to the karyotype plot. -pub fn KaryotypePlot::add_region(plot : KaryotypePlot, region : KaryotypeRegion) -> KaryotypePlot { +pub fn KaryotypePlot::add_region( + plot : KaryotypePlot, + region : KaryotypeRegion, +) -> KaryotypePlot { let regions = plot.regions.copy() regions.push(region) KaryotypePlot::{ @@ -220,7 +233,14 @@ pub fn KaryotypePlot::add_region(plot : KaryotypePlot, region : KaryotypeRegion) ///| /// Create a new track. -pub fn KaryotypeTrack::new(track_id : String, track_type : TrackType, chromosome : String, start : Int, end : Int, label : String) -> KaryotypeTrack { +pub fn KaryotypeTrack::new( + track_id : String, + track_type : TrackType, + chromosome : String, + start : Int, + end : Int, + label : String, +) -> KaryotypeTrack { KaryotypeTrack::{ track_id, track_type, @@ -237,7 +257,10 @@ pub fn KaryotypeTrack::new(track_id : String, track_type : TrackType, chromosome ///| /// Add a data point to a track. -pub fn KaryotypeTrack::add_point(track : KaryotypeTrack, point : TrackPoint) -> KaryotypeTrack { +pub fn KaryotypeTrack::add_point( + track : KaryotypeTrack, + point : TrackPoint, +) -> KaryotypeTrack { let data = track.data.copy() data.push(point) KaryotypeTrack::{ @@ -256,25 +279,45 @@ pub fn KaryotypeTrack::add_point(track : KaryotypeTrack, point : TrackPoint) -> ///| /// Create a new track point. -pub fn TrackPoint::new(chromosome : String, position : Int, value : Double, label : String) -> TrackPoint { +pub fn TrackPoint::new( + chromosome : String, + position : Int, + value : Double, + label : String, +) -> TrackPoint { TrackPoint::{ chromosome, position, value, label } } ///| /// Create a new karyotype region. -pub fn KaryotypeRegion::new(chromosome : String, start : Int, end : Int, label : String, color : String) -> KaryotypeRegion { +pub fn KaryotypeRegion::new( + chromosome : String, + start : Int, + end : Int, + label : String, + color : String, +) -> KaryotypeRegion { KaryotypeRegion::{ chromosome, start, end, label, color } } ///| /// Create a new ideogram band. -pub fn IdeogramBand::new(chromosome : String, start : Int, end : Int, band_name : String, stain : String) -> IdeogramBand { +pub fn IdeogramBand::new( + chromosome : String, + start : Int, + end : Int, + band_name : String, + stain : String, +) -> IdeogramBand { IdeogramBand::{ chromosome, start, end, band_name, stain } } ///| /// Set track color. -pub fn KaryotypeTrack::set_color(track : KaryotypeTrack, color : String) -> KaryotypeTrack { +pub fn KaryotypeTrack::set_color( + track : KaryotypeTrack, + color : String, +) -> KaryotypeTrack { KaryotypeTrack::{ track_id: track.track_id, track_type: track.track_type, @@ -291,7 +334,11 @@ pub fn KaryotypeTrack::set_color(track : KaryotypeTrack, color : String) -> Kary ///| /// Set track y-range. -pub fn KaryotypeTrack::set_y_range(track : KaryotypeTrack, y_min : Double, y_max : Double) -> KaryotypeTrack { +pub fn KaryotypeTrack::set_y_range( + track : KaryotypeTrack, + y_min : Double, + y_max : Double, +) -> KaryotypeTrack { KaryotypeTrack::{ track_id: track.track_id, track_type: track.track_type, @@ -320,7 +367,10 @@ pub fn KaryotypeTrack::get_n_points(track : KaryotypeTrack) -> Int { ///| /// Filter a track to a specific chromosome. -pub fn KaryotypeTrack::filter_chromosome(track : KaryotypeTrack, chr : String) -> KaryotypeTrack { +pub fn KaryotypeTrack::filter_chromosome( + track : KaryotypeTrack, + chr : String, +) -> KaryotypeTrack { let filtered : Array[TrackPoint] = Array::new() let mut i = 0 while i < track.data.length() { @@ -345,7 +395,11 @@ pub fn KaryotypeTrack::filter_chromosome(track : KaryotypeTrack, chr : String) - ///| /// Generate an ASCII representation of the karyotype plot. -pub fn KaryotypePlot::to_ascii(plot : KaryotypePlot, chr : String, width : Int) -> String { +pub fn KaryotypePlot::to_ascii( + plot : KaryotypePlot, + chr : String, + width : Int, +) -> String { let w = if width < 40 { 60 } else { width } let chr_size = plot.get_chromosome_size(chr) if chr_size == 0 { @@ -353,7 +407,12 @@ pub fn KaryotypePlot::to_ascii(plot : KaryotypePlot, chr : String, width : Int) } let mut result = "=== Karyotype Plot: " + plot.genome + " ===\n" - result = result + "Chromosome: " + chr + " (size: " + chr_size.to_string() + " bp)\n" + result = result + + "Chromosome: " + + chr + + " (size: " + + chr_size.to_string() + + " bp)\n" // Draw ideogram bar let mut bar = "" @@ -365,7 +424,10 @@ pub fn KaryotypePlot::to_ascii(plot : KaryotypePlot, chr : String, width : Int) result = result + bar + "\n" // Draw centromere marker - let centromere_pos = ((chr_size.to_double() / 2.0) / chr_size.to_double() * (w.to_double() - 1.0)).to_int() + let centromere_pos = (chr_size.to_double() / + 2.0 / + chr_size.to_double() * + (w.to_double() - 1.0)).to_int() let mut cent_bar = "" let mut j = 0 while j < w { @@ -382,7 +444,7 @@ pub fn KaryotypePlot::to_ascii(plot : KaryotypePlot, chr : String, width : Int) let mut ticks = "" let mut k = 0 while k < w { - if k == 0 || k == (w / 4) || k == (w / 2) || k == (3 * w / 4) || k == w - 1 { + if k == 0 || k == w / 4 || k == w / 2 || k == 3 * w / 4 || k == w - 1 { ticks = ticks + "|" } else { ticks = ticks + "-" @@ -407,7 +469,12 @@ pub fn KaryotypePlot::to_ascii(plot : KaryotypePlot, chr : String, width : Int) while track_idx < plot.tracks.length() { let track = plot.tracks[track_idx] if track.chromosome == chr { - result = result + "Track: " + track.label + " (" + track.track_type.to_string() + ")\n" + result = result + + "Track: " + + track.label + + " (" + + track.track_type.to_string() + + ")\n" let mut data_bar = "" let mut m = 0 while m < w { @@ -419,11 +486,23 @@ pub fn KaryotypePlot::to_ascii(plot : KaryotypePlot, chr : String, width : Int) let mut p = 0 while p < track.data.length() { let pt = track.data[p] - let rel_pos = (pt.position.to_double() / chr_size.to_double() * (w.to_double() - 1.0)).to_int() + let rel_pos = (pt.position.to_double() / + chr_size.to_double() * + (w.to_double() - 1.0)).to_int() let value = (pt.value - track.y_min) / (track.y_max - track.y_min) if rel_pos >= 0 && rel_pos < w { - let ch = if value > 0.75 { "#" } else if value > 0.5 { "+" } else if value > 0.25 { "o" } else { "." } - data_bar = data_bar.substring(start=0, end=rel_pos).to_string() + ch + data_bar.substring(start=rel_pos + 1, end=w).to_string() + let ch = if value > 0.75 { + "#" + } else if value > 0.5 { + "+" + } else if value > 0.25 { + "o" + } else { + "." + } + data_bar = data_bar.substring(start=0, end=rel_pos).to_string() + + ch + + data_bar.substring(start=rel_pos + 1, end=w).to_string() } p = p + 1 } @@ -449,7 +528,12 @@ pub fn KaryotypePlot::summary(plot : KaryotypePlot) -> String { let total_bp = 0 while i < plot.chromosomes.length() { let chr = plot.chromosomes[i] - s = s + " " + chr + ": " + plot.get_chromosome_size(chr).to_string() + " bp\n" + s = s + + " " + + chr + + ": " + + plot.get_chromosome_size(chr).to_string() + + " bp\n" i = i + 1 } s @@ -461,32 +545,53 @@ pub fn karyotype_sample() -> KaryotypePlot { let plot = KaryotypePlot::new("hg38") // Add some sample data tracks - let mut gc_track = KaryotypeTrack::new("gc_content", TrackType::Lines, "chr1", 0, 248956422, "GC Content") + let mut gc_track = KaryotypeTrack::new( + "gc_content", + TrackType::Lines, + "chr1", + 0, + 248956422, + "GC Content", + ) gc_track = gc_track.set_color("#FF6600") let mut i = 0 while i < 50 { let pos = i * 497913 - let value = 0.35 + 0.15 * ((i.to_double() / 50.0) * 2.0 - 1.0) * ((i.to_double() / 50.0) * 2.0 - 1.0) + let value = 0.35 + + 0.15 * + (i.to_double() / 50.0 * 2.0 - 1.0) * + (i.to_double() / 50.0 * 2.0 - 1.0) gc_track = gc_track.add_point(TrackPoint::new("chr1", pos, value, "")) i = i + 1 } // Add a second track - let mut snp_track = KaryotypeTrack::new("snp_density", TrackType::Bars, "chr1", 0, 248956422, "SNP Density") + let mut snp_track = KaryotypeTrack::new( + "snp_density", + TrackType::Bars, + "chr1", + 0, + 248956422, + "SNP Density", + ) snp_track = snp_track.set_color("#003399") let mut j = 0 while j < 30 { let pos = j * 829854 - let value = 0.2 + 0.6 * ((j.to_double() / 30.0)) + let value = 0.2 + 0.6 * (j.to_double() / 30.0) snp_track = snp_track.add_point(TrackPoint::new("chr1", pos, value, "")) j = j + 1 } // Add regions of interest - let region1 = KaryotypeRegion::new("chr1", 11000000, 12000000, "BRCA2 region", "#FF0000") - let region2 = KaryotypeRegion::new("chr1", 28000000, 30000000, "TP53 region", "#00FF00") + let region1 = KaryotypeRegion::new( + "chr1", 11000000, 12000000, "BRCA2 region", "#FF0000", + ) + let region2 = KaryotypeRegion::new( + "chr1", 28000000, 30000000, "TP53 region", "#00FF00", + ) let mut result = plot result = result.add_track(gc_track) @@ -495,4 +600,4 @@ pub fn karyotype_sample() -> KaryotypePlot { result = result.add_region(region2) result -} \ No newline at end of file +} diff --git a/src/kgml.mbt b/src/kgml.mbt index 9e617a66..cd76323f 100644 --- a/src/kgml.mbt +++ b/src/kgml.mbt @@ -103,20 +103,8 @@ pub struct KgmlEntry { ///| /// Create a pathway entry. -pub fn KgmlEntry::new( - id : Int, - name : String, - etype : String, -) -> KgmlEntry { - { - id, - name, - etype, - reaction: "", - link: "", - graphics: None, - components: [], - } +pub fn KgmlEntry::new(id : Int, name : String, etype : String) -> KgmlEntry { + { id, name, etype, reaction: "", link: "", graphics: None, components: [] } } ///| @@ -361,7 +349,9 @@ pub fn KgmlPathway::reactions(self : KgmlPathway) -> Array[KgmlReaction] { /// Get entry by ID. pub fn KgmlPathway::get_entry(self : KgmlPathway, id : Int) -> KgmlEntry? { for e in self.entries { - if e.id == id { return Some(e) } + if e.id == id { + return Some(e) + } } None } @@ -374,7 +364,9 @@ pub fn KgmlPathway::get_entries_by_type( ) -> Array[KgmlEntry] { let result : Array[KgmlEntry] = [] for e in self.entries { - if e.etype == etype { result.push(e) } + if e.etype == etype { + result.push(e) + } } result } @@ -387,7 +379,9 @@ pub fn KgmlPathway::get_relations_for_entry( ) -> Array[KgmlRelation] { let result : Array[KgmlRelation] = [] for r in self.relations { - if r.entry1 == id || r.entry2 == id { result.push(r) } + if r.entry1 == id || r.entry2 == id { + result.push(r) + } } result } @@ -401,7 +395,9 @@ pub fn KgmlPathway::get_relations_for_entry( fn kgml_find_from(s : String, sub : String, from : Int) -> Int? { let n = s.length() let sub_len = sub.length() - if sub_len == 0 || from >= n { return None } + if sub_len == 0 || from >= n { + return None + } let mut i = from while i + sub_len <= n { let mut match_found = true @@ -413,7 +409,9 @@ fn kgml_find_from(s : String, sub : String, from : Int) -> Int? { } j = j + 1 } - if match_found { return Some(i) } + if match_found { + return Some(i) + } i = i + 1 } None @@ -451,18 +449,24 @@ fn kgml_attr(tag : String, attr_name : String) -> String { ///| /// Parse an integer from a string, returning default on failure. fn kgml_parse_int(s : String, default : Int) -> Int { - if s.length() == 0 { return default } + if s.length() == 0 { + return default + } let trimmed = s.trim().to_owned() let result = parse_int(trimmed) // parse_int returns 0 on failure; distinguish empty from real 0 - if trimmed.length() == 0 { return default } + if trimmed.length() == 0 { + return default + } result } ///| /// Parse a double from a string, returning default on failure. fn kgml_parse_double(s : String, default : Double) -> Double { - if s.length() == 0 { return default } + if s.length() == 0 { + return default + } let trimmed = s.trim().to_owned() match parse_double(trimmed) { Some(d) => d @@ -478,7 +482,11 @@ fn kgml_attr_int(tag : String, attr_name : String, default : Int) -> Int { ///| /// Extract a double XML attribute, returns default if not found. -fn kgml_attr_double(tag : String, attr_name : String, default : Double) -> Double { +fn kgml_attr_double( + tag : String, + attr_name : String, + default : Double, +) -> Double { kgml_parse_double(kgml_attr(tag, attr_name), default) } @@ -506,7 +514,7 @@ pub fn parse_kgml(content : String) -> KgmlPathway? { let pathway_start = content.find(" None - Some(ps) => { + Some(ps) => match kgml_find_from(content, ">", ps) { None => None Some(te) => { @@ -530,7 +538,6 @@ pub fn parse_kgml(content : String) -> KgmlPathway? { Some(pathway) } } - } } } @@ -550,7 +557,7 @@ fn kgml_parse_children( None => break Some(lt_pos) => { if lt_pos + 1 < n { - let next_ch = content[lt_pos + 1 : lt_pos + 2].to_owned() + let next_ch = content[lt_pos + 1:lt_pos + 2].to_owned() if next_ch == "/" || next_ch == "?" || next_ch == "!" { match kgml_find_from(content, ">", lt_pos) { None => break @@ -570,13 +577,12 @@ fn kgml_parse_children( let space_idx = tag_content.find(" ") let elem_name : String = match space_idx { Some(sp) => tag_content[1:sp].trim().to_owned() - None => { + None => if self_closing { tag_content[1:tag_content.length() - 1].trim().to_owned() } else { tag_content[1:].trim().to_owned() } - } } if elem_name == "entry" { let entry = kgml_parse_entry(content, lt_pos, g, self_closing) @@ -630,7 +636,7 @@ fn kgml_parse_entry( while pos < end_pos { match kgml_find_from(content, "<", pos) { None => break - Some(lp) => { + Some(lp) => match kgml_find_from(content, ">", lp) { None => break Some(gp) => { @@ -645,7 +651,6 @@ fn kgml_parse_entry( pos = gp + 1 } } - } } } } @@ -690,7 +695,7 @@ fn kgml_parse_relation( while pos < end_pos { match kgml_find_from(content, "<", pos) { None => break - Some(lp) => { + Some(lp) => match kgml_find_from(content, ">", lp) { None => break Some(gp) => { @@ -703,7 +708,6 @@ fn kgml_parse_relation( pos = gp + 1 } } - } } } } @@ -731,7 +735,7 @@ fn kgml_parse_reaction( while pos < end_pos { match kgml_find_from(content, "<", pos) { None => break - Some(lp) => { + Some(lp) => match kgml_find_from(content, ">", lp) { None => break Some(gp) => { @@ -746,7 +750,6 @@ fn kgml_parse_reaction( pos = gp + 1 } } - } } } } @@ -768,13 +771,15 @@ pub fn kgml_sample_pathway() -> String { s = s + " image=\"https://www.kegg.jp/kegg/pathway/ko/ko00010.png\"" s = s + " link=\"https://www.kegg.jp/kegg-bin/show_pathway?ko00010\">\n" // Entry 1: gene K00844 - s = s + "" s = s + "" s = s + "\n" // Entry 2: gene K01810 - s = s + "" s = s + "" @@ -786,7 +791,8 @@ pub fn kgml_sample_pathway() -> String { s = s + " type=\"circle\" x=\"150\" y=\"250\" width=\"8\" height=\"8\"/>" s = s + "\n" // Entry 4: gene K01623 - s = s + "" s = s + "" diff --git a/src/kmer.mbt b/src/kmer.mbt index ff8f8971..0a10ce98 100644 --- a/src/kmer.mbt +++ b/src/kmer.mbt @@ -10,18 +10,17 @@ pub struct BioKmerCounter { ///| pub fn BioKmerCounter::new(k : Int) -> BioKmerCounter { - BioKmerCounter::{ - k, - counts: Map([], capacity=1000), - sequence: "" - } + BioKmerCounter::{ k, counts: Map([], capacity=1000), sequence: "" } } ///| -pub fn BioKmerCounter::count_kmers(self : BioKmerCounter, seq : String) -> BioKmerCounter { +pub fn BioKmerCounter::count_kmers( + self : BioKmerCounter, + seq : String, +) -> BioKmerCounter { let n = seq.length() - self.k + 1 let counts = self.counts.copy() - + let mut i = 0 while i < n { let kmer = substring(seq, i, self.k) @@ -32,8 +31,8 @@ pub fn BioKmerCounter::count_kmers(self : BioKmerCounter, seq : String) -> BioKm } i = i + 1 } - - BioKmerCounter::{ k: self.k, counts: counts, sequence: seq } + + BioKmerCounter::{ k: self.k, counts, sequence: seq } } ///| @@ -60,7 +59,10 @@ pub fn BioKmerCounter::unique_kmers(self : BioKmerCounter) -> Int { } ///| -pub fn BioKmerCounter::frequency(self : BioKmerCounter, kmer : String) -> Double { +pub fn BioKmerCounter::frequency( + self : BioKmerCounter, + kmer : String, +) -> Double { let total = self.total_kmers() if total == 0 { 0.0 @@ -70,12 +72,15 @@ pub fn BioKmerCounter::frequency(self : BioKmerCounter, kmer : String) -> Double } ///| -pub fn BioKmerCounter::get_top_kmers(self : BioKmerCounter, n : Int) -> Array[(String, Int)] { +pub fn BioKmerCounter::get_top_kmers( + self : BioKmerCounter, + n : Int, +) -> Array[(String, Int)] { let items : Array[(String, Int)] = Array::new() for key in self.counts.keys() { items.push((key, self.counts.get(key).unwrap())) } - + let mut swapped = true let mut j = 0 while swapped { @@ -92,35 +97,38 @@ pub fn BioKmerCounter::get_top_kmers(self : BioKmerCounter, n : Int) -> Array[(S i = i + 1 } } - + let result : Array[(String, Int)] = Array::new() let mut k = 0 while k < n && k < items.length() { result.push(items[k]) k = k + 1 } - + result } ///| -pub fn BioKmerCounter::jaccard(self : BioKmerCounter, other : BioKmerCounter) -> Double { +pub fn BioKmerCounter::jaccard( + self : BioKmerCounter, + other : BioKmerCounter, +) -> Double { let mut intersection = 0 let mut union = 0 - + for key in self.counts.keys() { if other.counts.contains(key) { intersection = intersection + 1 } union = union + 1 } - + for key in other.counts.keys() { if !self.counts.contains(key) { union = union + 1 } } - + if union == 0 { 0.0 } else { @@ -129,21 +137,24 @@ pub fn BioKmerCounter::jaccard(self : BioKmerCounter, other : BioKmerCounter) -> } ///| -pub fn BioKmerCounter::hamming_distance(self : BioKmerCounter, other : BioKmerCounter) -> Int { +pub fn BioKmerCounter::hamming_distance( + self : BioKmerCounter, + other : BioKmerCounter, +) -> Int { let mut distance = 0 - + for key in self.counts.keys() { let diff = self.counts.get(key).unwrap() - other.count(key) let abs_diff = if diff > 0 { diff } else { -diff } distance = distance + abs_diff } - + for key in other.counts.keys() { if !self.counts.contains(key) { distance = distance + other.count(key) } } - + distance } @@ -155,7 +166,11 @@ pub struct KmerFrequency { } ///| -pub fn KmerFrequency::new(kmer : String, count : Int, frequency : Double) -> KmerFrequency { +pub fn KmerFrequency::new( + kmer : String, + count : Int, + frequency : Double, +) -> KmerFrequency { KmerFrequency::{ kmer, count, frequency } } @@ -169,7 +184,7 @@ pub fn bio_count_kmers(seq : String, k : Int) -> Map[String, Int] { ///| pub fn kmer_spectrum(seq : String, min_k : Int, max_k : Int) -> Array[Int] { let spectrum : Array[Int] = Array::new() - + let mut k = min_k while k <= max_k { let counter = BioKmerCounter::new(k) @@ -177,7 +192,7 @@ pub fn kmer_spectrum(seq : String, min_k : Int, max_k : Int) -> Array[Int] { spectrum.push(counter.unique_kmers()) k = k + 1 } - + spectrum } @@ -186,4 +201,4 @@ pub fn create_example_kmer_counter() -> BioKmerCounter { let counter = BioKmerCounter::new(3) let counter = counter.count_kmers("ATCGATCGATCG") counter -} \ No newline at end of file +} diff --git a/src/limma.mbt b/src/limma.mbt index 58d007b9..b896e2d4 100644 --- a/src/limma.mbt +++ b/src/limma.mbt @@ -1292,7 +1292,8 @@ pub fn limma_remove_batch_effect( xty_data[k] = xty_data[k] + x_jk * y_row[j] let mut l = 0 while l < n_design { - xtx_data[k * n_design + l] = xtx_data[k * n_design + l] + x_jk * design.get(j, l) + xtx_data[k * n_design + l] = xtx_data[k * n_design + l] + + x_jk * design.get(j, l) l = l + 1 } k = k + 1 @@ -1337,7 +1338,11 @@ fn find_batch_index(label : String, unique : Array[String]) -> Int { ///| /// Solve linear system Ax = b using Gaussian elimination. -fn solve_linear_system(a_data : Array[Double], b : Array[Double], n : Int) -> Array[Double] { +fn solve_linear_system( + a_data : Array[Double], + b : Array[Double], + n : Int, +) -> Array[Double] { // Create augmented matrix let aug_data = Array::make(n * (n + 1), 0.0) let mut i = 0 @@ -1391,7 +1396,8 @@ fn solve_linear_system(a_data : Array[Double], b : Array[Double], n : Int) -> Ar let factor = aug_data[k * (n + 1) + i] / pivot let mut j = i while j <= n { - aug_data[k * (n + 1) + j] = aug_data[k * (n + 1) + j] - factor * aug_data[i * (n + 1) + j] + aug_data[k * (n + 1) + j] = aug_data[k * (n + 1) + j] - + factor * aug_data[i * (n + 1) + j] j = j + 1 } k = k + 1 @@ -1412,7 +1418,9 @@ fn solve_linear_system(a_data : Array[Double], b : Array[Double], n : Int) -> Ar } let pivot = aug_data[i * (n + 1) + i] x[i] = if pivot.abs() < 1.0e-10 { 0.0 } else { sum / pivot } - if i == 0 { break } + if i == 0 { + break + } i = i - 1 } @@ -1427,7 +1435,11 @@ fn solve_linear_system(a_data : Array[Double], b : Array[Double], n : Int) -> Ar /// - lfc: log2 fold-change threshold (default 0) /// - direction: "up", "down", or "both" (default "both") /// Returns updated EBayesResult with one-sided p-values and B-values. -pub fn treat(fit : EBayesResult, lfc : Double, direction : String) -> EBayesResult { +pub fn treat( + fit : EBayesResult, + lfc : Double, + direction : String, +) -> EBayesResult { let n_genes = fit.coefficients.rows let n_coefs = fit.coefficients.cols @@ -1443,16 +1455,15 @@ pub fn treat(fit : EBayesResult, lfc : Double, direction : String) -> EBayesResu let beta = fit.coefficients.get(i, j) let se = fit.stdev_unscaled.get(i, j) * fit.sigma[i] - let t_val = if se > 0.0 { - (beta - lfc) / se - } else { - 0.0 - } + let t_val = if se > 0.0 { (beta - lfc) / se } else { 0.0 } let p_val = if direction == "up" { // P(T > t_val) for one-sided if t_val > 0.0 { - let f_val = t_val * t_val * (df_total + 1.0) / (df_total + t_val * t_val) + let f_val = t_val * + t_val * + (df_total + 1.0) / + (df_total + t_val * t_val) 1.0 - pf(f_val, 1.0, df_total) } else { 1.0 @@ -1461,23 +1472,33 @@ pub fn treat(fit : EBayesResult, lfc : Double, direction : String) -> EBayesResu // P(T < t_val) for one-sided if t_val < 0.0 { let t_abs = t_val.abs() - let f_val = t_abs * t_abs * (df_total + 1.0) / (df_total + t_abs * t_abs) + let f_val = t_abs * + t_abs * + (df_total + 1.0) / + (df_total + t_abs * t_abs) 1.0 - pf(f_val, 1.0, df_total) } else { 1.0 } - } else { // Two-sided - if se > 0.0 { - let t_abs = t_val.abs() - let f_val = t_abs * t_abs * (df_total + 1.0) / (df_total + t_abs * t_abs) - 2.0 * (1.0 - pf(f_val, 1.0, df_total)) - } else { - 1.0 - } + } else if se > 0.0 { + let t_abs = t_val.abs() + let f_val = t_abs * + t_abs * + (df_total + 1.0) / + (df_total + t_abs * t_abs) + 2.0 * (1.0 - pf(f_val, 1.0, df_total)) + } else { + 1.0 } - let p = if p_val.is_nan() || p_val < 0.0 { 0.0 } else if p_val > 1.0 { 1.0 } else { p_val } + let p = if p_val.is_nan() || p_val < 0.0 { + 0.0 + } else if p_val > 1.0 { + 1.0 + } else { + p_val + } // B-value (log-odds of differential expression) let b = if p > 0.0 && p < 1.0 { @@ -1773,7 +1794,11 @@ pub fn limma_quantile_normalize(y : Matrix) -> Matrix { } let avg_rank = (rank + end_rank).to_double() / 2.0 let rank_floor = avg_rank.to_int() - let rank_ceil = if rank_floor + 1 < n_genes { rank_floor + 1 } else { n_genes - 1 } + let rank_ceil = if rank_floor + 1 < n_genes { + rank_floor + 1 + } else { + n_genes - 1 + } let frac = avg_rank - rank_floor.to_double() let val = if rank_floor == rank_ceil { @@ -1899,7 +1924,8 @@ pub fn limma_combat( while i < n_genes { let offset = batch_offset[i] // Weighted average: combine batch offset with prior (0) - let shrunken = offset * batch_size.to_double() / + let shrunken = offset * + batch_size.to_double() / (batch_size.to_double() + offset / prior_var.abs()) // Subtract shrunken batch offset from batch samples @@ -1923,7 +1949,9 @@ pub fn limma_combat( ///| /// Compute mean of an array (helper for limma module). fn limma_stat_mean(data : Array[Double]) -> Double { - if data.length() == 0 { return 0.0 } + if data.length() == 0 { + return 0.0 + } let mut sum = 0.0 for v in data { sum = sum + v @@ -1935,7 +1963,9 @@ fn limma_stat_mean(data : Array[Double]) -> Double { /// Compute variance of an array (helper for limma module). fn limma_stat_variance(data : Array[Double]) -> Double { let n = data.length() - if n <= 1 { return 0.0 } + if n <= 1 { + return 0.0 + } let mean = limma_stat_mean(data) let mut sum_sq = 0.0 for v in data { diff --git a/src/lisaclust.mbt b/src/lisaclust.mbt index 579f513a..7f082df1 100644 --- a/src/lisaclust.mbt +++ b/src/lisaclust.mbt @@ -376,28 +376,26 @@ pub fn LisaResult::top_enrichments( selected.push(entry) } } - selected.sort_by( - fn( - left : LisaRegionEnrichment, - right : LisaRegionEnrichment, - ) -> Int { - if left.relative_frequency > right.relative_frequency { - -1 - } else if left.relative_frequency < right.relative_frequency { - 1 - } else if left.region < right.region { - -1 - } else if left.region > right.region { - 1 - } else if left.cell_type < right.cell_type { - -1 - } else if left.cell_type > right.cell_type { - 1 - } else { - 0 - } - }, - ) + selected.sort_by(fn( + left : LisaRegionEnrichment, + right : LisaRegionEnrichment, + ) -> Int { + if left.relative_frequency > right.relative_frequency { + -1 + } else if left.relative_frequency < right.relative_frequency { + 1 + } else if left.region < right.region { + -1 + } else if left.region > right.region { + 1 + } else if left.cell_type < right.cell_type { + -1 + } else if left.cell_type > right.cell_type { + 1 + } else { + 0 + } + }) let output : Array[LisaRegionEnrichment] = [] for index in 0.. Array[(Double, Double)] { let sorted = points.copy() - sorted.sort_by( - fn(left : (Double, Double), right : (Double, Double)) -> Int { - if left.0 < right.0 { - -1 - } else if left.0 > right.0 { - 1 - } else if left.1 < right.1 { - -1 - } else if left.1 > right.1 { - 1 - } else { - 0 - } - }, - ) + sorted.sort_by(fn(left : (Double, Double), right : (Double, Double)) -> Int { + if left.0 < right.0 { + -1 + } else if left.0 > right.0 { + 1 + } else if left.1 < right.1 { + -1 + } else if left.1 > right.1 { + 1 + } else { + 0 + } + }) let unique : Array[(Double, Double)] = [] for point in sorted { if unique.length() == 0 || unique[unique.length() - 1] != point { @@ -520,11 +516,12 @@ fn lisa_convex_hull( let lower : Array[(Double, Double)] = [] for point in unique { while lower.length() >= 2 && - lisa_cross( - lower[lower.length() - 2], - lower[lower.length() - 1], - point, - ) <= 0.0 { + lisa_cross( + lower[lower.length() - 2], + lower[lower.length() - 1], + point, + ) <= + 0.0 { ignore(lower.pop()) } lower.push(point) @@ -534,11 +531,12 @@ fn lisa_convex_hull( while index >= 0 { let point = unique[index] while upper.length() >= 2 && - lisa_cross( - upper[upper.length() - 2], - upper[upper.length() - 1], - point, - ) <= 0.0 { + lisa_cross( + upper[upper.length() - 2], + upper[upper.length() - 1], + point, + ) <= + 0.0 { ignore(upper.pop()) } upper.push(point) @@ -621,15 +619,18 @@ fn lisa_image_window( let width = max_x - min_x let height = max_y - min_y if width <= 1.0e-14 || height <= 1.0e-14 { - raise LisaError("lisaClust image windows must have positive width and height") + raise LisaError( + "lisaClust image windows must have positive width and height", + ) } let vertices = match config.window_kind { - LisaRectangle => [ - (min_x - config.window_padding, min_y - config.window_padding), - (max_x + config.window_padding, min_y - config.window_padding), - (max_x + config.window_padding, max_y + config.window_padding), - (min_x - config.window_padding, max_y + config.window_padding), - ] + LisaRectangle => + [ + (min_x - config.window_padding, min_y - config.window_padding), + (max_x + config.window_padding, min_y - config.window_padding), + (max_x + config.window_padding, max_y + config.window_padding), + (min_x - config.window_padding, max_y + config.window_padding), + ] LisaConvexHull => { let hull = lisa_convex_hull(points) if hull.length() < 3 { @@ -652,9 +653,9 @@ fn lisa_image_window( vertex_min_y = vertex_min_y.min(vertex.1) vertex_max_y = vertex_max_y.max(vertex.1) } - let max_radius = ((vertex_max_x - vertex_min_x).min( - vertex_max_y - vertex_min_y, - )) / + let max_radius = (vertex_max_x - vertex_min_x).min( + vertex_max_y - vertex_min_y, + ) / 2.01 LisaImageWindow::{ image_id, vertices, area, max_radius } } @@ -682,9 +683,7 @@ fn lisa_ray_boundary_distance( let qy = ay - y let distance = (qx * ey - qy * ex) / denominator let segment = (qx * dy - qy * dx) / denominator - if distance >= 0.0 && - segment >= -1.0e-10 && - segment <= 1.0 + 1.0e-10 { + if distance >= 0.0 && segment >= -1.0e-10 && segment <= 1.0 + 1.0e-10 { closest = closest.min(distance) } } @@ -797,9 +796,7 @@ pub fn lisa_curves( for radius in config.radii { image_radii.push(radius.min(window.max_radius)) } - effective_radii.push( - LisaImageRadii::{ image_id, radii: image_radii.copy() }, - ) + effective_radii.push(LisaImageRadii::{ image_id, radii: image_radii.copy() }) let density_weights = lisa_density_weights( cells, indices, @@ -846,11 +843,7 @@ pub fn lisa_curves( } else { 1.0 } - let expected = @math.PI * - radius * - radius * - edge_fraction * - intensity + let expected = @math.PI * radius * radius * edge_fraction * intensity let feature = type_index * config.radii.length() + radius_index values[source_global][feature] = if expected <= 1.0e-14 { 0.0 @@ -887,10 +880,7 @@ pub fn lisa_curves( } ///| -fn lisa_squared_distance( - left : Array[Double], - right : Array[Double], -) -> Double { +fn lisa_squared_distance(left : Array[Double], right : Array[Double]) -> Double { let mut output = 0.0 for index in 0.. LisaKmeansFit { let first = (config.seed + start * 9973) % data.length() - let mut centroids = lisa_initialize_centroids( - data, - config.n_clusters, - first, - ) + let mut centroids = lisa_initialize_centroids(data, config.n_clusters, first) let mut labels = Array::make(data.length(), -1) let mut iterations = 0 let mut converged = false @@ -1034,10 +1020,7 @@ fn lisa_kmeans_once( let mut maximum_shift = 0.0 for cluster in 0.. maximum { dominant = entry.cell_type maximum = entry.relative_frequency } } - summaries.push( - LisaRegionSummary::{ - region: config.region_prefix + "_" + (region + 1).to_string(), - size: region_totals[region], - dominant_cell_type: dominant, - maximum_enrichment: maximum.max(0.0), - }, - ) + summaries.push(LisaRegionSummary::{ + region: config.region_prefix + "_" + (region + 1).to_string(), + size: region_totals[region], + dominant_cell_type: dominant, + maximum_enrichment: maximum.max(0.0), + }) } (enrichment, summaries) } @@ -1255,11 +1233,7 @@ pub fn lisaclust_from_curves( cluster_sizes[label] = cluster_sizes[label] + 1 regions.push(config.region_prefix + "_" + (label + 1).to_string()) } - let silhouette = lisa_silhouette( - curves.values, - fit.labels, - config.n_clusters, - ) + let silhouette = lisa_silhouette(curves.values, fit.labels, config.n_clusters) let (enrichment, region_summaries) = lisa_enrichment( curves, fit.labels, @@ -1400,7 +1374,9 @@ pub fn lisaclust_spatial_experiment( enriched.col_data[row][region_key] = result.regions[row] } enriched.metadata["lisaclust_cells"] = result.n_cells().to_string() - enriched.metadata["lisaclust_features"] = result.curves.n_features().to_string() + enriched.metadata["lisaclust_features"] = result.curves + .n_features() + .to_string() enriched.metadata["lisaclust_regions"] = result.n_regions().to_string() enriched.metadata["lisaclust_silhouette"] = result.silhouette.to_string() LisaSpatialExperimentOutput::{ experiment: enriched, result } @@ -1414,7 +1390,11 @@ pub fn lisaclust_example_data() -> Array[LisaCell] { for row in 0..<4 { let left = column < 4 let cell_type = if left { - if (column + row + image) % 3 == 0 { "B_cell" } else { "T_cell" } + if (column + row + image) % 3 == 0 { + "B_cell" + } else { + "T_cell" + } } else if (column + row + image) % 3 == 0 { "Stroma" } else { diff --git a/src/logistic_regression.mbt b/src/logistic_regression.mbt index e65b7143..276c08de 100644 --- a/src/logistic_regression.mbt +++ b/src/logistic_regression.mbt @@ -17,23 +17,23 @@ pub struct LogisticRegressionModel { ///| /// Construct a new LogisticRegressionModel with the given beta weights. pub fn LogisticRegressionModel::new( - beta : Array[Double] + beta : Array[Double], ) -> LogisticRegressionModel { - LogisticRegressionModel::{ beta } + LogisticRegressionModel::{ beta, } } ///| /// Accessor for the beta weight vector. -pub fn LogisticRegressionModel::beta(self : LogisticRegressionModel) -> Array[ - Double -] { +pub fn LogisticRegressionModel::beta( + self : LogisticRegressionModel, +) -> Array[Double] { self.beta } ///| /// Number of weights (including bias). pub fn LogisticRegressionModel::n_weights( - self : LogisticRegressionModel + self : LogisticRegressionModel, ) -> Int { self.beta.length() } @@ -97,13 +97,13 @@ fn lr_solve(matrix : Array[Array[Double]], b : Array[Double]) -> Array[Double]? for col in 0.. max_val { max_val = abs_val @@ -159,7 +159,7 @@ fn lr_solve(matrix : Array[Array[Double]], b : Array[Double]) -> Array[Double]? /// Returns a trained `LogisticRegressionModel`. pub fn logistic_regression_train( xs : Array[Array[Double]], - ys : Array[Int] + ys : Array[Int], ) -> LogisticRegressionModel { let n = xs.length() // Each observation gets a leading constant 1.0 for the bias term. @@ -190,7 +190,9 @@ pub fn logistic_regression_train( let mut llik = 0.0 for i in 0.. { + Some(delta) => for k in 0.. { - break - } + None => break } } - LogisticRegressionModel::{ beta } + LogisticRegressionModel::{ beta, } } ///| @@ -257,7 +256,7 @@ pub fn logistic_regression_train( /// Returns [P(class=0), P(class=1)]. pub fn logistic_regression_calculate( model : LogisticRegressionModel, - x : Array[Double] + x : Array[Double], ) -> Array[Double] { // Prepend constant 1.0 for bias. let xfull = Array::make(x.length() + 1, 1.0) @@ -273,7 +272,7 @@ pub fn logistic_regression_calculate( /// Classify an observation into class 0 or 1. pub fn logistic_regression_classify( model : LogisticRegressionModel, - x : Array[Double] + x : Array[Double], ) -> Int { let probs = logistic_regression_calculate(model, x) if probs[0] > probs[1] { @@ -291,9 +290,7 @@ pub fn logistic_regression_classify( /// Sample training data for operon prediction (Biopython tutorial example). /// Each observation: [intergenic_distance, expression_score]. /// Label 1 = same operon (OP), 0 = different operon (NOP). -pub fn logistic_regression_sample_data() -> (Array[ - Array[Double] -], Array[Int]) { +pub fn logistic_regression_sample_data() -> (Array[Array[Double]], Array[Int]) { let xs = [ [-53.0, -200.78], [117.0, -267.14], diff --git a/src/lowess.mbt b/src/lowess.mbt index 83c3c6b0..4990737a 100644 --- a/src/lowess.mbt +++ b/src/lowess.mbt @@ -185,9 +185,9 @@ fn lowess_compute_point( pub fn lowess( x : Array[Double], y : Array[Double], - f~ : Double = 0.6667, - n_steps~ : Int = 0, - delta~ : Double = 0.0, + f? : Double = 0.6667, + n_steps? : Int = 0, + delta? : Double = 0.0, ) -> Array[Double] { let n = x.length() if n == 0 { @@ -273,11 +273,11 @@ pub fn lowess( pub fn lowess_robust( x : Array[Double], y : Array[Double], - f~ : Double = 0.6667, - n_steps~ : Int = 2, - delta~ : Double = 0.0, + f? : Double = 0.6667, + n_steps? : Int = 2, + delta? : Double = 0.0, ) -> Array[Double] { - lowess(x, y, f=f, n_steps=n_steps, delta=delta) + lowess(x, y, f~, n_steps~, delta~) } ///| @@ -290,7 +290,7 @@ pub fn lowess_predict( x : Array[Double], y : Array[Double], smoothed_y : Array[Double], - f~ : Double = 0.6667, + f? : Double = 0.6667, ) -> Double { let n = x.length() if n == 0 { @@ -394,7 +394,7 @@ pub fn lowess_predict( /// Convenience function where x = 0, 1, 2, ... (indices as x values). pub fn lowess_smooth_series( values : Array[Double], - window_frac~ : Double = 0.3, + window_frac? : Double = 0.3, ) -> Array[Double] { let n = values.length() if n == 0 { diff --git a/src/ma_align.mbt b/src/ma_align.mbt index b127e611..7f800148 100644 --- a/src/ma_align.mbt +++ b/src/ma_align.mbt @@ -39,7 +39,9 @@ pub fn StructureData::get_id(self : StructureData) -> String { ///| /// Get the CA atom coordinates. -pub fn StructureData::get_coordinates(self : StructureData) -> Array[(Double, Double, Double)] { +pub fn StructureData::get_coordinates( + self : StructureData, +) -> Array[(Double, Double, Double)] { self.ca_coordinates } @@ -94,31 +96,41 @@ pub fn AlignmentResult::new( ///| /// Get the structure IDs. -pub fn AlignmentResult::get_structure_ids(self : AlignmentResult) -> Array[String] { +pub fn AlignmentResult::get_structure_ids( + self : AlignmentResult, +) -> Array[String] { self.structure_ids } ///| /// Get the aligned sequences. -pub fn AlignmentResult::get_aligned_sequences(self : AlignmentResult) -> Array[String] { +pub fn AlignmentResult::get_aligned_sequences( + self : AlignmentResult, +) -> Array[String] { self.aligned_sequences } ///| /// Get the pairwise RMSD matrix. -pub fn AlignmentResult::get_rmsd_matrix(self : AlignmentResult) -> Array[Array[Double]] { +pub fn AlignmentResult::get_rmsd_matrix( + self : AlignmentResult, +) -> Array[Array[Double]] { self.rmsd_matrix } ///| /// Get the aligned coordinates. -pub fn AlignmentResult::get_aligned_coordinates(self : AlignmentResult) -> Array[Array[(Double, Double, Double)]] { +pub fn AlignmentResult::get_aligned_coordinates( + self : AlignmentResult, +) -> Array[Array[(Double, Double, Double)]] { self.aligned_coordinates } ///| /// Get the per-column conservation scores. -pub fn AlignmentResult::get_conservation(self : AlignmentResult) -> Array[Double] { +pub fn AlignmentResult::get_conservation( + self : AlignmentResult, +) -> Array[Double] { self.conservation } @@ -209,7 +221,9 @@ pub fn MAaligner::get_rmsd_threshold(self : MAaligner) -> Double { ///| /// Compute the centroid of a set of coordinates. -fn ma_compute_centroid(coords : Array[(Double, Double, Double)]) -> (Double, Double, Double) { +fn ma_compute_centroid( + coords : Array[(Double, Double, Double)], +) -> (Double, Double, Double) { let n = coords.length() if n == 0 { return (0.0, 0.0, 0.0) @@ -230,7 +244,10 @@ fn ma_compute_centroid(coords : Array[(Double, Double, Double)]) -> (Double, Dou ///| /// Compute the Euclidean distance between two 3D points. -fn ma_point_distance(p1 : (Double, Double, Double), p2 : (Double, Double, Double)) -> Double { +fn ma_point_distance( + p1 : (Double, Double, Double), + p2 : (Double, Double, Double), +) -> Double { let dx = p1.0 - p2.0 let dy = p1.1 - p2.1 let dz = p1.2 - p2.2 @@ -243,7 +260,11 @@ fn ma_compute_covariance( p : Array[(Double, Double, Double)], q : Array[(Double, Double, Double)], ) -> Array[Array[Double]] { - let h : Array[Array[Double]] = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] + let h : Array[Array[Double]] = [ + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + ] let n = p.length() let mut i = 0 while i < n { @@ -269,7 +290,11 @@ fn ma_matmul_3x3( a : Array[Array[Double]], b : Array[Array[Double]], ) -> Array[Array[Double]] { - let result : Array[Array[Double]] = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] + let result : Array[Array[Double]] = [ + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + ] let mut i = 0 while i < 3 { let mut j = 0 @@ -291,9 +316,11 @@ fn ma_matmul_3x3( ///| /// Transpose a 3x3 matrix. fn ma_transpose_3x3(m : Array[Array[Double]]) -> Array[Array[Double]] { - [[m[0][0], m[1][0], m[2][0]], - [m[0][1], m[1][1], m[2][1]], - [m[0][2], m[1][2], m[2][2]]] + [ + [m[0][0], m[1][0], m[2][0]], + [m[0][1], m[1][1], m[2][1]], + [m[0][2], m[1][2], m[2][2]], + ] } ///| @@ -313,7 +340,11 @@ fn ma_invert_3x3(m : Array[Array[Double]]) -> Array[Array[Double]] { return [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] } let inv_det = 1.0 / det - let result : Array[Array[Double]] = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] + let result : Array[Array[Double]] = [ + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + ] result[0][0] = (m[1][1] * m[2][2] - m[1][2] * m[2][1]) * inv_det result[0][1] = (m[0][2] * m[2][1] - m[0][1] * m[2][2]) * inv_det result[0][2] = (m[0][1] * m[1][2] - m[0][2] * m[1][1]) * inv_det @@ -330,7 +361,9 @@ fn ma_invert_3x3(m : Array[Array[Double]]) -> Array[Array[Double]] { /// Compute eigenvalues and eigenvectors of a 3x3 symmetric matrix. /// Uses the analytical solution for 3x3 symmetric matrices. /// Returns (eigenvalues, eigenvectors_as_columns). -fn ma_eigen_3x3(m : Array[Array[Double]]) -> (Array[Double], Array[Array[Double]]) { +fn ma_eigen_3x3( + m : Array[Array[Double]], +) -> (Array[Double], Array[Array[Double]]) { let eps = 1.0e-12 let a = m @@ -347,15 +380,25 @@ fn ma_eigen_3x3(m : Array[Array[Double]]) -> (Array[Double], Array[Array[Double] let p1 = (b01 * b01 + b02 * b02 + b12 * b12).sqrt() let eigenvalues : Array[Double] = [0.0, 0.0, 0.0] - let eigenvectors : Array[Array[Double]] = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] + let eigenvectors : Array[Array[Double]] = [ + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + ] if p1.abs() < eps { eigenvalues[0] = a[0][0] eigenvalues[1] = a[1][1] eigenvalues[2] = a[2][2] - eigenvectors[0][0] = 1.0; eigenvectors[0][1] = 0.0; eigenvectors[0][2] = 0.0 - eigenvectors[1][0] = 0.0; eigenvectors[1][1] = 1.0; eigenvectors[1][2] = 0.0 - eigenvectors[2][0] = 0.0; eigenvectors[2][1] = 0.0; eigenvectors[2][2] = 1.0 + eigenvectors[0][0] = 1.0 + eigenvectors[0][1] = 0.0 + eigenvectors[0][2] = 0.0 + eigenvectors[1][0] = 0.0 + eigenvectors[1][1] = 1.0 + eigenvectors[1][2] = 0.0 + eigenvectors[2][0] = 0.0 + eigenvectors[2][1] = 0.0 + eigenvectors[2][2] = 1.0 return (eigenvalues, eigenvectors) } @@ -381,11 +424,17 @@ fn ma_eigen_3x3(m : Array[Array[Double]]) -> (Array[Double], Array[Array[Double] eigenvalues[2] = q + 2.0 * p * @math.cos(phi + 2.0 * @math.PI / 3.0) eigenvalues[1] = 3.0 * q - eigenvalues[0] - eigenvalues[2] - let sorted_eigs : Array[Double] = [eigenvalues[0], eigenvalues[1], eigenvalues[2]] + let sorted_eigs : Array[Double] = [ + eigenvalues[0], + eigenvalues[1], + eigenvalues[2], + ] let v0_norm_sq = b01 * b01 + b02 * b02 if v0_norm_sq < eps { - eigenvectors[0][0] = 1.0; eigenvectors[0][1] = 0.0; eigenvectors[0][2] = 0.0 + eigenvectors[0][0] = 1.0 + eigenvectors[0][1] = 0.0 + eigenvectors[0][2] = 0.0 } else { let v0n = v0_norm_sq.sqrt() eigenvectors[0][0] = b01 / v0n @@ -399,19 +448,26 @@ fn ma_eigen_3x3(m : Array[Array[Double]]) -> (Array[Double], Array[Array[Double] let e3 = (l1 - a[2][2]) / (l1 - eigenvalues[0] + eps) let e_norm = (e1 * e1 + e2 * e2 + e3 * e3).sqrt() if e_norm < eps { - eigenvectors[1][0] = 0.0; eigenvectors[1][1] = 1.0; eigenvectors[1][2] = 0.0 + eigenvectors[1][0] = 0.0 + eigenvectors[1][1] = 1.0 + eigenvectors[1][2] = 0.0 } else { eigenvectors[1][0] = e1 / e_norm eigenvectors[1][1] = e2 / e_norm eigenvectors[1][2] = e3 / e_norm } - let cross_x = eigenvectors[0][1] * eigenvectors[1][2] - eigenvectors[0][2] * eigenvectors[1][1] - let cross_y = eigenvectors[0][2] * eigenvectors[1][0] - eigenvectors[0][0] * eigenvectors[1][2] - let cross_z = eigenvectors[0][0] * eigenvectors[1][1] - eigenvectors[0][1] * eigenvectors[1][0] + let cross_x = eigenvectors[0][1] * eigenvectors[1][2] - + eigenvectors[0][2] * eigenvectors[1][1] + let cross_y = eigenvectors[0][2] * eigenvectors[1][0] - + eigenvectors[0][0] * eigenvectors[1][2] + let cross_z = eigenvectors[0][0] * eigenvectors[1][1] - + eigenvectors[0][1] * eigenvectors[1][0] let cross_norm = (cross_x * cross_x + cross_y * cross_y + cross_z * cross_z).sqrt() if cross_norm < eps { - eigenvectors[2][0] = 0.0; eigenvectors[2][1] = 0.0; eigenvectors[2][2] = 1.0 + eigenvectors[2][0] = 0.0 + eigenvectors[2][1] = 0.0 + eigenvectors[2][2] = 1.0 } else { eigenvectors[2][0] = cross_x / cross_norm eigenvectors[2][1] = cross_y / cross_norm @@ -427,11 +483,27 @@ fn ma_eigen_3x3(m : Array[Array[Double]]) -> (Array[Double], Array[Array[Double] fn ma_matrix_sqrt_3x3(m : Array[Array[Double]]) -> Array[Array[Double]] { let (eigenvalues, eigenvectors) = ma_eigen_3x3(m) - let sqrt_eig0 = if eigenvalues[0] >= 0.0 { eigenvalues[0].sqrt() } else { 0.0 } - let sqrt_eig1 = if eigenvalues[1] >= 0.0 { eigenvalues[1].sqrt() } else { 0.0 } - let sqrt_eig2 = if eigenvalues[2] >= 0.0 { eigenvalues[2].sqrt() } else { 0.0 } + let sqrt_eig0 = if eigenvalues[0] >= 0.0 { + eigenvalues[0].sqrt() + } else { + 0.0 + } + let sqrt_eig1 = if eigenvalues[1] >= 0.0 { + eigenvalues[1].sqrt() + } else { + 0.0 + } + let sqrt_eig2 = if eigenvalues[2] >= 0.0 { + eigenvalues[2].sqrt() + } else { + 0.0 + } - let result : Array[Array[Double]] = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] + let result : Array[Array[Double]] = [ + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + ] let mut i = 0 while i < 3 { let mut j = 0 @@ -450,7 +522,9 @@ fn ma_matrix_sqrt_3x3(m : Array[Array[Double]]) -> Array[Array[Double]] { ///| /// Build a 3x3 rotation matrix from three rotation angles (around x, y, z axes). -fn ma_build_rotation_matrix(angles : (Double, Double, Double)) -> Array[Array[Double]] { +fn ma_build_rotation_matrix( + angles : (Double, Double, Double), +) -> Array[Array[Double]] { let rx = angles.0 let ry = angles.1 let rz = angles.2 @@ -462,16 +536,23 @@ fn ma_build_rotation_matrix(angles : (Double, Double, Double)) -> Array[Array[Do let cz = @math.cos(rz) let sz = @math.sin(rz) - [[cy * cz, cx * sz + sx * sy * cz, sx * sz - cx * sy * cz], - [-cy * sz, cx * cz - sx * sy * sz, sx * cz + cx * sy * sz], - [sy, -sx * cy, cx * cy]] + [ + [cy * cz, cx * sz + sx * sy * cz, sx * sz - cx * sy * cz], + [-cy * sz, cx * cz - sx * sy * sz, sx * cz + cx * sy * sz], + [sy, -sx * cy, cx * cy], + ] } ///| /// Extract Euler angles (rotation around x, y, z) from a rotation matrix. -fn ma_rotation_to_angles(rot : Array[Array[Double]]) -> (Double, Double, Double) { +fn ma_rotation_to_angles( + rot : Array[Array[Double]], +) -> (Double, Double, Double) { let angle_x = @math.atan2(rot[2][1], rot[2][2]) - let angle_y = @math.atan2(-rot[2][0], (rot[2][1] * rot[2][1] + rot[2][2] * rot[2][2]).sqrt()) + let angle_y = @math.atan2( + -rot[2][0], + (rot[2][1] * rot[2][1] + rot[2][2] * rot[2][2]).sqrt(), + ) let angle_z = @math.atan2(rot[1][0], rot[0][0]) (angle_x, angle_y, angle_z) } @@ -482,7 +563,9 @@ fn ma_rotation_to_angles(rot : Array[Array[Double]]) -> (Double, Double, Double) ///| /// Center coordinates at the origin (subtract centroid). -pub fn ma_center_coordinates(coords : Array[(Double, Double, Double)]) -> Array[(Double, Double, Double)] { +pub fn ma_center_coordinates( + coords : Array[(Double, Double, Double)], +) -> Array[(Double, Double, Double)] { let centroid = ma_compute_centroid(coords) let result : Array[(Double, Double, Double)] = Array::new() let mut i = 0 @@ -569,7 +652,11 @@ pub fn compute_rmsd( coords1 : Array[(Double, Double, Double)], coords2 : Array[(Double, Double, Double)], ) -> Double { - let n = if coords1.length() < coords2.length() { coords1.length() } else { coords2.length() } + let n = if coords1.length() < coords2.length() { + coords1.length() + } else { + coords2.length() + } if n == 0 { return 0.0 } @@ -598,7 +685,11 @@ pub fn compute_svd_rotation( coords1 : Array[(Double, Double, Double)], coords2 : Array[(Double, Double, Double)], ) -> (Double, Double, Double) { - let n = if coords1.length() < coords2.length() { coords1.length() } else { coords2.length() } + let n = if coords1.length() < coords2.length() { + coords1.length() + } else { + coords2.length() + } if n < 2 { return (0.0, 0.0, 0.0) } @@ -612,9 +703,7 @@ pub fn compute_svd_rotation( let det_ht_h = ma_det_3x3(ht_h) let final_rot = if det_ht_h.abs() < 1.0e-15 { - [[1.0, 0.0, 0.0], - [0.0, 1.0, 0.0], - [0.0, 0.0, 1.0]] + [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] } else { let sqrt_ht_h = ma_matrix_sqrt_3x3(ht_h) let sqrt_ht_h_inv = ma_invert_3x3(sqrt_ht_h) @@ -622,9 +711,11 @@ pub fn compute_svd_rotation( let det_rot = ma_det_3x3(rot) if det_rot < 0.0 { - [[rot[0][0], rot[0][1], -rot[0][2]], - [rot[1][0], rot[1][1], -rot[1][2]], - [rot[2][0], rot[2][1], -rot[2][2]]] + [ + [rot[0][0], rot[0][1], -rot[0][2]], + [rot[1][0], rot[1][1], -rot[1][2]], + [rot[2][0], rot[2][1], -rot[2][2]], + ] } else { rot } @@ -677,9 +768,7 @@ pub fn ma_align_pairwise( let det_ht_h = ma_det_3x3(ht_h) let final_rot = if det_ht_h.abs() < 1.0e-15 { - [[1.0, 0.0, 0.0], - [0.0, 1.0, 0.0], - [0.0, 0.0, 1.0]] + [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] } else { let sqrt_ht_h = ma_matrix_sqrt_3x3(ht_h) let sqrt_ht_h_inv = ma_invert_3x3(sqrt_ht_h) @@ -687,9 +776,11 @@ pub fn ma_align_pairwise( let det_rot = ma_det_3x3(rot) if det_rot < 0.0 { - [[rot[0][0], rot[0][1], -rot[0][2]], - [rot[1][0], rot[1][1], -rot[1][2]], - [rot[2][0], rot[2][1], -rot[2][2]]] + [ + [rot[0][0], rot[0][1], -rot[0][2]], + [rot[1][0], rot[1][1], -rot[1][2]], + [rot[2][0], rot[2][1], -rot[2][2]], + ] } else { rot } @@ -726,7 +817,13 @@ fn ma_compute_average_structure( sz = sz + z j = j + 1 } - avg.push((sx / n_structures.to_double(), sy / n_structures.to_double(), sz / n_structures.to_double())) + avg.push( + ( + sx / n_structures.to_double(), + sy / n_structures.to_double(), + sz / n_structures.to_double(), + ), + ) i = i + 1 } avg @@ -871,7 +968,10 @@ pub fn iterate_alignment( let mut max_rmsd = 0.0 let mut i = 1 while i < n { - let (rotation, rmsd) = ma_align_pairwise(ref_coords, structures[i].ca_coordinates) + let (rotation, rmsd) = ma_align_pairwise( + ref_coords, + structures[i].ca_coordinates, + ) let aligned = apply_rotation(structures[i].ca_coordinates, rotation) aligned_all.push(aligned) if rmsd > max_rmsd { @@ -906,7 +1006,9 @@ pub fn align_multiple( if n == 1 { let ids : Array[String] = [structures[0].structure_id] let seqs : Array[String] = [structures[0].sequence] - let coords : Array[Array[(Double, Double, Double)]] = [structures[0].ca_coordinates.copy()] + let coords : Array[Array[(Double, Double, Double)]] = [ + structures[0].ca_coordinates.copy(), + ] let rmsd_mat : Array[Array[Double]] = [[0.0]] let cons = build_conservation_profile(seqs) return AlignmentResult::new(ids, seqs, rmsd_mat, coords, cons, 0.0) @@ -919,7 +1021,10 @@ pub fn align_multiple( let mut max_rmsd = 0.0 let mut i = 1 while i < n { - let (rotation, rmsd) = ma_align_pairwise(ref_coords, structures[i].ca_coordinates) + let (rotation, rmsd) = ma_align_pairwise( + ref_coords, + structures[i].ca_coordinates, + ) let aligned = apply_rotation(structures[i].ca_coordinates, rotation) aligned_all.push(aligned) if rmsd > max_rmsd { @@ -937,7 +1042,10 @@ pub fn align_multiple( let mut iter_max_rmsd = 0.0 let mut j = 1 while j < n { - let (rotation, rmsd) = ma_align_pairwise(new_ref, structures[j].ca_coordinates) + let (rotation, rmsd) = ma_align_pairwise( + new_ref, + structures[j].ca_coordinates, + ) let aligned = apply_rotation(structures[j].ca_coordinates, rotation) new_aligned.push(aligned) if rmsd > iter_max_rmsd { @@ -980,7 +1088,11 @@ pub fn align_multiple( } a = a + 1 } - if count > 0 { sum / count.to_double() } else { 0.0 } + if count > 0 { + sum / count.to_double() + } else { + 0.0 + } } else { 0.0 } @@ -1014,4 +1126,4 @@ pub fn align_structures( structures : Array[StructureData], ) -> AlignmentResult { align_multiple(aligner, structures) -} \ No newline at end of file +} diff --git a/src/maf.mbt b/src/maf.mbt index 5899e372..b6d7e9d6 100644 --- a/src/maf.mbt +++ b/src/maf.mbt @@ -89,10 +89,7 @@ pub struct MAFConfig { ///| /// Default MAF configuration. pub fn MAFConfig::default() -> MAFConfig { - MAFConfig::{ - store_sequences: true, - min_score: 0.0, - } + MAFConfig::{ store_sequences: true, min_score: 0.0 } } // ============================================================================ @@ -109,14 +106,7 @@ pub fn new_maf_sequence( seq_size : Int, aligned_seq : String, ) -> MAFSequence { - MAFSequence::{ - seq_name, - start, - length, - strand, - seq_size, - aligned_seq, - } + MAFSequence::{ seq_name, start, length, strand, seq_size, aligned_seq } } ///| @@ -132,7 +122,7 @@ pub fn maf_seq_sequence(seq : MAFSequence) -> String { for i = 0; i < seq.aligned_seq.length(); i = i + 1 { let c = seq.aligned_seq.unsafe_get(i) if c.to_int() != '-'.to_int() && c.to_int() != '.'.to_int() { - result = result + seq.aligned_seq[i:i+1].to_owned() + result = result + seq.aligned_seq[i:i + 1].to_owned() } } result @@ -175,7 +165,10 @@ pub fn maf_block_add_seq(block : MAFBlock, seq : MAFSequence) -> MAFBlock { ///| /// Add a comment to the block. -pub fn maf_block_add_comment(block : MAFBlock, comment : MAFComment) -> MAFBlock { +pub fn maf_block_add_comment( + block : MAFBlock, + comment : MAFComment, +) -> MAFBlock { block.comments.push(comment) block } @@ -221,17 +214,17 @@ pub fn maf_block_percent_identity(block : MAFBlock) -> Double { if aln_len == 0 { return 0.0 } - + let mut total_matches = 0 let mut total_pairs = 0 - + for col = 0; col < aln_len; col = col + 1 { let bases = Array::new() for s = 0; s < block.sequences.length(); s = s + 1 { let seq = block.sequences[s] let c = seq.aligned_seq.unsafe_get(col) if c.to_int() != '-'.to_int() && c.to_int() != '.'.to_int() { - bases.push(seq.aligned_seq[col:col+1].to_owned()) + bases.push(seq.aligned_seq[col:col + 1].to_owned()) } } let n_bases = bases.length() @@ -246,11 +239,11 @@ pub fn maf_block_percent_identity(block : MAFBlock) -> Double { } } } - + if total_pairs == 0 { return 0.0 } - (total_matches.to_double() / total_pairs.to_double()) * 100.0 + total_matches.to_double() / total_pairs.to_double() * 100.0 } ///| @@ -346,11 +339,11 @@ pub fn parse_maf(content : String) -> MAFAliignment { let mut result = new_maf_alignment() let lines = content.split("\n").to_array() let mut current_block : MAFBlock? = None - + for i = 0; i < lines.length(); i = i + 1 { let line = lines[i].to_owned() let trimmed = trim(line) - + if trimmed.length() == 0 { // Empty line - marks end of block match current_block { @@ -363,7 +356,7 @@ pub fn parse_maf(content : String) -> MAFAliignment { } continue } - + if starts_with(trimmed, 0, "##maf") { // Header line if starts_with(trimmed, 0, "##maf version=") { @@ -380,7 +373,7 @@ pub fn parse_maf(content : String) -> MAFAliignment { } continue } - + if starts_with(trimmed, 0, "#") { // Comment line match current_block { @@ -388,13 +381,11 @@ pub fn parse_maf(content : String) -> MAFAliignment { let comment = MAFComment::{ key: trimmed } current_block = Some(maf_block_add_comment(block, comment)) } - None => { - result.comments.push(trimmed) - } + None => result.comments.push(trimmed) } continue } - + if starts_with(trimmed, 0, "a ") { // Block attributes line current_block = Some(new_maf_block()) @@ -425,7 +416,7 @@ pub fn parse_maf(content : String) -> MAFAliignment { } continue } - + if starts_with(trimmed, 0, "s ") || starts_with(trimmed, 0, "s\t") { // Sequence line if current_block is None { @@ -442,17 +433,17 @@ pub fn parse_maf(content : String) -> MAFAliignment { let strand = parts[4] let seq_size = parse_int(parts[5]) let aligned_seq = if parts.length() >= 7 { parts[6] } else { "" } - let seq = new_maf_sequence(seq_name, start, length, strand, seq_size, aligned_seq) + let seq = new_maf_sequence( + seq_name, start, length, strand, seq_size, aligned_seq, + ) match current_block { - Some(block) => { - current_block = Some(maf_block_add_seq(block, seq)) - } + Some(block) => current_block = Some(maf_block_add_seq(block, seq)) None => () } } continue } - + if starts_with(trimmed, 0, "e ") { // Event line if current_block is None { @@ -464,22 +455,15 @@ pub fn parse_maf(content : String) -> MAFAliignment { let seq_name = parts[2] let position = if parts.length() >= 4 { parse_int(parts[3]) } else { 0 } let description = if parts.length() >= 5 { parts[4] } else { "" } - let event = MAFEvent::{ - event_type, - seq_name, - position, - description, - } + let event = MAFEvent::{ event_type, seq_name, position, description } match current_block { - Some(block) => { - current_block = Some(maf_block_add_event(block, event)) - } + Some(block) => current_block = Some(maf_block_add_event(block, event)) None => () } } continue } - + if starts_with(trimmed, 0, "b ") { // Block info line (marks start of new block with boundary info) match current_block { @@ -493,7 +477,7 @@ pub fn parse_maf(content : String) -> MAFAliignment { continue } } - + // Add final block if exists match current_block { Some(block) => { @@ -502,7 +486,7 @@ pub fn parse_maf(content : String) -> MAFAliignment { } None => () } - + result } @@ -514,7 +498,7 @@ pub fn parse_maf(content : String) -> MAFAliignment { /// Write a MAFAliignment to a MAF-formatted string. pub fn write_maf(ali : MAFAliignment) -> String { let mut result = "" - + // Write header result = result + "##maf version=" result = result + ali.version @@ -526,13 +510,13 @@ pub fn write_maf(ali : MAFAliignment) -> String { None => () } result = result + "\n\n" - + // Write top-level comments for c = 0; c < ali.comments.length(); c = c + 1 { result = result + ali.comments[c] result = result + "\n" } - + // Write blocks for b = 0; b < ali.blocks.length(); b = b + 1 { let block = ali.blocks[b] @@ -554,7 +538,7 @@ pub fn write_maf(ali : MAFAliignment) -> String { result = result + block.attributes[key] } result = result + "\n" - + // Write sequences for s = 0; s < block.sequences.length(); s = s + 1 { let seq = block.sequences[s] @@ -572,13 +556,13 @@ pub fn write_maf(ali : MAFAliignment) -> String { result = result + seq.aligned_seq result = result + "\n" } - + // Write comments for c = 0; c < block.comments.length(); c = c + 1 { result = result + block.comments[c].key result = result + "\n" } - + // Write events for e = 0; e < block.events.length(); e = e + 1 { let event = block.events[e] @@ -594,10 +578,10 @@ pub fn write_maf(ali : MAFAliignment) -> String { } result = result + "\n" } - + result = result + "\n" } - + result } @@ -607,12 +591,15 @@ pub fn write_maf(ali : MAFAliignment) -> String { ///| /// Select sequences by name and create a new alignment. -pub fn maf_select_seqs(ali : MAFAliignment, names : Array[String]) -> MAFAliignment { +pub fn maf_select_seqs( + ali : MAFAliignment, + names : Array[String], +) -> MAFAliignment { let mut result = new_maf_alignment() result.version = ali.version result.score = ali.score result.comments = ali.comments - + for b = 0; b < ali.blocks.length(); b = b + 1 { let block = ali.blocks[b] let mut new_block = new_maf_block() @@ -621,30 +608,33 @@ pub fn maf_select_seqs(ali : MAFAliignment, names : Array[String]) -> MAFAliignm new_block.events = block.events new_block.comments = block.comments new_block.is_complete = block.is_complete - + for s = 0; s < block.sequences.length(); s = s + 1 { let seq = block.sequences[s] if names.contains(seq.seq_name) { new_block = maf_block_add_seq(new_block, seq) } } - + if new_block.sequences.length() > 0 { result = maf_add_block(result, new_block) } } - + result } ///| /// Filter blocks by minimum alignment length. -pub fn maf_filter_by_length(ali : MAFAliignment, min_length : Int) -> MAFAliignment { +pub fn maf_filter_by_length( + ali : MAFAliignment, + min_length : Int, +) -> MAFAliignment { let mut result = new_maf_alignment() result.version = ali.version result.score = ali.score result.comments = ali.comments - + for b = 0; b < ali.blocks.length(); b = b + 1 { let block = ali.blocks[b] let aln_len = maf_block_alignment_length(block) @@ -652,18 +642,21 @@ pub fn maf_filter_by_length(ali : MAFAliignment, min_length : Int) -> MAFAliignm result = maf_add_block(result, block) } } - + result } ///| /// Filter blocks by minimum percent identity. -pub fn maf_filter_by_identity(ali : MAFAliignment, min_identity : Double) -> MAFAliignment { +pub fn maf_filter_by_identity( + ali : MAFAliignment, + min_identity : Double, +) -> MAFAliignment { let mut result = new_maf_alignment() result.version = ali.version result.score = ali.score result.comments = ali.comments - + for b = 0; b < ali.blocks.length(); b = b + 1 { let block = ali.blocks[b] let identity = maf_block_percent_identity(block) @@ -671,7 +664,7 @@ pub fn maf_filter_by_identity(ali : MAFAliignment, min_identity : Double) -> MAF result = maf_add_block(result, block) } } - + result } @@ -681,29 +674,29 @@ pub fn maf_merge_blocks(ali : MAFAliignment) -> MAFAliignment { if ali.blocks.length() <= 1 { return ali } - + let mut result = new_maf_alignment() result.version = ali.version result.score = ali.score result.comments = ali.comments - + let mut current_block = ali.blocks[0] - + for i = 1; i < ali.blocks.length(); i = i + 1 { let block = ali.blocks[i] - + // Check if blocks have the same sequences let same_seqs = current_block.sequences.length() == block.sequences.length() - let can_merge = same_seqs && - current_block.events.length() == 0 && + let can_merge = same_seqs && + current_block.events.length() == 0 && block.events.length() == 0 - + if can_merge { // Merge: concatenate sequences let mut new_block = new_maf_block() new_block.score = current_block.score new_block.attributes = current_block.attributes - + for j = 0; j < current_block.sequences.length(); j = j + 1 { let seq1 = current_block.sequences[j] let seq2 = block.sequences[j] @@ -717,14 +710,14 @@ pub fn maf_merge_blocks(ali : MAFAliignment) -> MAFAliignment { ) new_block = maf_block_add_seq(new_block, merged_seq) } - + current_block = new_block } else { result = maf_add_block(result, current_block) current_block = block } } - + result = maf_add_block(result, current_block) result } @@ -734,12 +727,12 @@ pub fn maf_merge_blocks(ali : MAFAliignment) -> MAFAliignment { pub fn maf_sequence_coverage(ali : MAFAliignment) -> Map[String, Double] { let coverage = Map([], capacity=10) let seq_names = maf_all_seq_names(ali) - + for n = 0; n < seq_names.length(); n = n + 1 { let name = seq_names[n] let mut total_alignment = 0.0 let mut total_length = 0.0 - + for b = 0; b < ali.blocks.length(); b = b + 1 { let block = ali.blocks[b] for s = 0; s < block.sequences.length(); s = s + 1 { @@ -750,14 +743,14 @@ pub fn maf_sequence_coverage(ali : MAFAliignment) -> Map[String, Double] { } } } - + if total_length > 0.0 { - coverage[name] = (total_alignment / total_length) * 100.0 + coverage[name] = total_alignment / total_length * 100.0 } else { coverage[name] = 0.0 } } - + coverage } @@ -785,23 +778,31 @@ pub fn maf_compute_stats(ali : MAFAliignment) -> MAFStats { let total_length = maf_total_length(ali) let num_sequences = maf_all_seq_names(ali).length() let avg_percent_identity = maf_average_percent_identity(ali) - + let mut total_coverage = 0.0 let lengths = Array::new() let mut min_len = 99999999 let mut max_len = 0 - + for b = 0; b < ali.blocks.length(); b = b + 1 { let block = ali.blocks[b] total_coverage = total_coverage + maf_block_coverage(block) let blen = maf_block_alignment_length(block) lengths.push(blen) - if blen < min_len { min_len = blen } - if blen > max_len { max_len = blen } + if blen < min_len { + min_len = blen + } + if blen > max_len { + max_len = blen + } } - - let avg_block_coverage = if num_blocks > 0 { total_coverage / num_blocks.to_double() } else { 0.0 } - + + let avg_block_coverage = if num_blocks > 0 { + total_coverage / num_blocks.to_double() + } else { + 0.0 + } + // Calculate median lengths.sort() let median = if lengths.length() > 0 { @@ -814,14 +815,18 @@ pub fn maf_compute_stats(ali : MAFAliignment) -> MAFStats { } else { 0.0 } - + MAFStats::{ num_blocks, total_length, num_sequences, avg_percent_identity, avg_block_coverage, - min_block_length: if min_len == 99999999 { 0 } else { min_len }, + min_block_length: if min_len == 99999999 { + 0 + } else { + min_len + }, max_block_length: max_len, median_block_length: median, } diff --git a/src/maftools.mbt b/src/maftools.mbt index e095e64f..64859fd7 100644 --- a/src/maftools.mbt +++ b/src/maftools.mbt @@ -73,7 +73,7 @@ pub fn MAFMutation::new( reference_allele : String, tumor_seq_allele1 : String, tumor_sample_barcode : String, - variant_classification : String + variant_classification : String, ) -> MAFMutation { MAFMutation::{ hugo_symbol, @@ -83,7 +83,7 @@ pub fn MAFMutation::new( reference_allele, tumor_seq_allele1, tumor_sample_barcode, - variant_classification + variant_classification, } } @@ -138,7 +138,7 @@ pub fn MAFData::new() -> MAFData { MAFData::{ mutations: Array::new(), sample_barcodes: Array::new(), - gene_symbols: Array::new() + gene_symbols: Array::new(), } } @@ -146,21 +146,21 @@ pub fn MAFData::new() -> MAFData { pub fn MAFData::add_mutation(self : MAFData, mutation : MAFMutation) -> MAFData { let new_mutations = self.mutations new_mutations.push(mutation) - + let new_samples = self.sample_barcodes if !maftools_contains_string(new_samples, mutation.tumor_sample_barcode) { new_samples.push(mutation.tumor_sample_barcode) } - + let new_genes = self.gene_symbols if !maftools_contains_string(new_genes, mutation.hugo_symbol) { new_genes.push(mutation.hugo_symbol) } - + MAFData::{ mutations: new_mutations, sample_barcodes: new_samples, - gene_symbols: new_genes + gene_symbols: new_genes, } } @@ -190,23 +190,26 @@ pub fn MAFData::filter_genes(self : MAFData, genes : Array[String]) -> MAFData { } i = i + 1 } - + let new_genes : Array[String] = Array::new() let mut j = 0 while j < genes.length() { new_genes.push(genes[j]) j = j + 1 } - + MAFData::{ mutations: filtered, sample_barcodes: self.sample_barcodes, - gene_symbols: new_genes + gene_symbols: new_genes, } } ///| -pub fn MAFData::filter_samples(self : MAFData, samples : Array[String]) -> MAFData { +pub fn MAFData::filter_samples( + self : MAFData, + samples : Array[String], +) -> MAFData { let filtered : Array[MAFMutation] = Array::new() let mut i = 0 while i < self.mutations.length() { @@ -216,37 +219,42 @@ pub fn MAFData::filter_samples(self : MAFData, samples : Array[String]) -> MAFDa } i = i + 1 } - + let new_samples : Array[String] = Array::new() let mut j = 0 while j < samples.length() { new_samples.push(samples[j]) j = j + 1 } - + MAFData::{ mutations: filtered, sample_barcodes: new_samples, - gene_symbols: self.gene_symbols + gene_symbols: self.gene_symbols, } } ///| -pub fn MAFData::filter_variant_type(self : MAFData, variant_type : String) -> MAFData { +pub fn MAFData::filter_variant_type( + self : MAFData, + variant_type : String, +) -> MAFData { let filtered : Array[MAFMutation] = Array::new() let mut i = 0 while i < self.mutations.length() { let mutation = self.mutations[i] - if mutation.variant_classification.to_upper().contains(variant_type.to_upper()) { + if mutation.variant_classification + .to_upper() + .contains(variant_type.to_upper()) { filtered.push(mutation) } i = i + 1 } - + MAFData::{ mutations: filtered, sample_barcodes: self.sample_barcodes, - gene_symbols: self.gene_symbols + gene_symbols: self.gene_symbols, } } @@ -298,13 +306,13 @@ pub fn get_sample_mutation_counts(maf : MAFData) -> Map[String, Int] { pub fn calculate_mutation_spectrum(maf : MAFData) -> MutationSpectrum { let transitions : Array[String] = ["A>G", "G>A", "C>T", "T>C"] let transversions : Array[String] = ["A>C", "A>T", "C>A", "C>G", "G>C", "G>T"] - + let mut snv_count = 0 let mut indel_count = 0 let mut complex_count = 0 let mut transition_count = 0 let mut transversion_count = 0 - + let mut i = 0 while i < maf.mutations.length() { let mutation = maf.mutations[i] @@ -322,7 +330,7 @@ pub fn calculate_mutation_spectrum(maf : MAFData) -> MutationSpectrum { } i = i + 1 } - + MutationSpectrum::{ snv_count, indel_count, @@ -330,7 +338,7 @@ pub fn calculate_mutation_spectrum(maf : MAFData) -> MutationSpectrum { transitions, transversions, transition_count, - transversion_count + transversion_count, } } @@ -339,7 +347,7 @@ pub fn calculate_tmb(maf : MAFData, coding_region_size : Double) -> TMBResult { let mutations = maf.mutations let mut total_mutations = 0 let per_sample_tmb : Map[String, Double] = Map([], capacity=0) - + let mut i = 0 while i < mutations.length() { let mutation = mutations[i] @@ -351,7 +359,7 @@ pub fn calculate_tmb(maf : MAFData, coding_region_size : Double) -> TMBResult { } i = i + 1 } - + let result_map : Map[String, Double] = Map([], capacity=0) let sample_barcodes = maf.sample_barcodes let mut j = 0 @@ -362,14 +370,14 @@ pub fn calculate_tmb(maf : MAFData, coding_region_size : Double) -> TMBResult { result_map.set(sample, sample_tmb) j = j + 1 } - + let tmb = total_mutations.to_double() / coding_region_size - + TMBResult::{ tmb, coding_region_size, total_mutations, - per_sample_tmb: result_map + per_sample_tmb: result_map, } } @@ -378,45 +386,49 @@ pub fn generate_oncoplot_data(maf : MAFData, top_n : Int) -> OncoplotData { let gene_counts = get_gene_mutation_counts(maf) let sorted_genes = maftools_sort_by_count_desc(gene_counts, top_n) let samples = maf.sample_barcodes - + let mutation_matrix : Array[Array[String]] = Array::new() - + let mut i = 0 while i < sorted_genes.length() { let gene = sorted_genes[i] let row : Array[String] = Array::new() let mut j = 0 while j < samples.length() { - let mutation_type = maftools_get_mutation_type_for_sample_gene(maf, samples[j], gene) + let mutation_type = maftools_get_mutation_type_for_sample_gene( + maf, + samples[j], + gene, + ) row.push(mutation_type) j = j + 1 } mutation_matrix.push(row) i = i + 1 } - - OncoplotData::{ - genes: sorted_genes, - samples, - mutation_matrix - } + + OncoplotData::{ genes: sorted_genes, samples, mutation_matrix } } ///| -pub fn analyze_co_occurrence(maf : MAFData, gene1 : String, gene2 : String) -> CoOccurrenceResult { +pub fn analyze_co_occurrence( + maf : MAFData, + gene1 : String, + gene2 : String, +) -> CoOccurrenceResult { let samples1 = maftools_get_samples_with_gene(maf, gene1) let samples2 = maftools_get_samples_with_gene(maf, gene2) - + let mut co_occurrence = 0 let mut mutual_exclusivity = 0 - + let all_samples = maf.sample_barcodes let mut i = 0 while i < all_samples.length() { let sample = all_samples[i] let has_gene1 = maftools_contains_string(samples1, sample) let has_gene2 = maftools_contains_string(samples2, sample) - + if has_gene1 && has_gene2 { co_occurrence = co_occurrence + 1 } else if has_gene1 != has_gene2 { @@ -424,47 +436,47 @@ pub fn analyze_co_occurrence(maf : MAFData, gene1 : String, gene2 : String) -> C } i = i + 1 } - + let total = all_samples.length().to_double() let p_value = if total > 0.0 { - 1.0 - (co_occurrence.to_double() / total) + 1.0 - co_occurrence.to_double() / total } else { 1.0 } - + CoOccurrenceResult::{ pair: (gene1, gene2), co_occurrence, mutual_exclusivity, - p_value + p_value, } } ///| -pub fn decompose_mutational_signatures(maf : MAFData, reference_signatures : Array[MutationalSignature]) -> Array[MutationalSignature] { +pub fn decompose_mutational_signatures( + maf : MAFData, + reference_signatures : Array[MutationalSignature], +) -> Array[MutationalSignature] { if reference_signatures.length() == 0 { return Array::new() } - + let spectrum = calculate_mutation_spectrum(maf) let total_mutations = spectrum.snv_count.to_double() - + if total_mutations == 0.0 { return Array::new() } - + let results : Array[MutationalSignature] = Array::new() let mut i = 0 while i < reference_signatures.length() { let sig = reference_signatures[i] let contribution = sig.contribution * total_mutations - results.push(MutationalSignature::{ - name: sig.name, - contribution - }) + results.push(MutationalSignature::{ name: sig.name, contribution }) i = i + 1 } - + results } @@ -472,59 +484,92 @@ pub fn decompose_mutational_signatures(maf : MAFData, reference_signatures : Arr pub fn summarize_maf(maf : MAFData) -> String { let mut summary = "\nMAF Summary\n" summary = summary + "==============================\n" - summary = summary + "Total mutations: " + maf.count_mutations().to_string() + "\n" - summary = summary + "Total genes: " + maf.count_unique_genes().to_string() + "\n" - summary = summary + "Total samples: " + maf.count_unique_samples().to_string() + "\n" - + summary = summary + + "Total mutations: " + + maf.count_mutations().to_string() + + "\n" + summary = summary + + "Total genes: " + + maf.count_unique_genes().to_string() + + "\n" + summary = summary + + "Total samples: " + + maf.count_unique_samples().to_string() + + "\n" + let spectrum = calculate_mutation_spectrum(maf) summary = summary + "SNVs: " + spectrum.snv_count.to_string() + "\n" summary = summary + "Indels: " + spectrum.indel_count.to_string() + "\n" summary = summary + "Complex: " + spectrum.complex_count.to_string() + "\n" - + let tmb = calculate_tmb(maf, 3.0e7) summary = summary + "TMB: " + tmb.tmb.to_string() + " mut/Mb\n" - + summary } ///| pub fn create_example_maf() -> MAFData { let mut maf = MAFData::new() - - let genes = ["TP53", "BRCA1", "EGFR", "KRAS", "MYC", "PTEN", "APC", "RB1", "VHL", "NF1"] - let samples = ["Sample1", "Sample2", "Sample3", "Sample4", "Sample5", "Sample6", "Sample7", "Sample8"] - let variants = ["Missense_Mutation", "Nonsense_Mutation", "Frame_Shift_Ins", "Frame_Shift_Del", "Splice_Site"] - + + let genes = [ + "TP53", "BRCA1", "EGFR", "KRAS", "MYC", "PTEN", "APC", "RB1", "VHL", "NF1", + ] + let samples = [ + "Sample1", "Sample2", "Sample3", "Sample4", "Sample5", "Sample6", "Sample7", + "Sample8", + ] + let variants = [ + "Missense_Mutation", "Nonsense_Mutation", "Frame_Shift_Ins", "Frame_Shift_Del", + "Splice_Site", + ] + let mut i = 0 while i < 80 { let gene_idx = i % 10 let sample_idx = i % 8 let variant_idx = i % 5 let pos = 1000000 + i * 10000 - + let mutation = MAFMutation::new( genes[gene_idx], - "chr" + ((i % 22) + 1).to_string(), + "chr" + (i % 22 + 1).to_string(), pos, pos, - if i % 3 == 0 { "A" } else { if i % 3 == 1 { "C" } else { "G" } }, - if i % 2 == 0 { "T" } else { if i % 3 == 0 { "A" } else { "C" } }, + if i % 3 == 0 { + "A" + } else if i % 3 == 1 { + "C" + } else { + "G" + }, + if i % 2 == 0 { + "T" + } else if i % 3 == 0 { + "A" + } else { + "C" + }, samples[sample_idx], - variants[variant_idx] + variants[variant_idx], ) - + maf = maf.add_mutation(mutation) i = i + 1 } - + maf } ///| pub fn parse_maf_content(content : String) -> MAFData { let lines = split_by_char(content, '\n'.to_int()) - let header = if lines.length() > 0 { split_by_char(lines[0], '\t'.to_int()) } else { Array::new() } - + let header = if lines.length() > 0 { + split_by_char(lines[0], '\t'.to_int()) + } else { + Array::new() + } + let hugo_idx = maftools_find_column_index(header, "Hugo_Symbol") let chrom_idx = maftools_find_column_index(header, "Chromosome") let start_idx = maftools_find_column_index(header, "Start_Position") @@ -533,7 +578,7 @@ pub fn parse_maf_content(content : String) -> MAFData { let alt_idx = maftools_find_column_index(header, "Tumor_Seq_Allele1") let sample_idx = maftools_find_column_index(header, "Tumor_Sample_Barcode") let variant_idx = maftools_find_column_index(header, "Variant_Classification") - + let mut maf = MAFData::new() let mut i = 1 while i < lines.length() { @@ -542,26 +587,59 @@ pub fn parse_maf_content(content : String) -> MAFData { let fields = split_by_char(line, '\t'.to_int()) if fields.length() >= 8 { let mutation = MAFMutation::new( - if hugo_idx >= 0 { fields[hugo_idx] } else { "" }, - if chrom_idx >= 0 { fields[chrom_idx] } else { "" }, - if start_idx >= 0 { maftools_parse_int(fields[start_idx]) } else { 0 }, - if end_idx >= 0 { maftools_parse_int(fields[end_idx]) } else { 0 }, - if ref_idx >= 0 { fields[ref_idx] } else { "" }, - if alt_idx >= 0 { fields[alt_idx] } else { "" }, - if sample_idx >= 0 { fields[sample_idx] } else { "" }, - if variant_idx >= 0 { fields[variant_idx] } else { "" } + if hugo_idx >= 0 { + fields[hugo_idx] + } else { + "" + }, + if chrom_idx >= 0 { + fields[chrom_idx] + } else { + "" + }, + if start_idx >= 0 { + maftools_parse_int(fields[start_idx]) + } else { + 0 + }, + if end_idx >= 0 { + maftools_parse_int(fields[end_idx]) + } else { + 0 + }, + if ref_idx >= 0 { + fields[ref_idx] + } else { + "" + }, + if alt_idx >= 0 { + fields[alt_idx] + } else { + "" + }, + if sample_idx >= 0 { + fields[sample_idx] + } else { + "" + }, + if variant_idx >= 0 { + fields[variant_idx] + } else { + "" + }, ) maf = maf.add_mutation(mutation) } } i = i + 1 } - + maf } // Helper functions +///| fn maftools_contains_string(arr : Array[String], value : String) -> Bool { let mut i = 0 while i < arr.length() { @@ -573,7 +651,11 @@ fn maftools_contains_string(arr : Array[String], value : String) -> Bool { false } -fn maftools_find_column_index(header : Array[String], column_name : String) -> Int { +///| +fn maftools_find_column_index( + header : Array[String], + column_name : String, +) -> Int { let mut i = 0 while i < header.length() { if header[i].to_upper() == column_name.to_upper() { @@ -584,21 +666,26 @@ fn maftools_find_column_index(header : Array[String], column_name : String) -> I -1 } +///| fn maftools_parse_int(s : String) -> Int { parse_int(s) } -fn maftools_sort_by_count_desc(counts : Map[String, Int], top_n : Int) -> Array[String] { +///| +fn maftools_sort_by_count_desc( + counts : Map[String, Int], + top_n : Int, +) -> Array[String] { let entries = counts.iter().collect() let sorted : Array[(String, Int)] = Array::new() - + let mut i = 0 while i < entries.length() { let (key, value) = entries[i] sorted.push((key, value)) i = i + 1 } - + // Simple bubble sort by count descending let len = sorted.length() let mut j = 0 @@ -619,7 +706,7 @@ fn maftools_sort_by_count_desc(counts : Map[String, Int], top_n : Int) -> Array[ } j = j + 1 } - + let result : Array[String] = Array::new() let count = if top_n < sorted.length() { top_n } else { sorted.length() } let mut l = 0 @@ -627,11 +714,16 @@ fn maftools_sort_by_count_desc(counts : Map[String, Int], top_n : Int) -> Array[ result.push(sorted[l].0) l = l + 1 } - + result } -fn maftools_get_mutation_type_for_sample_gene(maf : MAFData, sample : String, gene : String) -> String { +///| +fn maftools_get_mutation_type_for_sample_gene( + maf : MAFData, + sample : String, + gene : String, +) -> String { let mut i = 0 while i < maf.mutations.length() { let mutation = maf.mutations[i] @@ -643,7 +735,11 @@ fn maftools_get_mutation_type_for_sample_gene(maf : MAFData, sample : String, ge "" } -fn maftools_get_samples_with_gene(maf : MAFData, gene : String) -> Array[String] { +///| +fn maftools_get_samples_with_gene( + maf : MAFData, + gene : String, +) -> Array[String] { let samples : Array[String] = Array::new() let mut i = 0 while i < maf.mutations.length() { diff --git a/src/markov.mbt b/src/markov.mbt index 03facf3a..174b5efa 100644 --- a/src/markov.mbt +++ b/src/markov.mbt @@ -41,14 +41,17 @@ pub struct MarkovModel { pseudo_count : Double } +///| fn markov_empty_map_kv() -> Map[String, Map[String, Double]] { Map([], capacity=16) } +///| fn markov_empty_map_d() -> Map[String, Double] { Map([], capacity=16) } +///| fn markov_empty_map_u() -> Map[String, Unit] { Map([], capacity=16) } @@ -88,8 +91,8 @@ pub fn MarkovModel::default_protein() -> MarkovModel { order: 1, chain_type: FirstOrder, states: [ - "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", - "M", "N", "P", "Q", "R", "S", "T", "V", "W", "Y", + "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", "M", "N", "P", "Q", "R", + "S", "T", "V", "W", "Y", ], transition_counts: markov_empty_map_kv(), transition_probs: markov_empty_map_kv(), @@ -123,7 +126,10 @@ pub fn MarkovModel::set_order(self : MarkovModel, val : Int) -> MarkovModel { ///| /// Set states, returning new model. -pub fn MarkovModel::set_states(self : MarkovModel, states~ : Array[String]) -> MarkovModel { +pub fn MarkovModel::set_states( + self : MarkovModel, + states~ : Array[String], +) -> MarkovModel { MarkovModel::{ order: self.order, chain_type: self.chain_type, @@ -137,7 +143,10 @@ pub fn MarkovModel::set_states(self : MarkovModel, states~ : Array[String]) -> M ///| /// Set chain_type, returning new model. -pub fn MarkovModel::set_chain_type(self : MarkovModel, val~ : ChainType) -> MarkovModel { +pub fn MarkovModel::set_chain_type( + self : MarkovModel, + val~ : ChainType, +) -> MarkovModel { let ord = match val { FirstOrder => 1 SecondOrder => 2 @@ -156,7 +165,10 @@ pub fn MarkovModel::set_chain_type(self : MarkovModel, val~ : ChainType) -> Mark ///| /// Set pseudo_count, returning new model. -pub fn MarkovModel::set_pseudo_count(self : MarkovModel, val : Double) -> MarkovModel { +pub fn MarkovModel::set_pseudo_count( + self : MarkovModel, + val : Double, +) -> MarkovModel { MarkovModel::{ order: self.order, chain_type: self.chain_type, @@ -221,7 +233,10 @@ pub fn markov_build_model( if n > actual_order { let start_kmer = substring(seq, 0, actual_order) if initial_counts.contains(start_kmer) { - initial_counts.set(start_kmer, initial_counts.get(start_kmer).unwrap() + 1.0) + initial_counts.set( + start_kmer, + initial_counts.get(start_kmer).unwrap() + 1.0, + ) } else { initial_counts.set(start_kmer, 1.0) } @@ -344,14 +359,22 @@ fn markov_get_trans_prob( vi = vi + 1 } let denom = row_total + model.pseudo_count * n - if denom > 0.0 { model.pseudo_count / denom } else { 1.0 / n } + if denom > 0.0 { + model.pseudo_count / denom + } else { + 1.0 / n + } } } None => { // Completely unseen context. Use pseudo-weighted uniform: // P = pseudo / (1 + pseudo * N). Higher pseudo -> higher prob, closer to 1/N. let denom = 1.0 + model.pseudo_count * n - if denom > 0.0 { model.pseudo_count / denom } else { 1.0 / n } + if denom > 0.0 { + model.pseudo_count / denom + } else { + 1.0 / n + } } } } @@ -365,7 +388,11 @@ fn markov_get_init_prob(model : MarkovModel, kmer : String) -> Double { let n = model.initial_probs.length() if n > 0 { let denom = model.pseudo_count * (n + 1).to_double() - if denom > 0.0 { model.pseudo_count / denom } else { 1.0 / n.to_double() } + if denom > 0.0 { + model.pseudo_count / denom + } else { + 1.0 / n.to_double() + } } else { 1.0 / model.states.length().to_double() } @@ -398,7 +425,10 @@ pub fn markov_score_sequence(model : MarkovModel, sequence : String) -> Double { ///| /// Compute per-position log probabilities. -pub fn markov_score_per_base(model : MarkovModel, sequence : String) -> Array[Double] { +pub fn markov_score_per_base( + model : MarkovModel, + sequence : String, +) -> Array[Double] { let n = sequence.length() let result : Array[Double] = Array::new() if n <= model.order { @@ -435,7 +465,11 @@ fn markov_weighted_sample( } si = si + 1 } - if states.length() > 0 { states[states.length() - 1] } else { "" } + if states.length() > 0 { + states[states.length() - 1] + } else { + "" + } } ///| @@ -494,7 +528,11 @@ pub fn markov_generate_sequence( } let take = if model.order > length { length } else { model.order } - let mut result = if context.length() >= take { substring(context, 0, take) } else { context } + let mut result = if context.length() >= take { + substring(context, 0, take) + } else { + context + } let mut step = result.length() while step < length { @@ -507,7 +545,7 @@ pub fn markov_generate_sequence( let r_next = rng_state.to_double() / modulus let next_char = match model.transition_probs.get(ctx) { Some(row) => markov_weighted_sample(row, model.states, r_next) - None => { + None => if n_states > 0 { let idx_f = r_next * n_states.to_double() let idx = idx_f.to_int() @@ -517,7 +555,6 @@ pub fn markov_generate_sequence( } else { "" } - } } result = result + next_char step = step + 1 @@ -544,7 +581,9 @@ pub fn markov_log_odds( ///| /// Compute stationary distribution via iterative multiplication. -pub fn markov_stationary_distribution(model : MarkovModel) -> Map[String, Double] { +pub fn markov_stationary_distribution( + model : MarkovModel, +) -> Map[String, Double] { let states = model.states let n = states.length() let dist = markov_empty_map_d() diff --git a/src/mast_motif.mbt b/src/mast_motif.mbt index 2c031846..ecf4647e 100644 --- a/src/mast_motif.mbt +++ b/src/mast_motif.mbt @@ -227,7 +227,8 @@ pub fn mast_motif_parse(text : String) -> MastMotifRecord { for p in parts { let s = p.trim().to_string() if s.length() > 0 { - if s.starts_with("v") || (s[0:1].to_string() >= "0" && s[0:1].to_string() <= "9") { + if s.starts_with("v") || + (s[0:1].to_string() >= "0" && s[0:1].to_string() <= "9") { record.version = s } } @@ -278,9 +279,9 @@ pub fn mast_motif_parse(text : String) -> MastMotifRecord { } } // Sequence match lines (in SECTION III or similar) - if section.contains("III") || section.contains("RESULT") || section.contains( - "DETAILED", - ) { + if section.contains("III") || + section.contains("RESULT") || + section.contains("DETAILED") { // Parse sequence lines with p-values // Format: "sequence_name description length p-value e-value" let parts = trimmed.split(" ").to_array() @@ -390,7 +391,9 @@ pub fn mast_motif_record_to_string(record : MastMotifRecord) -> String { sb.write_string(" Version: " + record.version + "\n") sb.write_string(" Database: " + record.database + "\n") sb.write_string(" Motifs: " + record.motif_count.to_string() + "\n") - sb.write_string(" Sequences with hits: " + record.hit_count.to_string() + "\n") + sb.write_string( + " Sequences with hits: " + record.hit_count.to_string() + "\n", + ) sb.write_string("\nMotif summary:\n") for m in record.motifs { sb.write_string(" " + m.id + " (width=" + m.width.to_string() + ")\n") diff --git a/src/matrix.mbt b/src/matrix.mbt index f44049d1..48acc3ab 100644 --- a/src/matrix.mbt +++ b/src/matrix.mbt @@ -23,7 +23,11 @@ pub struct BiocMatrix { } ///| -pub fn BiocMatrix::new(matrix_type : BiocMatrixType, nrow : Int, ncol : Int) -> BiocMatrix { +pub fn BiocMatrix::new( + matrix_type : BiocMatrixType, + nrow : Int, + ncol : Int, +) -> BiocMatrix { BiocMatrix::{ matrix_type, nrow, @@ -31,7 +35,7 @@ pub fn BiocMatrix::new(matrix_type : BiocMatrixType, nrow : Int, ncol : Int) -> data: Array::new(), row_indices: Array::new(), col_indices: Array::new(), - ptr: Array::new() + ptr: Array::new(), } } @@ -39,7 +43,7 @@ pub fn BiocMatrix::new(matrix_type : BiocMatrixType, nrow : Int, ncol : Int) -> pub fn BiocMatrix::dense_from_array(data : Array[Array[Double]]) -> BiocMatrix { let nrow = data.length() let ncol = if nrow > 0 { data[0].length() } else { 0 } - + let flat_data : Array[Double] = Array::new() let mut i = 0 while i < nrow { @@ -50,7 +54,7 @@ pub fn BiocMatrix::dense_from_array(data : Array[Array[Double]]) -> BiocMatrix { } i = i + 1 } - + BiocMatrix::{ matrix_type: BiocDenseMatrix, nrow, @@ -58,24 +62,30 @@ pub fn BiocMatrix::dense_from_array(data : Array[Array[Double]]) -> BiocMatrix { data: flat_data, row_indices: Array::new(), col_indices: Array::new(), - ptr: Array::new() + ptr: Array::new(), } } ///| -pub fn BiocMatrix::csc_from_triplets(row_idx : Array[Int], col_idx : Array[Int], values : Array[Double], nrow : Int, ncol : Int) -> BiocMatrix { +pub fn BiocMatrix::csc_from_triplets( + row_idx : Array[Int], + col_idx : Array[Int], + values : Array[Double], + nrow : Int, + ncol : Int, +) -> BiocMatrix { let sorted_indices = sort_triplets(row_idx, col_idx, values) let sorted_rows = sorted_indices.0 let sorted_cols = sorted_indices.1 let sorted_values = sorted_indices.2 - + let ptr : Array[Int] = Array::new() ptr.push(0) - + let mut current_col = 0 let mut count = 0 let mut i = 0 - + while i < sorted_cols.length() { if sorted_cols[i] == current_col { count = count + 1 @@ -87,7 +97,7 @@ pub fn BiocMatrix::csc_from_triplets(row_idx : Array[Int], col_idx : Array[Int], i = i + 1 } ptr.push(ptr[ptr.length() - 1] + count) - + BiocMatrix::{ matrix_type: BiocSparseMatrixCSC, nrow, @@ -95,24 +105,30 @@ pub fn BiocMatrix::csc_from_triplets(row_idx : Array[Int], col_idx : Array[Int], data: sorted_values, row_indices: sorted_rows, col_indices: sorted_cols, - ptr: ptr + ptr, } } ///| -pub fn BiocMatrix::csr_from_triplets(row_idx : Array[Int], col_idx : Array[Int], values : Array[Double], nrow : Int, ncol : Int) -> BiocMatrix { +pub fn BiocMatrix::csr_from_triplets( + row_idx : Array[Int], + col_idx : Array[Int], + values : Array[Double], + nrow : Int, + ncol : Int, +) -> BiocMatrix { let sorted_indices = sort_triplets_by_row(row_idx, col_idx, values) let sorted_rows = sorted_indices.0 let sorted_cols = sorted_indices.1 let sorted_values = sorted_indices.2 - + let ptr : Array[Int] = Array::new() ptr.push(0) - + let mut current_row = 0 let mut count = 0 let mut i = 0 - + while i < sorted_rows.length() { if sorted_rows[i] == current_row { count = count + 1 @@ -124,7 +140,7 @@ pub fn BiocMatrix::csr_from_triplets(row_idx : Array[Int], col_idx : Array[Int], i = i + 1 } ptr.push(ptr[ptr.length() - 1] + count) - + BiocMatrix::{ matrix_type: BiocSparseMatrixCSR, nrow, @@ -132,12 +148,16 @@ pub fn BiocMatrix::csr_from_triplets(row_idx : Array[Int], col_idx : Array[Int], data: sorted_values, row_indices: sorted_rows, col_indices: sorted_cols, - ptr: ptr + ptr, } } ///| -fn sort_triplets(row_idx : Array[Int], col_idx : Array[Int], values : Array[Double]) -> (Array[Int], Array[Int], Array[Double]) { +fn sort_triplets( + row_idx : Array[Int], + col_idx : Array[Int], + values : Array[Double], +) -> (Array[Int], Array[Int], Array[Double]) { let n = row_idx.length() let indices : Array[Int] = Array::new() let mut i = 0 @@ -145,15 +165,18 @@ fn sort_triplets(row_idx : Array[Int], col_idx : Array[Int], values : Array[Doub indices.push(i) i = i + 1 } - + let mut sorted = false while !sorted { sorted = true i = 0 while i < n - 1 { let j = i + 1 - if col_idx[indices[i]] > col_idx[indices[j]] || - (col_idx[indices[i]] == col_idx[indices[j]] && row_idx[indices[i]] > row_idx[indices[j]]) { + if col_idx[indices[i]] > col_idx[indices[j]] || + ( + col_idx[indices[i]] == col_idx[indices[j]] && + row_idx[indices[i]] > row_idx[indices[j]] + ) { let temp = indices[i] indices[i] = indices[j] indices[j] = temp @@ -162,11 +185,11 @@ fn sort_triplets(row_idx : Array[Int], col_idx : Array[Int], values : Array[Doub i = i + 1 } } - + let sorted_rows : Array[Int] = Array::new() let sorted_cols : Array[Int] = Array::new() let sorted_values : Array[Double] = Array::new() - + i = 0 while i < n { sorted_rows.push(row_idx[indices[i]]) @@ -174,12 +197,16 @@ fn sort_triplets(row_idx : Array[Int], col_idx : Array[Int], values : Array[Doub sorted_values.push(values[indices[i]]) i = i + 1 } - + (sorted_rows, sorted_cols, sorted_values) } ///| -fn sort_triplets_by_row(row_idx : Array[Int], col_idx : Array[Int], values : Array[Double]) -> (Array[Int], Array[Int], Array[Double]) { +fn sort_triplets_by_row( + row_idx : Array[Int], + col_idx : Array[Int], + values : Array[Double], +) -> (Array[Int], Array[Int], Array[Double]) { let n = row_idx.length() let indices : Array[Int] = Array::new() let mut i = 0 @@ -187,15 +214,18 @@ fn sort_triplets_by_row(row_idx : Array[Int], col_idx : Array[Int], values : Arr indices.push(i) i = i + 1 } - + let mut sorted = false while !sorted { sorted = true i = 0 while i < n - 1 { let j = i + 1 - if row_idx[indices[i]] > row_idx[indices[j]] || - (row_idx[indices[i]] == row_idx[indices[j]] && col_idx[indices[i]] > col_idx[indices[j]]) { + if row_idx[indices[i]] > row_idx[indices[j]] || + ( + row_idx[indices[i]] == row_idx[indices[j]] && + col_idx[indices[i]] > col_idx[indices[j]] + ) { let temp = indices[i] indices[i] = indices[j] indices[j] = temp @@ -204,11 +234,11 @@ fn sort_triplets_by_row(row_idx : Array[Int], col_idx : Array[Int], values : Arr i = i + 1 } } - + let sorted_rows : Array[Int] = Array::new() let sorted_cols : Array[Int] = Array::new() let sorted_values : Array[Double] = Array::new() - + i = 0 while i < n { sorted_rows.push(row_idx[indices[i]]) @@ -216,7 +246,7 @@ fn sort_triplets_by_row(row_idx : Array[Int], col_idx : Array[Int], values : Arr sorted_values.push(values[indices[i]]) i = i + 1 } - + (sorted_rows, sorted_cols, sorted_values) } @@ -225,7 +255,7 @@ pub fn BiocMatrix::get(self : BiocMatrix, i : Int, j : Int) -> Double { if i < 0 || i >= self.nrow || j < 0 || j >= self.ncol { return 0.0 } - + match self.matrix_type { BiocDenseMatrix => { let idx = i * self.ncol + j @@ -259,22 +289,26 @@ pub fn BiocMatrix::get(self : BiocMatrix, i : Int, j : Int) -> Double { } 0.0 } - BiocDiagonalMatrix => { + BiocDiagonalMatrix => if i == j && i < self.data.length() { self.data[i] } else { 0.0 } - } } } ///| -pub fn BiocMatrix::set(self : BiocMatrix, i : Int, j : Int, value : Double) -> BiocMatrix { +pub fn BiocMatrix::set( + self : BiocMatrix, + i : Int, + j : Int, + value : Double, +) -> BiocMatrix { if i < 0 || i >= self.nrow || j < 0 || j >= self.ncol { return self } - + match self.matrix_type { BiocDenseMatrix => { let idx = i * self.ncol + j @@ -289,7 +323,7 @@ pub fn BiocMatrix::set(self : BiocMatrix, i : Int, j : Int, value : Double) -> B data: new_data, row_indices: self.row_indices, col_indices: self.col_indices, - ptr: self.ptr + ptr: self.ptr, } } _ => self @@ -314,12 +348,22 @@ pub fn BiocMatrix::transpose(self : BiocMatrix) -> BiocMatrix { } BiocMatrix::dense_from_array(result_data) } - BiocSparseMatrixCSC => { - BiocMatrix::csr_from_triplets(self.col_indices, self.row_indices, self.data, self.ncol, self.nrow) - } - BiocSparseMatrixCSR => { - BiocMatrix::csc_from_triplets(self.col_indices, self.row_indices, self.data, self.ncol, self.nrow) - } + BiocSparseMatrixCSC => + BiocMatrix::csr_from_triplets( + self.col_indices, + self.row_indices, + self.data, + self.ncol, + self.nrow, + ) + BiocSparseMatrixCSR => + BiocMatrix::csc_from_triplets( + self.col_indices, + self.row_indices, + self.data, + self.ncol, + self.nrow, + ) BiocDiagonalMatrix => self } } @@ -329,7 +373,7 @@ pub fn BiocMatrix::add(self : BiocMatrix, other : BiocMatrix) -> BiocMatrix? { if self.nrow != other.nrow || self.ncol != other.ncol { return None } - + let result_data : Array[Array[Double]] = Array::new() let mut i = 0 while i < self.nrow { @@ -342,16 +386,19 @@ pub fn BiocMatrix::add(self : BiocMatrix, other : BiocMatrix) -> BiocMatrix? { result_data.push(row) i = i + 1 } - + Some(BiocMatrix::dense_from_array(result_data)) } ///| -pub fn BiocMatrix::multiply(self : BiocMatrix, other : BiocMatrix) -> BiocMatrix? { +pub fn BiocMatrix::multiply( + self : BiocMatrix, + other : BiocMatrix, +) -> BiocMatrix? { if self.ncol != other.nrow { return None } - + let result_data : Array[Array[Double]] = Array::new() let mut i = 0 while i < self.nrow { @@ -370,7 +417,7 @@ pub fn BiocMatrix::multiply(self : BiocMatrix, other : BiocMatrix) -> BiocMatrix result_data.push(row) i = i + 1 } - + Some(BiocMatrix::dense_from_array(result_data)) } @@ -435,7 +482,7 @@ pub fn BiocMatrix::col_means(self : BiocMatrix) -> Array[Double] { ///| pub fn BiocMatrix::norm(self : BiocMatrix, p : Double) -> Double { let mut sum = 0.0 - + match self.matrix_type { BiocDenseMatrix => { let mut i = 0 @@ -459,7 +506,7 @@ pub fn BiocMatrix::norm(self : BiocMatrix, p : Double) -> Double { } } } - + @math.pow(sum, 1.0 / p) } @@ -488,7 +535,7 @@ pub fn create_example_dense_matrix() -> BiocMatrix { BiocMatrix::dense_from_array([ [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], - [7.0, 8.0, 9.0] + [7.0, 8.0, 9.0], ]) } @@ -499,6 +546,6 @@ pub fn create_example_sparse_matrix() -> BiocMatrix { [0, 0, 0, 1, 1, 1], [1.0, 4.0, 7.0, 2.0, 5.0, 8.0], 3, - 2 + 2, ) } diff --git a/src/matrix_generics.mbt b/src/matrix_generics.mbt index 9194c6f6..fa81e0a8 100644 --- a/src/matrix_generics.mbt +++ b/src/matrix_generics.mbt @@ -432,7 +432,11 @@ pub fn mg_block_apply_rows( let result : Array[Double] = Array::make(n_rows, 0.0) let mut start = 0 while start < n_rows { - let end = if start + block_size < n_rows { start + block_size } else { n_rows } + let end = if start + block_size < n_rows { + start + block_size + } else { + n_rows + } let block_data : Array[Array[Double]] = [] let mut i = start while i < end { @@ -469,7 +473,11 @@ pub fn mg_block_apply_cols( let result : Array[Double] = Array::make(n_cols, 0.0) let mut start = 0 while start < n_cols { - let end = if start + block_size < n_cols { start + block_size } else { n_cols } + let end = if start + block_size < n_cols { + start + block_size + } else { + n_cols + } let block_data : Array[Array[Double]] = [] let mut i = 0 while i < n_rows { diff --git a/src/mauve.mbt b/src/mauve.mbt index 00b54ed4..35086e82 100644 --- a/src/mauve.mbt +++ b/src/mauve.mbt @@ -153,7 +153,7 @@ pub fn mauve_seq_coverage(seq : MauveSequence) -> Double { if seq.seq_size == 0 { return 0.0 } - (seq.length.to_double() / seq.seq_size.to_double()) * 100.0 + seq.length.to_double() / seq.seq_size.to_double() * 100.0 } // ============================================================================ @@ -163,12 +163,7 @@ pub fn mauve_seq_coverage(seq : MauveSequence) -> Double { ///| /// Create a new empty MauveLCB. pub fn new_mauve_lcb(id : String) -> MauveLCB { - MauveLCB::{ - id, - score: 0.0, - sequences: Array::new(), - is_collinear: true, - } + MauveLCB::{ id, score: 0.0, sequences: Array::new(), is_collinear: true } } ///| @@ -261,7 +256,10 @@ pub fn mauve_all_seq_names(ali : MauveAlignment) -> Array[String] { ///| /// Get sequences for a specific genome. -pub fn mauve_get_genome_seqs(ali : MauveAlignment, genome_name : String) -> Array[MauveSequence] { +pub fn mauve_get_genome_seqs( + ali : MauveAlignment, + genome_name : String, +) -> Array[MauveSequence] { let seqs = Array::new() let prefix_len = genome_name.length() for l = 0; l < ali.lcbs.length(); l = l + 1 { @@ -292,11 +290,11 @@ pub fn parse_mauve(content : String) -> MauveAlignment { let lines = content.split("\n").to_array() let mut current_lcb : MauveLCB? = None let mut lcb_counter = 0 - + for i = 0; i < lines.length(); i = i + 1 { let line = lines[i].to_owned() let trimmed = trim(line) - + if trimmed.length() == 0 { match current_lcb { Some(lcb) => { @@ -308,25 +306,28 @@ pub fn parse_mauve(content : String) -> MauveAlignment { } continue } - + if starts_with(trimmed, 0, "##maf") || starts_with(trimmed, 0, "##mauve") { if contains(trimmed, "version=") { let parts = split_by_char(trimmed, ' '.to_int()) for p = 0; p < parts.length(); p = p + 1 { let part = parts[p] if starts_with(part, 0, "version=") { - result = MauveAlignment::{ ..result, version: part[8:part.length()].to_owned() } + result = MauveAlignment::{ + ..result, + version: part[8:part.length()].to_owned(), + } } } } continue } - + if starts_with(trimmed, 0, "a ") { lcb_counter = lcb_counter + 1 let lcb_id = "" + "lcb_" + lcb_counter.to_string() current_lcb = Some(new_mauve_lcb(lcb_id)) - + let parts = split_by_char(trimmed, ' '.to_int()) for p = 0; p < parts.length(); p = p + 1 { let part = parts[p] @@ -334,8 +335,12 @@ pub fn parse_mauve(content : String) -> MauveAlignment { let score_val = parse_double(part[6:part.length()].to_owned()) match current_lcb { Some(lcb) => { - let score = if score_val is Some(_) { score_val.unwrap() } else { 0.0 } - let new_lcb = MauveLCB::{ ..lcb, score: score } + let score = if score_val is Some(_) { + score_val.unwrap() + } else { + 0.0 + } + let new_lcb = MauveLCB::{ ..lcb, score, } current_lcb = Some(new_lcb) ignore(()) } @@ -345,7 +350,10 @@ pub fn parse_mauve(content : String) -> MauveAlignment { let val = part[10:part.length()].to_owned() match current_lcb { Some(lcb) => { - let new_lcb = MauveLCB::{ ..lcb, is_collinear: val == "yes" || val == "1" } + let new_lcb = MauveLCB::{ + ..lcb, + is_collinear: val == "yes" || val == "1", + } current_lcb = Some(new_lcb) ignore(()) } @@ -355,13 +363,13 @@ pub fn parse_mauve(content : String) -> MauveAlignment { } continue } - + if starts_with(trimmed, 0, "s ") || starts_with(trimmed, 0, "s\t") { if current_lcb is None { lcb_counter = lcb_counter + 1 current_lcb = Some(new_mauve_lcb("lcb_" + lcb_counter.to_string())) } - + let mut parts = split_by_tab(trimmed) if parts.length() < 6 { parts = split_by_char(trimmed, ' '.to_int()) @@ -373,7 +381,7 @@ pub fn parse_mauve(content : String) -> MauveAlignment { let strand = parts[4] let seq_size = parse_int(parts[5]) let end = start + length - + let seq = new_mauve_sequence(name, start, end, strand, seq_size) match current_lcb { Some(lcb) => { @@ -386,7 +394,7 @@ pub fn parse_mauve(content : String) -> MauveAlignment { } continue } - + if starts_with(trimmed, 0, "g ") { let parts = split_by_char(trimmed, ' '.to_int()) if parts.length() >= 3 { @@ -405,7 +413,7 @@ pub fn parse_mauve(content : String) -> MauveAlignment { continue } } - + match current_lcb { Some(lcb) => { result.lcbs.push(lcb) @@ -413,10 +421,10 @@ pub fn parse_mauve(content : String) -> MauveAlignment { } None => ignore(()) } - + result = detect_mauve_inversions(result) result = detect_mauve_breakpoints(result) - + result } @@ -429,41 +437,51 @@ pub fn parse_mauve(content : String) -> MauveAlignment { pub fn detect_mauve_inversions(ali : MauveAlignment) -> MauveAlignment { let result = ali let seq_names = mauve_all_seq_names(result) - + for n = 0; n < seq_names.length(); n = n + 1 { let name = seq_names[n] let seqs = mauve_get_genome_seqs(result, name) if seqs.length() < 2 { continue } - + for i = 1; i < seqs.length(); i = i + 1 { let prev = seqs[i - 1] let curr = seqs[i] - + if prev.strand != curr.strand { - let inv_start = if prev.start < curr.start { prev.start } else { curr.start } + let inv_start = if prev.start < curr.start { + prev.start + } else { + curr.start + } let inv_end = if prev.end > curr.end { prev.end } else { curr.end } let inv = MauveInversion::{ seq_name: name, start: inv_start, end: inv_end, - length: if curr.end - prev.start > 0 { curr.end - prev.start } else { prev.start - curr.end }, + length: if curr.end - prev.start > 0 { + curr.end - prev.start + } else { + prev.start - curr.end + }, affected_lcbs: Array::new(), } - + for l = 0; l < result.lcbs.length(); l = l + 1 { let lcb = result.lcbs[l] for s = 0; s < lcb.sequences.length(); s = s + 1 { let seq = lcb.sequences[s] - if seq.name == name && - ((seq.start >= inv.start && seq.end <= inv.end) || - (seq.end >= inv.start && seq.start <= inv.end)) { + if seq.name == name && + ( + (seq.start >= inv.start && seq.end <= inv.end) || + (seq.end >= inv.start && seq.start <= inv.end) + ) { inv.affected_lcbs.push(lcb.id) } } } - + result.inversions.push(inv) } } @@ -478,21 +496,33 @@ pub fn detect_mauve_breakpoints(ali : MauveAlignment) -> MauveAlignment { if result.lcbs.length() < 2 { return result } - + for i = 1; i < result.lcbs.length(); i = i + 1 { let prev_lcb = result.lcbs[i - 1] let curr_lcb = result.lcbs[i] - + for ps = 0; ps < prev_lcb.sequences.length(); ps = ps + 1 { let prev_seq = prev_lcb.sequences[ps] for cs = 0; cs < curr_lcb.sequences.length(); cs = cs + 1 { let curr_seq = curr_lcb.sequences[cs] if prev_seq.name == curr_seq.name { - let gap_start = if prev_seq.end > curr_seq.start { prev_seq.end } else { curr_seq.start } - let gap_end = if prev_seq.start < curr_seq.end { prev_seq.start } else { curr_seq.end } - + let gap_start = if prev_seq.end > curr_seq.start { + prev_seq.end + } else { + curr_seq.start + } + let gap_end = if prev_seq.start < curr_seq.end { + prev_seq.start + } else { + curr_seq.end + } + if gap_start > gap_end { - let bp_type = if prev_seq.strand != curr_seq.strand { "inversion" } else { "translocation" } + let bp_type = if prev_seq.strand != curr_seq.strand { + "inversion" + } else { + "translocation" + } let bp = MauveBreakpoint::{ lcb1_id: prev_lcb.id, lcb2_id: curr_lcb.id, @@ -521,13 +551,7 @@ pub fn new_mauve_inversion( end : Int, length : Int, ) -> MauveInversion { - MauveInversion::{ - seq_name, - start, - end, - length, - affected_lcbs: Array::new(), - } + MauveInversion::{ seq_name, start, end, length, affected_lcbs: Array::new() } } ///| @@ -535,29 +559,33 @@ pub fn new_mauve_inversion( pub fn mauve_genome_coverage(ali : MauveAlignment) -> Map[String, Double] { let coverage = Map([], capacity=10) let seq_names = mauve_all_seq_names(ali) - + for n = 0; n < seq_names.length(); n = n + 1 { let name = seq_names[n] let seqs = mauve_get_genome_seqs(ali, name) let mut total_aligned = 0.0 let mut max_end = 0 let mut min_start = 99999999 - + for s = 0; s < seqs.length(); s = s + 1 { let seq = seqs[s] total_aligned = total_aligned + seq.length.to_double() - if seq.end > max_end { max_end = seq.end } - if seq.start < min_start { min_start = seq.start } + if seq.end > max_end { + max_end = seq.end + } + if seq.start < min_start { + min_start = seq.start + } } - + let total_range = (max_end - min_start).to_double() if total_range > 0.0 { - coverage[name] = (total_aligned / total_range) * 100.0 + coverage[name] = total_aligned / total_range * 100.0 } else { coverage[name] = 0.0 } } - + coverage } @@ -566,13 +594,13 @@ pub fn mauve_genome_coverage(ali : MauveAlignment) -> Map[String, Double] { pub fn mauve_conserved_segments(ali : MauveAlignment) -> Map[String, Int] { let segments = Map([], capacity=10) let seq_names = mauve_all_seq_names(ali) - + for n = 0; n < seq_names.length(); n = n + 1 { let name = seq_names[n] let count = mauve_get_genome_seqs(ali, name).length() segments[name] = count } - + segments } @@ -583,7 +611,7 @@ pub fn mauve_rearrangement_rate(ali : MauveAlignment) -> Double { if total_size == 0 { return 0.0 } - (ali.breakpoints.length().to_double() / total_size.to_double()) * 1000000.0 + ali.breakpoints.length().to_double() / total_size.to_double() * 1000000.0 } ///| @@ -592,7 +620,7 @@ pub fn mauve_syntenic_regions(ali : MauveAlignment) -> Array[Array[String]] { let regions = Array::new() let mut current_region = Array::new() let mut prev_collinear = true - + for l = 0; l < ali.lcbs.length(); l = l + 1 { let lcb = ali.lcbs[l] if lcb.is_collinear && prev_collinear { @@ -608,29 +636,37 @@ pub fn mauve_syntenic_regions(ali : MauveAlignment) -> Array[Array[String]] { } prev_collinear = lcb.is_collinear } - + if current_region.length() > 0 { regions.push(current_region) } - + regions } ///| /// Filter LCBs by score threshold. -pub fn mauve_filter_lcbs(ali : MauveAlignment, min_score : Double) -> MauveAlignment { - let mut result = MauveAlignment::{ ..ali, lcbs: Array::new(), inversions: Array::new(), breakpoints: Array::new() } - +pub fn mauve_filter_lcbs( + ali : MauveAlignment, + min_score : Double, +) -> MauveAlignment { + let mut result = MauveAlignment::{ + ..ali, + lcbs: Array::new(), + inversions: Array::new(), + breakpoints: Array::new(), + } + for l = 0; l < ali.lcbs.length(); l = l + 1 { let lcb = ali.lcbs[l] if lcb.score >= min_score { result.lcbs.push(lcb) } } - + result = detect_mauve_inversions(result) result = detect_mauve_breakpoints(result) - + result } @@ -661,7 +697,10 @@ pub fn new_mauve_progressive_aligner() -> MauveProgressiveAligner { ///| /// Add a sequence to the progressive alignment. -pub fn mauve_add_sequence(aligner : MauveProgressiveAligner, seq_name : String) -> Unit { +pub fn mauve_add_sequence( + aligner : MauveProgressiveAligner, + seq_name : String, +) -> Unit { aligner.pending_seqs.push(seq_name) } @@ -679,15 +718,17 @@ pub fn mauve_build_guide_tree(aligner : MauveProgressiveAligner) -> Unit { ///| /// Execute progressive alignment by adding sequences one at a time. -pub fn mauve_execute_progressive(aligner : MauveProgressiveAligner) -> MauveAlignment { +pub fn mauve_execute_progressive( + aligner : MauveProgressiveAligner, +) -> MauveAlignment { mauve_build_guide_tree(aligner) - + let result = aligner.alignment - + for i = 0; i < aligner.guide_tree.length(); i = i + 1 { result.groups[i] = aligner.guide_tree[i] } - + result } @@ -701,15 +742,15 @@ pub fn mauve_summary(ali : MauveAlignment) -> String { let mut result = "" result = result + "Mauve Alignment Summary\n" result = result + "====================\n\n" - + result = result + "Version: " result = result + ali.version result = result + "\n\n" - + result = result + "Locally Collinear Blocks (LCBs): " result = result + ali.lcbs.length().to_string() result = result + "\n\n" - + result = result + "Genomes aligned:\n" let seq_names = mauve_all_seq_names(ali) let coverage = mauve_genome_coverage(ali) @@ -721,12 +762,12 @@ pub fn mauve_summary(ali : MauveAlignment) -> String { result = result + coverage[name].to_string() result = result + "%)\n" } - + result = result + "\n" result = result + "Inversions detected: " result = result + ali.inversions.length().to_string() result = result + "\n" - + for i = 0; i < ali.inversions.length(); i = i + 1 { let inv = ali.inversions[i] result = result + " - " @@ -739,12 +780,12 @@ pub fn mauve_summary(ali : MauveAlignment) -> String { result = result + inv.length.to_string() result = result + " bp)\n" } - + result = result + "\n" result = result + "Breakpoints detected: " result = result + ali.breakpoints.length().to_string() result = result + "\n" - + let bp_types = Map([], capacity=5) for b = 0; b < ali.breakpoints.length(); b = b + 1 { let bp = ali.breakpoints[b] @@ -755,7 +796,7 @@ pub fn mauve_summary(ali : MauveAlignment) -> String { bp_types[bp.breakpoint_type] = 1 } } - + let bp_keys = bp_types.keys().collect() for k = 0; k < bp_keys.length(); k = k + 1 { let key = bp_keys[k] @@ -765,14 +806,14 @@ pub fn mauve_summary(ali : MauveAlignment) -> String { result = result + bp_types[key].to_string() result = result + "\n" } - + result = result + "\n" result = result + "Syntenic regions:\n" let syntenic = mauve_syntenic_regions(ali) result = result + " Number: " result = result + syntenic.length().to_string() result = result + "\n" - + let segments = mauve_conserved_segments(ali) result = result + "\nConserved segments per genome:\n" let seg_keys = segments.keys().collect() @@ -784,11 +825,11 @@ pub fn mauve_summary(ali : MauveAlignment) -> String { result = result + segments[key].to_string() result = result + " segments\n" } - + result = result + "\nRearrangement rate: " result = result + mauve_rearrangement_rate(ali).to_string() result = result + " breakpoints/Mb\n" - + result } @@ -796,8 +837,9 @@ pub fn mauve_summary(ali : MauveAlignment) -> String { /// Export alignment to BED format for visualization. pub fn mauve_to_bed(ali : MauveAlignment) -> String { let mut result = "" - result = result + "track name=\"MauveAlignment\" description=\"Mauve Alignment Blocks\"\n" - + result = result + + "track name=\"MauveAlignment\" description=\"Mauve Alignment Blocks\"\n" + for l = 0; l < ali.lcbs.length(); l = l + 1 { let lcb = ali.lcbs[l] for s = 0; s < lcb.sequences.length(); s = s + 1 { @@ -816,7 +858,7 @@ pub fn mauve_to_bed(ali : MauveAlignment) -> String { result = result + "\n" } } - + result } @@ -825,7 +867,7 @@ pub fn mauve_to_bed(ali : MauveAlignment) -> String { pub fn mauve_inversions_to_bed(ali : MauveAlignment) -> String { let mut result = "" result = result + "track name=\"Inversions\" color=\"100,0,0\"\n" - + for i = 0; i < ali.inversions.length(); i = i + 1 { let inv = ali.inversions[i] result = result + inv.seq_name @@ -837,6 +879,6 @@ pub fn mauve_inversions_to_bed(ali : MauveAlignment) -> String { result = result + inv.length.to_string() result = result + "\t-\n" } - + result -} \ No newline at end of file +} diff --git a/src/max_entropy.mbt b/src/max_entropy.mbt index 5639f4c4..83b76cd9 100644 --- a/src/max_entropy.mbt +++ b/src/max_entropy.mbt @@ -24,7 +24,7 @@ pub struct MaxEntFeature { pub fn MaxEntFeature::new( attribute_index : Int, attribute_value : String, - class_label : String + class_label : String, ) -> MaxEntFeature { MaxEntFeature::{ attribute_index, attribute_value, class_label } } @@ -53,7 +53,7 @@ pub fn MaxEntFeature::class_label(self : MaxEntFeature) -> String { pub fn max_ent_eval_feature( feature : MaxEntFeature, observation : Array[String], - class_label : String + class_label : String, ) -> Int { if feature.attribute_index >= 0 && feature.attribute_index < observation.length() && @@ -92,7 +92,7 @@ pub fn MaxEntropyModel::alphas(self : MaxEntropyModel) -> Array[Double] { ///| /// Accessor for the features. pub fn MaxEntropyModel::features( - self : MaxEntropyModel + self : MaxEntropyModel, ) -> Array[MaxEntFeature] { self.features } @@ -135,7 +135,7 @@ fn me_safe_log(x : Double) -> Double { /// matches and we're summing over the class that the feature refers to). fn me_f_correction( feature : MaxEntFeature, - observation : Array[String] + observation : Array[String], ) -> Double { // f^#(x) = sum_y f(x, y). Since f is 1 only for one class, f^# is at most 1. if feature.attribute_index >= 0 && @@ -157,16 +157,14 @@ fn me_f_correction( /// `model.classes`. pub fn max_entropy_calculate( model : MaxEntropyModel, - observation : Array[String] + observation : Array[String], ) -> Array[Double] { let scores = Array::make(model.classes.length(), 0.0) for ci in 0.. String { let scores = max_entropy_calculate(model, observation) let mut best_idx = 0 @@ -203,7 +201,7 @@ pub fn max_entropy_classify( pub fn max_entropy_train( training_set : Array[Array[String]], results : Array[String], - features : Array[MaxEntFeature] + features : Array[MaxEntFeature], ) -> MaxEntropyModel { let n = training_set.length() // Collect unique classes. @@ -222,9 +220,8 @@ pub fn max_entropy_train( for fi in 0.. (Array[ - Array[String] -], Array[String], Array[MaxEntFeature]) { +pub fn max_entropy_sample_data() -> ( + Array[Array[String]], + Array[String], + Array[MaxEntFeature], +) { let xs = [ ["Red", "Sports", "Domestic"], ["Red", "Sports", "Domestic"], @@ -329,9 +332,7 @@ pub fn max_entropy_sample_data() -> (Array[ ["Red", "SUV", "Imported"], ["Red", "Sports", "Imported"], ] - let ys = [ - "Yes", "No", "Yes", "No", "Yes", "No", "Yes", "No", "No", "Yes", - ] + let ys = ["Yes", "No", "Yes", "No", "Yes", "No", "Yes", "No", "No", "Yes"] let features = [ MaxEntFeature::new(0, "Red", "Yes"), MaxEntFeature::new(0, "Red", "No"), diff --git a/src/mcp_counter.mbt b/src/mcp_counter.mbt index 5189b988..d42eea97 100644 --- a/src/mcp_counter.mbt +++ b/src/mcp_counter.mbt @@ -77,13 +77,21 @@ pub fn McpResult::get_score( ) -> Double { let mut pop_idx = -1 for i in 0.. Array[Double] { let mut idx = -1 for i in 0.. Double { let n = values.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut sum_log = 0.0 let mut count = 0 for v in values { @@ -120,7 +135,9 @@ fn mcp_geometric_mean(values : Array[Double]) -> Double { count = count + 1 } } - if count == 0 { return 0.0 } + if count == 0 { + return 0.0 + } @math.exp(sum_log / count.to_double()) } @@ -181,7 +198,9 @@ pub fn mcp_default_populations() -> Array[McpCellPopulation] { pub fn mcp_population_names() -> Array[String] { let pops = mcp_default_populations() let names : Array[String] = [] - for p in pops { names.push(p.name) } + for p in pops { + names.push(p.name) + } names } @@ -273,9 +292,14 @@ pub fn mcp_sample_data() -> (Array[String], Array[String], Array[Array[Double]]) for m in pop.markers { let mut found = false for existing in all_markers { - if existing == m { found = true; break } + if existing == m { + found = true + break + } + } + if !found { + all_markers.push(m) } - if !found { all_markers.push(m) } } } let sample_names = ["Tumor_A", "Tumor_B", "Tumor_C"] @@ -290,7 +314,10 @@ pub fn mcp_sample_data() -> (Array[String], Array[String], Array[Array[Double]]) let mut pi = 0 while pi < pops.length() && pop_idx < 0 { for m in pops[pi].markers { - if m == gene { pop_idx = pi; break } + if m == gene { + pop_idx = pi + break + } } pi = pi + 1 } @@ -300,13 +327,19 @@ pub fn mcp_sample_data() -> (Array[String], Array[String], Array[Array[Double]]) let base_exprs = [5.0, 4.0, 3.0, 6.0, 2.0, 3.0, 2.0, 1.0, 1.0, 7.0] let val_a = if pop_idx == 0 || pop_idx == 1 || pop_idx == 2 { base_exprs[pop_idx] + 5.0 - } else { base_exprs[pop_idx] * 0.3 } + } else { + base_exprs[pop_idx] * 0.3 + } let val_b = if pop_idx == 3 { base_exprs[pop_idx] + 5.0 - } else { base_exprs[pop_idx] * 0.3 } + } else { + base_exprs[pop_idx] * 0.3 + } let val_c = if pop_idx == 9 { base_exprs[pop_idx] + 5.0 - } else { base_exprs[pop_idx] * 0.3 } + } else { + base_exprs[pop_idx] * 0.3 + } row.push(val_a) row.push(val_b) row.push(val_c) diff --git a/src/melting_temp.mbt b/src/melting_temp.mbt index d7f7fcbc..b4c706fd 100644 --- a/src/melting_temp.mbt +++ b/src/melting_temp.mbt @@ -8,17 +8,20 @@ pub struct MeltingTempResult { } ///| -pub fn MeltingTempResult::new(tm : Double, method : String) -> MeltingTempResult { +pub fn MeltingTempResult::new( + tm : Double, + method : String, +) -> MeltingTempResult { MeltingTempResult::{ tm, method } } ///| pub fn mt_wallace(seq : String) -> MeltingTempResult { let seq_upper = seq.to_upper() - + let mut gc_count = 0 let mut at_count = 0 - + let mut idx = 0 while idx < seq_upper.length() { let c = substring(seq_upper, idx, 1) @@ -29,9 +32,9 @@ pub fn mt_wallace(seq : String) -> MeltingTempResult { } idx = idx + 1 } - + let tm = 4.0 * gc_count.to_double() + 2.0 * at_count.to_double() - + MeltingTempResult::new(tm, "wallace") } @@ -39,9 +42,9 @@ pub fn mt_wallace(seq : String) -> MeltingTempResult { pub fn mt_gc_content(seq : String) -> MeltingTempResult { let seq_upper = seq.to_upper() let length = seq_upper.length().to_double() - + let mut gc_count = 0 - + let mut idx = 0 while idx < seq_upper.length() { let c = substring(seq_upper, idx, 1) @@ -50,9 +53,9 @@ pub fn mt_gc_content(seq : String) -> MeltingTempResult { } idx = idx + 1 } - + let tm = 64.9 + 41.0 * (gc_count.to_double() - 16.4) / length - + MeltingTempResult::new(tm, "gc_content") } @@ -64,10 +67,10 @@ pub fn create_example_dna() -> String { ///| pub fn recommend_tm_method(seq : String) -> String { let length = seq.length() - + if length <= 14 { "wallace" } else { "gc_content" } -} \ No newline at end of file +} diff --git a/src/meme.mbt b/src/meme.mbt index f0678a10..1d92bc94 100644 --- a/src/meme.mbt +++ b/src/meme.mbt @@ -44,7 +44,7 @@ pub struct MemeMotif { pub fn MemeMotif::new( name : String, pspm : Array[Array[Double]], - alphabet~ : String = "ACGT", + alphabet? : String = "ACGT", ) -> MemeMotif { let width = if pspm.length() > 0 { pspm.length() } else { 0 } MemeMotif::{ @@ -275,22 +275,18 @@ pub fn meme_parse(text : String) -> MemeRecord { // If we were building a motif, save it first if has_motif { finalize_motif( - record, - has_motif, - m_name, - m_alt_name, - m_alphabet, - m_nsites, - m_evalue, - m_url, - m_strands, - matrix_rows, + record, has_motif, m_name, m_alt_name, m_alphabet, m_nsites, m_evalue, + m_url, m_strands, matrix_rows, ) } in_matrix = false matrix_rows = Array::new() let parts = line.split(" ").to_array() - m_name = if parts.length() >= 2 { parts[1].trim().to_string() } else { "" } + m_name = if parts.length() >= 2 { + parts[1].trim().to_string() + } else { + "" + } m_alt_name = if parts.length() >= 3 { parts[2].trim().to_string() } else { @@ -323,16 +319,8 @@ pub fn meme_parse(text : String) -> MemeRecord { m_url = line.substring(start=4).trim().to_string() in_matrix = false finalize_motif( - record, - has_motif, - m_name, - m_alt_name, - m_alphabet, - m_nsites, - m_evalue, - m_url, - m_strands, - matrix_rows, + record, has_motif, m_name, m_alt_name, m_alphabet, m_nsites, m_evalue, m_url, + m_strands, matrix_rows, ) has_motif = false i = i + 1 @@ -449,7 +437,10 @@ fn parse_meme_double_field(text : String, field : String) -> Double { let mut i = 0 while i < rest.length() { let ch = rest[i:i + 1].to_string() - if (ch >= "0" && ch <= "9") || ch == "." || ch == "-" || ch == "+" || + if (ch >= "0" && ch <= "9") || + ch == "." || + ch == "-" || + ch == "+" || ch == "e" || ch == "E" { num_str.write_string(ch) diff --git a/src/metagenomeseq.mbt b/src/metagenomeseq.mbt index a3d7ce5d..8141dc2e 100644 --- a/src/metagenomeseq.mbt +++ b/src/metagenomeseq.mbt @@ -10,12 +10,16 @@ pub struct MRexperiment { } ///| -pub fn MRexperiment::new(counts : Array[Array[Int]], taxa_names : Array[String], sample_names : Array[String]) -> MRexperiment { +pub fn MRexperiment::new( + counts : Array[Array[Int]], + taxa_names : Array[String], + sample_names : Array[String], +) -> MRexperiment { MRexperiment::{ counts, taxa_names, sample_names, - sample_data: Map([], capacity=10) + sample_data: Map([], capacity=10), } } @@ -42,8 +46,22 @@ pub struct MGResult { } ///| -pub fn MGResult::new(taxa_name : String, log2_fold_change : Double, p_value : Double, adjusted_p_value : Double, zero_inflation_prob : Double, abundance_mean : Double) -> MGResult { - MGResult::{ taxa_name, log2_fold_change, p_value, adjusted_p_value, zero_inflation_prob, abundance_mean } +pub fn MGResult::new( + taxa_name : String, + log2_fold_change : Double, + p_value : Double, + adjusted_p_value : Double, + zero_inflation_prob : Double, + abundance_mean : Double, +) -> MGResult { + MGResult::{ + taxa_name, + log2_fold_change, + p_value, + adjusted_p_value, + zero_inflation_prob, + abundance_mean, + } } ///| @@ -60,9 +78,9 @@ pub fn mg_normalize_counts(obj : MRexperiment) -> MRexperiment { total_counts.push(sum) j = j + 1 } - + let median_depth = median_int(total_counts) - + let normalized : Array[Array[Int]] = Array::new() let mut i = 0 while i < obj.taxa_names.length() { @@ -70,7 +88,7 @@ pub fn mg_normalize_counts(obj : MRexperiment) -> MRexperiment { let mut j = 0 while j < obj.sample_names.length() { if total_counts[j] > 0 { - row.push((obj.counts[i][j] * median_depth) / total_counts[j]) + row.push(obj.counts[i][j] * median_depth / total_counts[j]) } else { row.push(0) } @@ -79,8 +97,13 @@ pub fn mg_normalize_counts(obj : MRexperiment) -> MRexperiment { normalized.push(row) i = i + 1 } - - MRexperiment::{ counts: normalized, taxa_names: obj.taxa_names, sample_names: obj.sample_names, sample_data: obj.sample_data } + + MRexperiment::{ + counts: normalized, + taxa_names: obj.taxa_names, + sample_names: obj.sample_names, + sample_data: obj.sample_data, + } } ///| @@ -102,7 +125,7 @@ fn median_int(arr : Array[Int]) -> Int { } n = n - 1 } - + if sorted.length() % 2 == 1 { sorted[sorted.length() / 2] } else { @@ -113,7 +136,7 @@ fn median_int(arr : Array[Int]) -> Int { ///| pub fn mg_calculate_zero_inflation(obj : MRexperiment) -> Array[Double] { let zero_probs : Array[Double] = Array::new() - + let mut i = 0 while i < obj.taxa_names.length() { let mut zeros = 0 @@ -127,17 +150,20 @@ pub fn mg_calculate_zero_inflation(obj : MRexperiment) -> Array[Double] { zero_probs.push(zeros.to_double() / obj.sample_names.length().to_double()) i = i + 1 } - + zero_probs } ///| -pub fn mg_test_zero_inflated(obj : MRexperiment, group : Array[String]) -> Array[MGResult] { +pub fn mg_test_zero_inflated( + obj : MRexperiment, + group : Array[String], +) -> Array[MGResult] { let results : Array[MGResult] = Array::new() - + let group0_indices : Array[Int] = Array::new() let group1_indices : Array[Int] = Array::new() - + let mut i = 0 while i < group.length() { if group[i] == "control" { @@ -147,51 +173,59 @@ pub fn mg_test_zero_inflated(obj : MRexperiment, group : Array[String]) -> Array } i = i + 1 } - + let zero_probs = mg_calculate_zero_inflation(obj) - + let mut t = 0 while t < obj.taxa_names.length() { let mut group0_sum = 0 for idx in group0_indices { group0_sum = group0_sum + obj.counts[t][idx] } - + let mut group1_sum = 0 for idx in group1_indices { group1_sum = group1_sum + obj.counts[t][idx] } - + let n0 = group0_indices.length() let n1 = group1_indices.length() - - let mean0 = if n0 > 0 { group0_sum.to_double() / n0.to_double() } else { 0.0 } - let mean1 = if n1 > 0 { group1_sum.to_double() / n1.to_double() } else { 0.0 } - + + let mean0 = if n0 > 0 { + group0_sum.to_double() / n0.to_double() + } else { + 0.0 + } + let mean1 = if n1 > 0 { + group1_sum.to_double() / n1.to_double() + } else { + 0.0 + } + let log2_fc = if mean0 > 0.0 && mean1 > 0.0 { - @math.log2(mean1 / mean0) - } else { - 0.0 - } - + @math.log2(mean1 / mean0) + } else { + 0.0 + } + let zero_prob = zero_probs[t] - + let p_value = 1.0 / (1.0 + log2_fc * log2_fc * (1.0 - zero_prob)) - + let adjusted_p = p_value * 0.1 - + let result = MGResult::new( obj.taxa_names[t], log2_fc, p_value, adjusted_p, zero_prob, - (mean0 + mean1) / 2.0 + (mean0 + mean1) / 2.0, ) results.push(result) t = t + 1 } - + results } @@ -203,11 +237,16 @@ pub fn create_example_mrexperiment() -> MRexperiment { [200, 220, 250, 200, 180, 150], [0, 0, 10, 50, 80, 100], [10, 5, 0, 0, 0, 0], - [80, 90, 100, 70, 60, 50] + [80, 90, 100, 70, 60, 50], + ] + + let taxa_names = [ + "Bacteroides", "Firmicutes", "Actinobacteria", "Proteobacteria", "Fusobacteria", + "Verrucomicrobia", + ] + let sample_names = [ + "control1", "control2", "control3", "treatment1", "treatment2", "treatment3", ] - - let taxa_names = ["Bacteroides", "Firmicutes", "Actinobacteria", "Proteobacteria", "Fusobacteria", "Verrucomicrobia"] - let sample_names = ["control1", "control2", "control3", "treatment1", "treatment2", "treatment3"] - + MRexperiment::new(counts, taxa_names, sample_names) -} \ No newline at end of file +} diff --git a/src/methyl_seekr.mbt b/src/methyl_seekr.mbt index c3cbd254..70fda664 100644 --- a/src/methyl_seekr.mbt +++ b/src/methyl_seekr.mbt @@ -112,16 +112,9 @@ pub fn MethylTile::new( end~ : Int, methylation_level~ : Double, coverage~ : Int, - region_type~ : String = "FMR", + region_type? : String = "FMR", ) -> MethylTile { - MethylTile::{ - chr, - start, - end, - methylation_level, - coverage, - region_type, - } + MethylTile::{ chr, start, end, methylation_level, coverage, region_type } } ///| @@ -433,7 +426,10 @@ pub fn tile_methylation( let mut j = i + 1 while j < m { let lt = entries[j].0 < entries[min_idx].0 || - (entries[j].0 == entries[min_idx].0 && entries[j].1 < entries[min_idx].1) + ( + entries[j].0 == entries[min_idx].0 && + entries[j].1 < entries[min_idx].1 + ) if lt { min_idx = j } @@ -458,8 +454,8 @@ pub fn tile_methylation( let start = idx * params.tile_size tiles.push( MethylTile::new( - chr=chr, - start=start, + chr~, + start~, end=start + params.tile_size, methylation_level=level, coverage=total, @@ -526,7 +522,8 @@ pub fn detect_pmds( let mut i = 0 while i < n { // Skip tiles that are not PMD candidates. - if tiles[i].region_type != "FMR" || tiles[i].methylation_level >= params.gamma { + if tiles[i].region_type != "FMR" || + tiles[i].methylation_level >= params.gamma { i = i + 1 continue } @@ -603,11 +600,11 @@ pub fn merge_regions( if end - start >= params.min_region_size { result.push( MethylRegion::new( - chr=chr, - start=start, - end=end, + chr~, + start~, + end~, region_type=rtype, - n_tiles=n_tiles, + n_tiles~, mean_methylation=sum_level / n_tiles.to_double(), min_methylation=min_level, max_methylation=max_level, @@ -682,10 +679,30 @@ pub fn region_summary(regions : Array[MethylRegion]) -> String { let mut s = "Methylation Regimes Summary\n" s = s + "===========================\n" s = s + "Total regions: " + regions.length().to_string() + "\n" - s = s + "UMR: " + n_umr.to_string() + " regions, " + bp_umr.to_string() + " bp\n" - s = s + "LMR: " + n_lmr.to_string() + " regions, " + bp_lmr.to_string() + " bp\n" - s = s + "PMD: " + n_pmd.to_string() + " regions, " + bp_pmd.to_string() + " bp\n" - s = s + "FMR: " + n_fmr.to_string() + " regions, " + bp_fmr.to_string() + " bp\n" + s = s + + "UMR: " + + n_umr.to_string() + + " regions, " + + bp_umr.to_string() + + " bp\n" + s = s + + "LMR: " + + n_lmr.to_string() + + " regions, " + + bp_lmr.to_string() + + " bp\n" + s = s + + "PMD: " + + n_pmd.to_string() + + " regions, " + + bp_pmd.to_string() + + " bp\n" + s = s + + "FMR: " + + n_fmr.to_string() + + " regions, " + + bp_fmr.to_string() + + " bp\n" s } @@ -709,7 +726,7 @@ pub fn methyl_seekr_sample_data() -> Array[CytosineSite] { ] for region in regions { let (t_start, t_end, meth, unmeth) = region - for t in t_start..=t_end { + for t in t_start..<=t_end { let base = t * 1000 for k in 0..<10 { let pos = base + 50 + k * 100 diff --git a/src/methylkit.mbt b/src/methylkit.mbt index 791e1e64..087703f1 100644 --- a/src/methylkit.mbt +++ b/src/methylkit.mbt @@ -17,7 +17,7 @@ fn methylkit_round(x : Double) -> Int { if x >= 0.0 { (x + 0.5).to_int() } else { - -((-x) + 0.5).to_int() + -(-x + 0.5).to_int() } } @@ -77,11 +77,7 @@ fn methylkit_median(arr : Array[Double]) -> Double { ///| /// Logarithm of a binomial coefficient using a precomputed log-factorial table. -fn methylkit_log_choose_tbl( - n : Int, - k : Int, - lf : Array[Double], -) -> Double { +fn methylkit_log_choose_tbl(n : Int, k : Int, lf : Array[Double]) -> Double { if k < 0 || k > n { return -700.0 } @@ -200,11 +196,7 @@ pub struct MethylSample { ///| /// Construct an empty MethylSample. pub fn MethylSample::new(sample_id : String) -> MethylSample { - MethylSample::{ - sample_id, - coverage: Array::new(), - n_cpgs: 0, - } + MethylSample::{ sample_id, coverage: Array::new(), n_cpgs: 0 } } ///| @@ -604,7 +596,7 @@ pub fn methylkit_fisher_test( } // Precompute log-factorial table up to n. let log_fact : Array[Double] = Array::make(n + 1, 0.0) - for i in 2..=n { + for i in 2..<=n { log_fact[i] = log_fact[i - 1] + @math.ln(i.to_double()) } let log_pmf = fn(aa : Int) -> Double { @@ -624,7 +616,7 @@ pub fn methylkit_fisher_test( let lo = if c1 - r2 > 0 { c1 - r2 } else { 0 } let hi = if r1 < c1 { r1 } else { c1 } let mut p_sum = 0.0 - for aa in lo..=hi { + for aa in lo..<=hi { let p = @math.exp(log_pmf(aa)) if p <= p_obs + 1.0e-12 { p_sum = p_sum + p @@ -731,16 +723,14 @@ pub fn methylkit_diff_meth( let (chr, pos, diff) = info[i] let q = q_values[i] let sig = q < config.q_threshold && diff.abs() >= config.min_diff - results.push( - MethylDiffResult::{ - chr, - position: pos, - p_value: p_values[i], - q_value: q, - meth_diff: diff, - significant: sig, - }, - ) + results.push(MethylDiffResult::{ + chr, + position: pos, + p_value: p_values[i], + q_value: q, + meth_diff: diff, + significant: sig, + }) i = i + 1 } results @@ -832,16 +822,14 @@ pub fn methylkit_tiling( let mut i = 0 while i < info.length() { let (chr, pos, diff) = info[i] - results.push( - MethylDiffResult::{ - chr, - position: pos, - p_value: p_values[i], - q_value: q_values[i], - meth_diff: diff, - significant: q_values[i] < 0.05 && diff.abs() >= 25.0, - }, - ) + results.push(MethylDiffResult::{ + chr, + position: pos, + p_value: p_values[i], + q_value: q_values[i], + meth_diff: diff, + significant: q_values[i] < 0.05 && diff.abs() >= 25.0, + }) i = i + 1 } results @@ -866,8 +854,10 @@ pub fn methylkit_get_dmr( let mut j = i + 1 while j < n { if sorted[j].chr < sorted[min_idx].chr || - (sorted[j].chr == sorted[min_idx].chr && - sorted[j].position < sorted[min_idx].position) { + ( + sorted[j].chr == sorted[min_idx].chr && + sorted[j].position < sorted[min_idx].position + ) { min_idx = j } j = j + 1 @@ -888,9 +878,9 @@ pub fn methylkit_get_dmr( let mut end_pos = sorted[i].position let mut j = i + 1 while j < n && - sorted[j].significant && - sorted[j].chr == chr && - sorted[j].position - end_pos <= 1000 { + sorted[j].significant && + sorted[j].chr == chr && + sorted[j].position - end_pos <= 1000 { end_pos = sorted[j].position j = j + 1 } diff --git a/src/microbiome.mbt b/src/microbiome.mbt index 7dc908f5..3ee3f006 100644 --- a/src/microbiome.mbt +++ b/src/microbiome.mbt @@ -52,7 +52,7 @@ pub fn calc_shannon(counts : Array[Double]) -> Double { if total == 0.0 { return 0.0 } - + let mut shannon = 0.0 let mut i = 0 while i < counts.length() { @@ -73,7 +73,7 @@ pub fn calc_simpson(counts : Array[Double]) -> Double { if total == 0.0 { return 0.0 } - + let mut sum_sq = 0.0 let mut i = 0 while i < counts.length() { @@ -92,7 +92,7 @@ pub fn calc_inv_simpson(counts : Array[Double]) -> Double { if total == 0.0 { return 0.0 } - + let mut sum_sq = 0.0 let mut i = 0 while i < counts.length() { @@ -124,7 +124,7 @@ pub fn calc_pielou_evenness(counts : Array[Double]) -> Double { /// where f1 = number of singletons, f2 = number of doubletons pub fn calc_chao1(counts : Array[Double]) -> Double { let s_obs = calc_observed(counts) - + let mut f1 = 0.0 let mut f2 = 0.0 let mut i = 0 @@ -136,8 +136,8 @@ pub fn calc_chao1(counts : Array[Double]) -> Double { } i = i + 1 } - - s_obs + (f1 * (f1 - 1.0)) / (2.0 * (f2 + 1.0)) + + s_obs + f1 * (f1 - 1.0) / (2.0 * (f2 + 1.0)) } ///| @@ -147,7 +147,7 @@ pub fn calc_ace(counts : Array[Double], threshold : Int) -> Double { let mut s_rare = 0.0 let mut s_abund = 0.0 let mut f1 = 0.0 - + let mut i = 0 while i < counts.length() { let count = counts[i] @@ -164,16 +164,16 @@ pub fn calc_ace(counts : Array[Double], threshold : Int) -> Double { } i = i + 1 } - + if n_rare == 0.0 || s_rare <= f1 { return s_rare + s_abund } - + let mut c_ace = 1.0 - f1 / n_rare if c_ace <= 0.0 { c_ace = 0.001 } - + let mut sum_fi = 0.0 let mut sum_fi_i = 0.0 i = 0 @@ -185,11 +185,11 @@ pub fn calc_ace(counts : Array[Double], threshold : Int) -> Double { } i = i + 1 } - + let gamma2 = 0.0 if c_ace > 0.0 && n_rare > 0.0 { // Simplified ACE calculation - s_abund + s_rare / c_ace + (f1 / c_ace) * gamma2 + s_abund + s_rare / c_ace + f1 / c_ace * gamma2 } else { s_rare + s_abund } @@ -202,11 +202,11 @@ pub fn calc_ace(counts : Array[Double], threshold : Int) -> Double { pub fn calc_fisher_alpha(counts : Array[Double]) -> Double { let n = sum_double(counts) let s = calc_observed(counts) - + if n <= 0.0 || s <= 0.0 { return 0.0 } - + // Solve S = alpha * ln(1 + N/alpha) numerically let mut alpha = s let mut iter = 0 @@ -228,7 +228,7 @@ pub fn calc_fisher_alpha(counts : Array[Double]) -> Double { } iter = iter + 1 } - + alpha } @@ -249,12 +249,14 @@ pub fn calc_alpha_diversity(counts : Array[Double]) -> AlphaDiversity { ///| /// Calculate alpha diversity for multiple samples (OTU table: rows=taxa, cols=samples). -pub fn calc_alpha_diversity_table(otu_table : Array[Array[Double]]) -> Array[AlphaDiversity] { +pub fn calc_alpha_diversity_table( + otu_table : Array[Array[Double]], +) -> Array[AlphaDiversity] { let result : Array[AlphaDiversity] = Array::new() if otu_table.length() == 0 { return result } - + let num_samples = otu_table[0].length() let mut j = 0 while j < num_samples { @@ -267,7 +269,7 @@ pub fn calc_alpha_diversity_table(otu_table : Array[Array[Double]]) -> Array[Alp result.push(calc_alpha_diversity(sample_counts)) j = j + 1 } - + result } @@ -282,7 +284,7 @@ pub fn bray_curtis(x : Array[Double], y : Array[Double]) -> Double { if x.length() != y.length() { return 0.0 } - + let mut num = 0.0 let mut den = 0.0 let mut i = 0 @@ -291,11 +293,11 @@ pub fn bray_curtis(x : Array[Double], y : Array[Double]) -> Double { den = den + x[i] + y[i] i = i + 1 } - + if den == 0.0 { return 0.0 } - + num / den } @@ -306,7 +308,7 @@ pub fn jaccard_distance(x : Array[Double], y : Array[Double]) -> Double { if x.length() != y.length() { return 0.0 } - + let mut intersection = 0.0 let mut union = 0.0 let mut i = 0 @@ -321,11 +323,11 @@ pub fn jaccard_distance(x : Array[Double], y : Array[Double]) -> Double { } i = i + 1 } - + if union == 0.0 { return 0.0 } - + 1.0 - intersection / union } @@ -333,25 +335,28 @@ pub fn jaccard_distance(x : Array[Double], y : Array[Double]) -> Double { /// Calculate Jensen-Shannon divergence between two samples. /// JSD = 0.5 * KL(P||M) + 0.5 * KL(Q||M) /// where M = (P + Q) / 2 -pub fn jensen_shannon_divergence(x : Array[Double], y : Array[Double]) -> Double { +pub fn jensen_shannon_divergence( + x : Array[Double], + y : Array[Double], +) -> Double { if x.length() != y.length() { return 0.0 } - + let sum_x = sum_double(x) let sum_y = sum_double(y) - + if sum_x == 0.0 || sum_y == 0.0 { return 0.0 } - + let mut jsd = 0.0 let mut i = 0 while i < x.length() { let p = x[i] / sum_x let q = y[i] / sum_y let m = (p + q) / 2.0 - + if p > 0.0 && m > 0.0 { jsd = jsd + 0.5 * p * @math.ln(p / m) } @@ -360,7 +365,7 @@ pub fn jensen_shannon_divergence(x : Array[Double], y : Array[Double]) -> Double } i = i + 1 } - + jsd } @@ -382,14 +387,17 @@ pub fn unweighted_unifrac(x : Array[Double], y : Array[Double]) -> Double { ///| /// Calculate a beta diversity distance matrix for all samples. /// OTU table format: rows=taxa, cols=samples -pub fn calc_beta_diversity_matrix(otu_table : Array[Array[Double]], dist_method : String) -> Array[Array[Double]] { +pub fn calc_beta_diversity_matrix( + otu_table : Array[Array[Double]], + dist_method : String, +) -> Array[Array[Double]] { if otu_table.length() == 0 { return Array::new() } - + let num_samples = otu_table[0].length() let dist_matrix : Array[Array[Double]] = Array::new() - + // Initialize distance matrix let mut i = 0 while i < num_samples { @@ -402,7 +410,7 @@ pub fn calc_beta_diversity_matrix(otu_table : Array[Array[Double]], dist_method dist_matrix.push(row) i = i + 1 } - + // Calculate pairwise distances i = 0 while i < num_samples { @@ -416,7 +424,7 @@ pub fn calc_beta_diversity_matrix(otu_table : Array[Array[Double]], dist_method sample_j.push(otu_table[k][j]) k = k + 1 } - + let dist = match dist_method { "bray" => bray_curtis(sample_i, sample_j) "jaccard" => jaccard_distance(sample_i, sample_j) @@ -425,14 +433,14 @@ pub fn calc_beta_diversity_matrix(otu_table : Array[Array[Double]], dist_method "wunifrac" => weighted_unifrac(sample_i, sample_j) _ => bray_curtis(sample_i, sample_j) } - + dist_matrix[i][j] = dist dist_matrix[j][i] = dist j = j + 1 } i = i + 1 } - + dist_matrix } @@ -464,11 +472,11 @@ pub fn PCoAResult::new() -> PCoAResult { /// Uses classical MDS (metric multidimensional scaling). pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { let n = dist_matrix.length() - + if n <= 1 { return PCoAResult::new() } - + // Step 1: Center the distance matrix // Convert distances to similarities and double-center let d2 : Array[Array[Double]] = Array::new() @@ -483,7 +491,7 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { d2.push(row) i = i + 1 } - + // Calculate row means, column means, and grand mean let row_means : Array[Double] = Array::new() i = 0 @@ -497,7 +505,7 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { row_means.push(sum / n.to_double()) i = i + 1 } - + let col_means : Array[Double] = Array::new() let mut j = 0 while j < n { @@ -510,7 +518,7 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { col_means.push(sum / n.to_double()) j = j + 1 } - + let mut grand_mean = 0.0 i = 0 while i < n { @@ -518,7 +526,7 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { i = i + 1 } grand_mean = grand_mean / n.to_double() - + // Double-center the matrix let b : Array[Array[Double]] = Array::new() i = 0 @@ -533,22 +541,22 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { b.push(row) i = i + 1 } - + // Step 2: Simple power iteration for eigenvalues/vectors (first k) // We'll compute first min(n-1, 5) principal coordinates let k = if n - 1 < 5 { n - 1 } else { 5 } - + let eigenvalues : Array[Double] = Array::new() let vectors : Array[Array[Double]] = Array::new() - + // Simple implementation using power iteration let remaining = b.copy() - + let mut comp = 0 while comp < k { // Power iteration let v : Array[Double] = Array::make(n, 1.0) - + let mut lambda = 0.0 let mut iter = 0 while iter < 100 { @@ -565,7 +573,7 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { bv.push(sum) i = i + 1 } - + // Compute new lambda (Rayleigh quotient) let mut v_norm = 0.0 let mut v_bv = 0.0 @@ -575,13 +583,13 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { v_bv = v_bv + v[i] * bv[i] i = i + 1 } - + if v_norm == 0.0 { break } - + let new_lambda = v_bv / v_norm - + // Normalize bv let bv_norm = 0.0 let mut i = 0 @@ -595,17 +603,17 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { i = i + 1 } bv_len = bv_len.sqrt() - + if bv_len == 0.0 { break } - + i = 0 while i < n { v[i] = bv[i] / bv_len i = i + 1 } - + if (new_lambda - lambda).abs() < 0.000001 { lambda = new_lambda break @@ -613,13 +621,13 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { lambda = new_lambda iter = iter + 1 } - + if lambda < 0.0 { lambda = 0.0 } - + eigenvalues.push(lambda) - + // Scale eigenvector by sqrt(eigenvalue) let scaled_v : Array[Double] = Array::new() let mut i = 0 @@ -628,7 +636,7 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { i = i + 1 } vectors.push(scaled_v) - + // Deflate: remove this component from remaining let mut i = 0 while i < n { @@ -641,14 +649,14 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { } comp = comp + 1 } - + // Calculate variance explained let total_var = sum_double(eigenvalues) - + let variance_explained : Array[Double] = Array::new() let cumulative_variance : Array[Double] = Array::new() let mut cum_var = 0.0 - + let mut i = 0 while i < eigenvalues.length() { let ve = if total_var > 0.0 { eigenvalues[i] / total_var } else { 0.0 } @@ -657,7 +665,7 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { cumulative_variance.push(cum_var) i = i + 1 } - + // Transpose vectors to get samples x components let transposed : Array[Array[Double]] = Array::new() if vectors.length() > 0 { @@ -674,12 +682,12 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { i = i + 1 } } - + PCoAResult::{ - eigenvalues: eigenvalues, + eigenvalues, vectors: transposed, - variance_explained: variance_explained, - cumulative_variance: cumulative_variance, + variance_explained, + cumulative_variance, } } @@ -699,9 +707,16 @@ pub struct DAResult { } ///| -pub fn DAResult::new(taxa : String, log2_fc : Double, p_val : Double, adj_p : Double, mean1 : Double, mean2 : Double) -> DAResult { +pub fn DAResult::new( + taxa : String, + log2_fc : Double, + p_val : Double, + adj_p : Double, + mean1 : Double, + mean2 : Double, +) -> DAResult { DAResult::{ - taxa: taxa, + taxa, log2_fold_change: log2_fc, p_value: p_val, adjusted_p_value: adj_p, @@ -720,17 +735,19 @@ pub fn differential_abundance( group2_indices : Array[Int], ) -> Array[DAResult] { let results : Array[DAResult] = Array::new() - - if otu_table.length() == 0 || group1_indices.length() == 0 || group2_indices.length() == 0 { + + if otu_table.length() == 0 || + group1_indices.length() == 0 || + group2_indices.length() == 0 { return results } - + let p_values : Array[Double] = Array::new() let log2_fcs : Array[Double] = Array::new() let mean1s : Array[Double] = Array::new() let mean2s : Array[Double] = Array::new() let taxon_names : Array[String] = Array::new() - + let mut i = 0 while i < otu_table.length() { // Extract group 1 values @@ -740,7 +757,7 @@ pub fn differential_abundance( group1.push(otu_table[i][group1_indices[j]]) j = j + 1 } - + // Extract group 2 values let group2 : Array[Double] = Array::new() j = 0 @@ -748,46 +765,52 @@ pub fn differential_abundance( group2.push(otu_table[i][group2_indices[j]]) j = j + 1 } - + let mean1 = mean_double(group1) let mean2 = mean_double(group2) - + let log2_fc = if mean1 > 0.0 && mean2 > 0.0 { @math.log2(mean2 / mean1) } else { 0.0 } - + // Simple t-test approximation let p_val = micro_welch_t_test(group1, group2) p_values.push(p_val) log2_fcs.push(log2_fc) mean1s.push(mean1) mean2s.push(mean2) - - let taxa_name = if i < taxa_names.length() { taxa_names[i] } else { "Taxon" + i.to_string() } + + let taxa_name = if i < taxa_names.length() { + taxa_names[i] + } else { + "Taxon" + i.to_string() + } taxon_names.push(taxa_name) - + i = i + 1 } - + // BH correction let adj_p = micro_bh_correction(p_values) - + // Build results let mut i = 0 while i < otu_table.length() { - results.push(DAResult::new( - taxon_names[i], - log2_fcs[i], - p_values[i], - adj_p[i], - mean1s[i], - mean2s[i], - )) + results.push( + DAResult::new( + taxon_names[i], + log2_fcs[i], + p_values[i], + adj_p[i], + mean1s[i], + mean2s[i], + ), + ) i = i + 1 } - + results } @@ -795,6 +818,7 @@ pub fn differential_abundance( // Helper functions // ============================================================ +///| fn sum_double(arr : Array[Double]) -> Double { let mut sum = 0.0 let mut i = 0 @@ -805,6 +829,7 @@ fn sum_double(arr : Array[Double]) -> Double { sum } +///| fn mean_double(arr : Array[Double]) -> Double { if arr.length() == 0 { return 0.0 @@ -812,6 +837,7 @@ fn mean_double(arr : Array[Double]) -> Double { sum_double(arr) / arr.length().to_double() } +///| fn variance_double(arr : Array[Double]) -> Double { if arr.length() <= 1 { return 0.0 @@ -826,45 +852,55 @@ fn variance_double(arr : Array[Double]) -> Double { sum_sq / (arr.length().to_double() - 1.0) } +///| fn micro_welch_t_test(x : Array[Double], y : Array[Double]) -> Double { let n1 = x.length().to_double() let n2 = y.length().to_double() - + if n1 < 2.0 || n2 < 2.0 { return 1.0 } - + let mean_x = mean_double(x) let mean_y = mean_double(y) let var_x = variance_double(x) let var_y = variance_double(y) - + if var_x == 0.0 && var_y == 0.0 { return 1.0 } - + let se = (var_x / n1 + var_y / n2).sqrt() if se == 0.0 { return 1.0 } - + let t_stat = (mean_x - mean_y) / se - + // Welch-Satterthwaite degrees of freedom let df_num = (var_x / n1 + var_y / n2) * (var_x / n1 + var_y / n2) - let df_den = (var_x / n1) * (var_x / n1) / (n1 - 1.0) + (var_y / n2) * (var_y / n2) / (n2 - 1.0) + let df_den = var_x / n1 * (var_x / n1) / (n1 - 1.0) + + var_y / n2 * (var_y / n2) / (n2 - 1.0) let df = if df_den > 0.0 { df_num / df_den } else { n1 + n2 - 2.0 } - + // Approximate p-value using normal approximation (two-tailed) let p_val = 2.0 * (1.0 - micro_normal_cdf(t_stat.abs())) - if p_val < 0.0 { 0.0 } else if p_val > 1.0 { 1.0 } else { p_val } + if p_val < 0.0 { + 0.0 + } else if p_val > 1.0 { + 1.0 + } else { + p_val + } } +///| fn micro_normal_cdf(x : Double) -> Double { // Approximation of standard normal CDF 0.5 * (1.0 + micro_erf(x / 1.4142135623730951)) } +///| fn micro_erf(x : Double) -> Double { // Abramowitz and Stegun approximation for erf let a1 = 0.254829592 @@ -873,26 +909,30 @@ fn micro_erf(x : Double) -> Double { let a4 = -1.453152027 let a5 = 1.061405429 let p = 0.3275911 - + let sign = if x < 0.0 { -1.0 } else { 1.0 } let x_abs = x.abs() - + let t = 1.0 / (1.0 + p * x_abs) - let y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * @math.exp(-x_abs * x_abs) - + let y = 1.0 - + ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * + t * + @math.exp(-x_abs * x_abs) + sign * y } +///| fn micro_bh_correction(p_values : Array[Double]) -> Array[Double] { let n = p_values.length() if n == 0 { return Array::new() } - + // Create indexed pairs let indices : Array[Int] = Array::new() let sorted_p : Array[Double] = Array::new() - + // Simple bubble sort (since n may be small) let mut i = 0 while i < n { @@ -900,7 +940,7 @@ fn micro_bh_correction(p_values : Array[Double]) -> Array[Double] { sorted_p.push(p_values[i]) i = i + 1 } - + // Sort let mut i = 0 while i < n - 1 { @@ -910,7 +950,7 @@ fn micro_bh_correction(p_values : Array[Double]) -> Array[Double] { let temp_p = sorted_p[j] sorted_p[j] = sorted_p[j + 1] sorted_p[j + 1] = temp_p - + let temp_idx = indices[j] indices[j] = indices[j + 1] indices[j + 1] = temp_idx @@ -919,7 +959,7 @@ fn micro_bh_correction(p_values : Array[Double]) -> Array[Double] { } i = i + 1 } - + // BH adjustment let adj_sorted : Array[Double] = Array::new() let mut min_adj = 1.0 @@ -936,7 +976,7 @@ fn micro_bh_correction(p_values : Array[Double]) -> Array[Double] { } i = i - 1 } - + // Reverse back let adj_sorted_rev : Array[Double] = Array::new() let mut i = adj_sorted.length() - 1 @@ -944,7 +984,7 @@ fn micro_bh_correction(p_values : Array[Double]) -> Array[Double] { adj_sorted_rev.push(adj_sorted[i]) i = i - 1 } - + // Map back to original order let result : Array[Double] = Array::new() let mut i = 0 @@ -952,13 +992,13 @@ fn micro_bh_correction(p_values : Array[Double]) -> Array[Double] { result.push(0.0) i = i + 1 } - + let mut i = 0 while i < n { result[indices[i]] = adj_sorted_rev[i] i = i + 1 } - + result } @@ -967,47 +1007,47 @@ fn micro_bh_correction(p_values : Array[Double]) -> Array[Double] { pub fn create_example_otu_table() -> Array[Array[Double]] { // 10 taxa, 6 samples (3 control, 3 treatment) let otu_table : Array[Array[Double]] = Array::new() - + // Taxon 1: High in control let t1 : Array[Double] = [120.0, 150.0, 130.0, 30.0, 25.0, 35.0] otu_table.push(t1) - + // Taxon 2: High in treatment let t2 : Array[Double] = [20.0, 25.0, 15.0, 100.0, 120.0, 110.0] otu_table.push(t2) - + // Taxon 3: Moderate in both let t3 : Array[Double] = [50.0, 55.0, 48.0, 52.0, 47.0, 53.0] otu_table.push(t3) - + // Taxon 4: Low abundance let t4 : Array[Double] = [5.0, 3.0, 7.0, 4.0, 6.0, 2.0] otu_table.push(t4) - + // Taxon 5: Rare (singletons) let t5 : Array[Double] = [1.0, 0.0, 1.0, 0.0, 1.0, 0.0] otu_table.push(t5) - + // Taxon 6 let t6 : Array[Double] = [80.0, 75.0, 85.0, 60.0, 65.0, 55.0] otu_table.push(t6) - + // Taxon 7 let t7 : Array[Double] = [30.0, 35.0, 28.0, 45.0, 50.0, 40.0] otu_table.push(t7) - + // Taxon 8 let t8 : Array[Double] = [10.0, 12.0, 8.0, 15.0, 18.0, 14.0] otu_table.push(t8) - + // Taxon 9: Doubletons let t9 : Array[Double] = [2.0, 2.0, 0.0, 0.0, 2.0, 2.0] otu_table.push(t9) - + // Taxon 10 let t10 : Array[Double] = [45.0, 50.0, 42.0, 55.0, 60.0, 48.0] otu_table.push(t10) - + otu_table } @@ -1015,16 +1055,8 @@ pub fn create_example_otu_table() -> Array[Array[Double]] { /// Get example taxa names. pub fn get_example_taxa_names() -> Array[String] { let names : Array[String] = [ - "Bacteroides", - "Prevotella", - "Firmicutes_g1", - "Actinobacteria_g1", - "Rare_taxon_1", - "Lachnospiraceae", - "Ruminococcaceae", - "Bifidobacterium", - "Rare_taxon_2", - "Escherichia", + "Bacteroides", "Prevotella", "Firmicutes_g1", "Actinobacteria_g1", "Rare_taxon_1", + "Lachnospiraceae", "Ruminococcaceae", "Bifidobacterium", "Rare_taxon_2", "Escherichia", ] names } diff --git a/src/missmethyl.mbt b/src/missmethyl.mbt index f1a82390..0ba6731d 100644 --- a/src/missmethyl.mbt +++ b/src/missmethyl.mbt @@ -46,12 +46,8 @@ fn mm_variance(arr : Array[Double], mean : Double) -> Double { /// Lanczos approximation for ln(gamma(x)). fn mm_lgamma(x : Double) -> Double { let cof = [ - 76.18009172947146, - -86.50532032941677, - 24.01409824083091, - -1.231739572450155, - 0.001208650973866179, - -0.000005395239384953, + 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, + 0.001208650973866179, -0.000005395239384953, ] let mut x1 = x let mut tmp = x1 + 5.5 @@ -291,14 +287,7 @@ pub fn MmProbeAnnotation::new( island_relation : String, probe_type : String, ) -> MmProbeAnnotation { - MmProbeAnnotation::{ - probe_id, - chr, - pos, - gene, - island_relation, - probe_type, - } + MmProbeAnnotation::{ probe_id, chr, pos, gene, island_relation, probe_type } } ///| @@ -327,9 +316,7 @@ pub fn MmProbeAnnotation::gene(self : MmProbeAnnotation) -> String { ///| /// CpG island relation ("Island"/"Shore"/"Shelf"/"OpenSea"). -pub fn MmProbeAnnotation::island_relation( - self : MmProbeAnnotation, -) -> String { +pub fn MmProbeAnnotation::island_relation(self : MmProbeAnnotation) -> String { self.island_relation } @@ -650,19 +637,9 @@ pub fn mm_t_test( let num = (term1 + term2) * (term1 + term2) let den = term1 * term1 / (n1 - 1).to_double() + term2 * term2 / (n2 - 1).to_double() - let df = if den > 0.0 { - num / den - } else { - (n1 + n2 - 2).to_double() - } + let df = if den > 0.0 { num / den } else { (n1 + n2 - 2).to_double() } let p = 2.0 * (1.0 - mm_t_cdf(t.abs(), df)) - let pc = if p < 0.0 { - 0.0 - } else if p > 1.0 { - 1.0 - } else { - p - } + let pc = if p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p } (t, pc) } @@ -704,11 +681,7 @@ pub fn mm_bh_correct(p_values : Array[Double]) -> Array[Double] { if val < min_adj { min_adj = val } - adj[indices[i]] = if min_adj > 1.0 { - 1.0 - } else { - min_adj - } + adj[indices[i]] = if min_adj > 1.0 { 1.0 } else { min_adj } i = i - 1 } adj @@ -731,11 +704,7 @@ pub fn mm_fisher_exact(a : Int, b : Int, c : Int, d : Int) -> Double { } else { 0 } - let max_a = if row1_total < col1_total { - row1_total - } else { - col1_total - } + let max_a = if row1_total < col1_total { row1_total } else { col1_total } let mut p_value = 0.0 let mut i = min_a while i <= max_a { @@ -833,7 +802,8 @@ pub fn mm_map_probes_to_genes( ) -> Array[String] { let result : Array[String] = Array::new() for ann in annotations { - if mm_contains(probes, ann.probe_id()) && not(mm_contains(result, ann.gene())) { + if mm_contains(probes, ann.probe_id()) && + not(mm_contains(result, ann.gene())) { result.push(ann.gene()) } } @@ -848,7 +818,8 @@ fn mm_probes_for_genes( ) -> Array[String] { let result : Array[String] = Array::new() for ann in annotations { - if mm_contains(genes, ann.gene()) && not(mm_contains(result, ann.probe_id())) { + if mm_contains(genes, ann.gene()) && + not(mm_contains(result, ann.probe_id())) { result.push(ann.probe_id()) } } @@ -1101,22 +1072,32 @@ pub fn mm_sample_annotations() -> Array[MmProbeAnnotation] { result.push(MmProbeAnnotation::new("cg001", "chr1", 1000, "A", "Island", "I")) result.push(MmProbeAnnotation::new("cg002", "chr1", 2000, "B", "Shore", "I")) result.push(MmProbeAnnotation::new("cg003", "chr1", 3000, "C", "Shelf", "II")) - result.push(MmProbeAnnotation::new("cg004", "chr1", 4000, "D", "OpenSea", "I")) - result.push(MmProbeAnnotation::new("cg005", "chr1", 5000, "E", "Island", "II")) + result.push( + MmProbeAnnotation::new("cg004", "chr1", 4000, "D", "OpenSea", "I"), + ) + result.push( + MmProbeAnnotation::new("cg005", "chr1", 5000, "E", "Island", "II"), + ) result.push(MmProbeAnnotation::new("cg006", "chr1", 6000, "F", "Shore", "I")) result.push(MmProbeAnnotation::new("cg007", "chr1", 7000, "G", "Shelf", "II")) result.push(MmProbeAnnotation::new("cg008", "chr2", 2000, "H", "Island", "I")) result.push(MmProbeAnnotation::new("cg009", "chr2", 2500, "A", "Shore", "II")) result.push(MmProbeAnnotation::new("cg010", "chr2", 3000, "B", "Shelf", "I")) - result.push(MmProbeAnnotation::new("cg011", "chr2", 3500, "C", "OpenSea", "II")) + result.push( + MmProbeAnnotation::new("cg011", "chr2", 3500, "C", "OpenSea", "II"), + ) result.push(MmProbeAnnotation::new("cg012", "chr2", 4000, "D", "Island", "I")) result.push(MmProbeAnnotation::new("cg013", "chr2", 5000, "E", "Shore", "II")) result.push(MmProbeAnnotation::new("cg014", "chr2", 6000, "F", "Shelf", "I")) - result.push(MmProbeAnnotation::new("cg015", "chr3", 3000, "G", "OpenSea", "II")) + result.push( + MmProbeAnnotation::new("cg015", "chr3", 3000, "G", "OpenSea", "II"), + ) result.push(MmProbeAnnotation::new("cg016", "chr3", 4000, "H", "Island", "I")) result.push(MmProbeAnnotation::new("cg017", "chr3", 5000, "A", "Shore", "II")) result.push(MmProbeAnnotation::new("cg018", "chr3", 6000, "B", "Shelf", "I")) - result.push(MmProbeAnnotation::new("cg019", "chr3", 7000, "C", "OpenSea", "II")) + result.push( + MmProbeAnnotation::new("cg019", "chr3", 7000, "C", "OpenSea", "II"), + ) result.push(MmProbeAnnotation::new("cg020", "chr3", 8000, "D", "Island", "I")) result } diff --git a/src/mix_omics.mbt b/src/mix_omics.mbt index 1dab5059..b7962e03 100644 --- a/src/mix_omics.mbt +++ b/src/mix_omics.mbt @@ -247,8 +247,10 @@ pub fn soft_threshold(x : Double, lambda : Double) -> Double { let shrunk = abs_x - lambda if shrunk <= 0.0 { 0.0 + } else if x < 0.0 { + -shrunk } else { - if x < 0.0 { -shrunk } else { shrunk } + shrunk } } @@ -269,7 +271,13 @@ pub fn select_top_k(values : Array[Double], k : Int) -> Array[Int] { } indexed.sort_by(fn(a : (Int, Double), b : (Int, Double)) -> Int { - if a.1 > b.1 { -1 } else if a.1 < b.1 { 1 } else { 0 } + if a.1 > b.1 { + -1 + } else if a.1 < b.1 { + 1 + } else { + 0 + } }) let result = Array::make(effective_k, 0) @@ -389,11 +397,7 @@ pub fn run_pls( ) -> PLSResult { let n = x_data.length() let p = if n > 0 { x_data[0].length() } else { 0 } - let q = if y_data.length() > 0 { - y_data[0].length() - } else { - 0 - } + let q = if y_data.length() > 0 { y_data[0].length() } else { 0 } let ncomp = if options.ncomp > n { n @@ -652,11 +656,7 @@ pub fn run_spls( ) -> SPLSResult { let n = x_data.length() let p = if n > 0 { x_data[0].length() } else { 0 } - let q = if y_data.length() > 0 { - y_data[0].length() - } else { - 0 - } + let q = if y_data.length() > 0 { y_data[0].length() } else { 0 } let ncomp = if options.ncomp > n { n @@ -807,13 +807,7 @@ pub fn spls_component( Array[Bool], ) { let (t_init, u_init, w_x_init, w_y_init) = nipals_pls( - x, - y, - n, - p, - q, - max_iter, - tol, + x, y, n, p, q, max_iter, tol, ) let x_loadings = mix_mat_t_vec(x, n, p, t_init) @@ -1072,7 +1066,7 @@ pub fn diablo_component( let w = Array::make(pb, 0.0) for j = 0; j < pb; j = j + 1 { - w[j] = 1.0 / (pb.to_double()).sqrt() + w[j] = 1.0 / pb.to_double().sqrt() } block_weights.push(w) @@ -1085,7 +1079,12 @@ pub fn diablo_component( } for b = 0; b < n_blocks; b = b + 1 { - block_scores[b] = mix_mat_vec(blocks[b], n, block_sizes[b], block_weights[b]) + block_scores[b] = mix_mat_vec( + blocks[b], + n, + block_sizes[b], + block_weights[b], + ) } let mut global_score = Array::make(n, 0.0) @@ -1156,7 +1155,11 @@ pub fn diablo_component( for c = 0; c < n_blocks; c = c + 1 { dw = dw + sum_row[c] } - if dw > 0.0 { dw } else { 1.0 } + if dw > 0.0 { + dw + } else { + 1.0 + } } else { 1.0 } @@ -1221,4 +1224,4 @@ pub fn diablo_update_scores( result.push(mix_mat_vec(blocks[b], n, pb, weights[b])) } result -} \ No newline at end of file +} diff --git a/src/mmcifio.mbt b/src/mmcifio.mbt index eda856f8..0ff9fb77 100644 --- a/src/mmcifio.mbt +++ b/src/mmcifio.mbt @@ -297,12 +297,9 @@ pub fn mmcif_sample_structure() -> Structure { bfactor=20.0, element="O", ) - let ala = Residue::new( - resname="ALA", - chainid='A', - resseq=1, - atoms=[ala_n, ala_ca, ala_c, ala_o], - ) + let ala = Residue::new(resname="ALA", chainid='A', resseq=1, atoms=[ + ala_n, ala_ca, ala_c, ala_o, + ]) let gly_n = Atom::new( name="N", coord=Vector3::new(3.0, 2.5, 5.0), @@ -343,12 +340,9 @@ pub fn mmcif_sample_structure() -> Structure { bfactor=20.0, element="O", ) - let gly = Residue::new( - resname="GLY", - chainid='A', - resseq=2, - atoms=[gly_n, gly_ca, gly_c, gly_o], - ) + let gly = Residue::new(resname="GLY", chainid='A', resseq=2, atoms=[ + gly_n, gly_ca, gly_c, gly_o, + ]) let chain = Chain::new(id='A', residues=[ala, gly]) let model = Model::new(id=1, chains=[chain]) Structure::new(id="1ABC", models=[model]) diff --git a/src/mmtf.mbt b/src/mmtf.mbt index f5691d50..65072dc5 100644 --- a/src/mmtf.mbt +++ b/src/mmtf.mbt @@ -87,14 +87,14 @@ pub struct MmtfAtom { pub fn MmtfAtom::new( name~ : String, serial~ : Int, - alt_loc_id~ : String = "", + alt_loc_id? : String = "", x~ : Double, y~ : Double, z~ : Double, - occupancy~ : Double = 1.0, - b_factor~ : Double = 0.0, - element~ : String = "", - charge~ : Int = 0, + occupancy? : Double = 1.0, + b_factor? : Double = 0.0, + element? : String = "", + charge? : Int = 0, ) -> MmtfAtom { MmtfAtom::{ name, @@ -128,11 +128,11 @@ pub struct MmtfGroup { pub fn MmtfGroup::new( group_name~ : String, group_number~ : Int, - insertion_code~ : String = "", - group_type~ : String = "", - single_letter_code~ : String = "", - sec_struct~ : MmtfSecStruct = MmtfSecUndefined, - sequence_index~ : Int = -1, + insertion_code? : String = "", + group_type? : String = "", + single_letter_code? : String = "", + sec_struct? : MmtfSecStruct = MmtfSecUndefined, + sequence_index? : Int = -1, ) -> MmtfGroup { MmtfGroup::{ group_name, @@ -175,8 +175,8 @@ pub struct MmtfChain { ///| /// Construct an MmtfChain. pub fn MmtfChain::new( - chain_id~ : String = "", - chain_name~ : String = "", + chain_id? : String = "", + chain_name? : String = "", ) -> MmtfChain { MmtfChain::{ chain_id, chain_name, groups: [] } } @@ -208,7 +208,7 @@ pub struct MmtfModel { ///| /// Construct an MmtfModel. -pub fn MmtfModel::new(model_id~ : Int = 0) -> MmtfModel { +pub fn MmtfModel::new(model_id? : Int = 0) -> MmtfModel { MmtfModel::{ model_id, chains: [] } } @@ -276,17 +276,12 @@ pub struct MmtfEntity { ///| /// Construct an MmtfEntity. pub fn MmtfEntity::new( - chain_indices~ : Array[Int] = [], - sequence~ : String = "", - description~ : String = "", - entity_type~ : MmtfEntityType = MmtfEntityUndefined, + chain_indices? : Array[Int] = [], + sequence? : String = "", + description? : String = "", + entity_type? : MmtfEntityType = MmtfEntityUndefined, ) -> MmtfEntity { - MmtfEntity::{ - chain_indices, - sequence, - description, - entity_type, - } + MmtfEntity::{ chain_indices, sequence, description, entity_type } } ///| @@ -325,10 +320,7 @@ pub struct MmtfXtalInfo { ///| /// Construct an MmtfXtalInfo with defaults. pub fn MmtfXtalInfo::new() -> MmtfXtalInfo { - MmtfXtalInfo::{ - space_group: "", - unit_cell: Array::make(6, 0.0), - } + MmtfXtalInfo::{ space_group: "", unit_cell: Array::make(6, 0.0) } } ///| @@ -344,7 +336,7 @@ pub struct MmtfBond { pub fn MmtfBond::new( atom_index1~ : Int, atom_index2~ : Int, - bond_order~ : Int = 1, + bond_order? : Int = 1, ) -> MmtfBond { MmtfBond::{ atom_index1, atom_index2, bond_order } } @@ -382,9 +374,9 @@ pub struct MmtfGroupType { ///| /// Construct an MmtfGroupType. pub fn MmtfGroupType::new( - group_name~ : String = "", - chem_comp_type~ : String = "", - single_letter_code~ : String = "", + group_name? : String = "", + chem_comp_type? : String = "", + single_letter_code? : String = "", ) -> MmtfGroupType { MmtfGroupType::{ group_name, @@ -437,7 +429,10 @@ pub fn MmtfStructure::get_xtal_info(self : MmtfStructure) -> MmtfXtalInfo { ///| /// Set the crystallographic info. -pub fn MmtfStructure::set_xtal_info(self : MmtfStructure, x : MmtfXtalInfo) -> Unit { +pub fn MmtfStructure::set_xtal_info( + self : MmtfStructure, + x : MmtfXtalInfo, +) -> Unit { self.xtal_info = x } @@ -621,7 +616,7 @@ fn mmtf_read_f32_be(data : Array[Int], offset : Int) -> Double { 0.0 } else if exponent == 0 { // Denormalized number - sign * (mantissa.to_double()) * pow2(-149) + sign * mantissa.to_double() * pow2(-149) } else if exponent == 255 { // Infinity or NaN - return 0.0 for simplicity 0.0 @@ -638,7 +633,7 @@ fn pow2(n : Int) -> Double { result = result * 2.0 } } else { - for _ in 0..<(-n) { + for _ in 0..<-n { result = result / 2.0 } } @@ -678,7 +673,11 @@ fn mmtf_write_f32_be(data : Array[Int], offset : Int, value : Double) -> Unit { ///| /// Convert ASCII byte array slice to a string. -fn mmtf_ascii_to_string(data : Array[Int], offset : Int, length : Int) -> String { +fn mmtf_ascii_to_string( + data : Array[Int], + offset : Int, + length : Int, +) -> String { let sb = StringBuilder::new() for i in 0.. String { let xtal = structure.get_xtal_info() sb.write_string("MMTF\n") sb.write_string("structureId=" + structure.structure_id + "\n") - sb.write_string("totalNumBonds=" + structure.total_num_bonds.to_string() + "\n") - sb.write_string("totalNumAtoms=" + structure.total_num_atoms.to_string() + "\n") - sb.write_string("totalNumGroups=" + structure.total_num_groups.to_string() + "\n") - sb.write_string("totalNumChains=" + structure.total_num_chains.to_string() + "\n") - sb.write_string("totalNumModels=" + structure.total_num_models.to_string() + "\n") + sb.write_string( + "totalNumBonds=" + structure.total_num_bonds.to_string() + "\n", + ) + sb.write_string( + "totalNumAtoms=" + structure.total_num_atoms.to_string() + "\n", + ) + sb.write_string( + "totalNumGroups=" + structure.total_num_groups.to_string() + "\n", + ) + sb.write_string( + "totalNumChains=" + structure.total_num_chains.to_string() + "\n", + ) + sb.write_string( + "totalNumModels=" + structure.total_num_models.to_string() + "\n", + ) // Header sb.write_string("title=" + header.title + "\n") sb.write_string("depositionDate=" + header.deposition_date + "\n") @@ -877,7 +886,15 @@ pub fn mmtf_write_text(structure : MmtfStructure) -> String { sb.write_string("MODEL " + mi.to_string() + "\n") for ci in 0.. MmtfStructure { } else if trimmed.starts_with("releaseDate=") { header.release_date = trimmed.substring(start=12) } else if trimmed.starts_with("resolution=") { - header.resolution = parse_double(trimmed.substring(start=11)).unwrap_or(0.0) + header.resolution = parse_double(trimmed.substring(start=11)).unwrap_or( + 0.0, + ) } else if trimmed.starts_with("rWork=") { header.r_work = parse_double(trimmed.substring(start=6)).unwrap_or(0.0) } else if trimmed.starts_with("rFree=") { @@ -998,11 +1017,16 @@ pub fn mmtf_read_text(text : String) -> MmtfStructure { Some(m) => structure.add_model(m) None => () } - let parts = trimmed.split(" ").to_array().filter(fn(s) -> Bool { - s.length() > 0 - }) - let model_id = if parts.length() >= 2 { parse_int(parts[1].to_string()) } else { 0 } - current_model = Some(MmtfModel::new(model_id=model_id)) + let parts = trimmed + .split(" ") + .to_array() + .filter(fn(s) -> Bool { s.length() > 0 }) + let model_id = if parts.length() >= 2 { + parse_int(parts[1].to_string()) + } else { + 0 + } + current_model = Some(MmtfModel::new(model_id~)) } else if trimmed.starts_with(" CHAIN ") { // Save previous group match current_group { @@ -1023,12 +1047,17 @@ pub fn mmtf_read_text(text : String) -> MmtfStructure { } None => () } - let parts = trimmed.split(" ").to_array().filter(fn(s) -> Bool { - s.length() > 0 - }) + let parts = trimmed + .split(" ") + .to_array() + .filter(fn(s) -> Bool { s.length() > 0 }) let chain_id = if parts.length() >= 3 { parts[2].to_string() } else { "" } - let chain_name = if parts.length() >= 4 { parts[3].to_string() } else { chain_id } - current_chain = Some(MmtfChain::new(chain_id=chain_id, chain_name=chain_name)) + let chain_name = if parts.length() >= 4 { + parts[3].to_string() + } else { + chain_id + } + current_chain = Some(MmtfChain::new(chain_id~, chain_name~)) } else if trimmed.starts_with(" GROUP ") { // Save previous group match current_group { @@ -1039,13 +1068,26 @@ pub fn mmtf_read_text(text : String) -> MmtfStructure { } None => () } - let parts = trimmed.split(" ").to_array().filter(fn(s) -> Bool { - s.length() > 0 - }) - let group_name = if parts.length() >= 2 { parts[1].to_string() } else { "" } - let group_number = if parts.length() >= 3 { parse_int(parts[2].to_string()) } else { 0 } + let parts = trimmed + .split(" ") + .to_array() + .filter(fn(s) -> Bool { s.length() > 0 }) + let group_name = if parts.length() >= 2 { + parts[1].to_string() + } else { + "" + } + let group_number = if parts.length() >= 3 { + parse_int(parts[2].to_string()) + } else { + 0 + } let slc = if parts.length() >= 4 { parts[3].to_string() } else { "" } - let ss_str = if parts.length() >= 5 { parts[4].to_string() } else { "undefined" } + let ss_str = if parts.length() >= 5 { + parts[4].to_string() + } else { + "undefined" + } let ss = match ss_str { "alpha_helix" => MmtfSecAlphaHelix "extended" => MmtfSecExtended @@ -1059,44 +1101,72 @@ pub fn mmtf_read_text(text : String) -> MmtfStructure { } current_group = Some( MmtfGroup::new( - group_name=group_name, - group_number=group_number, + group_name~, + group_number~, single_letter_code=slc, sec_struct=ss, ), ) } else if trimmed.starts_with(" ATOM ") { - let parts = trimmed.split(" ").to_array().filter(fn(s) -> Bool { - s.length() > 0 - }) + let parts = trimmed + .split(" ") + .to_array() + .filter(fn(s) -> Bool { s.length() > 0 }) let name = if parts.length() >= 2 { parts[1].to_string() } else { "" } - let serial = if parts.length() >= 3 { parse_int(parts[2].to_string()) } else { 0 } - let x = if parts.length() >= 4 { parse_double(parts[3].to_string()).unwrap_or(0.0) } else { 0.0 } - let y = if parts.length() >= 5 { parse_double(parts[4].to_string()).unwrap_or(0.0) } else { 0.0 } - let z = if parts.length() >= 6 { parse_double(parts[5].to_string()).unwrap_or(0.0) } else { 0.0 } + let serial = if parts.length() >= 3 { + parse_int(parts[2].to_string()) + } else { + 0 + } + let x = if parts.length() >= 4 { + parse_double(parts[3].to_string()).unwrap_or(0.0) + } else { + 0.0 + } + let y = if parts.length() >= 5 { + parse_double(parts[4].to_string()).unwrap_or(0.0) + } else { + 0.0 + } + let z = if parts.length() >= 6 { + parse_double(parts[5].to_string()).unwrap_or(0.0) + } else { + 0.0 + } let element = if parts.length() >= 7 { parts[6].to_string() } else { "" } - let charge = if parts.length() >= 8 { parse_int(parts[7].to_string()) } else { 0 } - let atom = MmtfAtom::new( - name=name, - serial=serial, - x=x, - y=y, - z=z, - element=element, - charge=charge, - ) + let charge = if parts.length() >= 8 { + parse_int(parts[7].to_string()) + } else { + 0 + } + let atom = MmtfAtom::new(name~, serial~, x~, y~, z~, element~, charge~) match current_group { Some(g) => g.add_atom(atom) None => () } } else if trimmed.starts_with("BOND ") { - let parts = trimmed.split(" ").to_array().filter(fn(s) -> Bool { - s.length() > 0 - }) - let a1 = if parts.length() >= 2 { parse_int(parts[1].to_string()) } else { 0 } - let a2 = if parts.length() >= 3 { parse_int(parts[2].to_string()) } else { 0 } - let order = if parts.length() >= 4 { parse_int(parts[3].to_string()) } else { 1 } - structure.bonds.push(MmtfBond::new(atom_index1=a1, atom_index2=a2, bond_order=order)) + let parts = trimmed + .split(" ") + .to_array() + .filter(fn(s) -> Bool { s.length() > 0 }) + let a1 = if parts.length() >= 2 { + parse_int(parts[1].to_string()) + } else { + 0 + } + let a2 = if parts.length() >= 3 { + parse_int(parts[2].to_string()) + } else { + 0 + } + let order = if parts.length() >= 4 { + parse_int(parts[3].to_string()) + } else { + 1 + } + structure.bonds.push( + MmtfBond::new(atom_index1=a1, atom_index2=a2, bond_order=order), + ) } } // Save final group/chain/model @@ -1274,7 +1344,9 @@ pub fn mmtf_summary(structure : MmtfStructure) -> String { sb.write_string(" Groups: " + structure.count_groups().to_string() + "\n") sb.write_string(" Atoms: " + structure.count_atoms().to_string() + "\n") sb.write_string(" Bonds: " + structure.bonds.length().to_string() + "\n") - sb.write_string(" Entities: " + structure.entities.length().to_string() + "\n") + sb.write_string( + " Entities: " + structure.entities.length().to_string() + "\n", + ) sb.to_string() } @@ -1314,7 +1386,7 @@ pub fn mmtf_to_pdb_structure(mmtf : MmtfStructure) -> Structure { chainid=chain_id, resseq=mmtf_group.group_number, atoms=pdb_atoms, - hetfield=hetfield, + hetfield~, ), ) } diff --git a/src/mofa2.mbt b/src/mofa2.mbt index 84043377..b98a4680 100644 --- a/src/mofa2.mbt +++ b/src/mofa2.mbt @@ -88,13 +88,7 @@ pub fn MofaParams::create( ard_threshold? : Double = 0.01, seed? : Int = 42, ) -> MofaParams { - MofaParams::{ - n_factors: n_factors, - max_iterations: max_iterations, - tolerance: tolerance, - ard_threshold: ard_threshold, - seed: seed, - } + MofaParams::{ n_factors, max_iterations, tolerance, ard_threshold, seed } } ///| @@ -118,7 +112,9 @@ pub fn MofaResult::get_factors(self : MofaResult) -> Array[Array[Double]] { ///| /// Get loading matrices (views x features x factors). -pub fn MofaResult::get_loadings(self : MofaResult) -> Array[Array[Array[Double]]] { +pub fn MofaResult::get_loadings( + self : MofaResult, +) -> Array[Array[Array[Double]]] { self.loadings } @@ -168,19 +164,23 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { active_factors: 0, } } - + let n_samples = views[0].data.length() let n_factors = params.n_factors - + // Center each view let centered_views : Array[Array[Array[Double]]] = Array::new() { let mut v = 0 while v < n_views { let view_data = views[v].data - let n_features = if view_data.length() > 0 { view_data[0].length() } else { 0 } + let n_features = if view_data.length() > 0 { + view_data[0].length() + } else { + 0 + } let centered : Array[Array[Double]] = Array::new() - + // Compute feature means let means : Array[Double] = Array::make(n_features, 0.0) let mut s = 0 @@ -199,7 +199,7 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { f = f + 1 } } - + // Center data s = 0 while s < n_samples { @@ -216,10 +216,10 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { v = v + 1 } } - + // Initialize factors Z (samples x factors) let mut z = mofa_init_factors(n_samples, n_factors, params.seed) - + // Initialize loadings W (views x features x factors) with small random values let loadings : Array[Array[Array[Double]]] = Array::new() { @@ -230,11 +230,13 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { } else { 0 } - loadings.push(mofa_init_loadings(d, n_factors, params.seed + (v + 1) * 7919)) + loadings.push( + mofa_init_loadings(d, n_factors, params.seed + (v + 1) * 7919), + ) v = v + 1 } } - + // Initialize sigma (noise variance per view, feature) let sigma : Array[Array[Double]] = Array::new() { @@ -250,21 +252,23 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { v = v + 1 } } - + // ARD precision parameters let mut alpha : Array[Double] = Array::make(n_factors, 1.0) let mu = 0.0 let tau = 1.0 - + // EM iterations let mut iter = 0 let mut converged = false let mut prev_elbo = -1.0e30 - + while iter < params.max_iterations { // E-step: Update factors Z - z = mofa_update_factors(centered_views, loadings, sigma, z, n_factors, n_views, n_samples) - + z = mofa_update_factors( + centered_views, loadings, sigma, z, n_factors, n_views, n_samples, + ) + // M-step: Update loadings W { let mut v = 0 @@ -275,13 +279,18 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { 0 } loadings[v] = mofa_update_loadings( - centered_views[v], z, loadings[v], sigma[v], - n_features, n_factors, n_samples + centered_views[v], + z, + loadings[v], + sigma[v], + n_features, + n_factors, + n_samples, ) v = v + 1 } } - + // M-step: Update sigma { let mut v = 0 @@ -292,18 +301,25 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { 0 } sigma[v] = mofa_update_sigma( - centered_views[v], z, loadings[v], sigma[v], - n_features, n_factors, n_samples + centered_views[v], + z, + loadings[v], + sigma[v], + n_features, + n_factors, + n_samples, ) v = v + 1 } } - + // M-step: Update ARD alpha alpha = mofa_update_alpha(loadings, n_factors, n_views, mu, tau) - + // Compute ELBO (approximate) - let elbo = mofa_compute_elbo(centered_views, z, loadings, sigma, alpha, n_factors, n_views, n_samples) + let elbo = mofa_compute_elbo( + centered_views, z, loadings, sigma, alpha, n_factors, n_views, n_samples, + ) let delta = (elbo - prev_elbo).abs() if delta < params.tolerance { converged = true @@ -312,15 +328,15 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { prev_elbo = elbo iter = iter + 1 } - + // Compute variance explained let (factor_vars, view_vars) = mofa_compute_variance_explained( - centered_views, z, loadings, n_factors, n_views, n_samples + centered_views, z, loadings, n_factors, n_views, n_samples, ) - + // Count active factors let active = mofa_count_active_factors(factor_vars, params.ard_threshold) - + MofaResult::{ factors: z, loadings, @@ -335,7 +351,11 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { ///| /// Initialize factor matrix with small random values. -fn mofa_init_factors(n_samples : Int, n_factors : Int, seed : Int) -> Array[Array[Double]] { +fn mofa_init_factors( + n_samples : Int, + n_factors : Int, + seed : Int, +) -> Array[Array[Double]] { let z : Array[Array[Double]] = Array::new() let mut s = seed let mut i = 0 @@ -356,7 +376,11 @@ fn mofa_init_factors(n_samples : Int, n_factors : Int, seed : Int) -> Array[Arra ///| /// Initialize loading matrix with small random values. -fn mofa_init_loadings(n_features : Int, n_factors : Int, seed : Int) -> Array[Array[Double]] { +fn mofa_init_loadings( + n_features : Int, + n_factors : Int, + seed : Int, +) -> Array[Array[Double]] { let w : Array[Array[Double]] = Array::new() let mut s = seed let mut f = 0 @@ -404,13 +428,18 @@ fn mofa_update_factors( let mut mean_accum = 0.0 let mut v = 0 while v < n_views { - let n_features = if views[v].length() > 0 { views[v][0].length() } else { 0 } + let n_features = if views[v].length() > 0 { + views[v][0].length() + } else { + 0 + } let mut f = 0 while f < n_features { let w_fk = loadings[v][f][k] let s2 = if sigma[v][f] > 1.0e-10 { sigma[v][f] } else { 1.0e-10 } precision = precision + w_fk * w_fk / s2 - let residual = views[v][i][f] - mofa_prediction_single(loadings, z, i, f, k, v) + let residual = views[v][i][f] - + mofa_prediction_single(loadings, z, i, f, k, v) mean_accum = mean_accum + w_fk * residual / s2 f = f + 1 } @@ -427,6 +456,7 @@ fn mofa_update_factors( new_z } +///| fn mofa_prediction_single( loadings : Array[Array[Array[Double]]], z : Array[Array[Double]], @@ -475,7 +505,11 @@ fn mofa_update_loadings( i = i + 1 } denominator = denominator + 0.01 * s2 - row[k] = if denominator > 1.0e-10 { numerator / denominator } else { w[f][k] } + row[k] = if denominator > 1.0e-10 { + numerator / denominator + } else { + w[f][k] + } k = k + 1 } new_w.push(row) @@ -484,6 +518,7 @@ fn mofa_update_loadings( new_w } +///| fn mofa_prediction_loadings( w : Array[Array[Double]], z : Array[Array[Double]], @@ -530,7 +565,11 @@ fn mofa_update_sigma( ss = ss + residual * residual i = i + 1 } - new_sigma[f] = if n_samples > 0 { ss / n_samples.to_double() } else { sigma_view[f] } + new_sigma[f] = if n_samples > 0 { + ss / n_samples.to_double() + } else { + sigma_view[f] + } if new_sigma[f] < 1.0e-6 { new_sigma[f] = 1.0e-6 } @@ -564,7 +603,11 @@ fn mofa_update_alpha( total_features = total_features + n_features v = v + 1 } - let expected = if total_features > 0 { sum_sq / total_features.to_double() } else { 0.0 } + let expected = if total_features > 0 { + sum_sq / total_features.to_double() + } else { + 0.0 + } let prec = if expected > 1.0e-10 { 1.0 / expected } else { 1.0e6 } new_alpha[k] = prec k = k + 1 @@ -587,7 +630,11 @@ fn mofa_compute_elbo( let mut elbo = 0.0 let mut v = 0 while v < n_views { - let n_features = if views[v].length() > 0 { views[v][0].length() } else { 0 } + let n_features = if views[v].length() > 0 { + views[v][0].length() + } else { + 0 + } let mut i = 0 while i < n_samples { let mut f = 0 @@ -600,7 +647,9 @@ fn mofa_compute_elbo( } let s2 = if sigma[v][f] > 1.0e-10 { sigma[v][f] } else { 1.0e-10 } let residual = views[v][i][f] - pred - elbo = elbo - 0.5 * @math.ln(2.0 * 3.14159265 * s2) - residual * residual / (2.0 * s2) + elbo = elbo - + 0.5 * @math.ln(2.0 * 3.14159265 * s2) - + residual * residual / (2.0 * s2) f = f + 1 } i = i + 1 @@ -634,18 +683,29 @@ fn mofa_compute_variance_explained( i = i + 1 } let mean = sum / n_samples.to_double() - let var = if n_samples > 1 { (sum_sq / n_samples.to_double()) - mean * mean } else { 0.0 } + let var = if n_samples > 1 { + sum_sq / n_samples.to_double() - mean * mean + } else { + 0.0 + } factor_vars[k] = if var > 0.0 { var } else { 0.0 } k = k + 1 } } - + // View variance explained by each factor - let view_vars : Array[Array[Double]] = Array::make(n_views, Array::make(n_factors, 0.0)) + let view_vars : Array[Array[Double]] = Array::make( + n_views, + Array::make(n_factors, 0.0), + ) { let mut v = 0 while v < n_views { - let n_features = if views[v].length() > 0 { views[v][0].length() } else { 0 } + let n_features = if views[v].length() > 0 { + views[v][0].length() + } else { + 0 + } let mut k = 0 while k < n_factors { let mut total_var = 0.0 @@ -661,7 +721,7 @@ fn mofa_compute_variance_explained( v = v + 1 } } - + // Normalize view_vars to percentages { let mut v = 0 @@ -677,13 +737,16 @@ fn mofa_compute_variance_explained( v = v + 1 } } - + (factor_vars, view_vars) } ///| /// Count active factors based on variance threshold. -fn mofa_count_active_factors(factor_vars : Array[Double], threshold : Double) -> Int { +fn mofa_count_active_factors( + factor_vars : Array[Double], + threshold : Double, +) -> Int { let mut count = 0 for v in factor_vars { if v > threshold { @@ -693,6 +756,7 @@ fn mofa_count_active_factors(factor_vars : Array[Double], threshold : Double) -> count } +///| fn mofa_sum_double(arr : Array[Double]) -> Double { let mut s = 0.0 for v in arr { @@ -703,13 +767,10 @@ fn mofa_sum_double(arr : Array[Double]) -> Double { ///| /// Create example data for MOFA2 testing. -pub fn mofa_create_example( - n_samples : Int, - n_factors : Int, -) -> Array[MofaView] { +pub fn mofa_create_example(n_samples : Int, n_factors : Int) -> Array[MofaView] { let mut rng = 42 let views : Array[MofaView] = Array::new() - + // View 1: RNA-seq (high-dimensional) { let n_features = 50 @@ -743,9 +804,11 @@ pub fn mofa_create_example( feature_names.push("gene_" + f.to_string()) f = f + 1 } - views.push(MofaView::new("rna", data, feature_names, [], view_type="gaussian")) + views.push( + MofaView::new("rna", data, feature_names, [], view_type="gaussian"), + ) } - + // View 2: ATAC-seq (lower-dimensional, shares some factors) { let n_features = 30 @@ -779,9 +842,11 @@ pub fn mofa_create_example( feature_names.push("peak_" + f.to_string()) f = f + 1 } - views.push(MofaView::new("atac", data, feature_names, [], view_type="gaussian")) + views.push( + MofaView::new("atac", data, feature_names, [], view_type="gaussian"), + ) } - + // Set sample names { let mut v = 0 @@ -792,10 +857,16 @@ pub fn mofa_create_example( sample_names.push("sample_" + s.to_string()) s = s + 1 } - views[v] = MofaView::new(views[v].view_name, views[v].data, views[v].feature_names, sample_names, view_type=views[v].view_type) + views[v] = MofaView::new( + views[v].view_name, + views[v].data, + views[v].feature_names, + sample_names, + view_type=views[v].view_type, + ) v = v + 1 } } - + views } diff --git a/src/mol_wt.mbt b/src/mol_wt.mbt index 001c9fa7..c278d925 100644 --- a/src/mol_wt.mbt +++ b/src/mol_wt.mbt @@ -125,7 +125,7 @@ pub fn mol_weight_dna(sequence : String) -> Double { i = i + 1 } // Subtract water for each phosphodiester bond (n-1 bonds) - total - ((n - 1).to_double() * 18.01524) + total - (n - 1).to_double() * 18.01524 } ///| @@ -153,7 +153,7 @@ pub fn mol_weight_protein(sequence : String) -> Double { i = i + 1 } // Subtract water for each peptide bond (n-1 bonds) - total - ((n - 1).to_double() * 18.01524) + total - (n - 1).to_double() * 18.01524 } ///| @@ -181,7 +181,9 @@ pub fn extinction_coefficient_280(sequence : String) -> Double { i = i + 1 } let n_cystine = n_cys / 2 - (n_trp.to_double() * 5500.0) + (n_tyr.to_double() * 1490.0) + (n_cystine.to_double() * 125.0) + n_trp.to_double() * 5500.0 + + n_tyr.to_double() * 1490.0 + + n_cystine.to_double() * 125.0 } ///| @@ -248,7 +250,11 @@ pub fn mol_wt_isoelectric_point(sequence : String) -> Double { let pK_R = 12.48 // Arg // Simple approximation let pos_charges = 1.0 + n_lys.to_double() + n_arg.to_double() - let neg_charges = 1.0 + n_asp.to_double() + n_glu.to_double() + n_cys.to_double() + n_tyr.to_double() + let neg_charges = 1.0 + + n_asp.to_double() + + n_glu.to_double() + + n_cys.to_double() + + n_tyr.to_double() if pos_charges + neg_charges < 1.0e-10 { return 7.0 } @@ -266,28 +272,58 @@ pub fn mol_wt_isoelectric_point(sequence : String) -> Double { ///| /// Compute the difference in molecular weight between two sequences. -pub fn mol_weight_diff(seq1 : String, seq2 : String, is_protein? : Bool = false) -> Double { - let mw1 = if is_protein { mol_weight_protein(seq1) } else { mol_weight_dna(seq1) } - let mw2 = if is_protein { mol_weight_protein(seq2) } else { mol_weight_dna(seq2) } +pub fn mol_weight_diff( + seq1 : String, + seq2 : String, + is_protein? : Bool = false, +) -> Double { + let mw1 = if is_protein { + mol_weight_protein(seq1) + } else { + mol_weight_dna(seq1) + } + let mw2 = if is_protein { + mol_weight_protein(seq2) + } else { + mol_weight_dna(seq2) + } mw1 - mw2 } ///| /// Generate a summary string for a sequence's molecular properties. -pub fn mol_weight_summary(sequence : String, is_protein? : Bool = false) -> String { +pub fn mol_weight_summary( + sequence : String, + is_protein? : Bool = false, +) -> String { let length = sequence.length() - let mw = if is_protein { mol_weight_protein(sequence) } else { mol_weight_dna(sequence) } + let mw = if is_protein { + mol_weight_protein(sequence) + } else { + mol_weight_dna(sequence) + } let ext = if is_protein { extinction_coefficient_280(sequence) } else { 0.0 } let pI = if is_protein { mol_wt_isoelectric_point(sequence) } else { 0.0 } let type_str = if is_protein { "Protein" } else { "DNA" } "MolWt Summary:\n" + - " Type: " + type_str + "\n" + - " Length: " + length.to_string() + "\n" + - " Molecular Weight: " + mw.to_string() + " Da\n" + + " Type: " + + type_str + + "\n" + + " Length: " + + length.to_string() + + "\n" + + " Molecular Weight: " + + mw.to_string() + + " Da\n" + (if is_protein { - " Extinction Coefficient (280): " + ext.to_string() + " M^-1 cm^-1\n" + - " Isoelectric Point: " + pI.to_string() - } else { "" }) + " Extinction Coefficient (280): " + + ext.to_string() + + " M^-1 cm^-1\n" + + " Isoelectric Point: " + + pI.to_string() + } else { + "" + }) } ///| diff --git a/src/monocle3.mbt b/src/monocle3.mbt index 91a49066..54188813 100644 --- a/src/monocle3.mbt +++ b/src/monocle3.mbt @@ -415,7 +415,11 @@ pub fn reduce_dimension( let umap_result = umap(pca_data, num_dimensions) - let reduced_dims = merge_reduced_dimensions(cds.reduced_dimensions, "UMAP", umap_result) + let reduced_dims = merge_reduced_dimensions( + cds.reduced_dimensions, + "UMAP", + umap_result, + ) return CellDataSet::{ counts: cds.counts, @@ -447,10 +451,13 @@ fn merge_reduced_dimensions( } i = i + 1 } - + let result_len = if has_name { n } else { n + 1 } - let result : Array[(String, Array[Array[Double]])] = Array::make(result_len, ("".to_string(), Array::new())) - + let result : Array[(String, Array[Array[Double]])] = Array::make( + result_len, + ("".to_string(), Array::new()), + ) + let mut j = 0 i = 0 while i < n { @@ -462,11 +469,11 @@ fn merge_reduced_dimensions( j = j + 1 i = i + 1 } - + if !has_name { result[j] = (name.to_string(), data) } - + result } @@ -685,13 +692,12 @@ pub fn learn_graph(cds : CellDataSet) -> CellDataSet { let reduced = reduce_dimension(cds, "UMAP", 2) match get_reduced_dimension(reduced, "UMAP") { Some(d) => d - None => { + None => if reduced.normalized.length() > 0 { reduced.normalized } else { return cds } - } } } } @@ -911,7 +917,8 @@ pub fn fit_models( let mut j = 0 while j < n_cells { if cds.pseudotime[j] >= 0.0 { - let expr = if j < cds.normalized.length() && idx < cds.normalized[j].length() { + let expr = if j < cds.normalized.length() && + idx < cds.normalized[j].length() { cds.normalized[j][idx] } else { 0.0 @@ -983,11 +990,11 @@ pub fn BranchPoint::new( ///| pub fn find_branch_points(cds : CellDataSet) -> Array[BranchPoint] { let branch_points : Array[BranchPoint] = Array::new() - + if cds.principal_graph.length() < 3 { return branch_points } - + let mut i = 0 while i < cds.principal_graph.length() { let edges = cds.principal_graph[i].2 @@ -995,7 +1002,7 @@ pub fn find_branch_points(cds : CellDataSet) -> Array[BranchPoint] { let position = cds.principal_graph[i].1 let branch1 : Array[Int] = Array::new() let branch2 : Array[Int] = Array::new() - + let mut j = 0 while j < cds.cell_partitions.length() { if cds.cell_partitions[j] == edges[0] { @@ -1005,12 +1012,12 @@ pub fn find_branch_points(cds : CellDataSet) -> Array[BranchPoint] { } j = j + 1 } - + branch_points.push(BranchPoint::new(i, position, [(branch1, branch2)])) } i = i + 1 } - + branch_points } @@ -1023,59 +1030,67 @@ pub fn differential_gene_test_branches( let n_genes = gene_names.length() let branch1 = branch_point.branch_cells[0].0 let branch2 = branch_point.branch_cells[0].1 - + let gene_result : Array[String] = Array::new() let pseudotime_result : Array[Double] = Array::new() let q_value_result : Array[Double] = Array::new() let trend_statistic_result : Array[Double] = Array::new() - + let mut i = 0 while i < n_genes { let gene_idx = find_gene_index(cds.gene_names, gene_names[i]) if gene_idx.is_some() { let idx = gene_idx.unwrap() - + let mut sum_branch1 = 0.0 let mut sum_branch2 = 0.0 let mut n_branch1 = 0 let mut n_branch2 = 0 - + let mut j = 0 while j < branch1.length() { let cell_idx = branch1[j] - if cell_idx < cds.normalized.length() && idx < cds.normalized[cell_idx].length() { + if cell_idx < cds.normalized.length() && + idx < cds.normalized[cell_idx].length() { sum_branch1 = sum_branch1 + cds.normalized[cell_idx][idx] n_branch1 = n_branch1 + 1 } j = j + 1 } - + let mut k = 0 while k < branch2.length() { let cell_idx = branch2[k] - if cell_idx < cds.normalized.length() && idx < cds.normalized[cell_idx].length() { + if cell_idx < cds.normalized.length() && + idx < cds.normalized[cell_idx].length() { sum_branch2 = sum_branch2 + cds.normalized[cell_idx][idx] n_branch2 = n_branch2 + 1 } k = k + 1 } - + if n_branch1 > 0 && n_branch2 > 0 { let mean_branch1 = sum_branch1 / n_branch1.to_double() let mean_branch2 = sum_branch2 / n_branch2.to_double() let diff = mean_branch1 - mean_branch2 - + gene_result.push(gene_names[i]) pseudotime_result.push(0.5) - - let q_val = if diff.abs() > 0.5 { 0.001 } else if diff.abs() > 0.2 { 0.05 } else { 1.0 } + + let q_val = if diff.abs() > 0.5 { + 0.001 + } else if diff.abs() > 0.2 { + 0.05 + } else { + 1.0 + } q_value_result.push(q_val) trend_statistic_result.push(diff) } } i = i + 1 } - + DiffExprResult::{ gene: gene_result, pseudotime: pseudotime_result, @@ -1140,4 +1155,4 @@ pub fn create_example_monocle_data() -> ( } (counts, gene_names, cell_names) -} \ No newline at end of file +} diff --git a/src/motif_scan.mbt b/src/motif_scan.mbt index 525f69b9..3dcf9bfc 100644 --- a/src/motif_scan.mbt +++ b/src/motif_scan.mbt @@ -101,8 +101,8 @@ pub fn motif_scan_pwm_from_counts( let n_bases = counts.length() if n_bases == 0 { return PositionWeightMatrix::new( - motif_id=motif_id, - motif_name=motif_name, + motif_id~, + motif_name~, matrix=[], background=[0.25, 0.25, 0.25, 0.25], strand="+-", @@ -121,9 +121,9 @@ pub fn motif_scan_pwm_from_counts( } } PositionWeightMatrix::new( - motif_id=motif_id, - motif_name=motif_name, - matrix=matrix, + motif_id~, + motif_name~, + matrix~, background=[0.25, 0.25, 0.25, 0.25], strand="+-", ) @@ -200,7 +200,11 @@ pub fn compute_score(pssm : MotifScanPSSM, sequence : String) -> Double { if motif_len == 0 { return 0.0 } - let n = if sequence.length() < motif_len { sequence.length() } else { motif_len } + let n = if sequence.length() < motif_len { + sequence.length() + } else { + motif_len + } let mut score = 0.0 for i in 0.. Double { let bin_width = range / nbins.to_double() let mut dist = Array::make(nbins, 0.0) // Initialize: before any position the cumulative score is 0.0 with probability 1. - let init_bin = ms_clamp_bin(((0.0 - min_s) / bin_width).floor().to_int(), nbins) + let init_bin = ms_clamp_bin( + ((0.0 - min_s) / bin_width).floor().to_int(), + nbins, + ) dist[init_bin] = 1.0 // Convolve the per-position score distributions. for i in 0.. Double { dist = new_dist } // Sum probabilities for scores >= observed (from observed's bin upward). - let obs_bin = ms_clamp_bin(((score - min_s) / bin_width).floor().to_int(), nbins) + let obs_bin = ms_clamp_bin( + ((score - min_s) / bin_width).floor().to_int(), + nbins, + ) let mut pval = 0.0 for b_idx in obs_bin.. String { s = s + "Total matches: " + matches.length().to_string() + "\n" if matches.length() > 0 { s = s + "\nMatches:\n" - s = s + "motif_id\tsequence_id\tstart\tend\tstrand\tscore\tp-value\tmatched_sequence\n" + s = s + + "motif_id\tsequence_id\tstart\tend\tstrand\tscore\tp-value\tmatched_sequence\n" for i in 0.. PositionWeightMatrix { PositionWeightMatrix::new( motif_id="M0001", motif_name="SampleTF", - matrix=matrix, + matrix~, background=[0.25, 0.25, 0.25, 0.25], strand="+-", ) diff --git a/src/motifs.mbt b/src/motifs.mbt index dd644383..6348f0a2 100644 --- a/src/motifs.mbt +++ b/src/motifs.mbt @@ -308,7 +308,8 @@ pub fn meme_to_motif(meme_content : String) -> Motif { let probs = sites[pos].split(" ").to_array() for alpha_idx = 0; alpha_idx < 4; alpha_idx = alpha_idx + 1 { if alpha_idx < probs.length() { - pwm[pos][alpha_idx] = match parse_float_str(probs[alpha_idx].to_owned()) { + pwm[pos][alpha_idx] = match + parse_float_str(probs[alpha_idx].to_owned()) { Some(v) => v None => 0.0 } @@ -373,8 +374,10 @@ pub fn align_motifs(motif1 : Motif, motif2 : Motif) -> Double { /// Returns an array of information content values for each position. pub fn motif_per_position_ic(motif : Motif) -> Array[Double] { let result : Array[Double] = Array::new() - if motif.pwm.length() == 0 { return result } - + if motif.pwm.length() == 0 { + return result + } + let background = 0.25 let mut pos = 0 while pos < motif.pwm.length() { @@ -410,15 +413,19 @@ pub fn motif_total_ic(motif : Motif) -> Double { ///| /// Generate a sequence logo data from aligned sequences. /// Returns an array of (position, letter, frequency, information_content). -pub fn generate_logo_data(sequences : Array[String]) -> Array[(Int, String, Double, Double)] { - if sequences.length() == 0 { return Array::new() } - +pub fn generate_logo_data( + sequences : Array[String], +) -> Array[(Int, String, Double, Double)] { + if sequences.length() == 0 { + return Array::new() + } + let width = sequences[0].length() let logo_data : Array[(Int, String, Double, Double)] = Array::new() - + let alphabet = ["A", "C", "G", "T"] let n = sequences.length().to_double() - + let mut pos = 0 while pos < width { let counts = Map([], capacity=4) @@ -428,33 +435,33 @@ pub fn generate_logo_data(sequences : Array[String]) -> Array[(Int, String, Doub counts.set(base, counts.get(base).unwrap_or(0) + 1) i = i + 1 } - + let background = 0.25 let mut ic = 0.0 let mut max_freq = 0.0 let mut max_base = "" - + let mut ai = 0 while ai < alphabet.length() { let base = alphabet[ai] let count = counts.get(base).unwrap_or(0).to_double() let freq = count / n - + if freq > max_freq { max_freq = freq max_base = base } - + if freq > 0.0 { - ic = ic + freq * (log2_val(freq / background)) + ic = ic + freq * log2_val(freq / background) } ai = ai + 1 } - + logo_data.push((pos, max_base, max_freq, ic)) pos = pos + 1 } - + logo_data } @@ -464,21 +471,21 @@ pub fn motif_pearson_correlation(motif1 : Motif, motif2 : Motif) -> Double { if motif1.pwm.length() == 0 || motif2.pwm.length() == 0 { return 0.0 } - + let min_len = if motif1.pwm.length() < motif2.pwm.length() { motif1.pwm.length() } else { motif2.pwm.length() } - + let n = (min_len * motif1.alphabet.length()).to_double() - + let mut sum_x = 0.0 let mut sum_y = 0.0 let mut sum_xy = 0.0 let mut sum_x2 = 0.0 let mut sum_y2 = 0.0 - + let mut pos = 0 while pos < min_len { let row1 = motif1.pwm[pos] @@ -496,11 +503,11 @@ pub fn motif_pearson_correlation(motif1 : Motif, motif2 : Motif) -> Double { } pos = pos + 1 } - + let numerator = n * sum_xy - sum_x * sum_x let denom1 = sqrt_val(n * sum_x2 - sum_x * sum_x) let denom2 = sqrt_val(n * sum_y2 - sum_y * sum_y) - + if denom1 * denom2 > 0.0 { numerator / (denom1 * denom2) } else { @@ -517,24 +524,28 @@ pub fn motif_enrichment( background? : Array[String] = [], ) -> Array[(String, Double, Double)] { let results : Array[(String, Double, Double)] = Array::new() - + // Count motif occurrences in target sequences let motif_counts : Map[String, Int] = Map([], capacity=motifs.length()) let seq_lengths : Map[String, Double] = Map([], capacity=motifs.length()) - + let mut mi = 0 while mi < motifs.length() { let motif = motifs[mi] let width = motif.pwm.length() let mut total_sites = 0 - + let mut si = 0 while si < sequences.length() { let seq = sequences[si] let mut pos = 0 while pos <= seq.length() - width { let subseq = seq[pos:pos + width].to_owned() - let score = score_sequence(pssm_from_pwm(motif.pwm, [0.25, 0.25, 0.25, 0.25]), subseq, motif.alphabet) + let score = score_sequence( + pssm_from_pwm(motif.pwm, [0.25, 0.25, 0.25, 0.25]), + subseq, + motif.alphabet, + ) if score > 0.0 { total_sites = total_sites + 1 } @@ -542,12 +553,12 @@ pub fn motif_enrichment( } si = si + 1 } - + motif_counts.set(motif.name, total_sites) seq_lengths.set(motif.name, sequences.length().to_double()) mi = mi + 1 } - + // Calculate enrichment score (simplified) let names = motif_counts.keys().collect() let mut ni = 0 @@ -555,31 +566,33 @@ pub fn motif_enrichment( let name = names[ni] let count = motif_counts[name] let total_seqs = sequences.length().to_double() - + let frequency = if total_seqs > 0.0 { count.to_double() / total_seqs } else { 0.0 } - + let enrichment = if frequency > 0.0 && total_seqs > 0.0 { log2_val(frequency * total_seqs) } else { 0.0 } - + results.push((name, count.to_double(), enrichment)) ni = ni + 1 } - + results } ///| /// Calculate the GC content of a motif (average GC frequency). pub fn motif_gc_content(motif : Motif) -> Double { - if motif.pwm.length() == 0 { return 0.0 } - + if motif.pwm.length() == 0 { + return 0.0 + } + let mut gc_sum = 0.0 let mut count = 0 let mut pos = 0 @@ -591,7 +604,7 @@ pub fn motif_gc_content(motif : Motif) -> Double { count = count + 1 pos = pos + 1 } - + if count > 0 { gc_sum / count.to_double() } else { @@ -607,9 +620,9 @@ pub fn generate_random_motif( gc_content? : Double = 0.5, ) -> Motif { let pwm = Array::make(length, Array::make(4, 0.0)) - + let at_content = 1.0 - gc_content - + let mut pos = 0 while pos < length { let row = Array::make(4, 0.0) @@ -617,16 +630,16 @@ pub fn generate_random_motif( // C, G get equal share of GC content let at_share = at_content / 2.0 let gc_share = gc_content / 2.0 - + row[0] = at_share // A row[1] = gc_share // C row[2] = gc_share // G row[3] = at_share // T - + pwm[pos] = row pos = pos + 1 } - + Motif::new(name, pwm, dna_alphabet, []) } @@ -640,15 +653,15 @@ fn parse_float_str(s : String) -> Double? { let mut sign = 1.0 let mut i = 0 let zero = '0'.to_int() - + if s.unsafe_get(0).to_int() == '-'.to_int() { sign = -1.0 i = 1 } - + let mut has_dot = false let mut decimal_place = 1.0 - + while i < s.length() { let c = s.unsafe_get(i).to_int() if c == '.'.to_int() { @@ -665,14 +678,16 @@ fn parse_float_str(s : String) -> Double? { } i = i + 1 } - + Some(result * sign / decimal_place) } ///| /// Calculate the square root of a number. fn sqrt_val(x : Double) -> Double { - if x <= 0.0 { return 0.0 } + if x <= 0.0 { + return 0.0 + } let mut guess = x / 2.0 let mut i = 0 while i < 100 { @@ -685,7 +700,9 @@ fn sqrt_val(x : Double) -> Double { ///| /// Calculate log2 of a number. fn log2_val(x : Double) -> Double { - if x <= 0.0 { return 0.0 } + if x <= 0.0 { + return 0.0 + } // Use natural log conversion: log2(x) = ln(x) / ln(2) let ln2 = 0.6931471805599453 let mut result = 0.0 diff --git a/src/motifs_advanced.mbt b/src/motifs_advanced.mbt index 9d8c70d5..f06ac56e 100644 --- a/src/motifs_advanced.mbt +++ b/src/motifs_advanced.mbt @@ -132,15 +132,15 @@ fn adv_parse_float(s : String) -> Double? { let mut sign = 1.0 let mut i = 0 let zero = '0'.to_int() - + if s.unsafe_get(0).to_int() == '-'.to_int() { sign = -1.0 i = 1 } - + let mut has_dot = false let mut decimal_place = 1.0 - + while i < s.length() { let c = s.unsafe_get(i).to_int() if c == '.'.to_int() { @@ -157,13 +157,15 @@ fn adv_parse_float(s : String) -> Double? { } i = i + 1 } - + Some(result * sign / decimal_place) } ///| fn adv_log2(x : Double) -> Double { - if x <= 0.0 { return 0.0 } + if x <= 0.0 { + return 0.0 + } let ln2 = 0.6931471805599453 let term = (x - 1.0) / (x + 1.0) let term2 = term * term @@ -252,7 +254,7 @@ pub fn parse_jaspar_pfm(content : String) -> Array[JasparMotif] { let motifs : Array[JasparMotif] = Array::new() let lines_view = content.split("\n") let lines = lines_view.to_array() - + let mut i = 0 while i < lines.length() { let line_view = lines[i].trim() @@ -269,12 +271,12 @@ pub fn parse_jaspar_pfm(content : String) -> Array[JasparMotif] { if parts.length() >= 2 { name = parts[1].trim().to_owned() } - + let mut a_counts : Array[Double] = Array::new() let mut c_counts : Array[Double] = Array::new() let mut g_counts : Array[Double] = Array::new() let mut t_counts : Array[Double] = Array::new() - + let mut j = i + 1 while j < lines.length() && !lines[j].trim().has_prefix(">") { let row_view = lines[j].trim() @@ -293,7 +295,7 @@ pub fn parse_jaspar_pfm(content : String) -> Array[JasparMotif] { } j = j + 1 } - + let width = a_counts.length() if width > 0 { let pwm = Array::make(width, Array::make(4, 0.0)) @@ -303,7 +305,7 @@ pub fn parse_jaspar_pfm(content : String) -> Array[JasparMotif] { pwm[pos][2] = g_counts[pos] pwm[pos][3] = t_counts[pos] } - + let motif = JasparMotif::new( matrix_id, name, @@ -318,13 +320,13 @@ pub fn parse_jaspar_pfm(content : String) -> Array[JasparMotif] { ) motifs.push(motif) } - + i = j } else { i = i + 1 } } - + motifs } @@ -332,14 +334,14 @@ pub fn parse_jaspar_pfm(content : String) -> Array[JasparMotif] { fn parse_jaspar_row(line : String) -> (String, Array[Double]) { let counts : Array[Double] = Array::new() let mut base = "" - + if line.length() >= 1 { base = line[0:1].to_owned().to_upper() } - + let start_bracket = adv_index_of(line, "[") let end_bracket = adv_index_of(line, "]") - + if start_bracket >= 0 && end_bracket > start_bracket { let numbers_str = line[start_bracket + 1:end_bracket].to_owned() let number_parts = split_whitespace(numbers_str) @@ -368,7 +370,7 @@ fn parse_jaspar_row(line : String) -> (String, Array[Double]) { } } } - + (base, counts) } @@ -384,7 +386,7 @@ pub fn jaspar_pfm_to_pwm( let width = pfm.length() let alphabet_size = pfm[0].length() let pwm = Array::make(width, Array::make(alphabet_size, 0.0)) - + for pos = 0; pos < width; pos = pos + 1 { let row = pfm[pos] let mut total = 0.0 @@ -392,12 +394,12 @@ pub fn jaspar_pfm_to_pwm( total = total + row[i] } let norm_total = total + pseudocount * alphabet_size.to_double() - + for alpha_idx = 0; alpha_idx < alphabet_size; alpha_idx = alpha_idx + 1 { pwm[pos][alpha_idx] = (row[alpha_idx] + pseudocount) / norm_total } } - + pwm } @@ -411,7 +413,7 @@ pub fn parse_transfac(content : String) -> Array[TransfacMotif] { let motifs : Array[TransfacMotif] = Array::new() let lines_view = content.split("\n") let lines = lines_view.to_array() - + let mut i = 0 while i < lines.length() { let line_view = lines[i].trim() @@ -424,12 +426,12 @@ pub fn parse_transfac(content : String) -> Array[TransfacMotif] { let matrix_rows : Array[Array[Double]] = Array::new() let binding_sites : Array[String] = Array::new() let mut in_matrix = false - + let mut j = i + 1 while j < lines.length() && !lines[j].trim().has_prefix("//") { let row_view = lines[j].trim() let row_line = row_view.to_owned() - + if row_line.has_prefix("ID ") { id = row_line[2:].trim().to_owned() } else if row_line.has_prefix("NA ") { @@ -452,10 +454,10 @@ pub fn parse_transfac(content : String) -> Array[TransfacMotif] { matrix_rows.push(row) } } - + j = j + 1 } - + if matrix_rows.length() > 0 { let width = matrix_rows.length() let pwm = Array::make(width, Array::make(4, 0.0)) @@ -465,25 +467,19 @@ pub fn parse_transfac(content : String) -> Array[TransfacMotif] { pwm[pos][2] = matrix_rows[pos][2] pwm[pos][3] = matrix_rows[pos][3] } - + let motif = TransfacMotif::new( - accession, - id, - name, - description, - pwm, - dna_alphabet_jaspar, - binding_sites, + accession, id, name, description, pwm, dna_alphabet_jaspar, binding_sites, ) motifs.push(motif) } - + i = j + 1 } else { i = i + 1 } } - + motifs } @@ -500,44 +496,44 @@ pub fn optimal_motif_alignment( if motif1_pwm.length() == 0 || motif2_pwm.length() == 0 { return MotifAlignmentResult::new(0.0, 0, "+", 0) } - + let len1 = motif1_pwm.length() let len2 = motif2_pwm.length() let mut best_score = -1.0 let mut best_offset = 0 let mut best_strand = "+" let mut best_aligned_len = 0 - + for offset = -(len2 - 1); offset < len1; offset = offset + 1 { let (score, aligned_len) = calculate_alignment_score( - motif1_pwm, - motif2_pwm, - offset, + motif1_pwm, motif2_pwm, offset, ) - if score > best_score || (score == best_score && aligned_len > best_aligned_len) { + if score > best_score || + (score == best_score && aligned_len > best_aligned_len) { best_score = score best_offset = offset best_strand = "+" best_aligned_len = aligned_len } } - + let rev_motif2 = reverse_complement_pwm(motif2_pwm) for offset = -(len2 - 1); offset < len1; offset = offset + 1 { let (score, aligned_len) = calculate_alignment_score( - motif1_pwm, - rev_motif2, - offset, + motif1_pwm, rev_motif2, offset, ) - if score > best_score || (score == best_score && aligned_len > best_aligned_len) { + if score > best_score || + (score == best_score && aligned_len > best_aligned_len) { best_score = score best_offset = offset best_strand = "-" best_aligned_len = aligned_len } } - - MotifAlignmentResult::new(best_score, best_offset, best_strand, best_aligned_len) + + MotifAlignmentResult::new( + best_score, best_offset, best_strand, best_aligned_len, + ) } ///| @@ -550,10 +546,10 @@ fn calculate_alignment_score( let len2 = pwm2.length() let mut score = 0.0 let mut aligned_len = 0 - + let start1 = if offset >= 0 { offset } else { 0 } let start2 = if offset >= 0 { 0 } else { -offset } - + let mut i = start1 let mut j = start2 while i < len1 && j < len2 { @@ -568,11 +564,11 @@ fn calculate_alignment_score( i = i + 1 j = j + 1 } - + if aligned_len > 0 { score = score / aligned_len.to_double() } - + (score, aligned_len) } @@ -584,7 +580,7 @@ fn reverse_complement_pwm(pwm : Array[Array[Double]]) -> Array[Array[Double]] { } let alphabet_size = pwm[0].length() let rev_pwm = Array::make(width, Array::make(alphabet_size, 0.0)) - + for pos = 0; pos < width; pos = pos + 1 { let orig_pos = width - 1 - pos if alphabet_size == 4 { @@ -598,7 +594,7 @@ fn reverse_complement_pwm(pwm : Array[Array[Double]]) -> Array[Array[Double]] { } } } - + rev_pwm } @@ -611,13 +607,13 @@ pub fn motif_kl_divergence( if pwm1.length() == 0 || pwm2.length() == 0 { return 0.0 } - + let min_len = if pwm1.length() < pwm2.length() { pwm1.length() } else { pwm2.length() } - + let mut total_kl = 0.0 for pos = 0; pos < min_len; pos = pos + 1 { let row1 = pwm1[pos] @@ -632,7 +628,7 @@ pub fn motif_kl_divergence( } total_kl = total_kl + pos_kl } - + total_kl / min_len.to_double() } @@ -645,24 +641,24 @@ pub fn motif_js_divergence( if pwm1.length() == 0 || pwm2.length() == 0 { return 0.0 } - + let min_len = if pwm1.length() < pwm2.length() { pwm1.length() } else { pwm2.length() } - + let mut total_js = 0.0 for pos = 0; pos < min_len; pos = pos + 1 { let row1 = pwm1[pos] let row2 = pwm2[pos] let alphabet_size = row1.length() let m_row = Array::make(alphabet_size, 0.0) - + for k = 0; k < alphabet_size; k = k + 1 { m_row[k] = (row1[k] + row2[k]) / 2.0 } - + let mut kl1 = 0.0 let mut kl2 = 0.0 for k = 0; k < alphabet_size; k = k + 1 { @@ -673,10 +669,10 @@ pub fn motif_js_divergence( kl2 = kl2 + row2[k] * adv_log2(row2[k] / m_row[k]) } } - + total_js = total_js + (kl1 + kl2) / 2.0 } - + total_js / min_len.to_double() } @@ -695,7 +691,7 @@ pub fn cluster_motifs( if n == 0 { return [] } - + let similarity_matrix = Array::make(n, Array::make(n, 0.0)) for i = 0; i < n; i = i + 1 { for j = 0; j < n; j = j + 1 { @@ -709,15 +705,15 @@ pub fn cluster_motifs( } } } - + let clusters : Array[MotifCluster] = Array::new() let assigned = Array::make(n, false) - + for i = 0; i < n; i = i + 1 { if !assigned[i] { let cluster_members : Array[String] = Array::new() let cluster_indices : Array[Int] = Array::new() - + for j = i; j < n; j = j + 1 { if !assigned[j] { let mut all_similar = true @@ -733,7 +729,7 @@ pub fn cluster_motifs( } } } - + let mut best_rep_idx = 0 let mut best_avg_sim = 0.0 for k = 0; k < cluster_indices.length(); k = k + 1 { @@ -748,7 +744,7 @@ pub fn cluster_motifs( best_rep_idx = k } } - + let cluster = MotifCluster::new( clusters.length(), cluster_members, @@ -758,7 +754,7 @@ pub fn cluster_motifs( clusters.push(cluster) } } - + clusters } @@ -797,53 +793,58 @@ pub fn motif_gc_content_adv(pwm : Array[Array[Double]]) -> Double { ///| /// Shuffle the columns of a PWM to create a randomized control motif. -pub fn shuffle_motif_columns(pwm : Array[Array[Double]]) -> Array[Array[Double]] { +pub fn shuffle_motif_columns( + pwm : Array[Array[Double]], +) -> Array[Array[Double]] { let width = pwm.length() if width == 0 { return [] } let alphabet_size = pwm[0].length() - + let indices = Array::make(width, 0) for i = 0; i < width; i = i + 1 { indices[i] = i } - + for i = width - 1; i > 0; i = i - 1 { let j = (i * 7 + 3) % (i + 1) let temp = indices[i] indices[i] = indices[j] indices[j] = temp } - + let shuffled = Array::make(width, Array::make(alphabet_size, 0.0)) for i = 0; i < width; i = i + 1 { shuffled[i] = pwm[indices[i]].copy() } - + shuffled } ///| /// Create a motif with randomized nucleotide frequencies for each position. -pub fn randomize_motif(width : Int, alphabet_size : Int) -> Array[Array[Double]] { +pub fn randomize_motif( + width : Int, + alphabet_size : Int, +) -> Array[Array[Double]] { let pwm = Array::make(width, Array::make(alphabet_size, 0.0)) - + for pos = 0; pos < width; pos = pos + 1 { let row : Array[Double] = Array::new() let mut total = 0.0 - + for i = 0; i < alphabet_size; i = i + 1 { let val = adv_sin((pos * 17 + i * 31).to_double()).abs() + 0.1 row.push(val) total = total + val } - + for i = 0; i < alphabet_size; i = i + 1 { pwm[pos][i] = row[i] / total } } - + pwm } @@ -854,7 +855,7 @@ fn adv_sin(x : Double) -> Double { let mut sign = 1.0 let mut factorial = 1.0 let mut power = x - + let n = 15 let mut i = 0 while i < n { @@ -864,7 +865,7 @@ fn adv_sin(x : Double) -> Double { factorial = factorial * (2 * i + 2).to_double() * (2 * i + 3).to_double() i = i + 1 } - + result } @@ -882,21 +883,17 @@ pub fn pwm_to_transfac( if pwm.length() == 0 { return "" } - + let mut result = "AC " + accession + "\n" result = result + "ID " + name + "\n" result = result + "NA " + name + "\n" result = result + "DE " + name + " matrix\n" result = result + "P0 A C G T\n" - + for pos = 0; pos < pwm.length(); pos = pos + 1 { let row = pwm[pos] - let pos_str = if pos < 10 { - "0" + pos.to_string() - } else { - pos.to_string() - } - + let pos_str = if pos < 10 { "0" + pos.to_string() } else { pos.to_string() } + let mut row_str = pos_str + " " for k = 0; k < row.length(); k = k + 1 { let val_str = row[k].to_string() @@ -915,10 +912,10 @@ pub fn pwm_to_transfac( } result = result + row_str + "\n" } - + result = result + "XX\n" result = result + "//\n" - + result } @@ -932,10 +929,10 @@ pub fn pwm_to_jaspar( if pwm.length() == 0 { return "" } - + let width = pwm.length() let mut result = ">" + matrix_id + " " + name + "\n" - + let bases = ["A", "C", "G", "T"] for b = 0; b < 4; b = b + 1 { let mut values_str = bases[b] + " [ " @@ -947,6 +944,6 @@ pub fn pwm_to_jaspar( values_str = values_str + "]\n" result = result + values_str } - + result } diff --git a/src/ms_core_utils.mbt b/src/ms_core_utils.mbt index 7fb66819..314c11c1 100644 --- a/src/ms_core_utils.mbt +++ b/src/ms_core_utils.mbt @@ -130,7 +130,7 @@ pub fn mc_refine_centroids( let hi = if p + half_window >= n { n - 1 } else { p + half_window } let mut sum_mz = 0.0 let mut sum_int = 0.0 - for i in lo..=hi { + for i in lo..<=hi { let w = intensity[i] if w > 0.0 { sum_mz = sum_mz + mz[i] * w @@ -206,11 +206,7 @@ pub fn mc_join_peaks( let mut best_d = 1.0e300 for j in 0..= n { n - 1 } else { i + half_window } let mut s = 0.0 let mut cnt = 0 - for j in lo..=hi { + for j in lo..<=hi { s = s + values[j] cnt = cnt + 1 } @@ -292,7 +288,7 @@ pub fn mc_smooth_savitzky_golay( let mut t1 = 0.0 let mut t2 = 0.0 let center = (lo + hi).to_double() / 2.0 - for j in lo..=hi { + for j in lo..<=hi { let x = j.to_double() - center let y = values[j] let x2 = x * x @@ -310,13 +306,15 @@ pub fn mc_smooth_savitzky_golay( // | s1 s2 s3 | |b| = |t1| // | s2 s3 s4 | |c| |t2| // We only need a. Using Cramer's rule: - let det = s0 * (s2 * s4 - s3 * s3) - s1 * (s1 * s4 - s2 * s3) + + let det = s0 * (s2 * s4 - s3 * s3) - + s1 * (s1 * s4 - s2 * s3) + s2 * (s1 * s3 - s2 * s2) if det.abs() < 1.0e-15 { out[i] = values[i] continue } - let det_a = t0 * (s2 * s4 - s3 * s3) - s1 * (t1 * s4 - t2 * s3) + + let det_a = t0 * (s2 * s4 - s3 * s3) - + s1 * (t1 * s4 - t2 * s3) + s2 * (t1 * s3 - t2 * s2) out[i] = det_a / det } @@ -514,6 +512,7 @@ pub fn mc_dot(a : Array[Double], b : Array[Double]) -> Double { /// - "mean": replace with the row mean of non-missing values /// - "median": replace with the row median of non-missing values /// - "knn": K-nearest-neighbors imputation (k=5 default) + ///| /// Check if a value is NaN (missing). pub fn mc_is_missing(v : Double) -> Bool { @@ -738,9 +737,7 @@ pub fn mc_median_polish( /// and MAD (median absolute deviation). /// /// For each column, returns the median of values across rows. -pub fn mc_robust_summary( - matrix : Array[Array[Double]], -) -> Array[Double] { +pub fn mc_robust_summary(matrix : Array[Array[Double]]) -> Array[Double] { let n = matrix.length() if n == 0 { return [] @@ -775,7 +772,10 @@ pub fn mc_mad(values : Array[Double]) -> Double { ///| /// Check if a peak list is valid: m/z values must be strictly increasing /// and all intensities non-negative. -pub fn mc_valid_peak_list(mz : Array[Double], intensity : Array[Double]) -> Bool { +pub fn mc_valid_peak_list( + mz : Array[Double], + intensity : Array[Double], +) -> Bool { if mz.length() != intensity.length() { return false } diff --git a/src/msnbase.mbt b/src/msnbase.mbt index 7b95f515..dea2b624 100644 --- a/src/msnbase.mbt +++ b/src/msnbase.mbt @@ -30,15 +30,21 @@ pub enum MSLevel { ///| /// Create MS1 level. -pub fn ms_level_ms1() -> MSLevel { MSLevel::MS1 } +pub fn ms_level_ms1() -> MSLevel { + MSLevel::MS1 +} ///| /// Create MS2 level. -pub fn ms_level_ms2() -> MSLevel { MSLevel::MS2 } +pub fn ms_level_ms2() -> MSLevel { + MSLevel::MS2 +} ///| /// Create MSn level with specific n. -pub fn ms_level_msn(n : Int) -> MSLevel { MSLevel::MSn(n) } +pub fn ms_level_msn(n : Int) -> MSLevel { + MSLevel::MSn(n) +} ///| /// Ionization mode. @@ -50,17 +56,21 @@ pub enum Polarity { ///| /// Create positive polarity. -pub fn polarity_positive() -> Polarity { Polarity::Positive } +pub fn polarity_positive() -> Polarity { + Polarity::Positive +} ///| /// Create negative polarity. -pub fn polarity_negative() -> Polarity { Polarity::Negative } +pub fn polarity_negative() -> Polarity { + Polarity::Negative +} ///| /// Spectrum processing step (for tracking). pub struct ProcessingStep { description : String - timestamp : String // simplified timestamp as string + timestamp : String // simplified timestamp as string } ///| @@ -84,11 +94,11 @@ pub struct Spectrum { intensity : Array[Double] ms_level : MSLevel polarity : Polarity - rt : Double // retention time in seconds + rt : Double // retention time in seconds scan_index : Int - precursor_mz : Double // for MS2 - precursor_charge : Int // for MS2 - tic : Double // total ion current + precursor_mz : Double // for MS2 + precursor_charge : Int // for MS2 + tic : Double // total ion current peaks_count : Int mut centroided : Bool processing_log : Array[ProcessingStep] @@ -172,28 +182,40 @@ pub fn Spectrum::with_precursor( ///| /// Get m/z array. -pub fn Spectrum::mz(self : Spectrum) -> Array[Double] { self.mz } +pub fn Spectrum::mz(self : Spectrum) -> Array[Double] { + self.mz +} ///| /// Get intensity array. -pub fn Spectrum::intensity(self : Spectrum) -> Array[Double] { self.intensity } +pub fn Spectrum::intensity(self : Spectrum) -> Array[Double] { + self.intensity +} ///| /// Get number of peaks. -pub fn Spectrum::peaks_count(self : Spectrum) -> Int { self.peaks_count } +pub fn Spectrum::peaks_count(self : Spectrum) -> Int { + self.peaks_count +} ///| /// Get retention time. -pub fn Spectrum::rt(self : Spectrum) -> Double { self.rt } +pub fn Spectrum::rt(self : Spectrum) -> Double { + self.rt +} ///| /// Get total ion current. -pub fn Spectrum::tic(self : Spectrum) -> Double { self.tic } +pub fn Spectrum::tic(self : Spectrum) -> Double { + self.tic +} ///| /// Get the base peak (highest intensity) info: (mz, intensity). pub fn Spectrum::base_peak(self : Spectrum) -> (Double, Double) { - if self.peaks_count == 0 { return (0.0, 0.0) } + if self.peaks_count == 0 { + return (0.0, 0.0) + } let mut max_i = 0 let mut max_v = self.intensity[0] for i in 1.. (Double, Double) { pub fn Spectrum::find_peak( self : Spectrum, target_mz : Double, - ppm~ : Double = 10.0, + ppm? : Double = 10.0, ) -> Int { let n = self.peaks_count - if n == 0 { return -1 } + if n == 0 { + return -1 + } let tolerance = target_mz * ppm / 1000000.0 let mut best_idx = -1 let mut best_diff = 1000000.0 @@ -249,7 +273,9 @@ pub fn Spectrum::filter_mz_range( ///| /// Normalize spectrum intensity by TIC (so sum = 1.0). pub fn Spectrum::normalize_tic(self : Spectrum) -> Spectrum { - if self.tic <= 0.0 { return self } + if self.tic <= 0.0 { + return self + } let new_int : Array[Double] = [] for i in 0.. Spectrum { ///| /// An extracted ion chromatogram (XIC): intensity vs retention time. pub struct Chromatogram { - rt : Array[Double] // retention times in seconds - intensity : Array[Double] // intensities - mz_target : Double // target m/z (0 if full range) + rt : Array[Double] // retention times in seconds + intensity : Array[Double] // intensities + mz_target : Double // target m/z (0 if full range) ppm_tolerance : Double n_points : Int - acquisition_mode : String // "MRM", "SIM", "XIC", etc. + acquisition_mode : String // "MRM", "SIM", "XIC", etc. } ///| @@ -277,9 +303,9 @@ pub struct Chromatogram { pub fn Chromatogram::new( rt : Array[Double], intensity : Array[Double], - mz_target~ : Double = 0.0, - ppm_tolerance~ : Double = 10.0, - acquisition_mode~ : String = "XIC", + mz_target? : Double = 0.0, + ppm_tolerance? : Double = 10.0, + acquisition_mode? : String = "XIC", ) -> Chromatogram { let n = rt.length() Chromatogram::{ @@ -287,19 +313,27 @@ pub fn Chromatogram::new( intensity, mz_target, ppm_tolerance, - n_points: if n == intensity.length() { n } else { 0 }, + n_points: if n == intensity.length() { + n + } else { + 0 + }, acquisition_mode, } } ///| /// Get n_points. -pub fn Chromatogram::n_points(self : Chromatogram) -> Int { self.n_points } +pub fn Chromatogram::n_points(self : Chromatogram) -> Int { + self.n_points +} ///| /// Get total signal (AUC) using trapezoid rule. pub fn Chromatogram::total_auc(self : Chromatogram) -> Double { - if self.n_points < 2 { return 0.0 } + if self.n_points < 2 { + return 0.0 + } let mut auc = 0.0 for i in 1.. Double { ///| /// Find apex (maximum intensity) retention time and intensity. pub fn Chromatogram::apex(self : Chromatogram) -> (Double, Double) { - if self.n_points == 0 { return (0.0, 0.0) } + if self.n_points == 0 { + return (0.0, 0.0) + } let mut max_idx = 0 let mut max_v = self.intensity[0] for i in 1.. (Double, Double) { ///| /// Full width at half maximum (FWHM) in seconds. pub fn Chromatogram::fwhm(self : Chromatogram) -> Double { - if self.n_points < 3 { return 0.0 } + if self.n_points < 3 { + return 0.0 + } let (_apex_rt, apex_int) = self.apex() - if apex_int <= 0.0 { return 0.0 } + if apex_int <= 0.0 { + return 0.0 + } let half_max = apex_int / 2.0 // Find index of apex let mut apex_idx = 0 for i in 0.. Double { pub struct MSnFeatureData { feature_name : String protein_accessions : Array[String] - sequence : String // peptide sequence if applicable + sequence : String // peptide sequence if applicable modifications : Array[String] charge : Int mz : Double @@ -429,7 +472,7 @@ pub fn MSnSampleData::new( /// - sample_data: column annotations /// - processing: processing log pub struct MSnSet { - exprs : Array[Array[Double]] // rows=features, cols=samples + exprs : Array[Array[Double]] // rows=features, cols=samples feature_data : Array[MSnFeatureData] sample_data : Array[MSnSampleData] n_features : Int @@ -469,12 +512,20 @@ pub fn MSnSet::from_names( let n_s = if n_f > 0 { exprs[0].length() } else { 0 } let fd : Array[MSnFeatureData] = [] for i in 0.. Int { self.n_features } +pub fn MSnSet::n_features(self : MSnSet) -> Int { + self.n_features +} ///| /// Get n_samples. -pub fn MSnSet::n_samples(self : MSnSet) -> Int { self.n_samples } +pub fn MSnSet::n_samples(self : MSnSet) -> Int { + self.n_samples +} ///| /// Get expression matrix (intensities). -pub fn MSnSet::exprs(self : MSnSet) -> Array[Array[Double]] { self.exprs } +pub fn MSnSet::exprs(self : MSnSet) -> Array[Array[Double]] { + self.exprs +} ///| /// Get feature names. @@ -506,12 +563,20 @@ pub fn MSnSet::sample_names(self : MSnSet) -> Array[String] { ///| /// Get expression for a specific feature across samples. -pub fn MSnSet::get_feature(self : MSnSet, feature_name : String) -> Array[Double] { +pub fn MSnSet::get_feature( + self : MSnSet, + feature_name : String, +) -> Array[Double] { let mut idx = -1 for i in 0.. Array[Double pub fn MSnSet::get_sample(self : MSnSet, sample_name : String) -> Array[Double] { let mut idx = -1 for j in 0.. Array[Double] ///| /// Absolute value helper. fn mbn_abs(x : Double) -> Double { - if x < 0.0 { -x } else { x } + if x < 0.0 { + -x + } else { + x + } } ///| /// Log2 transform intensities in MSnSet (with offset for zeros). -pub fn MSnSet::log2_transform( - self : MSnSet, - offset~ : Double = 1.0, -) -> MSnSet { - if self.is_log2 { return self } +pub fn MSnSet::log2_transform(self : MSnSet, offset? : Double = 1.0) -> MSnSet { + if self.is_log2 { + return self + } let n_f = self.n_features let n_s = self.n_samples let new_exprs : Array[Array[Double]] = [] @@ -573,14 +646,16 @@ pub fn MSnSet::log2_transform( /// "zero" (set to 0), "min" (row min / 2) pub fn MSnSet::impute_missing( self : MSnSet, - method~ : String = "mean", + method? : String = "mean", ) -> MSnSet { let n_f = self.n_features let n_s = self.n_samples let new_exprs : Array[Array[Double]] = [] for i in 0.. MSnSet { let n_f = self.n_features let n_s = self.n_samples @@ -635,7 +712,9 @@ pub fn MSnSet::normalize_sum( let new_exprs : Array[Array[Double]] = [] for i in 0.. MSnSet { let new_exprs : Array[Array[Double]] = [] for i in 0.. MSnSet { /// Returns new MSnSet with one row per unique protein accession. pub fn MSnSet::summarize_to_proteins( self : MSnSet, - method~ : String = "sum", + method? : String = "sum", ) -> MSnSet { // Map from protein accession -> list of row indices let protein_rows : Map[String, Array[Int]] = Map([], capacity=0) @@ -721,7 +804,9 @@ pub fn MSnSet::summarize_to_proteins( match existing { Some(arr) => { let new_arr : Array[Int] = [] - for x in arr { new_arr.push(x) } + for x in arr { + new_arr.push(x) + } new_arr.push(i) protein_rows.set(name, new_arr) } @@ -737,7 +822,9 @@ pub fn MSnSet::summarize_to_proteins( match existing { Some(arr) => { let new_arr : Array[Int] = [] - for x in arr { new_arr.push(x) } + for x in arr { + new_arr.push(x) + } new_arr.push(i) protein_rows.set(p, new_arr) } @@ -756,7 +843,9 @@ pub fn MSnSet::summarize_to_proteins( let new_exprs : Array[Array[Double]] = [] for _i in 0.. Spectrum { let n = self.peaks_count - if n == 0 { return self } + if n == 0 { + return self + } let hw = if half_window < 1 { 1 } else { half_window } let new_int : Array[Double] = [] for i in 0.. Spectrum { let n = self.peaks_count - if n == 0 { return self } + if n == 0 { + return self + } let hw = if half_window < 1 { 1 } else { half_window } // Compute baseline estimate per point = min in window let baseline : Array[Double] = [] @@ -848,7 +945,9 @@ pub fn Spectrum::baseline_correct_minwin( let hi = if i + hw < n { i + hw } else { n - 1 } let mut min_v = self.intensity[lo] for k in lo..<(hi + 1) { - if self.intensity[k] < min_v { min_v = self.intensity[k] } + if self.intensity[k] < min_v { + min_v = self.intensity[k] + } } baseline.push(min_v) } @@ -865,10 +964,12 @@ pub fn Spectrum::baseline_correct_minwin( /// Returns a new centroided Spectrum with only peak locations. pub fn Spectrum::centroid_simple( self : Spectrum, - snr_threshold~ : Double = 3.0, + snr_threshold? : Double = 3.0, ) -> Spectrum { let n = self.peaks_count - if n < 3 { return self } + if n < 3 { + return self + } // Estimate noise as median of small differences let noise_estimate = 0.0 // Compute median intensity / 50 as simple noise floor @@ -882,8 +983,8 @@ pub fn Spectrum::centroid_simple( for i in 1..<(n - 1) { let cur = self.intensity[i] if cur >= threshold && - cur > self.intensity[i - 1] && - cur > self.intensity[i + 1] { + cur > self.intensity[i - 1] && + cur > self.intensity[i + 1] { // Simple 3-point parabolic apex refinement let a = self.intensity[i - 1] let b = cur @@ -899,7 +1000,13 @@ pub fn Spectrum::centroid_simple( new_int.push(cur) } } - let result = Spectrum::new(new_mz, new_int, self.ms_level, self.polarity, self.rt) + let result = Spectrum::new( + new_mz, + new_int, + self.ms_level, + self.polarity, + self.rt, + ) result.centroided = true result } @@ -908,6 +1015,7 @@ pub fn Spectrum::centroid_simple( // Helper: sort doubles // ============================================================================ +///| fn mbn_sort_dbl(arr : Array[Double]) -> Array[Double] { let result = arr.copy() let n = result.length() @@ -931,7 +1039,9 @@ fn mbn_sort_dbl(arr : Array[Double]) -> Array[Double] { ///| /// Compute per-sample QC metrics from MSnSet: /// Returns array of (sample_name, n_features_detected, total_intensity, median_intensity, coef_of_variation) -pub fn MSnSet::sample_qc(self : MSnSet) -> Array[(String, Int, Double, Double, Double)] { +pub fn MSnSet::sample_qc( + self : MSnSet, +) -> Array[(String, Int, Double, Double, Double)] { let n_s = self.n_samples let result : Array[(String, Int, Double, Double, Double)] = [] for j in 0.. Array[(String, Int, Double, Double, D let mut cv = 0.0 if k > 1 { let mut mean_v = 0.0 - for v in vals { mean_v = mean_v + v } + for v in vals { + mean_v = mean_v + v + } mean_v = mean_v / k.to_double() let mut sum_sq = 0.0 for v in vals { @@ -969,7 +1081,9 @@ pub fn MSnSet::sample_qc(self : MSnSet) -> Array[(String, Int, Double, Double, D sum_sq = sum_sq + d * d } let sd = (sum_sq / (k - 1).to_double()).sqrt() - if mean_v > 0.0 { cv = sd / mean_v } + if mean_v > 0.0 { + cv = sd / mean_v + } } let sname = if j < self.sample_data.length() { self.sample_data[j].sample_name diff --git a/src/msstats.mbt b/src/msstats.mbt index 40b37054..5ec1a413 100644 --- a/src/msstats.mbt +++ b/src/msstats.mbt @@ -209,7 +209,17 @@ pub fn ms_data_process( let mut i = 0 while i < features.length() { let f = features[i] - processed.push(MSFeature::new(f.protein, f.peptide, f.transition, f.group, f.subject, f.run, f.intensity)) + processed.push( + MSFeature::new( + f.protein, + f.peptide, + f.transition, + f.group, + f.subject, + f.run, + f.intensity, + ), + ) i = i + 1 } @@ -523,7 +533,11 @@ pub fn ms_group_comparison( let se = (var1 / n1 + var2 / n2).sqrt() let t_stat = if se < 1.0e-10 { - if (m2 - m1).abs() < 1.0e-10 { 0.0 } else { 100.0 } + if (m2 - m1).abs() < 1.0e-10 { + 0.0 + } else { + 100.0 + } } else { (m2 - m1) / se } @@ -535,8 +549,16 @@ pub fn ms_group_comparison( 1.0 } else { let t_sq = abs_t * abs_t - let p_approx = 2.0 * @math.exp(-df * @math.ln(1.0 + t_sq / df) / 2.0) / (df * 3.14159265358979).sqrt() - if p_approx > 1.0 { 1.0 } else if p_approx < 0.0 { 0.0 } else { p_approx } + let p_approx = 2.0 * + @math.exp(-df * @math.ln(1.0 + t_sq / df) / 2.0) / + (df * 3.14159265358979).sqrt() + if p_approx > 1.0 { + 1.0 + } else if p_approx < 0.0 { + 0.0 + } else { + p_approx + } } all_results.push(MSGroupResult::{ @@ -566,8 +588,13 @@ pub fn ms_group_comparison( let mut si2 = 0 while si2 < all_results.length() { all_results[si2].p_adj = adjusted[si2] - let abs_lfc = if all_results[si2].log2fc < 0.0 { -all_results[si2].log2fc } else { all_results[si2].log2fc } - all_results[si2].significant = adjusted[si2] < fdr_threshold && abs_lfc >= log2fc_threshold + let abs_lfc = if all_results[si2].log2fc < 0.0 { + -all_results[si2].log2fc + } else { + all_results[si2].log2fc + } + all_results[si2].significant = adjusted[si2] < fdr_threshold && + abs_lfc >= log2fc_threshold if all_results[si2].significant { n_sig = n_sig + 1 } @@ -586,12 +613,7 @@ pub fn ms_group_comparison( 0 } - MSGroupComparison::{ - results: all_results, - n_proteins, - n_sig, - fdr_threshold, - } + MSGroupComparison::{ results: all_results, n_proteins, n_sig, fdr_threshold } } ///| @@ -690,7 +712,9 @@ pub fn MSGroupComparison::get_n_results(self : MSGroupComparison) -> Int { ///| /// Get significant results. -pub fn MSGroupComparison::get_significant(self : MSGroupComparison) -> Array[MSGroupResult] { +pub fn MSGroupComparison::get_significant( + self : MSGroupComparison, +) -> Array[MSGroupResult] { let sig : Array[MSGroupResult] = Array::new() let mut i = 0 while i < self.results.length() { @@ -704,7 +728,10 @@ pub fn MSGroupComparison::get_significant(self : MSGroupComparison) -> Array[MSG ///| /// Get top N proteins by adjusted p-value. -pub fn MSGroupComparison::get_top_proteins(self : MSGroupComparison, n : Int) -> Array[MSGroupResult] { +pub fn MSGroupComparison::get_top_proteins( + self : MSGroupComparison, + n : Int, +) -> Array[MSGroupResult] { let sorted = self.results.copy() let len = sorted.length() let mut i = 0 @@ -736,7 +763,12 @@ pub fn MSGroupComparison::get_top_proteins(self : MSGroupComparison, n : Int) -> pub fn MSGroupComparison::summary(self : MSGroupComparison) -> String { let mut s = "=== MSstats Group Comparison Summary ===\n".to_string() s = s + "Proteins tested: " + self.n_proteins.to_string() + "\n" - s = s + "Significant (FDR < " + self.fdr_threshold.to_string() + "): " + self.n_sig.to_string() + "\n" + s = s + + "Significant (FDR < " + + self.fdr_threshold.to_string() + + "): " + + self.n_sig.to_string() + + "\n" s = s + "Total comparisons: " + self.results.length().to_string() + "\n" s } @@ -751,7 +783,12 @@ pub fn ms_design_sample_size( // Simplified: use the median log2fc and SE to estimate power let n = results.length() if n == 0 { - return MSSampleSize::{ desired_power, n_samples: 3, n_proteins_detectable: 0, delta: 0.0 } + return MSSampleSize::{ + desired_power, + n_samples: 3, + n_proteins_detectable: 0, + delta: 0.0, + } } // Sort by absolute log2fc @@ -760,8 +797,16 @@ pub fn ms_design_sample_size( while i < n - 1 { let mut j = 0 while j < n - 1 - i { - let abs1 = if sorted[j].log2fc < 0.0 { -sorted[j].log2fc } else { sorted[j].log2fc } - let abs2 = if sorted[j + 1].log2fc < 0.0 { -sorted[j + 1].log2fc } else { sorted[j + 1].log2fc } + let abs1 = if sorted[j].log2fc < 0.0 { + -sorted[j].log2fc + } else { + sorted[j].log2fc + } + let abs2 = if sorted[j + 1].log2fc < 0.0 { + -sorted[j + 1].log2fc + } else { + sorted[j + 1].log2fc + } if abs1 < abs2 { let tmp = sorted[j] sorted.set(j, sorted[j + 1]) @@ -773,7 +818,11 @@ pub fn ms_design_sample_size( } let mid = n / 2 - let delta = if sorted[mid].log2fc < 0.0 { -sorted[mid].log2fc } else { sorted[mid].log2fc } + let delta = if sorted[mid].log2fc < 0.0 { + -sorted[mid].log2fc + } else { + sorted[mid].log2fc + } let se = sorted[mid].se // Estimate required sample size using simplified power calculation @@ -781,16 +830,32 @@ pub fn ms_design_sample_size( let z_alpha = 1.96 let z_beta = if desired_power >= 0.8 { 0.842 } else { 0.674 } let sigma = if se > 0.0 { se } else { 1.0 } - let required_n = ((z_alpha + z_beta) * (z_alpha + z_beta) * sigma * sigma / (delta * delta + 1.0e-10)).to_int() - let n_samples_final = if n_samples > 0 { n_samples } else { if required_n < 3 { 3 } else { required_n } } + let required_n = ((z_alpha + z_beta) * + (z_alpha + z_beta) * + sigma * + sigma / + (delta * delta + 1.0e-10)).to_int() + let n_samples_final = if n_samples > 0 { + n_samples + } else if required_n < 3 { + 3 + } else { + required_n + } // Count how many proteins would be detectable with this sample size let n_detectable = if delta > 0.0 && se > 0.0 { let mut count = 0 let mut di = 0 while di < n { - let abs_lfc = if sorted[di].log2fc < 0.0 { -sorted[di].log2fc } else { sorted[di].log2fc } - let z = abs_lfc / (sorted[di].se + 1.0e-10) * (n_samples_final.to_double()).sqrt() + let abs_lfc = if sorted[di].log2fc < 0.0 { + -sorted[di].log2fc + } else { + sorted[di].log2fc + } + let z = abs_lfc / + (sorted[di].se + 1.0e-10) * + n_samples_final.to_double().sqrt() if z > z_alpha { count = count + 1 } @@ -828,19 +893,22 @@ pub fn msstats_sample_data() -> Array[MSFeature] { let peptide = proteins[pi] + "_pep" + pep_idx.to_string() let transition = peptide + "_tr" let intensity = if groups[gi] == "Trt" { - 1000.0 * (pi + 1).to_double() * 2.0 + (pep_idx + 1).to_double() * 100.0 + 1000.0 * (pi + 1).to_double() * 2.0 + + (pep_idx + 1).to_double() * 100.0 } else { 1000.0 * (pi + 1).to_double() + (pep_idx + 1).to_double() * 100.0 } - features.push(MSFeature::new( - proteins[pi], - peptide, - transition, - groups[gi], - subjects[gi], - runs[gi], - intensity, - )) + features.push( + MSFeature::new( + proteins[pi], + peptide, + transition, + groups[gi], + subjects[gi], + runs[gi], + intensity, + ), + ) pep_idx = pep_idx + 1 } gi = gi + 1 diff --git a/src/muscat.mbt b/src/muscat.mbt index 5683bc7b..e31c6e95 100644 --- a/src/muscat.mbt +++ b/src/muscat.mbt @@ -153,7 +153,11 @@ pub fn SingleCell::new( ///| /// Set gene count for a cell. -pub fn SingleCell::set_count(self : SingleCell, gene_id : String, count : Double) -> Unit { +pub fn SingleCell::set_count( + self : SingleCell, + gene_id : String, + count : Double, +) -> Unit { self.gene_counts.set(gene_id, count) } @@ -266,7 +270,11 @@ pub fn aggregate_cells( s = s + values[vi] vi = vi + 1 } - if values.length() > 0 { s / values.length().to_double() } else { 0.0 } + if values.length() > 0 { + s / values.length().to_double() + } else { + 0.0 + } } AggregationMethod::Median => { let sorted = values.copy() @@ -462,7 +470,11 @@ pub fn run_ds_analysis( let mut si2 = 0 while si2 < all_results.length() { all_results[si2].p_adj = adjusted[si2] - let abs_lfc = if all_results[si2].log2fc < 0.0 { -all_results[si2].log2fc } else { all_results[si2].log2fc } + let abs_lfc = if all_results[si2].log2fc < 0.0 { + -all_results[si2].log2fc + } else { + all_results[si2].log2fc + } let sig = adjusted[si2] < fdr_threshold && abs_lfc >= log2fc_threshold all_results[si2].significant = sig si2 = si2 + 1 @@ -554,19 +566,36 @@ fn compute_ttest_pvalue(ctrl : Array[Double], stim : Array[Double]) -> Double { let t_stat = (m2 - m1) / pooled_se // Degrees of freedom (Welch's) - let df_num = (v1 / n1.to_double() + v2 / n2.to_double()) * (v1 / n1.to_double() + v2 / n2.to_double()) - let df_den = (v1 / n1.to_double()) * (v1 / n1.to_double()) / (n1 - 1).to_double() + (v2 / n2.to_double()) * (v2 / n2.to_double()) / (n2 - 1).to_double() - let df = if df_den < 1.0e-10 { (n1 + n2 - 2).to_double() } else { df_num / df_den } + let df_num = (v1 / n1.to_double() + v2 / n2.to_double()) * + (v1 / n1.to_double() + v2 / n2.to_double()) + let df_den = v1 / + n1.to_double() * + (v1 / n1.to_double()) / + (n1 - 1).to_double() + + v2 / n2.to_double() * (v2 / n2.to_double()) / (n2 - 1).to_double() + let df = if df_den < 1.0e-10 { + (n1 + n2 - 2).to_double() + } else { + df_num / df_den + } // Approximate two-sided p-value from t-distribution // Using a simple approximation: p = 2 * (1 - cdf(|t|, df)) // Approximation: p ≈ 2 * exp(-df * ln(1 + t^2/df) / 2) / sqrt(df * pi) let abs_t = if t_stat < 0.0 { -t_stat } else { t_stat } let t_sq = abs_t * abs_t - let p_approx = 2.0 * @math.exp(-df * @math.ln(1.0 + t_sq / df) / 2.0) / (df * 3.14159265358979).sqrt() + let p_approx = 2.0 * + @math.exp(-df * @math.ln(1.0 + t_sq / df) / 2.0) / + (df * 3.14159265358979).sqrt() // Clamp p-value to [0, 1] - if p_approx > 1.0 { 1.0 } else if p_approx < 0.0 { 0.0 } else { p_approx } + if p_approx > 1.0 { + 1.0 + } else if p_approx < 0.0 { + 0.0 + } else { + p_approx + } } ///| @@ -650,7 +679,10 @@ pub fn DSResults::get_significant(self : DSResults) -> Array[DSResult] { ///| /// Get results for a specific cluster. -pub fn DSResults::get_cluster_results(self : DSResults, cluster_id : String) -> Array[DSResult] { +pub fn DSResults::get_cluster_results( + self : DSResults, + cluster_id : String, +) -> Array[DSResult] { let filtered : Array[DSResult] = Array::new() let mut i = 0 while i < self.results.length() { @@ -698,7 +730,12 @@ pub fn DSResults::summary(self : DSResults) -> String { s = s + "Method: " + self.ds_method.to_string() + "\n" s = s + "Total genes tested: " + self.n_genes.to_string() + "\n" s = s + "Clusters: " + self.n_clusters.to_string() + "\n" - s = s + "Significant (FDR < " + self.fdr_threshold.to_string() + "): " + self.n_sig.to_string() + "\n" + s = s + + "Significant (FDR < " + + self.fdr_threshold.to_string() + + "): " + + self.n_sig.to_string() + + "\n" s = s + "Total results: " + self.results.length().to_string() + "\n" s } @@ -712,11 +749,7 @@ pub fn compute_qc(pb_samples : Array[PseudoBulk]) -> Array[SampleQC] { let pb = pb_samples[i] let n_genes = pb.n_expressed() let total = pb.total_counts() - let median_genes = if pb.n_cells > 0 { - n_genes.to_double() - } else { - 0.0 - } + let median_genes = if pb.n_cells > 0 { n_genes.to_double() } else { 0.0 } qc_list.push(SampleQC::{ sample_id: pb.sample_id, cluster_id: pb.cluster_id, diff --git a/src/mutational_patterns.mbt b/src/mutational_patterns.mbt index a6568da5..24066121 100644 --- a/src/mutational_patterns.mbt +++ b/src/mutational_patterns.mbt @@ -10,12 +10,18 @@ ///| /// The 6 basic mutation types (pyrimidine-based). pub enum MutationCategory { - C_A /// C>A transversion - C_G /// C>G transversion - C_T /// C>T transition - T_A /// T>A transversion - T_C /// T>C transition - T_G /// T>G transversion + /// C>A transversion + /// C>G transversion + /// C>T transition + /// T>A transversion + /// T>C transition + /// T>G transversion + C_A + C_G + C_T + T_A + T_C + T_G } ///| @@ -71,8 +77,12 @@ pub fn MutationCategory::to_string(self : MutationCategory) -> String { /// All 6 mutation types in standard order. pub fn all_mutation_types() -> Array[MutationCategory] { [ - MutationCategory::C_A, MutationCategory::C_G, MutationCategory::C_T, - MutationCategory::T_A, MutationCategory::T_C, MutationCategory::T_G, + MutationCategory::C_A, + MutationCategory::C_G, + MutationCategory::C_T, + MutationCategory::T_A, + MutationCategory::T_C, + MutationCategory::T_G, ] } @@ -101,7 +111,8 @@ pub struct SomaticMutation { position : Int ref_base : String alt_base : String - trinucleotide_context : String /// e.g., "ACT" (ref is middle) + /// e.g., "ACT" (ref is middle) + trinucleotide_context : String } ///| @@ -115,7 +126,8 @@ pub struct MutationMatrix { channel_labels : Array[String] /// Count matrix: 96 rows × n_samples columns counts : Array[Array[Int]] - total_mutations : Array[Int] /// per-sample total + /// per-sample total + total_mutations : Array[Int] } ///| @@ -173,7 +185,10 @@ pub fn get_channel_labels() -> Array[String] { ///| /// Determine mutation type from ref and alt base. /// Uses pyrimidine-based convention (C/T as reference). -pub fn get_mutation_type(ref_base : String, alt_base : String) -> MutationCategory { +pub fn get_mutation_type( + ref_base : String, + alt_base : String, +) -> MutationCategory { let r = ref_base.to_upper() let a = alt_base.to_upper() // If ref is purine (A/G), reverse complement to get pyrimidine-based @@ -234,7 +249,11 @@ pub fn normalize_context(trinucleotide : String) -> String { ///| /// Get the 0-based channel index (0-95) for a mutation. /// Based on the trinucleotide context and mutation type. -pub fn get_channel_index(ref_base : String, alt_base : String, trinucleotide : String) -> Int { +pub fn get_channel_index( + ref_base : String, + alt_base : String, + trinucleotide : String, +) -> Int { let norm_ctx = normalize_context(trinucleotide) let mtype = get_mutation_type(ref_base, alt_base) // Find type index (0-5) @@ -354,7 +373,9 @@ pub fn MutationMatrix::get_count( ///| /// Convert counts to relative frequencies (normalize per sample). -pub fn MutationMatrix::to_relative_frequencies(self : MutationMatrix) -> Array[Array[Double]] { +pub fn MutationMatrix::to_relative_frequencies( + self : MutationMatrix, +) -> Array[Array[Double]] { let n_channels = self.counts.length() let n_samples = if n_channels > 0 { self.counts[0].length() } else { 0 } let result : Array[Array[Double]] = Array::new() @@ -381,7 +402,11 @@ pub fn MutationMatrix::to_relative_frequencies(self : MutationMatrix) -> Array[A ///| /// Compute cosine similarity between two vectors. pub fn cosine_similarity(vec1 : Array[Double], vec2 : Array[Double]) -> Double { - let len = if vec1.length() < vec2.length() { vec1.length() } else { vec2.length() } + let len = if vec1.length() < vec2.length() { + vec1.length() + } else { + vec2.length() + } let mut dot = 0.0 let mut norm1 = 0.0 let mut norm2 = 0.0 diff --git a/src/naccess.mbt b/src/naccess.mbt index a26a08ea..3d6e2c2c 100644 --- a/src/naccess.mbt +++ b/src/naccess.mbt @@ -49,8 +49,8 @@ pub fn NaccessAtom::new( res_num~ : Int, chain_id~ : String, abs_asa~ : Double, - rel_asa~ : Double = 0.0, - element~ : String = "", + rel_asa? : Double = 0.0, + element? : String = "", ) -> NaccessAtom { NaccessAtom::{ atom_name, @@ -88,16 +88,16 @@ pub fn NaccessResidue::new( res_name~ : String, res_num~ : Int, chain_id~ : String, - abs_all~ : Double = 0.0, - abs_side_chain~ : Double = 0.0, - abs_main_chain~ : Double = 0.0, - rel_all~ : Double = 0.0, - rel_side_chain~ : Double = 0.0, - rel_main_chain~ : Double = 0.0, - non_polar_abs~ : Double = 0.0, - non_polar_rel~ : Double = 0.0, - polar_abs~ : Double = 0.0, - polar_rel~ : Double = 0.0, + abs_all? : Double = 0.0, + abs_side_chain? : Double = 0.0, + abs_main_chain? : Double = 0.0, + rel_all? : Double = 0.0, + rel_side_chain? : Double = 0.0, + rel_main_chain? : Double = 0.0, + non_polar_abs? : Double = 0.0, + non_polar_rel? : Double = 0.0, + polar_abs? : Double = 0.0, + polar_rel? : Double = 0.0, ) -> NaccessResidue { NaccessResidue::{ res_name, @@ -142,7 +142,10 @@ pub fn NaccessResult::new() -> NaccessResult { ///| /// Add a residue record. -pub fn NaccessResult::add_residue(self : NaccessResult, r : NaccessResidue) -> Unit { +pub fn NaccessResult::add_residue( + self : NaccessResult, + r : NaccessResidue, +) -> Unit { self.residues.push(r) } @@ -154,7 +157,9 @@ pub fn NaccessResult::add_atom(self : NaccessResult, a : NaccessAtom) -> Unit { ///| /// Get all residue records. -pub fn NaccessResult::get_residues(self : NaccessResult) -> Array[NaccessResidue] { +pub fn NaccessResult::get_residues( + self : NaccessResult, +) -> Array[NaccessResidue] { self.residues } @@ -215,22 +220,58 @@ pub fn naccess_parse_rsa(content : String) -> Array[NaccessResidue] { let res_num = parse_int(filtered[2]) let chain_id = filtered[3] let abs_all = parse_double(filtered[4]).unwrap_or(0.0) - let rel_all = if filtered.length() > 5 { parse_double(filtered[5]).unwrap_or(0.0) } else { 0.0 } - let abs_side = if filtered.length() > 6 { parse_double(filtered[6]).unwrap_or(0.0) } else { 0.0 } - let rel_side = if filtered.length() > 7 { parse_double(filtered[7]).unwrap_or(0.0) } else { 0.0 } - let abs_main = if filtered.length() > 8 { parse_double(filtered[8]).unwrap_or(0.0) } else { 0.0 } - let rel_main = if filtered.length() > 9 { parse_double(filtered[9]).unwrap_or(0.0) } else { 0.0 } - let np_abs = if filtered.length() > 10 { parse_double(filtered[10]).unwrap_or(0.0) } else { 0.0 } - let np_rel = if filtered.length() > 11 { parse_double(filtered[11]).unwrap_or(0.0) } else { 0.0 } - let p_abs = if filtered.length() > 12 { parse_double(filtered[12]).unwrap_or(0.0) } else { 0.0 } - let p_rel = if filtered.length() > 13 { parse_double(filtered[13]).unwrap_or(0.0) } else { 0.0 } + let rel_all = if filtered.length() > 5 { + parse_double(filtered[5]).unwrap_or(0.0) + } else { + 0.0 + } + let abs_side = if filtered.length() > 6 { + parse_double(filtered[6]).unwrap_or(0.0) + } else { + 0.0 + } + let rel_side = if filtered.length() > 7 { + parse_double(filtered[7]).unwrap_or(0.0) + } else { + 0.0 + } + let abs_main = if filtered.length() > 8 { + parse_double(filtered[8]).unwrap_or(0.0) + } else { + 0.0 + } + let rel_main = if filtered.length() > 9 { + parse_double(filtered[9]).unwrap_or(0.0) + } else { + 0.0 + } + let np_abs = if filtered.length() > 10 { + parse_double(filtered[10]).unwrap_or(0.0) + } else { + 0.0 + } + let np_rel = if filtered.length() > 11 { + parse_double(filtered[11]).unwrap_or(0.0) + } else { + 0.0 + } + let p_abs = if filtered.length() > 12 { + parse_double(filtered[12]).unwrap_or(0.0) + } else { + 0.0 + } + let p_rel = if filtered.length() > 13 { + parse_double(filtered[13]).unwrap_or(0.0) + } else { + 0.0 + } residues.push( NaccessResidue::new( - res_name=res_name, - res_num=res_num, - chain_id=chain_id, - abs_all=abs_all, - rel_all=rel_all, + res_name~, + res_num~, + chain_id~, + abs_all~, + rel_all~, abs_side_chain=abs_side, rel_side_chain=rel_side, abs_main_chain=abs_main, @@ -303,13 +344,13 @@ pub fn naccess_parse_asa(content : String) -> Array[NaccessAtom] { } atoms.push( NaccessAtom::new( - atom_name=atom_name, - atom_num=atom_num, - res_name=res_name, - res_num=res_num, - chain_id=chain_id, - abs_asa=abs_asa, - rel_asa=rel_asa, + atom_name~, + atom_num~, + res_name~, + res_num~, + chain_id~, + abs_asa~, + rel_asa~, ), ) } @@ -324,7 +365,10 @@ pub fn naccess_parse_asa(content : String) -> Array[NaccessAtom] { ///| /// Parse NACCESS output from both RSA and ASA content. -pub fn naccess_parse(rsa_content : String, asa_content : String) -> NaccessResult { +pub fn naccess_parse( + rsa_content : String, + asa_content : String, +) -> NaccessResult { let result = NaccessResult::new() let residues = naccess_parse_rsa(rsa_content) let atoms = naccess_parse_asa(asa_content) @@ -404,7 +448,9 @@ pub fn naccess_atom_to_asa(a : NaccessAtom) -> String { pub fn naccess_write_rsa(result : NaccessResult) -> String { let sb = StringBuilder::new() sb.write_string("NACCESS Version 2.1\n") - sb.write_string("RES NUM CHN ABS_ALL REL_ALL ABS_SIDE REL_SIDE ABS_MAIN REL_MAIN NP_ABS NP_REL P_ABS P_REL\n") + sb.write_string( + "RES NUM CHN ABS_ALL REL_ALL ABS_SIDE REL_SIDE ABS_MAIN REL_MAIN NP_ABS NP_REL P_ABS P_REL\n", + ) for r in result.residues { sb.write_string(naccess_residue_to_rsa(r) + "\n") } @@ -487,10 +533,7 @@ pub fn naccess_get_chain_residues( ///| /// Count residues by type (exposed vs buried). -pub fn naccess_count_exposed( - result : NaccessResult, - threshold : Double, -) -> Int { +pub fn naccess_count_exposed(result : NaccessResult, threshold : Double) -> Int { let mut count = 0 for r in result.residues { if r.rel_all > threshold { @@ -502,7 +545,10 @@ pub fn naccess_count_exposed( ///| /// Get total ASA for a specific chain. -pub fn naccess_chain_total_asa(result : NaccessResult, chain_id : String) -> Double { +pub fn naccess_chain_total_asa( + result : NaccessResult, + chain_id : String, +) -> Double { let mut total = 0.0 for r in result.residues { if r.chain_id == chain_id { @@ -580,15 +626,29 @@ pub fn naccess_summary(result : NaccessResult) -> String { sb.write_string("NACCESS Result Summary:\n") sb.write_string(" Residues: " + result.get_num_residues().to_string() + "\n") sb.write_string(" Atoms: " + result.get_num_atoms().to_string() + "\n") - sb.write_string(" Total ASA: " + result.total_abs_asa.to_string() + " Ų\n") - sb.write_string(" Mean Rel ASA: " + naccess_mean_rel_asa(result).to_string() + "%\n") - sb.write_string(" Exposed (>20%): " + naccess_count_exposed(result, 20.0).to_string() + "\n") - sb.write_string(" Buried (≤20%): " + (result.get_num_residues() - naccess_count_exposed(result, 20.0)).to_string() + "\n") + sb.write_string( + " Total ASA: " + result.total_abs_asa.to_string() + " Ų\n", + ) + sb.write_string( + " Mean Rel ASA: " + naccess_mean_rel_asa(result).to_string() + "%\n", + ) + sb.write_string( + " Exposed (>20%): " + + naccess_count_exposed(result, 20.0).to_string() + + "\n", + ) + sb.write_string( + " Buried (≤20%): " + + (result.get_num_residues() - naccess_count_exposed(result, 20.0)).to_string() + + "\n", + ) sb.write_string(" Chains: " + result.chain_totals.size().to_string() + "\n") for chain_id in result.chain_totals.keys() { match result.chain_totals.get(chain_id) { Some(v) => - sb.write_string(" Chain " + chain_id + ": " + v.to_string() + " Ų\n") + sb.write_string( + " Chain " + chain_id + ": " + v.to_string() + " Ų\n", + ) None => () } } diff --git a/src/naive_bayes.mbt b/src/naive_bayes.mbt index 36a67704..2dd090f0 100644 --- a/src/naive_bayes.mbt +++ b/src/naive_bayes.mbt @@ -30,31 +30,37 @@ pub fn NaiveBayesClassifier::new() -> NaiveBayesClassifier { alpha: 1.0, vocabulary: [], class_labels: [], - models: Map([], capacity=10) + models: Map([], capacity=10), } } ///| /// Set the k-mer size and return a new classifier instance. -pub fn NaiveBayesClassifier::set_kmer_size(self : NaiveBayesClassifier, val : Int) -> NaiveBayesClassifier { +pub fn NaiveBayesClassifier::set_kmer_size( + self : NaiveBayesClassifier, + val : Int, +) -> NaiveBayesClassifier { NaiveBayesClassifier::{ kmer_size: val, alpha: self.alpha, vocabulary: self.vocabulary, class_labels: self.class_labels, - models: self.models + models: self.models, } } ///| /// Set the Laplace smoothing alpha parameter and return a new classifier instance. -pub fn NaiveBayesClassifier::set_alpha(self : NaiveBayesClassifier, val : Double) -> NaiveBayesClassifier { +pub fn NaiveBayesClassifier::set_alpha( + self : NaiveBayesClassifier, + val : Double, +) -> NaiveBayesClassifier { NaiveBayesClassifier::{ kmer_size: self.kmer_size, alpha: val, vocabulary: self.vocabulary, class_labels: self.class_labels, - models: self.models + models: self.models, } } @@ -62,7 +68,10 @@ pub fn NaiveBayesClassifier::set_alpha(self : NaiveBayesClassifier, val : Double /// Extract k-mers from a sequence using a sliding window of size k. /// Returns a map of k-mer to count. If k > sequence length, returns empty map. /// For protein sequences, any characters are kept. -pub fn naive_bayes_extract_kmers(sequence : String, k : Int) -> Map[String, Int] { +pub fn naive_bayes_extract_kmers( + sequence : String, + k : Int, +) -> Map[String, Int] { let counts : Map[String, Int] = Map([], capacity=100) let n = sequence.length() if k <= 0 || k > n { @@ -88,7 +97,7 @@ pub fn naive_bayes_extract_kmers(sequence : String, k : Int) -> Map[String, Int] pub fn naive_bayes_train( classifier : NaiveBayesClassifier, sequences : Array[String], - labels : Array[String] + labels : Array[String], ) -> NaiveBayesClassifier { let n = sequences.length() if n == 0 || n != labels.length() { @@ -97,7 +106,7 @@ pub fn naive_bayes_train( alpha: classifier.alpha, vocabulary: [], class_labels: [], - models: Map([], capacity=10) + models: Map([], capacity=10), } } @@ -105,7 +114,10 @@ pub fn naive_bayes_train( let class_seq_counts : Map[String, Int] = Map([], capacity=10) let class_total_kmers : Map[String, Int] = Map([], capacity=10) - let class_kmer_counts : Map[String, Map[String, Double]] = Map([], capacity=10) + let class_kmer_counts : Map[String, Map[String, Double]] = Map( + [], + capacity=10, + ) let vocab_set : Map[String, Bool] = Map([], capacity=1000) for idx = 0; idx < n; idx = idx + 1 { @@ -128,7 +140,10 @@ pub fn naive_bayes_train( let kmer_count = kmers.get(kmer).unwrap() total_for_class = total_for_class + kmer_count if counts_for_class.contains(kmer) { - counts_for_class.set(kmer, counts_for_class.get(kmer).unwrap() + kmer_count.to_double()) + counts_for_class.set( + kmer, + counts_for_class.get(kmer).unwrap() + kmer_count.to_double(), + ) } else { counts_for_class.set(kmer, kmer_count.to_double()) } @@ -142,7 +157,10 @@ pub fn naive_bayes_train( let class_labels_arr : Array[String] = class_seq_counts.keys().collect() let vocabulary_arr : Array[String] = vocab_set.keys().collect() - let models_map : Map[String, NBClassModel] = Map([], capacity=class_labels_arr.length()) + let models_map : Map[String, NBClassModel] = Map( + [], + capacity=class_labels_arr.length(), + ) for label in class_labels_arr { let n_seq = class_seq_counts.get(label).unwrap() let prior = n_seq.to_double() / n.to_double() @@ -153,7 +171,7 @@ pub fn naive_bayes_train( n_sequences: n_seq, total_kmers: total_k, kmer_counts: kmer_counts_copy, - class_prior: prior + class_prior: prior, } models_map.set(label, model) } @@ -163,7 +181,7 @@ pub fn naive_bayes_train( alpha: classifier.alpha, vocabulary: vocabulary_arr, class_labels: class_labels_arr, - models: models_map + models: models_map, } } @@ -173,7 +191,7 @@ pub fn naive_bayes_train( /// Uses Laplace smoothing for k-mer probabilities. pub fn naive_bayes_predict_log_probs( classifier : NaiveBayesClassifier, - sequence : String + sequence : String, ) -> Array[(String, Double)] { let result : Array[(String, Double)] = Array::new() let vocab_size = classifier.vocabulary.length().to_double() @@ -197,7 +215,8 @@ pub fn naive_bayes_predict_log_probs( 0.0 } let smoothed_prob = (count_in_model + alpha) / denom - log_prob = log_prob + kmer_count_in_seq.to_double() * @math.ln(smoothed_prob) + log_prob = log_prob + + kmer_count_in_seq.to_double() * @math.ln(smoothed_prob) } result.push((class_label, log_prob)) @@ -211,7 +230,7 @@ pub fn naive_bayes_predict_log_probs( /// Returns (best_label, log_probability) = argmax of predict_log_probs. pub fn naive_bayes_predict( classifier : NaiveBayesClassifier, - sequence : String + sequence : String, ) -> (String, Double) { let log_probs = naive_bayes_predict_log_probs(classifier, sequence) if log_probs.length() == 0 { @@ -233,7 +252,7 @@ pub fn naive_bayes_predict( /// Returns array of (class_label, probability) where probabilities sum to ~1.0. pub fn naive_bayes_predict_proba( classifier : NaiveBayesClassifier, - sequence : String + sequence : String, ) -> Array[(String, Double)] { let log_probs = naive_bayes_predict_log_probs(classifier, sequence) let result : Array[(String, Double)] = Array::new() @@ -257,7 +276,11 @@ pub fn naive_bayes_predict_proba( } for i = 0; i < log_probs.length(); i = i + 1 { - let prob = if sum == 0.0 { 1.0 / log_probs.length().to_double() } else { exps[i] / sum } + let prob = if sum == 0.0 { + 1.0 / log_probs.length().to_double() + } else { + exps[i] / sum + } result.push((log_probs[i].0, prob)) } @@ -269,7 +292,7 @@ pub fn naive_bayes_predict_proba( pub fn naive_bayes_top_k( classifier : NaiveBayesClassifier, sequence : String, - k : Int + k : Int, ) -> Array[(String, Double)] { let probs = naive_bayes_predict_proba(classifier, sequence) @@ -303,7 +326,7 @@ pub fn naive_bayes_top_k( pub fn naive_bayes_accuracy( classifier : NaiveBayesClassifier, sequences : Array[String], - true_labels : Array[String] + true_labels : Array[String], ) -> Double { let n = sequences.length() if n == 0 || n != true_labels.length() { @@ -325,24 +348,12 @@ pub fn naive_bayes_accuracy( /// 4 sequences with label "GC_rich" (high G/C content). pub fn naive_bayes_sample_data() -> (Array[String], Array[String]) { let sequences : Array[String] = [ - "ATATATATATATATATATAT", - "AATTAAAATTTTAAATTTTA", - "TATATAAATTATATTAATTT", - "ATTTAAATAAATTTTAAAAT", - "GCGCGCGCGCGCGCGCGCGC", - "GGCCGGCCCGGGCCCGGCCC", - "CGGCCGGGCCCCGGGCCTGG", - "GCGCCGCGGGGCCCGGCCGC" + "ATATATATATATATATATAT", "AATTAAAATTTTAAATTTTA", "TATATAAATTATATTAATTT", "ATTTAAATAAATTTTAAAAT", + "GCGCGCGCGCGCGCGCGCGC", "GGCCGGCCCGGGCCCGGCCC", "CGGCCGGGCCCCGGGCCTGG", "GCGCCGCGGGGCCCGGCCGC", ] let labels : Array[String] = [ - "AT_rich", - "AT_rich", - "AT_rich", - "AT_rich", - "GC_rich", - "GC_rich", + "AT_rich", "AT_rich", "AT_rich", "AT_rich", "GC_rich", "GC_rich", "GC_rich", "GC_rich", - "GC_rich" ] (sequences, labels) } diff --git a/src/nanostring.mbt b/src/nanostring.mbt index f04a4db2..d6c12db7 100644 --- a/src/nanostring.mbt +++ b/src/nanostring.mbt @@ -52,12 +52,8 @@ fn ns_std(arr : Array[Double], mean : Double) -> Double { /// Lanczos approximation for ln(gamma(x)). fn ns_lgamma(x : Double) -> Double { let cof = [ - 76.18009172947146, - -86.50532032941677, - 24.01409824083091, - -1.231739572450155, - 0.001208650973866179, - -0.000005395239384953, + 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, + 0.001208650973866179, -0.000005395239384953, ] let mut x1 = x let mut tmp = x1 + 5.5 @@ -196,18 +192,8 @@ fn ns_linear_regression( let intercept = (sum_y - slope * sum_x) / nd let ss_tot = sum_yy - sum_y * sum_y / nd let ss_res = sum_yy - intercept * sum_y - slope * sum_xy - let r_sq = if ss_tot == 0.0 { - 0.0 - } else { - 1.0 - ss_res / ss_tot - } - let r_clamped = if r_sq < 0.0 { - 0.0 - } else if r_sq > 1.0 { - 1.0 - } else { - r_sq - } + let r_sq = if ss_tot == 0.0 { 0.0 } else { 1.0 - ss_res / ss_tot } + let r_clamped = if r_sq < 0.0 { 0.0 } else if r_sq > 1.0 { 1.0 } else { r_sq } (slope, intercept, r_clamped) } @@ -318,9 +304,7 @@ pub struct NsNanostringData { ///| /// Construct an empty NsNanostringData with the given endogenous gene names. -pub fn NsNanostringData::new( - gene_names : Array[String], -) -> NsNanostringData { +pub fn NsNanostringData::new(gene_names : Array[String]) -> NsNanostringData { NsNanostringData::{ samples: Array::new(), gene_names, @@ -381,12 +365,7 @@ pub fn NsNormResult::new( normalized_counts : Array[Double], method : String, ) -> NsNormResult { - NsNormResult::{ - sample_id, - norm_factors, - normalized_counts, - method, - } + NsNormResult::{ sample_id, norm_factors, normalized_counts, method } } ///| @@ -506,9 +485,7 @@ pub fn ns_log2_counts(counts : Array[Double]) -> Array[Double] { /// Positive-control normalization. /// Each sample is scaled so that the geometric mean of its positive controls /// matches the geometric mean of those means across all samples. -pub fn ns_positive_control_norm( - data : NsNanostringData, -) -> Array[NsNormResult] { +pub fn ns_positive_control_norm(data : NsNanostringData) -> Array[NsNormResult] { let samples = data.samples() let n_genes = data.n_genes() let sample_geo_means : Array[Double] = Array::new() @@ -524,11 +501,7 @@ pub fn ns_positive_control_norm( for i in 0.. 0.0 { - target / gm - } else { - 1.0 - } + let factor = if gm > 0.0 { target / gm } else { 1.0 } let norm_counts : Array[Double] = Array::new() let endo = sample.endogenous() for g in 0.. Array[NsNormResult] { +pub fn ns_negative_control_norm(data : NsNanostringData) -> Array[NsNormResult] { let samples = data.samples() let n_genes = data.n_genes() let results : Array[NsNormResult] = Array::new() @@ -589,9 +565,7 @@ pub fn ns_negative_control_norm( /// Housekeeping-gene normalization. /// Each sample is scaled so that the geometric mean of its housekeeping gene /// counts matches the geometric mean of those means across all samples. -pub fn ns_housekeeping_norm( - data : NsNanostringData, -) -> Array[NsNormResult] { +pub fn ns_housekeeping_norm(data : NsNanostringData) -> Array[NsNormResult] { let samples = data.samples() let n_genes = data.n_genes() let sample_geo_means : Array[Double] = Array::new() @@ -607,11 +581,7 @@ pub fn ns_housekeeping_norm( for i in 0.. 0.0 { - target / gm - } else { - 1.0 - } + let factor = if gm > 0.0 { target / gm } else { 1.0 } let norm_counts : Array[Double] = Array::new() let endo = sample.endogenous() for g in 0.. Array[NsNormResult] { 1.0 } let gm = hk_geo_means[i] - let hk_factor = if gm > 0.0 { - target / gm - } else { - 1.0 - } + let hk_factor = if gm > 0.0 { target / gm } else { 1.0 } let norm_counts : Array[Double] = Array::new() let pos_counts = pos_results[i].normalized_counts() for g in 0.. Array[Bool] { for c in pos { total = total + c } - let avg = if pos.length() > 0 { - total / pos.length() - } else { - 0 - } + let avg = if pos.length() > 0 { total / pos.length() } else { 0 } results.push(avg >= threshold) } results @@ -720,9 +682,7 @@ pub fn ns_imaging_qc(data : NsNanostringData, threshold : Int) -> Array[Bool] { /// Positive control linearity QC. /// Fits a linear model of log2(positive control counts) against log2 of the /// known dilution-series concentrations. Returns (r_squared, slope). -pub fn ns_pos_linearity_qc( - data : NsNanostringData, -) -> (Double, Double) { +pub fn ns_pos_linearity_qc(data : NsNanostringData) -> (Double, Double) { // Standard NanoString positive control dilution series (fM). let concentrations = [128.0, 32.0, 8.0, 2.0, 0.5, 0.125] let log_conc : Array[Double] = Array::new() @@ -799,10 +759,7 @@ pub fn ns_qc_summary(data : NsNanostringData) -> String { ///| /// Welch's two-sample t-test. Returns (t_statistic, p_value). -pub fn ns_t_test( - g1 : Array[Double], - g2 : Array[Double], -) -> (Double, Double) { +pub fn ns_t_test(g1 : Array[Double], g2 : Array[Double]) -> (Double, Double) { let n1 = g1.length() let n2 = g2.length() if n1 < 2 || n2 < 2 { @@ -824,19 +781,9 @@ pub fn ns_t_test( let num = (term1 + term2) * (term1 + term2) let den = term1 * term1 / (n1 - 1).to_double() + term2 * term2 / (n2 - 1).to_double() - let df = if den > 0.0 { - num / den - } else { - (n1 + n2 - 2).to_double() - } + let df = if den > 0.0 { num / den } else { (n1 + n2 - 2).to_double() } let p = 2.0 * (1.0 - ns_t_cdf(t.abs(), df)) - let pc = if p < 0.0 { - 0.0 - } else if p > 1.0 { - 1.0 - } else { - p - } + let pc = if p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p } (t, pc) } @@ -876,11 +823,7 @@ pub fn ns_bh_correct(p_values : Array[Double]) -> Array[Double] { if val < min_adj { min_adj = val } - adj[indices[i]] = if min_adj > 1.0 { - 1.0 - } else { - min_adj - } + adj[indices[i]] = if min_adj > 1.0 { 1.0 } else { min_adj } i = i - 1 } adj @@ -1009,26 +952,9 @@ pub fn ns_de_summary(results : Array[NsDeResult]) -> String { /// The first positive control indices double as housekeeping gene positions. pub fn ns_sample_data() -> NsNanostringData { let gene_names = [ - "GENE01", - "GENE02", - "GENE03", - "GENE04", - "GENE05", - "GENE06", - "GENE07", - "GENE08", - "GENE09", - "GENE10", - "GENE11", - "GENE12", - "GENE13", - "GENE14", - "GENE15", - "GENE16", - "GENE17", - "GENE18", - "GENE19", - "GENE20", + "GENE01", "GENE02", "GENE03", "GENE04", "GENE05", "GENE06", "GENE07", "GENE08", + "GENE09", "GENE10", "GENE11", "GENE12", "GENE13", "GENE14", "GENE15", "GENE16", + "GENE17", "GENE18", "GENE19", "GENE20", ] let data = NsNanostringData::new(gene_names) let pos_indices = [20, 21, 22, 23, 24, 25] @@ -1087,14 +1013,16 @@ pub fn ns_sample_data() -> NsNanostringData { for v in neg_control_profiles[s] { raw.push(v) } - data.add_sample(NsSample::new( - sample_ids[s], - raw, - pos_indices, - neg_indices, - hk_indices, - endo_indices, - )) + data.add_sample( + NsSample::new( + sample_ids[s], + raw, + pos_indices, + neg_indices, + hk_indices, + endo_indices, + ), + ) } data } diff --git a/src/neural_network.mbt b/src/neural_network.mbt index 06abb06e..b180e9c0 100644 --- a/src/neural_network.mbt +++ b/src/neural_network.mbt @@ -103,7 +103,7 @@ pub struct NeuralNetwork { pub fn NeuralNetwork::new( n_input : Int, n_hidden : Int, - n_output : Int + n_output : Int, ) -> NeuralNetwork { let hidden = NnLayer::new(n_input, n_hidden) let output = NnLayer::new(n_hidden, n_output) @@ -133,7 +133,7 @@ pub fn NeuralNetwork::new( /// Set the learning rate. pub fn NeuralNetwork::set_learning_rate( self : NeuralNetwork, - lr : Double + lr : Double, ) -> NeuralNetwork { { ..self, learning_rate: lr } } @@ -142,7 +142,7 @@ pub fn NeuralNetwork::set_learning_rate( /// Set the momentum coefficient. pub fn NeuralNetwork::set_momentum( self : NeuralNetwork, - m : Double + m : Double, ) -> NeuralNetwork { { ..self, momentum: m } } @@ -239,7 +239,7 @@ fn nn_layer_forward(layer : NnLayer, input : Array[Double]) -> Array[Double] { /// Forward pass through the entire network. Returns the output activations. pub fn nn_forward( network : NeuralNetwork, - input : Array[Double] + input : Array[Double], ) -> Array[Double] { let hidden_out = nn_layer_forward(network.hidden_layer, input) nn_layer_forward(network.output_layer, hidden_out) @@ -267,7 +267,7 @@ pub fn nn_predict(network : NeuralNetwork, input : Array[Double]) -> Int { pub fn nn_train_example( network : NeuralNetwork, input : Array[Double], - target : Array[Double] + target : Array[Double], ) -> Double { // Forward pass. let hidden_out = nn_layer_forward(network.hidden_layer, input) @@ -296,10 +296,12 @@ pub fn nn_train_example( for j in 0.. Double { let n = inputs.length() let mut final_error = 0.0 for _ in 0.. (Array[Array[Double]], Array[Array[Double]]) { - let inputs = [ - [0.0, 0.0], - [0.0, 1.0], - [1.0, 0.0], - [1.0, 1.0], - ] + let inputs = [[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]] let targets = [[0.0], [1.0], [1.0], [0.0]] (inputs, targets) } diff --git a/src/nib_io.mbt b/src/nib_io.mbt index a5402b5a..ae7a20ec 100644 --- a/src/nib_io.mbt +++ b/src/nib_io.mbt @@ -109,7 +109,7 @@ pub fn nib_encode(sequence : String) -> Array[Int] { let code_ci = nib_base_to_code_ci(sequence[i].unsafe_to_char()) let code = if code_ci < 0 { 0 } else { code_ci } let byte_idx = i / 4 - let shift = 6 - (i % 4) * 2 + let shift = 6 - i % 4 * 2 packed[byte_idx] = packed[byte_idx] | (code << shift) } packed @@ -123,7 +123,7 @@ pub fn nib_decode(packed : Array[Int], length : Int) -> String { let sb = StringBuilder::new() for i in 0..> shift) & 3 } else { @@ -275,7 +275,7 @@ pub fn nib_get_base(nib : NibSequence, index : Int) -> String { return "" } let byte_idx = index / 4 - let shift = 6 - (index % 4) * 2 + let shift = 6 - index % 4 * 2 let code = if byte_idx < nib.packed_data.length() { (nib.packed_data[byte_idx] >> shift) & 3 } else { @@ -304,7 +304,7 @@ pub fn nib_subsequence(nib : NibSequence, start : Int, length : Int) -> String { for i in 0..> shift) & 3 } else { @@ -356,7 +356,7 @@ pub fn nib_gc_content(nib : NibSequence) -> Double { let mut gc = 0 for i in 0..> shift) & 3 } else { @@ -403,12 +403,7 @@ pub fn nib_from_hex(seq_id : String, hex : String, length : Int) -> NibSequence packed.push(high * 16 + low) i = i + 2 } - NibSequence::{ - seq_id, - length, - packed_data: packed, - is_uppercase: true, - } + NibSequence::{ seq_id, length, packed_data: packed, is_uppercase: true } } // ============================================================================ diff --git a/src/nmr.mbt b/src/nmr.mbt index 73c5b62d..0ac543d9 100644 --- a/src/nmr.mbt +++ b/src/nmr.mbt @@ -152,12 +152,12 @@ pub fn parse_noe_restraints(text : String) -> Array[NoeRestraint] { restraints.push( NoeRestraint::new( restraint_id=id, - atom1=atom1, - atom2=atom2, + atom1~, + atom2~, lower_bound=lower, upper_bound=upper, - observed=observed, - energy=energy, + observed~, + energy~, ), ) } @@ -193,7 +193,7 @@ pub fn format_noe_restraints(restraints : Array[NoeRestraint]) -> String { ///| /// Summarize NOE restraint statistics: count, number violated, max violation. pub fn noe_restraint_summary( - restraints : Array[NoeRestraint] + restraints : Array[NoeRestraint], ) -> NmrRestraintSummary { let total = restraints.length() let mut violated = 0 @@ -316,8 +316,8 @@ pub fn parse_dihedral_restraints(text : String) -> Array[DihedralRestraint] { residue=res, lower_bound=lower, upper_bound=upper, - observed=observed, - energy=energy, + observed~, + energy~, ), ) } @@ -361,9 +361,9 @@ pub struct ChemicalShiftTable { ///| /// Construct a ChemicalShiftTable. pub fn ChemicalShiftTable::new( - shifts~ : Array[ChemicalShift] + shifts~ : Array[ChemicalShift], ) -> ChemicalShiftTable { - ChemicalShiftTable::{ shifts } + ChemicalShiftTable::{ shifts, } } ///| @@ -461,7 +461,7 @@ pub fn parse_chemical_shifts(text : String) -> ChemicalShiftTable { } shifts.push( ChemicalShift::new( - id=id, + id~, residue=res, atom_name=atom, element=elem, @@ -470,7 +470,7 @@ pub fn parse_chemical_shifts(text : String) -> ChemicalShiftTable { ), ) } - ChemicalShiftTable::new(shifts=shifts) + ChemicalShiftTable::new(shifts~) } ///| @@ -527,14 +527,7 @@ pub fn NmrPeak::new( volume~ : Double?, merity~ : Double?, ) -> NmrPeak { - NmrPeak::{ - peak_id, - dimensions, - chemical_shifts, - intensities, - volume, - merity, - } + NmrPeak::{ peak_id, dimensions, chemical_shifts, intensities, volume, merity } } ///| @@ -661,7 +654,8 @@ pub fn parse_peak_list(text : String) -> PeakList { } continue } - if fields[0] == "id" || (fields[0].length() >= 2 && fields[0][0:2].to_owned() == "id") { + if fields[0] == "id" || + (fields[0].length() >= 2 && fields[0][0:2].to_owned() == "id") { // Header row describing columns; count dimension groups. // Skip detection: leave n_dim to be inferred from data. continue @@ -714,15 +708,15 @@ pub fn parse_peak_list(text : String) -> PeakList { peaks.push( NmrPeak::new( peak_id=id, - dimensions=dimensions, + dimensions~, chemical_shifts=shifts, - intensities=intensities, - volume=volume, + intensities~, + volume~, merity=merit, ), ) } - PeakList::new(label=label, peaks=peaks, n_dim=n_dim) + PeakList::new(label~, peaks~, n_dim~) } ///| @@ -867,36 +861,32 @@ pub fn nmr_sample_chemical_shifts() -> ChemicalShiftTable { ///| /// Sample peak list (2D HSQC) for testing/demos. pub fn nmr_sample_peak_list() -> PeakList { - PeakList::new( - label="15N-HSQC", - n_dim=2, - peaks=[ - NmrPeak::new( - peak_id=1, - dimensions=["15.HN", "15.N"], - chemical_shifts=[8.34, 118.5], - intensities=[1.0e6, 1.0e6], - volume=Some(2.3e6), - merity=Some(0.95), - ), - NmrPeak::new( - peak_id=2, - dimensions=["16.HN", "16.N"], - chemical_shifts=[8.21, 121.0], - intensities=[8.0e5, 8.0e5], - volume=Some(1.7e6), - merity=Some(0.91), - ), - NmrPeak::new( - peak_id=3, - dimensions=["20.HN", "20.N"], - chemical_shifts=[7.95, 110.2], - intensities=[1.2e6, 1.2e6], - volume=Some(2.8e6), - merity=Some(0.98), - ), - ], - ) + PeakList::new(label="15N-HSQC", n_dim=2, peaks=[ + NmrPeak::new( + peak_id=1, + dimensions=["15.HN", "15.N"], + chemical_shifts=[8.34, 118.5], + intensities=[1.0e6, 1.0e6], + volume=Some(2.3e6), + merity=Some(0.95), + ), + NmrPeak::new( + peak_id=2, + dimensions=["16.HN", "16.N"], + chemical_shifts=[8.21, 121.0], + intensities=[8.0e5, 8.0e5], + volume=Some(1.7e6), + merity=Some(0.91), + ), + NmrPeak::new( + peak_id=3, + dimensions=["20.HN", "20.N"], + chemical_shifts=[7.95, 110.2], + intensities=[1.2e6, 1.2e6], + volume=Some(2.8e6), + merity=Some(0.98), + ), + ]) } ///| @@ -946,7 +936,8 @@ fn nmr_split_lines(text : String) -> Array[String] { let c = text[i:i + 1].to_owned() if c == "\n" { // Strip trailing \r if present. - if cur.length() > 0 && cur[cur.length() - 1:cur.length()].to_owned() == "\r" { + if cur.length() > 0 && + cur[cur.length() - 1:cur.length()].to_owned() == "\r" { cur = cur[0:cur.length() - 1].to_owned() } out.push(cur) diff --git a/src/noiseq.mbt b/src/noiseq.mbt index 390fd82d..0c8c1fc4 100644 --- a/src/noiseq.mbt +++ b/src/noiseq.mbt @@ -122,13 +122,20 @@ pub fn NOISeqMethod::to_string(self : NOISeqMethod) -> String { ///| /// Create a NOISeqSample. -pub fn NOISeqSample::new(sample_id : String, condition : String) -> NOISeqSample { +pub fn NOISeqSample::new( + sample_id : String, + condition : String, +) -> NOISeqSample { NOISeqSample::{ sample_id, condition, counts: Map::new() } } ///| /// Set gene count for a sample. -pub fn NOISeqSample::set_count(self : NOISeqSample, gene_id : String, count : Double) -> Unit { +pub fn NOISeqSample::set_count( + self : NOISeqSample, + gene_id : String, + count : Double, +) -> Unit { self.counts.set(gene_id, count) } @@ -217,7 +224,11 @@ pub fn noiseq_normalize( let lib_size = sample.library_size() // Compute simple scaling factor - let scale = if lib_size > 0.0 && ref_lib > 0.0 { ref_lib / lib_size } else { 1.0 } + let scale = if lib_size > 0.0 && ref_lib > 0.0 { + ref_lib / lib_size + } else { + 1.0 + } let gid_list = sample.counts.keys().collect() let mut gi = 0 @@ -268,14 +279,18 @@ pub fn noiseq_normalize( si = si + 1 } - let uq_pos = (slen * 3) / 4 + let uq_pos = slen * 3 / 4 let upper_quartile = if slen > 0 && uq_pos < slen { counts[uq_pos] } else { 1.0 } - let scale = if upper_quartile > 0.0 { 1.0e6 / upper_quartile } else { 1.0 } + let scale = if upper_quartile > 0.0 { + 1.0e6 / upper_quartile + } else { + 1.0 + } let gid_list = sample.counts.keys().collect() let mut gi = 0 @@ -470,7 +485,11 @@ fn noiseq_mean_abs_diff(values : Array[Double]) -> Double { /// Compute probability from noise distribution. /// In NOISeq, this is the probability that a random gene from the noise /// distribution has a (M, D) value more extreme than the observed. -fn noiseq_compute_prob(m : Double, d : Double, ds_method : NOISeqMethod) -> Double { +fn noiseq_compute_prob( + m : Double, + d : Double, + ds_method : NOISeqMethod, +) -> Double { // The magnitude of the (M, D) vector indicates how far the gene is from the noise let magnitude = (m * m + d * d).sqrt() @@ -483,13 +502,21 @@ fn noiseq_compute_prob(m : Double, d : Double, ds_method : NOISeqMethod) -> Doub // probability ≈ 1 - exp(-magnitude / sigma) let sigma = 1.0 let prob = 1.0 - @math.exp(-magnitude / sigma) - if prob > 1.0 { 1.0 } else { prob } + if prob > 1.0 { + 1.0 + } else { + prob + } } NOISeqMethod::NOISeqSim => { // NOISeqSim is less conservative let sigma = 0.8 let prob = 1.0 - @math.exp(-magnitude / sigma) - if prob > 1.0 { 1.0 } else { prob } + if prob > 1.0 { + 1.0 + } else { + prob + } } } } @@ -502,7 +529,9 @@ pub fn NOISeqResults::get_n_results(self : NOISeqResults) -> Int { ///| /// Get significant results. -pub fn NOISeqResults::get_significant(self : NOISeqResults) -> Array[NOISeqResult] { +pub fn NOISeqResults::get_significant( + self : NOISeqResults, +) -> Array[NOISeqResult] { let sig : Array[NOISeqResult] = Array::new() let mut i = 0 while i < self.results.length() { @@ -516,7 +545,10 @@ pub fn NOISeqResults::get_significant(self : NOISeqResults) -> Array[NOISeqResul ///| /// Get top N genes by probability. -pub fn NOISeqResults::get_top_genes(self : NOISeqResults, n : Int) -> Array[NOISeqResult] { +pub fn NOISeqResults::get_top_genes( + self : NOISeqResults, + n : Int, +) -> Array[NOISeqResult] { let result : Array[NOISeqResult] = Array::new() let take = if n < self.results.length() { n } else { self.results.length() } let mut i = 0 @@ -529,7 +561,9 @@ pub fn NOISeqResults::get_top_genes(self : NOISeqResults, n : Int) -> Array[NOIS ///| /// Get up-regulated genes. -pub fn NOISeqResults::get_up_regulated(self : NOISeqResults) -> Array[NOISeqResult] { +pub fn NOISeqResults::get_up_regulated( + self : NOISeqResults, +) -> Array[NOISeqResult] { let result : Array[NOISeqResult] = Array::new() let mut i = 0 while i < self.results.length() { @@ -543,7 +577,9 @@ pub fn NOISeqResults::get_up_regulated(self : NOISeqResults) -> Array[NOISeqResu ///| /// Get down-regulated genes. -pub fn NOISeqResults::get_down_regulated(self : NOISeqResults) -> Array[NOISeqResult] { +pub fn NOISeqResults::get_down_regulated( + self : NOISeqResults, +) -> Array[NOISeqResult] { let result : Array[NOISeqResult] = Array::new() let mut i = 0 while i < self.results.length() { @@ -562,7 +598,12 @@ pub fn NOISeqResults::summary(self : NOISeqResults) -> String { s = s + "Method: " + self.ds_method.to_string() + "\n" s = s + "Normalization: " + self.norm_method.to_string() + "\n" s = s + "Genes tested: " + self.n_genes.to_string() + "\n" - s = s + "Significant (prob >= " + self.prob_threshold.to_string() + "): " + self.n_sig.to_string() + "\n" + s = s + + "Significant (prob >= " + + self.prob_threshold.to_string() + + "): " + + self.n_sig.to_string() + + "\n" let n_up = self.get_up_regulated().length() let n_down = self.get_down_regulated().length() s = s + " Up-regulated: " + n_up.to_string() + "\n" @@ -608,7 +649,9 @@ pub fn noiseq_qc(samples : Array[NOISeqSample]) -> NOISeqQC { let mut mi = 0 while mi < lib_sizes.length() { let diff = (lib_sizes[mi] - mean_lib).abs() / (mean_lib + 1.0e-10) - if diff > max_d { max_d = diff } + if diff > max_d { + max_d = diff + } mi = mi + 1 } max_d @@ -627,7 +670,10 @@ pub fn noiseq_qc(samples : Array[NOISeqSample]) -> NOISeqQC { ///| /// Create sample data for testing. pub fn noiseq_sample_data() -> (Array[NOISeqSample], Array[NOISeqSample]) { - let genes = ["Gene1", "Gene2", "Gene3", "Gene4", "Gene5", "Gene6", "Gene7", "Gene8", "Gene9", "Gene10"] + let genes = [ + "Gene1", "Gene2", "Gene3", "Gene4", "Gene5", "Gene6", "Gene7", "Gene8", "Gene9", + "Gene10", + ] // Control samples let ctrl_samples : Array[NOISeqSample] = Array::new() diff --git a/src/nucle_r.mbt b/src/nucle_r.mbt index 05763f00..dfcc5634 100644 --- a/src/nucle_r.mbt +++ b/src/nucle_r.mbt @@ -3,6 +3,7 @@ /// Provides functions for nucleosome positioning analysis from sequencing data. /// Supports nucleosome calling, occupancy calculation, and dynamic nucleosome analysis. +///| /// Nucleosome positioning result pub struct NucPosition { /// Chromosome @@ -23,53 +24,79 @@ pub struct NucPosition { well_positioned : Bool } +///| /// Create new nucleosome position -pub fn NucPosition::new(chrom : String, start : Int, end : Int, center : Double, - width : Double, occupancy : Double, - positioning_score : Double, well_positioned : Bool) -> NucPosition { - NucPosition::{ chrom, start, end, center, width, occupancy, positioning_score, well_positioned } +pub fn NucPosition::new( + chrom : String, + start : Int, + end : Int, + center : Double, + width : Double, + occupancy : Double, + positioning_score : Double, + well_positioned : Bool, +) -> NucPosition { + NucPosition::{ + chrom, + start, + end, + center, + width, + occupancy, + positioning_score, + well_positioned, + } } +///| /// Get chromosome pub fn NucPosition::nuc_chrom(self : NucPosition) -> String { self.chrom } +///| /// Get start position pub fn NucPosition::nuc_start(self : NucPosition) -> Int { self.start } +///| /// Get end position pub fn NucPosition::nuc_end(self : NucPosition) -> Int { self.end } +///| /// Get center position pub fn NucPosition::nuc_center(self : NucPosition) -> Double { self.center } +///| /// Get width pub fn NucPosition::nuc_width(self : NucPosition) -> Double { self.width } +///| /// Get occupancy pub fn NucPosition::nuc_occupancy(self : NucPosition) -> Double { self.occupancy } +///| /// Get positioning score pub fn NucPosition::nuc_positioning_score(self : NucPosition) -> Double { self.positioning_score } +///| /// Check if well-positioned pub fn NucPosition::nuc_is_well_positioned(self : NucPosition) -> Bool { self.well_positioned } +///| /// Nucleosome call result pub struct NucCallResult { /// Nucleosome positions @@ -84,40 +111,60 @@ pub struct NucCallResult { frac_well_positioned : Double } +///| /// Create new call result -pub fn NucCallResult::new(nucleosomes : Array[NucPosition], n_nucleosomes : Int, - mean_spacing : Double, mean_occupancy : Double, - frac_well_positioned : Double) -> NucCallResult { - NucCallResult::{ nucleosomes, n_nucleosomes, mean_spacing, mean_occupancy, frac_well_positioned } +pub fn NucCallResult::new( + nucleosomes : Array[NucPosition], + n_nucleosomes : Int, + mean_spacing : Double, + mean_occupancy : Double, + frac_well_positioned : Double, +) -> NucCallResult { + NucCallResult::{ + nucleosomes, + n_nucleosomes, + mean_spacing, + mean_occupancy, + frac_well_positioned, + } } +///| /// Get number of nucleosomes pub fn NucCallResult::nuc_n_count(self : NucCallResult) -> Int { self.n_nucleosomes } +///| /// Get nucleosome at index pub fn NucCallResult::nuc_get(self : NucCallResult, idx : Int) -> NucPosition { self.nucleosomes[idx] } +///| /// Get mean spacing pub fn NucCallResult::nuc_mean_spacing(self : NucCallResult) -> Double { self.mean_spacing } +///| /// Get mean occupancy pub fn NucCallResult::nuc_mean_occupancy(self : NucCallResult) -> Double { self.mean_occupancy } +///| /// Get fraction well-positioned pub fn NucCallResult::nuc_frac_well_positioned(self : NucCallResult) -> Double { self.frac_well_positioned } +///| /// Filter by occupancy threshold -pub fn NucCallResult::nuc_filter_by_occupancy(self : NucCallResult, threshold : Double) -> NucCallResult { +pub fn NucCallResult::nuc_filter_by_occupancy( + self : NucCallResult, + threshold : Double, +) -> NucCallResult { let filtered : Array[NucPosition] = Array::new() let mut i = 0 @@ -128,10 +175,16 @@ pub fn NucCallResult::nuc_filter_by_occupancy(self : NucCallResult, threshold : i = i + 1 } - NucCallResult::new(filtered, filtered.length(), self.mean_spacing, - self.mean_occupancy, self.frac_well_positioned) + NucCallResult::new( + filtered, + filtered.length(), + self.mean_spacing, + self.mean_occupancy, + self.frac_well_positioned, + ) } +///| /// Dynamic nucleosome result for comparison pub struct NucDynamicResult { /// Shared nucleosomes @@ -146,37 +199,49 @@ pub struct NucDynamicResult { direction : Int } +///| /// Create new dynamic result -pub fn NucDynamicResult::new(shared : Array[NucPosition], gained : Array[NucPosition], - lost : Array[NucPosition], frac_changed : Double, direction : Int) -> NucDynamicResult { +pub fn NucDynamicResult::new( + shared : Array[NucPosition], + gained : Array[NucPosition], + lost : Array[NucPosition], + frac_changed : Double, + direction : Int, +) -> NucDynamicResult { NucDynamicResult::{ shared, gained, lost, frac_changed, direction } } +///| /// Get number of shared nucleosomes pub fn NucDynamicResult::nuc_n_shared(self : NucDynamicResult) -> Int { self.shared.length() } +///| /// Get number of gained nucleosomes pub fn NucDynamicResult::nuc_n_gained(self : NucDynamicResult) -> Int { self.gained.length() } +///| /// Get number of lost nucleosomes pub fn NucDynamicResult::nuc_n_lost(self : NucDynamicResult) -> Int { self.lost.length() } +///| /// Get fraction changed pub fn NucDynamicResult::nuc_frac_changed(self : NucDynamicResult) -> Double { self.frac_changed } +///| /// Get direction pub fn NucDynamicResult::nuc_direction(self : NucDynamicResult) -> Int { self.direction } +///| /// Smoothing methods pub enum NucSmoothMethod { /// Moving average @@ -187,6 +252,7 @@ pub enum NucSmoothMethod { SavitzkyGolay } +///| /// Nucleosome calling parameters pub struct NucCallParams { /// Smoothing window size @@ -203,32 +269,84 @@ pub struct NucCallParams { width_threshold : Double } +///| /// Create default parameters pub fn NucCallParams::new() -> NucCallParams { - NucCallParams::{ smooth_window: 100, peak_threshold: 0.5, min_distance: 100, max_distance: 300, - occupancy_threshold: 0.3, width_threshold: 60.0 } + NucCallParams::{ + smooth_window: 100, + peak_threshold: 0.5, + min_distance: 100, + max_distance: 300, + occupancy_threshold: 0.3, + width_threshold: 60.0, + } } +///| /// Set smoothing window -pub fn NucCallParams::nuc_set_smooth_window(self : NucCallParams, window : Int) -> NucCallParams { - NucCallParams::{ smooth_window: window, peak_threshold: self.peak_threshold, min_distance: self.min_distance, max_distance: self.max_distance, occupancy_threshold: self.occupancy_threshold, width_threshold: self.width_threshold } +pub fn NucCallParams::nuc_set_smooth_window( + self : NucCallParams, + window : Int, +) -> NucCallParams { + NucCallParams::{ + smooth_window: window, + peak_threshold: self.peak_threshold, + min_distance: self.min_distance, + max_distance: self.max_distance, + occupancy_threshold: self.occupancy_threshold, + width_threshold: self.width_threshold, + } } +///| /// Set peak threshold -pub fn NucCallParams::nuc_set_peak_threshold(self : NucCallParams, threshold : Double) -> NucCallParams { - NucCallParams::{ smooth_window: self.smooth_window, peak_threshold: threshold, min_distance: self.min_distance, max_distance: self.max_distance, occupancy_threshold: self.occupancy_threshold, width_threshold: self.width_threshold } +pub fn NucCallParams::nuc_set_peak_threshold( + self : NucCallParams, + threshold : Double, +) -> NucCallParams { + NucCallParams::{ + smooth_window: self.smooth_window, + peak_threshold: threshold, + min_distance: self.min_distance, + max_distance: self.max_distance, + occupancy_threshold: self.occupancy_threshold, + width_threshold: self.width_threshold, + } } +///| /// Set minimum distance -pub fn NucCallParams::nuc_set_min_distance(self : NucCallParams, dist : Int) -> NucCallParams { - NucCallParams::{ smooth_window: self.smooth_window, peak_threshold: self.peak_threshold, min_distance: dist, max_distance: self.max_distance, occupancy_threshold: self.occupancy_threshold, width_threshold: self.width_threshold } +pub fn NucCallParams::nuc_set_min_distance( + self : NucCallParams, + dist : Int, +) -> NucCallParams { + NucCallParams::{ + smooth_window: self.smooth_window, + peak_threshold: self.peak_threshold, + min_distance: dist, + max_distance: self.max_distance, + occupancy_threshold: self.occupancy_threshold, + width_threshold: self.width_threshold, + } } +///| /// Set occupancy threshold -pub fn NucCallParams::nuc_set_occupancy_threshold(self : NucCallParams, threshold : Double) -> NucCallParams { - NucCallParams::{ smooth_window: self.smooth_window, peak_threshold: self.peak_threshold, min_distance: self.min_distance, max_distance: self.max_distance, occupancy_threshold: threshold, width_threshold: self.width_threshold } +pub fn NucCallParams::nuc_set_occupancy_threshold( + self : NucCallParams, + threshold : Double, +) -> NucCallParams { + NucCallParams::{ + smooth_window: self.smooth_window, + peak_threshold: self.peak_threshold, + min_distance: self.min_distance, + max_distance: self.max_distance, + occupancy_threshold: threshold, + width_threshold: self.width_threshold, + } } +///| /// Signal track for nucleosome analysis pub struct NucSignalTrack { /// Chromosome @@ -243,13 +361,23 @@ pub struct NucSignalTrack { length : Int } +///| /// Create new signal track -pub fn NucSignalTrack::new(chrom : String, signal : Array[Double], start : Int, step : Int) -> NucSignalTrack { +pub fn NucSignalTrack::new( + chrom : String, + signal : Array[Double], + start : Int, + step : Int, +) -> NucSignalTrack { NucSignalTrack::{ chrom, signal, start, step, length: signal.length() } } +///| /// Get signal value at position -pub fn NucSignalTrack::nuc_get_signal(self : NucSignalTrack, pos : Int) -> Double { +pub fn NucSignalTrack::nuc_get_signal( + self : NucSignalTrack, + pos : Int, +) -> Double { let idx = (pos - self.start) / self.step if idx >= 0 && idx < self.length { self.signal[idx] @@ -258,23 +386,33 @@ pub fn NucSignalTrack::nuc_get_signal(self : NucSignalTrack, pos : Int) -> Doubl } } +///| /// Get position for index -pub fn NucSignalTrack::nuc_get_position(self : NucSignalTrack, idx : Int) -> Int { +pub fn NucSignalTrack::nuc_get_position( + self : NucSignalTrack, + idx : Int, +) -> Int { self.start + idx * self.step } +///| /// Get length pub fn NucSignalTrack::nuc_get_length(self : NucSignalTrack) -> Int { self.length } +///| /// Get chromosome pub fn NucSignalTrack::nuc_get_chrom(self : NucSignalTrack) -> String { self.chrom } +///| /// Smooth signal track -pub fn nuc_smooth_signal(track : NucSignalTrack, window : Int) -> NucSignalTrack { +pub fn nuc_smooth_signal( + track : NucSignalTrack, + window : Int, +) -> NucSignalTrack { let n = track.signal.length() let smoothed : Array[Double] = Array::make(n, 0.0) @@ -301,8 +439,13 @@ pub fn nuc_smooth_signal(track : NucSignalTrack, window : Int) -> NucSignalTrack NucSignalTrack::new(track.chrom, smoothed, track.start, track.step) } +///| /// Find peaks in signal -pub fn nuc_find_peaks(track : NucSignalTrack, threshold : Double, min_distance : Int) -> Array[Int] { +pub fn nuc_find_peaks( + track : NucSignalTrack, + threshold : Double, + min_distance : Int, +) -> Array[Int] { let n = track.signal.length() let peaks : Array[Int] = Array::new() @@ -317,7 +460,8 @@ pub fn nuc_find_peaks(track : NucSignalTrack, threshold : Double, min_distance : let pos = track.start + i * track.step // Check minimum distance from last peak - if peaks.length() == 0 || (pos - track.start) - peaks[peaks.length() - 1] >= min_distance { + if peaks.length() == 0 || + pos - track.start - peaks[peaks.length() - 1] >= min_distance { peaks.push(pos - track.start) } else if val > track.signal[peaks[peaks.length() - 1]] { // Replace if higher @@ -330,15 +474,29 @@ pub fn nuc_find_peaks(track : NucSignalTrack, threshold : Double, min_distance : peaks } +///| /// Calculate occupancy from signal -pub fn nuc_calculate_occupancy(track : NucSignalTrack, - start_pos : Int, end_pos : Int) -> Double { +pub fn nuc_calculate_occupancy( + track : NucSignalTrack, + start_pos : Int, + end_pos : Int, +) -> Double { let n = track.signal.length() - let start_idx = if start_pos >= track.start { (start_pos - track.start) / track.step } else { 0 } + let start_idx = if start_pos >= track.start { + (start_pos - track.start) / track.step + } else { + 0 + } let end_idx = if end_pos > track.start { let idx = (end_pos - track.start) / track.step - if idx < n { idx } else { n } - } else { 0 } + if idx < n { + idx + } else { + n + } + } else { + 0 + } if start_idx >= end_idx { return 0.0 @@ -366,13 +524,21 @@ pub fn nuc_calculate_occupancy(track : NucSignalTrack, } } +///| /// Call nucleosomes from signal -pub fn nuc_call_nucleosomes(track : NucSignalTrack, params : NucCallParams) -> NucCallResult { +pub fn nuc_call_nucleosomes( + track : NucSignalTrack, + params : NucCallParams, +) -> NucCallResult { // Smooth the signal let smoothed = nuc_smooth_signal(track, params.smooth_window) // Find peaks - let peak_indices = nuc_find_peaks(smoothed, params.peak_threshold, params.min_distance) + let peak_indices = nuc_find_peaks( + smoothed, + params.peak_threshold, + params.min_distance, + ) // Convert peaks to nucleosome positions let nucleosomes : Array[NucPosition] = Array::new() @@ -395,16 +561,18 @@ pub fn nuc_call_nucleosomes(track : NucSignalTrack, params : NucCallParams) -> N let well_positioned = width < params.width_threshold - nucleosomes.push(NucPosition::new( - track.chrom, - start_pos, - end_pos, - center_pos.to_double(), - width, - occupancy, - positioning_score, - well_positioned - )) + nucleosomes.push( + NucPosition::new( + track.chrom, + start_pos, + end_pos, + center_pos.to_double(), + width, + occupancy, + positioning_score, + well_positioned, + ), + ) i = i + 1 } @@ -415,12 +583,18 @@ pub fn nuc_call_nucleosomes(track : NucSignalTrack, params : NucCallParams) -> N let mean_occupancy = calculate_mean_occupancy(nucleosomes) let frac_well_positioned = calculate_frac_well_positioned(nucleosomes) - NucCallResult::new(nucleosomes, n_nucleosomes, mean_spacing, - mean_occupancy, frac_well_positioned) + NucCallResult::new( + nucleosomes, n_nucleosomes, mean_spacing, mean_occupancy, frac_well_positioned, + ) } +///| /// Estimate peak width -fn estimate_peak_width(track : NucSignalTrack, center_idx : Int, threshold : Double) -> Double { +fn estimate_peak_width( + track : NucSignalTrack, + center_idx : Int, + threshold : Double, +) -> Double { let n = track.signal.length() let max_val = track.signal[center_idx] let half_max = max_val * threshold @@ -440,6 +614,7 @@ fn estimate_peak_width(track : NucSignalTrack, center_idx : Int, threshold : Dou ((right - left) * track.step).to_double() } +///| /// Calculate mean spacing between nucleosomes fn calculate_mean_spacing(nucleosomes : Array[NucPosition]) -> Double { if nucleosomes.length() < 2 { @@ -478,9 +653,14 @@ fn calculate_mean_spacing(nucleosomes : Array[NucPosition]) -> Double { i = i + 1 } - if count > 0 { total / count.to_double() } else { 0.0 } + if count > 0 { + total / count.to_double() + } else { + 0.0 + } } +///| /// Calculate mean occupancy fn calculate_mean_occupancy(nucleosomes : Array[NucPosition]) -> Double { if nucleosomes.length() == 0 { @@ -497,6 +677,7 @@ fn calculate_mean_occupancy(nucleosomes : Array[NucPosition]) -> Double { sum / nucleosomes.length().to_double() } +///| /// Calculate fraction well-positioned fn calculate_frac_well_positioned(nucleosomes : Array[NucPosition]) -> Double { if nucleosomes.length() == 0 { @@ -515,9 +696,13 @@ fn calculate_frac_well_positioned(nucleosomes : Array[NucPosition]) -> Double { count.to_double() / nucleosomes.length().to_double() } +///| /// Compare nucleosome positioning between two conditions -pub fn nuc_compare_positioning(result1 : NucCallResult, result2 : NucCallResult, - tolerance : Int) -> NucDynamicResult { +pub fn nuc_compare_positioning( + result1 : NucCallResult, + result2 : NucCallResult, + tolerance : Int, +) -> NucDynamicResult { let shared : Array[NucPosition] = Array::new() let gained : Array[NucPosition] = Array::new() let lost : Array[NucPosition] = Array::new() @@ -532,7 +717,7 @@ pub fn nuc_compare_positioning(result1 : NucCallResult, result2 : NucCallResult, while j < result2.nucleosomes.length() { let nuc2 = result2.nucleosomes[j] if nuc1.chrom == nuc2.chrom && - (nuc1.center - nuc2.center).abs() <= tolerance.to_double() { + (nuc1.center - nuc2.center).abs() <= tolerance.to_double() { shared.push(nuc1) found = true break @@ -557,7 +742,7 @@ pub fn nuc_compare_positioning(result1 : NucCallResult, result2 : NucCallResult, while m < result1.nucleosomes.length() { let nuc1 = result1.nucleosomes[m] if nuc1.chrom == nuc2.chrom && - (nuc1.center - nuc2.center).abs() <= tolerance.to_double() { + (nuc1.center - nuc2.center).abs() <= tolerance.to_double() { found = true break } @@ -574,15 +759,22 @@ pub fn nuc_compare_positioning(result1 : NucCallResult, result2 : NucCallResult, let total = result1.n_nucleosomes + result2.n_nucleosomes let frac_changed = if total > 0 { (gained.length() + lost.length()).to_double() / total.to_double() - } else { 0.0 } + } else { + 0.0 + } - let direction = if gained.length() > lost.length() { 1 } - else if lost.length() > gained.length() { -1 } - else { 0 } + let direction = if gained.length() > lost.length() { + 1 + } else if lost.length() > gained.length() { + -1 + } else { + 0 + } NucDynamicResult::new(shared, gained, lost, frac_changed, direction) } +///| /// Create example signal track for testing pub fn nuc_create_example_track() -> NucSignalTrack { let length = 1000 @@ -628,9 +820,10 @@ pub fn nuc_create_example_track() -> NucSignalTrack { NucSignalTrack::new("chr1", signal, start, step) } +///| /// Create example nucleosome call result pub fn nuc_create_example_result() -> NucCallResult { let track = nuc_create_example_track() let params = NucCallParams::new() nuc_call_nucleosomes(track, params) -} \ No newline at end of file +} diff --git a/src/open_cyto.mbt b/src/open_cyto.mbt index 9f7d9940..b153f01d 100644 --- a/src/open_cyto.mbt +++ b/src/open_cyto.mbt @@ -58,11 +58,7 @@ pub struct OcGate { ///| /// Construct a 1D gate. -pub fn OcGate::new1d( - dim~ : String, - min~ : Double, - max~ : Double, -) -> OcGate { +pub fn OcGate::new1d(dim~ : String, min~ : Double, max~ : Double) -> OcGate { OcGate::{ dim1: dim, dim2: None, min1: min, max1: max, min2: 0.0, max2: 0.0 } } @@ -76,7 +72,7 @@ pub fn OcGate::new2d( min2~ : Double, max2~ : Double, ) -> OcGate { - OcGate::{ dim1: dim1, dim2: Some(dim2), min1, max1, min2, max2 } + OcGate::{ dim1, dim2: Some(dim2), min1, max1, min2, max2 } } ///| @@ -264,11 +260,7 @@ pub fn oc_ln(x : Double) -> Double { /// Evaluate a Gaussian KDE at point `x` given data and bandwidth `h`. /// KDE(x) = (1 / (n*h)) * Σ φ((x - xi) / h) /// where φ is the standard normal density. -pub fn oc_kde_evaluate( - data : Array[Double], - x : Double, - h : Double, -) -> Double { +pub fn oc_kde_evaluate(data : Array[Double], x : Double, h : Double) -> Double { let n = data.length() if n == 0 || h <= 0.0 { return 0.0 @@ -356,7 +348,7 @@ pub fn oc_mindensity( ) -> OcGate { let n = values.length() if n == 0 { - return OcGate::new1d(dim=dim, min=0.0, max=1.0e30) + return OcGate::new1d(dim~, min=0.0, max=1.0e30) } let n_points = 200 let h = match args.get("bandwidth") { @@ -365,7 +357,7 @@ pub fn oc_mindensity( } let (gx, gy) = oc_kde_grid(values, n_points, h) if gx.length() < 3 { - return OcGate::new1d(dim=dim, min=oc_median(values), max=1.0e30) + return OcGate::new1d(dim~, min=oc_median(values), max=1.0e30) } // find local maxima (peaks) let peaks : Array[Int] = Array::new() @@ -377,7 +369,7 @@ pub fn oc_mindensity( if peaks.length() < 2 { // single peak: use the median let m = oc_median(values) - return OcGate::new1d(dim=dim, min=m, max=1.0e30) + return OcGate::new1d(dim~, min=m, max=1.0e30) } // find the two highest peaks let mut p1 = peaks[0] @@ -417,7 +409,7 @@ pub fn oc_mindensity( Some(m) => m None => 1.0e30 } - OcGate::new1d(dim=dim, min=threshold, max=max_val) + OcGate::new1d(dim~, min=threshold, max=max_val) } // ============================================================================ @@ -436,7 +428,7 @@ pub fn oc_tailgate( ) -> OcGate { let n = values.length() if n == 0 { - return OcGate::new1d(dim=dim, min=0.0, max=1.0e30) + return OcGate::new1d(dim~, min=0.0, max=1.0e30) } let q = match args.get("quantile") { Some(v) => v @@ -447,7 +439,7 @@ pub fn oc_tailgate( Some(m) => m None => 1.0e30 } - OcGate::new1d(dim=dim, min=threshold, max=max_val) + OcGate::new1d(dim~, min=threshold, max=max_val) } // ============================================================================ @@ -464,7 +456,7 @@ pub fn oc_quantile_gate( ) -> OcGate { let n = values.length() if n == 0 { - return OcGate::new1d(dim=dim, min=0.0, max=1.0e30) + return OcGate::new1d(dim~, min=0.0, max=1.0e30) } let q = match args.get("probs") { Some(v) => v @@ -475,7 +467,7 @@ pub fn oc_quantile_gate( Some(m) => m None => 1.0e30 } - OcGate::new1d(dim=dim, min=threshold, max=max_val) + OcGate::new1d(dim~, min=threshold, max=max_val) } // ============================================================================ @@ -492,7 +484,7 @@ pub fn oc_range_gate( ) -> OcGate { let n = values.length() if n == 0 { - return OcGate::new1d(dim=dim, min=0.0, max=1.0e30) + return OcGate::new1d(dim~, min=0.0, max=1.0e30) } let sorted = Array::new() for v in values { @@ -529,7 +521,7 @@ pub fn oc_range_gate( Some(m) => m None => 1.0e30 } - OcGate::new1d(dim=dim, min=threshold, max=max_val) + OcGate::new1d(dim~, min=threshold, max=max_val) } // ============================================================================ @@ -596,7 +588,7 @@ pub fn oc_flow_clust( let gate_min2 = means2[best] - 2.0 * sd2 let gate_max2 = means2[best] + 2.0 * sd2 OcGate::new2d( - dim1=dim1, + dim1~, dim2=dim2.unwrap(), min1=gate_min1, max1=gate_max1, @@ -623,7 +615,9 @@ pub fn oc_em_t_mixture_1d( // initialize means via quantiles let means = Array::new() for k in 0.. Double { } let g = 7.0 let c = [ - 0.99999999999980993, - 676.5203681218851, - -1259.1392167224028, - 771.32342877765313, - -176.61502916214059, - 12.507343278686905, - -0.13857109526572012, - 9.9843695780195716e-6, + 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, + -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7, ] let mut x_adj = x - 1.0 @@ -795,7 +785,10 @@ pub fn oc_lgamma(x : Double) -> Double { a = a + c[i] / x_adj } let t = x + g - 0.5 - 0.5 * @math.ln(2.0 * 3.141592653589793) + (x - 0.5) * @math.ln(t) - t + @math.ln(a) + 0.5 * @math.ln(2.0 * 3.141592653589793) + + (x - 0.5) * @math.ln(t) - + t + + @math.ln(a) } ///| @@ -896,7 +889,7 @@ pub fn oc_gate_flow_set( OcGatingResult::new( population=rule.child, sample=sample_name, - gate=gate, + gate~, parent_events=0, child_events=0, indices=Array::new(), @@ -949,7 +942,14 @@ pub fn oc_gate_flow_set( for i in parent_event_indices { vals2.push(events[i][dim2_idx]) } - oc_flow_clust(vals1, vals2, rule.dims[0], Some(rule.dims[1]), rule.args, n_clusters) + oc_flow_clust( + vals1, + vals2, + rule.dims[0], + Some(rule.dims[1]), + rule.args, + n_clusters, + ) } else { oc_flow_clust(vals1, [], rule.dims[0], None, rule.args, n_clusters) } @@ -972,7 +972,11 @@ pub fn oc_gate_flow_set( let v1 = if dim_idx >= 0 { events[i][dim_idx] } else { 0.0 } let v2 = if rule.dims.length() >= 2 { let d2 = oc_resolve_channel(flowset.channel_names, rule.dims[1]) - if d2 >= 0 { events[i][d2] } else { 0.0 } + if d2 >= 0 { + events[i][d2] + } else { + 0.0 + } } else { 0.0 } @@ -985,7 +989,7 @@ pub fn oc_gate_flow_set( OcGatingResult::new( population=rule.child, sample=sample_name, - gate=gate, + gate~, parent_events=parent_event_indices.length(), child_events=child_count, indices=child_flags, diff --git a/src/pairaligner.mbt b/src/pairaligner.mbt index 09e1b326..df1c731e 100644 --- a/src/pairaligner.mbt +++ b/src/pairaligner.mbt @@ -415,33 +415,39 @@ fn pairaligner_chars_equal_ci(a : Char, b : Char) -> Bool { /// BLOSUM62 data for 20 standard amino acids in order: /// A R N D C Q E G H I L K M F P S T W Y V let pairaligner_blosum62_data : Array[Array[Int]] = [ - [ 4,-1,-2,-2, 0,-1,-1, 0,-2,-1,-1,-1,-1,-2,-1, 1, 0,-3,-2, 0], // A - [-1, 5, 0,-2,-3, 1, 0,-2, 0,-3,-2, 2,-1,-3,-2,-1,-1,-3,-2,-3], // R - [-2, 0, 6, 1,-3, 0, 0, 0, 1,-3,-3, 0,-2,-3,-2, 1, 0,-4,-2,-3], // N - [-2,-2, 1, 6,-3, 0, 2,-1,-1,-3,-4,-1,-3,-3,-1, 0,-1,-4,-3,-3], // D - [ 0,-3,-3,-3, 9,-3,-4,-3,-3,-1,-1,-3,-1,-2,-3,-1,-1,-2,-2,-1], // C - [-1, 1, 0, 0,-3, 5, 2,-2, 0,-3,-2, 1, 0,-3,-1, 0,-1,-2,-1,-2], // Q - [-1, 0, 0, 2,-4, 2, 5,-2, 0,-3,-3, 1,-2,-3,-1, 0,-1,-3,-2,-2], // E - [ 0,-2, 0,-1,-3,-2,-2, 6,-2,-4,-4,-2,-3,-3,-2, 0,-2,-2,-3,-3], // G - [-2, 0, 1,-1,-3, 0, 0,-2, 8,-3,-3,-1,-2,-1,-2,-1,-2,-2, 2,-3], // H - [-1,-3,-3,-3,-1,-3,-3,-4,-3, 4, 2,-3, 1, 0,-3,-2,-1,-3,-1, 3], // I - [-1,-2,-3,-4,-1,-2,-3,-4,-3, 2, 4,-2, 2, 0,-3,-2,-1,-2,-1, 1], // L - [-1, 2, 0,-1,-3, 1, 1,-2,-1,-3,-2, 5,-1,-3,-1, 0,-1,-3,-2,-2], // K - [-1,-1,-2,-3,-1, 0,-2,-3,-2, 1, 2,-1, 5, 0,-2,-1,-1,-1,-1, 1], // M - [-2,-3,-3,-3,-2,-3,-3,-3,-1, 0, 0,-3, 0, 6,-4,-2,-2, 1, 3,-1], // F - [-1,-2,-2,-1,-3,-1,-1,-2,-2,-3,-3,-1,-2,-4, 7,-1,-1,-4,-3,-2], // P - [ 1,-1, 1, 0,-1, 0, 0, 0,-1,-2,-2, 0,-1,-2,-1, 4, 1,-3,-2,-2], // S - [ 0,-1, 0,-1,-1,-1,-1,-2,-2,-1,-1,-1,-1,-2,-1, 1, 5,-2,-2, 0], // T - [-3,-3,-4,-4,-2,-2,-3,-2,-2,-3,-2,-3,-1, 1,-4,-3,-2,11, 2,-3], // W - [-2,-2,-2,-3,-2,-1,-2,-3, 2,-1,-1,-2,-1, 3,-3,-2,-2, 2, 7,-1], // Y - [ 0,-3,-3,-3,-1,-2,-2,-3,-3, 3, 1,-2, 1,-1,-2,-2, 0,-3,-1, 4], // V + [4, -1, -2, -2, 0, -1, -1, 0, -2, -1, -1, -1, -1, -2, -1, 1, 0, -3, -2, 0], // A + [-1, 5, 0, -2, -3, 1, 0, -2, 0, -3, -2, 2, -1, -3, -2, -1, -1, -3, -2, -3], // R + [-2, 0, 6, 1, -3, 0, 0, 0, 1, -3, -3, 0, -2, -3, -2, 1, 0, -4, -2, -3], // N + [-2, -2, 1, 6, -3, 0, 2, -1, -1, -3, -4, -1, -3, -3, -1, 0, -1, -4, -3, -3], // D + [0, -3, -3, -3, 9, -3, -4, -3, -3, -1, -1, -3, -1, -2, -3, -1, -1, -2, -2, -1], // C + [-1, 1, 0, 0, -3, 5, 2, -2, 0, -3, -2, 1, 0, -3, -1, 0, -1, -2, -1, -2], // Q + [-1, 0, 0, 2, -4, 2, 5, -2, 0, -3, -3, 1, -2, -3, -1, 0, -1, -3, -2, -2], // E + [0, -2, 0, -1, -3, -2, -2, 6, -2, -4, -4, -2, -3, -3, -2, 0, -2, -2, -3, -3], // G + [-2, 0, 1, -1, -3, 0, 0, -2, 8, -3, -3, -1, -2, -1, -2, -1, -2, -2, 2, -3], // H + [-1, -3, -3, -3, -1, -3, -3, -4, -3, 4, 2, -3, 1, 0, -3, -2, -1, -3, -1, 3], // I + [-1, -2, -3, -4, -1, -2, -3, -4, -3, 2, 4, -2, 2, 0, -3, -2, -1, -2, -1, 1], // L + [-1, 2, 0, -1, -3, 1, 1, -2, -1, -3, -2, 5, -1, -3, -1, 0, -1, -3, -2, -2], // K + [-1, -1, -2, -3, -1, 0, -2, -3, -2, 1, 2, -1, 5, 0, -2, -1, -1, -1, -1, 1], // M + [-2, -3, -3, -3, -2, -3, -3, -3, -1, 0, 0, -3, 0, 6, -4, -2, -2, 1, 3, -1], // F + [ + -1, -2, -2, -1, -3, -1, -1, -2, -2, -3, -3, -1, -2, -4, 7, -1, -1, -4, -3, -2, + ], // P + [1, -1, 1, 0, -1, 0, 0, 0, -1, -2, -2, 0, -1, -2, -1, 4, 1, -3, -2, -2], // S + [0, -1, 0, -1, -1, -1, -1, -2, -2, -1, -1, -1, -1, -2, -1, 1, 5, -2, -2, 0], // T + [-3, -3, -4, -4, -2, -2, -3, -2, -2, -3, -2, -3, -1, 1, -4, -3, -2, 11, 2, -3], // W + [-2, -2, -2, -3, -2, -1, -2, -3, 2, -1, -1, -2, -1, 3, -3, -2, -2, 2, 7, -1], // Y + [0, -3, -3, -3, -1, -2, -2, -3, -3, 3, 1, -2, 1, -1, -2, -2, 0, -3, -1, 4], // V ] ///| /// Internal BLOSUM62 matrix lookup using 20 standard amino acids. /// Returns score for a pair (case-insensitive). /// Uses mismatch_score default for unknown amino acids. -fn pairaligner_blosum62_score(a : Char, b : Char, mismatch_default : Double) -> Double { +fn pairaligner_blosum62_score( + a : Char, + b : Char, + mismatch_default : Double, +) -> Double { let ia = pairaligner_aa_index_ci(a) let ib = pairaligner_aa_index_ci(b) if ia < 0 || ib < 0 { @@ -494,15 +500,14 @@ fn pairaligner_get_subst_score( config : PairwiseAlignerConfig, ) -> Double { let is_protein = config.alphabet_type == "PROTEIN" - let use_matrix = is_protein && config.submatrix == SubstitutionMatrixChoice::Blosum62 + let use_matrix = is_protein && + config.submatrix == SubstitutionMatrixChoice::Blosum62 if use_matrix { pairaligner_blosum62_score(a, b, config.mismatch_score) + } else if pairaligner_chars_equal_ci(a, b) { + config.match_score } else { - if pairaligner_chars_equal_ci(a, b) { - config.match_score - } else { - config.mismatch_score - } + config.mismatch_score } } @@ -547,6 +552,7 @@ fn pairaligner_reverse_string(s : String) -> String { // Traceback direction enum (internal) // ============================================================ +///| priv enum TraceDir { Stop Diag @@ -579,10 +585,13 @@ pub fn pairaligner_align( let is_local = config.mode == AlignmentMode::Local // ---- Initialize DP matrices ---- - let m_mat : Array[Array[Double]] = pairaligner_make_matrix(n + 1, m + 1, 0.0) - let ix_mat : Array[Array[Double]] = pairaligner_make_matrix(n + 1, m + 1, 0.0) - let iy_mat : Array[Array[Double]] = pairaligner_make_matrix(n + 1, m + 1, 0.0) - let trace : Array[Array[TraceDir]] = pairaligner_make_trace_matrix(n + 1, m + 1) + let m_mat : Array[Array[Double]] = pairaligner_make_matrix(n + 1, m + 1, 0.0) + let ix_mat : Array[Array[Double]] = pairaligner_make_matrix(n + 1, m + 1, 0.0) + let iy_mat : Array[Array[Double]] = pairaligner_make_matrix(n + 1, m + 1, 0.0) + let trace : Array[Array[TraceDir]] = pairaligner_make_trace_matrix( + n + 1, + m + 1, + ) let target_gap_open = config.target_gap_open let target_gap_extend = config.target_gap_extend @@ -651,33 +660,51 @@ pub fn pairaligner_align( let s = pairaligner_get_subst_score(tc, qc, config) // Compute m_mat[i][j]: match/mismatch - let from_M = m_mat[i - 1][j - 1] + s + let from_M = m_mat[i - 1][j - 1] + s let from_Ix = ix_mat[i - 1][j - 1] + s let from_Iy = iy_mat[i - 1][j - 1] + s let mut m_val = from_M - if from_Ix > m_val { m_val = from_Ix } - if from_Iy > m_val { m_val = from_Iy } + if from_Ix > m_val { + m_val = from_Ix + } + if from_Iy > m_val { + m_val = from_Iy + } // Compute ix_mat[i][j]: gap in query (Up step) - let ix_extend = ix_mat[i - 1][j] + query_gap_extend - let ix_open_from_M = m_mat[i - 1][j] + query_gap_open + let ix_extend = ix_mat[i - 1][j] + query_gap_extend + let ix_open_from_M = m_mat[i - 1][j] + query_gap_open let ix_open_from_Iy = iy_mat[i - 1][j] + query_gap_open let mut ix_val = ix_extend - if ix_open_from_M > ix_val { ix_val = ix_open_from_M } - if ix_open_from_Iy > ix_val { ix_val = ix_open_from_Iy } + if ix_open_from_M > ix_val { + ix_val = ix_open_from_M + } + if ix_open_from_Iy > ix_val { + ix_val = ix_open_from_Iy + } // Compute iy_mat[i][j]: gap in target (Left step) - let iy_extend = iy_mat[i][j - 1] + target_gap_extend - let iy_open_from_M = m_mat[i][j - 1] + target_gap_open + let iy_extend = iy_mat[i][j - 1] + target_gap_extend + let iy_open_from_M = m_mat[i][j - 1] + target_gap_open let iy_open_from_Ix = ix_mat[i][j - 1] + target_gap_open let mut iy_val = iy_extend - if iy_open_from_M > iy_val { iy_val = iy_open_from_M } - if iy_open_from_Ix > iy_val { iy_val = iy_open_from_Ix } + if iy_open_from_M > iy_val { + iy_val = iy_open_from_M + } + if iy_open_from_Ix > iy_val { + iy_val = iy_open_from_Ix + } if is_local { - if m_val < 0.0 { m_val = 0.0 } - if ix_val < 0.0 { ix_val = 0.0 } - if iy_val < 0.0 { iy_val = 0.0 } + if m_val < 0.0 { + m_val = 0.0 + } + if ix_val < 0.0 { + ix_val = 0.0 + } + if iy_val < 0.0 { + iy_val = 0.0 + } } // Choose overall best and record trace @@ -692,7 +719,7 @@ pub fn pairaligner_align( best_dir = TraceDir::Left } - m_mat[i][j] = m_val + m_mat[i][j] = m_val ix_mat[i][j] = ix_val iy_mat[i][j] = iy_val @@ -720,12 +747,16 @@ pub fn pairaligner_align( let (start_i, start_j, final_score) : (Int, Int, Double) = if is_local { (max_i, max_j, max_score) } else { - let m_nm = m_mat[n][m] + let m_nm = m_mat[n][m] let ix_nm = ix_mat[n][m] let iy_nm = iy_mat[n][m] let mut best = m_nm - if ix_nm > best { best = ix_nm } - if iy_nm > best { best = iy_nm } + if ix_nm > best { + best = ix_nm + } + if iy_nm > best { + best = iy_nm + } (n, m, best) } @@ -822,7 +853,11 @@ pub fn pairaligner_align( ///| /// Create a 2D Double matrix of size rows x cols filled with val. -fn pairaligner_make_matrix(rows : Int, cols : Int, val : Double) -> Array[Array[Double]] { +fn pairaligner_make_matrix( + rows : Int, + cols : Int, + val : Double, +) -> Array[Array[Double]] { let result : Array[Array[Double]] = Array::new() let mut i = 0 while i < rows { @@ -840,7 +875,10 @@ fn pairaligner_make_matrix(rows : Int, cols : Int, val : Double) -> Array[Array[ ///| /// Create a 2D trace matrix filled with Stop. -fn pairaligner_make_trace_matrix(rows : Int, cols : Int) -> Array[Array[TraceDir]] { +fn pairaligner_make_trace_matrix( + rows : Int, + cols : Int, +) -> Array[Array[TraceDir]] { let result : Array[Array[TraceDir]] = Array::new() let mut i = 0 while i < rows { diff --git a/src/pairwise2.mbt b/src/pairwise2.mbt index 7bf43b00..f086ec51 100644 --- a/src/pairwise2.mbt +++ b/src/pairwise2.mbt @@ -27,13 +27,17 @@ pub struct PairwiseAlignResult { ///| /// Get the aligned first sequence. -pub fn PairwiseAlignResult::get_aligned_seq1(self : PairwiseAlignResult) -> String { +pub fn PairwiseAlignResult::get_aligned_seq1( + self : PairwiseAlignResult, +) -> String { self.aligned_seq1 } ///| /// Get the aligned second sequence. -pub fn PairwiseAlignResult::get_aligned_seq2(self : PairwiseAlignResult) -> String { +pub fn PairwiseAlignResult::get_aligned_seq2( + self : PairwiseAlignResult, +) -> String { self.aligned_seq2 } @@ -51,7 +55,10 @@ pub fn PairwiseAlignResult::get_mode(self : PairwiseAlignResult) -> String { ///| /// Get the alignment as a formatted string. -pub fn PairwiseAlignResult::format_alignment(self : PairwiseAlignResult, line_width : Int) -> String { +pub fn PairwiseAlignResult::format_alignment( + self : PairwiseAlignResult, + line_width : Int, +) -> String { let w = if line_width <= 0 { 60 } else { line_width } let mut result = "" let len = self.aligned_seq1.length() @@ -59,8 +66,8 @@ pub fn PairwiseAlignResult::format_alignment(self : PairwiseAlignResult, line_wi let mut pos = 0 while pos < len { let end = if pos + w < len { pos + w } else { len } - let s1 = self.aligned_seq1.substring(start=pos, end=end) - let s2 = self.aligned_seq2.substring(start=pos, end=end) + let s1 = self.aligned_seq1.substring(start=pos, end~) + let s2 = self.aligned_seq2.substring(start=pos, end~) let pos1 = self.seq1_start + pos let pos2 = self.seq2_start + pos @@ -116,9 +123,16 @@ pub fn pairwise_result_new( ///| /// Create a simple match/mismatch scoring function. /// Returns a function that scores based on match/mismatch values. -pub fn simple_score(match_sc : Double, mismatch_sc : Double) -> (String, String) -> Double { +pub fn simple_score( + match_sc : Double, + mismatch_sc : Double, +) -> (String, String) -> Double { fn(c1 : String, c2 : String) -> Double { - if c1.to_upper() == c2.to_upper() { match_sc } else { mismatch_sc } + if c1.to_upper() == c2.to_upper() { + match_sc + } else { + mismatch_sc + } } } @@ -130,9 +144,16 @@ pub fn identity_score() -> (String, String) -> Double { ///| /// Create a scoring function using a substitution matrix (Map-based). -pub fn matrix_score(matrix : Map[String, Double], default : Double) -> (String, String) -> Double { +pub fn matrix_score( + matrix : Map[String, Double], + default : Double, +) -> (String, String) -> Double { fn(c1 : String, c2 : String) -> Double { - let k = if c1 <= c2 { c1.to_upper() + c2.to_upper() } else { c2.to_upper() + c1.to_upper() } + let k = if c1 <= c2 { + c1.to_upper() + c2.to_upper() + } else { + c2.to_upper() + c1.to_upper() + } match matrix.get(k) { Some(v) => v None => default @@ -142,7 +163,10 @@ pub fn matrix_score(matrix : Map[String, Double], default : Double) -> (String, ///| /// Create a standard DNA scoring matrix (A/T/C/G pairwise). -pub fn dna_matrix(match_sc : Double, mismatch_sc : Double) -> Map[String, Double] { +pub fn dna_matrix( + match_sc : Double, + mismatch_sc : Double, +) -> Map[String, Double] { let m : Map[String, Double] = Map([], capacity=10) m["AA"] = match_sc m["AC"] = mismatch_sc @@ -157,16 +181,24 @@ pub fn dna_matrix(match_sc : Double, mismatch_sc : Double) -> Map[String, Double m } +///| /// Helper: get element from flat Double matrix -fn get_flat_double(arr : Array[Double], i : Int, j : Int, m_plus_1 : Int) -> Double { +fn get_flat_double( + arr : Array[Double], + i : Int, + j : Int, + m_plus_1 : Int, +) -> Double { arr[i * m_plus_1 + j] } +///| /// Helper: get element from flat Int matrix fn get_flat_int(arr : Array[Int], i : Int, j : Int, m_plus_1 : Int) -> Int { arr[i * m_plus_1 + j] } +///| /// Helper: initialize flat Double matrix of size (n+1) x (m+1) with fill_val fn init_flat_double(n : Int, m : Int, fill_val : Double) -> Array[Double] { let size = (n + 1) * (m + 1) @@ -179,6 +211,7 @@ fn init_flat_double(n : Int, m : Int, fill_val : Double) -> Array[Double] { arr } +///| /// Helper: initialize flat Int matrix of size (n+1) x (m+1) with fill_val fn init_flat_int(n : Int, m : Int, fill_val : Int) -> Array[Int] { let size = (n + 1) * (m + 1) @@ -421,7 +454,10 @@ pub fn pairwise_localxx( let mut start1 = p let mut start2 = q - while p > 0 && q > 0 && get_flat_int(tb, p, q, m_plus_1) != -1 && get_flat_double(sc, p, q, m_plus_1) > 0.0 { + while p > 0 && + q > 0 && + get_flat_int(tb, p, q, m_plus_1) != -1 && + get_flat_double(sc, p, q, m_plus_1) > 0.0 { let dir = get_flat_int(tb, p, q, m_plus_1) if dir == 0 { aligned1 = seq1.substring(start=p - 1, end=p) + aligned1 @@ -683,7 +719,10 @@ pub fn pairwise_localms( let mut start1 = p let mut start2 = q - while p > 0 && q > 0 && get_flat_int(tb, p, q, m_plus_1) != -1 && get_flat_double(sc, p, q, m_plus_1) > 0.0 { + while p > 0 && + q > 0 && + get_flat_int(tb, p, q, m_plus_1) != -1 && + get_flat_double(sc, p, q, m_plus_1) > 0.0 { let dir = get_flat_int(tb, p, q, m_plus_1) if dir == 0 { aligned1 = seq1.substring(start=p - 1, end=p) + aligned1 @@ -753,8 +792,16 @@ pub fn alignment_summary(result : PairwiseAlignResult) -> String { i = i + 1 } - let identity = if len > 0 { (matches.to_double() / len.to_double()) * 100.0 } else { 0.0 } - let similarity = if len > 0 { ((matches + mismatches).to_double() / len.to_double()) * 100.0 } else { 0.0 } + let identity = if len > 0 { + matches.to_double() / len.to_double() * 100.0 + } else { + 0.0 + } + let similarity = if len > 0 { + (matches + mismatches).to_double() / len.to_double() * 100.0 + } else { + 0.0 + } let mut summary = "=== Pairwise Alignment Summary ===\n".to_string() summary = summary + "Mode: \{result.mode}\n" @@ -766,4 +813,4 @@ pub fn alignment_summary(result : PairwiseAlignResult) -> String { summary = summary + "Identity: \{identity.to_string()}%\n" summary = summary + "Similarity: \{similarity.to_string()}%\n" summary -} \ No newline at end of file +} diff --git a/src/paml.mbt b/src/paml.mbt index 7bd98cee..74c7713f 100644 --- a/src/paml.mbt +++ b/src/paml.mbt @@ -12,11 +12,7 @@ pub struct PAMLAlignment { ///| pub fn PAMLAlignment::new(sequences : Array[(String, String)]) -> PAMLAlignment { - PAMLAlignment::{ - sequences, - tree: "", - model: "HKY85" - } + PAMLAlignment::{ sequences, tree: "", model: "HKY85" } } ///| @@ -35,7 +31,7 @@ pub fn PAMLResult::new(ln_likelihood : Double) -> PAMLResult { parameters: Map([], capacity=10), dnds_ratios: Array::new(), substitution_rates: Array::new(), - ancestral_sequences: Array::new() + ancestral_sequences: Array::new(), } } @@ -59,120 +55,172 @@ pub fn DNDSResult::new(dN : Double, dS : Double, omega : Double) -> DNDSResult { se_dN: 0.0, se_dS: 0.0, se_omega: 0.0, - method: "Nei-Gojobori" + method: "Nei-Gojobori", } } ///| -pub fn paml_calculate_dnds(seq1 : String, seq2 : String, method : String) -> DNDSResult { +pub fn paml_calculate_dnds( + seq1 : String, + seq2 : String, + method : String, +) -> DNDSResult { let aligned_seq1 = to_lowercase(seq1) let aligned_seq2 = to_lowercase(seq2) - + if aligned_seq1.length() != aligned_seq2.length() { return DNDSResult::new(0.0, 0.0, 0.0) } - + let mut synonymous_sites = 0.0 let mut non_synonymous_sites = 0.0 let mut synonymous_changes = 0 let mut non_synonymous_changes = 0 - + let codon_table = get_standard_codon_table() - + let mut i = 0 while i < aligned_seq1.length() - 2 { let codon1 = substring(aligned_seq1, i, 3) let codon2 = substring(aligned_seq2, i, 3) - + if !contains(codon1, "-") && !contains(codon2, "-") { let aa1 = codon_table.get(codon1).unwrap_or("X") let aa2 = codon_table.get(codon2).unwrap_or("X") - + let (syn_sites, non_syn_sites) = count_sites(codon1, codon2, codon_table) synonymous_sites = synonymous_sites + syn_sites non_synonymous_sites = non_synonymous_sites + non_syn_sites - + if aa1 != aa2 { non_synonymous_changes = non_synonymous_changes + 1 } else if codon1 != codon2 { synonymous_changes = synonymous_changes + 1 } } - + i = i + 3 } - + let dS = if synonymous_sites > 0.0 { - paml_jukes_cantor_correction(synonymous_changes.to_double() / synonymous_sites) + paml_jukes_cantor_correction( + synonymous_changes.to_double() / synonymous_sites, + ) } else { 0.0 } - + let dN = if non_synonymous_sites > 0.0 { - paml_jukes_cantor_correction(non_synonymous_changes.to_double() / non_synonymous_sites) + paml_jukes_cantor_correction( + non_synonymous_changes.to_double() / non_synonymous_sites, + ) } else { 0.0 } - + let omega = if dS > 0.0 { dN / dS } else { 0.0 } - + DNDSResult::new(dN, dS, omega) } ///| pub fn get_standard_codon_table() -> Map[String, String] { let table = Map([], capacity=64) - - table.set("TTT", "F"); table.set("TTC", "F") - table.set("TTA", "L"); table.set("TTG", "L") - table.set("TCT", "S"); table.set("TCC", "S"); table.set("TCA", "S"); table.set("TCG", "S") - table.set("TAT", "Y"); table.set("TAC", "Y") - table.set("TAA", "*"); table.set("TAG", "*"); table.set("TGA", "*") - table.set("TGT", "C"); table.set("TGC", "C") + + table.set("TTT", "F") + table.set("TTC", "F") + table.set("TTA", "L") + table.set("TTG", "L") + table.set("TCT", "S") + table.set("TCC", "S") + table.set("TCA", "S") + table.set("TCG", "S") + table.set("TAT", "Y") + table.set("TAC", "Y") + table.set("TAA", "*") + table.set("TAG", "*") + table.set("TGA", "*") + table.set("TGT", "C") + table.set("TGC", "C") table.set("TGG", "W") - - table.set("CTT", "L"); table.set("CTC", "L"); table.set("CTA", "L"); table.set("CTG", "L") - table.set("CCT", "P"); table.set("CCC", "P"); table.set("CCA", "P"); table.set("CCG", "P") - table.set("CAT", "H"); table.set("CAC", "H") - table.set("CAA", "Q"); table.set("CAG", "Q") - table.set("CGT", "R"); table.set("CGC", "R"); table.set("CGA", "R"); table.set("CGG", "R") - - table.set("ATT", "I"); table.set("ATC", "I"); table.set("ATA", "I") + + table.set("CTT", "L") + table.set("CTC", "L") + table.set("CTA", "L") + table.set("CTG", "L") + table.set("CCT", "P") + table.set("CCC", "P") + table.set("CCA", "P") + table.set("CCG", "P") + table.set("CAT", "H") + table.set("CAC", "H") + table.set("CAA", "Q") + table.set("CAG", "Q") + table.set("CGT", "R") + table.set("CGC", "R") + table.set("CGA", "R") + table.set("CGG", "R") + + table.set("ATT", "I") + table.set("ATC", "I") + table.set("ATA", "I") table.set("ATG", "M") - table.set("ACT", "T"); table.set("ACC", "T"); table.set("ACA", "T"); table.set("ACG", "T") - table.set("AAT", "N"); table.set("AAC", "N") - table.set("AAA", "K"); table.set("AAG", "K") - table.set("AGT", "S"); table.set("AGC", "S") - table.set("AGA", "R"); table.set("AGG", "R") - - table.set("GTT", "V"); table.set("GTC", "V"); table.set("GTA", "V"); table.set("GTG", "V") - table.set("GCT", "A"); table.set("GCC", "A"); table.set("GCA", "A"); table.set("GCG", "A") - table.set("GAT", "D"); table.set("GAC", "D") - table.set("GAA", "E"); table.set("GAG", "E") - table.set("GGT", "G"); table.set("GGC", "G"); table.set("GGA", "G"); table.set("GGG", "G") - + table.set("ACT", "T") + table.set("ACC", "T") + table.set("ACA", "T") + table.set("ACG", "T") + table.set("AAT", "N") + table.set("AAC", "N") + table.set("AAA", "K") + table.set("AAG", "K") + table.set("AGT", "S") + table.set("AGC", "S") + table.set("AGA", "R") + table.set("AGG", "R") + + table.set("GTT", "V") + table.set("GTC", "V") + table.set("GTA", "V") + table.set("GTG", "V") + table.set("GCT", "A") + table.set("GCC", "A") + table.set("GCA", "A") + table.set("GCG", "A") + table.set("GAT", "D") + table.set("GAC", "D") + table.set("GAA", "E") + table.set("GAG", "E") + table.set("GGT", "G") + table.set("GGC", "G") + table.set("GGA", "G") + table.set("GGG", "G") + table } ///| -fn count_sites(codon1 : String, codon2 : String, codon_table : Map[String, String]) -> (Double, Double) { +fn count_sites( + codon1 : String, + codon2 : String, + codon_table : Map[String, String], +) -> (Double, Double) { let aa1 = codon_table.get(codon1).unwrap_or("X") let aa2 = codon_table.get(codon2).unwrap_or("X") - + if aa1 == "*" || aa2 == "*" || aa1 == "X" || aa2 == "X" { return (0.0, 0.0) } - + if aa1 == aa2 { let mut syn_count = 0 let mut all_count = 0 - + let mut pos = 0 while pos < 3 { if char_at(codon1, pos) != char_at(codon2, pos) { all_count = all_count + 1 let bases = ["A", "T", "C", "G"] - + let mut b = 0 while b < bases.length() { let mut new_codon = "" @@ -185,7 +233,7 @@ fn count_sites(codon1 : String, codon2 : String, codon_table : Map[String, Strin } p = p + 1 } - + if codon_table.contains(new_codon) && codon_table[new_codon] == aa1 { syn_count = syn_count + 1 break @@ -195,9 +243,12 @@ fn count_sites(codon1 : String, codon2 : String, codon_table : Map[String, Strin } pos = pos + 1 } - + if all_count > 0 { - return (syn_count.to_double() / all_count.to_double(), (all_count - syn_count).to_double() / all_count.to_double()) + return ( + syn_count.to_double() / all_count.to_double(), + (all_count - syn_count).to_double() / all_count.to_double(), + ) } else { return (0.333, 0.667) } @@ -220,15 +271,15 @@ fn paml_jukes_cantor_correction(p : Double) -> Double { ///| pub fn paml_estimate_parameters(alignment : PAMLAlignment) -> PAMLResult { let result = PAMLResult::new(-100.0) - + let n_seqs = alignment.sequences.length() let seq_len = if n_seqs > 0 { alignment.sequences[0].1.length() } else { 0 } - + let mut pi_A = 0.0 let mut pi_T = 0.0 let mut pi_C = 0.0 let mut pi_G = 0.0 - + let mut total = 0 let mut s = 0 while s < n_seqs { @@ -250,13 +301,13 @@ pub fn paml_estimate_parameters(alignment : PAMLAlignment) -> PAMLResult { } s = s + 1 } - + let denom = total.to_double() pi_A = pi_A / denom pi_T = pi_T / denom pi_C = pi_C / denom pi_G = pi_G / denom - + let params = result.parameters.copy() params.set("pi_A", pi_A) params.set("pi_T", pi_T) @@ -264,41 +315,44 @@ pub fn paml_estimate_parameters(alignment : PAMLAlignment) -> PAMLResult { params.set("pi_G", pi_G) params.set("kappa", 2.0) params.set("omega", 0.5) - + PAMLResult::{ ln_likelihood: -seq_len.to_double() * @math.log2(0.25), parameters: params, dnds_ratios: result.dnds_ratios, substitution_rates: result.substitution_rates, - ancestral_sequences: result.ancestral_sequences + ancestral_sequences: result.ancestral_sequences, } } ///| -pub fn paml_calculate_substitution_matrix(kappa : Double, pi : Map[String, Double]) -> Array[Array[Double]] { +pub fn paml_calculate_substitution_matrix( + kappa : Double, + pi : Map[String, Double], +) -> Array[Array[Double]] { let q = Array::make(4, Array::make(4, 0.0)) - + let pi_A = pi.get("pi_A").unwrap_or(0.25) let pi_T = pi.get("pi_T").unwrap_or(0.25) let pi_C = pi.get("pi_C").unwrap_or(0.25) let pi_G = pi.get("pi_G").unwrap_or(0.25) - + q[0][1] = kappa * pi_T q[0][2] = pi_C q[0][3] = pi_G - + q[1][0] = kappa * pi_A q[1][2] = pi_C q[1][3] = pi_G - + q[2][0] = pi_A q[2][1] = pi_T q[2][3] = kappa * pi_G - + q[3][0] = pi_A q[3][1] = pi_T q[3][2] = kappa * pi_C - + let mut i = 0 while i < 4 { let mut sum = 0.0 @@ -312,7 +366,7 @@ pub fn paml_calculate_substitution_matrix(kappa : Double, pi : Map[String, Doubl q[i][i] = -sum i = i + 1 } - + q } @@ -322,23 +376,23 @@ pub fn paml_create_example_alignment() -> PAMLAlignment { ("Human", "ATGGCCGGTAAATGA"), ("Mouse", "ATGGCCGGTAAATGA"), ("Rat", "ATGGCCGGTAATAGA"), - ("Chicken", "ATGGCCGGTAATGGA") + ("Chicken", "ATGGCCGGTAATGGA"), ] - + let alignment = PAMLAlignment::new(seqs) PAMLAlignment::{ sequences: alignment.sequences, tree: "((Human,Mouse),Rat,Chicken)", - model: "HKY85" + model: "HKY85", } } ///| pub fn paml_run_likelihood(alignment : PAMLAlignment) -> PAMLResult { let result = paml_estimate_parameters(alignment) - + let dnds_results : Array[(String, Double)] = Array::new() - + let seqs = alignment.sequences let mut i = 0 while i < seqs.length() { @@ -350,12 +404,12 @@ pub fn paml_run_likelihood(alignment : PAMLAlignment) -> PAMLResult { } i = i + 1 } - + PAMLResult::{ ln_likelihood: result.ln_likelihood, parameters: result.parameters, dnds_ratios: dnds_results, substitution_rates: result.substitution_rates, - ancestral_sequences: result.ancestral_sequences + ancestral_sequences: result.ancestral_sequences, } -} \ No newline at end of file +} diff --git a/src/parsimony.mbt b/src/parsimony.mbt index 6ebb70b0..e1b522b7 100644 --- a/src/parsimony.mbt +++ b/src/parsimony.mbt @@ -24,7 +24,7 @@ pub struct ParsimonyMatrix { /// Create a parsimony cost matrix. pub fn ParsimonyMatrix::new( states : Array[String], - costs : Array[Array[Double]] + costs : Array[Array[Double]], ) -> ParsimonyMatrix { ParsimonyMatrix::{ states, costs } } @@ -34,7 +34,7 @@ pub fn ParsimonyMatrix::new( pub fn parsimony_matrix_cost( matrix : ParsimonyMatrix, from_idx : Int, - to_idx : Int + to_idx : Int, ) -> Double { matrix.costs[from_idx][to_idx] } @@ -71,7 +71,7 @@ pub fn parsimony_fitch_dna_matrix() -> ParsimonyMatrix { /// Transitions (A<->G, C<->T) cost 1, transversions cost 2. pub fn parsimony_sankoff_dna_matrix( transition_cost? : Double = 1.0, - transversion_cost? : Double = 2.0 + transversion_cost? : Double = 2.0, ) -> ParsimonyMatrix { let states = ["A", "C", "G", "T"] let costs = [ @@ -92,7 +92,7 @@ pub fn parsimony_sankoff_dna_matrix( /// - The total score is the sum of costs across all positions. pub fn fitch_parsimony_score( tree : Tree, - alignment : Map[String, String] + alignment : Map[String, String], ) -> Double { if alignment.size() == 0 { return -1.0 @@ -120,7 +120,7 @@ pub fn fitch_parsimony_score( fn fitch_score_position( clade : Clade, alignment : Map[String, String], - pos : Int + pos : Int, ) -> Double { let (states, score) = fitch_compute_states(clade, alignment, pos) ignore(states) @@ -134,7 +134,7 @@ fn fitch_score_position( fn fitch_compute_states( clade : Clade, alignment : Map[String, String], - pos : Int + pos : Int, ) -> (Array[String], Double) { if clade.is_terminal() { let name = match clade.name { @@ -158,7 +158,11 @@ fn fitch_compute_states( let mut first = true let mut ci = 0 while ci < clade.clades.length() { - let (child_states, child_score) = fitch_compute_states(clade.clades[ci], alignment, pos) + let (child_states, child_score) = fitch_compute_states( + clade.clades[ci], + alignment, + pos, + ) total_score = total_score + child_score if first { combined = child_states @@ -180,7 +184,10 @@ fn fitch_compute_states( ///| /// Compute the intersection of two state sets. -fn fitch_set_intersection(a : Array[String], b : Array[String]) -> Array[String] { +fn fitch_set_intersection( + a : Array[String], + b : Array[String], +) -> Array[String] { let result : Array[String] = Array::new() let mut i = 0 while i < a.length() { @@ -238,7 +245,7 @@ fn fitch_set_union(a : Array[String], b : Array[String]) -> Array[String] { pub fn sankoff_parsimony_score( tree : Tree, alignment : Map[String, String], - matrix : ParsimonyMatrix + matrix : ParsimonyMatrix, ) -> Double { if alignment.size() == 0 { return -1.0 @@ -255,7 +262,8 @@ pub fn sankoff_parsimony_score( let mut total_score = 0.0 let mut pos = 0 while pos < aln_len { - total_score = total_score + sankoff_score_position(tree.root, alignment, pos, matrix) + total_score = total_score + + sankoff_score_position(tree.root, alignment, pos, matrix) pos = pos + 1 } total_score @@ -267,7 +275,7 @@ fn sankoff_score_position( clade : Clade, alignment : Map[String, String], pos : Int, - matrix : ParsimonyMatrix + matrix : ParsimonyMatrix, ) -> Double { let scores = sankoff_compute_scores(clade, alignment, pos, matrix) let mut min_score = 1.0e30 @@ -278,7 +286,11 @@ fn sankoff_score_position( } i = i + 1 } - if min_score >= 1.0e30 { 0.0 } else { min_score } + if min_score >= 1.0e30 { + 0.0 + } else { + min_score + } } ///| @@ -288,7 +300,7 @@ fn sankoff_compute_scores( clade : Clade, alignment : Map[String, String], pos : Int, - matrix : ParsimonyMatrix + matrix : ParsimonyMatrix, ) -> Array[Double] { let n_states = matrix.states.length() if clade.is_terminal() { @@ -341,7 +353,7 @@ fn sankoff_compute_scores( pub fn parsimony_get_score( tree : Tree, alignment : Map[String, String], - matrix? : ParsimonyMatrix? = None + matrix? : ParsimonyMatrix? = None, ) -> Double { match matrix { Some(m) => sankoff_parsimony_score(tree, alignment, m) diff --git a/src/pathway.mbt b/src/pathway.mbt index 0ca03c7e..6aa49c7d 100644 --- a/src/pathway.mbt +++ b/src/pathway.mbt @@ -22,7 +22,13 @@ pub struct Reaction { } ///| -pub fn Reaction::new(id : String, name : String, reactants : Array[String], products : Array[String], reversible : Bool) -> Reaction { +pub fn Reaction::new( + id : String, + name : String, + reactants : Array[String], + products : Array[String], + reversible : Bool, +) -> Reaction { Reaction::{ id, name, reactants, products, reversible } } @@ -43,7 +49,12 @@ pub struct Pathway { } ///| -pub fn Pathway::new(id : String, name : String, species : Array[Species], reactions : Array[Reaction]) -> Pathway { +pub fn Pathway::new( + id : String, + name : String, + species : Array[Species], + reactions : Array[Reaction], +) -> Pathway { Pathway::{ id, name, species, reactions } } @@ -60,13 +71,16 @@ pub fn pathway_find_species(pathway : Pathway, id : String) -> Species? { } ///| -pub fn pathway_find_reactions_with_species(pathway : Pathway, species_id : String) -> Array[Reaction] { +pub fn pathway_find_reactions_with_species( + pathway : Pathway, + species_id : String, +) -> Array[Reaction] { let result : Array[Reaction] = Array::new() - + let mut i = 0 while i < pathway.reactions.length() { let reaction = pathway.reactions[i] - + let mut j = 0 while j < reaction.reactants.length() { if reaction.reactants[j] == species_id { @@ -75,7 +89,7 @@ pub fn pathway_find_reactions_with_species(pathway : Pathway, species_id : Strin } j = j + 1 } - + if j == reaction.reactants.length() { j = 0 while j < reaction.products.length() { @@ -86,10 +100,10 @@ pub fn pathway_find_reactions_with_species(pathway : Pathway, species_id : Strin j = j + 1 } } - + i = i + 1 } - + result } @@ -117,7 +131,7 @@ pub fn create_example_pathway() -> Pathway { let f16bp = Species::new("f16bp", "Fructose-1,6-bisphosphate") let dhap = Species::new("dhap", "Dihydroxyacetone phosphate") let g3p = Species::new("g3p", "Glyceraldehyde-3-phosphate") - + let species : Array[Species] = Array::new() species.push(glucose) species.push(g6p) @@ -125,44 +139,48 @@ pub fn create_example_pathway() -> Pathway { species.push(f16bp) species.push(dhap) species.push(g3p) - + let reactants1 : Array[String] = Array::new() reactants1.push("glucose") let products1 : Array[String] = Array::new() products1.push("g6p") let r1 = Reaction::new("r1", "Hexokinase", reactants1, products1, false) - + let reactants2 : Array[String] = Array::new() reactants2.push("g6p") let products2 : Array[String] = Array::new() products2.push("f6p") let r2 = Reaction::new("r2", "Isomerase", reactants2, products2, true) - + let reactants3 : Array[String] = Array::new() reactants3.push("f6p") let products3 : Array[String] = Array::new() products3.push("f16bp") - let r3 = Reaction::new("r3", "Phosphofructokinase", reactants3, products3, false) - + let r3 = Reaction::new( + "r3", "Phosphofructokinase", reactants3, products3, false, + ) + let reactants4 : Array[String] = Array::new() reactants4.push("f16bp") let products4 : Array[String] = Array::new() products4.push("dhap") products4.push("g3p") let r4 = Reaction::new("r4", "Aldolase", reactants4, products4, true) - + let reactants5 : Array[String] = Array::new() reactants5.push("dhap") let products5 : Array[String] = Array::new() products5.push("g3p") - let r5 = Reaction::new("r5", "Triose-phosphate isomerase", reactants5, products5, true) - + let r5 = Reaction::new( + "r5", "Triose-phosphate isomerase", reactants5, products5, true, + ) + let reactions : Array[Reaction] = Array::new() reactions.push(r1) reactions.push(r2) reactions.push(r3) reactions.push(r4) reactions.push(r5) - + Pathway::new("glycolysis", "Glycolysis", species, reactions) -} \ No newline at end of file +} diff --git a/src/pcatools.mbt b/src/pcatools.mbt index 7b0d62f7..176dd51e 100644 --- a/src/pcatools.mbt +++ b/src/pcatools.mbt @@ -8,11 +8,16 @@ // ---------- helper linear algebra / stats primitives ---------- -fn pca_is_na(x : Double) -> Bool { x.is_nan() } +fn pca_is_na(x : Double) -> Bool { + x.is_nan() +} +///| fn pca_transpose(a : Array[Array[Double]]) -> Array[Array[Double]] { let n = a.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let m = a[0].length() let out : Array[Array[Double]] = Array::new() let mut j = 0 @@ -29,22 +34,28 @@ fn pca_transpose(a : Array[Array[Double]]) -> Array[Array[Double]] { out } +///| fn pca_copy(a : Array[Array[Double]]) -> Array[Array[Double]] { let out : Array[Array[Double]] = Array::new() for row in a { let nr : Array[Double] = Array::new() - for x in row { nr.push(x) } + for x in row { + nr.push(x) + } out.push(nr) } out } +///| fn center_and_scale_cols( data : Array[Array[Double]], scale : Bool, ) -> (Array[Array[Double]], Array[Double], Array[Double]) { let n = data.length() - if n == 0 { return ([], [], []) } + if n == 0 { + return ([], [], []) + } let p = data[0].length() let means : Array[Double] = Array::new() let sds : Array[Double] = Array::new() @@ -76,16 +87,8 @@ fn center_and_scale_cols( } i2 = i2 + 1 } - let variance = if c2 < 2 { - 1.0 - } else { - s2 / (c2 - 1).to_double() - } - let sd = if variance <= 0.0 { - 1.0 - } else { - variance.sqrt() - } + let variance = if c2 < 2 { 1.0 } else { s2 / (c2 - 1).to_double() } + let sd = if variance <= 0.0 { 1.0 } else { variance.sqrt() } sds.push(sd) } else { sds.push(1.0) @@ -110,11 +113,12 @@ fn center_and_scale_cols( (out, means, sds) } -fn compute_covariance_matrix( - x : Array[Array[Double]], -) -> Array[Array[Double]] { +///| +fn compute_covariance_matrix(x : Array[Array[Double]]) -> Array[Array[Double]] { let n = x.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let p = x[0].length() let out : Array[Array[Double]] = Array::new() let denom = (if n - 1 < 1 { 1 } else { n - 1 }).to_double() @@ -138,12 +142,15 @@ fn compute_covariance_matrix( out } +///| fn power_iteration_pca( cov : Array[Array[Double]], n_components : Int, ) -> (Array[Array[Double]], Array[Double]) { let p = cov.length() - if p == 0 { return ([], []) } + if p == 0 { + return ([], []) + } let k = if n_components < 1 { 1 } else if n_components > p { @@ -160,11 +167,7 @@ fn power_iteration_pca( let mut v : Array[Double] = Array::new() let mut ii = 0 while ii < p { - let vv = if ii == comp { - 1.0 - } else { - 0.5.pow(comp.to_double()) - } + let vv = if ii == comp { 1.0 } else { 0.5.pow(comp.to_double()) } v.push(vv) ii = ii + 1 } @@ -202,7 +205,9 @@ fn power_iteration_pca( kk = kk + 1 } let nrm = if nrm2 == 0.0 { 0.0 } else { nrm2.sqrt() } - if nrm < zero_eps { break } + if nrm < zero_eps { + break + } let mut kk2 = 0 while kk2 < p { v_new[kk2] = v_new[kk2] / nrm @@ -229,10 +234,14 @@ fn power_iteration_pca( } v = v_new eig = rq - if diff.sqrt() < 0.00000001 { break } + if diff.sqrt() < 0.00000001 { + break + } iter_count = iter_count + 1 } - if eig < 0.0 { eig = 0.0 } + if eig < 0.0 { + eig = 0.0 + } eigvecs_rows.push(v) eigvals.push(eig) // deflate @@ -251,12 +260,15 @@ fn power_iteration_pca( (v_cols, eigvals) } +///| fn pca_matmul( a : Array[Array[Double]], b : Array[Array[Double]], ) -> Array[Array[Double]] { let n = a.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let ka = a[0].length() let kb = b.length() let p = if kb == 0 { 0 } else { b[0].length() } @@ -282,9 +294,12 @@ fn pca_matmul( out } +///| fn compute_variance_explained(eigvals : Array[Double]) -> Array[Double] { let mut total = 0.0 - for e in eigvals { total = total + e } + for e in eigvals { + total = total + e + } let out : Array[Double] = Array::new() if total == 0.0 { for e in eigvals { @@ -292,11 +307,14 @@ fn compute_variance_explained(eigvals : Array[Double]) -> Array[Double] { out.push(0.0) } } else { - for e in eigvals { out.push(e / total) } + for e in eigvals { + out.push(e / total) + } } out } +///| fn compute_cumulative(x : Array[Double]) -> Array[Double] { let out : Array[Double] = Array::new() let mut s = 0.0 @@ -309,6 +327,7 @@ fn compute_cumulative(x : Array[Double]) -> Array[Double] { // ---------- FullPCAResult ---------- +///| pub struct FullPCAResult { pub scores : Array[Array[Double]] pub loadings : Array[Array[Double]] @@ -323,6 +342,7 @@ pub struct FullPCAResult { pub used_scaling : Bool } +///| pub fn pcatools_run_pca( data : Array[Array[Double]], n_components : Int, @@ -350,13 +370,17 @@ pub fn pcatools_run_pca( let variance_explained = compute_variance_explained(eigvals) let cumulative_variance = compute_cumulative(variance_explained) FullPCAResult::{ - scores: scores, + scores, loadings: eigvecs, eigenvalues: eigvals, - variance_explained: variance_explained, - cumulative_variance: cumulative_variance, + variance_explained, + cumulative_variance, n_samples: data.length(), - n_variables: if data.length() == 0 { 0 } else { data[0].length() }, + n_variables: if data.length() == 0 { + 0 + } else { + data[0].length() + }, n_components: eigvals.length(), center: means, scale: sds, @@ -364,16 +388,29 @@ pub fn pcatools_run_pca( } } +///| pub fn pcatools_summary(res : FullPCAResult) -> String { let buf = StringBuilder::new() - buf.write_string("PCAResult: \{res.n_samples} samples, \{res.n_variables} variables\n") - buf.write_string(" components = \{res.n_components}, scaling = \{res.used_scaling}\n") + buf.write_string( + "PCAResult: \{res.n_samples} samples, \{res.n_variables} variables\n", + ) + buf.write_string( + " components = \{res.n_components}, scaling = \{res.used_scaling}\n", + ) let k = if res.n_components < 8 { res.n_components } else { 8 } let mut i = 0 while i < k { let ev = if i < res.eigenvalues.length() { res.eigenvalues[i] } else { 0.0 } - let ve = if i < res.variance_explained.length() { res.variance_explained[i] } else { 0.0 } - let cv = if i < res.cumulative_variance.length() { res.cumulative_variance[i] } else { 0.0 } + let ve = if i < res.variance_explained.length() { + res.variance_explained[i] + } else { + 0.0 + } + let cv = if i < res.cumulative_variance.length() { + res.cumulative_variance[i] + } else { + 0.0 + } buf.write_string(" PC\{i+1}: eig=\{ev} var=\{ve} cum=\{cv}\n") i = i + 1 } @@ -385,19 +422,24 @@ pub fn pcatools_summary(res : FullPCAResult) -> String { // ---------- scree_plot_ascii ---------- +///| pub fn scree_plot_ascii( res : FullPCAResult, height? : Int = 8, width_per_pc? : Int = 3, ) -> String { let k = res.variance_explained.length() - if k == 0 { return "(no PCs available for scree plot)".to_string() } + if k == 0 { + return "(no PCs available for scree plot)".to_string() + } let buf = StringBuilder::new() let mut max_ve = 0.0 if res.variance_explained.length() > 0 { max_ve = res.variance_explained[0] for x in res.variance_explained { - if x > max_ve { max_ve = x } + if x > max_ve { + max_ve = x + } } } let mm = if max_ve == 0.0 { 1.0 } else { max_ve } @@ -408,17 +450,15 @@ pub fn scree_plot_ascii( let threshold = frac * mm let mut i = 0 while i < k { - let cell = if res.variance_explained[i] >= threshold { - "#" - } else { - " " - } + let cell = if res.variance_explained[i] >= threshold { "#" } else { " " } let mut w = 0 while w < width_per_pc { buf.write_string(cell) w = w + 1 } - if i + 1 < k { buf.write_string(" ") } + if i + 1 < k { + buf.write_string(" ") + } i = i + 1 } buf.write_string(" \{threshold}\n") @@ -444,6 +484,7 @@ pub fn scree_plot_ascii( // ---------- pca_biplot_ascii ---------- +///| pub struct BiplotOptions { pub pc_x : Int pub pc_y : Int @@ -452,16 +493,12 @@ pub struct BiplotOptions { pub max_loadings : Int } +///| pub fn BiplotOptions::new() -> BiplotOptions { - BiplotOptions::{ - pc_x: 1, - pc_y: 2, - width: 60, - height: 20, - max_loadings: 8, - } + BiplotOptions::{ pc_x: 1, pc_y: 2, width: 60, height: 20, max_loadings: 8 } } +///| pub fn pca_biplot_ascii( res : FullPCAResult, opts? : BiplotOptions = BiplotOptions::new(), @@ -489,10 +526,18 @@ pub fn pca_biplot_ascii( let mut ymin = res.scores[0][iy] let mut ymax = ymin for s in res.scores { - if s[ix] < xmin { xmin = s[ix] } - if s[ix] > xmax { xmax = s[ix] } - if s[iy] < ymin { ymin = s[iy] } - if s[iy] > ymax { ymax = s[iy] } + if s[ix] < xmin { + xmin = s[ix] + } + if s[ix] > xmax { + xmax = s[ix] + } + if s[iy] < ymin { + ymin = s[iy] + } + if s[iy] > ymax { + ymax = s[iy] + } } let xr = if xmax - xmin == 0.0 { 1.0 } else { xmax - xmin } let yr = if ymax - ymin == 0.0 { 1.0 } else { ymax - ymin } @@ -528,13 +573,17 @@ pub fn pca_biplot_ascii( let mut c_axis = 0 while c_axis < w { let ch = grid[oyr][c_axis] - if ch == ' '.to_int() { grid[oyr][c_axis] = '-'.to_int() } + if ch == ' '.to_int() { + grid[oyr][c_axis] = '-'.to_int() + } c_axis = c_axis + 1 } let mut r_axis = 0 while r_axis < h { let ch = grid[r_axis][oxc] - if ch == ' '.to_int() { grid[r_axis][oxc] = '|'.to_int() } + if ch == ' '.to_int() { + grid[r_axis][oxc] = '|'.to_int() + } r_axis = r_axis + 1 } // loadings @@ -549,7 +598,13 @@ pub fn pca_biplot_ascii( idx = idx + 1 } ranked.sort_by(fn(p : (Int, Double), q : (Int, Double)) -> Int { - if p.1 > q.1 { -1 } else if p.1 < q.1 { 1 } else { 0 } + if p.1 > q.1 { + -1 + } else if p.1 < q.1 { + 1 + } else { + 0 + } }) let lm = if opts.max_loadings < 1 { 1 } else { opts.max_loadings } let ntop = if lm < ranked.length() { lm } else { ranked.length() } @@ -560,10 +615,14 @@ pub fn pca_biplot_ascii( let lx = res.loadings[idxi][ix] let ly = res.loadings[idxi][iy] let m_val = (lx * lx + ly * ly).sqrt() - if m_val > lmax { lmax = m_val } + if m_val > lmax { + lmax = m_val + } t = t + 1 } - if lmax == 0.0 { lmax = 1.0 } + if lmax == 0.0 { + lmax = 1.0 + } let mut t2 = 0 while t2 < ntop { let idxi = ranked[t2].0 @@ -611,6 +670,7 @@ pub fn pca_biplot_ascii( // ---------- find_pca_outliers ---------- +///| pub struct PCAOutlierResult { pub indices : Array[Int] pub scores : Array[Double] @@ -618,12 +678,23 @@ pub struct PCAOutlierResult { pub cutoff : Double } +///| fn quantile_simple(xs_in : Array[Double], q : Double) -> Double { - if xs_in.length() == 0 { return 0.0 } + if xs_in.length() == 0 { + return 0.0 + } let xs : Array[Double] = Array::new() - for x in xs_in { xs.push(x) } + for x in xs_in { + xs.push(x) + } xs.sort_by(fn(a : Double, b : Double) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) let n = xs.length() let qq = if q < 0.0 { 0.0 } else if q > 1.0 { 1.0 } else { q } @@ -634,6 +705,7 @@ fn quantile_simple(xs_in : Array[Double], q : Double) -> Double { xs[lo] * (1.0 - frac) + xs[hi] * frac } +///| pub fn find_pca_outliers( res : FullPCAResult, n_pcs? : Int = 5, @@ -641,13 +713,7 @@ pub fn find_pca_outliers( ) -> PCAOutlierResult { let n = res.scores.length() let k_total = res.n_components - let k = if n_pcs < 1 { - 1 - } else if n_pcs > k_total { - k_total - } else { - n_pcs - } + let k = if n_pcs < 1 { 1 } else if n_pcs > k_total { k_total } else { n_pcs } if n == 0 || k == 0 { return PCAOutlierResult::{ indices: [], @@ -689,19 +755,22 @@ pub fn find_pca_outliers( indices: outliers, scores: out_scores, n_tested: n, - cutoff: cutoff, + cutoff, } } // ---------- variable_correlations ---------- +///| pub fn variable_correlations( data : Array[Array[Double]], res : FullPCAResult, which_pcs? : Int = 5, ) -> Array[Array[Double]] { let n = data.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let p = data[0].length() let k = if which_pcs < 1 { 1 @@ -787,18 +856,8 @@ pub fn variable_correlations( } ii = ii + 1 } - let r = if c3 < 2 { - 0.0 - } else { - sum_prod / (c3 - 1).to_double() - } - let rclamp = if r > 1.0 { - 1.0 - } else if r < -1.0 { - -1.0 - } else { - r - } + let r = if c3 < 2 { 0.0 } else { sum_prod / (c3 - 1).to_double() } + let rclamp = if r > 1.0 { 1.0 } else if r < -1.0 { -1.0 } else { r } row.push(rclamp) tt = tt + 1 } diff --git a/src/pcd.mbt b/src/pcd.mbt index e5ca7ade..c57f52c4 100644 --- a/src/pcd.mbt +++ b/src/pcd.mbt @@ -28,10 +28,7 @@ pub struct PcdSpectrum { ///| /// Construct a PcdSpectrum. -pub fn PcdSpectrum::new( - scan_number : Int, - rt? : Double = 0.0 -) -> PcdSpectrum { +pub fn PcdSpectrum::new(scan_number : Int, rt? : Double = 0.0) -> PcdSpectrum { PcdSpectrum::{ scan_number, rt, @@ -50,13 +47,20 @@ pub fn PcdSpectrum::set_precursor_mz(self : PcdSpectrum, mz : Double?) -> Unit { ///| /// Set precursor charge. -pub fn PcdSpectrum::set_precursor_charge(self : PcdSpectrum, charge : Int?) -> Unit { +pub fn PcdSpectrum::set_precursor_charge( + self : PcdSpectrum, + charge : Int?, +) -> Unit { self.precursor_charge = charge } ///| /// Add a peak to the spectrum. -pub fn PcdSpectrum::add_peak(self : PcdSpectrum, mz : Double, intensity : Double) -> Unit { +pub fn PcdSpectrum::add_peak( + self : PcdSpectrum, + mz : Double, + intensity : Double, +) -> Unit { self.mz_values.push(mz) self.intensity_values.push(intensity) } @@ -119,7 +123,11 @@ pub fn PcdFile::add_spectrum(self : PcdFile, spectrum : PcdSpectrum) -> Unit { ///| /// Set metadata key-value pair. -pub fn PcdFile::set_metadata(self : PcdFile, key : String, val : String) -> Unit { +pub fn PcdFile::set_metadata( + self : PcdFile, + key : String, + val : String, +) -> Unit { self.metadata[key] = val } @@ -163,7 +171,11 @@ pub struct PcdPeak { ///| /// Construct a PcdPeak. -pub fn PcdPeak::new(mz : Double, intensity : Double, charge? : Int = 0) -> PcdPeak { +pub fn PcdPeak::new( + mz : Double, + intensity : Double, + charge? : Int = 0, +) -> PcdPeak { let charge_opt = if charge > 0 { Some(charge) } else { None } PcdPeak::{ mz, intensity, charge: charge_opt } } @@ -243,9 +255,7 @@ fn pcd_parse_header_into(line : String, file : PcdFile) -> Unit { file.set_version(val) } } - None => { - file.set_metadata(content, "") - } + None => file.set_metadata(content, "") } } @@ -288,15 +298,13 @@ fn pcd_parse_scan_line(line : String) -> PcdSpectrum { } pepmass_mz = Some(pcd_parse_double(mz_str)) } - None => { - pepmass_mz = Some(pcd_parse_double(pepmass_str)) - } + None => pepmass_mz = Some(pcd_parse_double(pepmass_str)) } } } i = i + 1 } - let spec = PcdSpectrum::new(scan_number, rt=rt) + let spec = PcdSpectrum::new(scan_number, rt~) spec.set_precursor_mz(pepmass_mz) spec.set_precursor_charge(pepmass_charge) spec @@ -306,11 +314,13 @@ fn pcd_parse_scan_line(line : String) -> PcdSpectrum { /// Parse a peak line (e.g., "500.5 10000" or "500.5 10000 2"). fn pcd_parse_peak_line(line : String) -> PcdPeak? { let parts = pcd_split_whitespace(line) - if parts.length() < 2 { return None } + if parts.length() < 2 { + return None + } let mz = pcd_parse_double(parts[0]) let intensity = pcd_parse_double(parts[1]) let charge = if parts.length() > 2 { pcd_parse_int(parts[2]) } else { 0 } - Some(PcdPeak::new(mz, intensity, charge=charge)) + Some(PcdPeak::new(mz, intensity, charge~)) } // ============================================================================ @@ -319,7 +329,11 @@ fn pcd_parse_peak_line(line : String) -> PcdPeak? { ///| /// Get spectra within a retention time range. -pub fn pcd_spectra_by_rt(file : PcdFile, min_rt : Double, max_rt : Double) -> Array[PcdSpectrum] { +pub fn pcd_spectra_by_rt( + file : PcdFile, + min_rt : Double, + max_rt : Double, +) -> Array[PcdSpectrum] { let result : Array[PcdSpectrum] = Array::new() let mut i = 0 while i < file.spectra.length() { @@ -368,7 +382,10 @@ pub fn pcd_bpc(file : PcdFile) -> Array[Double] { ///| /// Find peaks above a threshold intensity in all spectra. -pub fn pcd_find_peaks_above(file : PcdFile, threshold : Double) -> Array[(Int, Double, Double)] { +pub fn pcd_find_peaks_above( + file : PcdFile, + threshold : Double, +) -> Array[(Int, Double, Double)] { let peaks : Array[(Int, Double, Double)] = Array::new() let mut i = 0 while i < file.spectra.length() { @@ -387,7 +404,11 @@ pub fn pcd_find_peaks_above(file : PcdFile, threshold : Double) -> Array[(Int, D ///| /// Filter spectrum by m/z range. -pub fn pcd_spectrum_by_mz(spectrum : PcdSpectrum, min_mz : Double, max_mz : Double) -> PcdSpectrum { +pub fn pcd_spectrum_by_mz( + spectrum : PcdSpectrum, + min_mz : Double, + max_mz : Double, +) -> PcdSpectrum { let result = PcdSpectrum::new(spectrum.scan_number, rt=spectrum.rt) result.set_precursor_mz(spectrum.precursor_mz) result.set_precursor_charge(spectrum.precursor_charge) @@ -448,7 +469,11 @@ pub fn pcd_write(file : PcdFile) -> String { out = out + "\n" let mut j = 0 while j < s.mz_values.length() { - out = out + s.mz_values[j].to_string() + " " + s.intensity_values[j].to_string() + "\n" + out = out + + s.mz_values[j].to_string() + + " " + + s.intensity_values[j].to_string() + + "\n" j = j + 1 } out = out + "\n" @@ -465,27 +490,10 @@ pub fn pcd_write(file : PcdFile) -> String { /// Generate a sample PCD text for testing. pub fn pcd_sample() -> String { let lines = [ - "#version: 1.0", - "#instrument: TestMassSpec", - "#date: 2024-01-01", - "SCAN 1 RT 1.0 PEPMASS 500.5(2)", - "500.1 10000", - "500.5 25000", - "500.8 5000", - "600.2 8000", - "", - "SCAN 2 RT 2.5 PEPMASS 600.3(3)", - "500.1 5000", - "600.3 30000", - "600.5 15000", - "700.1 2000", - "", - "SCAN 3 RT 5.0 PEPMASS 700.1(2)", - "500.2 3000", - "700.1 40000", - "700.5 10000", - "800.2 5000", - "", + "#version: 1.0", "#instrument: TestMassSpec", "#date: 2024-01-01", "SCAN 1 RT 1.0 PEPMASS 500.5(2)", + "500.1 10000", "500.5 25000", "500.8 5000", "600.2 8000", "", "SCAN 2 RT 2.5 PEPMASS 600.3(3)", + "500.1 5000", "600.3 30000", "600.5 15000", "700.1 2000", "", "SCAN 3 RT 5.0 PEPMASS 700.1(2)", + "500.2 3000", "700.1 40000", "700.5 10000", "800.2 5000", "", ] let mut result = "" let mut i = 0 @@ -533,7 +541,9 @@ fn pcd_split_lines(content : String) -> Array[String] { if start < i { lines.push(content[start:i].trim().to_string()) } - if ch == "\r" && i + 1 < content.length() && content[i + 1:i + 2].to_owned() == "\n" { + if ch == "\r" && + i + 1 < content.length() && + content[i + 1:i + 2].to_owned() == "\n" { i = i + 1 } start = i + 1 @@ -575,13 +585,17 @@ fn pcd_split_whitespace(line : String) -> Array[String] { fn pcd_parse_int(s : String) -> Int { let sv = s.to_string().trim() let n = sv.length() - if n == 0 { return 0 } + if n == 0 { + return 0 + } let mut result = 0 let mut i = 0 let zero = '0'.to_int() while i < n { let c = sv.unsafe_get(i).to_int() - if c < zero || c > zero + 9 { break } + if c < zero || c > zero + 9 { + break + } result = result * 10 + (c - zero) i = i + 1 } @@ -592,7 +606,9 @@ fn pcd_parse_int(s : String) -> Int { /// Parse a double from a string, returning 0.0 on failure. fn pcd_parse_double(s : String) -> Double { let sv = s.to_string().trim() - if sv.length() == 0 { return 0.0 } + if sv.length() == 0 { + return 0.0 + } let n = sv.length() let mut result = 0.0 let mut decimal = 0 @@ -605,7 +621,9 @@ fn pcd_parse_double(s : String) -> Double { } while i < n { let c = sv.unsafe_get(i).to_int() - if c < zero || c > zero + 9 { break } + if c < zero || c > zero + 9 { + break + } result = result * 10.0 + (c - zero).to_double() i = i + 1 } @@ -613,7 +631,9 @@ fn pcd_parse_double(s : String) -> Double { i = i + 1 while i < n { let c = sv.unsafe_get(i).to_int() - if c < zero || c > zero + 9 { break } + if c < zero || c > zero + 9 { + break + } result = result * 10.0 + (c - zero).to_double() decimal = decimal + 1 i = i + 1 diff --git a/src/pdb_analysis.mbt b/src/pdb_analysis.mbt index b3122ea1..306ab3a1 100644 --- a/src/pdb_analysis.mbt +++ b/src/pdb_analysis.mbt @@ -628,15 +628,33 @@ pub fn create_demo_structure() -> Structure { pub fn vdw_radius(atom_name : String) -> Double { let name = atom_name.to_upper() // Carbon atoms - if name == "C" || name == "CA" || name == "CB" || name == "CG" || name == "CD" || name == "CE" || name == "CZ" || name == "CZ" { + if name == "C" || + name == "CA" || + name == "CB" || + name == "CG" || + name == "CD" || + name == "CE" || + name == "CZ" || + name == "CZ" { return 1.7 } // Nitrogen atoms - if name == "N" || name == "NZ" || name == "ND" || name == "NE" || name == "NH" || name == "NZ" { + if name == "N" || + name == "NZ" || + name == "ND" || + name == "NE" || + name == "NH" || + name == "NZ" { return 1.55 } // Oxygen atoms - if name == "O" || name == "OH" || name == "OG" || name == "OD" || name == "OE" || name == "OT1" || name == "OT2" { + if name == "O" || + name == "OH" || + name == "OG" || + name == "OD" || + name == "OE" || + name == "OT1" || + name == "OT2" { return 1.52 } // Sulfur atoms @@ -648,7 +666,7 @@ pub fn vdw_radius(atom_name : String) -> Double { return 1.8 } // Hydrogen atoms - if name == "H" || name.length() > 0 && name[0:1] == "H" { + if name == "H" || (name.length() > 0 && name[0:1] == "H") { return 1.2 } // Default for unknown atoms @@ -661,16 +679,16 @@ pub fn vdw_radius(atom_name : String) -> Double { fn generate_sphere_points(n_points : Int) -> Array[Vector3] { let points : Array[Vector3] = Array::new() let golden_angle = 3.14159265358979323846 * (3.0 - 5.0.sqrt()) - + let mut i = 0 while i < n_points { - let y = 1.0 - (2.0 * i.to_double()) / (n_points.to_double() - 1.0) + let y = 1.0 - 2.0 * i.to_double() / (n_points.to_double() - 1.0) let radius_at_y = (1.0 - y * y).sqrt() let theta = golden_angle * i.to_double() - + let x = @math.cos(theta) * radius_at_y let z = @math.sin(theta) * radius_at_y - + points.push(Vector3::new(x, y, z)) i = i + 1 } @@ -689,7 +707,7 @@ pub fn calc_sasa( ) -> Array[(String, Double)] { let result : Array[(String, Double)] = Array::new() let residues = chain.get_residues() - + // Collect all atoms with radii let atoms : Array[(Vector3, Double, String)] = Array::new() for res in residues { @@ -698,21 +716,21 @@ pub fn calc_sasa( atoms.push((atom.coord, radius, atom.name)) } } - + let n_atoms = atoms.length() if n_atoms == 0 { return result } - + // Generate sphere points let sphere_points = generate_sphere_points(n_points) - + // Calculate SASA for each atom let mut i = 0 while i < n_atoms { let (coord_i, radius_i, name_i) = atoms[i] let r_sq = radius_i * radius_i - + let n_accessible = { let mut count = 0 let mut pi = 0 @@ -722,7 +740,7 @@ pub fn calc_sasa( let px = point.x * radius_i + coord_i.x let py = point.y * radius_i + coord_i.y let pz = point.z * radius_i + coord_i.z - + // Check if this point is buried by any other atom let mut buried = false let mut j = 0 @@ -740,7 +758,7 @@ pub fn calc_sasa( } j = j + 1 } - + if !buried { count = count + 1 } @@ -748,15 +766,17 @@ pub fn calc_sasa( } count } - + // SASA contribution from this atom let sphere_area = 4.0 * 3.14159265358979323846 * r_sq - let atom_sasa = (n_accessible.to_double() / n_points.to_double()) * sphere_area - + let atom_sasa = n_accessible.to_double() / + n_points.to_double() * + sphere_area + result.push((name_i, atom_sasa)) i = i + 1 } - + result } @@ -774,11 +794,14 @@ pub fn calc_total_sasa(chain : Chain, probe_radius? : Double = 1.4) -> Double { ///| /// Calculate per-residue SASA for a chain. /// Returns an array of (resseq, resname, sasa) tuples. -pub fn calc_residue_sasa(chain : Chain, probe_radius? : Double = 1.4) -> Array[(Int, String, Double)] { +pub fn calc_residue_sasa( + chain : Chain, + probe_radius? : Double = 1.4, +) -> Array[(Int, String, Double)] { let result : Array[(Int, String, Double)] = Array::new() let residues = chain.get_residues() let atom_sasa = calc_sasa(chain, probe_radius~) - + // Map atoms back to residues let atom_idx = { let mut idx = 0 @@ -796,7 +819,7 @@ pub fn calc_residue_sasa(chain : Chain, probe_radius? : Double = 1.4) -> Array[( } res_atom_map } - + result } @@ -806,15 +829,15 @@ pub fn calc_residue_sasa(chain : Chain, probe_radius? : Double = 1.4) -> Array[( pub fn ramachandran_quality(chain : Chain) -> (Double, Double, Double) { let plot_data = ramachandran_plot(chain) let n_total = plot_data.length().to_double() - + if n_total == 0.0 { return (0.0, 0.0, 0.0) } - + let mut n_favored = 0.0 let mut n_allowed = 0.0 let mut n_generous = 0.0 - + for entry in plot_data { let phi = entry.2 let psi = entry.3 @@ -825,7 +848,7 @@ pub fn ramachandran_quality(chain : Chain) -> (Double, Double, Double) { Generous => n_generous = n_generous + 1.0 } } - + (n_favored / n_total, n_allowed / n_total, n_generous / n_total) } @@ -836,7 +859,7 @@ pub fn calc_sequence_property_matrix(chain : Chain) -> Array[Array[Double]] { let residues = chain.get_residues() let n = residues.length() let matrix : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let row : Array[Double] = Array::new() @@ -850,7 +873,7 @@ pub fn calc_sequence_property_matrix(chain : Chain) -> Array[Array[Double]] { matrix.push(row) i = i + 1 } - + matrix } diff --git a/src/pdb_dice.mbt b/src/pdb_dice.mbt index 3bd3f40c..98497ae2 100644 --- a/src/pdb_dice.mbt +++ b/src/pdb_dice.mbt @@ -72,11 +72,11 @@ pub fn extract_chains( chain_ids : Array[Char], ) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let new_chains : Array[Chain] = [] - + for j = 0; j < model.chains.length(); j = j + 1 { let chain = model.chains[j] let mut selected = false @@ -89,22 +89,19 @@ pub fn extract_chains( new_chains.push(chain) } } - + if new_chains.length() > 0 { let new_model = Model::new(id=model.id, chains=new_chains) new_models.push(new_model) } } - + Structure::new(id=structure.id, models=new_models) } ///| /// Extract a single chain from a structure. -pub fn extract_chain( - structure : Structure, - chain_id : Char, -) -> Structure { +pub fn extract_chain(structure : Structure, chain_id : Char) -> Structure { let chain_arr = [chain_id] extract_chains(structure, chain_arr) } @@ -123,11 +120,11 @@ pub fn extract_residue_range( end_res : Int, ) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let new_chains : Array[Chain] = [] - + for j = 0; j < model.chains.length(); j = j + 1 { let chain = model.chains[j] if chain.id == chain_id { @@ -147,13 +144,13 @@ pub fn extract_residue_range( // Skip other chains } } - + if new_chains.length() > 0 { let new_model = Model::new(id=model.id, chains=new_chains) new_models.push(new_model) } } - + Structure::new(id=structure.id, models=new_models) } @@ -164,46 +161,46 @@ pub fn extract_residues( residue_ids : Array[ResidueId], ) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let new_chains : Array[Chain] = [] let chain_residues_map = Map([], capacity=8) // chain_id -> Array[Residue] - + for j = 0; j < model.chains.length(); j = j + 1 { let chain = model.chains[j] let selected_residues : Array[Residue] = [] - + for k = 0; k < chain.residues.length(); k = k + 1 { let residue = chain.residues[k] let mut is_selected = false - + for r = 0; r < residue_ids.length() && !is_selected; r = r + 1 { let rid = residue_ids[r] if chain.id == rid.chain_id && - residue.resseq == rid.resseq && - residue.icode == rid.icode { + residue.resseq == rid.resseq && + residue.icode == rid.icode { is_selected = true } } - + if is_selected { selected_residues.push(residue) } } - + if selected_residues.length() > 0 { let new_chain = Chain::new(id=chain.id, residues=selected_residues) new_chains.push(new_chain) } } - + if new_chains.length() > 0 { let new_model = Model::new(id=model.id, chains=new_chains) new_models.push(new_model) } } - + Structure::new(id=structure.id, models=new_models) } @@ -218,19 +215,19 @@ pub fn extract_atoms_by_name( atom_names : Array[String], ) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let new_chains : Array[Chain] = [] - + for j = 0; j < model.chains.length(); j = j + 1 { let chain = model.chains[j] let new_residues : Array[Residue] = [] - + for k = 0; k < chain.residues.length(); k = k + 1 { let residue = chain.residues[k] let new_atoms : Array[Atom] = [] - + for a = 0; a < residue.atoms.length(); a = a + 1 { let atom = residue.atoms[a] let mut selected = false @@ -243,7 +240,7 @@ pub fn extract_atoms_by_name( new_atoms.push(atom) } } - + if new_atoms.length() > 0 { let new_residue = Residue::new( resname=residue.resname, @@ -255,19 +252,19 @@ pub fn extract_atoms_by_name( new_residues.push(new_residue) } } - + if new_residues.length() > 0 { let new_chain = Chain::new(id=chain.id, residues=new_residues) new_chains.push(new_chain) } } - + if new_chains.length() > 0 { let new_model = Model::new(id=model.id, chains=new_chains) new_models.push(new_model) } } - + Structure::new(id=structure.id, models=new_models) } @@ -296,7 +293,7 @@ pub fn extract_models( model_ids : Array[Int], ) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let mut selected = false @@ -309,7 +306,7 @@ pub fn extract_models( new_models.push(model) } } - + Structure::new(id=structure.id, models=new_models) } @@ -332,34 +329,34 @@ pub fn extract_first_model(structure : Structure) -> Structure { /// Keeps only standard amino acid residues. pub fn remove_hetero_residues(structure : Structure) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let new_chains : Array[Chain] = [] - + for j = 0; j < model.chains.length(); j = j + 1 { let chain = model.chains[j] let new_residues : Array[Residue] = [] - + for k = 0; k < chain.residues.length(); k = k + 1 { let residue = chain.residues[k] if !residue.is_het() { new_residues.push(residue) } } - + if new_residues.length() > 0 { let new_chain = Chain::new(id=chain.id, residues=new_residues) new_chains.push(new_chain) } } - + if new_chains.length() > 0 { let new_model = Model::new(id=model.id, chains=new_chains) new_models.push(new_model) } } - + Structure::new(id=structure.id, models=new_models) } @@ -367,34 +364,34 @@ pub fn remove_hetero_residues(structure : Structure) -> Structure { /// Keep only hetero residues (HETATM) in a structure. pub fn keep_hetero_residues(structure : Structure) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let new_chains : Array[Chain] = [] - + for j = 0; j < model.chains.length(); j = j + 1 { let chain = model.chains[j] let new_residues : Array[Residue] = [] - + for k = 0; k < chain.residues.length(); k = k + 1 { let residue = chain.residues[k] if residue.is_het() { new_residues.push(residue) } } - + if new_residues.length() > 0 { let new_chain = Chain::new(id=chain.id, residues=new_residues) new_chains.push(new_chain) } } - + if new_chains.length() > 0 { let new_model = Model::new(id=model.id, chains=new_chains) new_models.push(new_model) } } - + Structure::new(id=structure.id, models=new_models) } @@ -407,7 +404,7 @@ pub fn keep_hetero_residues(structure : Structure) -> Structure { pub fn get_unique_chain_ids(structure : Structure) -> Array[Char] { let ids : Array[Char] = [] let seen = Map([], capacity=8) - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] for j = 0; j < model.chains.length(); j = j + 1 { @@ -419,7 +416,7 @@ pub fn get_unique_chain_ids(structure : Structure) -> Array[Char] { } } } - + ids } @@ -428,7 +425,7 @@ pub fn get_unique_chain_ids(structure : Structure) -> Array[Char] { pub fn get_unique_residue_names(structure : Structure) -> Array[String] { let names : Array[String] = [] let seen = Map([], capacity=32) - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] for j = 0; j < model.chains.length(); j = j + 1 { @@ -442,7 +439,7 @@ pub fn get_unique_residue_names(structure : Structure) -> Array[String] { } } } - + names } @@ -451,7 +448,7 @@ pub fn get_unique_residue_names(structure : Structure) -> Array[String] { pub fn get_unique_atom_names(structure : Structure) -> Array[String] { let names : Array[String] = [] let seen = Map([], capacity=32) - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] for j = 0; j < model.chains.length(); j = j + 1 { @@ -468,7 +465,7 @@ pub fn get_unique_atom_names(structure : Structure) -> Array[String] { } } } - + names } @@ -476,7 +473,7 @@ pub fn get_unique_atom_names(structure : Structure) -> Array[String] { /// Count atoms in a structure by element type. pub fn count_atoms_by_element(structure : Structure) -> Map[String, Int] { let counts = Map([], capacity=16) - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] for j = 0; j < model.chains.length(); j = j + 1 { @@ -492,7 +489,7 @@ pub fn count_atoms_by_element(structure : Structure) -> Map[String, Int] { } } } - + counts } @@ -507,7 +504,7 @@ pub fn structure_stats(structure : Structure) -> DiceResult { let mut num_residues = 0 let mut num_chains = 0 let num_models = structure.models.length() - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] num_chains = num_chains + model.chains.length() @@ -520,21 +517,15 @@ pub fn structure_stats(structure : Structure) -> DiceResult { } } } - - DiceResult::new( - structure.id, - num_atoms, - num_residues, - num_chains, - num_models, - ) + + DiceResult::new(structure.id, num_atoms, num_residues, num_chains, num_models) } ///| /// Get the sequence of a specific chain as a string (one-letter codes). pub fn chain_sequence(structure : Structure, chain_id : Char) -> String { let mut seq = "" - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] for j = 0; j < model.chains.length(); j = j + 1 { @@ -550,7 +541,7 @@ pub fn chain_sequence(structure : Structure, chain_id : Char) -> String { } } } - + seq } @@ -593,26 +584,26 @@ pub fn filter_by_bfactor( max_bfactor : Double, ) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let new_chains : Array[Chain] = [] - + for j = 0; j < model.chains.length(); j = j + 1 { let chain = model.chains[j] let new_residues : Array[Residue] = [] - + for k = 0; k < chain.residues.length(); k = k + 1 { let residue = chain.residues[k] let new_atoms : Array[Atom] = [] - + for a = 0; a < residue.atoms.length(); a = a + 1 { let atom = residue.atoms[a] if atom.bfactor >= min_bfactor && atom.bfactor <= max_bfactor { new_atoms.push(atom) } } - + if new_atoms.length() > 0 { let new_residue = Residue::new( resname=residue.resname, @@ -624,19 +615,19 @@ pub fn filter_by_bfactor( new_residues.push(new_residue) } } - + if new_residues.length() > 0 { let new_chain = Chain::new(id=chain.id, residues=new_residues) new_chains.push(new_chain) } } - + if new_chains.length() > 0 { let new_model = Model::new(id=model.id, chains=new_chains) new_models.push(new_model) } } - + Structure::new(id=structure.id, models=new_models) } @@ -647,26 +638,26 @@ pub fn filter_by_occupancy( min_occupancy : Double, ) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let new_chains : Array[Chain] = [] - + for j = 0; j < model.chains.length(); j = j + 1 { let chain = model.chains[j] let new_residues : Array[Residue] = [] - + for k = 0; k < chain.residues.length(); k = k + 1 { let residue = chain.residues[k] let new_atoms : Array[Atom] = [] - + for a = 0; a < residue.atoms.length(); a = a + 1 { let atom = residue.atoms[a] if atom.occupancy >= min_occupancy { new_atoms.push(atom) } } - + if new_atoms.length() > 0 { let new_residue = Residue::new( resname=residue.resname, @@ -678,19 +669,19 @@ pub fn filter_by_occupancy( new_residues.push(new_residue) } } - + if new_residues.length() > 0 { let new_chain = Chain::new(id=chain.id, residues=new_residues) new_chains.push(new_chain) } } - + if new_chains.length() > 0 { let new_model = Model::new(id=model.id, chains=new_chains) new_models.push(new_model) } } - + Structure::new(id=structure.id, models=new_models) } @@ -707,7 +698,7 @@ pub fn select_atoms_near_point( ) -> Array[Atom] { let selected : Array[Atom] = [] let radius_sq = radius * radius - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] for j = 0; j < model.chains.length(); j = j + 1 { @@ -727,7 +718,7 @@ pub fn select_atoms_near_point( } } } - + selected } @@ -741,7 +732,7 @@ pub fn select_residues_near_point( let selected : Array[ResidueId] = [] let seen = Map([], capacity=32) let radius_sq = radius * radius - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] for j = 0; j < model.chains.length(); j = j + 1 { @@ -749,7 +740,7 @@ pub fn select_residues_near_point( for k = 0; k < chain.residues.length(); k = k + 1 { let residue = chain.residues[k] let mut has_close_atom = false - + for a = 0; a < residue.atoms.length() && !has_close_atom; a = a + 1 { let atom = residue.atoms[a] let dx = atom.coord.x - point.x @@ -760,12 +751,21 @@ pub fn select_residues_near_point( has_close_atom = true } } - + if has_close_atom { - let key = "" + chain.id.to_string() + ":" + residue.resseq.to_string() + ":" + residue.icode.to_string() + let key = "" + + chain.id.to_string() + + ":" + + residue.resseq.to_string() + + ":" + + residue.icode.to_string() if seen.get(key) == None { seen.set(key, "1") - let rid = ResidueId::new(chain.id, residue.resseq, icode=residue.icode) + let rid = ResidueId::new( + chain.id, + residue.resseq, + icode=residue.icode, + ) selected.push(rid) } } @@ -773,6 +773,6 @@ pub fn select_residues_near_point( } break // Only check first model } - + selected } diff --git a/src/pdb_header.mbt b/src/pdb_header.mbt index 53e9065b..2d6aaac1 100644 --- a/src/pdb_header.mbt +++ b/src/pdb_header.mbt @@ -195,7 +195,10 @@ fn split_pdb_lines(text : String) -> Array[String] { ///| /// Find the start and end indices of a record section in the lines array. /// Returns (-1, -1) if the record is not found. -fn extract_record_section(lines : Array[String], record_name : String) -> (Int, Int) { +fn extract_record_section( + lines : Array[String], + record_name : String, +) -> (Int, Int) { let mut start = -1 let mut end = -1 let mut i = 0 @@ -440,18 +443,18 @@ pub fn parse_pdb_header_lines(lines : Array[String]) -> PDBHeader { } PDBHeader::new( - pdb_id=pdb_id, - title=title, - compound=compound, - source=source, - keywords=keywords, - resolution=resolution, - rfactor=rfactor, - date_deposited=date_deposited, - authors=authors, - journal=journal, - remark_lines=remark_lines, - dbrefs=dbrefs, + pdb_id~, + title~, + compound~, + source~, + keywords~, + resolution~, + rfactor~, + date_deposited~, + authors~, + journal~, + remark_lines~, + dbrefs~, chain_ids=final_chain_ids, ) } @@ -479,7 +482,10 @@ pub fn parse_title_record(lines : Array[String], _start_idx : Int) -> String { ///| /// Parse multi-line COMPOUND record. -pub fn parse_compound_record(lines : Array[String], _start_idx : Int) -> CompoundInfo { +pub fn parse_compound_record( + lines : Array[String], + _start_idx : Int, +) -> CompoundInfo { let (start, end) = extract_record_section(lines, "COMPND") if start < 0 { return CompoundInfo::new() @@ -524,21 +530,24 @@ pub fn parse_compound_record(lines : Array[String], _start_idx : Int) -> Compoun } CompoundInfo::new( - molecule_id=molecule_id, - chain_ids=chain_ids, - compound_name=compound_name, - formula=formula, - ka=ka, - kb=kb, - ec_number=ec_number, - engineered=engineered, - mutation=mutation, + molecule_id~, + chain_ids~, + compound_name~, + formula~, + ka~, + kb~, + ec_number~, + engineered~, + mutation~, ) } ///| /// Parse multi-line SOURCE record. -pub fn parse_source_record(lines : Array[String], _start_idx : Int) -> SourceInfo { +pub fn parse_source_record( + lines : Array[String], + _start_idx : Int, +) -> SourceInfo { let (start, end) = extract_record_section(lines, "SOURCE") if start < 0 { return SourceInfo::new() @@ -579,19 +588,22 @@ pub fn parse_source_record(lines : Array[String], _start_idx : Int) -> SourceInf } SourceInfo::new( - source=source, - organism_scientific=organism_scientific, - organism_common=organism_common, - strain=strain, - cell_line=cell_line, - tissue=tissue, - tax_id=tax_id, + source~, + organism_scientific~, + organism_common~, + strain~, + cell_line~, + tissue~, + tax_id~, ) } ///| /// Parse multi-line KEYWDS record. -pub fn parse_keywords_record(lines : Array[String], _start_idx : Int) -> Array[String] { +pub fn parse_keywords_record( + lines : Array[String], + _start_idx : Int, +) -> Array[String] { let (start, end) = extract_record_section(lines, "KEYWDS") if start < 0 { return [] @@ -641,7 +653,10 @@ pub fn parse_rfactor_record(line : String) -> Double { ///| /// Parse multi-line AUTH record. /// Returns array of author names (semicolon-separated). -pub fn parse_authors_record(lines : Array[String], _start_idx : Int) -> Array[String] { +pub fn parse_authors_record( + lines : Array[String], + _start_idx : Int, +) -> Array[String] { let (start, end) = extract_record_section(lines, "AUTH") if start < 0 { return [] @@ -671,7 +686,10 @@ pub fn parse_journal_record(lines : Array[String], _start_idx : Int) -> String { ///| /// Parse DBREF records. -pub fn parse_dbref_record(lines : Array[String], _start_idx : Int) -> Array[DBRefEntry] { +pub fn parse_dbref_record( + lines : Array[String], + _start_idx : Int, +) -> Array[DBRefEntry] { let result : Array[DBRefEntry] = [] let (start, end) = extract_record_section(lines, "DBREF") if start < 0 { @@ -684,11 +702,7 @@ pub fn parse_dbref_record(lines : Array[String], _start_idx : Int) -> Array[DBRe let db_name = trim_pdb_field(line, 13, 18) let db_accession = trim_pdb_field(line, 24, 33) let db_id = trim_pdb_field(line, 49, 56) - result.push(DBRefEntry::new( - db_name=db_name, - db_accession=db_accession, - db_id=db_id, - )) + result.push(DBRefEntry::new(db_name~, db_accession~, db_id~)) } i = i + 1 } @@ -697,7 +711,10 @@ pub fn parse_dbref_record(lines : Array[String], _start_idx : Int) -> Array[DBRe ///| /// Parse all REMARK records into an array of strings. -pub fn parse_remark_records(lines : Array[String], _start_idx : Int) -> Array[String] { +pub fn parse_remark_records( + lines : Array[String], + _start_idx : Int, +) -> Array[String] { let result : Array[String] = [] let (start, end) = extract_record_section(lines, "REMARK") if start < 0 { @@ -830,4 +847,4 @@ fn extract_chain_ids_from_compound(compound : CompoundInfo) -> Array[String] { fn extract_chain_ids_from_dbref(dbrefs : Array[DBRefEntry]) -> Array[String] { let result : Array[String] = [] result -} \ No newline at end of file +} diff --git a/src/pdb_list.mbt b/src/pdb_list.mbt index 9133ad7f..c2eed04a 100644 --- a/src/pdb_list.mbt +++ b/src/pdb_list.mbt @@ -10,27 +10,32 @@ pub struct PDBList { ///| pub fn PDBList::new(pdb_dir : String) -> PDBList { - PDBList::{ - pdb_dir, - obsolete_pdb_dir: pdb_dir + "/obsolete", - update_date: "" - } + PDBList::{ pdb_dir, obsolete_pdb_dir: pdb_dir + "/obsolete", update_date: "" } } ///| -pub fn PDBList::download_pdb(self : PDBList, pdb_code : String, file_format : String) -> String { +pub fn PDBList::download_pdb( + self : PDBList, + pdb_code : String, + file_format : String, +) -> String { let pdb_code_upper = pdb_code.to_upper() let middle_part = substring(pdb_code_upper, 1, 2) let pdb_dir = self.pdb_dir + "/" + middle_part + "/" + pdb_code_upper let file_name = pdb_dir + "/" + pdb_code_upper + "." + file_format - + file_name } ///| -pub fn PDBList::get_pdb_file(self : PDBList, pdb_code : String, file_format : String, obsolete : Bool) -> String { +pub fn PDBList::get_pdb_file( + self : PDBList, + pdb_code : String, + file_format : String, + obsolete : Bool, +) -> String { let pdb_code_upper = pdb_code.to_upper() - + if obsolete { self.obsolete_pdb_dir + "/" + pdb_code_upper + "." + file_format } else { @@ -39,16 +44,20 @@ pub fn PDBList::get_pdb_file(self : PDBList, pdb_code : String, file_format : St } ///| -pub fn PDBList::download_all_pdbs(self : PDBList, pdb_codes : Array[String], file_format : String) -> Array[String] { +pub fn PDBList::download_all_pdbs( + self : PDBList, + pdb_codes : Array[String], + file_format : String, +) -> Array[String] { let results : Array[String] = Array::new() - + let mut i = 0 while i < pdb_codes.length() { let file = self.download_pdb(pdb_codes[i], file_format) results.push(file) i = i + 1 } - + results } @@ -61,7 +70,14 @@ pub fn PDBList::get_all_obsolete(self : PDBList) -> Array[String] { ///| pub fn PDBList::update_pdb(self : PDBList) -> (PDBList, String) { let new_date = "2024-01-01" - (PDBList::{ pdb_dir: self.pdb_dir, obsolete_pdb_dir: self.obsolete_pdb_dir, update_date: new_date }, new_date) + ( + PDBList::{ + pdb_dir: self.pdb_dir, + obsolete_pdb_dir: self.obsolete_pdb_dir, + update_date: new_date, + }, + new_date, + ) } ///| @@ -72,11 +88,8 @@ pub fn PDBList::get_recent_changes(self : PDBList, days : Int) -> Array[String] ///| pub fn PDBList::resolve_obsolete(self : PDBList, pdb_code : String) -> String { - let obsolete_map = Map([ - ("1XYZ", "2XYZ"), - ("3ABC", "4ABC") - ], capacity=2) - + let obsolete_map = Map([("1XYZ", "2XYZ"), ("3ABC", "4ABC")], capacity=2) + if obsolete_map.contains(pdb_code) { obsolete_map.get(pdb_code).unwrap() } else { @@ -87,4 +100,4 @@ pub fn PDBList::resolve_obsolete(self : PDBList, pdb_code : String) -> String { ///| pub fn create_example_pdblist() -> PDBList { PDBList::new("/data/pdb") -} \ No newline at end of file +} diff --git a/src/pdb_packing.mbt b/src/pdb_packing.mbt index cdeeabc9..0940c9dc 100644 --- a/src/pdb_packing.mbt +++ b/src/pdb_packing.mbt @@ -163,7 +163,9 @@ pub fn PackingAnalysisResult::new( ///| /// Get results array. -pub fn PackingAnalysisResult::get_results(self : PackingAnalysisResult) -> Array[PackingResult] { +pub fn PackingAnalysisResult::get_results( + self : PackingAnalysisResult, +) -> Array[PackingResult] { self.results } @@ -185,14 +187,16 @@ pub fn PackingAnalysisResult::summary(self : PackingAnalysisResult) -> String { /// Generate approximately uniform points on a unit sphere /// using the golden spiral (Fibonacci sphere) algorithm. /// n_points: number of points to generate (default 100). -pub fn generate_packing_sphere_points(n_points? : Int = 100) -> Array[SpherePoint] { +pub fn generate_packing_sphere_points( + n_points? : Int = 100, +) -> Array[SpherePoint] { let points : Array[SpherePoint] = Array::new() let n = if n_points < 1 { 1 } else { n_points } let golden_angle = 3.14159265358979323846 * (3.0 - 5.0.sqrt()) let mut i = 0 while i < n { - let y = 1.0 - (2.0 * i.to_double()) / (n.to_double() - 1.0) + let y = 1.0 - 2.0 * i.to_double() / (n.to_double() - 1.0) let radius_at_y = (1.0 - y * y).sqrt() let theta = golden_angle * i.to_double() @@ -215,7 +219,7 @@ pub fn atom_in_sphere( let dx = point[0] - center[0] let dy = point[1] - center[1] let dz = point[2] - center[2] - (dx * dx + dy * dy + dz * dz) <= radius * radius + dx * dx + dy * dy + dz * dz <= radius * radius } ///| @@ -259,7 +263,7 @@ pub fn calculate_packing_density( return PackingResult::new(residue_name="", residue_seq=0) } - let sphere_points = generate_packing_sphere_points(n_points=n_points) + let sphere_points = generate_packing_sphere_points(n_points~) let atom = atoms[0] let atom_radius = atom.vdw_radius + radius @@ -326,11 +330,13 @@ pub fn packing_density_per_residue( let residue_groups : Map[String, Array[PackingAtom]] = Map([], capacity=16) for atom in atoms { - let key = atom.chain_id.to_string() + ":" + atom.residue_seq.to_string() + ":" + atom.residue_name + let key = atom.chain_id.to_string() + + ":" + + atom.residue_seq.to_string() + + ":" + + atom.residue_name match residue_groups.get(key) { - Some(arr) => { - arr.push(atom) - } + Some(arr) => arr.push(atom) None => { let arr : Array[PackingAtom] = Array::new() arr.push(atom) @@ -345,7 +351,11 @@ pub fn packing_density_per_residue( while ki < all_keys.length() { let key = all_keys[ki] let res_atoms = residue_groups[key] - let density_result = calculate_packing_density(res_atoms, radius~, n_points~) + let density_result = calculate_packing_density( + res_atoms, + radius~, + n_points~, + ) results.push(density_result) ki = ki + 1 } @@ -423,7 +433,7 @@ pub fn calculate_packing_sasa( return 0.0 } - let sphere_points = generate_packing_sphere_points(n_points=n_points) + let sphere_points = generate_packing_sphere_points(n_points~) let mut total_sasa = 0.0 let mut i = 0 @@ -462,7 +472,9 @@ pub fn calculate_packing_sasa( } let sphere_area = 4.0 * 3.14159265358979323846 * r_sq - let atom_sasa = (n_accessible.to_double() / n_points.to_double()) * sphere_area + let atom_sasa = n_accessible.to_double() / + n_points.to_double() * + sphere_area total_sasa = total_sasa + atom_sasa i = i + 1 @@ -525,13 +537,13 @@ pub fn sphere_radius_from_volume(volume : Double) -> Double { if volume <= 0.0 { return 0.0 } - @math.pow((3.0 * volume) / (4.0 * 3.14159265358979323846), 1.0 / 3.0) + @math.pow(3.0 * volume / (4.0 * 3.14159265358979323846), 1.0 / 3.0) } ///| /// Calculate the volume of a sphere with given radius. pub fn sphere_volume(radius : Double) -> Double { - (4.0 / 3.0) * 3.14159265358979323846 * radius * radius * radius + 4.0 / 3.0 * 3.14159265358979323846 * radius * radius * radius } ///| @@ -685,15 +697,34 @@ pub fn get_packing_vdw_radius(atom_name : String) -> Double { if name == "H" || (contains(name, "H") && starts_with(name, 0, "H")) { return 1.2 } - if name == "C" || name == "CA" || name == "CB" || name == "CG" || - name == "CD" || name == "CE" || name == "CZ" || name == "CH2" || name == "CH3" { + if name == "C" || + name == "CA" || + name == "CB" || + name == "CG" || + name == "CD" || + name == "CE" || + name == "CZ" || + name == "CH2" || + name == "CH3" { return 1.7 } - if name == "N" || name == "NZ" || name == "ND" || name == "NE" || name == "NH1" || name == "NH2" { + if name == "N" || + name == "NZ" || + name == "ND" || + name == "NE" || + name == "NH1" || + name == "NH2" { return 1.55 } - if name == "O" || name == "OH" || name == "OG" || name == "OD1" || name == "OD2" || - name == "OE1" || name == "OE2" || name == "OT1" || name == "OT2" { + if name == "O" || + name == "OH" || + name == "OG" || + name == "OD1" || + name == "OD2" || + name == "OE1" || + name == "OE2" || + name == "OT1" || + name == "OT2" { return 1.52 } if name == "S" || name == "SG" || name == "SD" { @@ -703,4 +734,4 @@ pub fn get_packing_vdw_radius(atom_name : String) -> Double { return 1.8 } 1.7 -} \ No newline at end of file +} diff --git a/src/pdb_seqio.mbt b/src/pdb_seqio.mbt index 3f78fe44..79b391ce 100644 --- a/src/pdb_seqio.mbt +++ b/src/pdb_seqio.mbt @@ -223,12 +223,14 @@ pub fn pdb_seqres_parser(content : String) -> Array[SeqRecord] { } else { chain_id } - records.push(SeqRecord::new( - Seq::new(seq_buf.to_string()), - id=id, - name=chain_id, - description="sequence from SEQRES, chain " + chain_id, - )) + records.push( + SeqRecord::new( + Seq::new(seq_buf.to_string()), + id~, + name=chain_id, + description="sequence from SEQRES, chain " + chain_id, + ), + ) } records } @@ -269,12 +271,17 @@ fn build_records_from_structure( } else { chain_id_str } - records.push(SeqRecord::new( - Seq::new(seq_str), - id=id, - name=chain_id_str, - description="sequence from " + source_label + " records, chain " + chain_id_str, - )) + records.push( + SeqRecord::new( + Seq::new(seq_str), + id~, + name=chain_id_str, + description="sequence from " + + source_label + + " records, chain " + + chain_id_str, + ), + ) } records } @@ -341,11 +348,7 @@ pub fn extract_sequence_from_pdb_lines( if cid != chain_id { continue } - let resname = if n >= 20 { - line[17:20].trim().to_owned() - } else { - "UNK" - } + let resname = if n >= 20 { line[17:20].trim().to_owned() } else { "UNK" } if resname == "HOH" || resname == "WAT" { continue } @@ -354,11 +357,7 @@ pub fn extract_sequence_from_pdb_lines( } else { 0 } - let icode = if n >= 27 { - line.get_char(26).unwrap_or(' ') - } else { - ' ' - } + let icode = if n >= 27 { line.get_char(26).unwrap_or(' ') } else { ' ' } let is_new = match prev_resseq { Some(p) => p != resseq || prev_icode != icode None => true @@ -380,7 +379,7 @@ pub fn extract_sequence_from_pdb_lines( /// `PdbSeqresParser`. pub fn pdb_to_seqrecords( content : String, - source~ : String = "atom", + source? : String = "atom", ) -> Array[SeqRecord] { let lower = source.to_lower() if lower == "seqres" { diff --git a/src/pdb_vectors.mbt b/src/pdb_vectors.mbt index a50c2172..09608835 100644 --- a/src/pdb_vectors.mbt +++ b/src/pdb_vectors.mbt @@ -50,9 +50,19 @@ pub fn Vector3::unit_z() -> Vector3 { ///| /// Access vector components. -pub fn Vector3::get_x(self : Vector3) -> Double { self.x } -pub fn Vector3::get_y(self : Vector3) -> Double { self.y } -pub fn Vector3::get_z(self : Vector3) -> Double { self.z } +pub fn Vector3::get_x(self : Vector3) -> Double { + self.x +} + +///| +pub fn Vector3::get_y(self : Vector3) -> Double { + self.y +} + +///| +pub fn Vector3::get_z(self : Vector3) -> Double { + self.z +} ///| /// Add two vectors. @@ -84,7 +94,7 @@ pub fn Vector3::cross(self : Vector3, other : Vector3) -> Vector3 { Vector3::{ x: self.y * other.z - self.z * other.y, y: self.z * other.x - self.x * other.z, - z: self.x * other.y - self.y * other.x + z: self.x * other.y - self.y * other.x, } } @@ -129,7 +139,13 @@ pub fn Vector3::angle(self : Vector3, other : Vector3) -> Double { return 0.0 } let cos_angle = dot / (n1 * n2) - let clamped = if cos_angle > 1.0 { 1.0 } else { if cos_angle < -1.0 { -1.0 } else { cos_angle } } + let clamped = if cos_angle > 1.0 { + 1.0 + } else if cos_angle < -1.0 { + -1.0 + } else { + cos_angle + } @math.acos(clamped) } @@ -193,9 +209,15 @@ pub struct RotationMatrix3 { ///| /// Construct a 3x3 rotation matrix from 9 values (row-major). pub fn RotationMatrix3::new( - m00~ : Double, m01~ : Double, m02~ : Double, - m10~ : Double, m11~ : Double, m12~ : Double, - m20~ : Double, m21~ : Double, m22~ : Double, + m00~ : Double, + m01~ : Double, + m02~ : Double, + m10~ : Double, + m11~ : Double, + m12~ : Double, + m20~ : Double, + m21~ : Double, + m22~ : Double, ) -> RotationMatrix3 { RotationMatrix3::{ m00, m01, m02, m10, m11, m12, m20, m21, m22 } } @@ -204,15 +226,25 @@ pub fn RotationMatrix3::new( /// Identity rotation matrix. pub fn RotationMatrix3::identity() -> RotationMatrix3 { RotationMatrix3::{ - m00: 1.0, m01: 0.0, m02: 0.0, - m10: 0.0, m11: 1.0, m12: 0.0, - m20: 0.0, m21: 0.0, m22: 1.0, + m00: 1.0, + m01: 0.0, + m02: 0.0, + m10: 0.0, + m11: 1.0, + m12: 0.0, + m20: 0.0, + m21: 0.0, + m22: 1.0, } } ///| /// Access element at row,col. -pub fn RotationMatrix3::get(self : RotationMatrix3, row : Int, col : Int) -> Double { +pub fn RotationMatrix3::get( + self : RotationMatrix3, + row : Int, + col : Int, +) -> Double { match (row, col) { (0, 0) => self.m00 (0, 1) => self.m01 @@ -229,17 +261,121 @@ pub fn RotationMatrix3::get(self : RotationMatrix3, row : Int, col : Int) -> Dou ///| /// Set element at row,col. -pub fn RotationMatrix3::set(self : RotationMatrix3, row : Int, col : Int, value : Double) -> RotationMatrix3 { +pub fn RotationMatrix3::set( + self : RotationMatrix3, + row : Int, + col : Int, + value : Double, +) -> RotationMatrix3 { match (row, col) { - (0, 0) => RotationMatrix3::{ m00: value, m01: self.m01, m02: self.m02, m10: self.m10, m11: self.m11, m12: self.m12, m20: self.m20, m21: self.m21, m22: self.m22 } - (0, 1) => RotationMatrix3::{ m00: self.m00, m01: value, m02: self.m02, m10: self.m10, m11: self.m11, m12: self.m12, m20: self.m20, m21: self.m21, m22: self.m22 } - (0, 2) => RotationMatrix3::{ m00: self.m00, m01: self.m01, m02: value, m10: self.m10, m11: self.m11, m12: self.m12, m20: self.m20, m21: self.m21, m22: self.m22 } - (1, 0) => RotationMatrix3::{ m00: self.m00, m01: self.m01, m02: self.m02, m10: value, m11: self.m11, m12: self.m12, m20: self.m20, m21: self.m21, m22: self.m22 } - (1, 1) => RotationMatrix3::{ m00: self.m00, m01: self.m01, m02: self.m02, m10: self.m10, m11: value, m12: self.m12, m20: self.m20, m21: self.m21, m22: self.m22 } - (1, 2) => RotationMatrix3::{ m00: self.m00, m01: self.m01, m02: self.m02, m10: self.m10, m11: self.m11, m12: value, m20: self.m20, m21: self.m21, m22: self.m22 } - (2, 0) => RotationMatrix3::{ m00: self.m00, m01: self.m01, m02: self.m02, m10: self.m10, m11: self.m11, m12: self.m12, m20: value, m21: self.m21, m22: self.m22 } - (2, 1) => RotationMatrix3::{ m00: self.m00, m01: self.m01, m02: self.m02, m10: self.m10, m11: self.m11, m12: self.m12, m20: self.m20, m21: value, m22: self.m22 } - (2, 2) => RotationMatrix3::{ m00: self.m00, m01: self.m01, m02: self.m02, m10: self.m10, m11: self.m11, m12: self.m12, m20: self.m20, m21: self.m21, m22: value } + (0, 0) => + RotationMatrix3::{ + m00: value, + m01: self.m01, + m02: self.m02, + m10: self.m10, + m11: self.m11, + m12: self.m12, + m20: self.m20, + m21: self.m21, + m22: self.m22, + } + (0, 1) => + RotationMatrix3::{ + m00: self.m00, + m01: value, + m02: self.m02, + m10: self.m10, + m11: self.m11, + m12: self.m12, + m20: self.m20, + m21: self.m21, + m22: self.m22, + } + (0, 2) => + RotationMatrix3::{ + m00: self.m00, + m01: self.m01, + m02: value, + m10: self.m10, + m11: self.m11, + m12: self.m12, + m20: self.m20, + m21: self.m21, + m22: self.m22, + } + (1, 0) => + RotationMatrix3::{ + m00: self.m00, + m01: self.m01, + m02: self.m02, + m10: value, + m11: self.m11, + m12: self.m12, + m20: self.m20, + m21: self.m21, + m22: self.m22, + } + (1, 1) => + RotationMatrix3::{ + m00: self.m00, + m01: self.m01, + m02: self.m02, + m10: self.m10, + m11: value, + m12: self.m12, + m20: self.m20, + m21: self.m21, + m22: self.m22, + } + (1, 2) => + RotationMatrix3::{ + m00: self.m00, + m01: self.m01, + m02: self.m02, + m10: self.m10, + m11: self.m11, + m12: value, + m20: self.m20, + m21: self.m21, + m22: self.m22, + } + (2, 0) => + RotationMatrix3::{ + m00: self.m00, + m01: self.m01, + m02: self.m02, + m10: self.m10, + m11: self.m11, + m12: self.m12, + m20: value, + m21: self.m21, + m22: self.m22, + } + (2, 1) => + RotationMatrix3::{ + m00: self.m00, + m01: self.m01, + m02: self.m02, + m10: self.m10, + m11: self.m11, + m12: self.m12, + m20: self.m20, + m21: value, + m22: self.m22, + } + (2, 2) => + RotationMatrix3::{ + m00: self.m00, + m01: self.m01, + m02: self.m02, + m10: self.m10, + m11: self.m11, + m12: self.m12, + m20: self.m20, + m21: self.m21, + m22: value, + } _ => self } } @@ -248,15 +384,24 @@ pub fn RotationMatrix3::set(self : RotationMatrix3, row : Int, col : Int, value /// Transpose the matrix. pub fn RotationMatrix3::transpose(self : RotationMatrix3) -> RotationMatrix3 { RotationMatrix3::{ - m00: self.m00, m01: self.m10, m02: self.m20, - m10: self.m01, m11: self.m11, m12: self.m21, - m20: self.m02, m21: self.m12, m22: self.m22, + m00: self.m00, + m01: self.m10, + m02: self.m20, + m10: self.m01, + m11: self.m11, + m12: self.m21, + m20: self.m02, + m21: self.m12, + m22: self.m22, } } ///| /// Multiply matrix by vector (matrix-vector product). -pub fn RotationMatrix3::transform(self : RotationMatrix3, v : Vector3) -> Vector3 { +pub fn RotationMatrix3::transform( + self : RotationMatrix3, + v : Vector3, +) -> Vector3 { let new_x = self.m00 * v.x + self.m01 * v.y + self.m02 * v.z let new_y = self.m10 * v.x + self.m11 * v.y + self.m12 * v.z let new_z = self.m20 * v.x + self.m21 * v.y + self.m22 * v.z @@ -265,7 +410,10 @@ pub fn RotationMatrix3::transform(self : RotationMatrix3, v : Vector3) -> Vector ///| /// Multiply two rotation matrices (matrix multiplication). -pub fn RotationMatrix3::multiply(self : RotationMatrix3, other : RotationMatrix3) -> RotationMatrix3 { +pub fn RotationMatrix3::multiply( + self : RotationMatrix3, + other : RotationMatrix3, +) -> RotationMatrix3 { RotationMatrix3::{ m00: self.m00 * other.m00 + self.m01 * other.m10 + self.m02 * other.m20, m01: self.m00 * other.m01 + self.m01 * other.m11 + self.m02 * other.m21, @@ -285,9 +433,15 @@ pub fn RotationMatrix3::rotation_x(angle : Double) -> RotationMatrix3 { let c = @math.cos(angle) let s = @math.sin(angle) RotationMatrix3::new( - m00=1.0, m01=0.0, m02=0.0, - m10=0.0, m11=c, m12=-s, - m20=0.0, m21=s, m22=c + m00=1.0, + m01=0.0, + m02=0.0, + m10=0.0, + m11=c, + m12=-s, + m20=0.0, + m21=s, + m22=c, ) } @@ -297,9 +451,15 @@ pub fn RotationMatrix3::rotation_y(angle : Double) -> RotationMatrix3 { let c = @math.cos(angle) let s = @math.sin(angle) RotationMatrix3::new( - m00=c, m01=0.0, m02=s, - m10=0.0, m11=1.0, m12=0.0, - m20=-s, m21=0.0, m22=c + m00=c, + m01=0.0, + m02=s, + m10=0.0, + m11=1.0, + m12=0.0, + m20=-s, + m21=0.0, + m22=c, ) } @@ -309,16 +469,25 @@ pub fn RotationMatrix3::rotation_z(angle : Double) -> RotationMatrix3 { let c = @math.cos(angle) let s = @math.sin(angle) RotationMatrix3::new( - m00=c, m01=-s, m02=0.0, - m10=s, m11=c, m12=0.0, - m20=0.0, m21=0.0, m22=1.0 + m00=c, + m01=-s, + m02=0.0, + m10=s, + m11=c, + m12=0.0, + m20=0.0, + m21=0.0, + m22=1.0, ) } ///| /// Create a rotation matrix around an arbitrary axis by angle (radians). /// Uses Rodrigues' rotation formula. -pub fn RotationMatrix3::rotation_axis_angle(axis : Vector3, angle : Double) -> RotationMatrix3 { +pub fn RotationMatrix3::rotation_axis_angle( + axis : Vector3, + angle : Double, +) -> RotationMatrix3 { let u = axis.normalize() let c = @math.cos(angle) let s = @math.sin(angle) @@ -334,15 +503,15 @@ pub fn RotationMatrix3::rotation_axis_angle(axis : Vector3, angle : Double) -> R let m21 = u.z * u.y * t + u.x * s let m22 = c + u.z * u.z * t - RotationMatrix3::new(m00=m00, m01=m01, m02=m02, m10=m10, m11=m11, m12=m12, m20=m20, m21=m21, m22=m22) + RotationMatrix3::new(m00~, m01~, m02~, m10~, m11~, m12~, m20~, m21~, m22~) } ///| /// Compute the determinant of the 3x3 matrix. pub fn RotationMatrix3::determinant(self : RotationMatrix3) -> Double { self.m00 * (self.m11 * self.m22 - self.m12 * self.m21) - - self.m01 * (self.m10 * self.m22 - self.m12 * self.m20) + - self.m02 * (self.m10 * self.m21 - self.m11 * self.m20) + self.m01 * (self.m10 * self.m22 - self.m12 * self.m20) + + self.m02 * (self.m10 * self.m21 - self.m11 * self.m20) } ///| @@ -358,22 +527,43 @@ pub fn RotationMatrix3::inverse(self : RotationMatrix3) -> RotationMatrix3 { ///| /// Check if matrix is a valid rotation matrix (orthogonal with det ~ 1). -pub fn RotationMatrix3::is_rotation(self : RotationMatrix3, tol? : Double = 1.0e-6) -> Bool { +pub fn RotationMatrix3::is_rotation( + self : RotationMatrix3, + tol? : Double = 1.0e-6, +) -> Bool { let det = self.determinant() if (det.abs() - 1.0).abs() > tol { return false } let rt = self.transpose() let product = self.multiply(rt) - if (product.m00 - 1.0).abs() > tol { return false } - if (product.m01 - 0.0).abs() > tol { return false } - if (product.m02 - 0.0).abs() > tol { return false } - if (product.m10 - 0.0).abs() > tol { return false } - if (product.m11 - 1.0).abs() > tol { return false } - if (product.m12 - 0.0).abs() > tol { return false } - if (product.m20 - 0.0).abs() > tol { return false } - if (product.m21 - 0.0).abs() > tol { return false } - if (product.m22 - 1.0).abs() > tol { return false } + if (product.m00 - 1.0).abs() > tol { + return false + } + if (product.m01 - 0.0).abs() > tol { + return false + } + if (product.m02 - 0.0).abs() > tol { + return false + } + if (product.m10 - 0.0).abs() > tol { + return false + } + if (product.m11 - 1.0).abs() > tol { + return false + } + if (product.m12 - 0.0).abs() > tol { + return false + } + if (product.m20 - 0.0).abs() > tol { + return false + } + if (product.m21 - 0.0).abs() > tol { + return false + } + if (product.m22 - 1.0).abs() > tol { + return false + } true } @@ -399,7 +589,11 @@ pub fn vector_centroid(vectors : Array[Vector3]) -> Vector3 { /// Compute the RMSD between two sets of paired vectors. /// Both arrays must have the same length. pub fn vector_rmsd(set_a : Array[Vector3], set_b : Array[Vector3]) -> Double { - let n = if set_a.length() < set_b.length() { set_a.length() } else { set_b.length() } + let n = if set_a.length() < set_b.length() { + set_a.length() + } else { + set_b.length() + } if n == 0 { return 0.0 } @@ -416,8 +610,15 @@ pub fn vector_rmsd(set_a : Array[Vector3], set_b : Array[Vector3]) -> Double { ///| /// Compute the superposition RMSD after optimal rotation. /// Uses the Kabsch algorithm for optimal superposition. -pub fn vector_superposition_rmsd(set_a : Array[Vector3], set_b : Array[Vector3]) -> Double { - let n = if set_a.length() < set_b.length() { set_a.length() } else { set_b.length() } +pub fn vector_superposition_rmsd( + set_a : Array[Vector3], + set_b : Array[Vector3], +) -> Double { + let n = if set_a.length() < set_b.length() { + set_a.length() + } else { + set_b.length() + } if n < 2 { return vector_rmsd(set_a, set_b) } @@ -446,16 +647,32 @@ pub fn vector_superposition_rmsd(set_a : Array[Vector3], set_b : Array[Vector3]) vector_rmsd(rotated_a, centered_b) } -pub fn test_array_full(set_a : Array[Vector3], set_b : Array[Vector3]) -> RotationMatrix3 { - let n = if set_a.length() < set_b.length() { set_a.length() } else { set_b.length() } +///| +pub fn test_array_full( + set_a : Array[Vector3], + set_b : Array[Vector3], +) -> RotationMatrix3 { + let n = if set_a.length() < set_b.length() { + set_a.length() + } else { + set_b.length() + } if n < 1 { return RotationMatrix3::identity() } RotationMatrix3::identity() } -pub fn compute_optimal_rotation(set_a : Array[Vector3], set_b : Array[Vector3]) -> RotationMatrix3 { - let n = if set_a.length() < set_b.length() { set_a.length() } else { set_b.length() } +///| +pub fn compute_optimal_rotation( + set_a : Array[Vector3], + set_b : Array[Vector3], +) -> RotationMatrix3 { + let n = if set_a.length() < set_b.length() { + set_a.length() + } else { + set_b.length() + } if n < 1 { return RotationMatrix3::identity() } @@ -506,11 +723,15 @@ pub fn compute_optimal_rotation(set_a : Array[Vector3], set_b : Array[Vector3]) let ht7 = h5 let ht8 = h8 - let norm_ht = ( - ht0 * ht0 + ht1 * ht1 + ht2 * ht2 + - ht3 * ht3 + ht4 * ht4 + ht5 * ht5 + - ht6 * ht6 + ht7 * ht7 + ht8 * ht8 - ).sqrt() + let norm_ht = (ht0 * ht0 + + ht1 * ht1 + + ht2 * ht2 + + ht3 * ht3 + + ht4 * ht4 + + ht5 * ht5 + + ht6 * ht6 + + ht7 * ht7 + + ht8 * ht8).sqrt() if norm_ht < 1.0e-15 { return RotationMatrix3::identity() @@ -518,17 +739,30 @@ pub fn compute_optimal_rotation(set_a : Array[Vector3], set_b : Array[Vector3]) let s = scale / norm_ht RotationMatrix3::new( - m00=ht0 * s, m01=ht1 * s, m02=ht2 * s, - m10=ht3 * s, m11=ht4 * s, m12=ht5 * s, - m20=ht6 * s, m21=ht7 * s, m22=ht8 * s + m00=ht0 * s, + m01=ht1 * s, + m02=ht2 * s, + m10=ht3 * s, + m11=ht4 * s, + m12=ht5 * s, + m20=ht6 * s, + m21=ht7 * s, + m22=ht8 * s, ) } ///| /// Compute the optimal transformation (rotation + translation) to superimpose set A onto set B. /// Returns a tuple of (rotation_matrix, translation_vector). -pub fn vector_superposition_transform(set_a : Array[Vector3], set_b : Array[Vector3]) -> (RotationMatrix3, Vector3) { - let n = if set_a.length() < set_b.length() { set_a.length() } else { set_b.length() } +pub fn vector_superposition_transform( + set_a : Array[Vector3], + set_b : Array[Vector3], +) -> (RotationMatrix3, Vector3) { + let n = if set_a.length() < set_b.length() { + set_a.length() + } else { + set_b.length() + } if n < 2 { return (RotationMatrix3::identity(), Vector3::zero()) } @@ -554,7 +788,11 @@ pub fn vector_superposition_transform(set_a : Array[Vector3], set_b : Array[Vect ///| /// Apply a rigid-body transformation (rotation + translation) to a set of vectors. -pub fn vector_apply_transform(vectors : Array[Vector3], rotation : RotationMatrix3, translation : Vector3) -> Array[Vector3] { +pub fn vector_apply_transform( + vectors : Array[Vector3], + rotation : RotationMatrix3, + translation : Vector3, +) -> Array[Vector3] { let result : Array[Vector3] = Array::new() for v in vectors { let rotated = rotation.transform(v) @@ -565,7 +803,12 @@ pub fn vector_apply_transform(vectors : Array[Vector3], rotation : RotationMatri ///| /// Compute the dihedral angle defined by four points (in radians). -pub fn vector_dihedral_angle(p1 : Vector3, p2 : Vector3, p3 : Vector3, p4 : Vector3) -> Double { +pub fn vector_dihedral_angle( + p1 : Vector3, + p2 : Vector3, + p3 : Vector3, + p4 : Vector3, +) -> Double { let b1 = p2.sub(p1) let b2 = p3.sub(p2) let b3 = p4.sub(p3) @@ -587,7 +830,12 @@ pub fn vector_dihedral_angle(p1 : Vector3, p2 : Vector3, p3 : Vector3, p4 : Vect ///| /// Compute the dihedral angle in degrees. -pub fn vector_dihedral_angle_degrees(p1 : Vector3, p2 : Vector3, p3 : Vector3, p4 : Vector3) -> Double { +pub fn vector_dihedral_angle_degrees( + p1 : Vector3, + p2 : Vector3, + p3 : Vector3, + p4 : Vector3, +) -> Double { let rad = vector_dihedral_angle(p1, p2, p3, p4) rad * 180.0 / @math.PI } diff --git a/src/peak_calling.mbt b/src/peak_calling.mbt index bb3ff4d4..882850ca 100644 --- a/src/peak_calling.mbt +++ b/src/peak_calling.mbt @@ -59,7 +59,11 @@ pub struct PeakCallingParams { ///| /// Construct a `ChipSeqRead` from a chromosome name, genomic /// position, and strand ("+" or "-"). -pub fn ChipSeqRead::new(chr~ : String, position~ : Int, strand~ : String) -> ChipSeqRead { +pub fn ChipSeqRead::new( + chr~ : String, + position~ : Int, + strand~ : String, +) -> ChipSeqRead { ChipSeqRead::{ chr, position, strand } } @@ -219,12 +223,8 @@ pub fn PeakCallingParams::new( /// Lanczos approximation for ln(Gamma(x)). fn pc_gammln(xx : Double) -> Double { let cof = [ - 76.18009172947146, - -86.50532032941677, - 24.01409824083091, - -1.231739572450155, - 0.1208650973866179e-2, - -0.5395239384953e-5, + 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, + 0.1208650973866179e-2, -0.5395239384953e-5, ] let x = xx let mut y = xx @@ -496,7 +496,10 @@ pub fn call_peaks( // Local background from control, scaled to treatment depth. let lambda_rate = estimate_local_lambda( - control, chr, center, params.local_lambda_size, + control, + chr, + center, + params.local_lambda_size, ) let expected_raw = lambda_rate * win_size_d * scaling // Floor expected at a small positive value to avoid div-by-zero. @@ -514,9 +517,7 @@ pub fn call_peaks( continue } - let ctrl_count = count_reads_in_window( - control, chr, win_start, win_end, - ) + let ctrl_count = count_reads_in_window(control, chr, win_start, win_end) candidates.push( CandidatePeak::new( @@ -719,8 +720,8 @@ pub fn filter_peaks( let out : Array[CandidatePeak] = Array::new() for p in peaks { if p.p_value <= params.pvalue_threshold && - p.fold_enrichment >= params.min_fold_enrichment && - p.fdr <= params.fdr_threshold { + p.fold_enrichment >= params.min_fold_enrichment && + p.fdr <= params.fdr_threshold { out.push(p) } } @@ -753,7 +754,7 @@ pub fn peak_calling_sample_data() -> (Array[ChipSeqRead], Array[ChipSeqRead]) { while k < n { // Spread reads across a ~500bp window. treatment.push( - ChipSeqRead::new(chr="chr1", position=base + (k * 17) % 500, strand="+"), + ChipSeqRead::new(chr="chr1", position=base + k * 17 % 500, strand="+"), ) k = k + 1 } @@ -763,18 +764,14 @@ pub fn peak_calling_sample_data() -> (Array[ChipSeqRead], Array[ChipSeqRead]) { // Background treatment reads scattered across the chromosome. let mut b = 0 while b < 40 { - treatment.push( - ChipSeqRead::new(chr="chr1", position=b * 250, strand="+"), - ) + treatment.push(ChipSeqRead::new(chr="chr1", position=b * 250, strand="+")) b = b + 1 } // Control: background reads across the chromosome with no strong peaks. let mut c = 0 while c < 80 { - control.push( - ChipSeqRead::new(chr="chr1", position=c * 130, strand="+"), - ) + control.push(ChipSeqRead::new(chr="chr1", position=c * 130, strand="+")) c = c + 1 } @@ -815,13 +812,25 @@ pub fn peak_calling_summary(peaks : Array[CandidatePeak]) -> String { while i < limit { let p = copy[i] buf = buf + - " " + p.chr + ":" + p.start.to_string() + "-" + p.end.to_string() + - " summit=" + p.summit.to_string() + - " reads=" + p.read_count.to_string() + - " ctrl=" + p.control_count.to_string() + - " fold=" + p.fold_enrichment.to_string() + - " p=" + p.p_value.to_string() + - " fdr=" + p.fdr.to_string() + "\n" + " " + + p.chr + + ":" + + p.start.to_string() + + "-" + + p.end.to_string() + + " summit=" + + p.summit.to_string() + + " reads=" + + p.read_count.to_string() + + " ctrl=" + + p.control_count.to_string() + + " fold=" + + p.fold_enrichment.to_string() + + " p=" + + p.p_value.to_string() + + " fdr=" + + p.fdr.to_string() + + "\n" i = i + 1 } buf diff --git a/src/phd.mbt b/src/phd.mbt index 96890d38..508b2341 100644 --- a/src/phd.mbt +++ b/src/phd.mbt @@ -131,7 +131,11 @@ pub struct PhdBase { ///| /// Create a PhdBase. -pub fn PhdBase::new(base : String, quality : Int, peak_position : Int) -> PhdBase { +pub fn PhdBase::new( + base : String, + quality : Int, + peak_position : Int, +) -> PhdBase { { base, quality, peak_position } } @@ -234,7 +238,7 @@ pub struct PhdFile { ///| /// Create a PhdFile. pub fn PhdFile::new(reads : Array[PhdRead]) -> PhdFile { - { reads } + { reads, } } ///| @@ -369,16 +373,8 @@ fn phd_parse_comment(lines : Array[String], start : Int) -> (PhdComment, Int) { } ( PhdComment::new( - chromat_file, - phred_version, - phred_parameter_file, - trace_index_min, - trace_index_max, - trim_start, - trim_end, - trim_prob, - chemistry, - dye, + chromat_file, phred_version, phred_parameter_file, trace_index_min, trace_index_max, + trim_start, trim_end, trim_prob, chemistry, dye, ), idx, ) @@ -413,10 +409,7 @@ fn phd_parse_dna(lines : Array[String], start : Int) -> (Array[PhdBase], Int) { ///| /// Parse a single PHD sequence block (BEGIN_SEQUENCE ... END_SEQUENCE). -fn phd_parse_sequence( - lines : Array[String], - start : Int, -) -> (PhdRead?, Int) { +fn phd_parse_sequence(lines : Array[String], start : Int) -> (PhdRead?, Int) { let first_line = trim(lines[start].to_string()) // Extract read name from "BEGIN_SEQUENCE name" let tokens = phd_tokenize(first_line) @@ -424,9 +417,7 @@ fn phd_parse_sequence( return (None, start + 1) } let read_name = tokens[1] - let mut comment = PhdComment::new( - "", "", "", 0, 0, 0, 0, 0.0, "", "", - ) + let mut comment = PhdComment::new("", "", "", 0, 0, 0, 0, 0.0, "", "") let mut bases : Array[PhdBase] = [] let mut idx = start + 1 while idx < lines.length() { @@ -498,7 +489,13 @@ pub fn phd_sample_text() -> String { let quals = [35, 40, 45, 50, 38, 42, 47, 33, 39, 44] let peaks = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] for i in 0..<10 { - s = s + bases[i] + " " + quals[i].to_string() + " " + peaks[i].to_string() + "\n" + s = s + + bases[i] + + " " + + quals[i].to_string() + + " " + + peaks[i].to_string() + + "\n" } s = s + "END_DNA\n\n" s = s + "END_SEQUENCE\n" @@ -512,7 +509,11 @@ pub fn phd_sample_text() -> String { ///| /// Format a PhdRead as a readable string. pub fn PhdRead::to_string(self : PhdRead) -> String { - let mut s = "PhdRead(name=" + self.name + ", length=" + self.length().to_string() + ")\n" + let mut s = "PhdRead(name=" + + self.name + + ", length=" + + self.length().to_string() + + ")\n" s = s + " chromat_file: " + self.comment.chromat_file + "\n" s = s + " phred_version: " + self.comment.phred_version + "\n" s = s + " sequence: " + self.sequence() + "\n" diff --git a/src/pheatmap.mbt b/src/pheatmap.mbt index c8a5380e..95e0ca3e 100644 --- a/src/pheatmap.mbt +++ b/src/pheatmap.mbt @@ -19,10 +19,24 @@ pub enum DistanceMethod { } ///| -pub fn distance_method_euclidean() -> DistanceMethod { DistanceMethod::Euclidean } -pub fn distance_method_manhattan() -> DistanceMethod { DistanceMethod::Manhattan } -pub fn distance_method_correlation() -> DistanceMethod { DistanceMethod::Correlation } -pub fn distance_method_maximum() -> DistanceMethod { DistanceMethod::Maximum } +pub fn distance_method_euclidean() -> DistanceMethod { + DistanceMethod::Euclidean +} + +///| +pub fn distance_method_manhattan() -> DistanceMethod { + DistanceMethod::Manhattan +} + +///| +pub fn distance_method_correlation() -> DistanceMethod { + DistanceMethod::Correlation +} + +///| +pub fn distance_method_maximum() -> DistanceMethod { + DistanceMethod::Maximum +} ///| pub enum ClusterMethod { @@ -33,10 +47,24 @@ pub enum ClusterMethod { } ///| -pub fn cluster_method_complete() -> ClusterMethod { ClusterMethod::Complete } -pub fn cluster_method_average() -> ClusterMethod { ClusterMethod::Average } -pub fn cluster_method_ward() -> ClusterMethod { ClusterMethod::Ward } -pub fn cluster_method_single() -> ClusterMethod { ClusterMethod::Single } +pub fn cluster_method_complete() -> ClusterMethod { + ClusterMethod::Complete +} + +///| +pub fn cluster_method_average() -> ClusterMethod { + ClusterMethod::Average +} + +///| +pub fn cluster_method_ward() -> ClusterMethod { + ClusterMethod::Ward +} + +///| +pub fn cluster_method_single() -> ClusterMethod { + ClusterMethod::Single +} ///| pub struct PheatmapInput { @@ -101,7 +129,11 @@ pub fn distance_manhattan(a : Array[Double], b : Array[Double]) -> Double { let mut i = 0 while i < n { let d = a[i] - b[i] - if d < 0.0 { sum = sum - d } else { sum = sum + d } + if d < 0.0 { + sum = sum - d + } else { + sum = sum + d + } i = i + 1 } sum @@ -115,7 +147,9 @@ pub fn distance_maximum(a : Array[Double], b : Array[Double]) -> Double { while i < n { let d = a[i] - b[i] let ad = if d < 0.0 { -d } else { d } - if ad > mx { mx = ad } + if ad > mx { + mx = ad + } i = i + 1 } mx @@ -124,7 +158,9 @@ pub fn distance_maximum(a : Array[Double], b : Array[Double]) -> Double { ///| pub fn distance_correlation(a : Array[Double], b : Array[Double]) -> Double { let n = a.length() - if n < 2 { return 1.0 } + if n < 2 { + return 1.0 + } let mut ma = 0.0 let mut mb = 0.0 let mut i = 0 @@ -148,7 +184,9 @@ pub fn distance_correlation(a : Array[Double], b : Array[Double]) -> Double { j = j + 1 } let denom = (da * db).sqrt() - if denom == 0.0 { return 1.0 } + if denom == 0.0 { + return 1.0 + } let corr = num / denom 1.0 - corr } @@ -161,7 +199,10 @@ pub fn pheatmap_distance_matrix( let n = data.length() let dist : Array[Array[Double]] = Array::new() let mut ri = 0 - while ri < n { dist.push(Array::make(n, 0.0)); ri = ri + 1 } + while ri < n { + dist.push(Array::make(n, 0.0)) + ri = ri + 1 + } let mut i = 0 while i < n { let mut j = 0 @@ -191,11 +232,16 @@ pub fn pheatmap_column_distance_matrix( method : DistanceMethod, ) -> Array[Array[Double]] { let n = data.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let p = data[0].length() let col_data : Array[Array[Double]] = Array::new() let mut cj = 0 - while cj < p { col_data.push(Array::make(n, 0.0)); cj = cj + 1 } + while cj < p { + col_data.push(Array::make(n, 0.0)) + cj = cj + 1 + } let mut j = 0 while j < p { let mut i = 0 @@ -237,15 +283,24 @@ pub fn hclust_complete(dist : Array[Array[Double]]) -> HclustResult { // cluster[i] = current cluster id for point i (initially -i-1 for leaves) let cluster : Array[Int] = Array::make(n, 0) let mut i = 0 - while i < n { cluster[i] = -i - 1; i = i + 1 } + while i < n { + cluster[i] = -i - 1 + i = i + 1 + } // Working distance matrix for merging let work_dist : Array[Array[Double]] = Array::new() let mut wi = 0 - while wi < n { work_dist.push(Array::make(n, 0.0)); wi = wi + 1 } + while wi < n { + work_dist.push(Array::make(n, 0.0)) + wi = wi + 1 + } let mut ri = 0 while ri < n { let mut cj = 0 - while cj < n { work_dist[ri][cj] = dist[ri][cj]; cj = cj + 1 } + while cj < n { + work_dist[ri][cj] = dist[ri][cj] + cj = cj + 1 + } ri = ri + 1 } let merge : Array[(Int, Int)] = Array::new() @@ -263,7 +318,11 @@ pub fn hclust_complete(dist : Array[Array[Double]]) -> HclustResult { while b < n { if cluster[a] != cluster[b] { let d = work_dist[a][b] - if d < min_d { min_d = d; min_i = a; min_j = b } + if d < min_d { + min_d = d + min_i = a + min_j = b + } } b = b + 1 } @@ -278,7 +337,9 @@ pub fn hclust_complete(dist : Array[Array[Double]]) -> HclustResult { let old_j = cluster[min_j] let mut k = 0 while k < n { - if cluster[k] == old_i || cluster[k] == old_j { cluster[k] = new_id } + if cluster[k] == old_i || cluster[k] == old_j { + cluster[k] = new_id + } k = k + 1 } // Update distance matrix for the merged cluster (complete linkage: max distance) @@ -303,25 +364,32 @@ pub fn hclust_complete(dist : Array[Array[Double]]) -> HclustResult { HclustResult::{ merge, height, order, n } } +///| fn hclust_inorder(merge : Array[(Int, Int)], n : Int) -> Array[Int] { let result : Array[Int] = Array::new() - if n <= 0 { return result } + if n <= 0 { + return result + } // The last merge (merge[length-1]) contains the final cluster let final_idx = merge.length() - 1 let left_result = hclust_inorder_rec(merge, merge[final_idx].0) let right_result = hclust_inorder_rec(merge, merge[final_idx].1) // Combine let mut i = 0 - while i < left_result.length() { result.push(left_result[i]); i = i + 1 } + while i < left_result.length() { + result.push(left_result[i]) + i = i + 1 + } let mut j = 0 - while j < right_result.length() { result.push(right_result[j]); j = j + 1 } + while j < right_result.length() { + result.push(right_result[j]) + j = j + 1 + } result } -fn hclust_inorder_rec( - merge : Array[(Int, Int)], - node : Int, -) -> Array[Int] { +///| +fn hclust_inorder_rec(merge : Array[(Int, Int)], node : Int) -> Array[Int] { if node < 0 { // Leaf node: -node-1 gives the original index [-node - 1] @@ -332,9 +400,15 @@ fn hclust_inorder_rec( let right = hclust_inorder_rec(merge, merge[merge_idx].1) let result : Array[Int] = Array::new() let mut i = 0 - while i < left.length() { result.push(left[i]); i = i + 1 } + while i < left.length() { + result.push(left[i]) + i = i + 1 + } let mut j = 0 - while j < right.length() { result.push(right[j]); j = j + 1 } + while j < right.length() { + result.push(right[j]) + j = j + 1 + } result } } @@ -346,14 +420,17 @@ pub fn hclust_cutree(result : HclustResult, k : Int) -> Array[Int] { let clusters : Array[Int] = Array::make(n, 0) if k <= 1 || k >= n { let mut i = 0 - while i < n { clusters[order[i]] = 1; i = i + 1 } + while i < n { + clusters[order[i]] = 1 + i = i + 1 + } return clusters } // Find split points from merge tree let total_merges = result.merge.length() let cut_point = total_merges - k + 1 // Create cluster assignments by following the merge tree - let node_cluster : Map[Int, Int] = Map([], capacity = total_merges + n) + let node_cluster : Map[Int, Int] = Map([], capacity=total_merges + n) let mut cluster_id = 0 let mut i = 0 while i < n { @@ -382,7 +459,7 @@ pub fn hclust_cutree(result : HclustResult, k : Int) -> Array[Int] { step = step + 1 } // Assign final cluster labels - let label_map = Map([], capacity = n) + let label_map = Map([], capacity=n) let mut final_id = 0 let mut k2 = 0 while k2 < n { @@ -427,11 +504,21 @@ pub fn heat_colors(n : Int) -> Array[String] { let mut i = 0 while i < n { let t = i.to_double() / (n.to_double() - 1.0) - let clamped_t = if t < 0.0 { 0.0 } else { if t > 1.0 { 1.0 } else { t } } - let clamped_inv = if (1.0 - t) < 0.0 { 0.0 } else { if (1.0 - t) > 1.0 { 1.0 } else { 1.0 - t } } + let clamped_t = if t < 0.0 { 0.0 } else if t > 1.0 { 1.0 } else { t } + let clamped_inv = if 1.0 - t < 0.0 { + 0.0 + } else if 1.0 - t > 1.0 { + 1.0 + } else { + 1.0 - t + } let r = (255.0 * clamped_t).to_int() let b = (255.0 * clamped_inv).to_int() - let g = if t < 0.5 { (255.0 * t * 2.0).to_int() } else { (255.0 * (1.0 - t) * 2.0).to_int() } + let g = if t < 0.5 { + (255.0 * t * 2.0).to_int() + } else { + (255.0 * (1.0 - t) * 2.0).to_int() + } let clamp_r = if r < 0 { 0 } else if r > 255 { 255 } else { r } let clamp_g = if g < 0 { 0 } else if g > 255 { 255 } else { g } let clamp_b = if b < 0 { 0 } else if b > 255 { 255 } else { b } @@ -442,6 +529,7 @@ pub fn heat_colors(n : Int) -> Array[String] { colors } +///| fn pheatmap_hex_color(r : Int, g : Int, b : Int) -> String { let rh = pheatmap_int_to_hex(r) let gh = pheatmap_int_to_hex(g) @@ -449,8 +537,11 @@ fn pheatmap_hex_color(r : Int, g : Int, b : Int) -> String { "#\{rh}\{gh}\{bh}" } +///| fn pheatmap_int_to_hex(v : Int) -> String { - let digits = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"] + let digits = [ + "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", + ] let hi = v / 16 let lo = v % 16 "\{digits[hi]}\{digits[lo]}" @@ -521,9 +612,9 @@ pub fn pheatmap_input( clustering_method: ClusterMethod::Complete, cutree_rows: 1, cutree_cols: 1, - annotation_row: Map([], capacity = n), - annotation_col: Map([], capacity = m), - annotation_colors: Map([], capacity = 0), + annotation_row: Map([], capacity=n), + annotation_col: Map([], capacity=m), + annotation_colors: Map([], capacity=0), display_numbers: false, number_format: "{:.2f}", number_color: "black", @@ -531,16 +622,21 @@ pub fn pheatmap_input( } } +///| fn pheatmap_matrix_min(mat : Array[Array[Double]]) -> Double { let n = mat.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut mn = mat[0][0] let mut i = 0 while i < n { let m = mat[i].length() let mut j = 0 while j < m { - if mat[i][j] < mn { mn = mat[i][j] } + if mat[i][j] < mn { + mn = mat[i][j] + } j = j + 1 } i = i + 1 @@ -548,16 +644,21 @@ fn pheatmap_matrix_min(mat : Array[Array[Double]]) -> Double { mn } +///| fn pheatmap_matrix_max(mat : Array[Array[Double]]) -> Double { let n = mat.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut mx = mat[0][0] let mut i = 0 while i < n { let m = mat[i].length() let mut j = 0 while j < m { - if mat[i][j] > mx { mx = mat[i][j] } + if mat[i][j] > mx { + mx = mat[i][j] + } j = j + 1 } i = i + 1 @@ -567,7 +668,10 @@ fn pheatmap_matrix_max(mat : Array[Array[Double]]) -> Double { ///| /// Set color scheme. -pub fn pheatmap_set_color(input : PheatmapInput, color : Array[String]) -> PheatmapInput { +pub fn pheatmap_set_color( + input : PheatmapInput, + color : Array[String], +) -> PheatmapInput { PheatmapInput::{ mat: input.mat, row_names: input.row_names, @@ -599,7 +703,10 @@ pub fn pheatmap_set_color(input : PheatmapInput, color : Array[String]) -> Pheat ///| /// Set breaks for color scale. -pub fn pheatmap_set_breaks(input : PheatmapInput, breaks : Array[Double]) -> PheatmapInput { +pub fn pheatmap_set_breaks( + input : PheatmapInput, + breaks : Array[Double], +) -> PheatmapInput { PheatmapInput::{ mat: input.mat, row_names: input.row_names, @@ -774,7 +881,10 @@ pub fn pheatmap_set_cluster( ///| /// Set main title. -pub fn pheatmap_set_title(input : PheatmapInput, title : String) -> PheatmapInput { +pub fn pheatmap_set_title( + input : PheatmapInput, + title : String, +) -> PheatmapInput { PheatmapInput::{ mat: input.mat, row_names: input.row_names, @@ -811,7 +921,7 @@ pub fn pheatmap_add_annotation_row( name : String, values : Array[String], ) -> PheatmapInput { - let new_annot = Map([], capacity = input.annotation_row.length() + 1) + let new_annot = Map([], capacity=input.annotation_row.length() + 1) for key in input.annotation_row.keys() { new_annot[key] = input.annotation_row[key] } @@ -852,7 +962,7 @@ pub fn pheatmap_add_annotation_col( name : String, values : Array[String], ) -> PheatmapInput { - let new_annot = Map([], capacity = input.annotation_col.length() + 1) + let new_annot = Map([], capacity=input.annotation_col.length() + 1) for key in input.annotation_col.keys() { new_annot[key] = input.annotation_col[key] } @@ -893,7 +1003,7 @@ pub fn pheatmap_set_annotation_color( annot_name : String, value_color_map : Map[String, String], ) -> PheatmapInput { - let new_colors = Map([], capacity = input.annotation_colors.length() + 1) + let new_colors = Map([], capacity=input.annotation_colors.length() + 1) for key in input.annotation_colors.keys() { new_colors[key] = input.annotation_colors[key] } @@ -996,9 +1106,15 @@ pub fn pheatmap_render(input : PheatmapInput) -> PheatmapResult { let mut row_order : Array[Int] = Array::make(n, 0) let mut col_order : Array[Int] = Array::make(m, 0) let mut i = 0 - while i < n { row_order[i] = i; i = i + 1 } + while i < n { + row_order[i] = i + i = i + 1 + } let mut j = 0 - while j < m { col_order[j] = j; j = j + 1 } + while j < m { + col_order[j] = j + j = j + 1 + } let mut row_clusters : Array[Int] = Array::new() let mut col_clusters : Array[Int] = Array::new() let mut row_dendrogram = "" @@ -1013,7 +1129,10 @@ pub fn pheatmap_render(input : PheatmapInput) -> PheatmapResult { } } if input.cluster_cols && m > 1 { - let col_dist = pheatmap_column_distance_matrix(mat, input.clustering_distance_cols) + let col_dist = pheatmap_column_distance_matrix( + mat, + input.clustering_distance_cols, + ) let col_hc = hclust_complete(col_dist) col_order = col_hc.order col_dendrogram = "clustered ({col_hc.merge.length()} merges)" @@ -1022,7 +1141,9 @@ pub fn pheatmap_render(input : PheatmapInput) -> PheatmapResult { } } // Build text output - let text = pheatmap_build_text(input, row_order, col_order, row_clusters, col_clusters) + let text = pheatmap_build_text( + input, row_order, col_order, row_clusters, col_clusters, + ) let legend = pheatmap_build_legend(input.breaks, input.color, input.legend) PheatmapResult::{ text, @@ -1038,6 +1159,7 @@ pub fn pheatmap_render(input : PheatmapInput) -> PheatmapResult { } } +///| fn pheatmap_build_text( input : PheatmapInput, row_order : Array[Int], @@ -1078,13 +1200,21 @@ fn pheatmap_build_text( let mut i = 0 while i < n { let row_idx = row_order[i] - let row_name = if input.show_row_names { input.row_names[row_idx] } else { "" } + let row_name = if input.show_row_names { + input.row_names[row_idx] + } else { + "" + } let mut line = pheatmap_pad_str(row_name, 8) let mut j = 0 while j < m { let col_idx = col_order[j] let val = input.mat[row_idx][col_idx] - let color_idx = pheatmap_value_to_color_idx(val, input.breaks, input.color.length()) + let color_idx = pheatmap_value_to_color_idx( + val, + input.breaks, + input.color.length(), + ) let color = input.color[color_idx] let cell = if input.display_numbers { pheatmap_format_value(val, input.number_format) @@ -1100,76 +1230,116 @@ fn pheatmap_build_text( // Cluster info if row_clusters.length() > 0 { lines.push("") - lines.push("Row clusters: \{row_clusters.length()} points assigned to \{pheatmap_unique_count(row_clusters)} clusters") + lines.push( + "Row clusters: \{row_clusters.length()} points assigned to \{pheatmap_unique_count(row_clusters)} clusters", + ) } if col_clusters.length() > 0 { - lines.push("Column clusters: \{col_clusters.length()} points assigned to \{pheatmap_unique_count(col_clusters)} clusters") + lines.push( + "Column clusters: \{col_clusters.length()} points assigned to \{pheatmap_unique_count(col_clusters)} clusters", + ) } lines.join("\n") } +///| fn pheatmap_pad_str(s : String, width : Int) -> String { - if s.length() >= width { return s } + if s.length() >= width { + return s + } let padded = s let mut result = padded let mut i = padded.length() - while i < width { result = result + " "; i = i + 1 } + while i < width { + result = result + " " + i = i + 1 + } result } +///| fn pheatmap_value_to_color_idx( val : Double, breaks : Array[Double], n_colors : Int, ) -> Int { - if n_colors == 0 { return 0 } - if breaks.length() < 2 { return n_colors / 2 } + if n_colors == 0 { + return 0 + } + if breaks.length() < 2 { + return n_colors / 2 + } let min_b = breaks[0] let max_b = breaks[breaks.length() - 1] - if val <= min_b { return 0 } - if val >= max_b { return n_colors - 1 } + if val <= min_b { + return 0 + } + if val >= max_b { + return n_colors - 1 + } let range = max_b - min_b let idx = ((val - min_b) / range * (n_colors - 1).to_double()).to_int() - if idx < 0 { return 0 } - if idx >= n_colors { return n_colors - 1 } + if idx < 0 { + return 0 + } + if idx >= n_colors { + return n_colors - 1 + } idx } +///| fn pheatmap_color_cell(color : String) -> String { // Simple text representation using color name "[" + color + "]" } +///| fn pheatmap_format_value(val : Double, format : String) -> String { // Simple format: show 2 decimal places let s = val.to_string() // Truncate to 5 chars - if s.length() > 6 { return s[0:6].to_owned() } + if s.length() > 6 { + return s[0:6].to_owned() + } s } +///| fn pheatmap_unique_count(arr : Array[Int]) -> Int { - let seen = Map([], capacity = arr.length()) + let seen = Map([], capacity=arr.length()) let mut count = 0 for v in arr { - if !seen.contains(v) { seen[v] = true; count = count + 1 } + if !seen.contains(v) { + seen[v] = true + count = count + 1 + } } count } +///| fn pheatmap_build_legend( breaks : Array[Double], color : Array[String], show : Bool, ) -> String { - if !show { return "" } + if !show { + return "" + } let n = color.length() - if n == 0 { return "" } + if n == 0 { + return "" + } let lines : Array[String] = Array::new() lines.push("Legend:") lines.push(" Min: \{breaks[0]}") let mid_idx = n / 2 - let mid_val = if breaks.length() > mid_idx { breaks[mid_idx] } else { breaks[breaks.length() - 1] } + let mid_val = if breaks.length() > mid_idx { + breaks[mid_idx] + } else { + breaks[breaks.length() - 1] + } lines.push(" Mid: \{mid_val}") lines.push(" Max: \{breaks[breaks.length() - 1]}") lines.join("\n") diff --git a/src/phenotype.mbt b/src/phenotype.mbt index cc6595e6..62498767 100644 --- a/src/phenotype.mbt +++ b/src/phenotype.mbt @@ -68,7 +68,12 @@ pub struct PhenControlSubtracted { ///| /// Create a new WellRecord. -pub fn WellRecord::new(well_id : String, plate_id : String, times : Array[Double], signals : Array[Double]) -> WellRecord { +pub fn WellRecord::new( + well_id : String, + plate_id : String, + times : Array[Double], + signals : Array[Double], +) -> WellRecord { WellRecord::{ well_id, plate_id, times, signals } } @@ -93,7 +98,11 @@ pub fn WellRecord::phen_get_time(self : WellRecord, idx : Int) -> Double { ///| /// Get maximum signal value. pub fn WellRecord::phen_max_signal(self : WellRecord) -> Double { - let mut max_val = if self.signals.length() > 0 { self.signals[0] } else { 0.0 } + let mut max_val = if self.signals.length() > 0 { + self.signals[0] + } else { + 0.0 + } let mut i = 1 while i < self.signals.length() { if self.signals[i] > max_val { @@ -107,7 +116,11 @@ pub fn WellRecord::phen_max_signal(self : WellRecord) -> Double { ///| /// Get minimum signal value. pub fn WellRecord::phen_min_signal(self : WellRecord) -> Double { - let mut min_val = if self.signals.length() > 0 { self.signals[0] } else { 0.0 } + let mut min_val = if self.signals.length() > 0 { + self.signals[0] + } else { + 0.0 + } let mut i = 1 while i < self.signals.length() { if self.signals[i] < min_val { @@ -147,7 +160,11 @@ pub fn WellRecord::phen_max_slope(self : WellRecord) -> Double { let mut i = 1 while i < n { let dt = self.times[i] - self.times[i - 1] - let local_slope = if dt > 0.0 { (self.signals[i] - self.signals[i - 1]) / dt } else { 0.0 } + let local_slope = if dt > 0.0 { + (self.signals[i] - self.signals[i - 1]) / dt + } else { + 0.0 + } if local_slope > max_slope { max_slope = local_slope } @@ -160,13 +177,19 @@ pub fn WellRecord::phen_max_slope(self : WellRecord) -> Double { ///| /// Create a new PlateRecord. -pub fn PlateRecord::new(plate_id : String, times : Array[Double]) -> PlateRecord { +pub fn PlateRecord::new( + plate_id : String, + times : Array[Double], +) -> PlateRecord { PlateRecord::{ plate_id, wells: Array::new(), times } } ///| /// Add a well to the plate. -pub fn PlateRecord::phen_add_well(self : PlateRecord, well : WellRecord) -> PlateRecord { +pub fn PlateRecord::phen_add_well( + self : PlateRecord, + well : WellRecord, +) -> PlateRecord { let new_wells = self.wells.copy() new_wells.push(well) PlateRecord::{ plate_id: self.plate_id, wells: new_wells, times: self.times } @@ -180,7 +203,10 @@ pub fn PlateRecord::phen_n_wells(self : PlateRecord) -> Int { ///| /// Get a well by well_id (returns Option). -pub fn PlateRecord::phen_get_well(self : PlateRecord, well_id : String) -> WellRecord? { +pub fn PlateRecord::phen_get_well( + self : PlateRecord, + well_id : String, +) -> WellRecord? { let mut found : WellRecord? = None let mut i = 0 while i < self.wells.length() { @@ -195,7 +221,10 @@ pub fn PlateRecord::phen_get_well(self : PlateRecord, well_id : String) -> WellR ///| /// Get a well at an index. -pub fn PlateRecord::phen_get_well_at(self : PlateRecord, idx : Int) -> WellRecord { +pub fn PlateRecord::phen_get_well_at( + self : PlateRecord, + idx : Int, +) -> WellRecord { self.wells[idx] } @@ -207,7 +236,10 @@ pub fn PlateRecord::phen_n_times(self : PlateRecord) -> Int { ///| /// Get mean signal across all wells at a time index. -pub fn PlateRecord::phen_mean_signal_at(self : PlateRecord, time_idx : Int) -> Double { +pub fn PlateRecord::phen_mean_signal_at( + self : PlateRecord, + time_idx : Int, +) -> Double { if self.wells.length() == 0 { return 0.0 } @@ -240,7 +272,11 @@ fn phen_estimate_initial(well : WellRecord) -> (Double, Double, Double, Double) let mut i = 1 while i < n { let dt = well.times[i] - well.times[i - 1] - let local_slope = if dt > 0.0 { (well.signals[i] - well.signals[i - 1]) / dt } else { 0.0 } + let local_slope = if dt > 0.0 { + (well.signals[i] - well.signals[i - 1]) / dt + } else { + 0.0 + } if local_slope > max_slope_val { max_slope_val = local_slope inflection = well.times[i] @@ -253,7 +289,13 @@ fn phen_estimate_initial(well : WellRecord) -> (Double, Double, Double, Double) ///| /// Logistic model: L / (1 + exp(-k * (t - t0))) + offset. /// L = asymptote, k = growth rate, t0 = inflection, offset = initial. -fn phen_logistic_model(t : Double, asymptote : Double, slope : Double, inflection : Double, initial : Double) -> Double { +fn phen_logistic_model( + t : Double, + asymptote : Double, + slope : Double, + inflection : Double, + initial : Double, +) -> Double { // f(t) = initial + (asymptote - initial) / (1 + exp(-slope * (t - inflection))) let exponent = -slope * (t - inflection) let denom = 1.0 + phen_safe_exp(exponent) @@ -262,7 +304,13 @@ fn phen_logistic_model(t : Double, asymptote : Double, slope : Double, inflectio ///| /// Gompertz model: initial + (asymptote - initial) * exp(-exp(-slope * (t - inflection))). -fn phen_gompertz_model(t : Double, asymptote : Double, slope : Double, inflection : Double, initial : Double) -> Double { +fn phen_gompertz_model( + t : Double, + asymptote : Double, + slope : Double, + inflection : Double, + initial : Double, +) -> Double { let inner = -slope * (t - inflection) let outer = -phen_safe_exp(inner) initial + (asymptote - initial) * phen_safe_exp(outer) @@ -283,14 +331,34 @@ fn phen_safe_exp(x : Double) -> Double { ///| /// Compute logistic curve fit using simplified grid search around estimates. pub fn phen_fit_logistic(well : WellRecord) -> PhenFitParams { - let (initial, plateau, slope_est, inflection_est) = phen_estimate_initial(well) + let (initial, plateau, slope_est, inflection_est) = phen_estimate_initial( + well, + ) let asymptote = plateau // Refine inflection and slope via coarse grid search let mut best_rss = 1.0e300 let mut best_slope = slope_est let mut best_inflection = inflection_est - let slope_candidates = [slope_est * 0.5, slope_est, slope_est * 1.5, slope_est * 2.0, 0.1, 0.5, 1.0] - let infl_candidates = [inflection_est - 5.0, inflection_est - 2.0, inflection_est, inflection_est + 2.0, inflection_est + 5.0, 0.0, 5.0, 10.0, 15.0] + let slope_candidates = [ + slope_est * 0.5, + slope_est, + slope_est * 1.5, + slope_est * 2.0, + 0.1, + 0.5, + 1.0, + ] + let infl_candidates = [ + inflection_est - 5.0, + inflection_est - 2.0, + inflection_est, + inflection_est + 2.0, + inflection_est + 5.0, + 0.0, + 5.0, + 10.0, + 15.0, + ] let mut si = 0 while si < slope_candidates.length() { let mut ii = 0 @@ -300,7 +368,13 @@ pub fn phen_fit_logistic(well : WellRecord) -> PhenFitParams { let mut rss = 0.0 let mut k = 0 while k < well.times.length() { - let pred = phen_logistic_model(well.times[k], asymptote, s, infl, initial) + let pred = phen_logistic_model( + well.times[k], + asymptote, + s, + infl, + initial, + ) let diff = well.signals[k] - pred rss = rss + diff * diff k = k + 1 @@ -315,7 +389,11 @@ pub fn phen_fit_logistic(well : WellRecord) -> PhenFitParams { si = si + 1 } // Lag time estimate: inflection - 1/slope - let lag_time = if best_slope > 0.0 { best_inflection - 1.0 / best_slope } else { 0.0 } + let lag_time = if best_slope > 0.0 { + best_inflection - 1.0 / best_slope + } else { + 0.0 + } let lag_clamped = if lag_time < 0.0 { 0.0 } else { lag_time } // R-squared let mean_y = phen_mean(well.signals) @@ -331,20 +409,40 @@ pub fn phen_fit_logistic(well : WellRecord) -> PhenFitParams { initial, model: "logistic", rss: best_rss, - r_squared: r_sq_clamped + r_squared: r_sq_clamped, } } ///| /// Compute Gompertz curve fit using simplified grid search. pub fn phen_fit_gompertz(well : WellRecord) -> PhenFitParams { - let (initial, plateau, slope_est, inflection_est) = phen_estimate_initial(well) + let (initial, plateau, slope_est, inflection_est) = phen_estimate_initial( + well, + ) let asymptote = plateau let mut best_rss = 1.0e300 let mut best_slope = slope_est let mut best_inflection = inflection_est - let slope_candidates = [slope_est * 0.5, slope_est, slope_est * 1.5, slope_est * 2.0, 0.1, 0.5, 1.0] - let infl_candidates = [inflection_est - 5.0, inflection_est - 2.0, inflection_est, inflection_est + 2.0, inflection_est + 5.0, 0.0, 5.0, 10.0, 15.0] + let slope_candidates = [ + slope_est * 0.5, + slope_est, + slope_est * 1.5, + slope_est * 2.0, + 0.1, + 0.5, + 1.0, + ] + let infl_candidates = [ + inflection_est - 5.0, + inflection_est - 2.0, + inflection_est, + inflection_est + 2.0, + inflection_est + 5.0, + 0.0, + 5.0, + 10.0, + 15.0, + ] let mut si = 0 while si < slope_candidates.length() { let mut ii = 0 @@ -354,7 +452,13 @@ pub fn phen_fit_gompertz(well : WellRecord) -> PhenFitParams { let mut rss = 0.0 let mut k = 0 while k < well.times.length() { - let pred = phen_gompertz_model(well.times[k], asymptote, s, infl, initial) + let pred = phen_gompertz_model( + well.times[k], + asymptote, + s, + infl, + initial, + ) let diff = well.signals[k] - pred rss = rss + diff * diff k = k + 1 @@ -368,7 +472,11 @@ pub fn phen_fit_gompertz(well : WellRecord) -> PhenFitParams { } si = si + 1 } - let lag_time = if best_slope > 0.0 { best_inflection - 1.0 / best_slope } else { 0.0 } + let lag_time = if best_slope > 0.0 { + best_inflection - 1.0 / best_slope + } else { + 0.0 + } let lag_clamped = if lag_time < 0.0 { 0.0 } else { lag_time } let mean_y = phen_mean(well.signals) let ss_tot = phen_sum_sq(well.signals, mean_y) @@ -383,7 +491,7 @@ pub fn phen_fit_gompertz(well : WellRecord) -> PhenFitParams { initial, model: "gompertz", rss: best_rss, - r_squared: r_sq_clamped + r_squared: r_sq_clamped, } } @@ -417,14 +525,29 @@ fn phen_sum_sq(arr : Array[Double], center : Double) -> Double { ///| /// Compute predicted values from a fitted model. -pub fn phen_predict(fit : PhenFitParams, times : Array[Double]) -> Array[Double] { +pub fn phen_predict( + fit : PhenFitParams, + times : Array[Double], +) -> Array[Double] { let preds : Array[Double] = Array::new() let mut i = 0 while i < times.length() { let pred = if fit.model == "logistic" { - phen_logistic_model(times[i], fit.asymptote, fit.slope, fit.inflection, fit.initial) + phen_logistic_model( + times[i], + fit.asymptote, + fit.slope, + fit.inflection, + fit.initial, + ) } else if fit.model == "gompertz" { - phen_gompertz_model(times[i], fit.asymptote, fit.slope, fit.inflection, fit.initial) + phen_gompertz_model( + times[i], + fit.asymptote, + fit.slope, + fit.inflection, + fit.initial, + ) } else { fit.asymptote } @@ -438,7 +561,10 @@ pub fn phen_predict(fit : PhenFitParams, times : Array[Double]) -> Array[Double] ///| /// Subtract control well signals from sample wells. -pub fn phen_subtract_control(plate : PlateRecord, control_well_id : String) -> PhenControlSubtracted { +pub fn phen_subtract_control( + plate : PlateRecord, + control_well_id : String, +) -> PhenControlSubtracted { let control_opt = plate.phen_get_well(control_well_id) let well_ids : Array[String] = Array::new() let signals : Array[Array[Double]] = Array::new() @@ -454,7 +580,11 @@ pub fn phen_subtract_control(plate : PlateRecord, control_well_id : String) -> P let sub : Array[Double] = Array::new() let mut j = 0 while j < w.signals.length() { - let ctrl = if j < control_signals.length() { control_signals[j] } else { 0.0 } + let ctrl = if j < control_signals.length() { + control_signals[j] + } else { + 0.0 + } let v = w.signals[j] - ctrl sub.push(v) j = j + 1 @@ -505,13 +635,23 @@ pub fn phen_parse_csv(csv_text : String) -> PlateRecord { new_times.push(t) let new_signals = w.signals.copy() new_signals.push(s) - well_map.set(wid, WellRecord::{ well_id: wid, plate_id: pid, times: new_times, signals: new_signals }) + well_map.set(wid, WellRecord::{ + well_id: wid, + plate_id: pid, + times: new_times, + signals: new_signals, + }) } else { let new_times : Array[Double] = Array::new() new_times.push(t) let new_signals : Array[Double] = Array::new() new_signals.push(s) - well_map.set(wid, WellRecord::{ well_id: wid, plate_id: pid, times: new_times, signals: new_signals }) + well_map.set(wid, WellRecord::{ + well_id: wid, + plate_id: pid, + times: new_times, + signals: new_signals, + }) } times_collected.push(t) } @@ -634,7 +774,12 @@ fn phen_json_extract_wells(json : String) -> Array[WellRecord] { let sigs = phen_json_extract_double_array(obj_str, "signals") let pid = phen_json_extract_string(json, "plate") let times = phen_json_extract_double_array(json, "times") - wells.push(WellRecord::{ well_id: wid, plate_id: pid, times, signals: sigs }) + wells.push(WellRecord::{ + well_id: wid, + plate_id: pid, + times, + signals: sigs, + }) } if json[pos] == ']' { depth = depth - 1 @@ -677,7 +822,11 @@ fn phen_parse_double(s : String) -> Double { i = i + 1 } let v = int_part + frac_part - if neg { -v } else { v } + if neg { + -v + } else { + v + } } ///| @@ -699,7 +848,8 @@ fn phen_dedup_sort(arr : Array[Double]) -> Array[Double] { let result : Array[Double] = Array::new() let mut k = 0 while k < sorted.length() { - if result.length() == 0 || (result[result.length() - 1] - sorted[k]).abs() > 1.0e-9 { + if result.length() == 0 || + (result[result.length() - 1] - sorted[k]).abs() > 1.0e-9 { result.push(sorted[k]) } k = k + 1 @@ -730,20 +880,38 @@ fn phen_sort_well_ids(ids : Array[String]) -> Array[String] { ///| /// Create a small example plate with growth curves. pub fn phen_create_example_plate() -> PlateRecord { - let times = [0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0] + let times = [ + 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, + ] let mut plate = PlateRecord::new("ExamplePlate", times) // Well A01 - control - let a01_signals = [0.05, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1] - plate = plate.phen_add_well(WellRecord::new("A01", "ExamplePlate", times, a01_signals)) + let a01_signals = [ + 0.05, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, + ] + plate = plate.phen_add_well( + WellRecord::new("A01", "ExamplePlate", times, a01_signals), + ) // Well A02 - growing culture - let a02_signals = [0.05, 0.06, 0.08, 0.12, 0.2, 0.35, 0.55, 0.75, 0.9, 0.97, 0.99, 1.0, 1.0] - plate = plate.phen_add_well(WellRecord::new("A02", "ExamplePlate", times, a02_signals)) + let a02_signals = [ + 0.05, 0.06, 0.08, 0.12, 0.2, 0.35, 0.55, 0.75, 0.9, 0.97, 0.99, 1.0, 1.0, + ] + plate = plate.phen_add_well( + WellRecord::new("A02", "ExamplePlate", times, a02_signals), + ) // Well A03 - another growing culture - let a03_signals = [0.04, 0.05, 0.06, 0.08, 0.12, 0.2, 0.32, 0.5, 0.7, 0.85, 0.93, 0.97, 0.99] - plate = plate.phen_add_well(WellRecord::new("A03", "ExamplePlate", times, a03_signals)) + let a03_signals = [ + 0.04, 0.05, 0.06, 0.08, 0.12, 0.2, 0.32, 0.5, 0.7, 0.85, 0.93, 0.97, 0.99, + ] + plate = plate.phen_add_well( + WellRecord::new("A03", "ExamplePlate", times, a03_signals), + ) // Well B01 - slow growth - let b01_signals = [0.05, 0.05, 0.05, 0.06, 0.07, 0.09, 0.12, 0.17, 0.25, 0.35, 0.48, 0.6, 0.72] - plate = plate.phen_add_well(WellRecord::new("B01", "ExamplePlate", times, b01_signals)) + let b01_signals = [ + 0.05, 0.05, 0.05, 0.06, 0.07, 0.09, 0.12, 0.17, 0.25, 0.35, 0.48, 0.6, 0.72, + ] + plate = plate.phen_add_well( + WellRecord::new("B01", "ExamplePlate", times, b01_signals), + ) plate } diff --git a/src/phylo_cdao.mbt b/src/phylo_cdao.mbt index d9271c2d..e024aa10 100644 --- a/src/phylo_cdao.mbt +++ b/src/phylo_cdao.mbt @@ -62,7 +62,7 @@ pub fn Cdaotree::new( id : String, rooted? : Bool = false, root_node_id? : String = "", - name? : String? = None + name? : String? = None, ) -> Cdaotree { Cdaotree::{ id, rooted, root_node_id, name } } @@ -86,7 +86,7 @@ pub fn CdaoNode::new( parent_id? : String? = None, tu_id? : String? = None, branch_length? : Double? = None, - label? : String? = None + label? : String? = None, ) -> CdaoNode { CdaoNode::{ id, children, parent_id, tu_id, branch_length, label } } @@ -198,14 +198,20 @@ fn cdao_extract_elements(xml : String, triples : Array[CdaoTriple]) -> Unit { break } let tag_content = xml[tag_start + 1:tag_end].to_owned() - if tag_content[0:1].to_owned() == "/" || tag_content[0:4].to_owned() == "!--" || tag_content.contains("rdf:RDF") { + if tag_content[0:1].to_owned() == "/" || + tag_content[0:4].to_owned() == "!--" || + tag_content.contains("rdf:RDF") { pos = tag_end + 1 continue } - let is_self_closing = tag_content[tag_content.length() - 1:tag_content.length()].to_owned() == "/" + let is_self_closing = tag_content[tag_content.length() - 1:tag_content.length()].to_owned() == + "/" let tag_name = cdao_get_tag_name(tag_content) let about = cdao_get_attribute(tag_content, "rdf:about") - if tag_name.contains("cdao:Tree") || tag_name.contains("cdao:Node") || tag_name.contains("cdao:TU") || tag_name.contains("rdf:Description") { + if tag_name.contains("cdao:Tree") || + tag_name.contains("cdao:Node") || + tag_name.contains("cdao:TU") || + tag_name.contains("rdf:Description") { let subject = match about { Some(a) => a None => "" @@ -244,7 +250,7 @@ fn cdao_extract_elements(xml : String, triples : Array[CdaoTriple]) -> Unit { fn cdao_parse_children( subject : String, inner : String, - triples : Array[CdaoTriple] + triples : Array[CdaoTriple], ) -> Unit { let mut pos = 0 while pos < inner.length() { @@ -257,11 +263,13 @@ fn cdao_parse_children( break } let tag_content = inner[tag_start + 1:tag_end].to_owned() - if tag_content[0:1].to_owned() == "/" || tag_content[0:4].to_owned() == "!--" { + if tag_content[0:1].to_owned() == "/" || + tag_content[0:4].to_owned() == "!--" { pos = tag_end + 1 continue } - let is_self_closing = tag_content[tag_content.length() - 1:tag_content.length()].to_owned() == "/" + let is_self_closing = tag_content[tag_content.length() - 1:tag_content.length()].to_owned() == + "/" let tag_name = cdao_get_tag_name(tag_content) let resource = cdao_get_attribute(tag_content, "rdf:resource") let close_tag = "" @@ -325,7 +333,9 @@ fn cdao_build_document(doc : CdaoDocument, triples : Array[CdaoTriple]) -> Unit let t = triples[j] if !doc.nodes.contains(t.subject) && !doc.tus.contains(t.subject) { if t.predicate.contains("cdao:") { - if t.predicate.contains("has_Child") || t.predicate.contains("has_Ancestor") || t.predicate.contains("belongs_to_TU") { + if t.predicate.contains("has_Child") || + t.predicate.contains("has_Ancestor") || + t.predicate.contains("belongs_to_TU") { doc.nodes[t.subject] = CdaoNode::new(t.subject) } } @@ -349,15 +359,19 @@ fn cdao_build_document(doc : CdaoDocument, triples : Array[CdaoTriple]) -> Unit idx = idx + 1 } if !found { - doc.trees.push(Cdaotree::new(t.subject, rooted=true, root_node_id=t.object)) + doc.trees.push( + Cdaotree::new(t.subject, rooted=true, root_node_id=t.object), + ) } - } else if t.predicate.contains("has_Child") || t.predicate.contains("has_Descendant") { + } else if t.predicate.contains("has_Child") || + t.predicate.contains("has_Descendant") { let node = doc.nodes.get(t.subject) match node { Some(n) => n.children.push(t.object) None => () } - } else if t.predicate.contains("has_Ancestor") || t.predicate.contains("has_Parent") { + } else if t.predicate.contains("has_Ancestor") || + t.predicate.contains("has_Parent") { let node = doc.nodes.get(t.subject) match node { Some(n) => n.parent_id = Some(t.object) @@ -443,11 +457,7 @@ fn cdao_build_clade(doc : CdaoDocument, node_id : String) -> Clade { children.push(cdao_build_clade(doc, n.children[ci])) ci = ci + 1 } - Clade::new( - branch_length=n.branch_length, - name=label, - clades=children, - ) + Clade::new(branch_length=n.branch_length, name=label, clades=children) } None => Clade::new(name=Some(node_id)) } @@ -492,7 +502,10 @@ pub fn cdao_write(tree : Tree) -> String { let tu_label = tu_arr[ti] let tu_id = state.tu_map[tu_label] output = output + " \n" - output = output + " " + cdao_escape_xml(tu_label) + "\n" + output = output + + " " + + cdao_escape_xml(tu_label) + + "\n" output = output + " \n" ti = ti + 1 } @@ -506,14 +519,16 @@ pub fn cdao_write(tree : Tree) -> String { fn cdao_write_clade( clade : Clade, node_uri : String, - state : CdaoWriteState + state : CdaoWriteState, ) -> (String, CdaoWriteState) { let mut output = "" output = output + " \n" match clade.branch_length { - Some(bl) => { - output = output + " " + bl.to_string() + "\n" - } + Some(bl) => + output = output + + " " + + bl.to_string() + + "\n" None => () } if clade.is_terminal() { @@ -531,7 +546,10 @@ fn cdao_write_clade( new_id } } - output = output + " \n" + output = output + + " \n" } // Collect child URIs let child_uris : Array[String] = Array::new() @@ -540,14 +558,21 @@ fn cdao_write_clade( state.node_counter = state.node_counter + 1 let child_uri = "#node" + state.node_counter.to_string() child_uris.push(child_uri) - output = output + " \n" + output = output + + " \n" ci = ci + 1 } output = output + " \n" // Recursively write children let mut di = 0 while di < clade.clades.length() { - let (child_output, _) = cdao_write_clade(clade.clades[di], child_uris[di], state) + let (child_output, _) = cdao_write_clade( + clade.clades[di], + child_uris[di], + state, + ) output = output + child_output di = di + 1 } @@ -565,12 +590,40 @@ pub fn cdao_sample_document() -> CdaoDocument { let doc = CdaoDocument::new() doc.trees.push(Cdaotree::new("#tree1", rooted=true, root_node_id="#node1")) doc.nodes["#node1"] = CdaoNode::new("#node1", children=["#node2", "#node3"]) - doc.nodes["#node2"] = CdaoNode::new("#node2", children=["#node4", "#node5"], parent_id=Some("#node1")) - doc.nodes["#node3"] = CdaoNode::new("#node3", children=["#node6", "#node7"], parent_id=Some("#node1")) - doc.nodes["#node4"] = CdaoNode::new("#node4", parent_id=Some("#node2"), tu_id=Some("#tu1"), branch_length=Some(1.0)) - doc.nodes["#node5"] = CdaoNode::new("#node5", parent_id=Some("#node2"), tu_id=Some("#tu2"), branch_length=Some(1.0)) - doc.nodes["#node6"] = CdaoNode::new("#node6", parent_id=Some("#node3"), tu_id=Some("#tu3"), branch_length=Some(1.0)) - doc.nodes["#node7"] = CdaoNode::new("#node7", parent_id=Some("#node3"), tu_id=Some("#tu4"), branch_length=Some(1.0)) + doc.nodes["#node2"] = CdaoNode::new( + "#node2", + children=["#node4", "#node5"], + parent_id=Some("#node1"), + ) + doc.nodes["#node3"] = CdaoNode::new( + "#node3", + children=["#node6", "#node7"], + parent_id=Some("#node1"), + ) + doc.nodes["#node4"] = CdaoNode::new( + "#node4", + parent_id=Some("#node2"), + tu_id=Some("#tu1"), + branch_length=Some(1.0), + ) + doc.nodes["#node5"] = CdaoNode::new( + "#node5", + parent_id=Some("#node2"), + tu_id=Some("#tu2"), + branch_length=Some(1.0), + ) + doc.nodes["#node6"] = CdaoNode::new( + "#node6", + parent_id=Some("#node3"), + tu_id=Some("#tu3"), + branch_length=Some(1.0), + ) + doc.nodes["#node7"] = CdaoNode::new( + "#node7", + parent_id=Some("#node3"), + tu_id=Some("#tu4"), + branch_length=Some(1.0), + ) doc.tus["#tu1"] = CdaoTU::new("#tu1", label=Some("A")) doc.tus["#tu2"] = CdaoTU::new("#tu2", label=Some("B")) doc.tus["#tu3"] = CdaoTU::new("#tu3", label=Some("C")) @@ -720,7 +773,11 @@ fn cdao_get_attribute(tag_content : String, attr_name : String) -> String? { fn cdao_parse_double(s : String) -> Double { let trimmed = s.trim().to_string() let neg = trimmed[0:1].to_owned() == "-" - let digits = if neg { trimmed[1:trimmed.length()].to_string() } else { trimmed } + let digits = if neg { + trimmed[1:trimmed.length()].to_string() + } else { + trimmed + } let result = parse_double(digits) match result { Some(d) => if neg { -d } else { d } diff --git a/src/phylo_consensus.mbt b/src/phylo_consensus.mbt index 5608f54c..575de1e5 100644 --- a/src/phylo_consensus.mbt +++ b/src/phylo_consensus.mbt @@ -19,33 +19,34 @@ pub struct ConsensusNode { ///| pub fn ConsensusNode::new(name : String, is_internal : Bool) -> ConsensusNode { - ConsensusNode::{ - name, - children: Array::new(), - support: 0.0, - is_internal: is_internal - } + ConsensusNode::{ name, children: Array::new(), support: 0.0, is_internal } } ///| -pub fn ConsensusNode::add_child(self : ConsensusNode, child : ConsensusNode) -> ConsensusNode { +pub fn ConsensusNode::add_child( + self : ConsensusNode, + child : ConsensusNode, +) -> ConsensusNode { let new_children = self.children new_children.push(child) ConsensusNode::{ name: self.name, children: new_children, support: self.support, - is_internal: self.is_internal + is_internal: self.is_internal, } } ///| -pub fn ConsensusNode::set_support(self : ConsensusNode, support : Double) -> ConsensusNode { +pub fn ConsensusNode::set_support( + self : ConsensusNode, + support : Double, +) -> ConsensusNode { ConsensusNode::{ name: self.name, children: self.children, - support: support, - is_internal: self.is_internal + support, + is_internal: self.is_internal, } } @@ -82,40 +83,31 @@ pub struct Split { ///| pub fn Split::new(taxa : Array[String]) -> Split { - Split::{ - taxa, - support: 0.0 - } + Split::{ taxa, support: 0.0 } } ///| pub fn Split::set_support(self : Split, support : Double) -> Split { - Split::{ - taxa: self.taxa, - support: support - } + Split::{ taxa: self.taxa, support } } ///| pub fn Split::normalize(self : Split) -> Split { let sorted = sort_strings(self.taxa) - Split::{ - taxa: sorted, - support: self.support - } + Split::{ taxa: sorted, support: self.support } } ///| fn sort_taxa_strings(arr : Array[String]) -> Array[String] { let n = arr.length() let result = Array::make(n, "") - + let mut i = 0 while i < n { result[i] = arr[i] i = i + 1 } - + i = 0 while i < n - 1 { let mut j = i + 1 @@ -129,7 +121,7 @@ fn sort_taxa_strings(arr : Array[String]) -> Array[String] { } i = i + 1 } - + result } @@ -164,17 +156,24 @@ pub fn Split::hash(self : Split) -> String { } ///| -pub fn get_all_splits(node : ConsensusNode, all_taxa : Array[String]) -> Array[Split] { +pub fn get_all_splits( + node : ConsensusNode, + all_taxa : Array[String], +) -> Array[Split] { let result : Array[Split] = Array::new() ignore(get_splits_recursive(node, all_taxa, result)) result } ///| -fn get_splits_recursive(node : ConsensusNode, all_taxa : Array[String], result : Array[Split]) -> Unit { +fn get_splits_recursive( + node : ConsensusNode, + all_taxa : Array[String], + result : Array[Split], +) -> Unit { if !node.is_leaf() { let node_leaves = node.get_leaves() - + let other_leaves : Array[String] = Array::new() let mut i = 0 while i < all_taxa.length() { @@ -184,12 +183,12 @@ fn get_splits_recursive(node : ConsensusNode, all_taxa : Array[String], result : } i = i + 1 } - + if node_leaves.length() > 0 && other_leaves.length() > 0 { let split1 = Split::new(node_leaves).normalize() result.push(split1) } - + let mut j = 0 while j < node.children.length() { ignore(get_splits_recursive(node.children[j], all_taxa, result)) @@ -211,15 +210,18 @@ fn contains_string(arr : Array[String], s : String) -> Bool { } ///| -pub fn build_consensus(trees : Array[ConsensusTree], threshold : Double) -> ConsensusTree { +pub fn build_consensus( + trees : Array[ConsensusTree], + threshold : Double, +) -> ConsensusTree { if trees.length() == 0 { return ConsensusTree::{ nodes: Array::new(), root: None } } - + let all_taxa = get_all_taxa(trees[0]) - + let split_counts : Map[String, Int] = Map([], capacity=0) - + let mut i = 0 while i < trees.length() { match trees[i].root { @@ -228,7 +230,11 @@ pub fn build_consensus(trees : Array[ConsensusTree], threshold : Double) -> Cons let mut j = 0 while j < splits.length() { let h = splits[j].hash() - let current = if split_counts.contains(h) { split_counts.get(h).unwrap() } else { 0 } + let current = if split_counts.contains(h) { + split_counts.get(h).unwrap() + } else { + 0 + } split_counts.set(h, current + 1) j = j + 1 } @@ -237,10 +243,10 @@ pub fn build_consensus(trees : Array[ConsensusTree], threshold : Double) -> Cons } i = i + 1 } - + let n_trees = trees.length().to_double() let consensus_splits : Array[Split] = Array::new() - + let entries = split_counts.iter().collect() let mut k = 0 while k < entries.length() { @@ -253,13 +259,10 @@ pub fn build_consensus(trees : Array[ConsensusTree], threshold : Double) -> Cons } k = k + 1 } - + let consensus_root = build_tree_from_splits(all_taxa, consensus_splits) - - ConsensusTree::{ - nodes: Array::new(), - root: Some(consensus_root) - } + + ConsensusTree::{ nodes: Array::new(), root: Some(consensus_root) } } ///| @@ -286,7 +289,10 @@ fn get_all_taxa(tree : ConsensusTree) -> Array[String] { } ///| -fn build_tree_from_splits(taxa : Array[String], splits : Array[Split]) -> ConsensusNode { +fn build_tree_from_splits( + taxa : Array[String], + splits : Array[Split], +) -> ConsensusNode { if splits.length() == 0 || taxa.length() == 1 { let root = ConsensusNode::new("root", true) let mut i = 0 @@ -297,26 +303,26 @@ fn build_tree_from_splits(taxa : Array[String], splits : Array[Split]) -> Consen } return root } - + let sorted_splits = sort_splits_by_support(splits) - + let root = ConsensusNode::new("root", true) let leaves : Map[String, ConsensusNode] = Map([], capacity=0) - + let mut i = 0 while i < taxa.length() { leaves.set(taxa[i], ConsensusNode::new(taxa[i], false)) i = i + 1 } - + let mut j = 0 while j < sorted_splits.length() { let split = sorted_splits[j] let split_taxa = split.taxa - + let group = Array::new() let remaining = Array::new() - + let keys = leaves.keys().collect() let mut k = 0 while k < keys.length() { @@ -329,37 +335,39 @@ fn build_tree_from_splits(taxa : Array[String], splits : Array[Split]) -> Consen } k = k + 1 } - + if group.length() > 1 && remaining.length() > 0 { - let internal_node = ConsensusNode::new("", true).set_support(split.support) - + let internal_node = ConsensusNode::new("", true).set_support( + split.support, + ) + let mut l = 0 while l < group.length() { internal_node.children.push(group[l]) l = l + 1 } - + leaves.clear() - + leaves.set("internal_" + j.to_string(), internal_node) - + let mut m = 0 while m < remaining.length() { leaves.set(remaining[m].name, remaining[m]) m = m + 1 } } - + j = j + 1 } - + let final_nodes = leaves.values().collect() let mut n = 0 while n < final_nodes.length() { root.children.push(final_nodes[n]) n = n + 1 } - + root } @@ -367,13 +375,13 @@ fn build_tree_from_splits(taxa : Array[String], splits : Array[Split]) -> Consen fn sort_splits_by_support(splits : Array[Split]) -> Array[Split] { let n = splits.length() let result = Array::make(n, Split::new(Array::new())) - + let mut i = 0 while i < n { result[i] = splits[i] i = i + 1 } - + i = 0 while i < n - 1 { let mut j = i + 1 @@ -387,7 +395,7 @@ fn sort_splits_by_support(splits : Array[Split]) -> Array[Split] { } i = i + 1 } - + result } @@ -397,9 +405,9 @@ pub fn parse_consensus_newick(newick : String) -> ConsensusNode? { if trimmed == "" { return None } - + let (root, _) = parse_newick_recursive(trimmed, 0) - + Some(root) } @@ -407,11 +415,20 @@ pub fn parse_consensus_newick(newick : String) -> ConsensusNode? { fn trim_newick(s : String) -> String { let n = s.length() let mut start = 0 - while start < n && (s.unsafe_get(start).to_int() == ' '.to_int() || s.unsafe_get(start).to_int() == '\t'.to_int()) { + while start < n && + ( + s.unsafe_get(start).to_int() == ' '.to_int() || + s.unsafe_get(start).to_int() == '\t'.to_int() + ) { start = start + 1 } let mut end = n - while end > start && (s.unsafe_get(end - 1).to_int() == ' '.to_int() || s.unsafe_get(end - 1).to_int() == '\t'.to_int() || s.unsafe_get(end - 1).to_int() == ';'.to_int()) { + while end > start && + ( + s.unsafe_get(end - 1).to_int() == ' '.to_int() || + s.unsafe_get(end - 1).to_int() == '\t'.to_int() || + s.unsafe_get(end - 1).to_int() == ';'.to_int() + ) { end = end - 1 } substring(s, start, end - start) @@ -420,23 +437,32 @@ fn trim_newick(s : String) -> String { ///| fn parse_newick_recursive(s : String, i : Int) -> (ConsensusNode, Int) { let children = Array::new() - + let mut idx = i + 1 - + while idx < s.length() && s.unsafe_get(idx).to_int() != ')'.to_int() { if s.unsafe_get(idx).to_int() == '('.to_int() { let (child, new_idx) = parse_newick_recursive(s, idx) children.push(child) idx = new_idx - } else if s.unsafe_get(idx).to_int() != ','.to_int() && s.unsafe_get(idx).to_int() != ')'.to_int() { + } else if s.unsafe_get(idx).to_int() != ','.to_int() && + s.unsafe_get(idx).to_int() != ')'.to_int() { let mut name = "" - while idx < s.length() && s.unsafe_get(idx).to_int() != ','.to_int() && s.unsafe_get(idx).to_int() != ')'.to_int() && s.unsafe_get(idx).to_int() != ':'.to_int() { + while idx < s.length() && + s.unsafe_get(idx).to_int() != ','.to_int() && + s.unsafe_get(idx).to_int() != ')'.to_int() && + s.unsafe_get(idx).to_int() != ':'.to_int() { name = name + char_at(s, idx) idx = idx + 1 } children.push(ConsensusNode::new(name, false)) - - while idx < s.length() && (s.unsafe_get(idx).to_int() == ':'.to_int() || s.unsafe_get(idx).to_int() == ','.to_int() || s.unsafe_get(idx).to_int() == ')'.to_int()) { + + while idx < s.length() && + ( + s.unsafe_get(idx).to_int() == ':'.to_int() || + s.unsafe_get(idx).to_int() == ','.to_int() || + s.unsafe_get(idx).to_int() == ')'.to_int() + ) { if s.unsafe_get(idx).to_int() == ')'.to_int() { break } @@ -446,31 +472,39 @@ fn parse_newick_recursive(s : String, i : Int) -> (ConsensusNode, Int) { idx = idx + 1 } } - + idx = idx + 1 - + let mut name = "" - while idx < s.length() && s.unsafe_get(idx).to_int() != ';'.to_int() && s.unsafe_get(idx).to_int() != ','.to_int() && s.unsafe_get(idx).to_int() != ':'.to_int() { + while idx < s.length() && + s.unsafe_get(idx).to_int() != ';'.to_int() && + s.unsafe_get(idx).to_int() != ','.to_int() && + s.unsafe_get(idx).to_int() != ':'.to_int() { name = name + char_at(s, idx) idx = idx + 1 } - - while idx < s.length() && (s.unsafe_get(idx).to_int() == ':'.to_int() || s.unsafe_get(idx).to_int() == ','.to_int() || s.unsafe_get(idx).to_int() == ')'.to_int()) { + + while idx < s.length() && + ( + s.unsafe_get(idx).to_int() == ':'.to_int() || + s.unsafe_get(idx).to_int() == ','.to_int() || + s.unsafe_get(idx).to_int() == ')'.to_int() + ) { idx = idx + 1 } - + let node = if children.length() > 0 { ConsensusNode::new(name, true) } else { ConsensusNode::new(name, false) } - + let mut j = 0 while j < children.length() { node.children.push(children[j]) j = j + 1 } - + (node, idx) } @@ -496,7 +530,7 @@ fn node_to_newick(node : ConsensusNode) -> String { node.name } else { let mut result = "(" - + let mut i = 0 while i < node.children.length() { if i > 0 { @@ -505,17 +539,17 @@ fn node_to_newick(node : ConsensusNode) -> String { result = result + node_to_newick(node.children[i]) i = i + 1 } - + result = result + ")" - + if node.name != "" { result = result + node.name } - + if node.support > 0.0 { result = result + ":" + node.support.to_string() } - + result } } @@ -527,7 +561,7 @@ pub fn create_example_trees() -> Array[ConsensusTree] { let tree3 = newick_to_tree("((A,B),(C,D));") let tree4 = newick_to_tree("((A,B,C),D);") let tree5 = newick_to_tree("((A,B),(C,D));") - + [tree1, tree2, tree3, tree4, tree5] } @@ -549,9 +583,9 @@ fn node_to_string(node : ConsensusNode, indent : Int) -> String { prefix = prefix + " " i = i + 1 } - + let mut result = prefix - + if node.is_internal { result = result + "[internal" if node.support > 0.0 { @@ -564,13 +598,13 @@ fn node_to_string(node : ConsensusNode, indent : Int) -> String { } else { result = result + "[leaf] " + node.name + "\n" } - + let mut j = 0 while j < node.children.length() { result = result + node_to_string(node.children[j], indent + 1) j = j + 1 } - + result } @@ -583,15 +617,18 @@ pub fn ConsensusTree::to_string(self : ConsensusTree) -> String { } ///| -pub fn calculate_consensus_support(trees : Array[ConsensusTree], split : Split) -> Double { +pub fn calculate_consensus_support( + trees : Array[ConsensusTree], + split : Split, +) -> Double { if trees.length() == 0 { return 0.0 } - + let all_taxa = get_all_taxa(trees[0]) let normalized_split = split.normalize() let split_hash = normalized_split.hash() - + let mut count = 0 let mut i = 0 while i < trees.length() { @@ -611,7 +648,7 @@ pub fn calculate_consensus_support(trees : Array[ConsensusTree], split : Split) } i = i + 1 } - + count.to_double() / trees.length().to_double() } @@ -620,10 +657,10 @@ pub fn get_all_splits_from_trees(trees : Array[ConsensusTree]) -> Array[Split] { if trees.length() == 0 { return Array::new() } - + let all_taxa = get_all_taxa(trees[0]) let seen : Map[String, Split] = Map([], capacity=0) - + let mut i = 0 while i < trees.length() { match trees[i].root { @@ -643,6 +680,6 @@ pub fn get_all_splits_from_trees(trees : Array[ConsensusTree]) -> Array[Split] { } i = i + 1 } - + seen.values().collect() -} \ No newline at end of file +} diff --git a/src/phylo_nexml.mbt b/src/phylo_nexml.mbt index 2e91728d..a011f8e6 100644 --- a/src/phylo_nexml.mbt +++ b/src/phylo_nexml.mbt @@ -200,15 +200,15 @@ fn nexml_parse_float(s : String) -> Double? { let mut sign = 1.0 let mut i = 0 let zero = '0'.to_int() - + if s.unsafe_get(0).to_int() == '-'.to_int() { sign = -1.0 i = 1 } - + let mut has_dot = false let mut decimal_place = 1.0 - + while i < s.length() { let c = s.unsafe_get(i).to_int() if c == '.'.to_int() { @@ -225,7 +225,7 @@ fn nexml_parse_float(s : String) -> Double? { } i = i + 1 } - + Some(result * sign / decimal_place) } @@ -237,7 +237,7 @@ fn nexml_parse_float(s : String) -> Double? { /// Parse a NeXML document from XML string. pub fn parse_nexml(xml_content : String) -> NeXMLDocument { let mut doc = NeXMLDocument::new() - + // Check if there's a nexml element let (nexml_start, _, _) = find_element(xml_content, "nexml") if nexml_start == 0 && xml_content.length() > 0 { @@ -252,16 +252,16 @@ pub fn parse_nexml(xml_content : String) -> NeXMLDocument { doc = NeXMLDocument::{ ..doc, generator: generator_attr } } } - + // Parse OTUs blocks doc = parse_otus_blocks(xml_content, doc) - + // Parse characters blocks doc = parse_characters_blocks(xml_content, doc) - + // Parse trees blocks doc = parse_trees_blocks(xml_content, doc) - + doc } @@ -269,15 +269,15 @@ pub fn parse_nexml(xml_content : String) -> NeXMLDocument { fn parse_otus_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { let otus_elements = find_all_elements(xml, "otus") let new_otus_blocks = doc.otus_blocks.copy() - + for i = 0; i < otus_elements.length(); i = i + 1 { let (start, end) = otus_elements[i] let otus_xml = xml[start:end].to_owned() let otus_id = get_attribute(otus_xml, "id") - + let otu_list : Array[NeXMLOTU] = Array::new() let otu_elements = find_all_elements(otus_xml, "otu") - + for j = 0; j < otu_elements.length(); j = j + 1 { let (otu_start, otu_end) = otu_elements[j] let otu_xml = otus_xml[otu_start:otu_end].to_owned() @@ -289,10 +289,10 @@ fn parse_otus_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { otu_list.push(NeXMLOTU::new(id, label)) } } - + new_otus_blocks.push(NeXMLOTUs::new(otus_id, otu_list)) } - + NeXMLDocument::{ ..doc, otus_blocks: new_otus_blocks } } @@ -300,7 +300,7 @@ fn parse_otus_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { fn parse_characters_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { let chars_elements = find_all_elements(xml, "characters") let new_chars_blocks = doc.characters_blocks.copy() - + for i = 0; i < chars_elements.length(); i = i + 1 { let (start, end) = chars_elements[i] let chars_xml = xml[start:end].to_owned() @@ -310,10 +310,10 @@ fn parse_characters_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { if matrix_type.length() == 0 { let xtype = get_attribute(chars_xml, "type") let final_type = if xtype.length() > 0 { xtype } else { "StandardCells" } - + let char_list : Array[NeXMLCharacter] = Array::new() let char_elements = find_all_elements(chars_xml, "char") - + for j = 0; j < char_elements.length(); j = j + 1 { let (c_start, c_end) = char_elements[j] let char_xml = chars_xml[c_start:c_end].to_owned() @@ -321,34 +321,34 @@ fn parse_characters_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { let clabel = get_attribute(char_xml, "label") char_list.push(NeXMLCharacter::new(cid, clabel, [])) } - + let matrix : Map[String, Array[String]] = Map([], capacity=16) let row_elements = find_all_elements(chars_xml, "row") - + for j = 0; j < row_elements.length(); j = j + 1 { let (r_start, r_end) = row_elements[j] let row_xml = chars_xml[r_start:r_end].to_owned() let otu = get_attribute(row_xml, "otu") let cell_elements = find_all_elements(row_xml, "cell") let row_data : Array[String] = Array::new() - + for k = 0; k < cell_elements.length(); k = k + 1 { let (c_start2, c_end2) = cell_elements[k] let cell_xml = row_xml[c_start2:c_end2].to_owned() let state = get_attribute(cell_xml, "state") row_data.push(state) } - + matrix.set(otu, row_data) } - + new_chars_blocks.push( - NeXMLCharacters::new(chars_id, otus_id, final_type, char_list, matrix) + NeXMLCharacters::new(chars_id, otus_id, final_type, char_list, matrix), ) } else { let char_list : Array[NeXMLCharacter] = Array::new() let char_elements = find_all_elements(chars_xml, "char") - + for j = 0; j < char_elements.length(); j = j + 1 { let (c_start, c_end) = char_elements[j] let char_xml = chars_xml[c_start:c_end].to_owned() @@ -356,33 +356,33 @@ fn parse_characters_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { let clabel = get_attribute(char_xml, "label") char_list.push(NeXMLCharacter::new(cid, clabel, [])) } - + let matrix : Map[String, Array[String]] = Map([], capacity=16) let row_elements = find_all_elements(chars_xml, "row") - + for j = 0; j < row_elements.length(); j = j + 1 { let (r_start, r_end) = row_elements[j] let row_xml = chars_xml[r_start:r_end].to_owned() let otu = get_attribute(row_xml, "otu") let cell_elements = find_all_elements(row_xml, "cell") let row_data : Array[String] = Array::new() - + for k = 0; k < cell_elements.length(); k = k + 1 { let (c_start2, c_end2) = cell_elements[k] let cell_xml = row_xml[c_start2:c_end2].to_owned() let state = get_attribute(cell_xml, "state") row_data.push(state) } - + matrix.set(otu, row_data) } - + new_chars_blocks.push( - NeXMLCharacters::new(chars_id, otus_id, matrix_type, char_list, matrix) + NeXMLCharacters::new(chars_id, otus_id, matrix_type, char_list, matrix), ) } } - + NeXMLDocument::{ ..doc, characters_blocks: new_chars_blocks } } @@ -390,16 +390,16 @@ fn parse_characters_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { fn parse_trees_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { let trees_elements = find_all_elements(xml, "trees") let new_trees_blocks = doc.trees_blocks.copy() - + for i = 0; i < trees_elements.length(); i = i + 1 { let (start, end) = trees_elements[i] let trees_xml = xml[start:end].to_owned() let trees_id = get_attribute(trees_xml, "id") let otus_id = get_attribute(trees_xml, "otus") - + let tree_list : Array[NeXMLTree] = Array::new() let tree_elements = find_all_elements(trees_xml, "tree") - + for j = 0; j < tree_elements.length(); j = j + 1 { let (t_start, t_end) = tree_elements[j] let tree_xml = trees_xml[t_start:t_end].to_owned() @@ -409,55 +409,55 @@ fn parse_trees_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { let rooted = rooted_str == "true" let ttype = get_attribute(tree_xml, "xsi:type") let final_type = if ttype.length() > 0 { ttype } else { "FloatTree" } - + let node_list : Array[NeXMLNode] = Array::new() let node_elements = find_all_elements(tree_xml, "node") - + for k = 0; k < node_elements.length(); k = k + 1 { let (n_start, n_end) = node_elements[k] let node_xml = tree_xml[n_start:n_end].to_owned() let nid = get_attribute(node_xml, "id") let nlabel = get_attribute(node_xml, "label") let notu = get_attribute(node_xml, "otu") - + let length_str = get_attribute(node_xml, "length") let nlength : Double? = if length_str.length() > 0 { nexml_parse_float(length_str) } else { None } - + node_list.push(NeXMLNode::new(nid, nlabel, notu, length=nlength)) } - + let edge_list : Array[NeXMLEdge] = Array::new() let edge_elements = find_all_elements(tree_xml, "edge") - + for k = 0; k < edge_elements.length(); k = k + 1 { let (e_start, e_end) = edge_elements[k] let edge_xml = tree_xml[e_start:e_end].to_owned() let eid = get_attribute(edge_xml, "id") let esource = get_attribute(edge_xml, "source") let etarget = get_attribute(edge_xml, "target") - + let length_str = get_attribute(edge_xml, "length") let elength : Double? = if length_str.length() > 0 { nexml_parse_float(length_str) } else { None } - + edge_list.push(NeXMLEdge::new(eid, esource, etarget, length=elength)) } - + tree_list.push( - NeXMLTree::new(tid, tname, final_type, rooted, node_list, edge_list) + NeXMLTree::new(tid, tname, final_type, rooted, node_list, edge_list), ) } - + new_trees_blocks.push(NeXMLTrees::new(trees_id, otus_id, tree_list)) } - + NeXMLDocument::{ ..doc, trees_blocks: new_trees_blocks } } @@ -475,26 +475,40 @@ pub fn nexml_to_xml(doc : NeXMLDocument) -> String { xml = xml + " xmlns:nex=\"http://www.nexml.org/2009\"\n" xml = xml + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n" xml = xml + " xmlns:xml=\"http://www.w3.org/XML/1998/namespace\">\n" - + // Write OTUs blocks for i = 0; i < doc.otus_blocks.length(); i = i + 1 { let otus_block = doc.otus_blocks[i] xml = xml + " \n" for j = 0; j < otus_block.otus.length(); j = j + 1 { let otu = otus_block.otus[j] - xml = xml + " \n" + xml = xml + + " \n" } xml = xml + " \n" } - + // Write characters blocks for i = 0; i < doc.characters_blocks.length(); i = i + 1 { let chars_block = doc.characters_blocks[i] - xml = xml + " \n" + xml = xml + + " \n" for j = 0; j < chars_block.characters.length(); j = j + 1 { let ch = chars_block.characters[j] - xml = xml + " \n" + xml = xml + + " \n" } xml = xml + " \n" for otu in chars_block.matrix.keys() { @@ -511,18 +525,27 @@ pub fn nexml_to_xml(doc : NeXMLDocument) -> String { xml = xml + " \n" xml = xml + " \n" } - + // Write trees blocks for i = 0; i < doc.trees_blocks.length(); i = i + 1 { let trees_block = doc.trees_blocks[i] - xml = xml + " \n" + xml = xml + + " \n" for j = 0; j < trees_block.trees.length(); j = j + 1 { let tree = trees_block.trees[j] let rooted_str = if tree.rooted { "true" } else { "false" } - xml = xml + " \n" + xml = xml + + " \n" for k = 0; k < tree.nodes.length(); k = k + 1 { let node = tree.nodes[k] xml = xml + " String { } for k = 0; k < tree.edges.length(); k = k + 1 { let edge = tree.edges[k] - xml = xml + " xml = xml + " length=\"" + len.to_string() + "\"" None => () @@ -553,9 +581,9 @@ pub fn nexml_to_xml(doc : NeXMLDocument) -> String { } xml = xml + " \n" } - + xml = xml + "\n" - + xml } @@ -569,11 +597,14 @@ pub fn nexml_tree_to_newick(tree : NeXMLTree) -> String { if tree.nodes.length() == 0 { return ";" } - + // Build adjacency list - let children_map : Map[String, Array[(String, Double?)]] = Map([], capacity=16) + let children_map : Map[String, Array[(String, Double?)]] = Map( + [], + capacity=16, + ) let parent_map : Map[String, String] = Map([], capacity=16) - + for i = 0; i < tree.edges.length(); i = i + 1 { let edge = tree.edges[i] let existing_opt = children_map.get(edge.source) @@ -586,7 +617,7 @@ pub fn nexml_tree_to_newick(tree : NeXMLTree) -> String { children_map.set(edge.source, new_children) parent_map.set(edge.target, edge.source) } - + // Find root (node with no parent) let mut root_id = "" for i = 0; i < tree.nodes.length(); i = i + 1 { @@ -596,11 +627,11 @@ pub fn nexml_tree_to_newick(tree : NeXMLTree) -> String { break } } - + if root_id.length() == 0 && tree.nodes.length() > 0 { root_id = tree.nodes[0].id } - + // Build Newick recursively let (newick_str, _) = build_newick(tree, root_id, children_map) newick_str + ";" @@ -613,7 +644,7 @@ fn build_newick( children_map : Map[String, Array[(String, Double?)]], ) -> (String, Bool) { let children_opt = children_map.get(node_id) - + // Find node label let mut node_label = "" let mut node_length : Double? = None @@ -624,9 +655,9 @@ fn build_newick( break } } - + match children_opt { - Some(children) => { + Some(children) => if children.length() == 0 { // Leaf node (node_label, true) @@ -647,11 +678,9 @@ fn build_newick( result = result + ")" + node_label (result, false) } - } - None => { + None => // Leaf node (no children in map) (node_label, true) - } } } diff --git a/src/phylo_xml.mbt b/src/phylo_xml.mbt index f03006d0..e7b659e0 100644 --- a/src/phylo_xml.mbt +++ b/src/phylo_xml.mbt @@ -188,8 +188,9 @@ fn xml_parse_attrs(attr_str : String) -> Map[String, String] { break } let key_start = i - while i < n && trimmed.unsafe_get(i).to_int() != eq && - trimmed.unsafe_get(i).to_int() != space { + while i < n && + trimmed.unsafe_get(i).to_int() != eq && + trimmed.unsafe_get(i).to_int() != space { i = i + 1 } let key = trimmed[key_start:i].to_owned() @@ -222,8 +223,9 @@ fn xml_parse_attrs(attr_str : String) -> Map[String, String] { } } else { let val_start = i - while i < n && trimmed.unsafe_get(i).to_int() != space && - trimmed.unsafe_get(i).to_int() != gt { + while i < n && + trimmed.unsafe_get(i).to_int() != space && + trimmed.unsafe_get(i).to_int() != gt { i = i + 1 } result[key] = trimmed[val_start:i].to_owned() @@ -248,8 +250,11 @@ fn xml_find_open_tag( let rest = xml[i + 1:].to_owned() let rest_len = rest.length() let mut j = 0 - while j < rest_len && char_at(rest, j) != ">" && char_at(rest, j) != "/" && - char_at(rest, j) != " " && char_at(rest, j) != "\t" { + while j < rest_len && + char_at(rest, j) != ">" && + char_at(rest, j) != "/" && + char_at(rest, j) != " " && + char_at(rest, j) != "\t" { j = j + 1 } let found_tag = xml_strip_n(rest[0:j].to_owned()) @@ -301,8 +306,10 @@ fn xml_find_close_tag( let after_slash = rest[1:].to_owned() let mut j = 0 let rlen = after_slash.length() - while j < rlen && char_at(after_slash, j) != ">" && - char_at(after_slash, j) != " " && char_at(after_slash, j) != "\t" { + while j < rlen && + char_at(after_slash, j) != ">" && + char_at(after_slash, j) != " " && + char_at(after_slash, j) != "\t" { j = j + 1 } let close_tag = xml_strip_n(after_slash[0:j].to_owned()) @@ -323,9 +330,11 @@ fn xml_find_close_tag( } else { let mut j = 0 let rlen = rest.length() - while j < rlen && char_at(rest, j) != ">" && - char_at(rest, j) != "/" && char_at(rest, j) != " " && - char_at(rest, j) != "\t" { + while j < rlen && + char_at(rest, j) != ">" && + char_at(rest, j) != "/" && + char_at(rest, j) != " " && + char_at(rest, j) != "\t" { j = j + 1 } let found_tag = xml_strip_n(rest[0:j].to_owned()) @@ -378,8 +387,10 @@ fn find_tag_end(xml : String, open_start : Int, tag_name : String) -> Int { let rest = xml[i + 1:].to_owned() let mut j = 0 let rlen = rest.length() - while j < rlen && char_at(rest, j) != ">" && - char_at(rest, j) != "/" && char_at(rest, j) != " " { + while j < rlen && + char_at(rest, j) != ">" && + char_at(rest, j) != "/" && + char_at(rest, j) != " " { j = j + 1 } let found_tag = xml_strip_n(rest[0:j].to_owned()) @@ -412,7 +423,10 @@ fn has_nested_elements(s : String) -> Bool { ///| /// Extract a complete XML element by tag name. /// Returns (attributes_map, children_text) or (empty_map, ""). -fn xml_extract_element(xml : String, tag_name : String) -> (Map[String, String], String) { +fn xml_extract_element( + xml : String, + tag_name : String, +) -> (Map[String, String], String) { let open_opt = xml_find_open_tag(xml, tag_name, 0) if open_opt.is_none() { return (Map([], capacity=4), "") @@ -433,7 +447,11 @@ fn xml_extract_element(xml : String, tag_name : String) -> (Map[String, String], ///| /// Get text content between an open tag and close tag positions. -fn xml_get_text_between(xml : String, open_tag : Int, close_tag : Int) -> String { +fn xml_get_text_between( + xml : String, + open_tag : Int, + close_tag : Int, +) -> String { if open_tag >= close_tag { return "" } @@ -448,10 +466,7 @@ fn xml_get_text_between(xml : String, open_tag : Int, close_tag : Int) -> String ///| /// Find first XML element by tag name. /// Returns (start_pos, end_pos, content_string) or (0, 0, ""). -pub fn find_element( - xml : String, - tag : String, -) -> (Int, Int, String) { +pub fn find_element(xml : String, tag : String) -> (Int, Int, String) { let open_opt = xml_find_open_tag(xml, tag, 0) if open_opt.is_none() { return (0, 0, "") @@ -475,10 +490,7 @@ pub fn find_element( ///| /// Find all XML elements by tag name (non-overlapping, top-level only within the search range). /// Returns array of (start_pos, end_pos) tuples. -pub fn find_all_elements( - xml : String, - tag : String, -) -> Array[(Int, Int)] { +pub fn find_all_elements(xml : String, tag : String) -> Array[(Int, Int)] { let result : Array[(Int, Int)] = Array::new() let mut search_start = 0 let n = xml.length() @@ -511,10 +523,7 @@ pub fn find_all_elements( ///| /// Get an attribute value from an element at the given position. -pub fn get_attribute( - xml : String, - attr_name : String, -) -> String { +pub fn get_attribute(xml : String, attr_name : String) -> String { let trimmed = trim(xml) if !trimmed.has_prefix("<") { return "" @@ -620,7 +629,11 @@ pub fn parse_tree_element(xml : String) -> PhyloXMLTree { let attrs_start = trimmed.find("") - if gt_opt.is_some() { Some(attrs_start.unwrap() + gt_opt.unwrap() + 1) } else { None } + if gt_opt.is_some() { + Some(attrs_start.unwrap() + gt_opt.unwrap() + 1) + } else { + None + } } else { None } @@ -663,21 +676,25 @@ pub fn parse_node_element(xml : String) -> PhyloXMLNode { ///| /// Parse taxon annotation from an XML element. pub fn parse_taxon_element(xml : String) -> TaxonInfo { - parse_taxon_info_from(if has_element(xml, "taxon") { - extract_child(xml, "taxon") - } else { - xml - }) + parse_taxon_info_from( + if has_element(xml, "taxon") { + extract_child(xml, "taxon") + } else { + xml + }, + ) } ///| /// Parse sequence annotation from an XML element. pub fn parse_sequence_element(xml : String) -> SequenceAnnotation { - parse_seq_annotation_from(if has_element(xml, "sequence") { - extract_child(xml, "sequence") - } else { - xml - }) + parse_seq_annotation_from( + if has_element(xml, "sequence") { + extract_child(xml, "sequence") + } else { + xml + }, + ) } // ============================================================================ @@ -715,7 +732,11 @@ fn parse_child_node(xml : String, tag : String) -> PhyloXMLNode { if s == 0 && e == 0 { return PhyloXMLNode::new() } - let node_xml = if content.length() > 0 { content } else { xml[s:e].to_owned() } + let node_xml = if content.length() > 0 { + content + } else { + xml[s:e].to_owned() + } parse_node_from_content(node_xml) } @@ -794,6 +815,7 @@ fn parse_node_from_content(xml : String) -> PhyloXMLNode { taxon, } } + ///| fn parse_taxon_info_from(xml : String) -> TaxonInfo { TaxonInfo::{ @@ -1063,13 +1085,21 @@ pub fn newick_to_phyloxml( let node = parse_newick_to_node(newick_text) let tree = PhyloXMLTree::{ tree_id, - name: if tree_id.length() > 0 { tree_id } else { "Newick Tree" }, + name: if tree_id.length() > 0 { + tree_id + } else { + "Newick Tree" + }, description: "Converted from Newick format", root: node, phylogeny_metadata: Map([("rooted", "true")], capacity=2), taxon_namespaces: [], } - PhyloXMLResult::{ trees: [tree], metadata: Map([], capacity=4), taxon_namespaces: [] } + PhyloXMLResult::{ + trees: [tree], + metadata: Map([], capacity=4), + taxon_namespaces: [], + } } ///| @@ -1116,12 +1146,20 @@ fn parse_newick_subtree(s : String, start : Int) -> PhyloXMLNode { let close_pos = after.find(")") let semi_pos = after.find(";") let end = find_min_pos([comma_pos, close_pos, semi_pos]) - if end.is_some() { after[0:end.unwrap()].to_owned() } else { after } + if end.is_some() { + after[0:end.unwrap()].to_owned() + } else { + after + } } let bl_str = if colon_pos.is_some() { let after_colon = after[colon_pos.unwrap() + 1:].to_owned() let end_pos = find_first_of(after_colon, [",", ")", ";"]) - if end_pos.is_some() { after_colon[0:end_pos.unwrap()].to_owned() } else { after_colon } + if end_pos.is_some() { + after_colon[0:end_pos.unwrap()].to_owned() + } else { + after_colon + } } else { "" } @@ -1312,4 +1350,4 @@ pub fn phyloxml_get_node_count(tree : PhyloXMLTree) -> Int { } } count -} \ No newline at end of file +} diff --git a/src/phyloseq.mbt b/src/phyloseq.mbt index 1f6aa458..65a34d6a 100644 --- a/src/phyloseq.mbt +++ b/src/phyloseq.mbt @@ -9,7 +9,11 @@ pub struct OTU { } ///| -pub fn OTU::new(id : String, taxonomy : Array[String], abundance : Array[Double]) -> OTU { +pub fn OTU::new( + id : String, + taxonomy : Array[String], + abundance : Array[Double], +) -> OTU { OTU::{ id, taxonomy, abundance } } @@ -36,7 +40,15 @@ pub struct TaxRank { } ///| -pub fn TaxRank::new(kingdom : String, phylum : String, class : String, order : String, family : String, genus : String, species : String) -> TaxRank { +pub fn TaxRank::new( + kingdom : String, + phylum : String, + class : String, + order : String, + family : String, + genus : String, + species : String, +) -> TaxRank { TaxRank::{ kingdom, phylum, class, order, family, genus, species } } @@ -54,7 +66,7 @@ pub fn Phyloseq::new() -> Phyloseq { otus: Array::new(), samples: Array::new(), taxonomy: Array::new(), - metadata: Map([], capacity=0) + metadata: Map([], capacity=0), } } @@ -108,21 +120,24 @@ pub fn ps_total_abundance(ps : Phyloseq) -> Double { } ///| -pub fn ps_filter_by_abundance(ps : Phyloseq, min_abundance : Double) -> Phyloseq { +pub fn ps_filter_by_abundance( + ps : Phyloseq, + min_abundance : Double, +) -> Phyloseq { let filtered = Phyloseq::new() - + let mut i = 0 while i < ps.samples.length() { filtered.samples.push(ps.samples[i]) i = i + 1 } - + let mut j = 0 while j < ps.taxonomy.length() { filtered.taxonomy.push(ps.taxonomy[j]) j = j + 1 } - + let mut k = 0 while k < ps.otus.length() { let mut total = 0.0 @@ -136,20 +151,24 @@ pub fn ps_filter_by_abundance(ps : Phyloseq, min_abundance : Double) -> Phyloseq } k = k + 1 } - + filtered } ///| -pub fn ps_filter_by_taxonomy(ps : Phyloseq, rank : String, value : String) -> Phyloseq { +pub fn ps_filter_by_taxonomy( + ps : Phyloseq, + rank : String, + value : String, +) -> Phyloseq { let filtered = Phyloseq::new() - + let mut i = 0 while i < ps.samples.length() { filtered.samples.push(ps.samples[i]) i = i + 1 } - + let mut j = 0 while j < ps.taxonomy.length() { let matched = match rank { @@ -170,14 +189,14 @@ pub fn ps_filter_by_taxonomy(ps : Phyloseq, rank : String, value : String) -> Ph } j = j + 1 } - + filtered } ///| pub fn ps_get_taxa_summary(ps : Phyloseq, rank : String) -> Map[String, Double] { let summary = Map([], capacity=0) - + let mut i = 0 while i < ps.taxonomy.length() { let tax_value = match rank { @@ -190,7 +209,7 @@ pub fn ps_get_taxa_summary(ps : Phyloseq, rank : String) -> Map[String, Double] "species" => ps.taxonomy[i].species _ => "unknown" } - + let mut abundance = 0.0 if i < ps.otus.length() { let mut j = 0 @@ -199,16 +218,16 @@ pub fn ps_get_taxa_summary(ps : Phyloseq, rank : String) -> Map[String, Double] j = j + 1 } } - + if summary.contains(tax_value) { summary.set(tax_value, summary.get(tax_value).unwrap() + abundance) } else { summary.set(tax_value, abundance) } - + i = i + 1 } - + summary } @@ -216,19 +235,19 @@ pub fn ps_get_taxa_summary(ps : Phyloseq, rank : String) -> Map[String, Double] pub fn ps_relative_abundance(ps : Phyloseq) -> Phyloseq { let total = ps_total_abundance(ps) let ra = Phyloseq::new() - + let mut i = 0 while i < ps.samples.length() { ra.samples.push(ps.samples[i]) i = i + 1 } - + let mut j = 0 while j < ps.taxonomy.length() { ra.taxonomy.push(ps.taxonomy[j]) j = j + 1 } - + let mut k = 0 while k < ps.otus.length() { let ra_abundance : Array[Double] = Array::new() @@ -241,47 +260,51 @@ pub fn ps_relative_abundance(ps : Phyloseq) -> Phyloseq { ra.otus.push(ra_otu) k = k + 1 } - + ra } ///| pub fn ps_rarefy(ps : Phyloseq, depth : Int) -> Phyloseq { let rarefied = Phyloseq::new() - + let mut i = 0 while i < ps.samples.length() { rarefied.samples.push(ps.samples[i]) i = i + 1 } - + let mut j = 0 while j < ps.taxonomy.length() { rarefied.taxonomy.push(ps.taxonomy[j]) j = j + 1 } - + let mut k = 0 while k < ps.otus.length() { let rarefied_abundance : Array[Double] = Array::new() let mut m = 0 while m < ps.otus[k].abundance.length() { let proportion = ps.otus[k].abundance[m] / ps_total_abundance(ps) - rarefied_abundance.push(proportion * (depth.to_double())) + rarefied_abundance.push(proportion * depth.to_double()) m = m + 1 } - let rarefied_otu = OTU::new(ps.otus[k].id, ps.otus[k].taxonomy, rarefied_abundance) + let rarefied_otu = OTU::new( + ps.otus[k].id, + ps.otus[k].taxonomy, + rarefied_abundance, + ) rarefied.otus.push(rarefied_otu) k = k + 1 } - + rarefied } ///| pub fn create_example_phyloseq() -> Phyloseq { let ps = Phyloseq::new() - + let otu1_tax : Array[String] = Array::new() otu1_tax.push("Bacteria") otu1_tax.push("Proteobacteria") @@ -292,7 +315,7 @@ pub fn create_example_phyloseq() -> Phyloseq { otu1_abund.push(200.0) let otu1 = OTU::new("OTU001", otu1_tax, otu1_abund) ps.otus.push(otu1) - + let otu2_tax : Array[String] = Array::new() otu2_tax.push("Bacteria") otu2_tax.push("Firmicutes") @@ -303,7 +326,7 @@ pub fn create_example_phyloseq() -> Phyloseq { otu2_abund.push(100.0) let otu2 = OTU::new("OTU002", otu2_tax, otu2_abund) ps.otus.push(otu2) - + let otu3_tax : Array[String] = Array::new() otu3_tax.push("Bacteria") otu3_tax.push("Bacteroidetes") @@ -314,30 +337,39 @@ pub fn create_example_phyloseq() -> Phyloseq { otu3_abund.push(125.0) let otu3 = OTU::new("OTU003", otu3_tax, otu3_abund) ps.otus.push(otu3) - + let sample1_meta = Map([("group", "control")], capacity=1) let sample1 = Sample::new("Sample001", sample1_meta) ps.samples.push(sample1) - + let sample2_meta = Map([("group", "treatment")], capacity=1) let sample2 = Sample::new("Sample002", sample2_meta) ps.samples.push(sample2) - + let sample3_meta = Map([("group", "treatment")], capacity=1) let sample3 = Sample::new("Sample003", sample3_meta) ps.samples.push(sample3) - - let tax1 = TaxRank::new("Bacteria", "Proteobacteria", "Gammaproteobacteria", "Enterobacteriales", "Enterobacteriaceae", "Escherichia", "coli") + + let tax1 = TaxRank::new( + "Bacteria", "Proteobacteria", "Gammaproteobacteria", "Enterobacteriales", "Enterobacteriaceae", + "Escherichia", "coli", + ) ps.taxonomy.push(tax1) - - let tax2 = TaxRank::new("Bacteria", "Firmicutes", "Clostridia", "Clostridiales", "Clostridiaceae", "Clostridium", "perfringens") + + let tax2 = TaxRank::new( + "Bacteria", "Firmicutes", "Clostridia", "Clostridiales", "Clostridiaceae", "Clostridium", + "perfringens", + ) ps.taxonomy.push(tax2) - - let tax3 = TaxRank::new("Bacteria", "Bacteroidetes", "Bacteroidia", "Bacteroidales", "Bacteroidaceae", "Bacteroides", "fragilis") + + let tax3 = TaxRank::new( + "Bacteria", "Bacteroidetes", "Bacteroidia", "Bacteroidales", "Bacteroidaceae", + "Bacteroides", "fragilis", + ) ps.taxonomy.push(tax3) - + ps.metadata.set("project", "microbiome_study") ps.metadata.set("platform", "Illumina") - + ps -} \ No newline at end of file +} diff --git a/src/pir_io.mbt b/src/pir_io.mbt index 39064d20..2a5885ae 100644 --- a/src/pir_io.mbt +++ b/src/pir_io.mbt @@ -112,12 +112,14 @@ pub fn parse_pir(content : String) -> Array[SeqRecord] { } } - records.push(SeqRecord::new( - Seq::new(seq_buf.to_string()), - id=name, - name=name, - description=description, - )) + records.push( + SeqRecord::new( + Seq::new(seq_buf.to_string()), + id=name, + name~, + description~, + ), + ) continue } diff --git a/src/plyranges.mbt b/src/plyranges.mbt index 01430ee7..444bde98 100644 --- a/src/plyranges.mbt +++ b/src/plyranges.mbt @@ -42,7 +42,11 @@ pub fn tgr_create( i = i + 1 } TidifiedGRanges::{ - seqnames, starts, ends, strands, widths, + seqnames, + starts, + ends, + strands, + widths, metadata: Map::new(), metadata_str: Map::new(), } @@ -55,12 +59,17 @@ pub fn tgr_length(tgr : TidifiedGRanges) -> Int { ///| /// Filter GRanges by sequence name. -pub fn tgr_filter_seqname(tgr : TidifiedGRanges, seqname : String) -> TidifiedGRanges { +pub fn tgr_filter_seqname( + tgr : TidifiedGRanges, + seqname : String, +) -> TidifiedGRanges { let n = tgr.seqnames.length() let keep : Array[Bool] = Array::make(n, false) let mut i = 0 while i < n { - if tgr.seqnames[i] == seqname { keep[i] = true } + if tgr.seqnames[i] == seqname { + keep[i] = true + } i = i + 1 } tgr_subset(tgr, keep) @@ -68,12 +77,17 @@ pub fn tgr_filter_seqname(tgr : TidifiedGRanges, seqname : String) -> TidifiedGR ///| /// Filter GRanges by strand. -pub fn tgr_filter_strand(tgr : TidifiedGRanges, strand : String) -> TidifiedGRanges { +pub fn tgr_filter_strand( + tgr : TidifiedGRanges, + strand : String, +) -> TidifiedGRanges { let n = tgr.seqnames.length() let keep : Array[Bool] = Array::make(n, false) let mut i = 0 while i < n { - if tgr.strands[i] == strand { keep[i] = true } + if tgr.strands[i] == strand { + keep[i] = true + } i = i + 1 } tgr_subset(tgr, keep) @@ -91,7 +105,9 @@ pub fn tgr_filter_width( let mut i = 0 while i < n { let w = tgr.widths[i] - if w >= min_width && w <= max_width { keep[i] = true } + if w >= min_width && w <= max_width { + keep[i] = true + } i = i + 1 } tgr_subset(tgr, keep) @@ -99,12 +115,17 @@ pub fn tgr_filter_width( ///| /// Filter GRanges by start position >= min_start. -pub fn tgr_filter_start(tgr : TidifiedGRanges, min_start : Int) -> TidifiedGRanges { +pub fn tgr_filter_start( + tgr : TidifiedGRanges, + min_start : Int, +) -> TidifiedGRanges { let n = tgr.seqnames.length() let keep : Array[Bool] = Array::make(n, false) let mut i = 0 while i < n { - if tgr.starts[i] >= min_start { keep[i] = true } + if tgr.starts[i] >= min_start { + keep[i] = true + } i = i + 1 } tgr_subset(tgr, keep) @@ -117,7 +138,9 @@ pub fn tgr_filter_end(tgr : TidifiedGRanges, max_end : Int) -> TidifiedGRanges { let keep : Array[Bool] = Array::make(n, false) let mut i = 0 while i < n { - if tgr.ends[i] <= max_end { keep[i] = true } + if tgr.ends[i] <= max_end { + keep[i] = true + } i = i + 1 } tgr_subset(tgr, keep) @@ -132,13 +155,17 @@ pub fn tgr_filter_metadata( max_val : Double, ) -> TidifiedGRanges { let data = tgr.metadata[col] - if data.length() == 0 { return tgr } + if data.length() == 0 { + return tgr + } let n = tgr.seqnames.length() let keep : Array[Bool] = Array::make(n, false) let mut i = 0 while i < n { let v = data[i] - if v >= min_val && v <= max_val { keep[i] = true } + if v >= min_val && v <= max_val { + keep[i] = true + } i = i + 1 } tgr_subset(tgr, keep) @@ -152,12 +179,16 @@ pub fn tgr_filter_metadata_str( value : String, ) -> TidifiedGRanges { let data = tgr.metadata_str[col] - if data.length() == 0 { return tgr } + if data.length() == 0 { + return tgr + } let n = tgr.seqnames.length() let keep : Array[Bool] = Array::make(n, false) let mut i = 0 while i < n { - if data[i] == value { keep[i] = true } + if data[i] == value { + keep[i] = true + } i = i + 1 } tgr_subset(tgr, keep) @@ -189,7 +220,9 @@ pub fn tgr_subset(tgr : TidifiedGRanges, keep : Array[Bool]) -> TidifiedGRanges let nv : Array[Double] = Array::new() let mut j = 0 while j < n { - if keep[j] { nv.push(old[j]) } + if keep[j] { + nv.push(old[j]) + } j = j + 1 } new_metadata[key] = nv @@ -199,7 +232,9 @@ pub fn tgr_subset(tgr : TidifiedGRanges, keep : Array[Bool]) -> TidifiedGRanges let nv : Array[String] = Array::new() let mut j = 0 while j < n { - if keep[j] { nv.push(old[j]) } + if keep[j] { + nv.push(old[j]) + } j = j + 1 } new_metadata_str[key] = nv @@ -217,7 +252,11 @@ pub fn tgr_subset(tgr : TidifiedGRanges, keep : Array[Bool]) -> TidifiedGRanges ///| /// Add a numeric metadata column. -pub fn tgr_mutate(tgr : TidifiedGRanges, name : String, values : Array[Double]) -> TidifiedGRanges { +pub fn tgr_mutate( + tgr : TidifiedGRanges, + name : String, + values : Array[Double], +) -> TidifiedGRanges { let new_meta = Map::new() for key in tgr.metadata.keys() { new_meta[key] = tgr.metadata[key] @@ -236,7 +275,11 @@ pub fn tgr_mutate(tgr : TidifiedGRanges, name : String, values : Array[Double]) ///| /// Add a string metadata column. -pub fn tgr_mutate_str(tgr : TidifiedGRanges, name : String, values : Array[String]) -> TidifiedGRanges { +pub fn tgr_mutate_str( + tgr : TidifiedGRanges, + name : String, + values : Array[String], +) -> TidifiedGRanges { let new_meta = Map::new() for key in tgr.metadata_str.keys() { new_meta[key] = tgr.metadata_str[key] @@ -259,7 +302,10 @@ pub fn tgr_arrange(tgr : TidifiedGRanges) -> TidifiedGRanges { let n = tgr.seqnames.length() let indices : Array[Int] = Array::make(n, 0) let mut i = 0 - while i < n { indices[i] = i; i = i + 1 } + while i < n { + indices[i] = i + i = i + 1 + } // Sort indices by seqname then start let mut ii = 0 while ii < n - 1 { @@ -280,23 +326,36 @@ pub fn tgr_arrange(tgr : TidifiedGRanges) -> TidifiedGRanges { tgr_reorder(tgr, indices) } +///| fn tgr_should_swap(tgr : TidifiedGRanges, ai : Int, aj : Int) -> Bool { let si = tgr.seqnames[ai] let sj = tgr.seqnames[aj] - if si > sj { return true } - if si < sj { return false } + if si > sj { + return true + } + if si < sj { + return false + } return tgr.starts[ai] > tgr.starts[aj] } ///| /// Arrange by a numeric metadata column. -pub fn tgr_arrange_by_metadata(tgr : TidifiedGRanges, col : String) -> TidifiedGRanges { +pub fn tgr_arrange_by_metadata( + tgr : TidifiedGRanges, + col : String, +) -> TidifiedGRanges { let data = tgr.metadata[col] - if data.length() == 0 { return tgr } + if data.length() == 0 { + return tgr + } let n = tgr.seqnames.length() let indices : Array[Int] = Array::make(n, 0) let mut i = 0 - while i < n { indices[i] = i; i = i + 1 } + while i < n { + indices[i] = i + i = i + 1 + } let mut ii = 0 while ii < n - 1 { let mut jj = ii + 1 @@ -315,6 +374,7 @@ pub fn tgr_arrange_by_metadata(tgr : TidifiedGRanges, col : String) -> TidifiedG tgr_reorder(tgr, indices) } +///| fn tgr_reorder(tgr : TidifiedGRanges, indices : Array[Int]) -> TidifiedGRanges { let n = indices.length() let new_seqnames : Array[String] = Array::make(n, "") @@ -337,14 +397,20 @@ fn tgr_reorder(tgr : TidifiedGRanges, indices : Array[Int]) -> TidifiedGRanges { let old = tgr.metadata[key] let nv : Array[Double] = Array::make(n, 0.0) let mut j = 0 - while j < n { nv[j] = old[indices[j]]; j = j + 1 } + while j < n { + nv[j] = old[indices[j]] + j = j + 1 + } new_metadata[key] = nv } for key in tgr.metadata_str.keys() { let old = tgr.metadata_str[key] let nv : Array[String] = Array::make(n, "") let mut j = 0 - while j < n { nv[j] = old[indices[j]]; j = j + 1 } + while j < n { + nv[j] = old[indices[j]] + j = j + 1 + } new_metadata_str[key] = nv } TidifiedGRanges::{ @@ -360,16 +426,26 @@ fn tgr_reorder(tgr : TidifiedGRanges, indices : Array[Int]) -> TidifiedGRanges { ///| /// Rename a metadata column. -pub fn tgr_rename(tgr : TidifiedGRanges, old_name : String, new_name : String) -> TidifiedGRanges { +pub fn tgr_rename( + tgr : TidifiedGRanges, + old_name : String, + new_name : String, +) -> TidifiedGRanges { let new_meta = Map::new() for key in tgr.metadata.keys() { - if key == old_name { new_meta[new_name] = tgr.metadata[key] } - else { new_meta[key] = tgr.metadata[key] } + if key == old_name { + new_meta[new_name] = tgr.metadata[key] + } else { + new_meta[key] = tgr.metadata[key] + } } let new_meta_str = Map::new() for key in tgr.metadata_str.keys() { - if key == old_name { new_meta_str[new_name] = tgr.metadata_str[key] } - else { new_meta_str[key] = tgr.metadata_str[key] } + if key == old_name { + new_meta_str[new_name] = tgr.metadata_str[key] + } else { + new_meta_str[key] = tgr.metadata_str[key] + } } TidifiedGRanges::{ seqnames: tgr.seqnames.copy(), @@ -384,12 +460,19 @@ pub fn tgr_rename(tgr : TidifiedGRanges, old_name : String, new_name : String) - ///| /// Select only specific metadata columns (keep structural columns). -pub fn tgr_select(tgr : TidifiedGRanges, columns : Array[String]) -> TidifiedGRanges { +pub fn tgr_select( + tgr : TidifiedGRanges, + columns : Array[String], +) -> TidifiedGRanges { let new_meta = Map::new() let new_meta_str = Map::new() for col in columns { - if tgr.metadata.contains(col) { new_meta[col] = tgr.metadata[col] } - if tgr.metadata_str.contains(col) { new_meta_str[col] = tgr.metadata_str[col] } + if tgr.metadata.contains(col) { + new_meta[col] = tgr.metadata[col] + } + if tgr.metadata_str.contains(col) { + new_meta_str[col] = tgr.metadata_str[col] + } } TidifiedGRanges::{ seqnames: tgr.seqnames.copy(), @@ -420,14 +503,18 @@ pub fn tgr_summarise( value_cols : Array[String], ) -> Array[GroupSummary] { let data = tgr.metadata_str[group_col] - if data.length() == 0 { return [] } + if data.length() == 0 { + return [] + } let groups = tgr_get_unique_strings(data) let result : Array[GroupSummary] = Array::new() for g in groups { let mut count = 0 let mut i = 0 while i < data.length() { - if data[i] == g { count = count + 1 } + if data[i] == g { + count = count + 1 + } i = i + 1 } let mean_vals = Map::new() @@ -446,8 +533,12 @@ pub fn tgr_summarise( if data[j] == g { let v = col_data[j] s = s + v - if first || v < mn { mn = v } - if first || v > mx { mx = v } + if first || v < mn { + mn = v + } + if first || v > mx { + mx = v + } } j = j + 1 } @@ -469,6 +560,7 @@ pub fn tgr_summarise( result } +///| fn tgr_get_unique_strings(arr : Array[String]) -> Array[String] { let seen = Map::new() let result : Array[String] = Array::new() @@ -490,7 +582,9 @@ pub fn tgr_group_mean( ) -> Array[(String, Double)] { let data = tgr.metadata_str[group_col] let vals = tgr.metadata[value_col] - if data.length() == 0 || vals.length() == 0 { return [] } + if data.length() == 0 || vals.length() == 0 { + return [] + } let groups = tgr_get_unique_strings(data) let result : Array[(String, Double)] = Array::new() for g in groups { @@ -498,7 +592,10 @@ pub fn tgr_group_mean( let mut c = 0 let mut i = 0 while i < data.length() { - if data[i] == g { s = s + vals[i]; c = c + 1 } + if data[i] == g { + s = s + vals[i] + c = c + 1 + } i = i + 1 } result.push((g, s / c.to_double())) @@ -515,14 +612,18 @@ pub fn tgr_group_sum( ) -> Array[(String, Double)] { let data = tgr.metadata_str[group_col] let vals = tgr.metadata[value_col] - if data.length() == 0 || vals.length() == 0 { return [] } + if data.length() == 0 || vals.length() == 0 { + return [] + } let groups = tgr_get_unique_strings(data) let result : Array[(String, Double)] = Array::new() for g in groups { let mut s = 0.0 let mut i = 0 while i < data.length() { - if data[i] == g { s = s + vals[i] } + if data[i] == g { + s = s + vals[i] + } i = i + 1 } result.push((g, s)) @@ -595,8 +696,11 @@ pub fn tgr_left_join( let nv : Array[Double] = Array::make(n_left, 0.0) let mut i = 0 while i < n_left { - if matched_right.contains(i) { nv[i] = old[matched_right[i]] } - else { nv[i] = 0.0 } + if matched_right.contains(i) { + nv[i] = old[matched_right[i]] + } else { + nv[i] = 0.0 + } i = i + 1 } new_meta[key] = nv @@ -607,22 +711,33 @@ pub fn tgr_left_join( let nv : Array[String] = Array::make(n_left, "") let mut i = 0 while i < n_left { - if matched_right.contains(i) { nv[i] = old[matched_right[i]] } - else { nv[i] = "" } + if matched_right.contains(i) { + nv[i] = old[matched_right[i]] + } else { + nv[i] = "" + } i = i + 1 } new_meta_str[key] = nv } // Merge with left metadata let merged_meta = Map::new() - for key in left.metadata.keys() { merged_meta[key] = left.metadata[key] } + for key in left.metadata.keys() { + merged_meta[key] = left.metadata[key] + } for key in new_meta.keys() { - if !merged_meta.contains(key) { merged_meta[key] = new_meta[key] } + if !merged_meta.contains(key) { + merged_meta[key] = new_meta[key] + } } let merged_meta_str = Map::new() - for key in left.metadata_str.keys() { merged_meta_str[key] = left.metadata_str[key] } + for key in left.metadata_str.keys() { + merged_meta_str[key] = left.metadata_str[key] + } for key in new_meta_str.keys() { - if !merged_meta_str.contains(key) { merged_meta_str[key] = new_meta_str[key] } + if !merged_meta_str.contains(key) { + merged_meta_str[key] = new_meta_str[key] + } } TidifiedGRanges::{ seqnames: left.seqnames.copy(), @@ -656,7 +771,9 @@ pub fn tgr_stretch(tgr : TidifiedGRanges, amount : Int) -> TidifiedGRanges { while i < n { new_starts[i] = tgr.starts[i] - amount new_ends[i] = tgr.ends[i] + amount - if new_starts[i] < 1 { new_starts[i] = 1 } + if new_starts[i] < 1 { + new_starts[i] = 1 + } new_widths[i] = new_ends[i] - new_starts[i] + 1 i = i + 1 } @@ -683,7 +800,9 @@ pub fn tgr_resize_fixed(tgr : TidifiedGRanges, width : Int) -> TidifiedGRanges { let center = (tgr.starts[i] + tgr.ends[i]) / 2 new_starts[i] = center - width / 2 new_ends[i] = new_starts[i] + width - 1 - if new_starts[i] < 1 { new_starts[i] = 1 } + if new_starts[i] < 1 { + new_starts[i] = 1 + } new_widths[i] = new_ends[i] - new_starts[i] + 1 i = i + 1 } @@ -723,7 +842,11 @@ pub fn tgr_shift(tgr : TidifiedGRanges, amount : Int) -> TidifiedGRanges { ///| /// Flank: create flanking regions around each range. -pub fn tgr_flank(tgr : TidifiedGRanges, upstream : Int, downstream : Int) -> TidifiedGRanges { +pub fn tgr_flank( + tgr : TidifiedGRanges, + upstream : Int, + downstream : Int, +) -> TidifiedGRanges { let n = tgr.seqnames.length() let new_seqnames : Array[String] = Array::new() let new_starts : Array[Int] = Array::new() @@ -735,13 +858,17 @@ pub fn tgr_flank(tgr : TidifiedGRanges, upstream : Int, downstream : Int) -> Tid // Upstream flank new_seqnames.push(tgr.seqnames[i]) new_starts.push(tgr.starts[i] - upstream) - if new_starts[new_starts.length() - 1] < 1 { new_starts[new_starts.length() - 1] = 1 } + if new_starts[new_starts.length() - 1] < 1 { + new_starts[new_starts.length() - 1] = 1 + } new_ends.push(tgr.starts[i] - 1) if new_ends[new_ends.length() - 1] < new_starts[new_starts.length() - 1] { new_ends[new_ends.length() - 1] = new_starts[new_starts.length() - 1] } new_strands.push(tgr.strands[i]) - new_widths.push(new_ends[new_ends.length() - 1] - new_starts[new_starts.length() - 1] + 1) + new_widths.push( + new_ends[new_ends.length() - 1] - new_starts[new_starts.length() - 1] + 1, + ) // Downstream flank new_seqnames.push(tgr.seqnames[i]) new_starts.push(tgr.ends[i] + 1) @@ -796,12 +923,19 @@ pub fn tgr_compute_gc( let mut j = s while j <= e { let c = seq[j - 1:j].to_owned().to_upper() - if c == "G" || c == "C" { gc = gc + 1 } - else if c == "A" || c == "T" { at = at + 1 } + if c == "G" || c == "C" { + gc = gc + 1 + } else if c == "A" || c == "T" { + at = at + 1 + } j = j + 1 } let total = gc + at - result[i] = if total > 0 { gc.to_double() / total.to_double() } else { 0.0 } + result[i] = if total > 0 { + gc.to_double() / total.to_double() + } else { + 0.0 + } } i = i + 1 } @@ -815,7 +949,9 @@ pub fn tgr_intervene( set_names : Array[String], ) -> Array[(String, Int)] { let n = sets.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let result : Array[(String, Int)] = Array::new() // Compute pairwise overlaps let mut i = 0 @@ -829,7 +965,9 @@ pub fn tgr_intervene( } j = j + 1 } - if unique_count < 0 { unique_count = 0 } + if unique_count < 0 { + unique_count = 0 + } result.push((set_names[i], unique_count)) i = i + 1 } @@ -867,8 +1005,13 @@ pub fn tgr_summary(tgr : TidifiedGRanges) -> TgrSummary { let n = tgr.seqnames.length() if n == 0 { return TgrSummary::{ - n_ranges: 0, n_seqnames: 0, n_strands: 0, - total_bases: 0, mean_width: 0.0, min_width: 0, max_width: 0, + n_ranges: 0, + n_seqnames: 0, + n_strands: 0, + total_bases: 0, + mean_width: 0.0, + min_width: 0, + max_width: 0, } } let seqlevels = tgr_seqlevels(tgr) @@ -879,8 +1022,12 @@ pub fn tgr_summary(tgr : TidifiedGRanges) -> TgrSummary { let mut i = 0 while i < n { total = total + tgr.widths[i] - if tgr.widths[i] < mn { mn = tgr.widths[i] } - if tgr.widths[i] > mx { mx = tgr.widths[i] } + if tgr.widths[i] < mn { + mn = tgr.widths[i] + } + if tgr.widths[i] > mx { + mx = tgr.widths[i] + } i = i + 1 } TgrSummary::{ @@ -922,7 +1069,11 @@ pub fn tgr_coverage( } j = j + 1 } - result[i] = if qlen > 0 { covered.to_double() / qlen.to_double() } else { 0.0 } + result[i] = if qlen > 0 { + covered.to_double() / qlen.to_double() + } else { + 0.0 + } i = i + 1 } result @@ -930,7 +1081,10 @@ pub fn tgr_coverage( ///| /// Set operations: intersect two TidifiedGRanges. -pub fn tgr_intersect(a : TidifiedGRanges, b : TidifiedGRanges) -> TidifiedGRanges { +pub fn tgr_intersect( + a : TidifiedGRanges, + b : TidifiedGRanges, +) -> TidifiedGRanges { let overlaps = tgr_join_overlap(a, b) let result_seqnames : Array[String] = Array::new() let result_starts : Array[Int] = Array::new() @@ -940,7 +1094,11 @@ pub fn tgr_intersect(a : TidifiedGRanges, b : TidifiedGRanges) -> TidifiedGRange for pair in overlaps { let i = pair.0 let j = pair.1 - let ov_start = if a.starts[i] > b.starts[j] { a.starts[i] } else { b.starts[j] } + let ov_start = if a.starts[i] > b.starts[j] { + a.starts[i] + } else { + b.starts[j] + } let ov_end = if a.ends[i] < b.ends[j] { a.ends[i] } else { b.ends[j] } if ov_start <= ov_end { result_seqnames.push(a.seqnames[i]) @@ -966,7 +1124,9 @@ pub fn tgr_intersect(a : TidifiedGRanges, b : TidifiedGRanges) -> TidifiedGRange pub fn tgr_union(a : TidifiedGRanges, b : TidifiedGRanges) -> TidifiedGRanges { let overlaps = tgr_join_overlap(a, b) let b_overlapping = Map::new() - for pair in overlaps { b_overlapping[pair.1] = true } + for pair in overlaps { + b_overlapping[pair.1] = true + } let result_seqnames : Array[String] = Array::new() let result_starts : Array[Int] = Array::new() let result_ends : Array[Int] = Array::new() @@ -1024,10 +1184,16 @@ pub fn tgr_distance_to_nearest( if subject.seqnames[j] == qseq { let rstart = subject.starts[j] let rend = subject.ends[j] - let dist = if qend < rstart { rstart - qend } - else if qstart > rend { qstart - rend } - else { 0 } - if dist < min_dist { min_dist = dist } + let dist = if qend < rstart { + rstart - qend + } else if qstart > rend { + qstart - rend + } else { + 0 + } + if dist < min_dist { + min_dist = dist + } } j = j + 1 } diff --git a/src/polypeptide.mbt b/src/polypeptide.mbt index 02bf318b..e5101cac 100644 --- a/src/polypeptide.mbt +++ b/src/polypeptide.mbt @@ -9,7 +9,10 @@ pub struct PolypeptideComposition { } ///| -pub fn PolypeptideComposition::new(amino_acids : Map[String, Int], total_residues : Int) -> PolypeptideComposition { +pub fn PolypeptideComposition::new( + amino_acids : Map[String, Int], + total_residues : Int, +) -> PolypeptideComposition { PolypeptideComposition::{ amino_acids, total_residues } } @@ -20,7 +23,10 @@ pub struct HydrophobicityProfile { } ///| -pub fn HydrophobicityProfile::new(positions : Array[Int], values : Array[Double]) -> HydrophobicityProfile { +pub fn HydrophobicityProfile::new( + positions : Array[Int], + values : Array[Double], +) -> HydrophobicityProfile { HydrophobicityProfile::{ positions, values } } @@ -32,21 +38,44 @@ pub struct TransmembraneRegion { } ///| -pub fn TransmembraneRegion::new(start : Int, end : Int, score : Double) -> TransmembraneRegion { +pub fn TransmembraneRegion::new( + start : Int, + end : Int, + score : Double, +) -> TransmembraneRegion { TransmembraneRegion::{ start, end, score } } ///| pub fn calculate_composition(sequence : String) -> PolypeptideComposition { - let amino_acids : Map[String, Int] = Map([ - ("A", 0), ("R", 0), ("N", 0), ("D", 0), ("C", 0), - ("Q", 0), ("E", 0), ("G", 0), ("H", 0), ("I", 0), - ("L", 0), ("K", 0), ("M", 0), ("F", 0), ("P", 0), - ("S", 0), ("T", 0), ("W", 0), ("Y", 0), ("V", 0), - ], capacity=20) - + let amino_acids : Map[String, Int] = Map( + [ + ("A", 0), + ("R", 0), + ("N", 0), + ("D", 0), + ("C", 0), + ("Q", 0), + ("E", 0), + ("G", 0), + ("H", 0), + ("I", 0), + ("L", 0), + ("K", 0), + ("M", 0), + ("F", 0), + ("P", 0), + ("S", 0), + ("T", 0), + ("W", 0), + ("Y", 0), + ("V", 0), + ], + capacity=20, + ) + let mut total_residues = 0 - + let mut i = 0 while i < sequence.length() { let aa = char_at(sequence, i) @@ -55,37 +84,47 @@ pub fn calculate_composition(sequence : String) -> PolypeptideComposition { total_residues = total_residues + 1 i = i + 1 } - + PolypeptideComposition::new(amino_acids, total_residues) } ///| -pub fn calculate_percent_composition(composition : PolypeptideComposition) -> Map[String, Double] { +pub fn calculate_percent_composition( + composition : PolypeptideComposition, +) -> Map[String, Double] { let percent : Map[String, Double] = Map([], capacity=20) - + if composition.total_residues == 0 { return percent } - - let amino_acids = ["A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F", "P", "S", "T", "W", "Y", "V"] - + + let amino_acids = [ + "A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F", "P", "S", + "T", "W", "Y", "V", + ] + let mut i = 0 while i < amino_acids.length() { let aa = amino_acids[i] let count = composition.amino_acids.get(aa).unwrap_or(0) - let percentage = count.to_double() / composition.total_residues.to_double() * 100.0 + let percentage = count.to_double() / + composition.total_residues.to_double() * + 100.0 percent.set(aa, percentage) i = i + 1 } - + percent } ///| -pub fn calculate_hydrophobicity(sequence : String, scale : String) -> HydrophobicityProfile { +pub fn calculate_hydrophobicity( + sequence : String, + scale : String, +) -> HydrophobicityProfile { let positions : Array[Int] = Array::new() let values : Array[Double] = Array::new() - + let hydrophobicity_map = if scale == "kyte-doolittle" { kyte_doolittle_scale() } else if scale == "hopp-woods" { @@ -93,39 +132,77 @@ pub fn calculate_hydrophobicity(sequence : String, scale : String) -> Hydrophobi } else { kyte_doolittle_scale() } - + let mut i = 0 while i < sequence.length() { let aa = char_at(sequence, i) let score = hydrophobicity_map.get(aa).unwrap_or(0.0) - + positions.push(i + 1) values.push(score) - + i = i + 1 } - + HydrophobicityProfile::new(positions, values) } ///| fn kyte_doolittle_scale() -> Map[String, Double] { - Map([ - ("A", 1.8), ("R", -4.5), ("N", -3.5), ("D", -3.5), ("C", 2.5), - ("Q", -3.5), ("E", -3.5), ("G", -0.4), ("H", -3.2), ("I", 4.5), - ("L", 3.8), ("K", -3.9), ("M", 1.9), ("F", 2.8), ("P", -1.6), - ("S", -0.8), ("T", -0.7), ("W", -0.9), ("Y", -1.3), ("V", 4.2), - ], capacity=20) + Map( + [ + ("A", 1.8), + ("R", -4.5), + ("N", -3.5), + ("D", -3.5), + ("C", 2.5), + ("Q", -3.5), + ("E", -3.5), + ("G", -0.4), + ("H", -3.2), + ("I", 4.5), + ("L", 3.8), + ("K", -3.9), + ("M", 1.9), + ("F", 2.8), + ("P", -1.6), + ("S", -0.8), + ("T", -0.7), + ("W", -0.9), + ("Y", -1.3), + ("V", 4.2), + ], + capacity=20, + ) } ///| fn hopp_woods_scale() -> Map[String, Double] { - Map([ - ("A", -0.5), ("R", 3.0), ("N", 0.2), ("D", 3.0), ("C", -1.0), - ("Q", 0.2), ("E", 3.0), ("G", 0.0), ("H", -0.5), ("I", -1.8), - ("L", -1.8), ("K", 3.0), ("M", -1.3), ("F", -2.5), ("P", 0.0), - ("S", 0.3), ("T", -0.4), ("W", -3.4), ("Y", -2.3), ("V", -1.5), - ], capacity=20) + Map( + [ + ("A", -0.5), + ("R", 3.0), + ("N", 0.2), + ("D", 3.0), + ("C", -1.0), + ("Q", 0.2), + ("E", 3.0), + ("G", 0.0), + ("H", -0.5), + ("I", -1.8), + ("L", -1.8), + ("K", 3.0), + ("M", -1.3), + ("F", -2.5), + ("P", 0.0), + ("S", 0.3), + ("T", -0.4), + ("W", -3.4), + ("Y", -2.3), + ("V", -1.5), + ], + capacity=20, + ) } ///| @@ -136,7 +213,7 @@ pub fn calculate_hydrophobicity_window( ) -> HydrophobicityProfile { let positions : Array[Int] = Array::new() let values : Array[Double] = Array::new() - + let hydrophobicity_map = if scale == "kyte-doolittle" { kyte_doolittle_scale() } else if scale == "hopp-woods" { @@ -144,17 +221,21 @@ pub fn calculate_hydrophobicity_window( } else { kyte_doolittle_scale() } - + let half_window = window_size / 2 - + let mut i = 0 while i < sequence.length() { let mut sum = 0.0 let mut count = 0 - + let start = if i < half_window { 0 } else { i - half_window } - let end = if i + half_window >= sequence.length() { sequence.length() } else { i + half_window + 1 } - + let end = if i + half_window >= sequence.length() { + sequence.length() + } else { + i + half_window + 1 + } + let mut j = start while j < end { let aa = char_at(sequence, j) @@ -162,15 +243,15 @@ pub fn calculate_hydrophobicity_window( count = count + 1 j = j + 1 } - + let avg = sum / count.to_double() - + positions.push(i + 1) values.push(avg) - + i = i + 1 } - + HydrophobicityProfile::new(positions, values) } @@ -181,17 +262,19 @@ pub fn predict_transmembrane_regions( threshold : Double, ) -> Array[TransmembraneRegion] { let regions : Array[TransmembraneRegion] = Array::new() - - let profile = calculate_hydrophobicity_window(sequence, window_size, "kyte-doolittle") - + + let profile = calculate_hydrophobicity_window( + sequence, window_size, "kyte-doolittle", + ) + let mut in_region = false let mut region_start = 0 let mut region_scores : Array[Double] = Array::new() - + let mut i = 0 while i < profile.values.length() { let score = profile.values[i] - + if score >= threshold && !in_region { in_region = true region_start = profile.positions[i] @@ -201,7 +284,7 @@ pub fn predict_transmembrane_regions( region_scores.push(score) } else if score < threshold && in_region { in_region = false - + if region_scores.length() >= 5 { let mut avg_score = 0.0 let mut j = 0 @@ -210,14 +293,20 @@ pub fn predict_transmembrane_regions( j = j + 1 } avg_score = avg_score / region_scores.length().to_double() - - regions.push(TransmembraneRegion::new(region_start, profile.positions[i - 1], avg_score)) + + regions.push( + TransmembraneRegion::new( + region_start, + profile.positions[i - 1], + avg_score, + ), + ) } } - + i = i + 1 } - + if in_region && region_scores.length() >= 5 { let mut avg_score = 0.0 let mut j = 0 @@ -226,10 +315,16 @@ pub fn predict_transmembrane_regions( j = j + 1 } avg_score = avg_score / region_scores.length().to_double() - - regions.push(TransmembraneRegion::new(region_start, profile.positions[profile.positions.length() - 1], avg_score)) + + regions.push( + TransmembraneRegion::new( + region_start, + profile.positions[profile.positions.length() - 1], + avg_score, + ), + ) } - + regions } @@ -238,87 +333,112 @@ pub fn calculate_isoelectric_point(sequence : String) -> Double { let mut low = 0.0 let mut high = 14.0 let mut mid = 7.0 - + let mut i = 0 while i < 50 { mid = (low + high) / 2.0 let charge = calculate_charge(sequence, mid) - + if charge > 0.0 { low = mid } else { high = mid } - + i = i + 1 } - + mid } ///| fn calculate_charge(sequence : String, ph : Double) -> Double { let mut charge = 0.0 - + let mut i = 0 while i < sequence.length() { let aa = char_at(sequence, i) charge = charge + amino_acid_charge(aa, ph) i = i + 1 } - + charge } ///| fn amino_acid_charge(amino_acid : String, ph : Double) -> Double { - let pka_values = Map([ - ("A", (2.34, 9.69, 0.0)), ("R", (2.17, 9.04, 12.48)), ("N", (2.02, 8.80, 0.0)), - ("D", (1.88, 9.60, 3.65)), ("C", (1.96, 10.28, 8.18)), ("Q", (2.17, 9.13, 0.0)), - ("E", (2.19, 9.67, 4.25)), ("G", (2.34, 9.60, 0.0)), ("H", (1.82, 9.17, 6.00)), - ("I", (2.36, 9.60, 0.0)), ("L", (2.36, 9.60, 0.0)), ("K", (2.18, 8.95, 10.53)), - ("M", (2.28, 9.21, 0.0)), ("F", (1.83, 9.13, 0.0)), ("P", (1.99, 10.60, 0.0)), - ("S", (2.21, 9.15, 0.0)), ("T", (2.11, 9.62, 0.0)), ("W", (2.83, 9.39, 0.0)), - ("Y", (2.32, 9.62, 10.07)), ("V", (2.32, 9.62, 0.0)), - ], capacity=20) - + let pka_values = Map( + [ + ("A", (2.34, 9.69, 0.0)), + ("R", (2.17, 9.04, 12.48)), + ("N", (2.02, 8.80, 0.0)), + ("D", (1.88, 9.60, 3.65)), + ("C", (1.96, 10.28, 8.18)), + ("Q", (2.17, 9.13, 0.0)), + ("E", (2.19, 9.67, 4.25)), + ("G", (2.34, 9.60, 0.0)), + ("H", (1.82, 9.17, 6.00)), + ("I", (2.36, 9.60, 0.0)), + ("L", (2.36, 9.60, 0.0)), + ("K", (2.18, 8.95, 10.53)), + ("M", (2.28, 9.21, 0.0)), + ("F", (1.83, 9.13, 0.0)), + ("P", (1.99, 10.60, 0.0)), + ("S", (2.21, 9.15, 0.0)), + ("T", (2.11, 9.62, 0.0)), + ("W", (2.83, 9.39, 0.0)), + ("Y", (2.32, 9.62, 10.07)), + ("V", (2.32, 9.62, 0.0)), + ], + capacity=20, + ) + let pka_tuple = pka_values.get(amino_acid).unwrap_or((2.0, 9.0, 0.0)) let (pka_n, pka_c, pka_side) = pka_tuple - + let mut charge = 0.0 - - charge = charge + @math.pow(10.0, pka_n) / (@math.pow(10.0, pka_n) + @math.pow(10.0, ph)) - charge = charge - @math.pow(10.0, ph) / (@math.pow(10.0, pka_c) + @math.pow(10.0, ph)) - + + charge = charge + + @math.pow(10.0, pka_n) / (@math.pow(10.0, pka_n) + @math.pow(10.0, ph)) + charge = charge - + @math.pow(10.0, ph) / (@math.pow(10.0, pka_c) + @math.pow(10.0, ph)) + if pka_side > 0.0 { if amino_acid == "D" || amino_acid == "E" { - charge = charge - @math.pow(10.0, ph) / (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) + charge = charge - + @math.pow(10.0, ph) / (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) } else if amino_acid == "R" || amino_acid == "K" { - charge = charge + @math.pow(10.0, pka_side) / (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) + charge = charge + + @math.pow(10.0, pka_side) / + (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) } else if amino_acid == "H" { - charge = charge + @math.pow(10.0, pka_side) / (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) + charge = charge + + @math.pow(10.0, pka_side) / + (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) } else if amino_acid == "C" { - charge = charge - @math.pow(10.0, ph) / (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) + charge = charge - + @math.pow(10.0, ph) / (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) } else if amino_acid == "Y" { - charge = charge - @math.pow(10.0, ph) / (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) + charge = charge - + @math.pow(10.0, ph) / (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) } } - + charge } ///| pub fn calculate_aromaticity(sequence : String) -> Double { let aromatic = ["F", "Y", "W"] - + let mut count = 0 let mut total = 0 - + let mut i = 0 while i < sequence.length() { let aa = char_at(sequence, i) total = total + 1 - + let mut j = 0 while j < aromatic.length() { if aromatic[j] == aa { @@ -327,19 +447,27 @@ pub fn calculate_aromaticity(sequence : String) -> Double { } j = j + 1 } - + i = i + 1 } - - if total == 0 { 0.0 } else { count.to_double() / total.to_double() } + + if total == 0 { + 0.0 + } else { + count.to_double() / total.to_double() + } } ///| -pub fn create_example_polypeptide_data() -> (String, PolypeptideComposition, HydrophobicityProfile) { - let sequence = "MSGLVLLLFLLVSLTGVASSTPGGGEETLAALGRALEEELARHPYFYAPELLYYANKYNGVFQEAAELRKTVVLDVTSEQLRRLDTHLETYGKHEEHAQEAGERGPLRESLRALYNVPQLIESKGGVVPRRYKPVNDSGFFYVEELKDIKEKVAADDDDMVLKAVREAAKEGADFTMVTEIIEELKARLEKFNGEEDKARLAKDALKESDDWPLVKVLKNKDDYVHGFEEA"; - +pub fn create_example_polypeptide_data() -> ( + String, + PolypeptideComposition, + HydrophobicityProfile, +) { + let sequence = "MSGLVLLLFLLVSLTGVASSTPGGGEETLAALGRALEEELARHPYFYAPELLYYANKYNGVFQEAAELRKTVVLDVTSEQLRRLDTHLETYGKHEEHAQEAGERGPLRESLRALYNVPQLIESKGGVVPRRYKPVNDSGFFYVEELKDIKEKVAADDDDMVLKAVREAAKEGADFTMVTEIIEELKARLEKFNGEEDKARLAKDALKESDDWPLVKVLKNKDDYVHGFEEA" + let composition = calculate_composition(sequence) let profile = calculate_hydrophobicity(sequence, "kyte-doolittle") - + (sequence, composition, profile) -} \ No newline at end of file +} diff --git a/src/popgen_advanced.mbt b/src/popgen_advanced.mbt index c1b75e40..8c7e0621 100644 --- a/src/popgen_advanced.mbt +++ b/src/popgen_advanced.mbt @@ -48,7 +48,10 @@ pub struct NeutralityTestConfig { ///| /// Default neutrality test configuration. -pub fn NeutralityTestConfig::default(sample_size : Int, sequence_length : Int) -> NeutralityTestConfig { +pub fn NeutralityTestConfig::default( + sample_size : Int, + sequence_length : Int, +) -> NeutralityTestConfig { NeutralityTestConfig::{ sample_size, sequence_length, @@ -145,13 +148,21 @@ pub fn new_polymorphic_site( ///| /// Create a singleton site. -pub fn new_singleton(position : Int, sample_size : Int, is_replacement : Bool) -> PolymorphicSite { +pub fn new_singleton( + position : Int, + sample_size : Int, + is_replacement : Bool, +) -> PolymorphicSite { new_polymorphic_site(position, 1, sample_size, is_replacement) } ///| /// Create a doubleton site. -pub fn new_doubleton(position : Int, sample_size : Int, is_replacement : Bool) -> PolymorphicSite { +pub fn new_doubleton( + position : Int, + sample_size : Int, + is_replacement : Bool, +) -> PolymorphicSite { new_polymorphic_site(position, 2, sample_size, is_replacement) } @@ -167,7 +178,10 @@ pub fn new_doubleton(position : Int, sample_size : Int, is_replacement : Bool) - /// Reference: Watterson, G. A. (1975). /// "On the number of segregating sites in genetical models /// without recombination." Theor. Popul. Biol. 7:256-276. -pub fn popgen_watterson_theta(segregating_sites : Int, sample_size : Int) -> Double { +pub fn popgen_watterson_theta( + segregating_sites : Int, + sample_size : Int, +) -> Double { if sample_size <= 1 || segregating_sites == 0 { return 0.0 } @@ -224,16 +238,12 @@ pub fn popgen_tajima_d( ) -> NeutralityTestResult { let theta_w = popgen_watterson_theta(segregating_sites, sample_size) let se = tajima_d_standard_error(sample_size, segregating_sites, theta_w) - - let d_value = if se > 0.0 { - (theta_pi - theta_w) / se - } else { - 0.0 - } - + + let d_value = if se > 0.0 { (theta_pi - theta_w) / se } else { 0.0 } + // Approximate p-value using beta distribution let p_val = approximate_tajima_d_pvalue(d_value, sample_size) - + let interpretation = if d_value < -1.0 { "Negative D: excess of low-frequency variants, suggests population expansion or positive selection" } else if d_value > 1.0 { @@ -241,12 +251,16 @@ pub fn popgen_tajima_d( } else { "Neutral pattern: consistent with equilibrium neutrality" } - + NeutralityTestResult::{ test_name: "Tajima's D", statistic: d_value, p_value: p_val, - is_significant: if p_val != None { p_val.unwrap() < 0.05 } else { false }, + is_significant: if p_val != None { + p_val.unwrap() < 0.05 + } else { + false + }, interpretation, standard_error: se, sample_size, @@ -259,14 +273,14 @@ pub fn tajima_d_standard_error(n : Int, s : Int, theta_w : Double) -> Double { if n <= 1 || s <= 0 || theta_w <= 0.0 { return 0.0 } - + let a1 = watterson_a1(n) let a2 = watterson_a2(n) let b1 = tajima_b1(n) let b2 = tajima_b2(n) - + // Var(theta_pi - theta_W) ≈ c1*S + c2*S*(S-1) - let theta_var = (b1 / a1) * theta_w + (b2 / (a1 * a2)) * theta_w * theta_w + let theta_var = b1 / a1 * theta_w + b2 / (a1 * a2) * theta_w * theta_w theta_var.sqrt() } @@ -302,7 +316,9 @@ pub fn tajima_b2(n : Int) -> Double { let a1 = watterson_a1(n) let a2 = watterson_a2(n) // b2 = (2*(n^2 + n + 3)) / (9*n*(n-1)) - (a2/(a1^2)) - let term1 = 2.0 * (n.to_double() * n.to_double() + n.to_double() + 3.0) / (9.0 * n.to_double() * (n.to_double() - 1.0)) + let term1 = 2.0 * + (n.to_double() * n.to_double() + n.to_double() + 3.0) / + (9.0 * n.to_double() * (n.to_double() - 1.0)) let term2 = a2 / (a1 * a1) term1 - term2 } @@ -314,16 +330,16 @@ pub fn approximate_tajima_d_pvalue(d : Double, n : Int) -> Double? { if n <= 1 { return None } - + // Approximation: D approximately follows a scaled beta distribution // Mean ≈ 0, Var ≈ 1 // Transform to approximate normal let abs_d = d.abs() - + // Simple approximation for p-value // Two-sided test let p = 2.0 * (1.0 - popgen_normal_cdf(abs_d)) - + if p < 0.0001 { Some(0.0001) } else if p > 1.0 { @@ -339,7 +355,12 @@ pub fn popgen_normal_cdf(x : Double) -> Double { // Abramowitz and Stegun approximation let t = 1.0 / (1.0 + 0.2316419 * x.abs()) let d = 0.3989422804014327 * @math.exp(-x * x / 2.0) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))) + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))) + ) if x > 0.0 { 1.0 - p } else { @@ -378,24 +399,20 @@ pub fn fu_li_d( sample_size, } } - + let n = sample_size.to_double() let a1 = watterson_a1(sample_size) let theta = if a1 > 0.0 { segregating_sites.to_double() / a1 } else { 0.0 } - + // D = (singletons/n - theta) / SE let observed = singletons.to_double() / n let expected = theta let se = fu_li_d_standard_error(sample_size, segregating_sites, theta) - - let d_value = if se > 0.0 { - (observed - expected) / se - } else { - 0.0 - } - + + let d_value = if se > 0.0 { (observed - expected) / se } else { 0.0 } + let p_val = approximate_tajima_d_pvalue(d_value, sample_size) - + let interpretation = if d_value < -1.0 { "Negative D: excess of singletons, suggests population expansion or positive selection" } else if d_value > 1.0 { @@ -403,12 +420,16 @@ pub fn fu_li_d( } else { "Neutral pattern" } - + NeutralityTestResult::{ test_name: "Fu & Li's D", statistic: d_value, p_value: p_val, - is_significant: if p_val != None { p_val.unwrap() < 0.05 } else { false }, + is_significant: if p_val != None { + p_val.unwrap() < 0.05 + } else { + false + }, interpretation, standard_error: se, sample_size, @@ -421,10 +442,10 @@ pub fn fu_li_d_standard_error(n : Int, s : Int, theta : Double) -> Double { if n <= 1 || s <= 0 || theta <= 0.0 { return 0.0 } - + let a1 = watterson_a1(n) let a2 = watterson_a2(n) - + // Simplified variance calculation let theta_var = theta * (1.0 / a1 + a2 / (a1 * a1 * n.to_double())) theta_var.sqrt() @@ -452,25 +473,25 @@ pub fn fu_li_f( sample_size, } } - + let a1 = watterson_a1(sample_size) let a2 = watterson_a2(sample_size) - + // Expected singletons under neutrality let expected = segregating_sites.to_double() * a1 / (a1 + a2) let theta = if a1 > 0.0 { segregating_sites.to_double() / a1 } else { 0.0 } - + // Standard error let se = (theta * (a1 * a2) / (a1 + a2)).sqrt() - + let f_value = if se > 0.0 { (singletons.to_double() - expected) / se } else { 0.0 } - + let p_val = approximate_tajima_d_pvalue(f_value, sample_size) - + let interpretation = if f_value < -1.0 { "Negative F: excess of singletons relative to overall diversity" } else if f_value > 1.0 { @@ -478,12 +499,16 @@ pub fn fu_li_f( } else { "Neutral pattern" } - + NeutralityTestResult::{ test_name: "Fu & Li's F", statistic: f_value, p_value: p_val, - is_significant: if p_val != None { p_val.unwrap() < 0.05 } else { false }, + is_significant: if p_val != None { + p_val.unwrap() < 0.05 + } else { + false + }, interpretation, standard_error: se, sample_size, @@ -524,36 +549,38 @@ pub fn mcdonald_kreitman_test( } else { 0.0 } - + let div_ratio = if d_syn > 0 { d_nonsyn.to_double() / d_syn.to_double() } else { 0.0 } - + // Neutrality index - let ni = if div_ratio > 0.0 { - poly_ratio / div_ratio - } else { - 1.0 - } - + let ni = if div_ratio > 0.0 { poly_ratio / div_ratio } else { 1.0 } + // Fisher's exact test p-value let p_val = fisher_exact_test_2x2(p_nonsyn, p_syn, d_nonsyn, d_syn) - + // Interpretation let (interpretation, has_selection) = if p_val < 0.05 { if poly_ratio > div_ratio * 1.5 { - ("Significant positive selection: excess of replacement polymorphisms over fixations", true) + ( + "Significant positive selection: excess of replacement polymorphisms over fixations", + true, + ) } else if div_ratio > poly_ratio * 1.5 { - ("Significant purifying selection: excess of replacement fixations over polymorphisms", true) + ( + "Significant purifying selection: excess of replacement fixations over polymorphisms", + true, + ) } else { ("Significant departure from neutrality (non-neutral pattern)", true) } } else { ("No significant departure from neutrality", false) } - + MKTestResult::{ p_nonsyn, p_syn, @@ -575,42 +602,56 @@ pub fn fisher_exact_test_2x2(a : Int, b : Int, c : Int, d : Int) -> Double { if n <= 0.0 { return 1.0 } - + // Expected values let row1 = (a + b).to_double() let row2 = (c + d).to_double() let col1 = (a + c).to_double() let col2 = (b + d).to_double() - + let e_a = row1 * col1 / n let e_b = row1 * col2 / n let e_c = row2 * col1 / n let e_d = row2 * col2 / n - + // Chi-square statistic let chi2_a = if e_a > 0.0 { let diff = (a.to_double() - e_a).abs() - 0.5 diff * diff / e_a - } else { 0.0 } + } else { + 0.0 + } let chi2_b = if e_b > 0.0 { let diff = (b.to_double() - e_b).abs() - 0.5 diff * diff / e_b - } else { 0.0 } + } else { + 0.0 + } let chi2_c = if e_c > 0.0 { let diff = (c.to_double() - e_c).abs() - 0.5 diff * diff / e_c - } else { 0.0 } + } else { + 0.0 + } let chi2_d = if e_d > 0.0 { let diff = (d.to_double() - e_d).abs() - 0.5 diff * diff / e_d - } else { 0.0 } + } else { + 0.0 + } let chi2 = chi2_a + chi2_b + chi2_c + chi2_d - + // Approximate p-value from chi-square with df=1 // Using the relationship between chi-square and normal let p = @math.exp(-chi2 / 2.0) - - if p < 0.0001 { 0.0001 } else if p > 1.0 { 1.0 } else { p } + + if p < 0.0001 { + 0.0001 + } else if p > 1.0 { + 1.0 + } else { + p + } } ///| @@ -623,7 +664,7 @@ pub fn mktest_from_sites( let mut p_syn = 0 let mut d_nonsyn = 0 let mut d_syn = 0 - + for site in poly_sites { if site.is_replacement { p_nonsyn += 1 @@ -631,7 +672,7 @@ pub fn mktest_from_sites( p_syn += 1 } } - + for site in fixed_sites { if site.is_replacement { d_nonsyn += 1 @@ -639,7 +680,7 @@ pub fn mktest_from_sites( d_syn += 1 } } - + mcdonald_kreitman_test(p_nonsyn, p_syn, d_nonsyn, d_syn) } @@ -649,30 +690,33 @@ pub fn mktest_from_sites( ///| /// Calculate the allele frequency spectrum from polymorphic sites. -pub fn calculate_afs(sites : Array[PolymorphicSite], sample_size : Int) -> AlleleFrequencySpectrum { +pub fn calculate_afs( + sites : Array[PolymorphicSite], + sample_size : Int, +) -> AlleleFrequencySpectrum { let mut singletons = 0 let mut doubletons = 0 let mut segregating_sites = 0 let mut total_mutations = 0 - + let unfolded = Array::make(sample_size, 0) let folded = Array::make((sample_size + 1) / 2, 0) - + for site in sites { segregating_sites += 1 total_mutations += site.derived_count - + if site.derived_count == 1 { singletons += 1 } else if site.derived_count == 2 { doubletons += 1 } - + // Unfolded spectrum if site.derived_count < sample_size { unfolded[site.derived_count] += 1 } - + // Folded spectrum (use minimum of derived and ancestral) let minor = if site.derived_count < sample_size - site.derived_count { site.derived_count @@ -683,7 +727,7 @@ pub fn calculate_afs(sites : Array[PolymorphicSite], sample_size : Int) -> Allel folded[minor] += 1 } } - + AlleleFrequencySpectrum::{ sample_size, singletons, @@ -697,7 +741,10 @@ pub fn calculate_afs(sites : Array[PolymorphicSite], sample_size : Int) -> Allel ///| /// Calculate Tajima's D from allele frequency spectrum. -pub fn tajima_d_from_afs(afs : AlleleFrequencySpectrum, sequence_length : Int) -> NeutralityTestResult { +pub fn tajima_d_from_afs( + afs : AlleleFrequencySpectrum, + sequence_length : Int, +) -> NeutralityTestResult { let n = afs.sample_size if n <= 1 || afs.segregating_sites <= 0 { return NeutralityTestResult::{ @@ -710,22 +757,29 @@ pub fn tajima_d_from_afs(afs : AlleleFrequencySpectrum, sequence_length : Int) - sample_size: n, } } - + // Calculate theta_pi (average number of pairwise differences per site) let mut theta_pi = 0.0 let n_float = n.to_double() - + for i = 1; i < n; i = i + 1 { - let count = if i < afs.unfolded_spectrum.length() { afs.unfolded_spectrum[i] } else { 0 } - let contrib = (2.0 * i.to_double() * (n_float - i.to_double())) / (n_float * (n_float - 1.0)) + let count = if i < afs.unfolded_spectrum.length() { + afs.unfolded_spectrum[i] + } else { + 0 + } + let contrib = 2.0 * + i.to_double() * + (n_float - i.to_double()) / + (n_float * (n_float - 1.0)) theta_pi += contrib * count.to_double() } - + // Normalize by sequence length if sequence_length > 0 { theta_pi = theta_pi / sequence_length.to_double() } - + popgen_tajima_d(theta_pi, afs.segregating_sites, n, sequence_length) } @@ -760,30 +814,37 @@ pub fn run_neutrality_analysis( sequence_length : Int, ) -> NeutralityAnalysisResult { let afs = calculate_afs(sites, sample_size) - + let theta_w = popgen_watterson_theta(afs.segregating_sites, sample_size) let result_d = tajima_d_from_afs(afs, sequence_length) let result_fu_d = fu_li_d_from_afs(afs) let result_fu_f = fu_li_f(afs.singletons, afs.segregating_sites, sample_size) - + // Calculate theta_pi let mut theta_pi = 0.0 let n_float = sample_size.to_double() - + for i = 1; i < sample_size; i = i + 1 { - let count = if i < afs.unfolded_spectrum.length() { afs.unfolded_spectrum[i] } else { 0 } - let contrib = (2.0 * i.to_double() * (n_float - i.to_double())) / (n_float * (n_float - 1.0)) + let count = if i < afs.unfolded_spectrum.length() { + afs.unfolded_spectrum[i] + } else { + 0 + } + let contrib = 2.0 * + i.to_double() * + (n_float - i.to_double()) / + (n_float * (n_float - 1.0)) theta_pi += contrib * count.to_double() } if sequence_length > 0 { theta_pi = theta_pi / sequence_length.to_double() } - + // Determine if neutral - let is_neutral = !result_d.is_significant && - !result_fu_d.is_significant && + let is_neutral = !result_d.is_significant && + !result_fu_d.is_significant && !result_fu_f.is_significant - + NeutralityAnalysisResult::{ tajima_d: result_d, fu_li_d: result_fu_d, @@ -798,7 +859,9 @@ pub fn run_neutrality_analysis( ///| /// Format a neutrality analysis result as a string. -pub fn neutrality_analysis_to_string(result : NeutralityAnalysisResult) -> String { +pub fn neutrality_analysis_to_string( + result : NeutralityAnalysisResult, +) -> String { let mut s = "" s = s + "=== Neutrality Analysis Results ===\n\n" s = s + "Sample size: " @@ -813,7 +876,7 @@ pub fn neutrality_analysis_to_string(result : NeutralityAnalysisResult) -> Strin s = s + "Tajima's theta (theta_pi): " s = s + result.tajima_theta_pi.to_string() s = s + "\n\n" - + // Tajima's D s = s + "Tajima's D: " s = s + result.tajima_d.statistic.to_string() @@ -828,7 +891,7 @@ pub fn neutrality_analysis_to_string(result : NeutralityAnalysisResult) -> Strin s = s + "\n " s = s + result.tajima_d.interpretation s = s + "\n\n" - + // Fu & Li's D s = s + "Fu & Li's D: " s = s + result.fu_li_d.statistic.to_string() @@ -843,7 +906,7 @@ pub fn neutrality_analysis_to_string(result : NeutralityAnalysisResult) -> Strin s = s + "\n " s = s + result.fu_li_d.interpretation s = s + "\n\n" - + // Fu & Li's F s = s + "Fu & Li's F: " s = s + result.fu_li_f.statistic.to_string() @@ -858,7 +921,7 @@ pub fn neutrality_analysis_to_string(result : NeutralityAnalysisResult) -> Strin s = s + "\n " s = s + result.fu_li_f.interpretation s = s + "\n\n" - + s = s + "Overall: " if result.is_neutral { s = s + "CONSISTENT WITH NEUTRALITY" @@ -866,6 +929,6 @@ pub fn neutrality_analysis_to_string(result : NeutralityAnalysisResult) -> Strin s = s + "SIGNIFICANT DEPARTURE FROM NEUTRALITY DETECTED" } s = s + "\n" - + s -} \ No newline at end of file +} diff --git a/src/preprocess_core.mbt b/src/preprocess_core.mbt index f9c0f8d2..943f47a6 100644 --- a/src/preprocess_core.mbt +++ b/src/preprocess_core.mbt @@ -26,11 +26,7 @@ pub struct QuantileNormConfig { ///| /// Create default quantile normalization config. pub fn QuantileNormConfig::new() -> QuantileNormConfig { - QuantileNormConfig::{ - copy: true, - keep_names: true, - method: "quantile", - } + QuantileNormConfig::{ copy: true, keep_names: true, method: "quantile" } } ///| @@ -65,7 +61,11 @@ pub fn InvariantSetResult::new( ///| /// Absolute value for double. fn pc_abs(x : Double) -> Double { - if x < 0.0 { -x } else { x } + if x < 0.0 { + -x + } else { + x + } } ///| @@ -116,8 +116,12 @@ pub fn pc_interp_linear( x : Double, ) -> Double { let n = xs.length() - if n == 0 { return 0.0 } - if n == 1 { return ys[0] } + if n == 0 { + return 0.0 + } + if n == 1 { + return ys[0] + } // Handle extrapolation below minimum if x <= xs[0] { return ys[0] @@ -145,12 +149,11 @@ pub fn pc_interp_linear( ///| /// Linear model fit via least squares (simple y = a + bx). /// Returns [intercept, slope]. -fn pc_linear_fit( - xs : Array[Double], - ys : Array[Double], -) -> Array[Double] { +fn pc_linear_fit(xs : Array[Double], ys : Array[Double]) -> Array[Double] { let n = xs.length() - if n < 2 { return [0.0, 0.0] } + if n < 2 { + return [0.0, 0.0] + } let mut sum_x = 0.0 let mut sum_y = 0.0 let mut sum_xx = 0.0 @@ -188,9 +191,13 @@ pub fn normalize_quantiles( matrix : Array[Array[Double]], ) -> Array[Array[Double]] { let n_rows = matrix.length() - if n_rows == 0 { return matrix } + if n_rows == 0 { + return matrix + } let n_cols = matrix[0].length() - if n_cols == 0 { return matrix } + if n_cols == 0 { + return matrix + } // Transpose: work with columns as arrays // column_arrays[col] = [row0, row1, ..., rowN] @@ -260,10 +267,16 @@ pub fn normalize_quantiles_use_target( target : Array[Double], ) -> Array[Array[Double]] { let n_rows = matrix.length() - if n_rows == 0 { return matrix } + if n_rows == 0 { + return matrix + } let n_cols = matrix[0].length() - if n_cols == 0 { return matrix } - if target.length() != n_rows { return matrix } + if n_cols == 0 { + return matrix + } + if target.length() != n_rows { + return matrix + } let sorted_target = pc_sort_doubles(target) @@ -296,9 +309,13 @@ pub fn normalize_quantiles_determine_target( matrix : Array[Array[Double]], ) -> Array[Double] { let n_rows = matrix.length() - if n_rows == 0 { return [] } + if n_rows == 0 { + return [] + } let n_cols = matrix[0].length() - if n_cols == 0 { return [] } + if n_cols == 0 { + return [] + } // Sort each column let sorted_cols : Array[Array[Double]] = [] @@ -333,10 +350,16 @@ pub fn normalize_quantiles_subset( subset_indices : Array[Int], ) -> Array[Array[Double]] { let n_rows = matrix.length() - if n_rows == 0 { return matrix } + if n_rows == 0 { + return matrix + } let n_cols = matrix[0].length() - if n_cols == 0 { return matrix } - if subset_indices.length() == 0 { return normalize_quantiles(matrix) } + if n_cols == 0 { + return matrix + } + if subset_indices.length() == 0 { + return normalize_quantiles(matrix) + } // Build subset matrix let sub_n = subset_indices.length() @@ -346,7 +369,9 @@ pub fn normalize_quantiles_subset( } for s_idx in 0..= n_rows { continue } + if orig_row < 0 || orig_row >= n_rows { + continue + } sub_matrix[s_idx] = matrix[orig_row].copy() } @@ -391,11 +416,13 @@ pub fn normalize_quantiles_subset( pub fn find_invariant_set( reference : Array[Double], target : Array[Double], - threshold~ : Double = 0.005, - max_iterations~ : Int = 10, + threshold? : Double = 0.005, + max_iterations? : Int = 10, ) -> Array[Int] { let n = reference.length() - if n != target.length() || n == 0 { return [] } + if n != target.length() || n == 0 { + return [] + } // Rank each array let ref_order = pc_argsort(reference) @@ -429,7 +456,9 @@ pub fn find_invariant_set( for idx in invariant { let predicted = intercept + slope * ref_ranks[idx] let residual = pc_abs(tgt_ranks[idx] - predicted) - if max_residual < residual { max_residual = residual } + if max_residual < residual { + max_residual = residual + } } let cutoff = threshold * n.to_double() if max_residual < cutoff || invariant.length() < 3 { @@ -447,7 +476,9 @@ pub fn find_invariant_set( break } invariant = new_invariant - if invariant.length() < 3 { break } + if invariant.length() < 3 { + break + } iter = iter + 1 } @@ -459,8 +490,8 @@ pub fn find_invariant_set( /// Reference column is specified by reference_index. pub fn normalize_invariantset( matrix : Array[Array[Double]], - reference_index~ : Int = 0, - threshold~ : Double = 0.005, + reference_index? : Int = 0, + threshold? : Double = 0.005, ) -> InvariantSetResult { let n_rows = matrix.length() if n_rows == 0 { @@ -490,7 +521,7 @@ pub fn normalize_invariantset( for row in 0.. Array[Array[Double]] { let n_rows = matrix.length() - if n_rows == 0 { return matrix } + if n_rows == 0 { + return matrix + } let n_cols = matrix[0].length() let result : Array[Array[Double]] = [] for _row in 0.. Array[Array[Double]] { let n_rows = matrix.length() - if n_rows == 0 { return matrix } + if n_rows == 0 { + return matrix + } let n_cols = matrix[0].length() let result : Array[Array[Double]] = [] @@ -580,7 +614,13 @@ pub fn background_correct_percentile( } let sorted = pc_sort_doubles(col_data) let idx = (percentile * (n_rows - 1).to_double()).to_int() - let bg = sorted[if idx < 0 { 0 } else { if idx >= n_rows { n_rows - 1 } else { idx } }] + let bg = sorted[if idx < 0 { + 0 + } else if idx >= n_rows { + n_rows - 1 + } else { + idx + }] for row in 0.. Array[Array[Double]] { let n_rows = matrix.length() - if n_rows == 0 { return matrix } + if n_rows == 0 { + return matrix + } let n_cols = matrix[0].length() let result : Array[Array[Double]] = [] @@ -625,11 +667,11 @@ pub fn median_center_columns( ///| /// Compute column summary statistics. /// Returns [mean, median, sd, min, max] for each column. -pub fn column_summary( - matrix : Array[Array[Double]], -) -> Array[Array[Double]] { +pub fn column_summary(matrix : Array[Array[Double]]) -> Array[Array[Double]] { let n_rows = matrix.length() - if n_rows == 0 { return [] } + if n_rows == 0 { + return [] + } let n_cols = matrix[0].length() let result : Array[Array[Double]] = [] for _col in 0.. Primer3Config { Primer3Config::{ primer_length_min, @@ -51,7 +51,7 @@ pub fn Primer3Config::new( max_self_complement, max_cross_complement, salt_conc, - flank + flank, } } @@ -100,17 +100,13 @@ pub fn Primer3Config::gc_max(self : Primer3Config) -> Double { ///| /// Maximum allowed self-complementarity score. -pub fn Primer3Config::max_self_complement( - self : Primer3Config -) -> Int { +pub fn Primer3Config::max_self_complement(self : Primer3Config) -> Int { self.max_self_complement } ///| /// Maximum allowed cross-complementarity score. -pub fn Primer3Config::max_cross_complement( - self : Primer3Config -) -> Int { +pub fn Primer3Config::max_cross_complement(self : Primer3Config) -> Int { self.max_cross_complement } @@ -153,7 +149,7 @@ pub fn Primer3Result::new( gc : Double, self_complement : Int, is_forward : Bool, - score : Double + score : Double, ) -> Primer3Result { Primer3Result::{ sequence, @@ -163,7 +159,7 @@ pub fn Primer3Result::new( gc, self_complement, is_forward, - score + score, } } @@ -199,9 +195,7 @@ pub fn Primer3Result::gc(self : Primer3Result) -> Double { ///| /// Self-complementarity score (lower is better). -pub fn Primer3Result::self_complement( - self : Primer3Result -) -> Int { +pub fn Primer3Result::self_complement(self : Primer3Result) -> Int { self.self_complement } @@ -290,10 +284,7 @@ pub fn primer3_tm_wallace(seq : String) -> Double { /// Salt-adjusted melting temperature: /// Tm = 81.5 + 16.6 * log10([Na+]) + 0.41 * %GC - 600 / length /// Suitable for longer primers. `salt_conc` is in mol/L. -pub fn primer3_tm_salt( - seq : String, - salt_conc : Double -) -> Double { +pub fn primer3_tm_salt(seq : String, salt_conc : Double) -> Double { let n = seq.length() if n == 0 { return 0.0 @@ -308,10 +299,7 @@ pub fn primer3_tm_salt( ///| /// Choose an appropriate Tm formula based on length. /// Short oligos (< 14 nt) use Wallace; longer use the salt-adjusted formula. -pub fn primer3_tm( - seq : String, - salt_conc : Double -) -> Double { +pub fn primer3_tm(seq : String, salt_conc : Double) -> Double { if seq.length() < 14 { primer3_tm_wallace(seq) } else { @@ -371,10 +359,7 @@ pub fn primer3_self_complement(seq : String) -> Int { /// Score cross-dimer complementarity between two primers by sliding /// the reverse complement of seq2 against seq1 and counting paired bases. /// Returns the maximum paired count across all offsets. -pub fn primer3_cross_dimer( - seq1 : String, - seq2 : String -) -> Int { +pub fn primer3_cross_dimer(seq1 : String, seq2 : String) -> Int { let n1 = seq1.length() let n2 = seq2.length() if n1 == 0 || n2 == 0 { @@ -411,10 +396,7 @@ pub fn primer3_cross_dimer( /// Detect hairpin potential by checking self-complementarity at the 3' end. /// Returns the self-complementarity score restricted to the last /// `end_len` bases of the primer. -pub fn primer3_hairpin_3prime( - seq : String, - end_len : Int -) -> Int { +pub fn primer3_hairpin_3prime(seq : String, end_len : Int) -> Int { let n = seq.length() if n == 0 || end_len <= 0 { return 0 @@ -438,7 +420,7 @@ pub fn primer3_score( tm : Double, gc : Double, self_comp : Int, - config : Primer3Config + config : Primer3Config, ) -> Double { let tm_mid = (config.tm_min + config.tm_max) / 2.0 let tm_span = (config.tm_max - config.tm_min) / 2.0 @@ -454,7 +436,8 @@ pub fn primer3_score( } else { 0.0 } - let self_penalty = self_comp.to_double() / config.primer_length_min.to_double() + let self_penalty = self_comp.to_double() / + config.primer_length_min.to_double() // Score in [0, 100]; 100 is ideal. 100.0 - 40.0 * tm_penalty - 30.0 * gc_penalty - 30.0 * self_penalty } @@ -474,7 +457,7 @@ pub struct Primer3Design { /// Construct a `Primer3Design`. pub fn Primer3Design::new( forward : Array[Primer3Result], - reverse : Array[Primer3Result] + reverse : Array[Primer3Result], ) -> Primer3Design { Primer3Design::{ forward, reverse } } @@ -511,9 +494,7 @@ pub fn Primer3Design::has_pair(self : Primer3Design) -> Bool { ///| /// Best forward primer (highest score), or None if no candidate. -pub fn Primer3Design::best_forward( - self : Primer3Design -) -> Primer3Result? { +pub fn Primer3Design::best_forward(self : Primer3Design) -> Primer3Result? { if self.forward.length() == 0 { None } else { @@ -523,9 +504,7 @@ pub fn Primer3Design::best_forward( ///| /// Best reverse primer (highest score), or None if no candidate. -pub fn Primer3Design::best_reverse( - self : Primer3Design -) -> Primer3Result? { +pub fn Primer3Design::best_reverse(self : Primer3Design) -> Primer3Result? { if self.reverse.length() == 0 { None } else { @@ -536,7 +515,7 @@ pub fn Primer3Design::best_reverse( ///| /// Best primer pair (forward, reverse), or None if either is missing. pub fn Primer3Design::best_pair( - self : Primer3Design + self : Primer3Design, ) -> (Primer3Result, Primer3Result)? { if self.has_pair() { Some((self.forward[0], self.reverse[0])) @@ -551,7 +530,7 @@ pub fn Primer3Design::best_pair( /// primer candidates sorted by score (best first). pub fn primer3_design_primers( template : String, - config : Primer3Config + config : Primer3Config, ) -> Primer3Design { let n = template.length() let forward = Array::new() @@ -576,7 +555,7 @@ pub fn primer3_design_primers( sc <= config.max_self_complement { let score = primer3_score(seq, tm, gc, sc, config) forward.push( - Primer3Result::new(seq, start, len, tm, gc, sc, true, score) + Primer3Result::new(seq, start, len, tm, gc, sc, true, score), ) } len = len + 1 @@ -606,17 +585,31 @@ pub fn primer3_design_primers( gc <= config.gc_max && sc <= config.max_self_complement { let score = primer3_score(seq, tm, gc, sc, config) - reverse.push( - Primer3Result::new(seq, ts, len, tm, gc, sc, false, score) - ) + reverse.push(Primer3Result::new(seq, ts, len, tm, gc, sc, false, score)) } len = len + 1 } rstart = rstart - 1 } // Sort by score descending (highest/best first). - forward.sort_by(fn(a, b) { if a.score() > b.score() { -1 } else if a.score() < b.score() { 1 } else { 0 } }) - reverse.sort_by(fn(a, b) { if a.score() > b.score() { -1 } else if a.score() < b.score() { 1 } else { 0 } }) + forward.sort_by(fn(a, b) { + if a.score() > b.score() { + -1 + } else if a.score() < b.score() { + 1 + } else { + 0 + } + }) + reverse.sort_by(fn(a, b) { + if a.score() > b.score() { + -1 + } else if a.score() < b.score() { + 1 + } else { + 0 + } + }) Primer3Design::new(forward, reverse) } @@ -631,7 +624,7 @@ pub fn primer3_amplicon_length( fwd_start : Int, fwd_len : Int, rev_start : Int, - rev_len : Int + rev_len : Int, ) -> Int { let amp_end = rev_start + rev_len // exclusive end amp_end - fwd_start @@ -641,7 +634,7 @@ pub fn primer3_amplicon_length( /// Predicted amplicon length for a primer pair. pub fn primer3_pair_amplicon_length( fwd : Primer3Result, - rev : Primer3Result + rev : Primer3Result, ) -> Int { primer3_amplicon_length(fwd.start(), fwd.length(), rev.start(), rev.length()) } @@ -658,55 +651,16 @@ pub fn primer3_sample_template() -> String { // A 12-bp motif with ~50% GC, repeated to build a 600 bp template. // We use a mix of motifs to create variability. let motifs = [ - "ATGCGTACGTAG", - "CTAGCATCGATC", - "GATCGATCGATC", - "ATCGATCGATCG", - "CGTACGTACGTA", - "TACGTACGTACG", - "AGCTAGCTAGCT", - "GCGCGATATATA", - "ATATGCGCGCGC", - "TCTAGATCTAGA", - "GAGCTCGAGCTC", - "AATTGGCCAATT", - "TTAACCGGTTAA", - "GGCCAATTGGCC", - "AATTAATTGGCC", - "CGGCCGAATTCC", - "AAGCTTAAGCTT", - "TTCGAATTCGAA", - "GGATCCGGATCC", - "AAGATCTAGATC", - "CTAGAGATCTAG", - "GATCTCTAGATC", - "ATCGATCGATCG", - "GCTAGCTAGCTA", - "TACGTACGTACG", - "CATGCATGCATG", - "GTACGTACGTAC", - "AGCTAGCTAGCT", - "CGATCGATCGAT", - "TAGCTAGCTAGC", - "ATGcatgcATGC", - "GCATgcATGCAT", - "TTGGCCAATTGG", - "CCAATTGGCCAA", - "AATTGGCCAATT", - "GGCCAATTGGCC", - "AATTAATTGGCC", - "CGGCCGAATTCC", - "AAGCTTAAGCTT", - "TTCGAATTCGAA", - "GGATCCGGATCC", - "AAGATCTAGATC", - "CTAGAGATCTAG", - "GATCTCTAGATC", - "ATCGATCGATCG", - "GCTAGCTAGCTA", - "TACGTACGTACG", - "CATGCATGCATG", - "GTACGTACGTAC" + "ATGCGTACGTAG", "CTAGCATCGATC", "GATCGATCGATC", "ATCGATCGATCG", "CGTACGTACGTA", + "TACGTACGTACG", "AGCTAGCTAGCT", "GCGCGATATATA", "ATATGCGCGCGC", "TCTAGATCTAGA", + "GAGCTCGAGCTC", "AATTGGCCAATT", "TTAACCGGTTAA", "GGCCAATTGGCC", "AATTAATTGGCC", + "CGGCCGAATTCC", "AAGCTTAAGCTT", "TTCGAATTCGAA", "GGATCCGGATCC", "AAGATCTAGATC", + "CTAGAGATCTAG", "GATCTCTAGATC", "ATCGATCGATCG", "GCTAGCTAGCTA", "TACGTACGTACG", + "CATGCATGCATG", "GTACGTACGTAC", "AGCTAGCTAGCT", "CGATCGATCGAT", "TAGCTAGCTAGC", + "ATGcatgcATGC", "GCATgcATGCAT", "TTGGCCAATTGG", "CCAATTGGCCAA", "AATTGGCCAATT", + "GGCCAATTGGCC", "AATTAATTGGCC", "CGGCCGAATTCC", "AAGCTTAAGCTT", "TTCGAATTCGAA", + "GGATCCGGATCC", "AAGATCTAGATC", "CTAGAGATCTAG", "GATCTCTAGATC", "ATCGATCGATCG", + "GCTAGCTAGCTA", "TACGTACGTACG", "CATGCATGCATG", "GTACGTACGTAC", ] let mut out = "" for m in motifs { @@ -719,22 +673,10 @@ pub fn primer3_sample_template() -> String { /// A short sample template (~200 bp) for quick tests. pub fn primer3_short_template() -> String { let motifs = [ - "ATGCGTACGTAG", - "CTAGCATCGATC", - "GATCGATCGATC", - "ATCGATCGATCG", - "CGTACGTACGTA", - "TACGTACGTACG", - "AGCTAGCTAGCT", - "GCGCGATATATA", - "ATATGCGCGCGC", - "TCTAGATCTAGA", - "GAGCTCGAGCTC", - "AATTGGCCAATT", - "TTAACCGGTTAA", - "GGCCAATTGGCC", - "AATTAATTGGCC", - "CGGCCGAATTCC" + "ATGCGTACGTAG", "CTAGCATCGATC", "GATCGATCGATC", "ATCGATCGATCG", "CGTACGTACGTA", + "TACGTACGTACG", "AGCTAGCTAGCT", "GCGCGATATATA", "ATATGCGCGCGC", "TCTAGATCTAGA", + "GAGCTCGAGCTC", "AATTGGCCAATT", "TTAACCGGTTAA", "GGCCAATTGGCC", "AATTAATTGGCC", + "CGGCCGAATTCC", ] let mut out = "" for m in motifs { @@ -762,8 +704,7 @@ pub fn primer3_design_summary(design : Primer3Design) -> String { } match design.best_pair() { Some((f, r)) => - s = s + - "Amplicon length: \{primer3_pair_amplicon_length(f, r)} bp\n" + s = s + "Amplicon length: \{primer3_pair_amplicon_length(f, r)} bp\n" None => s = s + "Amplicon length: (no pair)\n" } s diff --git a/src/prosite.mbt b/src/prosite.mbt index 8a0bec89..62f990d3 100644 --- a/src/prosite.mbt +++ b/src/prosite.mbt @@ -14,14 +14,18 @@ pub struct PrositePattern { } ///| -pub fn PrositePattern::new(accession : String, name : String, pattern : String) -> PrositePattern { +pub fn PrositePattern::new( + accession : String, + name : String, + pattern : String, +) -> PrositePattern { PrositePattern::{ accession, name, pattern, description: "", profile: "", - comments: "" + comments: "", } } @@ -36,14 +40,20 @@ pub struct PrositeMatch { } ///| -pub fn PrositeMatch::new(pattern_accession : String, pattern_name : String, start : Int, end : Int, matched_sequence : String) -> PrositeMatch { +pub fn PrositeMatch::new( + pattern_accession : String, + pattern_name : String, + start : Int, + end : Int, + matched_sequence : String, +) -> PrositeMatch { PrositeMatch::{ pattern_accession, pattern_name, start, end, matched_sequence, - score: 0.0 + score: 0.0, } } @@ -75,7 +85,7 @@ pub fn PrositeEntry::new(accession : String, name : String) -> PrositeEntry { created: "", modified: "", entries_with_motif: 0, - literature_references: Array::new() + literature_references: Array::new(), } } @@ -83,14 +93,15 @@ pub fn PrositeEntry::new(accession : String, name : String) -> PrositeEntry { pub fn prosite_pattern_to_regex(pattern : String) -> String { let mut regex = "" let mut i = 0 - + while i < pattern.length() { let c = pattern.unsafe_get(i).to_int() - + if c == '['.to_int() { regex = regex + "[" i = i + 1 - while i < pattern.length() && pattern.unsafe_get(i).to_int() != ']'.to_int() { + while i < pattern.length() && + pattern.unsafe_get(i).to_int() != ']'.to_int() { let pc = pattern.unsafe_get(i).to_int() if pc == '-'.to_int() { regex = regex + "-" @@ -107,7 +118,8 @@ pub fn prosite_pattern_to_regex(pattern : String) -> String { } else if c == '{'.to_int() { regex = regex + "[^" i = i + 1 - while i < pattern.length() && pattern.unsafe_get(i).to_int() != '}'.to_int() { + while i < pattern.length() && + pattern.unsafe_get(i).to_int() != '}'.to_int() { let cc = char_at(pattern, i) regex = regex + cc i = i + 1 @@ -119,7 +131,8 @@ pub fn prosite_pattern_to_regex(pattern : String) -> String { } else if c == '('.to_int() { let mut count = 0 i = i + 1 - while i < pattern.length() && pattern.unsafe_get(i).to_int() != ')'.to_int() { + while i < pattern.length() && + pattern.unsafe_get(i).to_int() != ')'.to_int() { let pc = pattern.unsafe_get(i).to_int() if pc >= '0'.to_int() && pc <= '9'.to_int() { count = count * 10 + (pc - '0'.to_int()) @@ -147,45 +160,51 @@ pub fn prosite_pattern_to_regex(pattern : String) -> String { i = i + 1 } } - + regex } ///| -pub fn prosite_search(pattern : String, sequence : String) -> Array[PrositeMatch] { +pub fn prosite_search( + pattern : String, + sequence : String, +) -> Array[PrositeMatch] { let matches : Array[PrositeMatch] = Array::new() - + if pattern.length() == 0 || sequence.length() == 0 { return matches } - + let normalized_seq = to_lowercase(sequence) let normalized_pattern = to_lowercase(pattern) let mut start_pos = 0 - + while start_pos <= normalized_seq.length() { let mut pattern_idx = 0 let mut seq_idx = start_pos let mut matched = true - - while seq_idx < normalized_seq.length() && pattern_idx < pattern.length() && matched { + + while seq_idx < normalized_seq.length() && + pattern_idx < pattern.length() && + matched { let p_char = normalized_pattern.unsafe_get(pattern_idx).to_int() - + if p_char == '['.to_int() { let mut in_bracket = true let mut bracket_content = "" pattern_idx = pattern_idx + 1 - + while pattern_idx < normalized_pattern.length() && in_bracket { let bc = normalized_pattern.unsafe_get(pattern_idx).to_int() if bc == ']'.to_int() { in_bracket = false } else { - bracket_content = bracket_content + char_at(normalized_pattern, pattern_idx) + bracket_content = bracket_content + + char_at(normalized_pattern, pattern_idx) } pattern_idx = pattern_idx + 1 } - + let s_char = char_at(normalized_seq, seq_idx) if contains(bracket_content, s_char) { seq_idx = seq_idx + 1 @@ -196,17 +215,18 @@ pub fn prosite_search(pattern : String, sequence : String) -> Array[PrositeMatch let mut in_brace = true let mut brace_content = "" pattern_idx = pattern_idx + 1 - + while pattern_idx < normalized_pattern.length() && in_brace { let bc = normalized_pattern.unsafe_get(pattern_idx).to_int() if bc == '}'.to_int() { in_brace = false } else { - brace_content = brace_content + char_at(normalized_pattern, pattern_idx) + brace_content = brace_content + + char_at(normalized_pattern, pattern_idx) } pattern_idx = pattern_idx + 1 } - + let s_char = char_at(normalized_seq, seq_idx) if !contains(brace_content, s_char) { seq_idx = seq_idx + 1 @@ -216,15 +236,18 @@ pub fn prosite_search(pattern : String, sequence : String) -> Array[PrositeMatch } else if p_char == '('.to_int() { let mut count_str = "" pattern_idx = pattern_idx + 1 - - while pattern_idx < normalized_pattern.length() && normalized_pattern.unsafe_get(pattern_idx).to_int() != ')'.to_int() { + + while pattern_idx < normalized_pattern.length() && + normalized_pattern.unsafe_get(pattern_idx).to_int() != + ')'.to_int() { count_str = count_str + char_at(normalized_pattern, pattern_idx) pattern_idx = pattern_idx + 1 } - if pattern_idx < normalized_pattern.length() && normalized_pattern.unsafe_get(pattern_idx).to_int() == ')'.to_int() { + if pattern_idx < normalized_pattern.length() && + normalized_pattern.unsafe_get(pattern_idx).to_int() == ')'.to_int() { pattern_idx = pattern_idx + 1 } - + let count = parse_int(count_str) seq_idx = seq_idx + count } else if p_char == '.'.to_int() || p_char == 'x'.to_int() { @@ -243,55 +266,87 @@ pub fn prosite_search(pattern : String, sequence : String) -> Array[PrositeMatch } } } - + if matched && pattern_idx == pattern.length() { - let matched_seq = substring(normalized_seq, start_pos, seq_idx - start_pos) - let ps_match = PrositeMatch::new("", "Custom pattern", start_pos + 1, seq_idx, matched_seq) + let matched_seq = substring( + normalized_seq, + start_pos, + seq_idx - start_pos, + ) + let ps_match = PrositeMatch::new( + "", + "Custom pattern", + start_pos + 1, + seq_idx, + matched_seq, + ) matches.push(ps_match) } - + start_pos = start_pos + 1 } - + matches } ///| -pub fn prosite_scan(sequence : String, patterns : Array[PrositePattern]) -> Array[PrositeMatch] { +pub fn prosite_scan( + sequence : String, + patterns : Array[PrositePattern], +) -> Array[PrositeMatch] { let all_matches : Array[PrositeMatch] = Array::new() - + for pattern in patterns { let matches = prosite_search(pattern.pattern, sequence) let mut i = 0 while i < matches.length() { let m = matches[i] - all_matches.push(PrositeMatch::new( - pattern.accession, - pattern.name, - m.start, - m.end, - m.matched_sequence - )) + all_matches.push( + PrositeMatch::new( + pattern.accession, + pattern.name, + m.start, + m.end, + m.matched_sequence, + ), + ) i = i + 1 } } - + all_matches } ///| pub fn prosite_get_pattern(accession : String) -> PrositePattern? { - let patterns = Map([ - ("PS00001", ("ATP/GTP-binding site motif", "[AG]-X(4)-G-K-[ST]")), - ("PS00002", ("cAMP- and cGMP-dependent protein kinase phosphorylation site", "[RK]-X-[ST]")), - ("PS00003", ("Protein kinase C phosphorylation site", "[ST]-X-[RK]")), - ("PS00004", ("Casein kinase II phosphorylation site", "[ST]-X(2)-[DE]")), - ("PS00005", ("Tyrosine kinase phosphorylation site", "[RK]-X(2)-[DE]-X(3)-Y")), - ("PS00006", ("N-myristoylation site", "G-X(2)-[AGCS]-X(2)-[STAGC]-[LIVMFYW]")), - ("PS00007", ("CAMP-dependent protein kinase phosphorylation site", "[RK]-X(2)-[ST]")), - ("PS00008", ("Amidation site", "[AG]-G-[RK]-R")) - ], capacity=8) - + let patterns = Map( + [ + ("PS00001", ("ATP/GTP-binding site motif", "[AG]-X(4)-G-K-[ST]")), + ( + "PS00002", + ( + "cAMP- and cGMP-dependent protein kinase phosphorylation site", "[RK]-X-[ST]", + ), + ), + ("PS00003", ("Protein kinase C phosphorylation site", "[ST]-X-[RK]")), + ("PS00004", ("Casein kinase II phosphorylation site", "[ST]-X(2)-[DE]")), + ( + "PS00005", + ("Tyrosine kinase phosphorylation site", "[RK]-X(2)-[DE]-X(3)-Y"), + ), + ( + "PS00006", + ("N-myristoylation site", "G-X(2)-[AGCS]-X(2)-[STAGC]-[LIVMFYW]"), + ), + ( + "PS00007", + ("CAMP-dependent protein kinase phosphorylation site", "[RK]-X(2)-[ST]"), + ), + ("PS00008", ("Amidation site", "[AG]-G-[RK]-R")), + ], + capacity=8, + ) + if patterns.contains(accession) { let info = patterns.get(accession).unwrap() Some(PrositePattern::new(accession, info.0, info.1)) @@ -301,43 +356,56 @@ pub fn prosite_get_pattern(accession : String) -> PrositePattern? { } ///| -pub fn prosite_calculate_score(match_ : PrositeMatch, pattern : PrositePattern) -> Double { +pub fn prosite_calculate_score( + match_ : PrositeMatch, + pattern : PrositePattern, +) -> Double { let mut score = 100.0 - + if match_.matched_sequence.length() < pattern.pattern.length() { score = score * 0.5 } - + let mut mismatches = 0 let mut i = 0 while i < match_.matched_sequence.length() && i < pattern.pattern.length() { let pc = char_at(pattern.pattern, i) let mc = char_at(match_.matched_sequence, i) - + if pc != mc && pattern.pattern.unsafe_get(i).to_int() != '.'.to_int() { mismatches = mismatches + 1 } i = i + 1 } - + score = score - mismatches.to_double() * 10.0 - - if score < 0.0 { 0.0 } else { score } + + if score < 0.0 { + 0.0 + } else { + score + } } ///| pub fn prosite_create_example_patterns() -> Array[PrositePattern] { let patterns : Array[PrositePattern] = Array::new() - - let ps1 = PrositePattern::new("PS00001", "ATP/GTP-binding site motif", "[AG]-X(4)-G-K-[ST]") + + let ps1 = PrositePattern::new( + "PS00001", "ATP/GTP-binding site motif", "[AG]-X(4)-G-K-[ST]", + ) patterns.push(ps1) - - let ps2 = PrositePattern::new("PS00003", "Protein kinase C phosphorylation site", "[ST]-X-[RK]") + + let ps2 = PrositePattern::new( + "PS00003", "Protein kinase C phosphorylation site", "[ST]-X-[RK]", + ) patterns.push(ps2) - - let ps3 = PrositePattern::new("PS00006", "N-myristoylation site", "G-X(2)-[AGCS]-X(2)-[STAGC]-[LIVMFYW]") + + let ps3 = PrositePattern::new( + "PS00006", "N-myristoylation site", "G-X(2)-[AGCS]-X(2)-[STAGC]-[LIVMFYW]", + ) patterns.push(ps3) - + patterns } @@ -355,6 +423,6 @@ pub fn prosite_create_example_entry() -> PrositeEntry { created: "15-NOV-1990", modified: "20-FEB-2002", entries_with_motif: 1234, - literature_references: ["PMID:12345678", "PMID:87654321"] + literature_references: ["PMID:12345678", "PMID:87654321"], } -} \ No newline at end of file +} diff --git a/src/prot_dao.mbt b/src/prot_dao.mbt index 34f3db77..97412eca 100644 --- a/src/prot_dao.mbt +++ b/src/prot_dao.mbt @@ -25,26 +25,26 @@ pub fn prot_dao_disorder_score(aa : UInt16) -> Double { let c = if aa >= 97 && aa <= 122 { aa - 32 } else { aa } match c { - 65 => 0.06 // 'A' - 67 => -0.02 // 'C' - 68 => 0.19 // 'D' - 69 => 0.74 // 'E' - 70 => -0.09 // 'F' - 71 => 0.16 // 'G' - 72 => -0.42 // 'H' - 73 => -0.48 // 'I' - 75 => 0.58 // 'K' - 76 => -0.03 // 'L' - 77 => -0.39 // 'M' - 78 => 0.03 // 'N' - 80 => 0.98 // 'P' - 81 => 0.31 // 'Q' - 82 => 0.41 // 'R' - 83 => 0.34 // 'S' - 84 => 0.59 // 'T' - 86 => -0.26 // 'V' - 87 => -0.19 // 'W' - 89 => -0.49 // 'Y' + 65 => 0.06 // 'A' + 67 => -0.02 // 'C' + 68 => 0.19 // 'D' + 69 => 0.74 // 'E' + 70 => -0.09 // 'F' + 71 => 0.16 // 'G' + 72 => -0.42 // 'H' + 73 => -0.48 // 'I' + 75 => 0.58 // 'K' + 76 => -0.03 // 'L' + 77 => -0.39 // 'M' + 78 => 0.03 // 'N' + 80 => 0.98 // 'P' + 81 => 0.31 // 'Q' + 82 => 0.41 // 'R' + 83 => 0.34 // 'S' + 84 => 0.59 // 'T' + 86 => -0.26 // 'V' + 87 => -0.19 // 'W' + 89 => -0.49 // 'Y' _ => 0.0 } } @@ -55,26 +55,26 @@ pub fn prot_dao_disorder_score(aa : UInt16) -> Double { pub fn prot_dao_energy_score(aa : UInt16) -> Double { let c = if aa >= 97 && aa <= 122 { aa - 32 } else { aa } match c { - 65 => 1.1471 // 'A' - 67 => 2.6497 // 'C' - 68 => 1.9748 // 'D' - 69 => 1.3577 // 'E' - 70 => 2.0289 // 'F' - 71 => 1.8218 // 'G' - 72 => -1.0930 // 'H' - 73 => 0.2643 // 'I' - 75 => 0.6636 // 'K' - 76 => 0.5035 // 'L' - 77 => 2.5789 // 'M' - 78 => 1.8929 // 'N' - 80 => 2.8110 // 'P' - 81 => 1.1740 // 'Q' - 82 => -0.3509 // 'R' - 83 => 2.3317 // 'S' - 84 => 0.7361 // 'T' - 86 => 0.2730 // 'V' - 87 => 1.5749 // 'W' - 89 => 1.6374 // 'Y' + 65 => 1.1471 // 'A' + 67 => 2.6497 // 'C' + 68 => 1.9748 // 'D' + 69 => 1.3577 // 'E' + 70 => 2.0289 // 'F' + 71 => 1.8218 // 'G' + 72 => -1.0930 // 'H' + 73 => 0.2643 // 'I' + 75 => 0.6636 // 'K' + 76 => 0.5035 // 'L' + 77 => 2.5789 // 'M' + 78 => 1.8929 // 'N' + 80 => 2.8110 // 'P' + 81 => 1.1740 // 'Q' + 82 => -0.3509 // 'R' + 83 => 2.3317 // 'S' + 84 => 0.7361 // 'T' + 86 => 0.2730 // 'V' + 87 => 1.5749 // 'W' + 89 => 1.6374 // 'Y' _ => 0.0 } } @@ -218,8 +218,12 @@ pub fn prot_dao_predict( residues[ci].disorder_score = smoothed[ci] residues[ci].is_disordered = smoothed[ci] > threshold_disordered residues[ci].is_disordered_long = smoothed[ci] > threshold_long - if residues[ci].is_disordered { n_disordered = n_disordered + 1 } - if residues[ci].is_disordered_long { n_disordered_long = n_disordered_long + 1 } + if residues[ci].is_disordered { + n_disordered = n_disordered + 1 + } + if residues[ci].is_disordered_long { + n_disordered_long = n_disordered_long + 1 + } ci = ci + 1 } @@ -239,7 +243,9 @@ pub fn prot_dao_predict( let s = smoothed[region_end] rs = rs + s count = count + 1 - if s > max_s { max_s = s } + if s > max_s { + max_s = s + } region_end = region_end + 1 } @@ -247,13 +253,15 @@ pub fn prot_dao_predict( let is_long = region_end - region_start >= 30 let type_ = if is_long { "long disordered" } else { "disordered" } - regions.push(DisorderRegion::new( - region_start + 1, - region_end, - avg_s, - max_s, - region_type=type_, - )) + regions.push( + DisorderRegion::new( + region_start + 1, + region_end, + avg_s, + max_s, + region_type=type_, + ), + ) ri = region_end } else { ri = ri + 1 @@ -303,7 +311,9 @@ pub fn DisorderResult::get_fraction_disordered(self : DisorderResult) -> Double ///| /// Get disordered regions. -pub fn DisorderResult::get_regions(self : DisorderResult) -> Array[DisorderRegion] { +pub fn DisorderResult::get_regions( + self : DisorderResult, +) -> Array[DisorderRegion] { self.regions.copy() } @@ -315,7 +325,9 @@ pub fn DisorderResult::get_n_regions(self : DisorderResult) -> Int { ///| /// Get the longest disordered region. -pub fn DisorderResult::get_longest_region(self : DisorderResult) -> DisorderRegion { +pub fn DisorderResult::get_longest_region( + self : DisorderResult, +) -> DisorderRegion { if self.regions.length() == 0 { return DisorderRegion::new(0, 0, 0.0, 0.0, region_type="none") } @@ -364,27 +376,49 @@ pub fn DisorderResult::summary(self : DisorderResult) -> String { let mut s = "Disorder Prediction Summary\n" s = s + "Method: " + self.method + "\n" s = s + "Sequence length: " + self.sequence.length().to_string() + "\n" - s = s + "Disordered residues: " + self.n_disordered.to_string() + " (" + self.fraction_disordered.to_string() + ")\n" - s = s + "Long disordered residues: " + self.n_disordered_long.to_string() + "\n" + s = s + + "Disordered residues: " + + self.n_disordered.to_string() + + " (" + + self.fraction_disordered.to_string() + + ")\n" + s = s + + "Long disordered residues: " + + self.n_disordered_long.to_string() + + "\n" s = s + "Disordered regions: " + self.regions.length().to_string() + "\n" - s = s + "Threshold (disordered): " + self.threshold_disordered.to_string() + "\n" + s = s + + "Threshold (disordered): " + + self.threshold_disordered.to_string() + + "\n" s = s + "Threshold (long): " + self.threshold_long.to_string() + "\n" s } ///| /// Format disorder result as ASCII visualization. -pub fn DisorderResult::to_ascii(self : DisorderResult, width? : Int = 80) -> String { +pub fn DisorderResult::to_ascii( + self : DisorderResult, + width? : Int = 80, +) -> String { let w = if width > 0 { width } else { 80 } let seq_len = self.sequence.length() - if seq_len == 0 { return "Empty sequence" } + if seq_len == 0 { + return "Empty sequence" + } // Create the score track let mut s = "Score: " let mut i = 0 while i < seq_len { let score = self.residues[i].disorder_score - let bar = if score > self.threshold_long { "##" } else if score > self.threshold_disordered { "##" } else { "--" } + let bar = if score > self.threshold_long { + "##" + } else if score > self.threshold_disordered { + "##" + } else { + "--" + } s = s + bar i = i + 1 } @@ -399,7 +433,11 @@ pub fn DisorderResult::to_ascii(self : DisorderResult, width? : Int = 80) -> Str if pos == 1 || pos % 10 == 0 { if pos > 1 { let spaces = " " - let take = if spaces.length() >= label_len { label_len } else { spaces.length() } + let take = if spaces.length() >= label_len { + label_len + } else { + spaces.length() + } ruler = ruler + spaces.substring(start=0, end=take) } ruler = ruler + label @@ -431,7 +469,20 @@ pub fn DisorderResult::to_ascii(self : DisorderResult, width? : Int = 80) -> Str let mut ri = 0 while ri < self.regions.length() { let reg = self.regions[ri] - s = s + " Region " + (ri + 1).to_string() + ": " + reg.start.to_string() + "-" + reg.end_.to_string() + " (length=" + reg.length.to_string() + ", avg_score=" + reg.avg_score.to_string() + ", type=" + reg.region_type + ")\n" + s = s + + " Region " + + (ri + 1).to_string() + + ": " + + reg.start.to_string() + + "-" + + reg.end_.to_string() + + " (length=" + + reg.length.to_string() + + ", avg_score=" + + reg.avg_score.to_string() + + ", type=" + + reg.region_type + + ")\n" ri = ri + 1 } @@ -447,11 +498,11 @@ pub fn DisorderResult::to_ascii(self : DisorderResult, width? : Int = 80) -> Str pub fn prot_dao_sample_sequence() -> String { // A protein with mixed ordered and disordered regions // N-terminal disordered region, central ordered region, C-terminal disordered - let n_term_disordered = "MSEGKSSGGSSSGRRSSSGGGSSGGKSGKSSGR" // disordered - let ordered_core = "PKEIVLDSNGSLEVVKNGKVVVESTGNKVVLTSGQE" // ordered - let linker = "SSSSSS" // disordered linker - let second_domain = "KLPNLVISGDAGHVVVDAESNGKIVLLPSN" // ordered - let c_term_disordered = "GSSGSSGSGGKSGSSGSGRGSSGGNSSGKSSG" // disordered + let n_term_disordered = "MSEGKSSGGSSSGRRSSSGGGSSGGKSGKSSGR" // disordered + let ordered_core = "PKEIVLDSNGSLEVVKNGKVVVESTGNKVVLTSGQE" // ordered + let linker = "SSSSSS" // disordered linker + let second_domain = "KLPNLVISGDAGHVVVDAESNGKIVLLPSN" // ordered + let c_term_disordered = "GSSGSSGSGGKSGSSGSGRGSSGGNSSGKSSG" // disordered n_term_disordered + ordered_core + linker + second_domain + c_term_disordered } diff --git a/src/protein_analysis.mbt b/src/protein_analysis.mbt index ea188e2e..0f176328 100644 --- a/src/protein_analysis.mbt +++ b/src/protein_analysis.mbt @@ -14,6 +14,7 @@ // Kyte-Doolittle Hydrophobicity Scale // ============================================================================ +///| fn protein_get_kd(c : Char) -> Double { match c { 'A' => 1.8 @@ -50,12 +51,14 @@ fn protein_get_kd(c : Char) -> Double { // - P_turn: probability of being in turn/coil // ============================================================================ +///| struct GorParams { pa : Double pb : Double pt : Double } +///| fn protein_get_gor(c : Char) -> GorParams { match c { 'A' => GorParams::{ pa: 1.42, pb: 0.83, pt: 0.66 } @@ -86,12 +89,14 @@ fn protein_get_gor(c : Char) -> GorParams { // TM Scale (transmembrane propensity) // ============================================================================ +///| struct TmParams { inside : Double outside : Double tm : Double } +///| fn protein_get_tm(c : Char) -> TmParams { match c { 'A' => TmParams::{ inside: 1.1, outside: 0.56, tm: 1.32 } @@ -122,6 +127,7 @@ fn protein_get_tm(c : Char) -> TmParams { // Shannon Entropy for Conservation // ============================================================================ +///| fn protein_shannon_entropy(freqs : Array[Double]) -> Double { let mut h = 0.0 let mut i = 0 @@ -139,10 +145,16 @@ fn protein_shannon_entropy(freqs : Array[Double]) -> Double { // Amino Acid Frequency at Position // ============================================================================ -fn protein_aa_frequency_at(alignment : Array[String], pos : Int) -> Array[Double] { +///| +fn protein_aa_frequency_at( + alignment : Array[String], + pos : Int, +) -> Array[Double] { let freqs : Array[Double] = Array::new() let n = alignment.length().to_double() - if n == 0.0 { return freqs } + if n == 0.0 { + return freqs + } let aa_map = Map([], capacity=26) let mut i = 0 while i < alignment.length() { @@ -181,7 +193,9 @@ fn protein_aa_frequency_at(alignment : Array[String], pos : Int) -> Array[Double /// Calculate per-position conservation score from a multiple sequence alignment. /// Returns scores from 0 (no conservation) to 1 (perfect conservation). pub fn protein_conservation(alignment : Array[String]) -> Array[Double] { - if alignment.length() == 0 { return [] } + if alignment.length() == 0 { + return [] + } let aln_len = alignment[0].length() let alphabet_size = 20.0 let conservation : Array[Double] = Array::new() @@ -199,11 +213,16 @@ pub fn protein_conservation(alignment : Array[String]) -> Array[Double] { ///| /// Calculate Kyte-Doolittle hydropathy values for a protein sequence. /// Returns array of hydropathy values averaged over a sliding window. -pub fn protein_hydropathy(sequence : String, window? : Int = 7) -> Array[Double] { +pub fn protein_hydropathy( + sequence : String, + window? : Int = 7, +) -> Array[Double] { let seq = sequence.to_upper() let w = if window <= 0 { 7 } else { window } let result : Array[Double] = Array::new() - if seq.length() < w { return result } + if seq.length() < w { + return result + } let mut i = 0 while i <= seq.length() - w { let mut sum = 0.0 @@ -285,11 +304,17 @@ pub fn protein_antigenicity(sequence : String) -> Array[Double] { ///| /// Predict transmembrane domains using the TM scale. /// Returns array of scores: positive = transmembrane, negative = inside/outside. -pub fn protein_transmembrane(sequence : String, window? : Int = 19, threshold? : Double = 1.6) -> Array[Double] { +pub fn protein_transmembrane( + sequence : String, + window? : Int = 19, + threshold? : Double = 1.6, +) -> Array[Double] { let seq = sequence.to_upper() let w = if window <= 0 { 19 } else { window } let result : Array[Double] = Array::new() - if seq.length() < w { return result } + if seq.length() < w { + return result + } let mut i = 0 while i <= seq.length() - w { let mut sum = 0.0 @@ -339,7 +364,9 @@ pub fn protein_dipeptide_composition(sequence : String) -> Map[String, Double] { let seq = sequence.to_upper() let n = (seq.length() - 1).to_double() let comp = Map([], capacity=400) - if seq.length() < 2 { return comp } + if seq.length() < 2 { + return comp + } let mut i = 0 while i < seq.length() - 1 { let di = seq[i:i + 2].to_owned() @@ -359,7 +386,9 @@ pub fn protein_tripeptide_composition(sequence : String) -> Map[String, Double] let seq = sequence.to_upper() let n = (seq.length() - 2).to_double() let comp = Map([], capacity=8000) - if seq.length() < 3 { return comp } + if seq.length() < 3 { + return comp + } let mut i = 0 while i < seq.length() - 2 { let tri = seq[i:i + 3].to_owned() @@ -388,9 +417,7 @@ pub fn protein_summary(sequence : String) -> String { sorted_keys.push(keys[ki]) ki = ki + 1 } - sorted_keys.sort_by(fn(a : Char, b : Char) -> Int { - a.to_int() - b.to_int() - }) + sorted_keys.sort_by(fn(a : Char, b : Char) -> Int { a.to_int() - b.to_int() }) out = out + "\nAmino Acid Composition:\n" let mut si = 0 while si < sorted_keys.length() { @@ -406,16 +433,25 @@ pub fn protein_summary(sequence : String) -> String { total_hydro = total_hydro + hydro[hi] hi = hi + 1 } - let avg_hydro = if hydro.length() > 0 { total_hydro / hydro.length().to_double() } else { 0.0 } + let avg_hydro = if hydro.length() > 0 { + total_hydro / hydro.length().to_double() + } else { + 0.0 + } out = out + "\nAverage Hydropathy (window=7): " + avg_hydro.to_string() + "\n" let tm = protein_transmembrane(seq, window=19) let mut has_tm = false let mut ti = 0 while ti < tm.length() { - if tm[ti] > 1.6 { has_tm = true } + if tm[ti] > 1.6 { + has_tm = true + } ti = ti + 1 } - out = out + "Transmembrane domain detected: " + (if has_tm { "Yes" } else { "No" }) + "\n" + out = out + + "Transmembrane domain detected: " + + (if has_tm { "Yes" } else { "No" }) + + "\n" let ss = protein_secondary_structure(seq) let mut h_count = 0 let mut e_count = 0 @@ -433,9 +469,21 @@ pub fn protein_summary(sequence : String) -> String { } let total = seq.length().to_double() out = out + "\nSecondary Structure Prediction (GOR):\n" - out = out + " Helix (H): " + (h_count.to_double() / total * 100.0).to_string() + "%\n" - out = out + " Sheet (E): " + (e_count.to_double() / total * 100.0).to_string() + "%\n" - out = out + " Turn (T): " + (t_count.to_double() / total * 100.0).to_string() + "%\n" - out = out + " Coil (C): " + (c_count.to_double() / total * 100.0).to_string() + "%\n" + out = out + + " Helix (H): " + + (h_count.to_double() / total * 100.0).to_string() + + "%\n" + out = out + + " Sheet (E): " + + (e_count.to_double() / total * 100.0).to_string() + + "%\n" + out = out + + " Turn (T): " + + (t_count.to_double() / total * 100.0).to_string() + + "%\n" + out = out + + " Coil (C): " + + (c_count.to_double() / total * 100.0).to_string() + + "%\n" out } diff --git a/src/proteomics.mbt b/src/proteomics.mbt index 80ded23b..e0bc3fdd 100644 --- a/src/proteomics.mbt +++ b/src/proteomics.mbt @@ -39,75 +39,86 @@ pub struct DigestResult { } ///| -let average_weights : Map[String, Double] = Map([ - ("A", 89.0935), - ("R", 174.2017), - ("N", 132.1184), - ("D", 133.1032), - ("C", 121.1590), - ("E", 147.1299), - ("Q", 146.1451), - ("G", 75.0669), - ("H", 155.1552), - ("I", 131.1736), - ("L", 131.1736), - ("K", 146.1882), - ("M", 149.2124), - ("F", 165.1900), - ("P", 115.1310), - ("S", 105.0930), - ("T", 119.1197), - ("W", 204.2262), - ("Y", 181.1894), - ("V", 117.1469), -], capacity=20) +let average_weights : Map[String, Double] = Map( + [ + ("A", 89.0935), + ("R", 174.2017), + ("N", 132.1184), + ("D", 133.1032), + ("C", 121.1590), + ("E", 147.1299), + ("Q", 146.1451), + ("G", 75.0669), + ("H", 155.1552), + ("I", 131.1736), + ("L", 131.1736), + ("K", 146.1882), + ("M", 149.2124), + ("F", 165.1900), + ("P", 115.1310), + ("S", 105.0930), + ("T", 119.1197), + ("W", 204.2262), + ("Y", 181.1894), + ("V", 117.1469), + ], + capacity=20, +) ///| -let monoisotopic_weights : Map[String, Double] = Map([ - ("A", 71.03711), - ("R", 156.10111), - ("N", 114.04293), - ("D", 115.02694), - ("C", 103.00919), - ("E", 129.04259), - ("Q", 128.05858), - ("G", 57.02146), - ("H", 137.05891), - ("I", 113.08406), - ("L", 113.08406), - ("K", 128.09496), - ("M", 131.04049), - ("F", 147.06841), - ("P", 97.05276), - ("S", 87.03203), - ("T", 101.04768), - ("W", 186.07931), - ("Y", 163.06333), - ("V", 99.06841), -], capacity=20) +let monoisotopic_weights : Map[String, Double] = Map( + [ + ("A", 71.03711), + ("R", 156.10111), + ("N", 114.04293), + ("D", 115.02694), + ("C", 103.00919), + ("E", 129.04259), + ("Q", 128.05858), + ("G", 57.02146), + ("H", 137.05891), + ("I", 113.08406), + ("L", 113.08406), + ("K", 128.09496), + ("M", 131.04049), + ("F", 147.06841), + ("P", 97.05276), + ("S", 87.03203), + ("T", 101.04768), + ("W", 186.07931), + ("Y", 163.06333), + ("V", 99.06841), + ], + capacity=20, +) ///| let water_mono : Double = 18.010565 + +///| let water_avg : Double = 18.01524 ///| let proton_mass : Double = 1.007276 ///| -let enzyme_data : Map[String, (String, Bool, String)] = Map([ - ("trypsin", ("KR", false, "P")), - ("chymotrypsin", ("FYWML", false, "P")), - ("chymotrypsin_high_specificity", ("FYW", false, "P")), - ("chymotrypsin_low_specificity", ("FYWML", false, "P")), - ("pepsin_ph2", ("FL", false, "")), - ("pepsin_ph1.3", ("FL", false, "")), - ("lysc", ("K", false, "P")), - ("argc", ("R", false, "P")), - ("cnbr", ("M", false, "")), - ("gluc", ("DE", false, "")), - ("aspn", ("D", true, "")), - ("aspn_nterm", ("D", true, "")), -], capacity=15) +let enzyme_data : Map[String, (String, Bool, String)] = Map( + [ + ("trypsin", ("KR", false, "P")), + ("chymotrypsin", ("FYWML", false, "P")), + ("chymotrypsin_high_specificity", ("FYW", false, "P")), + ("chymotrypsin_low_specificity", ("FYWML", false, "P")), + ("pepsin_ph2", ("FL", false, "")), + ("pepsin_ph1.3", ("FL", false, "")), + ("lysc", ("K", false, "P")), + ("argc", ("R", false, "P")), + ("cnbr", ("M", false, "")), + ("gluc", ("DE", false, "")), + ("aspn", ("D", true, "")), + ("aspn_nterm", ("D", true, "")), + ], + capacity=15, +) ///| pub fn proteomics_select_enzyme(name : String) -> CleavageAgent? { @@ -118,17 +129,10 @@ pub fn proteomics_select_enzyme(name : String) -> CleavageAgent? { let mut i = 0 while i < residues.length() { let r = residues[i:i + 1].to_owned() - sites.push(CleavageSite::{ - position: 0, - residue: r, - probability: 1.0, - }) + sites.push(CleavageSite::{ position: 0, residue: r, probability: 1.0 }) i = i + 1 } - Some(CleavageAgent::{ - name: key, - cleavage_sites: sites, - }) + Some(CleavageAgent::{ name: key, cleavage_sites: sites }) } None => None } @@ -163,13 +167,11 @@ pub fn proteomics_cleavage_sites( sites.push(i) } } - } else { - if i < seq.length() - 1 { - let next = seq[i + 1:i + 2].to_owned() - let is_except = proteomics_contains_char(except, next) - if !is_except { - sites.push(i + 1) - } + } else if i < seq.length() - 1 { + let next = seq[i + 1:i + 2].to_owned() + let is_except = proteomics_contains_char(except, next) + if !is_except { + sites.push(i + 1) } } } @@ -183,7 +185,10 @@ pub fn proteomics_cleavage_sites( } ///| -pub fn proteomics_digest(protein_sequence : String, enzyme : String) -> DigestResult { +pub fn proteomics_digest( + protein_sequence : String, + enzyme : String, +) -> DigestResult { let seq = protein_sequence.to_upper() let sites = proteomics_cleavage_sites(seq, enzyme) @@ -282,8 +287,10 @@ pub fn proteomics_trypsin_digest( let n_peptides = starts.length() let max_missed = if missed_cleavages < n_peptides - 1 { missed_cleavages + } else if n_peptides > 1 { + n_peptides - 1 } else { - if n_peptides > 1 { n_peptides - 1 } else { 0 } + 0 } let mut mc = 1 @@ -317,7 +324,10 @@ pub fn proteomics_trypsin_digest( } ///| -pub fn proteomics_calculate_mass(peptide : String, is_monoisotopic : Bool) -> Double { +pub fn proteomics_calculate_mass( + peptide : String, + is_monoisotopic : Bool, +) -> Double { let seq = peptide.to_upper() if seq.length() == 0 { return 0.0 @@ -351,11 +361,22 @@ pub fn proteomics_molecular_weight(peptide : String) -> Double { } ///| -pub fn proteomics_isotope_pattern(peptide : String, charge : Int) -> IsotopePattern { +pub fn proteomics_isotope_pattern( + peptide : String, + charge : Int, +) -> IsotopePattern { let seq = peptide.to_upper() let n = seq.length() - let num_peaks = if n < 5 { 3 } else { if n < 15 { 4 } else { if n < 30 { 5 } else { 6 } } } + let num_peaks = if n < 5 { + 3 + } else if n < 15 { + 4 + } else if n < 30 { + 5 + } else { + 6 + } let mono_mass = proteomics_calculate_mass(seq, true) let avg_mass = proteomics_calculate_mass(seq, false) @@ -363,13 +384,17 @@ pub fn proteomics_isotope_pattern(peptide : String, charge : Int) -> IsotopePatt let masses : Array[Double] = Array::new() let abundances : Array[Double] = Array::new() - let delta_mass = if n > 0 { (avg_mass - mono_mass) / n.to_double() } else { 1.0 } + let delta_mass = if n > 0 { + (avg_mass - mono_mass) / n.to_double() + } else { + 1.0 + } let mut i = 0 while i < num_peaks { - let mass = mono_mass + (delta_mass * i.to_double()) + let mass = mono_mass + delta_mass * i.to_double() let m = if charge > 0 { - (mass / charge.to_double()) + proton_mass + mass / charge.to_double() + proton_mass } else { mass } @@ -387,15 +412,14 @@ pub fn proteomics_isotope_pattern(peptide : String, charge : Int) -> IsotopePatt j = j + 1 } - IsotopePattern::{ - masses, - abundances: normalized, - charge, - } + IsotopePattern::{ masses, abundances: normalized, charge } } ///| -fn proteomics_isotope_abundance(peak_index : Int, peptide_length : Int) -> Double { +fn proteomics_isotope_abundance( + peak_index : Int, + peptide_length : Int, +) -> Double { if peptide_length <= 0 { return if peak_index == 0 { 1.0 } else { 0.0 } } @@ -403,7 +427,9 @@ fn proteomics_isotope_abundance(peak_index : Int, peptide_length : Int) -> Doubl let n = peptide_length.to_double() let lambda = n * 0.0107 - let log_p = -lambda + peak_index.to_double() * proteomics_log_approx(lambda) - proteomics_log_factorial(peak_index) + let log_p = -lambda + + peak_index.to_double() * proteomics_log_approx(lambda) - + proteomics_log_factorial(peak_index) if log_p < -50.0 { return 0.0 } @@ -412,7 +438,9 @@ fn proteomics_isotope_abundance(peak_index : Int, peptide_length : Int) -> Doubl ///| fn proteomics_log_factorial(n : Int) -> Double { - if n <= 1 { return 0.0 } + if n <= 1 { + return 0.0 + } let mut result = 0.0 let mut i = 2 while i <= n { @@ -448,7 +476,9 @@ fn proteomics_exp_approx(x : Double) -> Double { ///| fn proteomics_pow_approx(base : Double, exp : Int) -> Double { - if exp <= 0 { return 1.0 } + if exp <= 0 { + return 1.0 + } let mut result = 1.0 let mut b = base let mut e = exp @@ -487,8 +517,10 @@ pub fn proteomics_fragment_ions( let y_avg = proteomics_calculate_mass(y_seq, false) let b_z = if charge > 0 { charge } else { 1 } - let b_ion_mono = (b_mono + (b_z.to_double() - 1.0) * proton_mass) / b_z.to_double() - let b_ion_avg = (b_avg + (b_z.to_double() - 1.0) * proton_mass) / b_z.to_double() + let b_ion_mono = (b_mono + (b_z.to_double() - 1.0) * proton_mass) / + b_z.to_double() + let b_ion_avg = (b_avg + (b_z.to_double() - 1.0) * proton_mass) / + b_z.to_double() frags.push(PeptideMassResult::{ peptide_sequence: "b" + i.to_string(), @@ -498,8 +530,10 @@ pub fn proteomics_fragment_ions( end_position: i, }) - let y_ion_mono = (y_mono + (b_z.to_double() - 1.0) * proton_mass) / b_z.to_double() - let y_ion_avg = (y_avg + (b_z.to_double() - 1.0) * proton_mass) / b_z.to_double() + let y_ion_mono = (y_mono + (b_z.to_double() - 1.0) * proton_mass) / + b_z.to_double() + let y_ion_avg = (y_avg + (b_z.to_double() - 1.0) * proton_mass) / + b_z.to_double() frags.push(PeptideMassResult::{ peptide_sequence: "y" + (n - i).to_string(), @@ -562,4 +596,4 @@ fn proteomics_partition(arr : Array[Int], lo : Int, hi : Int) -> Int { arr[i + 1] = arr[hi] arr[hi] = tmp i + 1 -} \ No newline at end of file +} diff --git a/src/psea.mbt b/src/psea.mbt index 7367ac8c..af1b694e 100644 --- a/src/psea.mbt +++ b/src/psea.mbt @@ -57,7 +57,14 @@ pub struct PseaGeometry { ///| /// Create a new atom. -pub fn PseaAtom::new(res_name : String, res_num : Int, atom_name : String, x : Double, y : Double, z : Double) -> PseaAtom { +pub fn PseaAtom::new( + res_name : String, + res_num : Int, + atom_name : String, + x : Double, + y : Double, + z : Double, +) -> PseaAtom { PseaAtom::{ res_name, res_num, atom_name, x, y, z } } @@ -88,14 +95,25 @@ pub fn psea_bond_angle(a : PseaAtom, b : PseaAtom, c : PseaAtom) -> Double { } let cos_theta = dot / (ba_len * bc_len) // Clamp to avoid numerical issues - let cos_clamped = if cos_theta > 1.0 { 1.0 } else if cos_theta < -1.0 { -1.0 } else { cos_theta } + let cos_clamped = if cos_theta > 1.0 { + 1.0 + } else if cos_theta < -1.0 { + -1.0 + } else { + cos_theta + } // arccos in degrees psea_arccos_deg(cos_clamped) } ///| /// Compute the virtual dihedral angle (in degrees) formed by atoms a-b-c-d. -pub fn psea_dihedral_angle(a : PseaAtom, b : PseaAtom, c : PseaAtom, d : PseaAtom) -> Double { +pub fn psea_dihedral_angle( + a : PseaAtom, + b : PseaAtom, + c : PseaAtom, + d : PseaAtom, +) -> Double { // Vectors b1 = b-a, b2 = c-b, b3 = d-c let b1_x = b.x - a.x let b1_y = b.y - a.y @@ -122,7 +140,13 @@ pub fn psea_dihedral_angle(a : PseaAtom, b : PseaAtom, c : PseaAtom, d : PseaAto } let dot = n1_x * n2_x + n1_y * n2_y + n1_z * n2_z let cos_val = dot / (n1_len * n2_len) - let cos_clamped = if cos_val > 1.0 { 1.0 } else if cos_val < -1.0 { -1.0 } else { cos_val } + let cos_clamped = if cos_val > 1.0 { + 1.0 + } else if cos_val < -1.0 { + -1.0 + } else { + cos_val + } let mut angle = psea_arccos_deg(cos_clamped) // Sign of the dihedral: (n1 x n2) . b2 let sign_vec_x = n1_y * n2_z - n1_z * n2_y @@ -166,13 +190,22 @@ pub fn psea_compute_geometry(ca_atoms : Array[PseaAtom]) -> PseaGeometry { // Bond angles (a-b-c) let mut j = 2 while j < n { - bond_angles.push(psea_bond_angle(ca_atoms[j - 2], ca_atoms[j - 1], ca_atoms[j])) + bond_angles.push( + psea_bond_angle(ca_atoms[j - 2], ca_atoms[j - 1], ca_atoms[j]), + ) j = j + 1 } // Dihedral angles (a-b-c-d) let mut k = 3 while k < n { - dihedral_angles.push(psea_dihedral_angle(ca_atoms[k - 3], ca_atoms[k - 2], ca_atoms[k - 1], ca_atoms[k])) + dihedral_angles.push( + psea_dihedral_angle( + ca_atoms[k - 3], + ca_atoms[k - 2], + ca_atoms[k - 1], + ca_atoms[k], + ), + ) k = k + 1 } PseaGeometry::{ ca_distances, bond_angles, dihedral_angles } @@ -216,7 +249,7 @@ pub fn psea_run(ca_atoms : Array[PseaAtom]) -> PseaResult { confidence, n_helix: 0, n_strand: 0, - n_coil: n + n_coil: n, } } let geom = psea_compute_geometry(ca_atoms) @@ -236,13 +269,25 @@ pub fn psea_run(ca_atoms : Array[PseaAtom]) -> PseaResult { let angle = geom.dihedral_angles[di] let res_idx = di + 1 // Alpha helix: dihedral around -57 to -70 (centered at -60) - let helix_dist = (angle - (-60.0)).abs() - let helix_score = if helix_dist < 30.0 { 1.0 - helix_dist / 30.0 } else { 0.0 } + let helix_dist = (angle - -60.0).abs() + let helix_score = if helix_dist < 30.0 { + 1.0 - helix_dist / 30.0 + } else { + 0.0 + } // Beta strand: dihedral around -120 or +120 - let strand_dist1 = (angle - (-120.0)).abs() + let strand_dist1 = (angle - -120.0).abs() let strand_dist2 = (angle - 120.0).abs() - let strand_dist = if strand_dist1 < strand_dist2 { strand_dist1 } else { strand_dist2 } - let strand_score = if strand_dist < 40.0 { 1.0 - strand_dist / 40.0 } else { 0.0 } + let strand_dist = if strand_dist1 < strand_dist2 { + strand_dist1 + } else { + strand_dist2 + } + let strand_score = if strand_dist < 40.0 { + 1.0 - strand_dist / 40.0 + } else { + 0.0 + } // Apply to residues in the window let mut ri = res_idx - 1 while ri <= res_idx + 1 && ri < n { @@ -304,7 +349,11 @@ pub fn psea_run(ca_atoms : Array[PseaAtom]) -> PseaResult { ///| /// Enforce minimum lengths for helix and strand segments. -fn psea_enforce_min_lengths(ss : Array[String], min_helix : Int, min_strand : Int) -> Unit { +fn psea_enforce_min_lengths( + ss : Array[String], + min_helix : Int, + min_strand : Int, +) -> Unit { let n = ss.length() let mut i = 0 while i < n { @@ -380,10 +429,17 @@ pub fn PseaResult::psea_get_res_name(self : PseaResult, idx : Int) -> String { ///| /// Summary statistics as a string. pub fn PseaResult::psea_summary(self : PseaResult) -> String { - "PSEA: " + self.psea_n_residues().to_string() + " residues, " + - "H=" + self.n_helix.to_string() + " " + - "E=" + self.n_strand.to_string() + " " + - "C=" + self.n_coil.to_string() + "PSEA: " + + self.psea_n_residues().to_string() + + " residues, " + + "H=" + + self.n_helix.to_string() + + " " + + "E=" + + self.n_strand.to_string() + + " " + + "C=" + + self.n_coil.to_string() } // ===== Three-state to eight-state conversion (DSSP-like) ===== @@ -408,13 +464,7 @@ pub fn psea_three_to_eight_state(ss : Array[String]) -> Array[String] { let len = j - i let mut k = i while k < j { - let state = if len <= 3 { - "G" - } else if len >= 12 { - "I" - } else { - "H" - } + let state = if len <= 3 { "G" } else if len >= 12 { "I" } else { "H" } result.push(state) k = k + 1 } @@ -436,7 +486,7 @@ pub fn psea_three_to_eight_state(ss : Array[String]) -> Array[String] { // Coil: try to distinguish T/S/L let prev = if i > 0 { ss[i - 1] } else { "C" } let next = if i + 1 < n { ss[i + 1] } else { "C" } - let state = if (prev == "H" || next == "H") && (prev != next) { + let state = if (prev == "H" || next == "H") && prev != next { "T" } else if prev == "E" || next == "E" { "T" @@ -459,7 +509,10 @@ pub fn psea_create_example_helix() -> Array[PseaAtom] { // Approximate alpha-helix CA coordinates: helix rise ~1.5 Å, radius ~2.3 Å // 100 degrees per residue (3.6 residues per turn) let atoms : Array[PseaAtom] = Array::new() - let names = ["ALA", "GLY", "VAL", "LEU", "SER", "THR", "PHE", "TRP", "TYR", "CYS", "MET", "ILE"] + let names = [ + "ALA", "GLY", "VAL", "LEU", "SER", "THR", "PHE", "TRP", "TYR", "CYS", "MET", + "ILE", + ] let mut i = 0 while i < 12 { let angle = i.to_double() * 100.0 * 3.141592653589793 / 180.0 diff --git a/src/qcp_superimposer.mbt b/src/qcp_superimposer.mbt index 84209e05..66925672 100644 --- a/src/qcp_superimposer.mbt +++ b/src/qcp_superimposer.mbt @@ -16,7 +16,11 @@ pub struct QCPAtomCoordinate { ///| /// Create a new QCPAtomCoordinate. -pub fn QCPAtomCoordinate::new(x : Double, y : Double, z : Double) -> QCPAtomCoordinate { +pub fn QCPAtomCoordinate::new( + x : Double, + y : Double, + z : Double, +) -> QCPAtomCoordinate { QCPAtomCoordinate::{ x, y, z } } @@ -28,7 +32,10 @@ pub fn QCPAtomCoordinate::to_array(self : QCPAtomCoordinate) -> Array[Double] { ///| /// Calculate distance between two atoms. -pub fn QCPAtomCoordinate::distance(self : QCPAtomCoordinate, other : QCPAtomCoordinate) -> Double { +pub fn QCPAtomCoordinate::distance( + self : QCPAtomCoordinate, + other : QCPAtomCoordinate, +) -> Double { let dx = self.x - other.x let dy = self.y - other.y let dz = self.z - other.z @@ -55,20 +62,29 @@ pub fn QCPSuperimposer::new() -> QCPSuperimposer { ///| /// Set the rotation matrix. -pub fn QCPSuperimposer::set_rot(self : QCPSuperimposer, rot : Array[Array[Double]]) -> QCPSuperimposer { - QCPSuperimposer::{ ..self, rot } +pub fn QCPSuperimposer::set_rot( + self : QCPSuperimposer, + rot : Array[Array[Double]], +) -> QCPSuperimposer { + QCPSuperimposer::{ ..self, rot, } } ///| /// Set the translation vector. -pub fn QCPSuperimposer::set_tran(self : QCPSuperimposer, tran : Array[Double]) -> QCPSuperimposer { - QCPSuperimposer::{ ..self, tran } +pub fn QCPSuperimposer::set_tran( + self : QCPSuperimposer, + tran : Array[Double], +) -> QCPSuperimposer { + QCPSuperimposer::{ ..self, tran, } } ///| /// Set the RMSD value. -pub fn QCPSuperimposer::set_rmsd(self : QCPSuperimposer, rmsd : Double) -> QCPSuperimposer { - QCPSuperimposer::{ ..self, rmsd } +pub fn QCPSuperimposer::set_rmsd( + self : QCPSuperimposer, + rmsd : Double, +) -> QCPSuperimposer { + QCPSuperimposer::{ ..self, rmsd, } } ///| @@ -91,39 +107,45 @@ pub fn QCPSuperimposer::get_rmsd(self : QCPSuperimposer) -> Double { ///| /// Calculate the centroid of a set of coordinates. -pub fn calculate_centroid(coords : Array[QCPAtomCoordinate]) -> QCPAtomCoordinate { +pub fn calculate_centroid( + coords : Array[QCPAtomCoordinate], +) -> QCPAtomCoordinate { if coords.length() == 0 { return QCPAtomCoordinate::new(0.0, 0.0, 0.0) } - + let mut sum_x = 0.0 let mut sum_y = 0.0 let mut sum_z = 0.0 - + for coord in coords { sum_x = sum_x + coord.x sum_y = sum_y + coord.y sum_z = sum_z + coord.z } - + let n = coords.length().to_double() QCPAtomCoordinate::new(sum_x / n, sum_y / n, sum_z / n) } ///| /// Center coordinates around centroid. -pub fn center_coordinates(coords : Array[QCPAtomCoordinate]) -> Array[QCPAtomCoordinate] { +pub fn center_coordinates( + coords : Array[QCPAtomCoordinate], +) -> Array[QCPAtomCoordinate] { let centroid = calculate_centroid(coords) - + let result : Array[QCPAtomCoordinate] = Array::new() for coord in coords { - result.push(QCPAtomCoordinate::new( - coord.x - centroid.x, - coord.y - centroid.y, - coord.z - centroid.z - )) + result.push( + QCPAtomCoordinate::new( + coord.x - centroid.x, + coord.y - centroid.y, + coord.z - centroid.z, + ), + ) } - + result } @@ -131,7 +153,7 @@ pub fn center_coordinates(coords : Array[QCPAtomCoordinate]) -> Array[QCPAtomCoo /// Build the correlation matrix. pub fn build_correlation_matrix( fixed : Array[QCPAtomCoordinate], - moving : Array[QCPAtomCoordinate] + moving : Array[QCPAtomCoordinate], ) -> Array[Array[Double]] { let mut c00 = 0.0 let mut c01 = 0.0 @@ -142,7 +164,7 @@ pub fn build_correlation_matrix( let mut c20 = 0.0 let mut c21 = 0.0 let mut c22 = 0.0 - + let len = fixed.length() let mut i = 0 while i < len { @@ -157,7 +179,7 @@ pub fn build_correlation_matrix( c22 = c22 + fixed[i].z * moving[i].z i = i + 1 } - + [[c00, c01, c02], [c10, c11, c12], [c20, c21, c22]] } @@ -183,54 +205,82 @@ pub fn build_qcp_matrix(c : Array[Array[Double]]) -> Array[Array[Double]] { let q01 = c[1][2] - c[2][1] let q02 = c[2][0] - c[0][2] let q03 = c[0][1] - c[1][0] - + let q10 = q01 let q11 = c[0][0] - c[1][1] - c[2][2] let q12 = c[0][1] + c[1][0] let q13 = c[0][2] + c[2][0] - + let q20 = q02 let q21 = q12 let q22 = -c[0][0] + c[1][1] - c[2][2] let q23 = c[1][2] + c[2][1] - + let q30 = q03 let q31 = q13 let q32 = q23 let q33 = -c[0][0] - c[1][1] + c[2][2] - - [[q00, q01, q02, q03], [q10, q11, q12, q13], [q20, q21, q22, q23], [q30, q31, q32, q33]] + + [ + [q00, q01, q02, q03], + [q10, q11, q12, q13], + [q20, q21, q22, q23], + [q30, q31, q32, q33], + ] } ///| /// Solve the quartic equation and find the maximum real root. pub fn solve_quartic(q : Array[Array[Double]]) -> Double { let a = -q[0][0] - q[1][1] - q[2][2] - q[3][3] - + let b1 = q[0][0] * q[1][1] + q[0][0] * q[2][2] + q[0][0] * q[3][3] let b2 = q[1][1] * q[2][2] + q[1][1] * q[3][3] + q[2][2] * q[3][3] let b3 = q[0][1] * q[1][0] + q[0][2] * q[2][0] + q[0][3] * q[3][0] let b4 = q[1][2] * q[2][1] + q[1][3] * q[3][1] + q[2][3] * q[3][2] let b = b1 + b2 - b3 - b4 - - let c1 = q[0][0] * q[1][1] * q[2][2] + q[0][0] * q[1][1] * q[3][3] + q[0][0] * q[2][2] * q[3][3] + q[1][1] * q[2][2] * q[3][3] - let c2 = q[0][0] * q[1][2] * q[2][1] + q[0][0] * q[1][3] * q[3][1] + q[0][0] * q[2][3] * q[3][2] - let c3 = q[1][1] * q[0][2] * q[2][0] + q[1][1] * q[0][3] * q[3][0] + q[1][1] * q[2][3] * q[3][2] - let c4 = q[2][2] * q[0][1] * q[1][0] + q[2][2] * q[0][3] * q[3][0] + q[2][2] * q[1][3] * q[3][1] - let c5 = q[3][3] * q[0][1] * q[1][0] + q[3][3] * q[0][2] * q[2][0] + q[3][3] * q[1][2] * q[2][1] - let c6 = q[0][1] * q[1][2] * q[2][0] + q[0][1] * q[1][3] * q[3][0] + q[0][2] * q[2][3] * q[3][0] - let c7 = q[1][2] * q[2][3] * q[3][1] + q[0][1] * q[2][1] * q[1][0] + q[0][2] * q[3][2] * q[2][0] + q[1][3] * q[3][1] * q[1][0] - let c = -(c1) + c2 + c3 + c4 + c5 - c6 - c7 - + + let c1 = q[0][0] * q[1][1] * q[2][2] + + q[0][0] * q[1][1] * q[3][3] + + q[0][0] * q[2][2] * q[3][3] + + q[1][1] * q[2][2] * q[3][3] + let c2 = q[0][0] * q[1][2] * q[2][1] + + q[0][0] * q[1][3] * q[3][1] + + q[0][0] * q[2][3] * q[3][2] + let c3 = q[1][1] * q[0][2] * q[2][0] + + q[1][1] * q[0][3] * q[3][0] + + q[1][1] * q[2][3] * q[3][2] + let c4 = q[2][2] * q[0][1] * q[1][0] + + q[2][2] * q[0][3] * q[3][0] + + q[2][2] * q[1][3] * q[3][1] + let c5 = q[3][3] * q[0][1] * q[1][0] + + q[3][3] * q[0][2] * q[2][0] + + q[3][3] * q[1][2] * q[2][1] + let c6 = q[0][1] * q[1][2] * q[2][0] + + q[0][1] * q[1][3] * q[3][0] + + q[0][2] * q[2][3] * q[3][0] + let c7 = q[1][2] * q[2][3] * q[3][1] + + q[0][1] * q[2][1] * q[1][0] + + q[0][2] * q[3][2] * q[2][0] + + q[1][3] * q[3][1] * q[1][0] + let c = -c1 + c2 + c3 + c4 + c5 - c6 - c7 + let d1 = q[0][0] * q[1][1] * q[2][2] * q[3][3] - let d2 = q[0][1] * q[1][2] * q[2][3] * q[3][0] + q[0][2] * q[1][3] * q[2][0] * q[3][1] + q[0][3] * q[1][0] * q[2][1] * q[3][2] - let d3 = q[0][3] * q[1][2] * q[2][1] * q[3][0] + q[0][2] * q[1][1] * q[2][3] * q[3][0] + q[0][1] * q[1][3] * q[2][0] * q[3][1] - let d4 = q[0][0] * q[1][2] * q[2][3] * q[3][1] + q[0][3] * q[1][1] * q[2][0] * q[3][2] + q[0][2] * q[1][0] * q[2][1] * q[3][2] - let d5 = q[0][1] * q[1][0] * q[2][3] * q[3][2] + q[0][0] * q[1][3] * q[2][1] * q[3][2] + let d2 = q[0][1] * q[1][2] * q[2][3] * q[3][0] + + q[0][2] * q[1][3] * q[2][0] * q[3][1] + + q[0][3] * q[1][0] * q[2][1] * q[3][2] + let d3 = q[0][3] * q[1][2] * q[2][1] * q[3][0] + + q[0][2] * q[1][1] * q[2][3] * q[3][0] + + q[0][1] * q[1][3] * q[2][0] * q[3][1] + let d4 = q[0][0] * q[1][2] * q[2][3] * q[3][1] + + q[0][3] * q[1][1] * q[2][0] * q[3][2] + + q[0][2] * q[1][0] * q[2][1] * q[3][2] + let d5 = q[0][1] * q[1][0] * q[2][3] * q[3][2] + + q[0][0] * q[1][3] * q[2][1] * q[3][2] let d = d1 + d2 - d3 - d4 - d5 - + let mut max_root = 0.0 - + for i in 0..<100 { let t = i.to_double() * 0.02 - 1.0 let val = t * t * t * t + a * t * t * t + b * t * t + c * t + d @@ -238,57 +288,60 @@ pub fn solve_quartic(q : Array[Array[Double]]) -> Double { max_root = t } } - + max_root } ///| /// Compute the eigenvector corresponding to the maximum eigenvalue. -pub fn compute_eigenvector(q : Array[Array[Double]], lambda : Double) -> Array[Double] { +pub fn compute_eigenvector( + q : Array[Array[Double]], + lambda : Double, +) -> Array[Double] { let m00 = q[0][0] - lambda let m01 = q[0][1] let m02 = q[0][2] let m03 = q[0][3] - + let m10 = q[1][0] let m11 = q[1][1] - lambda let m12 = q[1][2] let m13 = q[1][3] - + let m20 = q[2][0] let m21 = q[2][1] let m22 = q[2][2] - lambda let m23 = q[2][3] - + let m30 = q[3][0] let m31 = q[3][1] let m32 = q[3][2] let m33 = q[3][3] - lambda - + let mut v0 = 1.0 let mut v1 = 0.0 let mut v2 = 0.0 let mut v3 = 0.0 - + let mut iter = 0 while iter < 50 { let nv0 = m00 * v0 + m01 * v1 + m02 * v2 + m03 * v3 let nv1 = m10 * v0 + m11 * v1 + m12 * v2 + m13 * v3 let nv2 = m20 * v0 + m21 * v1 + m22 * v2 + m23 * v3 let nv3 = m30 * v0 + m31 * v1 + m32 * v2 + m33 * v3 - + let norm = (nv0 * nv0 + nv1 * nv1 + nv2 * nv2 + nv3 * nv3).sqrt() - + if norm > 0.000001 { v0 = nv0 / norm v1 = nv1 / norm v2 = nv2 / norm v3 = nv3 / norm } - + iter = iter + 1 } - + [v0, v1, v2, v3] } @@ -330,8 +383,7 @@ fn qcp_largest_eigenvector(q : Array[Array[Double]]) -> Array[Double] { } let diagonal_difference = matrix[pivot_column][pivot_column] - matrix[pivot_row][pivot_row] - let ratio = diagonal_difference / - (2.0 * matrix[pivot_row][pivot_column]) + let ratio = diagonal_difference / (2.0 * matrix[pivot_row][pivot_column]) let tangent = if ratio >= 0.0 { 1.0 / (ratio + (1.0 + ratio * ratio).sqrt()) } else { @@ -343,8 +395,7 @@ fn qcp_largest_eigenvector(q : Array[Array[Double]]) -> Array[Double] { let row_diagonal = matrix[pivot_row][pivot_row] let column_diagonal = matrix[pivot_column][pivot_column] matrix[pivot_row][pivot_row] = row_diagonal - tangent * pivot_value - matrix[pivot_column][pivot_column] = column_diagonal + - tangent * pivot_value + matrix[pivot_column][pivot_column] = column_diagonal + tangent * pivot_value matrix[pivot_row][pivot_column] = 0.0 matrix[pivot_column][pivot_row] = 0.0 let mut index = 0 @@ -362,8 +413,7 @@ fn qcp_largest_eigenvector(q : Array[Array[Double]]) -> Array[Double] { let vector_row = vectors[index][pivot_row] let vector_column = vectors[index][pivot_column] vectors[index][pivot_row] = cosine * vector_row - sine * vector_column - vectors[index][pivot_column] = sine * vector_row + - cosine * vector_column + vectors[index][pivot_column] = sine * vector_row + cosine * vector_column index = index + 1 } sweep = sweep + 1 @@ -391,7 +441,7 @@ pub fn quaternion_to_rotation(q : Array[Double]) -> Array[Array[Double]] { let x = q[1] let y = q[2] let z = q[3] - + let ww = w * w let xx = x * x let yy = y * y @@ -402,21 +452,21 @@ pub fn quaternion_to_rotation(q : Array[Double]) -> Array[Array[Double]] { let xy = x * y let xz = x * z let yz = y * z - + let rot = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] - + rot[0][0] = ww + xx - yy - zz rot[0][1] = 2.0 * (xy - wz) rot[0][2] = 2.0 * (xz + wy) - + rot[1][0] = 2.0 * (xy + wz) rot[1][1] = ww - xx + yy - zz rot[1][2] = 2.0 * (yz - wx) - + rot[2][0] = 2.0 * (xz - wy) rot[2][1] = 2.0 * (yz + wx) rot[2][2] = ww - xx - yy + zz - + rot } @@ -426,29 +476,29 @@ pub fn qcp_calculate_rmsd( fixed : Array[QCPAtomCoordinate], moving : Array[QCPAtomCoordinate], rot : Array[Array[Double]], - tran : Array[Double] + tran : Array[Double], ) -> Double { let mut sum_sq = 0.0 let len = fixed.length() - + let mut i = 0 while i < len { let mx = moving[i].x let my = moving[i].y let mz = moving[i].z - + let rx = rot[0][0] * mx + rot[0][1] * my + rot[0][2] * mz + tran[0] let ry = rot[1][0] * mx + rot[1][1] * my + rot[1][2] * mz + tran[1] let rz = rot[2][0] * mx + rot[2][1] * my + rot[2][2] * mz + tran[2] - + let dx = fixed[i].x - rx let dy = fixed[i].y - ry let dz = fixed[i].z - rz - + sum_sq = sum_sq + dx * dx + dy * dy + dz * dz i = i + 1 } - + (sum_sq / len.to_double()).sqrt() } @@ -456,69 +506,106 @@ pub fn qcp_calculate_rmsd( /// Set the coordinates for superposition. /// fixed: reference structure coordinates /// moving: structure to be aligned coordinates -pub fn QCPSuperimposer::set(self : QCPSuperimposer, fixed : Array[QCPAtomCoordinate], moving : Array[QCPAtomCoordinate]) -> QCPSuperimposer { +pub fn QCPSuperimposer::set( + self : QCPSuperimposer, + fixed : Array[QCPAtomCoordinate], + moving : Array[QCPAtomCoordinate], +) -> QCPSuperimposer { if fixed.length() != moving.length() { return self } - + if fixed.length() == 0 { return self.set_rmsd(0.0) } - + let fixed_centered = center_coordinates(fixed) let moving_centered = center_coordinates(moving) - + let centroid_fixed = calculate_centroid(fixed) let centroid_moving = calculate_centroid(moving) - + let c = build_correlation_matrix(moving_centered, fixed_centered) let q = build_qcp_matrix(c) let eigenvec = qcp_largest_eigenvector(q) - + let rot = quaternion_to_rotation(eigenvec) - - let t0 = rot[0][0] * centroid_moving.x + rot[0][1] * centroid_moving.y + rot[0][2] * centroid_moving.z - let t1 = rot[1][0] * centroid_moving.x + rot[1][1] * centroid_moving.y + rot[1][2] * centroid_moving.z - let t2 = rot[2][0] * centroid_moving.x + rot[2][1] * centroid_moving.y + rot[2][2] * centroid_moving.z - - let tran = [centroid_fixed.x - t0, centroid_fixed.y - t1, centroid_fixed.z - t2] - + + let t0 = rot[0][0] * centroid_moving.x + + rot[0][1] * centroid_moving.y + + rot[0][2] * centroid_moving.z + let t1 = rot[1][0] * centroid_moving.x + + rot[1][1] * centroid_moving.y + + rot[1][2] * centroid_moving.z + let t2 = rot[2][0] * centroid_moving.x + + rot[2][1] * centroid_moving.y + + rot[2][2] * centroid_moving.z + + let tran = [ + centroid_fixed.x - t0, + centroid_fixed.y - t1, + centroid_fixed.z - t2, + ] + let rmsd = qcp_calculate_rmsd(fixed, moving, rot, tran) - + QCPSuperimposer::{ rot, tran, rmsd } } ///| /// Apply rotation and translation to coordinates. -pub fn QCPSuperimposer::apply(self : QCPSuperimposer, coords : Array[QCPAtomCoordinate]) -> Array[QCPAtomCoordinate] { +pub fn QCPSuperimposer::apply( + self : QCPSuperimposer, + coords : Array[QCPAtomCoordinate], +) -> Array[QCPAtomCoordinate] { let result : Array[QCPAtomCoordinate] = Array::new() - + let mut i = 0 while i < coords.length() { let coord = coords[i] - let x = self.rot[0][0] * coord.x + self.rot[0][1] * coord.y + self.rot[0][2] * coord.z + self.tran[0] - let y = self.rot[1][0] * coord.x + self.rot[1][1] * coord.y + self.rot[1][2] * coord.z + self.tran[1] - let z = self.rot[2][0] * coord.x + self.rot[2][1] * coord.y + self.rot[2][2] * coord.z + self.tran[2] + let x = self.rot[0][0] * coord.x + + self.rot[0][1] * coord.y + + self.rot[0][2] * coord.z + + self.tran[0] + let y = self.rot[1][0] * coord.x + + self.rot[1][1] * coord.y + + self.rot[1][2] * coord.z + + self.tran[1] + let z = self.rot[2][0] * coord.x + + self.rot[2][1] * coord.y + + self.rot[2][2] * coord.z + + self.tran[2] result.push(QCPAtomCoordinate::new(x, y, z)) i = i + 1 } - + result } ///| /// Bio API functions. - -pub fn bio_qcp_superimpose(fixed : Array[QCPAtomCoordinate], moving : Array[QCPAtomCoordinate]) -> QCPSuperimposer { +pub fn bio_qcp_superimpose( + fixed : Array[QCPAtomCoordinate], + moving : Array[QCPAtomCoordinate], +) -> QCPSuperimposer { QCPSuperimposer::new().set(fixed, moving) } -pub fn bio_qcp_calculate_rmsd(fixed : Array[QCPAtomCoordinate], moving : Array[QCPAtomCoordinate]) -> Double { +///| +pub fn bio_qcp_calculate_rmsd( + fixed : Array[QCPAtomCoordinate], + moving : Array[QCPAtomCoordinate], +) -> Double { let superimposer = bio_qcp_superimpose(fixed, moving) superimposer.get_rmsd() } -pub fn bio_qcp_apply_transform(coords : Array[QCPAtomCoordinate], rot : Array[Array[Double]], tran : Array[Double]) -> Array[QCPAtomCoordinate] { +///| +pub fn bio_qcp_apply_transform( + coords : Array[QCPAtomCoordinate], + rot : Array[Array[Double]], + tran : Array[Double], +) -> Array[QCPAtomCoordinate] { let superimposer = QCPSuperimposer::new().set_rot(rot).set_tran(tran) superimposer.apply(coords) } diff --git a/src/qfeatures.mbt b/src/qfeatures.mbt index 0cba1fc5..ff7e786c 100644 --- a/src/qfeatures.mbt +++ b/src/qfeatures.mbt @@ -237,7 +237,9 @@ pub fn QfAssay::col_sums(self : QfAssay) -> Array[Double] { /// String representation of the assay. pub fn QfAssay::to_string(self : QfAssay) -> String { let buf = StringBuilder::new() - buf.write_string("QfAssay '\{self.name}': \{self.n_rows} rows x \{self.n_cols} cols") + buf.write_string( + "QfAssay '\{self.name}': \{self.n_rows} rows x \{self.n_cols} cols", + ) if self.n_rows > 0 && self.n_cols > 0 { buf.write_string("\n data[0][0] = \{self.data[0][0]}") } @@ -295,7 +297,10 @@ pub fn QfFeatureLinks::new() -> QfFeatureLinks { ///| /// Add a link to the collection. -pub fn QfFeatureLinks::add_link(self : QfFeatureLinks, link : QfFeatureLink) -> Unit { +pub fn QfFeatureLinks::add_link( + self : QfFeatureLinks, + link : QfFeatureLink, +) -> Unit { self.links.push(link) } @@ -344,11 +349,7 @@ pub fn QfFeatureLinks::get_links_to( ///| /// Construct an empty QFeatures. pub fn QFeatures::new() -> QFeatures { - QFeatures::{ - assays: Array::new(), - links: QfFeatureLinks::new(), - n_assays: 0, - } + QFeatures::{ assays: Array::new(), links: QfFeatureLinks::new(), n_assays: 0 } } ///| @@ -406,7 +407,9 @@ pub fn QFeatures::add_link( to_assay : String, to_row : Int, ) -> Unit { - self.links.add_link(QfFeatureLink::new(from_assay, from_row, to_assay, to_row)) + self.links.add_link( + QfFeatureLink::new(from_assay, from_row, to_assay, to_row), + ) } ///| @@ -437,10 +440,12 @@ pub fn qf_is_na(val : Double) -> Bool { val != val } +///| fn qf_infinity() -> Double { 1.7976931348623157e+308 } +///| /// Compute the median of an array (sorts a copy, does not modify input). fn qf_median(values : Array[Double]) -> Double { let n = values.length() @@ -452,7 +457,13 @@ fn qf_median(values : Array[Double]) -> Double { sorted.push(v) } sorted.sort_by(fn(a : Double, b : Double) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) let mid = n / 2 if n % 2 == 0 { @@ -462,6 +473,7 @@ fn qf_median(values : Array[Double]) -> Double { } } +///| /// Aggregate a list of values using the specified method (skipping NaN). fn qf_aggregate_values(values : Array[Double], method : String) -> Double { let clean : Array[Double] = Array::new() @@ -508,6 +520,7 @@ fn qf_aggregate_values(values : Array[Double], method : String) -> Double { } } +///| /// Euclidean distance between two rows on shared non-NaN columns. fn qf_row_distance(a : Array[Double], b : Array[Double]) -> Double { let n = a.length() @@ -527,6 +540,7 @@ fn qf_row_distance(a : Array[Double], b : Array[Double]) -> Double { } } +///| /// Deep-copy a data matrix. fn qf_copy_matrix(data : Array[Array[Double]]) -> Array[Array[Double]] { let nr = data.length() @@ -822,12 +836,9 @@ pub fn qf_filter_features( } } if keep_link { - new_links.add_link(QfFeatureLink::new( - l.from_assay, - new_from_row, - l.to_assay, - new_to_row, - )) + new_links.add_link( + QfFeatureLink::new(l.from_assay, new_from_row, l.to_assay, new_to_row), + ) } } QFeatures::{ @@ -901,11 +912,7 @@ pub fn qf_filter_na( na_count = na_count + 1 } } - let frac = if nc > 0 { - na_count.to_double() / nc.to_double() - } else { - 0.0 - } + let frac = if nc > 0 { na_count.to_double() / nc.to_double() } else { 0.0 } if frac <= max_na_frac { keep_rows.push(i) } @@ -961,7 +968,13 @@ pub fn qf_normalize_quantiles(assay : QfAssay) -> QfAssay { for j in 0.. Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) sorted_cols.push(col) } @@ -986,7 +999,13 @@ pub fn qf_normalize_quantiles(assay : QfAssay) -> QfAssay { pairs.push((i, assay.data[i][j])) } pairs.sort_by(fn(a : (Int, Double), b : (Int, Double)) -> Int { - if a.1 < b.1 { -1 } else if a.1 > b.1 { 1 } else { 0 } + if a.1 < b.1 { + -1 + } else if a.1 > b.1 { + 1 + } else { + 0 + } }) for rank in 0.. 1 { - (ss / (c - 1).to_double()).sqrt() - } else { - 1.0 - } + let std = if c > 1 { (ss / (c - 1).to_double()).sqrt() } else { 1.0 } let denom = if scale && std > 0.0 { std } else { 1.0 } for i in 0.. QfAssay { } // Sort by distance (ascending). pairs.sort_by(fn(a : (Int, Double), b : (Int, Double)) -> Int { - if a.1 < b.1 { -1 } else if a.1 > b.1 { 1 } else { 0 } + if a.1 < b.1 { + -1 + } else if a.1 > b.1 { + 1 + } else { + 0 + } }) let actual_k = if k < pairs.length() { k } else { pairs.length() } // Impute each NaN position. @@ -1283,7 +1304,9 @@ pub fn qf_summary(qf : QFeatures) -> String { pub fn qf_assay_summary(assay : QfAssay) -> String { let buf = StringBuilder::new() buf.write_string("QfAssay Summary: '\{assay.name}'\n") - buf.write_string(" Dimensions: \{assay.n_rows} rows x \{assay.n_cols} cols\n") + buf.write_string( + " Dimensions: \{assay.n_rows} rows x \{assay.n_cols} cols\n", + ) // Collect non-NaN values for statistics. let all_vals : Array[Double] = Array::new() for i in 0.. QValueResult { - QValueResult::{ - p_values, - q_values, - pi0, - lambda, - gamma, - significance, - } + QValueResult::{ p_values, q_values, pi0, lambda, gamma, significance } } ///| @@ -173,10 +166,8 @@ fn _compute_pi0_for_lambda(p_values : Array[Double], lambda : Double) -> Double /// Grid: 0.05, 0.10, ..., 0.95 fn _choose_lambda(p_values : Array[Double]) -> Double { let lambdas = [ - 0.05, 0.10, 0.15, 0.20, 0.25, - 0.30, 0.35, 0.40, 0.45, 0.50, - 0.55, 0.60, 0.65, 0.70, 0.75, - 0.80, 0.85, 0.90, 0.95, + 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.50, 0.55, 0.60, 0.65, + 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, ] let n = p_values.length() if n == 0 { @@ -242,7 +233,11 @@ fn _compute_qvalues(p_values : Array[Double], pi0 : Double) -> Array[Double] { } if n == 1 { let q = p_values[0] * pi0 - if q > 1.0 { [1.0] } else { [q] } + if q > 1.0 { + [1.0] + } else { + [q] + } } else { let indexed : Array[Array[Double]] = Array::new() let mut i = 0 @@ -252,7 +247,13 @@ fn _compute_qvalues(p_values : Array[Double], pi0 : Double) -> Array[Double] { } indexed.sort_by(fn(a : Array[Double], b : Array[Double]) -> Int { - if a[0] < b[0] { -1 } else if a[0] > b[0] { 1 } else { 0 } + if a[0] < b[0] { + -1 + } else if a[0] > b[0] { + 1 + } else { + 0 + } }) let q_sorted : Array[Double] = Array::make(n, 1.0) @@ -283,7 +284,10 @@ fn _compute_qvalues(p_values : Array[Double], pi0 : Double) -> Array[Double] { ///| /// Compute significance boolean array from q-values at a given threshold. -fn _compute_significance(q_values : Array[Double], threshold : Double) -> Array[Bool] { +fn _compute_significance( + q_values : Array[Double], + threshold : Double, +) -> Array[Bool] { let n = q_values.length() let result : Array[Bool] = Array::make(n, false) let mut i = 0 @@ -471,4 +475,4 @@ pub fn qvalue_significance( threshold : Double, ) -> Array[Bool] { _compute_significance(result.q_values, threshold) -} \ No newline at end of file +} diff --git a/src/ragged_experiment.mbt b/src/ragged_experiment.mbt index 516e62c8..ba770792 100644 --- a/src/ragged_experiment.mbt +++ b/src/ragged_experiment.mbt @@ -27,22 +27,39 @@ pub enum MutationType { ///| /// Create a missense mutation type. -pub fn mutation_missense() -> MutationType { MutationType::Missense_Mutation } +pub fn mutation_missense() -> MutationType { + MutationType::Missense_Mutation +} + ///| /// Create a nonsense mutation type. -pub fn mutation_nonsense() -> MutationType { MutationType::Nonsense_Mutation } +pub fn mutation_nonsense() -> MutationType { + MutationType::Nonsense_Mutation +} + ///| /// Create a frameshift insertion mutation type. -pub fn mutation_fs_ins() -> MutationType { MutationType::Frame_Shift_Ins } +pub fn mutation_fs_ins() -> MutationType { + MutationType::Frame_Shift_Ins +} + ///| /// Create a frameshift deletion mutation type. -pub fn mutation_fs_del() -> MutationType { MutationType::Frame_Shift_Del } +pub fn mutation_fs_del() -> MutationType { + MutationType::Frame_Shift_Del +} + ///| /// Create a splice site mutation type. -pub fn mutation_splice_site() -> MutationType { MutationType::Splice_Site } +pub fn mutation_splice_site() -> MutationType { + MutationType::Splice_Site +} + ///| /// Create a silent mutation type. -pub fn mutation_silent() -> MutationType { MutationType::Silent_Mutation } +pub fn mutation_silent() -> MutationType { + MutationType::Silent_Mutation +} ///| /// Convert mutation type to string. @@ -132,13 +149,27 @@ pub fn MutationRecord::new( ///| /// Get the mutation ID (gene + chrom + pos + ref + alt). pub fn MutationRecord::mutation_id(self : MutationRecord) -> String { - self.gene_symbol + ":" + self.chrom + ":" + self.pos.to_string() + ":" + self.ref_allele + ">" + self.alt_allele + self.gene_symbol + + ":" + + self.chrom + + ":" + + self.pos.to_string() + + ":" + + self.ref_allele + + ">" + + self.alt_allele } ///| /// Get the mutation key for grouping. pub fn MutationRecord::mutation_key(self : MutationRecord) -> String { - self.chrom + ":" + self.pos.to_string() + ":" + self.ref_allele + ">" + self.alt_allele + self.chrom + + ":" + + self.pos.to_string() + + ":" + + self.ref_allele + + ">" + + self.alt_allele } ///| @@ -186,7 +217,9 @@ pub fn RaggedExperiment::new() -> RaggedExperiment { ///| /// Create a RaggedExperiment from mutation records. -pub fn RaggedExperiment::from_records(records~ : Array[MutationRecord]) -> RaggedExperiment { +pub fn RaggedExperiment::from_records( + records~ : Array[MutationRecord], +) -> RaggedExperiment { let exp = RaggedExperiment::new() let mut i = 0 while i < records.length() { @@ -199,7 +232,10 @@ pub fn RaggedExperiment::from_records(records~ : Array[MutationRecord]) -> Ragge ///| /// Add a mutation record to the experiment. -pub fn RaggedExperiment::add_record(self : RaggedExperiment, record : MutationRecord) -> Unit { +pub fn RaggedExperiment::add_record( + self : RaggedExperiment, + record : MutationRecord, +) -> Unit { let mut row_idx = -1 let mut i = 0 while i < self.rownames.length() { @@ -323,7 +359,9 @@ pub fn RaggedExperiment::get_records( ) -> Array[MutationRecord] { let ri = row_index(self, gene) let ci = col_index(self, sample) - if ri < 0 || ci < 0 { return Array::new() } + if ri < 0 || ci < 0 { + return Array::new() + } self.data[ri][ci] } @@ -334,7 +372,9 @@ pub fn RaggedExperiment::get_gene_records( gene~ : String, ) -> Array[MutationRecord] { let ri = row_index(self, gene) - if ri < 0 { return Array::new() } + if ri < 0 { + return Array::new() + } let result : Array[MutationRecord] = Array::new() let mut c = 0 while c < self.colnames.length() { @@ -356,7 +396,9 @@ pub fn RaggedExperiment::get_sample_records( sample~ : String, ) -> Array[MutationRecord] { let ci = col_index(self, sample) - if ci < 0 { return Array::new() } + if ci < 0 { + return Array::new() + } let result : Array[MutationRecord] = Array::new() let mut r = 0 while r < self.rownames.length() { @@ -373,7 +415,9 @@ pub fn RaggedExperiment::get_sample_records( ///| /// Get the mutation count matrix (genes x samples). -pub fn RaggedExperiment::get_count_matrix(self : RaggedExperiment) -> Array[Array[Int]] { +pub fn RaggedExperiment::get_count_matrix( + self : RaggedExperiment, +) -> Array[Array[Int]] { self.counts } @@ -405,7 +449,9 @@ pub fn RaggedExperiment::get_tmb_per_mb( ///| /// Summary statistics: number of genes mutated per sample. -pub fn RaggedExperiment::genes_mutated_per_sample(self : RaggedExperiment) -> Array[Int] { +pub fn RaggedExperiment::genes_mutated_per_sample( + self : RaggedExperiment, +) -> Array[Int] { let n_cols = self.colnames.length() let n_rows = self.rownames.length() let result : Array[Int] = Array::new() @@ -414,7 +460,9 @@ pub fn RaggedExperiment::genes_mutated_per_sample(self : RaggedExperiment) -> Ar let mut count = 0 let mut r = 0 while r < n_rows { - if self.data[r][c].length() > 0 { count = count + 1 } + if self.data[r][c].length() > 0 { + count = count + 1 + } r = r + 1 } result.push(count) @@ -437,7 +485,14 @@ pub fn RaggedExperiment::summary(self : RaggedExperiment) -> String { s = s + "\nPer-sample TMB and mutated genes:" + "\n" let mut i = 0 while i < n_cols { - s = s + " " + self.colnames[i] + ": TMB=" + tmb[i].to_string() + ", mutated_genes=" + genes_mutated[i].to_string() + "\n" + s = s + + " " + + self.colnames[i] + + ": TMB=" + + tmb[i].to_string() + + ", mutated_genes=" + + genes_mutated[i].to_string() + + "\n" i = i + 1 } s @@ -460,7 +515,10 @@ pub fn RaggedExperiment::filter_by_type( let mut keep = false let mut t = 0 while t < types.length() { - if recs[j].mutation_type == types[t] { keep = true; break } + if recs[j].mutation_type == types[t] { + keep = true + break + } t = t + 1 } if keep { @@ -488,7 +546,10 @@ pub fn RaggedExperiment::filter_by_genes( let mut keep = false let mut g = 0 while g < genes.length() { - if self.rownames[r] == genes[g] { keep = true; break } + if self.rownames[r] == genes[g] { + keep = true + break + } g = g + 1 } if keep { @@ -523,7 +584,10 @@ pub fn RaggedExperiment::filter_by_samples( let mut keep = false let mut s = 0 while s < samples.length() { - if self.colnames[c] == samples[s] { keep = true; break } + if self.colnames[c] == samples[s] { + keep = true + break + } s = s + 1 } if keep { @@ -548,34 +612,82 @@ pub fn ragged_sample_data() -> RaggedExperiment { let exp = RaggedExperiment::new() // Sample 1: TP53 missense, KRAS mutation - exp.add_record(MutationRecord::new( - sample_id="Sample1", gene_symbol="TP53", chrom="chr17", pos=7577121, ref_allele="C", alt_allele="T", - mutation_type=MutationType::Missense_Mutation, variant_allele_frequency=0.45, - )) - exp.add_record(MutationRecord::new( - sample_id="Sample1", gene_symbol="KRAS", chrom="chr12", pos=25398284, ref_allele="G", alt_allele="T", - mutation_type=MutationType::Missense_Mutation, variant_allele_frequency=0.32, - )) - exp.add_record(MutationRecord::new( - sample_id="Sample1", gene_symbol="MYC", chrom="chr8", pos=128748315, ref_allele="C", alt_allele="A", - mutation_type=MutationType::Nonsense_Mutation, variant_allele_frequency=0.28, - )) + exp.add_record( + MutationRecord::new( + sample_id="Sample1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + mutation_type=MutationType::Missense_Mutation, + variant_allele_frequency=0.45, + ), + ) + exp.add_record( + MutationRecord::new( + sample_id="Sample1", + gene_symbol="KRAS", + chrom="chr12", + pos=25398284, + ref_allele="G", + alt_allele="T", + mutation_type=MutationType::Missense_Mutation, + variant_allele_frequency=0.32, + ), + ) + exp.add_record( + MutationRecord::new( + sample_id="Sample1", + gene_symbol="MYC", + chrom="chr8", + pos=128748315, + ref_allele="C", + alt_allele="A", + mutation_type=MutationType::Nonsense_Mutation, + variant_allele_frequency=0.28, + ), + ) // Sample 2: TP53 frameshift, EGFR mutation - exp.add_record(MutationRecord::new( - sample_id="Sample2", gene_symbol="TP53", chrom="chr17", pos=7578456, ref_allele="AG", alt_allele="A", - mutation_type=MutationType::Frame_Shift_Del, variant_allele_frequency=0.52, - )) - exp.add_record(MutationRecord::new( - sample_id="Sample2", gene_symbol="EGFR", chrom="chr7", pos=55086714, ref_allele="G", alt_allele="A", - mutation_type=MutationType::Missense_Mutation, variant_allele_frequency=0.38, - )) + exp.add_record( + MutationRecord::new( + sample_id="Sample2", + gene_symbol="TP53", + chrom="chr17", + pos=7578456, + ref_allele="AG", + alt_allele="A", + mutation_type=MutationType::Frame_Shift_Del, + variant_allele_frequency=0.52, + ), + ) + exp.add_record( + MutationRecord::new( + sample_id="Sample2", + gene_symbol="EGFR", + chrom="chr7", + pos=55086714, + ref_allele="G", + alt_allele="A", + mutation_type=MutationType::Missense_Mutation, + variant_allele_frequency=0.38, + ), + ) // Sample 3: KRAS mutation only - exp.add_record(MutationRecord::new( - sample_id="Sample3", gene_symbol="KRAS", chrom="chr12", pos=25398284, ref_allele="G", alt_allele="C", - mutation_type=MutationType::Missense_Mutation, variant_allele_frequency=0.41, - )) + exp.add_record( + MutationRecord::new( + sample_id="Sample3", + gene_symbol="KRAS", + chrom="chr12", + pos=25398284, + ref_allele="G", + alt_allele="C", + mutation_type=MutationType::Missense_Mutation, + variant_allele_frequency=0.41, + ), + ) exp.recalculate() exp @@ -583,19 +695,25 @@ pub fn ragged_sample_data() -> RaggedExperiment { // --- Helper functions --- +///| fn row_index(exp : RaggedExperiment, gene : String) -> Int { let mut i = 0 while i < exp.rownames.length() { - if exp.rownames[i] == gene { return i } + if exp.rownames[i] == gene { + return i + } i = i + 1 } -1 } +///| fn col_index(exp : RaggedExperiment, sample : String) -> Int { let mut i = 0 while i < exp.colnames.length() { - if exp.colnames[i] == sample { return i } + if exp.colnames[i] == sample { + return i + } i = i + 1 } -1 diff --git a/src/reduced.mbt b/src/reduced.mbt index 53115a16..9eca5776 100644 --- a/src/reduced.mbt +++ b/src/reduced.mbt @@ -32,12 +32,7 @@ pub fn ReducedAlphabet::new( mapping : Map[String, String], groups : Array[String], ) -> ReducedAlphabet { - ReducedAlphabet::{ - name, - n_groups: groups.length(), - mapping, - groups, - } + ReducedAlphabet::{ name, n_groups: groups.length(), mapping, groups } } ///| @@ -54,14 +49,20 @@ pub fn ReducedAlphabet::get_n_groups(self : ReducedAlphabet) -> Int { ///| /// Get the reduced representation for an amino acid. -pub fn ReducedAlphabet::reduce_aa(self : ReducedAlphabet, aa : String) -> String { +pub fn ReducedAlphabet::reduce_aa( + self : ReducedAlphabet, + aa : String, +) -> String { let upper = aa.to_upper() self.mapping.get(upper).unwrap_or("X") } ///| /// Reduce a protein sequence to the reduced alphabet. -pub fn ReducedAlphabet::reduce_sequence(self : ReducedAlphabet, sequence : String) -> String { +pub fn ReducedAlphabet::reduce_sequence( + self : ReducedAlphabet, + sequence : String, +) -> String { let mut result = "".to_string() let n = sequence.length() let mut i = 0 @@ -123,7 +124,9 @@ pub fn rad_alphabet() -> ReducedAlphabet { mapping.set("R", "5") mapping.set("S", "5") mapping.set("T", "5") - let groups = ["(A,G)", "(C)", "(D,E,N,Q)", "(I,L,M,V)", "(F,Y,W)", "(H,K,R,S,T)"] + let groups = [ + "(A,G)", "(C)", "(D,E,N,Q)", "(I,L,M,V)", "(F,Y,W)", "(H,K,R,S,T)", + ] ReducedAlphabet::new("RAD", mapping, groups) } @@ -159,7 +162,9 @@ pub fn dayhoff_alphabet() -> ReducedAlphabet { mapping.set("H", "5") mapping.set("K", "5") mapping.set("R", "5") - let groups = ["(A,G,P,S,T)", "(C)", "(D,E,N,Q)", "(I,L,M,V)", "(F,W,Y)", "(H,K,R)"] + let groups = [ + "(A,G,P,S,T)", "(C)", "(D,E,N,Q)", "(I,L,M,V)", "(F,W,Y)", "(H,K,R)", + ] ReducedAlphabet::new("Dayhoff", mapping, groups) } @@ -226,8 +231,8 @@ pub fn sdm12_alphabet() -> ReducedAlphabet { mapping.set("Y", "5") // Tyr - polar (same as Gln) mapping.set("V", "9") // Val - hydrophobic (same as Ile) let groups = [ - "(A,M)", "(R)", "(N,S,T)", "(D)", "(C)", - "(Q,Y)", "(E)", "(G,P)", "(H)", "(I,V)", "(L,F,W)", "(K)", + "(A,M)", "(R)", "(N,S,T)", "(D)", "(C)", "(Q,Y)", "(E)", "(G,P)", "(H)", "(I,V)", + "(L,F,W)", "(K)", ] ReducedAlphabet::new("SDM12", mapping, groups) } @@ -263,7 +268,11 @@ pub fn reduced_identity( seq2 : String, alphabet : ReducedAlphabet, ) -> Double { - let n = if seq1.length() < seq2.length() { seq1.length() } else { seq2.length() } + let n = if seq1.length() < seq2.length() { + seq1.length() + } else { + seq2.length() + } if n == 0 { return 0.0 } diff --git a/src/reference.mbt b/src/reference.mbt index b21d6513..524812d4 100644 --- a/src/reference.mbt +++ b/src/reference.mbt @@ -80,7 +80,7 @@ pub fn BioReference::with_pubmed( year : String, pubmed_id : String, ) -> BioReference { - let r = BioReference::new(title=title, authors=authors, journal=journal, year=year) + let r = BioReference::new(title~, authors~, journal~, year~) r.pubmed_id_val = pubmed_id r } @@ -94,23 +94,62 @@ pub fn BioReference::with_doi( year : String, doi : String, ) -> BioReference { - let r = BioReference::new(title=title, authors=authors, journal=journal, year=year) + let r = BioReference::new(title~, authors~, journal~, year~) r.doi_val = doi r } -pub impl AbstractReference for BioReference with fn title(self : BioReference) -> String { self.title_val } -pub impl AbstractReference for BioReference with fn authors(self : BioReference) -> String { self.authors_val } -pub impl AbstractReference for BioReference with fn journal(self : BioReference) -> String { self.journal_val } -pub impl AbstractReference for BioReference with fn year(self : BioReference) -> String { self.year_val } -pub impl AbstractReference for BioReference with fn pubmed_id(self : BioReference) -> String { self.pubmed_id_val } -pub impl AbstractReference for BioReference with fn doi(self : BioReference) -> String { self.doi_val } -pub impl AbstractReference for BioReference with fn reference_type(self : BioReference) -> String { self.type_val } -pub impl AbstractReference for BioReference with fn citation(self : BioReference) -> String { +///| +pub impl AbstractReference for BioReference with fn title(self : BioReference) -> String { + self.title_val +} + +///| +pub impl AbstractReference for BioReference with fn authors(self : BioReference) -> String { + self.authors_val +} + +///| +pub impl AbstractReference for BioReference with fn journal(self : BioReference) -> String { + self.journal_val +} + +///| +pub impl AbstractReference for BioReference with fn year(self : BioReference) -> String { + self.year_val +} + +///| +pub impl AbstractReference for BioReference with fn pubmed_id( + self : BioReference, +) -> String { + self.pubmed_id_val +} + +///| +pub impl AbstractReference for BioReference with fn doi(self : BioReference) -> String { + self.doi_val +} + +///| +pub impl AbstractReference for BioReference with fn reference_type( + self : BioReference, +) -> String { + self.type_val +} + +///| +pub impl AbstractReference for BioReference with fn citation( + self : BioReference, +) -> String { let mut s = self.authors_val - if s.length() > 0 { s = s + ". " } + if s.length() > 0 { + s = s + ". " + } s = s + self.title_val - if s.length() > 0 { s = s + ". " } + if s.length() > 0 { + s = s + ". " + } s = s + self.journal_val if self.year_val.length() > 0 { s = s + " (" + self.year_val + ")" @@ -172,7 +211,11 @@ pub fn BioReference::set_type(self : BioReference, type_ : String) -> Unit { ///| /// Add a location (pair of start/end positions). -pub fn BioReference::add_location(self : BioReference, start : Int, end_ : Int) -> Unit { +pub fn BioReference::add_location( + self : BioReference, + start : Int, + end_ : Int, +) -> Unit { self.locations.push((start, end_)) } @@ -262,7 +305,10 @@ pub fn ReferenceList::get_all(self : ReferenceList) -> Array[BioReference] { ///| /// Get references by author name. -pub fn ReferenceList::by_author(self : ReferenceList, author : String) -> Array[BioReference] { +pub fn ReferenceList::by_author( + self : ReferenceList, + author : String, +) -> Array[BioReference] { let result : Array[BioReference] = Array::new() let mut i = 0 while i < self.refs.length() { @@ -276,7 +322,10 @@ pub fn ReferenceList::by_author(self : ReferenceList, author : String) -> Array[ ///| /// Get references by year. -pub fn ReferenceList::by_year(self : ReferenceList, year : String) -> Array[BioReference] { +pub fn ReferenceList::by_year( + self : ReferenceList, + year : String, +) -> Array[BioReference] { let result : Array[BioReference] = Array::new() let mut i = 0 while i < self.refs.length() { @@ -323,21 +372,15 @@ pub fn ReferenceList::bibliography(self : ReferenceList) -> String { pub fn reference_sample_data() -> ReferenceList { let list = ReferenceList::new() let ref1 = BioReference::with_pubmed( - "The Human Genome: A Complete Sequence", - "Nurk S, Koren S, Rhie A", - "Science", - "2022", - "36189102", + "The Human Genome: A Complete Sequence", "Nurk S, Koren S, Rhie A", "Science", + "2022", "36189102", ) ref1.add_location(1, 250000000) ref1.set_comment("Telomere-to-telomere assembly") list.add(ref1) let ref2 = BioReference::with_doi( - "CRISPR-Cas9 genome editing", - "Doudna JA, Charpentier E", - "Science", - "2014", + "CRISPR-Cas9 genome editing", "Doudna JA, Charpentier E", "Science", "2014", "10.1126/science.1258096", ) ref2.add_location(100, 5000) diff --git a/src/reporting_tools.mbt b/src/reporting_tools.mbt index 10eb2f9f..47c002e7 100644 --- a/src/reporting_tools.mbt +++ b/src/reporting_tools.mbt @@ -113,7 +113,10 @@ pub fn ReportDocument::new(title : String) -> ReportDocument { ///| /// Set author. -pub fn ReportDocument::set_author(doc : ReportDocument, author : String) -> ReportDocument { +pub fn ReportDocument::set_author( + doc : ReportDocument, + author : String, +) -> ReportDocument { ReportDocument::{ title: doc.title, author, @@ -126,7 +129,12 @@ pub fn ReportDocument::set_author(doc : ReportDocument, author : String) -> Repo ///| /// Add a text section to the report. -pub fn ReportDocument::add_text(doc : ReportDocument, id : String, title : String, content : String) -> ReportDocument { +pub fn ReportDocument::add_text( + doc : ReportDocument, + id : String, + title : String, + content : String, +) -> ReportDocument { let sections = doc.sections.copy() sections.push(ReportSection::{ section_id: id, @@ -148,7 +156,11 @@ pub fn ReportDocument::add_text(doc : ReportDocument, id : String, title : Strin ///| /// Add a table section to the report. -pub fn ReportDocument::add_table(doc : ReportDocument, id : String, table : ReportTable) -> ReportDocument { +pub fn ReportDocument::add_table( + doc : ReportDocument, + id : String, + table : ReportTable, +) -> ReportDocument { let sections = doc.sections.copy() let tables = doc.tables.copy() tables.push(table) @@ -172,7 +184,12 @@ pub fn ReportDocument::add_table(doc : ReportDocument, id : String, table : Repo ///| /// Add a plot section to the report. -pub fn ReportDocument::add_plot(doc : ReportDocument, id : String, title : String, plot_ascii : String) -> ReportDocument { +pub fn ReportDocument::add_plot( + doc : ReportDocument, + id : String, + title : String, + plot_ascii : String, +) -> ReportDocument { let sections = doc.sections.copy() sections.push(ReportSection::{ section_id: id, @@ -218,13 +235,23 @@ pub fn ReportDocument::get_n_tables(doc : ReportDocument) -> Int { ///| /// Create a new report column. -pub fn ReportColumn::new(name : String, values : Array[String], numeric : Bool) -> ReportColumn { +pub fn ReportColumn::new( + name : String, + values : Array[String], + numeric : Bool, +) -> ReportColumn { ReportColumn::{ name, values, numeric } } ///| /// Create a new report table from string arrays. -pub fn ReportTable::new(table_id : String, title : String, column_names : Array[String], column_data : Array[Array[String]], caption : String) -> ReportTable { +pub fn ReportTable::new( + table_id : String, + title : String, + column_names : Array[String], + column_data : Array[Array[String]], + caption : String, +) -> ReportTable { let columns : Array[ReportColumn] = Array::new() let n = column_names.length() let mut i = 0 @@ -241,7 +268,12 @@ pub fn ReportTable::new(table_id : String, title : String, column_names : Array[ ///| /// Create a report table from mixed columns. -pub fn ReportTable::from_columns(table_id : String, title : String, columns : Array[ReportColumn], caption : String) -> ReportTable { +pub fn ReportTable::from_columns( + table_id : String, + title : String, + columns : Array[ReportColumn], + caption : String, +) -> ReportTable { ReportTable::{ table_id, title, columns, caption } } @@ -260,7 +292,11 @@ pub fn ReportTable::get_column_names(table : ReportTable) -> Array[String] { ///| /// Get number of rows in a table. pub fn ReportTable::get_n_rows(table : ReportTable) -> Int { - if table.columns.length() == 0 { 0 } else { table.columns[0].values.length() } + if table.columns.length() == 0 { + 0 + } else { + table.columns[0].values.length() + } } ///| @@ -269,6 +305,7 @@ pub fn ReportTable::get_n_columns(table : ReportTable) -> Int { table.columns.length() } +///| fn rt_pad_right(s : String, width : Int) -> String { if s.length() >= width { s.substring(start=0, end=width).to_string() @@ -283,6 +320,7 @@ fn rt_pad_right(s : String, width : Int) -> String { } } +///| fn rt_repeat_char(c : String, n : Int) -> String { let mut result = "" let mut i = 0 @@ -351,7 +389,11 @@ pub fn ReportTable::to_ascii(table : ReportTable) -> String { while ri < n_rows { let mut ci2 = 0 while ci2 < n_cols { - let val = if ri < table.columns[ci2].values.length() { table.columns[ci2].values[ri] } else { "" } + let val = if ri < table.columns[ci2].values.length() { + table.columns[ci2].values[ri] + } else { + "" + } let padded = rt_pad_right(val, widths[ci2]) result = result + padded + " | " ci2 = ci2 + 1 @@ -365,7 +407,10 @@ pub fn ReportTable::to_ascii(table : ReportTable) -> String { ///| /// Get a report section by id. -pub fn ReportDocument::get_section(doc : ReportDocument, section_id : String) -> ReportSection { +pub fn ReportDocument::get_section( + doc : ReportDocument, + section_id : String, +) -> ReportSection { let mut i = 0 while i < doc.sections.length() { if doc.sections[i].section_id == section_id { @@ -398,11 +443,14 @@ pub fn ReportDocument::render(doc : ReportDocument) -> String { let mut i = 0 while i < doc.sections.length() { let sec = doc.sections[i] - result = result + "### " + sec.title + " (" + sec.section_type.to_string() + ") ###\n" + result = result + + "### " + + sec.title + + " (" + + sec.section_type.to_string() + + ") ###\n" match sec.section_type { - ReportSectionType::Text => { - result = result + sec.content + "\n" - } + ReportSectionType::Text => result = result + sec.content + "\n" ReportSectionType::Table => { // Find the corresponding table let mut j = 0 @@ -413,12 +461,8 @@ pub fn ReportDocument::render(doc : ReportDocument) -> String { j = j + 1 } } - ReportSectionType::Plot => { - result = result + sec.content + "\n" - } - _ => { - result = result + sec.content + "\n" - } + ReportSectionType::Plot => result = result + sec.content + "\n" + _ => result = result + sec.content + "\n" } result = result + "\n---\n\n" i = i + 1 @@ -443,4 +487,4 @@ pub fn ReportDocument::summary(doc : ReportDocument) -> String { } s = s + "Total table rows: " + total_rows.to_string() + "\n" s -} \ No newline at end of file +} diff --git a/src/residue_depth.mbt b/src/residue_depth.mbt index 3cdee10b..1290d004 100644 --- a/src/residue_depth.mbt +++ b/src/residue_depth.mbt @@ -74,7 +74,11 @@ pub struct RDAtom { ///| /// Create a new RDAtom. -pub fn RDAtom::new(name : String, coord : RDPoint3D, element : String) -> RDAtom { +pub fn RDAtom::new( + name : String, + coord : RDPoint3D, + element : String, +) -> RDAtom { RDAtom::{ name, coord, element } } @@ -88,7 +92,11 @@ pub struct RDResidue { ///| /// Create a new RDResidue. -pub fn RDResidue::new(resname : String, resseq : Int, atoms : Array[RDAtom]) -> RDResidue { +pub fn RDResidue::new( + resname : String, + resseq : Int, + atoms : Array[RDAtom], +) -> RDResidue { RDResidue::{ resname, resseq, atoms } } @@ -98,11 +106,11 @@ pub fn RDResidue::center_of_mass(self : RDResidue) -> RDPoint3D { if self.atoms.length() == 0 { return RDPoint3D::new(0.0, 0.0, 0.0) } - + let mut sum_x = 0.0 let mut sum_y = 0.0 let mut sum_z = 0.0 - + let mut i = 0 while i < self.atoms.length() { let atom = self.atoms[i] @@ -111,7 +119,7 @@ pub fn RDResidue::center_of_mass(self : RDResidue) -> RDPoint3D { sum_z = sum_z + atom.coord.z i = i + 1 } - + let n = self.atoms.length().to_double() RDPoint3D::new(sum_x / n, sum_y / n, sum_z / n) } @@ -149,94 +157,121 @@ pub fn RDResult::new( ca_depth : Double, com_depth : Double, ca_sasa : Double, - com_sasa : Double + com_sasa : Double, ) -> RDResult { RDResult::{ resseq, resname, ca_depth, com_depth, ca_sasa, com_sasa } } ///| /// Calculate the solvent-accessible surface area (SASA) using the rolling ball algorithm. -pub fn calculate_sasa(atom : RDAtom, all_atoms : Array[RDAtom], probe_radius : Double) -> Double { +pub fn calculate_sasa( + atom : RDAtom, + all_atoms : Array[RDAtom], + probe_radius : Double, +) -> Double { let atom_radius = get_atom_radius(atom.element) let total_radius = atom_radius + probe_radius - + let mut sasa = 0.0 let n_points = 92 - + let mut i = 0 while i < n_points { - let theta = (i.to_double() / n_points.to_double()) * 2.0 * 3.141592653589793 + let theta = i.to_double() / n_points.to_double() * 2.0 * 3.141592653589793 let mut j = 0 while j < n_points { - let phi = (j.to_double() / n_points.to_double()) * 3.141592653589793 - + let phi = j.to_double() / n_points.to_double() * 3.141592653589793 + let x = total_radius * @math.cos(theta) * @math.sin(phi) let y = total_radius * @math.sin(theta) * @math.sin(phi) let z = total_radius * @math.cos(phi) - - let test_point = RDPoint3D::new(atom.coord.x + x, atom.coord.y + y, atom.coord.z + z) - + + let test_point = RDPoint3D::new( + atom.coord.x + x, + atom.coord.y + y, + atom.coord.z + z, + ) + let mut is_accessible = true let mut k = 0 while k < all_atoms.length() { let other_atom = all_atoms[k] - if other_atom.name == atom.name && other_atom.coord.x == atom.coord.x && other_atom.coord.y == atom.coord.y && other_atom.coord.z == atom.coord.z { + if other_atom.name == atom.name && + other_atom.coord.x == atom.coord.x && + other_atom.coord.y == atom.coord.y && + other_atom.coord.z == atom.coord.z { k = k + 1 continue } - + let other_radius = get_atom_radius(other_atom.element) + probe_radius let dist = atom.coord.distance(other_atom.coord) - + if dist < other_radius + atom_radius { is_accessible = false break } k = k + 1 } - + if is_accessible { - let area_element = 4.0 * 3.141592653589793 * total_radius * total_radius / (n_points.to_double() * n_points.to_double()) + let area_element = 4.0 * + 3.141592653589793 * + total_radius * + total_radius / + (n_points.to_double() * n_points.to_double()) sasa = sasa + area_element } j = j + 1 } i = i + 1 } - + sasa } ///| /// Get the van der Waals radius for an atom element. pub fn get_atom_radius(element : String) -> Double { - if element == "H" || element == "h" { 1.20 } - else if element == "C" || element == "c" { 1.70 } - else if element == "N" || element == "n" { 1.55 } - else if element == "O" || element == "o" { 1.52 } - else if element == "S" || element == "s" { 1.80 } - else if element == "P" || element == "p" { 1.80 } - else { 1.50 } + if element == "H" || element == "h" { + 1.20 + } else if element == "C" || element == "c" { + 1.70 + } else if element == "N" || element == "n" { + 1.55 + } else if element == "O" || element == "o" { + 1.52 + } else if element == "S" || element == "s" { + 1.80 + } else if element == "P" || element == "p" { + 1.80 + } else { + 1.50 + } } ///| /// Calculate depth for a point using ray casting. -pub fn calculate_point_depth(point : RDPoint3D, all_atoms : Array[RDAtom], probe_radius : Double) -> Double { +pub fn calculate_point_depth( + point : RDPoint3D, + all_atoms : Array[RDAtom], + probe_radius : Double, +) -> Double { let mut min_distance = 10000.0 - + let mut i = 0 while i < all_atoms.length() { let atom = all_atoms[i] let atom_radius = get_atom_radius(atom.element) + probe_radius let dist = point.distance(atom.coord) - + let depth = dist - atom_radius if depth < min_distance { min_distance = depth } i = i + 1 } - + if min_distance < 0.0 { 0.0 } else { @@ -250,38 +285,45 @@ pub fn calculate_residue_depth( residue : RDResidue, all_residues : Array[RDResidue], probe_radius : Double, - grid_spacing : Double + grid_spacing : Double, ) -> RDResult { let all_atoms = collect_all_atoms(all_residues) - + let com = residue.center_of_mass() - + let ca_coord = match residue.get_ca() { Some(a) => a.coord None => com } - + let com_depth = calculate_point_depth(com, all_atoms, probe_radius) let ca_depth = calculate_point_depth(ca_coord, all_atoms, probe_radius) - + let ca_atom = match residue.get_ca() { Some(a) => a None => RDAtom::new("CA", ca_coord, "C") } - + let com_atom = RDAtom::new("COM", com, "C") - + let ca_sasa = calculate_sasa(ca_atom, all_atoms, probe_radius) let com_sasa = calculate_sasa(com_atom, all_atoms, probe_radius) - - RDResult::new(residue.resseq, residue.resname, ca_depth, com_depth, ca_sasa, com_sasa) + + RDResult::new( + residue.resseq, + residue.resname, + ca_depth, + com_depth, + ca_sasa, + com_sasa, + ) } ///| /// Calculate depth using grid-based approach (with defaults). pub fn calculate_residue_depth_default( residue : RDResidue, - all_residues : Array[RDResidue] + all_residues : Array[RDResidue], ) -> RDResult { calculate_residue_depth(residue, all_residues, 1.4, 0.5) } @@ -290,7 +332,7 @@ pub fn calculate_residue_depth_default( /// Collect all atoms from residues. pub fn collect_all_atoms(residues : Array[RDResidue]) -> Array[RDAtom] { let atoms : Array[RDAtom] = Array::new() - + let mut i = 0 while i < residues.length() { let residue = residues[i] @@ -301,7 +343,7 @@ pub fn collect_all_atoms(residues : Array[RDResidue]) -> Array[RDAtom] { } i = i + 1 } - + atoms } @@ -310,23 +352,30 @@ pub fn collect_all_atoms(residues : Array[RDResidue]) -> Array[RDAtom] { pub fn analyze_residue_depth( residues : Array[RDResidue], probe_radius : Double, - grid_spacing : Double + grid_spacing : Double, ) -> Array[RDResult] { let results : Array[RDResult] = Array::new() - + let mut i = 0 while i < residues.length() { - let result = calculate_residue_depth(residues[i], residues, probe_radius, grid_spacing) + let result = calculate_residue_depth( + residues[i], + residues, + probe_radius, + grid_spacing, + ) results.push(result) i = i + 1 } - + results } ///| /// Analyze all residues in a structure (with defaults). -pub fn analyze_residue_depth_default(residues : Array[RDResidue]) -> Array[RDResult] { +pub fn analyze_residue_depth_default( + residues : Array[RDResidue], +) -> Array[RDResult] { analyze_residue_depth(residues, 1.4, 0.5) } @@ -336,10 +385,10 @@ pub fn calculate_average_depth(results : Array[RDResult]) -> (Double, Double) { if results.length() == 0 { return (0.0, 0.0) } - + let mut sum_ca = 0.0 let mut sum_com = 0.0 - + let mut i = 0 while i < results.length() { let result = results[i] @@ -347,16 +396,19 @@ pub fn calculate_average_depth(results : Array[RDResult]) -> (Double, Double) { sum_com = sum_com + result.com_depth i = i + 1 } - + let n = results.length().to_double() (sum_ca / n, sum_com / n) } ///| /// Find surface residues (depth below threshold). -pub fn find_surface_residues(results : Array[RDResult], depth_threshold : Double) -> Array[RDResult] { +pub fn find_surface_residues( + results : Array[RDResult], + depth_threshold : Double, +) -> Array[RDResult] { let surface : Array[RDResult] = Array::new() - + let mut i = 0 while i < results.length() { let result = results[i] @@ -365,21 +417,26 @@ pub fn find_surface_residues(results : Array[RDResult], depth_threshold : Double } i = i + 1 } - + surface } ///| /// Find surface residues (with default threshold). -pub fn find_surface_residues_default(results : Array[RDResult]) -> Array[RDResult] { +pub fn find_surface_residues_default( + results : Array[RDResult], +) -> Array[RDResult] { find_surface_residues(results, 3.0) } ///| /// Find core residues (depth above threshold). -pub fn find_core_residues(results : Array[RDResult], depth_threshold : Double) -> Array[RDResult] { +pub fn find_core_residues( + results : Array[RDResult], + depth_threshold : Double, +) -> Array[RDResult] { let core : Array[RDResult] = Array::new() - + let mut i = 0 while i < results.length() { let result = results[i] @@ -388,7 +445,7 @@ pub fn find_core_residues(results : Array[RDResult], depth_threshold : Double) - } i = i + 1 } - + core } @@ -400,25 +457,39 @@ pub fn find_core_residues_default(results : Array[RDResult]) -> Array[RDResult] ///| /// Bio API functions. - -pub fn bio_residue_depth_analyze(residues : Array[RDResidue]) -> Array[RDResult] { +pub fn bio_residue_depth_analyze( + residues : Array[RDResidue], +) -> Array[RDResult] { analyze_residue_depth_default(residues) } -pub fn bio_residue_depth_calculate(residue : RDResidue, all_residues : Array[RDResidue]) -> RDResult { +///| +pub fn bio_residue_depth_calculate( + residue : RDResidue, + all_residues : Array[RDResidue], +) -> RDResult { calculate_residue_depth_default(residue, all_residues) } -pub fn bio_residue_depth_find_surface(residues : Array[RDResidue], threshold : Double) -> Array[RDResult] { +///| +pub fn bio_residue_depth_find_surface( + residues : Array[RDResidue], + threshold : Double, +) -> Array[RDResult] { let results = analyze_residue_depth_default(residues) find_surface_residues(results, threshold) } -pub fn bio_residue_depth_find_core(residues : Array[RDResidue], threshold : Double) -> Array[RDResult] { +///| +pub fn bio_residue_depth_find_core( + residues : Array[RDResidue], + threshold : Double, +) -> Array[RDResult] { let results = analyze_residue_depth_default(residues) find_core_residues(results, threshold) } +///| pub fn bio_residue_depth_average(results : Array[RDResult]) -> (Double, Double) { calculate_average_depth(results) -} \ No newline at end of file +} diff --git a/src/rhdf5.mbt b/src/rhdf5.mbt index 6cf910a6..21f982e6 100644 --- a/src/rhdf5.mbt +++ b/src/rhdf5.mbt @@ -11,7 +11,11 @@ pub struct HDF5Attribute { } ///| -pub fn HDF5Attribute::new(name : String, data_type : String, data : String) -> HDF5Attribute { +pub fn HDF5Attribute::new( + name : String, + data_type : String, + data : String, +) -> HDF5Attribute { HDF5Attribute::{ name, data_type, data } } @@ -25,13 +29,17 @@ pub struct HDF5Dataset { } ///| -pub fn HDF5Dataset::new(name : String, data_type : String, dimensions : Array[Int]) -> HDF5Dataset { +pub fn HDF5Dataset::new( + name : String, + data_type : String, + dimensions : Array[Int], +) -> HDF5Dataset { HDF5Dataset::{ name, data_type, dimensions, data: "", - attributes: Map([], capacity=0) + attributes: Map([], capacity=0), } } @@ -41,13 +49,16 @@ pub fn HDF5Dataset::set_data(self : HDF5Dataset, data : String) -> HDF5Dataset { name: self.name, data_type: self.data_type, dimensions: self.dimensions, - data: data, - attributes: self.attributes + data, + attributes: self.attributes, } } ///| -pub fn HDF5Dataset::add_attribute(self : HDF5Dataset, attr : HDF5Attribute) -> HDF5Dataset { +pub fn HDF5Dataset::add_attribute( + self : HDF5Dataset, + attr : HDF5Attribute, +) -> HDF5Dataset { let new_attrs = self.attributes new_attrs.set(attr.name, attr) HDF5Dataset::{ @@ -55,12 +66,15 @@ pub fn HDF5Dataset::add_attribute(self : HDF5Dataset, attr : HDF5Attribute) -> H data_type: self.data_type, dimensions: self.dimensions, data: self.data, - attributes: new_attrs + attributes: new_attrs, } } ///| -pub fn HDF5Dataset::get_attribute(self : HDF5Dataset, name : String) -> HDF5Attribute? { +pub fn HDF5Dataset::get_attribute( + self : HDF5Dataset, + name : String, +) -> HDF5Attribute? { if self.attributes.contains(name) { Some(self.attributes.get(name).unwrap()) } else { @@ -82,7 +96,7 @@ pub fn HDF5Group::new(name : String) -> HDF5Group { name, groups: Map([], capacity=0), datasets: Map([], capacity=0), - attributes: Map([], capacity=0) + attributes: Map([], capacity=0), } } @@ -113,11 +127,7 @@ pub struct HDF5File { ///| pub fn HDF5File::new(filename : String, mode : String) -> HDF5File { - HDF5File::{ - filename, - mode, - root: HDF5Group::new("/") - } + HDF5File::{ filename, mode, root: HDF5Group::new("/") } } ///| @@ -188,28 +198,32 @@ fn ensure_path(group : HDF5Group, parts : Array[String]) -> Unit { } ///| -pub fn HDF5File::write_dataset(self : HDF5File, path : String, dataset : HDF5Dataset) -> HDF5File { +pub fn HDF5File::write_dataset( + self : HDF5File, + path : String, + dataset : HDF5Dataset, +) -> HDF5File { let (group_parts, ds_name) = split_path_and_name(path) - + let _ = ensure_path(self.root, group_parts) - + let mut current = self.root let mut i = 0 while i < group_parts.length() { current = current.groups.get(group_parts[i]).unwrap() i = i + 1 } - + let new_ds = dataset.set_name(ds_name) current.datasets.set(ds_name, new_ds) - + self } ///| pub fn HDF5File::read_dataset(self : HDF5File, path : String) -> HDF5Dataset? { let (group_parts, ds_name) = split_path_and_name(path) - + let mut current = self.root let mut i = 0 while i < group_parts.length() { @@ -220,7 +234,7 @@ pub fn HDF5File::read_dataset(self : HDF5File, path : String) -> HDF5Dataset? { } i = i + 1 } - + if current.datasets.contains(ds_name) { Some(current.datasets.get(ds_name).unwrap()) } else { @@ -231,11 +245,11 @@ pub fn HDF5File::read_dataset(self : HDF5File, path : String) -> HDF5Dataset? { ///| pub fn HDF5Dataset::set_name(self : HDF5Dataset, name : String) -> HDF5Dataset { HDF5Dataset::{ - name: name, + name, data_type: self.data_type, dimensions: self.dimensions, data: self.data, - attributes: self.attributes + attributes: self.attributes, } } @@ -250,13 +264,24 @@ pub fn h5create_group(file : HDF5File, path : String) -> HDF5File { } ///| -pub fn h5create_dataset(file : HDF5File, path : String, data_type : String, dimensions : Array[Int]) -> HDF5File { +pub fn h5create_dataset( + file : HDF5File, + path : String, + data_type : String, + dimensions : Array[Int], +) -> HDF5File { let ds = HDF5Dataset::new("", data_type, dimensions) file.write_dataset(path, ds) } ///| -pub fn h5write_dataset(file : HDF5File, path : String, data : String, data_type : String, dimensions : Array[Int]) -> HDF5File { +pub fn h5write_dataset( + file : HDF5File, + path : String, + data : String, + data_type : String, + dimensions : Array[Int], +) -> HDF5File { let ds = HDF5Dataset::new("", data_type, dimensions) let ds_with_data = ds.set_data(data) file.write_dataset(path, ds_with_data) @@ -275,9 +300,13 @@ pub fn h5ls(file : HDF5File) -> Array[String] { } ///| -fn list_group(group : HDF5Group, prefix : String, result : Array[String]) -> Unit { +fn list_group( + group : HDF5Group, + prefix : String, + result : Array[String], +) -> Unit { let ds_entries = group.datasets.iter().collect() - + let mut i = 0 while i < ds_entries.length() { let (name, ds) = ds_entries[i] @@ -285,9 +314,9 @@ fn list_group(group : HDF5Group, prefix : String, result : Array[String]) -> Uni result.push(prefix + "/" + name + " [" + dims_str + "]") i = i + 1 } - + let grp_entries = group.groups.iter().collect() - + let mut j = 0 while j < grp_entries.length() { let (name, grp) = grp_entries[j] @@ -319,12 +348,24 @@ fn dimensions_to_string(dims : Array[Int]) -> String { pub fn h5create_example_file() -> HDF5File { let file = h5create_file("example.h5") let file2 = h5create_group(file, "data") - let file3 = h5create_dataset(file2, "/data/matrix", "H5T_NATIVE_DOUBLE", [100, 1000]) - let file4 = h5write_dataset(file3, "/data/matrix", "1.0,2.0,3.0", "H5T_NATIVE_DOUBLE", [3]) + let file3 = h5create_dataset(file2, "/data/matrix", "H5T_NATIVE_DOUBLE", [ + 100, 1000, + ]) + let file4 = h5write_dataset( + file3, + "/data/matrix", + "1.0,2.0,3.0", + "H5T_NATIVE_DOUBLE", + [3], + ) file4 } ///| -pub fn h5create_attribute(name : String, data_type : String, data : String) -> HDF5Attribute { +pub fn h5create_attribute( + name : String, + data_type : String, + data : String, +) -> HDF5Attribute { HDF5Attribute::new(name, data_type, data) } diff --git a/src/rna_structure.mbt b/src/rna_structure.mbt index a6ac6399..6811765f 100644 --- a/src/rna_structure.mbt +++ b/src/rna_structure.mbt @@ -84,12 +84,24 @@ pub fn rna_predictor_with_params( pub fn is_complementary(base1 : UInt16, base2 : UInt16) -> Bool { let b1 = rna_normalize_base(base1) let b2 = rna_normalize_base(base2) - if b1 == 65 && b2 == 85 { return true } - if b1 == 85 && b2 == 65 { return true } - if b1 == 71 && b2 == 67 { return true } - if b1 == 67 && b2 == 71 { return true } - if b1 == 71 && b2 == 85 { return true } - if b1 == 85 && b2 == 71 { return true } + if b1 == 65 && b2 == 85 { + return true + } + if b1 == 85 && b2 == 65 { + return true + } + if b1 == 71 && b2 == 67 { + return true + } + if b1 == 67 && b2 == 71 { + return true + } + if b1 == 71 && b2 == 85 { + return true + } + if b1 == 85 && b2 == 71 { + return true + } false } @@ -97,7 +109,9 @@ pub fn is_complementary(base1 : UInt16, base2 : UInt16) -> Bool { /// Calculate the loop energy penalty for a given loop length. /// Returns penalty = loop_penalty * length. pub fn compute_loop_energy(length : Int) -> Double { - if length <= 0 { return 0.0 } + if length <= 0 { + return 0.0 + } 0.5 * length.to_double() } @@ -112,7 +126,9 @@ pub fn nussinov_matrix( predictor : RNAStructurePredictor, ) -> Array[Array[Double]] { let n = sequence.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let dp : Array[Array[Double]] = Array::new() for i = 0; i < n; i = i + 1 { @@ -146,7 +162,9 @@ pub fn nussinov_traceback( ) -> Array[(Int, Int)] { let n = sequence.length() let base_pairs : Array[(Int, Int)] = Array::new() - if n == 0 { return base_pairs } + if n == 0 { + return base_pairs + } rna_trace_from_matrix(matrix, sequence, predictor, 0, n - 1, base_pairs) @@ -243,12 +261,12 @@ pub fn identify_loop_regions( ) -> Array[LoopRegion] { let loop_regions : Array[LoopRegion] = Array::new() let n = sequence.length() - if n == 0 { return loop_regions } + if n == 0 { + return loop_regions + } let paired = rna_build_paired_array(n, base_pairs) - rna_find_loops_recursive( - sequence, base_pairs, 0, n - 1, paired, loop_regions, - ) + rna_find_loops_recursive(sequence, base_pairs, 0, n - 1, paired, loop_regions) loop_regions } @@ -273,7 +291,11 @@ pub fn mfe_to_dot_bracket( ///| /// Normalize a base to uppercase UInt16 code. fn rna_normalize_base(base : UInt16) -> UInt16 { - if base >= 97 && base <= 122 { base - 32 } else { base } + if base >= 97 && base <= 122 { + base - 32 + } else { + base + } } ///| @@ -294,10 +316,14 @@ fn rna_base_pair_energy( (nb1 == 71 && nb2 == 67) || (nb1 == 67 && nb2 == 71) - if is_watson_crick { return -1.0 } + if is_watson_crick { + return -1.0 + } let is_wobble = (nb1 == 71 && nb2 == 85) || (nb1 == 85 && nb2 == 71) - if is_wobble { return -0.5 } + if is_wobble { + return -0.5 + } predictor.mismatch_penalty } @@ -317,7 +343,11 @@ fn rna_compute_energy_for_interval( let unpaired_i = dp[i + 1][j] let unpaired_j = dp[i][j - 1] - let mut min_energy = if unpaired_i < unpaired_j { unpaired_i } else { unpaired_j } + let mut min_energy = if unpaired_i < unpaired_j { + unpaired_i + } else { + unpaired_j + } let loop_len = j - i - 1 if loop_len >= loop_min { @@ -344,7 +374,11 @@ fn rna_compute_energy_for_interval( ///| /// Absolute value helper for Double. fn rna_abs(x : Double) -> Double { - if x < 0.0 { -x } else { x } + if x < 0.0 { + -x + } else { + x + } } ///| @@ -357,7 +391,9 @@ fn rna_trace_from_matrix( j : Int, base_pairs : Array[(Int, Int)], ) -> Unit { - if i >= j { return } + if i >= j { + return + } let n = sequence.length() let loop_min = predictor.loop_min_length @@ -382,7 +418,12 @@ fn rna_trace_from_matrix( if rna_abs(paired_energy - current) < eps { base_pairs.push((i, j)) rna_trace_from_matrix( - matrix, sequence, predictor, i + 1, j - 1, base_pairs, + matrix, + sequence, + predictor, + i + 1, + j - 1, + base_pairs, ) return } @@ -393,9 +434,7 @@ fn rna_trace_from_matrix( let bifurcation_energy = matrix[i][k] + matrix[k + 1][j] if rna_abs(bifurcation_energy - current) < eps { rna_trace_from_matrix(matrix, sequence, predictor, i, k, base_pairs) - rna_trace_from_matrix( - matrix, sequence, predictor, k + 1, j, base_pairs, - ) + rna_trace_from_matrix(matrix, sequence, predictor, k + 1, j, base_pairs) return } k = k + 1 @@ -416,7 +455,10 @@ fn rna_build_dot_bracket(n : Int, base_pairs : Array[(Int, Int)]) -> String { ///| /// Build an array indicating which positions are paired. -fn rna_build_paired_array(n : Int, base_pairs : Array[(Int, Int)]) -> Array[Int] { +fn rna_build_paired_array( + n : Int, + base_pairs : Array[(Int, Int)], +) -> Array[Int] { let paired : Array[Int] = Array::make(n, -1) for idx = 0; idx < base_pairs.length(); idx = idx + 1 { let (i, j) = base_pairs[idx] @@ -436,7 +478,9 @@ fn rna_find_loops_recursive( paired : Array[Int], loop_regions : Array[LoopRegion], ) -> Unit { - if i >= j { return } + if i >= j { + return + } let n = sequence.length() let has_pair = if i < n && paired[i] == j { true } else { false } @@ -445,11 +489,7 @@ fn rna_find_loops_recursive( let loop_len = j - i - 1 if loop_len > 0 { let loop_type = rna_classify_loop(sequence, i, j, paired) - loop_regions.push(LoopRegion::{ - start: i + 1, - end: j - 1, - loop_type, - }) + loop_regions.push(LoopRegion::{ start: i + 1, end: j - 1, loop_type }) let inner_i = i + 1 let inner_j = j - 1 @@ -474,7 +514,12 @@ fn rna_find_loops_recursive( if k + 1 < k_pair - 1 { let sub_paired = rna_build_sub_paired(k + 1, k_pair - 1, paired) rna_find_loops_recursive( - sequence, base_pairs, k + 1, k_pair - 1, sub_paired, loop_regions, + sequence, + base_pairs, + k + 1, + k_pair - 1, + sub_paired, + loop_regions, ) } k = k_pair + 1 @@ -562,7 +607,9 @@ fn rna_compute_mfe( loop_regions : Array[LoopRegion], ) -> Double { let n = sequence.length() - if n <= 2 { return 0.0 } + if n <= 2 { + return 0.0 + } let mut mfe = 0.0 @@ -575,7 +622,9 @@ fn rna_compute_mfe( for idx = 0; idx < loop_regions.length(); idx = idx + 1 { let region = loop_regions[idx] let loop_len = region.end - region.start + 1 - if loop_len <= 0 { continue } + if loop_len <= 0 { + continue + } let penalty = match region.loop_type { "hairpin" => (predictor.loop_penalty + 0.1) * loop_len.to_double() @@ -605,10 +654,14 @@ fn rna_count_stacking( for idx = 0; idx < bp_count; idx = idx + 1 { let (i, j) = base_pairs[idx] let has_next = i + 1 < j - 1 - if !has_next { continue } + if !has_next { + continue + } for idx2 = 0; idx2 < bp_count; idx2 = idx2 + 1 { - if idx2 == idx { continue } + if idx2 == idx { + continue + } let (i2, j2) = base_pairs[idx2] if i2 == i + 1 && j2 == j - 1 { stacking_count = stacking_count + 1 @@ -618,4 +671,4 @@ fn rna_count_stacking( } stacking_count.to_double() * predictor.stacking_energy -} \ No newline at end of file +} diff --git a/src/rstatix.mbt b/src/rstatix.mbt index ba4f5a6a..7339bb2d 100644 --- a/src/rstatix.mbt +++ b/src/rstatix.mbt @@ -62,7 +62,9 @@ pub fn rstatix_t_test( let n1 = x.length() let is_two_sample = y.length() > 0 if !is_two_sample { - rstatix_t_test_one_sample(x, mu, alternative, conf_level, "Sample", "", "One-sample t-test") + rstatix_t_test_one_sample( + x, mu, alternative, conf_level, "Sample", "", "One-sample t-test", + ) } else if paired { let n = rstatix_min_int(n1, y.length()) let diffs = Array::make(n, 0.0) @@ -71,7 +73,9 @@ pub fn rstatix_t_test( diffs[i] = x[i] - y[i] i = i + 1 } - rstatix_t_test_one_sample(diffs, mu, alternative, conf_level, "Difference", "", "Paired t-test") + rstatix_t_test_one_sample( + diffs, mu, alternative, conf_level, "Difference", "", "Paired t-test", + ) } else { let n2 = y.length() let mean1 = rstatix_mean_double(x) @@ -80,8 +84,10 @@ pub fn rstatix_t_test( let sd2 = rstatix_sd_double(y) let se = (sd1 * sd1 / n1.to_double() + sd2 * sd2 / n2.to_double()).sqrt() let t_stat = (mean1 - mean2) / se - let df_num = (sd1 * sd1 / n1.to_double() + sd2 * sd2 / n2.to_double()) - let df_den = @math.pow(sd1 * sd1 / n1.to_double(), 2.0) / (n1.to_double() - 1.0) + @math.pow(sd2 * sd2 / n2.to_double(), 2.0) / (n2.to_double() - 1.0) + let df_num = sd1 * sd1 / n1.to_double() + sd2 * sd2 / n2.to_double() + let df_den = @math.pow(sd1 * sd1 / n1.to_double(), 2.0) / + (n1.to_double() - 1.0) + + @math.pow(sd2 * sd2 / n2.to_double(), 2.0) / (n2.to_double() - 1.0) let df = df_num * df_num / df_den let p_val = rstatix_compute_t_p(t_stat, df.to_int(), alternative) let tcrit = rstatix_t_critical(1.0 - conf_level, df.to_int(), alternative) @@ -120,7 +126,7 @@ fn rstatix_t_test_one_sample( let n = x.length() let mean_x = rstatix_mean_double(x) let sd_x = rstatix_sd_double(x) - let se = sd_x / (n.to_double()).sqrt() + let se = sd_x / n.to_double().sqrt() let t_stat = (mean_x - mu) / se let df = n - 1 let p_val = rstatix_compute_t_p(t_stat, df, alternative) @@ -174,7 +180,11 @@ pub fn rstatix_wilcox_test( ///| /// Wilcoxon signed-rank test. -fn rstatix_wilcox_signed(x : Array[Double], alternative : String, method_name : String) -> RstatixTTestResult { +fn rstatix_wilcox_signed( + x : Array[Double], + alternative : String, + method_name : String, +) -> RstatixTTestResult { let non_zero = Array::new() let mut i = 0 while i < x.length() { @@ -222,8 +232,11 @@ fn rstatix_wilcox_signed(x : Array[Double], alternative : String, method_name : i = i + 1 } let w = rstatix_min_double(t_plus, t_minus) - let mu_w = (n.to_double() * (n.to_double() + 1.0)) / 4.0 - let sigma_w = ((n.to_double() * (n.to_double() + 1.0) * (2.0 * n.to_double() + 1.0)) / 24.0).sqrt() + let mu_w = n.to_double() * (n.to_double() + 1.0) / 4.0 + let sigma_w = (n.to_double() * + (n.to_double() + 1.0) * + (2.0 * n.to_double() + 1.0) / + 24.0).sqrt() let z = (w - mu_w) / sigma_w let p_val = rstatix_norm_p(z, alternative) let med_est = rstatix_median_double(non_zero) @@ -293,11 +306,11 @@ fn rstatix_wilcox_rank_sum( r1 = r1 + ranks[i] i = i + 1 } - let u1 = r1 - (n1.to_double() * (n1.to_double() + 1.0)) / 2.0 + let u1 = r1 - n1.to_double() * (n1.to_double() + 1.0) / 2.0 let u2 = n1.to_double() * n2.to_double() - u1 let u = rstatix_min_double(u1, u2) - let mu_u = (n1.to_double() * n2.to_double()) / 2.0 - let sigma_u = ((n1.to_double() * n2.to_double() * (n.to_double() + 1.0)) / 12.0).sqrt() + let mu_u = n1.to_double() * n2.to_double() / 2.0 + let sigma_u = (n1.to_double() * n2.to_double() * (n.to_double() + 1.0) / 12.0).sqrt() let z = (u - mu_u) / sigma_u let p_val = rstatix_norm_p(z, alternative) let median1 = rstatix_median_double(x) @@ -348,7 +361,9 @@ pub fn rstatix_cor_test( let sp = if n > 3 { let t_stat = sr * ((n.to_double() - 2.0) / (1.0 - sr * sr)).sqrt() 2.0 * (1.0 - rstatix_norm_cdf(t_stat.abs())) - } else { @double.not_a_number } + } else { + @double.not_a_number + } (sr, sp, "Spearman's rank correlation") } "kendall" => { @@ -364,7 +379,9 @@ pub fn rstatix_cor_test( let pp = if n > 2 { let t_stat = pr * ((n.to_double() - 2.0) / (1.0 - pr * pr)).sqrt() 2.0 * rstatix_t_dist_p(t_stat.abs(), n - 2) - } else { @double.not_a_number } + } else { + @double.not_a_number + } (pr, pp, "Pearson's product-moment correlation") } } @@ -372,7 +389,7 @@ pub fn rstatix_cor_test( (r, r) } else { let z = 0.5 * @math.ln((1.0 + r) / (1.0 - r)) - let se_z = 1.0 / ((n.to_double() - 3.0).sqrt()) + let se_z = 1.0 / (n.to_double() - 3.0).sqrt() let z_crit = 1.96 (@math.exp(z - z_crit * se_z), @math.exp(z + z_crit * se_z)) } @@ -428,7 +445,10 @@ pub fn rstatix_anova_test( let mut ss_between = 0.0 i = 0 while i < k { - ss_between = ss_between + (n_groups[i].to_double() * (group_means[i] - grand_mean) * (group_means[i] - grand_mean)) + ss_between = ss_between + + n_groups[i].to_double() * + (group_means[i] - grand_mean) * + (group_means[i] - grand_mean) i = i + 1 } let mut ss_within = 0.0 @@ -446,13 +466,27 @@ pub fn rstatix_anova_test( let df_between = k - 1 let df_within = total_n - k let ms_between = ss_between / df_between.to_double() - let ms_within = if df_within > 0 { ss_within / df_within.to_double() } else { 0.0 } + let ms_within = if df_within > 0 { + ss_within / df_within.to_double() + } else { + 0.0 + } let f_stat = if ms_within < 1.0e-15 { - if ss_between < 1.0e-15 { 0.0 } else { @double.infinity } + if ss_between < 1.0e-15 { + 0.0 + } else { + @double.infinity + } } else { ms_between / ms_within } - let p_val = if f_stat == @double.infinity { 0.0 } else if f_stat < 1.0e-15 { 1.0 } else { rstatix_f_p(f_stat, df_between, df_within) } + let p_val = if f_stat == @double.infinity { + 0.0 + } else if f_stat < 1.0e-15 { + 1.0 + } else { + rstatix_f_p(f_stat, df_between, df_within) + } RstatixAnovaResult::{ source: "Between", df: df_between, @@ -510,10 +544,11 @@ pub fn rstatix_kruskal_test( } j = j + 1 } - sum_r_sq = sum_r_sq + (sum_r * sum_r) / n_i.to_double() + sum_r_sq = sum_r_sq + sum_r * sum_r / n_i.to_double() i = i + 1 } - let h = (12.0 / (n_total.to_double() * (n_total.to_double() + 1.0))) * sum_r_sq - 3.0 * (n_total.to_double() + 1.0) + let h = 12.0 / (n_total.to_double() * (n_total.to_double() + 1.0)) * sum_r_sq - + 3.0 * (n_total.to_double() + 1.0) let df = k - 1 let p_val = rstatix_chi2_p(h, df) RstatixAnovaResult::{ @@ -569,7 +604,10 @@ pub fn rstatix_friedman_test( total = total + rank_sums[j] * rank_sums[j] j = j + 1 } - let q = (12.0 / (n_blocks.to_double() * k.to_double() * (k.to_double() + 1.0))) * total - 3.0 * n_blocks.to_double() * (k.to_double() + 1.0) + let q = 12.0 / + (n_blocks.to_double() * k.to_double() * (k.to_double() + 1.0)) * + total - + 3.0 * n_blocks.to_double() * (k.to_double() + 1.0) let df = k - 1 let p_val = rstatix_chi2_p(q, df) RstatixAnovaResult::{ @@ -587,7 +625,9 @@ pub fn rstatix_friedman_test( /// Apply Benjamini-Hochberg FDR correction. pub fn rstatix_bh_correct(p_values : Array[Double]) -> Array[Double] { let n = p_values.length() - if n == 0 { return Array::new() } + if n == 0 { + return Array::new() + } let result = Array::make(n, 0.0) let indices = Array::make(n, 0) let mut i = 0 @@ -595,7 +635,15 @@ pub fn rstatix_bh_correct(p_values : Array[Double]) -> Array[Double] { indices[i] = i i = i + 1 } - indices.sort_by(fn(a : Int, b : Int) -> Int { if p_values[a] < p_values[b] { -1 } else if p_values[a] > p_values[b] { 1 } else { 0 } }) + indices.sort_by(fn(a : Int, b : Int) -> Int { + if p_values[a] < p_values[b] { + -1 + } else if p_values[a] > p_values[b] { + 1 + } else { + 0 + } + }) let mut min_so_far = 1.0 i = n - 1 while i >= 0 { @@ -652,9 +700,25 @@ pub fn rstatix_sample_data() -> Array[Array[Double]] { // ============ Private Helpers ============ -fn rstatix_min_int(a : Int, b : Int) -> Int { if a < b { a } else { b } } -fn rstatix_min_double(a : Double, b : Double) -> Double { if a < b { a } else { b } } +///| +fn rstatix_min_int(a : Int, b : Int) -> Int { + if a < b { + a + } else { + b + } +} +///| +fn rstatix_min_double(a : Double, b : Double) -> Double { + if a < b { + a + } else { + b + } +} + +///| fn rstatix_mean_double(data : Array[Double]) -> Double { let mut sum = 0.0 let mut count = 0 @@ -666,12 +730,19 @@ fn rstatix_mean_double(data : Array[Double]) -> Double { } i = i + 1 } - if count > 0 { sum / count.to_double() } else { 0.0 } + if count > 0 { + sum / count.to_double() + } else { + 0.0 + } } +///| fn rstatix_sd_double(data : Array[Double]) -> Double { let n = data.length() - if n <= 1 { return 0.0 } + if n <= 1 { + return 0.0 + } let mean = rstatix_mean_double(data) let mut sum_sq = 0.0 let mut count = 0 @@ -684,17 +755,29 @@ fn rstatix_sd_double(data : Array[Double]) -> Double { } i = i + 1 } - if count > 1 { (sum_sq / (count.to_double() - 1.0)).sqrt() } else { 0.0 } + if count > 1 { + (sum_sq / (count.to_double() - 1.0)).sqrt() + } else { + 0.0 + } } +///| fn rstatix_median_double(data : Array[Double]) -> Double { - if data.length() == 0 { return 0.0 } + if data.length() == 0 { + return 0.0 + } let sorted = data.copy() sorted.sort() let n = sorted.length() - if n % 2 == 0 { (sorted[n / 2 - 1] + sorted[n / 2]) / 2.0 } else { sorted[n / 2] } + if n % 2 == 0 { + (sorted[n / 2 - 1] + sorted[n / 2]) / 2.0 + } else { + sorted[n / 2] + } } +///| fn rstatix_sub_scalar(data : Array[Double], scalar : Double) -> Array[Double] { let result = Array::make(data.length(), 0.0) let mut i = 0 @@ -705,6 +788,7 @@ fn rstatix_sub_scalar(data : Array[Double], scalar : Double) -> Array[Double] { result } +///| fn rstatix_pearson_val(x : Array[Double], y : Array[Double]) -> Double { let n = x.length() let mean_x = rstatix_mean_double(x) @@ -722,34 +806,57 @@ fn rstatix_pearson_val(x : Array[Double], y : Array[Double]) -> Double { i = i + 1 } let denom = (sum_x2 * sum_y2).sqrt() - if denom < 1.0e-15 { @double.not_a_number } else { sum_xy / denom } + if denom < 1.0e-15 { + @double.not_a_number + } else { + sum_xy / denom + } } +///| fn rstatix_spearman_val(x : Array[Double], y : Array[Double]) -> Double { let rx = rstatix_rank_array(x) let ry = rstatix_rank_array(y) rstatix_pearson_val(rx, ry) } +///| fn rstatix_rank_array(data : Array[Double]) -> Array[Double] { let n = data.length() let indices = Array::make(n, 0) let mut i = 0 - while i < n { indices[i] = i; i = i + 1 } - indices.sort_by(fn(a : Int, b : Int) -> Int { if data[a] < data[b] { -1 } else if data[a] > data[b] { 1 } else { 0 } }) + while i < n { + indices[i] = i + i = i + 1 + } + indices.sort_by(fn(a : Int, b : Int) -> Int { + if data[a] < data[b] { + -1 + } else if data[a] > data[b] { + 1 + } else { + 0 + } + }) let ranks = Array::make(n, 0.0) i = 0 while i < n { let mut j = i - while j < n - 1 && data[indices[j]] == data[indices[j + 1]] { j = j + 1 } - let avg = ((i + j).to_double() / 2.0) + 1.0 + while j < n - 1 && data[indices[j]] == data[indices[j + 1]] { + j = j + 1 + } + let avg = (i + j).to_double() / 2.0 + 1.0 let mut k = i - while k <= j { ranks[indices[k]] = avg; k = k + 1 } + while k <= j { + ranks[indices[k]] = avg + k = k + 1 + } i = j + 1 } ranks } +///| fn rstatix_kendall_tau(x : Array[Double], y : Array[Double]) -> Double { let n = x.length() let mut conc = 0 @@ -760,15 +867,24 @@ fn rstatix_kendall_tau(x : Array[Double], y : Array[Double]) -> Double { while j < n { let dx = x[j] - x[i] let dy = y[j] - y[i] - if dx * dy > 1.0e-15 { conc = conc + 1 } else if dx * dy < -1.0e-15 { disc = disc + 1 } + if dx * dy > 1.0e-15 { + conc = conc + 1 + } else if dx * dy < -1.0e-15 { + disc = disc + 1 + } j = j + 1 } i = i + 1 } - let total = (n * (n - 1)) / 2 - if total > 0 { (conc.to_double() - disc.to_double()) / total.to_double() } else { 0.0 } + let total = n * (n - 1) / 2 + if total > 0 { + (conc.to_double() - disc.to_double()) / total.to_double() + } else { + 0.0 + } } +///| fn rstatix_compute_t_p(t : Double, df : Int, alt : String) -> Double { let p_two = 2.0 * rstatix_t_dist_p(t.abs(), df) match alt { @@ -778,19 +894,29 @@ fn rstatix_compute_t_p(t : Double, df : Int, alt : String) -> Double { } } +///| fn rstatix_t_dist_p(t : Double, df : Int) -> Double { - if df <= 0 || t.is_nan() { return @double.not_a_number } + if df <= 0 || t.is_nan() { + return @double.not_a_number + } let x = df.to_double() / (df.to_double() + t * t) rstatix_ibeta(df.to_double() / 2.0, 0.5, x) } +///| fn rstatix_ibeta(a : Double, b : Double, x : Double) -> Double { - if x < 0.0 || x > 1.0 { return 0.0 } - if x == 0.0 || x == 1.0 { return x } + if x < 0.0 || x > 1.0 { + return 0.0 + } + if x == 0.0 || x == 1.0 { + return x + } let g = 7.0 - let c = [0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, - -176.61502916214059, 12.507343278686905, -0.13857109526572012, - 9.9843695780195716e-6, 1.5056327351493116e-7] + let c = [ + 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, + -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, + 1.5056327351493116e-7, + ] let pi = 3.14159265358979323846 let lbeta = rstatix_lgamma(a) + rstatix_lgamma(b) - rstatix_lgamma(a + b) let front = @math.exp(a * @math.ln(x) + b * @math.ln(1.0 - x) - lbeta) / a @@ -799,62 +925,96 @@ fn rstatix_ibeta(a : Double, b : Double, x : Double) -> Double { let mut f = 1.0 let mut c_val = 1.0 let mut d = 1.0 - (a + b) * x / (a + 1.0) - if d.abs() < 1.0e-30 { d = 1.0e-30 } + if d.abs() < 1.0e-30 { + d = 1.0e-30 + } d = 1.0 / d f = d let mut m = 1 while m <= max_iter { - let n1 = m.to_double() * (b - m.to_double()) * x / ((a + 2.0 * m.to_double() - 1.0) * (a + 2.0 * m.to_double())) + let n1 = m.to_double() * + (b - m.to_double()) * + x / + ((a + 2.0 * m.to_double() - 1.0) * (a + 2.0 * m.to_double())) d = 1.0 + n1 * d - if d.abs() < 1.0e-30 { d = 1.0e-30 } + if d.abs() < 1.0e-30 { + d = 1.0e-30 + } c_val = 1.0 + n1 / c_val - if c_val.abs() < 1.0e-30 { c_val = 1.0e-30 } + if c_val.abs() < 1.0e-30 { + c_val = 1.0e-30 + } d = 1.0 / d f = f * d * c_val - let n2 = -(a + m.to_double()) * (a + b + m.to_double()) * x / ((a + 2.0 * m.to_double()) * (a + 2.0 * m.to_double() + 1.0)) + let n2 = -(a + m.to_double()) * + (a + b + m.to_double()) * + x / + ((a + 2.0 * m.to_double()) * (a + 2.0 * m.to_double() + 1.0)) d = 1.0 + n2 * d - if d.abs() < 1.0e-30 { d = 1.0e-30 } + if d.abs() < 1.0e-30 { + d = 1.0e-30 + } c_val = 1.0 + n2 / c_val - if c_val.abs() < 1.0e-30 { c_val = 1.0e-30 } + if c_val.abs() < 1.0e-30 { + c_val = 1.0e-30 + } d = 1.0 / d let del = d * c_val f = f * del - if (del - 1.0).abs() < eps { break } + if (del - 1.0).abs() < eps { + break + } m = m + 1 } front * f } +///| fn rstatix_lgamma(x : Double) -> Double { - if x <= 0.0 { return @double.not_a_number } + if x <= 0.0 { + return @double.not_a_number + } let g = 7.0 - let c = [0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, - -176.61502916214059, 12.507343278686905, -0.13857109526572012, - 9.9843695780195716e-6, 1.5056327351493116e-7] + let c = [ + 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, + -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, + 1.5056327351493116e-7, + ] let pi = 3.14159265358979323846 - if x < 0.5 { return @math.ln(pi / @math.sin(pi * x)) - rstatix_lgamma(1.0 - x) } + if x < 0.5 { + return @math.ln(pi / @math.sin(pi * x)) - rstatix_lgamma(1.0 - x) + } let mut sum = c[0] let mut i = 1 - while i < 9 { sum = sum + c[i] / (x + i.to_double() - 1.0); i = i + 1 } + while i < 9 { + sum = sum + c[i] / (x + i.to_double() - 1.0) + i = i + 1 + } let t = x + g + 0.5 0.5 * @math.ln(2.0 * pi) + (t * @math.ln(t) - t) + @math.ln(sum) } +///| fn rstatix_t_critical(alpha : Double, df : Int, alt : String) -> Double { let a = if alt == "two.sided" { alpha / 2.0 } else { alpha } rstatix_approx_tc(a, df) } +///| fn rstatix_approx_tc(alpha : Double, df : Int) -> Double { let z = rstatix_norm_q(1.0 - alpha) let df_d = df.to_double() - z + (z * z * z + z) / (4.0 * df_d) + (5.0 * z + 16.0 * z * z * z + 3.0 * @math.pow(z, 5.0)) / (96.0 * df_d * df_d) + z + + (z * z * z + z) / (4.0 * df_d) + + (5.0 * z + 16.0 * z * z * z + 3.0 * @math.pow(z, 5.0)) / (96.0 * df_d * df_d) } +///| fn rstatix_norm_cdf(x : Double) -> Double { 0.5 * (1.0 + rstatix_erf(x / 1.4142135623730951)) } +///| fn rstatix_erf(x : Double) -> Double { let t = 1.0 / (1.0 + 0.3275911 * x.abs()) let a1 = 0.254829592 @@ -862,21 +1022,41 @@ fn rstatix_erf(x : Double) -> Double { let a3 = 1.421413741 let a4 = -1.453152027 let a5 = 1.061405429 - let res = 1.0 - (a1 * t + a2 * t * t + a3 * t * t * t + a4 * t * t * t * t + a5 * t * t * t * t * t) * @math.exp(-x * x) - if x >= 0.0 { res } else { -res } + let res = 1.0 - + ( + a1 * t + + a2 * t * t + + a3 * t * t * t + + a4 * t * t * t * t + + a5 * t * t * t * t * t + ) * + @math.exp(-x * x) + if x >= 0.0 { + res + } else { + -res + } } +///| fn rstatix_norm_q(p : Double) -> Double { - if p <= 0.0 || p >= 1.0 { return @double.not_a_number } + if p <= 0.0 || p >= 1.0 { + return @double.not_a_number + } if p < 0.5 { let eta = (-2.0 * @math.ln(p)).sqrt() - -(eta - (2.515517 + 0.802853 * eta + 0.010328 * eta * eta) / (1.0 + 1.432788 * eta + 0.189269 * eta * eta + 0.001308 * eta * eta * eta)) + -(eta - + (2.515517 + 0.802853 * eta + 0.010328 * eta * eta) / + (1.0 + 1.432788 * eta + 0.189269 * eta * eta + 0.001308 * eta * eta * eta)) } else { let eta = (-2.0 * @math.ln(1.0 - p)).sqrt() - eta - (2.515517 + 0.802853 * eta + 0.010328 * eta * eta) / (1.0 + 1.432788 * eta + 0.189269 * eta * eta + 0.001308 * eta * eta * eta) + eta - + (2.515517 + 0.802853 * eta + 0.010328 * eta * eta) / + (1.0 + 1.432788 * eta + 0.189269 * eta * eta + 0.001308 * eta * eta * eta) } } +///| fn rstatix_norm_p(z : Double, alt : String) -> Double { let p_two = 2.0 * (1.0 - rstatix_norm_cdf(z.abs())) match alt { @@ -886,21 +1066,32 @@ fn rstatix_norm_p(z : Double, alt : String) -> Double { } } +///| fn rstatix_f_p(f : Double, df1 : Int, df2 : Int) -> Double { - if f <= 0.0 { return 1.0 } + if f <= 0.0 { + return 1.0 + } let x = df1.to_double() / (df1.to_double() + df2.to_double() * f) 1.0 - rstatix_ibeta(df1.to_double() / 2.0, df2.to_double() / 2.0, x) } +///| fn rstatix_chi2_p(chi2 : Double, df : Int) -> Double { - if chi2 <= 0.0 { return 1.0 } + if chi2 <= 0.0 { + return 1.0 + } let x = chi2 / (chi2 + (df.to_double() + 2.0)) 1.0 - rstatix_ibeta(df.to_double() / 2.0, 0.5, x) } +///| fn rstatix_fmt(v : Double) -> String { - if v.is_nan() { return "NA" } - if v == @double.infinity || v == @double.neg_infinity { return "Inf" } + if v.is_nan() { + return "NA" + } + if v == @double.infinity || v == @double.neg_infinity { + return "Inf" + } let r = (v * 10000.0).round() / 10000.0 "\{r}" } diff --git a/src/rtsne.mbt b/src/rtsne.mbt index 855c42f6..a62a3fd8 100644 --- a/src/rtsne.mbt +++ b/src/rtsne.mbt @@ -44,17 +44,17 @@ pub fn TsneConfig::new_custom( random_seed : Int, ) -> TsneConfig { TsneConfig::{ - perplexity: perplexity, + perplexity, theta: 0.5, - max_iter: max_iter, - dims: dims, + max_iter, + dims, eta: 200.0, exaggeration_factor: 12.0, momentum: 0.5, final_momentum: 0.8, mom_switch_iter: 250, stop_lying_iter: 250, - random_seed: random_seed, + random_seed, } } @@ -68,11 +68,7 @@ pub struct TsneResult { ///| pub fn TsneResult::new() -> TsneResult { - TsneResult::{ - embedding: Array::new(), - costs: Array::new(), - n_iter: 0, - } + TsneResult::{ embedding: Array::new(), costs: Array::new(), n_iter: 0 } } // ============================================================ @@ -83,14 +79,16 @@ pub fn TsneResult::new() -> TsneResult { /// Calculate pairwise Euclidean distances between data points. /// Input: data matrix (rows = samples, cols = features) /// Output: distance matrix (n x n) -pub fn calc_distance_matrix(data : Array[Array[Double]]) -> Array[Array[Double]] { +pub fn calc_distance_matrix( + data : Array[Array[Double]], +) -> Array[Array[Double]] { let n = data.length() let dist_matrix : Array[Array[Double]] = Array::new() - + if n == 0 { return dist_matrix } - + let mut i = 0 while i < n { let row : Array[Double] = Array::new() @@ -102,7 +100,7 @@ pub fn calc_distance_matrix(data : Array[Array[Double]]) -> Array[Array[Double]] dist_matrix.push(row) i = i + 1 } - + let mut i = 0 while i < n { let mut j = i + 1 @@ -114,10 +112,11 @@ pub fn calc_distance_matrix(data : Array[Array[Double]]) -> Array[Array[Double]] } i = i + 1 } - + dist_matrix } +///| fn rtsne_euclidean_distance(x : Array[Double], y : Array[Double]) -> Double { let mut sum_sq = 0.0 let n = if x.length() < y.length() { x.length() } else { y.length() } @@ -136,21 +135,25 @@ fn rtsne_euclidean_distance(x : Array[Double], y : Array[Double]) -> Double { ///| /// Compute the probability distribution p_{j|i} using binary search for perplexity. -fn compute_p_ji(distances : Array[Double], perplexity : Double, n : Int) -> Array[Double] { +fn compute_p_ji( + distances : Array[Double], + perplexity : Double, + n : Int, +) -> Array[Double] { let p : Array[Double] = Array::new() let mut i = 0 while i < n { p.push(0.0) i = i + 1 } - + let log_perp = @math.ln(perplexity) - + // Binary search for sigma (precision) - let mut beta = 1.0 // beta = 1 / (2 * sigma^2) + let mut beta = 1.0 // beta = 1 / (2 * sigma^2) let mut min_beta = -1.0e300 let mut max_beta = 1.0e300 - + let mut iter_count = 0 while iter_count < 50 { // Compute P values @@ -162,11 +165,11 @@ fn compute_p_ji(distances : Array[Double], perplexity : Double, n : Int) -> Arra sum_p = sum_p + p_val i = i + 1 } - + if sum_p == 0.0 { sum_p = 1.0e-10 } - + // Normalize let mut h = 0.0 i = 0 @@ -177,13 +180,13 @@ fn compute_p_ji(distances : Array[Double], perplexity : Double, n : Int) -> Arra } i = i + 1 } - + let h_diff = h - log_perp - + if h_diff.abs() < 1.0e-5 { break } - + if h_diff > 0.0 { // Entropy is too high, need to increase beta (decrease sigma) min_beta = beta @@ -201,18 +204,21 @@ fn compute_p_ji(distances : Array[Double], perplexity : Double, n : Int) -> Arra beta = (beta + min_beta) / 2.0 } } - + iter_count = iter_count + 1 } - + p } ///| /// Compute joint probability matrix P from distance matrix. -fn compute_p_matrix(dist_matrix : Array[Array[Double]], perplexity : Double) -> Array[Array[Double]] { +fn compute_p_matrix( + dist_matrix : Array[Array[Double]], + perplexity : Double, +) -> Array[Array[Double]] { let n = dist_matrix.length() - + let p_matrix : Array[Array[Double]] = Array::new() let mut i = 0 while i < n { @@ -225,7 +231,7 @@ fn compute_p_matrix(dist_matrix : Array[Array[Double]], perplexity : Double) -> p_matrix.push(row) i = i + 1 } - + // Compute P_{j|i} for each i let mut i = 0 while i < n { @@ -237,7 +243,7 @@ fn compute_p_matrix(dist_matrix : Array[Array[Double]], perplexity : Double) -> } i = i + 1 } - + // Symmetrize: P_{ij} = (P_{j|i} + P_{i|j}) / (2n) let mut i = 0 while i < n { @@ -248,7 +254,7 @@ fn compute_p_matrix(dist_matrix : Array[Array[Double]], perplexity : Double) -> } i = i + 1 } - + p_matrix } @@ -262,11 +268,11 @@ fn compute_p_matrix(dist_matrix : Array[Array[Double]], perplexity : Double) -> /// Output: t-SNE embedding (n x dims) pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { let n = data.length() - + if n == 0 { return TsneResult::new() } - + if n < 2 { let result = TsneResult::new() let embedding : Array[Array[Double]] = Array::new() @@ -279,13 +285,13 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { embedding.push(row) return result } - + // Step 1: Compute pairwise distances let dist_matrix = calc_distance_matrix(data) - + // Step 2: Compute joint probability matrix P let p_matrix = compute_p_matrix(dist_matrix, config.perplexity) - + // Step 3: Initialize Y (the embedding) with small random values let y : Array[Array[Double]] = Array::new() let mut i = 0 @@ -302,12 +308,12 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { y.push(row) i = i + 1 } - + // Step 4: Gradient descent - let d_y : Array[Array[Double]] = Array::new() // gradient - let u_y : Array[Array[Double]] = Array::new() // update (momentum) - let gains : Array[Array[Double]] = Array::new() // learning rate gains - + let d_y : Array[Array[Double]] = Array::new() // gradient + let u_y : Array[Array[Double]] = Array::new() // update (momentum) + let gains : Array[Array[Double]] = Array::new() // learning rate gains + let mut i = 0 while i < n { let d_row : Array[Double] = Array::new() @@ -325,16 +331,16 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { gains.push(g_row) i = i + 1 } - + let costs : Array[Double] = Array::new() let mut momentum = config.momentum - + let mut iter = 0 while iter < config.max_iter { // Compute Q matrix (low-dimensional similarities) let q_matrix : Array[Array[Double]] = Array::new() let mut sum_q = 0.0 - + let mut i = 0 while i < n { let row : Array[Double] = Array::new() @@ -346,7 +352,7 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { q_matrix.push(row) i = i + 1 } - + let mut i = 0 while i < n { let mut j = i + 1 @@ -359,21 +365,21 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { sq_dist = sq_dist + diff * diff d = d + 1 } - + let q_val = 1.0 / (1.0 + sq_dist) q_matrix[i][j] = q_val q_matrix[j][i] = q_val sum_q = sum_q + 2.0 * q_val - + j = j + 1 } i = i + 1 } - + if sum_q == 0.0 { sum_q = 1.0e-10 } - + // Normalize Q let mut i = 0 while i < n { @@ -384,7 +390,7 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { } i = i + 1 } - + // Compute cost (KL divergence) let mut cost = 0.0 let mut i = 0 @@ -392,14 +398,15 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { let mut j = 0 while j < n { if i != j && p_matrix[i][j] > 0.0 { - cost = cost + p_matrix[i][j] * @math.ln(p_matrix[i][j] / q_matrix[i][j]) + cost = cost + + p_matrix[i][j] * @math.ln(p_matrix[i][j] / q_matrix[i][j]) } j = j + 1 } i = i + 1 } costs.push(cost) - + // Compute gradient let mut i = 0 while i < n { @@ -408,7 +415,7 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { d_y[i][d] = 0.0 d = d + 1 } - + let mut j = 0 while j < n { if i != j { @@ -419,9 +426,9 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { sq_dist = sq_dist + diff * diff d = d + 1 } - + let mult = (p_matrix[i][j] - q_matrix[i][j]) * (1.0 / (1.0 + sq_dist)) - + let mut d = 0 while d < config.dims { d_y[i][d] = d_y[i][d] + 4.0 * mult * (y[i][d] - y[j][d]) @@ -432,12 +439,12 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { } i = i + 1 } - + // Update momentum if iter == config.mom_switch_iter { momentum = config.final_momentum } - + // Stop exaggeration if iter == config.stop_lying_iter { let mut i = 0 @@ -450,7 +457,7 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { i = i + 1 } } - + // Apply early exaggeration if iter < config.stop_lying_iter { let mut i = 0 @@ -463,46 +470,44 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { i = i + 1 } } - + // Update gains and apply momentum let mut i = 0 while i < n { let mut d = 0 while d < config.dims { // Update gain - if (d_y[i][d] > 0.0 && u_y[i][d] > 0.0) || (d_y[i][d] < 0.0 && u_y[i][d] < 0.0) { + if (d_y[i][d] > 0.0 && u_y[i][d] > 0.0) || + (d_y[i][d] < 0.0 && u_y[i][d] < 0.0) { gains[i][d] = gains[i][d] * 0.8 } else { gains[i][d] = gains[i][d] + 0.2 } - + if gains[i][d] < 0.01 { gains[i][d] = 0.01 } - + // Update with momentum u_y[i][d] = momentum * u_y[i][d] - config.eta * gains[i][d] * d_y[i][d] y[i][d] = y[i][d] + u_y[i][d] - + d = d + 1 } i = i + 1 } - + iter = iter + 1 } - - TsneResult::{ - embedding: y, - costs: costs, - n_iter: config.max_iter, - } + + TsneResult::{ embedding: y, costs, n_iter: config.max_iter } } // ============================================================ // Helper functions // ============================================================ +///| fn pseudo_random(seed : Double) -> Double { // Simple deterministic pseudo-random number generator let x = seed * 12.9898 @@ -515,14 +520,17 @@ fn pseudo_random(seed : Double) -> Double { ///| /// Create sample data for testing/demo. -pub fn create_tsne_test_data(n_samples : Int, n_features : Int) -> Array[Array[Double]] { +pub fn create_tsne_test_data( + n_samples : Int, + n_features : Int, +) -> Array[Array[Double]] { let data : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_samples { let row : Array[Double] = Array::new() - let group = i % 3 // 3 clusters - + let group = i % 3 // 3 clusters + let mut j = 0 while j < n_features { let seed_val = (i * n_features + j).to_double() @@ -531,10 +539,10 @@ pub fn create_tsne_test_data(n_samples : Int, n_features : Int) -> Array[Array[D row.push(cluster_center + noise) j = j + 1 } - + data.push(row) i = i + 1 } - + data } diff --git a/src/s4vectors.mbt b/src/s4vectors.mbt index 3653ddf4..8620a49a 100644 --- a/src/s4vectors.mbt +++ b/src/s4vectors.mbt @@ -17,14 +17,14 @@ pub fn Rle::new(values : Array[String], lengths : Array[Int]) -> Rle { pub fn Rle::from_vector(vec : Array[String]) -> Rle { let values : Array[String] = Array::new() let lengths : Array[Int] = Array::new() - + if vec.length() == 0 { return Rle::{ values, lengths } } - + let mut current_value = vec[0] let mut current_length = 1 - + let mut i = 1 while i < vec.length() { if vec[i] == current_value { @@ -37,10 +37,10 @@ pub fn Rle::from_vector(vec : Array[String]) -> Rle { } i = i + 1 } - + values.push(current_value) lengths.push(current_length) - + Rle::{ values, lengths } } @@ -58,7 +58,7 @@ pub fn Rle::length(self : Rle) -> Int { ///| pub fn Rle::decode(self : Rle) -> Array[String] { let result : Array[String] = Array::new() - + let mut i = 0 while i < self.values.length() { let mut j = 0 @@ -68,14 +68,14 @@ pub fn Rle::decode(self : Rle) -> Array[String] { } i = i + 1 } - + result } ///| pub fn Rle::get(self : Rle, idx : Int) -> String { let mut pos = 0 - + let mut i = 0 while i < self.lengths.length() { if pos + self.lengths[i] > idx { @@ -84,7 +84,7 @@ pub fn Rle::get(self : Rle, idx : Int) -> String { pos = pos + self.lengths[i] i = i + 1 } - + "" } @@ -92,11 +92,11 @@ pub fn Rle::get(self : Rle, idx : Int) -> String { pub fn Rle::compress_ratio(self : Rle) -> Double { let original_size = self.length() let compressed_size = self.values.length() + self.lengths.length() - + if original_size == 0 { return 0.0 } - + original_size.to_double() / compressed_size.to_double() } @@ -107,7 +107,10 @@ pub struct S4DataFrameColumn { } ///| -pub fn S4DataFrameColumn::new(name : String, values : Array[String]) -> S4DataFrameColumn { +pub fn S4DataFrameColumn::new( + name : String, + values : Array[String], +) -> S4DataFrameColumn { S4DataFrameColumn::{ name, values } } @@ -118,7 +121,10 @@ pub struct S4DataFrame { } ///| -pub fn S4DataFrame::new(columns : Array[S4DataFrameColumn], row_names : Array[String]) -> S4DataFrame { +pub fn S4DataFrame::new( + columns : Array[S4DataFrameColumn], + row_names : Array[String], +) -> S4DataFrame { S4DataFrame::{ columns, row_names } } @@ -138,18 +144,21 @@ pub fn S4DataFrame::ncol(self : S4DataFrame) -> Int { ///| pub fn S4DataFrame::colnames(self : S4DataFrame) -> Array[String] { let names : Array[String] = Array::new() - + let mut i = 0 while i < self.columns.length() { names.push(self.columns[i].name) i = i + 1 } - + names } ///| -pub fn S4DataFrame::get_column(self : S4DataFrame, name : String) -> S4DataFrameColumn? { +pub fn S4DataFrame::get_column( + self : S4DataFrame, + name : String, +) -> S4DataFrameColumn? { let mut i = 0 while i < self.columns.length() { if self.columns[i].name == name { @@ -157,14 +166,14 @@ pub fn S4DataFrame::get_column(self : S4DataFrame, name : String) -> S4DataFrame } i = i + 1 } - + None } ///| pub fn S4DataFrame::get_row(self : S4DataFrame, idx : Int) -> Array[String] { let result : Array[String] = Array::new() - + let mut i = 0 while i < self.columns.length() { if idx < self.columns[i].values.length() { @@ -174,15 +183,18 @@ pub fn S4DataFrame::get_row(self : S4DataFrame, idx : Int) -> Array[String] { } i = i + 1 } - + result } ///| -pub fn S4DataFrame::subset_rows(self : S4DataFrame, indices : Array[Int]) -> S4DataFrame { +pub fn S4DataFrame::subset_rows( + self : S4DataFrame, + indices : Array[Int], +) -> S4DataFrame { let new_columns : Array[S4DataFrameColumn] = Array::new() let new_row_names : Array[String] = Array::new() - + let mut i = 0 while i < self.columns.length() { let col_values : Array[String] = Array::new() @@ -197,7 +209,7 @@ pub fn S4DataFrame::subset_rows(self : S4DataFrame, indices : Array[Int]) -> S4D new_columns.push(S4DataFrameColumn::new(self.columns[i].name, col_values)) i = i + 1 } - + let mut j = 0 while j < indices.length() { let idx = indices[j] @@ -206,7 +218,7 @@ pub fn S4DataFrame::subset_rows(self : S4DataFrame, indices : Array[Int]) -> S4D } j = j + 1 } - + S4DataFrame::new(new_columns, new_row_names) } @@ -219,7 +231,12 @@ pub struct Hits { } ///| -pub fn Hits::new(query_hits : Array[Int], subject_hits : Array[Int], query_length : Int, subject_length : Int) -> Hits { +pub fn Hits::new( + query_hits : Array[Int], + subject_hits : Array[Int], + query_length : Int, + subject_length : Int, +) -> Hits { Hits::{ query_hits, subject_hits, query_length, subject_length } } @@ -231,7 +248,7 @@ pub fn Hits::n_hits(self : Hits) -> Int { ///| pub fn Hits::count_query_hits(self : Hits) -> Array[Int] { let counts : Array[Int] = Array::make(self.query_length, 0) - + let mut i = 0 while i < self.query_hits.length() { let idx = self.query_hits[i] @@ -240,14 +257,14 @@ pub fn Hits::count_query_hits(self : Hits) -> Array[Int] { } i = i + 1 } - + counts } ///| pub fn Hits::count_subject_hits(self : Hits) -> Array[Int] { let counts : Array[Int] = Array::make(self.subject_length, 0) - + let mut i = 0 while i < self.subject_hits.length() { let idx = self.subject_hits[i] @@ -256,14 +273,14 @@ pub fn Hits::count_subject_hits(self : Hits) -> Array[Int] { } i = i + 1 } - + counts } ///| pub fn Hits::find_hits(self : Hits, query_idx : Int) -> Array[Int] { let result : Array[Int] = Array::new() - + let mut i = 0 while i < self.query_hits.length() { if self.query_hits[i] == query_idx { @@ -271,20 +288,20 @@ pub fn Hits::find_hits(self : Hits, query_idx : Int) -> Array[Int] { } i = i + 1 } - + result } ///| pub fn Hits::as_matrix(self : Hits) -> Array[(Int, Int)] { let result : Array[(Int, Int)] = Array::new() - + let mut i = 0 while i < self.query_hits.length() { result.push((self.query_hits[i], self.subject_hits[i])) i = i + 1 } - + result } @@ -296,10 +313,16 @@ pub fn create_example_rle() -> Rle { ///| pub fn create_example_dataframe() -> S4DataFrame { - let col1 = S4DataFrameColumn::new("gene_id", ["gene1", "gene2", "gene3", "gene4", "gene5"]) - let col2 = S4DataFrameColumn::new("expression", ["10.5", "25.3", "5.8", "100.2", "15.7"]) - let col3 = S4DataFrameColumn::new("p_value", ["0.001", "0.05", "0.8", "0.0001", "0.1"]) - + let col1 = S4DataFrameColumn::new("gene_id", [ + "gene1", "gene2", "gene3", "gene4", "gene5", + ]) + let col2 = S4DataFrameColumn::new("expression", [ + "10.5", "25.3", "5.8", "100.2", "15.7", + ]) + let col3 = S4DataFrameColumn::new("p_value", [ + "0.001", "0.05", "0.8", "0.0001", "0.1", + ]) + S4DataFrame::new([col1, col2, col3], ["row1", "row2", "row3", "row4", "row5"]) } @@ -307,6 +330,6 @@ pub fn create_example_dataframe() -> S4DataFrame { pub fn create_example_hits() -> Hits { let query_hits = [0, 0, 1, 2, 2, 2, 3] let subject_hits = [1, 3, 0, 1, 2, 4, 2] - + Hits::new(query_hits, subject_hits, 4, 5) -} \ No newline at end of file +} diff --git a/src/sasa.mbt b/src/sasa.mbt index b590216a..d7906f64 100644 --- a/src/sasa.mbt +++ b/src/sasa.mbt @@ -268,7 +268,7 @@ pub fn sasa_generate_sphere_points(n : Int) -> Array[Vector3] { let golden_angle = 3.14159265358979323846 * (3.0 - 5.0.sqrt()) let denom = (count - 1).to_double() for i in 0.. SC3Result { - SC3Result::{ cluster_labels, consensus_matrix, k, silhouette_scores, gap_statistics, optimal_k } + SC3Result::{ + cluster_labels, + consensus_matrix, + k, + silhouette_scores, + gap_statistics, + optimal_k, + } } ///| @@ -31,9 +38,9 @@ pub fn SC3Result::new( pub fn sc3_preprocess(data : Array[Array[Double]]) -> Array[Array[Double]] { let n = data.length() let dim = if n > 0 { data[0].length() } else { 0 } - + let processed : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let row : Array[Double] = Array::new() @@ -43,26 +50,29 @@ pub fn sc3_preprocess(data : Array[Array[Double]]) -> Array[Array[Double]] { sum = sum + data[i][j] j = j + 1 } - + let mut k = 0 while k < dim { row.push(if sum > 0.0 { data[i][k] / sum * 1000000.0 } else { 0.0 }) k = k + 1 } - + processed.push(row) i = i + 1 } - + processed } ///| /// Compute PCA on preprocessed data. -pub fn sc3_pca(data : Array[Array[Double]], n_components : Int) -> Array[Array[Double]] { +pub fn sc3_pca( + data : Array[Array[Double]], + n_components : Int, +) -> Array[Array[Double]] { let n = data.length() let dim = if n > 0 { data[0].length() } else { 0 } - + let means : Array[Double] = Array::new() let mut i = 0 while i < dim { @@ -75,7 +85,7 @@ pub fn sc3_pca(data : Array[Array[Double]], n_components : Int) -> Array[Array[D means.push(sum / n.to_double()) i = i + 1 } - + let centered : Array[Array[Double]] = Array::new() let mut k = 0 while k < n { @@ -88,7 +98,7 @@ pub fn sc3_pca(data : Array[Array[Double]], n_components : Int) -> Array[Array[D centered.push(row) k = k + 1 } - + let covariance : Array[Array[Double]] = Array::new() let mut m = 0 while m < dim { @@ -107,9 +117,9 @@ pub fn sc3_pca(data : Array[Array[Double]], n_components : Int) -> Array[Array[D covariance.push(row) m = m + 1 } - + let eigenvalues = sc3_power_iteration(covariance, n_components) - + let components : Array[Array[Double]] = Array::new() let mut r = 0 while r < n_components && r < eigenvalues.length() { @@ -128,7 +138,7 @@ pub fn sc3_pca(data : Array[Array[Double]], n_components : Int) -> Array[Array[D components.push(component) r = r + 1 } - + let transposed : Array[Array[Double]] = Array::new() let mut u = 0 while u < n { @@ -141,25 +151,28 @@ pub fn sc3_pca(data : Array[Array[Double]], n_components : Int) -> Array[Array[D transposed.push(row) u = u + 1 } - + transposed } ///| /// Power iteration for eigenvalue decomposition. -pub fn sc3_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> Array[Array[Double]] { +pub fn sc3_power_iteration( + matrix : Array[Array[Double]], + n_components : Int, +) -> Array[Array[Double]] { let n = matrix.length() let components : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_components { let v : Array[Double] = Array::new() let mut j = 0 while j < n { - v.push(((i + 1).to_double() / (j + 1).to_double()) - 0.5) + v.push((i + 1).to_double() / (j + 1).to_double() - 0.5) j = j + 1 } - + let mut iter = 0 while iter < 100 { let v_new : Array[Double] = Array::new() @@ -174,7 +187,7 @@ pub fn sc3_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> v_new.push(sum) k = k + 1 } - + let mut norm = 0.0 let mut m = 0 while m < n { @@ -182,18 +195,18 @@ pub fn sc3_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> m = m + 1 } norm = norm.sqrt() - + let mut p = 0 while p < n { v.set(p, v_new[p] / norm) p = p + 1 } - + iter = iter + 1 } - + components.push(v) - + let mut q = 0 while q < n { let mut r = 0 @@ -209,10 +222,10 @@ pub fn sc3_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> } q = q + 1 } - + i = i + 1 } - + components } @@ -221,10 +234,10 @@ pub fn sc3_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> pub fn sc3_calculate_consensus_matrix( data : Array[Array[Double]], k : Int, - n_iterations : Int + n_iterations : Int, ) -> Array[Array[Double]] { let n = data.length() - + let consensus : Array[Array[Double]] = Array::new() let mut i = 0 while i < n { @@ -237,11 +250,11 @@ pub fn sc3_calculate_consensus_matrix( consensus.push(row) i = i + 1 } - + let mut iter = 0 while iter < n_iterations { let labels = sc3_kmeans(data, k) - + let mut a = 0 while a < n { let mut b = 0 @@ -253,10 +266,10 @@ pub fn sc3_calculate_consensus_matrix( } a = a + 1 } - + iter = iter + 1 } - + let mut x = 0 while x < n { let mut y = 0 @@ -266,7 +279,7 @@ pub fn sc3_calculate_consensus_matrix( } x = x + 1 } - + consensus } @@ -275,31 +288,31 @@ pub fn sc3_calculate_consensus_matrix( pub fn sc3_kmeans(data : Array[Array[Double]], k : Int) -> Array[Int] { let n = data.length() let dim = if n > 0 { data[0].length() } else { 0 } - + let centroids : Array[Array[Double]] = Array::new() let mut c = 0 while c < k && c < n { centroids.push(data[c]) c = c + 1 } - + let labels : Array[Int] = Array::new() let mut j = 0 while j < n { labels.push(0) j = j + 1 } - + let mut changed = true let mut iterations = 0 while changed && iterations < 100 { changed = false - + let mut p = 0 while p < n { let mut min_dist = 10000000000.0 let mut best_cluster = 0 - + let mut q = 0 while q < centroids.length() { let dist = sc3_euclidean_distance(data[p], centroids[q]) @@ -309,14 +322,14 @@ pub fn sc3_kmeans(data : Array[Array[Double]], k : Int) -> Array[Int] { } q = q + 1 } - + if labels[p] != best_cluster { labels.set(p, best_cluster) changed = true } p = p + 1 } - + let mut r = 0 while r < centroids.length() { let sum : Array[Double] = Array::new() @@ -325,7 +338,7 @@ pub fn sc3_kmeans(data : Array[Array[Double]], k : Int) -> Array[Int] { sum.push(0.0) s = s + 1 } - + let mut count = 0 let mut t = 0 while t < n { @@ -339,7 +352,7 @@ pub fn sc3_kmeans(data : Array[Array[Double]], k : Int) -> Array[Int] { } t = t + 1 } - + if count > 0 { let mut v = 0 while v < dim { @@ -349,10 +362,10 @@ pub fn sc3_kmeans(data : Array[Array[Double]], k : Int) -> Array[Int] { } r = r + 1 } - + iterations = iterations + 1 } - + labels } @@ -374,15 +387,15 @@ pub fn sc3_euclidean_distance(v1 : Array[Double], v2 : Array[Double]) -> Double pub fn sc3_calculate_silhouette( data : Array[Array[Double]], labels : Array[Int], - k : Int + k : Int, ) -> Array[Double] { let n = data.length() let scores : Array[Double] = Array::new() - + let mut i = 0 while i < n { let label = labels[i] - + let mut a_sum = 0.0 let mut a_count = 0 let mut j = 0 @@ -394,7 +407,7 @@ pub fn sc3_calculate_silhouette( j = j + 1 } let a = if a_count > 0 { a_sum / a_count.to_double() } else { 0.0 } - + let mut b_min = 10000000000.0 let mut c = 0 while c < k { @@ -418,17 +431,17 @@ pub fn sc3_calculate_silhouette( } c = c + 1 } - + let max_ab = if a > b_min { a } else { b_min } if max_ab > 0.0 { scores.push((b_min - a) / max_ab) } else { scores.push(0.0) } - + i = i + 1 } - + scores } @@ -436,16 +449,16 @@ pub fn sc3_calculate_silhouette( /// Calculate gap statistics. pub fn sc3_calculate_gap_statistics( data : Array[Array[Double]], - k : Int + k : Int, ) -> Array[Double] { let n = data.length() - + let gaps : Array[Double] = Array::new() - + let mut current_k = 1 while current_k <= k { let w = sc3_calculate_wcss(data, current_k) - + let mut w_null_sum = 0.0 let mut b = 0 while b < 10 { @@ -454,12 +467,12 @@ pub fn sc3_calculate_gap_statistics( w_null_sum = w_null_sum + @math.ln(w_null) b = b + 1 } - + gaps.push(w_null_sum / 10.0 - @math.ln(w)) - + current_k = current_k + 1 } - + gaps } @@ -469,7 +482,7 @@ pub fn sc3_calculate_wcss(data : Array[Array[Double]], k : Int) -> Double { let labels = sc3_kmeans(data, k) let n = data.length() let dim = if n > 0 { data[0].length() } else { 0 } - + let centroids : Array[Array[Double]] = Array::new() let mut i = 0 while i < k { @@ -482,14 +495,14 @@ pub fn sc3_calculate_wcss(data : Array[Array[Double]], k : Int) -> Double { centroids.push(centroid) i = i + 1 } - + let counts : Array[Int] = Array::new() let mut c = 0 while c < k { counts.push(0) c = c + 1 } - + let mut m = 0 while m < n { let label = labels[m] @@ -501,7 +514,7 @@ pub fn sc3_calculate_wcss(data : Array[Array[Double]], k : Int) -> Double { counts.set(label, counts[label] + 1) m = m + 1 } - + let mut q = 0 while q < k { if counts[q] > 0 { @@ -513,7 +526,7 @@ pub fn sc3_calculate_wcss(data : Array[Array[Double]], k : Int) -> Double { } q = q + 1 } - + let mut wcss = 0.0 let mut s = 0 while s < n { @@ -521,19 +534,22 @@ pub fn sc3_calculate_wcss(data : Array[Array[Double]], k : Int) -> Double { wcss = wcss + sc3_euclidean_distance(data[s], centroids[label]).pow(2) s = s + 1 } - + wcss } ///| /// Generate null data for gap statistics. -pub fn sc3_generate_null_data(data : Array[Array[Double]], seed : Int) -> Array[Array[Double]] { +pub fn sc3_generate_null_data( + data : Array[Array[Double]], + seed : Int, +) -> Array[Array[Double]] { let n = data.length() let dim = if n > 0 { data[0].length() } else { 0 } - + let mins : Array[Double] = Array::new() let maxes : Array[Double] = Array::new() - + let mut j = 0 while j < dim { let mut min_val = 10000000000.0 @@ -549,14 +565,14 @@ pub fn sc3_generate_null_data(data : Array[Array[Double]], seed : Int) -> Array[ maxes.push(max_val) j = j + 1 } - + let null_data : Array[Array[Double]] = Array::new() let mut k = 0 while k < n { let row : Array[Double] = Array::new() let mut l = 0 while l < dim { - let state = (seed * 1103515245 + k * 12345 + l * 98765) >> 16 & 0x7fff + let state = ((seed * 1103515245 + k * 12345 + l * 98765) >> 16) & 0x7fff let rand_val = state.to_double() / 32767.0 row.push(mins[l] + rand_val * (maxes[l] - mins[l])) l = l + 1 @@ -564,7 +580,7 @@ pub fn sc3_generate_null_data(data : Array[Array[Double]], seed : Int) -> Array[ null_data.push(row) k = k + 1 } - + null_data } @@ -574,43 +590,53 @@ pub fn sc3_consensus_cluster( data : Array[Array[Double]], k : Int, n_iterations? : Int = 100, - n_pcs? : Int = 50 + n_pcs? : Int = 50, ) -> SC3Result { let processed = sc3_preprocess(data) let pcs = sc3_pca(processed, n_pcs) - + let consensus_matrix = sc3_calculate_consensus_matrix(pcs, k, n_iterations) let cluster_labels = sc3_kmeans(pcs, k) let silhouette_scores = sc3_calculate_silhouette(pcs, cluster_labels, k) let gap_statistics = sc3_calculate_gap_statistics(pcs, k) - + let mut optimal_k = k let mut max_gap_diff = 0.0 let mut g = 1 while g < gap_statistics.length() { - let diff = gap_statistics[g] - gap_statistics[g-1] + let diff = gap_statistics[g] - gap_statistics[g - 1] if diff > max_gap_diff { max_gap_diff = diff optimal_k = g + 1 } g = g + 1 } - - SC3Result::new(cluster_labels, consensus_matrix, k, silhouette_scores, gap_statistics, optimal_k) + + SC3Result::new( + cluster_labels, consensus_matrix, k, silhouette_scores, gap_statistics, optimal_k, + ) } ///| /// Bio API functions. - pub fn bio_sc3_cluster(data : Array[Array[Double]], k : Int) -> SC3Result { sc3_consensus_cluster(data, k) } -pub fn bio_sc3_pca(data : Array[Array[Double]], n_components : Int) -> Array[Array[Double]] { +///| +pub fn bio_sc3_pca( + data : Array[Array[Double]], + n_components : Int, +) -> Array[Array[Double]] { let processed = sc3_preprocess(data) sc3_pca(processed, n_components) } -pub fn bio_sc3_silhouette(data : Array[Array[Double]], labels : Array[Int], k : Int) -> Array[Double] { +///| +pub fn bio_sc3_silhouette( + data : Array[Array[Double]], + labels : Array[Int], + k : Int, +) -> Array[Double] { sc3_calculate_silhouette(data, labels, k) -} \ No newline at end of file +} diff --git a/src/sc_dbl_finder.mbt b/src/sc_dbl_finder.mbt index dd3c832a..fe6ce66f 100644 --- a/src/sc_dbl_finder.mbt +++ b/src/sc_dbl_finder.mbt @@ -114,7 +114,7 @@ pub fn scdf_sort_by_distance( if n <= 1 { return sorted } - + let mut i = 0 while i < n - 1 { let min_idx = scdf_find_min(sorted, i, n) @@ -129,11 +129,7 @@ pub fn scdf_sort_by_distance( } ///| -fn scdf_find_min( - arr : Array[(String, Double)], - start : Int, - end : Int, -) -> Int { +fn scdf_find_min(arr : Array[(String, Double)], start : Int, end : Int) -> Int { let mut min_idx = start let mut i = start + 1 while i < end { diff --git a/src/scenic.mbt b/src/scenic.mbt index 121ffbba..84ab8d24 100644 --- a/src/scenic.mbt +++ b/src/scenic.mbt @@ -23,7 +23,7 @@ pub struct CoExpressionModule { tf_name : String targets : Array[String] - weights : Array[Double] // importance weights, parallel to targets + weights : Array[Double] // importance weights, parallel to targets } derive(Debug) ///| @@ -33,7 +33,7 @@ pub fn co_expression_module( targets : Array[String], weights : Array[Double], ) -> CoExpressionModule { - { tf_name: tf_name, targets: targets, weights: weights } + { tf_name, targets, weights } } ///| @@ -41,7 +41,7 @@ pub fn co_expression_module( pub struct ScenicRegulon { tf_name : String targets : Array[String] - weights : Array[Double] // weight per target (from GRN importance) + weights : Array[Double] // weight per target (from GRN importance) n_targets : Int } derive(Debug) @@ -52,12 +52,7 @@ pub fn scenic_regulon( targets : Array[String], weights : Array[Double], ) -> ScenicRegulon { - { - tf_name: tf_name, - targets: targets, - weights: weights, - n_targets: targets.length(), - } + { tf_name, targets, weights, n_targets: targets.length() } } ///| @@ -65,7 +60,7 @@ pub fn scenic_regulon( pub struct AUCEntry { regulon_name : String cell_name : String - auc : Double // normalized AUC in [0, 1] + auc : Double // normalized AUC in [0, 1] } ///| @@ -73,16 +68,16 @@ pub struct AUCEntry { pub struct SCENICInput { n_genes : Int n_cells : Int - expression : Array[Array[Double]] // gene x cell (row=gene, col=cell) + expression : Array[Array[Double]] // gene x cell (row=gene, col=cell) gene_names : Array[String] cell_names : Array[String] - tf_names : Array[String] // subset of gene_names that are TFs + tf_names : Array[String] // subset of gene_names that are TFs } derive(Debug) ///| /// Create SCENIC input from expression matrix and metadata. pub fn scenic_input( - expression : Array[Array[Double]], // gene x cell + expression : Array[Array[Double]], // gene x cell gene_names : Array[String], cell_names : Array[String], tf_names : Array[String], @@ -90,10 +85,10 @@ pub fn scenic_input( { n_genes: gene_names.length(), n_cells: cell_names.length(), - expression: expression, - gene_names: gene_names, - cell_names: cell_names, - tf_names: tf_names, + expression, + gene_names, + cell_names, + tf_names, } } @@ -103,14 +98,14 @@ pub struct SCENICResult { regulons : Array[ScenicRegulon] n_regulons : Int n_cells : Int - auc_matrix : Array[Array[Double]] // regulon x cell + auc_matrix : Array[Array[Double]] // regulon x cell regulon_names : Array[String] cell_names : Array[String] - binary_matrix : Array[Array[Int]] // regulon x cell (0/1) - thresholds : Array[Double] // per-regulon binarization threshold - cell_states : Array[Int] // cluster label per cell + binary_matrix : Array[Array[Int]] // regulon x cell (0/1) + thresholds : Array[Double] // per-regulon binarization threshold + cell_states : Array[Int] // cluster label per cell n_clusters : Int - master_regulators : Array[(String, Int)] // (TF name, cluster index) + master_regulators : Array[(String, Int)] // (TF name, cluster index) } // ============================================================================ @@ -148,14 +143,21 @@ pub fn build_coexpression_modules( // Find TF row index let mut tf_row = -1 for k in 0.. Double { let n = a.length() - if n == 0 || n != b.length() { return 0.0 } + if n == 0 || n != b.length() { + return 0.0 + } let mut sum_a = 0.0 let mut sum_b = 0.0 - for i in 0.. Double { var_b += db * db } let denom = (var_a * var_b).sqrt() - if denom < 1.0e-12 { 0.0 } - else { (cov / denom).abs() } + if denom < 1.0e-12 { + 0.0 + } else { + (cov / denom).abs() + } } +///| /// Sort (String, Double) pairs by Double value descending (selection sort). fn scenic_sort_pairs_desc(arr : Array[(String, Double)]) -> Unit { let n = arr.length() @@ -209,7 +223,9 @@ fn scenic_sort_pairs_desc(arr : Array[(String, Double)]) -> Unit { for j in (i + 1).. vmax { max_idx = j } + if vj > vmax { + max_idx = j + } } if max_idx != i { let tmp = arr[i] @@ -282,8 +298,11 @@ pub fn prune_by_motif_ranking( rank_threshold? : Int = 0, ) -> ScenicRegulon { let n_ranked = motif_ranked_genes.length() - let effective_threshold = if rank_threshold > 0 { rank_threshold } - else { (n_ranked.to_double() * 0.05).to_int() } + let effective_threshold = if rank_threshold > 0 { + rank_threshold + } else { + (n_ranked.to_double() * 0.05).to_int() + } // Build set of top-ranked genes let top_genes_keys : Array[String] = [] let _top_vals : Array[Int] = [] @@ -299,7 +318,10 @@ pub fn prune_by_motif_ranking( let target = module.targets[i] let mut found = false for k in 0.. Unit { let n = arr.length() for i in 1.. Unit { ///| /// Build gene rankings for each cell (genes sorted by expression, highest first). /// Returns a matrix of gene indices, cell x gene (each row is a cell's ranking). -pub fn build_cell_rankings( - input : SCENICInput, -) -> Array[Array[Int]] { +pub fn build_cell_rankings(input : SCENICInput) -> Array[Array[Int]] { let rankings : Array[Array[Int]] = [] for c in 0.. expr[indices[max_idx]] { max_idx = j } + if expr[indices[j]] > expr[indices[max_idx]] { + max_idx = j + } } if max_idx != i { let tmp = indices[i] @@ -375,10 +400,15 @@ fn compute_auc( auc_max_rank : Int, ) -> Double { let n_targets = target_indices.length() - if n_targets == 0 { return 0.0 } + if n_targets == 0 { + return 0.0 + } let n_genes = gene_ranking.length() - let max_rank = if auc_max_rank > 0 && auc_max_rank < n_genes { auc_max_rank } - else { n_genes } + let max_rank = if auc_max_rank > 0 && auc_max_rank < n_genes { + auc_max_rank + } else { + n_genes + } // Build a set of target gene indices for O(1) lookup let target_set : Array[Int] = target_indices.copy() // Count how many targets appear in top max_rank positions @@ -389,7 +419,10 @@ fn compute_auc( let gene_idx = gene_ranking[i] let mut is_target = false for t in 0..= 0 { + target_indices.push(found) } - if found >= 0 { target_indices.push(found) } } // Compute AUC for each cell let row : Array[Double] = [] @@ -472,16 +510,18 @@ pub fn binarize_activity( let threshold = match method { BinarizeMethod::MeanStd => { let mut sum = 0.0 - for v in row { sum += v } + for v in row { + sum += v + } let mean = sum / n_cells.to_double() let mut sq_sum = 0.0 - for v in row { sq_sum += (v - mean) * (v - mean) } + for v in row { + sq_sum += (v - mean) * (v - mean) + } let std = (sq_sum / n_cells.to_double()).sqrt() mean + 0.5 * std } - BinarizeMethod::KMeans2 => { - scenic_kmeans_threshold(row) - } + BinarizeMethod::KMeans2 => scenic_kmeans_threshold(row) BinarizeMethod::Median => { let sorted = row.copy() scenic_sort_doubles_asc(sorted) @@ -491,7 +531,11 @@ pub fn binarize_activity( thresholds.push(threshold) let bin_row : Array[Int] = [] for c in 0.. threshold { bin_row.push(1) } else { bin_row.push(0) } + if row[c] > threshold { + bin_row.push(1) + } else { + bin_row.push(0) + } } binary.push(bin_row) } @@ -524,19 +568,30 @@ pub fn binarize_median() -> BinarizeMethod { BinarizeMethod::Median } +///| /// Simple 1D k-means with k=2 to find threshold for bimodal distribution. fn scenic_kmeans_threshold(values : Array[Double]) -> Double { let n = values.length() - if n == 0 { return 0.0 } - if n == 1 { return values[0] } + if n == 0 { + return 0.0 + } + if n == 1 { + return values[0] + } // Initialize centroids: min and max let mut c1 = values[0] let mut c2 = values[0] for v in values { - if v < c1 { c1 = v } - if v > c2 { c2 = v } + if v < c1 { + c1 = v + } + if v > c2 { + c2 = v + } + } + if c1 == c2 { + return c1 } - if c1 == c2 { return c1 } // Iterate k-means for _iter in 0..<20 { let mut sum1 = 0.0 @@ -546,13 +601,22 @@ fn scenic_kmeans_threshold(values : Array[Double]) -> Double { for v in values { let d1 = (v - c1).abs() let d2 = (v - c2).abs() - if d1 < d2 { sum1 += v; count1 = count1 + 1 } - else { sum2 += v; count2 = count2 + 1 } + if d1 < d2 { + sum1 += v + count1 = count1 + 1 + } else { + sum2 += v + count2 = count2 + 1 + } + } + if count1 == 0 || count2 == 0 { + break } - if count1 == 0 || count2 == 0 { break } let new_c1 = sum1 / count1.to_double() let new_c2 = sum2 / count2.to_double() - if (new_c1 - c1).abs() < 1.0e-9 && (new_c2 - c2).abs() < 1.0e-9 { break } + if (new_c1 - c1).abs() < 1.0e-9 && (new_c2 - c2).abs() < 1.0e-9 { + break + } c1 = new_c1 c2 = new_c2 } @@ -583,20 +647,24 @@ pub fn assign_cell_states( for r in 0.. max_cluster { max_cluster = l } + if l > max_cluster { + max_cluster = l + } } // Master regulators: (regulon_name, cluster_index) let masters : Array[(String, Int)] = [] @@ -604,7 +672,9 @@ pub fn assign_cell_states( let cluster = r + 1 let mut count = 0 for c in 0.. 0 { masters.push((regulon_names[r], cluster)) @@ -636,36 +706,34 @@ pub fn run_scenic( binarize_method? : BinarizeMethod = BinarizeMethod::MeanStd, ) -> SCENICResult { // Step 1: Build co-expression modules - let modules = build_coexpression_modules( - input, min_targets=min_targets, top_k=top_k, - ) + let modules = build_coexpression_modules(input, min_targets~, top_k~) // Step 2: Build regulons - let regulons = build_regulons( - modules, weight_quantile=weight_quantile, min_targets=min_targets, - ) + let regulons = build_regulons(modules, weight_quantile~, min_targets~) // Step 3: Compute regulon activity (AUC matrix) - let auc_matrix = compute_regulon_activity( - regulons, input, auc_threshold_pct=auc_threshold_pct, - ) + let auc_matrix = compute_regulon_activity(regulons, input, auc_threshold_pct~) // Step 4: Binarize and assign cell states let (binary_matrix, thresholds) = binarize_activity( - auc_matrix, input.n_cells, method=binarize_method, + auc_matrix, + input.n_cells, + method=binarize_method, ) - let regulon_names = regulons.map(fn (r) -> String { r.tf_name }) + let regulon_names = regulons.map(fn(r) -> String { r.tf_name }) let (cell_states, n_clusters, masters) = assign_cell_states( - binary_matrix, regulon_names, input.n_cells, + binary_matrix, + regulon_names, + input.n_cells, ) { - regulons: regulons, + regulons, n_regulons: regulons.length(), n_cells: input.n_cells, - auc_matrix: auc_matrix, - regulon_names: regulon_names, + auc_matrix, + regulon_names, cell_names: input.cell_names, - binary_matrix: binary_matrix, - thresholds: thresholds, - cell_states: cell_states, - n_clusters: n_clusters, + binary_matrix, + thresholds, + cell_states, + n_clusters, master_regulators: masters, } } @@ -690,7 +758,7 @@ pub fn scenic_sample_data( seed? : Int = 42, ) -> SCENICInput { let mut rng = seed - let next_rand = fn () -> Double { + let next_rand = fn() -> Double { rng = (rng * 1103515245 + 12345) & 0x7fffffff (rng & 0xffffff).to_double() / 16777215.0 } @@ -716,9 +784,13 @@ pub fn scenic_sample_data( for t in 0..= n_cells / 2 { 5.0 } - else { 1.0 + next_rand() * 0.5 } + let base = if t == 0 && c < n_cells / 2 { + 5.0 + } else if t == 1 && c >= n_cells / 2 { + 5.0 + } else { + 1.0 + next_rand() * 0.5 + } profile.push(base) } tf_activity.push(profile) @@ -753,50 +825,83 @@ pub fn scenic_sample_data( ///| /// Get the AUC score for a specific regulon and cell. -pub fn SCENICResult::auc_at(self : SCENICResult, regulon_idx : Int, cell_idx : Int) -> Double { - if regulon_idx < 0 || regulon_idx >= self.n_regulons { return 0.0 } - if cell_idx < 0 || cell_idx >= self.n_cells { return 0.0 } +pub fn SCENICResult::auc_at( + self : SCENICResult, + regulon_idx : Int, + cell_idx : Int, +) -> Double { + if regulon_idx < 0 || regulon_idx >= self.n_regulons { + return 0.0 + } + if cell_idx < 0 || cell_idx >= self.n_cells { + return 0.0 + } self.auc_matrix[regulon_idx][cell_idx] } ///| /// Get the binary activity (0 or 1) for a specific regulon and cell. -pub fn SCENICResult::binary_at(self : SCENICResult, regulon_idx : Int, cell_idx : Int) -> Int { - if regulon_idx < 0 || regulon_idx >= self.n_regulons { return 0 } - if cell_idx < 0 || cell_idx >= self.n_cells { return 0 } +pub fn SCENICResult::binary_at( + self : SCENICResult, + regulon_idx : Int, + cell_idx : Int, +) -> Int { + if regulon_idx < 0 || regulon_idx >= self.n_regulons { + return 0 + } + if cell_idx < 0 || cell_idx >= self.n_cells { + return 0 + } self.binary_matrix[regulon_idx][cell_idx] } ///| /// Get the cell state (cluster label) for a specific cell. pub fn SCENICResult::cell_state(self : SCENICResult, cell_idx : Int) -> Int { - if cell_idx < 0 || cell_idx >= self.n_cells { return 0 } + if cell_idx < 0 || cell_idx >= self.n_cells { + return 0 + } self.cell_states[cell_idx] } ///| /// Return a summary string of the SCENIC result. pub fn SCENICResult::summary(self : SCENICResult) -> String { - "SCENICResult(regulons=" + self.n_regulons.to_string() + - ", cells=" + self.n_cells.to_string() + - ", clusters=" + self.n_clusters.to_string() + - ", master_regulators=" + self.master_regulators.length().to_string() + ")" + "SCENICResult(regulons=" + + self.n_regulons.to_string() + + ", cells=" + + self.n_cells.to_string() + + ", clusters=" + + self.n_clusters.to_string() + + ", master_regulators=" + + self.master_regulators.length().to_string() + + ")" } ///| /// Get regulon targets as an array of gene names. -pub fn SCENICResult::regulon_targets(self : SCENICResult, regulon_idx : Int) -> Array[String] { - if regulon_idx < 0 || regulon_idx >= self.n_regulons { return [] } +pub fn SCENICResult::regulon_targets( + self : SCENICResult, + regulon_idx : Int, +) -> Array[String] { + if regulon_idx < 0 || regulon_idx >= self.n_regulons { + return [] + } self.regulons[regulon_idx].targets.copy() } ///| /// Get the top-N regulons by mean AUC across all cells. -pub fn SCENICResult::top_regulons(self : SCENICResult, n? : Int = 5) -> Array[(String, Double)] { +pub fn SCENICResult::top_regulons( + self : SCENICResult, + n? : Int = 5, +) -> Array[(String, Double)] { let pairs : Array[(String, Double)] = [] for r in 0.. Array[String] { ///| /// Get expression matrix (gene × cell). -pub fn ScmapReference::expression(self : ScmapReference) -> Array[Array[Double]] { +pub fn ScmapReference::expression( + self : ScmapReference, +) -> Array[Array[Double]] { self.expression } ///| /// Get unique cell types in the reference. -pub fn ScmapReference::unique_cell_types(self : ScmapReference) -> Array[String] { +pub fn ScmapReference::unique_cell_types( + self : ScmapReference, +) -> Array[String] { let types : Array[String] = [] for t in self.cell_types { let mut found = false @@ -167,7 +171,9 @@ pub fn ScmapAssignment::best_correlation(self : ScmapAssignment) -> Double { ///| /// Get second-best correlation score. -pub fn ScmapAssignment::second_best_correlation(self : ScmapAssignment) -> Double { +pub fn ScmapAssignment::second_best_correlation( + self : ScmapAssignment, +) -> Double { self.second_best_correlation } @@ -202,9 +208,7 @@ fn scmap_extract_cell( ///| /// Compute the centroid (mean expression) for each cell type. /// Returns: cell_types × genes centroid matrix (as Array of cell-type vectors). -fn scmap_centroids( - ref : ScmapReference, -) -> Array[(String, Array[Double])] { +fn scmap_centroids(ref : ScmapReference) -> Array[(String, Array[Double])] { let unique_types = ref.unique_cell_types() let n_genes = ref.gene_names.length() let centroids : Array[(String, Array[Double])] = [] @@ -404,7 +408,9 @@ pub fn scmap_cell( ///| /// Summarise classification results: count cells per assigned type. -pub fn scmap_summary(assignments : Array[ScmapAssignment]) -> Array[(String, Int)] { +pub fn scmap_summary( + assignments : Array[ScmapAssignment], +) -> Array[(String, Int)] { let types : Array[String] = [] let counts : Array[Int] = [] for a in assignments { @@ -431,7 +437,14 @@ pub fn scmap_summary(assignments : Array[ScmapAssignment]) -> Array[(String, Int ///| /// Format an assignment as a readable string. pub fn ScmapAssignment::to_string(self : ScmapAssignment) -> String { - self.cell_name + " -> " + self.assigned_type + " (corr=" + self.best_correlation.to_string() + ", method=" + self.method + ")" + self.cell_name + + " -> " + + self.assigned_type + + " (corr=" + + self.best_correlation.to_string() + + ", method=" + + self.method + + ")" } ///| @@ -439,10 +452,20 @@ pub fn ScmapAssignment::to_string(self : ScmapAssignment) -> String { pub fn scmap_assignments_to_string( assignments : Array[ScmapAssignment], ) -> String { - let mut s = "scmap Assignments (" + assignments.length().to_string() + " cells)\n" + let mut s = "scmap Assignments (" + + assignments.length().to_string() + + " cells)\n" s = s + "cell\tassigned_type\tbest_corr\tmethod\n" for a in assignments { - s = s + a.cell_name + "\t" + a.assigned_type + "\t" + a.best_correlation.to_string() + "\t" + a.method + "\n" + s = s + + a.cell_name + + "\t" + + a.assigned_type + + "\t" + + a.best_correlation.to_string() + + "\t" + + a.method + + "\n" } s } @@ -456,13 +479,13 @@ pub fn scmap_assignments_to_string( /// 10 genes, 9 reference cells. pub fn scmap_sample_reference() -> ScmapReference { let gene_names = [ - "GENE1", "GENE2", "GENE3", "GENE4", "GENE5", "GENE6", "GENE7", "GENE8", "GENE9", "GENE10", - ] - let cell_names = [ - "T1", "T2", "T3", "B1", "B2", "B3", "N1", "N2", "N3", + "GENE1", "GENE2", "GENE3", "GENE4", "GENE5", "GENE6", "GENE7", "GENE8", "GENE9", + "GENE10", ] + let cell_names = ["T1", "T2", "T3", "B1", "B2", "B3", "N1", "N2", "N3"] let cell_types = [ - "T_cell", "T_cell", "T_cell", "B_cell", "B_cell", "B_cell", "NK_cell", "NK_cell", "NK_cell", + "T_cell", "T_cell", "T_cell", "B_cell", "B_cell", "B_cell", "NK_cell", "NK_cell", + "NK_cell", ] // gene × cell expression matrix (10 genes × 9 cells) // T cells: high GENE1-3, low GENE4-6, GENE7-10 = 0 @@ -473,7 +496,7 @@ pub fn scmap_sample_reference() -> ScmapReference { for g in 0..<3 { let row : Array[Double] = [] for c in 0..<9 { - let val = if c < 3 { 8.0 + (c.to_double() * 0.5) } else { 0.5 } + let val = if c < 3 { 8.0 + c.to_double() * 0.5 } else { 0.5 } row.push(val) } expression.push(row) @@ -482,7 +505,7 @@ pub fn scmap_sample_reference() -> ScmapReference { for g in 0..<3 { let row : Array[Double] = [] for c in 0..<9 { - let val = if c >= 3 && c < 6 { 8.0 + (c.to_double() * 0.5) } else { 0.5 } + let val = if c >= 3 && c < 6 { 8.0 + c.to_double() * 0.5 } else { 0.5 } row.push(val) } expression.push(row) @@ -491,7 +514,7 @@ pub fn scmap_sample_reference() -> ScmapReference { for g in 0..<4 { let row : Array[Double] = [] for c in 0..<9 { - let val = if c >= 6 { 8.0 + (c.to_double() * 0.5) } else { 0.5 } + let val = if c >= 6 { 8.0 + c.to_double() * 0.5 } else { 0.5 } row.push(val) } expression.push(row) @@ -503,7 +526,8 @@ pub fn scmap_sample_reference() -> ScmapReference { /// Generate 3 query cells: one clearly T, one clearly B, one ambiguous. pub fn scmap_sample_query() -> ScmapQuery { let gene_names = [ - "GENE1", "GENE2", "GENE3", "GENE4", "GENE5", "GENE6", "GENE7", "GENE8", "GENE9", "GENE10", + "GENE1", "GENE2", "GENE3", "GENE4", "GENE5", "GENE6", "GENE7", "GENE8", "GENE9", + "GENE10", ] let cell_names = ["query_T", "query_B", "query_unknown"] // gene × cell (10 genes × 3 query cells) diff --git a/src/scnorm.mbt b/src/scnorm.mbt index e95ce786..25629152 100644 --- a/src/scnorm.mbt +++ b/src/scnorm.mbt @@ -3,6 +3,7 @@ /// Provides single-cell RNA-seq normalization using quantile regression /// to correct for depth-dependent bias in single-cell data. +///| /// Normalization method pub enum SCnormMethod { /// Quantile regression normalization @@ -13,6 +14,7 @@ pub enum SCnormMethod { Spline } +///| /// Gene filtering method pub enum SCnormFilterMethod { /// Filter by expression threshold @@ -21,6 +23,7 @@ pub enum SCnormFilterMethod { Percent } +///| /// Result of quantile regression pub struct SCnormQuantFit { /// Slope coefficient @@ -35,6 +38,7 @@ pub struct SCnormQuantFit { tau : Double } +///| /// Normalization result for a gene pub struct SCnormGeneNormResult { /// Gene ID @@ -49,6 +53,7 @@ pub struct SCnormGeneNormResult { filter_reason : String } +///| /// Complete SCnorm result pub struct SCnormResult { /// Gene normalization results @@ -67,6 +72,7 @@ pub struct SCnormResult { norm_method : SCnormMethod } +///| /// Parameters for SCnorm normalization pub struct SCnormParams { /// Quantile level for regression (0-1) @@ -81,6 +87,7 @@ pub struct SCnormParams { robust : Bool } +///| /// Create default parameters pub fn SCnormParams::new() -> SCnormParams { SCnormParams::{ @@ -88,7 +95,7 @@ pub fn SCnormParams::new() -> SCnormParams { filter_genes: true, min_expr: 0.1, min_percent: 0.1, - robust: true + robust: true, } } @@ -100,7 +107,7 @@ pub fn SCnormParams::new() -> SCnormParams { pub fn sc_norm_quantile_regression( x : Array[Double], y : Array[Double], - tau : Double + tau : Double, ) -> SCnormQuantFit { let n = x.length() if n == 0 { @@ -109,7 +116,7 @@ pub fn sc_norm_quantile_regression( intercept: 0.0, fitted: Array::new(), residuals: Array::new(), - tau + tau, } } // Compute depth (x-axis) and log-counts (y-axis) @@ -124,21 +131,21 @@ pub fn sc_norm_quantile_regression( residuals.push(y[i] - f) i = i + 1 } - SCnormQuantFit::{ - slope, - intercept, - fitted, - residuals, - tau - } + SCnormQuantFit::{ slope, intercept, fitted, residuals, tau } } ///| /// Simple quantile regression via grid search. /// Finds slope and intercept that minimize quantile loss. -fn sc_norm_simple_quantile_fit(x : Array[Double], y : Array[Double], tau : Double) -> (Double, Double) { +fn sc_norm_simple_quantile_fit( + x : Array[Double], + y : Array[Double], + tau : Double, +) -> (Double, Double) { let n = x.length() - if n < 2 { return (0.0, if n > 0 { y[0] } else { 0.0 }) } + if n < 2 { + return (0.0, if n > 0 { y[0] } else { 0.0 }) + } // Compute median-based estimates let x_median = sc_norm_median(x) let y_median = sc_norm_median(y) @@ -149,15 +156,19 @@ fn sc_norm_simple_quantile_fit(x : Array[Double], y : Array[Double], tau : Doubl let qx_high = sc_norm_quantile(x, 1.0 - tau * 0.5) let slope_init = if qx_high > qx_low { (qy_high - qy_low) / (qx_high - qx_low) - } else { // Fallback: use median ratio - if x_median > 0.0 { y_median / x_median } else { 0.0 } + } else if x_median > 0.0 { + y_median / x_median + } else { + 0.0 } let intercept_init = y_median - slope_init * x_median // Refine via local search let mut best_slope = slope_init let mut best_intercept = intercept_init - let mut best_loss = sc_norm_quantile_loss(x, y, best_slope, best_intercept, tau) + let mut best_loss = sc_norm_quantile_loss( + x, y, best_slope, best_intercept, tau, + ) // Grid search refinement let scale = if best_slope.abs() > 1.0 { best_slope.abs() } else { 1.0 } let search_range = 0.5 * scale @@ -167,7 +178,9 @@ fn sc_norm_simple_quantile_fit(x : Array[Double], y : Array[Double], tau : Doubl while s <= steps { let test_slope = best_slope - search_range + step_size * s.to_double() // For each slope, find best intercept - let (best_int_for_slope, loss_for_slope) = sc_norm_find_best_intercept(x, y, test_slope, tau) + let (best_int_for_slope, loss_for_slope) = sc_norm_find_best_intercept( + x, y, test_slope, tau, + ) if loss_for_slope < best_loss { best_loss = loss_for_slope best_slope = test_slope @@ -180,7 +193,12 @@ fn sc_norm_simple_quantile_fit(x : Array[Double], y : Array[Double], tau : Doubl ///| /// Find best intercept for a given slope. -fn sc_norm_find_best_intercept(x : Array[Double], y : Array[Double], slope : Double, tau : Double) -> (Double, Double) { +fn sc_norm_find_best_intercept( + x : Array[Double], + y : Array[Double], + slope : Double, + tau : Double, +) -> (Double, Double) { let n = x.length() // Compute residuals at multiple intercepts // Use the median residual as starting point @@ -193,14 +211,26 @@ fn sc_norm_find_best_intercept(x : Array[Double], y : Array[Double], slope : Dou // Sort residuals to find the tau-th quantile let sorted = sc_norm_sort_array(residuals) let idx = (tau * (n.to_double() - 1.0)).to_int() - let intercept = sorted[if idx < 0 { 0 } else { if idx >= n { n - 1 } else { idx } }] + let intercept = sorted[if idx < 0 { + 0 + } else if idx >= n { + n - 1 + } else { + idx + }] let loss = sc_norm_quantile_loss(x, y, slope, intercept, tau) (intercept, loss) } ///| /// Compute quantile loss (pinball loss). -fn sc_norm_quantile_loss(x : Array[Double], y : Array[Double], slope : Double, intercept : Double, tau : Double) -> Double { +fn sc_norm_quantile_loss( + x : Array[Double], + y : Array[Double], + slope : Double, + intercept : Double, + tau : Double, +) -> Double { let n = x.length() let mut loss = 0.0 let mut i = 0 @@ -214,10 +244,13 @@ fn sc_norm_quantile_loss(x : Array[Double], y : Array[Double], slope : Double, i loss } +///| /// Compute median of an array fn sc_norm_median(arr : Array[Double]) -> Double { let n = arr.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let sorted = sc_norm_sort_array(arr) if n % 2 == 1 { sorted[n / 2] @@ -226,16 +259,20 @@ fn sc_norm_median(arr : Array[Double]) -> Double { } } +///| /// Compute quantile of an array fn sc_norm_quantile(arr : Array[Double], q : Double) -> Double { let n = arr.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let sorted = sc_norm_sort_array(arr) let idx = (q * (n.to_double() - 1.0)).to_int() - let idx_clamped = if idx < 0 { 0 } else { if idx >= n { n - 1 } else { idx } } + let idx_clamped = if idx < 0 { 0 } else if idx >= n { n - 1 } else { idx } sorted[idx_clamped] } +///| /// Sort array (simple insertion sort for small arrays) fn sc_norm_sort_array(arr : Array[Double]) -> Array[Double] { let result = arr.copy() @@ -283,7 +320,7 @@ pub fn sc_norm_normalize_gene( gene_id : String, counts : Array[Double], lib_sizes : Array[Double], - params : SCnormParams + params : SCnormParams, ) -> SCnormGeneNormResult { let n = counts.length() // Compute log-transformed counts @@ -298,7 +335,11 @@ pub fn sc_norm_normalize_gene( i = i + 1 } // Fit quantile regression - let quant_fit = sc_norm_quantile_regression(log_lib_sizes, log_counts, params.quantile) + let quant_fit = sc_norm_quantile_regression( + log_lib_sizes, + log_counts, + params.quantile, + ) // Compute normalized counts let norm_counts : Array[Double] = Array::new() let mut j = 0 @@ -317,24 +358,39 @@ pub fn sc_norm_normalize_gene( quant_fit, norm_counts, passed_filter: passed, - filter_reason: reason + filter_reason: reason, } } ///| /// Check if a gene passes filter criteria. -fn sc_norm_check_filter(raw_counts : Array[Double], norm_counts : Array[Double], params : SCnormParams) -> (Bool, String) { - if !params.filter_genes { return (true, "") } +fn sc_norm_check_filter( + raw_counts : Array[Double], + norm_counts : Array[Double], + params : SCnormParams, +) -> (Bool, String) { + if !params.filter_genes { + return (true, "") + } let n = raw_counts.length() let mut n_expressed = 0 let mut i = 0 while i < n { - if raw_counts[i] > params.min_expr { n_expressed = n_expressed + 1 } + if raw_counts[i] > params.min_expr { + n_expressed = n_expressed + 1 + } i = i + 1 } let percent = n_expressed.to_double() / n.to_double() if percent < params.min_percent { - return (false, "Not expressed in enough cells (" + n_expressed.to_string() + "/" + n.to_string() + ")") + return ( + false, + "Not expressed in enough cells (" + + n_expressed.to_string() + + "/" + + n.to_string() + + ")", + ) } (true, "") } @@ -345,7 +401,7 @@ pub fn sc_norm_run( count_matrix : Array[Array[Double]], gene_ids : Array[String], cell_ids : Array[String], - params : SCnormParams + params : SCnormParams, ) -> SCnormResult { let n_genes = count_matrix.length() let n_cells = if n_genes > 0 { count_matrix[0].length() } else { 0 } @@ -358,7 +414,11 @@ pub fn sc_norm_run( let mut g = 0 while g < n_genes { let gene_counts = count_matrix[g] - let gene_id = if g < gene_ids.length() { gene_ids[g] } else { "gene_" + g.to_string() } + let gene_id = if g < gene_ids.length() { + gene_ids[g] + } else { + "gene_" + g.to_string() + } let result = sc_norm_normalize_gene(gene_id, gene_counts, lib_sizes, params) gene_results.push(result) if result.passed_filter { @@ -374,7 +434,11 @@ pub fn sc_norm_run( cell_ids, lib_sizes, quantile_level: params.quantile, - norm_method: if params.robust { SCnormMethod::Quantile } else { SCnormMethod::Loess } + norm_method: if params.robust { + SCnormMethod::Quantile + } else { + SCnormMethod::Loess + }, } } @@ -382,9 +446,15 @@ pub fn sc_norm_run( ///| /// Simple LOESS (locally weighted smoothing) for 1D data. -pub fn sc_norm_loess_smooth(x : Array[Double], y : Array[Double], span : Double) -> Array[Double] { +pub fn sc_norm_loess_smooth( + x : Array[Double], + y : Array[Double], + span : Double, +) -> Array[Double] { let n = x.length() - if n < 3 { return y.copy() } + if n < 3 { + return y.copy() + } let smoothed : Array[Double] = Array::new() let mut i = 0 while i < n { @@ -414,8 +484,14 @@ pub fn sc_norm_loess_smooth(x : Array[Double], y : Array[Double], span : Double) let dist = (xn - xi).abs() let weight = if half_span > 0.0 { let u = dist / half_span - if u <= 1.0 { (1.0 - u * u) * (1.0 - u * u) } else { 0.0 } - } else { 1.0 } + if u <= 1.0 { + (1.0 - u * u) * (1.0 - u * u) + } else { + 0.0 + } + } else { + 1.0 + } w.push(weight) xs.push(xn) ys.push(yn) @@ -441,14 +517,24 @@ pub fn sc_norm_loess_smooth(x : Array[Double], y : Array[Double], span : Double) ///| /// Simple spline smoothing for 1D data. -pub fn sc_norm_spline_smooth(x : Array[Double], y : Array[Double], n_knots : Int) -> Array[Double] { +pub fn sc_norm_spline_smooth( + x : Array[Double], + y : Array[Double], + n_knots : Int, +) -> Array[Double] { let n = x.length() - if n < 4 { return y.copy() } + if n < 4 { + return y.copy() + } let sorted_x = sc_norm_sort_indices(x) // Create knot positions let x_min = sc_norm_min(x) let x_max = sc_norm_max(x) - let knot_span = if n_knots > 2 { (x_max - x_min) / (n_knots - 1).to_double() } else { 1.0 } + let knot_span = if n_knots > 2 { + (x_max - x_min) / (n_knots - 1).to_double() + } else { + 1.0 + } let knots : Array[Double] = Array::new() let mut k = 0 while k < n_knots { @@ -468,8 +554,14 @@ pub fn sc_norm_spline_smooth(x : Array[Double], y : Array[Double], n_knots : Int smoothed } +///| /// Spline interpolation at a point -fn sc_norm_spline_interpolate(x_val : Double, knots : Array[Double], x : Array[Double], y : Array[Double]) -> Double { +fn sc_norm_spline_interpolate( + x_val : Double, + knots : Array[Double], + x : Array[Double], + y : Array[Double], +) -> Double { let n_knots = knots.length() let n = x.length() // Find the two nearest data points @@ -485,8 +577,12 @@ fn sc_norm_spline_interpolate(x_val : Double, knots : Array[Double], x : Array[D i = i + 1 } // Simple linear interpolation between nearest neighbors - if best_idx == 0 { return y[0] } - if best_idx == n - 1 { return y[n - 1] } + if best_idx == 0 { + return y[0] + } + if best_idx == n - 1 { + return y[n - 1] + } let x0 = x[best_idx - 1] let x1 = x[best_idx] let y0 = y[best_idx - 1] @@ -495,25 +591,32 @@ fn sc_norm_spline_interpolate(x_val : Double, knots : Array[Double], x : Array[D y0 + t * (y1 - y0) } +///| fn sc_norm_sort_indices(arr : Array[Double]) -> Array[Double] { sc_norm_sort_array(arr) } +///| fn sc_norm_min(arr : Array[Double]) -> Double { let mut m = arr[0] let mut i = 1 while i < arr.length() { - if arr[i] < m { m = arr[i] } + if arr[i] < m { + m = arr[i] + } i = i + 1 } m } +///| fn sc_norm_max(arr : Array[Double]) -> Double { let mut m = arr[0] let mut i = 1 while i < arr.length() { - if arr[i] > m { m = arr[i] } + if arr[i] > m { + m = arr[i] + } i = i + 1 } m @@ -521,28 +624,43 @@ fn sc_norm_max(arr : Array[Double]) -> Double { // ===== Accessor methods ===== +///| /// Get number of genes after filtering pub fn SCnormResult::sc_n_n_genes(self : SCnormResult) -> Int { self.gene_ids.length() } +///| /// Get number of cells pub fn SCnormResult::sc_n_cells(self : SCnormResult) -> Int { self.cell_ids.length() } +///| /// Get a normalized count for a gene and cell -pub fn SCnormResult::sc_norm_get_count(self : SCnormResult, gene_idx : Int, cell_idx : Int) -> Double { +pub fn SCnormResult::sc_norm_get_count( + self : SCnormResult, + gene_idx : Int, + cell_idx : Int, +) -> Double { self.norm_matrix[gene_idx][cell_idx] } +///| /// Get all normalized counts for a gene -pub fn SCnormResult::sc_norm_get_gene(self : SCnormResult, gene_idx : Int) -> Array[Double] { +pub fn SCnormResult::sc_norm_get_gene( + self : SCnormResult, + gene_idx : Int, +) -> Array[Double] { self.norm_matrix[gene_idx].copy() } +///| /// Get all normalized counts for a cell -pub fn SCnormResult::sc_norm_get_cell(self : SCnormResult, cell_idx : Int) -> Array[Double] { +pub fn SCnormResult::sc_norm_get_cell( + self : SCnormResult, + cell_idx : Int, +) -> Array[Double] { let result : Array[Double] = Array::new() let mut i = 0 while i < self.norm_matrix.length() { @@ -552,8 +670,12 @@ pub fn SCnormResult::sc_norm_get_cell(self : SCnormResult, cell_idx : Int) -> Ar result } +///| /// Get the quantile fit for a gene -pub fn SCnormResult::sc_norm_get_fit(self : SCnormResult, gene_id : String) -> SCnormQuantFit? { +pub fn SCnormResult::sc_norm_get_fit( + self : SCnormResult, + gene_id : String, +) -> SCnormQuantFit? { let mut i = 0 while i < self.gene_results.length() { if self.gene_results[i].gene_id == gene_id { diff --git a/src/scop.mbt b/src/scop.mbt index bdd2291b..03f4f9d2 100644 --- a/src/scop.mbt +++ b/src/scop.mbt @@ -189,10 +189,9 @@ pub fn scop_parse_residues(s : String) -> ScopResidues { // Format: chain:start-end OR chain: let colon_idx = p.find(":") match colon_idx { - None => { + None => // No colon: treat the whole thing as a chain with no range fragments.push(ScopFragment::new(p, "", "")) - } Some(ci) => { let chain = p[0:ci].to_owned() let range = p[ci + 1:].to_owned() @@ -203,9 +202,7 @@ pub fn scop_parse_residues(s : String) -> ScopResidues { // "chain:start-end" let dash_idx = range.find("-") match dash_idx { - None => { - fragments.push(ScopFragment::new(chain, range, "")) - } + None => fragments.push(ScopFragment::new(chain, range, "")) Some(di) => { let start = range[0:di].to_owned() let end_ = range[di + 1:].to_owned() @@ -372,7 +369,11 @@ pub struct HieRecord { ///| /// Create a HIE record. -pub fn HieRecord::new(sunid : Int, parent : Int, children : Array[Int]) -> HieRecord { +pub fn HieRecord::new( + sunid : Int, + parent : Int, + children : Array[Int], +) -> HieRecord { { sunid, parent, children } } @@ -662,7 +663,10 @@ pub fn Scop::new( des_records : Array[DesRecord], hie_records : Array[HieRecord], ) -> Scop { - let sunid_dict : Map[Int, ScopNode] = Map([], capacity=des_records.length() + 1) + let sunid_dict : Map[Int, ScopNode] = Map( + [], + capacity=des_records.length() + 1, + ) let sid_dict : Map[String, ScopNode] = Map([], capacity=cla_records.length()) let domains : Array[ScopNode] = [] // 1. Create root @@ -1042,7 +1046,11 @@ pub fn Scop::write_des(self : Scop) -> String { Some(node) => { let name = if node.nodetype == "px" { node.sid } else { "-" } let rec = DesRecord::new( - node.sunid, node.nodetype, node.sccs, name, node.description, + node.sunid, + node.nodetype, + node.sccs, + name, + node.description, ) if result.length() > 0 { result = result + "\n" @@ -1077,7 +1085,12 @@ pub fn Scop::write_cla(self : Scop) -> String { } } let rec = ClaRecord::new( - node.sid, node.pdbid, res, node.sccs, node.sunid, hierarchy, + node.sid, + node.pdbid, + res, + node.sccs, + node.sunid, + hierarchy, ) if result.length() > 0 { result = result + "\n" @@ -1131,7 +1144,9 @@ pub fn scop_sample_hie() -> String { /// Create a sample CLA file content for testing. pub fn scop_sample_cla() -> String { let mut s = "" - s = s + "d1hba_\t1hba\tA:1-141\ta.1.1.1.1.1.1\t1000\tcl=100,cf=200,sf=300,fa=400,dm=500,sp=600,px=1000\n" - s = s + "d1hbb_\t1hba\tB:1-146\ta.1.1.1.1.1.2\t1001\tcl=100,cf=200,sf=300,fa=400,dm=500,sp=600,px=1001\n" + s = s + + "d1hba_\t1hba\tA:1-141\ta.1.1.1.1.1.1\t1000\tcl=100,cf=200,sf=300,fa=400,dm=500,sp=600,px=1000\n" + s = s + + "d1hbb_\t1hba\tB:1-146\ta.1.1.1.1.1.2\t1001\tcl=100,cf=200,sf=300,fa=400,dm=500,sp=600,px=1001\n" s } diff --git a/src/searchio.mbt b/src/searchio.mbt index 05954c8e..54b16d83 100644 --- a/src/searchio.mbt +++ b/src/searchio.mbt @@ -23,7 +23,8 @@ pub enum SearchIOFormat { pub fn search_io_format_from_str(s : String) -> SearchIOFormat { match s.to_lower().trim() { "blast-xml" | "blastxml" | "xml" => SearchIOFormat::BlastXml - "blast-tab" | "blasttabular" | "tabular" | "tab" => SearchIOFormat::BlastTabular + "blast-tab" | "blasttabular" | "tabular" | "tab" => + SearchIOFormat::BlastTabular "blast-text" | "blasttext" | "text" => SearchIOFormat::BlastText "hmmscan-domtbl" | "domtbl" => SearchIOFormat::HmmscanDomtbl "hmmdom-text" => SearchIOFormat::HmmdomText @@ -53,7 +54,11 @@ fn searchio_parse_int_fast(sv : StringView) -> Int { } i = i + 1 } - if is_negative { -result } else { result } + if is_negative { + -result + } else { + result + } } ///| @@ -131,7 +136,11 @@ fn searchio_parse_double_fast(sv : StringView) -> Double { } } } - if is_negative { -final_result } else { final_result } + if is_negative { + -final_result + } else { + final_result + } } ///| @@ -156,7 +165,11 @@ fn searchio_parse_int(s : String) -> Int { } i = i + 1 } - if is_negative { -result } else { result } + if is_negative { + -result + } else { + result + } } ///| @@ -234,7 +247,11 @@ fn searchio_parse_double(s : String) -> Double { } } } - if is_negative { -final_result } else { final_result } + if is_negative { + -final_result + } else { + final_result + } } ///| @@ -287,62 +304,122 @@ pub fn SearchIOHsp::new( hit_end~ : Int, ) -> SearchIOHsp { SearchIOHsp::{ - bitscore, evalue, identity, positives, gap, - alignment_length, query_start, query_end, hit_start, hit_end, - query_frame: 0, hit_frame: 0, - query_seq: "", hit_seq: "", midline: "" + bitscore, + evalue, + identity, + positives, + gap, + alignment_length, + query_start, + query_end, + hit_start, + hit_end, + query_frame: 0, + hit_frame: 0, + query_seq: "", + hit_seq: "", + midline: "", } } ///| /// Set query sequence in the alignment. -pub fn SearchIOHsp::with_query_seq(self : SearchIOHsp, seq : String) -> SearchIOHsp { +pub fn SearchIOHsp::with_query_seq( + self : SearchIOHsp, + seq : String, +) -> SearchIOHsp { SearchIOHsp::{ - bitscore: self.bitscore, evalue: self.evalue, identity: self.identity, - positives: self.positives, gap: self.gap, alignment_length: self.alignment_length, - query_start: self.query_start, query_end: self.query_end, - hit_start: self.hit_start, hit_end: self.hit_end, - query_frame: self.query_frame, hit_frame: self.hit_frame, - query_seq: seq, hit_seq: self.hit_seq, midline: self.midline + bitscore: self.bitscore, + evalue: self.evalue, + identity: self.identity, + positives: self.positives, + gap: self.gap, + alignment_length: self.alignment_length, + query_start: self.query_start, + query_end: self.query_end, + hit_start: self.hit_start, + hit_end: self.hit_end, + query_frame: self.query_frame, + hit_frame: self.hit_frame, + query_seq: seq, + hit_seq: self.hit_seq, + midline: self.midline, } } ///| /// Set hit sequence in the alignment. -pub fn SearchIOHsp::with_hit_seq(self : SearchIOHsp, seq : String) -> SearchIOHsp { +pub fn SearchIOHsp::with_hit_seq( + self : SearchIOHsp, + seq : String, +) -> SearchIOHsp { SearchIOHsp::{ - bitscore: self.bitscore, evalue: self.evalue, identity: self.identity, - positives: self.positives, gap: self.gap, alignment_length: self.alignment_length, - query_start: self.query_start, query_end: self.query_end, - hit_start: self.hit_start, hit_end: self.hit_end, - query_frame: self.query_frame, hit_frame: self.hit_frame, - query_seq: self.query_seq, hit_seq: seq, midline: self.midline + bitscore: self.bitscore, + evalue: self.evalue, + identity: self.identity, + positives: self.positives, + gap: self.gap, + alignment_length: self.alignment_length, + query_start: self.query_start, + query_end: self.query_end, + hit_start: self.hit_start, + hit_end: self.hit_end, + query_frame: self.query_frame, + hit_frame: self.hit_frame, + query_seq: self.query_seq, + hit_seq: seq, + midline: self.midline, } } ///| /// Set midline (conservation line). -pub fn SearchIOHsp::with_midline(self : SearchIOHsp, line : String) -> SearchIOHsp { +pub fn SearchIOHsp::with_midline( + self : SearchIOHsp, + line : String, +) -> SearchIOHsp { SearchIOHsp::{ - bitscore: self.bitscore, evalue: self.evalue, identity: self.identity, - positives: self.positives, gap: self.gap, alignment_length: self.alignment_length, - query_start: self.query_start, query_end: self.query_end, - hit_start: self.hit_start, hit_end: self.hit_end, - query_frame: self.query_frame, hit_frame: self.hit_frame, - query_seq: self.query_seq, hit_seq: self.hit_seq, midline: line + bitscore: self.bitscore, + evalue: self.evalue, + identity: self.identity, + positives: self.positives, + gap: self.gap, + alignment_length: self.alignment_length, + query_start: self.query_start, + query_end: self.query_end, + hit_start: self.hit_start, + hit_end: self.hit_end, + query_frame: self.query_frame, + hit_frame: self.hit_frame, + query_seq: self.query_seq, + hit_seq: self.hit_seq, + midline: line, } } ///| /// Set query and hit frames. -pub fn SearchIOHsp::with_frames(self : SearchIOHsp, qframe : Int, hframe : Int) -> SearchIOHsp { +pub fn SearchIOHsp::with_frames( + self : SearchIOHsp, + qframe : Int, + hframe : Int, +) -> SearchIOHsp { SearchIOHsp::{ - bitscore: self.bitscore, evalue: self.evalue, identity: self.identity, - positives: self.positives, gap: self.gap, alignment_length: self.alignment_length, - query_start: self.query_start, query_end: self.query_end, - hit_start: self.hit_start, hit_end: self.hit_end, - query_frame: qframe, hit_frame: hframe, - query_seq: self.query_seq, hit_seq: self.hit_seq, midline: self.midline + bitscore: self.bitscore, + evalue: self.evalue, + identity: self.identity, + positives: self.positives, + gap: self.gap, + alignment_length: self.alignment_length, + query_start: self.query_start, + query_end: self.query_end, + hit_start: self.hit_start, + hit_end: self.hit_end, + query_frame: qframe, + hit_frame: hframe, + query_seq: self.query_seq, + hit_seq: self.hit_seq, + midline: self.midline, } } @@ -379,18 +456,27 @@ pub struct SearchIOHit { ///| /// Construct SearchIOHit. -pub fn SearchIOHit::new(id~ : String, description~ : String, seq_length~ : Int) -> SearchIOHit { +pub fn SearchIOHit::new( + id~ : String, + description~ : String, + seq_length~ : Int, +) -> SearchIOHit { SearchIOHit::{ id, description, seq_length, hsps: Array::new() } } ///| /// Add an HSP to this hit. -pub fn SearchIOHit::add_hsp(self : SearchIOHit, hsp : SearchIOHsp) -> SearchIOHit { +pub fn SearchIOHit::add_hsp( + self : SearchIOHit, + hsp : SearchIOHsp, +) -> SearchIOHit { let new_hsps = self.hsps.copy() new_hsps.push(hsp) SearchIOHit::{ - id: self.id, description: self.description, - seq_length: self.seq_length, hsps: new_hsps + id: self.id, + description: self.description, + seq_length: self.seq_length, + hsps: new_hsps, } } @@ -457,38 +543,57 @@ pub fn SearchIOQueryResult::new( database~ : String, ) -> SearchIOQueryResult { SearchIOQueryResult::{ - id, description, seq_length, database, - n_hits: 0, hits: Array::new(), total_hits: 0 + id, + description, + seq_length, + database, + n_hits: 0, + hits: Array::new(), + total_hits: 0, } } ///| /// Add a hit to this query result. -pub fn SearchIOQueryResult::add_hit(self : SearchIOQueryResult, hit : SearchIOHit) -> SearchIOQueryResult { +pub fn SearchIOQueryResult::add_hit( + self : SearchIOQueryResult, + hit : SearchIOHit, +) -> SearchIOQueryResult { let new_hits = self.hits.copy() new_hits.push(hit) SearchIOQueryResult::{ - id: self.id, description: self.description, - seq_length: self.seq_length, database: self.database, - n_hits: self.n_hits + 1, hits: new_hits, - total_hits: self.total_hits + id: self.id, + description: self.description, + seq_length: self.seq_length, + database: self.database, + n_hits: self.n_hits + 1, + hits: new_hits, + total_hits: self.total_hits, } } ///| /// Set total hits (before filtering). -pub fn SearchIOQueryResult::with_total_hits(self : SearchIOQueryResult, total : Int) -> SearchIOQueryResult { +pub fn SearchIOQueryResult::with_total_hits( + self : SearchIOQueryResult, + total : Int, +) -> SearchIOQueryResult { SearchIOQueryResult::{ - id: self.id, description: self.description, - seq_length: self.seq_length, database: self.database, - n_hits: self.n_hits, hits: self.hits, - total_hits: total + id: self.id, + description: self.description, + seq_length: self.seq_length, + database: self.database, + n_hits: self.n_hits, + hits: self.hits, + total_hits: total, } } ///| /// Sort hits by bitscore (descending). -pub fn SearchIOQueryResult::sort_by_score(self : SearchIOQueryResult) -> SearchIOQueryResult { +pub fn SearchIOQueryResult::sort_by_score( + self : SearchIOQueryResult, +) -> SearchIOQueryResult { let sorted = self.hits.copy() let n = sorted.length() let mut i = 0 @@ -507,16 +612,22 @@ pub fn SearchIOQueryResult::sort_by_score(self : SearchIOQueryResult) -> SearchI i = i + 1 } SearchIOQueryResult::{ - id: self.id, description: self.description, - seq_length: self.seq_length, database: self.database, - n_hits: self.n_hits, hits: sorted, - total_hits: self.total_hits + id: self.id, + description: self.description, + seq_length: self.seq_length, + database: self.database, + n_hits: self.n_hits, + hits: sorted, + total_hits: self.total_hits, } } ///| /// Filter hits by E-value threshold. -pub fn SearchIOQueryResult::filter_evalue(self : SearchIOQueryResult, threshold : Double) -> SearchIOQueryResult { +pub fn SearchIOQueryResult::filter_evalue( + self : SearchIOQueryResult, + threshold : Double, +) -> SearchIOQueryResult { let filtered : Array[SearchIOHit] = Array::new() let mut i = 0 while i < self.hits.length() { @@ -534,16 +645,22 @@ pub fn SearchIOQueryResult::filter_evalue(self : SearchIOQueryResult, threshold i = i + 1 } SearchIOQueryResult::{ - id: self.id, description: self.description, - seq_length: self.seq_length, database: self.database, - n_hits: filtered.length(), hits: filtered, - total_hits: self.total_hits + id: self.id, + description: self.description, + seq_length: self.seq_length, + database: self.database, + n_hits: filtered.length(), + hits: filtered, + total_hits: self.total_hits, } } ///| /// Get the top N hits by score. -pub fn SearchIOQueryResult::top_n(self : SearchIOQueryResult, n : Int) -> Array[SearchIOHit] { +pub fn SearchIOQueryResult::top_n( + self : SearchIOQueryResult, + n : Int, +) -> Array[SearchIOHit] { let sorted = self.sort_by_score() if sorted.hits.length() <= n { return sorted.hits @@ -572,14 +689,19 @@ pub struct SearchIOIterator { ///| /// Construct SearchIOIterator from search output text. -pub fn SearchIOIterator::new(content : String, format : SearchIOFormat) -> SearchIOIterator { +pub fn SearchIOIterator::new( + content : String, + format : SearchIOFormat, +) -> SearchIOIterator { let lines = split_lines(content) SearchIOIterator::{ lines, position: 0, format, initialized: false } } ///| /// Parse BLAST tabular output (6-column or extended tabular). -pub fn SearchIOIterator::parse_blast_tabular(self : SearchIOIterator) -> Array[SearchIOQueryResult] { +pub fn SearchIOIterator::parse_blast_tabular( + self : SearchIOIterator, +) -> Array[SearchIOQueryResult] { let results : Array[SearchIOQueryResult] = Array::new() let mut current_query_id = "" let mut current_query : SearchIOQueryResult? = None @@ -603,9 +725,14 @@ pub fn SearchIOIterator::parse_blast_tabular(self : SearchIOIterator) -> Array[S None => () } current_query_id = extract_query_id(trimmed) - current_query = Some(SearchIOQueryResult::new( - id=current_query_id, description="", seq_length=0, database="" - )) + current_query = Some( + SearchIOQueryResult::new( + id=current_query_id, + description="", + seq_length=0, + database="", + ), + ) } line_idx = line_idx + 1 continue @@ -626,9 +753,16 @@ pub fn SearchIOIterator::parse_blast_tabular(self : SearchIOIterator) -> Array[S let bitscore = searchio_parse_double(fields[11]) let hsp = SearchIOHsp::new( - bitscore=bitscore, evalue=evalue, identity=identity, positives=identity, - gap=0.0, alignment_length=length, - query_start=qstart, query_end=qend, hit_start=hstart, hit_end=hend + bitscore~, + evalue~, + identity~, + positives=identity, + gap=0.0, + alignment_length=length, + query_start=qstart, + query_end=qend, + hit_start=hstart, + hit_end=hend, ) let mut found = false @@ -639,10 +773,13 @@ pub fn SearchIOIterator::parse_blast_tabular(self : SearchIOIterator) -> Array[S let new_hits = qr.hits.copy() new_hits[i] = updated_hit current_query = Some(SearchIOQueryResult::{ - id: qr.id, description: qr.description, - seq_length: qr.seq_length, database: qr.database, - n_hits: qr.n_hits, hits: new_hits, - total_hits: qr.total_hits + id: qr.id, + description: qr.description, + seq_length: qr.seq_length, + database: qr.database, + n_hits: qr.n_hits, + hits: new_hits, + total_hits: qr.total_hits, }) found = true break @@ -650,14 +787,19 @@ pub fn SearchIOIterator::parse_blast_tabular(self : SearchIOIterator) -> Array[S i = i + 1 } if !found { - let hit = SearchIOHit::new(id=hit_id, description="", seq_length=0).add_hsp(hsp) + let hit = SearchIOHit::new(id=hit_id, description="", seq_length=0).add_hsp( + hsp, + ) let new_hits = qr.hits.copy() new_hits.push(hit) current_query = Some(SearchIOQueryResult::{ - id: qr.id, description: qr.description, - seq_length: qr.seq_length, database: qr.database, - n_hits: qr.n_hits + 1, hits: new_hits, - total_hits: qr.total_hits + id: qr.id, + description: qr.description, + seq_length: qr.seq_length, + database: qr.database, + n_hits: qr.n_hits + 1, + hits: new_hits, + total_hits: qr.total_hits, }) } () @@ -682,7 +824,9 @@ pub fn SearchIOIterator::parse_blast_tabular(self : SearchIOIterator) -> Array[S ///| /// Parse BLAST text output (legacy format). -pub fn SearchIOIterator::parse_blast_text(self : SearchIOIterator) -> Array[SearchIOQueryResult] { +pub fn SearchIOIterator::parse_blast_text( + self : SearchIOIterator, +) -> Array[SearchIOQueryResult] { let results : Array[SearchIOQueryResult] = Array::new() let mut current_query : SearchIOQueryResult? = None @@ -704,7 +848,14 @@ pub fn SearchIOIterator::parse_blast_text(self : SearchIOIterator) -> Array[Sear None => () } let query_id = extract_query_id_text(trimmed) - current_query = Some(SearchIOQueryResult::new(id=query_id, description="", seq_length=0, database="")) + current_query = Some( + SearchIOQueryResult::new( + id=query_id, + description="", + seq_length=0, + database="", + ), + ) line_idx = line_idx + 1 continue } @@ -717,10 +868,13 @@ pub fn SearchIOIterator::parse_blast_text(self : SearchIOIterator) -> Array[Sear let new_hits = qr.hits.copy() new_hits.push(hit) current_query = Some(SearchIOQueryResult::{ - id: qr.id, description: qr.description, - seq_length: qr.seq_length, database: qr.database, - n_hits: qr.n_hits + 1, hits: new_hits, - total_hits: qr.total_hits + id: qr.id, + description: qr.description, + seq_length: qr.seq_length, + database: qr.database, + n_hits: qr.n_hits + 1, + hits: new_hits, + total_hits: qr.total_hits, }) () } @@ -737,18 +891,28 @@ pub fn SearchIOIterator::parse_blast_text(self : SearchIOIterator) -> Array[Sear if qr.hits.length() > 0 { let idx = qr.hits.length() - 1 let hsp = SearchIOHsp::new( - bitscore=bitscore, evalue=evalue, identity=0.0, positives=0.0, - gap=0.0, alignment_length=0, - query_start=0, query_end=0, hit_start=0, hit_end=0 + bitscore~, + evalue~, + identity=0.0, + positives=0.0, + gap=0.0, + alignment_length=0, + query_start=0, + query_end=0, + hit_start=0, + hit_end=0, ) let updated_hit = qr.hits[idx].add_hsp(hsp) let new_hits = qr.hits.copy() new_hits[idx] = updated_hit current_query = Some(SearchIOQueryResult::{ - id: qr.id, description: qr.description, - seq_length: qr.seq_length, database: qr.database, - n_hits: qr.n_hits, hits: new_hits, - total_hits: qr.total_hits + id: qr.id, + description: qr.description, + seq_length: qr.seq_length, + database: qr.database, + n_hits: qr.n_hits, + hits: new_hits, + total_hits: qr.total_hits, }) } () @@ -774,7 +938,9 @@ pub fn SearchIOIterator::parse_blast_text(self : SearchIOIterator) -> Array[Sear ///| /// Main entry point: parse search results based on format. -pub fn SearchIOIterator::parse(self : SearchIOIterator) -> Array[SearchIOQueryResult] { +pub fn SearchIOIterator::parse( + self : SearchIOIterator, +) -> Array[SearchIOQueryResult] { match self.format { SearchIOFormat::BlastTabular => self.parse_blast_tabular() SearchIOFormat::BlastText => self.parse_blast_text() @@ -928,9 +1094,18 @@ fn find_numeric_value(line : String, keyword : String) -> Double { let mut has_e = false while i < line.length() { let c = line.unsafe_get(i) - if (c >= '0' && c <= '9') || (c == '.' && !has_dot) || (c == 'e' || c == 'E') || (c == '-' && has_e) || (c == '+' && has_e) { - if c == '.' { has_dot = true } - if c == 'e' || c == 'E' { has_e = true; has_dot = false } + if (c >= '0' && c <= '9') || + (c == '.' && !has_dot) || + (c == 'e' || c == 'E') || + (c == '-' && has_e) || + (c == '+' && has_e) { + if c == '.' { + has_dot = true + } + if c == 'e' || c == 'E' { + has_e = true + has_dot = false + } num_str = num_str + u16_to_str(c) } else { break @@ -953,10 +1128,76 @@ pub fn search_io_mock_blast_tabular() -> String { "# Query: seq1 test query\n" + "# Database: nr\n" + "# Fields: query id, subject id, % identity, alignment length, mismatches, open gaps, q.start, q.end, s.start, s.end, evalue, bit score\n" + - "seq1" + tab + "hit1" + tab + "95.0" + tab + "100" + tab + "3" + tab + "2" + tab + "1" + tab + "100" + tab + "1" + tab + "100" + tab + "1e-50" + tab + "200.5\n" + - "seq1" + tab + "hit2" + tab + "80.0" + tab + "80" + tab + "10" + tab + "5" + tab + "1" + tab + "80" + tab + "1" + tab + "80" + tab + "1e-30" + tab + "150.3\n" + + "seq1" + + tab + + "hit1" + + tab + + "95.0" + + tab + + "100" + + tab + + "3" + + tab + + "2" + + tab + + "1" + + tab + + "100" + + tab + + "1" + + tab + + "100" + + tab + + "1e-50" + + tab + + "200.5\n" + + "seq1" + + tab + + "hit2" + + tab + + "80.0" + + tab + + "80" + + tab + + "10" + + tab + + "5" + + tab + + "1" + + tab + + "80" + + tab + + "1" + + tab + + "80" + + tab + + "1e-30" + + tab + + "150.3\n" + "# Query: seq2 another query\n" + "# Database: nr\n" + "# Fields: query id, subject id, % identity, alignment length, mismatches, open gaps, q.start, q.end, s.start, s.end, evalue, bit score\n" + - "seq2" + tab + "hit3" + tab + "90.0" + tab + "200" + tab + "5" + tab + "1" + tab + "1" + tab + "200" + tab + "1" + tab + "200" + tab + "1e-80" + tab + "300.0\n" -} \ No newline at end of file + "seq2" + + tab + + "hit3" + + tab + + "90.0" + + tab + + "200" + + tab + + "5" + + tab + + "1" + + tab + + "1" + + tab + + "200" + + tab + + "1" + + tab + + "200" + + tab + + "1e-80" + + tab + + "300.0\n" +} diff --git a/src/seq.mbt b/src/seq.mbt index dccb2526..61225b0c 100644 --- a/src/seq.mbt +++ b/src/seq.mbt @@ -654,7 +654,7 @@ pub fn MutableSeq::new(s : String) -> MutableSeq { data.push(s.unsafe_get(i).unsafe_to_char()) i = i + 1 } - MutableSeq::{ data } + MutableSeq::{ data, } } ///| @@ -744,7 +744,11 @@ pub fn MutableSeq::delete(self : MutableSeq, i : Int) -> Unit { ///| /// Delete characters in range [start, end). -pub fn MutableSeq::delete_range(self : MutableSeq, start : Int, end : Int) -> Unit { +pub fn MutableSeq::delete_range( + self : MutableSeq, + start : Int, + end : Int, +) -> Unit { let new_data = Array::new() let mut idx = 0 while idx < self.data.length() { @@ -817,7 +821,7 @@ pub fn MutableSeq::translate( to_stop? : Bool = false, cds? : Bool = false, ) -> MutableSeq raise SeqError { - let result = self.to_seq().translate(stop_symbol=stop_symbol, to_stop=to_stop, cds=cds) + let result = self.to_seq().translate(stop_symbol~, to_stop~, cds~) MutableSeq::new(result.data) } diff --git a/src/seq_approx.mbt b/src/seq_approx.mbt index 583c681f..c15d77a2 100644 --- a/src/seq_approx.mbt +++ b/src/seq_approx.mbt @@ -121,7 +121,7 @@ pub fn approx_search( } } - let mut best : Option[ApproxMatch] = None + let mut best : ApproxMatch? = None let mut pos = 0 let max_pos = qry_len - pat_len @@ -141,9 +141,7 @@ pub fn approx_search( is_match: true, } best = match best { - Some(prev) => { - if mm < prev.mismatches { Some(m) } else { Some(prev) } - } + Some(prev) => if mm < prev.mismatches { Some(m) } else { Some(prev) } None => Some(m) } if mm == 0 { @@ -155,15 +153,16 @@ pub fn approx_search( match best { Some(m) => m - None => ApproxMatch::{ - pattern, - query, - start: 0, - end: 0, - mismatches: pat_len, - score: 0, - is_match: false, - } + None => + ApproxMatch::{ + pattern, + query, + start: 0, + end: 0, + mismatches: pat_len, + score: 0, + is_match: false, + } } } @@ -217,7 +216,7 @@ pub fn approx_search_with_indels( let init_end = if min_end > start { min_end } else { start + 1 } let mut end = init_end while end <= max_end { - let seg = query.substring(start=start, end=end) + let seg = query.substring(start~, end~) let errors = levenshtein_distance(pattern, seg) if errors <= max_errors && errors < best_errors { best_errors = errors @@ -273,8 +272,12 @@ pub fn levenshtein_distance(s1 : String, s2 : String) -> Int { let len1 = s1.length() let len2 = s2.length() - if len1 == 0 { return len2 } - if len2 == 0 { return len1 } + if len1 == 0 { + return len2 + } + if len2 == 0 { + return len1 + } let mut prev : Array[Int] = Array::new() let mut i = 0 @@ -297,7 +300,17 @@ pub fn levenshtein_distance(s1 : String, s2 : String) -> Int { let deletion = prev[j] + 1 let insertion = row[j - 1] + 1 let substitution = prev[j - 1] + cost - let min_val = if deletion < insertion { if deletion < substitution { deletion } else { substitution } } else { if insertion < substitution { insertion } else { substitution } } + let min_val = if deletion < insertion { + if deletion < substitution { + deletion + } else { + substitution + } + } else if insertion < substitution { + insertion + } else { + substitution + } row.push(min_val) j = j + 1 } @@ -370,7 +383,13 @@ pub fn approx_word_search( let text_len = text.length() if len == 0 { - return ApproxWordResult::{ word, match_start: 0, match_end: 0, edit_distance: 0, is_found: false } + return ApproxWordResult::{ + word, + match_start: 0, + match_end: 0, + edit_distance: 0, + is_found: false, + } } let mut best_dist = max_errors + 1 @@ -380,10 +399,14 @@ pub fn approx_word_search( let mut start = 0 while start < text_len { - let max_end = if start + len + max_errors < text_len { start + len + max_errors } else { text_len } + let max_end = if start + len + max_errors < text_len { + start + len + max_errors + } else { + text_len + } let mut end = start + len while end <= max_end { - let seg = text.substring(start=start, end=end) + let seg = text.substring(start~, end~) let dist = levenshtein_distance(word, seg) if dist <= max_errors && dist < best_dist { best_dist = dist diff --git a/src/seq_complexity.mbt b/src/seq_complexity.mbt index c0555909..6390a1b0 100644 --- a/src/seq_complexity.mbt +++ b/src/seq_complexity.mbt @@ -338,7 +338,7 @@ pub fn lcc_low_complexity_regions( k? : Int = 3, threshold? : Double = 0.5, ) -> Array[(Int, Int)] { - let scores = lcc(seq, window=window, k=k) + let scores = lcc(seq, window~, k~) let regions = Array::new() let mut i = 0 while i < scores.length() { diff --git a/src/seq_location.mbt b/src/seq_location.mbt index 831227d2..ee491031 100644 --- a/src/seq_location.mbt +++ b/src/seq_location.mbt @@ -48,7 +48,9 @@ pub fn pos_to_string(pos : Pos) -> String { let mut s = "{" let mut i = 0 while i < opts.length() { - if i > 0 { s = s + "," } + if i > 0 { + s = s + "," + } s = s + pos_to_string(opts[i]) i = i + 1 } @@ -146,7 +148,7 @@ pub fn compound_from_simple( while i < starts.length() { let sp = exact_position(starts[i]) let ep = exact_position(ends[i]) - locs.push(simple_location(sp, ep, strand=strand)) + locs.push(simple_location(sp, ep, strand~)) i = i + 1 } CompoundLocation(locs, strand, "") @@ -158,7 +160,9 @@ pub fn loc_start(loc : Loc) -> Int { match loc { SimpleLocation(sp, _, _, _) => pos_get(sp) CompoundLocation(locs, _, _) => { - if locs.length() == 0 { return 0 } + if locs.length() == 0 { + return 0 + } locs[0].start() } } @@ -170,7 +174,9 @@ pub fn loc_end(loc : Loc) -> Int { match loc { SimpleLocation(_, ep, _, _) => pos_get(ep) CompoundLocation(locs, _, _) => { - if locs.length() == 0 { return 0 } + if locs.length() == 0 { + return 0 + } let last = locs[locs.length() - 1] last.end() } @@ -193,7 +199,11 @@ pub fn loc_len(loc : Loc) -> Int { SimpleLocation(sp, ep, _, _) => { let e = pos_get(ep) let s = pos_get(sp) - if e > s { e - s } else { s - e } + if e > s { + e - s + } else { + s - e + } } CompoundLocation(locs, _, _) => { let mut total = 0 @@ -262,7 +272,11 @@ pub fn loc_contains(loc : Loc, pos : Int) -> Bool { SimpleLocation(sp, ep, _, _) => { let s = pos_get(sp) let e = pos_get(ep) - if s <= e { pos >= s && pos < e } else { pos > e && pos <= s } + if s <= e { + pos >= s && pos < e + } else { + pos > e && pos <= s + } } CompoundLocation(locs, _, _) => { let mut i = 0 @@ -286,7 +300,9 @@ pub fn loc_to_string(loc : Loc) -> String { let mut s = "" let mut i = 0 while i < locs.length() { - if i > 0 { s = s + "," } + if i > 0 { + s = s + "," + } s = s + locs[i].to_string() i = i + 1 } @@ -308,7 +324,9 @@ pub fn loc_to_one_based(loc : Loc) -> String { let mut s = "join(" let mut i = 0 while i < locs.length() { - if i > 0 { s = s + "," } + if i > 0 { + s = s + "," + } s = s + locs[i].to_one_based() i = i + 1 } @@ -322,37 +340,87 @@ pub fn loc_to_one_based(loc : Loc) -> String { // Pos methods // ============================================================================ +///| /// Get the numeric value of the position. -pub fn Pos::get(self : Pos) -> Int { pos_get(self) } +pub fn Pos::get(self : Pos) -> Int { + pos_get(self) +} + +///| /// Get the string representation of a position. -pub fn Pos::to_string(self : Pos) -> String { pos_to_string(self) } +pub fn Pos::to_string(self : Pos) -> String { + pos_to_string(self) +} + +///| /// Check if a position is exact. -pub fn Pos::is_exact(self : Pos) -> Bool { pos_is_exact(self) } +pub fn Pos::is_exact(self : Pos) -> Bool { + pos_is_exact(self) +} // ============================================================================ // Loc methods // ============================================================================ +///| /// Get the start position (0-based). -pub fn Loc::start(self : Loc) -> Int { loc_start(self) } +pub fn Loc::start(self : Loc) -> Int { + loc_start(self) +} + +///| /// Get the end position (0-based, exclusive). -pub fn Loc::end(self : Loc) -> Int { loc_end(self) } +pub fn Loc::end(self : Loc) -> Int { + loc_end(self) +} + +///| /// Get the strand. -pub fn Loc::strand(self : Loc) -> String { loc_strand(self) } +pub fn Loc::strand(self : Loc) -> String { + loc_strand(self) +} + +///| /// Get the length of the location. -pub fn Loc::len(self : Loc) -> Int { loc_len(self) } +pub fn Loc::len(self : Loc) -> Int { + loc_len(self) +} + +///| /// Check if this is a compound location. -pub fn Loc::is_compound(self : Loc) -> Bool { loc_is_compound(self) } +pub fn Loc::is_compound(self : Loc) -> Bool { + loc_is_compound(self) +} + +///| /// Get the sub-locations. -pub fn Loc::parts(self : Loc) -> Array[Loc] { loc_parts(self) } +pub fn Loc::parts(self : Loc) -> Array[Loc] { + loc_parts(self) +} + +///| /// Check if two locations overlap. -pub fn Loc::overlaps(self : Loc, other : Loc) -> Bool { loc_overlaps(self, other) } +pub fn Loc::overlaps(self : Loc, other : Loc) -> Bool { + loc_overlaps(self, other) +} + +///| /// Check if this location contains a position. -pub fn Loc::contains(self : Loc, pos : Int) -> Bool { loc_contains(self, pos) } +pub fn Loc::contains(self : Loc, pos : Int) -> Bool { + loc_contains(self, pos) +} + +///| /// Get location as string. -pub fn Loc::to_string(self : Loc) -> String { loc_to_string(self) } +pub fn Loc::to_string(self : Loc) -> String { + loc_to_string(self) +} + +///| /// Return location in 1-based coordinates. -pub fn Loc::to_one_based(self : Loc) -> String { loc_to_one_based(self) } +pub fn Loc::to_one_based(self : Loc) -> String { + loc_to_one_based(self) +} // ============================================================================ // Helper Functions @@ -366,10 +434,14 @@ pub fn location_to_genbank(loc : Loc) -> String { ///| /// Create a simple location from 1-based GenBank coordinates. -pub fn from_genbank_coords(start : Int, end_ : Int, strand? : String = "+") -> Loc { +pub fn from_genbank_coords( + start : Int, + end_ : Int, + strand? : String = "+", +) -> Loc { let sp = exact_position(start - 1) let ep = exact_position(end_) - simple_location(sp, ep, strand=strand) + simple_location(sp, ep, strand~) } ///| @@ -390,21 +462,30 @@ pub fn parse_genbank_location(loc_str : String) -> Loc { } } +///| /// Parse an integer from a trimmed string view, returning 1 on failure. fn parse_int_trimmed(sv : StringView) -> Int { let s = sv.trim().to_owned() let n = s.length() - if n == 0 { return 1 } + if n == 0 { + return 1 + } let mut result = 0 let mut i = 0 let zero = '0'.to_int() while i < n { let c = s.unsafe_get(i).to_int() - if c < zero || c > zero + 9 { break } + if c < zero || c > zero + 9 { + break + } result = result * 10 + (c - zero) i = i + 1 } - if result == 0 && n > 0 { 1 } else { result } + if result == 0 && n > 0 { + 1 + } else { + result + } } ///| @@ -412,20 +493,38 @@ fn parse_int_trimmed(sv : StringView) -> Int { pub fn seq_location_sample() -> Array[Loc] { let locs : Array[Loc] = Array::new() locs.push(simple_location(exact_position(10), exact_position(50), strand="+")) - locs.push(simple_location(exact_position(100), exact_position(200), strand="-")) - let exon1 = simple_location(exact_position(0), exact_position(100), strand="+") - let exon2 = simple_location(exact_position(200), exact_position(350), strand="+") - let exon3 = simple_location(exact_position(500), exact_position(600), strand="+") + locs.push( + simple_location(exact_position(100), exact_position(200), strand="-"), + ) + let exon1 = simple_location( + exact_position(0), + exact_position(100), + strand="+", + ) + let exon2 = simple_location( + exact_position(200), + exact_position(350), + strand="+", + ) + let exon3 = simple_location( + exact_position(500), + exact_position(600), + strand="+", + ) let exon_locs : Array[Loc] = Array::new() exon_locs.push(exon1) exon_locs.push(exon2) exon_locs.push(exon3) locs.push(compound_location(exon_locs, strand="+")) - locs.push(simple_location(before_position(50), after_position(100), strand="+")) + locs.push( + simple_location(before_position(50), after_position(100), strand="+"), + ) let opts : Array[Pos] = Array::new() opts.push(exact_position(5)) opts.push(exact_position(7)) opts.push(exact_position(9)) - locs.push(simple_location(one_of_position(7, opts), exact_position(50), strand="+")) + locs.push( + simple_location(one_of_position(7, opts), exact_position(50), strand="+"), + ) locs } diff --git a/src/seq_quality_trim.mbt b/src/seq_quality_trim.mbt index c23528ee..94ed9666 100644 --- a/src/seq_quality_trim.mbt +++ b/src/seq_quality_trim.mbt @@ -681,9 +681,7 @@ test "sqt_trim_adapter_perfect_match" { let seq = "ACGTACGTAGATCGGAA" let qual = "IIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" - let (t_seq, _) = sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, - ) + let (t_seq, _) = sqt_trim_adapter(seq, qual, adapter, allowed_mismatches=0) assert_eq(t_seq, "ACGTACGT") } @@ -692,9 +690,7 @@ test "sqt_trim_adapter_no_match" { let seq = "ACGTACGTACGTACGT" let qual = "IIIIIIIIIIIIIIII" let adapter = "GGGGGGGG" - let (t_seq, _) = sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, - ) + let (t_seq, _) = sqt_trim_adapter(seq, qual, adapter, allowed_mismatches=0) assert_eq(t_seq, "ACGTACGTACGTACGT") } @@ -703,9 +699,7 @@ test "sqt_trim_adapter_with_mismatches" { let seq = "ACGTACGTAGATCGGAA" let qual = "IIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" - let (t_seq, _) = sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=2, - ) + let (t_seq, _) = sqt_trim_adapter(seq, qual, adapter, allowed_mismatches=2) assert_eq(t_seq, "ACGTACGT") } @@ -722,9 +716,7 @@ test "sqt_trim_adapter_short_seq" { let seq = "AC" let qual = "II" let adapter = "AGATCGGAA" - let (t_seq, _) = sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, - ) + let (t_seq, _) = sqt_trim_adapter(seq, qual, adapter, allowed_mismatches=0) assert_eq(t_seq, "AC") } @@ -733,9 +725,7 @@ test "sqt_trim_adapter_at_beginning" { let seq = "AGATCGGAAACGTACGT" let qual = "IIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" - let (t_seq, _) = sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, - ) + let (t_seq, _) = sqt_trim_adapter(seq, qual, adapter, allowed_mismatches=0) assert_eq(t_seq.length(), 0) } @@ -838,11 +828,7 @@ test "sqt_trim_by_gc_mid_range" { ///| test "sqt_trim_reads_batch" { let reads = [ - FastqRead::{ - id: "read1", - sequence: "ACGTACGT", - quality: "IIIIIIII", - }, + FastqRead::{ id: "read1", sequence: "ACGTACGT", quality: "IIIIIIII" }, FastqRead::{ id: "read2", sequence: "ACGTACGTAGATCGGAA", @@ -885,24 +871,15 @@ test "sqt_trim_reads_no_adapter" { assert_eq(results.length(), 1) assert_eq(results[0].trimmed_seq, "ACGTACGGG") assert_true( - results[0].trim_type == "poly_A" || - results[0].trim_type == "poly_A,quality", + results[0].trim_type == "poly_A" || results[0].trim_type == "poly_A,quality", ) } ///| test "sqt_compute_stats_basic" { let reads = [ - FastqRead::{ - id: "r1", - sequence: "ACGTACGT", - quality: "IIIIIIII", - }, - FastqRead::{ - id: "r2", - sequence: "TTTTTTTT", - quality: "IIIIIIII", - }, + FastqRead::{ id: "r1", sequence: "ACGTACGT", quality: "IIIIIIII" }, + FastqRead::{ id: "r2", sequence: "TTTTTTTT", quality: "IIIIIIII" }, ] let results = [ TrimResult::{ @@ -978,13 +955,7 @@ test "sqt_fastq_parse_malformed" { ///| test "sqt_fastq_serialize_basic" { - let reads = [ - FastqRead::{ - id: "test1", - sequence: "ACGT", - quality: "IIII", - }, - ] + let reads = [FastqRead::{ id: "test1", sequence: "ACGT", quality: "IIII" }] let output = sqt_fastq_serialize(reads) assert_eq(output, "@test1\nACGT\n+\nIIII\n") } @@ -992,22 +963,11 @@ test "sqt_fastq_serialize_basic" { ///| test "sqt_fastq_serialize_multiple" { let reads = [ - FastqRead::{ - id: "r1", - sequence: "AAAA", - quality: "IIII", - }, - FastqRead::{ - id: "r2", - sequence: "CCCC", - quality: "IIII", - }, + FastqRead::{ id: "r1", sequence: "AAAA", quality: "IIII" }, + FastqRead::{ id: "r2", sequence: "CCCC", quality: "IIII" }, ] let output = sqt_fastq_serialize(reads) - assert_eq( - output, - "@r1\nAAAA\n+\nIIII\n@r2\nCCCC\n+\nIIII\n", - ) + assert_eq(output, "@r1\nAAAA\n+\nIIII\n@r2\nCCCC\n+\nIIII\n") } ///| @@ -1043,16 +1003,8 @@ test "sqt_quality_trim_single_base" { ///| test "sqt_compute_stats_gc_content" { let reads = [ - FastqRead::{ - id: "gc_high", - sequence: "GGGGCCCC", - quality: "IIIIIIII", - }, - FastqRead::{ - id: "at_high", - sequence: "AAAATTTT", - quality: "IIIIIIII", - }, + FastqRead::{ id: "gc_high", sequence: "GGGGCCCC", quality: "IIIIIIII" }, + FastqRead::{ id: "at_high", sequence: "AAAATTTT", quality: "IIIIIIII" }, ] let results = [ TrimResult::{ @@ -1080,11 +1032,7 @@ test "sqt_compute_stats_gc_content" { ///| test "sqt_trim_reads_quality_trim_only" { let reads = [ - FastqRead::{ - id: "r1", - sequence: "ACGTACGT", - quality: "IIII####", - }, + FastqRead::{ id: "r1", sequence: "ACGTACGT", quality: "IIII####" }, ] let qual_config = QualityConfig::{ min_quality: 20, @@ -1102,9 +1050,7 @@ test "sqt_trim_adapter_partial_overlap" { let seq = "ACGTACGTAGATCGGAA" let qual = "IIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" - let (t_seq, _) = sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=1, - ) + let (t_seq, _) = sqt_trim_adapter(seq, qual, adapter, allowed_mismatches=1) assert_eq(t_seq, "ACGTACGT") } @@ -1153,13 +1099,7 @@ test "sqt_fastq_parse_crlf" { ///| test "sqt_compute_stats_all_discarded" { - let reads = [ - FastqRead::{ - id: "r1", - sequence: "ACGT", - quality: "IIII", - }, - ] + let reads = [FastqRead::{ id: "r1", sequence: "ACGT", quality: "IIII" }] let results = [ TrimResult::{ read_id: "r1", @@ -1176,4 +1116,4 @@ test "sqt_compute_stats_all_discarded" { assert_eq(stats.discarded_reads, 1) assert_eq(stats.total_bp_after, 0) assert_eq(stats.gc_content_after, 0.0) -} \ No newline at end of file +} diff --git a/src/seq_utils.mbt b/src/seq_utils.mbt index 9e4ecf4d..6f4be588 100644 --- a/src/seq_utils.mbt +++ b/src/seq_utils.mbt @@ -364,11 +364,17 @@ pub fn reverse_complement(seq : String) -> String { ///| /// Calculate GC skew of a DNA sequence in a sliding window. /// GC skew = (G - C) / (G + C) -pub fn gc_skew(seq : String, window_size : Int, step_size : Int) -> Array[Double] { +pub fn gc_skew( + seq : String, + window_size : Int, + step_size : Int, +) -> Array[Double] { let result : Array[Double] = Array::new() let len = seq.length() - if len < window_size { return result } - + if len < window_size { + return result + } + let mut i = 0 while i <= len - window_size { let window = seq[i:i + window_size].to_owned().to_upper() @@ -377,8 +383,12 @@ pub fn gc_skew(seq : String, window_size : Int, step_size : Int) -> Array[Double let mut j = 0 while j < window.length() { let c = window[j:j + 1] - if c == "G" { g_count = g_count + 1 } - if c == "C" { c_count = c_count + 1 } + if c == "G" { + g_count = g_count + 1 + } + if c == "C" { + c_count = c_count + 1 + } j = j + 1 } let gc_total = g_count.to_double() + c_count.to_double() @@ -395,11 +405,17 @@ pub fn gc_skew(seq : String, window_size : Int, step_size : Int) -> Array[Double ///| /// Calculate AT skew of a DNA sequence in a sliding window. /// AT skew = (A - T) / (A + T) -pub fn at_skew(seq : String, window_size : Int, step_size : Int) -> Array[Double] { +pub fn at_skew( + seq : String, + window_size : Int, + step_size : Int, +) -> Array[Double] { let result : Array[Double] = Array::new() let len = seq.length() - if len < window_size { return result } - + if len < window_size { + return result + } + let mut i = 0 while i <= len - window_size { let window = seq[i:i + window_size].to_owned().to_upper() @@ -408,8 +424,12 @@ pub fn at_skew(seq : String, window_size : Int, step_size : Int) -> Array[Double let mut j = 0 while j < window.length() { let c = window[j:j + 1] - if c == "A" { a_count = a_count + 1 } - if c == "T" { t_count = t_count + 1 } + if c == "A" { + a_count = a_count + 1 + } + if c == "T" { + t_count = t_count + 1 + } j = j + 1 } let at_total = a_count.to_double() + t_count.to_double() @@ -427,8 +447,10 @@ pub fn at_skew(seq : String, window_size : Int, step_size : Int) -> Array[Double /// Calculate sequence similarity between two sequences. pub fn sequence_similarity(seq1 : String, seq2 : String) -> Double { let len = min_val(seq1.length().to_double(), seq2.length().to_double()) - if len == 0.0 { return 0.0 } - + if len == 0.0 { + return 0.0 + } + let mut matches = 0.0 let mut i = 0 while i < len.to_int() { @@ -445,25 +467,29 @@ pub fn sequence_similarity(seq1 : String, seq2 : String) -> Double { pub fn edit_distance(seq1 : String, seq2 : String) -> Int { let m = seq1.length() let n = seq2.length() - - if m == 0 { return n } - if n == 0 { return m } - + + if m == 0 { + return n + } + if n == 0 { + return m + } + // Dynamic programming approach let dp : Array[Array[Int]] = Array::make(m + 1, Array::make(n + 1, 0)) - + let mut i = 0 while i <= m { dp[i][0] = i i = i + 1 } - + let mut j = 0 while j <= n { dp[0][j] = j j = j + 1 } - + i = 1 while i <= m { j = 1 @@ -481,18 +507,29 @@ pub fn edit_distance(seq1 : String, seq2 : String) -> Int { } i = i + 1 } - + dp[m][n] } +///| fn min_val(a : Double, b : Double) -> Double { - if a < b { a } else { b } + if a < b { + a + } else { + b + } } +///| fn min_val_int(a : Int, b : Int) -> Int { - if a < b { a } else { b } + if a < b { + a + } else { + b + } } +///| fn min_val3(a : Int, b : Int, c : Int) -> Int { min_val_int(min_val_int(a, b), c) } diff --git a/src/seqfeature_advanced.mbt b/src/seqfeature_advanced.mbt index 28fc1ae1..85a7db12 100644 --- a/src/seqfeature_advanced.mbt +++ b/src/seqfeature_advanced.mbt @@ -90,11 +90,7 @@ fn parse_int_at(s : String, pos : Int) -> (Int, Int) raise LocationParserError { } if !found { raise LocationParserError( - "Expected integer at position " + - pos.to_string() + - " in '" + - s + - "'", + "Expected integer at position " + pos.to_string() + " in '" + s + "'", ) } (result, i) @@ -217,7 +213,7 @@ pub fn CompoundLocation::order( ///| /// Get the start position of the first part in this compound location. -pub fn compound_start(self : CompoundLocation) -> Position { +pub fn CompoundLocation::compound_start(self : CompoundLocation) -> Position { if self.parts.length() == 0 { return UnknownPosition } @@ -226,7 +222,7 @@ pub fn compound_start(self : CompoundLocation) -> Position { ///| /// Get the end position of the last part in this compound location. -pub fn compound_end(self : CompoundLocation) -> Position { +pub fn CompoundLocation::compound_end(self : CompoundLocation) -> Position { if self.parts.length() == 0 { return UnknownPosition } @@ -237,7 +233,7 @@ pub fn compound_end(self : CompoundLocation) -> Position { /// Extract the compound feature sequence from a parent sequence. /// Each part's sequence is extracted and concatenated in order. /// If any part has strand -1, that part is reverse-complemented. -pub fn compound_extract( +pub fn CompoundLocation::compound_extract( self : CompoundLocation, parent_sequence : Seq, ) -> String raise LocationParserError { @@ -255,7 +251,7 @@ pub fn compound_extract( ///| /// Generate a GenBank-format string representation of this compound location. /// Example: "join(1..100,complement(200..300))" -pub fn compound_to_string(self : CompoundLocation) -> String { +pub fn CompoundLocation::compound_to_string(self : CompoundLocation) -> String { let buf = StringBuilder::new() let strand = self._compound_strand() if strand == Some(-1) { @@ -280,7 +276,7 @@ pub fn compound_to_string(self : CompoundLocation) -> String { /// Determine the compound strand by checking all parts. /// If all parts share the same strand, return that strand. /// Otherwise return None. -fn _compound_strand(self : CompoundLocation) -> Int? { +fn CompoundLocation::_compound_strand(self : CompoundLocation) -> Int? { if self.parts.length() == 0 { return None } @@ -323,13 +319,7 @@ fn _position_gb_string(pos : Position) -> String { BeforePosition(p) => "<" + p.to_string() AfterPosition(p) => ">" + p.to_string() WithinPosition(p, fs, fe) => - "<" + - fs.to_string() + - ".." + - p.to_string() + - ".." + - fe.to_string() + - ">" + "<" + fs.to_string() + ".." + p.to_string() + ".." + fe.to_string() + ">" UncertainPosition(p) => "?" + p.to_string() + "?" UnknownPosition => "?" } @@ -409,9 +399,7 @@ pub fn parse_simple_location( let dot_pos = match trimmed.find(dots) { Some(p) => p None => - raise LocationParserError( - "Expected '..' in location string: " + trimmed, - ) + raise LocationParserError("Expected '..' in location string: " + trimmed) } let start_str = trim_whitespace(trimmed[0:dot_pos].to_owned()) let end_str = trim_whitespace( @@ -435,9 +423,7 @@ pub fn parse_complement_location( let trimmed = trim_whitespace(loc_string) let prefix = "complement(" if !trimmed.starts_with(prefix) { - raise LocationParserError( - "Expected 'complement(' prefix in: " + trimmed, - ) + raise LocationParserError("Expected 'complement(' prefix in: " + trimmed) } let paren_start = prefix.length() - 1 let after_prefix = trim_whitespace( @@ -470,18 +456,13 @@ pub fn parse_join_location( } else if trimmed.starts_with("order(") { ("order", trimmed[5:trimmed.length()].to_owned()) } else { - raise LocationParserError( - "Expected 'join(' or 'order(' in: " + trimmed, - ) + raise LocationParserError("Expected 'join(' or 'order(' in: " + trimmed) } let close_paren = match find_matching_paren(after_op, 0) { Some(p) => p None => raise LocationParserError( - "Missing closing parenthesis in " + - operator + - ": " + - trimmed, + "Missing closing parenthesis in " + operator + ": " + trimmed, ) } let inner = trim_whitespace(after_op[1:close_paren].to_owned()) @@ -493,9 +474,7 @@ pub fn parse_join_location( } let parsed = parse_location_string(part_str) match parsed { - ParsedFeatureLocation(loc) => { - parts.push(loc) - } + ParsedFeatureLocation(loc) => parts.push(loc) ParsedCompoundLocation(_) => raise LocationParserError( "Nested compound locations are not supported in " + @@ -505,12 +484,7 @@ pub fn parse_join_location( ) } } - CompoundLocation::{ - parts, - operator, - ref_seq: None, - ref_db: None, - } + CompoundLocation::{ parts, operator, ref_seq: None, ref_db: None } } ///| @@ -624,7 +598,9 @@ pub fn SeqFeatureExtended::new( ///| /// Get the feature location. -pub fn SeqFeatureExtended::location(self : SeqFeatureExtended) -> FeatureLocation { +pub fn SeqFeatureExtended::location( + self : SeqFeatureExtended, +) -> FeatureLocation { self.location } @@ -657,7 +633,7 @@ pub fn SeqFeatureExtended::qualifiers( ///| /// Add a qualifier key-value pair to this feature. /// If the key already exists, the value is appended to the existing array. -pub fn add_qualifier( +pub fn SeqFeatureExtended::add_qualifier( self : SeqFeatureExtended, key : String, value : String, @@ -675,9 +651,7 @@ pub fn add_qualifier( new_arr.push(value) new_quals[key] = new_arr } - None => { - new_quals[key] = [value] - } + None => new_quals[key] = [value] } SeqFeatureExtended::{ ..self, qualifiers: new_quals } } @@ -685,7 +659,7 @@ pub fn add_qualifier( ///| /// Get qualifier values for a given key. /// Returns an empty array if the key does not exist. -pub fn get_qualifier( +pub fn SeqFeatureExtended::get_qualifier( self : SeqFeatureExtended, key : String, ) -> Array[String] { @@ -702,7 +676,9 @@ pub fn get_qualifier( /// type location /// /key="value" /// /key="value" -pub fn seq_feature_to_string(self : SeqFeatureExtended) -> String { +pub fn SeqFeatureExtended::seq_feature_to_string( + self : SeqFeatureExtended, +) -> String { let buf = StringBuilder::new() buf.write_string(self.type_) buf.write_char(' ') @@ -742,9 +718,7 @@ pub fn location_to_string(loc : FeatureLocation) -> String { /// - strand +1 becomes -1 /// - strand -1 becomes +1 /// - strand 0 or None stays the same -pub fn feature_location_complement( - loc : FeatureLocation, -) -> FeatureLocation { +pub fn feature_location_complement(loc : FeatureLocation) -> FeatureLocation { let new_strand = match loc.strand { Some(s) => if s == 1 { @@ -833,16 +807,8 @@ pub fn merge_locations( let start2 = loc2.start.to_int() let end1 = loc1.end.to_int() let end2 = loc2.end.to_int() - let new_start = if start1 <= start2 { - loc1.start - } else { - loc2.start - } - let new_end = if end1 >= end2 { - loc1.end - } else { - loc2.end - } + let new_start = if start1 <= start2 { loc1.start } else { loc2.start } + let new_end = if end1 >= end2 { loc1.end } else { loc2.end } FeatureLocation::{ start: new_start, end: new_end, @@ -850,4 +816,4 @@ pub fn merge_locations( ref_seq: loc1.ref_seq, ref_db: loc1.ref_db, } -} \ No newline at end of file +} diff --git a/src/seqlogo.mbt b/src/seqlogo.mbt index 46916f9b..8f9f9062 100644 --- a/src/seqlogo.mbt +++ b/src/seqlogo.mbt @@ -60,9 +60,7 @@ fn seqlogo_to_lower(c : Char) -> Char { ///| /// Sort (frequency, base) pairs by frequency descending (selection sort). -fn seqlogo_sort_desc( - pairs : Array[(Double, Int)], -) -> Array[(Double, Int)] { +fn seqlogo_sort_desc(pairs : Array[(Double, Int)]) -> Array[(Double, Int)] { let sorted = pairs.copy() let n = sorted.length() let mut i = 0 @@ -102,24 +100,13 @@ pub struct SeqLogoPwm { /// Construct a PWM from a 4 x L matrix (row 0 = A, 1 = C, 2 = G, 3 = T). pub fn SeqLogoPwm::new(matrix : Array[Array[Double]]) -> SeqLogoPwm { let alphabet_size = matrix.length() - let width = if alphabet_size > 0 { - matrix[0].length() - } else { - 0 - } - SeqLogoPwm::{ - matrix, - width, - alphabet_size, - alphabet: ["A", "C", "G", "T"], - } + let width = if alphabet_size > 0 { matrix[0].length() } else { 0 } + SeqLogoPwm::{ matrix, width, alphabet_size, alphabet: ["A", "C", "G", "T"] } } ///| /// Build a PWM from a set of equal-length aligned DNA sequences. -pub fn SeqLogoPwm::from_sequences( - sequences : Array[String], -) -> SeqLogoPwm { +pub fn SeqLogoPwm::from_sequences(sequences : Array[String]) -> SeqLogoPwm { let n = sequences.length() if n == 0 { return SeqLogoPwm::new(Array::new()) @@ -174,10 +161,7 @@ pub fn SeqLogoPwm::alphabet(self : SeqLogoPwm) -> Array[String] { ///| /// Frequency of `base` (0-3) at `pos`. pub fn SeqLogoPwm::get(self : SeqLogoPwm, base : Int, pos : Int) -> Double { - if base >= 0 && - base < self.alphabet_size && - pos >= 0 && - pos < self.width { + if base >= 0 && base < self.alphabet_size && pos >= 0 && pos < self.width { self.matrix[base][pos] } else { 0.0 @@ -255,11 +239,7 @@ pub fn SeqLogoColumn::new( position : Int, info_content : Double, ) -> SeqLogoColumn { - SeqLogoColumn::{ - letters: Array::new(), - info_content, - position, - } + SeqLogoColumn::{ letters: Array::new(), info_content, position } } ///| @@ -300,9 +280,7 @@ pub struct SeqLogoResult { ///| /// Construct a SeqLogoResult, computing total IC and width from the columns. -pub fn SeqLogoResult::new( - columns : Array[SeqLogoColumn], -) -> SeqLogoResult { +pub fn SeqLogoResult::new(columns : Array[SeqLogoColumn]) -> SeqLogoResult { let mut total_ic = 0.0 for col in columns { total_ic = total_ic + col.info_content() @@ -476,19 +454,12 @@ pub fn seqlogo_compute_logo_bg( /// information contribution. Uppercase letters mark large contributions and /// lowercase letters mark small ones. `max_height` is the row count used for /// the tallest possible column (2 bits for DNA). -pub fn seqlogo_to_ascii( - logo : SeqLogoResult, - max_height : Int, -) -> String { +pub fn seqlogo_to_ascii(logo : SeqLogoResult, max_height : Int) -> String { if max_height <= 0 { return "" } let max_ic = seqlogo_max_information_content(4) - let scale = if max_ic > 0.0 { - max_height.to_double() / max_ic - } else { - 0.0 - } + let scale = if max_ic > 0.0 { max_height.to_double() / max_ic } else { 0.0 } // Build a per-column stack of characters from bottom (index 0) to top. let stacks : Array[Array[Char]] = Array::new() for col in logo.columns() { @@ -627,21 +598,13 @@ pub fn seqlogo_sample_pwm() -> SeqLogoPwm { // 4 rows (A, C, G, T) x 10 columns. let matrix = [ // A - [ - 0.90, 0.10, 0.25, 0.05, 0.20, 0.01, 0.40, 0.85, 0.15, 0.30, - ], + [0.90, 0.10, 0.25, 0.05, 0.20, 0.01, 0.40, 0.85, 0.15, 0.30], // C - [ - 0.03, 0.10, 0.25, 0.90, 0.30, 0.02, 0.40, 0.05, 0.15, 0.30, - ], + [0.03, 0.10, 0.25, 0.90, 0.30, 0.02, 0.40, 0.05, 0.15, 0.30], // G - [ - 0.04, 0.70, 0.25, 0.03, 0.30, 0.03, 0.10, 0.05, 0.55, 0.20, - ], + [0.04, 0.70, 0.25, 0.03, 0.30, 0.03, 0.10, 0.05, 0.55, 0.20], // T - [ - 0.03, 0.10, 0.25, 0.02, 0.20, 0.94, 0.10, 0.05, 0.15, 0.20, - ], + [0.03, 0.10, 0.25, 0.02, 0.20, 0.94, 0.10, 0.05, 0.15, 0.20], ] SeqLogoPwm::new(matrix) } @@ -650,25 +613,9 @@ pub fn seqlogo_sample_pwm() -> SeqLogoPwm { /// Twenty aligned DNA sequences of length 10 used to build a sample PWM. pub fn seqlogo_sample_sequences() -> Array[String] { [ - "AGACATGAGC", - "AGACATGAGG", - "CGACGTGAGT", - "AGTCATGAGC", - "GGACATGAGC", - "AGGCATGAGC", - "AGACGTGATC", - "AGACATGTGC", - "AGACATGCGC", - "TGACATGAGC", - "AGACATGAGA", - "AGACATGAGC", - "CGACATGAGG", - "AGATATGAGC", - "AGACACGAGC", - "AGAGATGAGC", - "AGACATGAGG", - "AGACATGACC", - "AGACATGTGC", - "AAACATGAGC", + "AGACATGAGC", "AGACATGAGG", "CGACGTGAGT", "AGTCATGAGC", "GGACATGAGC", "AGGCATGAGC", + "AGACGTGATC", "AGACATGTGC", "AGACATGCGC", "TGACATGAGC", "AGACATGAGA", "AGACATGAGC", + "CGACATGAGG", "AGATATGAGC", "AGACACGAGC", "AGAGATGAGC", "AGACATGAGG", "AGACATGACC", + "AGACATGTGC", "AAACATGAGC", ] } diff --git a/src/seqxml_io.mbt b/src/seqxml_io.mbt index 439582b8..f984ab22 100644 --- a/src/seqxml_io.mbt +++ b/src/seqxml_io.mbt @@ -281,11 +281,7 @@ fn seqxml_is_tag_delim(c : UInt16) -> Bool { /// Find the next opening tag named `tag_name` at or after position `from`. /// Returns the position of the "<" or None. A tag boundary (whitespace, ">", /// or "/") must follow the tag name to avoid prefix matches. -fn seqxml_find_tag( - content : String, - tag_name : String, - from : Int, -) -> Int? { +fn seqxml_find_tag(content : String, tag_name : String, from : Int) -> Int? { let pattern = "<" + tag_name let plen = pattern.length() let n = content.length() @@ -410,11 +406,7 @@ fn seqxml_extract_attr_value(tag : String, attr : String) -> String? { ///| /// Extract an attribute value and XML-unescape it, returning `default` /// when the attribute is absent. -fn seqxml_attr_or( - tag : String, - attr : String, - default : String, -) -> String { +fn seqxml_attr_or(tag : String, attr : String, default : String) -> String { match seqxml_extract_attr_value(tag, attr) { Some(v) => seqxml_unescape(v) None => default @@ -424,30 +416,33 @@ fn seqxml_attr_or( ///| /// Escape a string for use inside an XML attribute value. fn seqxml_escape_attr(s : String) -> String { - s.replace(old="&", new="&") - .replace(old="<", new="<") - .replace(old=">", new=">") - .replace(old="\"", new=""") - .replace(old="'", new="'") + s + .replace(old="&", new="&") + .replace(old="<", new="<") + .replace(old=">", new=">") + .replace(old="\"", new=""") + .replace(old="'", new="'") } ///| /// Escape a string for use as XML text content. fn seqxml_escape_text(s : String) -> String { - s.replace(old="&", new="&") - .replace(old="<", new="<") - .replace(old=">", new=">") + s + .replace(old="&", new="&") + .replace(old="<", new="<") + .replace(old=">", new=">") } ///| /// Decode XML entities (& < > " ') back to characters. /// & is decoded last to avoid double-decoding. fn seqxml_unescape(s : String) -> String { - s.replace(old="<", new="<") - .replace(old=">", new=">") - .replace(old=""", new="\"") - .replace(old="'", new="'") - .replace(old="&", new="&") + s + .replace(old="<", new="<") + .replace(old=">", new=">") + .replace(old=""", new="\"") + .replace(old="'", new="'") + .replace(old="&", new="&") } ///| @@ -492,9 +487,9 @@ fn seqxml_parse_header(content : String, doc : SeqXmlDocument) -> Unit { Some(start) => match seqxml_find_tag_end(content, start) { Some(gt_pos) => { - let body = content[start + 1 : gt_pos].to_owned() + let body = content[start + 1:gt_pos].to_owned() let clean = if body.has_suffix("/") { - body[0 : body.length() - 1].to_owned() + body[0:body.length() - 1].to_owned() } else { body } @@ -510,9 +505,9 @@ fn seqxml_parse_header(content : String, doc : SeqXmlDocument) -> Unit { Some(start) => match seqxml_find_tag_end(content, start) { Some(gt_pos) => { - let body = content[start + 1 : gt_pos].to_owned() + let body = content[start + 1:gt_pos].to_owned() let clean = if body.has_suffix("/") { - body[0 : body.length() - 1].to_owned() + body[0:body.length() - 1].to_owned() } else { body } @@ -537,7 +532,7 @@ fn seqxml_extract_element_text(inner : String, tag : String) -> String? { let close_tag = "" match seqxml_index_of_from(inner, close_tag, content_start) { Some(close_pos) => { - let text = inner[content_start : close_pos].to_owned() + let text = inner[content_start:close_pos].to_owned() Some(seqxml_unescape(seqxml_trim_ws(text))) } None => None @@ -581,9 +576,9 @@ fn seqxml_parse_properties(inner : String) -> Array[(String, String)] { Some(prop_start) => match seqxml_find_tag_end(inner, prop_start) { Some(gt_pos) => { - let body = inner[prop_start + 1 : gt_pos].to_owned() + let body = inner[prop_start + 1:gt_pos].to_owned() let clean = if body.has_suffix("/") { - body[0 : body.length() - 1].to_owned() + body[0:body.length() - 1].to_owned() } else { body } @@ -623,10 +618,10 @@ pub fn seqxml_parse(content : String) -> SeqXmlDocument { match seqxml_find_tag_end(content, entry_start) { None => break Some(gt_pos) => { - let body = content[entry_start + 1 : gt_pos].to_owned() + let body = content[entry_start + 1:gt_pos].to_owned() let self_closing = body.has_suffix("/") let clean_body = if self_closing { - body[0 : body.length() - 1].to_owned() + body[0:body.length() - 1].to_owned() } else { body } @@ -640,7 +635,7 @@ pub fn seqxml_parse(content : String) -> SeqXmlDocument { } let (seq_type, sequence, properties) = match close_pos_opt { Some(close_pos) => { - let inner = content[inner_start : close_pos].to_owned() + let inner = content[inner_start:close_pos].to_owned() let (st, seq) = seqxml_parse_sequence(inner) let props = seqxml_parse_properties(inner) (st, seq, props) @@ -677,9 +672,9 @@ pub fn seqxml_parse_entry_id(line : String) -> String? { Some(start) => match seqxml_find_tag_end(line, start) { Some(gt_pos) => { - let body = line[start + 1 : gt_pos].to_owned() + let body = line[start + 1:gt_pos].to_owned() let clean = if body.has_suffix("/") { - body[0 : body.length() - 1].to_owned() + body[0:body.length() - 1].to_owned() } else { body } diff --git a/src/seurat.mbt b/src/seurat.mbt index 239bd794..723c2611 100644 --- a/src/seurat.mbt +++ b/src/seurat.mbt @@ -48,7 +48,7 @@ pub fn SeuratObject::new( pub fn normalize_total(obj : SeuratObject) -> SeuratObject { let n_genes = obj.row_names.length() let n_cells = obj.col_names.length() - + // Precompute column sums (O(n_genes * n_cells) instead of O(n_genes^2 * n_cells)) let col_sums : Array[Double] = Array::make(n_cells, 0.0) let mut i = 0 @@ -60,7 +60,7 @@ pub fn normalize_total(obj : SeuratObject) -> SeuratObject { } i = i + 1 } - + let data : Array[Array[Double]] = Array::new() i = 0 while i < n_genes { @@ -84,24 +84,21 @@ pub fn normalize_total(obj : SeuratObject) -> SeuratObject { data.push(gene_data) i = i + 1 } - - SeuratObject::{ - ..obj, - data, - } + + SeuratObject::{ ..obj, data, } } ///| pub fn find_variable_features(obj : SeuratObject) -> SeuratObject { let n_genes = obj.row_names.length() let n_cells = obj.col_names.length() - + let gene_indices : Array[(Double, Int)] = Array::new() let mut k = 0 while k < n_genes { let row_data = obj.data[k] let (mean_val, var_val) = stat_mean_var(row_data) - + let vst_score = if mean_val > 0.0 && var_val > 0.0 { let expected_var = mean_val + mean_val * mean_val * 0.5 @math.ln(var_val / expected_var) @@ -111,9 +108,9 @@ pub fn find_variable_features(obj : SeuratObject) -> SeuratObject { gene_indices.push((vst_score, k)) k = k + 1 } - + let sorted_indices = stat_sort_indices_desc(gene_indices) - + let var_features : Array[String] = Array::new() let nfeatures = if n_genes < 2000 { n_genes } else { 2000 } let mut n_selected = 0 @@ -121,25 +118,22 @@ pub fn find_variable_features(obj : SeuratObject) -> SeuratObject { var_features.push(obj.row_names[sorted_indices[n_selected].1]) n_selected = n_selected + 1 } - - SeuratObject::{ - ..obj, - var_features, - } + + SeuratObject::{ ..obj, var_features, } } ///| pub fn scale_data(obj : SeuratObject) -> SeuratObject { let n_genes = obj.row_names.length() let n_cells = obj.col_names.length() - + let scaled_data : Array[Array[Double]] = Array::new() let mut i = 0 while i < n_genes { let row_data = obj.data[i] let (mean_val, var_val) = stat_mean_var(row_data) let std_val = if var_val > 0.0 { var_val.sqrt() } else { 1.0 } - + let gene_scaled : Array[Double] = Array::new() let mut j = 0 while j < n_cells { @@ -149,24 +143,21 @@ pub fn scale_data(obj : SeuratObject) -> SeuratObject { scaled_data.push(gene_scaled) i = i + 1 } - - SeuratObject::{ - ..obj, - scaled_data, - } + + SeuratObject::{ ..obj, scaled_data, } } ///| pub fn run_pca(obj : SeuratObject) -> SeuratObject { let n_genes = obj.row_names.length() let n_cells = obj.col_names.length() - + let use_features = if obj.var_features.length() > 0 { obj.var_features } else { obj.row_names } - + let feature_indices : Array[Int] = Array::new() for feature in use_features { let mut idx = 0 @@ -178,19 +169,25 @@ pub fn run_pca(obj : SeuratObject) -> SeuratObject { idx = idx + 1 } } - + let n_features = feature_indices.length() let npcs = if n_features < 50 { n_features } else { 50 } - - let pca = compute_pca_simple(obj.scaled_data, feature_indices, n_features, n_cells, npcs) - + + let pca = compute_pca_simple( + obj.scaled_data, + feature_indices, + n_features, + n_cells, + npcs, + ) + let var_explained : Array[Double] = Array::new() let mut m = 0 while m < npcs { var_explained.push((1.0 - m.to_double() / npcs.to_double()) * 0.3) m = m + 1 } - + let pca_loadings : Array[Array[Double]] = Array::new() let mut n = 0 while n < n_features { @@ -203,15 +200,11 @@ pub fn run_pca(obj : SeuratObject) -> SeuratObject { pca_loadings.push(loading) n = n + 1 } - - SeuratObject::{ - ..obj, - pca, - pca_loadings, - var_explained, - } + + SeuratObject::{ ..obj, pca, pca_loadings, var_explained } } +///| fn compute_pca_simple( scaled_data : Array[Array[Double]], feature_indices : Array[Int], @@ -220,11 +213,11 @@ fn compute_pca_simple( npcs : Int, ) -> Array[Array[Double]] { let pca : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_cells { let pc : Array[Double] = Array::new() - + let mut j = 0 while j < npcs && j < n_features { let mut score = 0.0 @@ -237,17 +230,17 @@ fn compute_pca_simple( pc.push(score) j = j + 1 } - + let mut pad = j while pad < npcs { pc.push(0.0) pad = pad + 1 } - + pca.push(pc) i = i + 1 } - + pca } @@ -258,15 +251,13 @@ pub fn find_neighbors(obj : SeuratObject) -> SeuratObject { return obj } let n_dims = obj.pca[0].length() - + let neighbors = find_neighbors_helper(obj.pca, n_cells, n_dims, 20) - - SeuratObject::{ - ..obj, - neighbors, - } + + SeuratObject::{ ..obj, neighbors, } } +///| fn find_neighbors_helper( pca : Array[Array[Double]], n_cells : Int, @@ -292,6 +283,7 @@ fn find_neighbors_helper( neighbors } +///| fn sort_distances(arr : Array[(Double, Int)]) -> Array[(Double, Int)] { stat_sort_indices_desc(arr) } @@ -299,11 +291,11 @@ fn sort_distances(arr : Array[(Double, Int)]) -> Array[(Double, Int)] { ///| pub fn find_clusters(obj : SeuratObject) -> SeuratObject { let n_cells = obj.col_names.length() - + if obj.clusters.length() > 0 && obj.clusters[0] != -1 { return obj } - + let clusters : Array[Int] = Array::new() let n_clusters = 4 let mut i = 0 @@ -311,11 +303,8 @@ pub fn find_clusters(obj : SeuratObject) -> SeuratObject { clusters.push(i / (n_cells / n_clusters)) i = i + 1 } - - SeuratObject::{ - ..obj, - clusters, - } + + SeuratObject::{ ..obj, clusters, } } ///| @@ -325,15 +314,13 @@ pub fn run_umap(obj : SeuratObject) -> SeuratObject { return obj } let n_components = 2 - + let umap = init_umap_coords(n_cells, n_components) - - SeuratObject::{ - ..obj, - umap, - } + + SeuratObject::{ ..obj, umap, } } +///| fn init_umap_coords(n_cells : Int, n_components : Int) -> Array[Array[Double]] { let coords : Array[Array[Double]] = Array::new() let mut seed = 42 @@ -367,7 +354,11 @@ pub struct IntegrationAnchor { } ///| -pub fn IntegrationAnchor::new(cell1 : Int, cell2 : Int, score : Double) -> IntegrationAnchor { +pub fn IntegrationAnchor::new( + cell1 : Int, + cell2 : Int, + score : Double, +) -> IntegrationAnchor { IntegrationAnchor::{ cell1, cell2, score } } @@ -395,29 +386,34 @@ pub fn find_integration_anchors( ) -> IntegrationAnchors { let n_ref_cells = reference_obj.col_names.length() let n_query_cells = query_obj.col_names.length() - + let anchors : Array[IntegrationAnchor] = Array::new() let reference_indices : Array[Int] = Array::new() let query_indices : Array[Int] = Array::new() - + if reference_obj.pca.length() == 0 || query_obj.pca.length() == 0 { return IntegrationAnchors::new(anchors, reference_indices, query_indices) } - - let n_anchors = if n_ref_cells < n_query_cells { n_ref_cells / 10 } else { n_query_cells / 10 } - + + let n_anchors = if n_ref_cells < n_query_cells { + n_ref_cells / 10 + } else { + n_query_cells / 10 + } + let mut i = 0 while i < n_anchors && i < n_ref_cells && i < n_query_cells { let ref_idx = i let query_idx = i - + let mut dist = 0.0 let mut dim_count = 0 - + let mut j = 0 while j < dims.length() { let d = dims[j] - if ref_idx < reference_obj.pca.length() && query_idx < query_obj.pca.length() { + if ref_idx < reference_obj.pca.length() && + query_idx < query_obj.pca.length() { let ref_pca = reference_obj.pca[ref_idx] let query_pca = query_obj.pca[query_idx] if d < ref_pca.length() && d < query_pca.length() { @@ -428,16 +424,20 @@ pub fn find_integration_anchors( } j = j + 1 } - - let score = if dist > 0.0 && dim_count > 0 { 1.0 / dist.sqrt() } else { 1.0 } - + + let score = if dist > 0.0 && dim_count > 0 { + 1.0 / dist.sqrt() + } else { + 1.0 + } + anchors.push(IntegrationAnchor::new(ref_idx, query_idx, score)) reference_indices.push(ref_idx) query_indices.push(query_idx) - + i = i + 1 } - + IntegrationAnchors::new(anchors, reference_indices, query_indices) } @@ -449,7 +449,7 @@ pub fn integrate_data( ) -> SeuratObject { let n_ref_genes = reference_obj.row_names.length() let n_query_genes = query_obj.row_names.length() - + let common_genes : Array[String] = Array::new() for gene in reference_obj.row_names { let mut found = false @@ -465,32 +465,32 @@ pub fn integrate_data( common_genes.push(gene) } } - + let n_common = common_genes.length() let n_ref_cells = reference_obj.col_names.length() let n_query_cells = query_obj.col_names.length() let n_total_cells = n_ref_cells + n_query_cells - + let integrated_counts : Array[Array[Int]] = Array::new() let row_names : Array[String] = Array::new() let col_names : Array[String] = Array::new() - + let mut i = 0 while i < n_common { let gene = common_genes[i] - + let mut ref_idx = 0 while ref_idx < n_ref_genes && reference_obj.row_names[ref_idx] != gene { ref_idx = ref_idx + 1 } - + let mut query_idx = 0 while query_idx < n_query_genes && query_obj.row_names[query_idx] != gene { query_idx = query_idx + 1 } - + row_names.push(gene) - + let gene_counts : Array[Int] = Array::new() let mut j = 0 while j < n_ref_cells { @@ -503,10 +503,10 @@ pub fn integrate_data( k = k + 1 } integrated_counts.push(gene_counts) - + i = i + 1 } - + let mut l = 0 while l < n_ref_cells { col_names.push("ref_" + reference_obj.col_names[l]) @@ -517,9 +517,11 @@ pub fn integrate_data( col_names.push("query_" + query_obj.col_names[m]) m = m + 1 } - - let integrated_obj = SeuratObject::new(integrated_counts, row_names, col_names) - + + let integrated_obj = SeuratObject::new( + integrated_counts, row_names, col_names, + ) + let clusters : Array[Int] = Array::new() let mut n = 0 while n < n_ref_cells { @@ -528,15 +530,16 @@ pub fn integrate_data( } let mut o = 0 while o < n_query_cells { - let offset = if query_obj.clusters.length() > 0 { query_obj.clusters[o] + 10 } else { 10 } + let offset = if query_obj.clusters.length() > 0 { + query_obj.clusters[o] + 10 + } else { + 10 + } clusters.push(offset) o = o + 1 } - - SeuratObject::{ - ..integrated_obj, - clusters, - } + + SeuratObject::{ ..integrated_obj, clusters, } } ///| @@ -558,62 +561,62 @@ pub fn MarkerResult::new( p_value : Double, adjusted_p_value : Double, ) -> MarkerResult { - MarkerResult::{ - gene, - avg_log2_fc, - pct_1, - pct_2, - p_value, - adjusted_p_value, - } + MarkerResult::{ gene, avg_log2_fc, pct_1, pct_2, p_value, adjusted_p_value } } ///| pub fn find_all_markers(obj : SeuratObject) -> Array[MarkerResult] { let markers : Array[MarkerResult] = Array::new() - + let n_clusters = 4 let mut i = 0 while i < n_clusters && i < obj.row_names.length() { - markers.push(MarkerResult::new( - obj.row_names[i * 100], - 2.0 + i.to_double() * 0.5, - 0.8 + i.to_double() * 0.05, - 0.2 + i.to_double() * 0.05, - 0.001 / (i.to_double() + 1.0), - 0.01 / (i.to_double() + 1.0), - )) + markers.push( + MarkerResult::new( + obj.row_names[i * 100], + 2.0 + i.to_double() * 0.5, + 0.8 + i.to_double() * 0.05, + 0.2 + i.to_double() * 0.05, + 0.001 / (i.to_double() + 1.0), + 0.01 / (i.to_double() + 1.0), + ), + ) i = i + 1 } - + markers } ///| -pub fn get_top_markers(markers : Array[MarkerResult], n : Int) -> Array[MarkerResult] { +pub fn get_top_markers( + markers : Array[MarkerResult], + n : Int, +) -> Array[MarkerResult] { let indexed : Array[(Double, Int)] = Array::new() let mut i = 0 while i < markers.length() { indexed.push((markers[i].adjusted_p_value, i)) i = i + 1 } - + let sorted = sort_by_p_value(indexed) - + let result : Array[MarkerResult] = Array::new() let mut j = 0 while j < n && j < sorted.length() { result.push(markers[sorted[j].1]) j = j + 1 } - + result } +///| fn sort_by_p_value(arr : Array[(Double, Int)]) -> Array[(Double, Int)] { stat_sort_indices_asc(arr) } +///| fn sort_indices_desc(arr : Array[(Double, Int)]) -> Array[(Double, Int)] { stat_sort_indices_desc(arr) } @@ -622,17 +625,18 @@ fn sort_indices_desc(arr : Array[(Double, Int)]) -> Array[(Double, Int)] { fn t_cdf(t : Double, df : Double) -> Double { let x = t / (1.0 + t * t / df).sqrt() let z = (1.0 + x) / 2.0 - + let mut sum = z let mut term = z * (1.0 - z) let mut i = 1 while i <= 50 { - let coeff = ((df - 1.0) / 2.0 + i.to_double() - 1.0) / (i.to_double() * (df / 2.0 + i.to_double() - 1.0)) + let coeff = ((df - 1.0) / 2.0 + i.to_double() - 1.0) / + (i.to_double() * (df / 2.0 + i.to_double() - 1.0)) sum = sum + coeff * term term = term * (1.0 - z) * z i = i + 1 } - + 0.5 * (1.0 + sum) } @@ -641,23 +645,27 @@ pub fn seurat_create_example_data() -> SeuratObject { let n_cells = 200 let n_genes = 500 let n_clusters = 4 - + let counts : Array[Array[Int]] = Array::new() let row_names : Array[String] = Array::new() let col_names : Array[String] = Array::new() - + let mut seed = 12345 let mut i = 0 while i < n_genes { row_names.push("gene_" + i.to_string()) let gene_counts : Array[Int] = Array::new() - + let mut j = 0 while j < n_cells { let cluster_id = j / (n_cells / n_clusters) let marker_gene_cluster = i % n_clusters - let cluster_factor = if marker_gene_cluster == cluster_id { 3.0 } else { 0.5 } - + let cluster_factor = if marker_gene_cluster == cluster_id { + 3.0 + } else { + 0.5 + } + let mut x = 0.0 let mut k = 0 while k < 12 { @@ -667,33 +675,30 @@ pub fn seurat_create_example_data() -> SeuratObject { k = k + 1 } x = x - 6.0 - + let base_count = (@math.exp(x) * cluster_factor).to_int() gene_counts.push(if base_count > 0 { base_count } else { 0 }) j = j + 1 } - + counts.push(gene_counts) i = i + 1 } - + let mut l = 0 while l < n_cells { col_names.push("cell_" + l.to_string()) l = l + 1 } - + let obj = SeuratObject::new(counts, row_names, col_names) - + let clusters : Array[Int] = Array::new() let mut m = 0 while m < n_cells { clusters.push(m / (n_cells / n_clusters)) m = m + 1 } - - SeuratObject::{ - ..obj, - clusters, - } + + SeuratObject::{ ..obj, clusters, } } diff --git a/src/sff_io.mbt b/src/sff_io.mbt index 87844cb8..6334944b 100644 --- a/src/sff_io.mbt +++ b/src/sff_io.mbt @@ -87,7 +87,12 @@ pub struct SffFile { ///| /// Create a new SFF header. -pub fn SffHeader::new(n_reads : Int, n_flows : Int, flow_chars : String, key_sequence : String) -> SffHeader { +pub fn SffHeader::new( + n_reads : Int, + n_flows : Int, + flow_chars : String, + key_sequence : String, +) -> SffHeader { let key_length = key_sequence.length() // Fixed header is 32 bytes + n_flows + key_length, padded to multiple of 8 let base_length = 32 + n_flows + key_length @@ -103,7 +108,7 @@ pub fn SffHeader::new(n_reads : Int, n_flows : Int, flow_chars : String, key_seq n_flows, flowgram_format: sff_flowgram_format_u16, flow_chars, - key_sequence + key_sequence, } } @@ -136,19 +141,37 @@ pub fn SffHeader::sff_key_sequence(self : SffHeader) -> String { pub fn SffHeader::sff_validate(self : SffHeader) -> Array[String] { let errors : Array[String] = Array::new() if self.magic != sff_magic { - errors.push("Invalid magic number: expected " + sff_magic.to_string() + ", got " + self.magic.to_string()) + errors.push( + "Invalid magic number: expected " + + sff_magic.to_string() + + ", got " + + self.magic.to_string(), + ) } if self.version != sff_version { errors.push("Unsupported version: " + self.version.to_string()) } if self.header_length % 8 != 0 { - errors.push("Header length must be a multiple of 8, got " + self.header_length.to_string()) + errors.push( + "Header length must be a multiple of 8, got " + + self.header_length.to_string(), + ) } if self.flowgram_format != sff_flowgram_format_u16 { - errors.push("Unsupported flowgram format: " + self.flowgram_format.to_string() + " (only format 1/u16 is supported)") + errors.push( + "Unsupported flowgram format: " + + self.flowgram_format.to_string() + + " (only format 1/u16 is supported)", + ) } if self.flow_chars.length() != self.n_flows { - errors.push("Flow chars length (" + self.flow_chars.length().to_string() + ") does not match n_flows (" + self.n_flows.to_string() + ")") + errors.push( + "Flow chars length (" + + self.flow_chars.length().to_string() + + ") does not match n_flows (" + + self.n_flows.to_string() + + ")", + ) } if self.key_sequence.length() != self.key_length { errors.push("Key sequence length does not match key_length") @@ -160,7 +183,17 @@ pub fn SffHeader::sff_validate(self : SffHeader) -> Array[String] { ///| /// Create a new SFF read record. -pub fn SffRead::new(name : String, bases : String, qualities : Array[Int], flowgram : Array[Double], flow_index : Array[Int], clip_qual_left : Int, clip_qual_right : Int, clip_adapter_left : Int, clip_adapter_right : Int) -> SffRead { +pub fn SffRead::new( + name : String, + bases : String, + qualities : Array[Int], + flowgram : Array[Double], + flow_index : Array[Int], + clip_qual_left : Int, + clip_qual_right : Int, + clip_adapter_left : Int, + clip_adapter_right : Int, +) -> SffRead { let name_length = name.length() let n_bases = bases.length() // read_header_length = 16 (fixed) + name_length, padded to multiple of 8 @@ -178,7 +211,7 @@ pub fn SffRead::new(name : String, bases : String, qualities : Array[Int], flowg flowgram, flow_index, bases, - qualities + qualities, } } @@ -222,7 +255,11 @@ pub fn SffRead::sff_flow_index(self : SffRead) -> Array[Int] { /// Get the clipped sequence (after applying quality clipping). pub fn SffRead::sff_clipped_bases(self : SffRead) -> String { let left = if self.clip_qual_left > 0 { self.clip_qual_left - 1 } else { 0 } - let right = if self.clip_qual_right > 0 { self.clip_qual_right } else { self.n_bases } + let right = if self.clip_qual_right > 0 { + self.clip_qual_right + } else { + self.n_bases + } if left >= right || left >= self.n_bases { return "" } @@ -234,7 +271,11 @@ pub fn SffRead::sff_clipped_bases(self : SffRead) -> String { /// Get the clipped quality scores. pub fn SffRead::sff_clipped_qualities(self : SffRead) -> Array[Int] { let left = if self.clip_qual_left > 0 { self.clip_qual_left - 1 } else { 0 } - let right = if self.clip_qual_right > 0 { self.clip_qual_right } else { self.n_bases } + let right = if self.clip_qual_right > 0 { + self.clip_qual_right + } else { + self.n_bases + } let result : Array[Int] = Array::new() if left >= right || left >= self.n_bases { return result @@ -329,24 +370,23 @@ pub fn SffFile::sff_total_bases(self : SffFile) -> Int { /// Pad a length up to the next multiple of 8. fn sff_pad_to_8(n : Int) -> Int { let rem = n % 8 - if rem == 0 { n } else { n + (8 - rem) } + if rem == 0 { + n + } else { + n + (8 - rem) + } } ///| /// Encode a 32-bit unsigned integer as 4 big-endian bytes. fn sff_encode_u32(v : Int) -> Array[Int] { - [ - (v / 16777216) % 256, - (v / 65536) % 256, - (v / 256) % 256, - v % 256 - ] + [v / 16777216 % 256, v / 65536 % 256, v / 256 % 256, v % 256] } ///| /// Encode a 16-bit unsigned integer as 2 big-endian bytes. fn sff_encode_u16(v : Int) -> Array[Int] { - [(v / 256) % 256, v % 256] + [v / 256 % 256, v % 256] } ///| @@ -361,7 +401,10 @@ fn sff_encode_u64(v : Int) -> Array[Int] { ///| /// Read a 32-bit big-endian unsigned integer from a byte array at a position. fn sff_read_u32(bytes : Array[Int], pos : Int) -> Int { - bytes[pos] * 16777216 + bytes[pos + 1] * 65536 + bytes[pos + 2] * 256 + bytes[pos + 3] + bytes[pos] * 16777216 + + bytes[pos + 1] * 65536 + + bytes[pos + 2] * 256 + + bytes[pos + 3] } ///| @@ -547,7 +590,10 @@ pub fn sff_encode(file : SffFile) -> Array[Int] { qi = qi + 1 } // Padding to multiple of 8 for read data section - let data_len = read.flowgram.length() * 2 + read.flow_index.length() + read.bases.length() + read.qualities.length() + let data_len = read.flowgram.length() * 2 + + read.flow_index.length() + + read.bases.length() + + read.qualities.length() let data_pad = sff_pad_to_8(data_len) - data_len let mut dp = 0 while dp < data_pad { @@ -597,7 +643,7 @@ pub fn sff_parse(bytes : Array[Int]) -> SffFile? { n_flows, flowgram_format, flow_chars, - key_sequence + key_sequence, } // ===== Per-read data ===== let reads : Array[SffRead] = Array::new() @@ -656,7 +702,7 @@ pub fn sff_parse(bytes : Array[Int]) -> SffFile? { flowgram, flow_index, bases, - qualities + qualities, }) // Advance to next read (with padding) let data_len = n_flows * 2 + n_bases + n_bases + n_bases @@ -696,7 +742,7 @@ pub fn sff_create_example_file() -> SffFile { 1, 10, 0, - 0 + 0, ) let read2 = SffRead::new( "READ0002", @@ -707,7 +753,7 @@ pub fn sff_create_example_file() -> SffFile { 1, 10, 0, - 0 + 0, ) SffFile::new(header, [read1, read2]) } @@ -724,7 +770,7 @@ pub fn sff_create_example_read() -> SffRead { 1, 8, 0, - 0 + 0, ) } diff --git a/src/sgseq.mbt b/src/sgseq.mbt index 572c482b..dd0b3c51 100644 --- a/src/sgseq.mbt +++ b/src/sgseq.mbt @@ -68,8 +68,8 @@ pub fn SGSeqJunction::new( chr~ : String, start~ : Int, end~ : Int, - strand~ : String = "+", - count~ : Int = 1, + strand? : String = "+", + count? : Int = 1, ) -> SGSeqJunction { SGSeqJunction::{ chr, start, end, strand, count } } @@ -115,16 +115,9 @@ pub fn SGSeqExon::new( chr~ : String, start~ : Int, end~ : Int, - strand~ : String = "+", + strand? : String = "+", ) -> SGSeqExon { - SGSeqExon::{ - chr, - start, - end, - strand, - count: 0, - is_cassette: false, - } + SGSeqExon::{ chr, start, end, strand, count: 0, is_cassette: false } } ///| @@ -157,8 +150,8 @@ pub fn SGSeqFeature::new( chr~ : String, start~ : Int, end~ : Int, - strand~ : String = "+", - count~ : Int = 0, + strand? : String = "+", + count? : Int = 0, ) -> SGSeqFeature { SGSeqFeature::{ type_, chr, start, end, strand, count } } @@ -183,7 +176,7 @@ pub fn SGSeqVariant::new( chr~ : String, start~ : Int, end~ : Int, - strand~ : String = "+", + strand? : String = "+", variant_type~ : SGSeqVariantType, ) -> SGSeqVariant { SGSeqVariant::{ @@ -207,13 +200,19 @@ pub fn SGSeqVariant::type_name(self : SGSeqVariant) -> String { ///| /// Set inclusion count. -pub fn SGSeqVariant::set_inclusion_count(self : SGSeqVariant, val : Int) -> Unit { +pub fn SGSeqVariant::set_inclusion_count( + self : SGSeqVariant, + val : Int, +) -> Unit { self.inclusion_count = val } ///| /// Set exclusion count. -pub fn SGSeqVariant::set_exclusion_count(self : SGSeqVariant, val : Int) -> Unit { +pub fn SGSeqVariant::set_exclusion_count( + self : SGSeqVariant, + val : Int, +) -> Unit { self.exclusion_count = val } @@ -244,7 +243,7 @@ pub fn SGSeqVariant::compute_psi(self : SGSeqVariant) -> Double { /// Check if variant is significant (PSI between 0.1 and 0.9). pub fn SGSeqVariant::is_significant(self : SGSeqVariant) -> Bool { let p = self.compute_psi() - p > 0.1 && p < 0.9 && (self.inclusion_count + self.exclusion_count) >= 10 + p > 0.1 && p < 0.9 && self.inclusion_count + self.exclusion_count >= 10 } // =========================================================================== @@ -289,13 +288,7 @@ pub fn sgseq_parse_junctions(text : String) -> Array[SGSeqJunction] { 1 } if count > 0 && end > start { - junctions.push(SGSeqJunction::new( - chr=chr, - start=start, - end=end, - strand=strand, - count=count, - )) + junctions.push(SGSeqJunction::new(chr~, start~, end~, strand~, count~)) } } junctions @@ -337,7 +330,8 @@ pub fn sgseq_build_splice_graph( // Remove duplicates let unique_sites = Array::new() for s in sites { - if unique_sites.length() == 0 || unique_sites[unique_sites.length() - 1] != s { + if unique_sites.length() == 0 || + unique_sites[unique_sites.length() - 1] != s { unique_sites.push(s) } } @@ -382,31 +376,37 @@ pub fn sgseq_build_splice_graph( continue } // First exon: ends at first junction's donor (start) - exons.push(SGSeqExon::new( - chr=chr_name, - start=1, - end=chr_junctions[0].start, - strand=chr_junctions[0].strand, - )) + exons.push( + SGSeqExon::new( + chr=chr_name, + start=1, + end=chr_junctions[0].start, + strand=chr_junctions[0].strand, + ), + ) // Middle exons: between j[k].end and j[k+1].start let mut k = 0 while k < chr_junctions.length() - 1 { - exons.push(SGSeqExon::new( - chr=chr_name, - start=chr_junctions[k].end, - end=chr_junctions[k + 1].start, - strand=chr_junctions[k].strand, - )) + exons.push( + SGSeqExon::new( + chr=chr_name, + start=chr_junctions[k].end, + end=chr_junctions[k + 1].start, + strand=chr_junctions[k].strand, + ), + ) k = k + 1 } // Last exon: starts at last junction's acceptor (end) let last = chr_junctions[chr_junctions.length() - 1] - exons.push(SGSeqExon::new( - chr=chr_name, - start=last.end, - end=last.end + 1000, // arbitrary end - strand=last.strand, - )) + exons.push( + SGSeqExon::new( + chr=chr_name, + start=last.end, + end=last.end + 1000, // arbitrary end + strand=last.strand, + ), + ) } exons } @@ -419,24 +419,28 @@ pub fn sgseq_to_features( ) -> Array[SGSeqFeature] { let features = Array::new() for e in exons { - features.push(SGSeqFeature::new( - type_="E", - chr=e.chr, - start=e.start, - end=e.end, - strand=e.strand, - count=e.count, - )) + features.push( + SGSeqFeature::new( + type_="E", + chr=e.chr, + start=e.start, + end=e.end, + strand=e.strand, + count=e.count, + ), + ) } for j in junctions { - features.push(SGSeqFeature::new( - type_="J", - chr=j.chr, - start=j.start, - end=j.end, - strand=j.strand, - count=j.count, - )) + features.push( + SGSeqFeature::new( + type_="J", + chr=j.chr, + start=j.start, + end=j.end, + strand=j.strand, + count=j.count, + ), + ) } features } @@ -820,12 +824,11 @@ pub fn sgseq_quantify_psi( exc = exc + j.count } } - _ => { + _ => // Simplified: use counts near variant if j.start >= variant.start && j.end <= variant.end { inc = inc + j.count } - } } } let total = inc + exc @@ -840,7 +843,7 @@ pub fn sgseq_quantify_psi( /// Filter variants by minimum read support. pub fn sgseq_filter_variants( variants : Array[SGSeqVariant], - min_reads~ : Int = 10, + min_reads? : Int = 10, ) -> Array[SGSeqVariant] { let result = Array::new() for v in variants { @@ -886,30 +889,28 @@ pub fn sgseq_sample_exons() -> Array[SGSeqExon] { /// Format a variant as a string. pub fn sgseq_variant_to_string(v : SGSeqVariant) -> String { v.type_name() + - " " + - v.chr + - ":" + - v.start.to_string() + - "-" + - v.end.to_string() + - " (" + - v.strand + - ") inc=" + - v.inclusion_count.to_string() + - " exc=" + - v.exclusion_count.to_string() + - " PSI=" + - v.psi.to_string() + - " [" + - v.details + - "]" + " " + + v.chr + + ":" + + v.start.to_string() + + "-" + + v.end.to_string() + + " (" + + v.strand + + ") inc=" + + v.inclusion_count.to_string() + + " exc=" + + v.exclusion_count.to_string() + + " PSI=" + + v.psi.to_string() + + " [" + + v.details + + "]" } ///| /// Summarize variants by type. -pub fn sgseq_summary( - variants : Array[SGSeqVariant], -) -> Map[String, Int] { +pub fn sgseq_summary(variants : Array[SGSeqVariant]) -> Map[String, Int] { let counts : Map[String, Int] = Map([], capacity=5) for v in variants { let name = v.type_name() diff --git a/src/single_r.mbt b/src/single_r.mbt index 8377ffc1..f26fbe46 100644 --- a/src/single_r.mbt +++ b/src/single_r.mbt @@ -80,7 +80,10 @@ pub struct SingleRParams { ///| /// Spearman correlation coefficient. -pub fn single_r_spearman_correlation(x : Array[Double], y : Array[Double]) -> Double { +pub fn single_r_spearman_correlation( + x : Array[Double], + y : Array[Double], +) -> Double { let n = x.length() if n < 3 { return 0.0 @@ -116,7 +119,10 @@ pub fn single_r_spearman_correlation(x : Array[Double], y : Array[Double]) -> Do ///| /// Pearson correlation coefficient (SingleR-scoped version). -pub fn single_r_pearson_correlation(x : Array[Double], y : Array[Double]) -> Double { +pub fn single_r_pearson_correlation( + x : Array[Double], + y : Array[Double], +) -> Double { let n = x.length() if n < 3 { return 0.0 @@ -169,7 +175,8 @@ pub fn single_r_rank_values(values : Array[Double]) -> Array[Double] { } // For descending sort, map to ascending ranks (smallest=1, largest=n) // Position j..k-1 in descending → ascending ranks n-j..n-(k-1) - let avg_rank = (2.0 * n.to_double() - j.to_double() - k.to_double() + 1.0) / 2.0 + let avg_rank = (2.0 * n.to_double() - j.to_double() - k.to_double() + 1.0) / + 2.0 let mut m = j while m < k { ranks[sorted[m].1] = avg_rank @@ -202,7 +209,9 @@ fn single_r_sort_array(arr : Array[(Double, Int)]) -> Array[(Double, Int)] { ///| /// Sort array of (Int, Double) tuples by the Double value (descending). -fn single_r_sort_int_double_array(arr : Array[(Int, Double)]) -> Array[(Int, Double)] { +fn single_r_sort_int_double_array( + arr : Array[(Int, Double)], +) -> Array[(Int, Double)] { let n = arr.length() let result = arr.copy() let mut i = 1 @@ -251,13 +260,7 @@ pub fn ReferenceDataset::new( for p in profiles { cell_types.push(p.cell_type) } - ReferenceDataset::{ - profiles, - cell_types, - gene_names, - n_genes, - n_profiles, - } + ReferenceDataset::{ profiles, cell_types, gene_names, n_genes, n_profiles } } ///| @@ -272,7 +275,7 @@ pub fn ReferenceDataset::from_matrix( let mut i = 0 while i < n_samples { profiles.push( - ReferenceProfile::new(cell_types[i], expression_data[i], gene_names) + ReferenceProfile::new(cell_types[i], expression_data[i], gene_names), ) i = i + 1 } @@ -311,7 +314,7 @@ pub fn SingleRParams::new() -> SingleRParams { /// Create custom SingleR parameters with specific method. pub fn SingleRParams::with_method(method : String) -> SingleRParams { let base = SingleRParams::new() - SingleRParams::{ ..base, method } + SingleRParams::{ ..base, method, } } ///| @@ -323,13 +326,7 @@ pub fn SingleRParams::with_all( min_score : Double, quantile_score : Bool, ) -> SingleRParams { - SingleRParams::{ - method, - n_top_scores, - fine_tune, - min_score, - quantile_score, - } + SingleRParams::{ method, n_top_scores, fine_tune, min_score, quantile_score } } ///| @@ -387,7 +384,10 @@ pub fn single_r_aggregate_scores_by_type( reference : ReferenceDataset, n_top : Int, ) -> Map[String, Double] { - let unique_types : Map[String, Array[Double]] = Map([], capacity=reference.n_profiles) + let unique_types : Map[String, Array[Double]] = Map( + [], + capacity=reference.n_profiles, + ) let mut i = 0 while i < reference.n_profiles { @@ -407,7 +407,11 @@ pub fn single_r_aggregate_scores_by_type( for key in keys { let vals = unique_types.get(key).unwrap_or([]) let sorted_vals = single_r_sort_desc(vals) - let n = if n_top < sorted_vals.length() { n_top } else { sorted_vals.length() } + let n = if n_top < sorted_vals.length() { + n_top + } else { + sorted_vals.length() + } let mut sum = 0.0 let mut j = 0 while j < n { @@ -441,7 +445,9 @@ fn single_r_sort_desc(arr : Array[Double]) -> Array[Double] { ///| /// Find the cell type with the highest score. -pub fn single_r_get_best_label(scores_by_type : Map[String, Double]) -> (String, Double) { +pub fn single_r_get_best_label( + scores_by_type : Map[String, Double], +) -> (String, Double) { let keys = scores_by_type.keys() let mut best_label = "" let mut best_score = -2.0 @@ -457,7 +463,9 @@ pub fn single_r_get_best_label(scores_by_type : Map[String, Double]) -> (String, ///| /// Compute delta score (difference between top and second best). -pub fn single_r_compute_delta_score(scores_by_type : Map[String, Double]) -> Double { +pub fn single_r_compute_delta_score( + scores_by_type : Map[String, Double], +) -> Double { let keys = scores_by_type.keys() let sorted_scores : Array[(String, Double)] = Array::new() for key in keys { @@ -515,11 +523,12 @@ pub fn single_r_fine_tune_annotation( let avg_score = if marker_profiles.length() > 0 { let mut sum = 0.0 for p in marker_profiles { - sum = sum + (if method == "pearson" { - single_r_pearson_correlation(cell_expression, p) - } else { - single_r_spearman_correlation(cell_expression, p) - }) + sum = sum + + (if method == "pearson" { + single_r_pearson_correlation(cell_expression, p) + } else { + single_r_spearman_correlation(cell_expression, p) + }) } sum / marker_profiles.length().to_double() } else { @@ -536,14 +545,18 @@ pub fn single_r_fine_tune_annotation( single_r_pearson_correlation(cell_expression, p) } else { single_r_spearman_correlation(cell_expression, p) - } + }, ) } // Average scores by type let agg = single_r_aggregate_scores_by_type( other_scores, - ReferenceDataset::from_matrix(other_profiles, other_types, reference.gene_names), + ReferenceDataset::from_matrix( + other_profiles, + other_types, + reference.gene_names, + ), 1, ) @@ -553,11 +566,12 @@ pub fn single_r_fine_tune_annotation( let avg_initial = if marker_profiles.length() > 0 { let mut sum = 0.0 for p in marker_profiles { - sum = sum + (if method == "pearson" { - single_r_pearson_correlation(cell_expression, p) - } else { - single_r_spearman_correlation(cell_expression, p) - }) + sum = sum + + (if method == "pearson" { + single_r_pearson_correlation(cell_expression, p) + } else { + single_r_spearman_correlation(cell_expression, p) + }) } sum / marker_profiles.length().to_double() } else { @@ -581,10 +595,18 @@ pub fn single_r_annotate_cell( params : SingleRParams, ) -> SingleRResult { // Compute correlations with all reference profiles - let raw_scores = single_r_compute_correlations(cell_expression, reference, params.method) + let raw_scores = single_r_compute_correlations( + cell_expression, + reference, + params.method, + ) // Aggregate scores by cell type - let agg_scores = single_r_aggregate_scores_by_type(raw_scores, reference, params.n_top_scores) + let agg_scores = single_r_aggregate_scores_by_type( + raw_scores, + reference, + params.n_top_scores, + ) // Get initial prediction let (best_label, best_score) = single_r_get_best_label(agg_scores) @@ -593,7 +615,11 @@ pub fn single_r_annotate_cell( // Fine-tune if enabled let (final_label, final_score) = if params.fine_tune && best_score > 0.0 { single_r_fine_tune_annotation( - cell_expression, reference, best_label, 50, params.method + cell_expression, + reference, + best_label, + 50, + params.method, ) } else { (best_label, best_score) @@ -631,7 +657,10 @@ pub fn single_r_annotate_cell( ///| /// Sort labels by their scores (descending). -fn single_r_sort_labels_by_score(labels : Array[String], scores : Array[Double]) -> Array[String] { +fn single_r_sort_labels_by_score( + labels : Array[String], + scores : Array[Double], +) -> Array[String] { let n = labels.length() let pairs : Array[(String, Double)] = Array::new() let mut i = 0 @@ -683,14 +712,24 @@ pub fn single_r_annotate_cells( let mut i = 0 while i < data.n_cells { let cell_expr = single_r_get_cell_expression(data, i) - let cell_id = if i < data.cell_names.length() { data.cell_names[i] } else { "cell_".to_string() + i.to_string() } + let cell_id = if i < data.cell_names.length() { + data.cell_names[i] + } else { + "cell_".to_string() + i.to_string() + } let result = single_r_annotate_cell(cell_expr, cell_id, reference, params) cell_ids.push(result.cell_id) labels.push(result.first_annotation_fine) scores.push(if result.scores.length() > 0 { result.scores[0] } else { 0.0 }) - delta_scores.push(if result.delta_next.length() > 0 { result.delta_next[0] } else { 0.0 }) + delta_scores.push( + if result.delta_next.length() > 0 { + result.delta_next[0] + } else { + 0.0 + }, + ) first_labels.push(result.first_labels[0]) fine_annotations.push(result.annotations_fine[0]) @@ -710,7 +749,10 @@ pub fn single_r_annotate_cells( ///| /// Extract expression profile for a single cell. -fn single_r_get_cell_expression(data : SingleRData, cell_idx : Int) -> Array[Double] { +fn single_r_get_cell_expression( + data : SingleRData, + cell_idx : Int, +) -> Array[Double] { let n_genes = data.n_genes let expr : Array[Double] = Array::new() let mut i = 0 @@ -725,16 +767,13 @@ fn single_r_get_cell_expression(data : SingleRData, cell_idx : Int) -> Array[Dou /// Create a synthetic reference dataset for testing. pub fn single_r_create_reference_data() -> ReferenceDataset { let gene_names = [ - "CD3D", "CD3E", "CD4", "CD8A", "CD14", "CD19", "CD79A", "CD79B", - "CD56", "CD94", "NCAM1", "KLRD1", "KLRB1", "KLRF1", "NKG7", - "LYZ", "S100A8", "S100A9", "FCGR3A", "CSF1R", "C1QA", "C1QB", - "C1QC", "MARCO", "FABP4", "CD68", "CD163", "MRC1", - "CD34", "CD117", "KIT", "CD133", "PROM1", "ALDH1A1", - "CD45", "PTPRC", "CD31", "PECAM1", "VWF", "ENG", "ESAM", - "ACTA2", "TAGLN", "MYH11", "COL1A1", "COL1A2", "DCN", "LUM", - "CD235A", "GYPA", "HBB", "HBA1", "HBA2", "HBM", - "MS4A1", "CD20", "CD27", "CD38", "CD138", "SDC1", "BCMA", - "TPSAB1", "TPSB2", "CPA3", "TPSD1", "MS4A2", + "CD3D", "CD3E", "CD4", "CD8A", "CD14", "CD19", "CD79A", "CD79B", "CD56", "CD94", + "NCAM1", "KLRD1", "KLRB1", "KLRF1", "NKG7", "LYZ", "S100A8", "S100A9", "FCGR3A", + "CSF1R", "C1QA", "C1QB", "C1QC", "MARCO", "FABP4", "CD68", "CD163", "MRC1", "CD34", + "CD117", "KIT", "CD133", "PROM1", "ALDH1A1", "CD45", "PTPRC", "CD31", "PECAM1", + "VWF", "ENG", "ESAM", "ACTA2", "TAGLN", "MYH11", "COL1A1", "COL1A2", "DCN", "LUM", + "CD235A", "GYPA", "HBB", "HBA1", "HBA2", "HBM", "MS4A1", "CD20", "CD27", "CD38", + "CD138", "SDC1", "BCMA", "TPSAB1", "TPSB2", "CPA3", "TPSD1", "MS4A2", ] let n_genes = gene_names.length() @@ -847,7 +886,12 @@ pub fn single_r_create_reference_data() -> ReferenceDataset { ///| /// Helper to set gene expression value in an array by gene name. -fn single_r_set_gene_expr(expr : Array[Double], gene_names : Array[String], gene : String, value : Double) -> Unit { +fn single_r_set_gene_expr( + expr : Array[Double], + gene_names : Array[String], + gene : String, + value : Double, +) -> Unit { let n = gene_names.length() let mut i = 0 while i < n { @@ -863,16 +907,13 @@ fn single_r_set_gene_expr(expr : Array[Double], gene_names : Array[String], gene /// Create a synthetic single-cell dataset for testing. pub fn single_r_create_test_data() -> SingleRData { let gene_names = [ - "CD3D", "CD3E", "CD4", "CD8A", "CD14", "CD19", "CD79A", "CD79B", - "CD56", "CD94", "NCAM1", "KLRD1", "KLRB1", "KLRF1", "NKG7", - "LYZ", "S100A8", "S100A9", "FCGR3A", "CSF1R", "C1QA", "C1QB", - "C1QC", "MARCO", "FABP4", "CD68", "CD163", "MRC1", - "CD34", "CD117", "KIT", "CD133", "PROM1", "ALDH1A1", - "CD45", "PTPRC", "CD31", "PECAM1", "VWF", "ENG", "ESAM", - "ACTA2", "TAGLN", "MYH11", "COL1A1", "COL1A2", "DCN", "LUM", - "CD235A", "GYPA", "HBB", "HBA1", "HBA2", "HBM", - "MS4A1", "CD20", "CD27", "CD38", "CD138", "SDC1", "BCMA", - "TPSAB1", "TPSB2", "CPA3", "TPSD1", "MS4A2", + "CD3D", "CD3E", "CD4", "CD8A", "CD14", "CD19", "CD79A", "CD79B", "CD56", "CD94", + "NCAM1", "KLRD1", "KLRB1", "KLRF1", "NKG7", "LYZ", "S100A8", "S100A9", "FCGR3A", + "CSF1R", "C1QA", "C1QB", "C1QC", "MARCO", "FABP4", "CD68", "CD163", "MRC1", "CD34", + "CD117", "KIT", "CD133", "PROM1", "ALDH1A1", "CD45", "PTPRC", "CD31", "PECAM1", + "VWF", "ENG", "ESAM", "ACTA2", "TAGLN", "MYH11", "COL1A1", "COL1A2", "DCN", "LUM", + "CD235A", "GYPA", "HBB", "HBA1", "HBA2", "HBM", "MS4A1", "CD20", "CD27", "CD38", + "CD138", "SDC1", "BCMA", "TPSAB1", "TPSB2", "CPA3", "TPSD1", "MS4A2", ] let n_genes = gene_names.length() @@ -888,37 +929,68 @@ pub fn single_r_create_test_data() -> SingleRData { // Simulate different cell types let cell_type = cell_j % 5 let base = if cell_type == 0 { // T cell - if gene_names[gene_i] == "CD3D" || gene_names[gene_i] == "CD3E" { 100.0 } - else if gene_names[gene_i] == "CD4" { 80.0 } - else if gene_names[gene_i] == "CD8A" { 75.0 } - else if gene_names[gene_i] == "CD45" || gene_names[gene_i] == "PTPRC" { 90.0 } - else { 1.0 } + if gene_names[gene_i] == "CD3D" || gene_names[gene_i] == "CD3E" { + 100.0 + } else if gene_names[gene_i] == "CD4" { + 80.0 + } else if gene_names[gene_i] == "CD8A" { + 75.0 + } else if gene_names[gene_i] == "CD45" || gene_names[gene_i] == "PTPRC" { + 90.0 + } else { + 1.0 + } } else if cell_type == 1 { // B cell - if gene_names[gene_i] == "CD19" { 110.0 } - else if gene_names[gene_i] == "CD79A" || gene_names[gene_i] == "CD79B" { 100.0 } - else if gene_names[gene_i] == "MS4A1" || gene_names[gene_i] == "CD20" { 95.0 } - else if gene_names[gene_i] == "CD45" || gene_names[gene_i] == "PTPRC" { 90.0 } - else { 1.0 } + if gene_names[gene_i] == "CD19" { + 110.0 + } else if gene_names[gene_i] == "CD79A" || gene_names[gene_i] == "CD79B" { + 100.0 + } else if gene_names[gene_i] == "MS4A1" || gene_names[gene_i] == "CD20" { + 95.0 + } else if gene_names[gene_i] == "CD45" || gene_names[gene_i] == "PTPRC" { + 90.0 + } else { + 1.0 + } } else if cell_type == 2 { // NK cell - if gene_names[gene_i] == "CD56" || gene_names[gene_i] == "NCAM1" { 95.0 } - else if gene_names[gene_i] == "CD94" { 85.0 } - else if gene_names[gene_i] == "NKG7" { 80.0 } - else if gene_names[gene_i] == "KLRD1" || gene_names[gene_i] == "KLRB1" { 75.0 } - else if gene_names[gene_i] == "CD45" || gene_names[gene_i] == "PTPRC" { 90.0 } - else { 1.0 } + if gene_names[gene_i] == "CD56" || gene_names[gene_i] == "NCAM1" { + 95.0 + } else if gene_names[gene_i] == "CD94" { + 85.0 + } else if gene_names[gene_i] == "NKG7" { + 80.0 + } else if gene_names[gene_i] == "KLRD1" || gene_names[gene_i] == "KLRB1" { + 75.0 + } else if gene_names[gene_i] == "CD45" || gene_names[gene_i] == "PTPRC" { + 90.0 + } else { + 1.0 + } } else if cell_type == 3 { // Monocyte - if gene_names[gene_i] == "CD14" { 105.0 } - else if gene_names[gene_i] == "LYZ" { 95.0 } - else if gene_names[gene_i] == "S100A8" || gene_names[gene_i] == "S100A9" { 90.0 } - else if gene_names[gene_i] == "FCGR3A" { 70.0 } - else if gene_names[gene_i] == "CD45" || gene_names[gene_i] == "PTPRC" { 90.0 } - else { 1.0 } - } else { // Epithelial cell - if gene_names[gene_i] == "CDH1" { 90.0 } - else if gene_names[gene_i] == "EPCAM" { 85.0 } - else if gene_names[gene_i] == "KRT18" || gene_names[gene_i] == "KRT19" { 80.0 } - else if gene_names[gene_i] == "MUC1" { 75.0 } - else { 1.0 } + if gene_names[gene_i] == "CD14" { + 105.0 + } else if gene_names[gene_i] == "LYZ" { + 95.0 + } else if gene_names[gene_i] == "S100A8" || + gene_names[gene_i] == "S100A9" { + 90.0 + } else if gene_names[gene_i] == "FCGR3A" { + 70.0 + } else if gene_names[gene_i] == "CD45" || gene_names[gene_i] == "PTPRC" { + 90.0 + } else { + 1.0 + } // Epithelial cell + } else if gene_names[gene_i] == "CDH1" { + 90.0 + } else if gene_names[gene_i] == "EPCAM" { + 85.0 + } else if gene_names[gene_i] == "KRT18" || gene_names[gene_i] == "KRT19" { + 80.0 + } else if gene_names[gene_i] == "MUC1" { + 75.0 + } else { + 1.0 } // Add some noise @@ -943,7 +1015,9 @@ pub fn single_r_create_test_data() -> SingleRData { ///| /// Get summary statistics from annotation results. -pub fn single_r_annotation_summary(result : SingleRFullResult) -> Map[String, Double] { +pub fn single_r_annotation_summary( + result : SingleRFullResult, +) -> Map[String, Double] { let n_cells = result.cell_ids.length() let label_counts : Map[String, Int] = Map([], capacity=10) @@ -958,7 +1032,10 @@ pub fn single_r_annotation_summary(result : SingleRFullResult) -> Map[String, Do i = i + 1 } - let summary : Map[String, Double] = Map([], capacity=label_counts.length() + 2) + let summary : Map[String, Double] = Map( + [], + capacity=label_counts.length() + 2, + ) let keys = label_counts.keys() for key in keys { let count = label_counts.get(key).unwrap_or(0) @@ -976,4 +1053,4 @@ pub fn single_r_annotation_summary(result : SingleRFullResult) -> Map[String, Do summary.set("n_cells", n_cells.to_double()) summary -} \ No newline at end of file +} diff --git a/src/singscore.mbt b/src/singscore.mbt index 4cf6267f..ca5d85f2 100644 --- a/src/singscore.mbt +++ b/src/singscore.mbt @@ -19,13 +19,17 @@ pub fn SampleExpression::get_sample_id(self : SampleExpression) -> String { ///| /// Get gene names. -pub fn SampleExpression::get_gene_names(self : SampleExpression) -> Array[String] { +pub fn SampleExpression::get_gene_names( + self : SampleExpression, +) -> Array[String] { self.gene_names } ///| /// Get expression values. -pub fn SampleExpression::get_expression(self : SampleExpression) -> Array[Double] { +pub fn SampleExpression::get_expression( + self : SampleExpression, +) -> Array[Double] { self.expression } @@ -144,12 +148,24 @@ pub fn singscore_score( spec : GeneSetSpec, sample_id : String, ) -> SingscoreResult { - let (up_score, up_disp, n_up) = singscore_directional(sample, spec.up_genes, true) - let (down_score, down_disp, n_down) = singscore_directional(sample, spec.down_genes, false) - + let (up_score, up_disp, n_up) = singscore_directional( + sample, + spec.up_genes, + true, + ) + let (down_score, down_disp, n_down) = singscore_directional( + sample, + spec.down_genes, + false, + ) + let n_dir = (if n_up > 0 { 1 } else { 0 }) + (if n_down > 0 { 1 } else { 0 }) - let total = if n_dir > 0 { (up_score + down_score) / n_dir.to_double() } else { 0.0 } - + let total = if n_dir > 0 { + (up_score + down_score) / n_dir.to_double() + } else { + 0.0 + } + SingscoreResult::{ sample_id, score: total, @@ -185,12 +201,12 @@ fn singscore_directional( if genes.length() == 0 { return (0.0, 0.0, 0) } - + let n_genes = sample.gene_names.length() if n_genes == 0 { return (0.0, 0.0, 0) } - + // Build rank array (centered around 0) let ranks : Array[Double] = Array::make(n_genes, 0.0) // Create index array and sort by expression @@ -202,10 +218,10 @@ fn singscore_directional( i = i + 1 } } - + // Simple insertion sort for ranking (handles ties by averaging) let sorted_indices = singscore_sort_indices(sample.expression) - + // Assign ranks (1-based, then center) { let mut i = 0 @@ -214,7 +230,7 @@ fn singscore_directional( i = i + 1 } } - + // Center ranks around 0 let n = n_genes.to_double() { @@ -224,7 +240,7 @@ fn singscore_directional( i = i + 1 } } - + // Build gene name -> index map let gene_idx : Map[String, Int] = Map([], capacity=n_genes) { @@ -234,7 +250,7 @@ fn singscore_directional( i = i + 1 } } - + // Sum ranks for specified genes let mut sum = 0.0 let mut n_found = 0 @@ -251,20 +267,16 @@ fn singscore_directional( } i = i + 1 } - + if n_found == 0 { return (0.0, 0.0, 0) } - + // Normalize to [-0.5, 0.5] using (n-1) bound let nf = n_found.to_double() let nf1 = (n_found - 1).to_double() - let score = if nf1 > 0.0 { - sum / nf1 - } else { - sum / nf - } - + let score = if nf1 > 0.0 { sum / nf1 } else { sum / nf } + // Clip to [-0.5, 0.5] let clamped = if score > 0.5 { 0.5 @@ -273,10 +285,10 @@ fn singscore_directional( } else { score } - + // Compute dispersion (variance of ranks for found genes) let dispersion = singscore_compute_dispersion(sample, genes, is_up, gene_idx) - + (clamped, dispersion, n_found) } @@ -294,19 +306,20 @@ fn singscore_compute_dispersion( let gene = genes[i] match gene_idx.get(gene) { Some(idx) => { - let rank = (idx + 1).to_double() - (sample.gene_names.length().to_double() + 1.0) / 2.0 + let rank = (idx + 1).to_double() - + (sample.gene_names.length().to_double() + 1.0) / 2.0 ranks_found.push(if is_up { rank } else { -rank }) } None => () } i = i + 1 } - + let n = ranks_found.length() if n <= 1 { return 0.0 } - + let (mean, var) = stat_mean_var(ranks_found) let _ = mean var @@ -324,12 +337,13 @@ fn singscore_sort_indices(values : Array[Double]) -> Array[Int] { i = i + 1 } } - + // Quicksort singscore_quicksort(values, indices, 0, n - 1) indices } +///| fn singscore_quicksort( values : Array[Double], indices : Array[Int], @@ -352,7 +366,7 @@ fn singscore_quicksort( let tmp = indices[i + 1] indices[i + 1] = indices[hi] indices[hi] = tmp - + let p = i + 1 singscore_quicksort(values, indices, lo, p - 1) singscore_quicksort(values, indices, p + 1, hi) @@ -363,23 +377,21 @@ fn singscore_quicksort( /// Create example data for singscore testing. pub fn singscore_create_example() -> (SampleExpression, GeneSetSpec) { let genes = [ - "TP53", "BRCA1", "BRCA2", "EGFR", "MYC", "KRAS", - "PTEN", "AKT1", "MTOR", "JAK2", "STAT3", "NFKB1", - "CDK4", "CDK6", "RB1", "E2F1", "APC", "CTNNB1", - "SMAD4", "TGFBR1", + "TP53", "BRCA1", "BRCA2", "EGFR", "MYC", "KRAS", "PTEN", "AKT1", "MTOR", "JAK2", + "STAT3", "NFKB1", "CDK4", "CDK6", "RB1", "E2F1", "APC", "CTNNB1", "SMAD4", "TGFBR1", ] let expression = [ - 10.0, 8.5, 6.2, 15.0, 20.0, 5.0, - 3.2, 12.0, 18.0, 7.0, 9.5, 11.0, - 14.0, 13.0, 4.0, 16.0, 2.0, 1.5, - 2.5, 3.0, + 10.0, 8.5, 6.2, 15.0, 20.0, 5.0, 3.2, 12.0, 18.0, 7.0, 9.5, 11.0, 14.0, 13.0, + 4.0, 16.0, 2.0, 1.5, 2.5, 3.0, ] - + let sample = SampleExpression::new("sample_1", genes, expression) - - let up_genes = ["TP53", "BRCA1", "BRCA2", "EGFR", "MYC", "KRAS", "AKT1", "MTOR"] + + let up_genes = [ + "TP53", "BRCA1", "BRCA2", "EGFR", "MYC", "KRAS", "AKT1", "MTOR", + ] let down_genes = ["PTEN", "RB1", "APC", "CTNNB1"] - - let spec = GeneSetSpec::new("cell_cycle", up_genes, down_genes=down_genes) + + let spec = GeneSetSpec::new("cell_cycle", up_genes, down_genes~) (sample, spec) } diff --git a/src/slingshot.mbt b/src/slingshot.mbt index e2ed81da..45de3f9e 100644 --- a/src/slingshot.mbt +++ b/src/slingshot.mbt @@ -3,6 +3,7 @@ /// Provides single-cell lineage trajectory inference using minimum /// spanning trees and principal curves for pseudotime ordering. +///| /// Distance metric for cell comparisons pub enum SlingshotDistMetric { /// Euclidean distance @@ -13,6 +14,7 @@ pub enum SlingshotDistMetric { Cosine } +///| /// A node in the lineage tree (represents a cluster or cell) pub struct SlingshotNode { /// Node ID @@ -29,6 +31,7 @@ pub struct SlingshotNode { start : Bool } +///| /// An edge in the lineage tree pub struct SlingshotEdge { /// Source node ID @@ -39,6 +42,7 @@ pub struct SlingshotEdge { weight : Double } +///| /// A lineage curve (principal curve for a branch) pub struct SlingshotCurve { /// Curve ID @@ -55,6 +59,7 @@ pub struct SlingshotCurve { cell_indices : Array[Int] } +///| /// Complete slingshot result pub struct SlingshotResult { /// All nodes @@ -71,6 +76,7 @@ pub struct SlingshotResult { cell_branch : Array[String] } +///| /// Parameters for slingshot analysis pub struct SlingshotParams { /// Number of principal components @@ -83,49 +89,79 @@ pub struct SlingshotParams { shrink : Double } +///| /// Create default parameters pub fn SlingshotParams::new() -> SlingshotParams { SlingshotParams::{ n_pcs: 2, min_cluster_size: 10, allow_reversals: false, - shrink: 1.0 + shrink: 1.0, } } // ===== Node methods ===== +///| /// Create a new node -pub fn SlingshotNode::new(id : String, cluster : String, coords : Array[Double], size : Int) -> SlingshotNode { - SlingshotNode::{ - id, - cluster, - coords, - size, - terminal: false, - start: false - } +pub fn SlingshotNode::new( + id : String, + cluster : String, + coords : Array[Double], + size : Int, +) -> SlingshotNode { + SlingshotNode::{ id, cluster, coords, size, terminal: false, start: false } } +///| /// Set terminal flag -pub fn SlingshotNode::sling_set_terminal(self : SlingshotNode, terminal : Bool) -> SlingshotNode { - SlingshotNode::{ id: self.id, cluster: self.cluster, coords: self.coords, size: self.size, terminal, start: self.start } +pub fn SlingshotNode::sling_set_terminal( + self : SlingshotNode, + terminal : Bool, +) -> SlingshotNode { + SlingshotNode::{ + id: self.id, + cluster: self.cluster, + coords: self.coords, + size: self.size, + terminal, + start: self.start, + } } +///| /// Set start flag -pub fn SlingshotNode::sling_set_start(self : SlingshotNode, start : Bool) -> SlingshotNode { - SlingshotNode::{ id: self.id, cluster: self.cluster, coords: self.coords, size: self.size, terminal: false, start } +pub fn SlingshotNode::sling_set_start( + self : SlingshotNode, + start : Bool, +) -> SlingshotNode { + SlingshotNode::{ + id: self.id, + cluster: self.cluster, + coords: self.coords, + size: self.size, + terminal: false, + start, + } } +///| /// Get node coordinate at dimension pub fn SlingshotNode::sling_coord(self : SlingshotNode, dim : Int) -> Double { self.coords[dim] } +///| /// Compute distance between two nodes -pub fn SlingshotNode::sling_distance(self : SlingshotNode, other : SlingshotNode, metric : SlingshotDistMetric) -> Double { +pub fn SlingshotNode::sling_distance( + self : SlingshotNode, + other : SlingshotNode, + metric : SlingshotDistMetric, +) -> Double { let d = self.coords.length() - if d == 0 { return 0.0 } + if d == 0 { + return 0.0 + } match metric { SlingshotDistMetric::Euclidean => { let mut sum = 0.0 @@ -167,23 +203,31 @@ pub fn SlingshotNode::sling_distance(self : SlingshotNode, other : SlingshotNode // ===== Edge methods ===== +///| /// Create a new edge -pub fn SlingshotEdge::new(from_id : String, to_id : String, weight : Double) -> SlingshotEdge { +pub fn SlingshotEdge::new( + from_id : String, + to_id : String, + weight : Double, +) -> SlingshotEdge { SlingshotEdge::{ from_id, to_id, weight } } // ===== Metric helpers ===== +///| /// Get Euclidean distance metric pub fn sling_euclidean_metric() -> SlingshotDistMetric { SlingshotDistMetric::Euclidean } +///| /// Get Manhattan distance metric pub fn sling_manhattan_metric() -> SlingshotDistMetric { SlingshotDistMetric::Manhattan } +///| /// Get Cosine distance metric pub fn sling_cosine_metric() -> SlingshotDistMetric { SlingshotDistMetric::Cosine @@ -193,7 +237,10 @@ pub fn sling_cosine_metric() -> SlingshotDistMetric { ///| /// Build a distance matrix between all nodes. -pub fn sling_distance_matrix(nodes : Array[SlingshotNode], metric : SlingshotDistMetric) -> Array[Array[Double]] { +pub fn sling_distance_matrix( + nodes : Array[SlingshotNode], + metric : SlingshotDistMetric, +) -> Array[Array[Double]] { let n = nodes.length() let mat : Array[Array[Double]] = Array::new() let mut i = 0 @@ -216,9 +263,14 @@ pub fn sling_distance_matrix(nodes : Array[SlingshotNode], metric : SlingshotDis ///| /// Build a minimum spanning tree using Prim's algorithm. -pub fn sling_build_mst(nodes : Array[SlingshotNode], metric : SlingshotDistMetric) -> Array[SlingshotEdge] { +pub fn sling_build_mst( + nodes : Array[SlingshotNode], + metric : SlingshotDistMetric, +) -> Array[SlingshotEdge] { let n = nodes.length() - if n <= 1 { return Array::new() } + if n <= 1 { + return Array::new() + } let dist_mat = sling_distance_matrix(nodes, metric) let in_tree : Array[Bool] = Array::new() let min_edge : Array[Double] = Array::new() @@ -257,20 +309,29 @@ pub fn sling_build_mst(nodes : Array[SlingshotNode], metric : SlingshotDistMetri } m = m + 1 } - if min_idx < 0 { break } + if min_idx < 0 { + break + } in_tree[min_idx] = true - edges.push(SlingshotEdge::new( - nodes[min_from[min_idx]].id, - nodes[min_idx].id, - min_val - )) + edges.push( + SlingshotEdge::new( + nodes[min_from[min_idx]].id, + nodes[min_idx].id, + min_val, + ), + ) k = k + 1 } edges } +///| /// Find the most recently added node in the MST -fn sling_find_recently_added(in_tree : Array[Bool], min_edge : Array[Double], n : Int) -> Int { +fn sling_find_recently_added( + in_tree : Array[Bool], + min_edge : Array[Double], + n : Int, +) -> Int { // Find the node with the smallest min_edge that's in the tree let mut min_val = 1.0e30 let mut min_idx = 0 @@ -287,7 +348,10 @@ fn sling_find_recently_added(in_tree : Array[Bool], min_edge : Array[Double], n ///| /// Identify terminal nodes (leaf nodes in the MST). -pub fn sling_find_terminals(edges : Array[SlingshotEdge], nodes : Array[SlingshotNode]) -> Array[String] { +pub fn sling_find_terminals( + edges : Array[SlingshotEdge], + nodes : Array[SlingshotNode], +) -> Array[String] { let n = nodes.length() let degree : Array[Int] = Array::new() let mut i = 0 @@ -324,11 +388,14 @@ pub fn sling_find_terminals(edges : Array[SlingshotEdge], nodes : Array[Slingsho terminals } +///| /// Find node index by ID fn sling_find_node_idx(ids : Array[String], id : String) -> Int { let mut i = 0 while i < ids.length() { - if ids[i] == id { return i } + if ids[i] == id { + return i + } i = i + 1 } -1 @@ -340,14 +407,23 @@ fn sling_find_node_idx(ids : Array[String], id : String) -> Int { /// Fit a principal curve through a set of 2D points. /// Uses the simple iterative approach: project points onto the curve, /// update curve as running mean. -pub fn sling_fit_principal_curve(points : Array[Array[Double]], n_segments : Int) -> Array[Array[Double]] { +pub fn sling_fit_principal_curve( + points : Array[Array[Double]], + n_segments : Int, +) -> Array[Array[Double]] { let n_points = points.length() - if n_points == 0 { return Array::new() } + if n_points == 0 { + return Array::new() + } let dim = points[0].length() // Initialize curve segments along the first principal component let (pc1_min, pc1_max) = sling_pc1_range(points) let curve : Array[Array[Double]] = Array::new() - let seg_step = if n_segments > 1 { (pc1_max - pc1_min) / (n_segments - 1).to_double() } else { 0.0 } + let seg_step = if n_segments > 1 { + (pc1_max - pc1_min) / (n_segments - 1).to_double() + } else { + 0.0 + } let mut i = 0 while i < n_segments { let t = pc1_min + seg_step * i.to_double() @@ -360,7 +436,9 @@ pub fn sling_fit_principal_curve(points : Array[Array[Double]], n_segments : Int let mut iter = 0 while iter < max_iter { let (new_curve, changed) = sling_refine_curve(points, curve) - if !changed { break } + if !changed { + break + } iter = iter + 1 } curve @@ -370,7 +448,9 @@ pub fn sling_fit_principal_curve(points : Array[Array[Double]], n_segments : Int /// Get range of first principal component. fn sling_pc1_range(points : Array[Array[Double]]) -> (Double, Double) { let n = points.length() - if n == 0 { return (0.0, 0.0) } + if n == 0 { + return (0.0, 0.0) + } let dim = points[0].length() // Simple PCA: center data, find direction of maximum variance let center : Array[Double] = Array::new() @@ -414,8 +494,12 @@ fn sling_pc1_range(points : Array[Array[Double]]) -> (Double, Double) { let mut max_val = points[0][max_dim] let mut j = 1 while j < n { - if points[j][max_dim] < min_val { min_val = points[j][max_dim] } - if points[j][max_dim] > max_val { max_val = points[j][max_dim] } + if points[j][max_dim] < min_val { + min_val = points[j][max_dim] + } + if points[j][max_dim] > max_val { + max_val = points[j][max_dim] + } j = j + 1 } (min_val, max_val) @@ -423,7 +507,12 @@ fn sling_pc1_range(points : Array[Array[Double]]) -> (Double, Double) { ///| /// Get point on PC1 line at parameter t. -fn sling_point_on_pc1(points : Array[Array[Double]], t : Double, min_val : Double, max_val : Double) -> Array[Double] { +fn sling_point_on_pc1( + points : Array[Array[Double]], + t : Double, + min_val : Double, + max_val : Double, +) -> Array[Double] { let n = points.length() let dim = points[0].length() let pt : Array[Double] = Array::new() @@ -447,10 +536,15 @@ fn sling_point_on_pc1(points : Array[Array[Double]], t : Double, min_val : Doubl ///| /// Refine principal curve by projecting points and averaging. -fn sling_refine_curve(points : Array[Array[Double]], curve : Array[Array[Double]]) -> (Array[Array[Double]], Bool) { +fn sling_refine_curve( + points : Array[Array[Double]], + curve : Array[Array[Double]], +) -> (Array[Array[Double]], Bool) { let n_curve = curve.length() let n_points = points.length() - if n_curve < 2 || n_points == 0 { return (curve, false) } + if n_curve < 2 || n_points == 0 { + return (curve, false) + } let dim = curve[0].length() let new_curve : Array[Array[Double]] = Array::new() let mut changed = false @@ -468,7 +562,11 @@ fn sling_refine_curve(points : Array[Array[Double]], curve : Array[Array[Double] let mut count = 0.0 let mut pi = 0 while pi < n_points { - let proj = sling_project_to_segment(points[pi], curve[start_seg], curve[end_seg]) + let proj = sling_project_to_segment( + points[pi], + curve[start_seg], + curve[end_seg], + ) let dist2 = 0.0 let mut dd = 0 while dd < dim { @@ -499,7 +597,9 @@ fn sling_refine_curve(points : Array[Array[Double]], curve : Array[Array[Double] diff_sum = diff_sum + (new_pt[k] - curve[ci][k]).abs() k = k + 1 } - if diff_sum > 1.0e-6 { changed = true } + if diff_sum > 1.0e-6 { + changed = true + } new_curve.push(new_pt) } else { new_curve.push(curve[ci]) @@ -511,7 +611,11 @@ fn sling_refine_curve(points : Array[Array[Double]], curve : Array[Array[Double] ///| /// Project a point onto a line segment. -fn sling_project_to_segment(point : Array[Double], a : Array[Double], b : Array[Double]) -> Array[Double] { +fn sling_project_to_segment( + point : Array[Double], + a : Array[Double], + b : Array[Double], +) -> Array[Double] { let dim = point.length() let ab : Array[Double] = Array::new() let mut i = 0 @@ -532,7 +636,7 @@ fn sling_project_to_segment(point : Array[Double], a : Array[Double], b : Array[ k = k + 1 } let t = if ab2 > 0.0 { sling_dot(ap, ab) / ab2 } else { 0.0 } - let t_clamped = if t < 0.0 { 0.0 } else { if t > 1.0 { 1.0 } else { t } } + let t_clamped = if t < 0.0 { 0.0 } else if t > 1.0 { 1.0 } else { t } let proj : Array[Double] = Array::new() let mut m = 0 while m < dim { @@ -542,6 +646,7 @@ fn sling_project_to_segment(point : Array[Double], a : Array[Double], b : Array[ proj } +///| /// Dot product fn sling_dot(a : Array[Double], b : Array[Double]) -> Double { let mut sum = 0.0 @@ -559,7 +664,7 @@ fn sling_dot(a : Array[Double], b : Array[Double]) -> Double { /// Compute pseudotime for cells along a lineage curve. pub fn sling_compute_pseudotime( cell_coords : Array[Array[Double]], - curve : Array[Array[Double]] + curve : Array[Array[Double]], ) -> Array[Double] { let n_cells = cell_coords.length() let n_curve = curve.length() @@ -597,9 +702,14 @@ pub fn sling_compute_pseudotime( ///| /// Find nearest point on curve to a given point. -fn sling_nearest_on_curve(point : Array[Double], curve : Array[Array[Double]]) -> (Double, Double) { +fn sling_nearest_on_curve( + point : Array[Double], + curve : Array[Array[Double]], +) -> (Double, Double) { let n = curve.length() - if n < 2 { return (0.0, sling_euclid_dist(point, curve[0])) } + if n < 2 { + return (0.0, sling_euclid_dist(point, curve[0])) + } let mut best_dist = 1.0e30 let mut best_t = 0.0 let seg_len_total = sling_total_arc_length(curve) @@ -610,8 +720,11 @@ fn sling_nearest_on_curve(point : Array[Double], curve : Array[Array[Double]]) - let dist = sling_euclid_dist(point, proj) let seg_len = sling_euclid_dist(curve[i], curve[i + 1]) let local_t = if seg_len > 0.0 { - sling_dot(sling_sub(proj, curve[i]), sling_sub(curve[i + 1], curve[i])) / (seg_len * seg_len) - } else { 0.0 } + sling_dot(sling_sub(proj, curve[i]), sling_sub(curve[i + 1], curve[i])) / + (seg_len * seg_len) + } else { + 0.0 + } let global_t = arc_acc + local_t * seg_len if dist < best_dist { best_dist = dist @@ -623,6 +736,7 @@ fn sling_nearest_on_curve(point : Array[Double], curve : Array[Array[Double]]) - (best_t, best_dist) } +///| fn sling_total_arc_length(curve : Array[Array[Double]]) -> Double { let mut total = 0.0 let mut i = 1 @@ -633,6 +747,7 @@ fn sling_total_arc_length(curve : Array[Array[Double]]) -> Double { total } +///| fn sling_sub(a : Array[Double], b : Array[Double]) -> Array[Double] { let result : Array[Double] = Array::new() let mut i = 0 @@ -643,6 +758,7 @@ fn sling_sub(a : Array[Double], b : Array[Double]) -> Array[Double] { result } +///| fn sling_euclid_dist(a : Array[Double], b : Array[Double]) -> Double { let mut sum = 0.0 let mut i = 0 @@ -661,7 +777,7 @@ fn sling_euclid_dist(a : Array[Double], b : Array[Double]) -> Double { pub fn slingshot_run( cell_coords : Array[Array[Double]], cluster_labels : Array[String], - params : SlingshotParams + params : SlingshotParams, ) -> SlingshotResult { let n_cells = cell_coords.length() let n_clusters = sling_unique_labels(cluster_labels) @@ -676,10 +792,12 @@ pub fn slingshot_run( // Build lineages from edges let lineages = sling_build_lineages(edges, nodes, start_node, terminals) // Fit principal curves - let curves = sling_fit_lineage_curves(cell_coords, cluster_labels, nodes, lineages) + let curves = sling_fit_lineage_curves( + cell_coords, cluster_labels, nodes, lineages, + ) // Compute pseudotime let (cell_pseudotime, cell_lineage, cell_branch) = sling_assign_pseudotime( - cell_coords, cluster_labels, curves, nodes + cell_coords, cluster_labels, curves, nodes, ) SlingshotResult::{ nodes, @@ -687,10 +805,11 @@ pub fn slingshot_run( curves, cell_pseudotime, cell_lineage, - cell_branch + cell_branch, } } +///| /// Get unique cluster labels fn sling_unique_labels(labels : Array[String]) -> Array[String] { let unique : Array[String] = Array::new() @@ -705,17 +824,25 @@ fn sling_unique_labels(labels : Array[String]) -> Array[String] { unique } +///| fn sling_contains_str(arr : Array[String], s : String) -> Bool { let mut i = 0 while i < arr.length() { - if arr[i] == s { return true } + if arr[i] == s { + return true + } i = i + 1 } false } +///| /// Build nodes from cluster centers -fn sling_build_nodes(cell_coords : Array[Array[Double]], cluster_labels : Array[String], unique_labels : Array[String]) -> Array[SlingshotNode] { +fn sling_build_nodes( + cell_coords : Array[Array[Double]], + cluster_labels : Array[String], + unique_labels : Array[String], +) -> Array[SlingshotNode] { let n_clusters = unique_labels.length() let nodes : Array[SlingshotNode] = Array::new() let mut c = 0 @@ -723,21 +850,25 @@ fn sling_build_nodes(cell_coords : Array[Array[Double]], cluster_labels : Array[ let label = unique_labels[c] let center = sling_cluster_center(cell_coords, cluster_labels, label) let size = sling_cluster_size(cluster_labels, label) - nodes.push(SlingshotNode::new( - "cluster_" + c.to_string(), - label, - center, - size - )) + nodes.push( + SlingshotNode::new("cluster_" + c.to_string(), label, center, size), + ) c = c + 1 } nodes } +///| /// Compute cluster center (mean coordinates) -fn sling_cluster_center(cell_coords : Array[Array[Double]], cluster_labels : Array[String], label : String) -> Array[Double] { +fn sling_cluster_center( + cell_coords : Array[Array[Double]], + cluster_labels : Array[String], + label : String, +) -> Array[Double] { let n_cells = cell_coords.length() - if n_cells == 0 { return Array::new() } + if n_cells == 0 { + return Array::new() + } let dim = cell_coords[0].length() let center : Array[Double] = Array::new() let mut d = 0 @@ -758,19 +889,28 @@ fn sling_cluster_center(cell_coords : Array[Array[Double]], cluster_labels : Arr center } +///| /// Get cluster size fn sling_cluster_size(cluster_labels : Array[String], label : String) -> Int { let mut count = 0 let mut i = 0 while i < cluster_labels.length() { - if cluster_labels[i] == label { count = count + 1 } + if cluster_labels[i] == label { + count = count + 1 + } i = i + 1 } count } +///| /// Build lineage paths from MST edges -fn sling_build_lineages(edges : Array[SlingshotEdge], nodes : Array[SlingshotNode], start_id : String, terminals : Array[String]) -> Array[Array[String]] { +fn sling_build_lineages( + edges : Array[SlingshotEdge], + nodes : Array[SlingshotNode], + start_id : String, + terminals : Array[String], +) -> Array[Array[String]] { let lineages : Array[Array[String]] = Array::new() // For each terminal, find path from start let mut t = 0 @@ -794,8 +934,14 @@ fn sling_build_lineages(edges : Array[SlingshotEdge], nodes : Array[SlingshotNod lineages } +///| /// Find path between two nodes in MST -fn sling_find_path(edges : Array[SlingshotEdge], nodes : Array[SlingshotNode], start_id : String, end_id : String) -> Array[String] { +fn sling_find_path( + edges : Array[SlingshotEdge], + nodes : Array[SlingshotNode], + start_id : String, + end_id : String, +) -> Array[String] { // BFS let node_ids : Array[String] = Array::new() let mut i = 0 @@ -823,7 +969,9 @@ fn sling_find_path(edges : Array[SlingshotEdge], nodes : Array[SlingshotNode], s // BFS from start to end let start_idx = sling_find_node_idx(node_ids, start_id) let end_idx = sling_find_node_idx(node_ids, end_id) - if start_idx < 0 || end_idx < 0 { return Array::new() } + if start_idx < 0 || end_idx < 0 { + return Array::new() + } let visited : Array[Bool] = Array::new() let prev : Array[Int] = Array::new() let mut k = 0 @@ -838,7 +986,10 @@ fn sling_find_path(edges : Array[SlingshotEdge], nodes : Array[SlingshotNode], s let mut found = false while queue.length() > 0 && !found { let current = queue.remove(0) - if current == end_idx { found = true; break } + if current == end_idx { + found = true + break + } let mut ni = 0 while ni < adj[current].length() { let next = adj[current][ni] @@ -850,13 +1001,17 @@ fn sling_find_path(edges : Array[SlingshotEdge], nodes : Array[SlingshotNode], s ni = ni + 1 } } - if !found { return Array::new() } + if !found { + return Array::new() + } // Reconstruct path let path : Array[String] = Array::new() let mut cur = end_idx while cur >= 0 { path.push(node_ids[cur]) - if cur == start_idx { break } + if cur == start_idx { + break + } cur = prev[cur] } // Reverse @@ -869,12 +1024,13 @@ fn sling_find_path(edges : Array[SlingshotEdge], nodes : Array[SlingshotNode], s reversed } +///| /// Fit principal curves for each lineage fn sling_fit_lineage_curves( cell_coords : Array[Array[Double]], cluster_labels : Array[String], nodes : Array[SlingshotNode], - lineages : Array[Array[String]] + lineages : Array[Array[String]], ) -> Array[SlingshotCurve] { let curves : Array[SlingshotCurve] = Array::new() let n_cells = cell_coords.length() @@ -899,49 +1055,67 @@ fn sling_fit_lineage_curves( c = c + 1 } // Fit principal curve - let n_segments = if lineage.length() >= 2 { (lineage.length() * 3) } else { 6 } + let n_segments = if lineage.length() >= 2 { + lineage.length() * 3 + } else { + 6 + } let curve = sling_fit_principal_curve(lineage_coords, n_segments) // Compute pseudotime let pseudotime = sling_compute_pseudotime(lineage_coords, curve) let start_node = if lineage.length() > 0 { lineage[0] } else { "" } - let end_node = if lineage.length() > 0 { lineage[lineage.length() - 1] } else { "" } + let end_node = if lineage.length() > 0 { + lineage[lineage.length() - 1] + } else { + "" + } curves.push(SlingshotCurve::{ id: "curve_" + li.to_string(), start_node, end_node, control_points: curve, pseudotime, - cell_indices: lineage_cells + cell_indices: lineage_cells, }) li = li + 1 } curves } -fn sling_find_cluster_for_node(nodes : Array[SlingshotNode], cluster_label : String) -> Int { +///| +fn sling_find_cluster_for_node( + nodes : Array[SlingshotNode], + cluster_label : String, +) -> Int { let mut i = 0 while i < nodes.length() { - if nodes[i].cluster == cluster_label { return i } + if nodes[i].cluster == cluster_label { + return i + } i = i + 1 } -1 } +///| fn sling_lineage_contains(lineage : Array[String], node_id : String) -> Bool { let mut i = 0 while i < lineage.length() { - if lineage[i] == node_id { return true } + if lineage[i] == node_id { + return true + } i = i + 1 } false } +///| /// Assign pseudotime to all cells fn sling_assign_pseudotime( cell_coords : Array[Array[Double]], cluster_labels : Array[String], curves : Array[SlingshotCurve], - nodes : Array[SlingshotNode] + nodes : Array[SlingshotNode], ) -> (Array[Double], Array[String], Array[String]) { let n_cells = cell_coords.length() let pseudotime : Array[Double] = Array::new() @@ -951,7 +1125,10 @@ fn sling_assign_pseudotime( while i < n_cells { // Find which curve this cell belongs to let (ps, lin, br) = sling_assign_cell_to_curve( - cell_coords[i], cluster_labels[i], curves, nodes + cell_coords[i], + cluster_labels[i], + curves, + nodes, ) pseudotime.push(ps) lineages.push(lin) @@ -961,12 +1138,13 @@ fn sling_assign_pseudotime( (pseudotime, lineages, branches) } +///| /// Assign a cell to the nearest curve fn sling_assign_cell_to_curve( cell_coord : Array[Double], cluster_label : String, curves : Array[SlingshotCurve], - nodes : Array[SlingshotNode] + nodes : Array[SlingshotNode], ) -> (Double, String, String) { // Find curves containing this cell's cluster let cluster_idx = sling_find_cluster_for_node(nodes, cluster_label) @@ -998,7 +1176,12 @@ fn sling_assign_cell_to_curve( (best_ps, lineage_name, branch_name) } -fn sling_curve_contains_cluster(curve : SlingshotCurve, nodes : Array[SlingshotNode], cluster_id : String) -> Bool { +///| +fn sling_curve_contains_cluster( + curve : SlingshotCurve, + nodes : Array[SlingshotNode], + cluster_id : String, +) -> Bool { // Check if start or end node of curve matches the cluster if curve.start_node == cluster_id || curve.end_node == cluster_id { return true @@ -1008,8 +1191,12 @@ fn sling_curve_contains_cluster(curve : SlingshotCurve, nodes : Array[SlingshotN curve.cell_indices.length() > 0 } +///| /// Compute pseudotime for a cell on a given curve -fn sling_pseudotime_for_cell(cell_coord : Array[Double], curve : SlingshotCurve) -> (Double, Double) { +fn sling_pseudotime_for_cell( + cell_coord : Array[Double], + curve : SlingshotCurve, +) -> (Double, Double) { let control = curve.control_points if control.length() < 2 { return (0.0, 1.0e30) @@ -1019,8 +1206,11 @@ fn sling_pseudotime_for_cell(cell_coord : Array[Double], curve : SlingshotCurve) (t, dist) } +///| /// Get sorted pseudotime values -pub fn SlingshotResult::sling_sorted_pseudotime(self : SlingshotResult) -> Array[(Double, Int)] { +pub fn SlingshotResult::sling_sorted_pseudotime( + self : SlingshotResult, +) -> Array[(Double, Int)] { let n = self.cell_pseudotime.length() let indexed : Array[(Double, Int)] = Array::new() let mut i = 0 @@ -1046,8 +1236,12 @@ pub fn SlingshotResult::sling_sorted_pseudotime(self : SlingshotResult) -> Array sorted } +///| /// Get cells along a specific lineage -pub fn SlingshotResult::sling_cells_on_lineage(self : SlingshotResult, lineage_id : String) -> Array[Int] { +pub fn SlingshotResult::sling_cells_on_lineage( + self : SlingshotResult, + lineage_id : String, +) -> Array[Int] { let cells : Array[Int] = Array::new() let n = self.cell_lineage.length() let mut i = 0 diff --git a/src/smart.mbt b/src/smart.mbt index 899e8db6..eae3d5fa 100644 --- a/src/smart.mbt +++ b/src/smart.mbt @@ -36,7 +36,7 @@ pub fn SmartDomain::new( domain_name : String, start : Int, end : Int, - evalue? : Double = 0.0 + evalue? : Double = 0.0, ) -> SmartDomain { SmartDomain::{ domain_id, @@ -68,7 +68,7 @@ pub struct SmartResult { /// Construct a SmartResult. pub fn SmartResult::new( sequence_id : String, - sequence_length? : Int = 0 + sequence_length? : Int = 0, ) -> SmartResult { SmartResult::{ sequence_id, @@ -171,7 +171,10 @@ fn smart_parse_domain_line(cols : Array[String]) -> SmartDomain { ///| /// Find all domains matching a given domain name (substring match). -pub fn smart_find_domains(result : SmartResult, name : String) -> Array[SmartDomain] { +pub fn smart_find_domains( + result : SmartResult, + name : String, +) -> Array[SmartDomain] { let matches : Array[SmartDomain] = Array::new() let mut i = 0 while i < result.domains.length() { @@ -192,7 +195,11 @@ pub fn smart_find_domains(result : SmartResult, name : String) -> Array[SmartDom ///| /// Find all domains overlapping with a given region [start, end]. -pub fn smart_find_overlapping_domains(result : SmartResult, start : Int, end : Int) -> Array[SmartDomain] { +pub fn smart_find_overlapping_domains( + result : SmartResult, + start : Int, + end : Int, +) -> Array[SmartDomain] { let matches : Array[SmartDomain] = Array::new() let mut i = 0 while i < result.domains.length() { @@ -220,11 +227,10 @@ pub fn smart_best_domain(result : SmartResult) -> SmartDomain? { let mut i = 0 while i < result.domains.length() { match best { - Some(cur) => { + Some(cur) => if result.domains[i].evalue < cur.evalue { best = Some(result.domains[i]) } - } None => best = Some(result.domains[i]) } i = i + 1 @@ -232,11 +238,10 @@ pub fn smart_best_domain(result : SmartResult) -> SmartDomain? { let mut j = 0 while j < result.pfam_domains.length() { match best { - Some(cur) => { + Some(cur) => if result.pfam_domains[j].evalue < cur.evalue { best = Some(result.pfam_domains[j]) } - } None => best = Some(result.pfam_domains[j]) } j = j + 1 @@ -252,7 +257,10 @@ pub fn smart_total_domains(result : SmartResult) -> Int { ///| /// Filter domains by E-value threshold. -pub fn smart_filter_evalue(result : SmartResult, max_evalue : Double) -> Array[SmartDomain] { +pub fn smart_filter_evalue( + result : SmartResult, + max_evalue : Double, +) -> Array[SmartDomain] { let filtered : Array[SmartDomain] = Array::new() let mut i = 0 while i < result.domains.length() { @@ -275,9 +283,7 @@ pub fn smart_filter_evalue(result : SmartResult, max_evalue : Double) -> Array[S /// Generate a sample SMART output string for testing. pub fn smart_sample() -> String { let lines = [ - "#sequence_id\tProtein123", - "#sequence_length\t350", - "SM00001\tABC_membrane\tSMART\t10\t100\t1.5e-30\tMFWVLVVVGGVLALAVLVLAVL\tABC transporter membrane domain\tPF00001\tIPR00001\tGO:0005215;GO:0016020", + "#sequence_id\tProtein123", "#sequence_length\t350", "SM00001\tABC_membrane\tSMART\t10\t100\t1.5e-30\tMFWVLVVVGGVLALAVLVLAVL\tABC transporter membrane domain\tPF00001\tIPR00001\tGO:0005215;GO:0016020", "SM00002\tABC_subdomain\tSMART\t110\t250\t2.3e-25\tGCGKSTEQRLLLDELPGRRL\tABC transporter nucleotide binding domain\tPF00002\tIPR00002\tGO:0005524", "SM00003\tABC_membrane\tSMART\t260\t340\t5.1e-28\tVVLLVAVVGCGVALALVAVLL\tABC transporter membrane domain\tPF00001\tIPR00001\tGO:0005215;GO:0016020", "PF00001\tABC_membrane\tPfam\t10\t100\t1.5e-30\tMFWVLVVVGGVLALAVLVLAVL\tABC transporter membrane domain\tPF00001\tIPR00001\tGO:0005215;GO:0016020", @@ -305,12 +311,29 @@ pub fn smart_summary(result : SmartResult) -> String { out = out + "Length: " + result.sequence_length.to_string() + "\n" out = out + "SMART domains: " + result.domains.length().to_string() + "\n" out = out + "Pfam domains: " + result.pfam_domains.length().to_string() + "\n" - out = out + "Signal peptides: " + result.signal_peptides.length().to_string() + "\n" - out = out + "Transmembrane: " + result.transmembrane.length().to_string() + "\n" + out = out + + "Signal peptides: " + + result.signal_peptides.length().to_string() + + "\n" + out = out + + "Transmembrane: " + + result.transmembrane.length().to_string() + + "\n" let mut i = 0 while i < result.domains.length() { let d = result.domains[i] - out = out + " " + d.domain_id + "\t" + d.domain_name + "\t" + d.start.to_string() + "-" + d.end.to_string() + "\tE=" + d.evalue.to_string() + "\n" + out = out + + " " + + d.domain_id + + "\t" + + d.domain_name + + "\t" + + d.start.to_string() + + "-" + + d.end.to_string() + + "\tE=" + + d.evalue.to_string() + + "\n" i = i + 1 } out @@ -332,7 +355,9 @@ fn smart_split_lines(content : String) -> Array[String] { if start < i { lines.push(content[start:i].trim().to_string()) } - if ch == "\r" && i + 1 < content.length() && content[i + 1:i + 2].to_owned() == "\n" { + if ch == "\r" && + i + 1 < content.length() && + content[i + 1:i + 2].to_owned() == "\n" { i = i + 1 } start = i + 1 @@ -366,7 +391,9 @@ fn smart_split_tab(line : String) -> Array[String] { /// Split a string by semicolon delimiter. fn smart_split_semicolon(s : String) -> Array[String] { let items : Array[String] = Array::new() - if s.length() == 0 { return items } + if s.length() == 0 { + return items + } let mut start = 0 let mut i = 0 while i < s.length() { @@ -407,13 +434,17 @@ fn smart_extract_value(line : String) -> String { fn smart_parse_int(s : String) -> Int { let sv = s.to_string().trim() let n = sv.length() - if n == 0 { return 0 } + if n == 0 { + return 0 + } let mut result = 0 let mut i = 0 let zero = '0'.to_int() while i < n { let c = sv.unsafe_get(i).to_int() - if c < zero || c > zero + 9 { break } + if c < zero || c > zero + 9 { + break + } result = result * 10 + (c - zero) i = i + 1 } @@ -424,7 +455,9 @@ fn smart_parse_int(s : String) -> Int { /// Parse a double from a string, returning 0.0 on failure. fn smart_parse_double(s : String) -> Double { let sv = s.to_string().trim() - if sv.length() == 0 { return 0.0 } + if sv.length() == 0 { + return 0.0 + } let n = sv.length() let mut result = 0.0 let mut decimal = 0 @@ -437,7 +470,9 @@ fn smart_parse_double(s : String) -> Double { } while i < n { let c = sv.unsafe_get(i).to_int() - if c < zero || c > zero + 9 { break } + if c < zero || c > zero + 9 { + break + } result = result * 10.0 + (c - zero).to_double() i = i + 1 } @@ -445,7 +480,9 @@ fn smart_parse_double(s : String) -> Double { i = i + 1 while i < n { let c = sv.unsafe_get(i).to_int() - if c < zero || c > zero + 9 { break } + if c < zero || c > zero + 9 { + break + } result = result * 10.0 + (c - zero).to_double() decimal = decimal + 1 i = i + 1 @@ -468,7 +505,9 @@ fn smart_parse_double(s : String) -> Double { } while i < n { let c = sv.unsafe_get(i).to_int() - if c < zero || c > zero + 9 { break } + if c < zero || c > zero + 9 { + break + } exponent = exponent * 10 + (c - zero) i = i + 1 } diff --git a/src/snapgene_io.mbt b/src/snapgene_io.mbt index f1c3d942..920b81a3 100644 --- a/src/snapgene_io.mbt +++ b/src/snapgene_io.mbt @@ -99,13 +99,7 @@ pub fn SnapgenePrimer::new( bind_to~ : Int, binds_at_position~ : Int, ) -> SnapgenePrimer { - SnapgenePrimer::{ - name, - sequence, - description, - bind_to, - binds_at_position, - } + SnapgenePrimer::{ name, sequence, description, bind_to, binds_at_position } } ///| @@ -140,7 +134,10 @@ pub fn SnapgeneFile::new() -> SnapgeneFile { ///| /// Set the sequence type. -pub fn SnapgeneFile::set_seq_type(self : SnapgeneFile, t : SnapgeneSeqType) -> Unit { +pub fn SnapgeneFile::set_seq_type( + self : SnapgeneFile, + t : SnapgeneSeqType, +) -> Unit { self.seq_type = t } @@ -152,7 +149,10 @@ pub fn SnapgeneFile::set_comments(self : SnapgeneFile, s : String) -> Unit { ///| /// Set the export version. -pub fn SnapgeneFile::set_export_version(self : SnapgeneFile, s : String) -> Unit { +pub fn SnapgeneFile::set_export_version( + self : SnapgeneFile, + s : String, +) -> Unit { self.export_version = s } @@ -176,13 +176,19 @@ pub fn SnapgeneFile::set_circular(self : SnapgeneFile, b : Bool) -> Unit { ///| /// Add a feature to the file. -pub fn SnapgeneFile::add_feature(self : SnapgeneFile, f : SnapgeneFeature) -> Unit { +pub fn SnapgeneFile::add_feature( + self : SnapgeneFile, + f : SnapgeneFeature, +) -> Unit { self.features.push(f) } ///| /// Add a primer to the file. -pub fn SnapgeneFile::add_primer(self : SnapgeneFile, p : SnapgenePrimer) -> Unit { +pub fn SnapgeneFile::add_primer( + self : SnapgeneFile, + p : SnapgenePrimer, +) -> Unit { self.primers.push(p) } @@ -363,7 +369,15 @@ fn sg_build_comments( let type_str = seq_type.to_string() let circ_str = if is_circular { "true" } else { "false" } let ev = if export_version == "" { "1.0" } else { export_version } - "{\"comments\":\"" + sg_json_escape(comments) + "\",\"type\":\"" + type_str + "\",\"exportVersion\":\"" + ev + "\",\"circular\":" + circ_str + "}" + "{\"comments\":\"" + + sg_json_escape(comments) + + "\",\"type\":\"" + + type_str + + "\",\"exportVersion\":\"" + + ev + + "\",\"circular\":" + + circ_str + + "}" } ///| @@ -372,21 +386,11 @@ fn sg_json_escape(s : String) -> String { let sb = StringBuilder::new() for c in s.to_array() { match c { - '"' => { - sb.write_string("\\\"") - } - '\\' => { - sb.write_string("\\\\") - } - '\n' => { - sb.write_string("\\n") - } - '\t' => { - sb.write_string("\\t") - } - '\r' => { - sb.write_string("\\r") - } + '"' => sb.write_string("\\\"") + '\\' => sb.write_string("\\\\") + '\n' => sb.write_string("\\n") + '\t' => sb.write_string("\\t") + '\r' => sb.write_string("\\r") c => sb.write_char(c) } } @@ -463,13 +467,7 @@ fn sg_parse_one_feature(text : String) -> SnapgeneFeature? { } } Some( - SnapgeneFeature::new( - name=name, - type_=type_, - direction=direction, - segments=segs, - qualifiers=qualifiers, - ), + SnapgeneFeature::new(name~, type_~, direction~, segments=segs, qualifiers~), ) } @@ -536,15 +534,41 @@ fn sg_build_features(features : Array[SnapgeneFeature]) -> String { let sb = StringBuilder::new() sb.write_string("") for f in features { - let dir_str = if f.direction == 1 { "1" } else if f.direction == -1 { "-1" } else { "0" } - sb.write_string("") + let dir_str = if f.direction == 1 { + "1" + } else if f.direction == -1 { + "-1" + } else { + "0" + } + sb.write_string( + "", + ) for seg in f.segments { let (start, end) = seg - sb.write_string("") + sb.write_string( + "", + ) } let keys = f.qualifiers.keys() for k in keys { - sb.write_string("") + sb.write_string( + "", + ) } sb.write_string("") } @@ -625,10 +649,10 @@ fn sg_parse_primers(data : Array[Int]) -> Array[SnapgenePrimer] { offset = offset + 4 primers.push( SnapgenePrimer::new( - name=name, - sequence=sequence, - description=description, - bind_to=bind_to, + name~, + sequence~, + description~, + bind_to~, binds_at_position=binds_at, ), ) @@ -878,7 +902,7 @@ pub fn snapgene_to_seqrecord(file : SnapgeneFile) -> SeqRecord { let id = if file.comments != "" { file.comments } else { "snapgene" } let rec = SeqRecord::new( Seq::new(file.sequence), - id=id, + id~, name=id, description=file.comments, ) @@ -928,7 +952,9 @@ pub fn snapgene_summary(file : SnapgeneFile) -> String { sb.write_string(" Type: " + file.seq_type.to_string() + "\n") sb.write_string(" Circular: " + file.is_circular.to_string() + "\n") sb.write_string(" Export Version: " + file.export_version + "\n") - sb.write_string(" Sequence Length: " + snapgene_seq_length(file).to_string() + " bp\n") + sb.write_string( + " Sequence Length: " + snapgene_seq_length(file).to_string() + " bp\n", + ) sb.write_string(" Features: " + file.features.length().to_string() + "\n") sb.write_string(" Primers: " + file.primers.length().to_string() + "\n") if file.features.length() > 0 { diff --git a/src/spatial_experiment.mbt b/src/spatial_experiment.mbt index 2f530860..87b932e7 100644 --- a/src/spatial_experiment.mbt +++ b/src/spatial_experiment.mbt @@ -26,7 +26,11 @@ pub struct SpatialImage { } ///| -pub fn SpatialImage::new(id : String, data : Array[Array[Double]], scale_factor : Double) -> SpatialImage { +pub fn SpatialImage::new( + id : String, + data : Array[Array[Double]], + scale_factor : Double, +) -> SpatialImage { SpatialImage::{ id, data, scale_factor } } @@ -48,42 +52,62 @@ pub fn SpatialExperiment::new() -> SpatialExperiment { col_data: Array::new(), spatial_coords: Array::new(), images: Array::new(), - metadata: Map([], capacity=0) + metadata: Map([], capacity=0), } } ///| -pub fn se_add_assay(se : SpatialExperiment, name : String, data : Array[Array[Double]]) -> SpatialExperiment { +pub fn se_add_assay( + se : SpatialExperiment, + name : String, + data : Array[Array[Double]], +) -> SpatialExperiment { se.assay.set(name, data) se } ///| -pub fn se_add_row(se : SpatialExperiment, row : Map[String, String]) -> SpatialExperiment { +pub fn se_add_row( + se : SpatialExperiment, + row : Map[String, String], +) -> SpatialExperiment { se.row_data.push(row) se } ///| -pub fn se_add_col(se : SpatialExperiment, col : Map[String, String]) -> SpatialExperiment { +pub fn se_add_col( + se : SpatialExperiment, + col : Map[String, String], +) -> SpatialExperiment { se.col_data.push(col) se } ///| -pub fn se_add_spatial_coord(se : SpatialExperiment, coord : SpatialCoord) -> SpatialExperiment { +pub fn se_add_spatial_coord( + se : SpatialExperiment, + coord : SpatialCoord, +) -> SpatialExperiment { se.spatial_coords.push(coord) se } ///| -pub fn se_add_image(se : SpatialExperiment, image : SpatialImage) -> SpatialExperiment { +pub fn se_add_image( + se : SpatialExperiment, + image : SpatialImage, +) -> SpatialExperiment { se.images.push(image) se } ///| -pub fn se_set_metadata(se : SpatialExperiment, key : String, value : String) -> SpatialExperiment { +pub fn se_set_metadata( + se : SpatialExperiment, + key : String, + value : String, +) -> SpatialExperiment { se.metadata.set(key, value) se } @@ -104,16 +128,18 @@ pub fn se_num_assays(se : SpatialExperiment) -> Int { } ///| -pub fn se_get_spatial_range(se : SpatialExperiment) -> (Double, Double, Double, Double) { +pub fn se_get_spatial_range( + se : SpatialExperiment, +) -> (Double, Double, Double, Double) { if se.spatial_coords.length() == 0 { return (0.0, 0.0, 0.0, 0.0) } - + let mut min_x = se.spatial_coords[0].x let mut max_x = se.spatial_coords[0].x let mut min_y = se.spatial_coords[0].y let mut max_y = se.spatial_coords[0].y - + let mut i = 1 while i < se.spatial_coords.length() { let coord = se.spatial_coords[i] @@ -131,30 +157,39 @@ pub fn se_get_spatial_range(se : SpatialExperiment) -> (Double, Double, Double, } i = i + 1 } - + (min_x, max_x, min_y, max_y) } ///| -pub fn se_filter_spots_by_range(se : SpatialExperiment, min_x : Double, max_x : Double, min_y : Double, max_y : Double) -> SpatialExperiment { +pub fn se_filter_spots_by_range( + se : SpatialExperiment, + min_x : Double, + max_x : Double, + min_y : Double, + max_y : Double, +) -> SpatialExperiment { let filtered = SpatialExperiment::new() - + let mut i = 0 while i < se.row_data.length() { filtered.row_data.push(se.row_data[i]) i = i + 1 } - + let mut j = 0 while j < se.images.length() { filtered.images.push(se.images[j]) j = j + 1 } - + let mut k = 0 while k < se.spatial_coords.length() { let coord = se.spatial_coords[k] - if coord.x >= min_x && coord.x <= max_x && coord.y >= min_y && coord.y <= max_y { + if coord.x >= min_x && + coord.x <= max_x && + coord.y >= min_y && + coord.y <= max_y { filtered.spatial_coords.push(coord) if k < se.col_data.length() { filtered.col_data.push(se.col_data[k]) @@ -162,7 +197,7 @@ pub fn se_filter_spots_by_range(se : SpatialExperiment, min_x : Double, max_x : } k = k + 1 } - + filtered } @@ -171,28 +206,46 @@ pub fn create_example_spatial_experiment() -> SpatialExperiment { let se = SpatialExperiment::new() let _ = se_set_metadata(se, "platform", "Visium") let _ = se_set_metadata(se, "sample_id", "sample001") - - se.row_data.push(Map([("gene_id", "ENSG000001"), ("gene_name", "ACTB")], capacity=2)) - se.row_data.push(Map([("gene_id", "ENSG000002"), ("gene_name", "GAPDH")], capacity=2)) - se.row_data.push(Map([("gene_id", "ENSG000003"), ("gene_name", "TP53")], capacity=2)) - - se.col_data.push(Map([("spot_id", "AAACAAGTATCTCCCA"), ("tissue", "tumor")], capacity=2)) - se.col_data.push(Map([("spot_id", "AAACAGCTTTCAGAAG"), ("tissue", "tumor")], capacity=2)) - se.col_data.push(Map([("spot_id", "AAACAGGGTCTATATT"), ("tissue", "normal")], capacity=2)) - se.col_data.push(Map([("spot_id", "AAACATTTCCCGGATT"), ("tissue", "normal")], capacity=2)) - se.col_data.push(Map([("spot_id", "AAACCGGGTGTATGGC"), ("tissue", "tumor")], capacity=2)) - se.col_data.push(Map([("spot_id", "AAACCGTTCGTCCACA"), ("tissue", "normal")], capacity=2)) - + + se.row_data.push( + Map([("gene_id", "ENSG000001"), ("gene_name", "ACTB")], capacity=2), + ) + se.row_data.push( + Map([("gene_id", "ENSG000002"), ("gene_name", "GAPDH")], capacity=2), + ) + se.row_data.push( + Map([("gene_id", "ENSG000003"), ("gene_name", "TP53")], capacity=2), + ) + + se.col_data.push( + Map([("spot_id", "AAACAAGTATCTCCCA"), ("tissue", "tumor")], capacity=2), + ) + se.col_data.push( + Map([("spot_id", "AAACAGCTTTCAGAAG"), ("tissue", "tumor")], capacity=2), + ) + se.col_data.push( + Map([("spot_id", "AAACAGGGTCTATATT"), ("tissue", "normal")], capacity=2), + ) + se.col_data.push( + Map([("spot_id", "AAACATTTCCCGGATT"), ("tissue", "normal")], capacity=2), + ) + se.col_data.push( + Map([("spot_id", "AAACCGGGTGTATGGC"), ("tissue", "tumor")], capacity=2), + ) + se.col_data.push( + Map([("spot_id", "AAACCGTTCGTCCACA"), ("tissue", "normal")], capacity=2), + ) + se.spatial_coords.push(SpatialCoord::new_2d(100.0, 200.0)) se.spatial_coords.push(SpatialCoord::new_2d(150.0, 250.0)) se.spatial_coords.push(SpatialCoord::new_2d(200.0, 150.0)) se.spatial_coords.push(SpatialCoord::new_2d(250.0, 200.0)) se.spatial_coords.push(SpatialCoord::new_2d(300.0, 250.0)) se.spatial_coords.push(SpatialCoord::new_2d(350.0, 150.0)) - + let image_data : Array[Array[Double]] = Array::new() let image = SpatialImage::new("HE", image_data, 0.1) se.images.push(image) - + se -} \ No newline at end of file +} diff --git a/src/spia.mbt b/src/spia.mbt index a38edf93..64342a7a 100644 --- a/src/spia.mbt +++ b/src/spia.mbt @@ -98,13 +98,19 @@ pub fn SignalingPathway::new(id : String, name : String) -> SignalingPathway { ///| /// Add a node to the pathway. -pub fn SignalingPathway::add_node(self : SignalingPathway, node : PathwayNode) -> Unit { +pub fn SignalingPathway::add_node( + self : SignalingPathway, + node : PathwayNode, +) -> Unit { self.nodes.push(node) } ///| /// Get a node by gene ID. -pub fn SignalingPathway::get_node(self : SignalingPathway, gene_id : String) -> PathwayNode? { +pub fn SignalingPathway::get_node( + self : SignalingPathway, + gene_id : String, +) -> PathwayNode? { let mut i = 0 while i < self.nodes.length() { if self.nodes[i].gene_id == gene_id { @@ -147,10 +153,7 @@ pub fn run_spia( } // Over-representation p-value (hypergeometric test) let p_or = hypergeometric_pvalue( - n_de_in_pathway, - n_pathway_genes, - n_de, - n_total, + n_de_in_pathway, n_pathway_genes, n_de, n_total, ) // Perturbation accumulation let pert_factor = compute_perturbation(pathway, de_genes) @@ -159,7 +162,13 @@ pub fn run_spia( // Combine p-values using Fisher's method let p_combined = fisher_combine(p_or, p_pert) // Activation status - let activation_status = if pert_factor > 0.0 { 1 } else if pert_factor < 0.0 { -1 } else { 0 } + let activation_status = if pert_factor > 0.0 { + 1 + } else if pert_factor < 0.0 { + -1 + } else { + 0 + } all_results.push(SpiaResult::{ pathway_id: pathway.id, pathway_name: pathway.name, @@ -303,7 +312,13 @@ fn hypergeometric_pvalue( return 1.0 } let p = @math.exp(-chi_sq / 2.0) / (2.0 * 3.14159265358979 * chi_sq).sqrt() - if p > 1.0 { 1.0 } else if p < 0.0 { 0.0 } else { p } + if p > 1.0 { + 1.0 + } else if p < 0.0 { + 0.0 + } else { + p + } } ///| @@ -322,7 +337,13 @@ fn perturbation_pvalue(pert_factor : Double, n_de : Int) -> Double { let abs_z = if z < 0.0 { -z } else { z } // Two-sided p-value using normal CDF approximation let p = spia_erfc_approx(abs_z / 1.4142135623730951) - if p > 1.0 { 1.0 } else if p < 0.0 { 0.0 } else { p } + if p > 1.0 { + 1.0 + } else if p < 0.0 { + 0.0 + } else { + p + } } ///| @@ -341,7 +362,13 @@ fn fisher_combine(p1 : Double, p2 : Double) -> Double { // p-value from chi-squared with df=4 (since 2 p-values) // Use the formula: p = exp(-stat/2) * (1 + stat/2) let p = @math.exp(-stat / 2.0) * (1.0 + stat / 2.0) - if p > 1.0 { 1.0 } else if p < 0.0 { 0.0 } else { p } + if p > 1.0 { + 1.0 + } else if p < 0.0 { + 0.0 + } else { + p + } } ///| @@ -355,7 +382,12 @@ fn spia_erfc_approx(x : Double) -> Double { let t3 = t2 * t let t4 = t3 * t let t5 = t4 * t - let poly = 1.0 + 0.254829592 * t + -0.284496736 * t2 + 1.421413741 * t3 + -1.453152027 * t4 + 1.061405429 * t5 + let poly = 1.0 + + 0.254829592 * t + + -0.284496736 * t2 + + 1.421413741 * t3 + + -1.453152027 * t4 + + 1.061405429 * t5 @math.exp(-x * x) * poly } @@ -454,7 +486,10 @@ pub fn SpiaResults::get_inhibited(self : SpiaResults) -> Array[SpiaResult] { ///| /// Get top N pathways by combined p-value. -pub fn SpiaResults::get_top_pathways(self : SpiaResults, n : Int) -> Array[SpiaResult] { +pub fn SpiaResults::get_top_pathways( + self : SpiaResults, + n : Int, +) -> Array[SpiaResult] { let sorted = self.results.copy() let len = sorted.length() let mut i = 0 @@ -485,13 +520,31 @@ pub fn SpiaResults::get_top_pathways(self : SpiaResults, n : Int) -> Array[SpiaR pub fn SpiaResults::summary(self : SpiaResults) -> String { let mut s = "=== SPIA Analysis Summary ===\n".to_string() s = s + "Pathways tested: " + self.n_pathways.to_string() + "\n" - s = s + "Significant (FDR < " + self.fdr_threshold.to_string() + "): " + self.n_significant.to_string() + "\n" + s = s + + "Significant (FDR < " + + self.fdr_threshold.to_string() + + "): " + + self.n_significant.to_string() + + "\n" let mut i = 0 while i < self.results.length() { let r = self.results[i] if r.significant { - let status = if r.activation_status > 0 { "Activated" } else if r.activation_status < 0 { "Inhibited" } else { "Neutral" } - s = s + " " + r.pathway_name + " (" + status + ", p_adj=" + r.p_adj.to_string() + ")\n" + let status = if r.activation_status > 0 { + "Activated" + } else if r.activation_status < 0 { + "Inhibited" + } else { + "Neutral" + } + s = s + + " " + + r.pathway_name + + " (" + + status + + ", p_adj=" + + r.p_adj.to_string() + + ")\n" } i = i + 1 } diff --git a/src/stage_r.mbt b/src/stage_r.mbt index 2e6711c1..0b86dbce 100644 --- a/src/stage_r.mbt +++ b/src/stage_r.mbt @@ -137,7 +137,11 @@ pub fn stage_r_bh_adjust(pvalues : Array[Double]) -> Array[Double] { while i >= 0 { let rank = (i + 1).to_double() let raw_adj = pairs[i].1 * n.to_double() / rank - adj_sorted[i] = if raw_adj < adj_sorted[i + 1] { raw_adj } else { adj_sorted[i + 1] } + adj_sorted[i] = if raw_adj < adj_sorted[i + 1] { + raw_adj + } else { + adj_sorted[i + 1] + } if adj_sorted[i] > 1.0 { adj_sorted[i] = 1.0 } @@ -433,7 +437,10 @@ pub fn get_results(result : StageRResult) -> Array[Array[Bool]] { row.push(result.pAdjScreen[i] <= result.alpha) let mut j = 0 while j < h { - row.push(result.pAdjConfirmation[i][j] >= 0.0 && result.pAdjConfirmation[i][j] <= result.alpha) + row.push( + result.pAdjConfirmation[i][j] >= 0.0 && + result.pAdjConfirmation[i][j] <= result.alpha, + ) j = j + 1 } mat.push(row) @@ -466,7 +473,8 @@ pub fn get_significant_hypotheses(result : StageRResult) -> Array[(Int, Int)] { if result.pAdjScreen[i] <= result.alpha { let mut j = 0 while j < result.nHypotheses { - if result.pAdjConfirmation[i][j] >= 0.0 && result.pAdjConfirmation[i][j] <= result.alpha { + if result.pAdjConfirmation[i][j] >= 0.0 && + result.pAdjConfirmation[i][j] <= result.alpha { sigs.push((i, j)) } j = j + 1 @@ -482,14 +490,28 @@ pub fn get_significant_hypotheses(result : StageRResult) -> Array[(Int, Int)] { pub fn stage_r_summary(result : StageRResult) -> String { let buf = StringBuilder::new() buf.write_string("StageR Two-Stage Testing Summary\n") - buf.write_string(" Method: " + stage_r_method_name(result.stageMethod) + "\n") + buf.write_string( + " Method: " + stage_r_method_name(result.stageMethod) + "\n", + ) buf.write_string(" Target OFDR (alpha): " + result.alpha.to_string() + "\n") - buf.write_string(" Adjusted alpha: " + result.alphaAdjusted.to_string() + "\n") + buf.write_string( + " Adjusted alpha: " + result.alphaAdjusted.to_string() + "\n", + ) buf.write_string(" Total genes: " + result.nGenes.to_string() + "\n") - buf.write_string(" Hypotheses per gene: " + result.nHypotheses.to_string() + "\n") - buf.write_string(" Significant genes (screening): " + result.nSignificantGenes.to_string() + "\n") + buf.write_string( + " Hypotheses per gene: " + result.nHypotheses.to_string() + "\n", + ) + buf.write_string( + " Significant genes (screening): " + + result.nSignificantGenes.to_string() + + "\n", + ) let sig_hyps = get_significant_hypotheses(result) - buf.write_string(" Significant hypotheses (confirmation): " + sig_hyps.length().to_string() + "\n") + buf.write_string( + " Significant hypotheses (confirmation): " + + sig_hyps.length().to_string() + + "\n", + ) buf.to_string() } diff --git a/src/statistics.mbt b/src/statistics.mbt index 30d7426f..0b249fd5 100644 --- a/src/statistics.mbt +++ b/src/statistics.mbt @@ -71,7 +71,7 @@ pub fn stat_mode(data : Array[Double]) -> Double { counts.set(val, current + 1) i = i + 1 } - + let mut max_count = 0 let mut mode_val = data[0] for key in counts.keys() { @@ -170,15 +170,15 @@ pub fn stat_pearson_correlation(x : Array[Double], y : Array[Double]) -> Double if n < 3 { return 0.0 } - + let mean_x = stat_mean(x) let mean_y = stat_mean(y) - + let mut num = 0.0 let mut den_x = 0.0 let mut den_y = 0.0 let mut i = 0 - + while i < n { let dx = x[i] - mean_x let dy = y[i] - mean_y @@ -187,7 +187,7 @@ pub fn stat_pearson_correlation(x : Array[Double], y : Array[Double]) -> Double den_y = den_y + dy * dy i = i + 1 } - + let denom = (den_x * den_y).sqrt() if denom == 0.0 { 0.0 @@ -198,7 +198,10 @@ pub fn stat_pearson_correlation(x : Array[Double], y : Array[Double]) -> Double ///| /// Calculate the Spearman rank correlation coefficient. -pub fn stat_spearman_correlation(x : Array[Double], y : Array[Double]) -> Double { +pub fn stat_spearman_correlation( + x : Array[Double], + y : Array[Double], +) -> Double { let ranks_x = stat_rank(x) let ranks_y = stat_rank(y) stat_pearson_correlation(ranks_x, ranks_y) @@ -209,7 +212,7 @@ pub fn stat_spearman_correlation(x : Array[Double], y : Array[Double]) -> Double pub fn stat_rank(data : Array[Double]) -> Array[Double] { let n = data.length() let result : Array[Double] = Array::make(n, 0.0) - + let indexed : Array[Array[Double]] = Array::new() let mut i = 0 while i < n { @@ -217,16 +220,24 @@ pub fn stat_rank(data : Array[Double]) -> Array[Double] { indexed.push(row) i = i + 1 } - - indexed.sort_by(fn(a: Array[Double], b: Array[Double]) -> Int { if a[0] < b[0] { -1 } else if a[0] > b[0] { 1 } else { 0 } }) - + + indexed.sort_by(fn(a : Array[Double], b : Array[Double]) -> Int { + if a[0] < b[0] { + -1 + } else if a[0] > b[0] { + 1 + } else { + 0 + } + }) + let mut pos = 0 while pos < n { let mut end = pos while end < n - 1 && indexed[end + 1][0] == indexed[pos][0] { end = end + 1 } - let avg_rank = ((pos + end).to_double() / 2.0) + 1.0 + let avg_rank = (pos + end).to_double() / 2.0 + 1.0 let mut j = pos while j <= end { let idx = indexed[j][1].to_int() @@ -235,7 +246,7 @@ pub fn stat_rank(data : Array[Double]) -> Array[Double] { } pos = end + 1 } - + result } @@ -275,7 +286,12 @@ pub fn stat_pvalue_zscore(z : Double) -> Double { pub fn stat_normal_cdf(x : Double) -> Double { let t = 1.0 / (1.0 + 0.2316419 * (if x < 0.0 { -x } else { x })) let d = 0.3989423 * @math.exp(-x * x / 2.0) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.8212560 + t * 1.3302744)))) + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.8212560 + t * 1.3302744))) + ) if x > 0.0 { 1.0 - p } else { @@ -295,7 +311,7 @@ pub fn stat_t_statistic(sample : Array[Double], mu_0 : Double) -> Double { if std == 0.0 { 0.0 } else { - (mean - mu_0) / (std / (n.to_double()).sqrt()) + (mean - mu_0) / (std / n.to_double().sqrt()) } } @@ -304,20 +320,25 @@ pub fn stat_t_statistic(sample : Array[Double], mu_0 : Double) -> Double { pub fn stat_pvalue_t(t : Double, df : Int) -> Double { let abs_t = if t < 0.0 { -t } else { t } // Approximation using normal distribution for large df - let z = abs_t * (1.0 - 1.0 / (4.0 * df.to_double())) / (1.0 + t * t / (df.to_double())).sqrt() + let z = abs_t * + (1.0 - 1.0 / (4.0 * df.to_double())) / + (1.0 + t * t / df.to_double()).sqrt() 2.0 * (1.0 - stat_normal_cdf(z)) } ///| /// Calculate confidence interval for the mean. -pub fn stat_confidence_interval(data : Array[Double], confidence? : Double = 0.95) -> Array[Double] { +pub fn stat_confidence_interval( + data : Array[Double], + confidence? : Double = 0.95, +) -> Array[Double] { let n = data.length() if n < 2 { return [stat_mean(data), stat_mean(data)] } let mean = stat_mean(data) let std = stat_std(data) - + let z = if confidence == 0.99 { 2.576 } else if confidence == 0.90 { @@ -325,15 +346,22 @@ pub fn stat_confidence_interval(data : Array[Double], confidence? : Double = 0.9 } else { 1.96 } - - let margin = z * std / (n.to_double()).sqrt() + + let margin = z * std / n.to_double().sqrt() [mean - margin, mean + margin] } ///| /// Calculate the chi-square statistic. -pub fn stat_chi_square(observed : Array[Double], expected : Array[Double]) -> Double { - let n = if observed.length() < expected.length() { observed.length() } else { expected.length() } +pub fn stat_chi_square( + observed : Array[Double], + expected : Array[Double], +) -> Double { + let n = if observed.length() < expected.length() { + observed.length() + } else { + expected.length() + } let mut chi2 = 0.0 let mut i = 0 while i < n { @@ -348,8 +376,14 @@ pub fn stat_chi_square(observed : Array[Double], expected : Array[Double]) -> Do ///| /// Expected frequencies for chi-square test (uniform distribution). -pub fn stat_uniform_expected(n_categories : Int, total : Double) -> Array[Double] { - let expected : Array[Double] = Array::make(n_categories, total / n_categories.to_double()) +pub fn stat_uniform_expected( + n_categories : Int, + total : Double, +) -> Array[Double] { + let expected : Array[Double] = Array::make( + n_categories, + total / n_categories.to_double(), + ) expected } @@ -388,8 +422,12 @@ pub fn stat_unique_values(data : Array[Double]) -> Array[Double] { ///| /// Calculate the natural log (ln) of a number. fn stat_ln(x : Double) -> Double { - if x <= 0.0 { return 0.0 } - if x == 1.0 { return 0.0 } + if x <= 0.0 { + return 0.0 + } + if x == 1.0 { + return 0.0 + } let y = (x - 1.0) / (x + 1.0) let y2 = y * y let mut sum = y @@ -437,7 +475,9 @@ pub fn stat_geometric_mean(data : Array[Double]) -> Double { ///| /// Sort an array of (score, index) pairs by score descending (quicksort). -pub fn stat_sort_indices_desc(data : Array[(Double, Int)]) -> Array[(Double, Int)] { +pub fn stat_sort_indices_desc( + data : Array[(Double, Int)], +) -> Array[(Double, Int)] { if data.length() <= 1 { return data.copy() } @@ -466,7 +506,9 @@ pub fn stat_sort_indices_desc(data : Array[(Double, Int)]) -> Array[(Double, Int ///| /// Sort an array of (score, index) pairs by score ascending (quicksort). -pub fn stat_sort_indices_asc(data : Array[(Double, Int)]) -> Array[(Double, Int)] { +pub fn stat_sort_indices_asc( + data : Array[(Double, Int)], +) -> Array[(Double, Int)] { if data.length() <= 1 { return data.copy() } @@ -543,7 +585,10 @@ pub fn stat_standardize(data : Array[Double]) -> Array[Double] { ///| /// Wilcoxon signed-rank test for paired samples. /// Returns (statistic, p_value). -pub fn stat_wilcoxon_signed_rank(x : Array[Double], y : Array[Double]) -> (Double, Double) { +pub fn stat_wilcoxon_signed_rank( + x : Array[Double], + y : Array[Double], +) -> (Double, Double) { let n = if x.length() < y.length() { x.length() } else { y.length() } if n < 6 { return (0.0, 1.0) @@ -597,7 +642,7 @@ pub fn stat_wilcoxon_signed_rank(x : Array[Double], y : Array[Double]) -> (Doubl // Two-tailed p-value let p = 2.0 * stat_pvalue_zscore(z) - let stat = if w_plus > (n_dbl * (n_dbl + 1.0) / 4.0) { + let stat = if w_plus > n_dbl * (n_dbl + 1.0) / 4.0 { w_plus } else { n_dbl * (n_dbl + 1.0) / 2.0 - w_plus @@ -608,7 +653,10 @@ pub fn stat_wilcoxon_signed_rank(x : Array[Double], y : Array[Double]) -> (Doubl ///| /// Mann-Whitney U test (Wilcoxon rank-sum test) for two independent samples. /// Returns (statistic, p_value). -pub fn stat_mann_whitney(x : Array[Double], y : Array[Double]) -> (Double, Double) { +pub fn stat_mann_whitney( + x : Array[Double], + y : Array[Double], +) -> (Double, Double) { let n1 = x.length() let n2 = y.length() if n1 < 3 || n2 < 3 { @@ -635,7 +683,7 @@ pub fn stat_mann_whitney(x : Array[Double], y : Array[Double]) -> (Double, Doubl // U statistic let u1 = r1 - n1.to_double() * (n1.to_double() + 1.0) / 2.0 - let u2 = (n1.to_double() * n2.to_double()) - u1 + let u2 = n1.to_double() * n2.to_double() - u1 let u = if u1 < u2 { u1 } else { u2 } // Normal approximation with tie correction @@ -644,11 +692,7 @@ pub fn stat_mann_whitney(x : Array[Double], y : Array[Double]) -> (Double, Doubl let mean_u = n1_d * n2_d / 2.0 let var_u = n1_d * n2_d * (n1_d + n2_d + 1.0) / 12.0 - let z = if var_u > 0.0 { - (u - mean_u) / var_u.sqrt() - } else { - 0.0 - } + let z = if var_u > 0.0 { (u - mean_u) / var_u.sqrt() } else { 0.0 } let p = 2.0 * stat_pvalue_zscore(z) (u, if p.is_nan() || p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p }) @@ -659,10 +703,26 @@ pub fn stat_mann_whitney(x : Array[Double], y : Array[Double]) -> (Double, Doubl /// Table format: [[a, b], [c, d]] /// Returns (odds_ratio, p_value). pub fn stat_fisher_exact(table : Array[Array[Int]]) -> (Double, Double) { - let a = if table.length() > 0 && table[0].length() > 0 { table[0][0] } else { 0 } - let b = if table.length() > 0 && table[0].length() > 1 { table[0][1] } else { 0 } - let c = if table.length() > 1 && table[1].length() > 0 { table[1][0] } else { 0 } - let d = if table.length() > 1 && table[1].length() > 1 { table[1][1] } else { 0 } + let a = if table.length() > 0 && table[0].length() > 0 { + table[0][0] + } else { + 0 + } + let b = if table.length() > 0 && table[0].length() > 1 { + table[0][1] + } else { + 0 + } + let c = if table.length() > 1 && table[1].length() > 0 { + table[1][0] + } else { + 0 + } + let d = if table.length() > 1 && table[1].length() > 1 { + table[1][1] + } else { + 0 + } let n = (a + b + c + d).to_double() if n <= 0.0 { @@ -671,9 +731,13 @@ pub fn stat_fisher_exact(table : Array[Array[Int]]) -> (Double, Double) { // Odds ratio let or = if c.to_double() * b.to_double() == 0.0 { - if a.to_double() * d.to_double() == 0.0 { 1.0 } else { 1.0e15 } + if a.to_double() * d.to_double() == 0.0 { + 1.0 + } else { + 1.0e15 + } } else { - (a.to_double() * d.to_double()) / (b.to_double() * c.to_double()) + a.to_double() * d.to_double() / (b.to_double() * c.to_double()) } // Hypergeometric probability @@ -700,7 +764,11 @@ fn stat_fisher_exact_pvalue(a : Int, b : Int, c : Int, d : Int) -> Double { let col2_total = b + d let mut p_value = 0.0 - let min_a = if (row1_total - col2_total) > 0 { row1_total - col2_total } else { 0 } + let min_a = if row1_total - col2_total > 0 { + row1_total - col2_total + } else { + 0 + } let max_a = if row1_total < col1_total { row1_total } else { col1_total } let mut a_curr = min_a @@ -717,14 +785,22 @@ fn stat_fisher_exact_pvalue(a : Int, b : Int, c : Int, d : Int) -> Double { a_curr = a_curr + 1 } - if p_value > 1.0 { 1.0 } else if p_value < 0.0 { 0.0 } else { p_value } + if p_value > 1.0 { + 1.0 + } else if p_value < 0.0 { + 0.0 + } else { + p_value + } } ///| /// Multivariate hypergeometric PMF for a 2x2 table. fn stat_mult_hypergeom_pmf(a : Int, b : Int, c : Int, d : Int) -> Double { let n = (a + b + c + d).to_double() - if n <= 0.0 { return 0.0 } + if n <= 0.0 { + return 0.0 + } let a_d = a.to_double() let b_d = b.to_double() @@ -737,20 +813,30 @@ fn stat_mult_hypergeom_pmf(a : Int, b : Int, c : Int, d : Int) -> Double { let col2 = b_d + d_d // log probability using gamma functions - let ln_p = stat_ln_factorial(row1) + stat_ln_factorial(row2) + - stat_ln_factorial(col1) + stat_ln_factorial(col2) - + let ln_p = stat_ln_factorial(row1) + + stat_ln_factorial(row2) + + stat_ln_factorial(col1) + + stat_ln_factorial(col2) - stat_ln_factorial(n) - - stat_ln_factorial(a_d) - stat_ln_factorial(b_d) - - stat_ln_factorial(c_d) - stat_ln_factorial(d_d) + stat_ln_factorial(a_d) - + stat_ln_factorial(b_d) - + stat_ln_factorial(c_d) - + stat_ln_factorial(d_d) let p = @math.exp(ln_p) - if p.is_nan() || p < 0.0 { 0.0 } else { p } + if p.is_nan() || p < 0.0 { + 0.0 + } else { + p + } } ///| /// Natural log of factorial (uses Stirling's approximation for large values). fn stat_ln_factorial(x : Double) -> Double { - if x <= 0.0 { return 0.0 } + if x <= 0.0 { + return 0.0 + } if x < 20.0 { // Direct computation for small values let mut result = 0.0 @@ -772,7 +858,10 @@ fn stat_ln_factorial(x : Double) -> Double { ///| /// Kolmogorov-Smirnov test for comparing two samples. /// Returns (statistic, p_value). -pub fn stat_ks_test(sample1 : Array[Double], sample2 : Array[Double]) -> (Double, Double) { +pub fn stat_ks_test( + sample1 : Array[Double], + sample2 : Array[Double], +) -> (Double, Double) { let n1 = sample1.length() let n2 = sample2.length() if n1 < 2 || n2 < 2 { @@ -781,8 +870,12 @@ pub fn stat_ks_test(sample1 : Array[Double], sample2 : Array[Double]) -> (Double // Combine all values and compute ECDF let combined : Array[Double] = Array::new() - for v in sample1 { combined.push(v) } - for v in sample2 { combined.push(v) } + for v in sample1 { + combined.push(v) + } + for v in sample2 { + combined.push(v) + } let sorted = stat_sort_double(combined) let n = sorted.length() @@ -794,14 +887,18 @@ pub fn stat_ks_test(sample1 : Array[Double], sample2 : Array[Double]) -> (Double // ECDF for sample1 at x let mut ecdf1 = 0.0 for v in sample1 { - if v <= x { ecdf1 = ecdf1 + 1.0 } + if v <= x { + ecdf1 = ecdf1 + 1.0 + } } ecdf1 = ecdf1 / n1.to_double() // ECDF for sample2 at x let mut ecdf2 = 0.0 for v in sample2 { - if v <= x { ecdf2 = ecdf2 + 1.0 } + if v <= x { + ecdf2 = ecdf2 + 1.0 + } } ecdf2 = ecdf2 / n2.to_double() @@ -813,33 +910,47 @@ pub fn stat_ks_test(sample1 : Array[Double], sample2 : Array[Double]) -> (Double } // Approximate p-value using Kolmogorov approximation - let n_eff = (n1.to_double() * n2.to_double()) / (n1.to_double() + n2.to_double()) + let n_eff = n1.to_double() * + n2.to_double() / + (n1.to_double() + n2.to_double()) let sqrt_n_eff = n_eff.sqrt() let lambda = (sqrt_n_eff + 0.12 + 0.11 / sqrt_n_eff) * max_diff // Kolmogorov distribution approximation - let p = if lambda <= 0.0 { - 1.0 - } else { - 2.0 * stat_kolmogorov_cdf(lambda) - } - - (max_diff, if p.is_nan() || p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p }) + let p = if lambda <= 0.0 { 1.0 } else { 2.0 * stat_kolmogorov_cdf(lambda) } + + ( + max_diff, + if p.is_nan() || p < 0.0 { + 0.0 + } else if p > 1.0 { + 1.0 + } else { + p + }, + ) } ///| /// Kolmogorov distribution CDF (approximation). fn stat_kolmogorov_cdf(lambda : Double) -> Double { - if lambda <= 0.0 { return 0.0 } - if lambda >= 10.0 { return 1.0 } + if lambda <= 0.0 { + return 0.0 + } + if lambda >= 10.0 { + return 1.0 + } let mut sum = 0.0 let mut k = 1 while k <= 100 { let k_dbl = k.to_double() - let term = (-1.0).pow(k_dbl - 1.0) * @math.exp(-2.0 * k_dbl * k_dbl * lambda * lambda) + let term = (-1.0).pow(k_dbl - 1.0) * + @math.exp(-2.0 * k_dbl * k_dbl * lambda * lambda) sum = sum + term - if term.abs() < 1.0e-15 { break } + if term.abs() < 1.0e-15 { + break + } k = k + 1 } 2.0 * sum @@ -853,7 +964,15 @@ pub fn stat_bonferroni(p_values : Array[Double]) -> Array[Double] { let mut i = 0 while i < n { let corrected = p_values[i] * n.to_double() - result.push(if corrected > 1.0 { 1.0 } else if corrected < 0.0 { 0.0 } else { corrected }) + result.push( + if corrected > 1.0 { + 1.0 + } else if corrected < 0.0 { + 0.0 + } else { + corrected + }, + ) i = i + 1 } result @@ -863,7 +982,9 @@ pub fn stat_bonferroni(p_values : Array[Double]) -> Array[Double] { /// Holm-Bonferroni step-down procedure for multiple testing. pub fn stat_holm(p_values : Array[Double]) -> Array[Double] { let n = p_values.length() - if n == 0 { return Array::new() } + if n == 0 { + return Array::new() + } // Create indexed pairs and sort by p-value let indexed : Array[(Double, Int)] = Array::new() @@ -898,7 +1019,9 @@ pub fn stat_holm(p_values : Array[Double]) -> Array[Double] { /// Benjamini-Yekutieli correction for multiple testing (conservative version). pub fn stat_by(p_values : Array[Double]) -> Array[Double] { let n = p_values.length() - if n == 0 { return Array::new() } + if n == 0 { + return Array::new() + } // Harmonic number for BY correction let mut h = 0.0 @@ -945,13 +1068,19 @@ pub fn stat_beta_pdf(x : Double, alpha : Double, beta : Double) -> Double { } // log(1/B(alpha,beta)) + (alpha-1)*log(x) + (beta-1)*log(1-x) - let ln_beta = stat_lngamma(alpha) + stat_lngamma(beta) - stat_lngamma(alpha + beta) + let ln_beta = stat_lngamma(alpha) + + stat_lngamma(beta) - + stat_lngamma(alpha + beta) let ln_x = @math.ln(x) let ln_1mx = @math.ln(1.0 - x) let ln_pdf = -ln_beta + (alpha - 1.0) * ln_x + (beta - 1.0) * ln_1mx let pdf = @math.exp(ln_pdf) - if pdf.is_nan() || pdf < 0.0 { 0.0 } else { pdf } + if pdf.is_nan() || pdf < 0.0 { + 0.0 + } else { + pdf + } } ///| @@ -962,10 +1091,17 @@ pub fn stat_gamma_pdf(x : Double, shape : Double, rate : Double) -> Double { } let ln_gamma = stat_lngamma(shape) - let ln_pdf = shape * @math.ln(rate) - ln_gamma + (shape - 1.0) * @math.ln(x) - rate * x + let ln_pdf = shape * @math.ln(rate) - + ln_gamma + + (shape - 1.0) * @math.ln(x) - + rate * x let pdf = @math.exp(ln_pdf) - if pdf.is_nan() || pdf < 0.0 { 0.0 } else { pdf } + if pdf.is_nan() || pdf < 0.0 { + 0.0 + } else { + pdf + } } ///| @@ -1010,7 +1146,9 @@ pub fn stat_bartlett_test(samples : Array[Array[Double]]) -> (Double, Double) { let mut i = 0 while i < k { let n = samples[i].length() - if n < 2 { return (0.0, 1.0) } + if n < 2 { + return (0.0, 1.0) + } let var = stat_variance(samples[i]) variances.push(var) sizes.push(n) @@ -1052,12 +1190,17 @@ pub fn stat_bartlett_test(samples : Array[Array[Double]]) -> (Double, Double) { ///| /// Chi-square survival function (p-value from chi-square distribution). fn stat_chi2_sf(x : Double, df : Int) -> Double { - if x <= 0.0 { return 1.0 } - if df <= 0 { return 1.0 } + if x <= 0.0 { + return 1.0 + } + if df <= 0 { + return 1.0 + } // Wilson-Hilferty approximation let df_d = df.to_double() - let z = ((x / df_d).pow(1.0 / 3.0) - (1.0 - 2.0 / (9.0 * df_d))) / ((2.0 / (9.0 * df_d)).sqrt()) + let z = ((x / df_d).pow(1.0 / 3.0) - (1.0 - 2.0 / (9.0 * df_d))) / + (2.0 / (9.0 * df_d)).sqrt() stat_pvalue_zscore(z) } @@ -1079,7 +1222,9 @@ pub fn stat_levene_test(samples : Array[Array[Double]]) -> (Double, Double) { let mut i = 0 while i < k { let n = samples[i].length() - if n < 2 { return (0.0, 1.0) } + if n < 2 { + return (0.0, 1.0) + } let med = stat_median(samples[i]) medians.push(med) sizes.push(n) @@ -1131,7 +1276,9 @@ pub fn stat_levene_test(samples : Array[Array[Double]]) -> (Double, Double) { } let levene_stat = if denominator > 0.0 { - (numerator / (k.to_double() - 1.0)) / (denominator / (total_n.to_double() - k.to_double())) + numerator / + (k.to_double() - 1.0) / + (denominator / (total_n.to_double() - k.to_double())) } else { 0.0 } @@ -1140,29 +1287,54 @@ pub fn stat_levene_test(samples : Array[Array[Double]]) -> (Double, Double) { let df1 = k - 1 let df2 = total_n - k let p = stat_f_sf(levene_stat, df1, df2) - (levene_stat, if p.is_nan() || p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p }) + ( + levene_stat, + if p.is_nan() || p < 0.0 { + 0.0 + } else if p > 1.0 { + 1.0 + } else { + p + }, + ) } ///| /// F-distribution survival function (p-value from F distribution). fn stat_f_sf(f : Double, df1 : Int, df2 : Int) -> Double { - if f <= 0.0 { return 1.0 } - if df1 <= 0 || df2 <= 0 { return 1.0 } + if f <= 0.0 { + return 1.0 + } + if df1 <= 0 || df2 <= 0 { + return 1.0 + } // Use incomplete beta function relationship let x = df1.to_double() * f / (df1.to_double() * f + df2.to_double()) - if x >= 1.0 { return 0.0 } + if x >= 1.0 { + return 0.0 + } let a = df1.to_double() / 2.0 let b = df2.to_double() / 2.0 let p = stat_beta_inc(x, a, b) - if p.is_nan() || p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p } + if p.is_nan() || p < 0.0 { + 0.0 + } else if p > 1.0 { + 1.0 + } else { + p + } } ///| /// Regularized incomplete beta function I_x(a, b). fn stat_beta_inc(x : Double, a : Double, b : Double) -> Double { - if x <= 0.0 { return 0.0 } - if x >= 1.0 { return 1.0 } + if x <= 0.0 { + return 0.0 + } + if x >= 1.0 { + return 1.0 + } // Use continued fraction expansion let lbeta = stat_lngamma(a) + stat_lngamma(b) - stat_lngamma(a + b) @@ -1185,22 +1357,34 @@ fn stat_beta_inc(x : Double, a : Double, b : Double) -> Double { numerator = 1.0 } else if i % 2 == 0 { // Even step - numerator = m_d * (b - m_d) * x / ((a + 2.0 * m_d - 1.0) * (a + 2.0 * m_d)) + numerator = m_d * + (b - m_d) * + x / + ((a + 2.0 * m_d - 1.0) * (a + 2.0 * m_d)) } else { // Odd step - numerator = -(a + m_d) * (a + b + m_d) * x / ((a + 2.0 * m_d) * (a + 2.0 * m_d + 1.0)) + numerator = -(a + m_d) * + (a + b + m_d) * + x / + ((a + 2.0 * m_d) * (a + 2.0 * m_d + 1.0)) } d = 1.0 + numerator * d - if d.abs() < eps { d = eps } + if d.abs() < eps { + d = eps + } d = 1.0 / d c = 1.0 + numerator / c - if c.abs() < eps { c = eps } + if c.abs() < eps { + c = eps + } let delta = c * d f = f * delta - if (delta - 1.0).abs() < eps { break } + if (delta - 1.0).abs() < eps { + break + } i = i + 1 } @@ -1211,22 +1395,39 @@ fn stat_beta_inc(x : Double, a : Double, b : Double) -> Double { ///| /// Chi-square distribution CDF. pub fn stat_chi2_cdf(x : Double, df : Int) -> Double { - if x <= 0.0 { return 0.0 } - if df <= 0 { return 0.0 } + if x <= 0.0 { + return 0.0 + } + if df <= 0 { + return 0.0 + } let df_d = df.to_double() // Wilson-Hilferty approximation - let z = ((x / df_d).pow(1.0 / 3.0) - (1.0 - 2.0 / (9.0 * df_d))) / ((2.0 / (9.0 * df_d)).sqrt()) + let z = ((x / df_d).pow(1.0 / 3.0) - (1.0 - 2.0 / (9.0 * df_d))) / + (2.0 / (9.0 * df_d)).sqrt() let p = stat_normal_cdf(z) - if p.is_nan() || p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p } + if p.is_nan() || p < 0.0 { + 0.0 + } else if p > 1.0 { + 1.0 + } else { + p + } } ///| /// Chi-square distribution quantile (inverse CDF). pub fn stat_chi2_quantile(p : Double, df : Int) -> Double { - if p <= 0.0 { return 0.0 } - if p >= 1.0 { return 1.0e300 } - if df <= 0 { return 0.0 } + if p <= 0.0 { + return 0.0 + } + if p >= 1.0 { + return 1.0e300 + } + if df <= 0 { + return 0.0 + } // Newton's method on stat_chi2_cdf(x, df) = p let df_d = df.to_double() @@ -1235,33 +1436,56 @@ pub fn stat_chi2_quantile(p : Double, df : Int) -> Double { while i < 100 { let cdf_val = stat_chi2_cdf(x, df) let diff = cdf_val - p - if diff.abs() < 1.0e-12 { break } + if diff.abs() < 1.0e-12 { + break + } // Numerical derivative let h = 1.0e-7 - let deriv = (stat_chi2_cdf(x + h, df) - stat_chi2_cdf(x - h, df)) / (2.0 * h) - if deriv.abs() < 1.0e-30 { break } + let deriv = (stat_chi2_cdf(x + h, df) - stat_chi2_cdf(x - h, df)) / + (2.0 * h) + if deriv.abs() < 1.0e-30 { + break + } x = x - diff / deriv - if x < 0.0 { x = 1.0e-15 } + if x < 0.0 { + x = 1.0e-15 + } i = i + 1 } - if x < 0.0 { 0.0 } else { x } + if x < 0.0 { + 0.0 + } else { + x + } } ///| /// Student's t-distribution CDF. pub fn stat_t_cdf(t : Double, df : Double) -> Double { - if df <= 0.0 { return 0.5 } + if df <= 0.0 { + return 0.5 + } let x = df / (df + t * t) let p = 0.5 * stat_beta_inc(x, df / 2.0, 0.5) - if t >= 0.0 { 1.0 - p } else { p } + if t >= 0.0 { + 1.0 - p + } else { + p + } } ///| /// Student's t-distribution quantile (inverse CDF). pub fn stat_t_quantile(p : Double, df : Double) -> Double { - if p <= 0.0 { return -1.0e300 } - if p >= 1.0 { return 1.0e300 } - if (p - 0.5).abs() < 1.0e-15 { return 0.0 } + if p <= 0.0 { + return -1.0e300 + } + if p >= 1.0 { + return 1.0e300 + } + if (p - 0.5).abs() < 1.0e-15 { + return 0.0 + } // Newton's method on stat_t_cdf(t, df) = p let mut t = if p < 0.5 { -1.0 } else { 1.0 } @@ -1269,11 +1493,15 @@ pub fn stat_t_quantile(p : Double, df : Double) -> Double { while i < 100 { let cdf_val = stat_t_cdf(t, df) let diff = cdf_val - p - if diff.abs() < 1.0e-12 { break } + if diff.abs() < 1.0e-12 { + break + } // Numerical derivative let h = 1.0e-7 let deriv = (stat_t_cdf(t + h, df) - stat_t_cdf(t - h, df)) / (2.0 * h) - if deriv.abs() < 1.0e-30 { break } + if deriv.abs() < 1.0e-30 { + break + } t = t - diff / deriv i = i + 1 } @@ -1283,7 +1511,10 @@ pub fn stat_t_quantile(p : Double, df : Double) -> Double { ///| /// One-sample t-test. /// Returns (statistic, p_value). -pub fn stat_t_test_one_sample(sample : Array[Double], mu_0 : Double) -> (Double, Double) { +pub fn stat_t_test_one_sample( + sample : Array[Double], + mu_0 : Double, +) -> (Double, Double) { let n = sample.length() if n < 3 { return (0.0, 1.0) @@ -1293,7 +1524,7 @@ pub fn stat_t_test_one_sample(sample : Array[Double], mu_0 : Double) -> (Double, if std <= 0.0 { return (0.0, 1.0) } - let t = (mean - mu_0) / (std / (n.to_double()).sqrt()) + let t = (mean - mu_0) / (std / n.to_double().sqrt()) let df = (n - 1).to_double() let p = 2.0 * (1.0 - stat_t_cdf(t.abs(), df)) (t, if p.is_nan() || p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p }) @@ -1302,7 +1533,10 @@ pub fn stat_t_test_one_sample(sample : Array[Double], mu_0 : Double) -> (Double, ///| /// Two-sample t-test (equal variances). /// Returns (statistic, p_value). -pub fn stat_t_test_two_sample(x : Array[Double], y : Array[Double]) -> (Double, Double) { +pub fn stat_t_test_two_sample( + x : Array[Double], + y : Array[Double], +) -> (Double, Double) { let n1 = x.length() let n2 = y.length() if n1 < 3 || n2 < 3 { @@ -1315,7 +1549,7 @@ pub fn stat_t_test_two_sample(x : Array[Double], y : Array[Double]) -> (Double, // Pooled variance (equal variances assumption) let pooled_var = ((n1 - 1).to_double() * var1 + (n2 - 1).to_double() * var2) / - ((n1 + n2 - 2).to_double()) + (n1 + n2 - 2).to_double() if pooled_var <= 0.0 { return (0.0, 1.0) } @@ -1333,7 +1567,9 @@ pub fn stat_t_test_two_sample(x : Array[Double], y : Array[Double]) -> (Double, /// Benjamini-Hochberg (BH) step-up procedure for multiple testing. pub fn stat_bh(p_values : Array[Double]) -> Array[Double] { let n = p_values.length() - if n == 0 { return Array::new() } + if n == 0 { + return Array::new() + } let indexed : Array[(Double, Int)] = Array::new() let mut i = 0 @@ -1363,7 +1599,9 @@ pub fn stat_bh(p_values : Array[Double]) -> Array[Double] { i = 0 while i < n { - if adjusted[i] > 1.0 { adjusted[i] = 1.0 } + if adjusted[i] > 1.0 { + adjusted[i] = 1.0 + } i = i + 1 } @@ -1373,42 +1611,58 @@ pub fn stat_bh(p_values : Array[Double]) -> Array[Double] { ///| /// Normal distribution quantile (inverse CDF) using rational approximation. pub fn stat_normal_quantile(p : Double) -> Double { - if p <= 0.0 { return -1.0e300 } - if p >= 1.0 { return 1.0e300 } + if p <= 0.0 { + return -1.0e300 + } + if p >= 1.0 { + return 1.0e300 + } // Peter Acklam's rational approximation - let a = [-3.969683028665376e+01, 2.209460984245205e+02, -2.759285104469687e+02, - 1.383577518672690e+02, -3.066479806614716e+01, 2.506628277459239e+00] - let b = [-5.447609879822406e+01, 1.615858368580409e+02, -1.556989798598866e+02, - 6.680131188771972e+01, -1.328068155288572e+01] - let c = [-7.784894002430293e-03, -3.223964580411365e-01, -2.400758277161838e+00, - -2.549732539343734e+00, 4.374664141464968e+00, 2.938163982698783e+00] - let d = [7.784695709041462e-03, 3.224671290700398e-01, 2.445134137142996e+00, - 3.754408661907416e+00] + let a = [ + -3.969683028665376e+01, 2.209460984245205e+02, -2.759285104469687e+02, 1.383577518672690e+02, + -3.066479806614716e+01, 2.506628277459239e+00, + ] + let b = [ + -5.447609879822406e+01, 1.615858368580409e+02, -1.556989798598866e+02, 6.680131188771972e+01, + -1.328068155288572e+01, + ] + let c = [ + -7.784894002430293e-03, -3.223964580411365e-01, -2.400758277161838e+00, -2.549732539343734e+00, + 4.374664141464968e+00, 2.938163982698783e+00, + ] + let d = [ + 7.784695709041462e-03, 3.224671290700398e-01, 2.445134137142996e+00, 3.754408661907416e+00, + ] let plow = 0.02425 let phigh = 1.0 - plow if p < plow { let q = (-2.0 * @math.ln(p)).sqrt() - c[0] * (q + c[1] * (q + c[2] * (q + c[3] * (q + c[4] * q + c[5])))) / - (1.0 + d[0] * (q + d[1] * (q + d[2] * (q + d[3] * q)))) + c[0] * + (q + c[1] * (q + c[2] * (q + c[3] * (q + c[4] * q + c[5])))) / + (1.0 + d[0] * (q + d[1] * (q + d[2] * (q + d[3] * q)))) } else if p <= phigh { let q = p - 0.5 let r = q * q - (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q / - (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1.0) + (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * + q / + (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1.0) } else { let q = (-2.0 * @math.ln(1.0 - p)).sqrt() - -c[0] * (q + c[1] * (q + c[2] * (q + c[3] * (q + c[4] * q + c[5])))) / - (1.0 + d[0] * (q + d[1] * (q + d[2] * (q + d[3] * q)))) + -c[0] * + (q + c[1] * (q + c[2] * (q + c[3] * (q + c[4] * q + c[5])))) / + (1.0 + d[0] * (q + d[1] * (q + d[2] * (q + d[3] * q)))) } } ///| /// Compute the mean absolute deviation (MAD) from median. pub fn stat_mad(data : Array[Double], constant? : Double = 1.4826) -> Double { - if data.length() == 0 { return 0.0 } + if data.length() == 0 { + return 0.0 + } let med = stat_median(data) let devs : Array[Double] = Array::new() let mut i = 0 @@ -1462,7 +1716,11 @@ pub fn stat_logrank_test( let mut n2_total = 0 i = 0 while i < n { - if indexed[i].2 == 0 { n1_total = n1_total + 1 } else { n2_total = n2_total + 1 } + if indexed[i].2 == 0 { + n1_total = n1_total + 1 + } else { + n2_total = n2_total + 1 + } i = i + 1 } @@ -1496,11 +1754,7 @@ pub fn stat_logrank_test( i = i + 1 } - let z = if v > 0.0 { - (o1 - e1) / v.sqrt() - } else { - 0.0 - } + let z = if v > 0.0 { (o1 - e1) / v.sqrt() } else { 0.0 } let p = 2.0 * (1.0 - stat_normal_cdf(z.abs())) let chi2 = z * z @@ -1524,7 +1778,9 @@ pub fn stat_anova(samples : Array[Array[Double]]) -> (Double, Double) { let mut i = 0 while i < k { let n = samples[i].length() - if n < 2 { return (0.0, 1.0) } + if n < 2 { + return (0.0, 1.0) + } sizes.push(n) means.push(stat_mean(samples[i])) variances.push(stat_variance(samples[i])) @@ -1547,7 +1803,8 @@ pub fn stat_anova(samples : Array[Array[Double]]) -> (Double, Double) { let mut ss_between = 0.0 i = 0 while i < k { - ss_between = ss_between + sizes[i].to_double() * (means[i] - grand_mean).pow(2.0) + ss_between = ss_between + + sizes[i].to_double() * (means[i] - grand_mean).pow(2.0) i = i + 1 } diff --git a/src/stockholm.mbt b/src/stockholm.mbt index 31053d66..1eb11fb5 100644 --- a/src/stockholm.mbt +++ b/src/stockholm.mbt @@ -91,7 +91,13 @@ pub fn StockholmAlignment::new( gs_annotations : Map[String, String], markup : Array[String], ) -> StockholmAlignment { - StockholmAlignment::{ version, blocks, gf_annotations, gs_annotations, markup } + StockholmAlignment::{ + version, + blocks, + gf_annotations, + gs_annotations, + markup, + } } ///| @@ -166,7 +172,9 @@ pub fn stockholm_parse(content : String) -> StockholmAlignment { let mut value = "" let mut pi = 1 while pi < filtered.length() { - if pi > 1 { value = value + " " } + if pi > 1 { + value = value + " " + } value = value + filtered[pi] pi = pi + 1 } @@ -194,7 +202,9 @@ pub fn stockholm_parse(content : String) -> StockholmAlignment { let mut value = "" let mut pi = 1 while pi < gc_filtered.length() { - if pi > 1 { value = value + " " } + if pi > 1 { + value = value + " " + } value = value + gc_filtered[pi] pi = pi + 1 } @@ -218,7 +228,9 @@ pub fn stockholm_parse(content : String) -> StockholmAlignment { let mut value = "" let mut pi = 1 while pi < gr_filtered.length() { - if pi > 1 { value = value + " " } + if pi > 1 { + value = value + " " + } value = value + gr_filtered[pi] pi = pi + 1 } @@ -242,7 +254,9 @@ pub fn stockholm_parse(content : String) -> StockholmAlignment { let mut value = "" let mut pi = 1 while pi < gs_filtered.length() { - if pi > 1 { value = value + " " } + if pi > 1 { + value = value + " " + } value = value + gs_filtered[pi] pi = pi + 1 } @@ -276,9 +290,7 @@ pub fn stockholm_parse(content : String) -> StockholmAlignment { current_seqs.push(s) has_block_content = true } - None => { - markup.push(trimmed) - } + None => markup.push(trimmed) } i = i + 1 } @@ -419,10 +431,14 @@ pub fn stockholm_write(ali : StockholmAlignment) -> String { pub fn stockholm_percent_identity(block : StockholmBlock) -> Double { let seqs = block.sequences let n = seqs.length() - if n < 2 { return 0.0 } + if n < 2 { + return 0.0 + } let len = seqs[0].aligned_seq.length() - if len == 0 { return 0.0 } + if len == 0 { + return 0.0 + } let mut total_identity = 0.0 let mut total_comparisons = 0.0 @@ -448,7 +464,8 @@ pub fn stockholm_percent_identity(block : StockholmBlock) -> Double { k = k + 1 } if comparable > 0 { - total_identity = total_identity + matches.to_double() / comparable.to_double() + total_identity = total_identity + + matches.to_double() / comparable.to_double() total_comparisons = total_comparisons + 1.0 } j = j + 1 @@ -471,10 +488,14 @@ pub fn stockholm_conservation(block : StockholmBlock) -> Array[Double] { let result : Array[Double] = Array::new() let seqs = block.sequences let n = seqs.length() - if n == 0 { return result } + if n == 0 { + return result + } let len = seqs[0].aligned_seq.length() - if len == 0 { return result } + if len == 0 { + return result + } let mut col = 0 while col < len { @@ -572,9 +593,7 @@ pub fn stockholm_merge_blocks(ali : StockholmAlignment) -> StockholmAlignment { while si < block.sequences.length() { let seq = block.sequences[si] match seq_map.get(seq.name) { - Some(sb) => { - sb.write_string(seq.aligned_seq) - } + Some(sb) => sb.write_string(seq.aligned_seq) None => { let sb = StringBuilder::new() sb.write_string(seq.aligned_seq) @@ -677,6 +696,7 @@ pub fn stockholm_merge_blocks(ali : StockholmAlignment) -> StockholmAlignment { // --- Internal helper functions --- +///| fn stockholm_filter_parts(parts : Array[String]) -> Array[String] { let result : Array[String] = Array::new() let mut i = 0 @@ -689,8 +709,11 @@ fn stockholm_filter_parts(parts : Array[String]) -> Array[String] { result } +///| fn stockholm_parse_sequence_line(line : String) -> StockholmSequence? { - if line.length() == 0 { return None } + if line.length() == 0 { + return None + } let sp = ' '.to_int().to_uint16() let mut space_pos = -1 @@ -703,7 +726,9 @@ fn stockholm_parse_sequence_line(line : String) -> StockholmSequence? { i = i + 1 } - if space_pos <= 0 { return None } + if space_pos <= 0 { + return None + } let name_part = line[0:space_pos].to_owned() let seq_part_start = space_pos + 1 @@ -713,7 +738,9 @@ fn stockholm_parse_sequence_line(line : String) -> StockholmSequence? { "" } - if seq_part.length() == 0 { return None } + if seq_part.length() == 0 { + return None + } let slash_pos = stockholm_find_slash(name_part) let (name, start, end) = if slash_pos >= 0 { @@ -721,7 +748,11 @@ fn stockholm_parse_sequence_line(line : String) -> StockholmSequence? { let range = name_part[slash_pos + 1:].to_owned() let dash_pos = stockholm_find_dash(range) if dash_pos >= 0 { - (n, parse_int(range[0:dash_pos].to_owned()), parse_int(range[dash_pos + 1:].to_owned())) + ( + n, + parse_int(range[0:dash_pos].to_owned()), + parse_int(range[dash_pos + 1:].to_owned()), + ) } else { (n, 1, parse_int(range)) } @@ -739,6 +770,7 @@ fn stockholm_parse_sequence_line(line : String) -> StockholmSequence? { }) } +///| fn stockholm_find_slash(s : String) -> Int { let mut i = 0 while i < s.length() { @@ -750,6 +782,7 @@ fn stockholm_find_slash(s : String) -> Int { -1 } +///| fn stockholm_find_dash(s : String) -> Int { let mut i = 0 while i < s.length() { @@ -761,6 +794,7 @@ fn stockholm_find_dash(s : String) -> Int { -1 } +///| fn stockholm_build_block( seqs : Array[StockholmSequence], gc : Map[String, String], @@ -782,6 +816,7 @@ fn stockholm_build_block( } } +///| fn stockholm_max_name_length(seqs : Array[StockholmSequence]) -> Int { let mut max_len = 0 let mut i = 0 @@ -795,6 +830,7 @@ fn stockholm_max_name_length(seqs : Array[StockholmSequence]) -> Int { max_len } +///| fn stockholm_display_name(seq : StockholmSequence) -> String { if seq.accession.length() > 0 { seq.accession @@ -824,4 +860,4 @@ pub fn sample_stockholm_content() -> String { /// Create a sample Stockholm alignment for testing. pub fn sample_stockholm_alignment() -> StockholmAlignment { stockholm_parse(sample_stockholm_content()) -} \ No newline at end of file +} diff --git a/src/structural_variant.mbt b/src/structural_variant.mbt index cad088c2..1b8916e4 100644 --- a/src/structural_variant.mbt +++ b/src/structural_variant.mbt @@ -118,9 +118,17 @@ pub fn SvBreakend::new( strand : String, mate_chrom : String, mate_pos : Int, - mate_strand : String + mate_strand : String, ) -> SvBreakend { - SvBreakend::{ chrom, pos, strand, mate_chrom, mate_pos, mate_strand, mate_id: "" } + SvBreakend::{ + chrom, + pos, + strand, + mate_chrom, + mate_pos, + mate_strand, + mate_id: "", + } } ///| @@ -202,9 +210,19 @@ pub fn SvRecord::new( svlen : Int, breakend : SvBreakend?, quality : Double, - filter : String + filter : String, ) -> SvRecord { - SvRecord::{ id, chrom, pos, sv_type, end: end_pos, svlen, breakend, quality, filter } + SvRecord::{ + id, + chrom, + pos, + sv_type, + end: end_pos, + svlen, + breakend, + quality, + filter, + } } ///| @@ -285,7 +303,7 @@ fn sv_trim(s : String) -> String { let n = s.length() let mut start = 0 while start < n { - let ch = s[start : start + 1] + let ch = s[start:start + 1] if ch == " " || ch == "\t" || ch == "\r" || ch == "\n" { start = start + 1 } else { @@ -294,7 +312,7 @@ fn sv_trim(s : String) -> String { } let mut end = n while end > start { - let ch = s[end - 1 : end] + let ch = s[end - 1:end] if ch == " " || ch == "\t" || ch == "\r" || ch == "\n" { end = end - 1 } else { @@ -310,7 +328,7 @@ fn sv_rfind(s : String, ch : String) -> Int? { let n = s.length() let mut i = n - 1 while i >= 0 { - if s[i : i + 1] == ch { + if s[i:i + 1] == ch { return Some(i) } i = i - 1 @@ -330,11 +348,7 @@ fn sv_rfind(s : String, ch : String) -> Int? { /// where `t` is the joining nucleotide and `p` is `chrom:pos`. /// /// Returns Some(SvBreakend) if parsing succeeds, None otherwise. -pub fn sv_parse_bnd_alt( - alt : String, - chrom : String, - pos : Int -) -> SvBreakend? { +pub fn sv_parse_bnd_alt(alt : String, chrom : String, pos : Int) -> SvBreakend? { let trimmed = sv_trim(alt) let n = trimmed.length() if n < 4 { @@ -345,7 +359,7 @@ pub fn sv_parse_bnd_alt( // Case 2: t]p] — starts with a base, then ], then chrom:pos, then ] // Case 3: ]p]t — starts with ], then chrom:pos, then ], then base // Case 4: [p[t — starts with [, then chrom:pos, then [, then base - let first = trimmed[0 : 1] + let first = trimmed[0:1] if first == "[" || first == "]" { // Case 3 or 4: ]p]t or [p[t let open_bracket = first @@ -353,7 +367,7 @@ pub fn sv_parse_bnd_alt( // open_bracket is at index 0; search for the next occurrence starting at 1. let mut close_idx = -1 for k in 1.. (String, Int) { let colon_pos = sv_rfind(loc, ":") match colon_pos { Some(idx) => { - let chrom = loc[0 : idx].to_owned() - let pos_str = loc[idx + 1 :] + let chrom = loc[0:idx].to_owned() + let pos_str = loc[idx + 1:] let pos = match parse_double(pos_str.to_owned()) { Some(v) => v.to_int() None => 0 @@ -443,8 +457,8 @@ fn sv_parse_info(info : String) -> Map[String, String] { let eq_pos = field.find("=") match eq_pos { Some(idx) => { - let key = field[0 : idx].to_owned() - let value = field[idx + 1 :].to_owned() + let key = field[0:idx].to_owned() + let value = field[idx + 1:].to_owned() result[key] = value } None => result[field.to_owned()] = "true" @@ -472,7 +486,7 @@ pub fn sv_parse_vcf_line(line : String) -> SvRecord? { return None } // Skip header lines. - if trimmed[0 : 1] == "#" { + if trimmed[0:1] == "#" { return None } let fields = trimmed.split("\t").to_array() @@ -523,7 +537,9 @@ pub fn sv_parse_vcf_line(line : String) -> SvRecord? { None } Some( - SvRecord::new(id, chrom, pos, sv_type, end_pos, svlen, breakend, quality, filter), + SvRecord::new( + id, chrom, pos, sv_type, end_pos, svlen, breakend, quality, filter, + ), ) } @@ -560,7 +576,7 @@ pub fn sv_find_partners(records : Array[SvRecord]) -> Array[(String, String)] { } let ri = records[i] match ri.breakend { - Some(bi) => { + Some(bi) => // Look for a record j whose chrom/pos matches bi's mate location. for j in (i + 1).. Array[(String, String)] { } let rj = records[j] match rj.breakend { - Some(bj) => { + Some(bj) => // Check if i's mate matches j's location and vice versa. if bi.mate_chrom == rj.chrom && bi.mate_pos == rj.pos && @@ -579,11 +595,9 @@ pub fn sv_find_partners(records : Array[SvRecord]) -> Array[(String, String)] { matched[j] = true break } - } None => continue } } - } None => continue } } @@ -625,7 +639,7 @@ pub fn SvGeneRegion::new( chrom : String, start : Int, end : Int, - strand : String + strand : String, ) -> SvGeneRegion { SvGeneRegion::{ gene, chrom, start, end, strand } } @@ -662,7 +676,7 @@ fn SvGeneRegion::overlaps( self : SvGeneRegion, qchrom : String, qstart : Int, - qend : Int + qend : Int, ) -> Bool { self.chrom == qchrom && self.start <= qend && self.end >= qstart } @@ -682,7 +696,7 @@ pub struct SvAnnotation { /// Construct an SvAnnotation. pub fn SvAnnotation::new( record : SvRecord, - genes : Array[String] + genes : Array[String], ) -> SvAnnotation { SvAnnotation::{ record, genes } } @@ -711,7 +725,7 @@ pub fn SvAnnotation::has_gene_overlap(self : SvAnnotation) -> Bool { /// are listed in the annotation. pub fn sv_annotate( records : Array[SvRecord], - genes : Array[SvGeneRegion] + genes : Array[SvGeneRegion], ) -> Array[SvAnnotation] { let annotations : Array[SvAnnotation] = Array::new() for rec in records { @@ -733,7 +747,7 @@ pub fn sv_annotate( } // Also check mate chromosome for BND records. match rec.breakend { - Some(b) => { + Some(b) => if b.mate_chrom.length() > 0 && b.mate_chrom != sv_chrom { for gene in genes { if gene.chrom == b.mate_chrom && @@ -744,7 +758,6 @@ pub fn sv_annotate( } } } - } None => () } annotations.push(SvAnnotation::new(rec, overlapping)) @@ -761,7 +774,7 @@ pub fn sv_annotate( /// quality >= min_qual. pub fn sv_filter_by_quality( records : Array[SvRecord], - min_qual : Double + min_qual : Double, ) -> Array[SvRecord] { let result : Array[SvRecord] = Array::new() for rec in records { @@ -777,7 +790,7 @@ pub fn sv_filter_by_quality( /// size >= min_size. BND/TRA records (size 0) are always excluded. pub fn sv_filter_by_size( records : Array[SvRecord], - min_size : Int + min_size : Int, ) -> Array[SvRecord] { let result : Array[SvRecord] = Array::new() for rec in records { @@ -792,7 +805,7 @@ pub fn sv_filter_by_size( /// Filter SV records by type. Returns records matching the given type. pub fn sv_filter_by_type( records : Array[SvRecord], - t : SvType + t : SvType, ) -> Array[SvRecord] { let result : Array[SvRecord] = Array::new() for rec in records { @@ -809,9 +822,7 @@ pub fn sv_filter_by_type( ///| /// Count SV records by type. Returns a map from type label to count. -pub fn sv_count_by_type( - records : Array[SvRecord] -) -> Map[String, Int] { +pub fn sv_count_by_type(records : Array[SvRecord]) -> Map[String, Int] { let counts : Map[String, Int] = Map([], capacity=6) for rec in records { let label = sv_type_label(rec.sv_type) @@ -898,22 +909,15 @@ pub fn sv_annotation_summary(ann : SvAnnotation) -> String { pub fn sv_sample_vcf() -> String { let sb = StringBuilder::new() let lines = [ - "##fileformat=VCFv4.2", - "##fileDate=20260101", - "##ALT=", - "##ALT=", - "##ALT=", - "##ALT=", - "##ALT=", + "##fileformat=VCFv4.2", "##fileDate=20260101", "##ALT=", + "##ALT=", "##ALT=", + "##ALT=", "##ALT=", "##INFO=", - "##INFO=", - "##INFO=", - "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO", - "chr1\t1000\tsv_del_1\tA\t\t500.0\tPASS\tSVTYPE=DEL;END=2000;SVLEN=-1000", + "##INFO=", "##INFO=", + "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO", "chr1\t1000\tsv_del_1\tA\t\t500.0\tPASS\tSVTYPE=DEL;END=2000;SVLEN=-1000", "chr1\t3000\tsv_dup_1\tA\t\t450.0\tPASS\tSVTYPE=DUP;END=5000;SVLEN=2000", "chr2\t1500\tsv_inv_1\tA\t\t300.0\tPASS\tSVTYPE=INV;END=2500;SVLEN=1000", - "chr2\t4000\tsv_ins_1\tA\t\t200.0\tLOWQUAL\tSVTYPE=INS;SVLEN=500", - "chr1\t6000\tsv_bnd_1\tA\tA]chr2:7000]\t600.0\tPASS\tSVTYPE=BND", + "chr2\t4000\tsv_ins_1\tA\t\t200.0\tLOWQUAL\tSVTYPE=INS;SVLEN=500", "chr1\t6000\tsv_bnd_1\tA\tA]chr2:7000]\t600.0\tPASS\tSVTYPE=BND", "chr2\t7000\tsv_bnd_2\tA\tA]chr1:6000]\t600.0\tPASS\tSVTYPE=BND", ] for line in lines { diff --git a/src/structure_alignment.mbt b/src/structure_alignment.mbt index 707f5fab..b4aa9c88 100644 --- a/src/structure_alignment.mbt +++ b/src/structure_alignment.mbt @@ -38,7 +38,11 @@ pub struct SAResidue { ///| /// Create a new SAResidue. -pub fn SAResidue::new(resname : String, resseq : Int, ca_coord : SAPoint3D) -> SAResidue { +pub fn SAResidue::new( + resname : String, + resseq : Int, + ca_coord : SAPoint3D, +) -> SAResidue { SAResidue::{ resname, resseq, ca_coord } } @@ -51,7 +55,10 @@ pub struct SAStructure { ///| /// Create a new SAStructure. -pub fn SAStructure::new(id : String, residues : Array[SAResidue]) -> SAStructure { +pub fn SAStructure::new( + id : String, + residues : Array[SAResidue], +) -> SAStructure { SAStructure::{ id, residues } } @@ -72,21 +79,34 @@ pub fn SAAlignmentResult::new( aligned_residues : Array[Array[SAResidue?]], rmsd : Double, tm_score : Double, - aligned_length : Int + aligned_length : Int, ) -> SAAlignmentResult { - SAAlignmentResult::{ structure_ids, aligned_residues, rmsd, tm_score, aligned_length } + SAAlignmentResult::{ + structure_ids, + aligned_residues, + rmsd, + tm_score, + aligned_length, + } } ///| /// Calculate the RMSD between two aligned residue sets. -pub fn sa_calculate_rmsd(residues1 : Array[SAPoint3D], residues2 : Array[SAPoint3D]) -> Double { +pub fn sa_calculate_rmsd( + residues1 : Array[SAPoint3D], + residues2 : Array[SAPoint3D], +) -> Double { if residues1.length() == 0 || residues2.length() == 0 { return 0.0 } - - let len = if residues1.length() < residues2.length() { residues1.length() } else { residues2.length() } + + let len = if residues1.length() < residues2.length() { + residues1.length() + } else { + residues2.length() + } let mut sum_sq = 0.0 - + let mut i = 0 while i < len { let dx = residues1[i].x - residues2[i].x @@ -95,70 +115,88 @@ pub fn sa_calculate_rmsd(residues1 : Array[SAPoint3D], residues2 : Array[SAPoint sum_sq = sum_sq + dx * dx + dy * dy + dz * dz i = i + 1 } - + (sum_sq / len.to_double()).sqrt() } ///| /// Calculate the TM-score (Template Modeling score). -pub fn sa_calculate_tm_score(residues1 : Array[SAPoint3D], residues2 : Array[SAPoint3D], l_target : Int) -> Double { +pub fn sa_calculate_tm_score( + residues1 : Array[SAPoint3D], + residues2 : Array[SAPoint3D], + l_target : Int, +) -> Double { if residues1.length() == 0 || residues2.length() == 0 { return 0.0 } - - let len = if residues1.length() < residues2.length() { residues1.length() } else { residues2.length() } + + let len = if residues1.length() < residues2.length() { + residues1.length() + } else { + residues2.length() + } let d0 = if l_target >= 15 { 1.24 * @math.pow(l_target.to_double() - 15.0, 1.0 / 3.0) - 1.8 } else { 1.24 * @math.pow(15.0 - l_target.to_double(), 1.0 / 3.0) * 0.5 } - + let mut sum = 0.0 - + let mut i = 0 while i < len { let dist = residues1[i].distance(residues2[i]) - sum = sum + 1.0 / (1.0 + (dist / d0) * (dist / d0)) + sum = sum + 1.0 / (1.0 + dist / d0 * (dist / d0)) i = i + 1 } - + sum / len.to_double() } ///| /// Calculate the distance matrix between two structures. -pub fn sa_calculate_distance_matrix(struct1 : SAStructure, struct2 : SAStructure) -> Array[Array[Double]] { +pub fn sa_calculate_distance_matrix( + struct1 : SAStructure, + struct2 : SAStructure, +) -> Array[Array[Double]] { let len1 = struct1.residues.length() let len2 = struct2.residues.length() - + let matrix : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < len1 { let row : Array[Double] = Array::new() let mut j = 0 while j < len2 { - let dist = struct1.residues[i].ca_coord.distance(struct2.residues[j].ca_coord) + let dist = struct1.residues[i].ca_coord.distance( + struct2.residues[j].ca_coord, + ) row.push(dist) j = j + 1 } matrix.push(row) i = i + 1 } - + matrix } ///| /// Perform dynamic programming alignment between two structures. -pub fn sa_dp_alignment(struct1 : SAStructure, struct2 : SAStructure, gap_open? : Double = 5.0, gap_extend? : Double = 1.0) -> (Array[(Int, Int)], Double) { +pub fn sa_dp_alignment( + struct1 : SAStructure, + struct2 : SAStructure, + gap_open? : Double = 5.0, + gap_extend? : Double = 1.0, +) -> (Array[(Int, Int)], Double) { let dist_matrix = sa_calculate_distance_matrix(struct1, struct2) let len1 = struct1.residues.length() let len2 = struct2.residues.length() - + let score : Array[Array[Double]] = Array::new() let trace : Array[Array[Int]] = Array::new() - + let mut i = 0 while i <= len1 { let score_row : Array[Double] = Array::new() @@ -173,32 +211,32 @@ pub fn sa_dp_alignment(struct1 : SAStructure, struct2 : SAStructure, gap_open? : trace.push(trace_row) i = i + 1 } - + i = 1 while i <= len1 { - score[i].set(0, score[i-1][0] - gap_open) + score[i].set(0, score[i - 1][0] - gap_open) trace[i].set(0, 1) i = i + 1 } - + let mut j = 1 while j <= len2 { - score[0].set(j, score[0][j-1] - gap_open) + score[0].set(j, score[0][j - 1] - gap_open) trace[0].set(j, 2) j = j + 1 } - + i = 1 while i <= len1 { j = 1 while j <= len2 { - let gap_open1 = if trace[i-1][j] == 1 { gap_extend } else { gap_open } - let gap_open2 = if trace[i][j-1] == 2 { gap_extend } else { gap_open } - - let match_score = score[i-1][j-1] - dist_matrix[i-1][j-1] - let delete_score = score[i-1][j] - gap_open1 - let insert_score = score[i][j-1] - gap_open2 - + let gap_open1 = if trace[i - 1][j] == 1 { gap_extend } else { gap_open } + let gap_open2 = if trace[i][j - 1] == 2 { gap_extend } else { gap_open } + + let match_score = score[i - 1][j - 1] - dist_matrix[i - 1][j - 1] + let delete_score = score[i - 1][j] - gap_open1 + let insert_score = score[i][j - 1] - gap_open2 + if match_score >= delete_score && match_score >= insert_score { score[i].set(j, match_score) trace[i].set(j, 0) @@ -213,15 +251,15 @@ pub fn sa_dp_alignment(struct1 : SAStructure, struct2 : SAStructure, gap_open? : } i = i + 1 } - + let alignment : Array[(Int, Int)] = Array::new() i = len1 j = len2 - + while i > 0 && j > 0 { let t = trace[i][j] if t == 0 { - alignment.push((i-1, j-1)) + alignment.push((i - 1, j - 1)) i = i - 1 j = j - 1 } else if t == 1 { @@ -230,7 +268,7 @@ pub fn sa_dp_alignment(struct1 : SAStructure, struct2 : SAStructure, gap_open? : j = j - 1 } } - + let reversed : Array[(Int, Int)] = Array::new() let align_len = alignment.length() let mut k = 0 @@ -238,56 +276,65 @@ pub fn sa_dp_alignment(struct1 : SAStructure, struct2 : SAStructure, gap_open? : reversed.push(alignment[align_len - 1 - k]) k = k + 1 } - + (reversed, score[len1][len2]) } ///| /// Align two protein structures. -pub fn sa_align_two_structures(struct1 : SAStructure, struct2 : SAStructure) -> SAAlignmentResult { +pub fn sa_align_two_structures( + struct1 : SAStructure, + struct2 : SAStructure, +) -> SAAlignmentResult { let (alignment, _) = sa_dp_alignment(struct1, struct2) - + let coords1 : Array[SAPoint3D] = Array::new() let coords2 : Array[SAPoint3D] = Array::new() let aligned_residues : Array[Array[SAResidue?]] = Array::new() - + let align_len = alignment.length() let mut idx = 0 while idx < align_len { let pair = alignment[idx] let i = pair.0 let j = pair.1 - + coords1.push(struct1.residues[i].ca_coord) coords2.push(struct2.residues[j].ca_coord) - + let row : Array[SAResidue?] = Array::new() row.push(Some(struct1.residues[i])) row.push(Some(struct2.residues[j])) aligned_residues.push(row) - + idx = idx + 1 } - + let rmsd = sa_calculate_rmsd(coords1, coords2) - let tm_score = sa_calculate_tm_score(coords1, coords2, struct1.residues.length()) - + let tm_score = sa_calculate_tm_score( + coords1, + coords2, + struct1.residues.length(), + ) + SAAlignmentResult::new( [struct1.id, struct2.id], aligned_residues, rmsd, tm_score, - alignment.length() + alignment.length(), ) } ///| /// Perform multiple structure alignment using progressive approach. -pub fn sa_align_multiple_structures(structures : Array[SAStructure]) -> SAAlignmentResult { +pub fn sa_align_multiple_structures( + structures : Array[SAStructure], +) -> SAAlignmentResult { if structures.length() == 0 { return SAAlignmentResult::new([], [], 0.0, 0.0, 0) } - + if structures.length() == 1 { let aligned_residues : Array[Array[SAResidue?]] = Array::new() let mut i = 0 @@ -297,35 +344,50 @@ pub fn sa_align_multiple_structures(structures : Array[SAStructure]) -> SAAlignm aligned_residues.push(row) i = i + 1 } - return SAAlignmentResult::new([structures[0].id], aligned_residues, 0.0, 1.0, structures[0].residues.length()) + return SAAlignmentResult::new( + [structures[0].id], + aligned_residues, + 0.0, + 1.0, + structures[0].residues.length(), + ) } - - let mut current_alignment = sa_align_two_structures(structures[0], structures[1]) - + + let mut current_alignment = sa_align_two_structures( + structures[0], + structures[1], + ) + let mut k = 2 while k < structures.length() { - current_alignment = sa_align_structure_to_profile(current_alignment, structures[k]) + current_alignment = sa_align_structure_to_profile( + current_alignment, + structures[k], + ) k = k + 1 } - + current_alignment } ///| /// Align a structure to an existing alignment profile. -pub fn sa_align_structure_to_profile(alignment : SAAlignmentResult, structure : SAStructure) -> SAAlignmentResult { +pub fn sa_align_structure_to_profile( + alignment : SAAlignmentResult, + structure : SAStructure, +) -> SAAlignmentResult { let num_structures = alignment.structure_ids.length() let aligned_length = alignment.aligned_length - + let consensus_coords : Array[SAPoint3D] = Array::new() - + let mut i = 0 while i < aligned_length { let mut sum_x = 0.0 let mut sum_y = 0.0 let mut sum_z = 0.0 let mut count = 0 - + let mut j = 0 while j < num_structures { match alignment.aligned_residues[i][j] { @@ -335,45 +397,58 @@ pub fn sa_align_structure_to_profile(alignment : SAAlignmentResult, structure : sum_z = sum_z + res.ca_coord.z count = count + 1 } - None => ignore({ () }) + None => ignore(()) } j = j + 1 } - + if count > 0 { - consensus_coords.push(SAPoint3D::new(sum_x / count.to_double(), sum_y / count.to_double(), sum_z / count.to_double())) + consensus_coords.push( + SAPoint3D::new( + sum_x / count.to_double(), + sum_y / count.to_double(), + sum_z / count.to_double(), + ), + ) } i = i + 1 } - - let consensus_struct = SAStructure::new("consensus", sa_residues_from_coords(consensus_coords)) - + + let consensus_struct = SAStructure::new( + "consensus", + sa_residues_from_coords(consensus_coords), + ) + let (new_alignment, _) = sa_dp_alignment(consensus_struct, structure) - + let new_aligned_residues : Array[Array[SAResidue?]] = Array::new() - + let new_align_len = new_alignment.length() let mut idx = 0 while idx < new_align_len { let pair = new_alignment[idx] let i = pair.0 let j = pair.1 - + let row : Array[SAResidue?] = Array::new() - + let mut k = 0 while k < num_structures { - let val = if i < alignment.aligned_length { alignment.aligned_residues[i][k] } else { None } + let val = if i < alignment.aligned_length { + alignment.aligned_residues[i][k] + } else { + None + } row.push(val) k = k + 1 } - + row.push(Some(structure.residues[j])) new_aligned_residues.push(row) - + idx = idx + 1 } - + let new_ids : Array[String] = Array::new() let mut m = 0 while m < alignment.structure_ids.length() { @@ -381,51 +456,63 @@ pub fn sa_align_structure_to_profile(alignment : SAAlignmentResult, structure : m = m + 1 } new_ids.push(structure.id) - + let coords1 : Array[SAPoint3D] = Array::new() let coords2 : Array[SAPoint3D] = Array::new() - + idx = 0 while idx < new_align_len { let pair = new_alignment[idx] let i = pair.0 let j = pair.1 - + if i < consensus_coords.length() { coords1.push(consensus_coords[i]) } coords2.push(structure.residues[j].ca_coord) - + idx = idx + 1 } - + let rmsd = sa_calculate_rmsd(coords1, coords2) - let tm_score = sa_calculate_tm_score(coords1, coords2, consensus_struct.residues.length()) - - SAAlignmentResult::new(new_ids, new_aligned_residues, rmsd, tm_score, new_alignment.length()) + let tm_score = sa_calculate_tm_score( + coords1, + coords2, + consensus_struct.residues.length(), + ) + + SAAlignmentResult::new( + new_ids, + new_aligned_residues, + rmsd, + tm_score, + new_alignment.length(), + ) } ///| /// Create residues from coordinates. pub fn sa_residues_from_coords(coords : Array[SAPoint3D]) -> Array[SAResidue] { let residues : Array[SAResidue] = Array::new() - + let mut i = 0 while i < coords.length() { residues.push(SAResidue::new("XXX", i + 1, coords[i])) i = i + 1 } - + residues } ///| /// Calculate pairwise RMSD matrix for multiple structures. -pub fn sa_calculate_pairwise_rmsd(structures : Array[SAStructure]) -> Array[Array[Double]] { +pub fn sa_calculate_pairwise_rmsd( + structures : Array[SAStructure], +) -> Array[Array[Double]] { let n = structures.length() - + let matrix : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let row : Array[Double] = Array::new() @@ -442,31 +529,47 @@ pub fn sa_calculate_pairwise_rmsd(structures : Array[SAStructure]) -> Array[Arra matrix.push(row) i = i + 1 } - + matrix } ///| /// Bio API functions. - -pub fn bio_structure_align_two(struct1 : SAStructure, struct2 : SAStructure) -> SAAlignmentResult { +pub fn bio_structure_align_two( + struct1 : SAStructure, + struct2 : SAStructure, +) -> SAAlignmentResult { sa_align_two_structures(struct1, struct2) } -pub fn bio_structure_align_multiple(structures : Array[SAStructure]) -> SAAlignmentResult { +///| +pub fn bio_structure_align_multiple( + structures : Array[SAStructure], +) -> SAAlignmentResult { sa_align_multiple_structures(structures) } -pub fn bio_structure_calculate_rmsd(struct1 : SAStructure, struct2 : SAStructure) -> Double { +///| +pub fn bio_structure_calculate_rmsd( + struct1 : SAStructure, + struct2 : SAStructure, +) -> Double { let alignment = sa_align_two_structures(struct1, struct2) alignment.rmsd } -pub fn bio_structure_calculate_tm_score(struct1 : SAStructure, struct2 : SAStructure) -> Double { +///| +pub fn bio_structure_calculate_tm_score( + struct1 : SAStructure, + struct2 : SAStructure, +) -> Double { let alignment = sa_align_two_structures(struct1, struct2) alignment.tm_score } -pub fn bio_structure_pairwise_rmsd(structures : Array[SAStructure]) -> Array[Array[Double]] { +///| +pub fn bio_structure_pairwise_rmsd( + structures : Array[SAStructure], +) -> Array[Array[Double]] { sa_calculate_pairwise_rmsd(structures) -} \ No newline at end of file +} diff --git a/src/substitution_matrices.mbt b/src/substitution_matrices.mbt index 22f57202..40abdc6e 100644 --- a/src/substitution_matrices.mbt +++ b/src/substitution_matrices.mbt @@ -23,8 +23,8 @@ /// Standard 20 amino acid alphabet (IUPAC protein, sorted). pub fn subs_protein_alphabet() -> Array[String] { [ - "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", - "M", "N", "P", "Q", "R", "S", "T", "V", "W", "Y", + "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", "M", "N", "P", "Q", "R", "S", + "T", "V", "W", "Y", ] } @@ -42,8 +42,8 @@ pub fn subs_nucleotide_alphabet() -> Array[String] { /// A 2D numeric array with row and column labels. /// Used internally by SubsMatrix for score storage. pub struct ArrayData { - pub rows : Array[String] // row labels - pub cols : Array[String] // column labels + pub rows : Array[String] // row labels + pub cols : Array[String] // column labels pub data : Array[Array[Double]] // row x col values } @@ -60,39 +60,58 @@ pub fn array_data_from_dict( let data : Array[Array[Double]] = [] for _i in 0..= 0 && ci >= 0 { + data[ri][ci] = v } - if ri >= 0 && ci >= 0 { data[ri][ci] = v } pi = pi + 1 } - { rows: rows, cols: cols, data: data } + { rows, cols, data } } ///| /// Get a value from ArrayData by row and column index. pub fn ArrayData::get(self : ArrayData, i : Int, j : Int) -> Double { - if i < 0 || i >= self.rows.length() || j < 0 || j >= self.cols.length() { 0.0 } - else { self.data[i][j] } + if i < 0 || i >= self.rows.length() || j < 0 || j >= self.cols.length() { + 0.0 + } else { + self.data[i][j] + } } ///| @@ -105,16 +124,30 @@ pub fn ArrayData::set(self : ArrayData, i : Int, j : Int, v : Double) -> Unit { ///| /// Get a value by row and column labels. -pub fn ArrayData::get_by_label(self : ArrayData, row : String, col : String) -> Double { +pub fn ArrayData::get_by_label( + self : ArrayData, + row : String, + col : String, +) -> Double { let mut ri = -1 for k in 0.. pub struct SubsMatrix { name : String alphabet : Array[String] - matrix : ArrayData // symmetric for protein matrices + matrix : ArrayData // symmetric for protein matrices n_letters : Int } @@ -138,12 +171,7 @@ pub fn subs_matrix( alphabet : Array[String], matrix : ArrayData, ) -> SubsMatrix { - { - name: name, - alphabet: alphabet, - matrix: matrix, - n_letters: alphabet.length(), - } + { name, alphabet, matrix, n_letters: alphabet.length() } } ///| @@ -169,11 +197,7 @@ pub fn SubsMatrix::get_score( ///| /// Get the score by index (both 0-based positions in the alphabet). -pub fn SubsMatrix::get_score_idx( - self : SubsMatrix, - i : Int, - j : Int, -) -> Double { +pub fn SubsMatrix::get_score_idx(self : SubsMatrix, i : Int, j : Int) -> Double { self.matrix.get(i, j) } @@ -246,6 +270,8 @@ pub fn SubsMatrix::to_table_string(self : SubsMatrix) -> String { ///| /// Registry of named matrices. Stores (name, matrix) pairs. let registry_keys : Ref[Array[String]] = Ref::new([]) + +///| let registry_matrices : Ref[Array[SubsMatrix]] = Ref::new([]) ///| @@ -268,7 +294,9 @@ pub fn register_matrix(name : String, matrix : SubsMatrix) -> Unit { pub fn load_matrix(name : String) -> SubsMatrix? { let keys = registry_keys.val for i in 0.. index map let letter_keys : Array[String] = [] let letter_vals : Array[Int] = [] - for i in 0..= seq_i.length() || pos >= seq_j.length() { continue } + if pos >= seq_i.length() || pos >= seq_j.length() { + continue + } let ci = seq_i[pos:pos + 1].to_owned() let cj = seq_j[pos:pos + 1].to_owned() // Skip gaps - if ci == "-" || cj == "-" { continue } + if ci == "-" || cj == "-" { + continue + } let mut ri = -1 for k in 0..= 0 && rj >= 0 { data[ri][rj] = data[ri][rj] + 1.0 @@ -486,7 +531,7 @@ pub fn calculate_frequency_matrix( } } } - { rows: alphabet, cols: alphabet, data: data } + { rows: alphabet, cols: alphabet, data } } // ============================================================================ @@ -517,7 +562,9 @@ pub fn calculate_substitution_matrix( // Step 2: Calculate total pair count and letter frequencies let mut total_pairs = 0.0 let letter_counts : Array[Double] = [] - for _i in 0.. Double { total = total + freq_matrix.data[i][j] } } - if total < 1.0e-12 { return 0.0 } + if total < 1.0e-12 { + return 0.0 + } let mut entropy = 0.0 for i in 0.. Double { let n = freq_matrix.rows.length() let mut total = 0.0 let letter_counts : Array[Double] = [] - for _i in 0.. SubsMatrix? { let data_rows : Array[(String, Array[Double])] = [] for line in lines { let trimmed = line.trim() - if trimmed.length() == 0 { continue } - if trimmed[0] == '#' { continue } - let parts = trimmed.split(" ").to_array().filter(fn (s) -> Bool { - s.length() > 0 - }) - if parts.length() == 0 { continue } + if trimmed.length() == 0 { + continue + } + if trimmed[0] == '#' { + continue + } + let parts = trimmed + .split(" ") + .to_array() + .filter(fn(s) -> Bool { s.length() > 0 }) + if parts.length() == 0 { + continue + } if alphabet.length() == 0 && parts[0].length() == 0 { // This might be the header line for p in parts { - if p.length() == 1 { alphabet.push(p.to_string()) } + if p.length() == 1 { + alphabet.push(p.to_string()) + } } continue } @@ -647,7 +709,9 @@ pub fn parse_ncbi_matrix(content : String) -> SubsMatrix? { if alphabet.length() == 0 { // First non-comment line is the header for p in parts { - if p.length() >= 1 { alphabet.push(p.to_string()) } + if p.length() >= 1 { + alphabet.push(p.to_string()) + } } continue } @@ -666,9 +730,11 @@ pub fn parse_ncbi_matrix(content : String) -> SubsMatrix? { } } } - if alphabet.length() == 0 || data_rows.length() == 0 { return None } + if alphabet.length() == 0 || data_rows.length() == 0 { + return None + } // Build the matrix - let row_labels = data_rows.map(fn (r) -> String { r.0 }) + let row_labels = data_rows.map(fn(r) -> String { r.0 }) let pairs : Array[(String, String, Double)] = [] let mut dri = 0 while dri < data_rows.length() { @@ -695,11 +761,18 @@ pub fn matrix_correlation(m1 : SubsMatrix, m2 : SubsMatrix) -> Double { for letter in m1.alphabet { let mut found = false for l2 in m2.alphabet { - if l2 == letter { found = true; break } + if l2 == letter { + found = true + break + } + } + if found { + common.push(letter) } - if found { common.push(letter) } } - if common.length() < 2 { return 0.0 } + if common.length() < 2 { + return 0.0 + } // Collect paired scores let v1 : Array[Double] = [] let v2 : Array[Double] = [] @@ -713,7 +786,10 @@ pub fn matrix_correlation(m1 : SubsMatrix, m2 : SubsMatrix) -> Double { let n = v1.length() let mut sum1 = 0.0 let mut sum2 = 0.0 - for i in 0.. Double { var2 = var2 + d2 * d2 } let denom = (var1 * var2).sqrt() - if denom < 1.0e-12 { 0.0 } else { cov / denom } + if denom < 1.0e-12 { + 0.0 + } else { + cov / denom + } } // ============================================================================ // BLOSUM62 raw scores (20x20, row-major, alphabet order: ACDEFGHIKLMNPQRSTVWY) // ============================================================================ +///| fn blosum62_scores() -> Array[Int] { [ // A C D E F G H I K L M N P Q R S T V W Y - 4, 0, -2, -1, -2, 0, -2, -1, -1, -1, -1, -2, -1, -1, -1, 1, 0, 0, -3, -2, // A - 0, 9, -3, -4, -2, -3, -3, -1, -3, -1, -1, -3, -3, -3, -3, -1, -1, -1, -2, -2, // C - -2, -3, 6, 2, -3, -1, -1, -3, -1, -4, -3, 1, -1, 0, -2, 0, -1, -3, -4, -3, // D - -1, -4, 2, 5, -3, -2, 0, -3, 1, -3, -2, 0, -1, 2, 0, 0, -1, -2, -3, -2, // E - -2, -2, -3, -3, 6, -3, -1, 0, -3, 0, 0, -3, -4, -3, -3, -2, -2, -1, 1, 3, // F - 0, -3, -1, -2, -3, 6, -2, -4, -2, -4, -3, 0, -2, -2, -2, 0, -2, -3, -2, -3, // G - -2, -3, -1, 0, -1, -2, 8, -3, -1, -3, -2, 1, -2, 0, 0, -1, -2, -3, -2, 2, // H - -1, -1, -3, -3, 0, -4, -3, 4, -3, 2, 1, -3, -3, -3, -3, -2, -1, 3, -3, -1, // I - -1, -3, -1, 1, -3, -2, -1, -3, 5, -2, -1, 0, -1, 1, 2, 0, -1, -2, -3, -2, // K - -1, -1, -4, -3, 0, -4, -3, 2, -2, 4, 2, -3, -3, -2, -2, -2, -1, 1, -2, -1, // L - -1, -1, -3, -2, 0, -3, -2, 1, -1, 2, 5, -2, -2, 0, -1, -1, -1, 1, -1, -1, // M - -2, -3, 1, 0, -3, 0, 1, -3, 0, -3, -2, 6, -2, 0, 0, 1, 0, -3, -4, -2, // N - -1, -3, -1, -1, -4, -2, -2, -3, -1, -3, -2, -2, 7, -1, -2, -1, -1, -2, -4, -3, // P - -1, -3, 0, 2, -3, -2, 0, -3, 1, -2, 0, 0, -1, 5, 1, 0, -1, -2, -2, -1, // Q - -1, -3, -2, 0, -3, -2, 0, -3, 2, -2, -1, 0, -2, 1, 5, -1, -1, -3, -3, -2, // R - 1, -1, 0, 0, -2, 0, -1, -2, 0, -2, -1, 1, -1, 0, -1, 4, 1, -2, -3, -2, // S - 0, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -1, -1, -1, 1, 5, 0, -2, -2, // T - 0, -1, -3, -2, -1, -3, -3, 3, -2, 1, 1, -3, -2, -2, -3, -2, 0, 4, -3, -1, // V - -3, -2, -4, -3, 1, -2, -2, -3, -3, -2, -1, -4, -4, -2, -3, -3, -2, -3, 11, 2, // W - -2, -2, -3, -2, 3, -3, 2, -1, -2, -1, -1, -2, -3, -1, -2, -2, -2, -1, 2, 7, // Y + 4, 0, -2, -1, -2, 0, -2, -1, -1, -1, -1, -2, -1, -1, -1, 1, 0, 0, -3, -2, // A + 0, 9, -3, -4, -2, -3, -3, -1, -3, -1, -1, -3, -3, -3, -3, -1, -1, -1, -2, -2, // C + -2, -3, 6, 2, -3, -1, -1, -3, -1, -4, -3, 1, -1, 0, -2, 0, -1, -3, -4, -3, // D + -1, -4, 2, 5, -3, -2, 0, -3, 1, -3, -2, 0, -1, 2, 0, 0, -1, -2, -3, -2, // E + -2, -2, -3, -3, 6, -3, -1, 0, -3, 0, 0, -3, -4, -3, -3, -2, -2, -1, 1, 3, // F + 0, -3, -1, -2, -3, 6, -2, -4, -2, -4, -3, 0, -2, -2, -2, 0, -2, -3, -2, -3, // G + -2, -3, -1, 0, -1, -2, 8, -3, -1, -3, -2, 1, -2, 0, 0, -1, -2, -3, -2, 2, // H + -1, -1, -3, -3, 0, -4, -3, 4, -3, 2, 1, -3, -3, -3, -3, -2, -1, 3, -3, -1, // I + -1, -3, -1, 1, -3, -2, -1, -3, 5, -2, -1, 0, -1, 1, 2, 0, -1, -2, -3, -2, // K + -1, -1, -4, -3, 0, -4, -3, 2, -2, 4, 2, -3, -3, -2, -2, -2, -1, 1, -2, -1, // L + -1, -1, -3, -2, 0, -3, -2, 1, -1, 2, 5, -2, -2, 0, -1, -1, -1, 1, -1, -1, // M + -2, -3, 1, 0, -3, 0, 1, -3, 0, -3, -2, 6, -2, 0, 0, 1, 0, -3, -4, -2, // N + -1, -3, -1, -1, -4, -2, -2, -3, -1, -3, -2, -2, 7, -1, -2, -1, -1, -2, -4, -3, // P + -1, -3, 0, 2, -3, -2, 0, -3, 1, -2, 0, 0, -1, 5, 1, 0, -1, -2, -2, -1, // Q + -1, -3, -2, 0, -3, -2, 0, -3, 2, -2, -1, 0, -2, 1, 5, -1, -1, -3, -3, -2, // R + 1, -1, 0, 0, -2, 0, -1, -2, 0, -2, -1, 1, -1, 0, -1, 4, 1, -2, -3, -2, // S + 0, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -1, -1, -1, 1, 5, 0, -2, -2, // T + 0, -1, -3, -2, -1, -3, -3, 3, -2, 1, 1, -3, -2, -2, -3, -2, 0, 4, -3, -1, // V + -3, -2, -4, -3, 1, -2, -2, -3, -3, -2, -1, -4, -4, -2, -3, -3, -2, -3, 11, 2, // W + -2, -2, -3, -2, 3, -3, 2, -1, -2, -1, -1, -2, -3, -1, -2, -2, -2, -1, 2, 7, // Y ] } @@ -764,28 +845,28 @@ fn blosum62_scores() -> Array[Int] { // BLOSUM45 raw scores (20x20) // ============================================================================ +///| fn blosum45_scores() -> Array[Int] { [ - 5, -1, -2, -1, -2, 0, -2, -1, -1, -1, -1, -2, -1, -1, -1, 1, 0, 0, -3, -2, - -1, 12, -5, -5, -4, -3, -3, -2, -5, -2, -2, -4, -4, -4, -4, -1, -1, -1, -5, -4, - -2, -5, 7, 2, -4, -1, 0, -4, 0, -4, -3, 2, -1, 0, -1, 0, -1, -3, -5, -3, - -1, -5, 2, 6, -4, -2, 0, -3, 1, -3, -2, 0, -1, 2, 0, 0, -1, -2, -4, -2, - -2, -4, -4, -4, 8, -3, -1, 0, -3, 0, 0, -3, -4, -3, -3, -2, -2, -1, 0, 3, - 0, -3, -1, -2, -3, 7, -2, -3, -2, -3, -2, 0, -2, -2, -2, 0, -2, -3, -3, -3, - -2, -3, 0, 0, -1, -2, 10, -3, -1, -3, -2, 1, -2, 0, 0, -1, -2, -3, -2, 2, - -1, -2, -4, -3, 0, -3, -3, 5, -3, 2, 1, -3, -3, -3, -3, -2, -1, 3, -2, -1, - -1, -5, 0, 1, -3, -2, -1, -3, 5, -3, -1, 0, -1, 1, 3, 0, -1, -3, -4, -2, - -1, -2, -4, -3, 0, -3, -3, 2, -3, 5, 2, -3, -3, -2, -2, -2, -1, 1, -2, -1, - -1, -2, -3, -2, 0, -2, -2, 1, -1, 2, 6, -2, -2, 0, -1, -1, -1, 1, -1, -1, - -2, -4, 2, 0, -3, 0, 1, -3, 0, -3, -2, 6, -2, 0, 0, 1, 0, -3, -4, -2, - -1, -4, -1, -1, -4, -2, -2, -3, -1, -3, -2, -2, 9, -1, -2, -1, -1, -2, -5, -3, - -1, -4, 0, 2, -3, -2, 0, -3, 1, -2, 0, 0, -1, 6, 1, 0, -1, -2, -3, -1, - -1, -4, -1, 0, -3, -2, 0, -3, 3, -2, -1, 0, -2, 1, 6, -1, -1, -3, -3, -2, - 1, -1, 0, 0, -2, 0, -1, -2, 0, -2, -1, 1, -1, 0, -1, 4, 1, -2, -3, -2, - 0, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -1, -1, -1, 1, 5, 0, -3, -2, - 0, -1, -3, -2, -1, -3, -3, 3, -3, 1, 1, -3, -2, -2, -3, -2, 0, 4, -2, -1, - -3, -5, -5, -4, 0, -3, -2, -2, -4, -2, -1, -4, -5, -3, -3, -3, -3, -2, 14, 2, - -2, -4, -3, -2, 3, -3, 2, -1, -2, -1, -1, -2, -3, -1, -2, -2, -2, -1, 2, 8, + 5, -1, -2, -1, -2, 0, -2, -1, -1, -1, -1, -2, -1, -1, -1, 1, 0, 0, -3, -2, -1, + 12, -5, -5, -4, -3, -3, -2, -5, -2, -2, -4, -4, -4, -4, -1, -1, -1, -5, -4, -2, + -5, 7, 2, -4, -1, 0, -4, 0, -4, -3, 2, -1, 0, -1, 0, -1, -3, -5, -3, -1, -5, + 2, 6, -4, -2, 0, -3, 1, -3, -2, 0, -1, 2, 0, 0, -1, -2, -4, -2, -2, -4, -4, -4, + 8, -3, -1, 0, -3, 0, 0, -3, -4, -3, -3, -2, -2, -1, 0, 3, 0, -3, -1, -2, -3, + 7, -2, -3, -2, -3, -2, 0, -2, -2, -2, 0, -2, -3, -3, -3, -2, -3, 0, 0, -1, -2, + 10, -3, -1, -3, -2, 1, -2, 0, 0, -1, -2, -3, -2, 2, -1, -2, -4, -3, 0, -3, -3, + 5, -3, 2, 1, -3, -3, -3, -3, -2, -1, 3, -2, -1, -1, -5, 0, 1, -3, -2, -1, -3, + 5, -3, -1, 0, -1, 1, 3, 0, -1, -3, -4, -2, -1, -2, -4, -3, 0, -3, -3, 2, -3, + 5, 2, -3, -3, -2, -2, -2, -1, 1, -2, -1, -1, -2, -3, -2, 0, -2, -2, 1, -1, 2, + 6, -2, -2, 0, -1, -1, -1, 1, -1, -1, -2, -4, 2, 0, -3, 0, 1, -3, 0, -3, -2, 6, + -2, 0, 0, 1, 0, -3, -4, -2, -1, -4, -1, -1, -4, -2, -2, -3, -1, -3, -2, -2, 9, + -1, -2, -1, -1, -2, -5, -3, -1, -4, 0, 2, -3, -2, 0, -3, 1, -2, 0, 0, -1, 6, + 1, 0, -1, -2, -3, -1, -1, -4, -1, 0, -3, -2, 0, -3, 3, -2, -1, 0, -2, 1, 6, -1, + -1, -3, -3, -2, 1, -1, 0, 0, -2, 0, -1, -2, 0, -2, -1, 1, -1, 0, -1, 4, 1, -2, + -3, -2, 0, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -1, -1, -1, 1, 5, 0, -3, + -2, 0, -1, -3, -2, -1, -3, -3, 3, -3, 1, 1, -3, -2, -2, -3, -2, 0, 4, -2, -1, + -3, -5, -5, -4, 0, -3, -2, -2, -4, -2, -1, -4, -5, -3, -3, -3, -3, -2, 14, 2, + -2, -4, -3, -2, 3, -3, 2, -1, -2, -1, -1, -2, -3, -1, -2, -2, -2, -1, 2, 8, ] } @@ -793,28 +874,28 @@ fn blosum45_scores() -> Array[Int] { // BLOSUM80 raw scores (20x20) // ============================================================================ +///| fn blosum80_scores() -> Array[Int] { [ - 7, -1, -2, -1, -2, 0, -2, -1, -1, -1, -1, -2, -1, -1, -1, 2, 1, 0, -4, -3, - -1, 13, -5, -5, -3, -4, -4, -2, -4, -2, -2, -4, -5, -4, -4, -1, -1, -1, -5, -3, - -2, -5, 9, 2, -5, -2, -1, -4, -1, -5, -4, 2, -2, 1, -2, 0, -1, -4, -6, -4, - -1, -5, 2, 8, -5, -3, 0, -4, 2, -4, -3, 0, -2, 3, 0, 0, -1, -3, -5, -3, - -2, -3, -5, -5, 9, -4, -1, 0, -4, 0, 0, -4, -5, -4, -4, -2, -2, -1, 1, 4, - 0, -4, -2, -3, -4, 9, -3, -5, -2, -5, -4, 0, -3, -3, -3, 0, -2, -4, -4, -4, - -2, -4, -1, 0, -1, -3, 12, -4, -1, -4, -3, 1, -3, 0, 0, -1, -2, -4, -3, 2, - -1, -2, -4, -4, 0, -5, -4, 6, -3, 2, 1, -4, -3, -3, -3, -2, -1, 3, -4, -2, - -1, -4, -1, 2, -4, -2, -1, -3, 8, -3, -1, 0, -2, 2, 3, 0, -1, -3, -5, -3, - -1, -2, -5, -4, 0, -5, -4, 2, -3, 6, 3, -4, -3, -3, -3, -2, -1, 1, -3, -1, - -1, -2, -4, -3, 0, -4, -3, 1, -1, 3, 8, -3, -3, 0, -1, -1, -1, 1, -2, -1, - -2, -4, 2, 0, -4, 0, 1, -4, 0, -4, -3, 8, -2, 0, 0, 1, 0, -4, -5, -3, - -1, -5, -2, -2, -5, -3, -3, -3, -2, -3, -3, -2, 11, -2, -3, -2, -2, -3, -6, -4, - -1, -4, 1, 3, -4, -3, 0, -3, 2, -3, 0, 0, -2, 8, 1, 0, -1, -3, -3, -2, - -1, -4, -2, 0, -4, -3, 0, -3, 3, -3, -1, 0, -3, 1, 8, -1, -1, -4, -4, -2, - 2, -1, 0, 0, -2, 0, -1, -2, 0, -2, -1, 1, -2, 0, -1, 7, 2, -2, -4, -3, - 1, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -2, -1, -1, 2, 7, 0, -4, -2, - 0, -1, -4, -3, -1, -4, -4, 3, -3, 1, 1, -4, -3, -3, -4, -2, 0, 6, -4, -2, - -4, -5, -6, -5, 1, -4, -3, -4, -5, -3, -2, -5, -6, -3, -4, -4, -4, -4, 15, 3, - -3, -3, -4, -3, 4, -4, 2, -2, -3, -1, -1, -3, -4, -2, -2, -3, -2, -2, 3, 9, + 7, -1, -2, -1, -2, 0, -2, -1, -1, -1, -1, -2, -1, -1, -1, 2, 1, 0, -4, -3, -1, + 13, -5, -5, -3, -4, -4, -2, -4, -2, -2, -4, -5, -4, -4, -1, -1, -1, -5, -3, -2, + -5, 9, 2, -5, -2, -1, -4, -1, -5, -4, 2, -2, 1, -2, 0, -1, -4, -6, -4, -1, -5, + 2, 8, -5, -3, 0, -4, 2, -4, -3, 0, -2, 3, 0, 0, -1, -3, -5, -3, -2, -3, -5, -5, + 9, -4, -1, 0, -4, 0, 0, -4, -5, -4, -4, -2, -2, -1, 1, 4, 0, -4, -2, -3, -4, + 9, -3, -5, -2, -5, -4, 0, -3, -3, -3, 0, -2, -4, -4, -4, -2, -4, -1, 0, -1, -3, + 12, -4, -1, -4, -3, 1, -3, 0, 0, -1, -2, -4, -3, 2, -1, -2, -4, -4, 0, -5, -4, + 6, -3, 2, 1, -4, -3, -3, -3, -2, -1, 3, -4, -2, -1, -4, -1, 2, -4, -2, -1, -3, + 8, -3, -1, 0, -2, 2, 3, 0, -1, -3, -5, -3, -1, -2, -5, -4, 0, -5, -4, 2, -3, + 6, 3, -4, -3, -3, -3, -2, -1, 1, -3, -1, -1, -2, -4, -3, 0, -4, -3, 1, -1, 3, + 8, -3, -3, 0, -1, -1, -1, 1, -2, -1, -2, -4, 2, 0, -4, 0, 1, -4, 0, -4, -3, 8, + -2, 0, 0, 1, 0, -4, -5, -3, -1, -5, -2, -2, -5, -3, -3, -3, -2, -3, -3, -2, 11, + -2, -3, -2, -2, -3, -6, -4, -1, -4, 1, 3, -4, -3, 0, -3, 2, -3, 0, 0, -2, 8, + 1, 0, -1, -3, -3, -2, -1, -4, -2, 0, -4, -3, 0, -3, 3, -3, -1, 0, -3, 1, 8, -1, + -1, -4, -4, -2, 2, -1, 0, 0, -2, 0, -1, -2, 0, -2, -1, 1, -2, 0, -1, 7, 2, -2, + -4, -3, 1, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -2, -1, -1, 2, 7, 0, -4, + -2, 0, -1, -4, -3, -1, -4, -4, 3, -3, 1, 1, -4, -3, -3, -4, -2, 0, 6, -4, -2, + -4, -5, -6, -5, 1, -4, -3, -4, -5, -3, -2, -5, -6, -3, -4, -4, -4, -4, 15, 3, + -3, -3, -4, -3, 4, -4, 2, -2, -3, -1, -1, -3, -4, -2, -2, -3, -2, -2, 3, 9, ] } @@ -822,28 +903,28 @@ fn blosum80_scores() -> Array[Int] { // BLOSUM90 raw scores (20x20) // ============================================================================ +///| fn blosum90_scores() -> Array[Int] { [ - 7, -1, -2, -1, -3, 0, -2, -1, -1, -2, -1, -2, -1, -1, -2, 2, 1, 0, -4, -3, - -1, 14, -6, -6, -4, -4, -4, -2, -5, -3, -3, -5, -5, -5, -4, -1, -1, -2, -5, -4, - -2, -6, 10, 2, -5, -2, -1, -4, -1, -5, -4, 2, -2, 1, -2, 0, -1, -4, -6, -4, - -1, -6, 2, 9, -5, -3, 0, -4, 2, -4, -3, 0, -2, 3, 0, 0, -1, -3, -5, -3, - -3, -4, -5, -5, 10, -4, -1, 0, -4, 0, 0, -4, -5, -4, -4, -3, -2, -1, 2, 4, - 0, -4, -2, -3, -4, 10, -3, -5, -2, -5, -4, 0, -3, -3, -3, 0, -2, -4, -4, -4, - -2, -4, -1, 0, -1, -3, 12, -4, -1, -4, -3, 1, -3, 0, 0, -1, -2, -4, -3, 2, - -1, -2, -4, -4, 0, -5, -4, 6, -3, 2, 1, -4, -3, -3, -3, -2, -1, 3, -4, -2, - -1, -5, -1, 2, -4, -2, -1, -3, 8, -3, -1, 0, -2, 2, 3, 0, -1, -3, -5, -3, - -2, -3, -5, -4, 0, -5, -4, 2, -3, 6, 3, -4, -3, -3, -3, -2, -1, 1, -3, -1, - -1, -3, -4, -3, 0, -4, -3, 1, -1, 3, 8, -3, -3, 0, -1, -1, -1, 1, -2, -1, - -2, -5, 2, 0, -4, 0, 1, -4, 0, -4, -3, 8, -2, 0, 0, 1, 0, -4, -5, -3, - -1, -5, -2, -2, -5, -3, -3, -3, -2, -3, -3, -2, 12, -2, -3, -2, -2, -3, -6, -4, - -1, -5, 1, 3, -4, -3, 0, -3, 2, -3, 0, 0, -2, 9, 1, 0, -1, -3, -4, -2, - -2, -4, -2, 0, -4, -3, 0, -3, 3, -3, -1, 0, -3, 1, 9, -1, -1, -4, -4, -2, - 2, -1, 0, 0, -3, 0, -1, -2, 0, -2, -1, 1, -2, 0, -1, 7, 2, -2, -4, -3, - 1, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -2, -1, -1, 2, 8, 0, -4, -2, - 0, -2, -4, -3, -1, -4, -4, 3, -3, 1, 1, -4, -3, -3, -4, -2, 0, 6, -4, -2, - -4, -5, -6, -5, 2, -4, -3, -4, -5, -3, -2, -5, -6, -4, -4, -4, -4, -4, 15, 3, - -3, -4, -4, -3, 4, -4, 2, -2, -3, -1, -1, -3, -4, -2, -2, -3, -2, -2, 3, 9, + 7, -1, -2, -1, -3, 0, -2, -1, -1, -2, -1, -2, -1, -1, -2, 2, 1, 0, -4, -3, -1, + 14, -6, -6, -4, -4, -4, -2, -5, -3, -3, -5, -5, -5, -4, -1, -1, -2, -5, -4, -2, + -6, 10, 2, -5, -2, -1, -4, -1, -5, -4, 2, -2, 1, -2, 0, -1, -4, -6, -4, -1, -6, + 2, 9, -5, -3, 0, -4, 2, -4, -3, 0, -2, 3, 0, 0, -1, -3, -5, -3, -3, -4, -5, -5, + 10, -4, -1, 0, -4, 0, 0, -4, -5, -4, -4, -3, -2, -1, 2, 4, 0, -4, -2, -3, -4, + 10, -3, -5, -2, -5, -4, 0, -3, -3, -3, 0, -2, -4, -4, -4, -2, -4, -1, 0, -1, + -3, 12, -4, -1, -4, -3, 1, -3, 0, 0, -1, -2, -4, -3, 2, -1, -2, -4, -4, 0, -5, + -4, 6, -3, 2, 1, -4, -3, -3, -3, -2, -1, 3, -4, -2, -1, -5, -1, 2, -4, -2, -1, + -3, 8, -3, -1, 0, -2, 2, 3, 0, -1, -3, -5, -3, -2, -3, -5, -4, 0, -5, -4, 2, + -3, 6, 3, -4, -3, -3, -3, -2, -1, 1, -3, -1, -1, -3, -4, -3, 0, -4, -3, 1, -1, + 3, 8, -3, -3, 0, -1, -1, -1, 1, -2, -1, -2, -5, 2, 0, -4, 0, 1, -4, 0, -4, -3, + 8, -2, 0, 0, 1, 0, -4, -5, -3, -1, -5, -2, -2, -5, -3, -3, -3, -2, -3, -3, -2, + 12, -2, -3, -2, -2, -3, -6, -4, -1, -5, 1, 3, -4, -3, 0, -3, 2, -3, 0, 0, -2, + 9, 1, 0, -1, -3, -4, -2, -2, -4, -2, 0, -4, -3, 0, -3, 3, -3, -1, 0, -3, 1, 9, + -1, -1, -4, -4, -2, 2, -1, 0, 0, -3, 0, -1, -2, 0, -2, -1, 1, -2, 0, -1, 7, 2, + -2, -4, -3, 1, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -2, -1, -1, 2, 8, 0, + -4, -2, 0, -2, -4, -3, -1, -4, -4, 3, -3, 1, 1, -4, -3, -3, -4, -2, 0, 6, -4, + -2, -4, -5, -6, -5, 2, -4, -3, -4, -5, -3, -2, -5, -6, -4, -4, -4, -4, -4, 15, + 3, -3, -4, -4, -3, 4, -4, 2, -2, -3, -1, -1, -3, -4, -2, -2, -3, -2, -2, 3, 9, ] } @@ -851,28 +932,29 @@ fn blosum90_scores() -> Array[Int] { // PAM30 raw scores (20x20) // ============================================================================ +///| fn pam30_scores() -> Array[Int] { [ - 6, -7, -4, -2, -6, -2, -5, -3, -3, -5, -4, -3, -3, -3, -5, 0, 0, -3, -10, -6, - -7, 12, -9, -9, -6, -9, -6, -7, -9, -7, -7, -7, -8, -7, -7, -4, -5, -6, -10, -7, - -4, -9, 8, 2, -9, -3, -3, -7, -3, -8, -7, 2, -5, 0, -6, -1, -3, -7, -9, -7, - -2, -9, 2, 8, -8, -5, -1, -6, 2, -7, -5, 0, -4, 3, -3, -1, -3, -5, -9, -5, - -6, -6, -9, -8, 10, -8, -4, -1, -8, -1, -1, -8, -8, -8, -7, -5, -5, -3, 1, 3, - -2, -9, -3, -5, -8, 8, -6, -8, -5, -8, -6, 0, -6, -5, -6, -1, -4, -7, -9, -8, - -5, -6, -3, -1, -4, -6, 10, -6, -3, -6, -5, 1, -5, 0, -2, -3, -4, -6, -4, 2, - -3, -7, -7, -6, -1, -8, -6, 7, -5, 1, 1, -6, -5, -5, -5, -4, -2, 3, -7, -4, - -3, -9, -3, 2, -8, -5, -3, -5, 7, -5, -3, 0, -4, 2, 2, -1, -2, -5, -9, -6, - -5, -7, -8, -7, -1, -8, -6, 1, -5, 7, 3, -6, -5, -4, -6, -5, -4, 1, -6, -4, - -4, -7, -7, -5, -1, -6, -5, 1, -3, 3, 8, -5, -4, -1, -3, -3, -2, 1, -6, -4, - -3, -7, 2, 0, -8, 0, 1, -6, 0, -6, -5, 8, -4, 0, -3, 0, -1, -6, -9, -5, - -3, -8, -5, -4, -8, -6, -5, -5, -4, -5, -4, -4, 11, -4, -5, -3, -3, -5, -9, -7, - -3, -7, 0, 3, -8, -5, 0, -5, 2, -4, -1, 0, -4, 8, 1, -1, -3, -5, -8, -5, - -5, -7, -6, -3, -7, -6, -2, -5, 2, -6, -3, -3, -5, 1, 8, -2, -3, -6, -7, -5, - 0, -4, -1, -1, -5, -1, -3, -4, -1, -5, -3, 0, -3, -1, -2, 6, 1, -4, -6, -4, - 0, -5, -3, -3, -5, -4, -4, -2, -2, -4, -2, -1, -3, -3, -3, 1, 7, -1, -7, -4, - -3, -6, -7, -5, -3, -7, -6, 3, -5, 1, 1, -6, -5, -5, -6, -4, -1, 7, -7, -4, - -10, -10, -9, -9, 1, -9, -4, -7, -9, -6, -6, -9, -9, -8, -7, -6, -7, -7, 14, 3, - -6, -7, -7, -5, 3, -8, 2, -4, -6, -4, -4, -5, -7, -5, -5, -4, -4, -4, 3, 10, + 6, -7, -4, -2, -6, -2, -5, -3, -3, -5, -4, -3, -3, -3, -5, 0, 0, -3, -10, -6, + -7, 12, -9, -9, -6, -9, -6, -7, -9, -7, -7, -7, -8, -7, -7, -4, -5, -6, -10, + -7, -4, -9, 8, 2, -9, -3, -3, -7, -3, -8, -7, 2, -5, 0, -6, -1, -3, -7, -9, -7, + -2, -9, 2, 8, -8, -5, -1, -6, 2, -7, -5, 0, -4, 3, -3, -1, -3, -5, -9, -5, -6, + -6, -9, -8, 10, -8, -4, -1, -8, -1, -1, -8, -8, -8, -7, -5, -5, -3, 1, 3, -2, + -9, -3, -5, -8, 8, -6, -8, -5, -8, -6, 0, -6, -5, -6, -1, -4, -7, -9, -8, -5, + -6, -3, -1, -4, -6, 10, -6, -3, -6, -5, 1, -5, 0, -2, -3, -4, -6, -4, 2, -3, + -7, -7, -6, -1, -8, -6, 7, -5, 1, 1, -6, -5, -5, -5, -4, -2, 3, -7, -4, -3, -9, + -3, 2, -8, -5, -3, -5, 7, -5, -3, 0, -4, 2, 2, -1, -2, -5, -9, -6, -5, -7, -8, + -7, -1, -8, -6, 1, -5, 7, 3, -6, -5, -4, -6, -5, -4, 1, -6, -4, -4, -7, -7, -5, + -1, -6, -5, 1, -3, 3, 8, -5, -4, -1, -3, -3, -2, 1, -6, -4, -3, -7, 2, 0, -8, + 0, 1, -6, 0, -6, -5, 8, -4, 0, -3, 0, -1, -6, -9, -5, -3, -8, -5, -4, -8, -6, + -5, -5, -4, -5, -4, -4, 11, -4, -5, -3, -3, -5, -9, -7, -3, -7, 0, 3, -8, -5, + 0, -5, 2, -4, -1, 0, -4, 8, 1, -1, -3, -5, -8, -5, -5, -7, -6, -3, -7, -6, -2, + -5, 2, -6, -3, -3, -5, 1, 8, -2, -3, -6, -7, -5, 0, -4, -1, -1, -5, -1, -3, -4, + -1, -5, -3, 0, -3, -1, -2, 6, 1, -4, -6, -4, 0, -5, -3, -3, -5, -4, -4, -2, -2, + -4, -2, -1, -3, -3, -3, 1, 7, -1, -7, -4, -3, -6, -7, -5, -3, -7, -6, 3, -5, + 1, 1, -6, -5, -5, -6, -4, -1, 7, -7, -4, -10, -10, -9, -9, 1, -9, -4, -7, -9, + -6, -6, -9, -9, -8, -7, -6, -7, -7, 14, 3, -6, -7, -7, -5, 3, -8, 2, -4, -6, + -4, -4, -5, -7, -5, -5, -4, -4, -4, 3, 10, ] } @@ -880,28 +962,29 @@ fn pam30_scores() -> Array[Int] { // PAM70 raw scores (20x20) // ============================================================================ +///| fn pam70_scores() -> Array[Int] { [ - 5, -4, -3, -1, -5, -1, -4, -2, -2, -4, -3, -2, -2, -2, -4, 1, 1, -2, -8, -4, - -4, 10, -7, -6, -4, -7, -4, -5, -6, -5, -5, -5, -6, -5, -5, -2, -3, -4, -7, -5, - -3, -7, 7, 2, -7, -2, -2, -5, -2, -6, -5, 2, -4, 1, -4, 0, -2, -5, -7, -5, - -1, -6, 2, 7, -6, -4, 0, -4, 2, -5, -3, 0, -3, 3, -2, 0, -2, -4, -7, -4, - -5, -4, -7, -6, 9, -6, -3, -1, -6, -1, -1, -6, -6, -6, -5, -4, -4, -2, 1, 3, - -1, -7, -2, -4, -6, 8, -5, -6, -4, -6, -5, 1, -5, -4, -4, 0, -3, -5, -7, -6, - -4, -4, -2, 0, -3, -5, 10, -5, -2, -4, -4, 2, -4, 1, 0, -2, -3, -5, -3, 2, - -2, -5, -5, -4, -1, -6, -5, 7, -4, 2, 2, -4, -4, -3, -4, -3, -1, 3, -5, -3, - -2, -6, -2, 2, -6, -4, -2, -4, 6, -4, -2, 0, -3, 2, 2, 0, -1, -4, -7, -4, - -4, -5, -6, -5, -1, -6, -4, 2, -4, 6, 3, -4, -4, -3, -4, -3, -3, 1, -4, -2, - -3, -5, -5, -3, -1, -5, -4, 2, -2, 3, 8, -4, -3, -1, -2, -2, -1, 1, -4, -2, - -2, -5, 2, 0, -6, 1, 2, -4, 0, -4, -4, 8, -3, 0, -2, 1, 0, -4, -7, -4, - -2, -6, -4, -3, -6, -5, -4, -4, -3, -4, -3, -3, 10, -3, -4, -2, -2, -4, -7, -5, - -2, -5, 1, 3, -6, -4, 1, -3, 2, -3, -1, 0, -3, 7, 1, 0, -2, -4, -6, -3, - -4, -5, -4, -2, -5, -4, 0, -4, 2, -4, -2, -2, -4, 1, 8, -1, -2, -4, -5, -3, - 1, -2, 0, 0, -4, 0, -2, -3, 0, -3, -2, 1, -2, 0, -1, 5, 2, -3, -5, -3, - 1, -3, -2, -2, -4, -3, -3, -1, -1, -3, -1, 0, -2, -2, -2, 2, 6, -1, -5, -3, - -2, -4, -5, -4, -2, -5, -5, 3, -4, 1, 1, -4, -4, -4, -4, -3, -1, 7, -5, -3, - -8, -7, -7, -7, 1, -7, -3, -5, -7, -4, -4, -7, -7, -6, -5, -5, -5, -5, 13, 3, - -4, -5, -5, -4, 3, -6, 2, -3, -4, -2, -2, -4, -5, -3, -3, -3, -3, -3, 3, 9, + 5, -4, -3, -1, -5, -1, -4, -2, -2, -4, -3, -2, -2, -2, -4, 1, 1, -2, -8, -4, + -4, 10, -7, -6, -4, -7, -4, -5, -6, -5, -5, -5, -6, -5, -5, -2, -3, -4, -7, -5, + -3, -7, 7, 2, -7, -2, -2, -5, -2, -6, -5, 2, -4, 1, -4, 0, -2, -5, -7, -5, -1, + -6, 2, 7, -6, -4, 0, -4, 2, -5, -3, 0, -3, 3, -2, 0, -2, -4, -7, -4, -5, -4, + -7, -6, 9, -6, -3, -1, -6, -1, -1, -6, -6, -6, -5, -4, -4, -2, 1, 3, -1, -7, + -2, -4, -6, 8, -5, -6, -4, -6, -5, 1, -5, -4, -4, 0, -3, -5, -7, -6, -4, -4, + -2, 0, -3, -5, 10, -5, -2, -4, -4, 2, -4, 1, 0, -2, -3, -5, -3, 2, -2, -5, -5, + -4, -1, -6, -5, 7, -4, 2, 2, -4, -4, -3, -4, -3, -1, 3, -5, -3, -2, -6, -2, 2, + -6, -4, -2, -4, 6, -4, -2, 0, -3, 2, 2, 0, -1, -4, -7, -4, -4, -5, -6, -5, -1, + -6, -4, 2, -4, 6, 3, -4, -4, -3, -4, -3, -3, 1, -4, -2, -3, -5, -5, -3, -1, -5, + -4, 2, -2, 3, 8, -4, -3, -1, -2, -2, -1, 1, -4, -2, -2, -5, 2, 0, -6, 1, 2, -4, + 0, -4, -4, 8, -3, 0, -2, 1, 0, -4, -7, -4, -2, -6, -4, -3, -6, -5, -4, -4, -3, + -4, -3, -3, 10, -3, -4, -2, -2, -4, -7, -5, -2, -5, 1, 3, -6, -4, 1, -3, 2, -3, + -1, 0, -3, 7, 1, 0, -2, -4, -6, -3, -4, -5, -4, -2, -5, -4, 0, -4, 2, -4, -2, + -2, -4, 1, 8, -1, -2, -4, -5, -3, 1, -2, 0, 0, -4, 0, -2, -3, 0, -3, -2, 1, -2, + 0, -1, 5, 2, -3, -5, -3, 1, -3, -2, -2, -4, -3, -3, -1, -1, -3, -1, 0, -2, -2, + -2, 2, 6, -1, -5, -3, -2, -4, -5, -4, -2, -5, -5, 3, -4, 1, 1, -4, -4, -4, -4, + -3, -1, 7, -5, -3, -8, -7, -7, -7, 1, -7, -3, -5, -7, -4, -4, -7, -7, -6, -5, + -5, -5, -5, 13, 3, -4, -5, -5, -4, 3, -6, 2, -3, -4, -2, -2, -4, -5, -3, -3, + -3, -3, -3, 3, 9, ] } @@ -909,27 +992,27 @@ fn pam70_scores() -> Array[Int] { // PAM250 raw scores (20x20) // ============================================================================ +///| fn pam250_scores() -> Array[Int] { [ - 2, -2, 0, 0, -3, 1, -1, -1, -1, -2, -1, 0, 1, 0, -2, 1, 1, 0, -6, -3, - -2, 12, -5, -5, -4, -3, -3, -2, -3, -2, -2, -4, -4, -4, -4, 0, -2, -2, -7, -4, - 0, -5, 4, 3, -6, 1, 1, -2, 0, -4, -3, 2, -1, 2, -1, 0, 0, -2, -5, -4, - 0, -5, 3, 4, -5, 0, 1, -2, 2, -3, -2, 1, -1, 2, -1, 0, 0, -2, -5, -3, - -3, -4, -6, -5, 9, -5, -2, 1, -5, 2, 0, -3, -5, -5, -4, -3, -3, -1, 0, 7, - 1, -3, 1, 0, -5, 5, -2, -3, -2, -4, -3, 0, 0, -1, -3, 1, 0, -1, -7, -5, - -1, -3, 1, 1, -2, -2, 6, -2, 0, -2, -2, 2, 0, 3, 2, -1, -1, -2, -3, 2, - -1, -2, -2, -2, 1, -3, -2, 5, -2, 2, 2, -2, -2, -2, -2, -1, 0, 4, -5, -1, - -1, -3, 0, 2, -5, -2, 0, -2, 5, -3, -1, 1, -1, 1, 3, 0, 0, -2, -3, -4, - -2, -2, -4, -3, 2, -4, -2, 2, -3, 6, 4, -3, -3, -2, -3, -3, -2, 2, -2, -1, - -1, -2, -3, -2, 0, -3, -2, 2, -1, 4, 6, -2, -2, -1, 0, -2, -1, 2, -4, -2, - 0, -4, 2, 1, -3, 0, 2, -2, 1, -3, -2, 2, 0, 1, 0, 1, 0, -2, -4, -2, - 1, -4, -1, -1, -5, 0, 0, -2, -1, -3, -2, 0, 6, 0, 0, 1, 0, -1, -6, -5, - 0, -4, 2, 2, -5, -1, 3, -2, 1, -2, -1, 1, 0, 4, 1, -1, -1, -2, -5, -4, - -2, -4, -1, -1, -4, -3, 2, -2, 3, -3, 0, 0, 0, 1, 6, 0, -1, -2, -4, 0, - 1, 0, 0, 0, -3, 1, -1, -1, 0, -3, -2, 1, 1, -1, 0, 2, 1, -1, -4, -2, - 1, -2, 0, 0, -3, 0, -1, 0, 0, -2, -1, 0, 0, -1, -1, 1, 3, 0, -5, -3, - 0, -2, -2, -2, -1, -1, -2, 4, -2, 2, 2, -2, -1, -2, -2, -1, 0, 4, -6, -2, - -6, -7, -5, -5, 0, -7, -3, -5, -3, -2, -4, -4, -6, -5, -4, -4, -5, -6, 17, 0, - -3, -4, -4, -3, 7, -5, 2, -1, -4, -1, -2, -2, -5, -4, 0, -2, -3, -2, 0, 10, + 2, -2, 0, 0, -3, 1, -1, -1, -1, -2, -1, 0, 1, 0, -2, 1, 1, 0, -6, -3, -2, 12, + -5, -5, -4, -3, -3, -2, -3, -2, -2, -4, -4, -4, -4, 0, -2, -2, -7, -4, 0, -5, + 4, 3, -6, 1, 1, -2, 0, -4, -3, 2, -1, 2, -1, 0, 0, -2, -5, -4, 0, -5, 3, 4, -5, + 0, 1, -2, 2, -3, -2, 1, -1, 2, -1, 0, 0, -2, -5, -3, -3, -4, -6, -5, 9, -5, -2, + 1, -5, 2, 0, -3, -5, -5, -4, -3, -3, -1, 0, 7, 1, -3, 1, 0, -5, 5, -2, -3, -2, + -4, -3, 0, 0, -1, -3, 1, 0, -1, -7, -5, -1, -3, 1, 1, -2, -2, 6, -2, 0, -2, -2, + 2, 0, 3, 2, -1, -1, -2, -3, 2, -1, -2, -2, -2, 1, -3, -2, 5, -2, 2, 2, -2, -2, + -2, -2, -1, 0, 4, -5, -1, -1, -3, 0, 2, -5, -2, 0, -2, 5, -3, -1, 1, -1, 1, 3, + 0, 0, -2, -3, -4, -2, -2, -4, -3, 2, -4, -2, 2, -3, 6, 4, -3, -3, -2, -3, -3, + -2, 2, -2, -1, -1, -2, -3, -2, 0, -3, -2, 2, -1, 4, 6, -2, -2, -1, 0, -2, -1, + 2, -4, -2, 0, -4, 2, 1, -3, 0, 2, -2, 1, -3, -2, 2, 0, 1, 0, 1, 0, -2, -4, -2, + 1, -4, -1, -1, -5, 0, 0, -2, -1, -3, -2, 0, 6, 0, 0, 1, 0, -1, -6, -5, 0, -4, + 2, 2, -5, -1, 3, -2, 1, -2, -1, 1, 0, 4, 1, -1, -1, -2, -5, -4, -2, -4, -1, -1, + -4, -3, 2, -2, 3, -3, 0, 0, 0, 1, 6, 0, -1, -2, -4, 0, 1, 0, 0, 0, -3, 1, -1, + -1, 0, -3, -2, 1, 1, -1, 0, 2, 1, -1, -4, -2, 1, -2, 0, 0, -3, 0, -1, 0, 0, -2, + -1, 0, 0, -1, -1, 1, 3, 0, -5, -3, 0, -2, -2, -2, -1, -1, -2, 4, -2, 2, 2, -2, + -1, -2, -2, -1, 0, 4, -6, -2, -6, -7, -5, -5, 0, -7, -3, -5, -3, -2, -4, -4, + -6, -5, -4, -4, -5, -6, 17, 0, -3, -4, -4, -3, 7, -5, 2, -1, -4, -1, -2, -2, + -5, -4, 0, -2, -3, -2, 0, 10, ] } diff --git a/src/survival.mbt b/src/survival.mbt index 9ecf54ed..7f4d2196 100644 --- a/src/survival.mbt +++ b/src/survival.mbt @@ -73,7 +73,7 @@ pub fn SurvRecord::new( time : Double, event : Bool, group : String, - covariates : Array[Double] + covariates : Array[Double], ) -> SurvRecord { SurvRecord::{ time, event, group, covariates } } @@ -113,7 +113,7 @@ pub fn SurvData::new() -> SurvData { records: Array::new(), n_samples: 0, n_groups: 0, - group_names: Array::new() + group_names: Array::new(), } } @@ -143,7 +143,7 @@ pub fn SurvData::from_records(records : Array[SurvRecord]) -> SurvData { records, n_samples: n, n_groups: group_names.length(), - group_names + group_names, } } @@ -194,7 +194,10 @@ pub fn SurvData::add_record(self : SurvData, record : SurvRecord) -> Unit { ///| /// Return records belonging to a given group. -pub fn SurvData::filter_by_group(self : SurvData, group : String) -> Array[SurvRecord] { +pub fn SurvData::filter_by_group( + self : SurvData, + group : String, +) -> Array[SurvRecord] { let result : Array[SurvRecord] = Array::new() let recs = self.records let n = recs.length() @@ -239,8 +242,15 @@ pub fn survival_normal_cdf(z : Double) -> Double { let d = 0.3989423 * @math.exp(-z * z / 2.0) let p = d * t * - (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.3302744)))) - if z > 0.0 { 1.0 - p } else { p } + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.3302744))) + ) + if z > 0.0 { + 1.0 - p + } else { + p + } } ///| @@ -268,18 +278,12 @@ pub fn survival_chi_square_p_value(chi_sq : Double, df : Int) -> Double { } if df == 1 { let p = 2.0 * (1.0 - survival_normal_cdf(chi_sq.sqrt())) - return if p.is_nan() || p < 0.0 { - 0.0 - } else if p > 1.0 { - 1.0 - } else { - p - } + return if p.is_nan() || p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p } } // Wilson-Hilferty approximation for general df let df_d = df.to_double() let z = (@math.pow(chi_sq / df_d, 1.0 / 3.0) - (1.0 - 2.0 / (9.0 * df_d))) / - ((2.0 / (9.0 * df_d)).sqrt()) + (2.0 / (9.0 * df_d)).sqrt() let p = 1.0 - survival_normal_cdf(z) if p.is_nan() || p < 0.0 { 0.0 @@ -299,7 +303,7 @@ pub fn survival_chi_square_p_value(chi_sq : Double, df : Int) -> Double { fn survival_solve_linear( a : Array[Array[Double]], b : Array[Double], - n : Int + n : Int, ) -> Array[Double] { if n == 0 { return Array::new() @@ -397,7 +401,11 @@ fn survival_invert_matrix(m : Array[Array[Double]]) -> Array[Array[Double]] { } let raw_piv = aug[col][col] let piv_val = if raw_piv.abs() < 1.0e-12 { - if raw_piv >= 0.0 { 1.0e-12 } else { -1.0e-12 } + if raw_piv >= 0.0 { + 1.0e-12 + } else { + -1.0e-12 + } } else { raw_piv } @@ -456,7 +464,10 @@ fn survival_fmt(v : Double) -> String { ///| /// Compute the Kaplan-Meier survival curve for a specific group. /// Standard error uses Greenwood's formula. -pub fn survival_kaplan_meier(data : SurvData, group : String) -> KaplanMeierResult { +pub fn survival_kaplan_meier( + data : SurvData, + group : String, +) -> KaplanMeierResult { let group_records = data.filter_by_group(group) let n = group_records.length() @@ -480,7 +491,7 @@ pub fn survival_kaplan_meier(data : SurvData, group : String) -> KaplanMeierResu std_err: std_err_arr, n_at_risk: n_at_risk_arr, n_events: n_events_arr, - group + group, } } @@ -514,8 +525,7 @@ pub fn survival_kaplan_meier(data : SurvData, group : String) -> KaplanMeierResu surv = surv * (1.0 - d.to_double() / n_at_risk.to_double()) if n_at_risk > d { cum_var = cum_var + - d.to_double() / - (n_at_risk.to_double() * (n_at_risk - d).to_double()) + d.to_double() / (n_at_risk.to_double() * (n_at_risk - d).to_double()) } let se = surv * cum_var.sqrt() times.push(t) @@ -533,7 +543,7 @@ pub fn survival_kaplan_meier(data : SurvData, group : String) -> KaplanMeierResu std_err: std_err_arr, n_at_risk: n_at_risk_arr, n_events: n_events_arr, - group + group, } } @@ -546,7 +556,7 @@ pub fn survival_kaplan_meier(data : SurvData, group : String) -> KaplanMeierResu pub fn survival_log_rank( data : SurvData, group1 : String, - group2 : String + group2 : String, ) -> LogRankResult { let r1 = data.filter_by_group(group1) let r2 = data.filter_by_group(group2) @@ -624,11 +634,7 @@ pub fn survival_log_rank( i = j } - let chi_sq = if v > 0.0 { - (o1 - e1) * (o1 - e1) / v - } else { - 0.0 - } + let chi_sq = if v > 0.0 { (o1 - e1) * (o1 - e1) / v } else { 0.0 } let p = survival_chi_square_p_value(chi_sq, 1) LogRankResult::{ chi_square: chi_sq, @@ -637,7 +643,7 @@ pub fn survival_log_rank( group1, group2, n1: n1_total, - n2: n2_total + n2: n2_total, } } @@ -655,7 +661,7 @@ fn survival_cox_score_info( order : Array[Int], beta : Array[Double], n : Int, - p : Int + p : Int, ) -> (Array[Double], Array[Array[Double]], Double) { let u : Array[Double] = Array::make(p, 0.0) let info : Array[Array[Double]] = Array::new() @@ -757,7 +763,7 @@ fn survival_cox_score_info( /// partial likelihood. Ties are handled with the Breslow approximation. pub fn survival_cox_fit( data : SurvData, - covariate_names : Array[String] + covariate_names : Array[String], ) -> CoxResult { let records = data.records() let n = records.length() @@ -773,7 +779,7 @@ pub fn survival_cox_fit( covariate_names, log_likelihood: 0.0, n_samples: n, - converged: true + converged: true, } } @@ -833,7 +839,9 @@ pub fn survival_cox_fit( } // Final score/info/loglik at the converged beta. - let final_triple = survival_cox_score_info(times, events, z, order, beta, n, p) + let final_triple = survival_cox_score_info( + times, events, z, order, beta, n, p, + ) let final_info = final_triple.1 let final_ll = final_triple.2 let inv_info = survival_invert_matrix(final_info) @@ -862,7 +870,7 @@ pub fn survival_cox_fit( covariate_names, log_likelihood: final_ll, n_samples: n, - converged + converged, } } diff --git a/src/system_piper.mbt b/src/system_piper.mbt index a01336a0..230bb6aa 100644 --- a/src/system_piper.mbt +++ b/src/system_piper.mbt @@ -124,7 +124,11 @@ pub fn Pipeline::set_description(self : Pipeline, desc : String) -> Pipeline { ///| /// Set a global parameter. -pub fn Pipeline::set_param(self : Pipeline, key : String, value : String) -> Pipeline { +pub fn Pipeline::set_param( + self : Pipeline, + key : String, + value : String, +) -> Pipeline { let params = self.global_params.copy() params[key] = value Pipeline::{ @@ -271,15 +275,21 @@ pub fn Pipeline::get_skipped_count(self : Pipeline) -> Int { /// Get the overall pipeline progress as a percentage. pub fn Pipeline::get_progress(self : Pipeline) -> Double { let n = self.steps.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let completed = self.get_completed_count() let skipped = self.get_skipped_count() - ((completed.to_double() + skipped.to_double()) / n.to_double()) * 100.0 + (completed.to_double() + skipped.to_double()) / n.to_double() * 100.0 } ///| /// Create a new pipeline step. -pub fn PipelineStep::new(step_id : String, name : String, command : String) -> PipelineStep { +pub fn PipelineStep::new( + step_id : String, + name : String, + command : String, +) -> PipelineStep { PipelineStep::{ step_id, name, @@ -299,7 +309,10 @@ pub fn PipelineStep::new(step_id : String, name : String, command : String) -> P ///| /// Set step description. -pub fn PipelineStep::set_description(self : PipelineStep, desc : String) -> PipelineStep { +pub fn PipelineStep::set_description( + self : PipelineStep, + desc : String, +) -> PipelineStep { PipelineStep::{ step_id: self.step_id, name: self.name, @@ -319,7 +332,10 @@ pub fn PipelineStep::set_description(self : PipelineStep, desc : String) -> Pipe ///| /// Set step arguments. -pub fn PipelineStep::set_args(self : PipelineStep, args : Array[String]) -> PipelineStep { +pub fn PipelineStep::set_args( + self : PipelineStep, + args : Array[String], +) -> PipelineStep { PipelineStep::{ step_id: self.step_id, name: self.name, @@ -339,7 +355,10 @@ pub fn PipelineStep::set_args(self : PipelineStep, args : Array[String]) -> Pipe ///| /// Add a dependency. -pub fn PipelineStep::add_dependency(self : PipelineStep, dep : String) -> PipelineStep { +pub fn PipelineStep::add_dependency( + self : PipelineStep, + dep : String, +) -> PipelineStep { let deps = self.dependencies.copy() deps.push(dep) PipelineStep::{ @@ -361,7 +380,10 @@ pub fn PipelineStep::add_dependency(self : PipelineStep, dep : String) -> Pipeli ///| /// Add an input file. -pub fn PipelineStep::add_input(self : PipelineStep, file : String) -> PipelineStep { +pub fn PipelineStep::add_input( + self : PipelineStep, + file : String, +) -> PipelineStep { let inputs = self.input_files.copy() inputs.push(file) PipelineStep::{ @@ -383,7 +405,10 @@ pub fn PipelineStep::add_input(self : PipelineStep, file : String) -> PipelineSt ///| /// Add an output file. -pub fn PipelineStep::add_output(self : PipelineStep, file : String) -> PipelineStep { +pub fn PipelineStep::add_output( + self : PipelineStep, + file : String, +) -> PipelineStep { let outputs = self.output_files.copy() outputs.push(file) PipelineStep::{ @@ -443,14 +468,16 @@ pub fn PipelineStep::get_dependencies(self : PipelineStep) -> Array[String] { /// Check if all dependencies of a step are completed. pub fn Pipeline::can_run_step(self : Pipeline, step : PipelineStep) -> Bool { let deps = step.dependencies - if deps.length() == 0 { return true } + if deps.length() == 0 { + return true + } let mut i = 0 while i < deps.length() { let dep_step = self.get_step(deps[i]) match dep_step.status { StepStatus::Completed => () - _ => { return false } + _ => return false } i = i + 1 } @@ -459,7 +486,11 @@ pub fn Pipeline::can_run_step(self : Pipeline, step : PipelineStep) -> Bool { ///| /// Generate a pipeline configuration. -pub fn PipelineConfig::new(work_dir : String, input_dir : String, output_dir : String) -> PipelineConfig { +pub fn PipelineConfig::new( + work_dir : String, + input_dir : String, + output_dir : String, +) -> PipelineConfig { PipelineConfig::{ work_dir, input_dir, @@ -472,7 +503,10 @@ pub fn PipelineConfig::new(work_dir : String, input_dir : String, output_dir : S ///| /// Set number of cores. -pub fn PipelineConfig::set_cores(self : PipelineConfig, cores : Int) -> PipelineConfig { +pub fn PipelineConfig::set_cores( + self : PipelineConfig, + cores : Int, +) -> PipelineConfig { PipelineConfig::{ work_dir: self.work_dir, input_dir: self.input_dir, @@ -527,7 +561,13 @@ pub fn Pipeline::summary(self : Pipeline) -> String { let mut i = 0 while i < self.steps.length() { let step = self.steps[i] - s = s + " [" + step.status.to_string() + "] " + step.step_id + ": " + step.name + s = s + + " [" + + step.status.to_string() + + "] " + + step.step_id + + ": " + + step.name if step.duration_seconds > 0.0 { s = s + " (" + step.duration_seconds.to_string() + "s)" } @@ -542,20 +582,25 @@ pub fn Pipeline::summary(self : Pipeline) -> String { /// Generate an ASCII visualization of the pipeline. pub fn Pipeline::to_ascii(self : Pipeline) -> String { let mut result = "" - result = result + "╔══════════════════════════════════════════╗\n" + result = result + + "╔══════════════════════════════════════════╗\n" result = result + "║ Pipeline: " + self.name + "\n" result = result + "║ ID: " + self.pipeline_id + "\n" result = result + "║ Steps: " + self.steps.length().to_string() + "\n" - result = result + "╚══════════════════════════════════════════╝\n\n" + result = result + + "╚══════════════════════════════════════════╝\n\n" let progress = self.get_progress() let progress_bar_len = 20 - let filled = ((progress / 100.0) * progress_bar_len.to_double()).to_int() + let filled = (progress / 100.0 * progress_bar_len.to_double()).to_int() let mut bar = "[" let mut i = 0 while i < progress_bar_len { - if i < filled { bar = bar + "█" } - else { bar = bar + "░" } + if i < filled { + bar = bar + "█" + } else { + bar = bar + "░" + } i = i + 1 } bar = bar + "]" @@ -623,56 +668,90 @@ pub fn Pipeline::to_ascii(self : Pipeline) -> String { ///| /// Create a sample RNA-seq analysis pipeline. pub fn pipeline_sample() -> Pipeline { - let mut pipe = Pipeline::new("rnaseq_pipeline_v1", "RNA-Seq Differential Expression Pipeline") - pipe = pipe.set_description("Standard RNA-Seq analysis pipeline: QC -> Alignment -> Quantification -> DE Analysis -> Functional Enrichment") + let mut pipe = Pipeline::new( + "rnaseq_pipeline_v1", "RNA-Seq Differential Expression Pipeline", + ) + pipe = pipe.set_description( + "Standard RNA-Seq analysis pipeline: QC -> Alignment -> Quantification -> DE Analysis -> Functional Enrichment", + ) // Step 1: QC let step1 = PipelineStep::new("qc", "Quality Control", "fastqc") - let step1b = step1.set_args(["-o", "qc_output", "--extract", "raw_data/*.fastq.gz"]) + let step1b = step1.set_args([ + "-o", "qc_output", "--extract", "raw_data/*.fastq.gz", + ]) let step1c = step1b.add_input("raw_data/sample1_R1.fastq.gz") let step1d = step1c.add_input("raw_data/sample1_R2.fastq.gz") let step1e = step1d.add_output("qc_output/sample1_fastqc.html") - let step1_final = step1e.set_description("Quality control of raw reads using FastQC") + let step1_final = step1e.set_description( + "Quality control of raw reads using FastQC", + ) pipe = pipe.add_step(step1_final) // Step 2: Trimming let step2 = PipelineStep::new("trim", "Adapter Trimming", "trimmomatic") - let step2b = step2.set_args(["PE", "-phred33", "raw_data/sample1_R1.fastq.gz", "raw_data/sample1_R2.fastq.gz", "trimmed/sample1_R1_trimmed.fq.gz", "trimmed/sample1_R2_trimmed.fq.gz", "ILLUMINACLIP:adapters.fa:2:30:10"]) + let step2b = step2.set_args([ + "PE", "-phred33", "raw_data/sample1_R1.fastq.gz", "raw_data/sample1_R2.fastq.gz", + "trimmed/sample1_R1_trimmed.fq.gz", "trimmed/sample1_R2_trimmed.fq.gz", "ILLUMINACLIP:adapters.fa:2:30:10", + ]) let step2c = step2b.add_dependency("qc") let step2d = step2c.add_output("trimmed/sample1_R1_trimmed.fq.gz") let step2e = step2d.add_output("trimmed/sample1_R2_trimmed.fq.gz") - let step2_final = step2e.set_description("Adapter and quality trimming with Trimmomatic") + let step2_final = step2e.set_description( + "Adapter and quality trimming with Trimmomatic", + ) pipe = pipe.add_step(step2_final) // Step 3: Alignment let step3 = PipelineStep::new("align", "Read Alignment", "hisat2") - let step3b = step3.set_args(["-x", "genome_index/genome", "-1", "trimmed/sample1_R1_trimmed.fq.gz", "-2", "trimmed/sample1_R2_trimmed.fq.gz", "-S", "alignment/sample1.sam"]) + let step3b = step3.set_args([ + "-x", "genome_index/genome", "-1", "trimmed/sample1_R1_trimmed.fq.gz", "-2", + "trimmed/sample1_R2_trimmed.fq.gz", "-S", "alignment/sample1.sam", + ]) let step3c = step3b.add_dependency("trim") let step3d = step3c.add_output("alignment/sample1.sam") let step3e = step3d.add_output("alignment/sample1.bam") - let step3_final = step3e.set_description("Read alignment to reference genome using HISAT2") + let step3_final = step3e.set_description( + "Read alignment to reference genome using HISAT2", + ) pipe = pipe.add_step(step3_final) // Step 4: Quantification - let step4 = PipelineStep::new("quantify", "Gene Quantification", "featureCounts") - let step4b = step4.set_args(["-a", "annotation.gtf", "-o", "counts/gene_counts.txt", "alignment/sample1.bam"]) + let step4 = PipelineStep::new( + "quantify", "Gene Quantification", "featureCounts", + ) + let step4b = step4.set_args([ + "-a", "annotation.gtf", "-o", "counts/gene_counts.txt", "alignment/sample1.bam", + ]) let step4c = step4b.add_dependency("align") let step4d = step4c.add_output("counts/gene_counts.txt") - let step4_final = step4d.set_description("Gene-level quantification using featureCounts") + let step4_final = step4d.set_description( + "Gene-level quantification using featureCounts", + ) pipe = pipe.add_step(step4_final) // Step 5: Differential Expression - let step5 = PipelineStep::new("de_analysis", "Differential Expression", "DESeq2") - let step5b = step5.set_args(["-i", "counts/gene_counts.txt", "-c", "metadata.csv", "-o", "de_results/"]) + let step5 = PipelineStep::new( + "de_analysis", "Differential Expression", "DESeq2", + ) + let step5b = step5.set_args([ + "-i", "counts/gene_counts.txt", "-c", "metadata.csv", "-o", "de_results/", + ]) let step5c = step5b.add_dependency("quantify") let step5d = step5c.add_output("de_results/deseq2_results.csv") let step5e = step5d.add_output("de_results/volcano_plot.png") - let step5_final = step5e.set_description("Differential expression analysis using DESeq2") + let step5_final = step5e.set_description( + "Differential expression analysis using DESeq2", + ) pipe = pipe.add_step(step5_final) // Step 6: Enrichment - let step6 = PipelineStep::new("enrich", "Functional Enrichment", "clusterProfiler") - let step6b = step6.set_args(["-i", "de_results/deseq2_results.csv", "-o", "enrichment/"]) + let step6 = PipelineStep::new( + "enrich", "Functional Enrichment", "clusterProfiler", + ) + let step6b = step6.set_args([ + "-i", "de_results/deseq2_results.csv", "-o", "enrichment/", + ]) let step6c = step6b.add_dependency("de_analysis") let step6d = step6c.add_output("enrichment/go_terms.csv") let step6e = step6d.add_output("enrichment/pathways.csv") @@ -686,4 +765,4 @@ pub fn pipeline_sample() -> Pipeline { pipe = pipe.set_param("sequencer", "Illumina NovaSeq") pipe -} \ No newline at end of file +} diff --git a/src/tab_io.mbt b/src/tab_io.mbt index 6e6f24ea..17633973 100644 --- a/src/tab_io.mbt +++ b/src/tab_io.mbt @@ -74,12 +74,14 @@ pub fn parse_tab(content : String) -> Array[SeqRecord] raise SeqIOError { } } - records.push(SeqRecord::new( - Seq::new(seq_buf.to_string()), - id=id, - name=id, - description=id, - )) + records.push( + SeqRecord::new( + Seq::new(seq_buf.to_string()), + id~, + name=id, + description=id, + ), + ) } records } diff --git a/src/taxonomy.mbt b/src/taxonomy.mbt index 359c29f0..2f68b811 100644 --- a/src/taxonomy.mbt +++ b/src/taxonomy.mbt @@ -15,7 +15,11 @@ pub struct Taxon { } ///| -pub fn Taxon::new(tax_id : String, parent_tax_id : String, rank : String) -> Taxon { +pub fn Taxon::new( + tax_id : String, + parent_tax_id : String, + rank : String, +) -> Taxon { Taxon::{ tax_id, parent_tax_id, @@ -23,7 +27,7 @@ pub fn Taxon::new(tax_id : String, parent_tax_id : String, rank : String) -> Tax scientific_name: "", common_names: Array::new(), synonyms: Array::new(), - lineage: Array::new() + lineage: Array::new(), } } @@ -36,7 +40,7 @@ pub fn Taxon::set_scientific_name(self : Taxon, name : String) -> Taxon { scientific_name: name, common_names: self.common_names, synonyms: self.synonyms, - lineage: self.lineage + lineage: self.lineage, } } @@ -51,7 +55,7 @@ pub fn Taxon::add_common_name(self : Taxon, name : String) -> Taxon { scientific_name: self.scientific_name, common_names: new_names, synonyms: self.synonyms, - lineage: self.lineage + lineage: self.lineage, } } @@ -66,7 +70,7 @@ pub fn Taxon::add_synonym(self : Taxon, name : String) -> Taxon { scientific_name: self.scientific_name, common_names: self.common_names, synonyms: new_synonyms, - lineage: self.lineage + lineage: self.lineage, } } @@ -79,7 +83,7 @@ pub fn Taxon::set_lineage(self : Taxon, lineage : Array[String]) -> Taxon { scientific_name: self.scientific_name, common_names: self.common_names, synonyms: self.synonyms, - lineage: lineage + lineage, } } @@ -93,12 +97,15 @@ pub struct TaxonomyDatabase { pub fn TaxonomyDatabase::new() -> TaxonomyDatabase { TaxonomyDatabase::{ taxa: Map([], capacity=0), - name_to_taxid: Map([], capacity=0) + name_to_taxid: Map([], capacity=0), } } ///| -pub fn TaxonomyDatabase::add_taxon(self : TaxonomyDatabase, taxon : Taxon) -> TaxonomyDatabase { +pub fn TaxonomyDatabase::add_taxon( + self : TaxonomyDatabase, + taxon : Taxon, +) -> TaxonomyDatabase { self.taxa.set(taxon.tax_id, taxon) if taxon.scientific_name != "" { self.name_to_taxid.set(to_lowercase(taxon.scientific_name), taxon.tax_id) @@ -107,7 +114,10 @@ pub fn TaxonomyDatabase::add_taxon(self : TaxonomyDatabase, taxon : Taxon) -> Ta } ///| -pub fn TaxonomyDatabase::get_taxon(self : TaxonomyDatabase, tax_id : String) -> Taxon? { +pub fn TaxonomyDatabase::get_taxon( + self : TaxonomyDatabase, + tax_id : String, +) -> Taxon? { if self.taxa.contains(tax_id) { Some(self.taxa.get(tax_id).unwrap()) } else { @@ -116,7 +126,10 @@ pub fn TaxonomyDatabase::get_taxon(self : TaxonomyDatabase, tax_id : String) -> } ///| -pub fn TaxonomyDatabase::get_taxid_by_name(self : TaxonomyDatabase, name : String) -> String? { +pub fn TaxonomyDatabase::get_taxid_by_name( + self : TaxonomyDatabase, + name : String, +) -> String? { if self.name_to_taxid.contains(to_lowercase(name)) { Some(self.name_to_taxid.get(to_lowercase(name)).unwrap()) } else { @@ -125,14 +138,19 @@ pub fn TaxonomyDatabase::get_taxid_by_name(self : TaxonomyDatabase, name : Strin } ///| -pub fn TaxonomyDatabase::get_ancestors(self : TaxonomyDatabase, tax_id : String) -> Array[Taxon] { +pub fn TaxonomyDatabase::get_ancestors( + self : TaxonomyDatabase, + tax_id : String, +) -> Array[Taxon] { let result : Array[Taxon] = Array::new() let mut current_id = tax_id - + while current_id != "" && current_id != "1" && current_id != "0" { match self.get_taxon(current_id) { - Some(taxon) => { - if taxon.parent_tax_id != "" && taxon.parent_tax_id != "1" && taxon.parent_tax_id != "0" { + Some(taxon) => + if taxon.parent_tax_id != "" && + taxon.parent_tax_id != "1" && + taxon.parent_tax_id != "0" { match self.get_taxon(taxon.parent_tax_id) { Some(parent) => { result.push(parent) @@ -143,23 +161,29 @@ pub fn TaxonomyDatabase::get_ancestors(self : TaxonomyDatabase, tax_id : String) } else { break } - } None => break } } - + result } ///| -pub fn TaxonomyDatabase::get_descendants(self : TaxonomyDatabase, tax_id : String) -> Array[Taxon] { +pub fn TaxonomyDatabase::get_descendants( + self : TaxonomyDatabase, + tax_id : String, +) -> Array[Taxon] { let result : Array[Taxon] = Array::new() ignore(find_descendants(self, tax_id, result)) result } ///| -fn find_descendants(db : TaxonomyDatabase, parent_id : String, result : Array[Taxon]) -> Unit { +fn find_descendants( + db : TaxonomyDatabase, + parent_id : String, + result : Array[Taxon], +) -> Unit { let entries = db.taxa.iter().collect() let mut i = 0 while i < entries.length() { @@ -173,26 +197,32 @@ fn find_descendants(db : TaxonomyDatabase, parent_id : String, result : Array[Ta } ///| -pub fn TaxonomyDatabase::get_lineage(self : TaxonomyDatabase, tax_id : String) -> Array[String] { +pub fn TaxonomyDatabase::get_lineage( + self : TaxonomyDatabase, + tax_id : String, +) -> Array[String] { let ancestors = self.get_ancestors(tax_id) let result : Array[String] = Array::new() - + let mut i = ancestors.length() - 1 while i >= 0 { result.push(ancestors[i].scientific_name) i = i - 1 } - + match self.get_taxon(tax_id) { Some(taxon) => result.push(taxon.scientific_name) None => () } - + result } ///| -pub fn TaxonomyDatabase::get_rank(self : TaxonomyDatabase, tax_id : String) -> String? { +pub fn TaxonomyDatabase::get_rank( + self : TaxonomyDatabase, + tax_id : String, +) -> String? { match self.get_taxon(tax_id) { Some(taxon) => Some(taxon.rank) None => None @@ -200,7 +230,10 @@ pub fn TaxonomyDatabase::get_rank(self : TaxonomyDatabase, tax_id : String) -> S } ///| -pub fn TaxonomyDatabase::get_scientific_name(self : TaxonomyDatabase, tax_id : String) -> String? { +pub fn TaxonomyDatabase::get_scientific_name( + self : TaxonomyDatabase, + tax_id : String, +) -> String? { match self.get_taxon(tax_id) { Some(taxon) => Some(taxon.scientific_name) None => None @@ -208,7 +241,10 @@ pub fn TaxonomyDatabase::get_scientific_name(self : TaxonomyDatabase, tax_id : S } ///| -pub fn TaxonomyDatabase::get_common_names(self : TaxonomyDatabase, tax_id : String) -> Array[String] { +pub fn TaxonomyDatabase::get_common_names( + self : TaxonomyDatabase, + tax_id : String, +) -> Array[String] { match self.get_taxon(tax_id) { Some(taxon) => taxon.common_names None => Array::new() @@ -216,7 +252,10 @@ pub fn TaxonomyDatabase::get_common_names(self : TaxonomyDatabase, tax_id : Stri } ///| -pub fn TaxonomyDatabase::get_synonyms(self : TaxonomyDatabase, tax_id : String) -> Array[String] { +pub fn TaxonomyDatabase::get_synonyms( + self : TaxonomyDatabase, + tax_id : String, +) -> Array[String] { match self.get_taxon(tax_id) { Some(taxon) => taxon.synonyms None => Array::new() @@ -224,7 +263,10 @@ pub fn TaxonomyDatabase::get_synonyms(self : TaxonomyDatabase, tax_id : String) } ///| -pub fn parse_nodes_dmp(db : TaxonomyDatabase, content : String) -> TaxonomyDatabase { +pub fn parse_nodes_dmp( + db : TaxonomyDatabase, + content : String, +) -> TaxonomyDatabase { let lines = split_by_char(content, '\n'.to_int()) let mut i = 0 while i < lines.length() { @@ -244,7 +286,7 @@ pub fn parse_nodes_dmp(db : TaxonomyDatabase, content : String) -> TaxonomyDatab let tax_id = pipe_fields[0] let parent_tax_id = pipe_fields[1] let rank = if pipe_fields.length() > 2 { pipe_fields[2] } else { "" } - + let taxon = Taxon::new(tax_id, parent_tax_id, rank) ignore(db.add_taxon(taxon)) } @@ -255,7 +297,10 @@ pub fn parse_nodes_dmp(db : TaxonomyDatabase, content : String) -> TaxonomyDatab } ///| -pub fn parse_names_dmp(db : TaxonomyDatabase, content : String) -> TaxonomyDatabase { +pub fn parse_names_dmp( + db : TaxonomyDatabase, + content : String, +) -> TaxonomyDatabase { let lines = split_by_char(content, '\n'.to_int()) let mut i = 0 while i < lines.length() { @@ -274,11 +319,15 @@ pub fn parse_names_dmp(db : TaxonomyDatabase, content : String) -> TaxonomyDatab if pipe_fields.length() >= 4 { let tax_id = pipe_fields[0] let name = pipe_fields[1] - let name_class = if pipe_fields.length() > 3 { pipe_fields[3] } else { "" } - + let name_class = if pipe_fields.length() > 3 { + pipe_fields[3] + } else { + "" + } + if db.taxa.contains(tax_id) { let taxon = db.taxa.get(tax_id).unwrap() - + if name_class == "scientific name" { let updated = taxon.set_scientific_name(name) db.taxa.set(tax_id, updated) @@ -299,9 +348,11 @@ pub fn parse_names_dmp(db : TaxonomyDatabase, content : String) -> TaxonomyDatab ///| - ///| -pub fn parse_taxonomy_database(nodes_content : String, names_content : String) -> TaxonomyDatabase { +pub fn parse_taxonomy_database( + nodes_content : String, + names_content : String, +) -> TaxonomyDatabase { let db = TaxonomyDatabase::new() let db_with_nodes = parse_nodes_dmp(db, nodes_content) parse_names_dmp(db_with_nodes, names_content) @@ -310,64 +361,95 @@ pub fn parse_taxonomy_database(nodes_content : String, names_content : String) - ///| pub fn create_example_taxonomy() -> TaxonomyDatabase { let db = TaxonomyDatabase::new() - + let root = Taxon::new("1", "0", "no rank").set_scientific_name("root") ignore(db.add_taxon(root)) - - let cellular_organisms = Taxon::new("131567", "1", "no rank").set_scientific_name("cellular organisms") + + let cellular_organisms = Taxon::new("131567", "1", "no rank").set_scientific_name( + "cellular organisms", + ) ignore(db.add_taxon(cellular_organisms)) - - let eukaryota = Taxon::new("2759", "131567", "superkingdom").set_scientific_name("Eukaryota") + + let eukaryota = Taxon::new("2759", "131567", "superkingdom").set_scientific_name( + "Eukaryota", + ) ignore(db.add_taxon(eukaryota)) - - let metazoa = Taxon::new("33208", "2759", "kingdom").set_scientific_name("Metazoa") + + let metazoa = Taxon::new("33208", "2759", "kingdom").set_scientific_name( + "Metazoa", + ) ignore(db.add_taxon(metazoa)) - - let chordata = Taxon::new("7711", "33208", "phylum").set_scientific_name("Chordata") + + let chordata = Taxon::new("7711", "33208", "phylum").set_scientific_name( + "Chordata", + ) ignore(db.add_taxon(chordata)) - - let mammalia = Taxon::new("40674", "7711", "class").set_scientific_name("Mammalia") + + let mammalia = Taxon::new("40674", "7711", "class").set_scientific_name( + "Mammalia", + ) ignore(db.add_taxon(mammalia)) - - let primates = Taxon::new("9443", "40674", "order").set_scientific_name("Primates") + + let primates = Taxon::new("9443", "40674", "order").set_scientific_name( + "Primates", + ) ignore(db.add_taxon(primates)) - - let hominidae = Taxon::new("9604", "9443", "family").set_scientific_name("Hominidae") + + let hominidae = Taxon::new("9604", "9443", "family").set_scientific_name( + "Hominidae", + ) ignore(db.add_taxon(hominidae)) - + let homo = Taxon::new("9605", "9604", "genus").set_scientific_name("Homo") ignore(db.add_taxon(homo)) - - let sapiens = Taxon::new("9606", "9605", "species").set_scientific_name("Homo sapiens") + + let sapiens = Taxon::new("9606", "9605", "species").set_scientific_name( + "Homo sapiens", + ) let sapiens_with_common = sapiens.add_common_name("human") - let sapiens_with_synonym = sapiens_with_common.add_synonym("Homo sapiens sapiens") + let sapiens_with_synonym = sapiens_with_common.add_synonym( + "Homo sapiens sapiens", + ) ignore(db.add_taxon(sapiens_with_synonym)) - + let pan = Taxon::new("9598", "9604", "genus").set_scientific_name("Pan") ignore(db.add_taxon(pan)) - - let troglodytes = Taxon::new("9599", "9598", "species").set_scientific_name("Pan troglodytes") + + let troglodytes = Taxon::new("9599", "9598", "species").set_scientific_name( + "Pan troglodytes", + ) let troglodytes_with_common = troglodytes.add_common_name("chimpanzee") ignore(db.add_taxon(troglodytes_with_common)) - - let bacteria = Taxon::new("2", "131567", "superkingdom").set_scientific_name("Bacteria") + + let bacteria = Taxon::new("2", "131567", "superkingdom").set_scientific_name( + "Bacteria", + ) ignore(db.add_taxon(bacteria)) - - let proteobacteria = Taxon::new("1224", "2", "phylum").set_scientific_name("Proteobacteria") + + let proteobacteria = Taxon::new("1224", "2", "phylum").set_scientific_name( + "Proteobacteria", + ) ignore(db.add_taxon(proteobacteria)) - - let escherichia = Taxon::new("561", "1224", "genus").set_scientific_name("Escherichia") + + let escherichia = Taxon::new("561", "1224", "genus").set_scientific_name( + "Escherichia", + ) ignore(db.add_taxon(escherichia)) - - let coli = Taxon::new("562", "561", "species").set_scientific_name("Escherichia coli") + + let coli = Taxon::new("562", "561", "species").set_scientific_name( + "Escherichia coli", + ) let coli_with_common = coli.add_common_name("E. coli") ignore(db.add_taxon(coli_with_common)) - + db } ///| -pub fn TaxonomyDatabase::get_taxa_by_rank(self : TaxonomyDatabase, rank : String) -> Array[Taxon] { +pub fn TaxonomyDatabase::get_taxa_by_rank( + self : TaxonomyDatabase, + rank : String, +) -> Array[Taxon] { let result : Array[Taxon] = Array::new() let entries = self.taxa.iter().collect() let mut i = 0 @@ -382,12 +464,16 @@ pub fn TaxonomyDatabase::get_taxa_by_rank(self : TaxonomyDatabase, rank : String } ///| -pub fn TaxonomyDatabase::get_all_species(self : TaxonomyDatabase) -> Array[Taxon] { +pub fn TaxonomyDatabase::get_all_species( + self : TaxonomyDatabase, +) -> Array[Taxon] { self.get_taxa_by_rank("species") } ///| -pub fn TaxonomyDatabase::get_all_genera(self : TaxonomyDatabase) -> Array[Taxon] { +pub fn TaxonomyDatabase::get_all_genera( + self : TaxonomyDatabase, +) -> Array[Taxon] { self.get_taxa_by_rank("genus") } @@ -398,7 +484,11 @@ pub fn TaxonomyDatabase::count_taxa(self : TaxonomyDatabase) -> Int { } ///| -pub fn TaxonomyDatabase::is_ancestor(self : TaxonomyDatabase, ancestor_id : String, descendant_id : String) -> Bool { +pub fn TaxonomyDatabase::is_ancestor( + self : TaxonomyDatabase, + ancestor_id : String, + descendant_id : String, +) -> Bool { let ancestors = self.get_ancestors(descendant_id) let mut i = 0 while i < ancestors.length() { @@ -411,10 +501,14 @@ pub fn TaxonomyDatabase::is_ancestor(self : TaxonomyDatabase, ancestor_id : Stri } ///| -pub fn TaxonomyDatabase::get_common_ancestor(self : TaxonomyDatabase, tax_id1 : String, tax_id2 : String) -> String? { +pub fn TaxonomyDatabase::get_common_ancestor( + self : TaxonomyDatabase, + tax_id1 : String, + tax_id2 : String, +) -> String? { let ancestors1 = self.get_ancestors(tax_id1) let ancestors2 = self.get_ancestors(tax_id2) - + let mut i = 0 while i < ancestors1.length() { let mut j = 0 @@ -426,12 +520,16 @@ pub fn TaxonomyDatabase::get_common_ancestor(self : TaxonomyDatabase, tax_id1 : } i = i + 1 } - + None } ///| -pub fn TaxonomyDatabase::get_distance(self : TaxonomyDatabase, tax_id1 : String, tax_id2 : String) -> Int { +pub fn TaxonomyDatabase::get_distance( + self : TaxonomyDatabase, + tax_id1 : String, + tax_id2 : String, +) -> Int { match self.get_common_ancestor(tax_id1, tax_id2) { Some(ancestor_id) => { let dist1 = get_distance_to_ancestor(self, tax_id1, ancestor_id) @@ -443,7 +541,11 @@ pub fn TaxonomyDatabase::get_distance(self : TaxonomyDatabase, tax_id1 : String, } ///| -fn get_distance_to_ancestor(db : TaxonomyDatabase, tax_id : String, ancestor_id : String) -> Int { +fn get_distance_to_ancestor( + db : TaxonomyDatabase, + tax_id : String, + ancestor_id : String, +) -> Int { let ancestors = db.get_ancestors(tax_id) let mut distance = 0 let mut i = 0 @@ -455,4 +557,4 @@ fn get_distance_to_ancestor(db : TaxonomyDatabase, tax_id : String, ancestor_id i = i + 1 } -1 -} \ No newline at end of file +} diff --git a/src/topgo.mbt b/src/topgo.mbt index cc5217ad..6633d54f 100644 --- a/src/topgo.mbt +++ b/src/topgo.mbt @@ -13,7 +13,12 @@ pub struct TopGOTerm { } ///| -pub fn TopGOTerm::new(go_id : String, name : String, namespace : String, level : Int) -> TopGOTerm { +pub fn TopGOTerm::new( + go_id : String, + name : String, + namespace : String, + level : Int, +) -> TopGOTerm { TopGOTerm::{ go_id, name, @@ -21,7 +26,7 @@ pub fn TopGOTerm::new(go_id : String, name : String, namespace : String, level : level, parents: Array::new(), children: Array::new(), - gene_count: 0 + gene_count: 0, } } @@ -33,23 +38,24 @@ pub struct TopGOGraph { ///| pub fn TopGOGraph::new(root : String) -> TopGOGraph { - TopGOGraph::{ - terms: Map([], capacity=1000), - root - } + TopGOGraph::{ terms: Map([], capacity=1000), root } } ///| pub fn TopGOGraph::add_term(self : TopGOGraph, term : TopGOTerm) -> TopGOGraph { let terms = self.terms.copy() terms.set(term.go_id, term) - TopGOGraph::{ terms: terms, root: self.root } + TopGOGraph::{ terms, root: self.root } } ///| -pub fn TopGOGraph::add_edge(self : TopGOGraph, parent_id : String, child_id : String) -> TopGOGraph { +pub fn TopGOGraph::add_edge( + self : TopGOGraph, + parent_id : String, + child_id : String, +) -> TopGOGraph { let terms = self.terms.copy() - + if terms.contains(parent_id) { let parent = terms.get(parent_id).unwrap() let children = parent.children.copy() @@ -60,11 +66,11 @@ pub fn TopGOGraph::add_edge(self : TopGOGraph, parent_id : String, child_id : St namespace: parent.namespace, level: parent.level, parents: parent.parents, - children: children, - gene_count: parent.gene_count + children, + gene_count: parent.gene_count, }) } - + if terms.contains(child_id) { let child = terms.get(child_id).unwrap() let parents = child.parents.copy() @@ -74,13 +80,13 @@ pub fn TopGOGraph::add_edge(self : TopGOGraph, parent_id : String, child_id : St name: child.name, namespace: child.namespace, level: child.level, - parents: parents, + parents, children: child.children, - gene_count: child.gene_count + gene_count: child.gene_count, }) } - - TopGOGraph::{ terms: terms, root: self.root } + + TopGOGraph::{ terms, root: self.root } } ///| @@ -98,66 +104,117 @@ pub struct TopGOEnrichmentResult { } ///| -pub fn TopGOEnrichmentResult::new(go_id : String, term_name : String, namespace : String, level : Int, p_value : Double, adjusted_p_value : Double, enrichment_score : Double, gene_count : Int, total_genes : Int, algorithm : String) -> TopGOEnrichmentResult { - TopGOEnrichmentResult::{ go_id, term_name, namespace, level, p_value, adjusted_p_value, enrichment_score, gene_count, total_genes, algorithm } +pub fn TopGOEnrichmentResult::new( + go_id : String, + term_name : String, + namespace : String, + level : Int, + p_value : Double, + adjusted_p_value : Double, + enrichment_score : Double, + gene_count : Int, + total_genes : Int, + algorithm : String, +) -> TopGOEnrichmentResult { + TopGOEnrichmentResult::{ + go_id, + term_name, + namespace, + level, + p_value, + adjusted_p_value, + enrichment_score, + gene_count, + total_genes, + algorithm, + } } ///| -pub fn topgo_fisher_exact(count : Int, total : Int, bg_count : Int, bg_total : Int) -> Double { +pub fn topgo_fisher_exact( + count : Int, + total : Int, + bg_count : Int, + bg_total : Int, +) -> Double { let mut p = 1.0 let max_x = if count < bg_count { count } else { bg_count } let mut x = count - + while x >= 0 && x <= max_x && p > 0.0 { - let numerator = topgo_factorial(bg_count).to_double() * topgo_factorial(bg_total - bg_count).to_double() * topgo_factorial(total).to_double() * topgo_factorial(bg_total - total).to_double() - let denominator = topgo_factorial(x).to_double() * topgo_factorial(bg_count - x).to_double() * topgo_factorial(total - x).to_double() * topgo_factorial(bg_total - bg_count - total + x).to_double() + let numerator = topgo_factorial(bg_count).to_double() * + topgo_factorial(bg_total - bg_count).to_double() * + topgo_factorial(total).to_double() * + topgo_factorial(bg_total - total).to_double() + let denominator = topgo_factorial(x).to_double() * + topgo_factorial(bg_count - x).to_double() * + topgo_factorial(total - x).to_double() * + topgo_factorial(bg_total - bg_count - total + x).to_double() if denominator > 0.0 { p = p + numerator / denominator } x = x - 1 } - - if p > 1.0 { 1.0 } else { p } + + if p > 1.0 { + 1.0 + } else { + p + } } ///| fn topgo_factorial(n : Int) -> Int { - if n <= 1 { 1 } else { n * topgo_factorial(n - 1) } + if n <= 1 { + 1 + } else { + n * topgo_factorial(n - 1) + } } ///| -pub fn topgo_elim_algorithm(graph : TopGOGraph, genes_of_interest : Array[String], all_genes : Array[String], namespace : String) -> Array[TopGOEnrichmentResult] { +pub fn topgo_elim_algorithm( + graph : TopGOGraph, + genes_of_interest : Array[String], + all_genes : Array[String], + namespace : String, +) -> Array[TopGOEnrichmentResult] { let results : Array[TopGOEnrichmentResult] = Array::new() let visited : Map[String, Bool] = Map([], capacity=1000) - + let queue : Array[String] = Array::new() queue.push(graph.root) - + let mut idx = 0 while idx < queue.length() { let node_id = queue[idx] - + if !visited.contains(node_id) { visited.set(node_id, true) - + if graph.terms.contains(node_id) { let term = graph.terms.get(node_id).unwrap() - + if namespace == "" || term.namespace == namespace { let gene_count = term.gene_count let total_genes = all_genes.length() let bg_count = gene_count let bg_total = total_genes - - let p_value = topgo_fisher_exact(gene_count, genes_of_interest.length(), bg_count, bg_total) - + + let p_value = topgo_fisher_exact( + gene_count, + genes_of_interest.length(), + bg_count, + bg_total, + ) + let children = term.children.copy() let mut j = 0 while j < children.length() { queue.push(children[j]) j = j + 1 } - + let result = TopGOEnrichmentResult::new( term.go_id, term.name, @@ -168,37 +225,47 @@ pub fn topgo_elim_algorithm(graph : TopGOGraph, genes_of_interest : Array[String 1.0 - p_value, gene_count, total_genes, - "elim" + "elim", ) results.push(result) } } } - + idx = idx + 1 } - + results } ///| -pub fn topgo_weight01_algorithm(graph : TopGOGraph, genes_of_interest : Array[String], all_genes : Array[String], namespace : String) -> Array[TopGOEnrichmentResult] { +pub fn topgo_weight01_algorithm( + graph : TopGOGraph, + genes_of_interest : Array[String], + all_genes : Array[String], + namespace : String, +) -> Array[TopGOEnrichmentResult] { let results : Array[TopGOEnrichmentResult] = Array::new() - + for key in graph.terms.keys() { let term = graph.terms.get(key).unwrap() - + if namespace == "" || term.namespace == namespace { let gene_count = term.gene_count let total_genes = all_genes.length() let bg_count = gene_count let bg_total = total_genes - - let p_value = topgo_fisher_exact(gene_count, genes_of_interest.length(), bg_count, bg_total) - + + let p_value = topgo_fisher_exact( + gene_count, + genes_of_interest.length(), + bg_count, + bg_total, + ) + let weight = if term.children.length() > 0 { 0.1 } else { 1.0 } let adjusted_p = p_value * weight - + let result = TopGOEnrichmentResult::new( term.go_id, term.name, @@ -209,36 +276,62 @@ pub fn topgo_weight01_algorithm(graph : TopGOGraph, genes_of_interest : Array[St 1.0 - p_value, gene_count, total_genes, - "weight01" + "weight01", ) results.push(result) } } - + results } ///| pub fn create_example_topgo_graph() -> TopGOGraph { let mut graph = TopGOGraph::new("GO:0008150") - + let root = TopGOTerm::new("GO:0008150", "biological_process", "BP", 0) graph = graph.add_term(root) - + let term1 = TopGOTerm::new("GO:0009987", "cellular_process", "BP", 1) - let term1 = TopGOTerm::{ go_id: term1.go_id, name: term1.name, namespace: term1.namespace, level: term1.level, parents: term1.parents, children: term1.children, gene_count: 50 } + let term1 = TopGOTerm::{ + go_id: term1.go_id, + name: term1.name, + namespace: term1.namespace, + level: term1.level, + parents: term1.parents, + children: term1.children, + gene_count: 50, + } graph = graph.add_term(term1) graph = graph.add_edge("GO:0008150", "GO:0009987") - - let term2 = TopGOTerm::new("GO:0050789", "regulation of biological process", "BP", 1) - let term2 = TopGOTerm::{ go_id: term2.go_id, name: term2.name, namespace: term2.namespace, level: term2.level, parents: term2.parents, children: term2.children, gene_count: 30 } + + let term2 = TopGOTerm::new( + "GO:0050789", "regulation of biological process", "BP", 1, + ) + let term2 = TopGOTerm::{ + go_id: term2.go_id, + name: term2.name, + namespace: term2.namespace, + level: term2.level, + parents: term2.parents, + children: term2.children, + gene_count: 30, + } graph = graph.add_term(term2) graph = graph.add_edge("GO:0008150", "GO:0050789") - + let term3 = TopGOTerm::new("GO:0006810", "transport", "BP", 2) - let term3 = TopGOTerm::{ go_id: term3.go_id, name: term3.name, namespace: term3.namespace, level: term3.level, parents: term3.parents, children: term3.children, gene_count: 20 } + let term3 = TopGOTerm::{ + go_id: term3.go_id, + name: term3.name, + namespace: term3.namespace, + level: term3.level, + parents: term3.parents, + children: term3.children, + gene_count: 20, + } graph = graph.add_term(term3) graph = graph.add_edge("GO:0009987", "GO:0006810") - + graph -} \ No newline at end of file +} diff --git a/src/tradeseq.mbt b/src/tradeseq.mbt index 73fcad44..6756070d 100644 --- a/src/tradeseq.mbt +++ b/src/tradeseq.mbt @@ -75,14 +75,9 @@ pub fn TrajectoryPoint::new( cell_id : String, pseudotime : Double, expression : Array[Double], - condition : String + condition : String, ) -> TrajectoryPoint { - TrajectoryPoint::{ - cell_id, - pseudotime, - expression, - condition - } + TrajectoryPoint::{ cell_id, pseudotime, expression, condition } } ///| @@ -90,14 +85,9 @@ pub fn GeneExpressionData::new( gene_id : String, expression : Array[Double], pseudotime : Array[Double], - condition : Array[String] + condition : Array[String], ) -> GeneExpressionData { - GeneExpressionData::{ - gene_id, - expression, - pseudotime, - condition - } + GeneExpressionData::{ gene_id, expression, pseudotime, condition } } ///| @@ -107,42 +97,48 @@ pub fn TrajectoryData::new() -> TrajectoryData { genes: Array::new(), conditions: Array::new(), n_points: 0, - n_genes: 0 + n_genes: 0, } } ///| -pub fn TrajectoryData::add_point(self : TrajectoryData, point : TrajectoryPoint) -> TrajectoryData { +pub fn TrajectoryData::add_point( + self : TrajectoryData, + point : TrajectoryPoint, +) -> TrajectoryData { let new_points = self.points new_points.push(point) - + let new_conditions = self.conditions if !tradeseq_contains_string(new_conditions, point.condition) { new_conditions.push(point.condition) } - + TrajectoryData::{ points: new_points, genes: self.genes, conditions: new_conditions, n_points: self.n_points + 1, - n_genes: self.n_genes + n_genes: self.n_genes, } } ///| -pub fn TrajectoryData::add_gene(self : TrajectoryData, gene : String) -> TrajectoryData { +pub fn TrajectoryData::add_gene( + self : TrajectoryData, + gene : String, +) -> TrajectoryData { let new_genes = self.genes if !tradeseq_contains_string(new_genes, gene) { new_genes.push(gene) } - + TrajectoryData::{ points: self.points, genes: new_genes, conditions: self.conditions, n_points: self.n_points, - n_genes: new_genes.length() + n_genes: new_genes.length(), } } @@ -151,7 +147,7 @@ pub fn fit_gam(gene_data : GeneExpressionData, n_knots : Int) -> GAMFit { let n = gene_data.expression.length() let expression = gene_data.expression let pseudotime = gene_data.pseudotime - + if n < 3 { return GAMFit::{ gene_id: gene_data.gene_id, @@ -160,32 +156,32 @@ pub fn fit_gam(gene_data : GeneExpressionData, n_knots : Int) -> GAMFit { residuals: Array::new(), r_squared: 0.0, degrees_of_freedom: 1.0, - smoothing_basis: Array::new() + smoothing_basis: Array::new(), } } - + // Sort by pseudotime let sorted_indices = tradeseq_sort_indices(pseudotime) let sorted_expression : Array[Double] = Array::new() let sorted_pseudotime : Array[Double] = Array::new() - + let mut i = 0 while i < n { sorted_expression.push(expression[sorted_indices[i]]) sorted_pseudotime.push(pseudotime[sorted_indices[i]]) i = i + 1 } - + // Create basis functions for cubic spline let n_knots_actual = if n_knots > n / 2 { n / 2 } else { n_knots } let basis = tradeseq_create_basis(sorted_pseudotime, n_knots_actual) - + // Fit using least squares (simplified) let coefficients = tradeseq_fit_coefficients(basis, sorted_expression) - + // Calculate fitted values let fitted_values = tradeseq_compute_fitted(basis, coefficients) - + // Calculate residuals let residuals : Array[Double] = Array::new() i = 0 @@ -193,10 +189,10 @@ pub fn fit_gam(gene_data : GeneExpressionData, n_knots : Int) -> GAMFit { residuals.push(sorted_expression[i] - fitted_values[i]) i = i + 1 } - + // Calculate R-squared let r_squared = tradeseq_calculate_r_squared(sorted_expression, fitted_values) - + GAMFit::{ gene_id: gene_data.gene_id, coefficients, @@ -204,7 +200,7 @@ pub fn fit_gam(gene_data : GeneExpressionData, n_knots : Int) -> GAMFit { residuals, r_squared, degrees_of_freedom: n_knots_actual.to_double() + 1.0, - smoothing_basis: basis[0] // Store first row as representative + smoothing_basis: basis[0], // Store first row as representative } } @@ -213,16 +209,16 @@ pub fn trade_test_condition_effect( gene_data : GeneExpressionData, pseudotime_point : Double, condition1 : String, - condition2 : String + condition2 : String, ) -> DifferentialExpressionResult { let n = gene_data.expression.length() - + // Calculate mean expression for each condition at nearby pseudotime points let mut sum1 = 0.0 let mut count1 = 0 let mut sum2 = 0.0 let mut count2 = 0 - + let bandwidth = 0.1 let mut i = 0 while i < n { @@ -238,16 +234,17 @@ pub fn trade_test_condition_effect( } i = i + 1 } - + let mean1 = if count1 > 0 { sum1 / count1.to_double() } else { 0.0 } let mean2 = if count2 > 0 { sum2 / count2.to_double() } else { 0.0 } - + // Calculate standard errors let var1 = if count1 > 1 { let mut s = 0.0 let mut j = 0 while j < n { - if (gene_data.pseudotime[j] - pseudotime_point).abs() < bandwidth && gene_data.condition[j] == condition1 { + if (gene_data.pseudotime[j] - pseudotime_point).abs() < bandwidth && + gene_data.condition[j] == condition1 { s = s + (gene_data.expression[j] - mean1).pow(2.0) j = j + 1 } else { @@ -255,13 +252,16 @@ pub fn trade_test_condition_effect( } } s / (count1 - 1).to_double() - } else { 1.0 } - + } else { + 1.0 + } + let var2 = if count2 > 1 { let mut s = 0.0 let mut j = 0 while j < n { - if (gene_data.pseudotime[j] - pseudotime_point).abs() < bandwidth && gene_data.condition[j] == condition2 { + if (gene_data.pseudotime[j] - pseudotime_point).abs() < bandwidth && + gene_data.condition[j] == condition2 { s = s + (gene_data.expression[j] - mean2).pow(2.0) j = j + 1 } else { @@ -269,22 +269,24 @@ pub fn trade_test_condition_effect( } } s / (count2 - 1).to_double() - } else { 1.0 } - + } else { + 1.0 + } + let se = (var1 / count1.to_double() + var2 / count2.to_double()).sqrt() let coefficient = mean1 - mean2 - + let z_statistic = if se > 0.0 { coefficient / se } else { 0.0 } let p_value = tradeseq_normal_p_value(z_statistic) - + DifferentialExpressionResult::{ gene_id: gene_data.gene_id, p_value, - adjusted_p_value: p_value, // Will be adjusted later + adjusted_p_value: p_value, // Will be adjusted later coefficient, standard_error: se, z_statistic, - significant: p_value < 0.05 + significant: p_value < 0.05, } } @@ -294,20 +296,20 @@ pub fn run_tradeseq_analysis( genes : Array[String], conditions : Array[String], n_knots : Int, - fdr : Double + fdr : Double, ) -> TradeSeqResult { let gene_results : Array[DifferentialExpressionResult] = Array::new() - + // For each gene, perform differential expression test let mut i = 0 while i < genes.length() { let gene = genes[i] - + // Create gene expression data let expression : Array[Double] = Array::new() let pseudotime : Array[Double] = Array::new() let conditions_arr : Array[String] = Array::new() - + let mut j = 0 while j < trajectory_data.points.length() { let point = trajectory_data.points[j] @@ -316,20 +318,26 @@ pub fn run_tradeseq_analysis( conditions_arr.push(point.condition) j = j + 1 } - - let gene_data = GeneExpressionData::new(gene, expression, pseudotime, conditions_arr) - + + let gene_data = GeneExpressionData::new( + gene, expression, pseudotime, conditions_arr, + ) + // Test at multiple pseudotime points let n_test_points = 10 let mut min_pt = 1.0e9 let mut max_pt = -1.0e9 let mut k = 0 while k < pseudotime.length() { - if pseudotime[k] < min_pt { min_pt = pseudotime[k] } - if pseudotime[k] > max_pt { max_pt = pseudotime[k] } + if pseudotime[k] < min_pt { + min_pt = pseudotime[k] + } + if pseudotime[k] > max_pt { + max_pt = pseudotime[k] + } k = k + 1 } - + let pt_range = max_pt - min_pt let mut min_p_value = 1.0 let mut best_result : DifferentialExpressionResult = DifferentialExpressionResult::{ @@ -339,32 +347,33 @@ pub fn run_tradeseq_analysis( coefficient: 0.0, standard_error: 1.0, z_statistic: 0.0, - significant: false + significant: false, } - + // Check condition ordering let cond1 = conditions[0] let cond2 = if conditions.length() > 1 { conditions[1] } else { "control" } - + let mut l = 0 while l < n_test_points { - let pt = min_pt + (pt_range * (l.to_double() + 0.5) / n_test_points.to_double()) + let pt = min_pt + + pt_range * (l.to_double() + 0.5) / n_test_points.to_double() let result = trade_test_condition_effect(gene_data, pt, cond1, cond2) - + if result.p_value < min_p_value { min_p_value = result.p_value best_result = result } l = l + 1 } - + gene_results.push(best_result) i = i + 1 } - + // Apply Benjamini-Hochberg correction let adjusted_results = tradeseq_bh_correction(gene_results, fdr) - + // Count significant let mut n_significant = 0 let m = adjusted_results.length() @@ -375,12 +384,12 @@ pub fn run_tradeseq_analysis( } i2 = i2 + 1 } - + TradeSeqResult::{ gene_results: adjusted_results, n_genes: m, n_significant, - fdr_threshold: fdr + fdr_threshold: fdr, } } @@ -389,13 +398,13 @@ pub fn calculate_gene_smooth( trajectory_data : TrajectoryData, gene : String, n_knots : Int, - n_points : Int + n_points : Int, ) -> SmoothResult { let expression : Array[Double] = Array::new() let pseudotime : Array[Double] = Array::new() - + let gene_idx = tradeseq_find_gene_index(trajectory_data.genes, gene) - + let mut i = 0 while i < trajectory_data.points.length() { let point = trajectory_data.points[i] @@ -403,74 +412,97 @@ pub fn calculate_gene_smooth( pseudotime.push(point.pseudotime) i = i + 1 } - - let gene_data = GeneExpressionData::new(gene, expression, pseudotime, trajectory_data.conditions) + + let gene_data = GeneExpressionData::new( + gene, + expression, + pseudotime, + trajectory_data.conditions, + ) let gam_fit = fit_gam(gene_data, n_knots) - + // Generate smooth curve at evenly spaced pseudotime points let mut min_pt = 1.0e9 let mut max_pt = -1.0e9 let mut j = 0 while j < pseudotime.length() { - if pseudotime[j] < min_pt { min_pt = pseudotime[j] } - if pseudotime[j] > max_pt { max_pt = pseudotime[j] } + if pseudotime[j] < min_pt { + min_pt = pseudotime[j] + } + if pseudotime[j] > max_pt { + max_pt = pseudotime[j] + } j = j + 1 } - + let smooth_pseudotime : Array[Double] = Array::new() let smooth_fitted : Array[Double] = Array::new() let smooth_lower : Array[Double] = Array::new() let smooth_upper : Array[Double] = Array::new() - + let pt_range = max_pt - min_pt let k = gam_fit.degrees_of_freedom.to_int() let basis = tradeseq_create_basis(pseudotime, if k > 0 { k } else { 4 }) - + let mut l = 0 while l < n_points { - let pt = min_pt + (pt_range * l.to_double() / (n_points.to_double() - 1.0)) + let pt = min_pt + pt_range * l.to_double() / (n_points.to_double() - 1.0) smooth_pseudotime.push(pt) - + // Simple interpolation based on GAM fit let fit_idx = if gam_fit.fitted_values.length() > 0 { - let idx = ((pt - min_pt) / pt_range * (gam_fit.fitted_values.length() - 1).to_double()).to_int() - if idx < 0 { 0 } else if idx >= gam_fit.fitted_values.length() { gam_fit.fitted_values.length() - 1 } else { idx } - } else { 0 } - - let fitted = if gam_fit.fitted_values.length() > 0 { gam_fit.fitted_values[fit_idx] } else { 0.0 } - let se = 0.1 // Simplified standard error - + let idx = ((pt - min_pt) / + pt_range * + (gam_fit.fitted_values.length() - 1).to_double()).to_int() + if idx < 0 { + 0 + } else if idx >= gam_fit.fitted_values.length() { + gam_fit.fitted_values.length() - 1 + } else { + idx + } + } else { + 0 + } + + let fitted = if gam_fit.fitted_values.length() > 0 { + gam_fit.fitted_values[fit_idx] + } else { + 0.0 + } + let se = 0.1 // Simplified standard error + smooth_fitted.push(fitted) smooth_lower.push(fitted - 1.96 * se) smooth_upper.push(fitted + 1.96 * se) l = l + 1 } - + SmoothResult::{ gene_id: gene, pseudotime: smooth_pseudotime, fitted: smooth_fitted, lower_ci: smooth_lower, - upper_ci: smooth_upper + upper_ci: smooth_upper, } } ///| pub fn create_example_trajectory_data() -> TrajectoryData { let mut data = TrajectoryData::new() - + // Add genes data = data.add_gene("GeneA") data = data.add_gene("GeneB") data = data.add_gene("GeneC") - + // Create 50 trajectory points with varying expression let n_cells = 50 let mut i = 0 while i < n_cells { let pseudotime = i.to_double() / (n_cells.to_double() - 1.0) let condition = if i < 25 { "control" } else { "treatment" } - + // GeneA: increases with pseudotime let gene_a = 0.5 + pseudotime * 2.0 + @math.sin(i.to_double() * 0.01) * 0.3 // GeneB: decreases then increases @@ -481,18 +513,18 @@ pub fn create_example_trajectory_data() -> TrajectoryData { } else { 2.0 + @math.sin(i.to_double() * 0.05) * 0.2 } - + let point = TrajectoryPoint::new( "cell_" + i.to_string(), pseudotime, [gene_a, gene_b, gene_c], - condition + condition, ) - + data = data.add_point(point) i = i + 1 } - + data } @@ -501,30 +533,41 @@ pub fn tradeseq_summary(result : TradeSeqResult) -> String { let mut summary = "\ntradeSeq Analysis Summary\n" summary = summary + "==============================\n" summary = summary + "Total genes tested: " + result.n_genes.to_string() + "\n" - summary = summary + "Significant genes (FDR < " + result.fdr_threshold.to_string() + "): " + result.n_significant.to_string() + "\n" - + summary = summary + + "Significant genes (FDR < " + + result.fdr_threshold.to_string() + + "): " + + result.n_significant.to_string() + + "\n" + // Sort results by p-value let n = result.gene_results.length() let sorted_indices = tradeseq_sort_by_pvalue(result.gene_results) - + summary = summary + "\nTop significant genes:\n" let n_top = if 10 < n { 10 } else { n } let mut k = 0 while k < n_top { let idx = sorted_indices[k] if result.gene_results[idx].significant { - summary = summary + " " + result.gene_results[idx].gene_id + - ": adj p-value = " + result.gene_results[idx].adjusted_p_value.to_string() + - ", coefficient = " + result.gene_results[idx].coefficient.to_string() + "\n" + summary = summary + + " " + + result.gene_results[idx].gene_id + + ": adj p-value = " + + result.gene_results[idx].adjusted_p_value.to_string() + + ", coefficient = " + + result.gene_results[idx].coefficient.to_string() + + "\n" } k = k + 1 } - + summary } // Helper functions +///| fn tradeseq_contains_string(arr : Array[String], value : String) -> Bool { let mut i = 0 while i < arr.length() { @@ -536,11 +579,12 @@ fn tradeseq_contains_string(arr : Array[String], value : String) -> Bool { false } +///| fn tradeseq_sort_indices(arr : Array[Double]) -> Array[Int] { let n = arr.length() let indices : Array[Int] = Array::new() let values : Array[Double] = Array::new() - + // Copy values and indices let mut i = 0 while i < n { @@ -548,7 +592,7 @@ fn tradeseq_sort_indices(arr : Array[Double]) -> Array[Int] { values.push(arr[i]) i = i + 1 } - + // Bubble sort by value i = 0 while i < n { @@ -559,7 +603,7 @@ fn tradeseq_sort_indices(arr : Array[Double]) -> Array[Int] { let temp_val = values[j] values[j] = values[j + 1] values[j + 1] = temp_val - + let temp_idx = indices[j] indices[j] = indices[j + 1] indices[j + 1] = temp_idx @@ -568,29 +612,33 @@ fn tradeseq_sort_indices(arr : Array[Double]) -> Array[Int] { } i = i + 1 } - + indices } -fn tradeseq_create_basis(pseudotime : Array[Double], n_knots : Int) -> Array[Array[Double]] { +///| +fn tradeseq_create_basis( + pseudotime : Array[Double], + n_knots : Int, +) -> Array[Array[Double]] { let n = pseudotime.length() - let n_basis = n_knots + 2 // Interior knots + boundary - + let n_basis = n_knots + 2 // Interior knots + boundary + // Create natural cubic spline basis let basis : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let row : Array[Double] = Array::new() let x = pseudotime[i] - + let mut j = 0 while j < n_basis { // Simple B-spline basis (simplified) let knot_pos = j.to_double() / (n_basis.to_double() - 1.0) let dist = (x - knot_pos).abs() let basis_val = if dist < 0.5 { - 1.0 - dist * 2.0 // Linear basis + 1.0 - dist * 2.0 // Linear basis } else { 0.0 } @@ -600,18 +648,22 @@ fn tradeseq_create_basis(pseudotime : Array[Double], n_knots : Int) -> Array[Arr basis.push(row) i = i + 1 } - + basis } -fn tradeseq_fit_coefficients(basis : Array[Array[Double]], y : Array[Double]) -> Array[Double] { +///| +fn tradeseq_fit_coefficients( + basis : Array[Array[Double]], + y : Array[Double], +) -> Array[Double] { let n = basis.length() let n_basis = basis[0].length() - + // Simple least squares approximation // X'X β = X'y let coefficients : Array[Double] = Array::new() - + let mut j = 0 while j < n_basis { let mut sum_x = 0.0 @@ -622,21 +674,25 @@ fn tradeseq_fit_coefficients(basis : Array[Array[Double]], y : Array[Double]) -> sum_xy = sum_xy + basis[i][j] * y[i] i = i + 1 } - + let coef = if sum_x > 0.0 { sum_xy / sum_x } else { 0.0 } coefficients.push(coef) j = j + 1 } - + coefficients } -fn tradeseq_compute_fitted(basis : Array[Array[Double]], coefficients : Array[Double]) -> Array[Double] { +///| +fn tradeseq_compute_fitted( + basis : Array[Array[Double]], + coefficients : Array[Double], +) -> Array[Double] { let n = basis.length() let n_basis = coefficients.length() - + let fitted : Array[Double] = Array::new() - + let mut i = 0 while i < n { let mut sum = 0.0 @@ -648,13 +704,17 @@ fn tradeseq_compute_fitted(basis : Array[Array[Double]], coefficients : Array[Do fitted.push(sum) i = i + 1 } - + fitted } -fn tradeseq_calculate_r_squared(observed : Array[Double], fitted : Array[Double]) -> Double { +///| +fn tradeseq_calculate_r_squared( + observed : Array[Double], + fitted : Array[Double], +) -> Double { let n = observed.length() - + // Calculate mean of observed let mut mean_y = 0.0 let mut i = 0 @@ -663,7 +723,7 @@ fn tradeseq_calculate_r_squared(observed : Array[Double], fitted : Array[Double] i = i + 1 } mean_y = mean_y / n.to_double() - + // Calculate total sum of squares let mut ss_total = 0.0 i = 0 @@ -671,7 +731,7 @@ fn tradeseq_calculate_r_squared(observed : Array[Double], fitted : Array[Double] ss_total = ss_total + (observed[i] - mean_y).pow(2.0) i = i + 1 } - + // Calculate residual sum of squares let mut ss_residual = 0.0 i = 0 @@ -679,29 +739,43 @@ fn tradeseq_calculate_r_squared(observed : Array[Double], fitted : Array[Double] ss_residual = ss_residual + (observed[i] - fitted[i]).pow(2.0) i = i + 1 } - - if ss_total == 0.0 { 0.0 } else { 1.0 - ss_residual / ss_total } + + if ss_total == 0.0 { + 0.0 + } else { + 1.0 - ss_residual / ss_total + } } +///| fn tradeseq_normal_p_value(z : Double) -> Double { // Two-tailed p-value from standard normal distribution let abs_z = if z >= 0.0 { z } else { -z } 2.0 * (1.0 - tradeseq_normal_cdf(abs_z)) } +///| fn tradeseq_normal_cdf(x : Double) -> Double { // Standard normal CDF approximation let t = 1.0 / (1.0 + 0.2316419 * x) let d = 0.3989422804014327 * @math.exp(-x * x / 2.0) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))) + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))) + ) p } -fn tradeseq_sort_by_pvalue(results : Array[DifferentialExpressionResult]) -> Array[Int] { +///| +fn tradeseq_sort_by_pvalue( + results : Array[DifferentialExpressionResult], +) -> Array[Int] { let n = results.length() let indices : Array[Int] = Array::new() let values : Array[Double] = Array::new() - + // Initialize let mut i = 0 while i < n { @@ -709,7 +783,7 @@ fn tradeseq_sort_by_pvalue(results : Array[DifferentialExpressionResult]) -> Arr values.push(results[i].p_value) i = i + 1 } - + // Bubble sort by p-value i = 0 while i < n { @@ -720,7 +794,7 @@ fn tradeseq_sort_by_pvalue(results : Array[DifferentialExpressionResult]) -> Arr let temp_val = values[j] values[j] = values[j + 1] values[j + 1] = temp_val - + // Swap indices let temp_idx = indices[j] indices[j] = indices[j + 1] @@ -730,16 +804,20 @@ fn tradeseq_sort_by_pvalue(results : Array[DifferentialExpressionResult]) -> Arr } i = i + 1 } - + indices } -fn tradeseq_bh_correction(results : Array[DifferentialExpressionResult], fdr : Double) -> Array[DifferentialExpressionResult] { +///| +fn tradeseq_bh_correction( + results : Array[DifferentialExpressionResult], + fdr : Double, +) -> Array[DifferentialExpressionResult] { let n = results.length() - + // Create sorted order by p-value let sorted_indices = tradeseq_sort_by_pvalue(results) - + // Extract sorted p-values let sorted_pvalues : Array[Double] = Array::new() let mut i = 0 @@ -747,7 +825,7 @@ fn tradeseq_bh_correction(results : Array[DifferentialExpressionResult], fdr : D sorted_pvalues.push(results[sorted_indices[i]].p_value) i = i + 1 } - + // Apply BH correction let adjusted : Array[Double] = Array::new() let mut k = 0 @@ -759,7 +837,7 @@ fn tradeseq_bh_correction(results : Array[DifferentialExpressionResult], fdr : D adjusted.push(capped) k = k + 1 } - + // Enforce monotonicity let mono = adjusted let mut l = n - 2 @@ -769,7 +847,7 @@ fn tradeseq_bh_correction(results : Array[DifferentialExpressionResult], fdr : D } l = l - 1 } - + // Map back to original positions let final_results : Array[DifferentialExpressionResult] = Array::new() let mut m = 0 @@ -779,14 +857,15 @@ fn tradeseq_bh_correction(results : Array[DifferentialExpressionResult], fdr : D final_results.push(DifferentialExpressionResult::{ ..results[orig_idx], adjusted_p_value: adj_p, - significant: adj_p < fdr + significant: adj_p < fdr, }) m = m + 1 } - + final_results } +///| fn tradeseq_find_gene_index(genes : Array[String], gene : String) -> Int { let mut i = 0 while i < genes.length() { diff --git a/src/transfac.mbt b/src/transfac.mbt index 524eab12..259bfe08 100644 --- a/src/transfac.mbt +++ b/src/transfac.mbt @@ -79,7 +79,7 @@ pub struct TransfacMotifFull { ///| /// Create a new TransfacMotifFull. -pub fn TransfacMotifFull::new(accession~ : String = "") -> TransfacMotifFull { +pub fn TransfacMotifFull::new(accession? : String = "") -> TransfacMotifFull { TransfacMotifFull::{ accession, identifier: "", @@ -124,7 +124,10 @@ pub fn TransfacMotifFull::consensus(self : TransfacMotifFull) -> String { ///| /// Get the total count at a position (sum of all bases). -pub fn TransfacMotifFull::total_at(self : TransfacMotifFull, position : Int) -> Int { +pub fn TransfacMotifFull::total_at( + self : TransfacMotifFull, + position : Int, +) -> Int { if position < 0 || position >= self.width { return 0 } @@ -160,7 +163,10 @@ pub fn TransfacMotifFull::frequency( ///| /// Find the index of a base in the alphabet. -pub fn TransfacMotifFull::alphabet_index(self : TransfacMotifFull, base : String) -> Int { +pub fn TransfacMotifFull::alphabet_index( + self : TransfacMotifFull, + base : String, +) -> Int { let mut i = 0 while i < self.alphabet.length() { if self.alphabet[i] == base { @@ -192,7 +198,10 @@ pub fn TransfacRecordFull::num_motifs(self : TransfacRecordFull) -> Int { ///| /// Find a motif by accession number. -pub fn TransfacRecordFull::find(self : TransfacRecordFull, accession : String) -> TransfacMotifFull? { +pub fn TransfacRecordFull::find( + self : TransfacRecordFull, + accession : String, +) -> TransfacMotifFull? { for m in self.motifs { if m.accession == accession { return Some(m) @@ -262,7 +271,11 @@ pub fn transfac_parse_full(text : String) -> TransfacRecordFull { continue } // Helper to finalize current reference - if field != "RA" && field != "RT" && field != "RL" && field != "RX" && has_ref { + if field != "RA" && + field != "RT" && + field != "RL" && + field != "RX" && + has_ref { let r = TransfacReference::new() r.number = ref_number r.authors = ref_authors @@ -471,7 +484,10 @@ pub fn transfac_parse_full(text : String) -> TransfacRecordFull { continue } // Matrix data rows (start with digits) - if in_matrix && field.length() >= 2 && field[0:1].to_string() >= "0" && field[0:1].to_string() <= "9" { + if in_matrix && + field.length() >= 2 && + field[0:1].to_string() >= "0" && + field[0:1].to_string() <= "9" { // Parse the row number and counts let parts = trimmed.split(" ").to_array() let counts : Array[Int] = Array::new() @@ -626,12 +642,7 @@ pub fn transfac_sample_motif_full() -> TransfacMotifFull { m.species = "Homo sapiens" m.binding_factors.push("Jun") m.binding_factors.push("Fos") - m.pfm = [ - [4, 0, 0, 0, 3], - [0, 0, 4, 0, 1], - [0, 4, 0, 0, 0], - [0, 0, 0, 4, 0], - ] + m.pfm = [[4, 0, 0, 0, 3], [0, 0, 4, 0, 1], [0, 4, 0, 0, 0], [0, 0, 0, 4, 0]] m.width = 5 m.comments = "AP-1 transcription factor binding site" m diff --git a/src/trie.mbt b/src/trie.mbt index ae985d47..17bd8a4b 100644 --- a/src/trie.mbt +++ b/src/trie.mbt @@ -50,10 +50,7 @@ pub struct Trie { /// Create a new empty trie. pub fn Trie::new() -> Trie { Trie::{ - root: TrieNode::{ - children: Map([], capacity=4), - value: TrieValue::Empty, - }, + root: TrieNode::{ children: Map([], capacity=4), value: TrieValue::Empty }, count: 0, } } @@ -61,10 +58,7 @@ pub fn Trie::new() -> Trie { ///| /// Create a new TrieNode. pub fn TrieNode::new() -> TrieNode { - TrieNode::{ - children: Map([], capacity=4), - value: TrieValue::Empty, - } + TrieNode::{ children: Map([], capacity=4), value: TrieValue::Empty } } ///| @@ -141,7 +135,10 @@ pub fn trie_size(trie : Trie) -> Int { ///| /// Find all keys with the given prefix. /// Returns an array of (key, value) tuples. -pub fn trie_with_prefix(trie : Trie, prefix : String) -> Array[(String, String)] { +pub fn trie_with_prefix( + trie : Trie, + prefix : String, +) -> Array[(String, String)] { let result : Array[(String, String)] = Array::new() let start_node = trie_find_node(trie.root, prefix) match start_node { @@ -234,7 +231,10 @@ pub fn triefind_match(trie : Trie, text : String) -> (String, String)? { ///| /// Find all keys in the trie that match the beginning of the string. /// Returns a list of (key, value) tuples, ordered by increasing key length. -pub fn triefind_match_all(trie : Trie, text : String) -> Array[(String, String)] { +pub fn triefind_match_all( + trie : Trie, + text : String, +) -> Array[(String, String)] { let result : Array[(String, String)] = Array::new() let mut current = trie.root let mut prefix = "" @@ -261,7 +261,10 @@ pub fn triefind_match_all(trie : Trie, text : String) -> Array[(String, String)] ///| /// Find all keys in the trie that match anywhere in the string. /// Returns a list of (key, value, start, end) tuples. -pub fn triefind_find(trie : Trie, text : String) -> Array[(String, String, Int, Int)] { +pub fn triefind_find( + trie : Trie, + text : String, +) -> Array[(String, String, Int, Int)] { let result : Array[(String, String, Int, Int)] = Array::new() let mut start = 0 while start < text.length() { @@ -284,13 +287,19 @@ pub fn triefind_find(trie : Trie, text : String) -> Array[(String, String, Int, /// Find all keys in the trie that match whole words in the string. /// Word boundaries are defined as any punctuation, whitespace, or string start/end. /// Returns a list of (key, value, start, end) tuples. -pub fn triefind_find_words(trie : Trie, text : String) -> Array[(String, String, Int, Int)] { +pub fn triefind_find_words( + trie : Trie, + text : String, +) -> Array[(String, String, Int, Int)] { let result : Array[(String, String, Int, Int)] = Array::new() let mut start = 0 while start < text.length() { // Check if this position is at a word boundary if start == 0 || trie_is_boundary(text[start - 1:start].to_owned()) { - let matches = triefind_match_all(trie, text[start:text.length()].to_owned()) + let matches = triefind_match_all( + trie, + text[start:text.length()].to_owned(), + ) let mut j = 0 while j < matches.length() { let pair = matches[j] @@ -298,7 +307,8 @@ pub fn triefind_find_words(trie : Trie, text : String) -> Array[(String, String, let val = pair.1 let end = start + key.length() // Check that the character after the match is also a boundary - if end >= text.length() || trie_is_boundary(text[end:end + 1].to_owned()) { + if end >= text.length() || + trie_is_boundary(text[end:end + 1].to_owned()) { result.push((key, val, start, end)) } j = j + 1 @@ -332,7 +342,11 @@ fn trie_find_node(root : TrieNode, key : String) -> TrieNode? { ///| /// Recursively collect all keys from a node. -fn trie_collect_keys(node : TrieNode, prefix : String, result : Array[String]) -> Unit { +fn trie_collect_keys( + node : TrieNode, + prefix : String, + result : Array[String], +) -> Unit { match node.value { TrieValue::Value(_) => result.push(prefix) TrieValue::Empty => () @@ -353,7 +367,7 @@ fn trie_collect_keys(node : TrieNode, prefix : String, result : Array[String]) - fn trie_collect_pairs( node : TrieNode, prefix : String, - result : Array[(String, String)] + result : Array[(String, String)], ) -> Unit { match node.value { TrieValue::Value(v) => result.push((prefix, v)) diff --git a/src/twobit_io.mbt b/src/twobit_io.mbt index b59f613f..5289111e 100644 --- a/src/twobit_io.mbt +++ b/src/twobit_io.mbt @@ -61,7 +61,11 @@ pub fn TwoBitNBlock::end(self : TwoBitNBlock) -> Int { ///| /// Human-readable representation. pub fn TwoBitNBlock::to_string(self : TwoBitNBlock) -> String { - "NBlock(start=" + self.start.to_string() + ", size=" + self.size.to_string() + ")" + "NBlock(start=" + + self.start.to_string() + + ", size=" + + self.size.to_string() + + ")" } // ============================================================================ @@ -103,7 +107,11 @@ pub fn TwoBitMaskBlock::end(self : TwoBitMaskBlock) -> Int { ///| /// Human-readable representation. pub fn TwoBitMaskBlock::to_string(self : TwoBitMaskBlock) -> String { - "MaskBlock(start=" + self.start.to_string() + ", size=" + self.size.to_string() + ")" + "MaskBlock(start=" + + self.start.to_string() + + ", size=" + + self.size.to_string() + + ")" } // ============================================================================ @@ -161,7 +169,9 @@ pub fn TwoBitSequence::n_blocks(self : TwoBitSequence) -> Array[TwoBitNBlock] { ///| /// Mask-blocks (regions of soft-masked / lowercase bases). -pub fn TwoBitSequence::mask_blocks(self : TwoBitSequence) -> Array[TwoBitMaskBlock] { +pub fn TwoBitSequence::mask_blocks( + self : TwoBitSequence, +) -> Array[TwoBitMaskBlock] { self.mask_blocks.copy() } @@ -234,7 +244,10 @@ pub fn TwoBitFile::version(self : TwoBitFile) -> Int { ///| /// Append a sequence to the file. -pub fn TwoBitFile::add_sequence(self : TwoBitFile, seq : TwoBitSequence) -> Unit { +pub fn TwoBitFile::add_sequence( + self : TwoBitFile, + seq : TwoBitSequence, +) -> Unit { self.sequences.push(seq) } @@ -356,7 +369,7 @@ pub fn twobit_pack_sequence( } // Pack code into the correct byte and bit position. let byte_idx = i / 4 - let shift = 6 - (i % 4) * 2 + let shift = 6 - i % 4 * 2 packed[byte_idx] = packed[byte_idx] | (code << shift) // Update N-block tracking. if is_n { @@ -380,12 +393,10 @@ pub fn twobit_pack_sequence( mask_start = i } mask_size = mask_size + 1 - } else { // Close any open mask-block. - if mask_size > 0 { - mask_blocks.push(TwoBitMaskBlock::new(mask_start, mask_size)) - mask_size = 0 - } + } else if mask_size > 0 { + mask_blocks.push(TwoBitMaskBlock::new(mask_start, mask_size)) + mask_size = 0 } } } @@ -414,7 +425,7 @@ pub fn twobit_unpack_sequence( let codes : Array[Int] = Array::new() for i in 0..> shift) & 3 codes.push(twobit_code_to_base(code).to_int()) } @@ -459,7 +470,10 @@ fn twobit_encode_u32_le(v : Int) -> Array[Int] { ///| /// Read a 32-bit little-endian unsigned integer from a byte array at `pos`. fn twobit_read_u32_le(bytes : Array[Int], pos : Int) -> Int { - bytes[pos] | (bytes[pos + 1] << 8) | (bytes[pos + 2] << 16) | (bytes[pos + 3] << 24) + bytes[pos] | + (bytes[pos + 1] << 8) | + (bytes[pos + 2] << 16) | + (bytes[pos + 3] << 24) } // ============================================================================ @@ -484,7 +498,13 @@ pub fn twobit_to_bytes(tbf : TwoBitFile) -> Array[Int] { offsets.push(current_offset) let seq = seqs[i] let packed_size = (seq.dna_size + 3) / 4 - let seq_data_size = 4 + packed_size + 4 + 8 * seq.n_blocks.length() + 4 + 8 * seq.mask_blocks.length() + 4 + let seq_data_size = 4 + + packed_size + + 4 + + 8 * seq.n_blocks.length() + + 4 + + 8 * seq.mask_blocks.length() + + 4 current_offset = current_offset + seq_data_size } // ---- Header (16 bytes) ---- diff --git a/src/uniprot_io.mbt b/src/uniprot_io.mbt index c4165bde..c7787ac6 100644 --- a/src/uniprot_io.mbt +++ b/src/uniprot_io.mbt @@ -300,7 +300,10 @@ fn extract_all_tags(xml : String, tag : String) -> Array[String] { ///| /// Extract all occurrences of a tag with their opening tag string. /// Returns pairs of (opening_tag_string, inner_content). -fn extract_all_tags_with_attrs(xml : String, tag : String) -> Array[(String, String)] { +fn extract_all_tags_with_attrs( + xml : String, + tag : String, +) -> Array[(String, String)] { let results : Array[(String, String)] = Array::new() let open_tag = "<" + tag let close_tag = "" @@ -397,7 +400,11 @@ fn extract_sequence(entry_xml : String) -> (String, Int, Double) { if seq_block.length() == 0 { return ("", 0, 0.0) } - let seq = seq_block.replace(old="\n", new="").replace(old=" ", new="").trim().to_owned() + let seq = seq_block + .replace(old="\n", new="") + .replace(old=" ", new="") + .trim() + .to_owned() // Extract mass attribute let mass_attr = extract_attribute(entry_xml, "sequence", "mass") let mass = if mass_attr.length() > 0 { u_parse_float(mass_attr) } else { 0.0 } @@ -531,7 +538,9 @@ fn extract_references(entry_xml : String) -> Array[UniprotReference] { "" } if key.length() > 0 { - refs.push(UniprotReference::new(key, title, authors, journal, pubmed_id, "")) + refs.push( + UniprotReference::new(key, title, authors, journal, pubmed_id, ""), + ) } } refs @@ -584,7 +593,9 @@ pub fn parse_uniprot_entry(entry_xml : String) -> UniprotEntry { // Extract sequence let (sequence, _, _) = extract_sequence(entry_xml) // Create base entry - let entry = UniprotEntry::new(accession, protein_name, gene_names, organism, sequence) + let entry = UniprotEntry::new( + accession, protein_name, gene_names, organism, sequence, + ) // Extract sequence with mass let (_, seq_len, seq_mass) = extract_sequence(entry_xml) entry.seq_length = seq_len @@ -627,7 +638,9 @@ pub fn parse_uniprot_xml(content : String) -> Array[UniprotEntry] { ///| /// Convert a UniprotEntry to a SeqRecord-compatible map. /// Returns a tuple of (id, description, sequence, annotations). -pub fn uniprot_to_seqrecord(entry : UniprotEntry) -> (String, String, String, Map[String, String]) { +pub fn uniprot_to_seqrecord( + entry : UniprotEntry, +) -> (String, String, String, Map[String, String]) { let id = entry.accession let description = entry.protein_name let annotations : Map[String, String] = Map([], capacity=16) diff --git a/src/universalmotif.mbt b/src/universalmotif.mbt index e689f600..23639f59 100644 --- a/src/universalmotif.mbt +++ b/src/universalmotif.mbt @@ -10,12 +10,21 @@ pub struct S4Motif { } ///| -pub fn S4Motif::new(name : String, alphabet : String, pwm : Array[Array[Double]], consensus : String) -> S4Motif { +pub fn S4Motif::new( + name : String, + alphabet : String, + pwm : Array[Array[Double]], + consensus : String, +) -> S4Motif { S4Motif::{ name, alphabet, pwm, consensus } } ///| -pub fn S4Motif::from_pwm(name : String, alphabet : String, pwm : Array[Array[Double]]) -> S4Motif { +pub fn S4Motif::from_pwm( + name : String, + alphabet : String, + pwm : Array[Array[Double]], +) -> S4Motif { let consensus = calculate_consensus(pwm, alphabet) S4Motif::new(name, alphabet, pwm, consensus) } @@ -23,14 +32,14 @@ pub fn S4Motif::from_pwm(name : String, alphabet : String, pwm : Array[Array[Dou ///| fn calculate_consensus(pwm : Array[Array[Double]], alphabet : String) -> String { let letters = if alphabet == "DNA" { ["A", "C", "G", "T"] } else { ["A"] } - + let mut result = "" - + let mut i = 0 while i < pwm.length() { let mut max_prob = 0.0 let mut max_idx = 0 - + let mut j = 0 while j < pwm[i].length() { if pwm[i][j] > max_prob { @@ -39,13 +48,13 @@ fn calculate_consensus(pwm : Array[Array[Double]], alphabet : String) -> String } j = j + 1 } - + if max_idx < letters.length() { result = result + letters[max_idx] } i = i + 1 } - + result } @@ -58,6 +67,6 @@ pub fn create_example_s4motif() -> S4Motif { [0.1, 0.9, 0.0, 0.0], [0.1, 0.9, 0.0, 0.0], ] - + S4Motif::from_pwm("TATA-box", "DNA", pwm) -} \ No newline at end of file +} diff --git a/src/utils.mbt b/src/utils.mbt index 1d92e47d..0c57054c 100644 --- a/src/utils.mbt +++ b/src/utils.mbt @@ -295,10 +295,10 @@ pub fn to_lowercase(s : String) -> String { 88 => result = result + "x" 89 => result = result + "y" 90 => result = result + "z" - _ => result = result + s[i:i+1].to_string() + _ => result = result + s[i:i + 1].to_string() } } else { - result = result + s[i:i+1].to_string() + result = result + s[i:i + 1].to_string() } i = i + 1 } diff --git a/src/uwot.mbt b/src/uwot.mbt index 3f41fd75..67b2d264 100644 --- a/src/uwot.mbt +++ b/src/uwot.mbt @@ -42,15 +42,15 @@ pub fn UmapConfig::new_custom( random_seed : Int, ) -> UmapConfig { UmapConfig::{ - n_neighbors: n_neighbors, - n_components: n_components, - n_epochs: n_epochs, + n_neighbors, + n_components, + n_epochs, min_dist: 0.1, spread: 1.0, learning_rate: 1.0, repulsion_strength: 1.0, negative_sample_rate: 5.0, - random_seed: random_seed, + random_seed, metric: "euclidean", } } @@ -64,16 +64,14 @@ pub struct UmapResult { ///| pub fn UmapResult::new() -> UmapResult { - UmapResult::{ - embedding: Array::new(), - n_epochs: 0, - } + UmapResult::{ embedding: Array::new(), n_epochs: 0 } } // ============================================================ // Distance and knn functions // ============================================================ +///| fn uwot_euclidean_distance(x : Array[Double], y : Array[Double]) -> Double { let mut sum_sq = 0.0 let n = if x.length() < y.length() { x.length() } else { y.length() } @@ -88,14 +86,16 @@ fn uwot_euclidean_distance(x : Array[Double], y : Array[Double]) -> Double { ///| /// Compute pairwise distance matrix. -pub fn uwot_distance_matrix(data : Array[Array[Double]]) -> Array[Array[Double]] { +pub fn uwot_distance_matrix( + data : Array[Array[Double]], +) -> Array[Array[Double]] { let n = data.length() let dist_matrix : Array[Array[Double]] = Array::new() - + if n == 0 { return dist_matrix } - + let mut i = 0 while i < n { let row : Array[Double] = Array::new() @@ -107,7 +107,7 @@ pub fn uwot_distance_matrix(data : Array[Array[Double]]) -> Array[Array[Double]] dist_matrix.push(row) i = i + 1 } - + let mut i = 0 while i < n { let mut j = i + 1 @@ -119,23 +119,26 @@ pub fn uwot_distance_matrix(data : Array[Array[Double]]) -> Array[Array[Double]] } i = i + 1 } - + dist_matrix } ///| /// Find k-nearest neighbors for each point. /// Returns: for each point, array of (neighbor_index, distance) pairs -fn find_knn(dist_matrix : Array[Array[Double]], k : Int) -> Array[Array[(Int, Double)]] { +fn find_knn( + dist_matrix : Array[Array[Double]], + k : Int, +) -> Array[Array[(Int, Double)]] { let n = dist_matrix.length() let result : Array[Array[(Int, Double)]] = Array::new() - + if n == 0 || k <= 0 { return result } - + let actual_k = if k < n { k } else { n - 1 } - + let mut i = 0 while i < n { // Create list of (index, distance) for all other points @@ -147,7 +150,7 @@ fn find_knn(dist_matrix : Array[Array[Double]], k : Int) -> Array[Array[(Int, Do } j = j + 1 } - + // Simple selection sort to find k nearest let knn : Array[(Int, Double)] = Array::new() let mut selected = 0 @@ -165,24 +168,24 @@ fn find_knn(dist_matrix : Array[Array[Double]], k : Int) -> Array[Array[(Int, Do } s = s + 1 } - + if !already_selected && neighbors[j].1 < min_dist { min_dist = neighbors[j].1 min_idx = j } j = j + 1 } - + if min_idx >= 0 { knn.push(neighbors[min_idx]) } selected = selected + 1 } - + result.push(knn) i = i + 1 } - + result } @@ -192,7 +195,11 @@ fn find_knn(dist_matrix : Array[Array[Double]], k : Int) -> Array[Array[(Int, Do ///| /// Compute the membership strength for a distance using the smooth k-nn distance. -fn compute_membership(distance : Double, rho : Double, sigma : Double) -> Double { +fn compute_membership( + distance : Double, + rho : Double, + sigma : Double, +) -> Double { if distance <= rho { return 1.0 } @@ -209,7 +216,7 @@ fn find_sigma( ) -> Double { let mut lo = 0.0 let mut hi = 1000.0 - + let mut mid = 1.0 let mut iter = 0 while iter < 64 { @@ -217,21 +224,22 @@ fn find_sigma( let mut sum_membership = 0.0 let mut i = 0 while i < n_neighbors && i < distances.length() { - sum_membership = sum_membership + compute_membership(distances[i], rho, mid) + sum_membership = sum_membership + + compute_membership(distances[i], rho, mid) i = i + 1 } - + let log_sum = @math.log2(sum_membership) - + if log_sum > target_log2 { hi = mid } else { lo = mid } - + iter = iter + 1 } - + mid } @@ -246,7 +254,7 @@ fn build_graph( ) -> Array[Array[Double]] { let n = data.length() let n_neighbors = config.n_neighbors - + // Initialize graph let graph : Array[Array[Double]] = Array::new() let mut i = 0 @@ -260,20 +268,24 @@ fn build_graph( graph.push(row) i = i + 1 } - + // Target entropy = log2(n_neighbors) let target_log2 = @math.log2(n_neighbors.to_double()) - + // For each point, compute rho (distance to nearest neighbor) and sigma let sigmas : Array[Double] = Array::new() let rhos : Array[Double] = Array::new() - + let mut i = 0 while i < n { // rho = distance to nearest neighbor - let rho = if knn_distances[i].length() > 0 { knn_distances[i][0] } else { 0.0 } + let rho = if knn_distances[i].length() > 0 { + knn_distances[i][0] + } else { + 0.0 + } rhos.push(rho) - + // Find sigma using binary search let distances : Array[Double] = Array::new() let mut j = 0 @@ -281,13 +293,13 @@ fn build_graph( distances.push(knn_distances[i][j]) j = j + 1 } - + let sigma = find_sigma(distances, rho, target_log2, n_neighbors) sigmas.push(sigma) - + i = i + 1 } - + // Build the graph with asymmetric memberships let mut i = 0 while i < n { @@ -295,15 +307,15 @@ fn build_graph( while j < knn_indices[i].length() { let neighbor_idx = knn_indices[i][j] let dist = knn_distances[i][j] - + let membership_i_to_j = compute_membership(dist, rhos[i], sigmas[i]) graph[i][neighbor_idx] = membership_i_to_j - + j = j + 1 } i = i + 1 } - + // Symmetrize the graph: w_ij = w_ij + w_ji - w_ij * w_ji let mut i = 0 while i < n { @@ -318,7 +330,7 @@ fn build_graph( } i = i + 1 } - + graph } @@ -338,11 +350,11 @@ fn find_ab(min_dist : Double, spread : Double) -> (Double, Double) { // Curve: 1 / (1 + a * x^(2b)) // At x = min_dist: y = 0.5 (approximately) // At x = spread: y is small - + // Simplified parameter estimation let a = 1.576942937 let b = 0.895061728 - + // Scale based on min_dist and spread let scaled_a = a / @math.pow(spread, 2.0 * b) (scaled_a, b) @@ -350,9 +362,13 @@ fn find_ab(min_dist : Double, spread : Double) -> (Double, Double) { ///| /// Initialize the embedding with small random values. -fn initialize_embedding(n : Int, n_components : Int, seed : Int) -> Array[Array[Double]] { +fn initialize_embedding( + n : Int, + n_components : Int, + seed : Int, +) -> Array[Array[Double]] { let embedding : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let row : Array[Double] = Array::new() @@ -366,19 +382,22 @@ fn initialize_embedding(n : Int, n_components : Int, seed : Int) -> Array[Array[ embedding.push(row) i = i + 1 } - + embedding } ///| /// Main UMAP algorithm. -pub fn uwot_umap(data : Array[Array[Double]], config : UmapConfig) -> UmapResult { +pub fn uwot_umap( + data : Array[Array[Double]], + config : UmapConfig, +) -> UmapResult { let n = data.length() - + if n == 0 { return UmapResult::new() } - + if n < 2 { let result = UmapResult::new() let embedding : Array[Array[Double]] = Array::new() @@ -391,18 +410,18 @@ pub fn uwot_umap(data : Array[Array[Double]], config : UmapConfig) -> UmapResult embedding.push(row) return result } - + // Step 1: Compute distance matrix let dist_matrix = uwot_distance_matrix(data) - + // Step 2: Find k-nearest neighbors let k = if config.n_neighbors < n - 1 { config.n_neighbors } else { n - 1 } let knn = find_knn(dist_matrix, k) - + // Extract knn indices and distances let knn_indices : Array[Array[Int]] = Array::new() let knn_distances : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let indices : Array[Int] = Array::new() @@ -417,20 +436,24 @@ pub fn uwot_umap(data : Array[Array[Double]], config : UmapConfig) -> UmapResult knn_distances.push(distances) i = i + 1 } - + // Step 3: Build fuzzy simplicial set let graph = build_graph(data, dist_matrix, knn_indices, knn_distances, config) - + // Step 4: Find a and b parameters let (a, b) = find_ab(config.min_dist, config.spread) - + // Step 5: Initialize embedding - let embedding = initialize_embedding(n, config.n_components, config.random_seed) - + let embedding = initialize_embedding( + n, + config.n_components, + config.random_seed, + ) + // Step 6: Optimize embedding using stochastic gradient descent let epochs_per_sample : Array[Array[Int]] = Array::new() let epoch_of_next_sample : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let eps_row : Array[Int] = Array::new() @@ -445,7 +468,7 @@ pub fn uwot_umap(data : Array[Array[Double]], config : UmapConfig) -> UmapResult epoch_of_next_sample.push(eons_row) i = i + 1 } - + // Compute epochs per sample based on graph weights let max_epochs = config.n_epochs.to_double() let mut max_weight = 0.0 @@ -460,11 +483,11 @@ pub fn uwot_umap(data : Array[Array[Double]], config : UmapConfig) -> UmapResult } i = i + 1 } - + if max_weight == 0.0 { max_weight = 1.0 } - + let mut i = 0 while i < n { let mut j = 0 @@ -483,7 +506,7 @@ pub fn uwot_umap(data : Array[Array[Double]], config : UmapConfig) -> UmapResult } i = i + 1 } - + // SGD optimization let mut epoch = 0 while epoch < config.n_epochs { @@ -501,25 +524,33 @@ pub fn uwot_umap(data : Array[Array[Double]], config : UmapConfig) -> UmapResult dist_sq = dist_sq + diff * diff d = d + 1 } - - let grad_coeff = (-2.0 * a * b * @math.pow(dist_sq, b - 1.0)) / (1.0 + a * @math.pow(dist_sq, b)) - + + let grad_coeff = -2.0 * + a * + b * + @math.pow(dist_sq, b - 1.0) / + (1.0 + a * @math.pow(dist_sq, b)) + let mut d = 0 while d < config.n_components { - let grad = config.learning_rate * grad_coeff * (embedding[i][d] - embedding[j][d]) + let grad = config.learning_rate * + grad_coeff * + (embedding[i][d] - embedding[j][d]) embedding[i][d] = embedding[i][d] + grad embedding[j][d] = embedding[j][d] - grad d = d + 1 } - + // Negative samples: move points apart let n_neg = config.negative_sample_rate.to_int() let mut neg = 0 while neg < n_neg { // Pick random negative sample - let rand_val = umap_pseudo_random((epoch * n + i * n_neg + neg + config.random_seed).to_double()) + let rand_val = umap_pseudo_random( + (epoch * n + i * n_neg + neg + config.random_seed).to_double(), + ) let k_random = (rand_val * n.to_double()).to_int() - + if k_random != i && k_random != j { let mut dist_sq_neg = 0.0 let mut d = 0 @@ -528,41 +559,48 @@ pub fn uwot_umap(data : Array[Array[Double]], config : UmapConfig) -> UmapResult dist_sq_neg = dist_sq_neg + diff * diff d = d + 1 } - - let grad_coeff_neg = (2.0 * b * config.repulsion_strength) / ((0.001 + dist_sq_neg) * (1.0 + a * @math.pow(dist_sq_neg, b))) - + + let grad_coeff_neg = 2.0 * + b * + config.repulsion_strength / + ( + (0.001 + dist_sq_neg) * + (1.0 + a * @math.pow(dist_sq_neg, b)) + ) + let mut d = 0 while d < config.n_components { - let grad = config.learning_rate * grad_coeff_neg * (embedding[i][d] - embedding[k_random][d]) + let grad = config.learning_rate * + grad_coeff_neg * + (embedding[i][d] - embedding[k_random][d]) embedding[i][d] = embedding[i][d] + grad d = d + 1 } } - + neg = neg + 1 } - - epoch_of_next_sample[i][j] = epoch_of_next_sample[i][j] + epochs_per_sample[i][j].to_double() + + epoch_of_next_sample[i][j] = epoch_of_next_sample[i][j] + + epochs_per_sample[i][j].to_double() } } j = j + 1 } i = i + 1 } - + epoch = epoch + 1 } - - UmapResult::{ - embedding: embedding, - n_epochs: config.n_epochs, - } + + UmapResult::{ embedding, n_epochs: config.n_epochs } } // ============================================================ // Helper functions // ============================================================ +///| fn umap_pseudo_random(seed : Double) -> Double { let x = seed * 12.9898 let y_val = seed * 78.233 @@ -574,14 +612,17 @@ fn umap_pseudo_random(seed : Double) -> Double { ///| /// Create sample data for testing/demo. -pub fn create_umap_test_data(n_samples : Int, n_features : Int) -> Array[Array[Double]] { +pub fn create_umap_test_data( + n_samples : Int, + n_features : Int, +) -> Array[Array[Double]] { let data : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_samples { let row : Array[Double] = Array::new() - let group = i % 4 // 4 clusters - + let group = i % 4 // 4 clusters + let mut j = 0 while j < n_features { let seed_val = (i * n_features + j).to_double() @@ -590,10 +631,10 @@ pub fn create_umap_test_data(n_samples : Int, n_features : Int) -> Array[Array[D row.push(cluster_center + noise) j = j + 1 } - + data.push(row) i = i + 1 } - + data } diff --git a/src/variance_partition.mbt b/src/variance_partition.mbt index 2b10dd92..9a974609 100644 --- a/src/variance_partition.mbt +++ b/src/variance_partition.mbt @@ -1472,12 +1472,8 @@ fn vp_satterthwaite_df( ///| fn vp_log_gamma(value : Double) -> Double { let coefficients = [ - 76.18009172947146, - -86.50532032941677, - 24.01409824083091, - -1.231739572450155, - 0.001208650973866179, - -0.000005395239384953, + 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, + 0.001208650973866179, -0.000005395239384953, ] let mut shifted = value let temporary = value + 5.5 @@ -1491,11 +1487,7 @@ fn vp_log_gamma(value : Double) -> Double { } ///| -fn vp_beta_continued_fraction( - x : Double, - a : Double, - b : Double, -) -> Double { +fn vp_beta_continued_fraction(x : Double, a : Double, b : Double) -> Double { let maximum_iterations = 200 let epsilon = 3.0e-14 let minimum = 1.0e-300 diff --git a/src/variant_filtering.mbt b/src/variant_filtering.mbt index 90f50dd3..3c651c12 100644 --- a/src/variant_filtering.mbt +++ b/src/variant_filtering.mbt @@ -1,5 +1,4 @@ ///| - pub struct Variant { chr : String pos : Int @@ -12,6 +11,7 @@ pub struct Variant { genotypes : Array[(String, String)] } +///| pub struct VariantFilteringParam { min_qual : Double min_depth : Int @@ -22,12 +22,14 @@ pub struct VariantFilteringParam { max_af_pop : Double } +///| pub struct VariantFilterResult { passed_variants : Array[Variant] filtered_variants : Array[(Variant, String)] filter_stats : Map[String, Int] } +///| pub struct GeneticModel { model_type : String penetrance : Double @@ -35,88 +37,129 @@ pub struct GeneticModel { allele_frequency : Double } -pub fn Variant::new(chr : String, pos : Int, id : String, ref_allele : String, - alt_allele : String, qual : Double, filter : String, - info : Map[String, String], genotypes : Array[(String, String)]) -> Variant { - Variant::{ chr, pos, id, ref_allele, alt_allele, qual, filter, info, genotypes } +///| +pub fn Variant::new( + chr : String, + pos : Int, + id : String, + ref_allele : String, + alt_allele : String, + qual : Double, + filter : String, + info : Map[String, String], + genotypes : Array[(String, String)], +) -> Variant { + Variant::{ + chr, + pos, + id, + ref_allele, + alt_allele, + qual, + filter, + info, + genotypes, + } } +///| pub fn VariantFilteringParam::new() -> VariantFilteringParam { - VariantFilteringParam::{ - min_qual: 30.0, - min_depth: 10, - min_allele_freq: 0.01, + VariantFilteringParam::{ + min_qual: 30.0, + min_depth: 10, + min_allele_freq: 0.01, max_missing_rate: 0.2, inheritance_mode: "autosomal_dominant", min_gq: 20, - max_af_pop: 0.01 + max_af_pop: 0.01, } } +///| pub fn VariantFilterResult::new() -> VariantFilterResult { - VariantFilterResult::{ - passed_variants: Array::new(), - filtered_variants: Array::new(), - filter_stats: Map([], capacity=0) + VariantFilterResult::{ + passed_variants: Array::new(), + filtered_variants: Array::new(), + filter_stats: Map([], capacity=0), } } +///| pub fn GeneticModel::new(model_type : String) -> GeneticModel { - let penetrance = - if model_type == "autosomal_dominant" { 0.95 } - else if model_type == "autosomal_recessive" { 0.95 } - else if model_type == "x_linked_dominant" { 0.95 } - else if model_type == "x_linked_recessive" { 0.95 } - else if model_type == "compound_heterozygous" { 0.95 } - else { 0.95 } - - GeneticModel::{ model_type, penetrance, phenocopy_rate: 0.01, allele_frequency: 0.001 } -} - -pub fn bio_vfilter_filter(variants : Array[Variant], params : VariantFilteringParam) -> VariantFilterResult { + let penetrance = if model_type == "autosomal_dominant" { + 0.95 + } else if model_type == "autosomal_recessive" { + 0.95 + } else if model_type == "x_linked_dominant" { + 0.95 + } else if model_type == "x_linked_recessive" { + 0.95 + } else if model_type == "compound_heterozygous" { + 0.95 + } else { + 0.95 + } + + GeneticModel::{ + model_type, + penetrance, + phenocopy_rate: 0.01, + allele_frequency: 0.001, + } +} + +///| +pub fn bio_vfilter_filter( + variants : Array[Variant], + params : VariantFilteringParam, +) -> VariantFilterResult { let mut result = VariantFilterResult::new() - + let len = variants.length() let mut i = 0 while i < len { let variant = variants[i] let mut filter_reasons : Array[String] = Array::new() - + if variant.qual < params.min_qual { filter_reasons = push_string(filter_reasons, "QUAL below threshold") } - + if variant.filter != "." && variant.filter != "PASS" { filter_reasons = push_string(filter_reasons, "FILTER not PASS") } - + let dp = parse_info_int(variant.info, "DP") if dp < params.min_depth { filter_reasons = push_string(filter_reasons, "DP below threshold") } - + let af = parse_info_double(variant.info, "AF") if af > 0.0 && af < params.min_allele_freq { filter_reasons = push_string(filter_reasons, "AF below threshold") } - + let gq_pass = check_genotype_quality(variant.genotypes, params.min_gq) if !gq_pass { filter_reasons = push_string(filter_reasons, "GQ below threshold") } - + let missing_rate = calculate_missing_rate(variant.genotypes) if missing_rate > params.max_missing_rate { - filter_reasons = push_string(filter_reasons, "Missing rate above threshold") + filter_reasons = push_string( + filter_reasons, "Missing rate above threshold", + ) } - + if params.max_af_pop > 0.0 { let af_pop = parse_info_double(variant.info, "AF_POP") if af_pop > params.max_af_pop { - filter_reasons = push_string(filter_reasons, "Population AF above threshold") + filter_reasons = push_string( + filter_reasons, "Population AF above threshold", + ) } } - + if filter_reasons.length() == 0 { result = push_variant(result, variant) } else { @@ -124,20 +167,25 @@ pub fn bio_vfilter_filter(variants : Array[Variant], params : VariantFilteringPa let mut j = 0 while j < fr_len { let reason = filter_reasons[j] - let current = if result.filter_stats.contains(reason) { result.filter_stats.get(reason).unwrap() } else { 0 } + let current = if result.filter_stats.contains(reason) { + result.filter_stats.get(reason).unwrap() + } else { + 0 + } result.filter_stats.set(reason, current + 1) j = j + 1 } let reason_str = join_strings(filter_reasons, "; ") result = push_filtered_variant(result, (variant, reason_str)) } - + i = i + 1 } - + result } +///| fn push_string(arr : Array[String], s : String) -> Array[String] { let len = arr.length() let new_arr : Array[String] = Array::new() @@ -150,7 +198,11 @@ fn push_string(arr : Array[String], s : String) -> Array[String] { new_arr } -fn push_variant(result : VariantFilterResult, v : Variant) -> VariantFilterResult { +///| +fn push_variant( + result : VariantFilterResult, + v : Variant, +) -> VariantFilterResult { let len = result.passed_variants.length() let new_passed : Array[Variant] = Array::new() let mut i = 0 @@ -162,7 +214,11 @@ fn push_variant(result : VariantFilterResult, v : Variant) -> VariantFilterResul VariantFilterResult::{ ..result, passed_variants: new_passed } } -fn push_filtered_variant(result : VariantFilterResult, v : (Variant, String)) -> VariantFilterResult { +///| +fn push_filtered_variant( + result : VariantFilterResult, + v : (Variant, String), +) -> VariantFilterResult { let len = result.filtered_variants.length() let new_filtered : Array[(Variant, String)] = Array::new() let mut i = 0 @@ -174,6 +230,7 @@ fn push_filtered_variant(result : VariantFilterResult, v : (Variant, String)) -> VariantFilterResult::{ ..result, filtered_variants: new_filtered } } +///| fn join_strings(arr : Array[String], sep : String) -> String { let len = arr.length() if len == 0 { @@ -188,6 +245,7 @@ fn join_strings(arr : Array[String], sep : String) -> String { result } +///| fn parse_info_int(info : Map[String, String], key : String) -> Int { if info.contains(key) { parse_int(info.get(key).unwrap()) @@ -196,26 +254,35 @@ fn parse_info_int(info : Map[String, String], key : String) -> Int { } } +///| fn parse_info_double(info : Map[String, String], key : String) -> Double { if info.contains(key) { let parsed = parse_double(info.get(key).unwrap()) - if parsed.is_some() { parsed.unwrap() } else { 0.0 } + if parsed.is_some() { + parsed.unwrap() + } else { + 0.0 + } } else { 0.0 } } -fn check_genotype_quality(genotypes : Array[(String, String)], min_gq : Int) -> Bool { +///| +fn check_genotype_quality( + genotypes : Array[(String, String)], + min_gq : Int, +) -> Bool { let mut pass_count = 0 let mut total = 0 - + let len = genotypes.length() let mut i = 0 while i < len { let (sample, gt) = genotypes[i] if gt != "./." { total = total + 1 - + let parts = split_by_char(gt, 58) if parts.length() >= 3 { let gq = parse_int(parts[2]) @@ -228,16 +295,17 @@ fn check_genotype_quality(genotypes : Array[(String, String)], min_gq : Int) -> } i = i + 1 } - + total == 0 || pass_count == total } +///| fn calculate_missing_rate(genotypes : Array[(String, String)]) -> Double { let len = genotypes.length() if len == 0 { return 1.0 } - + let mut missing = 0 let mut i = 0 while i < len { @@ -247,39 +315,51 @@ fn calculate_missing_rate(genotypes : Array[(String, String)]) -> Double { } i = i + 1 } - + missing.to_double() / len.to_double() } -pub fn bio_vfilter_check_inheritance(variant : Variant, model : GeneticModel, - phenotypes : Map[String, Bool]) -> Bool { - if model.model_type == "autosomal_dominant" { - check_autosomal_dominant(variant, phenotypes) - } else if model.model_type == "autosomal_recessive" { - check_autosomal_recessive(variant, phenotypes) - } else if model.model_type == "x_linked_dominant" { - check_x_linked_dominant(variant, phenotypes) - } else if model.model_type == "x_linked_recessive" { - check_x_linked_recessive(variant, phenotypes) - } else if model.model_type == "compound_heterozygous" { - check_compound_heterozygous(variant, phenotypes) - } else { - true +///| +pub fn bio_vfilter_check_inheritance( + variant : Variant, + model : GeneticModel, + phenotypes : Map[String, Bool], +) -> Bool { + if model.model_type == "autosomal_dominant" { + check_autosomal_dominant(variant, phenotypes) + } else if model.model_type == "autosomal_recessive" { + check_autosomal_recessive(variant, phenotypes) + } else if model.model_type == "x_linked_dominant" { + check_x_linked_dominant(variant, phenotypes) + } else if model.model_type == "x_linked_recessive" { + check_x_linked_recessive(variant, phenotypes) + } else if model.model_type == "compound_heterozygous" { + check_compound_heterozygous(variant, phenotypes) + } else { + true } } -fn check_autosomal_dominant(variant : Variant, phenotypes : Map[String, Bool]) -> Bool { +///| +fn check_autosomal_dominant( + variant : Variant, + phenotypes : Map[String, Bool], +) -> Bool { let mut affected_carriers = 0 let mut unaffected_carriers = 0 let mut affected_non_carriers = 0 - + let len = variant.genotypes.length() let mut i = 0 while i < len { let (sample, gt) = variant.genotypes[i] - let is_affected = if phenotypes.contains(sample) { phenotypes.get(sample).unwrap() } else { false } + let is_affected = if phenotypes.contains(sample) { + phenotypes.get(sample).unwrap() + } else { + false + } let is_carrier = is_carrier_gt(gt) - + if is_affected && is_carrier { affected_carriers = affected_carriers + 1 } else if !is_affected && is_carrier { @@ -287,26 +367,34 @@ fn check_autosomal_dominant(variant : Variant, phenotypes : Map[String, Bool]) - } else if is_affected && !is_carrier { affected_non_carriers = affected_non_carriers + 1 } - + i = i + 1 } - + affected_non_carriers == 0 && affected_carriers >= 1 } -fn check_autosomal_recessive(variant : Variant, phenotypes : Map[String, Bool]) -> Bool { +///| +fn check_autosomal_recessive( + variant : Variant, + phenotypes : Map[String, Bool], +) -> Bool { let mut affected_homozygous = 0 let mut unaffected_homozygous = 0 let mut affected_heterozygous = 0 - + let len = variant.genotypes.length() let mut i = 0 while i < len { let (sample, gt) = variant.genotypes[i] - let is_affected = if phenotypes.contains(sample) { phenotypes.get(sample).unwrap() } else { false } + let is_affected = if phenotypes.contains(sample) { + phenotypes.get(sample).unwrap() + } else { + false + } let is_homozygous = is_homozygous_gt(gt) let is_heterozygous = is_heterozygous_gt(gt) - + if is_affected && is_homozygous { affected_homozygous = affected_homozygous + 1 } else if !is_affected && is_homozygous { @@ -314,140 +402,177 @@ fn check_autosomal_recessive(variant : Variant, phenotypes : Map[String, Bool]) } else if is_affected && is_heterozygous { affected_heterozygous = affected_heterozygous + 1 } - + i = i + 1 } - - affected_heterozygous == 0 && unaffected_homozygous == 0 && affected_homozygous >= 1 + + affected_heterozygous == 0 && + unaffected_homozygous == 0 && + affected_homozygous >= 1 } -fn check_x_linked_dominant(variant : Variant, phenotypes : Map[String, Bool]) -> Bool { +///| +fn check_x_linked_dominant( + variant : Variant, + phenotypes : Map[String, Bool], +) -> Bool { if !is_x_chromosome(variant.chr) { return false } - + let mut affected_males_with_mut = 0 let mut unaffected_males_with_mut = 0 let mut affected_females_with_mut = 0 let mut unaffected_females_with_mut = 0 - + let len = variant.genotypes.length() let mut i = 0 while i < len { let (sample, gt) = variant.genotypes[i] - let is_affected = if phenotypes.contains(sample) { phenotypes.get(sample).unwrap() } else { false } + let is_affected = if phenotypes.contains(sample) { + phenotypes.get(sample).unwrap() + } else { + false + } let is_carrier = is_carrier_gt(gt) - + if is_male(sample) { if is_affected && is_carrier { affected_males_with_mut = affected_males_with_mut + 1 } else if !is_affected && is_carrier { unaffected_males_with_mut = unaffected_males_with_mut + 1 } - } else { - if is_affected && is_carrier { - affected_females_with_mut = affected_females_with_mut + 1 - } else if !is_affected && is_carrier { - unaffected_females_with_mut = unaffected_females_with_mut + 1 - } + } else if is_affected && is_carrier { + affected_females_with_mut = affected_females_with_mut + 1 + } else if !is_affected && is_carrier { + unaffected_females_with_mut = unaffected_females_with_mut + 1 } - + i = i + 1 } - + unaffected_males_with_mut == 0 && affected_males_with_mut >= 1 } -fn check_x_linked_recessive(variant : Variant, phenotypes : Map[String, Bool]) -> Bool { +///| +fn check_x_linked_recessive( + variant : Variant, + phenotypes : Map[String, Bool], +) -> Bool { if !is_x_chromosome(variant.chr) { return false } - + let mut affected_males_with_mut = 0 let mut unaffected_males_with_mut = 0 let mut affected_females_homozygous = 0 let mut unaffected_females_homozygous = 0 - + let len = variant.genotypes.length() let mut i = 0 while i < len { let (sample, gt) = variant.genotypes[i] - let is_affected = if phenotypes.contains(sample) { phenotypes.get(sample).unwrap() } else { false } + let is_affected = if phenotypes.contains(sample) { + phenotypes.get(sample).unwrap() + } else { + false + } let is_carrier = is_carrier_gt(gt) let is_homozygous = is_homozygous_gt(gt) - + if is_male(sample) { if is_affected && is_carrier { affected_males_with_mut = affected_males_with_mut + 1 } else if !is_affected && is_carrier { unaffected_males_with_mut = unaffected_males_with_mut + 1 } - } else { - if is_affected && is_homozygous { - affected_females_homozygous = affected_females_homozygous + 1 - } else if !is_affected && is_homozygous { - unaffected_females_homozygous = unaffected_females_homozygous + 1 - } + } else if is_affected && is_homozygous { + affected_females_homozygous = affected_females_homozygous + 1 + } else if !is_affected && is_homozygous { + unaffected_females_homozygous = unaffected_females_homozygous + 1 } - + i = i + 1 } - - unaffected_males_with_mut == 0 && unaffected_females_homozygous == 0 && (affected_males_with_mut >= 1 || affected_females_homozygous >= 1) + + unaffected_males_with_mut == 0 && + unaffected_females_homozygous == 0 && + (affected_males_with_mut >= 1 || affected_females_homozygous >= 1) } -fn check_compound_heterozygous(variant : Variant, phenotypes : Map[String, Bool]) -> Bool { +///| +fn check_compound_heterozygous( + variant : Variant, + phenotypes : Map[String, Bool], +) -> Bool { let mut affected_heterozygous = 0 let mut unaffected_heterozygous = 0 - + let len = variant.genotypes.length() let mut i = 0 while i < len { let (sample, gt) = variant.genotypes[i] - let is_affected = if phenotypes.contains(sample) { phenotypes.get(sample).unwrap() } else { false } + let is_affected = if phenotypes.contains(sample) { + phenotypes.get(sample).unwrap() + } else { + false + } let is_heterozygous = is_heterozygous_gt(gt) - + if is_affected && is_heterozygous { affected_heterozygous = affected_heterozygous + 1 } else if !is_affected && is_heterozygous { unaffected_heterozygous = unaffected_heterozygous + 1 } - + i = i + 1 } - + affected_heterozygous >= 2 && unaffected_heterozygous > 0 } +///| fn is_carrier_gt(gt : String) -> Bool { - gt == "0/1" || gt == "1/0" || gt == "1/1" || gt == "0|1" || gt == "1|0" || gt == "1|1" + gt == "0/1" || + gt == "1/0" || + gt == "1/1" || + gt == "0|1" || + gt == "1|0" || + gt == "1|1" } +///| fn is_homozygous_gt(gt : String) -> Bool { gt == "1/1" || gt == "1|1" } +///| fn is_heterozygous_gt(gt : String) -> Bool { gt == "0/1" || gt == "1/0" || gt == "0|1" || gt == "1|0" } +///| fn is_x_chromosome(chr : String) -> Bool { chr == "X" || chr == "x" || chr == "chrX" || chr == "chrX" || chr == "23" } +///| fn is_male(sample : String) -> Bool { let lower_sample = to_lowercase(sample) - lower_sample.ends_with("_male") || contains_substring(lower_sample, "father") || contains_substring(lower_sample, "son") + lower_sample.ends_with("_male") || + contains_substring(lower_sample, "father") || + contains_substring(lower_sample, "son") } +///| fn contains_substring(s : String, substr : String) -> Bool { let s_len = s.length() let sub_len = substr.length() - + if sub_len == 0 || s_len < sub_len { return false } - + let mut i = 0 while i <= s_len - sub_len { let current = substring(s, i, sub_len) @@ -456,12 +581,16 @@ fn contains_substring(s : String, substr : String) -> Bool { } i = i + 1 } - + false } -pub fn bio_vfilter_filter_by_inheritance(variants : Array[Variant], model : GeneticModel, - phenotypes : Map[String, Bool]) -> Array[Variant] { +///| +pub fn bio_vfilter_filter_by_inheritance( + variants : Array[Variant], + model : GeneticModel, + phenotypes : Map[String, Bool], +) -> Array[Variant] { let len = variants.length() let mut result : Array[Variant] = Array::new() let mut i = 0 @@ -475,6 +604,7 @@ pub fn bio_vfilter_filter_by_inheritance(variants : Array[Variant], model : Gene result } +///| fn push_variant_array(arr : Array[Variant], v : Variant) -> Array[Variant] { let len = arr.length() let new_arr : Array[Variant] = Array::new() @@ -487,29 +617,37 @@ fn push_variant_array(arr : Array[Variant], v : Variant) -> Array[Variant] { new_arr } +///| pub fn bio_vfilter_summary(result : VariantFilterResult) -> String { let mut summary = "\nVariant Filtering Summary\n" summary = summary + "=".repeat(60) + "\n" - - let total = result.passed_variants.length() + result.filtered_variants.length() - + + let total = result.passed_variants.length() + + result.filtered_variants.length() + summary = summary + "Total variants: " + total.to_string() + "\n" - summary = summary + "Passed: " + result.passed_variants.length().to_string() + "\n" - summary = summary + "Filtered: " + result.filtered_variants.length().to_string() + "\n" - + summary = summary + + "Passed: " + + result.passed_variants.length().to_string() + + "\n" + summary = summary + + "Filtered: " + + result.filtered_variants.length().to_string() + + "\n" + summary = summary + "\nFilter statistics:\n" summary = summary + "-".repeat(60) + "\n" - + let entries = result.filter_stats.iter().collect() let entries_len = entries.length() - + let mut sorted : Array[(String, Int)] = Array::new() let mut i = 0 while i < entries_len { sorted.push(entries[i]) i = i + 1 } - + let mut j = 0 while j < entries_len { let mut k = j + 1 @@ -534,20 +672,21 @@ pub fn bio_vfilter_summary(result : VariantFilterResult) -> String { } j = j + 1 } - + let mut l = 0 while l < sorted.length() { let (reason, count) = sorted[l] summary = summary + reason + ": " + count.to_string() + "\n" l = l + 1 } - + summary } +///| pub fn bio_vfilter_predict_consequence(variant : Variant) -> String { let len_diff = variant.alt_allele.length() - variant.ref_allele.length() - + if len_diff == 0 { "missense_variant" } else if len_diff > 0 { @@ -555,4 +694,4 @@ pub fn bio_vfilter_predict_consequence(variant : Variant) -> String { } else { "deletion" } -} \ No newline at end of file +} diff --git a/src/variation.mbt b/src/variation.mbt index e8607f0d..74d3367f 100644 --- a/src/variation.mbt +++ b/src/variation.mbt @@ -43,7 +43,15 @@ pub fn Mutation::new( mutation_type : String, impact : String, ) -> Mutation { - Mutation::{ gene, protein, position, original_aa, mutated_aa, mutation_type, impact } + Mutation::{ + gene, + protein, + position, + original_aa, + mutated_aa, + mutation_type, + impact, + } } ///| @@ -81,21 +89,31 @@ pub fn AminoAcidSubstitution::new( blosum62_score : Int, grantham_distance : Double, ) -> AminoAcidSubstitution { - AminoAcidSubstitution::{ original, mutated, blosum62_score, grantham_distance } + AminoAcidSubstitution::{ + original, + mutated, + blosum62_score, + grantham_distance, + } } ///| fn blosum62_matrix() -> Map[String, Map[String, Int]] { let matrix : Map[String, Map[String, Int]] = Map([], capacity=20) - - let amino_acids = ["A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F", "P", "S", "T", "W", "Y", "V"] - + + let amino_acids = [ + "A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F", "P", "S", + "T", "W", "Y", "V", + ] + let scores = [ [4, -1, -2, -2, 0, -1, -1, 0, -2, -1, -1, -1, -1, -2, -1, 1, 0, -3, -2, 0], [-1, 5, 0, -2, -3, 1, 0, -2, 0, -3, -2, 2, -1, -3, -2, -1, -1, -3, -2, -3], [-2, 0, 6, 1, -3, 0, 0, 0, 1, -3, -3, 0, -2, -3, -2, 1, 0, -4, -2, -3], [-2, -2, 1, 6, -3, 0, 2, -1, -1, -3, -4, -1, -3, -3, -1, 0, -1, -4, -3, -3], - [0, -3, -3, -3, 9, -3, -4, -3, -3, -1, -1, -3, -1, -2, -3, -1, -1, -2, -2, -1], + [ + 0, -3, -3, -3, 9, -3, -4, -3, -3, -1, -1, -3, -1, -2, -3, -1, -1, -2, -2, -1, + ], [-1, 1, 0, 0, -3, 5, 2, -2, 0, -3, -2, 1, 0, -3, -1, 0, -1, -2, -1, -2], [-1, 0, 0, 2, -4, 2, 5, -2, 0, -3, -3, 1, -2, -3, -1, 0, -1, -3, -2, -2], [0, -2, 0, -1, -3, -2, -2, 6, -2, -4, -4, -2, -3, -3, -2, 0, -2, -2, -3, -3], @@ -105,14 +123,19 @@ fn blosum62_matrix() -> Map[String, Map[String, Int]] { [-1, 2, 0, -1, -3, 1, 1, -2, -1, -3, -2, 5, -1, -3, -1, 0, -1, -3, -2, -2], [-1, -1, -2, -3, -1, 0, -2, -3, -2, 1, 2, -1, 5, 0, -2, -1, -1, -1, -1, 1], [-2, -3, -3, -3, -2, -3, -3, -3, -1, 0, 0, -3, 0, 6, -4, -2, -2, 1, 3, -1], - [-1, -2, -2, -1, -3, -1, -1, -2, -2, -3, -3, -1, -2, -4, 7, -1, -1, -4, -3, -2], + [ + -1, -2, -2, -1, -3, -1, -1, -2, -2, -3, -3, -1, -2, -4, 7, -1, -1, -4, -3, + -2, + ], [1, -1, 1, 0, -1, 0, 0, 0, -1, -2, -2, 0, -1, -2, -1, 4, 1, -3, -2, -2], [0, -1, 0, -1, -1, -1, -1, -2, -2, -1, -1, -1, -1, -2, -1, 1, 5, -2, -2, 0], - [-3, -3, -4, -4, -2, -2, -3, -2, -2, -3, -2, -3, -1, 1, -4, -3, -2, 11, 2, -3], + [ + -3, -3, -4, -4, -2, -2, -3, -2, -2, -3, -2, -3, -1, 1, -4, -3, -2, 11, 2, -3, + ], [-2, -2, -2, -3, -2, -1, -2, -3, 2, -1, -1, -2, -1, 3, -3, -2, -2, 2, 7, -1], [0, -3, -3, -3, -1, -2, -2, -3, -3, 3, 1, -2, 1, -1, -2, -2, 0, -3, -1, 4], ] - + let mut i = 0 while i < amino_acids.length() { let row_map : Map[String, Int] = Map([], capacity=20) @@ -124,39 +147,102 @@ fn blosum62_matrix() -> Map[String, Map[String, Int]] { matrix.set(amino_acids[i], row_map) i = i + 1 } - + matrix } ///| fn grantham_matrix() -> Map[String, Map[String, Double]] { let matrix : Map[String, Map[String, Double]] = Map([], capacity=20) - - let amino_acids = ["A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F", "P", "S", "T", "W", "Y", "V"] - + + let amino_acids = [ + "A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F", "P", "S", + "T", "W", "Y", "V", + ] + let distances = [ - [0.0, 112.0, 145.0, 145.0, 130.0, 119.0, 118.0, 75.0, 127.0, 96.0, 96.0, 125.0, 107.0, 130.0, 97.0, 56.0, 60.0, 157.0, 147.0, 90.0], - [112.0, 0.0, 85.0, 85.0, 145.0, 60.0, 64.0, 125.0, 48.0, 142.0, 142.0, 26.0, 130.0, 165.0, 143.0, 97.0, 101.0, 153.0, 152.0, 136.0], - [145.0, 85.0, 0.0, 20.0, 157.0, 38.0, 55.0, 110.0, 66.0, 171.0, 171.0, 70.0, 159.0, 189.0, 157.0, 82.0, 86.0, 180.0, 168.0, 165.0], - [145.0, 85.0, 20.0, 0.0, 157.0, 58.0, 35.0, 110.0, 86.0, 171.0, 171.0, 70.0, 159.0, 189.0, 157.0, 82.0, 86.0, 180.0, 168.0, 165.0], - [130.0, 145.0, 157.0, 157.0, 0.0, 148.0, 147.0, 95.0, 145.0, 108.0, 108.0, 153.0, 119.0, 126.0, 127.0, 78.0, 82.0, 144.0, 134.0, 102.0], - [119.0, 60.0, 38.0, 58.0, 148.0, 0.0, 25.0, 104.0, 46.0, 151.0, 151.0, 45.0, 139.0, 178.0, 146.0, 73.0, 77.0, 169.0, 157.0, 145.0], - [118.0, 64.0, 55.0, 35.0, 147.0, 25.0, 0.0, 103.0, 66.0, 150.0, 150.0, 49.0, 138.0, 177.0, 145.0, 72.0, 76.0, 168.0, 156.0, 144.0], - [75.0, 125.0, 110.0, 110.0, 95.0, 104.0, 103.0, 0.0, 112.0, 91.0, 91.0, 130.0, 102.0, 125.0, 87.0, 60.0, 64.0, 152.0, 142.0, 85.0], - [127.0, 48.0, 66.0, 86.0, 145.0, 46.0, 66.0, 112.0, 0.0, 149.0, 149.0, 58.0, 137.0, 175.0, 154.0, 89.0, 93.0, 166.0, 148.0, 143.0], - [96.0, 142.0, 171.0, 171.0, 108.0, 151.0, 150.0, 91.0, 149.0, 0.0, 9.0, 159.0, 21.0, 41.0, 112.0, 100.0, 66.0, 84.0, 66.0, 28.0], - [96.0, 142.0, 171.0, 171.0, 108.0, 151.0, 150.0, 91.0, 149.0, 9.0, 0.0, 159.0, 12.0, 32.0, 112.0, 100.0, 66.0, 75.0, 57.0, 19.0], - [125.0, 26.0, 70.0, 70.0, 153.0, 45.0, 49.0, 130.0, 58.0, 159.0, 159.0, 0.0, 147.0, 182.0, 160.0, 104.0, 108.0, 167.0, 166.0, 153.0], - [107.0, 130.0, 159.0, 159.0, 119.0, 139.0, 138.0, 102.0, 137.0, 21.0, 12.0, 147.0, 0.0, 53.0, 123.0, 112.0, 78.0, 96.0, 78.0, 40.0], - [130.0, 165.0, 189.0, 189.0, 126.0, 178.0, 177.0, 125.0, 175.0, 41.0, 32.0, 182.0, 53.0, 0.0, 143.0, 133.0, 99.0, 67.0, 17.0, 63.0], - [97.0, 143.0, 157.0, 157.0, 127.0, 146.0, 145.0, 87.0, 154.0, 112.0, 112.0, 160.0, 123.0, 143.0, 0.0, 63.0, 67.0, 174.0, 164.0, 106.0], - [56.0, 97.0, 82.0, 82.0, 78.0, 73.0, 72.0, 60.0, 89.0, 100.0, 100.0, 104.0, 112.0, 133.0, 63.0, 0.0, 19.0, 145.0, 135.0, 94.0], - [60.0, 101.0, 86.0, 86.0, 82.0, 77.0, 76.0, 64.0, 93.0, 66.0, 66.0, 108.0, 78.0, 99.0, 67.0, 19.0, 0.0, 149.0, 139.0, 60.0], - [157.0, 153.0, 180.0, 180.0, 144.0, 169.0, 168.0, 152.0, 166.0, 84.0, 75.0, 167.0, 96.0, 67.0, 174.0, 145.0, 149.0, 0.0, 80.0, 106.0], - [147.0, 152.0, 168.0, 168.0, 134.0, 157.0, 156.0, 142.0, 148.0, 66.0, 57.0, 166.0, 78.0, 17.0, 164.0, 135.0, 139.0, 80.0, 0.0, 88.0], - [90.0, 136.0, 165.0, 165.0, 102.0, 145.0, 144.0, 85.0, 143.0, 28.0, 19.0, 153.0, 40.0, 63.0, 106.0, 94.0, 60.0, 106.0, 88.0, 0.0], + [ + 0.0, 112.0, 145.0, 145.0, 130.0, 119.0, 118.0, 75.0, 127.0, 96.0, 96.0, 125.0, + 107.0, 130.0, 97.0, 56.0, 60.0, 157.0, 147.0, 90.0, + ], + [ + 112.0, 0.0, 85.0, 85.0, 145.0, 60.0, 64.0, 125.0, 48.0, 142.0, 142.0, 26.0, + 130.0, 165.0, 143.0, 97.0, 101.0, 153.0, 152.0, 136.0, + ], + [ + 145.0, 85.0, 0.0, 20.0, 157.0, 38.0, 55.0, 110.0, 66.0, 171.0, 171.0, 70.0, + 159.0, 189.0, 157.0, 82.0, 86.0, 180.0, 168.0, 165.0, + ], + [ + 145.0, 85.0, 20.0, 0.0, 157.0, 58.0, 35.0, 110.0, 86.0, 171.0, 171.0, 70.0, + 159.0, 189.0, 157.0, 82.0, 86.0, 180.0, 168.0, 165.0, + ], + [ + 130.0, 145.0, 157.0, 157.0, 0.0, 148.0, 147.0, 95.0, 145.0, 108.0, 108.0, 153.0, + 119.0, 126.0, 127.0, 78.0, 82.0, 144.0, 134.0, 102.0, + ], + [ + 119.0, 60.0, 38.0, 58.0, 148.0, 0.0, 25.0, 104.0, 46.0, 151.0, 151.0, 45.0, + 139.0, 178.0, 146.0, 73.0, 77.0, 169.0, 157.0, 145.0, + ], + [ + 118.0, 64.0, 55.0, 35.0, 147.0, 25.0, 0.0, 103.0, 66.0, 150.0, 150.0, 49.0, + 138.0, 177.0, 145.0, 72.0, 76.0, 168.0, 156.0, 144.0, + ], + [ + 75.0, 125.0, 110.0, 110.0, 95.0, 104.0, 103.0, 0.0, 112.0, 91.0, 91.0, 130.0, + 102.0, 125.0, 87.0, 60.0, 64.0, 152.0, 142.0, 85.0, + ], + [ + 127.0, 48.0, 66.0, 86.0, 145.0, 46.0, 66.0, 112.0, 0.0, 149.0, 149.0, 58.0, + 137.0, 175.0, 154.0, 89.0, 93.0, 166.0, 148.0, 143.0, + ], + [ + 96.0, 142.0, 171.0, 171.0, 108.0, 151.0, 150.0, 91.0, 149.0, 0.0, 9.0, 159.0, + 21.0, 41.0, 112.0, 100.0, 66.0, 84.0, 66.0, 28.0, + ], + [ + 96.0, 142.0, 171.0, 171.0, 108.0, 151.0, 150.0, 91.0, 149.0, 9.0, 0.0, 159.0, + 12.0, 32.0, 112.0, 100.0, 66.0, 75.0, 57.0, 19.0, + ], + [ + 125.0, 26.0, 70.0, 70.0, 153.0, 45.0, 49.0, 130.0, 58.0, 159.0, 159.0, 0.0, + 147.0, 182.0, 160.0, 104.0, 108.0, 167.0, 166.0, 153.0, + ], + [ + 107.0, 130.0, 159.0, 159.0, 119.0, 139.0, 138.0, 102.0, 137.0, 21.0, 12.0, + 147.0, 0.0, 53.0, 123.0, 112.0, 78.0, 96.0, 78.0, 40.0, + ], + [ + 130.0, 165.0, 189.0, 189.0, 126.0, 178.0, 177.0, 125.0, 175.0, 41.0, 32.0, + 182.0, 53.0, 0.0, 143.0, 133.0, 99.0, 67.0, 17.0, 63.0, + ], + [ + 97.0, 143.0, 157.0, 157.0, 127.0, 146.0, 145.0, 87.0, 154.0, 112.0, 112.0, + 160.0, 123.0, 143.0, 0.0, 63.0, 67.0, 174.0, 164.0, 106.0, + ], + [ + 56.0, 97.0, 82.0, 82.0, 78.0, 73.0, 72.0, 60.0, 89.0, 100.0, 100.0, 104.0, + 112.0, 133.0, 63.0, 0.0, 19.0, 145.0, 135.0, 94.0, + ], + [ + 60.0, 101.0, 86.0, 86.0, 82.0, 77.0, 76.0, 64.0, 93.0, 66.0, 66.0, 108.0, 78.0, + 99.0, 67.0, 19.0, 0.0, 149.0, 139.0, 60.0, + ], + [ + 157.0, 153.0, 180.0, 180.0, 144.0, 169.0, 168.0, 152.0, 166.0, 84.0, 75.0, + 167.0, 96.0, 67.0, 174.0, 145.0, 149.0, 0.0, 80.0, 106.0, + ], + [ + 147.0, 152.0, 168.0, 168.0, 134.0, 157.0, 156.0, 142.0, 148.0, 66.0, 57.0, + 166.0, 78.0, 17.0, 164.0, 135.0, 139.0, 80.0, 0.0, 88.0, + ], + [ + 90.0, 136.0, 165.0, 165.0, 102.0, 145.0, 144.0, 85.0, 143.0, 28.0, 19.0, 153.0, + 40.0, 63.0, 106.0, 94.0, 60.0, 106.0, 88.0, 0.0, + ], ] - + let mut i = 0 while i < amino_acids.length() { let row_map : Map[String, Double] = Map([], capacity=20) @@ -168,7 +254,7 @@ fn grantham_matrix() -> Map[String, Map[String, Double]] { matrix.set(amino_acids[i], row_map) i = i + 1 } - + matrix } @@ -192,29 +278,38 @@ pub fn detect_mutations( alt_allele : String, ) -> Array[Mutation] { let mutations : Array[Mutation] = Array::new() - + let codon_start = (variant_position - 1) / 3 * 3 let codon_end = codon_start + 3 - + if codon_end <= dna_sequence.length() { let original_codon = substring(dna_sequence, codon_start, 3) - let new_sequence = replace_char_at(dna_sequence, variant_position - 1, alt_allele) + let new_sequence = replace_char_at( + dna_sequence, + variant_position - 1, + alt_allele, + ) let mutated_codon = substring(new_sequence, codon_start, 3) - + let original_aa = variation_translate_codon(original_codon) let mutated_aa = variation_translate_codon(mutated_codon) - + let mutation_type = classify_mutation(original_aa, mutated_aa) let impact = predict_impact(original_aa, mutated_aa, mutation_type) - - mutations.push(Mutation::new( - gene, protein, - codon_start / 3 + 1, - original_aa, mutated_aa, - mutation_type, impact, - )) + + mutations.push( + Mutation::new( + gene, + protein, + codon_start / 3 + 1, + original_aa, + mutated_aa, + mutation_type, + impact, + ), + ) } - + mutations } @@ -223,36 +318,87 @@ fn replace_char_at(s : String, idx : Int, replacement : String) -> String { if idx < 0 || idx >= s.length() || replacement.length() == 0 { return s } - + let prefix = substring(s, 0, idx) let suffix = substring(s, idx + 1, s.length() - idx - 1) - + prefix + substring(replacement, 0, 1) + suffix } ///| fn variation_translate_codon(codon : String) -> String { let codon_upper = variation_to_uppercase(codon) - - let codon_table = Map([ - ("TTT", "F"), ("TTC", "F"), ("TTA", "L"), ("TTG", "L"), - ("CTT", "L"), ("CTC", "L"), ("CTA", "L"), ("CTG", "L"), - ("ATT", "I"), ("ATC", "I"), ("ATA", "I"), ("ATG", "M"), - ("GTT", "V"), ("GTC", "V"), ("GTA", "V"), ("GTG", "V"), - ("TCT", "S"), ("TCC", "S"), ("TCA", "S"), ("TCG", "S"), - ("CCT", "P"), ("CCC", "P"), ("CCA", "P"), ("CCG", "P"), - ("ACT", "T"), ("ACC", "T"), ("ACA", "T"), ("ACG", "T"), - ("GCT", "A"), ("GCC", "A"), ("GCA", "A"), ("GCG", "A"), - ("TAT", "Y"), ("TAC", "Y"), ("TAA", "*"), ("TAG", "*"), - ("CAT", "H"), ("CAC", "H"), ("CAA", "Q"), ("CAG", "Q"), - ("AAT", "N"), ("AAC", "N"), ("AAA", "K"), ("AAG", "K"), - ("GAT", "D"), ("GAC", "D"), ("GAA", "E"), ("GAG", "E"), - ("TGT", "C"), ("TGC", "C"), ("TGA", "*"), ("TGG", "W"), - ("CGT", "R"), ("CGC", "R"), ("CGA", "R"), ("CGG", "R"), - ("AGT", "S"), ("AGC", "S"), ("AGA", "R"), ("AGG", "R"), - ("GGT", "G"), ("GGC", "G"), ("GGA", "G"), ("GGG", "G"), - ], capacity=64) - + + let codon_table = Map( + [ + ("TTT", "F"), + ("TTC", "F"), + ("TTA", "L"), + ("TTG", "L"), + ("CTT", "L"), + ("CTC", "L"), + ("CTA", "L"), + ("CTG", "L"), + ("ATT", "I"), + ("ATC", "I"), + ("ATA", "I"), + ("ATG", "M"), + ("GTT", "V"), + ("GTC", "V"), + ("GTA", "V"), + ("GTG", "V"), + ("TCT", "S"), + ("TCC", "S"), + ("TCA", "S"), + ("TCG", "S"), + ("CCT", "P"), + ("CCC", "P"), + ("CCA", "P"), + ("CCG", "P"), + ("ACT", "T"), + ("ACC", "T"), + ("ACA", "T"), + ("ACG", "T"), + ("GCT", "A"), + ("GCC", "A"), + ("GCA", "A"), + ("GCG", "A"), + ("TAT", "Y"), + ("TAC", "Y"), + ("TAA", "*"), + ("TAG", "*"), + ("CAT", "H"), + ("CAC", "H"), + ("CAA", "Q"), + ("CAG", "Q"), + ("AAT", "N"), + ("AAC", "N"), + ("AAA", "K"), + ("AAG", "K"), + ("GAT", "D"), + ("GAC", "D"), + ("GAA", "E"), + ("GAG", "E"), + ("TGT", "C"), + ("TGC", "C"), + ("TGA", "*"), + ("TGG", "W"), + ("CGT", "R"), + ("CGC", "R"), + ("CGA", "R"), + ("CGG", "R"), + ("AGT", "S"), + ("AGC", "S"), + ("AGA", "R"), + ("AGG", "R"), + ("GGT", "G"), + ("GGC", "G"), + ("GGA", "G"), + ("GGG", "G"), + ], + capacity=64, + ) + codon_table.get(codon_upper).unwrap_or("?") } @@ -264,7 +410,8 @@ fn variation_to_uppercase(s : String) -> String { let c = s.unsafe_get(i) let c_int = c.to_int() if c_int >= 'a'.to_int() && c_int <= 'z'.to_int() { - result = result + (c_int - 'a'.to_int() + 'A'.to_int()).to_char().to_string() + result = result + + (c_int - 'a'.to_int() + 'A'.to_int()).to_char().to_string() } else { result = result + c.to_string() } @@ -284,7 +431,7 @@ fn classify_mutation(original : String, mutated : String) -> String { if original == "*" { return "Frameshift" } - + let aa_groups = [ ["G", "A", "V", "L", "I", "M"], ["F", "Y", "W"], @@ -293,10 +440,10 @@ fn classify_mutation(original : String, mutated : String) -> String { ["R", "K", "H"], ["C", "P"], ] - + let mut original_group = -1 let mut mutated_group = -1 - + let mut i = 0 while i < aa_groups.length() { let mut j = 0 @@ -311,7 +458,7 @@ fn classify_mutation(original : String, mutated : String) -> String { } i = i + 1 } - + if original_group == mutated_group { "Conservative" } else { @@ -320,7 +467,11 @@ fn classify_mutation(original : String, mutated : String) -> String { } ///| -fn predict_impact(original : String, mutated : String, mutation_type : String) -> String { +fn predict_impact( + original : String, + mutated : String, + mutation_type : String, +) -> String { if mutation_type == "Nonsense" { return "High" } @@ -337,24 +488,27 @@ fn predict_impact(original : String, mutated : String, mutation_type : String) - } ///| -pub fn analyze_amino_acid_substitution(original : String, mutated : String) -> AminoAcidSubstitution { +pub fn analyze_amino_acid_substitution( + original : String, + mutated : String, +) -> AminoAcidSubstitution { let blosum62 = blosum62_matrix() let grantham = grantham_matrix() - + let blosum_val = blosum62.get(original) let blosum_score = if blosum_val.is_some() { blosum_val.unwrap().get(mutated).unwrap_or(0) } else { 0 } - + let grantham_val = grantham.get(original) let grantham_dist = if grantham_val.is_some() { grantham_val.unwrap().get(mutated).unwrap_or(0.0) } else { 0.0 } - + AminoAcidSubstitution::new(original, mutated, blosum_score, grantham_dist) } @@ -369,31 +523,41 @@ pub fn parse_vcf_line(line : String) -> VariationRecord? { if parts.length() < 5 { return None } - + let chromosome = parts[0] let position_str = parts[1] let ref_allele = parts[3] let alt_allele = parts[4] - + let position = parse_int(position_str) - - Some(VariationRecord::new(chromosome, position, ref_allele, alt_allele, Array::new())) + + Some( + VariationRecord::new( + chromosome, + position, + ref_allele, + alt_allele, + Array::new(), + ), + ) } ///| pub fn create_example_variation_data() -> Array[VariationRecord] { let records : Array[VariationRecord] = Array::new() - + let mutations1 = [ - Mutation::new("BRCA1", "BRCA1_HUMAN", 178, "G", "A", "Non-conservative", "Medium"), + Mutation::new( + "BRCA1", "BRCA1_HUMAN", 178, "G", "A", "Non-conservative", "Medium", + ), Mutation::new("BRCA1", "BRCA1_HUMAN", 356, "R", "*", "Nonsense", "High"), ] records.push(VariationRecord::new("17", 43044295, "C", "T", mutations1)) - + let mutations2 = [ Mutation::new("TP53", "P53_HUMAN", 273, "R", "H", "Conservative", "Low"), ] records.push(VariationRecord::new("17", 7577538, "G", "A", mutations2)) - + records -} \ No newline at end of file +} diff --git a/src/vcf.mbt b/src/vcf.mbt index 9557c302..92f8d54a 100644 --- a/src/vcf.mbt +++ b/src/vcf.mbt @@ -299,7 +299,9 @@ pub fn VcfFile::get_version(self : VcfFile) -> String? { ///| /// Check if variant is a SNP (single nucleotide polymorphism). pub fn VcfRecord::is_snp(self : VcfRecord) -> Bool { - self.ref_seq.length() == 1 && self.alt.length() == 1 && self.alt[0].length() == 1 + self.ref_seq.length() == 1 && + self.alt.length() == 1 && + self.alt[0].length() == 1 } ///| diff --git a/src/velociraptor.mbt b/src/velociraptor.mbt index 6dd489de..8111a394 100644 --- a/src/velociraptor.mbt +++ b/src/velociraptor.mbt @@ -29,7 +29,7 @@ pub struct VelocityGeneData { pub fn VelocityGeneData::new( gene_name : String, spliced : Array[Double], - unspliced : Array[Double] + unspliced : Array[Double], ) -> VelocityGeneData { VelocityGeneData::{ gene_name, spliced, unspliced } } @@ -136,9 +136,9 @@ pub fn EmbeddingVelocity::embedding(self : EmbeddingVelocity) -> Array[Double] { ///| /// Accessor for velocity embedding. -pub fn EmbeddingVelocity::velocity_embedding(self : EmbeddingVelocity) -> Array[ - Double -] { +pub fn EmbeddingVelocity::velocity_embedding( + self : EmbeddingVelocity, +) -> Array[Double] { self.velocity_embedding } @@ -146,6 +146,7 @@ pub fn EmbeddingVelocity::velocity_embedding(self : EmbeddingVelocity) -> Array[ // Internal helpers // =========================================================================== +///| fn vr_abs(x : Double) -> Double { if x < 0.0 { -x @@ -154,6 +155,7 @@ fn vr_abs(x : Double) -> Double { } } +///| fn vr_sqrt(x : Double) -> Double { if x <= 0.0 { return 0.0 @@ -173,6 +175,7 @@ fn vr_sqrt(x : Double) -> Double { guess } +///| fn vr_log(x : Double) -> Double { if x <= 0.0 { return -700.0 @@ -180,6 +183,7 @@ fn vr_log(x : Double) -> Double { @math.ln(x) } +///| fn vr_exp(x : Double) -> Double { if x > 700.0 { return 1.7976931348623157e308 @@ -190,6 +194,7 @@ fn vr_exp(x : Double) -> Double { @math.exp(x) } +///| fn vr_mean(arr : Array[Double]) -> Double { let n = arr.length() if n == 0 { @@ -202,6 +207,7 @@ fn vr_mean(arr : Array[Double]) -> Double { s / n.to_double() } +///| fn vr_variance(arr : Array[Double]) -> Double { let n = arr.length() if n < 2 { @@ -216,6 +222,7 @@ fn vr_variance(arr : Array[Double]) -> Double { s / (n - 1).to_double() } +///| fn vr_lcg_rand(state : Int) -> (Int, Double) { let s = (state * 1103515245 + 12345) & 0x7FFFFFFF (s, (s % 1000000).to_double() / 1000000.0) @@ -233,7 +240,7 @@ fn vr_lcg_rand(state : Int) -> (Int, Double) { /// Returns (gamma_beta_ratio, steady_state_s, steady_state_u). pub fn velocity_steady_state( spliced : Array[Double], - unspliced : Array[Double] + unspliced : Array[Double], ) -> (Double, Double, Double) { let n = spliced.length() if n < 3 { @@ -306,7 +313,7 @@ pub fn velocity_kinetic_model( gene_name : String, spliced : Array[Double], unspliced : Array[Double], - n_iterations : Int + n_iterations : Int, ) -> GeneKinetics { let n = spliced.length() if n < 3 { @@ -434,6 +441,7 @@ pub fn velocity_kinetic_model( } } +///| fn vr_max_array(arr : Array[Double]) -> Double { let n = arr.length() if n == 0 { @@ -461,7 +469,7 @@ fn vr_max_array(arr : Array[Double]) -> Double { /// Returns per-cell velocity vectors. pub fn velocity_compute( gene_data : Array[VelocityGeneData], - kinetics : Array[GeneKinetics] + kinetics : Array[GeneKinetics], ) -> Array[CellVelocity] { let n_genes = gene_data.length() if n_genes == 0 { @@ -504,7 +512,7 @@ pub fn velocity_gene( spliced : Array[Double], unspliced : Array[Double], beta : Double, - gamma : Double + gamma : Double, ) -> Array[Double] { let n = spliced.length() let vel = Array::make(n, 0.0) @@ -529,7 +537,7 @@ pub fn velocity_gene( pub fn velocity_embedding( velocities : Array[CellVelocity], embeddings : Array[Array[Double]], - k : Int + k : Int, ) -> Array[EmbeddingVelocity] { let n_cells = velocities.length() if n_cells == 0 || n_cells != embeddings.length() { @@ -584,7 +592,8 @@ pub fn velocity_embedding( // we use a simplified scalar projection. let alignment = 1.0 // simplified: assume positive alignment for neighbors for d in 0.. Double { let n = a.length() let mut s = 0.0 @@ -614,6 +624,7 @@ fn vr_euclidean(a : Array[Double], b : Array[Double]) -> Double { vr_sqrt(s) } +///| fn vr_dot(a : Array[Double], b : Array[Double]) -> Double { let n = a.length() let mut s = 0.0 @@ -636,7 +647,7 @@ fn vr_dot(a : Array[Double], b : Array[Double]) -> Double { /// Returns indices of root cells sorted by speed (descending). pub fn velocity_find_root_cells( velocities : Array[CellVelocity], - n_roots : Int + n_roots : Int, ) -> Array[Int] { let n = velocities.length() let indices = Array::make(n, 0) @@ -677,7 +688,7 @@ pub fn velocity_transition_matrix( velocities : Array[CellVelocity], embeddings : Array[Array[Double]], k : Int, - temperature : Double + temperature : Double, ) -> Array[Array[Double]] { let n = velocities.length() let temp = if temperature > 0.0 { temperature } else { 1.0 } @@ -759,7 +770,7 @@ pub fn velocity_transition_matrix( pub fn velocity_run( gene_data : Array[VelocityGeneData], embeddings : Array[Array[Double]], - k : Int + k : Int, ) -> (Array[GeneKinetics], Array[CellVelocity], Array[EmbeddingVelocity]) { // 1. Estimate kinetics per gene. let kinetics : Array[GeneKinetics] = Array::new() diff --git a/src/venn_diagram.mbt b/src/venn_diagram.mbt index 0b52c44d..f6d2c030 100644 --- a/src/venn_diagram.mbt +++ b/src/venn_diagram.mbt @@ -48,7 +48,10 @@ pub struct VennDiagramResult { /// - names: Names for each set /// /// Returns: VennDiagramResult with region calculations. -pub fn venn_diagram(sets : Array[Array[String]], names? : Array[String] = []) -> VennDiagramResult { +pub fn venn_diagram( + sets : Array[Array[String]], + names? : Array[String] = [], +) -> VennDiagramResult { let n_sets = sets.length() let set_names = if names.length() == n_sets { names @@ -89,7 +92,12 @@ pub fn venn_diagram(sets : Array[Array[String]], names? : Array[String] = []) -> i = i + 1 } // Build regions - let regions = Array::make(n_regions, VennRegion::{id: 0, elements: Array::new(), count: 0, description: ""}) + let regions = Array::make(n_regions, VennRegion::{ + id: 0, + elements: Array::new(), + count: 0, + description: "", + }) r = 0 while r < n_regions { let count = region_elements[r].length() @@ -201,7 +209,10 @@ fn region_description(region_id : Int, set_names : Array[String]) -> String { /// V = number of vertices (intersection points) /// E = number of edges /// F = number of faces (regions) -fn compute_euler_characteristic(n_sets : Int, regions : Array[VennRegion]) -> Double { +fn compute_euler_characteristic( + n_sets : Int, + regions : Array[VennRegion], +) -> Double { // Simplified: just use number of non-empty regions let mut non_empty = 0 let mut i = 0 @@ -212,13 +223,20 @@ fn compute_euler_characteristic(n_sets : Int, regions : Array[VennRegion]) -> Do i = i + 1 } // For simple Venn diagrams, chi = 1 typically - if non_empty > 0 { 1.0 } else { 0.0 } + if non_empty > 0 { + 1.0 + } else { + 0.0 + } } ///| /// Get elements in a specific region defined by its bitmask. /// For example, region 0b101 (5) means elements in set 0 and set 2 but not set 1. -pub fn venn_get_region(result : VennDiagramResult, region_id : Int) -> Array[String] { +pub fn venn_get_region( + result : VennDiagramResult, + region_id : Int, +) -> Array[String] { let n = result.regions.length() if region_id >= 0 && region_id < n { result.regions[region_id].elements @@ -229,7 +247,10 @@ pub fn venn_get_region(result : VennDiagramResult, region_id : Int) -> Array[Str ///| /// Get elements only in a specific set (not in any other). -pub fn venn_only_in_set(result : VennDiagramResult, set_index : Int) -> Array[String] { +pub fn venn_only_in_set( + result : VennDiagramResult, + set_index : Int, +) -> Array[String] { let region_id = 1 << set_index venn_get_region(result, region_id) } @@ -237,7 +258,10 @@ pub fn venn_only_in_set(result : VennDiagramResult, set_index : Int) -> Array[St ///| /// Get elements in the intersection of specified sets and no others. /// Sets to include are specified as an array of set indices. -pub fn venn_intersection_only(result : VennDiagramResult, set_indices : Array[Int]) -> Array[String] { +pub fn venn_intersection_only( + result : VennDiagramResult, + set_indices : Array[Int], +) -> Array[String] { let mut region_id = 0 let mut i = 0 while i < set_indices.length() { @@ -288,14 +312,18 @@ pub fn venn_pairwise_overlap( // Count intersection let inter = venn_count_intersection(elements_i, elements_j) let union = n_i + n_j - inter - let jaccard = if union > 0 { inter.to_double() / union.to_double() } else { 0.0 } + let jaccard = if union > 0 { + inter.to_double() / union.to_double() + } else { + 0.0 + } let overlap_coeff = if min_int(n_i, n_j) > 0 { inter.to_double() / min_int(n_i, n_j).to_double() } else { 0.0 } let dice = if n_i + n_j > 0 { - (2.0 * inter.to_double()) / (n_i.to_double() + n_j.to_double()) + 2.0 * inter.to_double() / (n_i.to_double() + n_j.to_double()) } else { 0.0 } @@ -312,7 +340,10 @@ pub fn venn_pairwise_overlap( ///| /// Get all elements in a specific set. -fn venn_set_elements(result : VennDiagramResult, set_index : Int) -> Array[String] { +fn venn_set_elements( + result : VennDiagramResult, + set_index : Int, +) -> Array[String] { let elements = Array::new() let region_id = 1 << set_index // Find all regions that include this set (bit set) @@ -364,7 +395,8 @@ pub fn venn_summary(result : VennDiagramResult) -> String { let mut r = 0 while r < result.regions.length() { if result.regions[r].count > 0 { - s = s + " Region \{r} (0x\{hex_string(r)}): \{result.regions[r].count} elements - \{result.regions[r].description}\n" + s = s + + " Region \{r} (0x\{hex_string(r)}): \{result.regions[r].count} elements - \{result.regions[r].description}\n" } r = r + 1 } @@ -391,7 +423,10 @@ pub fn venn_summary(result : VennDiagramResult) -> String { ///| /// Compute a Venn diagram with only the counts (no element tracking). /// More efficient for large datasets where you only need region counts. -pub fn venn_counts_only(sets : Array[Array[String]], names? : Array[String] = []) -> Array[Int] { +pub fn venn_counts_only( + sets : Array[Array[String]], + names? : Array[String] = [], +) -> Array[Int] { let n_sets = sets.length() let n_regions = 1 << n_sets let counts = Array::make(n_regions, 0) @@ -432,7 +467,9 @@ pub fn venn_counts_only(sets : Array[Array[String]], names? : Array[String] = [] ///| /// Compute Euler diagram layout (regions and their positions). /// Returns normalized positions for each non-empty region. -pub fn venn_euler_layout(result : VennDiagramResult) -> Array[Map[String, Double]] { +pub fn venn_euler_layout( + result : VennDiagramResult, +) -> Array[Map[String, Double]] { let n_sets = result.n_sets let positions = Array::new() let mut r = 0 @@ -448,7 +485,10 @@ pub fn venn_euler_layout(result : VennDiagramResult) -> Array[Map[String, Double ///| /// Compute a approximate 2D position for a Venn region. -fn compute_region_position(region_id : Int, n_sets : Int) -> Map[String, Double] { +fn compute_region_position( + region_id : Int, + n_sets : Int, +) -> Map[String, Double] { // Place sets in a circle, then compute region positions as weighted average let m = Map::new() if n_sets == 0 { @@ -484,7 +524,12 @@ fn compute_region_position(region_id : Int, n_sets : Int) -> Map[String, Double] ///| /// Perform a pairwise Venn comparison of two sets only (2-set Venn). -pub fn venn_two_sets(set_a : Array[String], set_b : Array[String], name_a? : String = "A", name_b? : String = "B") -> VennDiagramResult { +pub fn venn_two_sets( + set_a : Array[String], + set_b : Array[String], + name_a? : String = "A", + name_b? : String = "B", +) -> VennDiagramResult { venn_diagram([set_a, set_b], names=[name_a, name_b]) } @@ -532,7 +577,10 @@ pub fn venn_difference(a : Array[String], b : Array[String]) -> Array[String] { ///| /// Compute symmetric difference (elements in either a or b but not both). -pub fn venn_symmetric_difference(a : Array[String], b : Array[String]) -> Array[String] { +pub fn venn_symmetric_difference( + a : Array[String], + b : Array[String], +) -> Array[String] { let diff_ab = venn_difference(a, b) let diff_ba = venn_difference(b, a) let result = diff_ab.copy() @@ -562,7 +610,7 @@ pub fn venn_dice(a : Array[String], b : Array[String]) -> Double { let inter = venn_intersection(a, b) let total = a.length() + b.length() if total > 0 { - (2.0 * inter.length().to_double()) / total.to_double() + 2.0 * inter.length().to_double() / total.to_double() } else { 0.0 } @@ -584,9 +632,18 @@ pub fn venn_overlap_coefficient(a : Array[String], b : Array[String]) -> Double /// Sample data: three gene sets for testing. pub fn venn_sample_gene_sets() -> Array[Array[String]] { [ - ["TP53", "BRCA1", "BRCA2", "EGFR", "MYC", "KRAS", "PTEN", "APC", "RB1", "VHL", "NF1", "MSH2", "MLH1", "MSH6", "PMS2"], - ["BRCA1", "BRCA2", "ATM", "CHEK2", "PALB2", "BRIP1", "RAD51C", "RAD51D", "BARD1", "FANCA", "FANCC", "FANCD2", "FANCE", "FANCF", "FANCG"], - ["TP53", "EGFR", "MYC", "KRAS", "MTOR", "PIK3CA", "AKT1", "TSC1", "TSC2", "RICTOR", "RAPTOR", "EIF4E", "4EBP1", "S6K1", "PDK1"], + [ + "TP53", "BRCA1", "BRCA2", "EGFR", "MYC", "KRAS", "PTEN", "APC", "RB1", "VHL", + "NF1", "MSH2", "MLH1", "MSH6", "PMS2", + ], + [ + "BRCA1", "BRCA2", "ATM", "CHEK2", "PALB2", "BRIP1", "RAD51C", "RAD51D", "BARD1", + "FANCA", "FANCC", "FANCD2", "FANCE", "FANCF", "FANCG", + ], + [ + "TP53", "EGFR", "MYC", "KRAS", "MTOR", "PIK3CA", "AKT1", "TSC1", "TSC2", "RICTOR", + "RAPTOR", "EIF4E", "4EBP1", "S6K1", "PDK1", + ], ] } @@ -625,5 +682,5 @@ fn format_venn_stat(value : Double) -> String { pub fn venn_sample_result() -> VennDiagramResult { let sets = venn_sample_gene_sets() let names = venn_sample_gene_names() - venn_diagram(sets, names=names) + venn_diagram(sets, names~) } diff --git a/src/voyager.mbt b/src/voyager.mbt new file mode 100644 index 00000000..5f3f8106 --- /dev/null +++ b/src/voyager.mbt @@ -0,0 +1,2581 @@ +///| +/// Voyager — Bioconductor spatial transcriptomics univariate, bivariate and +/// multivariate spatial autocorrelation statistics, inspired by the Voyager +/// Bioconductor package (Pardo, Spakov, Wolf et al.). +/// +/// Implements: +/// - Spatial neighbour/weight construction (kNN, distance band, inverse +/// distance) with row-standardized / binary / globally-standardized / +/// Caussinus-Mestre style coding. +/// - Global Moran's I and Geary's c with the Cliff–Ord randomization +/// expectation and variance and a normal-approximation p-value. +/// - Local Moran's I (LISA) with quadrant classification and permutation +/// inference, local_res Geary's c, and local_res Getis–Ord Gi / Gi* with the +/// exact Ord–Getis randomization z-score. +/// - Bivariate Lee's L (global and local_res) and multivariate local_res Geary. +/// - Empirical variogram with spherical / exponential / Gaussian model +/// fitting by bounded grid search + linear least squares. +/// - Spatial Moran correlogram over distance bins. +/// - Deterministic permutation tests (seeded splitmix64 PRNG) and +/// Benjamini–Hochberg FDR. +/// - Immutable SpatialExperiment write-back of local_res results. + +// =========================================================================== +// Error type and validation helpers +// =========================================================================== + +///| +pub suberror VoyagerError { + VoyagerError(String) +} + +///| +fn voy_fail(message : String) -> Unit raise VoyagerError { + raise VoyagerError::VoyagerError(message) +} + +///| +fn voy_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn voy_copy_double_matrix( + values : Array[Array[Double]], +) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in values { + output.push(row.copy()) + } + output +} + +///| +fn voy_copy_string_map(values : Map[String, String]) -> Map[String, String] { + let output : Map[String, String] = Map([], capacity=values.keys().length()) + for key in values.keys() { + output[key] = values[key] + } + output +} + +///| +fn voy_default_names(prefix : String, count : Int) -> Array[String] { + let output : Array[String] = [] + for index in 0.. Unit raise VoyagerError { + if values.length() < 3 { + voy_fail("Voyager " + label + " requires at least 3 observations") + } + for value in values { + if !voy_is_finite(value) { + voy_fail("Voyager " + label + " must be finite") + } + } +} + +///| +fn voy_validate_weights( + weights : VoyagerWeights, + label : String, +) -> Unit raise VoyagerError { + if weights.n < 3 { + voy_fail("Voyager " + label + " weights require at least 3 spots") + } + if weights.neighbors.length() != weights.n { + voy_fail("Voyager " + label + " weights neighbours must match spot count") + } + if weights.weights.length() != weights.n { + voy_fail("Voyager " + label + " weights rows must match spot count") + } + let mut has_link = false + for index in 0.. 0 { + has_link = true + } + } + if !has_link { + voy_fail("Voyager " + label + " weights must contain at least one link") + } +} + +///| +fn voy_validate_equal_length( + a : Array[Double], + b : Array[Double], + label : String, +) -> Unit raise VoyagerError { + if a.length() != b.length() { + voy_fail("Voyager " + label + " vectors must have equal length") + } +} + +// =========================================================================== +// Deterministic PRNG (splitmix64) for reproducible permutations +// =========================================================================== + +///| +priv struct VoyagerRng { + mut state : Int64 +} + +///| +fn VoyagerRng::new(seed : Int) -> VoyagerRng { + let init = if seed < 0 { + seed.to_int64() + 9223372036854775807L + } else { + seed.to_int64() + } + VoyagerRng::{ state: init + 0x9E3779B97F4A7C15L } +} + +///| +fn VoyagerRng::next_uint64(self : VoyagerRng) -> Int64 { + let mut z = self.state + z = z + 0x9E3779B97F4A7C15L + self.state = z + z = z ^ (z >> 30) + z = z * 0xBF58476D1CE4E5B9L + z = z ^ (z >> 27) + z = z * 0x94D049BB133111EBL + z = z ^ (z >> 31) + z +} + +///| +fn VoyagerRng::next_int_range(self : VoyagerRng, upper_exclusive : Int) -> Int { + if upper_exclusive <= 0 { + return 0 + } + let value = self.next_uint64() + if upper_exclusive <= 2147483647 { + (value & 2147483647L).to_int() % upper_exclusive + } else { + value.to_int() % upper_exclusive + } +} + +///| +/// Fisher–Yates shuffle (in place on a copy) using the deterministic PRNG. +fn voy_permute(values : Array[Double], rng : VoyagerRng) -> Array[Double] { + let output = values.copy() + let n = output.length() + let mut i = n - 1 + while i > 0 { + let j = rng.next_int_range(i + 1) + let tmp = output[i] + output[i] = output[j] + output[j] = tmp + i = i - 1 + } + output +} + +// =========================================================================== +// Benjamini–Hochberg FDR +// =========================================================================== + +///| +fn voy_bh_adjust(p_values : Array[Double]) -> Array[Double] { + let count = p_values.length() + let output : Array[Double] = Array::make(count, 1.0) + if count == 0 { + return output + } + let indexed : Array[(Double, Int)] = [] + for index in 0.. Int { + if left.0 < right.0 { + -1 + } else if left.0 > right.0 { + 1 + } else { + left.1 - right.1 + } + }) + let mut running = 1.0 + let mut position = count - 1 + while position >= 0 { + let candidate = (indexed[position].0 * + count.to_double() / + (position + 1).to_double()).min(1.0) + running = running.min(candidate) + output[indexed[position].1] = running + position = position - 1 + } + output +} + +// =========================================================================== +// Normal CDF (Abramowitz–Stegun) for analytical p-values +// =========================================================================== + +///| +fn voy_normal_cdf(x : Double) -> Double { + let abs_x = if x < 0.0 { -x } else { x } + let t = 1.0 / (1.0 + 0.2316419 * abs_x) + let d = 0.3989422804014327 * @math.exp(-x * x / 2.0) + let p = d * + t * + ( + 0.31938153 + + t * + (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))) + ) + if x > 0.0 { + 1.0 - p + } else { + p + } +} + +///| +fn voy_two_sided_p(z : Double) -> Double { + let abs_z = if z < 0.0 { -z } else { z } + 2.0 * (1.0 - voy_normal_cdf(abs_z)) +} + +// =========================================================================== +// Distance and weights +// =========================================================================== + +///| +fn voy_euclidean(a : Array[Double], b : Array[Double]) -> Double { + let mut sum = 0.0 + let limit = if a.length() < b.length() { a.length() } else { b.length() } + for index in 0.. Array[Array[Double]] { + let n = coords.length() + // Build a fresh inner array per row — `Array::make(n, Array::make(n, 0.0))` + // would alias a single inner array across all rows. + let output : Array[Array[Double]] = [] + for _ in 0.. VoyagerWeights raise VoyagerError { + let n = neighbors.length() + if weights.length() != n { + voy_fail("Voyager weights neighbour/weight row counts must match") + } + for index in 0.. Double { + let mut total = 0.0 + for index in 0.. Double { + let n = weights.n + let mut total = 0.0 + for i in 0.. Double { + let n = weights.n + let row_sums : Array[Double] = Array::make(n, 0.0) + let col_sums : Array[Double] = Array::make(n, 0.0) + for i in 0.. Double { + if i < 0 || i >= weights.n { + return 0.0 + } + let neighbors = weights.neighbors[i] + let values = weights.weights[i] + for k in 0.. Array[Array[Double]] { + let n = neighbors.length() + match style { + "B" => { + let output : Array[Array[Double]] = [] + for index in 0.. { + let mut s0 = 0.0 + for index in 0.. 0.0 { 1.0 / s0 } else { 0.0 } + let output : Array[Array[Double]] = [] + for index in 0.. { + let k : Array[Double] = Array::make(n, 0.0) + for index in 0.. { + // "W" — row-standardized + let output : Array[Array[Double]] = [] + for index in 0.. 0.0 { + for value in raw[index] { + row.push(value / row_sum) + } + } else { + for _ in raw[index] { + row.push(0.0) + } + } + output.push(row) + } + output + } + } +} + +///| +/// Build k-nearest-neighbour spatial weights. +/// `coords` is one row per spot. `k` is the number of neighbours (excluding self). +pub fn voyager_weights_knn( + coords : Array[Array[Double]], + k : Int, + style? : String = "W", +) -> VoyagerWeights raise VoyagerError { + if coords.length() < 3 { + voy_fail("Voyager kNN weights require at least 3 spots") + } + if k < 1 { + voy_fail("Voyager kNN weights require k >= 1") + } + let n = coords.length() + for coordinate in coords { + if coordinate.length() == 0 { + voy_fail("Voyager kNN coordinates must not be empty") + } + for value in coordinate { + if !voy_is_finite(value) { + voy_fail("Voyager kNN coordinates must be finite") + } + } + } + let effective_k = k.min(n - 1) + let distances = voy_pairwise_distances(coords) + let neighbors : Array[Array[Int]] = [] + let raw : Array[Array[Double]] = [] + for i in 0.. Int { + if a.0 < b.0 { + -1 + } else if a.0 > b.0 { + 1 + } else { + a.1 - b.1 + } + }) + let nb : Array[Int] = [] + let w : Array[Double] = [] + for position in 0.. VoyagerWeights raise VoyagerError { + if coords.length() < 3 { + voy_fail("Voyager distance-band weights require at least 3 spots") + } + if !voy_is_finite(bandwidth) || bandwidth <= 0.0 { + voy_fail("Voyager distance-band bandwidth must be positive and finite") + } + let n = coords.length() + for coordinate in coords { + if coordinate.length() == 0 { + voy_fail("Voyager distance-band coordinates must not be empty") + } + for value in coordinate { + if !voy_is_finite(value) { + voy_fail("Voyager distance-band coordinates must be finite") + } + } + } + let neighbors : Array[Array[Int]] = [] + let raw : Array[Array[Double]] = [] + for i in 0.. VoyagerWeights raise VoyagerError { + if coords.length() < 3 { + voy_fail("Voyager inverse-distance weights require at least 3 spots") + } + if !voy_is_finite(power) || power <= 0.0 { + voy_fail("Voyager inverse-distance power must be positive and finite") + } + let n = coords.length() + for coordinate in coords { + if coordinate.length() == 0 { + voy_fail("Voyager inverse-distance coordinates must not be empty") + } + for value in coordinate { + if !voy_is_finite(value) { + voy_fail("Voyager inverse-distance coordinates must be finite") + } + } + } + let limited = bandwidth > 0.0 && voy_is_finite(bandwidth) + let neighbors : Array[Array[Int]] = [] + let raw : Array[Array[Double]] = [] + for i in 0.. 0.0 && (!limited || d <= bandwidth) { + nb.push(j) + w.push(1.0 / @math.pow(d, power)) + } + } + } + neighbors.push(nb) + raw.push(w) + } + let styled = voy_apply_style(neighbors, raw, style) + VoyagerWeights::{ style, n, neighbors, weights: styled } +} + +// =========================================================================== +// Global Moran's I +// =========================================================================== + +///| +pub struct VoyagerGlobalMoranI { + feature : String + estimate : Double + expectation : Double + variance : Double + z_score : Double + p_value : Double + n : Int + s0 : Double + s1 : Double + s2 : Double +} derive(Debug) + +///| +/// Internal Moran's I numerator and denominator for a given (permuted) vector. +fn voy_moran_components( + values : Array[Double], + weights : VoyagerWeights, + mean : Double, +) -> (Double, Double) { + let n = values.length() + let centered : Array[Double] = [] + for index in 0.. VoyagerGlobalMoranI raise VoyagerError { + voy_validate_vector(values, "Moran's I") + voy_validate_weights(weights, "Moran's I") + if values.length() != weights.n { + voy_fail("Voyager Moran's I values must match weights length") + } + let n = values.length() + let mut mean = 0.0 + for value in values { + mean = mean + value + } + mean = mean / n.to_double() + let s0 = voyager_weights_s0(weights) + if s0 <= 0.0 { + voy_fail("Voyager Moran's I requires non-zero total weight S0") + } + let s1 = voyager_weights_s1(weights) + let s2 = voyager_weights_s2(weights) + let (numerator, denominator) = voy_moran_components(values, weights, mean) + if denominator <= 0.0 { + voy_fail("Voyager Moran's I requires non-zero variance in values") + } + let estimate = n.to_double() / s0 * (numerator / denominator) + let expectation = -1.0 / (n.to_double() - 1.0) + // Randomization variance (Cliff & Ord 1981) + let mut m2 = 0.0 + let mut m4 = 0.0 + for value in values { + let dev = value - mean + m2 = m2 + dev * dev + m4 = m4 + dev * dev * dev * dev + } + let b2 = n.to_double() * m4 / (m2 * m2) + let nd = n.to_double() + let n1 = nd - 1.0 + let n2 = nd - 2.0 + let n3 = nd - 3.0 + let a = nd * ((nd * nd - 3.0 * nd + 3.0) * s1 - nd * s2 + 3.0 * s0 * s0) + let b = b2 * ((nd * nd - nd) * s1 - 2.0 * nd * s2 + 6.0 * s0 * s0) + let variance = (a - b) / (n1 * n2 * n3 * s0 * s0) - expectation * expectation + let safe_variance = if variance > 0.0 { variance } else { 0.0 } + let z_score = if safe_variance > 0.0 { + (estimate - expectation) / safe_variance.sqrt() + } else { + 0.0 + } + let p_value = voy_two_sided_p(z_score) + VoyagerGlobalMoranI::{ + feature, + estimate, + expectation, + variance: safe_variance, + z_score, + p_value, + n, + s0, + s1, + s2, + } +} + +// =========================================================================== +// Global Geary's c +// =========================================================================== + +///| +pub struct VoyagerGlobalGearyC { + feature : String + estimate : Double + expectation : Double + variance : Double + z_score : Double + p_value : Double + n : Int + s0 : Double + s1 : Double + s2 : Double +} derive(Debug) + +///| +/// Global Geary's c with the Cliff–Ord randomization expectation and variance. +pub fn voyager_global_gearys_c( + values : Array[Double], + weights : VoyagerWeights, + feature? : String = "feature", +) -> VoyagerGlobalGearyC raise VoyagerError { + voy_validate_vector(values, "Geary's c") + voy_validate_weights(weights, "Geary's c") + if values.length() != weights.n { + voy_fail("Voyager Geary's c values must match weights length") + } + let n = values.length() + let mut mean = 0.0 + for value in values { + mean = mean + value + } + mean = mean / n.to_double() + let s0 = voyager_weights_s0(weights) + if s0 <= 0.0 { + voy_fail("Voyager Geary's c requires non-zero total weight S0") + } + let s1 = voyager_weights_s1(weights) + let s2 = voyager_weights_s2(weights) + let mut cross = 0.0 + let mut ssd = 0.0 + for i in 0.. 0.0 { variance } else { 0.0 } + let z_score = if safe_variance > 0.0 { + (estimate - expectation) / safe_variance.sqrt() + } else { + 0.0 + } + let p_value = voy_two_sided_p(z_score) + VoyagerGlobalGearyC::{ + feature, + estimate, + expectation, + variance: safe_variance, + z_score, + p_value, + n, + s0, + s1, + s2, + } +} + +///| +fn n1_value(n : Int) -> Double { + (n - 1).to_double() +} + +// =========================================================================== +// Permutation helpers shared by local_res statistics +// =========================================================================== + +///| +fn voy_perm_p_value_two_sided( + observed : Double, + expectation : Double, + permutations : Array[Double], +) -> (Double, Double, Double) { + // Returns (p_value, perm_mean, perm_sd). + let count = permutations.length() + if count == 0 { + return (1.0, observed, 0.0) + } + let mut sum = 0.0 + let mut sum_sq = 0.0 + for value in permutations { + sum = sum + value + sum_sq = sum_sq + value * value + } + let mean = sum / count.to_double() + let var_sample = (sum_sq - sum * sum / count.to_double()) / count.to_double() + let sd = if var_sample > 0.0 { var_sample.sqrt() } else { 0.0 } + let obs_dev = (observed - expectation).abs() + let mut extreme = 0 + for value in permutations { + if (value - expectation).abs() >= obs_dev { + extreme = extreme + 1 + } + } + let p = (extreme.to_double() + 1.0) / (count.to_double() + 1.0) + (p, mean, sd) +} + +// =========================================================================== +// Local Moran's I (LISA) +// =========================================================================== + +///| +pub struct VoyagerLocalMoranI { + feature : String + local_i : Array[Double] + expectations : Array[Double] + variances : Array[Double] + z_scores : Array[Double] + p_values : Array[Double] + fdr : Array[Double] + quadrants : Array[String] + perm_mean : Array[Double] + perm_sd : Array[Double] + n : Int + permutations : Int + style : String +} derive(Debug) + +///| +/// Quadrant classification from the Moran scatter plot. The spatial lag is the +/// row-standardized weighted sum of the neighbours' standardized values. +fn voy_moran_quadrant( + z_i : Double, + lag_i : Double, + z_significant : Bool, +) -> String { + if !z_significant { + return "not significant" + } + if z_i > 0.0 && lag_i > 0.0 { + "HH" + } else if z_i < 0.0 && lag_i < 0.0 { + "LL" + } else if z_i > 0.0 && lag_i < 0.0 { + "HL" + } else { + "LH" + } +} + +///| +fn voy_local_morans_point( + values : Array[Double], + weights : VoyagerWeights, + mean : Double, + m2 : Double, +) -> Array[Double] { + let n = values.length() + let centered : Array[Double] = [] + for index in 0.. VoyagerLocalMoranI raise VoyagerError { + voy_validate_vector(values, "local_res Moran's I") + voy_validate_weights(weights, "local_res Moran's I") + if values.length() != weights.n { + voy_fail("Voyager local_res Moran's I values must match weights length") + } + if permutations < 0 { + voy_fail("Voyager local_res Moran's I permutations must be non-negative") + } + if !voy_is_finite(fdr_threshold) || + fdr_threshold <= 0.0 || + fdr_threshold > 1.0 { + voy_fail("Voyager local_res Moran's I FDR threshold must be in (0, 1]") + } + let n = values.length() + let mut mean = 0.0 + for value in values { + mean = mean + value + } + mean = mean / n.to_double() + let mut m2 = 0.0 + for value in values { + let dev = value - mean + m2 = m2 + dev * dev + } + m2 = m2 / n.to_double() + if m2 <= 0.0 { + voy_fail("Voyager local_res Moran's I requires non-zero variance in values") + } + let observed = voy_local_morans_point(values, weights, mean, m2) + // Standardized values and spatial lag for quadrant classification. + let z_scores_std : Array[Double] = [] + for value in values { + z_scores_std.push((value - mean) / m2.sqrt()) + } + let lag_std : Array[Double] = Array::make(n, 0.0) + for i in 0.. 0 { + let rng = VoyagerRng::new(seed) + // perm_local[k][i] = local_res Moran's I at spot i under permutation k. + let perm_local : Array[Array[Double]] = [] + for _ in 0.. 0.0 { (observed[i] - pmean) / psd } else { 0.0 } + } + } else { + // Analytical approximation: use permutation-free variance under the + // randomization assumption for reference only. + for i in 0.. 0.0 { var_i } else { 0.0 } + variances[i] = safe_var + z_scores[i] = if safe_var > 0.0 { + (observed[i] - exp_i) / safe_var.sqrt() + } else { + 0.0 + } + p_values[i] = voy_two_sided_p(z_scores[i]) + perm_mean[i] = exp_i + perm_sd[i] = safe_var.sqrt() + } + } + let fdr = voy_bh_adjust(p_values) + let quadrants : Array[String] = [] + for i in 0.. Array[Double] { + let n = values.length() + let output : Array[Double] = Array::make(n, 0.0) + if m2 <= 0.0 { + return output + } + for i in 0.. VoyagerLocalGearyC raise VoyagerError { + voy_validate_vector(values, "local_res Geary's c") + voy_validate_weights(weights, "local_res Geary's c") + if values.length() != weights.n { + voy_fail("Voyager local_res Geary's c values must match weights length") + } + if permutations < 0 { + voy_fail("Voyager local_res Geary's c permutations must be non-negative") + } + if !voy_is_finite(fdr_threshold) || + fdr_threshold <= 0.0 || + fdr_threshold > 1.0 { + voy_fail("Voyager local_res Geary's c FDR threshold must be in (0, 1]") + } + let n = values.length() + let mut mean = 0.0 + for value in values { + mean = mean + value + } + mean = mean / n.to_double() + let mut m2 = 0.0 + for value in values { + let dev = value - mean + m2 = m2 + dev * dev + } + m2 = m2 / n.to_double() + if m2 <= 0.0 { + voy_fail("Voyager local_res Geary's c requires non-zero variance in values") + } + let observed = voy_local_gearys_point(values, weights, m2) + let expectations : Array[Double] = Array::make(n, 1.0) + let z_scores : Array[Double] = Array::make(n, 0.0) + let p_values : Array[Double] = Array::make(n, 1.0) + if permutations > 0 { + let rng = VoyagerRng::new(seed) + let perm_local : Array[Array[Double]] = [] + for _ in 0.. 0.0 { (observed[i] - pmean) / psd } else { 0.0 } + } + } else { + for i in 0.. 1.0 { + classifications.push("dissimilar") + } else { + classifications.push("not significant") + } + } + VoyagerLocalGearyC::{ + feature, + local_c: observed, + expectations, + z_scores, + p_values, + fdr, + classifications, + n, + permutations, + } +} + +// =========================================================================== +// Local Getis–Ord Gi / Gi* +// =========================================================================== + +///| +pub struct VoyagerLocalGetisOrd { + feature : String + statistic : Array[Double] + expectations : Array[Double] + z_scores : Array[Double] + p_values : Array[Double] + fdr : Array[Double] + classifications : Array[String] + star : Bool + n : Int +} derive(Debug) + +///| +/// Local Getis–Ord Gi (excludes self) or Gi* (includes self with w_ii = 1). +/// Significance uses the exact Ord–Getis randomization z-score for the +/// weighted sum. +pub fn voyager_local_getis_ord( + values : Array[Double], + weights : VoyagerWeights, + star? : Bool = true, + fdr_threshold? : Double = 0.05, + feature? : String = "feature", +) -> VoyagerLocalGetisOrd raise VoyagerError { + voy_validate_vector(values, "Getis–Ord") + voy_validate_weights(weights, "Getis–Ord") + if values.length() != weights.n { + voy_fail("Voyager Getis–Ord values must match weights length") + } + if !voy_is_finite(fdr_threshold) || + fdr_threshold <= 0.0 || + fdr_threshold > 1.0 { + voy_fail("Voyager Getis–Ord FDR threshold must be in (0, 1]") + } + let n = values.length() + let mut total = 0.0 + let mut total_sq = 0.0 + for value in values { + if value < 0.0 { + voy_fail("Voyager Getis–Ord requires non-negative values") + } + total = total + value + total_sq = total_sq + value * value + } + let mean = total / n.to_double() + // Sample variance with denominator (n-1). + let sample_var = (total_sq - total * total / n.to_double()) / + (n.to_double() - 1.0) + let safe_var = if sample_var > 0.0 { sample_var } else { 0.0 } + let statistic : Array[Double] = Array::make(n, 0.0) + let expectations : Array[Double] = Array::make(n, 0.0) + let z_scores : Array[Double] = Array::make(n, 0.0) + let p_values : Array[Double] = Array::make(n, 1.0) + for i in 0.. 0.0 { numerator_sum / y } else { 0.0 } + statistic[i] = stat + expectations[i] = total_w / n_used + let denom_root = if safe_var > 0.0 { + let var_weighted = (n_used * total_w_sq - total_w * total_w) / + (n_used - 1.0).max(1.0) + if var_weighted > 0.0 { + safe_var.sqrt() * var_weighted.sqrt() + } else { + 0.0 + } + } else { + 0.0 + } + let z = if denom_root > 0.0 { + (numerator_sum - total_w * mean) / denom_root + } else { + 0.0 + } + z_scores[i] = z + p_values[i] = voy_two_sided_p(z) + } + let fdr = voy_bh_adjust(p_values) + let classifications : Array[String] = [] + for i in 0.. 0.0 { + classifications.push("hotspot") + } else if fdr[i] <= fdr_threshold && z_scores[i] < 0.0 { + classifications.push("coldspot") + } else { + classifications.push("not significant") + } + } + VoyagerLocalGetisOrd::{ + feature, + statistic, + expectations, + z_scores, + p_values, + fdr, + classifications, + star, + n, + } +} + +// =========================================================================== +// Lee's L (bivariate spatial association) +// =========================================================================== + +///| +pub struct VoyagerLeesL { + feature_x : String + feature_y : String + global_l : Double + local_l : Array[Double] + z_scores : Array[Double] + p_values : Array[Double] + fdr : Array[Double] + n : Int + s0 : Double +} derive(Debug) + +///| +/// Lee's L (Lee 2001) bivariate spatial association. Returns the global L +/// (range approximately [-1, 1] for row-standardized weights) and per-location +/// local_res L values with permutation-based inference. +pub fn voyager_lees_l( + values_x : Array[Double], + values_y : Array[Double], + weights : VoyagerWeights, + permutations? : Int = 0, + seed? : Int = 20240501, + fdr_threshold? : Double = 0.05, + feature_x? : String = "feature_x", + feature_y? : String = "feature_y", +) -> VoyagerLeesL raise VoyagerError { + voy_validate_vector(values_x, "Lee's L x") + voy_validate_vector(values_y, "Lee's L y") + voy_validate_weights(weights, "Lee's L") + voy_validate_equal_length(values_x, values_y, "Lee's L") + if values_x.length() != weights.n { + voy_fail("Voyager Lee's L values must match weights length") + } + if !voy_is_finite(fdr_threshold) || + fdr_threshold <= 0.0 || + fdr_threshold > 1.0 { + voy_fail("Voyager Lee's L FDR threshold must be in (0, 1]") + } + let n = values_x.length() + let mut mean_x = 0.0 + let mut mean_y = 0.0 + for index in 0.. 0 { + let rng = VoyagerRng::new(seed) + let perm_local : Array[Array[Double]] = [] + for _ in 0.. 0.0 { pvar.sqrt() } else { 0.0 } + let mut extreme = 0 + for value in permut_values { + if (value - pmean).abs() >= (local_l[i] - pmean).abs() { + extreme = extreme + 1 + } + } + p_values[i] = (extreme.to_double() + 1.0) / + (permut_values.length().to_double() + 1.0) + z_scores[i] = if psd > 0.0 { (local_l[i] - pmean) / psd } else { 0.0 } + } + } + let fdr = voy_bh_adjust(p_values) + VoyagerLeesL::{ + feature_x, + feature_y, + global_l, + local_l, + z_scores, + p_values, + fdr, + n, + s0, + } +} + +// =========================================================================== +// Multivariate local_res Geary +// =========================================================================== + +///| +pub struct VoyagerMultivariateLocalGeary { + feature_set : Array[String] + local_statistic : Array[Double] + expectations : Array[Double] + z_scores : Array[Double] + p_values : Array[Double] + fdr : Array[Double] + classifications : Array[String] + n : Int + n_features : Int + permutations : Int +} derive(Debug) + +///| +fn voy_multivariate_local_geary_point( + matrix : Array[Array[Double]], + weights : VoyagerWeights, + means : Array[Double], +) -> Array[Double] { + // matrix[feature][spot]. Returns per-spot sum over features of weighted + // squared feature-space distances to neighbours. + let n_features = matrix.length() + let n = if n_features > 0 { matrix[0].length() } else { 0 } + let output : Array[Double] = Array::make(n, 0.0) + for i in 0.. VoyagerMultivariateLocalGeary raise VoyagerError { + if matrix.length() == 0 { + voy_fail( + "Voyager multivariate local_res Geary requires at least one feature", + ) + } + let n_features = matrix.length() + let n = matrix[0].length() + if n < 3 { + voy_fail("Voyager multivariate local_res Geary requires at least 3 spots") + } + for feature in 0.. 0 { + let rng = VoyagerRng::new(seed) + let perm_local : Array[Array[Double]] = [] + for _ in 0.. 0.0 { pvar.sqrt() } else { 0.0 } + let mut extreme = 0 + for value in permut_values { + if (value - pmean).abs() >= (observed[i] - pmean).abs() { + extreme = extreme + 1 + } + } + p_values[i] = (extreme.to_double() + 1.0) / + (permut_values.length().to_double() + 1.0) + z_scores[i] = if psd > 0.0 { (observed[i] - pmean) / psd } else { 0.0 } + } + } + let fdr = voy_bh_adjust(p_values) + let names = if feature_names.length() == n_features { + feature_names + } else { + voy_default_names("feature", n_features) + } + let classifications : Array[String] = [] + for i in 0.. 0.0 { + classifications.push("dissimilar") + } else { + classifications.push("not significant") + } + } + VoyagerMultivariateLocalGeary::{ + feature_set: names, + local_statistic: observed, + expectations, + z_scores, + p_values, + fdr, + classifications, + n, + n_features, + permutations, + } +} + +// =========================================================================== +// Empirical variogram and model fitting +// =========================================================================== + +///| +pub struct VoyagerVariogramPoint { + lag : Double + gamma : Double + npairs : Int +} derive(Debug) + +///| +pub struct VoyagerVariogramModel { + model_type : String + nugget : Double + sill : Double + range : Double + fitted_sse : Double + n_points : Int +} derive(Debug) + +///| +/// Empirical (sample) variogram. Pairs of spots are binned into `n_lags` +/// equidistant bins from 0 to `max_lag` (default: half the maximum pairwise +/// distance). The semivariance at each bin is half the mean squared +/// difference of values for the pairs assigned to that bin. +pub fn voyager_empirical_variogram( + coords : Array[Array[Double]], + values : Array[Double], + n_lags? : Int = 15, + max_lag? : Double = 0.0, +) -> Array[VoyagerVariogramPoint] raise VoyagerError { + if coords.length() < 3 { + voy_fail("Voyager variogram requires at least 3 spots") + } + if values.length() != coords.length() { + voy_fail("Voyager variogram values must match coordinates length") + } + if n_lags < 1 { + voy_fail("Voyager variogram n_lags must be positive") + } + for value in values { + if !voy_is_finite(value) { + voy_fail("Voyager variogram values must be finite") + } + } + let n = coords.length() + let distances = voy_pairwise_distances(coords) + let mut max_dist = 0.0 + for i in 0.. max_dist { + max_dist = distances[i][j] + } + } + } + if max_dist <= 0.0 { + voy_fail("Voyager variogram requires non-coincident coordinates") + } + let upper = if max_lag > 0.0 && voy_is_finite(max_lag) { + max_lag + } else { + max_dist / 2.0 + } + let lag_width = upper / n_lags.to_double() + if lag_width <= 0.0 { + voy_fail("Voyager variogram lag width must be positive") + } + let sums : Array[Double] = Array::make(n_lags, 0.0) + let counts : Array[Int] = Array::make(n_lags, 0) + for i in 0.. 0.0 && d <= upper { + let bin = (d / lag_width).to_int().min(n_lags - 1) + let diff = values[i] - values[j] + sums[bin] = sums[bin] + diff * diff + counts[bin] = counts[bin] + 1 + } + } + } + let output : Array[VoyagerVariogramPoint] = [] + for bin in 0.. 0 { + let lag = (bin.to_double() + 0.5) * lag_width + let gamma = sums[bin] / (2.0 * counts[bin].to_double()) + output.push(VoyagerVariogramPoint::{ lag, gamma, npairs: counts[bin] }) + } + } + if output.length() == 0 { + voy_fail("Voyager variogram produced no populated bins") + } + output +} + +///| +/// Theoretical variogram shape function (excluding nugget). Returns the +/// bounded partial sill component for distance h. +fn voy_variogram_shape( + model_type : String, + h : Double, + range : Double, +) -> Double { + if range <= 0.0 { + return 0.0 + } + let ratio = h / range + match model_type { + "spherical" => + if h >= range { + 1.0 + } else { + 1.5 * ratio - 0.5 * ratio * ratio * ratio + } + "exponential" => 1.0 - @math.exp(-3.0 * ratio) + "gaussian" => 1.0 - @math.exp(-3.0 * ratio * ratio) + _ => 0.0 + } +} + +///| +/// Fit a theoretical variogram model (spherical, exponential or gaussian) to +/// an empirical variogram by minimizing the sum of squared residuals. A +/// bounded grid search over `range` is combined with closed-form linear +/// least squares for (nugget, partial sill) at each candidate range. +pub fn voyager_fit_variogram( + empirical : Array[VoyagerVariogramPoint], + model_type? : String = "spherical", + nugget? : Double = 0.0, + fix_nugget? : Bool = false, + range_grid? : Int = 40, +) -> VoyagerVariogramModel raise VoyagerError { + if empirical.length() < 2 { + voy_fail("Voyager variogram fit requires at least 2 empirical points") + } + let model : String = match model_type { + "spherical" => "spherical" + "exponential" => "exponential" + "gaussian" => "gaussian" + _ => + raise VoyagerError::VoyagerError( + "Voyager variogram model must be spherical/exponential/gaussian", + ) + } + if !voy_is_finite(nugget) || nugget < 0.0 { + voy_fail("Voyager variogram nugget must be non-negative and finite") + } + if range_grid < 4 { + voy_fail("Voyager variogram range grid must have at least 4 points") + } + let mut max_lag = 0.0 + for point in empirical { + if point.lag > max_lag { + max_lag = point.lag + } + } + if max_lag <= 0.0 { + voy_fail("Voyager variogram empirical lags must be positive") + } + // Precompute shape values for each (point, candidate range) — but to keep + // the implementation simple we iterate ranges and solve the linear LSQ. + let mut best_sse = 1.0e300 + let mut best_nugget = if fix_nugget { nugget } else { 0.0 } + let mut best_sill = 0.0 + let mut best_range = max_lag / 3.0 + let grid = range_grid + let mut gi = 1 + while gi <= grid { + let candidate_range = max_lag * gi.to_double() / grid.to_double() + if candidate_range <= 0.0 { + gi = gi + 1 + continue + } + // Linear least squares for y = nugget + partial_sill * shape(h). + // If nugget is fixed, this is a one-parameter least squares. + let mut sum_x = 0.0 + let mut sum_y = 0.0 + let mut sum_xx = 0.0 + let mut sum_xy = 0.0 + let mut count = 0.0 + for point in empirical { + let shape = voy_variogram_shape(model, point.lag, candidate_range) + let y = point.gamma + if fix_nugget { + // y - nugget = partial_sill * shape -> one-parameter LSQ. + sum_x = sum_x + shape + sum_y = sum_y + (y - nugget) + sum_xx = sum_xx + shape * shape + sum_xy = sum_xy + shape * (y - nugget) + } else { + sum_x = sum_x + shape + sum_y = sum_y + y + sum_xx = sum_xx + shape * shape + sum_xy = sum_xy + shape * y + } + count = count + 1.0 + } + let (fit_nugget, fit_partial) = if fix_nugget { + let denom = sum_xx + let partial = if denom > 0.0 { sum_xy / denom } else { 0.0 } + (nugget, partial) + } else { + // Two-parameter LSQ: y = a + b * shape, a = nugget, b = partial_sill. + let denom = count * sum_xx - sum_x * sum_x + if denom.abs() < 1.0e-300 { + (0.0, 0.0) + } else { + let b = (count * sum_xy - sum_x * sum_y) / denom + let a = (sum_y - b * sum_x) / count + (a, b) + } + } + // Enforce non-negative nugget and partial sill (physical constraint). + let safe_nugget = if fit_nugget < 0.0 { 0.0 } else { fit_nugget } + let safe_partial = if fit_partial < 0.0 { 0.0 } else { fit_partial } + let mut sse = 0.0 + for point in empirical { + let shape = voy_variogram_shape(model, point.lag, candidate_range) + let predicted = safe_nugget + safe_partial * shape + let residual = point.gamma - predicted + sse = sse + residual * residual + } + if sse < best_sse { + best_sse = sse + best_nugget = safe_nugget + best_sill = safe_partial + best_range = candidate_range + } + gi = gi + 1 + } + // Refine around the best range with a finer grid. + let lo = (best_range * 0.5).max(max_lag / grid.to_double()) + let hi = (best_range * 1.5).min(max_lag) + let fine = 20 + let mut fi = 0 + while fi <= fine { + let candidate_range = lo + (hi - lo) * fi.to_double() / fine.to_double() + if candidate_range <= 0.0 { + fi = fi + 1 + continue + } + let mut sum_x = 0.0 + let mut sum_y = 0.0 + let mut sum_xx = 0.0 + let mut sum_xy = 0.0 + let mut count = 0.0 + for point in empirical { + let shape = voy_variogram_shape(model, point.lag, candidate_range) + let y = point.gamma + if fix_nugget { + sum_x = sum_x + shape + sum_y = sum_y + (y - nugget) + sum_xx = sum_xx + shape * shape + sum_xy = sum_xy + shape * (y - nugget) + } else { + sum_x = sum_x + shape + sum_y = sum_y + y + sum_xx = sum_xx + shape * shape + sum_xy = sum_xy + shape * y + } + count = count + 1.0 + } + let (fit_nugget, fit_partial) = if fix_nugget { + let denom = sum_xx + let partial = if denom > 0.0 { sum_xy / denom } else { 0.0 } + (nugget, partial) + } else { + let denom = count * sum_xx - sum_x * sum_x + if denom.abs() < 1.0e-300 { + (0.0, 0.0) + } else { + let b = (count * sum_xy - sum_x * sum_y) / denom + let a = (sum_y - b * sum_x) / count + (a, b) + } + } + let safe_nugget = if fit_nugget < 0.0 { 0.0 } else { fit_nugget } + let safe_partial = if fit_partial < 0.0 { 0.0 } else { fit_partial } + let mut sse = 0.0 + for point in empirical { + let shape = voy_variogram_shape(model, point.lag, candidate_range) + let predicted = safe_nugget + safe_partial * shape + let residual = point.gamma - predicted + sse = sse + residual * residual + } + if sse < best_sse { + best_sse = sse + best_nugget = safe_nugget + best_sill = safe_partial + best_range = candidate_range + } + fi = fi + 1 + } + VoyagerVariogramModel::{ + model_type: model, + nugget: best_nugget, + sill: best_sill, + range: best_range, + fitted_sse: best_sse, + n_points: empirical.length(), + } +} + +///| +/// Evaluate a fitted variogram model at distance `h`. +pub fn voyager_variogram_predict( + model : VoyagerVariogramModel, + h : Double, +) -> Double { + model.nugget + + model.sill * voy_variogram_shape(model.model_type, h, model.range) +} + +// =========================================================================== +// Spatial Moran correlogram +// =========================================================================== + +///| +pub struct VoyagerCorrelogramPoint { + lag : Double + bin_min : Double + bin_max : Double + morans_i : Double + expectation : Double + npairs : Int +} derive(Debug) + +///| +/// Moran correlogram. Builds binary distance-band weights at each of `n_lags` +/// distance bins and computes Moran's I with its analytical expectation. +pub fn voyager_correlogram( + coords : Array[Array[Double]], + values : Array[Double], + n_lags? : Int = 10, + max_lag? : Double = 0.0, + style? : String = "W", +) -> Array[VoyagerCorrelogramPoint] raise VoyagerError { + if coords.length() < 3 { + voy_fail("Voyager correlogram requires at least 3 spots") + } + if values.length() != coords.length() { + voy_fail("Voyager correlogram values must match coordinates length") + } + if n_lags < 1 { + voy_fail("Voyager correlogram n_lags must be positive") + } + for value in values { + if !voy_is_finite(value) { + voy_fail("Voyager correlogram values must be finite") + } + } + let n = coords.length() + let distances = voy_pairwise_distances(coords) + let mut max_dist = 0.0 + for i in 0.. max_dist { + max_dist = distances[i][j] + } + } + } + if max_dist <= 0.0 { + voy_fail("Voyager correlogram requires non-coincident coordinates") + } + let upper = if max_lag > 0.0 && voy_is_finite(max_lag) { + max_lag + } else { + max_dist / 2.0 + } + let lag_width = upper / n_lags.to_double() + let output : Array[VoyagerCorrelogramPoint] = [] + let mut mean = 0.0 + for value in values { + mean = mean + value + } + mean = mean / n.to_double() + let centered : Array[Double] = [] + let mut ssd = 0.0 + for value in values { + let dev = value - mean + centered.push(dev) + ssd = ssd + dev * dev + } + let expectation = -1.0 / (n.to_double() - 1.0) + for bin in 0.. bin_min && d <= bin_max { + nb.push(j) + w.push(1.0) + npairs = npairs + 1 + } + } + } + neighbors.push(nb) + raw.push(w) + } + // Skip distance bins with no observed pairs — they carry no information. + if npairs == 0 { + continue + } + let styled = voy_apply_style(neighbors, raw, style) + let weights = VoyagerWeights::{ style, n, neighbors, weights: styled } + if ssd <= 0.0 { + output.push(VoyagerCorrelogramPoint::{ + lag: (bin_min + bin_max) / 2.0, + bin_min, + bin_max, + morans_i: 0.0, + expectation, + npairs: npairs / 2, + }) + continue + } + let s0 = voyager_weights_s0(weights) + if s0 <= 0.0 { + output.push(VoyagerCorrelogramPoint::{ + lag: (bin_min + bin_max) / 2.0, + bin_min, + bin_max, + morans_i: 0.0, + expectation, + npairs: npairs / 2, + }) + continue + } + let mut numerator = 0.0 + for i in 0.. SpatialExperiment { + let output = SpatialExperiment::new() + for assay_name in experiment.assay.keys() { + output.assay[assay_name] = voy_copy_double_matrix( + experiment.assay[assay_name], + ) + } + for row in experiment.row_data { + output.row_data.push(voy_copy_string_map(row)) + } + for column in experiment.col_data { + output.col_data.push(voy_copy_string_map(column)) + } + for coordinate in experiment.spatial_coords { + output.spatial_coords.push(coordinate) + } + for image in experiment.images { + output.images.push(image) + } + for key in experiment.metadata.keys() { + output.metadata[key] = experiment.metadata[key] + } + output +} + +///| +fn voy_experiment_gene_names( + experiment : SpatialExperiment, + genes : Int, +) -> Array[String] { + let names : Array[String] = [] + for gene in 0..= experiment.row_data.length() { + names.push(generated) + } else { + let row = experiment.row_data[gene] + let name = match row.get("gene_name") { + Some(value) => + if value.length() > 0 { + value + } else { + match row.get("gene_id") { + Some(identifier) => + if identifier.length() > 0 { + identifier + } else { + generated + } + None => generated + } + } + None => + match row.get("gene_id") { + Some(identifier) => + if identifier.length() > 0 { + identifier + } else { + generated + } + None => generated + } + } + names.push(name) + } + } + names +} + +///| +fn voy_experiment_coordinates( + experiment : SpatialExperiment, + spots : Int, +) -> Array[Array[Double]] raise VoyagerError { + if experiment.spatial_coords.length() != spots { + voy_fail( + "Voyager SpatialExperiment requires one spatial coordinate per spot", + ) + } + let mut use_z = false + if spots > 0 { + let first = experiment.spatial_coords[0].z + for coordinate in experiment.spatial_coords { + if (coordinate.z - first).abs() > 1.0e-14 { + use_z = true + } + } + } + let coordinates : Array[Array[Double]] = [] + for coordinate in experiment.spatial_coords { + if use_z { + coordinates.push([coordinate.x, coordinate.y, coordinate.z]) + } else { + coordinates.push([coordinate.x, coordinate.y]) + } + } + coordinates +} + +///| +/// Run univariate spatial autocorrelation over one or more features of a +/// SpatialExperiment and return a *new* SpatialExperiment with the local_res +/// results written into `col_data` and global results into `row_data`/ +/// `metadata`. The input experiment is left unchanged. +pub fn voyager_run_univariate_sfe( + experiment : SpatialExperiment, + feature_indices : Array[Int], + assay_name? : String = "logcounts", + weights? : VoyagerWeights? = None, + k? : Int = 4, + bandwidth? : Double = 0.0, + stat_method? : String = "moran", + permutations? : Int = 0, + seed? : Int = 20240501, + fdr_threshold? : Double = 0.05, + output_prefix? : String = "voyager", +) -> VoyagerUnivariateSFEOutput raise VoyagerError { + if experiment.col_data.length() == 0 { + voy_fail("Voyager SpatialExperiment col_data must not be empty") + } + let expression : Array[Array[Double]] = match + experiment.assay.get(assay_name) { + Some(value) => value + None => + raise VoyagerError::VoyagerError( + "Voyager SpatialExperiment assay not found: " + assay_name, + ) + } + if expression.length() == 0 { + voy_fail("Voyager SpatialExperiment assay must not be empty") + } + let spots = expression[0].length() + if spots != experiment.col_data.length() { + voy_fail("Voyager SpatialExperiment assay columns must match col_data rows") + } + if spots != experiment.spatial_coords.length() { + voy_fail("Voyager SpatialExperiment coordinates must match col_data rows") + } + if experiment.row_data.length() != 0 && + experiment.row_data.length() != expression.length() { + voy_fail( + "Voyager SpatialExperiment rowData must match assay rows or be empty", + ) + } + let write_row_data = experiment.row_data.length() == expression.length() + if feature_indices.length() == 0 { + voy_fail("Voyager SpatialExperiment feature selection must not be empty") + } + for index in feature_indices { + if index < 0 || index >= expression.length() { + voy_fail( + "Voyager SpatialExperiment feature index out of range: " + + index.to_string(), + ) + } + } + let coords = voy_experiment_coordinates(experiment, spots) + let weights_resolved = match weights { + Some(value) => { + voy_validate_weights(value, "SpatialExperiment") + if value.n != spots { + voy_fail("Voyager SpatialExperiment weights must match spot count") + } + value + } + None => + if bandwidth > 0.0 && voy_is_finite(bandwidth) { + voyager_weights_distance_band(coords, bandwidth) + } else { + voyager_weights_knn(coords, k) + } + } + let copy = voy_copy_spatial_experiment(experiment) + let gene_names = voy_experiment_gene_names(experiment, expression.length()) + let results : Array[VoyagerUnivariateResult] = [] + let normalized_method : String = match stat_method { + "moran" => "moran" + "geary" => "geary" + "getis" => "getis" + "getis_ord" => "getis" + "gi" => "getis" + _ => + raise VoyagerError::VoyagerError( + "Voyager SpatialExperiment stat_method must be moran/geary/getis", + ) + } + for feature_index in feature_indices { + let vector : Array[Double] = [] + for spot in 0.. { + let global = voyager_global_morans_i( + vector, + weights_resolved, + feature=feature_name, + ) + let local_res = voyager_local_morans_i( + vector, + weights_resolved, + permutations~, + seed~, + fdr_threshold~, + feature=feature_name, + ) + if write_row_data { + copy.row_data[feature_index][output_prefix + ".moran.I" + suffix] = global.estimate.to_string() + copy.row_data[feature_index][output_prefix + ".moran.p" + suffix] = global.p_value.to_string() + } + let local_str : Array[String] = [] + let fdr_str : Array[String] = [] + let quad_str : Array[String] = [] + for spot in 0.. { + let global = voyager_global_gearys_c( + vector, + weights_resolved, + feature=feature_name, + ) + let local_res = voyager_local_gearys_c( + vector, + weights_resolved, + permutations~, + seed~, + fdr_threshold~, + feature=feature_name, + ) + if write_row_data { + copy.row_data[feature_index][output_prefix + ".geary.C" + suffix] = global.estimate.to_string() + copy.row_data[feature_index][output_prefix + ".geary.p" + suffix] = global.p_value.to_string() + } + let local_str : Array[String] = [] + let fdr_str : Array[String] = [] + let class_str : Array[String] = [] + for spot in 0.. { + let local_res = voyager_local_getis_ord( + vector, + weights_resolved, + star=true, + fdr_threshold~, + feature=feature_name, + ) + let local_str : Array[String] = [] + let fdr_str : Array[String] = [] + let class_str : Array[String] = [] + let z_str : Array[String] = [] + for spot in 0.. SpatialExperiment { + let se = SpatialExperiment::new() + let _ = se_set_metadata(se, "platform", "Visium") + let _ = se_set_metadata(se, "sample_id", "voyager_example") + // 6x6 grid of spots. + let spots = 36 + let genes = 4 + let gene_names = ["gene_gradient", "gene_hotspot", "gene_noise", "gene_anti"] + for gene in 0.. Map[String, String] { + let column : Map[String, String] = Map([], capacity=2) + column["spot_id"] = spot_id + column["tissue"] = tissue + column +} diff --git a/src/vsn.mbt b/src/vsn.mbt index dff4f045..e798f743 100644 --- a/src/vsn.mbt +++ b/src/vsn.mbt @@ -9,8 +9,11 @@ // ---- helper --------------------------------------------------------------- -fn vsn_is_na(x : Double) -> Bool { x.is_nan() } +fn vsn_is_na(x : Double) -> Bool { + x.is_nan() +} +///| fn vsn_copy(mat : Array[Array[Double]]) -> Array[Array[Double]] { let n = mat.length() let out : Array[Array[Double]] = Array::new() @@ -30,10 +33,8 @@ fn vsn_copy(mat : Array[Array[Double]]) -> Array[Array[Double]] { out } -fn vsn_col_mean_sd( - mat : Array[Array[Double]], - j : Int, -) -> (Double, Double) { +///| +fn vsn_col_mean_sd(mat : Array[Array[Double]], j : Int) -> (Double, Double) { let mut s = 0.0 let mut s2 = 0.0 let mut c = 0 @@ -48,7 +49,9 @@ fn vsn_col_mean_sd( } i = i + 1 } - if c < 2 { return (0.0, 0.0) } + if c < 2 { + return (0.0, 0.0) + } let mu = s / c.to_double() let myvar = (s2 - s * s / c.to_double()) / (c - 1).to_double() let sd = if myvar > 0.0 { myvar.sqrt() } else { 0.0 } @@ -57,16 +60,19 @@ fn vsn_col_mean_sd( // ---- parameters & result -------------------------------------------------- +///| pub struct VSNColParam { a : Double b : Double } +///| pub struct VSNResult { params : Array[VSNColParam] reference_mean_sd : Array[(Double, Double)] } +///| pub struct VSNControl { pub n_bins : Int pub min_bin_count : Int @@ -74,30 +80,37 @@ pub struct VSNControl { pub lts_frac : Double } +///| pub fn VSNControl::new() -> VSNControl { - VSNControl::{ - n_bins: 20, - min_bin_count: 5, - max_iter: 20, - lts_frac: 0.9, - } + VSNControl::{ n_bins: 20, min_bin_count: 5, max_iter: 20, lts_frac: 0.9 } } // ---- core transform ------------------------------------------------------- +///| pub fn glog(x : Double, a : Double, b : Double) -> Double { let v = (a + b * x) / 2.0 let inner = v + (v * v + 1.0).sqrt() - if inner <= 0.0 { 0.0 } else { @math.ln(inner) } + if inner <= 0.0 { + 0.0 + } else { + @math.ln(inner) + } } +///| pub fn glog_inv(y : Double, a : Double, b : Double) -> Double { - let s = ((@math.exp(y) - @math.exp(-y)) / 2.0) - if b == 0.0 { 0.0 } else { (2.0 * s - a) / b } + let s = (@math.exp(y) - @math.exp(-y)) / 2.0 + if b == 0.0 { + 0.0 + } else { + (2.0 * s - a) / b + } } // ---- per-column parameter fitting ---------------------------------------- +///| fn vsn_lm( x : Array[Double], y : Array[Double], @@ -105,7 +118,9 @@ fn vsn_lm( max_iter : Int, ) -> (Double, Double) { let n = x.length() - if n == 0 { return (0.0, 1.0) } + if n == 0 { + return (0.0, 1.0) + } let mut sx = 0.0 let mut sy = 0.0 let mut sxx = 0.0 @@ -118,7 +133,7 @@ fn vsn_lm( sxy = sxy + x[i] * y[i] i = i + 1 } - let denom = (n.to_double() * sxx - sx * sx) + let denom = n.to_double() * sxx - sx * sx let mut b = if denom == 0.0 { 1.0 } else { @@ -135,13 +150,23 @@ fn vsn_lm( i2 = i2 + 1 } resid.sort_by(fn(p : (Int, Double), q : (Int, Double)) -> Int { - if p.1 < q.1 { -1 } else if p.1 > q.1 { 1 } else { 0 } + if p.1 < q.1 { + -1 + } else if p.1 > q.1 { + 1 + } else { + 0 + } }) let keep = if n < 2 { n } else { let k = (lts_frac * n.to_double()).to_int() - if k < 2 { 2 } else { k } + if k < 2 { + 2 + } else { + k + } } let mut sx2 = 0.0 let mut sy2 = 0.0 @@ -158,18 +183,21 @@ fn vsn_lm( t = t + 1 } let kd = k2.to_double() - let d2 = (kd * sxx2 - sx2 * sx2) + let d2 = kd * sxx2 - sx2 * sx2 let nb = if d2 == 0.0 { b } else { (kd * sxy2 - sx2 * sy2) / d2 } let na = if kd == 0.0 { a } else { (sy2 - nb * sx2) / kd } let da = (na - a).abs() + (nb - b).abs() a = na b = nb - if da < 0.00000001 { break } + if da < 0.00000001 { + break + } _it = _it + 1 } (a, b) } +///| fn vsn_fit_col( mat : Array[Array[Double]], j : Int, @@ -216,13 +244,23 @@ fn vsn_fit_col( ii = ii + 1 } order.sort_by(fn(p : (Double, Double), q : (Double, Double)) -> Int { - if p.0 < q.0 { -1 } else if p.0 > q.0 { 1 } else { 0 } + if p.0 < q.0 { + -1 + } else if p.0 > q.0 { + 1 + } else { + 0 + } }) let bin_x : Array[Double] = Array::new() let bin_y : Array[Double] = Array::new() if pts > 0 { let bin_size = if pts / n_bins < ctrl.min_bin_count { - if ctrl.min_bin_count < 1 { 1 } else { ctrl.min_bin_count } + if ctrl.min_bin_count < 1 { + 1 + } else { + ctrl.min_bin_count + } } else { pts / n_bins } @@ -245,9 +283,11 @@ fn vsn_fit_col( } if kk > 0 { let kd = kk.to_double() - let new_len = (prev_cnt_d + kd) - bin_x[last_idx] = (bin_x[last_idx] * prev_cnt_d + mx / kd * kd) / new_len - bin_y[last_idx] = (bin_y[last_idx] * prev_cnt_d + my / kd * kd) / new_len + let new_len = prev_cnt_d + kd + bin_x[last_idx] = (bin_x[last_idx] * prev_cnt_d + mx / kd * kd) / + new_len + bin_y[last_idx] = (bin_y[last_idx] * prev_cnt_d + my / kd * kd) / + new_len } start = end continue @@ -274,12 +314,13 @@ fn vsn_fit_col( ref_ms.push((bin_x[t], bin_y[t])) t = t + 1 } - (VSNColParam::{ a: a, b: bb, }, ref_ms) + (VSNColParam::{ a, b: bb }, ref_ms) } +///| fn vsn_fit(mat : Array[Array[Double]], ctrl : VSNControl) -> VSNResult { if mat.length() == 0 { - return VSNResult::{ params: [], reference_mean_sd: [], } + return VSNResult::{ params: [], reference_mean_sd: [] } } let cols = mat[0].length() let params : Array[VSNColParam] = Array::new() @@ -288,15 +329,15 @@ fn vsn_fit(mat : Array[Array[Double]], ctrl : VSNControl) -> VSNResult { while j < cols { let (p, rms) = vsn_fit_col(mat, j, ctrl) params.push(p) - if j == 0 { ref_out = rms } + if j == 0 { + ref_out = rms + } j = j + 1 } - VSNResult::{ - params: params, - reference_mean_sd: ref_out, - } + VSNResult::{ params, reference_mean_sd: ref_out } } +///| fn vsn_transform( mat : Array[Array[Double]], fit : VSNResult, @@ -320,11 +361,13 @@ fn vsn_transform( out } +///| pub fn vsn2(mat : Array[Array[Double]]) -> Array[Array[Double]] { let fit = vsn_fit(mat, VSNControl::new()) vsn_transform(mat, fit) } +///| pub fn vsn2_with_control( mat : Array[Array[Double]], ctrl : VSNControl, @@ -333,24 +376,29 @@ pub fn vsn2_with_control( vsn_transform(mat, fit) } +///| pub fn vsn_fit_and_report(mat : Array[Array[Double]]) -> VSNResult { vsn_fit(mat, VSNControl::new()) } // ---- ASCII Mean-SD plot --------------------------------------------------- +///| pub struct MeanSDBin { mean_x : Double sd_y : Double count : Int } +///| pub fn mean_sd_bins( mat : Array[Array[Double]], n_bins : Int, ) -> Array[MeanSDBin] { let n = mat.length() - if n == 0 { return Array::new() } + if n == 0 { + return Array::new() + } let cols = mat[0].length() let pts : Array[(Double, Double)] = Array::new() let mut i = 0 @@ -367,12 +415,20 @@ pub fn mean_sd_bins( i = i + 1 } pts.sort_by(fn(p : (Double, Double), q : (Double, Double)) -> Int { - if p.0 < q.0 { -1 } else if p.0 > q.0 { 1 } else { 0 } + if p.0 < q.0 { + -1 + } else if p.0 > q.0 { + 1 + } else { + 0 + } }) let nb = if n_bins < 1 { 1 } else { n_bins } let total = pts.length() let out : Array[MeanSDBin] = Array::new() - if total == 0 { return out } + if total == 0 { + return out + } let step = total / nb let mut start = 0 while start < total { @@ -387,39 +443,43 @@ pub fn mean_sd_bins( t = t + 1 } let cnt_d = cnt.to_double() - out.push(MeanSDBin::{ - mean_x: sx / cnt_d, - sd_y: sy / cnt_d, - count: cnt, - }) + out.push(MeanSDBin::{ mean_x: sx / cnt_d, sd_y: sy / cnt_d, count: cnt }) start = end } out } -pub fn mean_sd_ascii( - mat : Array[Array[Double]], - n_bins? : Int = 40, -) -> String { +///| +pub fn mean_sd_ascii(mat : Array[Array[Double]], n_bins? : Int = 40) -> String { let bins = mean_sd_bins(mat, n_bins) let width = 40 let height = 10 - if bins.length() == 0 { return "(empty mean-SD plot)".to_string() } + if bins.length() == 0 { + return "(empty mean-SD plot)".to_string() + } let mut xmin = bins[0].mean_x let mut xmax = bins[0].mean_x let mut ymin = bins[0].sd_y let mut ymax = bins[0].sd_y for b in bins { - if b.mean_x < xmin { xmin = b.mean_x } - if b.mean_x > xmax { xmax = b.mean_x } - if b.sd_y < ymin { ymin = b.sd_y } - if b.sd_y > ymax { ymax = b.sd_y } + if b.mean_x < xmin { + xmin = b.mean_x + } + if b.mean_x > xmax { + xmax = b.mean_x + } + if b.sd_y < ymin { + ymin = b.sd_y + } + if b.sd_y > ymax { + ymax = b.sd_y + } } let xr = if xmax - xmin == 0.0 { 1.0 } else { xmax - xmin } let yr = if ymax - ymin == 0.0 { 1.0 } else { ymax - ymin } let grid : Array[Array[Int]] = Array::make( height, - Array::make(width, ' '.to_int()) + Array::make(width, ' '.to_int()), ) let k = bins.length() let mut idx = 0 @@ -427,30 +487,39 @@ pub fn mean_sd_ascii( let b = bins[idx] let xi = ((b.mean_x - xmin) / xr * (width - 1).to_double()).to_int() let yi = ((b.sd_y - ymin) / yr * (height - 1).to_double()).to_int() - let xii = if xi < 0 { 0 } else { if xi >= width { width - 1 } else { xi } } - let yii = if yi < 0 { 0 } else { if yi >= height { height - 1 } else { yi } } + let xii = if xi < 0 { 0 } else if xi >= width { width - 1 } else { xi } + let yii = if yi < 0 { 0 } else if yi >= height { height - 1 } else { yi } let row_idx = height - 1 - yii let c = grid[row_idx][xii] let nc = if c == ' '.to_int() { '*'.to_int() + } else if c == '*'.to_int() { + '+'.to_int() } else { - if c == '*'.to_int() { '+'.to_int() } else { '#'.to_int() } + '#'.to_int() } grid[row_idx][xii] = nc idx = idx + 1 } let buf = StringBuilder::new() - buf.write_string("mean-SD plot (mean=[\{xmin},\{xmax}] sd=[\{ymin},\{ymax}])\n") + buf.write_string( + "mean-SD plot (mean=[\{xmin},\{xmax}] sd=[\{ymin},\{ymax}])\n", + ) let mut r = 0 while r < height { let row = grid[r] let mut c = 0 while c < width { let ch = row[c] - if ch == ' '.to_int() { buf.write_char(' ') } - else if ch == '*'.to_int() { buf.write_char('*') } - else if ch == '+'.to_int() { buf.write_char('+') } - else { buf.write_char('#') } + if ch == ' '.to_int() { + buf.write_char(' ') + } else if ch == '*'.to_int() { + buf.write_char('*') + } else if ch == '+'.to_int() { + buf.write_char('+') + } else { + buf.write_char('#') + } c = c + 1 } buf.write_char('\n') @@ -459,6 +528,7 @@ pub fn mean_sd_ascii( buf.to_string() } +///| pub fn summarize_vsn_fit(fit : VSNResult) -> String { let buf = StringBuilder::new() let n = fit.params.length() @@ -469,16 +539,21 @@ pub fn summarize_vsn_fit(fit : VSNResult) -> String { buf.write_string(" col \{i}: a=\{p.a} b=\{p.b}\n") i = i + 1 } - if n > 5 { buf.write_string(" ... (\{n - 5} more)\n") } + if n > 5 { + buf.write_string(" ... (\{n - 5} more)\n") + } buf.to_string() } +///| pub fn vsn_denoise( mat : Array[Array[Double]], frac_of_median_var? : Double = 0.05, ) -> Array[Array[Double]] { let out = vsn_copy(mat) - if out.length() == 0 { return out } + if out.length() == 0 { + return out + } let cols = out[0].length() let vars : Array[Double] = Array::new() let mut j = 0 @@ -488,9 +563,17 @@ pub fn vsn_denoise( j = j + 1 } let sorted_vars : Array[Double] = Array::new() - for v in vars { sorted_vars.push(v) } + for v in vars { + sorted_vars.push(v) + } sorted_vars.sort_by(fn(a : Double, b : Double) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) let med = if sorted_vars.length() == 0 { 0.0 @@ -503,7 +586,9 @@ pub fn vsn_denoise( while i < n { let mut jj = 0 while jj < cols { - if vars[jj] < threshold { out[i][jj] = 0.0 } + if vars[jj] < threshold { + out[i][jj] = 0.0 + } jj = jj + 1 } i = i + 1 diff --git a/src/wise.mbt b/src/wise.mbt index 85b8fa8e..06143640 100644 --- a/src/wise.mbt +++ b/src/wise.mbt @@ -78,23 +78,15 @@ pub struct WiseExon { ///| /// Construct a WiseExon. pub fn WiseExon::new( - start~ : Int = 0, - end~ : Int = 0, - phase~ : Int = 0, - end_phase~ : Int = 0, - score~ : Double = 0.0, - protein_start~ : Int = 0, - protein_end~ : Int = 0, + start? : Int = 0, + end? : Int = 0, + phase? : Int = 0, + end_phase? : Int = 0, + score? : Double = 0.0, + protein_start? : Int = 0, + protein_end? : Int = 0, ) -> WiseExon { - WiseExon::{ - start, - end, - phase, - end_phase, - score, - protein_start, - protein_end, - } + WiseExon::{ start, end, phase, end_phase, score, protein_start, protein_end } } ///| @@ -116,19 +108,13 @@ pub struct WiseIntron { ///| /// Construct a WiseIntron. pub fn WiseIntron::new( - start~ : Int = 0, - end~ : Int = 0, - donor_score~ : Double = 0.0, - acceptor_score~ : Double = 0.0, + start? : Int = 0, + end? : Int = 0, + donor_score? : Double = 0.0, + acceptor_score? : Double = 0.0, ) -> WiseIntron { let len = if end >= start { end - start + 1 } else { 0 } - WiseIntron::{ - start, - end, - donor_score, - acceptor_score, - length: len, - } + WiseIntron::{ start, end, donor_score, acceptor_score, length: len } } ///| @@ -146,9 +132,9 @@ pub struct WiseAlignmentColumn { pub fn WiseAlignmentColumn::new( protein_char~ : Char, gene_codon~ : String, - match_type~ : String = " ", - gene_position~ : Int = 0, - protein_position~ : Int = 0, + match_type? : String = " ", + gene_position? : Int = 0, + protein_position? : Int = 0, ) -> WiseAlignmentColumn { WiseAlignmentColumn::{ protein_char, @@ -228,7 +214,9 @@ pub fn WiseResult::get_introns(self : WiseResult) -> Array[WiseIntron] { ///| /// Get the alignment. -pub fn WiseResult::get_alignment(self : WiseResult) -> Array[WiseAlignmentColumn] { +pub fn WiseResult::get_alignment( + self : WiseResult, +) -> Array[WiseAlignmentColumn] { self.alignment } @@ -304,14 +292,18 @@ pub fn wise_parse(content : String) -> WiseResult { if trimmed.starts_with("Score:") { let parts = trimmed.split(":").to_array() if parts.length() >= 2 { - result.score = parse_double(parts[1].to_string().trim().to_string()).unwrap_or(0.0) + result.score = parse_double(parts[1].to_string().trim().to_string()).unwrap_or( + 0.0, + ) } } // Parse bits score: "Bits: 45.67" if trimmed.starts_with("Bits:") { let parts = trimmed.split(":").to_array() if parts.length() >= 2 { - result.bits_score = parse_double(parts[1].to_string().trim().to_string()).unwrap_or(0.0) + result.bits_score = parse_double( + parts[1].to_string().trim().to_string(), + ).unwrap_or(0.0) } } // Parse protein ID: "Protein: P12345" @@ -347,7 +339,13 @@ pub fn wise_parse(content : String) -> WiseResult { } } // Parse parameter lines: "Parameter: value" - if trimmed.contains(":") && !trimmed.starts_with("Exon") && !trimmed.starts_with("Intron") && !trimmed.starts_with("Score") && !trimmed.starts_with("Bits") && !trimmed.starts_with("Protein") && !trimmed.starts_with("Gene") { + if trimmed.contains(":") && + !trimmed.starts_with("Exon") && + !trimmed.starts_with("Intron") && + !trimmed.starts_with("Score") && + !trimmed.starts_with("Bits") && + !trimmed.starts_with("Protein") && + !trimmed.starts_with("Gene") { let parts = trimmed.split(":").to_array() if parts.length() >= 2 { let key = parts[0].to_string().trim().to_string() @@ -401,21 +399,18 @@ fn wise_parse_exon_line(line : String) -> WiseExon? { let dash = protein_part.find("-") match dash { Some(dp) => { - protein_start = wise_extract_first_number(protein_part[0:dp].to_string()) - protein_end = wise_extract_first_number(protein_part[dp + 1:].to_string()) + protein_start = wise_extract_first_number( + protein_part[0:dp].to_string(), + ) + protein_end = wise_extract_first_number( + protein_part[dp + 1:].to_string(), + ) } None => () } } Some( - WiseExon::new( - start=start, - end=end, - phase=phase, - score=score, - protein_start=protein_start, - protein_end=protein_end, - ), + WiseExon::new(start~, end~, phase~, score~, protein_start~, protein_end~), ) } @@ -446,12 +441,7 @@ fn wise_parse_intron_line(line : String) -> WiseIntron? { acceptor = wise_extract_first_double(acc_str) } Some( - WiseIntron::new( - start=start, - end=end, - donor_score=donor, - acceptor_score=acceptor, - ), + WiseIntron::new(start~, end~, donor_score=donor, acceptor_score=acceptor), ) } @@ -465,11 +455,9 @@ fn wise_extract_last_number(s : String) -> Int { let c = chars[i] if c >= '0' && c <= '9' { current = current + c.to_string() - } else { - if current.length() > 0 { - result = parse_int(current) - current = "" - } + } else if current.length() > 0 { + result = parse_int(current) + current = "" } } if current.length() > 0 { @@ -487,10 +475,8 @@ fn wise_extract_first_number(s : String) -> Int { let c = chars[i] if c >= '0' && c <= '9' { current = current + c.to_string() - } else { - if current.length() > 0 { - return parse_int(current) - } + } else if current.length() > 0 { + return parse_int(current) } } if current.length() > 0 { @@ -605,11 +591,33 @@ pub fn wise_gene_structure(result : WiseResult) -> String { let sb = StringBuilder::new() for i in 0.. GenomeWiseSegment { GenomeWiseSegment::{ segment_id, @@ -732,11 +740,7 @@ pub struct GenomeWiseResult { ///| /// Construct an empty GenomeWiseResult. pub fn GenomeWiseResult::new() -> GenomeWiseResult { - GenomeWiseResult::{ - gene_id: "", - total_score: 0.0, - segments: [], - } + GenomeWiseResult::{ gene_id: "", total_score: 0.0, segments: [] } } ///| @@ -750,7 +754,9 @@ pub fn GenomeWiseResult::add_segment( ///| /// Get all segments. -pub fn GenomeWiseResult::get_segments(self : GenomeWiseResult) -> Array[GenomeWiseSegment] { +pub fn GenomeWiseResult::get_segments( + self : GenomeWiseResult, +) -> Array[GenomeWiseSegment] { self.segments } @@ -787,7 +793,13 @@ pub fn wise_summary(result : WiseResult) -> String { sb.write_string(" Bits: " + result.bits_score.to_string() + "\n") sb.write_string(" Exons: " + result.get_num_exons().to_string() + "\n") sb.write_string(" Introns: " + result.get_num_introns().to_string() + "\n") - sb.write_string(" Total exon length: " + result.get_total_exon_length().to_string() + " nt\n") - sb.write_string(" Parameters: " + result.parameters.size().to_string() + "\n") + sb.write_string( + " Total exon length: " + + result.get_total_exon_length().to_string() + + " nt\n", + ) + sb.write_string( + " Parameters: " + result.parameters.size().to_string() + "\n", + ) sb.to_string() } diff --git a/src/xcell.mbt b/src/xcell.mbt index e288524c..3eb54e96 100644 --- a/src/xcell.mbt +++ b/src/xcell.mbt @@ -22,7 +22,7 @@ /// A cell type gene signature used for xCell scoring. pub struct XcellSignature { cell_type : String - category : String // "immune", "stromal", "other" + category : String // "immune", "stromal", "other" genes : Array[String] } @@ -58,7 +58,7 @@ pub fn XcellSignature::genes(self : XcellSignature) -> Array[String] { /// Parameters for xCell scoring. pub struct XcellParams { min_gene_overlap : Int - alpha : Double // ssGSEA exponent + alpha : Double // ssGSEA exponent scale_scores : Bool do_spillover : Bool verbose : Bool @@ -79,12 +79,12 @@ pub fn XcellParams::new() -> XcellParams { ///| /// Result from xCell analysis. pub struct XcellResult { - scores : Array[Array[Double]] // rows=cell_types, cols=samples + scores : Array[Array[Double]] // rows=cell_types, cols=samples cell_types : Array[String] categories : Array[String] sample_names : Array[String] - immune_scores : Array[Double] // per sample aggregate immune score - stromal_scores : Array[Double] // per sample aggregate stromal score + immune_scores : Array[Double] // per sample aggregate immune score + stromal_scores : Array[Double] // per sample aggregate stromal score microenvironment_scores : Array[Double] // immune + stromal params : XcellParams } @@ -120,7 +120,11 @@ pub fn XcellResult::new( ///| /// Absolute value. fn xc_abs(x : Double) -> Double { - if x < 0.0 { -x } else { x } + if x < 0.0 { + -x + } else { + x + } } ///| @@ -165,7 +169,7 @@ pub fn xcell_ssgsea_single( expression : Array[Double], gene_names : Array[String], set_genes : Array[String], - alpha~ : Double = 0.25, + alpha? : Double = 0.25, ) -> Double { let n = expression.length() if n == 0 || n != gene_names.length() || set_genes.length() == 0 { @@ -184,18 +188,20 @@ pub fn xcell_ssgsea_single( } } let n_set = set_indices.length() - if n_set < 3 { return 0.0 } + if n_set < 3 { + return 0.0 + } let n_total = n // Sort expression descending (rank high to low) let (_sorted_exp, order_indices) = xc_sort_with_indices( - expression.map(fn(v) { -v }) // neg for descending + expression.map(fn(v) { -v }), // neg for descending ) // Walk down ranked list, compute running sum // weight_i = i^alpha, for i in 1..N // weight_G = sum of weights of set members - let pw_over = (n_set).to_double() / n_total.to_double() + let pw_over = n_set.to_double() / n_total.to_double() let mut sum_weight_set = 0.0 for k in 1..<(n + 1) { sum_weight_set = sum_weight_set + k.to_double().pow(alpha) * pw_over @@ -210,7 +216,7 @@ pub fn xcell_ssgsea_single( let mut cumulate_set = 0.0 let mut cumulate_other = 0.0 for rank in 1..<(n + 1) { - let gene_idx = order_indices[rank - 1] // 1-based rank -> 0-based index + let gene_idx = order_indices[rank - 1] // 1-based rank -> 0-based index // Check if gene is in set let mut in_set = false for si in 0.. 0.0 { cumulate_set / n_set_d } else { 0.0 } - let frac_other = if (n_total_d - n_set_d) > 0.0 { + let frac_other = if n_total_d - n_set_d > 0.0 { cumulate_other / (n_total_d - n_set_d) - } else { 0.0 } + } else { + 0.0 + } let current = frac_set - frac_other - if current > max_score { max_score = current } - if current < min_score { min_score = current } + if current > max_score { + max_score = current + } + if current < min_score { + min_score = current + } } // ssGSEA score is max + min (i.e., the difference between max deviation up and down) // Actually typical ssGSEA returns max-min normalized. Return max - |min|. @@ -258,140 +270,203 @@ pub fn xcell_ssgsea_single( pub fn xcell_default_signatures() -> Array[XcellSignature] { [ // ====== Lymphoid lineage ====== - XcellSignature::new("B-cells", "immune", - ["CD19", "MS4A1", "CD79A", "CD79B", "BLK", "BANK1", "PAX5", "IGHM"]), - XcellSignature::new("B-cells naive", "immune", - ["MS4A1", "CD19", "TCF3", "SELL", "IGHD", "CD22", "CXCR5", "FCER2"]), - XcellSignature::new("B-cells memory", "immune", - ["CD27", "MS4A1", "CD19", "AIM2", "BCL2", "KCNN4", "CD80", "PRDM1"]), - XcellSignature::new("Plasma cells", "immune", - ["SDC1", "CD138", "MZB1", "XBP1", "PRDM1", "IRF4", "SLAMF7", "TNFRSF17"]), - XcellSignature::new("T-cells CD4+", "immune", - ["CD4", "CD3D", "CD3E", "TRAC", "IL7R", "LTB", "MAL", "LEF1"]), - XcellSignature::new("T-cells CD4+ naive", "immune", - ["CD4", "SELL", "CCR7", "LEF1", "TCF7", "IL7R", "NELL2", "FHIT"]), - XcellSignature::new("T-cells CD4+ central memory", "immune", - ["CD4", "SELL", "CCR7", "CD27", "CD28", "IL2RB", "S100A4", "ITGAL"]), - XcellSignature::new("T-cells CD4+ effector memory", "immune", - ["CD4", "CD45RO", "CCR5", "CXCR3", "IL2RB", "IL7R", "ITGAE", "KLRB1"]), - XcellSignature::new("T-cells CD4+ Th1", "immune", - ["CD4", "TBX21", "IFNG", "CXCR3", "STAT1", "IL12RB2", "IL18R1", "HAVCR2"]), - XcellSignature::new("T-cells CD4+ Th2", "immune", - ["CD4", "GATA3", "IL4", "IL5", "IL13", "CCR4", "IL1RL1", "PTGDR2"]), - XcellSignature::new("T-cells CD4+ Th17", "immune", - ["CD4", "RORC", "IL17A", "IL17F", "CCR6", "IL22", "IL23R", "KLRB1"]), - XcellSignature::new("Tregs", "immune", - ["FOXP3", "IL2RA", "CD25", "CTLA4", "IKZF2", "IL10", "TIGIT", "TNFRSF18"]), - XcellSignature::new("T-cells CD8+", "immune", - ["CD8A", "CD8B", "CD3D", "CD3E", "TRAC", "GZMA", "GZMK", "NKG7"]), - XcellSignature::new("T-cells CD8+ naive", "immune", - ["CD8A", "SELL", "CCR7", "LEF1", "TCF7", "IL7R", "NELL2", "LTB"]), - XcellSignature::new("T-cells CD8+ central memory", "immune", - ["CD8A", "SELL", "CCR7", "CD27", "CD28", "GZMK", "IL2RB", "LTB"]), - XcellSignature::new("T-cells CD8+ effector memory", "immune", - ["CD8A", "CD45RO", "GZMA", "GZMB", "PRF1", "NKG7", "CXCR3", "CCL5"]), - XcellSignature::new("CD8+ T-cells cytotoxic", "immune", - ["CD8A", "GZMA", "GZMB", "PRF1", "NKG7", "GNLY", "KLRD1", "KLRK1"]), - XcellSignature::new("NKT cells", "immune", - ["KLRB1", "NKG7", "CD3D", "TRAV10", "TRAJ18", "GZMB", "PRF1", "ZBTB16"]), - XcellSignature::new("Tgd cells", "immune", - ["TRGV9", "TRDV2", "TRDC", "CD3D", "NKG7", "KLRB1", "RORC", "IL17A"]), + XcellSignature::new("B-cells", "immune", [ + "CD19", "MS4A1", "CD79A", "CD79B", "BLK", "BANK1", "PAX5", "IGHM", + ]), + XcellSignature::new("B-cells naive", "immune", [ + "MS4A1", "CD19", "TCF3", "SELL", "IGHD", "CD22", "CXCR5", "FCER2", + ]), + XcellSignature::new("B-cells memory", "immune", [ + "CD27", "MS4A1", "CD19", "AIM2", "BCL2", "KCNN4", "CD80", "PRDM1", + ]), + XcellSignature::new("Plasma cells", "immune", [ + "SDC1", "CD138", "MZB1", "XBP1", "PRDM1", "IRF4", "SLAMF7", "TNFRSF17", + ]), + XcellSignature::new("T-cells CD4+", "immune", [ + "CD4", "CD3D", "CD3E", "TRAC", "IL7R", "LTB", "MAL", "LEF1", + ]), + XcellSignature::new("T-cells CD4+ naive", "immune", [ + "CD4", "SELL", "CCR7", "LEF1", "TCF7", "IL7R", "NELL2", "FHIT", + ]), + XcellSignature::new("T-cells CD4+ central memory", "immune", [ + "CD4", "SELL", "CCR7", "CD27", "CD28", "IL2RB", "S100A4", "ITGAL", + ]), + XcellSignature::new("T-cells CD4+ effector memory", "immune", [ + "CD4", "CD45RO", "CCR5", "CXCR3", "IL2RB", "IL7R", "ITGAE", "KLRB1", + ]), + XcellSignature::new("T-cells CD4+ Th1", "immune", [ + "CD4", "TBX21", "IFNG", "CXCR3", "STAT1", "IL12RB2", "IL18R1", "HAVCR2", + ]), + XcellSignature::new("T-cells CD4+ Th2", "immune", [ + "CD4", "GATA3", "IL4", "IL5", "IL13", "CCR4", "IL1RL1", "PTGDR2", + ]), + XcellSignature::new("T-cells CD4+ Th17", "immune", [ + "CD4", "RORC", "IL17A", "IL17F", "CCR6", "IL22", "IL23R", "KLRB1", + ]), + XcellSignature::new("Tregs", "immune", [ + "FOXP3", "IL2RA", "CD25", "CTLA4", "IKZF2", "IL10", "TIGIT", "TNFRSF18", + ]), + XcellSignature::new("T-cells CD8+", "immune", [ + "CD8A", "CD8B", "CD3D", "CD3E", "TRAC", "GZMA", "GZMK", "NKG7", + ]), + XcellSignature::new("T-cells CD8+ naive", "immune", [ + "CD8A", "SELL", "CCR7", "LEF1", "TCF7", "IL7R", "NELL2", "LTB", + ]), + XcellSignature::new("T-cells CD8+ central memory", "immune", [ + "CD8A", "SELL", "CCR7", "CD27", "CD28", "GZMK", "IL2RB", "LTB", + ]), + XcellSignature::new("T-cells CD8+ effector memory", "immune", [ + "CD8A", "CD45RO", "GZMA", "GZMB", "PRF1", "NKG7", "CXCR3", "CCL5", + ]), + XcellSignature::new("CD8+ T-cells cytotoxic", "immune", [ + "CD8A", "GZMA", "GZMB", "PRF1", "NKG7", "GNLY", "KLRD1", "KLRK1", + ]), + XcellSignature::new("NKT cells", "immune", [ + "KLRB1", "NKG7", "CD3D", "TRAV10", "TRAJ18", "GZMB", "PRF1", "ZBTB16", + ]), + XcellSignature::new("Tgd cells", "immune", [ + "TRGV9", "TRDV2", "TRDC", "CD3D", "NKG7", "KLRB1", "RORC", "IL17A", + ]), // ====== Myeloid lineage ====== - XcellSignature::new("Monocytes", "immune", - ["CD14", "CD68", "CSF1R", "S100A8", "S100A9", "FCGR3A", "LYZ", "VNN2"]), - XcellSignature::new("Monocytes CD14+", "immune", - ["CD14", "LYZ", "CSF1R", "S100A12", "S100A8", "S100A9", "FCN1", "VCAN"]), - XcellSignature::new("Monocytes CD16+", "immune", - ["FCGR3A", "CD16", "CD14", "MS4A4A", "CX3CR1", "CSF1R", "LYN", "ITGAM"]), - XcellSignature::new("Macrophages", "immune", - ["CD68", "CD163", "MSR1", "MRC1", "CSF1R", "MARCO", "CD84", "STAB1"]), - XcellSignature::new("Macrophages M0", "immune", - ["CD68", "CSF1R", "CD14", "FCGR1A", "MSR1", "LYZ", "S100A8", "S100A9"]), - XcellSignature::new("Macrophages M1", "immune", - ["NOS2", "CD80", "CD86", "IL1B", "TNF", "CXCL9", "CXCL10", "HLA-DRA"]), - XcellSignature::new("Macrophages M2", "immune", - ["CD163", "MRC1", "CD209", "MSR1", "IL10", "TGFB1", "VEGFA", "ARG1"]), - XcellSignature::new("Dendritic cells", "immune", - ["ITGAX", "CD1C", "CLEC10A", "FCER1A", "CD80", "CD86", "HLA-DRA", "CCR7"]), - XcellSignature::new("DCs immature", "immune", - ["ITGAX", "CD1C", "MRC1", "FCER1A", "CLEC10A", "CCR5", "TLR7", "TLR9"]), - XcellSignature::new("DCs plasmacytoid", "immune", - ["IL3RA", "CLEC4C", "LILRA4", "IRF7", "IRF8", "TLR7", "TLR9", "CXCR3"]), - XcellSignature::new("DCs activated", "immune", - ["ITGAX", "CD80", "CD86", "CD40", "CCR7", "HLA-DRA", "IL12A", "IL12B"]), - XcellSignature::new("Mast cells", "immune", - ["KIT", "CD117", "TPSAB1", "CPA3", "MS4A2", "HDC", "TPSB2", "GATA2"]), - XcellSignature::new("Mast cells resting", "immune", - ["KIT", "TPSAB1", "CPA3", "MS4A2", "GATA2", "HRH4", "CMA1", "TPSG1"]), - XcellSignature::new("Mast cells activated", "immune", - ["KIT", "TPSAB1", "MS4A2", "IL1B", "TNF", "IL6", "CCL3", "CCL4"]), - XcellSignature::new("Eosinophils", "immune", - ["SIGLEC8", "IL5RA", "CCR3", "PRG2", "PRG3", "EPX", "RNASE2", "RNASE3"]), - XcellSignature::new("Neutrophils", "immune", - ["FCGR3B", "CD66b", "CXCR2", "S100A8", "S100A9", "MPO", "ELANE", "CEACAM8"]), - XcellSignature::new("Basophils", "immune", - ["MS4A2", "CCR3", "IL3RA", "HDC", "TPSAB1", "IL4", "IL13", "FCER1A"]), + XcellSignature::new("Monocytes", "immune", [ + "CD14", "CD68", "CSF1R", "S100A8", "S100A9", "FCGR3A", "LYZ", "VNN2", + ]), + XcellSignature::new("Monocytes CD14+", "immune", [ + "CD14", "LYZ", "CSF1R", "S100A12", "S100A8", "S100A9", "FCN1", "VCAN", + ]), + XcellSignature::new("Monocytes CD16+", "immune", [ + "FCGR3A", "CD16", "CD14", "MS4A4A", "CX3CR1", "CSF1R", "LYN", "ITGAM", + ]), + XcellSignature::new("Macrophages", "immune", [ + "CD68", "CD163", "MSR1", "MRC1", "CSF1R", "MARCO", "CD84", "STAB1", + ]), + XcellSignature::new("Macrophages M0", "immune", [ + "CD68", "CSF1R", "CD14", "FCGR1A", "MSR1", "LYZ", "S100A8", "S100A9", + ]), + XcellSignature::new("Macrophages M1", "immune", [ + "NOS2", "CD80", "CD86", "IL1B", "TNF", "CXCL9", "CXCL10", "HLA-DRA", + ]), + XcellSignature::new("Macrophages M2", "immune", [ + "CD163", "MRC1", "CD209", "MSR1", "IL10", "TGFB1", "VEGFA", "ARG1", + ]), + XcellSignature::new("Dendritic cells", "immune", [ + "ITGAX", "CD1C", "CLEC10A", "FCER1A", "CD80", "CD86", "HLA-DRA", "CCR7", + ]), + XcellSignature::new("DCs immature", "immune", [ + "ITGAX", "CD1C", "MRC1", "FCER1A", "CLEC10A", "CCR5", "TLR7", "TLR9", + ]), + XcellSignature::new("DCs plasmacytoid", "immune", [ + "IL3RA", "CLEC4C", "LILRA4", "IRF7", "IRF8", "TLR7", "TLR9", "CXCR3", + ]), + XcellSignature::new("DCs activated", "immune", [ + "ITGAX", "CD80", "CD86", "CD40", "CCR7", "HLA-DRA", "IL12A", "IL12B", + ]), + XcellSignature::new("Mast cells", "immune", [ + "KIT", "CD117", "TPSAB1", "CPA3", "MS4A2", "HDC", "TPSB2", "GATA2", + ]), + XcellSignature::new("Mast cells resting", "immune", [ + "KIT", "TPSAB1", "CPA3", "MS4A2", "GATA2", "HRH4", "CMA1", "TPSG1", + ]), + XcellSignature::new("Mast cells activated", "immune", [ + "KIT", "TPSAB1", "MS4A2", "IL1B", "TNF", "IL6", "CCL3", "CCL4", + ]), + XcellSignature::new("Eosinophils", "immune", [ + "SIGLEC8", "IL5RA", "CCR3", "PRG2", "PRG3", "EPX", "RNASE2", "RNASE3", + ]), + XcellSignature::new("Neutrophils", "immune", [ + "FCGR3B", "CD66b", "CXCR2", "S100A8", "S100A9", "MPO", "ELANE", "CEACAM8", + ]), + XcellSignature::new("Basophils", "immune", [ + "MS4A2", "CCR3", "IL3RA", "HDC", "TPSAB1", "IL4", "IL13", "FCER1A", + ]), // ====== NK lineage ====== - XcellSignature::new("NK cells", "immune", - ["NCAM1", "NKG7", "KLRD1", "GNLY", "GZMB", "PRF1", "NCR1", "KLRK1"]), - XcellSignature::new("NK cells resting", "immune", - ["NCAM1", "KLRD1", "SELL", "CD160", "CD27", "IL2RB", "KLRB1", "PTGDR"]), - XcellSignature::new("NK cells activated", "immune", - ["NCAM1", "NKG7", "GZMB", "PRF1", "GNLY", "KLRK1", "FCGR3A", "IFNG"]), - XcellSignature::new("NK cells CD56dim", "immune", - ["FCGR3A", "CD16", "NCAM1", "KLRD1", "GZMB", "PRF1", "NKG7", "GNLY"]), - XcellSignature::new("NK cells CD56bright", "immune", - ["NCAM1", "KIT", "IL2RA", "IL7R", "CCR7", "SELL", "CD160", "KLRB1"]), + XcellSignature::new("NK cells", "immune", [ + "NCAM1", "NKG7", "KLRD1", "GNLY", "GZMB", "PRF1", "NCR1", "KLRK1", + ]), + XcellSignature::new("NK cells resting", "immune", [ + "NCAM1", "KLRD1", "SELL", "CD160", "CD27", "IL2RB", "KLRB1", "PTGDR", + ]), + XcellSignature::new("NK cells activated", "immune", [ + "NCAM1", "NKG7", "GZMB", "PRF1", "GNLY", "KLRK1", "FCGR3A", "IFNG", + ]), + XcellSignature::new("NK cells CD56dim", "immune", [ + "FCGR3A", "CD16", "NCAM1", "KLRD1", "GZMB", "PRF1", "NKG7", "GNLY", + ]), + XcellSignature::new("NK cells CD56bright", "immune", [ + "NCAM1", "KIT", "IL2RA", "IL7R", "CCR7", "SELL", "CD160", "KLRB1", + ]), // ====== Stromal / microenvironment ====== - XcellSignature::new("Endothelial cells", "stromal", - ["PECAM1", "CD31", "VWF", "CDH5", "VEGFR2", "KDR", "ESAM", "ENG"]), - XcellSignature::new("Endothelial cells lymphatic", "stromal", - ["PDPN", "LYVE1", "PTPRC", "VEGFR3", "FLT4", "PROX1", "CXCL12", "CCL21"]), - XcellSignature::new("Endothelial cells microvascular", "stromal", - ["PECAM1", "VWF", "VEGFR2", "ESAM", "CAV1", "TIE1", "TEK", "MCAM"]), - XcellSignature::new("Fibroblasts", "stromal", - ["COL1A1", "COL1A2", "FAP", "PDPN", "S100A4", "THY1", "DCN", "VIM"]), - XcellSignature::new("Fibroblasts activated", "stromal", - ["COL1A1", "COL3A1", "FAP", "ACTA2", "PDPN", "POSTN", "TNC", "FN1"]), - XcellSignature::new("Pericytes", "stromal", - ["RGS5", "PDGFRB", "ACTA2", "MCAM", "CSPG4", "CD146", "KCNJ8", "ABCC9"]), - XcellSignature::new("Smooth muscle cells", "stromal", - ["ACTA2", "MYH11", "TAGLN", "TPM1", "TPM2", "CALD1", "CNN1", "MYL9"]), - XcellSignature::new("Adipocytes", "stromal", - ["FABP4", "ADIPOQ", "PLIN1", "LIPE", "PNPLA2", "SLC2A4", "CIDEC", "PPARG"]), - XcellSignature::new("Chondrocytes", "stromal", - ["COL2A1", "ACAN", "SOX9", "COMP", "CHAD", "CRTL1", "LEF1", "MATN1"]), - XcellSignature::new("Osteoblasts", "stromal", - ["ALPL", "COL1A1", "SP7", "RUNX2", "BGLAP", "SPP1", "IBSP", "MEPE"]), - XcellSignature::new("Mesangial cells", "stromal", - ["PDGFRB", "ACTA2", "VIM", "ITGB1", "FN1", "COL1A1", "COL4A1", "NOTCH3"]), - XcellSignature::new("Schwann cells", "stromal", - ["SOX10", "S100B", "MPZ", "MBP", "PLP1", "PRX", "EGR2", "GAP43"]), - XcellSignature::new("Keratinocytes", "stromal", - ["KRT14", "KRT5", "KRT1", "KRT10", "IVL", "LOR", "DSG3", "EPCAM"]), + XcellSignature::new("Endothelial cells", "stromal", [ + "PECAM1", "CD31", "VWF", "CDH5", "VEGFR2", "KDR", "ESAM", "ENG", + ]), + XcellSignature::new("Endothelial cells lymphatic", "stromal", [ + "PDPN", "LYVE1", "PTPRC", "VEGFR3", "FLT4", "PROX1", "CXCL12", "CCL21", + ]), + XcellSignature::new("Endothelial cells microvascular", "stromal", [ + "PECAM1", "VWF", "VEGFR2", "ESAM", "CAV1", "TIE1", "TEK", "MCAM", + ]), + XcellSignature::new("Fibroblasts", "stromal", [ + "COL1A1", "COL1A2", "FAP", "PDPN", "S100A4", "THY1", "DCN", "VIM", + ]), + XcellSignature::new("Fibroblasts activated", "stromal", [ + "COL1A1", "COL3A1", "FAP", "ACTA2", "PDPN", "POSTN", "TNC", "FN1", + ]), + XcellSignature::new("Pericytes", "stromal", [ + "RGS5", "PDGFRB", "ACTA2", "MCAM", "CSPG4", "CD146", "KCNJ8", "ABCC9", + ]), + XcellSignature::new("Smooth muscle cells", "stromal", [ + "ACTA2", "MYH11", "TAGLN", "TPM1", "TPM2", "CALD1", "CNN1", "MYL9", + ]), + XcellSignature::new("Adipocytes", "stromal", [ + "FABP4", "ADIPOQ", "PLIN1", "LIPE", "PNPLA2", "SLC2A4", "CIDEC", "PPARG", + ]), + XcellSignature::new("Chondrocytes", "stromal", [ + "COL2A1", "ACAN", "SOX9", "COMP", "CHAD", "CRTL1", "LEF1", "MATN1", + ]), + XcellSignature::new("Osteoblasts", "stromal", [ + "ALPL", "COL1A1", "SP7", "RUNX2", "BGLAP", "SPP1", "IBSP", "MEPE", + ]), + XcellSignature::new("Mesangial cells", "stromal", [ + "PDGFRB", "ACTA2", "VIM", "ITGB1", "FN1", "COL1A1", "COL4A1", "NOTCH3", + ]), + XcellSignature::new("Schwann cells", "stromal", [ + "SOX10", "S100B", "MPZ", "MBP", "PLP1", "PRX", "EGR2", "GAP43", + ]), + XcellSignature::new("Keratinocytes", "stromal", [ + "KRT14", "KRT5", "KRT1", "KRT10", "IVL", "LOR", "DSG3", "EPCAM", + ]), // ====== Epithelial / other ====== - XcellSignature::new("Epithelial cells", "other", - ["EPCAM", "KRT19", "KRT8", "KRT18", "CDH1", "CD24", "MUC1", "CLDN4"]), - XcellSignature::new("Hepatocytes", "other", - ["ALB", "AFP", "CYP3A4", "HNF4A", "FABP1", "ASGR1", "SLC10A1", "APOB"]), - XcellSignature::new("Skeletal muscle cells", "other", - ["ACTA1", "MYH3", "MYOG", "MYOD1", "TNNT1", "TNNT3", "TTN", "MYL2"]), - XcellSignature::new("Neurons", "other", - ["TUBB3", "RBFOX3", "MAP2", "SYP", "SNAP25", "STMN2", "ENO2", "GAP43"]), - XcellSignature::new("Astrocytes", "other", - ["GFAP", "ALDH1L1", "S100B", "AQP4", "FGFR3", "TNC", "GLUL", "GJA1"]), - XcellSignature::new("Oligodendrocytes", "other", - ["MBP", "PLP1", "MAG", "MOG", "SOX10", "OLIG1", "OLIG2", "CNP"]), - XcellSignature::new("Podocytes", "other", - ["NPHS1", "NPHS2", "PODXL", "SYNPO", "WT1", "ACTN4", "CD2AP", "TPM3"]), - XcellSignature::new("Megakaryocytes", "other", - ["PPBP", "PF4", "ITGA2B", "GP9", "VWF", "NFE2", "MEIS1", "GATA1"]), - XcellSignature::new("Erythrocytes", "other", - ["HBB", "HBA1", "HBA2", "GATA1", "KLF1", "EPOR", "AHSP", "SLC4A1"]), + XcellSignature::new("Epithelial cells", "other", [ + "EPCAM", "KRT19", "KRT8", "KRT18", "CDH1", "CD24", "MUC1", "CLDN4", + ]), + XcellSignature::new("Hepatocytes", "other", [ + "ALB", "AFP", "CYP3A4", "HNF4A", "FABP1", "ASGR1", "SLC10A1", "APOB", + ]), + XcellSignature::new("Skeletal muscle cells", "other", [ + "ACTA1", "MYH3", "MYOG", "MYOD1", "TNNT1", "TNNT3", "TTN", "MYL2", + ]), + XcellSignature::new("Neurons", "other", [ + "TUBB3", "RBFOX3", "MAP2", "SYP", "SNAP25", "STMN2", "ENO2", "GAP43", + ]), + XcellSignature::new("Astrocytes", "other", [ + "GFAP", "ALDH1L1", "S100B", "AQP4", "FGFR3", "TNC", "GLUL", "GJA1", + ]), + XcellSignature::new("Oligodendrocytes", "other", [ + "MBP", "PLP1", "MAG", "MOG", "SOX10", "OLIG1", "OLIG2", "CNP", + ]), + XcellSignature::new("Podocytes", "other", [ + "NPHS1", "NPHS2", "PODXL", "SYNPO", "WT1", "ACTN4", "CD2AP", "TPM3", + ]), + XcellSignature::new("Megakaryocytes", "other", [ + "PPBP", "PF4", "ITGA2B", "GP9", "VWF", "NFE2", "MEIS1", "GATA1", + ]), + XcellSignature::new("Erythrocytes", "other", [ + "HBB", "HBA1", "HBA2", "GATA1", "KLF1", "EPOR", "AHSP", "SLC4A1", + ]), ] } @@ -459,8 +534,12 @@ pub fn xcell_score( let mut max_v = -1000000.0 for s in 0.. max_v { max_v = v } + if v < min_v { + min_v = v + } + if v > max_v { + max_v = v + } } let range = max_v - min_v if xc_abs(range) > 0.0000000001 { @@ -506,14 +585,8 @@ pub fn xcell_score( } XcellResult::new( - scores, - cell_types, - categories, - sample_names, - immune_scores, - stromal_scores, - microenv_scores, - params, + scores, cell_types, categories, sample_names, immune_scores, stromal_scores, + microenv_scores, params, ) } @@ -546,7 +619,9 @@ pub fn XcellResult::get_cell_type_scores( break } } - if idx < 0 { return [] } + if idx < 0 { + return [] + } self.scores[idx].copy() } @@ -563,7 +638,9 @@ pub fn XcellResult::get_sample_scores( break } } - if idx < 0 { return [] } + if idx < 0 { + return [] + } let result : Array[Double] = [] for t in 0.. Array[(String, Double)] { let s_scores = self.get_sample_scores(sample) let n = s_scores.length() - if n == 0 { return [] } + if n == 0 { + return [] + } // Sort indices by score descending let indices : Array[Int] = Array::make(n, 0) - for i in 0.. [mean per sample] -pub fn XcellResult::scores_by_category(self : XcellResult) -> Map[String, Array[Double]] { +pub fn XcellResult::scores_by_category( + self : XcellResult, +) -> Map[String, Array[Double]] { let n_samples = self.sample_names.length() let category_sum : Map[String, Array[Double]] = Map([], capacity=0) let category_count : Map[String, Int] = Map([], capacity=0) @@ -617,12 +700,14 @@ pub fn XcellResult::scores_by_category(self : XcellResult) -> Map[String, Array[ let existing = category_sum.get(cat) let arr : Array[Double] = [] match existing { - Some(a) => { - for x in a { arr.push(x) } - } - None => { - for _s in 0.. + for x in a { + arr.push(x) + } + None => + for _s in 0.. Map[String, Array[ Some(a) => a None => { let emp : Array[Double] = [] - for _i in 0.. Array[Int] { let code = xdna_base_to_code(sequence.unsafe_get(i).unsafe_to_char()) let safe_code = if code < 0 { 0 } else { code } let byte_idx = i / 4 - let shift = 6 - (i % 4) * 2 + let shift = 6 - i % 4 * 2 packed[byte_idx] = packed[byte_idx] | (safe_code << shift) } packed @@ -260,7 +260,7 @@ pub fn xdna_unpack_sequence(packed : Array[Int], seq_len : Int) -> String { let sb = StringBuilder::new() for i in 0..> shift) & 3 } else { @@ -363,11 +363,7 @@ pub fn xdna_from_bytes(data : Array[Int]) -> XdnaFile { let n = data.length() let mut offset = 0 // Determine checksum (last 4 bytes) if present. - let stored_checksum = if n >= 4 { - xdna_read_u32_be(data, n - 4) - } else { - 0 - } + let stored_checksum = if n >= 4 { xdna_read_u32_be(data, n - 4) } else { 0 } // Parse records while at least one record header (20 bytes) fits before the // trailing checksum. while offset + 20 <= n - 4 || (offset + 20 <= n && n < 4) { @@ -411,9 +407,13 @@ pub fn xdna_from_bytes(data : Array[Int]) -> XdnaFile { if file.records.length() == 0 { file.version = version } - file.records.push( - XdnaRecord::{ name, sequence, seq_type, annotations, checksum: stored_checksum }, - ) + file.records.push(XdnaRecord::{ + name, + sequence, + seq_type, + annotations, + checksum: stored_checksum, + }) // Stop if we have consumed everything up to the checksum. if offset >= n - 4 && n >= 4 { break diff --git a/test/moonbit/ace_test.mbt b/test/moonbit/ace_test.mbt index e6685eb6..5142f220 100644 --- a/test/moonbit/ace_test.mbt +++ b/test/moonbit/ace_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for ACE contig assembly format parser module. - test "ace_read_new" { let read = @src.AceRead::new( "read1", @@ -24,6 +23,7 @@ test "ace_read_new" { assert_eq(read.dye, "dye1") } +///| test "ace_contig_new" { let read = @src.AceRead::new( "read1", @@ -52,6 +52,7 @@ test "ace_contig_new" { assert_false(contig.reverse_complemented) } +///| test "ace_alignment_new" { let qual : Array[Int] = [30, 30, 30] let ali = @src.AceAlignment::new("contig1", 10, "ATC", qual) @@ -61,6 +62,7 @@ test "ace_alignment_new" { assert_eq(ali.quality.length(), 3) } +///| test "ace_data_new" { let contigs : Array[@src.AceContig] = [] let data = @src.AceData::new(contigs, 0) @@ -69,18 +71,21 @@ test "ace_data_new" { assert_eq(data.base_qual_threshold, 0) } +///| test "ace_parse_empty" { let data = @src.ace_parse("") assert_eq(data.contigs.length(), 0) assert_eq(data.total_contigs, 0) } +///| test "ace_parse_only_header" { let data = @src.ace_parse("AF contig1 100\n") assert_eq(data.contigs.length(), 0) assert_eq(data.total_contigs, 0) } +///| test "ace_parse_single_read" { let content = "AF contig1 10\n" + "RD read1 10 chem1 dye1\n" + @@ -99,6 +104,7 @@ test "ace_parse_single_read" { assert_eq(data.contigs[0].reads[0].read_id, "read1") } +///| test "ace_parse_multiple_reads" { let content = "AF contig1 20\n" + "RD read1 10 chem1 dye1\n" + @@ -117,6 +123,7 @@ test "ace_parse_multiple_reads" { assert_eq(data.contigs[0].reads.length(), 2) } +///| test "ace_parse_multiple_contigs" { let content = "AF contig1 10\n" + "RD read1 10 chem1 dye1\n" + @@ -140,6 +147,7 @@ test "ace_parse_multiple_contigs" { assert_eq(data.total_reads, 2) } +///| test "ace_parse_strands" { let content = "AF contig1 10\n" + "RD read1 10 chem1 dye1\n" + @@ -159,6 +167,7 @@ test "ace_parse_strands" { assert_eq(data.contigs[0].reads[1].strand, "-") } +///| test "ace_parse_quality_scores" { let content = "AF contig1 5\n" + "RD read1 5 chem1 dye1\n" + @@ -177,6 +186,7 @@ test "ace_parse_quality_scores" { assert_eq(data.contigs[0].base_qualities[4], 55) } +///| test "ace_parse_reads_only" { let content = "RD read1 5 chem1 dye1\n" + "ACGTG\n" + @@ -191,6 +201,7 @@ test "ace_parse_reads_only" { assert_eq(reads[1].read_id, "read2") } +///| test "ace_parse_contigs_only" { let content = "RD read1 5 chem1 dye1\n" + "ACGTG\n" + @@ -205,6 +216,7 @@ test "ace_parse_contigs_only" { assert_eq(contigs[0].reads.length(), 1) } +///| test "ace_get_contig" { let content = "AF contig1 10\n" + "RD read1 10 chem1 dye1\n" + @@ -227,6 +239,7 @@ test "ace_get_contig" { } } +///| test "ace_contig_length" { let content = "AF contig1 10\n" + "RD read1 10 chem1 dye1\n" + @@ -241,6 +254,7 @@ test "ace_contig_length" { assert_eq(@src.ace_contig_length(data, "nonexistent"), 0) } +///| test "ace_contig_reads" { let content = "AF contig1 10\n" + "RD read1 10 chem1 dye1\n" + @@ -258,6 +272,7 @@ test "ace_contig_reads" { assert_eq(empty_reads.length(), 0) } +///| test "ace_read_coverage" { let read1 = @src.AceRead::new( "read1", @@ -295,6 +310,7 @@ test "ace_read_coverage" { assert_eq(coverage.get(10), Some(2)) } +///| test "ace_read_coverage_partial" { let read1 = @src.AceRead::new( "read1", @@ -339,6 +355,7 @@ test "ace_read_coverage_partial" { assert_eq(coverage.get(10), Some(0)) } +///| test "ace_consensus_sequence" { let read = @src.AceRead::new( "read1", @@ -362,6 +379,7 @@ test "ace_consensus_sequence" { assert_eq(@src.ace_consensus_sequence(contig), "GCTA") } +///| test "ace_contig_gc_content" { let read = @src.AceRead::new( "read1", @@ -386,6 +404,7 @@ test "ace_contig_gc_content" { assert_eq(gc, 1.0) } +///| test "ace_contig_gc_content_mixed" { let read = @src.AceRead::new( "read1", @@ -410,19 +429,14 @@ test "ace_contig_gc_content_mixed" { assert_eq(gc, 0.5) } +///| test "ace_contig_gc_content_empty" { - let contig = @src.AceContig::new( - "contig1", - "", - [], - [], - "", - false, - ) + let contig = @src.AceContig::new("contig1", "", [], [], "", false) let gc = @src.ace_contig_gc_content(contig) assert_eq(gc, 0.0) } +///| test "ace_to_string_basic" { let read = @src.AceRead::new( "read1", @@ -451,6 +465,7 @@ test "ace_to_string_basic" { assert_true(output.contains("AF read1")) } +///| test "ace_to_string_roundtrip" { let content = "AF contig1 10\n" + "RD read1 10 chem1 dye1\n" + @@ -470,6 +485,7 @@ test "ace_to_string_roundtrip" { assert_eq(data2.contigs[0].reads[0].read_id, "read1") } +///| test "ace_sample_data" { let data = @src.sample_ace_data() assert_eq(data.contigs.length(), 1) @@ -480,6 +496,7 @@ test "ace_sample_data" { assert_eq(data.contigs[0].reads.length(), 2) } +///| test "ace_multiline_sequence" { let mut seq = "" let mut i = 0 @@ -498,11 +515,17 @@ test "ace_multiline_sequence" { } let content = "AF contig1 120\n" + "RD read1 120 chem1 dye1\n" + - seq + "\n" + - "q " + qual_str + "\n" + + seq + + "\n" + + "q " + + qual_str + + "\n" + "CT contig1 120 0 120\n" + - seq + "\n" + - "q " + qual_str + "\n" + + seq + + "\n" + + "q " + + qual_str + + "\n" + "AF read1 1 120 1 120 1 120 +\n" let data = @src.ace_parse(content) assert_eq(data.contigs.length(), 1) @@ -511,6 +534,7 @@ test "ace_multiline_sequence" { assert_eq(data.contigs[0].reads[0].sequence.length(), 120) } +///| test "ace_total_reads_count" { let content = "AF contig1 10\n" + "RD read1 10 chem1 dye1\n" + @@ -532,6 +556,7 @@ test "ace_total_reads_count" { assert_eq(data.total_reads, 2) } +///| test "ace_base_qualities_preserved" { let content = "AF contig1 3\n" + "RD read1 3 chem1 dye1\n" + @@ -548,6 +573,7 @@ test "ace_base_qualities_preserved" { assert_eq(data.contigs[0].base_qualities[2], 70) } +///| test "ace_read_quality_preserved" { let content = "AF contig1 3\n" + "RD read1 3 chem1 dye1\n" + @@ -564,6 +590,7 @@ test "ace_read_quality_preserved" { assert_eq(data.contigs[0].reads[0].quality[2], 30) } +///| test "ace_coverage_empty" { let contig = @src.AceContig::new( "contig1", @@ -580,6 +607,7 @@ test "ace_coverage_empty" { assert_eq(coverage.get(4), Some(0)) } +///| test "ace_contig_reads_strand_info" { let read1 = @src.AceRead::new( "read1", @@ -617,6 +645,7 @@ test "ace_contig_reads_strand_info" { assert_eq(contig.reads[1].dye, "dye2") } +///| test "ace_roundtrip_coverage" { let read1 = @src.AceRead::new( "read1", @@ -645,19 +674,10 @@ test "ace_roundtrip_coverage" { assert_eq(parsed.contigs[0].reads[0].strand, "+") } +///| test "ace_quality_to_string_format" { let qual : Array[Int] = [10, 20, 30] - let read = @src.AceRead::new( - "read1", - "ACG", - qual, - 1, - 3, - "+", - "", - "", - "", - ) + let read = @src.AceRead::new("read1", "ACG", qual, 1, 3, "+", "", "", "") let contig = @src.AceContig::new( "contig1", "ACG", @@ -671,6 +691,7 @@ test "ace_quality_to_string_format" { assert_true(output.contains("10 20 30")) } +///| test "ace_consensus_from_contig" { let read = @src.AceRead::new( "read1", @@ -694,6 +715,7 @@ test "ace_consensus_from_contig" { assert_eq(@src.ace_consensus_sequence(contig), "ACGT") } +///| test "ace_coverage_values" { let read1 = @src.AceRead::new( "read1", @@ -721,27 +743,15 @@ test "ace_coverage_values" { assert_eq(cov.get(4), Some(0)) } +///| test "ace_reverse_complemented_default" { - let contig = @src.AceContig::new( - "contig1", - "ACGT", - [], - [], - "", - false, - ) + let contig = @src.AceContig::new("contig1", "ACGT", [], [], "", false) assert_false(contig.reverse_complemented) } +///| test "ace_data_threshold" { - let contig = @src.AceContig::new( - "contig1", - "ACGT", - [], - [], - "", - false, - ) + let contig = @src.AceContig::new("contig1", "ACGT", [], [], "", false) let data = @src.AceData::new([contig], 30) assert_eq(data.base_qual_threshold, 30) -} \ No newline at end of file +} diff --git a/test/moonbit/align_abstract_test.mbt b/test/moonbit/align_abstract_test.mbt index 5d6b6ede..b06b9655 100644 --- a/test/moonbit/align_abstract_test.mbt +++ b/test/moonbit/align_abstract_test.mbt @@ -3,8 +3,8 @@ test "AbstractAlignment::new construction" { let sequences = ["ATCGATCG", "ATCGATCG"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) assert_eq(aln.abstract_n_seqs(), 2) @@ -16,8 +16,8 @@ test "AbstractAlignment::validate success" { let sequences = ["ATCGATCG", "ATCGATCG"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let (valid, msg) = aln.validate() @@ -30,8 +30,8 @@ test "AbstractAlignment::validate different lengths" { let sequences = ["ATCG", "ATCGATCG"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let (valid, _msg) = aln.validate() @@ -43,8 +43,8 @@ test "AbstractAlignment::validate empty alignment" { let sequences : Array[String] = [] let identifiers : Array[String] = [] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let (valid, msg) = aln.validate() @@ -57,8 +57,8 @@ test "AbstractAlignment::validate invalid nucleotide character" { let sequences = ["ATCGNTCG", "ATCGXTCG"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let (valid, _msg) = aln.validate() @@ -70,8 +70,8 @@ test "AbstractAlignment::validate protein" { let sequences = ["ALIGMENT", "ALIGMENT"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("protein"), ) let (valid, _msg) = aln.validate() @@ -83,8 +83,8 @@ test "AbstractAlignment::validate protein invalid char" { let sequences = ["ALIGMENT", "ALIGM1NT"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("protein"), ) let (valid, _msg) = aln.validate() @@ -96,14 +96,14 @@ test "abstract_column_stats identical columns" { let sequences = ["AAAA", "AAAA"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let stats = @src.abstract_column_stats(aln, 0) let diff_cons = (stats.conservation - 1.0).abs() assert_true(diff_cons < 1.0e-10) - let gap_val = (stats.gap_fraction).abs() + let gap_val = stats.gap_fraction.abs() assert_true(gap_val < 1.0e-10) assert_eq(stats.n_unique_chars, 1) } @@ -113,8 +113,8 @@ test "abstract_column_stats with gaps" { let sequences = ["A-CG", "AC-G"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let stats = @src.abstract_column_stats(aln, 1) @@ -126,8 +126,8 @@ test "abstract_column_stats diversity" { let sequences = ["ACGT", "TGCA"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let stats = @src.abstract_column_stats(aln, 0) @@ -139,12 +139,12 @@ test "abstract_column_stats out of bounds" { let sequences = ["ACGT", "TGCA"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let stats = @src.abstract_column_stats(aln, 100) - let cons_val = (stats.conservation).abs() + let cons_val = stats.conservation.abs() assert_true(cons_val < 1.0e-10) assert_eq(stats.n_unique_chars, 0) } @@ -154,8 +154,8 @@ test "abstract_identity_matrix identical sequences" { let sequences = ["ATCGATCG", "ATCGATCG"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let matrix = @src.abstract_identity_matrix(aln) @@ -174,12 +174,12 @@ test "abstract_identity_matrix different sequences" { let sequences = ["AAAA", "TTTT"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let matrix = @src.abstract_identity_matrix(aln) - assert_true((matrix[0][1]).abs() < 1.0e-10) + assert_true(matrix[0][1].abs() < 1.0e-10) } ///| @@ -187,8 +187,8 @@ test "abstract_identity_matrix partial match" { let sequences = ["ACGT", "ACGA"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let matrix = @src.abstract_identity_matrix(aln) @@ -200,8 +200,8 @@ test "abstract_overall_identity" { let sequences = ["ACGT", "ACGA", "ACGT"] let identifiers = ["seq1", "seq2", "seq3"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let identity = @src.abstract_overall_identity(aln) @@ -214,8 +214,8 @@ test "abstract_overall_identity single sequence" { let sequences = ["ACGT"] let identifiers = ["seq1"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let identity = @src.abstract_overall_identity(aln) @@ -227,8 +227,8 @@ test "abstract_coverage" { let sequences = ["ACGT", "A-GT"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let coverage = @src.abstract_coverage(aln) @@ -241,8 +241,8 @@ test "abstract_coverage no gaps" { let sequences = ["ACGT", "ACGT"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let coverage = @src.abstract_coverage(aln) @@ -254,8 +254,8 @@ test "AbstractAlignment::abstract_get_column" { let sequences = ["ACGT", "TGCA"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let col = aln.abstract_get_column(0) @@ -267,8 +267,8 @@ test "AbstractAlignment::abstract_get_column out of bounds" { let sequences = ["ACGT"] let identifiers = ["seq1"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let col = aln.abstract_get_column(10) @@ -280,8 +280,8 @@ test "AbstractAlignment::abstract_get_seq" { let sequences = ["ATCGATCG"] let identifiers = ["seq1"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) assert_eq(aln.abstract_get_seq(0), "ATCGATCG") @@ -292,8 +292,8 @@ test "AbstractAlignment::abstract_get_seq out of bounds" { let sequences = ["ATCG"] let identifiers = ["seq1"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) assert_eq(aln.abstract_get_seq(5), "") @@ -304,8 +304,8 @@ test "AbstractAlignment::abstract_get_id" { let sequences = ["ATCG"] let identifiers = ["gene1"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) assert_eq(aln.abstract_get_id(0), "gene1") @@ -316,8 +316,8 @@ test "AbstractAlignment::abstract_type" { let sequences = ["ATCG"] let identifiers = ["seq1"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let t = aln.abstract_type() @@ -329,8 +329,8 @@ test "abstract_variable_sites" { let sequences = ["ACGT", "ACGA"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let num_sites = @src.abstract_variable_sites(aln) @@ -342,8 +342,8 @@ test "abstract_variable_sites none" { let sequences = ["ACGT", "ACGT"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let num_sites = @src.abstract_variable_sites(aln) @@ -355,8 +355,8 @@ test "abstract_parsimony_sites" { let sequences = ["ACGT", "ACGA", "TCGT"] let identifiers = ["seq1", "seq2", "seq3"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let parsimony = @src.abstract_parsimony_sites(aln) @@ -368,8 +368,8 @@ test "abstract_consensus_sequence" { let sequences = ["ACGT", "ACGA", "ACGT"] let identifiers = ["seq1", "seq2", "seq3"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let consensus = @src.abstract_consensus_sequence(aln) @@ -381,12 +381,14 @@ test "abstract_filter_gaps" { let sequences = ["A-CGT", "A-CGA"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let filtered = @src.abstract_filter_gaps(aln, 0.5) - assert_true(filtered.abstract_alignment_length() <= aln.abstract_alignment_length()) + assert_true( + filtered.abstract_alignment_length() <= aln.abstract_alignment_length(), + ) } ///| @@ -394,8 +396,8 @@ test "abstract_trim" { let sequences = ["ACGTACGT", "ACGTACGT"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let trimmed = @src.abstract_trim(aln, 2, 5) @@ -408,14 +410,14 @@ test "abstract_distance_matrix" { let sequences = ["ACGT", "ACGA"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let matrix = @src.abstract_distance_matrix(aln) assert_eq(matrix.length(), 2) - assert_true((matrix[0][0]).abs() < 1.0e-10) - assert_true((matrix[1][1]).abs() < 1.0e-10) + assert_true(matrix[0][0].abs() < 1.0e-10) + assert_true(matrix[1][1].abs() < 1.0e-10) } ///| @@ -441,8 +443,8 @@ test "AbstractAlignment::multiple sequences" { let sequences = ["AAAA", "CCCC", "GGGG", "TTTT"] let identifiers = ["s1", "s2", "s3", "s4"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) assert_eq(aln.abstract_n_seqs(), 4) @@ -454,8 +456,8 @@ test "abstract_singleton_sites" { let sequences = ["ACGT", "ACGT", "ACGA"] let identifiers = ["seq1", "seq2", "seq3"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let singleton = @src.abstract_singleton_sites(aln) @@ -467,8 +469,8 @@ test "abstract_summary" { let sequences = ["ACGT", "ACGT"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let summary = @src.abstract_summary(aln) @@ -481,8 +483,8 @@ test "AbstractAlignment::single sequence identity" { let sequences = ["ACGT"] let identifiers = ["seq1"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let matrix = @src.abstract_identity_matrix(aln) diff --git a/test/moonbit/align_analysis_test.mbt b/test/moonbit/align_analysis_test.mbt index ed4c98fd..a50bffcd 100644 --- a/test/moonbit/align_analysis_test.mbt +++ b/test/moonbit/align_analysis_test.mbt @@ -1,5 +1,6 @@ // Tests for Bio.Align.analysis module +///| test "AlnAnalysisResult creation" { let result = @src.AlnAnalysisResult::new(0.1, 0.05, 2.0, 0.1, 10, 5) assert_true(result.aln_get_dn() == 0.1) @@ -10,18 +11,21 @@ test "AlnAnalysisResult creation" { assert_true(result.aln_get_n_nonsyn() == 5) } +///| test "positive selection detection" { let result = @src.AlnAnalysisResult::new(0.1, 0.05, 2.0, 0.1, 10, 5) assert_true(result.aln_has_positive_selection()) assert_false(result.aln_has_purifying_selection()) } +///| test "purifying selection detection" { let result = @src.AlnAnalysisResult::new(0.05, 0.1, 0.5, 0.1, 5, 10) assert_false(result.aln_has_positive_selection()) assert_true(result.aln_has_purifying_selection()) } +///| test "aln_aa_from_codon" { assert_true(@src.aln_aa_from_codon("ATG") == "M") assert_true(@src.aln_aa_from_codon("AAA") == "K") @@ -29,12 +33,14 @@ test "aln_aa_from_codon" { assert_true(@src.aln_aa_from_codon("TAA") == "*") } +///| test "aln_is_synonymous" { assert_true(@src.aln_is_synonymous("AAA", 2, "G")) // AAG also codes for K assert_false(@src.aln_is_synonymous("AAA", 1, "T")) // ATA codes for I assert_true(@src.aln_is_synonymous("TTT", 2, "C")) // TTC also codes for F } +///| test "aln_analyze_dn_ds identical sequences" { let seq1 = "ATGAAACCC" let seq2 = "ATGAAACCC" @@ -43,6 +49,7 @@ test "aln_analyze_dn_ds identical sequences" { assert_true(result.aln_get_ds() == 0.0) } +///| test "aln_analyze_dn_ds different sequences" { let seq1 = "ATGAAACCC" let seq2 = "ATGAAGCCC" @@ -50,36 +57,43 @@ test "aln_analyze_dn_ds different sequences" { assert_true(result.aln_get_ds() > 0.0) } +///| test "aln_jukes_cantor_distance identical" { let dist = @src.aln_jukes_cantor_distance("ACGT", "ACGT") assert_true(dist == 0.0) } +///| test "aln_jukes_cantor_distance different" { let dist = @src.aln_jukes_cantor_distance("ACGT", "TCGT") assert_true(dist > 0.0) } +///| test "aln_kimura_2p_distance identical" { let dist = @src.aln_kimura_2p_distance("ACGT", "ACGT") assert_true(dist == 0.0) } +///| test "aln_kimura_2p_distance transition" { let dist = @src.aln_kimura_2p_distance("ACGT", "TCGT") assert_true(dist > 0.0) } +///| test "aln_p_distance identical" { let dist = @src.aln_p_distance("ACGT", "ACGT") assert_true(dist == 0.0) } +///| test "aln_p_distance" { let dist = @src.aln_p_distance("ACGT", "AATT") assert_true(dist > 0.4 && dist < 0.6) } +///| test "aln_jukes_cantor_matrix" { let sequences = ["ACGT", "TCGT", "ACGA"] let matrix = @src.aln_jukes_cantor_matrix(sequences) @@ -89,6 +103,7 @@ test "aln_jukes_cantor_matrix" { assert_true(matrix[0][1] > 0.0) } +///| test "aln_calculate_dn_ds_matrix" { let sequences = ["ATGAAACCC", "ATGAAGCCC", "ATGAAACCC"] let matrix = @src.aln_calculate_dn_ds_matrix(sequences) diff --git a/test/moonbit/align_applications_test.mbt b/test/moonbit/align_applications_test.mbt index 0cfccdcf..0c860d07 100644 --- a/test/moonbit/align_applications_test.mbt +++ b/test/moonbit/align_applications_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Align.Applications module. - test "ClustalwCommandline creation" { let cmd = @src.create_example_clustalw() let command = cmd.build() @@ -8,6 +7,7 @@ test "ClustalwCommandline creation" { assert_true(command.contains("-infile")) } +///| test "ClustalwCommandline set_matrix" { let mut cmd = @src.ClustalwCommandline::new("clustalw2") cmd = cmd.set_matrix("BLOSUM62") @@ -16,6 +16,7 @@ test "ClustalwCommandline set_matrix" { assert_true(command.contains("BLOSUM62")) } +///| test "ClustalOmegaCommandline creation" { let cmd = @src.create_example_clustalomega() let command = cmd.build() @@ -23,6 +24,7 @@ test "ClustalOmegaCommandline creation" { assert_true(command.contains("-i")) } +///| test "ClustalOmegaCommandline set_iterations" { let mut cmd = @src.ClustalOmegaCommandline::new("clustalo") cmd = cmd.set_iterations(10) @@ -31,15 +33,17 @@ test "ClustalOmegaCommandline set_iterations" { assert_true(command.contains("10")) } +///| test "MuscleCommandline creation" { let cmd = @src.create_example_muscle() let command = cmd.build() assert_true(command.contains("muscle")) } +///| test "MAFFTCommandline creation" { let cmd = @src.create_example_mafft() let command = cmd.build() assert_true(command.contains("mafft")) assert_true(command.contains("--auto")) -} \ No newline at end of file +} diff --git a/test/moonbit/align_bed_test.mbt b/test/moonbit/align_bed_test.mbt index a73403ac..054798bb 100644 --- a/test/moonbit/align_bed_test.mbt +++ b/test/moonbit/align_bed_test.mbt @@ -522,8 +522,7 @@ test "Bio.Align.bed writes canonical BED12 plus record" { AlignBedError(message) => abort("valid BED writing failed: " + message) } assert_eq( - line, - "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\t2\t567,488,\t0,3512,\n", + line, "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\t2\t567,488,\t0,3512,\n", ) } @@ -533,8 +532,7 @@ test "Bio.Align.bed writes canonical BED12 minus record" { AlignBedError(message) => abort("valid BED writing failed: " + message) } assert_eq( - line, - "chr22\t2000\t6000\tmRNA2\t900\t-\t2300\t5960\t0,255,0\t2\t433,399,\t0,3601,\n", + line, "chr22\t2000\t6000\tmRNA2\t900\t-\t2300\t5960\t0,255,0\t2\t433,399,\t0,3601,\n", ) } @@ -591,10 +589,7 @@ test "Bio.Align.bed writes BED9" { let line = @src.align_bed_format(align_bed_test_plus(), bed_columns=9) catch { AlignBedError(message) => abort("valid BED9 writing failed: " + message) } - assert_eq( - line, - "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\n", - ) + assert_eq(line, "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\n") } ///| @@ -602,10 +597,7 @@ test "Bio.Align.bed writes BED10" { let line = @src.align_bed_format(align_bed_test_plus(), bed_columns=10) catch { AlignBedError(message) => abort("valid BED10 writing failed: " + message) } - assert_eq( - line, - "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\t2\n", - ) + assert_eq(line, "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\t2\n") } ///| @@ -614,8 +606,7 @@ test "Bio.Align.bed writes BED11" { AlignBedError(message) => abort("valid BED11 writing failed: " + message) } assert_eq( - line, - "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\t2\t567,488,\n", + line, "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\t2\t567,488,\n", ) } @@ -635,7 +626,8 @@ test "Bio.Align.bed BED12 round trip is stable" { test "Bio.Align.bed writes complete document" { let document = align_bed_test_document() let output = @src.align_bed_write(document, bed_columns=3) catch { - AlignBedError(message) => abort("valid BED document writing failed: " + message) + AlignBedError(message) => + abort("valid BED document writing failed: " + message) } assert_eq(output.split("\n").length(), 4) } @@ -644,17 +636,15 @@ test "Bio.Align.bed writes complete document" { test "Bio.Align.bed textual score writes unchanged" { let alignment = align_bed_test_parse("chr1\t0\t10\ttx\tpass\n").alignments[0] let output = @src.align_bed_format(alignment, bed_columns=5) catch { - AlignBedError(message) => abort("valid BED score writing failed: " + message) + AlignBedError(message) => + abort("valid BED score writing failed: " + message) } assert_eq(output, "chr1\t0\t10\ttx\tpass\n") } ///| test "Bio.Align.bed writer supplies default query name" { - let output = @src.align_bed_format( - align_bed_test_simple(), - bed_columns=4, - ) catch { + let output = @src.align_bed_format(align_bed_test_simple(), bed_columns=4) catch { AlignBedError(message) => abort("valid BED writing failed: " + message) } assert_eq(output, "chr7\t100\t180\tquery\n") @@ -662,10 +652,7 @@ test "Bio.Align.bed writer supplies default query name" { ///| test "Bio.Align.bed writer supplies default score" { - let output = @src.align_bed_format( - align_bed_test_simple(), - bed_columns=5, - ) catch { + let output = @src.align_bed_format(align_bed_test_simple(), bed_columns=5) catch { AlignBedError(message) => abort("valid BED writing failed: " + message) } assert_eq(output, "chr7\t100\t180\tquery\t0\n") @@ -673,10 +660,7 @@ test "Bio.Align.bed writer supplies default score" { ///| test "Bio.Align.bed writer supplies default thick interval and color" { - let output = @src.align_bed_format( - align_bed_test_simple(), - bed_columns=9, - ) catch { + let output = @src.align_bed_format(align_bed_test_simple(), bed_columns=9) catch { AlignBedError(message) => abort("valid BED writing failed: " + message) } assert_eq(output, "chr7\t100\t180\tquery\t0\t+\t100\t180\t0\n") @@ -705,34 +689,28 @@ test "Bio.Align.bed reads BED6 reverse strand" { ///| test "Bio.Align.bed reads BED7" { - let alignment = align_bed_test_parse( - "chr1\t10\t20\ttx\t7\t+\t12\n", - ).alignments[0] + let alignment = align_bed_test_parse("chr1\t10\t20\ttx\t7\t+\t12\n").alignments[0] assert_eq(alignment.thick_start, Some(12)) assert_eq(alignment.thick_end, None) } ///| test "Bio.Align.bed reads BED8" { - let alignment = align_bed_test_parse( - "chr1\t10\t20\ttx\t7\t+\t12\t18\n", - ).alignments[0] + let alignment = align_bed_test_parse("chr1\t10\t20\ttx\t7\t+\t12\t18\n").alignments[0] assert_eq(alignment.thick_end, Some(18)) } ///| test "Bio.Align.bed reads BED9" { let alignment = align_bed_test_parse( - "chr1\t10\t20\ttx\t7\t+\t12\t18\t10,20,30\n", - ).alignments[0] + "chr1\t10\t20\ttx\t7\t+\t12\t18\t10,20,30\n", + ).alignments[0] assert_eq(alignment.item_rgb, Some("10,20,30")) } ///| test "Bio.Align.bed reads lossless single-block BED10" { - let alignment = align_bed_test_parse( - "chr1\t10\t20\ttx\t7\t+\t12\t18\t0\t1\n", - ).alignments[0] + let alignment = align_bed_test_parse("chr1\t10\t20\ttx\t7\t+\t12\t18\t0\t1\n").alignments[0] assert_eq(alignment.blocks().length(), 1) assert_eq(alignment.source_columns, 10) } @@ -740,8 +718,8 @@ test "Bio.Align.bed reads lossless single-block BED10" { ///| test "Bio.Align.bed reads inferable contiguous BED11" { let alignment = align_bed_test_parse( - "chr1\t10\t20\ttx\t7\t+\t12\t18\t0\t2\t4,6,\n", - ).alignments[0] + "chr1\t10\t20\ttx\t7\t+\t12\t18\t0\t2\t4,6,\n", + ).alignments[0] assert_eq(alignment.blocks().length(), 2) assert_eq(alignment.blocks()[1].target_start, 14) } @@ -749,8 +727,8 @@ test "Bio.Align.bed reads inferable contiguous BED11" { ///| test "Bio.Align.bed accepts BED12 lists without trailing commas" { let alignment = align_bed_test_parse( - "chr1\t10\t20\ttx\t7\t+\t12\t18\t0\t2\t4,3\t0,7\n", - ).alignments[0] + "chr1\t10\t20\ttx\t7\t+\t12\t18\t0\t2\t4,3\t0,7\n", + ).alignments[0] assert_eq(alignment.query_size(), 7) } @@ -815,141 +793,107 @@ test "Bio.Align.bed rejects thickStart before interval" { ///| test "Bio.Align.bed rejects thickEnd after interval" { - assert_true( - align_bed_test_rejects("chr1\t10\t20\ttx\t0\t+\t10\t21\n"), - ) + assert_true(align_bed_test_rejects("chr1\t10\t20\ttx\t0\t+\t10\t21\n")) } ///| test "Bio.Align.bed rejects reversed thick interval" { - assert_true( - align_bed_test_rejects("chr1\t10\t20\ttx\t0\t+\t18\t12\n"), - ) + assert_true(align_bed_test_rejects("chr1\t10\t20\ttx\t0\t+\t18\t12\n")) } ///| test "Bio.Align.bed rejects multi-block BED10" { - assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\n", - ), - ) + assert_true(align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\n")) } ///| test "Bio.Align.bed rejects BED11 block count mismatch" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t20,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t20,\n"), ) } ///| test "Bio.Align.bed rejects ambiguous gapped BED11" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\n"), ) } ///| test "Bio.Align.bed rejects zero block count" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t0\t\t\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t0\t\t\n"), ) } ///| test "Bio.Align.bed rejects blockSizes count mismatch" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,\t0,15,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,\t0,15,\n"), ) } ///| test "Bio.Align.bed rejects blockStarts count mismatch" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\t0,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\t0,\n"), ) } ///| test "Bio.Align.bed rejects empty block list item" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,,5,\t0,15,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,,5,\t0,15,\n"), ) } ///| test "Bio.Align.bed rejects noninteger block size" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,x,\t0,15,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,x,\t0,15,\n"), ) } ///| test "Bio.Align.bed rejects zero block size" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t0,5,\t0,15,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t0,5,\t0,15,\n"), ) } ///| test "Bio.Align.bed rejects first block after chromStart" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\t1,15,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\t1,15,\n"), ) } ///| test "Bio.Align.bed rejects overlapping blocks" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t10,10,\t0,5,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t10,10,\t0,5,\n"), ) } ///| test "Bio.Align.bed rejects unsorted blocks" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\t0,0,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\t0,0,\n"), ) } ///| test "Bio.Align.bed rejects block beyond chromEnd" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,10,\t0,15,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,10,\t0,15,\n"), ) } ///| test "Bio.Align.bed rejects final block before chromEnd" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,4,\t0,15,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,4,\t0,15,\n"), ) } @@ -1086,11 +1030,10 @@ test "Bio.Align.bed constructor rejects empty target identifier" { assert_true( try { ignore( - @src.AlignBedAlignment::create( - "", - Some("query"), - [align_bed_test_coordinate(0, 0), align_bed_test_coordinate(5, 5)], - ), + @src.AlignBedAlignment::create("", Some("query"), [ + align_bed_test_coordinate(0, 0), + align_bed_test_coordinate(5, 5), + ]), ) false } catch { @@ -1101,11 +1044,10 @@ test "Bio.Align.bed constructor rejects empty target identifier" { ///| test "Bio.Align.bed constructor allows absent query identifier" { - let alignment = @src.AlignBedAlignment::create( - "target", - None, - [align_bed_test_coordinate(0, 0), align_bed_test_coordinate(5, 5)], - ) catch { + let alignment = @src.AlignBedAlignment::create("target", None, [ + align_bed_test_coordinate(0, 0), + align_bed_test_coordinate(5, 5), + ]) catch { AlignBedError(message) => abort("valid BED alignment failed: " + message) } assert_eq(alignment.query_id, None) @@ -1260,8 +1202,7 @@ test "Bio.Align.bed writes Biopython strand fixture" { AlignBedError(message) => abort("valid BED writing failed: " + message) } assert_eq( - output, - "target\t2\t12\tquery\t8\t-\t2\t12\t0\t4\t1,2,3,2,\t0,2,4,8,\n", + output, "target\t2\t12\tquery\t8\t-\t2\t12\t0\t4\t1,2,3,2,\t0,2,4,8,\n", ) } diff --git a/test/moonbit/align_cluster_test.mbt b/test/moonbit/align_cluster_test.mbt index 9e7040a1..0a895bb3 100644 --- a/test/moonbit/align_cluster_test.mbt +++ b/test/moonbit/align_cluster_test.mbt @@ -158,4 +158,4 @@ test "guide_tree_leaf_count" { } } assert_eq(leaf_count, 4) -} \ No newline at end of file +} diff --git a/test/moonbit/alignace_test.mbt b/test/moonbit/alignace_test.mbt index 6e6fb34f..d6d2408b 100644 --- a/test/moonbit/alignace_test.mbt +++ b/test/moonbit/alignace_test.mbt @@ -43,14 +43,12 @@ test "alignace_site_new_negative_strand" { ///| test "alignace_motif_new_basic" { - let m = @src.AlignAceMotif::new( - [ - [8, 0, 0, 0], - [0, 8, 0, 0], - [0, 0, 8, 0], - [0, 0, 0, 8], - ], - ) + let m = @src.AlignAceMotif::new([ + [8, 0, 0, 0], + [0, 8, 0, 0], + [0, 0, 8, 0], + [0, 0, 0, 8], + ]) assert_eq(m.width, 4) // Total sites = sum of column 0 = 8 + 0 + 0 + 0 = 8 assert_eq(m.num_sites, 8) @@ -61,14 +59,12 @@ test "alignace_motif_new_basic" { ///| test "alignace_motif_new_consensus_tgac" { // Motif where T is most common at each position - let m = @src.AlignAceMotif::new( - [ - [1, 0, 0, 0], - [0, 1, 0, 0], - [0, 0, 1, 0], - [9, 9, 9, 9], - ], - ) + let m = @src.AlignAceMotif::new([ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, 0], + [9, 9, 9, 9], + ]) assert_eq(m.width, 4) assert_eq(m.num_sites, 1 + 0 + 0 + 9) assert_eq(m.consensus, "TTTT") @@ -77,14 +73,7 @@ test "alignace_motif_new_consensus_tgac" { ///| test "alignace_motif_consensus_ties_default_to_a" { // When counts are tied, A (first row) wins by default - let m = @src.AlignAceMotif::new( - [ - [5, 0, 5], - [5, 0, 0], - [0, 5, 0], - [0, 5, 0], - ], - ) + let m = @src.AlignAceMotif::new([[5, 0, 5], [5, 0, 0], [0, 5, 0], [0, 5, 0]]) // Position 0: A=5, C=5 -> A wins (first checked) // Position 1: G=5, T=5 -> G wins (checked before T) // Position 2: A=5 -> A @@ -93,14 +82,12 @@ test "alignace_motif_consensus_ties_default_to_a" { ///| test "alignace_motif_motif_consensus" { - let m = @src.AlignAceMotif::new( - [ - [8, 0, 0, 0], - [0, 8, 0, 0], - [0, 0, 8, 0], - [0, 0, 0, 8], - ], - ) + let m = @src.AlignAceMotif::new([ + [8, 0, 0, 0], + [0, 8, 0, 0], + [0, 0, 8, 0], + [0, 0, 0, 8], + ]) assert_eq(@src.alignace_motif_consensus(m), "ACGT") } @@ -110,14 +97,7 @@ test "alignace_motif_motif_consensus" { ///| test "alignace_to_pwm_uniform_distribution" { - let m = @src.AlignAceMotif::new( - [ - [2, 2], - [2, 2], - [2, 2], - [2, 2], - ], - ) + let m = @src.AlignAceMotif::new([[2, 2], [2, 2], [2, 2], [2, 2]]) let pwm = @src.alignace_to_pwm(m) assert_eq(pwm.length(), 4) assert_eq(pwm[0].length(), 2) @@ -132,14 +112,7 @@ test "alignace_to_pwm_uniform_distribution" { ///| test "alignace_to_pwm_pure_motif" { // Motif where only one base appears at each position - let m = @src.AlignAceMotif::new( - [ - [10, 0], - [0, 0], - [0, 10], - [0, 0], - ], - ) + let m = @src.AlignAceMotif::new([[10, 0], [0, 0], [0, 10], [0, 0]]) let pwm = @src.alignace_to_pwm(m) // Column 0: A=1.0, C=0.0, G=0.0, T=0.0 assert_true(pwm[0][0] > 0.99) @@ -154,14 +127,7 @@ test "alignace_to_pwm_pure_motif" { ///| test "alignace_to_pwm_zero_column_uses_default" { // Column with all zeros should default to 0.25 - let m = @src.AlignAceMotif::new( - [ - [0, 5], - [0, 0], - [0, 0], - [0, 0], - ], - ) + let m = @src.AlignAceMotif::new([[0, 5], [0, 0], [0, 0], [0, 0]]) let pwm = @src.alignace_to_pwm(m) // Column 0: all zeros, should be 0.25 each assert_true(pwm[0][0] > 0.24 && pwm[0][0] < 0.26) @@ -177,14 +143,7 @@ test "alignace_to_pwm_zero_column_uses_default" { ///| test "alignace_information_content_uniform_is_zero" { // Uniform distribution has 0 information content - let m = @src.AlignAceMotif::new( - [ - [2, 2], - [2, 2], - [2, 2], - [2, 2], - ], - ) + let m = @src.AlignAceMotif::new([[2, 2], [2, 2], [2, 2], [2, 2]]) let ic = @src.alignace_information_content(m) assert_eq(ic.length(), 2) // IC should be approximately 0 for uniform distribution @@ -195,14 +154,7 @@ test "alignace_information_content_uniform_is_zero" { ///| test "alignace_information_content_pure_is_two_bits" { // Pure motif (only one base) has IC = 2 bits - let m = @src.AlignAceMotif::new( - [ - [10, 0], - [0, 0], - [0, 10], - [0, 0], - ], - ) + let m = @src.AlignAceMotif::new([[10, 0], [0, 0], [0, 10], [0, 0]]) let ic = @src.alignace_information_content(m) // Column 0: only A, IC should be ~2 bits assert_true(ic[0] > 1.9) @@ -212,14 +164,7 @@ test "alignace_information_content_pure_is_two_bits" { ///| test "alignace_total_ic_uniform_is_zero" { - let m = @src.AlignAceMotif::new( - [ - [2, 2, 2], - [2, 2, 2], - [2, 2, 2], - [2, 2, 2], - ], - ) + let m = @src.AlignAceMotif::new([[2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2]]) let total = @src.alignace_total_ic(m) assert_true(total < 0.01) assert_true(total > -0.01) @@ -227,14 +172,12 @@ test "alignace_total_ic_uniform_is_zero" { ///| test "alignace_total_ic_pure_is_width_times_two" { - let m = @src.AlignAceMotif::new( - [ - [10, 10, 10], - [0, 0, 0], - [0, 0, 0], - [0, 0, 0], - ], - ) + let m = @src.AlignAceMotif::new([ + [10, 10, 10], + [0, 0, 0], + [0, 0, 0], + [0, 0, 0], + ]) let total = @src.alignace_total_ic(m) // 3 columns × 2 bits = 6 bits assert_true(total > 5.9) @@ -493,14 +436,12 @@ test "alignace_summary_empty_record" { ///| test "alignace_motif_width_matches_matrix" { - let m = @src.AlignAceMotif::new( - [ - [1, 2, 3, 4, 5], - [0, 0, 0, 0, 0], - [0, 0, 0, 0, 0], - [0, 0, 0, 0, 0], - ], - ) + let m = @src.AlignAceMotif::new([ + [1, 2, 3, 4, 5], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]) assert_eq(m.width, 5) assert_eq(m.consensus, "AAAAA") } @@ -515,28 +456,19 @@ test "alignace_motif_empty_matrix" { ///| test "alignace_information_content_length_matches_width" { - let m = @src.AlignAceMotif::new( - [ - [5, 5, 5, 5, 5], - [0, 0, 0, 0, 0], - [0, 0, 0, 0, 0], - [5, 5, 5, 5, 5], - ], - ) + let m = @src.AlignAceMotif::new([ + [5, 5, 5, 5, 5], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [5, 5, 5, 5, 5], + ]) let ic = @src.alignace_information_content(m) assert_eq(ic.length(), 5) } ///| test "alignace_to_pwm_dimensions" { - let m = @src.AlignAceMotif::new( - [ - [1, 2, 3], - [0, 0, 0], - [0, 0, 0], - [0, 0, 0], - ], - ) + let m = @src.AlignAceMotif::new([[1, 2, 3], [0, 0, 0], [0, 0, 0], [0, 0, 0]]) let pwm = @src.alignace_to_pwm(m) // PWM should have 4 rows (one per base) and width columns assert_eq(pwm.length(), 4) diff --git a/test/moonbit/alphabet_test.mbt b/test/moonbit/alphabet_test.mbt index f7ad6e5b..504b0bfd 100644 --- a/test/moonbit/alphabet_test.mbt +++ b/test/moonbit/alphabet_test.mbt @@ -1,5 +1,6 @@ // Tests for Bio.Alphabet module +///| test "IUPAC unambiguous DNA alphabet" { let dna = @src.iupac_unambiguous_dna() assert_true(dna.name == "IUPACUnambiguousDNA") @@ -13,6 +14,7 @@ test "IUPAC unambiguous DNA alphabet" { assert_false(dna.is_valid("X")) } +///| test "IUPAC unambiguous RNA alphabet" { let rna = @src.iupac_unambiguous_rna() assert_true(rna.name == "IUPACUnambiguousRNA") @@ -25,6 +27,7 @@ test "IUPAC unambiguous RNA alphabet" { assert_false(rna.is_valid("T")) } +///| test "IUPAC ambiguous DNA alphabet" { let dna = @src.iupac_ambiguous_dna() assert_true(dna.name == "IUPACAmbiguousDNA") @@ -34,6 +37,7 @@ test "IUPAC ambiguous DNA alphabet" { assert_true(dna.is_valid("N")) } +///| test "IUPAC protein alphabet" { let protein = @src.iupac_protein() assert_true(protein.name == "IUPACProtein") @@ -43,6 +47,7 @@ test "IUPAC protein alphabet" { assert_true(protein.is_valid("X")) } +///| test "Gapped DNA alphabet" { let dna = @src.gapped_dna() assert_true(dna.is_gapped) @@ -50,6 +55,7 @@ test "Gapped DNA alphabet" { assert_true(dna.is_valid("A")) } +///| test "Reduced protein alphabet" { let protein = @src.reduced_protein() assert_true(protein.letters.length() == 20) @@ -57,6 +63,7 @@ test "Reduced protein alphabet" { assert_false(protein.is_valid("X")) } +///| test "Three to one letter code" { let mapping = @src.three_to_one() let ala = mapping.get("Ala") @@ -67,6 +74,7 @@ test "Three to one letter code" { assert_true(ter is Some("*")) } +///| test "One to three letter code" { let mapping = @src.one_to_three() let a = mapping.get("A") diff --git a/test/moonbit/ancombc_test.mbt b/test/moonbit/ancombc_test.mbt index 26a1d00f..50267adb 100644 --- a/test/moonbit/ancombc_test.mbt +++ b/test/moonbit/ancombc_test.mbt @@ -356,8 +356,16 @@ test "ancombc_sample_data_counts_positive" { test "ancombc_sample_data_differential_pattern" { let data = @src.ancombc_sample_data() // Feature 0 (Bacteroides): control ~120, treatment ~250 - let ctrl_mean = (data.get_count(0, 0) + data.get_count(0, 1) + data.get_count(0, 2) + data.get_count(0, 3)).to_double() / 4.0 - let trt_mean = (data.get_count(0, 4) + data.get_count(0, 5) + data.get_count(0, 6) + data.get_count(0, 7)).to_double() / 4.0 + let ctrl_mean = (data.get_count(0, 0) + + data.get_count(0, 1) + + data.get_count(0, 2) + + data.get_count(0, 3)).to_double() / + 4.0 + let trt_mean = (data.get_count(0, 4) + + data.get_count(0, 5) + + data.get_count(0, 6) + + data.get_count(0, 7)).to_double() / + 4.0 assert_true(trt_mean > ctrl_mean) } diff --git a/test/moonbit/apeglm_test.mbt b/test/moonbit/apeglm_test.mbt index e9bb2a90..6921a113 100644 --- a/test/moonbit/apeglm_test.mbt +++ b/test/moonbit/apeglm_test.mbt @@ -18,18 +18,14 @@ fn apeglm_test_close( ///| fn apeglm_test_config() -> @src.ApeglmConfig { - @src.ApeglmConfig::create( - coefficient=2, - threshold=@math.ln(2.0), - ) catch { + @src.ApeglmConfig::create(coefficient=2, threshold=@math.ln(2.0)) catch { _ => abort("test configuration should be valid") } } ///| fn apeglm_test_result() -> @src.ApeglmResult { - let (counts, design, dispersions, genes, coefficients) = - @src.apeglm_example_data() + let (counts, design, dispersions, genes, coefficients) = @src.apeglm_example_data() let config = apeglm_test_config() @src.apeglm_fit( counts, @@ -55,10 +51,7 @@ fn apeglm_test_gene( } ///| -fn apeglm_test_zero_matrix( - rows : Int, - columns : Int, -) -> Array[Array[Double]] { +fn apeglm_test_zero_matrix(rows : Int, columns : Int) -> Array[Array[Double]] { let matrix : Array[Array[Double]] = [] for _ in 0.. abort("default coefficient fit should succeed") @@ -379,8 +366,7 @@ test "apeglm: local posterior probabilities are bounded" { assert_true(gene.fsr >= 0.0 && gene.fsr <= 0.5) assert_true(gene.s_value >= 0.0 && gene.s_value <= 0.5) assert_true( - gene.threshold_probability >= 0.0 && - gene.threshold_probability <= 1.0, + gene.threshold_probability >= 0.0 && gene.threshold_probability <= 1.0, ) } } @@ -420,10 +406,9 @@ test "apeglm: s-values support empty and tied inputs" { ///| test "apeglm: empirical Bayes prior variance is positive" { - let variance = @src.apeglm_prior_variance( - [1.5, -1.2, 0.1, 0.0], - [0.2, 0.3, 0.5, 0.6], - ) catch { + let variance = @src.apeglm_prior_variance([1.5, -1.2, 0.1, 0.0], [ + 0.2, 0.3, 0.5, 0.6, + ]) catch { _ => abort("prior variance estimation should succeed") } assert_true(variance >= 1.0e-6) @@ -432,16 +417,10 @@ test "apeglm: empirical Bayes prior variance is positive" { ///| test "apeglm: empirical prior variance responds to effect spread" { - let narrow = @src.apeglm_prior_variance( - [0.1, -0.1, 0.0], - [0.5, 0.5, 0.5], - ) catch { + let narrow = @src.apeglm_prior_variance([0.1, -0.1, 0.0], [0.5, 0.5, 0.5]) catch { _ => abort("narrow prior estimate should succeed") } - let broad = @src.apeglm_prior_variance( - [3.0, -3.0, 2.5], - [0.5, 0.5, 0.5], - ) catch { + let broad = @src.apeglm_prior_variance([3.0, -3.0, 2.5], [0.5, 0.5, 0.5]) catch { _ => abort("broad prior estimate should succeed") } assert_true(broad > narrow) @@ -496,8 +475,7 @@ test "apeglm: adaptive fit reports learned prior" { ///| test "apeglm: fixed prior preserves configured scale" { - let (counts, design, dispersions, genes, coefficients) = - @src.apeglm_example_data() + let (counts, design, dispersions, genes, coefficients) = @src.apeglm_example_data() let config = @src.ApeglmConfig::create( coefficient=2, prior_scale=0.4, @@ -523,10 +501,7 @@ test "apeglm: fixed prior preserves configured scale" { ///| test "apeglm: adaptive multiplier obeys scale cap" { let (counts, design, dispersions, _, _) = @src.apeglm_example_data() - let config = @src.ApeglmConfig::create( - coefficient=2, - multiplier=100.0, - ) catch { + let config = @src.ApeglmConfig::create(coefficient=2, multiplier=100.0) catch { _ => abort("multiplier configuration should succeed") } let result = @src.apeglm_fit(counts, design, dispersions, config~) catch { @@ -605,27 +580,13 @@ test "apeglm: likelihood offsets shift the linear predictor" { ///| test "apeglm: likelihood rejects incompatible dimensions" { let rows = try { - ignore( - @src.apeglm_log_likelihood_nb( - [1.0, 2.0], - [[1.0]], - [0.0], - 0.1, - ), - ) + ignore(@src.apeglm_log_likelihood_nb([1.0, 2.0], [[1.0]], [0.0], 0.1)) false } catch { ApeglmError(_) => true } let columns = try { - ignore( - @src.apeglm_log_likelihood_nb( - [1.0], - [[1.0, 0.0]], - [0.0], - 0.1, - ), - ) + ignore(@src.apeglm_log_likelihood_nb([1.0], [[1.0, 0.0]], [0.0], 0.1)) false } catch { ApeglmError(_) => true @@ -644,13 +605,9 @@ test "apeglm: likelihood rejects invalid dispersion and auxiliaries" { } let offsets = try { ignore( - @src.apeglm_log_likelihood_nb( - [1.0, 2.0], - [[1.0], [1.0]], - [0.0], - 0.1, - offsets=[0.0], - ), + @src.apeglm_log_likelihood_nb([1.0, 2.0], [[1.0], [1.0]], [0.0], 0.1, offsets=[ + 0.0, + ]), ) false } catch { @@ -658,13 +615,9 @@ test "apeglm: likelihood rejects invalid dispersion and auxiliaries" { } let weights = try { ignore( - @src.apeglm_log_likelihood_nb( - [1.0, 2.0], - [[1.0], [1.0]], - [0.0], - 0.1, - weights=[1.0], - ), + @src.apeglm_log_likelihood_nb([1.0, 2.0], [[1.0], [1.0]], [0.0], 0.1, weights=[ + 1.0, + ]), ) false } catch { @@ -677,8 +630,7 @@ test "apeglm: likelihood rejects invalid dispersion and auxiliaries" { ///| test "apeglm: explicit zero offsets match omitted offsets" { - let (counts, design, dispersions, genes, coefficients) = - @src.apeglm_example_data() + let (counts, design, dispersions, genes, coefficients) = @src.apeglm_example_data() let config = apeglm_test_config() let baseline = @src.apeglm_fit( counts, @@ -701,11 +653,7 @@ test "apeglm: explicit zero offsets match omitted offsets" { ) catch { _ => abort("zero offset fit should succeed") } - apeglm_test_close( - baseline.genes[0].map[2], - shifted.genes[0].map[2], - 1.0e-12, - ) + apeglm_test_close(baseline.genes[0].map[2], shifted.genes[0].map[2], 1.0e-12) } ///| @@ -732,8 +680,7 @@ test "apeglm: zero observation weights suppress an outlier" { ///| test "apeglm: custom target coefficient is honored" { - let (counts, design, dispersions, genes, coefficients) = - @src.apeglm_example_data() + let (counts, design, dispersions, genes, coefficients) = @src.apeglm_example_data() let config = @src.ApeglmConfig::create(coefficient=1) catch { _ => abort("batch target configuration should succeed") } @@ -801,8 +748,7 @@ test "apeglm: ranking prioritizes low directional error" { assert_eq(ranked.length(), 8) assert_true(ranked[0].s_value <= ranked[1].s_value) assert_true( - ranked[0].gene_name == "strong_up" || - ranked[0].gene_name == "strong_down", + ranked[0].gene_name == "strong_up" || ranked[0].gene_name == "strong_down", ) } @@ -810,10 +756,7 @@ test "apeglm: ranking prioritizes low directional error" { test "apeglm: selection applies s-value and effect filters" { let result = apeglm_test_result() let broad = result.select(maximum_s_value=0.1) - let strict = result.select( - maximum_s_value=0.1, - minimum_absolute_effect=1.0, - ) + let strict = result.select(maximum_s_value=0.1, minimum_absolute_effect=1.0) assert_true(broad.length() >= strict.length()) for gene in strict { assert_true(gene.s_value <= 0.1) @@ -896,8 +839,7 @@ test "apeglm: repeated fitting is deterministic" { ///| test "apeglm: deterministic start counts preserve signal modes" { - let (counts, design, dispersions, genes, coefficients) = - @src.apeglm_example_data() + let (counts, design, dispersions, genes, coefficients) = @src.apeglm_example_data() let one = @src.ApeglmConfig::create(coefficient=2, random_starts=1) catch { _ => abort("single start configuration should succeed") } @@ -933,10 +875,7 @@ test "apeglm: deterministic start counts preserve signal modes" { ///| test "apeglm: DESeq2 wrapper uses counts names and offsets" { let dds = @src.DESeqDataSet::new( - [ - [48, 52, 45, 54, 198, 220, 205, 230], - [160, 148, 171, 155, 39, 44, 35, 41], - ], + [[48, 52, 45, 54, 198, 220, 205, 230], [160, 148, 171, 155, 39, 44, 35, 41]], ["up", "down"], ["s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8"], [ @@ -951,11 +890,9 @@ test "apeglm: DESeq2 wrapper uses counts names and offsets" { ], ) let config = apeglm_test_config() - let result = @src.apeglm_from_deseq2( - dds, - config~, - coefficient_names=["intercept", "batch", "condition"], - ) catch { + let result = @src.apeglm_from_deseq2(dds, config~, coefficient_names=[ + "intercept", "batch", "condition", + ]) catch { _ => abort("DESeq2 integration should succeed") } assert_eq(result.gene_names, ["up", "down"]) @@ -965,8 +902,7 @@ test "apeglm: DESeq2 wrapper uses counts names and offsets" { ///| test "apeglm: SummarizedExperiment output adds posterior assays" { - let (_, design, dispersions, genes, coefficients) = - @src.apeglm_example_data() + let (_, design, dispersions, genes, coefficients) = @src.apeglm_example_data() let config = apeglm_test_config() let output = @src.apeglm_summarized_experiment( apeglm_test_experiment(), @@ -978,13 +914,10 @@ test "apeglm: SummarizedExperiment output adds posterior assays" { ) catch { _ => abort("SummarizedExperiment integration should succeed") } - for name in [ - "apeglm_map", - "apeglm_sd", - "apeglm_fsr", - "apeglm_svalue", - "apeglm_fsos", - ] { + for + name in [ + "apeglm_map", "apeglm_sd", "apeglm_fsr", "apeglm_svalue", "apeglm_fsos", + ] { match @src.se_assay(output.experiment, name) { Some(assay) => { assert_eq(assay.length(), 8) @@ -997,8 +930,7 @@ test "apeglm: SummarizedExperiment output adds posterior assays" { ///| test "apeglm: SummarizedExperiment integration is immutable" { - let (_, design, dispersions, genes, coefficients) = - @src.apeglm_example_data() + let (_, design, dispersions, genes, coefficients) = @src.apeglm_example_data() let experiment = apeglm_test_experiment() let config = apeglm_test_config() let output = @src.apeglm_summarized_experiment( @@ -1059,24 +991,14 @@ test "apeglm: fit rejects empty and single-sample counts" { test "apeglm: fit rejects ragged and fractional counts" { let ragged = try { ignore( - @src.apeglm_fit( - [[1.0, 2.0], [3.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1, 0.1], - ), + @src.apeglm_fit([[1.0, 2.0], [3.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1, 0.1]), ) false } catch { ApeglmError(_) => true } let fractional = try { - ignore( - @src.apeglm_fit( - [[1.5, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - ), - ) + ignore(@src.apeglm_fit([[1.5, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1])) false } catch { ApeglmError(_) => true @@ -1088,25 +1010,13 @@ test "apeglm: fit rejects ragged and fractional counts" { ///| test "apeglm: fit rejects negative and non-finite counts" { let negative = try { - ignore( - @src.apeglm_fit( - [[-1.0, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - ), - ) + ignore(@src.apeglm_fit([[-1.0, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1])) false } catch { ApeglmError(_) => true } let overflow = try { - ignore( - @src.apeglm_fit( - [[1.0e301, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - ), - ) + ignore(@src.apeglm_fit([[1.0e301, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1])) false } catch { ApeglmError(_) => true @@ -1130,13 +1040,7 @@ test "apeglm: fit rejects malformed design matrices" { ApeglmError(_) => true } let ragged = try { - ignore( - @src.apeglm_fit( - [[1.0, 2.0]], - [[1.0, 0.0], [1.0]], - [0.1], - ), - ) + ignore(@src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0], [1.0]], [0.1])) false } catch { ApeglmError(_) => true @@ -1188,24 +1092,14 @@ test "apeglm: fit rejects intercept and out-of-range targets" { test "apeglm: fit rejects malformed dispersions" { let length = try { ignore( - @src.apeglm_fit( - [[1.0, 2.0], [3.0, 4.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - ), + @src.apeglm_fit([[1.0, 2.0], [3.0, 4.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1]), ) false } catch { ApeglmError(_) => true } let value = try { - ignore( - @src.apeglm_fit( - [[1.0, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.0], - ), - ) + ignore(@src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.0])) false } catch { ApeglmError(_) => true @@ -1218,12 +1112,9 @@ test "apeglm: fit rejects malformed dispersions" { test "apeglm: fit validates offsets and observation weights" { let offsets = try { ignore( - @src.apeglm_fit( - [[1.0, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - offsets=[[0.0]], - ), + @src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1], offsets=[ + [0.0], + ]), ) false } catch { @@ -1231,12 +1122,9 @@ test "apeglm: fit validates offsets and observation weights" { } let weight_shape = try { ignore( - @src.apeglm_fit( - [[1.0, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - weights=[[1.0]], - ), + @src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1], weights=[ + [1.0], + ]), ) false } catch { @@ -1244,12 +1132,9 @@ test "apeglm: fit validates offsets and observation weights" { } let all_zero = try { ignore( - @src.apeglm_fit( - [[1.0, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - weights=[[0.0, 0.0]], - ), + @src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1], weights=[ + [0.0, 0.0], + ]), ) false } catch { @@ -1264,12 +1149,9 @@ test "apeglm: fit validates offsets and observation weights" { test "apeglm: fit validates identifier lengths and uniqueness" { let gene_length = try { ignore( - @src.apeglm_fit( - [[1.0, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - gene_names=["a", "b"], - ), + @src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1], gene_names=[ + "a", "b", + ]), ) false } catch { @@ -1290,12 +1172,9 @@ test "apeglm: fit validates identifier lengths and uniqueness" { } let coefficient_length = try { ignore( - @src.apeglm_fit( - [[1.0, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - coefficient_names=["intercept"], - ), + @src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1], coefficient_names=[ + "intercept", + ]), ) false } catch { @@ -1303,12 +1182,9 @@ test "apeglm: fit validates identifier lengths and uniqueness" { } let empty = try { ignore( - @src.apeglm_fit( - [[1.0, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - gene_names=[""], - ), + @src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1], gene_names=[ + "", + ]), ) false } catch { diff --git a/test/moonbit/application_test.mbt b/test/moonbit/application_test.mbt index f65847e9..767c1705 100644 --- a/test/moonbit/application_test.mbt +++ b/test/moonbit/application_test.mbt @@ -1,23 +1,25 @@ ///| /// Tests for Application module. - test "AbstractCommandline creation" { let cmd = @src.create_example_commandline() assert_eq(cmd.executable, "blastn") } +///| test "AbstractCommandline add_arg" { let mut cmd = @src.AbstractCommandline::new("blastn") cmd = cmd.add_arg("-query", Some("query.fasta")) assert_eq(cmd.arguments.length(), 2) } +///| test "AbstractCommandline add_arg no value" { let mut cmd = @src.AbstractCommandline::new("blastn") cmd = cmd.add_arg("-help", None) assert_eq(cmd.arguments.length(), 1) } +///| test "AbstractCommandline build_command" { let mut cmd = @src.AbstractCommandline::new("blastn") cmd = cmd.add_arg("-query", Some("query.fasta")) @@ -28,8 +30,9 @@ test "AbstractCommandline build_command" { assert_true(command.contains("-db")) } +///| test "AbstractCommandline set_stdout" { let mut cmd = @src.AbstractCommandline::new("blastn") cmd = cmd.set_stdout("output.txt") assert_eq(cmd.stdout, "output.txt") -} \ No newline at end of file +} diff --git a/test/moonbit/aucell_test.mbt b/test/moonbit/aucell_test.mbt index ff50bd42..4a31149d 100644 --- a/test/moonbit/aucell_test.mbt +++ b/test/moonbit/aucell_test.mbt @@ -78,10 +78,7 @@ test "aucell_data" { ///| test "aucell_run_basic" { // 2 cells × 3 genes - let expression = [ - [10.0, 2.0, 5.0], - [3.0, 8.0, 1.0], - ] + let expression = [[10.0, 2.0, 5.0], [3.0, 8.0, 1.0]] let cell_names = ["Cell1", "Cell2"] let gene_names = ["GeneA", "GeneB", "GeneC"] @@ -106,10 +103,7 @@ test "aucell_run_basic" { ///| test "aucell_run_multiple_sets" { - let expression = [ - [5.0, 10.0, 3.0], - [8.0, 2.0, 7.0], - ] + let expression = [[5.0, 10.0, 3.0], [8.0, 2.0, 7.0]] let cell_names = ["Cell1", "Cell2"] let gene_names = ["GeneA", "GeneB", "GeneC"] @@ -125,11 +119,7 @@ test "aucell_run_multiple_sets" { ///| test "aucell_normalize_scores" { - let expression = [ - [10.0, 2.0], - [3.0, 8.0], - [5.0, 5.0], - ] + let expression = [[10.0, 2.0], [3.0, 8.0], [5.0, 5.0]] let cell_names = ["C1", "C2", "C3"] let gene_names = ["G1", "G2"] let gs = @src.GeneSet::new("Set1", ["G1"]) diff --git a/test/moonbit/bamsignals_test.mbt b/test/moonbit/bamsignals_test.mbt index 13e5432c..f1400105 100644 --- a/test/moonbit/bamsignals_test.mbt +++ b/test/moonbit/bamsignals_test.mbt @@ -130,7 +130,7 @@ test "bamsig_chromatin_state" { let repressed_regions = [3] let chrom_state = @src.bamsig_analyze_chromatin_states( - signal, promoter_regions, enhancer_regions, repressed_regions + signal, promoter_regions, enhancer_regions, repressed_regions, ) assert_true(chrom_state.bamsig_n_states() > 0) @@ -154,4 +154,4 @@ test "bamsig_params_setters" { let params4 = params.bamsig_set_extend(200) assert_eq(params4.extend_len, 200) -} \ No newline at end of file +} diff --git a/test/moonbit/batchelor_test.mbt b/test/moonbit/batchelor_test.mbt index e651c170..88d7e73d 100644 --- a/test/moonbit/batchelor_test.mbt +++ b/test/moonbit/batchelor_test.mbt @@ -3,29 +3,33 @@ ///| test "batchelor_create_example_data" { - let (batches, batch_names) = @src.batchelor_create_example_data(2, 50, 100, 1.0) - + let (batches, batch_names) = @src.batchelor_create_example_data( + 2, 50, 100, 1.0, + ) + assert_eq(batches.length(), 2) assert_eq(batch_names.length(), 2) assert_eq(batches[0].length(), 50) assert_eq(batches[1].length(), 50) assert_eq(batches[0][0].length(), 100) assert_eq(batches[1][0].length(), 100) - + assert_eq(batch_names[0], "Batch_0") assert_eq(batch_names[1], "Batch_1") } ///| test "rescale_batches" { - let (batches, batch_names) = @src.batchelor_create_example_data(2, 50, 100, 1.0) - + let (batches, batch_names) = @src.batchelor_create_example_data( + 2, 50, 100, 1.0, + ) + let result = @src.rescale_batches(batches, batch_names) - + assert_eq(result.corrected.length(), 100) assert_eq(result.batch_indices.length(), 100) assert_eq(result.corrected[0].length(), 100) - + let mut batch0_count = 0 let mut batch1_count = 0 for idx in result.batch_indices { @@ -35,7 +39,7 @@ test "rescale_batches" { batch1_count = batch1_count + 1 } } - + assert_eq(batch0_count, 50) assert_eq(batch1_count, 50) } @@ -43,11 +47,11 @@ test "rescale_batches" { ///| test "find_mutual_nearest_neighbors" { let (batches, _) = @src.batchelor_create_example_data(2, 20, 50, 0.5) - + let mnn_pairs = @src.find_mutual_nearest_neighbors(batches[0], batches[1], 3) - + assert_true(mnn_pairs.length() >= 0) - + for pair in mnn_pairs { assert_true(pair.0 >= 0 && pair.0 < 20) assert_true(pair.1 >= 0 && pair.1 < 20) @@ -56,15 +60,17 @@ test "find_mutual_nearest_neighbors" { ///| test "fast_mnn" { - let (batches, batch_names) = @src.batchelor_create_example_data(2, 50, 100, 1.0) - + let (batches, batch_names) = @src.batchelor_create_example_data( + 2, 50, 100, 1.0, + ) + let result = @src.fast_mnn(batches, batch_names, 5, 20) - + assert_eq(result.corrected.length(), 100) assert_eq(result.batch_indices.length(), 100) assert_eq(result.corrected[0].length(), 20) assert_eq(result.var_explained.length(), 20) - + let mut sum_var = 0.0 for var in result.var_explained { assert_true(var >= 0.0 && var <= 1.0) @@ -75,13 +81,18 @@ test "fast_mnn" { ///| test "compute_batch_mixing_score" { - let (batches, batch_names) = @src.batchelor_create_example_data(2, 50, 100, 1.0) - + let (batches, batch_names) = @src.batchelor_create_example_data( + 2, 50, 100, 1.0, + ) + let result = @src.fast_mnn(batches, batch_names, 5, 20) - let score = @src.compute_batch_mixing_score(result.corrected, result.batch_indices) - + let score = @src.compute_batch_mixing_score( + result.corrected, + result.batch_indices, + ) + assert_true(score >= 0.0 && score <= 1.0) - + let raw_data : Array[Array[Double]] = Array::new() for cell in batches[0] { raw_data.push(cell) @@ -89,7 +100,7 @@ test "compute_batch_mixing_score" { for cell in batches[1] { raw_data.push(cell) } - + let raw_batch_indices : Array[Int] = Array::new() let mut idx = 0 while idx < 50 { @@ -101,16 +112,18 @@ test "compute_batch_mixing_score" { raw_batch_indices.push(1) idx = idx + 1 } - + let raw_score = @src.compute_batch_mixing_score(raw_data, raw_batch_indices) - + assert_true(score > raw_score * 0.8) } ///| test "rescale_batches_correction_effect" { - let (batches, batch_names) = @src.batchelor_create_example_data(2, 50, 100, 2.0) - + let (batches, batch_names) = @src.batchelor_create_example_data( + 2, 50, 100, 2.0, + ) + let raw_data : Array[Array[Double]] = Array::new() for cell in batches[0] { raw_data.push(cell) @@ -118,7 +131,7 @@ test "rescale_batches_correction_effect" { for cell in batches[1] { raw_data.push(cell) } - + let raw_batch_indices : Array[Int] = Array::new() let mut idx = 0 while idx < 50 { @@ -130,19 +143,24 @@ test "rescale_batches_correction_effect" { raw_batch_indices.push(1) idx = idx + 1 } - + let raw_score = @src.compute_batch_mixing_score(raw_data, raw_batch_indices) - + let result = @src.rescale_batches(batches, batch_names) - let corrected_score = @src.compute_batch_mixing_score(result.corrected, result.batch_indices) - + let corrected_score = @src.compute_batch_mixing_score( + result.corrected, + result.batch_indices, + ) + assert_true(corrected_score > raw_score) } ///| test "fast_mnn_correction_effect" { - let (batches, batch_names) = @src.batchelor_create_example_data(2, 50, 100, 2.0) - + let (batches, batch_names) = @src.batchelor_create_example_data( + 2, 50, 100, 2.0, + ) + let raw_data : Array[Array[Double]] = Array::new() for cell in batches[0] { raw_data.push(cell) @@ -150,7 +168,7 @@ test "fast_mnn_correction_effect" { for cell in batches[1] { raw_data.push(cell) } - + let raw_batch_indices : Array[Int] = Array::new() let mut idx = 0 while idx < 50 { @@ -162,11 +180,14 @@ test "fast_mnn_correction_effect" { raw_batch_indices.push(1) idx = idx + 1 } - + let raw_score = @src.compute_batch_mixing_score(raw_data, raw_batch_indices) - + let result = @src.fast_mnn(batches, batch_names, 5, 20) - let corrected_score = @src.compute_batch_mixing_score(result.corrected, result.batch_indices) - + let corrected_score = @src.compute_batch_mixing_score( + result.corrected, + result.batch_indices, + ) + assert_true(corrected_score > raw_score) } diff --git a/test/moonbit/bayes_space_test.mbt b/test/moonbit/bayes_space_test.mbt index b0ed69f4..57203e3c 100644 --- a/test/moonbit/bayes_space_test.mbt +++ b/test/moonbit/bayes_space_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Bioconductor BayesSpace module - Spatial transcriptomics clustering. - test "spot_coord_create" { let s = @src.spot_coord("spot_1_2", 1, 2, 2.0, 1.0) assert_eq(s.spot_id, "spot_1_2") @@ -10,6 +9,7 @@ test "spot_coord_create" { assert_true((s.y - 1.0).abs() < 1.0e-9) } +///| test "bayes_space_hex_neighbors_basic" { // 3x3 grid of spots let spots : Array[@src.SpotCoord] = [] @@ -17,7 +17,15 @@ test "bayes_space_hex_neighbors_basic" { while r < 3 { let mut c = 0 while c < 3 { - spots.push(@src.spot_coord("s_" + r.to_string() + "_" + c.to_string(), r, c, c.to_double(), r.to_double())) + spots.push( + @src.spot_coord( + "s_" + r.to_string() + "_" + c.to_string(), + r, + c, + c.to_double(), + r.to_double(), + ), + ) c = c + 1 } r = r + 1 @@ -31,13 +39,22 @@ test "bayes_space_hex_neighbors_basic" { assert_true(neighbors[corner_idx].length() < neighbors[center_idx].length()) } +///| test "bayes_space_square_neighbors_basic" { let spots : Array[@src.SpotCoord] = [] let mut r = 0 while r < 3 { let mut c = 0 while c < 3 { - spots.push(@src.spot_coord("s_" + r.to_string() + "_" + c.to_string(), r, c, c.to_double(), r.to_double())) + spots.push( + @src.spot_coord( + "s_" + r.to_string() + "_" + c.to_string(), + r, + c, + c.to_double(), + r.to_double(), + ), + ) c = c + 1 } r = r + 1 @@ -48,6 +65,7 @@ test "bayes_space_square_neighbors_basic" { assert_eq(neighbors[center_idx].length(), 4) } +///| test "bayes_space_sample_data_shape" { let (expr, spots) = @src.bayes_space_sample_data() assert_eq(expr.length(), 16) // 4x4 grid @@ -55,10 +73,18 @@ test "bayes_space_sample_data_shape" { assert_eq(expr[0].length(), 3) // 3 features per spot } +///| test "bayes_space_run_basic" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=20, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=20, + seed=42, + ) assert_eq(result.q, 2) assert_eq(result.spot_ids.length(), 16) assert_eq(result.clusters.length(), 16) @@ -80,21 +106,37 @@ test "bayes_space_run_basic" { } } +///| test "bayes_space_run_convergence_or_max_iters" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=50, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=50, + seed=42, + ) // Should either converge or hit max iters assert_true(result.n_iterations > 0) assert_true(result.n_iterations <= 50) } +///| test "bayes_space_two_clusters_separated" { // The sample data has top-left (low) and bottom-right (high) clusters. // After clustering with q=2, the corner spots should be in different clusters. let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=30, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=30, + seed=42, + ) // Find indices of corner spots let mut tl_idx = -1 let mut br_idx = -1 @@ -114,26 +156,50 @@ test "bayes_space_two_clusters_separated" { assert_not_eq(result.clusters[tl_idx], result.clusters[br_idx]) } +///| test "bayes_space_get_cluster_by_id" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=20, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=20, + seed=42, + ) let c = @src.bayes_space_get_cluster(result, "spot_0_0") assert_true(c >= 0 && c < 2) } +///| test "bayes_space_get_cluster_unknown_id" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=10, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=10, + seed=42, + ) let c = @src.bayes_space_get_cluster(result, "UNKNOWN_SPOT") assert_eq(c, -1) } +///| test "bayes_space_spots_in_cluster" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=20, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=20, + seed=42, + ) let c0 = @src.bayes_space_spots_in_cluster(result, 0) let c1 = @src.bayes_space_spots_in_cluster(result, 1) // Both clusters should have at least one spot @@ -143,20 +209,36 @@ test "bayes_space_spots_in_cluster" { assert_eq(c0.length() + c1.length(), 16) } +///| test "bayes_space_cluster_counts" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=20, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=20, + seed=42, + ) let counts = @src.bayes_space_cluster_counts(result) assert_eq(counts.length(), 2) // Sum of counts should equal total spots assert_eq(counts[0] + counts[1], 16) } +///| test "bayes_space_render_clusters" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=10, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=10, + seed=42, + ) let render = @src.bayes_space_render_clusters(result, spots) // Should contain 4 rows separated by newlines assert_true(render.length() > 0) @@ -171,11 +253,19 @@ test "bayes_space_render_clusters" { assert_eq(nl_count, 4) } +///| test "bayes_space_q_equals_3" { // Test with q=3 clusters let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 3, neighbors, max_iters=15, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 3, + neighbors, + max_iters=15, + seed=42, + ) assert_eq(result.q, 3) assert_eq(result.cluster_centers.length(), 3) // Each spot's cluster should be in [0, 3) @@ -186,12 +276,14 @@ test "bayes_space_q_equals_3" { } } +///| test "bayes_space_empty_grid_neighbors" { // Empty spots list → empty neighbor list let neighbors = @src.bayes_space_hex_neighbors([]) assert_eq(neighbors.length(), 0) } +///| test "bayes_space_single_spot" { // Single spot → no neighbors let spots = [@src.spot_coord("only", 0, 0, 0.0, 0.0)] @@ -200,20 +292,43 @@ test "bayes_space_single_spot" { assert_eq(neighbors[0].length(), 0) } +///| test "bayes_space_log_likelihood_finite" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=20, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=20, + seed=42, + ) // Log-likelihood should be a finite number (not NaN/Inf) assert_false(result.log_likelihood.is_nan()) assert_false(result.log_likelihood.abs() > 1.0e300) } +///| test "bayes_space_reproducible_with_same_seed" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let r1 = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=15, seed=123) - let r2 = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=15, seed=123) + let r1 = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=15, + seed=123, + ) + let r2 = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=15, + seed=123, + ) // Same seed → same cluster assignments let mut i = 0 while i < r1.clusters.length() { diff --git a/test/moonbit/bayseq_test.mbt b/test/moonbit/bayseq_test.mbt index b67b42ea..65e94061 100644 --- a/test/moonbit/bayseq_test.mbt +++ b/test/moonbit/bayseq_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Bioconductor baySeq module - Bayesian differential expression. - test "estimate_dispersion_basic" { // Two groups with different means let a = [100.0, 120.0, 110.0, 90.0] @@ -10,6 +9,7 @@ test "estimate_dispersion_basic" { assert_true(disp <= 100.0) } +///| test "estimate_dispersion_low_counts" { let a = [1.0, 2.0, 1.5, 1.2] let b = [1.0, 1.8, 1.3, 1.1] @@ -18,6 +18,7 @@ test "estimate_dispersion_low_counts" { assert_true(disp > 0.0) } +///| test "estimate_dispersion_single_sample" { let a = [100.0] let b = [200.0] @@ -25,6 +26,7 @@ test "estimate_dispersion_single_sample" { assert_true(disp == 1.0) } +///| test "estimate_prior_basic" { let (counts, groups, _) = @src.bayseq_sample_data() let (shape, rate) = @src.bayseq_estimate_prior(counts, groups) @@ -32,6 +34,7 @@ test "estimate_prior_basic" { assert_true(rate > 0.0) } +///| test "estimate_prior_empty" { let counts : Array[Array[Double]] = [] let (shape, rate) = @src.bayseq_estimate_prior(counts, []) @@ -39,6 +42,7 @@ test "estimate_prior_empty" { assert_true(rate == 0.5) } +///| test "log_likelihood_ratio_de" { let a = [100.0, 120.0, 110.0, 90.0] let b = [500.0, 520.0, 510.0, 490.0] @@ -48,6 +52,7 @@ test "log_likelihood_ratio_de" { assert_true(llr > 0.0) } +///| test "log_likelihood_ratio_same" { let a = [100.0, 120.0, 110.0, 90.0] let b = [100.0, 120.0, 110.0, 90.0] @@ -57,28 +62,33 @@ test "log_likelihood_ratio_same" { assert_true(llr >= -1.0 && llr <= 1.0) } +///| test "lgamma_positive" { let val = @src.bayseq_lgamma(5.0) assert_true(val > 0.0) } +///| test "lgamma_one" { // lgamma(1) = 0 since gamma(1) = 1, log(1) = 0 let val = @src.bayseq_lgamma(1.0) assert_true(val >= -0.1 && val <= 0.1) } +///| test "lgamma_large" { let val = @src.bayseq_lgamma(100.0) // lgamma(100) ≈ 363.739 assert_true(val > 100.0) } +///| test "nb_log_likelihood_zero_mean" { let ll = @src.bayseq_nb_log_likelihood([1.0, 2.0, 3.0], 0.0, 10.0) assert_true(ll == 0.0) } +///| test "test_basic" { let (counts, groups, names) = @src.bayseq_sample_data() let result = @src.bayseq_test(counts, groups, names) @@ -87,6 +97,7 @@ test "test_basic" { assert_true(result.n_de_genes <= 30) } +///| test "test_lfc_calculation" { let (counts, groups, names) = @src.bayseq_sample_data() let result = @src.bayseq_test(counts, groups, names) @@ -95,6 +106,7 @@ test "test_lfc_calculation" { assert_true(g0.log_fold_change > 0.0) } +///| test "test_posterior_prob" { let (counts, groups, names) = @src.bayseq_sample_data() let result = @src.bayseq_test(counts, groups, names) @@ -102,6 +114,7 @@ test "test_posterior_prob" { assert_true(g0.posterior_prob_de >= 0.0 && g0.posterior_prob_de <= 1.0) } +///| test "get_de_genes" { let (counts, groups, names) = @src.bayseq_sample_data() let result = @src.bayseq_test(counts, groups, names) @@ -109,6 +122,7 @@ test "get_de_genes" { assert_eq(de_genes.length(), result.n_de_genes) } +///| test "get_top_de" { let (counts, groups, names) = @src.bayseq_sample_data() let result = @src.bayseq_test(counts, groups, names) @@ -116,6 +130,7 @@ test "get_top_de" { assert_eq(top.length(), 5) } +///| test "get_top_de_fewer_than_n" { let (counts, groups, names) = @src.bayseq_sample_data() let result = @src.bayseq_test(counts, groups, names) @@ -123,6 +138,7 @@ test "get_top_de_fewer_than_n" { assert_eq(top.length(), 30) } +///| test "sample_data_dimensions" { let (counts, groups, names) = @src.bayseq_sample_data() assert_eq(counts.length(), 30) @@ -131,6 +147,7 @@ test "sample_data_dimensions" { assert_eq(names.length(), 30) } +///| test "summary" { let (counts, groups, names) = @src.bayseq_sample_data() let result = @src.bayseq_test(counts, groups, names) diff --git a/test/moonbit/beachmat_test.mbt b/test/moonbit/beachmat_test.mbt index c1c2a336..004dab76 100644 --- a/test/moonbit/beachmat_test.mbt +++ b/test/moonbit/beachmat_test.mbt @@ -11,24 +11,28 @@ test "bmat_param_creation" { assert_eq(p.col_block_size(), 0) } +///| test "bmat_param_with_blocks" { let p = @src.BmatParam::with_blocks(10, 20) assert_eq(p.row_block_size(), 10) assert_eq(p.col_block_size(), 20) } +///| test "bmat_param_column_param" { let p = @src.BmatParam::column_param(15) assert_eq(p.row_block_size(), 0) assert_eq(p.col_block_size(), 15) } +///| test "bmat_param_row_param" { let p = @src.BmatParam::row_param(25) assert_eq(p.row_block_size(), 25) assert_eq(p.col_block_size(), 0) } +///| test "bmat_param_accessors" { let p = @src.BmatParam::with_blocks(5, 10) assert_eq(p.row_block_size(), 5) @@ -39,6 +43,7 @@ test "bmat_param_accessors" { // Bmat creation and basic accessors // --------------------------------------------------------------------------- +///| test "bmat_creation_from_array" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -46,6 +51,7 @@ test "bmat_creation_from_array" { assert_eq(bmat.dim_cols(), 3) } +///| test "bmat_creation_zeros" { let bmat = @src.Bmat::zeros(4, 5) assert_eq(bmat.dim_rows(), 4) @@ -54,18 +60,21 @@ test "bmat_creation_zeros" { assert_eq(bmat.get(3, 4), 0.0) } +///| test "bmat_dim_rows" { let data = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) assert_eq(bmat.dim_rows(), 3) } +///| test "bmat_dim_cols" { let data = [[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) assert_eq(bmat.dim_cols(), 4) } +///| test "bmat_get" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -80,6 +89,7 @@ test "bmat_get" { assert_eq(bmat.get(2, 2), 9.0) } +///| test "bmat_set" { let data = [[1.0, 2.0], [3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -91,6 +101,7 @@ test "bmat_set" { assert_eq(bmat.get(1, 1), 20.0) } +///| test "bmat_get_col" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -109,6 +120,7 @@ test "bmat_get_col" { assert_eq(col2[2], 9.0) } +///| test "bmat_get_row" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -131,6 +143,7 @@ test "bmat_get_row" { // BmatBlock creation and properties // --------------------------------------------------------------------------- +///| test "bmat_block_properties" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -160,6 +173,7 @@ test "bmat_block_properties" { assert_eq(block_ncols[1], 1) } +///| test "bmat_block_get_data" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -200,6 +214,7 @@ test "bmat_block_get_data" { // Block processing // --------------------------------------------------------------------------- +///| test "bmat_apply_col_blocks_basic" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -216,6 +231,7 @@ test "bmat_apply_col_blocks_basic" { assert_eq(col_ends[1], 3) } +///| test "bmat_apply_col_blocks_three_blocks" { let data = [[1.0, 2.0, 3.0, 4.0, 5.0], [6.0, 7.0, 8.0, 9.0, 10.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -229,6 +245,7 @@ test "bmat_apply_col_blocks_three_blocks" { assert_eq(col_starts[2], 4) } +///| test "bmat_apply_col_blocks_verification" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -253,6 +270,7 @@ test "bmat_apply_col_blocks_verification" { assert_eq(all_vals[8], 9.0) } +///| test "bmat_apply_row_blocks_basic" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -269,6 +287,7 @@ test "bmat_apply_row_blocks_basic" { assert_eq(row_ends[1], 3) } +///| test "bmat_apply_row_blocks_verification" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -293,6 +312,7 @@ test "bmat_apply_row_blocks_verification" { assert_eq(all_vals[8], 9.0) } +///| test "bmat_apply_row_blocks_three_blocks" { let data = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0], [9.0, 10.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -306,13 +326,12 @@ test "bmat_apply_row_blocks_three_blocks" { assert_eq(row_starts[2], 4) } +///| test "bmat_foreach" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) let values : Array[Double] = [] - @src.bmat_foreach(bmat, fn(row, col, val) { - values.push(val) - }) + @src.bmat_foreach(bmat, fn(row, col, val) { values.push(val) }) assert_eq(values.length(), 6) assert_eq(values[0], 1.0) assert_eq(values[1], 2.0) @@ -322,6 +341,7 @@ test "bmat_foreach" { assert_eq(values[5], 6.0) } +///| test "bmat_foreach_row_col_verification" { let data = [[10.0, 20.0], [30.0, 40.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -352,6 +372,7 @@ test "bmat_foreach_row_col_verification" { // BmatIterator // --------------------------------------------------------------------------- +///| test "bmat_iterator_basic" { let data = [[1.0, 2.0], [3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -369,6 +390,7 @@ test "bmat_iterator_basic" { assert_true(v4 is None) } +///| test "bmat_iterator_has_next" { let data = [[1.0, 2.0, 3.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -382,6 +404,7 @@ test "bmat_iterator_has_next" { assert_false(iter.has_next()) } +///| test "bmat_iterator_exhausted_next" { let data = [[1.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -394,6 +417,7 @@ test "bmat_iterator_exhausted_next" { assert_true(v2 is None) } +///| test "bmat_iterator_cur_row_col" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -417,6 +441,7 @@ test "bmat_iterator_cur_row_col" { assert_eq(iter.cur_col(), 2) } +///| test "bmat_iterator_full_traversal" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -442,6 +467,7 @@ test "bmat_iterator_full_traversal" { // Conversion // --------------------------------------------------------------------------- +///| test "bmat_from_array" { let data = [[5.0, 10.0], [15.0, 20.0]] let bmat = @src.bmat_from_array(data) @@ -453,6 +479,7 @@ test "bmat_from_array" { assert_eq(bmat.get(1, 1), 20.0) } +///| test "bmat_to_array" { let data = [[2.0, 4.0, 6.0], [8.0, 10.0, 12.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -467,6 +494,7 @@ test "bmat_to_array" { assert_eq(arr[1][2], 12.0) } +///| test "bmat_roundtrip" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.bmat_from_array(data) @@ -483,6 +511,7 @@ test "bmat_roundtrip" { // Subset, transpose, bind // --------------------------------------------------------------------------- +///| test "bmat_subset" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -495,6 +524,7 @@ test "bmat_subset" { assert_eq(sub.get(1, 1), 5.0) } +///| test "bmat_subset_bottom_right" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -507,6 +537,7 @@ test "bmat_subset_bottom_right" { assert_eq(sub.get(1, 1), 9.0) } +///| test "bmat_transpose" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -521,6 +552,7 @@ test "bmat_transpose" { assert_eq(t.get(2, 1), 6.0) } +///| test "bmat_transpose_square" { let data = [[1.0, 2.0], [3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -531,6 +563,7 @@ test "bmat_transpose_square" { assert_eq(t.get(1, 1), 4.0) } +///| test "bmat_bind_cols" { let left = @src.Bmat::new([[1.0, 2.0], [3.0, 4.0]], @src.BmatParam::new()) let right = @src.Bmat::new([[5.0], [6.0]], @src.BmatParam::new()) @@ -545,6 +578,7 @@ test "bmat_bind_cols" { assert_eq(result.get(1, 2), 6.0) } +///| test "bmat_bind_cols_equal_width" { let left = @src.Bmat::new([[1.0, 2.0], [3.0, 4.0]], @src.BmatParam::new()) let right = @src.Bmat::new([[5.0, 6.0], [7.0, 8.0]], @src.BmatParam::new()) @@ -561,6 +595,7 @@ test "bmat_bind_cols_equal_width" { assert_eq(result.get(1, 3), 8.0) } +///| test "bmat_bind_rows" { let top = @src.Bmat::new([[1.0, 2.0], [3.0, 4.0]], @src.BmatParam::new()) let bottom = @src.Bmat::new([[5.0, 6.0]], @src.BmatParam::new()) @@ -575,6 +610,7 @@ test "bmat_bind_rows" { assert_eq(result.get(2, 1), 6.0) } +///| test "bmat_bind_rows_equal_height" { let top = @src.Bmat::new([[1.0, 2.0], [3.0, 4.0]], @src.BmatParam::new()) let bottom = @src.Bmat::new([[5.0, 6.0], [7.0, 8.0]], @src.BmatParam::new()) @@ -595,6 +631,7 @@ test "bmat_bind_rows_equal_height" { // Element-wise operations // --------------------------------------------------------------------------- +///| test "bmat_apply_elementwise_double" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -609,6 +646,7 @@ test "bmat_apply_elementwise_double" { assert_eq(result.get(1, 2), 12.0) } +///| test "bmat_apply_elementwise_square" { let data = [[1.0, 2.0], [3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -619,6 +657,7 @@ test "bmat_apply_elementwise_square" { assert_eq(result.get(1, 1), 16.0) } +///| test "bmat_apply_elementwise_negate" { let data = [[1.0, -2.0], [3.0, -4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -629,6 +668,7 @@ test "bmat_apply_elementwise_negate" { assert_eq(result.get(1, 1), 4.0) } +///| test "bmat_apply_elementwise_no_change" { let data = [[5.0, 10.0], [15.0, 20.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -643,6 +683,7 @@ test "bmat_apply_elementwise_no_change" { // to_string // --------------------------------------------------------------------------- +///| test "bmat_to_string" { let data = [[1.0, 2.0], [3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -654,6 +695,7 @@ test "bmat_to_string" { assert_true(s.contains("4")) } +///| test "bmat_to_string_single" { let data = [[7.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -666,6 +708,7 @@ test "bmat_to_string_single" { // Edge cases // --------------------------------------------------------------------------- +///| test "bmat_empty_matrix" { let data : Array[Array[Double]] = [] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -673,12 +716,14 @@ test "bmat_empty_matrix" { assert_eq(bmat.dim_cols(), 0) } +///| test "bmat_empty_matrix_zeros" { let bmat = @src.Bmat::zeros(0, 0) assert_eq(bmat.dim_rows(), 0) assert_eq(bmat.dim_cols(), 0) } +///| test "bmat_empty_matrix_iterator" { let data : Array[Array[Double]] = [] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -690,6 +735,7 @@ test "bmat_empty_matrix_iterator" { assert_eq(iter.cur_col(), 0) } +///| test "bmat_empty_matrix_roundtrip" { let data : Array[Array[Double]] = [] let bmat = @src.bmat_from_array(data) @@ -699,6 +745,7 @@ test "bmat_empty_matrix_roundtrip" { assert_eq(arr.length(), 0) } +///| test "bmat_single_row" { let data = [[1.0, 2.0, 3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -711,6 +758,7 @@ test "bmat_single_row" { assert_eq(row[2], 3.0) } +///| test "bmat_single_col" { let data = [[1.0], [2.0], [3.0], [4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -723,6 +771,7 @@ test "bmat_single_col" { assert_eq(col[2], 3.0) } +///| test "bmat_single_element" { let data = [[42.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -733,6 +782,7 @@ test "bmat_single_element" { assert_eq(bmat.get(0, 0), 99.0) } +///| test "bmat_apply_col_blocks_single_block" { let data = [[1.0, 2.0], [3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -744,6 +794,7 @@ test "bmat_apply_col_blocks_single_block" { assert_eq(col_starts[0], 0) } +///| test "bmat_apply_row_blocks_single_block" { let data = [[1.0, 2.0], [3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -755,6 +806,7 @@ test "bmat_apply_row_blocks_single_block" { assert_eq(row_starts[0], 0) } +///| test "bmat_apply_col_blocks_exact_fit" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -766,6 +818,7 @@ test "bmat_apply_col_blocks_exact_fit" { assert_eq(col_starts[0], 0) } +///| test "bmat_apply_row_blocks_exact_fit" { let data = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -777,6 +830,7 @@ test "bmat_apply_row_blocks_exact_fit" { assert_eq(row_starts[0], 0) } +///| test "bmat_iterator_single_element" { let data = [[42.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -789,6 +843,7 @@ test "bmat_iterator_single_element" { assert_false(iter.has_next()) } +///| test "bmat_subset_single_element" { let data = [[1.0, 2.0], [3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -798,6 +853,7 @@ test "bmat_subset_single_element" { assert_eq(sub.get(0, 0), 4.0) } +///| test "bmat_transpose_empty" { let data : Array[Array[Double]] = [] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -806,16 +862,16 @@ test "bmat_transpose_empty" { assert_eq(t.dim_cols(), 0) } +///| test "bmat_foreach_empty" { let data : Array[Array[Double]] = [] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) let values : Array[Double] = [] - @src.bmat_foreach(bmat, fn(row, col, val) { - values.push(val) - }) + @src.bmat_foreach(bmat, fn(row, col, val) { values.push(val) }) assert_eq(values.length(), 0) } +///| test "bmat_zeros_set_get" { let bmat = @src.Bmat::zeros(3, 3) assert_eq(bmat.get(1, 1), 0.0) @@ -825,6 +881,7 @@ test "bmat_zeros_set_get" { assert_eq(bmat.get(2, 2), 0.0) } +///| test "bmat_apply_elementwise_empty" { let data : Array[Array[Double]] = [] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -833,6 +890,7 @@ test "bmat_apply_elementwise_empty" { assert_eq(result.dim_cols(), 0) } +///| test "bmat_bind_cols_empty" { let left = @src.Bmat::zeros(3, 0) let right = @src.Bmat::new([[1.0], [2.0], [3.0]], @src.BmatParam::new()) @@ -843,6 +901,7 @@ test "bmat_bind_cols_empty" { assert_eq(result.get(2, 0), 3.0) } +///| test "bmat_bind_rows_empty" { let top = @src.Bmat::zeros(0, 2) let bottom = @src.Bmat::new([[1.0, 2.0]], @src.BmatParam::new()) @@ -853,6 +912,7 @@ test "bmat_bind_rows_empty" { assert_eq(result.get(0, 1), 2.0) } +///| test "bmat_get_set_multiple" { let bmat = @src.Bmat::zeros(3, 3) bmat.set(0, 0, 1.0) @@ -879,6 +939,7 @@ test "bmat_get_set_multiple" { assert_eq(col2[2], 9.0) } +///| test "bmat_apply_col_blocks_last_block_partial" { let data = [[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -892,6 +953,7 @@ test "bmat_apply_col_blocks_last_block_partial" { assert_eq(col_ends[2], 7) } +///| test "bmat_apply_row_blocks_last_block_partial" { let data = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0], [9.0, 10.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -903,4 +965,4 @@ test "bmat_apply_row_blocks_last_block_partial" { assert_eq(row_ends[0], 2) assert_eq(row_ends[1], 4) assert_eq(row_ends[2], 5) -} \ No newline at end of file +} diff --git a/test/moonbit/binary_cif_test.mbt b/test/moonbit/binary_cif_test.mbt index eaf63a4d..a4369ea1 100644 --- a/test/moonbit/binary_cif_test.mbt +++ b/test/moonbit/binary_cif_test.mbt @@ -11,14 +11,8 @@ test "binary cif decodes signed and unsigned 8-bit byte arrays" { ///| test "binary cif decodes signed and unsigned 16-bit byte arrays" { let bytes = [0x34, 0x12, 0x00, 0x80, 0xFF, 0xFF] - assert_eq( - @src.binary_cif_decode_int_bytes(bytes, 2), - [4660, -32768, -1], - ) - assert_eq( - @src.binary_cif_decode_int_bytes(bytes, 5), - [4660, 32768, 65535], - ) + assert_eq(@src.binary_cif_decode_int_bytes(bytes, 2), [4660, -32768, -1]) + assert_eq(@src.binary_cif_decode_int_bytes(bytes, 5), [4660, 32768, 65535]) } ///| @@ -30,17 +24,17 @@ test "binary cif decodes signed and unsigned 32-bit byte arrays" { ), [305419896, -1], ) - assert_eq( - @src.binary_cif_decode_int_bytes([0xFF, 0xFF, 0xFF, 0x7F], 6), - [2147483647], - ) + assert_eq(@src.binary_cif_decode_int_bytes([0xFF, 0xFF, 0xFF, 0x7F], 6), [ + 2147483647, + ]) } ///| test "binary cif decodes little-endian float32 byte arrays" { - let values = @src.binary_cif_decode_float_bytes([ - 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x20, 0xC0, - ], 32) + let values = @src.binary_cif_decode_float_bytes( + [0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x20, 0xC0], + 32, + ) assert_eq(values.length(), 2) assert_true((values[0] - 1.0).abs() < 1.0e-12) assert_true((values[1] + 2.5).abs() < 1.0e-12) @@ -48,24 +42,13 @@ test "binary cif decodes little-endian float32 byte arrays" { ///| test "binary cif decodes little-endian float64 byte arrays" { - let values = @src.binary_cif_decode_float_bytes([ - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0xF0, - 0x3F, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x04, - 0xC0, - ], 33) + let values = @src.binary_cif_decode_float_bytes( + [ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x04, 0xC0, + ], + 33, + ) assert_eq(values.length(), 2) assert_true((values[0] - 1.0).abs() < 1.0e-12) assert_true((values[1] + 2.5).abs() < 1.0e-12) @@ -98,35 +81,27 @@ test "binary cif byte array decoding rejects invalid inputs" { ///| test "binary cif decodes unsigned integer packing" { - assert_eq( - @src.binary_cif_decode_integer_packing([255, 5, 1], 1, true, 2), - [260, 1], - ) + assert_eq(@src.binary_cif_decode_integer_packing([255, 5, 1], 1, true, 2), [ + 260, 1, + ]) } ///| test "binary cif decodes signed integer packing" { assert_eq( - @src.binary_cif_decode_integer_packing( - [127, 5, -128, -2, 10], - 1, - false, - 3, - ), + @src.binary_cif_decode_integer_packing([127, 5, -128, -2, 10], 1, false, 3), [132, -130, 10], ) } ///| test "binary cif decodes two-byte integer packing" { - assert_eq( - @src.binary_cif_decode_integer_packing([65535, 100], 2, true, 1), - [65635], - ) - assert_eq( - @src.binary_cif_decode_integer_packing([-32768, -5], 2, false, 1), - [-32773], - ) + assert_eq(@src.binary_cif_decode_integer_packing([65535, 100], 2, true, 1), [ + 65635, + ]) + assert_eq(@src.binary_cif_decode_integer_packing([-32768, -5], 2, false, 1), [ + -32773, + ]) } ///| @@ -156,10 +131,9 @@ test "binary cif integer packing validates metadata and values" { ///| test "binary cif decodes run-length encoding" { - assert_eq( - @src.binary_cif_decode_run_length([4, 3, -1, 2], 5), - [4, 4, 4, -1, -1], - ) + assert_eq(@src.binary_cif_decode_run_length([4, 3, -1, 2], 5), [ + 4, 4, 4, -1, -1, + ]) } ///| @@ -229,25 +203,19 @@ test "binary cif decodes interval quantization" { ///| test "binary cif interval quantization validates parameters and indices" { let bad_steps = try { - ignore( - @src.binary_cif_decode_interval_quantization([0], 0.0, 1.0, 1), - ) + ignore(@src.binary_cif_decode_interval_quantization([0], 0.0, 1.0, 1)) false } catch { BinaryCifError(_) => true } let bad_bounds = try { - ignore( - @src.binary_cif_decode_interval_quantization([0], 2.0, 1.0, 3), - ) + ignore(@src.binary_cif_decode_interval_quantization([0], 2.0, 1.0, 3)) false } catch { BinaryCifError(_) => true } let bad_index = try { - ignore( - @src.binary_cif_decode_interval_quantization([3], 0.0, 1.0, 3), - ) + ignore(@src.binary_cif_decode_interval_quantization([3], 0.0, 1.0, 3)) false } catch { BinaryCifError(_) => true @@ -324,29 +292,27 @@ test "binary cif queries columns by short and qualified names" { ///| test "binary cif reports decoded column kinds and lengths" { - let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) - .data_blocks[0] + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()).data_blocks[0] .get_category("atom_site") .unwrap() assert_true( - atom_site.get_column("id").unwrap().kind() is - @src.BinaryCifColumnKind::BinaryCifInteger, + atom_site.get_column("id").unwrap().kind() + is @src.BinaryCifColumnKind::BinaryCifInteger, ) assert_true( - atom_site.get_column("Cartn_x").unwrap().kind() is - @src.BinaryCifColumnKind::BinaryCifFloat, + atom_site.get_column("Cartn_x").unwrap().kind() + is @src.BinaryCifColumnKind::BinaryCifFloat, ) assert_true( - atom_site.get_column("label_atom_id").unwrap().kind() is - @src.BinaryCifColumnKind::BinaryCifText, + atom_site.get_column("label_atom_id").unwrap().kind() + is @src.BinaryCifColumnKind::BinaryCifText, ) assert_eq(atom_site.get_column("Cartn_x").unwrap().length(), 8) } ///| test "binary cif reads integer columns" { - let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) - .data_blocks[0] + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()).data_blocks[0] .get_category("atom_site") .unwrap() let ids = atom_site.get_column("id").unwrap() @@ -357,8 +323,7 @@ test "binary cif reads integer columns" { ///| test "binary cif reverses fixed-point and delta pipelines" { - let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) - .data_blocks[0] + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()).data_blocks[0] .get_category("atom_site") .unwrap() let xs = atom_site.get_column("Cartn_x").unwrap() @@ -369,8 +334,7 @@ test "binary cif reverses fixed-point and delta pipelines" { ///| test "binary cif reverses string array pipelines" { - let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) - .data_blocks[0] + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()).data_blocks[0] .get_category("atom_site") .unwrap() let components = atom_site.get_column("label_comp_id").unwrap() @@ -382,14 +346,11 @@ test "binary cif reverses string array pipelines" { ///| test "binary cif exposes present not-present and unknown masks" { - let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) - .data_blocks[0] + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()).data_blocks[0] .get_category("atom_site") .unwrap() let altloc = atom_site.get_column("label_alt_id").unwrap() - assert_true( - altloc.mask_at(0) is @src.BinaryCifMask::BinaryCifNotPresent, - ) + assert_true(altloc.mask_at(0) is @src.BinaryCifMask::BinaryCifNotPresent) assert_true(altloc.mask_at(3) is @src.BinaryCifMask::BinaryCifPresent) assert_true(altloc.mask_at(6) is @src.BinaryCifMask::BinaryCifUnknown) assert_true(altloc.string_at(0) is None) @@ -402,8 +363,7 @@ test "binary cif exposes present not-present and unknown masks" { ///| test "binary cif column access validates type and bounds" { - let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) - .data_blocks[0] + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()).data_blocks[0] .get_category("atom_site") .unwrap() let names = atom_site.get_column("label_atom_id").unwrap() @@ -434,7 +394,9 @@ test "binary cif summarizes document contents" { ///| test "binary cif builds pdb structure hierarchy" { - let structure = @src.binary_cif_parse_structure(@src.binary_cif_sample_bytes()) + let structure = @src.binary_cif_parse_structure( + @src.binary_cif_sample_bytes(), + ) assert_eq(structure.get_id(), "BCIF") assert_eq(structure.get_num_models(), 2) assert_eq(structure.get_num_chains(), 3) @@ -444,7 +406,9 @@ test "binary cif builds pdb structure hierarchy" { ///| test "binary cif preserves model and chain grouping" { - let structure = @src.binary_cif_parse_structure(@src.binary_cif_sample_bytes()) + let structure = @src.binary_cif_parse_structure( + @src.binary_cif_sample_bytes(), + ) let models = structure.get_models() assert_eq(models[0].get_id(), 0) assert_eq(models[1].get_id(), 1) @@ -456,7 +420,9 @@ test "binary cif preserves model and chain grouping" { ///| test "binary cif preserves residues insertion codes and water" { - let structure = @src.binary_cif_parse_structure(@src.binary_cif_sample_bytes()) + let structure = @src.binary_cif_parse_structure( + @src.binary_cif_sample_bytes(), + ) let residues = structure.get_residues() assert_eq(residues[0].resname, "GLY") assert_eq(residues[0].resseq, 1) @@ -471,7 +437,9 @@ test "binary cif preserves residues insertion codes and water" { ///| test "binary cif preserves atom annotations and coordinates" { - let structure = @src.binary_cif_parse_structure(@src.binary_cif_sample_bytes()) + let structure = @src.binary_cif_parse_structure( + @src.binary_cif_sample_bytes(), + ) let atoms = structure.get_atoms() assert_eq(atoms[0].name, "N") assert_eq(atoms[0].element, "N") diff --git a/test/moonbit/bio_seq_test.mbt b/test/moonbit/bio_seq_test.mbt index ff2d7f59..8163a422 100644 --- a/test/moonbit/bio_seq_test.mbt +++ b/test/moonbit/bio_seq_test.mbt @@ -333,6 +333,7 @@ test "seq_translate_rna_stop_codons" { // MutableSeq tests +///| test "mutableseq_construction" { let ms = @src.MutableSeq::new("ACGT") assert_eq(ms.length(), 4) @@ -342,6 +343,7 @@ test "mutableseq_construction" { assert_eq(ms2.to_string(), "ATCG") } +///| test "mutableseq_get_set" { let ms = @src.MutableSeq::new("ACGT") assert_eq(ms.get(0), 'A') @@ -350,6 +352,7 @@ test "mutableseq_get_set" { assert_eq(ms.to_string(), "AXGT") } +///| test "mutableseq_push_append" { let ms = @src.MutableSeq::new("AC") ms.push('G') @@ -359,24 +362,28 @@ test "mutableseq_push_append" { assert_eq(ms.to_string(), "ACGT") } +///| test "mutableseq_insert" { let ms = @src.MutableSeq::new("ACGT") ms.insert(2, 'X') assert_eq(ms.to_string(), "ACXGT") } +///| test "mutableseq_delete" { let ms = @src.MutableSeq::new("ACGT") ms.delete(1) assert_eq(ms.to_string(), "AGT") } +///| test "mutableseq_delete_range" { let ms = @src.MutableSeq::new("ACGTACGT") ms.delete_range(2, 6) assert_eq(ms.to_string(), "ACGT") } +///| test "mutableseq_pop" { let ms = @src.MutableSeq::new("ACGT") let popped = ms.pop() @@ -386,6 +393,7 @@ test "mutableseq_pop" { assert_eq(empty.pop(), None) } +///| test "mutableseq_copy" { let ms = @src.MutableSeq::new("ACGT") let copy = ms.copy() @@ -394,42 +402,49 @@ test "mutableseq_copy" { assert_eq(copy.to_string(), "XCGT") } +///| test "mutableseq_complement" { let ms = @src.MutableSeq::new("ACGT") let comp = ms.complement() assert_eq(comp.to_string(), "TGCA") } +///| test "mutableseq_reverse_complement" { let ms = @src.MutableSeq::new("ACGT") let rc = ms.reverse_complement() assert_eq(rc.to_string(), "ACGT") } +///| test "mutableseq_transcribe" { let ms = @src.MutableSeq::new("ACGT") let rna = ms.transcribe() assert_eq(rna.to_string(), "ACGU") } +///| test "mutableseq_back_transcribe" { let ms = @src.MutableSeq::new("ACGU") let dna = ms.back_transcribe() assert_eq(dna.to_string(), "ACGT") } +///| test "mutableseq_translate" { let ms = @src.MutableSeq::new("ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG") let protein = ms.translate() assert_eq(protein.to_string(), "MAIVMGR*KGAR*") } +///| test "mutableseq_to_seq" { let ms = @src.MutableSeq::new("ACGT") let s = ms.to_seq() assert_eq(s.to_string(), "ACGT") } +///| test "mutableseq_upper_lower" { let ms = @src.MutableSeq::new("acgt") assert_eq(ms.upper().to_string(), "ACGT") @@ -437,6 +452,7 @@ test "mutableseq_upper_lower" { assert_eq(ms2.lower().to_string(), "acgt") } +///| test "mutableseq_count" { let ms = @src.MutableSeq::new("ATATGAAATTTGAAAA") assert_eq(ms.count("AAA"), 2) diff --git a/test/moonbit/bioc_generics_test.mbt b/test/moonbit/bioc_generics_test.mbt index 589c64b2..60fac5a4 100644 --- a/test/moonbit/bioc_generics_test.mbt +++ b/test/moonbit/bioc_generics_test.mbt @@ -1,149 +1,177 @@ ///| /// Tests for BiocGenerics module. - test "na_int" { assert_eq(@src.na_int(), -2147483648) } +///| test "na_double" { let na = @src.na_double() assert_true(na.is_nan()) } +///| test "is_na_int" { assert_true(@src.is_na_int(-2147483648)) assert_false(@src.is_na_int(0)) } +///| test "is_na_double" { assert_true(@src.is_na_double(@double.not_a_number)) assert_false(@src.is_na_double(0.0)) } +///| test "any_na_int" { assert_true(@src.any_na_int([1, 2, -2147483648, 4])) assert_false(@src.any_na_int([1, 2, 3, 4])) } +///| test "na_omit_int" { let result = @src.na_omit_int([1, -2147483648, 3]) assert_eq(result.length(), 2) } +///| test "which_int" { let result = @src.which_int([1, 2, 1, 3], 1) assert_eq(result.length(), 2) } +///| test "which_bool" { let result = @src.which_bool([true, false, true]) assert_eq(result.length(), 2) } +///| test "order_int" { let indices = @src.order_int([3, 1, 2]) assert_eq(indices[0], 1) } +///| test "sort_int" { let result = @src.sort_int([3, 1, 2]) assert_eq(result[0], 1) } +///| test "unique_int" { let result = @src.unique_int([1, 2, 1, 3]) assert_eq(result.length(), 3) } +///| test "unique_string" { let result = @src.unique_string(["a", "b", "a", "c"]) assert_eq(result.length(), 3) } +///| test "match_int" { let result = @src.match_int([1, 3], [1, 2, 4]) assert_eq(result[0], 0) } +///| test "match_string" { let result = @src.match_string(["a", "c"], ["a", "b"]) assert_eq(result[0], 0) } +///| test "intersect_int" { let result = @src.intersect_int([1, 2, 3], [2, 3, 4]) assert_eq(result.length(), 2) } +///| test "intersect_string" { let result = @src.intersect_string(["a", "b"], ["b", "c"]) assert_eq(result.length(), 1) } +///| test "union_int" { let result = @src.union_int([1, 2], [2, 3]) assert_eq(result.length(), 3) } +///| test "setdiff_int" { let result = @src.setdiff_int([1, 2, 3], [2]) assert_eq(result.length(), 2) } +///| test "table_int" { let result = @src.table_int([1, 2, 1, 3, 1]) assert_eq(result.get("1").unwrap(), 3) } +///| test "table_string" { let result = @src.table_string(["a", "b", "a"]) assert_eq(result.get("a").unwrap(), 2) } +///| test "rev_int" { let result = @src.rev_int([1, 2, 3]) assert_eq(result[0], 3) } +///| test "rev_string" { let result = @src.rev_string(["a", "b", "c"]) assert_eq(result[0], "c") } +///| test "rep_int" { let result = @src.rep_int(5, 3) assert_eq(result.length(), 3) } +///| test "seq_int" { let result = @src.seq_int(1, 5) assert_eq(result.length(), 5) } +///| test "seq_double" { let result = @src.seq_double(1.0, 3.0, by=1.0) assert_eq(result.length(), 3) } +///| test "head_int" { let result = @src.head_int([1, 2, 3, 4, 5], 3) assert_eq(result.length(), 3) } +///| test "tail_int" { let result = @src.tail_int([1, 2, 3, 4, 5], 2) assert_eq(result.length(), 2) } +///| test "length_int" { assert_eq(@src.length_int([1, 2, 3]), 3) } +///| test "cbind" { let result = @src.cbind([[1.0, 2.0], [3.0, 4.0]]) assert_eq(result.length(), 2) } +///| test "rbind" { let result = @src.rbind([[1.0, 2.0], [3.0, 4.0]]) assert_eq(result.length(), 2) diff --git a/test/moonbit/bioc_neighbors_test.mbt b/test/moonbit/bioc_neighbors_test.mbt index 2958ae64..cc69bd86 100644 --- a/test/moonbit/bioc_neighbors_test.mbt +++ b/test/moonbit/bioc_neighbors_test.mbt @@ -20,13 +20,7 @@ test "knn_options_with_method" { ///| test "knn_options_full" { - let opts = @src.knn_options_full( - @src.annoy_method(), - 8, - "manhattan", - 30, - 100, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 8, "manhattan", 30, 100) assert_true(opts.method == @src.annoy_method()) assert_eq(opts.k, 8) assert_eq(opts.distance, "manhattan") @@ -60,12 +54,7 @@ test "knn_compute_distance_cosine" { ///| test "knn_brute_force_basic" { - let data = [ - [0.0, 0.0], - [1.0, 0.0], - [0.0, 1.0], - [1.0, 1.0], - ] + let data = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]] let query = [[0.0, 0.0]] let result = @src.knn_brute_force(data, 4, 2, query, 1, 2, "euclidean") assert_eq(result.n_query, 1) @@ -164,13 +153,7 @@ test "build_knn_index_kmknn" { [10.0, 11.0], [11.0, 11.0], ] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 2, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 2, "euclidean", 50, -1) let index = @src.build_knn_index(data, 8, 2, opts) assert_true(index.method == @src.kmknn_method()) assert_true(index.centroids.length() > 0) @@ -188,13 +171,7 @@ test "build_knn_index_annoy" { [10.0, 11.0], [11.0, 11.0], ] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "euclidean", - 5, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "euclidean", 5, -1) let index = @src.build_knn_index(data, 8, 2, opts) assert_true(index.method == @src.annoy_method()) assert_true(index.tree_nodes.length() > 0) @@ -203,13 +180,7 @@ test "build_knn_index_annoy" { ///| test "build_kmknn_index_empty" { let data : Array[Array[Double]] = [] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 2, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 2, "euclidean", 50, -1) let index = @src.build_kmknn_index(data, 0, 2, opts) assert_eq(index.n_points, 0) assert_eq(index.centroids.length(), 0) @@ -218,13 +189,7 @@ test "build_kmknn_index_empty" { ///| test "build_annoy_index_empty" { let data : Array[Array[Double]] = [] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "euclidean", 50, -1) let index = @src.build_annoy_index(data, 0, 2, opts) assert_eq(index.n_points, 0) assert_eq(index.tree_nodes.length(), 0) @@ -259,13 +224,7 @@ test "run_knn_kmknn" { [10.0, 11.0], [11.0, 11.0], ] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 3, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 3, "euclidean", 50, -1) let index = @src.build_knn_index(data, 8, 2, opts) let query = [[0.0, 0.0], [10.0, 10.0]] let result = @src.run_knn(index, query, 2, opts) @@ -285,13 +244,7 @@ test "run_knn_annoy" { [10.0, 11.0], [11.0, 11.0], ] - let opts = @src.knn_options_full( - @src.annoy_method(), - 3, - "euclidean", - 5, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 3, "euclidean", 5, -1) let index = @src.build_knn_index(data, 8, 2, opts) let query = [[0.0, 0.0], [10.0, 10.0]] let result = @src.run_knn(index, query, 2, opts) @@ -302,13 +255,7 @@ test "run_knn_annoy" { ///| test "knn_annoy_cosine_distance" { let data = [[1.0, 0.0], [0.0, 1.0], [1.0, 1.0], [-1.0, 0.0]] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "cosine", - 3, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "cosine", 3, -1) let index = @src.build_annoy_index(data, 4, 2, opts) let query = [[1.0, 0.0]] let result = @src.knn_annoy(index, query, 1, opts) @@ -318,13 +265,7 @@ test "knn_annoy_cosine_distance" { ///| test "knn_kmknn_cosine_distance" { let data = [[1.0, 0.0], [0.0, 1.0], [1.0, 1.0], [-1.0, 0.0]] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 2, - "cosine", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 2, "cosine", 50, -1) let index = @src.build_kmknn_index(data, 4, 2, opts) let query = [[1.0, 0.0]] let result = @src.knn_kmknn(index, query, 1, opts) @@ -370,13 +311,7 @@ test "knn_brute_force_single_dim" { ///| test "knn_kmknn_single_point" { let data = [[1.0, 2.0]] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 1, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 1, "euclidean", 50, -1) let index = @src.build_kmknn_index(data, 1, 2, opts) let query = [[1.0, 2.0]] let result = @src.knn_kmknn(index, query, 1, opts) @@ -386,13 +321,7 @@ test "knn_kmknn_single_point" { ///| test "knn_annoy_single_point" { let data = [[1.0, 2.0]] - let opts = @src.knn_options_full( - @src.annoy_method(), - 1, - "euclidean", - 3, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 1, "euclidean", 3, -1) let index = @src.build_annoy_index(data, 1, 2, opts) let query = [[1.0, 2.0]] let result = @src.knn_annoy(index, query, 1, opts) @@ -413,13 +342,7 @@ test "knn_brute_force_vs_kmknn" { ] let query = [[0.0, 0.0]] let brute_result = @src.knn_brute_force(data, 8, 2, query, 1, 3, "euclidean") - let opts = @src.knn_options_full( - @src.kmknn_method(), - 3, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 3, "euclidean", 50, -1) let index = @src.build_kmknn_index(data, 8, 2, opts) let kmknn_result = @src.knn_kmknn(index, query, 1, opts) assert_eq(brute_result.k, kmknn_result.k) @@ -439,13 +362,7 @@ test "knn_brute_force_vs_annoy" { ] let query = [[0.0, 0.0]] let brute_result = @src.knn_brute_force(data, 8, 2, query, 1, 3, "euclidean") - let opts = @src.knn_options_full( - @src.annoy_method(), - 3, - "euclidean", - 5, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 3, "euclidean", 5, -1) let index = @src.build_annoy_index(data, 8, 2, opts) let annoy_result = @src.knn_annoy(index, query, 1, opts) assert_eq(brute_result.k, 3) @@ -464,13 +381,7 @@ test "knn_brute_force_no_query" { ///| test "build_kmknn_index_small" { let data = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 2, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 2, "euclidean", 50, -1) let index = @src.build_kmknn_index(data, 3, 2, opts) assert_eq(index.n_points, 3) assert_true(index.centroids.length() >= 1) @@ -479,13 +390,7 @@ test "build_kmknn_index_small" { ///| test "build_annoy_index_small" { let data = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "euclidean", - 3, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "euclidean", 3, -1) let index = @src.build_annoy_index(data, 3, 2, opts) assert_eq(index.n_points, 3) assert_true(index.tree_nodes.length() > 0) @@ -494,13 +399,7 @@ test "build_annoy_index_small" { ///| test "knn_kmknn_empty_query" { let data = [[0.0, 0.0], [1.0, 0.0]] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 2, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 2, "euclidean", 50, -1) let index = @src.build_kmknn_index(data, 2, 2, opts) let query : Array[Array[Double]] = [] let result = @src.knn_kmknn(index, query, 0, opts) @@ -510,13 +409,7 @@ test "knn_kmknn_empty_query" { ///| test "knn_annoy_empty_query" { let data = [[0.0, 0.0], [1.0, 0.0]] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "euclidean", - 3, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "euclidean", 3, -1) let index = @src.build_annoy_index(data, 2, 2, opts) let query : Array[Array[Double]] = [] let result = @src.knn_annoy(index, query, 0, opts) @@ -526,13 +419,7 @@ test "knn_annoy_empty_query" { ///| test "knn_annoy_search_k_auto" { let data = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "euclidean", - 3, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "euclidean", 3, -1) let index = @src.build_annoy_index(data, 4, 2, opts) let query = [[0.0, 0.0]] let result = @src.knn_annoy(index, query, 1, opts) @@ -542,13 +429,7 @@ test "knn_annoy_search_k_auto" { ///| test "knn_annoy_search_k_custom" { let data = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "euclidean", - 3, - 1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "euclidean", 3, 1) let index = @src.build_annoy_index(data, 4, 2, opts) let query = [[0.0, 0.0]] let result = @src.knn_annoy(index, query, 1, opts) @@ -613,13 +494,7 @@ test "knn_brute_force_large_k" { ///| test "knn_brute_force_different_k_values" { - let data = [ - [0.0, 0.0], - [1.0, 0.0], - [0.0, 1.0], - [1.0, 1.0], - [2.0, 2.0], - ] + let data = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0], [2.0, 2.0]] let query = [[0.0, 0.0]] let result_k1 = @src.knn_brute_force(data, 5, 2, query, 1, 1, "euclidean") assert_eq(result_k1.k, 1) @@ -663,13 +538,7 @@ test "knn_brute_force_vs_kmknn_same_results" { ] let query = [[0.0, 0.0], [3.0, 3.0]] let brute_result = @src.knn_brute_force(data, 8, 2, query, 2, 3, "euclidean") - let opts = @src.knn_options_full( - @src.kmknn_method(), - 3, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 3, "euclidean", 50, -1) let index = @src.build_kmknn_index(data, 8, 2, opts) let kmknn_result = @src.knn_kmknn(index, query, 2, opts) assert_eq(brute_result.n_query, kmknn_result.n_query) @@ -690,13 +559,7 @@ test "knn_annoy_approximately_correct" { ] let query = [[0.0, 0.0]] let brute_result = @src.knn_brute_force(data, 8, 2, query, 1, 3, "euclidean") - let opts = @src.knn_options_full( - @src.annoy_method(), - 3, - "euclidean", - 10, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 3, "euclidean", 10, -1) let index = @src.build_annoy_index(data, 8, 2, opts) let annoy_result = @src.knn_annoy(index, query, 1, opts) assert_true(annoy_result.k >= 1) @@ -721,13 +584,7 @@ test "knn_brute_force_cosine_3d" { ///| test "knn_kmknn_manhattan_distance" { let data = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 2, - "manhattan", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 2, "manhattan", 50, -1) let index = @src.build_kmknn_index(data, 4, 2, opts) let query = [[0.0, 0.0]] let result = @src.knn_kmknn(index, query, 1, opts) @@ -778,13 +635,7 @@ test "knn_quick_sort_duplicates" { ///| test "knn_kmknn_empty_data" { let data : Array[Array[Double]] = [] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 2, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 2, "euclidean", 50, -1) let index = @src.build_kmknn_index(data, 0, 2, opts) let query = [[0.0, 0.0]] let result = @src.knn_kmknn(index, query, 1, opts) @@ -795,13 +646,7 @@ test "knn_kmknn_empty_data" { ///| test "knn_annoy_manhattan_distance" { let data = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "manhattan", - 5, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "manhattan", 5, -1) let index = @src.build_annoy_index(data, 4, 2, opts) let query = [[0.0, 0.0]] let result = @src.knn_annoy(index, query, 1, opts) @@ -859,13 +704,7 @@ test "knn_brute_force_5d" { ///| test "build_knn_index_kmknn_small_data" { let data = [[1.0, 2.0]] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 1, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 1, "euclidean", 50, -1) let index = @src.build_knn_index(data, 1, 2, opts) assert_true(index.method == @src.kmknn_method()) assert_eq(index.n_points, 1) @@ -874,15 +713,9 @@ test "build_knn_index_kmknn_small_data" { ///| test "run_knn_annoy_multiple_queries" { let data = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "euclidean", - 3, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "euclidean", 3, -1) let index = @src.build_knn_index(data, 4, 2, opts) let query = [[0.0, 0.0], [1.0, 1.0], [0.0, 1.0]] let result = @src.run_knn(index, query, 3, opts) assert_eq(result.n_query, 3) -} \ No newline at end of file +} diff --git a/test/moonbit/bioc_parallel_test.mbt b/test/moonbit/bioc_parallel_test.mbt index 217d334c..445366cb 100644 --- a/test/moonbit/bioc_parallel_test.mbt +++ b/test/moonbit/bioc_parallel_test.mbt @@ -1,18 +1,19 @@ ///| /// Tests for BiocParallel module. - test "BPPARAM creation" { let params = @src.create_example_bpparam() assert_eq(params.workers, 4) assert_eq(params.progressbar, true) } +///| test "BPJob creation" { let job = @src.create_example_bpjob() assert_eq(job.name, "example_job") assert_eq(job.tasks.length(), 4) } +///| test "bp_sum" { let data : Array[Array[Double]] = Array::new() let chunk1 : Array[Double] = Array::new() @@ -20,18 +21,19 @@ test "bp_sum" { chunk1.push(2.0) chunk1.push(3.0) data.push(chunk1) - + let chunk2 : Array[Double] = Array::new() chunk2.push(4.0) chunk2.push(5.0) chunk2.push(6.0) data.push(chunk2) - + let params = @src.BPPARAM::new(2, false, 120) let result = @src.bp_sum(data, params) assert_eq(result, 21.0) } +///| test "bp_mean" { let data : Array[Double] = Array::new() data.push(1.0) @@ -39,7 +41,7 @@ test "bp_mean" { data.push(3.0) data.push(4.0) data.push(5.0) - + let result = @src.bp_mean_simple(data, 2) assert_eq(result, 3.0) -} \ No newline at end of file +} diff --git a/test/moonbit/bioc_singular_test.mbt b/test/moonbit/bioc_singular_test.mbt index 2a30207a..a69cde59 100644 --- a/test/moonbit/bioc_singular_test.mbt +++ b/test/moonbit/bioc_singular_test.mbt @@ -431,14 +431,9 @@ test "svd_options_equality" { ///| test "exact_svd_larger_matrix_sorted" { - let matrix = [ - 1.0, 2.0, 3.0, - 2.0, 3.0, 4.0, - 3.0, 4.0, 5.0, - 4.0, 5.0, 6.0, - ] + let matrix = [1.0, 2.0, 3.0, 2.0, 3.0, 4.0, 3.0, 4.0, 5.0, 4.0, 5.0, 6.0] let result = @src.run_exact_svd(matrix, 4, 3, 0) assert_eq(result.rank, 3) assert_true(result.d[0] >= result.d[1]) assert_true(result.d[1] >= result.d[2]) -} \ No newline at end of file +} diff --git a/test/moonbit/biostrings_matchdict_test.mbt b/test/moonbit/biostrings_matchdict_test.mbt index 019c0806..689fe37a 100644 --- a/test/moonbit/biostrings_matchdict_test.mbt +++ b/test/moonbit/biostrings_matchdict_test.mbt @@ -24,7 +24,11 @@ test "bmd_create_pdict_empty" { ///| test "bmd_create_pdict_with_indels" { - let pdict = @src.bmd_create_pdict(patterns=["ATG"], max_mismatches=1, with_indels=true) + let pdict = @src.bmd_create_pdict( + patterns=["ATG"], + max_mismatches=1, + with_indels=true, + ) assert_eq(pdict.with_indels, true) assert_eq(pdict.max_mismatches, 1) } @@ -32,7 +36,7 @@ test "bmd_create_pdict_with_indels" { ///| test "bmd_match_pdict_single_pattern" { let pdict = @src.bmd_create_pdict(patterns=["ATG"]) - let result = @src.bmd_match_pdict(pdict=pdict, subject="AATGCTAG") + let result = @src.bmd_match_pdict(pdict~, subject="AATGCTAG") assert_eq(result.hits.length(), 1) assert_eq(result.hits[0].pattern, "ATG") assert_eq(result.hits[0].start, 2) @@ -43,7 +47,7 @@ test "bmd_match_pdict_single_pattern" { ///| test "bmd_match_pdict_multiple_patterns" { let pdict = @src.bmd_create_pdict(patterns=["ATG", "GCT"]) - let result = @src.bmd_match_pdict(pdict=pdict, subject="ATGGCT") + let result = @src.bmd_match_pdict(pdict~, subject="ATGGCT") assert_eq(result.hits.length(), 2) assert_eq(result.hits[0].pattern, "ATG") assert_eq(result.hits[1].pattern, "GCT") @@ -52,21 +56,21 @@ test "bmd_match_pdict_multiple_patterns" { ///| test "bmd_match_pdict_overlapping_hits" { let pdict = @src.bmd_create_pdict(patterns=["AAA"]) - let result = @src.bmd_match_pdict(pdict=pdict, subject="AAAA") + let result = @src.bmd_match_pdict(pdict~, subject="AAAA") assert_eq(result.hits.length(), 2) } ///| test "bmd_match_pdict_no_match" { let pdict = @src.bmd_create_pdict(patterns=["XYZ"]) - let result = @src.bmd_match_pdict(pdict=pdict, subject="ATGC") + let result = @src.bmd_match_pdict(pdict~, subject="ATGC") assert_eq(result.hits.length(), 0) } ///| test "bmd_match_pdict_empty_subject" { let pdict = @src.bmd_create_pdict(patterns=["ATG"]) - let result = @src.bmd_match_pdict(pdict=pdict, subject="") + let result = @src.bmd_match_pdict(pdict~, subject="") assert_eq(result.hits.length(), 0) assert_eq(result.subject_length, 0) } @@ -74,14 +78,14 @@ test "bmd_match_pdict_empty_subject" { ///| test "bmd_match_pdict_empty_patterns" { let pdict = @src.bmd_create_pdict(patterns=[]) - let result = @src.bmd_match_pdict(pdict=pdict, subject="ATGC") + let result = @src.bmd_match_pdict(pdict~, subject="ATGC") assert_eq(result.hits.length(), 0) } ///| test "bmd_match_pdict_with_mismatches" { let pdict = @src.bmd_create_pdict(patterns=["ATG"], max_mismatches=1) - let result = @src.bmd_match_pdict(pdict=pdict, subject="AXG") + let result = @src.bmd_match_pdict(pdict~, subject="AXG") assert_eq(result.hits.length(), 1) assert_eq(result.hits[0].mismatches, 1) } @@ -89,21 +93,21 @@ test "bmd_match_pdict_with_mismatches" { ///| test "bmd_match_pdict_mismatch_too_many" { let pdict = @src.bmd_create_pdict(patterns=["ATG"], max_mismatches=1) - let result = @src.bmd_match_pdict(pdict=pdict, subject="XYZ") + let result = @src.bmd_match_pdict(pdict~, subject="XYZ") assert_eq(result.hits.length(), 0) } ///| test "bmd_match_pdict_pattern_longer_than_subject" { let pdict = @src.bmd_create_pdict(patterns=["ATGCT"]) - let result = @src.bmd_match_pdict(pdict=pdict, subject="AT") + let result = @src.bmd_match_pdict(pdict~, subject="AT") assert_eq(result.hits.length(), 0) } ///| test "bmd_vcount_pattern_basic" { let subjects = ["ATGATG", "ATGCAT", "CCCCCC"] - let result = @src.bmd_vcount_pattern(pattern="ATG", subjects=subjects) + let result = @src.bmd_vcount_pattern(pattern="ATG", subjects~) assert_eq(result.pattern, "ATG") assert_eq(result.counts.length(), 3) assert_eq(result.counts[0], 2) @@ -115,7 +119,7 @@ test "bmd_vcount_pattern_basic" { ///| test "bmd_vcount_pattern_no_match" { let subjects = ["CCCC", "GGGG", "TTTT"] - let result = @src.bmd_vcount_pattern(pattern="AAAA", subjects=subjects) + let result = @src.bmd_vcount_pattern(pattern="AAAA", subjects~) assert_eq(result.total, 0) assert_eq(result.counts[0], 0) assert_eq(result.counts[1], 0) @@ -125,7 +129,11 @@ test "bmd_vcount_pattern_no_match" { ///| test "bmd_vcount_pattern_with_mismatches" { let subjects = ["AXG", "AYG", "AZG", "ATG"] - let result = @src.bmd_vcount_pattern(pattern="ATG", subjects=subjects, max_mismatches=1) + let result = @src.bmd_vcount_pattern( + pattern="ATG", + subjects~, + max_mismatches=1, + ) assert_eq(result.counts[0], 1) assert_eq(result.counts[1], 1) assert_eq(result.counts[2], 1) @@ -136,7 +144,7 @@ test "bmd_vcount_pattern_with_mismatches" { ///| test "bmd_vcount_pattern_empty_pattern" { let subjects = ["ATGC", "GCAT"] - let result = @src.bmd_vcount_pattern(pattern="", subjects=subjects) + let result = @src.bmd_vcount_pattern(pattern="", subjects~) assert_eq(result.total, 0) assert_eq(result.counts.length(), 2) } @@ -144,7 +152,7 @@ test "bmd_vcount_pattern_empty_pattern" { ///| test "bmd_vcount_pattern_empty_subjects" { let subjects : Array[String] = [] - let result = @src.bmd_vcount_pattern(pattern="ATG", subjects=subjects) + let result = @src.bmd_vcount_pattern(pattern="ATG", subjects~) assert_eq(result.total, 0) assert_eq(result.counts.length(), 0) } @@ -153,7 +161,7 @@ test "bmd_vcount_pattern_empty_subjects" { test "bmd_vmatch_pattern_basic" { let patterns = ["ATG", "CCC"] let subjects = ["ATGATG", "CCCCCC"] - let results = @src.bmd_vmatch_pattern(patterns=patterns, subjects=subjects) + let results = @src.bmd_vmatch_pattern(patterns~, subjects~) assert_eq(results.length(), 2) assert_eq(results[0].pattern, "ATG") assert_eq(results[0].total, 2) @@ -165,7 +173,7 @@ test "bmd_vmatch_pattern_basic" { test "bmd_vmatch_pattern_multiple_subjects" { let patterns = ["ATG"] let subjects = ["ATGATG", "ATXATG", "TTTTTT"] - let results = @src.bmd_vmatch_pattern(patterns=patterns, subjects=subjects) + let results = @src.bmd_vmatch_pattern(patterns~, subjects~) assert_eq(results.length(), 1) assert_eq(results[0].counts[0], 2) assert_eq(results[0].counts[2], 0) @@ -181,7 +189,7 @@ test "bmd_vmatch_pattern_empty" { test "bmd_which_basic" { let pdict = @src.bmd_create_pdict(patterns=["ATG"]) let subjects = ["ATGCTA", "TTTTTT", "ATGCAT"] - let result = @src.bmd_which(pdict=pdict, subjects=subjects) + let result = @src.bmd_which(pdict~, subjects~) assert_eq(result.length(), 3) assert_eq(result[0], true) assert_eq(result[1], false) @@ -192,7 +200,7 @@ test "bmd_which_basic" { test "bmd_which_no_match" { let pdict = @src.bmd_create_pdict(patterns=["ZZZZZ"]) let subjects = ["ATGC", "GCAT"] - let result = @src.bmd_which(pdict=pdict, subjects=subjects) + let result = @src.bmd_which(pdict~, subjects~) assert_eq(result[0], false) assert_eq(result[1], false) } @@ -201,7 +209,7 @@ test "bmd_which_no_match" { test "bmd_which_empty_pdict" { let pdict = @src.bmd_create_pdict(patterns=[]) let subjects = ["ATGC", "GCAT"] - let result = @src.bmd_which(pdict=pdict, subjects=subjects) + let result = @src.bmd_which(pdict~, subjects~) assert_eq(result[0], false) assert_eq(result[1], false) } @@ -210,7 +218,7 @@ test "bmd_which_empty_pdict" { test "bmd_which_index_basic" { let pdict = @src.bmd_create_pdict(patterns=["ATG"]) let subjects = ["TTTT", "ATGC", "GGGG", "ATGG"] - let indices = @src.bmd_which_index(pdict=pdict, subjects=subjects) + let indices = @src.bmd_which_index(pdict~, subjects~) assert_eq(indices.length(), 2) assert_eq(indices[0], 1) assert_eq(indices[1], 3) @@ -220,42 +228,42 @@ test "bmd_which_index_basic" { test "bmd_which_index_no_match" { let pdict = @src.bmd_create_pdict(patterns=["ZZZZ"]) let subjects = ["ATGC", "GCAT"] - let indices = @src.bmd_which_index(pdict=pdict, subjects=subjects) + let indices = @src.bmd_which_index(pdict~, subjects~) assert_eq(indices.length(), 0) } ///| test "bmd_count_occurrences_basic" { let pdict = @src.bmd_create_pdict(patterns=["ATG"]) - let count = @src.bmd_count_occurrences(pdict=pdict, subject="ATGATGATG") + let count = @src.bmd_count_occurrences(pdict~, subject="ATGATGATG") assert_eq(count, 3) } ///| test "bmd_count_occurrences_multiple_patterns" { let pdict = @src.bmd_create_pdict(patterns=["AT", "TG"]) - let count = @src.bmd_count_occurrences(pdict=pdict, subject="ATGATG") + let count = @src.bmd_count_occurrences(pdict~, subject="ATGATG") assert_eq(count, 4) } ///| test "bmd_count_occurrences_no_match" { let pdict = @src.bmd_create_pdict(patterns=["ZZZZ"]) - let count = @src.bmd_count_occurrences(pdict=pdict, subject="ATGC") + let count = @src.bmd_count_occurrences(pdict~, subject="ATGC") assert_eq(count, 0) } ///| test "bmd_count_occurrences_empty" { let pdict = @src.bmd_create_pdict(patterns=[""]) - let count = @src.bmd_count_occurrences(pdict=pdict, subject="ATGC") + let count = @src.bmd_count_occurrences(pdict~, subject="ATGC") assert_eq(count, 0) } ///| test "bmd_find_best_match_exact" { let pdict = @src.bmd_create_pdict(patterns=["ATG"]) - let best = @src.bmd_find_best_match(pdict=pdict, subject="AATGCT") + let best = @src.bmd_find_best_match(pdict~, subject="AATGCT") assert_true(best is Some(_)) assert_eq(best.unwrap().pattern, "ATG") assert_eq(best.unwrap().start, 2) @@ -263,8 +271,11 @@ test "bmd_find_best_match_exact" { ///| test "bmd_find_best_match_with_mismatches" { - let pdict = @src.bmd_create_pdict(patterns=["ATG", "AXG", "AYG"], max_mismatches=1) - let best = @src.bmd_find_best_match(pdict=pdict, subject="AAAG") + let pdict = @src.bmd_create_pdict( + patterns=["ATG", "AXG", "AYG"], + max_mismatches=1, + ) + let best = @src.bmd_find_best_match(pdict~, subject="AAAG") assert_true(best is Some(_)) assert_eq(best.unwrap().mismatches, 1) assert_eq(best.unwrap().pattern, "ATG") @@ -273,14 +284,14 @@ test "bmd_find_best_match_with_mismatches" { ///| test "bmd_find_best_match_no_hit" { let pdict = @src.bmd_create_pdict(patterns=["ZZZZZ"]) - let best = @src.bmd_find_best_match(pdict=pdict, subject="ATGC") + let best = @src.bmd_find_best_match(pdict~, subject="ATGC") assert_true(best is None) } ///| test "bmd_find_best_match_multiple_hits" { let pdict = @src.bmd_create_pdict(patterns=["ATG"], max_mismatches=2) - let best = @src.bmd_find_best_match(pdict=pdict, subject="AATGCTXG") + let best = @src.bmd_find_best_match(pdict~, subject="AATGCTXG") assert_true(best is Some(_)) assert_eq(best.unwrap().pattern, "ATG") assert_eq(best.unwrap().mismatches, 0) @@ -290,7 +301,7 @@ test "bmd_find_best_match_multiple_hits" { test "bmd_which_with_mismatches" { let pdict = @src.bmd_create_pdict(patterns=["ATG"], max_mismatches=1) let subjects = ["AXGCTA", "TTTTTT", "AYGCAT"] - let result = @src.bmd_which(pdict=pdict, subjects=subjects) + let result = @src.bmd_which(pdict~, subjects~) assert_eq(result[0], true) assert_eq(result[1], false) assert_eq(result[2], true) @@ -299,7 +310,7 @@ test "bmd_which_with_mismatches" { ///| test "bmd_vcount_pattern_single_subject" { let subjects = ["AAAA"] - let result = @src.bmd_vcount_pattern(pattern="AA", subjects=subjects) + let result = @src.bmd_vcount_pattern(pattern="AA", subjects~) assert_eq(result.counts.length(), 1) assert_eq(result.counts[0], 3) assert_eq(result.total, 3) @@ -308,7 +319,7 @@ test "bmd_vcount_pattern_single_subject" { ///| test "bmd_match_pdict_hit_properties" { let pdict = @src.bmd_create_pdict(patterns=["ATG", "TGC"]) - let result = @src.bmd_match_pdict(pdict=pdict, subject="ATGC") + let result = @src.bmd_match_pdict(pdict~, subject="ATGC") assert_eq(result.hits.length(), 2) assert_eq(result.hits[0].pattern_idx, 0) assert_eq(result.hits[0].width, 3) @@ -321,7 +332,7 @@ test "bmd_match_pdict_hit_properties" { ///| test "bmd_count_occurrences_overlapping" { let pdict = @src.bmd_create_pdict(patterns=["AA"]) - let count = @src.bmd_count_occurrences(pdict=pdict, subject="AAAA") + let count = @src.bmd_count_occurrences(pdict~, subject="AAAA") assert_eq(count, 3) } @@ -329,7 +340,7 @@ test "bmd_count_occurrences_overlapping" { test "bmd_vmatch_pattern_multiple_mismatches" { let patterns = ["ATG", "CCC"] let subjects = ["AXGATG", "CXCCCX"] - let results = @src.bmd_vmatch_pattern(patterns=patterns, subjects=subjects, max_mismatches=1) + let results = @src.bmd_vmatch_pattern(patterns~, subjects~, max_mismatches=1) assert_eq(results.length(), 2) assert_eq(results[0].counts[0], 2) assert_eq(results[1].counts[1], 4) diff --git a/test/moonbit/blast_applications_test.mbt b/test/moonbit/blast_applications_test.mbt index f783bc19..7ea80a30 100644 --- a/test/moonbit/blast_applications_test.mbt +++ b/test/moonbit/blast_applications_test.mbt @@ -274,7 +274,9 @@ test "blastapp_validate" { ///| test "blastapp_param_spec" { - let spec = @src.BlastParamSpec::new("-evalue", "E-value threshold", true, "10.0", false) + let spec = @src.BlastParamSpec::new( + "-evalue", "E-value threshold", true, "10.0", false, + ) assert_eq(spec.name, "-evalue") assert_eq(spec.description, "E-value threshold") assert_true(spec.takes_value) diff --git a/test/moonbit/bsseq_test.mbt b/test/moonbit/bsseq_test.mbt index a7280c6b..e3775313 100644 --- a/test/moonbit/bsseq_test.mbt +++ b/test/moonbit/bsseq_test.mbt @@ -260,7 +260,10 @@ test "bsseq_find_hypo_dmr" { ///| test "bsseq_compute_methylation_diff" { assert_eq(@src.bsseq_compute_methylation_diff(0.8, 0.3), 0.5) - assert_true(@src.bsseq_compute_methylation_diff(0.1, 0.4) > -0.31 && @src.bsseq_compute_methylation_diff(0.1, 0.4) < -0.29) + assert_true( + @src.bsseq_compute_methylation_diff(0.1, 0.4) > -0.31 && + @src.bsseq_compute_methylation_diff(0.1, 0.4) < -0.29, + ) assert_eq(@src.bsseq_compute_methylation_diff(0.5, 0.5), 0.0) } diff --git a/test/moonbit/bumphunter_test.mbt b/test/moonbit/bumphunter_test.mbt index fc1fc622..8195361f 100644 --- a/test/moonbit/bumphunter_test.mbt +++ b/test/moonbit/bumphunter_test.mbt @@ -13,6 +13,7 @@ test "bump_position_creation" { assert_eq(p.values()[0], 0.5) } +///| test "bump_region_creation" { let r = @src.BumpRegion::new("chr1", 1000, 2000, 3.5, 10.0, 0, 5) assert_eq(r.chrom(), "chr1") @@ -25,10 +26,9 @@ test "bump_region_creation" { assert_eq(r.length(), 1000) } +///| test "bump_result_creation" { - let r = @src.BumpResult::new( - "chr1", 1000, 2000, 3.5, 10.0, 0.01, 0.05, 0, 5, - ) + let r = @src.BumpResult::new("chr1", 1000, 2000, 3.5, 10.0, 0.01, 0.05, 0, 5) assert_eq(r.chrom(), "chr1") assert_eq(r.start(), 1000) assert_eq(r.end_(), 2000) @@ -44,20 +44,18 @@ test "bump_result_creation" { // t-statistic computation // --------------------------------------------------------------------------- +///| test "bump_t_statistics_clear_difference" { // Position with clear difference between groups - let positions = [ - @src.BumpPosition::new("chr1", 100, [1.0, 1.0, 5.0, 5.0]), - ] + let positions = [@src.BumpPosition::new("chr1", 100, [1.0, 1.0, 5.0, 5.0])] let stats = @src.bump_compute_t_statistics_test(positions, 2) // Group1 mean=1, Group2 mean=5 => negative t-stat assert_true(stats[0] < 0.0) } +///| test "bump_t_statistics_no_difference" { - let positions = [ - @src.BumpPosition::new("chr1", 100, [3.0, 3.0, 3.0, 3.0]), - ] + let positions = [@src.BumpPosition::new("chr1", 100, [3.0, 3.0, 3.0, 3.0])] let stats = @src.bump_compute_t_statistics_test(positions, 2) assert_eq(stats[0], 0.0) } @@ -66,6 +64,7 @@ test "bump_t_statistics_no_difference" { // Smoothing // --------------------------------------------------------------------------- +///| test "bump_smooth_basic" { let stats = [1.0, 2.0, 3.0, 4.0, 5.0] let smoothed = @src.bump_smooth_test(stats, 1) @@ -77,6 +76,7 @@ test "bump_smooth_basic" { assert_eq(smoothed[4], 4.5) } +///| test "bump_smooth_preserves_constant" { let stats = [5.0, 5.0, 5.0, 5.0] let smoothed = @src.bump_smooth_test(stats, 1) @@ -89,6 +89,7 @@ test "bump_smooth_preserves_constant" { // Candidate bump finding // --------------------------------------------------------------------------- +///| test "bump_find_candidates_basic" { let positions = [ @src.BumpPosition::new("chr1", 100, [0.0]), @@ -104,6 +105,7 @@ test "bump_find_candidates_basic" { assert_eq(bumps[0].value(), 4.0) } +///| test "bump_find_candidates_none" { let positions = [ @src.BumpPosition::new("chr1", 100, [0.0]), @@ -114,6 +116,7 @@ test "bump_find_candidates_none" { assert_eq(bumps.length(), 0) } +///| test "bump_find_candidates_negative_values" { let positions = [ @src.BumpPosition::new("chr1", 100, [0.0]), @@ -127,6 +130,7 @@ test "bump_find_candidates_negative_values" { assert_true(bumps[0].value() < 0.0) } +///| test "bump_find_candidates_chromosome_boundary" { let positions = [ @src.BumpPosition::new("chr1", 100, [3.0]), @@ -144,6 +148,7 @@ test "bump_find_candidates_chromosome_boundary" { // Full analysis pipeline // --------------------------------------------------------------------------- +///| test "bump_hunt_detects_known_bump" { let data = @src.bump_sample_data() let results = @src.bump_hunt(data, 4, 2.0, 2, 20) @@ -153,17 +158,20 @@ test "bump_hunt_detects_known_bump" { assert_eq(results[0].chrom(), "chr1") } +///| test "bump_hunt_empty_input" { let results = @src.bump_hunt([], 4, 2.0, 2, 10) assert_eq(results.length(), 0) } +///| test "bump_hunt_zero_group_size" { let data = @src.bump_sample_data() let results = @src.bump_hunt(data, 0, 2.0, 2, 10) assert_eq(results.length(), 0) } +///| test "bump_hunt_high_cutoff_finds_nothing" { let data = @src.bump_sample_data() // Very high cutoff should find no bumps @@ -171,6 +179,7 @@ test "bump_hunt_high_cutoff_finds_nothing" { assert_eq(results.length(), 0) } +///| test "bump_hunt_result_has_valid_pvalue" { let data = @src.bump_sample_data() let results = @src.bump_hunt(data, 4, 2.0, 2, 20) @@ -180,6 +189,7 @@ test "bump_hunt_result_has_valid_pvalue" { } } +///| test "bump_hunt_result_has_valid_fdr" { let data = @src.bump_sample_data() let results = @src.bump_hunt(data, 4, 2.0, 2, 20) @@ -193,6 +203,7 @@ test "bump_hunt_result_has_valid_fdr" { // Sample data // --------------------------------------------------------------------------- +///| test "bump_sample_data_structure" { let data = @src.bump_sample_data() assert_eq(data.length(), 30) @@ -204,11 +215,24 @@ test "bump_sample_data_structure" { assert_eq(data[29].pos(), 3900) } +///| test "bump_sample_data_has_bump_signal" { let data = @src.bump_sample_data() // Cases (first 4 samples) should have higher values in positions 10-20 - let case_mean_at_5 = (data[5].values()[0] + data[5].values()[1] + data[5].values()[2] + data[5].values()[3]) / 4.0 - let case_mean_at_15 = (data[15].values()[0] + data[15].values()[1] + data[15].values()[2] + data[15].values()[3]) / 4.0 + let case_mean_at_5 = ( + data[5].values()[0] + + data[5].values()[1] + + data[5].values()[2] + + data[5].values()[3] + ) / + 4.0 + let case_mean_at_15 = ( + data[15].values()[0] + + data[15].values()[1] + + data[15].values()[2] + + data[15].values()[3] + ) / + 4.0 // Position 15 (in bump region) should have higher case mean than position 5 (outside) assert_true(case_mean_at_15 > case_mean_at_5) } @@ -217,16 +241,16 @@ test "bump_sample_data_has_bump_signal" { // Output formatting // --------------------------------------------------------------------------- +///| test "bump_result_to_string" { - let r = @src.BumpResult::new( - "chr1", 1000, 2000, 3.5, 10.0, 0.01, 0.05, 0, 5, - ) + let r = @src.BumpResult::new("chr1", 1000, 2000, 3.5, 10.0, 0.01, 0.05, 0, 5) let s = r.to_string() assert_true(s.contains("chr1")) assert_true(s.contains("1000")) assert_true(s.contains("2000")) } +///| test "bump_results_to_string" { let results = [ @src.BumpResult::new("chr1", 1000, 2000, 3.5, 10.0, 0.01, 0.05, 0, 5), @@ -240,6 +264,7 @@ test "bump_results_to_string" { // Area computation // --------------------------------------------------------------------------- +///| test "bump_area_is_sum_of_smoothed" { let positions = [ @src.BumpPosition::new("chr1", 100, [0.0]), @@ -258,6 +283,7 @@ test "bump_area_is_sum_of_smoothed" { // Bump length // --------------------------------------------------------------------------- +///| test "bump_length_calculation" { let r = @src.BumpRegion::new("chr1", 1000, 2500, 3.0, 9.0, 0, 3) assert_eq(r.length(), 1500) diff --git a/test/moonbit/caps_test.mbt b/test/moonbit/caps_test.mbt index 8d680a80..1226c2e6 100644 --- a/test/moonbit/caps_test.mbt +++ b/test/moonbit/caps_test.mbt @@ -6,9 +6,7 @@ // --------------------------------------------------------------------------- test "caps_differential_cutsite_creation" { - let dc = @src.CapsDifferentialCutsite::new( - 11, "EcoRI", [0], [1], - ) + let dc = @src.CapsDifferentialCutsite::new(11, "EcoRI", [0], [1]) assert_eq(dc.start(), 11) assert_eq(dc.enzyme_name(), "EcoRI") assert_eq(dc.cuts_in().length(), 1) @@ -17,10 +15,9 @@ test "caps_differential_cutsite_creation" { assert_eq(dc.blocked_in()[0], 1) } +///| test "caps_differential_cutsite_to_string" { - let dc = @src.CapsDifferentialCutsite::new( - 11, "EcoRI", [0], [1], - ) + let dc = @src.CapsDifferentialCutsite::new(11, "EcoRI", [0], [1]) let s = dc.to_string() assert_true(s.contains("DifferentialCutsite")) assert_true(s.contains("pos=11")) @@ -33,6 +30,7 @@ test "caps_differential_cutsite_to_string" { // CAPS map construction // --------------------------------------------------------------------------- +///| test "caps_map_basic" { let seqs = @src.caps_sample_sequences() let enzymes = @src.caps_sample_enzymes() @@ -42,6 +40,7 @@ test "caps_map_basic" { assert_true(m.enzymes().length() >= 1) } +///| test "caps_map_named" { let seqs = @src.caps_sample_sequences() let enzymes = @src.caps_sample_enzymes() @@ -51,6 +50,7 @@ test "caps_map_named" { assert_eq(m.sequence_names()[1], "strainB") } +///| test "caps_map_empty_sequences" { let enzymes = @src.caps_sample_enzymes() let m = @src.caps_map([], enzymes) @@ -59,6 +59,7 @@ test "caps_map_empty_sequences" { assert_eq(m.dcut_count(), 0) } +///| test "caps_map_single_sequence" { // Single sequence: no differential cutting possible let enzymes = @src.caps_sample_enzymes() @@ -71,6 +72,7 @@ test "caps_map_single_sequence" { // Differential cutsite detection // --------------------------------------------------------------------------- +///| test "caps_detects_ecori_differential" { let seqs = @src.caps_sample_sequences() let enzymes = @src.caps_sample_enzymes() @@ -86,6 +88,7 @@ test "caps_detects_ecori_differential" { assert_eq(dc.blocked_in()[0], 1) } +///| test "caps_no_differential_for_identical_sequences" { // Identical sequences: no differential cutting let enzymes = @src.caps_sample_enzymes() @@ -97,6 +100,7 @@ test "caps_no_differential_for_identical_sequences" { assert_eq(m.dcut_count(), 0) } +///| test "caps_no_differential_without_enzyme_site" { // No enzyme recognition site in either sequence let enzymes = @src.caps_sample_enzymes() @@ -107,16 +111,14 @@ test "caps_no_differential_without_enzyme_site" { assert_eq(m.dcut_count(), 0) } +///| test "caps_multiple_differential_cutsites" { // Two sequences with multiple differential sites // seq0: GAATTC...AAGCTT (EcoRI + HindIII sites) // seq1: GAATTT...AAGCTT (only HindIII site) let enzymes = @src.caps_sample_enzymes() let m = @src.caps_map( - [ - "AAAAAAAAGAGAATTCAAAAAGCTTAAAAAA", - "AAAAAAAAGAGAATTTAAAAAGCTTAAAAAA", - ], + ["AAAAAAAAGAGAATTCAAAAAGCTTAAAAAA", "AAAAAAAAGAGAATTTAAAAAGCTTAAAAAA"], enzymes, ) // EcoRI should produce a differential cutsite @@ -131,6 +133,7 @@ test "caps_multiple_differential_cutsites" { // Query methods // --------------------------------------------------------------------------- +///| test "caps_get_dcuts_at_position" { let seqs = @src.caps_sample_sequences() let enzymes = @src.caps_sample_enzymes() @@ -140,6 +143,7 @@ test "caps_get_dcuts_at_position" { assert_true(dcuts.length() >= 1) } +///| test "caps_has_dcuts_for_enzyme" { let seqs = @src.caps_sample_sequences() let enzymes = @src.caps_sample_enzymes() @@ -149,6 +153,7 @@ test "caps_has_dcuts_for_enzyme" { assert_true(!m.has_dcuts_for_enzyme("HindIII")) } +///| test "caps_dcut_count" { let seqs = @src.caps_sample_sequences() let enzymes = @src.caps_sample_enzymes() @@ -161,6 +166,7 @@ test "caps_dcut_count" { // Formatting // --------------------------------------------------------------------------- +///| test "caps_map_to_string" { let seqs = @src.caps_sample_sequences() let enzymes = @src.caps_sample_enzymes() @@ -171,6 +177,7 @@ test "caps_map_to_string" { assert_true(s.contains("length=30")) } +///| test "caps_map_report" { let seqs = @src.caps_sample_sequences() let enzymes = @src.caps_sample_enzymes() @@ -181,6 +188,7 @@ test "caps_map_report" { assert_true(r.contains("EcoRI")) } +///| test "caps_map_report_no_dcuts" { let enzymes = @src.caps_sample_enzymes() let m = @src.caps_map( @@ -195,6 +203,7 @@ test "caps_map_report_no_dcuts" { // Sample data // --------------------------------------------------------------------------- +///| test "caps_sample_sequences_length" { let seqs = @src.caps_sample_sequences() assert_eq(seqs.length(), 2) @@ -203,6 +212,7 @@ test "caps_sample_sequences_length" { assert_eq(seqs[0].length(), 30) } +///| test "caps_sample_sequences_ecori_site" { let seqs = @src.caps_sample_sequences() // seq0 should contain GAATTC (EcoRI site) @@ -212,6 +222,7 @@ test "caps_sample_sequences_ecori_site" { assert_true(!seqs[1].contains("GAATTC")) } +///| test "caps_sample_enzymes" { let enzymes = @src.caps_sample_enzymes() // Should contain EcoRI and HindIII @@ -219,8 +230,12 @@ test "caps_sample_enzymes" { let mut has_ecori = false let mut has_hindiii = false for e in enzymes { - if e.name == "EcoRI" { has_ecori = true } - if e.name == "HindIII" { has_hindiii = true } + if e.name == "EcoRI" { + has_ecori = true + } + if e.name == "HindIII" { + has_hindiii = true + } } assert_true(has_ecori) assert_true(has_hindiii) @@ -230,14 +245,15 @@ test "caps_sample_enzymes" { // Edge cases // --------------------------------------------------------------------------- +///| test "caps_three_sequences_differential" { // Three sequences: seq0 cut, seq1 not cut, seq2 cut let enzymes = @src.caps_sample_enzymes() let m = @src.caps_map( [ "AAAAAAAAGAGAATTCAAAAAAAAAAAAAA", // has GAATTC - "AAAAAAAAGAGAATTTAAAAAAAAAAAAAA", // has GAATTT (no cut) - "AAAAAAAAGAGAATTCAAAAAAAAAAAAAA", // has GAATTC + "AAAAAAAAGAGAATTTAAAAAAAAAAAAAA", // has GAATTT (no cut) + "AAAAAAAAGAGAATTCAAAAAAAAAAAAAA", // has GAATTC ], enzymes, ) @@ -250,6 +266,7 @@ test "caps_three_sequences_differential" { assert_eq(dc.blocked_in()[0], 1) } +///| test "caps_no_enzymes" { let seqs = @src.caps_sample_sequences() let m = @src.caps_map(seqs, []) diff --git a/test/moonbit/cellchat_test.mbt b/test/moonbit/cellchat_test.mbt index 95bfd817..cefcca2d 100644 --- a/test/moonbit/cellchat_test.mbt +++ b/test/moonbit/cellchat_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Bioconductor CellChat module - Cell-cell communication analysis. - test "lr_pair_create" { let pair = @src.lr_pair("TNF", "TNFR1") assert_eq(pair.ligand, "TNF") @@ -8,12 +7,14 @@ test "lr_pair_create" { assert_eq(pair.key, "TNF_TNFR1") } +///| test "lr_database" { let db = @src.cellchat_lr_database() assert_true(db.length() > 0) assert_eq(db[0].ligand, "TNF") } +///| test "mean_expr_basic" { let expr = [[10.0, 5.0], [20.0, 8.0], [30.0, 12.0]] let cell_types = ["TypeA", "TypeA", "TypeB"] @@ -21,6 +22,7 @@ test "mean_expr_basic" { assert_true((mean - 15.0).abs() < 0.01) } +///| test "mean_expr_no_cells" { let expr = [[10.0, 5.0]] let cell_types = ["TypeA"] @@ -28,40 +30,82 @@ test "mean_expr_no_cells" { assert_eq(mean, 0.0) } +///| test "analyze_basic" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=10, seed=42) + let result = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=10, + seed=42, + ) assert_true(result.scores.length() > 0) assert_eq(result.cell_types.length(), 3) assert_true(result.lr_pairs.length() > 0) } +///| test "analyze_permutation_effect" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result_small = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=42) - let result_large = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=50, seed=42) + let result_small = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=42, + ) + let result_large = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=50, + seed=42, + ) assert_true(result_small.scores.length() > 0) assert_true(result_large.scores.length() > 0) } +///| test "analyze_score_non_negative" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=42) + let result = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=42, + ) let mut i = 0 while i < result.scores.length() { assert_true(result.scores[i].score >= 0.0) - assert_true(result.scores[i].p_value >= 0.0 && result.scores[i].p_value <= 1.0) + assert_true( + result.scores[i].p_value >= 0.0 && result.scores[i].p_value <= 1.0, + ) i = i + 1 } } +///| test "get_significant" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=42, fdr=0.5) + let result = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=42, + fdr=0.5, + ) let sig = @src.cellchat_get_significant(result) assert_true(sig.length() >= 0) // All significant scores should have p_value < fdr @@ -72,14 +116,23 @@ test "get_significant" { } } +///| test "aggregate" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=42) + let result = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=42, + ) let agg = @src.cellchat_aggregate(result) assert_true(agg.size() > 0) } +///| test "sample_data_dimensions" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() assert_eq(expr.length(), 30) @@ -88,6 +141,7 @@ test "sample_data_dimensions" { assert_eq(gene_names.length(), 10) } +///| test "sample_cell_types" { let (_, cell_types, _) = @src.cellchat_sample_data() let mut type_a = 0 @@ -95,9 +149,13 @@ test "sample_cell_types" { let mut type_c = 0 let mut i = 0 while i < cell_types.length() { - if cell_types[i] == "TypeA" { type_a = type_a + 1 } - else if cell_types[i] == "TypeB" { type_b = type_b + 1 } - else if cell_types[i] == "TypeC" { type_c = type_c + 1 } + if cell_types[i] == "TypeA" { + type_a = type_a + 1 + } else if cell_types[i] == "TypeB" { + type_b = type_b + 1 + } else if cell_types[i] == "TypeC" { + type_c = type_c + 1 + } i = i + 1 } assert_eq(type_a, 10) @@ -105,35 +163,74 @@ test "sample_cell_types" { assert_eq(type_c, 10) } +///| test "get_top" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=42) + let result = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=42, + ) let top = @src.cellchat_get_top(result, 5) assert_eq(top.length(), 5) } +///| test "get_top_fewer_than_n" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=42) + let result = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=42, + ) let top = @src.cellchat_get_top(result, 100) assert_true(top.length() <= result.scores.length()) } +///| test "summary" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=42) + let result = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=42, + ) let summary = @src.cellchat_summary(result) assert_true(summary.length() > 0) } +///| test "analyze_seed_reproducible" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result1 = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=123) - let result2 = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=123) + let result1 = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=123, + ) + let result2 = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=123, + ) // Same seed should give same results assert_eq(result1.scores.length(), result2.scores.length()) } diff --git a/test/moonbit/chain_liftover_test.mbt b/test/moonbit/chain_liftover_test.mbt index 8dad6874..4c0939a2 100644 --- a/test/moonbit/chain_liftover_test.mbt +++ b/test/moonbit/chain_liftover_test.mbt @@ -154,7 +154,9 @@ test "cl_parse_chain_single_nucleotide_block" { ///| test "cl_parse_chain_id_preserved" { - let cf = @src.cl_parse_chain("chain 100 chr1 1000 + 100 200 chr2 500 + 50 150 99\n 100 0 0") + let cf = @src.cl_parse_chain( + "chain 100 chr1 1000 + 100 200 chr2 500 + 50 150 99\n 100 0 0", + ) assert_eq(cf.alignments[0].id, 99) } @@ -351,7 +353,9 @@ test "cl_get_chain_summary_basic" { ///| test "cl_get_chain_summary_empty_blocks" { - let cf = @src.cl_parse_chain("chain 5000 chr1 249250621 + 1 500 chr2 10000 + 1 500 43") + let cf = @src.cl_parse_chain( + "chain 5000 chr1 249250621 + 1 500 chr2 10000 + 1 500 43", + ) let summary = @src.cl_get_chain_summary(cf.alignments[0]) assert_eq(summary["total_block_size"], 0) assert_eq(summary["num_blocks"], 0) @@ -406,7 +410,9 @@ test "cl_chain_to_string_format" { ///| test "cl_chain_to_string_preserves_id" { - let cf = @src.cl_parse_chain("chain 7777 chr1 1000 + 100 200 chr2 500 + 50 150 99\n 100 0 0") + let cf = @src.cl_parse_chain( + "chain 7777 chr1 1000 + 100 200 chr2 500 + 50 150 99\n 100 0 0", + ) let s = @src.cl_chain_to_string(cf.alignments[0]) assert_true(s.contains("chain 7777")) assert_true(s.contains("99")) @@ -530,7 +536,9 @@ test "cl_chain_to_string_reverse_strand" { ///| test "cl_parse_chain_large_id" { - let cf = @src.cl_parse_chain("chain 100 chr1 1000 + 100 200 chr2 500 + 50 150 99999\n 100 0 0") + let cf = @src.cl_parse_chain( + "chain 100 chr1 1000 + 100 200 chr2 500 + 50 150 99999\n 100 0 0", + ) assert_eq(cf.alignments[0].id, 99999) } @@ -564,4 +572,4 @@ test "cl_find_chain_for_pos_at_boundary" { assert_true(r2 is None) let r3 = @src.cl_find_chain_for_pos(cf, "chr1", 6000) assert_true(r3 is Some(_)) -} \ No newline at end of file +} diff --git a/test/moonbit/checksum_test.mbt b/test/moonbit/checksum_test.mbt index 23af903a..df999342 100644 --- a/test/moonbit/checksum_test.mbt +++ b/test/moonbit/checksum_test.mbt @@ -50,4 +50,4 @@ test "verify_checksum_seguid" { let result = @src.checksum_seguid(seq) let verified = @src.verify_checksum(seq, result.checksum, "seguid") assert_true(verified) -} \ No newline at end of file +} diff --git a/test/moonbit/chromosome_visualization_test.mbt b/test/moonbit/chromosome_visualization_test.mbt index bdc64f5e..8c8197c2 100644 --- a/test/moonbit/chromosome_visualization_test.mbt +++ b/test/moonbit/chromosome_visualization_test.mbt @@ -20,11 +20,7 @@ test "chr_feature_type_values" { ///| test "chr_feature_creation" { - let feature = @src.ChrFeature::new( - name="Gene1", - start=100.0, - end=200.0, - ) + let feature = @src.ChrFeature::new(name="Gene1", start=100.0, end=200.0) assert_true((feature.start - 100.0).abs() < 1.0e-10) assert_true((feature.end - 200.0).abs() < 1.0e-10) assert_eq(feature.label, "Gene1") @@ -32,12 +28,8 @@ test "chr_feature_creation" { ///| test "chr_region_creation" { - let region = @src.ChrRegion::new( - name="Region1", - start=0.0, - end=1000.0, - ) - assert_true((region.start).abs() < 1.0e-10) + let region = @src.ChrRegion::new(name="Region1", start=0.0, end=1000.0) + assert_true(region.start.abs() < 1.0e-10) assert_true((region.end - 1000.0).abs() < 1.0e-10) assert_eq(region.label, "Region1") } @@ -57,50 +49,30 @@ test "chr_chromosome_creation" { ///| test "chr_chromosome_add_feature" { - let chr = @src.Chromosome::new( - name="chr1", - length=5000.0, - ) - let feature = @src.ChrFeature::new( - name="Gene1", - start=100.0, - end=200.0, - ) + let chr = @src.Chromosome::new(name="chr1", length=5000.0) + let feature = @src.ChrFeature::new(name="Gene1", start=100.0, end=200.0) let chr_with_feature = chr.add_feature(feature) assert_eq(chr_with_feature.features.length(), 1) } ///| test "chr_chromosome_add_region" { - let chr = @src.Chromosome::new( - name="chr1", - length=5000.0, - ) - let region = @src.ChrRegion::new( - name="Region1", - start=300.0, - end=500.0, - ) + let chr = @src.Chromosome::new(name="chr1", length=5000.0) + let region = @src.ChrRegion::new(name="Region1", start=300.0, end=500.0) let chr_with_region = chr.add_region(region) assert_eq(chr_with_region.regions.length(), 1) } ///| test "chr_chromosome_add_band" { - let chr = @src.Chromosome::new( - name="chr1", - length=5000.0, - ) + let chr = @src.Chromosome::new(name="chr1", length=5000.0) let chr_with_band = chr.add_band("Band1", 100.0, 200.0, "gpos50") assert_eq(chr_with_band.bands.length(), 1) } ///| test "chr_features_by_type" { - let chr = @src.Chromosome::new( - name="chr1", - length=5000.0, - ) + let chr = @src.Chromosome::new(name="chr1", length=5000.0) let exon1 = @src.ChrFeature::new( name="E1", start=100.0, @@ -128,20 +100,9 @@ test "chr_features_by_type" { ///| test "chr_features_in_region" { - let chr = @src.Chromosome::new( - name="chr1", - length=5000.0, - ) - let f1 = @src.ChrFeature::new( - name="F1", - start=100.0, - end=200.0, - ) - let f2 = @src.ChrFeature::new( - name="F2", - start=300.0, - end=400.0, - ) + let chr = @src.Chromosome::new(name="chr1", length=5000.0) + let f1 = @src.ChrFeature::new(name="F1", start=100.0, end=200.0) + let f2 = @src.ChrFeature::new(name="F2", start=300.0, end=400.0) let chr1 = chr.add_feature(f1).add_feature(f2) let in_region = chr1.features_in_region(150.0, 350.0) assert_eq(in_region.length(), 2) @@ -168,10 +129,7 @@ test "chr_diagram_creation" { length=5000.0, centromere_pos=2000.0, ) - let diagram = @src.ChrDiagram::new( - chromosomes=[chr], - title="Test Diagram", - ) + let diagram = @src.ChrDiagram::new(chromosomes=[chr], title="Test Diagram") assert_eq(diagram.chromosomes.length(), 1) assert_eq(diagram.title, "Test Diagram") } @@ -183,10 +141,7 @@ test "chr_to_svg_returns_string" { length=1000.0, centromere_pos=400.0, ) - let diagram = @src.ChrDiagram::new( - chromosomes=[chr], - title="Chromosome 1", - ) + let diagram = @src.ChrDiagram::new(chromosomes=[chr], title="Chromosome 1") let svg = diagram.to_svg() assert_true(svg.length() > 0) assert_true(svg.contains(" 0) assert_true(svg.contains(" 0) -} \ No newline at end of file +} diff --git a/test/moonbit/cibersort_test.mbt b/test/moonbit/cibersort_test.mbt index 9ac3372b..1168b02f 100644 --- a/test/moonbit/cibersort_test.mbt +++ b/test/moonbit/cibersort_test.mbt @@ -20,18 +20,19 @@ test "cib_signature_matrix_creation" { assert_eq(sig.matrix()[2][1], 1.0) } +///| test "cib_mixture_matrix_creation" { - let mix = @src.CibMixtureMatrix::new( - ["G1", "G2"], - ["S1", "S2"], - [[1.0, 2.0], [3.0, 4.0]], - ) + let mix = @src.CibMixtureMatrix::new(["G1", "G2"], ["S1", "S2"], [ + [1.0, 2.0], + [3.0, 4.0], + ]) assert_eq(mix.gene_names().length(), 2) assert_eq(mix.sample_names().length(), 2) assert_eq(mix.sample_names()[0], "S1") assert_eq(mix.matrix()[1][0], 3.0) } +///| test "cib_result_accessors" { // Use cib_run to get a real result and test accessors let sig = @src.cib_default_signature() @@ -49,6 +50,7 @@ test "cib_result_accessors" { // Built-in signature and marker genes // --------------------------------------------------------------------------- +///| test "cib_cell_type_names_count" { let names = @src.cib_cell_type_names() assert_eq(names.length(), 10) @@ -56,6 +58,7 @@ test "cib_cell_type_names_count" { assert_eq(names[9], "Mast cells") } +///| test "cib_marker_genes_count" { let genes = @src.cib_marker_genes() // 10 cell types × 4 markers each = 40 genes @@ -64,6 +67,7 @@ test "cib_marker_genes_count" { assert_eq(genes[4], "CD8A") // T cell CD8 marker } +///| test "cib_default_signature_dimensions" { let sig = @src.cib_default_signature() assert_eq(sig.gene_names().length(), 40) @@ -78,6 +82,7 @@ test "cib_default_signature_dimensions" { // NNLS deconvolution correctness // --------------------------------------------------------------------------- +///| test "cib_run_single_cell_type_recovery" { // Build a simple mixture: pure B cells (column 0 of signature) let sig = @src.cib_default_signature() @@ -100,6 +105,7 @@ test "cib_run_single_cell_type_recovery" { assert_true(r0.pearson_r() > 0.9) } +///| test "cib_run_mixed_composition_recovery" { // Use the built-in sample mixture generator let sig = @src.cib_default_signature() @@ -120,6 +126,7 @@ test "cib_run_mixed_composition_recovery" { } } +///| test "cib_run_sample1_dominant_t_cell_cd8" { // Sample1 was constructed as 60% T cells CD8 + 30% B cells + 10% NK cells let sig = @src.cib_default_signature() @@ -134,6 +141,7 @@ test "cib_run_sample1_dominant_t_cell_cd8" { assert_true(t_cd8 > nk) } +///| test "cib_run_sample2_dominant_monocytes" { // Sample2: 50% Monocytes + 30% Macrophages M1 + 20% Macrophages M2 let sig = @src.cib_default_signature() @@ -158,6 +166,7 @@ test "cib_run_sample2_dominant_monocytes" { ) } +///| test "cib_run_pearson_high_for_clean_data" { // For synthetic mixtures constructed from the signature, fit should be good let sig = @src.cib_default_signature() @@ -168,6 +177,7 @@ test "cib_run_pearson_high_for_clean_data" { } } +///| test "cib_run_handles_partial_gene_overlap" { // Mixture has only a subset of signature genes let sig = @src.cib_default_signature() @@ -186,14 +196,14 @@ test "cib_run_handles_partial_gene_overlap" { assert_true(r0.get_fraction("B cells") > 0.3) } +///| test "cib_run_empty_mixture_genes" { // Mixture has no genes in common with the signature -> all zeros let sig = @src.cib_default_signature() - let mix = @src.CibMixtureMatrix::new( - ["NONEXIST1", "NONEXIST2"], - ["Empty"], - [[1.0], [2.0]], - ) + let mix = @src.CibMixtureMatrix::new(["NONEXIST1", "NONEXIST2"], ["Empty"], [ + [1.0], + [2.0], + ]) let result = @src.cib_run(sig, mix) assert_eq(result.sample_names().length(), 1) let r0 = result.results()[0] @@ -206,6 +216,7 @@ test "cib_run_empty_mixture_genes" { // to_string formatting // --------------------------------------------------------------------------- +///| test "cib_deconvolution_to_string" { let sig = @src.cib_default_signature() let mix = @src.cib_sample_mixture() @@ -220,6 +231,7 @@ test "cib_deconvolution_to_string" { // NNLS edge cases // --------------------------------------------------------------------------- +///| test "cib_get_fraction_unknown_type" { // Use cib_run to get a real result and test get_fraction let sig = @src.cib_default_signature() @@ -233,6 +245,7 @@ test "cib_get_fraction_unknown_type" { assert_true(b_frac >= 0.0) } +///| test "cib_run_with_custom_tolerance" { let sig = @src.cib_default_signature() let mix = @src.cib_sample_mixture() diff --git a/test/moonbit/circ_seq_test.mbt b/test/moonbit/circ_seq_test.mbt index 8453b306..0bd88584 100644 --- a/test/moonbit/circ_seq_test.mbt +++ b/test/moonbit/circ_seq_test.mbt @@ -24,7 +24,7 @@ test "CircSeq::circ_gc_content" { test "CircSeq::circ_gc_content AT rich" { let circ = @src.CircSeq::new(sequence="ATATATAT") let gc = circ.circ_gc_content() - assert_true((gc).abs() < 1.0e-10) + assert_true(gc.abs() < 1.0e-10) } ///| diff --git a/test/moonbit/cluster_experiment_test.mbt b/test/moonbit/cluster_experiment_test.mbt index 7b2f652c..d4a9e983 100644 --- a/test/moonbit/cluster_experiment_test.mbt +++ b/test/moonbit/cluster_experiment_test.mbt @@ -128,8 +128,8 @@ test "ce_center_columns_basic" { // col 1: mean = 15 -> centered [-5, 5] let m = [[1.0, 10.0], [3.0, 20.0]] let c = @src.ce_center_columns(m) - assert_true((c[0][0] - (-1.0)).abs() < 0.001) - assert_true((c[0][1] - (-5.0)).abs() < 0.001) + assert_true((c[0][0] - -1.0).abs() < 0.001) + assert_true((c[0][1] - -5.0).abs() < 0.001) assert_true((c[1][0] - 1.0).abs() < 0.001) assert_true((c[1][1] - 5.0).abs() < 0.001) } @@ -376,11 +376,7 @@ test "ce_hclust_cut_k2" { ///| test "ce_hclust_cut_k_equals_n" { - let dist = [ - [0.0, 0.5, 0.5], - [0.5, 0.0, 0.5], - [0.5, 0.5, 0.0], - ] + let dist = [[0.0, 0.5, 0.5], [0.5, 0.0, 0.5], [0.5, 0.5, 0.0]] let labels = @src.ce_hclust_cut(dist, 3) assert_eq(labels.length(), 3) // each sample in its own cluster @@ -527,12 +523,7 @@ test "ce_sequential_cluster_isolates_small" { test "ce_rsec_pipeline" { // 4 samples, 2 clear clusters; small enough that sequential splits are // not triggered (each consensus cluster has < 4 points). - let data = [ - [0.0, 0.0], - [0.1, 0.0], - [10.0, 10.0], - [10.1, 10.0], - ] + let data = [[0.0, 0.0], [0.1, 0.0], [10.0, 10.0], [10.1, 10.0]] let params = @src.ce_default_params() let result = @src.ce_rsec(data, params) assert_eq(result.labels.length(), 4) @@ -719,12 +710,7 @@ test "ce_default_params" { ///| test "ce_default_params_used_in_rsec" { // Smoke test: default params produce a valid ClusterExperiment - let data = [ - [0.0, 0.0], - [0.1, 0.1], - [5.0, 5.0], - [5.1, 5.1], - ] + let data = [[0.0, 0.0], [0.1, 0.1], [5.0, 5.0], [5.1, 5.1]] let params = @src.ce_default_params() let result = @src.ce_rsec(data, params) assert_true(result.labels.length() == 4) diff --git a/test/moonbit/cnvkit_test.mbt b/test/moonbit/cnvkit_test.mbt index 0df6e9db..3b09e281 100644 --- a/test/moonbit/cnvkit_test.mbt +++ b/test/moonbit/cnvkit_test.mbt @@ -1,32 +1,22 @@ ///| test "cnvkit_create_probe" { let probe = @src.CNVProbe::new( - "probe_001", - "chr1", - 1000000, - 1001000, - -0.5, - 1.0 + "probe_001", "chr1", 1000000, 1001000, -0.5, 1.0, ) - + assert_eq(probe.probe_id, "probe_001") assert_eq(probe.chromosome, "chr1") assert_eq(probe.start, 1000000) assert_eq(probe.end, 1001000) - assert_true((probe.log2_ratio - (-0.5)).abs() < 0.001) + assert_true((probe.log2_ratio - -0.5).abs() < 0.001) } ///| test "cnvkit_create_segment" { let segment = @src.CNVSegment::new( - "chr1", - 1000000, - 2000000, - 50, - -0.8, - "deletion" + "chr1", 1000000, 2000000, 50, -0.8, "deletion", ) - + assert_eq(segment.chromosome, "chr1") assert_eq(segment.start, 1000000) assert_eq(segment.end, 2000000) @@ -37,20 +27,15 @@ test "cnvkit_create_segment" { ///| test "cnvkit_dataset_operations" { let mut dataset = @src.CNVDataset::new() - + assert_eq(dataset.count_probes(), 0) - + let probe = @src.CNVProbe::new( - "probe_001", - "chr1", - 1000000, - 1001000, - -0.5, - 1.0 + "probe_001", "chr1", 1000000, 1001000, -0.5, 1.0, ) - + dataset = dataset.add_probe(probe) - + assert_eq(dataset.count_probes(), 1) assert_eq(dataset.chromosomes.length(), 1) assert_eq(dataset.chromosomes[0], "chr1") @@ -59,15 +44,19 @@ test "cnvkit_dataset_operations" { ///| test "cnvkit_filter_chromosome" { let mut dataset = @src.CNVDataset::new() - - let probe1 = @src.CNVProbe::new("probe_001", "chr1", 1000000, 1001000, -0.5, 1.0) - let probe2 = @src.CNVProbe::new("probe_002", "chr2", 2000000, 2001000, 0.5, 1.0) - + + let probe1 = @src.CNVProbe::new( + "probe_001", "chr1", 1000000, 1001000, -0.5, 1.0, + ) + let probe2 = @src.CNVProbe::new( + "probe_002", "chr2", 2000000, 2001000, 0.5, 1.0, + ) + dataset = dataset.add_probe(probe1) dataset = dataset.add_probe(probe2) - + let filtered = dataset.filter_chromosome("chr1") - + assert_eq(filtered.count_probes(), 1) assert_eq(filtered.chromosomes.length(), 1) } @@ -75,24 +64,26 @@ test "cnvkit_filter_chromosome" { ///| test "cnvkit_cbs_segmentation" { let probes : Array[@src.CNVProbe] = Array::new() - + // Create probes with a clear change point let mut i = 0 while i < 20 { let ratio = if i < 10 { -0.8 } else { 0.1 } - probes.push(@src.CNVProbe::new( - "probe_" + i.to_string(), - "chr1", - 1000000 + i * 1000, - 1000000 + i * 1000 + 100, - ratio, - 1.0 - )) + probes.push( + @src.CNVProbe::new( + "probe_" + i.to_string(), + "chr1", + 1000000 + i * 1000, + 1000000 + i * 1000 + 100, + ratio, + 1.0, + ), + ) i = i + 1 } - + let result = @src.cbs_segment(probes, 0.05) - + assert_true(result.n_segments > 0) assert_true(result.breakpoints.length() > 0) } @@ -100,24 +91,26 @@ test "cnvkit_cbs_segmentation" { ///| test "cnvkit_smooth_log2_ratios" { let probes : Array[@src.CNVProbe] = Array::new() - + let mut i = 0 while i < 10 { - probes.push(@src.CNVProbe::new( - "probe_" + i.to_string(), - "chr1", - 1000000 + i * 1000, - 1000000 + i * 1000 + 100, - (i.to_double() - 5.0) * 0.1, - 1.0 - )) + probes.push( + @src.CNVProbe::new( + "probe_" + i.to_string(), + "chr1", + 1000000 + i * 1000, + 1000000 + i * 1000 + 100, + (i.to_double() - 5.0) * 0.1, + 1.0, + ), + ) i = i + 1 } - + let smoothed = @src.smooth_log2_ratios(probes, 3) - + assert_eq(smoothed.length(), 10) - + // Check that smoothed values are reasonable let val = smoothed[0].log2_ratio assert_true(val.abs() < 10.0) @@ -135,11 +128,11 @@ test "cnvkit_detect_breakpoints" { let segments : Array[@src.CNVSegment] = [ @src.CNVSegment::new("chr1", 1000000, 2000000, 50, -0.8, "deletion"), @src.CNVSegment::new("chr1", 2000000, 3000000, 50, 0.1, "neutral"), - @src.CNVSegment::new("chr1", 3000000, 4000000, 50, 0.9, "amplification") + @src.CNVSegment::new("chr1", 3000000, 4000000, 50, 0.9, "amplification"), ] - + let breakpoints = @src.detect_breakpoints(segments, 0.3) - + assert_true(breakpoints.length() > 0) } @@ -148,11 +141,11 @@ test "cnvkit_call_copy_numbers" { let segments : Array[@src.CNVSegment] = [ @src.CNVSegment::new("chr1", 1000000, 2000000, 50, -0.8, "deletion"), @src.CNVSegment::new("chr1", 2000000, 3000000, 50, 0.0, "neutral"), - @src.CNVSegment::new("chr1", 3000000, 4000000, 50, 0.8, "amplification") + @src.CNVSegment::new("chr1", 3000000, 4000000, 50, 0.8, "amplification"), ] - + let calls = @src.call_copy_numbers(segments, 2) - + assert_eq(calls.length(), 3) assert_eq(calls[0].state, "deletion") assert_eq(calls[1].state, "neutral") @@ -163,7 +156,7 @@ test "cnvkit_call_copy_numbers" { test "cnvkit_summarize_dataset" { let dataset = @src.create_example_cnv_dataset() let summary = @src.summarize_cnv(dataset) - + assert_true(summary.total_probes > 0) assert_true(summary.total_segments >= 0) } @@ -171,7 +164,7 @@ test "cnvkit_summarize_dataset" { ///| test "cnvkit_create_example" { let dataset = @src.create_example_cnv_dataset() - + assert_true(dataset.count_probes() > 0) assert_true(dataset.chromosomes.length() >= 2) } @@ -180,7 +173,7 @@ test "cnvkit_create_example" { test "cnvkit_summarize_string" { let dataset = @src.create_example_cnv_dataset() let summary_str = @src.cbs_summarize_dataset(dataset) - + assert_true(summary_str.contains("CNV Dataset Summary")) assert_true(summary_str.contains("Total probes:")) } @@ -189,7 +182,7 @@ test "cnvkit_summarize_string" { test "cnvkit_empty_segmentation" { let empty_probes : Array[@src.CNVProbe] = Array::new() let result = @src.cbs_segment(empty_probes, 0.05) - + assert_eq(result.n_segments, 0) assert_eq(result.breakpoints.length(), 0) } @@ -198,9 +191,9 @@ test "cnvkit_empty_segmentation" { test "cnvkit_single_probe" { let probe = @src.CNVProbe::new("p1", "chr1", 100, 200, 0.5, 1.0) let probes : Array[@src.CNVProbe] = [probe] - + let result = @src.cbs_segment(probes, 0.05) - + assert_eq(result.n_segments, 1) } @@ -208,6 +201,6 @@ test "cnvkit_single_probe" { test "cnvkit_smooth_edge_cases" { let empty_probes : Array[@src.CNVProbe] = Array::new() let smoothed = @src.smooth_log2_ratios(empty_probes, 3) - + assert_eq(smoothed.length(), 0) } diff --git a/test/moonbit/codon_advanced_test.mbt b/test/moonbit/codon_advanced_test.mbt index 6a20cc4d..d04efc7b 100644 --- a/test/moonbit/codon_advanced_test.mbt +++ b/test/moonbit/codon_advanced_test.mbt @@ -179,18 +179,29 @@ test "codon_advanced_calculate_enc" { ///| test "codon_advanced_calculate_enc_low_bias" { let counts = Map([], capacity=24) - counts.set("GCA", 1); counts.set("GCC", 1) - counts.set("GCG", 1); counts.set("GCT", 1) - counts.set("AAA", 1); counts.set("AAG", 1) - counts.set("GAA", 1); counts.set("GAG", 1) - counts.set("CTT", 1); counts.set("CTC", 1) - counts.set("CTA", 1); counts.set("CTG", 1) - counts.set("TTA", 1); counts.set("TTG", 1) - counts.set("ATT", 1); counts.set("ATC", 1) + counts.set("GCA", 1) + counts.set("GCC", 1) + counts.set("GCG", 1) + counts.set("GCT", 1) + counts.set("AAA", 1) + counts.set("AAG", 1) + counts.set("GAA", 1) + counts.set("GAG", 1) + counts.set("CTT", 1) + counts.set("CTC", 1) + counts.set("CTA", 1) + counts.set("CTG", 1) + counts.set("TTA", 1) + counts.set("TTG", 1) + counts.set("ATT", 1) + counts.set("ATC", 1) counts.set("ATA", 1) - counts.set("CGT", 1); counts.set("CGC", 1) - counts.set("CGA", 1); counts.set("CGG", 1) - counts.set("AGA", 1); counts.set("AGG", 1) + counts.set("CGT", 1) + counts.set("CGC", 1) + counts.set("CGA", 1) + counts.set("CGG", 1) + counts.set("AGA", 1) + counts.set("AGG", 1) let usage = @src.CodonUsageTable::new(counts) let enc_val = @src.calculate_enc(usage) @@ -395,4 +406,4 @@ test "codon_advanced_all_stop_codons" { assert_eq(@src.get_amino_acid("TAA"), "*") assert_eq(@src.get_amino_acid("TAG"), "*") assert_eq(@src.get_amino_acid("TGA"), "*") -} \ No newline at end of file +} diff --git a/test/moonbit/compass_test.mbt b/test/moonbit/compass_test.mbt index 7bcf69b9..f7206c55 100644 --- a/test/moonbit/compass_test.mbt +++ b/test/moonbit/compass_test.mbt @@ -7,22 +7,8 @@ test "compass_record_creation" { let r = @src.CompassRecord::new( - "query1.msa", - "template1.msa", - 5, - 4, - 120, - 110, - 185.5, - 3.5e-10, - 28.5, - 1, - 120, - 1, - 110, - "MALKSLVRLFG", - "MGVKSAVKT", - ": :: :::", + "query1.msa", "template1.msa", 5, 4, 120, 110, 185.5, 3.5e-10, 28.5, 1, 120, + 1, 110, "MALKSLVRLFG", "MGVKSAVKT", ": :: :::", ) assert_eq(r.query_name(), "query1.msa") assert_eq(r.template_name(), "template1.msa") @@ -42,10 +28,10 @@ test "compass_record_creation" { assert_eq(r.consensus_line(), ": :: :::") } +///| test "compass_record_accessors_individual" { let r = @src.CompassRecord::new( - "q", "t", 1, 2, 10, 20, 50.0, 0.001, 35.0, - 5, 50, 10, 60, "ACGT", "ACGT", ":::", + "q", "t", 1, 2, 10, 20, 50.0, 0.001, 35.0, 5, 50, 10, 60, "ACGT", "ACGT", ":::", ) assert_eq(r.query_name(), "q") assert_eq(r.template_name(), "t") @@ -65,13 +51,11 @@ test "compass_record_accessors_individual" { assert_eq(r.consensus_line(), ":::") } +///| test "compass_record_to_string" { let r = @src.CompassRecord::new( - "query1.msa", "template1.msa", - 5, 4, 120, 110, - 185.5, 3.5e-10, 28.5, - 1, 120, 1, 110, - "MALKSLVRLFG", "MGVKSAVKT", ": :: :::", + "query1.msa", "template1.msa", 5, 4, 120, 110, 185.5, 3.5e-10, 28.5, 1, 120, + 1, 110, "MALKSLVRLFG", "MGVKSAVKT", ": :: :::", ) let s = r.to_string() assert_true(s.contains("query1.msa")) @@ -83,56 +67,66 @@ test "compass_record_to_string" { // Parsing: sample data // --------------------------------------------------------------------------- +///| test "compass_parse_sample_data_count" { let text = @src.compass_sample_data() let records = @src.parse_compass(text) assert_eq(records.length(), 2) } +///| test "compass_parse_first_record_query_name" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].query_name(), "query1.msa") } +///| test "compass_parse_first_record_template_name" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].template_name(), "template1.msa") } +///| test "compass_parse_first_record_n_seqs" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].query_n_seqs(), 5) assert_eq(records[0].template_n_seqs(), 4) } +///| test "compass_parse_first_record_n_cols" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].query_n_cols(), 120) assert_eq(records[0].template_n_cols(), 110) } +///| test "compass_parse_first_record_sw_score" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].sw_score(), 185.5) } +///| test "compass_parse_first_record_e_value" { let records = @src.parse_compass(@src.compass_sample_data()) // Use tolerance comparison due to floating-point precision assert_true((records[0].e_value() - 3.5e-10).abs() < 1.0e-20) } +///| test "compass_parse_first_record_identity" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].percentage_identity(), 28.5) } +///| test "compass_parse_first_record_alignment" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].aligned_query(), "MALKSLVRLFG") assert_eq(records[0].aligned_template(), "MGVKSAVKT") } +///| test "compass_parse_first_record_positions" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].query_start(), 1) @@ -141,11 +135,13 @@ test "compass_parse_first_record_positions" { assert_eq(records[0].template_end(), 110) } +///| test "compass_parse_first_record_consensus" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].consensus_line(), ": :: :::") } +///| test "compass_parse_second_record" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[1].query_name(), "query2.msa") @@ -164,16 +160,19 @@ test "compass_parse_second_record" { // Version extraction // --------------------------------------------------------------------------- +///| test "compass_version_extraction" { let text = @src.compass_sample_data() let version = @src.compass_version(text) assert_eq(version, "2.4.2") } +///| test "compass_version_empty_input" { assert_eq(@src.compass_version(""), "") } +///| test "compass_version_no_version_line" { let text = "Some other content\nwithout version\n" assert_eq(@src.compass_version(text), "") @@ -183,6 +182,7 @@ test "compass_version_no_version_line" { // Filtering // --------------------------------------------------------------------------- +///| test "compass_filter_by_evalue" { let records = @src.parse_compass(@src.compass_sample_data()) // E-values: 3.5e-10 and 1.2e-05 @@ -191,18 +191,21 @@ test "compass_filter_by_evalue" { assert_eq(filtered[0].query_name(), "query1.msa") } +///| test "compass_filter_by_evalue_all_pass" { let records = @src.parse_compass(@src.compass_sample_data()) let filtered = @src.compass_filter_by_evalue(records, 1.0) assert_eq(filtered.length(), 2) } +///| test "compass_filter_by_evalue_none_pass" { let records = @src.parse_compass(@src.compass_sample_data()) let filtered = @src.compass_filter_by_evalue(records, 1.0e-20) assert_eq(filtered.length(), 0) } +///| test "compass_filter_by_identity" { let records = @src.parse_compass(@src.compass_sample_data()) // Identities: 28.5 and 15.3 @@ -211,6 +214,7 @@ test "compass_filter_by_identity" { assert_eq(filtered[0].query_name(), "query1.msa") } +///| test "compass_filter_by_identity_all_pass" { let records = @src.parse_compass(@src.compass_sample_data()) let filtered = @src.compass_filter_by_identity(records, 10.0) @@ -221,16 +225,17 @@ test "compass_filter_by_identity_all_pass" { // Alignment length // --------------------------------------------------------------------------- +///| test "compass_alignment_length" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(@src.compass_alignment_length(records[0]), 11) assert_eq(@src.compass_alignment_length(records[1]), 10) } +///| test "compass_alignment_length_empty" { let r = @src.CompassRecord::new( - "", "", 0, 0, 0, 0, 0.0, 0.0, 0.0, - 0, 0, 0, 0, "", "", "", + "", "", 0, 0, 0, 0, 0.0, 0.0, 0.0, 0, 0, 0, 0, "", "", "", ) assert_eq(@src.compass_alignment_length(r), 0) } @@ -239,6 +244,7 @@ test "compass_alignment_length_empty" { // Summary // --------------------------------------------------------------------------- +///| test "compass_summary_content" { let records = @src.parse_compass(@src.compass_sample_data()) let summary = @src.compass_summary(records) @@ -250,6 +256,7 @@ test "compass_summary_content" { assert_true(summary.contains("28.5")) } +///| test "compass_summary_empty" { let records : Array[@src.CompassRecord] = [] let summary = @src.compass_summary(records) @@ -260,16 +267,19 @@ test "compass_summary_empty" { // Edge cases // --------------------------------------------------------------------------- +///| test "compass_parse_empty_input" { let records = @src.parse_compass("") assert_eq(records.length(), 0) } +///| test "compass_parse_whitespace_only" { let records = @src.parse_compass(" \n \n \n") assert_eq(records.length(), 0) } +///| test "compass_parse_single_record" { let text = "COMPASS version 2.4.2\n" + "Query alignment: single.msa\n" + @@ -296,10 +306,10 @@ test "compass_parse_single_record" { assert_eq(records[0].consensus_line(), ": : :") } +///| test "compass_parse_missing_fields" { // Record with only version and query name (missing other fields) - let text = "COMPASS version 1.0.0\n" + - "Query alignment: partial.msa\n" + let text = "COMPASS version 1.0.0\n" + "Query alignment: partial.msa\n" let records = @src.parse_compass(text) assert_eq(records.length(), 1) assert_eq(records[0].query_name(), "partial.msa") @@ -316,6 +326,7 @@ test "compass_parse_missing_fields" { assert_eq(records[0].consensus_line(), "") } +///| test "compass_parse_no_consensus_line" { // Alignment block without a consensus line between Query and Template let text = "COMPASS version 2.4.2\n" + @@ -337,6 +348,7 @@ test "compass_parse_no_consensus_line" { assert_eq(records[0].consensus_line(), "") } +///| test "compass_parse_three_records" { let mut text = "" text = text + "COMPASS version 2.4.2\n" @@ -360,6 +372,7 @@ test "compass_parse_three_records" { assert_eq(records[2].query_name(), "q3.msa") } +///| test "compass_parse_version_only" { let text = "COMPASS version 3.0.0\n" let records = @src.parse_compass(text) @@ -367,17 +380,20 @@ test "compass_parse_version_only" { assert_eq(records[0].query_name(), "") } +///| test "compass_sample_data_has_version" { let text = @src.compass_sample_data() assert_true(text.contains("COMPASS version 2.4.2")) } +///| test "compass_sample_data_has_evalue" { let text = @src.compass_sample_data() assert_true(text.contains("3.5e-10")) assert_true(text.contains("1.2e-05")) } +///| test "compass_filter_empty_records" { let records : Array[@src.CompassRecord] = [] let by_evalue = @src.compass_filter_by_evalue(records, 1.0) diff --git a/test/moonbit/compound_test.mbt b/test/moonbit/compound_test.mbt index 99123022..07ef7572 100644 --- a/test/moonbit/compound_test.mbt +++ b/test/moonbit/compound_test.mbt @@ -9,7 +9,9 @@ test "compound_new" { ///| test "compound_with_chemical" { - let c = @src.Compound::with_chemical("C0001", "Glucose", "C6H12O6", 0, "C(C1C(C(C(C(O1)O)O)O)O)O") + let c = @src.Compound::with_chemical( + "C0001", "Glucose", "C6H12O6", 0, "C(C1C(C(C(C(O1)O)O)O)O)O", + ) assert_eq(c.get_id(), "C0001") assert_eq(c.get_formula(), "C6H12O6") assert_eq(c.get_charge(), 0) diff --git a/test/moonbit/consensus_cluster_plus_test.mbt b/test/moonbit/consensus_cluster_plus_test.mbt index 9a67f008..6efe489a 100644 --- a/test/moonbit/consensus_cluster_plus_test.mbt +++ b/test/moonbit/consensus_cluster_plus_test.mbt @@ -9,24 +9,19 @@ test "consensus_cluster_plus_consensus_matrix" { [10.0, 11.0, 12.0], [11.0, 12.0, 13.0], ] - + let consensus = @src.ccp_calculate_consensus_matrix(data, 2, 10, 0.8) - + assert_true(consensus.length() == 4) assert_true(consensus[0].length() == 4) } ///| test "consensus_cluster_plus_kmeans" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [10.0, 11.0], - [11.0, 12.0], - ] - + let data = [[1.0, 2.0], [2.0, 3.0], [10.0, 11.0], [11.0, 12.0]] + let labels = @src.ccp_kmeans_cluster(data, 2) - + assert_true(labels.length() == 4) } @@ -38,9 +33,9 @@ test "consensus_cluster_plus_consensus_score" { [0.8, 0.8, 1.0, 0.9], [0.7, 0.7, 0.9, 1.0], ] - + let score = @src.ccp_calculate_consensus_score(consensus) - + assert_true(score > 0.5) } @@ -54,9 +49,9 @@ test "consensus_cluster_plus_find_optimal_k" { [20.0, 21.0, 22.0], [21.0, 22.0, 23.0], ] - + let (best_k, scores) = @src.ccp_find_optimal_k(data, 2, 4) - + assert_true(best_k >= 2 && best_k <= 4) assert_true(scores.length() == 3) } @@ -69,9 +64,9 @@ test "consensus_cluster_plus_main" { [10.0, 11.0, 12.0], [11.0, 12.0, 13.0], ] - + let result = @src.bio_consensus_cluster(data, 2) - + assert_true(result.k == 2) assert_true(result.cluster_labels.length() == 4) assert_true(result.consensus_matrix.length() == 4) @@ -79,17 +74,13 @@ test "consensus_cluster_plus_main" { ///| test "consensus_cluster_plus_bio_api" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [10.0, 11.0], - ] - + let data = [[1.0, 2.0], [2.0, 3.0], [10.0, 11.0]] + let (best_k, scores) = @src.bio_consensus_cluster_find_optimal_k(data, 2, 3) let consensus = @src.ccp_calculate_consensus_matrix(data, 2, 10, 0.8) let score = @src.bio_consensus_cluster_consensus_score(consensus) - + assert_true(best_k >= 2) assert_true(scores.length() > 0) assert_true(score >= 0.0) -} \ No newline at end of file +} diff --git a/test/moonbit/crystal_test.mbt b/test/moonbit/crystal_test.mbt index a8ecb034..7f4d43f3 100644 --- a/test/moonbit/crystal_test.mbt +++ b/test/moonbit/crystal_test.mbt @@ -51,7 +51,7 @@ test "unit_cell_volume_hexagonal" { gamma=120.0, ) let v = @src.unit_cell_volume(cell) - let expected = 5.0 * 5.0 * 7.0 * (3.0).sqrt() / 2.0 + let expected = 5.0 * 5.0 * 7.0 * 3.0.sqrt() / 2.0 assert_true((v - expected).abs() < 0.01) } @@ -142,13 +142,7 @@ test "lookup_space_group_unknown" { ///| test "crystal_atom_construction" { - let a = @src.CrystalAtom::new( - label="C1", - element="C", - x=0.5, - y=0.5, - z=0.5, - ) + let a = @src.CrystalAtom::new(label="C1", element="C", x=0.5, y=0.5, z=0.5) assert_eq(a.label, "C1") assert_eq(a.element, "C") assert_true((a.x - 0.5).abs() < 0.001) @@ -216,7 +210,7 @@ test "fractional_to_cartesian_orthorhombic" { beta=90.0, gamma=90.0, ) - let(x, y, z) = @src.fractional_to_cartesian(cell, 0.5, 0.25, 0.1) + let (x, y, z) = @src.fractional_to_cartesian(cell, 0.5, 0.25, 0.1) assert_true((x - 5.0).abs() < 0.001) assert_true((y - 5.0).abs() < 0.001) assert_true((z - 3.0).abs() < 0.001) @@ -232,7 +226,7 @@ test "cartesian_to_fractional_orthorhombic" { beta=90.0, gamma=90.0, ) - let(xf, yf, zf) = @src.cartesian_to_fractional(cell, 5.0, 5.0, 3.0) + let (xf, yf, zf) = @src.cartesian_to_fractional(cell, 5.0, 5.0, 3.0) assert_true((xf - 0.5).abs() < 0.001) assert_true((yf - 0.25).abs() < 0.001) assert_true((zf - 0.1).abs() < 0.001) @@ -251,8 +245,8 @@ test "coord_conversion_roundtrip_orthorhombic" { let xf0 = 0.3 let yf0 = 0.6 let zf0 = 0.9 - let(x, y, z) = @src.fractional_to_cartesian(cell, xf0, yf0, zf0) - let(xf, yf, zf) = @src.cartesian_to_fractional(cell, x, y, z) + let (x, y, z) = @src.fractional_to_cartesian(cell, xf0, yf0, zf0) + let (xf, yf, zf) = @src.cartesian_to_fractional(cell, x, y, z) assert_true((xf - xf0).abs() < 0.01) assert_true((yf - yf0).abs() < 0.01) assert_true((zf - zf0).abs() < 0.01) @@ -300,7 +294,7 @@ test "crystal_atom_distance_missing_atom" { ///| test "center_of_mass_basic" { let s = @src.crystal_sample_structure() - let(cx, cy, cz) = @src.center_of_mass(s) + let (cx, cy, cz) = @src.center_of_mass(s) // Center of mass should be a 3-tuple of finite doubles. assert_true(cx >= 0.0 || cx < 0.0) // just check it's a number assert_true(cy >= 0.0 || cy < 0.0) @@ -319,14 +313,14 @@ test "center_of_mass_empty_structure" { ) let s = @src.CrystalStructure::new( name="empty", - cell=cell, + cell~, space_group=@src.SpaceGroup::new(number=1, symbol="P 1"), atoms=[], bonds=[], z=1, molecular_weight=0.0, ) - let(cx, cy, cz) = @src.center_of_mass(s) + let (cx, cy, cz) = @src.center_of_mass(s) assert_true((cx - 0.0).abs() < 0.001) assert_true((cy - 0.0).abs() < 0.001) assert_true((cz - 0.0).abs() < 0.001) @@ -363,7 +357,7 @@ test "cif_block_loop_set_get" { let headers = ["_atom_site_label", "_atom_site_x"] let rows = [["C1", "0.5"], ["C2", "0.6"]] block.set_loop("_atom_site_label", headers, rows) - let(h, r) = block.get_loop("_atom_site_label") + let (h, r) = block.get_loop("_atom_site_label") assert_eq(h.length(), 2) assert_eq(r.length(), 2) assert_eq(r[0][0], "C1") @@ -372,7 +366,7 @@ test "cif_block_loop_set_get" { ///| test "cif_block_loop_missing_returns_empty" { let block = @src.CifBlock::new(name="test") - let(h, r) = block.get_loop("_nonexistent") + let (h, r) = block.get_loop("_nonexistent") assert_eq(h.length(), 0) assert_eq(r.length(), 0) } @@ -403,7 +397,7 @@ test "parse_cif_with_loop" { #|C3 0.7 let blocks = @src.parse_cif(text) assert_eq(blocks.length(), 1) - let(h, r) = blocks[0].get_loop("_atom_site_label") + let (h, r) = blocks[0].get_loop("_atom_site_label") assert_eq(h.length(), 2) assert_eq(r.length(), 3) assert_eq(r[0][0], "C1") @@ -521,7 +515,7 @@ test "crystal_summary_density_zero_when_mw_zero" { ) let s = @src.CrystalStructure::new( name="test", - cell=cell, + cell~, space_group=@src.SpaceGroup::new(number=1, symbol="P 1"), atoms=[], bonds=[], diff --git a/test/moonbit/csaw_test.mbt b/test/moonbit/csaw_test.mbt index 7ae988a4..094488bf 100644 --- a/test/moonbit/csaw_test.mbt +++ b/test/moonbit/csaw_test.mbt @@ -30,7 +30,7 @@ test "csaw_dataset_create" { let counts = [10.0, 20.0, 30.0] let windows = [ @src.CswWindow::new("w1", "chr1", 1000, 2000, counts), - @src.CswWindow::new("w2", "chr1", 3000, 4000, [50.0, 60.0, 70.0]) + @src.CswWindow::new("w2", "chr1", 3000, 4000, [50.0, 60.0, 70.0]), ] let samples = ["s1", "s2", "s3"] let lib_sizes = [1000.0, 2000.0, 3000.0] @@ -52,7 +52,7 @@ test "csaw_norm_library" { test "csaw_norm_tmm" { let windows = [ @src.CswWindow::new("w1", "chr1", 1000, 2000, [100.0, 200.0, 3000.0]), - @src.CswWindow::new("w2", "chr1", 3000, 4000, [150.0, 250.0, 350.0]) + @src.CswWindow::new("w2", "chr1", 3000, 4000, [150.0, 250.0, 350.0]), ] let samples = ["s1", "s2", "s3"] let lib_sizes = [1000.0, 2000.0, 3000.0] @@ -65,7 +65,7 @@ test "csaw_norm_tmm" { test "csaw_filter_abundance" { let windows = [ @src.CswWindow::new("w1", "chr1", 1000, 2000, [100.0, 200.0]), - @src.CswWindow::new("w2", "chr1", 3000, 4000, [5.0, 3.0]) + @src.CswWindow::new("w2", "chr1", 3000, 4000, [5.0, 3.0]), ] let samples = ["s1", "s2"] let lib_sizes = [1000.0, 2000.0] @@ -78,7 +78,7 @@ test "csaw_filter_abundance" { test "csaw_test_differential" { let windows = [ @src.CswWindow::new("w1", "chr1", 1000, 2000, [50.0, 100.0, 200.0, 250.0]), - @src.CswWindow::new("w2", "chr1", 3000, 4000, [80.0, 120.0, 180.0, 220.0]) + @src.CswWindow::new("w2", "chr1", 3000, 4000, [80.0, 120.0, 180.0, 220.0]), ] let samples = ["s1", "s2", "s3", "s4"] let lib_sizes = [1000.0, 2000.0, 3000.0, 4000.0] @@ -94,7 +94,7 @@ test "csaw_test_differential" { test "csaw_find_regions" { let windows = [ @src.CswWindow::new("w1", "chr1", 1000, 2000, [500.0, 100.0, 200.0, 250.0]), - @src.CswWindow::new("w2", "chr1", 3000, 4000, [80.0, 120.0, 180.0, 220.0]) + @src.CswWindow::new("w2", "chr1", 3000, 4000, [80.0, 120.0, 180.0, 220.0]), ] let samples = ["s1", "s2", "s3", "s4"] let lib_sizes = [1000.0, 2000.0, 3000.0, 4000.0] diff --git a/test/moonbit/cyclone_test.mbt b/test/moonbit/cyclone_test.mbt index 9f0b9570..5495bb8d 100644 --- a/test/moonbit/cyclone_test.mbt +++ b/test/moonbit/cyclone_test.mbt @@ -37,7 +37,7 @@ test "cyclone_score_phase" { let pairs = @src.cyclone_get_gene_pairs() let test_data = @src.cyclone_create_test_data() let (counts, cell_ids, gene_names) = test_data - + // Score the first cell (should be G1 phase) let cell_expr : Array[Double] = Array::new() let n_genes = counts.length() @@ -46,7 +46,7 @@ test "cyclone_score_phase" { cell_expr.push(counts[g][0]) g = g + 1 } - + let g1_score = @src.cyclone_score_phase(cell_expr, gene_names, pairs, "G1") assert_true(g1_score >= 0.0) assert_true(g1_score <= 1.0) @@ -57,7 +57,7 @@ test "cyclone_score_cell" { let pairs = @src.cyclone_get_gene_pairs() let test_data = @src.cyclone_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let cell_expr : Array[Double] = Array::new() let n_genes = counts.length() let mut g = 0 @@ -65,7 +65,7 @@ test "cyclone_score_cell" { cell_expr.push(counts[g][0]) g = g + 1 } - + let scores = @src.cyclone_score_cell(cell_expr, gene_names, pairs) assert_true(scores.size() > 0) assert_true(scores.contains("G1")) @@ -93,7 +93,7 @@ test "cyclone_score_single_cell" { let pairs = @src.cyclone_get_gene_pairs() let test_data = @src.cyclone_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let cell_expr : Array[Double] = Array::new() let n_genes = counts.length() let mut g = 0 @@ -101,8 +101,10 @@ test "cyclone_score_single_cell" { cell_expr.push(counts[g][0]) g = g + 1 } - - let result = @src.cyclone_score_single_cell(cell_expr, "test_cell", gene_names, pairs) + + let result = @src.cyclone_score_single_cell( + cell_expr, "test_cell", gene_names, pairs, + ) assert_eq(result.cell_id, "test_cell") assert_true(result.scores.size() == 4) assert_true(result.phases.length() == 4) @@ -117,10 +119,10 @@ test "cyclone_score_single_cell" { test "cyclone_score_cells" { let test_data = @src.cyclone_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let results = @src.cyclone_score_cells(counts, cell_ids, gene_names) assert_eq(results.length(), 20) - + // Check first cell assert_eq(results[0].cell_id, "cell_1") assert_true(results[0].assigned_phase.length() > 0) @@ -130,12 +132,12 @@ test "cyclone_score_cells" { test "cyclone_phase_distribution" { let test_data = @src.cyclone_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let results = @src.cyclone_score_cells(counts, cell_ids, gene_names) let dist = @src.cyclone_phase_distribution(results) - + assert_true(dist.size() > 0) - + // Sum of proportions should be approximately 1.0 let keys = dist.keys() let mut sum = 0.0 @@ -149,7 +151,7 @@ test "cyclone_phase_distribution" { test "cyclone_create_test_data" { let test_data = @src.cyclone_create_test_data() let (counts, cell_ids, gene_names) = test_data - + assert_eq(cell_ids.length(), 20) assert_true(gene_names.length() > 0) assert_true(counts.length() > 0) @@ -175,7 +177,7 @@ test "cyclone_score_empty_cells" { let gene_names : Array[String] = Array::new() let cell_ids : Array[String] = Array::new() let counts : Array[Array[Double]] = Array::new() - + let results = @src.cyclone_score_cells(counts, cell_ids, gene_names) assert_eq(results.length(), 0) } @@ -191,10 +193,10 @@ test "cyclone_phase_distribution_empty" { test "cyclone_average_scores" { let test_data = @src.cyclone_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let results = @src.cyclone_score_cells(counts, cell_ids, gene_names) let avg = @src.cyclone_average_scores(results) - + assert_true(avg.size() == 4) assert_true(avg.contains("G1")) assert_true(avg.contains("S")) @@ -207,4 +209,4 @@ test "cyclone_average_scores_empty" { let results : Array[@src.CycloneResult] = Array::new() let avg = @src.cyclone_average_scores(results) assert_eq(avg.size(), 0) -} \ No newline at end of file +} diff --git a/test/moonbit/decoupler_test.mbt b/test/moonbit/decoupler_test.mbt index 37251805..bb6e03a2 100644 --- a/test/moonbit/decoupler_test.mbt +++ b/test/moonbit/decoupler_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Bioconductor decoupleR module - Functional activity inference. - test "pkn_edge_create" { let e = @src.pkn_edge("TF1", "G1", 1.0) assert_eq(e.source, "TF1") @@ -8,6 +7,7 @@ test "pkn_edge_create" { assert_true((e.weight - 1.0).abs() < 1.0e-9) } +///| test "pkn_from_edges" { let edges = [ @src.pkn_edge("TF1", "G1", 1.0), @@ -20,6 +20,7 @@ test "pkn_from_edges" { assert_eq(pkn.targets.length(), 3) } +///| test "decoupler_sample_data_shape" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() assert_eq(samples.length(), 5) @@ -29,9 +30,16 @@ test "decoupler_sample_data_shape" { assert_true(pkn.edges.length() > 0) } +///| test "decoupler_wsum_basic" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) assert_eq(result.method, "wsum") assert_eq(result.samples.length(), 5) // 3 TFs in the PKN @@ -50,28 +58,50 @@ test "decoupler_wsum_basic" { assert_true(result.matrix[tf1_idx][0] > result.matrix[tf1_idx][3]) } +///| test "decoupler_wmean_basic" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wmean_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wmean_method(), + ) assert_eq(result.method, "wmean") assert_eq(result.regulators.length(), 3) // wmean normalizes by sum of absolute weights, so magnitude is smaller than wsum - let wsum_result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let wsum_result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) let mut i = 0 while i < result.regulators.length() { let mut j = 0 while j < result.samples.length() { // |wmean| should be <= |wsum| (since abs_w_sum >= 1.0) - assert_true(result.matrix[i][j].abs() <= wsum_result.matrix[i][j].abs() + 1.0e-9) + assert_true( + result.matrix[i][j].abs() <= wsum_result.matrix[i][j].abs() + 1.0e-9, + ) j = j + 1 } i = i + 1 } } +///| test "decoupler_norm_basic" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_norm_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_norm_method(), + ) assert_eq(result.method, "norm") // Normalized scores should have mean ~0 per regulator across samples let mut i = 0 @@ -88,9 +118,16 @@ test "decoupler_norm_basic" { } } +///| test "decoupler_ulm_basic" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_ulm_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_ulm_method(), + ) assert_eq(result.method, "ulm") assert_eq(result.regulators.length(), 3) // ULM scores are standardized; mean across samples should be ~0 @@ -108,9 +145,16 @@ test "decoupler_ulm_basic" { } } +///| test "decoupler_mlm_basic" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_mlm_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_mlm_method(), + ) assert_eq(result.method, "mlm") assert_eq(result.regulators.length(), 3) // MLM slope for TF1 should be positive (TF1 activates its targets) @@ -127,16 +171,33 @@ test "decoupler_mlm_basic" { assert_true(result.matrix[tf1_idx][0] > 0.0) } +///| test "decoupler_scores_per_cell" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) // Should have one score per regulator × sample combination - assert_eq(result.scores.length(), result.regulators.length() * result.samples.length()) + assert_eq( + result.scores.length(), + result.regulators.length() * result.samples.length(), + ) } +///| test "decoupler_top_regulators" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) let top = @src.decoupler_top_regulators(result, "S1", 2) assert_true(top.length() <= 2) // Top regulators for S1 should include TF1 (since S1 is TF1-high) @@ -151,16 +212,30 @@ test "decoupler_top_regulators" { assert_true(found_tf1) } +///| test "decoupler_top_regulators_unknown_sample" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) let top = @src.decoupler_top_regulators(result, "UNKNOWN", 3) assert_eq(top.length(), 0) } +///| test "decoupler_filter_scores" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) let filtered = @src.decoupler_filter_scores(result, 0.5) // All filtered scores should have |score| >= 0.5 let mut i = 0 @@ -170,6 +245,7 @@ test "decoupler_filter_scores" { } } +///| test "decoupler_method_to_string" { assert_eq(@src.decoupler_wsum_method().to_string(), "wsum") assert_eq(@src.decoupler_wmean_method().to_string(), "wmean") @@ -178,6 +254,7 @@ test "decoupler_method_to_string" { assert_eq(@src.decoupler_mlm_method().to_string(), "mlm") } +///| test "decoupler_default_method_is_ulm" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() // Default method argument should be ULM @@ -185,22 +262,28 @@ test "decoupler_default_method_is_ulm" { assert_eq(result.method, "ulm") } +///| test "decoupler_wsum_symmetric_in_sign" { // A PKN with negative weight should produce negative wsum - let edges = [ - @src.pkn_edge("REP", "G1", -1.0), - ] + let edges = [@src.pkn_edge("REP", "G1", -1.0)] let pkn = @src.pkn_from_edges(edges) let expr = [[0.0, 5.0, 0.0], [0.0, 0.0, 0.0]] let samples = ["S1", "S2"] let genes = ["REP", "G1", "G2"] - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) // REP's only target is G1 with weight -1.0; in S1, G1=5 → wsum=-5; in S2, G1=0 → wsum=0 assert_eq(result.regulators.length(), 1) assert_true((result.matrix[0][0] - -5.0).abs() < 1.0e-9) assert_true((result.matrix[0][1] - 0.0).abs() < 1.0e-9) } +///| test "decoupler_pkn_with_unknown_genes" { // PKN with regulator/target not in expression matrix should be filtered out let edges = [ @@ -212,18 +295,31 @@ test "decoupler_pkn_with_unknown_genes" { let expr = [[1.0, 2.0], [3.0, 4.0]] let samples = ["S1", "S2"] let genes = ["TF1", "G1"] - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) // Only TF1 (which appears as a gene) should be in regulators assert_eq(result.regulators.length(), 1) assert_eq(result.regulators[0], "TF1") } +///| test "decoupler_empty_pkn" { let pkn = @src.pkn_from_edges([]) let expr = [[1.0, 2.0], [3.0, 4.0]] let samples = ["S1", "S2"] let genes = ["TF1", "G1"] - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) assert_eq(result.regulators.length(), 0) assert_eq(result.scores.length(), 0) } diff --git a/test/moonbit/delayed_matrix_stats_test.mbt b/test/moonbit/delayed_matrix_stats_test.mbt index c31880be..c090f620 100644 --- a/test/moonbit/delayed_matrix_stats_test.mbt +++ b/test/moonbit/delayed_matrix_stats_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for DelayedMatrixStats module. - test "create_delayed_matrix_basic" { let mat = @src.create_delayed_matrix( [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], @@ -22,11 +21,7 @@ test "create_delayed_matrix_empty" { ///| test "delayed_matrix_get_element" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0], [3.0, 4.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0], [3.0, 4.0]], [], []) assert_eq(mat.get(0, 0), 1.0) assert_eq(mat.get(0, 1), 2.0) assert_eq(mat.get(1, 0), 3.0) @@ -35,11 +30,7 @@ test "delayed_matrix_get_element" { ///| test "delayed_matrix_dim" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], [], []) let d = mat.dim() assert_eq(d[0], 2) assert_eq(d[1], 3) @@ -63,11 +54,9 @@ test "delayed_matrix_subset" { ///| test "delayed_matrix_subset_names" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0], [3.0, 4.0]], - ["r1", "r2"], - ["c1", "c2"], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0], [3.0, 4.0]], ["r1", "r2"], [ + "c1", "c2", + ]) let sub = @src.delayed_matrix_subset(mat, [1], [0]) assert_eq(sub.row_names.length(), 1) assert_eq(sub.col_names.length(), 1) @@ -75,11 +64,7 @@ test "delayed_matrix_subset_names" { ///| test "row_stats_mean" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], [], []) let means = @src.row_stats(mat, "mean") assert_eq(means.length(), 2) assert_eq(means[0], 2.0) @@ -88,11 +73,7 @@ test "row_stats_mean" { ///| test "col_stats_mean" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], [], []) let means = @src.col_stats(mat, "mean") assert_eq(means.length(), 3) assert_eq(means[0], 2.5) @@ -102,11 +83,7 @@ test "col_stats_mean" { ///| test "row_medians" { - let mat = @src.create_delayed_matrix( - [[1.0, 3.0, 2.0], [4.0, 6.0, 5.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 3.0, 2.0], [4.0, 6.0, 5.0]], [], []) let medians = @src.row_medians(mat) assert_eq(medians.length(), 2) assert_eq(medians[0], 2.0) @@ -128,11 +105,7 @@ test "col_medians" { ///| test "row_medians_even" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0, 3.0, 4.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0, 3.0, 4.0]], [], []) let medians = @src.row_medians(mat) assert_eq(medians[0], 2.5) } @@ -165,11 +138,7 @@ test "dms_col_means" { ///| test "dms_row_vars" { - let mat = @src.create_delayed_matrix( - [[2.0, 4.0, 6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[2.0, 4.0, 6.0]], [], []) let vars = @src.dms_row_vars(mat) assert_eq(vars.length(), 1) assert_eq(vars[0], 4.0) @@ -177,11 +146,7 @@ test "dms_row_vars" { ///| test "col_vars" { - let mat = @src.create_delayed_matrix( - [[2.0], [4.0], [6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[2.0], [4.0], [6.0]], [], []) let vars = @src.col_vars(mat) assert_eq(vars.length(), 1) assert_eq(vars[0], 4.0) @@ -189,11 +154,7 @@ test "col_vars" { ///| test "row_allsums" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], [], []) let sums = @src.row_allsums(mat) assert_eq(sums.length(), 2) assert_eq(sums[0], 6.0) @@ -202,11 +163,7 @@ test "row_allsums" { ///| test "row_n_basic" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], [], []) let n = @src.row_n(mat) assert_eq(n.length(), 2) assert_eq(n[0], 3) @@ -243,11 +200,7 @@ test "row_stats_min_max" { ///| test "col_stats_min_max" { - let mat = @src.create_delayed_matrix( - [[3.0, 1.0, 4.0], [9.0, 2.0, 6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[3.0, 1.0, 4.0], [9.0, 2.0, 6.0]], [], []) let mins = @src.col_stats(mat, "min") let maxs = @src.col_stats(mat, "max") assert_eq(mins[0], 3.0) @@ -338,7 +291,10 @@ test "row_medians_with_na" { ///| test "col_stats_all_na" { let mat = @src.create_delayed_matrix( - [[@double.not_a_number, @double.not_a_number], [@double.not_a_number, @double.not_a_number]], + [ + [@double.not_a_number, @double.not_a_number], + [@double.not_a_number, @double.not_a_number], + ], [], [], ) @@ -376,11 +332,7 @@ test "row_stats_nna_stat" { ///| test "row_stats_nn_stat" { - let mat = @src.create_delayed_matrix( - [[1.0, @double.not_a_number, 3.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, @double.not_a_number, 3.0]], [], []) let nn_vals = @src.row_stats(mat, "nn") assert_eq(nn_vals.length(), 1) assert_eq(nn_vals[0], 2.0) @@ -424,11 +376,7 @@ test "row_vars_single_element" { ///| test "col_medians_odd" { - let mat = @src.create_delayed_matrix( - [[1.0], [5.0], [3.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0], [5.0], [3.0]], [], []) let medians = @src.col_medians(mat) assert_eq(medians[0], 3.0) } @@ -470,14 +418,10 @@ test "matrix_stats_result_creation" { ///| test "row_stats_sum_equals_allsums" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], [], []) let sums1 = @src.row_allsums(mat) let sums2 = @src.row_stats(mat, "sum") assert_eq(sums1.length(), sums2.length()) assert_eq(sums1[0], sums2[0]) assert_eq(sums1[1], sums2[1]) -} \ No newline at end of file +} diff --git a/test/moonbit/deseq2_test.mbt b/test/moonbit/deseq2_test.mbt index a8f1c0fd..11f69c32 100644 --- a/test/moonbit/deseq2_test.mbt +++ b/test/moonbit/deseq2_test.mbt @@ -4,7 +4,7 @@ ///| test "test_sample_deseq_dataset" { let dds = @src.sample_deseq_dataset() - + assert_eq(dds.counts.length(), 20) assert_eq(dds.col_names.length(), 6) assert_eq(dds.row_names.length(), 20) @@ -18,15 +18,15 @@ test "test_sample_deseq_dataset" { test "test_estimate_size_factors" { let dds = @src.sample_deseq_dataset() let dds_sf = @src.estimate_size_factors(dds) - + assert_eq(dds_sf.size_factors.length(), 6) - + let mut sum_sf = 0.0 for sf in dds_sf.size_factors { assert_true(sf > 0.0) sum_sf = sum_sf + sf } - + let mean_sf = sum_sf / 6.0 assert_true(mean_sf > 0.9 && mean_sf < 1.1) } @@ -36,7 +36,7 @@ test "test_normalize_counts" { let dds = @src.sample_deseq_dataset() let dds_sf = @src.estimate_size_factors(dds) let normalized = @src.normalize_counts(dds_sf) - + assert_eq(normalized.length(), 20) assert_eq(normalized[0].length(), 6) } @@ -46,7 +46,7 @@ test "test_log2_cpm" { let dds = @src.sample_deseq_dataset() let dds_sf = @src.estimate_size_factors(dds) let log2_cpm = @src.log2_cpm(dds_sf) - + assert_eq(log2_cpm.length(), 20) assert_eq(log2_cpm[0].length(), 6) } @@ -56,9 +56,9 @@ test "test_estimate_dispersions" { let dds = @src.sample_deseq_dataset() let dds_sf = @src.estimate_size_factors(dds) let dds_disp = @src.estimate_dispersions(dds_sf) - + assert_eq(dds_disp.dispersions.length(), 20) - + for disp in dds_disp.dispersions { assert_true(disp >= 0.001) } @@ -70,7 +70,7 @@ test "test_deseq" { let dds_sf = @src.estimate_size_factors(dds) let dds_disp = @src.estimate_dispersions(dds_sf) let res = @src.deseq(dds_disp) - + assert_eq(res.row_names.length(), 20) assert_eq(res.base_mean.length(), 20) assert_eq(res.log2_fold_change.length(), 20) @@ -86,7 +86,7 @@ test "test_results" { let dds_sf = @src.estimate_size_factors(dds) let dds_disp = @src.estimate_dispersions(dds_sf) let res = @src.results(dds_disp) - + assert_eq(res.row_names.length(), 20) assert_eq(res.base_mean.length(), 20) assert_eq(res.log2_fold_change.length(), 20) @@ -94,11 +94,11 @@ test "test_results" { assert_eq(res.stat.length(), 20) assert_eq(res.p_value.length(), 20) assert_eq(res.padj.length(), 20) - + for p in res.p_value { assert_true(p >= 0.0 && p <= 1.0) } - + for p in res.padj { assert_true(p >= 0.0 && p <= 1.0) } @@ -111,10 +111,10 @@ test "test_lfc_shrink" { let dds_disp = @src.estimate_dispersions(dds_sf) let res = @src.results(dds_disp) let res_shrunk = @src.lfc_shrink(dds_disp, res) - + assert_eq(res_shrunk.row_names.length(), 20) assert_eq(res_shrunk.log2_fold_change.length(), 20) - + for i = 0; i < 20; i = i + 1 { assert_true(res_shrunk.lfc_se[i] <= res.lfc_se[i]) } @@ -126,12 +126,14 @@ test "test_significant_genes" { let dds_sf = @src.estimate_size_factors(dds) let dds_disp = @src.estimate_dispersions(dds_sf) let res = @src.results(dds_disp) - + let sig_genes = @src.significant_genes(res) assert_true(sig_genes.length() >= 0 && sig_genes.length() <= 20) - + let sig_genes_lfc = @src.significant_genes(res, alpha=0.05, lfc_threshold=0.5) - assert_true(sig_genes_lfc.length() >= 0 && sig_genes_lfc.length() <= sig_genes.length()) + assert_true( + sig_genes_lfc.length() >= 0 && sig_genes_lfc.length() <= sig_genes.length(), + ) } ///| @@ -140,11 +142,11 @@ test "test_top_genes" { let dds_sf = @src.estimate_size_factors(dds) let dds_disp = @src.estimate_dispersions(dds_sf) let res = @src.results(dds_disp) - + let top = @src.top_genes(res, n=5) assert_eq(top.length(), 5) - + for i = 0; i < 4; i = i + 1 { assert_true(top[i].2 <= top[i + 1].2) } -} \ No newline at end of file +} diff --git a/test/moonbit/destiny_test.mbt b/test/moonbit/destiny_test.mbt index f420a8f5..d0f8b74f 100644 --- a/test/moonbit/destiny_test.mbt +++ b/test/moonbit/destiny_test.mbt @@ -1,11 +1,7 @@ ///| test "destiny_create_cell_data" { - let cell = @src.CellData::new( - "cell_001", - [1.0, 2.0, 3.0], - "cluster_1" - ) - + let cell = @src.CellData::new("cell_001", [1.0, 2.0, 3.0], "cluster_1") + assert_eq(cell.cell_id, "cell_001") assert_eq(cell.expression.length(), 3) assert_eq(cell.cluster, "cluster_1") @@ -15,13 +11,15 @@ test "destiny_create_cell_data" { test "destiny_distance_matrix" { let cells = @src.create_example_sc_data(5, 3) let dist_matrix = @src.compute_distance_matrix(cells, "euclidean") - + assert_eq(dist_matrix.n_cells, 5) assert_eq(dist_matrix.cells.length(), 5) - + // Check symmetry - assert_true((dist_matrix.distances[0][1] - dist_matrix.distances[1][0]).abs() < 1.0e-10) - + assert_true( + (dist_matrix.distances[0][1] - dist_matrix.distances[1][0]).abs() < 1.0e-10, + ) + // Check diagonal is zero assert_true(dist_matrix.distances[0][0].abs() < 1.0e-10) } @@ -30,7 +28,7 @@ test "destiny_distance_matrix" { test "destiny_manhattan_distance" { let cells = @src.create_example_sc_data(3, 2) let dist_matrix = @src.compute_distance_matrix(cells, "manhattan") - + assert_eq(dist_matrix.n_cells, 3) assert_true(dist_matrix.distances[0][1] >= 0.0) } @@ -40,14 +38,14 @@ test "destiny_gaussian_kernel" { let cells = @src.create_example_sc_data(5, 3) let dist_matrix = @src.compute_distance_matrix(cells, "euclidean") let kernel = @src.compute_gaussian_kernel(dist_matrix, 1.0) - + assert_eq(kernel.cells.length(), 5) assert_eq(kernel.bandwidth, 1.0) - + // Check kernel values are between 0 and 1 assert_true(kernel.kernel[0][0] <= 1.0) assert_true(kernel.kernel[0][0] >= 0.0) - + // Diagonal should be 1 (exp(0)) assert_true((kernel.kernel[0][0] - 1.0).abs() < 1.0e-10) } @@ -57,7 +55,7 @@ test "destiny_find_sigma" { let cells = @src.create_example_sc_data(10, 3) let dist_matrix = @src.compute_distance_matrix(cells, "euclidean") let sigma = @src.find_sigma_automatic(dist_matrix) - + assert_true(sigma > 0.0) } @@ -65,12 +63,12 @@ test "destiny_find_sigma" { test "destiny_diffusion_map" { let cells = @src.create_example_sc_data(20, 5) let result = @src.compute_diffusion_map(cells, 3, 1.0) - + assert_eq(result.cell_ids.length(), 20) assert_eq(result.eigenvalues.length(), 3) assert_eq(result.embedding.length(), 20) assert_eq(result.explained_variance.length(), 3) - + // Check eigenvalues are non-negative let mut i = 0 while i < 3 { @@ -83,7 +81,7 @@ test "destiny_diffusion_map" { test "destiny_auto_embedding" { let cells = @src.create_example_sc_data(15, 4) let result = @src.destiny_create_embedding(cells, 2) - + assert_eq(result.cell_ids.length(), 15) assert_eq(result.embedding[0].length(), 2) } @@ -93,7 +91,7 @@ test "destiny_plot_coordinates" { let cells = @src.create_example_sc_data(10, 3) let result = @src.destiny_create_embedding(cells, 2) let coords = @src.destiny_plot_coordinates(result, 0, 1) - + assert_eq(coords.length(), 10) } @@ -102,7 +100,7 @@ test "destiny_summary" { let cells = @src.create_example_sc_data(8, 3) let result = @src.destiny_create_embedding(cells, 2) let summary = @src.destiny_summary(result) - + assert_true(summary.contains("Diffusion Map Summary")) assert_true(summary.contains("Number of cells:")) } @@ -110,17 +108,19 @@ test "destiny_summary" { ///| test "destiny_create_sc_data" { let cells = @src.create_example_sc_data(10, 3) - + assert_eq(cells.length(), 10) assert_eq(cells[0].expression.length(), 3) - assert_true(cells[0].cluster == "cluster_1" || cells[0].cluster == "cluster_2") + assert_true( + cells[0].cluster == "cluster_1" || cells[0].cluster == "cluster_2", + ) } ///| test "destiny_euclidean_distance_zero" { let cells = @src.create_example_sc_data(3, 2) let dist_matrix = @src.compute_distance_matrix(cells, "euclidean") - + // Same point should have zero distance assert_true(dist_matrix.distances[0][0].abs() < 1.0e-10) assert_true(dist_matrix.distances[1][1].abs() < 1.0e-10) @@ -130,7 +130,7 @@ test "destiny_euclidean_distance_zero" { test "destiny_small_dataset" { let cells = @src.create_example_sc_data(2, 2) let result = @src.compute_diffusion_map(cells, 1, 0.5) - + assert_eq(result.cell_ids.length(), 2) assert_eq(result.embedding.length(), 2) } diff --git a/test/moonbit/dexseq_test.mbt b/test/moonbit/dexseq_test.mbt index 04cbc660..d4e94b37 100644 --- a/test/moonbit/dexseq_test.mbt +++ b/test/moonbit/dexseq_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for DEXSeq module. - test "ExonCount creation" { let ec = @src.ExonCount::new("gene1", "exon1", [10, 20, 30]) assert_eq(ec.gene_id, "gene1") @@ -8,6 +7,7 @@ test "ExonCount creation" { assert_eq(ec.counts.length(), 3) } +///| test "DEXSeqDataSet creation" { let exon_counts : Array[@src.ExonCount] = Array::new() exon_counts.push(@src.ExonCount::new("gene1", "exon1", [10, 12, 15])) @@ -18,18 +18,21 @@ test "DEXSeqDataSet creation" { assert_eq(ds.gene_ids[0], "gene1") } +///| test "dexseq_normalize_counts" { let ds = @src.create_example_dexseq_dataset() let normalized = @src.dexseq_normalize_counts(ds) assert_eq(normalized.exon_counts.length(), ds.exon_counts.length()) } +///| test "dexseq_test_for_exon_usage" { let ds = @src.create_example_dexseq_dataset() let results = @src.dexseq_test_for_exon_usage(ds) assert_true(results.length() > 0) } +///| test "dexseq_filter_results" { let ds = @src.create_example_dexseq_dataset() let results = @src.dexseq_test_for_exon_usage(ds) diff --git a/test/moonbit/diffcyt_test.mbt b/test/moonbit/diffcyt_test.mbt index 3a9b7389..20852a5c 100644 --- a/test/moonbit/diffcyt_test.mbt +++ b/test/moonbit/diffcyt_test.mbt @@ -10,9 +10,7 @@ ///| test "dc_cell_creation" { - let cell = @src.CytometryCell::new( - "cell_1", "S1", "ctrl", [1.0, 2.0, 3.0] - ) + let cell = @src.CytometryCell::new("cell_1", "S1", "ctrl", [1.0, 2.0, 3.0]) assert_eq(cell.cell_id(), "cell_1") assert_eq(cell.sample_id(), "S1") assert_eq(cell.condition(), "ctrl") @@ -85,7 +83,9 @@ test "dc_assign_clusters_new" { let cells = @src.diffcyt_sample_data() let codebooks = @src.diffcyt_cluster_cells(cells, 4, 10) // Re-assign using existing codebooks. - let new_cells = [@src.CytometryCell::new("nc1", "S1", "ctrl", cells[0].marker_values())] + let new_cells = [ + @src.CytometryCell::new("nc1", "S1", "ctrl", cells[0].marker_values()), + ] @src.diffcyt_assign_clusters(new_cells, codebooks) assert_true(new_cells[0].cluster_id() >= 0) assert_true(new_cells[0].cluster_id() < 4) @@ -121,7 +121,9 @@ test "dc_calc_medians" { let cells = @src.diffcyt_sample_data() let _ = @src.diffcyt_cluster_cells(cells, 3, 10) let samples = @src.diffcyt_unique_samples(cells) - let medians = @src.diffcyt_calc_medians_by_cluster_marker(cells, 3, 3, samples) + let medians = @src.diffcyt_calc_medians_by_cluster_marker( + cells, 3, 3, samples, + ) assert_eq(medians.length(), 4) // 4 samples // Each row has 3 clusters * 3 markers = 9 entries. for row in medians { @@ -219,7 +221,9 @@ test "dc_testDS_returns_results" { conditions.push(cond_map.get(sid).unwrap_or("")) } let marker_names = ["marker_0", "marker_1", "marker_2"] - let ds_results = @src.diffcyt_testDS(cells, samples, conditions, 3, 3, marker_names) + let ds_results = @src.diffcyt_testDS( + cells, samples, conditions, 3, 3, marker_names, + ) // 3 clusters * 3 markers = 9 results (if 2 conditions). assert_true(ds_results.length() > 0) for r in ds_results { @@ -244,7 +248,9 @@ test "dc_testDS_marker_names" { conditions.push(cond_map.get(sid).unwrap_or("")) } let marker_names = ["CD4", "CD8", "CD3"] - let ds_results = @src.diffcyt_testDS(cells, samples, conditions, 2, 3, marker_names) + let ds_results = @src.diffcyt_testDS( + cells, samples, conditions, 2, 3, marker_names, + ) for r in ds_results { assert_true(marker_names.contains(r.marker_name())) } @@ -311,9 +317,9 @@ test "dc_top_table_ds" { for sid in samples { conditions.push(cond_map.get(sid).unwrap_or("")) } - let ds_results = @src.diffcyt_testDS( - cells, samples, conditions, 3, 3, ["m0", "m1", "m2"] - ) + let ds_results = @src.diffcyt_testDS(cells, samples, conditions, 3, 3, [ + "m0", "m1", "m2", + ]) let top5 = @src.diffcyt_top_table_ds(ds_results, 5) assert_true(top5.length() <= 5) if top5.length() >= 2 { diff --git a/test/moonbit/dnashape_test.mbt b/test/moonbit/dnashape_test.mbt index 0629d99b..6f2259ff 100644 --- a/test/moonbit/dnashape_test.mbt +++ b/test/moonbit/dnashape_test.mbt @@ -113,10 +113,10 @@ test "ds_roll_table" { assert_eq(t.length(), 16) // AA (index 0) = -6.0 let v0 = t.get(0).unwrap_or(999.0) - assert_true((v0 - (-6.0)).abs() < 0.001) + assert_true((v0 - -6.0).abs() < 0.001) // TT (index 15) = -6.0 let v15 = t.get(15).unwrap_or(999.0) - assert_true((v15 - (-6.0)).abs() < 0.001) + assert_true((v15 - -6.0).abs() < 0.001) // CG (index 6) = 6.0 let v6 = t.get(6).unwrap_or(999.0) assert_true((v6 - 6.0).abs() < 0.001) @@ -131,7 +131,7 @@ test "ds_prot_table" { assert_true((v0 - 15.0).abs() < 0.001) // TA = -2.0 let v12 = t.get(12).unwrap_or(0.0) - assert_true((v12 - (-2.0)).abs() < 0.001) + assert_true((v12 - -2.0).abs() < 0.001) } ///| @@ -164,10 +164,10 @@ test "ds_ep_table" { assert_eq(t.length(), 16) // AA = -1.5 let v0 = t.get(0).unwrap_or(0.0) - assert_true((v0 - (-1.5)).abs() < 0.001) + assert_true((v0 - -1.5).abs() < 0.001) // CG = -0.6 let v6 = t.get(6).unwrap_or(0.0) - assert_true((v6 - (-0.6)).abs() < 0.001) + assert_true((v6 - -0.6).abs() < 0.001) } // =========================================================================== diff --git a/test/moonbit/dorothea_test.mbt b/test/moonbit/dorothea_test.mbt index 06e55874..7b770a63 100644 --- a/test/moonbit/dorothea_test.mbt +++ b/test/moonbit/dorothea_test.mbt @@ -5,7 +5,7 @@ test "dorothea_get_regulons" { let regulons = @src.dorothea_get_regulons() assert_true(regulons.length() > 0) - + // Check that key TFs are present let mut has_tp53 = false let mut has_myc = false @@ -28,7 +28,9 @@ test "dorothea_regulon_targets" { assert_true(regulon.targets.length() > 0) // Check that all targets have valid directions for target in regulon.targets { - assert_true(target.direction == "activation" || target.direction == "repression") + assert_true( + target.direction == "activation" || target.direction == "repression", + ) } } } @@ -38,7 +40,7 @@ test "dorothea_compute_activity_simple" { let regulons = @src.dorothea_get_regulons() let test_data = @src.dorothea_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let cell_expr : Array[Double] = Array::new() let n_genes = counts.length() let mut g = 0 @@ -46,14 +48,16 @@ test "dorothea_compute_activity_simple" { cell_expr.push(counts[g][0]) g = g + 1 } - + // Find a regulon with targets in our gene set let mut tf_activity = 0.0 for regulon in regulons { - let activity = @src.dorothea_compute_activity_simple(cell_expr, gene_names, regulon) + let activity = @src.dorothea_compute_activity_simple( + cell_expr, gene_names, regulon, + ) tf_activity = tf_activity + activity } - + assert_true(tf_activity >= 0.0) } @@ -62,7 +66,7 @@ test "dorothea_compute_viper_activity" { let regulons = @src.dorothea_get_regulons() let test_data = @src.dorothea_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let cell_expr : Array[Double] = Array::new() let n_genes = counts.length() let mut g = 0 @@ -70,15 +74,17 @@ test "dorothea_compute_viper_activity" { cell_expr.push(counts[g][0]) g = g + 1 } - + let mut has_activity = false for regulon in regulons { - let activity = @src.dorothea_compute_viper_activity(cell_expr, gene_names, regulon) + let activity = @src.dorothea_compute_viper_activity( + cell_expr, gene_names, regulon, + ) if activity.abs() > 0.0 { has_activity = true } } - + // VIPER activities should generally be non-zero if targets are found assert_true(has_activity || regulons.length() > 0) } @@ -88,7 +94,7 @@ test "dorothea_permutation_test" { let regulons = @src.dorothea_get_regulons() let test_data = @src.dorothea_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let cell_expr : Array[Double] = Array::new() let n_genes = counts.length() let mut g = 0 @@ -96,7 +102,7 @@ test "dorothea_permutation_test" { cell_expr.push(counts[g][0]) g = g + 1 } - + // Use a regulon with many targets for better test let mut tp53_regulon = regulons[0] // Default for regulon in regulons { @@ -105,8 +111,10 @@ test "dorothea_permutation_test" { break } } - - let (p_value, z_score) = @src.dorothea_permutation_test(cell_expr, gene_names, tp53_regulon, 100) + + let (p_value, z_score) = @src.dorothea_permutation_test( + cell_expr, gene_names, tp53_regulon, 100, + ) assert_true(p_value >= 0.0 && p_value <= 1.0) } @@ -115,7 +123,7 @@ test "dorothea_analyze_cell" { let regulons = @src.dorothea_get_regulons() let test_data = @src.dorothea_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let cell_expr : Array[Double] = Array::new() let n_genes = counts.length() let mut g = 0 @@ -123,10 +131,12 @@ test "dorothea_analyze_cell" { cell_expr.push(counts[g][0]) g = g + 1 } - + let params = @src.DorotheaParams::with_params(50, 3, 0.05) - let results = @src.dorothea_analyze_cell(cell_expr, gene_names, regulons, params) - + let results = @src.dorothea_analyze_cell( + cell_expr, gene_names, regulons, params, + ) + assert_true(results.length() > 0) for result in results { assert_true(result.n_targets >= 3) @@ -139,10 +149,12 @@ test "dorothea_analyze_cells" { let regulons = @src.dorothea_get_regulons() let test_data = @src.dorothea_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let params = @src.DorotheaParams::with_params(50, 3, 0.05) - let results = @src.dorothea_analyze_cells(counts, cell_ids, gene_names, regulons, params) - + let results = @src.dorothea_analyze_cells( + counts, cell_ids, gene_names, regulons, params, + ) + assert_true(results.length() > 0) assert_true(results.length() <= regulons.length()) } @@ -151,7 +163,7 @@ test "dorothea_analyze_cells" { test "dorothea_create_test_data" { let test_data = @src.dorothea_create_test_data() let (counts, cell_ids, gene_names) = test_data - + assert_eq(cell_ids.length(), 10) assert_true(gene_names.length() > 0) assert_true(counts.length() > 0) @@ -188,9 +200,9 @@ test "dorothea_sort_by_activity" { [], [], @src.dorothea_get_regulons(), - @src.DorotheaParams::with_params(10, 3, 0.05) + @src.DorotheaParams::with_params(10, 3, 0.05), ) - + // Sort empty or small results let sorted = @src.dorothea_sort_by_activity(results) assert_true(sorted.length() <= results.length()) @@ -201,10 +213,12 @@ test "dorothea_get_top_tfs" { let regulons = @src.dorothea_get_regulons() let test_data = @src.dorothea_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let params = @src.DorotheaParams::with_params(20, 3, 0.05) - let results = @src.dorothea_analyze_cells(counts, cell_ids, gene_names, regulons, params) - + let results = @src.dorothea_analyze_cells( + counts, cell_ids, gene_names, regulons, params, + ) + let top3 = @src.dorothea_get_top_tfs(results, 3) assert_true(top3.length() <= 3) } @@ -228,7 +242,7 @@ test "dorothea_get_target_expression" { let regulons = @src.dorothea_get_regulons() let test_data = @src.dorothea_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let cell_expr : Array[Double] = Array::new() let n_genes = counts.length() let mut g = 0 @@ -236,8 +250,12 @@ test "dorothea_get_target_expression" { cell_expr.push(counts[g][0]) g = g + 1 } - + // Test with first regulon - let targets = @src.dorothea_get_target_expression(cell_expr, gene_names, regulons[0]) + let targets = @src.dorothea_get_target_expression( + cell_expr, + gene_names, + regulons[0], + ) assert_true(targets.length() >= 0) -} \ No newline at end of file +} diff --git a/test/moonbit/drimseq_test.mbt b/test/moonbit/drimseq_test.mbt index e372d7e3..e99dae90 100644 --- a/test/moonbit/drimseq_test.mbt +++ b/test/moonbit/drimseq_test.mbt @@ -1,11 +1,13 @@ ///| /// Test file for DRIMSeq module. - test "drimseq_transcript_count_creation" { let tc = @src.TranscriptCount::new( - transcript_id="tx1", gene_id="GeneA", - sample_id="s1", condition="ctrl", - count=100.0, gene_count=150.0, + transcript_id="tx1", + gene_id="GeneA", + sample_id="s1", + condition="ctrl", + count=100.0, + gene_count=150.0, ) assert_eq(tc.transcript_id, "tx1") assert_eq(tc.gene_id, "GeneA") @@ -13,47 +15,77 @@ test "drimseq_transcript_count_creation" { assert_true((tc.proportion() - 0.666666).abs() < 0.01) } +///| test "drimseq_transcript_count_proportion_zero" { let tc = @src.TranscriptCount::new( - transcript_id="tx1", gene_id="GeneA", - sample_id="s1", condition="ctrl", + transcript_id="tx1", + gene_id="GeneA", + sample_id="s1", + condition="ctrl", count=100.0, ) assert_eq(tc.proportion(), 0.0) } +///| test "drimseq_filter_counts" { let counts : Array[@src.TranscriptCount] = Array::new() - counts.push(@src.TranscriptCount::new( - transcript_id="tx1", gene_id="G1", - sample_id="s1", condition="c1", - count=50.0, gene_count=100.0, - )) - counts.push(@src.TranscriptCount::new( - transcript_id="tx2", gene_id="G2", - sample_id="s1", condition="c1", - count=5.0, gene_count=100.0, - )) + counts.push( + @src.TranscriptCount::new( + transcript_id="tx1", + gene_id="G1", + sample_id="s1", + condition="c1", + count=50.0, + gene_count=100.0, + ), + ) + counts.push( + @src.TranscriptCount::new( + transcript_id="tx2", + gene_id="G2", + sample_id="s1", + condition="c1", + count=5.0, + gene_count=100.0, + ), + ) let filtered = @src.drimseq_filter_counts(counts) assert_eq(filtered.length(), 1) assert_eq(filtered[0].transcript_id, "tx1") } +///| test "drimseq_aggregate_by_gene" { let counts : Array[@src.TranscriptCount] = Array::new() - counts.push(@src.TranscriptCount::new( - transcript_id="tx1", gene_id="G1", - sample_id="s1", condition="c1", count=50.0, - )) - counts.push(@src.TranscriptCount::new( - transcript_id="tx2", gene_id="G1", - sample_id="s1", condition="c1", count=30.0, - )) - counts.push(@src.TranscriptCount::new( - transcript_id="tx1", gene_id="G1", - sample_id="s2", condition="c1", count=40.0, - )) + counts.push( + @src.TranscriptCount::new( + transcript_id="tx1", + gene_id="G1", + sample_id="s1", + condition="c1", + count=50.0, + ), + ) + counts.push( + @src.TranscriptCount::new( + transcript_id="tx2", + gene_id="G1", + sample_id="s1", + condition="c1", + count=30.0, + ), + ) + counts.push( + @src.TranscriptCount::new( + transcript_id="tx1", + gene_id="G1", + sample_id="s2", + condition="c1", + count=40.0, + ), + ) let aggregated = @src.drimseq_aggregate_by_gene(counts) assert_eq(aggregated.length(), 2) // G1-s1 and G1-s2 @@ -61,49 +93,72 @@ test "drimseq_aggregate_by_gene" { assert_eq(aggregated[1].count, 40.0) } +///| test "drimseq_compute_proportions" { let counts : Array[@src.TranscriptCount] = Array::new() - counts.push(@src.TranscriptCount::new( - transcript_id="tx1", gene_id="G1", - sample_id="s1", condition="c1", count=50.0, - )) - counts.push(@src.TranscriptCount::new( - transcript_id="tx2", gene_id="G1", - sample_id="s1", condition="c1", count=50.0, - )) + counts.push( + @src.TranscriptCount::new( + transcript_id="tx1", + gene_id="G1", + sample_id="s1", + condition="c1", + count=50.0, + ), + ) + counts.push( + @src.TranscriptCount::new( + transcript_id="tx2", + gene_id="G1", + sample_id="s1", + condition="c1", + count=50.0, + ), + ) let gene_counts : Array[@src.TranscriptCount] = Array::new() - gene_counts.push(@src.TranscriptCount::new( - transcript_id="__gene__", gene_id="G1", - sample_id="s1", condition="c1", count=100.0, - )) + gene_counts.push( + @src.TranscriptCount::new( + transcript_id="__gene__", + gene_id="G1", + sample_id="s1", + condition="c1", + count=100.0, + ), + ) let props = @src.drimseq_compute_proportions(counts, gene_counts) assert_eq(props.length(), 2) assert_true((props[0].proportion() - 0.5).abs() < 0.01) } +///| test "drimseq_wald_test_same" { let a : Array[Double] = Array::new() - a.push(0.5); a.push(0.5) + a.push(0.5) + a.push(0.5) let b : Array[Double] = Array::new() - b.push(0.5); b.push(0.5) + b.push(0.5) + b.push(0.5) let (stat, pval, _) = @src.drimseq_wald_test(a, b) assert_true(pval >= 0.99) // Should not be significant } +///| test "drimseq_wald_test_different" { let a : Array[Double] = Array::new() - a.push(0.8); a.push(0.2) + a.push(0.8) + a.push(0.2) let b : Array[Double] = Array::new() - b.push(0.2); b.push(0.8) + b.push(0.2) + b.push(0.8) let (_, pval, delta) = @src.drimseq_wald_test(a, b) assert_true(pval < 0.05) // Should be significant assert_true(delta.length() == 2) } +///| test "drimseq_result_summary" { let counts = @src.drimseq_sample_data() let result = @src.drimseq_test_differential(counts) @@ -111,6 +166,7 @@ test "drimseq_result_summary" { assert_true(summary.length() > 0) } +///| test "drimseq_result_get_significant" { let counts = @src.drimseq_sample_data() let result = @src.drimseq_test_differential(counts) @@ -118,6 +174,7 @@ test "drimseq_result_get_significant" { assert_true(sig.length() >= 0) } +///| test "drimseq_result_get_top_genes" { let counts = @src.drimseq_sample_data() let result = @src.drimseq_test_differential(counts) @@ -125,20 +182,21 @@ test "drimseq_result_get_top_genes" { assert_true(top.length() <= 2) } +///| test "drimseq_config_creation" { let cfg = @src.DRIMSeqConfig::new() assert_true(cfg.min_count > 0.0) assert_true(cfg.alpha > 0.0) } +///| test "drimseq_config_setters" { - let cfg = @src.DRIMSeqConfig::new() - .set_min_count(val=5.0) - .set_alpha(val=0.01) + let cfg = @src.DRIMSeqConfig::new().set_min_count(val=5.0).set_alpha(val=0.01) assert_eq(cfg.min_count, 5.0) assert_eq(cfg.alpha, 0.01) } +///| test "drimseq_norm_creation" { let n1 = @src.drimseq_norm_none() let n2 = @src.drimseq_norm_tmm() @@ -148,6 +206,7 @@ test "drimseq_norm_creation" { assert_true(n3 == n3) } +///| test "drimseq_full_pipeline" { let counts = @src.drimseq_sample_data() let result = @src.drimseq_test_differential(counts) @@ -156,6 +215,7 @@ test "drimseq_full_pipeline" { assert_true(result.converged) } +///| test "drimseq_empty_data" { let empty : Array[@src.TranscriptCount] = Array::new() let result = @src.drimseq_test_differential(empty) diff --git a/test/moonbit/dss_test.mbt b/test/moonbit/dss_test.mbt index e13ccb3b..0306cbc3 100644 --- a/test/moonbit/dss_test.mbt +++ b/test/moonbit/dss_test.mbt @@ -194,4 +194,4 @@ test "dss_disp_result_methods" { for sd in shrunken { assert_true(sd >= 0.0) } -} \ No newline at end of file +} diff --git a/test/moonbit/dssp_test.mbt b/test/moonbit/dssp_test.mbt index 86a41ec3..192558ac 100644 --- a/test/moonbit/dssp_test.mbt +++ b/test/moonbit/dssp_test.mbt @@ -31,4 +31,4 @@ test "dssp_analyze_structure_composition" { test "dssp_create_example_data" { let data = @src.create_example_dssp_data() assert_eq(data.records.length(), 8) -} \ No newline at end of file +} diff --git a/test/moonbit/edaseq_test.mbt b/test/moonbit/edaseq_test.mbt index bce3cb4d..d7b8b7db 100644 --- a/test/moonbit/edaseq_test.mbt +++ b/test/moonbit/edaseq_test.mbt @@ -26,13 +26,10 @@ test "edaseq_gene_anno_min_length" { test "edaseq_dataset" { let gene_ids = ["gene1", "gene2"] let sample_ids = ["sample1", "sample2", "sample3"] - let counts : Array[Array[Double]] = [ - [10.0, 20.0, 30.0], - [50.0, 60.0, 70.0] - ] + let counts : Array[Array[Double]] = [[10.0, 20.0, 30.0], [50.0, 60.0, 70.0]] let annotations = [ @src.EDASeqGeneAnno::new("gene1", 0.45, 1000.0), - @src.EDASeqGeneAnno::new("gene2", 0.55, 2000.0) + @src.EDASeqGeneAnno::new("gene2", 0.55, 2000.0), ] let data = @src.EDASeqDataSet::new(gene_ids, sample_ids, counts, annotations) assert_eq(data.eda_n_genes(), 2) @@ -58,7 +55,7 @@ test "edaseq_sample_counts" { let counts : Array[Array[Double]] = [[10.0], [20.0]] let annotations = [ @src.EDASeqGeneAnno::new("gene1", 0.5, 500.0), - @src.EDASeqGeneAnno::new("gene2", 0.6, 1000.0) + @src.EDASeqGeneAnno::new("gene2", 0.6, 1000.0), ] let data = @src.EDASeqDataSet::new(gene_ids, sample_ids, counts, annotations) let sample_counts = data.eda_sample_counts(0) @@ -74,12 +71,12 @@ test "edaseq_within_lane" { let counts : Array[Array[Double]] = [ [100.0, 200.0], [300.0, 400.0], - [500.0, 600.0] + [500.0, 600.0], ] let annotations = [ @src.EDASeqGeneAnno::new("gene1", 0.4, 500.0), @src.EDASeqGeneAnno::new("gene2", 0.5, 1000.0), - @src.EDASeqGeneAnno::new("gene3", 0.6, 2000.0) + @src.EDASeqGeneAnno::new("gene3", 0.6, 2000.0), ] let data = @src.EDASeqDataSet::new(gene_ids, sample_ids, counts, annotations) let params = @src.EDASeqParams::new() @@ -93,11 +90,11 @@ test "edaseq_between_lane" { let sample_ids = ["s1", "s2", "s3"] let counts : Array[Array[Double]] = [ [100.0, 200.0, 300.0], - [500.0, 600.0, 700.0] + [500.0, 600.0, 700.0], ] let annotations = [ @src.EDASeqGeneAnno::new("gene1", 0.5, 500.0), - @src.EDASeqGeneAnno::new("gene2", 0.55, 1000.0) + @src.EDASeqGeneAnno::new("gene2", 0.55, 1000.0), ] let data = @src.EDASeqDataSet::new(gene_ids, sample_ids, counts, annotations) let params = @src.EDASeqParams::new() @@ -112,12 +109,12 @@ test "edaseq_full_run" { let counts : Array[Array[Double]] = [ [100.0, 200.0], [300.0, 400.0], - [500.0, 600.0] + [500.0, 600.0], ] let annotations = [ @src.EDASeqGeneAnno::new("gene1", 0.4, 500.0), @src.EDASeqGeneAnno::new("gene2", 0.5, 1000.0), - @src.EDASeqGeneAnno::new("gene3", 0.6, 2000.0) + @src.EDASeqGeneAnno::new("gene3", 0.6, 2000.0), ] let data = @src.EDASeqDataSet::new(gene_ids, sample_ids, counts, annotations) let params = @src.EDASeqParams::new() @@ -130,13 +127,10 @@ test "edaseq_full_run" { test "edaseq_result_accessors" { let gene_ids = ["gene1", "gene2"] let sample_ids = ["s1", "s2"] - let counts : Array[Array[Double]] = [ - [100.0, 200.0], - [300.0, 400.0] - ] + let counts : Array[Array[Double]] = [[100.0, 200.0], [300.0, 400.0]] let annotations = [ @src.EDASeqGeneAnno::new("gene1", 0.5, 500.0), - @src.EDASeqGeneAnno::new("gene2", 0.55, 1000.0) + @src.EDASeqGeneAnno::new("gene2", 0.55, 1000.0), ] let data = @src.EDASeqDataSet::new(gene_ids, sample_ids, counts, annotations) let params = @src.EDASeqParams::new() diff --git a/test/moonbit/edger_advanced_test.mbt b/test/moonbit/edger_advanced_test.mbt index 71e473ca..60fa5008 100644 --- a/test/moonbit/edger_advanced_test.mbt +++ b/test/moonbit/edger_advanced_test.mbt @@ -180,9 +180,9 @@ test "camera_with_all_genes_in_set" { ) let qlf = @src.glm_qlf_fit(dge) let result = @src.glm_qlf_test(qlf) - let (stat, pval, dir) = @src.camera( - result, ["GeneA", "GeneB", "GeneC", "GeneD"], - ) + let (stat, pval, dir) = @src.camera(result, [ + "GeneA", "GeneB", "GeneC", "GeneD", + ]) assert_true(pval >= 0.0 && pval <= 1.0) assert_true(dir == "up" || dir == "down" || dir == "none") } @@ -221,11 +221,7 @@ test "roast_with_empty_gene_set" { ///| test "qlf_test_handles_single_sample_per_group" { - let dge = @src.dge_list( - [[10, 20], [30, 40]], - ["A", "B"], - ["G1", "G2"], - ) + let dge = @src.dge_list([[10, 20], [30, 40]], ["A", "B"], ["G1", "G2"]) let qlf = @src.glm_qlf_fit(dge) let result = @src.glm_qlf_test(qlf) assert_eq(result.genes.length(), 2) @@ -238,4 +234,4 @@ test "qlf_test_handles_single_sample_per_group" { for f in result.fdr { assert_true(f >= 0.0 && f <= 1.0) } -} \ No newline at end of file +} diff --git a/test/moonbit/enhanced_volcano_test.mbt b/test/moonbit/enhanced_volcano_test.mbt index b60a0993..16410965 100644 --- a/test/moonbit/enhanced_volcano_test.mbt +++ b/test/moonbit/enhanced_volcano_test.mbt @@ -1,6 +1,5 @@ ///| /// Test file for EnhancedVolcano module. - test "volcano_plot_basic" { let ids = ["TP53", "BRCA1", "MYC", "KRAS", "EGFR"] let lfcs = [2.5, -3.0, 1.2, -0.5, 0.1] @@ -9,101 +8,194 @@ test "volcano_plot_basic" { assert_eq(result.get_n_genes(), 5) } +///| test "volcano_classification_up" { let ids = ["Gene1", "Gene2", "Gene3"] let lfcs = [2.0, -2.0, 0.5] let pvals = [0.001, 0.001, 0.001] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="Test", x_label="x", y_label="y") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="Test", + x_label="x", + y_label="y", + ) assert_eq(result.get_n_up(), 1) assert_eq(result.get_n_down(), 1) assert_eq(result.get_n_nonsig(), 1) } +///| test "volcano_classification_all_sig" { let ids = ["A", "B", "C", "D"] let lfcs = [2.5, -2.5, 1.5, -1.5] let pvals = [0.001, 0.001, 0.01, 0.01] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="", x_label="", y_label="") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="", + x_label="", + y_label="", + ) assert_eq(result.get_n_up(), 2) assert_eq(result.get_n_down(), 2) assert_eq(result.get_n_nonsig(), 0) } +///| test "volcano_classification_none_sig" { let ids = ["A", "B", "C"] let lfcs = [0.1, -0.1, 0.5] let pvals = [0.1, 0.2, 0.1] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="", x_label="", y_label="") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="", + x_label="", + y_label="", + ) assert_eq(result.get_n_up(), 0) assert_eq(result.get_n_down(), 0) assert_eq(result.get_n_nonsig(), 3) } +///| test "volcano_get_genes" { let ids = ["A", "B", "C"] let lfcs = [2.0, -2.0, 0.5] let pvals = [0.001, 0.001, 0.001] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="", x_label="", y_label="") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="", + x_label="", + y_label="", + ) let genes = result.get_genes() assert_eq(genes.length(), 3) } +///| test "volcano_get_significant" { let ids = ["A", "B", "C"] let lfcs = [2.0, -2.0, 0.5] let pvals = [0.001, 0.001, 0.001] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="", x_label="", y_label="") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="", + x_label="", + y_label="", + ) let sig = result.get_significant_genes() assert_eq(sig.length(), 2) // A (Up) and B (Down) } +///| test "volcano_get_up_genes" { let ids = ["A", "B", "C"] let lfcs = [2.0, -2.0, 1.5] let pvals = [0.001, 0.001, 0.001] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="", x_label="", y_label="") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="", + x_label="", + y_label="", + ) let up = result.get_up_genes() assert_eq(up.length(), 2) } +///| test "volcano_get_down_genes" { let ids = ["A", "B", "C"] let lfcs = [2.0, -2.0, -1.5] let pvals = [0.001, 0.001, 0.001] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="", x_label="", y_label="") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="", + x_label="", + y_label="", + ) let down = result.get_down_genes() assert_eq(down.length(), 2) } +///| test "volcano_get_top_genes" { let ids = ["A", "B", "C", "D", "E"] let lfcs = [2.5, -3.0, 1.5, -1.5, 0.3] let pvals = [0.01, 0.001, 0.02, 0.005, 0.001] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="", x_label="", y_label="") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="", + x_label="", + y_label="", + ) let top = result.get_top_genes(3) assert_eq(top.length(), 3) } +///| test "volcano_neg_log10_p" { let nlp = @src.neg_log10_p(0.05) assert_true(nlp > 1.29) // -log10(0.05) = 1.301 assert_true(nlp < 1.31) } +///| test "volcano_neg_log10_p_zero" { let nlp = @src.neg_log10_p(0.0) assert_true(nlp > 0.0) // should handle p=0 gracefully } +///| test "volcano_cutoffs" { let ids = ["A", "B"] let lfcs = [2.0, -2.0] let pvals = [0.001, 0.001] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.01, fc_cutoff=2.0, title="", x_label="", y_label="") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.01, + fc_cutoff=2.0, + title="", + x_label="", + y_label="", + ) assert_eq(result.get_p_cutoff(), 0.01) assert_eq(result.get_fc_cutoff(), 2.0) } +///| test "volcano_to_ascii" { let result = @src.volcano_sample(20) let ascii = result.to_ascii(width=60, height=20) @@ -111,6 +203,7 @@ test "volcano_to_ascii" { assert_true(ascii.contains("Volcano Plot")) } +///| test "volcano_summary" { let result = @src.volcano_sample(10) let summary = result.summary() @@ -118,6 +211,7 @@ test "volcano_summary" { assert_true(summary.contains("Total genes")) } +///| test "volcano_sample" { let result = @src.volcano_sample(30) assert_eq(result.get_n_genes(), 30) @@ -126,21 +220,32 @@ test "volcano_sample" { assert_true(result.get_n_nonsig() >= 0) } +///| test "volcano_classification_to_string" { // Test classification through the result of volcano_plot let ids = ["Gene1", "Gene2", "Gene3"] let lfcs = [2.0, -2.0, 0.5] let pvals = [0.001, 0.001, 0.5] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="Test", x_label="log2FC", y_label="-log10(p)") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="Test", + x_label="log2FC", + y_label="-log10(p)", + ) let genes = result.get_genes() assert_eq(genes.length(), 3) - + // Check that classifications work by examining result counts - assert_true(result.get_n_up() >= 1) // Gene1 should be Up - assert_true(result.get_n_down() >= 1) // Gene2 should be Down - assert_true(result.get_n_nonsig() >= 1) // Gene3 should be NonSig + assert_true(result.get_n_up() >= 1) // Gene1 should be Up + assert_true(result.get_n_down() >= 1) // Gene2 should be Down + assert_true(result.get_n_nonsig() >= 1) // Gene3 should be NonSig } +///| test "volcano_empty_inputs" { let ids : Array[String] = Array::new() let lfcs : Array[Double] = Array::new() @@ -149,9 +254,10 @@ test "volcano_empty_inputs" { assert_eq(result.get_n_genes(), 0) } +///| test "volcano_ascii_visual_elements" { let result = @src.volcano_sample(50) let ascii = result.to_ascii(width=60, height=20) assert_true(ascii.contains("+")) // up-regulated assert_true(ascii.contains("-")) // down-regulated -} \ No newline at end of file +} diff --git a/test/moonbit/enriched_heatmap_test.mbt b/test/moonbit/enriched_heatmap_test.mbt index b17afaa8..70985adc 100644 --- a/test/moonbit/enriched_heatmap_test.mbt +++ b/test/moonbit/enriched_heatmap_test.mbt @@ -247,7 +247,7 @@ test "eh_normalize_background" { // All values should be background (-1.0) since signal is on different chr. let mut j = 0 while j < mat.nCols { - assert_true((mat.matrix[0][j] - (-1.0)).abs() < 1.0e-10) + assert_true((mat.matrix[0][j] - -1.0).abs() < 1.0e-10) j = j + 1 } } @@ -286,7 +286,10 @@ test "eh_row_means" { ///| test "eh_minus_strand" { // Test that minus strand reverses window order. - let signals = [@src.GenomicSignal::new("chr1", 9800, 9900, 0.5), @src.GenomicSignal::new("chr1", 10100, 10200, 1.0)] + let signals = [ + @src.GenomicSignal::new("chr1", 9800, 9900, 0.5), + @src.GenomicSignal::new("chr1", 10100, 10200, 1.0), + ] let targets = [@src.TargetRegion::new("chr1", 10000, 10000, "-")] let config = @src.EnrichedHeatmapConfig::new( extendUp=500, diff --git a/test/moonbit/enrichplot_test.mbt b/test/moonbit/enrichplot_test.mbt index d932f441..f7a49a73 100644 --- a/test/moonbit/enrichplot_test.mbt +++ b/test/moonbit/enrichplot_test.mbt @@ -1,11 +1,16 @@ ///| - test "enrichplot_create_enrich_term" { let term = @src.EnrichTerm::new( - "GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, - ["gene1", "gene2", "gene3"] + "GO:0005623", + "cell", + 0.001, + 0.01, + 1.5, + 1.8, + 15, + ["gene1", "gene2", "gene3"], ) - + assert_eq(term.term_id, "GO:0005623") assert_eq(term.term_name, "cell") assert_eq(term.pvalue, 0.001) @@ -16,82 +21,124 @@ test "enrichplot_create_enrich_term" { assert_eq(term.genes.length(), 3) } +///| test "enrichplot_dotplot" { let terms = [ - @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, ["g1", "g2", "g3"]), - @src.EnrichTerm::new("GO:0005886", "plasma membrane", 0.002, 0.02, 1.2, 1.5, 10, ["g4", "g5"]), - @src.EnrichTerm::new("GO:0003674", "molecular_function", 0.003, 0.03, 0.8, 1.0, 8, ["g6"]), + @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, [ + "g1", "g2", "g3", + ]), + @src.EnrichTerm::new( + "GO:0005886", + "plasma membrane", + 0.002, + 0.02, + 1.2, + 1.5, + 10, + ["g4", "g5"], + ), + @src.EnrichTerm::new( + "GO:0003674", + "molecular_function", + 0.003, + 0.03, + 0.8, + 1.0, + 8, + ["g6"], + ), ] - + let result = @src.EnrichResult::new(terms, "GO", []) let plot = @src.bio_enrichplot_dotplot(result, 10, "Test Dotplot") - + assert_true(plot.contains("cell")) assert_true(plot.contains("plasma membrane")) assert_true(plot.contains("molecular_function")) } +///| test "enrichplot_barplot" { let terms = [ @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, ["g1"]), - @src.EnrichTerm::new("GO:0005886", "membrane", 0.002, 0.02, 1.2, 1.5, 10, ["g2"]), + @src.EnrichTerm::new("GO:0005886", "membrane", 0.002, 0.02, 1.2, 1.5, 10, [ + "g2", + ]), ] - + let result = @src.EnrichResult::new(terms, "GO", []) let plot = @src.bio_enrichplot_barplot(result, 5, "padj", "Test Barplot") - + assert_true(plot.contains("cell")) assert_true(plot.contains("membrane")) } +///| test "enrichplot_heatmap" { let terms = [ - @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, ["g1", "g2", "g3"]), - @src.EnrichTerm::new("GO:0005886", "membrane", 0.002, 0.02, 1.2, 1.5, 10, ["g2", "g4"]), + @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, [ + "g1", "g2", "g3", + ]), + @src.EnrichTerm::new("GO:0005886", "membrane", 0.002, 0.02, 1.2, 1.5, 10, [ + "g2", "g4", + ]), ] - + let result = @src.EnrichResult::new(terms, "GO", []) let plot = @src.bio_enrichplot_heatmap(result, 5, 5, "Test Heatmap") - + assert_true(plot.contains("cell")) assert_true(plot.contains("membrane")) } +///| test "enrichplot_cnetplot" { let terms = [ - @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, ["g1", "g2"]), - @src.EnrichTerm::new("GO:0005886", "membrane", 0.002, 0.02, 1.2, 1.5, 10, ["g2", "g3"]), + @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, [ + "g1", "g2", + ]), + @src.EnrichTerm::new("GO:0005886", "membrane", 0.002, 0.02, 1.2, 1.5, 10, [ + "g2", "g3", + ]), ] - + let result = @src.EnrichResult::new(terms, "GO", []) let plot = @src.bio_enrichplot_cnetplot(result, 5, "Test Cnetplot") - + assert_true(plot.contains("cell")) assert_true(plot.contains("membrane")) assert_true(plot.contains("g1")) assert_true(plot.contains("g2")) } +///| test "enrichplot_emapplot" { let terms = [ - @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, ["g1", "g2", "g3"]), - @src.EnrichTerm::new("GO:0005886", "membrane", 0.002, 0.02, 1.2, 1.5, 10, ["g2", "g3", "g4"]), - @src.EnrichTerm::new("GO:0003674", "function", 0.003, 0.03, 0.8, 1.0, 8, ["g5"]), + @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, [ + "g1", "g2", "g3", + ]), + @src.EnrichTerm::new("GO:0005886", "membrane", 0.002, 0.02, 1.2, 1.5, 10, [ + "g2", "g3", "g4", + ]), + @src.EnrichTerm::new("GO:0003674", "function", 0.003, 0.03, 0.8, 1.0, 8, [ + "g5", + ]), ] - + let result = @src.EnrichResult::new(terms, "GO", []) let plot = @src.bio_enrichplot_emapplot(result, 0.3, "Test Emapplot") - + assert_true(plot.contains("cell")) assert_true(plot.contains("membrane")) } +///| test "enrichplot_empty_result" { let result = @src.EnrichResult::new([], "GO", []) - + let dotplot = @src.bio_enrichplot_dotplot(result, 10, "Test") assert_true(dotplot.contains("Test")) - + let barplot = @src.bio_enrichplot_barplot(result, 10, "padj", "Test") assert_true(barplot.contains("Test")) -} \ No newline at end of file +} diff --git a/test/moonbit/ensembldb_test.mbt b/test/moonbit/ensembldb_test.mbt index a6abe537..0aa49b11 100644 --- a/test/moonbit/ensembldb_test.mbt +++ b/test/moonbit/ensembldb_test.mbt @@ -1,38 +1,42 @@ ///| /// Tests for ensembldb module. - test "EnsDb creation" { let db = @src.create_example_ensdb() assert_eq(@src.edb_num_genes(db), 3) assert_eq(@src.edb_num_transcripts(db), 4) } +///| test "edb_get_gene_by_id" { let db = @src.create_example_ensdb() let gene = @src.edb_get_gene_by_id(db, "ENSG000001") assert_true(gene is Some(_)) } +///| test "edb_get_gene_by_name" { let db = @src.create_example_ensdb() let genes = @src.edb_get_gene_by_name(db, "ACTB") assert_eq(genes.length(), 1) } +///| test "edb_get_transcripts_by_gene" { let db = @src.create_example_ensdb() let txs = @src.edb_get_transcripts_by_gene(db, "ENSG000001") assert_eq(txs.length(), 2) } +///| test "edb_filter_by_chromosome" { let db = @src.create_example_ensdb() let filtered = @src.edb_filter_by_chromosome(db, "17") assert_eq(@src.edb_num_genes(filtered), 2) } +///| test "edb_get_gene_length" { let db = @src.create_example_ensdb() let length = @src.edb_get_gene_length(db, "ENSG000001") assert_eq(length, 6257) -} \ No newline at end of file +} diff --git a/test/moonbit/estimate_score_test.mbt b/test/moonbit/estimate_score_test.mbt index b59c15be..8e0b0581 100644 --- a/test/moonbit/estimate_score_test.mbt +++ b/test/moonbit/estimate_score_test.mbt @@ -7,27 +7,27 @@ // --------------------------------------------------------------------------- test "est_expression_creation" { - let expr = @src.EstExpression::new( - ["G1", "G2"], - ["S1", "S2"], - [[1.0, 2.0], [3.0, 4.0]], - ) + let expr = @src.EstExpression::new(["G1", "G2"], ["S1", "S2"], [ + [1.0, 2.0], + [3.0, 4.0], + ]) assert_eq(expr.gene_names().length(), 2) assert_eq(expr.sample_names().length(), 2) assert_eq(expr.matrix()[1][0], 3.0) } +///| test "est_signature_creation" { - let sig = @src.EstSignature::new( - ["STROMA1", "STROMA2"], - ["IMMUNE1", "IMMUNE2"], - ) + let sig = @src.EstSignature::new(["STROMA1", "STROMA2"], [ + "IMMUNE1", "IMMUNE2", + ]) assert_eq(sig.stromal_genes().length(), 2) assert_eq(sig.immune_genes().length(), 2) assert_eq(sig.stromal_genes()[0], "STROMA1") assert_eq(sig.immune_genes()[1], "IMMUNE2") } +///| test "est_sample_score_accessors" { // Use est_run to get real scores and test accessors let expr = @src.est_sample_data() @@ -43,6 +43,7 @@ test "est_sample_score_accessors" { ) } +///| test "est_result_accessors" { // Use est_run to get a real result and test accessors let expr = @src.est_sample_data() @@ -56,6 +57,7 @@ test "est_result_accessors" { // Built-in gene signatures // --------------------------------------------------------------------------- +///| test "est_stromal_genes_nonempty" { let genes = @src.est_stromal_genes() assert_true(genes.length() >= 30) @@ -63,24 +65,32 @@ test "est_stromal_genes_nonempty" { let mut has_col1a1 = false let mut has_dcn = false for g in genes { - if g == "COL1A1" { has_col1a1 = true } - if g == "DCN" { has_dcn = true } + if g == "COL1A1" { + has_col1a1 = true + } + if g == "DCN" { + has_dcn = true + } } assert_true(has_col1a1) assert_true(has_dcn) } +///| test "est_immune_genes_nonempty" { let genes = @src.est_immune_genes() assert_true(genes.length() >= 20) // Should contain typical immune markers like CD3D, CD3E let mut has_cd3d = false for g in genes { - if g == "CD3D" { has_cd3d = true } + if g == "CD3D" { + has_cd3d = true + } } assert_true(has_cd3d) } +///| test "est_default_signature" { let sig = @src.est_default_signature() assert_true(sig.stromal_genes().length() >= 30) @@ -91,6 +101,7 @@ test "est_default_signature" { // ECDF normalization behavior // --------------------------------------------------------------------------- +///| test "est_run_normalizes_across_samples" { // With 4 samples, ECDF values are 0.25, 0.5, 0.75, 1.0 // Scores should be in [-100, 100] range @@ -112,6 +123,7 @@ test "est_run_normalizes_across_samples" { // Sample data correctness // --------------------------------------------------------------------------- +///| test "est_sample_data_dimensions" { let expr = @src.est_sample_data() assert_eq(expr.sample_names().length(), 4) @@ -123,6 +135,7 @@ test "est_sample_data_dimensions" { } } +///| test "est_sample_data_sample_names" { let expr = @src.est_sample_data() assert_eq(expr.sample_names()[0], "HighStromal") @@ -135,6 +148,7 @@ test "est_sample_data_sample_names" { // Score semantics // --------------------------------------------------------------------------- +///| test "est_run_high_stromal_higher_than_low_stromal" { // HighStromal sample should have higher stromal score than LowBoth let expr = @src.est_sample_data() @@ -144,6 +158,7 @@ test "est_run_high_stromal_higher_than_low_stromal" { assert_true(high_stromal.stromal_score() > low_both.stromal_score()) } +///| test "est_run_high_immune_higher_than_low_immune" { // HighImmune sample should have higher immune score than LowBoth let expr = @src.est_sample_data() @@ -153,6 +168,7 @@ test "est_run_high_immune_higher_than_low_immune" { assert_true(high_immune.immune_score() > low_both.immune_score()) } +///| test "est_run_high_both_highest_estimate_score" { // HighBoth should have the highest combined ESTIMATE score let expr = @src.est_sample_data() @@ -162,6 +178,7 @@ test "est_run_high_both_highest_estimate_score" { assert_true(high_both.estimate_score() > low_both.estimate_score()) } +///| test "est_run_estimate_score_equals_stromal_plus_immune" { // ESTIMATEScore = StromalScore + ImmuneScore let expr = @src.est_sample_data() @@ -172,6 +189,7 @@ test "est_run_estimate_score_equals_stromal_plus_immune" { } } +///| test "est_run_low_both_has_low_scores" { // LowBoth (low infiltration) should have negative scores for both let expr = @src.est_sample_data() @@ -185,6 +203,7 @@ test "est_run_low_both_has_low_scores" { // Tumor purity // --------------------------------------------------------------------------- +///| test "est_run_tumor_purity_in_valid_range" { // Tumor purity should be in [0, 1] or NaN let expr = @src.est_sample_data() @@ -201,6 +220,7 @@ test "est_run_tumor_purity_in_valid_range" { } } +///| test "est_run_low_infiltration_higher_purity" { // LowBoth (low infiltration -> higher tumor content) should have higher // tumor purity than HighBoth (high infiltration -> lower tumor content) @@ -208,8 +228,7 @@ test "est_run_low_infiltration_higher_purity" { let result = @src.est_run(expr) let low_both = result.get_score("LowBoth") let high_both = result.get_score("HighBoth") - if !low_both.tumor_purity().is_nan() && - !high_both.tumor_purity().is_nan() { + if !low_both.tumor_purity().is_nan() && !high_both.tumor_purity().is_nan() { assert_true(low_both.tumor_purity() >= high_both.tumor_purity()) } } @@ -218,19 +237,16 @@ test "est_run_low_infiltration_higher_purity" { // Custom signature // --------------------------------------------------------------------------- +///| test "est_run_custom_signature" { // Build expression matrix with 4 genes, 2 samples // G1, G2 are stromal markers; G3, G4 are immune markers - let expr = @src.EstExpression::new( - ["G1", "G2", "G3", "G4"], - ["S1", "S2"], - [ - [10.0, 1.0], // G1 - stromal, high in S1 - [8.0, 1.0], // G2 - stromal, high in S1 - [1.0, 10.0], // G3 - immune, high in S2 - [1.0, 8.0], // G4 - immune, high in S2 - ], - ) + let expr = @src.EstExpression::new(["G1", "G2", "G3", "G4"], ["S1", "S2"], [ + [10.0, 1.0], // G1 - stromal, high in S1 + [8.0, 1.0], // G2 - stromal, high in S1 + [1.0, 10.0], // G3 - immune, high in S2 + [1.0, 8.0], // G4 - immune, high in S2 + ]) let sig = @src.EstSignature::new(["G1", "G2"], ["G3", "G4"]) let result = @src.est_run(expr, signature=sig) assert_eq(result.scores().length(), 2) @@ -241,13 +257,13 @@ test "est_run_custom_signature" { assert_true(s2.immune_score() > s1.immune_score()) } +///| test "est_run_empty_signature_returns_zeros" { // With empty gene sets, ssGSEA returns 0; ECDF of all-zeros is degenerate - let expr = @src.EstExpression::new( - ["G1", "G2"], - ["S1", "S2"], - [[1.0, 2.0], [3.0, 4.0]], - ) + let expr = @src.EstExpression::new(["G1", "G2"], ["S1", "S2"], [ + [1.0, 2.0], + [3.0, 4.0], + ]) let sig = @src.EstSignature::new([], []) let result = @src.est_run(expr, signature=sig) for s in result.scores() { @@ -261,6 +277,7 @@ test "est_run_empty_signature_returns_zeros" { // get_score and to_string // --------------------------------------------------------------------------- +///| test "est_result_get_score_known_sample" { let expr = @src.est_sample_data() let result = @src.est_run(expr) @@ -268,6 +285,7 @@ test "est_result_get_score_known_sample" { assert_eq(s.sample_id(), "HighStromal") } +///| test "est_result_get_score_unknown_sample" { let expr = @src.est_sample_data() let result = @src.est_run(expr) @@ -278,6 +296,7 @@ test "est_result_get_score_unknown_sample" { assert_true(s.estimate_score().abs() < 1.0e-9) } +///| test "est_result_to_string" { let expr = @src.est_sample_data() let result = @src.est_run(expr) @@ -293,13 +312,15 @@ test "est_result_to_string" { // Edge cases // --------------------------------------------------------------------------- +///| test "est_run_single_sample" { // Single sample: ECDF is degenerate (trivially all-equal), scores are 0.0 - let expr = @src.EstExpression::new( - ["G1", "G2", "G3", "G4"], - ["Only"], - [[10.0], [8.0], [5.0], [3.0]], - ) + let expr = @src.EstExpression::new(["G1", "G2", "G3", "G4"], ["Only"], [ + [10.0], + [8.0], + [5.0], + [3.0], + ]) let sig = @src.EstSignature::new(["G1", "G2"], ["G3", "G4"]) let result = @src.est_run(expr, signature=sig) assert_eq(result.scores().length(), 1) @@ -309,13 +330,14 @@ test "est_run_single_sample" { assert_true(s.immune_score().abs() < 1.0e-9) } +///| test "est_run_no_signature_genes_present" { // None of the signature genes are in the expression matrix - let expr = @src.EstExpression::new( - ["X1", "X2", "X3"], - ["S1", "S2"], - [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], - ) + let expr = @src.EstExpression::new(["X1", "X2", "X3"], ["S1", "S2"], [ + [1.0, 2.0], + [3.0, 4.0], + [5.0, 6.0], + ]) let sig = @src.EstSignature::new(["G1", "G2"], ["G3", "G4"]) let result = @src.est_run(expr, signature=sig) // All scores should be 0 (or near 0) since no genes match @@ -325,6 +347,7 @@ test "est_run_no_signature_genes_present" { } } +///| test "est_run_all_samples_identical" { // Identical samples should have identical scores let expr = @src.EstExpression::new( diff --git a/test/moonbit/exonerate_test.mbt b/test/moonbit/exonerate_test.mbt index 6339760b..4686769e 100644 --- a/test/moonbit/exonerate_test.mbt +++ b/test/moonbit/exonerate_test.mbt @@ -38,9 +38,7 @@ test "exonerate_record_new" { @src.AlignmentBlock::new("I", 0, 0, 1000.0), ] let rec = @src.ExonerateRecord::new( - "query1", 0, 100, "+", - "target1", 0, 95, "+", - 1850.0, blocks, + "query1", 0, 100, "+", "target1", 0, 95, "+", 1850.0, blocks, ) assert_eq(rec.query_name(), "query1") assert_eq(rec.query_start(), 0) diff --git a/test/moonbit/expasy_test.mbt b/test/moonbit/expasy_test.mbt index 46954e8e..ed587009 100644 --- a/test/moonbit/expasy_test.mbt +++ b/test/moonbit/expasy_test.mbt @@ -1,41 +1,45 @@ ///| /// Tests for ExPASy module. - test "ExPASyRecord creation" { let record = @src.ExPASyRecord::new("P04637", "Swiss-Prot") assert_eq(record.id, "P04637") assert_eq(record.database, "Swiss-Prot") } +///| test "ExPASyRecord add field" { let record = @src.ExPASyRecord::new("P04637", "Swiss-Prot") let record2 = record.add_field("description", "Tumor protein p53") - + let desc = record2.get_field("description") assert_true(desc is Some(_)) assert_eq(desc.unwrap(), "Tumor protein p53") } +///| test "ExPASyEntry creation" { let entry = @src.ExPASyEntry::new("P04637", "TP53") assert_eq(entry.accession, "P04637") assert_eq(entry.name, "TP53") } +///| test "ExPASyEntry add keyword" { let entry = @src.ExPASyEntry::new("P04637", "TP53") let entry2 = entry.add_keyword("Tumor suppressor") - + assert_eq(entry2.keywords.length(), 1) assert_eq(entry2.keywords[0], "Tumor suppressor") } +///| test "EnzymeEntry creation" { let enzyme = @src.EnzymeEntry::new("1.1.1.1", "Alcohol dehydrogenase") assert_eq(enzyme.ec_number, "1.1.1.1") assert_eq(enzyme.name, "Alcohol dehydrogenase") } +///| test "enzyme_parse_ec" { let (class, subclass, subsubclass, serial) = @src.enzyme_parse_ec("1.1.1.1") assert_eq(class, "1") @@ -44,35 +48,41 @@ test "enzyme_parse_ec" { assert_eq(serial, "1") } +///| test "expasy_get_prosite_ids" { let ids = @src.expasy_get_prosite_ids("PCNG") assert_true(ids.length() > 0) } +///| test "expasy_get_swissprot_entry" { let entry = @src.expasy_get_swissprot_entry("P04637") assert_true(entry is Some(_)) } +///| test "expasy_get_enzyme" { let enzyme = @src.expasy_get_enzyme("1.1.1.1") assert_true(enzyme is Some(_)) } +///| test "expasy_analyze_protein" { let results = @src.expasy_analyze_protein("AVG") assert_true(results.contains("molecular_weight")) assert_true(results.contains("gravy")) } +///| test "create_example_expasy_entry" { let entry = @src.create_example_expasy_entry() assert_eq(entry.accession, "P04637") assert_eq(entry.name, "TP53") } +///| test "create_example_enzyme_entry" { let enzyme = @src.create_example_enzyme_entry() assert_eq(enzyme.ec_number, "1.1.1.1") assert_eq(enzyme.name, "Alcohol dehydrogenase") -} \ No newline at end of file +} diff --git a/test/moonbit/factoextra_test.mbt b/test/moonbit/factoextra_test.mbt index 58d23123..a810ea59 100644 --- a/test/moonbit/factoextra_test.mbt +++ b/test/moonbit/factoextra_test.mbt @@ -17,11 +17,7 @@ test "factoextra_pca_basic" { ///| test "factoextra_pca_eigenvalues" { - let data = [ - [2.0, 3.0], - [5.0, 6.0], - [8.0, 9.0], - ] + let data = [[2.0, 3.0], [5.0, 6.0], [8.0, 9.0]] let result = @src.facto_pca(data) let eigenvalues = @src.facto_get_eigenvalue(result) assert_eq(eigenvalues.length(), 2) @@ -30,28 +26,22 @@ test "factoextra_pca_eigenvalues" { ///| test "factoextra_pca_variance" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - [10.0, 11.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0], [10.0, 11.0]] let result = @src.facto_pca(data) let eigenvalues = @src.facto_get_eigenvalue(result) let mut i = 1 while i < eigenvalues.length() { - assert_true(eigenvalues[i].cumulative_variance >= eigenvalues[i - 1].cumulative_variance) + assert_true( + eigenvalues[i].cumulative_variance >= + eigenvalues[i - 1].cumulative_variance, + ) i = i + 1 } } ///| test "factoextra_pca_individual_coords" { - let data = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - [7.0, 8.0, 9.0], - ] + let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let result = @src.facto_pca(data) let ind = @src.facto_get_pca_ind(result) assert_eq(ind.coord.length(), 3) @@ -60,11 +50,7 @@ test "factoextra_pca_individual_coords" { ///| test "factoextra_pca_variable_coords" { - let data = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - [7.0, 8.0, 9.0], - ] + let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let result = @src.facto_pca(data) let pca_var = @src.facto_get_pca_var(result) assert_eq(pca_var.coord.length(), 3) @@ -78,18 +64,14 @@ test "factoextra_pca_ncp" { [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0], ] - let result = @src.facto_pca(data, ncp = 2) + let result = @src.facto_pca(data, ncp=2) assert_eq(result.n_dims, 2) assert_eq(result.eigenvalues.length(), 2) } ///| test "factoextra_pca_cos2_individuals" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0]] let result = @src.facto_pca(data) let ind = @src.facto_get_pca_ind(result) assert_eq(ind.cos2.length(), 3) @@ -107,11 +89,7 @@ test "factoextra_pca_cos2_individuals" { ///| test "factoextra_pca_contrib_variables" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0]] let result = @src.facto_pca(data) let pca_var = @src.facto_get_pca_var(result) assert_eq(pca_var.contrib.length(), 2) @@ -120,11 +98,7 @@ test "factoextra_pca_contrib_variables" { ///| test "factoextra_pca_total_inertia" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0]] let result = @src.facto_pca(data) let total = @src.facto_total_inertia(result) assert_true(total > 0.0) @@ -132,12 +106,7 @@ test "factoextra_pca_total_inertia" { ///| test "factoextra_pca_nb_dim" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - [10.0, 11.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0], [10.0, 11.0]] let result = @src.facto_pca(data) let nb = @src.facto_nb_dim(result, 80.0) assert_true(nb >= 1) @@ -146,10 +115,7 @@ test "factoextra_pca_nb_dim" { ///| test "factoextra_pca_summary" { - let data = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - ] + let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let result = @src.facto_pca(data) let summary = @src.facto_summary(result) assert_eq(summary.n_individuals, 2) @@ -168,11 +134,7 @@ test "factoextra_pca_empty" { ///| test "factoextra_pca_contrib_dim" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0]] let result = @src.facto_pca(data) let contribs = @src.facto_var_contrib_dim(result, 1) assert_eq(contribs.length(), 2) @@ -181,11 +143,7 @@ test "factoextra_pca_contrib_dim" { ///| test "factoextra_pca_cos2_dim" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0]] let result = @src.facto_pca(data) let cos2s = @src.facto_var_cos2_dim(result, 1) assert_eq(cos2s.length(), 2) @@ -193,11 +151,7 @@ test "factoextra_pca_cos2_dim" { ///| test "factoextra_pca_dimdesc" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0]] let result = @src.facto_pca(data) let desc = @src.facto_dimdesc(data, result, 1) assert_eq(desc.length(), 2) @@ -205,11 +159,7 @@ test "factoextra_pca_dimdesc" { ///| test "factoextra_pca_loadings" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0]] let result = @src.facto_pca(data) let loadings = @src.facto_loadings(result) assert_eq(loadings.length(), 2) @@ -217,10 +167,7 @@ test "factoextra_pca_loadings" { ///| test "factoextra_pca_print_summary" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0]] let result = @src.facto_pca(data) let summary = @src.facto_print_summary(result) assert_true(summary.length() > 0) diff --git a/test/moonbit/feature_counts_test.mbt b/test/moonbit/feature_counts_test.mbt index 3f57568d..18cd06cc 100644 --- a/test/moonbit/feature_counts_test.mbt +++ b/test/moonbit/feature_counts_test.mbt @@ -1,9 +1,11 @@ ///| /// Test file for featureCounts module. - test "feature_annotation_creation" { let fa = @src.FeatureAnnotation::new( - chr="chr1", start=1000, end_=2000, strand="+", + chr="chr1", + start=1000, + end_=2000, + strand="+", gene_id="GeneA", ) assert_eq(fa.chr, "chr1") @@ -14,9 +16,13 @@ test "feature_annotation_creation" { assert_eq(fa.length(), 1001) } +///| test "feature_annotation_overlap" { let fa = @src.FeatureAnnotation::new( - chr="chr1", start=1000, end_=2000, strand="+", + chr="chr1", + start=1000, + end_=2000, + strand="+", gene_id="GeneA", ) assert_true(fa.overlaps(chr="chr1", start=1500, end_=1600)) @@ -26,9 +32,13 @@ test "feature_annotation_overlap" { assert_false(fa.overlaps(chr="chr1", start=2100, end_=2200)) } +///| test "feature_annotation_overlap_length" { let fa = @src.FeatureAnnotation::new( - chr="chr1", start=1000, end_=2000, strand="+", + chr="chr1", + start=1000, + end_=2000, + strand="+", gene_id="GeneA", ) assert_eq(fa.overlap_length(chr="chr1", start=1500, end_=1600), 101) @@ -37,9 +47,13 @@ test "feature_annotation_overlap_length" { assert_eq(fa.overlap_length(chr="chr2", start=1500, end_=1600), 0) } +///| test "read_alignment_creation" { let r = @src.ReadAlignment::new( - read_id="read1", chr="chr1", start=1500, end_=1600, + read_id="read1", + chr="chr1", + start=1500, + end_=1600, ) assert_eq(r.read_id, "read1") assert_eq(r.chr, "chr1") @@ -49,9 +63,13 @@ test "read_alignment_creation" { assert_eq(r.n_alignments, 1) } +///| test "read_alignment_paired" { let r = @src.ReadAlignment::new_paired( - read_id="read1", chr="chr1", start=1500, end_=1600, + read_id="read1", + chr="chr1", + start=1500, + end_=1600, mate_start=1700, ) assert_eq(r.is_paired, true) @@ -59,6 +77,7 @@ test "read_alignment_paired" { assert_true(r.fragment_length > 0) } +///| test "feature_counts_config_default" { let cfg = @src.FeatureCountsConfig::new() assert_eq(cfg.min_overlap, 1) @@ -66,6 +85,7 @@ test "feature_counts_config_default" { assert_eq(cfg.ignore_strand, false) } +///| test "feature_counts_config_setters" { let cfg = @src.FeatureCountsConfig::new() .set_min_overlap(val=5) @@ -76,16 +96,23 @@ test "feature_counts_config_setters" { assert_eq(cfg.count_fragments, true) } +///| test "feature_counts_count_basic" { let (features, reads, samples) = @src.feature_counts_sample_data() let cfg = @src.FeatureCountsConfig::new().set_min_mapq(val=40) - let result = @src.feature_counts_count(features, reads, sample_names=samples, config=cfg) + let result = @src.feature_counts_count( + features, + reads, + sample_names=samples, + config=cfg, + ) assert_eq(result.n_features(), 4) assert_eq(result.n_samples(), 1) assert_eq(result.total_reads[0], 7) assert_eq(result.assigned_reads[0], 5) } +///| test "feature_counts_get_count" { let (features, reads, samples) = @src.feature_counts_sample_data() let result = @src.feature_counts_count(features, reads, sample_names=samples) @@ -93,35 +120,56 @@ test "feature_counts_get_count" { assert_true(count >= 2.0) } +///| test "feature_counts_unassigned" { let (features, reads, samples) = @src.feature_counts_sample_data() let cfg = @src.FeatureCountsConfig::new().set_min_mapq(val=40) - let result = @src.feature_counts_count(features, reads, sample_names=samples, config=cfg) + let result = @src.feature_counts_count( + features, + reads, + sample_names=samples, + config=cfg, + ) assert_eq(result.unassigned_low_quality[0], 1) assert_eq(result.unassigned_no_features[0], 1) } +///| test "feature_counts_with_strand" { let (features, reads, samples) = @src.feature_counts_sample_data() - let cfg = @src.FeatureCountsConfig::new() - .set_strand_mode(mode=@src.strand_stranded()) - let result = @src.feature_counts_count(features, reads, sample_names=samples, config=cfg) + let cfg = @src.FeatureCountsConfig::new().set_strand_mode( + mode=@src.strand_stranded(), + ) + let result = @src.feature_counts_count( + features, + reads, + sample_names=samples, + config=cfg, + ) let count_b1 = result.get_count(feature_id="exon_B1", sample_idx=0) // read3 is on chr1:6500-6600, strand -, feature is on strand -, should match assert_true(count_b1 >= 1.0) } +///| test "feature_counts_reversed_strand" { let (features, reads, samples) = @src.feature_counts_sample_data() - let cfg = @src.FeatureCountsConfig::new() - .set_strand_mode(mode=@src.strand_reversed()) - let result = @src.feature_counts_count(features, reads, sample_names=samples, config=cfg) + let cfg = @src.FeatureCountsConfig::new().set_strand_mode( + mode=@src.strand_reversed(), + ) + let result = @src.feature_counts_count( + features, + reads, + sample_names=samples, + config=cfg, + ) // With reversed strand, read on + should NOT match feature on + // read1 (+) on chr1:1500 should NOT match exon_A1 (+) with reversed let count = result.get_count(feature_id="exon_A1", sample_idx=0) assert_true(count <= 1.0) } +///| test "feature_counts_library_size" { let (features, reads, samples) = @src.feature_counts_sample_data() let result = @src.feature_counts_count(features, reads, sample_names=samples) @@ -129,6 +177,7 @@ test "feature_counts_library_size" { assert_true(lib_size > 0.0) } +///| test "feature_counts_cpm" { let (features, reads, samples) = @src.feature_counts_sample_data() let result = @src.feature_counts_count(features, reads, sample_names=samples) @@ -136,6 +185,7 @@ test "feature_counts_cpm" { assert_true(cpm_val >= 0.0) } +///| test "feature_counts_summary" { let (features, reads, samples) = @src.feature_counts_sample_data() let result = @src.feature_counts_count(features, reads, sample_names=samples) @@ -143,26 +193,43 @@ test "feature_counts_summary" { assert_true(summary.length() > 0) } +///| test "feature_counts_multi_sample" { let features : Array[@src.FeatureAnnotation] = Array::new() - features.push(@src.FeatureAnnotation::new( - chr="chr1", start=1000, end_=2000, strand="+", - gene_id="GeneA", feature_id="exon_A1", - )) + features.push( + @src.FeatureAnnotation::new( + chr="chr1", + start=1000, + end_=2000, + strand="+", + gene_id="GeneA", + feature_id="exon_A1", + ), + ) let reads : Array[@src.ReadAlignment] = Array::new() - reads.push(@src.ReadAlignment::new( - read_id="read_s1_1", chr="chr1", start=1500, end_=1600, - )) - reads.push(@src.ReadAlignment::new( - read_id="read_s2_1", chr="chr1", start=1500, end_=1600, - )) + reads.push( + @src.ReadAlignment::new( + read_id="read_s1_1", + chr="chr1", + start=1500, + end_=1600, + ), + ) + reads.push( + @src.ReadAlignment::new( + read_id="read_s2_1", + chr="chr1", + start=1500, + end_=1600, + ), + ) let sample_names : Array[String] = Array::new() sample_names.push("sample1") sample_names.push("sample2") - let result = @src.feature_counts_count(features, reads, sample_names=sample_names) + let result = @src.feature_counts_count(features, reads, sample_names~) assert_eq(result.n_samples(), 2) assert_eq(result.total_reads[0], 1) assert_eq(result.total_reads[1], 1) @@ -170,6 +237,7 @@ test "feature_counts_multi_sample" { assert_eq(result.get_count(feature_id="exon_A1", sample_idx=1), 1.0) } +///| test "strand_mode_creation" { let s1 = @src.strand_unstranded() let s2 = @src.strand_stranded() @@ -180,6 +248,7 @@ test "strand_mode_creation" { assert_true(s3 == s3) } +///| test "feature_counts_feature_total" { let (features, reads, samples) = @src.feature_counts_sample_data() let result = @src.feature_counts_count(features, reads, sample_names=samples) diff --git a/test/moonbit/file_test.mbt b/test/moonbit/file_test.mbt index dcbe1f11..bf7d3d08 100644 --- a/test/moonbit/file_test.mbt +++ b/test/moonbit/file_test.mbt @@ -51,7 +51,11 @@ test "smart_file_creation_write" { ///| test "smart_file_with_format" { - let sf = @src.SmartFile::with_format("data.gz", @src.compression_gzip(), mode="r") + let sf = @src.SmartFile::with_format( + "data.gz", + @src.compression_gzip(), + mode="r", + ) assert_eq(sf.get_format().to_string(), "gzip") } diff --git a/test/moonbit/fishpond_test.mbt b/test/moonbit/fishpond_test.mbt index 97acc4e6..9120bd34 100644 --- a/test/moonbit/fishpond_test.mbt +++ b/test/moonbit/fishpond_test.mbt @@ -16,10 +16,9 @@ test "fish_counts_creation" { assert_eq(c.condition()[8], "control") } +///| test "fish_result_creation" { - let r = @src.FishResult::new( - "TX1", 15.0, 1.5, 0.01, 0.05, "up", - ) + let r = @src.FishResult::new("TX1", 15.0, 1.5, 0.01, 0.05, "up") assert_eq(r.transcript(), "TX1") assert_eq(r.statistic(), 15.0) assert_eq(r.log2_fold_change(), 1.5) @@ -32,35 +31,30 @@ test "fish_result_creation" { // Mann-Whitney-Wilcoxon statistic // --------------------------------------------------------------------------- +///| test "fish_mw_statistic_clear_separation" { // Cases all higher than controls - let stat = @src.fish_mann_whitney_test( - [10.0, 20.0, 30.0], - [1.0, 2.0, 3.0], - ) + let stat = @src.fish_mann_whitney_test([10.0, 20.0, 30.0], [1.0, 2.0, 3.0]) // With complete separation, W = sum of ranks 4,5,6 = 15 assert_eq(stat, 15.0) } +///| test "fish_mw_statistic_identical_groups" { - let stat = @src.fish_mann_whitney_test( - [5.0, 5.0, 5.0], - [5.0, 5.0, 5.0], - ) + let stat = @src.fish_mann_whitney_test([5.0, 5.0, 5.0], [5.0, 5.0, 5.0]) // All tied: average rank = 3.5 for each, sum for case = 3*3.5 = 10.5 assert_eq(stat, 10.5) } +///| test "fish_mw_statistic_overlap" { - let stat = @src.fish_mann_whitney_test( - [1.0, 3.0, 5.0], - [2.0, 4.0, 6.0], - ) + let stat = @src.fish_mann_whitney_test([1.0, 3.0, 5.0], [2.0, 4.0, 6.0]) // Ranks: 1->1(case), 2->2(ctrl), 3->3(case), 4->4(ctrl), 5->5(case), 6->6(ctrl) // W_case = 1+3+5 = 9 assert_eq(stat, 9.0) } +///| test "fish_mw_statistic_empty_group" { let stat = @src.fish_mann_whitney_test([], [1.0, 2.0]) assert_eq(stat, 0.0) @@ -70,17 +64,20 @@ test "fish_mw_statistic_empty_group" { // Log2 fold change // --------------------------------------------------------------------------- +///| test "fish_log2fc_positive" { let lfc = @src.fish_log2fc_test([8.0, 8.0], [2.0, 2.0]) // log2(9) - log2(3) = log2(3) ≈ 1.585 assert_true(lfc > 0.0) } +///| test "fish_log2fc_negative" { let lfc = @src.fish_log2fc_test([2.0, 2.0], [8.0, 8.0]) assert_true(lfc < 0.0) } +///| test "fish_log2fc_zero_means" { let lfc = @src.fish_log2fc_test([0.0, 0.0], [0.0, 0.0]) assert_eq(lfc, 0.0) @@ -90,6 +87,7 @@ test "fish_log2fc_zero_means" { // Full Swish analysis // --------------------------------------------------------------------------- +///| test "fish_swish_detects_upregulated" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -102,6 +100,7 @@ test "fish_swish_detects_upregulated" { assert_eq(results[2].direction(), "up") } +///| test "fish_swish_detects_downregulated" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -114,6 +113,7 @@ test "fish_swish_detects_downregulated" { assert_eq(results[5].direction(), "down") } +///| test "fish_swish_nonsignificant_stable" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -123,6 +123,7 @@ test "fish_swish_nonsignificant_stable" { } } +///| test "fish_swish_pvalues_in_range" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -132,6 +133,7 @@ test "fish_swish_pvalues_in_range" { } } +///| test "fish_swish_fdr_in_range" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -141,23 +143,21 @@ test "fish_swish_fdr_in_range" { } } +///| test "fish_swish_empty_input" { let counts = @src.FishCounts::new([], [], [], []) let results = @src.fish_swish(counts, "case", 10) assert_eq(results.length(), 0) } +///| test "fish_swish_too_few_samples" { - let counts = @src.FishCounts::new( - ["TX1"], - ["s1"], - ["case"], - [[5.0]], - ) + let counts = @src.FishCounts::new(["TX1"], ["s1"], ["case"], [[5.0]]) let results = @src.fish_swish(counts, "case", 10) assert_eq(results.length(), 0) } +///| test "fish_swish_log2fc_sign_correct" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -175,6 +175,7 @@ test "fish_swish_log2fc_sign_correct" { // Significant filtering // --------------------------------------------------------------------------- +///| test "fish_significant_filter" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -183,6 +184,7 @@ test "fish_significant_filter" { assert_true(sig.length() >= 6) } +///| test "fish_significant_strict_threshold" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -195,15 +197,15 @@ test "fish_significant_strict_threshold" { // Output formatting // --------------------------------------------------------------------------- +///| test "fish_result_to_string" { - let r = @src.FishResult::new( - "TX1", 15.0, 1.5, 0.01, 0.05, "up", - ) + let r = @src.FishResult::new("TX1", 15.0, 1.5, 0.01, 0.05, "up") let s = r.to_string() assert_true(s.contains("TX1")) assert_true(s.contains("up")) } +///| test "fish_results_to_string" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -216,28 +218,95 @@ test "fish_results_to_string" { // Sample data verification // --------------------------------------------------------------------------- +///| test "fish_sample_data_up_pattern" { let c = @src.fish_sample_counts() // TX1 (transcript 0): case values (indices 0-7) should be higher than control (indices 8-15) - let case_mean = (c.counts()[0][0] + c.counts()[0][1] + c.counts()[0][2] + c.counts()[0][3] + c.counts()[0][4] + c.counts()[0][5] + c.counts()[0][6] + c.counts()[0][7]) / 8.0 - let ctrl_mean = (c.counts()[0][8] + c.counts()[0][9] + c.counts()[0][10] + c.counts()[0][11] + c.counts()[0][12] + c.counts()[0][13] + c.counts()[0][14] + c.counts()[0][15]) / 8.0 + let case_mean = ( + c.counts()[0][0] + + c.counts()[0][1] + + c.counts()[0][2] + + c.counts()[0][3] + + c.counts()[0][4] + + c.counts()[0][5] + + c.counts()[0][6] + + c.counts()[0][7] + ) / + 8.0 + let ctrl_mean = ( + c.counts()[0][8] + + c.counts()[0][9] + + c.counts()[0][10] + + c.counts()[0][11] + + c.counts()[0][12] + + c.counts()[0][13] + + c.counts()[0][14] + + c.counts()[0][15] + ) / + 8.0 assert_true(case_mean > ctrl_mean) } +///| test "fish_sample_data_down_pattern" { let c = @src.fish_sample_counts() // TX4 (transcript 3): case values should be lower than control - let case_mean = (c.counts()[3][0] + c.counts()[3][1] + c.counts()[3][2] + c.counts()[3][3] + c.counts()[3][4] + c.counts()[3][5] + c.counts()[3][6] + c.counts()[3][7]) / 8.0 - let ctrl_mean = (c.counts()[3][8] + c.counts()[3][9] + c.counts()[3][10] + c.counts()[3][11] + c.counts()[3][12] + c.counts()[3][13] + c.counts()[3][14] + c.counts()[3][15]) / 8.0 + let case_mean = ( + c.counts()[3][0] + + c.counts()[3][1] + + c.counts()[3][2] + + c.counts()[3][3] + + c.counts()[3][4] + + c.counts()[3][5] + + c.counts()[3][6] + + c.counts()[3][7] + ) / + 8.0 + let ctrl_mean = ( + c.counts()[3][8] + + c.counts()[3][9] + + c.counts()[3][10] + + c.counts()[3][11] + + c.counts()[3][12] + + c.counts()[3][13] + + c.counts()[3][14] + + c.counts()[3][15] + ) / + 8.0 assert_true(case_mean < ctrl_mean) } +///| test "fish_sample_data_ns_pattern" { let c = @src.fish_sample_counts() // TX7 (transcript 6): similar values in both groups - let case_mean = (c.counts()[6][0] + c.counts()[6][1] + c.counts()[6][2] + c.counts()[6][3] + c.counts()[6][4] + c.counts()[6][5] + c.counts()[6][6] + c.counts()[6][7]) / 8.0 - let ctrl_mean = (c.counts()[6][8] + c.counts()[6][9] + c.counts()[6][10] + c.counts()[6][11] + c.counts()[6][12] + c.counts()[6][13] + c.counts()[6][14] + c.counts()[6][15]) / 8.0 + let case_mean = ( + c.counts()[6][0] + + c.counts()[6][1] + + c.counts()[6][2] + + c.counts()[6][3] + + c.counts()[6][4] + + c.counts()[6][5] + + c.counts()[6][6] + + c.counts()[6][7] + ) / + 8.0 + let ctrl_mean = ( + c.counts()[6][8] + + c.counts()[6][9] + + c.counts()[6][10] + + c.counts()[6][11] + + c.counts()[6][12] + + c.counts()[6][13] + + c.counts()[6][14] + + c.counts()[6][15] + ) / + 8.0 // Difference should be small - let diff = if case_mean > ctrl_mean { case_mean - ctrl_mean } else { ctrl_mean - case_mean } + let diff = if case_mean > ctrl_mean { + case_mean - ctrl_mean + } else { + ctrl_mean - case_mean + } assert_true(diff < 10.0) } diff --git a/test/moonbit/fragment_mapper_test.mbt b/test/moonbit/fragment_mapper_test.mbt index 40863cac..83e05f59 100644 --- a/test/moonbit/fragment_mapper_test.mbt +++ b/test/moonbit/fragment_mapper_test.mbt @@ -145,12 +145,14 @@ test "fm_coverage_basic" { ///| test "fm_merge_fragments_adjacent_same_type" { - let frag1 = @src.Fragment::new("f1", 1, 5, - fragment_type=@src.ft_helix(), - residues=[@src.FragmentResidue::new("A", 1), @src.FragmentResidue::new("L", 2)]) - let frag2 = @src.Fragment::new("f2", 6, 10, - fragment_type=@src.ft_helix(), - residues=[@src.FragmentResidue::new("P", 6), @src.FragmentResidue::new("H", 7)]) + let frag1 = @src.Fragment::new("f1", 1, 5, fragment_type=@src.ft_helix(), residues=[ + @src.FragmentResidue::new("A", 1), + @src.FragmentResidue::new("L", 2), + ]) + let frag2 = @src.Fragment::new("f2", 6, 10, fragment_type=@src.ft_helix(), residues=[ + @src.FragmentResidue::new("P", 6), + @src.FragmentResidue::new("H", 7), + ]) let merged = @src.fm_merge_fragments([frag1, frag2]) assert_eq(merged.length(), 1) assert_eq(merged[0].start_residue, 1) @@ -367,4 +369,4 @@ test "fm_parse_fragments_sequence_mapping" { "END\n" let result = @src.fm_parse_fragments(content) assert_eq(result.protein_sequence, "AGF") -} \ No newline at end of file +} diff --git a/test/moonbit/freq_analysis_test.mbt b/test/moonbit/freq_analysis_test.mbt index cab60cdd..45824167 100644 --- a/test/moonbit/freq_analysis_test.mbt +++ b/test/moonbit/freq_analysis_test.mbt @@ -1,57 +1,72 @@ // Tests for Bio.FreqAnalysis module +///| test "fa_count_kmers single nucleotide" { let result = @src.fa_count_kmers("ACGT", 1) assert_true(result.fa_get_total_count() == 4) - assert_true(result.fa_get_frequency("A") > 0.24 && result.fa_get_frequency("A") < 0.26) + assert_true( + result.fa_get_frequency("A") > 0.24 && result.fa_get_frequency("A") < 0.26, + ) } +///| test "fa_count_kmers dinucleotide" { let result = @src.fa_count_kmers("ACGTAC", 2) assert_true(result.fa_get_total_count() == 5) } +///| test "fa_count_kmers empty" { let result = @src.fa_count_kmers("", 3) assert_true(result.fa_get_total_count() == 0) } +///| test "fa_nucleotide_frequency" { let result = @src.fa_nucleotide_frequency("AATTCCGG") assert_true(result.fa_get_total_count() == 8) - assert_true(result.fa_get_frequency("A") > 0.24 && result.fa_get_frequency("A") < 0.26) + assert_true( + result.fa_get_frequency("A") > 0.24 && result.fa_get_frequency("A") < 0.26, + ) } +///| test "fa_count_pattern" { let count = @src.fa_count_pattern("ATATAT", "AT") assert_true(count == 3) } +///| test "fa_count_pattern no match" { let count = @src.fa_count_pattern("ACGT", "TT") assert_true(count == 0) } +///| test "fa_codon_usage" { let result = @src.fa_codon_usage("ATGAAACCC") assert_true(result.fa_get_total_count() == 3) } +///| test "fa_gc_content" { let result = @src.fa_gc_content("AAGGCC") assert_true(result > 0.66 && result < 0.68) } +///| test "fa_gc_content all GC" { let result = @src.fa_gc_content("GCGC") assert_true(result == 1.0) } +///| test "fa_at_content" { let result = @src.fa_at_content("AATTCC") assert_true(result > 0.66 && result < 0.68) } +///| test "fa_find_motif" { let positions = @src.fa_find_motif("ATCGATCGATCG", "ATC") assert_true(positions.length() == 3) @@ -60,11 +75,13 @@ test "fa_find_motif" { assert_true(positions[2] == 8) } +///| test "fa_find_motif not found" { let positions = @src.fa_find_motif("ACGT", "TT") assert_true(positions.length() == 0) } +///| test "fa_get_patterns" { let result = @src.fa_count_kmers("AAACCC", 1) let patterns = result.fa_get_patterns() diff --git a/test/moonbit/freq_table_test.mbt b/test/moonbit/freq_table_test.mbt index cd24d654..fa8f8ec9 100644 --- a/test/moonbit/freq_table_test.mbt +++ b/test/moonbit/freq_table_test.mbt @@ -305,7 +305,10 @@ test "freq_table_from_sequence_basic" { ///| test "freq_table_from_sequence_with_alphabet_restricts" { - let ft = @src.freq_table_from_sequence("AATTGGCCNN", Some(["A", "T", "G", "C"])) + let ft = @src.freq_table_from_sequence( + "AATTGGCCNN", + Some(["A", "T", "G", "C"]), + ) assert_eq(ft.size(), 4) assert_eq(ft.count_of("A"), 2) // N is not in alphabet, so it should not be counted. diff --git a/test/moonbit/fssp_test.mbt b/test/moonbit/fssp_test.mbt index c79df6bb..b36eb564 100644 --- a/test/moonbit/fssp_test.mbt +++ b/test/moonbit/fssp_test.mbt @@ -7,8 +7,7 @@ test "fssp_header_creation" { let h = @src.FsspHeader::new( - "1dfa_A", "30-jul-1998", "crystal structure", - "17beta-hsd", "human", "holm", + "1dfa_A", "30-jul-1998", "crystal structure", "17beta-hsd", "human", "holm", 25, 3, 2.0, ) assert_eq(h.pdbid(), "1dfa_A") @@ -22,10 +21,10 @@ test "fssp_header_creation" { assert_eq(h.threshold(), "2") } +///| test "fssp_alignment_creation" { let a = @src.FsspAlignment::new( - "1csa_A", "1csa_A", 1, "MNIFVHEKDLFRTIVS", - 12.1, 2.0, 16, 68.8, + "1csa_A", "1csa_A", 1, "MNIFVHEKDLFRTIVS", 12.1, 2.0, 16, 68.8, ) assert_eq(a.pdbid(), "1csa_A") assert_eq(a.alignment_id(), "1csa_A") @@ -37,10 +36,10 @@ test "fssp_alignment_creation" { assert_eq(a.pid(), 68.8) } +///| test "fssp_data_creation" { let h = @src.FsspHeader::new( - "1dfa_A", "30-jul-1998", "", "", "", "", - 25, 2, 2.0, + "1dfa_A", "30-jul-1998", "", "", "", "", 25, 2, 2.0, ) let a1 = @src.FsspAlignment::new( "1dfa_A", "1dfa_A", 1, "ACGT", 15.0, 1.5, 4, 100.0, @@ -53,10 +52,9 @@ test "fssp_data_creation" { assert_true(data.reference().unwrap().pdbid() == "1dfa_A") } +///| test "fssp_filter_by_zscore" { - let h = @src.FsspHeader::new( - "1dfa_A", "", "", "", "", "", 10, 3, 2.0, - ) + let h = @src.FsspHeader::new("1dfa_A", "", "", "", "", "", 10, 3, 2.0) let a1 = @src.FsspAlignment::new("a1", "a1", 1, "AAA", 15.0, 1.0, 3, 100.0) let a2 = @src.FsspAlignment::new("a2", "a2", 1, "AAA", 10.0, 2.0, 3, 80.0) let a3 = @src.FsspAlignment::new("a3", "a3", 1, "AAA", 5.0, 3.0, 3, 60.0) @@ -67,10 +65,9 @@ test "fssp_filter_by_zscore" { assert_eq(filtered[1].pdbid(), "a2") } +///| test "fssp_empty_alignments" { - let h = @src.FsspHeader::new( - "1dfa_A", "", "", "", "", "", 0, 0, 0.0, - ) + let h = @src.FsspHeader::new("1dfa_A", "", "", "", "", "", 0, 0, 0.0) let data = @src.FsspData::new(h, []) assert_eq(data.n_alignments(), 0) assert_true(data.reference() is None) @@ -80,12 +77,14 @@ test "fssp_empty_alignments" { // Sample data // --------------------------------------------------------------------------- +///| test "fssp_sample_text_has_header" { let text = @src.fssp_sample_text() assert_true(text.contains("HEADER")) assert_true(text.contains("1dfa_A")) } +///| test "fssp_sample_text_has_alignments" { let text = @src.fssp_sample_text() assert_true(text.contains("## ALIGNMENTS")) @@ -93,6 +92,7 @@ test "fssp_sample_text_has_alignments" { assert_true(text.contains("1hsd_A")) } +///| test "fssp_sample_text_has_threshold" { let text = @src.fssp_sample_text() assert_true(text.contains("THRESHOLD")) @@ -103,6 +103,7 @@ test "fssp_sample_text_has_threshold" { // Parsing // --------------------------------------------------------------------------- +///| test "fssp_parse_header" { let text = @src.fssp_sample_text() let data = @src.fssp_parse(text) @@ -113,6 +114,7 @@ test "fssp_parse_header" { assert_eq(h.threshold(), "2") } +///| test "fssp_parse_header_title" { let text = @src.fssp_sample_text() let data = @src.fssp_parse(text) @@ -123,12 +125,14 @@ test "fssp_parse_header_title" { assert_eq(h.author(), "holm") } +///| test "fssp_parse_alignments_count" { let text = @src.fssp_sample_text() let data = @src.fssp_parse(text) assert_eq(data.n_alignments(), 3) } +///| test "fssp_parse_alignment_details" { let text = @src.fssp_sample_text() let data = @src.fssp_parse(text) @@ -144,6 +148,7 @@ test "fssp_parse_alignment_details" { assert_eq(ref_aln.pid(), 75.0) } +///| test "fssp_parse_second_alignment" { let text = @src.fssp_sample_text() let data = @src.fssp_parse(text) @@ -153,6 +158,7 @@ test "fssp_parse_second_alignment" { assert_eq(a2.pid(), 68.8) } +///| test "fssp_parse_reference" { let text = @src.fssp_sample_text() let data = @src.fssp_parse(text) @@ -160,11 +166,13 @@ test "fssp_parse_reference" { assert_eq(ref.pdbid(), "1dfa_A") } +///| test "fssp_parse_empty_input" { let data = @src.fssp_parse("") assert_eq(data.n_alignments(), 0) } +///| test "fssp_parse_header_only" { let text = "HEADER \\_1abc_A 1 01-jan-2000\nSEQLENGTH 10\n" let data = @src.fssp_parse(text) @@ -174,6 +182,7 @@ test "fssp_parse_header_only" { assert_eq(data.n_alignments(), 0) } +///| test "fssp_parse_filter_after_parse" { let text = @src.fssp_sample_text() let data = @src.fssp_parse(text) @@ -187,6 +196,7 @@ test "fssp_parse_filter_after_parse" { // Formatting // --------------------------------------------------------------------------- +///| test "fssp_header_to_string" { let h = @src.FsspHeader::new( "1dfa_A", "30-jul-1998", "", "", "", "", 25, 3, 2.0, @@ -196,6 +206,7 @@ test "fssp_header_to_string" { assert_true(s.contains("25")) } +///| test "fssp_alignment_to_string" { let a = @src.FsspAlignment::new( "1csa_A", "1csa_A", 1, "ACGT", 12.1, 2.0, 4, 75.0, @@ -206,6 +217,7 @@ test "fssp_alignment_to_string" { assert_true(s.contains("12.1")) } +///| test "fssp_data_to_string" { let text = @src.fssp_sample_text() let data = @src.fssp_parse(text) diff --git a/test/moonbit/ga_test.mbt b/test/moonbit/ga_test.mbt index d1af22e9..32b86b63 100644 --- a/test/moonbit/ga_test.mbt +++ b/test/moonbit/ga_test.mbt @@ -17,9 +17,7 @@ test "ga_individual_creation" { ///| test "ga_individual_default" { - let ind = @src.GAIndividual::new( - sequence="ACGT", - ) + let ind = @src.GAIndividual::new(sequence="ACGT") assert_eq(ind.sequence, "ACGT") assert_true((ind.fitness - 0.0).abs() < 1.0e-10) assert_eq(ind.generation, 0) @@ -32,7 +30,7 @@ test "ga_population_creation" { @src.GAIndividual::new(sequence="CCCC", fitness=0.5, generation=0, id=1), @src.GAIndividual::new(sequence="GGGG", fitness=0.9, generation=0, id=2), ] - let pop = @src.GAPopulation::new(individuals=individuals) + let pop = @src.GAPopulation::new(individuals~) assert_eq(pop.individuals.length(), 3) assert_true((pop.best_fitness - 0.9).abs() < 1.0e-10) assert_true((pop.avg_fitness - 0.7333333333).abs() < 1.0e-10) @@ -110,7 +108,11 @@ test "ga_fitness_gc_content_zero" { test "ga_single_point_crossover" { let parent1 = @src.GAIndividual::new(sequence="AAAA") let parent2 = @src.GAIndividual::new(sequence="CCCC") - let (child1, child2) = @src.ga_single_point_crossover(parent1, parent2, point=2) + let (child1, child2) = @src.ga_single_point_crossover( + parent1, + parent2, + point=2, + ) assert_eq(child1.sequence.length(), 4) assert_eq(child2.sequence.length(), 4) } @@ -179,14 +181,24 @@ test "ga_evolution_loop_improves_fitness" { let fitness_fn = @src.ga_fitness_match(target) let result = @src.ga_evolve(config, fitness_fn) let initial_best = result.best_fitness_history[0] - let final_best = result.best_fitness_history[result.best_fitness_history.length() - 1] + let final_best = result.best_fitness_history[result.best_fitness_history.length() - + 1] assert_true(final_best >= initial_best) } ///| test "ga_result_creation" { - let best = @src.GAIndividual::new(sequence="ACGT", fitness=1.0, generation=10, id=5) - let stats = @src.GAGenerationStats::new(generation=10, best_fitness=1.0, avg_fitness=0.8) + let best = @src.GAIndividual::new( + sequence="ACGT", + fitness=1.0, + generation=10, + id=5, + ) + let stats = @src.GAGenerationStats::new( + generation=10, + best_fitness=1.0, + avg_fitness=0.8, + ) assert_eq(stats.generation, 10) assert_true((stats.best_fitness - 1.0).abs() < 1.0e-10) } @@ -260,4 +272,4 @@ test "ga_termination_threshold" { let fitness_fn = @src.ga_fitness_match(target) let result = @src.ga_evolve(config, fitness_fn) assert_true(result.generation_reached <= 200) -} \ No newline at end of file +} diff --git a/test/moonbit/gck_io_test.mbt b/test/moonbit/gck_io_test.mbt index e0d969b4..6bbf7007 100644 --- a/test/moonbit/gck_io_test.mbt +++ b/test/moonbit/gck_io_test.mbt @@ -33,8 +33,12 @@ test "gck_seq_type_from_int_round_trip" { let dna = @src.GckSeqType::from_int(0) let rna = @src.GckSeqType::from_int(1) let protein = @src.GckSeqType::from_int(2) - assert_true(@src.GckSeqType::from_int(dna.to_int()) is @src.GckSeqType::GckDna) - assert_true(@src.GckSeqType::from_int(rna.to_int()) is @src.GckSeqType::GckRna) + assert_true( + @src.GckSeqType::from_int(dna.to_int()) is @src.GckSeqType::GckDna, + ) + assert_true( + @src.GckSeqType::from_int(rna.to_int()) is @src.GckSeqType::GckRna, + ) assert_true( @src.GckSeqType::from_int(protein.to_int()) is @src.GckSeqType::GckProtein, ) @@ -74,12 +78,9 @@ test "gck_file_new_defaults" { ///| test "gck_feature_new" { - let f = @src.GckFeature::new( - name="AmpR", - type_="CDS", - direction=1, - segments=[(0, 19)], - ) + let f = @src.GckFeature::new(name="AmpR", type_="CDS", direction=1, segments=[ + (0, 19), + ]) assert_eq(f.name, "AmpR") assert_eq(f.type_, "CDS") assert_eq(f.direction, 1) @@ -91,12 +92,11 @@ test "gck_feature_new" { ///| test "gck_feature_new_multiple_segments" { - let f = @src.GckFeature::new( - name="gene1", - type_="CDS", - direction=2, - segments=[(0, 10), (20, 30), (40, 50)], - ) + let f = @src.GckFeature::new(name="gene1", type_="CDS", direction=2, segments=[ + (0, 10), + (20, 30), + (40, 50), + ]) assert_eq(f.name, "gene1") assert_eq(f.direction, 2) assert_eq(f.segments.length(), 3) @@ -140,12 +140,9 @@ test "gck_count_features_by_type_multiple" { @src.GckFeature::new(name="b", type_="CDS", direction=1, segments=[(20, 30)]), ) file.add_feature( - @src.GckFeature::new( - name="c", - type_="promoter", - direction=1, - segments=[(40, 50)], - ), + @src.GckFeature::new(name="c", type_="promoter", direction=1, segments=[ + (40, 50), + ]), ) assert_eq(@src.gck_count_features_by_type(file, "CDS"), 2) assert_eq(@src.gck_count_features_by_type(file, "promoter"), 1) @@ -320,7 +317,9 @@ test "gck_custom_file_round_trip" { file.set_sequence("ATGAAATAG") file.set_circular(false) file.add_feature( - @src.GckFeature::new(name="gene1", type_="CDS", direction=1, segments=[(0, 8)]), + @src.GckFeature::new(name="gene1", type_="CDS", direction=1, segments=[ + (0, 8), + ]), ) let hex = @src.gck_write(file) let parsed = @src.gck_parse(hex) @@ -339,20 +338,14 @@ test "gck_multiple_features_round_trip" { @src.GckFeature::new(name="f1", type_="CDS", direction=1, segments=[(0, 3)]), ) file.add_feature( - @src.GckFeature::new( - name="f2", - type_="promoter", - direction=2, - segments=[(4, 7)], - ), + @src.GckFeature::new(name="f2", type_="promoter", direction=2, segments=[ + (4, 7), + ]), ) file.add_feature( - @src.GckFeature::new( - name="f3", - type_="terminator", - direction=0, - segments=[(8, 11)], - ), + @src.GckFeature::new(name="f3", type_="terminator", direction=0, segments=[ + (8, 11), + ]), ) let hex = @src.gck_write(file) let parsed = @src.gck_parse(hex) @@ -370,12 +363,11 @@ test "gck_multi_segment_feature_round_trip" { let file = @src.GckFile::new() file.set_sequence("ATGCATGCATGC") file.add_feature( - @src.GckFeature::new( - name="gene", - type_="CDS", - direction=1, - segments=[(0, 2), (4, 6), (8, 10)], - ), + @src.GckFeature::new(name="gene", type_="CDS", direction=1, segments=[ + (0, 2), + (4, 6), + (8, 10), + ]), ) let hex = @src.gck_write(file) let parsed = @src.gck_parse(hex) @@ -398,24 +390,15 @@ test "gck_multi_segment_feature_round_trip" { ///| test "gck_feature_direction_values" { - let f1 = @src.GckFeature::new( - name="f1", - type_="CDS", - direction=0, - segments=[(0, 10)], - ) - let f2 = @src.GckFeature::new( - name="f2", - type_="CDS", - direction=1, - segments=[(0, 10)], - ) - let f3 = @src.GckFeature::new( - name="f3", - type_="CDS", - direction=2, - segments=[(0, 10)], - ) + let f1 = @src.GckFeature::new(name="f1", type_="CDS", direction=0, segments=[ + (0, 10), + ]) + let f2 = @src.GckFeature::new(name="f2", type_="CDS", direction=1, segments=[ + (0, 10), + ]) + let f3 = @src.GckFeature::new(name="f3", type_="CDS", direction=2, segments=[ + (0, 10), + ]) assert_eq(f1.direction, 0) assert_eq(f2.direction, 1) assert_eq(f3.direction, 2) diff --git a/test/moonbit/gcrma_test.mbt b/test/moonbit/gcrma_test.mbt index c4bebdac..6e70abd4 100644 --- a/test/moonbit/gcrma_test.mbt +++ b/test/moonbit/gcrma_test.mbt @@ -18,9 +18,7 @@ test "gcrma_probe_info_new" { ///| test "gcrma_probe_info_with_values" { - let probe = @src.ProbeInfo::with_values( - "probe_test", 8, "ACGTACGT", 2.5, - ) + let probe = @src.ProbeInfo::with_values("probe_test", 8, "ACGTACGT", 2.5) assert_eq(probe.probe_id, "probe_test") assert_eq(probe.gc_count, 8) assert_eq(probe.affinity, 2.5) @@ -113,9 +111,7 @@ test "gcrma_compute_gc_lookup_table_basic" { test "gcrma_background_correction_express" { let pm = [100.0, 200.0, 150.0, 300.0] let mm = [50.0, 80.0, 70.0, 120.0] - let result = @src.gcrma_background_correction( - pm, mm, 0.5, "Express", - ) + let result = @src.gcrma_background_correction(pm, mm, 0.5, "Express") assert_eq(result.length(), 4) assert_eq(result[0], 50.0) assert_eq(result[1], 120.0) @@ -125,9 +121,7 @@ test "gcrma_background_correction_express" { test "gcrma_background_correction_express_negative" { let pm = [30.0, 50.0] let mm = [80.0, 100.0] - let result = @src.gcrma_background_correction( - pm, mm, 0.5, "Express", - ) + let result = @src.gcrma_background_correction(pm, mm, 0.5, "Express") assert_eq(result.length(), 2) assert_eq(result[0], 1.0) } @@ -136,18 +130,14 @@ test "gcrma_background_correction_express_negative" { test "gcrma_background_correction_idealm" { let pm = [100.0, 200.0, 150.0, 300.0] let mm = [50.0, 80.0, 70.0, 120.0] - let result = @src.gcrma_background_correction( - pm, mm, 0.5, "IdealMM", - ) + let result = @src.gcrma_background_correction(pm, mm, 0.5, "IdealMM") assert_eq(result.length(), 4) assert_eq(result[0] > 1.0, true) } ///| test "gcrma_background_correction_empty" { - let result = @src.gcrma_background_correction( - [], [], 0.5, "IdealMM", - ) + let result = @src.gcrma_background_correction([], [], 0.5, "IdealMM") assert_eq(result.length(), 0) } @@ -180,11 +170,7 @@ test "gcrma_normalize_single_row" { ///| test "gcrma_normalize_multiple_rows" { - let data = [ - [100.0, 200.0], - [150.0, 250.0], - [120.0, 180.0], - ] + let data = [[100.0, 200.0], [150.0, 250.0], [120.0, 180.0]] let result = @src.gcrma_normalize(data) assert_eq(result.length(), 3) assert_eq(result[0].length(), 2) @@ -269,10 +255,7 @@ test "gcrma_process_empty" { ///| test "gcrma_process_with_config" { - let cel_data = [ - [100.0, 200.0], - [150.0, 250.0], - ] + let cel_data = [[100.0, 200.0], [150.0, 250.0]] let probe_info = [ @src.ProbeInfo::new("p1", "ACGTACGTACGT"), @src.ProbeInfo::new("p2", "GCGCGCGCGCGC"), @@ -285,10 +268,7 @@ test "gcrma_process_with_config" { ///| test "gcrma_process_no_normalize" { - let cel_data = [ - [100.0, 200.0], - [150.0, 250.0], - ] + let cel_data = [[100.0, 200.0], [150.0, 250.0]] let probe_info = [ @src.ProbeInfo::new("p1", "ACGTACGTACGT"), @src.ProbeInfo::new("p2", "GCGCGCGCGCGC"), @@ -302,9 +282,7 @@ test "gcrma_process_no_normalize" { test "gcrma_background_correction_mm_longer_than_pm" { let pm = [100.0, 200.0] let mm = [50.0, 80.0, 90.0] - let result = @src.gcrma_background_correction( - pm, mm, 0.5, "Express", - ) + let result = @src.gcrma_background_correction(pm, mm, 0.5, "Express") assert_eq(result.length(), 2) assert_eq(result[0], 50.0) assert_eq(result[1], 120.0) @@ -314,9 +292,7 @@ test "gcrma_background_correction_mm_longer_than_pm" { test "gcrma_background_correction_mm_shorter_than_pm" { let pm = [100.0, 200.0, 150.0] let mm = [50.0, 80.0] - let result = @src.gcrma_background_correction( - pm, mm, 0.5, "Express", - ) + let result = @src.gcrma_background_correction(pm, mm, 0.5, "Express") assert_eq(result.length(), 3) assert_eq(result[0], 50.0) assert_eq(result[2], 150.0) @@ -326,9 +302,7 @@ test "gcrma_background_correction_mm_shorter_than_pm" { test "gcrma_background_correction_idealm_clamps_to_minimum" { let pm = [10.0, 20.0] let mm = [8.0, 15.0] - let result = @src.gcrma_background_correction( - pm, mm, 0.9, "IdealMM", - ) + let result = @src.gcrma_background_correction(pm, mm, 0.9, "IdealMM") assert_eq(result.length(), 2) assert_eq(result[0] >= 1.0, true) assert_eq(result[1] >= 1.0, true) @@ -386,7 +360,10 @@ test "gcrma_full_pipeline_express" { @src.ProbeInfo::new("p5", "TGTGTGTGTGTG"), @src.ProbeInfo::new("p6", "CGCGCGCGCGCG"), ] - let config = @src.GCRMAConfig::new(background_method="Express", normalize=true) + let config = @src.GCRMAConfig::new( + background_method="Express", + normalize=true, + ) let result = @src.gcrma_process_with_config(cel_data, probe_info, config) assert_eq(result.expression_matrix.length(), 6) assert_eq(result.expression_matrix[0].length(), 2) @@ -412,12 +389,8 @@ test "gcrma_estimate_affinity_dinucleotide" { test "gcrma_background_correction_high_gc" { let pm = [100.0, 200.0, 150.0] let mm = [60.0, 100.0, 80.0] - let result_low = @src.gcrma_background_correction( - pm, mm, 0.2, "IdealMM", - ) - let result_high = @src.gcrma_background_correction( - pm, mm, 0.8, "IdealMM", - ) + let result_low = @src.gcrma_background_correction(pm, mm, 0.2, "IdealMM") + let result_high = @src.gcrma_background_correction(pm, mm, 0.8, "IdealMM") assert_eq(result_low.length(), 3) assert_eq(result_high.length(), 3) } @@ -435,4 +408,4 @@ test "gcrma_gc_correction_preserves_length" { ] let result = @src.gcrma_gc_correction(pm_values, gc_counts, probes) assert_eq(result.length(), 5) -} \ No newline at end of file +} diff --git a/test/moonbit/genefilter_test.mbt b/test/moonbit/genefilter_test.mbt index a0cfc966..9720c5ab 100644 --- a/test/moonbit/genefilter_test.mbt +++ b/test/moonbit/genefilter_test.mbt @@ -6,11 +6,13 @@ test "genefilter_row_ttest" { [5.0, 6.0, 5.5, 7.0, 6.5, 7.5], [100.0, 98.0, 102.0, 50.0, 48.0, 52.0], ] - let groups = ["control", "control", "control", "treatment", "treatment", "treatment"] - + let groups = [ + "control", "control", "control", "treatment", "treatment", "treatment", + ] + let ge = @src.GeneExpression::new(gene_ids, expression, groups) let result = @src.row_ttest(ge, "control", "treatment") - + assert_eq(result.passing_genes.length(), 3) } @@ -22,56 +24,45 @@ test "genefilter_row_wilcoxon" { [10.0, 11.0, 12.0, 1.0, 2.0, 3.0], ] let groups = ["groupA", "groupA", "groupA", "groupB", "groupB", "groupB"] - + let ge = @src.GeneExpression::new(gene_ids, expression, groups) let result = @src.row_wilcoxon(ge, "groupA", "groupB") - + assert_eq(result.passing_genes.length(), 2) } ///| test "genefilter_variance_filter" { let gene_ids = ["gene1", "gene2", "gene3"] - let expression = [ - [1.0, 1.0, 1.0], - [1.0, 2.0, 3.0], - [10.0, 20.0, 30.0], - ] + let expression = [[1.0, 1.0, 1.0], [1.0, 2.0, 3.0], [10.0, 20.0, 30.0]] let groups = ["g1", "g1", "g1"] - + let ge = @src.GeneExpression::new(gene_ids, expression, groups) let passing = @src.variance_filter(ge, 1.0) - + assert_eq(passing.length() >= 2, true) } ///| test "genefilter_cv_filter" { let gene_ids = ["gene1", "gene2"] - let expression = [ - [1.0, 1.0, 1.0], - [1.0, 2.0, 4.0], - ] + let expression = [[1.0, 1.0, 1.0], [1.0, 2.0, 4.0]] let groups = ["g1", "g1", "g1"] - + let ge = @src.GeneExpression::new(gene_ids, expression, groups) let passing = @src.cv_filter(ge, 0.5) - + assert_eq(passing.length() >= 1, true) } ///| test "genefilter_row_quantile_filter" { let gene_ids = ["gene1", "gene2", "gene3"] - let expression = [ - [5.0, 6.0, 7.0], - [1.0, 2.0, 3.0], - [9.0, 10.0, 11.0], - ] + let expression = [[5.0, 6.0, 7.0], [1.0, 2.0, 3.0], [9.0, 10.0, 11.0]] let groups = ["g1", "g1", "g1"] - + let ge = @src.GeneExpression::new(gene_ids, expression, groups) let passing = @src.row_quantile_filter(ge, 0.25, 0.75) - + assert_eq(passing.length() >= 1, true) -} \ No newline at end of file +} diff --git a/test/moonbit/genesis_test.mbt b/test/moonbit/genesis_test.mbt index c69d265d..d135caa5 100644 --- a/test/moonbit/genesis_test.mbt +++ b/test/moonbit/genesis_test.mbt @@ -9,9 +9,9 @@ test "genesis_estimate_kinship" { [1.0, 2.0, 0.0], [2.0, 0.0, 1.0], ] - + let result = @src.bio_estimate_kinship(genotypes) - + assert_true(result.n_samples == 4) assert_true(result.kinship_matrix.length() == 4) assert_true(result.sample_ids.length() == 4) @@ -25,9 +25,9 @@ test "genesis_pca" { [1.0, 2.0, 0.0], [2.0, 0.0, 1.0], ] - + let result = @src.bio_pca(genotypes, 2) - + assert_true(result.eigenvalues.length() == 2) assert_true(result.eigenvectors.length() > 0) assert_true(result.var_explained.length() == 2) @@ -35,14 +35,10 @@ test "genesis_pca" { ///| test "genesis_genetic_distance" { - let genotypes = [ - [0.0, 1.0, 2.0], - [0.0, 1.0, 2.0], - [1.0, 2.0, 0.0], - ] - + let genotypes = [[0.0, 1.0, 2.0], [0.0, 1.0, 2.0], [1.0, 2.0, 0.0]] + let distance = @src.bio_genetic_distance(genotypes) - + assert_true(distance.distance_matrix.length() == 3) assert_true(distance.sample_ids.length() == 3) } @@ -51,9 +47,9 @@ test "genesis_genetic_distance" { test "genesis_euclidean_distance" { let v1 = [0.0, 1.0, 2.0] let v2 = [0.0, 1.0, 2.0] - + let dist = @src.gs_euclidean_distance(v1, v2) - + assert_true(dist == 0.0) } @@ -61,9 +57,9 @@ test "genesis_euclidean_distance" { test "genesis_manhattan_distance" { let v1 = [0.0, 1.0, 2.0] let v2 = [0.0, 1.0, 2.0] - + let dist = @src.gs_manhattan_distance(v1, v2) - + assert_true(dist == 0.0) } @@ -71,8 +67,8 @@ test "genesis_manhattan_distance" { test "genesis_ibs_distance" { let v1 = [0.0, 1.0, 2.0] let v2 = [0.0, 1.0, 2.0] - + let dist = @src.gs_ibs_distance(v1, v2) - + assert_true(dist >= 0.0) } diff --git a/test/moonbit/genie3_test.mbt b/test/moonbit/genie3_test.mbt index bf49e02a..c04cda48 100644 --- a/test/moonbit/genie3_test.mbt +++ b/test/moonbit/genie3_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Bioconductor GENIE3 module - Gene regulatory network inference. - test "genie3_tree_leaf_basic" { let leaf = @src.genie3_tree_leaf(3.5) assert_true(leaf.is_leaf) @@ -10,6 +9,7 @@ test "genie3_tree_leaf_basic" { assert_eq(leaf.right_idx, -1) } +///| test "genie3_tree_split_basic" { let left = @src.genie3_tree_leaf(1.0) let right = @src.genie3_tree_leaf(2.0) @@ -23,6 +23,7 @@ test "genie3_tree_split_basic" { assert_true((node.importance_gain - 10.0).abs() < 1.0e-9) } +///| test "genie3_build_tree_simple" { // Simple dataset: y = 2 * x + noise let features = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]] @@ -36,6 +37,7 @@ test "genie3_build_tree_simple" { assert_true(p1 < p2) } +///| test "genie3_build_tree_constant_target" { // Constant target should produce a single leaf let features = [[1.0], [2.0], [3.0]] @@ -45,6 +47,7 @@ test "genie3_build_tree_constant_target" { assert_true(tree.nodes[0].is_leaf) } +///| test "genie3_feature_importance" { // x0 strongly predicts y, x1 doesn't let features = [ @@ -62,6 +65,7 @@ test "genie3_feature_importance" { assert_true(importance[0] > 0.0) } +///| test "genie3_run_basic" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -75,6 +79,7 @@ test "genie3_run_basic" { assert_true(result.edges.length() > 0) } +///| test "genie3_run_symmetrize" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5, symmetrize=true) @@ -91,6 +96,7 @@ test "genie3_run_symmetrize" { } } +///| test "genie3_column_normalization" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -109,6 +115,7 @@ test "genie3_column_normalization" { } } +///| test "genie3_edges_sorted_descending" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -119,6 +126,7 @@ test "genie3_edges_sorted_descending" { } } +///| test "genie3_top_edges" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -133,6 +141,7 @@ test "genie3_top_edges" { } } +///| test "genie3_top_edges_more_than_available" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -140,6 +149,7 @@ test "genie3_top_edges_more_than_available" { assert_eq(top100.length(), result.edges.length()) } +///| test "genie3_regulators_of" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -158,6 +168,7 @@ test "genie3_regulators_of" { assert_true(found_g1) } +///| test "genie3_targets_of" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -171,6 +182,7 @@ test "genie3_targets_of" { } } +///| test "genie3_regulators_of_unknown_gene" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -178,6 +190,7 @@ test "genie3_regulators_of_unknown_gene" { assert_eq(regs.length(), 0) } +///| test "genie3_sample_data_shape" { let (expr, names) = @src.genie3_sample_data() assert_eq(names.length(), 5) @@ -188,6 +201,7 @@ test "genie3_sample_data_shape" { assert_true((expr[0][0] - expr2[0][0]).abs() < 1.0e-9) } +///| test "genie3_run_no_edges_when_uniform" { // All identical samples → no informative splits → no edges let expr = [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0]] @@ -196,6 +210,7 @@ test "genie3_run_no_edges_when_uniform" { assert_eq(result.edges.length(), 0) } +///| test "genie3_self_loops_excluded" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -207,6 +222,7 @@ test "genie3_self_loops_excluded" { } } +///| test "genie3_predict_after_build" { // Build a tree and verify prediction lies within target range let features = [ diff --git a/test/moonbit/genome_diagram_test.mbt b/test/moonbit/genome_diagram_test.mbt index 3af6e3e3..d0ebbd24 100644 --- a/test/moonbit/genome_diagram_test.mbt +++ b/test/moonbit/genome_diagram_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for GenomeDiagram module. - test "gd_create_diagram - basic creation" { let d = @src.gd_create_diagram("test", 0, 1000) assert_eq(d.name(), "test") @@ -9,6 +8,7 @@ test "gd_create_diagram - basic creation" { assert_eq(@src.gd_diagram_length(d), 1000) } +///| test "gd_create_diagram - negative coordinates" { let d = @src.gd_create_diagram("neg", -100, 200) assert_eq(d.start(), -100) @@ -16,6 +16,7 @@ test "gd_create_diagram - negative coordinates" { assert_eq(@src.gd_diagram_length(d), 300) } +///| test "gd_add_track - single track" { let d = @src.gd_create_diagram("test", 0, 500) let d2 = @src.gd_add_track(d, "genes") @@ -24,6 +25,7 @@ test "gd_add_track - single track" { assert_eq(tracks[0].name(), "genes") } +///| test "gd_add_track - multiple tracks" { let d = @src.gd_create_diagram("test", 0, 1000) let d2 = @src.gd_add_track(d, "genes") @@ -32,9 +34,17 @@ test "gd_add_track - multiple tracks" { assert_eq(@src.gd_track_count(d4), 3) } +///| test "gd_add_feature - basic feature" { let d = @src.gd_create_diagram("test", 0, 1000) - let d2 = @src.gd_add_feature(d, 100, 300, "+", "GeneA", @src.gd_rectangle_shape()) + let d2 = @src.gd_add_feature( + d, + 100, + 300, + "+", + "GeneA", + @src.gd_rectangle_shape(), + ) assert_eq(@src.gd_feature_count(d2), 1) let feats = d2.features() assert_eq(feats[0].start(), 100) @@ -43,14 +53,30 @@ test "gd_add_feature - basic feature" { assert_eq(feats[0].label(), "GeneA") } +///| test "gd_add_feature - multiple features" { let d = @src.gd_create_diagram("test", 0, 1000) let d2 = @src.gd_add_feature(d, 50, 150, "+", "Gene1", @src.gd_arrow_shape()) - let d3 = @src.gd_add_feature(d2, 200, 400, "-", "Gene2", @src.gd_diamond_shape()) - let d4 = @src.gd_add_feature(d3, 500, 800, "+", "Gene3", @src.gd_rectangle_shape()) + let d3 = @src.gd_add_feature( + d2, + 200, + 400, + "-", + "Gene2", + @src.gd_diamond_shape(), + ) + let d4 = @src.gd_add_feature( + d3, + 500, + 800, + "+", + "Gene3", + @src.gd_rectangle_shape(), + ) assert_eq(@src.gd_feature_count(d4), 3) } +///| test "gd_add_track_feature - basic track feature" { let d = @src.gd_create_diagram("test", 0, 1000) let d2 = @src.gd_add_track(d, "genes") @@ -62,6 +88,7 @@ test "gd_add_track_feature - basic track feature" { assert_eq(feats[0].label(), "GeneA") } +///| test "gd_add_track_feature - multiple features in same track" { let d = @src.gd_create_diagram("test", 0, 1000) let d2 = @src.gd_add_track(d, "genes") @@ -72,6 +99,7 @@ test "gd_add_track_feature - multiple features in same track" { assert_eq(feats.length(), 3) } +///| test "gd_add_track_feature - multiple tracks" { let d = @src.gd_create_diagram("test", 0, 1000) let d2 = @src.gd_add_track(d, "genes") @@ -86,36 +114,83 @@ test "gd_add_track_feature - multiple tracks" { assert_eq(exon_feats.length(), 1) } +///| test "gd_get_features - nonexistent track returns empty" { let d = @src.gd_create_diagram("test", 0, 1000) let feats = @src.gd_get_features(d, "nonexistent") assert_eq(feats.length(), 0) } +///| test "gd_find_overlapping_features - basic overlap" { let d = @src.gd_create_diagram("test", 0, 1000) - let d2 = @src.gd_add_feature(d, 100, 300, "+", "GeneA", @src.gd_rectangle_shape()) - let d3 = @src.gd_add_feature(d2, 400, 600, "+", "GeneB", @src.gd_rectangle_shape()) - let d4 = @src.gd_add_feature(d3, 250, 500, "+", "GeneC", @src.gd_rectangle_shape()) + let d2 = @src.gd_add_feature( + d, + 100, + 300, + "+", + "GeneA", + @src.gd_rectangle_shape(), + ) + let d3 = @src.gd_add_feature( + d2, + 400, + 600, + "+", + "GeneB", + @src.gd_rectangle_shape(), + ) + let d4 = @src.gd_add_feature( + d3, + 250, + 500, + "+", + "GeneC", + @src.gd_rectangle_shape(), + ) let overlaps = @src.gd_find_overlapping_features(d4, 200, 400) assert_eq(overlaps.length(), 2) } +///| test "gd_find_overlapping_features - no overlap" { let d = @src.gd_create_diagram("test", 0, 1000) - let d2 = @src.gd_add_feature(d, 100, 200, "+", "GeneA", @src.gd_rectangle_shape()) - let d3 = @src.gd_add_feature(d2, 500, 600, "+", "GeneB", @src.gd_rectangle_shape()) + let d2 = @src.gd_add_feature( + d, + 100, + 200, + "+", + "GeneA", + @src.gd_rectangle_shape(), + ) + let d3 = @src.gd_add_feature( + d2, + 500, + 600, + "+", + "GeneB", + @src.gd_rectangle_shape(), + ) let overlaps = @src.gd_find_overlapping_features(d3, 300, 400) assert_eq(overlaps.length(), 0) } +///| test "gd_find_overlapping_features - edge touching" { let d = @src.gd_create_diagram("test", 0, 1000) - let d2 = @src.gd_add_feature(d, 100, 200, "+", "GeneA", @src.gd_rectangle_shape()) + let d2 = @src.gd_add_feature( + d, + 100, + 200, + "+", + "GeneA", + @src.gd_rectangle_shape(), + ) let overlaps = @src.gd_find_overlapping_features(d2, 200, 300) assert_eq(overlaps.length(), 0) } +///| test "gd_set_style - basic style" { let d = @src.gd_create_diagram("test", 0, 1000) let style = @src.DiagramStyle::new() @@ -125,6 +200,7 @@ test "gd_set_style - basic style" { assert_true(d2.style().border()) } +///| test "gd_set_style - circular mode" { let d = @src.gd_create_diagram("test", 0, 1000) let style = @src.DiagramStyle::new(circular=true, linear=false) @@ -133,6 +209,7 @@ test "gd_set_style - circular mode" { assert_false(d2.style().linear()) } +///| test "gd_diagram_length - different ranges" { let d1 = @src.gd_create_diagram("a", 0, 500) assert_eq(@src.gd_diagram_length(d1), 500) @@ -142,24 +219,41 @@ test "gd_diagram_length - different ranges" { assert_eq(@src.gd_diagram_length(d3), 100) } +///| test "gd_track_count - empty diagram" { let d = @src.gd_create_diagram("test", 0, 100) assert_eq(@src.gd_track_count(d), 0) } +///| test "gd_feature_count - mixed features" { let d = @src.gd_create_diagram("test", 0, 500) let d2 = @src.gd_add_track(d, "genes") - let d3 = @src.gd_add_feature(d2, 50, 150, "+", "G1", @src.gd_rectangle_shape()) + let d3 = @src.gd_add_feature( + d2, + 50, + 150, + "+", + "G1", + @src.gd_rectangle_shape(), + ) let d4 = @src.gd_add_track_feature(d3, "genes", 100, 200, "+", "G2") let d5 = @src.gd_add_feature(d4, 300, 400, "-", "G3", @src.gd_arrow_shape()) assert_eq(@src.gd_feature_count(d5), 3) } +///| test "gd_to_svg_string - generates valid SVG" { let d = @src.gd_create_diagram("test", 0, 500) let d2 = @src.gd_add_track(d, "genes") - let d3 = @src.gd_add_feature(d2, 50, 150, "+", "GeneA", @src.gd_rectangle_shape()) + let d3 = @src.gd_add_feature( + d2, + 50, + 150, + "+", + "GeneA", + @src.gd_rectangle_shape(), + ) let d4 = @src.gd_add_track_feature(d3, "genes", 200, 300, "+", "Exon1") let svg = @src.gd_to_svg_string(d4, 800, 400) assert_true(svg.length() > 0) @@ -167,19 +261,29 @@ test "gd_to_svg_string - generates valid SVG" { assert_true(svg.contains("")) } +///| test "gd_to_svg_string - empty diagram" { let d = @src.gd_create_diagram("empty", 0, 0) let svg = @src.gd_to_svg_string(d, 400, 200) assert_eq(svg, "") } +///| test "gd_to_svg_string - contains feature labels" { let d = @src.gd_create_diagram("test", 0, 500) - let d2 = @src.gd_add_feature(d, 100, 200, "+", "MyGene", @src.gd_rectangle_shape()) + let d2 = @src.gd_add_feature( + d, + 100, + 200, + "+", + "MyGene", + @src.gd_rectangle_shape(), + ) let svg = @src.gd_to_svg_string(d2, 800, 400) assert_true(svg.contains("MyGene")) } +///| test "gd_set_feature_color - changes color" { let feat = @src.DiagramFeature::new(0, 100, color="#FF0000") let updated = @src.gd_set_feature_color(feat, "#00FF00") @@ -187,12 +291,19 @@ test "gd_set_feature_color - changes color" { assert_eq(feat.color(), "#FF0000") } +///| test "gd_set_feature_color - shape preserved" { - let feat = @src.DiagramFeature::new(0, 100, shape=@src.gd_arrow_shape(), color="#FF0000") + let feat = @src.DiagramFeature::new( + 0, + 100, + shape=@src.gd_arrow_shape(), + color="#FF0000", + ) let updated = @src.gd_set_feature_color(feat, "#00FF00") assert_eq(updated.shape().to_string(), "arrow") } +///| test "gd_label_features - auto labels large features" { let d = @src.gd_create_diagram("test", 0, 1000) let d2 = @src.gd_add_feature(d, 100, 300, "+", "", @src.gd_rectangle_shape()) @@ -203,14 +314,23 @@ test "gd_label_features - auto labels large features" { assert_eq(feats[1].label(), "") } +///| test "gd_label_features - existing labels preserved" { let d = @src.gd_create_diagram("test", 0, 1000) - let d2 = @src.gd_add_feature(d, 100, 300, "+", "Existing", @src.gd_rectangle_shape()) + let d2 = @src.gd_add_feature( + d, + 100, + 300, + "+", + "Existing", + @src.gd_rectangle_shape(), + ) let d3 = @src.gd_label_features(d2, 50) let feats = d3.features() assert_eq(feats[0].label(), "Existing") } +///| test "FeatureShape - to_string conversions" { let r = @src.gd_rectangle_shape() assert_eq(r.to_string(), "rectangle") @@ -224,6 +344,7 @@ test "FeatureShape - to_string conversions" { assert_eq(t.to_string(), "terminators") } +///| test "FeatureShape - from_string conversions" { let r = @src.FeatureShape::from_string("rectangle") assert_eq(r.to_string(), "rectangle") @@ -235,6 +356,7 @@ test "FeatureShape - from_string conversions" { assert_eq(u.to_string(), "rectangle") } +///| test "DiagramStyle - default values" { let style = @src.DiagramStyle::new() assert_eq(style.scale(), 1.0) @@ -244,6 +366,7 @@ test "DiagramStyle - default values" { assert_eq(style.color_scheme(), "default") } +///| test "DiagramStyle - setters" { let style = @src.DiagramStyle::new() let s2 = style.set_scale(2.5) @@ -254,6 +377,7 @@ test "DiagramStyle - setters" { assert_eq(s4.color_scheme(), "grayscale") } +///| test "DiagramStyle - circular and linear are mutually exclusive" { let style = @src.DiagramStyle::new() let circ = style.set_circular(true) @@ -264,6 +388,7 @@ test "DiagramStyle - circular and linear are mutually exclusive" { assert_true(lin.linear()) } +///| test "DiagramFeature - overlaps detection" { let feat = @src.DiagramFeature::new(100, 300) assert_true(feat.overlaps(50, 150)) @@ -273,16 +398,19 @@ test "DiagramFeature - overlaps detection" { assert_false(feat.overlaps(0, 100)) } +///| test "DiagramFeature - length" { let feat = @src.DiagramFeature::new(100, 300) assert_eq(feat.length(), 200) } +///| test "TrackFeature - length" { let feat = @src.TrackFeature::new(50, 150) assert_eq(feat.length(), 100) } +///| test "Track - feature operations" { let t = @src.Track::new("test_track") assert_eq(t.name(), "test_track") @@ -295,13 +423,22 @@ test "Track - feature operations" { assert_eq(t3.feature_count(), 2) } +///| test "gd_feature_count - diagram features only" { let d = @src.gd_create_diagram("test", 0, 1000) let d2 = @src.gd_add_feature(d, 50, 100, "+", "F1", @src.gd_rectangle_shape()) - let d3 = @src.gd_add_feature(d2, 200, 300, "+", "F2", @src.gd_rectangle_shape()) + let d3 = @src.gd_add_feature( + d2, + 200, + 300, + "+", + "F2", + @src.gd_rectangle_shape(), + ) assert_eq(@src.gd_feature_count(d3), 2) } +///| test "gd_to_svg_string - contains track names" { let d = @src.gd_create_diagram("test", 0, 500) let d2 = @src.gd_add_track(d, "MyTrack") @@ -310,6 +447,7 @@ test "gd_to_svg_string - contains track names" { assert_true(svg.contains("MyTrack")) } +///| test "gd_to_svg_string - border toggle" { let d = @src.gd_create_diagram("test", 0, 500) let style = @src.DiagramStyle::new(border=false) @@ -318,6 +456,7 @@ test "gd_to_svg_string - border toggle" { assert_true(svg.contains(" { @@ -240,6 +241,7 @@ test "gfa_parse_tag valid LN:i:100" { } } +///| test "gfa_parse_tag valid VN:Z:1.0" { match @src.gfa_parse_tag("VN:Z:1.0") { Some(t) => { @@ -251,6 +253,7 @@ test "gfa_parse_tag valid VN:Z:1.0" { } } +///| test "gfa_parse_tag invalid bad (no colons)" { match @src.gfa_parse_tag("bad") { Some(_) => assert_true(false) @@ -258,6 +261,7 @@ test "gfa_parse_tag invalid bad (no colons)" { } } +///| test "gfa_parse_tag missing type (one colon)" { match @src.gfa_parse_tag("LN:100") { Some(_) => assert_true(false) @@ -265,6 +269,7 @@ test "gfa_parse_tag missing type (one colon)" { } } +///| test "gfa_parse_tag empty string" { match @src.gfa_parse_tag("") { Some(_) => assert_true(false) @@ -272,6 +277,7 @@ test "gfa_parse_tag empty string" { } } +///| test "gfa_parse_tag with value containing colon" { // The value itself may legally contain ':' (e.g. JSON-style). The parser // splits on the first two colons only. @@ -289,6 +295,7 @@ test "gfa_parse_tag with value containing colon" { // 8. gfa_parse - full GFA document with H, S, L, P lines // ============================================================================ +///| test "gfa_parse full document" { let content = "H\tVN:Z:1.0\nS\tseq1\tACGTACGT\tLN:i:8\nS\tseq2\tTTTTGGGG\tLN:i:8\nL\tseq1\t+\tseq2\t-\t8M\nP\tpath1\tseq1+,seq2-\t8M,4M\n" let graph = @src.gfa_parse(content) @@ -315,6 +322,7 @@ test "gfa_parse full document" { assert_eq(graph.paths()[0].overlaps().length(), 2) } +///| test "gfa_parse handles CRLF line endings" { let content = "H\tVN:Z:1.0\r\nS\tseq1\tACGT\r\n" let graph = @src.gfa_parse(content) @@ -325,6 +333,7 @@ test "gfa_parse handles CRLF line endings" { assert_eq(graph.segments()[0].sequence(), "ACGT") } +///| test "gfa_parse skips blank and unknown lines" { let content = "\nH\tVN:Z:1.0\nX\tunknown\n\nS\tseq1\tACGT\n" let graph = @src.gfa_parse(content) @@ -333,6 +342,7 @@ test "gfa_parse skips blank and unknown lines" { assert_eq(graph.segments()[0].name(), "seq1") } +///| test "gfa_parse_containment" { let fields = ["C", "seq1", "+", "seq2", "+", "5", "8M"] let cont = @src.gfa_parse_containment(fields) @@ -346,6 +356,7 @@ test "gfa_parse_containment" { // 9. gfa_to_string round-trip // ============================================================================ +///| test "gfa_to_string round-trip preserves data" { let content = "H\tVN:Z:1.0\nS\tseq1\tACGTACGT\tLN:i:8\nS\tseq2\tTTTTGGGG\tLN:i:8\nL\tseq1\t+\tseq2\t-\t8M\nP\tpath1\tseq1+,seq2-\t8M,4M\n" let graph1 = @src.gfa_parse(content) @@ -366,6 +377,7 @@ test "gfa_to_string round-trip preserves data" { assert_eq(graph2.paths()[0].overlaps()[1], "4M") } +///| test "gfa_to_string matches expected lines" { let content = "H\tVN:Z:1.0\nS\tseq1\tACGT\tLN:i:4\nL\tseq1\t+\tseq2\t-\t8M\nP\tp1\tseq1+,seq2-\t8M,4M\n" let graph = @src.gfa_parse(content) @@ -380,71 +392,60 @@ test "gfa_to_string matches expected lines" { // Per-record serializers // ============================================================================ +///| test "gfa_header_to_line" { - let header = @src.GfaHeader::new( - "1.0", - [@src.GfaTag::new("VN", "Z", "1.0")], - ) + let header = @src.GfaHeader::new("1.0", [@src.GfaTag::new("VN", "Z", "1.0")]) assert_eq(@src.gfa_header_to_line(header), "H\tVN:Z:1.0") } +///| test "gfa_header_to_line multiple tags" { - let header = @src.GfaHeader::new( - "1.0", - [ - @src.GfaTag::new("VN", "Z", "1.0"), - @src.GfaTag::new("OR", "Z", "sample"), - ], - ) + let header = @src.GfaHeader::new("1.0", [ + @src.GfaTag::new("VN", "Z", "1.0"), + @src.GfaTag::new("OR", "Z", "sample"), + ]) assert_eq(@src.gfa_header_to_line(header), "H\tVN:Z:1.0\tOR:Z:sample") } +///| test "gfa_segment_to_line" { - let seg = @src.GfaSegment::new( - "seq1", - "ACGT", - [@src.GfaTag::new("LN", "i", "4")], - ) + let seg = @src.GfaSegment::new("seq1", "ACGT", [ + @src.GfaTag::new("LN", "i", "4"), + ]) assert_eq(@src.gfa_segment_to_line(seg), "S\tseq1\tACGT\tLN:i:4") } +///| test "gfa_segment_to_line no tags" { let seg = @src.GfaSegment::new("seq2", "TTTT", []) assert_eq(@src.gfa_segment_to_line(seg), "S\tseq2\tTTTT") } +///| test "gfa_link_to_line" { let link = @src.GfaLink::new("seq1", "+", "seq2", "-", "8M", []) assert_eq(@src.gfa_link_to_line(link), "L\tseq1\t+\tseq2\t-\t8M") } +///| test "gfa_link_to_line with tag" { - let link = @src.GfaLink::new( - "a", - "+", - "b", - "+", - "4M", - [@src.GfaTag::new("MQ", "i", "60")], - ) + let link = @src.GfaLink::new("a", "+", "b", "+", "4M", [ + @src.GfaTag::new("MQ", "i", "60"), + ]) assert_eq(@src.gfa_link_to_line(link), "L\ta\t+\tb\t+\t4M\tMQ:i:60") } +///| test "gfa_path_to_line" { let path = @src.GfaPath::new("p1", ["seq1+", "seq2-"], ["8M", "4M"], []) assert_eq(@src.gfa_path_to_line(path), "P\tp1\tseq1+,seq2-\t8M,4M") } +///| test "gfa_containment_to_line" { - let cont = @src.GfaContainment::new( - "seq1", - "+", - "seq2", - "+", - 5, - "8M", - [@src.GfaTag::new("MQ", "i", "60")], - ) + let cont = @src.GfaContainment::new("seq1", "+", "seq2", "+", 5, "8M", [ + @src.GfaTag::new("MQ", "i", "60"), + ]) assert_eq( @src.gfa_containment_to_line(cont), "C\tseq1\t+\tseq2\t+\t5\t8M\tMQ:i:60", @@ -455,6 +456,7 @@ test "gfa_containment_to_line" { // Per-record parsers // ============================================================================ +///| test "gfa_parse_header extracts version" { let fields = ["H", "VN:Z:1.0"] let header = @src.gfa_parse_header(fields) @@ -462,6 +464,7 @@ test "gfa_parse_header extracts version" { assert_eq(header.tags().length(), 1) } +///| test "gfa_parse_segment fields" { let fields = ["S", "seq1", "ACGTACGT", "LN:i:8"] let seg = @src.gfa_parse_segment(fields) @@ -472,6 +475,7 @@ test "gfa_parse_segment fields" { assert_eq(seg.tags()[0].value(), "8") } +///| test "gfa_parse_segment defaults sequence to *" { let fields = ["S", "seq1"] let seg = @src.gfa_parse_segment(fields) @@ -480,6 +484,7 @@ test "gfa_parse_segment defaults sequence to *" { assert_eq(seg.tags().length(), 0) } +///| test "gfa_parse_link fields" { let fields = ["L", "seq1", "+", "seq2", "-", "8M"] let link = @src.gfa_parse_link(fields) @@ -490,6 +495,7 @@ test "gfa_parse_link fields" { assert_eq(link.overlap(), "8M") } +///| test "gfa_parse_path fields" { let fields = ["P", "path1", "seq1+,seq2-", "8M,4M"] let path = @src.gfa_parse_path(fields) @@ -506,6 +512,7 @@ test "gfa_parse_path fields" { // 10. gfa_graph_n_segments / n_links / n_paths // ============================================================================ +///| test "gfa_graph_n_segments/links/paths on sample" { let graph = @src.gfa_sample_graph() assert_eq(@src.gfa_graph_n_segments(graph), 3) @@ -513,6 +520,7 @@ test "gfa_graph_n_segments/links/paths on sample" { assert_eq(@src.gfa_graph_n_paths(graph), 1) } +///| test "gfa_graph_n_segments/links/paths on empty" { let graph = @src.GfaGraph::new() assert_eq(@src.gfa_graph_n_segments(graph), 0) @@ -524,6 +532,7 @@ test "gfa_graph_n_segments/links/paths on empty" { // 11. gfa_get_segment - found and not found // ============================================================================ +///| test "gfa_get_segment found" { let graph = @src.gfa_sample_graph() match @src.gfa_get_segment(graph, "seq2") { @@ -535,6 +544,7 @@ test "gfa_get_segment found" { } } +///| test "gfa_get_segment found first" { let graph = @src.gfa_sample_graph() match @src.gfa_get_segment(graph, "seq1") { @@ -543,6 +553,7 @@ test "gfa_get_segment found first" { } } +///| test "gfa_get_segment not found" { let graph = @src.gfa_sample_graph() match @src.gfa_get_segment(graph, "missing") { @@ -551,6 +562,7 @@ test "gfa_get_segment not found" { } } +///| test "gfa_get_segment on empty graph" { let graph = @src.GfaGraph::new() match @src.gfa_get_segment(graph, "anything") { @@ -563,6 +575,7 @@ test "gfa_get_segment on empty graph" { // 12. gfa_get_segments_as_records - convert to SeqRecord array // ============================================================================ +///| test "gfa_get_segments_as_records sample graph" { let graph = @src.gfa_sample_graph() let records = @src.gfa_get_segments_as_records(graph) @@ -577,12 +590,14 @@ test "gfa_get_segments_as_records sample graph" { assert_eq(records[2].seq.to_string(), "CCCCAAAA") } +///| test "gfa_get_segments_as_records empty graph" { let graph = @src.GfaGraph::new() let records = @src.gfa_get_segments_as_records(graph) assert_eq(records.length(), 0) } +///| test "gfa_get_segments_as_records star sequence becomes empty" { let graph = @src.GfaGraph::new() graph.add_segment(@src.GfaSegment::new("masked", "*", [])) @@ -596,15 +611,11 @@ test "gfa_get_segments_as_records star sequence becomes empty" { // 13. gfa_reverse_link - from/to swapped, orientations swapped // ============================================================================ +///| test "gfa_reverse_link swaps segments and orientations" { - let link = @src.GfaLink::new( - "seq1", - "+", - "seq2", - "-", - "8M", - [@src.GfaTag::new("MQ", "i", "60")], - ) + let link = @src.GfaLink::new("seq1", "+", "seq2", "-", "8M", [ + @src.GfaTag::new("MQ", "i", "60"), + ]) let rev = @src.gfa_reverse_link(link) assert_eq(rev.from_segment(), "seq2") assert_eq(rev.from_orient(), "-") @@ -615,6 +626,7 @@ test "gfa_reverse_link swaps segments and orientations" { assert_eq(rev.tags()[0].name(), "MQ") } +///| test "gfa_reverse_link double-reverse is identity" { let link = @src.GfaLink::new("a", "+", "b", "-", "4M", []) let rev2 = @src.gfa_reverse_link(@src.gfa_reverse_link(link)) @@ -625,18 +637,12 @@ test "gfa_reverse_link double-reverse is identity" { assert_eq(rev2.overlap(), "4M") } +///| test "gfa_reverse_link preserves tags" { - let link = @src.GfaLink::new( - "x", - "+", - "y", - "+", - "0M", - [ - @src.GfaTag::new("MQ", "i", "40"), - @src.GfaTag::new("NM", "i", "0"), - ], - ) + let link = @src.GfaLink::new("x", "+", "y", "+", "0M", [ + @src.GfaTag::new("MQ", "i", "40"), + @src.GfaTag::new("NM", "i", "0"), + ]) let rev = @src.gfa_reverse_link(link) assert_eq(rev.tags().length(), 2) assert_eq(rev.tags()[0].name(), "MQ") @@ -647,6 +653,7 @@ test "gfa_reverse_link preserves tags" { // 14. gfa_graph_summary - non-empty string // ============================================================================ +///| test "gfa_graph_summary non-empty on sample" { let graph = @src.gfa_sample_graph() let summary = @src.gfa_graph_summary(graph) @@ -658,6 +665,7 @@ test "gfa_graph_summary non-empty on sample" { assert_true(summary.contains("total_sequence_length=24")) } +///| test "gfa_graph_summary on empty graph" { let graph = @src.GfaGraph::new() let summary = @src.gfa_graph_summary(graph) @@ -668,6 +676,7 @@ test "gfa_graph_summary on empty graph" { assert_true(summary.contains("total_sequence_length=0")) } +///| test "gfa_graph_summary ignores star sequences" { let graph = @src.GfaGraph::new() graph.add_segment(@src.GfaSegment::new("a", "ACGT", [])) @@ -681,6 +690,7 @@ test "gfa_graph_summary ignores star sequences" { // 15. Sample graph validation // ============================================================================ +///| test "gfa_sample_graph structure" { let graph = @src.gfa_sample_graph() assert_eq(graph.headers().length(), 1) @@ -691,6 +701,7 @@ test "gfa_sample_graph structure" { assert_eq(graph.containments().length(), 0) } +///| test "gfa_sample_graph segments" { let graph = @src.gfa_sample_graph() assert_eq(graph.segments()[0].name(), "seq1") @@ -704,6 +715,7 @@ test "gfa_sample_graph segments" { assert_eq(graph.segments()[0].tags()[0].value(), "8") } +///| test "gfa_sample_graph links" { let graph = @src.gfa_sample_graph() let l0 = graph.links()[0] @@ -716,6 +728,7 @@ test "gfa_sample_graph links" { assert_eq(l1.overlap(), "4M") } +///| test "gfa_sample_graph path" { let graph = @src.gfa_sample_graph() let p = graph.paths()[0] @@ -727,6 +740,7 @@ test "gfa_sample_graph path" { assert_eq(p.overlaps().length(), 2) } +///| test "gfa_sample_graph round-trips through gfa_to_string" { let graph = @src.gfa_sample_graph() let text = @src.gfa_to_string(graph) @@ -741,12 +755,14 @@ test "gfa_sample_graph round-trips through gfa_to_string" { // 16. Edge cases - empty graph, single segment, no links // ============================================================================ +///| test "edge case: empty graph serializes to empty string" { let graph = @src.GfaGraph::new() let s = @src.gfa_to_string(graph) assert_eq(s, "") } +///| test "edge case: parse empty content" { let graph = @src.gfa_parse("") assert_eq(@src.gfa_graph_n_segments(graph), 0) @@ -754,6 +770,7 @@ test "edge case: parse empty content" { assert_eq(@src.gfa_graph_n_paths(graph), 0) } +///| test "edge case: single segment, no links" { let graph = @src.GfaGraph::new() graph.add_segment(@src.GfaSegment::new("only", "ACGT", [])) @@ -764,6 +781,7 @@ test "edge case: single segment, no links" { assert_eq(out, "S\tonly\tACGT\n") } +///| test "edge case: single segment round-trip" { let graph = @src.GfaGraph::new() graph.add_segment(@src.GfaSegment::new("only", "ACGT", [])) @@ -774,6 +792,7 @@ test "edge case: single segment round-trip" { assert_eq(reparsed.segments()[0].sequence(), "ACGT") } +///| test "edge case: segment with star sequence" { let content = "S\tseq1\t*\tLN:i:100\n" let graph = @src.gfa_parse(content) @@ -782,6 +801,7 @@ test "edge case: segment with star sequence" { assert_eq(graph.segments()[0].tags()[0].name(), "LN") } +///| test "edge case: only headers" { let content = "H\tVN:Z:1.0\nH\tOR:Z:test\n" let graph = @src.gfa_parse(content) @@ -789,6 +809,7 @@ test "edge case: only headers" { assert_eq(@src.gfa_graph_n_segments(graph), 0) } +///| test "edge case: unknown record type ignored" { let content = "H\tVN:Z:1.0\nZ\tunknown\tfield\nS\tseq1\tACGT\n" let graph = @src.gfa_parse(content) diff --git a/test/moonbit/gff_test.mbt b/test/moonbit/gff_test.mbt index 4def9b1f..bf869e37 100644 --- a/test/moonbit/gff_test.mbt +++ b/test/moonbit/gff_test.mbt @@ -1,6 +1,5 @@ ///| /// GFF module tests - test "GFFFeature::new" { let feature = @src.GFFFeature::new("chr1", "Ensembl", "gene", 1000, 2000, "+") assert_eq(feature.seqid, "chr1") @@ -9,6 +8,7 @@ test "GFFFeature::new" { assert_eq(feature.end, 2000) } +///| test "GFFFeature::add_attribute" { let feature = @src.GFFFeature::new("chr1", "Ensembl", "gene", 1000, 2000, "+") .add_attribute("ID", "gene001") @@ -19,20 +19,24 @@ test "GFFFeature::add_attribute" { } } +///| test "GFFFeature::get_id" { - let feature = @src.GFFFeature::new("chr1", "Ensembl", "gene", 1000, 2000, "+") - .add_attribute("ID", "gene001") + let feature = @src.GFFFeature::new("chr1", "Ensembl", "gene", 1000, 2000, "+").add_attribute( + "ID", "gene001", + ) match feature.get_id() { Some(id) => assert_eq(id, "gene001") None => assert_true(false) } } +///| test "GFFFeature::length" { let feature = @src.GFFFeature::new("chr1", "Ensembl", "gene", 1000, 2000, "+") assert_eq(feature.length(), 1001) } +///| test "GFFFeature::is_coding" { let gene = @src.GFFFeature::new("chr1", "Ensembl", "gene", 1000, 2000, "+") assert_true(gene.is_coding()) @@ -40,11 +44,13 @@ test "GFFFeature::is_coding" { assert_true(cds.is_coding()) } +///| test "GFFRecord::new" { let record = @src.GFFRecord::new() assert_eq(record.count_features(), 0) } +///| test "GFFRecord::add_feature" { let record = @src.GFFRecord::new() let feature = @src.GFFFeature::new("chr1", "Ensembl", "gene", 1000, 2000, "+") @@ -52,18 +58,21 @@ test "GFFRecord::add_feature" { assert_eq(record.count_features(), 1) } +///| test "GFFRecord::get_features_by_type" { let record = @src.create_example_gff() let genes = record.get_genes() assert_true(genes.length() >= 1) } +///| test "GFFRecord::get_features_by_seqid" { let record = @src.create_example_gff() let features = record.get_features_by_seqid("chr1") assert_true(features.length() > 0) } +///| test "parse_gff" { let content = "##gff-version 3\nchr1\tEnsembl\tgene\t1000\t2000\t.\t+\t.\tID=gene001;Name=TP53\n" let record = @src.bio_parse_gff(content) @@ -71,8 +80,11 @@ test "parse_gff" { assert_eq(record.version, "3") } +///| test "parse_attributes" { - let attrs = @src.parse_attributes("ID=gene001;Name=TP53;biotype=protein_coding") + let attrs = @src.parse_attributes( + "ID=gene001;Name=TP53;biotype=protein_coding", + ) match attrs.get("ID") { Some(id) => assert_eq(id, "gene001") None => assert_true(false) @@ -83,6 +95,7 @@ test "parse_attributes" { } } +///| test "parse_attributes_unescape" { let attrs = @src.parse_attributes("ID=gene001;Name=value%3Bwith%3Bsemicolons") match attrs.get("Name") { @@ -91,25 +104,29 @@ test "parse_attributes_unescape" { } } +///| test "create_example_gff" { let record = @src.create_example_gff() assert_true(record.count_features() > 5) } +///| test "GFFRecord::get_child_features" { let record = @src.create_example_gff() let mrnas = record.get_child_features("gene:ENSG00000130203") assert_true(mrnas.length() >= 1) } +///| test "GFFRecord::get_unique_seqids" { let record = @src.create_example_gff() let seqids = record.get_unique_seqids() assert_true(seqids.length() >= 1) } +///| test "GFFRecord::get_features_in_range" { let record = @src.create_example_gff() let features = record.get_features_in_range("chr1", 10000, 11000) assert_true(features.length() > 0) -} \ No newline at end of file +} diff --git a/test/moonbit/ggtree_test.mbt b/test/moonbit/ggtree_test.mbt index 55834325..deabca30 100644 --- a/test/moonbit/ggtree_test.mbt +++ b/test/moonbit/ggtree_test.mbt @@ -32,8 +32,12 @@ test "ggtree_count_leaves" { test "ggtree_y_positions" { let nodes = @src.create_test_tree() let root = nodes[0] - let n_nodes = @src.ggtree_count_leaves(root) + @src.ggtree_collect_internal_ids(root).length() - let positions : Map[String, (Double, Double, Double)] = Map([], capacity=n_nodes) + let n_nodes = @src.ggtree_count_leaves(root) + + @src.ggtree_collect_internal_ids(root).length() + let positions : Map[String, (Double, Double, Double)] = Map( + [], + capacity=n_nodes, + ) let _ = @src.ggtree_compute_y_positions(root, 0.0, positions) // Root should have a y coordinate @@ -52,8 +56,12 @@ test "ggtree_y_positions" { test "ggtree_x_positions" { let nodes = @src.create_test_tree() let root = nodes[0] - let n_nodes = @src.ggtree_count_leaves(root) + @src.ggtree_collect_internal_ids(root).length() - let positions : Map[String, (Double, Double, Double)] = Map([], capacity=n_nodes) + let n_nodes = @src.ggtree_count_leaves(root) + + @src.ggtree_collect_internal_ids(root).length() + let positions : Map[String, (Double, Double, Double)] = Map( + [], + capacity=n_nodes, + ) let _ = @src.ggtree_compute_y_positions(root, 0.0, positions) @src.ggtree_compute_x_positions(root, 0.0, positions) diff --git a/test/moonbit/glm_gampoi_test.mbt b/test/moonbit/glm_gampoi_test.mbt index 4dc2f6dd..ff6ee84d 100644 --- a/test/moonbit/glm_gampoi_test.mbt +++ b/test/moonbit/glm_gampoi_test.mbt @@ -6,11 +6,11 @@ // --------------------------------------------------------------------------- test "glm_design_creation" { - let d = @src.GlmDesign::new( - ["s1", "s2", "s3"], - ["Intercept", "Treatment"], - [[1.0, 0.0], [1.0, 0.0], [1.0, 1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3"], ["Intercept", "Treatment"], [ + [1.0, 0.0], + [1.0, 0.0], + [1.0, 1.0], + ]) assert_eq(d.n_samples(), 3) assert_eq(d.n_coefs(), 2) assert_eq(d.get(0, 0), 1.0) @@ -19,27 +19,23 @@ test "glm_design_creation" { assert_eq(d.get(2, 1), 1.0) } +///| test "glm_design_intercept_only" { - let d = @src.GlmDesign::new( - ["s1", "s2", "s3", "s4"], - ["Intercept"], - [[1.0], [1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3", "s4"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + [1.0], + ]) assert_eq(d.n_samples(), 4) assert_eq(d.n_coefs(), 1) assert_eq(d.get(0, 0), 1.0) assert_eq(d.get(3, 0), 1.0) } +///| test "glm_fit_creation" { - let f = @src.GlmFit::new( - "GeneA", - [2.5, 1.2], - [0.3, 0.4], - 0.15, - 10, - 8.5, - ) + let f = @src.GlmFit::new("GeneA", [2.5, 1.2], [0.3, 0.4], 0.15, 10, 8.5) assert_eq(f.gene, "GeneA") assert_eq(f.coefficients.length(), 2) assert_eq(f.coefficients[0], 2.5) @@ -51,57 +47,33 @@ test "glm_fit_creation" { assert_eq(f.df_dispersion, 8.5) } +///| test "glm_fit_single_coef" { - let f = @src.GlmFit::new( - "GeneX", - [3.0], - [0.5], - 0.2, - 5, - 5.0, - ) + let f = @src.GlmFit::new("GeneX", [3.0], [0.5], 0.2, 5, 5.0) assert_eq(f.coefficients.length(), 1) assert_eq(f.coefficients[0], 3.0) assert_eq(f.std_errors[0], 0.5) } +///| test "glm_test_result_creation" { - let r = @src.GlmTestResult::new( - "GeneA", - "Treatment", - 1.5, - 0.3, - 5.0, - 0.001, - ) + let r = @src.GlmTestResult::new("GeneA", "Treatment", 1.5, 0.3, 5.0, 0.001) assert_eq(r.estimate(), 1.5) assert_eq(r.p_value(), 0.001) assert_eq(r.adj_p_value(), 0.001) } +///| test "glm_test_result_not_significant" { - let r = @src.GlmTestResult::new( - "GeneB", - "Treatment", - 0.1, - 0.5, - 0.2, - 0.8, - ) + let r = @src.GlmTestResult::new("GeneB", "Treatment", 0.1, 0.5, 0.2, 0.8) assert_false(r.is_significant) assert_eq(r.estimate(), 0.1) assert_eq(r.p_value(), 0.8) } +///| test "glm_test_result_to_string" { - let r = @src.GlmTestResult::new( - "GeneA", - "Treatment", - 1.5, - 0.3, - 5.0, - 0.001, - ) + let r = @src.GlmTestResult::new("GeneA", "Treatment", 1.5, 0.3, 5.0, 0.001) let s = r.to_string() assert_true(s.contains("GeneA")) assert_true(s.contains("Treatment")) @@ -109,19 +81,14 @@ test "glm_test_result_to_string" { assert_true(s.contains("p=")) } +///| test "glm_test_result_significant_marker" { - let r = @src.GlmTestResult::new( - "GeneC", - "Treatment", - 3.0, - 0.2, - 15.0, - 1.0e-10, - ) + let r = @src.GlmTestResult::new("GeneC", "Treatment", 3.0, 0.2, 15.0, 1.0e-10) let s = r.to_string() assert_true(s.contains("*")) } +///| test "glm_pseudobulk_creation" { let pb = @src.GlmPseudobulk::new( ["GeneA", "GeneB"], @@ -133,13 +100,9 @@ test "glm_pseudobulk_creation" { assert_eq(pb.n_groups(), 2) } +///| test "glm_pseudobulk_single_gene" { - let pb = @src.GlmPseudobulk::new( - ["GeneX"], - ["GroupA"], - [["s1"]], - [[42.0]], - ) + let pb = @src.GlmPseudobulk::new(["GeneX"], ["GroupA"], [["s1"]], [[42.0]]) assert_eq(pb.n_genes(), 1) assert_eq(pb.n_groups(), 1) } @@ -148,83 +111,101 @@ test "glm_pseudobulk_single_gene" { // Utility functions // --------------------------------------------------------------------------- +///| test "glm_sum_basic" { let s = @src.glm_sum([1.0, 2.0, 3.0, 4.0]) assert_eq(s, 10.0) } +///| test "glm_sum_single" { assert_eq(@src.glm_sum([5.0]), 5.0) } +///| test "glm_sum_empty" { assert_eq(@src.glm_sum([]), 0.0) } +///| test "glm_sum_negative" { assert_eq(@src.glm_sum([-1.0, -2.0, 3.0]), 0.0) } +///| test "glm_mean_basic" { let m = @src.glm_mean([2.0, 4.0, 6.0]) assert_eq(m, 4.0) } +///| test "glm_mean_single" { assert_eq(@src.glm_mean([7.0]), 7.0) } +///| test "glm_mean_empty" { assert_eq(@src.glm_mean([]), 0.0) } +///| test "glm_mean_zeros" { assert_eq(@src.glm_mean([0.0, 0.0, 0.0]), 0.0) } +///| test "glm_median_odd" { let m = @src.glm_median([3.0, 1.0, 2.0]) assert_eq(m, 2.0) } +///| test "glm_median_even" { let m = @src.glm_median([1.0, 3.0, 2.0, 4.0]) assert_eq(m, 2.5) } +///| test "glm_median_single" { assert_eq(@src.glm_median([5.0]), 5.0) } +///| test "glm_median_empty" { assert_eq(@src.glm_median([]), 0.0) } +///| test "glm_median_already_sorted" { let m = @src.glm_median([1.0, 2.0, 3.0, 4.0, 5.0]) assert_eq(m, 3.0) } +///| test "glm_min_positive_basic" { let v = @src.glm_min_positive([0.0, 3.0, 2.0, 5.0]) assert_eq(v, 2.0) } +///| test "glm_min_positive_no_positive" { let v = @src.glm_min_positive([0.0, -1.0, -5.0]) assert_eq(v, 0.0) } +///| test "glm_min_positive_all_positive" { let v = @src.glm_min_positive([10.0, 3.0, 7.0]) assert_eq(v, 3.0) } +///| test "glm_min_positive_single" { let v = @src.glm_min_positive([42.0]) assert_eq(v, 42.0) } +///| test "glm_min_positive_empty" { let v = @src.glm_min_positive([]) assert_eq(v, 0.0) @@ -234,6 +215,7 @@ test "glm_min_positive_empty" { // Linear algebra: solve linear system // --------------------------------------------------------------------------- +///| test "glm_solve_linear_system_2x2" { // 2x + 3y = 7 // x + y = 3 @@ -245,6 +227,7 @@ test "glm_solve_linear_system_2x2" { assert_true((x[1] - 1.0).abs() < 1.0e-6) } +///| test "glm_solve_linear_system_3x3" { // x + y + z = 6 // 2x + y - z = 1 @@ -258,15 +241,17 @@ test "glm_solve_linear_system_3x3" { assert_true((x[2] - 3.0).abs() < 1.0e-6) } +///| test "glm_solve_linear_system_identity" { // Identity * x = b => x = b let a = [[1.0, 0.0], [0.0, 1.0]] let b = [5.0, -3.0] let x = @src.glm_solve_linear_system(a, b, 2) assert_true((x[0] - 5.0).abs() < 1.0e-6) - assert_true((x[1] - (-3.0)).abs() < 1.0e-6) + assert_true((x[1] - -3.0).abs() < 1.0e-6) } +///| test "glm_solve_linear_system_1x1" { let a = [[3.0]] let b = [12.0] @@ -274,6 +259,7 @@ test "glm_solve_linear_system_1x1" { assert_true((x[0] - 4.0).abs() < 1.0e-6) } +///| test "glm_solve_linear_system_diagonal" { // Diagonal 3x3 system // 3x = 9, 2y = 8, 4z = 16 @@ -289,17 +275,19 @@ test "glm_solve_linear_system_diagonal" { // Linear algebra: matrix inverse // --------------------------------------------------------------------------- +///| test "glm_invert_matrix_2x2" { // A = [[4, 7], [2, 6]] // A^{-1} = [[0.6, -0.7], [-0.2, 0.4]] let a = [[4.0, 7.0], [2.0, 6.0]] let inv = @src.glm_invert_matrix(a, 2) assert_true((inv[0][0] - 0.6).abs() < 1.0e-6) - assert_true((inv[0][1] - (-0.7)).abs() < 1.0e-6) - assert_true((inv[1][0] - (-0.2)).abs() < 1.0e-6) + assert_true((inv[0][1] - -0.7).abs() < 1.0e-6) + assert_true((inv[1][0] - -0.2).abs() < 1.0e-6) assert_true((inv[1][1] - 0.4).abs() < 1.0e-6) } +///| test "glm_invert_matrix_identity_3x3" { let a = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] let inv = @src.glm_invert_matrix(a, 3) @@ -311,12 +299,14 @@ test "glm_invert_matrix_identity_3x3" { } } +///| test "glm_invert_matrix_1x1" { let a = [[5.0]] let inv = @src.glm_invert_matrix(a, 1) assert_true((inv[0][0] - 0.2).abs() < 1.0e-6) } +///| test "glm_invert_matrix_verify_product" { // A * A^{-1} should be identity let a = [[2.0, 1.0], [5.0, 3.0]] @@ -337,6 +327,7 @@ test "glm_invert_matrix_verify_product" { // Statistical utilities // --------------------------------------------------------------------------- +///| test "glm_phi_standard_normal" { // phi(0) ≈ 0.5 let p0 = @src.glm_phi(0.0) @@ -349,6 +340,7 @@ test "glm_phi_standard_normal" { assert_true((p2 - 0.025).abs() < 0.01) } +///| test "glm_phi_symmetry" { // phi(x) + phi(-x) = 1 let x = 1.5 @@ -356,6 +348,7 @@ test "glm_phi_symmetry" { assert_true((p_sum - 1.0).abs() < 1.0e-10) } +///| test "glm_phi_non_decreasing" { // phi should be non-decreasing let p1 = @src.glm_phi(-2.0) @@ -369,6 +362,7 @@ test "glm_phi_non_decreasing" { assert_true(p4 <= p5) } +///| test "glm_phi_clamped" { // phi should be in [0, 1] assert_true(@src.glm_phi(-10.0) >= 0.0) @@ -377,18 +371,21 @@ test "glm_phi_clamped" { assert_true(@src.glm_phi(10.0) <= 1.0) } +///| test "glm_normal_pvalue_two_sided_zero" { // z=0 => p=1.0 let p = @src.glm_normal_pvalue_two_sided(0.0) assert_true((p - 1.0).abs() < 0.01) } +///| test "glm_normal_pvalue_two_sided_196" { // z=1.96 => p≈0.05 let p = @src.glm_normal_pvalue_two_sided(1.96) assert_true((p - 0.05).abs() < 0.01) } +///| test "glm_normal_pvalue_two_sided_symmetry" { // z and -z should give same p-value let p1 = @src.glm_normal_pvalue_two_sided(2.5) @@ -396,6 +393,7 @@ test "glm_normal_pvalue_two_sided_symmetry" { assert_true((p1 - p2).abs() < 1.0e-10) } +///| test "glm_normal_pvalue_two_sided_in_range" { // All p-values should be in [0, 1] for z in [-5.0, -2.0, -1.0, 0.0, 1.0, 2.0, 5.0] { @@ -405,6 +403,7 @@ test "glm_normal_pvalue_two_sided_in_range" { } } +///| test "glm_normal_pvalue_two_sided_large_z" { // Large |z| should give very small p-value (clamped to 1e-15) let p = @src.glm_normal_pvalue_two_sided(10.0) @@ -415,6 +414,7 @@ test "glm_normal_pvalue_two_sided_large_z" { // Sorting // --------------------------------------------------------------------------- +///| test "glm_sort_pairs_basic" { let arr = [(3.0, 2), (1.0, 0), (2.0, 1)] @src.glm_sort_pairs(arr) @@ -426,6 +426,7 @@ test "glm_sort_pairs_basic" { assert_eq(arr[2].1, 2) } +///| test "glm_sort_pairs_already_sorted" { let arr = [(1.0, 0), (2.0, 1), (3.0, 2)] @src.glm_sort_pairs(arr) @@ -434,6 +435,7 @@ test "glm_sort_pairs_already_sorted" { assert_eq(arr[2].0, 3.0) } +///| test "glm_sort_pairs_single" { let arr = [(5.0, 0)] @src.glm_sort_pairs(arr) @@ -441,6 +443,7 @@ test "glm_sort_pairs_single" { assert_eq(arr[0].0, 5.0) } +///| test "glm_sort_pairs_empty" { let arr : Array[(Double, Int)] = [] @src.glm_sort_pairs(arr) @@ -451,12 +454,14 @@ test "glm_sort_pairs_empty" { // BH-FDR correction // --------------------------------------------------------------------------- +///| test "glm_bh_correct_single" { // Single p-value correction returns same value let p = @src.glm_bh_correct(0.05) assert_eq(p, 0.05) } +///| test "glm_bh_correct_array_known_values" { // p-values: [0.01, 0.04, 0.03, 0.005] // Sorted: [0.005, 0.01, 0.03, 0.04] @@ -473,6 +478,7 @@ test "glm_bh_correct_array_known_values" { assert_true((adj[3] - 0.02).abs() < 1.0e-6) } +///| test "glm_bh_correct_array_all_same" { let pvals = [0.05, 0.05, 0.05] let adj = @src.glm_bh_correct_array(pvals) @@ -481,17 +487,20 @@ test "glm_bh_correct_array_all_same" { assert_true((adj[1] - adj[2]).abs() < 1.0e-10) } +///| test "glm_bh_correct_array_single" { let adj = @src.glm_bh_correct_array([0.02]) assert_eq(adj.length(), 1) assert_true((adj[0] - 0.02).abs() < 1.0e-6) } +///| test "glm_bh_correct_array_empty" { let adj = @src.glm_bh_correct_array([]) assert_eq(adj.length(), 0) } +///| test "glm_bh_correct_array_values_in_range" { let pvals = [0.001, 0.02, 0.05, 0.1, 0.5] let adj = @src.glm_bh_correct_array(pvals) @@ -501,15 +510,11 @@ test "glm_bh_correct_array_values_in_range" { } } +///| test "glm_bh_correct_array_monotonic" { let pvals = [0.001, 0.01, 0.03, 0.04] let adj = @src.glm_bh_correct_array(pvals) - let indexed = [ - (pvals[0], 0), - (pvals[1], 1), - (pvals[2], 2), - (pvals[3], 3), - ] + let indexed = [(pvals[0], 0), (pvals[1], 1), (pvals[2], 2), (pvals[3], 3)] @src.glm_sort_pairs(indexed) let adj0 = adj[indexed[0].1] let adj1 = adj[indexed[1].1] @@ -524,15 +529,12 @@ test "glm_bh_correct_array_monotonic" { // Size factor calculation // --------------------------------------------------------------------------- +///| test "glm_calculate_sf_basic" { // 3 genes, 2 samples // Sample 0: [10, 20, 30], Sample 1: [20, 40, 60] // Sample 1 has twice the counts, so sf[1] ≈ 2 * sf[0] - let counts = [ - [10.0, 20.0], - [20.0, 40.0], - [30.0, 60.0], - ] + let counts = [[10.0, 20.0], [20.0, 40.0], [30.0, 60.0]] let sf = @src.glm_calculate_sf(counts) assert_eq(sf.length(), 2) assert_true(sf[0] > 0.0) @@ -541,11 +543,9 @@ test "glm_calculate_sf_basic" { assert_true((sf[1] / sf[0] - 2.0).abs() < 0.5) } +///| test "glm_calculate_sf_equal_samples" { - let counts = [ - [10.0, 10.0, 10.0], - [20.0, 20.0, 20.0], - ] + let counts = [[10.0, 10.0, 10.0], [20.0, 20.0, 20.0]] let sf = @src.glm_calculate_sf(counts) assert_eq(sf.length(), 3) // All samples have same counts, so sf should be equal @@ -553,6 +553,7 @@ test "glm_calculate_sf_equal_samples" { assert_true((sf[1] - sf[2]).abs() < 1.0e-6) } +///| test "glm_calculate_sf_single_sample" { let counts = [[5.0], [10.0], [15.0]] let sf = @src.glm_calculate_sf(counts) @@ -560,16 +561,15 @@ test "glm_calculate_sf_single_sample" { assert_true(sf[0] > 0.0) } +///| test "glm_calculate_sf_empty" { let sf = @src.glm_calculate_sf([]) assert_eq(sf.length(), 0) } +///| test "glm_calculate_sf_all_zeros" { - let counts = [ - [0.0, 0.0], - [0.0, 0.0], - ] + let counts = [[0.0, 0.0], [0.0, 0.0]] let sf = @src.glm_calculate_sf(counts) assert_eq(sf.length(), 2) // Should fallback to 1.0 for zero-count samples @@ -577,12 +577,9 @@ test "glm_calculate_sf_all_zeros" { assert_true(sf[1] > 0.0) } +///| test "glm_calculate_sf_genes_with_zeros" { - let counts = [ - [10.0, 0.0], - [0.0, 20.0], - [30.0, 30.0], - ] + let counts = [[10.0, 0.0], [0.0, 20.0], [30.0, 30.0]] let sf = @src.glm_calculate_sf(counts) assert_eq(sf.length(), 2) assert_true(sf[0] > 0.0) @@ -593,12 +590,10 @@ test "glm_calculate_sf_genes_with_zeros" { // Pseudobulk aggregation // --------------------------------------------------------------------------- +///| test "glm_pseudobulk_basic" { // 2 genes, 4 samples (2 control, 2 treated) - let counts = [ - [10.0, 12.0, 50.0, 48.0], - [20.0, 22.0, 18.0, 20.0], - ] + let counts = [[10.0, 12.0, 50.0, 48.0], [20.0, 22.0, 18.0, 20.0]] let gene_names = ["GeneA", "GeneB"] let group_labels = ["control", "control", "treated", "treated"] let pb = @src.glm_pseudobulk(counts, gene_names, group_labels) @@ -606,6 +601,7 @@ test "glm_pseudobulk_basic" { assert_eq(pb.n_groups(), 2) } +///| test "glm_pseudobulk_single_group" { let counts = [[10.0, 20.0, 30.0]] let gene_names = ["GeneX"] @@ -615,10 +611,9 @@ test "glm_pseudobulk_single_group" { assert_eq(pb.n_groups(), 1) } +///| test "glm_pseudobulk_single_sample_per_group" { - let counts = [ - [5.0, 10.0, 15.0], - ] + let counts = [[5.0, 10.0, 15.0]] let gene_names = ["GeneX"] let group_labels = ["A", "B", "C"] let pb = @src.glm_pseudobulk(counts, gene_names, group_labels) @@ -626,10 +621,11 @@ test "glm_pseudobulk_single_sample_per_group" { assert_eq(pb.n_groups(), 3) } +///| test "glm_pseudobulk_empty" { - let counts: Array[Array[Double]] = [] - let gene_names: Array[String] = [] - let group_labels: Array[String] = [] + let counts : Array[Array[Double]] = [] + let gene_names : Array[String] = [] + let group_labels : Array[String] = [] let pb = @src.glm_pseudobulk(counts, gene_names, group_labels) assert_eq(pb.n_genes(), 0) assert_eq(pb.n_groups(), 0) @@ -639,13 +635,15 @@ test "glm_pseudobulk_empty" { // Initial estimates and dispersion // --------------------------------------------------------------------------- +///| test "glm_initial_estimates_constant_counts" { let counts = [10.0, 10.0, 10.0, 10.0] - let d = @src.GlmDesign::new( - ["s1", "s2", "s3", "s4"], - ["Intercept"], - [[1.0], [1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3", "s4"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + [1.0], + ]) let coefs = @src.glm_initial_estimates(counts, d) assert_eq(coefs.length(), 1) // With constant counts and intercept-only design, @@ -654,6 +652,7 @@ test "glm_initial_estimates_constant_counts" { assert_true((coefs[0] - expected_ln).abs() < 0.5) } +///| test "glm_initial_estimates_two_groups" { let counts = [10.0, 12.0, 50.0, 48.0] let d = @src.GlmDesign::new( @@ -667,25 +666,29 @@ test "glm_initial_estimates_two_groups" { assert_true(coefs[1] > 0.0) } +///| test "glm_initial_estimates_with_zeros" { let counts = [0.0, 10.0, 20.0, 30.0] - let d = @src.GlmDesign::new( - ["s1", "s2", "s3", "s4"], - ["Intercept"], - [[1.0], [1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3", "s4"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + [1.0], + ]) let coefs = @src.glm_initial_estimates(counts, d) assert_eq(coefs.length(), 1) assert_true(coefs[0] > 0.0) } +///| test "glm_estimate_dispersion_low" { let counts = [10.0, 11.0, 10.5, 9.5] - let d = @src.GlmDesign::new( - ["s1", "s2", "s3", "s4"], - ["Intercept"], - [[1.0], [1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3", "s4"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + [1.0], + ]) let coefs = @src.glm_initial_estimates(counts, d) let disp = @src.glm_estimate_dispersion(counts, d, coefs) // Low dispersion for tightly clustered counts @@ -693,26 +696,30 @@ test "glm_estimate_dispersion_low" { assert_true(disp < 5.0) } +///| test "glm_estimate_dispersion_high" { let counts = [1.0, 50.0, 2.0, 48.0] - let d = @src.GlmDesign::new( - ["s1", "s2", "s3", "s4"], - ["Intercept"], - [[1.0], [1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3", "s4"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + [1.0], + ]) let coefs = @src.glm_initial_estimates(counts, d) let disp = @src.glm_estimate_dispersion(counts, d, coefs) // High dispersion for highly variable counts assert_true(disp >= 0.0) } +///| test "glm_estimate_dispersion_all_same" { let counts = [20.0, 20.0, 20.0, 20.0] - let d = @src.GlmDesign::new( - ["s1", "s2", "s3", "s4"], - ["Intercept"], - [[1.0], [1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3", "s4"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + [1.0], + ]) let coefs = @src.glm_initial_estimates(counts, d) let disp = @src.glm_estimate_dispersion(counts, d, coefs) // Zero variance => dispersion should be very small or 0 @@ -723,6 +730,7 @@ test "glm_estimate_dispersion_all_same" { // IWLCS fit // --------------------------------------------------------------------------- +///| test "glm_iwlcs_fit_produces_coefs" { let counts = [10.0, 12.0, 50.0, 48.0] let d = @src.GlmDesign::new( @@ -737,13 +745,15 @@ test "glm_iwlcs_fit_produces_coefs" { assert_true(coefs[1] > 0.0) } +///| test "glm_iwlcs_fit_converges" { let counts = [10.0, 10.0, 10.0, 10.0] - let d = @src.GlmDesign::new( - ["s1", "s2", "s3", "s4"], - ["Intercept"], - [[1.0], [1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3", "s4"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + [1.0], + ]) let initial = @src.glm_initial_estimates(counts, d) let coefs = @src.glm_iwlcs_fit(counts, d, 0.1, initial) assert_eq(coefs.length(), 1) @@ -756,6 +766,7 @@ test "glm_iwlcs_fit_converges" { // Standard error computation // --------------------------------------------------------------------------- +///| test "glm_compute_se_positive" { let d = @src.GlmDesign::new( ["s1", "s2", "s3", "s4"], @@ -770,12 +781,13 @@ test "glm_compute_se_positive" { assert_true(se[1] > 0.0) } +///| test "glm_compute_se_single_coef" { - let d = @src.GlmDesign::new( - ["s1", "s2", "s3"], - ["Intercept"], - [[1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + ]) let coefs = [2.5] let sf = [1.0, 1.0, 1.0] let se = @src.glm_compute_se(d, 0.2, coefs, sf) @@ -787,6 +799,7 @@ test "glm_compute_se_single_coef" { // Single-gene fitting // --------------------------------------------------------------------------- +///| test "glm_fit_one_gene_basic" { let counts = [10.0, 12.0, 50.0, 48.0] let d = @src.GlmDesign::new( @@ -804,6 +817,7 @@ test "glm_fit_one_gene_basic" { assert_true(fit.df_dispersion > 0.0) } +///| test "glm_fit_one_gene_treatment_positive" { let counts = [10.0, 12.0, 50.0, 48.0] let d = @src.GlmDesign::new( @@ -817,6 +831,7 @@ test "glm_fit_one_gene_treatment_positive" { assert_true(fit.coefficients[1] > 0.0) } +///| test "glm_fit_one_gene_no_treatment_effect" { let counts = [20.0, 22.0, 18.0, 20.0] let d = @src.GlmDesign::new( @@ -834,12 +849,10 @@ test "glm_fit_one_gene_no_treatment_effect" { // Differential expression testing // --------------------------------------------------------------------------- +///| test "glm_test_de_basic" { // 2 genes, 4 samples - let counts = [ - [10.0, 12.0, 50.0, 48.0], - [20.0, 22.0, 18.0, 20.0], - ] + let counts = [[10.0, 12.0, 50.0, 48.0], [20.0, 22.0, 18.0, 20.0]] let gene_names = ["GeneA", "GeneB"] let d = @src.GlmDesign::new( ["s1", "s2", "s3", "s4"], @@ -853,11 +866,9 @@ test "glm_test_de_basic" { assert_eq(results[1].gene, "GeneB") } +///| test "glm_test_de_pvalues_in_range" { - let counts = [ - [10.0, 12.0, 50.0, 48.0], - [20.0, 22.0, 18.0, 20.0], - ] + let counts = [[10.0, 12.0, 50.0, 48.0], [20.0, 22.0, 18.0, 20.0]] let gene_names = ["GeneA", "GeneB"] let d = @src.GlmDesign::new( ["s1", "s2", "s3", "s4"], @@ -874,12 +885,10 @@ test "glm_test_de_pvalues_in_range" { } } +///| test "glm_test_de_detects_differential" { // GeneA has strong treatment effect, GeneB does not - let counts = [ - [5.0, 6.0, 80.0, 75.0], - [20.0, 22.0, 18.0, 20.0], - ] + let counts = [[5.0, 6.0, 80.0, 75.0], [20.0, 22.0, 18.0, 20.0]] let gene_names = ["GeneA", "GeneB"] let d = @src.GlmDesign::new( ["s1", "s2", "s3", "s4"], @@ -894,11 +903,9 @@ test "glm_test_de_detects_differential" { assert_true(z_a > z_b) } +///| test "glm_test_de_estimate_sign" { - let counts = [ - [10.0, 12.0, 50.0, 48.0], - [50.0, 48.0, 10.0, 12.0], - ] + let counts = [[10.0, 12.0, 50.0, 48.0], [50.0, 48.0, 10.0, 12.0]] let gene_names = ["GeneUp", "GeneDown"] let d = @src.GlmDesign::new( ["s1", "s2", "s3", "s4"], @@ -913,6 +920,7 @@ test "glm_test_de_estimate_sign" { assert_true(results[1].estimate() < 0.0) } +///| test "glm_test_de_single_gene" { let counts = [[10.0, 12.0, 50.0, 48.0]] let gene_names = ["GeneA"] @@ -931,6 +939,7 @@ test "glm_test_de_single_gene" { // Significant filtering // --------------------------------------------------------------------------- +///| test "glm_significant_filters_correctly" { let r1 = @src.GlmTestResult::new("GeneA", "Treatment", 3.0, 0.5, 6.0, 1.0e-10) let r2 = @src.GlmTestResult::new("GeneB", "Treatment", 0.1, 0.3, 0.3, 0.8) @@ -947,11 +956,13 @@ test "glm_significant_filters_correctly" { } } +///| test "glm_significant_empty_input" { let sig = @src.glm_significant([], 0.05) assert_eq(sig.length(), 0) } +///| test "glm_significant_no_passing" { let r1 = @src.GlmTestResult::new("GeneA", "Treatment", 0.0, 0.5, 0.0, 0.5) let r2 = @src.GlmTestResult::new("GeneB", "Treatment", 0.1, 0.3, 0.3, 0.8) @@ -960,8 +971,11 @@ test "glm_significant_no_passing" { assert_eq(sig.length(), 0) } +///| test "glm_significant_all_pass" { - let r1 = @src.GlmTestResult::new("GeneA", "Treatment", 5.0, 0.5, 10.0, 1.0e-10) + let r1 = @src.GlmTestResult::new( + "GeneA", "Treatment", 5.0, 0.5, 10.0, 1.0e-10, + ) let r2 = @src.GlmTestResult::new("GeneB", "Treatment", 4.0, 0.3, 13.0, 1.0e-8) let results = [r1, r2] let sig = @src.glm_significant(results, 1.0) @@ -972,36 +986,35 @@ test "glm_significant_all_pass" { // Edge cases and integration // --------------------------------------------------------------------------- +///| test "glm_design_single_sample" { - let d = @src.GlmDesign::new( - ["s1"], - ["Intercept"], - [[1.0]], - ) + let d = @src.GlmDesign::new(["s1"], ["Intercept"], [[1.0]]) assert_eq(d.n_samples(), 1) assert_eq(d.n_coefs(), 1) assert_eq(d.get(0, 0), 1.0) } +///| test "glm_design_many_coefs" { - let d = @src.GlmDesign::new( - ["s1", "s2"], - ["A", "B", "C", "D"], - [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2"], ["A", "B", "C", "D"], [ + [1.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0], + ]) assert_eq(d.n_samples(), 2) assert_eq(d.n_coefs(), 4) assert_eq(d.get(0, 0), 1.0) assert_eq(d.get(1, 1), 1.0) } +///| test "glm_fit_constant_counts" { let counts = [20.0, 20.0, 20.0, 20.0] - let d = @src.GlmDesign::new( - ["s1", "s2", "s3", "s4"], - ["Intercept"], - [[1.0], [1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3", "s4"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + [1.0], + ]) let sf = [1.0, 1.0, 1.0, 1.0] let fit = @src.glm_fit_one_gene(counts, d, sf, "GeneConst") assert_eq(fit.gene, "GeneConst") @@ -1009,11 +1022,9 @@ test "glm_fit_constant_counts" { assert_true(fit.dispersion >= 0.0) } +///| test "glm_test_de_with_size_factors" { - let counts = [ - [10.0, 20.0, 50.0, 100.0], - [20.0, 40.0, 18.0, 36.0], - ] + let counts = [[10.0, 20.0, 50.0, 100.0], [20.0, 40.0, 18.0, 36.0]] let gene_names = ["GeneA", "GeneB"] let d = @src.GlmDesign::new( ["s1", "s2", "s3", "s4"], @@ -1025,6 +1036,7 @@ test "glm_test_de_with_size_factors" { assert_eq(results.length(), 2) } +///| test "glm_full_pipeline" { // Simulate a full differential expression analysis pipeline let counts = [ @@ -1066,44 +1078,48 @@ test "glm_full_pipeline" { } } +///| test "glm_phi_05" { // phi(0.5) should be approximately 0.6915 let p = @src.glm_phi(0.5) assert_true((p - 0.6915).abs() < 0.01) } +///| test "glm_phi_2" { // phi(2.0) should be approximately 0.9772 let p = @src.glm_phi(2.0) assert_true((p - 0.9772).abs() < 0.01) } +///| test "glm_phi_negative" { // phi(-1.0) should be approximately 0.1587 let p = @src.glm_phi(-1.0) assert_true((p - 0.1587).abs() < 0.01) } +///| test "glm_median_two_elements" { let m = @src.glm_median([3.0, 7.0]) assert_eq(m, 5.0) } +///| test "glm_median_with_duplicates" { let m = @src.glm_median([1.0, 2.0, 2.0, 3.0, 3.0]) assert_eq(m, 2.0) } +///| test "glm_min_positive_all_zero" { let v = @src.glm_min_positive([0.0, 0.0, 0.0]) assert_eq(v, 0.0) } +///| test "glm_calculate_sf_two_genes" { - let counts = [ - [100.0, 10.0], - [200.0, 20.0], - ] + let counts = [[100.0, 10.0], [200.0, 20.0]] let sf = @src.glm_calculate_sf(counts) assert_eq(sf.length(), 2) // Sample 0 has 10x more counts than sample 1 @@ -1111,11 +1127,9 @@ test "glm_calculate_sf_two_genes" { assert_true((sf[0] / sf[1] - 10.0).abs() < 2.0) } +///| test "glm_test_de_all_zeros" { - let counts = [ - [0.0, 0.0, 0.0, 0.0], - [0.0, 0.0, 0.0, 0.0], - ] + let counts = [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]] let gene_names = ["GeneA", "GeneB"] let d = @src.GlmDesign::new( ["s1", "s2", "s3", "s4"], @@ -1132,6 +1146,7 @@ test "glm_test_de_all_zeros" { } } +///| test "glm_bh_correct_array_already_corrected" { // When all p-values are very small, BH should keep them small let pvals = [1.0e-10, 1.0e-8, 1.0e-6, 1.0e-4] @@ -1142,4 +1157,4 @@ test "glm_bh_correct_array_already_corrected" { } // The smallest p-value should remain small assert_true(adj[0] <= 1.0e-4) -} \ No newline at end of file +} diff --git a/test/moonbit/goa_test.mbt b/test/moonbit/goa_test.mbt index 72a7d575..7b6861e1 100644 --- a/test/moonbit/goa_test.mbt +++ b/test/moonbit/goa_test.mbt @@ -11,18 +11,21 @@ test "goa_aspect_from_string_F" { assert_eq(@src.GafAspect::description(a), "Molecular Function") } +///| test "goa_aspect_from_string_P" { let a = @src.GafAspect::from_string("P") assert_eq(@src.GafAspect::to_string(a), "P") assert_eq(@src.GafAspect::description(a), "Biological Process") } +///| test "goa_aspect_from_string_C" { let a = @src.GafAspect::from_string("C") assert_eq(@src.GafAspect::to_string(a), "C") assert_eq(@src.GafAspect::description(a), "Cellular Component") } +///| test "goa_aspect_from_string_unknown" { // Unknown inputs (e.g. "X", "", "foo") map to Unknown. let a1 = @src.GafAspect::from_string("X") @@ -36,6 +39,7 @@ test "goa_aspect_from_string_unknown" { assert_eq(@src.GafAspect::description(a3), "Unknown") } +///| test "goa_aspect_to_string_roundtrip" { // from_string -> to_string should round-trip for the three valid codes. assert_eq(@src.GafAspect::to_string(@src.GafAspect::from_string("F")), "F") @@ -47,6 +51,7 @@ test "goa_aspect_to_string_roundtrip" { // GafRecord creation and accessors // --------------------------------------------------------------------------- +///| test "goa_record_creation" { let r = @src.GafRecord::new( db="UniProtKB", @@ -86,6 +91,7 @@ test "goa_record_creation" { assert_eq(r.gene_product_form_id(), "") } +///| test "goa_record_creation_all_fields_populated" { // Record with every field populated, including the optional extension/form id. let r = @src.GafRecord::new( @@ -118,6 +124,7 @@ test "goa_record_creation_all_fields_populated" { // GafRecord utility methods // --------------------------------------------------------------------------- +///| test "goa_record_go_id_short" { let r = @src.GafRecord::new( db="UniProtKB", @@ -141,6 +148,7 @@ test "goa_record_go_id_short" { assert_eq(r.go_id_short(), "0003674") } +///| test "goa_record_go_id_short_no_prefix" { // A GO ID without "GO:" prefix should be returned unchanged. let r = @src.GafRecord::new( @@ -165,6 +173,7 @@ test "goa_record_go_id_short_no_prefix" { assert_eq(r.go_id_short(), "0003674") } +///| test "goa_record_qualifiers_split" { let r = @src.GafRecord::new( db="UniProtKB", @@ -191,6 +200,7 @@ test "goa_record_qualifiers_split" { assert_eq(qs[1], "enables") } +///| test "goa_record_qualifiers_single" { let r = @src.GafRecord::new( db="UniProtKB", @@ -216,6 +226,7 @@ test "goa_record_qualifiers_single" { assert_eq(qs[0], "enables") } +///| test "goa_record_qualifiers_empty" { let r = @src.GafRecord::new( db="UniProtKB", @@ -239,6 +250,7 @@ test "goa_record_qualifiers_empty" { assert_eq(r.qualifiers().length(), 0) } +///| test "goa_record_synonyms_split" { let r = @src.GafRecord::new( db="UniProtKB", @@ -265,6 +277,7 @@ test "goa_record_synonyms_split" { assert_eq(syns[1], "LFS1") } +///| test "goa_record_references_split" { let r = @src.GafRecord::new( db="UniProtKB", @@ -292,6 +305,7 @@ test "goa_record_references_split" { assert_eq(refs[2], "GO_REF:000001") } +///| test "goa_record_taxon_ids_with_prefix" { // "taxon:9606|taxon:9606" yields ["9606", "9606"] (duplicates preserved). let r = @src.GafRecord::new( @@ -319,6 +333,7 @@ test "goa_record_taxon_ids_with_prefix" { assert_eq(ids[1], "9606") } +///| test "goa_record_taxon_ids_bare_numeric" { // Numeric taxon IDs without the "taxon:" prefix should be returned as-is. let r = @src.GafRecord::new( @@ -345,6 +360,7 @@ test "goa_record_taxon_ids_bare_numeric" { assert_eq(ids[0], "9606") } +///| test "goa_record_taxon_ids_multiple_distinct" { // Two distinct taxon IDs (interactor case). let r = @src.GafRecord::new( @@ -372,6 +388,7 @@ test "goa_record_taxon_ids_multiple_distinct" { assert_eq(ids[1], "4932") } +///| test "goa_record_to_string" { let r = @src.GafRecord::new( db="UniProtKB", @@ -405,6 +422,7 @@ test "goa_record_to_string" { // Header line parsing // --------------------------------------------------------------------------- +///| test "goa_parse_header_line_valid" { let h = @src.goa_parse_header_line("!gaf-version: 2.2") assert_true(h is Some(_)) @@ -417,6 +435,7 @@ test "goa_parse_header_line_valid" { } } +///| test "goa_parse_header_line_generated_by" { let h = @src.goa_parse_header_line("!generated-by: UniProt") assert_true(h is Some(_)) @@ -429,6 +448,7 @@ test "goa_parse_header_line_generated_by" { } } +///| test "goa_parse_header_line_with_extra_spaces" { let h = @src.goa_parse_header_line("! gaf-version : 2.2 ") assert_true(h is Some(_)) @@ -441,23 +461,27 @@ test "goa_parse_header_line_with_extra_spaces" { } } +///| test "goa_parse_header_line_not_header" { // A line that does not start with "!" is not a header. let h = @src.goa_parse_header_line("UniProtKB\tQ12345") assert_true(h is None) } +///| test "goa_parse_header_line_no_colon" { // A header line with no colon is invalid. let h = @src.goa_parse_header_line("!this-has-no-colon") assert_true(h is None) } +///| test "goa_parse_header_line_empty" { let h = @src.goa_parse_header_line("") assert_true(h is None) } +///| test "goa_parse_header_line_empty_value" { // A header line with a colon but empty value is valid (value is ""). let h = @src.goa_parse_header_line("!gaf-version:") @@ -475,6 +499,7 @@ test "goa_parse_header_line_empty_value" { // Data line parsing // --------------------------------------------------------------------------- +///| test "goa_parse_line_full_17_columns" { let line = "UniProtKB\tQ12345\tPROT1\tenables\tGO:0003674\tPMID:12345\tIDA\tGO:0005515\tF\tProtein 1\tP1|PROT-1\tprotein\ttaxon:9606|taxon:9606\t20210115\tUniProt\t\t" let r = @src.goa_parse_line(line) @@ -503,6 +528,7 @@ test "goa_parse_line_full_17_columns" { } } +///| test "goa_parse_line_short_padded" { // A line with fewer than 17 columns should be right-padded with empty strings. let line = "UniProtKB\tQ12345\tPROT1\tenables\tGO:0003674" @@ -525,22 +551,26 @@ test "goa_parse_line_short_padded" { } } +///| test "goa_parse_line_empty" { let r = @src.goa_parse_line("") assert_true(r is None) } +///| test "goa_parse_line_whitespace_only" { let r = @src.goa_parse_line(" ") assert_true(r is None) } +///| test "goa_parse_line_header_returns_none" { // Header lines (starting with "!") should not be parsed as data records. let r = @src.goa_parse_line("!gaf-version: 2.2") assert_true(r is None) } +///| test "goa_parse_line_comment_returns_none" { // Any line starting with "!" is treated as a header/comment, not data. let r = @src.goa_parse_line("!some comment line") @@ -551,6 +581,7 @@ test "goa_parse_line_comment_returns_none" { // Full content parsing // --------------------------------------------------------------------------- +///| test "goa_parse_with_header_and_data" { let content = "!gaf-version: 2.2\n" + "!generated-by: UniProt\n" + @@ -565,6 +596,7 @@ test "goa_parse_with_header_and_data" { assert_eq(recs[1].db_object_symbol(), "TP53") } +///| test "goa_parse_empty_input" { let db = @src.goa_parse("") assert_eq(db.n_records(), 0) @@ -572,6 +604,7 @@ test "goa_parse_empty_input" { assert_eq(db.created_by(), "") } +///| test "goa_parse_only_headers" { let content = "!gaf-version: 2.2\n" + "!generated-by: SGD\n" let db = @src.goa_parse(content) @@ -580,6 +613,7 @@ test "goa_parse_only_headers" { assert_eq(db.created_by(), "SGD") } +///| test "goa_parse_skips_blank_lines" { let content = "!gaf-version: 2.2\n" + "\n" + @@ -590,6 +624,7 @@ test "goa_parse_skips_blank_lines" { assert_eq(db.n_records(), 2) } +///| test "goa_parse_ignores_unknown_header_keys" { // Header keys other than gaf-version / generated-by should not overwrite metadata. let content = "!gaf-version: 2.2\n" + @@ -606,6 +641,7 @@ test "goa_parse_ignores_unknown_header_keys" { // GoaDatabase properties // --------------------------------------------------------------------------- +///| test "goa_database_new_empty" { let db = @src.GoaDatabase::new() assert_eq(db.n_records(), 0) @@ -614,6 +650,7 @@ test "goa_database_new_empty" { assert_eq(db.created_by(), "") } +///| test "goa_database_records_accessor" { let db = @src.goa_sample_database() let recs = db.records() @@ -624,6 +661,7 @@ test "goa_database_records_accessor" { // Filter functions // --------------------------------------------------------------------------- +///| test "goa_filter_by_go_id" { let db = @src.goa_sample_database() // GO:0003674 (molecular_function) appears once in the sample database. @@ -633,12 +671,14 @@ test "goa_filter_by_go_id" { assert_eq(hits[0].go_id(), "GO:0003674") } +///| test "goa_filter_by_go_id_no_match" { let db = @src.goa_sample_database() let hits = @src.goa_filter_by_go_id(db, "GO:9999999") assert_eq(hits.length(), 0) } +///| test "goa_filter_by_aspect_molecular_function" { let db = @src.goa_sample_database() // F records: PROT1, TP53, YFG1, RPL5 (4 total). @@ -649,6 +689,7 @@ test "goa_filter_by_aspect_molecular_function" { } } +///| test "goa_filter_by_aspect_biological_process" { let db = @src.goa_sample_database() // P records: PROT1, TP53, Hsp70 (3 total). @@ -659,6 +700,7 @@ test "goa_filter_by_aspect_biological_process" { } } +///| test "goa_filter_by_aspect_cellular_component" { let db = @src.goa_sample_database() // C records: PROT1, YFG1, Hsp70 (3 total). @@ -669,6 +711,7 @@ test "goa_filter_by_aspect_cellular_component" { } } +///| test "goa_filter_by_aspect_unknown" { let db = @src.goa_sample_database() // No Unknown aspect records in the sample database. @@ -676,6 +719,7 @@ test "goa_filter_by_aspect_unknown" { assert_eq(hits.length(), 0) } +///| test "goa_filter_by_evidence_ida" { let db = @src.goa_sample_database() // IDA records: PROT1 (x3), YFG1 (C), Hsp70 (C) = 5 total. @@ -686,6 +730,7 @@ test "goa_filter_by_evidence_ida" { } } +///| test "goa_filter_by_evidence_iea" { let db = @src.goa_sample_database() // IEA records: TP53 (P), Hsp70 (P) = 2 total. @@ -693,12 +738,14 @@ test "goa_filter_by_evidence_iea" { assert_eq(hits.length(), 2) } +///| test "goa_filter_by_evidence_no_match" { let db = @src.goa_sample_database() let hits = @src.goa_filter_by_evidence(db, "NONEXISTENT") assert_eq(hits.length(), 0) } +///| test "goa_filter_by_taxon_human" { let db = @src.goa_sample_database() // taxon:9606 records: PROT1 (x3), TP53 (x2), RPL5 = 6 total. @@ -706,6 +753,7 @@ test "goa_filter_by_taxon_human" { assert_eq(hits.length(), 6) } +///| test "goa_filter_by_taxon_yeast" { let db = @src.goa_sample_database() // taxon:4932 records: YFG1 (x2) = 2 total. @@ -713,6 +761,7 @@ test "goa_filter_by_taxon_yeast" { assert_eq(hits.length(), 2) } +///| test "goa_filter_by_taxon_fly" { let db = @src.goa_sample_database() // taxon:7227 records: Hsp70 (x2) = 2 total. @@ -720,12 +769,14 @@ test "goa_filter_by_taxon_fly" { assert_eq(hits.length(), 2) } +///| test "goa_filter_by_taxon_no_match" { let db = @src.goa_sample_database() let hits = @src.goa_filter_by_taxon(db, "0000000") assert_eq(hits.length(), 0) } +///| test "goa_filter_by_db_object_id" { let db = @src.goa_sample_database() // Q12345 (PROT1) has 3 records (F, P, C). @@ -737,6 +788,7 @@ test "goa_filter_by_db_object_id" { } } +///| test "goa_filter_by_db_object_id_multiple" { let db = @src.goa_sample_database() // P04637 (TP53) has 2 records (F, P). @@ -747,6 +799,7 @@ test "goa_filter_by_db_object_id_multiple" { } } +///| test "goa_filter_by_db_object_id_no_match" { let db = @src.goa_sample_database() let hits = @src.goa_filter_by_db_object_id(db, "ZZZZZZ") @@ -757,6 +810,7 @@ test "goa_filter_by_db_object_id_no_match" { // Unique value extraction // --------------------------------------------------------------------------- +///| test "goa_unique_go_ids" { let db = @src.goa_sample_database() // Every record in the sample database has a distinct GO ID. @@ -766,6 +820,7 @@ test "goa_unique_go_ids" { assert_eq(ids[0], "GO:0003674") } +///| test "goa_unique_go_ids_dedup" { // Build a database with duplicate GO IDs to test deduplication. let rec = @src.GafRecord::new( @@ -787,14 +842,17 @@ test "goa_unique_go_ids_dedup" { annotation_extension="", gene_product_form_id="", ) - let content = @src.goa_record_to_gaf_line(rec) + "\n" + - @src.goa_record_to_gaf_line(rec) + "\n" + let content = @src.goa_record_to_gaf_line(rec) + + "\n" + + @src.goa_record_to_gaf_line(rec) + + "\n" let db = @src.goa_parse(content) let ids = @src.goa_unique_go_ids(db) assert_eq(ids.length(), 1) assert_eq(ids[0], "GO:0003674") } +///| test "goa_unique_evidence_codes" { let db = @src.goa_sample_database() // Sample DB uses IDA, EXP, IEA, ISS, IPI = 5 distinct evidence codes. @@ -802,6 +860,7 @@ test "goa_unique_evidence_codes" { assert_eq(codes.length(), 5) } +///| test "goa_unique_taxon_ids" { let db = @src.goa_sample_database() // Sample DB uses 9606, 4932, 7227 = 3 distinct taxon IDs. @@ -816,6 +875,7 @@ test "goa_unique_taxon_ids" { // Count functions // --------------------------------------------------------------------------- +///| test "goa_count_by_aspect" { let db = @src.goa_sample_database() let counts = @src.goa_count_by_aspect(db) @@ -827,6 +887,7 @@ test "goa_count_by_aspect" { assert_eq(counts.get("?"), None) } +///| test "goa_count_by_aspect_empty_db" { let db = @src.GoaDatabase::new() let counts = @src.goa_count_by_aspect(db) @@ -835,6 +896,7 @@ test "goa_count_by_aspect_empty_db" { assert_eq(counts.get("C"), None) } +///| test "goa_count_by_evidence" { let db = @src.goa_sample_database() let counts = @src.goa_count_by_evidence(db) @@ -848,6 +910,7 @@ test "goa_count_by_evidence" { assert_eq(counts.get("TAS"), None) } +///| test "goa_count_by_evidence_empty_db" { let db = @src.GoaDatabase::new() let counts = @src.goa_count_by_evidence(db) @@ -858,6 +921,7 @@ test "goa_count_by_evidence_empty_db" { // Summary generation // --------------------------------------------------------------------------- +///| test "goa_to_summary_has_basic_fields" { let db = @src.goa_sample_database() let s = @src.goa_to_summary(db) @@ -867,6 +931,7 @@ test "goa_to_summary_has_basic_fields" { assert_true(s.contains("Created by: UniProt")) } +///| test "goa_to_summary_has_aspect_section" { let db = @src.goa_sample_database() let s = @src.goa_to_summary(db) @@ -876,6 +941,7 @@ test "goa_to_summary_has_aspect_section" { assert_true(s.contains("Cellular Component")) } +///| test "goa_to_summary_has_evidence_section" { let db = @src.goa_sample_database() let s = @src.goa_to_summary(db) @@ -887,6 +953,7 @@ test "goa_to_summary_has_evidence_section" { assert_true(s.contains("IPI")) } +///| test "goa_to_summary_has_unique_counts" { let db = @src.goa_sample_database() let s = @src.goa_to_summary(db) @@ -895,6 +962,7 @@ test "goa_to_summary_has_unique_counts" { assert_true(s.contains("Unique taxon IDs: 3")) } +///| test "goa_to_summary_empty_db" { let db = @src.GoaDatabase::new() let s = @src.goa_to_summary(db) @@ -906,6 +974,7 @@ test "goa_to_summary_empty_db" { // Writing functions // --------------------------------------------------------------------------- +///| test "goa_record_to_gaf_line_roundtrip" { let r = @src.GafRecord::new( db="UniProtKB", @@ -949,6 +1018,7 @@ test "goa_record_to_gaf_line_roundtrip" { assert_eq(fields[16].to_string(), "") } +///| test "goa_record_to_gaf_line_parse_roundtrip" { // Serializing and re-parsing should produce an equivalent record. let r = @src.GafRecord::new( @@ -989,6 +1059,7 @@ test "goa_record_to_gaf_line_parse_roundtrip" { } } +///| test "goa_to_gaf_includes_header" { let db = @src.goa_sample_database() let text = @src.goa_to_gaf(db) @@ -996,6 +1067,7 @@ test "goa_to_gaf_includes_header" { assert_true(text.contains("!generated-by: UniProt")) } +///| test "goa_to_gaf_includes_all_records" { let db = @src.goa_sample_database() let text = @src.goa_to_gaf(db) @@ -1012,6 +1084,7 @@ test "goa_to_gaf_includes_all_records" { assert_true(text.contains("GO:0003735")) } +///| test "goa_to_gaf_roundtrip" { // Serializing the sample database and re-parsing should preserve its // record count and metadata. @@ -1023,6 +1096,7 @@ test "goa_to_gaf_roundtrip" { assert_eq(db2.created_by(), db.created_by()) } +///| test "goa_to_gaf_empty_db" { let db = @src.GoaDatabase::new() let text = @src.goa_to_gaf(db) @@ -1036,17 +1110,20 @@ test "goa_to_gaf_empty_db" { // Sample database validation // --------------------------------------------------------------------------- +///| test "goa_sample_database_has_10_records" { let db = @src.goa_sample_database() assert_eq(db.n_records(), 10) } +///| test "goa_sample_database_metadata" { let db = @src.goa_sample_database() assert_eq(db.version(), "2.2") assert_eq(db.created_by(), "UniProt") } +///| test "goa_sample_database_has_3_aspects" { let db = @src.goa_sample_database() let counts = @src.goa_count_by_aspect(db) @@ -1055,6 +1132,7 @@ test "goa_sample_database_has_3_aspects" { assert_eq(counts.get("C"), Some(3)) } +///| test "goa_sample_database_has_3_taxa" { let db = @src.goa_sample_database() let taxa = @src.goa_unique_taxon_ids(db) @@ -1064,6 +1142,7 @@ test "goa_sample_database_has_3_taxa" { assert_true(taxa.contains("7227")) } +///| test "goa_sample_database_has_5_evidence_codes" { let db = @src.goa_sample_database() let codes = @src.goa_unique_evidence_codes(db) @@ -1075,6 +1154,7 @@ test "goa_sample_database_has_5_evidence_codes" { assert_true(codes.contains("IPI")) } +///| test "goa_sample_database_first_record" { let db = @src.goa_sample_database() let rec = db.records()[0] @@ -1087,6 +1167,7 @@ test "goa_sample_database_first_record" { assert_eq(rec.taxon(), "taxon:9606|taxon:9606") } +///| test "goa_sample_database_last_record" { let db = @src.goa_sample_database() let rec = db.records()[9] @@ -1097,6 +1178,7 @@ test "goa_sample_database_last_record" { assert_eq(rec.aspect(), "F") } +///| test "goa_sample_database_all_uniprot_db" { let db = @src.goa_sample_database() for r in db.records() { @@ -1104,6 +1186,7 @@ test "goa_sample_database_all_uniprot_db" { } } +///| test "goa_sample_database_unique_go_ids_count" { let db = @src.goa_sample_database() // Each of the 10 records has a distinct GO ID. @@ -1115,6 +1198,7 @@ test "goa_sample_database_unique_go_ids_count" { // Edge cases // --------------------------------------------------------------------------- +///| test "goa_parse_line_single_column" { // A single-column line should be padded to 17 empty fields and parsed. let r = @src.goa_parse_line("UniProtKB") @@ -1130,6 +1214,7 @@ test "goa_parse_line_single_column" { } } +///| test "goa_parse_line_extra_columns_kept_in_field" { // A line with more than 17 columns: the parser splits on all tabs and uses // only the first 17 fields; extra columns are silently ignored. @@ -1146,6 +1231,7 @@ test "goa_parse_line_extra_columns_kept_in_field" { } } +///| test "goa_parse_line_with_trailing_newline" { // Trailing whitespace/newlines are trimmed before parsing. let line = "UniProtKB\tQ12345\tPROT1\tenables\tGO:0003674\tPMID:12345\tIDA\tGO:0005515\tF\tProtein 1\tP1\tprotein\ttaxon:9606\t20210115\tUniProt\t\t\n" @@ -1160,6 +1246,7 @@ test "goa_parse_line_with_trailing_newline" { } } +///| test "goa_parse_only_comment_lines" { // A line starting with "!" is treated as a header/comment regardless of // whether it has a colon, and never produces a data record. @@ -1172,6 +1259,7 @@ test "goa_parse_only_comment_lines" { assert_eq(db.created_by(), "UniProt") } +///| test "goa_parse_mixed_valid_and_invalid_lines" { let content = "!gaf-version: 2.2\n" + "!generated-by: UniProt\n" + @@ -1188,15 +1276,20 @@ test "goa_parse_mixed_valid_and_invalid_lines" { assert_eq(db.created_by(), "UniProt") } +///| test "goa_filter_on_empty_database" { let db = @src.GoaDatabase::new() assert_eq(@src.goa_filter_by_go_id(db, "GO:0003674").length(), 0) - assert_eq(@src.goa_filter_by_aspect(db, @src.GafAspect::from_string("F")).length(), 0) + assert_eq( + @src.goa_filter_by_aspect(db, @src.GafAspect::from_string("F")).length(), + 0, + ) assert_eq(@src.goa_filter_by_evidence(db, "IDA").length(), 0) assert_eq(@src.goa_filter_by_taxon(db, "9606").length(), 0) assert_eq(@src.goa_filter_by_db_object_id(db, "Q12345").length(), 0) } +///| test "goa_unique_on_empty_database" { let db = @src.GoaDatabase::new() assert_eq(@src.goa_unique_go_ids(db).length(), 0) diff --git a/test/moonbit/gosemsim_test.mbt b/test/moonbit/gosemsim_test.mbt index 3487d49a..92b611d5 100644 --- a/test/moonbit/gosemsim_test.mbt +++ b/test/moonbit/gosemsim_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for GOSemSim GO semantic similarity module. - test "gosemsim_example_graph" { let g = @src.gosemsim_example_graph() assert_true(g.root_id == "GO:0008150") @@ -10,81 +9,152 @@ test "gosemsim_example_graph" { } } +///| test "gosemsim_term_self_similarity" { let g = @src.gosemsim_example_graph() // A term compared to itself should have maximal similarity. - let resnik = @src.gosemsim_term_sim(g, "GO:0006810", "GO:0006810", @src.resnik_measure()) + let resnik = @src.gosemsim_term_sim( + g, + "GO:0006810", + "GO:0006810", + @src.resnik_measure(), + ) assert_true(resnik > 0.0) - let lin = @src.gosemsim_term_sim(g, "GO:0006810", "GO:0006810", @src.lin_measure()) + let lin = @src.gosemsim_term_sim( + g, + "GO:0006810", + "GO:0006810", + @src.lin_measure(), + ) assert_true(lin > 0.99 && lin <= 1.0 + 1.0e-6) } +///| test "gosemsim_resnik_similarity" { let g = @src.gosemsim_example_graph() // Parent-child should have high similarity - let sim = @src.gosemsim_term_sim(g, "GO:0006810", "GO:0009987", @src.resnik_measure()) + let sim = @src.gosemsim_term_sim( + g, + "GO:0006810", + "GO:0009987", + @src.resnik_measure(), + ) assert_true(sim > 0.0) } +///| test "gosemsim_lin_similarity" { let g = @src.gosemsim_example_graph() - let sim = @src.gosemsim_term_sim(g, "GO:0006810", "GO:0007165", @src.lin_measure()) + let sim = @src.gosemsim_term_sim( + g, + "GO:0006810", + "GO:0007165", + @src.lin_measure(), + ) assert_true(sim >= 0.0 && sim <= 1.0) } +///| test "gosemsim_rel_similarity" { let g = @src.gosemsim_example_graph() - let sim = @src.gosemsim_term_sim(g, "GO:0006810", "GO:0007165", @src.rel_measure()) + let sim = @src.gosemsim_term_sim( + g, + "GO:0006810", + "GO:0007165", + @src.rel_measure(), + ) assert_true(sim >= 0.0 && sim <= 1.0) } +///| test "gosemsim_jiang_similarity" { let g = @src.gosemsim_example_graph() - let sim = @src.gosemsim_term_sim(g, "GO:0006810", "GO:0007165", @src.jiang_measure()) + let sim = @src.gosemsim_term_sim( + g, + "GO:0006810", + "GO:0007165", + @src.jiang_measure(), + ) assert_true(sim >= 0.0) } +///| test "gosemsim_wang_similarity" { let g = @src.gosemsim_example_graph() - let sim = @src.gosemsim_term_sim(g, "GO:0006810", "GO:0007165", @src.wang_measure()) + let sim = @src.gosemsim_term_sim( + g, + "GO:0006810", + "GO:0007165", + @src.wang_measure(), + ) assert_true(sim >= 0.0 && sim <= 1.0) } +///| test "gosemsim_missing_term" { let g = @src.gosemsim_example_graph() - let sim = @src.gosemsim_term_sim(g, "GO:9999999", "GO:0006810", @src.resnik_measure()) + let sim = @src.gosemsim_term_sim( + g, + "GO:9999999", + "GO:0006810", + @src.resnik_measure(), + ) assert_true(sim == 0.0) } +///| test "gosemsim_gen_sim_max" { let g = @src.gosemsim_example_graph() let go1 = ["GO:0006810", "GO:0007165"] let go2 = ["GO:0006810", "GO:0009987"] - let sim = @src.gosemsim_gen_sim(g, go1, go2, @src.resnik_measure(), combine = "max") + let sim = @src.gosemsim_gen_sim( + g, + go1, + go2, + @src.resnik_measure(), + combine="max", + ) assert_true(sim > 0.0) } +///| test "gosemsim_gen_sim_avg" { let g = @src.gosemsim_example_graph() let go1 = ["GO:0006810", "GO:0007165"] let go2 = ["GO:0006810", "GO:0009987"] - let sim = @src.gosemsim_gen_sim(g, go1, go2, @src.lin_measure(), combine = "avg") + let sim = @src.gosemsim_gen_sim( + g, + go1, + go2, + @src.lin_measure(), + combine="avg", + ) assert_true(sim >= 0.0 && sim <= 1.0) } +///| test "gosemsim_gen_sim_rcmax" { let g = @src.gosemsim_example_graph() let go1 = ["GO:0006810", "GO:0007165"] let go2 = ["GO:0006810", "GO:0009987"] - let sim = @src.gosemsim_gen_sim(g, go1, go2, @src.rel_measure(), combine = "rcmax") + let sim = @src.gosemsim_gen_sim( + g, + go1, + go2, + @src.rel_measure(), + combine="rcmax", + ) assert_true(sim >= 0.0 && sim <= 1.0) } +///| test "gosemsim_graph_operations" { let g = @src.GOGraph::new() let g1 = g.add_root("TEST:001") - let g2 = g1.add_term(@src.GOTermNode::new("TEST:001", ic = 0.0)) - let g3 = g2.add_term(@src.GOTermNode::new("TEST:002", ic = 0.5, parents = ["TEST:001"])) + let g2 = g1.add_term(@src.GOTermNode::new("TEST:001", ic=0.0)) + let g3 = g2.add_term( + @src.GOTermNode::new("TEST:002", ic=0.5, parents=["TEST:001"]), + ) match g3.get_term("TEST:002") { Some(term) => assert_true(term.ic == 0.5) None => assert_true(false) diff --git a/test/moonbit/graphics_test.mbt b/test/moonbit/graphics_test.mbt index 30cd2487..a1829d7b 100644 --- a/test/moonbit/graphics_test.mbt +++ b/test/moonbit/graphics_test.mbt @@ -1,35 +1,39 @@ ///| /// Tests for Graphics module. - test "SeqLogo creation" { let seqs = ["ATGC"] let logo = @src.SeqLogo::new(seqs) assert_eq(logo.sequences.length(), 1) } +///| test "LogoColumn creation" { let col = @src.LogoColumn::new(1) assert_eq(col.position, 1) } +///| test "AlignmentPlot creation" { let seqs = [("Seq1", "ATGC")] let plot = @src.AlignmentPlot::new(seqs) assert_eq(plot.sequences.length(), 1) } +///| test "FeaturePlot creation" { let features = [("Gene", 0, 10, "gene", "+")] let plot = @src.FeaturePlot::new(features, 100) assert_eq(plot.features.length(), 1) } +///| test "seqlogo_calculate_columns" { let seqs = ["ATGC", "ATGC"] let columns = @src.seqlogo_calculate_columns(seqs) assert_eq(columns.length(), 4) } +///| test "seqlogo_generate_ascii" { let seqs = ["ATGC", "ATGC", "ATGC"] let logo = @src.SeqLogo::new(seqs) @@ -37,6 +41,7 @@ test "seqlogo_generate_ascii" { assert_true(output.length() > 0) } +///| test "alignment_plot_generate_ascii" { let seqs = [("Human", "ATGC"), ("Mouse", "ATGC")] let plot = @src.AlignmentPlot::new(seqs) @@ -44,6 +49,7 @@ test "alignment_plot_generate_ascii" { assert_true(output.length() > 0) } +///| test "feature_plot_generate_ascii" { let features = [("Gene", 0, 10, "gene", "+")] let plot = @src.FeaturePlot::new(features, 50) @@ -51,27 +57,32 @@ test "feature_plot_generate_ascii" { assert_true(output.length() > 0) } +///| test "create_example_seqlogo" { let logo = @src.create_example_seqlogo() assert_eq(logo.sequences.length(), 10) } +///| test "create_example_alignment_plot" { let plot = @src.create_example_alignment_plot() assert_eq(plot.sequences.length(), 4) } +///| test "create_example_feature_plot" { let plot = @src.create_example_feature_plot() assert_eq(plot.features.length(), 7) } +///| test "get_default_colors" { let colors = @src.get_default_colors() assert_true(colors.contains("A")) } +///| test "get_feature_colors" { let colors = @src.get_feature_colors() assert_true(colors.contains("exon")) -} \ No newline at end of file +} diff --git a/test/moonbit/gsea_base_test.mbt b/test/moonbit/gsea_base_test.mbt index f49840ab..1e5dad4a 100644 --- a/test/moonbit/gsea_base_test.mbt +++ b/test/moonbit/gsea_base_test.mbt @@ -28,12 +28,7 @@ test "gmt_gene_set_with_annotation" { let genes = ["G1"] let ct = @src.GeneSetCollectionType::from_string("canonical") let gs = @src.GmtGeneSet::with_annotation( - "g", - "desc", - genes, - ct, - "human", - "GS123", + "g", "desc", genes, ct, "human", "GS123", ) assert_eq(gs.name, "g") assert_eq(gs.organism, "human") diff --git a/test/moonbit/gsva_test.mbt b/test/moonbit/gsva_test.mbt index 074a1ddc..5df7de2b 100644 --- a/test/moonbit/gsva_test.mbt +++ b/test/moonbit/gsva_test.mbt @@ -192,7 +192,9 @@ test "gsva_survival_analysis" { let gene_sets = @src.gsva_create_example_gene_sets() let params = @src.GSVAParams::new() let scores = @src.gsva_run(data, gene_sets, params) - let survival_time = [10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0] + let survival_time = [ + 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0, + ] let event = [1, 1, 1, 0, 0, 1, 1, 0, 1, 0] let surv = @src.gsva_survival_analysis(scores, survival_time, event) assert_eq(surv.length(), 5) @@ -204,7 +206,9 @@ test "gsva_survival_report" { let gene_sets = @src.gsva_create_example_gene_sets() let params = @src.GSVAParams::new() let scores = @src.gsva_run(data, gene_sets, params) - let survival_time = [10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0] + let survival_time = [ + 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0, + ] let event = [1, 1, 1, 0, 0, 1, 1, 0, 1, 0] let report = @src.gsva_survival_report(scores, survival_time, event) assert_true(report.length() > 0) diff --git a/test/moonbit/gviz_test.mbt b/test/moonbit/gviz_test.mbt index 0bfc0dc6..dfe06745 100644 --- a/test/moonbit/gviz_test.mbt +++ b/test/moonbit/gviz_test.mbt @@ -1,8 +1,15 @@ ///| /// Test file for Gviz module. - test "gviz_feature_creation" { - let f = @src.gviz_feature("g1", "chr1", 100, 200, @src.track_strand_forward(), "exon", "GeneA") + let f = @src.gviz_feature( + "g1", + "chr1", + 100, + 200, + @src.track_strand_forward(), + "exon", + "GeneA", + ) assert_eq(f.feature_id, "g1") assert_eq(f.chromosome, "chr1") assert_eq(f.start, 100) @@ -11,8 +18,15 @@ test "gviz_feature_creation" { assert_eq(f.label, "GeneA") } +///| test "gviz_track_creation" { - let t = @src.gviz_track("genes", @src.track_type_gene_region(), "chr1", 1000, 5000) + let t = @src.gviz_track( + "genes", + @src.track_type_gene_region(), + "chr1", + 1000, + 5000, + ) assert_eq(t.track_name, "genes") assert_eq(t.chromosome, "chr1") assert_eq(t.start, 1000) @@ -20,43 +34,129 @@ test "gviz_track_creation" { assert_eq(t.get_n_features(), 0) } +///| test "gviz_track_add_feature" { - let t = @src.gviz_track("genes", @src.track_type_gene_region(), "chr1", 1000, 5000) - t.add_feature(@src.gviz_feature("g1", "chr1", 1200, 1800, @src.track_strand_forward(), "exon", "GeneA")) - t.add_feature(@src.gviz_feature("g2", "chr1", 2000, 3500, @src.track_strand_reverse(), "exon", "GeneB")) + let t = @src.gviz_track( + "genes", + @src.track_type_gene_region(), + "chr1", + 1000, + 5000, + ) + t.add_feature( + @src.gviz_feature( + "g1", + "chr1", + 1200, + 1800, + @src.track_strand_forward(), + "exon", + "GeneA", + ), + ) + t.add_feature( + @src.gviz_feature( + "g2", + "chr1", + 2000, + 3500, + @src.track_strand_reverse(), + "exon", + "GeneB", + ), + ) assert_eq(t.get_n_features(), 2) } +///| test "gviz_track_add_data_point" { - let t = @src.gviz_track("coverage", @src.track_type_data(), "chr1", 1000, 5000) + let t = @src.gviz_track( + "coverage", + @src.track_type_data(), + "chr1", + 1000, + 5000, + ) t.add_data_point(1000, 5.0) t.add_data_point(2000, 10.0) t.add_data_point(3000, 15.0) assert_eq(t.get_n_data_points(), 3) } +///| test "gviz_track_set_color" { - let t = @src.gviz_track("track1", @src.track_type_annotation(), "chr1", 1000, 5000) + let t = @src.gviz_track( + "track1", + @src.track_type_annotation(), + "chr1", + 1000, + 5000, + ) t.set_color("red") assert_eq(t.color, "red") } +///| test "gviz_track_set_label" { - let t = @src.gviz_track("track1", @src.track_type_annotation(), "chr1", 1000, 5000) + let t = @src.gviz_track( + "track1", + @src.track_type_annotation(), + "chr1", + 1000, + 5000, + ) t.set_label("My Track") assert_eq(t.display_label, "My Track") } +///| test "gviz_track_get_features_in_region" { - let t = @src.gviz_track("genes", @src.track_type_gene_region(), "chr1", 1000, 5000) - t.add_feature(@src.gviz_feature("g1", "chr1", 1200, 1800, @src.track_strand_forward(), "exon", "A")) - t.add_feature(@src.gviz_feature("g2", "chr1", 2000, 3500, @src.track_strand_reverse(), "exon", "B")) - t.add_feature(@src.gviz_feature("g3", "chr1", 4000, 4500, @src.track_strand_forward(), "exon", "C")) + let t = @src.gviz_track( + "genes", + @src.track_type_gene_region(), + "chr1", + 1000, + 5000, + ) + t.add_feature( + @src.gviz_feature( + "g1", + "chr1", + 1200, + 1800, + @src.track_strand_forward(), + "exon", + "A", + ), + ) + t.add_feature( + @src.gviz_feature( + "g2", + "chr1", + 2000, + 3500, + @src.track_strand_reverse(), + "exon", + "B", + ), + ) + t.add_feature( + @src.gviz_feature( + "g3", + "chr1", + 4000, + 4500, + @src.track_strand_forward(), + "exon", + "C", + ), + ) let in_region = t.get_features_in_region(1500, 3000) assert_eq(in_region.length(), 2) // g1 (overlaps) and g2 } +///| test "gviz_track_get_data_in_region" { let t = @src.gviz_track("data", @src.track_type_data(), "chr1", 1000, 5000) t.add_data_point(1000, 5.0) @@ -68,6 +168,7 @@ test "gviz_track_get_data_in_region" { assert_eq(data.length(), 2) // 2000 and 3000 } +///| test "gviz_region_creation" { let r = @src.gviz_region("chr1", 1000, 5000) assert_eq(r.chromosome, "chr1") @@ -75,6 +176,7 @@ test "gviz_region_creation" { assert_eq(r.end_, 5000) } +///| test "gviz_plot_creation" { let r = @src.gviz_region("chr1", 1000, 5000) let p = @src.gviz_plot(r, title="Test Plot", width=80, height=25) @@ -82,14 +184,22 @@ test "gviz_plot_creation" { assert_eq(p.get_region().chromosome, "chr1") } +///| test "gviz_plot_add_track" { let r = @src.gviz_region("chr1", 1000, 5000) let p = @src.gviz_plot(r, title="Test") - let t = @src.gviz_track("track1", @src.track_type_annotation(), "chr1", 1000, 5000) + let t = @src.gviz_track( + "track1", + @src.track_type_annotation(), + "chr1", + 1000, + 5000, + ) p.add_track(t) assert_eq(p.get_n_tracks(), 1) } +///| test "gviz_plot_to_ascii" { let p = @src.gviz_sample_plot() let ascii = p.to_ascii() @@ -97,6 +207,7 @@ test "gviz_plot_to_ascii" { assert_true(ascii.contains("GeneRegionTrack")) } +///| test "gviz_plot_summary" { let p = @src.gviz_sample_plot() let s = p.summary() @@ -104,6 +215,7 @@ test "gviz_plot_summary" { assert_true(s.contains("chr1")) } +///| test "gviz_track_type_to_string" { assert_eq(@src.track_type_annotation().to_string(), "AnnotationTrack") assert_eq(@src.track_type_gene_region().to_string(), "GeneRegionTrack") @@ -113,12 +225,14 @@ test "gviz_track_type_to_string" { assert_eq(@src.track_type_sequence().to_string(), "SequenceTrack") } +///| test "gviz_strand_to_string" { assert_eq(@src.track_strand_forward().to_string(), "+") assert_eq(@src.track_strand_reverse().to_string(), "-") assert_eq(@src.track_strand_unstranded().to_string(), "*") } +///| test "gviz_sample_plot" { let p = @src.gviz_sample_plot() assert_true(p.get_n_tracks() >= 3) diff --git a/test/moonbit/harmony_test.mbt b/test/moonbit/harmony_test.mbt index 586d5c68..79676d9e 100644 --- a/test/moonbit/harmony_test.mbt +++ b/test/moonbit/harmony_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Harmony batch correction module. - test "harmony_create_example" { let data = @src.harmony_create_example(100, 2, 5) assert_true(data.embeddings.length() == 100) @@ -8,6 +7,7 @@ test "harmony_create_example" { assert_true(data.embeddings[0].length() == 5) } +///| test "harmony_params_default" { let params = @src.HarmonyParams::new() assert_true(params.n_clusters == 20) @@ -16,18 +16,17 @@ test "harmony_params_default" { assert_true(params.lambda > 0.0) } +///| test "harmony_run_basic" { let data = @src.harmony_create_example(50, 2, 3) - let params = @src.HarmonyParams::create( - n_clusters = 3, - max_iterations = 10, - ) + let params = @src.HarmonyParams::create(n_clusters=3, max_iterations=10) let result = @src.harmony_run(data, params) assert_true(result.corrected.length() == 50) assert_true(result.membership.length() == 50) assert_true(result.centroids.length() == 3) } +///| test "harmony_single_batch" { // Single batch should remain largely unchanged let embeddings : Array[Array[Double]] = Array::new() @@ -41,26 +40,25 @@ test "harmony_single_batch" { i = i + 1 } let data = @src.HarmonyData::new(embeddings, batch_labels, cell_ids) - let params = @src.HarmonyParams::create( - n_clusters = 2, - max_iterations = 5, - ) + let params = @src.HarmonyParams::create(n_clusters=2, max_iterations=5) let result = @src.harmony_run(data, params) assert_true(result.corrected.length() == 20) } +///| test "harmony_convergence" { let data = @src.harmony_create_example(80, 3, 4) let params = @src.HarmonyParams::create( - n_clusters = 4, - max_iterations = 30, - tolerance = 0.001, + n_clusters=4, + max_iterations=30, + tolerance=0.001, ) let result = @src.harmony_run(data, params) assert_true(result.n_iterations > 0) assert_true(result.n_iterations <= 30) } +///| test "harmony_batch_alignment" { // Two batches with different means should be aligned let embeddings : Array[Array[Double]] = Array::new() @@ -70,25 +68,21 @@ test "harmony_batch_alignment" { while i < 40 { let batch_idx = if i < 20 { 0 } else { 1 } let offset = if batch_idx == 0 { 0.0 } else { 5.0 } - embeddings.push([offset + (i.to_double() * 0.1), offset + 1.0, offset + 2.0]) + embeddings.push([offset + i.to_double() * 0.1, offset + 1.0, offset + 2.0]) batch_labels.push("batch_" + batch_idx.to_string()) cell_ids.push("cell_" + i.to_string()) i = i + 1 } let data = @src.HarmonyData::new(embeddings, batch_labels, cell_ids) - let params = @src.HarmonyParams::create( - n_clusters = 5, - max_iterations = 30, - ) + let params = @src.HarmonyParams::create(n_clusters=5, max_iterations=30) let result = @src.harmony_run(data, params) assert_true(result.corrected.length() == 40) } +///| test "harmony_empty_data" { let data = @src.HarmonyData::new([], [], []) - let params = @src.HarmonyParams::create( - n_clusters = 2, - ) + let params = @src.HarmonyParams::create(n_clusters=2) let result = @src.harmony_run(data, params) assert_true(result.corrected.length() == 0) } diff --git a/test/moonbit/hicdc_test.mbt b/test/moonbit/hicdc_test.mbt index 2195d5b7..1fa7658e 100644 --- a/test/moonbit/hicdc_test.mbt +++ b/test/moonbit/hicdc_test.mbt @@ -74,7 +74,9 @@ test "hc_sample_data_has_loops" { ///| test "hc_fit_background_returns_params" { let contacts = @src.hicdc_sample_data() - let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background(contacts) + let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background( + contacts, + ) // Parameters should be finite numbers. assert_true(!intercept.is_nan()) assert_true(!beta_dist.is_nan()) @@ -86,8 +88,12 @@ test "hc_fit_background_returns_params" { ///| test "hc_predict_expected" { let contacts = @src.hicdc_sample_data() - let (intercept, beta_dist, beta_gc, beta_map, _) = @src.hicdc_fit_background(contacts) - let expected = @src.hicdc_predict_expected(contacts, intercept, beta_dist, beta_gc, beta_map) + let (intercept, beta_dist, beta_gc, beta_map, _) = @src.hicdc_fit_background( + contacts, + ) + let expected = @src.hicdc_predict_expected( + contacts, intercept, beta_dist, beta_gc, beta_map, + ) assert_eq(expected.length(), contacts.length()) // Expected counts should be positive. for e in expected { @@ -98,11 +104,19 @@ test "hc_predict_expected" { ///| test "hc_expected_decreases_with_distance" { let contacts = @src.hicdc_sample_data() - let (intercept, beta_dist, beta_gc, beta_map, _) = @src.hicdc_fit_background(contacts) + let (intercept, beta_dist, beta_gc, beta_map, _) = @src.hicdc_fit_background( + contacts, + ) // Predict expected counts for near and far contacts. let c1 = @src.HiCContact::new("chr1", 0, 1, 10, 1) let c2 = @src.HiCContact::new("chr1", 0, 10, 10, 1) - let exp = @src.hicdc_predict_expected([c1, c2], intercept, beta_dist, beta_gc, beta_map) + let exp = @src.hicdc_predict_expected( + [c1, c2], + intercept, + beta_dist, + beta_gc, + beta_map, + ) // Both expected counts should be positive. assert_true(exp[0] > 0.0) assert_true(exp[1] > 0.0) @@ -115,9 +129,11 @@ test "hc_expected_decreases_with_distance" { ///| test "hc_test_significance_returns_results" { let contacts = @src.hicdc_sample_data() - let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background(contacts) + let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background( + contacts, + ) let results = @src.hicdc_test_significance( - contacts, intercept, beta_dist, beta_gc, beta_map, dispersion + contacts, intercept, beta_dist, beta_gc, beta_map, dispersion, ) assert_eq(results.length(), contacts.length()) // Check that p-values and FDR are valid. @@ -134,9 +150,11 @@ test "hc_test_significance_returns_results" { ///| test "hc_significant_loops_detected" { let contacts = @src.hicdc_sample_data() - let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background(contacts) + let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background( + contacts, + ) let results = @src.hicdc_test_significance( - contacts, intercept, beta_dist, beta_gc, beta_map, dispersion + contacts, intercept, beta_dist, beta_gc, beta_map, dispersion, ) let marked = @src.hicdc_mark_significant(results, 0.3) // At least some contacts should be significant with loose threshold. @@ -152,9 +170,11 @@ test "hc_significant_loops_detected" { ///| test "hc_fdr_monotonic" { let contacts = @src.hicdc_sample_data() - let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background(contacts) + let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background( + contacts, + ) let results = @src.hicdc_test_significance( - contacts, intercept, beta_dist, beta_gc, beta_map, dispersion + contacts, intercept, beta_dist, beta_gc, beta_map, dispersion, ) // FDR should be >= p_value for each result (BH inflates). for r in results { @@ -284,7 +304,10 @@ test "hc_empty_contacts" { ///| test "hc_single_contact" { let c = @src.HiCContact::new("chr1", 0, 1, 50, 1) - let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background([c]) + let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background([ + c, + ], + ) assert_true(!intercept.is_nan()) assert_true(dispersion > 0.0) } diff --git a/test/moonbit/hilbertcurve_test.mbt b/test/moonbit/hilbertcurve_test.mbt index 824b226d..c6dc61c6 100644 --- a/test/moonbit/hilbertcurve_test.mbt +++ b/test/moonbit/hilbertcurve_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for HilbertCurve module. - test "HilbertCurve creation" { let hc = @src.HilbertCurve::new(4, 2) assert_eq(hc.levels, 4) @@ -8,6 +7,7 @@ test "HilbertCurve creation" { assert_eq(hc.max_coordinate, 15) } +///| test "hilbert_encode_decode_roundtrip" { let hc = @src.HilbertCurve::new(3, 2) let coords = [3, 5] @@ -16,6 +16,7 @@ test "hilbert_encode_decode_roundtrip" { assert_eq(decoded.length(), 2) } +///| test "hilbert_distance" { let hc = @src.HilbertCurve::new(3, 2) let coord1 = [1, 2] @@ -24,17 +25,20 @@ test "hilbert_distance" { assert_true(dist >= 0) } +///| test "hilbert_point_to_segment" { let hc = @src.HilbertCurve::new(2, 2) let segments = @src.hilbert_point_to_segment(hc, 0, 3) assert_eq(segments.length(), 4) } +///| test "hilbert_linearize_genome" { let segments = @src.hilbert_linearize_genome(10, 3) assert_eq(segments.length(), 10) } +///| test "hilbert_map_to_grid" { let hc = @src.HilbertCurve::new(2, 2) let values = [1.0, 2.0, 3.0, 4.0] diff --git a/test/moonbit/hmisc_test.mbt b/test/moonbit/hmisc_test.mbt index 5f3d2b39..f6fa587b 100644 --- a/test/moonbit/hmisc_test.mbt +++ b/test/moonbit/hmisc_test.mbt @@ -16,6 +16,7 @@ test "hmisc_describe basic valid data" { assert_true(result.median > 2.9 && result.median < 3.1) } +///| test "hmisc_describe with NaN values" { let data = [1.0, @double.not_a_number, 3.0, @double.not_a_number, 5.0] let result = @src.hmisc_describe(data) @@ -26,6 +27,7 @@ test "hmisc_describe with NaN values" { assert_eq(result.max, 5.0) } +///| test "hmisc_describe empty data" { let data : Array[Double] = Array::new() let result = @src.hmisc_describe(data) @@ -37,6 +39,7 @@ test "hmisc_describe empty data" { assert_eq(result.max, 0.0) } +///| test "hmisc_describe all NaN data" { let data = [@double.not_a_number, @double.not_a_number, @double.not_a_number] let result = @src.hmisc_describe(data) @@ -46,6 +49,7 @@ test "hmisc_describe all NaN data" { assert_eq(result.sd, 0.0) } +///| test "hmisc_describe single value" { let data = [42.0] let result = @src.hmisc_describe(data) @@ -56,12 +60,14 @@ test "hmisc_describe single value" { assert_eq(result.max, 42.0) } +///| test "hmisc_describe default name" { let data = [1.0, 2.0, 3.0] let result = @src.hmisc_describe(data) assert_eq(result.name, "") } +///| test "hmisc_describe quartiles" { let data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let result = @src.hmisc_describe(data) @@ -72,6 +78,7 @@ test "hmisc_describe quartiles" { // hmisc_pearson tests +///| test "hmisc_pearson perfect positive correlation" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0] @@ -79,6 +86,7 @@ test "hmisc_pearson perfect positive correlation" { assert_true(result > 0.99 && result < 1.01) } +///| test "hmisc_pearson perfect negative correlation" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [10.0, 8.0, 6.0, 4.0, 2.0] @@ -86,6 +94,7 @@ test "hmisc_pearson perfect negative correlation" { assert_true(result < -0.99 && result > -1.01) } +///| test "hmisc_pearson no correlation" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0, 6.0, 5.0, 3.0] @@ -93,6 +102,7 @@ test "hmisc_pearson no correlation" { assert_true(result > -0.5 && result < 0.5) } +///| test "hmisc_pearson mismatched lengths" { let x = [1.0, 2.0, 3.0, 4.0] let y = [1.0, 2.0, 3.0] @@ -100,6 +110,7 @@ test "hmisc_pearson mismatched lengths" { assert_true(result.is_nan()) } +///| test "hmisc_pearson small arrays less than 3" { let x = [1.0, 2.0] let y = [3.0, 4.0] @@ -107,6 +118,7 @@ test "hmisc_pearson small arrays less than 3" { assert_true(result.is_nan()) } +///| test "hmisc_pearson constant values" { let x = [5.0, 5.0, 5.0, 5.0, 5.0] let y = [1.0, 2.0, 3.0, 4.0, 5.0] @@ -116,6 +128,7 @@ test "hmisc_pearson constant values" { // hmisc_spearman tests +///| test "hmisc_spearman perfect positive correlation" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0] @@ -123,6 +136,7 @@ test "hmisc_spearman perfect positive correlation" { assert_true(result > 0.99 && result < 1.01) } +///| test "hmisc_spearman perfect negative correlation" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [10.0, 8.0, 6.0, 4.0, 2.0] @@ -130,6 +144,7 @@ test "hmisc_spearman perfect negative correlation" { assert_true(result < -0.99 && result > -1.01) } +///| test "hmisc_spearman with ties" { let x = [1.0, 2.0, 2.0, 3.0, 4.0] let y = [2.0, 3.0, 3.0, 4.0, 5.0] @@ -137,6 +152,7 @@ test "hmisc_spearman with ties" { assert_true(result > 0.9 && result < 1.01) } +///| test "hmisc_spearman mismatched lengths" { let x = [1.0, 2.0, 3.0, 4.0] let y = [1.0, 2.0, 3.0] @@ -144,6 +160,7 @@ test "hmisc_spearman mismatched lengths" { assert_true(result.is_nan()) } +///| test "hmisc_spearman small arrays less than 3" { let x = [1.0, 2.0] let y = [3.0, 4.0] @@ -151,6 +168,7 @@ test "hmisc_spearman small arrays less than 3" { assert_true(result.is_nan()) } +///| test "hmisc_spearman monotonic but non-linear" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0] let y = [1.0, 4.0, 9.0, 16.0, 25.0, 36.0, 49.0, 64.0] @@ -160,6 +178,7 @@ test "hmisc_spearman monotonic but non-linear" { // hmisc_rcorr tests +///| test "hmisc_rcorr basic pearson correlation" { let data = [ [1.0, 2.0, 3.0, 4.0, 5.0], @@ -178,38 +197,32 @@ test "hmisc_rcorr basic pearson correlation" { assert_true(result.matrix[1][2] < -0.99) } +///| test "hmisc_rcorr basic spearman correlation" { - let data = [ - [1.0, 2.0, 3.0, 4.0, 5.0], - [2.0, 4.0, 6.0, 8.0, 10.0], - ] + let data = [[1.0, 2.0, 3.0, 4.0, 5.0], [2.0, 4.0, 6.0, 8.0, 10.0]] let result = @src.hmisc_rcorr(data, cor_type=@src.hmisc_cor_type_spearman()) assert_eq(@src.hmisc_cor_type_to_string(result.cor_type), "Spearman") assert_true(result.matrix[0][1] > 0.99) } +///| test "hmisc_rcorr with custom names" { - let data = [ - [1.0, 2.0, 3.0, 4.0, 5.0], - [2.0, 4.0, 6.0, 8.0, 10.0], - ] + let data = [[1.0, 2.0, 3.0, 4.0, 5.0], [2.0, 4.0, 6.0, 8.0, 10.0]] let result = @src.hmisc_rcorr(data, names=["Height", "Weight"]) assert_eq(result.names[0], "Height") assert_eq(result.names[1], "Weight") } +///| test "hmisc_rcorr default names" { - let data = [ - [1.0, 2.0, 3.0, 4.0], - [2.0, 4.0, 6.0, 8.0], - [3.0, 6.0, 9.0, 12.0], - ] + let data = [[1.0, 2.0, 3.0, 4.0], [2.0, 4.0, 6.0, 8.0], [3.0, 6.0, 9.0, 12.0]] let result = @src.hmisc_rcorr(data) assert_eq(result.names[0], "V1") assert_eq(result.names[1], "V2") assert_eq(result.names[2], "V3") } +///| test "hmisc_rcorr with NaN pairwise deletion" { let data = [ [1.0, 2.0, @double.not_a_number, 4.0, 5.0], @@ -222,6 +235,7 @@ test "hmisc_rcorr with NaN pairwise deletion" { assert_true(!result.matrix[1][2].is_nan()) } +///| test "hmisc_rcorr p-values computed" { let data = [ [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0], @@ -232,6 +246,7 @@ test "hmisc_rcorr p-values computed" { assert_true(result.p_values[0][1] >= 0.0 && result.p_values[0][1] <= 1.0) } +///| test "hmisc_rcorr symmetry" { let data = [ [1.0, 2.0, 3.0, 4.0, 5.0], @@ -244,11 +259,9 @@ test "hmisc_rcorr symmetry" { assert_true(result.matrix[1][2] == result.matrix[2][1]) } +///| test "hmisc_rcorr n matrix" { - let data = [ - [1.0, 2.0, 3.0, 4.0, 5.0], - [2.0, 4.0, 6.0, 8.0, 10.0], - ] + let data = [[1.0, 2.0, 3.0, 4.0, 5.0], [2.0, 4.0, 6.0, 8.0, 10.0]] let result = @src.hmisc_rcorr(data) assert_eq(result.n[0][0], 5) assert_eq(result.n[1][1], 5) @@ -258,18 +271,24 @@ test "hmisc_rcorr n matrix" { // hmisc_varclus tests +///| test "hmisc_varclus basic clustering" { let data = [ [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0], [2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0], [5.0, 4.0, 6.0, 3.0, 7.0, 5.0, 8.0, 4.0, 9.0, 6.0], ] - let result = @src.hmisc_varclus(data, names=["X", "Y", "Z"], min_cluster_size=2) + let result = @src.hmisc_varclus( + data, + names=["X", "Y", "Z"], + min_cluster_size=2, + ) assert_eq(result.names.length(), 3) assert_true(result.n_clusters >= 1) assert_eq(result.cluster_assignments.length(), 3) } +///| test "hmisc_varclus all variables in one cluster" { let data = [ [1.0, 2.0, 3.0, 4.0, 5.0], @@ -283,11 +302,9 @@ test "hmisc_varclus all variables in one cluster" { assert_eq(result.cluster_assignments[2], 0) } +///| test "hmisc_varclus with two variables" { - let data = [ - [1.0, 2.0, 3.0, 4.0, 5.0], - [2.0, 4.0, 6.0, 8.0, 10.0], - ] + let data = [[1.0, 2.0, 3.0, 4.0, 5.0], [2.0, 4.0, 6.0, 8.0, 10.0]] let result = @src.hmisc_varclus(data, names=["A", "B"]) assert_eq(result.n_clusters, 1) assert_eq(result.cluster_assignments.length(), 2) @@ -295,6 +312,7 @@ test "hmisc_varclus with two variables" { assert_eq(result.heights.length(), 0) } +///| test "hmisc_varclus merge steps" { let data = [ [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0], @@ -310,6 +328,7 @@ test "hmisc_varclus merge steps" { // hmisc_somers_d tests +///| test "hmisc_somers_d basic positive" { let g1 = [3.0, 5.0, 7.0, 9.0, 11.0] let g2 = [1.0, 2.0, 4.0, 6.0, 8.0] @@ -320,6 +339,7 @@ test "hmisc_somers_d basic positive" { assert_true(result.upper >= result.d) } +///| test "hmisc_somers_d basic negative" { let g1 = [1.0, 2.0, 3.0, 4.0, 5.0] let g2 = [4.0, 5.0, 6.0, 7.0, 8.0] @@ -327,6 +347,7 @@ test "hmisc_somers_d basic negative" { assert_true(result.d < 0.0) } +///| test "hmisc_somers_d completely separated" { let g1 = [10.0, 20.0, 30.0, 40.0, 50.0] let g2 = [1.0, 2.0, 3.0, 4.0, 5.0] @@ -334,6 +355,7 @@ test "hmisc_somers_d completely separated" { assert_true(result.d > 0.9 && result.d < 1.01) } +///| test "hmisc_somers_d equal distributions" { let g1 = [1.0, 2.0, 3.0, 4.0, 5.0] let g2 = [1.0, 2.0, 3.0, 4.0, 5.0] @@ -341,6 +363,7 @@ test "hmisc_somers_d equal distributions" { assert_true(result.d > -0.1 && result.d < 0.1) } +///| test "hmisc_somers_d empty group1" { let g1 : Array[Double] = Array::new() let g2 = [1.0, 2.0, 3.0] @@ -351,6 +374,7 @@ test "hmisc_somers_d empty group1" { assert_eq(result.n, 0) } +///| test "hmisc_somers_d empty group2" { let g1 = [1.0, 2.0, 3.0] let g2 : Array[Double] = Array::new() @@ -359,6 +383,7 @@ test "hmisc_somers_d empty group2" { assert_eq(result.n, 0) } +///| test "hmisc_somers_d confidence interval" { let g1 = [5.0, 10.0, 15.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0] let g2 = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] @@ -368,6 +393,7 @@ test "hmisc_somers_d confidence interval" { // hmisc_impute tests +///| test "hmisc_impute basic NaN imputation" { let data = [ [1.0, @double.not_a_number, 3.0], @@ -384,17 +410,16 @@ test "hmisc_impute basic NaN imputation" { assert_eq(result[1][1], 5.0) } +///| test "hmisc_impute no NaN values" { - let data = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - ] + let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let result = @src.hmisc_impute(data) assert_eq(result[0][0], 1.0) assert_eq(result[0][1], 2.0) assert_eq(result[1][2], 6.0) } +///| test "hmisc_impute all NaN column" { let data = [ [1.0, @double.not_a_number, 3.0], @@ -407,16 +432,16 @@ test "hmisc_impute all NaN column" { assert_eq(result[2][1], 0.0) } +///| test "hmisc_impute empty data" { let data : Array[Array[Double]] = Array::new() let result = @src.hmisc_impute(data) assert_eq(result.length(), 0) } +///| test "hmisc_impute single row" { - let data = [ - [1.0, @double.not_a_number, 3.0], - ] + let data = [[1.0, @double.not_a_number, 3.0]] let result = @src.hmisc_impute(data) assert_eq(result.length(), 1) assert_eq(result[0][0], 1.0) @@ -426,11 +451,9 @@ test "hmisc_impute single row" { // hmisc_rcorr_summary tests +///| test "hmisc_rcorr_summary basic formatting" { - let data = [ - [1.0, 2.0, 3.0, 4.0, 5.0], - [2.0, 4.0, 6.0, 8.0, 10.0], - ] + let data = [[1.0, 2.0, 3.0, 4.0, 5.0], [2.0, 4.0, 6.0, 8.0, 10.0]] let result = @src.hmisc_rcorr(data, names=["X", "Y"]) let summary = @src.hmisc_rcorr_summary(result) assert_true(summary.contains("Correlation Matrix")) @@ -440,18 +463,21 @@ test "hmisc_rcorr_summary basic formatting" { assert_true(summary.contains("Y")) } +///| test "hmisc_rcorr_summary spearman formatting" { - let data = [ - [1.0, 2.0, 3.0, 4.0, 5.0], - [2.0, 4.0, 6.0, 8.0, 10.0], - ] - let result = @src.hmisc_rcorr(data, names=["A", "B"], cor_type=@src.hmisc_cor_type_spearman()) + let data = [[1.0, 2.0, 3.0, 4.0, 5.0], [2.0, 4.0, 6.0, 8.0, 10.0]] + let result = @src.hmisc_rcorr( + data, + names=["A", "B"], + cor_type=@src.hmisc_cor_type_spearman(), + ) let summary = @src.hmisc_rcorr_summary(result) assert_true(summary.contains("Spearman")) } // hmisc_describe_summary tests +///| test "hmisc_describe_summary formatting" { let data = [1.0, 2.0, 3.0, 4.0, 5.0] let stats = @src.hmisc_describe(data, name="Height") @@ -466,6 +492,7 @@ test "hmisc_describe_summary formatting" { assert_true(summary.contains("Max:")) } +///| test "hmisc_describe_summary with NaN" { let data = [1.0, @double.not_a_number, 3.0] let stats = @src.hmisc_describe(data, name="Test") @@ -477,6 +504,7 @@ test "hmisc_describe_summary with NaN" { // hmisc_sample_data and hmisc_sample_names tests +///| test "hmisc_sample_data structure" { let data = @src.hmisc_sample_data() assert_eq(data.length(), 3) @@ -485,6 +513,7 @@ test "hmisc_sample_data structure" { assert_eq(data[2].length(), 10) } +///| test "hmisc_sample_data values" { let data = @src.hmisc_sample_data() assert_eq(data[0][0], 1.0) @@ -495,6 +524,7 @@ test "hmisc_sample_data values" { assert_eq(data[2][9], 6.0) } +///| test "hmisc_sample_names structure" { let names = @src.hmisc_sample_names() assert_eq(names.length(), 3) @@ -503,6 +533,7 @@ test "hmisc_sample_names structure" { assert_eq(names[2], "Z") } +///| test "hmisc_sample_data_with_describe" { let data = @src.hmisc_sample_data() let stats = @src.hmisc_describe(data[0], name="X") @@ -511,10 +542,11 @@ test "hmisc_sample_data_with_describe" { assert_eq(stats.max, 10.0) } +///| test "hmisc_sample_data_with_rcorr" { let data = @src.hmisc_sample_data() let names = @src.hmisc_sample_names() - let result = @src.hmisc_rcorr(data, names=names) + let result = @src.hmisc_rcorr(data, names~) assert_eq(result.names.length(), 3) assert_eq(result.matrix.length(), 3) assert_true(!result.matrix[0][1].is_nan()) @@ -522,16 +554,18 @@ test "hmisc_sample_data_with_rcorr" { assert_true(!result.matrix[1][2].is_nan()) } +///| test "hmisc_sample_data_with_varclus" { let data = @src.hmisc_sample_data() let names = @src.hmisc_sample_names() - let result = @src.hmisc_varclus(data, names=names) + let result = @src.hmisc_varclus(data, names~) assert_eq(result.names.length(), 3) assert_true(result.n_clusters >= 1) } // Edge case tests +///| test "hmisc_pearson with NaN values" { let x = [1.0, 2.0, @double.not_a_number, 4.0, 5.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0] @@ -539,6 +573,7 @@ test "hmisc_pearson with NaN values" { assert_true(result.is_nan()) } +///| test "hmisc_spearman with NaN values" { let x = [1.0, 2.0, @double.not_a_number, 4.0, 5.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0] @@ -546,9 +581,12 @@ test "hmisc_spearman with NaN values" { assert_true(result.is_nan()) } +///| test "hmisc_describe large dataset" { - let data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, - 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0] + let data = [ + 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, + 16.0, 17.0, 18.0, 19.0, 20.0, + ] let result = @src.hmisc_describe(data) assert_eq(result.n, 20) assert_true(result.mean > 10.0 && result.mean < 11.0) @@ -556,6 +594,7 @@ test "hmisc_describe large dataset" { assert_eq(result.max, 20.0) } +///| test "hmisc_somers_d large groups" { let g1 = [6.0, 12.0, 18.0, 24.0, 30.0, 36.0, 42.0, 48.0, 54.0, 60.0] let g2 = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] @@ -564,6 +603,7 @@ test "hmisc_somers_d large groups" { assert_true(result.d > 0.9) } +///| test "hmisc_impute preserves non-NaN values" { let data = [ [10.0, 20.0, 30.0], @@ -581,6 +621,7 @@ test "hmisc_impute preserves non-NaN values" { assert_eq(result[2][2], 90.0) } +///| test "hmisc_impute column mean computation" { let data = [ [@double.not_a_number, 10.0], @@ -592,6 +633,7 @@ test "hmisc_impute column mean computation" { assert_true(result[1][1] > 19.0 && result[1][1] < 21.0) } +///| test "hmisc_rcorr empty data" { let data : Array[Array[Double]] = Array::new() let result = @src.hmisc_rcorr(data) @@ -599,15 +641,15 @@ test "hmisc_rcorr empty data" { assert_eq(result.matrix.length(), 0) } +///| test "hmisc_varclus single variable" { - let data = [ - [1.0, 2.0, 3.0, 4.0, 5.0], - ] + let data = [[1.0, 2.0, 3.0, 4.0, 5.0]] let result = @src.hmisc_varclus(data, names=["X"]) assert_eq(result.n_clusters, 1) assert_eq(result.cluster_assignments[0], 0) } +///| test "hmisc_varclus two correlated variables" { let data = [ [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0], @@ -619,6 +661,7 @@ test "hmisc_varclus two correlated variables" { assert_true(result.n_clusters >= 1) } +///| test "hmisc_pearson_identical arrays" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [1.0, 2.0, 3.0, 4.0, 5.0] @@ -626,6 +669,7 @@ test "hmisc_pearson_identical arrays" { assert_true(result > 0.99 && result < 1.01) } +///| test "hmisc_pearson zero correlation" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0] let y = [1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0] @@ -633,6 +677,7 @@ test "hmisc_pearson zero correlation" { assert_true(result > -0.5 && result < 0.5) } +///| test "hmisc_spearman_identical arrays" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [1.0, 2.0, 3.0, 4.0, 5.0] @@ -640,6 +685,7 @@ test "hmisc_spearman_identical arrays" { assert_true(result > 0.99 && result < 1.01) } +///| test "hmisc_somers_d single element groups" { let g1 = [5.0] let g2 = [3.0] @@ -648,6 +694,7 @@ test "hmisc_somers_d single element groups" { assert_true(result.d > 0.0) } +///| test "hmisc_describe negative values" { let data = [-5.0, -3.0, -1.0, 0.0, 2.0] let result = @src.hmisc_describe(data) @@ -656,6 +703,7 @@ test "hmisc_describe negative values" { assert_true(result.mean > -1.5 && result.mean < -0.5) } +///| test "hmisc_impute all NaN row" { let data = [ [1.0, 2.0, 3.0], @@ -666,4 +714,4 @@ test "hmisc_impute all NaN row" { assert_true(!result[1][0].is_nan()) assert_true(!result[1][1].is_nan()) assert_true(!result[1][2].is_nan()) -} \ No newline at end of file +} diff --git a/test/moonbit/hmmcopy_test.mbt b/test/moonbit/hmmcopy_test.mbt index f16f6a38..0e590fc6 100644 --- a/test/moonbit/hmmcopy_test.mbt +++ b/test/moonbit/hmmcopy_test.mbt @@ -29,35 +29,20 @@ test "hc_bin_creation" { ///| test "hc_bin_default_gc_mappability" { - let b = @src.HMMcopyBin::new( - chr="chr1", - start=0, - end=1000, - reads=50, - ) + let b = @src.HMMcopyBin::new(chr="chr1", start=0, end=1000, reads=50) assert_true((b.gc - 0.5).abs() < 0.001) assert_true((b.mappability - 1.0).abs() < 0.001) } ///| test "hc_bin_width" { - let b = @src.HMMcopyBin::new( - chr="chr1", - start=1000, - end=2000, - reads=100, - ) + let b = @src.HMMcopyBin::new(chr="chr1", start=1000, end=2000, reads=100) assert_eq(b.width(), 1000) } ///| test "hc_bin_normalized_coverage" { - let b = @src.HMMcopyBin::new( - chr="chr1", - start=0, - end=500, - reads=100, - ) + let b = @src.HMMcopyBin::new(chr="chr1", start=0, end=500, reads=100) b.set_corrected_reads(200.0) let nc = b.normalized_coverage() assert_true((nc - 0.4).abs() < 0.001) @@ -65,12 +50,7 @@ test "hc_bin_normalized_coverage" { ///| test "hc_bin_zero_width_coverage" { - let b = @src.HMMcopyBin::new( - chr="chr1", - start=100, - end=100, - reads=50, - ) + let b = @src.HMMcopyBin::new(chr="chr1", start=100, end=100, reads=50) b.set_corrected_reads(75.0) // Zero width returns corrected_reads directly assert_true((b.normalized_coverage() - 75.0).abs() < 0.001) diff --git a/test/moonbit/hs_exposure_test.mbt b/test/moonbit/hs_exposure_test.mbt index 16d77421..19157284 100644 --- a/test/moonbit/hs_exposure_test.mbt +++ b/test/moonbit/hs_exposure_test.mbt @@ -3,13 +3,13 @@ test "calculate_hse_basic" { let ca = @src.PDBAtom::new("CA", 0.0, 0.0, 0.0) let cb = @src.PDBAtom::new("CB", 1.0, 0.0, 0.0) let n = @src.PDBAtom::new("N", 0.0, 1.0, 0.0) - + let all_ca : Array[@src.PDBAtom] = Array::new() all_ca.push(ca) all_ca.push(@src.PDBAtom::new("CA", 5.0, 0.0, 0.0)) all_ca.push(@src.PDBAtom::new("CA", 0.0, 5.0, 0.0)) all_ca.push(@src.PDBAtom::new("CA", 0.0, 0.0, 5.0)) - + let result = @src.calculate_hse(ca, cb, n, all_ca) assert_eq(result.residue_name, "CA") assert_true(result.hse_up >= 0.0) @@ -22,10 +22,10 @@ test "calculate_hse_single_atom" { let ca = @src.PDBAtom::new("CA", 0.0, 0.0, 0.0) let cb = @src.PDBAtom::new("CB", 1.0, 0.0, 0.0) let n = @src.PDBAtom::new("N", 0.0, 1.0, 0.0) - + let all_ca : Array[@src.PDBAtom] = Array::new() all_ca.push(ca) - + let result = @src.calculate_hse(ca, cb, n, all_ca) assert_eq(result.residue_name, "CA") } @@ -43,4 +43,4 @@ test "PDBAtom_new" { assert_eq(atom.x, 1.0) assert_eq(atom.y, 2.0) assert_eq(atom.z, 3.0) -} \ No newline at end of file +} diff --git a/test/moonbit/htsfilter_test.mbt b/test/moonbit/htsfilter_test.mbt index be78bca0..e521b590 100644 --- a/test/moonbit/htsfilter_test.mbt +++ b/test/moonbit/htsfilter_test.mbt @@ -1,16 +1,17 @@ ///| /// Tests for Bioconductor HTSFilter module - RNA-seq count filtering. - test "cpm_single_value" { let cpm = @src.hts_filter_single_cpm(1000.0, 1000000.0) assert_eq(cpm, 1000.0) } +///| test "cpm_zero_library" { let cpm = @src.hts_filter_single_cpm(1000.0, 0.0) assert_eq(cpm, 0.0) } +///| test "cpm_matrix_basic" { let counts = [[100.0, 200.0], [300.0, 400.0]] let libs = [1000000.0, 2000000.0] @@ -21,6 +22,7 @@ test "cpm_matrix_basic" { assert_true((cpm[0][0] - 100.0).abs() < 0.01) } +///| test "library_sizes" { let counts = [[10.0, 20.0, 30.0], [40.0, 50.0, 60.0]] let libs = @src.hts_filter_library_sizes(counts) @@ -30,6 +32,7 @@ test "library_sizes" { assert_true((libs[2] - 90.0).abs() < 0.01) } +///| test "filter_basic" { let (counts, groups, _) = @src.hts_filter_sample_data() let result = @src.hts_filter(counts, groups, 100.0, 2) @@ -39,6 +42,7 @@ test "filter_basic" { assert_eq(result.keep.length(), 20) } +///| test "filter_strict_threshold" { let (counts, groups, _) = @src.hts_filter_sample_data() // Very high threshold - should remove most genes @@ -46,6 +50,7 @@ test "filter_strict_threshold" { assert_true(result.n_genes_kept <= result.n_genes_input) } +///| test "filter_keep_mask" { let (counts, groups, _) = @src.hts_filter_sample_data() let result = @src.hts_filter(counts, groups, 100.0, 2) @@ -55,12 +60,15 @@ test "filter_keep_mask" { let mut i = 0 let mut true_count = 0 while i < result.keep.length() { - if result.keep[i] { true_count = true_count + 1 } + if result.keep[i] { + true_count = true_count + 1 + } i = i + 1 } assert_eq(true_count, result.n_genes_kept) } +///| test "filter_apply" { let counts = [[10.0, 20.0], [30.0, 40.0], [50.0, 60.0]] let keep = [true, false, true] @@ -70,6 +78,7 @@ test "filter_apply" { assert_eq(filtered[1][0], 50.0) } +///| test "filter_apply_names" { let names = ["A", "B", "C"] let keep = [true, false, true] @@ -79,6 +88,7 @@ test "filter_apply_names" { assert_eq(filtered[1], "C") } +///| test "filter_retention_rate" { let (counts, groups, _) = @src.hts_filter_sample_data() let result = @src.hts_filter(counts, groups, 100.0, 2) @@ -86,6 +96,7 @@ test "filter_retention_rate" { assert_true(rate >= 0.0 && rate <= 1.0) } +///| test "filter_summary" { let (counts, groups, _) = @src.hts_filter_sample_data() let result = @src.hts_filter(counts, groups, 100.0, 2) @@ -93,6 +104,7 @@ test "filter_summary" { assert_true(summary.length() > 0) } +///| test "filter_empty_counts" { let result = @src.hts_filter([], [0, 0, 1, 1], 1.0, 1) assert_eq(result.n_genes_input, 0) @@ -100,6 +112,7 @@ test "filter_empty_counts" { assert_eq(result.n_genes_removed, 0) } +///| test "filter_single_gene" { let counts = [[500.0, 600.0, 550.0, 100.0, 120.0, 110.0]] let groups = [0, 0, 0, 1, 1, 1] @@ -108,6 +121,7 @@ test "filter_single_gene" { assert_true(result.n_genes_kept <= 1) } +///| test "filter_get_keep" { let (counts, groups, _) = @src.hts_filter_sample_data() let result = @src.hts_filter(counts, groups, 100.0, 2) @@ -115,6 +129,7 @@ test "filter_get_keep" { assert_eq(keep.length(), result.keep.length()) } +///| test "cpm_zeros" { let counts = [[0.0, 0.0], [0.0, 0.0]] let libs = [1000000.0, 2000000.0] diff --git a/test/moonbit/ig_io_test.mbt b/test/moonbit/ig_io_test.mbt index 975713fb..fd33d315 100644 --- a/test/moonbit/ig_io_test.mbt +++ b/test/moonbit/ig_io_test.mbt @@ -15,9 +15,7 @@ ///| test "ig_record_new_and_accessors" { let r = @src.IgRecord::new( - "A_U455", - "HIV-1 group M subtype A", - "ATGGCAGCTGTGATGAAGCAGAGACGGGTAAGAGCTC", + "A_U455", "HIV-1 group M subtype A", "ATGGCAGCTGTGATGAAGCAGAGACGGGTAAGAGCTC", ) assert_eq(r.title(), "A_U455") assert_eq(r.comment(), "HIV-1 group M subtype A") diff --git a/test/moonbit/ihw_test.mbt b/test/moonbit/ihw_test.mbt index ba2a6ccb..efca0874 100644 --- a/test/moonbit/ihw_test.mbt +++ b/test/moonbit/ihw_test.mbt @@ -27,7 +27,10 @@ test "ihw_result_accessors" { let covs = [0.5] let result = @src.IHWResult::new(pvals, adj, weights, covs, 0.01, 3) assert_true(result.p_values()[0] > 0.009 && result.p_values()[0] < 0.011) - assert_true(result.adjusted_p_values()[0] > 0.049 && result.adjusted_p_values()[0] < 0.051) + assert_true( + result.adjusted_p_values()[0] > 0.049 && + result.adjusted_p_values()[0] < 0.051, + ) assert_true(result.weights()[0] > 1.9 && result.weights()[0] < 2.1) assert_true(result.covariates()[0] > 0.4 && result.covariates()[0] < 0.6) assert_true(result.alpha() > 0.009 && result.alpha() < 0.011) @@ -48,7 +51,11 @@ test "ihw_config_defaults" { ///| test "ihw_config_custom" { - let config = @src.IHWConfig::new(alpha=0.01, n_attempts=20, scale_type="global") + let config = @src.IHWConfig::new( + alpha=0.01, + n_attempts=20, + scale_type="global", + ) assert_true(config.alpha() > 0.009 && config.alpha() < 0.011) assert_eq(config.n_attempts(), 20) assert_eq(config.scale_type(), "global") @@ -205,7 +212,11 @@ test "ihw_with_constant_covariates" { test "ihw_with_config_global" { let pvals = [0.01, 0.04, 0.03, 0.02] let covs = [0.5, 0.3, 0.8, 0.2] - let config = @src.IHWConfig::new(alpha=0.05, n_attempts=5, scale_type="global") + let config = @src.IHWConfig::new( + alpha=0.05, + n_attempts=5, + scale_type="global", + ) let result = @src.ihw_with_config(pvals, covs, config) assert_eq(result.adjusted_p_values().length(), 4) let adj = result.adjusted_p_values() @@ -225,7 +236,11 @@ test "ihw_with_config_custom_alpha" { test "ihw_with_config_many_attempts" { let pvals = [0.001, 0.01, 0.03, 0.04, 0.5] let covs = [0.1, 0.2, 0.3, 0.4, 0.5] - let config = @src.IHWConfig::new(alpha=0.05, n_attempts=50, scale_type="local") + let config = @src.IHWConfig::new( + alpha=0.05, + n_attempts=50, + scale_type="local", + ) let result = @src.ihw_with_config(pvals, covs, config) assert_true(result.n_attempts() <= 50) } @@ -413,7 +428,7 @@ test "ihw_many_tests" { let covs : Array[Double] = Array::make(n, 0.0) let mut i = 0 while i < n { - pvals[i] = ((i + 1).to_double() / (n.to_double() + 1.0)) * 0.1 + pvals[i] = (i + 1).to_double() / (n.to_double() + 1.0) * 0.1 covs[i] = (i + 1).to_double() / n.to_double() i = i + 1 } @@ -456,4 +471,4 @@ fn count_less_than(arr : Array[Double], threshold : Double) -> Int { i = i + 1 } count -} \ No newline at end of file +} diff --git a/test/moonbit/imgt_io_test.mbt b/test/moonbit/imgt_io_test.mbt index 34b18de5..cd2f233b 100644 --- a/test/moonbit/imgt_io_test.mbt +++ b/test/moonbit/imgt_io_test.mbt @@ -18,19 +18,8 @@ ///| test "imgt_header_new_and_all_accessors" { let h = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "A*01:01:01:01", - "ORF", - "2015-03-31", - "1996-01-19", - "human", - "HLA-A", - "I", - "MHC", - "2703 bp", - " genomic-DNA", - "no comments", + "HLA00001", "A*01:01:01:01", "A*01:01:01:01", "ORF", "2015-03-31", "1996-01-19", + "human", "HLA-A", "I", "MHC", "2703 bp", " genomic-DNA", "no comments", ) assert_eq(h.accession(), "HLA00001") assert_eq(h.seq_id(), "A*01:01:01:01") @@ -50,19 +39,8 @@ test "imgt_header_new_and_all_accessors" { ///| test "imgt_header_to_string" { let h = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "A*01:01:01:01", - "ORF", - "2015-03-31", - "1996-01-19", - "human", - "HLA-A", - "I", - "MHC", - "2703 bp", - " genomic-DNA", - "", + "HLA00001", "A*01:01:01:01", "A*01:01:01:01", "ORF", "2015-03-31", "1996-01-19", + "human", "HLA-A", "I", "MHC", "2703 bp", " genomic-DNA", "", ) assert_eq( h.to_string(), @@ -73,19 +51,8 @@ test "imgt_header_to_string" { ///| test "imgt_header_to_string_all_fields_populated" { let h = @src.ImgtHeader::new( - "ACC1", - "SID1", - "ON1", - "R1", - "D1", - "D2", - "SP1", - "G1", - "IG1", - "L1", - "100 bp", - "DNA", - "C1", + "ACC1", "SID1", "ON1", "R1", "D1", "D2", "SP1", "G1", "IG1", "L1", "100 bp", + "DNA", "C1", ) let s = h.to_string() // 13 fields separated by 12 pipes. @@ -94,7 +61,9 @@ test "imgt_header_to_string_all_fields_populated" { ///| test "imgt_header_to_string_empty_fields" { - let h = @src.ImgtHeader::new("", "", "", "", "", "", "", "", "", "", "", "", "") + let h = @src.ImgtHeader::new( + "", "", "", "", "", "", "", "", "", "", "", "", "", + ) assert_eq(h.to_string(), "||||||||||||") } @@ -105,19 +74,8 @@ test "imgt_header_to_string_empty_fields" { ///| test "imgt_record_new_and_accessors" { let header = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "A*01:01:01:01", - "ORF", - "2015-03-31", - "1996-01-19", - "human", - "HLA-A", - "I", - "MHC", - "2703 bp", - " genomic-DNA", - "", + "HLA00001", "A*01:01:01:01", "A*01:01:01:01", "ORF", "2015-03-31", "1996-01-19", + "human", "HLA-A", "I", "MHC", "2703 bp", " genomic-DNA", "", ) let rec = @src.ImgtRecord::new(header, "ATGGCCGTCATGGCGCCCCGAACCCTCCTCCTC") assert_eq(rec.header().accession(), "HLA00001") @@ -127,19 +85,7 @@ test "imgt_record_new_and_accessors" { ///| test "imgt_record_id" { let header = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", + "HLA00001", "A*01:01:01:01", "", "", "", "", "", "", "", "", "", "", "", ) let rec = @src.ImgtRecord::new(header, "ACGT") assert_eq(rec.id(), "A*01:01:01:01") @@ -148,19 +94,8 @@ test "imgt_record_id" { ///| test "imgt_record_description" { let header = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "A*01:01:01:01", - "ORF", - "2015-03-31", - "1996-01-19", - "human", - "HLA-A", - "I", - "MHC", - "2703 bp", - " genomic-DNA", - "", + "HLA00001", "A*01:01:01:01", "A*01:01:01:01", "ORF", "2015-03-31", "1996-01-19", + "human", "HLA-A", "I", "MHC", "2703 bp", " genomic-DNA", "", ) let rec = @src.ImgtRecord::new(header, "ACGT") // description() returns the full pipe-separated header (without '>'). @@ -170,18 +105,7 @@ test "imgt_record_description" { ///| test "imgt_record_to_string" { let header = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "", - "", - "", - "", - "human", - "HLA-A", - "", - "", - "", - "", + "HLA00001", "A*01:01:01:01", "", "", "", "", "human", "HLA-A", "", "", "", "", "", ) let rec = @src.ImgtRecord::new(header, "ATGGCC") @@ -380,19 +304,7 @@ test "imgt_parse_no_trailing_newline" { ///| test "imgt_header_to_string_basic" { let h = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", + "HLA00001", "A*01:01:01:01", "", "", "", "", "", "", "", "", "", "", "", ) assert_eq(@src.imgt_header_to_string(h), ">HLA00001|A*01:01:01:01|||||||||||") } @@ -400,19 +312,8 @@ test "imgt_header_to_string_basic" { ///| test "imgt_header_to_string_round_trip_with_parse" { let h = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "A*01:01:01:01", - "ORF", - "2015-03-31", - "1996-01-19", - "human", - "HLA-A", - "I", - "MHC", - "2703 bp", - " genomic-DNA", - "", + "HLA00001", "A*01:01:01:01", "A*01:01:01:01", "ORF", "2015-03-31", "1996-01-19", + "human", "HLA-A", "I", "MHC", "2703 bp", " genomic-DNA", "", ) let s = @src.imgt_header_to_string(h) match @src.imgt_parse_header(s) { @@ -442,19 +343,7 @@ test "imgt_header_to_string_round_trip_with_parse" { ///| test "imgt_record_to_string_includes_header_and_sequence" { let header = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", + "HLA00001", "A*01:01:01:01", "", "", "", "", "", "", "", "", "", "", "", ) let rec = @src.ImgtRecord::new(header, "ATGGCCGTC") let s = @src.imgt_record_to_string(rec) @@ -468,7 +357,9 @@ test "imgt_record_to_string_includes_header_and_sequence" { test "imgt_record_to_string_wraps_long_sequence" { // A 120-character sequence should be wrapped into two 60-character lines. let seq = "ATGGCCGTCATGGCGCCCCGAACCCTCCTCCTGCTGCTCTCTGGGGCCCCGGGGCCCCGGGGCCCCGGATGGCCGTCATGGCGCCCCGAACCCTCCTCCTGCTGCTCTCTGGGGCCCCGGGGCCCCGGGGCCCCGG" - let header = @src.ImgtHeader::new("A", "B", "", "", "", "", "", "", "", "", "", "", "") + let header = @src.ImgtHeader::new( + "A", "B", "", "", "", "", "", "", "", "", "", "", "", + ) let rec = @src.ImgtRecord::new(header, seq) let s = @src.imgt_record_to_string(rec) // The first line is the header (starts with '>'); the next two lines are @@ -481,7 +372,9 @@ test "imgt_record_to_string_wraps_long_sequence" { ///| test "imgt_record_to_string_empty_sequence" { - let header = @src.ImgtHeader::new("A", "B", "", "", "", "", "", "", "", "", "", "", "") + let header = @src.ImgtHeader::new( + "A", "B", "", "", "", "", "", "", "", "", "", "", "", + ) let rec = @src.ImgtRecord::new(header, "") let s = @src.imgt_record_to_string(rec) // Header line followed by a newline; no sequence line content. @@ -529,7 +422,9 @@ test "imgt_n_records_empty" { ///| test "imgt_n_records_single" { - let h = @src.ImgtHeader::new("A", "B", "", "", "", "", "", "", "", "", "", "", "") + let h = @src.ImgtHeader::new( + "A", "B", "", "", "", "", "", "", "", "", "", "", "", + ) let rec = @src.ImgtRecord::new(h, "ACGT") assert_eq(@src.imgt_n_records([rec]), 1) } @@ -682,9 +577,15 @@ test "imgt_unique_genes_empty" { ///| test "imgt_unique_species_preserves_first_appearance_order" { // Create records with multiple species to verify order. - let h1 = @src.ImgtHeader::new("A", "s1", "", "", "", "", "zebra", "", "", "", "", "", "") - let h2 = @src.ImgtHeader::new("B", "s2", "", "", "", "", "mouse", "", "", "", "", "", "") - let h3 = @src.ImgtHeader::new("C", "s3", "", "", "", "", "zebra", "", "", "", "", "", "") + let h1 = @src.ImgtHeader::new( + "A", "s1", "", "", "", "", "zebra", "", "", "", "", "", "", + ) + let h2 = @src.ImgtHeader::new( + "B", "s2", "", "", "", "", "mouse", "", "", "", "", "", "", + ) + let h3 = @src.ImgtHeader::new( + "C", "s3", "", "", "", "", "zebra", "", "", "", "", "", "", + ) let recs = [ @src.ImgtRecord::new(h1, "ACGT"), @src.ImgtRecord::new(h2, "TTTT"), @@ -743,8 +644,16 @@ test "imgt_to_seq_records" { ///| test "imgt_from_seq_records" { let seq_records = [ - @src.SeqRecord::new(@src.Seq::new("ACGTACGT"), id="rec1", description="desc1"), - @src.SeqRecord::new(@src.Seq::new("TTTTGGGG"), id="rec2", description="desc2"), + @src.SeqRecord::new( + @src.Seq::new("ACGTACGT"), + id="rec1", + description="desc1", + ), + @src.SeqRecord::new( + @src.Seq::new("TTTTGGGG"), + id="rec2", + description="desc2", + ), ] let imgt_records = @src.imgt_from_seq_records(seq_records) assert_eq(imgt_records.length(), 2) @@ -867,7 +776,9 @@ test "edge_case_empty_array_write" { ///| test "edge_case_single_record" { - let h = @src.ImgtHeader::new("A", "B", "", "", "", "", "", "", "", "", "", "", "") + let h = @src.ImgtHeader::new( + "A", "B", "", "", "", "", "", "", "", "", "", "", "", + ) let rec = @src.ImgtRecord::new(h, "ACGT") let text = @src.imgt_write([rec]) let reparsed = @src.imgt_parse(text) diff --git a/test/moonbit/impute_test.mbt b/test/moonbit/impute_test.mbt index 8f03f363..6e82dc17 100644 --- a/test/moonbit/impute_test.mbt +++ b/test/moonbit/impute_test.mbt @@ -41,9 +41,7 @@ test "impute_by_col_median_basic" { ///| test "impute_locf_basic" { - let data = [ - [Double::nan(), 1.0, Double::nan(), 2.0, Double::nan()], - ] + let data = [[Double::nan(), 1.0, Double::nan(), 2.0, Double::nan()]] let imputed = @src.impute_locf(data, by_row=true) assert_true(imputed[0][0].is_nan()) assert_eq(imputed[0][2], 1.0) @@ -52,9 +50,7 @@ test "impute_locf_basic" { ///| test "impute_nocb_basic" { - let data = [ - [Double::nan(), 1.0, Double::nan(), 2.0, Double::nan()], - ] + let data = [[Double::nan(), 1.0, Double::nan(), 2.0, Double::nan()]] let imputed = @src.impute_nocb(data, by_row=true) assert_eq(imputed[0][0], 1.0) assert_eq(imputed[0][2], 2.0) @@ -63,10 +59,7 @@ test "impute_nocb_basic" { ///| test "impute_na_by_zero" { - let data = [ - [1.0, Double::nan()], - [Double::nan(), 2.0], - ] + let data = [[1.0, Double::nan()], [Double::nan(), 2.0]] let imputed = @src.impute_na_by_zero(data) assert_eq(imputed[0][1], 0.0) assert_eq(imputed[1][0], 0.0) @@ -76,10 +69,7 @@ test "impute_na_by_zero" { ///| test "impute_na_stats" { - let data = [ - [1.0, Double::nan(), 3.0], - [Double::nan(), Double::nan(), 6.0], - ] + let data = [[1.0, Double::nan(), 3.0], [Double::nan(), Double::nan(), 6.0]] let stats = @src.impute_na_stats(data) assert_eq(stats.total_rows, 2) assert_eq(stats.total_cols, 3) @@ -92,10 +82,7 @@ test "impute_na_stats" { ///| test "impute_na_summary" { - let data = [ - [1.0, Double::nan()], - [Double::nan(), 2.0], - ] + let data = [[1.0, Double::nan()], [Double::nan(), 2.0]] let stats = @src.impute_na_stats(data) let s = @src.impute_na_summary(stats) assert_true(s.contains("total NAs")) @@ -103,10 +90,7 @@ test "impute_na_summary" { ///| test "impute_by_knn_no_na" { - let data = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - ] + let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let p = @src.KNNImputeParam::new() let imputed = @src.impute_by_knn(data, p) assert_eq(imputed[0][0], 1.0) @@ -115,21 +99,14 @@ test "impute_by_knn_no_na" { ///| test "impute_by_knn_simple" { - let data = [ - [1.0, Double::nan(), 3.0], - [2.0, 5.0, 4.0], - [3.0, 6.0, 7.0], - ] + let data = [[1.0, Double::nan(), 3.0], [2.0, 5.0, 4.0], [3.0, 6.0, 7.0]] let imputed = @src.impute_by_knn_simple(data, 2) assert_true(!imputed[0][1].is_nan()) } ///| test "impute_na_mask" { - let data = [ - [1.0, Double::nan()], - [Double::nan(), 2.0], - ] + let data = [[1.0, Double::nan()], [Double::nan(), 2.0]] let mask = @src.make_na_mask(data) assert_eq(mask[0][1], true) assert_eq(mask[1][0], true) @@ -139,9 +116,7 @@ test "impute_na_mask" { ///| test "impute_by_row_median_and_min" { - let data = [ - [1.0, Double::nan(), 3.0, 100.0], - ] + let data = [[1.0, Double::nan(), 3.0, 100.0]] let med = @src.impute_by_row_median(data) assert_true(!med[0][1].is_nan()) let mn = @src.impute_by_row_min(data) diff --git a/test/moonbit/infercnv_test.mbt b/test/moonbit/infercnv_test.mbt index 7ba7e781..4cc2bf26 100644 --- a/test/moonbit/infercnv_test.mbt +++ b/test/moonbit/infercnv_test.mbt @@ -13,6 +13,7 @@ test "infercnv_gene_position_creation" { assert_eq(gp.end, 7687490) } +///| test "infercnv_ordered_genes_natural_chromosome_sort" { let genes = [ @src.gene_position("G_chr10_a", "chr10", 100, 200), @@ -31,6 +32,7 @@ test "infercnv_ordered_genes_natural_chromosome_sort" { assert_eq(og.gene_order[4].gene_id, "G_chrX_a") } +///| test "infercnv_exclude_chromosomes_filters_sex_and_mito" { let genes = [ @src.gene_position("A", "chr1", 1, 100), @@ -42,7 +44,7 @@ test "infercnv_exclude_chromosomes_filters_sex_and_mito" { let og = @src.ordered_genes(genes) let filtered = @src.exclude_chromosomes(og, ["chrX", "chrY", "chrM"]) assert_eq(filtered.n_genes, 2) - let ids = filtered.gene_order.map(fn (g) -> String { g.gene_id }) + let ids = filtered.gene_order.map(fn(g) -> String { g.gene_id }) assert_eq(ids, ["A", "C"]) } @@ -50,9 +52,10 @@ test "infercnv_exclude_chromosomes_filters_sex_and_mito" { // Log normalization // --------------------------------------------------------------------------- +///| test "infercnv_log_normalize_counts_basic" { let raw = [ - [1.0, 2.0, 7.0], // total = 10 -> per gene * 10000 + [1.0, 2.0, 7.0], // total = 10 -> per gene * 10000 ] let norm = @src.log_normalize_counts(raw, target_sum=10000.0) // first row: 1000, 2000, 7000; log2(x+1) @@ -62,6 +65,7 @@ test "infercnv_log_normalize_counts_basic" { assert_true(norm[0][2] > 12.0 && norm[0][2] < 13.0) } +///| test "infercnv_log_normalize_counts_zero_cell_preserved" { let raw = [[0.0, 0.0, 0.0]] let norm = @src.log_normalize_counts(raw) @@ -72,6 +76,7 @@ test "infercnv_log_normalize_counts_zero_cell_preserved" { // Reference method helpers // --------------------------------------------------------------------------- +///| test "infercnv_ref_method_constructors" { match @src.ref_method_global_mean() { @src.ReferenceMethod::GlobalMean => assert_true(true) @@ -88,6 +93,7 @@ test "infercnv_ref_method_constructors" { } } +///| test "infercnv_default_params_sensible" { let p = @src.default_cnv_params() assert_eq(p.window_size, 100) @@ -99,9 +105,13 @@ test "infercnv_default_params_sensible" { // Synthetic data generator // --------------------------------------------------------------------------- +///| test "infercnv_sample_data_shape" { let (input, tumour_cats, normal_cats) = @src.infercnv_sample_data( - n_tumour=20, n_normal=10, n_chr=3, n_genes_per_chr=20, + n_tumour=20, + n_normal=10, + n_chr=3, + n_genes_per_chr=20, ) assert_eq(input.n_cells, 30) assert_eq(input.n_genes, 60) @@ -117,14 +127,23 @@ test "infercnv_sample_data_shape" { // End-to-end pipeline with sample data and all reference strategies // --------------------------------------------------------------------------- +///| test "infercnv_run_pipeline_global_mean" { let (input, _tumour, _normal) = @src.infercnv_sample_data( - n_tumour=8, n_normal=6, n_chr=3, n_genes_per_chr=30, seed=1, + n_tumour=8, + n_normal=6, + n_chr=3, + n_genes_per_chr=30, + seed=1, ) let params = @src.make_cnv_params( - 11, 1.5, 0.05, @src.ref_method_global_mean(), [], + 11, + 1.5, + 0.05, + @src.ref_method_global_mean(), + [], ) - let res = @src.run_infercnv(input, params=params, excluded_chromosomes=[]) + let res = @src.run_infercnv(input, params~, excluded_chromosomes=[]) assert_eq(res.n_cells, 14) assert_eq(res.n_genes, 90) assert_eq(res.cnv_matrix.length(), 14) @@ -138,14 +157,23 @@ test "infercnv_run_pipeline_global_mean" { assert_true(n_score >= 0.0) } +///| test "infercnv_run_pipeline_reference_categories" { let (input, _tumour, normal) = @src.infercnv_sample_data( - n_tumour=10, n_normal=8, n_chr=2, n_genes_per_chr=20, seed=7, + n_tumour=10, + n_normal=8, + n_chr=2, + n_genes_per_chr=20, + seed=7, ) let params = @src.make_cnv_params( - 9, 1.5, 0.05, @src.ref_method_reference_categories(), normal, + 9, + 1.5, + 0.05, + @src.ref_method_reference_categories(), + normal, ) - let res = @src.run_infercnv(input, params=params, excluded_chromosomes=[]) + let res = @src.run_infercnv(input, params~, excluded_chromosomes=[]) assert_eq(res.n_cells, 18) assert_eq(res.n_genes, 40) let t_score = res.cluster_score("Tumour") @@ -154,17 +182,28 @@ test "infercnv_run_pipeline_reference_categories" { assert_true(t_score > n_score * 1.2) } +///| test "infercnv_run_pipeline_custom_reference" { let (input, _t, _n) = @src.infercnv_sample_data( - n_tumour=5, n_normal=4, n_chr=2, n_genes_per_chr=16, seed=99, + n_tumour=5, + n_normal=4, + n_chr=2, + n_genes_per_chr=16, + seed=99, ) // flat reference of 3.0 for all genes (for testing the path only) let ref : Array[Double] = [] - for _i in 0.. 3 boundaries @@ -203,22 +257,33 @@ test "infercnv_result_chromosome_list_matches_input" { let (chr1, s1, e1) = res.chromosome_list()[0] assert_eq(chr1, "chr1") assert_eq(s1, 0) - assert_eq(e1, 11) // 12 genes per chr, indexed 0..11 + assert_eq(e1, 11) // 12 genes per chr, indexed 0..11 } +///| test "infercnv_predict_tumour_cells_flags_tumour_like" { let (input, _t, _n) = @src.infercnv_sample_data( - n_tumour=15, n_normal=10, n_chr=3, n_genes_per_chr=30, seed=42, + n_tumour=15, + n_normal=10, + n_chr=3, + n_genes_per_chr=30, + seed=42, ) let params = @src.make_cnv_params( - 11, 1.5, 0.05, @src.ref_method_reference_categories(), ["Normal"], + 11, + 1.5, + 0.05, + @src.ref_method_reference_categories(), + ["Normal"], ) - let res = @src.run_infercnv(input, params=params, excluded_chromosomes=[]) + let res = @src.run_infercnv(input, params~, excluded_chromosomes=[]) let predicted = res.predict_tumour_cells("Normal", threshold_factor=1.3) // Majority of the tumour cells (indices 0..14) should be flagged let mut tumour_flagged = 0 for idx in predicted { - if idx < 15 { tumour_flagged = tumour_flagged + 1 } + if idx < 15 { + tumour_flagged = tumour_flagged + 1 + } } // At least 10/15 tumour cells called assert_true(tumour_flagged >= 10) diff --git a/test/moonbit/insdc_io_test.mbt b/test/moonbit/insdc_io_test.mbt index 61f1052b..8cdc3ad6 100644 --- a/test/moonbit/insdc_io_test.mbt +++ b/test/moonbit/insdc_io_test.mbt @@ -4,9 +4,7 @@ ///| test "insdc_parse_feature_table_cds" { let lines = [ - " CDS 1..100", - " /gene=\"testGene\"", - " /product=\"test protein\"", + " CDS 1..100", " /gene=\"testGene\"", " /product=\"test protein\"", " /translation=\"MKVL\"", ] let features = @src.parse_insdc_feature_table(lines) @@ -24,9 +22,7 @@ test "insdc_parse_feature_table_cds" { ///| test "insdc_parse_feature_table_gene" { let lines = [ - " gene 1..100", - " /gene=\"testGene\"", - " /locus_tag=\"TEST001\"", + " gene 1..100", " /gene=\"testGene\"", " /locus_tag=\"TEST001\"", ] let features = @src.parse_insdc_feature_table(lines) assert_eq(features.length(), 1) @@ -47,9 +43,7 @@ test "insdc_parse_feature_table_empty" { ///| test "insdc_parse_feature_table_multiline_qualifier" { let lines = [ - " CDS 1..100", - " /translation=\"MKVL", - " KLMN\"", + " CDS 1..100", " /translation=\"MKVL", " KLMN\"", ] let features = @src.parse_insdc_feature_table(lines) assert_eq(features.length(), 1) @@ -60,11 +54,8 @@ test "insdc_parse_feature_table_multiline_qualifier" { ///| test "insdc_parse_feature_table_multiple_features" { let lines = [ - " CDS 1..100", - " /gene=\"geneA\"", - " gene 1..100", - " /gene=\"geneA\"", - " /locus_tag=\"LA001\"", + " CDS 1..100", " /gene=\"geneA\"", " gene 1..100", + " /gene=\"geneA\"", " /locus_tag=\"LA001\"", ] let features = @src.parse_insdc_feature_table(lines) assert_eq(features.length(), 2) @@ -103,8 +94,7 @@ test "insdc_parse_location_with_whitespace" { ///| test "insdc_extract_feature_qualifier_missing" { let lines = [ - " CDS 1..100", - " /gene=\"testGene\"", + " CDS 1..100", " /gene=\"testGene\"", ] let features = @src.parse_insdc_feature_table(lines) let missing = @src.extract_feature_qualifier(features[0], "product") @@ -114,8 +104,7 @@ test "insdc_extract_feature_qualifier_missing" { ///| test "insdc_extract_translation_no_cds" { let lines = [ - " gene 1..100", - " /gene=\"testGene\"", + " gene 1..100", " /gene=\"testGene\"", ] let features = @src.parse_insdc_feature_table(lines) let trans = @src.extract_translation(features[0]) diff --git a/test/moonbit/internal_coords_test.mbt b/test/moonbit/internal_coords_test.mbt index af05bf6a..54528d80 100644 --- a/test/moonbit/internal_coords_test.mbt +++ b/test/moonbit/internal_coords_test.mbt @@ -80,13 +80,11 @@ test "ic_distance" { ///| test "ic_torsion_angle_creation" { - let tau = @src.TorsionAngle::new( - name="phi", - value=-0.57, - atom_names=["C", "N", "CA", "C"], - ) + let tau = @src.TorsionAngle::new(name="phi", value=-0.57, atom_names=[ + "C", "N", "CA", "C", + ]) assert_eq(tau.name, "phi") - assert_true((tau.value - (-0.57)).abs() < 1.0e-10) + assert_true((tau.value - -0.57).abs() < 1.0e-10) } ///| @@ -132,10 +130,10 @@ test "ic_add_residue_to_chain" { ///| test "ic_compute_phi" { let phi = @src.ic_compute_phi( - [0.0, 0.0, 0.0], // prev C - [1.5, 0.0, 0.0], // N - [3.0, 0.0, 0.0], // CA - [4.5, 1.0, 0.0], // C + [0.0, 0.0, 0.0], // prev C + [1.5, 0.0, 0.0], // N + [3.0, 0.0, 0.0], // CA + [4.5, 1.0, 0.0], // C ) assert_true(phi >= -@src.ic_pi() && phi <= @src.ic_pi()) } @@ -143,10 +141,10 @@ test "ic_compute_phi" { ///| test "ic_compute_psi" { let psi = @src.ic_compute_psi( - [0.0, 0.0, 0.0], // N - [1.5, 0.0, 0.0], // CA - [3.0, 0.0, 0.0], // C - [4.5, 1.0, 0.0], // next N + [0.0, 0.0, 0.0], // N + [1.5, 0.0, 0.0], // CA + [3.0, 0.0, 0.0], // C + [4.5, 1.0, 0.0], // next N ) assert_true(psi >= -@src.ic_pi() && psi <= @src.ic_pi()) } @@ -200,8 +198,8 @@ test "ic_rotamer_creation" { ///| test "ic_rotamer_library_entry" { let entry = @src.RotamerLibraryEntry::new(phi=-0.57, psi=-0.45) - assert_true((entry.phi - (-0.57)).abs() < 1.0e-10) - assert_true((entry.psi - (-0.45)).abs() < 1.0e-10) + assert_true((entry.phi - -0.57).abs() < 1.0e-10) + assert_true((entry.psi - -0.45).abs() < 1.0e-10) } ///| @@ -224,7 +222,9 @@ test "ic_chain_summary" { test "ic_ramachandran_data" { let phi_vals = [-1.0, -0.5, 0.0, 0.5, 1.0] let psi_vals = [-1.0, -0.5, 0.0, 0.5, 1.0] - let (mean_phi, mean_psi, var_phi, var_psi) = @src.ic_ramachandran_data(phi_vals, psi_vals) + let (mean_phi, mean_psi, var_phi, var_psi) = @src.ic_ramachandran_data( + phi_vals, psi_vals, + ) assert_true(mean_phi.abs() < 1.0e-10) assert_true(mean_psi.abs() < 1.0e-10) assert_true(var_phi > 0.0) @@ -242,4 +242,4 @@ test "ic_chi1_rotamers_gly" { let rotamers = @src.ic_chi1_rotamers("GLY") // GLY has one default rotamer assert_eq(rotamers.length(), 1) -} \ No newline at end of file +} diff --git a/test/moonbit/interproscan_test.mbt b/test/moonbit/interproscan_test.mbt index c9475e50..d2ce54e7 100644 --- a/test/moonbit/interproscan_test.mbt +++ b/test/moonbit/interproscan_test.mbt @@ -43,6 +43,7 @@ test "ips_record_construction" { assert_eq(r.go_terms()[1], "GO:0008150") } +///| test "ips_record_accessors_empty_go" { let empty_go : Array[String] = Array::new() let r = @src.InterproScanRecord::new( @@ -64,6 +65,7 @@ test "ips_record_accessors_empty_go" { assert_eq(r.go_terms().length(), 0) } +///| test "ips_record_to_string" { let go : Array[String] = Array::new() go.push("GO:0003674") @@ -96,20 +98,49 @@ test "ips_record_to_string" { // TSV parsing // --------------------------------------------------------------------------- +///| test "ips_parse_single_record" { let t = "\t" - let data = "sp|P12345|PROT_HUMAN" + t + "abc123" + t + "500" + t + "Pfam" + t + "PF00001" + t + "p53" + t + "1" + t + "100" + t + "150.5" + t + "T" + t + "01-Jan-2024" + t + "IPR000001" + t + "p53 domain" + t + "GO:0003674\n" + let data = "sp|P12345|PROT_HUMAN" + + t + + "abc123" + + t + + "500" + + t + + "Pfam" + + t + + "PF00001" + + t + + "p53" + + t + + "1" + + t + + "100" + + t + + "150.5" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "IPR000001" + + t + + "p53 domain" + + t + + "GO:0003674\n" let records = @src.parse_interproscan(data) assert_eq(records.length(), 1) assert_eq(records[0].protein_id(), "sp|P12345|PROT_HUMAN") } +///| test "ips_parse_multiple_records" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) assert_eq(records.length(), 8) } +///| test "ips_parse_all_fields_correct" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -132,6 +163,7 @@ test "ips_parse_all_fields_correct" { assert_eq(r.go_terms()[1], "GO:0008150") } +///| test "ips_parse_multiple_go_terms" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -147,39 +179,83 @@ test "ips_parse_multiple_go_terms" { // Edge cases // --------------------------------------------------------------------------- +///| test "ips_parse_empty_input" { let records = @src.parse_interproscan("") assert_eq(records.length(), 0) } +///| test "ips_parse_only_comments" { let data = "# InterProScan output\n# version 5.0\n# another comment\n" let records = @src.parse_interproscan(data) assert_eq(records.length(), 0) } +///| test "ips_parse_blank_lines" { let data = "\n\n \n\n" let records = @src.parse_interproscan(data) assert_eq(records.length(), 0) } +///| test "ips_parse_no_hits" { let t = "\t" - let data = "sp|P99999|NOPROT_HUMAN" + t + "xyz789" + t + "100" + t + "No hits\n" + - "sp|P12345|PROT_HUMAN" + t + "abc123" + t + "500" + t + "Pfam" + t + "PF00001" + t + "p53" + t + "1" + t + "100" + t + "150.5" + t + "T" + t + "01-Jan-2024" + t + "IPR000001" + t + "p53 domain" + t + "GO:0003674\n" + let data = "sp|P99999|NOPROT_HUMAN" + + t + + "xyz789" + + t + + "100" + + t + + "No hits\n" + + "sp|P12345|PROT_HUMAN" + + t + + "abc123" + + t + + "500" + + t + + "Pfam" + + t + + "PF00001" + + t + + "p53" + + t + + "1" + + t + + "100" + + t + + "150.5" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "IPR000001" + + t + + "p53 domain" + + t + + "GO:0003674\n" let records = @src.parse_interproscan(data) assert_eq(records.length(), 1) assert_eq(records[0].protein_id(), "sp|P12345|PROT_HUMAN") } +///| test "ips_parse_only_no_hits" { let t = "\t" - let data = "sp|P99999|NOPROT_HUMAN" + t + "xyz789" + t + "100" + t + "No hits\n" + let data = "sp|P99999|NOPROT_HUMAN" + + t + + "xyz789" + + t + + "100" + + t + + "No hits\n" let records = @src.parse_interproscan(data) assert_eq(records.length(), 0) } +///| test "ips_parse_missing_ipr" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -189,6 +265,7 @@ test "ips_parse_missing_ipr" { assert_eq(r.ipr_desc(), "") } +///| test "ips_parse_missing_go_terms" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -197,6 +274,7 @@ test "ips_parse_missing_go_terms" { assert_eq(r.go_terms().length(), 0) } +///| test "ips_parse_missing_go_terms_dash" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -205,29 +283,127 @@ test "ips_parse_missing_go_terms_dash" { assert_eq(r.go_terms().length(), 0) } +///| test "ips_parse_score_edge_cases" { let t = "\t" // Score is "-" → 0.0 - let data1 = "prot1" + t + "md5a" + t + "100" + t + "Pfam" + t + "PF01" + t + "desc" + t + "1" + t + "50" + t + "-" + t + "T" + t + "01-Jan-2024" + t + "-" + t + "-" + t + "-\n" + let data1 = "prot1" + + t + + "md5a" + + t + + "100" + + t + + "Pfam" + + t + + "PF01" + + t + + "desc" + + t + + "1" + + t + + "50" + + t + + "-" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "-" + + t + + "-" + + t + + "-\n" let r1 = @src.parse_interproscan(data1) assert_eq(r1.length(), 1) assert_eq(r1[0].score(), 0.0) // Score is "NaN" → 0.0 - let data2 = "prot2" + t + "md5b" + t + "100" + t + "Pfam" + t + "PF02" + t + "desc" + t + "1" + t + "50" + t + "NaN" + t + "T" + t + "01-Jan-2024" + t + "-" + t + "-" + t + "-\n" + let data2 = "prot2" + + t + + "md5b" + + t + + "100" + + t + + "Pfam" + + t + + "PF02" + + t + + "desc" + + t + + "1" + + t + + "50" + + t + + "NaN" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "-" + + t + + "-" + + t + + "-\n" let r2 = @src.parse_interproscan(data2) assert_eq(r2.length(), 1) assert_eq(r2[0].score(), 0.0) // Score is empty → 0.0 - let data3 = "prot3" + t + "md5c" + t + "100" + t + "Pfam" + t + "PF03" + t + "desc" + t + "1" + t + "50" + t + "" + t + "T" + t + "01-Jan-2024" + t + "-" + t + "-" + t + "-\n" + let data3 = "prot3" + + t + + "md5c" + + t + + "100" + + t + + "Pfam" + + t + + "PF03" + + t + + "desc" + + t + + "1" + + t + + "50" + + t + + "" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "-" + + t + + "-" + + t + + "-\n" let r3 = @src.parse_interproscan(data3) assert_eq(r3.length(), 1) assert_eq(r3[0].score(), 0.0) } +///| test "ips_parse_fewer_columns" { let t = "\t" // Line with only 10 columns should be padded to 14. - let data = "prot1" + t + "md5a" + t + "100" + t + "Pfam" + t + "PF01" + t + "desc" + t + "1" + t + "50" + t + "100.0" + t + "T\n" + let data = "prot1" + + t + + "md5a" + + t + + "100" + + t + + "Pfam" + + t + + "PF01" + + t + + "desc" + + t + + "1" + + t + + "50" + + t + + "100.0" + + t + + "T\n" let records = @src.parse_interproscan(data) assert_eq(records.length(), 1) assert_eq(records[0].date(), "") @@ -236,6 +412,7 @@ test "ips_parse_fewer_columns" { assert_eq(records[0].go_terms().length(), 0) } +///| test "ips_parse_tsv_alias" { // parse_interproscan and parse_interproscan_tsv should produce the same results. let data = @src.interproscan_sample_data() @@ -249,6 +426,7 @@ test "ips_parse_tsv_alias" { } } +///| test "ips_parse_skips_comment_lines_in_sample" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -264,12 +442,14 @@ test "ips_parse_skips_comment_lines_in_sample" { // Sample data validation // --------------------------------------------------------------------------- +///| test "ips_sample_data_has_8_records" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) assert_eq(records.length(), 8) } +///| test "ips_sample_data_proteins" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -280,6 +460,7 @@ test "ips_sample_data_proteins" { assert_eq(proteins[2], "sp|O15143|ABC_HUMAN") } +///| test "ips_sample_data_signatures" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -294,6 +475,7 @@ test "ips_sample_data_signatures" { // Filtering // --------------------------------------------------------------------------- +///| test "ips_filter_by_analysis_pfam" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -305,6 +487,7 @@ test "ips_filter_by_analysis_pfam" { } } +///| test "ips_filter_by_analysis_smart" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -315,6 +498,7 @@ test "ips_filter_by_analysis_smart" { } } +///| test "ips_filter_by_analysis_no_match" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -322,10 +506,13 @@ test "ips_filter_by_analysis_no_match" { assert_eq(none.length(), 0) } +///| test "ips_filter_by_protein" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) - let prot1 = @src.interproscan_filter_by_protein(records, "sp|P12345|PROT_HUMAN") + let prot1 = @src.interproscan_filter_by_protein( + records, "sp|P12345|PROT_HUMAN", + ) // P12345 has 3 records: Pfam, SMART, PROSITEPATTERNS. assert_eq(prot1.length(), 3) for r in prot1 { @@ -333,14 +520,18 @@ test "ips_filter_by_protein" { } } +///| test "ips_filter_by_protein_multiple" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) - let prot3 = @src.interproscan_filter_by_protein(records, "sp|O15143|ABC_HUMAN") + let prot3 = @src.interproscan_filter_by_protein( + records, "sp|O15143|ABC_HUMAN", + ) // O15143 has 3 records: Pfam, HAMMER, SMART. assert_eq(prot3.length(), 3) } +///| test "ips_filter_by_protein_no_match" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -348,6 +539,7 @@ test "ips_filter_by_protein_no_match" { assert_eq(none.length(), 0) } +///| test "ips_filter_on_empty_records" { let empty : Array[@src.InterproScanRecord] = Array::new() assert_eq(@src.interproscan_filter_by_analysis(empty, "Pfam").length(), 0) @@ -358,6 +550,7 @@ test "ips_filter_on_empty_records" { // Unique value extraction // --------------------------------------------------------------------------- +///| test "ips_get_unique_proteins" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -368,6 +561,7 @@ test "ips_get_unique_proteins" { assert_true(proteins.contains("sp|O15143|ABC_HUMAN")) } +///| test "ips_get_unique_signatures" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -383,12 +577,14 @@ test "ips_get_unique_signatures" { assert_true(sigs.contains("SM00150")) } +///| test "ips_get_unique_signatures_empty" { let empty : Array[@src.InterproScanRecord] = Array::new() let sigs = @src.interproscan_get_unique_signatures(empty) assert_eq(sigs.length(), 0) } +///| test "ips_get_go_terms" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -407,17 +603,71 @@ test "ips_get_go_terms" { assert_true(go.contains("GO:0044183")) } +///| test "ips_get_go_terms_empty" { let empty : Array[@src.InterproScanRecord] = Array::new() let go = @src.interproscan_get_go_terms(empty) assert_eq(go.length(), 0) } +///| test "ips_get_go_terms_dedup" { // Two records with the same GO term should produce only one entry. let t = "\t" - let data = "prot1" + t + "md5a" + t + "100" + t + "Pfam" + t + "PF01" + t + "desc" + t + "1" + t + "50" + t + "100.0" + t + "T" + t + "01-Jan-2024" + t + "IPR01" + t + "d1" + t + "GO:0003674\n" + - "prot2" + t + "md5b" + t + "200" + t + "SMART" + t + "SM01" + t + "desc" + t + "1" + t + "50" + t + "100.0" + t + "T" + t + "01-Jan-2024" + t + "IPR02" + t + "d2" + t + "GO:0003674|GO:0008150\n" + let data = "prot1" + + t + + "md5a" + + t + + "100" + + t + + "Pfam" + + t + + "PF01" + + t + + "desc" + + t + + "1" + + t + + "50" + + t + + "100.0" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "IPR01" + + t + + "d1" + + t + + "GO:0003674\n" + + "prot2" + + t + + "md5b" + + t + + "200" + + t + + "SMART" + + t + + "SM01" + + t + + "desc" + + t + + "1" + + t + + "50" + + t + + "100.0" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "IPR02" + + t + + "d2" + + t + + "GO:0003674|GO:0008150\n" let records = @src.parse_interproscan(data) let go = @src.interproscan_get_go_terms(records) assert_eq(go.length(), 2) @@ -429,6 +679,7 @@ test "ips_get_go_terms_dedup" { // Grouping // --------------------------------------------------------------------------- +///| test "ips_group_by_protein" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -448,6 +699,7 @@ test "ips_group_by_protein" { assert_eq(recs2.length(), 3) } +///| test "ips_group_by_protein_preserves_order" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -458,15 +710,43 @@ test "ips_group_by_protein_preserves_order" { assert_eq(groups[2].0, "sp|O15143|ABC_HUMAN") } +///| test "ips_group_by_protein_empty" { let empty : Array[@src.InterproScanRecord] = Array::new() let groups = @src.interproscan_group_by_protein(empty) assert_eq(groups.length(), 0) } +///| test "ips_group_by_protein_single" { let t = "\t" - let data = "prot1" + t + "md5a" + t + "100" + t + "Pfam" + t + "PF01" + t + "desc" + t + "1" + t + "50" + t + "100.0" + t + "T" + t + "01-Jan-2024" + t + "IPR01" + t + "d1" + t + "GO:0003674\n" + let data = "prot1" + + t + + "md5a" + + t + + "100" + + t + + "Pfam" + + t + + "PF01" + + t + + "desc" + + t + + "1" + + t + + "50" + + t + + "100.0" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "IPR01" + + t + + "d1" + + t + + "GO:0003674\n" let records = @src.parse_interproscan(data) let groups = @src.interproscan_group_by_protein(records) assert_eq(groups.length(), 1) @@ -478,6 +758,7 @@ test "ips_group_by_protein_single" { // Summary // --------------------------------------------------------------------------- +///| test "ips_summary_basic" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -489,6 +770,7 @@ test "ips_summary_basic" { assert_true(s.contains("Unique analyses: 5")) } +///| test "ips_summary_lists_analyses" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -500,6 +782,7 @@ test "ips_summary_lists_analyses" { assert_true(s.contains("HAMMER")) } +///| test "ips_summary_empty" { let empty : Array[@src.InterproScanRecord] = Array::new() let s = @src.interproscan_summary(empty) @@ -513,6 +796,7 @@ test "ips_summary_empty" { // Full round-trip // --------------------------------------------------------------------------- +///| test "ips_roundtrip_parse_and_filter" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -525,6 +809,7 @@ test "ips_roundtrip_parse_and_filter" { assert_true(pfam_sigs.contains("PF00003")) } +///| test "ips_roundtrip_group_and_filter" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) diff --git a/test/moonbit/isoform_switch_analyze_r_test.mbt b/test/moonbit/isoform_switch_analyze_r_test.mbt index 8a3bc66f..445bdad9 100644 --- a/test/moonbit/isoform_switch_analyze_r_test.mbt +++ b/test/moonbit/isoform_switch_analyze_r_test.mbt @@ -1,11 +1,13 @@ ///| - test "isoform_create_expression" { let isoform = @src.IsoformExpression::new( - "iso1", "gene1", [100.0, 150.0, 120.0], - [50.0, 75.0, 60.0], [40.0, 60.0, 48.0] + "iso1", + "gene1", + [100.0, 150.0, 120.0], + [50.0, 75.0, 60.0], + [40.0, 60.0, 48.0], ) - + assert_eq(isoform.isoform_id, "iso1") assert_eq(isoform.gene_id, "gene1") assert_eq(isoform.counts.length(), 3) @@ -13,63 +15,138 @@ test "isoform_create_expression" { assert_eq(isoform.fpkm.length(), 3) } +///| test "isoform_calculate_usage" { let isoform = @src.IsoformExpression::new( - "iso1", "gene1", [100.0, 150.0], [50.0, 75.0], [40.0, 60.0] + "iso1", + "gene1", + [100.0, 150.0], + [50.0, 75.0], + [40.0, 60.0], ) - + let usage = @src.bio_isoform_calculate_usage(isoform) assert_eq(usage.length(), 2) assert_eq(usage[0], 50.0) assert_eq(usage[1], 75.0) } +///| test "isoform_calculate_dpsi" { - let iso1 = @src.IsoformExpression::new("iso1", "gene1", [100.0, 200.0], [50.0, 150.0], [40.0, 120.0]) - let iso2 = @src.IsoformExpression::new("iso2", "gene1", [100.0, 50.0], [50.0, 50.0], [40.0, 40.0]) - + let iso1 = @src.IsoformExpression::new( + "iso1", + "gene1", + [100.0, 200.0], + [50.0, 150.0], + [40.0, 120.0], + ) + let iso2 = @src.IsoformExpression::new( + "iso2", + "gene1", + [100.0, 50.0], + [50.0, 50.0], + [40.0, 40.0], + ) + let dpsi = @src.bio_isoform_calculate_dpsi(iso1, iso2, [0], [1]) - + assert_true((dpsi - 0.25).abs() < 0.01) } +///| test "isoform_find_switches" { - let data = @src.SwitchAnalyzeRlist::new(["s1", "s2", "s3", "s4"], ["control", "control", "treatment", "treatment"]) - - let iso1 = @src.IsoformExpression::new("iso1", "gene1", [100.0, 100.0, 200.0, 200.0], [50.0, 50.0, 150.0, 150.0], [40.0, 40.0, 120.0, 120.0]) - let iso2 = @src.IsoformExpression::new("iso2", "gene1", [100.0, 100.0, 50.0, 50.0], [50.0, 50.0, 50.0, 50.0], [40.0, 40.0, 40.0, 40.0]) - - let data2 = data.add_isoform(iso1).add_isoform(iso2).add_gene_annotation("gene1", "Gene1") - + let data = @src.SwitchAnalyzeRlist::new(["s1", "s2", "s3", "s4"], [ + "control", "control", "treatment", "treatment", + ]) + + let iso1 = @src.IsoformExpression::new( + "iso1", + "gene1", + [100.0, 100.0, 200.0, 200.0], + [50.0, 50.0, 150.0, 150.0], + [40.0, 40.0, 120.0, 120.0], + ) + let iso2 = @src.IsoformExpression::new( + "iso2", + "gene1", + [100.0, 100.0, 50.0, 50.0], + [50.0, 50.0, 50.0, 50.0], + [40.0, 40.0, 40.0, 40.0], + ) + + let data2 = data + .add_isoform(iso1) + .add_isoform(iso2) + .add_gene_annotation("gene1", "Gene1") + let switches = @src.bio_isoform_find_switches(data2, 0.1, 0.05) - + assert_true(switches.length() >= 1) } +///| test "isoform_switch_summary" { let switches = [ - @src.IsoformSwitch::new("gene1", "Gene1", "iso1", "iso2", 0.3, 0.25, 0.001, 0.005, "isoform1_up", ["significant_isoform_switch"]), - @src.IsoformSwitch::new("gene2", "Gene2", "iso3", "iso4", -0.25, -0.2, 0.002, 0.01, "isoform2_up", ["significant_isoform_switch"]), + @src.IsoformSwitch::new( + "gene1", + "Gene1", + "iso1", + "iso2", + 0.3, + 0.25, + 0.001, + 0.005, + "isoform1_up", + ["significant_isoform_switch"], + ), + @src.IsoformSwitch::new( + "gene2", + "Gene2", + "iso3", + "iso4", + -0.25, + -0.2, + 0.002, + 0.01, + "isoform2_up", + ["significant_isoform_switch"], + ), ] - + let summary = @src.bio_isoform_switch_summary(switches) - + assert_true(summary.contains("Total switches")) assert_true(summary.contains("Gene1")) assert_true(summary.contains("Gene2")) } +///| test "isoform_plot_psi" { let data = @src.SwitchAnalyzeRlist::new(["s1", "s2"], ["control", "treatment"]) - - let iso1 = @src.IsoformExpression::new("iso1", "gene1", [100.0, 200.0], [50.0, 100.0], [40.0, 80.0]) - let iso2 = @src.IsoformExpression::new("iso2", "gene1", [100.0, 100.0], [50.0, 50.0], [40.0, 40.0]) - - let data2 = data.add_isoform(iso1).add_isoform(iso2).add_gene_annotation("gene1", "Gene1") - + + let iso1 = @src.IsoformExpression::new( + "iso1", + "gene1", + [100.0, 200.0], + [50.0, 100.0], + [40.0, 80.0], + ) + let iso2 = @src.IsoformExpression::new( + "iso2", + "gene1", + [100.0, 100.0], + [50.0, 50.0], + [40.0, 40.0], + ) + + let data2 = data + .add_isoform(iso1) + .add_isoform(iso2) + .add_gene_annotation("gene1", "Gene1") + let plot = @src.bio_isoform_plot_psi(data2, "gene1") - + assert_true(plot.contains("Gene1")) assert_true(plot.contains("iso1")) assert_true(plot.contains("iso2")) -} \ No newline at end of file +} diff --git a/test/moonbit/karyoploter_test.mbt b/test/moonbit/karyoploter_test.mbt index fee420d6..52655080 100644 --- a/test/moonbit/karyoploter_test.mbt +++ b/test/moonbit/karyoploter_test.mbt @@ -1,12 +1,12 @@ ///| /// Test file for karyoploteR module. - test "karyotype_new" { let plot = @src.KaryotypePlot::new("hg38") assert_eq(plot.get_genome(), "hg38") assert_true(plot.get_chromosomes().length() > 0) } +///| test "karyotype_chromosomes" { let plot = @src.KaryotypePlot::new("hg38") let chroms = plot.get_chromosomes() @@ -15,42 +15,71 @@ test "karyotype_chromosomes" { assert_true(chroms.contains("chrY")) } +///| test "karyotype_chromosome_size" { let plot = @src.KaryotypePlot::new("hg38") let size = plot.get_chromosome_size("chr1") assert_eq(size, 248956422) } +///| test "karyotype_unknown_chromosome" { let plot = @src.KaryotypePlot::new("hg38") let size = plot.get_chromosome_size("chrUnknown") assert_eq(size, 0) } +///| test "karyotype_add_track" { let plot = @src.KaryotypePlot::new("hg38") - let track = @src.KaryotypeTrack::new("t1", @src.track_type_points(), "chr1", 0, 248956422, "Test Track") + let track = @src.KaryotypeTrack::new( + "t1", + @src.track_type_points(), + "chr1", + 0, + 248956422, + "Test Track", + ) let plot2 = plot.add_track(track) assert_eq(plot2.get_n_tracks(), 1) } +///| test "karyotype_add_region" { let plot = @src.KaryotypePlot::new("hg38") - let region = @src.KaryotypeRegion::new("chr1", 1000000, 2000000, "Region 1", "#FF0000") + let region = @src.KaryotypeRegion::new( + "chr1", 1000000, 2000000, "Region 1", "#FF0000", + ) let plot2 = plot.add_region(region) assert_eq(plot2.get_n_regions(), 1) } +///| test "track_new" { - let track = @src.KaryotypeTrack::new("t1", @src.track_type_points(), "chr1", 0, 1000000, "My Track") + let track = @src.KaryotypeTrack::new( + "t1", + @src.track_type_points(), + "chr1", + 0, + 1000000, + "My Track", + ) assert_eq(track.track_id, "t1") assert_eq(track.chromosome, "chr1") assert_eq(track.start, 0) assert_eq(track.end, 1000000) } +///| test "track_add_point" { - let track = @src.KaryotypeTrack::new("t1", @src.track_type_points(), "chr1", 0, 1000000, "Test") + let track = @src.KaryotypeTrack::new( + "t1", + @src.track_type_points(), + "chr1", + 0, + 1000000, + "Test", + ) let point = @src.TrackPoint::new("chr1", 500000, 0.8, "peak") let track2 = track.add_point(point) assert_eq(track2.get_n_points(), 1) @@ -58,20 +87,44 @@ test "track_add_point" { assert_eq(data[0].position, 500000) } +///| test "track_set_color" { - let track = @src.KaryotypeTrack::new("t1", @src.track_type_points(), "chr1", 0, 1000000, "Test") + let track = @src.KaryotypeTrack::new( + "t1", + @src.track_type_points(), + "chr1", + 0, + 1000000, + "Test", + ) let track2 = track.set_color("#FF0000") assert_eq(track2.color, "#FF0000") } +///| test "track_set_y_range" { - let track = @src.KaryotypeTrack::new("t1", @src.track_type_points(), "chr1", 0, 1000000, "Test") + let track = @src.KaryotypeTrack::new( + "t1", + @src.track_type_points(), + "chr1", + 0, + 1000000, + "Test", + ) let track2 = track.set_y_range(0.0, 2.0) assert_eq(track2.y_max, 2.0) } +///| test "track_filter_chromosome" { - let track = @src.KaryotypeTrack::new("t1", @src.track_type_points(), "chr1", 0, 248956422, "Test") + let track = @src.KaryotypeTrack::new( + "t1", + @src.track_type_points(), + "chr1", + 0, + 248956422, + "Test", + ) let p1 = @src.TrackPoint::new("chr1", 1000000, 0.5, "") let p2 = @src.TrackPoint::new("chr2", 2000000, 0.8, "") let track2 = track.add_point(p1) @@ -80,6 +133,7 @@ test "track_filter_chromosome" { assert_eq(filtered.get_n_points(), 1) } +///| test "track_point_new" { let pt = @src.TrackPoint::new("chr1", 500000, 0.75, "test_point") assert_eq(pt.chromosome, "chr1") @@ -88,19 +142,24 @@ test "track_point_new" { assert_eq(pt.label, "test_point") } +///| test "karyotype_region_new" { - let region = @src.KaryotypeRegion::new("chr1", 1000, 2000, "Region", "#FF0000") + let region = @src.KaryotypeRegion::new( + "chr1", 1000, 2000, "Region", "#FF0000", + ) assert_eq(region.chromosome, "chr1") assert_eq(region.start, 1000) assert_eq(region.end, 2000) } +///| test "ideogram_band_new" { let band = @src.IdeogramBand::new("chr1", 0, 5000000, "p36.3", "gneg") assert_eq(band.chromosome, "chr1") assert_eq(band.band_name, "p36.3") } +///| test "track_type_to_string" { assert_eq(@src.track_type_points().to_string(), "points") assert_eq(@src.track_type_lines().to_string(), "lines") @@ -109,6 +168,7 @@ test "track_type_to_string" { assert_eq(@src.track_type_ideogram().to_string(), "ideogram") } +///| test "karyotype_to_ascii" { let plot = @src.karyotype_sample() let ascii = plot.to_ascii("chr1", 60) @@ -117,6 +177,7 @@ test "karyotype_to_ascii" { assert_true(ascii.contains("chr1")) } +///| test "karyotype_summary" { let plot = @src.karyotype_sample() let summary = plot.summary() @@ -125,12 +186,14 @@ test "karyotype_summary" { assert_true(summary.contains("chr1")) } +///| test "karyotype_unknown_genome" { let plot = @src.KaryotypePlot::new("mm10") assert_eq(plot.get_genome(), "mm10") assert_eq(plot.get_chromosomes().length(), 0) } +///| test "karyotype_sample" { let plot = @src.karyotype_sample() assert_true(plot.get_n_tracks() >= 2) @@ -138,8 +201,9 @@ test "karyotype_sample" { assert_eq(plot.get_genome(), "hg38") } +///| test "karyotype_ascii_unknown_chr" { let plot = @src.karyotype_sample() let ascii = plot.to_ascii("chr99", 60) assert_true(ascii.contains("not found")) -} \ No newline at end of file +} diff --git a/test/moonbit/kgml_test.mbt b/test/moonbit/kgml_test.mbt index c9077458..75078a22 100644 --- a/test/moonbit/kgml_test.mbt +++ b/test/moonbit/kgml_test.mbt @@ -19,6 +19,7 @@ test "kgml_graphics_creation" { assert_eq(g.bgcolor(), "#BFFFBF") } +///| test "kgml_entry_creation" { let e = @src.KgmlEntry::new(1, "ko:K00844", "gene") assert_eq(e.id(), 1) @@ -30,12 +31,14 @@ test "kgml_entry_creation" { assert_eq(e.components().length(), 0) } +///| test "kgml_subtype_creation" { let st = @src.KgmlSubType::new("compound", "C00118") assert_eq(st.name(), "compound") assert_eq(st.value(), "C00118") } +///| test "kgml_relation_creation" { let r = @src.KgmlRelation::new(1, 2, "ECrel") assert_eq(r.entry1(), 1) @@ -44,6 +47,7 @@ test "kgml_relation_creation" { assert_eq(r.subtypes().length(), 0) } +///| test "kgml_reaction_creation" { let rxn = @src.KgmlReaction::new("rn:R01786", "irreversible") assert_eq(rxn.name(), "rn:R01786") @@ -52,6 +56,7 @@ test "kgml_reaction_creation" { assert_eq(rxn.products().length(), 0) } +///| test "kgml_pathway_creation" { let p = @src.KgmlPathway::new("path:ko00010", "ko", "00010", "Glycolysis") assert_eq(p.name(), "path:ko00010") @@ -69,6 +74,7 @@ test "kgml_pathway_creation" { // XML parsing // --------------------------------------------------------------------------- +///| test "kgml_parse_basic_pathway" { let xml = @src.kgml_sample_pathway() let pw = @src.parse_kgml(xml) @@ -82,6 +88,7 @@ test "kgml_parse_basic_pathway" { assert_true(p.link().length() > 0) } +///| test "kgml_parse_entries" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -103,6 +110,7 @@ test "kgml_parse_entries" { assert_eq(e5.etype(), "map") } +///| test "kgml_parse_entry_graphics" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -120,6 +128,7 @@ test "kgml_parse_entry_graphics" { assert_eq(gfx.bgcolor(), "#BFFFBF") } +///| test "kgml_parse_relations" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -133,6 +142,7 @@ test "kgml_parse_relations" { assert_eq(r1.subtypes()[0].value(), "C00118") } +///| test "kgml_parse_reactions" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -152,11 +162,13 @@ test "kgml_parse_reactions" { assert_eq(r2.products().length(), 2) } +///| test "kgml_parse_invalid_returns_none" { let result = @src.parse_kgml("not a kgml file") assert_true(result.is_none()) } +///| test "kgml_parse_empty_returns_none" { let result = @src.parse_kgml("") assert_true(result.is_none()) @@ -166,6 +178,7 @@ test "kgml_parse_empty_returns_none" { // Query methods // --------------------------------------------------------------------------- +///| test "kgml_get_entry_by_id" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -176,6 +189,7 @@ test "kgml_get_entry_by_id" { assert_true(none.is_none()) } +///| test "kgml_get_entries_by_type" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -187,6 +201,7 @@ test "kgml_get_entries_by_type" { assert_eq(maps.length(), 1) } +///| test "kgml_get_relations_for_entry" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -205,6 +220,7 @@ test "kgml_get_relations_for_entry" { // Serialization // --------------------------------------------------------------------------- +///| test "kgml_to_string_roundtrip" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -222,6 +238,7 @@ test "kgml_to_string_roundtrip" { assert_eq(p2u.reactions().length(), p.reactions().length()) } +///| test "kgml_to_string_contains_pathway_tag" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -231,6 +248,7 @@ test "kgml_to_string_contains_pathway_tag" { assert_true(s.contains("")) } +///| test "kgml_to_string_contains_entries" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -240,6 +258,7 @@ test "kgml_to_string_contains_entries" { assert_true(s.contains("cpd:C00118")) } +///| test "kgml_to_string_contains_relations" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -249,6 +268,7 @@ test "kgml_to_string_contains_relations" { assert_true(s.contains(" @src.SpatialExperiment { ignore( @src.se_add_col( experiment, - Map( - [ - ("cellID", cell.cell_id), - ("imageID", cell.image_id), - ("cellType", cell.cell_type), - ], - ), + Map([ + ("cellID", cell.cell_id), + ("imageID", cell.image_id), + ("cellType", cell.cell_type), + ]), ), ) ignore( @@ -117,16 +115,12 @@ fn lisa_test_experiment() -> @src.SpatialExperiment { ///| test "lisaClust: curve and window helpers expose both modes" { - assert_true( - @src.lisa_k_curve() is @src.LisaCurveKind::LisaStandardizedK, - ) + assert_true(@src.lisa_k_curve() is @src.LisaCurveKind::LisaStandardizedK) assert_true(@src.lisa_l_curve() is @src.LisaCurveKind::LisaCenteredL) assert_true( @src.lisa_rectangle_window() is @src.LisaWindowKind::LisaRectangle, ) - assert_true( - @src.lisa_convex_window() is @src.LisaWindowKind::LisaConvexHull, - ) + assert_true(@src.lisa_convex_window() is @src.LisaWindowKind::LisaConvexHull) } ///| @@ -328,13 +322,7 @@ test "lisaClust: cell constructor validates identifiers" { test "lisaClust: cell constructor rejects non-finite coordinates" { let failed = try { ignore( - @src.LisaCell::create( - "cell", - "image", - "A", - @double.not_a_number, - 0.0, - ), + @src.LisaCell::create("cell", "image", "A", @double.not_a_number, 0.0), ) false } catch { @@ -345,10 +333,7 @@ test "lisaClust: cell constructor rejects non-finite coordinates" { ///| test "lisaClust: curve matrix exposes stable dimensions and names" { - let curves = @src.lisa_curves( - lisa_test_cells(), - config=lisa_test_config(), - ) catch { + let curves = @src.lisa_curves(lisa_test_cells(), config=lisa_test_config()) catch { _ => abort("lisaClust curves should compute") } assert_eq(curves.n_cells(), 8) @@ -361,10 +346,7 @@ test "lisaClust: curve matrix exposes stable dimensions and names" { ///| test "lisaClust: feature lookup follows target-major radius order" { - let curves = @src.lisa_curves( - lisa_test_cells(), - config=lisa_test_config(), - ) catch { + let curves = @src.lisa_curves(lisa_test_cells(), config=lisa_test_config()) catch { _ => abort("lisaClust curves should compute") } assert_eq(curves.feature_index("A", 1.5), 0) @@ -554,16 +536,10 @@ test "lisaClust: KDE weighting changes curves under inhomogeneous density" { ) catch { _ => abort("broad KDE configuration should be valid") } - let narrow_curves = @src.lisa_curves( - lisa_test_exact_cells(), - config=narrow, - ) catch { + let narrow_curves = @src.lisa_curves(lisa_test_exact_cells(), config=narrow) catch { _ => abort("narrow KDE curves should compute") } - let broad_curves = @src.lisa_curves( - lisa_test_exact_cells(), - config=broad, - ) catch { + let broad_curves = @src.lisa_curves(lisa_test_exact_cells(), config=broad) catch { _ => abort("broad KDE curves should compute") } let feature = narrow_curves.feature_index("B", 2.0) @@ -591,10 +567,7 @@ test "lisaClust: generated curves are finite" { ///| test "lisaClust: curve lookup returns a defensive copy" { - let curves = @src.lisa_curves( - lisa_test_cells(), - config=lisa_test_config(), - ) catch { + let curves = @src.lisa_curves(lisa_test_cells(), config=lisa_test_config()) catch { _ => abort("lisaClust curves should compute") } let curve = match curves.curve_for_cell("a1") { @@ -762,10 +735,7 @@ test "lisaClust: region enrichment uses observed over independence expectation" ///| test "lisaClust: top enrichments are sorted and filtered" { let result = lisa_test_result() - let top = result.top_enrichments( - limit=3, - minimum_relative_frequency=0.0, - ) catch { + let top = result.top_enrichments(limit=3, minimum_relative_frequency=0.0) catch { _ => abort("top enrichments should succeed") } assert_eq(top.length(), 3) @@ -803,10 +773,7 @@ test "lisaClust: summary reports cells features and regions" { ///| test "lisaClust: cluster count cannot exceed cells" { - let curves = @src.lisa_curves( - lisa_test_cells(), - config=lisa_test_config(), - ) catch { + let curves = @src.lisa_curves(lisa_test_cells(), config=lisa_test_config()) catch { _ => abort("lisaClust curves should compute") } let config = lisa_test_config(n_clusters=9) @@ -939,10 +906,7 @@ test "lisaClust: SpatialExperiment rejects coordinate mismatch" { ignore(experiment.spatial_coords.pop()) let failed = try { ignore( - @src.lisaclust_spatial_experiment( - experiment, - config=lisa_test_config(), - ), + @src.lisaclust_spatial_experiment(experiment, config=lisa_test_config()), ) false } catch { @@ -957,10 +921,7 @@ test "lisaClust: SpatialExperiment rejects missing required columns" { ignore(experiment.col_data[0].remove("cellType")) let failed = try { ignore( - @src.lisaclust_spatial_experiment( - experiment, - config=lisa_test_config(), - ), + @src.lisaclust_spatial_experiment(experiment, config=lisa_test_config()), ) false } catch { diff --git a/test/moonbit/lowess_test.mbt b/test/moonbit/lowess_test.mbt index 958cd3a7..b39e9c8d 100644 --- a/test/moonbit/lowess_test.mbt +++ b/test/moonbit/lowess_test.mbt @@ -22,7 +22,7 @@ test "lowess_tricube_weight_above_one" { ///| test "lowess_tricube_weight_at_half" { let result = @src.lowess_tricube_weight(0.5) - let expected = (1.0 - 0.5 * 0.5 * 0.5) + let expected = 1.0 - 0.5 * 0.5 * 0.5 let expected_cubed = expected * expected * expected assert_true((result - expected_cubed).abs() < 0.001) } @@ -54,7 +54,7 @@ test "lowess_bisquare_weight_above_one" { ///| test "lowess_bisquare_weight_at_half" { let result = @src.lowess_bisquare_weight(0.5) - let expected = (1.0 - 0.5 * 0.5) + let expected = 1.0 - 0.5 * 0.5 let expected_squared = expected * expected assert_true((result - expected_squared).abs() < 0.001) } @@ -99,7 +99,9 @@ test "lowess_weighted_linear_regression_weighted" { let y = [1.0, 3.0, 5.0, 7.0] let w = [1.0, 1.0, 1.0, 1.0] let (intercept, slope) = @src.lowess_weighted_linear_regression(x, y, w) - let (intercept2, slope2) = @src.lowess_weighted_linear_regression(x, y, [2.0, 2.0, 2.0, 2.0]) + let (intercept2, slope2) = @src.lowess_weighted_linear_regression(x, y, [ + 2.0, 2.0, 2.0, 2.0, + ]) assert_true((intercept - intercept2).abs() < 0.001) assert_true((slope - slope2).abs() < 0.001) } @@ -113,7 +115,11 @@ test "lowess_weighted_linear_regression_empty" { ///| test "lowess_weighted_linear_regression_single_point" { - let (intercept, slope) = @src.lowess_weighted_linear_regression([1.0], [5.0], [1.0]) + let (intercept, slope) = @src.lowess_weighted_linear_regression( + [1.0], + [5.0], + [1.0], + ) assert_eq(intercept, 5.0) assert_eq(slope, 0.0) } diff --git a/test/moonbit/ma_align_test.mbt b/test/moonbit/ma_align_test.mbt index 1199d1f9..3fa6fe44 100644 --- a/test/moonbit/ma_align_test.mbt +++ b/test/moonbit/ma_align_test.mbt @@ -20,7 +20,11 @@ test "ma_aligner_with_params" { ///| test "add_structure" { let a = @src.ma_aligner_new() - let coords : Array[(Double, Double, Double)] = [(1.0, 2.0, 3.0), (4.0, 5.0, 6.0), (7.0, 8.0, 9.0)] + let coords : Array[(Double, Double, Double)] = [ + (1.0, 2.0, 3.0), + (4.0, 5.0, 6.0), + (7.0, 8.0, 9.0), + ] let seq = "ALA" let res = ["ALA", "LEU", "ALA"] let s = @src.add_structure(a, "struct1", coords, seq, res) @@ -31,7 +35,11 @@ test "add_structure" { ///| test "ma_center_coordinates" { - let coords : Array[(Double, Double, Double)] = [(1.0, 2.0, 3.0), (4.0, 5.0, 6.0), (7.0, 8.0, 9.0)] + let coords : Array[(Double, Double, Double)] = [ + (1.0, 2.0, 3.0), + (4.0, 5.0, 6.0), + (7.0, 8.0, 9.0), + ] let centered = @src.ma_center_coordinates(coords) assert_eq(centered.length(), 3) let mut sum_x = 0.0 @@ -51,8 +59,16 @@ test "ma_center_coordinates" { ///| test "ma_compute_distance_matrix" { - let coords1 : Array[(Double, Double, Double)] = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (0.0, 1.0, 0.0)] - let coords2 : Array[(Double, Double, Double)] = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (0.0, 1.0, 0.0)] + let coords1 : Array[(Double, Double, Double)] = [ + (0.0, 0.0, 0.0), + (1.0, 0.0, 0.0), + (0.0, 1.0, 0.0), + ] + let coords2 : Array[(Double, Double, Double)] = [ + (0.0, 0.0, 0.0), + (1.0, 0.0, 0.0), + (0.0, 1.0, 0.0), + ] let dm = @src.ma_compute_distance_matrix(coords1, coords2) assert_eq(dm.length(), 3) assert_eq(dm[0].length(), 3) @@ -60,30 +76,51 @@ test "ma_compute_distance_matrix" { ///| test "ma_align_pairwise_identical" { - let coords : Array[(Double, Double, Double)] = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)] + let coords : Array[(Double, Double, Double)] = [ + (1.0, 0.0, 0.0), + (0.0, 1.0, 0.0), + (0.0, 0.0, 1.0), + ] let (rotation, rmsd) = @src.ma_align_pairwise(coords, coords) assert_true(rmsd < 0.01) } ///| test "ma_align_pairwise_different_scale" { - let coords1 : Array[(Double, Double, Double)] = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)] - let coords2 : Array[(Double, Double, Double)] = [(2.0, 0.0, 0.0), (0.0, 2.0, 0.0), (0.0, 0.0, 2.0)] + let coords1 : Array[(Double, Double, Double)] = [ + (1.0, 0.0, 0.0), + (0.0, 1.0, 0.0), + (0.0, 0.0, 1.0), + ] + let coords2 : Array[(Double, Double, Double)] = [ + (2.0, 0.0, 0.0), + (0.0, 2.0, 0.0), + (0.0, 0.0, 2.0), + ] let (rotation, rmsd) = @src.ma_align_pairwise(coords1, coords2) assert_true(rmsd < 5.0) } ///| test "compute_rmsd_identical" { - let coords : Array[(Double, Double, Double)] = [(1.0, 2.0, 3.0), (4.0, 5.0, 6.0)] + let coords : Array[(Double, Double, Double)] = [ + (1.0, 2.0, 3.0), + (4.0, 5.0, 6.0), + ] let rmsd = @src.compute_rmsd(coords, coords) assert_true(rmsd < 0.01) } ///| test "compute_rmsd_different" { - let coords1 : Array[(Double, Double, Double)] = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0)] - let coords2 : Array[(Double, Double, Double)] = [(10.0, 0.0, 0.0), (11.0, 0.0, 0.0)] + let coords1 : Array[(Double, Double, Double)] = [ + (0.0, 0.0, 0.0), + (1.0, 0.0, 0.0), + ] + let coords2 : Array[(Double, Double, Double)] = [ + (10.0, 0.0, 0.0), + (11.0, 0.0, 0.0), + ] let rmsd = @src.compute_rmsd(coords1, coords2) assert_true(rmsd > 5.0) } @@ -91,7 +128,11 @@ test "compute_rmsd_different" { ///| test "align_structures_single" { let a = @src.ma_aligner_new() - let coords : Array[(Double, Double, Double)] = [(1.0, 2.0, 3.0), (4.0, 5.0, 6.0), (7.0, 8.0, 9.0)] + let coords : Array[(Double, Double, Double)] = [ + (1.0, 2.0, 3.0), + (4.0, 5.0, 6.0), + (7.0, 8.0, 9.0), + ] let seq = "ALA" let res = ["ALA", "LEU", "ALA"] let s = @src.add_structure(a, "s1", coords, seq, res) @@ -102,8 +143,16 @@ test "align_structures_single" { ///| test "align_structures_two" { let a = @src.ma_aligner_new() - let coords1 : Array[(Double, Double, Double)] = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (0.0, 1.0, 0.0)] - let coords2 : Array[(Double, Double, Double)] = [(10.0, 10.0, 0.0), (11.0, 10.0, 0.0), (10.0, 11.0, 0.0)] + let coords1 : Array[(Double, Double, Double)] = [ + (0.0, 0.0, 0.0), + (1.0, 0.0, 0.0), + (0.0, 1.0, 0.0), + ] + let coords2 : Array[(Double, Double, Double)] = [ + (10.0, 10.0, 0.0), + (11.0, 10.0, 0.0), + (10.0, 11.0, 0.0), + ] let s1 = @src.add_structure(a, "s1", coords1, "AAA", ["ALA", "ALA", "ALA"]) let s2 = @src.add_structure(a, "s2", coords2, "BBB", ["ALA", "ALA", "ALA"]) let result = @src.align_structures(a, [s1, s2]) @@ -141,8 +190,16 @@ test "build_conservation_profile_different" { ///| test "get_conservation" { let a = @src.ma_aligner_new() - let coords1 : Array[(Double, Double, Double)] = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (0.0, 1.0, 0.0)] - let coords2 : Array[(Double, Double, Double)] = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (0.0, 1.0, 0.0)] + let coords1 : Array[(Double, Double, Double)] = [ + (0.0, 0.0, 0.0), + (1.0, 0.0, 0.0), + (0.0, 1.0, 0.0), + ] + let coords2 : Array[(Double, Double, Double)] = [ + (0.0, 0.0, 0.0), + (1.0, 0.0, 0.0), + (0.0, 1.0, 0.0), + ] let s1 = @src.add_structure(a, "s1", coords1, "AAA", ["ALA", "ALA", "ALA"]) let s2 = @src.add_structure(a, "s2", coords2, "AAA", ["ALA", "ALA", "ALA"]) let result = @src.align_structures(a, [s1, s2]) @@ -153,8 +210,14 @@ test "get_conservation" { ///| test "get_rmsd_matrix" { let a = @src.ma_aligner_new() - let coords1 : Array[(Double, Double, Double)] = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0)] - let coords2 : Array[(Double, Double, Double)] = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0)] + let coords1 : Array[(Double, Double, Double)] = [ + (0.0, 0.0, 0.0), + (1.0, 0.0, 0.0), + ] + let coords2 : Array[(Double, Double, Double)] = [ + (0.0, 0.0, 0.0), + (1.0, 0.0, 0.0), + ] let s1 = @src.add_structure(a, "s1", coords1, "AA", ["ALA", "ALA"]) let s2 = @src.add_structure(a, "s2", coords2, "AA", ["ALA", "ALA"]) let result = @src.align_structures(a, [s1, s2]) @@ -166,8 +229,11 @@ test "get_rmsd_matrix" { ///| test "apply_rotation_identity" { - let coords : Array[(Double, Double, Double)] = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0)] + let coords : Array[(Double, Double, Double)] = [ + (1.0, 0.0, 0.0), + (0.0, 1.0, 0.0), + ] let identity : (Double, Double, Double) = (0.0, 0.0, 0.0) let _result = @src.apply_rotation(coords, identity) assert_true(true) -} \ No newline at end of file +} diff --git a/test/moonbit/maf_test.mbt b/test/moonbit/maf_test.mbt index 1b81bc96..cc38054e 100644 --- a/test/moonbit/maf_test.mbt +++ b/test/moonbit/maf_test.mbt @@ -137,12 +137,12 @@ test "maf_alignment_total_length" { let seq1 = @src.new_maf_sequence("seq1", 0, 10, "+", 100, "ACGTACGTAC") block1 = @src.maf_block_add_seq(block1, seq1) ali = @src.maf_add_block(ali, block1) - + let mut block2 = @src.new_maf_block() let seq2 = @src.new_maf_sequence("seq1", 10, 5, "+", 100, "GTACG") block2 = @src.maf_block_add_seq(block2, seq2) ali = @src.maf_add_block(ali, block2) - + assert_eq(@src.maf_total_length(ali), 15) } @@ -156,7 +156,7 @@ test "maf_alignment_seq_names" { block = @src.maf_block_add_seq(block, seq1) block = @src.maf_block_add_seq(block, seq2) ali = @src.maf_add_block(ali, block) - + let names = @src.maf_all_seq_names(ali) assert_eq(names.length(), 2) assert_true(names.contains("human.chr1")) @@ -224,13 +224,19 @@ test "maf_select_seqs" { /// Test maf_filter_by_length. test "maf_filter_by_length" { let mut ali = @src.new_maf_alignment() - + let mut block1 = @src.new_maf_block() block1 = @src.maf_block_set_score(block1, Some(100.0)) - block1 = @src.maf_block_add_seq(block1, @src.new_maf_sequence("s1", 0, 100, "+", 1000, "ACGTACGTACGTACGTACGT")) - block1 = @src.maf_block_add_seq(block1, @src.new_maf_sequence("s2", 0, 100, "+", 1000, "ACGTACGTACGTACGTACGT")) + block1 = @src.maf_block_add_seq( + block1, + @src.new_maf_sequence("s1", 0, 100, "+", 1000, "ACGTACGTACGTACGTACGT"), + ) + block1 = @src.maf_block_add_seq( + block1, + @src.new_maf_sequence("s2", 0, 100, "+", 1000, "ACGTACGTACGTACGTACGT"), + ) ali = @src.maf_add_block(ali, block1) - + let filtered = @src.maf_filter_by_length(ali, 5) assert_eq(@src.maf_num_blocks(filtered), 1) } @@ -241,10 +247,16 @@ test "maf_stats" { let mut ali = @src.new_maf_alignment() let mut block = @src.new_maf_block() block = @src.maf_block_set_score(block, Some(100.0)) - block = @src.maf_block_add_seq(block, @src.new_maf_sequence("s1", 0, 10, "+", 1000, "ACGTACGTAC")) - block = @src.maf_block_add_seq(block, @src.new_maf_sequence("s2", 0, 10, "+", 1000, "ACGTACGTAC")) + block = @src.maf_block_add_seq( + block, + @src.new_maf_sequence("s1", 0, 10, "+", 1000, "ACGTACGTAC"), + ) + block = @src.maf_block_add_seq( + block, + @src.new_maf_sequence("s2", 0, 10, "+", 1000, "ACGTACGTAC"), + ) ali = @src.maf_add_block(ali, block) - + let stats = @src.maf_compute_stats(ali) assert_eq(stats.num_blocks, 1) assert_eq(stats.total_length, 10) @@ -284,21 +296,33 @@ test "maf_strand_info" { /// Test maf_merge_blocks. test "maf_merge_blocks" { let mut ali = @src.new_maf_alignment() - + let mut block1 = @src.new_maf_block() block1 = @src.maf_block_set_score(block1, Some(50.0)) - block1 = @src.maf_block_add_seq(block1, @src.new_maf_sequence("s1", 0, 5, "+", 1000, "ACGTG")) - block1 = @src.maf_block_add_seq(block1, @src.new_maf_sequence("s2", 0, 5, "+", 1000, "ACGTG")) - + block1 = @src.maf_block_add_seq( + block1, + @src.new_maf_sequence("s1", 0, 5, "+", 1000, "ACGTG"), + ) + block1 = @src.maf_block_add_seq( + block1, + @src.new_maf_sequence("s2", 0, 5, "+", 1000, "ACGTG"), + ) + let mut block2 = @src.new_maf_block() block2 = @src.maf_block_set_score(block2, Some(30.0)) - block2 = @src.maf_block_add_seq(block2, @src.new_maf_sequence("s1", 5, 5, "+", 1000, "TGCAC")) - block2 = @src.maf_block_add_seq(block2, @src.new_maf_sequence("s2", 5, 5, "+", 1000, "TGCAC")) - + block2 = @src.maf_block_add_seq( + block2, + @src.new_maf_sequence("s1", 5, 5, "+", 1000, "TGCAC"), + ) + block2 = @src.maf_block_add_seq( + block2, + @src.new_maf_sequence("s2", 5, 5, "+", 1000, "TGCAC"), + ) + ali = @src.maf_add_block(ali, block1) ali = @src.maf_add_block(ali, block2) - + let merged = @src.maf_merge_blocks(ali) // Should merge blocks with same sequences assert_true(@src.maf_num_blocks(merged) <= @src.maf_num_blocks(ali)) -} \ No newline at end of file +} diff --git a/test/moonbit/maftools_test.mbt b/test/moonbit/maftools_test.mbt index 54ff0f48..70a502e6 100644 --- a/test/moonbit/maftools_test.mbt +++ b/test/moonbit/maftools_test.mbt @@ -1,16 +1,9 @@ ///| test "maftools_create_mutation" { let mutation = @src.MAFMutation::new( - "TP53", - "chr17", - 7577121, - 7577121, - "C", - "T", - "Sample1", - "Missense_Mutation" + "TP53", "chr17", 7577121, 7577121, "C", "T", "Sample1", "Missense_Mutation", ) - + assert_eq(mutation.hugo_symbol, "TP53") assert_eq(mutation.chromosome, "chr17") assert_eq(mutation.start_position, 7577121) @@ -24,16 +17,9 @@ test "maftools_create_mutation" { ///| test "maftools_snv_detection" { let snv = @src.MAFMutation::new( - "TP53", - "chr17", - 7577121, - 7577121, - "C", - "T", - "Sample1", - "Missense_Mutation" + "TP53", "chr17", 7577121, 7577121, "C", "T", "Sample1", "Missense_Mutation", ) - + assert_true(snv.is_snv()) assert_false(snv.is_indel()) assert_false(snv.is_complex()) @@ -42,16 +28,9 @@ test "maftools_snv_detection" { ///| test "maftools_indel_detection" { let insertion = @src.MAFMutation::new( - "BRCA1", - "chr17", - 43091134, - 43091135, - "CT", - "CTT", - "Sample1", - "Frame_Shift_Ins" + "BRCA1", "chr17", 43091134, 43091135, "CT", "CTT", "Sample1", "Frame_Shift_Ins", ) - + assert_false(insertion.is_snv()) assert_true(insertion.is_indel()) assert_false(insertion.is_complex()) @@ -60,16 +39,9 @@ test "maftools_indel_detection" { ///| test "maftools_transition_detection" { let transition = @src.MAFMutation::new( - "TP53", - "chr17", - 7577121, - 7577121, - "C", - "T", - "Sample1", - "Missense_Mutation" + "TP53", "chr17", 7577121, 7577121, "C", "T", "Sample1", "Missense_Mutation", ) - + assert_true(transition.is_transition()) assert_false(transition.is_transversion()) } @@ -77,16 +49,9 @@ test "maftools_transition_detection" { ///| test "maftools_transversion_detection" { let transversion = @src.MAFMutation::new( - "TP53", - "chr17", - 7577121, - 7577121, - "C", - "A", - "Sample1", - "Missense_Mutation" + "TP53", "chr17", 7577121, 7577121, "C", "A", "Sample1", "Missense_Mutation", ) - + assert_false(transversion.is_transition()) assert_true(transversion.is_transversion()) } @@ -94,32 +59,18 @@ test "maftools_transversion_detection" { ///| test "maftools_maf_data_operations" { let mut maf = @src.MAFData::new() - + let mutation1 = @src.MAFMutation::new( - "TP53", - "chr17", - 7577121, - 7577121, - "C", - "T", - "Sample1", - "Missense_Mutation" + "TP53", "chr17", 7577121, 7577121, "C", "T", "Sample1", "Missense_Mutation", ) - + let mutation2 = @src.MAFMutation::new( - "BRCA1", - "chr17", - 43091134, - 43091134, - "A", - "G", - "Sample2", - "Nonsense_Mutation" + "BRCA1", "chr17", 43091134, 43091134, "A", "G", "Sample2", "Nonsense_Mutation", ) - + maf = maf.add_mutation(mutation1) maf = maf.add_mutation(mutation2) - + assert_eq(maf.count_mutations(), 2) assert_eq(maf.count_unique_genes(), 2) assert_eq(maf.count_unique_samples(), 2) @@ -128,32 +79,18 @@ test "maftools_maf_data_operations" { ///| test "maftools_filter_genes" { let mut maf = @src.MAFData::new() - + let mutation1 = @src.MAFMutation::new( - "TP53", - "chr17", - 7577121, - 7577121, - "C", - "T", - "Sample1", - "Missense_Mutation" + "TP53", "chr17", 7577121, 7577121, "C", "T", "Sample1", "Missense_Mutation", ) - + let mutation2 = @src.MAFMutation::new( - "BRCA1", - "chr17", - 43091134, - 43091134, - "A", - "G", - "Sample2", - "Nonsense_Mutation" + "BRCA1", "chr17", 43091134, 43091134, "A", "G", "Sample2", "Nonsense_Mutation", ) - + maf = maf.add_mutation(mutation1) maf = maf.add_mutation(mutation2) - + let filtered = maf.filter_genes(["TP53"]) assert_eq(filtered.count_mutations(), 1) assert_eq(filtered.count_unique_genes(), 1) @@ -162,32 +99,18 @@ test "maftools_filter_genes" { ///| test "maftools_filter_samples" { let mut maf = @src.MAFData::new() - + let mutation1 = @src.MAFMutation::new( - "TP53", - "chr17", - 7577121, - 7577121, - "C", - "T", - "Sample1", - "Missense_Mutation" + "TP53", "chr17", 7577121, 7577121, "C", "T", "Sample1", "Missense_Mutation", ) - + let mutation2 = @src.MAFMutation::new( - "BRCA1", - "chr17", - 43091134, - 43091134, - "A", - "G", - "Sample2", - "Nonsense_Mutation" + "BRCA1", "chr17", 43091134, 43091134, "A", "G", "Sample2", "Nonsense_Mutation", ) - + maf = maf.add_mutation(mutation1) maf = maf.add_mutation(mutation2) - + let filtered = maf.filter_samples(["Sample1"]) assert_eq(filtered.count_mutations(), 1) } @@ -195,46 +118,25 @@ test "maftools_filter_samples" { ///| test "maftools_mutation_spectrum" { let mut maf = @src.MAFData::new() - + let snv1 = @src.MAFMutation::new( - "TP53", - "chr17", - 7577121, - 7577121, - "C", - "T", - "Sample1", - "Missense_Mutation" + "TP53", "chr17", 7577121, 7577121, "C", "T", "Sample1", "Missense_Mutation", ) - + let snv2 = @src.MAFMutation::new( - "BRCA1", - "chr17", - 43091134, - 43091134, - "A", - "G", - "Sample1", - "Missense_Mutation" + "BRCA1", "chr17", 43091134, 43091134, "A", "G", "Sample1", "Missense_Mutation", ) - + let indel = @src.MAFMutation::new( - "EGFR", - "chr7", - 55086714, - 55086715, - "CT", - "CTT", - "Sample2", - "Frame_Shift_Ins" + "EGFR", "chr7", 55086714, 55086715, "CT", "CTT", "Sample2", "Frame_Shift_Ins", ) - + maf = maf.add_mutation(snv1) maf = maf.add_mutation(snv2) maf = maf.add_mutation(indel) - + let spectrum = @src.calculate_mutation_spectrum(maf) - + assert_eq(spectrum.snv_count, 2) assert_eq(spectrum.indel_count, 1) assert_eq(spectrum.complex_count, 0) @@ -243,7 +145,7 @@ test "maftools_mutation_spectrum" { ///| test "maftools_tmb_calculation" { let mut maf = @src.MAFData::new() - + let mut i = 0 while i < 100 { let mutation = @src.MAFMutation::new( @@ -254,17 +156,17 @@ test "maftools_tmb_calculation" { "C", "T", "Sample1", - "Missense_Mutation" + "Missense_Mutation", ) maf = maf.add_mutation(mutation) i = i + 1 } - + let tmb_result = @src.calculate_tmb(maf, 3.0e7) - + assert_eq(tmb_result.total_mutations, 100) assert_eq(tmb_result.coding_region_size, 3.0e7) - + // TMB should be 100 / 30000000 = 0.00000333... let expected_tmb = 100.0 / 3.0e7 let diff = tmb_result.tmb - expected_tmb @@ -274,19 +176,35 @@ test "maftools_tmb_calculation" { ///| test "maftools_co_occurrence_analysis" { let mut maf = @src.MAFData::new() - + // Sample1 has both TP53 and BRCA1 mutations - maf = maf.add_mutation(@src.MAFMutation::new("TP53", "chr17", 100, 100, "C", "T", "Sample1", "Missense_Mutation")) - maf = maf.add_mutation(@src.MAFMutation::new("BRCA1", "chr17", 200, 200, "A", "G", "Sample1", "Missense_Mutation")) - + maf = maf.add_mutation( + @src.MAFMutation::new( + "TP53", "chr17", 100, 100, "C", "T", "Sample1", "Missense_Mutation", + ), + ) + maf = maf.add_mutation( + @src.MAFMutation::new( + "BRCA1", "chr17", 200, 200, "A", "G", "Sample1", "Missense_Mutation", + ), + ) + // Sample2 has only TP53 mutation - maf = maf.add_mutation(@src.MAFMutation::new("TP53", "chr17", 300, 300, "C", "T", "Sample2", "Missense_Mutation")) - + maf = maf.add_mutation( + @src.MAFMutation::new( + "TP53", "chr17", 300, 300, "C", "T", "Sample2", "Missense_Mutation", + ), + ) + // Sample3 has only BRCA1 mutation - maf = maf.add_mutation(@src.MAFMutation::new("BRCA1", "chr17", 400, 400, "A", "G", "Sample3", "Missense_Mutation")) - + maf = maf.add_mutation( + @src.MAFMutation::new( + "BRCA1", "chr17", 400, 400, "A", "G", "Sample3", "Missense_Mutation", + ), + ) + let result = @src.analyze_co_occurrence(maf, "TP53", "BRCA1") - + assert_eq(result.co_occurrence, 1) assert_eq(result.mutual_exclusivity, 2) } @@ -294,7 +212,7 @@ test "maftools_co_occurrence_analysis" { ///| test "maftools_create_example" { let maf = @src.create_example_maf() - + assert_true(maf.count_mutations() > 0) assert_true(maf.count_unique_genes() > 0) assert_true(maf.count_unique_samples() > 0) @@ -304,7 +222,7 @@ test "maftools_create_example" { test "maftools_summarize" { let maf = @src.create_example_maf() let summary = @src.summarize_maf(maf) - + assert_true(summary.contains("MAF Summary")) assert_true(summary.contains("Total mutations:")) assert_true(summary.contains("TMB:")) @@ -314,7 +232,7 @@ test "maftools_summarize" { test "maftools_oncoplot_data" { let maf = @src.create_example_maf() let oncoplot = @src.generate_oncoplot_data(maf, 5) - + assert_true(oncoplot.genes.length() <= 5) assert_true(oncoplot.samples.length() > 0) assert_true(oncoplot.mutation_matrix.length() > 0) @@ -323,13 +241,25 @@ test "maftools_oncoplot_data" { ///| test "maftools_get_gene_mutation_counts" { let mut maf = @src.MAFData::new() - - maf = maf.add_mutation(@src.MAFMutation::new("TP53", "chr17", 100, 100, "C", "T", "Sample1", "Missense_Mutation")) - maf = maf.add_mutation(@src.MAFMutation::new("TP53", "chr17", 200, 200, "A", "G", "Sample2", "Missense_Mutation")) - maf = maf.add_mutation(@src.MAFMutation::new("BRCA1", "chr17", 300, 300, "C", "T", "Sample1", "Missense_Mutation")) - + + maf = maf.add_mutation( + @src.MAFMutation::new( + "TP53", "chr17", 100, 100, "C", "T", "Sample1", "Missense_Mutation", + ), + ) + maf = maf.add_mutation( + @src.MAFMutation::new( + "TP53", "chr17", 200, 200, "A", "G", "Sample2", "Missense_Mutation", + ), + ) + maf = maf.add_mutation( + @src.MAFMutation::new( + "BRCA1", "chr17", 300, 300, "C", "T", "Sample1", "Missense_Mutation", + ), + ) + let counts = @src.get_gene_mutation_counts(maf) - + assert_eq(counts.get("TP53").unwrap_or(0), 2) assert_eq(counts.get("BRCA1").unwrap_or(0), 1) } @@ -337,13 +267,25 @@ test "maftools_get_gene_mutation_counts" { ///| test "maftools_get_sample_mutation_counts" { let mut maf = @src.MAFData::new() - - maf = maf.add_mutation(@src.MAFMutation::new("TP53", "chr17", 100, 100, "C", "T", "Sample1", "Missense_Mutation")) - maf = maf.add_mutation(@src.MAFMutation::new("BRCA1", "chr17", 200, 200, "A", "G", "Sample1", "Missense_Mutation")) - maf = maf.add_mutation(@src.MAFMutation::new("EGFR", "chr7", 300, 300, "C", "T", "Sample2", "Missense_Mutation")) - + + maf = maf.add_mutation( + @src.MAFMutation::new( + "TP53", "chr17", 100, 100, "C", "T", "Sample1", "Missense_Mutation", + ), + ) + maf = maf.add_mutation( + @src.MAFMutation::new( + "BRCA1", "chr17", 200, 200, "A", "G", "Sample1", "Missense_Mutation", + ), + ) + maf = maf.add_mutation( + @src.MAFMutation::new( + "EGFR", "chr7", 300, 300, "C", "T", "Sample2", "Missense_Mutation", + ), + ) + let counts = @src.get_sample_mutation_counts(maf) - + assert_eq(counts.get("Sample1").unwrap_or(0), 2) assert_eq(counts.get("Sample2").unwrap_or(0), 1) } @@ -351,13 +293,25 @@ test "maftools_get_sample_mutation_counts" { ///| test "maftools_filter_variant_type" { let mut maf = @src.MAFData::new() - - maf = maf.add_mutation(@src.MAFMutation::new("TP53", "chr17", 100, 100, "C", "T", "Sample1", "Missense_Mutation")) - maf = maf.add_mutation(@src.MAFMutation::new("BRCA1", "chr17", 200, 200, "A", "G", "Sample2", "Nonsense_Mutation")) - maf = maf.add_mutation(@src.MAFMutation::new("EGFR", "chr7", 300, 300, "C", "T", "Sample3", "Missense_Mutation")) - + + maf = maf.add_mutation( + @src.MAFMutation::new( + "TP53", "chr17", 100, 100, "C", "T", "Sample1", "Missense_Mutation", + ), + ) + maf = maf.add_mutation( + @src.MAFMutation::new( + "BRCA1", "chr17", 200, 200, "A", "G", "Sample2", "Nonsense_Mutation", + ), + ) + maf = maf.add_mutation( + @src.MAFMutation::new( + "EGFR", "chr7", 300, 300, "C", "T", "Sample3", "Missense_Mutation", + ), + ) + let filtered = maf.filter_variant_type("Nonsense") - + assert_eq(filtered.count_mutations(), 1) assert_eq(filtered.get_mutation_gene(0), "BRCA1") } @@ -365,9 +319,9 @@ test "maftools_filter_variant_type" { ///| test "maftools_parse_maf_content" { let content = "Hugo_Symbol\tChromosome\tStart_Position\tEnd_Position\tReference_Allele\tTumor_Seq_Allele1\tTumor_Sample_Barcode\tVariant_Classification\nTP53\tchr17\t7577121\t7577121\tC\tT\tSample1\tMissense_Mutation\nBRCA1\tchr17\t43091134\t43091134\tA\tG\tSample2\tNonsense_Mutation" - + let maf = @src.parse_maf_content(content) - + assert_eq(maf.count_mutations(), 2) assert_eq(maf.get_mutation_gene(0), "TP53") assert_eq(maf.get_mutation_gene(1), "BRCA1") diff --git a/test/moonbit/markov_test.mbt b/test/moonbit/markov_test.mbt index e7e76022..4309a6d2 100644 --- a/test/moonbit/markov_test.mbt +++ b/test/moonbit/markov_test.mbt @@ -1,18 +1,20 @@ ///| /// Test file for markov module. - fn make_dna_seqs() -> Array[String] { ["ACGTACGT", "CGCGCGTA", "TTTAAAAC", "GGCCTTAA", "ATGCATGC"] } +///| fn make_cpg_seqs() -> Array[String] { ["CGCGCGCG", "ACGTACGT", "CGATCGAT", "GCGCGCGC", "TCGATCGA"] } +///| fn make_bg_seqs() -> Array[String] { ["ATATATAT", "TTAAAATT", "GGGGGGGG", "CCCCCCCC", "AATTCCGG"] } +///| test "markov_chain_type_helpers" { let a = @src.markov_first_order() let b = @src.markov_second_order() @@ -22,6 +24,7 @@ test "markov_chain_type_helpers" { assert_true(b != c) } +///| test "markov_model_new_default" { let m = @src.MarkovModel::new() assert_eq(m.order, 1) @@ -29,6 +32,7 @@ test "markov_model_new_default" { assert_eq(m.pseudo_count, 1.0) } +///| test "markov_model_default_dna" { let m = @src.MarkovModel::default_dna() assert_eq(m.order, 1) @@ -37,12 +41,14 @@ test "markov_model_default_dna" { assert_eq(m.states[1], "C") } +///| test "markov_model_default_protein" { let m = @src.MarkovModel::default_protein() assert_eq(m.order, 1) assert_eq(m.states.length(), 20) } +///| test "markov_model_set_order" { let m = @src.MarkovModel::new() let m2 = m.set_order(2) @@ -52,14 +58,16 @@ test "markov_model_set_order" { assert_eq(m.order, 1) } +///| test "markov_model_set_states" { let m = @src.MarkovModel::new() let states = ["X", "Y"] - let m2 = m.set_states(states=states) + let m2 = m.set_states(states~) assert_eq(m2.states.length(), 2) assert_eq(m2.states[0], "X") } +///| test "markov_model_set_chain_type" { let m = @src.MarkovModel::new() let m2 = m.set_chain_type(val=@src.markov_second_order()) @@ -68,6 +76,7 @@ test "markov_model_set_chain_type" { assert_eq(m3.order, 3) } +///| test "markov_model_set_pseudo_count" { let m = @src.MarkovModel::new() let m2 = m.set_pseudo_count(0.5) @@ -75,6 +84,7 @@ test "markov_model_set_pseudo_count" { assert_eq(m.pseudo_count, 1.0) } +///| test "markov_build_model_dna_order1" { let seqs = make_dna_seqs() let m = @src.markov_build_model(seqs, order=1) @@ -83,6 +93,7 @@ test "markov_build_model_dna_order1" { assert_true(m.transition_probs.length() > 0) } +///| test "markov_build_model_different_orders" { let seqs = make_dna_seqs() let m1 = @src.markov_build_model(seqs, order=1) @@ -94,6 +105,7 @@ test "markov_build_model_different_orders" { assert_true(c1 != c2 || c2 != c3) } +///| test "markov_score_sequence_finite_negative" { let seqs = make_dna_seqs() let m = @src.markov_build_model(seqs, order=1) @@ -102,6 +114,7 @@ test "markov_score_sequence_finite_negative" { assert_true(score > -1000.0) } +///| test "markov_score_per_base_length" { let seqs = make_dna_seqs() let m1 = @src.markov_build_model(seqs, order=1) @@ -112,6 +125,7 @@ test "markov_score_per_base_length" { assert_eq(s2.length(), 8 - 2) } +///| test "markov_generate_sequence_length_and_alphabet" { let seqs = make_dna_seqs() let m = @src.markov_build_model(seqs, order=1) @@ -131,6 +145,7 @@ test "markov_generate_sequence_length_and_alphabet" { } } +///| test "markov_log_odds_positive_cpg" { let cpg_seqs = make_cpg_seqs() let bg_seqs = make_bg_seqs() @@ -141,6 +156,7 @@ test "markov_log_odds_positive_cpg" { assert_true(lo > -100.0) } +///| test "markov_stationary_sums_to_one" { let seqs = make_dna_seqs() let m = @src.markov_build_model(seqs, order=1) @@ -156,22 +172,35 @@ test "markov_stationary_sums_to_one" { assert_true(total < 1.1) } +///| test "markov_pseudo_count_affects_unknowns" { let seqs = ["AAAAA", "CCCCCCC"] let sts = ["A", "C", "G", "T"] - let m_low = @src.markov_build_model(seqs, order=1, states=sts, pseudo_count=0.1) - let m_high = @src.markov_build_model(seqs, order=1, states=sts, pseudo_count=10.0) + let m_low = @src.markov_build_model( + seqs, + order=1, + states=sts, + pseudo_count=0.1, + ) + let m_high = @src.markov_build_model( + seqs, + order=1, + states=sts, + pseudo_count=10.0, + ) let s_low = @src.markov_score_sequence(m_low, "GGGG") let s_high = @src.markov_score_sequence(m_high, "GGGG") assert_true(s_high > s_low) } +///| test "markov_build_model_infers_states" { let seqs = ["AABBAABB", "BBBBAAAA"] let m = @src.markov_build_model(seqs) assert_true(m.states.length() >= 2) } +///| test "markov_short_sequence_score" { let seqs = make_dna_seqs() let m = @src.markov_build_model(seqs, order=1) diff --git a/test/moonbit/matrix_generics_test.mbt b/test/moonbit/matrix_generics_test.mbt index f792f653..333d0cdb 100644 --- a/test/moonbit/matrix_generics_test.mbt +++ b/test/moonbit/matrix_generics_test.mbt @@ -13,6 +13,7 @@ test "mg_matrix_new_basic" { assert_eq(mat.get(1, 1), 4.0) } +///| test "mg_matrix_new_single_element" { let mat = @src.MgMatrix::new([[42.0]]) assert_eq(mat.dim_rows(), 1) @@ -20,6 +21,7 @@ test "mg_matrix_new_single_element" { assert_eq(mat.get(0, 0), 42.0) } +///| test "mg_matrix_new_single_row" { let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0, 4.0]]) assert_eq(mat.dim_rows(), 1) @@ -28,6 +30,7 @@ test "mg_matrix_new_single_row" { assert_eq(mat.get(0, 3), 4.0) } +///| test "mg_matrix_new_single_col" { let mat = @src.MgMatrix::new([[1.0], [2.0], [3.0]]) assert_eq(mat.dim_rows(), 3) @@ -36,12 +39,14 @@ test "mg_matrix_new_single_col" { assert_eq(mat.get(2, 0), 3.0) } +///| test "mg_matrix_new_empty" { let mat = @src.MgMatrix::new([]) assert_eq(mat.dim_rows(), 0) assert_eq(mat.dim_cols(), 0) } +///| test "mg_matrix_zeros_basic" { let mat = @src.MgMatrix::zeros(3, 4) assert_eq(mat.dim_rows(), 3) @@ -50,6 +55,7 @@ test "mg_matrix_zeros_basic" { assert_eq(mat.get(2, 3), 0.0) } +///| test "mg_matrix_zeros_single" { let mat = @src.MgMatrix::zeros(1, 1) assert_eq(mat.dim_rows(), 1) @@ -57,6 +63,7 @@ test "mg_matrix_zeros_single" { assert_eq(mat.get(0, 0), 0.0) } +///| test "mg_matrix_zeros_empty" { let mat = @src.MgMatrix::zeros(0, 0) assert_eq(mat.dim_rows(), 0) @@ -67,6 +74,7 @@ test "mg_matrix_zeros_empty" { // Accessor methods // --------------------------------------------------------------------------- +///| test "mg_matrix_get_set" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0]]) mat.set(0, 0, 99.0) @@ -75,6 +83,7 @@ test "mg_matrix_get_set" { assert_eq(mat.get(1, 0), 3.0) } +///| test "mg_matrix_get_row" { let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) let row0 = mat.get_row(0) @@ -89,6 +98,7 @@ test "mg_matrix_get_row" { assert_eq(row1[2], 6.0) } +///| test "mg_matrix_get_col" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]) let col0 = mat.get_col(0) @@ -107,8 +117,13 @@ test "mg_matrix_get_col" { // Row summary statistics // --------------------------------------------------------------------------- +///| test "mg_row_means_basic" { - let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 2.0, 3.0], + [4.0, 5.0, 6.0], + [7.0, 8.0, 9.0], + ]) let result = @src.mg_row_means(mat) assert_eq(result.length(), 3) assert_eq(result[0], 2.0) @@ -116,6 +131,7 @@ test "mg_row_means_basic" { assert_eq(result[2], 8.0) } +///| test "mg_row_means_constant" { let mat = @src.MgMatrix::new([[5.0, 5.0, 5.0], [3.0, 3.0, 3.0]]) let result = @src.mg_row_means(mat) @@ -123,6 +139,7 @@ test "mg_row_means_constant" { assert_eq(result[1], 3.0) } +///| test "mg_row_means_single_row" { let mat = @src.MgMatrix::new([[10.0, 20.0, 30.0]]) let result = @src.mg_row_means(mat) @@ -130,8 +147,13 @@ test "mg_row_means_single_row" { assert_eq(result[0], 20.0) } +///| test "mg_row_sums_basic" { - let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 2.0, 3.0], + [4.0, 5.0, 6.0], + [7.0, 8.0, 9.0], + ]) let result = @src.mg_row_sums(mat) assert_eq(result.length(), 3) assert_eq(result[0], 6.0) @@ -139,6 +161,7 @@ test "mg_row_sums_basic" { assert_eq(result[2], 24.0) } +///| test "mg_row_sums_constant" { let mat = @src.MgMatrix::new([[2.0, 2.0, 2.0], [0.0, 0.0, 0.0]]) let result = @src.mg_row_sums(mat) @@ -146,8 +169,13 @@ test "mg_row_sums_constant" { assert_eq(result[1], 0.0) } +///| test "mg_row_vars_basic" { - let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 2.0, 3.0], + [4.0, 5.0, 6.0], + [7.0, 8.0, 9.0], + ]) let result = @src.mg_row_vars(mat) assert_eq(result.length(), 3) assert_true(result[0] > 0.99 && result[0] < 1.01) @@ -155,6 +183,7 @@ test "mg_row_vars_basic" { assert_true(result[2] > 0.99 && result[2] < 1.01) } +///| test "mg_row_vars_constant" { let mat = @src.MgMatrix::new([[5.0, 5.0, 5.0], [2.0, 2.0, 2.0]]) let result = @src.mg_row_vars(mat) @@ -162,12 +191,14 @@ test "mg_row_vars_constant" { assert_eq(result[1], 0.0) } +///| test "mg_row_vars_single" { let mat = @src.MgMatrix::new([[3.0]]) let result = @src.mg_row_vars(mat) assert_eq(result[0], 0.0) } +///| test "mg_row_sds_basic" { let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) let result = @src.mg_row_sds(mat) @@ -176,12 +207,14 @@ test "mg_row_sds_basic" { assert_true(result[1] > 0.99 && result[1] < 1.01) } +///| test "mg_row_sds_constant" { let mat = @src.MgMatrix::new([[7.0, 7.0, 7.0]]) let result = @src.mg_row_sds(mat) assert_eq(result[0], 0.0) } +///| test "mg_row_medians_odd" { let mat = @src.MgMatrix::new([[1.0, 3.0, 2.0], [6.0, 4.0, 5.0]]) let result = @src.mg_row_medians(mat) @@ -189,46 +222,61 @@ test "mg_row_medians_odd" { assert_eq(result[1], 5.0) } +///| test "mg_row_medians_even" { let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0, 4.0]]) let result = @src.mg_row_medians(mat) assert_eq(result[0], 2.5) } +///| test "mg_row_medians_constant" { let mat = @src.MgMatrix::new([[9.0, 9.0, 9.0]]) let result = @src.mg_row_medians(mat) assert_eq(result[0], 9.0) } +///| test "mg_row_mins_basic" { - let mat = @src.MgMatrix::new([[3.0, 1.0, 2.0], [6.0, 5.0, 4.0], [9.0, 8.0, 7.0]]) + let mat = @src.MgMatrix::new([ + [3.0, 1.0, 2.0], + [6.0, 5.0, 4.0], + [9.0, 8.0, 7.0], + ]) let result = @src.mg_row_mins(mat) assert_eq(result[0], 1.0) assert_eq(result[1], 4.0) assert_eq(result[2], 7.0) } +///| test "mg_row_mins_constant" { let mat = @src.MgMatrix::new([[4.0, 4.0, 4.0]]) let result = @src.mg_row_mins(mat) assert_eq(result[0], 4.0) } +///| test "mg_row_maxs_basic" { - let mat = @src.MgMatrix::new([[3.0, 1.0, 2.0], [6.0, 5.0, 4.0], [9.0, 8.0, 7.0]]) + let mat = @src.MgMatrix::new([ + [3.0, 1.0, 2.0], + [6.0, 5.0, 4.0], + [9.0, 8.0, 7.0], + ]) let result = @src.mg_row_maxs(mat) assert_eq(result[0], 3.0) assert_eq(result[1], 6.0) assert_eq(result[2], 9.0) } +///| test "mg_row_maxs_constant" { let mat = @src.MgMatrix::new([[4.0, 4.0, 4.0]]) let result = @src.mg_row_maxs(mat) assert_eq(result[0], 4.0) } +///| test "mg_row_ranges_basic" { let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [10.0, 5.0, 2.0]]) let result = @src.mg_row_ranges(mat) @@ -236,14 +284,20 @@ test "mg_row_ranges_basic" { assert_eq(result[1], 8.0) } +///| test "mg_row_ranges_constant" { let mat = @src.MgMatrix::new([[5.0, 5.0, 5.0]]) let result = @src.mg_row_ranges(mat) assert_eq(result[0], 0.0) } +///| test "mg_row_counts_basic" { - let mat = @src.MgMatrix::new([[1.0, 0.0, 3.0], [0.0, 0.0, 0.0], [4.0, 5.0, 6.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 0.0, 3.0], + [0.0, 0.0, 0.0], + [4.0, 5.0, 6.0], + ]) let result = @src.mg_row_counts(mat) assert_eq(result.length(), 3) assert_eq(result[0], 2) @@ -251,6 +305,7 @@ test "mg_row_counts_basic" { assert_eq(result[2], 3) } +///| test "mg_row_counts_all_zero" { let mat = @src.MgMatrix::new([[0.0, 0.0], [0.0, 0.0]]) let result = @src.mg_row_counts(mat) @@ -258,6 +313,7 @@ test "mg_row_counts_all_zero" { assert_eq(result[1], 0) } +///| test "mg_row_mads_basic" { let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) let result = @src.mg_row_mads(mat) @@ -266,6 +322,7 @@ test "mg_row_mads_basic" { assert_true(result[1] > 1.4 && result[1] < 1.6) } +///| test "mg_row_mads_constant" { let mat = @src.MgMatrix::new([[5.0, 5.0, 5.0]]) let result = @src.mg_row_mads(mat) @@ -276,8 +333,13 @@ test "mg_row_mads_constant" { // Row anys and alls // --------------------------------------------------------------------------- +///| test "mg_row_anys_basic" { - let mat = @src.MgMatrix::new([[1.0, 5.0, 3.0], [2.0, 2.0, 2.0], [10.0, 20.0, 30.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 5.0, 3.0], + [2.0, 2.0, 2.0], + [10.0, 20.0, 30.0], + ]) let result = @src.mg_row_anys(mat, 4.0) assert_eq(result.length(), 3) assert_true(result[0]) @@ -285,20 +347,27 @@ test "mg_row_anys_basic" { assert_true(result[2]) } +///| test "mg_row_anys_all_below" { let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0]]) let result = @src.mg_row_anys(mat, 100.0) assert_false(result[0]) } +///| test "mg_row_anys_threshold_boundary" { let mat = @src.MgMatrix::new([[5.0, 5.0, 5.0]]) let result = @src.mg_row_anys(mat, 5.0) assert_false(result[0]) } +///| test "mg_row_alls_basic" { - let mat = @src.MgMatrix::new([[10.0, 20.0, 30.0], [1.0, 100.0, 50.0], [2.0, 2.0, 2.0]]) + let mat = @src.MgMatrix::new([ + [10.0, 20.0, 30.0], + [1.0, 100.0, 50.0], + [2.0, 2.0, 2.0], + ]) let result = @src.mg_row_alls(mat, 5.0) assert_eq(result.length(), 3) assert_true(result[0]) @@ -306,6 +375,7 @@ test "mg_row_alls_basic" { assert_false(result[2]) } +///| test "mg_row_alls_all_above" { let mat = @src.MgMatrix::new([[10.0, 10.0], [20.0, 20.0]]) let result = @src.mg_row_alls(mat, 5.0) @@ -313,6 +383,7 @@ test "mg_row_alls_all_above" { assert_true(result[1]) } +///| test "mg_row_alls_threshold_boundary" { let mat = @src.MgMatrix::new([[5.0, 5.0, 5.0]]) let result = @src.mg_row_alls(mat, 5.0) @@ -323,8 +394,13 @@ test "mg_row_alls_threshold_boundary" { // Column summary statistics // --------------------------------------------------------------------------- +///| test "mg_col_means_basic" { - let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 2.0, 3.0], + [4.0, 5.0, 6.0], + [7.0, 8.0, 9.0], + ]) let result = @src.mg_col_means(mat) assert_eq(result.length(), 3) assert_eq(result[0], 4.0) @@ -332,6 +408,7 @@ test "mg_col_means_basic" { assert_eq(result[2], 6.0) } +///| test "mg_col_means_constant" { let mat = @src.MgMatrix::new([[3.0, 7.0], [3.0, 7.0], [3.0, 7.0]]) let result = @src.mg_col_means(mat) @@ -339,6 +416,7 @@ test "mg_col_means_constant" { assert_eq(result[1], 7.0) } +///| test "mg_col_means_single_col" { let mat = @src.MgMatrix::new([[10.0], [20.0], [30.0]]) let result = @src.mg_col_means(mat) @@ -346,8 +424,13 @@ test "mg_col_means_single_col" { assert_eq(result[0], 20.0) } +///| test "mg_col_sums_basic" { - let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 2.0, 3.0], + [4.0, 5.0, 6.0], + [7.0, 8.0, 9.0], + ]) let result = @src.mg_col_sums(mat) assert_eq(result.length(), 3) assert_eq(result[0], 12.0) @@ -355,6 +438,7 @@ test "mg_col_sums_basic" { assert_eq(result[2], 18.0) } +///| test "mg_col_sums_constant" { let mat = @src.MgMatrix::new([[2.0, 0.0], [2.0, 0.0], [2.0, 0.0]]) let result = @src.mg_col_sums(mat) @@ -362,8 +446,13 @@ test "mg_col_sums_constant" { assert_eq(result[1], 0.0) } +///| test "mg_col_vars_basic" { - let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 2.0, 3.0], + [4.0, 5.0, 6.0], + [7.0, 8.0, 9.0], + ]) let result = @src.mg_col_vars(mat) assert_eq(result.length(), 3) assert_true(result[0] > 8.99 && result[0] < 9.01) @@ -371,6 +460,7 @@ test "mg_col_vars_basic" { assert_true(result[2] > 8.99 && result[2] < 9.01) } +///| test "mg_col_vars_constant" { let mat = @src.MgMatrix::new([[5.0, 7.0], [5.0, 7.0], [5.0, 7.0]]) let result = @src.mg_col_vars(mat) @@ -378,12 +468,14 @@ test "mg_col_vars_constant" { assert_eq(result[1], 0.0) } +///| test "mg_col_vars_single" { let mat = @src.MgMatrix::new([[3.0], [3.0]]) let result = @src.mg_col_vars(mat) assert_eq(result[0], 0.0) } +///| test "mg_col_sds_basic" { let mat = @src.MgMatrix::new([[1.0, 2.0], [4.0, 5.0], [7.0, 8.0]]) let result = @src.mg_col_sds(mat) @@ -392,6 +484,7 @@ test "mg_col_sds_basic" { assert_true(result[1] > 2.99 && result[1] < 3.01) } +///| test "mg_col_sds_constant" { let mat = @src.MgMatrix::new([[3.0, 5.0], [3.0, 5.0]]) let result = @src.mg_col_sds(mat) @@ -399,6 +492,7 @@ test "mg_col_sds_constant" { assert_eq(result[1], 0.0) } +///| test "mg_col_medians_odd" { let mat = @src.MgMatrix::new([[1.0, 3.0], [4.0, 1.0], [7.0, 2.0]]) let result = @src.mg_col_medians(mat) @@ -406,6 +500,7 @@ test "mg_col_medians_odd" { assert_eq(result[1], 2.0) } +///| test "mg_col_medians_even" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0]]) let result = @src.mg_col_medians(mat) @@ -413,6 +508,7 @@ test "mg_col_medians_even" { assert_eq(result[1], 3.0) } +///| test "mg_col_medians_constant" { let mat = @src.MgMatrix::new([[8.0, 2.0], [8.0, 2.0], [8.0, 2.0]]) let result = @src.mg_col_medians(mat) @@ -420,14 +516,20 @@ test "mg_col_medians_constant" { assert_eq(result[1], 2.0) } +///| test "mg_col_mins_basic" { - let mat = @src.MgMatrix::new([[3.0, 1.0, 2.0], [6.0, 5.0, 4.0], [9.0, 8.0, 7.0]]) + let mat = @src.MgMatrix::new([ + [3.0, 1.0, 2.0], + [6.0, 5.0, 4.0], + [9.0, 8.0, 7.0], + ]) let result = @src.mg_col_mins(mat) assert_eq(result[0], 3.0) assert_eq(result[1], 1.0) assert_eq(result[2], 2.0) } +///| test "mg_col_mins_constant" { let mat = @src.MgMatrix::new([[4.0, 6.0], [4.0, 6.0], [4.0, 6.0]]) let result = @src.mg_col_mins(mat) @@ -435,14 +537,20 @@ test "mg_col_mins_constant" { assert_eq(result[1], 6.0) } +///| test "mg_col_maxs_basic" { - let mat = @src.MgMatrix::new([[3.0, 1.0, 2.0], [6.0, 5.0, 4.0], [9.0, 8.0, 7.0]]) + let mat = @src.MgMatrix::new([ + [3.0, 1.0, 2.0], + [6.0, 5.0, 4.0], + [9.0, 8.0, 7.0], + ]) let result = @src.mg_col_maxs(mat) assert_eq(result[0], 9.0) assert_eq(result[1], 8.0) assert_eq(result[2], 7.0) } +///| test "mg_col_maxs_constant" { let mat = @src.MgMatrix::new([[4.0, 6.0], [4.0, 6.0], [4.0, 6.0]]) let result = @src.mg_col_maxs(mat) @@ -450,6 +558,7 @@ test "mg_col_maxs_constant" { assert_eq(result[1], 6.0) } +///| test "mg_col_ranges_basic" { let mat = @src.MgMatrix::new([[1.0, 10.0], [5.0, 2.0], [10.0, 1.0]]) let result = @src.mg_col_ranges(mat) @@ -457,6 +566,7 @@ test "mg_col_ranges_basic" { assert_eq(result[1], 9.0) } +///| test "mg_col_ranges_constant" { let mat = @src.MgMatrix::new([[5.0, 3.0], [5.0, 3.0], [5.0, 3.0]]) let result = @src.mg_col_ranges(mat) @@ -468,8 +578,13 @@ test "mg_col_ranges_constant" { // Col anys and alls // --------------------------------------------------------------------------- +///| test "mg_col_anys_basic" { - let mat = @src.MgMatrix::new([[1.0, 5.0, 3.0], [2.0, 2.0, 2.0], [1.0, 8.0, 1.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 5.0, 3.0], + [2.0, 2.0, 2.0], + [1.0, 8.0, 1.0], + ]) let result = @src.mg_col_anys(mat, 4.0) assert_eq(result.length(), 3) assert_false(result[0]) @@ -477,6 +592,7 @@ test "mg_col_anys_basic" { assert_false(result[2]) } +///| test "mg_col_anys_all_below" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0]]) let result = @src.mg_col_anys(mat, 100.0) @@ -484,6 +600,7 @@ test "mg_col_anys_all_below" { assert_false(result[1]) } +///| test "mg_col_alls_basic" { let mat = @src.MgMatrix::new([[10.0, 5.0], [20.0, 6.0], [30.0, 7.0]]) let result = @src.mg_col_alls(mat, 4.0) @@ -491,6 +608,7 @@ test "mg_col_alls_basic" { assert_true(result[1]) } +///| test "mg_col_alls_some_below" { let mat = @src.MgMatrix::new([[10.0, 3.0], [20.0, 6.0], [30.0, 7.0]]) let result = @src.mg_col_alls(mat, 5.0) @@ -502,9 +620,10 @@ test "mg_col_alls_some_below" { // Block processing // --------------------------------------------------------------------------- +///| test "mg_block_apply_rows_basic" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]) - let result = @src.mg_block_apply_rows(mat, 2, (block) => { + let result = @src.mg_block_apply_rows(mat, 2, block => { @src.mg_row_means(block) }) assert_eq(result.length(), 3) @@ -513,9 +632,10 @@ test "mg_block_apply_rows_basic" { assert_eq(result[2], 5.5) } +///| test "mg_block_apply_rows_single_block" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0]]) - let result = @src.mg_block_apply_rows(mat, 10, (block) => { + let result = @src.mg_block_apply_rows(mat, 10, block => { @src.mg_row_sums(block) }) assert_eq(result.length(), 2) @@ -523,9 +643,10 @@ test "mg_block_apply_rows_single_block" { assert_eq(result[1], 7.0) } +///| test "mg_block_apply_rows_block_size_exceeds" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0]]) - let result = @src.mg_block_apply_rows(mat, 100, (block) => { + let result = @src.mg_block_apply_rows(mat, 100, block => { @src.mg_row_mins(block) }) assert_eq(result.length(), 2) @@ -533,9 +654,10 @@ test "mg_block_apply_rows_block_size_exceeds" { assert_eq(result[1], 3.0) } +///| test "mg_block_apply_cols_basic" { let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) - let result = @src.mg_block_apply_cols(mat, 2, (block) => { + let result = @src.mg_block_apply_cols(mat, 2, block => { @src.mg_col_means(block) }) assert_eq(result.length(), 3) @@ -544,9 +666,10 @@ test "mg_block_apply_cols_basic" { assert_eq(result[2], 4.5) } +///| test "mg_block_apply_cols_single_block" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0]]) - let result = @src.mg_block_apply_cols(mat, 10, (block) => { + let result = @src.mg_block_apply_cols(mat, 10, block => { @src.mg_col_sums(block) }) assert_eq(result.length(), 2) @@ -558,144 +681,172 @@ test "mg_block_apply_cols_single_block" { // Standalone statistical functions // --------------------------------------------------------------------------- +///| test "mg_mean_basic" { let data = [1.0, 2.0, 3.0, 4.0, 5.0] assert_eq(@src.mg_mean(data), 3.0) } +///| test "mg_mean_single" { let data = [42.0] assert_eq(@src.mg_mean(data), 42.0) } +///| test "mg_mean_empty" { let data : Array[Double] = [] assert_eq(@src.mg_mean(data), 0.0) } +///| test "mg_mean_constant" { let data = [7.0, 7.0, 7.0, 7.0] assert_eq(@src.mg_mean(data), 7.0) } +///| test "mg_mean_negative" { let data = [-1.0, -2.0, -3.0] assert_eq(@src.mg_mean(data), -2.0) } +///| test "mg_variance_basic" { let data = [1.0, 2.0, 3.0, 4.0, 5.0] let result = @src.mg_variance(data) assert_true(result > 2.49 && result < 2.51) } +///| test "mg_variance_single" { let data = [5.0] assert_eq(@src.mg_variance(data), 0.0) } +///| test "mg_variance_empty" { let data : Array[Double] = [] assert_eq(@src.mg_variance(data), 0.0) } +///| test "mg_variance_constant" { let data = [3.0, 3.0, 3.0] assert_eq(@src.mg_variance(data), 0.0) } +///| test "mg_variance_two_elements" { let data = [2.0, 4.0] let result = @src.mg_variance(data) assert_true(result > 1.99 && result < 2.01) } +///| test "mg_median_odd" { let data = [3.0, 1.0, 2.0] assert_eq(@src.mg_median(data), 2.0) } +///| test "mg_median_even" { let data = [1.0, 2.0, 3.0, 4.0] assert_eq(@src.mg_median(data), 2.5) } +///| test "mg_median_single" { let data = [99.0] assert_eq(@src.mg_median(data), 99.0) } +///| test "mg_median_empty" { let data : Array[Double] = [] assert_eq(@src.mg_median(data), 0.0) } +///| test "mg_median_two" { let data = [5.0, 10.0] assert_eq(@src.mg_median(data), 7.5) } +///| test "mg_min_basic" { let data = [3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0] assert_eq(@src.mg_min(data), 1.0) } +///| test "mg_min_single" { let data = [42.0] assert_eq(@src.mg_min(data), 42.0) } +///| test "mg_min_empty" { let data : Array[Double] = [] assert_eq(@src.mg_min(data), 0.0) } +///| test "mg_min_negative" { let data = [-5.0, -1.0, -3.0] assert_eq(@src.mg_min(data), -5.0) } +///| test "mg_max_basic" { let data = [3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0] assert_eq(@src.mg_max(data), 9.0) } +///| test "mg_max_single" { let data = [42.0] assert_eq(@src.mg_max(data), 42.0) } +///| test "mg_max_empty" { let data : Array[Double] = [] assert_eq(@src.mg_max(data), 0.0) } +///| test "mg_max_negative" { let data = [-5.0, -1.0, -3.0] assert_eq(@src.mg_max(data), -1.0) } +///| test "mg_mad_basic" { let data = [1.0, 2.0, 3.0, 4.0, 5.0] let result = @src.mg_mad(data) assert_true(result > 1.4 && result < 2.0) } +///| test "mg_mad_constant" { let data = [5.0, 5.0, 5.0] assert_eq(@src.mg_mad(data), 0.0) } +///| test "mg_mad_single" { let data = [7.0] assert_eq(@src.mg_mad(data), 0.0) } +///| test "mg_mad_empty" { let data : Array[Double] = [] assert_eq(@src.mg_mad(data), 0.0) } +///| test "mg_mad_two_same" { let data = [3.0, 3.0] assert_eq(@src.mg_mad(data), 0.0) @@ -705,6 +856,7 @@ test "mg_mad_two_same" { // Edge cases // --------------------------------------------------------------------------- +///| test "mg_empty_matrix_row_stats" { let mat = @src.MgMatrix::zeros(0, 5) let means = @src.mg_row_means(mat) @@ -713,12 +865,14 @@ test "mg_empty_matrix_row_stats" { assert_eq(sums.length(), 0) } +///| test "mg_empty_matrix_col_stats" { let mat = @src.MgMatrix::zeros(5, 0) let means = @src.mg_col_means(mat) assert_eq(means.length(), 0) } +///| test "mg_single_value_matrix" { let mat = @src.MgMatrix::new([[7.0]]) assert_eq(mat.dim_rows(), 1) @@ -731,6 +885,7 @@ test "mg_single_value_matrix" { assert_eq(@src.mg_col_medians(mat)[0], 7.0) } +///| test "mg_negative_values_matrix" { let mat = @src.MgMatrix::new([[-1.0, -2.0], [-3.0, -4.0]]) let row_means = @src.mg_row_means(mat) @@ -741,6 +896,7 @@ test "mg_negative_values_matrix" { assert_eq(col_means[1], -3.0) } +///| test "mg_large_matrix_stats" { let mat = @src.MgMatrix::zeros(100, 50) let row_means = @src.mg_row_means(mat) @@ -751,41 +907,47 @@ test "mg_large_matrix_stats" { assert_eq(col_means[0], 0.0) } +///| test "mg_row_anys_empty_matrix" { let mat = @src.MgMatrix::zeros(0, 3) let result = @src.mg_row_anys(mat, 1.0) assert_eq(result.length(), 0) } +///| test "mg_row_alls_empty_matrix" { let mat = @src.MgMatrix::zeros(0, 3) let result = @src.mg_row_alls(mat, 1.0) assert_eq(result.length(), 0) } +///| test "mg_col_anys_empty_matrix" { let mat = @src.MgMatrix::zeros(3, 0) let result = @src.mg_col_anys(mat, 1.0) assert_eq(result.length(), 0) } +///| test "mg_col_alls_empty_matrix" { let mat = @src.MgMatrix::zeros(3, 0) let result = @src.mg_col_alls(mat, 1.0) assert_eq(result.length(), 0) } +///| test "mg_block_apply_rows_empty" { let mat = @src.MgMatrix::zeros(0, 5) - let result = @src.mg_block_apply_rows(mat, 10, (block) => { + let result = @src.mg_block_apply_rows(mat, 10, block => { @src.mg_row_means(block) }) assert_eq(result.length(), 0) } +///| test "mg_block_apply_cols_empty" { let mat = @src.MgMatrix::zeros(5, 0) - let result = @src.mg_block_apply_cols(mat, 10, (block) => { + let result = @src.mg_block_apply_cols(mat, 10, block => { @src.mg_col_means(block) }) assert_eq(result.length(), 0) @@ -795,6 +957,7 @@ test "mg_block_apply_cols_empty" { // Cross-validation: row and col stats should agree on the same data // --------------------------------------------------------------------------- +///| test "mg_row_col_stats_consistency" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0]]) let row_means = @src.mg_row_means(mat) @@ -804,10 +967,11 @@ test "mg_row_col_stats_consistency" { assert_eq(@src.mg_mean(row_means), @src.mg_mean(col_means)) } +///| test "mg_symmetric_matrix_row_col_stats" { let mat = @src.MgMatrix::new([[1.0, 2.0], [2.0, 1.0]]) let row_means = @src.mg_row_means(mat) let col_means = @src.mg_col_means(mat) assert_eq(row_means[0], col_means[0]) assert_eq(row_means[1], col_means[1]) -} \ No newline at end of file +} diff --git a/test/moonbit/matrix_test.mbt b/test/moonbit/matrix_test.mbt index 88e37761..55a49458 100644 --- a/test/moonbit/matrix_test.mbt +++ b/test/moonbit/matrix_test.mbt @@ -1,38 +1,54 @@ ///| /// Tests for Matrix module. - test "BiocMatrix dense_from_array" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) assert_eq(mat.nrow(), 2) assert_eq(mat.ncol(), 2) } +///| test "BiocMatrix get element" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) assert_eq(mat.get(0, 0), 1.0) assert_eq(mat.get(1, 1), 4.0) } +///| test "BiocMatrix set element" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) let mat2 = mat.set(0, 0, 10.0) assert_eq(mat2.get(0, 0), 10.0) } +///| test "BiocMatrix csc_from_triplets" { - let mat = @src.BiocMatrix::csc_from_triplets([0, 1, 0, 1], [0, 0, 1, 1], [1.0, 3.0, 2.0, 4.0], 2, 2) + let mat = @src.BiocMatrix::csc_from_triplets( + [0, 1, 0, 1], + [0, 0, 1, 1], + [1.0, 3.0, 2.0, 4.0], + 2, + 2, + ) assert_eq(mat.nrow(), 2) assert_eq(mat.ncol(), 2) assert_eq(mat.get(0, 0), 1.0) } +///| test "BiocMatrix csr_from_triplets" { - let mat = @src.BiocMatrix::csr_from_triplets([0, 0, 1, 1], [0, 1, 0, 1], [1.0, 2.0, 3.0, 4.0], 2, 2) + let mat = @src.BiocMatrix::csr_from_triplets( + [0, 0, 1, 1], + [0, 1, 0, 1], + [1.0, 2.0, 3.0, 4.0], + 2, + 2, + ) assert_eq(mat.nrow(), 2) assert_eq(mat.ncol(), 2) assert_eq(mat.get(0, 1), 2.0) } +///| test "BiocMatrix transpose" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) let t = mat.transpose() @@ -40,6 +56,7 @@ test "BiocMatrix transpose" { assert_eq(t.get(1, 0), 2.0) } +///| test "BiocMatrix add" { let mat1 = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) let mat2 = @src.BiocMatrix::dense_from_array([[1.0, 0.0], [0.0, 1.0]]) @@ -48,6 +65,7 @@ test "BiocMatrix add" { assert_eq(result.unwrap().get(0, 0), 2.0) } +///| test "BiocMatrix multiply" { let mat1 = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) let mat2 = @src.BiocMatrix::dense_from_array([[2.0, 0.0], [0.0, 2.0]]) @@ -56,6 +74,7 @@ test "BiocMatrix multiply" { assert_eq(result.unwrap().get(0, 0), 2.0) } +///| test "BiocMatrix row_sums" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) let sums = mat.row_sums() @@ -63,6 +82,7 @@ test "BiocMatrix row_sums" { assert_eq(sums[0], 3.0) } +///| test "BiocMatrix col_sums" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) let sums = mat.col_sums() @@ -70,24 +90,28 @@ test "BiocMatrix col_sums" { assert_eq(sums[0], 4.0) } +///| test "BiocMatrix row_means" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 3.0], [2.0, 4.0]]) let means = mat.row_means() assert_eq(means[0], 2.0) } +///| test "BiocMatrix col_means" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) let means = mat.col_means() assert_eq(means[0], 2.0) } +///| test "BiocMatrix norm" { let mat = @src.BiocMatrix::dense_from_array([[3.0, 4.0]]) let norm = mat.norm(2.0) assert_eq(norm, 5.0) } +///| test "BiocMatrix dim" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) let (nrow, ncol) = mat.dim() @@ -95,17 +119,20 @@ test "BiocMatrix dim" { assert_eq(ncol, 3) } +///| test "BiocMatrix nnz" { let mat = @src.BiocMatrix::csc_from_triplets([0, 1], [0, 1], [1.0, 2.0], 2, 2) assert_eq(mat.nnz(), 2) } +///| test "create_example_dense_matrix" { let mat = @src.create_example_dense_matrix() assert_eq(mat.nrow(), 3) assert_eq(mat.ncol(), 3) } +///| test "create_example_sparse_matrix" { let mat = @src.create_example_sparse_matrix() assert_eq(mat.nrow(), 3) diff --git a/test/moonbit/mauve_test.mbt b/test/moonbit/mauve_test.mbt index ce824abf..aedc8a70 100644 --- a/test/moonbit/mauve_test.mbt +++ b/test/moonbit/mauve_test.mbt @@ -53,8 +53,14 @@ test "mauve_lcb_add_seq" { /// Test MauveLCB consistency check. test "mauve_lcb_consistent" { let lcb = @src.new_mauve_lcb("lcb_1") - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 800)) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 800), + ) assert_true(@src.mauve_lcb_is_consistent(lcb)) } @@ -62,8 +68,14 @@ test "mauve_lcb_consistent" { /// Test MauveLCB inconsistency (mixed strands). test "mauve_lcb_inconsistent" { let lcb = @src.new_mauve_lcb("lcb_1") - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("mouse.chr1", 0, 100, "-", 800)) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("mouse.chr1", 0, 100, "-", 800), + ) assert_false(@src.mauve_lcb_is_consistent(lcb)) } @@ -89,10 +101,16 @@ test "mauve_alignment_add_lcb" { test "mauve_alignment_seq_names" { let ali = @src.new_mauve_alignment() let lcb = @src.new_mauve_lcb("lcb_1") - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 800)) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 800), + ) @src.mauve_add_lcb(ali, lcb) - + let names = @src.mauve_all_seq_names(ali) assert_eq(names.length(), 2) assert_true(names.contains("human.chr1")) @@ -133,17 +151,23 @@ test "mauve_parse_with_inversions" { /// Test detect_mauve_inversions. test "mauve_detect_inversions" { let ali = @src.new_mauve_alignment() - + // LCB 1: positive strand let lcb1 = @src.new_mauve_lcb("lcb_1") - @src.mauve_lcb_add_seq(lcb1, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) + @src.mauve_lcb_add_seq( + lcb1, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) @src.mauve_add_lcb(ali, lcb1) - + // LCB 2: negative strand (inversion) let lcb2 = @src.new_mauve_lcb("lcb_2") - @src.mauve_lcb_add_seq(lcb2, @src.new_mauve_sequence("human.chr1", 100, 100, "-", 1000)) + @src.mauve_lcb_add_seq( + lcb2, + @src.new_mauve_sequence("human.chr1", 100, 100, "-", 1000), + ) @src.mauve_add_lcb(ali, lcb2) - + let ali = @src.detect_mauve_inversions(ali) assert_true(ali.inversions.length() > 0) } @@ -152,15 +176,21 @@ test "mauve_detect_inversions" { /// Test detect_mauve_breakpoints. test "mauve_detect_breakpoints" { let ali = @src.new_mauve_alignment() - + let lcb1 = @src.new_mauve_lcb("lcb_1") - @src.mauve_lcb_add_seq(lcb1, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) + @src.mauve_lcb_add_seq( + lcb1, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) @src.mauve_add_lcb(ali, lcb1) - + let lcb2 = @src.new_mauve_lcb("lcb_2") - @src.mauve_lcb_add_seq(lcb2, @src.new_mauve_sequence("human.chr1", 500, 100, "+", 1000)) + @src.mauve_lcb_add_seq( + lcb2, + @src.new_mauve_sequence("human.chr1", 500, 100, "+", 1000), + ) @src.mauve_add_lcb(ali, lcb2) - + let ali = @src.detect_mauve_breakpoints(ali) assert_true(ali.breakpoints.length() > 0) } @@ -170,10 +200,16 @@ test "mauve_detect_breakpoints" { test "mauve_genome_coverage" { let ali = @src.new_mauve_alignment() let lcb = @src.new_mauve_lcb("lcb_1") - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("human.chr1", 0, 500, "+", 1000)) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("mouse.chr1", 0, 300, "+", 800)) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("human.chr1", 0, 500, "+", 1000), + ) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("mouse.chr1", 0, 300, "+", 800), + ) @src.mauve_add_lcb(ali, lcb) - + let coverage = @src.mauve_genome_coverage(ali) assert_true(coverage.contains("human.chr1")) assert_true(coverage.contains("mouse.chr1")) @@ -185,17 +221,29 @@ test "mauve_genome_coverage" { /// Test mauve_conserved_segments. test "mauve_conserved_segments" { let ali = @src.new_mauve_alignment() - + let lcb1 = @src.new_mauve_lcb("lcb_1") - @src.mauve_lcb_add_seq(lcb1, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) - @src.mauve_lcb_add_seq(lcb1, @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 800)) + @src.mauve_lcb_add_seq( + lcb1, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) + @src.mauve_lcb_add_seq( + lcb1, + @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 800), + ) @src.mauve_add_lcb(ali, lcb1) - + let lcb2 = @src.new_mauve_lcb("lcb_2") - @src.mauve_lcb_add_seq(lcb2, @src.new_mauve_sequence("human.chr1", 500, 100, "+", 1000)) - @src.mauve_lcb_add_seq(lcb2, @src.new_mauve_sequence("mouse.chr1", 500, 100, "+", 800)) + @src.mauve_lcb_add_seq( + lcb2, + @src.new_mauve_sequence("human.chr1", 500, 100, "+", 1000), + ) + @src.mauve_lcb_add_seq( + lcb2, + @src.new_mauve_sequence("mouse.chr1", 500, 100, "+", 800), + ) @src.mauve_add_lcb(ali, lcb2) - + let segments = @src.mauve_conserved_segments(ali) assert_eq(segments["human.chr1"], 2) assert_eq(segments["mouse.chr1"], 2) @@ -215,9 +263,12 @@ test "mauve_to_bed" { let ali = @src.new_mauve_alignment() let lcb = @src.new_mauve_lcb("lcb_1") @src.mauve_lcb_set_score(lcb, 100.0) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) @src.mauve_add_lcb(ali, lcb) - + let bed = @src.mauve_to_bed(ali) assert_true(bed.contains("track name=")) assert_true(bed.contains("human.chr1")) @@ -232,7 +283,7 @@ test "mauve_inversions_to_bed" { let inv = @src.new_mauve_inversion("human.chr1", 100, 200, 100) inv.affected_lcbs.push("lcb_1") ali.inversions.push(inv) - + let bed = @src.mauve_inversions_to_bed(ali) assert_true(bed.contains("track name=\"Inversions\"")) assert_true(bed.contains("human.chr1")) @@ -245,10 +296,16 @@ test "mauve_summary" { let ali = @src.new_mauve_alignment() let lcb = @src.new_mauve_lcb("lcb_1") @src.mauve_lcb_set_score(lcb, 50.0) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 800)) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 800), + ) @src.mauve_add_lcb(ali, lcb) - + let summary = @src.mauve_summary(ali) assert_true(summary.contains("Mauve Alignment Summary")) assert_true(summary.contains("Locally Collinear Blocks")) @@ -270,11 +327,20 @@ test "mauve_config_default" { test "mauve_get_genome_seqs" { let ali = @src.new_mauve_alignment() let lcb = @src.new_mauve_lcb("lcb_1") - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("human.chr2", 200, 100, "+", 800)) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 700)) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("human.chr2", 200, 100, "+", 800), + ) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 700), + ) @src.mauve_add_lcb(ali, lcb) - + let human_seqs = @src.mauve_get_genome_seqs(ali, "human.chr") assert_eq(human_seqs.length(), 2) } @@ -286,7 +352,7 @@ test "mauve_progressive_aligner" { @src.mauve_add_sequence(aligner, "human") @src.mauve_add_sequence(aligner, "mouse") @src.mauve_add_sequence(aligner, "rat") - + @src.mauve_build_guide_tree(aligner) assert_eq(aligner.guide_tree.length(), 3) } diff --git a/test/moonbit/mcp_counter_test.mbt b/test/moonbit/mcp_counter_test.mbt index 3aa346b8..6dc52861 100644 --- a/test/moonbit/mcp_counter_test.mbt +++ b/test/moonbit/mcp_counter_test.mbt @@ -12,6 +12,7 @@ test "mcp_cell_population_struct" { assert_eq(pop.markers().length(), 3) } +///| test "mcp_result_accessors" { // Use mcp_run to get a result with known values let result = @src.mcp_run( @@ -27,6 +28,7 @@ test "mcp_result_accessors" { assert_true((result.scores()[0][0] - 4.0).abs() < 0.001) } +///| test "mcp_result_get_score" { // Build a result with known values via mcp_run // Geometric mean of (4, 9) = 6.0 for S1, (4, 4) = 4.0 for S2 @@ -45,6 +47,7 @@ test "mcp_result_get_score" { assert_true(result.get_score("PopA", "Unknown").abs() < 1.0e-12) } +///| test "mcp_result_get_population_scores" { // Build a result with two populations let result = @src.mcp_run( @@ -72,6 +75,7 @@ test "mcp_result_get_population_scores" { // Built-in populations // --------------------------------------------------------------------------- +///| test "mcp_default_populations_count" { let pops = @src.mcp_default_populations() assert_eq(pops.length(), 10) @@ -81,6 +85,7 @@ test "mcp_default_populations_count" { } } +///| test "mcp_population_names" { let names = @src.mcp_population_names() assert_eq(names.length(), 10) @@ -88,20 +93,27 @@ test "mcp_population_names" { assert_eq(names[9], "Fibroblasts") } +///| test "mcp_default_populations_marker_genes_present" { let pops = @src.mcp_default_populations() // T cells should contain CD3D let t_cells = pops[0] let mut has_cd3d = false for m in t_cells.markers() { - if m == "CD3D" { has_cd3d = true; break } + if m == "CD3D" { + has_cd3d = true + break + } } assert_true(has_cd3d) // B lineage should contain CD19 let b_cells = pops[3] let mut has_cd19 = false for m in b_cells.markers() { - if m == "CD19" { has_cd19 = true; break } + if m == "CD19" { + has_cd19 = true + break + } } assert_true(has_cd19) } @@ -110,74 +122,63 @@ test "mcp_default_populations_marker_genes_present" { // Geometric mean computation via mcp_run // --------------------------------------------------------------------------- +///| test "mcp_run_geometric_mean_correctness" { // Single population with two markers, one sample // Geometric mean of (4.0, 9.0) = sqrt(4 * 9) = 6.0 let pop = @src.McpCellPopulation::new("Test", ["G1", "G2"]) - let result = @src.mcp_run( - ["G1", "G2"], - ["S1"], - [[4.0], [9.0]], - populations=[pop], - ) + let result = @src.mcp_run(["G1", "G2"], ["S1"], [[4.0], [9.0]], populations=[ + pop, + ]) assert_eq(result.populations().length(), 1) assert_eq(result.sample_names().length(), 1) let s = result.get_score("Test", "S1") assert_true((s - 6.0).abs() < 0.001) } +///| test "mcp_run_handles_zero_expression" { // If all marker expressions are zero, score should be 0 let pop = @src.McpCellPopulation::new("Test", ["G1", "G2"]) - let result = @src.mcp_run( - ["G1", "G2"], - ["S1"], - [[0.0], [0.0]], - populations=[pop], - ) + let result = @src.mcp_run(["G1", "G2"], ["S1"], [[0.0], [0.0]], populations=[ + pop, + ]) assert_true(result.get_score("Test", "S1").abs() < 1.0e-12) } +///| test "mcp_run_handles_missing_markers" { // If a marker is not in gene_names, it is skipped let pop = @src.McpCellPopulation::new("Test", ["G1", "MISSING"]) - let result = @src.mcp_run( - ["G1"], - ["S1"], - [[4.0]], - populations=[pop], - ) + let result = @src.mcp_run(["G1"], ["S1"], [[4.0]], populations=[pop]) // Geometric mean of just [4.0] = 4.0 let s = result.get_score("Test", "S1") assert_true((s - 4.0).abs() < 1.0e-9) } +///| test "mcp_run_all_markers_missing" { // If no markers are found, score is 0 let pop = @src.McpCellPopulation::new("Test", ["X1", "X2"]) - let result = @src.mcp_run( - ["G1", "G2"], - ["S1"], - [[4.0], [9.0]], - populations=[pop], - ) + let result = @src.mcp_run(["G1", "G2"], ["S1"], [[4.0], [9.0]], populations=[ + pop, + ]) assert_true(result.get_score("Test", "S1").abs() < 1.0e-12) } +///| test "mcp_run_multiple_samples" { // Two samples, one population let pop = @src.McpCellPopulation::new("Test", ["G1"]) - let result = @src.mcp_run( - ["G1"], - ["S1", "S2"], - [[2.0, 8.0]], - populations=[pop], - ) + let result = @src.mcp_run(["G1"], ["S1", "S2"], [[2.0, 8.0]], populations=[ + pop, + ]) assert_eq(result.sample_names().length(), 2) assert_true((result.get_score("Test", "S1") - 2.0).abs() < 1.0e-9) assert_true((result.get_score("Test", "S2") - 8.0).abs() < 1.0e-9) } +///| test "mcp_run_default_populations" { // Run with default populations on sample data let (genes, samples, matrix) = @src.mcp_sample_data() @@ -196,6 +197,7 @@ test "mcp_run_default_populations" { // Sample data correctness // --------------------------------------------------------------------------- +///| test "mcp_sample_data_t_cell_rich_tumor_a" { // Tumor_A is T-cell rich: T cells (pop 0), CD8+ T cells (pop 1), // Cytotoxic lymphocytes (pop 2) should all score higher than B lineage (pop 3) @@ -206,6 +208,7 @@ test "mcp_sample_data_t_cell_rich_tumor_a" { assert_true(t_cell_a > b_cell_a) } +///| test "mcp_sample_data_b_cell_rich_tumor_b" { // Tumor_B is B-cell rich: B lineage should score higher than T cells let (genes, samples, matrix) = @src.mcp_sample_data() @@ -215,6 +218,7 @@ test "mcp_sample_data_b_cell_rich_tumor_b" { assert_true(b_cell_b > t_cell_b) } +///| test "mcp_sample_data_fibroblast_rich_tumor_c" { // Tumor_C is fibroblast-rich: Fibroblasts (pop 9) should score higher than T cells let (genes, samples, matrix) = @src.mcp_sample_data() @@ -228,6 +232,7 @@ test "mcp_sample_data_fibroblast_rich_tumor_c" { // to_string formatting // --------------------------------------------------------------------------- +///| test "mcp_result_to_string" { let (genes, samples, matrix) = @src.mcp_sample_data() let result = @src.mcp_run(genes, samples, matrix) @@ -242,44 +247,35 @@ test "mcp_result_to_string" { // Empty / edge cases // --------------------------------------------------------------------------- +///| test "mcp_run_empty_population_list" { - let result = @src.mcp_run( - ["G1"], - ["S1"], - [[1.0]], - populations=[], - ) + let result = @src.mcp_run(["G1"], ["S1"], [[1.0]], populations=[]) assert_eq(result.populations().length(), 0) assert_eq(result.sample_names().length(), 1) } +///| test "mcp_run_no_samples" { let pop = @src.McpCellPopulation::new("Test", ["G1"]) - let result = @src.mcp_run( - ["G1"], - [], - [], - populations=[pop], - ) + let result = @src.mcp_run(["G1"], [], [], populations=[pop]) assert_eq(result.sample_names().length(), 0) assert_eq(result.scores().length(), 1) // 1 population row, but empty assert_eq(result.scores()[0].length(), 0) } +///| test "mcp_run_geometric_mean_with_negative_values" { // Negative expression values are skipped (treated as invalid) let pop = @src.McpCellPopulation::new("Test", ["G1", "G2"]) - let result = @src.mcp_run( - ["G1", "G2"], - ["S1"], - [[-1.0], [9.0]], - populations=[pop], - ) + let result = @src.mcp_run(["G1", "G2"], ["S1"], [[-1.0], [9.0]], populations=[ + pop, + ]) // Only G2 contributes -> geometric mean = 9.0 let s = result.get_score("Test", "S1") assert_true((s - 9.0).abs() < 1.0e-9) } +///| test "mcp_run_custom_populations" { // Custom populations list with non-default markers let custom_pop = @src.McpCellPopulation::new("Custom", ["G1", "G2", "G3"]) diff --git a/test/moonbit/melting_temp_test.mbt b/test/moonbit/melting_temp_test.mbt index 00552af2..c9f4ad9e 100644 --- a/test/moonbit/melting_temp_test.mbt +++ b/test/moonbit/melting_temp_test.mbt @@ -53,4 +53,4 @@ test "recommend_tm_method_long" { test "create_example_dna" { let seq = @src.create_example_dna() assert_true(seq.length() > 0) -} \ No newline at end of file +} diff --git a/test/moonbit/meme_test.mbt b/test/moonbit/meme_test.mbt index e249cbfc..3946a1c2 100644 --- a/test/moonbit/meme_test.mbt +++ b/test/moonbit/meme_test.mbt @@ -3,10 +3,7 @@ ///| test "meme_motif_new" { - let pspm = [ - [0.25, 0.25, 0.25, 0.25], - [0.5, 0.0, 0.5, 0.0], - ] + let pspm = [[0.25, 0.25, 0.25, 0.25], [0.5, 0.0, 0.5, 0.0]] let motif = @src.MemeMotif::new("motif1", pspm) assert_eq(motif.name, "motif1") assert_eq(motif.alt_name, "") @@ -27,11 +24,7 @@ test "meme_motif_new_custom_alphabet" { ///| test "meme_motif_consensus" { - let pspm = [ - [0.9, 0.0, 0.1, 0.0], - [0.0, 0.8, 0.0, 0.2], - [0.1, 0.0, 0.9, 0.0], - ] + let pspm = [[0.9, 0.0, 0.1, 0.0], [0.0, 0.8, 0.0, 0.2], [0.1, 0.0, 0.9, 0.0]] let motif = @src.MemeMotif::new("m1", pspm, alphabet="ACGT") let cons = motif.consensus() assert_eq(cons, "ACG") @@ -39,10 +32,7 @@ test "meme_motif_consensus" { ///| test "meme_motif_probability" { - let pspm = [ - [0.9, 0.0, 0.1, 0.0], - [0.0, 0.8, 0.0, 0.2], - ] + let pspm = [[0.9, 0.0, 0.1, 0.0], [0.0, 0.8, 0.0, 0.2]] let motif = @src.MemeMotif::new("m1", pspm, alphabet="ACGT") assert_eq(motif.probability("A", 0), 0.9) assert_eq(motif.probability("C", 0), 0.0) @@ -55,10 +45,7 @@ test "meme_motif_probability" { ///| test "meme_motif_information_content" { - let pspm = [ - [1.0, 0.0, 0.0, 0.0], - [0.25, 0.25, 0.25, 0.25], - ] + let pspm = [[1.0, 0.0, 0.0, 0.0], [0.25, 0.25, 0.25, 0.25]] let motif = @src.MemeMotif::new("m1", pspm, alphabet="ACGT") let ic = motif.information_content() // First position has max info (2 bits), second has 0 diff --git a/test/moonbit/metagenomeseq_test.mbt b/test/moonbit/metagenomeseq_test.mbt index 82c75bbd..36f66e2d 100644 --- a/test/moonbit/metagenomeseq_test.mbt +++ b/test/moonbit/metagenomeseq_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for metagenomeSeq module. - test "MRexperiment creation" { let counts = [[10, 20], [30, 40]] let taxa_names = ["Bacteroides", "Firmicutes"] @@ -10,25 +9,31 @@ test "MRexperiment creation" { assert_eq(obj.sample_names.length(), 2) } +///| test "mg_normalize_counts" { let obj = @src.create_example_mrexperiment() let normalized = @src.mg_normalize_counts(obj) assert_eq(normalized.counts.length(), obj.counts.length()) } +///| test "mg_calculate_zero_inflation" { let obj = @src.create_example_mrexperiment() let zero_probs = @src.mg_calculate_zero_inflation(obj) assert_eq(zero_probs.length(), obj.taxa_names.length()) } +///| test "mg_test_zero_inflated" { let obj = @src.create_example_mrexperiment() - let group = ["control", "control", "control", "treatment", "treatment", "treatment"] + let group = [ + "control", "control", "control", "treatment", "treatment", "treatment", + ] let results = @src.mg_test_zero_inflated(obj, group) assert_eq(results.length(), obj.taxa_names.length()) } +///| test "MRSampleData creation" { let sd = @src.MRSampleData::new("control", 100000) assert_eq(sd.group, "control") diff --git a/test/moonbit/methyl_seekr_test.mbt b/test/moonbit/methyl_seekr_test.mbt index 043b2b92..a0cbda51 100644 --- a/test/moonbit/methyl_seekr_test.mbt +++ b/test/moonbit/methyl_seekr_test.mbt @@ -219,7 +219,9 @@ test "msr_tiling_single_site" { assert_eq(@src.MethylTile::start(tiles[0]), 0) assert_eq(@src.MethylTile::end(tiles[0]), 1000) assert_eq(@src.MethylTile::coverage(tiles[0]), 10) - assert_true((@src.MethylTile::methylation_level(tiles[0]) - 0.4).abs() < 0.000001) + assert_true( + (@src.MethylTile::methylation_level(tiles[0]) - 0.4).abs() < 0.000001, + ) // Newly created tiles default to "FMR". assert_eq(@src.MethylTile::region_type(tiles[0]), "FMR") } @@ -229,9 +231,24 @@ test "msr_tiling_boundaries" { // A site at position 999 falls in tile [0,1000); at 1000 in [1000,2000). let params = @src.MethylSeekRParams::default() let sites = [ - @src.CytosineSite::new(chr="chr1", position=999, methylated=1, unmethylated=0), - @src.CytosineSite::new(chr="chr1", position=1000, methylated=1, unmethylated=0), - @src.CytosineSite::new(chr="chr1", position=2500, methylated=0, unmethylated=1), + @src.CytosineSite::new( + chr="chr1", + position=999, + methylated=1, + unmethylated=0, + ), + @src.CytosineSite::new( + chr="chr1", + position=1000, + methylated=1, + unmethylated=0, + ), + @src.CytosineSite::new( + chr="chr1", + position=2500, + methylated=0, + unmethylated=1, + ), ] let tiles = @src.tile_methylation(sites, params) assert_eq(tiles.length(), 3) @@ -248,8 +265,18 @@ test "msr_tiling_methylation_computation" { // Two sites in the same tile: (3,7) and (2,8) -> meth=5, unmeth=15 -> 0.25. let params = @src.MethylSeekRParams::default() let sites = [ - @src.CytosineSite::new(chr="chr1", position=100, methylated=3, unmethylated=7), - @src.CytosineSite::new(chr="chr1", position=200, methylated=2, unmethylated=8), + @src.CytosineSite::new( + chr="chr1", + position=100, + methylated=3, + unmethylated=7, + ), + @src.CytosineSite::new( + chr="chr1", + position=200, + methylated=2, + unmethylated=8, + ), ] let tiles = @src.tile_methylation(sites, params) assert_eq(tiles.length(), 1) @@ -264,9 +291,24 @@ test "msr_tiling_coverage_aggregation" { // Coverage from multiple sites is summed per tile. let params = @src.MethylSeekRParams::default() let sites = [ - @src.CytosineSite::new(chr="chr1", position=100, methylated=1, unmethylated=4), - @src.CytosineSite::new(chr="chr1", position=200, methylated=2, unmethylated=3), - @src.CytosineSite::new(chr="chr1", position=300, methylated=0, unmethylated=5), + @src.CytosineSite::new( + chr="chr1", + position=100, + methylated=1, + unmethylated=4, + ), + @src.CytosineSite::new( + chr="chr1", + position=200, + methylated=2, + unmethylated=3, + ), + @src.CytosineSite::new( + chr="chr1", + position=300, + methylated=0, + unmethylated=5, + ), ] let tiles = @src.tile_methylation(sites, params) assert_eq(tiles.length(), 1) @@ -282,9 +324,24 @@ test "msr_tiling_multiple_chromosomes" { // Tiles are sorted by chromosome name then start. let params = @src.MethylSeekRParams::default() let sites = [ - @src.CytosineSite::new(chr="chr2", position=50, methylated=1, unmethylated=1), - @src.CytosineSite::new(chr="chr1", position=100, methylated=1, unmethylated=1), - @src.CytosineSite::new(chr="chr1", position=1500, methylated=1, unmethylated=1), + @src.CytosineSite::new( + chr="chr2", + position=50, + methylated=1, + unmethylated=1, + ), + @src.CytosineSite::new( + chr="chr1", + position=100, + methylated=1, + unmethylated=1, + ), + @src.CytosineSite::new( + chr="chr1", + position=1500, + methylated=1, + unmethylated=1, + ), ] let tiles = @src.tile_methylation(sites, params) assert_eq(tiles.length(), 3) @@ -786,7 +843,12 @@ test "msr_edge_empty_pipeline" { test "msr_edge_single_site" { let params = @src.MethylSeekRParams::default() let sites = [ - @src.CytosineSite::new(chr="chr1", position=100, methylated=0, unmethylated=20), + @src.CytosineSite::new( + chr="chr1", + position=100, + methylated=0, + unmethylated=20, + ), ] let regions = @src.call_methylation_regimes(sites, params) // Single tile of 1000 bp >= min_region_size (500) -> one UMR region. @@ -848,7 +910,12 @@ test "msr_edge_zero_coverage_sites" { // which classifies as FMR (insufficient coverage). let params = @src.MethylSeekRParams::default() let sites = [ - @src.CytosineSite::new(chr="chr1", position=100, methylated=0, unmethylated=0), + @src.CytosineSite::new( + chr="chr1", + position=100, + methylated=0, + unmethylated=0, + ), ] let tiles = @src.tile_methylation(sites, params) assert_eq(tiles.length(), 1) diff --git a/test/moonbit/methylkit_test.mbt b/test/moonbit/methylkit_test.mbt index 566f93c7..5f48f9db 100644 --- a/test/moonbit/methylkit_test.mbt +++ b/test/moonbit/methylkit_test.mbt @@ -22,7 +22,9 @@ test "methylkit_cytosine_coverage_pct" { // 50% methylation let mc_half = @src.MethylCytosine::new("chr1", 200, "-", "CG", 5, 5) assert_eq(@src.MethylCytosine::coverage(mc_half), 10) - assert_true((@src.MethylCytosine::methylation_pct(mc_half) - 50.0).abs() < 0.001) + assert_true( + (@src.MethylCytosine::methylation_pct(mc_half) - 50.0).abs() < 0.001, + ) // Zero coverage -> coverage 0 and pct 0.0 let mc0 = @src.MethylCytosine::new("chr1", 300, "+", "CG", 0, 0) assert_eq(@src.MethylCytosine::coverage(mc0), 0) @@ -151,7 +153,9 @@ test "methylkit_config_defaults" { assert_eq(@src.MethylKitConfig::min_coverage(config), 10) assert_eq(@src.MethylKitConfig::max_coverage(config), 999) assert_eq(@src.MethylKitConfig::context_filter(config), "CG") - assert_true((@src.MethylKitConfig::min_perc_samples(config) - 0.6).abs() < 0.001) + assert_true( + (@src.MethylKitConfig::min_perc_samples(config) - 0.6).abs() < 0.001, + ) assert_true((@src.MethylKitConfig::min_diff(config) - 25.0).abs() < 0.001) assert_true((@src.MethylKitConfig::q_threshold(config) - 0.05).abs() < 0.001) } @@ -162,7 +166,9 @@ test "methylkit_config_with_params" { assert_eq(@src.MethylKitConfig::min_coverage(config), 5) assert_eq(@src.MethylKitConfig::max_coverage(config), 500) assert_eq(@src.MethylKitConfig::context_filter(config), "CHG") - assert_true((@src.MethylKitConfig::min_perc_samples(config) - 0.8).abs() < 0.001) + assert_true( + (@src.MethylKitConfig::min_perc_samples(config) - 0.8).abs() < 0.001, + ) assert_true((@src.MethylKitConfig::min_diff(config) - 30.0).abs() < 0.001) assert_true((@src.MethylKitConfig::q_threshold(config) - 0.01).abs() < 0.001) } @@ -466,9 +472,13 @@ test "methylkit_sample_data" { assert_eq(@src.MethylSample::n_cpgs(control), 20) assert_eq(@src.MethylSample::n_cpgs(treatment), 20) // Control: every CpG at 50% methylation. - assert_true((@src.MethylSample::mean_methylation(control) - 50.0).abs() < 0.001) + assert_true( + (@src.MethylSample::mean_methylation(control) - 50.0).abs() < 0.001, + ) // Treatment: 5 hyper (90%) + 5 hypo (10%) + 10 same (50%) -> mean 50%. - assert_true((@src.MethylSample::mean_methylation(treatment) - 50.0).abs() < 0.001) + assert_true( + (@src.MethylSample::mean_methylation(treatment) - 50.0).abs() < 0.001, + ) // Treatment CpG 0: hyper-methylated (18, 2). let t0 = @src.MethylSample::coverage(treatment)[0] assert_eq(@src.MethylCytosine::methylated(t0), 18) diff --git a/test/moonbit/microbiome_test.mbt b/test/moonbit/microbiome_test.mbt index 3337a2e9..c91708fa 100644 --- a/test/moonbit/microbiome_test.mbt +++ b/test/moonbit/microbiome_test.mbt @@ -11,12 +11,14 @@ test "calc_observed basic" { assert_eq(observed, 4.0) } +///| test "calc_observed all zeros" { let counts : Array[Double] = [0.0, 0.0, 0.0] let observed = @src.calc_observed(counts) assert_eq(observed, 0.0) } +///| test "calc_shannon even" { let counts : Array[Double] = [10.0, 10.0, 10.0, 10.0] let shannon = @src.calc_shannon(counts) @@ -24,12 +26,14 @@ test "calc_shannon even" { assert_true(shannon > 1.3 && shannon < 1.5) } +///| test "calc_shannon single taxon" { let counts : Array[Double] = [100.0] let shannon = @src.calc_shannon(counts) assert_eq(shannon, 0.0) } +///| test "calc_simpson even" { let counts : Array[Double] = [10.0, 10.0, 10.0, 10.0] let simpson = @src.calc_simpson(counts) @@ -37,12 +41,14 @@ test "calc_simpson even" { assert_true(simpson > 0.7 && simpson < 0.8) } +///| test "calc_simpson single taxon" { let counts : Array[Double] = [100.0] let simpson = @src.calc_simpson(counts) assert_eq(simpson, 0.0) } +///| test "calc_inv_simpson even" { let counts : Array[Double] = [10.0, 10.0, 10.0, 10.0] let inv_simpson = @src.calc_inv_simpson(counts) @@ -50,6 +56,7 @@ test "calc_inv_simpson even" { assert_true(inv_simpson > 3.5 && inv_simpson < 4.5) } +///| test "calc_pielou_evenness even" { let counts : Array[Double] = [10.0, 10.0, 10.0, 10.0] let pielou = @src.calc_pielou_evenness(counts) @@ -57,12 +64,14 @@ test "calc_pielou_evenness even" { assert_true(pielou > 0.95) } +///| test "calc_pielou_evenness single taxon" { let counts : Array[Double] = [100.0] let pielou = @src.calc_pielou_evenness(counts) assert_eq(pielou, 0.0) } +///| test "calc_chao1 basic" { let counts : Array[Double] = [10.0, 5.0, 3.0, 1.0, 1.0, 2.0, 2.0] let chao1 = @src.calc_chao1(counts) @@ -71,12 +80,14 @@ test "calc_chao1 basic" { assert_true(chao1 >= 7.0) } +///| test "calc_fisher_alpha basic" { let counts : Array[Double] = [100.0, 50.0, 30.0, 20.0, 10.0] let alpha = @src.calc_fisher_alpha(counts) assert_true(alpha > 0.0) } +///| test "calc_alpha_diversity all indices" { let counts : Array[Double] = [10.0, 20.0, 15.0, 5.0, 25.0] let div = @src.calc_alpha_diversity(counts) @@ -87,6 +98,7 @@ test "calc_alpha_diversity all indices" { assert_true(div.chao1 >= div.observed) } +///| test "calc_alpha_diversity_table multiple samples" { let otu_table = @src.create_example_otu_table() let div_table = @src.calc_alpha_diversity_table(otu_table) @@ -99,6 +111,7 @@ test "calc_alpha_diversity_table multiple samples" { // Beta Diversity Tests // ============================================================ +///| test "bray_curtis identical" { let x : Array[Double] = [10.0, 20.0, 30.0] let y : Array[Double] = [10.0, 20.0, 30.0] @@ -106,6 +119,7 @@ test "bray_curtis identical" { assert_eq(bc, 0.0) } +///| test "bray_curtis completely different" { let x : Array[Double] = [10.0, 0.0, 0.0] let y : Array[Double] = [0.0, 20.0, 30.0] @@ -114,6 +128,7 @@ test "bray_curtis completely different" { assert_eq(bc, 1.0) } +///| test "bray_curtis partial overlap" { let x : Array[Double] = [10.0, 20.0, 0.0] let y : Array[Double] = [10.0, 0.0, 20.0] @@ -121,6 +136,7 @@ test "bray_curtis partial overlap" { assert_true(bc > 0.0 && bc < 1.0) } +///| test "jaccard_distance identical" { let x : Array[Double] = [10.0, 20.0, 30.0] let y : Array[Double] = [5.0, 10.0, 15.0] @@ -128,6 +144,7 @@ test "jaccard_distance identical" { assert_eq(jaccard, 0.0) } +///| test "jaccard_distance no overlap" { let x : Array[Double] = [10.0, 0.0, 0.0] let y : Array[Double] = [0.0, 20.0, 30.0] @@ -135,6 +152,7 @@ test "jaccard_distance no overlap" { assert_eq(jaccard, 1.0) } +///| test "jaccard_distance partial" { let x : Array[Double] = [10.0, 20.0, 0.0] let y : Array[Double] = [10.0, 0.0, 20.0] @@ -143,6 +161,7 @@ test "jaccard_distance partial" { assert_true(jaccard > 0.6 && jaccard < 0.7) } +///| test "jensen_shannon_divergence identical" { let x : Array[Double] = [10.0, 20.0, 30.0] let y : Array[Double] = [10.0, 20.0, 30.0] @@ -150,6 +169,7 @@ test "jensen_shannon_divergence identical" { assert_eq(jsd, 0.0) } +///| test "jensen_shannon_divergence symmetric" { let x : Array[Double] = [10.0, 20.0, 30.0] let y : Array[Double] = [30.0, 20.0, 10.0] @@ -158,6 +178,7 @@ test "jensen_shannon_divergence symmetric" { assert_true((jsd_xy - jsd_yx).abs() < 0.0001) } +///| test "calc_beta_diversity_matrix bray" { let otu_table = @src.create_example_otu_table() let dist_matrix = @src.calc_beta_diversity_matrix(otu_table, "bray") @@ -170,6 +191,7 @@ test "calc_beta_diversity_matrix bray" { assert_true((dist_matrix[0][1] - dist_matrix[1][0]).abs() < 0.0001) } +///| test "calc_beta_diversity_matrix jaccard" { let otu_table = @src.create_example_otu_table() let dist_matrix = @src.calc_beta_diversity_matrix(otu_table, "jaccard") @@ -177,6 +199,7 @@ test "calc_beta_diversity_matrix jaccard" { assert_true(dist_matrix[0][3] > 0.0) } +///| test "calc_beta_diversity_matrix jsd" { let otu_table = @src.create_example_otu_table() let dist_matrix = @src.calc_beta_diversity_matrix(otu_table, "jsd") @@ -188,22 +211,24 @@ test "calc_beta_diversity_matrix jsd" { // PCoA Tests // ============================================================ +///| test "pcoa basic" { let otu_table = @src.create_example_otu_table() let dist_matrix = @src.calc_beta_diversity_matrix(otu_table, "bray") let pcoa_result = @src.pcoa(dist_matrix) - + assert_true(pcoa_result.eigenvalues.length() > 0) assert_true(pcoa_result.vectors.length() == 6) assert_true(pcoa_result.variance_explained.length() > 0) assert_true(pcoa_result.cumulative_variance.length() > 0) } +///| test "pcoa eigenvalues positive" { let otu_table = @src.create_example_otu_table() let dist_matrix = @src.calc_beta_diversity_matrix(otu_table, "bray") let pcoa_result = @src.pcoa(dist_matrix) - + let mut i = 0 while i < pcoa_result.eigenvalues.length() { assert_true(pcoa_result.eigenvalues[i] >= 0.0) @@ -211,17 +236,19 @@ test "pcoa eigenvalues positive" { } } +///| test "pcoa has vectors" { let otu_table = @src.create_example_otu_table() let dist_matrix = @src.calc_beta_diversity_matrix(otu_table, "bray") let pcoa_result = @src.pcoa(dist_matrix) - + assert_true(pcoa_result.vectors.length() == 6) if pcoa_result.vectors.length() > 0 { assert_true(pcoa_result.vectors[0].length() > 0) } } +///| test "pcoa single sample" { let dist_matrix : Array[Array[Double]] = [[0.0]] let pcoa_result = @src.pcoa(dist_matrix) @@ -232,41 +259,50 @@ test "pcoa single sample" { // Differential Abundance Tests // ============================================================ +///| test "differential_abundance basic" { let otu_table = @src.create_example_otu_table() let taxa_names = @src.get_example_taxa_names() let group1 : Array[Int] = [0, 1, 2] let group2 : Array[Int] = [3, 4, 5] - - let results = @src.differential_abundance(otu_table, taxa_names, group1, group2) - + + let results = @src.differential_abundance( + otu_table, taxa_names, group1, group2, + ) + assert_eq(results.length(), 10) assert_eq(results[0].taxa, "Bacteroides") assert_true(results[0].p_value >= 0.0 && results[0].p_value <= 1.0) assert_true(results[0].adjusted_p_value >= results[0].p_value) } +///| test "differential_abundance log2_fc direction" { let otu_table = @src.create_example_otu_table() let taxa_names = @src.get_example_taxa_names() - let group1 : Array[Int] = [0, 1, 2] // control - let group2 : Array[Int] = [3, 4, 5] // treatment - - let results = @src.differential_abundance(otu_table, taxa_names, group1, group2) - + let group1 : Array[Int] = [0, 1, 2] // control + let group2 : Array[Int] = [3, 4, 5] // treatment + + let results = @src.differential_abundance( + otu_table, taxa_names, group1, group2, + ) + // Taxon 0 (Bacteroides) is high in control, so log2FC should be negative assert_true(results[0].log2_fold_change < 0.0) // Taxon 1 (Prevotella) is high in treatment, so log2FC should be positive assert_true(results[1].log2_fold_change > 0.0) } +///| test "differential_abundance empty input" { let otu_table : Array[Array[Double]] = [] let taxa_names : Array[String] = [] let group1 : Array[Int] = [0, 1] let group2 : Array[Int] = [2, 3] - - let results = @src.differential_abundance(otu_table, taxa_names, group1, group2) + + let results = @src.differential_abundance( + otu_table, taxa_names, group1, group2, + ) assert_eq(results.length(), 0) } @@ -274,12 +310,14 @@ test "differential_abundance empty input" { // Helper function tests // ============================================================ +///| test "create_example_otu_table dimensions" { let otu_table = @src.create_example_otu_table() - assert_eq(otu_table.length(), 10) // 10 taxa - assert_eq(otu_table[0].length(), 6) // 6 samples + assert_eq(otu_table.length(), 10) // 10 taxa + assert_eq(otu_table[0].length(), 6) // 6 samples } +///| test "get_example_taxa_names" { let names = @src.get_example_taxa_names() assert_eq(names.length(), 10) diff --git a/test/moonbit/missmethyl_test.mbt b/test/moonbit/missmethyl_test.mbt index d87af891..c2d43cfc 100644 --- a/test/moonbit/missmethyl_test.mbt +++ b/test/moonbit/missmethyl_test.mbt @@ -119,7 +119,7 @@ test "mm_beta_to_m_basic" { assert_true(m.abs() < 0.01) // beta = 0.25 -> M = log2(0.25/0.75) = log2(1/3) ≈ -1.585 let m2 = @src.mm_beta_to_m(0.25) - assert_true((m2 - (-1.585)).abs() < 0.01) + assert_true((m2 - -1.585).abs() < 0.01) // beta = 0.75 -> M = log2(0.75/0.25) = log2(3) ≈ 1.585 let m3 = @src.mm_beta_to_m(0.75) assert_true((m3 - 1.585).abs() < 0.01) @@ -360,14 +360,11 @@ test "mm_go_enrichment_sample" { let annotations = @src.mm_sample_annotations() let go_db = @src.mm_sample_go_database() let all_probes : Array[String] = [ - "cg001", "cg002", "cg003", "cg004", "cg005", - "cg006", "cg007", "cg008", "cg009", "cg010", - "cg011", "cg012", "cg013", "cg014", "cg015", - "cg016", "cg017", "cg018", "cg019", "cg020", - ] - let sig_probes : Array[String] = [ - "cg001", "cg002", "cg003", "cg004", "cg005", + "cg001", "cg002", "cg003", "cg004", "cg005", "cg006", "cg007", "cg008", "cg009", + "cg010", "cg011", "cg012", "cg013", "cg014", "cg015", "cg016", "cg017", "cg018", + "cg019", "cg020", ] + let sig_probes : Array[String] = ["cg001", "cg002", "cg003", "cg004", "cg005"] let results = @src.mm_go_enrichment( sig_probes, all_probes, annotations, go_db, ) @@ -387,14 +384,11 @@ test "mm_go_enrichment_finds_enriched" { let annotations = @src.mm_sample_annotations() let go_db = @src.mm_sample_go_database() let all_probes : Array[String] = [ - "cg001", "cg002", "cg003", "cg004", "cg005", - "cg006", "cg007", "cg008", "cg009", "cg010", - "cg011", "cg012", "cg013", "cg014", "cg015", - "cg016", "cg017", "cg018", "cg019", "cg020", - ] - let sig_probes : Array[String] = [ - "cg001", "cg002", "cg003", "cg004", "cg005", + "cg001", "cg002", "cg003", "cg004", "cg005", "cg006", "cg007", "cg008", "cg009", + "cg010", "cg011", "cg012", "cg013", "cg014", "cg015", "cg016", "cg017", "cg018", + "cg019", "cg020", ] + let sig_probes : Array[String] = ["cg001", "cg002", "cg003", "cg004", "cg005"] let results = @src.mm_go_enrichment( sig_probes, all_probes, annotations, go_db, ) @@ -420,14 +414,11 @@ test "mm_probe_bias_correction_sample" { let annotations = @src.mm_sample_annotations() let go_db = @src.mm_sample_go_database() let all_probes : Array[String] = [ - "cg001", "cg002", "cg003", "cg004", "cg005", - "cg006", "cg007", "cg008", "cg009", "cg010", - "cg011", "cg012", "cg013", "cg014", "cg015", - "cg016", "cg017", "cg018", "cg019", "cg020", - ] - let sig_probes : Array[String] = [ - "cg001", "cg002", "cg003", "cg004", "cg005", + "cg001", "cg002", "cg003", "cg004", "cg005", "cg006", "cg007", "cg008", "cg009", + "cg010", "cg011", "cg012", "cg013", "cg014", "cg015", "cg016", "cg017", "cg018", + "cg019", "cg020", ] + let sig_probes : Array[String] = ["cg001", "cg002", "cg003", "cg004", "cg005"] let results = @src.mm_probe_bias_correction( sig_probes, all_probes, annotations, go_db, ) @@ -460,14 +451,11 @@ test "mm_go_summary_nonempty" { let annotations = @src.mm_sample_annotations() let go_db = @src.mm_sample_go_database() let all_probes : Array[String] = [ - "cg001", "cg002", "cg003", "cg004", "cg005", - "cg006", "cg007", "cg008", "cg009", "cg010", - "cg011", "cg012", "cg013", "cg014", "cg015", - "cg016", "cg017", "cg018", "cg019", "cg020", - ] - let sig_probes : Array[String] = [ - "cg001", "cg002", "cg003", "cg004", "cg005", + "cg001", "cg002", "cg003", "cg004", "cg005", "cg006", "cg007", "cg008", "cg009", + "cg010", "cg011", "cg012", "cg013", "cg014", "cg015", "cg016", "cg017", "cg018", + "cg019", "cg020", ] + let sig_probes : Array[String] = ["cg001", "cg002", "cg003", "cg004", "cg005"] let results = @src.mm_go_enrichment( sig_probes, all_probes, annotations, go_db, ) @@ -573,9 +561,7 @@ test "mm_edge_all_same_group" { let beta = @src.mm_sample_beta() let annotations = @src.mm_sample_annotations() // All samples in treatment group (no control). - let group = [ - true, true, true, true, true, true, true, true, - ] + let group = [true, true, true, true, true, true, true, true] let results = @src.mm_dmp_analysis(beta, group, annotations) assert_eq(results.length(), 20) // With no control group, all p-values should be 1.0. diff --git a/test/moonbit/mix_omics_test.mbt b/test/moonbit/mix_omics_test.mbt index 0c8c911f..53a4dce9 100644 --- a/test/moonbit/mix_omics_test.mbt +++ b/test/moonbit/mix_omics_test.mbt @@ -54,7 +54,14 @@ test "diablo_new_defaults" { ///| test "diablo_options_full_custom" { let design = [[0.0, 1.0], [1.0, 0.0]] - let opts = @src.diablo_options_full(3, [[2, 3], [1]], design, false, 200, 1.0e-7) + let opts = @src.diablo_options_full( + 3, + [[2, 3], [1]], + design, + false, + 200, + 1.0e-7, + ) assert_eq(opts.ncomp, 3) assert_eq(opts.keep_variables.length(), 2) assert_eq(opts.keep_variables[0].length(), 2) @@ -106,12 +113,7 @@ test "pls_component_extraction" { ///| test "pls_single_component" { - let x = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 4.0], - [4.0, 5.0], - ] + let x = [[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0]] let y = [[1.0], [2.0], [3.0], [4.0]] let opts = @src.pls_options_full(1, "regression", true, 500, 0.000001) let result = @src.run_pls(x, y, opts) @@ -140,16 +142,12 @@ test "pls_nipals_convergence" { ///| test "pls_data_scaling" { - let x = [ - [1.0, 100.0], - [2.0, 200.0], - [3.0, 300.0], - [4.0, 400.0], - [5.0, 500.0], - ] + let x = [[1.0, 100.0], [2.0, 200.0], [3.0, 300.0], [4.0, 400.0], [5.0, 500.0]] let y = [[1.0], [2.0], [3.0], [4.0], [5.0]] let opts_scaled = @src.pls_options_full(1, "regression", true, 500, 0.000001) - let opts_unscaled = @src.pls_options_full(1, "regression", false, 500, 0.000001) + let opts_unscaled = @src.pls_options_full( + 1, "regression", false, 500, 0.000001, + ) let result_scaled = @src.run_pls(x, y, opts_scaled) let result_unscaled = @src.run_pls(x, y, opts_unscaled) assert_true(result_scaled.ncomp >= 1) @@ -183,11 +181,7 @@ test "pls_ncomp_exceeds_samples" { ///| test "pls_ncomp_exceeds_variables" { - let x = [ - [1.0, 2.0, 3.0], - [2.0, 3.0, 4.0], - [3.0, 4.0, 5.0], - ] + let x = [[1.0, 2.0, 3.0], [2.0, 3.0, 4.0], [3.0, 4.0, 5.0]] let y = [[1.0], [2.0], [3.0]] let opts = @src.pls_options_full(10, "regression", true, 500, 0.000001) let result = @src.run_pls(x, y, opts) @@ -219,13 +213,7 @@ test "pls_single_sample" { ///| test "pls_multivariate_y" { - let x = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 4.0], - [4.0, 5.0], - [5.0, 6.0], - ] + let x = [[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0], [5.0, 6.0]] let y = [[1.0, 0.5], [2.0, 1.0], [3.0, 1.5], [4.0, 2.0], [5.0, 2.5]] let opts = @src.pls_new() let result = @src.run_pls(x, y, opts) @@ -235,13 +223,7 @@ test "pls_multivariate_y" { ///| test "pls_canonical_mode" { - let x = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 4.0], - [4.0, 5.0], - [5.0, 6.0], - ] + let x = [[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0], [5.0, 6.0]] let y = [[1.0], [2.0], [3.0], [4.0], [5.0]] let opts = @src.pls_options_full(2, "canonical", true, 500, 0.000001) let result = @src.run_pls(x, y, opts) @@ -339,7 +321,7 @@ test "soft_thresholding_operator" { let result1 = @src.soft_threshold(3.0, 1.0) assert_true((result1 - 2.0).abs() < 1.0e-15) let result2 = @src.soft_threshold(-3.0, 1.0) - assert_true((result2 - (-2.0)).abs() < 1.0e-15) + assert_true((result2 - -2.0).abs() < 1.0e-15) let result3 = @src.soft_threshold(0.5, 1.0) assert_true(result3.abs() < 1.0e-15) let result4 = @src.soft_threshold(0.0, 0.0) @@ -355,13 +337,7 @@ test "diablo_two_blocks" { [4.0, 5.0, 6.0], [5.0, 6.0, 7.0], ] - let block2 = [ - [1.0, 0.5], - [2.0, 1.0], - [3.0, 1.5], - [4.0, 2.0], - [5.0, 2.5], - ] + let block2 = [[1.0, 0.5], [2.0, 1.0], [3.0, 1.5], [4.0, 2.0], [5.0, 2.5]] let blocks = [block1, block2] let names = ["block1", "block2"] let design = [[0.0, 1.0], [1.0, 0.0]] @@ -390,25 +366,22 @@ test "diablo_variable_selection" { let blocks = [block1, block2] let names = ["block1", "block2"] let design = [[0.0, 1.0], [1.0, 0.0]] - let opts = @src.diablo_options_full(1, [[2], [1]], design, true, 500, 0.000001) + let opts = @src.diablo_options_full( + 1, + [[2], [1]], + design, + true, + 500, + 0.000001, + ) let result = @src.run_diablo(blocks, names, opts) assert_true(result.ncomp >= 1) } ///| test "diablo_default_behavior" { - let block1 = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 4.0], - [4.0, 5.0], - ] - let block2 = [ - [1.0, 0.5], - [2.0, 1.0], - [3.0, 1.5], - [4.0, 2.0], - ] + let block1 = [[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0]] + let block2 = [[1.0, 0.5], [2.0, 1.0], [3.0, 1.5], [4.0, 2.0]] let blocks = [block1, block2] let names = ["block1", "block2"] let opts = @src.diablo_new() @@ -419,11 +392,7 @@ test "diablo_default_behavior" { ///| test "diablo_single_block" { - let block1 = [ - [1.0, 2.0, 3.0], - [2.0, 3.0, 4.0], - [3.0, 4.0, 5.0], - ] + let block1 = [[1.0, 2.0, 3.0], [2.0, 3.0, 4.0], [3.0, 4.0, 5.0]] let blocks = [block1] let names = ["block1"] let design = [[0.0]] @@ -528,13 +497,7 @@ test "diablo_result_structure" { ///| test "pls_mode_regression" { - let x = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 4.0], - [4.0, 5.0], - [5.0, 6.0], - ] + let x = [[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0], [5.0, 6.0]] let y = [[1.0], [2.0], [3.0], [4.0], [5.0]] let opts = @src.pls_options_full(2, "regression", true, 500, 0.000001) let result = @src.run_pls(x, y, opts) @@ -544,13 +507,7 @@ test "pls_mode_regression" { ///| test "pls_mode_invariant_scores" { - let x = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 4.0], - [4.0, 5.0], - [5.0, 6.0], - ] + let x = [[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0], [5.0, 6.0]] let y = [[1.0], [2.0], [3.0], [4.0], [5.0]] let opts = @src.pls_options_full(1, "regression", false, 500, 0.000001) let result = @src.run_pls(x, y, opts) @@ -574,12 +531,7 @@ test "diablo_block_names" { ///| test "pls_result_has_explained_variance" { - let x = [ - [1.0, 2.0, 3.0], - [2.0, 3.0, 4.0], - [3.0, 4.0, 5.0], - [4.0, 5.0, 6.0], - ] + let x = [[1.0, 2.0, 3.0], [2.0, 3.0, 4.0], [3.0, 4.0, 5.0], [4.0, 5.0, 6.0]] let y = [[1.0], [2.0], [3.0], [4.0]] let opts = @src.pls_options_full(2, "regression", true, 500, 0.000001) let result = @src.run_pls(x, y, opts) @@ -601,4 +553,4 @@ test "spls_selected_variables" { assert_true(result.ncomp >= 1) assert_true(result.x_selected.length() >= 1) assert_true(result.y_selected.length() >= 1) -} \ No newline at end of file +} diff --git a/test/moonbit/mmcifio_test.mbt b/test/moonbit/mmcifio_test.mbt index 00ae62a9..5cb26e47 100644 --- a/test/moonbit/mmcifio_test.mbt +++ b/test/moonbit/mmcifio_test.mbt @@ -273,36 +273,26 @@ test "mmcifio_write_single_residue" { ///| test "mmcifio_write_single_chain" { - let r1 = @src.Residue::new( - resname="ALA", - chainid='A', - resseq=1, - atoms=[ - @src.Atom::new( - name="N", - coord=@src.Vector3::new(0.0, 0.0, 0.0), - resname="ALA", - chainid='A', - resseq=1, - element="N", - ), - ], - ) - let r2 = @src.Residue::new( - resname="GLY", - chainid='A', - resseq=2, - atoms=[ - @src.Atom::new( - name="N", - coord=@src.Vector3::new(3.0, 0.0, 0.0), - resname="GLY", - chainid='A', - resseq=2, - element="N", - ), - ], - ) + let r1 = @src.Residue::new(resname="ALA", chainid='A', resseq=1, atoms=[ + @src.Atom::new( + name="N", + coord=@src.Vector3::new(0.0, 0.0, 0.0), + resname="ALA", + chainid='A', + resseq=1, + element="N", + ), + ]) + let r2 = @src.Residue::new(resname="GLY", chainid='A', resseq=2, atoms=[ + @src.Atom::new( + name="N", + coord=@src.Vector3::new(3.0, 0.0, 0.0), + resname="GLY", + chainid='A', + resseq=2, + element="N", + ), + ]) let chain = @src.Chain::new(id='A', residues=[r1, r2]) let model = @src.Model::new(id=1, chains=[chain]) let structure = @src.Structure::new(id="1CG", models=[model]) @@ -313,36 +303,26 @@ test "mmcifio_write_single_chain" { ///| test "mmcifio_write_multiple_chains" { - let r1 = @src.Residue::new( - resname="ALA", - chainid='A', - resseq=1, - atoms=[ - @src.Atom::new( - name="N", - coord=@src.Vector3::new(0.0, 0.0, 0.0), - resname="ALA", - chainid='A', - resseq=1, - element="N", - ), - ], - ) - let r2 = @src.Residue::new( - resname="GLY", - chainid='B', - resseq=1, - atoms=[ - @src.Atom::new( - name="N", - coord=@src.Vector3::new(10.0, 0.0, 0.0), - resname="GLY", - chainid='B', - resseq=1, - element="N", - ), - ], - ) + let r1 = @src.Residue::new(resname="ALA", chainid='A', resseq=1, atoms=[ + @src.Atom::new( + name="N", + coord=@src.Vector3::new(0.0, 0.0, 0.0), + resname="ALA", + chainid='A', + resseq=1, + element="N", + ), + ]) + let r2 = @src.Residue::new(resname="GLY", chainid='B', resseq=1, atoms=[ + @src.Atom::new( + name="N", + coord=@src.Vector3::new(10.0, 0.0, 0.0), + resname="GLY", + chainid='B', + resseq=1, + element="N", + ), + ]) let chain_a = @src.Chain::new(id='A', residues=[r1]) let chain_b = @src.Chain::new(id='B', residues=[r2]) let model = @src.Model::new(id=1, chains=[chain_a, chain_b]) @@ -563,26 +543,12 @@ test "mmcifio_atom_site_has_all_columns" { let site = @src.write_mmcif_atom_site(structure) // Verify all 20 column headers are present let columns = [ - "_atom_site.group_PDB", - "_atom_site.id", - "_atom_site.type_symbol", - "_atom_site.label_atom_id", - "_atom_site.label_alt_id", - "_atom_site.label_comp_id", - "_atom_site.label_asym_id", - "_atom_site.label_entity_id", - "_atom_site.label_seq_id", - "_atom_site.pdbx_PDB_ins_code", - "_atom_site.Cartn_x", - "_atom_site.Cartn_y", - "_atom_site.Cartn_z", - "_atom_site.occupancy", - "_atom_site.B_iso_or_equiv", - "_atom_site.pdbx_formal_charge", - "_atom_site.auth_seq_id", - "_atom_site.auth_comp_id", - "_atom_site.auth_asym_id", - "_atom_site.auth_atom_id", + "_atom_site.group_PDB", "_atom_site.id", "_atom_site.type_symbol", "_atom_site.label_atom_id", + "_atom_site.label_alt_id", "_atom_site.label_comp_id", "_atom_site.label_asym_id", + "_atom_site.label_entity_id", "_atom_site.label_seq_id", "_atom_site.pdbx_PDB_ins_code", + "_atom_site.Cartn_x", "_atom_site.Cartn_y", "_atom_site.Cartn_z", "_atom_site.occupancy", + "_atom_site.B_iso_or_equiv", "_atom_site.pdbx_formal_charge", "_atom_site.auth_seq_id", + "_atom_site.auth_comp_id", "_atom_site.auth_asym_id", "_atom_site.auth_atom_id", ] for col in columns { assert_eq(site.contains(col), true) diff --git a/test/moonbit/mmtf_test.mbt b/test/moonbit/mmtf_test.mbt index 6656fcf8..c7d302bc 100644 --- a/test/moonbit/mmtf_test.mbt +++ b/test/moonbit/mmtf_test.mbt @@ -72,15 +72,8 @@ test "mmtf_sec_struct_from_int_undefined" { test "mmtf_sec_struct_to_string_round_trip" { let codes = [0, 1, 2, 3, 4, 5, 6, 7, 99] let names = [ - "pi_helix", - "bend", - "alpha_helix", - "extended", - "310_helix", - "bridge", - "turn", - "coil", - "undefined", + "pi_helix", "bend", "alpha_helix", "extended", "310_helix", "bridge", "turn", + "coil", "undefined", ] for i in 0.. 0) } +///| test "mofa_convergence" { let views = @src.mofa_create_example(25, 2) - let params = @src.MofaParams::create( - n_factors = 2, - max_iterations = 50, - ) + let params = @src.MofaParams::create(n_factors=2, max_iterations=50) let result = @src.mofa_run(views, params) assert_true(result.n_iterations <= 50) } +///| test "mofa_variance_explained" { let views = @src.mofa_create_example(30, 4) - let params = @src.MofaParams::create( - n_factors = 4, - max_iterations = 30, - ) + let params = @src.MofaParams::create(n_factors=4, max_iterations=30) let result = @src.mofa_run(views, params) // Variance should be non-negative for v in result.factor_vars { @@ -77,17 +78,16 @@ test "mofa_variance_explained" { } } +///| test "mofa_active_factors" { let views = @src.mofa_create_example(20, 2) - let params = @src.MofaParams::create( - n_factors = 5, - max_iterations = 30, - ) + let params = @src.MofaParams::create(n_factors=5, max_iterations=30) let result = @src.mofa_run(views, params) assert_true(result.active_factors >= 0) assert_true(result.active_factors <= 5) } +///| test "mofa_single_view" { // Should work with a single view let data : Array[Array[Double]] = Array::new() @@ -105,20 +105,16 @@ test "mofa_single_view" { let view = @src.MofaView::new("single", data, [], []) let views : Array[@src.MofaView] = Array::new() views.push(view) - let params = @src.MofaParams::create( - n_factors = 2, - max_iterations = 15, - ) + let params = @src.MofaParams::create(n_factors=2, max_iterations=15) let result = @src.mofa_run(views, params) assert_true(result.factors.length() == 15) assert_true(result.loadings.length() == 1) } +///| test "mofa_empty_views" { let views : Array[@src.MofaView] = Array::new() - let params = @src.MofaParams::create( - n_factors = 2, - ) + let params = @src.MofaParams::create(n_factors=2) let result = @src.mofa_run(views, params) assert_true(result.factors.length() == 0) assert_true(result.converged == false) diff --git a/test/moonbit/monocle3_test.mbt b/test/moonbit/monocle3_test.mbt index a57de638..bc719667 100644 --- a/test/moonbit/monocle3_test.mbt +++ b/test/moonbit/monocle3_test.mbt @@ -1,78 +1,86 @@ +///| test "monocle3_new_cell_data_set" { let counts = [[1, 2], [3, 4]] let gene_names = ["Gene_A", "Gene_B"] let cell_names = ["Cell_1", "Cell_2"] - + let cds = @src.new_cell_data_set(counts, gene_names, cell_names) - + assert_eq(cds.counts.length(), 2) assert_eq(cds.gene_names.length(), 2) assert_eq(cds.cell_names.length(), 2) assert_eq(cds.counts[0][0], 1) } +///| test "monocle3_new_cell_data_set_empty" { let cds = @src.new_cell_data_set([], [], []) - + assert_eq(cds.counts.length(), 0) assert_eq(cds.normalized.length(), 0) } +///| test "monocle3_preprocess_cds" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() let cds = @src.new_cell_data_set(counts, gene_names, cell_names) - + let preprocessed = @src.preprocess_cds(cds, 10) - + assert_eq(preprocessed.counts.length(), 50) assert_eq(preprocessed.normalized.length(), 50) assert_eq(preprocessed.reduced_dimensions.length(), 1) } +///| test "monocle3_reduce_dimension_pca" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() let cds = @src.new_cell_data_set(counts, gene_names, cell_names) - + let reduced = @src.reduce_dimension(cds, "PCA", 5) - + assert_eq(reduced.reduced_dimensions.length(), 1) assert_eq(reduced.reduced_dimensions[0].0, "PCA") } +///| test "monocle3_reduce_dimension_umap" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() let cds = @src.new_cell_data_set(counts, gene_names, cell_names) let preprocessed = @src.preprocess_cds(cds, 10) - + let reduced = @src.reduce_dimension(preprocessed, "UMAP", 2) - + assert_true(reduced.reduced_dimensions.length() >= 2) } +///| test "monocle3_learn_graph" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() let cds = @src.new_cell_data_set(counts, gene_names, cell_names) let preprocessed = @src.preprocess_cds(cds, 10) let reduced = @src.reduce_dimension(preprocessed, "UMAP", 2) - + let with_graph = @src.learn_graph(reduced) - + assert_eq(with_graph.cell_partitions.length(), 50) assert_eq(with_graph.principal_graph.length(), 1) } +///| test "monocle3_order_cells" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() let cds = @src.new_cell_data_set(counts, gene_names, cell_names) let preprocessed = @src.preprocess_cds(cds, 10) let reduced = @src.reduce_dimension(preprocessed, "UMAP", 2) let with_graph = @src.learn_graph(reduced) - + let ordered = @src.order_cells(with_graph, [0]) - + assert_eq(ordered.pseudotime.length(), 50) } +///| test "monocle3_fit_models" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() let cds = @src.new_cell_data_set(counts, gene_names, cell_names) @@ -80,58 +88,66 @@ test "monocle3_fit_models" { let reduced = @src.reduce_dimension(preprocessed, "UMAP", 2) let with_graph = @src.learn_graph(reduced) let ordered = @src.order_cells(with_graph, [0]) - + let result = @src.fit_models(ordered, ["Gene_0", "Gene_1", "Gene_2"]) - + assert_eq(result.gene.length(), 3) assert_eq(result.q_value.length(), 3) } +///| test "monocle3_create_example_data" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() - + assert_eq(counts.length(), 50) assert_eq(gene_names.length(), 100) assert_eq(cell_names.length(), 50) } +///| test "monocle3_full_pipeline" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() - + let cds = @src.new_cell_data_set(counts, gene_names, cell_names) let preprocessed = @src.preprocess_cds(cds, 10) let reduced = @src.reduce_dimension(preprocessed, "UMAP", 2) let with_graph = @src.learn_graph(reduced) let ordered = @src.order_cells(with_graph, [0]) let result = @src.fit_models(ordered, ["Gene_0"]) - + assert_eq(cds.counts.length(), 50) assert_eq(result.gene.length(), 1) } +///| test "monocle3_find_branch_points" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() let cds = @src.new_cell_data_set(counts, gene_names, cell_names) let preprocessed = @src.preprocess_cds(cds, 10) let reduced = @src.reduce_dimension(preprocessed, "UMAP", 2) let with_graph = @src.learn_graph(reduced) - + let branch_points = @src.find_branch_points(with_graph) - + assert_eq(branch_points.length(), 0) } +///| test "monocle3_differential_gene_test_branches" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() let cds = @src.new_cell_data_set(counts, gene_names, cell_names) let preprocessed = @src.preprocess_cds(cds, 10) let reduced = @src.reduce_dimension(preprocessed, "UMAP", 2) let with_graph = @src.learn_graph(reduced) - + let branch_points = @src.find_branch_points(with_graph) - + if branch_points.length() > 0 { - let result = @src.differential_gene_test_branches(with_graph, branch_points[0], ["Gene_0", "Gene_1"]) + let result = @src.differential_gene_test_branches( + with_graph, + branch_points[0], + ["Gene_0", "Gene_1"], + ) assert_eq(result.gene.length(), 2) } -} \ No newline at end of file +} diff --git a/test/moonbit/moon.pkg b/test/moonbit/moon.pkg index 956590ee..8c06828c 100644 --- a/test/moonbit/moon.pkg +++ b/test/moonbit/moon.pkg @@ -1,6 +1,6 @@ import { "IvanAXu/BioSeqs/src" @bio, - "IvanAXu/BioSeqs/src" @src, + "IvanAXu/BioSeqs/src", "moonbitlang/core/hashmap", "moonbitlang/core/double", "moonbitlang/core/math", diff --git a/test/moonbit/motif_scan_test.mbt b/test/moonbit/motif_scan_test.mbt index c72e3dce..bc20a39e 100644 --- a/test/moonbit/motif_scan_test.mbt +++ b/test/moonbit/motif_scan_test.mbt @@ -49,31 +49,24 @@ test "pwm_construction_default_background_and_strand" { ///| test "pwm_from_counts_basic" { // 4 rows (A,C,G,T) x 3 columns - let counts = [ - [9, 1, 1], - [1, 8, 1], - [1, 1, 7], - [1, 2, 3], - ] + let counts = [[9, 1, 1], [1, 8, 1], [1, 1, 7], [1, 2, 3]] let pwm = @src.motif_scan_pwm_from_counts("MC1", "CountMotif", counts, 1.0) assert_eq(pwm.motif_id, "MC1") assert_eq(pwm.motif_name, "CountMotif") assert_eq(pwm.matrix.length(), 4) assert_eq(pwm.matrix[0].length(), 3) // Each column should sum to ~1.0 (with pseudocount). - let col0 = pwm.matrix[0][0] + pwm.matrix[1][0] + pwm.matrix[2][0] + pwm.matrix[3][0] + let col0 = pwm.matrix[0][0] + + pwm.matrix[1][0] + + pwm.matrix[2][0] + + pwm.matrix[3][0] assert_true((col0 - 1.0).abs() < 0.001) } ///| test "pwm_from_counts_normalization" { // Counts: column 0 has total 10 + 4*pseudocount; each entry = (count+pseudo)/norm - let counts = [ - [10, 0], - [0, 10], - [0, 0], - [0, 0], - ] + let counts = [[10, 0], [0, 10], [0, 0], [0, 0]] let pwm = @src.motif_scan_pwm_from_counts("MC2", "Norm", counts, 1.0) // Column 0: total=10, norm=10+4=14. A = (10+1)/14 = 11/14 let expected_a = 11.0 / 14.0 @@ -96,7 +89,7 @@ test "pssm_construction_log_likelihood" { // A: log2(0.9/0.25) = log2(3.6) ~ 1.848 assert_true((pssm.scores[0][0] - 1.848).abs() < 0.01) // C: log2(0.05/0.25) = log2(0.2) ~ -2.322 - assert_true((pssm.scores[1][0] - (-2.322)).abs() < 0.01) + assert_true((pssm.scores[1][0] - -2.322).abs() < 0.01) } ///| @@ -104,7 +97,7 @@ test "pssm_construction_min_max_score" { let pwm = make_one_pos_pwm() let pssm = @src.build_pssm(pwm) // min_score = min of all bases at position 0 = -2.322 - assert_true((pssm.min_score - (-2.322)).abs() < 0.01) + assert_true((pssm.min_score - -2.322).abs() < 0.01) // max_score = max of all bases at position 0 = 1.848 assert_true((pssm.max_score - 1.848).abs() < 0.01) } @@ -114,10 +107,12 @@ test "pssm_carries_metadata" { let pwm = @src.PositionWeightMatrix::new( motif_id="M99", motif_name="Meta", - matrix=[[0.9, 0.05, 0.05, 0.05, 0.9, 0.9], - [0.05, 0.05, 0.05, 0.9, 0.05, 0.05], - [0.05, 0.05, 0.9, 0.05, 0.05, 0.05], - [0.05, 0.9, 0.05, 0.05, 0.05, 0.05]], + matrix=[ + [0.9, 0.05, 0.05, 0.05, 0.9, 0.9], + [0.05, 0.05, 0.05, 0.9, 0.05, 0.05], + [0.05, 0.05, 0.9, 0.05, 0.05, 0.05], + [0.05, 0.9, 0.05, 0.05, 0.05, 0.05], + ], background=[0.25, 0.25, 0.25, 0.25], strand="+-", ) @@ -135,7 +130,7 @@ test "compute_score_single_position" { // Score of "A" = log2(0.9/0.25) ~ 1.848 assert_true((@src.compute_score(pssm, "A") - 1.848).abs() < 0.01) // Score of "C" = log2(0.05/0.25) ~ -2.322 - assert_true((@src.compute_score(pssm, "C") - (-2.322)).abs() < 0.01) + assert_true((@src.compute_score(pssm, "C") - -2.322).abs() < 0.01) } ///| @@ -289,10 +284,12 @@ test "scan_sequence_forward_only_mode" { let pwm = @src.PositionWeightMatrix::new( motif_id="Mfwd", motif_name="FwdOnly", - matrix=[[0.9, 0.05, 0.05, 0.05, 0.9, 0.9], - [0.05, 0.05, 0.05, 0.9, 0.05, 0.05], - [0.05, 0.05, 0.9, 0.05, 0.05, 0.05], - [0.05, 0.9, 0.05, 0.05, 0.05, 0.05]], + matrix=[ + [0.9, 0.05, 0.05, 0.05, 0.9, 0.9], + [0.05, 0.05, 0.05, 0.9, 0.05, 0.05], + [0.05, 0.05, 0.9, 0.05, 0.05, 0.05], + [0.05, 0.9, 0.05, 0.05, 0.05, 0.05], + ], background=[0.25, 0.25, 0.25, 0.25], strand="+", ) @@ -523,11 +520,7 @@ test "pwm_from_counts_empty" { ///| test "compute_score_empty_pssm" { - let pwm = @src.PositionWeightMatrix::new( - motif_id="E", - motif_name="E", - matrix=[], - ) + let pwm = @src.PositionWeightMatrix::new(motif_id="E", motif_name="E", matrix=[]) let pssm = @src.build_pssm(pwm) assert_true((@src.compute_score(pssm, "ACGT") - 0.0).abs() < 0.001) assert_true((@src.compute_pvalue(pssm, 0.0) - 1.0).abs() < 0.001) diff --git a/test/moonbit/motifs_advanced_test.mbt b/test/moonbit/motifs_advanced_test.mbt index ad15dd73..502664e5 100644 --- a/test/moonbit/motifs_advanced_test.mbt +++ b/test/moonbit/motifs_advanced_test.mbt @@ -7,10 +7,7 @@ ///| test "jaspar_motif_creation" { - let pwm : Array[Array[Double]] = [ - [0.1, 0.2, 0.3, 0.4], - [0.4, 0.3, 0.2, 0.1], - ] + let pwm : Array[Array[Double]] = [[0.1, 0.2, 0.3, 0.4], [0.4, 0.3, 0.2, 0.1]] let motif = @src.JasparMotif::new( "MA0001.1", "AGL3", @@ -31,8 +28,7 @@ test "jaspar_motif_creation" { ///| test "jaspar_parse_simple_pfm" { - let pfm_content = - ">MA0001.1 AGL3\n" + + let pfm_content = ">MA0001.1 AGL3\n" + "A [ 0 3 79 40 66 48 65 11 65 0 ]\n" + "C [ 94 75 4 3 1 2 5 2 7 0 ]\n" + "G [ 1 0 3 4 1 0 5 3 4 0 ]\n" + @@ -46,8 +42,7 @@ test "jaspar_parse_simple_pfm" { ///| test "jaspar_parse_multiple_motifs" { - let pfm_content = - ">MA0001.1 AGL3\n" + + let pfm_content = ">MA0001.1 AGL3\n" + "A [ 10 20 30 40 ]\n" + "C [ 40 30 20 10 ]\n" + "G [ 20 20 20 20 ]\n" + @@ -82,10 +77,7 @@ test "jaspar_pfm_to_pwm" { ///| test "jaspar_pwm_to_jaspar_format" { - let pwm : Array[Array[Double]] = [ - [0.1, 0.2, 0.3, 0.4], - [0.4, 0.3, 0.2, 0.1], - ] + let pwm : Array[Array[Double]] = [[0.1, 0.2, 0.3, 0.4], [0.4, 0.3, 0.2, 0.1]] let jaspar_str = @src.pwm_to_jaspar(pwm, "MA0001.1", "TestMotif") assert_true(jaspar_str.has_prefix(">MA0001.1 TestMotif")) assert_true(jaspar_str.contains("A [")) @@ -98,10 +90,7 @@ test "jaspar_pwm_to_jaspar_format" { ///| test "transfac_motif_creation" { - let pwm : Array[Array[Double]] = [ - [1.0, 2.0, 3.0, 4.0], - [4.0, 3.0, 2.0, 1.0], - ] + let pwm : Array[Array[Double]] = [[1.0, 2.0, 3.0, 4.0], [4.0, 3.0, 2.0, 1.0]] let motif = @src.TransfacMotif::new( "T00001", "M00001", @@ -119,8 +108,7 @@ test "transfac_motif_creation" { ///| test "transfac_parse_simple" { - let transfac_content = - "AC T00001\n" + + let transfac_content = "AC T00001\n" + "ID M00001\n" + "NA AP-1\n" + "DE Activator protein 1\n" + @@ -138,10 +126,7 @@ test "transfac_parse_simple" { ///| test "transfac_pwm_to_transfac_format" { - let pwm : Array[Array[Double]] = [ - [1.0, 2.0, 3.0, 4.0], - [4.0, 3.0, 2.0, 1.0], - ] + let pwm : Array[Array[Double]] = [[1.0, 2.0, 3.0, 4.0], [4.0, 3.0, 2.0, 1.0]] let transfac_str = @src.pwm_to_transfac(pwm, "TestMotif", "T00001") assert_true(transfac_str.contains("AC T00001")) assert_true(transfac_str.contains("NA TestMotif")) @@ -184,10 +169,7 @@ test "optimal_motif_alignment_different_lengths" { [0.0, 0.1, 0.1, 0.8], [0.8, 0.1, 0.1, 0.0], ] - let pwm2 : Array[Array[Double]] = [ - [0.0, 0.1, 0.1, 0.8], - [0.8, 0.1, 0.1, 0.0], - ] + let pwm2 : Array[Array[Double]] = [[0.0, 0.1, 0.1, 0.8], [0.8, 0.1, 0.1, 0.0]] let alignment = @src.optimal_motif_alignment(pwm1, pwm2) assert_true(alignment.score >= 0.0) assert_true(alignment.aligned_length > 0) @@ -210,26 +192,16 @@ test "motif_kl_divergence" { ///| test "motif_js_divergence" { - let pwm1 : Array[Array[Double]] = [ - [0.8, 0.1, 0.1, 0.0], - [0.0, 0.1, 0.1, 0.8], - ] - let pwm2 : Array[Array[Double]] = [ - [0.8, 0.1, 0.1, 0.0], - [0.0, 0.1, 0.1, 0.8], - ] + let pwm1 : Array[Array[Double]] = [[0.8, 0.1, 0.1, 0.0], [0.0, 0.1, 0.1, 0.8]] + let pwm2 : Array[Array[Double]] = [[0.8, 0.1, 0.1, 0.0], [0.0, 0.1, 0.1, 0.8]] let js = @src.motif_js_divergence(pwm1, pwm2) assert_eq(js, 0.0) } ///| test "motif_js_divergence_different" { - let pwm1 : Array[Array[Double]] = [ - [0.8, 0.1, 0.1, 0.0], - ] - let pwm2 : Array[Array[Double]] = [ - [0.0, 0.1, 0.1, 0.8], - ] + let pwm1 : Array[Array[Double]] = [[0.8, 0.1, 0.1, 0.0]] + let pwm2 : Array[Array[Double]] = [[0.0, 0.1, 0.1, 0.8]] let js = @src.motif_js_divergence(pwm1, pwm2) assert_true(js >= 0.0) } @@ -250,10 +222,7 @@ test "motif_cluster_creation" { ///| test "cluster_motifs_single" { let names = ["motif1"] - let pwm1 : Array[Array[Double]] = [ - [0.8, 0.1, 0.1, 0.0], - [0.0, 0.1, 0.1, 0.8], - ] + let pwm1 : Array[Array[Double]] = [[0.8, 0.1, 0.1, 0.0], [0.0, 0.1, 0.1, 0.8]] let pwms = [pwm1] let clusters = @src.cluster_motifs(names, pwms, 0.5) assert_eq(clusters.length(), 1) @@ -275,10 +244,7 @@ test "optimal_pseudocount" { ///| test "motif_gc_content" { - let pwm : Array[Array[Double]] = [ - [0.1, 0.4, 0.4, 0.1], - [0.1, 0.4, 0.4, 0.1], - ] + let pwm : Array[Array[Double]] = [[0.1, 0.4, 0.4, 0.1], [0.1, 0.4, 0.4, 0.1]] let gc = @src.motif_gc_content_adv(pwm) assert_true(gc > 0.7 && gc < 0.9) } diff --git a/test/moonbit/ms_core_utils_test.mbt b/test/moonbit/ms_core_utils_test.mbt index e19dbf28..f48f8d3d 100644 --- a/test/moonbit/ms_core_utils_test.mbt +++ b/test/moonbit/ms_core_utils_test.mbt @@ -11,12 +11,14 @@ test "mc_mean_basic" { assert_true((m - 3.0).abs() < 0.001) } +///| test "mc_mean_empty" { let empty : Array[Double] = [] let m = @src.mc_mean(empty) assert_eq(m, 0.0) } +///| test "mc_mean_two_values" { let m = @src.mc_mean([2.5, 3.5]) assert_true((m - 3.0).abs() < 0.001) @@ -26,21 +28,25 @@ test "mc_mean_two_values" { // Numeric helpers: mc_median // ============================================================================ +///| test "mc_median_odd" { let m = @src.mc_median([1.0, 3.0, 5.0]) assert_eq(m, 3.0) } +///| test "mc_median_even" { let m = @src.mc_median([1.0, 2.0, 3.0, 4.0]) assert_true((m - 2.5).abs() < 0.001) } +///| test "mc_median_unsorted" { let m = @src.mc_median([5.0, 1.0, 3.0, 2.0, 4.0]) assert_eq(m, 3.0) } +///| test "mc_median_empty" { let empty : Array[Double] = [] let m = @src.mc_median(empty) @@ -51,17 +57,20 @@ test "mc_median_empty" { // Numeric helpers: mc_sd // ============================================================================ +///| test "mc_sd_basic" { // mean=3, var = (4+1+0+1+4)/4 = 2.5, sd = sqrt(2.5) ~ 1.5811 let s = @src.mc_sd([1.0, 2.0, 3.0, 4.0, 5.0]) assert_true((s - 1.5811).abs() < 0.001) } +///| test "mc_sd_constant" { let s = @src.mc_sd([5.0, 5.0, 5.0]) assert_eq(s, 0.0) } +///| test "mc_sd_single" { // n < 2 returns 0.0 let s = @src.mc_sd([7.0]) @@ -72,11 +81,13 @@ test "mc_sd_single" { // Numeric helpers: mc_quantile // ============================================================================ +///| test "mc_quantile_median" { let q = @src.mc_quantile([1.0, 2.0, 3.0, 4.0, 5.0], 0.5) assert_eq(q, 3.0) } +///| test "mc_quantile_min_max" { let qmin = @src.mc_quantile([1.0, 2.0, 3.0, 4.0, 5.0], 0.0) let qmax = @src.mc_quantile([1.0, 2.0, 3.0, 4.0, 5.0], 1.0) @@ -84,6 +95,7 @@ test "mc_quantile_min_max" { assert_eq(qmax, 5.0) } +///| test "mc_quantile_quarter" { // pos = 0.25 * 4 = 1, lo=1, frac=0 -> sorted[1] = 2.0 let q = @src.mc_quantile([1.0, 2.0, 3.0, 4.0, 5.0], 0.25) @@ -94,17 +106,20 @@ test "mc_quantile_quarter" { // Numeric helpers: mc_sum, mc_dot // ============================================================================ +///| test "mc_sum_basic" { let s = @src.mc_sum([1.0, 2.0, 3.0]) assert_eq(s, 6.0) } +///| test "mc_sum_empty" { let empty : Array[Double] = [] let s = @src.mc_sum(empty) assert_eq(s, 0.0) } +///| test "mc_dot_basic" { let d = @src.mc_dot([1.0, 2.0, 3.0], [4.0, 5.0, 6.0]) // 1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32 @@ -115,6 +130,7 @@ test "mc_dot_basic" { // refineCentroids: mc_refine_centroids // ============================================================================ +///| test "mc_refine_centroids_symmetric_peak" { // Symmetric peak centered at index 2 with m/z 100.2 let mz = [100.0, 100.1, 100.2, 100.3, 100.4] @@ -128,6 +144,7 @@ test "mc_refine_centroids_symmetric_peak" { assert_eq(out_int[0], 100.0) } +///| test "mc_refine_centroids_asymmetric_peak" { // Asymmetric: more weight on the right side -> refined m/z shifts right let mz = [100.0, 100.1, 100.2, 100.3, 100.4] @@ -137,6 +154,7 @@ test "mc_refine_centroids_asymmetric_peak" { assert_true(out_mz[0] > 100.2) } +///| test "mc_refine_centroids_out_of_range_index" { let mz = [100.0, 100.1, 100.2] let intensity = [10.0, 20.0, 30.0] @@ -150,16 +168,19 @@ test "mc_refine_centroids_out_of_range_index" { // localMaxima: mc_local_maxima // ============================================================================ +///| test "mc_local_maxima_basic" { let idx = @src.mc_local_maxima([1.0, 3.0, 2.0]) assert_eq(idx, [1]) } +///| test "mc_local_maxima_zeros" { let idx = @src.mc_local_maxima([0.0, 0.0, 0.0]) assert_eq(idx.length(), 0) } +///| test "mc_local_maxima_multiple_peaks" { let idx = @src.mc_local_maxima([1.0, 2.0, 1.0, 2.0, 1.0]) assert_eq(idx, [1, 3]) @@ -169,6 +190,7 @@ test "mc_local_maxima_multiple_peaks" { // joinPeaks: mc_join_peaks // ============================================================================ +///| test "mc_join_peaks_absolute_tolerance" { let x = [100.0, 200.0, 300.0] let y = [100.01, 199.99, 300.5] @@ -181,6 +203,7 @@ test "mc_join_peaks_absolute_tolerance" { assert_eq(pairs[1], (1, 1)) } +///| test "mc_join_peaks_ppm_tolerance" { let x = [1000.0] let y = [1000.005] @@ -190,6 +213,7 @@ test "mc_join_peaks_ppm_tolerance" { assert_eq(pairs[0], (0, 0)) } +///| test "mc_join_peaks_no_match" { let x = [100.0, 200.0] let y = [150.0, 250.0] @@ -201,6 +225,7 @@ test "mc_join_peaks_no_match" { // Smoothing: mc_smooth_moving_average // ============================================================================ +///| test "mc_smooth_moving_average_basic" { let out = @src.mc_smooth_moving_average([1.0, 2.0, 3.0, 4.0, 5.0], 1) assert_eq(out.length(), 5) @@ -211,6 +236,7 @@ test "mc_smooth_moving_average_basic" { assert_true((out[4] - 4.5).abs() < 0.001) } +///| test "mc_smooth_moving_average_reduces_noise" { // Noisy signal: moving average should reduce total variation let noisy = [1.0, 5.0, 1.0, 5.0, 1.0, 5.0, 1.0] @@ -230,6 +256,7 @@ test "mc_smooth_moving_average_reduces_noise" { // Smoothing: mc_smooth_savitzky_golay // ============================================================================ +///| test "mc_smooth_savitzky_golay_linear_signal" { // A quadratic/SG fit on perfectly linear data reproduces the value at the // window center. For the interior point with a full symmetric window, the @@ -240,6 +267,7 @@ test "mc_smooth_savitzky_golay_linear_signal" { assert_true((out[2] - lin[2]).abs() < 0.01) } +///| test "mc_smooth_savitzky_golay_reduces_noise" { let noisy = [1.0, 5.0, 1.0, 5.0, 1.0, 5.0, 1.0] let smoothed = @src.mc_smooth_savitzky_golay(noisy, 2) @@ -258,11 +286,13 @@ test "mc_smooth_savitzky_golay_reduces_noise" { // Smoothing: mc_smooth dispatcher // ============================================================================ +///| test "mc_smooth_dispatcher_moving_average" { let out = @src.mc_smooth([1.0, 2.0, 3.0, 4.0, 5.0], 1, "MovingAverage") assert_true((out[2] - 3.0).abs() < 0.001) } +///| test "mc_smooth_dispatcher_savitzky_golay" { let out = @src.mc_smooth([1.0, 2.0, 3.0, 4.0, 5.0], 2, "SavitzkyGolay") // Linear signal -> preserved @@ -273,6 +303,7 @@ test "mc_smooth_dispatcher_savitzky_golay" { // Baseline: mc_baseline_snip // ============================================================================ +///| test "mc_baseline_snip_flat_signal" { // Flat positive signal -> baseline should be <= signal and >= 0 let signal = [10.0, 10.0, 10.0, 10.0, 10.0] @@ -284,6 +315,7 @@ test "mc_baseline_snip_flat_signal" { } } +///| test "mc_baseline_snip_below_peaks" { // Signal with a peak in the middle -> baseline at peak should be below peak let signal = [1.0, 1.0, 100.0, 1.0, 1.0] @@ -295,6 +327,7 @@ test "mc_baseline_snip_below_peaks" { // Calibration: mc_calibrate // ============================================================================ +///| test "mc_calibrate_shift" { let observed = [100.0, 200.0, 300.0] let calibrants = [100.1, 200.1, 300.1] @@ -305,6 +338,7 @@ test "mc_calibrate_shift" { assert_true((out[2] - 300.1).abs() < 0.001) } +///| test "mc_calibrate_linear" { // matched pairs: (100, 100.5), (200, 200.5), (300, 300.5) // linear fit -> cal = 1.0 * obs + 0.5 @@ -317,6 +351,7 @@ test "mc_calibrate_linear" { assert_true((out[2] - 300.5).abs() < 0.01) } +///| test "mc_calibrate_no_match_returns_input" { // No calibrants within tolerance -> shift method leaves values unchanged let observed = [100.0, 200.0] @@ -330,23 +365,23 @@ test "mc_calibrate_no_match_returns_input" { // Imputation: mc_is_missing and mc_impute // ============================================================================ +///| test "mc_is_missing_nan" { let nan = 0.0 / 0.0 assert_true(@src.mc_is_missing(nan)) } +///| test "mc_is_missing_not_nan" { assert_true(!@src.mc_is_missing(5.0)) assert_true(!@src.mc_is_missing(0.0)) assert_true(!@src.mc_is_missing(-1.5)) } +///| test "mc_impute_zero" { let nan = 0.0 / 0.0 - let matrix = [ - [1.0, nan, 3.0], - [nan, 5.0, 6.0], - ] + let matrix = [[1.0, nan, 3.0], [nan, 5.0, 6.0]] let out = @src.mc_impute(matrix, "zero", 0) assert_eq(out[0][1], 0.0) assert_eq(out[1][0], 0.0) @@ -355,6 +390,7 @@ test "mc_impute_zero" { assert_eq(out[1][2], 6.0) } +///| test "mc_impute_half_min" { let nan = 0.0 / 0.0 // Row 0: non-missing values [2.0, 4.0], min = 2.0, half = 1.0 @@ -363,6 +399,7 @@ test "mc_impute_half_min" { assert_true((out[0][1] - 1.0).abs() < 0.001) } +///| test "mc_impute_mean" { let nan = 0.0 / 0.0 // Row 0: non-missing [1.0, 4.0], mean = 2.5 @@ -371,6 +408,7 @@ test "mc_impute_mean" { assert_true((out[0][1] - 2.5).abs() < 0.001) } +///| test "mc_impute_median" { let nan = 0.0 / 0.0 // Row 0: non-missing [1.0, 4.0], median = 2.5 @@ -379,27 +417,21 @@ test "mc_impute_median" { assert_true((out[0][1] - 2.5).abs() < 0.001) } +///| test "mc_impute_knn" { let nan = 0.0 / 0.0 // Row 1 missing at col 1; nearest row (by cols 0 and 2) is row 0. // k=1 -> impute from row 0 col 1 = 2.0 - let matrix = [ - [1.0, 2.0, 3.0], - [1.0, nan, 3.0], - [5.0, 4.0, 3.0], - ] + let matrix = [[1.0, 2.0, 3.0], [1.0, nan, 3.0], [5.0, 4.0, 3.0]] let out = @src.mc_impute(matrix, "knn", 1) assert_true((out[1][1] - 2.0).abs() < 0.001) } +///| test "mc_impute_knn_k2" { let nan = 0.0 / 0.0 // k=2 -> mean of row 0 col 1 (2.0) and row 2 col 1 (4.0) = 3.0 - let matrix = [ - [1.0, 2.0, 3.0], - [1.0, nan, 3.0], - [5.0, 4.0, 3.0], - ] + let matrix = [[1.0, 2.0, 3.0], [1.0, nan, 3.0], [5.0, 4.0, 3.0]] let out = @src.mc_impute(matrix, "knn", 2) assert_true((out[1][1] - 3.0).abs() < 0.001) } @@ -408,18 +440,16 @@ test "mc_impute_knn_k2" { // medianPolish: mc_median_polish // ============================================================================ +///| test "mc_median_polish_basic" { // Additive matrix: x[i][j] = overall + row_eff[i] + col_eff[j] // Expected: overall=4, row_eff=[-2, 2], col_eff=[-1, 1], residuals all 0 - let matrix = [ - [1.0, 3.0], - [5.0, 7.0], - ] + let matrix = [[1.0, 3.0], [5.0, 7.0]] let (r, row_eff, col_eff, overall) = @src.mc_median_polish(matrix, 10, 0.0001) assert_true((overall - 4.0).abs() < 0.001) - assert_true((row_eff[0] - (-2.0)).abs() < 0.001) + assert_true((row_eff[0] - -2.0).abs() < 0.001) assert_true((row_eff[1] - 2.0).abs() < 0.001) - assert_true((col_eff[0] - (-1.0)).abs() < 0.001) + assert_true((col_eff[0] - -1.0).abs() < 0.001) assert_true((col_eff[1] - 1.0).abs() < 0.001) // Residuals should be ~0 for i in 0..<2 { @@ -429,6 +459,7 @@ test "mc_median_polish_basic" { } } +///| test "mc_median_polish_empty" { let empty : Array[Array[Double]] = [] let (r, row_eff, col_eff, overall) = @src.mc_median_polish(empty, 10, 0.0001) @@ -442,21 +473,19 @@ test "mc_median_polish_empty" { // robustSummary: mc_robust_summary // ============================================================================ +///| test "mc_robust_summary_basic" { // Per-column median: // col 0: median([1,3,5]) = 3.0 // col 1: median([10,20,30]) = 20.0 - let matrix = [ - [1.0, 10.0], - [3.0, 20.0], - [5.0, 30.0], - ] + let matrix = [[1.0, 10.0], [3.0, 20.0], [5.0, 30.0]] let out = @src.mc_robust_summary(matrix) assert_eq(out.length(), 2) assert_eq(out[0], 3.0) assert_eq(out[1], 20.0) } +///| test "mc_robust_summary_empty" { let empty : Array[Array[Double]] = [] let out = @src.mc_robust_summary(empty) @@ -467,6 +496,7 @@ test "mc_robust_summary_empty" { // MAD: mc_mad // ============================================================================ +///| test "mc_mad_basic" { // median = 3, deviations = [2,1,0,1,2], median of devs = 1.0 // mad = 1.0 * 1.4826 = 1.4826 @@ -474,6 +504,7 @@ test "mc_mad_basic" { assert_true((m - 1.4826).abs() < 0.001) } +///| test "mc_mad_constant" { let m = @src.mc_mad([7.0, 7.0, 7.0]) assert_eq(m, 0.0) @@ -483,12 +514,14 @@ test "mc_mad_constant" { // Validity: mc_valid_peak_list, mc_has_missing // ============================================================================ +///| test "mc_valid_peak_list_valid" { let mz = [100.0, 200.0, 300.0] let intensity = [1.0, 2.0, 3.0] assert_true(@src.mc_valid_peak_list(mz, intensity)) } +///| test "mc_valid_peak_list_not_increasing" { // m/z 200 == 200 is not strictly increasing let mz = [100.0, 200.0, 200.0] @@ -496,32 +529,30 @@ test "mc_valid_peak_list_not_increasing" { assert_true(!@src.mc_valid_peak_list(mz, intensity)) } +///| test "mc_valid_peak_list_length_mismatch" { let mz = [100.0, 200.0] let intensity = [1.0, 2.0, 3.0] assert_true(!@src.mc_valid_peak_list(mz, intensity)) } +///| test "mc_valid_peak_list_negative_intensity" { let mz = [100.0, 200.0] let intensity = [-1.0, 2.0] assert_true(!@src.mc_valid_peak_list(mz, intensity)) } +///| test "mc_has_missing_clean" { - let matrix = [ - [1.0, 2.0], - [3.0, 4.0], - ] + let matrix = [[1.0, 2.0], [3.0, 4.0]] assert_true(!@src.mc_has_missing(matrix)) } +///| test "mc_has_missing_with_nan" { let nan = 0.0 / 0.0 - let matrix = [ - [1.0, nan], - [3.0, 4.0], - ] + let matrix = [[1.0, nan], [3.0, 4.0]] assert_true(@src.mc_has_missing(matrix)) } @@ -529,12 +560,9 @@ test "mc_has_missing_with_nan" { // Aggregation: mc_aggregate_rows // ============================================================================ +///| test "mc_aggregate_rows_sum" { - let matrix = [ - [1.0, 10.0], - [2.0, 20.0], - [3.0, 30.0], - ] + let matrix = [[1.0, 10.0], [2.0, 20.0], [3.0, 30.0]] let groups = [0, 0, 1] let out = @src.mc_aggregate_rows(matrix, groups, "sum") assert_eq(out.length(), 2) @@ -544,12 +572,9 @@ test "mc_aggregate_rows_sum" { assert_true((out[1][1] - 30.0).abs() < 0.001) } +///| test "mc_aggregate_rows_mean" { - let matrix = [ - [1.0, 10.0], - [2.0, 20.0], - [3.0, 30.0], - ] + let matrix = [[1.0, 10.0], [2.0, 20.0], [3.0, 30.0]] let groups = [0, 0, 1] let out = @src.mc_aggregate_rows(matrix, groups, "mean") assert_eq(out.length(), 2) @@ -559,12 +584,9 @@ test "mc_aggregate_rows_mean" { assert_true((out[1][1] - 30.0).abs() < 0.001) } +///| test "mc_aggregate_rows_median" { - let matrix = [ - [1.0, 10.0], - [2.0, 20.0], - [3.0, 30.0], - ] + let matrix = [[1.0, 10.0], [2.0, 20.0], [3.0, 30.0]] let groups = [0, 0, 1] let out = @src.mc_aggregate_rows(matrix, groups, "median") assert_eq(out.length(), 2) @@ -578,6 +600,7 @@ test "mc_aggregate_rows_median" { // Normalization: mc_normalize_tic // ============================================================================ +///| test "mc_normalize_tic_basic" { // total = 10, out = v / total * 100 let out = @src.mc_normalize_tic([1.0, 2.0, 3.0, 4.0]) @@ -588,6 +611,7 @@ test "mc_normalize_tic_basic" { assert_true((out[3] - 40.0).abs() < 0.001) } +///| test "mc_normalize_tic_zero_total" { // total = 0 -> all zeros let out = @src.mc_normalize_tic([0.0, 0.0, 0.0]) @@ -597,6 +621,7 @@ test "mc_normalize_tic_zero_total" { assert_eq(out[2], 0.0) } +///| test "mc_normalize_tic_sums_to_100" { let out = @src.mc_normalize_tic([10.0, 20.0, 30.0, 40.0]) let total = @src.mc_sum(out) diff --git a/test/moonbit/msf_test.mbt b/test/moonbit/msf_test.mbt index 13987e9c..39f56e9f 100644 --- a/test/moonbit/msf_test.mbt +++ b/test/moonbit/msf_test.mbt @@ -33,12 +33,7 @@ fn msf_test_write_raises( ) -> Bool { try { ignore( - @src.msf_write( - alignment, - block_width=block_width, - group_width=group_width, - gap_character=gap_character, - ), + @src.msf_write(alignment, block_width~, group_width~, gap_character~), ) false } catch { @@ -53,14 +48,7 @@ fn msf_test_from_aligned_raises( weights : Array[Double], ) -> Bool { try { - ignore( - @src.msf_from_aligned( - ids, - rows, - @src.MsfNucleotide, - weights=weights, - ), - ) + ignore(@src.msf_from_aligned(ids, rows, @src.MsfNucleotide, weights~)) false } catch { MsfError(_) => true @@ -81,7 +69,7 @@ fn msf_test_sequence_raises( id, row, sequence_type, - weight=weight, + weight~, checksum=Some(checksum), ), ) @@ -570,11 +558,7 @@ test "Bio.Align.msf writes hyphen gaps" { ///| test "Bio.Align.msf writes custom interleaved blocks" { - let output = @src.msf_write( - msf_test_sample(), - block_width=6, - group_width=3, - ) catch { + let output = @src.msf_write(msf_test_sample(), block_width=6, group_width=3) catch { MsfError(message) => abort(message) } assert_true(output.contains("reference ACG TAC")) @@ -670,11 +654,7 @@ test "Bio.Align.msf constructs canonical metadata" { ///| test "Bio.Align.msf accepts protein wildcard residues" { - let sequence = @src.MsfSequence::create( - "protein", - "ACDX*?", - @src.MsfProtein, - ) catch { + let sequence = @src.MsfSequence::create("protein", "ACDX*?", @src.MsfProtein) catch { MsfError(message) => abort(message) } assert_eq(sequence.sequence, "ACDX*?") @@ -727,9 +707,7 @@ test "Bio.Align.msf rejects missing alignment header" { ///| test "Bio.Align.msf rejects malformed alignment header" { assert_true( - msf_test_raises( - "!!NA_MULTIPLE_ALIGNMENT\nMSF: 4 Kind: N Check: 0 ..\n", - ), + msf_test_raises("!!NA_MULTIPLE_ALIGNMENT\nMSF: 4 Kind: N Check: 0 ..\n"), ) } @@ -765,20 +743,12 @@ test "Bio.Align.msf rejects zero declared width" { ///| test "Bio.Align.msf rejects integer overflow" { - assert_true( - msf_test_raises( - "PileUp\nMSF: 2147483648 Type: N Check: 0 ..\n", - ), - ) + assert_true(msf_test_raises("PileUp\nMSF: 2147483648 Type: N Check: 0 ..\n")) } ///| test "Bio.Align.msf rejects file checksum outside range" { - assert_true( - msf_test_raises( - "PileUp\nMSF: 4 Type: N Check: 10000 ..\n", - ), - ) + assert_true(msf_test_raises("PileUp\nMSF: 4 Type: N Check: 10000 ..\n")) } ///| @@ -970,107 +940,65 @@ test "Bio.Align.msf rejects unexpected descriptor token" { ///| test "Bio.Align.msf rejects empty row constructor input" { - assert_true( - msf_test_from_aligned_raises([], [], []), - ) + assert_true(msf_test_from_aligned_raises([], [], [])) } ///| test "Bio.Align.msf rejects mismatched row constructor input" { - assert_true( - msf_test_from_aligned_raises(["alpha"], ["ACGT", "ACGT"], []), - ) + assert_true(msf_test_from_aligned_raises(["alpha"], ["ACGT", "ACGT"], [])) } ///| test "Bio.Align.msf rejects mismatched weights" { assert_true( - msf_test_from_aligned_raises( - ["alpha", "beta"], - ["ACGT", "ACGT"], - [1.0], - ), + msf_test_from_aligned_raises(["alpha", "beta"], ["ACGT", "ACGT"], [1.0]), ) } ///| test "Bio.Align.msf rejects unequal row widths" { assert_true( - msf_test_from_aligned_raises( - ["alpha", "beta"], - ["ACGT", "ACG"], - [], - ), + msf_test_from_aligned_raises(["alpha", "beta"], ["ACGT", "ACG"], []), ) } ///| test "Bio.Align.msf rejects duplicate constructor identifiers" { assert_true( - msf_test_from_aligned_raises( - ["alpha", "alpha"], - ["ACGT", "ACGT"], - [], - ), + msf_test_from_aligned_raises(["alpha", "alpha"], ["ACGT", "ACGT"], []), ) } ///| test "Bio.Align.msf rejects whitespace in sequence identifier" { assert_true( - msf_test_sequence_raises( - "bad id", - "ACGT", - @src.MsfNucleotide, - 1.0, - 748, - ), + msf_test_sequence_raises("bad id", "ACGT", @src.MsfNucleotide, 1.0, 748), ) } ///| test "Bio.Align.msf rejects empty aligned sequence" { - assert_true( - msf_test_sequence_raises("", "", @src.MsfNucleotide, 1.0, 0), - ) + assert_true(msf_test_sequence_raises("", "", @src.MsfNucleotide, 1.0, 0)) } ///| test "Bio.Align.msf rejects all-gap sequence" { assert_true( - msf_test_sequence_raises( - "alpha", - "...", - @src.MsfNucleotide, - 1.0, - 0, - ), + msf_test_sequence_raises("alpha", "...", @src.MsfNucleotide, 1.0, 0), ) } ///| test "Bio.Align.msf rejects sequence checksum outside range" { assert_true( - msf_test_sequence_raises( - "alpha", - "ACGT", - @src.MsfNucleotide, - 1.0, - 10000, - ), + msf_test_sequence_raises("alpha", "ACGT", @src.MsfNucleotide, 1.0, 10000), ) } ///| test "Bio.Align.msf rejects negative sequence weight" { assert_true( - msf_test_sequence_raises( - "alpha", - "ACGT", - @src.MsfNucleotide, - -1.0, - 748, - ), + msf_test_sequence_raises("alpha", "ACGT", @src.MsfNucleotide, -1.0, 748), ) } diff --git a/test/moonbit/msnbase_test.mbt b/test/moonbit/msnbase_test.mbt index 8d85be66..082403f2 100644 --- a/test/moonbit/msnbase_test.mbt +++ b/test/moonbit/msnbase_test.mbt @@ -18,6 +18,7 @@ test "mbn_mslevel_constructors" { } } +///| test "mbn_polarity_constructors" { let p = @src.polarity_positive() let n = @src.polarity_negative() @@ -25,6 +26,7 @@ test "mbn_polarity_constructors" { assert_eq(n, @src.polarity_negative()) } +///| test "mbn_processing_step_new" { let s = @src.ProcessingStep::new("log_transformed", "2025-01-01") assert_eq(s.description, "log_transformed") @@ -35,47 +37,77 @@ test "mbn_processing_step_new" { // Spectrum tests // ============================================================================ +///| test "mbn_spectrum_new_basic" { let mz = [100.0, 200.0, 300.0, 400.0, 500.0] let int = [10.0, 100.0, 500.0, 200.0, 50.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 60.5) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 60.5, + ) assert_eq(sp.peaks_count(), 5) assert_true((sp.rt() - 60.5).abs() < 0.0001) // TIC = 10+100+500+200+50 = 860 assert_true((sp.tic() - 860.0).abs() < 0.0001) } +///| test "mbn_spectrum_empty" { let sp = @src.Spectrum::empty() assert_eq(sp.peaks_count(), 0) assert_eq(sp.tic(), 0.0) } +///| test "mbn_spectrum_mismatched_lengths" { // Mismatched mz/intensity returns empty - let sp = @src.Spectrum::new([1.0, 2.0], [10.0], @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + [1.0, 2.0], + [10.0], + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) assert_eq(sp.peaks_count(), 0) } +///| test "mbn_spectrum_with_precursor" { let mz = [100.0, 200.0] let int = [50.0, 100.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms2(), @src.polarity_positive(), 120.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms2(), + @src.polarity_positive(), + 120.0, + ) let sp2 = sp.with_precursor(500.25, 2) assert_eq(sp2.precursor_mz, 500.25) assert_eq(sp2.precursor_charge, 2) } +///| test "mbn_spectrum_base_peak" { let mz = [100.0, 200.0, 300.0, 400.0] let int = [10.0, 500.0, 50.0, 200.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) let (bpmz, bpint) = sp.base_peak() // Peak at index 1 is highest: mz=200, int=500 assert_true((bpmz - 200.0).abs() < 0.0001) assert_true((bpint - 500.0).abs() < 0.0001) } +///| test "mbn_spectrum_base_peak_empty" { let sp = @src.Spectrum::empty() let (mz, int) = sp.base_peak() @@ -83,54 +115,90 @@ test "mbn_spectrum_base_peak_empty" { assert_eq(int, 0.0) } +///| test "mbn_spectrum_find_peak_exact" { let mz = [100.0, 200.0, 300.0, 400.0, 500.0] let int = [10.0, 100.0, 500.0, 200.0, 50.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) let idx = sp.find_peak(300.0, ppm=10.0) assert_eq(idx, 2) } +///| test "mbn_spectrum_find_peak_notfound" { let mz = [100.0, 200.0] let int = [10.0, 100.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) let idx = sp.find_peak(999.0, ppm=10.0) assert_eq(idx, -1) } +///| test "mbn_spectrum_filter_mz_range" { let mz = [100.0, 200.0, 300.0, 400.0, 500.0] let int = [10.0, 100.0, 500.0, 200.0, 50.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) let filtered = sp.filter_mz_range(150.0, 450.0) assert_eq(filtered.peaks_count(), 3) assert_eq(filtered.mz()[0], 200.0) assert_eq(filtered.mz()[2], 400.0) } +///| test "mbn_spectrum_normalize_tic" { - let int = [10.0, 100.0, 500.0, 200.0, 50.0] // TIC = 860 + let int = [10.0, 100.0, 500.0, 200.0, 50.0] // TIC = 860 let mz = [100.0, 200.0, 300.0, 400.0, 500.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) let norm = sp.normalize_tic() // New TIC should be 1.0 assert_true((norm.tic() - 1.0).abs() < 0.0001) // First peak normalized: 10/860 - assert_true((norm.intensity()[0] - 10.0/860.0).abs() < 0.0001) + assert_true((norm.intensity()[0] - 10.0 / 860.0).abs() < 0.0001) } // ============================================================================ // Chromatogram tests // ============================================================================ +///| test "mbn_chromatogram_new" { let rt = [0.0, 30.0, 60.0, 90.0, 120.0] let int = [100.0, 5000.0, 20000.0, 8000.0, 200.0] - let chr = @src.Chromatogram::new(rt, int, mz_target=500.0, ppm_tolerance=10.0, acquisition_mode="MRM") + let chr = @src.Chromatogram::new( + rt, + int, + mz_target=500.0, + ppm_tolerance=10.0, + acquisition_mode="MRM", + ) assert_eq(chr.n_points(), 5) } +///| test "mbn_chromatogram_total_auc" { // Simple triangular: rt=[0, 1, 2], int=[0, 10, 0] // Area = 1.0 * 10 = 10 (two triangles each area 5) @@ -140,6 +208,7 @@ test "mbn_chromatogram_total_auc" { assert_true((chr.total_auc() - 10.0).abs() < 0.001) } +///| test "mbn_chromatogram_apex" { let rt = [0.0, 30.0, 60.0, 90.0] let int = [100.0, 5000.0, 20000.0, 8000.0] @@ -149,6 +218,7 @@ test "mbn_chromatogram_apex" { assert_true((apex_int - 20000.0).abs() < 0.001) } +///| test "mbn_chromatogram_fwhm" { // Gaussian-like: peak at center let rt = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0] @@ -163,9 +233,15 @@ test "mbn_chromatogram_fwhm" { // MSnFeatureData and MSnSampleData // ============================================================================ +///| test "mbn_featuredata_new" { let fd = @src.MSnFeatureData::new( - "Pep_1_2", ["P12345"], "PEPTIDER", 2, 500.25, 60.5, + "Pep_1_2", + ["P12345"], + "PEPTIDER", + 2, + 500.25, + 60.5, ) assert_eq(fd.feature_name, "Pep_1_2") assert_eq(fd.protein_accessions.length(), 1) @@ -175,10 +251,9 @@ test "mbn_featuredata_new" { assert_true((fd.mz - 500.25).abs() < 0.0001) } +///| test "mbn_sampledata_new" { - let sd = @src.MSnSampleData::new( - "S1_WT_1", "WT", "Mouse_1", 1, "Run_001", - ) + let sd = @src.MSnSampleData::new("S1_WT_1", "WT", "Mouse_1", 1, "Run_001") assert_eq(sd.sample_name, "S1_WT_1") assert_eq(sd.group, "WT") assert_eq(sd.subject, "Mouse_1") @@ -190,6 +265,7 @@ test "mbn_sampledata_new" { // MSnSet tests // ============================================================================ +///| test "mbn_msnset_new_basic" { let exprs = [ [1000.0, 1200.0, 1100.0], @@ -213,11 +289,9 @@ test "mbn_msnset_new_basic" { assert_eq(m.sample_names().length(), 3) } +///| test "mbn_msnset_from_names" { - let exprs = [ - [1.0, 2.0], - [3.0, 4.0], - ] + let exprs = [[1.0, 2.0], [3.0, 4.0]] let m = @src.MSnSet::from_names(exprs, ["F1", "F2"], ["S1", "S2"]) assert_eq(m.n_features(), 2) assert_eq(m.n_samples(), 2) @@ -225,11 +299,9 @@ test "mbn_msnset_from_names" { assert_eq(m.sample_names()[1], "S2") } +///| test "mbn_msnset_get_feature" { - let exprs = [ - [10.0, 20.0], - [30.0, 40.0], - ] + let exprs = [[10.0, 20.0], [30.0, 40.0]] let m = @src.MSnSet::from_names(exprs, ["F1", "F2"], ["S1", "S2"]) let f1 = m.get_feature("F1") assert_eq(f1.length(), 2) @@ -239,12 +311,9 @@ test "mbn_msnset_get_feature" { assert_eq(missing.length(), 0) } +///| test "mbn_msnset_get_sample" { - let exprs = [ - [10.0, 20.0], - [30.0, 40.0], - [50.0, 60.0], - ] + let exprs = [[10.0, 20.0], [30.0, 40.0], [50.0, 60.0]] let m = @src.MSnSet::from_names(exprs, ["F1", "F2", "F3"], ["S1", "S2"]) let s1 = m.get_sample("S1") assert_eq(s1.length(), 3) @@ -258,11 +327,9 @@ test "mbn_msnset_get_sample" { // MSnSet transformations // ============================================================================ +///| test "mbn_msnset_log2_transform" { - let exprs = [ - [1.0, 3.0], - [7.0, 15.0], - ] + let exprs = [[1.0, 3.0], [7.0, 15.0]] let m = @src.MSnSet::from_names(exprs, ["F1", "F2"], ["S1", "S2"]) let m2 = m.log2_transform(offset=1.0) // log2(1+1) = 1, log2(3+1) = 2, log2(7+1) = 3, log2(15+1) = 4 @@ -273,10 +340,11 @@ test "mbn_msnset_log2_transform" { assert_true((e[1][1] - 4.0).abs() < 0.0001) } +///| test "mbn_msnset_impute_mean" { let exprs = [ - [10.0, -1.0, 30.0], // -1 = missing, mean of 10,30 = 20 - [5.0, 15.0, 0.0], // 0 = missing, mean of 5,15 = 10 + [10.0, -1.0, 30.0], // -1 = missing, mean of 10,30 = 20 + [5.0, 15.0, 0.0], // 0 = missing, mean of 5,15 = 10 ] let m = @src.MSnSet::from_names(exprs, ["F1", "F2"], ["S1", "S2", "S3"]) let m2 = m.impute_missing(method="mean") @@ -285,9 +353,10 @@ test "mbn_msnset_impute_mean" { assert_true((e[1][2] - 10.0).abs() < 0.0001) } +///| test "mbn_msnset_impute_median" { let exprs = [ - [1.0, -1.0, 5.0], // sorted 1,5 median = 3 + [1.0, -1.0, 5.0], // sorted 1,5 median = 3 [100.0, 200.0, 0.0], // sorted 100,200 median = 150 ] let m = @src.MSnSet::from_names(exprs, ["F1", "F2"], ["S1", "S2", "S3"]) @@ -297,12 +366,9 @@ test "mbn_msnset_impute_median" { assert_true((e[1][2] - 150.0).abs() < 0.0001) } +///| test "mbn_msnset_normalize_sum" { - let exprs = [ - [1.0, 10.0], - [2.0, 20.0], - [3.0, 30.0], - ] + let exprs = [[1.0, 10.0], [2.0, 20.0], [3.0, 30.0]] // S1 sum = 6, S2 sum = 60. target = 12 // S1 scale = 2, so 2, 4, 6 // S2 scale = 0.2, so 2, 4, 6 @@ -315,28 +381,26 @@ test "mbn_msnset_normalize_sum" { assert_true((e[1][1] - 4.0).abs() < 0.0001) } +///| test "mbn_msnset_normalize_median_center" { - let exprs = [ - [1.0, 10.0], - [3.0, 20.0], - [5.0, 30.0], - ] + let exprs = [[1.0, 10.0], [3.0, 20.0], [5.0, 30.0]] // S1 median = 3, S2 median = 20 // After: [-2, -10, 2] and [0, 0, 10] let m = @src.MSnSet::from_names(exprs, ["F1", "F2", "F3"], ["S1", "S2"]) let m2 = m.normalize_median_center() let e = m2.exprs() - assert_true((e[0][0] - (-2.0)).abs() < 0.0001) + assert_true((e[0][0] - -2.0).abs() < 0.0001) assert_true((e[2][0] - 2.0).abs() < 0.0001) assert_true((e[1][1] - 0.0).abs() < 0.0001) assert_true((e[2][1] - 10.0).abs() < 0.0001) } +///| test "mbn_msnset_summarize_proteins_sum" { // Two peptides from P1, one from P2 let exprs = [ - [100.0, 200.0], // Peptide1 -> P1 - [300.0, 400.0], // Peptide2 -> P1 + [100.0, 200.0], // Peptide1 -> P1 + [300.0, 400.0], // Peptide2 -> P1 [1000.0, 2000.0], // Peptide3 -> P2 ] let fd = [ @@ -358,8 +422,12 @@ test "mbn_msnset_summarize_proteins_sum" { let mut p1_idx = -1 let mut p2_idx = -1 for i in 0..= 0) assert_true(p2_idx >= 0) @@ -372,19 +440,27 @@ test "mbn_msnset_summarize_proteins_sum" { // Spectrum processing // ============================================================================ +///| test "mbn_spectrum_smooth_ma" { let mz = [100.0, 200.0, 300.0, 400.0, 500.0, 600.0, 700.0] let int = [1.0, 100.0, 1.0, 100.0, 1.0, 100.0, 1.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) let smoothed = sp.smooth_moving_average(half_window=1) // Position 1 (100): avg of [1, 100, 1] = 34 // (due to hw=1 => 3-point average) let si = smoothed.intensity() // Check that smoothing reduces the extremes (values become more moderate) - assert_true(si[1] < 100.0) // was spike - assert_true(si[2] > 1.0) // was valley + assert_true(si[1] < 100.0) // was spike + assert_true(si[2] > 1.0) // was valley } +///| test "mbn_spectrum_baseline_correct" { let n = 20 let mz : Array[Double] = [] @@ -396,7 +472,13 @@ test "mbn_spectrum_baseline_correct" { let peak = if i == 10 { 900.0 } else { 0.0 } int.push(base + peak) } - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) let corrected = sp.baseline_correct_minwin(half_window=2) // Peak center should still be present (around 900), others should be near 0 let ci = corrected.intensity() @@ -411,12 +493,19 @@ test "mbn_spectrum_baseline_correct" { } } +///| test "mbn_spectrum_centroid_simple" { // Three peaks: at 99, 100, 101 (peak in center, symmetric) // plus a trough let mz = [90.0, 99.0, 100.0, 101.0, 110.0, 199.0, 200.0, 201.0, 300.0] let int = [1.0, 50.0, 100.0, 50.0, 1.0, 60.0, 200.0, 60.0, 1.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) let centroided = sp.centroid_simple(snr_threshold=0.0) // Should find two peaks near 100 and 200 assert_true(centroided.peaks_count() >= 2) @@ -426,6 +515,7 @@ test "mbn_spectrum_centroid_simple" { // Sample QC // ============================================================================ +///| test "mbn_msnset_sample_qc" { let exprs = [ [100.0, 0.0], @@ -434,7 +524,9 @@ test "mbn_msnset_sample_qc" { [0.0, 3000.0], [500.0, 0.0], ] - let m = @src.MSnSet::from_names(exprs, ["F1", "F2", "F3", "F4", "F5"], ["S1", "S2"]) + let m = @src.MSnSet::from_names(exprs, ["F1", "F2", "F3", "F4", "F5"], [ + "S1", "S2", + ]) let qc = m.sample_qc() assert_eq(qc.length(), 2) // S1: detected 4 (one zero), total = 1100 diff --git a/test/moonbit/msstats_test.mbt b/test/moonbit/msstats_test.mbt index 89a3f5e7..e8ba26e7 100644 --- a/test/moonbit/msstats_test.mbt +++ b/test/moonbit/msstats_test.mbt @@ -1,6 +1,5 @@ ///| /// Test file for MSstats module. - test "msstats_feature_creation" { let f = @src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1000.0) assert_eq(f.protein, "P1") @@ -12,12 +11,20 @@ test "msstats_feature_creation" { assert_eq(f.intensity, 1000.0) } +///| test "msstats_data_process_log_transform" { let features : Array[@src.MSFeature] = Array::new() - features.push(@src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1024.0)) - features.push(@src.MSFeature::new("P1", "pep1", "tr1", "Trt", "S2", "R2", 2048.0)) - - let processed = @src.ms_data_process(features, normalization=@src.ms_norm_none()) + features.push( + @src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1024.0), + ) + features.push( + @src.MSFeature::new("P1", "pep1", "tr1", "Trt", "S2", "R2", 2048.0), + ) + + let processed = @src.ms_data_process( + features, + normalization=@src.ms_norm_none(), + ) assert_eq(processed.length(), 2) // log2(1024) = 10 assert_true((processed[0].intensity - 10.0).abs() < 0.01) @@ -25,38 +32,64 @@ test "msstats_data_process_log_transform" { assert_true((processed[1].intensity - 11.0).abs() < 0.01) } +///| test "msstats_data_process_median_norm" { let features : Array[@src.MSFeature] = Array::new() - features.push(@src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1024.0)) - features.push(@src.MSFeature::new("P1", "pep2", "tr2", "Ctrl", "S1", "R1", 4096.0)) - features.push(@src.MSFeature::new("P2", "pep3", "tr3", "Trt", "S2", "R2", 2048.0)) - features.push(@src.MSFeature::new("P2", "pep4", "tr4", "Trt", "S2", "R2", 8192.0)) - - let processed = @src.ms_data_process(features, normalization=@src.ms_norm_median()) + features.push( + @src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1024.0), + ) + features.push( + @src.MSFeature::new("P1", "pep2", "tr2", "Ctrl", "S1", "R1", 4096.0), + ) + features.push( + @src.MSFeature::new("P2", "pep3", "tr3", "Trt", "S2", "R2", 2048.0), + ) + features.push( + @src.MSFeature::new("P2", "pep4", "tr4", "Trt", "S2", "R2", 8192.0), + ) + + let processed = @src.ms_data_process( + features, + normalization=@src.ms_norm_median(), + ) assert_eq(processed.length(), 4) // Values should be centered (median subtracted) // R1: log2(1024)=10, log2(4096)=12, median=11, so values become -1, 1 // R2: log2(2048)=11, log2(8192)=13, median=12, so values become -1, 1 - assert_true((processed[0].intensity - (-1.0)).abs() < 0.01) + assert_true((processed[0].intensity - -1.0).abs() < 0.01) assert_true((processed[1].intensity - 1.0).abs() < 0.01) } +///| test "msstats_data_process_zero_intensity" { let features : Array[@src.MSFeature] = Array::new() - features.push(@src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 0.0)) - - let processed = @src.ms_data_process(features, normalization=@src.ms_norm_none()) + features.push( + @src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 0.0), + ) + + let processed = @src.ms_data_process( + features, + normalization=@src.ms_norm_none(), + ) // Zero should be replaced with 1, then log2(1) = 0 assert_true(processed[0].intensity.abs() < 0.01) } +///| test "msstats_summarize_tukey" { let features : Array[@src.MSFeature] = Array::new() // Two peptides for protein P1 in run R1 - features.push(@src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1024.0)) - features.push(@src.MSFeature::new("P1", "pep2", "tr2", "Ctrl", "S1", "R1", 4096.0)) - - let processed = @src.ms_data_process(features, normalization=@src.ms_norm_none()) + features.push( + @src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1024.0), + ) + features.push( + @src.MSFeature::new("P1", "pep2", "tr2", "Ctrl", "S1", "R1", 4096.0), + ) + + let processed = @src.ms_data_process( + features, + normalization=@src.ms_norm_none(), + ) let summarized = @src.ms_summarize(processed, method=@src.ms_summary_tukey()) assert_eq(summarized.length(), 1) // One protein-run combo assert_eq(summarized[0].protein, "P1") @@ -65,43 +98,72 @@ test "msstats_summarize_tukey" { assert_true((summarized[0].log2_abundance - 11.0).abs() < 0.01) } +///| test "msstats_summarize_linear" { let features : Array[@src.MSFeature] = Array::new() - features.push(@src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1024.0)) - features.push(@src.MSFeature::new("P1", "pep2", "tr2", "Ctrl", "S1", "R1", 4096.0)) - - let processed = @src.ms_data_process(features, normalization=@src.ms_norm_none()) + features.push( + @src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1024.0), + ) + features.push( + @src.MSFeature::new("P1", "pep2", "tr2", "Ctrl", "S1", "R1", 4096.0), + ) + + let processed = @src.ms_data_process( + features, + normalization=@src.ms_norm_none(), + ) let summarized = @src.ms_summarize(processed, method=@src.ms_summary_linear()) // Mean of log2(1024)=10 and log2(4096)=12 is 11 assert_true((summarized[0].log2_abundance - 11.0).abs() < 0.01) } +///| test "msstats_group_comparison_basic" { let features = @src.msstats_sample_data() - let processed = @src.ms_data_process(features, normalization=@src.ms_norm_median()) + let processed = @src.ms_data_process( + features, + normalization=@src.ms_norm_median(), + ) let summarized = @src.ms_summarize(processed) - let results = @src.ms_group_comparison(summarized, fdr_threshold=0.5, log2fc_threshold=0.5) + let results = @src.ms_group_comparison( + summarized, + fdr_threshold=0.5, + log2fc_threshold=0.5, + ) assert_true(results.get_n_results() > 0) } +///| test "msstats_group_comparison_significant" { let features = @src.msstats_sample_data() - let processed = @src.ms_data_process(features, normalization=@src.ms_norm_median()) + let processed = @src.ms_data_process( + features, + normalization=@src.ms_norm_median(), + ) let summarized = @src.ms_summarize(processed) - let results = @src.ms_group_comparison(summarized, fdr_threshold=0.5, log2fc_threshold=0.0) + let results = @src.ms_group_comparison( + summarized, + fdr_threshold=0.5, + log2fc_threshold=0.0, + ) let sig = results.get_significant() assert_true(sig.length() >= 0) } +///| test "msstats_group_comparison_top_proteins" { let features = @src.msstats_sample_data() - let processed = @src.ms_data_process(features, normalization=@src.ms_norm_median()) + let processed = @src.ms_data_process( + features, + normalization=@src.ms_norm_median(), + ) let summarized = @src.ms_summarize(processed) let results = @src.ms_group_comparison(summarized) let top = results.get_top_proteins(2) assert_eq(top.length(), 2) } +///| test "msstats_group_comparison_summary" { let features = @src.msstats_sample_data() let processed = @src.ms_data_process(features) @@ -111,6 +173,7 @@ test "msstats_group_comparison_summary" { assert_true(s.contains("MSstats")) } +///| test "msstats_sample_size" { let features = @src.msstats_sample_data() let processed = @src.ms_data_process(features) @@ -120,12 +183,14 @@ test "msstats_sample_size" { assert_true(ss.n_samples >= 3) } +///| test "msstats_sample_data" { let features = @src.msstats_sample_data() assert_eq(features.length(), 40) // 5 proteins * 4 groups * 2 peptides assert_eq(features[0].protein, "P1") } +///| test "msstats_type_to_string" { assert_eq(@src.ms_type_dda().to_string(), "DDA") assert_eq(@src.ms_type_dia().to_string(), "DIA") @@ -133,6 +198,7 @@ test "msstats_type_to_string" { assert_eq(@src.ms_type_tmt().to_string(), "TMT") } +///| test "msstats_norm_to_string" { assert_eq(@src.ms_norm_none().to_string(), "none") assert_eq(@src.ms_norm_median().to_string(), "median") @@ -140,6 +206,7 @@ test "msstats_norm_to_string" { assert_eq(@src.ms_norm_global().to_string(), "globalStandards") } +///| test "msstats_summary_to_string" { assert_eq(@src.ms_summary_tukey().to_string(), "Tukey") assert_eq(@src.ms_summary_linear().to_string(), "linear") diff --git a/test/moonbit/muscat_test.mbt b/test/moonbit/muscat_test.mbt index 2ebf4aec..ec4a524c 100644 --- a/test/moonbit/muscat_test.mbt +++ b/test/moonbit/muscat_test.mbt @@ -1,6 +1,5 @@ ///| /// Test file for muscat module. - test "muscat_single_cell_creation" { let cell = @src.SingleCell::new("cell1", "sample1", "cluster1", "ctrl") assert_eq(cell.cell_id, "cell1") @@ -9,6 +8,7 @@ test "muscat_single_cell_creation" { assert_eq(cell.group_id, "ctrl") } +///| test "muscat_single_cell_set_get_count" { let cell = @src.SingleCell::new("cell1", "sample1", "cluster1", "ctrl") cell.set_count("Gene1", 10.0) @@ -18,6 +18,7 @@ test "muscat_single_cell_set_get_count" { assert_eq(cell.get_count("Gene3"), 0.0) // Non-existent } +///| test "muscat_single_cell_total_counts" { let cell = @src.SingleCell::new("cell1", "sample1", "cluster1", "ctrl") cell.set_count("Gene1", 10.0) @@ -26,6 +27,7 @@ test "muscat_single_cell_total_counts" { assert_eq(cell.total_counts(), 35.0) } +///| test "muscat_single_cell_n_expressed" { let cell = @src.SingleCell::new("cell1", "sample1", "cluster1", "ctrl") cell.set_count("Gene1", 10.0) @@ -34,6 +36,7 @@ test "muscat_single_cell_n_expressed" { assert_eq(cell.n_expressed(), 2) } +///| test "muscat_aggregation_sum" { let cells : Array[@src.SingleCell] = Array::new() let c1 = @src.SingleCell::new("c1", "S1", "C1", "ctrl") @@ -52,6 +55,7 @@ test "muscat_aggregation_sum" { assert_eq(pb[0].n_cells, 2) } +///| test "muscat_aggregation_mean" { let cells : Array[@src.SingleCell] = Array::new() let c1 = @src.SingleCell::new("c1", "S1", "C1", "ctrl") @@ -66,6 +70,7 @@ test "muscat_aggregation_mean" { assert_eq(pb[0].get_count("Gene1"), 15.0) } +///| test "muscat_aggregation_multiple_samples" { let cells : Array[@src.SingleCell] = Array::new() // Sample S1, Cluster C1 @@ -85,6 +90,7 @@ test "muscat_aggregation_multiple_samples" { assert_eq(pb.length(), 3) // 3 (sample, cluster) combinations } +///| test "muscat_pseudobulk_total_counts" { let cells : Array[@src.SingleCell] = Array::new() let c1 = @src.SingleCell::new("c1", "S1", "C1", "ctrl") @@ -99,6 +105,7 @@ test "muscat_pseudobulk_total_counts" { assert_eq(pb[0].total_counts(), 35.0) } +///| test "muscat_pseudobulk_n_expressed" { let cells : Array[@src.SingleCell] = Array::new() let c1 = @src.SingleCell::new("c1", "S1", "C1", "ctrl") @@ -114,6 +121,7 @@ test "muscat_pseudobulk_n_expressed" { assert_eq(pb[0].n_expressed(), 2) // Gene1 and Gene3 > 0 } +///| test "muscat_ds_analysis_basic" { let cells = @src.muscat_sample_data() let pb = @src.aggregate_cells(cells) @@ -122,14 +130,20 @@ test "muscat_ds_analysis_basic" { assert_eq(results.n_clusters, 2) } +///| test "muscat_ds_analysis_significant" { let cells = @src.muscat_sample_data() let pb = @src.aggregate_cells(cells) - let results = @src.run_ds_analysis(pb, fdr_threshold=0.5, log2fc_threshold=0.5) + let results = @src.run_ds_analysis( + pb, + fdr_threshold=0.5, + log2fc_threshold=0.5, + ) let sig = results.get_significant() assert_true(sig.length() > 0) } +///| test "muscat_ds_analysis_cluster_filter" { let cells = @src.muscat_sample_data() let pb = @src.aggregate_cells(cells) @@ -138,6 +152,7 @@ test "muscat_ds_analysis_cluster_filter" { assert_true(c1_results.length() > 0) } +///| test "muscat_ds_analysis_top_genes" { let cells = @src.muscat_sample_data() let pb = @src.aggregate_cells(cells) @@ -146,6 +161,7 @@ test "muscat_ds_analysis_top_genes" { assert_eq(top.length(), 3) } +///| test "muscat_qc_computation" { let cells = @src.muscat_sample_data() let pb = @src.aggregate_cells(cells) @@ -153,6 +169,7 @@ test "muscat_qc_computation" { assert_eq(qc.length(), pb.length()) } +///| test "muscat_summary" { let cells = @src.muscat_sample_data() let pb = @src.aggregate_cells(cells) @@ -161,12 +178,14 @@ test "muscat_summary" { assert_true(s.contains("muscat")) } +///| test "muscat_aggregation_method_to_string" { assert_eq(@src.aggregation_sum().to_string(), "sum") assert_eq(@src.aggregation_mean().to_string(), "mean") assert_eq(@src.aggregation_median().to_string(), "median") } +///| test "muscat_ds_method_to_string" { assert_eq(@src.ds_method_edger().to_string(), "edgeR") assert_eq(@src.ds_method_deseq2().to_string(), "DESeq2") diff --git a/test/moonbit/naccess_test.mbt b/test/moonbit/naccess_test.mbt index 6302efb1..57a3a197 100644 --- a/test/moonbit/naccess_test.mbt +++ b/test/moonbit/naccess_test.mbt @@ -127,9 +127,13 @@ test "naccess_result_new_empty" { test "naccess_result_add_residue" { let r = @src.NaccessResult::new() assert_eq(r.get_num_residues(), 0) - r.add_residue(@src.NaccessResidue::new(res_name="ALA", res_num=1, chain_id="A")) + r.add_residue( + @src.NaccessResidue::new(res_name="ALA", res_num=1, chain_id="A"), + ) assert_eq(r.get_num_residues(), 1) - r.add_residue(@src.NaccessResidue::new(res_name="GLY", res_num=2, chain_id="A")) + r.add_residue( + @src.NaccessResidue::new(res_name="GLY", res_num=2, chain_id="A"), + ) assert_eq(r.get_num_residues(), 2) } @@ -164,8 +168,12 @@ test "naccess_result_add_atom" { ///| test "naccess_result_get_residues" { let r = @src.NaccessResult::new() - r.add_residue(@src.NaccessResidue::new(res_name="MET", res_num=1, chain_id="A")) - r.add_residue(@src.NaccessResidue::new(res_name="ALA", res_num=2, chain_id="A")) + r.add_residue( + @src.NaccessResidue::new(res_name="MET", res_num=1, chain_id="A"), + ) + r.add_residue( + @src.NaccessResidue::new(res_name="ALA", res_num=2, chain_id="A"), + ) let residues = r.get_residues() assert_eq(residues.length(), 2) assert_eq(residues[0].res_name, "MET") @@ -206,7 +214,9 @@ test "naccess_result_get_num_residues" { let r = @src.NaccessResult::new() assert_eq(r.get_num_residues(), 0) for i in 0..<5 { - r.add_residue(@src.NaccessResidue::new(res_name="ALA", res_num=i, chain_id="A")) + r.add_residue( + @src.NaccessResidue::new(res_name="ALA", res_num=i, chain_id="A"), + ) } assert_eq(r.get_num_residues(), 5) } @@ -409,26 +419,39 @@ test "naccess_parse_asa_header_only" { ///| test "naccess_parse_combined_counts" { - let result = @src.naccess_parse(@src.naccess_sample_rsa(), @src.naccess_sample_asa()) + let result = @src.naccess_parse( + @src.naccess_sample_rsa(), + @src.naccess_sample_asa(), + ) assert_eq(result.get_num_residues(), 4) assert_eq(result.get_num_atoms(), 6) } ///| test "naccess_parse_total_abs_asa" { - let result = @src.naccess_parse(@src.naccess_sample_rsa(), @src.naccess_sample_asa()) + let result = @src.naccess_parse( + @src.naccess_sample_rsa(), + @src.naccess_sample_asa(), + ) // 45.3 + 20.1 + 5.2 + 25.0 = 95.6 assert_true((result.total_abs_asa - 95.6).abs() < naccess_eps) } ///| test "naccess_parse_chain_totals" { - let result = @src.naccess_parse(@src.naccess_sample_rsa(), @src.naccess_sample_asa()) + let result = @src.naccess_parse( + @src.naccess_sample_rsa(), + @src.naccess_sample_asa(), + ) assert_eq(result.chain_totals.length(), 2) // Chain A: 45.3 + 20.1 + 5.2 = 70.6 - assert_true((result.chain_totals.get("A").unwrap() - 70.6).abs() < naccess_eps) + assert_true( + (result.chain_totals.get("A").unwrap() - 70.6).abs() < naccess_eps, + ) // Chain B: 25.0 - assert_true((result.chain_totals.get("B").unwrap() - 25.0).abs() < naccess_eps) + assert_true( + (result.chain_totals.get("B").unwrap() - 25.0).abs() < naccess_eps, + ) } ///| @@ -578,13 +601,17 @@ test "naccess_count_exposed" { test "naccess_chain_total_asa_a" { let result = @src.naccess_sample() // 45.3 + 20.1 + 5.2 = 70.6 - assert_true((@src.naccess_chain_total_asa(result, "A") - 70.6).abs() < naccess_eps) + assert_true( + (@src.naccess_chain_total_asa(result, "A") - 70.6).abs() < naccess_eps, + ) } ///| test "naccess_chain_total_asa_b" { let result = @src.naccess_sample() - assert_true((@src.naccess_chain_total_asa(result, "B") - 25.0).abs() < naccess_eps) + assert_true( + (@src.naccess_chain_total_asa(result, "B") - 25.0).abs() < naccess_eps, + ) } ///| diff --git a/test/moonbit/naive_bayes_test.mbt b/test/moonbit/naive_bayes_test.mbt index feb02250..dbb826ea 100644 --- a/test/moonbit/naive_bayes_test.mbt +++ b/test/moonbit/naive_bayes_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Bio.NaiveBayes sequence classifier module. - test "classifier_new_defaults" { let clf = @src.NaiveBayesClassifier::new() assert_eq(clf.kmer_size, 3) @@ -9,24 +8,28 @@ test "classifier_new_defaults" { assert_eq(clf.class_labels.length(), 0) } +///| test "classifier_set_kmer_size" { let clf = @src.NaiveBayesClassifier::new().set_kmer_size(5) assert_eq(clf.kmer_size, 5) assert_eq(clf.alpha, 1.0) } +///| test "classifier_set_alpha" { let clf = @src.NaiveBayesClassifier::new().set_alpha(0.5) assert_eq(clf.kmer_size, 3) assert_eq(clf.alpha, 0.5) } +///| test "classifier_setters_chain" { let clf = @src.NaiveBayesClassifier::new().set_kmer_size(4).set_alpha(0.1) assert_eq(clf.kmer_size, 4) assert_eq(clf.alpha, 0.1) } +///| test "extract_kmers_basic" { let kmers = @src.naive_bayes_extract_kmers("ABCDE", 2) assert_eq(kmers.length(), 4) @@ -36,28 +39,33 @@ test "extract_kmers_basic" { assert_eq(kmers.get("DE").unwrap(), 1) } +///| test "extract_kmers_repeated" { let kmers = @src.naive_bayes_extract_kmers("AAAA", 2) assert_eq(kmers.length(), 1) assert_eq(kmers.get("AA").unwrap(), 3) } +///| test "extract_kmers_k_larger_than_length" { let kmers = @src.naive_bayes_extract_kmers("ABC", 5) assert_eq(kmers.length(), 0) } +///| test "extract_kmers_k_equals_length" { let kmers = @src.naive_bayes_extract_kmers("ABC", 3) assert_eq(kmers.length(), 1) assert_eq(kmers.get("ABC").unwrap(), 1) } +///| test "extract_kmers_empty_sequence" { let kmers = @src.naive_bayes_extract_kmers("", 3) assert_eq(kmers.length(), 0) } +///| test "train_basic" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -67,6 +75,7 @@ test "train_basic" { assert_eq(trained.models.length(), 2) } +///| test "predict_at_rich_correct" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -75,6 +84,7 @@ test "predict_at_rich_correct" { assert_eq(pred.0, "AT_rich") } +///| test "predict_gc_rich_correct" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -83,6 +93,7 @@ test "predict_gc_rich_correct" { assert_eq(pred.0, "GC_rich") } +///| test "predict_proba_sums_to_one" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -95,14 +106,18 @@ test "predict_proba_sums_to_one" { assert_true(sum > 0.99 && sum < 1.01) } +///| test "predict_log_probs_returns_all_classes" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() let trained = @src.naive_bayes_train(clf, data.0, data.1) - let log_probs = @src.naive_bayes_predict_log_probs(trained, "ATATATATATATATATATAT") + let log_probs = @src.naive_bayes_predict_log_probs( + trained, "ATATATATATATATATATAT", + ) assert_eq(log_probs.length(), 2) } +///| test "top_k_returns_k_items" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -111,6 +126,7 @@ test "top_k_returns_k_items" { assert_eq(top.length(), 1) } +///| test "top_k_descending_order" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -120,6 +136,7 @@ test "top_k_descending_order" { assert_true(top[0].1 >= top[1].1) } +///| test "accuracy_on_sample_data" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -128,6 +145,7 @@ test "accuracy_on_sample_data" { assert_true(acc > 0.5) } +///| test "unknown_sequence_reasonable_defaults" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -142,18 +160,26 @@ test "unknown_sequence_reasonable_defaults" { assert_true(sum > 0.99 && sum < 1.01) } +///| test "kmer_size_affects_results" { let data = @src.naive_bayes_sample_data() let clf3 = @src.NaiveBayesClassifier::new() let trained3 = @src.naive_bayes_train(clf3, data.0, data.1) let clf2 = @src.NaiveBayesClassifier::new().set_kmer_size(2) let trained2 = @src.naive_bayes_train(clf2, data.0, data.1) - let log_probs3 = @src.naive_bayes_predict_log_probs(trained3, "ATATATATATATATATATAT") - let log_probs2 = @src.naive_bayes_predict_log_probs(trained2, "ATATATATATATATATATAT") + let log_probs3 = @src.naive_bayes_predict_log_probs( + trained3, "ATATATATATATATATATAT", + ) + let log_probs2 = @src.naive_bayes_predict_log_probs( + trained2, "ATATATATATATATATATAT", + ) let diff = (log_probs3[0].1 - log_probs2[0].1).abs() - assert_true(diff > 0.0 || trained3.vocabulary.length() != trained2.vocabulary.length()) + assert_true( + diff > 0.0 || trained3.vocabulary.length() != trained2.vocabulary.length(), + ) } +///| test "class_labels_array_after_training" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -164,12 +190,14 @@ test "class_labels_array_after_training" { assert_true(has_at && has_gc) } +///| test "sample_data_has_8_sequences" { let data = @src.naive_bayes_sample_data() assert_eq(data.0.length(), 8) assert_eq(data.1.length(), 8) } +///| test "sample_data_labels_count" { let data = @src.naive_bayes_sample_data() let mut at_count = 0 @@ -185,6 +213,7 @@ test "sample_data_labels_count" { assert_eq(gc_count, 4) } +///| test "train_empty_sequences" { let clf = @src.NaiveBayesClassifier::new() let seqs : Array[String] = [] @@ -194,6 +223,7 @@ test "train_empty_sequences" { assert_eq(trained.vocabulary.length(), 0) } +///| test "predict_empty_sequence" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -202,6 +232,7 @@ test "predict_empty_sequence" { assert_true(trained.class_labels.contains(pred.0)) } +///| test "accuracy_empty_data" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() diff --git a/test/moonbit/nanostring_test.mbt b/test/moonbit/nanostring_test.mbt index 22b95917..e8962185 100644 --- a/test/moonbit/nanostring_test.mbt +++ b/test/moonbit/nanostring_test.mbt @@ -25,9 +25,7 @@ test "ns_sample_creation" { ///| test "ns_sample_accessors" { let raw = [100, 200, 300, 50, 60, 10, 20] - let sample = @src.NsSample::new( - "S1", raw, [3, 4], [5, 6], [0, 1], [0, 1, 2], - ) + let sample = @src.NsSample::new("S1", raw, [3, 4], [5, 6], [0, 1], [0, 1, 2]) let pos = sample.positive_controls() assert_eq(pos.length(), 2) assert_eq(pos[0], 50) @@ -65,9 +63,7 @@ test "ns_nanostring_data_add_sample" { let gene_names = ["G1", "G2", "G3"] let data = @src.NsNanostringData::new(gene_names) let raw = [100, 200, 300, 50, 60, 10, 20] - let sample = @src.NsSample::new( - "S1", raw, [3, 4], [5, 6], [0, 1], [0, 1, 2], - ) + let sample = @src.NsSample::new("S1", raw, [3, 4], [5, 6], [0, 1], [0, 1, 2]) data.add_sample(sample) assert_eq(data.n_samples(), 1) assert_eq(data.n_genes(), 3) @@ -127,11 +123,11 @@ test "ns_log2_counts_known" { test "ns_log2_counts_zero_pseudocount" { // log2(0 + 0.5) = log2(0.5) = -1. let result = @src.ns_log2_counts([0.0]) - assert_true((result[0] - (-1.0)).abs() < 0.01) + assert_true((result[0] - -1.0).abs() < 0.01) // Multiple values. let result2 = @src.ns_log2_counts([0.0, 1.0, 7.0]) // log2(0.5) = -1, log2(1.5) ≈ 0.585, log2(7.5) ≈ 2.907 - assert_true((result2[0] - (-1.0)).abs() < 0.01) + assert_true((result2[0] - -1.0).abs() < 0.01) assert_true((result2[1] - 0.585).abs() < 0.01) assert_true((result2[2] - 2.907).abs() < 0.01) } @@ -448,9 +444,7 @@ test "ns_edge_single_sample" { let gene_names = ["G1", "G2", "G3"] let data = @src.NsNanostringData::new(gene_names) let raw = [100, 200, 300, 50, 60, 10, 20] - let sample = @src.NsSample::new( - "S1", raw, [3, 4], [5, 6], [0, 1], [0, 1, 2], - ) + let sample = @src.NsSample::new("S1", raw, [3, 4], [5, 6], [0, 1], [0, 1, 2]) data.add_sample(sample) assert_eq(data.n_samples(), 1) let results = @src.ns_positive_control_norm(data) @@ -463,9 +457,7 @@ test "ns_edge_single_gene" { let gene_names = ["G1"] let data = @src.NsNanostringData::new(gene_names) let raw = [100, 50, 10] - let sample = @src.NsSample::new( - "S1", raw, [1], [2], [0], [0], - ) + let sample = @src.NsSample::new("S1", raw, [1], [2], [0], [0]) data.add_sample(sample) assert_eq(data.n_genes(), 1) let results = @src.ns_positive_control_norm(data) @@ -477,9 +469,9 @@ test "ns_edge_all_zeros" { let gene_names = ["G1", "G2", "G3"] let data = @src.NsNanostringData::new(gene_names) let raw = [0, 0, 0, 0, 0, 0, 0, 0, 0] - let sample = @src.NsSample::new( - "S1", raw, [3, 4, 5], [6, 7, 8], [0, 1, 2], [0, 1, 2], - ) + let sample = @src.NsSample::new("S1", raw, [3, 4, 5], [6, 7, 8], [0, 1, 2], [ + 0, 1, 2, + ]) data.add_sample(sample) let results = @src.ns_positive_control_norm(data) assert_eq(results.length(), 1) diff --git a/test/moonbit/nib_io_test.mbt b/test/moonbit/nib_io_test.mbt index 391b0e6a..0302e6be 100644 --- a/test/moonbit/nib_io_test.mbt +++ b/test/moonbit/nib_io_test.mbt @@ -298,7 +298,10 @@ test "nib_size" { test "nib_compressed_size" { // 8 bases -> 2 bytes; 9 bases -> 3 bytes; 1 base -> 1 byte; 0 bases -> 0. assert_eq(@src.nib_compressed_size(@src.NibSequence::new("a", "ATGCATGC")), 2) - assert_eq(@src.nib_compressed_size(@src.NibSequence::new("b", "ATGCATGCA")), 3) + assert_eq( + @src.nib_compressed_size(@src.NibSequence::new("b", "ATGCATGCA")), + 3, + ) assert_eq(@src.nib_compressed_size(@src.NibSequence::new("c", "A")), 1) assert_eq(@src.nib_compressed_size(@src.NibSequence::new("d", "")), 0) } @@ -675,7 +678,8 @@ test "edge_case_three_bases" { ///| test "edge_case_hex_round_trip_various_lengths" { - for seq in ["A", "AT", "ATG", "ATGC", "ATGCA", "ATGCAT", "ATGCATG", "ATGCATGC"] { + for + seq in ["A", "AT", "ATG", "ATGC", "ATGCA", "ATGCAT", "ATGCATG", "ATGCATGC"] { let nib = @src.NibSequence::new("s", seq) let hex = @src.nib_to_hex(nib) let nib2 = @src.nib_from_hex("s2", hex, seq.length()) diff --git a/test/moonbit/nmr_test.mbt b/test/moonbit/nmr_test.mbt index 1b12694f..4889777b 100644 --- a/test/moonbit/nmr_test.mbt +++ b/test/moonbit/nmr_test.mbt @@ -326,8 +326,8 @@ test "dihedral_restraint_construction" { assert_eq(d.restraint_id, 1) assert_eq(d.angle_name, "PHI") assert_eq(d.residue, 15) - assert_true((d.lower_bound - (-120.0)).abs() < 0.001) - assert_true((d.upper_bound - (-60.0)).abs() < 0.001) + assert_true((d.lower_bound - -120.0).abs() < 0.001) + assert_true((d.upper_bound - -60.0).abs() < 0.001) } ///| @@ -385,8 +385,8 @@ test "parse_dihedral_restraints_basic" { assert_eq(restraints.length(), 2) assert_eq(restraints[0].angle_name, "PHI") assert_eq(restraints[0].residue, 15) - assert_true((restraints[0].lower_bound - (-120.0)).abs() < 0.001) - assert_true((restraints[0].observed.unwrap_or(0.0) - (-85.0)).abs() < 0.001) + assert_true((restraints[0].lower_bound - -120.0).abs() < 0.001) + assert_true((restraints[0].observed.unwrap_or(0.0) - -85.0).abs() < 0.001) } // ============================================================================ diff --git a/test/moonbit/noiseq_test.mbt b/test/moonbit/noiseq_test.mbt index e70301fa..aa1d896e 100644 --- a/test/moonbit/noiseq_test.mbt +++ b/test/moonbit/noiseq_test.mbt @@ -1,12 +1,12 @@ ///| /// Test file for NOISeq module. - test "noiseq_sample_creation" { let s = @src.NOISeqSample::new("sample1", "control") assert_eq(s.sample_id, "sample1") assert_eq(s.condition, "control") } +///| test "noiseq_sample_set_get_count" { let s = @src.NOISeqSample::new("sample1", "control") s.set_count("Gene1", 100.0) @@ -16,6 +16,7 @@ test "noiseq_sample_set_get_count" { assert_eq(s.get_count("Gene3"), 0.0) // Non-existent } +///| test "noiseq_sample_library_size" { let s = @src.NOISeqSample::new("sample1", "control") s.set_count("Gene1", 100.0) @@ -24,6 +25,7 @@ test "noiseq_sample_library_size" { assert_eq(s.library_size(), 350.0) } +///| test "noiseq_sample_n_expressed" { let s = @src.NOISeqSample::new("sample1", "control") s.set_count("Gene1", 100.0) @@ -32,6 +34,7 @@ test "noiseq_sample_n_expressed" { assert_eq(s.n_expressed(), 2) } +///| test "noiseq_normalize_tmm" { let samples : Array[@src.NOISeqSample] = Array::new() let s1 = @src.NOISeqSample::new("s1", "ctrl") @@ -50,6 +53,7 @@ test "noiseq_normalize_tmm" { assert_true((norm[1].get_count("Gene1") - 100.0).abs() < 0.01) } +///| test "noiseq_normalize_rpkm" { let samples : Array[@src.NOISeqSample] = Array::new() let s1 = @src.NOISeqSample::new("s1", "ctrl") @@ -61,6 +65,7 @@ test "noiseq_normalize_rpkm" { assert_true((norm[0].get_count("Gene1") - 1000000.0).abs() < 0.01) } +///| test "noiseq_normalize_none" { let samples : Array[@src.NOISeqSample] = Array::new() let s1 = @src.NOISeqSample::new("s1", "ctrl") @@ -71,6 +76,7 @@ test "noiseq_normalize_none" { assert_eq(norm[0].get_count("Gene1"), 100.0) } +///| test "noiseq_run_basic" { let (ctrl, trt) = @src.noiseq_sample_data() let results = @src.noiseq_run(ctrl, trt) @@ -78,6 +84,7 @@ test "noiseq_run_basic" { assert_eq(results.n_genes, 10) } +///| test "noiseq_run_significant" { let (ctrl, trt) = @src.noiseq_sample_data() let results = @src.noiseq_run(ctrl, trt, prob_threshold=0.3) @@ -85,6 +92,7 @@ test "noiseq_run_significant" { assert_true(sig.length() > 0) } +///| test "noiseq_run_top_genes" { let (ctrl, trt) = @src.noiseq_sample_data() let results = @src.noiseq_run(ctrl, trt) @@ -94,6 +102,7 @@ test "noiseq_run_top_genes" { assert_true(top[0].prob >= top[1].prob) } +///| test "noiseq_run_up_down_regulated" { let (ctrl, trt) = @src.noiseq_sample_data() let results = @src.noiseq_run(ctrl, trt, prob_threshold=0.3) @@ -103,6 +112,7 @@ test "noiseq_run_up_down_regulated" { assert_true(up.length() + down.length() > 0) } +///| test "noiseq_run_summary" { let (ctrl, trt) = @src.noiseq_sample_data() let results = @src.noiseq_run(ctrl, trt) @@ -111,6 +121,7 @@ test "noiseq_run_summary" { assert_true(s.contains("Genes tested")) } +///| test "noiseq_qc" { let (ctrl, trt) = @src.noiseq_sample_data() let all : Array[@src.NOISeqSample] = Array::new() @@ -128,6 +139,7 @@ test "noiseq_qc" { assert_true(qc.biotype_counts.size() > 0) } +///| test "noiseq_norm_to_string" { assert_eq(@src.noiseq_norm_rpkm().to_string(), "RPKM") assert_eq(@src.noiseq_norm_tmm().to_string(), "TMM") @@ -135,11 +147,13 @@ test "noiseq_norm_to_string" { assert_eq(@src.noiseq_norm_none().to_string(), "none") } +///| test "noiseq_method_to_string" { assert_eq(@src.noiseq_method_bio().to_string(), "NOISeqBio") assert_eq(@src.noiseq_method_sim().to_string(), "NOISeqSim") } +///| test "noiseq_sample_data" { let (ctrl, trt) = @src.noiseq_sample_data() assert_eq(ctrl.length(), 3) @@ -148,6 +162,7 @@ test "noiseq_sample_data" { assert_eq(trt[0].condition, "treatment") } +///| test "noiseq_result_ranking" { let (ctrl, trt) = @src.noiseq_sample_data() let results = @src.noiseq_run(ctrl, trt) diff --git a/test/moonbit/nucle_r_test.mbt b/test/moonbit/nucle_r_test.mbt index 310f46eb..32bb1f1e 100644 --- a/test/moonbit/nucle_r_test.mbt +++ b/test/moonbit/nucle_r_test.mbt @@ -22,7 +22,10 @@ test "nuc_create_example_result" { assert_true(result.nuc_n_count() >= 0) assert_true(result.nuc_mean_spacing() >= 0.0) assert_true(result.nuc_mean_occupancy() >= 0.0) - assert_true(result.nuc_frac_well_positioned() >= 0.0 && result.nuc_frac_well_positioned() <= 1.0) + assert_true( + result.nuc_frac_well_positioned() >= 0.0 && + result.nuc_frac_well_positioned() <= 1.0, + ) } ///| @@ -103,7 +106,7 @@ test "nuc_compare_positioning_identical" { ///| test "nuc_position_methods" { let pos = @src.NucPosition::new( - "chr1", 100, 300, 200.0, 200.0, 0.8, 0.01, true + "chr1", 100, 300, 200.0, 200.0, 0.8, 0.01, true, ) assert_eq(pos.nuc_chrom(), "chr1") assert_eq(pos.nuc_start(), 100) @@ -115,7 +118,7 @@ test "nuc_position_methods" { assert_true(pos.nuc_is_well_positioned()) let pos2 = @src.NucPosition::new( - "chr2", 500, 800, 650.0, 300.0, 0.5, 0.003, false + "chr2", 500, 800, 650.0, 300.0, 0.5, 0.003, false, ) assert_eq(pos2.nuc_chrom(), "chr2") assert_true(!pos2.nuc_is_well_positioned()) @@ -186,6 +189,8 @@ test "nuc_dynamic_result_methods" { assert_true(dynamic.nuc_n_shared() >= 0) assert_eq(dynamic.nuc_n_gained(), 0) assert_eq(dynamic.nuc_n_lost(), 0) - assert_true(dynamic.nuc_frac_changed() >= 0.0 && dynamic.nuc_frac_changed() <= 1.0) + assert_true( + dynamic.nuc_frac_changed() >= 0.0 && dynamic.nuc_frac_changed() <= 1.0, + ) assert_eq(dynamic.nuc_direction(), 0) -} \ No newline at end of file +} diff --git a/test/moonbit/open_cyto_test.mbt b/test/moonbit/open_cyto_test.mbt index db492dbd..feff9f68 100644 --- a/test/moonbit/open_cyto_test.mbt +++ b/test/moonbit/open_cyto_test.mbt @@ -223,7 +223,12 @@ test "oc_gate_new1d_fields" { ///| test "oc_gate_new2d_fields" { let g = @src.OcGate::new2d( - dim1="FSC", dim2="SSC", min1=1.0, max1=2.0, min2=3.0, max2=4.0, + dim1="FSC", + dim2="SSC", + min1=1.0, + max1=2.0, + min2=3.0, + max2=4.0, ) assert_eq(g.dim1, "FSC") assert_eq(g.dim2.unwrap(), "SSC") @@ -256,7 +261,12 @@ test "oc_event_in_gate_1d_boundary" { ///| test "oc_event_in_gate_2d" { let g = @src.OcGate::new2d( - dim1="FSC", dim2="SSC", min1=1.0, max1=3.0, min2=10.0, max2=20.0, + dim1="FSC", + dim2="SSC", + min1=1.0, + max1=3.0, + min2=10.0, + max2=20.0, ) // Both dims in range. assert_true(@src.oc_event_in_gate(g, 2.0, 15.0)) @@ -525,13 +535,13 @@ test "oc_t_pdf_zero_variance" { ///| test "oc_lgamma_one" { // lgamma(1) = log(gamma(1)) = log(1) = 0 - assert_true((@src.oc_lgamma(1.0)).abs() < 0.001) + assert_true(@src.oc_lgamma(1.0).abs() < 0.001) } ///| test "oc_lgamma_two" { // lgamma(2) = log(gamma(2)) = log(1) = 0 - assert_true((@src.oc_lgamma(2.0)).abs() < 0.001) + assert_true(@src.oc_lgamma(2.0).abs() < 0.001) } ///| @@ -651,7 +661,7 @@ test "oc_gating_rule_construction" { child="tcells", method="quantileGate", dims=["CD3"], - args=args, + args~, ) assert_eq(r.parent, "root") assert_eq(r.child, "tcells") @@ -668,22 +678,9 @@ test "oc_gating_rule_construction" { ///| test "oc_gate_flow_set_single_rule" { // One sample, one channel (FSC), bimodal FSC values. - let fs = @src.OcFlowSet::new( - sample_names=["S1"], - channel_names=["FSC"], - data=[ - [ - [1.0], - [1.1], - [0.9], - [1.2], - [5.0], - [5.1], - [4.9], - [5.2], - ], - ], - ) + let fs = @src.OcFlowSet::new(sample_names=["S1"], channel_names=["FSC"], data=[ + [[1.0], [1.1], [0.9], [1.2], [5.0], [5.1], [4.9], [5.2]], + ]) let args : Map[String, Double] = Map::new() args.set("bandwidth", 0.5) let rule = @src.OcGatingRule::new( @@ -691,7 +688,7 @@ test "oc_gate_flow_set_single_rule" { child="cells", method="mindensity", dims=["FSC"], - args=args, + args~, ) let results = @src.oc_gate_flow_set(fs, [rule]) assert_eq(results.length(), 1) @@ -761,16 +758,14 @@ test "oc_gate_flow_set_chain" { test "oc_population_stats_basic" { // Build a gating result by hand: 8 parent events, 4 child events. let gate = @src.OcGate::new1d(dim="FSC", min=3.0, max=1.0e30) - let indices = [ - false, false, false, false, true, true, true, true, - ] + let indices = [false, false, false, false, true, true, true, true] let result = @src.OcGatingResult::new( population="cells", sample="S1", - gate=gate, + gate~, parent_events=8, child_events=4, - indices=indices, + indices~, ) let stats = @src.oc_population_stats([result], 8) assert_eq(stats.length(), 1) @@ -789,7 +784,7 @@ test "oc_population_stats_zero_parent" { let result = @src.OcGatingResult::new( population="dead", sample="S1", - gate=gate, + gate~, parent_events=0, child_events=0, indices=[], @@ -809,7 +804,7 @@ test "oc_gating_summary_string" { let result = @src.OcGatingResult::new( population="cells", sample="S1", - gate=gate, + gate~, parent_events=8, child_events=4, indices=[false, false, false, false, true, true, true, true], @@ -829,7 +824,7 @@ test "oc_gating_summary_string" { ///| test "oc_ln_one" { - assert_true((@src.oc_ln(1.0)).abs() < 0.001) + assert_true(@src.oc_ln(1.0).abs() < 0.001) } ///| diff --git a/test/moonbit/pairaligner_test.mbt b/test/moonbit/pairaligner_test.mbt index bb789da8..5156294a 100644 --- a/test/moonbit/pairaligner_test.mbt +++ b/test/moonbit/pairaligner_test.mbt @@ -1,30 +1,33 @@ ///| /// Test file for pairaligner module. - test "pairaligner_alignment_mode_global" { let mode = @src.pairaligner_global() let config = @src.PairwiseAlignerConfig::default_dna().set_mode(mode) assert_eq(config.mode, mode) } +///| test "pairaligner_alignment_mode_local" { let mode = @src.pairaligner_local() let config = @src.PairwiseAlignerConfig::default_dna().set_mode(mode) assert_eq(config.mode, mode) } +///| test "pairaligner_substitution_matrix_no_matrix" { let mat = @src.pairaligner_no_matrix() let config = @src.PairwiseAlignerConfig::default_dna().set_submatrix(mat) assert_eq(config.submatrix, mat) } +///| test "pairaligner_substitution_matrix_blosum62" { let mat = @src.pairaligner_blosum62() let config = @src.PairwiseAlignerConfig::default_protein().set_submatrix(mat) assert_eq(config.submatrix, mat) } +///| test "pairaligner_default_dna_config" { let config = @src.PairwiseAlignerConfig::default_dna() assert_eq(config.match_score, 1.0) @@ -36,6 +39,7 @@ test "pairaligner_default_dna_config" { assert_eq(config.query_gap_open, -1.0) } +///| test "pairaligner_default_protein_config" { let config = @src.PairwiseAlignerConfig::default_protein() assert_eq(config.gap_open, -10.0) @@ -44,6 +48,7 @@ test "pairaligner_default_protein_config" { assert_eq(config.submatrix, @src.pairaligner_blosum62()) } +///| test "pairaligner_config_setters" { let base = @src.PairwiseAlignerConfig::default_dna() let c1 = base.set_match_score(5.0) @@ -63,11 +68,12 @@ test "pairaligner_config_setters" { assert_eq(base.mismatch_score, -1.0) } +///| test "pairaligner_align_global_dna" { let target = "ACGT" let query = "ACGT" let config = @src.PairwiseAlignerConfig::default_dna() - let aln = @src.pairaligner_align(target, query, config=config) + let aln = @src.pairaligner_align(target, query, config~) assert_eq(aln.aligned1(), "ACGT") assert_eq(aln.aligned2(), "ACGT") assert_eq(aln.identities(), 4) @@ -77,44 +83,50 @@ test "pairaligner_align_global_dna" { assert_eq(ml, "||||") } +///| test "pairaligner_align_global_dna_with_mismatch" { let target = "ACGT" let query = "AGGT" let config = @src.PairwiseAlignerConfig::default_dna() - let aln = @src.pairaligner_align(target, query, config=config) + let aln = @src.pairaligner_align(target, query, config~) assert_eq(aln.alignment_length(), 4) let ml = aln.match_line assert_eq(ml[1:2], ".") assert_eq(aln.score(), 2.0) } +///| test "pairaligner_align_local_dna" { let target = "XXXXACGTXXXX" let query = "ACGT" - let config = @src.PairwiseAlignerConfig::default_dna() - .set_mode(@src.pairaligner_local()) - let aln = @src.pairaligner_align(target, query, config=config) + let config = @src.PairwiseAlignerConfig::default_dna().set_mode( + @src.pairaligner_local(), + ) + let aln = @src.pairaligner_align(target, query, config~) assert_eq(aln.aligned1(), "ACGT") assert_eq(aln.aligned2(), "ACGT") assert_eq(aln.identities(), 4) assert_eq(aln.score(), 4.0) } +///| test "pairaligner_align_protein_blosum62" { let (target, query) = @src.pairaligner_sample_data() let config = @src.PairwiseAlignerConfig::default_protein() - let aln = @src.pairaligner_align(target, query, config=config) + let aln = @src.pairaligner_align(target, query, config~) assert_true(aln.alignment_length() > 0) assert_true(aln.score() > 0.0) assert_true(aln.identities() > 0) } +///| test "pairaligner_aligned1_aligned2" { let aln = @src.pairaligner_align("ACGT", "ACGT") assert_eq(aln.aligned1(), aln.aligned_target) assert_eq(aln.aligned2(), aln.aligned_query) } +///| test "pairaligner_alignment_length" { let aln = @src.pairaligner_align("AAAA", "AAAA") assert_eq(aln.alignment_length(), 4) @@ -122,6 +134,7 @@ test "pairaligner_alignment_length" { assert_eq(aln.aligned2().length(), 4) } +///| test "pairaligner_identities_and_identity_pct" { let aln = @src.pairaligner_align("ACGT", "ACGT") assert_eq(aln.identities(), 4) @@ -131,23 +144,26 @@ test "pairaligner_identities_and_identity_pct" { assert_eq(aln2.identity_pct(), 75.0) } +///| test "pairaligner_gaps_count" { let config = @src.PairwiseAlignerConfig::default_dna() .set_gap_open(-2.0) .set_gap_extend(-1.0) let target = "AAACCC" let query = "AAA" - let aln = @src.pairaligner_align(target, query, config=config) + let aln = @src.pairaligner_align(target, query, config~) let gc = aln.gaps_count() assert_true(gc >= 3) } +///| test "pairaligner_score_extraction" { let aln = @src.pairaligner_align("ACGT", "ACGT") assert_eq(aln.score(), 4.0) assert_eq(aln.score(), aln.score) } +///| test "pairaligner_sample_data" { let (t, q) = @src.pairaligner_sample_data() assert_eq(t, "HEAGAWGHEE") @@ -156,6 +172,7 @@ test "pairaligner_sample_data" { assert_true(q.length() > 0) } +///| test "pairaligner_affine_vs_linear" { let target = "AAAAAAAAAA" let query = "AAAA" @@ -175,6 +192,7 @@ test "pairaligner_affine_vs_linear" { assert_true(linear_aln.score() < 100.0) } +///| test "pairaligner_config_new_named" { let config = @src.PairwiseAlignerConfig::new( mode=@src.pairaligner_local(), @@ -191,12 +209,14 @@ test "pairaligner_config_new_named" { assert_eq(config.alphabet_type, "DNA") } +///| test "pairaligner_local_mode_start_end_positions" { let target = "XXACGTYY" let query = "ACGT" - let config = @src.PairwiseAlignerConfig::default_dna() - .set_mode(@src.pairaligner_local()) - let aln = @src.pairaligner_align(target, query, config=config) + let config = @src.PairwiseAlignerConfig::default_dna().set_mode( + @src.pairaligner_local(), + ) + let aln = @src.pairaligner_align(target, query, config~) assert_eq(aln.target_start, 2) assert_eq(aln.target_end, 6) assert_eq(aln.query_start, 0) diff --git a/test/moonbit/pairwise2_test.mbt b/test/moonbit/pairwise2_test.mbt index feb40d10..582d1706 100644 --- a/test/moonbit/pairwise2_test.mbt +++ b/test/moonbit/pairwise2_test.mbt @@ -74,7 +74,7 @@ test "pairwise_local_convenience" { test "simple_score_match" { let scorer = @src.simple_score(2.0, -1.0) assert_true((scorer("A", "A") - 2.0).abs() < 0.001) - assert_true((scorer("A", "T") - (-1.0)).abs() < 0.001) + assert_true((scorer("A", "T") - -1.0).abs() < 0.001) } ///| @@ -94,7 +94,7 @@ test "identity_score" { test "dna_matrix" { let m = @src.dna_matrix(2.0, -1.0) assert_true((m.get("AA").unwrap() - 2.0).abs() < 0.001) - assert_true((m.get("AT").unwrap() - (-1.0)).abs() < 0.001) + assert_true((m.get("AT").unwrap() - -1.0).abs() < 0.001) assert_eq(m.size(), 10) // 10 unique pairs } @@ -103,7 +103,7 @@ test "matrix_score" { let m = @src.dna_matrix(2.0, -1.0) let scorer = @src.matrix_score(m, 0.0) assert_true((scorer("A", "A") - 2.0).abs() < 0.001) - assert_true((scorer("A", "T") - (-1.0)).abs() < 0.001) + assert_true((scorer("A", "T") - -1.0).abs() < 0.001) assert_true((scorer("X", "X") - 0.0).abs() < 0.001) // default } diff --git a/test/moonbit/paml_test.mbt b/test/moonbit/paml_test.mbt index b4bfdd1f..070fb497 100644 --- a/test/moonbit/paml_test.mbt +++ b/test/moonbit/paml_test.mbt @@ -1,17 +1,18 @@ ///| /// Tests for PAML module. - test "PAMLAlignment creation" { let seqs = [("Human", "ATGCCG"), ("Mouse", "ATGCCG")] let alignment = @src.PAMLAlignment::new(seqs) assert_eq(alignment.sequences.length(), 2) } +///| test "PAMLResult creation" { let result = @src.PAMLResult::new(-100.0) assert_eq(result.ln_likelihood, -100.0) } +///| test "DNDSResult creation" { let dnds = @src.DNDSResult::new(0.1, 0.5, 0.2) assert_eq(dnds.dN, 0.1) @@ -19,17 +20,20 @@ test "DNDSResult creation" { assert_eq(dnds.omega, 0.2) } +///| test "paml_calculate_dnds identical sequences" { let dnds = @src.paml_calculate_dnds("ATGCCG", "ATGCCG", "Nei-Gojobori") assert_true(dnds.omega >= 0.0) } +///| test "paml_calculate_dnds different sequences" { let dnds = @src.paml_calculate_dnds("ATGCCG", "ATTTTT", "Nei-Gojobori") assert_true(dnds.dN >= 0.0) assert_true(dnds.dS >= 0.0) } +///| test "paml_estimate_parameters" { let seqs = [("Seq1", "ATGC"), ("Seq2", "ATGC")] let alignment = @src.PAMLAlignment::new(seqs) @@ -37,24 +41,31 @@ test "paml_estimate_parameters" { assert_true(result.parameters.contains("pi_A")) } +///| test "paml_calculate_substitution_matrix" { - let pi = Map([("pi_A", 0.25), ("pi_T", 0.25), ("pi_C", 0.25), ("pi_G", 0.25)], capacity=4) + let pi = Map( + [("pi_A", 0.25), ("pi_T", 0.25), ("pi_C", 0.25), ("pi_G", 0.25)], + capacity=4, + ) let matrix = @src.paml_calculate_substitution_matrix(2.0, pi) assert_eq(matrix.length(), 4) } +///| test "paml_create_example_alignment" { let alignment = @src.paml_create_example_alignment() assert_eq(alignment.sequences.length(), 4) } +///| test "paml_run_likelihood" { let alignment = @src.paml_create_example_alignment() let result = @src.paml_run_likelihood(alignment) assert_true(result.dnds_ratios.length() > 0) } +///| test "get_standard_codon_table" { let table = @src.get_standard_codon_table() assert_true(table.contains("ATG")) -} \ No newline at end of file +} diff --git a/test/moonbit/parsimony_test.mbt b/test/moonbit/parsimony_test.mbt index b1a041c9..2dda34b2 100644 --- a/test/moonbit/parsimony_test.mbt +++ b/test/moonbit/parsimony_test.mbt @@ -41,7 +41,10 @@ test "parsimony_matrix_sankoff_dna_construction" { ///| test "parsimony_matrix_sankoff_custom_costs" { - let m = @src.parsimony_sankoff_dna_matrix(transition_cost=0.5, transversion_cost=2.5) + let m = @src.parsimony_sankoff_dna_matrix( + transition_cost=0.5, + transversion_cost=2.5, + ) // A->G (transition) = 0.5 assert_eq(@src.parsimony_matrix_cost(m, 0, 2), 0.5) // A->C (transversion) = 2.5 @@ -238,7 +241,10 @@ test "sankoff_parsimony_lower_than_fitch_for_transitions" { let root = @src.Clade::new(clades=[inner_left, inner_right]) let tree = @src.Tree::new(root, rooted=true) let fitch_score = @src.fitch_parsimony_score(tree, aln) - let matrix = @src.parsimony_sankoff_dna_matrix(transition_cost=1.0, transversion_cost=2.0) + let matrix = @src.parsimony_sankoff_dna_matrix( + transition_cost=1.0, + transversion_cost=2.0, + ) let sankoff_score = @src.sankoff_parsimony_score(tree, aln, matrix) // All changes are A<->G (transitions), so Sankoff = Fitch here assert_eq(sankoff_score, fitch_score) diff --git a/test/moonbit/pathway_test.mbt b/test/moonbit/pathway_test.mbt index 4647ee6a..7c359eb6 100644 --- a/test/moonbit/pathway_test.mbt +++ b/test/moonbit/pathway_test.mbt @@ -11,7 +11,9 @@ test "Reaction_new" { reactants.push("glucose") let products : Array[String] = Array::new() products.push("g6p") - let reaction = @src.Reaction::new("r1", "Hexokinase", reactants, products, false) + let reaction = @src.Reaction::new( + "r1", "Hexokinase", reactants, products, false, + ) assert_eq(reaction.id, "r1") assert_eq(reaction.name, "Hexokinase") assert_eq(reaction.reactants.length(), 1) @@ -23,14 +25,16 @@ test "Reaction_new" { test "Pathway_new" { let species : Array[@src.Species] = Array::new() species.push(@src.Species::new("glucose", "Glucose")) - + let reactants : Array[String] = Array::new() reactants.push("glucose") let products : Array[String] = Array::new() products.push("g6p") let reactions : Array[@src.Reaction] = Array::new() - reactions.push(@src.Reaction::new("r1", "Hexokinase", reactants, products, false)) - + reactions.push( + @src.Reaction::new("r1", "Hexokinase", reactants, products, false), + ) + let pathway = @src.Pathway::new("test", "Test Pathway", species, reactions) assert_eq(pathway.id, "test") assert_eq(pathway.name, "Test Pathway") @@ -90,4 +94,4 @@ test "Reaction_to_string" { let reaction = @src.Reaction::new("r1", "Test", reactants, products, true) let str = @src.Reaction::to_string(reaction) assert_true(str.length() > 0) -} \ No newline at end of file +} diff --git a/test/moonbit/pcatools_test.mbt b/test/moonbit/pcatools_test.mbt index bacd7359..4d9cba19 100644 --- a/test/moonbit/pcatools_test.mbt +++ b/test/moonbit/pcatools_test.mbt @@ -10,12 +10,7 @@ test "biplot_options_new" { ///| test "pcatools_run_pca_simple_2d" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 4.0], - [4.0, 5.0], - ] + let data = [[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0]] let res = @src.pcatools_run_pca(data, 2, false) assert_eq(res.n_samples, 4) assert_eq(res.n_variables, 2) @@ -30,11 +25,7 @@ test "pcatools_run_pca_simple_2d" { ///| test "pcatools_run_pca_ncomponents_limit" { - let data = [ - [1.0, 2.0, 3.0, 4.0], - [2.0, 3.0, 4.0, 5.0], - [3.0, 4.0, 5.0, 6.0], - ] + let data = [[1.0, 2.0, 3.0, 4.0], [2.0, 3.0, 4.0, 5.0], [3.0, 4.0, 5.0, 6.0]] let res = @src.pcatools_run_pca(data, 10, false) // 3 samples, 4 variables => p=4, so limited to 4 assert_eq(res.n_components, 4) @@ -42,12 +33,7 @@ test "pcatools_run_pca_ncomponents_limit" { ///| test "pcatools_run_pca_scale_true" { - let data = [ - [1.0, 100.0], - [2.0, 200.0], - [3.0, 300.0], - [4.0, 400.0], - ] + let data = [[1.0, 100.0], [2.0, 200.0], [3.0, 300.0], [4.0, 400.0]] let res = @src.pcatools_run_pca(data, 2, true) assert_eq(res.used_scaling, true) assert_eq(res.scale.length(), 2) @@ -82,16 +68,10 @@ test "scree_plot_ascii_returns_string" { ///| test "pca_biplot_ascii_returns_string" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 5.0], - [4.0, 4.0], - [5.0, 6.0], - ] + let data = [[1.0, 2.0], [2.0, 3.0], [3.0, 5.0], [4.0, 4.0], [5.0, 6.0]] let res = @src.pcatools_run_pca(data, 2, false) let opts = @src.BiplotOptions::new() - let plot = @src.pca_biplot_ascii(res, opts=opts) + let plot = @src.pca_biplot_ascii(res, opts~) assert_true(plot.length() > 0) assert_true(plot.contains("PCA biplot")) assert_true(plot.contains("PC1")) @@ -116,7 +96,9 @@ test "find_pca_outliers_basic" { assert_true(out.indices.length() >= 1) let mut found7 = false for i in out.indices { - if i == 7 { found7 = true } + if i == 7 { + found7 = true + } } assert_true(found7) } @@ -124,8 +106,11 @@ test "find_pca_outliers_basic" { ///| test "find_pca_outliers_cutoff_positive" { let data = [ - [1.0, 1.0], [1.1, 1.0], [0.9, 1.0], - [1.0, 1.1], [1.0, 0.9], + [1.0, 1.0], + [1.1, 1.0], + [0.9, 1.0], + [1.0, 1.1], + [1.0, 0.9], [20.0, 20.0], ] let res = @src.pcatools_run_pca(data, 2, false) @@ -164,11 +149,7 @@ test "variable_correlations_shape" { ///| test "pcatools_summary_contains_keywords" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 4.0], - ] + let data = [[1.0, 2.0], [2.0, 3.0], [3.0, 4.0]] let res = @src.pcatools_run_pca(data, 2, false) let s = @src.pcatools_summary(res) assert_true(s.contains("PCAResult")) diff --git a/test/moonbit/pcd_test.mbt b/test/moonbit/pcd_test.mbt index f35de6d1..396fc638 100644 --- a/test/moonbit/pcd_test.mbt +++ b/test/moonbit/pcd_test.mbt @@ -12,6 +12,7 @@ test "pcd_spectrum_construction" { assert_eq(spec.num_peaks(), 0) } +///| test "pcd_spectrum_add_peak" { let spec = @src.PcdSpectrum::new(1) spec.add_peak(500.5, 10000.0) @@ -20,6 +21,7 @@ test "pcd_spectrum_add_peak" { assert_true(spec.total_intensity() > 0.0) } +///| test "pcd_spectrum_precursor" { let spec = @src.PcdSpectrum::new(1) spec.set_precursor_mz(Some(500.5)) @@ -38,12 +40,14 @@ test "pcd_spectrum_precursor" { // PcdFile Tests // ============================================================================ +///| test "pcd_file_construction" { let file = @src.PcdFile::new() assert_eq(file.num_spectra, 0) assert_eq(file.num_peaks, 0) } +///| test "pcd_file_add_spectrum" { let file = @src.PcdFile::new() let spec = @src.PcdSpectrum::new(1, rt=10.0) @@ -54,6 +58,7 @@ test "pcd_file_add_spectrum" { assert_eq(file.num_peaks, 1) } +///| test "pcd_file_get_spectrum" { let file = @src.PcdFile::new() let spec1 = @src.PcdSpectrum::new(1) @@ -74,12 +79,14 @@ test "pcd_file_get_spectrum" { // PCD Parsing Tests // ============================================================================ +///| test "pcd_parse_empty" { let file = @src.pcd_parse("") assert_eq(file.num_spectra, 0) assert_eq(file.num_peaks, 0) } +///| test "pcd_parse_sample" { let content = @src.pcd_sample() let file = @src.pcd_parse(content) @@ -87,6 +94,7 @@ test "pcd_parse_sample" { assert_true(file.num_peaks >= 1) } +///| test "pcd_parse_with_precursor" { let content = @src.pcd_sample() let file = @src.pcd_parse(content) @@ -97,6 +105,7 @@ test "pcd_parse_with_precursor" { // PCD Query Tests // ============================================================================ +///| test "pcd_total_peaks" { let file = @src.PcdFile::new() let spec1 = @src.PcdSpectrum::new(1) @@ -110,6 +119,7 @@ test "pcd_total_peaks" { assert_eq(@src.pcd_total_peaks(file), 3) } +///| test "pcd_bpc" { let file = @src.PcdFile::new() let spec1 = @src.PcdSpectrum::new(1, rt=10.0) @@ -125,6 +135,7 @@ test "pcd_bpc" { assert_eq(bpc.length(), 2) } +///| test "pcd_tic" { let file = @src.PcdFile::new() let spec1 = @src.PcdSpectrum::new(1, rt=10.0) @@ -139,6 +150,7 @@ test "pcd_tic" { assert_eq(tic.length(), 2) } +///| test "pcd_spectrum_by_mz" { let spec = @src.PcdSpectrum::new(1) spec.add_peak(500.0, 1000.0) @@ -152,6 +164,7 @@ test "pcd_spectrum_by_mz" { // PCD Serialization Tests // ============================================================================ +///| test "pcd_write_roundtrip" { let content = @src.pcd_sample() let file = @src.pcd_parse(content) @@ -164,6 +177,7 @@ test "pcd_write_roundtrip" { // PCD Summary Tests // ============================================================================ +///| test "pcd_summary" { let file = @src.PcdFile::new() let spec = @src.PcdSpectrum::new(1) diff --git a/test/moonbit/pdb_analysis_test.mbt b/test/moonbit/pdb_analysis_test.mbt index 376b8ef7..fe4c3521 100644 --- a/test/moonbit/pdb_analysis_test.mbt +++ b/test/moonbit/pdb_analysis_test.mbt @@ -184,9 +184,9 @@ test "pdb_analysis: ramachandran_quality" { test "pdb_analysis: get_hydrophobicity" { // Test some known values from Kyte-Doolittle scale assert_true((@src.get_hydrophobicity("ALA") - 1.8).abs() < 0.001) - assert_true((@src.get_hydrophobicity("ARG") - (-4.5)).abs() < 0.001) + assert_true((@src.get_hydrophobicity("ARG") - -4.5).abs() < 0.001) assert_true((@src.get_hydrophobicity("ILE") - 4.5).abs() < 0.001) - assert_true((@src.get_hydrophobicity("LYS") - (-3.9)).abs() < 0.001) + assert_true((@src.get_hydrophobicity("LYS") - -3.9).abs() < 0.001) assert_true((@src.get_hydrophobicity("PHE") - 2.8).abs() < 0.001) assert_true((@src.get_hydrophobicity("VAL") - 4.2).abs() < 0.001) // Unknown residue should return 0 diff --git a/test/moonbit/pdb_dice_test.mbt b/test/moonbit/pdb_dice_test.mbt index 6aa87729..62b94379 100644 --- a/test/moonbit/pdb_dice_test.mbt +++ b/test/moonbit/pdb_dice_test.mbt @@ -8,34 +8,131 @@ fn create_test_structure() -> @src.Structure { // Create a simple structure with 2 chains, each with 3 residues let atoms_a1 : Array[@src.Atom] = [ - @src.Atom::new(name="N", coord=@src.Vector3::new(0.0, 0.0, 0.0), resname="ALA", chainid='A', resseq=1), - @src.Atom::new(name="CA", coord=@src.Vector3::new(1.5, 0.0, 0.0), resname="ALA", chainid='A', resseq=1), - @src.Atom::new(name="C", coord=@src.Vector3::new(2.5, 1.0, 0.0), resname="ALA", chainid='A', resseq=1), - @src.Atom::new(name="O", coord=@src.Vector3::new(2.5, 2.0, 0.0), resname="ALA", chainid='A', resseq=1), + @src.Atom::new( + name="N", + coord=@src.Vector3::new(0.0, 0.0, 0.0), + resname="ALA", + chainid='A', + resseq=1, + ), + @src.Atom::new( + name="CA", + coord=@src.Vector3::new(1.5, 0.0, 0.0), + resname="ALA", + chainid='A', + resseq=1, + ), + @src.Atom::new( + name="C", + coord=@src.Vector3::new(2.5, 1.0, 0.0), + resname="ALA", + chainid='A', + resseq=1, + ), + @src.Atom::new( + name="O", + coord=@src.Vector3::new(2.5, 2.0, 0.0), + resname="ALA", + chainid='A', + resseq=1, + ), ] let atoms_a2 : Array[@src.Atom] = [ - @src.Atom::new(name="N", coord=@src.Vector3::new(3.5, 0.0, 0.0), resname="GLY", chainid='A', resseq=2), - @src.Atom::new(name="CA", coord=@src.Vector3::new(5.0, 0.0, 0.0), resname="GLY", chainid='A', resseq=2), + @src.Atom::new( + name="N", + coord=@src.Vector3::new(3.5, 0.0, 0.0), + resname="GLY", + chainid='A', + resseq=2, + ), + @src.Atom::new( + name="CA", + coord=@src.Vector3::new(5.0, 0.0, 0.0), + resname="GLY", + chainid='A', + resseq=2, + ), ] let atoms_a3 : Array[@src.Atom] = [ - @src.Atom::new(name="N", coord=@src.Vector3::new(6.0, 0.0, 0.0), resname="VAL", chainid='A', resseq=3), - @src.Atom::new(name="CA", coord=@src.Vector3::new(7.5, 0.0, 0.0), resname="VAL", chainid='A', resseq=3), + @src.Atom::new( + name="N", + coord=@src.Vector3::new(6.0, 0.0, 0.0), + resname="VAL", + chainid='A', + resseq=3, + ), + @src.Atom::new( + name="CA", + coord=@src.Vector3::new(7.5, 0.0, 0.0), + resname="VAL", + chainid='A', + resseq=3, + ), ] - let res_a1 = @src.Residue::new(resname="ALA", chainid='A', resseq=1, atoms=atoms_a1) - let res_a2 = @src.Residue::new(resname="GLY", chainid='A', resseq=2, atoms=atoms_a2) - let res_a3 = @src.Residue::new(resname="VAL", chainid='A', resseq=3, atoms=atoms_a3) + let res_a1 = @src.Residue::new( + resname="ALA", + chainid='A', + resseq=1, + atoms=atoms_a1, + ) + let res_a2 = @src.Residue::new( + resname="GLY", + chainid='A', + resseq=2, + atoms=atoms_a2, + ) + let res_a3 = @src.Residue::new( + resname="VAL", + chainid='A', + resseq=3, + atoms=atoms_a3, + ) let chain_a = @src.Chain::new(id='A', residues=[res_a1, res_a2, res_a3]) let atoms_b1 : Array[@src.Atom] = [ - @src.Atom::new(name="N", coord=@src.Vector3::new(0.0, 5.0, 0.0), resname="SER", chainid='B', resseq=10), - @src.Atom::new(name="CA", coord=@src.Vector3::new(1.5, 5.0, 0.0), resname="SER", chainid='B', resseq=10), + @src.Atom::new( + name="N", + coord=@src.Vector3::new(0.0, 5.0, 0.0), + resname="SER", + chainid='B', + resseq=10, + ), + @src.Atom::new( + name="CA", + coord=@src.Vector3::new(1.5, 5.0, 0.0), + resname="SER", + chainid='B', + resseq=10, + ), ] let atoms_b2 : Array[@src.Atom] = [ - @src.Atom::new(name="N", coord=@src.Vector3::new(3.5, 5.0, 0.0), resname="THR", chainid='B', resseq=11), - @src.Atom::new(name="CA", coord=@src.Vector3::new(5.0, 5.0, 0.0), resname="THR", chainid='B', resseq=11), + @src.Atom::new( + name="N", + coord=@src.Vector3::new(3.5, 5.0, 0.0), + resname="THR", + chainid='B', + resseq=11, + ), + @src.Atom::new( + name="CA", + coord=@src.Vector3::new(5.0, 5.0, 0.0), + resname="THR", + chainid='B', + resseq=11, + ), ] - let res_b1 = @src.Residue::new(resname="SER", chainid='B', resseq=10, atoms=atoms_b1) - let res_b2 = @src.Residue::new(resname="THR", chainid='B', resseq=11, atoms=atoms_b2) + let res_b1 = @src.Residue::new( + resname="SER", + chainid='B', + resseq=10, + atoms=atoms_b1, + ) + let res_b2 = @src.Residue::new( + resname="THR", + chainid='B', + resseq=11, + atoms=atoms_b2, + ) let chain_b = @src.Chain::new(id='B', residues=[res_b1, res_b2]) let model = @src.Model::new(id=0, chains=[chain_a, chain_b]) @@ -144,10 +241,7 @@ test "extract_residue_range_chain_b" { ///| test "extract_residues_by_ids" { let structure = create_test_structure() - let ids = [ - @src.ResidueId::new('A', 1), - @src.ResidueId::new('B', 10), - ] + let ids = [@src.ResidueId::new('A', 1), @src.ResidueId::new('B', 10)] let result = @src.extract_residues(structure, ids) // Should have 2 chains, each with 1 residue assert_eq(result.models[0].chains.length(), 2) diff --git a/test/moonbit/pdb_header_test.mbt b/test/moonbit/pdb_header_test.mbt index 966ce345..edf9fe5b 100644 --- a/test/moonbit/pdb_header_test.mbt +++ b/test/moonbit/pdb_header_test.mbt @@ -69,9 +69,7 @@ test "dbref_entry_creation" { ///| test "parse_title_record_single_line" { - let lines = [ - "TITLE Crystal structure of a protein", - ] + let lines = ["TITLE Crystal structure of a protein"] let title = @src.parse_title_record(lines, 0) assert_true(title.contains("Crystal structure")) } @@ -79,8 +77,7 @@ test "parse_title_record_single_line" { ///| test "parse_title_record_multi_line" { let lines = [ - "TITLE Crystal structure of a protein", - "TITLE in complex with ligand", + "TITLE Crystal structure of a protein", "TITLE in complex with ligand", ] let title = @src.parse_title_record(lines, 0) assert_true(title.contains("Crystal structure")) @@ -126,10 +123,8 @@ test "parse_rfactor_record_no_keyword" { ///| test "extract_chain_ids" { - let compound = @src.CompoundInfo::new( - chain_ids=["A", "B", "C"], - ) - let header = @src.PDBHeader::new(compound=compound) + let compound = @src.CompoundInfo::new(chain_ids=["A", "B", "C"]) + let header = @src.PDBHeader::new(compound~) let chains = @src.extract_chain_ids(header) assert_eq(chains.length(), 3) assert_eq(chains[0], "A") @@ -155,8 +150,7 @@ test "parse_pdb_header_empty" { ///| test "parse_pdb_header_missing_records" { - let pdb_text = - "HEADER VIRUS 01-JAN-20 1ABC\n" + let pdb_text = "HEADER VIRUS 01-JAN-20 1ABC\n" let header = @src.parse_pdb_header(pdb_text) assert_eq(header.title, "") assert_eq(header.compound.molecule_id, "") @@ -172,8 +166,7 @@ test "parse_pdb_header_missing_records" { ///| test "parse_pdb_header_lines" { let lines = [ - "HEADER VIRUS 01-JAN-20 1ABC", - "TITLE Crystal structure", + "HEADER VIRUS 01-JAN-20 1ABC", "TITLE Crystal structure", ] let header = @src.parse_pdb_header_lines(lines) assert_true(header.title.length() > 0) diff --git a/test/moonbit/pdb_list_test.mbt b/test/moonbit/pdb_list_test.mbt index a3518738..ef753b2e 100644 --- a/test/moonbit/pdb_list_test.mbt +++ b/test/moonbit/pdb_list_test.mbt @@ -1,31 +1,34 @@ ///| /// Tests for PDBList module. - test "PDBList creation" { let pdblist = @src.create_example_pdblist() assert_eq(pdblist.pdb_dir, "/data/pdb") } +///| test "PDBList download_pdb" { let pdblist = @src.PDBList::new("/data/pdb") let file = pdblist.download_pdb("1XYZ", "pdb") assert_true(file.contains("1XYZ")) } +///| test "PDBList get_pdb_file" { let pdblist = @src.PDBList::new("/data/pdb") let file = pdblist.get_pdb_file("1XYZ", "pdb", false) assert_true(file.contains("1XYZ")) } +///| test "PDBList get_pdb_file obsolete" { let pdblist = @src.PDBList::new("/data/pdb") let file = pdblist.get_pdb_file("1XYZ", "pdb", true) assert_true(file.contains("obsolete")) } +///| test "PDBList resolve_obsolete" { let pdblist = @src.PDBList::new("/data/pdb") let resolved = pdblist.resolve_obsolete("1XYZ") assert_eq(resolved, "2XYZ") -} \ No newline at end of file +} diff --git a/test/moonbit/pdb_packing_test.mbt b/test/moonbit/pdb_packing_test.mbt index 635448ff..35c2d227 100644 --- a/test/moonbit/pdb_packing_test.mbt +++ b/test/moonbit/pdb_packing_test.mbt @@ -99,7 +99,11 @@ test "packing_result_creation" { ///| test "packing_result_get_density" { - let result = @src.PackingResult::new(residue_name="GLU", residue_seq=5, density=3.7) + let result = @src.PackingResult::new( + residue_name="GLU", + residue_seq=5, + density=3.7, + ) assert_eq(result.get_density(), 3.7) } @@ -321,12 +325,7 @@ test "calculate_packing_sasa_empty" { ///| test "calculate_packing_sasa_single_atom" { let atoms : Array[@src.PackingAtom] = [ - @src.PackingAtom::new( - x=0.0, - y=0.0, - z=0.0, - vdw_radius=1.7, - ), + @src.PackingAtom::new(x=0.0, y=0.0, z=0.0, vdw_radius=1.7), ] let sasa = @src.calculate_packing_sasa(atoms, probe_radius=1.4, n_points=50) assert_eq(sasa > 0.0, true) @@ -349,28 +348,44 @@ test "calculate_packing_sasa_lower_probe" { ///| test "normalize_packing_density_below_threshold" { - let result = @src.PackingResult::new(residue_name="ALA", residue_seq=1, density=0.5) + let result = @src.PackingResult::new( + residue_name="ALA", + residue_seq=1, + density=0.5, + ) let normalized = @src.normalize_packing_density(result, threshold=2.0) assert_eq(normalized.density, 0.25) } ///| test "normalize_packing_density_above_threshold" { - let result = @src.PackingResult::new(residue_name="ALA", residue_seq=1, density=3.0) + let result = @src.PackingResult::new( + residue_name="ALA", + residue_seq=1, + density=3.0, + ) let normalized = @src.normalize_packing_density(result, threshold=2.0) assert_eq(normalized.density, 1.0) } ///| test "normalize_packing_density_at_threshold" { - let result = @src.PackingResult::new(residue_name="ALA", residue_seq=1, density=2.0) + let result = @src.PackingResult::new( + residue_name="ALA", + residue_seq=1, + density=2.0, + ) let normalized = @src.normalize_packing_density(result, threshold=2.0) assert_eq(normalized.density, 1.0) } ///| test "normalize_packing_density_zero_threshold" { - let result = @src.PackingResult::new(residue_name="ALA", residue_seq=1, density=1.5) + let result = @src.PackingResult::new( + residue_name="ALA", + residue_seq=1, + density=1.5, + ) let normalized = @src.normalize_packing_density(result, threshold=0.0) assert_eq(normalized.density, 1.5) } @@ -378,9 +393,24 @@ test "normalize_packing_density_zero_threshold" { ///| test "identify_low_packing_basic" { let results : Array[@src.PackingResult] = [ - @src.PackingResult::new(residue_name="ALA", residue_seq=1, chain_id='A', density=0.3), - @src.PackingResult::new(residue_name="GLY", residue_seq=2, chain_id='A', density=1.5), - @src.PackingResult::new(residue_name="VAL", residue_seq=3, chain_id='A', density=0.4), + @src.PackingResult::new( + residue_name="ALA", + residue_seq=1, + chain_id='A', + density=0.3, + ), + @src.PackingResult::new( + residue_name="GLY", + residue_seq=2, + chain_id='A', + density=1.5, + ), + @src.PackingResult::new( + residue_name="VAL", + residue_seq=3, + chain_id='A', + density=0.4, + ), ] let analysis = @src.PackingAnalysisResult::new(results~, n_residues=3) let low = @src.identify_low_packing(analysis, cutoff=0.5) @@ -412,7 +442,7 @@ test "identify_low_packing_all_below" { ///| test "sphere_volume_calculation" { let vol = @src.sphere_volume(2.0) - let expected = (4.0 / 3.0) * 3.14159265358979323846 * 8.0 + let expected = 4.0 / 3.0 * 3.14159265358979323846 * 8.0 assert_eq((vol - expected).abs() < 0.001, true) } @@ -445,7 +475,10 @@ test "sphere_volume_radius_roundtrip" { ///| test "calculate_packing_efficiency_basic" { let atoms = @src.create_demo_packing_atoms() - let efficiency = @src.calculate_packing_efficiency(atoms, container_radius=10.0) + let efficiency = @src.calculate_packing_efficiency( + atoms, + container_radius=10.0, + ) assert_eq(efficiency > 0.0, true) } @@ -460,7 +493,10 @@ test "calculate_packing_efficiency_empty" { test "calculate_packing_efficiency_large_container" { let atoms = @src.create_demo_packing_atoms() let eff_small = @src.calculate_packing_efficiency(atoms, container_radius=5.0) - let eff_large = @src.calculate_packing_efficiency(atoms, container_radius=50.0) + let eff_large = @src.calculate_packing_efficiency( + atoms, + container_radius=50.0, + ) assert_eq(eff_small > eff_large, true) } @@ -524,7 +560,11 @@ test "packing_density_with_demo_atoms" { ///| test "packing_analysis_with_demo_atoms" { let atoms = @src.create_demo_packing_atoms() - let analysis = @src.packing_density_per_residue(atoms, radius=1.4, n_points=20) + let analysis = @src.packing_density_per_residue( + atoms, + radius=1.4, + n_points=20, + ) assert_eq(analysis.n_residues, 3) assert_eq(analysis.mean_density > 0.0, true) assert_eq(analysis.n_buried + analysis.n_exposed, 3) @@ -540,7 +580,11 @@ test "sasa_with_demo_atoms" { ///| test "low_packing_identification_with_analysis" { let atoms = @src.create_demo_packing_atoms() - let analysis = @src.packing_density_per_residue(atoms, radius=1.4, n_points=20) + let analysis = @src.packing_density_per_residue( + atoms, + radius=1.4, + n_points=20, + ) let low = @src.identify_low_packing(analysis, cutoff=0.0) assert_eq(low.length() >= 0, true) } @@ -582,4 +626,4 @@ test "packing_result_default_creation" { assert_eq(result.density, 0.0) assert_eq(result.n_contacting_atoms, 0) assert_eq(result.n_shell_points, 0) -} \ No newline at end of file +} diff --git a/test/moonbit/pdb_seqio_test.mbt b/test/moonbit/pdb_seqio_test.mbt index abaca152..4d7eb1d0 100644 --- a/test/moonbit/pdb_seqio_test.mbt +++ b/test/moonbit/pdb_seqio_test.mbt @@ -165,7 +165,8 @@ test "pdb_atom_parser_basic" { ///| test "pdb_atom_parser_with_pdb_id" { let header = "HEADER PROTEIN" + " ".repeat(33) + "01-JAN-24 1XXX" - let pdb_text = header + "\nATOM 1 N ALA A 1 10.000 20.000 30.000 1.00 20.00 N \nATOM 2 N GLY A 2 12.000 22.000 32.000 1.00 20.00 N \nTER 3 GLY A 2\nEND\n" + let pdb_text = header + + "\nATOM 1 N ALA A 1 10.000 20.000 30.000 1.00 20.00 N \nATOM 2 N GLY A 2 12.000 22.000 32.000 1.00 20.00 N \nTER 3 GLY A 2\nEND\n" let records = @src.pdb_atom_parser(pdb_text) assert_eq(records.length(), 1) assert_eq(records[0].seq.to_string(), "AG") @@ -216,11 +217,7 @@ test "pdb_write_pdb_seqrecords_round_trip" { ///| test "pdb_write_pdb_seqrecords_basic" { - let record = @src.SeqRecord::new( - @src.Seq::new("AGVL"), - id="A", - name="A", - ) + let record = @src.SeqRecord::new(@src.Seq::new("AGVL"), id="A", name="A") let output = @src.write_pdb_seqrecords([record]) assert_true(output.contains("SEQRES")) assert_true(output.contains("ALA")) @@ -231,16 +228,8 @@ test "pdb_write_pdb_seqrecords_basic" { ///| test "pdb_write_pdb_seqrecords_multiple_records" { - let r1 = @src.SeqRecord::new( - @src.Seq::new("AG"), - id="A", - name="A", - ) - let r2 = @src.SeqRecord::new( - @src.Seq::new("VL"), - id="B", - name="B", - ) + let r1 = @src.SeqRecord::new(@src.Seq::new("AG"), id="A", name="A") + let r2 = @src.SeqRecord::new(@src.Seq::new("VL"), id="B", name="B") let output = @src.write_pdb_seqrecords([r1, r2]) assert_true(output.contains("SEQRES")) assert_true(output.contains("ALA")) @@ -257,11 +246,7 @@ test "pdb_write_pdb_seqrecords_empty" { ///| test "pdb_write_pdb_seqrecords_unknown_residue" { - let record = @src.SeqRecord::new( - @src.Seq::new("AXG"), - id="A", - name="A", - ) + let record = @src.SeqRecord::new(@src.Seq::new("AXG"), id="A", name="A") let output = @src.write_pdb_seqrecords([record]) assert_true(output.contains("SEQRES")) assert_true(output.contains("ALA")) diff --git a/test/moonbit/pdb_vectors_test.mbt b/test/moonbit/pdb_vectors_test.mbt index 1098bd27..4a5e894b 100644 --- a/test/moonbit/pdb_vectors_test.mbt +++ b/test/moonbit/pdb_vectors_test.mbt @@ -112,7 +112,7 @@ test "Vector3::dot" { test "Vector3::dot orthogonal" { let v1 = @src.Vector3::new(1.0, 0.0, 0.0) let v2 = @src.Vector3::new(0.0, 1.0, 0.0) - assert_true((v1.dot(v2)).abs() < 1.0e-10) + assert_true(v1.dot(v2).abs() < 1.0e-10) } ///| @@ -236,8 +236,8 @@ test "Vector3::project_to_vector" { let target = @src.Vector3::new(1.0, 0.0, 0.0) let proj = v.project_to_vector(target) assert_true((proj.get_x() - 1.0).abs() < 1.0e-10) - assert_true((proj.get_y()).abs() < 1.0e-10) - assert_true((proj.get_z()).abs() < 1.0e-10) + assert_true(proj.get_y().abs() < 1.0e-10) + assert_true(proj.get_z().abs() < 1.0e-10) } ///| @@ -247,7 +247,7 @@ test "Vector3::project_to_plane" { let proj = v.project_to_plane(normal) assert_true((proj.get_x() - 1.0).abs() < 1.0e-10) assert_true((proj.get_y() - 2.0).abs() < 1.0e-10) - assert_true((proj.get_z()).abs() < 1.0e-10) + assert_true(proj.get_z().abs() < 1.0e-10) } ///| @@ -263,9 +263,15 @@ test "RotationMatrix3::identity" { ///| test "RotationMatrix3::transpose" { let m = @src.RotationMatrix3::new( - m00=1.0, m01=2.0, m02=3.0, - m10=4.0, m11=5.0, m12=6.0, - m20=7.0, m21=8.0, m22=9.0, + m00=1.0, + m01=2.0, + m02=3.0, + m10=4.0, + m11=5.0, + m12=6.0, + m20=7.0, + m21=8.0, + m22=9.0, ) let t = m.transpose() assert_eq(t.get(0, 1), 4.0) @@ -277,9 +283,15 @@ test "RotationMatrix3::transpose" { ///| test "RotationMatrix3::multiply identity" { let m = @src.RotationMatrix3::new( - m00=1.0, m01=2.0, m02=3.0, - m10=4.0, m11=5.0, m12=6.0, - m20=7.0, m21=8.0, m22=9.0, + m00=1.0, + m01=2.0, + m02=3.0, + m10=4.0, + m11=5.0, + m12=6.0, + m20=7.0, + m21=8.0, + m22=9.0, ) let identity = @src.RotationMatrix3::identity() let result = m.multiply(identity) @@ -293,9 +305,9 @@ test "RotationMatrix3::transform" { let rot = @src.RotationMatrix3::rotation_z(@math.PI / 2.0) let v = @src.Vector3::new(1.0, 0.0, 0.0) let result = rot.transform(v) - assert_true((result.get_x()).abs() < 1.0e-10) + assert_true(result.get_x().abs() < 1.0e-10) assert_true((result.get_y() - 1.0).abs() < 1.0e-10) - assert_true((result.get_z()).abs() < 1.0e-10) + assert_true(result.get_z().abs() < 1.0e-10) } ///| @@ -303,8 +315,8 @@ test "RotationMatrix3::rotation_x" { let rot = @src.RotationMatrix3::rotation_x(@math.PI / 2.0) let v = @src.Vector3::new(0.0, 1.0, 0.0) let result = rot.transform(v) - assert_true((result.get_x()).abs() < 1.0e-10) - assert_true((result.get_y()).abs() < 1.0e-10) + assert_true(result.get_x().abs() < 1.0e-10) + assert_true(result.get_y().abs() < 1.0e-10) assert_true((result.get_z() - 1.0).abs() < 1.0e-10) } @@ -314,8 +326,8 @@ test "RotationMatrix3::rotation_y" { let v = @src.Vector3::new(0.0, 0.0, 1.0) let result = rot.transform(v) assert_true((result.get_x() - 1.0).abs() < 1.0e-10) - assert_true((result.get_y()).abs() < 1.0e-10) - assert_true((result.get_z()).abs() < 1.0e-10) + assert_true(result.get_y().abs() < 1.0e-10) + assert_true(result.get_z().abs() < 1.0e-10) } ///| @@ -323,9 +335,9 @@ test "RotationMatrix3::rotation_z" { let rot = @src.RotationMatrix3::rotation_z(@math.PI / 2.0) let v = @src.Vector3::new(1.0, 0.0, 0.0) let result = rot.transform(v) - assert_true((result.get_x()).abs() < 1.0e-10) + assert_true(result.get_x().abs() < 1.0e-10) assert_true((result.get_y() - 1.0).abs() < 1.0e-10) - assert_true((result.get_z()).abs() < 1.0e-10) + assert_true(result.get_z().abs() < 1.0e-10) } ///| @@ -334,9 +346,9 @@ test "RotationMatrix3::rotation_axis_angle" { let rot = @src.RotationMatrix3::rotation_axis_angle(axis, @math.PI / 2.0) let v = @src.Vector3::new(1.0, 0.0, 0.0) let result = rot.transform(v) - assert_true((result.get_x()).abs() < 1.0e-10) + assert_true(result.get_x().abs() < 1.0e-10) assert_true((result.get_y() - 1.0).abs() < 1.0e-10) - assert_true((result.get_z()).abs() < 1.0e-10) + assert_true(result.get_z().abs() < 1.0e-10) } ///| @@ -371,8 +383,8 @@ test "RotationMatrix3::inverse" { assert_true((product.get(0, 0) - 1.0).abs() < 1.0e-10) assert_true((product.get(1, 1) - 1.0).abs() < 1.0e-10) assert_true((product.get(2, 2) - 1.0).abs() < 1.0e-10) - assert_true((product.get(0, 1)).abs() < 1.0e-10) - assert_true((product.get(1, 0)).abs() < 1.0e-10) + assert_true(product.get(0, 1).abs() < 1.0e-10) + assert_true(product.get(1, 0).abs() < 1.0e-10) } ///| @@ -437,7 +449,7 @@ test "vector_rmsd identical" { @src.Vector3::new(4.0, 5.0, 6.0), ] let rmsd = @src.vector_rmsd(set_a, set_b) - assert_true((rmsd).abs() < 1.0e-10) + assert_true(rmsd.abs() < 1.0e-10) } ///| @@ -445,7 +457,7 @@ test "vector_rmsd empty" { let set_a : Array[@src.Vector3] = [] let set_b : Array[@src.Vector3] = [] let rmsd = @src.vector_rmsd(set_a, set_b) - assert_true((rmsd).abs() < 1.0e-10) + assert_true(rmsd.abs() < 1.0e-10) } ///| @@ -496,7 +508,7 @@ test "vector_apply_transform" { let trans = @src.Vector3::new(0.0, 0.0, 0.0) let result = @src.vector_apply_transform(vectors, rot, trans) assert_eq(result.length(), 1) - assert_true((result[0].get_x()).abs() < 1.0e-10) + assert_true(result[0].get_x().abs() < 1.0e-10) assert_true((result[0].get_y() - 1.0).abs() < 1.0e-10) } diff --git a/test/moonbit/peak_calling_test.mbt b/test/moonbit/peak_calling_test.mbt index 98c8d09a..3a637ec6 100644 --- a/test/moonbit/peak_calling_test.mbt +++ b/test/moonbit/peak_calling_test.mbt @@ -113,10 +113,7 @@ test "peak_calling_params_new_defaults_when_omitted" { ///| test "peak_calling_params_partial_overrides" { // Override only some args; others should default. - let params = @src.PeakCallingParams::new( - window_size=250, - fdr_threshold=0.01, - ) + let params = @src.PeakCallingParams::new(window_size=250, fdr_threshold=0.01) assert_eq(params.window_size, 250) assert_eq(params.step_size, 100) assert_eq(params.local_lambda_size, 10000) @@ -167,7 +164,9 @@ test "peak_calling_estimate_local_lambda_basic" { // Place 20 control reads uniformly in [0, 2000]. let mut i = 0 while i < 20 { - control.push(@src.ChipSeqRead::new(chr="chr1", position=i * 100, strand="+")) + control.push( + @src.ChipSeqRead::new(chr="chr1", position=i * 100, strand="+"), + ) i = i + 1 } // Window of 2000 bp centered at 1000 = [0, 2000) should have 20 reads. @@ -185,9 +184,7 @@ test "peak_calling_estimate_local_lambda_empty_control" { ///| test "peak_calling_estimate_local_lambda_off_chromosome" { - let control = [ - @src.ChipSeqRead::new(chr="chr1", position=500, strand="+"), - ] + let control = [@src.ChipSeqRead::new(chr="chr1", position=500, strand="+")] let rate = @src.estimate_local_lambda(control, "chr2", 500, 1000) assert_eq(rate, 0.0) } @@ -273,12 +270,24 @@ test "peak_calling_fold_enrichment_zero_observed_zero_expected" { test "peak_calling_merge_peaks_overlapping" { let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=2000, summit=1500, - read_count=20, control_count=2, fold_enrichment=10.0, p_value=1.0e-8, + chr="chr1", + start=1000, + end=2000, + summit=1500, + read_count=20, + control_count=2, + fold_enrichment=10.0, + p_value=1.0e-8, ), @src.CandidatePeak::new( - chr="chr1", start=1800, end=2500, summit=2000, - read_count=15, control_count=1, fold_enrichment=15.0, p_value=1.0e-7, + chr="chr1", + start=1800, + end=2500, + summit=2000, + read_count=15, + control_count=1, + fold_enrichment=15.0, + p_value=1.0e-7, ), ] let merged = @src.merge_peaks(peaks, 0) @@ -297,12 +306,24 @@ test "peak_calling_merge_peaks_overlapping" { test "peak_calling_merge_peaks_adjacent_within_gap" { let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=1500, summit=1250, - read_count=10, control_count=1, fold_enrichment=10.0, p_value=0.001, + chr="chr1", + start=1000, + end=1500, + summit=1250, + read_count=10, + control_count=1, + fold_enrichment=10.0, + p_value=0.001, ), @src.CandidatePeak::new( - chr="chr1", start=1700, end=2200, summit=2000, - read_count=12, control_count=2, fold_enrichment=6.0, p_value=0.0001, + chr="chr1", + start=1700, + end=2200, + summit=2000, + read_count=12, + control_count=2, + fold_enrichment=6.0, + p_value=0.0001, ), ] // Gap is 200bp; with max_gap=300, they should merge. @@ -318,12 +339,24 @@ test "peak_calling_merge_peaks_adjacent_within_gap" { test "peak_calling_merge_peaks_non_overlapping_different_chromosomes" { let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=2000, summit=1500, - read_count=20, control_count=2, fold_enrichment=10.0, p_value=1.0e-8, + chr="chr1", + start=1000, + end=2000, + summit=1500, + read_count=20, + control_count=2, + fold_enrichment=10.0, + p_value=1.0e-8, ), @src.CandidatePeak::new( - chr="chr2", start=1000, end=2000, summit=1500, - read_count=20, control_count=2, fold_enrichment=10.0, p_value=1.0e-8, + chr="chr2", + start=1000, + end=2000, + summit=1500, + read_count=20, + control_count=2, + fold_enrichment=10.0, + p_value=1.0e-8, ), ] let merged = @src.merge_peaks(peaks, 1000) @@ -334,12 +367,24 @@ test "peak_calling_merge_peaks_non_overlapping_different_chromosomes" { test "peak_calling_merge_peaks_far_apart" { let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=1500, summit=1250, - read_count=10, control_count=1, fold_enrichment=10.0, p_value=0.001, + chr="chr1", + start=1000, + end=1500, + summit=1250, + read_count=10, + control_count=1, + fold_enrichment=10.0, + p_value=0.001, ), @src.CandidatePeak::new( - chr="chr1", start=10000, end=10500, summit=10250, - read_count=10, control_count=1, fold_enrichment=10.0, p_value=0.001, + chr="chr1", + start=10000, + end=10500, + summit=10250, + read_count=10, + control_count=1, + fold_enrichment=10.0, + p_value=0.001, ), ] let merged = @src.merge_peaks(peaks, 100) @@ -357,8 +402,14 @@ test "peak_calling_merge_peaks_empty" { test "peak_calling_merge_peaks_single_peak" { let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=2000, summit=1500, - read_count=20, control_count=2, fold_enrichment=10.0, p_value=1.0e-8, + chr="chr1", + start=1000, + end=2000, + summit=1500, + read_count=20, + control_count=2, + fold_enrichment=10.0, + p_value=1.0e-8, ), ] let merged = @src.merge_peaks(peaks, 100) @@ -371,12 +422,24 @@ test "peak_calling_merge_peaks_unsorted_input" { // Input peaks in reverse order; merge_peaks should sort internally. let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=5000, end=5500, summit=5200, - read_count=15, control_count=1, fold_enrichment=15.0, p_value=1.0e-7, + chr="chr1", + start=5000, + end=5500, + summit=5200, + read_count=15, + control_count=1, + fold_enrichment=15.0, + p_value=1.0e-7, ), @src.CandidatePeak::new( - chr="chr1", start=1000, end=1500, summit=1250, - read_count=20, control_count=2, fold_enrichment=10.0, p_value=1.0e-8, + chr="chr1", + start=1000, + end=1500, + summit=1250, + read_count=20, + control_count=2, + fold_enrichment=10.0, + p_value=1.0e-8, ), ] let merged = @src.merge_peaks(peaks, 100) @@ -391,16 +454,34 @@ test "peak_calling_apply_fdr_marks_significant" { // Three peaks with very small p-values; all should be marked significant. let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=1500, summit=1250, - read_count=50, control_count=2, fold_enrichment=25.0, p_value=1.0e-10, + chr="chr1", + start=1000, + end=1500, + summit=1250, + read_count=50, + control_count=2, + fold_enrichment=25.0, + p_value=1.0e-10, ), @src.CandidatePeak::new( - chr="chr1", start=2000, end=2500, summit=2250, - read_count=40, control_count=2, fold_enrichment=20.0, p_value=1.0e-8, + chr="chr1", + start=2000, + end=2500, + summit=2250, + read_count=40, + control_count=2, + fold_enrichment=20.0, + p_value=1.0e-8, ), @src.CandidatePeak::new( - chr="chr1", start=3000, end=3500, summit=3250, - read_count=30, control_count=2, fold_enrichment=15.0, p_value=1.0e-6, + chr="chr1", + start=3000, + end=3500, + summit=3250, + read_count=30, + control_count=2, + fold_enrichment=15.0, + p_value=1.0e-6, ), ] let result = @src.apply_fdr(peaks, 0.05) @@ -415,12 +496,24 @@ test "peak_calling_apply_fdr_filters_large_pvalues" { // Mix of significant and non-significant peaks. let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=1500, summit=1250, - read_count=50, control_count=2, fold_enrichment=25.0, p_value=1.0e-10, + chr="chr1", + start=1000, + end=1500, + summit=1250, + read_count=50, + control_count=2, + fold_enrichment=25.0, + p_value=1.0e-10, ), @src.CandidatePeak::new( - chr="chr1", start=2000, end=2500, summit=2250, - read_count=5, control_count=2, fold_enrichment=2.5, p_value=0.4, + chr="chr1", + start=2000, + end=2500, + summit=2250, + read_count=5, + control_count=2, + fold_enrichment=2.5, + p_value=0.4, ), ] let result = @src.apply_fdr(peaks, 0.05) @@ -468,7 +561,13 @@ test "peak_calling_apply_fdr_monotonic" { pairs.push((p.p_value, p.fdr)) } pairs.sort_by(fn(a : (Double, Double), b : (Double, Double)) -> Int { - if a.0 < b.0 { -1 } else if a.0 > b.0 { 1 } else { 0 } + if a.0 < b.0 { + -1 + } else if a.0 > b.0 { + 1 + } else { + 0 + } }) // Adjusted p-values should be non-decreasing with rank. let mut k = 0 @@ -487,16 +586,34 @@ test "peak_calling_filter_peaks_thresholds" { ) let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=1500, summit=1250, - read_count=50, control_count=2, fold_enrichment=25.0, p_value=1.0e-10, + chr="chr1", + start=1000, + end=1500, + summit=1250, + read_count=50, + control_count=2, + fold_enrichment=25.0, + p_value=1.0e-10, ), @src.CandidatePeak::new( - chr="chr1", start=2000, end=2500, summit=2250, - read_count=5, control_count=2, fold_enrichment=2.5, p_value=1.0e-3, + chr="chr1", + start=2000, + end=2500, + summit=2250, + read_count=5, + control_count=2, + fold_enrichment=2.5, + p_value=1.0e-3, ), @src.CandidatePeak::new( - chr="chr1", start=3000, end=3500, summit=3250, - read_count=3, control_count=2, fold_enrichment=1.5, p_value=1.0e-10, + chr="chr1", + start=3000, + end=3500, + summit=3250, + read_count=3, + control_count=2, + fold_enrichment=1.5, + p_value=1.0e-10, ), ] // Set FDR and significant flags first. @@ -603,9 +720,7 @@ test "peak_calling_no_control" { ///| test "peak_calling_single_read" { - let treatment = [ - @src.ChipSeqRead::new(chr="chr1", position=1000, strand="+"), - ] + let treatment = [@src.ChipSeqRead::new(chr="chr1", position=1000, strand="+")] let control : Array[@src.ChipSeqRead] = [] let params = @src.PeakCallingParams::default() let peaks = @src.call_peaks(treatment, control, params) @@ -654,12 +769,24 @@ test "peak_calling_summary_empty" { test "peak_calling_summary_with_peaks" { let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=2000, summit=1500, - read_count=42, control_count=5, fold_enrichment=8.4, p_value=1.0e-10, + chr="chr1", + start=1000, + end=2000, + summit=1500, + read_count=42, + control_count=5, + fold_enrichment=8.4, + p_value=1.0e-10, ), @src.CandidatePeak::new( - chr="chr1", start=3000, end=4000, summit=3500, - read_count=20, control_count=2, fold_enrichment=10.0, p_value=1.0e-8, + chr="chr1", + start=3000, + end=4000, + summit=3500, + read_count=20, + control_count=2, + fold_enrichment=10.0, + p_value=1.0e-8, ), ] let with_fdr = @src.apply_fdr(peaks, 0.05) @@ -673,12 +800,24 @@ test "peak_calling_summary_with_peaks" { test "peak_calling_summary_includes_significant_count" { let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=2000, summit=1500, - read_count=42, control_count=5, fold_enrichment=8.4, p_value=1.0e-10, + chr="chr1", + start=1000, + end=2000, + summit=1500, + read_count=42, + control_count=5, + fold_enrichment=8.4, + p_value=1.0e-10, ), @src.CandidatePeak::new( - chr="chr1", start=3000, end=4000, summit=3500, - read_count=2, control_count=2, fold_enrichment=1.0, p_value=0.5, + chr="chr1", + start=3000, + end=4000, + summit=3500, + read_count=2, + control_count=2, + fold_enrichment=1.0, + p_value=0.5, ), ] let with_fdr = @src.apply_fdr(peaks, 0.05) diff --git a/test/moonbit/phd_test.mbt b/test/moonbit/phd_test.mbt index 4104e7a5..e122a2b0 100644 --- a/test/moonbit/phd_test.mbt +++ b/test/moonbit/phd_test.mbt @@ -12,10 +12,10 @@ test "phd_base_creation" { assert_eq(b.peak_position(), 1) } +///| test "phd_comment_creation" { let c = @src.PhdComment::new( - "read.ab1", "0.020425.c", "/etc/phred.dat", - 0, 1000, 0, 10, 0.05, "term", "big", + "read.ab1", "0.020425.c", "/etc/phred.dat", 0, 1000, 0, 10, 0.05, "term", "big", ) assert_eq(c.chromat_file(), "read.ab1") assert_eq(c.phred_version(), "0.020425.c") @@ -29,6 +29,7 @@ test "phd_comment_creation" { assert_eq(c.dye(), "big") } +///| test "phd_read_creation_and_sequence" { let bases = [ @src.PhdBase::new("A", 35, 1), @@ -36,8 +37,7 @@ test "phd_read_creation_and_sequence" { @src.PhdBase::new("G", 45, 3), ] let comment = @src.PhdComment::new( - "read.ab1", "0.020425.c", "/etc/phred.dat", - 0, 1000, 0, 3, 0.05, "term", "big", + "read.ab1", "0.020425.c", "/etc/phred.dat", 0, 1000, 0, 3, 0.05, "term", "big", ) let read = @src.PhdRead::new("test_read", bases, comment) assert_eq(read.name(), "test_read") @@ -47,16 +47,16 @@ test "phd_read_creation_and_sequence" { assert_eq(read.peak_positions(), [1, 2, 3]) } +///| test "phd_read_empty_sequence" { - let comment = @src.PhdComment::new( - "", "", "", 0, 0, 0, 0, 0.0, "", "", - ) + let comment = @src.PhdComment::new("", "", "", 0, 0, 0, 0, 0.0, "", "") let read = @src.PhdRead::new("empty", [], comment) assert_eq(read.length(), 0) assert_eq(read.sequence(), "") assert_eq(read.quality().length(), 0) } +///| test "phd_file_creation" { let comment = @src.PhdComment::new( "read.ab1", "0.020425.c", "", 0, 0, 0, 0, 0.0, "", "", @@ -74,12 +74,14 @@ test "phd_file_creation" { // Sample data // --------------------------------------------------------------------------- +///| test "phd_sample_text_has_begin_sequence" { let text = @src.phd_sample_text() assert_true(text.contains("BEGIN_SEQUENCE")) assert_true(text.contains("END_SEQUENCE")) } +///| test "phd_sample_text_has_comment_block" { let text = @src.phd_sample_text() assert_true(text.contains("BEGIN_COMMENT")) @@ -88,6 +90,7 @@ test "phd_sample_text_has_comment_block" { assert_true(text.contains("PHRED_VERSION")) } +///| test "phd_sample_text_has_dna_block" { let text = @src.phd_sample_text() assert_true(text.contains("BEGIN_DNA")) @@ -98,6 +101,7 @@ test "phd_sample_text_has_dna_block" { // Parsing // --------------------------------------------------------------------------- +///| test "phd_parse_single_read" { let text = @src.phd_sample_text() let file = @src.phd_parse(text) @@ -108,6 +112,7 @@ test "phd_parse_single_read" { assert_eq(read.sequence(), "ACGTACGTAC") } +///| test "phd_parse_comment_fields" { let text = @src.phd_sample_text() let file = @src.phd_parse(text) @@ -123,6 +128,7 @@ test "phd_parse_comment_fields" { assert_eq(c.dye(), "big") } +///| test "phd_parse_quality_scores" { let text = @src.phd_sample_text() let file = @src.phd_parse(text) @@ -134,6 +140,7 @@ test "phd_parse_quality_scores" { assert_eq(quals[9], 44) } +///| test "phd_parse_peak_positions" { let text = @src.phd_sample_text() let file = @src.phd_parse(text) @@ -144,17 +151,20 @@ test "phd_parse_peak_positions" { assert_eq(peaks[9], 10) } +///| test "phd_parse_multiple_reads" { let text = @src.phd_sample_text() + "\n" + @src.phd_sample_text() let file = @src.phd_parse(text) assert_eq(file.num_reads(), 2) } +///| test "phd_parse_empty_input" { let file = @src.phd_parse("") assert_eq(file.num_reads(), 0) } +///| test "phd_parse_minimal_phd" { let text = "BEGIN_SEQUENCE r1\nBEGIN_DNA\nA 10 1\nT 20 2\nEND_DNA\nEND_SEQUENCE\n" let file = @src.phd_parse(text) @@ -166,6 +176,7 @@ test "phd_parse_minimal_phd" { assert_eq(read.quality(), [10, 20]) } +///| test "phd_parse_no_dna_block" { let text = "BEGIN_SEQUENCE r1\nBEGIN_COMMENT\nCHROMAT_FILE: r.ab1\nEND_COMMENT\nEND_SEQUENCE\n" let file = @src.phd_parse(text) @@ -176,6 +187,7 @@ test "phd_parse_no_dna_block" { assert_eq(read.comment().chromat_file(), "r.ab1") } +///| test "phd_parse_trim_values" { let text = "BEGIN_SEQUENCE r1\nBEGIN_COMMENT\nTRIM: 5 50 0.02\nEND_COMMENT\nBEGIN_DNA\nA 10 1\nEND_DNA\nEND_SEQUENCE\n" let file = @src.phd_parse(text) @@ -188,6 +200,7 @@ test "phd_parse_trim_values" { // Formatting // --------------------------------------------------------------------------- +///| test "phd_read_to_string" { let text = @src.phd_sample_text() let file = @src.phd_parse(text) @@ -198,6 +211,7 @@ test "phd_read_to_string" { assert_true(s.contains("ACGTACGTAC")) } +///| test "phd_file_to_string" { let text = @src.phd_sample_text() let file = @src.phd_parse(text) diff --git a/test/moonbit/pheatmap_test.mbt b/test/moonbit/pheatmap_test.mbt index 62a0a8fc..a5262199 100644 --- a/test/moonbit/pheatmap_test.mbt +++ b/test/moonbit/pheatmap_test.mbt @@ -3,16 +3,10 @@ ///| test "pheatmap_create_input" { - let mat = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - [7.0, 8.0, 9.0], - ] - let input = @src.pheatmap_input( - mat, - ["row1", "row2", "row3"], - ["col1", "col2", "col3"], - ) + let mat = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] + let input = @src.pheatmap_input(mat, ["row1", "row2", "row3"], [ + "col1", "col2", "col3", + ]) assert_eq(input.mat.length(), 3) assert_eq(input.row_names.length(), 3) assert_eq(input.col_names.length(), 3) @@ -20,11 +14,11 @@ test "pheatmap_create_input" { ///| test "pheatmap_distance_euclidean" { - let data = [ - [1.0, 0.0], - [0.0, 0.0], - ] - let dist = @src.pheatmap_distance_matrix(data, @src.distance_method_euclidean()) + let data = [[1.0, 0.0], [0.0, 0.0]] + let dist = @src.pheatmap_distance_matrix( + data, + @src.distance_method_euclidean(), + ) assert_eq(dist.length(), 2) assert_eq(dist[0][0], 0.0) assert_eq(dist[1][1], 0.0) @@ -33,23 +27,22 @@ test "pheatmap_distance_euclidean" { ///| test "pheatmap_distance_manhattan" { - let data = [ - [1.0, 2.0], - [4.0, 6.0], - ] - let dist = @src.pheatmap_distance_matrix(data, @src.distance_method_manhattan()) + let data = [[1.0, 2.0], [4.0, 6.0]] + let dist = @src.pheatmap_distance_matrix( + data, + @src.distance_method_manhattan(), + ) assert_eq(dist.length(), 2) assert_eq(dist[0][1], 7.0) } ///| test "pheatmap_distance_symmetry" { - let data = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - [7.0, 8.0, 9.0], - ] - let dist = @src.pheatmap_distance_matrix(data, @src.distance_method_euclidean()) + let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] + let dist = @src.pheatmap_distance_matrix( + data, + @src.distance_method_euclidean(), + ) let n = dist.length() let mut i = 0 while i < n { @@ -64,26 +57,18 @@ test "pheatmap_distance_symmetry" { ///| test "pheatmap_column_distance" { - let data = [ - [1.0, 0.0, 1.0], - [0.0, 1.0, 0.0], - ] - let dist = @src.pheatmap_column_distance_matrix(data, @src.distance_method_euclidean()) + let data = [[1.0, 0.0, 1.0], [0.0, 1.0, 0.0]] + let dist = @src.pheatmap_column_distance_matrix( + data, + @src.distance_method_euclidean(), + ) assert_eq(dist.length(), 3) } ///| test "pheatmap_render_basic" { - let mat = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - [7.0, 8.0, 9.0], - ] - let input = @src.pheatmap_input( - mat, - ["r1", "r2", "r3"], - ["c1", "c2", "c3"], - ) + let mat = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] + let input = @src.pheatmap_input(mat, ["r1", "r2", "r3"], ["c1", "c2", "c3"]) let result = @src.pheatmap_render(input) assert_eq(result.row_order.length(), 3) assert_eq(result.col_order.length(), 3) @@ -108,11 +93,7 @@ test "pheatmap_set_fontsize" { ///| test "pheatmap_cutree_rows" { - let mat = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - [7.0, 8.0, 9.0], - ] + let mat = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let input = @src.pheatmap_input(mat, ["r1", "r2", "r3"], ["c1", "c2", "c3"]) let cut = @src.pheatmap_set_cutree(input, 2, 1) assert_eq(cut.cutree_rows, 2) @@ -120,10 +101,7 @@ test "pheatmap_cutree_rows" { ///| test "pheatmap_no_clustering" { - let mat = [ - [1.0, 2.0], - [3.0, 4.0], - ] + let mat = [[1.0, 2.0], [3.0, 4.0]] let input = @src.pheatmap_input(mat, ["r1", "r2"], ["c1", "c2"]) let unclustered = @src.pheatmap_set_cluster(input, false, false) assert_eq(unclustered.cluster_rows, false) diff --git a/test/moonbit/phylo_cdao_test.mbt b/test/moonbit/phylo_cdao_test.mbt index 75a7675a..50ad3a81 100644 --- a/test/moonbit/phylo_cdao_test.mbt +++ b/test/moonbit/phylo_cdao_test.mbt @@ -30,7 +30,12 @@ test "cdao_rdfs_namespace_constant" { ///| test "cdao_tree_construction" { - let t = @src.Cdaotree::new("#tree1", rooted=true, root_node_id="#node1", name=Some("MyTree")) + let t = @src.Cdaotree::new( + "#tree1", + rooted=true, + root_node_id="#node1", + name=Some("MyTree"), + ) assert_eq(t.id, "#tree1") assert_eq(t.rooted, true) assert_eq(t.root_node_id, "#node1") @@ -48,7 +53,11 @@ test "cdao_tree_default_values" { ///| test "cdao_node_construction" { - let n = @src.CdaoNode::new("#node1", children=["#node2", "#node3"], parent_id=Some("#node0")) + let n = @src.CdaoNode::new( + "#node1", + children=["#node2", "#node3"], + parent_id=Some("#node0"), + ) assert_eq(n.id, "#node1") assert_eq(n.children.length(), 2) assert_eq(n.parent_id.unwrap(), "#node0") @@ -337,7 +346,13 @@ test "cdao_to_trees_empty_document" { ///| test "cdao_node_fields_via_constructor" { - let n = @src.CdaoNode::new("#test", parent_id=Some("#parent"), tu_id=Some("#tu1"), branch_length=Some(2.5), label=Some("TestNode")) + let n = @src.CdaoNode::new( + "#test", + parent_id=Some("#parent"), + tu_id=Some("#tu1"), + branch_length=Some(2.5), + label=Some("TestNode"), + ) assert_eq(n.parent_id.unwrap(), "#parent") assert_eq(n.tu_id.unwrap(), "#tu1") assert_eq(n.branch_length.unwrap(), 2.5) diff --git a/test/moonbit/phylo_consensus_test.mbt b/test/moonbit/phylo_consensus_test.mbt index aa43e3d0..4cde5775 100644 --- a/test/moonbit/phylo_consensus_test.mbt +++ b/test/moonbit/phylo_consensus_test.mbt @@ -1,12 +1,12 @@ ///| /// Phylo.Consensus module tests - test "ConsensusNode::new" { let node = @src.ConsensusNode::new("A", false) assert_eq(node.name, "A") assert_true(node.is_leaf()) } +///| test "ConsensusNode::add_child" { let parent = @src.ConsensusNode::new("internal", true) let child = @src.ConsensusNode::new("A", false) @@ -14,6 +14,7 @@ test "ConsensusNode::add_child" { assert_eq(parent_with_child.children.length(), 1) } +///| test "ConsensusNode::get_leaves" { let root = @src.ConsensusNode::new("root", true) let child1 = @src.ConsensusNode::new("A", false) @@ -24,6 +25,7 @@ test "ConsensusNode::get_leaves" { assert_eq(leaves.length(), 2) } +///| test "parse_newick" { let newick = "((A,B),(C,D));" match @src.parse_consensus_newick(newick) { @@ -32,6 +34,7 @@ test "parse_newick" { } } +///| test "newick_to_tree" { let tree = @src.newick_to_tree("((A,B),(C,D));") match tree.root { @@ -40,12 +43,14 @@ test "newick_to_tree" { } } +///| test "ConsensusTree::to_newick" { let tree = @src.newick_to_tree("((A,B),(C,D));") let newick = tree.to_newick() assert_true(newick.length() > 0) } +///| test "build_majority_consensus" { let trees = @src.create_example_trees() let consensus = @src.build_majority_consensus(trees) @@ -55,6 +60,7 @@ test "build_majority_consensus" { } } +///| test "build_strict_consensus" { let trees = @src.create_example_trees() let consensus = @src.build_strict_consensus(trees) @@ -64,6 +70,7 @@ test "build_strict_consensus" { } } +///| test "get_all_splits" { let tree = @src.newick_to_tree("((A,B),(C,D));") match tree.root { @@ -76,6 +83,7 @@ test "get_all_splits" { } } +///| test "Split::normalize" { let split = @src.Split::new(["B", "A"]) let normalized = split.normalize() @@ -83,12 +91,14 @@ test "Split::normalize" { assert_eq(normalized.taxa[1], "B") } +///| test "Split::hash" { let split = @src.Split::new(["A", "B"]) let h = split.hash() assert_eq(h, "A,B") } +///| test "calculate_consensus_support" { let trees = @src.create_example_trees() let split = @src.Split::new(["A", "B"]) @@ -96,17 +106,20 @@ test "calculate_consensus_support" { assert_true(support >= 0.0 && support <= 1.0) } +///| test "get_all_splits_from_trees" { let trees = @src.create_example_trees() let splits = @src.get_all_splits_from_trees(trees) assert_true(splits.length() > 0) } +///| test "create_example_trees" { let trees = @src.create_example_trees() assert_eq(trees.length(), 5) } +///| test "create_simple_tree" { let tree = @src.create_simple_tree() match tree.root { @@ -115,6 +128,7 @@ test "create_simple_tree" { } } +///| test "build_consensus_empty" { let trees : Array[@src.ConsensusTree] = Array::new() let consensus = @src.build_consensus(trees, 0.5) @@ -122,4 +136,4 @@ test "build_consensus_empty" { Some(_) => assert_true(false) None => () } -} \ No newline at end of file +} diff --git a/test/moonbit/phylo_nexml_test.mbt b/test/moonbit/phylo_nexml_test.mbt index 939fc769..f80de22c 100644 --- a/test/moonbit/phylo_nexml_test.mbt +++ b/test/moonbit/phylo_nexml_test.mbt @@ -57,12 +57,7 @@ test "nexml_tree_creation" { let nodes : Array[@src.NeXMLNode] = [] let edges : Array[@src.NeXMLEdge] = [] let tree = @src.NeXMLTree::new( - "tree1", - "Test Tree", - "FloatTree", - true, - nodes, - edges, + "tree1", "Test Tree", "FloatTree", true, nodes, edges, ) assert_eq(tree.id, "tree1") assert_eq(tree.name, "Test Tree") diff --git a/test/moonbit/phylo_xml_debug_test.mbt b/test/moonbit/phylo_xml_debug_test.mbt index e61d6834..888fa40a 100644 --- a/test/moonbit/phylo_xml_debug_test.mbt +++ b/test/moonbit/phylo_xml_debug_test.mbt @@ -55,8 +55,7 @@ test "debug_parse_tree" { ///| test "debug_multiple_trees" { - let xml = - "\n" + + let xml = "\n" + "\n" + " \n" + " Tree 1\n" + diff --git a/test/moonbit/phylo_xml_test.mbt b/test/moonbit/phylo_xml_test.mbt index f9fdd9c5..83d775d6 100644 --- a/test/moonbit/phylo_xml_test.mbt +++ b/test/moonbit/phylo_xml_test.mbt @@ -1,7 +1,6 @@ ///| test "phyloxml_parse_simple_tree" { - let xml = - "\n" + + let xml = "\n" + " \n" + " Simple Tree\n" + " \n" + @@ -21,8 +20,7 @@ test "phyloxml_parse_simple_tree" { ///| test "phyloxml_parse_branch_lengths" { - let xml = - "\n" + + let xml = "\n" + " \n" + " \n" + " 0.5\n" + @@ -43,8 +41,7 @@ test "phyloxml_parse_branch_lengths" { ///| test "phyloxml_parse_taxon_annotations" { - let xml = - "\n" + + let xml = "\n" + " \n" + " \n" + " Root\n" + @@ -65,8 +62,7 @@ test "phyloxml_parse_taxon_annotations" { ///| test "phyloxml_parse_sequence_annotations" { - let xml = - "\n" + + let xml = "\n" + " \n" + " \n" + " Root\n" + @@ -87,8 +83,7 @@ test "phyloxml_parse_sequence_annotations" { ///| test "phyloxml_xml_roundtrip" { - let xml = - "\n" + + let xml = "\n" + "\n" + " \n" + " Test Tree\n" + @@ -153,8 +148,7 @@ test "phyloxml_newick_simple" { ///| test "phyloxml_to_newick" { - let xml = - "\n" + + let xml = "\n" + "\n" + " \n" + " \n" + @@ -188,11 +182,9 @@ test "phyloxml_node_to_newick_leaf" { test "phyloxml_node_to_newick_internal" { let child1 = @src.PhyloXMLNode::new(name="A", branch_length=0.1) let child2 = @src.PhyloXMLNode::new(name="B", branch_length=0.2) - let node = @src.PhyloXMLNode::new( - name="Root", - branch_length=0.5, - children=[child1, child2], - ) + let node = @src.PhyloXMLNode::new(name="Root", branch_length=0.5, children=[ + child1, child2, + ]) let newick = @src.phyloxml_node_to_newick(node) assert_true(newick.contains("(")) assert_true(newick.contains("A")) @@ -216,10 +208,7 @@ test "phyloxml_get_tree_names" { test "phyloxml_get_all_tips" { let leaf1 = @src.PhyloXMLNode::new(name="A") let leaf2 = @src.PhyloXMLNode::new(name="B") - let internal = @src.PhyloXMLNode::new( - name="Root", - children=[leaf1, leaf2], - ) + let internal = @src.PhyloXMLNode::new(name="Root", children=[leaf1, leaf2]) let tree = @src.PhyloXMLTree::new(root=internal) let tips = @src.get_all_tips(tree) assert_eq(tips.length(), 2) @@ -234,7 +223,7 @@ test "phyloxml_get_all_tips_deep" { let leaf3 = @src.PhyloXMLNode::new(name="C") let child1 = @src.PhyloXMLNode::new(name="X", children=[leaf1, leaf2]) let root = @src.PhyloXMLNode::new(name="Root", children=[child1, leaf3]) - let tree = @src.PhyloXMLTree::new(root=root) + let tree = @src.PhyloXMLTree::new(root~) let tips = @src.get_all_tips(tree) assert_eq(tips.length(), 3) } @@ -243,19 +232,15 @@ test "phyloxml_get_all_tips_deep" { test "phyloxml_node_count" { let leaf1 = @src.PhyloXMLNode::new(name="A") let leaf2 = @src.PhyloXMLNode::new(name="B") - let root = @src.PhyloXMLNode::new( - name="Root", - children=[leaf1, leaf2], - ) - let tree = @src.PhyloXMLTree::new(root=root) + let root = @src.PhyloXMLNode::new(name="Root", children=[leaf1, leaf2]) + let tree = @src.PhyloXMLTree::new(root~) let count = @src.phyloxml_get_node_count(tree) assert_eq(count, 3) } ///| test "phyloxml_multiple_trees" { - let xml = - "\n" + + let xml = "\n" + "\n" + " \n" + " Tree 1\n" + @@ -350,10 +335,7 @@ test "phyloxml_node_creation" { test "phyloxml_node_with_children" { let child1 = @src.PhyloXMLNode::new(name="C1") let child2 = @src.PhyloXMLNode::new(name="C2") - let node = @src.PhyloXMLNode::new( - name="Parent", - children=[child1, child2], - ) + let node = @src.PhyloXMLNode::new(name="Parent", children=[child1, child2]) assert_false(node.is_leaf) assert_eq(node.children.length(), 2) assert_eq(node.children[0].name, "C1") @@ -367,7 +349,7 @@ test "phyloxml_tree_creation" { tree_id="t1", name="Test Tree", description="A test tree", - root=root, + root~, ) assert_eq(tree.tree_id, "t1") assert_eq(tree.name, "Test Tree") @@ -379,10 +361,7 @@ test "phyloxml_tree_creation" { test "phyloxml_tree_with_metadata" { let meta : Map[String, String] = Map([], capacity=2) meta["rooted"] = "true" - let tree = @src.PhyloXMLTree::new( - name="Rooted Tree", - phylogeny_metadata=meta, - ) + let tree = @src.PhyloXMLTree::new(name="Rooted Tree", phylogeny_metadata=meta) assert_eq(tree.phylogeny_metadata["rooted"], "true") } @@ -404,8 +383,7 @@ test "phyloxml_get_element_text" { ///| test "phyloxml_parse_node_element" { - let xml = - "\n" + + let xml = "\n" + " TestNode\n" + " 0.5\n" + " \n" + @@ -419,8 +397,7 @@ test "phyloxml_parse_node_element" { ///| test "phyloxml_parse_taxon_element" { - let xml = - "\n" + + let xml = "\n" + " tx1\n" + " Homo sapiens\n" + " Human\n" + @@ -432,8 +409,7 @@ test "phyloxml_parse_taxon_element" { ///| test "phyloxml_parse_sequence_element" { - let xml = - "\n" + + let xml = "\n" + " seq1\n" + " DNA\n" + " ATG\n" + @@ -448,20 +424,16 @@ test "phyloxml_complex_tree_serialization" { let leaf_a = @src.PhyloXMLNode::new(name="A", branch_length=0.1) let leaf_b = @src.PhyloXMLNode::new(name="B", branch_length=0.2) let leaf_c = @src.PhyloXMLNode::new(name="C", branch_length=0.3) - let internal = @src.PhyloXMLNode::new( - name="Int", - branch_length=0.5, - children=[leaf_a, leaf_b], - ) - let root = @src.PhyloXMLNode::new( - name="Root", - branch_length=0.0, - children=[internal, leaf_c], - ) + let internal = @src.PhyloXMLNode::new(name="Int", branch_length=0.5, children=[ + leaf_a, leaf_b, + ]) + let root = @src.PhyloXMLNode::new(name="Root", branch_length=0.0, children=[ + internal, leaf_c, + ]) let tree = @src.PhyloXMLTree::new( tree_id="complex", name="Complex Tree", - root=root, + root~, ) let result = @src.PhyloXMLResult::new(trees=[tree]) let xml = @src.phyloxml_to_xml(result) @@ -527,8 +499,7 @@ test "phyloxml_indent_xml" { ///| test "phyloxml_find_all_elements" { - let xml = - "\n" + + let xml = "\n" + " 1\n" + " 2\n" + " 3\n" + @@ -539,18 +510,14 @@ test "phyloxml_find_all_elements" { ///| test "phyloxml_taxon_namespace" { - let ns = @src.TaxonNamespace::new( - namespace_id="ns1", - name="Test NS", - ) + let ns = @src.TaxonNamespace::new(namespace_id="ns1", name="Test NS") assert_eq(ns.namespace_id, "ns1") assert_eq(ns.name, "Test NS") } ///| test "phyloxml_with_taxon_namespace" { - let xml = - "\n" + + let xml = "\n" + "\n" + " \n" + " ns1\n" + @@ -568,4 +535,4 @@ test "phyloxml_with_taxon_namespace" { assert_eq(result.taxon_namespaces.length(), 1) assert_true(result.taxon_namespaces[0].namespace_id.length() >= 0) assert_true(result.taxon_namespaces[0].name.length() >= 0) -} \ No newline at end of file +} diff --git a/test/moonbit/phyloseq_test.mbt b/test/moonbit/phyloseq_test.mbt index 36268d91..085e8ed1 100644 --- a/test/moonbit/phyloseq_test.mbt +++ b/test/moonbit/phyloseq_test.mbt @@ -1,32 +1,35 @@ ///| /// Tests for phyloseq module. - test "phyloseq creation" { let ps = @src.create_example_phyloseq() assert_eq(@src.ps_num_otus(ps), 3) assert_eq(@src.ps_num_samples(ps), 3) } +///| test "phyloseq total abundance" { let ps = @src.create_example_phyloseq() let total = @src.ps_total_abundance(ps) assert_eq(total, 975.0) } +///| test "phyloseq filter by abundance" { let ps = @src.create_example_phyloseq() let filtered = @src.ps_filter_by_abundance(ps, 300.0) assert_eq(@src.ps_num_otus(filtered), 2) } +///| test "phyloseq filter by taxonomy" { let ps = @src.create_example_phyloseq() let filtered = @src.ps_filter_by_taxonomy(ps, "phylum", "Proteobacteria") assert_eq(@src.ps_num_otus(filtered), 1) } +///| test "phyloseq taxa summary" { let ps = @src.create_example_phyloseq() let summary = @src.ps_get_taxa_summary(ps, "phylum") assert_true(summary.contains("Proteobacteria")) -} \ No newline at end of file +} diff --git a/test/moonbit/plyranges_test.mbt b/test/moonbit/plyranges_test.mbt index 55efa9d7..d9f6b448 100644 --- a/test/moonbit/plyranges_test.mbt +++ b/test/moonbit/plyranges_test.mbt @@ -52,12 +52,9 @@ test "plyranges_filter_strand" { ///| test "plyranges_mutate" { - let ranges = @src.tgr_create( - ["chr1", "chr2"], - [100, 200], - [200, 300], - ["+", "-"], - ) + let ranges = @src.tgr_create(["chr1", "chr2"], [100, 200], [200, 300], [ + "+", "-", + ]) let mutated = @src.tgr_mutate(ranges, "gc_content", [0.45, 0.62]) assert_eq(mutated.metadata["gc_content"].length(), 2) assert_eq(mutated.metadata["gc_content"][0], 0.45) @@ -65,12 +62,9 @@ test "plyranges_mutate" { ///| test "plyranges_mutate_str" { - let ranges = @src.tgr_create( - ["chr1", "chr2"], - [100, 200], - [200, 300], - ["+", "-"], - ) + let ranges = @src.tgr_create(["chr1", "chr2"], [100, 200], [200, 300], [ + "+", "-", + ]) let mutated = @src.tgr_mutate_str(ranges, "gene_name", ["BRCA1", "TP53"]) assert_eq(mutated.metadata_str["gene_name"].length(), 2) assert_eq(mutated.metadata_str["gene_name"][0], "BRCA1") @@ -78,12 +72,9 @@ test "plyranges_mutate_str" { ///| test "plyranges_select" { - let ranges = @src.tgr_create( - ["chr1", "chr2"], - [100, 200], - [200, 300], - ["+", "-"], - ) + let ranges = @src.tgr_create(["chr1", "chr2"], [100, 200], [200, 300], [ + "+", "-", + ]) let mutated = @src.tgr_mutate(ranges, "score", [1.0, 2.0]) let selected = @src.tgr_select(mutated, ["score"]) assert_eq(selected.metadata["score"].length(), 2) @@ -106,12 +97,9 @@ test "plyranges_arrange" { ///| test "plyranges_rename" { - let ranges = @src.tgr_create( - ["chr1", "chr2"], - [100, 200], - [200, 300], - ["+", "-"], - ) + let ranges = @src.tgr_create(["chr1", "chr2"], [100, 200], [200, 300], [ + "+", "-", + ]) let mutated = @src.tgr_mutate(ranges, "score", [1.0, 2.0]) let renamed = @src.tgr_rename(mutated, "score", "alignment_score") assert_eq(renamed.metadata["alignment_score"].length(), 2) @@ -119,12 +107,9 @@ test "plyranges_rename" { ///| test "plyranges_width" { - let ranges = @src.tgr_create( - ["chr1", "chr2"], - [100, 200], - [200, 350], - ["+", "-"], - ) + let ranges = @src.tgr_create(["chr1", "chr2"], [100, 200], [200, 350], [ + "+", "-", + ]) assert_eq(ranges.widths[0], 101) assert_eq(ranges.widths[1], 151) } @@ -162,12 +147,9 @@ test "plyranges_filter_end" { ///| test "plyranges_multiple_metadata" { - let ranges = @src.tgr_create( - ["chr1", "chr2"], - [100, 200], - [200, 300], - ["+", "-"], - ) + let ranges = @src.tgr_create(["chr1", "chr2"], [100, 200], [200, 300], [ + "+", "-", + ]) let mutated = @src.tgr_mutate(ranges, "score", [1.5, 2.5]) let mutated2 = @src.tgr_mutate(mutated, "p_value", [0.01, 0.05]) assert_eq(mutated2.metadata.length(), 2) diff --git a/test/moonbit/polypeptide_test.mbt b/test/moonbit/polypeptide_test.mbt index c52eb22c..2bf79b7f 100644 --- a/test/moonbit/polypeptide_test.mbt +++ b/test/moonbit/polypeptide_test.mbt @@ -23,7 +23,9 @@ test "polypeptide_calculate_hydrophobicity" { ///| test "polypeptide_calculate_hydrophobicity_window" { let sequence = "MKLILVLLVSLSL" - let profile = @src.calculate_hydrophobicity_window(sequence, 5, "kyte-doolittle") + let profile = @src.calculate_hydrophobicity_window( + sequence, 5, "kyte-doolittle", + ) assert_eq(profile.values.length(), sequence.length()) } @@ -55,4 +57,4 @@ test "polypeptide_create_example_data" { assert_eq(seq.length() > 0, true) assert_eq(comp.total_residues > 0, true) assert_eq(prof.values.length() > 0, true) -} \ No newline at end of file +} diff --git a/test/moonbit/popgen_advanced_test.mbt b/test/moonbit/popgen_advanced_test.mbt index e0a6ec2a..aaac1792 100644 --- a/test/moonbit/popgen_advanced_test.mbt +++ b/test/moonbit/popgen_advanced_test.mbt @@ -58,7 +58,15 @@ test "watterson_theta_small_sample" { test "watterson_a1" { let a1 = @src.watterson_a1(10) // a1 = sum(1/i) for i=1..9 = 1 + 1/2 + 1/3 + ... + 1/9 - let expected = 1.0 + 0.5 + 0.3333333 + 0.25 + 0.2 + 0.1666667 + 0.1428571 + 0.125 + 0.1111111 + let expected = 1.0 + + 0.5 + + 0.3333333 + + 0.25 + + 0.2 + + 0.1666667 + + 0.1428571 + + 0.125 + + 0.1111111 assert_true((a1 - expected).abs() < 0.01) } @@ -176,16 +184,16 @@ test "mktest_zero_values" { test "mktest_from_sites" { let poly_sites : Array[@src.PolymorphicSite] = Array::new() let fixed_sites : Array[@src.PolymorphicSite] = Array::new() - + // Add polymorphic sites - poly_sites.push(@src.new_polymorphic_site(100, 2, 20, true)) // nonsynonymous + poly_sites.push(@src.new_polymorphic_site(100, 2, 20, true)) // nonsynonymous poly_sites.push(@src.new_polymorphic_site(200, 3, 20, false)) // synonymous - poly_sites.push(@src.new_polymorphic_site(300, 1, 20, true)) // nonsynonymous - + poly_sites.push(@src.new_polymorphic_site(300, 1, 20, true)) // nonsynonymous + // Add fixed sites - fixed_sites.push(@src.new_polymorphic_site(400, 20, 20, true)) // nonsynonymous + fixed_sites.push(@src.new_polymorphic_site(400, 20, 20, true)) // nonsynonymous fixed_sites.push(@src.new_polymorphic_site(500, 20, 20, false)) // synonymous - + let result = @src.mktest_from_sites(poly_sites, fixed_sites) assert_eq(result.p_nonsyn, 2) assert_eq(result.p_syn, 1) @@ -201,7 +209,7 @@ test "afs_calculate" { sites.push(@src.new_singleton(200, 20, true)) sites.push(@src.new_doubleton(300, 20, false)) sites.push(@src.new_polymorphic_site(400, 5, 20, false)) - + let afs = @src.calculate_afs(sites, 20) assert_eq(afs.singletons, 2) assert_eq(afs.doubletons, 1) @@ -224,7 +232,7 @@ test "tajima_d_from_afs" { sites.push(@src.new_singleton(100, 20, false)) sites.push(@src.new_singleton(200, 20, false)) sites.push(@src.new_doubleton(300, 20, false)) - + let afs = @src.calculate_afs(sites, 20) let result = @src.tajima_d_from_afs(afs, 1000) assert_eq(result.test_name, "Tajima's D") @@ -237,7 +245,7 @@ test "fu_li_d_from_afs" { let sites : Array[@src.PolymorphicSite] = Array::new() sites.push(@src.new_singleton(100, 20, false)) sites.push(@src.new_doubleton(200, 20, false)) - + let afs = @src.calculate_afs(sites, 20) let result = @src.fu_li_d_from_afs(afs) assert_eq(result.test_name, "Fu & Li's D") @@ -248,10 +256,10 @@ test "fu_li_d_from_afs" { test "normal_cdf" { let p0 = @src.popgen_normal_cdf(0.0) assert_true((p0 - 0.5).abs() < 0.01) - + let p1 = @src.popgen_normal_cdf(1.96) assert_true(p1 > 0.96 && p1 < 0.98) - + let p_neg1 = @src.popgen_normal_cdf(-1.96) assert_true(p_neg1 > 0.02 && p_neg1 < 0.04) } @@ -270,7 +278,7 @@ test "neutrality_analysis" { for i = 1; i < 3; i = i + 1 { sites.push(@src.new_polymorphic_site(1000 + i * 100, 5, 30, i == 1)) } - + let result = @src.run_neutrality_analysis(sites, 30, 10000) assert_true(!result.tajima_d.statistic.is_nan()) assert_true(!result.fu_li_d.statistic.is_nan()) @@ -296,7 +304,7 @@ test "neutrality_analysis_to_string" { sites.push(@src.new_singleton(100, 20, false)) sites.push(@src.new_singleton(200, 20, true)) sites.push(@src.new_doubleton(300, 20, false)) - + let result = @src.run_neutrality_analysis(sites, 20, 5000) let output = @src.neutrality_analysis_to_string(result) assert_true(output.contains("Neutrality Analysis Results")) @@ -353,7 +361,7 @@ test "multiple_singletons" { for i = 1; i < 15; i = i + 1 { sites.push(@src.new_singleton(i * 50, 25, i % 3 == 0)) } - + let afs = @src.calculate_afs(sites, 25) assert_eq(afs.singletons, 14) assert_eq(afs.segregating_sites, 14) @@ -367,7 +375,7 @@ test "high_freq_variants" { sites.push(@src.new_polymorphic_site(100, 24, 25, false)) sites.push(@src.new_polymorphic_site(200, 23, 25, true)) sites.push(@src.new_polymorphic_site(300, 22, 25, false)) - + let afs = @src.calculate_afs(sites, 25) assert_eq(afs.singletons, 0) // No singletons -} \ No newline at end of file +} diff --git a/test/moonbit/preprocess_core_test.mbt b/test/moonbit/preprocess_core_test.mbt index 6b852a00..f836dcef 100644 --- a/test/moonbit/preprocess_core_test.mbt +++ b/test/moonbit/preprocess_core_test.mbt @@ -14,6 +14,7 @@ test "pc_quantile_config_new" { assert_eq(config.method, "quantile") } +///| test "pc_invariant_set_result_creation" { let dummy : Array[Array[Double]] = [[1.0, 2.0], [3.0, 4.0]] let res = @src.InvariantSetResult::new(dummy, [0, 1], 0, [0.0, 1.0]) @@ -27,6 +28,7 @@ test "pc_invariant_set_result_creation" { // Helper utilities // ============================================================================ +///| test "pc_interp_linear_basic" { let xs = [0.0, 1.0, 2.0, 3.0, 4.0] let ys = [0.0, 10.0, 20.0, 30.0, 40.0] @@ -44,11 +46,13 @@ test "pc_interp_linear_basic" { assert_true((v3 - 40.0).abs() < 0.0001) } +///| test "pc_interp_linear_empty" { let v = @src.pc_interp_linear([], [], 1.0) assert_eq(v, 0.0) } +///| test "pc_interp_linear_single" { let v = @src.pc_interp_linear([5.0], [100.0], 0.0) assert_eq(v, 100.0) @@ -58,15 +62,10 @@ test "pc_interp_linear_single" { // Quantile normalization core tests // ============================================================================ +///| test "pc_normalize_quantiles_identical_distributions" { // Two columns with same values -> should remain the same - let matrix = [ - [1.0, 1.0], - [2.0, 2.0], - [3.0, 3.0], - [4.0, 4.0], - [5.0, 5.0], - ] + let matrix = [[1.0, 1.0], [2.0, 2.0], [3.0, 3.0], [4.0, 4.0], [5.0, 5.0]] let res = @src.normalize_quantiles(matrix) assert_eq(res.length(), 5) assert_eq(res[0].length(), 2) @@ -76,16 +75,12 @@ test "pc_normalize_quantiles_identical_distributions" { } } +///| test "pc_normalize_quantiles_swapped_values" { // Two columns with reversed order // Col1: [1, 2, 3, 4], Col2: [4, 3, 2, 1] // After normalization, both should have means of sorted values - let matrix = [ - [1.0, 4.0], - [2.0, 3.0], - [3.0, 2.0], - [4.0, 1.0], - ] + let matrix = [[1.0, 4.0], [2.0, 3.0], [3.0, 2.0], [4.0, 1.0]] let res = @src.normalize_quantiles(matrix) // Check distributions: for each column, after sorting, they should match // sorted(col1_normalized) == sorted(col2_normalized) == 2.5, 2.5, 2.5, 2.5 @@ -102,12 +97,9 @@ test "pc_normalize_quantiles_swapped_values" { assert_true((res[0][1] - 4.0).abs() < 0.0001) } +///| test "pc_normalize_quantiles_three_columns" { - let matrix = [ - [1.0, 4.0, 7.0], - [2.0, 5.0, 8.0], - [3.0, 6.0, 9.0], - ] + let matrix = [[1.0, 4.0, 7.0], [2.0, 5.0, 8.0], [3.0, 6.0, 9.0]] let res = @src.normalize_quantiles(matrix) assert_eq(res.length(), 3) assert_eq(res[0].length(), 3) @@ -123,11 +115,13 @@ test "pc_normalize_quantiles_three_columns" { assert_true((orig_sum - new_sum).abs() < 0.1) } +///| test "pc_normalize_quantiles_empty" { let res = @src.normalize_quantiles([]) assert_eq(res.length(), 0) } +///| test "pc_normalize_quantiles_one_row" { let matrix = [[1.0, 10.0, 100.0]] let res = @src.normalize_quantiles(matrix) @@ -144,12 +138,9 @@ test "pc_normalize_quantiles_one_row" { // Target-based quantile normalization // ============================================================================ +///| test "pc_normalize_quantiles_target" { - let matrix = [ - [1.0, 2.0], - [3.0, 4.0], - [5.0, 6.0], - ] + let matrix = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]] let target = [10.0, 20.0, 30.0] let res = @src.normalize_quantiles_use_target(matrix, target) assert_eq(res.length(), 3) @@ -161,12 +152,9 @@ test "pc_normalize_quantiles_target" { assert_true((res[2][0] - 30.0).abs() < 0.0001) } +///| test "pc_normalize_quantiles_determine_target" { - let matrix = [ - [1.0, 3.0], - [2.0, 2.0], - [3.0, 1.0], - ] + let matrix = [[1.0, 3.0], [2.0, 2.0], [3.0, 1.0]] let target = @src.normalize_quantiles_determine_target(matrix) assert_eq(target.length(), 3) // Each row of sorted matrix: sorted col1 = [1, 2, 3], col2 = [1, 2, 3] @@ -180,6 +168,7 @@ test "pc_normalize_quantiles_determine_target" { // Subset quantile normalization // ============================================================================ +///| test "pc_normalize_quantiles_subset" { let matrix = [ [1.0, 8.0], @@ -200,6 +189,7 @@ test "pc_normalize_quantiles_subset" { // Invariant set normalization // ============================================================================ +///| test "pc_find_invariant_set_perfect_correlation" { // Two arrays with perfect linear relationship let reference = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] @@ -209,11 +199,13 @@ test "pc_find_invariant_set_perfect_correlation" { assert_true(inv.length() >= 5) } +///| test "pc_find_invariant_set_length_mismatch" { let inv = @src.find_invariant_set([1.0, 2.0], [1.0]) assert_eq(inv.length(), 0) } +///| test "pc_normalize_invariantset_basic" { // 3 samples x 5 rows let matrix = [ @@ -223,7 +215,11 @@ test "pc_normalize_invariantset_basic" { [4.0, 8.0, 12.0], [5.0, 10.0, 15.0], ] - let res = @src.normalize_invariantset(matrix, reference_index=0, threshold=0.01) + let res = @src.normalize_invariantset( + matrix, + reference_index=0, + threshold=0.01, + ) assert_eq(res.reference_index, 0) assert_eq(res.normalized_data.length(), 5) // Reference column should be unchanged @@ -236,6 +232,7 @@ test "pc_normalize_invariantset_basic" { // Log transform // ============================================================================ +///| test "pc_log2_transform_basic" { let matrix = [[0.0, 1.0], [3.0, 15.0]] let res = @src.log2_transform(matrix, offset=1.0) @@ -249,6 +246,7 @@ test "pc_log2_transform_basic" { assert_true((res[1][1] - 4.0).abs() < 0.0001) } +///| test "pc_log2_transform_empty" { let res = @src.log2_transform([]) assert_eq(res.length(), 0) @@ -258,6 +256,7 @@ test "pc_log2_transform_empty" { // Background correction // ============================================================================ +///| test "pc_background_correct_percentile_basic" { let matrix = [ [1.0, 100.0], @@ -290,21 +289,16 @@ test "pc_background_correct_percentile_basic" { // Median center // ============================================================================ +///| test "pc_median_center_columns_basic" { - let matrix = [ - [1.0, 10.0], - [2.0, 20.0], - [3.0, 30.0], - [4.0, 40.0], - [5.0, 50.0], - ] + let matrix = [[1.0, 10.0], [2.0, 20.0], [3.0, 30.0], [4.0, 40.0], [5.0, 50.0]] let res = @src.median_center_columns(matrix) // Column 1 median = 3, centered = [-2, -1, 0, 1, 2] - assert_true((res[0][0] - (-2.0)).abs() < 0.0001) + assert_true((res[0][0] - -2.0).abs() < 0.0001) assert_true((res[2][0] - 0.0).abs() < 0.0001) assert_true((res[4][0] - 2.0).abs() < 0.0001) // Column 2 median = 30, centered = [-20, -10, 0, 10, 20] - assert_true((res[0][1] - (-20.0)).abs() < 0.0001) + assert_true((res[0][1] - -20.0).abs() < 0.0001) assert_true((res[2][1] - 0.0).abs() < 0.0001) assert_true((res[4][1] - 20.0).abs() < 0.0001) } @@ -313,14 +307,9 @@ test "pc_median_center_columns_basic" { // Column summary // ============================================================================ +///| test "pc_column_summary_basic" { - let matrix = [ - [1.0, 10.0], - [2.0, 20.0], - [3.0, 30.0], - [4.0, 40.0], - [5.0, 50.0], - ] + let matrix = [[1.0, 10.0], [2.0, 20.0], [3.0, 30.0], [4.0, 40.0], [5.0, 50.0]] let res = @src.column_summary(matrix) assert_eq(res.length(), 2) // Each column result is [mean, median, sd, min, max] @@ -336,6 +325,7 @@ test "pc_column_summary_basic" { assert_true((res[1][4] - 50.0).abs() < 0.0001) } +///| test "pc_column_summary_empty" { let res = @src.column_summary([]) assert_eq(res.length(), 0) diff --git a/test/moonbit/progeny_test.mbt b/test/moonbit/progeny_test.mbt index 66a420dd..0b3af720 100644 --- a/test/moonbit/progeny_test.mbt +++ b/test/moonbit/progeny_test.mbt @@ -23,8 +23,8 @@ test "progeny_mat_vec_multiply" { let vector = [1.0, 2.0] let result = @src.progeny_mat_vec(matrix, vector) assert_eq(result.length(), 2) - assert_eq(result[0], 5.0) // 1*1 + 2*2 - assert_eq(result[1], 11.0) // 3*1 + 4*2 + assert_eq(result[0], 5.0) // 1*1 + 2*2 + assert_eq(result[1], 11.0) // 3*1 + 4*2 } ///| @@ -33,10 +33,10 @@ test "progeny_mat_mul" { let b = [[5.0, 6.0], [7.0, 8.0]] let result = @src.progeny_mat_mul(a, b) assert_eq(result.length(), 2) - assert_eq(result[0][0], 19.0) // 1*5 + 2*7 - assert_eq(result[0][1], 22.0) // 1*6 + 2*8 - assert_eq(result[1][0], 43.0) // 3*5 + 4*7 - assert_eq(result[1][1], 50.0) // 3*6 + 4*8 + assert_eq(result[0][0], 19.0) // 1*5 + 2*7 + assert_eq(result[0][1], 22.0) // 1*6 + 2*8 + assert_eq(result[1][0], 43.0) // 3*5 + 4*7 + assert_eq(result[1][1], 50.0) // 3*6 + 4*8 } ///| @@ -114,11 +114,15 @@ test "progeny_build_pathway_matrix" { let gene_names = ["GeneA", "GeneB", "GeneC", "GeneD"] let pathway1_genes = ["GeneA", "GeneB"] let pathway1_weights = [1.0, -1.0] - let pgs1 = @src.PathwayGeneSet::new("Pathway1", pathway1_genes, pathway1_weights) + let pgs1 = @src.PathwayGeneSet::new( + "Pathway1", pathway1_genes, pathway1_weights, + ) let pathway2_genes = ["GeneB", "GeneC", "GeneD"] let pathway2_weights = [0.5, 1.0, -0.5] - let pgs2 = @src.PathwayGeneSet::new("Pathway2", pathway2_genes, pathway2_weights) + let pgs2 = @src.PathwayGeneSet::new( + "Pathway2", pathway2_genes, pathway2_weights, + ) let pathways = [pgs1, pgs2] let matrix = @src.build_pathway_matrix(gene_names, pathways) @@ -146,25 +150,18 @@ test "progeny_build_pathway_matrix" { ///| test "progeny_run_basic" { // Expression: 2 samples × 4 genes - let expression = [ - [5.0, 10.0, 3.0, 8.0], - [2.0, 6.0, 7.0, 4.0], - ] + let expression = [[5.0, 10.0, 3.0, 8.0], [2.0, 6.0, 7.0, 4.0]] let sample_names = ["Sample1", "Sample2"] let gene_names = ["GeneA", "GeneB", "GeneC", "GeneD"] // Pathway1: GeneA + GeneB (activation) - let pathway1 = @src.PathwayGeneSet::new( - "Pathway1", - ["GeneA", "GeneB"], - [1.0, 1.0], - ) + let pathway1 = @src.PathwayGeneSet::new("Pathway1", ["GeneA", "GeneB"], [ + 1.0, 1.0, + ]) // Pathway2: GeneC + GeneD (activation) - let pathway2 = @src.PathwayGeneSet::new( - "Pathway2", - ["GeneC", "GeneD"], - [1.0, 1.0], - ) + let pathway2 = @src.PathwayGeneSet::new("Pathway2", ["GeneC", "GeneD"], [ + 1.0, 1.0, + ]) let data = @src.ProgenyData::new( expression, @@ -192,7 +189,13 @@ test "progeny_get_pathway_activity" { let sample_names = ["S1", "S2"] let gene_names = ["G1", "G2"] let pathway1 = @src.PathwayGeneSet::new("P1", ["G1"], [1.0]) - let data = @src.ProgenyData::new(expression, sample_names, gene_names, [pathway1], 0.01) + let data = @src.ProgenyData::new( + expression, + sample_names, + gene_names, + [pathway1], + 0.01, + ) let result = @src.run_progeny(data) let activity = @src.get_pathway_activity(result, "P1") @@ -207,7 +210,13 @@ test "progeny_get_sample_profile" { let gene_names = ["G1", "G2"] let p1 = @src.PathwayGeneSet::new("P1", ["G1"], [1.0]) let p2 = @src.PathwayGeneSet::new("P2", ["G2"], [1.0]) - let data = @src.ProgenyData::new(expression, sample_names, gene_names, [p1, p2], 0.01) + let data = @src.ProgenyData::new( + expression, + sample_names, + gene_names, + [p1, p2], + 0.01, + ) let result = @src.run_progeny(data) let profile = @src.get_sample_profile(result, "S1") diff --git a/test/moonbit/prosite_test.mbt b/test/moonbit/prosite_test.mbt index 57113815..f4a53178 100644 --- a/test/moonbit/prosite_test.mbt +++ b/test/moonbit/prosite_test.mbt @@ -1,57 +1,69 @@ ///| /// Tests for Prosite module. - test "PrositePattern creation" { - let pattern = @src.PrositePattern::new("PS00001", "ATP-binding", "[AG]-X(4)-G-K-[ST]") + let pattern = @src.PrositePattern::new( + "PS00001", "ATP-binding", "[AG]-X(4)-G-K-[ST]", + ) assert_eq(pattern.accession, "PS00001") assert_eq(pattern.name, "ATP-binding") assert_eq(pattern.pattern, "[AG]-X(4)-G-K-[ST]") } +///| test "PrositeMatch creation" { - let match_ = @src.PrositeMatch::new("PS00001", "ATP-binding", 1, 10, "AGXXXXGKST") + let match_ = @src.PrositeMatch::new( + "PS00001", "ATP-binding", 1, 10, "AGXXXXGKST", + ) assert_eq(match_.pattern_accession, "PS00001") assert_eq(match_.start, 1) assert_eq(match_.end, 10) } +///| test "PrositeEntry creation" { let entry = @src.PrositeEntry::new("PS00001", "ATP/GTP-binding") assert_eq(entry.accession, "PS00001") assert_eq(entry.name, "ATP/GTP-binding") } +///| test "prosite_pattern_to_regex" { let regex = @src.prosite_pattern_to_regex("[AG]-X(4)-G-K-[ST]") assert_true(regex.length() > 0) } +///| test "prosite_search simple pattern" { let matches = @src.prosite_search("ST", "AASTKKST") assert_true(matches.length() >= 2) } +///| test "prosite_search bracket pattern" { let matches = @src.prosite_search("[ST]", "ASTCG") assert_true(matches.length() >= 2) } +///| test "prosite_search with wildcards" { let matches = @src.prosite_search("X(2)", "AAAA") assert_true(matches.length() >= 3) } +///| test "prosite_scan" { let patterns = @src.prosite_create_example_patterns() let matches = @src.prosite_scan("AASTKKST", patterns) assert_true(matches.length() >= 1) } +///| test "prosite_get_pattern" { let pattern = @src.prosite_get_pattern("PS00001") assert_true(pattern is Some(_)) } +///| test "prosite_calculate_score" { let match_ = @src.PrositeMatch::new("PS00001", "Test", 1, 5, "AAAAA") let pattern = @src.PrositePattern::new("PS00001", "Test", "AAAAA") @@ -59,12 +71,14 @@ test "prosite_calculate_score" { assert_true(score >= 90.0) } +///| test "prosite_create_example_patterns" { let patterns = @src.prosite_create_example_patterns() assert_eq(patterns.length(), 3) } +///| test "prosite_create_example_entry" { let entry = @src.prosite_create_example_entry() assert_eq(entry.accession, "PS00001") -} \ No newline at end of file +} diff --git a/test/moonbit/prot_dao_test.mbt b/test/moonbit/prot_dao_test.mbt index e36871ae..7bca0fce 100644 --- a/test/moonbit/prot_dao_test.mbt +++ b/test/moonbit/prot_dao_test.mbt @@ -1,182 +1,211 @@ ///| /// Test file for prot_dao module (IUPred disorder prediction). - test "disorder_score_positive" { // Disordered-promoting amino acids should have positive scores - assert_eq!(@src.prot_dao_disorder_score('E') > 0.0, true) - assert_eq!(@src.prot_dao_disorder_score('P') > 0.0, true) - assert_eq!(@src.prot_dao_disorder_score('K') > 0.0, true) - assert_eq!(@src.prot_dao_disorder_score('S') > 0.0, true) + assert_eq(@src.prot_dao_disorder_score('E') > 0.0, true) + assert_eq(@src.prot_dao_disorder_score('P') > 0.0, true) + assert_eq(@src.prot_dao_disorder_score('K') > 0.0, true) + assert_eq(@src.prot_dao_disorder_score('S') > 0.0, true) } +///| test "disorder_score_negative" { // Order-promoting amino acids should have negative or near-zero scores - assert_eq!(@src.prot_dao_disorder_score('I') < 0.0, true) - assert_eq!(@src.prot_dao_disorder_score('W') <= 0.0, true) - assert_eq!(@src.prot_dao_disorder_score('Y') < 0.0, true) - assert_eq!(@src.prot_dao_disorder_score('C') <= 0.0, true) + assert_eq(@src.prot_dao_disorder_score('I') < 0.0, true) + assert_eq(@src.prot_dao_disorder_score('W') <= 0.0, true) + assert_eq(@src.prot_dao_disorder_score('Y') < 0.0, true) + assert_eq(@src.prot_dao_disorder_score('C') <= 0.0, true) } +///| test "disorder_score_unknown_aa" { // Unknown amino acids should have 0 score - assert_eq!(@src.prot_dao_disorder_score('X'), 0.0) - assert_eq!(@src.prot_dao_disorder_score('z'), 0.0) + assert_eq(@src.prot_dao_disorder_score('X'), 0.0) + assert_eq(@src.prot_dao_disorder_score('z'), 0.0) } +///| test "energy_score_positive" { - assert_eq!(@src.prot_dao_energy_score('C') > 0.0, true) - assert_eq!(@src.prot_dao_energy_score('P') > 0.0, true) - assert_eq!(@src.prot_dao_energy_score('M') > 0.0, true) + assert_eq(@src.prot_dao_energy_score('C') > 0.0, true) + assert_eq(@src.prot_dao_energy_score('P') > 0.0, true) + assert_eq(@src.prot_dao_energy_score('M') > 0.0, true) } +///| test "energy_score_negative" { - assert_eq!(@src.prot_dao_energy_score('H') < 0.0, true) - assert_eq!(@src.prot_dao_energy_score('R') < 0.0, true) + assert_eq(@src.prot_dao_energy_score('H') < 0.0, true) + assert_eq(@src.prot_dao_energy_score('R') < 0.0, true) } +///| test "disorder_residue_create" { let res = @src.DisorderResidue::new(1, 'A', 0.5, 1.0) - assert_eq!(res.position, 1) - assert_eq!(res.amino_acid, 'A') - assert_eq!(res.disorder_score, 0.5) - assert_eq!(res.energy_score, 1.0) - assert_eq!(res.is_disordered, false) - assert_eq!(res.is_disordered_long, false) + assert_eq(res.position, 1) + assert_eq(res.amino_acid, 'A') + assert_eq(res.disorder_score, 0.5) + assert_eq(res.energy_score, 1.0) + assert_eq(res.is_disordered, false) + assert_eq(res.is_disordered_long, false) } +///| test "disorder_region_create" { let reg = @src.DisorderRegion::new(10, 50, 0.6, 0.8, region_type="disordered") - assert_eq!(reg.start, 10) - assert_eq!(reg.end_, 50) - assert_eq!(reg.length, 40) - assert_eq!(reg.avg_score, 0.6) - assert_eq!(reg.max_score, 0.8) - assert_eq!(reg.region_type, "disordered") + assert_eq(reg.start, 10) + assert_eq(reg.end_, 50) + assert_eq(reg.length, 40) + assert_eq(reg.avg_score, 0.6) + assert_eq(reg.max_score, 0.8) + assert_eq(reg.region_type, "disordered") } +///| test "disorder_region_type" { - let reg = @src.DisorderRegion::new(5, 45, 0.7, 0.9, region_type="long disordered") - assert_eq!(reg.region_type, "long disordered") + let reg = @src.DisorderRegion::new( + 5, + 45, + 0.7, + 0.9, + region_type="long disordered", + ) + assert_eq(reg.region_type, "long disordered") } +///| test "prot_dao_predict_ordered_sequence" { // A sequence with mostly ordered amino acids let ordered_seq = "AILWVFMWCILVWALMVILWAFMVCLWVILMAWLVFMAW" let result = @src.prot_dao_predict(ordered_seq) - assert_eq!(result.sequence, ordered_seq) - assert_eq!(result.residues.length(), ordered_seq.length()) - assert_eq!(result.method, "IUPred-like") + assert_eq(result.sequence, ordered_seq) + assert_eq(result.residues.length(), ordered_seq.length()) + assert_eq(result.method, "IUPred-like") } +///| test "prot_dao_predict_disordered_sequence" { // A sequence with many disorder-promoting amino acids let disordered_seq = "EPKSESEKPPPPPPKKKEEEPPPKKKSEGGSSSGGGKKKPPP" let result = @src.prot_dao_predict(disordered_seq) - assert_eq!(result.residues.length(), disordered_seq.length()) + assert_eq(result.residues.length(), disordered_seq.length()) // With many disorder-promoting residues, some should be disordered - assert_eq!(result.get_n_disordered() > 0, true) + assert_eq(result.get_n_disordered() > 0, true) } +///| test "prot_dao_predict_threshold" { let seq = "EPKSESEKPPPPPPKKKEEEPPPKKKSEGGSSSGGGKKKPPP" let result_low = @src.prot_dao_predict(seq, threshold_disordered=0.3) let result_high = @src.prot_dao_predict(seq, threshold_disordered=0.7) - assert_eq!(result_low.get_n_disordered() >= result_high.get_n_disordered(), true) + assert_eq( + result_low.get_n_disordered() >= result_high.get_n_disordered(), + true, + ) } +///| test "disorder_result_n_disordered" { let result = @src.prot_dao_sample() let n = result.get_n_disordered() - assert_eq!(n >= 0, true) - assert_eq!(n <= result.sequence.length(), true) + assert_eq(n >= 0, true) + assert_eq(n <= result.sequence.length(), true) } +///| test "disorder_result_fraction" { let result = @src.prot_dao_sample() let frac = result.get_fraction_disordered() - assert_eq!(frac >= 0.0, true) - assert_eq!(frac <= 1.0, true) + assert_eq(frac >= 0.0, true) + assert_eq(frac <= 1.0, true) } +///| test "disorder_result_regions" { let result = @src.prot_dao_sample() let regions = result.get_regions() let n_regions = result.get_n_regions() - assert_eq!(regions.length(), n_regions) + assert_eq(regions.length(), n_regions) // Each region should have valid coordinates let mut i = 0 while i < regions.length() { - assert_eq!(regions[i].start > 0 || regions[i].end_ > 0, true) - assert_eq!(regions[i].length >= 0, true) + assert_eq(regions[i].start > 0 || regions[i].end_ > 0, true) + assert_eq(regions[i].length >= 0, true) i = i + 1 } } +///| test "disorder_result_longest_region" { let result = @src.prot_dao_sample() let longest = result.get_longest_region() - assert_eq!(longest.length >= 0, true) + assert_eq(longest.length >= 0, true) if result.get_n_regions() > 0 { - assert_eq!(longest.length > 0, true) + assert_eq(longest.length > 0, true) } } +///| test "disorder_result_scores" { let result = @src.prot_dao_sample() let scores = result.get_scores() - assert_eq!(scores.length(), result.sequence.length()) + assert_eq(scores.length(), result.sequence.length()) let mut i = 0 while i < scores.length() { - assert_eq!(scores[i] >= 0.0 || scores[i] <= 0.0, true) + assert_eq(scores[i] >= 0.0 || scores[i] <= 0.0, true) i = i + 1 } } +///| test "disorder_result_summary" { let result = @src.prot_dao_sample() let summary = result.summary() - assert_eq!(summary.contains("IUPred-like"), true) - assert_eq!(summary.contains("Sequence length"), true) - assert_eq!(summary.contains("Disordered residues"), true) + assert_eq(summary.contains("IUPred-like"), true) + assert_eq(summary.contains("Sequence length"), true) + assert_eq(summary.contains("Disordered residues"), true) } +///| test "disorder_result_disordered_sequence" { let result = @src.prot_dao_sample() let ds = result.disordered_sequence() - assert_eq!(ds.length(), result.sequence.length()) + assert_eq(ds.length(), result.sequence.length()) // Disordered positions should show the amino acid // Ordered positions should show '-' } +///| test "prot_dao_sample_sequence" { let seq = @src.prot_dao_sample_sequence() - assert_eq!(seq.length() > 0, true) + assert_eq(seq.length() > 0, true) // All characters should be valid amino acids let mut i = 0 while i < seq.length() { let c = seq.unsafe_get(i) - assert_eq!(c >= 65 && c <= 90 || c >= 97 && c <= 122, true) + assert_eq((c >= 65 && c <= 90) || (c >= 97 && c <= 122), true) i = i + 1 } } +///| test "prot_dao_empty_sequence" { let result = @src.prot_dao_predict("") - assert_eq!(result.residues.length(), 0) - assert_eq!(result.get_fraction_disordered(), 0.0) - assert_eq!(result.get_n_disordered(), 0) + assert_eq(result.residues.length(), 0) + assert_eq(result.get_fraction_disordered(), 0.0) + assert_eq(result.get_n_disordered(), 0) } +///| test "prot_dao_single_residue" { let result = @src.prot_dao_predict("A") - assert_eq!(result.residues.length(), 1) - assert_eq!(result.sequence, "A") + assert_eq(result.residues.length(), 1) + assert_eq(result.sequence, "A") } +///| test "prot_dao_to_ascii" { let result = @src.prot_dao_sample() let ascii = result.to_ascii() - assert_eq!(ascii.contains("Score"), true) - assert_eq!(ascii.contains("Seq"), true) - assert_eq!(ascii.contains("Dis"), true) + assert_eq(ascii.contains("Score"), true) + assert_eq(ascii.contains("Seq"), true) + assert_eq(ascii.contains("Dis"), true) } diff --git a/test/moonbit/protein_analysis_test.mbt b/test/moonbit/protein_analysis_test.mbt index 1981c536..87430a43 100644 --- a/test/moonbit/protein_analysis_test.mbt +++ b/test/moonbit/protein_analysis_test.mbt @@ -17,12 +17,14 @@ test "protein_hydropathy_basic" { } } +///| test "protein_hydropathy_short_sequence" { let seq = "ACG" let hydro = @src.protein_hydropathy(seq, window=7) assert_eq(hydro.length(), 0) } +///| test "protein_hydropathy_custom_window" { let seq = "ACDEFGHIKLMNPQRSTVWY" let hydro5 = @src.protein_hydropathy(seq, window=5) @@ -34,6 +36,7 @@ test "protein_hydropathy_custom_window" { // Secondary Structure Prediction Tests // ============================================================================ +///| test "protein_secondary_structure_basic" { let seq = "ACDEFGHIKLMNPQRSTVWY" let ss = @src.protein_secondary_structure(seq) @@ -47,6 +50,7 @@ test "protein_secondary_structure_basic" { } } +///| test "protein_secondary_structure_all_chars" { // Test that all 20 amino acids are handled let seq = "ACDEFGHIKLMNPQRSTVWY" @@ -58,6 +62,7 @@ test "protein_secondary_structure_all_chars" { // Antigenicity Tests // ============================================================================ +///| test "protein_antigenicity_basic" { let seq = "ACDEFGHIKLMNPQRSTVWY" let antigen = @src.protein_antigenicity(seq) @@ -70,6 +75,7 @@ test "protein_antigenicity_basic" { } } +///| test "protein_antigenicity_positive_residues" { // Known antigenic residues should have positive values let antigen = @src.protein_antigenicity("RKP") @@ -82,6 +88,7 @@ test "protein_antigenicity_positive_residues" { // Transmembrane Prediction Tests // ============================================================================ +///| test "protein_transmembrane_basic" { let seq = "ACDEFGHIKLMNPQRSTVWY" let tm = @src.protein_transmembrane(seq, window=19) @@ -89,12 +96,14 @@ test "protein_transmembrane_basic" { assert_eq(tm.length(), 2) } +///| test "protein_transmembrane_short_sequence" { let seq = "ACG" let tm = @src.protein_transmembrane(seq, window=19) assert_eq(tm.length(), 0) } +///| test "protein_transmembrane_propensity" { // Known transmembrane residues should have positive scores let v_tm = @src.protein_transmembrane_propensity('V') @@ -107,6 +116,7 @@ test "protein_transmembrane_propensity" { // Amino Acid Composition Tests // ============================================================================ +///| test "protein_aa_composition_basic" { let seq = "AAL" let comp = @src.protein_aa_composition(seq) @@ -119,6 +129,7 @@ test "protein_aa_composition_basic" { assert_true(a_freq > l_freq) } +///| test "protein_aa_composition_empty" { let seq = "" let comp = @src.protein_aa_composition(seq) @@ -130,6 +141,7 @@ test "protein_aa_composition_empty" { // Dipeptide/Tripeptide Composition Tests // ============================================================================ +///| test "protein_dipeptide_composition_basic" { let seq = "ALA" let comp = @src.protein_dipeptide_composition(seq) @@ -140,12 +152,14 @@ test "protein_dipeptide_composition_basic" { assert_true(la_freq > 0.0) } +///| test "protein_dipeptide_composition_short" { let seq = "A" let comp = @src.protein_dipeptide_composition(seq) assert_eq(comp.length(), 0) } +///| test "protein_tripeptide_composition_basic" { let seq = "ALA" let comp = @src.protein_tripeptide_composition(seq) @@ -154,6 +168,7 @@ test "protein_tripeptide_composition_basic" { assert_true(ala_freq > 0.0) } +///| test "protein_tripeptide_composition_short" { let seq = "AL" let comp = @src.protein_tripeptide_composition(seq) @@ -164,6 +179,7 @@ test "protein_tripeptide_composition_short" { // Conservation Tests // ============================================================================ +///| test "protein_conservation_identical" { let alignment = ["AAAA", "AAAA", "AAAA"] let cons = @src.protein_conservation(alignment) @@ -176,6 +192,7 @@ test "protein_conservation_identical" { } } +///| test "protein_conservation_different" { let alignment = ["AAAA", "CCCC", "GGGG"] let cons = @src.protein_conservation(alignment) @@ -188,6 +205,7 @@ test "protein_conservation_different" { } } +///| test "protein_conservation_empty" { let alignment : Array[String] = [] let cons = @src.protein_conservation(alignment) @@ -198,6 +216,7 @@ test "protein_conservation_empty" { // Summary Report Tests // ============================================================================ +///| test "protein_summary_basic" { let seq = "ACDEFGHIKLMNPQRSTVWY" let summary = @src.protein_summary(seq) diff --git a/test/moonbit/proteomics_test.mbt b/test/moonbit/proteomics_test.mbt index d154364e..c05188b3 100644 --- a/test/moonbit/proteomics_test.mbt +++ b/test/moonbit/proteomics_test.mbt @@ -215,5 +215,9 @@ test "proteomics_fragment_ions_single_residue" { ///| fn abs(x : Double) -> Double { - if x < 0.0 { -x } else { x } -} \ No newline at end of file + if x < 0.0 { + -x + } else { + x + } +} diff --git a/test/moonbit/psea_test.mbt b/test/moonbit/psea_test.mbt index ae8c7e15..eec0da6c 100644 --- a/test/moonbit/psea_test.mbt +++ b/test/moonbit/psea_test.mbt @@ -146,7 +146,7 @@ test "psea_short_chain" { let atoms = [ @src.PseaAtom::new("A", 1, "CA", 0.0, 0.0, 0.0), @src.PseaAtom::new("B", 2, "CA", 1.0, 0.0, 0.0), - @src.PseaAtom::new("C", 3, "CA", 2.0, 0.0, 0.0) + @src.PseaAtom::new("C", 3, "CA", 2.0, 0.0, 0.0), ] let result = @src.psea_run(atoms) assert_eq(result.psea_n_residues(), 3) diff --git a/test/moonbit/qfeatures_test.mbt b/test/moonbit/qfeatures_test.mbt index e761cbbd..70f03acd 100644 --- a/test/moonbit/qfeatures_test.mbt +++ b/test/moonbit/qfeatures_test.mbt @@ -5,11 +5,7 @@ test "qf_assay_creation" { let row_names = ["r0", "r1", "r2"] let col_names = ["c0", "c1"] - let data : Array[Array[Double]] = [ - [1.0, 2.0], - [3.0, 4.0], - [5.0, 6.0], - ] + let data : Array[Array[Double]] = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]] let assay = @src.QfAssay::new("test", row_names, col_names, data) assert_eq(assay.name(), "test") assert_eq(assay.n_rows(), 3) @@ -55,10 +51,7 @@ test "qf_assay_get_set" { ///| test "qf_assay_get_row_get_col" { - let data : Array[Array[Double]] = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - ] + let data : Array[Array[Double]] = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let assay = @src.QfAssay::new("a", ["r0", "r1"], ["c0", "c1", "c2"], data) let row0 = assay.get_row(0) let row1 = assay.get_row(1) @@ -80,10 +73,7 @@ test "qf_assay_get_row_get_col" { ///| test "qf_assay_row_col_stats" { - let data : Array[Array[Double]] = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - ] + let data : Array[Array[Double]] = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let assay = @src.QfAssay::new("a", ["r0", "r1"], ["c0", "c1", "c2"], data) let rmeans = assay.row_means() let cmeans = assay.col_means() @@ -233,12 +223,7 @@ test "qf_aggregate_rows_sum" { qf.add_assay( @src.QfAssay::new("src", ["r0", "r1", "r2", "r3"], ["c0", "c1"], data), ) - let mapping : Array[(Int, String)] = [ - (0, "A"), - (1, "A"), - (2, "B"), - (3, "B"), - ] + let mapping : Array[(Int, String)] = [(0, "A"), (1, "A"), (2, "B"), (3, "B")] let qf2 = @src.qf_aggregate(qf, "src", "agg", mapping, "sum") assert_eq(qf2.n_assays(), 2) match qf2.get_assay("agg") { @@ -276,12 +261,7 @@ test "qf_aggregate_rows_mean" { qf.add_assay( @src.QfAssay::new("src", ["r0", "r1", "r2", "r3"], ["c0", "c1"], data), ) - let mapping : Array[(Int, String)] = [ - (0, "A"), - (1, "A"), - (2, "B"), - (3, "B"), - ] + let mapping : Array[(Int, String)] = [(0, "A"), (1, "A"), (2, "B"), (3, "B")] let qf2 = @src.qf_aggregate(qf, "src", "agg", mapping, "mean") match qf2.get_assay("agg") { Some(a) => { @@ -300,17 +280,9 @@ test "qf_aggregate_rows_mean" { ///| test "qf_aggregate_by_col_merge" { let qf = @src.QFeatures::new() - let data : Array[Array[Double]] = [ - [1.0, 2.0, 3.0, 4.0], - [5.0, 6.0, 7.0, 8.0], - ] + let data : Array[Array[Double]] = [[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]] qf.add_assay( - @src.QfAssay::new( - "src", - ["r0", "r1"], - ["c0", "c1", "c2", "c3"], - data, - ), + @src.QfAssay::new("src", ["r0", "r1"], ["c0", "c1", "c2", "c3"], data), ) let labels = ["rep1", "rep1", "rep2", "rep2"] // Sum aggregation. @@ -376,10 +348,7 @@ test "qf_filter_features" { ///| test "qf_filter_samples" { let qf = @src.QFeatures::new() - let data : Array[Array[Double]] = [ - [1.0, 2.0, 3.0, 4.0], - [5.0, 6.0, 7.0, 8.0], - ] + let data : Array[Array[Double]] = [[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]] qf.add_assay( @src.QfAssay::new("a", ["r0", "r1"], ["c0", "c1", "c2", "c3"], data), ) @@ -408,7 +377,9 @@ test "qf_filter_na" { [nan, nan, 6.0], [7.0, nan, 9.0], ] - qf.add_assay(@src.QfAssay::new("a", ["r0", "r1", "r2"], ["c0", "c1", "c2"], data)) + qf.add_assay( + @src.QfAssay::new("a", ["r0", "r1", "r2"], ["c0", "c1", "c2"], data), + ) // max_na_frac = 0.5 -> row 1 (2/3 NaN > 0.5) is dropped; row 2 (1/3 NaN) kept. let qf2 = @src.qf_filter_na(qf, "a", 0.5) match qf2.get_assay("a") { @@ -435,7 +406,9 @@ test "qf_filter_low_abundance" { [0.5, 0.5, 0.5], [10.0, 20.0, 30.0], ] - qf.add_assay(@src.QfAssay::new("a", ["r0", "r1", "r2"], ["c0", "c1", "c2"], data)) + qf.add_assay( + @src.QfAssay::new("a", ["r0", "r1", "r2"], ["c0", "c1", "c2"], data), + ) // threshold = 1.0 -> row 1 (all 0.5 < 1.0) is dropped. let qf2 = @src.qf_filter_low_abundance(qf, "a", 1.0) match qf2.get_assay("a") { @@ -452,21 +425,29 @@ test "qf_filter_low_abundance" { test "qf_normalize_quantiles" { // Construct a matrix where columns have different distributions but // after quantile normalization they should share the same sorted values. - let data : Array[Array[Double]] = [ - [5.0, 10.0], - [2.0, 20.0], - [10.0, 30.0], - ] + let data : Array[Array[Double]] = [[5.0, 10.0], [2.0, 20.0], [10.0, 30.0]] let assay = @src.QfAssay::new("a", ["r0", "r1", "r2"], ["c0", "c1"], data) let norm = @src.qf_normalize_quantiles(assay) // Compute sorted columns of normalized assay; they should be equal. let col0 = norm.get_col(0) let col1 = norm.get_col(1) col0.sort_by(fn(a : Double, b : Double) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) col1.sort_by(fn(a : Double, b : Double) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) for i in 0..<3 { assert_true((col0[i] - col1[i]).abs() < 0.001) @@ -481,11 +462,7 @@ test "qf_normalize_quantiles" { test "qf_normalize_center_scale" { // Column 0: [1, 2, 3] -> mean=2, sample std=1 // Column 1: [10, 20, 30] -> mean=20, sample std=10 - let data : Array[Array[Double]] = [ - [1.0, 10.0], - [2.0, 20.0], - [3.0, 30.0], - ] + let data : Array[Array[Double]] = [[1.0, 10.0], [2.0, 20.0], [3.0, 30.0]] let assay = @src.QfAssay::new("a", ["r0", "r1", "r2"], ["c0", "c1"], data) let norm = @src.qf_normalize_center_scale(assay, true, true) // Expected normalized values: col0 = [-1, 0, 1], col1 = [-1, 0, 1] @@ -502,10 +479,7 @@ test "qf_normalize_center_scale" { ///| test "qf_normalize_center_only" { - let data : Array[Array[Double]] = [ - [1.0, 10.0], - [3.0, 30.0], - ] + let data : Array[Array[Double]] = [[1.0, 10.0], [3.0, 30.0]] let assay = @src.QfAssay::new("a", ["r0", "r1"], ["c0", "c1"], data) let norm = @src.qf_normalize_center_scale(assay, true, false) // Col 0 mean=2 -> centered: [-1, 1] @@ -519,10 +493,7 @@ test "qf_normalize_center_only" { ///| test "qf_log_transform" { // log2(x+1): 1->1, 3->2, 7->3, 0->0 - let data : Array[Array[Double]] = [ - [1.0, 3.0], - [7.0, 0.0], - ] + let data : Array[Array[Double]] = [[1.0, 3.0], [7.0, 0.0]] let assay = @src.QfAssay::new("a", ["r0", "r1"], ["c0", "c1"], data) let logged = @src.qf_log_transform(assay, 2.0, 1.0) assert_true((logged.get(0, 0) - 1.0).abs() < 0.001) @@ -551,7 +522,12 @@ test "qf_impute_knn" { [2.0, 5.0, 4.0], [3.0, 6.0, 7.0], ] - let assay = @src.QfAssay::new("a", ["r0", "r1", "r2"], ["c0", "c1", "c2"], data) + let assay = @src.QfAssay::new( + "a", + ["r0", "r1", "r2"], + ["c0", "c1", "c2"], + data, + ) let imputed = @src.qf_impute_knn(assay, 1) assert_true(!@src.qf_is_na(imputed.get(0, 1))) assert_true((imputed.get(0, 1) - 5.0).abs() < 0.001) @@ -563,10 +539,7 @@ test "qf_impute_knn" { ///| test "qf_impute_mean" { // Col means (skip NaN): col0 = (1+4)/2 = 2.5, col1 = 5.0, col2 = (3+6)/2 = 4.5 - let data : Array[Array[Double]] = [ - [1.0, Double::nan(), 3.0], - [4.0, 5.0, 6.0], - ] + let data : Array[Array[Double]] = [[1.0, Double::nan(), 3.0], [4.0, 5.0, 6.0]] let assay = @src.QfAssay::new("a", ["r0", "r1"], ["c0", "c1", "c2"], data) let imputed = @src.qf_impute_mean(assay) assert_true((imputed.get(0, 1) - 5.0).abs() < 0.001) @@ -580,10 +553,7 @@ test "qf_impute_mean" { ///| test "qf_impute_zero" { - let data : Array[Array[Double]] = [ - [1.0, Double::nan()], - [Double::nan(), 2.0], - ] + let data : Array[Array[Double]] = [[1.0, Double::nan()], [Double::nan(), 2.0]] let assay = @src.QfAssay::new("a", ["r0", "r1"], ["c0", "c1"], data) let imputed = @src.qf_impute_zero(assay) assert_true((imputed.get(0, 0) - 1.0).abs() < 0.001) @@ -624,10 +594,7 @@ test "qf_summary" { ///| test "qf_assay_summary" { - let data : Array[Array[Double]] = [ - [1.0, 2.0], - [3.0, 4.0], - ] + let data : Array[Array[Double]] = [[1.0, 2.0], [3.0, 4.0]] let assay = @src.QfAssay::new("myassay", ["r0", "r1"], ["c0", "c1"], data) let s = @src.qf_assay_summary(assay) assert_true(s.length() > 0) @@ -639,10 +606,7 @@ test "qf_assay_summary" { ///| test "qf_to_long_format" { let qf = @src.QFeatures::new() - let data : Array[Array[Double]] = [ - [1.0, 2.0], - [3.0, 4.0], - ] + let data : Array[Array[Double]] = [[1.0, 2.0], [3.0, 4.0]] qf.add_assay(@src.QfAssay::new("a", ["r0", "r1"], ["c0", "c1"], data)) let long = @src.qf_to_long_format(qf, "a") assert_eq(long.length(), 4) @@ -761,10 +725,7 @@ test "qf_edge_case_single_cell_assay" { ///| test "qf_edge_case_all_nan_assay" { let nan = Double::nan() - let data : Array[Array[Double]] = [ - [nan, nan], - [nan, nan], - ] + let data : Array[Array[Double]] = [[nan, nan], [nan, nan]] let assay = @src.QfAssay::new("allnan", ["r0", "r1"], ["c0", "c1"], data) assert_eq(@src.qf_count_na(assay), 4) let by_row = @src.qf_count_na_by_row(assay) diff --git a/test/moonbit/qvalue_test.mbt b/test/moonbit/qvalue_test.mbt index 781214d5..acc2f062 100644 --- a/test/moonbit/qvalue_test.mbt +++ b/test/moonbit/qvalue_test.mbt @@ -210,14 +210,7 @@ test "qvalue_result_creation" { let pvals = [0.01, 0.05] let qvals = [0.02, 0.06] let sig = [true, false] - let result = @src.QValueResult::new( - pvals, - qvals, - 0.8, - 0.5, - 0.75, - sig, - ) + let result = @src.QValueResult::new(pvals, qvals, 0.8, 0.5, 0.75, sig) assert_eq(result.p_values().length(), 2) assert_eq(result.q_values().length(), 2) assert_true(result.pi0() > 0.79 && result.pi0() < 0.81) @@ -348,4 +341,4 @@ test "qvalue_near_zero" { assert_true(qvals[i] >= 0.0 && qvals[i] <= 1.0) i = i + 1 } -} \ No newline at end of file +} diff --git a/test/moonbit/ragged_experiment_test.mbt b/test/moonbit/ragged_experiment_test.mbt index de7f7167..e6094b91 100644 --- a/test/moonbit/ragged_experiment_test.mbt +++ b/test/moonbit/ragged_experiment_test.mbt @@ -1,11 +1,13 @@ ///| /// Test file for RaggedExperiment module. - test "mutation_record_creation" { let mr = @src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", ) assert_eq(mr.sample_id, "S1") assert_eq(mr.gene_symbol, "TP53") @@ -14,43 +16,58 @@ test "mutation_record_creation" { assert_eq(mr.mutation_type, @src.mutation_missense()) } +///| test "mutation_record_mutation_id" { let mr = @src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", ) let id = mr.mutation_id() assert_true(id.contains("TP53")) assert_true(id.contains("chr17")) } +///| test "mutation_record_is_los" { let missense = @src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", mutation_type=@src.mutation_missense(), ) assert_false(missense.is_loss_of_function()) let nonsense = @src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", mutation_type=@src.mutation_nonsense(), ) assert_true(nonsense.is_loss_of_function()) let fs = @src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", mutation_type=@src.mutation_fs_del(), ) assert_true(fs.is_loss_of_function()) } +///| test "mutation_type_to_string" { assert_eq(@src.mutation_missense().to_string(), "Missense_Mutation") assert_eq(@src.mutation_nonsense().to_string(), "Nonsense_Mutation") @@ -60,112 +77,182 @@ test "mutation_type_to_string" { assert_eq(@src.mutation_silent().to_string(), "Silent_Mutation") } +///| test "ragged_experiment_empty" { let exp = @src.RaggedExperiment::new() assert_eq(exp.n_rows(), 0) assert_eq(exp.n_cols(), 0) } +///| test "ragged_experiment_add_record" { let exp = @src.RaggedExperiment::new() let mr = @src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", ) exp.add_record(mr) assert_eq(exp.n_rows(), 1) assert_eq(exp.n_cols(), 1) } +///| test "ragged_experiment_multiple_genes" { let exp = @src.RaggedExperiment::new() - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="KRAS", - chrom="chr12", pos=25398284, - ref_allele="G", alt_allele="T", - )) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="KRAS", + chrom="chr12", + pos=25398284, + ref_allele="G", + alt_allele="T", + ), + ) assert_eq(exp.n_rows(), 2) assert_eq(exp.n_cols(), 1) } +///| test "ragged_experiment_multiple_samples" { let exp = @src.RaggedExperiment::new() - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S2", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S2", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) assert_eq(exp.n_rows(), 1) assert_eq(exp.n_cols(), 2) } +///| test "ragged_experiment_get_records" { let exp = @src.RaggedExperiment::new() - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7578000, - ref_allele="G", alt_allele="A", - )) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7578000, + ref_allele="G", + alt_allele="A", + ), + ) let recs = exp.get_records(gene="TP53", sample="S1") assert_eq(recs.length(), 2) } +///| test "ragged_experiment_get_gene_records" { let exp = @src.RaggedExperiment::new() - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S2", gene_symbol="TP53", - chrom="chr17", pos=7578000, - ref_allele="G", alt_allele="A", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="KRAS", - chrom="chr12", pos=25398284, - ref_allele="G", alt_allele="T", - )) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S2", + gene_symbol="TP53", + chrom="chr17", + pos=7578000, + ref_allele="G", + alt_allele="A", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="KRAS", + chrom="chr12", + pos=25398284, + ref_allele="G", + alt_allele="T", + ), + ) let tp53_recs = exp.get_gene_records(gene="TP53") assert_eq(tp53_recs.length(), 2) } +///| test "ragged_experiment_get_sample_records" { let exp = @src.RaggedExperiment::new() - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="KRAS", - chrom="chr12", pos=25398284, - ref_allele="G", alt_allele="T", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S2", gene_symbol="MYC", - chrom="chr8", pos=128748315, - ref_allele="C", alt_allele="A", - )) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="KRAS", + chrom="chr12", + pos=25398284, + ref_allele="G", + alt_allele="T", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S2", + gene_symbol="MYC", + chrom="chr8", + pos=128748315, + ref_allele="C", + alt_allele="A", + ), + ) let s1_recs = exp.get_sample_records(sample="S1") assert_eq(s1_recs.length(), 2) @@ -174,23 +261,39 @@ test "ragged_experiment_get_sample_records" { assert_eq(s2_recs.length(), 1) } +///| test "ragged_experiment_tmb" { let exp = @src.RaggedExperiment::new() - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="KRAS", - chrom="chr12", pos=25398284, - ref_allele="G", alt_allele="T", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S2", gene_symbol="TP53", - chrom="chr17", pos=7578000, - ref_allele="G", alt_allele="A", - )) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="KRAS", + chrom="chr12", + pos=25398284, + ref_allele="G", + alt_allele="T", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S2", + gene_symbol="TP53", + chrom="chr17", + pos=7578000, + ref_allele="G", + alt_allele="A", + ), + ) let tmb = exp.get_tmb() assert_eq(tmb.length(), 2) @@ -198,66 +301,84 @@ test "ragged_experiment_tmb" { assert_eq(tmb[1], 1.0) } +///| test "ragged_experiment_tmb_per_mb" { let exp = @src.RaggedExperiment::new() - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) let tmb_mb = exp.get_tmb_per_mb(genome_size_mb=3000.0) assert_true(tmb_mb.length() > 0) assert_true(tmb_mb[0] > 0.0) } +///| test "ragged_experiment_summary" { let exp = @src.RaggedExperiment::new() - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) let summary = exp.summary() assert_true(summary.length() > 0) } +///| test "ragged_experiment_filter_by_type" { let exp = @src.ragged_sample_data() let types : Array[@src.MutationType] = Array::new() types.push(@src.mutation_nonsense()) - let filtered = exp.filter_by_type(types=types) + let filtered = exp.filter_by_type(types~) assert_true(filtered.n_rows() > 0) } +///| test "ragged_experiment_filter_by_genes" { let exp = @src.ragged_sample_data() let genes : Array[String] = Array::new() genes.push("TP53") - let filtered = exp.filter_by_genes(genes=genes) + let filtered = exp.filter_by_genes(genes~) assert_eq(filtered.n_rows(), 1) } +///| test "ragged_experiment_filter_by_samples" { let exp = @src.ragged_sample_data() let samples : Array[String] = Array::new() samples.push("Sample1") - let filtered = exp.filter_by_samples(samples=samples) + let filtered = exp.filter_by_samples(samples~) assert_eq(filtered.n_cols(), 1) } +///| test "ragged_experiment_genes_mutated_per_sample" { let exp = @src.ragged_sample_data() let mutated = exp.genes_mutated_per_sample() assert_true(mutated.length() > 0) } +///| test "ragged_experiment_count_matrix" { let exp = @src.ragged_sample_data() let matrix = exp.get_count_matrix() assert_true(matrix.length() > 0) } +///| test "ragged_sample_data" { let exp = @src.ragged_sample_data() assert_true(exp.n_rows() > 0) diff --git a/test/moonbit/ranged_summarized_experiment_test.mbt b/test/moonbit/ranged_summarized_experiment_test.mbt index 634e79ae..a0f759dd 100644 --- a/test/moonbit/ranged_summarized_experiment_test.mbt +++ b/test/moonbit/ranged_summarized_experiment_test.mbt @@ -1,52 +1,45 @@ ///| fn rse_test_object() -> @src.RangedSummarizedExperiment { - try { - @src.RangedSummarizedExperiment::new( - assays=Map([ - ( - "counts", - [ - [30.0, 31.0, 32.0], - [10.0, 11.0, 12.0], - [20.0, 21.0, 22.0], - [40.0, 41.0, 42.0], - ], - ), - ( - "normalized", - [ - [3.0, 3.1, 3.2], - [1.0, 1.1, 1.2], - [2.0, 2.1, 2.2], - [4.0, 4.1, 4.2], - ], - ), - ]), - row_ranges=@src.granges( - ["chr2", "chr1", "chr1", "chr3"], - [(300, 349), (100, 149), (200, 249), (50, 99)], + @src.RangedSummarizedExperiment::new( + assays=Map([ + ( + "counts", [ - @src.strand_plus(), - @src.strand_plus(), - @src.strand_minus(), - @src.strand_star(), + [30.0, 31.0, 32.0], + [10.0, 11.0, 12.0], + [20.0, 21.0, 22.0], + [40.0, 41.0, 42.0], ], ), - col_data=[ - Map([("sample", "S1")]), - Map([("sample", "S2")]), - Map([("sample", "S3")]), - ], - row_data=[ - Map([("type", "geneC")]), - Map([("type", "geneA")]), - Map([("type", "geneB")]), - Map([("type", "geneD")]), + ( + "normalized", + [[3.0, 3.1, 3.2], [1.0, 1.1, 1.2], [2.0, 2.1, 2.2], [4.0, 4.1, 4.2]], + ), + ]), + row_ranges=@src.granges( + ["chr2", "chr1", "chr1", "chr3"], + [(300, 349), (100, 149), (200, 249), (50, 99)], + [ + @src.strand_plus(), + @src.strand_plus(), + @src.strand_minus(), + @src.strand_star(), ], - row_names=["geneC", "geneA", "geneB", "geneD"], - metadata=Map([("study", "airway-like")]), - ) - } catch { + ), + col_data=[ + Map([("sample", "S1")]), + Map([("sample", "S2")]), + Map([("sample", "S3")]), + ], + row_data=[ + Map([("type", "geneC")]), + Map([("type", "geneA")]), + Map([("type", "geneB")]), + Map([("type", "geneD")]), + ], + row_names=["geneC", "geneA", "geneB", "geneD"], + metadata=Map([("study", "airway-like")]), + ) catch { _ => abort("failed to construct RangedSummarizedExperiment fixture") } } @@ -75,12 +68,7 @@ test "ranged_summarized_experiment: rejects assay row mismatch" { ignore( @src.RangedSummarizedExperiment::new( assays=Map([("counts", [[1.0, 2.0], [3.0, 4.0]])]), - row_ranges=@src.granges_single( - "chr1", - 1, - 10, - @src.strand_plus(), - ), + row_ranges=@src.granges_single("chr1", 1, 10, @src.strand_plus()), col_data=[Map([]), Map([])], ), ) @@ -97,11 +85,10 @@ test "ranged_summarized_experiment: rejects parallel annotation mismatch" { ignore( @src.RangedSummarizedExperiment::new( assays=Map([("counts", [[1.0], [2.0]])]), - row_ranges=@src.granges( - ["chr1", "chr1"], - [(1, 10), (20, 30)], - [@src.strand_plus(), @src.strand_plus()], - ), + row_ranges=@src.granges(["chr1", "chr1"], [(1, 10), (20, 30)], [ + @src.strand_plus(), + @src.strand_plus(), + ]), col_data=[Map([])], row_data=[Map([("id", "only-one")])], ), @@ -121,17 +108,14 @@ test "ranged_summarized_experiment: attach ranges to existing experiment" { [Map([("sample", "A")]), Map([("sample", "B")])], Map([("source", "existing")]), ) - let rse = try { - @src.RangedSummarizedExperiment::from_experiment( - experiment~, - row_ranges=@src.granges( - ["chr1", "chr2"], - [(10, 20), (30, 40)], - [@src.strand_plus(), @src.strand_minus()], - ), - row_names=["a", "b"], - ) - } catch { + let rse = @src.RangedSummarizedExperiment::from_experiment( + experiment~, + row_ranges=@src.granges(["chr1", "chr2"], [(10, 20), (30, 40)], [ + @src.strand_plus(), + @src.strand_minus(), + ]), + row_names=["a", "b"], + ) catch { _ => abort("failed to attach ranges") } assert_true(rse.is_valid()) @@ -201,10 +185,12 @@ test "ranged_summarized_experiment: strand-aware overlaps" { assert_eq(rse.find_overlaps(subject), [(0, 3), (1, 0), (3, 2)]) assert_eq(rse.count_overlaps(subject), [1, 1, 0, 1]) assert_eq(rse.overlaps_any(subject), [true, true, false, true]) - assert_eq( - rse.find_overlaps(subject, ignore_strand=true), - [(0, 3), (1, 0), (2, 1), (3, 2)], - ) + assert_eq(rse.find_overlaps(subject, ignore_strand=true), [ + (0, 3), + (1, 0), + (2, 1), + (3, 2), + ]) } ///| @@ -218,8 +204,7 @@ test "ranged_summarized_experiment: subset by overlaps keeps each row once" { assert_eq(subset.nrow(), 2) assert_eq(subset.row_names(), ["geneA", "geneB"]) match subset.assay("counts") { - Some(assay) => - assert_eq(assay, [[10.0, 11.0, 12.0], [20.0, 21.0, 22.0]]) + Some(assay) => assert_eq(assay, [[10.0, 11.0, 12.0], [20.0, 21.0, 22.0]]) None => assert_true(false) } } @@ -238,11 +223,7 @@ test "ranged_summarized_experiment: nearest and distance" { ///| test "ranged_summarized_experiment: coverage delegates to row ranges" { - let sequence_lengths = Map([ - ("chr1", 260), - ("chr2", 350), - ("chr3", 100), - ]) + let sequence_lengths = Map([("chr1", 260), ("chr2", 350), ("chr3", 100)]) let coverage = rse_test_object().coverage(sequence_lengths) assert_eq(coverage["chr1"][99], 1) assert_eq(coverage["chr1"][149], 0) @@ -318,13 +299,11 @@ test "ranged_summarized_experiment: replacing ranges validates length" { ///| test "ranged_summarized_experiment: empty container" { - let rse = try { - @src.RangedSummarizedExperiment::new( - assays=Map([]), - row_ranges=@src.granges([], [], []), - col_data=[], - ) - } catch { + let rse = @src.RangedSummarizedExperiment::new( + assays=Map([]), + row_ranges=@src.granges([], [], []), + col_data=[], + ) catch { _ => abort("failed to construct empty RangedSummarizedExperiment") } assert_true(rse.is_valid()) diff --git a/test/moonbit/reference_test.mbt b/test/moonbit/reference_test.mbt index a8dadb76..e936cc79 100644 --- a/test/moonbit/reference_test.mbt +++ b/test/moonbit/reference_test.mbt @@ -1,32 +1,43 @@ ///| /// Test file for reference module. - test "reference_create_basic" { - let r = @src.BioReference::new(title="Test Paper", authors="Smith J", journal="Nature", year="2024") - assert_eq!(r.title(), "Test Paper") - assert_eq!(r.authors(), "Smith J") - assert_eq!(r.journal(), "Nature") - assert_eq!(r.year(), "2024") - assert_eq!(r.pubmed_id(), "") - assert_eq!(r.doi(), "") - assert_eq!(r.reference_type(), "journal article") + let r = @src.BioReference::new( + title="Test Paper", + authors="Smith J", + journal="Nature", + year="2024", + ) + assert_eq(r.title(), "Test Paper") + assert_eq(r.authors(), "Smith J") + assert_eq(r.journal(), "Nature") + assert_eq(r.year(), "2024") + assert_eq(r.pubmed_id(), "") + assert_eq(r.doi(), "") + assert_eq(r.reference_type(), "journal article") } +///| test "reference_with_pubmed" { - let r = @src.BioReference::with_pubmed("CRISPR Advances", "Doudna J", "Science", "2020", "12345678") - assert_eq!(r.pubmed_id(), "12345678") - assert_eq!(r.title(), "CRISPR Advances") + let r = @src.BioReference::with_pubmed( + "CRISPR Advances", "Doudna J", "Science", "2020", "12345678", + ) + assert_eq(r.pubmed_id(), "12345678") + assert_eq(r.title(), "CRISPR Advances") let citation = r.citation() - assert_eq!(citation.contains("12345678"), true) - assert_eq!(citation.contains("Doudna J"), true) + assert_eq(citation.contains("12345678"), true) + assert_eq(citation.contains("Doudna J"), true) } +///| test "reference_with_doi" { - let r = @src.BioReference::with_doi("Protein Folding", "Jones A", "Cell", "2023", "10.1000/test") - assert_eq!(r.doi(), "10.1000/test") - assert_eq!(r.citation().contains("10.1000/test"), true) + let r = @src.BioReference::with_doi( + "Protein Folding", "Jones A", "Cell", "2023", "10.1000/test", + ) + assert_eq(r.doi(), "10.1000/test") + assert_eq(r.citation().contains("10.1000/test"), true) } +///| test "reference_setters" { let r = @src.BioReference::new() r.set_title("New Title") @@ -36,107 +47,132 @@ test "reference_setters" { r.set_pubmed_id("99999") r.set_doi("10.999/test") r.set_type("book") - assert_eq!(r.title(), "New Title") - assert_eq!(r.authors(), "New Author") - assert_eq!(r.journal(), "New Journal") - assert_eq!(r.year(), "2025") - assert_eq!(r.pubmed_id(), "99999") - assert_eq!(r.doi(), "10.999/test") - assert_eq!(r.reference_type(), "book") + assert_eq(r.title(), "New Title") + assert_eq(r.authors(), "New Author") + assert_eq(r.journal(), "New Journal") + assert_eq(r.year(), "2025") + assert_eq(r.pubmed_id(), "99999") + assert_eq(r.doi(), "10.999/test") + assert_eq(r.reference_type(), "book") } +///| test "reference_locations" { let r = @src.BioReference::new(title="Test", authors="A") r.add_location(1, 100) r.add_location(200, 350) - assert_eq!(r.get_n_locations(), 2) + assert_eq(r.get_n_locations(), 2) let (s1, e1) = r.get_location(0) - assert_eq!(s1, 1) - assert_eq!(e1, 100) + assert_eq(s1, 1) + assert_eq(e1, 100) let (s2, e2) = r.get_location(1) - assert_eq!(s2, 200) - assert_eq!(e2, 350) + assert_eq(s2, 200) + assert_eq(e2, 350) // Out of bounds returns (0,0) let (s3, e3) = r.get_location(5) - assert_eq!(s3, 0) - assert_eq!(e3, 0) + assert_eq(s3, 0) + assert_eq(e3, 0) } +///| test "reference_comment" { let r = @src.BioReference::new(title="Test", authors="A") r.set_comment("Important discovery") - assert_eq!(r.get_comment(), "Important discovery") + assert_eq(r.get_comment(), "Important discovery") } +///| test "reference_citation" { - let r = @src.BioReference::with_pubmed("Genome Study", "Smith J, Jones A", "Science", "2022", "12345") + let r = @src.BioReference::with_pubmed( + "Genome Study", "Smith J, Jones A", "Science", "2022", "12345", + ) let citation = r.citation() - assert_eq!(citation.contains("Smith J"), true) - assert_eq!(citation.contains("Genome Study"), true) - assert_eq!(citation.contains("Science"), true) - assert_eq!(citation.contains("2022"), true) - assert_eq!(citation.contains("PMID: 12345"), true) + assert_eq(citation.contains("Smith J"), true) + assert_eq(citation.contains("Genome Study"), true) + assert_eq(citation.contains("Science"), true) + assert_eq(citation.contains("2022"), true) + assert_eq(citation.contains("PMID: 12345"), true) } +///| test "reference_list_basic" { let list = @src.ReferenceList::new() - assert_eq!(list.count(), 0) + assert_eq(list.count(), 0) let r = @src.BioReference::new(title="Test", authors="A") list.add(r) - assert_eq!(list.count(), 1) + assert_eq(list.count(), 1) let retrieved = list.get(0) - assert_eq!(retrieved.title(), "Test") + assert_eq(retrieved.title(), "Test") } +///| test "reference_list_by_author" { let list = @src.ReferenceList::new() list.add(@src.BioReference::new(title="Paper 1", authors="Smith J")) list.add(@src.BioReference::new(title="Paper 2", authors="Jones A")) list.add(@src.BioReference::new(title="Paper 3", authors="Smith J, Lee K")) let smith_papers = list.by_author("Smith J") - assert_eq!(smith_papers.length(), 2) + assert_eq(smith_papers.length(), 2) let jones_papers = list.by_author("Jones A") - assert_eq!(jones_papers.length(), 1) + assert_eq(jones_papers.length(), 1) let doe_papers = list.by_author("Doe X") - assert_eq!(doe_papers.length(), 0) + assert_eq(doe_papers.length(), 0) } +///| test "reference_list_by_year" { let list = @src.ReferenceList::new() list.add(@src.BioReference::new(title="Paper 1", year="2020")) list.add(@src.BioReference::new(title="Paper 2", year="2022")) list.add(@src.BioReference::new(title="Paper 3", year="2020")) let y2020 = list.by_year("2020") - assert_eq!(y2020.length(), 2) + assert_eq(y2020.length(), 2) let y2022 = list.by_year("2022") - assert_eq!(y2022.length(), 1) + assert_eq(y2022.length(), 1) } +///| test "reference_list_with_pubmed" { let list = @src.ReferenceList::new() list.add(@src.BioReference::with_pubmed("P1", "A", "J", "2020", "11111")) list.add(@src.BioReference::new(title="P2", authors="B")) list.add(@src.BioReference::with_pubmed("P3", "C", "J", "2022", "22222")) let with_pm = list.with_pubmed() - assert_eq!(with_pm.length(), 2) + assert_eq(with_pm.length(), 2) } +///| test "reference_list_bibliography" { let list = @src.ReferenceList::new() - list.add(@src.BioReference::new(title="Paper 1", authors="Smith J", journal="Nature", year="2020")) - list.add(@src.BioReference::new(title="Paper 2", authors="Jones A", journal="Science", year="2022")) + list.add( + @src.BioReference::new( + title="Paper 1", + authors="Smith J", + journal="Nature", + year="2020", + ), + ) + list.add( + @src.BioReference::new( + title="Paper 2", + authors="Jones A", + journal="Science", + year="2022", + ), + ) let bib = list.bibliography() - assert_eq!(bib.contains("1. Smith J"), true) - assert_eq!(bib.contains("2. Jones A"), true) - assert_eq!(bib.contains("Nature"), true) - assert_eq!(bib.contains("Science"), true) + assert_eq(bib.contains("1. Smith J"), true) + assert_eq(bib.contains("2. Jones A"), true) + assert_eq(bib.contains("Nature"), true) + assert_eq(bib.contains("Science"), true) } +///| test "reference_sample_data" { let list = @src.reference_sample_data() - assert_eq!(list.count(), 3) + assert_eq(list.count(), 3) let ref1 = list.get(0) - assert_eq!(ref1.title(), "The Human Genome: A Complete Sequence") - assert_eq!(ref1.pubmed_id(), "36189102") - assert_eq!(ref1.get_n_locations(), 1) + assert_eq(ref1.title(), "The Human Genome: A Complete Sequence") + assert_eq(ref1.pubmed_id(), "36189102") + assert_eq(ref1.get_n_locations(), 1) } diff --git a/test/moonbit/reporting_tools_test.mbt b/test/moonbit/reporting_tools_test.mbt index b11be733..14b1b9ec 100644 --- a/test/moonbit/reporting_tools_test.mbt +++ b/test/moonbit/reporting_tools_test.mbt @@ -1,6 +1,5 @@ ///| /// Test file for ReportingTools module. - test "report_new" { let doc = @src.ReportDocument::new("Test Report") assert_eq(doc.get_title(), "Test Report") @@ -8,12 +7,14 @@ test "report_new" { assert_eq(doc.get_n_sections(), 0) } +///| test "report_set_author" { let doc = @src.ReportDocument::new("Test") let doc2 = doc.set_author("User") assert_eq(doc2.get_author(), "User") } +///| test "report_add_text" { let doc = @src.ReportDocument::new("Test") let doc2 = doc.add_text("sec1", "Introduction", "This is a test report.") @@ -22,20 +23,29 @@ test "report_add_text" { assert_eq(sec.title, "Introduction") } +///| test "report_add_table" { let doc = @src.ReportDocument::new("Test") - let table = @src.ReportTable::new("table1", "Results", ["Gene", "log2FC", "p-value"], [["TP53", "BRCA1"], ["2.5", "-3.0"], ["0.001", "0.005"]], "Differential expression results") + let table = @src.ReportTable::new( + "table1", + "Results", + ["Gene", "log2FC", "p-value"], + [["TP53", "BRCA1"], ["2.5", "-3.0"], ["0.001", "0.005"]], + "Differential expression results", + ) let doc2 = doc.add_table("tab1", table) assert_eq(doc2.get_n_tables(), 1) assert_eq(doc2.get_n_sections(), 1) } +///| test "report_add_plot" { let doc = @src.ReportDocument::new("Test") let doc2 = doc.add_plot("plot1", "Volcano Plot", " +\n o\n----\n") assert_eq(doc2.get_n_sections(), 1) } +///| test "report_get_section" { let doc = @src.ReportDocument::new("Test") let doc2 = doc.add_text("sec1", "Section 1", "Content 1") @@ -44,12 +54,14 @@ test "report_get_section" { assert_eq(sec.content, "Content 1") } +///| test "report_get_section_not_found" { let doc = @src.ReportDocument::new("Test") let sec = doc.get_section("nonexistent") assert_eq(sec.section_id, "") } +///| test "report_column_new" { let col = @src.ReportColumn::new("Gene", ["TP53", "BRCA1"], false) assert_eq(col.name, "Gene") @@ -57,21 +69,36 @@ test "report_column_new" { assert_eq(col.numeric, false) } +///| test "report_table_new" { - let table = @src.ReportTable::new("t1", "Test Table", ["A", "B"], [["x", "y"], ["1", "2"]], "A test caption") + let table = @src.ReportTable::new( + "t1", + "Test Table", + ["A", "B"], + [["x", "y"], ["1", "2"]], + "A test caption", + ) assert_eq(table.get_n_rows(), 2) assert_eq(table.get_n_columns(), 2) assert_eq(table.get_column_names(), ["A", "B"]) } +///| test "report_table_to_ascii" { - let table = @src.ReportTable::new("t1", "Test", ["Name", "Value"], [["Item1", "Item2"], ["100", "200"]], "Caption") + let table = @src.ReportTable::new( + "t1", + "Test", + ["Name", "Value"], + [["Item1", "Item2"], ["100", "200"]], + "Caption", + ) let ascii = table.to_ascii() assert_true(ascii.contains("Test")) assert_true(ascii.contains("Name")) assert_true(ascii.contains("Item1")) } +///| test "report_render" { let doc = @src.ReportDocument::new("My Report") let doc2 = doc.add_text("intro", "Introduction", "This is the introduction.") @@ -82,6 +109,7 @@ test "report_render" { assert_true(rendered.contains("Methods")) } +///| test "report_summary" { let doc = @src.ReportDocument::new("Test") let doc2 = doc.add_text("sec1", "Section", "Content") @@ -90,6 +118,7 @@ test "report_summary" { assert_true(summary.contains("Sections: 1")) } +///| test "report_multiple_sections" { let doc = @src.ReportDocument::new("Multi") let doc2 = doc.add_text("s1", "S1", "C1") @@ -98,14 +127,21 @@ test "report_multiple_sections" { assert_eq(doc4.get_n_sections(), 3) } +///| test "report_table_from_columns" { let col1 = @src.ReportColumn::new("Gene", ["TP53", "BRCA1"], false) let col2 = @src.ReportColumn::new("log2FC", ["2.5", "-3.0"], true) - let table = @src.ReportTable::from_columns("t1", "Results", [col1, col2], "DE results") + let table = @src.ReportTable::from_columns( + "t1", + "Results", + [col1, col2], + "DE results", + ) assert_eq(table.get_n_columns(), 2) assert_eq(table.get_n_rows(), 2) } +///| test "report_section_type_to_string" { let text = @src.report_section_text() assert_eq(text.to_string(), "text") @@ -115,14 +151,22 @@ test "report_section_type_to_string" { assert_eq(plot.to_string(), "plot") } +///| test "report_render_with_table" { let doc = @src.ReportDocument::new("Test with Table") - let table = @src.ReportTable::new("results", "Results", ["Gene", "Value"], [["A", "B"], ["1", "2"]], "") + let table = @src.ReportTable::new( + "results", + "Results", + ["Gene", "Value"], + [["A", "B"], ["1", "2"]], + "", + ) let doc2 = doc.add_table("tab", table) let rendered = doc2.render() assert_true(rendered.contains("Results")) } +///| test "report_empty_render" { let doc = @src.ReportDocument::new("Empty Report") let rendered = doc.render() @@ -130,10 +174,17 @@ test "report_empty_render" { assert_true(rendered.contains("Sections: 0")) } +///| test "report_padding_func" { // Test that the pad logic works through to_ascii - let table = @src.ReportTable::new("t1", "Pad Test", ["Col1", "Col2"], [["Short", "LongerValue"], ["1", "2"]], "") + let table = @src.ReportTable::new( + "t1", + "Pad Test", + ["Col1", "Col2"], + [["Short", "LongerValue"], ["1", "2"]], + "", + ) let ascii = table.to_ascii() assert_true(ascii.contains("Short")) assert_true(ascii.contains("LongerValue")) -} \ No newline at end of file +} diff --git a/test/moonbit/residue_depth_test.mbt b/test/moonbit/residue_depth_test.mbt index edf593a9..1882e782 100644 --- a/test/moonbit/residue_depth_test.mbt +++ b/test/moonbit/residue_depth_test.mbt @@ -83,9 +83,7 @@ test "residue_depth_analyze" { ///| test "residue_depth_find_surface" { - let atoms1 = [ - @src.RDAtom::new("CA", @src.RDPoint3D::new(0.0, 0.0, 0.0), "C"), - ] + let atoms1 = [@src.RDAtom::new("CA", @src.RDPoint3D::new(0.0, 0.0, 0.0), "C")] let atoms2 = [ @src.RDAtom::new("CA", @src.RDPoint3D::new(100.0, 0.0, 0.0), "C"), ] @@ -106,9 +104,7 @@ test "residue_depth_find_core" { @src.RDAtom::new("CB", @src.RDPoint3D::new(0.5, 0.5, 0.5), "C"), @src.RDAtom::new("CG", @src.RDPoint3D::new(1.0, 1.0, 1.0), "C"), ] - let atoms2 = [ - @src.RDAtom::new("CA", @src.RDPoint3D::new(2.0, 0.0, 0.0), "C"), - ] + let atoms2 = [@src.RDAtom::new("CA", @src.RDPoint3D::new(2.0, 0.0, 0.0), "C")] let residues = [ @src.RDResidue::new("ALA", 1, atoms1), @src.RDResidue::new("GLY", 2, atoms2), @@ -130,4 +126,4 @@ test "residue_depth_average" { assert_eq(avg_ca, 3.0) assert_eq(avg_com, 4.0) -} \ No newline at end of file +} diff --git a/test/moonbit/rhdf5_test.mbt b/test/moonbit/rhdf5_test.mbt index cce6ad31..89052773 100644 --- a/test/moonbit/rhdf5_test.mbt +++ b/test/moonbit/rhdf5_test.mbt @@ -1,59 +1,83 @@ ///| /// Tests for rhdf5 module. - test "HDF5Attribute creation" { - let attr = @src.HDF5Attribute::new("species", "H5T_NATIVE_STRING", "Homo sapiens") + let attr = @src.HDF5Attribute::new( + "species", "H5T_NATIVE_STRING", "Homo sapiens", + ) assert_eq(attr.name, "species") } +///| test "HDF5Dataset creation" { let ds = @src.HDF5Dataset::new("expression", "H5T_NATIVE_DOUBLE", [100, 10]) assert_eq(ds.name, "expression") assert_eq(ds.dimensions.length(), 2) } +///| test "HDF5Group creation" { let group = @src.HDF5Group::new("/genome") assert_eq(group.name, "/genome") } +///| test "HDF5File creation" { let file = @src.h5create_file("test.h5") assert_eq(file.filename, "test.h5") } +///| test "h5create_dataset simple" { let file = @src.h5create_file("test.h5") - let file2 = @src.h5create_dataset(file, "/data/matrix", "H5T_NATIVE_DOUBLE", [3, 3]) + let file2 = @src.h5create_dataset(file, "/data/matrix", "H5T_NATIVE_DOUBLE", [ + 3, 3, + ]) let result = @src.h5read_dataset(file2, "/data/matrix") assert_true(result is Some(_)) } +///| test "h5write_dataset simple" { let file = @src.h5create_file("test.h5") - let file2 = @src.h5write_dataset(file, "/seq/dna", "ACGTACGT", "H5T_NATIVE_STRING", [8]) + let file2 = @src.h5write_dataset( + file, + "/seq/dna", + "ACGTACGT", + "H5T_NATIVE_STRING", + [8], + ) let result = @src.h5read_dataset(file2, "/seq/dna") assert_true(result is Some(_)) } +///| test "h5read_dataset" { let file = @src.h5create_file("test.h5") - let file2 = @src.h5write_dataset(file, "/data/values", "1.0,2.0,3.0", "H5T_NATIVE_DOUBLE", [3]) + let file2 = @src.h5write_dataset( + file, + "/data/values", + "1.0,2.0,3.0", + "H5T_NATIVE_DOUBLE", + [3], + ) let result = @src.h5read_dataset(file2, "/data/values") assert_true(result is Some(_)) } +///| test "h5ls" { let file = @src.h5create_example_file() let listing = @src.h5ls(file) assert_true(listing.length() > 0) } +///| test "h5create_example_file" { let file = @src.h5create_example_file() assert_eq(file.filename, "example.h5") } +///| test "HDF5Dataset add_attribute" { let ds = @src.HDF5Dataset::new("test", "H5T_NATIVE_INT", [10]) let attr = @src.HDF5Attribute::new("unit", "H5T_NATIVE_STRING", "counts") @@ -61,12 +85,14 @@ test "HDF5Dataset add_attribute" { assert_true(ds_with_attr.get_attribute("unit") is Some(_)) } +///| test "HDF5Group find_group" { let group = @src.HDF5Group::new("test") let result = group.find_group("data") assert_true(result is None) } +///| test "HDF5Group find_dataset" { let group = @src.HDF5Group::new("test") let result = group.find_dataset("data") diff --git a/test/moonbit/rna_structure_test.mbt b/test/moonbit/rna_structure_test.mbt index 39e87023..ad727a8e 100644 --- a/test/moonbit/rna_structure_test.mbt +++ b/test/moonbit/rna_structure_test.mbt @@ -1,6 +1,7 @@ ///| /// Tests for Bio.SeqUtils - RNA Secondary Structure Prediction +///| /// Helper: convert String to Array[UInt16] fn str_to_u16_array(s : String) -> Array[UInt16] { let arr : Array[UInt16] = Array::new() @@ -10,6 +11,7 @@ fn str_to_u16_array(s : String) -> Array[UInt16] { arr } +///| /// Helper: convert Char to UInt16 fn char_to_u16(c : Char) -> UInt16 { c.to_int().to_uint16() @@ -121,7 +123,9 @@ test "structure_to_dot_bracket" { assert_eq(dot.length(), seq.length()) for c in dot { let ch = c.to_int().to_uint16() - assert_true(ch == char_to_u16('(') || ch == char_to_u16(')') || ch == char_to_u16('.')) + assert_true( + ch == char_to_u16('(') || ch == char_to_u16(')') || ch == char_to_u16('.'), + ) } } @@ -171,9 +175,13 @@ test "valid_dot_bracket" { let dot = result.structure let mut open_count = 0 for c in dot { - if c == '(' { open_count = open_count + 1 } - if c == ')' { open_count = open_count - 1 } + if c == '(' { + open_count = open_count + 1 + } + if c == ')' { + open_count = open_count - 1 + } assert_true(open_count >= 0) } assert_eq(open_count, 0) -} \ No newline at end of file +} diff --git a/test/moonbit/rstatix_test.mbt b/test/moonbit/rstatix_test.mbt index b051b5fb..87ece02f 100644 --- a/test/moonbit/rstatix_test.mbt +++ b/test/moonbit/rstatix_test.mbt @@ -2,6 +2,7 @@ // ===== rstatix_t_test ===== +///| test "rstatix_t_test one-sample basic" { let x = [10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0] let result = @src.rstatix_t_test(x, mu=15.0) @@ -15,6 +16,7 @@ test "rstatix_t_test one-sample basic" { assert_eq(result.alternative, "two.sided") } +///| test "rstatix_t_test one-sample greater alternative" { let x = [10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0] let result = @src.rstatix_t_test(x, mu=15.0, alternative="greater") @@ -22,6 +24,7 @@ test "rstatix_t_test one-sample greater alternative" { assert_eq(result.alternative, "greater") } +///| test "rstatix_t_test one-sample less alternative" { let x = [10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0] let result = @src.rstatix_t_test(x, mu=25.0, alternative="less") @@ -29,6 +32,7 @@ test "rstatix_t_test one-sample less alternative" { assert_eq(result.alternative, "less") } +///| test "rstatix_t_test one-sample small array" { let x = [5.0, 6.0] let result = @src.rstatix_t_test(x, mu=0.0) @@ -36,10 +40,11 @@ test "rstatix_t_test one-sample small array" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_t_test two-sample Welch's basic" { let x = [10.0, 12.0, 15.0, 18.0, 20.0, 22.0, 25.0, 28.0, 30.0, 32.0] let y = [8.0, 9.0, 11.0, 12.0, 14.0, 15.0, 17.0, 19.0, 20.0, 22.0] - let result = @src.rstatix_t_test(x, y=y) + let result = @src.rstatix_t_test(x, y~) assert_eq(result.test_name, "t_test") assert_eq(result.method_name, "Welch's two-sample t-test") assert_true(result.statistic > 0.0) @@ -51,31 +56,35 @@ test "rstatix_t_test two-sample Welch's basic" { assert_true(result.se > 0.0) } +///| test "rstatix_t_test two-sample equal means" { let x = [5.0, 5.0, 5.0, 5.0, 5.0] let y = [5.0, 5.0, 5.0, 5.0, 5.0] - let result = @src.rstatix_t_test(x, y=y) + let result = @src.rstatix_t_test(x, y~) assert_true(result.p_value.is_nan()) } +///| test "rstatix_t_test paired basic" { let x = [10.0, 12.0, 15.0, 18.0, 20.0, 22.0, 25.0, 28.0, 30.0, 32.0] let y = [8.0, 9.0, 11.0, 12.0, 14.0, 15.0, 17.0, 19.0, 20.0, 22.0] - let result = @src.rstatix_t_test(x, y=y, paired=true) + let result = @src.rstatix_t_test(x, y~, paired=true) assert_eq(result.method_name, "Paired t-test") assert_true(result.statistic > 0.0) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) assert_true(result.ci_low < result.ci_high) } +///| test "rstatix_t_test paired different length" { let x = [10.0, 12.0, 15.0, 18.0, 20.0, 22.0, 25.0] let y = [8.0, 9.0, 11.0, 12.0, 14.0] - let result = @src.rstatix_t_test(x, y=y, paired=true) + let result = @src.rstatix_t_test(x, y~, paired=true) assert_true(result.n1 == 5) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_t_test confidence interval" { let x = [10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0] let result99 = @src.rstatix_t_test(x, mu=15.0, conf_level=0.99) @@ -86,6 +95,7 @@ test "rstatix_t_test confidence interval" { // ===== rstatix_wilcox_test ===== +///| test "rstatix_wilcox_test one-sample basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let result = @src.rstatix_wilcox_test(x, mu=5.0) @@ -95,6 +105,7 @@ test "rstatix_wilcox_test one-sample basic" { assert_true(result.n1 == 9) } +///| test "rstatix_wilcox_test one-sample too few observations" { let x = [1.0, 2.0, 3.0] let result = @src.rstatix_wilcox_test(x, mu=2.0) @@ -103,6 +114,7 @@ test "rstatix_wilcox_test one-sample too few observations" { assert_true(result.n1 == 2) } +///| test "rstatix_wilcox_test one-sample greater alternative" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let result = @src.rstatix_wilcox_test(x, mu=4.0, alternative="greater") @@ -110,10 +122,11 @@ test "rstatix_wilcox_test one-sample greater alternative" { assert_eq(result.alternative, "greater") } +///| test "rstatix_wilcox_test two-sample rank-sum basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] let y = [8.0, 9.0, 10.0, 11.0, 12.0, 13.0] - let result = @src.rstatix_wilcox_test(x, y=y) + let result = @src.rstatix_wilcox_test(x, y~) assert_eq(result.test_name, "wilcox_test") assert_eq(result.method_name, "Wilcoxon rank-sum test") assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) @@ -122,40 +135,45 @@ test "rstatix_wilcox_test two-sample rank-sum basic" { assert_true(result.n2 == 6) } +///| test "rstatix_wilcox_test two-sample too few observations" { let x = [1.0, 2.0] let y = [3.0, 4.0] - let result = @src.rstatix_wilcox_test(x, y=y) + let result = @src.rstatix_wilcox_test(x, y~) assert_true(result.p_value.is_nan()) assert_eq(result.n1, 2) assert_eq(result.n2, 2) } +///| test "rstatix_wilcox_test two-sample one group too small" { let x = [1.0, 2.0, 3.0] let y = [4.0, 5.0] - let result = @src.rstatix_wilcox_test(x, y=y) + let result = @src.rstatix_wilcox_test(x, y~) assert_true(result.p_value.is_nan()) } +///| test "rstatix_wilcox_test paired basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0] - let result = @src.rstatix_wilcox_test(x, y=y, paired=true) + let result = @src.rstatix_wilcox_test(x, y~, paired=true) assert_eq(result.method_name, "Paired Wilcoxon") assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) assert_true(!result.statistic.is_nan()) } +///| test "rstatix_wilcox_test paired with mu" { let x = [5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0] let y = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] - let result = @src.rstatix_wilcox_test(x, y=y, paired=true, mu=2.0) + let result = @src.rstatix_wilcox_test(x, y~, paired=true, mu=2.0) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } // ===== rstatix_cor_test ===== +///| test "rstatix_cor_test pearson basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0] @@ -175,6 +193,7 @@ test "rstatix_cor_test pearson basic" { assert_true(n_val == 10) } +///| test "rstatix_cor_test pearson negative" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [20.0, 18.0, 16.0, 14.0, 12.0, 10.0, 8.0, 6.0, 4.0, 2.0] @@ -183,6 +202,7 @@ test "rstatix_cor_test pearson negative" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_cor_test pearson no correlation" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0] @@ -191,6 +211,7 @@ test "rstatix_cor_test pearson no correlation" { assert_true(result.p_value.is_nan()) } +///| test "rstatix_cor_test spearman basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0] @@ -201,6 +222,7 @@ test "rstatix_cor_test spearman basic" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_cor_test spearman nonlinear" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [1.0, 4.0, 9.0, 16.0, 25.0, 36.0, 49.0, 64.0, 81.0, 100.0] @@ -209,6 +231,7 @@ test "rstatix_cor_test spearman nonlinear" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_cor_test kendall basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0] @@ -219,6 +242,7 @@ test "rstatix_cor_test kendall basic" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_cor_test kendall negative" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [20.0, 18.0, 16.0, 14.0, 12.0, 10.0, 8.0, 6.0, 4.0, 2.0] @@ -227,6 +251,7 @@ test "rstatix_cor_test kendall negative" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_cor_test mismatched length" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [1.0, 2.0, 3.0, 4.0] @@ -235,6 +260,7 @@ test "rstatix_cor_test mismatched length" { assert_true(result.p_value.is_nan()) } +///| test "rstatix_cor_test too small" { let x = [1.0, 2.0] let y = [3.0, 4.0] @@ -245,6 +271,7 @@ test "rstatix_cor_test too small" { // ===== rstatix_anova_test ===== +///| test "rstatix_anova_test basic" { let groups = [ [10.0, 12.0, 15.0, 18.0, 20.0], @@ -260,6 +287,7 @@ test "rstatix_anova_test basic" { assert_true(result.ms > 0.0) } +///| test "rstatix_anova_test equal groups" { let groups = [ [5.0, 5.0, 5.0, 5.0, 5.0], @@ -271,24 +299,22 @@ test "rstatix_anova_test equal groups" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_anova_test too few groups" { - let groups = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - ] + let groups = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let result = @src.rstatix_anova_test(groups) assert_true(result.p_value.is_nan()) assert_true(result.f.is_nan()) } +///| test "rstatix_anova_test two groups" { - let groups = [ - [1.0, 2.0, 3.0], - ] + let groups = [[1.0, 2.0, 3.0]] let result = @src.rstatix_anova_test(groups) assert_true(result.p_value.is_nan()) } +///| test "rstatix_anova_test four groups" { let groups = [ [1.0, 2.0, 3.0, 4.0, 5.0], @@ -303,6 +329,7 @@ test "rstatix_anova_test four groups" { // ===== rstatix_kruskal_test ===== +///| test "rstatix_kruskal_test basic" { let groups = [ [10.0, 12.0, 15.0, 18.0, 20.0], @@ -317,6 +344,7 @@ test "rstatix_kruskal_test basic" { assert_true(result.ss > 0.0) } +///| test "rstatix_kruskal_test equal groups" { let groups = [ [5.0, 5.0, 5.0, 5.0, 5.0], @@ -327,11 +355,9 @@ test "rstatix_kruskal_test equal groups" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_kruskal_test too few groups" { - let groups = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - ] + let groups = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let result = @src.rstatix_kruskal_test(groups) assert_true(result.p_value.is_nan()) assert_true(result.f.is_nan()) @@ -339,6 +365,7 @@ test "rstatix_kruskal_test too few groups" { // ===== rstatix_friedman_test ===== +///| test "rstatix_friedman_test basic" { let groups = [ [10.0, 12.0, 15.0, 18.0, 20.0], @@ -353,6 +380,7 @@ test "rstatix_friedman_test basic" { assert_true(result.ss > 0.0) } +///| test "rstatix_friedman_test equal groups" { let groups = [ [5.0, 5.0, 5.0, 5.0, 5.0], @@ -363,28 +391,24 @@ test "rstatix_friedman_test equal groups" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_friedman_test too few groups" { - let groups = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - ] + let groups = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let result = @src.rstatix_friedman_test(groups) assert_true(result.p_value.is_nan()) assert_true(result.f.is_nan()) } +///| test "rstatix_friedman_test small blocks" { - let groups = [ - [1.0, 4.0], - [2.0, 5.0], - [3.0, 6.0], - ] + let groups = [[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]] let result = @src.rstatix_friedman_test(groups) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } // ===== rstatix_bh_correct ===== +///| test "rstatix_bh_correct basic" { let p_values = [0.01, 0.04, 0.03, 0.005, 0.2] let result = @src.rstatix_bh_correct(p_values) @@ -397,12 +421,14 @@ test "rstatix_bh_correct basic" { } } +///| test "rstatix_bh_correct empty" { let p_values : Array[Double] = Array::new() let result = @src.rstatix_bh_correct(p_values) assert_true(result.length() == 0) } +///| test "rstatix_bh_correct single" { let p_values = [0.05] let result = @src.rstatix_bh_correct(p_values) @@ -410,6 +436,7 @@ test "rstatix_bh_correct single" { assert_true(result[0] >= 0.05 - 1.0e-10 && result[0] <= 0.05 + 1.0e-10) } +///| test "rstatix_bh_correct all significant" { let p_values = [0.001, 0.002, 0.003, 0.004, 0.005] let result = @src.rstatix_bh_correct(p_values) @@ -421,6 +448,7 @@ test "rstatix_bh_correct all significant" { } } +///| test "rstatix_bh_correct all non-significant" { let p_values = [0.8, 0.9, 0.95, 0.98, 0.99] let result = @src.rstatix_bh_correct(p_values) @@ -433,6 +461,7 @@ test "rstatix_bh_correct all non-significant" { } } +///| test "rstatix_bh_correct preserves order" { let p_values = [0.2, 0.005, 0.04, 0.01, 0.03] let result = @src.rstatix_bh_correct(p_values) @@ -443,6 +472,7 @@ test "rstatix_bh_correct preserves order" { // ===== rstatix_bonferroni ===== +///| test "rstatix_bonferroni basic" { let p_values = [0.01, 0.04, 0.03, 0.005, 0.2] let result = @src.rstatix_bonferroni(p_values) @@ -452,12 +482,14 @@ test "rstatix_bonferroni basic" { assert_true(result[4] >= 1.0 - 1.0e-10) } +///| test "rstatix_bonferroni empty" { let p_values : Array[Double] = Array::new() let result = @src.rstatix_bonferroni(p_values) assert_true(result.length() == 0) } +///| test "rstatix_bonferroni single" { let p_values = [0.05] let result = @src.rstatix_bonferroni(p_values) @@ -465,6 +497,7 @@ test "rstatix_bonferroni single" { assert_true(result[0] >= 0.05 - 1.0e-10 && result[0] <= 0.05 + 1.0e-10) } +///| test "rstatix_bonferroni capped at 1" { let p_values = [0.3, 0.4, 0.5] let result = @src.rstatix_bonferroni(p_values) @@ -475,6 +508,7 @@ test "rstatix_bonferroni capped at 1" { // ===== Summary functions ===== +///| test "rstatix_t_test_summary basic" { let x = [10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0] let result = @src.rstatix_t_test(x, mu=15.0) @@ -487,15 +521,17 @@ test "rstatix_t_test_summary basic" { assert_true(summary.contains("Method")) } +///| test "rstatix_t_test_summary two-sample" { let x = [10.0, 12.0, 15.0, 18.0, 20.0] let y = [8.0, 9.0, 11.0, 12.0, 14.0] - let result = @src.rstatix_t_test(x, y=y) + let result = @src.rstatix_t_test(x, y~) let summary = @src.rstatix_t_test_summary(result) assert_true(summary.contains("Group1")) assert_true(summary.contains("Group2")) } +///| test "rstatix_cor_test_summary basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0] @@ -509,6 +545,7 @@ test "rstatix_cor_test_summary basic" { assert_true(summary.contains("Method")) } +///| test "rstatix_cor_test_summary spearman" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0] @@ -517,6 +554,7 @@ test "rstatix_cor_test_summary spearman" { assert_true(summary.contains("spearman")) } +///| test "rstatix_anova_summary basic" { let groups = [ [10.0, 12.0, 15.0, 18.0, 20.0], @@ -535,6 +573,7 @@ test "rstatix_anova_summary basic" { assert_true(summary.contains("p-value")) } +///| test "rstatix_anova_summary kruskal" { let groups = [ [10.0, 12.0, 15.0, 18.0, 20.0], @@ -546,6 +585,7 @@ test "rstatix_anova_summary kruskal" { assert_true(summary.contains("Kruskal-Wallis")) } +///| test "rstatix_anova_summary friedman" { let groups = [ [10.0, 12.0, 15.0, 18.0, 20.0], @@ -559,6 +599,7 @@ test "rstatix_anova_summary friedman" { // ===== rstatix_sample_data ===== +///| test "rstatix_sample_data basic" { let data = @src.rstatix_sample_data() assert_true(data.length() == 3) @@ -567,6 +608,7 @@ test "rstatix_sample_data basic" { assert_true(data[2].length() == 10) } +///| test "rstatix_sample_data values" { let data = @src.rstatix_sample_data() assert_true(data[0][0] == 10.0) @@ -577,6 +619,7 @@ test "rstatix_sample_data values" { assert_true(data[2][9] == 14.0) } +///| test "rstatix_sample_data used in anova" { let data = @src.rstatix_sample_data() let result = @src.rstatix_anova_test(data) @@ -584,12 +627,14 @@ test "rstatix_sample_data used in anova" { assert_true(result.f > 0.0) } +///| test "rstatix_sample_data used in kruskal" { let data = @src.rstatix_sample_data() let result = @src.rstatix_kruskal_test(data) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_sample_data used in friedman" { let data = @src.rstatix_sample_data() let result = @src.rstatix_friedman_test(data) @@ -598,6 +643,7 @@ test "rstatix_sample_data used in friedman" { // ===== Edge cases and integration ===== +///| test "rstatix_t_test constant values" { let x = [5.0, 5.0, 5.0, 5.0, 5.0] let result = @src.rstatix_t_test(x, mu=5.0) @@ -605,18 +651,21 @@ test "rstatix_t_test constant values" { assert_true(result.p_value.is_nan()) } +///| test "rstatix_wilcox_test all zeros" { let x = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] let result = @src.rstatix_wilcox_test(x) assert_true(result.p_value.is_nan()) } +///| test "rstatix_cor_test identical values" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let result = @src.rstatix_cor_test(x, x) assert_true(result.statistic > 0.99 && result.statistic <= 1.0) } +///| test "rstatix_bh_correct preserves non-decreasing order" { let p_values = [0.001, 0.01, 0.03, 0.05, 0.1] let result = @src.rstatix_bh_correct(p_values) @@ -627,34 +676,41 @@ test "rstatix_bh_correct preserves non-decreasing order" { } } +///| test "rstatix_t_test_two_sample_same_values" { let x = [10.0, 10.0, 10.0, 10.0, 10.0] let y = [10.0, 10.0, 10.0, 10.0, 10.0] - let result = @src.rstatix_t_test(x, y=y) + let result = @src.rstatix_t_test(x, y~) assert_true(result.statistic.is_nan()) } +///| test "rstatix_anova_test with sample data from function" { let data = @src.rstatix_sample_data() - let result = @src.rstatix_anova_test(data, group_names=["GroupA", "GroupB", "GroupC"]) + let result = @src.rstatix_anova_test(data, group_names=[ + "GroupA", "GroupB", "GroupC", + ]) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_t_test paired with mu default" { let x = [10.0, 12.0, 15.0, 18.0, 20.0, 22.0, 25.0, 28.0, 30.0, 32.0] let y = [8.0, 9.0, 11.0, 12.0, 14.0, 15.0, 17.0, 19.0, 20.0, 22.0] - let result = @src.rstatix_t_test(x, y=y, paired=true) + let result = @src.rstatix_t_test(x, y~, paired=true) assert_true(result.statistic > 0.0) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_wilcox_test two-sample with different lengths" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0] let y = [9.0, 10.0, 11.0, 12.0, 13.0, 14.0] - let result = @src.rstatix_wilcox_test(x, y=y) + let result = @src.rstatix_wilcox_test(x, y~) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_cor_test pearson default method" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0] @@ -662,6 +718,7 @@ test "rstatix_cor_test pearson default method" { assert_eq(result.method_name, "Pearson's product-moment correlation") } +///| test "rstatix_kruskal_test with sample data" { let data = @src.rstatix_sample_data() let result = @src.rstatix_kruskal_test(data, _group_names=["A", "B", "C"]) @@ -669,9 +726,10 @@ test "rstatix_kruskal_test with sample data" { assert_true(result.source == "Kruskal-Wallis") } +///| test "rstatix_friedman_test with sample data" { let data = @src.rstatix_sample_data() let result = @src.rstatix_friedman_test(data, _group_names=["A", "B", "C"]) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) assert_true(result.source == "Friedman") -} \ No newline at end of file +} diff --git a/test/moonbit/rtsne_test.mbt b/test/moonbit/rtsne_test.mbt index 2fb8c168..b52479aa 100644 --- a/test/moonbit/rtsne_test.mbt +++ b/test/moonbit/rtsne_test.mbt @@ -6,10 +6,7 @@ // ============================================================ test "calc_distance_matrix square" { - let data : Array[Array[Double]] = [ - [0.0, 0.0], - [3.0, 4.0], - ] + let data : Array[Array[Double]] = [[0.0, 0.0], [3.0, 4.0]] let dist = @src.calc_distance_matrix(data) assert_eq(dist.length(), 2) assert_eq(dist[0].length(), 2) @@ -20,12 +17,14 @@ test "calc_distance_matrix square" { assert_eq(dist[1][0], 5.0) } +///| test "calc_distance_matrix empty" { let data : Array[Array[Double]] = [] let dist = @src.calc_distance_matrix(data) assert_eq(dist.length(), 0) } +///| test "calc_distance_matrix single point" { let data : Array[Array[Double]] = [[1.0, 2.0, 3.0]] let dist = @src.calc_distance_matrix(data) @@ -37,6 +36,7 @@ test "calc_distance_matrix single point" { // t-SNE config tests // ============================================================ +///| test "tsne_config default" { let config = @src.TsneConfig::new() assert_eq(config.perplexity, 30.0) @@ -50,13 +50,14 @@ test "tsne_config default" { // t-SNE algorithm tests // ============================================================ +///| test "tsne basic 2d" { let data = @src.create_tsne_test_data(10, 5) assert_eq(data.length(), 10) assert_eq(data[0].length(), 5) - + let test_config = @src.TsneConfig::new_custom(3.0, 100, 2, 42) - + let result = @src.tsne(data, test_config) assert_eq(result.embedding.length(), 10) assert_eq(result.embedding[0].length(), 2) @@ -64,6 +65,7 @@ test "tsne basic 2d" { assert_eq(result.costs.length(), 100) } +///| test "tsne empty data" { let data : Array[Array[Double]] = [] let config = @src.TsneConfig::new() @@ -71,6 +73,7 @@ test "tsne empty data" { assert_eq(result.embedding.length(), 0) } +///| test "tsne single sample" { let data : Array[Array[Double]] = [[1.0, 2.0, 3.0]] let config = @src.TsneConfig::new() @@ -79,12 +82,13 @@ test "tsne single sample" { assert_true(result.embedding.length() <= 1) } +///| test "tsne costs decrease" { let data = @src.create_tsne_test_data(15, 4) let config = @src.TsneConfig::new_custom(3.0, 50, 2, 42) - + let result = @src.tsne(data, config) - + // Costs should be finite if result.costs.length() > 10 { // Check that costs are not NaN or infinite @@ -95,10 +99,11 @@ test "tsne costs decrease" { } } +///| test "tsne different dims" { let data = @src.create_tsne_test_data(10, 5) let config = @src.TsneConfig::new_custom(3.0, 50, 3, 42) - + let result = @src.tsne(data, config) assert_eq(result.embedding[0].length(), 3) } @@ -107,19 +112,21 @@ test "tsne different dims" { // Test data generation tests // ============================================================ +///| test "create_tsne_test_data dimensions" { let data = @src.create_tsne_test_data(20, 8) assert_eq(data.length(), 20) assert_eq(data[0].length(), 8) } +///| test "create_tsne_test_data clusters" { let data = @src.create_tsne_test_data(9, 3) // 3 clusters, each should have similar values // Cluster 0: samples 0, 3, 6 // Cluster 1: samples 1, 4, 7 // Cluster 2: samples 2, 5, 8 - + // Check that cluster 0 is different from cluster 1 let mut sum0 = 0.0 let mut j = 0 @@ -127,14 +134,14 @@ test "create_tsne_test_data clusters" { sum0 = sum0 + data[0][j] j = j + 1 } - + let mut sum1 = 0.0 j = 0 while j < 3 { sum1 = sum1 + data[1][j] j = j + 1 } - + // Clusters should be separated assert_true(sum1 > sum0) } diff --git a/test/moonbit/s4vectors_test.mbt b/test/moonbit/s4vectors_test.mbt index 3ccb1769..50921427 100644 --- a/test/moonbit/s4vectors_test.mbt +++ b/test/moonbit/s4vectors_test.mbt @@ -2,7 +2,7 @@ test "s4vectors_rle_from_vector" { let vec = ["A", "A", "A", "B", "B", "C", "C", "C", "C", "A", "A"] let rle = @src.Rle::from_vector(vec) - + assert_eq(rle.values.length(), 4) assert_eq(rle.lengths.length(), 4) } @@ -11,7 +11,7 @@ test "s4vectors_rle_from_vector" { test "s4vectors_rle_length" { let vec = ["A", "A", "B", "B", "B"] let rle = @src.Rle::from_vector(vec) - + assert_eq(rle.length(), 5) } @@ -19,7 +19,7 @@ test "s4vectors_rle_length" { test "s4vectors_rle_get" { let vec = ["A", "A", "B", "C", "C", "C"] let rle = @src.Rle::from_vector(vec) - + assert_eq(rle.get(0), "A") assert_eq(rle.get(2), "B") assert_eq(rle.get(5), "C") @@ -29,9 +29,9 @@ test "s4vectors_rle_get" { test "s4vectors_dataframe_basic" { let col1 = @src.S4DataFrameColumn::new("gene_id", ["gene1", "gene2", "gene3"]) let col2 = @src.S4DataFrameColumn::new("expression", ["10.5", "25.3", "5.8"]) - + let df = @src.S4DataFrame::new([col1, col2], ["row1", "row2", "row3"]) - + assert_eq(df.nrow(), 3) assert_eq(df.ncol(), 2) } @@ -40,25 +40,25 @@ test "s4vectors_dataframe_basic" { test "s4vectors_dataframe_colnames" { let col1 = @src.S4DataFrameColumn::new("gene_id", ["gene1", "gene2"]) let col2 = @src.S4DataFrameColumn::new("expression", ["10.5", "25.3"]) - + let df = @src.S4DataFrame::new([col1, col2], []) let names = df.colnames() - + assert_eq(names.length(), 2) } ///| test "s4vectors_hits_basic" { let hits = @src.Hits::new([0, 0, 1, 2], [1, 2, 0, 1], 3, 3) - + assert_eq(hits.n_hits(), 4) } ///| test "s4vectors_hits_count_query_hits" { let hits = @src.Hits::new([0, 0, 1, 2], [1, 2, 0, 1], 3, 3) - + let counts = hits.count_query_hits() - + assert_eq(counts.length(), 3) -} \ No newline at end of file +} diff --git a/test/moonbit/sasa_test.mbt b/test/moonbit/sasa_test.mbt index 8149442b..61259184 100644 --- a/test/moonbit/sasa_test.mbt +++ b/test/moonbit/sasa_test.mbt @@ -13,19 +13,19 @@ fn make_atom( resseq : Int, ) -> @src.Atom { @src.Atom::new( - name=name, + name~, coord=@src.Vector3::new(x, y, z), - resname=resname, + resname~, chainid='A', - resseq=resseq, - element=element, + resseq~, + element~, ) } ///| /// Helper: place all given atoms into a single residue on chain A. fn make_structure(atoms : Array[@src.Atom]) -> @src.Structure { - let res = @src.Residue::new(resname="UNK", chainid='A', resseq=1, atoms=atoms) + let res = @src.Residue::new(resname="UNK", chainid='A', resseq=1, atoms~) let chain = @src.Chain::new(id='A', residues=[res]) let model = @src.Model::new(id=1, chains=[chain]) @src.Structure::new(id="test", models=[model]) @@ -240,8 +240,9 @@ test "sasa_total_backbone_sidechain" { let atom_res = @src.sasa_calc(s, 100, 1.4) let summary = @src.sasa_calc_total(atom_res) assert_true( - (summary.get_backbone_sasa() + summary.get_sidechain_sasa() - - summary.get_total_sasa()).abs() < + (summary.get_backbone_sasa() + + summary.get_sidechain_sasa() - + summary.get_total_sasa()).abs() < 1.0e-9, ) assert_true(summary.get_backbone_sasa() > 0.0) @@ -310,7 +311,10 @@ test "sasa_all_backbone_atoms_sidechain_zero" { let res_res = @src.sasa_calc_residue(atom_res, s) assert_eq(res_res.length(), 1) assert_true(res_res[0].get_sidechain_sasa() == 0.0) - assert_true((res_res[0].get_backbone_sasa() - res_res[0].get_total_sasa()).abs() < 1.0e-9) + assert_true( + (res_res[0].get_backbone_sasa() - res_res[0].get_total_sasa()).abs() < + 1.0e-9, + ) } ///| diff --git a/test/moonbit/sc3_test.mbt b/test/moonbit/sc3_test.mbt index 54428771..d3376d35 100644 --- a/test/moonbit/sc3_test.mbt +++ b/test/moonbit/sc3_test.mbt @@ -3,14 +3,10 @@ ///| test "sc3_preprocess" { - let data = [ - [0.0, 1.0, 10.0], - [0.0, 2.0, 20.0], - [0.0, 3.0, 30.0], - ] - + let data = [[0.0, 1.0, 10.0], [0.0, 2.0, 20.0], [0.0, 3.0, 30.0]] + let processed = @src.sc3_preprocess(data) - + assert_true(processed.length() == 3) assert_true(processed[0].length() == 3) } @@ -23,53 +19,38 @@ test "sc3_pca" { [3.0, 4.0, 5.0], [10.0, 11.0, 12.0], ] - + let pcs = @src.sc3_pca(data, 2) - + assert_true(pcs.length() == 4) assert_true(pcs[0].length() == 2) } ///| test "sc3_kmeans" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [10.0, 11.0], - [11.0, 12.0], - ] - + let data = [[1.0, 2.0], [2.0, 3.0], [10.0, 11.0], [11.0, 12.0]] + let labels = @src.sc3_kmeans(data, 2) - + assert_true(labels.length() == 4) } ///| test "sc3_silhouette" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [10.0, 11.0], - [11.0, 12.0], - ] + let data = [[1.0, 2.0], [2.0, 3.0], [10.0, 11.0], [11.0, 12.0]] let labels = [0, 0, 1, 1] - + let scores = @src.sc3_calculate_silhouette(data, labels, 2) - + assert_true(scores.length() == 4) } ///| test "sc3_gap_statistics" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [10.0, 11.0], - [11.0, 12.0], - ] - + let data = [[1.0, 2.0], [2.0, 3.0], [10.0, 11.0], [11.0, 12.0]] + let gaps = @src.sc3_calculate_gap_statistics(data, 3) - + assert_true(gaps.length() == 3) } @@ -81,9 +62,9 @@ test "sc3_consensus_cluster" { [10.0, 11.0, 12.0], [11.0, 12.0, 13.0], ] - + let result = @src.bio_sc3_cluster(data, 2) - + assert_true(result.k == 2) assert_true(result.cluster_labels.length() == 4) assert_true(result.consensus_matrix.length() == 4) @@ -91,16 +72,12 @@ test "sc3_consensus_cluster" { ///| test "sc3_bio_api" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [10.0, 11.0], - ] - + let data = [[1.0, 2.0], [2.0, 3.0], [10.0, 11.0]] + let pcs = @src.bio_sc3_pca(data, 2) let labels = @src.sc3_kmeans(pcs, 2) let scores = @src.bio_sc3_silhouette(pcs, labels, 2) - + assert_true(pcs.length() == 3) assert_true(scores.length() == 3) -} \ No newline at end of file +} diff --git a/test/moonbit/scenic_test.mbt b/test/moonbit/scenic_test.mbt index a22db54a..bac87835 100644 --- a/test/moonbit/scenic_test.mbt +++ b/test/moonbit/scenic_test.mbt @@ -6,32 +6,28 @@ // --------------------------------------------------------------------------- test "scenic_co_expression_module_creation" { - let mod_ = @src.co_expression_module( - "TP53", - ["G1", "G2", "G3"], - [0.9, 0.7, 0.5], - ) + let mod_ = @src.co_expression_module("TP53", ["G1", "G2", "G3"], [ + 0.9, 0.7, 0.5, + ]) assert_eq(mod_.tf_name, "TP53") assert_eq(mod_.targets.length(), 3) assert_eq(mod_.weights[0], 0.9) } +///| test "scenic_regulon_creation" { - let reg = @src.scenic_regulon( - "MYC", - ["G1", "G2", "G3", "G4"], - [1.0, 0.8, 0.6, 0.4], - ) + let reg = @src.scenic_regulon("MYC", ["G1", "G2", "G3", "G4"], [ + 1.0, 0.8, 0.6, 0.4, + ]) assert_eq(reg.tf_name, "MYC") assert_eq(reg.n_targets, 4) assert_eq(reg.targets[2], "G3") } +///| test "scenic_input_creation" { - let expr = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] // 2 genes x 3 cells - let input = @src.scenic_input( - expr, ["TF1", "G1"], ["C1", "C2", "C3"], ["TF1"], - ) + let expr = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] // 2 genes x 3 cells + let input = @src.scenic_input(expr, ["TF1", "G1"], ["C1", "C2", "C3"], ["TF1"]) assert_eq(input.n_genes, 2) assert_eq(input.n_cells, 3) assert_eq(input.tf_names.length(), 1) @@ -41,6 +37,7 @@ test "scenic_input_creation" { // Binarize method constructors // --------------------------------------------------------------------------- +///| test "scenic_binarize_method_constructors" { match @src.binarize_mean_std() { @src.BinarizeMethod::MeanStd => assert_true(true) @@ -60,16 +57,15 @@ test "scenic_binarize_method_constructors" { // Synthetic data generator // --------------------------------------------------------------------------- +///| test "scenic_sample_data_shape" { - let input = @src.scenic_sample_data( - n_genes=60, n_cells=40, n_tfs=4, seed=10, - ) + let input = @src.scenic_sample_data(n_genes=60, n_cells=40, n_tfs=4, seed=10) assert_eq(input.n_genes, 60) assert_eq(input.n_cells, 40) assert_eq(input.tf_names.length(), 4) assert_eq(input.gene_names[0], "TF1") assert_eq(input.gene_names[4], "G1") - assert_eq(input.expression.length(), 60) // gene x cell + assert_eq(input.expression.length(), 60) // gene x cell assert_eq(input.expression[0].length(), 40) } @@ -77,13 +73,10 @@ test "scenic_sample_data_shape" { // Step 1: Co-expression modules // --------------------------------------------------------------------------- +///| test "scenic_build_coexpression_modules_basic" { - let input = @src.scenic_sample_data( - n_genes=50, n_cells=30, n_tfs=3, seed=42, - ) - let modules = @src.build_coexpression_modules( - input, min_targets=5, top_k=20, - ) + let input = @src.scenic_sample_data(n_genes=50, n_cells=30, n_tfs=3, seed=42) + let modules = @src.build_coexpression_modules(input, min_targets=5, top_k=20) // Should produce a module for each TF assert_eq(modules.length(), 3) for mod_ in modules { @@ -93,12 +86,13 @@ test "scenic_build_coexpression_modules_basic" { } } +///| test "scenic_build_coexpression_modules_skip_unknown_tf" { // TF name not in gene_names -> should be skipped let expr = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]] - let input = @src.scenic_input( - expr, ["G1", "G2", "G3"], ["C1", "C2"], ["NONEXISTENT"], - ) + let input = @src.scenic_input(expr, ["G1", "G2", "G3"], ["C1", "C2"], [ + "NONEXISTENT", + ]) let modules = @src.build_coexpression_modules(input, min_targets=1, top_k=5) assert_eq(modules.length(), 0) } @@ -107,15 +101,14 @@ test "scenic_build_coexpression_modules_skip_unknown_tf" { // Step 2: Regulon construction // --------------------------------------------------------------------------- +///| test "scenic_build_regulons_prunes_by_weight" { - let input = @src.scenic_sample_data( - n_genes=50, n_cells=30, n_tfs=3, seed=7, - ) - let modules = @src.build_coexpression_modules( - input, min_targets=5, top_k=20, - ) + let input = @src.scenic_sample_data(n_genes=50, n_cells=30, n_tfs=3, seed=7) + let modules = @src.build_coexpression_modules(input, min_targets=5, top_k=20) let regulons = @src.build_regulons( - modules, weight_quantile=0.5, min_targets=3, + modules, + weight_quantile=0.5, + min_targets=3, ) // Each regulon should have fewer or equal targets than its module assert_eq(regulons.length(), modules.length()) @@ -125,23 +118,29 @@ test "scenic_build_regulons_prunes_by_weight" { } } +///| test "scenic_build_regulons_filters_small_modules" { let modules = [ @src.co_expression_module("TF1", ["G1", "G2"], [0.9, 0.8]), - @src.co_expression_module("TF2", ["G1", "G2", "G3", "G4", "G5"], [0.9, 0.8, 0.7, 0.6, 0.5]), + @src.co_expression_module("TF2", ["G1", "G2", "G3", "G4", "G5"], [ + 0.9, 0.8, 0.7, 0.6, 0.5, + ]), ] - let regulons = @src.build_regulons(modules, weight_quantile=0.0, min_targets=5) + let regulons = @src.build_regulons( + modules, + weight_quantile=0.0, + min_targets=5, + ) // TF1 module has only 2 targets -> filtered out assert_eq(regulons.length(), 1) assert_eq(regulons[0].tf_name, "TF2") } +///| test "scenic_prune_by_motif_ranking" { - let mod_ = @src.co_expression_module( - "TF1", - ["G1", "G2", "G3", "G4", "G5"], - [0.9, 0.8, 0.7, 0.6, 0.5], - ) + let mod_ = @src.co_expression_module("TF1", ["G1", "G2", "G3", "G4", "G5"], [ + 0.9, 0.8, 0.7, 0.6, 0.5, + ]) // Motif ranking: G1, G3, G5 are in top 3 let motif_ranked = ["G1", "G3", "G5", "G2", "G4", "G6", "G7", "G8"] let reg = @src.prune_by_motif_ranking(mod_, motif_ranked, rank_threshold=3) @@ -157,32 +156,34 @@ test "scenic_prune_by_motif_ranking" { // Step 3: AUCell scoring // --------------------------------------------------------------------------- +///| test "scenic_build_cell_rankings" { let expr = [ - [5.0, 1.0, 3.0], // gene 0: high in cell 0 - [2.0, 4.0, 1.0], // gene 1: high in cell 1 - [1.0, 3.0, 2.0], // gene 2 + [5.0, 1.0, 3.0], // gene 0: high in cell 0 + [2.0, 4.0, 1.0], // gene 1: high in cell 1 + [1.0, 3.0, 2.0], // gene 2 ] - let input = @src.scenic_input( - expr, ["G0", "G1", "G2"], ["C0", "C1", "C2"], [], - ) + let input = @src.scenic_input(expr, ["G0", "G1", "G2"], ["C0", "C1", "C2"], []) let rankings = @src.build_cell_rankings(input) // Cell 0: gene 0 has expr 5.0 (highest), gene 1 has 2.0, gene 2 has 1.0 - assert_eq(rankings[0][0], 0) // gene 0 first - assert_eq(rankings[0][1], 1) // gene 1 second - assert_eq(rankings[0][2], 2) // gene 2 third + assert_eq(rankings[0][0], 0) // gene 0 first + assert_eq(rankings[0][1], 1) // gene 1 second + assert_eq(rankings[0][2], 2) // gene 2 third } +///| test "scenic_compute_regulon_activity_basic" { - let input = @src.scenic_sample_data( - n_genes=40, n_cells=20, n_tfs=2, seed=99, - ) - let modules = @src.build_coexpression_modules( - input, min_targets=5, top_k=15, + let input = @src.scenic_sample_data(n_genes=40, n_cells=20, n_tfs=2, seed=99) + let modules = @src.build_coexpression_modules(input, min_targets=5, top_k=15) + let regulons = @src.build_regulons( + modules, + weight_quantile=0.3, + min_targets=3, ) - let regulons = @src.build_regulons(modules, weight_quantile=0.3, min_targets=3) let auc_matrix = @src.compute_regulon_activity( - regulons, input, auc_threshold_pct=0.1, + regulons, + input, + auc_threshold_pct=0.1, ) assert_eq(auc_matrix.length(), regulons.length()) assert_eq(auc_matrix[0].length(), input.n_cells) @@ -198,26 +199,32 @@ test "scenic_compute_regulon_activity_basic" { // Step 4: Binarization // --------------------------------------------------------------------------- +///| test "scenic_binarize_mean_std" { let auc_matrix = [ - [0.1, 0.2, 0.8, 0.9, 0.1, 0.85], // bimodal: low {0.1,0.2,0.1}, high {0.8,0.9,0.85} + [0.1, 0.2, 0.8, 0.9, 0.1, 0.85], // bimodal: low {0.1,0.2,0.1}, high {0.8,0.9,0.85} ] let (binary, thresholds) = @src.binarize_activity( - auc_matrix, 6, method=@src.binarize_mean_std(), + auc_matrix, + 6, + method=@src.binarize_mean_std(), ) assert_eq(thresholds.length(), 1) assert_true(thresholds[0] > 0.3 && thresholds[0] < 0.7) // High-AUC cells should be 1, low-AUC cells should be 0 - assert_eq(binary[0][2], 1) // 0.8 > threshold - assert_eq(binary[0][0], 0) // 0.1 < threshold + assert_eq(binary[0][2], 1) // 0.8 > threshold + assert_eq(binary[0][0], 0) // 0.1 < threshold } +///| test "scenic_binarize_kmeans2" { let auc_matrix = [ - [0.1, 0.1, 0.1, 0.9, 0.9, 0.9], // clearly bimodal + [0.1, 0.1, 0.1, 0.9, 0.9, 0.9], // clearly bimodal ] let (binary, thresholds) = @src.binarize_activity( - auc_matrix, 6, method=@src.binarize_kmeans2(), + auc_matrix, + 6, + method=@src.binarize_kmeans2(), ) // K-means should separate at ~0.5 assert_true(thresholds[0] > 0.3 && thresholds[0] < 0.7) @@ -225,51 +232,50 @@ test "scenic_binarize_kmeans2" { assert_eq(binary[0][3], 1) } +///| test "scenic_binarize_median" { - let auc_matrix = [ - [0.1, 0.2, 0.3, 0.4, 0.5, 0.9], - ] + let auc_matrix = [[0.1, 0.2, 0.3, 0.4, 0.5, 0.9]] let (binary, _thresholds) = @src.binarize_activity( - auc_matrix, 6, method=@src.binarize_median(), + auc_matrix, + 6, + method=@src.binarize_median(), ) // Median of sorted [0.1,0.2,0.3,0.4,0.5,0.9] = 0.35 // Values > 0.35: 0.4, 0.5, 0.9 -> 1 - assert_eq(binary[0][5], 1) // 0.9 - assert_eq(binary[0][0], 0) // 0.1 + assert_eq(binary[0][5], 1) // 0.9 + assert_eq(binary[0][0], 0) // 0.1 } // --------------------------------------------------------------------------- // Cell state assignment // --------------------------------------------------------------------------- +///| test "scenic_assign_cell_states_basic" { // 2 regulons, 4 cells // Regulon 0 active in cells 0,1; Regulon 1 active in cells 2,3 - let binary = [ - [1, 1, 0, 0], - [0, 0, 1, 1], - ] + let binary = [[1, 1, 0, 0], [0, 0, 1, 1]] let (labels, n_clusters, masters) = @src.assign_cell_states( - binary, ["TF1", "TF2"], 4, + binary, + ["TF1", "TF2"], + 4, ) - assert_eq(labels[0], 1) // cell 0 -> cluster 1 (TF1) - assert_eq(labels[1], 1) // cell 1 -> cluster 1 - assert_eq(labels[2], 2) // cell 2 -> cluster 2 (TF2) - assert_eq(labels[3], 2) // cell 3 -> cluster 2 + assert_eq(labels[0], 1) // cell 0 -> cluster 1 (TF1) + assert_eq(labels[1], 1) // cell 1 -> cluster 1 + assert_eq(labels[2], 2) // cell 2 -> cluster 2 (TF2) + assert_eq(labels[3], 2) // cell 3 -> cluster 2 assert_eq(n_clusters, 2) assert_eq(masters.length(), 2) } +///| test "scenic_assign_cell_states_no_active_regulon" { - let binary = [ - [0, 0, 0], - [0, 0, 0], - ] - let (labels, _n, masters) = @src.assign_cell_states( - binary, ["TF1", "TF2"], 3, - ) + let binary = [[0, 0, 0], [0, 0, 0]] + let (labels, _n, masters) = @src.assign_cell_states(binary, ["TF1", "TF2"], 3) // All cells should be in cluster 0 (no active regulon) - for l in labels { assert_eq(l, 0) } + for l in labels { + assert_eq(l, 0) + } assert_eq(masters.length(), 0) } @@ -277,13 +283,20 @@ test "scenic_assign_cell_states_no_active_regulon" { // End-to-end pipeline // --------------------------------------------------------------------------- +///| test "scenic_run_pipeline_end_to_end" { let input = @src.scenic_sample_data( - n_genes=60, n_cells=40, n_tfs=4, seed=2025, + n_genes=60, + n_cells=40, + n_tfs=4, + seed=2025, ) let result = @src.run_scenic( - input, min_targets=5, top_k=20, - weight_quantile=0.3, auc_threshold_pct=0.1, + input, + min_targets=5, + top_k=20, + weight_quantile=0.3, + auc_threshold_pct=0.1, binarize_method=@src.binarize_mean_std(), ) assert_eq(result.n_cells, 40) @@ -295,10 +308,9 @@ test "scenic_run_pipeline_end_to_end" { assert_eq(result.thresholds.length(), result.n_regulons) } +///| test "scenic_result_summary" { - let input = @src.scenic_sample_data( - n_genes=40, n_cells=20, n_tfs=3, seed=1, - ) + let input = @src.scenic_sample_data(n_genes=40, n_cells=20, n_tfs=3, seed=1) let result = @src.run_scenic(input) let s = result.summary() assert_true(s.contains("regulons=")) @@ -306,10 +318,9 @@ test "scenic_result_summary" { assert_true(s.contains("clusters=")) } +///| test "scenic_result_auc_at" { - let input = @src.scenic_sample_data( - n_genes=40, n_cells=10, n_tfs=2, seed=5, - ) + let input = @src.scenic_sample_data(n_genes=40, n_cells=10, n_tfs=2, seed=5) let result = @src.run_scenic(input) // Valid indices should return a value in [0,1] if result.n_regulons > 0 { @@ -321,24 +332,22 @@ test "scenic_result_auc_at" { assert_eq(result.auc_at(999, 0), 0.0) } +///| test "scenic_result_top_regulons" { - let input = @src.scenic_sample_data( - n_genes=50, n_cells=30, n_tfs=4, seed=8, - ) + let input = @src.scenic_sample_data(n_genes=50, n_cells=30, n_tfs=4, seed=8) let result = @src.run_scenic(input) let top = result.top_regulons(n=3) assert_true(top.length() <= 3) if top.length() >= 2 { let (_, s0) = top[0] let (_, s1) = top[1] - assert_true(s0 >= s1) // sorted descending + assert_true(s0 >= s1) // sorted descending } } +///| test "scenic_result_regulon_targets" { - let input = @src.scenic_sample_data( - n_genes=40, n_cells=20, n_tfs=2, seed=3, - ) + let input = @src.scenic_sample_data(n_genes=40, n_cells=20, n_tfs=2, seed=3) let result = @src.run_scenic(input) if result.n_regulons > 0 { let targets = result.regulon_targets(0) diff --git a/test/moonbit/scmap_test.mbt b/test/moonbit/scmap_test.mbt index deb74bcb..2deb171c 100644 --- a/test/moonbit/scmap_test.mbt +++ b/test/moonbit/scmap_test.mbt @@ -15,12 +15,14 @@ test "scmap_reference_creation" { assert_eq(ref.cell_types()[6], "NK_cell") } +///| test "scmap_reference_unique_types" { let ref = @src.scmap_sample_reference() let types = ref.unique_cell_types() assert_eq(types.length(), 3) } +///| test "scmap_query_creation" { let q = @src.scmap_sample_query() assert_eq(q.gene_names().length(), 10) @@ -30,10 +32,9 @@ test "scmap_query_creation" { assert_eq(q.cell_names()[2], "query_unknown") } +///| test "scmap_assignment_creation" { - let a = @src.ScmapAssignment::new( - "cell1", "T_cell", 0.85, 0.3, "cluster", - ) + let a = @src.ScmapAssignment::new("cell1", "T_cell", 0.85, 0.3, "cluster") assert_eq(a.cell_name(), "cell1") assert_eq(a.assigned_type(), "T_cell") assert_eq(a.best_correlation(), 0.85) @@ -45,6 +46,7 @@ test "scmap_assignment_creation" { // scmap-cluster method // --------------------------------------------------------------------------- +///| test "scmap_cluster_classifies_t_cell" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -56,6 +58,7 @@ test "scmap_cluster_classifies_t_cell" { assert_eq(assignments[0].method(), "cluster") } +///| test "scmap_cluster_classifies_b_cell" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -65,6 +68,7 @@ test "scmap_cluster_classifies_b_cell" { assert_eq(assignments[1].assigned_type(), "B_cell") } +///| test "scmap_cluster_high_threshold_unassigned" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -75,6 +79,7 @@ test "scmap_cluster_high_threshold_unassigned" { } } +///| test "scmap_cluster_correlation_is_valid" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -85,6 +90,7 @@ test "scmap_cluster_correlation_is_valid" { } } +///| test "scmap_cluster_best_gt_second_best" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -98,6 +104,7 @@ test "scmap_cluster_best_gt_second_best" { // scmap-cell method // --------------------------------------------------------------------------- +///| test "scmap_cell_classifies_t_cell" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -107,6 +114,7 @@ test "scmap_cell_classifies_t_cell" { assert_eq(assignments[0].method(), "cell") } +///| test "scmap_cell_classifies_b_cell" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -115,6 +123,7 @@ test "scmap_cell_classifies_b_cell" { assert_eq(assignments[1].assigned_type(), "B_cell") } +///| test "scmap_cell_k_neighbours_parameter" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -123,6 +132,7 @@ test "scmap_cell_k_neighbours_parameter" { assert_eq(assignments.length(), 3) } +///| test "scmap_cell_high_threshold_unassigned" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -140,6 +150,7 @@ test "scmap_cell_high_threshold_unassigned" { // Summary utilities // --------------------------------------------------------------------------- +///| test "scmap_summary_counts" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -156,16 +167,16 @@ test "scmap_summary_counts" { assert_eq(total, assignments.length()) } +///| test "scmap_assignment_to_string" { - let a = @src.ScmapAssignment::new( - "cell1", "T_cell", 0.85, 0.3, "cluster", - ) + let a = @src.ScmapAssignment::new("cell1", "T_cell", 0.85, 0.3, "cluster") let s = a.to_string() assert_true(s.contains("cell1")) assert_true(s.contains("T_cell")) assert_true(s.contains("cluster")) } +///| test "scmap_assignments_to_string" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -179,6 +190,7 @@ test "scmap_assignments_to_string" { // Sample data verification // --------------------------------------------------------------------------- +///| test "scmap_sample_reference_expression_structure" { let ref = @src.scmap_sample_reference() // 10 genes × 9 cells @@ -190,6 +202,7 @@ test "scmap_sample_reference_expression_structure" { assert_true(ref.expression()[3][3] > ref.expression()[3][0]) } +///| test "scmap_sample_query_expression_structure" { let q = @src.scmap_sample_query() // 10 genes × 3 cells @@ -203,6 +216,7 @@ test "scmap_sample_query_expression_structure" { // Edge cases // --------------------------------------------------------------------------- +///| test "scmap_cluster_single_query_cell" { let ref = @src.scmap_sample_reference() // Create a single-cell query using the T cell reference profile @@ -215,6 +229,7 @@ test "scmap_cluster_single_query_cell" { assert_eq(assignments.length(), 1) } +///| test "scmap_cell_single_query_cell" { let ref = @src.scmap_sample_reference() let q = @src.scmap_sample_query() diff --git a/test/moonbit/scnorm_test.mbt b/test/moonbit/scnorm_test.mbt index 8d4dffd2..f3dd380e 100644 --- a/test/moonbit/scnorm_test.mbt +++ b/test/moonbit/scnorm_test.mbt @@ -12,7 +12,7 @@ test "scnorm_library_sizes" { let counts : Array[Array[Double]] = [ [10.0, 20.0, 30.0], [5.0, 15.0, 25.0], - [50.0, 100.0, 150.0] + [50.0, 100.0, 150.0], ] let sizes = @src.sc_norm_library_sizes(counts) assert_eq(sizes.length(), 3) @@ -61,7 +61,7 @@ test "scnorm_full_run" { let count_matrix : Array[Array[Double]] = [ [10.0, 20.0, 30.0], [50.0, 60.0, 70.0], - [100.0, 200.0, 300.0] + [100.0, 200.0, 300.0], ] let gene_ids = ["gene1", "gene2", "gene3"] let cell_ids = ["cell1", "cell2", "cell3"] @@ -74,7 +74,7 @@ test "scnorm_full_run" { test "scnorm_result_accessors" { let count_matrix : Array[Array[Double]] = [ [10.0, 20.0, 30.0], - [50.0, 60.0, 70.0] + [50.0, 60.0, 70.0], ] let gene_ids = ["gene1", "gene2"] let cell_ids = ["cell1", "cell2", "cell3"] diff --git a/test/moonbit/scop_test.mbt b/test/moonbit/scop_test.mbt index c1ed0188..0e899c9d 100644 --- a/test/moonbit/scop_test.mbt +++ b/test/moonbit/scop_test.mbt @@ -17,6 +17,7 @@ test "scop_node_type_name" { assert_eq(@src.scop_node_type_name("xx"), "unknown") } +///| test "scop_node_type_code" { assert_eq(@src.scop_node_type_code("root"), "ro") assert_eq(@src.scop_node_type_code("class"), "cl") @@ -28,6 +29,7 @@ test "scop_node_type_code" { assert_eq(@src.scop_node_type_code("domain"), "px") } +///| test "scop_node_type_order" { assert_true(@src.scop_node_type_order("ro") < @src.scop_node_type_order("cl")) assert_true(@src.scop_node_type_order("cl") < @src.scop_node_type_order("cf")) @@ -42,18 +44,21 @@ test "scop_node_type_order" { // Residues parsing // --------------------------------------------------------------------------- +///| test "scop_parse_residues_dash" { let r = @src.scop_parse_residues("-") assert_eq(r.pdbid(), "") assert_eq(r.fragments().length(), 0) } +///| test "scop_parse_residues_empty" { let r = @src.scop_parse_residues("") assert_eq(r.pdbid(), "") assert_eq(r.fragments().length(), 0) } +///| test "scop_parse_residues_paren_dash" { let r = @src.scop_parse_residues("(-)") assert_eq(r.pdbid(), "") @@ -63,6 +68,7 @@ test "scop_parse_residues_paren_dash" { assert_eq(r.fragments()[0].end_(), "") } +///| test "scop_parse_residues_with_pdbid" { let r = @src.scop_parse_residues("1bba A:10-20,B:") assert_eq(r.pdbid(), "1bba") @@ -77,6 +83,7 @@ test "scop_parse_residues_with_pdbid" { assert_eq(r.fragments()[1].end_(), "") } +///| test "scop_parse_residues_single_chain" { let r = @src.scop_parse_residues("A:1-141") assert_eq(r.pdbid(), "") @@ -86,6 +93,7 @@ test "scop_parse_residues_single_chain" { assert_eq(r.fragments()[0].end_(), "141") } +///| test "scop_residues_to_string_roundtrip" { let r = @src.scop_parse_residues("1hba A:1-141") let s = @src.scop_residues_to_string(r) @@ -97,6 +105,7 @@ test "scop_residues_to_string_roundtrip" { assert_eq(r2.fragments()[0].end_(), "141") } +///| test "scop_residues_to_string_dash" { let r = @src.ScopResidues::new("", []) let s = @src.scop_residues_to_string(r) @@ -107,12 +116,15 @@ test "scop_residues_to_string_dash" { // Record creation and accessors // --------------------------------------------------------------------------- +///| test "scop_cla_record_creation" { let res = @src.scop_parse_residues("1hba A:1-141") let hier : Map[String, Int] = Map([], capacity=8) hier.set("cl", 100) hier.set("cf", 200) - let r = @src.ClaRecord::new("d1hba_", "1hba", res, "a.1.1.1.1.1.1", 1000, hier) + let r = @src.ClaRecord::new( + "d1hba_", "1hba", res, "a.1.1.1.1.1.1", 1000, hier, + ) assert_eq(r.sid(), "d1hba_") assert_eq(r.pdbid(), "1hba") assert_eq(r.sccs(), "a.1.1.1.1.1.1") @@ -120,6 +132,7 @@ test "scop_cla_record_creation" { assert_eq(r.hierarchy().get("cl").unwrap(), 100) } +///| test "scop_des_record_creation" { let r = @src.DesRecord::new( 1000, "px", "a.1.1.1.1.1.1", "d1hba_", "1hba Hemoglobin alpha chain", @@ -131,6 +144,7 @@ test "scop_des_record_creation" { assert_eq(r.description(), "1hba Hemoglobin alpha chain") } +///| test "scop_hie_record_creation" { let r = @src.HieRecord::new(600, 500, [1000, 1001]) assert_eq(r.sunid(), 600) @@ -144,6 +158,7 @@ test "scop_hie_record_creation" { // File parsers // --------------------------------------------------------------------------- +///| test "scop_parse_cla_line" { let line = "d1hba_\t1hba\tA:1-141\ta.1.1.1.1.1.1\t1000\tcl=100,cf=200,sf=300,fa=400,dm=500,sp=600,px=1000" let r = @src.scop_parse_cla_line(line) @@ -157,16 +172,19 @@ test "scop_parse_cla_line" { assert_eq(rec.hierarchy().get("px").unwrap(), 1000) } +///| test "scop_parse_cla_line_comment" { let r = @src.scop_parse_cla_line("# comment line") assert_true(r.is_none()) } +///| test "scop_parse_cla_line_empty" { let r = @src.scop_parse_cla_line("") assert_true(r.is_none()) } +///| test "scop_parse_des_line" { let line = "1000\tpx\ta.1.1.1.1.1.1\td1hba_\t1hba Hemoglobin alpha chain" let r = @src.scop_parse_des_line(line) @@ -177,6 +195,7 @@ test "scop_parse_des_line" { assert_eq(rec.name(), "d1hba_") } +///| test "scop_parse_des_line_class" { let line = "100\tcl\ta\t-\tAll alpha proteins" let r = @src.scop_parse_des_line(line) @@ -188,6 +207,7 @@ test "scop_parse_des_line_class" { assert_eq(rec.description(), "All alpha proteins") } +///| test "scop_parse_hie_line" { let line = "600\t500\t1000,1001" let r = @src.scop_parse_hie_line(line) @@ -198,6 +218,7 @@ test "scop_parse_hie_line" { assert_eq(rec.children().length(), 2) } +///| test "scop_parse_hie_line_root" { let line = "0\t-\t100" let r = @src.scop_parse_hie_line(line) @@ -208,6 +229,7 @@ test "scop_parse_hie_line_root" { assert_eq(rec.children().length(), 1) } +///| test "scop_parse_hie_line_leaf" { let line = "1000\t600\t-" let r = @src.scop_parse_hie_line(line) @@ -218,6 +240,7 @@ test "scop_parse_hie_line_leaf" { assert_eq(rec.children().length(), 0) } +///| test "scop_parse_cla_multiple" { let content = @src.scop_sample_cla() let records = @src.scop_parse_cla(content) @@ -226,6 +249,7 @@ test "scop_parse_cla_multiple" { assert_eq(records[1].sid(), "d1hbb_") } +///| test "scop_parse_des_multiple" { let content = @src.scop_sample_des() let records = @src.scop_parse_des(content) @@ -233,6 +257,7 @@ test "scop_parse_des_multiple" { assert_eq(records.length(), 9) } +///| test "scop_parse_hie_multiple" { let content = @src.scop_sample_hie() let records = @src.scop_parse_hie(content) @@ -243,6 +268,7 @@ test "scop_parse_hie_multiple" { // Scop hierarchy construction and queries // --------------------------------------------------------------------------- +///| test "scop_build_hierarchy" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -255,6 +281,7 @@ test "scop_build_hierarchy" { assert_eq(scop.get_domains().length(), 2) } +///| test "scop_get_node_by_sunid" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -269,6 +296,7 @@ test "scop_get_node_by_sunid" { assert_true(none.is_none()) } +///| test "scop_get_domain_by_sid" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -285,6 +313,7 @@ test "scop_get_domain_by_sid" { assert_true(none.is_none()) } +///| test "scop_get_parent" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -301,6 +330,7 @@ test "scop_get_parent" { assert_true(root_parent.is_none()) } +///| test "scop_get_children" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -317,6 +347,7 @@ test "scop_get_children" { assert_eq(scop.get_children(leaf).length(), 0) } +///| test "scop_get_ascendent_by_code" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -334,6 +365,7 @@ test "scop_get_ascendent_by_code" { assert_eq(fa.unwrap().sunid(), 400) } +///| test "scop_get_ascendent_by_long_name" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -347,6 +379,7 @@ test "scop_get_ascendent_by_long_name" { assert_eq(fold.unwrap().description(), "Globin-like") } +///| test "scop_get_descendents" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -365,6 +398,7 @@ test "scop_get_descendents" { assert_eq(families[0].sunid(), 400) } +///| test "scop_get_descendents_long_name" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -374,6 +408,7 @@ test "scop_get_descendents_long_name" { assert_eq(domains.length(), 2) } +///| test "scop_node_is_domain" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -389,27 +424,32 @@ test "scop_node_is_domain" { // SCCS comparison // --------------------------------------------------------------------------- +///| test "scop_cmp_sccs_equal" { assert_eq(@src.scop_cmp_sccs("a.1.1.1", "a.1.1.1"), 0) } +///| test "scop_cmp_sccs_letter_diff" { assert_true(@src.scop_cmp_sccs("a.1.1.1", "b.1.1.1") < 0) assert_true(@src.scop_cmp_sccs("b.1.1.1", "a.1.1.1") > 0) } +///| test "scop_cmp_sccs_numeric_diff" { assert_true(@src.scop_cmp_sccs("a.1.1.1", "a.1.1.2") < 0) assert_true(@src.scop_cmp_sccs("a.1.1.2", "a.1.1.1") > 0) assert_true(@src.scop_cmp_sccs("a.1.1.1", "a.1.2.1") < 0) } +///| test "scop_cmp_sccs_length_diff" { // Shorter prefix sorts first when all compared components are equal assert_true(@src.scop_cmp_sccs("a.1", "a.1.1") < 0) assert_true(@src.scop_cmp_sccs("a.1.1", "a.1") > 0) } +///| test "scop_cmp_sccs_numeric_not_lexical" { // Numerically, 2 < 11, so a.1.2 < a.1.11 (NOT lexical where "2" > "11") assert_true(@src.scop_cmp_sccs("a.1.2", "a.1.11") < 0) @@ -420,6 +460,7 @@ test "scop_cmp_sccs_numeric_not_lexical" { // Serialization // --------------------------------------------------------------------------- +///| test "scop_write_hie" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -432,6 +473,7 @@ test "scop_write_hie" { assert_true(output.contains("1000\t600\t-")) } +///| test "scop_write_des" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -442,6 +484,7 @@ test "scop_write_des" { assert_true(output.contains("d1hba_")) } +///| test "scop_write_cla" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -457,6 +500,7 @@ test "scop_write_cla" { // Empty Scop // --------------------------------------------------------------------------- +///| test "scop_empty" { let scop = @src.scop_empty() assert_eq(scop.root().sunid(), 0) diff --git a/test/moonbit/searchio_new_test.mbt b/test/moonbit/searchio_new_test.mbt index 3f488995..43a13c89 100644 --- a/test/moonbit/searchio_new_test.mbt +++ b/test/moonbit/searchio_new_test.mbt @@ -20,9 +20,16 @@ test "SearchIOHsp::new construction" { ///| test "SearchIOHsp::n_identical" { let hsp = @src.SearchIOHsp::new( - bitscore=200.5, evalue=1.0e-50, identity=95.0, positives=97.0, - gap=2.0, alignment_length=100, - query_start=1, query_end=100, hit_start=1, hit_end=100, + bitscore=200.5, + evalue=1.0e-50, + identity=95.0, + positives=97.0, + gap=2.0, + alignment_length=100, + query_start=1, + query_end=100, + hit_start=1, + hit_end=100, ) assert_eq(hsp.n_identical(), 95) } @@ -30,9 +37,16 @@ test "SearchIOHsp::n_identical" { ///| test "SearchIOHsp::n_positives" { let hsp = @src.SearchIOHsp::new( - bitscore=200.5, evalue=1.0e-50, identity=95.0, positives=97.0, - gap=2.0, alignment_length=100, - query_start=1, query_end=100, hit_start=1, hit_end=100, + bitscore=200.5, + evalue=1.0e-50, + identity=95.0, + positives=97.0, + gap=2.0, + alignment_length=100, + query_start=1, + query_end=100, + hit_start=1, + hit_end=100, ) assert_eq(hsp.n_positives(), 97) } @@ -40,9 +54,16 @@ test "SearchIOHsp::n_positives" { ///| test "SearchIOHsp::n_gaps" { let hsp = @src.SearchIOHsp::new( - bitscore=200.5, evalue=1.0e-50, identity=95.0, positives=97.0, - gap=2.0, alignment_length=100, - query_start=1, query_end=100, hit_start=1, hit_end=100, + bitscore=200.5, + evalue=1.0e-50, + identity=95.0, + positives=97.0, + gap=2.0, + alignment_length=100, + query_start=1, + query_end=100, + hit_start=1, + hit_end=100, ) assert_eq(hsp.n_gaps(), 2) } @@ -50,9 +71,16 @@ test "SearchIOHsp::n_gaps" { ///| test "SearchIOHsp::with_query_seq" { let hsp = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = hsp.with_query_seq("ATCGATCG") assert_eq(hsp2.query_seq, "ATCGATCG") @@ -61,9 +89,16 @@ test "SearchIOHsp::with_query_seq" { ///| test "SearchIOHsp::with_hit_seq" { let hsp = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = hsp.with_hit_seq("ATCGATCG") assert_eq(hsp2.hit_seq, "ATCGATCG") @@ -72,9 +107,16 @@ test "SearchIOHsp::with_hit_seq" { ///| test "SearchIOHsp::with_midline" { let hsp = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = hsp.with_midline("||||||..") assert_eq(hsp2.midline, "||||||..") @@ -83,9 +125,16 @@ test "SearchIOHsp::with_midline" { ///| test "SearchIOHsp::with_frames" { let hsp = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = hsp.with_frames(1, -1) assert_eq(hsp2.query_frame, 1) @@ -94,7 +143,11 @@ test "SearchIOHsp::with_frames" { ///| test "SearchIOHit::new construction" { - let hit = @src.SearchIOHit::new(id="hit1", description="Test hit", seq_length=1000) + let hit = @src.SearchIOHit::new( + id="hit1", + description="Test hit", + seq_length=1000, + ) assert_eq(hit.id, "hit1") assert_eq(hit.description, "Test hit") assert_eq(hit.seq_length, 1000) @@ -104,14 +157,28 @@ test "SearchIOHit::new construction" { ///| test "SearchIOHit::add_hsp and best_hsp" { let hsp1 = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = @src.SearchIOHsp::new( - bitscore=200.0, evalue=1.0e-40, identity=95.0, positives=97.0, - gap=0.5, alignment_length=80, - query_start=51, query_end=130, hit_start=51, hit_end=130, + bitscore=200.0, + evalue=1.0e-40, + identity=95.0, + positives=97.0, + gap=0.5, + alignment_length=80, + query_start=51, + query_end=130, + hit_start=51, + hit_end=130, ) let hit = @src.SearchIOHit::new(id="hit1", description="Test", seq_length=500) let hit_with_hsps = hit.add_hsp(hsp1).add_hsp(hsp2) @@ -137,14 +204,28 @@ test "SearchIOHit::best_hsp empty" { ///| test "SearchIOHit::sum_bitscore" { let hsp1 = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = @src.SearchIOHsp::new( - bitscore=200.0, evalue=1.0e-40, identity=95.0, positives=97.0, - gap=0.5, alignment_length=80, - query_start=51, query_end=130, hit_start=51, hit_end=130, + bitscore=200.0, + evalue=1.0e-40, + identity=95.0, + positives=97.0, + gap=0.5, + alignment_length=80, + query_start=51, + query_end=130, + hit_start=51, + hit_end=130, ) let hit = @src.SearchIOHit::new(id="hit1", description="Test", seq_length=500) let hit_with_hsps = hit.add_hsp(hsp1).add_hsp(hsp2) @@ -155,7 +236,10 @@ test "SearchIOHit::sum_bitscore" { ///| test "SearchIOQueryResult::new construction" { let qr = @src.SearchIOQueryResult::new( - id="query1", description="Test query", seq_length=500, database="nr", + id="query1", + description="Test query", + seq_length=500, + database="nr", ) assert_eq(qr.id, "query1") assert_eq(qr.description, "Test query") @@ -166,9 +250,16 @@ test "SearchIOQueryResult::new construction" { ///| test "SearchIOQueryResult::add_hit" { let qr = @src.SearchIOQueryResult::new( - id="query1", description="Test", seq_length=500, database="nr", + id="query1", + description="Test", + seq_length=500, + database="nr", + ) + let hit = @src.SearchIOHit::new( + id="hit1", + description="Hit 1", + seq_length=300, ) - let hit = @src.SearchIOHit::new(id="hit1", description="Hit 1", seq_length=300) let qr2 = qr.add_hit(hit) assert_eq(qr2.n_hits, 1) } @@ -176,20 +267,47 @@ test "SearchIOQueryResult::add_hit" { ///| test "SearchIOQueryResult::sort_by_score" { let hsp1 = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = @src.SearchIOHsp::new( - bitscore=200.0, evalue=1.0e-40, identity=95.0, positives=97.0, - gap=0.5, alignment_length=80, - query_start=1, query_end=80, hit_start=1, hit_end=80, + bitscore=200.0, + evalue=1.0e-40, + identity=95.0, + positives=97.0, + gap=0.5, + alignment_length=80, + query_start=1, + query_end=80, + hit_start=1, + hit_end=80, ) - let hit1 = @src.SearchIOHit::new(id="low", description="Low score", seq_length=300).add_hsp(hsp1) - let hit2 = @src.SearchIOHit::new(id="high", description="High score", seq_length=400).add_hsp(hsp2) + let hit1 = @src.SearchIOHit::new( + id="low", + description="Low score", + seq_length=300, + ).add_hsp(hsp1) + let hit2 = @src.SearchIOHit::new( + id="high", + description="High score", + seq_length=400, + ).add_hsp(hsp2) let qr = @src.SearchIOQueryResult::new( - id="query1", description="Test", seq_length=500, database="nr", - ).add_hit(hit1).add_hit(hit2) + id="query1", + description="Test", + seq_length=500, + database="nr", + ) + .add_hit(hit1) + .add_hit(hit2) let sorted = qr.sort_by_score() assert_eq(sorted.hits[0].id, "high") assert_eq(sorted.hits[1].id, "low") @@ -198,20 +316,43 @@ test "SearchIOQueryResult::sort_by_score" { ///| test "SearchIOQueryResult::filter_evalue" { let hsp1 = @src.SearchIOHsp::new( - bitscore=100.0, evalue=0.05, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=0.05, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = @src.SearchIOHsp::new( - bitscore=200.0, evalue=1.0e-40, identity=95.0, positives=97.0, - gap=0.5, alignment_length=80, - query_start=1, query_end=80, hit_start=1, hit_end=80, + bitscore=200.0, + evalue=1.0e-40, + identity=95.0, + positives=97.0, + gap=0.5, + alignment_length=80, + query_start=1, + query_end=80, + hit_start=1, + hit_end=80, + ) + let hit1 = @src.SearchIOHit::new(id="hit1", description="", seq_length=300).add_hsp( + hsp1, + ) + let hit2 = @src.SearchIOHit::new(id="hit2", description="", seq_length=400).add_hsp( + hsp2, ) - let hit1 = @src.SearchIOHit::new(id="hit1", description="", seq_length=300).add_hsp(hsp1) - let hit2 = @src.SearchIOHit::new(id="hit2", description="", seq_length=400).add_hsp(hsp2) let qr = @src.SearchIOQueryResult::new( - id="query1", description="", seq_length=500, database="nr", - ).add_hit(hit1).add_hit(hit2) + id="query1", + description="", + seq_length=500, + database="nr", + ) + .add_hit(hit1) + .add_hit(hit2) let filtered = qr.filter_evalue(0.01) assert_eq(filtered.n_hits, 1) assert_eq(filtered.hits[0].id, "hit2") @@ -220,26 +361,59 @@ test "SearchIOQueryResult::filter_evalue" { ///| test "SearchIOQueryResult::top_n" { let hsp1 = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = @src.SearchIOHsp::new( - bitscore=200.0, evalue=1.0e-40, identity=95.0, positives=97.0, - gap=0.5, alignment_length=80, - query_start=1, query_end=80, hit_start=1, hit_end=80, + bitscore=200.0, + evalue=1.0e-40, + identity=95.0, + positives=97.0, + gap=0.5, + alignment_length=80, + query_start=1, + query_end=80, + hit_start=1, + hit_end=80, ) let hsp3 = @src.SearchIOHsp::new( - bitscore=150.0, evalue=1.0e-30, identity=92.0, positives=94.0, - gap=0.8, alignment_length=60, - query_start=1, query_end=60, hit_start=1, hit_end=60, + bitscore=150.0, + evalue=1.0e-30, + identity=92.0, + positives=94.0, + gap=0.8, + alignment_length=60, + query_start=1, + query_end=60, + hit_start=1, + hit_end=60, + ) + let hit1 = @src.SearchIOHit::new(id="low", description="", seq_length=300).add_hsp( + hsp1, + ) + let hit2 = @src.SearchIOHit::new(id="high", description="", seq_length=400).add_hsp( + hsp2, + ) + let hit3 = @src.SearchIOHit::new(id="mid", description="", seq_length=350).add_hsp( + hsp3, ) - let hit1 = @src.SearchIOHit::new(id="low", description="", seq_length=300).add_hsp(hsp1) - let hit2 = @src.SearchIOHit::new(id="high", description="", seq_length=400).add_hsp(hsp2) - let hit3 = @src.SearchIOHit::new(id="mid", description="", seq_length=350).add_hsp(hsp3) let qr = @src.SearchIOQueryResult::new( - id="query1", description="", seq_length=500, database="nr", - ).add_hit(hit1).add_hit(hit2).add_hit(hit3) + id="query1", + description="", + seq_length=500, + database="nr", + ) + .add_hit(hit1) + .add_hit(hit2) + .add_hit(hit3) let tops = qr.top_n(2) assert_eq(tops.length(), 2) assert_eq(tops[0].id, "high") @@ -249,13 +423,25 @@ test "SearchIOQueryResult::top_n" { ///| test "SearchIOQueryResult::top_n exceeds total" { let hsp = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, + ) + let hit = @src.SearchIOHit::new(id="hit1", description="", seq_length=300).add_hsp( + hsp, ) - let hit = @src.SearchIOHit::new(id="hit1", description="", seq_length=300).add_hsp(hsp) let qr = @src.SearchIOQueryResult::new( - id="query1", description="", seq_length=500, database="nr", + id="query1", + description="", + seq_length=500, + database="nr", ).add_hit(hit) let tops = qr.top_n(5) assert_eq(tops.length(), 1) @@ -264,7 +450,10 @@ test "SearchIOQueryResult::top_n exceeds total" { ///| test "SearchIOQueryResult::with_total_hits" { let qr = @src.SearchIOQueryResult::new( - id="query1", description="", seq_length=500, database="nr", + id="query1", + description="", + seq_length=500, + database="nr", ) let qr2 = qr.with_total_hits(100) assert_eq(qr2.total_hits, 100) @@ -298,7 +487,10 @@ test "search_io_mock_blast_tabular" { ///| test "SearchIOIterator::parse_blast_tabular basic" { let content = @src.search_io_mock_blast_tabular() - let iter = @src.SearchIOIterator::new(content, @src.search_io_format_from_str("blast-tab")) + let iter = @src.SearchIOIterator::new( + content, + @src.search_io_format_from_str("blast-tab"), + ) let results = iter.parse_blast_tabular() assert_true(results.length() >= 0) } @@ -306,7 +498,10 @@ test "SearchIOIterator::parse_blast_tabular basic" { ///| test "SearchIOIterator::parse_blast_tabular hit count" { let content = @src.search_io_mock_blast_tabular() - let iter = @src.SearchIOIterator::new(content, @src.search_io_format_from_str("blast-tab")) + let iter = @src.SearchIOIterator::new( + content, + @src.search_io_format_from_str("blast-tab"), + ) let results = iter.parse_blast_tabular() assert_true(results.length() >= 0) } @@ -314,21 +509,30 @@ test "SearchIOIterator::parse_blast_tabular hit count" { ///| test "SearchIOIterator::parse_blast_tabular scores" { let content = @src.search_io_mock_blast_tabular() - let iter = @src.SearchIOIterator::new(content, @src.search_io_format_from_str("blast-tab")) + let iter = @src.SearchIOIterator::new( + content, + @src.search_io_format_from_str("blast-tab"), + ) let results = iter.parse_blast_tabular() assert_true(results.length() >= 0) } ///| test "SearchIOIterator::parse empty content" { - let iter = @src.SearchIOIterator::new("", @src.search_io_format_from_str("blast-tab")) + let iter = @src.SearchIOIterator::new( + "", + @src.search_io_format_from_str("blast-tab"), + ) let results = iter.parse_blast_tabular() assert_eq(results.length(), 0) } ///| test "SearchIOIterator::parse empty content text" { - let iter = @src.SearchIOIterator::new("", @src.search_io_format_from_str("blast-text")) + let iter = @src.SearchIOIterator::new( + "", + @src.search_io_format_from_str("blast-text"), + ) let results = iter.parse_blast_text() assert_eq(results.length(), 0) } @@ -340,7 +544,10 @@ test "SearchIOIterator::parse blast text basic" { ">hit1 description\n" + "Score = 200.5 (520 bits), Expect = 1.0e-50\n" + "Identities = 95/100 (95%)\n" - let iter = @src.SearchIOIterator::new(text, @src.search_io_format_from_str("blast-text")) + let iter = @src.SearchIOIterator::new( + text, + @src.search_io_format_from_str("blast-text"), + ) let results = iter.parse_blast_text() assert_true(results.length() >= 0) } @@ -348,7 +555,10 @@ test "SearchIOIterator::parse blast text basic" { ///| test "SearchIOIterator::parse dispatch" { let content = @src.search_io_mock_blast_tabular() - let iter = @src.SearchIOIterator::new(content, @src.search_io_format_from_str("blast-tab")) + let iter = @src.SearchIOIterator::new( + content, + @src.search_io_format_from_str("blast-tab"), + ) let results = iter.parse() assert_true(results.length() >= 0) } @@ -356,7 +566,10 @@ test "SearchIOIterator::parse dispatch" { ///| test "SearchIOIterator::parse unknown format returns empty" { let content = "some content" - let iter = @src.SearchIOIterator::new(content, @src.search_io_format_from_str("unknown")) + let iter = @src.SearchIOIterator::new( + content, + @src.search_io_format_from_str("unknown"), + ) let results = iter.parse() assert_eq(results.length(), 0) } diff --git a/test/moonbit/seq_complexity_test.mbt b/test/moonbit/seq_complexity_test.mbt index ff10eaa2..3a3125bc 100644 --- a/test/moonbit/seq_complexity_test.mbt +++ b/test/moonbit/seq_complexity_test.mbt @@ -134,6 +134,7 @@ test "seq_complexity: sequence_similarity_empty" { // LCC (Wooton-Federhen) tests +///| test "seq_complexity: lcc_basic" { let scores = @src.lcc("ATCGATCGATCGATCG", window=12, k=3) assert_true(scores.length() > 0) @@ -144,6 +145,7 @@ test "seq_complexity: lcc_basic" { } } +///| test "seq_complexity: lcc_low_complexity" { let scores = @src.lcc("AAAAAAAAAAAAAAAA", window=12, k=3) assert_true(scores.length() > 0) @@ -153,20 +155,28 @@ test "seq_complexity: lcc_low_complexity" { } } +///| test "seq_complexity: lcc_empty" { let scores = @src.lcc("", window=12, k=3) assert_eq(scores.length(), 0) } +///| test "seq_complexity: lcc_short" { let scores = @src.lcc("AC", window=12, k=3) assert_eq(scores.length(), 0) } +///| test "seq_complexity: lcc_low_complexity_regions" { // Mix of low complexity and high complexity let seq = "AAAAAAAAAAAAAACGATCGATCG" - let regions = @src.lcc_low_complexity_regions(seq, window=12, k=3, threshold=0.15) + let regions = @src.lcc_low_complexity_regions( + seq, + window=12, + k=3, + threshold=0.15, + ) // Should find low complexity region at the beginning assert_true(regions.length() > 0) } diff --git a/test/moonbit/seq_location_test.mbt b/test/moonbit/seq_location_test.mbt index 6326c089..59b6fe7d 100644 --- a/test/moonbit/seq_location_test.mbt +++ b/test/moonbit/seq_location_test.mbt @@ -1,161 +1,227 @@ ///| /// Test file for seq_location module. - test "exact_position" { let pos = @src.exact_position(42) - assert_eq!(pos.get(), 42) - assert_eq!(pos.to_string(), "42") - assert_eq!(pos.is_exact(), true) + assert_eq(pos.get(), 42) + assert_eq(pos.to_string(), "42") + assert_eq(pos.is_exact(), true) } +///| test "before_position" { let pos = @src.before_position(50) - assert_eq!(pos.get(), 50) - assert_eq!(pos.to_string(), "<50") - assert_eq!(pos.is_exact(), false) + assert_eq(pos.get(), 50) + assert_eq(pos.to_string(), "<50") + assert_eq(pos.is_exact(), false) } +///| test "after_position" { let pos = @src.after_position(100) - assert_eq!(pos.get(), 100) - assert_eq!(pos.to_string(), ">100") - assert_eq!(pos.is_exact(), false) + assert_eq(pos.get(), 100) + assert_eq(pos.to_string(), ">100") + assert_eq(pos.is_exact(), false) } +///| test "one_of_position" { let opts : Array[@src.Pos] = Array::new() opts.push(@src.exact_position(5)) opts.push(@src.exact_position(7)) opts.push(@src.exact_position(9)) let pos = @src.one_of_position(7, opts) - assert_eq!(pos.get(), 7) - assert_eq!(pos.is_exact(), false) + assert_eq(pos.get(), 7) + assert_eq(pos.is_exact(), false) let s = pos.to_string() - assert_eq!(s.starts_with("{"), true) - assert_eq!(s.contains("5"), true) - assert_eq!(s.contains("7"), true) - assert_eq!(s.contains("9"), true) + assert_eq(s.starts_with("{"), true) + assert_eq(s.contains("5"), true) + assert_eq(s.contains("7"), true) + assert_eq(s.contains("9"), true) } +///| test "within_position" { - let pos = @src.within_position(50, @src.exact_position(40), @src.exact_position(60)) - assert_eq!(pos.get(), 50) - assert_eq!(pos.is_exact(), false) + let pos = @src.within_position( + 50, + @src.exact_position(40), + @src.exact_position(60), + ) + assert_eq(pos.get(), 50) + assert_eq(pos.is_exact(), false) let s = pos.to_string() - assert_eq!(s.starts_with("("), true) - assert_eq!(s.contains("40"), true) - assert_eq!(s.contains("60"), true) + assert_eq(s.starts_with("("), true) + assert_eq(s.contains("40"), true) + assert_eq(s.contains("60"), true) } +///| test "simple_location_basic" { - let loc = @src.simple_location(@src.exact_position(10), @src.exact_position(50), strand="+") - assert_eq!(loc.start(), 10) - assert_eq!(loc.end(), 50) - assert_eq!(loc.strand(), "+") - assert_eq!(loc.len(), 40) - assert_eq!(loc.is_compound(), false) - assert_eq!(loc.to_string(), "10..50") + let loc = @src.simple_location( + @src.exact_position(10), + @src.exact_position(50), + strand="+", + ) + assert_eq(loc.start(), 10) + assert_eq(loc.end(), 50) + assert_eq(loc.strand(), "+") + assert_eq(loc.len(), 40) + assert_eq(loc.is_compound(), false) + assert_eq(loc.to_string(), "10..50") } +///| test "simple_location_reverse_strand" { - let loc = @src.simple_location(@src.exact_position(100), @src.exact_position(200), strand="-") - assert_eq!(loc.strand(), "-") - assert_eq!(loc.len(), 100) + let loc = @src.simple_location( + @src.exact_position(100), + @src.exact_position(200), + strand="-", + ) + assert_eq(loc.strand(), "-") + assert_eq(loc.len(), 100) } +///| test "simple_location_overlaps" { - let loc1 = @src.simple_location(@src.exact_position(10), @src.exact_position(50)) - let loc2 = @src.simple_location(@src.exact_position(30), @src.exact_position(70)) - let loc3 = @src.simple_location(@src.exact_position(100), @src.exact_position(200)) - assert_eq!(loc1.overlaps(loc2), true) - assert_eq!(loc1.overlaps(loc3), false) + let loc1 = @src.simple_location( + @src.exact_position(10), + @src.exact_position(50), + ) + let loc2 = @src.simple_location( + @src.exact_position(30), + @src.exact_position(70), + ) + let loc3 = @src.simple_location( + @src.exact_position(100), + @src.exact_position(200), + ) + assert_eq(loc1.overlaps(loc2), true) + assert_eq(loc1.overlaps(loc3), false) } +///| test "simple_location_contains" { - let loc = @src.simple_location(@src.exact_position(10), @src.exact_position(50)) - assert_eq!(loc.contains(10), true) - assert_eq!(loc.contains(25), true) - assert_eq!(loc.contains(49), true) - assert_eq!(loc.contains(5), false) - assert_eq!(loc.contains(50), false) - assert_eq!(loc.contains(100), false) + let loc = @src.simple_location( + @src.exact_position(10), + @src.exact_position(50), + ) + assert_eq(loc.contains(10), true) + assert_eq(loc.contains(25), true) + assert_eq(loc.contains(49), true) + assert_eq(loc.contains(5), false) + assert_eq(loc.contains(50), false) + assert_eq(loc.contains(100), false) } +///| test "compound_location_basic" { - let exon1 = @src.simple_location(@src.exact_position(0), @src.exact_position(100)) - let exon2 = @src.simple_location(@src.exact_position(200), @src.exact_position(350)) + let exon1 = @src.simple_location( + @src.exact_position(0), + @src.exact_position(100), + ) + let exon2 = @src.simple_location( + @src.exact_position(200), + @src.exact_position(350), + ) let locs : Array[@src.Loc] = Array::new() locs.push(exon1) locs.push(exon2) let cl = @src.compound_location(locs, strand="+") - assert_eq!(cl.is_compound(), true) - assert_eq!(cl.parts().length(), 2) - assert_eq!(cl.len(), 250) + assert_eq(cl.is_compound(), true) + assert_eq(cl.parts().length(), 2) + assert_eq(cl.len(), 250) } +///| test "compound_from_simple" { let starts : Array[Int] = [0, 200, 500] let ends : Array[Int] = [100, 350, 600] let cl = @src.compound_from_simple(starts, ends, strand="+") - assert_eq!(cl.is_compound(), true) - assert_eq!(cl.parts().length(), 3) - assert_eq!(cl.len(), 350) // 100 + 150 + 100 + assert_eq(cl.is_compound(), true) + assert_eq(cl.parts().length(), 3) + assert_eq(cl.len(), 350) // 100 + 150 + 100 } +///| test "compound_location_overlaps" { - let exon1 = @src.simple_location(@src.exact_position(0), @src.exact_position(100)) - let exon2 = @src.simple_location(@src.exact_position(200), @src.exact_position(350)) + let exon1 = @src.simple_location( + @src.exact_position(0), + @src.exact_position(100), + ) + let exon2 = @src.simple_location( + @src.exact_position(200), + @src.exact_position(350), + ) let locs : Array[@src.Loc] = Array::new() locs.push(exon1) locs.push(exon2) let cl = @src.compound_location(locs) - let overlapping = @src.simple_location(@src.exact_position(50), @src.exact_position(150)) - let not_overlapping = @src.simple_location(@src.exact_position(400), @src.exact_position(500)) - assert_eq!(cl.overlaps(overlapping), true) - assert_eq!(cl.overlaps(not_overlapping), false) + let overlapping = @src.simple_location( + @src.exact_position(50), + @src.exact_position(150), + ) + let not_overlapping = @src.simple_location( + @src.exact_position(400), + @src.exact_position(500), + ) + assert_eq(cl.overlaps(overlapping), true) + assert_eq(cl.overlaps(not_overlapping), false) } +///| test "compound_location_contains" { - let exon1 = @src.simple_location(@src.exact_position(0), @src.exact_position(100)) - let exon2 = @src.simple_location(@src.exact_position(200), @src.exact_position(350)) + let exon1 = @src.simple_location( + @src.exact_position(0), + @src.exact_position(100), + ) + let exon2 = @src.simple_location( + @src.exact_position(200), + @src.exact_position(350), + ) let locs : Array[@src.Loc] = Array::new() locs.push(exon1) locs.push(exon2) let cl = @src.compound_location(locs) - assert_eq!(cl.contains(50), true) - assert_eq!(cl.contains(250), true) - assert_eq!(cl.contains(150), false) - assert_eq!(cl.contains(400), false) + assert_eq(cl.contains(50), true) + assert_eq(cl.contains(250), true) + assert_eq(cl.contains(150), false) + assert_eq(cl.contains(400), false) } +///| test "location_genbank_format" { - let loc = @src.simple_location(@src.exact_position(9), @src.exact_position(50)) + let loc = @src.simple_location( + @src.exact_position(9), + @src.exact_position(50), + ) let gb = @src.location_to_genbank(loc) - assert_eq!(gb.contains("10"), true) - assert_eq!(gb.contains("50"), true) + assert_eq(gb.contains("10"), true) + assert_eq(gb.contains("50"), true) } +///| test "from_genbank_coords" { let loc = @src.from_genbank_coords(10, 50, strand="+") - assert_eq!(loc.start(), 9) - assert_eq!(loc.end(), 50) - assert_eq!(loc.strand(), "+") - assert_eq!(loc.len(), 41) + assert_eq(loc.start(), 9) + assert_eq(loc.end(), 50) + assert_eq(loc.strand(), "+") + assert_eq(loc.len(), 41) } +///| test "parse_genbank_location_simple" { let loc = @src.parse_genbank_location("10..50") - assert_eq!(loc.start(), 9) // 0-based - assert_eq!(loc.end(), 50) - assert_eq!(loc.len(), 41) + assert_eq(loc.start(), 9) // 0-based + assert_eq(loc.end(), 50) + assert_eq(loc.len(), 41) } +///| test "seq_location_sample" { let samples = @src.seq_location_sample() - assert_eq!(samples.length(), 5) + assert_eq(samples.length(), 5) // First is simple forward - assert_eq!(samples[0].is_compound(), false) + assert_eq(samples[0].is_compound(), false) // Third is compound - assert_eq!(samples[2].is_compound(), true) + assert_eq(samples[2].is_compound(), true) } diff --git a/test/moonbit/seq_quality_trim_test.mbt b/test/moonbit/seq_quality_trim_test.mbt index a27c52c1..c61d1a39 100644 --- a/test/moonbit/seq_quality_trim_test.mbt +++ b/test/moonbit/seq_quality_trim_test.mbt @@ -113,7 +113,10 @@ test "sqt_trim_adapter_perfect_match" { let qual = "IIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" let (t_seq, _) = @src.sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, + seq, + qual, + adapter, + allowed_mismatches=0, ) assert_eq(t_seq, "ACGTACGT") assert_eq(t_seq.length(), 8) @@ -125,7 +128,10 @@ test "sqt_trim_adapter_with_mismatches" { let qual = "IIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" let (t_seq, _) = @src.sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=2, + seq, + qual, + adapter, + allowed_mismatches=2, ) assert_eq(t_seq, "ACGTACGT") } @@ -136,7 +142,10 @@ test "sqt_trim_adapter_no_match" { let qual = "IIIIIIIIIIIIIIII" let adapter = "GGGGGGGG" let (t_seq, _) = @src.sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, + seq, + qual, + adapter, + allowed_mismatches=0, ) assert_eq(t_seq, "ACGTACGTACGTACGT") assert_eq(t_seq.length(), 16) @@ -146,9 +155,7 @@ test "sqt_trim_adapter_no_match" { test "sqt_trim_adapter_empty_adapter" { let seq = "ACGTACGT" let qual = "IIIIIIII" - let (t_seq, _) = @src.sqt_trim_adapter( - seq, qual, "", allowed_mismatches=0, - ) + let (t_seq, _) = @src.sqt_trim_adapter(seq, qual, "", allowed_mismatches=0) assert_eq(t_seq, "ACGTACGT") } @@ -158,7 +165,10 @@ test "sqt_trim_adapter_short_sequence" { let qual = "II" let adapter = "AGATCGGAA" let (t_seq, _) = @src.sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, + seq, + qual, + adapter, + allowed_mismatches=0, ) assert_eq(t_seq, "AC") } @@ -169,7 +179,10 @@ test "sqt_trim_adapter_at_beginning" { let qual = "IIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" let (t_seq, _) = @src.sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, + seq, + qual, + adapter, + allowed_mismatches=0, ) assert_eq(t_seq.length(), 0) } @@ -180,7 +193,10 @@ test "sqt_trim_adapter_partial_overlap" { let qual = "IIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" let (t_seq, _) = @src.sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=1, + seq, + qual, + adapter, + allowed_mismatches=1, ) assert_eq(t_seq, "ACGTACGT") } @@ -191,7 +207,10 @@ test "sqt_trim_adapter_at_3_prime_end" { let qual = "IIIIIIIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" let (t_seq, _) = @src.sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, + seq, + qual, + adapter, + allowed_mismatches=0, ) assert_eq(t_seq, "ACGTACGTACGT") } @@ -344,9 +363,7 @@ test "sqt_trim_reads_batch_with_adapter_config" { ] let qual_config = @src.QualityConfig::new(20, 4, 4, 20) let adapter_config = @src.AdapterConfig::new(["AGATCGGAA"], 4, 0) - let results = @src.sqt_trim_reads( - reads, qual_config, Some(adapter_config), - ) + let results = @src.sqt_trim_reads(reads, qual_config, Some(adapter_config)) assert_eq(results.length(), 1) assert_eq(results[0].trimmed_seq, "ACGTACGT") assert_true(results[0].trim_type == "adapter:AGATCGGAA") @@ -354,9 +371,7 @@ test "sqt_trim_reads_batch_with_adapter_config" { ///| test "sqt_trim_reads_quality_trim_only" { - let reads = [ - @src.FastqRead::new("r1", "ACGTACGT", "IIII####"), - ] + let reads = [@src.FastqRead::new("r1", "ACGTACGT", "IIII####")] let qual_config = @src.QualityConfig::new(20, 4, 4, 20) let results = @src.sqt_trim_reads(reads, qual_config, None) assert_eq(results.length(), 1) @@ -365,9 +380,7 @@ test "sqt_trim_reads_quality_trim_only" { ///| test "sqt_trim_reads_poly_a_trim" { - let reads = [ - @src.FastqRead::new("r1", "ACGTACGGGAAAA", "IIIIIIIIIIIIII"), - ] + let reads = [@src.FastqRead::new("r1", "ACGTACGGGAAAA", "IIIIIIIIIIIIII")] let qual_config = @src.QualityConfig::new(20, 4, 4, 20) let results = @src.sqt_trim_reads(reads, qual_config, None) assert_eq(results.length(), 1) @@ -381,9 +394,7 @@ test "sqt_trim_reads_adapter_at_end" { ] let qual_config = @src.QualityConfig::new(20, 4, 4, 20) let adapter_config = @src.AdapterConfig::new(["AGATCGGAA"], 4, 0) - let results = @src.sqt_trim_reads( - reads, qual_config, Some(adapter_config), - ) + let results = @src.sqt_trim_reads(reads, qual_config, Some(adapter_config)) assert_eq(results.length(), 1) assert_eq(results[0].trimmed_seq, "ACGTACGTACGT") } @@ -398,9 +409,7 @@ test "sqt_trim_reads_empty_batch" { ///| test "sqt_trim_reads_preserves_original_data" { - let reads = [ - @src.FastqRead::new("read_orig", "ACGTACGT", "IIIIIIII"), - ] + let reads = [@src.FastqRead::new("read_orig", "ACGTACGT", "IIIIIIII")] let qual_config = @src.QualityConfig::new(20, 4, 4, 20) let results = @src.sqt_trim_reads(reads, qual_config, None) assert_eq(results.length(), 1) @@ -416,7 +425,9 @@ test "sqt_compute_stats_basic" { @src.FastqRead::new("r2", "TTTTTTTT", "IIIIIIII"), ] let results = [ - @src.TrimResult::new("r1", "ACGTACGT", "ACGTACGT", "IIIIIIII", "IIIIIIII", "none"), + @src.TrimResult::new( + "r1", "ACGTACGT", "ACGTACGT", "IIIIIIII", "IIIIIIII", "none", + ), @src.TrimResult::new("r2", "TTTTTTTT", "", "IIIIIIII", "", "poly_A"), ] let stats = @src.sqt_compute_stats(results, reads) @@ -434,8 +445,12 @@ test "sqt_compute_stats_gc_content" { @src.FastqRead::new("at_high", "AAAATTTT", "IIIIIIII"), ] let results = [ - @src.TrimResult::new("gc_high", "GGGGCCCC", "GGGGCCCC", "IIIIIIII", "IIIIIIII", "none"), - @src.TrimResult::new("at_high", "AAAATTTT", "AAAATTTT", "IIIIIIII", "IIIIIIII", "none"), + @src.TrimResult::new( + "gc_high", "GGGGCCCC", "GGGGCCCC", "IIIIIIII", "IIIIIIII", "none", + ), + @src.TrimResult::new( + "at_high", "AAAATTTT", "AAAATTTT", "IIIIIIII", "IIIIIIII", "none", + ), ] let stats = @src.sqt_compute_stats(results, reads) assert_true(stats.gc_content_before > 0.4) @@ -455,12 +470,8 @@ test "sqt_compute_stats_empty" { ///| test "sqt_compute_stats_all_discarded" { - let reads = [ - @src.FastqRead::new("r1", "ACGT", "IIII"), - ] - let results = [ - @src.TrimResult::new("r1", "ACGT", "", "IIII", "", "quality"), - ] + let reads = [@src.FastqRead::new("r1", "ACGT", "IIII")] + let results = [@src.TrimResult::new("r1", "ACGT", "", "IIII", "", "quality")] let stats = @src.sqt_compute_stats(results, reads) assert_eq(stats.total_reads, 1) assert_eq(stats.kept_reads, 0) @@ -532,9 +543,7 @@ test "sqt_fastq_parse_multiple_with_variable_length" { ///| test "sqt_fastq_serialize_single" { - let reads = [ - @src.FastqRead::new("test1", "ACGT", "IIII"), - ] + let reads = [@src.FastqRead::new("test1", "ACGT", "IIII")] let output = @src.sqt_fastq_serialize(reads) assert_eq(output, "@test1\nACGT\n+\nIIII\n") } @@ -561,4 +570,4 @@ test "sqt_fastq_roundtrip" { assert_eq(reparsed[0].sequence, "ACGTACGT") assert_eq(reparsed[1].id, "sample2") assert_eq(reparsed[1].sequence, "TGCA") -} \ No newline at end of file +} diff --git a/test/moonbit/seqfeature_advanced_test.mbt b/test/moonbit/seqfeature_advanced_test.mbt index 63ac3e2b..625fbfda 100644 --- a/test/moonbit/seqfeature_advanced_test.mbt +++ b/test/moonbit/seqfeature_advanced_test.mbt @@ -580,4 +580,4 @@ test "seq_feature_extended_qualifiers_independent" { let feat2 = feat1.add_qualifier("gene", "BRCA1") assert_eq(feat1.qualifiers().length(), 0) assert_eq(feat2.qualifiers().length(), 1) -} \ No newline at end of file +} diff --git a/test/moonbit/seqio_advanced_test.mbt b/test/moonbit/seqio_advanced_test.mbt index d249c719..ffd0df6f 100644 --- a/test/moonbit/seqio_advanced_test.mbt +++ b/test/moonbit/seqio_advanced_test.mbt @@ -10,8 +10,7 @@ ///| test "parse_embl_basic_single" { - let embl_text = - "ID HSBGLOD; SV 1; linear; genomic DNA; STD; HUM; 500 BP.\n" + + let embl_text = "ID HSBGLOD; SV 1; linear; genomic DNA; STD; HUM; 500 BP.\n" + "XX\n" + "AC M12345;\n" + "XX\n" + @@ -26,13 +25,15 @@ test "parse_embl_basic_single" { assert_eq(records[0].id, "M12345") assert_eq(records[0].name, "HSBGLOD") assert_eq(records[0].description, "Human beta-globin gene region") - assert_eq(records[0].seq.to_string(), "ATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGC") + assert_eq( + records[0].seq.to_string(), + "ATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGC", + ) } ///| test "parse_embl_multiple_records" { - let embl_text = - "ID SEQ1; SV 1; linear; DNA; STD; 10 BP.\n" + + let embl_text = "ID SEQ1; SV 1; linear; DNA; STD; 10 BP.\n" + "XX\n" + "AC ACC001;\n" + "XX\n" + @@ -63,8 +64,7 @@ test "parse_embl_multiple_records" { ///| test "parse_embl_no_ac_uses_id" { - let embl_text = - "ID MYSEQ; SV 1; linear; DNA; STD; 4 BP.\n" + + let embl_text = "ID MYSEQ; SV 1; linear; DNA; STD; 4 BP.\n" + "XX\n" + "DE Sequence without accession.\n" + "XX\n" + @@ -82,8 +82,7 @@ test "parse_embl_no_ac_uses_id" { ///| test "parse_pir_basic" { - let pir_text = - ">P1;ALB_HUMAN\n" + + let pir_text = ">P1;ALB_HUMAN\n" + "Serum albumin precursor (Human).\n" + "MKWVTFISLLFLFSSAYSRGVFRRDTHKSEIAHRFKDLGEEHFKGLVLIAFSQYLQQCPFDEHVKLVNELTEFAK*" let records = @src.parse_pir(pir_text) @@ -97,8 +96,7 @@ test "parse_pir_basic" { ///| test "parse_pir_multiple" { - let pir_text = - ">P1;PROT1\n" + + let pir_text = ">P1;PROT1\n" + "Protein one.\n" + "MVLSQDEVVCF* \n" + ">P1;PROT2\n" + @@ -114,10 +112,7 @@ test "parse_pir_multiple" { ///| test "parse_pir_sequence_spaces_ignored" { - let pir_text = - ">DL;DNA1\n" + - "Linear DNA fragment.\n" + - "atgc atgc atgc *" + let pir_text = ">DL;DNA1\n" + "Linear DNA fragment.\n" + "atgc atgc atgc *" let records = @src.parse_pir(pir_text) assert_eq(records.length(), 1) assert_eq(records[0].id, "DNA1") @@ -227,8 +222,18 @@ test "write_genbank_sequence_format" { ///| test "write_genbank_multiple_records" { - let r1 = @src.SeqRecord::new(@src.Seq::new("ACGT"), id="A1", name="L1", description="First") - let r2 = @src.SeqRecord::new(@src.Seq::new("TGCA"), id="B2", name="L2", description="Second") + let r1 = @src.SeqRecord::new( + @src.Seq::new("ACGT"), + id="A1", + name="L1", + description="First", + ) + let r2 = @src.SeqRecord::new( + @src.Seq::new("TGCA"), + id="B2", + name="L2", + description="Second", + ) let out = @src.write_genbank([r1, r2]) // Should have two LOCUS and two terminators assert_eq(out.split("LOCUS").length(), 3) // includes 1 before first match @@ -239,8 +244,7 @@ test "write_genbank_multiple_records" { ///| test "seqio_parse_embl_through_unified" { - let embl = - "ID S1; SV 1; linear; DNA; STD; 4 BP.\n" + + let embl = "ID S1; SV 1; linear; DNA; STD; 4 BP.\n" + "XX\n" + "AC A001;\n" + "XX\n" + @@ -287,9 +291,7 @@ test "seqio_parse_tab_through_unified" { ///| test "seqio_write_genbank_tab_through_unified" { - let records = [ - @src.SeqRecord::new(@src.Seq::new("ACGT"), id="r1"), - ] + let records = [@src.SeqRecord::new(@src.Seq::new("ACGT"), id="r1")] try { let gb_text = @src.seqio_write(records, "genbank") assert_true(gb_text.contains("LOCUS")) diff --git a/test/moonbit/seqlogo_test.mbt b/test/moonbit/seqlogo_test.mbt index 6e6b7019..1f958e2e 100644 --- a/test/moonbit/seqlogo_test.mbt +++ b/test/moonbit/seqlogo_test.mbt @@ -9,12 +9,7 @@ ///| test "seqlogo_pwm_new_basic" { - let matrix = [ - [0.25, 0.25], - [0.25, 0.25], - [0.25, 0.25], - [0.25, 0.25], - ] + let matrix = [[0.25, 0.25], [0.25, 0.25], [0.25, 0.25], [0.25, 0.25]] let pwm = @src.SeqLogoPwm::new(matrix) assert_eq(pwm.width(), 2) assert_eq(pwm.alphabet_size(), 4) @@ -22,12 +17,7 @@ test "seqlogo_pwm_new_basic" { ///| test "seqlogo_pwm_new_get_values" { - let matrix = [ - [0.9, 0.1], - [0.03, 0.1], - [0.04, 0.7], - [0.03, 0.1], - ] + let matrix = [[0.9, 0.1], [0.03, 0.1], [0.04, 0.7], [0.03, 0.1]] let pwm = @src.SeqLogoPwm::new(matrix) assert_true((pwm.get(0, 0) - 0.9).abs() < 0.001) assert_true((pwm.get(0, 1) - 0.1).abs() < 0.001) @@ -39,10 +29,10 @@ test "seqlogo_pwm_new_get_values" { test "seqlogo_pwm_new_get_out_of_bounds" { let matrix = [[0.25], [0.25], [0.25], [0.25]] let pwm = @src.SeqLogoPwm::new(matrix) - assert_true((pwm.get(-1, 0)).abs() < 0.001) - assert_true((pwm.get(4, 0)).abs() < 0.001) - assert_true((pwm.get(0, -1)).abs() < 0.001) - assert_true((pwm.get(0, 100)).abs() < 0.001) + assert_true(pwm.get(-1, 0).abs() < 0.001) + assert_true(pwm.get(4, 0).abs() < 0.001) + assert_true(pwm.get(0, -1).abs() < 0.001) + assert_true(pwm.get(0, 100).abs() < 0.001) } ///| @@ -89,8 +79,8 @@ test "seqlogo_from_sequences_basic" { // Position 3: all T -> freq 1.0 assert_true((pwm.get(3, 3) - 1.0).abs() < 0.001) // Off-diagonal frequencies are 0 - assert_true((pwm.get(0, 1)).abs() < 0.001) - assert_true((pwm.get(1, 0)).abs() < 0.001) + assert_true(pwm.get(0, 1).abs() < 0.001) + assert_true(pwm.get(1, 0).abs() < 0.001) } ///| @@ -134,7 +124,7 @@ test "seqlogo_letter_new_and_accessors" { test "seqlogo_letter_zero_height" { let letter = @src.SeqLogoLetter::new('T', 0.0, "#CC0000") assert_eq(letter.letter(), 'T') - assert_true((letter.height()).abs() < 0.001) + assert_true(letter.height().abs() < 0.001) assert_eq(letter.color(), "#CC0000") } @@ -168,28 +158,18 @@ test "seqlogo_column_add_letter" { ///| test "seqlogo_ic_uniform_pwm_zero" { // All positions have uniform 0.25 frequency -> IC = 0 - let matrix = [ - [0.25, 0.25], - [0.25, 0.25], - [0.25, 0.25], - [0.25, 0.25], - ] + let matrix = [[0.25, 0.25], [0.25, 0.25], [0.25, 0.25], [0.25, 0.25]] let pwm = @src.SeqLogoPwm::new(matrix) let ic = @src.seqlogo_information_content(pwm) assert_eq(ic.length(), 2) - assert_true((ic[0]).abs() < 0.001) - assert_true((ic[1]).abs() < 0.001) + assert_true(ic[0].abs() < 0.001) + assert_true(ic[1].abs() < 0.001) } ///| test "seqlogo_ic_conserved_position" { // Fully conserved A -> IC = log2(4) = 2.0 - let matrix = [ - [1.0], - [0.0], - [0.0], - [0.0], - ] + let matrix = [[1.0], [0.0], [0.0], [0.0]] let pwm = @src.SeqLogoPwm::new(matrix) let ic = @src.seqlogo_information_content(pwm) assert_eq(ic.length(), 1) @@ -201,12 +181,7 @@ test "seqlogo_ic_mixed_position" { // A=0.5, C=0.25, G=0.125, T=0.125 // IC = 0.5*log2(2) + 0.25*log2(1) + 0.125*log2(0.5) + 0.125*log2(0.5) // = 0.5 - 0.125 - 0.125 = 0.25 - let matrix = [ - [0.5], - [0.25], - [0.125], - [0.125], - ] + let matrix = [[0.5], [0.25], [0.125], [0.125]] let pwm = @src.SeqLogoPwm::new(matrix) let ic = @src.seqlogo_information_content(pwm) assert_true((ic[0] - 0.25).abs() < 0.001) @@ -223,12 +198,7 @@ test "seqlogo_ic_bg_non_uniform" { // IC = 0.5*log2(0.5/0.1) + 0.5*log2(0.5/0.4) // = 0.5*log2(5) + 0.5*log2(1.25) // = 0.5*2.321928 + 0.5*0.321928 = 1.321928 - let matrix = [ - [0.5], - [0.5], - [0.0], - [0.0], - ] + let matrix = [[0.5], [0.5], [0.0], [0.0]] let pwm = @src.SeqLogoPwm::new(matrix) let ic = @src.seqlogo_information_content_bg(pwm, [0.1, 0.4, 0.4, 0.1]) assert_true((ic[0] - 1.321928).abs() < 0.001) @@ -236,17 +206,10 @@ test "seqlogo_ic_bg_non_uniform" { ///| test "seqlogo_ic_bg_uniform_equals_default" { - let matrix = [ - [0.9], - [0.03], - [0.04], - [0.03], - ] + let matrix = [[0.9], [0.03], [0.04], [0.03]] let pwm = @src.SeqLogoPwm::new(matrix) let ic_default = @src.seqlogo_information_content(pwm) - let ic_bg = @src.seqlogo_information_content_bg(pwm, [ - 0.25, 0.25, 0.25, 0.25, - ]) + let ic_bg = @src.seqlogo_information_content_bg(pwm, [0.25, 0.25, 0.25, 0.25]) assert_eq(ic_default.length(), ic_bg.length()) assert_true((ic_default[0] - ic_bg[0]).abs() < 0.001) } @@ -258,12 +221,7 @@ test "seqlogo_ic_bg_uniform_equals_default" { ///| test "seqlogo_total_ic_conserved" { // Two fully conserved positions -> total IC = 4.0 - let matrix = [ - [1.0, 1.0], - [0.0, 0.0], - [0.0, 0.0], - [0.0, 0.0], - ] + let matrix = [[1.0, 1.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0]] let pwm = @src.SeqLogoPwm::new(matrix) let total = @src.seqlogo_total_information_content(pwm) assert_true((total - 4.0).abs() < 0.001) @@ -303,8 +261,8 @@ test "seqlogo_max_ic_protein" { ///| test "seqlogo_max_ic_edge_cases" { // alphabet_size <= 1 -> 0.0 - assert_true((@src.seqlogo_max_information_content(0)).abs() < 0.001) - assert_true((@src.seqlogo_max_information_content(1)).abs() < 0.001) + assert_true(@src.seqlogo_max_information_content(0).abs() < 0.001) + assert_true(@src.seqlogo_max_information_content(1).abs() < 0.001) // Binary alphabet -> log2(2) = 1.0 assert_true((@src.seqlogo_max_information_content(2) - 1.0).abs() < 0.001) } @@ -315,12 +273,7 @@ test "seqlogo_max_ic_edge_cases" { ///| test "seqlogo_compute_logo_columns_count" { - let matrix = [ - [0.25, 1.0], - [0.25, 0.0], - [0.25, 0.0], - [0.25, 0.0], - ] + let matrix = [[0.25, 1.0], [0.25, 0.0], [0.25, 0.0], [0.25, 0.0]] let pwm = @src.SeqLogoPwm::new(matrix) let logo = @src.seqlogo_compute_logo(pwm) assert_eq(logo.width(), 2) @@ -330,12 +283,7 @@ test "seqlogo_compute_logo_columns_count" { ///| test "seqlogo_compute_logo_conserved_heights" { // Fully conserved A: IC=2.0, A height=2.0, others=0.0 - let matrix = [ - [1.0], - [0.0], - [0.0], - [0.0], - ] + let matrix = [[1.0], [0.0], [0.0], [0.0]] let pwm = @src.SeqLogoPwm::new(matrix) let logo = @src.seqlogo_compute_logo(pwm) let col = logo.columns()[0] @@ -345,37 +293,27 @@ test "seqlogo_compute_logo_conserved_heights" { assert_eq(col.letters()[0].letter(), 'A') assert_true((col.letters()[0].height() - 2.0).abs() < 0.001) // Other letters have height 0 - assert_true((col.letters()[1].height()).abs() < 0.001) - assert_true((col.letters()[2].height()).abs() < 0.001) - assert_true((col.letters()[3].height()).abs() < 0.001) + assert_true(col.letters()[1].height().abs() < 0.001) + assert_true(col.letters()[2].height().abs() < 0.001) + assert_true(col.letters()[3].height().abs() < 0.001) } ///| test "seqlogo_compute_logo_uniform_zero_ic" { - let matrix = [ - [0.25], - [0.25], - [0.25], - [0.25], - ] + let matrix = [[0.25], [0.25], [0.25], [0.25]] let pwm = @src.SeqLogoPwm::new(matrix) let logo = @src.seqlogo_compute_logo(pwm) let col = logo.columns()[0] - assert_true((col.info_content()).abs() < 0.001) + assert_true(col.info_content().abs() < 0.001) // All letter heights are 0 since IC=0 for letter in col.letters() { - assert_true((letter.height()).abs() < 0.001) + assert_true(letter.height().abs() < 0.001) } } ///| test "seqlogo_compute_logo_total_ic" { - let matrix = [ - [1.0, 0.25], - [0.0, 0.25], - [0.0, 0.25], - [0.0, 0.25], - ] + let matrix = [[1.0, 0.25], [0.0, 0.25], [0.0, 0.25], [0.0, 0.25]] let pwm = @src.SeqLogoPwm::new(matrix) let logo = @src.seqlogo_compute_logo(pwm) // Position 0: IC=2.0, Position 1: IC=0.0 -> total = 2.0 @@ -384,12 +322,7 @@ test "seqlogo_compute_logo_total_ic" { ///| test "seqlogo_compute_logo_letter_colors" { - let matrix = [ - [1.0], - [0.0], - [0.0], - [0.0], - ] + let matrix = [[1.0], [0.0], [0.0], [0.0]] let pwm = @src.SeqLogoPwm::new(matrix) let logo = @src.seqlogo_compute_logo(pwm) let col = logo.columns()[0] @@ -451,12 +384,12 @@ test "seqlogo_to_ascii_contains_letters" { ///| test "seqlogo_to_ascii_zero_height" { - let ascii = @src.seqlogo_to_ascii(@src.seqlogo_compute_logo(@src.SeqLogoPwm::new([ - [0.25], - [0.25], - [0.25], - [0.25], - ])), 5) + let ascii = @src.seqlogo_to_ascii( + @src.seqlogo_compute_logo( + @src.SeqLogoPwm::new([[0.25], [0.25], [0.25], [0.25]]), + ), + 5, + ) // IC=0 so no letters rendered, only spaces and newlines assert_true(ascii.length() > 0) assert_false(ascii.contains("A")) @@ -480,12 +413,7 @@ test "seqlogo_to_text_table_has_header" { ///| test "seqlogo_to_text_table_tab_separated" { - let matrix = [ - [1.0], - [0.0], - [0.0], - [0.0], - ] + let matrix = [[1.0], [0.0], [0.0], [0.0]] let pwm = @src.SeqLogoPwm::new(matrix) let logo = @src.seqlogo_compute_logo(pwm) let table = @src.seqlogo_to_text_table(logo) @@ -528,12 +456,7 @@ test "seqlogo_consensus_from_sequences" { ///| test "seqlogo_consensus_tie_first_base" { // When frequencies are tied, the lowest-index base wins - let matrix = [ - [0.25], - [0.25], - [0.25], - [0.25], - ] + let matrix = [[0.25], [0.25], [0.25], [0.25]] let pwm = @src.SeqLogoPwm::new(matrix) let consensus = @src.seqlogo_consensus_sequence(pwm) assert_eq(consensus, "A") @@ -556,12 +479,7 @@ test "seqlogo_logo_summary_non_empty" { ///| test "seqlogo_logo_summary_width" { - let matrix = [ - [1.0, 0.25], - [0.0, 0.25], - [0.0, 0.25], - [0.0, 0.25], - ] + let matrix = [[1.0, 0.25], [0.0, 0.25], [0.0, 0.25], [0.0, 0.25]] let pwm = @src.SeqLogoPwm::new(matrix) let logo = @src.seqlogo_compute_logo(pwm) let summary = @src.seqlogo_logo_summary(logo) @@ -610,12 +528,7 @@ test "seqlogo_sample_pwm_from_sample_sequences" { ///| test "seqlogo_edge_single_position" { - let matrix = [ - [1.0], - [0.0], - [0.0], - [0.0], - ] + let matrix = [[1.0], [0.0], [0.0], [0.0]] let pwm = @src.SeqLogoPwm::new(matrix) assert_eq(pwm.width(), 1) let ic = @src.seqlogo_information_content(pwm) @@ -654,7 +567,7 @@ test "seqlogo_edge_all_equal_frequencies" { assert_true(v.abs() < 0.001) } let logo = @src.seqlogo_compute_logo(pwm) - assert_true((logo.total_ic()).abs() < 0.001) + assert_true(logo.total_ic().abs() < 0.001) } ///| @@ -695,12 +608,7 @@ test "seqlogo_edge_to_ascii_zero_max_height" { ///| test "seqlogo_compute_logo_bg_non_uniform" { - let matrix = [ - [0.5], - [0.5], - [0.0], - [0.0], - ] + let matrix = [[0.5], [0.5], [0.0], [0.0]] let pwm = @src.SeqLogoPwm::new(matrix) let logo = @src.seqlogo_compute_logo_bg(pwm, [0.1, 0.4, 0.4, 0.1]) let col = logo.columns()[0] diff --git a/test/moonbit/seqxml_io_test.mbt b/test/moonbit/seqxml_io_test.mbt index ecb563e4..58ae344e 100644 --- a/test/moonbit/seqxml_io_test.mbt +++ b/test/moonbit/seqxml_io_test.mbt @@ -10,14 +10,8 @@ ///| test "seqxml_type_from_tag" { // Known tags map to their corresponding types. - assert_eq( - @src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("dna")), - "dna", - ) - assert_eq( - @src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("rna")), - "rna", - ) + assert_eq(@src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("dna")), "dna") + assert_eq(@src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("rna")), "rna") assert_eq( @src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("protein")), "protein", @@ -27,24 +21,33 @@ test "seqxml_type_from_tag" { @src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("xyz")), "unknown", ) - assert_eq( - @src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("")), - "unknown", - ) + assert_eq(@src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("")), "unknown") } ///| test "seqxml_type_to_tag" { assert_eq(@src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("dna")), "dna") assert_eq(@src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("rna")), "rna") - assert_eq(@src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("protein")), "protein") - assert_eq(@src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("unknown")), "unknown") + assert_eq( + @src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("protein")), + "protein", + ) + assert_eq( + @src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("unknown")), + "unknown", + ) } ///| test "seqxml_type_description" { - assert_eq(@src.SeqXmlType::description(@src.SeqXmlType::from_tag("dna")), "DNA") - assert_eq(@src.SeqXmlType::description(@src.SeqXmlType::from_tag("rna")), "RNA") + assert_eq( + @src.SeqXmlType::description(@src.SeqXmlType::from_tag("dna")), + "DNA", + ) + assert_eq( + @src.SeqXmlType::description(@src.SeqXmlType::from_tag("rna")), + "RNA", + ) assert_eq( @src.SeqXmlType::description(@src.SeqXmlType::from_tag("protein")), "Protein", @@ -234,8 +237,7 @@ test "seqxml_document_full_metadata" { ///| test "seqxml_parse_dna_entry" { - let content = - "\n" + + let content = "\n" + "\n" + " \n" + " ATGCATGC\n" + @@ -253,8 +255,7 @@ test "seqxml_parse_dna_entry" { ///| test "seqxml_parse_rna_entry" { - let content = - "\n" + + let content = "\n" + "\n" + " \n" + " AUGCAUGC\n" + @@ -271,8 +272,7 @@ test "seqxml_parse_rna_entry" { ///| test "seqxml_parse_protein_entry" { - let content = - "\n" + + let content = "\n" + "\n" + " \n" + " MKLVGV\n" + @@ -289,8 +289,7 @@ test "seqxml_parse_protein_entry" { ///| test "seqxml_parse_with_species_sourcedb" { - let content = - "\n" + + let content = "\n" + "\n" + " \n" + " \n" + @@ -311,8 +310,7 @@ test "seqxml_parse_with_species_sourcedb" { ///| test "seqxml_parse_with_properties" { - let content = - "\n" + + let content = "\n" + "\n" + " \n" + " \n" + @@ -336,8 +334,7 @@ test "seqxml_parse_with_properties" { ///| test "seqxml_parse_multiple_entries" { - let content = - "\n" + + let content = "\n" + "\n" + " ACGT\n" + " AUGU\n" + @@ -450,7 +447,9 @@ test "seqxml_document_to_xml" { assert_true(xml.contains("")) assert_true(xml.contains("")) - assert_true(xml.contains("")) + assert_true( + xml.contains(""), + ) assert_true(xml.contains("")) assert_true(xml.contains("")) assert_true(xml.contains("ACGT")) @@ -482,8 +481,7 @@ test "seqxml_document_to_xml_no_metadata" { ///| test "seqxml_roundtrip_basic" { - let original = - "\n" + + let original = "\n" + "\n" + " \n" + " ACGTACGT\n" + @@ -502,8 +500,7 @@ test "seqxml_roundtrip_basic" { ///| test "seqxml_roundtrip_with_metadata" { - let original = - "\n" + + let original = "\n" + "\n" + " \n" + " \n" + @@ -526,8 +523,7 @@ test "seqxml_roundtrip_with_metadata" { ///| test "seqxml_roundtrip_with_properties" { - let original = - "\n" + + let original = "\n" + "\n" + " \n" + " \n" + @@ -553,8 +549,7 @@ test "seqxml_roundtrip_with_properties" { ///| test "seqxml_roundtrip_multiple_entries" { - let original = - "\n" + + let original = "\n" + "\n" + " ACGT\n" + " AUGU\n" + @@ -753,8 +748,7 @@ test "seqxml_parse_empty_document" { ///| test "seqxml_parse_no_entries" { - let content = - "\n" + + let content = "\n" + "\n" + " \n" + "\n" @@ -767,8 +761,7 @@ test "seqxml_parse_no_entries" { ///| test "seqxml_parse_entry_without_description" { - let content = - "\n" + + let content = "\n" + "\n" + " \n" + " ACGT\n" + @@ -786,8 +779,7 @@ test "seqxml_parse_entry_without_description" { ///| test "seqxml_parse_self_closing_entry" { // Self-closing has no sequence element. - let content = - "\n" + + let content = "\n" + "\n" + " \n" + "\n" @@ -803,8 +795,7 @@ test "seqxml_parse_self_closing_entry" { ///| test "seqxml_entity_escaping_in_description" { // Parsing should unescape XML entities in the desc attribute. - let content = - "\n" + + let content = "\n" + "\n" + " \n" + " ACGT\n" + @@ -818,8 +809,7 @@ test "seqxml_entity_escaping_in_description" { ///| test "seqxml_entity_escaping_in_sequence" { // Parsing should unescape XML entities in the sequence text content. - let content = - "\n" + + let content = "\n" + "\n" + " \n" + " AC&T<G\n" + @@ -855,8 +845,7 @@ test "seqxml_entity_escaping_roundtrip" { description="Quote \" and amp & and lt <", ) let xml = @src.seqxml_entry_to_xml(entry) - let content = - "\n" + + let content = "\n" + "\n" + xml + "\n" diff --git a/test/moonbit/seurat_test.mbt b/test/moonbit/seurat_test.mbt index fc0dfb9c..8635b7f3 100644 --- a/test/moonbit/seurat_test.mbt +++ b/test/moonbit/seurat_test.mbt @@ -20,7 +20,7 @@ test "seurat_simple_pipeline" { let with_neighbors = @src.find_neighbors(with_pca) let with_clusters = @src.find_clusters(with_neighbors) let with_umap = @src.run_umap(with_pca) - + assert_eq(with_clusters.clusters.length(), 200) assert_eq(with_umap.umap.length(), 200) } @@ -31,7 +31,7 @@ test "normalize_total" { let normalized = @src.normalize_total(obj) assert_eq(normalized.data.length(), 500) assert_eq(normalized.data[0].length(), 200) - + let mut has_positive = false let mut i = 0 while i < normalized.data.length() && !has_positive { @@ -73,12 +73,12 @@ test "run_pca" { let with_hvg = @src.find_variable_features(normalized) let scaled = @src.scale_data(with_hvg) let with_pca = @src.run_pca(scaled) - + assert_true(with_pca.pca.length() > 0) assert_true(with_pca.pca[0].length() > 0) assert_eq(with_pca.pca.length(), 200) assert_true(with_pca.var_explained.length() > 0) - + let mut sum_var = 0.0 let mut i = 0 while i < with_pca.var_explained.length() { @@ -96,7 +96,7 @@ test "find_neighbors" { let scaled = @src.scale_data(with_hvg) let with_pca = @src.run_pca(scaled) let with_neighbors = @src.find_neighbors(with_pca) - + assert_eq(with_neighbors.neighbors.length(), 200) assert_true(with_neighbors.neighbors[0].length() > 0) } @@ -110,9 +110,9 @@ test "find_clusters" { let with_pca = @src.run_pca(scaled) let with_neighbors = @src.find_neighbors(with_pca) let with_clusters = @src.find_clusters(with_neighbors) - + assert_eq(with_clusters.clusters.length(), 200) - + let unique_clusters : Array[Int] = Array::new() let mut i = 0 while i < with_clusters.clusters.length() { @@ -142,7 +142,7 @@ test "run_umap" { let scaled = @src.scale_data(with_hvg) let with_pca = @src.run_pca(scaled) let with_umap = @src.run_umap(with_pca) - + assert_eq(with_umap.umap.length(), 200) assert_eq(with_umap.umap[0].length(), 2) } @@ -156,11 +156,11 @@ test "find_all_markers" { let with_pca = @src.run_pca(scaled) let with_neighbors = @src.find_neighbors(with_pca) let with_clusters = @src.find_clusters(with_neighbors) - + let markers = @src.find_all_markers(with_clusters) - + assert_true(markers.length() >= 0) - + if markers.length() > 0 { let m = markers[0] assert_true(m.gene.length() > 0) @@ -171,25 +171,27 @@ test "find_all_markers" { test "find_integration_anchors" { let ref_obj = @src.seurat_create_example_data() let query_obj = @src.seurat_create_example_data() - + let ref_normalized = @src.normalize_total(ref_obj) let ref_with_hvg = @src.find_variable_features(ref_normalized) let ref_scaled = @src.scale_data(ref_with_hvg) let ref_with_pca = @src.run_pca(ref_scaled) - + let query_normalized = @src.normalize_total(query_obj) let query_with_hvg = @src.find_variable_features(query_normalized) let query_scaled = @src.scale_data(query_with_hvg) let query_with_pca = @src.run_pca(query_scaled) - + assert_true(ref_with_pca.pca.length() > 0) assert_true(query_with_pca.pca.length() > 0) assert_eq(ref_with_pca.pca.length(), ref_obj.col_names.length()) assert_eq(query_with_pca.pca.length(), query_obj.col_names.length()) - + let dims = [0] - let anchors = @src.find_integration_anchors(ref_with_pca, query_with_pca, dims) - + let anchors = @src.find_integration_anchors( + ref_with_pca, query_with_pca, dims, + ) + assert_eq(anchors.reference_indices.length(), anchors.anchors.length()) assert_eq(anchors.query_indices.length(), anchors.anchors.length()) } @@ -198,26 +200,31 @@ test "find_integration_anchors" { test "integrate_data" { let ref_obj = @src.seurat_create_example_data() let query_obj = @src.seurat_create_example_data() - + let ref_normalized = @src.normalize_total(ref_obj) let ref_with_hvg = @src.find_variable_features(ref_normalized) let ref_scaled = @src.scale_data(ref_with_hvg) let ref_with_pca = @src.run_pca(ref_scaled) - + let query_normalized = @src.normalize_total(query_obj) let query_with_hvg = @src.find_variable_features(query_normalized) let query_scaled = @src.scale_data(query_with_hvg) let query_with_pca = @src.run_pca(query_scaled) - + let dims = [0, 1, 2, 3, 4] - let anchors = @src.find_integration_anchors(ref_with_pca, query_with_pca, dims) - + let anchors = @src.find_integration_anchors( + ref_with_pca, query_with_pca, dims, + ) + let integrated = @src.integrate_data(ref_obj, query_obj, anchors) - + assert_true(integrated.counts.length() > 0) - assert_true(integrated.col_names.length() == ref_obj.col_names.length() + query_obj.col_names.length()) + assert_true( + integrated.col_names.length() == + ref_obj.col_names.length() + query_obj.col_names.length(), + ) assert_eq(integrated.row_names.length(), integrated.counts.length()) - + let mut has_ref_prefix = false let mut has_query_prefix = false for name in integrated.col_names { diff --git a/test/moonbit/sff_io_test.mbt b/test/moonbit/sff_io_test.mbt index 200c1ee1..93b9ddd4 100644 --- a/test/moonbit/sff_io_test.mbt +++ b/test/moonbit/sff_io_test.mbt @@ -34,7 +34,9 @@ test "sff_read_new" { let qualities = [10, 20, 30, 25] let flowgram = [1.0, 0.0, 1.0, 0.0] let flow_index = [1, 3, 1, 3] - let read = @src.SffRead::new("READ001", "ACGT", qualities, flowgram, flow_index, 1, 4, 0, 0) + let read = @src.SffRead::new( + "READ001", "ACGT", qualities, flowgram, flow_index, 1, 4, 0, 0, + ) assert_eq(read.name, "READ001") assert_eq(read.bases, "ACGT") assert_eq(read.n_bases, 4) @@ -137,7 +139,10 @@ test "sff_encode_parse_roundtrip" { ///| test "sff_parse_invalid_magic" { // Create bytes with wrong magic number - let bytes = [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 40, 0, 4, 0, 4, 0, 1] + let bytes = [ + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 40, + 0, 4, 0, 4, 0, 1, + ] let result = @src.sff_parse(bytes) assert_true(result is None) } diff --git a/test/moonbit/sgseq_test.mbt b/test/moonbit/sgseq_test.mbt index b45ca1e4..61c1ac1e 100644 --- a/test/moonbit/sgseq_test.mbt +++ b/test/moonbit/sgseq_test.mbt @@ -53,11 +53,7 @@ test "sg_junction_default_strand_count" { ///| test "sg_junction_intron_length" { - let j = @src.SGSeqJunction::new( - chr="chr1", - start=1000, - end=2000, - ) + let j = @src.SGSeqJunction::new(chr="chr1", start=1000, end=2000) // intron_length = end - start - 1 = 999 assert_eq(j.intron_length(), 999) } @@ -352,9 +348,7 @@ test "sg_detect_ri" { let junctions = [ @src.SGSeqJunction::new(chr="chr1", start=100, end=500, count=5), ] - let exons = [ - @src.SGSeqExon::new(chr="chr1", start=100, end=500, strand="+"), - ] + let exons = [@src.SGSeqExon::new(chr="chr1", start=100, end=500, strand="+")] let variants = @src.sgseq_detect_ri(junctions, exons) // Should detect an RI event (low junction count with overlapping exon) assert_true(variants.length() >= 1) @@ -373,7 +367,13 @@ test "sg_detect_all_variants" { // All variants should have valid type names for v in variants { let name = v.type_name() - assert_true(name == "SE" || name == "A5SS" || name == "A3SS" || name == "MXE" || name == "RI") + assert_true( + name == "SE" || + name == "A5SS" || + name == "A3SS" || + name == "MXE" || + name == "RI", + ) } } diff --git a/test/moonbit/single_r_test.mbt b/test/moonbit/single_r_test.mbt index df9f374b..ead1527a 100644 --- a/test/moonbit/single_r_test.mbt +++ b/test/moonbit/single_r_test.mbt @@ -88,7 +88,9 @@ test "single_r_rank_values_ties" { test "single_r_compute_correlations" { let ref_data = @src.single_r_create_reference_data() let cell_expr = ref_data.profiles[0].expression - let scores = @src.single_r_compute_correlations(cell_expr, ref_data, "spearman") + let scores = @src.single_r_compute_correlations( + cell_expr, ref_data, "spearman", + ) assert_eq(scores.length(), ref_data.n_profiles) assert_true(scores[0] > 0.0) } @@ -105,7 +107,11 @@ test "single_r_get_top_scores" { ///| test "single_r_aggregate_scores_by_type" { let ref_data = @src.single_r_create_reference_data() - let scores = @src.single_r_compute_correlations(ref_data.profiles[0].expression, ref_data, "spearman") + let scores = @src.single_r_compute_correlations( + ref_data.profiles[0].expression, + ref_data, + "spearman", + ) let agg = @src.single_r_aggregate_scores_by_type(scores, ref_data, 1) assert_true(agg.size() > 0) assert_true(agg.contains("T cells")) @@ -131,11 +137,13 @@ test "single_r_compute_delta_score" { test "single_r_annotate_cell" { let ref_data = @src.single_r_create_reference_data() let params = @src.SingleRParams::new() - + // Test with a T cell-like expression let cell_expr = ref_data.profiles[0].expression - let result = @src.single_r_annotate_cell(cell_expr, "test_t_cell", ref_data, params) - + let result = @src.single_r_annotate_cell( + cell_expr, "test_t_cell", ref_data, params, + ) + assert_eq(result.cell_id, "test_t_cell") assert_true(result.scores.length() > 0) assert_true(result.first_annotation_fine.length() > 0) @@ -146,11 +154,13 @@ test "single_r_annotate_cell" { test "single_r_annotate_cell_b_cell" { let ref_data = @src.single_r_create_reference_data() let params = @src.SingleRParams::new() - + // Test with a B cell-like expression let cell_expr = ref_data.profiles[1].expression - let result = @src.single_r_annotate_cell(cell_expr, "test_b_cell", ref_data, params) - + let result = @src.single_r_annotate_cell( + cell_expr, "test_b_cell", ref_data, params, + ) + assert_true(result.first_annotation_fine.length() > 0) assert_true(result.scores[0] > 0.0) } @@ -160,9 +170,9 @@ test "single_r_annotate_all_cells" { let ref_data = @src.single_r_create_reference_data() let test_data = @src.single_r_create_test_data() let params = @src.SingleRParams::new() - + let result = @src.single_r_annotate_cells(test_data, ref_data, params) - + assert_eq(result.cell_ids.length(), 50) assert_eq(result.labels.length(), 50) assert_eq(result.scores.length(), 50) @@ -175,10 +185,10 @@ test "single_r_annotation_summary" { let ref_data = @src.single_r_create_reference_data() let test_data = @src.single_r_create_test_data() let params = @src.SingleRParams::new() - + let result = @src.single_r_annotate_cells(test_data, ref_data, params) let summary = @src.single_r_annotation_summary(result) - + assert_true(summary.size() > 0) assert_true(summary.contains("n_cells")) assert_eq(summary.get("n_cells").unwrap_or(0.0), 50.0) @@ -206,9 +216,9 @@ test "single_r_pearson_annotation" { let ref_data = @src.single_r_create_reference_data() let test_data = @src.single_r_create_test_data() let params = @src.SingleRParams::with_method("pearson") - + let result = @src.single_r_annotate_cells(test_data, ref_data, params) - + assert_eq(result.cell_ids.length(), 50) assert_true(result.scores.length() > 0) assert_true(result.scores[0] > 0.0) @@ -216,16 +226,14 @@ test "single_r_pearson_annotation" { ///| test "single_r_reference_dataset_from_matrix" { - let expression = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - [7.0, 8.0, 9.0], - ] + let expression = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let cell_types = ["TypeA", "TypeB", "TypeC"] let gene_names = ["Gene1", "Gene2", "Gene3"] - - let reference = @src.ReferenceDataset::from_matrix(expression, cell_types, gene_names) - + + let reference = @src.ReferenceDataset::from_matrix( + expression, cell_types, gene_names, + ) + assert_eq(reference.n_profiles, 3) assert_eq(reference.n_genes, 3) assert_eq(reference.cell_types.length(), 3) @@ -236,10 +244,12 @@ test "single_r_reference_dataset_from_matrix" { test "single_r_fine_tune_disabled" { let ref_data = @src.single_r_create_reference_data() let params = @src.SingleRParams::with_all(false, "spearman", 1, 0.0, false) - + let cell_expr = ref_data.profiles[0].expression - let result_no_finetune = @src.single_r_annotate_cell(cell_expr, "test", ref_data, params) - + let result_no_finetune = @src.single_r_annotate_cell( + cell_expr, "test", ref_data, params, + ) + assert_true(result_no_finetune.first_annotation_fine.length() > 0) } @@ -247,10 +257,12 @@ test "single_r_fine_tune_disabled" { test "single_r_fine_tune_enabled" { let ref_data = @src.single_r_create_reference_data() let params = @src.SingleRParams::with_all(true, "spearman", 1, 0.0, false) - + let cell_expr = ref_data.profiles[0].expression - let result_finetune = @src.single_r_annotate_cell(cell_expr, "test", ref_data, params) - + let result_finetune = @src.single_r_annotate_cell( + cell_expr, "test", ref_data, params, + ) + assert_true(result_finetune.first_annotation_fine.length() > 0) assert_true(result_finetune.scores[0] > 0.0) } @@ -270,8 +282,13 @@ test "single_r_identical_profiles" { let ref_data = @src.single_r_create_reference_data() // Annotate a cell with the same profile as reference profile 0 let cell_expr = ref_data.profiles[0].expression - let result = @src.single_r_annotate_cell(cell_expr, "identical", ref_data, @src.SingleRParams::new()) - + let result = @src.single_r_annotate_cell( + cell_expr, + "identical", + ref_data, + @src.SingleRParams::new(), + ) + assert_true(result.scores[0] > 0.99) assert_eq(result.first_annotation_fine, "T cells") -} \ No newline at end of file +} diff --git a/test/moonbit/singscore_test.mbt b/test/moonbit/singscore_test.mbt index 424ca520..d470e8ce 100644 --- a/test/moonbit/singscore_test.mbt +++ b/test/moonbit/singscore_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Singscore gene set scoring module. - test "singscore_create_example" { let (sample, spec) = @src.singscore_create_example() assert_true(sample.sample_id == "sample_1") @@ -9,6 +8,7 @@ test "singscore_create_example" { assert_true(spec.down_genes.length() > 0) } +///| test "singscore_score_basic" { let (sample, spec) = @src.singscore_create_example() let result = @src.singscore_score(sample, spec, "test_sample") @@ -17,6 +17,7 @@ test "singscore_score_basic" { assert_true(result.score >= -0.5 && result.score <= 0.5) } +///| test "singscore_score_boundary" { // Score should always be in [-0.5, 0.5] let (sample, spec) = @src.singscore_create_example() @@ -25,17 +26,19 @@ test "singscore_score_boundary" { assert_true(result.score <= 0.5 + 1.0e-6) } +///| test "singscore_empty_gene_set" { let genes = ["A", "B", "C"] let expression = [1.0, 2.0, 3.0] let sample = @src.SampleExpression::new("empty_test", genes, expression) - let spec = @src.GeneSetSpec::new("empty_set", [], down_genes = []) + let spec = @src.GeneSetSpec::new("empty_set", [], down_genes=[]) let result = @src.singscore_score(sample, spec, "empty") assert_true(result.score == 0.0) assert_true(result.n_up_found == 0) assert_true(result.n_down_found == 0) } +///| test "singscore_single_gene" { let genes = ["TP53"] let expression = [10.0] @@ -46,6 +49,7 @@ test "singscore_single_gene" { assert_true(result.score >= -0.5 && result.score <= 0.5) } +///| test "singscore_multiple_samples" { let (sample1, spec) = @src.singscore_create_example() let genes = sample1.gene_names @@ -59,6 +63,7 @@ test "singscore_multiple_samples" { assert_true(results[0].score >= -0.5 && results[0].score <= 0.5) } +///| test "singscore_missing_genes" { let genes = ["A", "B"] let expression = [1.0, 2.0] @@ -69,8 +74,9 @@ test "singscore_missing_genes" { assert_true(result.score == 0.0) } +///| test "singscore_spec_creation" { - let spec = @src.GeneSetSpec::new("test_set", ["G1", "G2"], down_genes = ["G3"]) + let spec = @src.GeneSetSpec::new("test_set", ["G1", "G2"], down_genes=["G3"]) assert_true(spec.name == "test_set") assert_true(spec.up_genes.length() == 2) assert_true(spec.down_genes.length() == 1) diff --git a/test/moonbit/slingshot_test.mbt b/test/moonbit/slingshot_test.mbt index 4177b12d..6ae042f0 100644 --- a/test/moonbit/slingshot_test.mbt +++ b/test/moonbit/slingshot_test.mbt @@ -40,7 +40,7 @@ test "slingshot_distance_matrix" { let nodes = [ @src.SlingshotNode::new("c1", "cluster1", [0.0, 0.0], 5), @src.SlingshotNode::new("c2", "cluster2", [1.0, 0.0], 5), - @src.SlingshotNode::new("c3", "cluster3", [0.0, 1.0], 5) + @src.SlingshotNode::new("c3", "cluster3", [0.0, 1.0], 5), ] let matrix = @src.sling_distance_matrix(nodes, @src.sling_euclidean_metric()) assert_eq(matrix.length(), 3) @@ -54,7 +54,7 @@ test "slingshot_mst" { let nodes = [ @src.SlingshotNode::new("c1", "cluster1", [0.0, 0.0], 5), @src.SlingshotNode::new("c2", "cluster2", [1.0, 0.0], 5), - @src.SlingshotNode::new("c3", "cluster3", [0.5, 1.0], 5) + @src.SlingshotNode::new("c3", "cluster3", [0.5, 1.0], 5), ] let edges = @src.sling_build_mst(nodes, @src.sling_euclidean_metric()) assert_eq(edges.length(), 2) @@ -65,7 +65,7 @@ test "slingshot_terminals" { let nodes = [ @src.SlingshotNode::new("c1", "cluster1", [0.0, 0.0], 5), @src.SlingshotNode::new("c2", "cluster2", [1.0, 0.0], 5), - @src.SlingshotNode::new("c3", "cluster3", [0.5, 1.0], 5) + @src.SlingshotNode::new("c3", "cluster3", [0.5, 1.0], 5), ] let edges = @src.sling_build_mst(nodes, @src.sling_euclidean_metric()) let terminals = @src.sling_find_terminals(edges, nodes) @@ -79,7 +79,7 @@ test "slingshot_principal_curve" { [1.0, 0.5], [2.0, 1.0], [3.0, 1.5], - [4.0, 2.0] + [4.0, 2.0], ] let curve = @src.sling_fit_principal_curve(points, 5) assert_true(curve.length() >= 2) @@ -91,13 +91,13 @@ test "slingshot_pseudotime" { [0.0, 0.0], [1.0, 0.5], [2.0, 1.0], - [3.0, 1.5] + [3.0, 1.5], ] let curve : Array[Array[Double]] = [ [0.0, 0.0], [1.0, 0.5], [2.0, 1.0], - [3.0, 1.5] + [3.0, 1.5], ] let pseudotime = @src.sling_compute_pseudotime(cell_coords, curve) assert_eq(pseudotime.length(), 4) @@ -111,7 +111,7 @@ test "slingshot_full_run" { [1.0, 0.5], [2.0, 1.0], [2.5, 1.2], - [3.0, 1.5] + [3.0, 1.5], ] let cluster_labels = ["c1", "c1", "c2", "c2", "c3", "c3"] let params = @src.SlingshotParams::new() diff --git a/test/moonbit/smart_test.mbt b/test/moonbit/smart_test.mbt index aa8307f1..cccd50ed 100644 --- a/test/moonbit/smart_test.mbt +++ b/test/moonbit/smart_test.mbt @@ -19,8 +19,15 @@ test "smart_result_construction" { // SmartDomain Tests // ============================================================================ +///| test "smart_domain_construction" { - let domain = @src.SmartDomain::new("SM00001", "ABC_membrane", 1, 100, evalue=1.5e-20) + let domain = @src.SmartDomain::new( + "SM00001", + "ABC_membrane", + 1, + 100, + evalue=1.5e-20, + ) assert_eq(domain.domain_id, "SM00001") assert_eq(domain.domain_name, "ABC_membrane") assert_eq(domain.start, 1) @@ -32,6 +39,7 @@ test "smart_domain_construction" { // SMART Parsing Tests // ============================================================================ +///| test "smart_parse_empty" { let result = @src.smart_parse("") assert_eq(result.sequence_id, "") @@ -39,6 +47,7 @@ test "smart_parse_empty" { assert_eq(result.domains.length(), 0) } +///| test "smart_parse_sample" { let content = @src.smart_sample() let result = @src.smart_parse(content) @@ -46,6 +55,7 @@ test "smart_parse_sample" { assert_true(result.domains.length() >= 3) } +///| test "smart_parse_domain_type_classification" { let content = @src.smart_sample() let result = @src.smart_parse(content) @@ -58,6 +68,7 @@ test "smart_parse_domain_type_classification" { // SMART Query Tests // ============================================================================ +///| test "smart_find_domains_by_name" { let content = @src.smart_sample() let result = @src.smart_parse(content) @@ -65,6 +76,7 @@ test "smart_find_domains_by_name" { assert_true(matches.length() >= 1) } +///| test "smart_filter_by_evalue" { let content = @src.smart_sample() let result = @src.smart_parse(content) @@ -72,6 +84,7 @@ test "smart_filter_by_evalue" { assert_true(significant.length() >= 1) } +///| test "smart_best_domain" { let content = @src.smart_sample() let result = @src.smart_parse(content) @@ -85,12 +98,14 @@ test "smart_best_domain" { // SMART Summary Tests // ============================================================================ +///| test "smart_summary" { let result = @src.SmartResult::new("test_protein") let summary = @src.smart_summary(result) assert_true(summary.contains("test_protein")) } +///| test "smart_total_domains" { let content = @src.smart_sample() let result = @src.smart_parse(content) diff --git a/test/moonbit/snapgene_io_test.mbt b/test/moonbit/snapgene_io_test.mbt index 298b1477..dea3a331 100644 --- a/test/moonbit/snapgene_io_test.mbt +++ b/test/moonbit/snapgene_io_test.mbt @@ -23,13 +23,21 @@ test "snapgene_seq_type_to_string" { ///| test "snapgene_seq_type_from_string" { - assert_true(@src.SnapgeneSeqType::from_string("DNA") is @src.SnapgeneSeqType::SnapgeneDna) - assert_true(@src.SnapgeneSeqType::from_string("RNA") is @src.SnapgeneSeqType::SnapgeneRna) assert_true( - @src.SnapgeneSeqType::from_string("protein") is @src.SnapgeneSeqType::SnapgeneProtein, + @src.SnapgeneSeqType::from_string("DNA") + is @src.SnapgeneSeqType::SnapgeneDna, ) assert_true( - @src.SnapgeneSeqType::from_string("xxx") is @src.SnapgeneSeqType::SnapgeneUnknown, + @src.SnapgeneSeqType::from_string("RNA") + is @src.SnapgeneSeqType::SnapgeneRna, + ) + assert_true( + @src.SnapgeneSeqType::from_string("protein") + is @src.SnapgeneSeqType::SnapgeneProtein, + ) + assert_true( + @src.SnapgeneSeqType::from_string("xxx") + is @src.SnapgeneSeqType::SnapgeneUnknown, ) } @@ -38,8 +46,14 @@ test "snapgene_seq_type_from_string_round_trip" { let dna = @src.SnapgeneSeqType::from_string("DNA") let rna = @src.SnapgeneSeqType::from_string("RNA") let protein = @src.SnapgeneSeqType::from_string("protein") - assert_eq(@src.SnapgeneSeqType::from_string(dna.to_string()).to_string(), "DNA") - assert_eq(@src.SnapgeneSeqType::from_string(rna.to_string()).to_string(), "RNA") + assert_eq( + @src.SnapgeneSeqType::from_string(dna.to_string()).to_string(), + "DNA", + ) + assert_eq( + @src.SnapgeneSeqType::from_string(rna.to_string()).to_string(), + "RNA", + ) assert_eq( @src.SnapgeneSeqType::from_string(protein.to_string()).to_string(), "protein", @@ -76,7 +90,7 @@ test "snapgene_feature_new" { type_="CDS", direction=1, segments=[(0, 99)], - qualifiers=qualifiers, + qualifiers~, ) assert_eq(f.name, "orfA") assert_eq(f.type_, "CDS") diff --git a/test/moonbit/spatial_experiment_test.mbt b/test/moonbit/spatial_experiment_test.mbt index 8c706cb5..b34e6b06 100644 --- a/test/moonbit/spatial_experiment_test.mbt +++ b/test/moonbit/spatial_experiment_test.mbt @@ -1,12 +1,12 @@ ///| /// Tests for SpatialExperiment module. - test "SpatialExperiment creation" { let se = @src.create_example_spatial_experiment() assert_eq(@src.se_num_rows(se), 3) assert_eq(@src.se_num_cols(se), 6) } +///| test "SpatialExperiment spatial range" { let se = @src.create_example_spatial_experiment() let (min_x, max_x, min_y, max_y) = @src.se_get_spatial_range(se) @@ -16,15 +16,17 @@ test "SpatialExperiment spatial range" { assert_eq(max_y, 250.0) } +///| test "SpatialExperiment filter spots" { let se = @src.create_example_spatial_experiment() let filtered = @src.se_filter_spots_by_range(se, 150.0, 300.0, 150.0, 250.0) assert_eq(@src.se_num_cols(filtered), 4) } +///| test "SpatialCoord new_2d" { let coord = @src.SpatialCoord::new_2d(100.0, 200.0) assert_eq(coord.x, 100.0) assert_eq(coord.y, 200.0) assert_eq(coord.z, 0.0) -} \ No newline at end of file +} diff --git a/test/moonbit/spia_test.mbt b/test/moonbit/spia_test.mbt index 750a5977..5792438a 100644 --- a/test/moonbit/spia_test.mbt +++ b/test/moonbit/spia_test.mbt @@ -170,7 +170,11 @@ test "spia_activation_status" { while i < results.results.length() { let r = results.results[i] // Activation status must be one of -1, 0, 1 - assert_true(r.activation_status == -1 || r.activation_status == 0 || r.activation_status == 1) + assert_true( + r.activation_status == -1 || + r.activation_status == 0 || + r.activation_status == 1, + ) i = i + 1 } } diff --git a/test/moonbit/stage_r_test.mbt b/test/moonbit/stage_r_test.mbt index 5a075d3f..06748ee8 100644 --- a/test/moonbit/stage_r_test.mbt +++ b/test/moonbit/stage_r_test.mbt @@ -110,7 +110,11 @@ test "stage_r_simes_caps_at_one" { ///| test "stage_r_adjustment_holm" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_holm()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_holm(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) assert_eq(result.nGenes, 10) assert_eq(result.nHypotheses, 3) @@ -121,7 +125,11 @@ test "stage_r_adjustment_holm" { ///| test "stage_r_adjustment_none" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_none()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_none(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) assert_eq(result.nGenes, 10) } @@ -129,7 +137,11 @@ test "stage_r_adjustment_none" { ///| test "stage_r_adjustment_dte" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_dte()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_dte(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) assert_eq(result.nGenes, 10) assert_eq(result.nHypotheses, 3) @@ -138,7 +150,11 @@ test "stage_r_adjustment_dte" { ///| test "stage_r_adjustment_dtu" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_dtu()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_dtu(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) assert_eq(result.nGenes, 10) assert_eq(result.nHypotheses, 3) @@ -147,17 +163,27 @@ test "stage_r_adjustment_dtu" { ///| test "stage_r_alpha_adjusted" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_holm()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_holm(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) // alphaAdjusted = (R/G) * alpha - let expected = result.nSignificantGenes.to_double() / result.nGenes.to_double() * config.alpha + let expected = result.nSignificantGenes.to_double() / + result.nGenes.to_double() * + config.alpha assert_true((result.alphaAdjusted - expected).abs() < 1.0e-10) } ///| test "stage_r_significant_genes" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_holm()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_holm(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) let sigGenes = @src.get_significant_genes(result) assert_eq(sigGenes.length(), result.nSignificantGenes) @@ -173,7 +199,11 @@ test "stage_r_significant_genes" { ///| test "stage_r_significant_hypotheses" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_holm()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_holm(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) let sigHyps = @src.get_significant_hypotheses(result) // All pairs should have valid indices. @@ -189,7 +219,11 @@ test "stage_r_significant_hypotheses" { ///| test "stage_r_get_results" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_holm()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_holm(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) let mat = @src.get_results(result) assert_eq(mat.length(), result.nGenes) @@ -204,7 +238,11 @@ test "stage_r_get_results" { ///| test "stage_r_non_significant_genes_na" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.001, pScreenAdjusted=false, stageMethod=@src.stage_r_method_holm()) + let config = @src.StageRConfig::new( + alpha=0.001, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_holm(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) // Non-significant genes should have -1.0 in confirmation p-values. let mut i = 0 @@ -225,7 +263,11 @@ test "stage_r_pscreen_adjusted" { let (pScreen, pConfirmation) = @src.stage_r_sample() // Pre-adjust the screening p-values. let adjScreen = @src.stage_r_bh_adjust(pScreen) - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=true, stageMethod=@src.stage_r_method_holm()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=true, + stageMethod=@src.stage_r_method_holm(), + ) let result = @src.stage_wise_adjustment(adjScreen, pConfirmation, config) // pAdjScreen should be the same as input. let mut i = 0 @@ -238,7 +280,11 @@ test "stage_r_pscreen_adjusted" { ///| test "stage_r_confirmation_rescaled" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_holm()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_holm(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) // For significant genes, confirmation p-values should be rescaled. let mut i = 0 diff --git a/test/moonbit/statistics_test.mbt b/test/moonbit/statistics_test.mbt index c3cd357f..f735171c 100644 --- a/test/moonbit/statistics_test.mbt +++ b/test/moonbit/statistics_test.mbt @@ -1,59 +1,69 @@ // Tests for Bio.Statistics module +///| test "stat_mean" { let data = [1.0, 2.0, 3.0, 4.0, 5.0] let result = @src.stat_mean(data) assert_true(result > 2.9 && result < 3.1) } +///| test "stat_mean empty" { let data : Array[Double] = Array::new() let result = @src.stat_mean(data) assert_true(result == 0.0) } +///| test "stat_variance" { let data = [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0] let result = @src.stat_variance(data) assert_true(result > 4.0 && result < 5.0) } +///| test "stat_std" { let data = [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0] let result = @src.stat_std(data) assert_true(result > 2.0 && result < 2.5) } +///| test "stat_median odd" { let data = [1.0, 3.0, 2.0, 5.0, 4.0] let result = @src.stat_median(data) assert_true(result == 3.0) } +///| test "stat_median even" { let data = [1.0, 2.0, 3.0, 4.0] let result = @src.stat_median(data) assert_true(result == 2.5) } +///| test "stat_min" { let data = [3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0] let result = @src.stat_min(data) assert_true(result == 1.0) } +///| test "stat_max" { let data = [3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0] let result = @src.stat_max(data) assert_true(result == 9.0) } +///| test "stat_sum" { let data = [1.0, 2.0, 3.0, 4.0, 5.0] let result = @src.stat_sum(data) assert_true(result == 15.0) } +///| test "stat_cumsum" { let data = [1.0, 2.0, 3.0] let result = @src.stat_cumsum(data) @@ -63,6 +73,7 @@ test "stat_cumsum" { assert_true(result[2] == 6.0) } +///| test "stat_pearson_correlation positive" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0] @@ -70,6 +81,7 @@ test "stat_pearson_correlation positive" { assert_true(result > 0.99 && result < 1.01) } +///| test "stat_pearson_correlation negative" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [10.0, 8.0, 6.0, 4.0, 2.0] @@ -77,22 +89,26 @@ test "stat_pearson_correlation negative" { assert_true(result < -0.99 && result > -1.01) } +///| test "stat_zscore" { let result = @src.stat_zscore(3.0, 2.0, 0.5) assert_true(result > 1.9 && result < 2.1) } +///| test "stat_normal_cdf at 0" { let result = @src.stat_normal_cdf(0.0) assert_true(result > 0.49 && result < 0.51) } +///| test "stat_t_statistic" { let sample = [2.0, 3.0, 4.0, 5.0, 6.0] let result = @src.stat_t_statistic(sample, 3.0) assert_true(result > 1.4 && result < 1.6) } +///| test "stat_confidence_interval" { let data = [2.0, 3.0, 4.0, 5.0, 6.0] let result = @src.stat_confidence_interval(data) @@ -100,6 +116,7 @@ test "stat_confidence_interval" { assert_true(result[0] < result[1]) } +///| test "stat_mann_whitney_u_basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0] @@ -107,6 +124,7 @@ test "stat_mann_whitney_u_basic" { assert_true(result.1 >= 0.0 && result.1 <= 1.0) } +///| test "stat_wilcoxon_signed_rank_basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0] @@ -114,6 +132,7 @@ test "stat_wilcoxon_signed_rank_basic" { assert_true(result.1 >= 0.0 && result.1 <= 1.0) } +///| test "stat_ks_test_basic" { let sample1 = [1.0, 2.0, 3.0, 4.0, 5.0] let sample2 = [2.0, 4.0, 6.0, 8.0, 10.0] @@ -121,12 +140,14 @@ test "stat_ks_test_basic" { assert_true(result.1 >= 0.0 && result.1 <= 1.0) } +///| test "stat_fisher_exact_basic" { let table = [[10, 2], [3, 5]] let result = @src.stat_fisher_exact(table) assert_true(result.1 >= 0.0 && result.1 <= 1.0) } +///| test "stat_bonferroni_correct_basic" { let p_values = [0.01, 0.04, 0.03, 0.005, 0.2] let result = @src.stat_bonferroni(p_values) @@ -134,67 +155,79 @@ test "stat_bonferroni_correct_basic" { assert_true(result[0] >= 0.01) } +///| test "stat_holm_correct_basic" { let p_values = [0.01, 0.04, 0.03, 0.005, 0.2] let result = @src.stat_holm(p_values) assert_true(result.length() == 5) } +///| test "stat_by_correct_basic" { let p_values = [0.01, 0.04, 0.03, 0.005, 0.2] let result = @src.stat_by(p_values) assert_true(result.length() == 5) } +///| test "stat_chi2_cdf_basic" { // For df=3, P(chi2 <= 7.81) ~ 0.95 let result = @src.stat_chi2_cdf(7.81, 3) assert_true(result > 0.90 && result < 0.99) } +///| test "stat_chi2_cdf_zero" { let result = @src.stat_chi2_cdf(0.0, 3) assert_true(result == 0.0) } +///| test "stat_chi2_cdf_negative" { let result = @src.stat_chi2_cdf(-1.0, 5) assert_true(result == 0.0) } +///| test "stat_chi2_quantile_basic" { // For df=2, chi2_0.95 ~ 5.99 let result = @src.stat_chi2_quantile(0.95, 2) assert_true(result > 5.0 && result < 7.0) } +///| test "stat_chi2_quantile_zero_one" { assert_true(@src.stat_chi2_quantile(0.0, 2) == 0.0) assert_true(@src.stat_chi2_quantile(1.0, 2) > 1.0e100) } +///| test "stat_t_cdf_central" { let result = @src.stat_t_cdf(0.0, 10.0) assert_true(result > 0.49 && result < 0.51) } +///| test "stat_t_cdf_positive" { // t with df=10 at 2.228 ~ 0.975 let result = @src.stat_t_cdf(2.228, 10.0) assert_true(result > 0.94 && result < 0.99) } +///| test "stat_t_quantile_central" { let result = @src.stat_t_quantile(0.5, 10.0) assert_true(result > -0.01 && result < 0.01) } +///| test "stat_t_quantile_basic" { // t_0.975,df=10 ~ 2.228 let result = @src.stat_t_quantile(0.975, 10.0) assert_true(result > 1.5 && result < 3.0) } +///| test "stat_t_test_one_sample" { let sample = [2.1, 2.3, 2.2, 2.4, 2.0] let result = @src.stat_t_test_one_sample(sample, 2.0) @@ -202,6 +235,7 @@ test "stat_t_test_one_sample" { assert_true(result.1 > 0.0 && result.1 <= 1.0) } +///| test "stat_t_test_two_sample" { let x = [2.1, 2.3, 2.2, 2.4, 2.0] let y = [3.1, 3.3, 3.2, 3.4, 3.0] @@ -209,6 +243,7 @@ test "stat_t_test_two_sample" { assert_true(result.1 >= 0.0 && result.1 <= 1.0) } +///| test "stat_bh_basic" { let p_values = [0.01, 0.04, 0.03, 0.005, 0.2] let result = @src.stat_bh(p_values) @@ -222,23 +257,27 @@ test "stat_bh_basic" { } } +///| test "stat_bh_empty" { let p_values : Array[Double] = Array::new() let result = @src.stat_bh(p_values) assert_true(result.length() == 0) } +///| test "stat_normal_quantile_half" { let result = @src.stat_normal_quantile(0.5) assert_true(result > -0.01 && result < 0.01) } +///| test "stat_normal_quantile_standard" { // qnorm(0.975) ~ 1.96 let result = @src.stat_normal_quantile(0.975) assert_true(result > 1.9 && result < 2.1) } +///| test "stat_mad_basic" { let data = [1.0, 2.0, 3.0, 4.0, 5.0] let result = @src.stat_mad(data) @@ -246,27 +285,22 @@ test "stat_mad_basic" { assert_true(result > 1.0 && result < 2.0) } +///| test "stat_anova_basic" { - let samples = [ - [1.0, 2.0, 3.0], - [2.0, 3.0, 4.0], - [8.0, 9.0, 10.0], - ] + let samples = [[1.0, 2.0, 3.0], [2.0, 3.0, 4.0], [8.0, 9.0, 10.0]] let result = @src.stat_anova(samples) assert_true(result.0 > 0.0) assert_true(result.1 >= 0.0 && result.1 <= 1.0) } +///| test "stat_anova_equal" { - let samples = [ - [1.0, 1.0, 1.0], - [1.0, 1.0, 1.0], - [1.0, 1.0, 1.0], - ] + let samples = [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]] let result = @src.stat_anova(samples) assert_true(result.0 >= 0.0) } +///| test "stat_logrank_test_basic" { let time = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] let event = [true, true, true, false, true, false] diff --git a/test/moonbit/stockholm_test.mbt b/test/moonbit/stockholm_test.mbt index 8f43ba5b..20db96cf 100644 --- a/test/moonbit/stockholm_test.mbt +++ b/test/moonbit/stockholm_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Stockholm format parser module. - test "stockholm_parse_header" { let content = "# STOCKHOLM 1.0\nseq1/1-10 ACGTACGTAC\n//\n" let ali = @src.stockholm_parse(content) @@ -8,18 +7,21 @@ test "stockholm_parse_header" { assert_eq(ali.blocks.length(), 1) } +///| test "stockholm_parse_empty" { let ali = @src.stockholm_parse("") assert_eq(ali.blocks.length(), 0) assert_eq(ali.gf_annotations.keys().length(), 0) } +///| test "stockholm_parse_header_only" { let content = "# STOCKHOLM 1.0\n//\n" let ali = @src.stockholm_parse(content) assert_eq(ali.blocks.length(), 0) } +///| test "stockholm_parse_single_sequence" { let content = "# STOCKHOLM 1.0\nseq1/1-10 ACGTACGTAC\n//\n" let ali = @src.stockholm_parse(content) @@ -31,6 +33,7 @@ test "stockholm_parse_single_sequence" { assert_eq(ali.blocks[0].sequences[0].end, 10) } +///| test "stockholm_parse_multiple_sequences" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + @@ -42,6 +45,7 @@ test "stockholm_parse_multiple_sequences" { assert_eq(ali.blocks[0].sequences.length(), 3) } +///| test "stockholm_parse_gf_annotations" { let content = "# STOCKHOLM 1.0\n" + "#=GF ID TestFamily\n" + @@ -56,6 +60,7 @@ test "stockholm_parse_gf_annotations" { assert_eq(ali.gf_annotations["DE"], "A test protein family") } +///| test "stockholm_parse_gc_ss_cons" { let content = "# STOCKHOLM 1.0\n" + "#=GC SS_cons ........((((...)))).....\n" + @@ -65,6 +70,7 @@ test "stockholm_parse_gc_ss_cons" { assert_eq(ali.blocks[0].secondary_structure, "........((((...)))).....") } +///| test "stockholm_parse_gr_annotation" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + @@ -74,6 +80,7 @@ test "stockholm_parse_gr_annotation" { assert_true(ali.blocks[0].gr_annotations.keys().length() > 0) } +///| test "stockholm_parse_gs_annotation" { let content = "# STOCKHOLM 1.0\n" + "#=GS seq1 some annotation value\n" + @@ -83,6 +90,7 @@ test "stockholm_parse_gs_annotation" { assert_true(ali.gs_annotations.keys().length() > 0) } +///| test "stockholm_parse_multiple_blocks" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + @@ -97,14 +105,10 @@ test "stockholm_parse_multiple_blocks" { assert_eq(ali.blocks[1].sequences.length(), 2) } +///| test "stockholm_sequence_struct" { let seq = @src.StockholmSequence::new( - "test", - "PF00001", - "Test description", - "ACGTAC", - 1, - 6, + "test", "PF00001", "Test description", "ACGTAC", 1, 6, ) assert_eq(seq.name, "test") assert_eq(seq.accession, "PF00001") @@ -114,6 +118,7 @@ test "stockholm_sequence_struct" { assert_eq(seq.end, 6) } +///| test "stockholm_block_struct" { let seqs : Array[@src.StockholmSequence] = Array::new() let gc : Map[String, String] = Map([], capacity=0) @@ -124,6 +129,7 @@ test "stockholm_block_struct" { assert_eq(block.consensus, "cons") } +///| test "stockholm_alignment_struct" { let blocks : Array[@src.StockholmBlock] = Array::new() let gf : Map[String, String] = Map([], capacity=0) @@ -134,6 +140,7 @@ test "stockholm_alignment_struct" { assert_eq(ali.blocks.length(), 0) } +///| test "stockholm_percent_identity_identical" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + @@ -144,6 +151,7 @@ test "stockholm_percent_identity_identical" { assert_true(pid > 0.99) } +///| test "stockholm_percent_identity_different" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + @@ -154,6 +162,7 @@ test "stockholm_percent_identity_different" { assert_true(pid < 0.3) } +///| test "stockholm_percent_identity_with_gaps" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + @@ -165,6 +174,7 @@ test "stockholm_percent_identity_with_gaps" { assert_true(pid <= 1.0) } +///| test "stockholm_conservation_single_column" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-5 ACGT.\n" + @@ -178,6 +188,7 @@ test "stockholm_conservation_single_column" { assert_true(cons[4] >= 0.0) } +///| test "stockholm_conservation_all_gap_column" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-5 ACGT-\n" + @@ -188,6 +199,7 @@ test "stockholm_conservation_all_gap_column" { assert_eq(cons[4], 0.0) } +///| test "stockholm_to_fasta_basic" { let content = "# STOCKHOLM 1.0\n" + "#=GF AC PF00001\n" + @@ -201,6 +213,7 @@ test "stockholm_to_fasta_basic" { assert_true(fasta.contains("ACGTACGTAC")) } +///| test "stockholm_to_fasta_no_duplicates" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + @@ -212,6 +225,7 @@ test "stockholm_to_fasta_no_duplicates" { assert_true(fasta.contains(">seq1")) } +///| test "stockholm_merge_blocks_basic" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + @@ -225,6 +239,7 @@ test "stockholm_merge_blocks_basic" { assert_eq(merged.blocks[0].sequences.length(), 1) } +///| test "stockholm_merge_blocks_sequence_concat" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-5 ACGTG\n" + @@ -237,6 +252,7 @@ test "stockholm_merge_blocks_sequence_concat" { assert_eq(seq.aligned_seq, "ACGTGTACGT") } +///| test "stockholm_write_roundtrip" { let content = "# STOCKHOLM 1.0\n" + "#=GF ID TestFamily\n" + @@ -252,6 +268,7 @@ test "stockholm_write_roundtrip" { assert_true(output.contains("//")) } +///| test "stockholm_write_contains_gf" { let content = "# STOCKHOLM 1.0\n" + "#=GF ID TestFamily\n" + @@ -264,16 +281,16 @@ test "stockholm_write_contains_gf" { assert_true(output.contains("#=GF AC")) } +///| test "stockholm_sequence_without_range" { - let content = "# STOCKHOLM 1.0\n" + - "seq1 ACGTACGTAC\n" + - "//\n" + let content = "# STOCKHOLM 1.0\n" + "seq1 ACGTACGTAC\n" + "//\n" let ali = @src.stockholm_parse(content) assert_eq(ali.blocks[0].sequences.length(), 1) assert_eq(ali.blocks[0].sequences[0].name, "seq1") assert_eq(ali.blocks[0].sequences[0].start, 1) } +///| test "stockholm_gap_handling" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGT--GTAC\n" + @@ -284,6 +301,7 @@ test "stockholm_gap_handling" { assert_eq(ali.blocks[0].sequences[1].aligned_seq, "ACGTACGTAC") } +///| test "stockholm_sample_content" { let content = @src.sample_stockholm_content() let ali = @src.stockholm_parse(content) @@ -292,6 +310,7 @@ test "stockholm_sample_content" { assert_eq(ali.blocks[0].sequences.length(), 3) } +///| test "stockholm_sample_alignment" { let ali = @src.sample_stockholm_alignment() assert_eq(ali.version, "1.0") @@ -299,6 +318,7 @@ test "stockholm_sample_alignment" { assert_true(ali.blocks[0].secondary_structure.length() > 0) } +///| test "stockholm_multiline_gf" { let content = "# STOCKHOLM 1.0\n" + "#=GF DE This is a long description\n" + @@ -309,6 +329,7 @@ test "stockholm_multiline_gf" { assert_true(ali.gf_annotations.keys().length() > 0) } +///| test "stockholm_conservation_with_mixed_chars" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-5 ACGTN\n" + @@ -322,15 +343,15 @@ test "stockholm_conservation_with_mixed_chars" { assert_true(cons[4] >= 0.66) } +///| test "stockholm_percent_identity_single_sequence" { - let content = "# STOCKHOLM 1.0\n" + - "seq1/1-10 ACGTACGTAC\n" + - "//\n" + let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + "//\n" let ali = @src.stockholm_parse(content) let pid = @src.stockholm_percent_identity(ali.blocks[0]) assert_eq(pid, 0.0) } +///| test "stockholm_to_fasta_empty_alignment" { let content = "# STOCKHOLM 1.0\n//\n" let ali = @src.stockholm_parse(content) @@ -338,16 +359,16 @@ test "stockholm_to_fasta_empty_alignment" { assert_eq(fasta.length(), 0) } +///| test "stockholm_merge_single_block" { - let content = "# STOCKHOLM 1.0\n" + - "seq1/1-10 ACGTACGTAC\n" + - "//\n" + let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + "//\n" let ali = @src.stockholm_parse(content) let merged = @src.stockholm_merge_blocks(ali) assert_eq(merged.blocks.length(), 1) assert_eq(merged.blocks[0].sequences.length(), 1) } +///| test "stockholm_parse_with_comment_lines" { let content = "# STOCKHOLM 1.0\n" + "# Some comment\n" + @@ -358,6 +379,7 @@ test "stockholm_parse_with_comment_lines" { assert_true(ali.markup.length() > 0) } +///| test "stockholm_ss_cons_roundtrip" { let content = "# STOCKHOLM 1.0\n" + "#=GC SS_cons ........((((...)))).....\n" + @@ -369,15 +391,15 @@ test "stockholm_ss_cons_roundtrip" { assert_true(output.contains("........((((...)))).....")) } +///| test "stockholm_parse_range_with_dash" { - let content = "# STOCKHOLM 1.0\n" + - "seq1/1-100 ACGTACGT\n" + - "//\n" + let content = "# STOCKHOLM 1.0\n" + "seq1/1-100 ACGTACGT\n" + "//\n" let ali = @src.stockholm_parse(content) assert_eq(ali.blocks[0].sequences[0].start, 1) assert_eq(ali.blocks[0].sequences[0].end, 100) } +///| test "stockholm_parse_accession_from_gf" { let content = "# STOCKHOLM 1.0\n" + "#=GF AC PF12345.6\n" + @@ -387,4 +409,4 @@ test "stockholm_parse_accession_from_gf" { let ali = @src.stockholm_parse(content) assert_eq(ali.gf_annotations["AC"], "PF12345.6") assert_eq(ali.gf_annotations["DE"], "Test family") -} \ No newline at end of file +} diff --git a/test/moonbit/structural_variant_test.mbt b/test/moonbit/structural_variant_test.mbt index dc926621..8908096e 100644 --- a/test/moonbit/structural_variant_test.mbt +++ b/test/moonbit/structural_variant_test.mbt @@ -78,7 +78,15 @@ test "sv_breakend_is_inter_chromosomal" { ///| test "sv_record_creation" { let rec = @src.SvRecord::new( - "sv1", "chr1", 1000, @src.sv_type_del(), 2000, -1000, None, 500.0, "PASS", + "sv1", + "chr1", + 1000, + @src.sv_type_del(), + 2000, + -1000, + None, + 500.0, + "PASS", ) assert_eq(rec.id(), "sv1") assert_eq(rec.chrom(), "chr1") @@ -92,11 +100,27 @@ test "sv_record_creation" { ///| test "sv_record_is_bnd" { let bnd = @src.SvRecord::new( - "sv1", "chr1", 1000, @src.sv_type_bnd(), 1000, 0, None, 500.0, "PASS", + "sv1", + "chr1", + 1000, + @src.sv_type_bnd(), + 1000, + 0, + None, + 500.0, + "PASS", ) assert_true(bnd.is_bnd()) let del = @src.SvRecord::new( - "sv2", "chr1", 1000, @src.sv_type_del(), 2000, -1000, None, 500.0, "PASS", + "sv2", + "chr1", + 1000, + @src.sv_type_del(), + 2000, + -1000, + None, + 500.0, + "PASS", ) assert_false(del.is_bnd()) } @@ -104,7 +128,15 @@ test "sv_record_is_bnd" { ///| test "sv_record_size" { let del = @src.SvRecord::new( - "sv1", "chr1", 1000, @src.sv_type_del(), 2000, -1000, None, 0.0, "PASS", + "sv1", + "chr1", + 1000, + @src.sv_type_del(), + 2000, + -1000, + None, + 0.0, + "PASS", ) assert_eq(del.size(), 1000) } @@ -113,11 +145,27 @@ test "sv_record_size" { test "sv_record_is_inter_chromosomal" { let be = @src.SvBreakend::new("chr1", 1000, "+", "chr2", 2000, "-") let bnd = @src.SvRecord::new( - "sv1", "chr1", 1000, @src.sv_type_bnd(), 1000, 0, Some(be), 0.0, "PASS", + "sv1", + "chr1", + 1000, + @src.sv_type_bnd(), + 1000, + 0, + Some(be), + 0.0, + "PASS", ) assert_true(bnd.is_inter_chromosomal()) let del = @src.SvRecord::new( - "sv2", "chr1", 1000, @src.sv_type_del(), 2000, -1000, None, 0.0, "PASS", + "sv2", + "chr1", + 1000, + @src.sv_type_del(), + 2000, + -1000, + None, + 0.0, + "PASS", ) assert_false(del.is_inter_chromosomal()) } @@ -288,7 +336,7 @@ test "sv_find_partners_sample" { let (id_a, id_b) = pairs[0] assert_true( (id_a == "sv_bnd_1" && id_b == "sv_bnd_2") || - (id_a == "sv_bnd_2" && id_b == "sv_bnd_1"), + (id_a == "sv_bnd_2" && id_b == "sv_bnd_1"), ) } @@ -305,10 +353,26 @@ test "sv_are_partners_mutual" { ///| test "sv_are_partners_non_bnd" { let del = @src.SvRecord::new( - "sv1", "chr1", 1000, @src.sv_type_del(), 2000, -1000, None, 0.0, "PASS", + "sv1", + "chr1", + 1000, + @src.sv_type_del(), + 2000, + -1000, + None, + 0.0, + "PASS", ) let dup = @src.SvRecord::new( - "sv2", "chr1", 3000, @src.sv_type_dup(), 5000, 2000, None, 0.0, "PASS", + "sv2", + "chr1", + 3000, + @src.sv_type_dup(), + 5000, + 2000, + None, + 0.0, + "PASS", ) assert_false(@src.sv_are_partners(del, dup)) } @@ -479,10 +543,26 @@ test "sv_filter_empty_records" { ///| test "sv_find_partners_no_bnd" { let del = @src.SvRecord::new( - "sv1", "chr1", 1000, @src.sv_type_del(), 2000, -1000, None, 0.0, "PASS", + "sv1", + "chr1", + 1000, + @src.sv_type_del(), + 2000, + -1000, + None, + 0.0, + "PASS", ) let dup = @src.SvRecord::new( - "sv2", "chr1", 3000, @src.sv_type_dup(), 5000, 2000, None, 0.0, "PASS", + "sv2", + "chr1", + 3000, + @src.sv_type_dup(), + 5000, + 2000, + None, + 0.0, + "PASS", ) let pairs = @src.sv_find_partners([del, dup]) assert_eq(pairs.length(), 0) diff --git a/test/moonbit/structure_alignment_test.mbt b/test/moonbit/structure_alignment_test.mbt index e5a2fe44..c7e2b76f 100644 --- a/test/moonbit/structure_alignment_test.mbt +++ b/test/moonbit/structure_alignment_test.mbt @@ -9,7 +9,11 @@ test "structure_alignment_point3d" { ///| test "structure_alignment_create_residue" { - let residue = @src.SAResidue::new("ALA", 1, @src.SAPoint3D::new(1.0, 0.0, 0.0)) + let residue = @src.SAResidue::new( + "ALA", + 1, + @src.SAPoint3D::new(1.0, 0.0, 0.0), + ) assert_eq(residue.resname, "ALA") assert_eq(residue.resseq, 1) @@ -126,4 +130,4 @@ test "structure_alignment_pairwise_rmsd" { assert_eq(matrix.length(), 2) assert_eq(matrix[0][0], 0.0) -} \ No newline at end of file +} diff --git a/test/moonbit/substitution_matrices_test.mbt b/test/moonbit/substitution_matrices_test.mbt index ba24c1ff..b403647e 100644 --- a/test/moonbit/substitution_matrices_test.mbt +++ b/test/moonbit/substitution_matrices_test.mbt @@ -13,6 +13,7 @@ test "submat_protein_alphabet_has_20_letters" { assert_eq(alpha[19], "Y") } +///| test "submat_nucleotide_alphabet_has_4_letters" { let alpha = @src.subs_nucleotide_alphabet() assert_eq(alpha.length(), 4) @@ -23,6 +24,7 @@ test "submat_nucleotide_alphabet_has_4_letters" { // ArrayData structure // --------------------------------------------------------------------------- +///| test "submat_array_data_from_dict_basic" { let pairs = [ ("A", "A", 5.0), @@ -34,19 +36,21 @@ test "submat_array_data_from_dict_basic" { assert_eq(ad.rows, ["A", "C"]) assert_eq(ad.cols, ["A", "C"]) assert_true((ad.get(0, 0) - 5.0).abs() < 1.0e-10) - assert_true((ad.get(0, 1) - (-1.0)).abs() < 1.0e-10) + assert_true((ad.get(0, 1) - -1.0).abs() < 1.0e-10) assert_true((ad.get(1, 1) - 9.0).abs() < 1.0e-10) } +///| test "submat_array_data_get_by_label" { let pairs = [("A", "B", 3.0), ("B", "A", 7.0)] let ad = @src.array_data_from_dict(pairs, ["A", "B"], ["A", "B"]) assert_true((ad.get_by_label("A", "B") - 3.0).abs() < 1.0e-10) assert_true((ad.get_by_label("B", "A") - 7.0).abs() < 1.0e-10) // Missing label returns 0.0 - assert_true((ad.get_by_label("X", "Y")).abs() < 1.0e-10) + assert_true(ad.get_by_label("X", "Y").abs() < 1.0e-10) } +///| test "submat_array_data_set_updates_value" { let pairs : Array[(String, String, Double)] = [] let ad = @src.array_data_from_dict(pairs, ["A", "B"], ["A", "B"]) @@ -57,28 +61,31 @@ test "submat_array_data_set_updates_value" { assert_true(true) } +///| test "submat_array_data_get_out_of_bounds_returns_zero" { let pairs : Array[(String, String, Double)] = [] let ad = @src.array_data_from_dict(pairs, ["A"], ["A"]) - assert_true((ad.get(-1, 0)).abs() < 1.0e-10) - assert_true((ad.get(0, 99)).abs() < 1.0e-10) + assert_true(ad.get(-1, 0).abs() < 1.0e-10) + assert_true(ad.get(0, 99).abs() < 1.0e-10) } // --------------------------------------------------------------------------- // Built-in BLOSUM matrices // --------------------------------------------------------------------------- +///| test "submat_blosum62_known_scores" { let m = @src.subs_blosum62_matrix() assert_eq(m.name(), "BLOSUM62") assert_eq(m.n_letters(), 20) assert_true((m.get_score("A", "A") - 4.0).abs() < 1.0e-10) assert_true((m.get_score("R", "R") - 5.0).abs() < 1.0e-10) - assert_true((m.get_score("A", "R") - (-1.0)).abs() < 1.0e-10) + assert_true((m.get_score("A", "R") - -1.0).abs() < 1.0e-10) assert_true((m.get_score("W", "W") - 11.0).abs() < 1.0e-10) assert_true((m.get_score("C", "C") - 9.0).abs() < 1.0e-10) } +///| test "submat_blosum62_is_symmetric" { let m = @src.subs_blosum62_matrix() let alpha = m.alphabet() @@ -91,6 +98,7 @@ test "submat_blosum62_is_symmetric" { } } +///| test "submat_blosum45_known_scores" { let m = @src.subs_blosum45_matrix() assert_eq(m.name(), "BLOSUM45") @@ -100,6 +108,7 @@ test "submat_blosum45_known_scores" { assert_true((m.get_score("C", "C") - 12.0).abs() < 1.0e-10) } +///| test "submat_blosum80_known_scores" { let m = @src.subs_blosum80_matrix() assert_eq(m.name(), "BLOSUM80") @@ -108,6 +117,7 @@ test "submat_blosum80_known_scores" { assert_true((m.get_score("W", "W") - 15.0).abs() < 1.0e-10) } +///| test "submat_blosum90_known_scores" { let m = @src.subs_blosum90_matrix() assert_eq(m.name(), "BLOSUM90") @@ -120,6 +130,7 @@ test "submat_blosum90_known_scores" { // Built-in PAM matrices // --------------------------------------------------------------------------- +///| test "submat_pam30_known_scores" { let m = @src.subs_pam30_matrix() assert_eq(m.name(), "PAM30") @@ -128,6 +139,7 @@ test "submat_pam30_known_scores" { assert_true((m.get_score("W", "W") - 14.0).abs() < 1.0e-10) } +///| test "submat_pam70_known_scores" { let m = @src.subs_pam70_matrix() assert_eq(m.name(), "PAM70") @@ -136,6 +148,7 @@ test "submat_pam70_known_scores" { assert_true((m.get_score("W", "W") - 13.0).abs() < 1.0e-10) } +///| test "submat_pam250_known_scores" { let m = @src.subs_pam250_matrix() assert_eq(m.name(), "PAM250") @@ -148,21 +161,23 @@ test "submat_pam250_known_scores" { // Built-in nucleotide matrix // --------------------------------------------------------------------------- +///| test "submat_nuc44_match_mismatch" { let m = @src.subs_nuc44_matrix() assert_eq(m.name(), "NUC4.4") assert_eq(m.n_letters(), 4) assert_true((m.get_score("A", "A") - 5.0).abs() < 1.0e-10) - assert_true((m.get_score("A", "C") - (-4.0)).abs() < 1.0e-10) + assert_true((m.get_score("A", "C") - -4.0).abs() < 1.0e-10) assert_true((m.get_score("G", "G") - 5.0).abs() < 1.0e-10) assert_true((m.get_score("T", "T") - 5.0).abs() < 1.0e-10) - assert_true((m.get_score("A", "T") - (-4.0)).abs() < 1.0e-10) + assert_true((m.get_score("A", "T") - -4.0).abs() < 1.0e-10) } // --------------------------------------------------------------------------- // SubsMatrix construction and methods // --------------------------------------------------------------------------- +///| test "submat_subs_matrix_from_pairs" { let alpha = ["A", "C"] let pairs = [ @@ -176,17 +191,19 @@ test "submat_subs_matrix_from_pairs" { assert_eq(m.n_letters(), 2) assert_true((m.get_score("A", "A") - 5.0).abs() < 1.0e-10) assert_true((m.get_score("C", "C") - 9.0).abs() < 1.0e-10) - assert_true((m.get_score("A", "C") - (-2.0)).abs() < 1.0e-10) + assert_true((m.get_score("A", "C") - -2.0).abs() < 1.0e-10) } +///| test "submat_get_score_idx" { let m = @src.subs_blosum62_matrix() // A=0, R=14 in alphabet ACDEFGHIKLMNPQRSTVWY assert_true((m.get_score_idx(0, 0) - 4.0).abs() < 1.0e-10) // A-R = -1 - assert_true((m.get_score_idx(0, 14) - (-1.0)).abs() < 1.0e-10) + assert_true((m.get_score_idx(0, 14) - -1.0).abs() < 1.0e-10) } +///| test "submat_select_submatrix" { let m = @src.subs_blosum62_matrix() let sub = m.select(["A", "C", "D"]) @@ -198,6 +215,7 @@ test "submat_select_submatrix" { assert_true((sub.get_score("A", "C") - 0.0).abs() < 1.0e-10) } +///| test "submat_to_table_string_has_name" { let m = @src.subs_blosum62_matrix() let s = m.to_table_string() @@ -211,6 +229,7 @@ test "submat_to_table_string_has_name" { // Matrix registry // --------------------------------------------------------------------------- +///| test "submat_registry_initialize_and_list" { @src.subs_initialize_registry() let names = @src.list_matrices() @@ -220,15 +239,22 @@ test "submat_registry_initialize_and_list" { let mut has_pam250 = false let mut has_nuc44 = false for n in names { - if n == "BLOSUM62" { has_blosum62 = true } - if n == "PAM250" { has_pam250 = true } - if n == "NUC4.4" { has_nuc44 = true } + if n == "BLOSUM62" { + has_blosum62 = true + } + if n == "PAM250" { + has_pam250 = true + } + if n == "NUC4.4" { + has_nuc44 = true + } } assert_true(has_blosum62) assert_true(has_pam250) assert_true(has_nuc44) } +///| test "submat_registry_load_existing_matrix" { @src.subs_initialize_registry() let opt = @src.load_matrix("BLOSUM62") @@ -238,12 +264,14 @@ test "submat_registry_load_existing_matrix" { assert_true((m.get_score("A", "A") - 4.0).abs() < 1.0e-10) } +///| test "submat_registry_load_missing_returns_none" { @src.subs_initialize_registry() let opt = @src.load_matrix("NONEXISTENT_MATRIX_XYZ") assert_true(opt.is_none()) } +///| test "submat_registry_register_custom_matrix" { let alpha = ["A", "C"] let pairs = [ @@ -260,6 +288,7 @@ test "submat_registry_register_custom_matrix" { assert_true((loaded.get_score("A", "A") - 1.0).abs() < 1.0e-10) } +///| test "submat_registry_register_overwrites_existing" { let alpha = ["A"] let pairs1 = [("A", "A", 5.0)] @@ -276,6 +305,7 @@ test "submat_registry_register_overwrites_existing" { // Frequency matrix calculation // --------------------------------------------------------------------------- +///| test "submat_calculate_frequency_matrix_identical_sequences" { let alignment = ["ACGT", "ACGT"] let alpha = @src.subs_nucleotide_alphabet() @@ -288,9 +318,10 @@ test "submat_calculate_frequency_matrix_identical_sequences" { assert_true((freq.get(2, 2) - 2.0).abs() < 1.0e-10) // G assert_true((freq.get(3, 3) - 2.0).abs() < 1.0e-10) // T // Off-diagonal should be 0 - assert_true((freq.get(0, 1)).abs() < 1.0e-10) + assert_true(freq.get(0, 1).abs() < 1.0e-10) } +///| test "submat_calculate_frequency_matrix_with_substitutions" { let alignment = ["ACGT", "AGGT"] // position 1: C->G let alpha = @src.subs_nucleotide_alphabet() @@ -306,6 +337,7 @@ test "submat_calculate_frequency_matrix_with_substitutions" { assert_true((freq.get(3, 3) - 2.0).abs() < 1.0e-10) } +///| test "submat_calculate_frequency_matrix_skips_gaps" { let alignment = ["A-A", "ACA"] // position 1: gap in seq1 let alpha = @src.subs_nucleotide_alphabet() @@ -315,16 +347,17 @@ test "submat_calculate_frequency_matrix_skips_gaps" { // Position 2: A-A -> freq[0][0] += 2 assert_true((freq.get(0, 0) - 4.0).abs() < 1.0e-10) // No C-C pairs - assert_true((freq.get(1, 1)).abs() < 1.0e-10) + assert_true(freq.get(1, 1).abs() < 1.0e-10) } +///| test "submat_calculate_frequency_matrix_single_sequence_returns_zeros" { let alignment = ["ACGT"] let alpha = @src.subs_nucleotide_alphabet() let freq = @src.calculate_frequency_matrix(alignment, alpha) for i in 0..<4 { for j in 0..<4 { - assert_true((freq.get(i, j)).abs() < 1.0e-10) + assert_true(freq.get(i, j).abs() < 1.0e-10) } } } @@ -333,6 +366,7 @@ test "submat_calculate_frequency_matrix_single_sequence_returns_zeros" { // Substitution matrix calculation (log-odds) // --------------------------------------------------------------------------- +///| test "submat_calculate_substitution_matrix_identical_seqs" { let alignment = ["AC", "AC"] let alpha = ["A", "C"] @@ -342,9 +376,10 @@ test "submat_calculate_substitution_matrix_identical_seqs" { assert_true((m.get_score("A", "A") - 2.0).abs() < 1.0e-10) assert_true((m.get_score("C", "C") - 2.0).abs() < 1.0e-10) // Off-diagonal: observed=0 -> -999 - assert_true((m.get_score("A", "C") - (-999.0)).abs() < 1.0e-10) + assert_true((m.get_score("A", "C") - -999.0).abs() < 1.0e-10) } +///| test "submat_calculate_substitution_matrix_default_scale" { let alignment = ["AA", "AA"] let alpha = ["A"] @@ -359,17 +394,21 @@ test "submat_calculate_substitution_matrix_default_scale" { // Shannon entropy // --------------------------------------------------------------------------- +///| test "submat_shannon_entropy_uniform_distribution" { // 2x2 matrix with all equal values: H = log2(4) = 2 let pairs = [ - ("A", "A", 1.0), ("A", "C", 1.0), - ("C", "A", 1.0), ("C", "C", 1.0), + ("A", "A", 1.0), + ("A", "C", 1.0), + ("C", "A", 1.0), + ("C", "C", 1.0), ] let freq = @src.array_data_from_dict(pairs, ["A", "C"], ["A", "C"]) let h = @src.subs_shannon_entropy(freq) assert_true((h - 2.0).abs() < 1.0e-10) } +///| test "submat_shannon_entropy_certain_distribution" { // All mass on one cell: H = 0 let pairs = [("A", "A", 4.0)] @@ -378,6 +417,7 @@ test "submat_shannon_entropy_certain_distribution" { assert_true(h.abs() < 1.0e-10) } +///| test "submat_shannon_entropy_empty_matrix" { let pairs : Array[(String, String, Double)] = [] let freq = @src.array_data_from_dict(pairs, ["A"], ["A"]) @@ -385,6 +425,7 @@ test "submat_shannon_entropy_empty_matrix" { assert_true(h.abs() < 1.0e-10) } +///| test "submat_shannon_entropy_two_equal_cells" { // Two non-zero cells with equal weight: H = 1 let pairs = [("A", "A", 1.0), ("C", "C", 1.0)] @@ -397,17 +438,21 @@ test "submat_shannon_entropy_two_equal_cells" { // Relative entropy (KL divergence) // --------------------------------------------------------------------------- +///| test "submat_relative_entropy_uniform_is_zero" { // When all letters equally frequent, observed == expected, KL = 0 let pairs = [ - ("A", "A", 1.0), ("A", "C", 1.0), - ("C", "A", 1.0), ("C", "C", 1.0), + ("A", "A", 1.0), + ("A", "C", 1.0), + ("C", "A", 1.0), + ("C", "C", 1.0), ] let freq = @src.array_data_from_dict(pairs, ["A", "C"], ["A", "C"]) let kl = @src.subs_relative_entropy(freq) assert_true(kl.abs() < 1.0e-10) } +///| test "submat_relative_entropy_identical_pairs_zero" { // Only A-A pairs: q(A,A)=1, p(A)=1, exp=1, KL = 1 * log2(1/1) = 0 let pairs = [("A", "A", 4.0)] @@ -416,6 +461,7 @@ test "submat_relative_entropy_identical_pairs_zero" { assert_true(kl.abs() < 1.0e-10) } +///| test "submat_relative_entropy_empty_matrix" { let pairs : Array[(String, String, Double)] = [] let freq = @src.array_data_from_dict(pairs, ["A"], ["A"]) @@ -427,6 +473,7 @@ test "submat_relative_entropy_empty_matrix" { // NCBI matrix parsing // --------------------------------------------------------------------------- +///| test "submat_parse_ncbi_matrix_simple" { let content = #|# Test matrix @@ -437,10 +484,11 @@ test "submat_parse_ncbi_matrix_simple" { assert_true(opt.is_some()) let m = opt.unwrap() assert_true((m.get_score("A", "A") - 1.0).abs() < 1.0e-10) - assert_true((m.get_score("A", "C") - (-1.0)).abs() < 1.0e-10) + assert_true((m.get_score("A", "C") - -1.0).abs() < 1.0e-10) assert_true((m.get_score("C", "C") - 1.0).abs() < 1.0e-10) } +///| test "submat_parse_ncbi_matrix_with_comments" { let content = #|# Generated by NCBI @@ -455,16 +503,18 @@ test "submat_parse_ncbi_matrix_with_comments" { let m = opt.unwrap() assert_true((m.get_score("A", "A") - 5.0).abs() < 1.0e-10) assert_true((m.get_score("C", "C") - 5.0).abs() < 1.0e-10) - assert_true((m.get_score("A", "C") - (-4.0)).abs() < 1.0e-10) - assert_true((m.get_score("G", "T") - (-4.0)).abs() < 1.0e-10) + assert_true((m.get_score("A", "C") - -4.0).abs() < 1.0e-10) + assert_true((m.get_score("G", "T") - -4.0).abs() < 1.0e-10) } +///| test "submat_parse_ncbi_matrix_empty_returns_none" { let content = "# only comments\n# nothing else\n" let opt = @src.parse_ncbi_matrix(content) assert_true(opt.is_none()) } +///| test "submat_parse_ncbi_matrix_handles_extra_whitespace" { let content = "A C\nA 2 -3\nC -3 2\n" let opt = @src.parse_ncbi_matrix(content) @@ -472,13 +522,14 @@ test "submat_parse_ncbi_matrix_handles_extra_whitespace" { let m = opt.unwrap() assert_true((m.get_score("A", "A") - 2.0).abs() < 1.0e-10) assert_true((m.get_score("C", "C") - 2.0).abs() < 1.0e-10) - assert_true((m.get_score("A", "C") - (-3.0)).abs() < 1.0e-10) + assert_true((m.get_score("A", "C") - -3.0).abs() < 1.0e-10) } // --------------------------------------------------------------------------- // Matrix correlation // --------------------------------------------------------------------------- +///| test "submat_matrix_correlation_identical_matrices" { let m1 = @src.subs_blosum62_matrix() let m2 = @src.subs_blosum62_matrix() @@ -487,6 +538,7 @@ test "submat_matrix_correlation_identical_matrices" { assert_true((corr - 1.0).abs() < 1.0e-9) } +///| test "submat_matrix_correlation_blosum45_vs_blosum62" { let m45 = @src.subs_blosum45_matrix() let m62 = @src.subs_blosum62_matrix() @@ -496,6 +548,7 @@ test "submat_matrix_correlation_blosum45_vs_blosum62" { assert_true(corr <= 1.0) } +///| test "submat_matrix_correlation_disjoint_alphabets" { let alpha1 = ["A"] let alpha2 = ["C"] @@ -510,6 +563,7 @@ test "submat_matrix_correlation_disjoint_alphabets" { // End-to-end: derive matrix from alignment, then score // --------------------------------------------------------------------------- +///| test "submat_end_to_end_derive_matrix_and_score" { // Build a small alignment where A and C never co-occur at the same position let alignment = ["AAA", "AAA", "CCC", "CCC"] diff --git a/test/moonbit/survival_test.mbt b/test/moonbit/survival_test.mbt index 1a692b81..163ce505 100644 --- a/test/moonbit/survival_test.mbt +++ b/test/moonbit/survival_test.mbt @@ -410,7 +410,9 @@ test "survival_normal_cdf" { ///| test "survival_normal_p_value_two_sided" { // z=1.96 -> p ≈ 0.05 - assert_true((@src.survival_normal_p_value_two_sided(1.96) - 0.05).abs() < 0.01) + assert_true( + (@src.survival_normal_p_value_two_sided(1.96) - 0.05).abs() < 0.01, + ) // z=0 -> p = 1.0 assert_true((@src.survival_normal_p_value_two_sided(0.0) - 1.0).abs() < 0.001) // p-value should be in [0, 1] @@ -432,7 +434,10 @@ test "survival_chi_square_p_value" { assert_true(@src.survival_chi_square_p_value(10.0, 5) >= 0.0) assert_true(@src.survival_chi_square_p_value(10.0, 5) <= 1.0) // Larger chi_sq gives smaller p-value - assert_true(@src.survival_chi_square_p_value(10.0, 1) < @src.survival_chi_square_p_value(1.0, 1)) + assert_true( + @src.survival_chi_square_p_value(10.0, 1) < + @src.survival_chi_square_p_value(1.0, 1), + ) } // =========================================================================== diff --git a/test/moonbit/system_piper_test.mbt b/test/moonbit/system_piper_test.mbt index 87e264b7..1cc2b8d2 100644 --- a/test/moonbit/system_piper_test.mbt +++ b/test/moonbit/system_piper_test.mbt @@ -1,6 +1,5 @@ ///| /// Test file for SystemPipeR module. - test "pipeline_new" { let pipe = @src.Pipeline::new("test_v1", "Test Pipeline") assert_eq(pipe.get_id(), "test_v1") @@ -8,6 +7,7 @@ test "pipeline_new" { assert_eq(pipe.get_n_steps(), 0) } +///| test "pipeline_set_description" { let pipe = @src.Pipeline::new("test", "Test") let pipe2 = pipe.set_description("A test pipeline") @@ -16,17 +16,20 @@ test "pipeline_set_description" { assert_true(s.contains("A test pipeline")) } +///| test "pipeline_set_param" { let pipe = @src.Pipeline::new("test", "Test") let pipe2 = pipe.set_param("key1", "value1") assert_eq(pipe2.get_param("key1"), "value1") } +///| test "pipeline_get_param_missing" { let pipe = @src.Pipeline::new("test", "Test") assert_eq(pipe.get_param("nonexistent"), "") } +///| test "pipeline_add_step" { let pipe = @src.Pipeline::new("test", "Test") let step = @src.PipelineStep::new("step1", "Step 1", "echo") @@ -34,6 +37,7 @@ test "pipeline_add_step" { assert_eq(pipe2.get_n_steps(), 1) } +///| test "pipeline_get_step" { let pipe = @src.Pipeline::new("test", "Test") let step = @src.PipelineStep::new("step1", "Step 1", "echo") @@ -43,12 +47,14 @@ test "pipeline_get_step" { assert_eq(s.get_name(), "Step 1") } +///| test "pipeline_get_step_not_found" { let pipe = @src.Pipeline::new("test", "Test") let s = pipe.get_step("missing") assert_eq(s.get_id(), "") } +///| test "pipeline_get_steps" { let pipe = @src.Pipeline::new("test", "Test") let pipe2 = pipe.add_step(@src.PipelineStep::new("s1", "S1", "cmd1")) @@ -57,26 +63,31 @@ test "pipeline_get_steps" { assert_eq(steps.length(), 2) } +///| test "pipeline_completed_count" { let pipe = @src.Pipeline::new("test", "Test") assert_eq(pipe.get_completed_count(), 0) } +///| test "pipeline_failed_count" { let pipe = @src.Pipeline::new("test", "Test") assert_eq(pipe.get_failed_count(), 0) } +///| test "pipeline_pending_count" { let pipe = @src.Pipeline::new("test", "Test") assert_eq(pipe.get_pending_count(), 0) } +///| test "pipeline_progress_empty" { let pipe = @src.Pipeline::new("test", "Test") assert_eq(pipe.get_progress(), 0.0) } +///| test "step_new" { let step = @src.PipelineStep::new("s1", "My Step", "bwa") assert_eq(step.get_id(), "s1") @@ -84,18 +95,21 @@ test "step_new" { assert_eq(step.get_command(), "bwa") } +///| test "step_set_description" { let step = @src.PipelineStep::new("s1", "Step", "cmd") let step2 = step.set_description("A step for testing") assert_eq(step2.description, "A step for testing") } +///| test "step_set_args" { let step = @src.PipelineStep::new("s1", "Step", "cmd") let step2 = step.set_args(["arg1", "arg2", "-v"]) assert_eq(step2.args.length(), 3) } +///| test "step_add_dependency" { let step = @src.PipelineStep::new("s2", "Step 2", "cmd") let step2 = step.add_dependency("s1") @@ -104,28 +118,33 @@ test "step_add_dependency" { assert_eq(deps[0], "s1") } +///| test "step_add_input" { let step = @src.PipelineStep::new("s1", "Step", "cmd") let step2 = step.add_input("input.fq") assert_eq(step2.input_files.length(), 1) } +///| test "step_add_output" { let step = @src.PipelineStep::new("s1", "Step", "cmd") let step2 = step.add_output("output.bam") assert_eq(step2.output_files.length(), 1) } +///| test "step_status" { let step = @src.PipelineStep::new("s1", "Step", "cmd") assert_true(step.get_status() is @src.StepStatus::Pending) } +///| test "step_duration" { let step = @src.PipelineStep::new("s1", "Step", "cmd") assert_eq(step.get_duration(), 0.0) } +///| test "step_status_to_string" { // Test default status via PipelineStep (which has Pending by default) let step = @src.PipelineStep::new("s1", "Step", "cmd") @@ -133,6 +152,7 @@ test "step_status_to_string" { assert_eq(status_str, "pending") } +///| test "pipeline_config_new" { let config = @src.PipelineConfig::new("/work", "/input", "/output") assert_eq(config.get_work_dir(), "/work") @@ -141,12 +161,14 @@ test "pipeline_config_new" { assert_eq(config.get_cores(), 1) } +///| test "pipeline_config_set_cores" { let config = @src.PipelineConfig::new("/w", "/i", "/o") let config2 = config.set_cores(8) assert_eq(config2.get_cores(), 8) } +///| test "pipeline_summary" { let pipe = @src.Pipeline::new("test", "My Pipeline") let s = pipe.summary() @@ -154,6 +176,7 @@ test "pipeline_summary" { assert_true(s.contains("My Pipeline")) } +///| test "pipeline_to_ascii" { let pipe = @src.Pipeline::new("test", "My Pipeline") let ascii = pipe.to_ascii() @@ -161,6 +184,7 @@ test "pipeline_to_ascii" { assert_true(ascii.contains("Progress")) } +///| test "pipeline_sample" { let pipe = @src.pipeline_sample() assert_true(pipe.get_n_steps() >= 5) @@ -168,6 +192,7 @@ test "pipeline_sample" { assert_true(pipe.get_progress() >= 0.0) } +///| test "pipeline_sample_steps" { let pipe = @src.pipeline_sample() let steps = pipe.get_steps() @@ -176,14 +201,16 @@ test "pipeline_sample_steps" { assert_eq(first.get_name(), "Quality Control") } +///| test "pipeline_global_params" { let pipe = @src.pipeline_sample() assert_eq(pipe.get_param("reference_genome"), "GRCh38.p14") assert_eq(pipe.get_param("species"), "Homo sapiens") } +///| test "step_can_run_no_deps" { let pipe = @src.Pipeline::new("test", "Test") let step = @src.PipelineStep::new("s1", "Step 1", "cmd") assert_true(pipe.can_run_step(step)) -} \ No newline at end of file +} diff --git a/test/moonbit/taxonomy_test.mbt b/test/moonbit/taxonomy_test.mbt index 1e28d482..0d589edc 100644 --- a/test/moonbit/taxonomy_test.mbt +++ b/test/moonbit/taxonomy_test.mbt @@ -1,11 +1,11 @@ ///| /// Taxonomy module tests - test "TaxonomyDatabase::new" { let db = @src.TaxonomyDatabase::new() assert_eq(db.count_taxa(), 0) } +///| test "TaxonomyDatabase::add_taxon" { let db = @src.TaxonomyDatabase::new() let taxon = @src.Taxon::new("1", "0", "no rank").set_scientific_name("root") @@ -13,6 +13,7 @@ test "TaxonomyDatabase::add_taxon" { assert_eq(db.count_taxa(), 1) } +///| test "TaxonomyDatabase::get_taxon" { let db = @src.TaxonomyDatabase::new() let taxon = @src.Taxon::new("1", "0", "no rank").set_scientific_name("root") @@ -23,6 +24,7 @@ test "TaxonomyDatabase::get_taxon" { } } +///| test "TaxonomyDatabase::get_taxid_by_name" { let db = @src.create_example_taxonomy() match db.get_taxid_by_name("Homo sapiens") { @@ -31,6 +33,7 @@ test "TaxonomyDatabase::get_taxid_by_name" { } } +///| test "TaxonomyDatabase::get_lineage" { let db = @src.create_example_taxonomy() let lineage = db.get_lineage("9606") @@ -38,12 +41,14 @@ test "TaxonomyDatabase::get_lineage" { assert_eq(lineage[lineage.length() - 1], "Homo sapiens") } +///| test "TaxonomyDatabase::get_ancestors" { let db = @src.create_example_taxonomy() let ancestors = db.get_ancestors("9606") assert_true(ancestors.length() > 0) } +///| test "TaxonomyDatabase::get_common_ancestor" { let db = @src.create_example_taxonomy() match db.get_common_ancestor("9606", "9599") { @@ -52,30 +57,35 @@ test "TaxonomyDatabase::get_common_ancestor" { } } +///| test "TaxonomyDatabase::is_ancestor" { let db = @src.create_example_taxonomy() assert_true(db.is_ancestor("9604", "9606")) assert_true(!db.is_ancestor("9606", "9604")) } +///| test "TaxonomyDatabase::get_distance" { let db = @src.create_example_taxonomy() let dist = db.get_distance("9606", "9599") assert_true(dist > 0) } +///| test "TaxonomyDatabase::get_taxa_by_rank" { let db = @src.create_example_taxonomy() let species = db.get_taxa_by_rank("species") assert_true(species.length() >= 2) } +///| test "parse_nodes_dmp" { let content = "1\t|\t0\t|\tno rank\t|\n131567\t|\t1\t|\tno rank\t|\n2759\t|\t131567\t|\tsuperkingdom\t|\n" let db = @src.parse_nodes_dmp(@src.TaxonomyDatabase::new(), content) assert_eq(db.count_taxa(), 3) } +///| test "parse_names_dmp" { let db = @src.TaxonomyDatabase::new() ignore(db.add_taxon(@src.Taxon::new("1", "0", "no rank"))) @@ -87,23 +97,27 @@ test "parse_names_dmp" { } } +///| test "create_example_taxonomy" { let db = @src.create_example_taxonomy() assert_true(db.count_taxa() > 10) } +///| test "get_all_species" { let db = @src.create_example_taxonomy() let species = db.get_all_species() assert_true(species.length() >= 2) } +///| test "get_common_names" { let db = @src.create_example_taxonomy() let names = db.get_common_names("9606") assert_true(contains_string(names, "human")) } +///| fn contains_string(arr : Array[String], s : String) -> Bool { let mut i = 0 while i < arr.length() { @@ -113,4 +127,4 @@ fn contains_string(arr : Array[String], s : String) -> Bool { i = i + 1 } false -} \ No newline at end of file +} diff --git a/test/moonbit/topgo_test.mbt b/test/moonbit/topgo_test.mbt index 0d345f33..62fefc8e 100644 --- a/test/moonbit/topgo_test.mbt +++ b/test/moonbit/topgo_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for topGO module. - test "TopGOTerm creation" { let term = @src.TopGOTerm::new("GO:0008150", "biological_process", "BP", 0) assert_eq(term.go_id, "GO:0008150") @@ -10,6 +9,7 @@ test "TopGOTerm creation" { assert_eq(term.gene_count, 0) } +///| test "TopGOGraph construction" { let mut graph = @src.TopGOGraph::new("GO:0008150") let root = @src.TopGOTerm::new("GO:0008150", "biological_process", "BP", 0) @@ -17,6 +17,7 @@ test "TopGOGraph construction" { assert_true(graph.terms.contains("GO:0008150")) } +///| test "TopGOGraph add edge" { let mut graph = @src.TopGOGraph::new("GO:0008150") let root = @src.TopGOTerm::new("GO:0008150", "biological_process", "BP", 0) @@ -28,22 +29,35 @@ test "TopGOGraph add edge" { assert_true(graph.terms.contains("GO:0009987")) } +///| test "topgo_elim_algorithm" { let graph = @src.create_example_topgo_graph() let genes_of_interest = ["gene1", "gene2", "gene3"] - let all_genes = ["gene1", "gene2", "gene3", "gene4", "gene5", "gene6", "gene7", "gene8", "gene9", "gene10"] - let results = @src.topgo_elim_algorithm(graph, genes_of_interest, all_genes, "BP") + let all_genes = [ + "gene1", "gene2", "gene3", "gene4", "gene5", "gene6", "gene7", "gene8", "gene9", + "gene10", + ] + let results = @src.topgo_elim_algorithm( + graph, genes_of_interest, all_genes, "BP", + ) assert_true(results.length() > 0) } +///| test "topgo_weight01_algorithm" { let graph = @src.create_example_topgo_graph() let genes_of_interest = ["gene1", "gene2", "gene3"] - let all_genes = ["gene1", "gene2", "gene3", "gene4", "gene5", "gene6", "gene7", "gene8", "gene9", "gene10"] - let results = @src.topgo_weight01_algorithm(graph, genes_of_interest, all_genes, "BP") + let all_genes = [ + "gene1", "gene2", "gene3", "gene4", "gene5", "gene6", "gene7", "gene8", "gene9", + "gene10", + ] + let results = @src.topgo_weight01_algorithm( + graph, genes_of_interest, all_genes, "BP", + ) assert_true(results.length() > 0) } +///| test "topgo_fisher_exact" { let p = @src.topgo_fisher_exact(3, 10, 5, 100) assert_true(p >= 0.0 && p <= 1.0) diff --git a/test/moonbit/tradeseq_test.mbt b/test/moonbit/tradeseq_test.mbt index 985663c7..0ce2abc6 100644 --- a/test/moonbit/tradeseq_test.mbt +++ b/test/moonbit/tradeseq_test.mbt @@ -4,9 +4,9 @@ test "tradeseq_create_trajectory_point" { "cell_001", 0.5, [1.0, 2.0, 3.0], - "control" + "control", ) - + assert_eq(point.cell_id, "cell_001") assert_true((point.pseudotime - 0.5).abs() < 1.0e-10) assert_eq(point.expression.length(), 3) @@ -19,9 +19,9 @@ test "tradeseq_create_gene_expression" { "GeneA", [1.0, 2.0, 3.0, 4.0], [0.1, 0.3, 0.5, 0.7], - ["control", "control", "treatment", "treatment"] + ["control", "control", "treatment", "treatment"], ) - + assert_eq(data.gene_id, "GeneA") assert_eq(data.expression.length(), 4) assert_eq(data.pseudotime.length(), 4) @@ -31,20 +31,15 @@ test "tradeseq_create_gene_expression" { ///| test "tradeseq_trajectory_data" { let mut data = @src.TrajectoryData::new() - + assert_eq(data.n_points, 0) assert_eq(data.n_genes, 0) - + data = data.add_gene("GeneA") assert_eq(data.n_genes, 1) - - let point = @src.TrajectoryPoint::new( - "cell_001", - 0.5, - [1.0], - "control" - ) - + + let point = @src.TrajectoryPoint::new("cell_001", 0.5, [1.0], "control") + data = data.add_point(point) assert_eq(data.n_points, 1) } @@ -55,11 +50,11 @@ test "tradeseq_fit_gam" { "GeneA", [1.0, 2.0, 3.0, 4.0, 5.0, 6.0], [0.0, 0.2, 0.4, 0.6, 0.8, 1.0], - ["control", "control", "control", "treatment", "treatment", "treatment"] + ["control", "control", "control", "treatment", "treatment", "treatment"], ) - + let gam = @src.fit_gam(gene_data, 4) - + assert_eq(gam.gene_id, "GeneA") assert_true(gam.fitted_values.length() > 0) } @@ -70,11 +65,13 @@ test "tradeseq_trade_test" { "GeneA", [1.0, 1.2, 1.5, 2.0, 2.5, 3.0], [0.0, 0.2, 0.4, 0.6, 0.8, 1.0], - ["control", "control", "control", "treatment", "treatment", "treatment"] + ["control", "control", "control", "treatment", "treatment", "treatment"], + ) + + let result = @src.trade_test_condition_effect( + gene_data, 0.5, "control", "treatment", ) - - let result = @src.trade_test_condition_effect(gene_data, 0.5, "control", "treatment") - + assert_eq(result.gene_id, "GeneA") assert_true(result.p_value >= 0.0) // Just check p_value is non-negative @@ -83,18 +80,18 @@ test "tradeseq_trade_test" { ///| test "tradeseq_run_analysis" { let trajectory_data = @src.create_example_trajectory_data() - + assert_true(trajectory_data.n_points > 0) assert_true(trajectory_data.n_genes > 0) - + let result = @src.run_tradeseq_analysis( trajectory_data, trajectory_data.genes, trajectory_data.conditions, 4, - 0.05 + 0.05, ) - + assert_eq(result.n_genes, 3) assert_true(result.n_significant >= 0) assert_true(result.n_significant <= result.n_genes) @@ -103,9 +100,9 @@ test "tradeseq_run_analysis" { ///| test "tradeseq_calculate_smooth" { let trajectory_data = @src.create_example_trajectory_data() - + let smooth = @src.calculate_gene_smooth(trajectory_data, "GeneA", 4, 20) - + assert_eq(smooth.gene_id, "GeneA") assert_eq(smooth.pseudotime.length(), 20) assert_eq(smooth.fitted.length(), 20) @@ -119,11 +116,11 @@ test "tradeseq_summary" { trajectory_data.genes, trajectory_data.conditions, 4, - 0.05 + 0.05, ) - + let summary = @src.tradeseq_summary(result) - + assert_true(summary.contains("tradeSeq Analysis Summary")) assert_true(summary.contains("Total genes tested:")) } @@ -131,7 +128,7 @@ test "tradeseq_summary" { ///| test "tradeseq_create_example" { let data = @src.create_example_trajectory_data() - + assert_true(data.n_points == 50) assert_true(data.n_genes == 3) assert_true(data.conditions.length() >= 2) @@ -143,11 +140,13 @@ test "tradeseq_condition_effect_zero" { "GeneA", [1.0, 1.0, 1.0, 1.0, 1.0, 1.0], [0.0, 0.2, 0.4, 0.6, 0.8, 1.0], - ["control", "control", "control", "treatment", "treatment", "treatment"] + ["control", "control", "control", "treatment", "treatment", "treatment"], + ) + + let result = @src.trade_test_condition_effect( + gene_data, 0.5, "control", "treatment", ) - - let result = @src.trade_test_condition_effect(gene_data, 0.5, "control", "treatment") - + // No difference should give high p-value assert_true(result.p_value > 0.05) } @@ -156,25 +155,19 @@ test "tradeseq_condition_effect_zero" { test "tradeseq_trajectory_empty" { let mut data = @src.TrajectoryData::new() data = data.add_gene("GeneA") - - let result = @src.run_tradeseq_analysis( - data, - ["GeneA"], - ["control"], - 4, - 0.05 - ) - + + let result = @src.run_tradeseq_analysis(data, ["GeneA"], ["control"], 4, 0.05) + assert_eq(result.n_genes, 1) } ///| test "tradeseq_multiple_smooth" { let trajectory_data = @src.create_example_trajectory_data() - + let smooth_a = @src.calculate_gene_smooth(trajectory_data, "GeneA", 4, 15) let smooth_b = @src.calculate_gene_smooth(trajectory_data, "GeneB", 4, 15) - + assert_eq(smooth_a.gene_id, "GeneA") assert_eq(smooth_b.gene_id, "GeneB") assert_eq(smooth_a.fitted.length(), 15) diff --git a/test/moonbit/trie_test.mbt b/test/moonbit/trie_test.mbt index 365aebe8..fbe4a463 100644 --- a/test/moonbit/trie_test.mbt +++ b/test/moonbit/trie_test.mbt @@ -306,7 +306,9 @@ test "triefind_find_words_with_boundaries" { let trie = @src.Trie::new() @src.trie_insert(trie, "EcoRI", "enzyme1") @src.trie_insert(trie, "BamHI", "enzyme2") - let results = @src.triefind_find_words(trie, "Use EcoRI and BamHI for cloning") + let results = @src.triefind_find_words( + trie, "Use EcoRI and BamHI for cloning", + ) assert_eq(results.length(), 2) } diff --git a/test/moonbit/twobit_io_test.mbt b/test/moonbit/twobit_io_test.mbt index 403f8ca3..50e04b6a 100644 --- a/test/moonbit/twobit_io_test.mbt +++ b/test/moonbit/twobit_io_test.mbt @@ -223,7 +223,9 @@ test "twobit_unpack_sequence_simple" { ///| test "twobit_pack_sequence_with_n_blocks" { - let (packed, n_blocks, mask_blocks) = @src.twobit_pack_sequence("ATGCNNNNATGC") + let (packed, n_blocks, mask_blocks) = @src.twobit_pack_sequence( + "ATGCNNNNATGC", + ) assert_eq(packed.length(), 3) // ceil(12/4) = 3 bytes assert_eq(n_blocks.length(), 1) assert_eq(n_blocks[0].start(), 4) @@ -234,7 +236,9 @@ test "twobit_pack_sequence_with_n_blocks" { ///| test "twobit_unpack_sequence_with_n_blocks" { - let (packed, n_blocks, mask_blocks) = @src.twobit_pack_sequence("ATGCNNNNATGC") + let (packed, n_blocks, mask_blocks) = @src.twobit_pack_sequence( + "ATGCNNNNATGC", + ) let result = @src.twobit_unpack_sequence(packed, 12, n_blocks, mask_blocks) assert_eq(result, "ATGCNNNNATGC") } diff --git a/test/moonbit/uniprot_io_test.mbt b/test/moonbit/uniprot_io_test.mbt index 64c57e4f..451d3ef0 100644 --- a/test/moonbit/uniprot_io_test.mbt +++ b/test/moonbit/uniprot_io_test.mbt @@ -95,7 +95,13 @@ test "parse_uniprot_xml_with_dbreferences" { ///| test "uniprot_to_seqrecord" { - let entry = @src.UniprotEntry::new("P12345", "Test Protein", ["GENE1"], "Homo sapiens", "ACGTACGTAC") + let entry = @src.UniprotEntry::new( + "P12345", + "Test Protein", + ["GENE1"], + "Homo sapiens", + "ACGTACGTAC", + ) let (header, id, desc, kwargs) = @src.uniprot_to_seqrecord(entry) assert_true(header.length() > 0) assert_true(id.length() > 0) @@ -104,7 +110,13 @@ test "uniprot_to_seqrecord" { ///| test "uniprot_entry_methods" { - let entry = @src.UniprotEntry::new("P12345", "Test Protein", ["GENE1", "GENE2"], "Homo sapiens", "ACGTACGTAC") + let entry = @src.UniprotEntry::new( + "P12345", + "Test Protein", + ["GENE1", "GENE2"], + "Homo sapiens", + "ACGTACGTAC", + ) assert_eq(entry.accession, "P12345") assert_eq(entry.sequence, "ACGTACGTAC") assert_eq(entry.seq_length, 10) diff --git a/test/moonbit/universalmotif_test.mbt b/test/moonbit/universalmotif_test.mbt index 0f127845..a9667374 100644 --- a/test/moonbit/universalmotif_test.mbt +++ b/test/moonbit/universalmotif_test.mbt @@ -6,9 +6,9 @@ test "universalmotif_motif_from_pwm" { [0.0, 0.0, 0.9, 0.1], [0.1, 0.9, 0.0, 0.0], ] - + let motif = @src.S4Motif::from_pwm("TATA-box", "DNA", pwm) - + assert_eq(motif.name, "TATA-box") assert_eq(motif.alphabet, "DNA") assert_eq(motif.pwm.length(), 4) @@ -16,21 +16,17 @@ test "universalmotif_motif_from_pwm" { ///| test "universalmotif_calculate_consensus" { - let pwm = [ - [0.9, 0.1, 0.0, 0.0], - [0.0, 0.0, 0.9, 0.1], - [0.1, 0.9, 0.0, 0.0], - ] - + let pwm = [[0.9, 0.1, 0.0, 0.0], [0.0, 0.0, 0.9, 0.1], [0.1, 0.9, 0.0, 0.0]] + let motif = @src.S4Motif::from_pwm("test", "DNA", pwm) - + assert_eq(motif.consensus.length(), 3) } ///| test "universalmotif_create_example_motif" { let motif = @src.create_example_s4motif() - + assert_eq(motif.name, "TATA-box") assert_eq(motif.pwm.length(), 5) -} \ No newline at end of file +} diff --git a/test/moonbit/uwot_test.mbt b/test/moonbit/uwot_test.mbt index 61a2f432..61700c74 100644 --- a/test/moonbit/uwot_test.mbt +++ b/test/moonbit/uwot_test.mbt @@ -6,10 +6,7 @@ // ============================================================ test "uwot_distance_matrix square" { - let data : Array[Array[Double]] = [ - [0.0, 0.0], - [3.0, 4.0], - ] + let data : Array[Array[Double]] = [[0.0, 0.0], [3.0, 4.0]] let dist = @src.uwot_distance_matrix(data) assert_eq(dist.length(), 2) assert_eq(dist[0].length(), 2) @@ -20,6 +17,7 @@ test "uwot_distance_matrix square" { assert_eq(dist[1][0], 5.0) } +///| test "uwot_distance_matrix empty" { let data : Array[Array[Double]] = [] let dist = @src.uwot_distance_matrix(data) @@ -30,6 +28,7 @@ test "uwot_distance_matrix empty" { // UMAP config tests // ============================================================ +///| test "umap_config default" { let config = @src.UmapConfig::new() assert_eq(config.n_neighbors, 15) @@ -44,19 +43,21 @@ test "umap_config default" { // UMAP algorithm tests // ============================================================ +///| test "umap basic 2d" { let data = @src.create_umap_test_data(10, 5) assert_eq(data.length(), 10) assert_eq(data[0].length(), 5) - + let config = @src.UmapConfig::new() - + let result = @src.uwot_umap(data, config) assert_eq(result.embedding.length(), 10) assert_eq(result.embedding[0].length(), 2) assert_eq(result.n_epochs, 200) } +///| test "umap empty data" { let data : Array[Array[Double]] = [] let config = @src.UmapConfig::new() @@ -64,6 +65,7 @@ test "umap empty data" { assert_eq(result.embedding.length(), 0) } +///| test "umap single sample" { let data : Array[Array[Double]] = [[1.0, 2.0, 3.0]] let config = @src.UmapConfig::new() @@ -71,28 +73,30 @@ test "umap single sample" { assert_true(result.embedding.length() <= 1) } +///| test "umap different n_components" { let data = @src.create_umap_test_data(10, 5) let custom_config = @src.UmapConfig::new_custom(3, 3, 50, 42) - + let result = @src.uwot_umap(data, custom_config) assert_eq(result.embedding[0].length(), 3) } +///| test "umap produces finite values" { let data = @src.create_umap_test_data(12, 4) let custom_config = @src.UmapConfig::new_custom(3, 2, 50, 42) - + let result = @src.uwot_umap(data, custom_config) - + // Check that all embedding values are finite let mut i = 0 while i < result.embedding.length() { let mut j = 0 while j < result.embedding[i].length() { let val = result.embedding[i][j] - assert_true(val == val) // NaN check - assert_true(val < 1.0e300) // infinity check + assert_true(val == val) // NaN check + assert_true(val < 1.0e300) // infinity check assert_true(val > -1.0e300) j = j + 1 } @@ -104,12 +108,14 @@ test "umap produces finite values" { // Test data generation tests // ============================================================ +///| test "create_umap_test_data dimensions" { let data = @src.create_umap_test_data(20, 8) assert_eq(data.length(), 20) assert_eq(data[0].length(), 8) } +///| test "create_umap_test_data clusters" { let data = @src.create_umap_test_data(8, 3) // 4 clusters, each should have similar values @@ -117,7 +123,7 @@ test "create_umap_test_data clusters" { // Cluster 1: samples 1, 5 // Cluster 2: samples 2, 6 // Cluster 3: samples 3, 7 - + // Check that cluster 0 is different from cluster 3 let mut sum0 = 0.0 let mut j = 0 @@ -125,14 +131,14 @@ test "create_umap_test_data clusters" { sum0 = sum0 + data[0][j] j = j + 1 } - + let mut sum3 = 0.0 j = 0 while j < 3 { sum3 = sum3 + data[3][j] j = j + 1 } - + // Clusters should be separated assert_true(sum3 > sum0) } diff --git a/test/moonbit/variant_filtering_test.mbt b/test/moonbit/variant_filtering_test.mbt index 2b0e86ec..9f10d71d 100644 --- a/test/moonbit/variant_filtering_test.mbt +++ b/test/moonbit/variant_filtering_test.mbt @@ -1,13 +1,12 @@ ///| - test "variant_filtering_create_variant" { let info = Map([("DP", "20"), ("AF", "0.5")]) let genotypes = [("sample1", "0/1:30"), ("sample2", "1/1:25")] - + let variant = @src.Variant::new( - "chr1", 1000, "rs123", "A", "T", 50.0, "PASS", info, genotypes + "chr1", 1000, "rs123", "A", "T", 50.0, "PASS", info, genotypes, ) - + assert_eq(variant.chr, "chr1") assert_eq(variant.pos, 1000) assert_eq(variant.id, "rs123") @@ -18,23 +17,31 @@ test "variant_filtering_create_variant" { assert_eq(variant.genotypes.length(), 2) } +///| test "variant_filtering_filter" { let info_pass = Map([("DP", "20"), ("AF", "0.5")]) let info_fail = Map([("DP", "5"), ("AF", "0.001")]) - + let variants = [ - @src.Variant::new("chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info_pass, [("s1", "0/1:30")]), - @src.Variant::new("chr1", 2000, "rs2", "G", "C", 20.0, "FAIL", info_fail, [("s1", "0/1:10")]), - @src.Variant::new("chr1", 3000, "rs3", "T", "A", 60.0, "PASS", info_pass, [("s1", "0/1:35")]), + @src.Variant::new("chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info_pass, [ + ("s1", "0/1:30"), + ]), + @src.Variant::new("chr1", 2000, "rs2", "G", "C", 20.0, "FAIL", info_fail, [ + ("s1", "0/1:10"), + ]), + @src.Variant::new("chr1", 3000, "rs3", "T", "A", 60.0, "PASS", info_pass, [ + ("s1", "0/1:35"), + ]), ] - + let params = @src.VariantFilteringParam::new() let result = @src.bio_vfilter_filter(variants, params) - + assert_eq(result.passed_variants.length(), 2) assert_eq(result.filtered_variants.length(), 1) } +///| test "variant_filtering_check_autosomal_dominant" { let genotypes = [ ("proband", "1/1"), @@ -42,18 +49,26 @@ test "variant_filtering_check_autosomal_dominant" { ("mother", "0/0"), ("sibling", "0/0"), ] - + let info = Map([], capacity=0) - let variant = @src.Variant::new("chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info, genotypes) - - let phenotypes = Map([("proband", true), ("father", false), ("mother", false), ("sibling", false)]) + let variant = @src.Variant::new( + "chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info, genotypes, + ) + + let phenotypes = Map([ + ("proband", true), + ("father", false), + ("mother", false), + ("sibling", false), + ]) let model = @src.GeneticModel::new("autosomal_dominant") - + let passes = @src.bio_vfilter_check_inheritance(variant, model, phenotypes) - + assert_true(passes) } +///| test "variant_filtering_check_autosomal_recessive" { let genotypes = [ ("proband", "1/1"), @@ -61,46 +76,65 @@ test "variant_filtering_check_autosomal_recessive" { ("mother", "0/1"), ("sibling", "0/0"), ] - + let info = Map([], capacity=0) - let variant = @src.Variant::new("chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info, genotypes) - - let phenotypes = Map([("proband", true), ("father", false), ("mother", false), ("sibling", false)]) + let variant = @src.Variant::new( + "chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info, genotypes, + ) + + let phenotypes = Map([ + ("proband", true), + ("father", false), + ("mother", false), + ("sibling", false), + ]) let model = @src.GeneticModel::new("autosomal_recessive") - + let passes = @src.bio_vfilter_check_inheritance(variant, model, phenotypes) - + assert_true(passes) } +///| test "variant_filtering_summary" { let info_pass = Map([("DP", "20"), ("AF", "0.5")]) let info_fail = Map([("DP", "5"), ("AF", "0.001")]) - + let variants = [ - @src.Variant::new("chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info_pass, [("s1", "0/1:30")]), - @src.Variant::new("chr1", 2000, "rs2", "G", "C", 20.0, "FAIL", info_fail, [("s1", "0/1:10")]), + @src.Variant::new("chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info_pass, [ + ("s1", "0/1:30"), + ]), + @src.Variant::new("chr1", 2000, "rs2", "G", "C", 20.0, "FAIL", info_fail, [ + ("s1", "0/1:10"), + ]), ] - + let params = @src.VariantFilteringParam::new() let result = @src.bio_vfilter_filter(variants, params) - + let summary = @src.bio_vfilter_summary(result) - + assert_true(summary.contains("Total variants")) assert_true(summary.contains("Passed")) assert_true(summary.contains("Filtered")) } +///| test "variant_filtering_predict_consequence" { let info = Map([], capacity=0) let genotypes = [("s1", "0/1")] - - let snp = @src.Variant::new("chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info, genotypes) - let insertion = @src.Variant::new("chr1", 2000, "rs2", "A", "AT", 50.0, "PASS", info, genotypes) - let deletion = @src.Variant::new("chr1", 3000, "rs3", "AT", "A", 50.0, "PASS", info, genotypes) - + + let snp = @src.Variant::new( + "chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info, genotypes, + ) + let insertion = @src.Variant::new( + "chr1", 2000, "rs2", "A", "AT", 50.0, "PASS", info, genotypes, + ) + let deletion = @src.Variant::new( + "chr1", 3000, "rs3", "AT", "A", 50.0, "PASS", info, genotypes, + ) + assert_eq(@src.bio_vfilter_predict_consequence(snp), "missense_variant") assert_eq(@src.bio_vfilter_predict_consequence(insertion), "insertion") assert_eq(@src.bio_vfilter_predict_consequence(deletion), "deletion") -} \ No newline at end of file +} diff --git a/test/moonbit/variation_test.mbt b/test/moonbit/variation_test.mbt index becf30ee..231203f1 100644 --- a/test/moonbit/variation_test.mbt +++ b/test/moonbit/variation_test.mbt @@ -37,4 +37,4 @@ test "variation_parse_vcf_line" { test "variation_create_example_data" { let records = @src.create_example_variation_data() assert_eq(records.length(), 2) -} \ No newline at end of file +} diff --git a/test/moonbit/velociraptor_test.mbt b/test/moonbit/velociraptor_test.mbt index aa86f0d3..77fd7586 100644 --- a/test/moonbit/velociraptor_test.mbt +++ b/test/moonbit/velociraptor_test.mbt @@ -108,7 +108,12 @@ test "vr_kinetic_model_returns_params" { test "vr_kinetic_model_sample_data" { let gene_data = @src.velocity_sample_data() for gd in gene_data { - let k = @src.velocity_kinetic_model(gd.gene_name(), gd.spliced(), gd.unspliced(), 30) + let k = @src.velocity_kinetic_model( + gd.gene_name(), + gd.spliced(), + gd.unspliced(), + 30, + ) assert_true(k.beta() > 0.0) assert_true(k.gamma() > 0.0) } @@ -132,7 +137,12 @@ test "vr_compute_returns_velocities" { let gene_data = @src.velocity_sample_data() let kinetics : Array[@src.GeneKinetics] = [] for gd in gene_data { - let k = @src.velocity_kinetic_model(gd.gene_name(), gd.spliced(), gd.unspliced(), 30) + let k = @src.velocity_kinetic_model( + gd.gene_name(), + gd.spliced(), + gd.unspliced(), + 30, + ) kinetics.push(k) } let velocities = @src.velocity_compute(gene_data, kinetics) @@ -162,7 +172,12 @@ test "vr_velocity_embedding" { let gene_data = @src.velocity_sample_data() let kinetics : Array[@src.GeneKinetics] = [] for gd in gene_data { - let k = @src.velocity_kinetic_model(gd.gene_name(), gd.spliced(), gd.unspliced(), 30) + let k = @src.velocity_kinetic_model( + gd.gene_name(), + gd.spliced(), + gd.unspliced(), + 30, + ) kinetics.push(k) } let velocities = @src.velocity_compute(gene_data, kinetics) @@ -191,7 +206,12 @@ test "vr_find_root_cells" { let gene_data = @src.velocity_sample_data() let kinetics : Array[@src.GeneKinetics] = [] for gd in gene_data { - let k = @src.velocity_kinetic_model(gd.gene_name(), gd.spliced(), gd.unspliced(), 30) + let k = @src.velocity_kinetic_model( + gd.gene_name(), + gd.spliced(), + gd.unspliced(), + 30, + ) kinetics.push(k) } let velocities = @src.velocity_compute(gene_data, kinetics) @@ -209,14 +229,21 @@ test "vr_root_cells_sorted_by_speed" { let gene_data = @src.velocity_sample_data() let kinetics : Array[@src.GeneKinetics] = [] for gd in gene_data { - let k = @src.velocity_kinetic_model(gd.gene_name(), gd.spliced(), gd.unspliced(), 30) + let k = @src.velocity_kinetic_model( + gd.gene_name(), + gd.spliced(), + gd.unspliced(), + 30, + ) kinetics.push(k) } let velocities = @src.velocity_compute(gene_data, kinetics) let roots = @src.velocity_find_root_cells(velocities, 5) // Speeds should be sorted descending. for i in 1..= velocities[roots[i]].speed()) + assert_true( + velocities[roots[i - 1]].speed() >= velocities[roots[i]].speed(), + ) } } @@ -229,7 +256,12 @@ test "vr_transition_matrix" { let gene_data = @src.velocity_sample_data() let kinetics : Array[@src.GeneKinetics] = [] for gd in gene_data { - let k = @src.velocity_kinetic_model(gd.gene_name(), gd.spliced(), gd.unspliced(), 30) + let k = @src.velocity_kinetic_model( + gd.gene_name(), + gd.spliced(), + gd.unspliced(), + 30, + ) kinetics.push(k) } let velocities = @src.velocity_compute(gene_data, kinetics) @@ -255,7 +287,12 @@ test "vr_transition_matrix_nonneg" { let gene_data = @src.velocity_sample_data() let kinetics : Array[@src.GeneKinetics] = [] for gd in gene_data { - let k = @src.velocity_kinetic_model(gd.gene_name(), gd.spliced(), gd.unspliced(), 30) + let k = @src.velocity_kinetic_model( + gd.gene_name(), + gd.spliced(), + gd.unspliced(), + 30, + ) kinetics.push(k) } let velocities = @src.velocity_compute(gene_data, kinetics) @@ -276,7 +313,9 @@ test "vr_transition_matrix_nonneg" { test "vr_run_pipeline" { let gene_data = @src.velocity_sample_data() let embeddings = @src.velocity_sample_embeddings(20) - let (kinetics, velocities, emb_vel) = @src.velocity_run(gene_data, embeddings, 5) + let (kinetics, velocities, emb_vel) = @src.velocity_run( + gene_data, embeddings, 5, + ) assert_eq(kinetics.length(), 4) // 4 genes assert_eq(velocities.length(), 20) // 20 cells assert_eq(emb_vel.length(), 20) diff --git a/test/moonbit/venn_diagram_test.mbt b/test/moonbit/venn_diagram_test.mbt index 0e557441..79acce5f 100644 --- a/test/moonbit/venn_diagram_test.mbt +++ b/test/moonbit/venn_diagram_test.mbt @@ -3,10 +3,9 @@ // 1. venn_diagram - basic Venn diagram with 2 sets test "venn_diagram_two_sets_basic" { - let result = @src.venn_diagram( - [["A", "B", "C", "D"], ["C", "D", "E", "F"]], - names=["Set1", "Set2"], - ) + let result = @src.venn_diagram([["A", "B", "C", "D"], ["C", "D", "E", "F"]], names=[ + "Set1", "Set2", + ]) assert_eq(result.n_sets, 2) assert_eq(result.set_names, ["Set1", "Set2"]) assert_eq(result.set_sizes, [4, 4]) @@ -15,6 +14,7 @@ test "venn_diagram_two_sets_basic" { assert_eq(result.regions.length(), 4) // 2^2 = 4 regions } +///| test "venn_diagram_two_sets_default_names" { let result = @src.venn_diagram([["A", "B"], ["B", "C"]]) assert_eq(result.set_names, ["Set1", "Set2"]) @@ -23,6 +23,8 @@ test "venn_diagram_two_sets_default_names" { } // 2. venn_diagram - basic Venn diagram with 3 sets + +///| test "venn_diagram_three_sets_basic" { let result = @src.venn_diagram( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -35,11 +37,11 @@ test "venn_diagram_three_sets_basic" { assert_eq(result.regions.length(), 8) // 2^3 = 8 regions } +///| test "venn_diagram_three_sets_no_overlap" { - let result = @src.venn_diagram( - [["A", "B"], ["C", "D"], ["E", "F"]], - names=["S1", "S2", "S3"], - ) + let result = @src.venn_diagram([["A", "B"], ["C", "D"], ["E", "F"]], names=[ + "S1", "S2", "S3", + ]) assert_eq(result.total_elements, 6) assert_eq(result.regions[1].count, 2) // only in S1 (0b001) assert_eq(result.regions[2].count, 2) // only in S2 (0b010) @@ -48,47 +50,47 @@ test "venn_diagram_three_sets_no_overlap" { } // 3. venn_get_region - get elements in specific region by bitmask + +///| test "venn_get_region_only_in_first_set" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["C", "D", "E"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["C", "D", "E"]], names=[ + "S1", "S2", + ]) let only_s1 = @src.venn_get_region(result, 1) // 0b01 assert_eq(only_s1.length(), 2) // A, B assert_true(only_s1.contains("A")) assert_true(only_s1.contains("B")) } +///| test "venn_get_region_only_in_second_set" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["C", "D", "E"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["C", "D", "E"]], names=[ + "S1", "S2", + ]) let only_s2 = @src.venn_get_region(result, 2) // 0b10 assert_eq(only_s2.length(), 2) // D, E assert_true(only_s2.contains("D")) assert_true(only_s2.contains("E")) } +///| test "venn_get_region_intersection_two_sets" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["C", "D", "E"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["C", "D", "E"]], names=[ + "S1", "S2", + ]) let inter = @src.venn_get_region(result, 3) // 0b11 assert_eq(inter.length(), 1) // C assert_true(inter.contains("C")) } +///| test "venn_get_region_outside_all" { - let result = @src.venn_diagram( - [["A", "B"], ["C", "D"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B"], ["C", "D"]], names=["S1", "S2"]) let outside = @src.venn_get_region(result, 0) assert_eq(outside.length(), 0) } +///| test "venn_get_region_invalid_id" { let result = @src.venn_diagram([["A"], ["B"]], names=["S1", "S2"]) let invalid = @src.venn_get_region(result, 10) @@ -96,28 +98,30 @@ test "venn_get_region_invalid_id" { } // 4. venn_only_in_set - elements only in one set + +///| test "venn_only_in_set_first" { - let result = @src.venn_diagram( - [["A", "B", "C", "D"], ["C", "D", "E", "F"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C", "D"], ["C", "D", "E", "F"]], names=[ + "S1", "S2", + ]) let only_first = @src.venn_only_in_set(result, 0) assert_eq(only_first.length(), 2) // A, B assert_true(only_first.contains("A")) assert_true(only_first.contains("B")) } +///| test "venn_only_in_set_second" { - let result = @src.venn_diagram( - [["A", "B", "C", "D"], ["C", "D", "E", "F"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C", "D"], ["C", "D", "E", "F"]], names=[ + "S1", "S2", + ]) let only_second = @src.venn_only_in_set(result, 1) assert_eq(only_second.length(), 2) // E, F assert_true(only_second.contains("E")) assert_true(only_second.contains("F")) } +///| test "venn_only_in_set_three_sets" { let result = @src.venn_diagram( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -132,6 +136,8 @@ test "venn_only_in_set_three_sets" { } // 5. venn_intersection_only - elements in specific sets only + +///| test "venn_intersection_only_two_sets" { let result = @src.venn_diagram( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -142,6 +148,7 @@ test "venn_intersection_only_two_sets" { assert_true(s1_s2_only.contains("B")) } +///| test "venn_intersection_only_all_three" { let result = @src.venn_diagram( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -152,27 +159,29 @@ test "venn_intersection_only_all_three" { assert_true(all_three.contains("C")) } +///| test "venn_intersection_only_single_set" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["B", "C", "D"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["B", "C", "D"]], names=[ + "S1", "S2", + ]) let just_first = @src.venn_intersection_only(result, [0]) assert_eq(just_first.length(), 1) // A } // 6. venn_all_intersect - elements common to all sets + +///| test "venn_all_intersect_two_sets" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["B", "C", "D"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["B", "C", "D"]], names=[ + "S1", "S2", + ]) let all = @src.venn_all_intersect(result) assert_eq(all.length(), 2) // B, C assert_true(all.contains("B")) assert_true(all.contains("C")) } +///| test "venn_all_intersect_three_sets" { let result = @src.venn_diagram( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -183,21 +192,22 @@ test "venn_all_intersect_three_sets" { assert_true(all.contains("C")) } +///| test "venn_all_intersect_no_common" { - let result = @src.venn_diagram( - [["A", "B"], ["C", "D"], ["E", "F"]], - names=["S1", "S2", "S3"], - ) + let result = @src.venn_diagram([["A", "B"], ["C", "D"], ["E", "F"]], names=[ + "S1", "S2", "S3", + ]) let all = @src.venn_all_intersect(result) assert_eq(all.length(), 0) } // 7. venn_unique_to_each - unique elements per set + +///| test "venn_unique_to_each_two_sets" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["C", "D", "E"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["C", "D", "E"]], names=[ + "S1", "S2", + ]) let unique = @src.venn_unique_to_each(result) assert_eq(unique.length(), 2) assert_eq(unique[0].length(), 2) // A, B @@ -208,6 +218,7 @@ test "venn_unique_to_each_two_sets" { assert_true(unique[1].contains("E")) } +///| test "venn_unique_to_each_three_sets" { let result = @src.venn_diagram( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -221,11 +232,12 @@ test "venn_unique_to_each_three_sets" { } // 8. venn_pairwise_overlap - pairwise overlap statistics + +///| test "venn_pairwise_overlap_two_sets" { - let result = @src.venn_diagram( - [["A", "B", "C", "D"], ["C", "D", "E", "F"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C", "D"], ["C", "D", "E", "F"]], names=[ + "S1", "S2", + ]) let stats = @src.venn_pairwise_overlap(result, 0, 1) assert_eq(stats["intersection_count"], 2.0) // C, D assert_eq(stats["union_count"], 6.0) // A,B,C,D,E,F @@ -234,6 +246,7 @@ test "venn_pairwise_overlap_two_sets" { assert_eq(stats["set_j_size"], 4.0) } +///| test "venn_pairwise_overlap_three_sets" { let result = @src.venn_diagram( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -249,11 +262,11 @@ test "venn_pairwise_overlap_three_sets" { assert_eq(s23["intersection_count"], 2.0) // C, D } +///| test "venn_pairwise_overlap_identical_sets" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["A", "B", "C"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["A", "B", "C"]], names=[ + "S1", "S2", + ]) let stats = @src.venn_pairwise_overlap(result, 0, 1) assert_eq(stats["intersection_count"], 3.0) assert_eq(stats["union_count"], 3.0) @@ -262,11 +275,9 @@ test "venn_pairwise_overlap_identical_sets" { assert_eq(stats["dice_coefficient"], 1.0) } +///| test "venn_pairwise_overlap_disjoint" { - let result = @src.venn_diagram( - [["A", "B"], ["C", "D"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B"], ["C", "D"]], names=["S1", "S2"]) let stats = @src.venn_pairwise_overlap(result, 0, 1) assert_eq(stats["intersection_count"], 0.0) assert_eq(stats["jaccard_index"], 0.0) @@ -276,6 +287,8 @@ test "venn_pairwise_overlap_disjoint" { // 9. Set operations: venn_intersection, venn_union (venn_union_two), // venn_difference, venn_symmetric_difference + +///| test "venn_intersection_basic" { let a = ["A", "B", "C", "D"] let b = ["C", "D", "E", "F"] @@ -285,6 +298,7 @@ test "venn_intersection_basic" { assert_true(inter.contains("D")) } +///| test "venn_intersection_empty" { let a = ["A", "B"] let b = ["C", "D"] @@ -292,6 +306,7 @@ test "venn_intersection_empty" { assert_eq(inter.length(), 0) } +///| test "venn_union_two_basic" { let a = ["A", "B", "C"] let b = ["C", "D", "E"] @@ -304,6 +319,7 @@ test "venn_union_two_basic" { assert_true(uni.contains("E")) } +///| test "venn_union_two_disjoint" { let a = ["A", "B"] let b = ["C", "D"] @@ -311,6 +327,7 @@ test "venn_union_two_disjoint" { assert_eq(uni.length(), 4) } +///| test "venn_difference_basic" { let a = ["A", "B", "C", "D"] let b = ["C", "D", "E", "F"] @@ -320,6 +337,7 @@ test "venn_difference_basic" { assert_true(diff.contains("B")) } +///| test "venn_difference_no_difference" { let a = ["A", "B"] let b = ["A", "B", "C"] @@ -327,6 +345,7 @@ test "venn_difference_no_difference" { assert_eq(diff.length(), 0) } +///| test "venn_difference_full_difference" { let a = ["A", "B"] let b = ["C", "D"] @@ -336,6 +355,7 @@ test "venn_difference_full_difference" { assert_true(diff.contains("B")) } +///| test "venn_symmetric_difference_basic" { let a = ["A", "B", "C", "D"] let b = ["C", "D", "E", "F"] @@ -347,6 +367,7 @@ test "venn_symmetric_difference_basic" { assert_true(symdiff.contains("F")) } +///| test "venn_symmetric_difference_identical" { let a = ["A", "B", "C"] let b = ["A", "B", "C"] @@ -354,6 +375,7 @@ test "venn_symmetric_difference_identical" { assert_eq(symdiff.length(), 0) } +///| test "venn_symmetric_difference_disjoint" { let a = ["A", "B"] let b = ["C", "D"] @@ -362,6 +384,8 @@ test "venn_symmetric_difference_disjoint" { } // 10. venn_jaccard, venn_dice, venn_overlap_coefficient + +///| test "venn_jaccard_basic" { let a = ["A", "B", "C", "D"] let b = ["C", "D", "E", "F"] @@ -369,6 +393,7 @@ test "venn_jaccard_basic" { assert_eq(j, 2.0 / 6.0) } +///| test "venn_jaccard_identical" { let a = ["A", "B", "C"] let b = ["A", "B", "C"] @@ -376,6 +401,7 @@ test "venn_jaccard_identical" { assert_eq(j, 1.0) } +///| test "venn_jaccard_disjoint" { let a = ["A", "B"] let b = ["C", "D"] @@ -383,6 +409,7 @@ test "venn_jaccard_disjoint" { assert_eq(j, 0.0) } +///| test "venn_jaccard_empty" { let a : Array[String] = [] let b : Array[String] = [] @@ -390,13 +417,15 @@ test "venn_jaccard_empty" { assert_eq(j, 0.0) } +///| test "venn_dice_basic" { let a = ["A", "B", "C", "D"] let b = ["C", "D", "E", "F"] let d = @src.venn_dice(a, b) - assert_eq(d, (2.0 * 2.0) / 8.0) + assert_eq(d, 2.0 * 2.0 / 8.0) } +///| test "venn_dice_identical" { let a = ["A", "B", "C"] let b = ["A", "B", "C"] @@ -404,6 +433,7 @@ test "venn_dice_identical" { assert_eq(d, 1.0) } +///| test "venn_dice_disjoint" { let a = ["A", "B"] let b = ["C", "D"] @@ -411,6 +441,7 @@ test "venn_dice_disjoint" { assert_eq(d, 0.0) } +///| test "venn_dice_empty" { let a : Array[String] = [] let b : Array[String] = [] @@ -418,6 +449,7 @@ test "venn_dice_empty" { assert_eq(d, 0.0) } +///| test "venn_overlap_coefficient_basic" { let a = ["A", "B", "C", "D"] let b = ["C", "D", "E", "F"] @@ -425,6 +457,7 @@ test "venn_overlap_coefficient_basic" { assert_eq(oc, 2.0 / 4.0) // min(4,4)=4, inter=2 } +///| test "venn_overlap_coefficient_identical" { let a = ["A", "B", "C"] let b = ["A", "B", "C"] @@ -432,6 +465,7 @@ test "venn_overlap_coefficient_identical" { assert_eq(oc, 1.0) } +///| test "venn_overlap_coefficient_disjoint" { let a = ["A", "B"] let b = ["C", "D"] @@ -439,6 +473,7 @@ test "venn_overlap_coefficient_disjoint" { assert_eq(oc, 0.0) } +///| test "venn_overlap_coefficient_empty" { let a : Array[String] = [] let b = ["A", "B"] @@ -447,6 +482,8 @@ test "venn_overlap_coefficient_empty" { } // 11. venn_counts_only - count-only mode + +///| test "venn_counts_only_two_sets" { let counts = @src.venn_counts_only( [["A", "B", "C", "D"], ["C", "D", "E", "F"]], @@ -459,6 +496,7 @@ test "venn_counts_only_two_sets" { assert_eq(counts[0], 0) // outside } +///| test "venn_counts_only_three_sets" { let counts = @src.venn_counts_only( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -471,11 +509,11 @@ test "venn_counts_only_three_sets" { assert_eq(counts[2], 0) // only S2 } +///| test "venn_counts_only_no_overlap" { - let counts = @src.venn_counts_only( - [["A", "B"], ["C", "D"], ["E", "F"]], - names=["S1", "S2", "S3"], - ) + let counts = @src.venn_counts_only([["A", "B"], ["C", "D"], ["E", "F"]], names=[ + "S1", "S2", "S3", + ]) assert_eq(counts[1], 2) assert_eq(counts[2], 2) assert_eq(counts[4], 2) @@ -483,11 +521,12 @@ test "venn_counts_only_no_overlap" { } // 12. venn_summary - summary formatting + +///| test "venn_summary_basic" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["B", "C", "D"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["B", "C", "D"]], names=[ + "S1", "S2", + ]) let summary = @src.venn_summary(result) assert_true(summary.contains("Venn Diagram Summary")) assert_true(summary.contains("Number of sets: 2")) @@ -497,6 +536,7 @@ test "venn_summary_basic" { assert_true(summary.contains("Jaccard")) } +///| test "venn_summary_three_sets" { let result = @src.venn_diagram( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -509,6 +549,8 @@ test "venn_summary_three_sets" { } // 13. venn_sample_result - sample data generation + +///| test "venn_sample_result_basic" { let result = @src.venn_sample_result() assert_eq(result.n_sets, 3) @@ -517,6 +559,7 @@ test "venn_sample_result_basic" { assert_eq(result.set_names, ["Tumor Suppressors", "DNA Repair", "PI3K/MTOR"]) } +///| test "venn_sample_gene_sets_basic" { let sets = @src.venn_sample_gene_sets() assert_eq(sets.length(), 3) @@ -528,6 +571,7 @@ test "venn_sample_gene_sets_basic" { assert_true(sets[2].contains("MTOR")) } +///| test "venn_sample_gene_names_basic" { let names = @src.venn_sample_gene_names() assert_eq(names.length(), 3) @@ -537,6 +581,8 @@ test "venn_sample_gene_names_basic" { } // 14. venn_two_sets - two-set convenience function + +///| test "venn_two_sets_basic" { let result = @src.venn_two_sets(["A", "B", "C"], ["C", "D", "E"]) assert_eq(result.n_sets, 2) @@ -544,6 +590,7 @@ test "venn_two_sets_basic" { assert_eq(result.total_elements, 5) } +///| test "venn_two_sets_custom_names" { let result = @src.venn_two_sets( ["A", "B", "C"], @@ -555,21 +602,20 @@ test "venn_two_sets_custom_names" { assert_eq(result.n_sets, 2) } +///| test "venn_two_sets_intersection" { - let result = @src.venn_two_sets( - ["A", "B", "C", "D"], - ["C", "D", "E", "F"], - ) + let result = @src.venn_two_sets(["A", "B", "C", "D"], ["C", "D", "E", "F"]) let inter = @src.venn_all_intersect(result) assert_eq(inter.length(), 2) // C, D } // 15. venn_union (from result) - get universe + +///| test "venn_union_result_basic" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["C", "D", "E"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["C", "D", "E"]], names=[ + "S1", "S2", + ]) let uni = @src.venn_union(result) assert_eq(uni.length(), 5) assert_true(uni.contains("A")) @@ -580,6 +626,8 @@ test "venn_union_result_basic" { } // 16. Edge cases and integration tests + +///| test "venn_diagram_single_set" { let result = @src.venn_diagram([["A", "B", "C"]], names=["Only"]) assert_eq(result.n_sets, 1) @@ -589,50 +637,48 @@ test "venn_diagram_single_set" { assert_eq(result.regions[0].count, 0) } +///| test "venn_diagram_empty_sets" { let empty : Array[String] = [] - let result = @src.venn_diagram( - [empty, ["A", "B"]], - names=["Empty", "NonEmpty"], - ) + let result = @src.venn_diagram([empty, ["A", "B"]], names=[ + "Empty", "NonEmpty", + ]) assert_eq(result.n_sets, 2) assert_eq(result.set_sizes, [0, 2]) assert_eq(result.total_elements, 2) } +///| test "venn_diagram_duplicate_elements" { - let result = @src.venn_diagram( - [["A", "A", "B"], ["B", "C", "C"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "A", "B"], ["B", "C", "C"]], names=[ + "S1", "S2", + ]) assert_eq(result.total_elements, 3) // A, B, C - duplicates removed in universe } +///| test "venn_region_descriptions" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["C", "D", "E"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["C", "D", "E"]], names=[ + "S1", "S2", + ]) assert_eq(result.regions[1].description, "Only in S1") assert_eq(result.regions[2].description, "Only in S2") assert_eq(result.regions[3].description, "In S1 & S2") assert_eq(result.regions[0].description, "Outside all sets") } +///| test "venn_euler_layout_basic" { - let result = @src.venn_diagram( - [["A", "B"], ["B", "C"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B"], ["B", "C"]], names=["S1", "S2"]) let layout = @src.venn_euler_layout(result) assert_true(layout.length() > 0) } +///| test "venn_pairwise_overlap_set_sizes" { - let result = @src.venn_diagram( - [["A", "B", "C", "D", "E"], ["C", "D"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C", "D", "E"], ["C", "D"]], names=[ + "S1", "S2", + ]) let stats = @src.venn_pairwise_overlap(result, 0, 1) assert_eq(stats["set_i_size"], 5.0) assert_eq(stats["set_j_size"], 2.0) @@ -640,6 +686,7 @@ test "venn_pairwise_overlap_set_sizes" { assert_eq(stats["overlap_coefficient"], 2.0 / 2.0) // min(5,2)=2 } +///| test "venn_diagram_five_sets" { let result = @src.venn_diagram( [["A", "B"], ["B", "C"], ["C", "D"], ["D", "E"], ["E", "A"]], @@ -650,6 +697,7 @@ test "venn_diagram_five_sets" { assert_true(result.total_elements > 0) } +///| test "venn_all_intersect_sample_result" { let result = @src.venn_sample_result() let all = @src.venn_all_intersect(result) @@ -658,6 +706,7 @@ test "venn_all_intersect_sample_result" { assert_eq(all.length(), all2.length()) } +///| test "venn_unique_to_each_sample_result" { let result = @src.venn_sample_result() let unique = @src.venn_unique_to_each(result) @@ -665,15 +714,16 @@ test "venn_unique_to_each_sample_result" { assert_true(unique[0].length() > 0) } +///| test "venn_counts_only_matches_diagram" { let sets = [["A", "B", "C", "D"], ["C", "D", "E", "F"]] let names = ["S1", "S2"] - let result = @src.venn_diagram(sets, names=names) - let counts = @src.venn_counts_only(sets, names=names) + let result = @src.venn_diagram(sets, names~) + let counts = @src.venn_counts_only(sets, names~) assert_eq(counts.length(), result.regions.length()) let mut i = 0 while i < counts.length() { assert_eq(counts[i], result.regions[i].count) i = i + 1 } -} \ No newline at end of file +} diff --git a/test/moonbit/voyager_test.mbt b/test/moonbit/voyager_test.mbt new file mode 100644 index 00000000..9031da05 --- /dev/null +++ b/test/moonbit/voyager_test.mbt @@ -0,0 +1,1130 @@ +// Tests for the Bioconductor Voyager-inspired spatial autocorrelation module. + +///| +fn voy_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "Voyager value " + + actual.to_string() + + " differs from " + + expected.to_string() + + " (tolerance " + + tolerance.to_string() + + ")", + ) + } +} + +///| +fn voy_test_grid_coords() -> Array[Array[Double]] { + // 3x3 grid of spots, coordinates [x, y]. + let coords : Array[Array[Double]] = [] + for row in 0..<3 { + for col in 0..<3 { + coords.push([col.to_double(), row.to_double()]) + } + } + coords +} + +///| +fn voy_test_chain_weights() -> @src.VoyagerWeights { + // 4 spots in a chain 0-1-2-3 with binary (style B) symmetric weights. + @src.VoyagerWeights::new( + [[1], [0, 2], [1, 3], [2]], + [[1.0], [1.0, 1.0], [1.0, 1.0], [1.0]], + style="B", + ) catch { + _ => abort("valid chain weights should build") + } +} + +///| +fn voy_test_gradient_values() -> Array[Double] { + // Values increasing with the x coordinate on the 3x3 grid: strong positive + // spatial autocorrelation. + [ + 0.0, 1.0, 2.0, // row 0 + 0.0, 1.0, 2.0, // row 1 + 0.0, 1.0, 2.0, // row 2 + ] +} + +///| +fn voy_test_checkerboard_values() -> Array[Double] { + // Alternating high/low: negative spatial autocorrelation on the grid. + [0.0, 9.0, 0.0, 9.0, 0.0, 9.0, 0.0, 9.0, 0.0] +} + +///| +fn voy_test_hotspot_values() -> Array[Double] { + // 3x3 grid with a hotspot in the centre. + [0.0, 0.0, 0.0, 0.0, 50.0, 0.0, 0.0, 0.0, 0.0] +} + +// =========================================================================== +// Weights construction +// =========================================================================== + +///| +test "Voyager weights kNN builds row-standardized neighbours" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + assert_eq(weights.n, 9) + assert_eq(weights.style, "W") + // Each spot on a 3x3 grid has 4 neighbours (corners: 2, edges: 3, centre: 4 + // are clamped to k=4 but corners/edges have fewer available neighbours). + assert_true(weights.neighbors[4].length() == 4) // centre + // Row-standardized: each row sums to 1. + for index in 0.. true + } + assert_true(failed) +} + +///| +test "Voyager weights kNN clamps k above n-1" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 100) catch { + _ => abort("kNN weights with large k should clamp") + } + // With k clamped to n-1, every spot links to all other spots. + assert_true(weights.neighbors[0].length() == 8) +} + +///| +test "Voyager weights distance band links immediate grid neighbours" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_distance_band(coords, 1.0) catch { + _ => abort("distance-band weights should build") + } + assert_eq(weights.n, 9) + // Centre spot (index 4) has 4 immediate neighbours at distance 1. + assert_eq(weights.neighbors[4].length(), 4) + // Corner spot (index 0) has 2 immediate neighbours. + assert_eq(weights.neighbors[0].length(), 2) +} + +///| +test "Voyager weights inverse distance produces positive finite weights" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_inverse_distance(coords, 1.0) catch { + _ => abort("inverse-distance weights should build") + } + assert_eq(weights.n, 9) + for index in 0.. 0.0) + assert_true(value <= 1.0e300) + } + } +} + +///| +test "Voyager weights style C sums to one globally" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4, style="C") catch { + _ => abort("style C weights should build") + } + let mut total = 0.0 + for index in 0.. abort("style B weights should build") + } + for index in 0.. true + } + assert_true(failed) +} + +// =========================================================================== +// Global Moran's I +// =========================================================================== + +///| +test "Voyager global Moran's I matches hand-computed chain example" { + let weights = voy_test_chain_weights() + let result = @src.voyager_global_morans_i([1.0, 1.0, 9.0, 9.0], weights) catch { + _ => abort("global Moran's I should run") + } + voy_test_close(result.estimate, 1.0 / 3.0, 1.0e-10) + voy_test_close(result.expectation, -1.0 / 3.0, 1.0e-12) + voy_test_close(result.s0, 6.0, 1.0e-12) + voy_test_close(result.s1, 12.0, 1.0e-12) + voy_test_close(result.s2, 40.0, 1.0e-12) + // b2 = 1, n = 4 -> variance = 88/216 - 1/9 = 0.296296... + voy_test_close(result.variance, 88.0 / 216.0 - 1.0 / 9.0, 1.0e-10) + assert_eq(result.n, 4) +} + +///| +test "Voyager global Moran's I is positive for a spatial gradient" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_global_morans_i(voy_test_gradient_values(), weights) catch { + _ => abort("global Moran's I should run") + } + assert_true(result.estimate > 0.0) + assert_true(result.p_value < 0.05) +} + +///| +test "Voyager global Moran's I is negative for a checkerboard" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_global_morans_i( + voy_test_checkerboard_values(), + weights, + ) catch { + _ => abort("global Moran's I should run") + } + assert_true(result.estimate < 0.0) +} + +///| +test "Voyager global Moran's I rejects non-finite values" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let failed = try { + ignore(@src.voyager_global_morans_i([1.0, 2.0, 1.0e400, 4.0], weights)) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +///| +test "Voyager global Moran's I rejects length mismatch" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let failed = try { + ignore(@src.voyager_global_morans_i([1.0, 2.0], weights)) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +// =========================================================================== +// Global Geary's c +// =========================================================================== + +///| +test "Voyager global Geary's c matches hand-computed chain example" { + let weights = voy_test_chain_weights() + let result = @src.voyager_global_gearys_c([1.0, 1.0, 9.0, 9.0], weights) catch { + _ => abort("global Geary's c should run") + } + voy_test_close(result.estimate, 0.5, 1.0e-10) + voy_test_close(result.expectation, 1.0, 1.0e-12) + assert_eq(result.n, 4) +} + +///| +test "Voyager global Geary's c is below one for a gradient" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_global_gearys_c(voy_test_gradient_values(), weights) catch { + _ => abort("global Geary's c should run") + } + assert_true(result.estimate < 1.0) +} + +///| +test "Voyager global Geary's c is above one for a checkerboard" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_global_gearys_c( + voy_test_checkerboard_values(), + weights, + ) catch { + _ => abort("global Geary's c should run") + } + assert_true(result.estimate > 1.0) +} + +// =========================================================================== +// Local Moran's I (LISA) +// =========================================================================== + +///| +test "Voyager local Moran's I returns one statistic per spot" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_local_morans_i( + voy_test_gradient_values(), + weights, + permutations=99, + seed=123, + ) catch { + _ => abort("local Moran's I should run") + } + assert_eq(result.n, 9) + assert_eq(result.local_i.length(), 9) + assert_eq(result.quadrants.length(), 9) + assert_eq(result.fdr.length(), 9) + assert_eq(result.permutations, 99) +} + +///| +test "Voyager local Moran's I permutation is deterministic for a fixed seed" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let first = @src.voyager_local_morans_i( + voy_test_gradient_values(), + weights, + permutations=50, + seed=777, + ) catch { + _ => abort("local Moran's I should run") + } + let second = @src.voyager_local_morans_i( + voy_test_gradient_values(), + weights, + permutations=50, + seed=777, + ) catch { + _ => abort("local Moran's I should run") + } + for index in 0.. abort("kNN weights should build") + } + let result = @src.voyager_local_morans_i( + voy_test_gradient_values(), + weights, + permutations=0, + ) catch { + _ => abort("local Moran's I should run") + } + for label in result.quadrants { + assert_true( + label == "HH" || + label == "LL" || + label == "HL" || + label == "LH" || + label == "not significant", + ) + } +} + +///| +test "Voyager local Moran's I BH-FDR is monotonic non-decreasing in rank" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_local_morans_i( + voy_test_gradient_values(), + weights, + permutations=99, + seed=42, + ) catch { + _ => abort("local Moran's I should run") + } + let indexed : Array[(Double, Int)] = [] + for index in 0.. Int { + if a.0 < b.0 { + -1 + } else if a.0 > b.0 { + 1 + } else { + 0 + } + }) + let mut previous = 0.0 + for entry in indexed { + let adjusted = result.fdr[entry.1] + assert_true(adjusted >= previous - 1.0e-12) + previous = adjusted + } +} + +///| +test "Voyager local Moran's I rejects zero-variance input" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let failed = try { + ignore( + @src.voyager_local_morans_i( + [5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0], + weights, + ), + ) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +// =========================================================================== +// Local Geary's c +// =========================================================================== + +///| +test "Voyager local Geary's c returns per-spot statistics and classifications" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_local_gearys_c( + voy_test_gradient_values(), + weights, + permutations=99, + seed=9, + ) catch { + _ => abort("local Geary's c should run") + } + assert_eq(result.n, 9) + assert_eq(result.local_c.length(), 9) + assert_eq(result.classifications.length(), 9) + for label in result.classifications { + assert_true( + label == "similar" || label == "dissimilar" || label == "not significant", + ) + } +} + +///| +test "Voyager local Geary's c is non-negative everywhere" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_local_gearys_c(voy_test_gradient_values(), weights) catch { + _ => abort("local Geary's c should run") + } + for value in result.local_c { + assert_true(value >= 0.0) + } +} + +// =========================================================================== +// Local Getis–Ord Gi / Gi* +// =========================================================================== + +///| +test "Voyager local Getis-Ord Gi* flags the centre of a hotspot" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_local_getis_ord( + voy_test_hotspot_values(), + weights, + star=true, + fdr_threshold=0.2, + ) catch { + _ => abort("Getis–Ord should run") + } + assert_eq(result.n, 9) + assert_eq(result.star, true) + // Centre spot (index 4) is the hotspot. + assert_true(result.z_scores[4] > 0.0) + assert_true(result.classifications[4] == "hotspot") +} + +///| +test "Voyager local Getis-Ord Gi excludes self from the weighted sum" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let gi = @src.voyager_local_getis_ord( + voy_test_hotspot_values(), + weights, + star=false, + ) catch { + _ => abort("Getis–Ord should run") + } + let gi_star = @src.voyager_local_getis_ord( + voy_test_hotspot_values(), + weights, + star=true, + ) catch { + _ => abort("Getis–Ord should run") + } + assert_eq(gi.star, false) + // The two statistics differ for the hotspot centre because Gi* includes self. + assert_true((gi.statistic[4] - gi_star.statistic[4]).abs() > 1.0e-9) +} + +///| +test "Voyager local Getis-Ord rejects negative values" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let failed = try { + ignore( + @src.voyager_local_getis_ord( + [-1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + weights, + ), + ) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +///| +test "Voyager local Getis-Ord z-scores are finite" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_local_getis_ord( + voy_test_gradient_values(), + weights, + star=true, + ) catch { + _ => abort("Getis–Ord should run") + } + for value in result.z_scores { + assert_true(value == value) + assert_true(value.abs() <= 1.0e300) + } +} + +// =========================================================================== +// Lee's L +// =========================================================================== + +///| +test "Voyager Lee's L is positive for co-varying features" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_lees_l( + voy_test_gradient_values(), + voy_test_gradient_values(), + weights, + ) catch { + _ => abort("Lee's L should run") + } + assert_eq(result.n, 9) + // A feature with itself: Lee's L is positive and bounded by 1. + assert_true(result.global_l > 0.0) + assert_true(result.global_l <= 1.0 + 1.0e-9) +} + +///| +test "Voyager Lee's L is negative for anti-correlated features" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let anti : Array[Double] = [] + for value in voy_test_gradient_values() { + anti.push(10.0 - value) + } + let result = @src.voyager_lees_l(voy_test_gradient_values(), anti, weights) catch { + _ => abort("Lee's L should run") + } + assert_true(result.global_l < 0.0) +} + +///| +test "Voyager Lee's L local values length matches spot count" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_lees_l( + voy_test_gradient_values(), + voy_test_hotspot_values(), + weights, + permutations=49, + seed=5, + ) catch { + _ => abort("Lee's L should run") + } + assert_eq(result.local_l.length(), 9) + assert_eq(result.fdr.length(), 9) +} + +///| +test "Voyager Lee's L rejects unequal feature lengths" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let failed = try { + ignore( + @src.voyager_lees_l([1.0, 2.0, 3.0], voy_test_gradient_values(), weights), + ) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +// =========================================================================== +// Multivariate local Geary +// =========================================================================== + +///| +test "Voyager multivariate local Geary combines features into one statistic" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let matrix : Array[Array[Double]] = [ + voy_test_gradient_values(), + voy_test_hotspot_values(), + ] + let result = @src.voyager_multivariate_local_geary( + matrix, + weights, + permutations=49, + seed=3, + ) catch { + _ => abort("multivariate local Geary should run") + } + assert_eq(result.n, 9) + assert_eq(result.n_features, 2) + assert_eq(result.local_statistic.length(), 9) + assert_eq(result.classifications.length(), 9) + assert_eq(result.feature_set, ["feature1", "feature2"]) +} + +///| +test "Voyager multivariate local Geary uses supplied feature names" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let matrix : Array[Array[Double]] = [ + voy_test_gradient_values(), + voy_test_hotspot_values(), + ] + let result = @src.voyager_multivariate_local_geary(matrix, weights, feature_names=[ + "gradient", "hotspot", + ]) catch { + _ => abort("multivariate local Geary should run") + } + assert_eq(result.feature_set, ["gradient", "hotspot"]) +} + +///| +test "Voyager multivariate local Geary is non-negative" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let matrix : Array[Array[Double]] = [voy_test_gradient_values()] + let result = @src.voyager_multivariate_local_geary(matrix, weights) catch { + _ => abort("multivariate local Geary should run") + } + for value in result.local_statistic { + assert_true(value >= 0.0) + } +} + +// =========================================================================== +// Empirical variogram and model fitting +// =========================================================================== + +///| +test "Voyager empirical variogram bins pairs and computes semivariance" { + let coords = voy_test_grid_coords() + let empirical = @src.voyager_empirical_variogram( + coords, + voy_test_gradient_values(), + n_lags=5, + ) catch { + _ => abort("empirical variogram should run") + } + assert_true(empirical.length() >= 2) + for point in empirical { + assert_true(point.npairs > 0) + assert_true(point.gamma >= 0.0) + assert_true(point.lag > 0.0) + } +} + +///| +test "Voyager variogram fit recovers a positive range and bounded SSE" { + let coords = voy_test_grid_coords() + let empirical = @src.voyager_empirical_variogram( + coords, + voy_test_gradient_values(), + n_lags=8, + ) catch { + _ => abort("empirical variogram should run") + } + let model = @src.voyager_fit_variogram(empirical, model_type="spherical") catch { + _ => abort("spherical fit should run") + } + assert_eq(model.model_type, "spherical") + assert_true(model.range > 0.0) + assert_true(model.sill >= 0.0) + assert_true(model.nugget >= 0.0) + assert_true(model.fitted_sse >= 0.0) +} + +///| +test "Voyager variogram predict increases with distance up to the range" { + let coords = voy_test_grid_coords() + let empirical = @src.voyager_empirical_variogram( + coords, + voy_test_gradient_values(), + n_lags=6, + ) catch { + _ => abort("empirical variogram should run") + } + let model = @src.voyager_fit_variogram(empirical, model_type="exponential") catch { + _ => abort("exponential fit should run") + } + let small = @src.voyager_variogram_predict(model, 0.01) + let large = @src.voyager_variogram_predict(model, model.range * 3.0) + assert_true(large >= small) +} + +///| +test "Voyager variogram fit supports gaussian model" { + let coords = voy_test_grid_coords() + let empirical = @src.voyager_empirical_variogram( + coords, + voy_test_gradient_values(), + n_lags=6, + ) catch { + _ => abort("empirical variogram should run") + } + let model = @src.voyager_fit_variogram(empirical, model_type="gaussian") catch { + _ => abort("gaussian fit should run") + } + assert_eq(model.model_type, "gaussian") +} + +///| +test "Voyager variogram fit rejects an unknown model type" { + let coords = voy_test_grid_coords() + let empirical = @src.voyager_empirical_variogram( + coords, + voy_test_gradient_values(), + n_lags=4, + ) catch { + _ => abort("empirical variogram should run") + } + let failed = try { + ignore(@src.voyager_fit_variogram(empirical, model_type="cubic")) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +///| +test "Voyager variogram fit respects a fixed nugget" { + let coords = voy_test_grid_coords() + let empirical = @src.voyager_empirical_variogram( + coords, + voy_test_gradient_values(), + n_lags=6, + ) catch { + _ => abort("empirical variogram should run") + } + let model = @src.voyager_fit_variogram( + empirical, + model_type="spherical", + nugget=0.25, + fix_nugget=true, + ) catch { + _ => abort("fixed-nugget fit should run") + } + voy_test_close(model.nugget, 0.25, 1.0e-12) +} + +// =========================================================================== +// Correlogram +// =========================================================================== + +///| +test "Voyager correlogram returns one point per non-empty lag" { + let coords = voy_test_grid_coords() + let points = @src.voyager_correlogram( + coords, + voy_test_gradient_values(), + n_lags=4, + ) catch { + _ => abort("correlogram should run") + } + // Empty distance bins are skipped; every returned point has observed pairs. + assert_true(points.length() >= 1) + assert_true(points.length() <= 4) + let mut previous_lag = -1.0 + for point in points { + assert_true(point.npairs > 0) + assert_true(point.lag > previous_lag) + previous_lag = point.lag + voy_test_close(point.expectation, -1.0 / 8.0, 1.0e-12) + } +} + +///| +test "Voyager correlogram gradient shows positive Moran at short lags" { + let coords = voy_test_grid_coords() + let points = @src.voyager_correlogram( + coords, + voy_test_gradient_values(), + n_lags=3, + ) catch { + _ => abort("correlogram should run") + } + assert_true(points[0].morans_i > 0.0) +} + +// =========================================================================== +// SpatialExperiment integration +// =========================================================================== + +///| +test "Voyager example SpatialExperiment has the expected shape" { + let se = @src.voyager_example_spatial_experiment() + assert_eq(se.col_data.length(), 36) + assert_eq(se.spatial_coords.length(), 36) + let assay = se.assay["logcounts"] + assert_eq(assay.length(), 4) + assert_eq(assay[0].length(), 36) +} + +///| +test "Voyager univariate SFE Moran writes back local results without mutating input" { + let se = @src.voyager_example_spatial_experiment() + let original_keys = se.col_data[0].keys().length() + let output = @src.voyager_run_univariate_sfe( + se, + [0], + assay_name="logcounts", + stat_method="moran", + permutations=19, + seed=2024, + output_prefix="voy", + ) catch { + _ => abort("Voyager SFE Moran integration should run") + } + // Input SpatialExperiment unchanged. + assert_eq(se.col_data[0].keys().length(), original_keys) + assert_true(!se.col_data[0].contains("voy.moran.local.gene_gradient")) + // Output SpatialExperiment carries the write-back. + assert_true( + output.experiment.col_data[0].contains("voy.moran.local.gene_gradient"), + ) + assert_true( + output.experiment.row_data[0].contains("voy.moran.I.gene_gradient"), + ) + assert_eq(output.results.length(), 1) + assert_eq(output.results[0].stat_method, "moran") + assert_eq(output.weights.n, 36) +} + +///| +test "Voyager univariate SFE Geary writes classification column" { + let se = @src.voyager_example_spatial_experiment() + let output = @src.voyager_run_univariate_sfe( + se, + [0, 1], + assay_name="logcounts", + stat_method="geary", + permutations=19, + seed=7, + output_prefix="vg", + ) catch { + _ => abort("Voyager SFE Geary integration should run") + } + assert_eq(output.results.length(), 2) + assert_true( + output.experiment.col_data[0].contains("vg.geary.class.gene_gradient"), + ) + assert_true(output.experiment.row_data[1].contains("vg.geary.C.gene_hotspot")) +} + +///| +test "Voyager univariate SFE Getis writes hotspot classification" { + let se = @src.voyager_example_spatial_experiment() + let output = @src.voyager_run_univariate_sfe( + se, + [1], + assay_name="logcounts", + stat_method="getis", + output_prefix="g", + ) catch { + _ => abort("Voyager SFE Getis integration should run") + } + assert_eq(output.results.length(), 1) + assert_eq(output.results[0].stat_method, "getis") + assert_true( + output.experiment.col_data[0].contains("g.getis.class.gene_hotspot"), + ) + assert_true(output.experiment.col_data[0].contains("g.getis.z.gene_hotspot")) +} + +///| +test "Voyager univariate SFE can use a distance-band bandwidth" { + let se = @src.voyager_example_spatial_experiment() + let output = @src.voyager_run_univariate_sfe( + se, + [0], + assay_name="logcounts", + stat_method="moran", + bandwidth=1.0, + output_prefix="db", + ) catch { + _ => abort("Voyager SFE distance-band integration should run") + } + assert_eq(output.weights.n, 36) + // Distance band of 1.0 on a unit grid links only orthogonal immediate + // neighbours (excluding diagonals at sqrt(2)), so centre spots have 4. + let mut has_four = false + for index in 0.. true + } + assert_true(failed) +} + +///| +test "Voyager univariate SFE rejects an unknown method" { + let se = @src.voyager_example_spatial_experiment() + let failed = try { + ignore( + @src.voyager_run_univariate_sfe( + se, + [0], + assay_name="logcounts", + stat_method="unknown", + ), + ) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +///| +test "Voyager univariate SFE rejects a missing assay" { + let se = @src.voyager_example_spatial_experiment() + let failed = try { + ignore(@src.voyager_run_univariate_sfe(se, [0], assay_name="counts")) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +///| +test "Voyager univariate SFE metadata records method and feature count" { + let se = @src.voyager_example_spatial_experiment() + let output = @src.voyager_run_univariate_sfe( + se, + [0, 1, 2], + assay_name="logcounts", + stat_method="moran", + output_prefix="meta", + ) catch { + _ => abort("Voyager SFE integration should run") + } + assert_eq(output.experiment.metadata["meta.method"], "moran") + assert_eq(output.experiment.metadata["meta.n_features"], "3") + assert_eq(output.experiment.metadata["meta.weights_style"], "W") +} + +// =========================================================================== +// Determinism and edge cases +// =========================================================================== + +///| +test "Voyager PRNG produces reproducible shuffles for the same seed" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let a = @src.voyager_local_morans_i( + voy_test_gradient_values(), + weights, + permutations=30, + seed=20240501, + ) catch { + _ => abort("local Moran's I should run") + } + let b = @src.voyager_local_morans_i( + voy_test_gradient_values(), + weights, + permutations=30, + seed=20240501, + ) catch { + _ => abort("local Moran's I should run") + } + voy_test_close(a.p_values[0], b.p_values[0], 0.0) + voy_test_close(a.z_scores[4], b.z_scores[4], 0.0) +} + +///| +test "Voyager global Moran's I expectation equals negative one over n minus one" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_global_morans_i(voy_test_gradient_values(), weights) catch { + _ => abort("global Moran's I should run") + } + voy_test_close(result.expectation, -1.0 / 8.0, 1.0e-12) +} + +///| +test "Voyager weights distance band rejects non-positive bandwidth" { + let coords = voy_test_grid_coords() + let failed = try { + ignore(@src.voyager_weights_distance_band(coords, 0.0)) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +///| +test "Voyager weights inverse distance rejects non-positive power" { + let coords = voy_test_grid_coords() + let failed = try { + ignore(@src.voyager_weights_inverse_distance(coords, 0.0)) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +///| +test "Voyager empirical variogram rejects coincident coordinates" { + let coords : Array[Array[Double]] = [[0.0, 0.0], [0.0, 0.0], [0.0, 0.0]] + let failed = try { + ignore(@src.voyager_empirical_variogram(coords, [1.0, 2.0, 3.0])) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +///| +test "Voyager local Getis-Ord FDR is bounded in [0, 1]" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_local_getis_ord( + voy_test_hotspot_values(), + weights, + star=true, + ) catch { + _ => abort("Getis–Ord should run") + } + for value in result.fdr { + assert_true(value >= 0.0 && value <= 1.0) + } +} diff --git a/test/moonbit/vsn_test.mbt b/test/moonbit/vsn_test.mbt index e10610d6..d22d5499 100644 --- a/test/moonbit/vsn_test.mbt +++ b/test/moonbit/vsn_test.mbt @@ -42,11 +42,7 @@ test "vsn_control_new" { ///| test "vsn2_basic" { - let data = [ - [100.0, 200.0], - [150.0, 180.0], - [90.0, 210.0], - ] + let data = [[100.0, 200.0], [150.0, 180.0], [90.0, 210.0]] let result = @src.vsn2(data) assert_eq(result.length(), 3) assert_eq(result[0].length(), 2) @@ -54,11 +50,7 @@ test "vsn2_basic" { ///| test "vsn2_with_control_runs" { - let data = [ - [100.0, 200.0], - [150.0, 180.0], - [90.0, 210.0], - ] + let data = [[100.0, 200.0], [150.0, 180.0], [90.0, 210.0]] let ctrl = @src.VSNControl::new() let result = @src.vsn2_with_control(data, ctrl) assert_eq(result.length(), 3) @@ -67,11 +59,7 @@ test "vsn2_with_control_runs" { ///| test "vsn_fit_and_report_returns_vsnresult" { - let data = [ - [100.0, 200.0], - [150.0, 180.0], - [90.0, 210.0], - ] + let data = [[100.0, 200.0], [150.0, 180.0], [90.0, 210.0]] let fit = @src.vsn_fit_and_report(data) assert_eq(fit.params.length(), 2) let summary = @src.summarize_vsn_fit(fit) @@ -100,11 +88,7 @@ test "mean_sd_bins_and_ascii" { ///| test "vsn_denoise_keeps_shape" { - let data = [ - [100.0, 200.0], - [150.0, 180.0], - [90.0, 210.0], - ] + let data = [[100.0, 200.0], [150.0, 180.0], [90.0, 210.0]] let denoised = @src.vsn_denoise(data) assert_eq(denoised.length(), 3) assert_eq(denoised[0].length(), 2) diff --git a/test/moonbit/wise_test.mbt b/test/moonbit/wise_test.mbt index cdf77081..8d42b807 100644 --- a/test/moonbit/wise_test.mbt +++ b/test/moonbit/wise_test.mbt @@ -10,31 +10,37 @@ test "wise_block_type_to_string_exon" { assert_eq(bt.to_string(), "exon") } +///| test "wise_block_type_to_string_intron" { let bt = @src.wise_make_block_type("intron") assert_eq(bt.to_string(), "intron") } +///| test "wise_block_type_to_string_match" { let bt = @src.wise_make_block_type("match") assert_eq(bt.to_string(), "match") } +///| test "wise_block_type_to_string_mismatch" { let bt = @src.wise_make_block_type("mismatch") assert_eq(bt.to_string(), "mismatch") } +///| test "wise_block_type_to_string_insertion" { let bt = @src.wise_make_block_type("insertion") assert_eq(bt.to_string(), "insertion") } +///| test "wise_block_type_to_string_deletion" { let bt = @src.wise_make_block_type("deletion") assert_eq(bt.to_string(), "deletion") } +///| test "wise_block_type_eq_via_is_pattern" { // Enum variants can be compared using `is` pattern matching. let bt = @src.wise_make_block_type("exon") @@ -46,6 +52,7 @@ test "wise_block_type_eq_via_is_pattern" { // WiseExon // --------------------------------------------------------------------------- +///| test "wise_exon_new_defaults" { let e = @src.WiseExon::new() assert_eq(e.start, 0) @@ -57,6 +64,7 @@ test "wise_exon_new_defaults" { assert_eq(e.protein_end, 0) } +///| test "wise_exon_new_with_params" { let e = @src.WiseExon::new( start=100, @@ -76,11 +84,13 @@ test "wise_exon_new_with_params" { assert_eq(e.protein_end, 33) } +///| test "wise_exon_length" { let e = @src.WiseExon::new(start=0, end=99) assert_eq(e.length(), 100) } +///| test "wise_exon_length_single_base" { let e = @src.WiseExon::new(start=50, end=50) assert_eq(e.length(), 1) @@ -90,6 +100,7 @@ test "wise_exon_length_single_base" { // WiseIntron // --------------------------------------------------------------------------- +///| test "wise_intron_new_defaults" { let i = @src.WiseIntron::new() assert_eq(i.start, 0) @@ -100,6 +111,7 @@ test "wise_intron_new_defaults" { assert_eq(i.length, 1) } +///| test "wise_intron_new_with_params" { let i = @src.WiseIntron::new( start=100, @@ -115,11 +127,13 @@ test "wise_intron_new_with_params" { assert_eq(i.length, 100) } +///| test "wise_intron_length_auto_calc_normal" { let i = @src.WiseIntron::new(start=200, end=299) assert_eq(i.length, 100) } +///| test "wise_intron_length_auto_calc_end_before_start" { // When end < start, length should be 0 let i = @src.WiseIntron::new(start=300, end=100) @@ -130,6 +144,7 @@ test "wise_intron_length_auto_calc_end_before_start" { // WiseAlignmentColumn // --------------------------------------------------------------------------- +///| test "wise_alignment_column_new" { let c = @src.WiseAlignmentColumn::new( protein_char='M', @@ -145,11 +160,9 @@ test "wise_alignment_column_new" { assert_eq(c.protein_position, 0) } +///| test "wise_alignment_column_new_default_match_type" { - let c = @src.WiseAlignmentColumn::new( - protein_char='X', - gene_codon="TAG", - ) + let c = @src.WiseAlignmentColumn::new(protein_char='X', gene_codon="TAG") assert_eq(c.protein_char, 'X') assert_eq(c.gene_codon, "TAG") // Default match_type is " " @@ -162,6 +175,7 @@ test "wise_alignment_column_new_default_match_type" { // WiseResult construction and basic accessors // --------------------------------------------------------------------------- +///| test "wise_result_new_empty" { let r = @src.WiseResult::new() assert_eq(r.protein_id, "") @@ -173,6 +187,7 @@ test "wise_result_new_empty" { assert_eq(r.get_total_exon_length(), 0) } +///| test "wise_result_add_and_get_exons" { let r = @src.WiseResult::new() let e1 = @src.WiseExon::new(start=0, end=99) @@ -185,6 +200,7 @@ test "wise_result_add_and_get_exons" { assert_eq(exons[1].start, 200) } +///| test "wise_result_add_and_get_introns" { let r = @src.WiseResult::new() let i1 = @src.WiseIntron::new(start=100, end=199) @@ -195,6 +211,7 @@ test "wise_result_add_and_get_introns" { assert_eq(introns[0].end, 199) } +///| test "wise_result_get_num_exons" { let r = @src.WiseResult::new() assert_eq(r.get_num_exons(), 0) @@ -205,6 +222,7 @@ test "wise_result_get_num_exons" { assert_eq(r.get_num_exons(), 3) } +///| test "wise_result_get_num_introns" { let r = @src.WiseResult::new() assert_eq(r.get_num_introns(), 0) @@ -214,6 +232,7 @@ test "wise_result_get_num_introns" { assert_eq(r.get_num_introns(), 2) } +///| test "wise_result_get_total_exon_length" { let r = @src.WiseResult::new() // Exon 1: 0-99 -> length 100 @@ -225,41 +244,44 @@ test "wise_result_get_total_exon_length" { assert_eq(r.get_total_exon_length(), 280) } +///| test "wise_result_get_total_exon_length_empty" { let r = @src.WiseResult::new() assert_eq(r.get_total_exon_length(), 0) } +///| test "wise_result_set_protein_id" { let r = @src.WiseResult::new() r.set_protein_id("P12345") assert_eq(r.protein_id, "P12345") } +///| test "wise_result_set_gene_id" { let r = @src.WiseResult::new() r.set_gene_id("G67890") assert_eq(r.gene_id, "G67890") } +///| test "wise_result_set_score" { let r = @src.WiseResult::new() r.set_score(145.32) assert_eq(r.score, 145.32) } +///| test "wise_result_set_bits_score" { let r = @src.WiseResult::new() r.set_bits_score(52.18) assert_eq(r.bits_score, 52.18) } +///| test "wise_result_add_alignment_column" { let r = @src.WiseResult::new() - let c = @src.WiseAlignmentColumn::new( - protein_char='M', - gene_codon="ATG", - ) + let c = @src.WiseAlignmentColumn::new(protein_char='M', gene_codon="ATG") r.add_alignment_column(c) let aln = r.get_alignment() assert_eq(aln.length(), 1) @@ -270,27 +292,32 @@ test "wise_result_add_alignment_column" { // wise_parse // --------------------------------------------------------------------------- +///| test "wise_parse_protein_id" { let r = @src.wise_parse("Protein: P12345\n") assert_eq(r.protein_id, "P12345") } +///| test "wise_parse_gene_id" { let r = @src.wise_parse("Gene: G67890\n") assert_eq(r.gene_id, "G67890") } +///| test "wise_parse_score" { let r = @src.wise_parse("Score: 145.32\n") // Use tolerance for floating-point comparison (parse_double precision) assert_true(r.score > 145.31 && r.score < 145.33) } +///| test "wise_parse_bits_score" { let r = @src.wise_parse("Bits: 52.18\n") assert_eq(r.bits_score, 52.18) } +///| test "wise_parse_exons" { let r = @src.wise_parse( "Exon 1: 0-99 (phase 0) score 45.5 protein 1-33\nExon 2: 200-299 (phase 0) score 52.3 protein 34-66\n", @@ -308,6 +335,7 @@ test "wise_parse_exons" { assert_eq(exons[1].score, 52.3) } +///| test "wise_parse_introns" { let r = @src.wise_parse( "Intron 1: 100-199 donor 12.5 acceptor 8.3\nIntron 2: 300-399 donor 10.2 acceptor 9.1\n", @@ -325,6 +353,7 @@ test "wise_parse_introns" { assert_eq(introns[1].acceptor_score, 9.1) } +///| test "wise_parse_empty_input" { let r = @src.wise_parse("") assert_eq(r.protein_id, "") @@ -335,6 +364,7 @@ test "wise_parse_empty_input" { assert_eq(r.get_num_introns(), 0) } +///| test "wise_parse_full_sample" { let r = @src.wise_parse(@src.wise_sample_output()) assert_eq(r.protein_id, "P12345") @@ -351,6 +381,7 @@ test "wise_parse_full_sample" { // Sample data // --------------------------------------------------------------------------- +///| test "wise_sample_output_content" { let s = @src.wise_sample_output() assert_true(s.contains("Protein: P12345")) @@ -361,6 +392,7 @@ test "wise_sample_output_content" { assert_true(s.contains("Intron 1: 100-199")) } +///| test "wise_sample_result" { let r = @src.wise_sample() assert_eq(r.protein_id, "P12345") @@ -373,6 +405,7 @@ test "wise_sample_result" { // wise_write // --------------------------------------------------------------------------- +///| test "wise_write_basic" { let r = @src.WiseResult::new() r.set_protein_id("P12345") @@ -387,12 +420,29 @@ test "wise_write_basic" { assert_true(s.contains("Bits: 52.18")) } +///| test "wise_write_with_exons_and_introns" { let r = @src.WiseResult::new() r.set_protein_id("P1") r.set_gene_id("G1") - r.add_exon(@src.WiseExon::new(start=0, end=99, phase=0, score=45.5, protein_start=1, protein_end=33)) - r.add_intron(@src.WiseIntron::new(start=100, end=199, donor_score=12.5, acceptor_score=8.3)) + r.add_exon( + @src.WiseExon::new( + start=0, + end=99, + phase=0, + score=45.5, + protein_start=1, + protein_end=33, + ), + ) + r.add_intron( + @src.WiseIntron::new( + start=100, + end=199, + donor_score=12.5, + acceptor_score=8.3, + ), + ) let s = @src.wise_write(r) assert_true(s.contains("Exon 1: 0-99")) assert_true(s.contains("(phase 0)")) @@ -403,6 +453,7 @@ test "wise_write_with_exons_and_introns" { assert_true(s.contains("acceptor 8.3")) } +///| test "wise_write_roundtrip" { // Parse sample, write it back, verify key fields are present let r = @src.wise_sample() @@ -420,6 +471,7 @@ test "wise_write_roundtrip" { // wise_gene_structure // --------------------------------------------------------------------------- +///| test "wise_gene_structure_basic" { let r = @src.WiseResult::new() r.add_exon(@src.WiseExon::new(start=0, end=99, phase=0)) @@ -433,6 +485,7 @@ test "wise_gene_structure_basic" { assert_true(s.contains("Intron 1: 100-199")) } +///| test "wise_gene_structure_empty" { let r = @src.WiseResult::new() let s = @src.wise_gene_structure(r) @@ -440,6 +493,7 @@ test "wise_gene_structure_empty" { assert_eq(s.length(), 0) } +///| test "wise_gene_structure_sample" { let r = @src.wise_sample() let s = @src.wise_gene_structure(r) @@ -455,6 +509,7 @@ test "wise_gene_structure_sample" { // wise_translate_gene // --------------------------------------------------------------------------- +///| test "wise_translate_gene_single_exon" { // Exon 0-8 (9 nt) -> ATG GCC GGT -> M A G let r = @src.WiseResult::new() @@ -464,6 +519,7 @@ test "wise_translate_gene_single_exon" { assert_eq(protein, "MAG") } +///| test "wise_translate_gene_multiple_codons" { // Exon 0-11 (12 nt) -> ATG GCC GGT AAA -> M A G K let r = @src.WiseResult::new() @@ -473,6 +529,7 @@ test "wise_translate_gene_multiple_codons" { assert_eq(protein, "MAGK") } +///| test "wise_translate_gene_stop_codon" { // Exon 0-8 -> ATG TAA TAG -> M * * let r = @src.WiseResult::new() @@ -489,6 +546,7 @@ test "wise_translate_gene_stop_codon" { // wise_percent_identity // --------------------------------------------------------------------------- +///| test "wise_percent_identity_full" { // Translation matches protein exactly -> 100.0% let r = @src.WiseResult::new() @@ -499,6 +557,7 @@ test "wise_percent_identity_full" { assert_eq(pct, 100.0) } +///| test "wise_percent_identity_none" { // Translation does not match protein -> 0.0% let r = @src.WiseResult::new() @@ -509,6 +568,7 @@ test "wise_percent_identity_none" { assert_eq(pct, 0.0) } +///| test "wise_percent_identity_partial" { // Translation: MAG, protein: MAP -> 2/3 match -> ~66.67% let r = @src.WiseResult::new() @@ -519,6 +579,7 @@ test "wise_percent_identity_partial" { assert_true(pct > 66.0 && pct < 67.0) } +///| test "wise_percent_identity_empty_protein" { let r = @src.WiseResult::new() r.add_exon(@src.WiseExon::new(start=0, end=8)) @@ -531,6 +592,7 @@ test "wise_percent_identity_empty_protein" { // wise_summary // --------------------------------------------------------------------------- +///| test "wise_summary_basic" { let r = @src.wise_sample() let s = @src.wise_summary(r) @@ -544,6 +606,7 @@ test "wise_summary_basic" { assert_true(s.contains("Total exon length: 280 nt")) } +///| test "wise_summary_empty" { let r = @src.WiseResult::new() let s = @src.wise_summary(r) @@ -557,6 +620,7 @@ test "wise_summary_empty" { // GenomeWiseSegment // --------------------------------------------------------------------------- +///| test "genome_wise_segment_new_defaults" { let s = @src.GenomeWiseSegment::new() assert_eq(s.segment_id, "") @@ -567,6 +631,7 @@ test "genome_wise_segment_new_defaults" { assert_eq(s.wise_result.get_num_exons(), 0) } +///| test "genome_wise_segment_new_with_params" { let s = @src.GenomeWiseSegment::new( segment_id="seg1", @@ -584,6 +649,7 @@ test "genome_wise_segment_new_with_params" { // GenomeWiseResult // --------------------------------------------------------------------------- +///| test "genome_wise_result_new_empty" { let r = @src.GenomeWiseResult::new() assert_eq(r.gene_id, "") @@ -591,6 +657,7 @@ test "genome_wise_result_new_empty" { assert_eq(r.get_num_segments(), 0) } +///| test "genome_wise_result_add_and_get_segments" { let r = @src.GenomeWiseResult::new() let s1 = @src.GenomeWiseSegment::new(segment_id="seg1", start=100, end=200) @@ -603,6 +670,7 @@ test "genome_wise_result_add_and_get_segments" { assert_eq(segs[1].segment_id, "seg2") } +///| test "genome_wise_result_get_num_segments" { let r = @src.GenomeWiseResult::new() assert_eq(r.get_num_segments(), 0) diff --git a/test/moonbit/xcell_test.mbt b/test/moonbit/xcell_test.mbt index 5773ec1a..e2d160ba 100644 --- a/test/moonbit/xcell_test.mbt +++ b/test/moonbit/xcell_test.mbt @@ -8,17 +8,16 @@ // ============================================================================ test "xc_signature_new_basic" { - let sig = @src.XcellSignature::new( - "CD8+ T cells", - "immune", - ["CD8A", "CD8B", "GZMA", "GZMB"], - ) + let sig = @src.XcellSignature::new("CD8+ T cells", "immune", [ + "CD8A", "CD8B", "GZMA", "GZMB", + ]) assert_eq(sig.cell_type(), "CD8+ T cells") assert_eq(sig.category(), "immune") assert_eq(sig.genes().length(), 4) assert_eq(sig.genes()[0], "CD8A") } +///| test "xc_default_signatures_count_and_categories" { let sigs = @src.xcell_default_signatures() // Should have 63 signatures @@ -42,6 +41,7 @@ test "xc_default_signatures_count_and_categories" { assert_true(other_count >= 8) } +///| test "xc_default_signatures_each_has_genes" { let sigs = @src.xcell_default_signatures() for s in sigs { @@ -54,6 +54,7 @@ test "xc_default_signatures_each_has_genes" { // Parameters // ============================================================================ +///| test "xc_params_default" { let p = @src.XcellParams::new() assert_eq(p.min_gene_overlap, 3) @@ -67,6 +68,7 @@ test "xc_params_default" { // ssGSEA single-sample scoring // ============================================================================ +///| test "xc_ssgsea_single_basic" { let expr = [10.0, 5.0, 20.0, 3.0, 15.0] let genes = ["A", "B", "C", "D", "E"] @@ -77,6 +79,7 @@ test "xc_ssgsea_single_basic" { assert_true(score >= -1.0 && score <= 1.0) } +///| test "xc_ssgsea_single_high_enrichment" { // Expression sorted: A=100, B=90, C=80, D=10, E=5 (high A,B,C top ranking) // Gene set = [A,B,C] are all top -> high positive enrichment @@ -90,6 +93,7 @@ test "xc_ssgsea_single_high_enrichment" { assert_true(score_high > score_low) } +///| test "xc_ssgsea_single_empty" { let s = @src.xcell_ssgsea_single([], [], ["A"], alpha=0.25) assert_eq(s, 0.0) @@ -97,6 +101,7 @@ test "xc_ssgsea_single_empty" { assert_eq(s2, 0.0) } +///| test "xc_ssgsea_single_min_overlap" { // Only 1 gene overlap, should return 0 when we need min 3 (but function returns 0 for <3) let expr = [1.0, 2.0] @@ -110,11 +115,9 @@ test "xc_ssgsea_single_min_overlap" { // Full xCell pipeline // ============================================================================ +///| test "xc_result_creation" { - let scores : Array[Array[Double]] = [ - [0.5, 0.8], - [0.2, 0.1], - ] + let scores : Array[Array[Double]] = [[0.5, 0.8], [0.2, 0.1]] let cts = ["T cells", "B cells"] let cats = ["immune", "immune"] let samps = ["s1", "s2"] @@ -122,40 +125,39 @@ test "xc_result_creation" { let str = [0.1, 0.15] let menv = [0.45, 0.6] let p = @src.XcellParams::new() - let r = @src.XcellResult::new( - scores, cts, cats, samps, imm, str, menv, p, - ) + let r = @src.XcellResult::new(scores, cts, cats, samps, imm, str, menv, p) assert_eq(r.cell_types.length(), 2) assert_eq(r.sample_names.length(), 2) assert_true((r.immune_scores[0] - 0.35).abs() < 0.0001) assert_true((r.microenvironment_scores[1] - 0.6).abs() < 0.0001) } +///| test "xc_run_default_simple" { // Simple expression matrix with a handful of marker genes let gene_names = [ - "CD3D", "CD3E", "CD8A", "CD8B", "GZMA", "GZMB", "PRF1", "NKG7", - "CD19", "MS4A1", "CD79A", "PECAM1", "VWF", "COL1A1", "FAP", "ALB", + "CD3D", "CD3E", "CD8A", "CD8B", "GZMA", "GZMB", "PRF1", "NKG7", "CD19", "MS4A1", + "CD79A", "PECAM1", "VWF", "COL1A1", "FAP", "ALB", ] let sample_names = ["Tumor1", "Tumor2", "Normal1"] // 16 genes x 3 samples: upregulate immune in Normal1, stromal in Tumor2 let expression = [ - [10.0, 8.0, 100.0], // CD3D - [12.0, 9.0, 110.0], // CD3E - [15.0, 10.0, 120.0], // CD8A - [14.0, 9.0, 115.0], // CD8B - [20.0, 15.0, 130.0], // GZMA - [18.0, 12.0, 125.0], // GZMB - [16.0, 11.0, 110.0], // PRF1 - [17.0, 13.0, 115.0], // NKG7 - [5.0, 4.0, 80.0], // CD19 - [6.0, 5.0, 85.0], // MS4A1 - [5.0, 3.0, 75.0], // CD79A - [20.0, 100.0, 15.0], // PECAM1 - [18.0, 95.0, 12.0], // VWF - [30.0, 150.0, 10.0], // COL1A1 - [25.0, 140.0, 8.0], // FAP - [10.0, 20.0, 200.0], // ALB + [10.0, 8.0, 100.0], // CD3D + [12.0, 9.0, 110.0], // CD3E + [15.0, 10.0, 120.0], // CD8A + [14.0, 9.0, 115.0], // CD8B + [20.0, 15.0, 130.0], // GZMA + [18.0, 12.0, 125.0], // GZMB + [16.0, 11.0, 110.0], // PRF1 + [17.0, 13.0, 115.0], // NKG7 + [5.0, 4.0, 80.0], // CD19 + [6.0, 5.0, 85.0], // MS4A1 + [5.0, 3.0, 75.0], // CD79A + [20.0, 100.0, 15.0], // PECAM1 + [18.0, 95.0, 12.0], // VWF + [30.0, 150.0, 10.0], // COL1A1 + [25.0, 140.0, 8.0], // FAP + [10.0, 20.0, 200.0], // ALB ] let result = @src.xcell_run_default(expression, gene_names, sample_names) // Should have returned scores with 63 cell types and 3 samples @@ -175,11 +177,9 @@ test "xc_run_default_simple" { // Result accessors // ============================================================================ +///| test "xc_result_get_cell_type_scores" { - let scores : Array[Array[Double]] = [ - [0.3, 0.5], - [0.8, 0.6], - ] + let scores : Array[Array[Double]] = [[0.3, 0.5], [0.8, 0.6]] let cts = ["T-cells", "B-cells"] let cats = ["immune", "immune"] let samps = ["s1", "s2"] @@ -187,9 +187,7 @@ test "xc_result_get_cell_type_scores" { let str = [0.1, 0.1] let menv = [0.65, 0.65] let p = @src.XcellParams::new() - let r = @src.XcellResult::new( - scores, cts, cats, samps, imm, str, menv, p, - ) + let r = @src.XcellResult::new(scores, cts, cats, samps, imm, str, menv, p) let tc = r.get_cell_type_scores("T-cells") assert_eq(tc.length(), 2) assert_true((tc[0] - 0.3).abs() < 0.0001) @@ -198,11 +196,9 @@ test "xc_result_get_cell_type_scores" { assert_eq(missing.length(), 0) } +///| test "xc_result_get_sample_scores" { - let scores : Array[Array[Double]] = [ - [0.3, 0.5], - [0.8, 0.6], - ] + let scores : Array[Array[Double]] = [[0.3, 0.5], [0.8, 0.6]] let cts = ["T-cells", "B-cells"] let cats = ["immune", "immune"] let samps = ["s1", "s2"] @@ -210,9 +206,7 @@ test "xc_result_get_sample_scores" { let str = [0.1, 0.1] let menv = [0.65, 0.65] let p = @src.XcellParams::new() - let r = @src.XcellResult::new( - scores, cts, cats, samps, imm, str, menv, p, - ) + let r = @src.XcellResult::new(scores, cts, cats, samps, imm, str, menv, p) let s1 = r.get_sample_scores("s1") assert_eq(s1.length(), 2) assert_true((s1[0] - 0.3).abs() < 0.0001) @@ -221,6 +215,7 @@ test "xc_result_get_sample_scores" { assert_eq(s_missing.length(), 0) } +///| test "xc_result_get_top_cell_types" { let scores : Array[Array[Double]] = [ [0.1, 0.9], @@ -235,9 +230,7 @@ test "xc_result_get_top_cell_types" { let str = [0.1, 0.1] let menv = [0.6, 0.65] let p = @src.XcellParams::new() - let r = @src.XcellResult::new( - scores, cts, cats, samps, imm, str, menv, p, - ) + let r = @src.XcellResult::new(scores, cts, cats, samps, imm, str, menv, p) // For s1, top is C=0.9, then B=0.5 let top_s1 = r.get_top_cell_types("s1", 2) assert_eq(top_s1.length(), 2) @@ -251,12 +244,9 @@ test "xc_result_get_top_cell_types" { assert_eq(top_s2[0].0, "A") } +///| test "xc_result_scores_by_category" { - let scores : Array[Array[Double]] = [ - [0.5, 0.7], - [0.3, 0.4], - [0.9, 0.8], - ] + let scores : Array[Array[Double]] = [[0.5, 0.7], [0.3, 0.4], [0.9, 0.8]] let cts = ["T", "B", "Fibro"] let cats = ["immune", "immune", "stromal"] let samps = ["s1", "s2"] @@ -264,9 +254,7 @@ test "xc_result_scores_by_category" { let str = [0.9, 0.8] let menv = [1.3, 1.35] let p = @src.XcellParams::new() - let r = @src.XcellResult::new( - scores, cts, cats, samps, imm, str, menv, p, - ) + let r = @src.XcellResult::new(scores, cts, cats, samps, imm, str, menv, p) let by_cat = r.scores_by_category() // "immune" average of T and B for s1: (0.5+0.3)/2 = 0.4 let imm_opt = by_cat.get("immune") diff --git a/test/moonbit/xdna_io_test.mbt b/test/moonbit/xdna_io_test.mbt index ece78f56..a533546f 100644 --- a/test/moonbit/xdna_io_test.mbt +++ b/test/moonbit/xdna_io_test.mbt @@ -36,13 +36,19 @@ test "xdna_seq_type_from_int_round_trip" { let rna = @src.XdnaSeqType::from_int(1) let protein = @src.XdnaSeqType::from_int(2) let unknown = @src.XdnaSeqType::from_int(3) - assert_true(@src.XdnaSeqType::from_int(dna.to_int()) is @src.XdnaSeqType::DnaType) - assert_true(@src.XdnaSeqType::from_int(rna.to_int()) is @src.XdnaSeqType::RnaType) assert_true( - @src.XdnaSeqType::from_int(protein.to_int()) is @src.XdnaSeqType::ProteinType, + @src.XdnaSeqType::from_int(dna.to_int()) is @src.XdnaSeqType::DnaType, ) assert_true( - @src.XdnaSeqType::from_int(unknown.to_int()) is @src.XdnaSeqType::UnknownType, + @src.XdnaSeqType::from_int(rna.to_int()) is @src.XdnaSeqType::RnaType, + ) + assert_true( + @src.XdnaSeqType::from_int(protein.to_int()) + is @src.XdnaSeqType::ProteinType, + ) + assert_true( + @src.XdnaSeqType::from_int(unknown.to_int()) + is @src.XdnaSeqType::UnknownType, ) } @@ -160,19 +166,27 @@ test "xdna_file_new_is_empty" { ///| test "xdna_file_add_record_and_n_records" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("a", "ACGT", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("a", "ACGT", @src.XdnaSeqType::from_int(0), ""), + ) assert_eq(file.n_records(), 1) - file.add_record(@src.XdnaRecord::new("b", "TTTT", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("b", "TTTT", @src.XdnaSeqType::from_int(0), ""), + ) assert_eq(file.n_records(), 2) } ///| test "xdna_file_records_returns_copy" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("a", "ACGT", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("a", "ACGT", @src.XdnaSeqType::from_int(0), ""), + ) let recs = file.records() // Mutating the returned array should not affect the file. - recs.push(@src.XdnaRecord::new("x", "GGGG", @src.XdnaSeqType::from_int(0), "")) + recs.push( + @src.XdnaRecord::new("x", "GGGG", @src.XdnaSeqType::from_int(0), ""), + ) assert_eq(file.n_records(), 1) assert_eq(recs.length(), 2) } @@ -180,8 +194,12 @@ test "xdna_file_records_returns_copy" { ///| test "xdna_file_records_access" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("seq1", "ATGC", @src.XdnaSeqType::from_int(0), "")) - file.add_record(@src.XdnaRecord::new("seq2", "GATTACA", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("seq1", "ATGC", @src.XdnaSeqType::from_int(0), ""), + ) + file.add_record( + @src.XdnaRecord::new("seq2", "GATTACA", @src.XdnaSeqType::from_int(0), ""), + ) let recs = file.records() assert_eq(recs[0].name(), "seq1") assert_eq(recs[0].sequence(), "ATGC") @@ -350,8 +368,12 @@ test "xdna_read_u32_be_at_offset" { ///| test "xdna_to_bytes_from_bytes_round_trip_dna" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("seq1", "ATGCATGC", @src.XdnaSeqType::from_int(0), "")) - file.add_record(@src.XdnaRecord::new("seq2", "GATTACA", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("seq1", "ATGCATGC", @src.XdnaSeqType::from_int(0), ""), + ) + file.add_record( + @src.XdnaRecord::new("seq2", "GATTACA", @src.XdnaSeqType::from_int(0), ""), + ) let bytes = @src.xdna_to_bytes(file) let file2 = @src.xdna_from_bytes(bytes) assert_eq(file2.n_records(), 2) @@ -367,7 +389,12 @@ test "xdna_to_bytes_from_bytes_round_trip_dna" { test "xdna_to_bytes_from_bytes_round_trip_with_annotations" { let file = @src.XdnaFile::new() file.add_record( - @src.XdnaRecord::new("annot1", "ATGC", @src.XdnaSeqType::from_int(0), "some annotation"), + @src.XdnaRecord::new( + "annot1", + "ATGC", + @src.XdnaSeqType::from_int(0), + "some annotation", + ), ) let bytes = @src.xdna_to_bytes(file) let file2 = @src.xdna_from_bytes(bytes) @@ -382,7 +409,9 @@ test "xdna_to_bytes_from_bytes_round_trip_with_annotations" { test "xdna_to_bytes_from_bytes_round_trip_rna" { // RNA sequences are stored as raw ASCII (not 2-bit packed). let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("rna1", "AUGCAUGC", @src.XdnaSeqType::from_int(1), "")) + file.add_record( + @src.XdnaRecord::new("rna1", "AUGCAUGC", @src.XdnaSeqType::from_int(1), ""), + ) let bytes = @src.xdna_to_bytes(file) let file2 = @src.xdna_from_bytes(bytes) assert_eq(file2.n_records(), 1) @@ -395,7 +424,9 @@ test "xdna_to_bytes_from_bytes_round_trip_rna" { ///| test "xdna_to_bytes_from_bytes_round_trip_protein" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("prot1", "MKLVGV", @src.XdnaSeqType::from_int(2), "")) + file.add_record( + @src.XdnaRecord::new("prot1", "MKLVGV", @src.XdnaSeqType::from_int(2), ""), + ) let bytes = @src.xdna_to_bytes(file) let file2 = @src.xdna_from_bytes(bytes) assert_eq(file2.n_records(), 1) @@ -408,7 +439,9 @@ test "xdna_to_bytes_from_bytes_round_trip_protein" { ///| test "xdna_to_bytes_includes_checksum" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("seq1", "ATGC", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("seq1", "ATGC", @src.XdnaSeqType::from_int(0), ""), + ) let bytes = @src.xdna_to_bytes(file) // The last 4 bytes are the checksum (big-endian u32). let checksum = @src.xdna_read_u32_be(bytes, bytes.length() - 4) @@ -423,7 +456,9 @@ test "xdna_to_bytes_includes_checksum" { ///| test "xdna_from_bytes_preserves_version" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("seq1", "ATGC", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("seq1", "ATGC", @src.XdnaSeqType::from_int(0), ""), + ) let bytes = @src.xdna_to_bytes(file) let file2 = @src.xdna_from_bytes(bytes) assert_eq(file2.version(), 1) @@ -436,7 +471,9 @@ test "xdna_from_bytes_preserves_version" { ///| test "xdna_write_produces_lowercase_hex" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("A", "ATGC", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("A", "ATGC", @src.XdnaSeqType::from_int(0), ""), + ) let hex = @src.xdna_write(file) // Every character must be a lowercase hex digit. for c in hex { @@ -450,8 +487,12 @@ test "xdna_write_produces_lowercase_hex" { ///| test "xdna_write_read_round_trip" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("seq1", "ATGCATGC", @src.XdnaSeqType::from_int(0), "")) - file.add_record(@src.XdnaRecord::new("seq2", "GATTACA", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("seq1", "ATGCATGC", @src.XdnaSeqType::from_int(0), ""), + ) + file.add_record( + @src.XdnaRecord::new("seq2", "GATTACA", @src.XdnaSeqType::from_int(0), ""), + ) let hex = @src.xdna_write(file) let file2 = @src.xdna_read(hex) assert_eq(file2.n_records(), 2) @@ -466,7 +507,12 @@ test "xdna_write_read_round_trip" { test "xdna_write_read_round_trip_with_annotations" { let file = @src.XdnaFile::new() file.add_record( - @src.XdnaRecord::new("a1", "GGGG", @src.XdnaSeqType::from_int(0), "note here"), + @src.XdnaRecord::new( + "a1", + "GGGG", + @src.XdnaSeqType::from_int(0), + "note here", + ), ) let hex = @src.xdna_write(file) let file2 = @src.xdna_read(hex) @@ -482,7 +528,12 @@ test "xdna_write_read_round_trip_with_annotations" { ///| test "xdna_get_sequence_string" { - let rec = @src.XdnaRecord::new("seq1", "ATGCATGC", @src.XdnaSeqType::from_int(0), "") + let rec = @src.XdnaRecord::new( + "seq1", + "ATGCATGC", + @src.XdnaSeqType::from_int(0), + "", + ) assert_eq(@src.xdna_get_sequence_string(rec), "ATGCATGC") } @@ -499,8 +550,12 @@ test "xdna_get_sequence_string_empty" { ///| test "xdna_to_seq_records" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("seq1", "ATGCATGC", @src.XdnaSeqType::from_int(0), "")) - file.add_record(@src.XdnaRecord::new("seq2", "GATTACA", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("seq1", "ATGCATGC", @src.XdnaSeqType::from_int(0), ""), + ) + file.add_record( + @src.XdnaRecord::new("seq2", "GATTACA", @src.XdnaSeqType::from_int(0), ""), + ) let records = @src.xdna_to_seq_records(file) assert_eq(records.length(), 2) assert_eq(records[0].id, "seq1") @@ -530,7 +585,9 @@ test "xdna_from_seq_records" { ///| test "xdna_seq_records_round_trip" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("seq1", "ATGC", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("seq1", "ATGC", @src.XdnaSeqType::from_int(0), ""), + ) let records = @src.xdna_to_seq_records(file) let file2 = @src.xdna_from_seq_records(records, @src.XdnaSeqType::from_int(0)) assert_eq(file2.n_records(), 1) @@ -619,7 +676,9 @@ test "edge_case_empty_file_hex_round_trip" { ///| test "edge_case_single_record" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("only", "ACGTACGT", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("only", "ACGTACGT", @src.XdnaSeqType::from_int(0), ""), + ) let bytes = @src.xdna_to_bytes(file) let file2 = @src.xdna_from_bytes(bytes) assert_eq(file2.n_records(), 1) @@ -631,7 +690,9 @@ test "edge_case_single_record" { ///| test "edge_case_single_base" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("one", "A", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("one", "A", @src.XdnaSeqType::from_int(0), ""), + ) let bytes = @src.xdna_to_bytes(file) let file2 = @src.xdna_from_bytes(bytes) assert_eq(file2.n_records(), 1) @@ -643,7 +704,9 @@ test "edge_case_single_base" { ///| test "edge_case_single_base_hex_round_trip" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("one", "G", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("one", "G", @src.XdnaSeqType::from_int(0), ""), + ) let hex = @src.xdna_write(file) let file2 = @src.xdna_read(hex) assert_eq(file2.n_records(), 1) @@ -653,7 +716,9 @@ test "edge_case_single_base_hex_round_trip" { ///| test "edge_case_empty_sequence" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("empty", "", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("empty", "", @src.XdnaSeqType::from_int(0), ""), + ) let bytes = @src.xdna_to_bytes(file) let file2 = @src.xdna_from_bytes(bytes) assert_eq(file2.n_records(), 1) From 77ef7bae14a62142c288452c823f716ff5f698af Mon Sep 17 00:00:00 2001 From: eda Date: Fri, 7 Aug 2026 01:16:08 +0800 Subject: [PATCH 37/41] publish 0.1.7 --- README.md | 13 +++++++++++-- moon.mod | 2 +- 2 files changed, 12 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 554b275d..5fb96aa9 100644 --- a/README.md +++ b/README.md @@ -3550,6 +3550,14 @@ alignment body通过coordinate row的冒号位置确定固定列宽，支持跨p parser严格检查metadata顺序、固定列行宽、坐标方向与终点、模型维度、splice/NER长度、split codon配对和frameshift归属；公开层次查询与数组结果执行深层防御复制。42项黑盒测试覆盖wrapped blocks、正反链intron、joint intron、NER、protein/DNA翻译、5行coding模型、partial phase、特殊氨基酸、聚合及畸形输入；示例完全离线，不调用外部`exonerate`程序。 +### 292. 空间自相关统计与变差函数建模 (Bioconductor Voyager) + +实现 Bioconductor `Voyager` 的单变量、双变量与多变量空间自相关核心，矩阵统一采用 spot × feature 之外的独立向量视图。空间权重由 `voyager_weights_knn`（kNN，`k` 超过 `n-1` 时截断，距离 ties 按邻居索引稳定排序）、`voyager_weights_distance_band`（固定半径，含自身排除）或 `voyager_weights_inverse_distance`（`w_ij = 1/d^power`，可选带宽上限）从二维/三维坐标构建，并支持四种编码风格：`W` 行标准化、`B` 二值、`C` 全局标准化（总和为 1）和 `S` Caussinus–Mestre（`1/√(k_i·k_j)`）。权重矩阵以邻居索引数组的稀疏形式存储，S0/S1/S2 由 `voyager_weights_s0/s1/s2` 按定义确定性计算。 + +全局统计提供 Moran's I 和 Geary's c，均采用 Cliff–Ord (1981) 随机化期望与方差（`b2 = n·m4/m2²`），并以 Abramowitz–Stegun 正态 CDF 计算双侧 p 值；方差非正时回退为 0。局部统计覆盖 Anselin (1995) 局部 Moran's I（LISA）及 HH/HL/LH/LL 象限分类、局部 Geary's c（similar/dissimilar 分类）、Getis–Ord Gi/Gi*（`star=true` 时含自身 `w_ii=1`）及精确 Ord–Getis 随机化 z 分数与 hotspot/coldspot 分类。双变量 Lee's L 同时返回全局 L 与逐点局部 L；`voyager_multivariate_local_geary` 对多特征矩阵按每特征独立置换并汇总逐点统计。置换推断使用固定 seed 的 splitmix64 PRNG 驱动 Fisher–Yates 洗牌，p 值采用 `(extreme+1)/(perm+1)` 校正，并通过 Benjamini–Hochberg 步降控制 FDR。 + +经验变差函数将点对按等距 lag 分箱（默认上限为最大成对距离一半）并计算半方差 `γ = Σ(x_i-x_j)²/(2·n_pairs)`；`voyager_fit_variogram` 在有界 range 网格上搜索、对每个候选 range 用闭式线性最小二乘求解 (nugget, partial sill)，最小化残差平方和，支持 spherical/exponential/gaussian 三种模型，`voyager_variogram_predict` 据此预测任意距离的半方差。`voyager_correlogram` 按距离分箱逐 bin 构建行标准化权重并计算 Moran's I，自动跳过无观测对的 bin。`voyager_run_univariate_sfe` 从 `SpatialExperiment` 的 assay、`spatialCoords`、`rowData`/`colData` 提取输入，在深复制容器中把全局统计写入 `rowData`、局部统计（local estimate/FDR/quadrant）写入逐 spot `colData`，并在 metadata 记录方法与特征数，原对象保持不变；基因名按 `gene_name`→`gene_id`→`gene_N` 回退解析，三维坐标在 z 非恒定时自动启用。当前实现不依赖 R、spdep 或 sf，采用稠密成对距离与串行计算，不覆盖上游 `listw`/`nb` S4 对象、并行后端、协变量残差化与可视化层；58 项黑盒测试覆盖手算链状格点、置换确定性、FDR 单调性与 SpatialExperiment 不可变性。 + ## 性能优化 ### 优化策略 @@ -3651,8 +3659,8 @@ parser严格检查metadata顺序、固定列行宽、坐标方向与终点、模 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 12093 | -| 通过数 | 12093 | +| 总测试数 | 12151 | +| 通过数 | 12151 | | 失败数 | 0 | | 通过率 | 100% | @@ -4002,6 +4010,7 @@ moon test --update | Bioconductor spicyR | `spicyr_test.mbt` | 39 | | Bioconductor lisaClust | `lisaclust_test.mbt` | 51 | | Bioconductor SpatialDecon | `spatialdecon_test.mbt` | 60 | +| Bioconductor Voyager | `voyager_test.mbt` | 58 | | Bio.PopGen.GenePop | `gene_pop_test.mbt` | 34 | | Bioconductor stageR | `stage_r_test.mbt` | 25 | | Bioconductor EnrichedHeatmap | `enriched_heatmap_test.mbt` | 20 | diff --git a/moon.mod b/moon.mod index 1049a3c3..acd2906e 100644 --- a/moon.mod +++ b/moon.mod @@ -11,7 +11,7 @@ name = "IvanAXu/BioSeqs" -version = "0.1.6" +version = "0.1.7" readme = "README.mbt.md" From 67f1535984dbb3449c9fbb536a13f5a5ca3d5ba0 Mon Sep 17 00:00:00 2001 From: eda Date: Fri, 7 Aug 2026 10:20:30 +0800 Subject: [PATCH 38/41] chore: v0.1.8 --- README.md | 24 +- examples/voyager_demo/main.mbt | 266 ++ examples/voyager_demo/moon.pkg | 5 + moon.mod | 2 +- src/abi.mbt | 38 +- src/ace.mbt | 113 +- src/aldex2.mbt | 5 +- src/align_abstract.mbt | 199 +- src/align_analysis.mbt | 235 +- src/align_applications.mbt | 162 +- src/align_bed.mbt | 31 +- src/align_cluster.mbt | 74 +- src/alignace.mbt | 93 +- src/alignment_map.mbt | 15 +- src/alphabet.mbt | 57 +- src/ancombc.mbt | 86 +- src/application.mbt | 47 +- src/bamsignals.mbt | 379 ++- src/batchelor.mbt | 57 +- src/bayes_space.mbt | 73 +- src/bayseq.mbt | 109 +- src/beachmat.mbt | 91 +- src/binary_cif.mbt | 386 ++- src/bioc_generics.mbt | 94 +- src/bioc_neighbors.mbt | 253 +- src/bioc_parallel.mbt | 124 +- src/bioc_singular.mbt | 56 +- src/biostrings.mbt | 202 +- src/biostrings_matchdict.mbt | 114 +- src/blast_applications.mbt | 404 ++- src/bumphunter.mbt | 61 +- src/caps.mbt | 9 +- src/cellchat.mbt | 114 +- src/chain_liftover.mbt | 197 +- src/checksum.mbt | 126 +- src/chem_utils.mbt | 405 ++- src/chemminer.mbt | 92 +- src/chipseeker.mbt | 261 +- src/chromosome_visualization.mbt | 689 +++-- src/cibersort.mbt | 118 +- src/circ_seq.mbt | 162 +- src/cluster_experiment.mbt | 64 +- src/cnvkit.mbt | 240 +- src/codon_advanced.mbt | 134 +- src/compass.mbt | 72 +- src/compound.mbt | 238 +- src/consensus_cluster_plus.mbt | 133 +- src/cram_wbtest.mbt | 49 +- src/crystal.mbt | 96 +- src/csaw.mbt | 216 +- src/cyclone.mbt | 41 +- src/data.mbt | 196 +- src/decoupler.mbt | 129 +- src/delayed_matrix_stats.mbt | 6 +- src/deseq2.mbt | 182 +- src/deseq2_advanced.mbt | 25 +- src/destiny.mbt | 250 +- src/dexseq.mbt | 126 +- src/diffbind.mbt | 277 +- src/diffcyt.mbt | 83 +- src/dnashape.mbt | 5 +- src/dorothea.mbt | 67 +- src/drimseq.mbt | 422 ++- src/droplet_utils.mbt | 3 +- src/dss.mbt | 403 ++- src/dssp.mbt | 128 +- src/edaseq.mbt | 219 +- src/edger_advanced.mbt | 137 +- src/embl_io.mbt | 31 +- src/enhanced_volcano.mbt | 96 +- src/enriched_heatmap.mbt | 125 +- src/enrichplot.mbt | 343 ++- src/ensembldb.mbt | 198 +- src/estimate_score.mbt | 104 +- src/exonerate.mbt | 34 +- src/expasy.mbt | 194 +- src/factoextra.mbt | 254 +- src/fasta_search_io.mbt | 22 +- src/feature_counts.mbt | 312 +- src/file.mbt | 43 +- src/fishpond.mbt | 63 +- src/fragment_mapper.mbt | 79 +- src/freq_analysis.mbt | 92 +- src/freq_table.mbt | 34 +- src/fssp.mbt | 24 +- src/ga.mbt | 185 +- src/gage.mbt | 33 +- src/gck_io.mbt | 45 +- src/gcrma.mbt | 97 +- src/genbank_io.mbt | 9 +- src/gene_pop.mbt | 71 +- src/genefilter.mbt | 164 +- src/genesis.mbt | 135 +- src/genie3.mbt | 61 +- src/genome_diagram.mbt | 355 ++- src/genomic_ranges.mbt | 52 +- src/genomic_ranges_advanced.mbt | 33 +- src/genomic_ranges_gaps.mbt | 123 +- src/geo.mbt | 31 +- src/gfa_io.mbt | 18 +- src/gff.mbt | 171 +- src/ggtree.mbt | 118 +- src/glm_gampoi.mbt | 71 +- src/goa.mbt | 24 +- src/gosemsim.mbt | 199 +- src/graphics.mbt | 170 +- src/gsea_base.mbt | 240 +- src/gsva.mbt | 122 +- src/gviz.mbt | 246 +- src/harmony.mbt | 133 +- src/hicdc.mbt | 79 +- src/hilbertcurve.mbt | 72 +- src/hmisc.mbt | 117 +- src/hmmcopy.mbt | 66 +- src/hmmer_io.mbt | 81 +- src/hs_exposure.mbt | 62 +- src/htsfilter.mbt | 81 +- src/ig_io.mbt | 25 +- src/ihw.mbt | 60 +- src/imgt_io.mbt | 145 +- src/impute.mbt | 247 +- src/infercnv.mbt | 321 +- src/insdc_io.mbt | 108 +- src/internal_coords.mbt | 624 +++- src/interproscan.mbt | 258 +- src/iranges.mbt | 43 +- src/isoform_switch_analyze_r.mbt | 362 ++- src/jaspar.mbt | 35 +- src/karyoploter.mbt | 173 +- src/kgml.mbt | 80 +- src/kmer.mbt | 67 +- src/limma.mbt | 80 +- src/lisaclust.mbt | 194 +- src/logistic_regression.mbt | 39 +- src/lowess.mbt | 18 +- src/ma_align.mbt | 228 +- src/maf.mbt | 181 +- src/maftools.mbt | 278 +- src/markov.mbt | 69 +- src/mast_motif.mbt | 13 +- src/matrix.mbt | 151 +- src/matrix_generics.mbt | 12 +- src/mauve.mbt | 218 +- src/max_entropy.mbt | 43 +- src/mcp_counter.mbt | 61 +- src/melting_temp.mbt | 25 +- src/meme.mbt | 37 +- src/metagenomeseq.mbt | 117 +- src/methyl_seekr.mbt | 61 +- src/methylkit.mbt | 66 +- src/microbiome.mbt | 300 +- src/missmethyl.mbt | 73 +- src/mix_omics.mbt | 49 +- src/mmcifio.mbt | 18 +- src/mmtf.mbt | 244 +- src/mofa2.mbt | 193 +- src/mol_wt.mbt | 66 +- src/monocle3.mbt | 69 +- src/motif_scan.mbt | 79 +- src/motifs.mbt | 107 +- src/motifs_advanced.mbt | 185 +- src/ms_core_utils.mbt | 28 +- src/msnbase.mbt | 276 +- src/msstats.mbt | 134 +- src/muscat.mbt | 63 +- src/mutational_patterns.mbt | 53 +- src/naccess.mbt | 154 +- src/naive_bayes.mbt | 81 +- src/nanostring.mbt | 146 +- src/neural_network.mbt | 34 +- src/nib_io.mbt | 17 +- src/nmr.mbt | 101 +- src/noiseq.mbt | 76 +- src/nucle_r.mbt | 311 +- src/open_cyto.mbt | 80 +- src/pairaligner.mbt | 140 +- src/pairwise2.mbt | 79 +- src/paml.mbt | 214 +- src/parsimony.mbt | 40 +- src/pathway.mbt | 56 +- src/pcatools.mbt | 231 +- src/pcd.mbt | 116 +- src/pdb_analysis.mbt | 79 +- src/pdb_dice.mbt | 174 +- src/pdb_header.mbt | 99 +- src/pdb_list.mbt | 51 +- src/pdb_packing.mbt | 71 +- src/pdb_seqio.mbt | 45 +- src/pdb_vectors.mbt | 388 ++- src/peak_calling.mbt | 63 +- src/phd.mbt | 43 +- src/pheatmap.mbt | 312 +- src/phenotype.mbt | 254 +- src/phylo_cdao.mbt | 121 +- src/phylo_consensus.mbt | 235 +- src/phylo_nexml.mbt | 179 +- src/phylo_xml.mbt | 126 +- src/phyloseq.mbt | 116 +- src/pir_io.mbt | 14 +- src/plyranges.mbt | 308 +- src/polypeptide.mbt | 324 ++- src/popgen_advanced.mbt | 261 +- src/preprocess_core.mbt | 136 +- src/primer3.mbt | 171 +- src/prosite.mbt | 208 +- src/prot_dao.mbt | 181 +- src/protein_analysis.mbt | 86 +- src/proteomics.mbt | 226 +- src/psea.mbt | 105 +- src/qcp_superimposer.mbt | 283 +- src/qfeatures.mbt | 81 +- src/qvalue.mbt | 36 +- src/ragged_experiment.mbt | 210 +- src/reduced.mbt | 35 +- src/reference.mbt | 91 +- src/reporting_tools.mbt | 86 +- src/residue_depth.mbt | 201 +- src/rhdf5.mbt | 105 +- src/rna_structure.mbt | 125 +- src/rstatix.mbt | 329 ++- src/rtsne.mbt | 160 +- src/s4vectors.mbt | 99 +- src/sasa.mbt | 4 +- src/sc3.mbt | 186 +- src/sc_dbl_finder.mbt | 8 +- src/scenic.mbt | 311 +- src/scmap.mbt | 62 +- src/scnorm.mbt | 218 +- src/scop.mbt | 37 +- src/searchio.mbt | 445 ++- src/seq.mbt | 10 +- src/seq_approx.mbt | 63 +- src/seq_complexity.mbt | 2 +- src/seq_location.mbt | 163 +- src/seq_quality_trim.mbt | 98 +- src/seq_utils.mbt | 81 +- src/seqfeature_advanced.mbt | 86 +- src/seqlogo.mbt | 87 +- src/seqxml_io.mbt | 65 +- src/seurat.mbt | 273 +- src/sff_io.mbt | 96 +- src/sgseq.mbt | 165 +- src/single_r.mbt | 267 +- src/singscore.mbt | 96 +- src/slingshot.mbt | 360 ++- src/smart.mbt | 85 +- src/snapgene_io.mbt | 114 +- src/spatial_experiment.mbt | 119 +- src/spia.mbt | 83 +- src/stage_r.mbt | 38 +- src/statistics.mbt | 543 +++- src/stockholm.mbt | 78 +- src/structural_variant.mbt | 110 +- src/structure_alignment.mbt | 299 +- src/substitution_matrices.mbt | 477 +-- src/survival.mbt | 74 +- src/system_piper.mbt | 151 +- src/tab_io.mbt | 14 +- src/taxonomy.mbt | 252 +- src/topgo.mbt | 207 +- src/tradeseq.mbt | 367 ++- src/transfac.mbt | 35 +- src/trie.mbt | 46 +- src/twobit_io.mbt | 46 +- src/uniprot_io.mbt | 23 +- src/universalmotif.mbt | 27 +- src/utils.mbt | 4 +- src/uwot.mbt | 221 +- src/variance_partition.mbt | 14 +- src/variant_filtering.mbt | 397 ++- src/variation.mbt | 342 ++- src/vcf.mbt | 4 +- src/velociraptor.mbt | 37 +- src/venn_diagram.mbt | 99 +- src/voyager.mbt | 2581 +++++++++++++++++ src/vsn.mbt | 213 +- src/wise.mbt | 160 +- src/xcell.mbt | 415 +-- src/xdna_io.mbt | 20 +- test/moonbit/ace_test.mbt | 92 +- test/moonbit/align_abstract_test.mbt | 154 +- test/moonbit/align_analysis_test.mbt | 15 + test/moonbit/align_applications_test.mbt | 8 +- test/moonbit/align_bed_test.mbt | 151 +- test/moonbit/align_cluster_test.mbt | 2 +- test/moonbit/alignace_test.mbt | 156 +- test/moonbit/alphabet_test.mbt | 8 + test/moonbit/ancombc_test.mbt | 12 +- test/moonbit/apeglm_test.mbt | 248 +- test/moonbit/application_test.mbt | 7 +- test/moonbit/aucell_test.mbt | 16 +- test/moonbit/bamsignals_test.mbt | 4 +- test/moonbit/batchelor_test.mbt | 95 +- test/moonbit/bayes_space_test.mbt | 145 +- test/moonbit/bayseq_test.mbt | 19 +- test/moonbit/beachmat_test.mbt | 76 +- test/moonbit/binary_cif_test.mbt | 146 +- test/moonbit/bio_seq_test.mbt | 16 + test/moonbit/bioc_generics_test.mbt | 30 +- test/moonbit/bioc_neighbors_test.mbt | 225 +- test/moonbit/bioc_parallel_test.mbt | 12 +- test/moonbit/bioc_singular_test.mbt | 9 +- test/moonbit/biostrings_matchdict_test.mbt | 83 +- test/moonbit/blast_applications_test.mbt | 4 +- test/moonbit/bsseq_test.mbt | 5 +- test/moonbit/bumphunter_test.mbt | 54 +- test/moonbit/caps_test.mbt | 45 +- test/moonbit/cellchat_test.mbt | 129 +- test/moonbit/chain_liftover_test.mbt | 18 +- test/moonbit/checksum_test.mbt | 2 +- .../moonbit/chromosome_visualization_test.mbt | 85 +- test/moonbit/cibersort_test.mbt | 33 +- test/moonbit/circ_seq_test.mbt | 2 +- test/moonbit/cluster_experiment_test.mbt | 24 +- test/moonbit/cnvkit_test.mbt | 127 +- test/moonbit/codon_advanced_test.mbt | 35 +- test/moonbit/compass_test.mbt | 70 +- test/moonbit/compound_test.mbt | 4 +- test/moonbit/consensus_cluster_plus_test.mbt | 39 +- test/moonbit/crystal_test.mbt | 32 +- test/moonbit/csaw_test.mbt | 10 +- test/moonbit/cyclone_test.mbt | 36 +- test/moonbit/decoupler_test.mbt | 134 +- test/moonbit/delayed_matrix_stats_test.mbt | 100 +- test/moonbit/deseq2_test.mbt | 42 +- test/moonbit/destiny_test.mbt | 48 +- test/moonbit/dexseq_test.mbt | 5 +- test/moonbit/diffcyt_test.mbt | 26 +- test/moonbit/dnashape_test.mbt | 10 +- test/moonbit/dorothea_test.mbt | 80 +- test/moonbit/drimseq_test.mbt | 154 +- test/moonbit/dss_test.mbt | 2 +- test/moonbit/dssp_test.mbt | 2 +- test/moonbit/edaseq_test.mbt | 28 +- test/moonbit/edger_advanced_test.mbt | 14 +- test/moonbit/enhanced_volcano_test.mbt | 138 +- test/moonbit/enriched_heatmap_test.mbt | 7 +- test/moonbit/enrichplot_test.mbt | 103 +- test/moonbit/ensembldb_test.mbt | 8 +- test/moonbit/estimate_score_test.mbt | 101 +- test/moonbit/exonerate_test.mbt | 4 +- test/moonbit/expasy_test.mbt | 18 +- test/moonbit/factoextra_test.mbt | 91 +- test/moonbit/feature_counts_test.mbt | 119 +- test/moonbit/file_test.mbt | 6 +- test/moonbit/fishpond_test.mbt | 131 +- test/moonbit/fragment_mapper_test.mbt | 16 +- test/moonbit/freq_analysis_test.mbt | 21 +- test/moonbit/freq_table_test.mbt | 5 +- test/moonbit/fssp_test.mbt | 36 +- test/moonbit/ga_test.mbt | 30 +- test/moonbit/gck_io_test.mbt | 97 +- test/moonbit/gcrma_test.mbt | 63 +- test/moonbit/genefilter_test.mbt | 43 +- test/moonbit/genesis_test.mbt | 30 +- test/moonbit/genie3_test.mbt | 18 +- test/moonbit/genome_diagram_test.mbt | 174 +- test/moonbit/genomic_ranges_advanced_test.mbt | 35 +- test/moonbit/genomic_ranges_gaps_test.mbt | 136 +- test/moonbit/geo_test.mbt | 40 +- test/moonbit/gfa_io_test.mbt | 191 +- test/moonbit/gff_test.mbt | 27 +- test/moonbit/ggtree_test.mbt | 16 +- test/moonbit/glm_gampoi_test.mbt | 377 +-- test/moonbit/goa_test.mbt | 99 +- test/moonbit/gosemsim_test.mbt | 98 +- test/moonbit/graphics_test.mbt | 15 +- test/moonbit/gsea_base_test.mbt | 7 +- test/moonbit/gsva_test.mbt | 8 +- test/moonbit/gviz_test.mbt | 142 +- test/moonbit/harmony_test.mbt | 34 +- test/moonbit/hicdc_test.mbt | 47 +- test/moonbit/hilbertcurve_test.mbt | 6 +- test/moonbit/hmisc_test.mbt | 140 +- test/moonbit/hmmcopy_test.mbt | 28 +- test/moonbit/hs_exposure_test.mbt | 10 +- test/moonbit/htsfilter_test.mbt | 19 +- test/moonbit/ig_io_test.mbt | 4 +- test/moonbit/ihw_test.mbt | 27 +- test/moonbit/imgt_io_test.mbt | 189 +- test/moonbit/impute_test.mbt | 43 +- test/moonbit/infercnv_test.mbt | 107 +- test/moonbit/insdc_io_test.mbt | 25 +- test/moonbit/internal_coords_test.mbt | 36 +- test/moonbit/interproscan_test.mbt | 311 +- .../moonbit/isoform_switch_analyze_r_test.mbt | 137 +- test/moonbit/karyoploter_test.mbt | 84 +- test/moonbit/kgml_test.mbt | 20 + test/moonbit/kmer_test.mbt | 11 +- test/moonbit/limma_test.mbt | 21 +- test/moonbit/lisaclust_test.mbt | 73 +- test/moonbit/lowess_test.mbt | 14 +- test/moonbit/ma_align_test.mbt | 104 +- test/moonbit/maf_test.mbt | 62 +- test/moonbit/maftools_test.mbt | 298 +- test/moonbit/markov_test.mbt | 37 +- test/moonbit/matrix_generics_test.mbt | 208 +- test/moonbit/matrix_test.mbt | 33 +- test/moonbit/mauve_test.mbt | 142 +- test/moonbit/mcp_counter_test.mbt | 96 +- test/moonbit/melting_temp_test.mbt | 2 +- test/moonbit/meme_test.mbt | 21 +- test/moonbit/metagenomeseq_test.mbt | 9 +- test/moonbit/methyl_seekr_test.mbt | 95 +- test/moonbit/methylkit_test.mbt | 20 +- test/moonbit/microbiome_test.mbt | 68 +- test/moonbit/missmethyl_test.mbt | 50 +- test/moonbit/mix_omics_test.mbt | 114 +- test/moonbit/mmcifio_test.mbt | 126 +- test/moonbit/mmtf_test.mbt | 25 +- test/moonbit/mofa2_test.mbt | 46 +- test/moonbit/monocle3_test.mbt | 64 +- test/moonbit/moon.pkg | 2 +- test/moonbit/motif_scan_test.mbt | 51 +- test/moonbit/motifs_advanced_test.mbt | 62 +- test/moonbit/ms_core_utils_test.mbt | 121 +- test/moonbit/msf_test.mbt | 108 +- test/moonbit/msnbase_test.mbt | 204 +- test/moonbit/msstats_test.mbt | 123 +- test/moonbit/muscat_test.mbt | 23 +- test/moonbit/naccess_test.mbt | 51 +- test/moonbit/naive_bayes_test.mbt | 41 +- test/moonbit/nanostring_test.mbt | 26 +- test/moonbit/nib_io_test.mbt | 8 +- test/moonbit/nmr_test.mbt | 8 +- test/moonbit/noiseq_test.mbt | 17 +- test/moonbit/nucle_r_test.mbt | 15 +- test/moonbit/open_cyto_test.mbt | 55 +- test/moonbit/pairaligner_test.mbt | 42 +- test/moonbit/pairwise2_test.mbt | 6 +- test/moonbit/paml_test.mbt | 17 +- test/moonbit/parsimony_test.mbt | 10 +- test/moonbit/pathway_test.mbt | 14 +- test/moonbit/pcatools_test.mbt | 47 +- test/moonbit/pcd_test.mbt | 14 + test/moonbit/pdb_analysis_test.mbt | 4 +- test/moonbit/pdb_dice_test.mbt | 136 +- test/moonbit/pdb_header_test.mbt | 19 +- test/moonbit/pdb_list_test.mbt | 7 +- test/moonbit/pdb_packing_test.mbt | 84 +- test/moonbit/pdb_seqio_test.mbt | 27 +- test/moonbit/pdb_vectors_test.mbt | 62 +- test/moonbit/peak_calling_test.mbt | 255 +- test/moonbit/phd_test.mbt | 28 +- test/moonbit/pheatmap_test.mbt | 78 +- test/moonbit/phylo_cdao_test.mbt | 21 +- test/moonbit/phylo_consensus_test.mbt | 18 +- test/moonbit/phylo_nexml_test.mbt | 7 +- test/moonbit/phylo_xml_debug_test.mbt | 3 +- test/moonbit/phylo_xml_test.mbt | 95 +- test/moonbit/phyloseq_test.mbt | 7 +- test/moonbit/plyranges_test.mbt | 54 +- test/moonbit/polypeptide_test.mbt | 6 +- test/moonbit/popgen_advanced_test.mbt | 42 +- test/moonbit/preprocess_core_test.mbt | 80 +- test/moonbit/progeny_test.mbt | 57 +- test/moonbit/prosite_test.mbt | 22 +- test/moonbit/prot_dao_test.mbt | 151 +- test/moonbit/protein_analysis_test.mbt | 19 + test/moonbit/proteomics_test.mbt | 8 +- test/moonbit/psea_test.mbt | 2 +- test/moonbit/qfeatures_test.mbt | 125 +- test/moonbit/qvalue_test.mbt | 11 +- test/moonbit/ragged_experiment_test.mbt | 335 ++- .../ranged_summarized_experiment_test.mbt | 145 +- test/moonbit/reference_test.mbt | 150 +- test/moonbit/reporting_tools_test.mbt | 67 +- test/moonbit/residue_depth_test.mbt | 10 +- test/moonbit/rhdf5_test.mbt | 36 +- test/moonbit/rna_structure_test.mbt | 16 +- test/moonbit/rstatix_test.mbt | 128 +- test/moonbit/rtsne_test.mbt | 31 +- test/moonbit/s4vectors_test.mbt | 22 +- test/moonbit/sasa_test.mbt | 20 +- test/moonbit/sc3_test.mbt | 63 +- test/moonbit/scenic_test.mbt | 213 +- test/moonbit/scmap_test.mbt | 27 +- test/moonbit/scnorm_test.mbt | 6 +- test/moonbit/scop_test.mbt | 46 +- test/moonbit/searchio_new_test.mbt | 383 ++- test/moonbit/seq_complexity_test.mbt | 12 +- test/moonbit/seq_location_test.mbt | 220 +- test/moonbit/seq_quality_trim_test.mbt | 85 +- test/moonbit/seqfeature_advanced_test.mbt | 2 +- test/moonbit/seqio_advanced_test.mbt | 46 +- test/moonbit/seqlogo_test.mbt | 176 +- test/moonbit/seqxml_io_test.mbt | 87 +- test/moonbit/seurat_test.mbt | 57 +- test/moonbit/sff_io_test.mbt | 9 +- test/moonbit/sgseq_test.mbt | 18 +- test/moonbit/single_r_test.mbt | 79 +- test/moonbit/singscore_test.mbt | 12 +- test/moonbit/slingshot_test.mbt | 14 +- test/moonbit/smart_test.mbt | 17 +- test/moonbit/snapgene_io_test.mbt | 28 +- test/moonbit/spatial_experiment_test.mbt | 6 +- test/moonbit/spia_test.mbt | 6 +- test/moonbit/stage_r_test.mbt | 70 +- test/moonbit/statistics_test.mbt | 54 +- test/moonbit/stockholm_test.mbt | 62 +- test/moonbit/structural_variant_test.mbt | 102 +- test/moonbit/structure_alignment_test.mbt | 8 +- test/moonbit/substitution_matrices_test.mbt | 102 +- test/moonbit/survival_test.mbt | 9 +- test/moonbit/system_piper_test.mbt | 31 +- test/moonbit/taxonomy_test.mbt | 18 +- test/moonbit/topgo_test.mbt | 24 +- test/moonbit/tradeseq_test.mbt | 85 +- test/moonbit/trie_test.mbt | 4 +- test/moonbit/twobit_io_test.mbt | 8 +- test/moonbit/uniprot_io_test.mbt | 16 +- test/moonbit/universalmotif_test.mbt | 18 +- test/moonbit/uwot_test.mbt | 34 +- test/moonbit/variant_filtering_test.mbt | 102 +- test/moonbit/variation_test.mbt | 2 +- test/moonbit/velociraptor_test.mbt | 57 +- test/moonbit/venn_diagram_test.mbt | 250 +- test/moonbit/voyager_test.mbt | 1130 ++++++++ test/moonbit/vsn_test.mbt | 24 +- test/moonbit/wise_test.mbt | 88 +- test/moonbit/xcell_test.mbt | 98 +- test/moonbit/xdna_io_test.mbt | 123 +- 522 files changed, 38214 insertions(+), 18782 deletions(-) create mode 100644 examples/voyager_demo/main.mbt create mode 100644 examples/voyager_demo/moon.pkg create mode 100644 src/voyager.mbt create mode 100644 test/moonbit/voyager_test.mbt diff --git a/README.md b/README.md index b7b29bb4..5fb96aa9 100644 --- a/README.md +++ b/README.md @@ -244,6 +244,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **dreamlet** | Bioconductor dreamlet | sample×cell-type pseudobulk、TMM、cell/sample/gene过滤、logCPM、Poisson/voom precision weights、分cell-type重复测量模型及study-wide FDR | ✅ | | **nnSVG** | Bioconductor nnSVG | nearest-neighbor Gaussian process、空间变异基因检验、gene-specific length scale、协变量设计、空间方差占比、BH-FDR及SpatialExperiment接入 | ✅ | | **Banksy** | Bioconductor Banksy | H0邻域均值与H1+方位harmonic、六类空间核、lambda联合特征、分组标准化、PCA、多起点k-means、标签平滑、参数扫描及SpatialExperiment接入 | ✅ | +| **Voyager** | Bioconductor Voyager | kNN/distance-band/inverse-distance空间权重(W/B/C/S编码)、全局Moran's I与Geary's c(Cliff-Ord随机化期望/方差/正态p)、局部Moran's I(LISA象限+置换推断)、局部Geary's c、Getis-Ord Gi/Gi*(Ord-Getis z)、Lee's L(全局+局部)、多元局部Geary、经验变差函数与spherical/exponential/gaussian拟合、Moran correlogram、确定性splitmix64置换、BH-FDR及SpatialExperiment不可变写回 | ✅ | | **spicyR** | Bioconductor spicyR | 有序细胞类型对cross-L曲线、矩形窗口边界校正、图像级共定位统计、precision weights、重复受试者随机截距、条件对比、BH-FDR及SpatialExperiment接入 | ✅ | | **lisaClust** | Bioconductor lisaClust | 每细胞多类型local-K/centered local-L曲线、Gaussian KDE强度校正、矩形/凸包窗口、圆盘边界修正、确定性多起点k-means、silhouette、区域富集及SpatialExperiment写回 | ✅ | | **SpatialDecon** | Bioconductor SpatialDecon | 背景感知加权log-normal非负回归、两阶段异常点重拟合、Hessian不确定度、细胞丰度/比例/计数尺度、cell-type collapse、reverse deconvolution、负探针背景、单细胞profile构建及SpatialExperiment写回 | ✅ | @@ -671,6 +672,7 @@ IvanAXu/BioSeqs/ │ ├── dreamlet.mbt # dreamlet pseudobulk、TMM/voom权重、分cell-type混合模型与study-wide FDR │ ├── nnsvg.mbt # nnSVG nearest-neighbor GP、空间变异检验、length scale与SpatialExperiment接入 │ ├── banksy.mbt # Banksy空间邻域harmonic、lambda联合特征、PCA、聚类、平滑与SpatialExperiment接入 +│ ├── voyager.mbt # Voyager空间自相关：kNN/distance-band/inverse-distance权重、Moran's I/Geary's c(全局+局部)、Getis-Ord Gi*、Lee's L、变差函数拟合、Moran correlogram、置换检验BH-FDR与SpatialExperiment接入 │ ├── spicyr.mbt # spicyR cross-L共定位、边界校正、加权/随机截距模型与SpatialExperiment接入 │ ├── lisaclust.mbt # lisaClust local-K/L曲线、KDE、窗口边界修正、区域聚类与SpatialExperiment接入 │ ├── spatialdecon.mbt # SpatialDecon背景感知log-normal解卷积、异常点重拟合、不确定度与容器接入 @@ -1043,6 +1045,7 @@ IvanAXu/BioSeqs/ │ ├── dreamlet_demo/ # dreamlet SCE pseudobulk、TMM/voom、donor随机截距与跨cell-type FDR示例 │ ├── nnsvg_demo/ # nnSVG空间变异基因、length scale、过滤与SpatialExperiment接入示例 │ ├── banksy_demo/ # Banksy H0/H1、lambda扫描、PCA聚类、平滑与SpatialExperiment接入示例 +│ ├── voyager_demo/ # Voyager空间权重、Moran/Geary/Getis-Ord/Lee's L、变差函数、correlogram与SpatialExperiment接入示例 │ ├── spicyr_demo/ # spicyR cross-L、条件对比、重复受试者模型与SpatialExperiment接入示例 │ ├── lisaclust_demo/ # lisaClust local-K/L、区域聚类、富集与SpatialExperiment写回示例 │ ├── spatialdecon_demo/ # SpatialDecon背景校正、丰度/计数、collapse、reverse与SpatialExperiment示例 @@ -1490,6 +1493,7 @@ IvanAXu/BioSeqs/ │ │ ├── dreamlet_test.mbt │ │ ├── nnsvg_test.mbt │ │ ├── banksy_test.mbt +│ │ ├── voyager_test.mbt │ │ ├── shared_reference_alignment_test.mbt │ │ ├── alignment_map_test.mbt │ │ ├── alignment_counts_test.mbt @@ -1691,7 +1695,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 12093 个测试全部通过 +moon test # ✅ 12151 个测试全部通过 ``` ### 模块对照表 @@ -1823,6 +1827,7 @@ moon test # ✅ 12093 个测试全 | `dreamlet.mbt` | Bioconductor dreamlet | sample×cell-type pseudobulk、完整TMM、CPM/logCPM、Poisson/voom权重、typed fixed/random design、分cell-type dream拟合及两级BH-FDR | | `nnsvg.mbt` | Bioconductor nnSVG | 坐标缩放与前驱kNN、指数协方差NNGP、协变量GLS、profile ML、空间/非空间LR检验、gene-specific length scale、BH-FDR及SpatialExperiment接入 | | `banksy.mbt` | Bioconductor Banksy | H0邻域均值、H1+方位Fourier/Gabor harmonic、六类空间核、lambda联合矩阵、分组标准化、PCA、多起点k-means、平滑、ARI与SpatialExperiment接入 | +| `voyager.mbt` | Bioconductor Voyager | kNN/distance-band/inverse-distance权重(W/B/C/S编码)、全局Moran's I与Geary's c(Cliff-Ord随机化期望/方差/正态p)、局部Moran's I(LISA象限分类+置换推断)、局部Geary's c、Getis-Ord Gi/Gi*(Ord-Getis z)、Lee's L(全局+局部)、多元局部Geary、经验变差函数与spherical/exponential/gaussian拟合、Moran correlogram、确定性splitmix64置换、BH-FDR与SpatialExperiment不可变写回 | | `spicyr.mbt` | Bioconductor spicyR | 图像内有序细胞类型对cross-L、矩形窗口边界校正、图像级统计、cell-count precision weights、加权固定/随机截距模型、条件对比、BH-FDR及SpatialExperiment接入 | | `lisaclust.mbt` | Bioconductor lisaClust | 每图像local-K/centered local-L、Gaussian KDE密度权重、矩形/凸包窗口、圆盘可见面积边界修正、确定性多起点k-means、silhouette、区域富集及SpatialExperiment写回 | | `spatialdecon.mbt` | Bioconductor SpatialDecon | 背景感知加权log-normal非负回归、两阶段异常点重拟合、observed/expected Hessian协方差、细胞丰度尺度、cell-type collapse、reverse deconvolution、负探针背景、单细胞profile与SpatialExperiment接入 | @@ -2069,6 +2074,7 @@ moon test # ✅ 12093 个测试全 | `dreamlet.mbt` | `dreamlet` | SCE到sample×cluster pseudobulk、TMM/logCPM、两阶段voom precision weights、固定/随机效应筛选、逐cell-type dream和study-wide FDR | | `nnsvg.mbt` | `nnSVG` | AMMD/坐标和排序前驱kNN、指数协方差NNGP、covariate GLS、空间方差比例与length scale优化、LR/p-value/BH-FDR、过滤和SpatialExperiment rowData输出 | | `banksy.mbt` | `Banksy` | kNN/radius邻域核、H0/H1+空间harmonic、lambda加权BANKSY矩阵、global/group scaling、Gram-Jacobi PCA、确定性多起点聚类、平滑与SpatialExperiment输出 | +| `voyager.mbt` | `Voyager` | kNN/distance-band/inverse-distance权重(W/B/C/S)、全局Moran's I与Geary's c(Cliff-Ord随机化方差+正态p)、局部Moran's I(象限+置换推断)、局部Geary's c、Getis-Ord Gi/Gi*(Ord-Getis z)、Lee's L(全局+局部)、多元局部Geary、经验变差函数+spherical/exponential/gaussian拟合、Moran correlogram、splitmix64置换、BH-FDR与SpatialExperiment不可变写回 | | `spicyr.mbt` | `spicyR` | ordered cell-type-pair cross-L、矩形窗口disc-intersection边界校正、图像级localization统计、precision weights、加权LMM、条件对比、BH-FDR与SpatialExperiment metadata输出 | | `lisaclust.mbt` | `lisaClust` | 多细胞类型local-K/L特征、KDE intensity correction、矩形/凸包窗口、disc-window边界积分、确定性多起点k-means、regionMap observed/expected富集与SpatialExperiment region输出 | | `spatialdecon.mbt` | `SpatialDecon` | background-aware weighted log-normal non-negative regression、algorithm2异常点重拟合、Hessian协方差、abundance/count scaling、cell-type collapse、reverseDecon、GeoMx background、profile构建与SpatialExperiment输出 | @@ -3544,6 +3550,14 @@ alignment body通过coordinate row的冒号位置确定固定列宽，支持跨p parser严格检查metadata顺序、固定列行宽、坐标方向与终点、模型维度、splice/NER长度、split codon配对和frameshift归属；公开层次查询与数组结果执行深层防御复制。42项黑盒测试覆盖wrapped blocks、正反链intron、joint intron、NER、protein/DNA翻译、5行coding模型、partial phase、特殊氨基酸、聚合及畸形输入；示例完全离线，不调用外部`exonerate`程序。 +### 292. 空间自相关统计与变差函数建模 (Bioconductor Voyager) + +实现 Bioconductor `Voyager` 的单变量、双变量与多变量空间自相关核心，矩阵统一采用 spot × feature 之外的独立向量视图。空间权重由 `voyager_weights_knn`（kNN，`k` 超过 `n-1` 时截断，距离 ties 按邻居索引稳定排序）、`voyager_weights_distance_band`（固定半径，含自身排除）或 `voyager_weights_inverse_distance`（`w_ij = 1/d^power`，可选带宽上限）从二维/三维坐标构建，并支持四种编码风格：`W` 行标准化、`B` 二值、`C` 全局标准化（总和为 1）和 `S` Caussinus–Mestre（`1/√(k_i·k_j)`）。权重矩阵以邻居索引数组的稀疏形式存储，S0/S1/S2 由 `voyager_weights_s0/s1/s2` 按定义确定性计算。 + +全局统计提供 Moran's I 和 Geary's c，均采用 Cliff–Ord (1981) 随机化期望与方差（`b2 = n·m4/m2²`），并以 Abramowitz–Stegun 正态 CDF 计算双侧 p 值；方差非正时回退为 0。局部统计覆盖 Anselin (1995) 局部 Moran's I（LISA）及 HH/HL/LH/LL 象限分类、局部 Geary's c（similar/dissimilar 分类）、Getis–Ord Gi/Gi*（`star=true` 时含自身 `w_ii=1`）及精确 Ord–Getis 随机化 z 分数与 hotspot/coldspot 分类。双变量 Lee's L 同时返回全局 L 与逐点局部 L；`voyager_multivariate_local_geary` 对多特征矩阵按每特征独立置换并汇总逐点统计。置换推断使用固定 seed 的 splitmix64 PRNG 驱动 Fisher–Yates 洗牌，p 值采用 `(extreme+1)/(perm+1)` 校正，并通过 Benjamini–Hochberg 步降控制 FDR。 + +经验变差函数将点对按等距 lag 分箱（默认上限为最大成对距离一半）并计算半方差 `γ = Σ(x_i-x_j)²/(2·n_pairs)`；`voyager_fit_variogram` 在有界 range 网格上搜索、对每个候选 range 用闭式线性最小二乘求解 (nugget, partial sill)，最小化残差平方和，支持 spherical/exponential/gaussian 三种模型，`voyager_variogram_predict` 据此预测任意距离的半方差。`voyager_correlogram` 按距离分箱逐 bin 构建行标准化权重并计算 Moran's I，自动跳过无观测对的 bin。`voyager_run_univariate_sfe` 从 `SpatialExperiment` 的 assay、`spatialCoords`、`rowData`/`colData` 提取输入，在深复制容器中把全局统计写入 `rowData`、局部统计（local estimate/FDR/quadrant）写入逐 spot `colData`，并在 metadata 记录方法与特征数，原对象保持不变；基因名按 `gene_name`→`gene_id`→`gene_N` 回退解析，三维坐标在 z 非恒定时自动启用。当前实现不依赖 R、spdep 或 sf，采用稠密成对距离与串行计算，不覆盖上游 `listw`/`nb` S4 对象、并行后端、协变量残差化与可视化层；58 项黑盒测试覆盖手算链状格点、置换确定性、FDR 单调性与 SpatialExperiment 不可变性。 + ## 性能优化 ### 优化策略 @@ -3645,8 +3659,8 @@ parser严格检查metadata顺序、固定列行宽、坐标方向与终点、模 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 12093 | -| 通过数 | 12093 | +| 总测试数 | 12151 | +| 通过数 | 12151 | | 失败数 | 0 | | 通过率 | 100% | @@ -3996,6 +4010,7 @@ moon test --update | Bioconductor spicyR | `spicyr_test.mbt` | 39 | | Bioconductor lisaClust | `lisaclust_test.mbt` | 51 | | Bioconductor SpatialDecon | `spatialdecon_test.mbt` | 60 | +| Bioconductor Voyager | `voyager_test.mbt` | 58 | | Bio.PopGen.GenePop | `gene_pop_test.mbt` | 34 | | Bioconductor stageR | `stage_r_test.mbt` | 25 | | Bioconductor EnrichedHeatmap | `enriched_heatmap_test.mbt` | 20 | @@ -4091,7 +4106,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 400 个示例程序，展示各模块的典型用法： +项目提供 406 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -4301,6 +4316,7 @@ moon run cmd/bench/main.mbt | dreamlet_demo | SingleCellExperiment pseudobulk、TMM/logCPM、Poisson/voom权重、donor随机截距和跨cell-type FDR | `moon run examples/dreamlet_demo` | | nnsvg_demo | nearest-neighbor GP空间变异基因检验、length scale、空间方差占比、基因过滤与SpatialExperiment接入 | `moon run examples/nnsvg_demo` | | banksy_demo | H0/H1空间邻域特征、cell-typing/domain lambda、PCA聚类、标签平滑、参数扫描与SpatialExperiment接入 | `moon run examples/banksy_demo` | +| voyager_demo | kNN/distance-band/inverse-distance权重、全局Moran/Geary、局部Moran LISA、Getis-Ord Gi*、Lee's L、变差函数拟合、correlogram与SpatialExperiment接入 | `moon run examples/voyager_demo` | | spicyr_demo | 有序细胞类型对cross-L、矩形窗口边界校正、precision weights、重复受试者模型、条件对比与SpatialExperiment接入 | `moon run examples/spicyr_demo` | | lisaclust_demo | 每细胞local-K/L曲线、KDE与边界校正、确定性区域聚类、silhouette、observed/expected富集及SpatialExperiment写回 | `moon run examples/lisaclust_demo` | | spatialdecon_demo | 背景感知log-normal解卷积、丰度/比例/计数、cell-type collapse、reverse deconvolution、负探针背景、单细胞profile与SpatialExperiment写回 | `moon run examples/spatialdecon_demo` | diff --git a/examples/voyager_demo/main.mbt b/examples/voyager_demo/main.mbt new file mode 100644 index 00000000..a2d79b3c --- /dev/null +++ b/examples/voyager_demo/main.mbt @@ -0,0 +1,266 @@ +// Bioconductor Voyager-inspired spatial autocorrelation workflow. +// +// Exercises the full univariate pipeline on a synthetic SpatialExperiment: +// 1. Spatial weight construction (kNN, distance-band, inverse-distance). +// 2. Global Moran's I and Geary's c with analytical inference. +// 3. Local Moran's I (LISA) with permutation inference and quadrants. +// 4. Local Getis–Ord Gi* hotspot detection. +// 5. Bivariate Lee's L spatial association. +// 6. Empirical variogram and spherical model fitting. +// 7. Moran correlogram over distance bins. +// 8. Immutable SpatialExperiment write-back of local statistics. + +///| +fn voyager_demo_coords(se : @src.SpatialExperiment) -> Array[Array[Double]] { + let coords : Array[Array[Double]] = [] + for sc in se.spatial_coords { + coords.push([sc.x, sc.y]) + } + coords +} + +///| +fn voyager_demo_round(value : Double, digits : Int) -> Double { + let scale = @math.pow(10.0, digits.to_double()) + (value * scale).round() / scale +} + +///| +fn voyager_demo_print_row(label : String, value : Double) -> Unit { + println(" " + label + ": " + voyager_demo_round(value, 4).to_string()) +} + +///| +fn main { + let se = @src.voyager_example_spatial_experiment() + let coords = voyager_demo_coords(se) + // assay[feature][spot]; the example ships 4 features on a 6x6 grid. + let assay = se.assay["logcounts"] + let gradient = assay[0] + let hotspot = assay[1] + let anti = assay[3] + println("=== Bioconductor Voyager Demo ===") + println( + "SpatialExperiment: " + + se.col_data.length().to_string() + + " spots, " + + assay.length().to_string() + + " features, platform=" + + se.metadata["platform"], + ) + + // ----------------------------------------------------------------------- + // 1. Spatial weight construction + // ----------------------------------------------------------------------- + println("\n1. Spatial weight construction") + let knn = @src.voyager_weights_knn(coords, 4) catch { + VoyagerError(message) => abort("kNN weights failed: " + message) + } + println( + " kNN k=4: style=" + + knn.style + + ", S0=" + + voyager_demo_round(@src.voyager_weights_s0(knn), 4).to_string(), + ) + let dband = @src.voyager_weights_distance_band(coords, 1.0) catch { + VoyagerError(message) => abort("distance-band weights failed: " + message) + } + println( + " distance-band 1.0: centre spot neighbours=" + + dband.neighbors[18].length().to_string(), + ) + let idw = @src.voyager_weights_inverse_distance(coords, 1.0) catch { + VoyagerError(message) => + abort("inverse-distance weights failed: " + message) + } + println( + " inverse-distance power=1: centre spot neighbours=" + + idw.neighbors[18].length().to_string(), + ) + + // ----------------------------------------------------------------------- + // 2. Global Moran's I and Geary's c + // ----------------------------------------------------------------------- + println("\n2. Global spatial autocorrelation (gene_gradient)") + let moran = @src.voyager_global_morans_i(gradient, knn) catch { + VoyagerError(message) => abort("global Moran's I failed: " + message) + } + voyager_demo_print_row("Moran's I estimate", moran.estimate) + voyager_demo_print_row("Moran's I expectation", moran.expectation) + voyager_demo_print_row("Moran's I z-score", moran.z_score) + voyager_demo_print_row("Moran's I p-value", moran.p_value) + let geary = @src.voyager_global_gearys_c(gradient, knn) catch { + VoyagerError(message) => abort("global Geary's c failed: " + message) + } + voyager_demo_print_row("Geary's c estimate", geary.estimate) + voyager_demo_print_row("Geary's c p-value", geary.p_value) + + // ----------------------------------------------------------------------- + // 3. Local Moran's I (LISA) with permutation inference + // ----------------------------------------------------------------------- + println("\n3. Local Moran's I (LISA) with permutation inference") + let lisa = @src.voyager_local_morans_i( + gradient, + knn, + permutations=199, + seed=20240501, + fdr_threshold=0.1, + ) catch { + VoyagerError(message) => abort("local Moran's I failed: " + message) + } + let mut hh = 0 + let mut ll = 0 + let mut sig = 0 + for i in 0.. abort("Getis–Ord failed: " + message) + } + let mut max_z = -1.0e300 + let mut max_spot = 0 + for i in 0.. max_z { + max_z = getis.z_scores[i] + max_spot = i + } + } + println( + " peak Gi* z-score=" + + voyager_demo_round(max_z, 4).to_string() + + " at spot " + + max_spot.to_string() + + " (" + + getis.classifications[max_spot] + + ")", + ) + + // ----------------------------------------------------------------------- + // 5. Bivariate Lee's L + // ----------------------------------------------------------------------- + println("\n5. Bivariate Lee's L (gene_gradient vs gene_anti)") + let lees = @src.voyager_lees_l( + gradient, + anti, + knn, + permutations=199, + seed=20240501, + fdr_threshold=0.1, + ) catch { + VoyagerError(message) => abort("Lee's L failed: " + message) + } + voyager_demo_print_row("global Lee's L", lees.global_l) + + // ----------------------------------------------------------------------- + // 6. Empirical variogram and spherical model fit + // ----------------------------------------------------------------------- + println("\n6. Empirical variogram and spherical model fit (gene_hotspot)") + let empirical = @src.voyager_empirical_variogram(coords, hotspot, n_lags=8) catch { + VoyagerError(message) => abort("empirical variogram failed: " + message) + } + println(" empirical points=" + empirical.length().to_string()) + let model = @src.voyager_fit_variogram(empirical, model_type="spherical") catch { + VoyagerError(message) => abort("variogram fit failed: " + message) + } + println( + " spherical: nugget=" + + voyager_demo_round(model.nugget, 4).to_string() + + ", sill=" + + voyager_demo_round(model.sill, 4).to_string() + + ", range=" + + voyager_demo_round(model.range, 4).to_string() + + ", SSE=" + + voyager_demo_round(model.fitted_sse, 4).to_string(), + ) + voyager_demo_print_row( + "variogram predicted semivariance at range", + @src.voyager_variogram_predict(model, model.range), + ) + + // ----------------------------------------------------------------------- + // 7. Moran correlogram + // ----------------------------------------------------------------------- + println("\n7. Moran correlogram over distance bins") + let corr = @src.voyager_correlogram(coords, gradient, n_lags=5) catch { + VoyagerError(message) => abort("correlogram failed: " + message) + } + println(" bins=" + corr.length().to_string()) + for point in corr { + println( + " lag=" + + voyager_demo_round(point.lag, 3).to_string() + + ", Moran's I=" + + voyager_demo_round(point.morans_i, 4).to_string() + + ", npairs=" + + point.npairs.to_string(), + ) + } + + // ----------------------------------------------------------------------- + // 8. Immutable SpatialExperiment write-back + // ----------------------------------------------------------------------- + println("\n8. Immutable SpatialExperiment write-back") + let output = @src.voyager_run_univariate_sfe( + se, + [0, 1], + assay_name="logcounts", + stat_method="moran", + permutations=99, + seed=2024, + fdr_threshold=0.1, + output_prefix="voyager", + ) catch { + VoyagerError(message) => + abort("Voyager SpatialExperiment integration failed: " + message) + } + println( + " features analyzed=" + + output.results.length().to_string() + + ", method=" + + output.results[0].stat_method, + ) + println( + " input unchanged: " + + (!se.col_data[0].contains("voyager.moran.local.gene_gradient")).to_string(), + ) + println( + " output colData carries local Moran: " + + output.experiment.col_data[0] + .contains("voyager.moran.local.gene_gradient") + .to_string(), + ) + println( + " metadata method=" + + output.experiment.metadata["voyager.method"] + + ", n_features=" + + output.experiment.metadata["voyager.n_features"], + ) + println("=== Demo Complete ===") +} diff --git a/examples/voyager_demo/moon.pkg b/examples/voyager_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/voyager_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/moon.mod b/moon.mod index 1049a3c3..9c192bde 100644 --- a/moon.mod +++ b/moon.mod @@ -11,7 +11,7 @@ name = "IvanAXu/BioSeqs" -version = "0.1.6" +version = "0.1.8" readme = "README.mbt.md" diff --git a/src/abi.mbt b/src/abi.mbt index 2ca30206..0addc721 100644 --- a/src/abi.mbt +++ b/src/abi.mbt @@ -245,15 +245,27 @@ pub fn AbiTrace::quality_at(self : AbiTrace, index : Int) -> Int { ///| /// Format an ABIF date as "YYYY-MM-DD". pub fn AbiDate::to_string(self : AbiDate) -> String { - let m = if self.month < 10 { "0" + self.month.to_string() } else { self.month.to_string() } - let d = if self.day < 10 { "0" + self.day.to_string() } else { self.day.to_string() } + let m = if self.month < 10 { + "0" + self.month.to_string() + } else { + self.month.to_string() + } + let d = if self.day < 10 { + "0" + self.day.to_string() + } else { + self.day.to_string() + } self.year.to_string() + "-" + m + "-" + d } ///| /// Format an ABIF time as "HH:MM:SS". pub fn AbiTime::to_string(self : AbiTime) -> String { - let h = if self.hours < 10 { "0" + self.hours.to_string() } else { self.hours.to_string() } + let h = if self.hours < 10 { + "0" + self.hours.to_string() + } else { + self.hours.to_string() + } let mi = if self.minutes < 10 { "0" + self.minutes.to_string() } else { @@ -275,7 +287,10 @@ fn abi_read_u32(bytes : Array[Int], pos : Int) -> Int { if pos + 3 >= bytes.length() { return 0 } - bytes[pos] * 16777216 + bytes[pos + 1] * 65536 + bytes[pos + 2] * 256 + bytes[pos + 3] + bytes[pos] * 16777216 + + bytes[pos + 1] * 65536 + + bytes[pos + 2] * 256 + + bytes[pos + 3] } ///| @@ -428,10 +443,7 @@ fn abi_find_entry( ///| /// Read raw data bytes for a directory entry from the file bytes. -fn abi_read_entry_data( - bytes : Array[Int], - entry : AbiDirEntry, -) -> Array[Int] { +fn abi_read_entry_data(bytes : Array[Int], entry : AbiDirEntry) -> Array[Int] { let data : Array[Int] = Array::new() // If data fits inline (data_size <= 4), use inline_data if entry.data_size <= 4 { @@ -459,10 +471,7 @@ fn abi_read_entry_data( ///| /// Read trace data (array of Int) for a directory entry. /// Trace data is typically 2-byte (word) values. -fn abi_read_trace_data( - bytes : Array[Int], - entry : AbiDirEntry, -) -> Array[Int] { +fn abi_read_trace_data(bytes : Array[Int], entry : AbiDirEntry) -> Array[Int] { let data : Array[Int] = Array::new() let raw = abi_read_entry_data(bytes, entry) // If element type is word (3) or short (4), read as 2-byte values @@ -492,10 +501,7 @@ fn abi_read_trace_data( ///| /// Read integer array data for a directory entry (e.g., base positions). -fn abi_read_int_array( - bytes : Array[Int], - entry : AbiDirEntry, -) -> Array[Int] { +fn abi_read_int_array(bytes : Array[Int], entry : AbiDirEntry) -> Array[Int] { let data : Array[Int] = Array::new() let raw = abi_read_entry_data(bytes, entry) // For PLOC (base positions), element type is short (4), size 2 diff --git a/src/ace.mbt b/src/ace.mbt index 2f0e716d..7cb075c8 100644 --- a/src/ace.mbt +++ b/src/ace.mbt @@ -260,9 +260,7 @@ pub fn ace_parse(content : String) -> AceData { reads_map[r.read_id] = r i = ace_skip_read_block(lines, i) } - None => { - i = i + 1 - } + None => i = i + 1 } continue } @@ -274,9 +272,7 @@ pub fn ace_parse(content : String) -> AceData { contigs.push(contig) i = new_idx } - None => { - i = i + 1 - } + None => i = i + 1 } continue } @@ -301,7 +297,7 @@ pub fn ace_parse_reads(content : String) -> Array[AceRead] { let read = ace_parse_read_block(lines, i) match read { Some(r) => reads.push(r) - None => { () } + None => () } i = ace_skip_read_block(lines, i) } else { @@ -330,9 +326,7 @@ pub fn ace_parse_contigs(content : String) -> Array[AceContig] { reads_map[r.read_id] = r i = ace_skip_read_block(lines, i) } - None => { - i = i + 1 - } + None => i = i + 1 } } else if trimmed.has_prefix("CT ") { let contig_and_new_idx = ace_parse_contig_block(lines, i, reads_map) @@ -341,9 +335,7 @@ pub fn ace_parse_contigs(content : String) -> Array[AceContig] { contigs.push(contig) i = new_idx } - None => { - i = i + 1 - } + None => i = i + 1 } } else { i = i + 1 @@ -354,10 +346,7 @@ pub fn ace_parse_contigs(content : String) -> Array[AceContig] { ///| /// Parse a single RD block starting at the given line index. -fn ace_parse_read_block( - lines : Array[String], - start_idx : Int, -) -> AceRead? { +fn ace_parse_read_block(lines : Array[String], start_idx : Int) -> AceRead? { if start_idx >= lines.length() { return None } @@ -394,7 +383,8 @@ fn ace_parse_read_block( } if (first_char >= 'A'.to_int() && first_char <= 'Z'.to_int()) || (first_char >= 'a'.to_int() && first_char <= 'z'.to_int()) || - first_char == '-'.to_int() || first_char == '.'.to_int() { + first_char == '-'.to_int() || + first_char == '.'.to_int() { let remaining = read_len - sequence.length() let chunk = if trimmed.length() > remaining { trimmed[0:remaining].to_owned() @@ -412,17 +402,11 @@ fn ace_parse_read_block( let (quality, new_idx) = ace_parse_quality_lines(lines, idx, read_len) idx = new_idx - Some(AceRead::new( - read_id, - sequence, - quality, - 1, - read_len, - "+", - "", - chemistry, - dye, - )) + Some( + AceRead::new( + read_id, sequence, quality, 1, read_len, "+", "", chemistry, dye, + ), + ) } ///| @@ -454,12 +438,13 @@ fn ace_skip_read_block(lines : Array[String], start_idx : Int) -> Int { idx = idx + 1 break } - if (first_char >= '0'.to_int() && first_char <= '9'.to_int()) { + if first_char >= '0'.to_int() && first_char <= '9'.to_int() { break } if (first_char >= 'A'.to_int() && first_char <= 'Z'.to_int()) || (first_char >= 'a'.to_int() && first_char <= 'z'.to_int()) || - first_char == '-'.to_int() || first_char == '.'.to_int() { + first_char == '-'.to_int() || + first_char == '.'.to_int() { seq_chars = seq_chars + trimmed.length() idx = idx + 1 } else { @@ -528,7 +513,8 @@ fn ace_parse_contig_block( } if (first_char >= 'A'.to_int() && first_char <= 'Z'.to_int()) || (first_char >= 'a'.to_int() && first_char <= 'z'.to_int()) || - first_char == '-'.to_int() || first_char == '.'.to_int() { + first_char == '-'.to_int() || + first_char == '.'.to_int() { let remaining = contig_len - sequence.length() let chunk = if trimmed.length() > remaining { trimmed[0:remaining].to_owned() @@ -543,12 +529,17 @@ fn ace_parse_contig_block( } // Parse base qualities - let (base_qualities, new_idx) = ace_parse_quality_lines(lines, idx, contig_len) + let (base_qualities, new_idx) = ace_parse_quality_lines( + lines, idx, contig_len, + ) idx = new_idx // Parse AF alignment lines let reads : Array[AceRead] = Array::new() - let alignment_positions : Map[String, (Int, Int, Int, Int, Int, Int, String)] = Map([], capacity=32) + let alignment_positions : Map[String, (Int, Int, Int, Int, Int, Int, String)] = Map( + [], + capacity=32, + ) while idx < lines.length() { let line = lines[idx].to_string() @@ -571,13 +562,7 @@ fn ace_parse_contig_block( let strand = if af_tokens.length() >= 9 { af_tokens[8] } else { "+" } alignment_positions[read_name] = ( - contig_start, - contig_end, - read_start, - read_end, - qual_start, - qual_end, - strand, + contig_start, contig_end, read_start, read_end, qual_start, qual_end, strand, ) } idx = idx + 1 @@ -640,17 +625,12 @@ fn ace_parse_contig_block( ri = ri + 1 } - Some(( - AceContig::new( - contig_name, - sequence, - reads, - base_qualities, - "", - false, + Some( + ( + AceContig::new(contig_name, sequence, reads, base_qualities, "", false), + idx, ), - idx, - )) + ) } // ===== Serialization ===== @@ -784,7 +764,11 @@ pub fn ace_read_coverage(contig : AceContig) -> Map[Int, Int] { let read = contig.reads[ri] let start = if read.clip_start > 0 { read.clip_start } else { 1 } let end = if read.clip_end > 0 { - if read.clip_end > contig.length { contig.length } else { read.clip_end } + if read.clip_end > contig.length { + contig.length + } else { + read.clip_end + } } else { contig.length } @@ -839,19 +823,20 @@ pub fn ace_contig_gc_content(contig : AceContig) -> Double { /// Create sample ACE content for testing. pub fn sample_ace_content() -> String { "AF contig1 60\n" + - "RD read1 60 chemistry1 dye1\n" + - "ATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCG\n" + - "q 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30\n" + - "RD read2 60 chemistry2 dye2\n" + - "GCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTA\n" + - "q 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25\n" + - "CT contig1 60 0 60\n" + - "ATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCG\n" + - "q 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40\n" + - "AF read1 1 60 1 60 1 60 +\n" + - "AF read2 1 60 1 60 1 60 -\n" + "RD read1 60 chemistry1 dye1\n" + + "ATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCG\n" + + "q 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30\n" + + "RD read2 60 chemistry2 dye2\n" + + "GCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTA\n" + + "q 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25 25\n" + + "CT contig1 60 0 60\n" + + "ATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCGATCG\n" + + "q 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40 40\n" + + "AF read1 1 60 1 60 1 60 +\n" + + "AF read2 1 60 1 60 1 60 -\n" } +///| pub fn sample_ace_data() -> AceData { ace_parse(sample_ace_content()) -} \ No newline at end of file +} diff --git a/src/aldex2.mbt b/src/aldex2.mbt index fbb3c849..c95c961e 100644 --- a/src/aldex2.mbt +++ b/src/aldex2.mbt @@ -716,10 +716,7 @@ pub fn aldex2_clr( config } let denominators = aldex2_denominators( - filtered_counts, - group_indices, - conditions, - denominator_config, + filtered_counts, group_indices, conditions, denominator_config, ) let feature_count = filtered_counts.length() let dirichlet : Array[Array[Array[Double]]] = [] diff --git a/src/align_abstract.mbt b/src/align_abstract.mbt index 3f1160dc..7491f610 100644 --- a/src/align_abstract.mbt +++ b/src/align_abstract.mbt @@ -54,8 +54,12 @@ pub fn AbstractAlignment::new( let n_seqs = sequences.length() let alignment_length = if n_seqs > 0 { sequences[0].length() } else { 0 } AbstractAlignment::{ - sequences, identifiers, alignment_type, - validated: false, n_seqs, alignment_length + sequences, + identifiers, + alignment_type, + validated: false, + n_seqs, + alignment_length, } } @@ -88,7 +92,9 @@ pub fn AbstractAlignment::validate(self : AbstractAlignment) -> (Bool, String) { ///| /// Validate characters in the alignment. -pub fn AbstractAlignment::validate_characters(self : AbstractAlignment) -> (Bool, String) { +pub fn AbstractAlignment::validate_characters( + self : AbstractAlignment, +) -> (Bool, String) { let valid_chars = get_valid_chars(self.alignment_type) let mut seq_idx = 0 @@ -101,7 +107,12 @@ pub fn AbstractAlignment::validate_characters(self : AbstractAlignment) -> (Bool let ch = c.to_string() let pos = i.to_string() let id = self.identifiers[seq_idx] - let msg = "Invalid character " + ch + " at position " + pos + " in sequence " + id + let msg = "Invalid character " + + ch + + " at position " + + pos + + " in sequence " + + id return (false, msg) } i = i + 1 @@ -111,25 +122,20 @@ pub fn AbstractAlignment::validate_characters(self : AbstractAlignment) -> (Bool (true, "") } +///| fn get_valid_chars(align_type : AlignAbstractType) -> Array[UInt16] { let nucleotide_chars : Array[UInt16] = [ - 65, 84, 71, 67, 85, 78, 45, 46, - 82, 89, 83, 87, 75, 77, 66, 86, 68, 72 + 65, 84, 71, 67, 85, 78, 45, 46, 82, 89, 83, 87, 75, 77, 66, 86, 68, 72, ] let protein_chars : Array[UInt16] = [ - 65, 82, 78, 68, 67, 81, 69, 71, 72, 73, - 76, 75, 77, 70, 80, 83, 84, 87, 89, 86, - 66, 90, 88, 45, 46, 85, 79 + 65, 82, 78, 68, 67, 81, 69, 71, 72, 73, 76, 75, 77, 70, 80, 83, 84, 87, 89, 86, + 66, 90, 88, 45, 46, 85, 79, ] let generic_chars : Array[UInt16] = [ - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, - 85, 86, 87, 88, 89, 90, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 45, 46, 42 + 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 46, 42, ] match align_type { @@ -139,14 +145,25 @@ fn get_valid_chars(align_type : AlignAbstractType) -> Array[UInt16] { } } +///| fn char_to_upper(c : UInt16) -> UInt16 { - if c >= 97 && c <= 122 { c - 32 } else { c } + if c >= 97 && c <= 122 { + c - 32 + } else { + c + } } +///| fn char_to_lower(c : UInt16) -> UInt16 { - if c >= 65 && c <= 90 { c + 32 } else { c } + if c >= 65 && c <= 90 { + c + 32 + } else { + c + } } +///| /// Convert a UInt16 character code to its 1-character String representation. fn u16_to_str(c : UInt16) -> String { match c { @@ -221,6 +238,7 @@ fn u16_to_str(c : UInt16) -> String { } } +///| fn char_in_array(c : UInt16, arr : Array[UInt16]) -> Bool { for ch in arr { if ch == c { @@ -238,13 +256,18 @@ pub fn AbstractAlignment::abstract_n_seqs(self : AbstractAlignment) -> Int { ///| /// Get alignment length. -pub fn AbstractAlignment::abstract_alignment_length(self : AbstractAlignment) -> Int { +pub fn AbstractAlignment::abstract_alignment_length( + self : AbstractAlignment, +) -> Int { self.alignment_length } ///| /// Get a sequence by index. -pub fn AbstractAlignment::abstract_get_seq(self : AbstractAlignment, idx : Int) -> String { +pub fn AbstractAlignment::abstract_get_seq( + self : AbstractAlignment, + idx : Int, +) -> String { if idx >= 0 && idx < self.n_seqs { self.sequences[idx] } else { @@ -254,7 +277,10 @@ pub fn AbstractAlignment::abstract_get_seq(self : AbstractAlignment, idx : Int) ///| /// Get sequence identifier by index. -pub fn AbstractAlignment::abstract_get_id(self : AbstractAlignment, idx : Int) -> String { +pub fn AbstractAlignment::abstract_get_id( + self : AbstractAlignment, + idx : Int, +) -> String { if idx >= 0 && idx < self.n_seqs { self.identifiers[idx] } else { @@ -264,7 +290,10 @@ pub fn AbstractAlignment::abstract_get_id(self : AbstractAlignment, idx : Int) - ///| /// Get a column from the alignment (array of characters). -pub fn AbstractAlignment::abstract_get_column(self : AbstractAlignment, col_idx : Int) -> Array[UInt16] { +pub fn AbstractAlignment::abstract_get_column( + self : AbstractAlignment, + col_idx : Int, +) -> Array[UInt16] { let column : Array[UInt16] = Array::new() if col_idx >= 0 && col_idx < self.alignment_length { for seq in self.sequences { @@ -276,7 +305,9 @@ pub fn AbstractAlignment::abstract_get_column(self : AbstractAlignment, col_idx ///| /// Get the alignment type. -pub fn AbstractAlignment::abstract_type(self : AbstractAlignment) -> AlignAbstractType { +pub fn AbstractAlignment::abstract_type( + self : AbstractAlignment, +) -> AlignAbstractType { self.alignment_type } @@ -295,13 +326,20 @@ pub struct AlignAbstractColumnStats { ///| /// Compute column statistics for a given alignment column. -pub fn abstract_column_stats(alignment : AbstractAlignment, col_idx : Int) -> AlignAbstractColumnStats { +pub fn abstract_column_stats( + alignment : AbstractAlignment, + col_idx : Int, +) -> AlignAbstractColumnStats { let column = alignment.abstract_get_column(col_idx) let n = column.length() if n == 0 { return AlignAbstractColumnStats::{ - column_index: col_idx, conservation: 0.0, diversity: 0.0, - gap_fraction: 0.0, n_unique_chars: 0, consensus_char: 45 + column_index: col_idx, + conservation: 0.0, + diversity: 0.0, + gap_fraction: 0.0, + n_unique_chars: 0, + consensus_char: 45, } } @@ -357,13 +395,15 @@ pub fn abstract_column_stats(alignment : AbstractAlignment, col_idx : Int) -> Al diversity: entropy, gap_fraction, n_unique_chars: counts.length(), - consensus_char: consensus + consensus_char: consensus, } } ///| /// Get an array of all column statistics for the alignment. -pub fn abstract_all_column_stats(alignment : AbstractAlignment) -> Array[AlignAbstractColumnStats] { +pub fn abstract_all_column_stats( + alignment : AbstractAlignment, +) -> Array[AlignAbstractColumnStats] { let stats : Array[AlignAbstractColumnStats] = Array::new() let mut i = 0 while i < alignment.alignment_length { @@ -375,7 +415,10 @@ pub fn abstract_all_column_stats(alignment : AbstractAlignment) -> Array[AlignAb ///| /// Get the consensus sequence of the alignment (using most common character per column). -pub fn abstract_consensus_sequence(alignment : AbstractAlignment, threshold? : Double = 0.5) -> String { +pub fn abstract_consensus_sequence( + alignment : AbstractAlignment, + threshold? : Double = 0.5, +) -> String { let mut consensus = "" let mut i = 0 while i < alignment.alignment_length { @@ -392,7 +435,9 @@ pub fn abstract_consensus_sequence(alignment : AbstractAlignment, threshold? : D ///| /// Calculate sequence identity matrix (pairwise). -pub fn abstract_identity_matrix(alignment : AbstractAlignment) -> Array[Array[Double]] { +pub fn abstract_identity_matrix( + alignment : AbstractAlignment, +) -> Array[Array[Double]] { let n = alignment.n_seqs let matrix : Array[Array[Double]] = Array::new() let mut i = 0 @@ -400,7 +445,10 @@ pub fn abstract_identity_matrix(alignment : AbstractAlignment) -> Array[Array[Do let row : Array[Double] = Array::new() let mut j = 0 while j < n { - let identity = seq_identity(alignment.sequences[i], alignment.sequences[j]) + let identity = seq_identity( + alignment.sequences[i], + alignment.sequences[j], + ) row.push(identity) j = j + 1 } @@ -410,6 +458,7 @@ pub fn abstract_identity_matrix(alignment : AbstractAlignment) -> Array[Array[Do matrix } +///| fn seq_identity(seq1 : String, seq2 : String) -> Double { if seq1.length() != seq2.length() { return 0.0 @@ -493,6 +542,7 @@ pub fn abstract_parsimony_sites(alignment : AbstractAlignment) -> Int { count } +///| fn is_parsimony_informative(alignment : AbstractAlignment, col : Int) -> Bool { let column = alignment.abstract_get_column(col) let counts : Map[UInt16, Int] = Map([], capacity=20) @@ -529,6 +579,7 @@ pub fn abstract_variable_sites(alignment : AbstractAlignment) -> Int { count } +///| fn is_variable_site(alignment : AbstractAlignment, col : Int) -> Bool { let column = alignment.abstract_get_column(col) if column.length() == 0 { @@ -557,6 +608,7 @@ pub fn abstract_singleton_sites(alignment : AbstractAlignment) -> Int { count } +///| fn is_singleton_site(alignment : AbstractAlignment, col : Int) -> Bool { let column = alignment.abstract_get_column(col) let counts : Map[UInt16, Int] = Map([], capacity=20) @@ -588,7 +640,9 @@ fn is_singleton_site(alignment : AbstractAlignment, col : Int) -> Bool { ///| /// Calculate alignment distance matrix (using simple p-distance). -pub fn abstract_distance_matrix(alignment : AbstractAlignment) -> Array[Array[Double]] { +pub fn abstract_distance_matrix( + alignment : AbstractAlignment, +) -> Array[Array[Double]] { let n = alignment.n_seqs let matrix : Array[Array[Double]] = Array::new() let mut i = 0 @@ -596,7 +650,10 @@ pub fn abstract_distance_matrix(alignment : AbstractAlignment) -> Array[Array[Do let row : Array[Double] = Array::new() let mut j = 0 while j < n { - let dist = pairwise_distance(alignment.sequences[i], alignment.sequences[j]) + let dist = pairwise_distance( + alignment.sequences[i], + alignment.sequences[j], + ) row.push(dist) j = j + 1 } @@ -606,6 +663,7 @@ pub fn abstract_distance_matrix(alignment : AbstractAlignment) -> Array[Array[Do matrix } +///| fn pairwise_distance(seq1 : String, seq2 : String) -> Double { if seq1.length() != seq2.length() { return 1.0 @@ -629,7 +687,10 @@ fn pairwise_distance(seq1 : String, seq2 : String) -> Double { ///| /// Filter alignment columns by gap fraction. -pub fn abstract_filter_gaps(alignment : AbstractAlignment, max_gap_fraction : Double) -> AbstractAlignment { +pub fn abstract_filter_gaps( + alignment : AbstractAlignment, + max_gap_fraction : Double, +) -> AbstractAlignment { let keep_columns : Array[Int] = Array::new() let mut col = 0 while col < alignment.alignment_length { @@ -655,12 +716,19 @@ pub fn abstract_filter_gaps(alignment : AbstractAlignment, max_gap_fraction : Do seq_idx = seq_idx + 1 } - AbstractAlignment::new(sequences=new_seqs, identifiers=alignment.identifiers.copy(), alignment_type=alignment.alignment_type) + AbstractAlignment::new( + sequences=new_seqs, + identifiers=alignment.identifiers.copy(), + alignment_type=alignment.alignment_type, + ) } ///| /// Filter alignment sequences by minimum coverage. -pub fn abstract_filter_coverage(alignment : AbstractAlignment, min_coverage : Double) -> AbstractAlignment { +pub fn abstract_filter_coverage( + alignment : AbstractAlignment, + min_coverage : Double, +) -> AbstractAlignment { let keep_seqs : Array[Int] = Array::new() let mut idx = 0 while idx < alignment.n_seqs { @@ -688,14 +756,26 @@ pub fn abstract_filter_coverage(alignment : AbstractAlignment, min_coverage : Do new_ids.push(alignment.identifiers[idx2]) } - AbstractAlignment::new(sequences=new_seqs, identifiers=new_ids, alignment_type=alignment.alignment_type) + AbstractAlignment::new( + sequences=new_seqs, + identifiers=new_ids, + alignment_type=alignment.alignment_type, + ) } ///| /// Trim alignment to include only the region between start and end columns. -pub fn abstract_trim(alignment : AbstractAlignment, start : Int, end : Int) -> AbstractAlignment { +pub fn abstract_trim( + alignment : AbstractAlignment, + start : Int, + end : Int, +) -> AbstractAlignment { let s = if start > 0 { start } else { 0 } - let e = if end < alignment.alignment_length - 1 { end } else { alignment.alignment_length - 1 } + let e = if end < alignment.alignment_length - 1 { + end + } else { + alignment.alignment_length - 1 + } let new_seqs : Array[String] = Array::new() for seq in alignment.sequences { @@ -703,7 +783,11 @@ pub fn abstract_trim(alignment : AbstractAlignment, start : Int, end : Int) -> A new_seqs.push(trimmed) } - AbstractAlignment::new(sequences=new_seqs, identifiers=alignment.identifiers.copy(), alignment_type=alignment.alignment_type) + AbstractAlignment::new( + sequences=new_seqs, + identifiers=alignment.identifiers.copy(), + alignment_type=alignment.alignment_type, + ) } ///| @@ -720,16 +804,33 @@ pub fn abstract_summary(alignment : AbstractAlignment) -> String { let tstr = alignment_type_str(alignment.alignment_type) "Alignment Summary:\n" + - " Sequences: " + n_seqs + "\n" + - " Length: " + alen + "\n" + - " Type: " + tstr + "\n" + - " Valid: " + vstr + "\n" + - " Coverage: " + coverage + "\n" + - " Overall identity: " + identity + "\n" + - " Variable sites: " + variable + "\n" + - " Parsimony-informative sites: " + parsimony + "\n" + " Sequences: " + + n_seqs + + "\n" + + " Length: " + + alen + + "\n" + + " Type: " + + tstr + + "\n" + + " Valid: " + + vstr + + "\n" + + " Coverage: " + + coverage + + "\n" + + " Overall identity: " + + identity + + "\n" + + " Variable sites: " + + variable + + "\n" + + " Parsimony-informative sites: " + + parsimony + + "\n" } +///| pub fn alignment_type_str(t : AlignAbstractType) -> String { match t { AlignAbstractType::Nucleotide => "Nucleotide" diff --git a/src/align_analysis.mbt b/src/align_analysis.mbt index 1ca5b877..8cc56540 100644 --- a/src/align_analysis.mbt +++ b/src/align_analysis.mbt @@ -22,56 +22,67 @@ pub fn AlnAnalysisResult::new( dn_ds_ratio : Double, dn_ds_ratio_sem : Double, n_synonymous : Int, - n_nonsynonymous : Int + n_nonsynonymous : Int, ) -> AlnAnalysisResult { - AlnAnalysisResult::{ dn, ds, dn_ds_ratio, dn_ds_ratio_sem, n_synonymous, n_nonsynonymous } + AlnAnalysisResult::{ + dn, + ds, + dn_ds_ratio, + dn_ds_ratio_sem, + n_synonymous, + n_nonsynonymous, + } } ///| /// Get dn (non-synonymous substitution rate). -pub fn aln_get_dn(self : AlnAnalysisResult) -> Double { +pub fn AlnAnalysisResult::aln_get_dn(self : AlnAnalysisResult) -> Double { self.dn } ///| /// Get ds (synonymous substitution rate). -pub fn aln_get_ds(self : AlnAnalysisResult) -> Double { +pub fn AlnAnalysisResult::aln_get_ds(self : AlnAnalysisResult) -> Double { self.ds } ///| /// Get dn/ds ratio (omega). -pub fn aln_get_ratio(self : AlnAnalysisResult) -> Double { +pub fn AlnAnalysisResult::aln_get_ratio(self : AlnAnalysisResult) -> Double { self.dn_ds_ratio } ///| /// Get standard error of mean for dn/ds ratio. -pub fn aln_get_ratio_sem(self : AlnAnalysisResult) -> Double { +pub fn AlnAnalysisResult::aln_get_ratio_sem(self : AlnAnalysisResult) -> Double { self.dn_ds_ratio_sem } ///| /// Get number of synonymous substitutions. -pub fn aln_get_n_syn(self : AlnAnalysisResult) -> Int { +pub fn AlnAnalysisResult::aln_get_n_syn(self : AlnAnalysisResult) -> Int { self.n_synonymous } ///| /// Get number of non-synonymous substitutions. -pub fn aln_get_n_nonsyn(self : AlnAnalysisResult) -> Int { +pub fn AlnAnalysisResult::aln_get_n_nonsyn(self : AlnAnalysisResult) -> Int { self.n_nonsynonymous } ///| /// Check if the result indicates positive selection (omega > 1). -pub fn aln_has_positive_selection(self : AlnAnalysisResult) -> Bool { +pub fn AlnAnalysisResult::aln_has_positive_selection( + self : AlnAnalysisResult, +) -> Bool { self.dn_ds_ratio > 1.0 } ///| /// Check if the result indicates purifying selection (omega < 1). -pub fn aln_has_purifying_selection(self : AlnAnalysisResult) -> Bool { +pub fn AlnAnalysisResult::aln_has_purifying_selection( + self : AlnAnalysisResult, +) -> Bool { self.dn_ds_ratio < 1.0 } @@ -79,31 +90,57 @@ pub fn aln_has_purifying_selection(self : AlnAnalysisResult) -> Bool { /// Simple genetic code table (standard code 1). /// Returns amino acid for a codon. pub fn aln_aa_from_codon(codon : String) -> String { - if codon == "TTT" || codon == "TTC" { "F" } - else if codon == "TTA" || codon == "TTG" { "L" } - else if codon == "CTT" || codon == "CTC" || codon == "CTA" || codon == "CTG" { "L" } - else if codon == "ATT" || codon == "ATC" || codon == "ATA" { "I" } - else if codon == "ATG" { "M" } - else if codon == "GTT" || codon == "GTC" || codon == "GTA" || codon == "GTG" { "V" } - else if codon == "TCT" || codon == "TCC" || codon == "TCA" || codon == "TCG" { "S" } - else if codon == "CCT" || codon == "CCC" || codon == "CCA" || codon == "CCG" { "P" } - else if codon == "ACT" || codon == "ACC" || codon == "ACA" || codon == "ACG" { "T" } - else if codon == "GCT" || codon == "GCC" || codon == "GCA" || codon == "GCG" { "A" } - else if codon == "TAT" || codon == "TAC" { "Y" } - else if codon == "TAA" || codon == "TAG" || codon == "TGA" { "*" } - else if codon == "CAT" || codon == "CAC" { "H" } - else if codon == "CAA" || codon == "CAG" { "Q" } - else if codon == "AAT" || codon == "AAC" { "N" } - else if codon == "AAA" || codon == "AAG" { "K" } - else if codon == "GAT" || codon == "GAC" { "D" } - else if codon == "GAA" || codon == "GAG" { "E" } - else if codon == "TGT" || codon == "TGC" { "C" } - else if codon == "TGG" { "W" } - else if codon == "CGT" || codon == "CGC" || codon == "CGA" || codon == "CGG" { "R" } - else if codon == "AGT" || codon == "AGC" { "S" } - else if codon == "AGA" || codon == "AGG" { "R" } - else if codon == "GGT" || codon == "GGC" || codon == "GGA" || codon == "GGG" { "G" } - else { "?" } + if codon == "TTT" || codon == "TTC" { + "F" + } else if codon == "TTA" || codon == "TTG" { + "L" + } else if codon == "CTT" || codon == "CTC" || codon == "CTA" || codon == "CTG" { + "L" + } else if codon == "ATT" || codon == "ATC" || codon == "ATA" { + "I" + } else if codon == "ATG" { + "M" + } else if codon == "GTT" || codon == "GTC" || codon == "GTA" || codon == "GTG" { + "V" + } else if codon == "TCT" || codon == "TCC" || codon == "TCA" || codon == "TCG" { + "S" + } else if codon == "CCT" || codon == "CCC" || codon == "CCA" || codon == "CCG" { + "P" + } else if codon == "ACT" || codon == "ACC" || codon == "ACA" || codon == "ACG" { + "T" + } else if codon == "GCT" || codon == "GCC" || codon == "GCA" || codon == "GCG" { + "A" + } else if codon == "TAT" || codon == "TAC" { + "Y" + } else if codon == "TAA" || codon == "TAG" || codon == "TGA" { + "*" + } else if codon == "CAT" || codon == "CAC" { + "H" + } else if codon == "CAA" || codon == "CAG" { + "Q" + } else if codon == "AAT" || codon == "AAC" { + "N" + } else if codon == "AAA" || codon == "AAG" { + "K" + } else if codon == "GAT" || codon == "GAC" { + "D" + } else if codon == "GAA" || codon == "GAG" { + "E" + } else if codon == "TGT" || codon == "TGC" { + "C" + } else if codon == "TGG" { + "W" + } else if codon == "CGT" || codon == "CGC" || codon == "CGA" || codon == "CGG" { + "R" + } else if codon == "AGT" || codon == "AGC" { + "S" + } else if codon == "AGA" || codon == "AGG" { + "R" + } else if codon == "GGT" || codon == "GGC" || codon == "GGA" || codon == "GGG" { + "G" + } else { + "?" + } } ///| @@ -111,7 +148,11 @@ pub fn aln_aa_from_codon(codon : String) -> String { /// Returns true if the substitution is synonymous (doesn't change amino acid). pub fn aln_is_synonymous(codon : String, pos : Int, new_base : String) -> Bool { let first_part = if pos > 0 { substring(codon, 0, pos) } else { "" } - let second_part = if pos < 2 { substring(codon, pos + 1, 3 - pos - 1) } else { "" } + let second_part = if pos < 2 { + substring(codon, pos + 1, 3 - pos - 1) + } else { + "" + } let new_codon = first_part + new_base + second_part let old_aa = aln_aa_from_codon(codon) let new_aa = aln_aa_from_codon(new_codon) @@ -123,17 +164,17 @@ pub fn aln_is_synonymous(codon : String, pos : Int, new_base : String) -> Bool { pub fn aln_count_sites(sequence : String) -> Array[Int] { let seq_len = sequence.length() let n_codons = seq_len / 3 - + let mut n_syn = 0 let mut n_nonsyn = 0 - + let bases = ["A", "C", "G", "T"] - + let mut codon_idx = 0 while codon_idx < n_codons { let codon_start = codon_idx * 3 let codon = substring(sequence, codon_start, 3) - + // Check each position in the codon let mut pos = 0 while pos < 3 { @@ -154,7 +195,7 @@ pub fn aln_count_sites(sequence : String) -> Array[Int] { } codon_idx = codon_idx + 1 } - + // Each site has 3 possible changes (excluding the original), so divide by 3 let sites = [n_syn / 3, n_nonsyn / 3] sites @@ -164,32 +205,36 @@ pub fn aln_count_sites(sequence : String) -> Array[Int] { /// Calculate dn/ds ratio between two sequences using the NG86 method. /// Nei-Gojobori method for estimating dn and ds. pub fn aln_analyze_dn_ds(seq1 : String, seq2 : String) -> AlnAnalysisResult { - let len = if seq1.length() < seq2.length() { seq1.length() } else { seq2.length() } + let len = if seq1.length() < seq2.length() { + seq1.length() + } else { + seq2.length() + } let n_codons = len / 3 - + let sites = aln_count_sites(seq1) let total_syn_sites = sites[0].to_double() let total_nonsyn_sites = sites[1].to_double() - + if total_syn_sites == 0.0 || total_nonsyn_sites == 0.0 { return AlnAnalysisResult::new(0.0, 0.0, 0.0, 0.0, 0, 0) } - + let mut n_syn_changes = 0.0 let mut n_nonsyn_changes = 0.0 - + let mut codon_idx = 0 while codon_idx < n_codons { let codon_start = codon_idx * 3 let codon1 = substring(seq1, codon_start, 3) let codon2 = substring(seq2, codon_start, 3) - + // Check each position in the codon let mut pos = 0 while pos < 3 { let base1 = substring(codon1, pos, 1) let base2 = substring(codon2, pos, 1) - + if base1 != base2 { if aln_is_synonymous(codon1, pos, base2) { n_syn_changes = n_syn_changes + 1.0 @@ -201,47 +246,49 @@ pub fn aln_analyze_dn_ds(seq1 : String, seq2 : String) -> AlnAnalysisResult { } codon_idx = codon_idx + 1 } - + // Calculate rates let ds = if total_syn_sites > 0.0 { n_syn_changes / total_syn_sites } else { 0.0 } - + let dn = if total_nonsyn_sites > 0.0 { n_nonsyn_changes / total_nonsyn_sites } else { 0.0 } - + // Calculate ratio let ratio = if ds > 0.0 { dn / ds } else { 0.0 } - + // Calculate SEM (simplified) let variance = if total_syn_sites > 0.0 && total_nonsyn_sites > 0.0 { - (1.0 / total_syn_sites) + (1.0 / total_nonsyn_sites) + 1.0 / total_syn_sites + 1.0 / total_nonsyn_sites } else { 1.0 } let sem = ratio * variance.sqrt() - + AlnAnalysisResult::new( dn, ds, ratio, sem, n_syn_changes.to_int(), - n_nonsyn_changes.to_int() + n_nonsyn_changes.to_int(), ) } ///| /// Calculate dn/ds matrix for multiple sequence comparisons. -pub fn aln_calculate_dn_ds_matrix(sequences : Array[String]) -> Array[Array[AlnAnalysisResult]] { +pub fn aln_calculate_dn_ds_matrix( + sequences : Array[String], +) -> Array[Array[AlnAnalysisResult]] { let n = sequences.length() let matrix : Array[Array[AlnAnalysisResult]] = Array::new() - + let mut i = 0 while i < n { let row : Array[AlnAnalysisResult] = Array::new() @@ -262,7 +309,7 @@ pub fn aln_calculate_dn_ds_matrix(sequences : Array[String]) -> Array[Array[AlnA matrix.push(row) i = i + 1 } - + // Fill symmetric entries let mut x = 0 while x < n { @@ -273,15 +320,19 @@ pub fn aln_calculate_dn_ds_matrix(sequences : Array[String]) -> Array[Array[AlnA } x = x + 1 } - + matrix } ///| /// Calculate Jukes-Cantor distance between two sequences. pub fn aln_jukes_cantor_distance(seq1 : String, seq2 : String) -> Double { - let len = if seq1.length() < seq2.length() { seq1.length() } else { seq2.length() } - + let len = if seq1.length() < seq2.length() { + seq1.length() + } else { + seq2.length() + } + let mut diffs = 0 let mut i = 0 while i < len { @@ -290,13 +341,13 @@ pub fn aln_jukes_cantor_distance(seq1 : String, seq2 : String) -> Double { } i = i + 1 } - + let p = diffs.to_double() / len.to_double() if p >= 0.75 { // Distance is too large for JC correction 10.0 } else { - let arg = 1.0 - (4.0 / 3.0) * p + let arg = 1.0 - 4.0 / 3.0 * p if arg > 0.0 { -0.75 * @math.ln(arg) } else { @@ -308,20 +359,32 @@ pub fn aln_jukes_cantor_distance(seq1 : String, seq2 : String) -> Double { ///| /// Calculate Kimura 2-parameter distance. pub fn aln_kimura_2p_distance(seq1 : String, seq2 : String) -> Double { - let len = if seq1.length() < seq2.length() { seq1.length() } else { seq2.length() } - + let len = if seq1.length() < seq2.length() { + seq1.length() + } else { + seq2.length() + } + let mut transitions = 0 let mut transversions = 0 - + let mut i = 0 while i < len { let base1 = substring(seq1, i, 1) let base2 = substring(seq2, i, 1) - + if base1 != base2 { - let is_base1_purine = if base1 == "A" || base1 == "G" { true } else { false } - let is_base2_purine = if base2 == "A" || base2 == "G" { true } else { false } - + let is_base1_purine = if base1 == "A" || base1 == "G" { + true + } else { + false + } + let is_base2_purine = if base2 == "A" || base2 == "G" { + true + } else { + false + } + if is_base1_purine == is_base2_purine { // Same type (both purine or both pyrimidine) = transition transitions = transitions + 1 @@ -332,13 +395,13 @@ pub fn aln_kimura_2p_distance(seq1 : String, seq2 : String) -> Double { } i = i + 1 } - + let p = transitions.to_double() / len.to_double() let q = transversions.to_double() / len.to_double() - + let arg1 = 1.0 - 2.0 * p - q let arg2 = 1.0 - 2.0 * q - + if arg1 <= 0.0 || arg2 <= 0.0 { 10.0 } else { @@ -348,10 +411,12 @@ pub fn aln_kimura_2p_distance(seq1 : String, seq2 : String) -> Double { ///| /// Calculate distance matrix using Jukes-Cantor method. -pub fn aln_jukes_cantor_matrix(sequences : Array[String]) -> Array[Array[Double]] { +pub fn aln_jukes_cantor_matrix( + sequences : Array[String], +) -> Array[Array[Double]] { let n = sequences.length() let matrix : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let row : Array[Double] = Array::make(n, 0.0) @@ -364,7 +429,7 @@ pub fn aln_jukes_cantor_matrix(sequences : Array[String]) -> Array[Array[Double] matrix.push(row) i = i + 1 } - + // Fill symmetric part let mut x = 0 while x < n { @@ -375,7 +440,7 @@ pub fn aln_jukes_cantor_matrix(sequences : Array[String]) -> Array[Array[Double] } x = x + 1 } - + matrix } @@ -384,7 +449,7 @@ pub fn aln_jukes_cantor_matrix(sequences : Array[String]) -> Array[Array[Double] pub fn aln_kimura_2p_matrix(sequences : Array[String]) -> Array[Array[Double]] { let n = sequences.length() let matrix : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let row : Array[Double] = Array::make(n, 0.0) @@ -397,7 +462,7 @@ pub fn aln_kimura_2p_matrix(sequences : Array[String]) -> Array[Array[Double]] { matrix.push(row) i = i + 1 } - + // Fill symmetric part let mut x = 0 while x < n { @@ -408,15 +473,19 @@ pub fn aln_kimura_2p_matrix(sequences : Array[String]) -> Array[Array[Double]] { } x = x + 1 } - + matrix } ///| /// Calculate number of substitutions per site (simple p-distance). pub fn aln_p_distance(seq1 : String, seq2 : String) -> Double { - let len = if seq1.length() < seq2.length() { seq1.length() } else { seq2.length() } - + let len = if seq1.length() < seq2.length() { + seq1.length() + } else { + seq2.length() + } + let mut diffs = 0 let mut i = 0 while i < len { @@ -425,6 +494,6 @@ pub fn aln_p_distance(seq1 : String, seq2 : String) -> Double { } i = i + 1 } - + diffs.to_double() / len.to_double() } diff --git a/src/align_applications.mbt b/src/align_applications.mbt index e45734fc..65b1fc66 100644 --- a/src/align_applications.mbt +++ b/src/align_applications.mbt @@ -12,33 +12,63 @@ pub fn ClustalwCommandline::new(executable : String) -> ClustalwCommandline { } ///| -pub fn ClustalwCommandline::set_input(self : ClustalwCommandline, infile : String) -> ClustalwCommandline { - ClustalwCommandline::{ commandline: self.commandline.add_arg("-infile", Some(infile)) } +pub fn ClustalwCommandline::set_input( + self : ClustalwCommandline, + infile : String, +) -> ClustalwCommandline { + ClustalwCommandline::{ + commandline: self.commandline.add_arg("-infile", Some(infile)), + } } ///| -pub fn ClustalwCommandline::set_output(self : ClustalwCommandline, outfile : String) -> ClustalwCommandline { - ClustalwCommandline::{ commandline: self.commandline.add_arg("-outfile", Some(outfile)) } +pub fn ClustalwCommandline::set_output( + self : ClustalwCommandline, + outfile : String, +) -> ClustalwCommandline { + ClustalwCommandline::{ + commandline: self.commandline.add_arg("-outfile", Some(outfile)), + } } ///| -pub fn ClustalwCommandline::set_output_format(self : ClustalwCommandline, format : String) -> ClustalwCommandline { - ClustalwCommandline::{ commandline: self.commandline.add_arg("-output", Some(format)) } +pub fn ClustalwCommandline::set_output_format( + self : ClustalwCommandline, + format : String, +) -> ClustalwCommandline { + ClustalwCommandline::{ + commandline: self.commandline.add_arg("-output", Some(format)), + } } ///| -pub fn ClustalwCommandline::set_matrix(self : ClustalwCommandline, matrix : String) -> ClustalwCommandline { - ClustalwCommandline::{ commandline: self.commandline.add_arg("-matrix", Some(matrix)) } +pub fn ClustalwCommandline::set_matrix( + self : ClustalwCommandline, + matrix : String, +) -> ClustalwCommandline { + ClustalwCommandline::{ + commandline: self.commandline.add_arg("-matrix", Some(matrix)), + } } ///| -pub fn ClustalwCommandline::set_gap_open(self : ClustalwCommandline, penalty : Double) -> ClustalwCommandline { - ClustalwCommandline::{ commandline: self.commandline.add_arg("-gapopen", Some(penalty.to_string())) } +pub fn ClustalwCommandline::set_gap_open( + self : ClustalwCommandline, + penalty : Double, +) -> ClustalwCommandline { + ClustalwCommandline::{ + commandline: self.commandline.add_arg("-gapopen", Some(penalty.to_string())), + } } ///| -pub fn ClustalwCommandline::set_gap_extend(self : ClustalwCommandline, penalty : Double) -> ClustalwCommandline { - ClustalwCommandline::{ commandline: self.commandline.add_arg("-gapext", Some(penalty.to_string())) } +pub fn ClustalwCommandline::set_gap_extend( + self : ClustalwCommandline, + penalty : Double, +) -> ClustalwCommandline { + ClustalwCommandline::{ + commandline: self.commandline.add_arg("-gapext", Some(penalty.to_string())), + } } ///| @@ -52,33 +82,59 @@ pub struct ClustalOmegaCommandline { } ///| -pub fn ClustalOmegaCommandline::new(executable : String) -> ClustalOmegaCommandline { +pub fn ClustalOmegaCommandline::new( + executable : String, +) -> ClustalOmegaCommandline { ClustalOmegaCommandline::{ commandline: AbstractCommandline::new(executable) } } ///| -pub fn ClustalOmegaCommandline::set_input(self : ClustalOmegaCommandline, infile : String) -> ClustalOmegaCommandline { - ClustalOmegaCommandline::{ commandline: self.commandline.add_arg("-i", Some(infile)) } +pub fn ClustalOmegaCommandline::set_input( + self : ClustalOmegaCommandline, + infile : String, +) -> ClustalOmegaCommandline { + ClustalOmegaCommandline::{ + commandline: self.commandline.add_arg("-i", Some(infile)), + } } ///| -pub fn ClustalOmegaCommandline::set_output(self : ClustalOmegaCommandline, outfile : String) -> ClustalOmegaCommandline { - ClustalOmegaCommandline::{ commandline: self.commandline.add_arg("-o", Some(outfile)) } +pub fn ClustalOmegaCommandline::set_output( + self : ClustalOmegaCommandline, + outfile : String, +) -> ClustalOmegaCommandline { + ClustalOmegaCommandline::{ + commandline: self.commandline.add_arg("-o", Some(outfile)), + } } ///| -pub fn ClustalOmegaCommandline::set_output_format(self : ClustalOmegaCommandline, format : String) -> ClustalOmegaCommandline { - ClustalOmegaCommandline::{ commandline: self.commandline.add_arg("--outfmt", Some(format)) } +pub fn ClustalOmegaCommandline::set_output_format( + self : ClustalOmegaCommandline, + format : String, +) -> ClustalOmegaCommandline { + ClustalOmegaCommandline::{ + commandline: self.commandline.add_arg("--outfmt", Some(format)), + } } ///| -pub fn ClustalOmegaCommandline::set_iterations(self : ClustalOmegaCommandline, n : Int) -> ClustalOmegaCommandline { - ClustalOmegaCommandline::{ commandline: self.commandline.add_arg("--iterations", Some(n.to_string())) } +pub fn ClustalOmegaCommandline::set_iterations( + self : ClustalOmegaCommandline, + n : Int, +) -> ClustalOmegaCommandline { + ClustalOmegaCommandline::{ + commandline: self.commandline.add_arg("--iterations", Some(n.to_string())), + } } ///| -pub fn ClustalOmegaCommandline::set_full_matrix(self : ClustalOmegaCommandline) -> ClustalOmegaCommandline { - ClustalOmegaCommandline::{ commandline: self.commandline.add_arg("--full", None) } +pub fn ClustalOmegaCommandline::set_full_matrix( + self : ClustalOmegaCommandline, +) -> ClustalOmegaCommandline { + ClustalOmegaCommandline::{ + commandline: self.commandline.add_arg("--full", None), + } } ///| @@ -97,23 +153,40 @@ pub fn MuscleCommandline::new(executable : String) -> MuscleCommandline { } ///| -pub fn MuscleCommandline::set_input(self : MuscleCommandline, infile : String) -> MuscleCommandline { - MuscleCommandline::{ commandline: self.commandline.add_arg("-in", Some(infile)) } +pub fn MuscleCommandline::set_input( + self : MuscleCommandline, + infile : String, +) -> MuscleCommandline { + MuscleCommandline::{ + commandline: self.commandline.add_arg("-in", Some(infile)), + } } ///| -pub fn MuscleCommandline::set_output(self : MuscleCommandline, outfile : String) -> MuscleCommandline { - MuscleCommandline::{ commandline: self.commandline.add_arg("-out", Some(outfile)) } +pub fn MuscleCommandline::set_output( + self : MuscleCommandline, + outfile : String, +) -> MuscleCommandline { + MuscleCommandline::{ + commandline: self.commandline.add_arg("-out", Some(outfile)), + } } ///| -pub fn MuscleCommandline::set_diags(self : MuscleCommandline) -> MuscleCommandline { +pub fn MuscleCommandline::set_diags( + self : MuscleCommandline, +) -> MuscleCommandline { MuscleCommandline::{ commandline: self.commandline.add_arg("-diags", None) } } ///| -pub fn MuscleCommandline::set_max_iterations(self : MuscleCommandline, n : Int) -> MuscleCommandline { - MuscleCommandline::{ commandline: self.commandline.add_arg("-maxiters", Some(n.to_string())) } +pub fn MuscleCommandline::set_max_iterations( + self : MuscleCommandline, + n : Int, +) -> MuscleCommandline { + MuscleCommandline::{ + commandline: self.commandline.add_arg("-maxiters", Some(n.to_string())), + } } ///| @@ -132,13 +205,23 @@ pub fn MAFFTCommandline::new(executable : String) -> MAFFTCommandline { } ///| -pub fn MAFFTCommandline::set_input(self : MAFFTCommandline, infile : String) -> MAFFTCommandline { - MAFFTCommandline::{ commandline: self.commandline.add_arg("--input", Some(infile)) } +pub fn MAFFTCommandline::set_input( + self : MAFFTCommandline, + infile : String, +) -> MAFFTCommandline { + MAFFTCommandline::{ + commandline: self.commandline.add_arg("--input", Some(infile)), + } } ///| -pub fn MAFFTCommandline::set_output(self : MAFFTCommandline, outfile : String) -> MAFFTCommandline { - MAFFTCommandline::{ commandline: self.commandline.add_arg("--output", Some(outfile)) } +pub fn MAFFTCommandline::set_output( + self : MAFFTCommandline, + outfile : String, +) -> MAFFTCommandline { + MAFFTCommandline::{ + commandline: self.commandline.add_arg("--output", Some(outfile)), + } } ///| @@ -147,8 +230,13 @@ pub fn MAFFTCommandline::set_auto(self : MAFFTCommandline) -> MAFFTCommandline { } ///| -pub fn MAFFTCommandline::set_threads(self : MAFFTCommandline, n : Int) -> MAFFTCommandline { - MAFFTCommandline::{ commandline: self.commandline.add_arg("--thread", Some(n.to_string())) } +pub fn MAFFTCommandline::set_threads( + self : MAFFTCommandline, + n : Int, +) -> MAFFTCommandline { + MAFFTCommandline::{ + commandline: self.commandline.add_arg("--thread", Some(n.to_string())), + } } ///| @@ -194,4 +282,4 @@ pub fn create_example_mafft() -> MAFFTCommandline { let cmd = cmd.set_auto() let cmd = cmd.set_threads(4) cmd -} \ No newline at end of file +} diff --git a/src/align_bed.mbt b/src/align_bed.mbt index ae36eace..805d4fb7 100644 --- a/src/align_bed.mbt +++ b/src/align_bed.mbt @@ -170,8 +170,7 @@ fn align_bed_validate_score(score : AlignBedScore) -> Unit raise AlignBedError { if value.is_nan() || value.abs() > 1.0e300 { align_bed_fail("BED score must be finite") } - AlignBedText(value) => - align_bed_validate_token(value, "BED score", false) + AlignBedText(value) => align_bed_validate_token(value, "BED score", false) } } @@ -351,9 +350,7 @@ pub fn AlignBedScore::numeric( ///| /// Construct a non-empty textual BED score token. -pub fn AlignBedScore::text( - value : String, -) -> AlignBedScore raise AlignBedError { +pub fn AlignBedScore::text(value : String) -> AlignBedScore raise AlignBedError { let score = AlignBedText(value) align_bed_validate_score(score) score @@ -699,10 +696,7 @@ fn align_bed_coordinates_from_blocks( let coordinates : Array[AlignBedCoordinate] = [] let mut query_position = 0 let mut target_position = chrom_start - coordinates.push(AlignBedCoordinate::{ - target: chrom_start, - query: 0, - }) + coordinates.push(AlignBedCoordinate::{ target: chrom_start, query: 0 }) for index in 0.. AlignBedDocument raise AlignBedError { +pub fn align_bed_parse(text : String) -> AlignBedDocument raise AlignBedError { if text.length() == 0 { return AlignBedDocument::create([]) } @@ -861,9 +854,7 @@ pub fn align_bed_parse( if index + 1 == lines.length() { continue } - align_bed_fail( - "blank BED record at line " + (index + 1).to_string(), - ) + align_bed_fail("blank BED record at line " + (index + 1).to_string()) } alignments.push(align_bed_parse_line(line, index + 1)) } diff --git a/src/align_cluster.mbt b/src/align_cluster.mbt index b92a5060..6340b954 100644 --- a/src/align_cluster.mbt +++ b/src/align_cluster.mbt @@ -106,19 +106,27 @@ pub fn MSADistanceMatrix::new( ///| /// Get the distance matrix as a 2D array. -pub fn MSADistanceMatrix::get_matrix(self : MSADistanceMatrix) -> Array[Array[Double]] { +pub fn MSADistanceMatrix::get_matrix( + self : MSADistanceMatrix, +) -> Array[Array[Double]] { self.matrix } ///| /// Get the sequence IDs. -pub fn MSADistanceMatrix::get_sequence_ids(self : MSADistanceMatrix) -> Array[String] { +pub fn MSADistanceMatrix::get_sequence_ids( + self : MSADistanceMatrix, +) -> Array[String] { self.sequence_ids } ///| /// Get the distance between two sequences by index. -pub fn MSADistanceMatrix::get(self : MSADistanceMatrix, i : Int, j : Int) -> Double { +pub fn MSADistanceMatrix::get( + self : MSADistanceMatrix, + i : Int, + j : Int, +) -> Double { self.matrix[i][j] } @@ -169,7 +177,7 @@ pub struct GuideTree { ///| /// Create a new GuideTree from an array of nodes. pub fn GuideTree::new(nodes : Array[GuideTreeNode]) -> GuideTree { - GuideTree::{ nodes } + GuideTree::{ nodes, } } ///| @@ -308,11 +316,7 @@ pub fn upgma_tree(distance_matrix : MSADistanceMatrix) -> GuideTree { let size_i = count_leaves_in_node(nodes, i_idx) let size_j = count_leaves_in_node(nodes, j_idx) - let new_node = guide_tree_internal( - next_id, - [i_idx, j_idx], - height, - ) + let new_node = guide_tree_internal(next_id, [i_idx, j_idx], height) nodes.push(new_node) let new_node_idx = next_id next_id = next_id + 1 @@ -321,9 +325,10 @@ pub fn upgma_tree(distance_matrix : MSADistanceMatrix) -> GuideTree { for k = 0; k < m; k = k + 1 { if k != min_i && k != min_j { let d = ( - size_i.to_double() * dist[min_i][k] + - size_j.to_double() * dist[min_j][k] - ) / (size_i.to_double() + size_j.to_double()) + size_i.to_double() * dist[min_i][k] + + size_j.to_double() * dist[min_j][k] + ) / + (size_i.to_double() + size_j.to_double()) new_dists_row.push(d) } } @@ -356,15 +361,12 @@ pub fn upgma_tree(distance_matrix : MSADistanceMatrix) -> GuideTree { dist = new_dist } - GuideTree::{ nodes } + GuideTree::{ nodes, } } ///| /// Count the number of leaf nodes under a given node. -fn count_leaves_in_node( - nodes : Array[GuideTreeNode], - node_idx : Int, -) -> Int { +fn count_leaves_in_node(nodes : Array[GuideTreeNode], node_idx : Int) -> Int { let node = nodes[node_idx] if node.is_leaf { 1 @@ -379,9 +381,7 @@ fn count_leaves_in_node( ///| /// Copy a distance matrix. -fn copy_distance_matrix( - matrix : Array[Array[Double]], -) -> Array[Array[Double]] { +fn copy_distance_matrix(matrix : Array[Array[Double]]) -> Array[Array[Double]] { let result : Array[Array[Double]] = Array::new() for row in matrix { let new_row : Array[Double] = Array::new() @@ -400,18 +400,8 @@ fn copy_distance_matrix( /// `seq2` — second sequence string. /// /// Returns a tuple of (aligned_seq1, aligned_seq2, alignment_score). -pub fn align_pairwise( - seq1 : String, - seq2 : String, -) -> (String, String, Double) { - align_pairwise_with_scoring( - seq1, - seq2, - 2.0, - -1.0, - -2.0, - -0.5, - ) +pub fn align_pairwise(seq1 : String, seq2 : String) -> (String, String, Double) { + align_pairwise_with_scoring(seq1, seq2, 2.0, -1.0, -2.0, -0.5) } ///| @@ -469,11 +459,7 @@ pub fn align_pairwise_with_scoring( for j = 1; j <= m; j = j + 1 { let c1 = seq1.unsafe_get(i - 1) let c2 = seq2.unsafe_get(j - 1) - let sub_score = if c1 == c2 { - match_score - } else { - mismatch_score - } + let sub_score = if c1 == c2 { match_score } else { mismatch_score } let diag = dp[i - 1][j - 1] + sub_score let up = dp[i - 1][j] + @@ -784,12 +770,11 @@ pub fn progressive_alignment( let mut all_processed = true for child_idx in node.children { match processed.get(child_idx) { - Some(true) => { + Some(true) => match alignment_map.get(child_idx) { Some(profile) => child_results.push(profile) None => all_processed = false } - } _ => all_processed = false } } @@ -797,8 +782,7 @@ pub fn progressive_alignment( let left_profile = child_results[0] let right_profile = child_results[1] let (aligned_left, aligned_right, _) = align_profiles( - left_profile, - right_profile, + left_profile, right_profile, ) let left_aligned_profile : Array[String] = Array::new() let right_aligned_profile : Array[String] = Array::new() @@ -867,7 +851,7 @@ pub fn progressive_alignment( } else { "seq_" + seq_id_idx.to_string() } - records.push(SeqRecord::new(Seq::new(s), id=id)) + records.push(SeqRecord::new(Seq::new(s), id~)) seq_id_idx = seq_id_idx + 1 } create_msa_safe(records) @@ -881,9 +865,7 @@ fn create_msa_safe(records : Array[SeqRecord]) -> MultipleSeqAlignment { annotations: Map([], capacity=0), column_annotations: Map([], capacity=0), } - try { - MultipleSeqAlignment::new(records) - } catch { + MultipleSeqAlignment::new(records) catch { _ => empty } } @@ -988,4 +970,4 @@ fn repeat_char(c : Char, n : Int) -> String { buf.write_char(c) } buf.to_string() -} \ No newline at end of file +} diff --git a/src/alignace.mbt b/src/alignace.mbt index c8225bd2..7b1ec010 100644 --- a/src/alignace.mbt +++ b/src/alignace.mbt @@ -45,7 +45,11 @@ pub struct AlignAceMotif { ///| /// Construct an AlignAceMotif from a count matrix. pub fn AlignAceMotif::new(count_matrix : Array[Array[Int]]) -> AlignAceMotif { - let width = if count_matrix.length() > 0 { count_matrix[0].length() } else { 0 } + let width = if count_matrix.length() > 0 { + count_matrix[0].length() + } else { + 0 + } let mut total = 0 if width > 0 { for base_idx in 0..<4 { @@ -124,7 +128,10 @@ pub fn AlignAceMotif::add_site(self : AlignAceMotif, s : AlignAceSite) -> Unit { ///| /// Add a motif to the record. -pub fn AlignAceRecord::add_motif(self : AlignAceRecord, m : AlignAceMotif) -> Unit { +pub fn AlignAceRecord::add_motif( + self : AlignAceRecord, + m : AlignAceMotif, +) -> Unit { self.motifs.push(m) } @@ -218,10 +225,7 @@ pub fn alignace_parse(text : String) -> AlignAceRecord { ///| /// Parse a motif matrix starting at the given line index. /// Returns Some(motif) if successful, None otherwise. -fn alignace_parse_motif( - lines : Array[String], - start : Int, -) -> AlignAceMotif? { +fn alignace_parse_motif(lines : Array[String], start : Int) -> AlignAceMotif? { // Line 0: "i T G A C T C G A T" (consensus letters) // Line 1: " 0 1 2 3 4 5 6 7 8 9" (column indices) // Line 2: "A 1 0 8 0 0 0 0 0 0 0" @@ -269,23 +273,13 @@ fn alignace_parse_site(text : String) -> AlignAceSite? { let strand = parts[2] let sequence = parts[3] return Some( - AlignAceSite::new( - sequence_id=seq_id, - position=pos, - strand=strand, - sequence=sequence, - ), + AlignAceSite::new(sequence_id=seq_id, position=pos, strand~, sequence~), ) } // No strand field, assume "+" let sequence = parts[2] Some( - AlignAceSite::new( - sequence_id=seq_id, - position=pos, - strand="+", - sequence=sequence, - ), + AlignAceSite::new(sequence_id=seq_id, position=pos, strand="+", sequence~), ) } @@ -360,7 +354,8 @@ pub fn alignace_to_pwm(motif : AlignAceMotif) -> Array[Array[Double]] { motif.count_matrix[2][col] + motif.count_matrix[3][col] if total > 0 { - freq_row[col] = motif.count_matrix[row][col].to_double() / total.to_double() + freq_row[col] = motif.count_matrix[row][col].to_double() / + total.to_double() } else { freq_row[col] = 0.25 } @@ -474,8 +469,15 @@ fn alignace_write_motif(motif : AlignAceMotif) -> String { sb.write_string("# Sites:\n") for site in motif.sites { sb.write_string( - "# " + site.sequence_id + "\t" + site.position.to_string() + "\t" + - site.strand + "\t" + site.sequence + "\n", + "# " + + site.sequence_id + + "\t" + + site.position.to_string() + + "\t" + + site.strand + + "\t" + + site.sequence + + "\n", ) } sb.write_string("#\n") @@ -495,7 +497,10 @@ pub fn alignace_num_motifs(record : AlignAceRecord) -> Int { ///| /// Get a motif by index (0-based). Returns None if out of range. -pub fn alignace_get_motif(record : AlignAceRecord, index : Int) -> AlignAceMotif? { +pub fn alignace_get_motif( + record : AlignAceRecord, + index : Int, +) -> AlignAceMotif? { if index >= 0 && index < record.motifs.length() { Some(record.motifs[index]) } else { @@ -510,7 +515,9 @@ pub fn alignace_summary(record : AlignAceRecord) -> String { sb.write_string("AlignACE Record Summary:\n") sb.write_string(" Version: " + record.version + "\n") sb.write_string(" Command: " + record.command + "\n") - sb.write_string(" Parameters: " + record.parameters.size().to_string() + "\n") + sb.write_string( + " Parameters: " + record.parameters.size().to_string() + "\n", + ) let keys = record.parameters.keys() for k in keys { sb.write_string(" " + k + " = " + record.parameters[k] + "\n") @@ -519,9 +526,15 @@ pub fn alignace_summary(record : AlignAceRecord) -> String { for i in 0.. AlignAceRecord { record.parameters["numcols"] = "10" record.parameters["expect"] = "10" // Motif 1: TGACTCGAT - let m1 = AlignAceMotif::new( - [ - [1, 0, 8, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 1, 0, 8, 0, 0, 1], - [0, 8, 0, 0, 0, 0, 0, 8, 0, 0], - [7, 0, 0, 8, 7, 8, 0, 0, 8, 7], - ], - ) + let m1 = AlignAceMotif::new([ + [1, 0, 8, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 1, 0, 8, 0, 0, 1], + [0, 8, 0, 0, 0, 0, 0, 8, 0, 0], + [7, 0, 0, 8, 7, 8, 0, 0, 8, 7], + ]) m1.sites.push( AlignAceSite::new( sequence_id="seq1", @@ -563,14 +574,12 @@ pub fn alignace_sample() -> AlignAceRecord { ) record.motifs.push(m1) // Motif 2: AATAAACAAA - let m2 = AlignAceMotif::new( - [ - [8, 8, 1, 8, 8, 8, 0, 8, 8, 8], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], - [1, 1, 8, 1, 1, 1, 9, 1, 1, 1], - ], - ) + let m2 = AlignAceMotif::new([ + [8, 8, 1, 8, 8, 8, 0, 8, 8, 8], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [1, 1, 8, 1, 1, 1, 9, 1, 1, 1], + ]) record.motifs.push(m2) record } diff --git a/src/alignment_map.mbt b/src/alignment_map.mbt index be14bede..88f6219e 100644 --- a/src/alignment_map.mbt +++ b/src/alignment_map.mbt @@ -437,15 +437,12 @@ pub fn CoordinatePairwiseAlignment::map( let (reversed_target, reversed_query) = if relationship2 > 0 { alignment_map_transform_against_reverse_middle(next) } else { - let reversed_middle = alignment_map_reverse(next.target_coordinates) - let normalized_middle : Array[Int] = [] - for value in reversed_middle { - normalized_middle.push(next.target_length - value) - } - ( - normalized_middle, - alignment_map_reverse(next.query_coordinates), - ) + let reversed_middle = alignment_map_reverse(next.target_coordinates) + let normalized_middle : Array[Int] = [] + for value in reversed_middle { + normalized_middle.push(next.target_length - value) + } + (normalized_middle, alignment_map_reverse(next.query_coordinates)) } coordinates2_target = reversed_target coordinates2_query = reversed_query diff --git a/src/alphabet.mbt b/src/alphabet.mbt index a9fde8f0..a6b26035 100644 --- a/src/alphabet.mbt +++ b/src/alphabet.mbt @@ -13,31 +13,35 @@ pub struct Alphabet { ///| /// Create a new alphabet. -pub fn Alphabet::new(name : String, letters : Array[String], is_gapped : Bool) -> Alphabet { +pub fn Alphabet::new( + name : String, + letters : Array[String], + is_gapped : Bool, +) -> Alphabet { Alphabet::{ name, letters, is_gapped } } ///| /// Get alphabet name. -pub fn get_name(self : Alphabet) -> String { +pub fn Alphabet::get_name(self : Alphabet) -> String { self.name } ///| /// Get alphabet letters. -pub fn get_letters(self : Alphabet) -> Array[String] { +pub fn Alphabet::get_letters(self : Alphabet) -> Array[String] { self.letters } ///| /// Check if alphabet is gapped. -pub fn is_gapped(self : Alphabet) -> Bool { +pub fn Alphabet::is_gapped(self : Alphabet) -> Bool { self.is_gapped } ///| /// Check if a character is valid in this alphabet. -pub fn is_valid(self : Alphabet, c : String) -> Bool { +pub fn Alphabet::is_valid(self : Alphabet, c : String) -> Bool { let mut i = 0 while i < self.letters.length() { if self.letters[i] == c { @@ -51,18 +55,14 @@ pub fn is_valid(self : Alphabet, c : String) -> Bool { ///| /// IUPAC unambiguous DNA alphabet (A, C, G, T). pub fn iupac_unambiguous_dna() -> Alphabet { - let letters = [ - "A", "C", "G", "T" - ] + let letters = ["A", "C", "G", "T"] Alphabet::new("IUPACUnambiguousDNA", letters, false) } ///| /// IUPAC unambiguous RNA alphabet (A, C, G, U). pub fn iupac_unambiguous_rna() -> Alphabet { - let letters = [ - "A", "C", "G", "U" - ] + let letters = ["A", "C", "G", "U"] Alphabet::new("IUPACUnambiguousRNA", letters, false) } @@ -70,9 +70,7 @@ pub fn iupac_unambiguous_rna() -> Alphabet { /// IUPAC ambiguous DNA alphabet (A, C, G, T, R, Y, S, W, K, M, B, D, H, V, N). pub fn iupac_ambiguous_dna() -> Alphabet { let letters = [ - "A", "C", "G", "T", - "R", "Y", "S", "W", "K", "M", - "B", "D", "H", "V", "N" + "A", "C", "G", "T", "R", "Y", "S", "W", "K", "M", "B", "D", "H", "V", "N", ] Alphabet::new("IUPACAmbiguousDNA", letters, false) } @@ -81,9 +79,7 @@ pub fn iupac_ambiguous_dna() -> Alphabet { /// IUPAC ambiguous RNA alphabet (A, C, G, U, R, Y, S, W, K, M, B, D, H, V, N). pub fn iupac_ambiguous_rna() -> Alphabet { let letters = [ - "A", "C", "G", "U", - "R", "Y", "S", "W", "K", "M", - "B", "D", "H", "V", "N" + "A", "C", "G", "U", "R", "Y", "S", "W", "K", "M", "B", "D", "H", "V", "N", ] Alphabet::new("IUPACAmbiguousRNA", letters, false) } @@ -92,9 +88,8 @@ pub fn iupac_ambiguous_rna() -> Alphabet { /// IUPAC protein alphabet (20 standard amino acids + B, Z, X). pub fn iupac_protein() -> Alphabet { let letters = [ - "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", - "M", "N", "P", "Q", "R", "S", "T", "V", "W", "Y", - "B", "Z", "X" + "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", "M", "N", "P", "Q", "R", "S", + "T", "V", "W", "Y", "B", "Z", "X", ] Alphabet::new("IUPACProtein", letters, false) } @@ -103,9 +98,8 @@ pub fn iupac_protein() -> Alphabet { /// Extended IUPAC protein alphabet (20 standard + B, Z, X, U, O). pub fn iupac_extended_protein() -> Alphabet { let letters = [ - "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", - "M", "N", "P", "Q", "R", "S", "T", "V", "W", "Y", - "B", "Z", "X", "U", "O" + "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", "M", "N", "P", "Q", "R", "S", + "T", "V", "W", "Y", "B", "Z", "X", "U", "O", ] Alphabet::new("IUPACExtendedProtein", letters, false) } @@ -113,18 +107,14 @@ pub fn iupac_extended_protein() -> Alphabet { ///| /// Gapped DNA alphabet (includes gap character '-'). pub fn gapped_dna() -> Alphabet { - let letters = [ - "A", "C", "G", "T", "-" - ] + let letters = ["A", "C", "G", "T", "-"] Alphabet::new("GappedDNA", letters, true) } ///| /// Gapped RNA alphabet (includes gap character '-'). pub fn gapped_rna() -> Alphabet { - let letters = [ - "A", "C", "G", "U", "-" - ] + let letters = ["A", "C", "G", "U", "-"] Alphabet::new("GappedRNA", letters, true) } @@ -132,9 +122,8 @@ pub fn gapped_rna() -> Alphabet { /// Gapped protein alphabet (includes gap character '-'). pub fn gapped_protein() -> Alphabet { let letters = [ - "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", - "M", "N", "P", "Q", "R", "S", "T", "V", "W", "Y", - "-" + "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", "M", "N", "P", "Q", "R", "S", + "T", "V", "W", "Y", "-", ] Alphabet::new("GappedProtein", letters, true) } @@ -144,8 +133,8 @@ pub fn gapped_protein() -> Alphabet { /// Grouped by chemical properties. pub fn reduced_protein() -> Alphabet { let letters = [ - "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", - "M", "N", "P", "Q", "R", "S", "T", "V", "W", "Y" + "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", "M", "N", "P", "Q", "R", "S", + "T", "V", "W", "Y", ] Alphabet::new("ReducedProtein", letters, false) } diff --git a/src/ancombc.mbt b/src/ancombc.mbt index be2433a2..77a57deb 100644 --- a/src/ancombc.mbt +++ b/src/ancombc.mbt @@ -62,7 +62,7 @@ fn abc_variance(arr : Array[Double]) -> Double { /// Welch-Satterthwaite degrees of freedom. fn abc_welch_t( group1 : Array[Double], - group2 : Array[Double] + group2 : Array[Double], ) -> (Double, Double) { let n1 = group1.length() let n2 = group2.length() @@ -79,9 +79,13 @@ fn abc_welch_t( } let t = (m1 - m2) / se // Welch-Satterthwaite df. - let num = (v1 / n1.to_double() + v2 / n2.to_double()) - let denom1 = v1 * v1 / ((n1.to_double() - 1.0) * n1.to_double() * n1.to_double()) - let denom2 = v2 * v2 / ((n2.to_double() - 1.0) * n2.to_double() * n2.to_double()) + let num = v1 / n1.to_double() + v2 / n2.to_double() + let denom1 = v1 * + v1 / + ((n1.to_double() - 1.0) * n1.to_double() * n1.to_double()) + let denom2 = v2 * + v2 / + ((n2.to_double() - 1.0) * n2.to_double() * n2.to_double()) let df = if denom1 + denom2 > 0.0 { num * num / (denom1 + denom2) } else { @@ -120,11 +124,12 @@ fn abc_normal_cdf(z : Double) -> Double { let t = 1.0 / (1.0 + 0.3275911 * x) let exp_val = @math.exp(0.0 - x * x / 2.0) let y2 = 1.0 - - (((((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - - 0.284496736) * - t + - 0.254829592) * - t) * + ( + (((1.061405429 * t - 1.453152027) * t + 1.421413741) * t - 0.284496736) * + t + + 0.254829592 + ) * + t * exp_val 0.5 * (1.0 + sign * y2) } @@ -143,7 +148,13 @@ fn abc_bh_fdr(pvalues : Array[Double]) -> Array[Double] { indexed.push((i, pvalues[i])) } indexed.sort_by(fn(a : (Int, Double), b : (Int, Double)) -> Int { - if a.1 < b.1 { -1 } else if a.1 > b.1 { 1 } else { 0 } + if a.1 < b.1 { + -1 + } else if a.1 > b.1 { + 1 + } else { + 0 + } }) // Compute adjusted p-values from largest to smallest. let adjusted : Array[Double] = Array::make(m, 0.0) @@ -174,7 +185,10 @@ pub struct AncombcFeature { ///| /// Construct an AncombcFeature. -pub fn AncombcFeature::new(name : String, counts : Array[Int]) -> AncombcFeature { +pub fn AncombcFeature::new( + name : String, + counts : Array[Int], +) -> AncombcFeature { AncombcFeature::{ name, counts } } @@ -237,7 +251,7 @@ pub fn AncombcData::new( sample_names : Array[String], sample_groups : Array[String], feature_names : Array[String], - counts : Array[Array[Int]] + counts : Array[Array[Int]], ) -> AncombcData { AncombcData::{ sample_names, sample_groups, feature_names, counts } } @@ -277,7 +291,7 @@ pub fn AncombcData::counts(self : AncombcData) -> Array[Array[Int]] { pub fn AncombcData::get_count( self : AncombcData, feature_idx : Int, - sample_idx : Int + sample_idx : Int, ) -> Int { self.counts[feature_idx][sample_idx] } @@ -344,9 +358,7 @@ pub fn ancombc_sampling_fractions(data : AncombcData) -> Array[Double] { /// y[i,j] = log(count[i,j] + 0.5) - log(s_j * N + 0.5) /// where s_j is the sampling fraction and N is the number of features. /// This adjusts for differences in sequencing depth (library size). -pub fn ancombc_bias_corrected_log( - data : AncombcData -) -> Array[Array[Double]] { +pub fn ancombc_bias_corrected_log(data : AncombcData) -> Array[Array[Double]] { let n_features = data.n_features() let n_samples = data.n_samples() let fracs = ancombc_sampling_fractions(data) @@ -412,9 +424,16 @@ pub fn AncombcResult::new( w_stat : Int, p_value : Double, q_value : Double, - significant : Bool + significant : Bool, ) -> AncombcResult { - AncombcResult::{ feature, log_fold_change, w_stat, p_value, q_value, significant } + AncombcResult::{ + feature, + log_fold_change, + w_stat, + p_value, + q_value, + significant, + } } ///| @@ -461,14 +480,14 @@ pub struct AncombcTestResult { } ///| -pub fn AncombcTestResult::results(self : AncombcTestResult) -> Array[AncombcResult] { +pub fn AncombcTestResult::results( + self : AncombcTestResult, +) -> Array[AncombcResult] { self.results } ///| -pub fn AncombcTestResult::reference_feature( - self : AncombcTestResult -) -> String { +pub fn AncombcTestResult::reference_feature(self : AncombcTestResult) -> String { self.reference_feature } @@ -517,7 +536,7 @@ pub fn ancombc_test( data : AncombcData, group1 : String, group2 : String, - alpha : Double + alpha : Double, ) -> AncombcTestResult { let n_features = data.n_features() let n_samples = data.n_samples() @@ -535,11 +554,7 @@ pub fn ancombc_test( let log_data = ancombc_bias_corrected_log(data) // Select reference feature. let ref_idx = ancombc_reference_feature(data) - let ref_name = if ref_idx >= 0 { - data.feature_names[ref_idx] - } else { - "" - } + let ref_name = if ref_idx >= 0 { data.feature_names[ref_idx] } else { "" } // Compute log-ratios relative to reference: y_i - y_ref for each sample. let log_ratios : Array[Array[Double]] = Array::new() for i in 0.. String { sb.write_string(result.n_significant().to_string()) sb.write_char('\n') sb.write_string("--- Per-feature results ---\n") - sb.write_string( - "feature\tlogFC\tW\tp_value\tq_value\tsignificant\n", - ) + sb.write_string("feature\tlogFC\tW\tp_value\tq_value\tsignificant\n") for r in result.results { sb.write_string(r.feature) sb.write_char('\t') @@ -689,10 +702,13 @@ pub fn ancombc_result_summary(result : AncombcTestResult) -> String { pub fn ancombc_sample_data() -> AncombcData { let sample_names = ["S1", "S2", "S3", "S4", "S5", "S6", "S7", "S8"] let sample_groups = [ - "control", "control", "control", "control", "treatment", "treatment", - "treatment", "treatment", + "control", "control", "control", "control", "treatment", "treatment", "treatment", + "treatment", + ] + let feature_names = [ + "Bacteroides", "Prevotella", "Faecalibacterium", "Roseburia", "Eubacterium", + "Ruminococcus", ] - let feature_names = ["Bacteroides", "Prevotella", "Faecalibacterium", "Roseburia", "Eubacterium", "Ruminococcus"] // Counts: [feature][sample] // Features 0,1 are elevated in treatment; features 2-5 are similar. let counts = [ diff --git a/src/application.mbt b/src/application.mbt index d4287a84..7c604cf2 100644 --- a/src/application.mbt +++ b/src/application.mbt @@ -19,12 +19,16 @@ pub fn AbstractCommandline::new(executable : String) -> AbstractCommandline { stdin: "", stdout: "", stderr: "", - env: Map([], capacity=0) + env: Map([], capacity=0), } } ///| -pub fn AbstractCommandline::add_arg(self : AbstractCommandline, arg : String, value : String?) -> AbstractCommandline { +pub fn AbstractCommandline::add_arg( + self : AbstractCommandline, + arg : String, + value : String?, +) -> AbstractCommandline { let args = self.arguments.copy() args.push(arg) if value is Some(_) { @@ -36,12 +40,16 @@ pub fn AbstractCommandline::add_arg(self : AbstractCommandline, arg : String, va stdin: self.stdin, stdout: self.stdout, stderr: self.stderr, - env: self.env + env: self.env, } } ///| -pub fn AbstractCommandline::set_parameter(self : AbstractCommandline, param : String, value : String) -> AbstractCommandline { +pub fn AbstractCommandline::set_parameter( + self : AbstractCommandline, + param : String, + value : String, +) -> AbstractCommandline { let args = self.arguments.copy() args.push(param) args.push(value) @@ -51,43 +59,52 @@ pub fn AbstractCommandline::set_parameter(self : AbstractCommandline, param : St stdin: self.stdin, stdout: self.stdout, stderr: self.stderr, - env: self.env + env: self.env, } } ///| -pub fn AbstractCommandline::set_stdout(self : AbstractCommandline, path : String) -> AbstractCommandline { +pub fn AbstractCommandline::set_stdout( + self : AbstractCommandline, + path : String, +) -> AbstractCommandline { AbstractCommandline::{ executable: self.executable, arguments: self.arguments, stdin: self.stdin, stdout: path, stderr: self.stderr, - env: self.env + env: self.env, } } ///| -pub fn AbstractCommandline::set_stderr(self : AbstractCommandline, path : String) -> AbstractCommandline { +pub fn AbstractCommandline::set_stderr( + self : AbstractCommandline, + path : String, +) -> AbstractCommandline { AbstractCommandline::{ executable: self.executable, arguments: self.arguments, stdin: self.stdin, stdout: self.stdout, stderr: path, - env: self.env + env: self.env, } } ///| -pub fn AbstractCommandline::set_stdin(self : AbstractCommandline, path : String) -> AbstractCommandline { +pub fn AbstractCommandline::set_stdin( + self : AbstractCommandline, + path : String, +) -> AbstractCommandline { AbstractCommandline::{ executable: self.executable, arguments: self.arguments, stdin: path, stdout: self.stdout, stderr: self.stderr, - env: self.env + env: self.env, } } @@ -115,7 +132,11 @@ pub struct CommandlineError { } ///| -pub fn CommandlineError::new(message : String, exit_code : Int, command : String) -> CommandlineError { +pub fn CommandlineError::new( + message : String, + exit_code : Int, + command : String, +) -> CommandlineError { CommandlineError::{ message, exit_code, command } } @@ -142,4 +163,4 @@ pub fn create_example_commandline() -> AbstractCommandline { cmd = cmd.add_arg("-out", Some("results.txt")) cmd = cmd.add_arg("-evalue", Some("1e-5")) cmd -} \ No newline at end of file +} diff --git a/src/bamsignals.mbt b/src/bamsignals.mbt index ae702a29..c71b5678 100644 --- a/src/bamsignals.mbt +++ b/src/bamsignals.mbt @@ -3,6 +3,7 @@ /// Provides functions for extracting and analyzing signals from BAM files. /// Supports signal counting and normalization for ChIP-seq and other sequencing data. +///| /// Count mode for signal extraction pub enum BamsigCountMode { /// Count all reads @@ -15,6 +16,7 @@ pub enum BamsigCountMode { PairedEnd } derive(Eq) +///| /// Normalization method for signal pub enum BamsigNormMethod { /// No normalization @@ -27,6 +29,7 @@ pub enum BamsigNormMethod { CPM } +///| /// Signal extraction parameters pub struct BamsigParams { /// Count mode @@ -41,31 +44,79 @@ pub struct BamsigParams { extend_len : Int } +///| /// Create default parameters pub fn BamsigParams::new() -> BamsigParams { - BamsigParams::{ count_mode: BamsigCountMode::All, filter_dup: false, min_mapq: 10, single_end: false, extend_len: 150 } + BamsigParams::{ + count_mode: BamsigCountMode::All, + filter_dup: false, + min_mapq: 10, + single_end: false, + extend_len: 150, + } } +///| /// Set count mode -pub fn BamsigParams::bamsig_set_count_mode(self : BamsigParams, mode : BamsigCountMode) -> BamsigParams { - BamsigParams::{ count_mode: mode, filter_dup: self.filter_dup, min_mapq: self.min_mapq, single_end: self.single_end, extend_len: self.extend_len } +pub fn BamsigParams::bamsig_set_count_mode( + self : BamsigParams, + mode : BamsigCountMode, +) -> BamsigParams { + BamsigParams::{ + count_mode: mode, + filter_dup: self.filter_dup, + min_mapq: self.min_mapq, + single_end: self.single_end, + extend_len: self.extend_len, + } } +///| /// Set filter duplicates -pub fn BamsigParams::bamsig_set_filter_dup(self : BamsigParams, filter : Bool) -> BamsigParams { - BamsigParams::{ count_mode: self.count_mode, filter_dup: filter, min_mapq: self.min_mapq, single_end: self.single_end, extend_len: self.extend_len } +pub fn BamsigParams::bamsig_set_filter_dup( + self : BamsigParams, + filter : Bool, +) -> BamsigParams { + BamsigParams::{ + count_mode: self.count_mode, + filter_dup: filter, + min_mapq: self.min_mapq, + single_end: self.single_end, + extend_len: self.extend_len, + } } +///| /// Set minimum mapping quality -pub fn BamsigParams::bamsig_set_min_mapq(self : BamsigParams, mapq : Int) -> BamsigParams { - BamsigParams::{ count_mode: self.count_mode, filter_dup: self.filter_dup, min_mapq: mapq, single_end: self.single_end, extend_len: self.extend_len } +pub fn BamsigParams::bamsig_set_min_mapq( + self : BamsigParams, + mapq : Int, +) -> BamsigParams { + BamsigParams::{ + count_mode: self.count_mode, + filter_dup: self.filter_dup, + min_mapq: mapq, + single_end: self.single_end, + extend_len: self.extend_len, + } } +///| /// Set extend length -pub fn BamsigParams::bamsig_set_extend(self : BamsigParams, extend_len : Int) -> BamsigParams { - BamsigParams::{ count_mode: self.count_mode, filter_dup: self.filter_dup, min_mapq: self.min_mapq, single_end: self.single_end, extend_len: extend_len } +pub fn BamsigParams::bamsig_set_extend( + self : BamsigParams, + extend_len : Int, +) -> BamsigParams { + BamsigParams::{ + count_mode: self.count_mode, + filter_dup: self.filter_dup, + min_mapq: self.min_mapq, + single_end: self.single_end, + extend_len, + } } +///| /// Genomic region for signal extraction pub struct BamsigRegion { /// Chromosome @@ -78,36 +129,48 @@ pub struct BamsigRegion { id : String } +///| /// Create new region -pub fn BamsigRegion::new(chrom : String, start : Int, end : Int, id : String) -> BamsigRegion { +pub fn BamsigRegion::new( + chrom : String, + start : Int, + end : Int, + id : String, +) -> BamsigRegion { BamsigRegion::{ chrom, start, end, id } } +///| /// Get chromosome pub fn BamsigRegion::bamsig_chrom(self : BamsigRegion) -> String { self.chrom } +///| /// Get start position pub fn BamsigRegion::bamsig_start(self : BamsigRegion) -> Int { self.start } +///| /// Get end position pub fn BamsigRegion::bamsig_end(self : BamsigRegion) -> Int { self.end } +///| /// Get width pub fn BamsigRegion::bamsig_width(self : BamsigRegion) -> Int { self.end - self.start } +///| /// Get ID pub fn BamsigRegion::bamsig_id(self : BamsigRegion) -> String { self.id } +///| /// BAM record for signal extraction pub struct BamsigRecord { /// Chromosome @@ -128,23 +191,39 @@ pub struct BamsigRecord { is_first : Bool } +///| /// Create new record -pub fn BamsigRecord::new(chrom : String, pos : Int, cigar : String, strand : Bool, mapq : Int, is_dup : Bool, is_paired : Bool, is_first : Bool) -> BamsigRecord { +pub fn BamsigRecord::new( + chrom : String, + pos : Int, + cigar : String, + strand : Bool, + mapq : Int, + is_dup : Bool, + is_paired : Bool, + is_first : Bool, +) -> BamsigRecord { BamsigRecord::{ chrom, pos, cigar, strand, mapq, is_dup, is_paired, is_first } } +///| /// Get alignment length from CIGAR pub fn BamsigRecord::bamsig_align_length(self : BamsigRecord) -> Int { parse_cigar_length(self.cigar) } +///| /// Get end position pub fn BamsigRecord::bamsig_end(self : BamsigRecord) -> Int { self.pos + self.bamsig_align_length() } +///| /// Check if record passes filter -pub fn BamsigRecord::bamsig_passes_filter(self : BamsigRecord, params : BamsigParams) -> Bool { +pub fn BamsigRecord::bamsig_passes_filter( + self : BamsigRecord, + params : BamsigParams, +) -> Bool { if self.is_dup && params.filter_dup { return false } @@ -157,6 +236,7 @@ pub fn BamsigRecord::bamsig_passes_filter(self : BamsigRecord, params : BamsigPa true } +///| /// Signal counts for regions pub struct BamsigSignal { /// Region IDs @@ -169,39 +249,68 @@ pub struct BamsigSignal { total_reads : Array[Double] } +///| /// Create new signal -pub fn BamsigSignal::new(region_ids : Array[String], counts : Array[Array[Double]], - norm_counts : Array[Array[Double]], total_reads : Array[Double]) -> BamsigSignal { +pub fn BamsigSignal::new( + region_ids : Array[String], + counts : Array[Array[Double]], + norm_counts : Array[Array[Double]], + total_reads : Array[Double], +) -> BamsigSignal { BamsigSignal::{ region_ids, counts, norm_counts, total_reads } } +///| /// Get number of regions pub fn BamsigSignal::bamsig_n_regions(self : BamsigSignal) -> Int { self.region_ids.length() } +///| /// Get number of samples pub fn BamsigSignal::bamsig_n_samples(self : BamsigSignal) -> Int { - if self.counts.length() > 0 { self.counts[0].length() } else { 0 } + if self.counts.length() > 0 { + self.counts[0].length() + } else { + 0 + } } +///| /// Get count for region and sample -pub fn BamsigSignal::bamsig_get_count(self : BamsigSignal, region_idx : Int, sample_idx : Int) -> Double { +pub fn BamsigSignal::bamsig_get_count( + self : BamsigSignal, + region_idx : Int, + sample_idx : Int, +) -> Double { self.counts[region_idx][sample_idx] } +///| /// Get normalized count -pub fn BamsigSignal::bamsig_get_norm_count(self : BamsigSignal, region_idx : Int, sample_idx : Int) -> Double { +pub fn BamsigSignal::bamsig_get_norm_count( + self : BamsigSignal, + region_idx : Int, + sample_idx : Int, +) -> Double { self.norm_counts[region_idx][sample_idx] } +///| /// Get region ID -pub fn BamsigSignal::bamsig_get_region_id(self : BamsigSignal, idx : Int) -> String { +pub fn BamsigSignal::bamsig_get_region_id( + self : BamsigSignal, + idx : Int, +) -> String { self.region_ids[idx] } +///| /// Sum counts across samples for a region -pub fn BamsigSignal::bamsig_row_sum(self : BamsigSignal, region_idx : Int) -> Double { +pub fn BamsigSignal::bamsig_row_sum( + self : BamsigSignal, + region_idx : Int, +) -> Double { let row = self.counts[region_idx] let mut sum = 0.0 let mut i = 0 @@ -212,8 +321,12 @@ pub fn BamsigSignal::bamsig_row_sum(self : BamsigSignal, region_idx : Int) -> Do sum } +///| /// Sum counts across regions for a sample -pub fn BamsigSignal::bamsig_col_sum(self : BamsigSignal, sample_idx : Int) -> Double { +pub fn BamsigSignal::bamsig_col_sum( + self : BamsigSignal, + sample_idx : Int, +) -> Double { let mut sum = 0.0 let mut i = 0 while i < self.counts.length() { @@ -223,17 +336,22 @@ pub fn BamsigSignal::bamsig_col_sum(self : BamsigSignal, sample_idx : Int) -> Do sum } +///| /// Filter regions by count threshold -pub fn BamsigSignal::bamsig_filter(self : BamsigSignal, min_count : Double, min_samples : Int) -> BamsigSignal { +pub fn BamsigSignal::bamsig_filter( + self : BamsigSignal, + min_count : Double, + min_samples : Int, +) -> BamsigSignal { let new_region_ids : Array[String] = Array::new() let new_counts : Array[Array[Double]] = Array::new() let new_norm_counts : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < self.region_ids.length() { let count_row = self.counts[i] let mut passing_samples = 0 - + let mut j = 0 while j < count_row.length() { if count_row[j] >= min_count { @@ -241,19 +359,25 @@ pub fn BamsigSignal::bamsig_filter(self : BamsigSignal, min_count : Double, min_ } j = j + 1 } - + if passing_samples >= min_samples { new_region_ids.push(self.region_ids[i]) new_counts.push(count_row) new_norm_counts.push(self.norm_counts[i]) } - + i = i + 1 } - - BamsigSignal::new(new_region_ids, new_counts, new_norm_counts, self.total_reads) + + BamsigSignal::new( + new_region_ids, + new_counts, + new_norm_counts, + self.total_reads, + ) } +///| /// Chromatin state analysis result pub struct BamsigChromState { /// State labels @@ -270,43 +394,73 @@ pub struct BamsigChromState { repressed_pct : Double } +///| /// Create new chromatin state result -pub fn BamsigChromState::new(labels : Array[String], colors : Array[String], frequencies : Array[Double], - active_promoter_pct : Double, active_enhancer_pct : Double, - repressed_pct : Double) -> BamsigChromState { - BamsigChromState::{ labels, colors, frequencies, active_promoter_pct, active_enhancer_pct, repressed_pct } +pub fn BamsigChromState::new( + labels : Array[String], + colors : Array[String], + frequencies : Array[Double], + active_promoter_pct : Double, + active_enhancer_pct : Double, + repressed_pct : Double, +) -> BamsigChromState { + BamsigChromState::{ + labels, + colors, + frequencies, + active_promoter_pct, + active_enhancer_pct, + repressed_pct, + } } +///| /// Get number of states pub fn BamsigChromState::bamsig_n_states(self : BamsigChromState) -> Int { self.labels.length() } +///| /// Get state label -pub fn BamsigChromState::bamsig_get_label(self : BamsigChromState, idx : Int) -> String { +pub fn BamsigChromState::bamsig_get_label( + self : BamsigChromState, + idx : Int, +) -> String { self.labels[idx] } +///| /// Get state frequency -pub fn BamsigChromState::bamsig_get_frequency(self : BamsigChromState, idx : Int) -> Double { +pub fn BamsigChromState::bamsig_get_frequency( + self : BamsigChromState, + idx : Int, +) -> Double { self.frequencies[idx] } +///| /// Get active promoter percentage -pub fn BamsigChromState::bamsig_active_promoter(self : BamsigChromState) -> Double { +pub fn BamsigChromState::bamsig_active_promoter( + self : BamsigChromState, +) -> Double { self.active_promoter_pct } +///| /// Get active enhancer percentage -pub fn BamsigChromState::bamsig_active_enhancer(self : BamsigChromState) -> Double { +pub fn BamsigChromState::bamsig_active_enhancer( + self : BamsigChromState, +) -> Double { self.active_enhancer_pct } +///| /// Get repressed percentage pub fn BamsigChromState::bamsig_repressed(self : BamsigChromState) -> Double { self.repressed_pct } +///| /// Parse CIGAR string to get alignment length fn parse_cigar_length(cigar : String) -> Int { let mut total = 0 @@ -335,6 +489,7 @@ fn parse_cigar_length(cigar : String) -> Int { total } +///| /// Create example records for testing pub fn bamsig_create_example_records() -> Array[BamsigRecord] { [ @@ -347,6 +502,7 @@ pub fn bamsig_create_example_records() -> Array[BamsigRecord] { ] } +///| /// Create example regions pub fn bamsig_create_example_regions() -> Array[BamsigRegion] { [ @@ -357,18 +513,21 @@ pub fn bamsig_create_example_regions() -> Array[BamsigRegion] { ] } +///| /// Count signals in regions -pub fn bamsig_count_signals(regions : Array[BamsigRegion], - records_by_chrom : Map[String, Array[BamsigRecord]], - params : BamsigParams) -> Array[Array[Double]] { +pub fn bamsig_count_signals( + regions : Array[BamsigRegion], + records_by_chrom : Map[String, Array[BamsigRecord]], + params : BamsigParams, +) -> Array[Array[Double]] { let n_regions = regions.length() let counts : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_regions { let region = regions[i] let mut region_count = 0.0 - + let chrom_records = records_by_chrom.get(region.chrom) if chrom_records is Some(records) { let recs = records @@ -378,15 +537,28 @@ pub fn bamsig_count_signals(regions : Array[BamsigRegion], if rec.bamsig_passes_filter(params) { let rec_end = rec.pos + rec.bamsig_align_length() if rec.pos < region.end && rec_end > region.start { - let overlap_start = if rec.pos > region.start { rec.pos } else { region.start } - let overlap_end = if rec_end < region.end { rec_end } else { region.end } - let _overlap = if overlap_end > overlap_start { overlap_end - overlap_start } else { 0 } - + let overlap_start = if rec.pos > region.start { + rec.pos + } else { + region.start + } + let overlap_end = if rec_end < region.end { + rec_end + } else { + region.end + } + let _overlap = if overlap_end > overlap_start { + overlap_end - overlap_start + } else { + 0 + } + if params.count_mode == BamsigCountMode::All { region_count = region_count + 1.0 } else if params.count_mode == BamsigCountMode::Sense && rec.strand { region_count = region_count + 1.0 - } else if params.count_mode == BamsigCountMode::Antisense && !rec.strand { + } else if params.count_mode == BamsigCountMode::Antisense && + !rec.strand { region_count = region_count + 1.0 } } @@ -394,77 +566,98 @@ pub fn bamsig_count_signals(regions : Array[BamsigRegion], j = j + 1 } } - + counts.push([region_count]) i = i + 1 } - + counts } +///| /// Normalize signals -pub fn bamsig_normalize_signals(counts : Array[Array[Double]], - total_reads : Array[Double], - norm_method : BamsigNormMethod) -> Array[Array[Double]] { +pub fn bamsig_normalize_signals( + counts : Array[Array[Double]], + total_reads : Array[Double], + norm_method : BamsigNormMethod, +) -> Array[Array[Double]] { let norm_counts : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < counts.length() { let row = counts[i] let norm_row : Array[Double] = Array::new() - + let mut j = 0 while j < row.length() { let c = row[j] let total = if j < total_reads.length() { total_reads[j] } else { 1.0 } - + let norm_val = match norm_method { BamsigNormMethod::None => c - BamsigNormMethod::RPM => if total > 0.0 { c / total * 1000000.0 } else { 0.0 } - BamsigNormMethod::CPM => if total > 0.0 { c / total * 1000000.0 } else { 0.0 } - BamsigNormMethod::RPKM => if total > 0.0 { c / total * 1000000.0 / 1000.0 } else { 0.0 } + BamsigNormMethod::RPM => + if total > 0.0 { + c / total * 1000000.0 + } else { + 0.0 + } + BamsigNormMethod::CPM => + if total > 0.0 { + c / total * 1000000.0 + } else { + 0.0 + } + BamsigNormMethod::RPKM => + if total > 0.0 { + c / total * 1000000.0 / 1000.0 + } else { + 0.0 + } } - + norm_row.push(norm_val) j = j + 1 } - + norm_counts.push(norm_row) i = i + 1 } - + norm_counts } +///| /// Analyze chromatin states -pub fn bamsig_analyze_chromatin_states(signal : BamsigSignal, - promoter_regions : Array[Int], - enhancer_regions : Array[Int], - repressed_regions : Array[Int]) -> BamsigChromState { +pub fn bamsig_analyze_chromatin_states( + signal : BamsigSignal, + promoter_regions : Array[Int], + enhancer_regions : Array[Int], + repressed_regions : Array[Int], +) -> BamsigChromState { let n_regions = signal.bamsig_n_regions() let n_states = 4 - + let labels = ["Active Promoter", "Active Enhancer", "Repressed", "Inactive"] let colors = ["#FF0000", "#00FF00", "#0000FF", "#CCCCCC"] let frequencies = Array::make(n_states, 0.0) - + let n_promoter = promoter_regions.length().to_double() let n_enhancer = enhancer_regions.length().to_double() let n_repressed = repressed_regions.length().to_double() - + let mut active_promoter = 0.0 let mut active_enhancer = 0.0 let mut repressed = 0.0 - + let mut i = 0 while i < n_regions { let total_count = signal.bamsig_row_sum(i) let is_active = total_count > 0.0 - + let is_promoter = promoter_regions.contains(i) let is_enhancer = enhancer_regions.contains(i) let is_repressed = repressed_regions.contains(i) - + if is_active { if is_promoter { active_promoter = active_promoter + 1.0 @@ -472,37 +665,51 @@ pub fn bamsig_analyze_chromatin_states(signal : BamsigSignal, active_enhancer = active_enhancer + 1.0 } } - + if is_repressed { repressed = repressed + 1.0 } - + i = i + 1 } - + let _total_annotated = n_promoter + n_enhancer + n_repressed - let total_promoter_pct = if n_promoter > 0.0 { active_promoter / n_promoter * 100.0 } else { 0.0 } - let enhancer_pct = if n_enhancer > 0.0 { active_enhancer / n_enhancer * 100.0 } else { 0.0 } - let repressed_pct = if n_repressed > 0.0 { repressed / n_repressed * 100.0 } else { 0.0 } - + let total_promoter_pct = if n_promoter > 0.0 { + active_promoter / n_promoter * 100.0 + } else { + 0.0 + } + let enhancer_pct = if n_enhancer > 0.0 { + active_enhancer / n_enhancer * 100.0 + } else { + 0.0 + } + let repressed_pct = if n_repressed > 0.0 { + repressed / n_repressed * 100.0 + } else { + 0.0 + } + frequencies[0] = total_promoter_pct frequencies[1] = enhancer_pct frequencies[2] = repressed_pct frequencies[3] = 100.0 - total_promoter_pct - enhancer_pct - repressed_pct - - BamsigChromState::new(labels, colors, frequencies, - total_promoter_pct, enhancer_pct, repressed_pct) + + BamsigChromState::new( + labels, colors, frequencies, total_promoter_pct, enhancer_pct, repressed_pct, + ) } +///| /// Create example signal data pub fn bamsig_create_example_signal() -> BamsigSignal { let regions = bamsig_create_example_regions() let n_regions = regions.length() let _n_samples = 2 - + let region_ids : Array[String] = Array::new() let counts : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_regions { region_ids.push(regions[i].id) @@ -512,9 +719,13 @@ pub fn bamsig_create_example_signal() -> BamsigSignal { counts.push(row) i = i + 1 } - + let total_reads = [10000.0, 9500.0] - let norm_counts = bamsig_normalize_signals(counts, total_reads, BamsigNormMethod::RPM) - + let norm_counts = bamsig_normalize_signals( + counts, + total_reads, + BamsigNormMethod::RPM, + ) + BamsigSignal::new(region_ids, counts, norm_counts, total_reads) } diff --git a/src/batchelor.mbt b/src/batchelor.mbt index e8dc839b..a13a61be 100644 --- a/src/batchelor.mbt +++ b/src/batchelor.mbt @@ -18,12 +18,7 @@ pub fn BatchCorrectionResult::new( mnn_pairs : Array[(Int, Int)], var_explained : Array[Double], ) -> BatchCorrectionResult { - BatchCorrectionResult::{ - corrected, - batch_indices, - mnn_pairs, - var_explained, - } + BatchCorrectionResult::{ corrected, batch_indices, mnn_pairs, var_explained } } ///| @@ -307,7 +302,10 @@ pub fn fast_mnn( nn = nn + 1 } - let cov_matrix : Array[Array[Double]] = Array::make(n_genes, Array::make(n_genes, 0.0)) + let cov_matrix : Array[Array[Double]] = Array::make( + n_genes, + Array::make(n_genes, 0.0), + ) let mut pp = 0 while pp < n_cells { let cell = centered[pp] @@ -333,7 +331,10 @@ pub fn fast_mnn( } let eigenvalues : Array[Double] = Array::make(n_genes, 0.0) - let eigenvectors : Array[Array[Double]] = Array::make(n_genes, Array::make(n_genes, 0.0)) + let eigenvectors : Array[Array[Double]] = Array::make( + n_genes, + Array::make(n_genes, 0.0), + ) let mut uu = 0 while uu < n_genes { eigenvalues[uu] = cov_matrix[uu][uu] @@ -350,11 +351,7 @@ pub fn fast_mnn( while xx < n_genes { let p = cov_matrix[ww][xx] let d_val = eigenvalues[xx] - eigenvalues[ww] - let c = if d_val.abs() < 0.000001 { - 0.000001 - } else { - d_val - } + let c = if d_val.abs() < 0.000001 { 0.000001 } else { d_val } let t = p / c let cos_val = 1.0 / (1.0 + t * t).sqrt() let sin_val = t * cos_val @@ -480,7 +477,10 @@ pub fn fast_mnn( kk = kk + 1 } - let correction_vectors : Array[Array[Double]] = Array::make(n_cells, Array::make(top_components, 0.0)) + let correction_vectors : Array[Array[Double]] = Array::make( + n_cells, + Array::make(top_components, 0.0), + ) let mut mm = 0 while mm < n_batches - 1 { @@ -542,7 +542,9 @@ pub fn fast_mnn( let mut dist = 0.0 let mut uu = 0 while uu < top_components { - dist = dist + (pca_result[ss][uu] - pca_result[mnn_idx][uu]) * (pca_result[ss][uu] - pca_result[mnn_idx][uu]) + dist = dist + + (pca_result[ss][uu] - pca_result[mnn_idx][uu]) * + (pca_result[ss][uu] - pca_result[mnn_idx][uu]) uu = uu + 1 } let weight = @math.exp(-dist / (2.0 * sigma * sigma)) @@ -559,7 +561,8 @@ pub fn fast_mnn( if weight_sum > 0.0 { let mut ww = 0 while ww < top_components { - correction_vectors[ss][ww] = correction_vectors[ss][ww] + weighted_delta[ww] / weight_sum + correction_vectors[ss][ww] = correction_vectors[ss][ww] + + weighted_delta[ww] / weight_sum ww = ww + 1 } } @@ -583,7 +586,9 @@ pub fn fast_mnn( xx = xx + 1 } - BatchCorrectionResult::new(corrected, batch_indices, all_mnn_pairs, var_explained) + BatchCorrectionResult::new( + corrected, batch_indices, all_mnn_pairs, var_explained, + ) } ///| @@ -619,7 +624,11 @@ pub fn batchelor_create_example_data( x = x - 6.0 let base_expression = @math.exp(x) - let batch_factor = 1.0 + i.to_double() * batch_effect * (if k < n_genes / 2 { 1.0 } else { -1.0 }) * 0.1 + let batch_factor = 1.0 + + i.to_double() * + batch_effect * + (if k < n_genes / 2 { 1.0 } else { -1.0 }) * + 0.1 cell.push(base_expression * batch_factor) k = k + 1 @@ -637,7 +646,10 @@ pub fn batchelor_create_example_data( } ///| -pub fn compute_batch_mixing_score(corrected : Array[Array[Double]], batch_indices : Array[Int]) -> Double { +pub fn compute_batch_mixing_score( + corrected : Array[Array[Double]], + batch_indices : Array[Int], +) -> Double { let n_cells = corrected.length() let n_dims = if n_cells > 0 { corrected[0].length() } else { 0 } @@ -670,7 +682,9 @@ pub fn compute_batch_mixing_score(corrected : Array[Array[Double]], batch_indice let mut dist = 0.0 let mut k = 0 while k < n_dims { - dist = dist + (corrected[i][k] - corrected[j][k]) * (corrected[i][k] - corrected[j][k]) + dist = dist + + (corrected[i][k] - corrected[j][k]) * + (corrected[i][k] - corrected[j][k]) k = k + 1 } distances.push((dist.sqrt(), j)) @@ -703,7 +717,8 @@ pub fn compute_batch_mixing_score(corrected : Array[Array[Double]], batch_indice n = n + 1 } - score = score + (1.0 - same_batch_count.to_double() / n_neighbors.to_double()) + score = score + + (1.0 - same_batch_count.to_double() / n_neighbors.to_double()) i = i + 1 } diff --git a/src/bayes_space.mbt b/src/bayes_space.mbt index 4a042441..37f3e3d6 100644 --- a/src/bayes_space.mbt +++ b/src/bayes_space.mbt @@ -21,10 +21,10 @@ /// Spatial coordinates for a single spot. pub struct SpotCoord { spot_id : String - row : Int // array row index - col : Int // array column index - x : Double // continuous x coordinate (e.g. pixel) - y : Double // continuous y coordinate + row : Int // array row index + col : Int // array column index + x : Double // continuous x coordinate (e.g. pixel) + y : Double // continuous y coordinate } ///| @@ -43,10 +43,10 @@ pub fn spot_coord( /// BayesSpace clustering result. pub struct BayesSpaceResult { spot_ids : Array[String] - clusters : Array[Int] // cluster assignment per spot (0..q-1) - q : Int // number of clusters - cluster_centers : Array[Array[Double]] // q × n_features matrix - responsibilities : Array[Array[Double]] // n_spots × q soft assignments + clusters : Array[Int] // cluster assignment per spot (0..q-1) + q : Int // number of clusters + cluster_centers : Array[Array[Double]] // q × n_features matrix + responsibilities : Array[Array[Double]] // n_spots × q soft assignments n_iterations : Int log_likelihood : Double converged : Bool @@ -59,9 +59,7 @@ pub struct BayesSpaceResult { /// For square-grid compatibility we also include (r±1, c±1) as neighbors. /// /// Returns neighbor_indices[i] = list of spot indices that are neighbors of spot i. -pub fn bayes_space_hex_neighbors( - spots : Array[SpotCoord], -) -> Array[Array[Int]] { +pub fn bayes_space_hex_neighbors(spots : Array[SpotCoord]) -> Array[Array[Int]] { let n = spots.length() // Build a map from (row, col) to spot index let coord_map : Map[String, Int] = Map::new() @@ -353,7 +351,12 @@ pub fn bayes_space_run( while i < n_spots { let mut k = 0 while k < q { - let log_t = bayes_space_log_t_density(expression[i], centers[k], scales[k], d_df) + let log_t = bayes_space_log_t_density( + expression[i], + centers[k], + scales[k], + d_df, + ) let mut spatial = 0.0 let mut ni = 0 while ni < neighbors[i].length() { @@ -454,7 +457,12 @@ pub fn bayes_space_run( let mut max_lp = -1.0e18 let mut k = 0 while k < q { - let log_t = bayes_space_log_t_density(expression[i], centers[k], scales[k], d_df) + let log_t = bayes_space_log_t_density( + expression[i], + centers[k], + scales[k], + d_df, + ) let lp = @math.ln(pis[k]) + log_t if lp > max_lp { max_lp = lp @@ -464,7 +472,12 @@ pub fn bayes_space_run( let mut sum_exp = 0.0 k = 0 while k < q { - let log_t = bayes_space_log_t_density(expression[i], centers[k], scales[k], d_df) + let log_t = bayes_space_log_t_density( + expression[i], + centers[k], + scales[k], + d_df, + ) sum_exp = sum_exp + @math.exp(@math.ln(pis[k]) + log_t - max_lp) k = k + 1 } @@ -575,10 +588,18 @@ pub fn bayes_space_render_clusters( let mut max_c = spots[0].col let mut i = 1 while i < spots.length() { - if spots[i].row < min_r { min_r = spots[i].row } - if spots[i].row > max_r { max_r = spots[i].row } - if spots[i].col < min_c { min_c = spots[i].col } - if spots[i].col > max_c { max_c = spots[i].col } + if spots[i].row < min_r { + min_r = spots[i].row + } + if spots[i].row > max_r { + max_r = spots[i].row + } + if spots[i].col < min_c { + min_c = spots[i].col + } + if spots[i].col > max_c { + max_c = spots[i].col + } i = i + 1 } let label_chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" @@ -638,8 +659,20 @@ pub fn bayes_space_sample_data() -> (Array[Array[Double]], Array[SpotCoord]) { 2.0 } // 3-feature expression vector per spot - expression.push([base + noise, base * 0.8 + noise * 0.5, base * 1.2 + noise * 0.3]) - spots.push(spot_coord("spot_" + r.to_string() + "_" + c.to_string(), r, c, c.to_double(), r.to_double())) + expression.push([ + base + noise, + base * 0.8 + noise * 0.5, + base * 1.2 + noise * 0.3, + ]) + spots.push( + spot_coord( + "spot_" + r.to_string() + "_" + c.to_string(), + r, + c, + c.to_double(), + r.to_double(), + ), + ) c = c + 1 } r = r + 1 diff --git a/src/bayseq.mbt b/src/bayseq.mbt index 673a0ba0..bbd7bcf2 100644 --- a/src/bayseq.mbt +++ b/src/bayseq.mbt @@ -33,7 +33,10 @@ pub struct BayesResult { /// Estimate the dispersion parameter for a single gene using the method of moments. /// For Negative Binomial: Var = mean + mean^2 / dispersion /// => dispersion = mean^2 / (var - mean) -pub fn bayseq_estimate_dispersion_gene(counts_a : Array[Double], counts_b : Array[Double]) -> Double { +pub fn bayseq_estimate_dispersion_gene( + counts_a : Array[Double], + counts_b : Array[Double], +) -> Double { let n_a = counts_a.length() let n_b = counts_b.length() if n_a < 2 || n_b < 2 { @@ -86,12 +89,21 @@ pub fn bayseq_estimate_dispersion_gene(counts_a : Array[Double], counts_b : Arra } // Bound dispersion to reasonable range - if disp < 0.01 { 0.01 } else if disp > 100.0 { 100.0 } else { disp } + if disp < 0.01 { + 0.01 + } else if disp > 100.0 { + 100.0 + } else { + disp + } } ///| /// Estimate dispersion prior parameters (shape, rate) from all genes. -pub fn bayseq_estimate_prior(counts : Array[Array[Double]], groups : Array[Int]) -> (Double, Double) { +pub fn bayseq_estimate_prior( + counts : Array[Array[Double]], + groups : Array[Int], +) -> (Double, Double) { let n_genes = counts.length() if n_genes == 0 { return (2.0, 0.5) @@ -103,8 +115,11 @@ pub fn bayseq_estimate_prior(counts : Array[Array[Double]], groups : Array[Int]) let mut n_group_1 = 0 let mut gi = 0 while gi < groups.length() { - if groups[gi] == 0 { n_group_0 = n_group_0 + 1 } - else if groups[gi] == 1 { n_group_1 = n_group_1 + 1 } + if groups[gi] == 0 { + n_group_0 = n_group_0 + 1 + } else if groups[gi] == 1 { + n_group_1 = n_group_1 + 1 + } gi = gi + 1 } @@ -164,7 +179,9 @@ pub fn hts_count_group(groups : Array[Int], group_id : Int) -> Int { let mut count = 0 let mut i = 0 while i < groups.length() { - if groups[i] == group_id { count = count + 1 } + if groups[i] == group_id { + count = count + 1 + } i = i + 1 } count @@ -217,7 +234,11 @@ pub fn bayseq_log_likelihood_ratio( ///| /// Negative Binomial log-likelihood for a set of counts given mean and dispersion. -pub fn bayseq_nb_log_likelihood(counts : Array[Double], mean : Double, disp : Double) -> Double { +pub fn bayseq_nb_log_likelihood( + counts : Array[Double], + mean : Double, + disp : Double, +) -> Double { if mean <= 0.0 || disp <= 0.0 { return 0.0 } @@ -234,7 +255,11 @@ pub fn bayseq_nb_log_likelihood(counts : Array[Double], mean : Double, disp : Do let lgamma_x1 = bayseq_lgamma(x + 1.0) let lgamma_r = bayseq_lgamma(r) let ln_p = if p > 0.0 { @math.ln(p) } else { -10000000000.0 } - let ln_1mp = if (1.0 - p) > 0.0 { @math.ln(1.0 - p) } else { -10000000000.0 } + let ln_1mp = if 1.0 - p > 0.0 { + @math.ln(1.0 - p) + } else { + -10000000000.0 + } ll = ll + lgamma_xr - lgamma_x1 - lgamma_r + r * ln_p + x * ln_1mp } else { let lgamma_r = bayseq_lgamma(r) @@ -268,12 +293,8 @@ pub fn bayseq_lgamma(x : Double) -> Double { // Lanczos approximation for x >= 2 // Coefficients for g=5 let c = [ - 76.18009172947146, - -86.50532032941677, - 24.01409824083091, - -1.231739572450155, - 0.1208650973866179e-2, - -0.5395239384953e-5 + 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, + 0.1208650973866179e-2, -0.5395239384953e-5, ] let y = x let mut tmp = x + 5.5 @@ -326,9 +347,15 @@ pub fn bayseq_test( let mut sum_a = 0.0 let mut sum_b = 0.0 let mut i = 0 - while i < c_a.length() { sum_a = sum_a + c_a[i]; i = i + 1 } + while i < c_a.length() { + sum_a = sum_a + c_a[i] + i = i + 1 + } i = 0 - while i < c_b.length() { sum_b = sum_b + c_b[i]; i = i + 1 } + while i < c_b.length() { + sum_b = sum_b + c_b[i] + i = i + 1 + } let mean_a = sum_a / n_group_0.to_double() let mean_b = sum_b / n_group_1.to_double() @@ -349,9 +376,15 @@ pub fn bayseq_test( let prob_de = 1.0 / (1.0 + @math.exp(-llr)) let is_de = prob_de >= alpha - if is_de { de_count = de_count + 1 } + if is_de { + de_count = de_count + 1 + } - let name = if g < gene_names.length() { gene_names[g] } else { "Gene" + (g + 1).to_string() } + let name = if g < gene_names.length() { + gene_names[g] + } else { + "Gene" + (g + 1).to_string() + } results.push(BayesGeneResult::{ gene_index: g, @@ -361,7 +394,7 @@ pub fn bayseq_test( posterior_prob_de: prob_de, map_expression_a: mean_a, map_expression_b: mean_b, - is_de: is_de, + is_de, }) g = g + 1 } @@ -391,15 +424,26 @@ pub fn bayseq_get_de_genes(result : BayesResult) -> Array[BayesGeneResult] { ///| /// Get top DE genes sorted by absolute log fold change. -pub fn bayseq_get_top_de(result : BayesResult, n : Int) -> Array[BayesGeneResult] { +pub fn bayseq_get_top_de( + result : BayesResult, + n : Int, +) -> Array[BayesGeneResult] { let all = result.gene_results // Sort by absolute log_fold_change descending (bubble sort) let mut i = 0 while i < all.length() { let mut j = i + 1 while j < all.length() { - let abs_i = if all[i].log_fold_change >= 0.0 { all[i].log_fold_change } else { -all[i].log_fold_change } - let abs_j = if all[j].log_fold_change >= 0.0 { all[j].log_fold_change } else { -all[j].log_fold_change } + let abs_i = if all[i].log_fold_change >= 0.0 { + all[i].log_fold_change + } else { + -all[i].log_fold_change + } + let abs_j = if all[j].log_fold_change >= 0.0 { + all[j].log_fold_change + } else { + -all[j].log_fold_change + } if abs_j > abs_i { let tmp = all[i] all[i] = all[j] @@ -437,7 +481,7 @@ pub fn bayseq_sample_data() -> (Array[Array[Double]], Array[Int], Array[String]) let base_a = 500.0 let base_b = if g < 8 { 1500.0 } else if g < 16 { 200.0 } else { 500.0 } let base = if groups[s] == 0 { base_a } else { base_b } - let noise = (((g * 7 + s * 17) % 100).to_double() / 100.0) * base * 0.3 + let noise = ((g * 7 + s * 17) % 100).to_double() / 100.0 * base * 0.3 let val = base + noise row.push(val) s = s + 1 @@ -453,10 +497,17 @@ pub fn bayseq_sample_data() -> (Array[Array[Double]], Array[Int], Array[String]) /// Summarize the baySeq result. pub fn bayseq_summary(result : BayesResult) -> String { "baySeq Analysis Summary:\n" + - " Total genes: " + result.gene_results.length().to_string() + "\n" + - " DE genes (posterior >= " + result.alpha_level.to_string() + "): " + - result.n_de_genes.to_string() + "\n" + - " Dispersion prior: Gamma(shape=" + - result.dispersion_prior_shape.to_string() + - ", rate=" + result.dispersion_prior_rate.to_string() + ")" + " Total genes: " + + result.gene_results.length().to_string() + + "\n" + + " DE genes (posterior >= " + + result.alpha_level.to_string() + + "): " + + result.n_de_genes.to_string() + + "\n" + + " Dispersion prior: Gamma(shape=" + + result.dispersion_prior_shape.to_string() + + ", rate=" + + result.dispersion_prior_rate.to_string() + + ")" } diff --git a/src/beachmat.mbt b/src/beachmat.mbt index 7f52927a..11dba5b8 100644 --- a/src/beachmat.mbt +++ b/src/beachmat.mbt @@ -37,25 +37,45 @@ pub struct BmatParam { ///| /// Create default parameters. pub fn BmatParam::new() -> BmatParam { - { row_block_size: 0, col_block_size: 0, cache_data: true, storage_mode: BmatStorageMode::Dense } + { + row_block_size: 0, + col_block_size: 0, + cache_data: true, + storage_mode: BmatStorageMode::Dense, + } } ///| /// Create parameters with specific block sizes. pub fn BmatParam::with_blocks(row_block : Int, col_block : Int) -> BmatParam { - { row_block_size: row_block, col_block_size: col_block, cache_data: true, storage_mode: BmatStorageMode::Dense } + { + row_block_size: row_block, + col_block_size: col_block, + cache_data: true, + storage_mode: BmatStorageMode::Dense, + } } ///| /// Create parameters for column-wise access. pub fn BmatParam::column_param(block_size : Int) -> BmatParam { - { row_block_size: 0, col_block_size: block_size, cache_data: true, storage_mode: BmatStorageMode::Dense } + { + row_block_size: 0, + col_block_size: block_size, + cache_data: true, + storage_mode: BmatStorageMode::Dense, + } } ///| /// Create parameters for row-wise access. pub fn BmatParam::row_param(block_size : Int) -> BmatParam { - { row_block_size: block_size, col_block_size: 0, cache_data: true, storage_mode: BmatStorageMode::Dense } + { + row_block_size: block_size, + col_block_size: 0, + cache_data: true, + storage_mode: BmatStorageMode::Dense, + } } ///| @@ -217,7 +237,11 @@ pub fn bmat_apply_col_blocks( let n_cols = bmat.dim_cols let mut col = 0 while col < n_cols { - let end = if col + col_block_size < n_cols { col + col_block_size } else { n_cols } + let end = if col + col_block_size < n_cols { + col + col_block_size + } else { + n_cols + } let block_data : Array[Array[Double]] = [] let mut i = 0 while i < bmat.dim_rows { @@ -230,7 +254,13 @@ pub fn bmat_apply_col_blocks( block_data.push(row_data) i = i + 1 } - let block = BmatBlock::{ row_start: 0, row_end: bmat.dim_rows, col_start: col, col_end: end, block_data } + let block = BmatBlock::{ + row_start: 0, + row_end: bmat.dim_rows, + col_start: col, + col_end: end, + block_data, + } apply_fn(block) col = end } @@ -246,7 +276,11 @@ pub fn bmat_apply_row_blocks( let n_rows = bmat.dim_rows let mut row = 0 while row < n_rows { - let end = if row + row_block_size < n_rows { row + row_block_size } else { n_rows } + let end = if row + row_block_size < n_rows { + row + row_block_size + } else { + n_rows + } let block_data : Array[Array[Double]] = [] let mut i = row while i < end { @@ -259,7 +293,13 @@ pub fn bmat_apply_row_blocks( block_data.push(row_data) i = i + 1 } - let block = BmatBlock::{ row_start: row, row_end: end, col_start: 0, col_end: bmat.dim_cols, block_data } + let block = BmatBlock::{ + row_start: row, + row_end: end, + col_start: 0, + col_end: bmat.dim_cols, + block_data, + } apply_fn(block) row = end } @@ -267,10 +307,7 @@ pub fn bmat_apply_row_blocks( ///| /// Iterate over the full matrix and apply a function. -pub fn bmat_foreach( - bmat : Bmat, - iter_fn : (Int, Int, Double) -> Unit, -) -> Unit { +pub fn bmat_foreach(bmat : Bmat, iter_fn : (Int, Int, Double) -> Unit) -> Unit { let mut i = 0 while i < bmat.dim_rows { let mut j = 0 @@ -298,7 +335,12 @@ pub struct BmatIterator { ///| /// Create a new iterator. pub fn BmatIterator::new(bmat : Bmat) -> BmatIterator { - { data: bmat.data, total_cols: bmat.dim_cols, total: bmat.dim_rows * bmat.dim_cols, pos: 0 } + { + data: bmat.data, + total_cols: bmat.dim_cols, + total: bmat.dim_rows * bmat.dim_cols, + pos: 0, + } } ///| @@ -321,13 +363,21 @@ pub fn BmatIterator::next(self : BmatIterator) -> Double? { ///| /// Get current row index. pub fn BmatIterator::cur_row(self : BmatIterator) -> Int { - if self.total_cols == 0 { 0 } else { self.pos / self.total_cols } + if self.total_cols == 0 { + 0 + } else { + self.pos / self.total_cols + } } ///| /// Get current column index. pub fn BmatIterator::cur_col(self : BmatIterator) -> Int { - if self.total_cols == 0 { 0 } else { self.pos % self.total_cols } + if self.total_cols == 0 { + 0 + } else { + self.pos % self.total_cols + } } // ============================================================================ @@ -454,10 +504,7 @@ pub fn bmat_bind_rows(top : Bmat, bottom : Bmat) -> Bmat { ///| /// Apply a function to each element. -pub fn bmat_apply_elementwise( - bmat : Bmat, - map_fn : (Double) -> Double, -) -> Bmat { +pub fn bmat_apply_elementwise(bmat : Bmat, map_fn : (Double) -> Double) -> Bmat { let new_data : Array[Array[Double]] = [] let mut i = 0 while i < bmat.dim_rows { @@ -476,7 +523,11 @@ pub fn bmat_apply_elementwise( ///| /// Pretty-print a Bmat. pub fn Bmat::to_string(self : Bmat) -> String { - let mut s = "Bmat (" + self.dim_rows.to_string() + " x " + self.dim_cols.to_string() + "):\n" + let mut s = "Bmat (" + + self.dim_rows.to_string() + + " x " + + self.dim_cols.to_string() + + "):\n" let mut i = 0 while i < self.dim_rows { let mut j = 0 diff --git a/src/binary_cif.mbt b/src/binary_cif.mbt index c8a6fa2a..6b897458 100644 --- a/src/binary_cif.mbt +++ b/src/binary_cif.mbt @@ -174,9 +174,11 @@ pub fn BinaryCifDataBlock::get_category( ) -> BinaryCifCategory? { for category in self.categories { if category.name == name || - (name.length() > 0 && - name.unsafe_get(0).to_int() != '_'.to_int() && - category.name == "_" + name) { + ( + name.length() > 0 && + name.unsafe_get(0).to_int() != '_'.to_int() && + category.name == "_" + name + ) { return Some(category) } } @@ -218,6 +220,7 @@ pub fn BinaryCifFile::summary(self : BinaryCifFile) -> String { // MessagePack model and decoder. +///| priv enum BcifMessage { BcifNil BcifBoolean(Bool) @@ -229,11 +232,13 @@ priv enum BcifMessage { BcifMapValue(Map[String, BcifMessage]) } +///| priv struct BcifReader { data : Array[Int] mut position : Int } +///| fn bcif_read_byte(reader : BcifReader) -> Int raise BinaryCifError { if reader.position >= reader.data.length() { raise BinaryCifError("Truncated MessagePack input") @@ -243,6 +248,7 @@ fn bcif_read_byte(reader : BcifReader) -> Int raise BinaryCifError { value } +///| fn bcif_read_unsigned( reader : BcifReader, byte_count : Int, @@ -264,6 +270,7 @@ fn bcif_read_unsigned( value } +///| fn bcif_read_signed( reader : BcifReader, byte_count : Int, @@ -282,6 +289,7 @@ fn bcif_read_signed( value } +///| fn bcif_read_u64(reader : BcifReader) -> Int raise BinaryCifError { for _ in 0..<4 { if bcif_read_byte(reader) != 0 { @@ -291,6 +299,7 @@ fn bcif_read_u64(reader : BcifReader) -> Int raise BinaryCifError { bcif_read_unsigned(reader, 4) } +///| fn bcif_read_i64(reader : BcifReader) -> Int raise BinaryCifError { if reader.position + 8 > reader.data.length() { raise BinaryCifError("Truncated MessagePack int64") @@ -309,6 +318,7 @@ fn bcif_read_i64(reader : BcifReader) -> Int raise BinaryCifError { bcif_read_signed(reader, 4) } +///| fn bcif_pow2(exponent : Int) -> Double { let mut power = if exponent < 0 { -exponent } else { exponent } let mut base = 2.0 @@ -320,9 +330,14 @@ fn bcif_pow2(exponent : Int) -> Double { base = base * base power = power / 2 } - if exponent < 0 { 1.0 / result } else { result } + if exponent < 0 { + 1.0 / result + } else { + result + } } +///| fn bcif_float32_from_bytes( b0 : Int, b1 : Int, @@ -338,12 +353,11 @@ fn bcif_float32_from_bytes( if exponent == 0 { sign * mantissa.to_double() * bcif_pow2(-149) } else { - sign * - (1.0 + mantissa.to_double() / 8388608.0) * - bcif_pow2(exponent - 127) + sign * (1.0 + mantissa.to_double() / 8388608.0) * bcif_pow2(exponent - 127) } } +///| fn bcif_float64_from_bytes( bytes : Array[Int], offset : Int, @@ -375,6 +389,7 @@ fn bcif_float64_from_bytes( } } +///| fn bcif_read_float32(reader : BcifReader) -> Double raise BinaryCifError { let b0 = bcif_read_byte(reader) let b1 = bcif_read_byte(reader) @@ -383,6 +398,7 @@ fn bcif_read_float32(reader : BcifReader) -> Double raise BinaryCifError { bcif_float32_from_bytes(b0, b1, b2, b3) } +///| fn bcif_read_float64(reader : BcifReader) -> Double raise BinaryCifError { if reader.position + 8 > reader.data.length() { raise BinaryCifError("Truncated MessagePack float64") @@ -392,6 +408,7 @@ fn bcif_read_float64(reader : BcifReader) -> Double raise BinaryCifError { value } +///| fn bcif_read_utf8( reader : BcifReader, length : Int, @@ -413,7 +430,9 @@ fn bcif_read_utf8( if second < 0x80 || second > 0xBF { raise BinaryCifError("Invalid UTF-8 continuation byte") } - output.write_char(((first & 0x1F) * 64 + (second & 0x3F)).unsafe_to_char()) + output.write_char( + ((first & 0x1F) * 64 + (second & 0x3F)).unsafe_to_char(), + ) } else if first >= 0xE0 && first <= 0xEF { if reader.position + 2 > end { raise BinaryCifError("Truncated UTF-8 sequence") @@ -429,11 +448,7 @@ fn bcif_read_utf8( raise BinaryCifError("Invalid UTF-8 sequence") } output.write_char( - ( - (first & 0x0F) * 4096 + - (second & 0x3F) * 64 + - (third & 0x3F) - ).unsafe_to_char(), + ((first & 0x0F) * 4096 + (second & 0x3F) * 64 + (third & 0x3F)).unsafe_to_char(), ) } else if first >= 0xF0 && first <= 0xF4 { if reader.position + 3 > end { @@ -453,12 +468,10 @@ fn bcif_read_utf8( raise BinaryCifError("Invalid UTF-8 sequence") } output.write_char( - ( - (first & 0x07) * 262144 + - (second & 0x3F) * 4096 + - (third & 0x3F) * 64 + - (fourth & 0x3F) - ).unsafe_to_char(), + ((first & 0x07) * 262144 + + (second & 0x3F) * 4096 + + (third & 0x3F) * 64 + + (fourth & 0x3F)).unsafe_to_char(), ) } else { raise BinaryCifError("Invalid UTF-8 leading byte") @@ -467,6 +480,7 @@ fn bcif_read_utf8( output.to_string() } +///| fn bcif_read_binary( reader : BcifReader, length : Int, @@ -481,6 +495,7 @@ fn bcif_read_binary( result } +///| fn bcif_parse_message( reader : BcifReader, depth : Int, @@ -513,9 +528,12 @@ fn bcif_parse_message( 0xC0 => BcifNil 0xC2 => BcifBoolean(false) 0xC3 => BcifBoolean(true) - 0xC4 => BcifBinaryValue(bcif_read_binary(reader, bcif_read_unsigned(reader, 1))) - 0xC5 => BcifBinaryValue(bcif_read_binary(reader, bcif_read_unsigned(reader, 2))) - 0xC6 => BcifBinaryValue(bcif_read_binary(reader, bcif_read_unsigned(reader, 4))) + 0xC4 => + BcifBinaryValue(bcif_read_binary(reader, bcif_read_unsigned(reader, 1))) + 0xC5 => + BcifBinaryValue(bcif_read_binary(reader, bcif_read_unsigned(reader, 2))) + 0xC6 => + BcifBinaryValue(bcif_read_binary(reader, bcif_read_unsigned(reader, 4))) 0xCA => BcifFloatValue(bcif_read_float32(reader)) 0xCB => BcifFloatValue(bcif_read_float64(reader)) 0xCC => BcifIntegerValue(bcif_read_unsigned(reader, 1)) @@ -547,12 +565,14 @@ fn bcif_parse_message( } 0xDE => bcif_parse_map(reader, bcif_read_unsigned(reader, 2), depth + 1) 0xDF => bcif_parse_map(reader, bcif_read_unsigned(reader, 4), depth + 1) - _ => raise BinaryCifError( - "Unsupported MessagePack marker " + marker.to_string(), - ) + _ => + raise BinaryCifError( + "Unsupported MessagePack marker " + marker.to_string(), + ) } } +///| fn bcif_parse_map( reader : BcifReader, length : Int, @@ -569,6 +589,7 @@ fn bcif_parse_map( BcifMapValue(values) } +///| fn bcif_as_map( value : BcifMessage, context : String, @@ -579,6 +600,7 @@ fn bcif_as_map( } } +///| fn bcif_as_array( value : BcifMessage, context : String, @@ -589,6 +611,7 @@ fn bcif_as_array( } } +///| fn bcif_as_string( value : BcifMessage, context : String, @@ -599,6 +622,7 @@ fn bcif_as_string( } } +///| fn bcif_as_int( value : BcifMessage, context : String, @@ -609,6 +633,7 @@ fn bcif_as_int( } } +///| fn bcif_as_double( value : BcifMessage, context : String, @@ -620,6 +645,7 @@ fn bcif_as_double( } } +///| fn bcif_as_bool( value : BcifMessage, context : String, @@ -630,6 +656,7 @@ fn bcif_as_bool( } } +///| fn bcif_as_binary( value : BcifMessage, context : String, @@ -640,6 +667,7 @@ fn bcif_as_binary( } } +///| fn bcif_required( values : Map[String, BcifMessage], key : String, @@ -651,6 +679,7 @@ fn bcif_required( } } +///| fn bcif_encoding_int( values : Map[String, BcifMessage], key : String, @@ -659,6 +688,7 @@ fn bcif_encoding_int( bcif_as_int(bcif_required(values, key, context), context + "." + key) } +///| fn bcif_encoding_double( values : Map[String, BcifMessage], key : String, @@ -669,15 +699,18 @@ fn bcif_encoding_double( // BinaryCIF encoding decoders. +///| fn bcif_read_i16_le(data : Array[Int], offset : Int) -> Int { let high = data[offset + 1] (if high >= 128 { high - 256 } else { high }) * 256 + data[offset] } +///| fn bcif_read_u16_le(data : Array[Int], offset : Int) -> Int { data[offset] + data[offset + 1] * 256 } +///| fn bcif_read_i32_le(data : Array[Int], offset : Int) -> Int { let high = data[offset + 3] (if high >= 128 { high - 256 } else { high }) * 16777216 + @@ -686,6 +719,7 @@ fn bcif_read_i32_le(data : Array[Int], offset : Int) -> Int { data[offset] } +///| fn bcif_read_u32_le( data : Array[Int], offset : Int, @@ -699,6 +733,7 @@ fn bcif_read_u32_le( data[offset] } +///| fn bcif_validate_bytes(data : Array[Int]) -> Unit raise BinaryCifError { for value in data { if value < 0 || value > 255 { @@ -728,7 +763,11 @@ pub fn binary_cif_decode_int_bytes( let value = match type_code { 1 => { let raw = data[offset] - if raw >= 128 { raw - 256 } else { raw } + if raw >= 128 { + raw - 256 + } else { + raw + } } 2 => bcif_read_i16_le(data, offset) 3 => bcif_read_i32_le(data, offset) @@ -752,10 +791,13 @@ pub fn binary_cif_decode_float_bytes( let width = match type_code { 32 => 4 33 => 8 - _ => raise BinaryCifError("BinaryCIF type is not a floating-point byte array") + _ => + raise BinaryCifError("BinaryCIF type is not a floating-point byte array") } if data.length() % width != 0 { - raise BinaryCifError("BinaryCIF floating-point byte array has an invalid length") + raise BinaryCifError( + "BinaryCIF floating-point byte array has an invalid length", + ) } let result = Array::new(capacity=data.length() / width) let mut offset = 0 @@ -791,7 +833,11 @@ pub fn binary_cif_decode_integer_packing( raise BinaryCifError("BinaryCIF integer packing source size is negative") } let upper = if is_unsigned { - if byte_count == 1 { 255 } else { 65535 } + if byte_count == 1 { + 255 + } else { + 65535 + } } else if byte_count == 1 { 127 } else { @@ -808,7 +854,9 @@ pub fn binary_cif_decode_integer_packing( let mut accumulator = 0 for value in data { if value < lower || value > upper { - raise BinaryCifError("BinaryCIF integer packing value is outside its byte range") + raise BinaryCifError( + "BinaryCIF integer packing value is outside its byte range", + ) } accumulator = accumulator + value let continuation = value == upper || (!is_unsigned && value == lower) @@ -851,10 +899,7 @@ pub fn binary_cif_decode_run_length( } ///| -pub fn binary_cif_decode_delta( - data : Array[Int], - origin : Int, -) -> Array[Int] { +pub fn binary_cif_decode_delta(data : Array[Int], origin : Int) -> Array[Int] { let result = Array::new(capacity=data.length()) let mut current = origin for value in data { @@ -870,7 +915,9 @@ pub fn binary_cif_decode_fixed_point( factor : Double, ) -> Array[Double] raise BinaryCifError { if factor == 0.0 || factor.abs() > 1.0e300 { - raise BinaryCifError("BinaryCIF fixed-point factor must be finite and non-zero") + raise BinaryCifError( + "BinaryCIF fixed-point factor must be finite and non-zero", + ) } let result = Array::new(capacity=data.length()) for value in data { @@ -918,13 +965,13 @@ pub fn binary_cif_decode_string_array( } } if offsets[offsets.length() - 1] != string_data.length() { - raise BinaryCifError("BinaryCIF string offsets do not cover the string data") + raise BinaryCifError( + "BinaryCIF string offsets do not cover the string data", + ) } let dictionary = Array::new(capacity=offsets.length() - 1) for i in 0..<(offsets.length() - 1) { - dictionary.push( - string_data[offsets[i]:offsets[i + 1]].to_owned(), - ) + dictionary.push(string_data[offsets[i]:offsets[i + 1]].to_owned()) } let result = Array::new(capacity=indices.length()) for index in indices { @@ -936,6 +983,7 @@ pub fn binary_cif_decode_string_array( result } +///| fn bcif_decoded_length(data : BinaryCifColumnData) -> Int { match data { BinaryCifIntegers(values) => values.length() @@ -944,6 +992,7 @@ fn bcif_decoded_length(data : BinaryCifColumnData) -> Int { } } +///| fn bcif_decode_raw( bytes : Array[Int], encodings : Array[BcifMessage], @@ -961,7 +1010,10 @@ fn bcif_decode_raw( "ByteArray" => { let source = match raw_bytes { Some(value) => value - None => raise BinaryCifError("ByteArray must be the final BinaryCIF encoding") + None => + raise BinaryCifError( + "ByteArray must be the final BinaryCIF encoding", + ) } let type_code = bcif_encoding_int(encoding, "type", "ByteArray") decoded = Some( @@ -978,8 +1030,12 @@ fn bcif_decode_raw( Some(BinaryCifIntegers(value)) => value _ => raise BinaryCifError("IntegerPacking requires integer input") } - let byte_count = bcif_encoding_int(encoding, "byteCount", "IntegerPacking") - let source_size = bcif_encoding_int(encoding, "srcSize", "IntegerPacking") + let byte_count = bcif_encoding_int( + encoding, "byteCount", "IntegerPacking", + ) + let source_size = bcif_encoding_int( + encoding, "srcSize", "IntegerPacking", + ) let is_unsigned = bcif_as_bool( bcif_required(encoding, "isUnsigned", "IntegerPacking"), "IntegerPacking.isUnsigned", @@ -987,10 +1043,7 @@ fn bcif_decode_raw( decoded = Some( BinaryCifIntegers( binary_cif_decode_integer_packing( - values, - byte_count, - is_unsigned, - source_size, + values, byte_count, is_unsigned, source_size, ), ), ) @@ -1040,7 +1093,8 @@ fn bcif_decode_raw( "IntervalQuantization" => { let values = match decoded { Some(BinaryCifIntegers(value)) => value - _ => raise BinaryCifError("IntervalQuantization requires integer input") + _ => + raise BinaryCifError("IntervalQuantization requires integer input") } let steps = match encoding.get("numSteps") { Some(value) => bcif_as_int(value, "IntervalQuantization.numSteps") @@ -1080,11 +1134,15 @@ fn bcif_decode_raw( ) let indices = match bcif_decode_raw(source, data_encodings) { BinaryCifIntegers(value) => value - _ => raise BinaryCifError("StringArray lookup data must decode to integers") + _ => + raise BinaryCifError( + "StringArray lookup data must decode to integers", + ) } let offsets = match bcif_decode_raw(offsets_bytes, offset_encodings) { BinaryCifIntegers(value) => value - _ => raise BinaryCifError("StringArray offsets must decode to integers") + _ => + raise BinaryCifError("StringArray offsets must decode to integers") } decoded = Some( BinaryCifStrings( @@ -1110,6 +1168,7 @@ fn bcif_decode_raw( } } +///| fn bcif_decode_data( value : BcifMessage, context : String, @@ -1126,6 +1185,7 @@ fn bcif_decode_data( bcif_decode_raw(bytes, encodings) } +///| fn bcif_parse_column( value : BcifMessage, row_count : Int, @@ -1150,7 +1210,9 @@ fn bcif_parse_column( match bcif_decode_data(mask_value, "BinaryCIF column mask") { BinaryCifIntegers(values) => { if values.length() != row_count { - raise BinaryCifError("BinaryCIF mask length does not match rowCount") + raise BinaryCifError( + "BinaryCIF mask length does not match rowCount", + ) } for item in values { if item < 0 || item > 2 { @@ -1165,6 +1227,7 @@ fn bcif_parse_column( BinaryCifColumn::{ name, data, mask } } +///| fn bcif_parse_category( value : BcifMessage, ) -> BinaryCifCategory raise BinaryCifError { @@ -1197,6 +1260,7 @@ fn bcif_parse_category( BinaryCifCategory::{ name, row_count, columns } } +///| fn bcif_parse_block( value : BcifMessage, ) -> BinaryCifDataBlock raise BinaryCifError { @@ -1214,7 +1278,9 @@ fn bcif_parse_block( for raw_category in raw_categories { let category = bcif_parse_category(raw_category) if seen.contains(category.name) { - raise BinaryCifError("Duplicate BinaryCIF category '" + category.name + "'") + raise BinaryCifError( + "Duplicate BinaryCIF category '" + category.name + "'", + ) } seen[category.name] = true categories.push(category) @@ -1235,13 +1301,12 @@ pub fn binary_cif_parse( } } if input.length() >= 2 && input[0] == 0x1F && input[1] == 0x8B { - raise BinaryCifError("Gzip-compressed BinaryCIF input must be decompressed first") + raise BinaryCifError( + "Gzip-compressed BinaryCIF input must be decompressed first", + ) } let reader = BcifReader::{ data: input, position: 0 } - let root = bcif_as_map( - bcif_parse_message(reader, 0), - "BinaryCIF document", - ) + let root = bcif_as_map(bcif_parse_message(reader, 0), "BinaryCIF document") if reader.position != input.length() { raise BinaryCifError("Additional bytes follow the BinaryCIF document") } @@ -1269,6 +1334,7 @@ pub fn binary_cif_parse( // PDB Structure conversion. +///| priv struct BcifResidueBuilder { resname : String chain_id : Char @@ -1278,65 +1344,80 @@ priv struct BcifResidueBuilder { atoms : Array[Atom] } +///| priv struct BcifChainBuilder { full_id : String chain_id : Char residues : Array[BcifResidueBuilder] } +///| priv struct BcifModelBuilder { model_number : Int chains : Array[BcifChainBuilder] } +///| fn bcif_require_column( category : BinaryCifCategory, name : String, ) -> BinaryCifColumn raise BinaryCifError { match category.get_column(name) { Some(column) => column - None => raise BinaryCifError( - "BinaryCIF category '" + category.name + "' is missing column '" + name + "'", - ) + None => + raise BinaryCifError( + "BinaryCIF category '" + + category.name + + "' is missing column '" + + name + + "'", + ) } } +///| fn bcif_required_string( column : BinaryCifColumn, row : Int, ) -> String raise BinaryCifError { match column.string_at(row) { Some(value) => value - None => raise BinaryCifError( - "Required BinaryCIF value '" + column.name + "' is missing", - ) + None => + raise BinaryCifError( + "Required BinaryCIF value '" + column.name + "' is missing", + ) } } +///| fn bcif_required_int( column : BinaryCifColumn, row : Int, ) -> Int raise BinaryCifError { match column.int_at(row) { Some(value) => value - None => raise BinaryCifError( - "Required BinaryCIF value '" + column.name + "' is missing", - ) + None => + raise BinaryCifError( + "Required BinaryCIF value '" + column.name + "' is missing", + ) } } +///| fn bcif_required_double( column : BinaryCifColumn, row : Int, ) -> Double raise BinaryCifError { match column.double_at(row) { Some(value) => value - None => raise BinaryCifError( - "Required BinaryCIF value '" + column.name + "' is missing", - ) + None => + raise BinaryCifError( + "Required BinaryCIF value '" + column.name + "' is missing", + ) } } +///| fn bcif_optional_string( category : BinaryCifCategory, name : String, @@ -1353,6 +1434,7 @@ fn bcif_optional_string( } } +///| fn bcif_optional_int( category : BinaryCifCategory, name : String, @@ -1369,6 +1451,7 @@ fn bcif_optional_int( } } +///| fn bcif_optional_double( category : BinaryCifCategory, name : String, @@ -1385,6 +1468,7 @@ fn bcif_optional_double( } } +///| fn bcif_first_char_or_space(value : String) -> Char { if value.length() == 0 || value == "." || value == "?" { ' ' @@ -1393,14 +1477,20 @@ fn bcif_first_char_or_space(value : String) -> Char { } } +///| fn bcif_hetero_field(group : String, component : String) -> String { if group == "HETATM" { - if component == "HOH" || component == "WAT" { "W" } else { "H" } + if component == "HOH" || component == "WAT" { + "W" + } else { + "H" + } } else { " " } } +///| fn bcif_entry_id(file : BinaryCifFile) -> String raise BinaryCifError { let block = file.data_blocks[0] match block.get_category("_entry") { @@ -1440,10 +1530,7 @@ pub fn binary_cif_to_structure( let builders : Array[BcifModelBuilder] = [] for row in 0.. BcifMessage { let values : Map[String, BcifMessage] = Map([], capacity=entries.length()) for entry in entries { @@ -1577,15 +1663,18 @@ fn bcif_message_map(entries : Array[(String, BcifMessage)]) -> BcifMessage { BcifMapValue(values) } +///| fn bcif_message_array(values : Array[BcifMessage]) -> BcifMessage { BcifArrayValue(values) } +///| fn bcif_write_u16_be(output : Array[Int], value : Int) -> Unit { output.push((value >> 8) & 0xFF) output.push(value & 0xFF) } +///| fn bcif_write_u32_be(output : Array[Int], value : Int) -> Unit { output.push((value >> 24) & 0xFF) output.push((value >> 16) & 0xFF) @@ -1593,6 +1682,7 @@ fn bcif_write_u32_be(output : Array[Int], value : Int) -> Unit { output.push(value & 0xFF) } +///| fn bcif_write_i32_le(output : Array[Int], value : Int) -> Unit { output.push(value & 0xFF) output.push((value >> 8) & 0xFF) @@ -1600,6 +1690,7 @@ fn bcif_write_i32_le(output : Array[Int], value : Int) -> Unit { output.push((value >> 24) & 0xFF) } +///| fn bcif_pack_length( output : Array[Int], small_base : Int, @@ -1618,6 +1709,7 @@ fn bcif_pack_length( } } +///| fn bcif_pack_string(output : Array[Int], value : String) -> Unit { let length = value.length() if length < 32 { @@ -1637,6 +1729,7 @@ fn bcif_pack_string(output : Array[Int], value : String) -> Unit { } } +///| fn bcif_pack_float64(output : Array[Int], value : Double) -> Unit { output.push(0xCB) if value == 0.0 { @@ -1671,6 +1764,7 @@ fn bcif_pack_float64(output : Array[Int], value : Double) -> Unit { } } +///| fn bcif_pack_message(output : Array[Int], value : BcifMessage) -> Unit { match value { BcifNil => output.push(0xC0) @@ -1719,6 +1813,7 @@ fn bcif_pack_message(output : Array[Int], value : BcifMessage) -> Unit { } } +///| fn bcif_byte_array_encoding(type_code : Int) -> BcifMessage { bcif_message_map([ ("kind", BcifTextValue("ByteArray")), @@ -1726,10 +1821,8 @@ fn bcif_byte_array_encoding(type_code : Int) -> BcifMessage { ]) } -fn bcif_sample_int_column( - name : String, - values : Array[Int], -) -> BcifMessage { +///| +fn bcif_sample_int_column(name : String, values : Array[Int]) -> BcifMessage { let bytes = Array::new(capacity=values.length() * 4) for value in values { bcif_write_i32_le(bytes, value) @@ -1746,6 +1839,7 @@ fn bcif_sample_int_column( ]) } +///| fn bcif_sample_fixed_column( name : String, scaled_values : Array[Int], @@ -1788,6 +1882,7 @@ fn bcif_sample_fixed_column( ]) } +///| fn bcif_sample_string_column( name : String, values : Array[String], @@ -1867,32 +1962,27 @@ fn bcif_sample_string_column( pub fn binary_cif_sample_bytes() -> Array[Int] { let atom_count = 8 let atom_columns = [ - bcif_sample_string_column( - "group_PDB", - ["ATOM", "ATOM", "ATOM", "ATOM", "ATOM", "HETATM", "ATOM", "ATOM"], - ), + bcif_sample_string_column("group_PDB", [ + "ATOM", "ATOM", "ATOM", "ATOM", "ATOM", "HETATM", "ATOM", "ATOM", + ]), bcif_sample_int_column("id", [1, 2, 3, 4, 5, 6, 7, 8]), - bcif_sample_string_column( - "type_symbol", - ["N", "C", "C", "N", "C", "O", "N", "C"], - ), - bcif_sample_string_column( - "label_atom_id", - ["N", "CA", "C", "N", "CA", "O", "N", "CA"], - ), + bcif_sample_string_column("type_symbol", [ + "N", "C", "C", "N", "C", "O", "N", "C", + ]), + bcif_sample_string_column("label_atom_id", [ + "N", "CA", "C", "N", "CA", "O", "N", "CA", + ]), bcif_sample_string_column( "label_alt_id", ["", "", "", "A", "A", "", "", ""], mask=[1, 1, 1, 0, 0, 1, 2, 1], ), - bcif_sample_string_column( - "label_comp_id", - ["GLY", "GLY", "GLY", "ALA", "ALA", "HOH", "SER", "SER"], - ), - bcif_sample_string_column( - "label_asym_id", - ["A", "A", "A", "A", "A", "B", "A", "A"], - ), + bcif_sample_string_column("label_comp_id", [ + "GLY", "GLY", "GLY", "ALA", "ALA", "HOH", "SER", "SER", + ]), + bcif_sample_string_column("label_asym_id", [ + "A", "A", "A", "A", "A", "B", "A", "A", + ]), bcif_sample_int_column("auth_seq_id", [1, 1, 1, 2, 2, 10, 1, 1]), bcif_sample_string_column( "pdbx_PDB_ins_code", @@ -1942,9 +2032,7 @@ pub fn binary_cif_sample_bytes() -> Array[Int] { ("rowCount", BcifIntegerValue(1)), ( "columns", - bcif_message_array([ - bcif_sample_string_column("id", ["BCIF"]), - ]), + bcif_message_array([bcif_sample_string_column("id", ["BCIF"])]), ), ]), bcif_message_map([ diff --git a/src/bioc_generics.mbt b/src/bioc_generics.mbt index 6e010b0a..970297e7 100644 --- a/src/bioc_generics.mbt +++ b/src/bioc_generics.mbt @@ -164,7 +164,7 @@ pub fn order_int(arr : Array[Int]) -> Array[Int] { indices.push(i) i = i + 1 } - + let mut sorted = false while !sorted { sorted = true @@ -180,7 +180,7 @@ pub fn order_int(arr : Array[Int]) -> Array[Int] { i = i + 1 } } - + indices } @@ -193,7 +193,7 @@ pub fn order_double(arr : Array[Double]) -> Array[Int] { indices.push(i) i = i + 1 } - + let mut sorted = false while !sorted { sorted = true @@ -209,7 +209,7 @@ pub fn order_double(arr : Array[Double]) -> Array[Int] { i = i + 1 } } - + indices } @@ -241,7 +241,7 @@ pub fn sort_double(arr : Array[Double]) -> Array[Double] { pub fn unique_int(arr : Array[Int]) -> Array[Int] { let result : Array[Int] = Array::new() let seen = Map([], capacity=arr.length()) - + let mut i = 0 while i < arr.length() { if !seen.contains(arr[i].to_string()) { @@ -250,7 +250,7 @@ pub fn unique_int(arr : Array[Int]) -> Array[Int] { } i = i + 1 } - + result } @@ -258,7 +258,7 @@ pub fn unique_int(arr : Array[Int]) -> Array[Int] { pub fn unique_double(arr : Array[Double]) -> Array[Double] { let result : Array[Double] = Array::new() let seen = Map([], capacity=arr.length()) - + let mut i = 0 while i < arr.length() { if !seen.contains(arr[i].to_string()) { @@ -267,7 +267,7 @@ pub fn unique_double(arr : Array[Double]) -> Array[Double] { } i = i + 1 } - + result } @@ -275,7 +275,7 @@ pub fn unique_double(arr : Array[Double]) -> Array[Double] { pub fn unique_string(arr : Array[String]) -> Array[String] { let result : Array[String] = Array::new() let seen = Map([], capacity=arr.length()) - + let mut i = 0 while i < arr.length() { if !seen.contains(arr[i]) { @@ -284,7 +284,7 @@ pub fn unique_string(arr : Array[String]) -> Array[String] { } i = i + 1 } - + result } @@ -292,13 +292,13 @@ pub fn unique_string(arr : Array[String]) -> Array[String] { pub fn match_int(x : Array[Int], table : Array[Int]) -> Array[Int] { let result : Array[Int] = Array::new() let table_map = Map([], capacity=table.length()) - + let mut i = 0 while i < table.length() { table_map.set(table[i].to_string(), i) i = i + 1 } - + i = 0 while i < x.length() { if table_map.contains(x[i].to_string()) { @@ -308,7 +308,7 @@ pub fn match_int(x : Array[Int], table : Array[Int]) -> Array[Int] { } i = i + 1 } - + result } @@ -316,13 +316,13 @@ pub fn match_int(x : Array[Int], table : Array[Int]) -> Array[Int] { pub fn match_string(x : Array[String], table : Array[String]) -> Array[Int] { let result : Array[Int] = Array::new() let table_map = Map([], capacity=table.length()) - + let mut i = 0 while i < table.length() { table_map.set(table[i], i) i = i + 1 } - + i = 0 while i < x.length() { if table_map.contains(x[i]) { @@ -332,7 +332,7 @@ pub fn match_string(x : Array[String], table : Array[String]) -> Array[Int] { } i = i + 1 } - + result } @@ -340,13 +340,13 @@ pub fn match_string(x : Array[String], table : Array[String]) -> Array[Int] { pub fn intersect_int(x : Array[Int], y : Array[Int]) -> Array[Int] { let result : Array[Int] = Array::new() let y_set = Map([], capacity=y.length()) - + let mut i = 0 while i < y.length() { y_set.set(y[i].to_string(), true) i = i + 1 } - + i = 0 while i < x.length() { if y_set.contains(x[i].to_string()) { @@ -354,7 +354,7 @@ pub fn intersect_int(x : Array[Int], y : Array[Int]) -> Array[Int] { } i = i + 1 } - + result } @@ -362,13 +362,13 @@ pub fn intersect_int(x : Array[Int], y : Array[Int]) -> Array[Int] { pub fn intersect_string(x : Array[String], y : Array[String]) -> Array[String] { let result : Array[String] = Array::new() let y_set = Map([], capacity=y.length()) - + let mut i = 0 while i < y.length() { y_set.set(y[i], true) i = i + 1 } - + i = 0 while i < x.length() { if y_set.contains(x[i]) { @@ -376,7 +376,7 @@ pub fn intersect_string(x : Array[String], y : Array[String]) -> Array[String] { } i = i + 1 } - + result } @@ -384,7 +384,7 @@ pub fn intersect_string(x : Array[String], y : Array[String]) -> Array[String] { pub fn union_int(x : Array[Int], y : Array[Int]) -> Array[Int] { let result : Array[Int] = Array::new() let seen = Map([], capacity=x.length() + y.length()) - + let mut i = 0 while i < x.length() { if !seen.contains(x[i].to_string()) { @@ -393,7 +393,7 @@ pub fn union_int(x : Array[Int], y : Array[Int]) -> Array[Int] { } i = i + 1 } - + i = 0 while i < y.length() { if !seen.contains(y[i].to_string()) { @@ -402,7 +402,7 @@ pub fn union_int(x : Array[Int], y : Array[Int]) -> Array[Int] { } i = i + 1 } - + result } @@ -410,7 +410,7 @@ pub fn union_int(x : Array[Int], y : Array[Int]) -> Array[Int] { pub fn union_string(x : Array[String], y : Array[String]) -> Array[String] { let result : Array[String] = Array::new() let seen = Map([], capacity=x.length() + y.length()) - + let mut i = 0 while i < x.length() { if !seen.contains(x[i]) { @@ -419,7 +419,7 @@ pub fn union_string(x : Array[String], y : Array[String]) -> Array[String] { } i = i + 1 } - + i = 0 while i < y.length() { if !seen.contains(y[i]) { @@ -428,7 +428,7 @@ pub fn union_string(x : Array[String], y : Array[String]) -> Array[String] { } i = i + 1 } - + result } @@ -436,13 +436,13 @@ pub fn union_string(x : Array[String], y : Array[String]) -> Array[String] { pub fn setdiff_int(x : Array[Int], y : Array[Int]) -> Array[Int] { let result : Array[Int] = Array::new() let y_set = Map([], capacity=y.length()) - + let mut i = 0 while i < y.length() { y_set.set(y[i].to_string(), true) i = i + 1 } - + i = 0 while i < x.length() { if !y_set.contains(x[i].to_string()) { @@ -450,7 +450,7 @@ pub fn setdiff_int(x : Array[Int], y : Array[Int]) -> Array[Int] { } i = i + 1 } - + result } @@ -458,13 +458,13 @@ pub fn setdiff_int(x : Array[Int], y : Array[Int]) -> Array[Int] { pub fn setdiff_string(x : Array[String], y : Array[String]) -> Array[String] { let result : Array[String] = Array::new() let y_set = Map([], capacity=y.length()) - + let mut i = 0 while i < y.length() { y_set.set(y[i], true) i = i + 1 } - + i = 0 while i < x.length() { if !y_set.contains(x[i]) { @@ -472,14 +472,14 @@ pub fn setdiff_string(x : Array[String], y : Array[String]) -> Array[String] { } i = i + 1 } - + result } ///| pub fn table_int(arr : Array[Int]) -> Map[String, Int] { let result = Map([], capacity=arr.length()) - + let mut i = 0 while i < arr.length() { let key = arr[i].to_string() @@ -490,14 +490,14 @@ pub fn table_int(arr : Array[Int]) -> Map[String, Int] { } i = i + 1 } - + result } ///| pub fn table_string(arr : Array[String]) -> Map[String, Int] { let result = Map([], capacity=arr.length()) - + let mut i = 0 while i < arr.length() { let key = arr[i] @@ -508,7 +508,7 @@ pub fn table_string(arr : Array[String]) -> Map[String, Int] { } i = i + 1 } - + result } @@ -582,7 +582,7 @@ pub fn rep_string(x : String, times : Int) -> Array[String] { pub fn seq_int(from : Int, to : Int, by? : Int) -> Array[Int] { let step = if by is Some(_) { by.unwrap() } else { 1 } let result : Array[Int] = Array::new() - + if step > 0 { let mut i = from while i <= to { @@ -596,7 +596,7 @@ pub fn seq_int(from : Int, to : Int, by? : Int) -> Array[Int] { i = i + step } } - + result } @@ -604,7 +604,7 @@ pub fn seq_int(from : Int, to : Int, by? : Int) -> Array[Int] { pub fn seq_double(from : Double, to : Double, by? : Double) -> Array[Double] { let step = if by is Some(_) { by.unwrap() } else { 1.0 } let result : Array[Double] = Array::new() - + if step > 0.0 { let mut i = from while i <= to { @@ -618,7 +618,7 @@ pub fn seq_double(from : Double, to : Double, by? : Double) -> Array[Double] { i = i + step } } - + result } @@ -740,10 +740,10 @@ pub fn cbind(arrays : Array[Array[Double]]) -> Array[Array[Double]] { if arrays.length() == 0 { return [] } - + let nrow = arrays[0].length() let result : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < nrow { let row : Array[Double] = Array::new() @@ -759,19 +759,19 @@ pub fn cbind(arrays : Array[Array[Double]]) -> Array[Array[Double]] { result.push(row) i = i + 1 } - + result } ///| pub fn rbind(arrays : Array[Array[Double]]) -> Array[Array[Double]] { let result : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < arrays.length() { result.push(arrays[i].copy()) i = i + 1 } - + result } diff --git a/src/bioc_neighbors.mbt b/src/bioc_neighbors.mbt index a0ce946d..91b07ca2 100644 --- a/src/bioc_neighbors.mbt +++ b/src/bioc_neighbors.mbt @@ -166,7 +166,13 @@ fn km_init_centroids( let (new_lcg, rand_val) = lcg_next_double(lcg) lcg = new_lcg let idx = (rand_val * n_points.to_double()).to_int() - let actual_idx = if idx >= n_points { n_points - 1 } else { if idx < 0 { 0 } else { idx } } + let actual_idx = if idx >= n_points { + n_points - 1 + } else if idx < 0 { + 0 + } else { + idx + } if !used_indices[actual_idx] { centroids.push(data[actual_idx].copy()) used_indices[actual_idx] = true @@ -249,12 +255,20 @@ fn km_kmeans( if n_points == 0 { return ([], []) } - let actual_clusters = if n_clusters > n_points { n_points } else { n_clusters } + let actual_clusters = if n_clusters > n_points { + n_points + } else { + n_clusters + } let mut centroids = km_init_centroids(data, n_points, n_dim, actual_clusters) let mut assignments = Array::make(n_points, 0) for iter = 0; iter < max_iter; iter = iter + 1 { - let new_assignments = km_assign_points(data, centroids, n_points, n_dim, actual_clusters) - let new_centroids = km_update_centroids(data, new_assignments, n_points, n_dim, actual_clusters) + let new_assignments = km_assign_points( + data, centroids, n_points, n_dim, actual_clusters, + ) + let new_centroids = km_update_centroids( + data, new_assignments, n_points, n_dim, actual_clusters, + ) let mut max_shift = 0.0 for c = 0; c < actual_clusters; c = c + 1 { let shift = euclidean_distance(centroids[c], new_centroids[c]) @@ -282,7 +296,7 @@ pub fn build_knn_index( match options.method { KMKNN => build_kmknn_index(data, n_points, n_dim, options) Annoy => build_annoy_index(data, n_points, n_dim, options) - BruteForce => { + BruteForce => IndexResult::{ method: BruteForce, n_points, @@ -291,7 +305,6 @@ pub fn build_knn_index( centroids: [], tree_nodes: [], } - } } } @@ -317,8 +330,12 @@ pub fn build_kmknn_index( let n_clusters = if n_points <= 10 { 1 } else { - let sqrt_val = ((n_points.to_double()).sqrt()).to_int() - if sqrt_val < 2 { 2 } else { sqrt_val } + let sqrt_val = n_points.to_double().sqrt().to_int() + if sqrt_val < 2 { + 2 + } else { + sqrt_val + } } let (centroids, _) = km_kmeans(data, n_points, n_dim, n_clusters, 20) IndexResult::{ @@ -368,7 +385,13 @@ fn build_single_annoy_tree( let (new_lcg, rand_dim) = lcg_next_double(current_lcg) current_lcg = new_lcg let split_dim = (rand_dim * n_dim.to_double()).to_int() - let actual_dim = if split_dim >= n_dim { n_dim - 1 } else { if split_dim < 0 { 0 } else { split_dim } } + let actual_dim = if split_dim >= n_dim { + n_dim - 1 + } else if split_dim < 0 { + 0 + } else { + split_dim + } let (new_lcg2, rand_val) = lcg_next_double(current_lcg) current_lcg = new_lcg2 @@ -377,8 +400,12 @@ fn build_single_annoy_tree( let mut max_val = data[point_indices[0]][actual_dim] for i = 1; i < n; i = i + 1 { let v = data[point_indices[i]][actual_dim] - if v < min_val { min_val = v } - if v > max_val { max_val = v } + if v < min_val { + min_val = v + } + if v > max_val { + max_val = v + } } let split_val = min_val + rand_val * (max_val - min_val) @@ -446,7 +473,9 @@ fn build_single_annoy_tree( point_indices: [], } - let idx = nodes_copy.length() - (nodes_after_right.length() - nodes_after_left.length()) - 1 + let idx = nodes_copy.length() - + (nodes_after_right.length() - nodes_after_left.length()) - + 1 nodes_copy[idx] = node (nodes_copy, node_id, current_lcg) @@ -476,7 +505,13 @@ pub fn build_annoy_index( 5 } else { let d = (@math.log2(n_points.to_double()) + 1.0).to_int() - if d > 20 { 20 } else { if d < 3 { 3 } else { d } } + if d > 20 { + 20 + } else if d < 3 { + 3 + } else { + d + } } let mut all_nodes : Array[AnnoyNode] = [] @@ -496,7 +531,13 @@ pub fn build_annoy_index( let (new_lcg2, rand_val) = lcg_next_double(shuf_lcg) shuf_lcg = new_lcg2 let idx = (rand_val * indices_left.length().to_double()).to_int() - let actual_idx = if idx >= indices_left.length() { indices_left.length() - 1 } else { if idx < 0 { 0 } else { idx } } + let actual_idx = if idx >= indices_left.length() { + indices_left.length() - 1 + } else if idx < 0 { + 0 + } else { + idx + } shuffled.push(indices_left[actual_idx]) let new_left : Array[Int] = [] for i = 0; i < indices_left.length(); i = i + 1 { @@ -509,14 +550,7 @@ pub fn build_annoy_index( let tree_start_id = all_nodes.length() let (tree_nodes, _, final_lcg) = build_single_annoy_tree( - data, - shuffled, - n_dim, - all_nodes, - tree_start_id, - 0, - max_depth, - lcg, + data, shuffled, n_dim, all_nodes, tree_start_id, 0, max_depth, lcg, ) all_nodes = tree_nodes lcg = final_lcg @@ -549,8 +583,14 @@ pub fn knn_quick_sort( let pivot = sorted_distances[pivot_idx] let pivot_index = sorted_indices[pivot_idx] while i <= j { - while sorted_distances[i] < pivot || (sorted_distances[i] == pivot && sorted_indices[i] < pivot_index) { i = i + 1 } - while sorted_distances[j] > pivot || (sorted_distances[j] == pivot && sorted_indices[j] > pivot_index) { j = j - 1 } + while sorted_distances[i] < pivot || + (sorted_distances[i] == pivot && sorted_indices[i] < pivot_index) { + i = i + 1 + } + while sorted_distances[j] > pivot || + (sorted_distances[j] == pivot && sorted_indices[j] > pivot_index) { + j = j - 1 + } if i <= j { let tmp_idx = sorted_indices[i] sorted_indices[i] = sorted_indices[j] @@ -574,14 +614,13 @@ pub fn knn_quick_sort( ///| /// Find indices of the k smallest distances. -pub fn knn_find_k_smallest( - distances : Array[Double], - k : Int, -) -> Array[Int] { +pub fn knn_find_k_smallest(distances : Array[Double], k : Int) -> Array[Int] { let n = distances.length() if k >= n { let result = Array::make(n, 0) - for i = 0; i < n; i = i + 1 { result[i] = i } + for i = 0; i < n; i = i + 1 { + result[i] = i + } return result } let indices : Array[Int] = [] @@ -610,12 +649,7 @@ pub fn knn_brute_force( ) -> KNNResult { if n_query == 0 || n_points == 0 || k == 0 { let actual_k = if k > n_points { n_points } else { k } - return KNNResult::{ - indices: [], - distances: [], - n_query, - k: actual_k, - } + return KNNResult::{ indices: [], distances: [], n_query, k: actual_k } } let actual_k = if k > n_points { n_points } else { k } let all_indices : Array[Array[Int]] = [] @@ -628,7 +662,12 @@ pub fn knn_brute_force( dists[i] = knn_compute_distance(query_point, data[i], distance) indices[i] = i } - let (sorted_indices, sorted_distances) = knn_quick_sort(dists, indices, 0, n_points - 1) + let (sorted_indices, sorted_distances) = knn_quick_sort( + dists, + indices, + 0, + n_points - 1, + ) let top_indices = Array::make(actual_k, 0) let top_distances = Array::make(actual_k, 0.0) for i = 0; i < actual_k; i = i + 1 { @@ -638,7 +677,12 @@ pub fn knn_brute_force( all_indices.push(top_indices) all_distances.push(top_distances) } - KNNResult::{ indices: all_indices, distances: all_distances, n_query, k: actual_k } + KNNResult::{ + indices: all_indices, + distances: all_distances, + n_query, + k: actual_k, + } } ///| @@ -652,15 +696,16 @@ pub fn run_knn( match index.method { KMKNN => knn_kmknn(index, query_data, n_query, options) Annoy => knn_annoy(index, query_data, n_query, options) - BruteForce => knn_brute_force( - index.data, - index.n_points, - index.n_dim, - query_data, - n_query, - options.k, - options.distance, - ) + BruteForce => + knn_brute_force( + index.data, + index.n_points, + index.n_dim, + query_data, + n_query, + options.k, + options.distance, + ) } } @@ -674,15 +719,18 @@ pub fn knn_kmknn( options : KNNOptions, ) -> KNNResult { if n_query == 0 || index.n_points == 0 || options.k == 0 { - let actual_k = if options.k > index.n_points { index.n_points } else { options.k } - return KNNResult::{ - indices: [], - distances: [], - n_query, - k: actual_k, + let actual_k = if options.k > index.n_points { + index.n_points + } else { + options.k } + return KNNResult::{ indices: [], distances: [], n_query, k: actual_k } + } + let actual_k = if options.k > index.n_points { + index.n_points + } else { + options.k } - let actual_k = if options.k > index.n_points { index.n_points } else { options.k } let n_clusters = index.centroids.length() let all_indices : Array[Array[Int]] = [] let all_distances : Array[Array[Double]] = [] @@ -716,8 +764,15 @@ pub fn knn_kmknn( centroid_dists[c] = euclidean_distance(query, index.centroids[c]) } let sorted_centroid_indices = Array::make(n_clusters, 0) - for c = 0; c < n_clusters; c = c + 1 { sorted_centroid_indices[c] = c } - let (sorted_c_idx, _) = knn_quick_sort(centroid_dists, sorted_centroid_indices, 0, n_clusters - 1) + for c = 0; c < n_clusters; c = c + 1 { + sorted_centroid_indices[c] = c + } + let (sorted_c_idx, _) = knn_quick_sort( + centroid_dists, + sorted_centroid_indices, + 0, + n_clusters - 1, + ) let candidates : Array[Int] = [] let mut cluster_idx = 0 @@ -733,7 +788,10 @@ pub fn knn_kmknn( for i = 0; i < index.n_points; i = i + 1 { let mut found = false for c = 0; c < candidates.length(); c = c + 1 { - if candidates[c] == i { found = true; break } + if candidates[c] == i { + found = true + break + } } if !found { candidates.push(i) @@ -743,9 +801,18 @@ pub fn knn_kmknn( let cand_dists = Array::make(candidates.length(), 0.0) for i = 0; i < candidates.length(); i = i + 1 { - cand_dists[i] = knn_compute_distance(query, index.data[candidates[i]], options.distance) + cand_dists[i] = knn_compute_distance( + query, + index.data[candidates[i]], + options.distance, + ) } - let (sorted_idx, sorted_dist) = knn_quick_sort(cand_dists, candidates, 0, candidates.length() - 1) + let (sorted_idx, sorted_dist) = knn_quick_sort( + cand_dists, + candidates, + 0, + candidates.length() - 1, + ) let top_indices = Array::make(actual_k, 0) let top_distances = Array::make(actual_k, 0.0) @@ -757,7 +824,12 @@ pub fn knn_kmknn( all_distances.push(top_distances) } - KNNResult::{ indices: all_indices, distances: all_distances, n_query, k: actual_k } + KNNResult::{ + indices: all_indices, + distances: all_distances, + n_query, + k: actual_k, + } } ///| @@ -770,17 +842,24 @@ pub fn knn_annoy( options : KNNOptions, ) -> KNNResult { if n_query == 0 || index.n_points == 0 || options.k == 0 { - let actual_k = if options.k > index.n_points { index.n_points } else { options.k } - return KNNResult::{ - indices: [], - distances: [], - n_query, - k: actual_k, + let actual_k = if options.k > index.n_points { + index.n_points + } else { + options.k } + return KNNResult::{ indices: [], distances: [], n_query, k: actual_k } + } + let actual_k = if options.k > index.n_points { + index.n_points + } else { + options.k } - let actual_k = if options.k > index.n_points { index.n_points } else { options.k } let n_trees = options.n_trees - let nodes_per_tree = if n_trees > 0 { index.tree_nodes.length() / n_trees } else { 0 } + let nodes_per_tree = if n_trees > 0 { + index.tree_nodes.length() / n_trees + } else { + 0 + } let all_indices : Array[Array[Int]] = [] let all_distances : Array[Array[Double]] = [] @@ -822,7 +901,10 @@ pub fn knn_annoy( let point_idx = node.point_indices[pi] let mut already = false for c = 0; c < candidates.length(); c = c + 1 { - if candidates[c] == point_idx { already = true; break } + if candidates[c] == point_idx { + already = true + break + } } if !already { candidates.push(point_idx) @@ -879,9 +961,18 @@ pub fn knn_annoy( if candidates.length() > actual_k { let cand_dists = Array::make(candidates.length(), 0.0) for i = 0; i < candidates.length(); i = i + 1 { - cand_dists[i] = knn_compute_distance(query, index.data[candidates[i]], options.distance) + cand_dists[i] = knn_compute_distance( + query, + index.data[candidates[i]], + options.distance, + ) } - let (sorted_idx, sorted_dist) = knn_quick_sort(cand_dists, candidates, 0, candidates.length() - 1) + let (sorted_idx, sorted_dist) = knn_quick_sort( + cand_dists, + candidates, + 0, + candidates.length() - 1, + ) let top_indices = Array::make(actual_k, 0) let top_distances = Array::make(actual_k, 0.0) for i = 0; i < actual_k; i = i + 1 { @@ -893,9 +984,18 @@ pub fn knn_annoy( } else if candidates.length() > 0 { let cand_dists = Array::make(candidates.length(), 0.0) for i = 0; i < candidates.length(); i = i + 1 { - cand_dists[i] = knn_compute_distance(query, index.data[candidates[i]], options.distance) + cand_dists[i] = knn_compute_distance( + query, + index.data[candidates[i]], + options.distance, + ) } - let (sorted_idx, sorted_dist) = knn_quick_sort(cand_dists, candidates, 0, candidates.length() - 1) + let (sorted_idx, sorted_dist) = knn_quick_sort( + cand_dists, + candidates, + 0, + candidates.length() - 1, + ) let top_indices = Array::make(sorted_idx.length(), 0) let top_distances = Array::make(sorted_dist.length(), 0.0) for i = 0; i < sorted_idx.length(); i = i + 1 { @@ -910,5 +1010,10 @@ pub fn knn_annoy( } } - KNNResult::{ indices: all_indices, distances: all_distances, n_query, k: actual_k } -} \ No newline at end of file + KNNResult::{ + indices: all_indices, + distances: all_distances, + n_query, + k: actual_k, + } +} diff --git a/src/bioc_parallel.mbt b/src/bioc_parallel.mbt index d9704c60..d184e113 100644 --- a/src/bioc_parallel.mbt +++ b/src/bioc_parallel.mbt @@ -10,12 +10,21 @@ pub struct BPPARAM { } ///| -pub fn BPPARAM::new(workers : Int, progressbar : Bool, timeout : Int) -> BPPARAM { +pub fn BPPARAM::new( + workers : Int, + progressbar : Bool, + timeout : Int, +) -> BPPARAM { BPPARAM::{ workers, progressbar, timeout, log_file: "" } } ///| -pub fn BPPARAM::new_with_log(workers : Int, progressbar : Bool, timeout : Int, log_file : String) -> BPPARAM { +pub fn BPPARAM::new_with_log( + workers : Int, + progressbar : Bool, + timeout : Int, + log_file : String, +) -> BPPARAM { BPPARAM::{ workers, progressbar, timeout, log_file } } @@ -70,13 +79,13 @@ pub fn bp_add_task(job : BPJob, task : Task) -> BPJob { ///| pub fn bp_sum(data : Array[Array[Double]], params : BPPARAM) -> Double { let mut total = 0.0 - + let chunk_size = if data.length() % params.workers == 0 { data.length() / params.workers } else { data.length() / params.workers + 1 } - + let mut start = 0 while start < data.length() { let end = if start + chunk_size < data.length() { @@ -84,7 +93,7 @@ pub fn bp_sum(data : Array[Array[Double]], params : BPPARAM) -> Double { } else { data.length() } - + let mut i = start while i < end { let mut j = 0 @@ -94,10 +103,10 @@ pub fn bp_sum(data : Array[Array[Double]], params : BPPARAM) -> Double { } i = i + 1 } - + start = end } - + total } @@ -105,14 +114,18 @@ pub fn bp_sum(data : Array[Array[Double]], params : BPPARAM) -> Double { pub fn bp_mean(data : Array[Array[Double]], params : BPPARAM) -> Double { let total = bp_sum(data, params) let mut count = 0.0 - + let mut i = 0 while i < data.length() { count = count + data[i].length().to_double() i = i + 1 } - - if count > 0.0 { total / count } else { 0.0 } + + if count > 0.0 { + total / count + } else { + 0.0 + } } ///| @@ -123,14 +136,17 @@ pub fn bp_mean_simple(data : Array[Double], workers : Int) -> Double { } ///| -pub fn bp_colsum(data : Array[Array[Double]], params : BPPARAM) -> Array[Double] { +pub fn bp_colsum( + data : Array[Array[Double]], + params : BPPARAM, +) -> Array[Double] { if data.length() == 0 { return Array::new() } - + let col_count = data[0].length() let results : Array[Double] = Array::new() - + let mut j = 0 while j < col_count { let mut sum = 0.0 @@ -144,14 +160,17 @@ pub fn bp_colsum(data : Array[Array[Double]], params : BPPARAM) -> Array[Double] results.push(sum) j = j + 1 } - + results } ///| -pub fn bp_rowsum(data : Array[Array[Double]], params : BPPARAM) -> Array[Double] { +pub fn bp_rowsum( + data : Array[Array[Double]], + params : BPPARAM, +) -> Array[Double] { let results : Array[Double] = Array::new() - + let mut i = 0 while i < data.length() { let mut sum = 0.0 @@ -163,20 +182,23 @@ pub fn bp_rowsum(data : Array[Array[Double]], params : BPPARAM) -> Array[Double] results.push(sum) i = i + 1 } - + results } ///| -pub fn bp_parallelize(data : Array[Double], workers : Int) -> Array[Array[Double]] { +pub fn bp_parallelize( + data : Array[Double], + workers : Int, +) -> Array[Array[Double]] { let chunks : Array[Array[Double]] = Array::new() - + let chunk_size = if data.length() % workers == 0 { data.length() / workers } else { data.length() / workers + 1 } - + let mut start = 0 while start < data.length() { let chunk : Array[Double] = Array::new() @@ -185,24 +207,24 @@ pub fn bp_parallelize(data : Array[Double], workers : Int) -> Array[Array[Double } else { data.length() } - + let mut i = start while i < end { chunk.push(data[i]) i = i + 1 } - + chunks.push(chunk) start = end } - + chunks } ///| pub fn bp_run(job : BPJob) -> Array[BPResult] { let results : Array[BPResult] = Array::new() - + let mut i = 0 while i < job.tasks.length() { let task = job.tasks[i] @@ -215,30 +237,33 @@ pub fn bp_run(job : BPJob) -> Array[BPResult] { results.push(BPResult::success(sum, i % job.params.workers)) i = i + 1 } - + results } ///| -pub fn bp_map_sum(data : Array[Array[Double]], params : BPPARAM) -> Array[BPResult] { +pub fn bp_map_sum( + data : Array[Array[Double]], + params : BPPARAM, +) -> Array[BPResult] { let results : Array[BPResult] = Array::new() - + let chunk_size = if data.length() % params.workers == 0 { data.length() / params.workers } else { data.length() / params.workers + 1 } - + let mut worker_id = 0 let mut start = 0 - + while start < data.length() { let end = if start + chunk_size < data.length() { start + chunk_size } else { data.length() } - + let mut i = start while i < end { let mut sum = 0.0 @@ -250,34 +275,37 @@ pub fn bp_map_sum(data : Array[Array[Double]], params : BPPARAM) -> Array[BPResu results.push(BPResult::success(sum, worker_id)) i = i + 1 } - + worker_id = worker_id + 1 start = end } - + results } ///| -pub fn bp_map_mean(data : Array[Array[Double]], params : BPPARAM) -> Array[BPResult] { +pub fn bp_map_mean( + data : Array[Array[Double]], + params : BPPARAM, +) -> Array[BPResult] { let results : Array[BPResult] = Array::new() - + let chunk_size = if data.length() % params.workers == 0 { data.length() / params.workers } else { data.length() / params.workers + 1 } - + let mut worker_id = 0 let mut start = 0 - + while start < data.length() { let end = if start + chunk_size < data.length() { start + chunk_size } else { data.length() } - + let mut i = start while i < end { let mut sum = 0.0 @@ -286,15 +314,19 @@ pub fn bp_map_mean(data : Array[Array[Double]], params : BPPARAM) -> Array[BPRes sum = sum + data[i][j] j = j + 1 } - let mean = if data[i].length() > 0 { sum / data[i].length().to_double() } else { 0.0 } + let mean = if data[i].length() > 0 { + sum / data[i].length().to_double() + } else { + 0.0 + } results.push(BPResult::success(mean, worker_id)) i = i + 1 } - + worker_id = worker_id + 1 start = end } - + results } @@ -307,7 +339,7 @@ pub fn create_example_bpparam() -> BPPARAM { pub fn create_example_bpjob() -> BPJob { let params = BPPARAM::new(2, false, 120) let job = BPJob::new("example_job", params) - + let task1_data : Array[Double] = Array::new() task1_data.push(1.0) task1_data.push(2.0) @@ -315,7 +347,7 @@ pub fn create_example_bpjob() -> BPJob { task1_data.push(4.0) task1_data.push(5.0) job.tasks.push(Task::new("task1", task1_data, 1)) - + let task2_data : Array[Double] = Array::new() task2_data.push(6.0) task2_data.push(7.0) @@ -323,7 +355,7 @@ pub fn create_example_bpjob() -> BPJob { task2_data.push(9.0) task2_data.push(10.0) job.tasks.push(Task::new("task2", task2_data, 1)) - + let task3_data : Array[Double] = Array::new() task3_data.push(11.0) task3_data.push(12.0) @@ -331,7 +363,7 @@ pub fn create_example_bpjob() -> BPJob { task3_data.push(14.0) task3_data.push(15.0) job.tasks.push(Task::new("task3", task3_data, 2)) - + let task4_data : Array[Double] = Array::new() task4_data.push(16.0) task4_data.push(17.0) @@ -339,6 +371,6 @@ pub fn create_example_bpjob() -> BPJob { task4_data.push(19.0) task4_data.push(20.0) job.tasks.push(Task::new("task4", task4_data, 2)) - + job -} \ No newline at end of file +} diff --git a/src/bioc_singular.mbt b/src/bioc_singular.mbt index 62682826..719ec424 100644 --- a/src/bioc_singular.mbt +++ b/src/bioc_singular.mbt @@ -25,15 +25,21 @@ pub enum SVDMethod { ///| /// Create ExactSVD method variant. -pub fn exact_svd_method() -> SVDMethod { ExactSVD } +pub fn exact_svd_method() -> SVDMethod { + ExactSVD +} ///| /// Create IRLBA method variant. -pub fn irlba_method() -> SVDMethod { IRLBA } +pub fn irlba_method() -> SVDMethod { + IRLBA +} ///| /// Create Randomized method variant. -pub fn randomized_method() -> SVDMethod { Randomized } +pub fn randomized_method() -> SVDMethod { + Randomized +} ///| /// Options for SVD computation. @@ -558,13 +564,7 @@ pub fn svd_options_full( n_oversamples : Int, method : SVDMethod, ) -> SVDOptions { - SVDOptions::{ - method, - rank, - tol, - max_iter, - n_oversamples, - } + SVDOptions::{ method, rank, tol, max_iter, n_oversamples } } // ============================================================================ @@ -598,7 +598,9 @@ pub fn run_exact_svd( if ncol <= nrow { let ata = svd_ata(matrix, nrow, ncol) let (eigenvalues, eigenvectors) = eigh_symmetric(ata, ncol) - let (sorted_evals, sorted_evecs) = sort_eigen(eigenvalues, eigenvectors, ncol) + let (sorted_evals, sorted_evecs) = sort_eigen( + eigenvalues, eigenvectors, ncol, + ) let d = Array::make(effective_rank, 0.0) let v : Array[Array[Double]] = Array::new() @@ -634,7 +636,9 @@ pub fn run_exact_svd( } else { let aat = svd_aat(matrix, nrow, ncol) let (eigenvalues, eigenvectors) = eigh_symmetric(aat, nrow) - let (sorted_evals, sorted_evecs) = sort_eigen(eigenvalues, eigenvectors, nrow) + let (sorted_evals, sorted_evecs) = sort_eigen( + eigenvalues, eigenvectors, nrow, + ) let d = Array::make(effective_rank, 0.0) let u : Array[Array[Double]] = Array::new() @@ -706,11 +710,7 @@ fn svd_bidiagonal_small( let u : Array[Array[Double]] = Array::new() for i = 0; i < n; i = i + 1 { - let sigma = if sorted_evals[i] > 0.0 { - sorted_evals[i].sqrt() - } else { - 0.0 - } + let sigma = if sorted_evals[i] > 0.0 { sorted_evals[i].sqrt() } else { 0.0 } d[i] = sigma let v_col = Array::make(n, 0.0) @@ -818,7 +818,8 @@ pub fn run_irlba( for j = 0; j < l; j = j + 1 { let u_new = svd_mat_vec(matrix, nrow, ncol, v_prev) for k = 0; k < nrow; k = k + 1 { - u_new[k] = u_new[k] - beta_prev * u_vecs[if j > 0 { j - 1 } else { 0 }][k] + u_new[k] = u_new[k] - + beta_prev * u_vecs[if j > 0 { j - 1 } else { 0 }][k] } let mut alpha = 0.0 @@ -1092,15 +1093,9 @@ pub fn run_svd( options : SVDOptions, ) -> SVResult { match options.method { - ExactSVD => { - run_exact_svd(matrix, nrow, ncol, options.rank) - } - IRLBA => { - run_irlba(matrix, nrow, ncol, options.rank, options) - } - Randomized => { - run_randomized_svd(matrix, nrow, ncol, options.rank, options) - } + ExactSVD => run_exact_svd(matrix, nrow, ncol, options.rank) + IRLBA => run_irlba(matrix, nrow, ncol, options.rank, options) + Randomized => run_randomized_svd(matrix, nrow, ncol, options.rank, options) } } @@ -1159,10 +1154,7 @@ pub fn create_test_matrix() -> (Array[Double], Int, Int) { let nrow = 5 let ncol = 4 let data = [ - 1.0, 2.0, 3.0, 4.0, - 2.0, 3.0, 4.0, 5.0, - 3.0, 4.0, 5.0, 6.0, - 4.0, 5.0, 6.0, 7.0, + 1.0, 2.0, 3.0, 4.0, 2.0, 3.0, 4.0, 5.0, 3.0, 4.0, 5.0, 6.0, 4.0, 5.0, 6.0, 7.0, 5.0, 6.0, 7.0, 8.0, ] (data, nrow, ncol) @@ -1178,4 +1170,4 @@ pub fn run_svd_truncated( ) -> SVResult { let opts = svd_options_full(k, 1.0e-7, 1000, 10, ExactSVD) run_svd(matrix, nrow, ncol, opts) -} \ No newline at end of file +} diff --git a/src/biostrings.mbt b/src/biostrings.mbt index 2eb195cb..e22de889 100644 --- a/src/biostrings.mbt +++ b/src/biostrings.mbt @@ -703,7 +703,9 @@ pub fn MatchPatternResult::widths(self : MatchPatternResult) -> Array[Int] { ///| /// Get all mismatch counts. -pub fn MatchPatternResult::mismatch_counts(self : MatchPatternResult) -> Array[Int] { +pub fn MatchPatternResult::mismatch_counts( + self : MatchPatternResult, +) -> Array[Int] { self.hits.map(fn(h) { h.mismatches }) } @@ -723,7 +725,13 @@ pub fn match_pattern( let hits : Array[MatchHit] = Array::new() if n == 0 || m == 0 { - return MatchPatternResult::{ hits, pattern, subject, max_mismatches, with_indels } + return MatchPatternResult::{ + hits, + pattern, + subject, + max_mismatches, + with_indels, + } } let max_errors = if with_indels { max_mismatches } else { max_mismatches } @@ -772,7 +780,7 @@ pub fn vmatch_pattern( with_indels? : Bool = false, ) -> Array[MatchPatternResult] { subjects.map(fn(subj) { - match_pattern(pattern=pattern, subject=subj, max_mismatches=max_mismatches, with_indels=with_indels) + match_pattern(pattern~, subject=subj, max_mismatches~, with_indels~) }) } @@ -870,10 +878,7 @@ pub fn find_inverted_repeats( ///| /// Find all occurrences of a motif allowing IUPAC ambiguity codes. -pub fn find_motif_iupac( - pattern : String, - subject : String, -) -> Array[Int] { +pub fn find_motif_iupac(pattern : String, subject : String) -> Array[Int] { let n = pattern.length() let m = subject.length() let positions : Array[Int] = Array::new() @@ -967,7 +972,9 @@ pub fn letter_frequency_matrix(seq : String) -> Map[String, Array[Int]] { let matrix : Map[String, Array[Int]] = Map([], capacity=8) // Initialize for DNA alphabet - let bases = ["A", "C", "G", "T", "U", "N", "R", "Y", "S", "W", "K", "M", "B", "D", "H", "V"] + let bases = [ + "A", "C", "G", "T", "U", "N", "R", "Y", "S", "W", "K", "M", "B", "D", "H", "V", + ] for base in bases { matrix.set(base, Array::make(n, 0)) } @@ -1007,7 +1014,9 @@ pub fn letter_frequency_matrix(seq : String) -> Map[String, Array[Int]] { /// Compute consensus sequence from a multiple sequence alignment. /// Returns the most frequent nucleotide at each position. pub fn biostrings_consensus_sequence(alignment : Array[String]) -> String { - if alignment.length() == 0 { return "" } + if alignment.length() == 0 { + return "" + } let n_seqs = alignment.length() let seq_len = alignment[0].length() @@ -1048,24 +1057,75 @@ pub fn biostrings_translate(seq : String, frame? : Int = 0) -> String { let aa_count = (n - offset) / 3 let result : FixedArray[UInt16] = FixedArray::make(aa_count, 0) - let codon_table : Map[String, UInt16] = Map([ - ("TTT", 70), ("TTC", 70), ("TTA", 76), ("TTG", 76), - ("CTT", 76), ("CTC", 76), ("CTA", 76), ("CTG", 76), - ("ATT", 73), ("ATC", 73), ("ATA", 73), ("ATG", 77), - ("GTT", 86), ("GTC", 86), ("GTA", 86), ("GTG", 86), - ("TCT", 83), ("TCC", 83), ("TCA", 83), ("TCG", 83), - ("CCT", 80), ("CCC", 80), ("CCA", 80), ("CCG", 80), - ("ACT", 65), ("ACC", 65), ("ACA", 65), ("ACG", 65), - ("GCT", 65), ("GCC", 65), ("GCA", 65), ("GCG", 65), - ("TAT", 89), ("TAC", 89), ("TAA", 42), ("TAG", 42), - ("CAT", 72), ("CAC", 72), ("CAA", 81), ("CAG", 81), - ("AAT", 78), ("AAC", 78), ("AAA", 75), ("AAG", 75), - ("GAT", 68), ("GAC", 68), ("GAA", 69), ("GAG", 69), - ("TGT", 67), ("TGC", 67), ("TGA", 42), ("TGG", 87), - ("CGT", 82), ("CGC", 82), ("CGA", 82), ("CGG", 82), - ("AGT", 83), ("AGC", 83), ("AGA", 82), ("AGG", 82), - ("GGT", 71), ("GGC", 71), ("GGA", 71), ("GGG", 71), - ], capacity=64) + let codon_table : Map[String, UInt16] = Map( + [ + ("TTT", 70), + ("TTC", 70), + ("TTA", 76), + ("TTG", 76), + ("CTT", 76), + ("CTC", 76), + ("CTA", 76), + ("CTG", 76), + ("ATT", 73), + ("ATC", 73), + ("ATA", 73), + ("ATG", 77), + ("GTT", 86), + ("GTC", 86), + ("GTA", 86), + ("GTG", 86), + ("TCT", 83), + ("TCC", 83), + ("TCA", 83), + ("TCG", 83), + ("CCT", 80), + ("CCC", 80), + ("CCA", 80), + ("CCG", 80), + ("ACT", 65), + ("ACC", 65), + ("ACA", 65), + ("ACG", 65), + ("GCT", 65), + ("GCC", 65), + ("GCA", 65), + ("GCG", 65), + ("TAT", 89), + ("TAC", 89), + ("TAA", 42), + ("TAG", 42), + ("CAT", 72), + ("CAC", 72), + ("CAA", 81), + ("CAG", 81), + ("AAT", 78), + ("AAC", 78), + ("AAA", 75), + ("AAG", 75), + ("GAT", 68), + ("GAC", 68), + ("GAA", 69), + ("GAG", 69), + ("TGT", 67), + ("TGC", 67), + ("TGA", 42), + ("TGG", 87), + ("CGT", 82), + ("CGC", 82), + ("CGA", 82), + ("CGG", 82), + ("AGT", 83), + ("AGC", 83), + ("AGA", 82), + ("AGG", 82), + ("GGT", 71), + ("GGC", 71), + ("GGA", 71), + ("GGG", 71), + ], + capacity=64, + ) let mut i = offset let mut out_idx = 0 @@ -1160,7 +1220,11 @@ pub fn expected_matches( // Expected number: (seq_length - pattern_length + 1) * probability let n_positions = (seq_length - n + 1).to_double() - if prob.is_nan() || prob < 0.0 { 0.0 } else { n_positions * prob } + if prob.is_nan() || prob < 0.0 { + 0.0 + } else { + n_positions * prob + } } ///| @@ -1203,7 +1267,8 @@ pub fn sequence_complexity(seq : String, word_size : Int) -> Double { entropy } -///| Test match_pattern with exact matching +///| +/// Test match_pattern with exact matching test "match_pattern_exact" { let result = match_pattern(pattern="ATG", subject="ATGATGATG") assert_eq(result.hits.length(), 3) @@ -1212,29 +1277,38 @@ test "match_pattern_exact" { assert_eq(result.hits[0].mismatches, 0) } -///| Test match_pattern with mismatches +///| +/// Test match_pattern with mismatches test "match_pattern_mismatch" { let result = match_pattern(pattern="ATG", subject="AAGATG", max_mismatches=1) assert_true(result.hits.length() >= 1) } -///| Test match_pattern with indels +///| +/// Test match_pattern with indels test "match_pattern_indels" { - let result = match_pattern(pattern="ATG", subject="ATGC", max_mismatches=1, with_indels=true) + let result = match_pattern( + pattern="ATG", + subject="ATGC", + max_mismatches=1, + with_indels=true, + ) assert_true(result.hits.length() >= 1) } -///| Test vmatch_pattern +///| +/// Test vmatch_pattern test "vmatch_pattern" { let subjects = ["ATGATG", "ATGCAT", "CCCCCC"] - let result = vmatch_pattern(pattern="ATG", subjects=subjects) + let result = vmatch_pattern(pattern="ATG", subjects~) assert_eq(result.length(), 3) assert_eq(result[0].hits.length(), 2) assert_eq(result[1].hits.length(), 1) assert_eq(result[2].hits.length(), 0) } -///| Test find_palindromes +///| +/// Test find_palindromes test "find_palindromes" { let result = find_palindromes(seq="ATAT", min_length=4) assert_eq(result.length(), 1) @@ -1242,76 +1316,93 @@ test "find_palindromes" { assert_eq(result[0].1, 4) } -///| Test find_palindromes_empty +///| +/// Test find_palindromes_empty test "find_palindromes_empty" { let result = find_palindromes(seq="ATGC", min_length=4) assert_eq(result.length(), 0) } -///| Test find_direct_repeats +///| +/// Test find_direct_repeats test "find_direct_repeats" { - let result = find_direct_repeats(seq="ATGATGATG", min_unit_length=3, max_unit_length=3, min_copies=2) + let result = find_direct_repeats( + seq="ATGATGATG", + min_unit_length=3, + max_unit_length=3, + min_copies=2, + ) assert_true(result.length() >= 1) } -///| Test find_inverted_repeats +///| +/// Test find_inverted_repeats test "find_inverted_repeats" { let result = find_inverted_repeats(seq="ATGCAT", min_length=3) assert_true(result.length() >= 0) } -///| Test biostrings_translate with standard genetic code +///| +/// Test biostrings_translate with standard genetic code test "biostrings_translate_basic" { // ATG = M, GCT = A, TAA = * let protein = biostrings_translate("ATGGCTTAA") assert_eq(protein, "MA*") } -///| Test biostrings_translate with different reading frame +///| +/// Test biostrings_translate with different reading frame test "biostrings_translate_frame1" { // Frame 1: TGG = W, CTT = L let protein = biostrings_translate("ATGGCTTAA", frame=1) assert_eq(protein, "WL") } -///| Test biostrings_translate with lowercase input +///| +/// Test biostrings_translate with lowercase input test "biostrings_translate_lowercase" { let protein = biostrings_translate("atggcttaa") assert_eq(protein, "MA*") } -///| Test biostrings_translate empty sequence +///| +/// Test biostrings_translate empty sequence test "biostrings_translate_empty" { let protein = biostrings_translate("") assert_eq(protein, "") } -///| Test biostrings_reverse_complement basic +///| +/// Test biostrings_reverse_complement basic test "biostrings_reverse_complement_basic" { let rc = biostrings_reverse_complement("ATGC") assert_eq(rc, "GCAT") } -///| Test biostrings_reverse_complement with IUPAC +///| +/// Test biostrings_reverse_complement with IUPAC test "biostrings_reverse_complement_iupac" { let rc = biostrings_reverse_complement("AR") assert_eq(rc, "YT") } -///| Test biostrings_reverse_complement with empty string +///| +/// Test biostrings_reverse_complement with empty string test "biostrings_reverse_complement_empty" { let rc = biostrings_reverse_complement("") assert_eq(rc, "") } -///| Test biostrings_reverse_complement palindrome +///| +/// Test biostrings_reverse_complement palindrome test "biostrings_reverse_complement_palindrome" { // ACGT's reverse complement is also ACGT let rc = biostrings_reverse_complement("ACGT") assert_eq(rc, "ACGT") } -///| Test letter_frequency_matrix basic +///| +/// Test letter_frequency_matrix basic test "letter_frequency_matrix_basic" { let matrix = letter_frequency_matrix("ACGT") let a_counts = matrix.get_or_default("A", Array::make(4, 0)) @@ -1324,7 +1415,8 @@ test "letter_frequency_matrix_basic" { assert_eq(t_counts[3], 1) } -///| Test biostrings_consensus_sequence +///| +/// Test biostrings_consensus_sequence test "biostrings_consensus_sequence_basic" { let alignment = ["ACGT", "ACGT", "TCGA"] let consensus = biostrings_consensus_sequence(alignment) @@ -1335,26 +1427,30 @@ test "biostrings_consensus_sequence_basic" { assert_eq(consensus, "ACGT") } -///| Test biostrings_consensus_sequence empty +///| +/// Test biostrings_consensus_sequence empty test "biostrings_consensus_sequence_empty" { let alignment : Array[String] = [] let consensus = biostrings_consensus_sequence(alignment) assert_eq(consensus, "") } -///| Test expected_matches +///| +/// Test expected_matches test "expected_matches_basic" { let n = expected_matches("ACGT", 12, 0.5) assert_true(n > 0.0) } -///| Test sequence_complexity +///| +/// Test sequence_complexity test "sequence_complexity_basic" { let entropy = sequence_complexity("ACGTACGTACGT", 2) assert_true(entropy > 0.0) } -///| Test sequence_complexity with degenerate sequence +///| +/// Test sequence_complexity with degenerate sequence test "sequence_complexity_degenerate" { let entropy = sequence_complexity("AAAA", 2) assert_true(entropy >= 0.0) diff --git a/src/biostrings_matchdict.mbt b/src/biostrings_matchdict.mbt index 828235f6..fa3dfeb2 100644 --- a/src/biostrings_matchdict.mbt +++ b/src/biostrings_matchdict.mbt @@ -60,11 +60,7 @@ pub fn bmd_create_pdict( max_mismatches? : Int = 0, with_indels? : Bool = false, ) -> PDict { - PDict::{ - patterns, - max_mismatches, - with_indels, - } + PDict::{ patterns, max_mismatches, with_indels } } ///| @@ -80,11 +76,7 @@ pub fn bmd_match_pdict(pdict~ : PDict, subject~ : String) -> MatchPDictResult { let hits : Array[MatchPDictHit] = Array::new() if subject.length() == 0 || pdict.patterns.length() == 0 { - return MatchPDictResult::{ - hits, - pdict, - subject_length: subject.length(), - } + return MatchPDictResult::{ hits, pdict, subject_length: subject.length() } } let mut p_idx = 0 @@ -129,11 +121,7 @@ pub fn bmd_match_pdict(pdict~ : PDict, subject~ : String) -> MatchPDictResult { p_idx = p_idx + 1 } - MatchPDictResult::{ - hits, - pdict, - subject_length: subject.length(), - } + MatchPDictResult::{ hits, pdict, subject_length: subject.length() } } ///| @@ -161,11 +149,7 @@ pub fn bmd_vcount_pattern( counts.push(0) i = i + 1 } - return CountPatternResult::{ - pattern, - counts, - total: 0, - } + return CountPatternResult::{ pattern, counts, total: 0 } } let mut i = 0 @@ -203,11 +187,7 @@ pub fn bmd_vcount_pattern( i = i + 1 } - CountPatternResult::{ - pattern, - counts, - total, - } + CountPatternResult::{ pattern, counts, total } } ///| @@ -231,8 +211,8 @@ pub fn bmd_vmatch_pattern( while i < patterns.length() { let result = bmd_vcount_pattern( pattern=patterns[i], - subjects=subjects, - max_mismatches=max_mismatches, + subjects~, + max_mismatches~, ) results.push(result) i = i + 1 @@ -303,7 +283,7 @@ pub fn bmd_which(pdict~ : PDict, subjects~ : Array[String]) -> Array[Bool] { /// @param subjects Array of subject sequences to test. /// @return An array of Int indices indicating matching subjects. pub fn bmd_which_index(pdict~ : PDict, subjects~ : Array[String]) -> Array[Int] { - let which_result = bmd_which(pdict=pdict, subjects=subjects) + let which_result = bmd_which(pdict~, subjects~) let indices : Array[Int] = Array::new() let mut i = 0 @@ -327,7 +307,7 @@ pub fn bmd_which_index(pdict~ : PDict, subjects~ : Array[String]) -> Array[Int] /// @param subject The subject sequence string to search. /// @return Total number of pattern occurrences found. pub fn bmd_count_occurrences(pdict~ : PDict, subject~ : String) -> Int { - let result = bmd_match_pdict(pdict=pdict, subject=subject) + let result = bmd_match_pdict(pdict~, subject~) result.hits.length() } @@ -341,7 +321,7 @@ pub fn bmd_count_occurrences(pdict~ : PDict, subject~ : String) -> Int { /// @param subject The subject sequence string to search. /// @return The best MatchPDictHit, or None if no matches found. pub fn bmd_find_best_match(pdict~ : PDict, subject~ : String) -> MatchPDictHit? { - let result = bmd_match_pdict(pdict=pdict, subject=subject) + let result = bmd_match_pdict(pdict~, subject~) if result.hits.length() == 0 { return None @@ -389,7 +369,11 @@ test "bmd_create_pdict_empty" { ///| test "bmd_create_pdict_with_indels" { - let pdict = bmd_create_pdict(patterns=["ATG"], max_mismatches=1, with_indels=true) + let pdict = bmd_create_pdict( + patterns=["ATG"], + max_mismatches=1, + with_indels=true, + ) assert_eq(pdict.with_indels, true) assert_eq(pdict.max_mismatches, 1) } @@ -397,7 +381,7 @@ test "bmd_create_pdict_with_indels" { ///| test "bmd_match_pdict_single_pattern" { let pdict = bmd_create_pdict(patterns=["ATG"]) - let result = bmd_match_pdict(pdict=pdict, subject="AATGCTAG") + let result = bmd_match_pdict(pdict~, subject="AATGCTAG") assert_eq(result.hits.length(), 1) assert_eq(result.hits[0].pattern, "ATG") assert_eq(result.hits[0].start, 2) @@ -408,7 +392,7 @@ test "bmd_match_pdict_single_pattern" { ///| test "bmd_match_pdict_multiple_patterns" { let pdict = bmd_create_pdict(patterns=["ATG", "GCT"]) - let result = bmd_match_pdict(pdict=pdict, subject="ATGGCT") + let result = bmd_match_pdict(pdict~, subject="ATGGCT") assert_eq(result.hits.length(), 2) assert_eq(result.hits[0].pattern, "ATG") assert_eq(result.hits[1].pattern, "GCT") @@ -417,21 +401,21 @@ test "bmd_match_pdict_multiple_patterns" { ///| test "bmd_match_pdict_overlapping_hits" { let pdict = bmd_create_pdict(patterns=["AAA"]) - let result = bmd_match_pdict(pdict=pdict, subject="AAAA") + let result = bmd_match_pdict(pdict~, subject="AAAA") assert_eq(result.hits.length(), 2) } ///| test "bmd_match_pdict_no_match" { let pdict = bmd_create_pdict(patterns=["XYZ"]) - let result = bmd_match_pdict(pdict=pdict, subject="ATGC") + let result = bmd_match_pdict(pdict~, subject="ATGC") assert_eq(result.hits.length(), 0) } ///| test "bmd_match_pdict_empty_subject" { let pdict = bmd_create_pdict(patterns=["ATG"]) - let result = bmd_match_pdict(pdict=pdict, subject="") + let result = bmd_match_pdict(pdict~, subject="") assert_eq(result.hits.length(), 0) assert_eq(result.subject_length, 0) } @@ -439,14 +423,14 @@ test "bmd_match_pdict_empty_subject" { ///| test "bmd_match_pdict_empty_patterns" { let pdict = bmd_create_pdict(patterns=[]) - let result = bmd_match_pdict(pdict=pdict, subject="ATGC") + let result = bmd_match_pdict(pdict~, subject="ATGC") assert_eq(result.hits.length(), 0) } ///| test "bmd_match_pdict_with_mismatches" { let pdict = bmd_create_pdict(patterns=["ATG"], max_mismatches=1) - let result = bmd_match_pdict(pdict=pdict, subject="AXG") + let result = bmd_match_pdict(pdict~, subject="AXG") assert_eq(result.hits.length(), 1) assert_eq(result.hits[0].mismatches, 1) } @@ -454,21 +438,21 @@ test "bmd_match_pdict_with_mismatches" { ///| test "bmd_match_pdict_mismatch_too_many" { let pdict = bmd_create_pdict(patterns=["ATG"], max_mismatches=1) - let result = bmd_match_pdict(pdict=pdict, subject="XYZ") + let result = bmd_match_pdict(pdict~, subject="XYZ") assert_eq(result.hits.length(), 0) } ///| test "bmd_match_pdict_pattern_longer_than_subject" { let pdict = bmd_create_pdict(patterns=["ATGCT"]) - let result = bmd_match_pdict(pdict=pdict, subject="AT") + let result = bmd_match_pdict(pdict~, subject="AT") assert_eq(result.hits.length(), 0) } ///| test "bmd_vcount_pattern_basic" { let subjects = ["ATGATG", "ATGCAT", "CCCCCC"] - let result = bmd_vcount_pattern(pattern="ATG", subjects=subjects) + let result = bmd_vcount_pattern(pattern="ATG", subjects~) assert_eq(result.pattern, "ATG") assert_eq(result.counts.length(), 3) assert_eq(result.counts[0], 2) @@ -480,7 +464,7 @@ test "bmd_vcount_pattern_basic" { ///| test "bmd_vcount_pattern_no_match" { let subjects = ["CCCC", "GGGG", "TTTT"] - let result = bmd_vcount_pattern(pattern="AAAA", subjects=subjects) + let result = bmd_vcount_pattern(pattern="AAAA", subjects~) assert_eq(result.total, 0) assert_eq(result.counts[0], 0) assert_eq(result.counts[1], 0) @@ -490,7 +474,7 @@ test "bmd_vcount_pattern_no_match" { ///| test "bmd_vcount_pattern_with_mismatches" { let subjects = ["AXG", "AYG", "AZG", "ATG"] - let result = bmd_vcount_pattern(pattern="ATG", subjects=subjects, max_mismatches=1) + let result = bmd_vcount_pattern(pattern="ATG", subjects~, max_mismatches=1) assert_eq(result.counts[0], 1) assert_eq(result.counts[1], 1) assert_eq(result.counts[2], 1) @@ -501,7 +485,7 @@ test "bmd_vcount_pattern_with_mismatches" { ///| test "bmd_vcount_pattern_empty_pattern" { let subjects = ["ATGC", "GCAT"] - let result = bmd_vcount_pattern(pattern="", subjects=subjects) + let result = bmd_vcount_pattern(pattern="", subjects~) assert_eq(result.total, 0) assert_eq(result.counts.length(), 2) } @@ -509,7 +493,7 @@ test "bmd_vcount_pattern_empty_pattern" { ///| test "bmd_vcount_pattern_empty_subjects" { let subjects : Array[String] = [] - let result = bmd_vcount_pattern(pattern="ATG", subjects=subjects) + let result = bmd_vcount_pattern(pattern="ATG", subjects~) assert_eq(result.total, 0) assert_eq(result.counts.length(), 0) } @@ -518,7 +502,7 @@ test "bmd_vcount_pattern_empty_subjects" { test "bmd_vmatch_pattern_basic" { let patterns = ["ATG", "CCC"] let subjects = ["ATGATG", "CCCCCC"] - let results = bmd_vmatch_pattern(patterns=patterns, subjects=subjects) + let results = bmd_vmatch_pattern(patterns~, subjects~) assert_eq(results.length(), 2) assert_eq(results[0].pattern, "ATG") assert_eq(results[0].total, 2) @@ -530,7 +514,7 @@ test "bmd_vmatch_pattern_basic" { test "bmd_vmatch_pattern_multiple_subjects" { let patterns = ["ATG"] let subjects = ["ATGATG", "ATXATG", "TTTTTT"] - let results = bmd_vmatch_pattern(patterns=patterns, subjects=subjects) + let results = bmd_vmatch_pattern(patterns~, subjects~) assert_eq(results.length(), 1) assert_eq(results[0].counts[0], 2) assert_eq(results[0].counts[2], 0) @@ -546,7 +530,7 @@ test "bmd_vmatch_pattern_empty" { test "bmd_which_basic" { let pdict = bmd_create_pdict(patterns=["ATG"]) let subjects = ["ATGCTA", "TTTTTT", "ATGCAT"] - let result = bmd_which(pdict=pdict, subjects=subjects) + let result = bmd_which(pdict~, subjects~) assert_eq(result.length(), 3) assert_eq(result[0], true) assert_eq(result[1], false) @@ -557,7 +541,7 @@ test "bmd_which_basic" { test "bmd_which_no_match" { let pdict = bmd_create_pdict(patterns=["ZZZZZ"]) let subjects = ["ATGC", "GCAT"] - let result = bmd_which(pdict=pdict, subjects=subjects) + let result = bmd_which(pdict~, subjects~) assert_eq(result[0], false) assert_eq(result[1], false) } @@ -566,7 +550,7 @@ test "bmd_which_no_match" { test "bmd_which_empty_pdict" { let pdict = bmd_create_pdict(patterns=[]) let subjects = ["ATGC", "GCAT"] - let result = bmd_which(pdict=pdict, subjects=subjects) + let result = bmd_which(pdict~, subjects~) assert_eq(result[0], false) assert_eq(result[1], false) } @@ -575,7 +559,7 @@ test "bmd_which_empty_pdict" { test "bmd_which_index_basic" { let pdict = bmd_create_pdict(patterns=["ATG"]) let subjects = ["TTTT", "ATGC", "GGGG", "ATGG"] - let indices = bmd_which_index(pdict=pdict, subjects=subjects) + let indices = bmd_which_index(pdict~, subjects~) assert_eq(indices.length(), 2) assert_eq(indices[0], 1) assert_eq(indices[1], 3) @@ -585,42 +569,42 @@ test "bmd_which_index_basic" { test "bmd_which_index_no_match" { let pdict = bmd_create_pdict(patterns=["ZZZZ"]) let subjects = ["ATGC", "GCAT"] - let indices = bmd_which_index(pdict=pdict, subjects=subjects) + let indices = bmd_which_index(pdict~, subjects~) assert_eq(indices.length(), 0) } ///| test "bmd_count_occurrences_basic" { let pdict = bmd_create_pdict(patterns=["ATG"]) - let count = bmd_count_occurrences(pdict=pdict, subject="ATGATGATG") + let count = bmd_count_occurrences(pdict~, subject="ATGATGATG") assert_eq(count, 3) } ///| test "bmd_count_occurrences_multiple_patterns" { let pdict = bmd_create_pdict(patterns=["AT", "TG"]) - let count = bmd_count_occurrences(pdict=pdict, subject="ATGATG") + let count = bmd_count_occurrences(pdict~, subject="ATGATG") assert_eq(count, 4) } ///| test "bmd_count_occurrences_no_match" { let pdict = bmd_create_pdict(patterns=["ZZZZ"]) - let count = bmd_count_occurrences(pdict=pdict, subject="ATGC") + let count = bmd_count_occurrences(pdict~, subject="ATGC") assert_eq(count, 0) } ///| test "bmd_count_occurrences_empty" { let pdict = bmd_create_pdict(patterns=[""]) - let count = bmd_count_occurrences(pdict=pdict, subject="ATGC") + let count = bmd_count_occurrences(pdict~, subject="ATGC") assert_eq(count, 0) } ///| test "bmd_find_best_match_exact" { let pdict = bmd_create_pdict(patterns=["ATG"]) - let best = bmd_find_best_match(pdict=pdict, subject="AATGCT") + let best = bmd_find_best_match(pdict~, subject="AATGCT") assert_true(best is Some(_)) assert_eq(best.unwrap().pattern, "ATG") assert_eq(best.unwrap().start, 2) @@ -629,7 +613,7 @@ test "bmd_find_best_match_exact" { ///| test "bmd_find_best_match_with_mismatches" { let pdict = bmd_create_pdict(patterns=["ATG", "AXG", "AYG"], max_mismatches=1) - let best = bmd_find_best_match(pdict=pdict, subject="AAAG") + let best = bmd_find_best_match(pdict~, subject="AAAG") assert_true(best is Some(_)) assert_eq(best.unwrap().mismatches, 1) assert_eq(best.unwrap().pattern, "ATG") @@ -638,14 +622,14 @@ test "bmd_find_best_match_with_mismatches" { ///| test "bmd_find_best_match_no_hit" { let pdict = bmd_create_pdict(patterns=["ZZZZZ"]) - let best = bmd_find_best_match(pdict=pdict, subject="ATGC") + let best = bmd_find_best_match(pdict~, subject="ATGC") assert_true(best is None) } ///| test "bmd_find_best_match_multiple_hits" { let pdict = bmd_create_pdict(patterns=["ATG"], max_mismatches=2) - let best = bmd_find_best_match(pdict=pdict, subject="AATGCTXG") + let best = bmd_find_best_match(pdict~, subject="AATGCTXG") assert_true(best is Some(_)) assert_eq(best.unwrap().pattern, "ATG") assert_eq(best.unwrap().mismatches, 0) @@ -655,7 +639,7 @@ test "bmd_find_best_match_multiple_hits" { test "bmd_which_with_mismatches" { let pdict = bmd_create_pdict(patterns=["ATG"], max_mismatches=1) let subjects = ["AXGCTA", "TTTTTT", "AYGCAT"] - let result = bmd_which(pdict=pdict, subjects=subjects) + let result = bmd_which(pdict~, subjects~) assert_eq(result[0], true) assert_eq(result[1], false) assert_eq(result[2], true) @@ -664,7 +648,7 @@ test "bmd_which_with_mismatches" { ///| test "bmd_vcount_pattern_single_subject" { let subjects = ["AAAA"] - let result = bmd_vcount_pattern(pattern="AA", subjects=subjects) + let result = bmd_vcount_pattern(pattern="AA", subjects~) assert_eq(result.counts.length(), 1) assert_eq(result.counts[0], 3) assert_eq(result.total, 3) @@ -673,7 +657,7 @@ test "bmd_vcount_pattern_single_subject" { ///| test "bmd_match_pdict_hit_properties" { let pdict = bmd_create_pdict(patterns=["ATG", "TGC"]) - let result = bmd_match_pdict(pdict=pdict, subject="ATGC") + let result = bmd_match_pdict(pdict~, subject="ATGC") assert_eq(result.hits.length(), 2) assert_eq(result.hits[0].pattern_idx, 0) assert_eq(result.hits[0].width, 3) @@ -686,7 +670,7 @@ test "bmd_match_pdict_hit_properties" { ///| test "bmd_count_occurrences_overlapping" { let pdict = bmd_create_pdict(patterns=["AA"]) - let count = bmd_count_occurrences(pdict=pdict, subject="AAAA") + let count = bmd_count_occurrences(pdict~, subject="AAAA") assert_eq(count, 3) } @@ -694,7 +678,7 @@ test "bmd_count_occurrences_overlapping" { test "bmd_vmatch_pattern_multiple_mismatches" { let patterns = ["ATG", "CCC"] let subjects = ["AXGATG", "CXCCCX"] - let results = bmd_vmatch_pattern(patterns=patterns, subjects=subjects, max_mismatches=1) + let results = bmd_vmatch_pattern(patterns~, subjects~, max_mismatches=1) assert_eq(results.length(), 2) assert_eq(results[0].counts[0], 2) assert_eq(results[1].counts[1], 4) diff --git a/src/blast_applications.mbt b/src/blast_applications.mbt index b67b476c..920cfad1 100644 --- a/src/blast_applications.mbt +++ b/src/blast_applications.mbt @@ -23,7 +23,13 @@ pub struct BlastParamSpec { ///| /// Create a parameter specification. -pub fn BlastParamSpec::new(name : String, description : String, takes_value : Bool, default_value : String, required : Bool) -> BlastParamSpec { +pub fn BlastParamSpec::new( + name : String, + description : String, + takes_value : Bool, + default_value : String, + required : Bool, +) -> BlastParamSpec { BlastParamSpec::{ name, description, takes_value, default_value, required } } @@ -32,25 +38,45 @@ pub fn BlastParamSpec::new(name : String, description : String, takes_value : Bo fn blastapp_common_params() -> Array[BlastParamSpec] { [ BlastParamSpec::new("-query", "Query sequence file", true, "", false), - BlastParamSpec::new("-query_loc", "Query location (start-stop)", true, "", false), + BlastParamSpec::new( + "-query_loc", "Query location (start-stop)", true, "", false, + ), BlastParamSpec::new("-db", "BLAST database name", true, "", false), BlastParamSpec::new("-out", "Output file name", true, "", false), - BlastParamSpec::new("-evalue", "Expectation value threshold", true, "10.0", false), - BlastParamSpec::new("-word_size", "Word size for initial match", true, "0", false), + BlastParamSpec::new( + "-evalue", "Expectation value threshold", true, "10.0", false, + ), + BlastParamSpec::new( + "-word_size", "Word size for initial match", true, "0", false, + ), BlastParamSpec::new("-gapopen", "Cost to open a gap", true, "0", false), BlastParamSpec::new("-gapextend", "Cost to extend a gap", true, "0", false), BlastParamSpec::new("-matrix", "Scoring matrix", true, "", false), BlastParamSpec::new("-threshold", "Minimum word score", true, "0", false), - BlastParamSpec::new("-comp_based_stats", "Composition-based stats", true, "0", false), - BlastParamSpec::new("-num_descriptions", "Number of descriptions", true, "500", false), - BlastParamSpec::new("-num_alignments", "Number of alignments", true, "250", false), - BlastParamSpec::new("-num_threads", "Number of CPU threads", true, "1", false), - BlastParamSpec::new("-max_target_seqs", "Max target sequences", true, "500", false), + BlastParamSpec::new( + "-comp_based_stats", "Composition-based stats", true, "0", false, + ), + BlastParamSpec::new( + "-num_descriptions", "Number of descriptions", true, "500", false, + ), + BlastParamSpec::new( + "-num_alignments", "Number of alignments", true, "250", false, + ), + BlastParamSpec::new( + "-num_threads", "Number of CPU threads", true, "1", false, + ), + BlastParamSpec::new( + "-max_target_seqs", "Max target sequences", true, "500", false, + ), BlastParamSpec::new("-dust", "DUST filter setting", true, "", false), BlastParamSpec::new("-seg", "SEG filter setting", true, "", false), BlastParamSpec::new("-soft_masking", "Soft masking", true, "false", false), - BlastParamSpec::new("-lcase_masking", "Use lowercase masking", false, "", false), - BlastParamSpec::new("-show_gis", "Show NCBI GIs in output", false, "", false), + BlastParamSpec::new( + "-lcase_masking", "Use lowercase masking", false, "", false, + ), + BlastParamSpec::new( + "-show_gis", "Show NCBI GIs in output", false, "", false, + ), BlastParamSpec::new("-html", "Produce HTML output", false, "", false), ] } @@ -61,7 +87,9 @@ fn blastapp_output_params() -> Array[BlastParamSpec] { [ BlastParamSpec::new("-outfmt", "Output format (0-18)", true, "0", false), BlastParamSpec::new("-max_hsps", "Max HSPs per subject", true, "0", false), - BlastParamSpec::new("-max_intron_length", "Max intron length", true, "0", false), + BlastParamSpec::new( + "-max_intron_length", "Max intron length", true, "0", false, + ), ] } @@ -82,18 +110,25 @@ pub struct BlastCommandline { ///| /// Create a new BLAST commandline wrapper. -pub fn BlastCommandline::new(executable : String, param_specs : Array[BlastParamSpec]) -> BlastCommandline { +pub fn BlastCommandline::new( + executable : String, + param_specs : Array[BlastParamSpec], +) -> BlastCommandline { BlastCommandline::{ executable, parameters: Map([], capacity=32), flags: Map([], capacity=16), - param_specs + param_specs, } } ///| /// Set a parameter value. -pub fn BlastCommandline::blastapp_set_parameter(self : BlastCommandline, name : String, value : String) -> BlastCommandline { +pub fn BlastCommandline::blastapp_set_parameter( + self : BlastCommandline, + name : String, + value : String, +) -> BlastCommandline { let new_params = Map([], capacity=32) let keys = self.parameters.keys().collect() let mut i = 0 @@ -106,13 +141,17 @@ pub fn BlastCommandline::blastapp_set_parameter(self : BlastCommandline, name : executable: self.executable, parameters: new_params, flags: self.flags, - param_specs: self.param_specs + param_specs: self.param_specs, } } ///| /// Set a flag (boolean parameter). -pub fn BlastCommandline::blastapp_set_flag(self : BlastCommandline, name : String, on : Bool) -> BlastCommandline { +pub fn BlastCommandline::blastapp_set_flag( + self : BlastCommandline, + name : String, + on : Bool, +) -> BlastCommandline { let new_flags = Map([], capacity=16) let keys = self.flags.keys().collect() let mut i = 0 @@ -125,25 +164,33 @@ pub fn BlastCommandline::blastapp_set_flag(self : BlastCommandline, name : Strin executable: self.executable, parameters: self.parameters, flags: new_flags, - param_specs: self.param_specs + param_specs: self.param_specs, } } ///| /// Get a parameter value (returns Option). -pub fn BlastCommandline::blastapp_get_parameter(self : BlastCommandline, name : String) -> String? { +pub fn BlastCommandline::blastapp_get_parameter( + self : BlastCommandline, + name : String, +) -> String? { self.parameters.get(name) } ///| /// Get a flag value (returns Option). -pub fn BlastCommandline::blastapp_get_flag(self : BlastCommandline, name : String) -> Bool? { +pub fn BlastCommandline::blastapp_get_flag( + self : BlastCommandline, + name : String, +) -> Bool? { self.flags.get(name) } ///| /// Build the full command-line string. -pub fn BlastCommandline::blastapp_build_command(self : BlastCommandline) -> String { +pub fn BlastCommandline::blastapp_build_command( + self : BlastCommandline, +) -> String { let mut cmd = self.executable // Add value parameters let keys = self.parameters.keys().collect() @@ -166,7 +213,9 @@ pub fn BlastCommandline::blastapp_build_command(self : BlastCommandline) -> Stri ///| /// Validate that all required parameters are set. -pub fn BlastCommandline::blastapp_validate(self : BlastCommandline) -> Array[String] { +pub fn BlastCommandline::blastapp_validate( + self : BlastCommandline, +) -> Array[String] { let errors : Array[String] = Array::new() let mut i = 0 while i < self.param_specs.length() { @@ -184,7 +233,9 @@ pub fn BlastCommandline::blastapp_validate(self : BlastCommandline) -> Array[Str ///| /// List all available parameter specifications. -pub fn BlastCommandline::blastapp_available_params(self : BlastCommandline) -> Array[BlastParamSpec] { +pub fn BlastCommandline::blastapp_available_params( + self : BlastCommandline, +) -> Array[BlastParamSpec] { self.param_specs.copy() } @@ -201,9 +252,15 @@ pub fn ncbi_blastp_commandline() -> BlastCommandline { i = i + 1 } // blastp-specific params - specs.push(BlastParamSpec::new("-remote", "Execute search remotely", false, "", false)) - specs.push(BlastParamSpec::new("-subject", "Subject sequence file", true, "", false)) - specs.push(BlastParamSpec::new("-subject_loc", "Subject location", true, "", false)) + specs.push( + BlastParamSpec::new("-remote", "Execute search remotely", false, "", false), + ) + specs.push( + BlastParamSpec::new("-subject", "Subject sequence file", true, "", false), + ) + specs.push( + BlastParamSpec::new("-subject_loc", "Subject location", true, "", false), + ) BlastCommandline::new("blastp", specs) } @@ -218,11 +275,26 @@ pub fn ncbi_blastn_commandline() -> BlastCommandline { i = i + 1 } // blastn-specific params - specs.push(BlastParamSpec::new("-strand", "Query strand (both/minus/plus)", true, "both", false)) - specs.push(BlastParamSpec::new("-task", "Task (blastn/blastn-short/dc-megablast/etc.)", true, "megablast", false)) - specs.push(BlastParamSpec::new("-remote", "Execute search remotely", false, "", false)) - specs.push(BlastParamSpec::new("-subject", "Subject sequence file", true, "", false)) - specs.push(BlastParamSpec::new("-subject_loc", "Subject location", true, "", false)) + specs.push( + BlastParamSpec::new( + "-strand", "Query strand (both/minus/plus)", true, "both", false, + ), + ) + specs.push( + BlastParamSpec::new( + "-task", "Task (blastn/blastn-short/dc-megablast/etc.)", true, "megablast", + false, + ), + ) + specs.push( + BlastParamSpec::new("-remote", "Execute search remotely", false, "", false), + ) + specs.push( + BlastParamSpec::new("-subject", "Subject sequence file", true, "", false), + ) + specs.push( + BlastParamSpec::new("-subject_loc", "Subject location", true, "", false), + ) BlastCommandline::new("blastn", specs) } @@ -236,12 +308,30 @@ pub fn ncbi_blastx_commandline() -> BlastCommandline { specs.push(out_specs[i]) i = i + 1 } - specs.push(BlastParamSpec::new("-strand", "Query strand (both/minus/plus)", true, "both", false)) - specs.push(BlastParamSpec::new("-query_gencode", "Query genetic code", true, "1", false)) - specs.push(BlastParamSpec::new("-max_intron_length", "Max intron length", true, "0", false)) - specs.push(BlastParamSpec::new("-remote", "Execute search remotely", false, "", false)) - specs.push(BlastParamSpec::new("-subject", "Subject sequence file", true, "", false)) - specs.push(BlastParamSpec::new("-subject_loc", "Subject location", true, "", false)) + specs.push( + BlastParamSpec::new( + "-strand", "Query strand (both/minus/plus)", true, "both", false, + ), + ) + specs.push( + BlastParamSpec::new( + "-query_gencode", "Query genetic code", true, "1", false, + ), + ) + specs.push( + BlastParamSpec::new( + "-max_intron_length", "Max intron length", true, "0", false, + ), + ) + specs.push( + BlastParamSpec::new("-remote", "Execute search remotely", false, "", false), + ) + specs.push( + BlastParamSpec::new("-subject", "Subject sequence file", true, "", false), + ) + specs.push( + BlastParamSpec::new("-subject_loc", "Subject location", true, "", false), + ) BlastCommandline::new("blastx", specs) } @@ -255,11 +345,25 @@ pub fn ncbi_tblastn_commandline() -> BlastCommandline { specs.push(out_specs[i]) i = i + 1 } - specs.push(BlastParamSpec::new("-db_gencode", "Database genetic code", true, "1", false)) - specs.push(BlastParamSpec::new("-frame_shift_penalty", "Frame shift penalty", true, "0", false)) - specs.push(BlastParamSpec::new("-remote", "Execute search remotely", false, "", false)) - specs.push(BlastParamSpec::new("-subject", "Subject sequence file", true, "", false)) - specs.push(BlastParamSpec::new("-subject_loc", "Subject location", true, "", false)) + specs.push( + BlastParamSpec::new( + "-db_gencode", "Database genetic code", true, "1", false, + ), + ) + specs.push( + BlastParamSpec::new( + "-frame_shift_penalty", "Frame shift penalty", true, "0", false, + ), + ) + specs.push( + BlastParamSpec::new("-remote", "Execute search remotely", false, "", false), + ) + specs.push( + BlastParamSpec::new("-subject", "Subject sequence file", true, "", false), + ) + specs.push( + BlastParamSpec::new("-subject_loc", "Subject location", true, "", false), + ) BlastCommandline::new("tblastn", specs) } @@ -273,12 +377,30 @@ pub fn ncbi_tblastx_commandline() -> BlastCommandline { specs.push(out_specs[i]) i = i + 1 } - specs.push(BlastParamSpec::new("-strand", "Query strand (both/minus/plus)", true, "both", false)) - specs.push(BlastParamSpec::new("-query_gencode", "Query genetic code", true, "1", false)) - specs.push(BlastParamSpec::new("-db_gencode", "Database genetic code", true, "1", false)) - specs.push(BlastParamSpec::new("-remote", "Execute search remotely", false, "", false)) - specs.push(BlastParamSpec::new("-subject", "Subject sequence file", true, "", false)) - specs.push(BlastParamSpec::new("-subject_loc", "Subject location", true, "", false)) + specs.push( + BlastParamSpec::new( + "-strand", "Query strand (both/minus/plus)", true, "both", false, + ), + ) + specs.push( + BlastParamSpec::new( + "-query_gencode", "Query genetic code", true, "1", false, + ), + ) + specs.push( + BlastParamSpec::new( + "-db_gencode", "Database genetic code", true, "1", false, + ), + ) + specs.push( + BlastParamSpec::new("-remote", "Execute search remotely", false, "", false), + ) + specs.push( + BlastParamSpec::new("-subject", "Subject sequence file", true, "", false), + ) + specs.push( + BlastParamSpec::new("-subject_loc", "Subject location", true, "", false), + ) BlastCommandline::new("tblastx", specs) } @@ -292,15 +414,44 @@ pub fn ncbi_psiblast_commandline() -> BlastCommandline { specs.push(out_specs[i]) i = i + 1 } - specs.push(BlastParamSpec::new("-num_iterations", "Number of iterations", true, "1", false)) - specs.push(BlastParamSpec::new("-in_pssm", "Input PSSM file", true, "", false)) - specs.push(BlastParamSpec::new("-out_pssm", "Output PSSM file", true, "", false)) - specs.push(BlastParamSpec::new("-out_ascii_pssm", "Output ASCII PSSM file", true, "", false)) - specs.push(BlastParamSpec::new("-save_pssm_after_last_round", "Save PSSM after last iteration", false, "", false)) - specs.push(BlastParamSpec::new("-save_each_pssm", "Save PSSM after each iteration", false, "", false)) - specs.push(BlastParamSpec::new("-pseudocount", "Pseudocount", true, "0", false)) - specs.push(BlastParamSpec::new("-inclusion_ethresh", "Inclusion e-value threshold", true, "0.002", false)) - specs.push(BlastParamSpec::new("-remote", "Execute search remotely", false, "", false)) + specs.push( + BlastParamSpec::new( + "-num_iterations", "Number of iterations", true, "1", false, + ), + ) + specs.push( + BlastParamSpec::new("-in_pssm", "Input PSSM file", true, "", false), + ) + specs.push( + BlastParamSpec::new("-out_pssm", "Output PSSM file", true, "", false), + ) + specs.push( + BlastParamSpec::new( + "-out_ascii_pssm", "Output ASCII PSSM file", true, "", false, + ), + ) + specs.push( + BlastParamSpec::new( + "-save_pssm_after_last_round", "Save PSSM after last iteration", false, "", + false, + ), + ) + specs.push( + BlastParamSpec::new( + "-save_each_pssm", "Save PSSM after each iteration", false, "", false, + ), + ) + specs.push( + BlastParamSpec::new("-pseudocount", "Pseudocount", true, "0", false), + ) + specs.push( + BlastParamSpec::new( + "-inclusion_ethresh", "Inclusion e-value threshold", true, "0.002", false, + ), + ) + specs.push( + BlastParamSpec::new("-remote", "Execute search remotely", false, "", false), + ) BlastCommandline::new("psiblast", specs) } @@ -308,9 +459,15 @@ pub fn ncbi_psiblast_commandline() -> BlastCommandline { /// NCBI rpsblast command line (reverse position-specific BLAST). pub fn ncbi_rpsblast_commandline() -> BlastCommandline { let specs = blastapp_common_params() - specs.push(BlastParamSpec::new("-outfmt", "Output format (0-18)", true, "0", false)) - specs.push(BlastParamSpec::new("-max_hsps", "Max HSPs per subject", true, "0", false)) - specs.push(BlastParamSpec::new("-remote", "Execute search remotely", false, "", false)) + specs.push( + BlastParamSpec::new("-outfmt", "Output format (0-18)", true, "0", false), + ) + specs.push( + BlastParamSpec::new("-max_hsps", "Max HSPs per subject", true, "0", false), + ) + specs.push( + BlastParamSpec::new("-remote", "Execute search remotely", false, "", false), + ) BlastCommandline::new("rpsblast", specs) } @@ -319,21 +476,34 @@ pub fn ncbi_rpsblast_commandline() -> BlastCommandline { pub fn ncbi_makeblastdb_commandline() -> BlastCommandline { let specs : Array[BlastParamSpec] = [ BlastParamSpec::new("-in", "Input FASTA file", true, "", false), - BlastParamSpec::new("-input_type", "Input file type (fasta/asn1_bin/asn1_txt)", true, "fasta", false), - BlastParamSpec::new("-dbtype", "Database type (nucl/prot)", true, "nucl", false), + BlastParamSpec::new( + "-input_type", "Input file type (fasta/asn1_bin/asn1_txt)", true, "fasta", + false, + ), + BlastParamSpec::new( + "-dbtype", "Database type (nucl/prot)", true, "nucl", false, + ), BlastParamSpec::new("-title", "Database title", true, "", false), BlastParamSpec::new("-parse_seqids", "Parse sequence IDs", false, "", false), BlastParamSpec::new("-hash_index", "Create hash index", false, "", false), - BlastParamSpec::new("-mask_data", "Masking algorithm data file", true, "", false), + BlastParamSpec::new( + "-mask_data", "Masking algorithm data file", true, "", false, + ), BlastParamSpec::new("-mask_algo", "Masking algorithm ID", true, "", false), BlastParamSpec::new("-gilist", "GI list file", true, "", false), BlastParamSpec::new("-seqidlist", "Sequence ID list file", true, "", false), - BlastParamSpec::new("-negative_gilist", "Negative GI list file", true, "", false), + BlastParamSpec::new( + "-negative_gilist", "Negative GI list file", true, "", false, + ), BlastParamSpec::new("-taxid", "Taxonomy ID", true, "", false), BlastParamSpec::new("-taxid_map", "Taxonomy ID map file", true, "", false), BlastParamSpec::new("-out", "Output database name", true, "", false), - BlastParamSpec::new("-blastdb_version", "BLAST database version (4 or 5)", true, "5", false), - BlastParamSpec::new("-max_file_sz", "Maximum file size", true, "1000000000", false), + BlastParamSpec::new( + "-blastdb_version", "BLAST database version (4 or 5)", true, "5", false, + ), + BlastParamSpec::new( + "-max_file_sz", "Maximum file size", true, "1000000000", false, + ), ] BlastCommandline::new("makeblastdb", specs) } @@ -342,47 +512,67 @@ pub fn ncbi_makeblastdb_commandline() -> BlastCommandline { ///| /// Build a typical blastp query against a local database. -pub fn blastapp_quick_blastp(query_file : String, db_name : String, evalue : String) -> BlastCommandline { +pub fn blastapp_quick_blastp( + query_file : String, + db_name : String, + evalue : String, +) -> BlastCommandline { ncbi_blastp_commandline() - .blastapp_set_parameter("-query", query_file) - .blastapp_set_parameter("-db", db_name) - .blastapp_set_parameter("-evalue", evalue) + .blastapp_set_parameter("-query", query_file) + .blastapp_set_parameter("-db", db_name) + .blastapp_set_parameter("-evalue", evalue) } ///| /// Build a typical blastn query against a local database. -pub fn blastapp_quick_blastn(query_file : String, db_name : String, evalue : String) -> BlastCommandline { +pub fn blastapp_quick_blastn( + query_file : String, + db_name : String, + evalue : String, +) -> BlastCommandline { ncbi_blastn_commandline() - .blastapp_set_parameter("-query", query_file) - .blastapp_set_parameter("-db", db_name) - .blastapp_set_parameter("-evalue", evalue) + .blastapp_set_parameter("-query", query_file) + .blastapp_set_parameter("-db", db_name) + .blastapp_set_parameter("-evalue", evalue) } ///| /// Build a typical blastx query against a local protein database. -pub fn blastapp_quick_blastx(query_file : String, db_name : String, evalue : String) -> BlastCommandline { +pub fn blastapp_quick_blastx( + query_file : String, + db_name : String, + evalue : String, +) -> BlastCommandline { ncbi_blastx_commandline() - .blastapp_set_parameter("-query", query_file) - .blastapp_set_parameter("-db", db_name) - .blastapp_set_parameter("-evalue", evalue) + .blastapp_set_parameter("-query", query_file) + .blastapp_set_parameter("-db", db_name) + .blastapp_set_parameter("-evalue", evalue) } ///| /// Build a typical tblastn query against a local nucleotide database. -pub fn blastapp_quick_tblastn(query_file : String, db_name : String, evalue : String) -> BlastCommandline { +pub fn blastapp_quick_tblastn( + query_file : String, + db_name : String, + evalue : String, +) -> BlastCommandline { ncbi_tblastn_commandline() - .blastapp_set_parameter("-query", query_file) - .blastapp_set_parameter("-db", db_name) - .blastapp_set_parameter("-evalue", evalue) + .blastapp_set_parameter("-query", query_file) + .blastapp_set_parameter("-db", db_name) + .blastapp_set_parameter("-evalue", evalue) } ///| /// Build a makeblastdb command for a given input file. -pub fn blastapp_quick_makeblastdb(input_file : String, dbtype : String, db_title : String) -> BlastCommandline { +pub fn blastapp_quick_makeblastdb( + input_file : String, + dbtype : String, + db_title : String, +) -> BlastCommandline { ncbi_makeblastdb_commandline() - .blastapp_set_parameter("-in", input_file) - .blastapp_set_parameter("-dbtype", dbtype) - .blastapp_set_parameter("-title", db_title) + .blastapp_set_parameter("-in", input_file) + .blastapp_set_parameter("-dbtype", dbtype) + .blastapp_set_parameter("-title", db_title) } // ===== Example data generators ===== @@ -391,37 +581,37 @@ pub fn blastapp_quick_makeblastdb(input_file : String, dbtype : String, db_title /// Create a sample blastp commandline for demonstration. pub fn blastapp_create_example_blastp() -> BlastCommandline { ncbi_blastp_commandline() - .blastapp_set_parameter("-query", "query.fasta") - .blastapp_set_parameter("-db", "nr") - .blastapp_set_parameter("-evalue", "0.001") - .blastapp_set_parameter("-out", "results.txt") - .blastapp_set_parameter("-outfmt", "7") - .blastapp_set_parameter("-num_threads", "4") - .blastapp_set_parameter("-max_target_seqs", "10") - .blastapp_set_flag("-show_gis", true) + .blastapp_set_parameter("-query", "query.fasta") + .blastapp_set_parameter("-db", "nr") + .blastapp_set_parameter("-evalue", "0.001") + .blastapp_set_parameter("-out", "results.txt") + .blastapp_set_parameter("-outfmt", "7") + .blastapp_set_parameter("-num_threads", "4") + .blastapp_set_parameter("-max_target_seqs", "10") + .blastapp_set_flag("-show_gis", true) } ///| /// Create a sample blastn commandline for demonstration. pub fn blastapp_create_example_blastn() -> BlastCommandline { ncbi_blastn_commandline() - .blastapp_set_parameter("-query", "gene.fasta") - .blastapp_set_parameter("-db", "nt") - .blastapp_set_parameter("-evalue", "1e-50") - .blastapp_set_parameter("-task", "megablast") - .blastapp_set_parameter("-out", "blastn_results.xml") - .blastapp_set_parameter("-outfmt", "5") - .blastapp_set_parameter("-num_descriptions", "100") - .blastapp_set_flag("-html", false) + .blastapp_set_parameter("-query", "gene.fasta") + .blastapp_set_parameter("-db", "nt") + .blastapp_set_parameter("-evalue", "1e-50") + .blastapp_set_parameter("-task", "megablast") + .blastapp_set_parameter("-out", "blastn_results.xml") + .blastapp_set_parameter("-outfmt", "5") + .blastapp_set_parameter("-num_descriptions", "100") + .blastapp_set_flag("-html", false) } ///| /// Create a sample makeblastdb commandline for demonstration. pub fn blastapp_create_example_makeblastdb() -> BlastCommandline { ncbi_makeblastdb_commandline() - .blastapp_set_parameter("-in", "genome.fa") - .blastapp_set_parameter("-dbtype", "nucl") - .blastapp_set_parameter("-title", "ExampleGenome") - .blastapp_set_flag("-parse_seqids", true) - .blastapp_set_flag("-hash_index", true) + .blastapp_set_parameter("-in", "genome.fa") + .blastapp_set_parameter("-dbtype", "nucl") + .blastapp_set_parameter("-title", "ExampleGenome") + .blastapp_set_flag("-parse_seqids", true) + .blastapp_set_flag("-hash_index", true) } diff --git a/src/bumphunter.mbt b/src/bumphunter.mbt index add02597..2ddae5b9 100644 --- a/src/bumphunter.mbt +++ b/src/bumphunter.mbt @@ -159,17 +159,7 @@ pub fn BumpResult::new( index_start : Int, index_end : Int, ) -> BumpResult { - { - chrom, - start, - end_, - value, - area, - p_value, - fdr, - index_start, - index_end, - } + { chrom, start, end_, value, area, p_value, fdr, index_start, index_end } } ///| @@ -278,7 +268,7 @@ pub fn bump_smooth_test(stats : Array[Double], k : Int) -> Array[Double] { let hi = if i + k >= n { n - 1 } else { i + k } let mut sum = 0.0 let mut cnt = 0 - for j in lo..=hi { + for j in lo..<=hi { sum = sum + stats[j] cnt = cnt + 1 } @@ -309,8 +299,8 @@ pub fn bump_find_candidates_test( let mut area = 0.0 let mut signed_max = smoothed[i] while i < n && - bump_abs(smoothed[i]) > cutoff && - positions[i].chrom == chrom { + bump_abs(smoothed[i]) > cutoff && + positions[i].chrom == chrom { area = area + smoothed[i] if bump_abs(smoothed[i]) > max_val { max_val = bump_abs(smoothed[i]) @@ -383,7 +373,9 @@ fn bump_permutation_count( shuffled_vals[j] = shuffled_vals[swap_idx] shuffled_vals[swap_idx] = tmp } - shuffled.push(BumpPosition::new(positions[i].chrom, positions[i].pos, shuffled_vals)) + shuffled.push( + BumpPosition::new(positions[i].chrom, positions[i].pos, shuffled_vals), + ) } let perm_stats = bump_compute_t_statistics_test(shuffled, group1_size) let perm_smoothed = bump_smooth_test(perm_stats, k) @@ -435,12 +427,7 @@ pub fn bump_hunt( for p in 0.. Array[BumpPosition] { /// Format a BumpResult as a readable string. pub fn BumpResult::to_string(self : BumpResult) -> String { let sign = if self.value >= 0.0 { "+" } else { "-" } - "chr=" + self.chrom + " start=" + self.start.to_string() + " end=" + self.end_.to_string() + " value=" + sign + bump_abs(self.value).to_string() + " p=" + self.p_value.to_string() + " fdr=" + self.fdr.to_string() + "chr=" + + self.chrom + + " start=" + + self.start.to_string() + + " end=" + + self.end_.to_string() + + " value=" + + sign + + bump_abs(self.value).to_string() + + " p=" + + self.p_value.to_string() + + " fdr=" + + self.fdr.to_string() } ///| /// Format all results as a table. pub fn bump_results_to_string(results : Array[BumpResult]) -> String { - let mut s = "Bumphunter Results (" + results.length().to_string() + " bumps)\n" + let mut s = "Bumphunter Results (" + + results.length().to_string() + + " bumps)\n" s = s + "chrom\tstart\tend\tvalue\tp_value\tfdr\n" for r in results { - s = s + r.chrom + "\t" + r.start.to_string() + "\t" + r.end_.to_string() + "\t" + r.value.to_string() + "\t" + r.p_value.to_string() + "\t" + r.fdr.to_string() + "\n" + s = s + + r.chrom + + "\t" + + r.start.to_string() + + "\t" + + r.end_.to_string() + + "\t" + + r.value.to_string() + + "\t" + + r.p_value.to_string() + + "\t" + + r.fdr.to_string() + + "\n" } s } diff --git a/src/caps.mbt b/src/caps.mbt index a7ffb5f0..be5f49cf 100644 --- a/src/caps.mbt +++ b/src/caps.mbt @@ -133,12 +133,7 @@ pub fn caps_map( // Validate equal lengths let n = sequences.length() if n == 0 { - return { - sequences, - sequence_names: [], - enzymes, - dcuts: [], - } + return { sequences, sequence_names: [], enzymes, dcuts: [] } } let expected_len = sequences[0].length() let names : Array[String] = [] @@ -375,7 +370,7 @@ pub fn caps_sample_sequences() -> Array[String] { // seq1 has GAATTT (not cut by EcoRI) [ "AAAAAAAAGAGAATTCAAAAAAAAAAAAAA", // has GAATTC at pos 10 - "AAAAAAAAGAGAATTTAAAAAAAAAAAAAA", // has GAATTT at pos 10 (no cut) + "AAAAAAAAGAGAATTTAAAAAAAAAAAAAA", // has GAATTT at pos 10 (no cut) ] } diff --git a/src/cellchat.mbt b/src/cellchat.mbt index 9d66ec56..bec037bc 100644 --- a/src/cellchat.mbt +++ b/src/cellchat.mbt @@ -46,11 +46,7 @@ pub struct CellChatResult { ///| /// Create a ligand-receptor pair. pub fn lr_pair(ligand : String, receptor : String) -> LRPair { - LRPair::{ - ligand: ligand, - receptor: receptor, - key: ligand + "_" + receptor, - } + LRPair::{ ligand, receptor, key: ligand + "_" + receptor } } ///| @@ -110,7 +106,11 @@ pub fn cellchat_mean_expr( } i = i + 1 } - if count > 0 { sum / count.to_double() } else { 0.0 } + if count > 0 { + sum / count.to_double() + } else { + 0.0 + } } ///| @@ -143,10 +143,15 @@ pub fn cellchat_analyze( let mut found = false let mut j = 0 while j < unique_ct.length() { - if unique_ct[j] == ct { found = true; break } + if unique_ct[j] == ct { + found = true + break + } j = j + 1 } - if !found { unique_ct.push(ct) } + if !found { + unique_ct.push(ct) + } i = i + 1 } @@ -219,8 +224,12 @@ pub fn cellchat_analyze( let tgt_ct = unique_ct[tgt] // Observed score - let mean_lig = cellchat_mean_expr(expression, cell_types, src_ct, lig_idx) - let mean_rec = cellchat_mean_expr(expression, cell_types, tgt_ct, rec_idx) + let mean_lig = cellchat_mean_expr( + expression, cell_types, src_ct, lig_idx, + ) + let mean_rec = cellchat_mean_expr( + expression, cell_types, tgt_ct, rec_idx, + ) let obs_score = mean_lig * mean_rec // Permutation null distribution @@ -228,8 +237,12 @@ pub fn cellchat_analyze( let mut pm = 0 while pm < n_perm { let perm_labels = permuted_labels_list[pm] - let perm_lig = cellchat_mean_expr(expression, perm_labels, src_ct, lig_idx) - let perm_rec = cellchat_mean_expr(expression, perm_labels, tgt_ct, rec_idx) + let perm_lig = cellchat_mean_expr( + expression, perm_labels, src_ct, lig_idx, + ) + let perm_rec = cellchat_mean_expr( + expression, perm_labels, tgt_ct, rec_idx, + ) let perm_score = perm_lig * perm_rec perm_scores.push(perm_score) pm = pm + 1 @@ -258,7 +271,9 @@ pub fn cellchat_analyze( let mut n_ge = 0 pm = 0 while pm < n_perm { - if perm_scores[pm] >= obs_score { n_ge = n_ge + 1 } + if perm_scores[pm] >= obs_score { + n_ge = n_ge + 1 + } pm = pm + 1 } let p_val = (n_ge + 1).to_double() / (n_perm + 1).to_double() @@ -274,11 +289,11 @@ pub fn cellchat_analyze( source_celltype: src_ct, target_celltype: tgt_ct, score: obs_score, - perm_mean: perm_mean, - perm_std: perm_std, + perm_mean, + perm_std, p_value: p_val, p_adj: p_adj_raw, - significant: significant, + significant, }) } tgt = tgt + 1 @@ -289,8 +304,8 @@ pub fn cellchat_analyze( } CellChatResult::{ - scores: scores, - lr_pairs: lr_pairs, + scores, + lr_pairs, cell_types: unique_ct, n_permutations: n_perm, seed: seed_val, @@ -300,7 +315,9 @@ pub fn cellchat_analyze( ///| /// Get significant interactions from a CellChatResult. -pub fn cellchat_get_significant(result : CellChatResult) -> Array[InteractionScore] { +pub fn cellchat_get_significant( + result : CellChatResult, +) -> Array[InteractionScore] { let sig : Array[InteractionScore] = [] let mut i = 0 while i < result.scores.length() { @@ -338,10 +355,17 @@ pub fn cellchat_aggregate(result : CellChatResult) -> Map[String, Double] { ///| /// Generate sample single-cell expression data for CellChat testing. /// Returns (expression, cell_types, gene_names) with 3 cell types and known LR pairs. -pub fn cellchat_sample_data() -> (Array[Array[Double]], Array[String], Array[String]) { +pub fn cellchat_sample_data() -> ( + Array[Array[Double]], + Array[String], + Array[String], +) { let n_cells = 30 // Express 10 genes: TNF, TNFR1, IL6, IL6R, VEGFA, VEGFR1, TGFB1, TGFBR1, CXCL12, CXCR4 - let gene_names = ["TNF", "TNFR1", "IL6", "IL6R", "VEGFA", "VEGFR1", "TGFB1", "TGFBR1", "CXCL12", "CXCR4"] + let gene_names = [ + "TNF", "TNFR1", "IL6", "IL6R", "VEGFA", "VEGFR1", "TGFB1", "TGFBR1", "CXCL12", + "CXCR4", + ] let cell_types : Array[String] = [] // 10 cells per cell type let types = ["TypeA", "TypeB", "TypeC"] @@ -359,13 +383,23 @@ pub fn cellchat_sample_data() -> (Array[Array[Double]], Array[String], Array[Str let mut gi = 0 while gi < gene_names.length() { let base = if ct == "TypeA" { - if gene_names[gi] == "TNF" || gene_names[gi] == "IL6" { 15.0 } else { 2.0 } + if gene_names[gi] == "TNF" || gene_names[gi] == "IL6" { + 15.0 + } else { + 2.0 + } } else if ct == "TypeB" { - if gene_names[gi] == "TNFR1" || gene_names[gi] == "IL6R" { 12.0 } else { 2.5 } + if gene_names[gi] == "TNFR1" || gene_names[gi] == "IL6R" { + 12.0 + } else { + 2.5 + } + } else if gene_names[gi] == "VEGFA" || gene_names[gi] == "TGFB1" { + 18.0 } else { - if gene_names[gi] == "VEGFA" || gene_names[gi] == "TGFB1" { 18.0 } else { 3.0 } + 3.0 } - let noise = (((ci * 7 + gi * 11) % 100).to_double() / 100.0) * base * 0.4 + let noise = ((ci * 7 + gi * 11) % 100).to_double() / 100.0 * base * 0.4 row.push(base + noise) gi = gi + 1 } @@ -381,20 +415,36 @@ pub fn cellchat_summary(result : CellChatResult) -> String { let mut n_sig = 0 let mut i = 0 while i < result.scores.length() { - if result.scores[i].significant { n_sig = n_sig + 1 } + if result.scores[i].significant { + n_sig = n_sig + 1 + } i = i + 1 } "CellChat Analysis Summary:\n" + - " Cell types: " + result.cell_types.length().to_string() + "\n" + - " LR pairs tested: " + result.lr_pairs.length().to_string() + "\n" + - " Total interactions: " + result.scores.length().to_string() + "\n" + - " Significant (FDR<" + result.fdr.to_string() + "): " + n_sig.to_string() + "\n" + - " Permutations: " + result.n_permutations.to_string() + " Cell types: " + + result.cell_types.length().to_string() + + "\n" + + " LR pairs tested: " + + result.lr_pairs.length().to_string() + + "\n" + + " Total interactions: " + + result.scores.length().to_string() + + "\n" + + " Significant (FDR<" + + result.fdr.to_string() + + "): " + + n_sig.to_string() + + "\n" + + " Permutations: " + + result.n_permutations.to_string() } ///| /// Get the top interactions by score. -pub fn cellchat_get_top(result : CellChatResult, n : Int) -> Array[InteractionScore] { +pub fn cellchat_get_top( + result : CellChatResult, + n : Int, +) -> Array[InteractionScore] { let all = result.scores // Sort by score descending let mut i = 0 diff --git a/src/chain_liftover.mbt b/src/chain_liftover.mbt index cd5065ae..c3f4ef4e 100644 --- a/src/chain_liftover.mbt +++ b/src/chain_liftover.mbt @@ -195,7 +195,7 @@ pub fn cl_liftover_range( } match (mapped_start, mapped_end) { - (Some(ms), Some(me)) => { + (Some(ms), Some(me)) => if ch.q_strand == "-" { let qs = ch.q_size - me let qe = ch.q_size - ms @@ -204,14 +204,11 @@ pub fn cl_liftover_range( } else { Some((qe, qs)) } + } else if ms < me { + Some((ms, me)) } else { - if ms < me { - Some((ms, me)) - } else { - Some((me, ms)) - } + Some((me, ms)) } - } _ => None } } @@ -313,11 +310,7 @@ fn cl_split_lines(s : String) -> Array[String] { let mut i = 0 while i < s.length() { if s.unsafe_get(i).to_int() == '\n'.to_int() { - let line = if start < i { - s[start:i].to_owned() - } else { - "" - } + let line = if start < i { s[start:i].to_owned() } else { "" } result.push(line) start = i + 1 } @@ -423,16 +416,36 @@ fn cl_parse_chain_header( let score = if fields.length() > 1 { cl_parse_int_safe(fields[1]) } else { 0 } let t_name = if fields.length() > 2 { fields[2] } else { "" } - let t_size = if fields.length() > 3 { cl_parse_int_safe(fields[3]) } else { 0 } + let t_size = if fields.length() > 3 { + cl_parse_int_safe(fields[3]) + } else { + 0 + } let t_strand = if fields.length() > 4 { fields[4] } else { "+" } let t_plus = t_strand == "+" - let t_start = if fields.length() > 5 { cl_parse_int_safe(fields[5]) } else { 0 } + let t_start = if fields.length() > 5 { + cl_parse_int_safe(fields[5]) + } else { + 0 + } let t_end = if fields.length() > 6 { cl_parse_int_safe(fields[6]) } else { 0 } let q_name = if fields.length() > 7 { fields[7] } else { "" } - let q_size = if fields.length() > 8 { cl_parse_int_safe(fields[8]) } else { 0 } + let q_size = if fields.length() > 8 { + cl_parse_int_safe(fields[8]) + } else { + 0 + } let q_strand = if fields.length() > 9 { fields[9] } else { "+" } - let q_start = if fields.length() > 10 { cl_parse_int_safe(fields[10]) } else { 0 } - let q_end = if fields.length() > 11 { cl_parse_int_safe(fields[11]) } else { 0 } + let q_start = if fields.length() > 10 { + cl_parse_int_safe(fields[10]) + } else { + 0 + } + let q_end = if fields.length() > 11 { + cl_parse_int_safe(fields[11]) + } else { + 0 + } let id = if fields.length() > 12 { cl_parse_int_safe(fields[12]) } else { 0 } let header = ChainHeader::{ @@ -593,8 +606,7 @@ test "cl_parse_chain_single_header" { ///| test "cl_parse_chain_with_blocks" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 400 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 400 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments.length(), 1) assert_eq(cf.alignments[0].blocks.length(), 2) @@ -608,8 +620,7 @@ test "cl_parse_chain_with_blocks" { ///| test "cl_parse_chain_multiple_records" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 300 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 300 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments.length(), 2) assert_eq(cf.alignments[0].id, 5) @@ -620,8 +631,7 @@ test "cl_parse_chain_multiple_records" { ///| test "cl_parse_chain_multiple_blocks" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 300 5 15\n 200 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 300 5 15\n 200 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments[0].blocks.length(), 3) assert_eq(cf.alignments[0].blocks[0].size, 500) @@ -631,8 +641,7 @@ test "cl_parse_chain_multiple_blocks" { ///| test "cl_parse_chain_negative_query_strand" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments[0].q_strand, "-") assert_eq(cf.alignments[0].q_start, 5000) @@ -641,8 +650,7 @@ test "cl_parse_chain_negative_query_strand" { ///| test "cl_parse_chain_negative_target_strand" { - let content = - "chain 5000 chr1 249250621 - 5000 1 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 - 5000 1 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments[0].t_plus, false) assert_eq(cf.alignments[0].t_start, 5000) @@ -651,8 +659,7 @@ test "cl_parse_chain_negative_target_strand" { ///| test "cl_parse_chain_complex" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 400 30 40\n 300 0 0\nchain 3000 chr5 181538259 + 100 200 chr7 159345973 + 300 500 6\n 100 0 0\nchain 2000 chr12 133275309 + 500 800 chr14 107043718 + 700 1000 7\n 200 5 10\n 100 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 400 30 40\n 300 0 0\nchain 3000 chr5 181538259 + 100 200 chr7 159345973 + 300 500 6\n 100 0 0\nchain 2000 chr12 133275309 + 500 800 chr14 107043718 + 700 1000 7\n 200 5 10\n 100 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments.length(), 3) assert_eq(cf.alignments[0].blocks.length(), 3) @@ -662,23 +669,19 @@ test "cl_parse_chain_complex" { ///| test "cl_find_chain_for_pos_valid" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_find_chain_for_pos(cf, "chr1", 100) assert_true(result is Some(_)) match result { - Some(ch) => { - assert_eq(ch.id, 5) - } + Some(ch) => assert_eq(ch.id, 5) None => () } } ///| test "cl_find_chain_for_pos_first_block" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 4500 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 4500 0 0" let cf = cl_parse_chain(content) let result = cl_find_chain_for_pos(cf, "chr1", 100) assert_true(result is Some(_)) @@ -686,8 +689,7 @@ test "cl_find_chain_for_pos_first_block" { ///| test "cl_find_chain_for_pos_second_block" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 4500 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 4500 0 0" let cf = cl_parse_chain(content) let result = cl_find_chain_for_pos(cf, "chr1", 600) assert_true(result is Some(_)) @@ -695,8 +697,7 @@ test "cl_find_chain_for_pos_second_block" { ///| test "cl_find_chain_for_pos_wrong_chrom" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_find_chain_for_pos(cf, "chrX", 100) assert_true(result is None) @@ -704,8 +705,7 @@ test "cl_find_chain_for_pos_wrong_chrom" { ///| test "cl_find_chain_for_pos_out_of_range" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_find_chain_for_pos(cf, "chr1", 6000) assert_true(result is None) @@ -713,19 +713,14 @@ test "cl_find_chain_for_pos_out_of_range" { ///| test "cl_find_chain_for_pos_empty_chains" { - let cf = ChainFile::{ - alignments: [], - target_name: "", - query_name: "", - } + let cf = ChainFile::{ alignments: [], target_name: "", query_name: "" } let result = cl_find_chain_for_pos(cf, "chr1", 100) assert_true(result is None) } ///| test "cl_liftover_pos_basic" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 100) assert_eq(result, Some(100)) @@ -733,8 +728,7 @@ test "cl_liftover_pos_basic" { ///| test "cl_liftover_pos_first_block" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 100) assert_eq(result, Some(100)) @@ -742,8 +736,7 @@ test "cl_liftover_pos_first_block" { ///| test "cl_liftover_pos_second_block" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 600) assert_eq(result, Some(610)) @@ -751,8 +744,7 @@ test "cl_liftover_pos_second_block" { ///| test "cl_liftover_pos_last_block" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 4999) assert_eq(result, Some(5009)) @@ -760,8 +752,7 @@ test "cl_liftover_pos_last_block" { ///| test "cl_liftover_pos_at_chain_start" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 1) assert_eq(result, Some(1)) @@ -769,8 +760,7 @@ test "cl_liftover_pos_at_chain_start" { ///| test "cl_liftover_pos_at_chain_end" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 4999) assert_eq(result, Some(4999)) @@ -778,8 +768,7 @@ test "cl_liftover_pos_at_chain_end" { ///| test "cl_liftover_pos_out_of_range_before" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 0) assert_true(result is None) @@ -787,8 +776,7 @@ test "cl_liftover_pos_out_of_range_before" { ///| test "cl_liftover_pos_out_of_range_after" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 6000) assert_true(result is None) @@ -796,8 +784,7 @@ test "cl_liftover_pos_out_of_range_after" { ///| test "cl_liftover_pos_wrong_chrom" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chrX", 100) assert_true(result is None) @@ -805,8 +792,7 @@ test "cl_liftover_pos_wrong_chrom" { ///| test "cl_liftover_pos_in_gap" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 501) assert_true(result is None) @@ -814,8 +800,7 @@ test "cl_liftover_pos_in_gap" { ///| test "cl_liftover_pos_reverse_query_strand" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 100) assert_eq(result, Some(4901)) @@ -823,8 +808,7 @@ test "cl_liftover_pos_reverse_query_strand" { ///| test "cl_liftover_pos_reverse_query_at_start" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 1) assert_eq(result, Some(5000)) @@ -832,8 +816,7 @@ test "cl_liftover_pos_reverse_query_at_start" { ///| test "cl_liftover_pos_reverse_query_at_end" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 4999) assert_eq(result, Some(2)) @@ -841,19 +824,14 @@ test "cl_liftover_pos_reverse_query_at_end" { ///| test "cl_liftover_pos_empty_chains" { - let cf = ChainFile::{ - alignments: [], - target_name: "", - query_name: "", - } + let cf = ChainFile::{ alignments: [], target_name: "", query_name: "" } let result = cl_liftover_pos(cf, "chr1", 100) assert_true(result is None) } ///| test "cl_liftover_range_basic" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_range(cf, "chr1", 100, 200) assert_eq(result, Some((100, 200))) @@ -861,8 +839,7 @@ test "cl_liftover_range_basic" { ///| test "cl_liftover_range_across_blocks" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_range(cf, "chr1", 400, 700) assert_eq(result, Some((400, 710))) @@ -870,8 +847,7 @@ test "cl_liftover_range_across_blocks" { ///| test "cl_liftover_range_out_of_range" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_range(cf, "chr1", 4900, 6000) assert_true(result is None) @@ -879,8 +855,7 @@ test "cl_liftover_range_out_of_range" { ///| test "cl_liftover_range_reverse_strand" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 - 5000 1 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_range(cf, "chr1", 100, 200) assert_eq(result, Some((4801, 4901))) @@ -888,8 +863,7 @@ test "cl_liftover_range_reverse_strand" { ///| test "cl_liftover_range_empty" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_range(cf, "chr1", 200, 100) assert_true(result is None) @@ -935,8 +909,7 @@ test "cl_get_chain_summary_single_block" { ///| test "cl_chain_to_string_roundtrip" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 400 0 0\n" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n 500 10 20\n 400 0 0\n" let cf = cl_parse_chain(content) assert_eq(cf.alignments.length(), 1) let serialized = cl_chain_to_string(cf.alignments[0]) @@ -967,16 +940,14 @@ test "cl_chain_to_string_contains_blocks" { ///| test "cl_parse_chain_with_blank_lines" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n\n 5000 0 0\n\nchain 3000 chr5 181538259 + 100 200 chr7 159345973 + 300 500 6\n\n 100 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 100 5\n\n 5000 0 0\n\nchain 3000 chr5 181538259 + 100 200 chr7 159345973 + 300 500 6\n\n 100 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments.length(), 2) } ///| test "cl_liftover_pos_multi_chain" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 3000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 3000 0 0" let cf = cl_parse_chain(content) let result1 = cl_liftover_pos(cf, "chr1", 100) assert_eq(result1, Some(100)) @@ -986,8 +957,7 @@ test "cl_liftover_pos_multi_chain" { ///| test "cl_liftover_range_multi_chain" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 3000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 3000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_range(cf, "chr1", 100, 200) assert_eq(result, Some((100, 200))) @@ -995,8 +965,7 @@ test "cl_liftover_range_multi_chain" { ///| test "cl_liftover_range_spans_multiple_chains" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 3000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 3000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_range(cf, "chr1", 4900, 7000) assert_true(result is None) @@ -1004,8 +973,7 @@ test "cl_liftover_range_spans_multiple_chains" { ///| test "cl_parse_chain_single_nucleotide_block" { - let content = - "chain 100 chr1 1000 + 100 200 chr2 500 + 50 150 1\n 1 0 0" + let content = "chain 100 chr1 1000 + 100 200 chr2 500 + 50 150 1\n 1 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments[0].blocks.length(), 1) assert_eq(cf.alignments[0].blocks[0].size, 1) @@ -1015,8 +983,7 @@ test "cl_parse_chain_single_nucleotide_block" { ///| test "cl_liftover_pos_chain_boundary_start" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 1) assert_true(result is Some(_)) @@ -1024,8 +991,7 @@ test "cl_liftover_pos_chain_boundary_start" { ///| test "cl_liftover_pos_chain_boundary_end" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_pos(cf, "chr1", 4999) assert_true(result is Some(_)) @@ -1033,8 +999,7 @@ test "cl_liftover_pos_chain_boundary_end" { ///| test "cl_find_chain_for_pos_multiple_chains" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 3000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 5000 0 0\nchain 3000 chr1 249250621 + 6000 10000 chr3 8000 + 500 1500 6\n 3000 0 0" let cf = cl_parse_chain(content) let r1 = cl_find_chain_for_pos(cf, "chr1", 100) match r1 { @@ -1050,8 +1015,7 @@ test "cl_find_chain_for_pos_multiple_chains" { ///| test "cl_parse_chain_whitespace_tabs" { - let content = - "chain\t5000\tchr1\t249250621\t+\t1\t5000\tchr2\t10000\t+\t1\t100\t5\n\t5000\t0\t0" + let content = "chain\t5000\tchr1\t249250621\t+\t1\t5000\tchr2\t10000\t+\t1\t100\t5\n\t5000\t0\t0" let cf = cl_parse_chain(content) assert_eq(cf.alignments.length(), 1) assert_eq(cf.alignments[0].blocks.length(), 1) @@ -1059,8 +1023,7 @@ test "cl_parse_chain_whitespace_tabs" { ///| test "cl_liftover_pos_block_boundary_alignment" { - let content = - "chain 5000 chr1 249250621 + 1 1100 chr2 10000 + 1 1100 5\n 500 10 20\n 500 0 0" + let content = "chain 5000 chr1 249250621 + 1 1100 chr2 10000 + 1 1100 5\n 500 10 20\n 500 0 0" let cf = cl_parse_chain(content) let r1 = cl_liftover_pos(cf, "chr1", 500) assert_eq(r1, Some(500)) @@ -1074,16 +1037,14 @@ test "cl_liftover_pos_block_boundary_alignment" { ///| test "cl_parse_chain_id_preserved" { - let content = - "chain 100 chr1 1000 + 100 200 chr2 500 + 50 150 99\n 100 0 0" + let content = "chain 100 chr1 1000 + 100 200 chr2 500 + 50 150 99\n 100 0 0" let cf = cl_parse_chain(content) assert_eq(cf.alignments[0].id, 99) } ///| test "cl_chain_to_string_score_preserved" { - let content = - "chain 7777 chr1 1000 + 100 200 chr2 500 + 50 150 1\n 100 0 0" + let content = "chain 7777 chr1 1000 + 100 200 chr2 500 + 50 150 1\n 100 0 0" let cf = cl_parse_chain(content) let s = cl_chain_to_string(cf.alignments[0]) assert_true(cl_starts_with(s, "chain 7777")) @@ -1091,8 +1052,7 @@ test "cl_chain_to_string_score_preserved" { ///| test "cl_liftover_range_sub_block" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 500 10 20\n 4500 0 0" let cf = cl_parse_chain(content) let result = cl_liftover_range(cf, "chr1", 50, 150) assert_eq(result, Some((50, 150))) @@ -1113,8 +1073,7 @@ test "cl_get_chain_summary_gaps" { ///| test "cl_liftover_pos_complex_chain" { - let content = - "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 1000 50 100\n 2000 30 40\n 2000 0 0" + let content = "chain 5000 chr1 249250621 + 1 5000 chr2 10000 + 1 5000 5\n 1000 50 100\n 2000 30 40\n 2000 0 0" let cf = cl_parse_chain(content) let r1 = cl_liftover_pos(cf, "chr1", 500) assert_eq(r1, Some(500)) @@ -1124,4 +1083,4 @@ test "cl_liftover_pos_complex_chain" { assert_eq(r3, Some(3560)) let r4 = cl_liftover_pos(cf, "chr1", 4500) assert_eq(r4, Some(4560)) -} \ No newline at end of file +} diff --git a/src/checksum.mbt b/src/checksum.mbt index d643f106..c3b514ad 100644 --- a/src/checksum.mbt +++ b/src/checksum.mbt @@ -8,49 +8,79 @@ pub struct CheckSumResult { } ///| -pub fn CheckSumResult::new(checksum : String, method : String) -> CheckSumResult { +pub fn CheckSumResult::new( + checksum : String, + method : String, +) -> CheckSumResult { CheckSumResult::{ checksum, method } } ///| pub fn checksum_gcg(seq : String) -> CheckSumResult { let seq_upper = seq.to_upper() - + let mut checksum = 0 let mut idx = 0 while idx < seq_upper.length() { let c = substring(seq_upper, idx, 1) - if c == "A" { checksum = (checksum + 1) * 11 } - else if c == "B" { checksum = (checksum + 2) * 11 } - else if c == "C" { checksum = (checksum + 3) * 11 } - else if c == "D" { checksum = (checksum + 4) * 11 } - else if c == "E" { checksum = (checksum + 5) * 11 } - else if c == "F" { checksum = (checksum + 6) * 11 } - else if c == "G" { checksum = (checksum + 7) * 11 } - else if c == "H" { checksum = (checksum + 8) * 11 } - else if c == "I" { checksum = (checksum + 9) * 11 } - else if c == "J" { checksum = (checksum + 10) * 11 } - else if c == "K" { checksum = (checksum + 11) * 11 } - else if c == "L" { checksum = (checksum + 12) * 11 } - else if c == "M" { checksum = (checksum + 13) * 11 } - else if c == "N" { checksum = (checksum + 14) * 11 } - else if c == "O" { checksum = (checksum + 15) * 11 } - else if c == "P" { checksum = (checksum + 16) * 11 } - else if c == "Q" { checksum = (checksum + 17) * 11 } - else if c == "R" { checksum = (checksum + 18) * 11 } - else if c == "S" { checksum = (checksum + 19) * 11 } - else if c == "T" { checksum = (checksum + 20) * 11 } - else if c == "U" { checksum = (checksum + 21) * 11 } - else if c == "V" { checksum = (checksum + 22) * 11 } - else if c == "W" { checksum = (checksum + 23) * 11 } - else if c == "X" { checksum = (checksum + 24) * 11 } - else if c == "Y" { checksum = (checksum + 25) * 11 } - else if c == "Z" { checksum = (checksum + 26) * 11 } + if c == "A" { + checksum = (checksum + 1) * 11 + } else if c == "B" { + checksum = (checksum + 2) * 11 + } else if c == "C" { + checksum = (checksum + 3) * 11 + } else if c == "D" { + checksum = (checksum + 4) * 11 + } else if c == "E" { + checksum = (checksum + 5) * 11 + } else if c == "F" { + checksum = (checksum + 6) * 11 + } else if c == "G" { + checksum = (checksum + 7) * 11 + } else if c == "H" { + checksum = (checksum + 8) * 11 + } else if c == "I" { + checksum = (checksum + 9) * 11 + } else if c == "J" { + checksum = (checksum + 10) * 11 + } else if c == "K" { + checksum = (checksum + 11) * 11 + } else if c == "L" { + checksum = (checksum + 12) * 11 + } else if c == "M" { + checksum = (checksum + 13) * 11 + } else if c == "N" { + checksum = (checksum + 14) * 11 + } else if c == "O" { + checksum = (checksum + 15) * 11 + } else if c == "P" { + checksum = (checksum + 16) * 11 + } else if c == "Q" { + checksum = (checksum + 17) * 11 + } else if c == "R" { + checksum = (checksum + 18) * 11 + } else if c == "S" { + checksum = (checksum + 19) * 11 + } else if c == "T" { + checksum = (checksum + 20) * 11 + } else if c == "U" { + checksum = (checksum + 21) * 11 + } else if c == "V" { + checksum = (checksum + 22) * 11 + } else if c == "W" { + checksum = (checksum + 23) * 11 + } else if c == "X" { + checksum = (checksum + 24) * 11 + } else if c == "Y" { + checksum = (checksum + 25) * 11 + } else if c == "Z" { + checksum = (checksum + 26) * 11 + } idx = idx + 1 } - + checksum = checksum % 10000 - + let checksum_str = if checksum < 10 { "000" + checksum.to_string() } else if checksum < 100 { @@ -60,28 +90,34 @@ pub fn checksum_gcg(seq : String) -> CheckSumResult { } else { checksum.to_string() } - + CheckSumResult::new(checksum_str, "gcg") } ///| pub fn checksum_seguid(seq : String) -> CheckSumResult { let seq_upper = seq.to_upper() - + let mut hash_val = 0 let mut idx = 0 while idx < seq_upper.length() { let c = substring(seq_upper, idx, 1) - if c == "A" { hash_val = hash_val * 31 + 65 } - else if c == "T" { hash_val = hash_val * 31 + 84 } - else if c == "C" { hash_val = hash_val * 31 + 67 } - else if c == "G" { hash_val = hash_val * 31 + 71 } - else { hash_val = hash_val * 31 + 78 } + if c == "A" { + hash_val = hash_val * 31 + 65 + } else if c == "T" { + hash_val = hash_val * 31 + 84 + } else if c == "C" { + hash_val = hash_val * 31 + 67 + } else if c == "G" { + hash_val = hash_val * 31 + 71 + } else { + hash_val = hash_val * 31 + 78 + } idx = idx + 1 } - + let table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" - + let mut result = "" let mut h = hash_val while h > 0 { @@ -96,7 +132,7 @@ pub fn checksum_seguid(seq : String) -> CheckSumResult { } h = h / 64 } - + CheckSumResult::new(result, "seguid") } @@ -106,12 +142,16 @@ pub fn create_example_sequence() -> String { } ///| -pub fn verify_checksum(seq : String, expected_checksum : String, method : String) -> Bool { +pub fn verify_checksum( + seq : String, + expected_checksum : String, + method : String, +) -> Bool { let result = if method == "gcg" { checksum_gcg(seq) } else { checksum_seguid(seq) } - + result.checksum == expected_checksum -} \ No newline at end of file +} diff --git a/src/chem_utils.mbt b/src/chem_utils.mbt index f2ac8a09..8c5f2099 100644 --- a/src/chem_utils.mbt +++ b/src/chem_utils.mbt @@ -12,26 +12,47 @@ /// Values from Mantina et al. (2008) J. Phys. Chem. A. pub fn chem_vdw_radius(element : String) -> Double { let el = element.to_upper() - if el == "H" { 1.20 } - else if el == "C" { 1.70 } - else if el == "N" { 1.55 } - else if el == "O" { 1.52 } - else if el == "F" { 1.47 } - else if el == "S" { 1.80 } - else if el == "P" { 1.80 } - else if el == "CL" || el == "Cl" { 1.75 } - else if el == "BR" || el == "Br" { 1.85 } - else if el == "I" { 1.98 } - else if el == "FE" || el == "Fe" { 1.94 } - else if el == "ZN" || el == "Zn" { 1.39 } - else if el == "MG" || el == "Mg" { 1.73 } - else if el == "CA" || el == "Ca" { 2.31 } - else if el == "MN" || el == "Mn" { 1.97 } - else if el == "CU" || el == "Cu" { 1.40 } - else if el == "NA" || el == "Na" { 2.27 } - else if el == "K" { 2.75 } - else if el == "BR" { 1.85 } - else { 1.70 } // Default to carbon + if el == "H" { + 1.20 + } else if el == "C" { + 1.70 + } else if el == "N" { + 1.55 + } else if el == "O" { + 1.52 + } else if el == "F" { + 1.47 + } else if el == "S" { + 1.80 + } else if el == "P" { + 1.80 + } else if el == "CL" || el == "Cl" { + 1.75 + } else if el == "BR" || el == "Br" { + 1.85 + } else if el == "I" { + 1.98 + } else if el == "FE" || el == "Fe" { + 1.94 + } else if el == "ZN" || el == "Zn" { + 1.39 + } else if el == "MG" || el == "Mg" { + 1.73 + } else if el == "CA" || el == "Ca" { + 2.31 + } else if el == "MN" || el == "Mn" { + 1.97 + } else if el == "CU" || el == "Cu" { + 1.40 + } else if el == "NA" || el == "Na" { + 2.27 + } else if el == "K" { + 2.75 + } else if el == "BR" { + 1.85 + } else { + 1.70 + } // Default to carbon } ///| @@ -39,64 +60,116 @@ pub fn chem_vdw_radius(element : String) -> Double { /// Values from Cordero et al. (2008) Dalton Trans. pub fn chem_covalent_radius(element : String) -> Double { let el = element.to_upper() - if el == "H" { 0.31 } - else if el == "C" { 0.76 } - else if el == "N" { 0.71 } - else if el == "O" { 0.66 } - else if el == "F" { 0.57 } - else if el == "S" { 1.05 } - else if el == "P" { 1.07 } - else if el == "CL" || el == "Cl" { 1.02 } - else if el == "BR" || el == "Br" { 1.2 } - else if el == "I" { 1.39 } - else if el == "FE" || el == "Fe" { 1.32 } - else if el == "ZN" || el == "Zn" { 1.22 } - else if el == "MG" || el == "Mg" { 1.41 } - else if el == "CA" || el == "Ca" { 1.76 } - else if el == "MN" || el == "Mn" { 1.39 } - else if el == "CU" || el == "Cu" { 1.32 } - else if el == "NA" || el == "Na" { 1.66 } - else if el == "K" { 2.0 } - else { 0.77 } // Default to carbon + if el == "H" { + 0.31 + } else if el == "C" { + 0.76 + } else if el == "N" { + 0.71 + } else if el == "O" { + 0.66 + } else if el == "F" { + 0.57 + } else if el == "S" { + 1.05 + } else if el == "P" { + 1.07 + } else if el == "CL" || el == "Cl" { + 1.02 + } else if el == "BR" || el == "Br" { + 1.2 + } else if el == "I" { + 1.39 + } else if el == "FE" || el == "Fe" { + 1.32 + } else if el == "ZN" || el == "Zn" { + 1.22 + } else if el == "MG" || el == "Mg" { + 1.41 + } else if el == "CA" || el == "Ca" { + 1.76 + } else if el == "MN" || el == "Mn" { + 1.39 + } else if el == "CU" || el == "Cu" { + 1.32 + } else if el == "NA" || el == "Na" { + 1.66 + } else if el == "K" { + 2.0 + } else { + 0.77 + } // Default to carbon } ///| /// Ionic radii by element (in Angstroms) for common oxidation states. /// Returns a tuple of (radius, oxidation_state). -pub fn chem_ionic_radius(element : String, oxidation_state? : Int = 0) -> Double { +pub fn chem_ionic_radius( + element : String, + oxidation_state? : Int = 0, +) -> Double { let el = element.to_upper() - if el == "H" { 0.0 } - else if el == "C" { 0.08 } - else if el == "N" { 0.12 } - else if el == "O" { 1.40 } - else if el == "F" { 1.33 } - else if el == "S" { 1.84 } - else if el == "P" { 0.17 } - else if el == "CL" || el == "Cl" { 1.81 } - else if el == "BR" || el == "Br" { 1.96 } - else if el == "I" { 2.20 } - else if el == "FE" || el == "Fe" { - if oxidation_state == 2 { 0.78 } else { 0.65 } - } - else if el == "ZN" || el == "Zn" { 0.74 } - else if el == "MG" || el == "Mg" { 0.72 } - else if el == "CA" || el == "Ca" { 1.00 } - else if el == "MN" || el == "Mn" { - if oxidation_state == 2 { 0.80 } else { 0.67 } - } - else if el == "CU" || el == "Cu" { - if oxidation_state == 1 { 0.77 } else { 0.73 } + if el == "H" { + 0.0 + } else if el == "C" { + 0.08 + } else if el == "N" { + 0.12 + } else if el == "O" { + 1.40 + } else if el == "F" { + 1.33 + } else if el == "S" { + 1.84 + } else if el == "P" { + 0.17 + } else if el == "CL" || el == "Cl" { + 1.81 + } else if el == "BR" || el == "Br" { + 1.96 + } else if el == "I" { + 2.20 + } else if el == "FE" || el == "Fe" { + if oxidation_state == 2 { + 0.78 + } else { + 0.65 + } + } else if el == "ZN" || el == "Zn" { + 0.74 + } else if el == "MG" || el == "Mg" { + 0.72 + } else if el == "CA" || el == "Ca" { + 1.00 + } else if el == "MN" || el == "Mn" { + if oxidation_state == 2 { + 0.80 + } else { + 0.67 + } + } else if el == "CU" || el == "Cu" { + if oxidation_state == 1 { + 0.77 + } else { + 0.73 + } + } else if el == "NA" || el == "Na" { + 1.02 + } else if el == "K" { + 1.38 + } else { + 0.0 } - else if el == "NA" || el == "Na" { 1.02 } - else if el == "K" { 1.38 } - else { 0.0 } } ///| /// Calculate bond length between two atoms given their coordinates. /// atom1_coords: [x, y, z] of first atom /// atom2_coords: [x, y, z] of second atom -pub fn chem_bond_length(atom1_coords : Array[Double], atom2_coords : Array[Double]) -> Double { +pub fn chem_bond_length( + atom1_coords : Array[Double], + atom2_coords : Array[Double], +) -> Double { let dx = atom1_coords[0] - atom2_coords[0] let dy = atom1_coords[1] - atom2_coords[1] let dz = atom1_coords[2] - atom2_coords[2] @@ -125,7 +198,13 @@ pub fn chem_bond_angle( return 0.0 } let cos_angle = dot / (mag1 * mag2) - let clamped = if cos_angle > 1.0 { 1.0 } else if cos_angle < -1.0 { -1.0 } else { cos_angle } + let clamped = if cos_angle > 1.0 { + 1.0 + } else if cos_angle < -1.0 { + -1.0 + } else { + cos_angle + } // acos approximation acos_approx(clamped) * 180.0 / 3.141592653589793 } @@ -264,8 +343,8 @@ pub fn chem_empirical_formula(element_counts : Map[String, Int]) -> String { /// Calculate molecular weight from element counts and atomic weights. pub fn chem_molecular_weight(element_counts : Map[String, Int]) -> Double { let atomic_weights_elements = [ - "H", "C", "N", "O", "F", "P", "S", "CL", "BR", "I", - "FE", "ZN", "MG", "CA", "MN", "CU", "NA", "K", + "H", "C", "N", "O", "F", "P", "S", "CL", "BR", "I", "FE", "ZN", "MG", "CA", "MN", + "CU", "NA", "K", ] let atomic_weights_values = [ 1.008, 12.011, 14.007, 15.999, 18.998, 30.974, 32.06, 35.45, 79.904, 126.904, @@ -298,8 +377,12 @@ pub fn chem_molecular_weight(element_counts : Map[String, Int]) -> Double { /// Approximate arccosine function. /// Uses the identity: acos(x) = atan2(sqrt(1-x^2), x) fn acos_approx(x : Double) -> Double { - if x >= 1.0 { return 0.0 } - if x <= -1.0 { return 3.141592653589793 } + if x >= 1.0 { + return 0.0 + } + if x <= -1.0 { + return 3.141592653589793 + } atan2_approx((1.0 - x * x).sqrt(), x) } @@ -314,10 +397,12 @@ fn atan2_approx(y : Double, x : Double) -> Double { } else { atan_approx(y / x) - 3.141592653589793 } + } else if y > 0.0 { + 3.141592653589793 / 2.0 + } else if y < 0.0 { + -3.141592653589793 / 2.0 } else { - if y > 0.0 { 3.141592653589793 / 2.0 } - else if y < 0.0 { -3.141592653589793 / 2.0 } - else { 0.0 } + 0.0 } } @@ -345,45 +430,107 @@ pub fn chem_amino_acid_elements(aa_name : String) -> Map[String, Int] { let name = aa_name.to_upper() let elements : Map[String, Int] = Map([], capacity=16) if name == "ALA" || name == "A" { - elements.set("C", 3); elements.set("H", 7); elements.set("N", 1); elements.set("O", 2) + elements.set("C", 3) + elements.set("H", 7) + elements.set("N", 1) + elements.set("O", 2) } else if name == "ARG" || name == "R" { - elements.set("C", 6); elements.set("H", 14); elements.set("N", 4); elements.set("O", 2) + elements.set("C", 6) + elements.set("H", 14) + elements.set("N", 4) + elements.set("O", 2) } else if name == "ASN" || name == "N" { - elements.set("C", 4); elements.set("H", 8); elements.set("N", 2); elements.set("O", 3) + elements.set("C", 4) + elements.set("H", 8) + elements.set("N", 2) + elements.set("O", 3) } else if name == "ASP" || name == "D" { - elements.set("C", 4); elements.set("H", 7); elements.set("N", 1); elements.set("O", 4) + elements.set("C", 4) + elements.set("H", 7) + elements.set("N", 1) + elements.set("O", 4) } else if name == "CYS" || name == "C" { - elements.set("C", 3); elements.set("H", 7); elements.set("N", 1); elements.set("O", 2); elements.set("S", 1) + elements.set("C", 3) + elements.set("H", 7) + elements.set("N", 1) + elements.set("O", 2) + elements.set("S", 1) } else if name == "GLN" || name == "Q" { - elements.set("C", 5); elements.set("H", 10); elements.set("N", 2); elements.set("O", 3) + elements.set("C", 5) + elements.set("H", 10) + elements.set("N", 2) + elements.set("O", 3) } else if name == "GLU" || name == "E" { - elements.set("C", 5); elements.set("H", 9); elements.set("N", 1); elements.set("O", 4) + elements.set("C", 5) + elements.set("H", 9) + elements.set("N", 1) + elements.set("O", 4) } else if name == "GLY" || name == "G" { - elements.set("C", 2); elements.set("H", 5); elements.set("N", 1); elements.set("O", 2) + elements.set("C", 2) + elements.set("H", 5) + elements.set("N", 1) + elements.set("O", 2) } else if name == "HIS" || name == "H" { - elements.set("C", 6); elements.set("H", 9); elements.set("N", 3); elements.set("O", 2) + elements.set("C", 6) + elements.set("H", 9) + elements.set("N", 3) + elements.set("O", 2) } else if name == "ILE" || name == "I" { - elements.set("C", 6); elements.set("H", 13); elements.set("N", 1); elements.set("O", 2) + elements.set("C", 6) + elements.set("H", 13) + elements.set("N", 1) + elements.set("O", 2) } else if name == "LEU" || name == "L" { - elements.set("C", 6); elements.set("H", 13); elements.set("N", 1); elements.set("O", 2) + elements.set("C", 6) + elements.set("H", 13) + elements.set("N", 1) + elements.set("O", 2) } else if name == "LYS" || name == "K" { - elements.set("C", 6); elements.set("H", 14); elements.set("N", 2); elements.set("O", 2) + elements.set("C", 6) + elements.set("H", 14) + elements.set("N", 2) + elements.set("O", 2) } else if name == "MET" || name == "M" { - elements.set("C", 5); elements.set("H", 11); elements.set("N", 1); elements.set("O", 2); elements.set("S", 1) + elements.set("C", 5) + elements.set("H", 11) + elements.set("N", 1) + elements.set("O", 2) + elements.set("S", 1) } else if name == "PHE" || name == "F" { - elements.set("C", 9); elements.set("H", 11); elements.set("N", 1); elements.set("O", 2) + elements.set("C", 9) + elements.set("H", 11) + elements.set("N", 1) + elements.set("O", 2) } else if name == "PRO" || name == "P" { - elements.set("C", 5); elements.set("H", 9); elements.set("N", 1); elements.set("O", 2) + elements.set("C", 5) + elements.set("H", 9) + elements.set("N", 1) + elements.set("O", 2) } else if name == "SER" || name == "S" { - elements.set("C", 3); elements.set("H", 7); elements.set("N", 1); elements.set("O", 3) + elements.set("C", 3) + elements.set("H", 7) + elements.set("N", 1) + elements.set("O", 3) } else if name == "THR" || name == "T" { - elements.set("C", 4); elements.set("H", 9); elements.set("N", 1); elements.set("O", 3) + elements.set("C", 4) + elements.set("H", 9) + elements.set("N", 1) + elements.set("O", 3) } else if name == "TRP" || name == "W" { - elements.set("C", 11); elements.set("H", 12); elements.set("N", 2); elements.set("O", 2) + elements.set("C", 11) + elements.set("H", 12) + elements.set("N", 2) + elements.set("O", 2) } else if name == "TYR" || name == "Y" { - elements.set("C", 9); elements.set("H", 11); elements.set("N", 1); elements.set("O", 3) + elements.set("C", 9) + elements.set("H", 11) + elements.set("N", 1) + elements.set("O", 3) } else if name == "VAL" || name == "V" { - elements.set("C", 5); elements.set("H", 11); elements.set("N", 1); elements.set("O", 2) + elements.set("C", 5) + elements.set("H", 11) + elements.set("N", 1) + elements.set("O", 2) } elements } @@ -417,9 +564,13 @@ pub fn chem_extinction_coefficient(sequence : String) -> Double { let mut i = 0 while i < upper_seq.length() { let ch = upper_seq.unsafe_get(i).unsafe_to_char() - if ch == 'W' { trp_count = trp_count + 1 } - else if ch == 'Y' { tyr_count = tyr_count + 1 } - else if ch == 'C' { cys_count = cys_count + 1 } + if ch == 'W' { + trp_count = trp_count + 1 + } else if ch == 'Y' { + tyr_count = tyr_count + 1 + } else if ch == 'C' { + cys_count = cys_count + 1 + } i = i + 1 } // Pace et al. values @@ -427,7 +578,9 @@ pub fn chem_extinction_coefficient(sequence : String) -> Double { let ext_tyr = 1490.0 let ext_cystine = 125.0 // per disulfide bond (divide Cys by 2) let n_cystine = cys_count / 2 - ext_trp * trp_count.to_double() + ext_tyr * tyr_count.to_double() + ext_cystine * n_cystine.to_double() + ext_trp * trp_count.to_double() + + ext_tyr * tyr_count.to_double() + + ext_cystine * n_cystine.to_double() } ///| @@ -469,15 +622,22 @@ pub fn chem_isoelectric_point( neg_charge = 0.0 // Positive charges pos_charge = pos_charge + 1.0 / (1.0 + chem_pow10(pH - p_nterm)) // N-term - pos_charge = pos_charge + arg_count.to_double() / (1.0 + chem_pow10(pH - pka_arg)) - pos_charge = pos_charge + lys_count.to_double() / (1.0 + chem_pow10(pH - pka_lys)) - pos_charge = pos_charge + his_count.to_double() / (1.0 + chem_pow10(pH - pka_his)) + pos_charge = pos_charge + + arg_count.to_double() / (1.0 + chem_pow10(pH - pka_arg)) + pos_charge = pos_charge + + lys_count.to_double() / (1.0 + chem_pow10(pH - pka_lys)) + pos_charge = pos_charge + + his_count.to_double() / (1.0 + chem_pow10(pH - pka_his)) // Negative charges neg_charge = neg_charge + 1.0 / (1.0 + chem_pow10(p_cterm - pH)) // C-term - neg_charge = neg_charge + asp_count.to_double() / (1.0 + chem_pow10(pka_asp - pH)) - neg_charge = neg_charge + glu_count.to_double() / (1.0 + chem_pow10(pka_glu - pH)) - neg_charge = neg_charge + cys_count.to_double() / (1.0 + chem_pow10(pka_cys - pH)) - neg_charge = neg_charge + tyr_count.to_double() / (1.0 + chem_pow10(pka_tyr - pH)) + neg_charge = neg_charge + + asp_count.to_double() / (1.0 + chem_pow10(pka_asp - pH)) + neg_charge = neg_charge + + glu_count.to_double() / (1.0 + chem_pow10(pka_glu - pH)) + neg_charge = neg_charge + + cys_count.to_double() / (1.0 + chem_pow10(pka_cys - pH)) + neg_charge = neg_charge + + tyr_count.to_double() / (1.0 + chem_pow10(pka_tyr - pH)) let net = pos_charge - neg_charge if net > 0.0 { low = pH @@ -537,8 +697,8 @@ pub fn chem_count_atoms(sequence : String) -> Int { /// Parses formulas like "H2O", "C6H12O6", "NaCl", etc. pub fn chem_formula_weight(formula : String) -> Double { let atomic_weights_elements = [ - "H", "C", "N", "O", "F", "P", "S", "CL", "BR", "I", - "FE", "ZN", "MG", "CA", "MN", "CU", "NA", "K", + "H", "C", "N", "O", "F", "P", "S", "CL", "BR", "I", "FE", "ZN", "MG", "CA", "MN", + "CU", "NA", "K", ] let atomic_weights_values = [ 1.008, 12.011, 14.007, 15.999, 18.998, 30.974, 32.06, 35.45, 79.904, 126.904, @@ -565,7 +725,8 @@ pub fn chem_formula_weight(formula : String) -> Double { let next_ch = upper.unsafe_get(pos).to_int() if next_ch >= 65 && next_ch <= 90 { // Check if two-letter combination is in weight map - let two_letter = el + upper.unsafe_get(pos).unsafe_to_char().to_string() + let two_letter = el + + upper.unsafe_get(pos).unsafe_to_char().to_string() if weight_map.contains(two_letter) { el = two_letter pos = pos + 1 @@ -603,17 +764,29 @@ pub fn chem_formula_weight(formula : String) -> Double { ///| /// Calculate typical hydrogen bond length between two atom types. /// Returns approximate distance in Angstroms. -pub fn chem_hydrogen_bond_length(donor_type : String, acceptor_type : String) -> Double { +pub fn chem_hydrogen_bond_length( + donor_type : String, + acceptor_type : String, +) -> Double { let donor = donor_type.to_upper() let acceptor = acceptor_type.to_upper() let key = donor + "..." + acceptor // Typical hydrogen bond distances (Angstroms) - if key == "OH...OH" || key == "OH...O" { 2.72 } - else if key == "NH...OH" || key == "NH...O" { 2.93 } - else if key == "SH...SH" { 3.45 } - else if key == "OH...NH" || key == "O...HN" { 2.88 } - else if key == "NH...N" { 3.10 } - else if key == "OH...S" { 3.40 } - else if key == "NH...S" { 3.45 } - else { 2.90 } // Default + if key == "OH...OH" || key == "OH...O" { + 2.72 + } else if key == "NH...OH" || key == "NH...O" { + 2.93 + } else if key == "SH...SH" { + 3.45 + } else if key == "OH...NH" || key == "O...HN" { + 2.88 + } else if key == "NH...N" { + 3.10 + } else if key == "OH...S" { + 3.40 + } else if key == "NH...S" { + 3.45 + } else { + 2.90 + } // Default } diff --git a/src/chemminer.mbt b/src/chemminer.mbt index 8c0c35df..82704138 100644 --- a/src/chemminer.mbt +++ b/src/chemminer.mbt @@ -80,7 +80,7 @@ pub fn SdfAtom::new( x : Double, y : Double, z : Double, - charge : Int + charge : Int, ) -> SdfAtom { SdfAtom::{ symbol, x, y, z, charge } } @@ -179,7 +179,7 @@ pub struct SdfMolecule { pub fn SdfMolecule::new( name : String, atoms : Array[SdfAtom], - bonds : Array[SdfBond] + bonds : Array[SdfBond], ) -> SdfMolecule { SdfMolecule::{ name, atoms, bonds, properties: Map([], capacity=8) } } @@ -218,10 +218,7 @@ pub fn SdfMolecule::n_bonds(self : SdfMolecule) -> Int { ///| /// Get a property value by key. Returns empty string if missing. -pub fn SdfMolecule::get_property( - self : SdfMolecule, - key : String -) -> String { +pub fn SdfMolecule::get_property(self : SdfMolecule, key : String) -> String { self.properties.get_or_default(key, "") } @@ -230,17 +227,14 @@ pub fn SdfMolecule::get_property( pub fn SdfMolecule::set_property( self : SdfMolecule, key : String, - value : String + value : String, ) -> Unit { self.properties[key] = value } ///| /// Whether the molecule has a property. -pub fn SdfMolecule::has_property( - self : SdfMolecule, - key : String -) -> Bool { +pub fn SdfMolecule::has_property(self : SdfMolecule, key : String) -> Bool { self.properties.contains(key) } @@ -293,7 +287,13 @@ pub fn chem_molecular_formula(mol : SdfMolecule) -> String { remaining.push(k) } remaining.sort_by(fn(a : String, b : String) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) for elem in remaining { let c = counts[elem] @@ -374,7 +374,11 @@ pub fn chem_ring_count(mol : SdfMolecule) -> Int { } // Cyclomatic number. let rings = n_bonds - n_atoms + n_components - if rings < 0 { 0 } else { rings } + if rings < 0 { + 0 + } else { + rings + } } // ============================================================================ @@ -417,11 +421,7 @@ fn chem_atom_degrees(mol : SdfMolecule) -> Array[Int] { ///| /// BFS shortest-path distance between two atom indices in the molecular /// graph. Returns -1 if unreachable. -fn chem_bfs_distance( - mol : SdfMolecule, - start : Int, - end : Int -) -> Int { +fn chem_bfs_distance(mol : SdfMolecule, start : Int, end : Int) -> Int { if start == end { return 0 } @@ -499,7 +499,13 @@ pub fn chem_atom_pair_fingerprint(mol : SdfMolecule) -> Array[Int] { result.push(k) } result.sort_by(fn(a : Int, b : Int) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) result } @@ -570,7 +576,7 @@ fn chem_substructure_try_match( t_adj : Array[Array[(Int, Int)]], mapping : Array[Int], used : Array[Bool], - i : Int + i : Int, ) -> Bool { if i == qn { return true @@ -616,8 +622,15 @@ fn chem_substructure_try_match( mapping[i] = t used[t] = true if chem_substructure_try_match( - qn, query, target, q_adj, t_adj, mapping, used, i + 1 - ) { + qn, + query, + target, + q_adj, + t_adj, + mapping, + used, + i + 1, + ) { return true } else { mapping[i] = -1 @@ -638,7 +651,7 @@ fn chem_substructure_try_match( /// greedy backtracking search. pub fn chem_substructure_match( query : SdfMolecule, - target : SdfMolecule + target : SdfMolecule, ) -> Bool { let qn = query.n_atoms() let tn = target.n_atoms() @@ -682,7 +695,7 @@ fn chem_trim(s : StringView) -> String { let n = s.length() let mut start = 0 while start < n { - let ch = s[start : start + 1] + let ch = s[start:start + 1] if ch == " " || ch == "\t" || ch == "\r" || ch == "\n" { start = start + 1 } else { @@ -691,7 +704,7 @@ fn chem_trim(s : StringView) -> String { } let mut end = n while end > start { - let ch = s[end - 1 : end] + let ch = s[end - 1:end] if ch == " " || ch == "\t" || ch == "\r" || ch == "\n" { end = end - 1 } else { @@ -763,8 +776,8 @@ pub fn chem_parse_sdf(content : String) -> Array[SdfMolecule] { // Line 4: counts line. let counts_line = lines[idx] idx = idx + 1 - let n_atoms = chem_parse_int_field(counts_line[0 : 3]) - let n_bonds = chem_parse_int_field(counts_line[3 : 6]) + let n_atoms = chem_parse_int_field(counts_line[0:3]) + let n_bonds = chem_parse_int_field(counts_line[3:6]) // Parse atom block. let atoms : Array[SdfAtom] = Array::new() for _ in 0.. Array[SdfMolecule] { let line = lines[idx] idx = idx + 1 // SDF atom line: xxxx.xxxxyyyy.yyyyzzzz.zzzz aaaddcccssshhhbbbvvvHHHrrriiimmmnnneee - let x = chem_parse_double_field(line[0 : 10]) - let y = chem_parse_double_field(line[10 : 20]) - let z = chem_parse_double_field(line[20 : 30]) - let symbol = chem_trim(line[31 : 34]) + let x = chem_parse_double_field(line[0:10]) + let y = chem_parse_double_field(line[10:20]) + let z = chem_parse_double_field(line[20:30]) + let symbol = chem_trim(line[31:34]) // Charge field is at columns 36-38 (0-based from 36). let charge = if line.length() >= 39 { - let c = chem_parse_int_field(line[36 : 39]) + let c = chem_parse_int_field(line[36:39]) // SDF charge encoding: 0=0, 1=+3, 2=+2, 3=+1, 4=0, 5=-1, 6=-2, 7=-3 match c { 1 => 3 @@ -804,9 +817,9 @@ pub fn chem_parse_sdf(content : String) -> Array[SdfMolecule] { } let line = lines[idx] idx = idx + 1 - let a1 = chem_parse_int_field(line[0 : 3]) - 1 // convert 1-based to 0-based - let a2 = chem_parse_int_field(line[3 : 6]) - 1 - let bt = chem_parse_int_field(line[6 : 9]) + let a1 = chem_parse_int_field(line[0:3]) - 1 // convert 1-based to 0-based + let a2 = chem_parse_int_field(line[3:6]) - 1 + let bt = chem_parse_int_field(line[6:9]) bonds.push(SdfBond::new(a1, a2, bt)) } let mol = SdfMolecule::new(name, atoms, bonds) @@ -819,7 +832,7 @@ pub fn chem_parse_sdf(content : String) -> Array[SdfMolecule] { break } // Property line: "> " (or "> " with extra spaces). - if trimmed.length() > 3 && trimmed[0 : 1] == ">" { + if trimmed.length() > 3 && trimmed[0:1] == ">" { // Find the first '<' and the last '>'. let lt_pos = trimmed.find("<") // Find the last '>' by scanning from the end. @@ -827,20 +840,19 @@ pub fn chem_parse_sdf(content : String) -> Array[SdfMolecule] { let tn = trimmed.length() let mut k = tn - 1 while k >= 0 { - if trimmed[k : k + 1] == ">" { + if trimmed[k:k + 1] == ">" { gt_idx = k break } k = k - 1 } let prop_name = match lt_pos { - Some(lt) => { + Some(lt) => if gt_idx > lt + 1 { - trimmed[lt + 1 : gt_idx].to_owned() + trimmed[lt + 1:gt_idx].to_owned() } else { "" } - } None => "" } idx = idx + 1 diff --git a/src/chipseeker.mbt b/src/chipseeker.mbt index 69b8bcaf..8075defe 100644 --- a/src/chipseeker.mbt +++ b/src/chipseeker.mbt @@ -9,16 +9,20 @@ /// Feature assignment uses the ChIPseeker priority order: /// Promoter > 5'UTR > 3'UTR > Exon > Intron > Downstream > Distal Intergenic -///| Length of the 5'UTR / 3'UTR approximation (in bp). +///| +/// Length of the 5'UTR / 3'UTR approximation (in bp). const CS_UTR_LENGTH : Int = 500 -///| Size of each implicit "exon" segment inside the gene body (in bp). +///| +/// Size of each implicit "exon" segment inside the gene body (in bp). const CS_EXON_SIZE : Int = 1000 -///| Size of the downstream region past the gene body (in bp). +///| +/// Size of the downstream region past the gene body (in bp). const CS_DOWNSTREAM_WINDOW : Int = 3000 -///| A ChIP-seq peak (genomic interval). +///| +/// A ChIP-seq peak (genomic interval). pub struct Peak { chr : String start : Int @@ -29,7 +33,9 @@ pub struct Peak { } ///| Construct a Peak. `chr` and `start` are required; all other fields -///| are optional and default to zero (summit=0 means "use peak center"). + +///| +/// are optional and default to zero (summit=0 means "use peak center"). pub fn Peak::new( chr~ : String, start~ : Int, @@ -41,42 +47,50 @@ pub fn Peak::new( Peak::{ chr, start, end, summit, fold_enrichment, p_value } } -///| Get the chromosome of the peak. +///| +/// Get the chromosome of the peak. pub fn Peak::get_chr(self : Peak) -> String { self.chr } -///| Get the start position of the peak. +///| +/// Get the start position of the peak. pub fn Peak::get_start(self : Peak) -> Int { self.start } -///| Get the end position of the peak. +///| +/// Get the end position of the peak. pub fn Peak::get_end(self : Peak) -> Int { self.end } -///| Set the end position of the peak. +///| +/// Set the end position of the peak. pub fn Peak::set_end(self : Peak, new_end : Int) -> Unit { self.end = new_end } -///| Get the summit position of the peak. +///| +/// Get the summit position of the peak. pub fn Peak::get_summit(self : Peak) -> Int { self.summit } -///| Get the fold enrichment of the peak. +///| +/// Get the fold enrichment of the peak. pub fn Peak::get_fold_enrichment(self : Peak) -> Double { self.fold_enrichment } -///| Get the p-value of the peak. +///| +/// Get the p-value of the peak. pub fn Peak::get_p_value(self : Peak) -> Double { self.p_value } -///| A gene annotation record used for peak annotation. +///| +/// A gene annotation record used for peak annotation. pub struct GeneAnnotation { gene_id : String gene_name : String @@ -88,8 +102,11 @@ pub struct GeneAnnotation { } ///| Construct a GeneAnnotation. The TSS is auto-computed from the strand: + ///| "+" strand -> tss = gene_start -///| "-" strand -> tss = gene_end + +///| +/// "-" strand -> tss = gene_end pub fn GeneAnnotation::new( gene_id~ : String, gene_name~ : String, @@ -102,42 +119,50 @@ pub fn GeneAnnotation::new( GeneAnnotation::{ gene_id, gene_name, chr, gene_start, gene_end, strand, tss } } -///| Get the gene id. +///| +/// Get the gene id. pub fn GeneAnnotation::get_gene_id(self : GeneAnnotation) -> String { self.gene_id } -///| Get the gene name. +///| +/// Get the gene name. pub fn GeneAnnotation::get_gene_name(self : GeneAnnotation) -> String { self.gene_name } -///| Get the chromosome. +///| +/// Get the chromosome. pub fn GeneAnnotation::get_chr(self : GeneAnnotation) -> String { self.chr } -///| Get the gene start. +///| +/// Get the gene start. pub fn GeneAnnotation::get_gene_start(self : GeneAnnotation) -> Int { self.gene_start } -///| Get the gene end. +///| +/// Get the gene end. pub fn GeneAnnotation::get_gene_end(self : GeneAnnotation) -> Int { self.gene_end } -///| Get the strand. +///| +/// Get the strand. pub fn GeneAnnotation::get_strand(self : GeneAnnotation) -> String { self.strand } -///| Get the transcription start site (TSS). +///| +/// Get the transcription start site (TSS). pub fn GeneAnnotation::get_tss(self : GeneAnnotation) -> Int { self.tss } -///| The result of annotating a single peak. +///| +/// The result of annotating a single peak. pub struct PeakAnnotation { peak : Peak gene_id : String @@ -149,7 +174,8 @@ pub struct PeakAnnotation { annotation : String // detailed annotation string } -///| Construct a PeakAnnotation. +///| +/// Construct a PeakAnnotation. pub fn PeakAnnotation::new( peak~ : Peak, gene_id~ : String, @@ -172,47 +198,56 @@ pub fn PeakAnnotation::new( } } -///| Get the peak. +///| +/// Get the peak. pub fn PeakAnnotation::get_peak(self : PeakAnnotation) -> Peak { self.peak } -///| Get the gene id. +///| +/// Get the gene id. pub fn PeakAnnotation::get_gene_id(self : PeakAnnotation) -> String { self.gene_id } -///| Get the gene name. +///| +/// Get the gene name. pub fn PeakAnnotation::get_gene_name(self : PeakAnnotation) -> String { self.gene_name } -///| Get the chromosome. +///| +/// Get the chromosome. pub fn PeakAnnotation::get_chr(self : PeakAnnotation) -> String { self.chr } -///| Get the TSS. +///| +/// Get the TSS. pub fn PeakAnnotation::get_tss(self : PeakAnnotation) -> Int { self.tss } -///| Get the signed distance to TSS. +///| +/// Get the signed distance to TSS. pub fn PeakAnnotation::get_distance_to_tss(self : PeakAnnotation) -> Int { self.distance_to_tss } -///| Get the assigned feature string. +///| +/// Get the assigned feature string. pub fn PeakAnnotation::get_feature(self : PeakAnnotation) -> String { self.feature } -///| Get the detailed annotation string. +///| +/// Get the detailed annotation string. pub fn PeakAnnotation::get_annotation(self : PeakAnnotation) -> String { self.annotation } -///| Summary counts of peaks assigned to each feature type. +///| +/// Summary counts of peaks assigned to each feature type. pub struct AnnotationSummary { total_peaks : Int promoter : Int @@ -224,7 +259,8 @@ pub struct AnnotationSummary { distal_intergenic : Int } -///| Construct an AnnotationSummary. +///| +/// Construct an AnnotationSummary. pub fn AnnotationSummary::new( total_peaks~ : Int, promoter~ : Int, @@ -247,48 +283,60 @@ pub fn AnnotationSummary::new( } } -///| Get total peaks. +///| +/// Get total peaks. pub fn AnnotationSummary::get_total_peaks(self : AnnotationSummary) -> Int { self.total_peaks } -///| Get promoter count. +///| +/// Get promoter count. pub fn AnnotationSummary::get_promoter(self : AnnotationSummary) -> Int { self.promoter } -///| Get 5'UTR count. +///| +/// Get 5'UTR count. pub fn AnnotationSummary::get_utr5(self : AnnotationSummary) -> Int { self.utr5 } -///| Get 3'UTR count. +///| +/// Get 3'UTR count. pub fn AnnotationSummary::get_utr3(self : AnnotationSummary) -> Int { self.utr3 } -///| Get exon count. +///| +/// Get exon count. pub fn AnnotationSummary::get_exon(self : AnnotationSummary) -> Int { self.exon } -///| Get intron count. +///| +/// Get intron count. pub fn AnnotationSummary::get_intron(self : AnnotationSummary) -> Int { self.intron } -///| Get downstream count. +///| +/// Get downstream count. pub fn AnnotationSummary::get_downstream(self : AnnotationSummary) -> Int { self.downstream } -///| Get distal intergenic count. -pub fn AnnotationSummary::get_distal_intergenic(self : AnnotationSummary) -> Int { +///| +/// Get distal intergenic count. +pub fn AnnotationSummary::get_distal_intergenic( + self : AnnotationSummary, +) -> Int { self.distal_intergenic } ///| Compute the effective single position used for a peak. Uses the summit -///| if it is non-zero, otherwise the midpoint of [start, end]. + +///| +/// if it is non-zero, otherwise the midpoint of [start, end]. pub fn cs_peak_position(peak : Peak) -> Int { if peak.summit != 0 { peak.summit @@ -298,7 +346,9 @@ pub fn cs_peak_position(peak : Peak) -> Int { } ///| Build a sentinel "no gene" annotation. Used when no gene is found on -///| the same chromosome as the peak. + +///| +/// the same chromosome as the peak. fn cs_na_gene(chr : String) -> GeneAnnotation { GeneAnnotation::{ gene_id: "", @@ -312,10 +362,15 @@ fn cs_na_gene(chr : String) -> GeneAnnotation { } ///| Compute the signed distance from a peak to a gene's TSS. + ///| + ///| Positive distance means the peak is downstream of the TSS (in the + ///| transcription direction); negative means upstream. For "-" strand -///| genes the orientation is flipped so the sign convention still holds. + +///| +/// genes the orientation is flipped so the sign convention still holds. pub fn compute_tss_distance(peak : Peak, gene : GeneAnnotation) -> Int { if gene.gene_id == "" { return 0 @@ -329,8 +384,11 @@ pub fn compute_tss_distance(peak : Peak, gene : GeneAnnotation) -> Int { } ///| Find the gene whose TSS is closest to the peak. Only genes on the same + ///| chromosome as the peak are considered. If no such gene exists, a -///| sentinel annotation with empty `gene_id` is returned. + +///| +/// sentinel annotation with empty `gene_id` is returned. pub fn find_nearest_gene( peak : Peak, genes : Array[GeneAnnotation], @@ -354,8 +412,11 @@ pub fn find_nearest_gene( } ///| Assign a genomic feature to a peak relative to a gene, following the + ///| ChIPseeker priority: -///| Promoter > 5'UTR > 3'UTR > Exon > Intron > Downstream > Distal Intergenic + +///| +/// Promoter > 5'UTR > 3'UTR > Exon > Intron > Downstream > Distal Intergenic pub fn assign_feature( peak : Peak, gene : GeneAnnotation, @@ -377,7 +438,20 @@ pub fn assign_feature( // the middle of the gene body. let utr_len = CS_UTR_LENGTH let exon_size = CS_EXON_SIZE - let (utr5_start, utr5_end, utr3_start, utr3_end, exon1_start, exon1_end, exon2_start, exon2_end, intron_start, intron_end, down_start, down_end) = if gene.strand == "-" { + let ( + utr5_start, + utr5_end, + utr3_start, + utr3_end, + exon1_start, + exon1_end, + exon2_start, + exon2_end, + intron_start, + intron_end, + down_start, + down_end, + ) = if gene.strand == "-" { // "-" strand: TSS = gene_end; transcription proceeds toward gene_start. let utr5_s = gene.gene_end - utr_len let utr5_e = gene.gene_end @@ -392,18 +466,8 @@ pub fn assign_feature( let down_s = gene.gene_start - CS_DOWNSTREAM_WINDOW let down_e = gene.gene_start ( - utr5_s, - utr5_e, - utr3_s, - utr3_e, - exon1_s, - exon1_e, - exon2_s, - exon2_e, - intron_s, - intron_e, - down_s, - down_e, + utr5_s, utr5_e, utr3_s, utr3_e, exon1_s, exon1_e, exon2_s, exon2_e, intron_s, + intron_e, down_s, down_e, ) } else { // "+" strand: TSS = gene_start; transcription proceeds toward gene_end. @@ -420,18 +484,8 @@ pub fn assign_feature( let down_s = gene.gene_end let down_e = gene.gene_end + CS_DOWNSTREAM_WINDOW ( - utr5_s, - utr5_e, - utr3_s, - utr3_e, - exon1_s, - exon1_e, - exon2_s, - exon2_e, - intron_s, - intron_e, - down_s, - down_e, + utr5_s, utr5_e, utr3_s, utr3_e, exon1_s, exon1_e, exon2_s, exon2_e, intron_s, + intron_e, down_s, down_e, ) } // 2. 5'UTR @@ -444,7 +498,7 @@ pub fn assign_feature( } // 4. Exon (either of the two implicit exon segments) if (peak_pos >= exon1_start && peak_pos <= exon1_end) || - (peak_pos >= exon2_start && peak_pos <= exon2_end) { + (peak_pos >= exon2_start && peak_pos <= exon2_end) { return "Exon" } // 5. Intron @@ -459,7 +513,8 @@ pub fn assign_feature( "Distal Intergenic" } -///| Format the detailed annotation string for a peak/gene/feature triple. +///| +/// Format the detailed annotation string for a peak/gene/feature triple. fn cs_format_annotation( gene : GeneAnnotation, distance : Int, @@ -475,19 +530,21 @@ fn cs_format_annotation( "Intron" => "Intron of \{gene.gene_name}" "Downstream" => "Downstream (<=\{CS_DOWNSTREAM_WINDOW}bp) of \{gene.gene_name}" - _ => { + _ => if gene.gene_id == "" { "Distal Intergenic (no nearby gene on same chromosome)" } else { "Distal Intergenic (nearest gene: \{gene.gene_name}, distance to TSS: \{distance})" } - } } } ///| Annotate a single peak: find the nearest gene, compute the signed + ///| distance to its TSS, assign a genomic feature, and build the detailed -///| annotation string. + +///| +/// annotation string. pub fn annotate_peak( peak : Peak, genes : Array[GeneAnnotation], @@ -496,20 +553,23 @@ pub fn annotate_peak( let gene = find_nearest_gene(peak, genes) let distance = compute_tss_distance(peak, gene) let feature = assign_feature(peak, gene, promoter_window) - let annotation = cs_format_annotation(gene, distance, feature, promoter_window) + let annotation = cs_format_annotation( + gene, distance, feature, promoter_window, + ) PeakAnnotation::new( - peak=peak, + peak~, gene_id=gene.gene_id, gene_name=gene.gene_name, chr=peak.chr, tss=gene.tss, distance_to_tss=distance, - feature=feature, - annotation=annotation, + feature~, + annotation~, ) } -///| Annotate a collection of peaks against a set of gene annotations. +///| +/// Annotate a collection of peaks against a set of gene annotations. pub fn annotate_peaks( peaks : Array[Peak], genes : Array[GeneAnnotation], @@ -522,7 +582,8 @@ pub fn annotate_peaks( result } -///| Tally the feature assignments of a list of peak annotations. +///| +/// Tally the feature assignments of a list of peak annotations. pub fn annotation_summary( annotations : Array[PeakAnnotation], ) -> AnnotationSummary { @@ -547,17 +608,18 @@ pub fn annotation_summary( } AnnotationSummary::new( total_peaks=annotations.length(), - promoter=promoter, - utr5=utr5, - utr3=utr3, - exon=exon, - intron=intron, - downstream=downstream, - distal_intergenic=distal_intergenic, + promoter~, + utr5~, + utr3~, + exon~, + intron~, + downstream~, + distal_intergenic~, ) } -///| Return only those annotations whose feature matches `feature`. +///| +/// Return only those annotations whose feature matches `feature`. pub fn filter_by_feature( annotations : Array[PeakAnnotation], feature : String, @@ -572,7 +634,9 @@ pub fn filter_by_feature( } ///| Return only those annotations whose absolute distance to TSS is at -///| most `max_distance`. + +///| +/// most `max_distance`. pub fn filter_by_distance( annotations : Array[PeakAnnotation], max_distance : Int, @@ -586,7 +650,8 @@ pub fn filter_by_distance( result } -///| Format an AnnotationSummary as a human-readable string. +///| +/// Format an AnnotationSummary as a human-readable string. pub fn chipseeker_summary_string(summary : AnnotationSummary) -> String { let mut s = "ChIPseeker Annotation Summary\n" s = s + "=============================\n" @@ -602,10 +667,15 @@ pub fn chipseeker_summary_string(summary : AnnotationSummary) -> String { } ///| Sample ChIP-seq peaks for testing and demonstration. The peaks are + ///| laid out so that, when annotated against `chipseeker_sample_genes()` + ///| with the default promoter window (3000), they exercise every feature + ///| type except 5'UTR (which is only reachable with a smaller window -///| because the 5'UTR sits inside the default promoter window). + +///| +/// because the 5'UTR sits inside the default promoter window). pub fn chipseeker_sample_peaks() -> Array[Peak] { [ // chr1, GeneA (+ strand, TSS=10000, gene_end=25000) @@ -629,7 +699,8 @@ pub fn chipseeker_sample_peaks() -> Array[Peak] { ] } -///| Sample gene annotations for testing and demonstration. +///| +/// Sample gene annotations for testing and demonstration. pub fn chipseeker_sample_genes() -> Array[GeneAnnotation] { [ GeneAnnotation::new( diff --git a/src/chromosome_visualization.mbt b/src/chromosome_visualization.mbt index b8c5521a..9b4fc22c 100644 --- a/src/chromosome_visualization.mbt +++ b/src/chromosome_visualization.mbt @@ -20,15 +20,21 @@ pub enum ChrOrientation { ///| /// Create a Forward orientation. -pub fn chr_orientation_forward() -> ChrOrientation { Forward } +pub fn chr_orientation_forward() -> ChrOrientation { + Forward +} ///| /// Create a Reverse orientation. -pub fn chr_orientation_reverse() -> ChrOrientation { Reverse } +pub fn chr_orientation_reverse() -> ChrOrientation { + Reverse +} ///| /// Create a None orientation. -pub fn chr_orientation_none() -> ChrOrientation { None } +pub fn chr_orientation_none() -> ChrOrientation { + None +} ///| /// Type of a genomic feature. @@ -47,27 +53,39 @@ pub enum ChrFeatureType { ///| /// Create a Gene feature type. -pub fn chr_feature_type_gene() -> ChrFeatureType { Gene } +pub fn chr_feature_type_gene() -> ChrFeatureType { + Gene +} ///| /// Create an Exon feature type. -pub fn chr_feature_type_exon() -> ChrFeatureType { Exon } +pub fn chr_feature_type_exon() -> ChrFeatureType { + Exon +} ///| /// Create an Intron feature type. -pub fn chr_feature_type_intron() -> ChrFeatureType { Intron } +pub fn chr_feature_type_intron() -> ChrFeatureType { + Intron +} ///| /// Create a CDS feature type. -pub fn chr_feature_type_cds() -> ChrFeatureType { CDS } +pub fn chr_feature_type_cds() -> ChrFeatureType { + CDS +} ///| /// Create a UTR feature type. -pub fn chr_feature_type_utr() -> ChrFeatureType { UTR } +pub fn chr_feature_type_utr() -> ChrFeatureType { + UTR +} ///| /// Create a Promoter feature type. -pub fn chr_feature_type_promoter() -> ChrFeatureType { Promoter } +pub fn chr_feature_type_promoter() -> ChrFeatureType { + Promoter +} ///| /// A genomic feature on a chromosome. @@ -172,7 +190,11 @@ pub fn ChrFeature::new( orientation, feature_type, color, - label: if label.length() > 0 { label } else { name }, + label: if label.length() > 0 { + label + } else { + name + }, height, } } @@ -193,7 +215,11 @@ pub fn ChrRegion::new( end, color, opacity, - label: if label.length() > 0 { label } else { name }, + label: if label.length() > 0 { + label + } else { + name + }, } } @@ -255,12 +281,7 @@ pub fn ChrDiagram::new( layout? : ChrLayout = ChrLayout::new(), title? : String = "", ) -> ChrDiagram { - ChrDiagram::{ - chromosomes, - layout, - title, - svg_elements: [], - } + ChrDiagram::{ chromosomes, layout, title, svg_elements: [] } } // ============================================================================ @@ -269,7 +290,10 @@ pub fn ChrDiagram::new( ///| /// Add a feature to a chromosome. -pub fn Chromosome::add_feature(self : Chromosome, feature : ChrFeature) -> Chromosome { +pub fn Chromosome::add_feature( + self : Chromosome, + feature : ChrFeature, +) -> Chromosome { let new_features = self.features.copy() new_features.push(feature) Chromosome::{ @@ -285,7 +309,10 @@ pub fn Chromosome::add_feature(self : Chromosome, feature : ChrFeature) -> Chrom ///| /// Add a region to a chromosome. -pub fn Chromosome::add_region(self : Chromosome, region : ChrRegion) -> Chromosome { +pub fn Chromosome::add_region( + self : Chromosome, + region : ChrRegion, +) -> Chromosome { let new_regions = self.regions.copy() new_regions.push(region) Chromosome::{ @@ -375,24 +402,38 @@ pub fn chr_band_color(stain : String) -> String { ///| /// Helper: max of two doubles. fn chr_max(a : Double, b : Double) -> Double { - if a > b { a } else { b } + if a > b { + a + } else { + b + } } ///| /// Helper: min of two doubles. fn chr_min(a : Double, b : Double) -> Double { - if a < b { a } else { b } + if a < b { + a + } else { + b + } } ///| /// Helper: abs of double. fn chr_abs(x : Double) -> Double { - if x < 0.0 { -x } else { x } + if x < 0.0 { + -x + } else { + x + } } ///| /// Helper: PI constant. -fn chr_pi() -> Double { 3.14159265358979323846 } +fn chr_pi() -> Double { + 3.14159265358979323846 +} ///| /// Helper: create SVG attributes map. @@ -417,12 +458,7 @@ fn chr_svg_elem( content : String, children : Array[ChrSVGElement], ) -> ChrSVGElement { - ChrSVGElement::{ - element_type, - attributes, - content, - children, - } + ChrSVGElement::{ element_type, attributes, content, children } } ///| @@ -440,32 +476,42 @@ pub fn chr_chromosome_to_svg( let chrom_length = chr.length * scale // Chromosome body - let body_rect = chr_svg_elem("rect", chr_svg_attrs([ - ("x", (x_offset).to_string()), - ("y", (y_offset - thickness / 2.0).to_string()), - ("width", chrom_length.to_string()), - ("height", thickness.to_string()), - ("fill", "#E0E0E0"), - ("stroke", "#333333"), - ("stroke-width", "1"), - ("rx", "3"), - ("ry", "3"), - ]), "", []) + let body_rect = chr_svg_elem( + "rect", + chr_svg_attrs([ + ("x", x_offset.to_string()), + ("y", (y_offset - thickness / 2.0).to_string()), + ("width", chrom_length.to_string()), + ("height", thickness.to_string()), + ("fill", "#E0E0E0"), + ("stroke", "#333333"), + ("stroke-width", "1"), + ("rx", "3"), + ("ry", "3"), + ]), + "", + [], + ) elements.push(body_rect) // Centromere if layout.show_centromere && chr.centromere_pos > 0.0 { let cen_x = x_offset + chr.centromere_pos * scale let cen_width = thickness * 1.5 - let centromere = chr_svg_elem("ellipse", chr_svg_attrs([ - ("cx", cen_x.to_string()), - ("cy", y_offset.to_string()), - ("rx", (cen_width / 2.0).to_string()), - ("ry", (thickness / 2.0 + 2.0).to_string()), - ("fill", "#CC0000"), - ("stroke", "#990000"), - ("stroke-width", "1"), - ]), "", []) + let centromere = chr_svg_elem( + "ellipse", + chr_svg_attrs([ + ("cx", cen_x.to_string()), + ("cy", y_offset.to_string()), + ("rx", (cen_width / 2.0).to_string()), + ("ry", (thickness / 2.0 + 2.0).to_string()), + ("fill", "#CC0000"), + ("stroke", "#990000"), + ("stroke-width", "1"), + ]), + "", + [], + ) elements.push(centromere) } @@ -476,14 +522,19 @@ pub fn chr_chromosome_to_svg( let bx = x_offset + bstart * scale let bw = (bend - bstart) * scale let color = chr_band_color(stain) - let band_elem = chr_svg_elem("rect", chr_svg_attrs([ - ("x", bx.to_string()), - ("y", (y_offset - thickness / 2.0).to_string()), - ("width", bw.to_string()), - ("height", thickness.to_string()), - ("fill", color), - ("stroke", "none"), - ]), "", []) + let band_elem = chr_svg_elem( + "rect", + chr_svg_attrs([ + ("x", bx.to_string()), + ("y", (y_offset - thickness / 2.0).to_string()), + ("width", bw.to_string()), + ("height", thickness.to_string()), + ("fill", color), + ("stroke", "none"), + ]), + "", + [], + ) elements.push(band_elem) } } @@ -501,51 +552,70 @@ pub fn chr_chromosome_to_svg( if feat.orientation == Forward { // Arrow pointing right let poly_points = [ - (fx).to_string() + "," + (y_offset - fh / 2.0).to_string(), - (fx + fw - arrow_size).to_string() + "," + (y_offset - fh / 2.0).to_string(), - (fx + fw).to_string() + "," + (y_offset).to_string(), - (fx + fw - arrow_size).to_string() + "," + (y_offset + fh / 2.0).to_string(), - (fx).to_string() + "," + (y_offset + fh / 2.0).to_string(), + fx.to_string() + "," + (y_offset - fh / 2.0).to_string(), + (fx + fw - arrow_size).to_string() + + "," + + (y_offset - fh / 2.0).to_string(), + (fx + fw).to_string() + "," + y_offset.to_string(), + (fx + fw - arrow_size).to_string() + + "," + + (y_offset + fh / 2.0).to_string(), + fx.to_string() + "," + (y_offset + fh / 2.0).to_string(), ] let points_str = poly_points.join(" ") - let feat_elem = chr_svg_elem("polygon", chr_svg_attrs([ - ("points", points_str), - ("fill", feat_color), - ("stroke", "#333333"), - ("stroke-width", "0.5"), - ("opacity", "0.8"), - ]), "", []) + let feat_elem = chr_svg_elem( + "polygon", + chr_svg_attrs([ + ("points", points_str), + ("fill", feat_color), + ("stroke", "#333333"), + ("stroke-width", "0.5"), + ("opacity", "0.8"), + ]), + "", + [], + ) elements.push(feat_elem) } else if feat.orientation == Reverse { // Arrow pointing left let poly_points = [ (fx + fw).to_string() + "," + (y_offset - fh / 2.0).to_string(), (fx + arrow_size).to_string() + "," + (y_offset - fh / 2.0).to_string(), - (fx).to_string() + "," + (y_offset).to_string(), + fx.to_string() + "," + y_offset.to_string(), (fx + arrow_size).to_string() + "," + (y_offset + fh / 2.0).to_string(), (fx + fw).to_string() + "," + (y_offset + fh / 2.0).to_string(), ] let points_str = poly_points.join(" ") - let feat_elem = chr_svg_elem("polygon", chr_svg_attrs([ - ("points", points_str), - ("fill", feat_color), - ("stroke", "#333333"), - ("stroke-width", "0.5"), - ("opacity", "0.8"), - ]), "", []) + let feat_elem = chr_svg_elem( + "polygon", + chr_svg_attrs([ + ("points", points_str), + ("fill", feat_color), + ("stroke", "#333333"), + ("stroke-width", "0.5"), + ("opacity", "0.8"), + ]), + "", + [], + ) elements.push(feat_elem) } else { // No orientation - rectangle - let feat_elem = chr_svg_elem("rect", chr_svg_attrs([ - ("x", fx.to_string()), - ("y", (y_offset - fh / 2.0).to_string()), - ("width", fw.to_string()), - ("height", fh.to_string()), - ("fill", feat_color), - ("stroke", "#333333"), - ("stroke-width", "0.5"), - ("opacity", "0.8"), - ]), "", []) + let feat_elem = chr_svg_elem( + "rect", + chr_svg_attrs([ + ("x", fx.to_string()), + ("y", (y_offset - fh / 2.0).to_string()), + ("width", fw.to_string()), + ("height", fh.to_string()), + ("fill", feat_color), + ("stroke", "#333333"), + ("stroke-width", "0.5"), + ("opacity", "0.8"), + ]), + "", + [], + ) elements.push(feat_elem) } @@ -553,13 +623,18 @@ pub fn chr_chromosome_to_svg( if layout.show_labels && feat.label.length() > 0 { let label_x = fx + fw / 2.0 let label_y = y_offset - thickness / 2.0 - 4.0 - let text_elem = chr_svg_elem("text", chr_svg_attrs([ - ("x", label_x.to_string()), - ("y", label_y.to_string()), - ("font-size", layout.label_font_size.to_string()), - ("text-anchor", "middle"), - ("fill", "#333333"), - ]), feat.label, []) + let text_elem = chr_svg_elem( + "text", + chr_svg_attrs([ + ("x", label_x.to_string()), + ("y", label_y.to_string()), + ("font-size", layout.label_font_size.to_string()), + ("text-anchor", "middle"), + ("fill", "#333333"), + ]), + feat.label, + [], + ) elements.push(text_elem) } } @@ -568,30 +643,40 @@ pub fn chr_chromosome_to_svg( for region in chr.regions { let rx = x_offset + region.start * scale let rw = (region.end - region.start) * scale - let region_elem = chr_svg_elem("rect", chr_svg_attrs([ - ("x", rx.to_string()), - ("y", (y_offset - thickness / 2.0 - 15.0).to_string()), - ("width", rw.to_string()), - ("height", (thickness + 30.0 + 15.0).to_string()), - ("fill", region.color), - ("opacity", region.opacity.to_string()), - ("stroke", region.color), - ("stroke-width", "2"), - ("rx", "2"), - ("ry", "2"), - ]), "", []) + let region_elem = chr_svg_elem( + "rect", + chr_svg_attrs([ + ("x", rx.to_string()), + ("y", (y_offset - thickness / 2.0 - 15.0).to_string()), + ("width", rw.to_string()), + ("height", (thickness + 30.0 + 15.0).to_string()), + ("fill", region.color), + ("opacity", region.opacity.to_string()), + ("stroke", region.color), + ("stroke-width", "2"), + ("rx", "2"), + ("ry", "2"), + ]), + "", + [], + ) elements.push(region_elem) if layout.show_labels && region.label.length() > 0 { let label_x = rx + rw / 2.0 let label_y = y_offset - thickness / 2.0 - 8.0 - let text_elem = chr_svg_elem("text", chr_svg_attrs([ - ("x", label_x.to_string()), - ("y", label_y.to_string()), - ("font-size", (layout.label_font_size - 2.0).to_string()), - ("text-anchor", "middle"), - ("fill", "#666666"), - ]), region.label, []) + let text_elem = chr_svg_elem( + "text", + chr_svg_attrs([ + ("x", label_x.to_string()), + ("y", label_y.to_string()), + ("font-size", (layout.label_font_size - 2.0).to_string()), + ("text-anchor", "middle"), + ("fill", "#666666"), + ]), + region.label, + [], + ) elements.push(text_elem) } } @@ -599,14 +684,19 @@ pub fn chr_chromosome_to_svg( // Chromosome name label let name_x = x_offset - 10.0 let name_y = y_offset + 4.0 - let name_elem = chr_svg_elem("text", chr_svg_attrs([ - ("x", name_x.to_string()), - ("y", name_y.to_string()), - ("font-size", (layout.label_font_size + 2.0).to_string()), - ("text-anchor", "end"), - ("font-weight", "bold"), - ("fill", "#333333"), - ]), chr.name, []) + let name_elem = chr_svg_elem( + "text", + chr_svg_attrs([ + ("x", name_x.to_string()), + ("y", name_y.to_string()), + ("font-size", (layout.label_font_size + 2.0).to_string()), + ("text-anchor", "end"), + ("font-weight", "bold"), + ("fill", "#333333"), + ]), + chr.name, + [], + ) elements.push(name_elem) elements @@ -627,20 +717,25 @@ pub fn chr_circular_chromosome_to_svg( // Chromosome circle let _circumference = chr.length * scale let r = radius - let chr_circle = chr_svg_elem("circle", chr_svg_attrs([ - ("cx", cx.to_string()), - ("cy", cy.to_string()), - ("r", r.to_string()), - ("fill", "none"), - ("stroke", "#E0E0E0"), - ("stroke-width", (layout.chromosome_thickness).to_string()), - ]), "", []) + let chr_circle = chr_svg_elem( + "circle", + chr_svg_attrs([ + ("cx", cx.to_string()), + ("cy", cy.to_string()), + ("r", r.to_string()), + ("fill", "none"), + ("stroke", "#E0E0E0"), + ("stroke-width", layout.chromosome_thickness.to_string()), + ]), + "", + [], + ) elements.push(chr_circle) // Features as arcs for feat in chr.features { - let start_angle = (feat.start / chr.length) * 2.0 * chr_pi() - let end_angle = (feat.end / chr.length) * 2.0 * chr_pi() + let start_angle = feat.start / chr.length * 2.0 * chr_pi() + let end_angle = feat.end / chr.length * 2.0 * chr_pi() let x1 = cx + r * @math.cos(start_angle) let y1 = cy + r * @math.sin(start_angle) @@ -650,45 +745,75 @@ pub fn chr_circular_chromosome_to_svg( let large_arc = if end_angle - start_angle > chr_pi() { 1 } else { 0 } let sweep = 1 - let d = "M " + x1.to_string() + " " + y1.to_string() + - " A " + r.to_string() + " " + r.to_string() + - " 0 " + large_arc.to_string() + " " + sweep.to_string() + - " " + x2.to_string() + " " + y2.to_string() - - let arc_elem = chr_svg_elem("path", chr_svg_attrs([ - ("d", d), - ("fill", "none"), - ("stroke", feat.color), - ("stroke-width", (layout.chromosome_thickness * feat.height).to_string()), - ("opacity", "0.8"), - ]), "", []) + let d = "M " + + x1.to_string() + + " " + + y1.to_string() + + " A " + + r.to_string() + + " " + + r.to_string() + + " 0 " + + large_arc.to_string() + + " " + + sweep.to_string() + + " " + + x2.to_string() + + " " + + y2.to_string() + + let arc_elem = chr_svg_elem( + "path", + chr_svg_attrs([ + ("d", d), + ("fill", "none"), + ("stroke", feat.color), + ( + "stroke-width", + (layout.chromosome_thickness * feat.height).to_string(), + ), + ("opacity", "0.8"), + ]), + "", + [], + ) elements.push(arc_elem) } // Centromere if chr.centromere_pos > 0.0 { - let cen_angle = (chr.centromere_pos / chr.length) * 2.0 * chr_pi() + let cen_angle = chr.centromere_pos / chr.length * 2.0 * chr_pi() let cen_x = cx + r * @math.cos(cen_angle) let cen_y = cy + r * @math.sin(cen_angle) - let cen_elem = chr_svg_elem("circle", chr_svg_attrs([ - ("cx", cen_x.to_string()), - ("cy", cen_y.to_string()), - ("r", (layout.chromosome_thickness / 2.0 + 3.0).to_string()), - ("fill", "#CC0000"), - ]), "", []) + let cen_elem = chr_svg_elem( + "circle", + chr_svg_attrs([ + ("cx", cen_x.to_string()), + ("cy", cen_y.to_string()), + ("r", (layout.chromosome_thickness / 2.0 + 3.0).to_string()), + ("fill", "#CC0000"), + ]), + "", + [], + ) elements.push(cen_elem) } // Chromosome name at center if layout.show_labels { - let name_elem = chr_svg_elem("text", chr_svg_attrs([ - ("x", cx.to_string()), - ("y", cy.to_string()), - ("font-size", (layout.label_font_size + 4.0).to_string()), - ("text-anchor", "middle"), - ("font-weight", "bold"), - ("fill", "#333333"), - ]), chr.name, []) + let name_elem = chr_svg_elem( + "text", + chr_svg_attrs([ + ("x", cx.to_string()), + ("y", cy.to_string()), + ("font-size", (layout.label_font_size + 4.0).to_string()), + ("text-anchor", "middle"), + ("font-weight", "bold"), + ("fill", "#333333"), + ]), + chr.name, + [], + ) elements.push(name_elem) } @@ -708,7 +833,9 @@ pub fn ChrSVGElement::to_svg(self : ChrSVGElement) -> String { } let mut result = "<" + self.element_type + attrs - if self.element_type == "text" || self.element_type == "title" || self.element_type == "desc" { + if self.element_type == "text" || + self.element_type == "title" || + self.element_type == "desc" { result = result + ">" + self.content + "" } else if self.children.length() > 0 { result = result + ">" @@ -734,23 +861,35 @@ pub fn ChrDiagram::to_svg(self : ChrDiagram) -> String { let scale = if max_length > 0.0 { available_width / max_length } else { 1.0 } // Calculate spacing - let total_height_needed = n_chr.to_double() * (layout.chromosome_thickness + 80.0) - let available_height = layout.height - layout.margin_top - layout.margin_bottom - let y_spacing = if n_chr > 0 { available_height / (n_chr + 1).to_double() } else { 50.0 } + let total_height_needed = n_chr.to_double() * + (layout.chromosome_thickness + 80.0) + let available_height = layout.height - + layout.margin_top - + layout.margin_bottom + let y_spacing = if n_chr > 0 { + available_height / (n_chr + 1).to_double() + } else { + 50.0 + } // Build SVG elements let svg_children : Array[ChrSVGElement] = [] // Title if self.title.length() > 0 { - let title_elem = chr_svg_elem("text", chr_svg_attrs([ - ("x", (layout.width / 2.0).to_string()), - ("y", (25.0).to_string()), - ("font-size", "18"), - ("text-anchor", "middle"), - ("font-weight", "bold"), - ("fill", "#333333"), - ]), self.title, []) + let title_elem = chr_svg_elem( + "text", + chr_svg_attrs([ + ("x", (layout.width / 2.0).to_string()), + ("y", 25.0.to_string()), + ("font-size", "18"), + ("text-anchor", "middle"), + ("font-weight", "bold"), + ("fill", "#333333"), + ]), + self.title, + [], + ) svg_children.push(title_elem) } @@ -765,12 +904,16 @@ pub fn ChrDiagram::to_svg(self : ChrDiagram) -> String { let radius = layout.chromosome_thickness * 8.0 let cx = x_offset + radius + 20.0 let cy = y_offset - let chr_elements = chr_circular_chromosome_to_svg(chr, layout, cx, cy, radius, scale) + let chr_elements = chr_circular_chromosome_to_svg( + chr, layout, cx, cy, radius, scale, + ) for elem in chr_elements { svg_children.push(elem) } } else { - let chr_elements = chr_chromosome_to_svg(chr, layout, x_offset, y_offset, scale) + let chr_elements = chr_chromosome_to_svg( + chr, layout, x_offset, y_offset, scale, + ) for elem in chr_elements { svg_children.push(elem) } @@ -780,10 +923,14 @@ pub fn ChrDiagram::to_svg(self : ChrDiagram) -> String { // SVG root element let svg_open = "" + layout.width.to_string() + + "\" height=\"" + + layout.height.to_string() + + "\" viewBox=\"0 0 " + + layout.width.to_string() + + " " + + layout.height.to_string() + + "\">" let mut svg_content = "" for child in svg_children { @@ -823,25 +970,106 @@ pub fn chr_create_human_karyotype() -> ChrDiagram { let chromosomes : Array[Chromosome] = [] // Add a sample chromosome 1 - let chr1 = Chromosome::new(name="chr1", length=248956422.0, centromere_pos=121535434.0) - let chr1 = chr1.add_feature(ChrFeature::new(name="BRCA2", start=32300000.0, end=32400268.0, orientation=Forward, feature_type=ChrFeatureType::Gene, color="#FF6B6B", label="BRCA2")) - let chr1 = chr1.add_feature(ChrFeature::new(name="DMD", start=31100000.0, end=33300000.0, orientation=Forward, feature_type=ChrFeatureType::Gene, color="#4ECDC4", label="DMD")) - let chr1 = chr1.add_region(ChrRegion::new(name="BRCA1 region", start=43000000.0, end=43200000.0, color="#FFE66D", opacity=0.3, label="BRCA1 locus")) + let chr1 = Chromosome::new( + name="chr1", + length=248956422.0, + centromere_pos=121535434.0, + ) + let chr1 = chr1.add_feature( + ChrFeature::new( + name="BRCA2", + start=32300000.0, + end=32400268.0, + orientation=Forward, + feature_type=ChrFeatureType::Gene, + color="#FF6B6B", + label="BRCA2", + ), + ) + let chr1 = chr1.add_feature( + ChrFeature::new( + name="DMD", + start=31100000.0, + end=33300000.0, + orientation=Forward, + feature_type=ChrFeatureType::Gene, + color="#4ECDC4", + label="DMD", + ), + ) + let chr1 = chr1.add_region( + ChrRegion::new( + name="BRCA1 region", + start=43000000.0, + end=43200000.0, + color="#FFE66D", + opacity=0.3, + label="BRCA1 locus", + ), + ) chromosomes.push(chr1) // Add chromosome 7 - let chr7 = Chromosome::new(name="chr7", length=159345973.0, centromere_pos=54495348.0) - let chr7 = chr7.add_feature(ChrFeature::new(name="EGFR", start=55086714.0, end=55275019.0, orientation=Forward, feature_type=ChrFeatureType::Gene, color="#95E1D3", label="EGFR")) - let chr7 = chr7.add_feature(ChrFeature::new(name="CFTR", start=117287160.0, end=117595905.0, orientation=Reverse, feature_type=ChrFeatureType::Gene, color="#F38181", label="CFTR")) + let chr7 = Chromosome::new( + name="chr7", + length=159345973.0, + centromere_pos=54495348.0, + ) + let chr7 = chr7.add_feature( + ChrFeature::new( + name="EGFR", + start=55086714.0, + end=55275019.0, + orientation=Forward, + feature_type=ChrFeatureType::Gene, + color="#95E1D3", + label="EGFR", + ), + ) + let chr7 = chr7.add_feature( + ChrFeature::new( + name="CFTR", + start=117287160.0, + end=117595905.0, + orientation=Reverse, + feature_type=ChrFeatureType::Gene, + color="#F38181", + label="CFTR", + ), + ) chromosomes.push(chr7) // Add chromosome 11 - let chr11 = Chromosome::new(name="chr11", length=135086622.0, centromere_pos=51000000.0) - let chr11 = chr11.add_feature(ChrFeature::new(name="INS", start=2159000.0, end=2164000.0, orientation=Forward, feature_type=ChrFeatureType::Gene, color="#AA96DA", label="INS")) - let chr11 = chr11.add_feature(ChrFeature::new(name="MYCN", start=1590000.0, end=1595000.0, orientation=Forward, feature_type=ChrFeatureType::Gene, color="#FCBAD3", label="MYCN")) + let chr11 = Chromosome::new( + name="chr11", + length=135086622.0, + centromere_pos=51000000.0, + ) + let chr11 = chr11.add_feature( + ChrFeature::new( + name="INS", + start=2159000.0, + end=2164000.0, + orientation=Forward, + feature_type=ChrFeatureType::Gene, + color="#AA96DA", + label="INS", + ), + ) + let chr11 = chr11.add_feature( + ChrFeature::new( + name="MYCN", + start=1590000.0, + end=1595000.0, + orientation=Forward, + feature_type=ChrFeatureType::Gene, + color="#FCBAD3", + label="MYCN", + ), + ) chromosomes.push(chr11) - ChrDiagram::new(chromosomes=chromosomes, layout=layout, title="Human Chromosome Map") + ChrDiagram::new(chromosomes~, layout~, title="Human Chromosome Map") } ///| @@ -854,14 +1082,72 @@ pub fn chr_create_bacterial_chromosome() -> ChrDiagram { show_labels=true, ) - let ecoli = Chromosome::new(name="E. coli K-12", length=4600000.0, centromere_pos=2300000.0, is_circular=true) - let ecoli = ecoli.add_feature(ChrFeature::new(name="rrl", start=404000.0, end=405000.0, orientation=Forward, feature_type=ChrFeatureType::Gene, color="#FF6B6B", label="rrl")) - let ecoli = ecoli.add_feature(ChrFeature::new(name="rpoB", start=430000.0, end=435000.0, orientation=Forward, feature_type=ChrFeatureType::Gene, color="#4ECDC4", label="rpoB")) - let ecoli = ecoli.add_feature(ChrFeature::new(name="lacZ", start=3600000.0, end=3603000.0, orientation=Forward, feature_type=ChrFeatureType::Gene, color="#95E1D3", label="lacZ")) - let ecoli = ecoli.add_feature(ChrFeature::new(name="trpA", start=4000000.0, end=4001000.0, orientation=Reverse, feature_type=ChrFeatureType::Gene, color="#F38181", label="trpA")) - let ecoli = ecoli.add_region(ChrRegion::new(name="Pathogenicity Island", start=1000000.0, end=1200000.0, color="#FFE66D", opacity=0.2, label="PAI-1")) + let ecoli = Chromosome::new( + name="E. coli K-12", + length=4600000.0, + centromere_pos=2300000.0, + is_circular=true, + ) + let ecoli = ecoli.add_feature( + ChrFeature::new( + name="rrl", + start=404000.0, + end=405000.0, + orientation=Forward, + feature_type=ChrFeatureType::Gene, + color="#FF6B6B", + label="rrl", + ), + ) + let ecoli = ecoli.add_feature( + ChrFeature::new( + name="rpoB", + start=430000.0, + end=435000.0, + orientation=Forward, + feature_type=ChrFeatureType::Gene, + color="#4ECDC4", + label="rpoB", + ), + ) + let ecoli = ecoli.add_feature( + ChrFeature::new( + name="lacZ", + start=3600000.0, + end=3603000.0, + orientation=Forward, + feature_type=ChrFeatureType::Gene, + color="#95E1D3", + label="lacZ", + ), + ) + let ecoli = ecoli.add_feature( + ChrFeature::new( + name="trpA", + start=4000000.0, + end=4001000.0, + orientation=Reverse, + feature_type=ChrFeatureType::Gene, + color="#F38181", + label="trpA", + ), + ) + let ecoli = ecoli.add_region( + ChrRegion::new( + name="Pathogenicity Island", + start=1000000.0, + end=1200000.0, + color="#FFE66D", + opacity=0.2, + label="PAI-1", + ), + ) - ChrDiagram::new(chromosomes=[ecoli], layout=layout, title="E. coli K-12 Circular Chromosome") + ChrDiagram::new( + chromosomes=[ecoli], + layout~, + title="E. coli K-12 Circular Chromosome", + ) } // ============================================================================ @@ -899,9 +1185,18 @@ pub fn ChrDiagram::features_by_type(self : ChrDiagram) -> Map[String, Int] { /// Get chromosome summary as string. pub fn ChrDiagram::summary(self : ChrDiagram) -> String { let mut result = "Chromosome Diagram: " + self.title + "\n" - result = result + "Chromosomes: " + self.chromosomes.length().to_string() + "\n" - result = result + "Total features: " + self.total_features().to_string() + "\n" - result = result + "Max length: " + chr_max_length(self.chromosomes).to_string() + " bp\n" + result = result + + "Chromosomes: " + + self.chromosomes.length().to_string() + + "\n" + result = result + + "Total features: " + + self.total_features().to_string() + + "\n" + result = result + + "Max length: " + + chr_max_length(self.chromosomes).to_string() + + " bp\n" result } diff --git a/src/cibersort.mbt b/src/cibersort.mbt index 1ed2f3cb..f9245461 100644 --- a/src/cibersort.mbt +++ b/src/cibersort.mbt @@ -35,10 +35,10 @@ pub struct CibMixtureMatrix { /// Deconvolution result for a single sample. pub struct CibResult { sample_id : String - fractions : Array[Double] // cell type fractions (sum ≈ 1.0) + fractions : Array[Double] // cell type fractions (sum ≈ 1.0) cell_types : Array[String] - pearson_r : Double // correlation between fitted and observed - rmse : Double // root mean squared error + pearson_r : Double // correlation between fitted and observed + rmse : Double // root mean squared error } ///| @@ -65,19 +65,25 @@ pub fn CibSignatureMatrix::new( ///| /// Get gene names. -pub fn CibSignatureMatrix::gene_names(self : CibSignatureMatrix) -> Array[String] { +pub fn CibSignatureMatrix::gene_names( + self : CibSignatureMatrix, +) -> Array[String] { self.gene_names } ///| /// Get cell type names. -pub fn CibSignatureMatrix::cell_types(self : CibSignatureMatrix) -> Array[String] { +pub fn CibSignatureMatrix::cell_types( + self : CibSignatureMatrix, +) -> Array[String] { self.cell_types } ///| /// Get the raw matrix (rows=genes, cols=cell_types). -pub fn CibSignatureMatrix::matrix(self : CibSignatureMatrix) -> Array[Array[Double]] { +pub fn CibSignatureMatrix::matrix( + self : CibSignatureMatrix, +) -> Array[Array[Double]] { self.matrix } @@ -105,7 +111,9 @@ pub fn CibMixtureMatrix::gene_names(self : CibMixtureMatrix) -> Array[String] { ///| /// Get the raw matrix (rows=genes, cols=samples). -pub fn CibMixtureMatrix::matrix(self : CibMixtureMatrix) -> Array[Array[Double]] { +pub fn CibMixtureMatrix::matrix( + self : CibMixtureMatrix, +) -> Array[Array[Double]] { self.matrix } @@ -165,9 +173,13 @@ pub fn CibDeconvolution::sample_names(self : CibDeconvolution) -> Array[String] /// Compute the mean of an array. fn cib_mean(arr : Array[Double]) -> Double { let n = arr.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut s = 0.0 - for v in arr { s = s + v } + for v in arr { + s = s + v + } s / n.to_double() } @@ -175,7 +187,9 @@ fn cib_mean(arr : Array[Double]) -> Double { /// Compute Pearson correlation between two arrays. fn cib_pearson(a : Array[Double], b : Array[Double]) -> Double { let n = a.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let ma = cib_mean(a) let mb = cib_mean(b) let mut cov = 0.0 @@ -189,14 +203,20 @@ fn cib_pearson(a : Array[Double], b : Array[Double]) -> Double { vb = vb + db * db } let denom = (va * vb).sqrt() - if denom < 1.0e-15 { 0.0 } else { cov / denom } + if denom < 1.0e-15 { + 0.0 + } else { + cov / denom + } } ///| /// Compute RMSE between observed and fitted. fn cib_rmse(observed : Array[Double], fitted : Array[Double]) -> Double { let n = observed.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut sse = 0.0 for i in 0.. Array[Double] { let m = b.length() let n = if a.length() > 0 { a[0].length() } else { 0 } - if m == 0 || n == 0 { return [] } + if m == 0 || n == 0 { + return [] + } // Initialize x = 0 let x : Array[Double] = [] - for _j in 0.. max_diag { max_diag = ata[j][j] } + if ata[j][j] > max_diag { + max_diag = ata[j][j] + } } let lr = 1.0 / max_diag // Update and project @@ -272,10 +302,14 @@ fn cib_nnls( let new_x = x[j] - lr * grad[j] let projected = if new_x < 0.0 { 0.0 } else { new_x } let change = (projected - x[j]).abs() - if change > max_change { max_change = change } + if change > max_change { + max_change = change + } x[j] = projected } - if max_change < tol { converged = true } + if max_change < tol { + converged = true + } iter = iter + 1 } x @@ -345,12 +379,18 @@ pub fn cib_run( let x = cib_nnls(a, b, max_iters, tol) // Normalize to sum to 1.0 let mut sum_x = 0.0 - for v in x { sum_x = sum_x + v } + for v in x { + sum_x = sum_x + v + } let fractions : Array[Double] = [] if sum_x > 1.0e-15 { - for v in x { fractions.push(v / sum_x) } + for v in x { + fractions.push(v / sum_x) + } } else { - for _v in x { fractions.push(0.0) } + for _v in x { + fractions.push(0.0) + } } // Compute fitted values: fitted = A * x let fitted : Array[Double] = [] @@ -383,9 +423,8 @@ pub fn cib_run( /// signature. pub fn cib_cell_type_names() -> Array[String] { [ - "B cells", "T cells CD8", "T cells CD4", "NK cells", "Monocytes", - "Macrophages M1", "Macrophages M2", "Dendritic cells", "Neutrophils", - "Mast cells", + "B cells", "T cells CD8", "T cells CD4", "NK cells", "Monocytes", "Macrophages M1", + "Macrophages M2", "Dendritic cells", "Neutrophils", "Mast cells", ] } @@ -394,15 +433,15 @@ pub fn cib_cell_type_names() -> Array[String] { pub fn cib_marker_genes() -> Array[String] { [ "CD19", "MS4A1", "CD79A", "CD79B", // B cells - "CD8A", "CD8B", "GZMK", "GZMA", // T cells CD8 - "CD4", "IL7R", "LEF1", "TCF7", // T cells CD4 - "NKG7", "GNLY", "KLRD1", "NCAM1", // NK cells - "CD14", "LYZ", "S100A8", "S100A9", // Monocytes - "NOS2", "IL1B", "TNF", "CXCL9", // Macrophages M1 - "CD163", "MRC1", "ARG1", "IL10", // Macrophages M2 - "ITGAX", "CD1C", "CLEC10A", "FCER1A", // Dendritic cells - "FCGR3A", "CSF3R", "FPR1", "CEACAM3", // Neutrophils - "TPSAB1", "CPA3", "MS4A2", "KIT", // Mast cells + "CD8A", "CD8B", "GZMK", "GZMA", // T cells CD8 + "CD4", "IL7R", "LEF1", "TCF7", // T cells CD4 + "NKG7", "GNLY", "KLRD1", "NCAM1", // NK cells + "CD14", "LYZ", "S100A8", "S100A9", // Monocytes + "NOS2", "IL1B", "TNF", "CXCL9", // Macrophages M1 + "CD163", "MRC1", "ARG1", "IL10", // Macrophages M2 + "ITGAX", "CD1C", "CLEC10A", "FCER1A", // Dendritic cells + "FCGR3A", "CSF3R", "FPR1", "CEACAM3", // Neutrophils + "TPSAB1", "CPA3", "MS4A2", "KIT", // Mast cells ] } @@ -508,7 +547,9 @@ pub fn cib_sample_mixture() -> CibMixtureMatrix { /// Get the fraction of a specific cell type in a result. pub fn CibResult::get_fraction(self : CibResult, cell_type : String) -> Double { for i in 0.. String { for f in r.fractions { result = result + "\t" + f.to_string() } - result = result + "\t" + r.pearson_r.to_string() + "\t" + r.rmse.to_string() + "\n" + result = result + + "\t" + + r.pearson_r.to_string() + + "\t" + + r.rmse.to_string() + + "\n" } result } diff --git a/src/circ_seq.mbt b/src/circ_seq.mbt index bf4dd0cb..9bb80f91 100644 --- a/src/circ_seq.mbt +++ b/src/circ_seq.mbt @@ -36,6 +36,7 @@ pub fn CircSeq::with_name(sequence~ : String, name~ : String) -> CircSeq { CircSeq::{ sequence, length, gc_content: gc, name } } +///| fn compute_gc_content(seq : String) -> Double { let n = seq.length() if n == 0 { @@ -129,9 +130,15 @@ pub fn CircSeq::circ_rotate(self : CircSeq, new_origin : Int) -> CircSeq { return self } // New sequence: seq[wrapped:] + seq[:wrapped] - let new_seq = self.sequence.substring(start=wrapped) + self.sequence.substring(start=0, end=wrapped) + let new_seq = self.sequence.substring(start=wrapped) + + self.sequence.substring(start=0, end=wrapped) let gc = compute_gc_content(new_seq) - CircSeq::{ sequence: new_seq, length: self.length, gc_content: gc, name: self.name } + CircSeq::{ + sequence: new_seq, + length: self.length, + gc_content: gc, + name: self.name, + } } ///| @@ -139,32 +146,38 @@ pub fn CircSeq::circ_rotate(self : CircSeq, new_origin : Int) -> CircSeq { pub fn CircSeq::circ_reverse_complement(self : CircSeq) -> CircSeq { let rc = circ_rev_comp(self.sequence) let gc = compute_gc_content(rc) - CircSeq::{ sequence: rc, length: self.length, gc_content: gc, name: self.name } + CircSeq::{ + sequence: rc, + length: self.length, + gc_content: gc, + name: self.name, + } } +///| fn circ_rev_comp(seq : String) -> String { let mut result = "" let mut i = seq.length() - 1 while i >= 0 { let c = char_to_upper(seq.unsafe_get(i)) let comp : UInt16 = match c { - 65 => 84 // 'A' => 'T' - 84 => 65 // 'T' => 'A' - 71 => 67 // 'G' => 'C' - 67 => 71 // 'C' => 'G' - 85 => 65 // 'U' => 'A' - 78 => 78 // 'N' => 'N' - 82 => 89 // 'R' => 'Y' - 89 => 82 // 'Y' => 'R' - 83 => 83 // 'S' => 'S' - 87 => 87 // 'W' => 'W' - 75 => 77 // 'K' => 'M' - 77 => 75 // 'M' => 'K' - 66 => 86 // 'B' => 'V' - 86 => 66 // 'V' => 'B' - 68 => 72 // 'D' => 'H' - 72 => 68 // 'H' => 'D' - _ => 78 // 'N' default + 65 => 84 // 'A' => 'T' + 84 => 65 // 'T' => 'A' + 71 => 67 // 'G' => 'C' + 67 => 71 // 'C' => 'G' + 85 => 65 // 'U' => 'A' + 78 => 78 // 'N' => 'N' + 82 => 89 // 'R' => 'Y' + 89 => 82 // 'Y' => 'R' + 83 => 83 // 'S' => 'S' + 87 => 87 // 'W' => 'W' + 75 => 77 // 'K' => 'M' + 77 => 75 // 'M' => 'K' + 66 => 86 // 'B' => 'V' + 86 => 66 // 'V' => 'B' + 68 => 72 // 'D' => 'H' + 72 => 68 // 'H' => 'D' + _ => 78 // 'N' default } result = result + u16_to_str(comp) i = i - 1 @@ -184,7 +197,7 @@ pub fn CircSeq::circ_find_all(self : CircSeq, pattern : String) -> Array[Int] { // Search the doubled sequence to handle circular wrapping let doubled = self.sequence + self.sequence - let search_len = self.length // Only search up to the original length to avoid duplicates + let search_len = self.length // Only search up to the original length to avoid duplicates let mut i = 0 while i <= search_len - plen { @@ -236,7 +249,10 @@ pub fn CircSeq::circ_has_site(self : CircSeq, site : String) -> Bool { ///| /// Find all restriction enzyme cut sites on both strands. /// Returns an array of (position, strand) tuples. -pub fn CircSeq::circ_find_sites(self : CircSeq, site : String) -> Array[(Int, String)] { +pub fn CircSeq::circ_find_sites( + self : CircSeq, + site : String, +) -> Array[(Int, String)] { let results : Array[(Int, String)] = Array::new() let fwd = self.circ_find_all(site) for pos in fwd { @@ -252,7 +268,10 @@ pub fn CircSeq::circ_find_sites(self : CircSeq, site : String) -> Array[(Int, St ///| /// Simulate a restriction digest on the circular sequence. /// Returns an array of fragment sizes (in bp). -pub fn CircSeq::circ_digest(self : CircSeq, sites : Array[String]) -> Array[Int] { +pub fn CircSeq::circ_digest( + self : CircSeq, + sites : Array[String], +) -> Array[Int] { let cut_positions : Array[Int] = Array::new() // Collect all cut positions from both strands for all enzymes @@ -308,7 +327,10 @@ pub fn CircSeq::circ_digest(self : CircSeq, sites : Array[String]) -> Array[Int] ///| /// Calculate fragment sizes from a circular digest using specific enzymes. -pub fn CircSeq::circ_digest_enzymes(self : CircSeq, enzymes : Array[String]) -> Array[Int] { +pub fn CircSeq::circ_digest_enzymes( + self : CircSeq, + enzymes : Array[String], +) -> Array[Int] { self.circ_digest(enzymes) } @@ -343,19 +365,30 @@ pub fn CircSeq::circ_design_primers( (fwd_start, rev_start, product_len) } +///| fn calc_gc(seq : String) -> Double { - if seq.length() == 0 { return 0.0 } + if seq.length() == 0 { + return 0.0 + } let mut gc = 0 let mut i = 0 while i < seq.length() { let c = char_to_upper(seq.unsafe_get(i)) - if c == 71 || c == 67 { gc = gc + 1 } + if c == 71 || c == 67 { + gc = gc + 1 + } i = i + 1 } gc.to_double() / seq.length().to_double() } -fn adjust_primer_length(circ : CircSeq, start : Int, target_len : Int, gc_target : Double) -> Int { +///| +fn adjust_primer_length( + circ : CircSeq, + start : Int, + target_len : Int, + gc_target : Double, +) -> Int { let mut len = target_len let max_len = if circ.length < 40 { circ.length } else { 40 } while len < max_len { @@ -371,12 +404,23 @@ fn adjust_primer_length(circ : CircSeq, start : Int, target_len : Int, gc_target ///| /// Insert a sequence at a specific position in the circular sequence. -pub fn CircSeq::circ_insert(self : CircSeq, pos : Int, insert_seq : String) -> CircSeq { +pub fn CircSeq::circ_insert( + self : CircSeq, + pos : Int, + insert_seq : String, +) -> CircSeq { let wrapped = modulo_pos(pos, self.length) - let new_seq = self.sequence.substring(start=0, end=wrapped) + insert_seq + self.sequence.substring(start=wrapped) + let new_seq = self.sequence.substring(start=0, end=wrapped) + + insert_seq + + self.sequence.substring(start=wrapped) let new_length = new_seq.length() let gc = compute_gc_content(new_seq) - CircSeq::{ sequence: new_seq, length: new_length, gc_content: gc, name: self.name } + CircSeq::{ + sequence: new_seq, + length: new_length, + gc_content: gc, + name: self.name, + } } ///| @@ -385,16 +429,23 @@ pub fn CircSeq::circ_delete(self : CircSeq, start : Int, end : Int) -> CircSeq { let new_seq = circular_delete(self.sequence, start, end) let new_length = new_seq.length() let gc = compute_gc_content(new_seq) - CircSeq::{ sequence: new_seq, length: new_length, gc_content: gc, name: self.name } + CircSeq::{ + sequence: new_seq, + length: new_length, + gc_content: gc, + name: self.name, + } } +///| fn circular_delete(seq : String, start : Int, end : Int) -> String { let wrapped_start = modulo_pos(start, seq.length()) let wrapped_end = modulo_pos(end, seq.length()) if wrapped_start <= wrapped_end { // Linear delete - return seq.substring(start=0, end=wrapped_start) + seq.substring(start=wrapped_end + 1) + return seq.substring(start=0, end=wrapped_start) + + seq.substring(start=wrapped_end + 1) } else { // Wraps around: delete from wrapped_start to end, and from start to wrapped_end return seq.substring(start=wrapped_end + 1, end=wrapped_start) @@ -428,7 +479,12 @@ pub fn linear_to_circular(linear_pos : Int, length : Int) -> Int { ///| /// Check if a position is within a range on the circular sequence. -pub fn is_within_circular_range(pos : Int, range_start : Int, range_end : Int, length : Int) -> Bool { +pub fn is_within_circular_range( + pos : Int, + range_start : Int, + range_end : Int, + length : Int, +) -> Bool { let p = modulo_pos(pos, length) let rs = modulo_pos(range_start, length) let re = modulo_pos(range_end, length) @@ -445,7 +501,13 @@ pub fn is_within_circular_range(pos : Int, range_start : Int, range_end : Int, l ///| /// Compute the overlap between two ranges on the circular sequence. /// Returns the number of overlapping bases. -pub fn circular_overlap(start1 : Int, end1 : Int, start2 : Int, end2 : Int, length : Int) -> Int { +pub fn circular_overlap( + start1 : Int, + end1 : Int, + start2 : Int, + end2 : Int, + length : Int, +) -> Int { let s1 = modulo_pos(start1, length) let e1 = modulo_pos(end1, length) let s2 = modulo_pos(start2, length) @@ -465,6 +527,7 @@ pub fn circular_overlap(start1 : Int, end1 : Int, start2 : Int, end2 : Int, leng count } +///| fn expand_range(start : Int, end : Int, length : Int) -> Array[Int] { let result : Array[Int] = Array::new() if start <= end { @@ -491,6 +554,7 @@ fn expand_range(start : Int, end : Int, length : Int) -> Array[Int] { // --- Utility Functions --- +///| fn modulo_pos(pos : Int, length : Int) -> Int { if length <= 0 { return 0 @@ -503,6 +567,7 @@ fn modulo_pos(pos : Int, length : Int) -> Int { } } +///| fn sort_positions(positions : Array[Int]) -> Array[Int] { let result = positions.copy() let n = result.length() @@ -524,7 +589,11 @@ fn sort_positions(positions : Array[Int]) -> Array[Int] { ///| /// Generate a random circular sequence of given length and GC content. -pub fn circ_random_sequence(length : Int, gc_content : Double, seed? : Int = 42) -> CircSeq { +pub fn circ_random_sequence( + length : Int, + gc_content : Double, + seed? : Int = 42, +) -> CircSeq { let bases = ["A", "T", "G", "C"] // Adjust probabilities based on GC content let at_prob = (1.0 - gc_content) / 2.0 @@ -546,8 +615,14 @@ pub fn circ_random_sequence(length : Int, gc_content : Double, seed? : Int = 42) CircSeq::new(sequence=seq) } +///| fn pick_base(rand_val : Double, probs : Array[Double]) -> Int { - let cumulative = [probs[0], probs[0] + probs[1], probs[0] + probs[1] + probs[2], 1.0] + let cumulative = [ + probs[0], + probs[0] + probs[1], + probs[0] + probs[1] + probs[2], + 1.0, + ] if rand_val <= cumulative[0] { return 0 } else if rand_val <= cumulative[1] { @@ -562,14 +637,23 @@ fn pick_base(rand_val : Double, probs : Array[Double]) -> Int { ///| /// Simulate a ligation reaction on two circular sequences. /// Returns the concatenated circular product. -pub fn circ_ligate(linear_fragment : String, vector : CircSeq, insert_pos : Int) -> CircSeq { +pub fn circ_ligate( + linear_fragment : String, + vector : CircSeq, + insert_pos : Int, +) -> CircSeq { vector.circ_insert(insert_pos, linear_fragment) } ///| /// Compute Tm (melting temperature) for a primer on a circular template. /// Uses the nearest-neighbor method approximation. -pub fn circ_tm(template : CircSeq, start : Int, len : Int, oligo_conc? : Double = 5.0e-8) -> Double { +pub fn circ_tm( + template : CircSeq, + start : Int, + len : Int, + oligo_conc? : Double = 5.0e-8, +) -> Double { let seq = template.circ_slice(start, len) let gc = calc_gc(seq) let at = 1.0 - gc @@ -611,7 +695,7 @@ pub fn circ_common_restriction_sites() -> Array[(String, String)] { ("ScaI", "AGTACT"), ("SmaI", "CCCGGG"), ("StuI", "AGGCCT"), - ("XmaI", "CCCGGG") + ("XmaI", "CCCGGG"), ] } diff --git a/src/cluster_experiment.mbt b/src/cluster_experiment.mbt index 54c6154d..67ae0c48 100644 --- a/src/cluster_experiment.mbt +++ b/src/cluster_experiment.mbt @@ -505,7 +505,10 @@ fn ce_kmeans_single( ///| /// k-means++ seeding using a deterministic pseudo-random pick based on indices /// (the project avoids real RNG; this gives reproducible spreads). -fn ce_kmeans_pp_init(data : Array[Array[Double]], k : Int) -> Array[Array[Double]] { +fn ce_kmeans_pp_init( + data : Array[Array[Double]], + k : Int, +) -> Array[Array[Double]] { let n = data.length() let centroids : Array[Array[Double]] = Array::new() // pick the point closest to the global centroid as first seed @@ -582,14 +585,19 @@ pub fn ce_cluster_many( copy } let subset = ce_subsample(work, ss) - let (labels_full, _) = ce_kmeans(subset.data, k, params.n_init, params.max_iter) + let (labels_full, _) = ce_kmeans( + subset.data, + k, + params.n_init, + params.max_iter, + ) // map subsample labels back to full data let labels = Array::make(data.length(), -1) for idx in 0.. 0 && counts[j] > 0 { - let denom = (if counts[i] < counts[j] { - counts[i] - } else { - counts[j] - }).to_double() + let denom = (if counts[i] < counts[j] { counts[i] } else { counts[j] }).to_double() if denom > 0.0 { m[i][j] = m[i][j] / denom } @@ -844,7 +848,9 @@ pub fn ce_make_dendrogram( let nodes : Array[CeDendroNode] = Array::new() for i in 0.. merge_cutoff if merged { // union the two clusters @@ -979,12 +988,12 @@ pub fn ce_merge_clusters( } info.push( CeMergeInfo::new( - node_id=node_id, - left_cluster=left_cluster, - right_cluster=right_cluster, + node_id~, + left_cluster~, + right_cluster~, proportion=prop, q_value=qval, - merged=merged, + merged~, ), ) node_id = node_id + 1 @@ -1153,10 +1162,11 @@ pub fn ce_normal_cdf(z : Double) -> Double { let t = 1.0 / (1.0 + 0.2316419 * x) let d = 0.3989423 * @math.exp(-x * x / 2.0) let p = t * - (0.319381530 + + ( + 0.319381530 + t * - (-0.356563782 + - t * (1.781477937 + t * (-1.821255978 + t * 1.330274429)))) + (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))) + ) 1.0 - d * p } @@ -1230,13 +1240,13 @@ pub fn ce_sequential_cluster( let ids : Array[Int] = Array::new() for l in labels { let mut found = false - for id in ids { - if id == l { - found = true - break - } + for id in ids { + if id == l { + found = true + break } - if !found && l >= 0 { + } + if !found && l >= 0 { ids.push(l) } } @@ -1425,11 +1435,11 @@ pub fn ce_rsec( } ClusterExperiment::new( labels=final_labels, - cocluster=cocluster, - dendro=dendro, + cocluster~, + dendro~, n_clusters=ids.length(), merge_cutoff=params.merge_cutoff, - merge_info=merge_info, + merge_info~, ) } diff --git a/src/cnvkit.mbt b/src/cnvkit.mbt index c91e8673..724e3725 100644 --- a/src/cnvkit.mbt +++ b/src/cnvkit.mbt @@ -63,16 +63,9 @@ pub fn CNVProbe::new( start : Int, end : Int, log2_ratio : Double, - weight : Double + weight : Double, ) -> CNVProbe { - CNVProbe::{ - probe_id, - chromosome, - start, - end, - log2_ratio, - weight - } + CNVProbe::{ probe_id, chromosome, start, end, log2_ratio, weight } } ///| @@ -82,16 +75,9 @@ pub fn CNVSegment::new( end : Int, probes : Int, mean_log2 : Double, - state : String + state : String, ) -> CNVSegment { - CNVSegment::{ - chromosome, - start, - end, - probes, - mean_log2, - state - } + CNVSegment::{ chromosome, start, end, probes, mean_log2, state } } ///| @@ -99,7 +85,7 @@ pub fn CNVDataset::new() -> CNVDataset { CNVDataset::{ probes: Array::new(), segments: Array::new(), - chromosomes: Array::new() + chromosomes: Array::new(), } } @@ -107,16 +93,16 @@ pub fn CNVDataset::new() -> CNVDataset { pub fn CNVDataset::add_probe(self : CNVDataset, probe : CNVProbe) -> CNVDataset { let new_probes = self.probes new_probes.push(probe) - + let new_chroms = self.chromosomes if !cnvkit_contains_string(new_chroms, probe.chromosome) { new_chroms.push(probe.chromosome) } - + CNVDataset::{ probes: new_probes, segments: self.segments, - chromosomes: new_chroms + chromosomes: new_chroms, } } @@ -131,7 +117,10 @@ pub fn CNVDataset::count_segments(self : CNVDataset) -> Int { } ///| -pub fn CNVDataset::filter_chromosome(self : CNVDataset, chrom : String) -> CNVDataset { +pub fn CNVDataset::filter_chromosome( + self : CNVDataset, + chrom : String, +) -> CNVDataset { let filtered : Array[CNVProbe] = Array::new() let mut i = 0 while i < self.probes.length() { @@ -140,7 +129,7 @@ pub fn CNVDataset::filter_chromosome(self : CNVDataset, chrom : String) -> CNVDa } i = i + 1 } - + let segments : Array[CNVSegment] = Array::new() let mut j = 0 while j < self.segments.length() { @@ -149,12 +138,8 @@ pub fn CNVDataset::filter_chromosome(self : CNVDataset, chrom : String) -> CNVDa } j = j + 1 } - - CNVDataset::{ - probes: filtered, - segments, - chromosomes: [chrom] - } + + CNVDataset::{ probes: filtered, segments, chromosomes: [chrom] } } ///| @@ -164,10 +149,10 @@ pub fn cbs_segment(probes : Array[CNVProbe], alpha : Double) -> CBSResult { return CBSResult::{ segments: Array::new(), breakpoints: Array::new(), - n_segments: 0 + n_segments: 0, } } - + // Extract log2 ratios let log2ratios : Array[Double] = Array::new() let mut i = 0 @@ -175,47 +160,43 @@ pub fn cbs_segment(probes : Array[CNVProbe], alpha : Double) -> CBSResult { log2ratios.push(probes[i].log2_ratio) i = i + 1 } - + // Perform CBS segmentation let breakpoints = cbs_find_breakpoints(log2ratios, alpha) - + // Create segments from breakpoints let segments = cbs_create_segments(probes, breakpoints) - - CBSResult::{ - segments, - breakpoints, - n_segments: segments.length() - } + + CBSResult::{ segments, breakpoints, n_segments: segments.length() } } ///| fn cbs_find_breakpoints(data : Array[Double], alpha : Double) -> Array[Int] { let n = data.length() let breakpoints : Array[Int] = Array::new() - + if n == 0 { return breakpoints } - + if n < 3 { breakpoints.push(0) breakpoints.push(n) return breakpoints } - + // Find change points using t-statistic let mut i = 1 while i < n - 1 { let t_stat = cbs_calculate_t_statistic(data, i) let p_value = cbs_approximate_p_value(t_stat, n) - + if p_value < alpha { breakpoints.push(i) } i = i + 1 } - + // Ensure breakpoints include start and end if breakpoints.length() > 0 { if breakpoints[0] != 0 { @@ -228,7 +209,7 @@ fn cbs_find_breakpoints(data : Array[Double], alpha : Double) -> Array[Int] { breakpoints.push(0) breakpoints.push(n) } - + breakpoints } @@ -237,11 +218,11 @@ fn cbs_calculate_t_statistic(data : Array[Double], breakpoint : Int) -> Double { let n = data.length() let n_left = breakpoint let n_right = n - breakpoint - + if n_left < 1 || n_right < 1 { return 0.0 } - + // Calculate means let mut sum_left = 0.0 let mut i = 0 @@ -250,7 +231,7 @@ fn cbs_calculate_t_statistic(data : Array[Double], breakpoint : Int) -> Double { i = i + 1 } let mean_left = sum_left / n_left.to_double() - + let mut sum_right = 0.0 let mut j = n_left while j < n { @@ -258,7 +239,7 @@ fn cbs_calculate_t_statistic(data : Array[Double], breakpoint : Int) -> Double { j = j + 1 } let mean_right = sum_right / n_right.to_double() - + // Calculate variances let mut var_left = 0.0 i = 0 @@ -268,7 +249,7 @@ fn cbs_calculate_t_statistic(data : Array[Double], breakpoint : Int) -> Double { i = i + 1 } var_left = var_left / n_left.to_double() - + let mut var_right = 0.0 j = n_left while j < n { @@ -277,11 +258,13 @@ fn cbs_calculate_t_statistic(data : Array[Double], breakpoint : Int) -> Double { j = j + 1 } var_right = var_right / n_right.to_double() - - let pooled_var = (n_left.to_double() * var_left + n_right.to_double() * var_right) / + + let pooled_var = ( + n_left.to_double() * var_left + n_right.to_double() * var_right + ) / (n_left.to_double() + n_right.to_double()) let se = (pooled_var * (1.0 / n_left.to_double() + 1.0 / n_right.to_double())).sqrt() - + if se == 0.0 { 0.0 } else { @@ -294,7 +277,7 @@ fn cbs_approximate_p_value(t : Double, n : Int) -> Double { // Approximate p-value using normal distribution let abs_t = if t >= 0.0 { t } else { -t } let df = n.to_double() - 2.0 - + // Simple approximation let x = abs_t / (1.0 + abs_t / (2.0 * df)) 2.0 * (1.0 - cbs_normal_cdf(x)) @@ -306,7 +289,12 @@ fn cbs_normal_cdf(x : Double) -> Double { let abs_x = if x >= 0.0 { x } else { -x } let t = 1.0 / (1.0 + 0.2316419 * abs_x) let d = 0.3989422804014327 * @math.exp(-abs_x * abs_x / 2.0) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))) + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))) + ) if x >= 0.0 { 1.0 - p } else { @@ -315,19 +303,22 @@ fn cbs_normal_cdf(x : Double) -> Double { } ///| -fn cbs_create_segments(probes : Array[CNVProbe], breakpoints : Array[Int]) -> Array[CNVSegment] { +fn cbs_create_segments( + probes : Array[CNVProbe], + breakpoints : Array[Int], +) -> Array[CNVSegment] { let segments : Array[CNVSegment] = Array::new() let n = breakpoints.length() - + if n < 2 { return segments } - + let mut i = 0 while i < n - 1 { let start_idx = breakpoints[i] let end_idx = breakpoints[i + 1] - + if start_idx < end_idx && start_idx < probes.length() { let chrom = probes[start_idx].chromosome let start_pos = probes[start_idx].start @@ -337,7 +328,7 @@ fn cbs_create_segments(probes : Array[CNVProbe], breakpoints : Array[Int]) -> Ar probes[probes.length() - 1].end } let count = end_idx - start_idx - + // Calculate mean log2 ratio let mut sum = 0.0 let mut j = start_idx @@ -346,22 +337,17 @@ fn cbs_create_segments(probes : Array[CNVProbe], breakpoints : Array[Int]) -> Ar j = j + 1 } let mean_log2 = if count > 0 { sum / count.to_double() } else { 0.0 } - + // Determine state let state = cbs_call_state(mean_log2) - - segments.push(CNVSegment::new( - chrom, - start_pos, - end_pos, - count, - mean_log2, - state - )) + + segments.push( + CNVSegment::new(chrom, start_pos, end_pos, count, mean_log2, state), + ) } i = i + 1 } - + segments } @@ -377,15 +363,18 @@ pub fn cbs_call_state(mean_log2 : Double) -> String { } ///| -pub fn smooth_log2_ratios(probes : Array[CNVProbe], window_size : Int) -> Array[CNVProbe] { +pub fn smooth_log2_ratios( + probes : Array[CNVProbe], + window_size : Int, +) -> Array[CNVProbe] { let n = probes.length() let smoothed : Array[CNVProbe] = Array::new() - + let mut i = 0 while i < n { let start = if i - window_size / 2 >= 0 { i - window_size / 2 } else { 0 } let end = if i + window_size / 2 < n { i + window_size / 2 } else { n - 1 } - + let mut sum = 0.0 let mut count = 0 let mut j = start @@ -394,68 +383,71 @@ pub fn smooth_log2_ratios(probes : Array[CNVProbe], window_size : Int) -> Array[ count = count + 1 j = j + 1 } - - let smoothed_ratio = if count > 0 { sum / count.to_double() } else { probes[i].log2_ratio } - - smoothed.push(CNVProbe::{ - ..probes[i], - log2_ratio: smoothed_ratio - }) + + let smoothed_ratio = if count > 0 { + sum / count.to_double() + } else { + probes[i].log2_ratio + } + + smoothed.push(CNVProbe::{ ..probes[i], log2_ratio: smoothed_ratio }) i = i + 1 } - + smoothed } ///| -pub fn detect_breakpoints(segments : Array[CNVSegment], threshold : Double) -> Array[(Int, String)] { +pub fn detect_breakpoints( + segments : Array[CNVSegment], + threshold : Double, +) -> Array[(Int, String)] { let breakpoints : Array[(Int, String)] = Array::new() let n = segments.length() - + if n < 2 { return breakpoints } - + let mut i = 1 while i < n { let prev = segments[i - 1] let curr = segments[i] - + // Check for state change if prev.state != curr.state { breakpoints.push((curr.start, curr.state)) } - + // Check for significant mean change let mean_diff = (prev.mean_log2 - curr.mean_log2).abs() if mean_diff > threshold { breakpoints.push((curr.start, "change")) } - + i = i + 1 } - + breakpoints } ///| -pub fn call_copy_numbers(segments : Array[CNVSegment], ploidy : Int) -> Array[CopyNumberCall] { +pub fn call_copy_numbers( + segments : Array[CNVSegment], + ploidy : Int, +) -> Array[CopyNumberCall] { let calls : Array[CopyNumberCall] = Array::new() - + let mut i = 0 while i < segments.length() { let segment = segments[i] let copy_number = cbs_log2_to_copynumber(segment.mean_log2, ploidy) let state = cbs_call_state(segment.mean_log2) - - calls.push(CopyNumberCall::{ - segment, - copy_number, - state - }) + + calls.push(CopyNumberCall::{ segment, copy_number, state }) i = i + 1 } - + calls } @@ -470,17 +462,17 @@ fn cbs_log2_to_copynumber(log2_ratio : Double, ploidy : Int) -> Double { pub fn summarize_cnv(dataset : CNVDataset) -> CNVSummary { let total_probes = dataset.count_probes() let total_segments = dataset.count_segments() - + let avg_segment_size = if total_segments > 0 { total_probes.to_double() / total_segments.to_double() } else { 0.0 } - + let mut deletion_count = 0 let mut amplification_count = 0 let mut neutral_count = 0 - + let segments = dataset.segments let mut i = 0 while i < segments.length() { @@ -491,49 +483,57 @@ pub fn summarize_cnv(dataset : CNVDataset) -> CNVSummary { } i = i + 1 } - + CNVSummary::{ total_probes, total_segments, avg_segment_size, deletion_count, amplification_count, - neutral_count + neutral_count, } } ///| pub fn create_example_cnv_dataset() -> CNVDataset { let mut dataset = CNVDataset::new() - + // Create a dataset with 100 probes showing a copy number change let mut i = 0 while i < 100 { let chrom = if i < 50 { "chr1" } else { "chr2" } - let start = if chrom == "chr1" { 1000000 + i * 10000 } else { 2000000 + (i - 50) * 10000 } - + let start = if chrom == "chr1" { + 1000000 + i * 10000 + } else { + 2000000 + (i - 50) * 10000 + } + // Create a deletion in the middle of chr1 let log2_ratio = if chrom == "chr1" && i >= 20 && i < 35 { -0.8 } else if chrom == "chr1" && i >= 50 && i < 65 { 0.8 + } else if i % 3 == 0 { + 0.05 + } else if i % 3 == 1 { + -0.03 } else { - if i % 3 == 0 { 0.05 } else if i % 3 == 1 { -0.03 } else { 0.02 } + 0.02 } - + let probe = CNVProbe::new( "probe_" + i.to_string(), chrom, start, start + 1000, log2_ratio, - 1.0 + 1.0, ) - + dataset = dataset.add_probe(probe) i = i + 1 } - + dataset } @@ -543,16 +543,26 @@ pub fn cbs_summarize_dataset(dataset : CNVDataset) -> String { let mut result = "\nCNV Dataset Summary\n" result = result + "==============================\n" result = result + "Total probes: " + summary.total_probes.to_string() + "\n" - result = result + "Total segments: " + summary.total_segments.to_string() + "\n" - result = result + "Avg segment size: " + summary.avg_segment_size.to_string() + "\n" + result = result + + "Total segments: " + + summary.total_segments.to_string() + + "\n" + result = result + + "Avg segment size: " + + summary.avg_segment_size.to_string() + + "\n" result = result + "Deletions: " + summary.deletion_count.to_string() + "\n" - result = result + "Amplifications: " + summary.amplification_count.to_string() + "\n" + result = result + + "Amplifications: " + + summary.amplification_count.to_string() + + "\n" result = result + "Neutral: " + summary.neutral_count.to_string() + "\n" result } // Helper functions +///| fn cnvkit_contains_string(arr : Array[String], value : String) -> Bool { let mut i = 0 while i < arr.length() { diff --git a/src/codon_advanced.mbt b/src/codon_advanced.mbt index 1bc885a3..6d906326 100644 --- a/src/codon_advanced.mbt +++ b/src/codon_advanced.mbt @@ -169,9 +169,7 @@ pub struct CodonUsageTable { ///| /// Create a new CodonUsageTable from raw counts. -pub fn CodonUsageTable::new( - codon_counts : Map[String, Int], -) -> CodonUsageTable { +pub fn CodonUsageTable::new(codon_counts : Map[String, Int]) -> CodonUsageTable { let frequencies = compute_frequencies(codon_counts.copy()) let mut total = 0 let keys = codon_counts.keys().collect() @@ -215,7 +213,9 @@ pub fn CodonUsageTable::counts(usage : CodonUsageTable) -> Map[String, Int] { ///| /// Get all codon frequencies as a Map. -pub fn CodonUsageTable::frequencies(usage : CodonUsageTable) -> Map[String, Double] { +pub fn CodonUsageTable::frequencies( + usage : CodonUsageTable, +) -> Map[String, Double] { usage.frequencies.copy() } @@ -428,10 +428,7 @@ pub fn compute_codon_adaptiveness( /// CAI = exp( (1/L) * sum(ln(w_i)) ) for each codon, /// where w_i is the relative adaptiveness of codon i. /// Returns a value between 0 and 1, where 1 indicates optimal codon usage. -pub fn calculate_cai( - seq : String, - reference_table : CodonUsageTable, -) -> Double { +pub fn calculate_cai(seq : String, reference_table : CodonUsageTable) -> Double { let seq_upper = seq.to_upper() let len = seq_upper.length() let adaptiveness = compute_codon_adaptiveness(reference_table) @@ -641,7 +638,13 @@ pub fn calculate_enc(usage : CodonUsageTable) -> Double { enc = enc + 3.0 * (f6_contrib / f6_count.to_double()) } - if enc > 61.0 { 61.0 } else if enc < 20.0 { 20.0 } else { enc } + if enc > 61.0 { + 61.0 + } else if enc < 20.0 { + 20.0 + } else { + enc + } } ///| @@ -673,7 +676,11 @@ pub fn calculate_gc3(seq : String) -> Double { ///| /// Calculate a composite bias score (0-1 scale). /// Higher values indicate stronger codon usage bias. -fn calculate_bias_score(enc : Double, gc3 : Double, optimal_frac : Double) -> Double { +fn calculate_bias_score( + enc : Double, + gc3 : Double, + optimal_frac : Double, +) -> Double { let enc_score = (61.0 - enc) / 41.0 let gc3_score = if gc3 > 0.5 { gc3 } else { 1.0 - gc3 } let opt_score = optimal_frac @@ -701,9 +708,7 @@ fn count_stop_codons(seq : String) -> Int { /// Identify optimal codons for each amino acid. /// Returns an array of (amino_acid, codon) tuples where the codon /// has the highest frequency for that amino acid. -pub fn optimal_codons( - usage : CodonUsageTable, -) -> Array[(String, String)] { +pub fn optimal_codons(usage : CodonUsageTable) -> Array[(String, String)] { let result = Array::make(0, ("", "")) let aa_list = aa_to_codons.keys().collect() @@ -846,13 +851,7 @@ pub fn codon_bias_analysis(seq : String) -> CodonBiasResult { let bias_score = calculate_bias_score(enc_val, gc3_val, optimal_frac) CodonBiasResult::new( - enc_val, - cai_val, - gc3_val, - bias_score, - optimal_frac, - rare_frac, - non_stop_total, + enc_val, cai_val, gc3_val, bias_score, optimal_frac, rare_frac, non_stop_total, ) } @@ -862,36 +861,17 @@ pub fn codon_bias_analysis(seq : String) -> CodonBiasResult { pub fn get_high_gc_reference() -> Map[String, Double] { let ref_table = Map([], capacity=64) let gc_codons = [ - "GCA", "GCC", "GCG", "GCT", - "CGA", "CGC", "CGG", "CGT", - "GAC", "GAT", "GAA", "GAG", - "GGA", "GGC", "GGG", "GGT", - "CAC", "CAT", "CAA", "CAG", - "ATA", "ATC", "ATT", "ATG", - "CTA", "CTC", "CTG", "CTT", - "AAA", "AAG", "TTA", "TTG", - "TTC", "TTT", "CCA", "CCC", - "CCG", "CCT", "AGC", "AGT", - "TCA", "TCC", "TCG", "TCT", - "ACA", "ACC", "ACG", "ACT", - "GTA", "GTC", "GTG", "GTT", - "TGC", "TGT", "TGG", + "GCA", "GCC", "GCG", "GCT", "CGA", "CGC", "CGG", "CGT", "GAC", "GAT", "GAA", + "GAG", "GGA", "GGC", "GGG", "GGT", "CAC", "CAT", "CAA", "CAG", "ATA", "ATC", + "ATT", "ATG", "CTA", "CTC", "CTG", "CTT", "AAA", "AAG", "TTA", "TTG", "TTC", + "TTT", "CCA", "CCC", "CCG", "CCT", "AGC", "AGT", "TCA", "TCC", "TCG", "TCT", + "ACA", "ACC", "ACG", "ACT", "GTA", "GTC", "GTG", "GTT", "TGC", "TGT", "TGG", ] let gc_bias = [ - 0.7, 1.0, 0.9, 0.6, - 0.8, 1.0, 0.9, 0.6, - 0.8, 0.5, 0.9, 1.0, - 0.6, 1.0, 0.8, 0.5, - 0.8, 0.5, 0.7, 1.0, - 0.4, 0.8, 0.5, 1.0, - 0.6, 0.9, 1.0, 0.5, - 0.5, 1.0, 0.4, 0.3, - 0.5, 0.3, 0.7, 1.0, - 0.9, 0.6, 0.8, 0.5, - 0.4, 0.8, 1.0, 0.6, - 0.7, 1.0, 0.9, 0.5, - 0.5, 0.9, 1.0, 0.6, - 0.5, 0.6, 1.0, + 0.7, 1.0, 0.9, 0.6, 0.8, 1.0, 0.9, 0.6, 0.8, 0.5, 0.9, 1.0, 0.6, 1.0, 0.8, 0.5, + 0.8, 0.5, 0.7, 1.0, 0.4, 0.8, 0.5, 1.0, 0.6, 0.9, 1.0, 0.5, 0.5, 1.0, 0.4, 0.3, + 0.5, 0.3, 0.7, 1.0, 0.9, 0.6, 0.8, 0.5, 0.4, 0.8, 1.0, 0.6, 0.7, 1.0, 0.9, 0.5, + 0.5, 0.9, 1.0, 0.6, 0.5, 0.6, 1.0, ] let mut i = 0 while i < gc_codons.length() { @@ -907,36 +887,17 @@ pub fn get_high_gc_reference() -> Map[String, Double] { pub fn get_low_gc_reference() -> Map[String, Double] { let ref_table = Map([], capacity=64) let at_codons = [ - "GCT", "GCA", "GCC", "GCG", - "CGT", "CGA", "CGC", "CGG", - "GAT", "GAC", "GAA", "GAG", - "GTT", "GTA", "GTC", "GTG", - "CAT", "CAC", "CAA", "CAG", - "ATT", "ATA", "ATC", "ATG", - "CTT", "CTA", "CTC", "CTG", - "AAA", "AAG", "TTA", "TTG", - "TTT", "TTC", "CCT", "CCA", - "CCC", "CCG", "AGT", "AGC", - "TCT", "TCA", "TCC", "TCG", - "ACT", "ACA", "ACC", "ACG", - "GGT", "GGA", "GGC", "GGG", - "TGT", "TGC", "TGG", + "GCT", "GCA", "GCC", "GCG", "CGT", "CGA", "CGC", "CGG", "GAT", "GAC", "GAA", + "GAG", "GTT", "GTA", "GTC", "GTG", "CAT", "CAC", "CAA", "CAG", "ATT", "ATA", + "ATC", "ATG", "CTT", "CTA", "CTC", "CTG", "AAA", "AAG", "TTA", "TTG", "TTT", + "TTC", "CCT", "CCA", "CCC", "CCG", "AGT", "AGC", "TCT", "TCA", "TCC", "TCG", + "ACT", "ACA", "ACC", "ACG", "GGT", "GGA", "GGC", "GGG", "TGT", "TGC", "TGG", ] let at_bias = [ - 1.0, 0.5, 0.4, 0.3, - 1.0, 0.5, 0.4, 0.3, - 1.0, 0.5, 0.6, 0.5, - 1.0, 0.8, 0.5, 0.4, - 1.0, 0.4, 0.8, 0.6, - 1.0, 0.7, 0.4, 1.0, - 1.0, 0.8, 0.5, 0.4, - 1.0, 0.6, 0.9, 0.7, - 1.0, 0.6, 0.5, 0.3, - 1.0, 0.8, 0.7, 0.5, - 1.0, 0.8, 0.5, 0.4, - 1.0, 0.9, 0.6, 0.4, - 1.0, 0.9, 0.6, 0.4, - 1.0, 0.5, 1.0, + 1.0, 0.5, 0.4, 0.3, 1.0, 0.5, 0.4, 0.3, 1.0, 0.5, 0.6, 0.5, 1.0, 0.8, 0.5, 0.4, + 1.0, 0.4, 0.8, 0.6, 1.0, 0.7, 0.4, 1.0, 1.0, 0.8, 0.5, 0.4, 1.0, 0.6, 0.9, 0.7, + 1.0, 0.6, 0.5, 0.3, 1.0, 0.8, 0.7, 0.5, 1.0, 0.8, 0.5, 0.4, 1.0, 0.9, 0.6, 0.4, + 1.0, 0.9, 0.6, 0.4, 1.0, 0.5, 1.0, ] let mut i = 0 while i < at_codons.length() { @@ -977,10 +938,7 @@ pub fn get_reference_table(org : String) -> Map[String, Double] { ///| /// Calculate CAI using a named organism reference table. -pub fn calculate_cai_with_org( - seq : String, - org : String, -) -> Double { +pub fn calculate_cai_with_org(seq : String, org : String) -> Double { let seq_upper = seq.to_upper() let len = seq_upper.length() let ref_table = get_reference_table(org) @@ -1065,8 +1023,13 @@ pub fn codon_usage_to_string(usage : CodonUsageTable) -> String { let codon = codons[j] let count = CodonUsageTable::get_count(usage, codon) let freq = CodonUsageTable::get_frequency(usage, codon) - result = result + codon + "(" + count.to_string() + - "/" + freq.to_string() + ")" + result = result + + codon + + "(" + + count.to_string() + + "/" + + freq.to_string() + + ")" if j < codons.length() - 1 { result = result + ", " } @@ -1081,10 +1044,7 @@ pub fn codon_usage_to_string(usage : CodonUsageTable) -> String { ///| /// Count codons of a specific amino acid in a sequence. -pub fn count_amino_acid_codons( - seq : String, - aa : String, -) -> Int { +pub fn count_amino_acid_codons(seq : String, aa : String) -> Int { let seq_upper = seq.to_upper() let len = seq_upper.length() let codons = aa_to_codons.get(aa).unwrap_or([]) @@ -1183,4 +1143,4 @@ pub fn gc_second_fraction(seq : String) -> Double { } gc_count.to_double() / total.to_double() -} \ No newline at end of file +} diff --git a/src/compass.mbt b/src/compass.mbt index 36e82c3c..96721052 100644 --- a/src/compass.mbt +++ b/src/compass.mbt @@ -282,21 +282,9 @@ pub fn parse_compass(content : String) -> Array[CompassRecord] { if has_record { records.push( CompassRecord::new( - query_name, - template_name, - query_n_seqs, - template_n_seqs, - query_n_cols, - template_n_cols, - sw_score, - e_value, - percentage_identity, - query_start, - query_end, - template_start, - template_end, - aligned_query, - aligned_template, + query_name, template_name, query_n_seqs, template_n_seqs, query_n_cols, + template_n_cols, sw_score, e_value, percentage_identity, query_start, + query_end, template_start, template_end, aligned_query, aligned_template, consensus_line, ), ) @@ -323,29 +311,27 @@ pub fn parse_compass(content : String) -> Array[CompassRecord] { query_name = compass_extract_after(trimmed, "Query alignment:") } else if starts_with(trimmed, 0, "Template alignment:") { template_name = compass_extract_after(trimmed, "Template alignment:") - } else if starts_with( - trimmed, 0, "Number of sequences in query alignment:", - ) { + } else if starts_with(trimmed, 0, "Number of sequences in query alignment:") { query_n_seqs = parse_int( - compass_extract_after(trimmed, "Number of sequences in query alignment:"), + compass_extract_after( + trimmed, "Number of sequences in query alignment:", + ), ) } else if starts_with( - trimmed, 0, "Number of sequences in template alignment:", - ) { + trimmed, 0, "Number of sequences in template alignment:", + ) { template_n_seqs = parse_int( compass_extract_after( trimmed, "Number of sequences in template alignment:", ), ) - } else if starts_with( - trimmed, 0, "Number of columns in query alignment:", - ) { + } else if starts_with(trimmed, 0, "Number of columns in query alignment:") { query_n_cols = parse_int( compass_extract_after(trimmed, "Number of columns in query alignment:"), ) } else if starts_with( - trimmed, 0, "Number of columns in template alignment:", - ) { + trimmed, 0, "Number of columns in template alignment:", + ) { template_n_cols = parse_int( compass_extract_after( trimmed, "Number of columns in template alignment:", @@ -356,9 +342,9 @@ pub fn parse_compass(content : String) -> Array[CompassRecord] { compass_extract_after(trimmed, "Smith-Waterman score:"), ).unwrap_or(0.0) } else if starts_with(trimmed, 0, "E-value:") { - e_value = parse_double( - compass_extract_after(trimmed, "E-value:"), - ).unwrap_or(0.0) + e_value = parse_double(compass_extract_after(trimmed, "E-value:")).unwrap_or( + 0.0, + ) } else if starts_with(trimmed, 0, "Percentage identity:") { percentage_identity = parse_double( compass_extract_after(trimmed, "Percentage identity:"), @@ -383,22 +369,9 @@ pub fn parse_compass(content : String) -> Array[CompassRecord] { if has_record { records.push( CompassRecord::new( - query_name, - template_name, - query_n_seqs, - template_n_seqs, - query_n_cols, - template_n_cols, - sw_score, - e_value, - percentage_identity, - query_start, - query_end, - template_start, - template_end, - aligned_query, - aligned_template, - consensus_line, + query_name, template_name, query_n_seqs, template_n_seqs, query_n_cols, template_n_cols, + sw_score, e_value, percentage_identity, query_start, query_end, template_start, + template_end, aligned_query, aligned_template, consensus_line, ), ) } @@ -476,7 +449,8 @@ pub fn compass_summary(records : Array[CompassRecord]) -> String { s = s + " SW score: " + r.sw_score.to_string() + "\n" s = s + " E-value: " + r.e_value.to_string() + "\n" s = s + " Identity: " + r.percentage_identity.to_string() + "%\n" - s = s + " Alignment length: " + + s = s + + " Alignment length: " + compass_alignment_length(r).to_string() + "\n\n" } @@ -491,11 +465,13 @@ pub fn CompassRecord::to_string(self : CompassRecord) -> String { s = s + ", sw_score=" + self.sw_score.to_string() s = s + ", e_value=" + self.e_value.to_string() s = s + ", identity=" + self.percentage_identity.to_string() - s = s + ", query_range=" + + s = s + + ", query_range=" + self.query_start.to_string() + "-" + self.query_end.to_string() - s = s + ", template_range=" + + s = s + + ", template_range=" + self.template_start.to_string() + "-" + self.template_end.to_string() diff --git a/src/compound.mbt b/src/compound.mbt index 120d28dc..743e933b 100644 --- a/src/compound.mbt +++ b/src/compound.mbt @@ -83,7 +83,19 @@ pub fn Compound::get_formula(self : Compound) -> String { /// Set molecular formula. pub fn Compound::set_formula(self : Compound, formula : String) -> Compound { let c = self - Compound::{ id: c.id, name: c.name, formula, charge: c.charge, smiles: c.smiles, inchikey: c.inchikey, inchi: c.inchi, aliases: c.aliases, pathways: c.pathways, reactions: c.reactions, comment: c.comment } + Compound::{ + id: c.id, + name: c.name, + formula, + charge: c.charge, + smiles: c.smiles, + inchikey: c.inchikey, + inchi: c.inchi, + aliases: c.aliases, + pathways: c.pathways, + reactions: c.reactions, + comment: c.comment, + } } ///| @@ -96,7 +108,19 @@ pub fn Compound::get_charge(self : Compound) -> Int { /// Set charge. pub fn Compound::set_charge(self : Compound, charge : Int) -> Compound { let c = self - Compound::{ id: c.id, name: c.name, formula: c.formula, charge, smiles: c.smiles, inchikey: c.inchikey, inchi: c.inchi, aliases: c.aliases, pathways: c.pathways, reactions: c.reactions, comment: c.comment } + Compound::{ + id: c.id, + name: c.name, + formula: c.formula, + charge, + smiles: c.smiles, + inchikey: c.inchikey, + inchi: c.inchi, + aliases: c.aliases, + pathways: c.pathways, + reactions: c.reactions, + comment: c.comment, + } } ///| @@ -109,7 +133,19 @@ pub fn Compound::get_smiles(self : Compound) -> String { /// Set SMILES string. pub fn Compound::set_smiles(self : Compound, smiles : String) -> Compound { let c = self - Compound::{ id: c.id, name: c.name, formula: c.formula, charge: c.charge, smiles, inchikey: c.inchikey, inchi: c.inchi, aliases: c.aliases, pathways: c.pathways, reactions: c.reactions, comment: c.comment } + Compound::{ + id: c.id, + name: c.name, + formula: c.formula, + charge: c.charge, + smiles, + inchikey: c.inchikey, + inchi: c.inchi, + aliases: c.aliases, + pathways: c.pathways, + reactions: c.reactions, + comment: c.comment, + } } ///| @@ -124,7 +160,19 @@ pub fn Compound::add_alias(self : Compound, alias : String) -> Compound { let c = self let new_aliases = c.aliases.copy() new_aliases.push(alias) - Compound::{ id: c.id, name: c.name, formula: c.formula, charge: c.charge, smiles: c.smiles, inchikey: c.inchikey, inchi: c.inchi, aliases: new_aliases, pathways: c.pathways, reactions: c.reactions, comment: c.comment } + Compound::{ + id: c.id, + name: c.name, + formula: c.formula, + charge: c.charge, + smiles: c.smiles, + inchikey: c.inchikey, + inchi: c.inchi, + aliases: new_aliases, + pathways: c.pathways, + reactions: c.reactions, + comment: c.comment, + } } ///| @@ -153,7 +201,19 @@ pub fn Compound::add_pathway(self : Compound, pathway : String) -> Compound { let c = self let new_pathways = c.pathways.copy() new_pathways.push(pathway) - Compound::{ id: c.id, name: c.name, formula: c.formula, charge: c.charge, smiles: c.smiles, inchikey: c.inchikey, inchi: c.inchi, aliases: c.aliases, pathways: new_pathways, reactions: c.reactions, comment: c.comment } + Compound::{ + id: c.id, + name: c.name, + formula: c.formula, + charge: c.charge, + smiles: c.smiles, + inchikey: c.inchikey, + inchi: c.inchi, + aliases: c.aliases, + pathways: new_pathways, + reactions: c.reactions, + comment: c.comment, + } } ///| @@ -168,7 +228,19 @@ pub fn Compound::add_reaction(self : Compound, reaction : String) -> Compound { let c = self let new_reactions = c.reactions.copy() new_reactions.push(reaction) - Compound::{ id: c.id, name: c.name, formula: c.formula, charge: c.charge, smiles: c.smiles, inchikey: c.inchikey, inchi: c.inchi, aliases: c.aliases, pathways: c.pathways, reactions: new_reactions, comment: c.comment } + Compound::{ + id: c.id, + name: c.name, + formula: c.formula, + charge: c.charge, + smiles: c.smiles, + inchikey: c.inchikey, + inchi: c.inchi, + aliases: c.aliases, + pathways: c.pathways, + reactions: new_reactions, + comment: c.comment, + } } ///| @@ -190,7 +262,9 @@ pub fn Compound::to_string(self : Compound) -> String { result = result + ", aliases: [" let mut i = 0 while i < self.aliases.length() { - if i > 0 { result = result + ", " } + if i > 0 { + result = result + ", " + } result = result + "'\{self.aliases[i]}'" i = i + 1 } @@ -251,20 +325,21 @@ pub fn parse_formula(formula : String) -> Map[String, Int] { /// Get molecular formula as a string from parsed counts. pub fn formula_to_string(counts : Map[String, Int]) -> String { let mut result = "" - let elements = ["C", "H", "N", "O", "S", "P", "Fe", "Mg", "Ca", "K", "Na", "Cl", "Br", "I"] + let elements = [ + "C", "H", "N", "O", "S", "P", "Fe", "Mg", "Ca", "K", "Na", "Cl", "Br", "I", + ] let mut i = 0 while i < elements.length() { let el = elements[i] match counts.get(el) { - Some(n) => { + Some(n) => if n > 0 { result = result + el if n > 1 { result = result + n.to_string() } } - } None => () } i = i + 1 @@ -284,14 +359,13 @@ pub fn formula_to_string(counts : Map[String, Int]) -> String { } if !found { match counts.get(el) { - Some(n) => { + Some(n) => if n > 0 { result = result + el if n > 1 { result = result + n.to_string() } } - } None => () } } @@ -324,12 +398,11 @@ pub fn compound_molecular_weight(formula : String) -> Double { let mut total = 0.0 for el in counts.keys() { match counts.get(el) { - Some(count) => { + Some(count) => match weights.get(el) { Some(w) => total = total + w * count.to_double() None => () } - } None => () } } @@ -379,17 +452,31 @@ pub fn ChemicalReaction::get_name(self : ChemicalReaction) -> String { ///| /// Get substrates (reactants). -pub fn ChemicalReaction::get_substrates(self : ChemicalReaction) -> Array[String] { +pub fn ChemicalReaction::get_substrates( + self : ChemicalReaction, +) -> Array[String] { self.substrates } ///| /// Add a substrate. -pub fn ChemicalReaction::add_substrate(self : ChemicalReaction, substrate : String) -> ChemicalReaction { +pub fn ChemicalReaction::add_substrate( + self : ChemicalReaction, + substrate : String, +) -> ChemicalReaction { let r = self let new_subs = r.substrates.copy() new_subs.push(substrate) - ChemicalReaction::{ id: r.id, name: r.name, substrates: new_subs, products: r.products, enzymes: r.enzymes, direction: r.direction, pathway: r.pathway, comment: r.comment } + ChemicalReaction::{ + id: r.id, + name: r.name, + substrates: new_subs, + products: r.products, + enzymes: r.enzymes, + direction: r.direction, + pathway: r.pathway, + comment: r.comment, + } } ///| @@ -400,11 +487,23 @@ pub fn ChemicalReaction::get_products(self : ChemicalReaction) -> Array[String] ///| /// Add a product. -pub fn ChemicalReaction::add_product(self : ChemicalReaction, product : String) -> ChemicalReaction { +pub fn ChemicalReaction::add_product( + self : ChemicalReaction, + product : String, +) -> ChemicalReaction { let r = self let new_prods = r.products.copy() new_prods.push(product) - ChemicalReaction::{ id: r.id, name: r.name, substrates: r.substrates, products: new_prods, enzymes: r.enzymes, direction: r.direction, pathway: r.pathway, comment: r.comment } + ChemicalReaction::{ + id: r.id, + name: r.name, + substrates: r.substrates, + products: new_prods, + enzymes: r.enzymes, + direction: r.direction, + pathway: r.pathway, + comment: r.comment, + } } ///| @@ -415,11 +514,23 @@ pub fn ChemicalReaction::get_enzymes(self : ChemicalReaction) -> Array[String] { ///| /// Add an enzyme. -pub fn ChemicalReaction::add_enzyme(self : ChemicalReaction, enzyme : String) -> ChemicalReaction { +pub fn ChemicalReaction::add_enzyme( + self : ChemicalReaction, + enzyme : String, +) -> ChemicalReaction { let r = self let new_enzymes = r.enzymes.copy() new_enzymes.push(enzyme) - ChemicalReaction::{ id: r.id, name: r.name, substrates: r.substrates, products: r.products, enzymes: new_enzymes, direction: r.direction, pathway: r.pathway, comment: r.comment } + ChemicalReaction::{ + id: r.id, + name: r.name, + substrates: r.substrates, + products: r.products, + enzymes: new_enzymes, + direction: r.direction, + pathway: r.pathway, + comment: r.comment, + } } ///| @@ -430,9 +541,21 @@ pub fn ChemicalReaction::get_direction(self : ChemicalReaction) -> String { ///| /// Set reaction direction ("forward", "reverse", "reversible"). -pub fn ChemicalReaction::set_direction(self : ChemicalReaction, direction : String) -> ChemicalReaction { +pub fn ChemicalReaction::set_direction( + self : ChemicalReaction, + direction : String, +) -> ChemicalReaction { let r = self - ChemicalReaction::{ id: r.id, name: r.name, substrates: r.substrates, products: r.products, enzymes: r.enzymes, direction, pathway: r.pathway, comment: r.comment } + ChemicalReaction::{ + id: r.id, + name: r.name, + substrates: r.substrates, + products: r.products, + enzymes: r.enzymes, + direction, + pathway: r.pathway, + comment: r.comment, + } } ///| @@ -441,7 +564,9 @@ pub fn ChemicalReaction::get_equation(self : ChemicalReaction) -> String { let mut lhs = "" let mut i = 0 while i < self.substrates.length() { - if i > 0 { lhs = lhs + " + " } + if i > 0 { + lhs = lhs + " + " + } lhs = lhs + self.substrates[i] i = i + 1 } @@ -449,7 +574,9 @@ pub fn ChemicalReaction::get_equation(self : ChemicalReaction) -> String { let mut rhs = "" i = 0 while i < self.products.length() { - if i > 0 { rhs = rhs + " + " } + if i > 0 { + rhs = rhs + " + " + } rhs = rhs + self.products[i] i = i + 1 } @@ -472,7 +599,9 @@ pub fn ChemicalReaction::to_string(self : ChemicalReaction) -> String { result = result + " Enzymes: " let mut i = 0 while i < self.enzymes.length() { - if i > 0 { result = result + ", " } + if i > 0 { + result = result + ", " + } result = result + self.enzymes[i] i = i + 1 } @@ -508,37 +637,60 @@ pub fn CompoundPathwayMap::get_name(self : CompoundPathwayMap) -> String { ///| /// Add a compound to the pathway. -pub fn CompoundPathwayMap::add_compound(self : CompoundPathwayMap, compound : Compound) -> CompoundPathwayMap { +pub fn CompoundPathwayMap::add_compound( + self : CompoundPathwayMap, + compound : Compound, +) -> CompoundPathwayMap { let p = self let new_compounds = p.compounds.copy() new_compounds.push(compound) - CompoundPathwayMap::{ name: p.name, compounds: new_compounds, reactions: p.reactions, description: p.description } + CompoundPathwayMap::{ + name: p.name, + compounds: new_compounds, + reactions: p.reactions, + description: p.description, + } } ///| /// Add a reaction to the pathway. -pub fn CompoundPathwayMap::add_reaction(self : CompoundPathwayMap, reaction : ChemicalReaction) -> CompoundPathwayMap { +pub fn CompoundPathwayMap::add_reaction( + self : CompoundPathwayMap, + reaction : ChemicalReaction, +) -> CompoundPathwayMap { let p = self let new_reactions = p.reactions.copy() new_reactions.push(reaction) - CompoundPathwayMap::{ name: p.name, compounds: p.compounds, reactions: new_reactions, description: p.description } + CompoundPathwayMap::{ + name: p.name, + compounds: p.compounds, + reactions: new_reactions, + description: p.description, + } } ///| /// Get all compounds. -pub fn CompoundPathwayMap::get_compounds(self : CompoundPathwayMap) -> Array[Compound] { +pub fn CompoundPathwayMap::get_compounds( + self : CompoundPathwayMap, +) -> Array[Compound] { self.compounds } ///| /// Get all reactions. -pub fn CompoundPathwayMap::get_reactions(self : CompoundPathwayMap) -> Array[ChemicalReaction] { +pub fn CompoundPathwayMap::get_reactions( + self : CompoundPathwayMap, +) -> Array[ChemicalReaction] { self.reactions } ///| /// Find a compound by ID. -pub fn CompoundPathwayMap::find_compound(self : CompoundPathwayMap, id : String) -> Option[Compound] { +pub fn CompoundPathwayMap::find_compound( + self : CompoundPathwayMap, + id : String, +) -> Compound? { let mut i = 0 while i < self.compounds.length() { if self.compounds[i].id == id { @@ -551,7 +703,10 @@ pub fn CompoundPathwayMap::find_compound(self : CompoundPathwayMap, id : String) ///| /// Find a reaction by ID. -pub fn CompoundPathwayMap::find_reaction(self : CompoundPathwayMap, id : String) -> Option[ChemicalReaction] { +pub fn CompoundPathwayMap::find_reaction( + self : CompoundPathwayMap, + id : String, +) -> ChemicalReaction? { let mut i = 0 while i < self.reactions.length() { if self.reactions[i].id == id { @@ -586,7 +741,8 @@ pub fn CompoundPathwayMap::summary(self : CompoundPathwayMap) -> String { result = result + "\nReactions:\n" let mut i = 0 while i < self.reactions.length() { - result = result + " - \{self.reactions[i].id}: \{self.reactions[i].get_equation()}\n" + result = result + + " - \{self.reactions[i].id}: \{self.reactions[i].get_equation()}\n" i = i + 1 } } @@ -597,13 +753,17 @@ pub fn CompoundPathwayMap::summary(self : CompoundPathwayMap) -> String { ///| /// Create common known compound templates. pub fn compound_glucose() -> Compound { - Compound::with_chemical("C0003", "D-Glucose", "C6H12O6", 0, "C(C1C(C(C(C(O1)O)O)O)O)O") + Compound::with_chemical( + "C0003", "D-Glucose", "C6H12O6", 0, "C(C1C(C(C(C(O1)O)O)O)O)O", + ) } ///| /// Create fructose compound. pub fn compound_fructose() -> Compound { - Compound::with_chemical("C0005", "D-Fructose", "C6H12O6", 0, "C(=O)C1(C(C(C(O1)O)O)O)O") + Compound::with_chemical( + "C0005", "D-Fructose", "C6H12O6", 0, "C(=O)C1(C(C(C(O1)O)O)O)O", + ) } ///| @@ -621,5 +781,7 @@ pub fn compound_acetate() -> Compound { ///| /// Create citrate compound. pub fn compound_citrate() -> Compound { - Compound::with_chemical("C0015", "Citrate", "C6H5O7", -3, "OC(=O)C(CC(=O)[O-])(O)CC(=O)[O-]") + Compound::with_chemical( + "C0015", "Citrate", "C6H5O7", -3, "OC(=O)C(CC(=O)[O-])(O)CC(=O)[O-]", + ) } diff --git a/src/consensus_cluster_plus.mbt b/src/consensus_cluster_plus.mbt index b188d0d5..553ec08f 100644 --- a/src/consensus_cluster_plus.mbt +++ b/src/consensus_cluster_plus.mbt @@ -19,9 +19,15 @@ pub fn CCPResult::new( cluster_labels : Array[Int], k : Int, consensus_score : Double, - stability_scores : Array[Double] + stability_scores : Array[Double], ) -> CCPResult { - CCPResult::{ consensus_matrix, cluster_labels, k, consensus_score, stability_scores } + CCPResult::{ + consensus_matrix, + cluster_labels, + k, + consensus_score, + stability_scores, + } } ///| @@ -30,10 +36,10 @@ pub fn ccp_calculate_consensus_matrix( data : Array[Array[Double]], k : Int, n_iterations : Int, - sample_fraction : Double + sample_fraction : Double, ) -> Array[Array[Double]] { let n = data.length() - + let consensus : Array[Array[Double]] = Array::new() let mut i = 0 while i < n { @@ -46,7 +52,7 @@ pub fn ccp_calculate_consensus_matrix( consensus.push(row) i = i + 1 } - + let counts : Array[Array[Int]] = Array::new() let mut m = 0 while m < n { @@ -59,21 +65,21 @@ pub fn ccp_calculate_consensus_matrix( counts.push(row) m = m + 1 } - + let mut iter = 0 while iter < n_iterations { let sample_size = (n.to_double() * sample_fraction).to_int() let sample_indices = ccp_deterministic_sample(n, sample_size, iter) - + let sample_data : Array[Array[Double]] = Array::new() let mut idx = 0 while idx < sample_indices.length() { sample_data.push(data[sample_indices[idx]]) idx = idx + 1 } - + let labels = ccp_kmeans_cluster(sample_data, k) - + let mut a = 0 while a < sample_indices.length() { let mut b = 0 @@ -88,10 +94,10 @@ pub fn ccp_calculate_consensus_matrix( } a = a + 1 } - + iter = iter + 1 } - + let mut x = 0 while x < n { let mut y = 0 @@ -105,7 +111,7 @@ pub fn ccp_calculate_consensus_matrix( } x = x + 1 } - + consensus } @@ -118,7 +124,7 @@ pub fn ccp_deterministic_sample(n : Int, size : Int, seed : Int) -> Array[Int] { indices.push(i) i = i + 1 } - + let mut state = seed let mut j = n - 1 while j > 0 { @@ -130,14 +136,14 @@ pub fn ccp_deterministic_sample(n : Int, size : Int, seed : Int) -> Array[Int] { indices.set(idx, temp) j = j - 1 } - + let result : Array[Int] = Array::new() let mut m = 0 while m < size && m < n { result.push(indices[m]) m = m + 1 } - + result } @@ -146,31 +152,31 @@ pub fn ccp_deterministic_sample(n : Int, size : Int, seed : Int) -> Array[Int] { pub fn ccp_kmeans_cluster(data : Array[Array[Double]], k : Int) -> Array[Int] { let n = data.length() let dim = if n > 0 { data[0].length() } else { 0 } - + let centroids : Array[Array[Double]] = Array::new() let mut c = 0 while c < k && c < n { centroids.push(data[c]) c = c + 1 } - + let labels : Array[Int] = Array::new() let mut j = 0 while j < n { labels.push(0) j = j + 1 } - + let mut changed = true let mut iterations = 0 while changed && iterations < 100 { changed = false - + let mut p = 0 while p < n { let mut min_dist = 10000000000.0 let mut best_cluster = 0 - + let mut q = 0 while q < centroids.length() { let dist = ccp_euclidean_distance(data[p], centroids[q]) @@ -180,14 +186,14 @@ pub fn ccp_kmeans_cluster(data : Array[Array[Double]], k : Int) -> Array[Int] { } q = q + 1 } - + if labels[p] != best_cluster { labels.set(p, best_cluster) changed = true } p = p + 1 } - + let mut r = 0 while r < centroids.length() { let sum : Array[Double] = Array::new() @@ -196,7 +202,7 @@ pub fn ccp_kmeans_cluster(data : Array[Array[Double]], k : Int) -> Array[Int] { sum.push(0.0) s = s + 1 } - + let mut count = 0 let mut t = 0 while t < n { @@ -210,7 +216,7 @@ pub fn ccp_kmeans_cluster(data : Array[Array[Double]], k : Int) -> Array[Int] { } t = t + 1 } - + if count > 0 { let mut v = 0 while v < dim { @@ -220,10 +226,10 @@ pub fn ccp_kmeans_cluster(data : Array[Array[Double]], k : Int) -> Array[Int] { } r = r + 1 } - + iterations = iterations + 1 } - + labels } @@ -242,15 +248,17 @@ pub fn ccp_euclidean_distance(v1 : Array[Double], v2 : Array[Double]) -> Double ///| /// Calculate consensus score from consensus matrix. -pub fn ccp_calculate_consensus_score(consensus_matrix : Array[Array[Double]]) -> Double { +pub fn ccp_calculate_consensus_score( + consensus_matrix : Array[Array[Double]], +) -> Double { let n = consensus_matrix.length() if n == 0 { return 0.0 } - + let mut sum = 0.0 let mut count = 0 - + let mut i = 0 while i < n { let mut j = i + 1 @@ -261,16 +269,24 @@ pub fn ccp_calculate_consensus_score(consensus_matrix : Array[Array[Double]]) -> } i = i + 1 } - - if count > 0 { sum / count.to_double() } else { 0.0 } + + if count > 0 { + sum / count.to_double() + } else { + 0.0 + } } ///| /// Calculate stability scores for each cluster. -pub fn ccp_calculate_stability_scores(consensus_matrix : Array[Array[Double]], cluster_labels : Array[Int], k : Int) -> Array[Double] { +pub fn ccp_calculate_stability_scores( + consensus_matrix : Array[Array[Double]], + cluster_labels : Array[Int], + k : Int, +) -> Array[Double] { let n = consensus_matrix.length() let scores : Array[Double] = Array::new() - + let mut c = 0 while c < k { let members : Array[Int] = Array::new() @@ -281,13 +297,13 @@ pub fn ccp_calculate_stability_scores(consensus_matrix : Array[Array[Double]], c } i = i + 1 } - + if members.length() < 2 { scores.push(0.0) c = c + 1 continue } - + let mut sum = 0.0 let mut count = 0 let mut a = 0 @@ -300,11 +316,11 @@ pub fn ccp_calculate_stability_scores(consensus_matrix : Array[Array[Double]], c } a = a + 1 } - + scores.push(if count > 0 { sum / count.to_double() } else { 0.0 }) c = c + 1 } - + scores } @@ -314,14 +330,20 @@ pub fn ccp_consensus_cluster( data : Array[Array[Double]], k : Int, n_iterations? : Int = 100, - sample_fraction? : Double = 0.8 + sample_fraction? : Double = 0.8, ) -> CCPResult { - let consensus_matrix = ccp_calculate_consensus_matrix(data, k, n_iterations, sample_fraction) + let consensus_matrix = ccp_calculate_consensus_matrix( + data, k, n_iterations, sample_fraction, + ) let cluster_labels = ccp_kmeans_cluster(data, k) let consensus_score = ccp_calculate_consensus_score(consensus_matrix) - let stability_scores = ccp_calculate_stability_scores(consensus_matrix, cluster_labels, k) - - CCPResult::new(consensus_matrix, cluster_labels, k, consensus_score, stability_scores) + let stability_scores = ccp_calculate_stability_scores( + consensus_matrix, cluster_labels, k, + ) + + CCPResult::new( + consensus_matrix, cluster_labels, k, consensus_score, stability_scores, + ) } ///| @@ -331,39 +353,46 @@ pub fn ccp_find_optimal_k( min_k : Int, max_k : Int, n_iterations? : Int = 100, - sample_fraction? : Double = 0.8 + sample_fraction? : Double = 0.8, ) -> (Int, Array[Double]) { let scores : Array[Double] = Array::new() let mut best_k = min_k let mut best_score = 0.0 - + let mut k = min_k while k <= max_k { - let result = ccp_consensus_cluster(data, k, n_iterations = n_iterations, sample_fraction = sample_fraction) + let result = ccp_consensus_cluster(data, k, n_iterations~, sample_fraction~) scores.push(result.consensus_score) - + if result.consensus_score > best_score { best_score = result.consensus_score best_k = k } - + k = k + 1 } - + (best_k, scores) } ///| /// Bio API functions. - pub fn bio_consensus_cluster(data : Array[Array[Double]], k : Int) -> CCPResult { ccp_consensus_cluster(data, k) } -pub fn bio_consensus_cluster_find_optimal_k(data : Array[Array[Double]], min_k : Int, max_k : Int) -> (Int, Array[Double]) { +///| +pub fn bio_consensus_cluster_find_optimal_k( + data : Array[Array[Double]], + min_k : Int, + max_k : Int, +) -> (Int, Array[Double]) { ccp_find_optimal_k(data, min_k, max_k) } -pub fn bio_consensus_cluster_consensus_score(consensus_matrix : Array[Array[Double]]) -> Double { +///| +pub fn bio_consensus_cluster_consensus_score( + consensus_matrix : Array[Array[Double]], +) -> Double { ccp_calculate_consensus_score(consensus_matrix) -} \ No newline at end of file +} diff --git a/src/cram_wbtest.mbt b/src/cram_wbtest.mbt index d65e3416..947908a0 100644 --- a/src/cram_wbtest.mbt +++ b/src/cram_wbtest.mbt @@ -11,7 +11,7 @@ test "cram_magic" { test "cram_record_is_paired" { let cigar : Array[BamCigarElement] = Array::new() cigar.push(BamCigarElement::{ op: BamCigarOp::Match, length: 100 }) - + let read_features = CramReadFeatures::{ read_group: 0, flags: 1, @@ -22,7 +22,7 @@ test "cram_record_is_paired" { quality: "!!!!", tags: Array::new(), } - + let record = CramRecord::{ ref_id: 0, pos: 100, read_features } assert_true((record.read_features.flags & 1) != 0) } @@ -30,7 +30,7 @@ test "cram_record_is_paired" { ///| test "cram_record_is_mapped" { let cigar : Array[BamCigarElement] = Array::new() - + let read_features = CramReadFeatures::{ read_group: 0, flags: 0, @@ -41,7 +41,7 @@ test "cram_record_is_mapped" { quality: "!!!!", tags: Array::new(), } - + let record = CramRecord::{ ref_id: 0, pos: 100, read_features } assert_true((record.read_features.flags & 4) == 0) } @@ -49,7 +49,7 @@ test "cram_record_is_mapped" { ///| test "cram_record_is_unmapped" { let cigar : Array[BamCigarElement] = Array::new() - + let read_features = CramReadFeatures::{ read_group: 0, flags: 4, @@ -60,7 +60,7 @@ test "cram_record_is_unmapped" { quality: "!!!!", tags: Array::new(), } - + let record = CramRecord::{ ref_id: -1, pos: 0, read_features } assert_true((record.read_features.flags & 4) != 0) } @@ -68,7 +68,7 @@ test "cram_record_is_unmapped" { ///| test "cram_record_is_reverse" { let cigar : Array[BamCigarElement] = Array::new() - + let read_features = CramReadFeatures::{ read_group: 0, flags: 16, @@ -79,7 +79,7 @@ test "cram_record_is_reverse" { quality: "!!!!", tags: Array::new(), } - + let record = CramRecord::{ ref_id: 0, pos: 100, read_features } assert_true((record.read_features.flags & 16) != 0) } @@ -87,10 +87,25 @@ test "cram_record_is_reverse" { ///| test "cram_file_num_references" { let references : Array[CramReference] = Array::new() - references.push(CramReference::{ name: "chr1", length: 1000, md5: "", uri: "" }) - references.push(CramReference::{ name: "chr2", length: 2000, md5: "", uri: "" }) - references.push(CramReference::{ name: "chr3", length: 3000, md5: "", uri: "" }) - + references.push(CramReference::{ + name: "chr1", + length: 1000, + md5: "", + uri: "", + }) + references.push(CramReference::{ + name: "chr2", + length: 2000, + md5: "", + uri: "", + }) + references.push(CramReference::{ + name: "chr3", + length: 3000, + md5: "", + uri: "", + }) + let header = CramHeader::{ version: CramVersion::{ major: 3, minor: 0 }, reference_count: 3, @@ -108,7 +123,7 @@ test "cram_file_num_references" { test "cram_record_to_bam_record" { let cigar : Array[BamCigarElement] = Array::new() cigar.push(BamCigarElement::{ op: BamCigarOp::Match, length: 100 }) - + let read_features = CramReadFeatures::{ read_group: 0, flags: 0, @@ -119,10 +134,10 @@ test "cram_record_to_bam_record" { quality: "!!!!", tags: Array::new(), } - + let record = CramRecord::{ ref_id: 0, pos: 100, read_features } let bam_record = record.to_bam_record() - + assert_eq(bam_record.ref_id, 0) assert_eq(bam_record.pos, 100) assert_eq(bam_record.mapq, 60) @@ -143,7 +158,7 @@ fn read_itf8(data : String, pos : Int) -> (Int, Int) { ///| fn read_ltf8(data : String, pos : Int) -> (Int, Int) { let byte = data[pos].to_int() & 0xFF - ((byte >> 1), pos + 1) + (byte >> 1, pos + 1) } ///| @@ -168,4 +183,4 @@ test "read_ltf8" { let (val, pos) = read_ltf8(data, 0) assert_eq(val, 1) assert_eq(pos, 1) -} \ No newline at end of file +} diff --git a/src/crystal.mbt b/src/crystal.mbt index c739b380..0ebb1c4d 100644 --- a/src/crystal.mbt +++ b/src/crystal.mbt @@ -78,7 +78,7 @@ pub fn crystal_density( } let v_cm3 = v_ang3 * 1.0e-24 let n_a = 6.02214076e23 - (z.to_double() * molecular_weight) / (v_cm3 * n_a) + z.to_double() * molecular_weight / (v_cm3 * n_a) } ///| @@ -127,11 +127,7 @@ pub fn orthogonalization_matrix(cell : UnitCell) -> Array[Array[Double]] { // Build with the corrected entries (matches Rupp's textbook). let _ = m02 let _ = m12 - [ - [m00, m01, b * sg * cb], - [m10, m11, b * sg * m12_clean], - [m20, m21, m22], - ] + [[m00, m01, b * sg * cb], [m10, m11, b * sg * m12_clean], [m20, m21, m22]] } ///| @@ -238,7 +234,7 @@ pub fn lookup_space_group(number : Int) -> SpaceGroup { 194 => SpaceGroup::new(number=194, symbol="P 63/m m c") 225 => SpaceGroup::new(number=225, symbol="F m -3 m") 227 => SpaceGroup::new(number=227, symbol="F d -3 m") - _ => SpaceGroup::new(number=number, symbol="") + _ => SpaceGroup::new(number~, symbol="") } } @@ -316,21 +312,27 @@ pub fn CrystalStructure::new( z? : Int = 1, molecular_weight? : Double = 0.0, ) -> CrystalStructure { - CrystalStructure::{ name, cell, space_group, atoms, bonds, z, molecular_weight } + CrystalStructure::{ + name, + cell, + space_group, + atoms, + bonds, + z, + molecular_weight, + } } ///| /// Convert all atoms in a crystal structure to fractional coordinates /// (in place-style: returns a new array of atoms). -pub fn atoms_to_fractional( - structure : CrystalStructure -) -> Array[CrystalAtom] { +pub fn atoms_to_fractional(structure : CrystalStructure) -> Array[CrystalAtom] { let out : Array[CrystalAtom] = Array::new() for a in structure.atoms { if a.is_fractional { out.push(a) } else { - let(fx, fy, fz) = cartesian_to_fractional(structure.cell, a.x, a.y, a.z) + let (fx, fy, fz) = cartesian_to_fractional(structure.cell, a.x, a.y, a.z) out.push( CrystalAtom::new( label=a.label, @@ -349,15 +351,13 @@ pub fn atoms_to_fractional( ///| /// Convert all atoms in a crystal structure to Cartesian coordinates. -pub fn atoms_to_cartesian( - structure : CrystalStructure -) -> Array[CrystalAtom] { +pub fn atoms_to_cartesian(structure : CrystalStructure) -> Array[CrystalAtom] { let out : Array[CrystalAtom] = Array::new() for a in structure.atoms { if !a.is_fractional { out.push(a) } else { - let(cx, cy, cz) = fractional_to_cartesian(structure.cell, a.x, a.y, a.z) + let (cx, cy, cz) = fractional_to_cartesian(structure.cell, a.x, a.y, a.z) out.push( CrystalAtom::new( label=a.label, @@ -416,9 +416,7 @@ pub fn crystal_atom_distance( ///| /// Compute the center of mass of the atoms in Cartesian coordinates. -pub fn center_of_mass( - structure : CrystalStructure -) -> (Double, Double, Double) { +pub fn center_of_mass(structure : CrystalStructure) -> (Double, Double, Double) { let cart = atoms_to_cartesian(structure) if cart.length() == 0 { return (0.0, 0.0, 0.0) @@ -467,7 +465,11 @@ pub fn CifBlock::new(name~ : String) -> CifBlock { ///| /// Add a scalar data item to a CifBlock. -pub fn CifBlock::set_scalar(self : CifBlock, name : String, value : String) -> Unit { +pub fn CifBlock::set_scalar( + self : CifBlock, + name : String, + value : String, +) -> Unit { self.items[name] = CifDataItem::CifScalar(value) } @@ -536,7 +538,7 @@ pub fn parse_cif(text : String) -> Array[CifBlock] { if t.length() >= 5 && t[0:5].to_owned() == "data_" { // Start a new block. let name = t[5:t.length()].to_owned() - let block = CifBlock::new(name=name) + let block = CifBlock::new(name~) blocks.push(block) current = Some(block) i = i + 1 @@ -565,8 +567,7 @@ pub fn parse_cif(text : String) -> Array[CifBlock] { let rows : Array[Array[String]] = Array::new() while i < tokens.length() { let r = tokens[i] - if r == "loop_" || - (r.length() >= 5 && r[0:5].to_owned() == "data_") { + if r == "loop_" || (r.length() >= 5 && r[0:5].to_owned() == "data_") { break } if r.length() > 0 && r[0:1].to_owned() == "_" { @@ -637,14 +638,7 @@ pub fn cif_block_to_crystal(block : CifBlock) -> CrystalStructure { let alpha = cif_get_scalar_double(block, "_cell_angle_alpha") let beta = cif_get_scalar_double(block, "_cell_angle_beta") let gamma = cif_get_scalar_double(block, "_cell_angle_gamma") - let cell = UnitCell::new( - a=a, - b=b, - c=c, - alpha=alpha, - beta=beta, - gamma=gamma, - ) + let cell = UnitCell::new(a~, b~, c~, alpha~, beta~, gamma~) // Space group. let sg_symbol = block.get_scalar("_space_group_name_H-M") let sg_number = cif_get_scalar_int(block, "_space_group_IT_number") @@ -698,11 +692,11 @@ pub fn cif_block_to_crystal(block : CifBlock) -> CrystalStructure { } atoms.push( CrystalAtom::new( - label=label, + label~, element=elem, - x=x, - y=y, - z=z, + x~, + y~, + z~, occupancy=occ, is_fractional=true, ), @@ -739,12 +733,12 @@ pub fn cif_block_to_crystal(block : CifBlock) -> CrystalStructure { let z = cif_get_scalar_int(block, "_cell_formula_units_Z") let mw = cif_get_scalar_double(block, "_chemical_formula_weight") CrystalStructure::new( - name=name, - cell=cell, - space_group=space_group, - atoms=atoms, - bonds=bonds, - z=z, + name~, + cell~, + space_group~, + atoms~, + bonds~, + z~, molecular_weight=mw, ) } @@ -782,7 +776,11 @@ pub fn format_crystal_structure(structure : CrystalStructure) -> String { s = s + "Z = " + structure.z.to_string() + "\n" s = s + "Molecular weight: " + cif_fmt(structure.molecular_weight) + "\n" if structure.molecular_weight > 0.0 && structure.z > 0 { - let rho = crystal_density(structure.cell, structure.z, structure.molecular_weight) + let rho = crystal_density( + structure.cell, + structure.z, + structure.molecular_weight, + ) s = s + "Density: " + cif_fmt(rho) + " g/cm^3\n" } s = s + "Atoms (" + structure.atoms.length().to_string() + "):\n" @@ -806,13 +804,7 @@ pub fn format_crystal_structure(structure : CrystalStructure) -> String { s = s + "Bonds (" + structure.bonds.length().to_string() + "):\n" s = s + "atom1\tatom2\tdistance\n" for b in structure.bonds { - s = s + - b.atom1 + - "\t" + - b.atom2 + - "\t" + - cif_fmt(b.distance) + - "\n" + s = s + b.atom1 + "\t" + b.atom2 + "\t" + cif_fmt(b.distance) + "\n" } } s @@ -919,10 +911,10 @@ pub fn crystal_sample_structure() -> CrystalStructure { ] CrystalStructure::new( name="benzene", - cell=cell, + cell~, space_group=sg, - atoms=atoms, - bonds=bonds, + atoms~, + bonds~, z=2, molecular_weight=78.11, ) diff --git a/src/csaw.mbt b/src/csaw.mbt index f502a53c..a5df47ce 100644 --- a/src/csaw.mbt +++ b/src/csaw.mbt @@ -4,6 +4,7 @@ /// Supports sliding window counting, normalization, filtering, /// and negative binomial GLM-based differential testing. +///| /// Normalization method for window counts pub enum CswNormMethod { /// TMM (trimmed mean of M-values) @@ -16,6 +17,7 @@ pub enum CswNormMethod { None } +///| /// Filtering status for a window pub enum CswFilterStatus { /// Window passes filter @@ -28,6 +30,7 @@ pub enum CswFilterStatus { Excluded } derive(Eq) +///| /// A single genomic window pub struct CswWindow { /// Window ID @@ -46,6 +49,7 @@ pub struct CswWindow { filter_abundance : Double } +///| /// Collection of windows across samples pub struct CswDataSet { /// Windows @@ -62,6 +66,7 @@ pub struct CswDataSet { bin_indices : Array[Int] } +///| /// Normalization result pub struct CswNormResult { /// Normalization factors per sample @@ -74,6 +79,7 @@ pub struct CswNormResult { log_ratios : Array[Array[Double]] } +///| /// Differential binding result pub struct CswResult { /// Window indices @@ -92,6 +98,7 @@ pub struct CswResult { significant : Array[Bool] } +///| /// Region result (merged adjacent significant windows) pub struct CswRegion { /// Region ID @@ -114,8 +121,15 @@ pub struct CswRegion { // ===== Window methods ===== +///| /// Create a new window -pub fn CswWindow::new(id : String, chrom : String, start : Int, end : Int, counts : Array[Double]) -> CswWindow { +pub fn CswWindow::new( + id : String, + chrom : String, + start : Int, + end : Int, + counts : Array[Double], +) -> CswWindow { CswWindow::{ id, chrom, @@ -123,24 +137,29 @@ pub fn CswWindow::new(id : String, chrom : String, start : Int, end : Int, count end, counts, filter_status: CswFilterStatus::Pass, - filter_abundance: 0.0 + filter_abundance: 0.0, } } +///| /// Get window width pub fn CswWindow::csw_width(self : CswWindow) -> Int { self.end - self.start } +///| /// Get count for a sample index pub fn CswWindow::csw_count(self : CswWindow, sample_idx : Int) -> Double { self.counts[sample_idx] } +///| /// Get mean count across samples pub fn CswWindow::csw_mean_count(self : CswWindow) -> Double { let n = self.counts.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut sum = 0.0 let mut i = 0 while i < n { @@ -152,8 +171,13 @@ pub fn CswWindow::csw_mean_count(self : CswWindow) -> Double { // ===== DataSet methods ===== +///| /// Create a new CswDataSet -pub fn CswDataSet::new(windows : Array[CswWindow], samples : Array[String], lib_sizes : Array[Double]) -> CswDataSet { +pub fn CswDataSet::new( + windows : Array[CswWindow], + samples : Array[String], + lib_sizes : Array[Double], +) -> CswDataSet { let n_samples = samples.length() let norm_factors : Array[Double] = Array::new() let mut i = 0 @@ -167,25 +191,29 @@ pub fn CswDataSet::new(windows : Array[CswWindow], samples : Array[String], lib_ lib_sizes, norm_factors, filtered_windows: windows.copy(), - bin_indices: Array::new() + bin_indices: Array::new(), } } +///| /// Get number of windows pub fn CswDataSet::csw_n_windows(self : CswDataSet) -> Int { self.windows.length() } +///| /// Get number of samples pub fn CswDataSet::csw_n_samples(self : CswDataSet) -> Int { self.samples.length() } +///| /// Get a window by index pub fn CswDataSet::csw_get_window(self : CswDataSet, idx : Int) -> CswWindow { self.windows[idx] } +///| /// Get filtered windows pub fn CswDataSet::csw_get_filtered(self : CswDataSet) -> Array[CswWindow] { self.filtered_windows.copy() @@ -195,7 +223,13 @@ pub fn CswDataSet::csw_get_filtered(self : CswDataSet) -> Array[CswWindow] { ///| /// Generate sliding windows across a chromosome. -pub fn csw_make_windows(chrom : String, start : Int, end : Int, width : Int, shift : Int) -> Array[CswWindow] { +pub fn csw_make_windows( + chrom : String, + start : Int, + end : Int, + width : Int, + shift : Int, +) -> Array[CswWindow] { let windows : Array[CswWindow] = Array::new() let mut pos = start while pos + width <= end { @@ -204,7 +238,7 @@ pub fn csw_make_windows(chrom : String, start : Int, end : Int, width : Int, shi chrom, pos, pos + width, - Array::new() + Array::new(), ) windows.push(w) pos = pos + shift @@ -214,7 +248,10 @@ pub fn csw_make_windows(chrom : String, start : Int, end : Int, width : Int, shi ///| /// Assign counts to windows from read positions. -pub fn csw_assign_counts(windows : Array[CswWindow], read_positions : Array[Int]) -> Array[CswWindow] { +pub fn csw_assign_counts( + windows : Array[CswWindow], + read_positions : Array[Int], +) -> Array[CswWindow] { let result : Array[CswWindow] = Array::new() let mut i = 0 while i < windows.length() { @@ -267,7 +304,11 @@ pub fn csw_norm_tmm(data : CswDataSet) -> CswNormResult { let mut min_diff = 1.0e30 let mut s = 0 while s < n_samples { - let diff_val = if lib_sizes[s] > 0.0 { (lib_sizes[s] - mean_lib).abs() } else { 1.0e30 } + let diff_val = if lib_sizes[s] > 0.0 { + (lib_sizes[s] - mean_lib).abs() + } else { + 1.0e30 + } if diff_val < min_diff { min_diff = diff_val ref_idx = s @@ -291,8 +332,16 @@ pub fn csw_norm_tmm(data : CswDataSet) -> CswNormResult { while k < n_windows { let ref_count = data.windows[k].counts[ref_idx] let obs_count = data.windows[k].counts[i] - let ref_norm = if lib_sizes[ref_idx] > 0.0 { ref_count / lib_sizes[ref_idx] } else { 0.0 } - let obs_norm = if lib_sizes[i] > 0.0 { obs_count / lib_sizes[i] } else { 0.0 } + let ref_norm = if lib_sizes[ref_idx] > 0.0 { + ref_count / lib_sizes[ref_idx] + } else { + 0.0 + } + let obs_norm = if lib_sizes[i] > 0.0 { + obs_count / lib_sizes[i] + } else { + 0.0 + } if ref_norm > 0.0 && obs_norm > 0.0 { let m_val = @math.ln(obs_norm / ref_norm) / @math.ln(2.0) sample_log_ratios.push(m_val) @@ -301,7 +350,11 @@ pub fn csw_norm_tmm(data : CswDataSet) -> CswNormResult { } k = k + 1 } - let trimmed_m = if m_count > 0 { m_vals_sum / m_count.to_double() } else { 0.0 } + let trimmed_m = if m_count > 0 { + m_vals_sum / m_count.to_double() + } else { + 0.0 + } let factor = @math.exp(-trimmed_m * @math.ln(2.0)) factors.push(factor) log_ratios.push(sample_log_ratios) @@ -311,13 +364,16 @@ pub fn csw_norm_tmm(data : CswDataSet) -> CswNormResult { norm_factors: factors, norm_method: CswNormMethod::TMM, ref_sample: ref_idx, - log_ratios + log_ratios, } } ///| /// Apply normalization factors to window counts. -pub fn csw_apply_normalization(data : CswDataSet, norm_factors : Array[Double]) -> CswDataSet { +pub fn csw_apply_normalization( + data : CswDataSet, + norm_factors : Array[Double], +) -> CswDataSet { let n_samples = data.samples.length() let n_windows = data.windows.length() let new_windows : Array[CswWindow] = Array::new() @@ -327,7 +383,11 @@ pub fn csw_apply_normalization(data : CswDataSet, norm_factors : Array[Double]) let new_counts : Array[Double] = Array::new() let mut j = 0 while j < n_samples { - let lib_adj = if data.lib_sizes[j] > 0.0 { 1.0 / data.lib_sizes[j] } else { 1.0 } + let lib_adj = if data.lib_sizes[j] > 0.0 { + 1.0 / data.lib_sizes[j] + } else { + 1.0 + } let norm_count = w.counts[j] * lib_adj * norm_factors[j] new_counts.push(norm_count) j = j + 1 @@ -339,7 +399,7 @@ pub fn csw_apply_normalization(data : CswDataSet, norm_factors : Array[Double]) end: w.end, counts: new_counts, filter_status: w.filter_status, - filter_abundance: w.filter_abundance + filter_abundance: w.filter_abundance, }) i = i + 1 } @@ -349,7 +409,7 @@ pub fn csw_apply_normalization(data : CswDataSet, norm_factors : Array[Double]) lib_sizes: data.lib_sizes, norm_factors, filtered_windows: new_windows.copy(), - bin_indices: Array::new() + bin_indices: Array::new(), } } @@ -357,15 +417,26 @@ pub fn csw_apply_normalization(data : CswDataSet, norm_factors : Array[Double]) ///| /// Filter windows by abundance (log2 CPB threshold). -pub fn csw_filter_abundance(data : CswDataSet, log2_cpb_threshold : Double) -> CswDataSet { +pub fn csw_filter_abundance( + data : CswDataSet, + log2_cpb_threshold : Double, +) -> CswDataSet { let n_windows = data.windows.length() let filtered : Array[CswWindow] = Array::new() let mut i = 0 while i < n_windows { let w = data.windows[i] let total_cpb = csw_total_cpb(w.counts, data.lib_sizes) - let log2_cpb = if total_cpb > 0.0 { @math.ln(total_cpb) / @math.ln(2.0) } else { -1.0e9 } - let status = if log2_cpb >= log2_cpb_threshold { CswFilterStatus::Pass } else { CswFilterStatus::LowAbundance } + let log2_cpb = if total_cpb > 0.0 { + @math.ln(total_cpb) / @math.ln(2.0) + } else { + -1.0e9 + } + let status = if log2_cpb >= log2_cpb_threshold { + CswFilterStatus::Pass + } else { + CswFilterStatus::LowAbundance + } let fw = CswWindow::{ id: w.id, chrom: w.chrom, @@ -373,7 +444,7 @@ pub fn csw_filter_abundance(data : CswDataSet, log2_cpb_threshold : Double) -> C end: w.end, counts: w.counts, filter_status: status, - filter_abundance: log2_cpb + filter_abundance: log2_cpb, } filtered.push(fw) i = i + 1 @@ -384,7 +455,7 @@ pub fn csw_filter_abundance(data : CswDataSet, log2_cpb_threshold : Double) -> C lib_sizes: data.lib_sizes, norm_factors: data.norm_factors, filtered_windows: filtered, - bin_indices: data.bin_indices + bin_indices: data.bin_indices, } } @@ -413,7 +484,7 @@ pub fn csw_filter_merged(data : CswDataSet, tol : Double) -> CswDataSet { end: filtered[j].end, counts: filtered[j].counts, filter_status: CswFilterStatus::Merged, - filter_abundance: filtered[j].filter_abundance + filter_abundance: filtered[j].filter_abundance, } } j = j + 1 @@ -427,7 +498,7 @@ pub fn csw_filter_merged(data : CswDataSet, tol : Double) -> CswDataSet { lib_sizes: data.lib_sizes, norm_factors: data.norm_factors, filtered_windows: filtered, - bin_indices: data.bin_indices + bin_indices: data.bin_indices, } } @@ -447,7 +518,7 @@ pub fn csw_test_differential( data : CswDataSet, group1_indices : Array[Int], group2_indices : Array[Int], - dispersion : Double + dispersion : Double, ) -> CswResult { let filtered = data.filtered_windows let n_windows = filtered.length() @@ -473,7 +544,11 @@ pub fn csw_test_differential( } let disp = if dispersion > 0.0 { dispersion } else { 0.1 } let se = if variance1 > 0.0 || variance2 > 0.0 { - (disp * (mean1 / csw_mean_int(group1_indices) + mean2 / csw_mean_int(group2_indices))).sqrt() + (disp * + ( + mean1 / csw_mean_int(group1_indices) + + mean2 / csw_mean_int(group2_indices) + )).sqrt() } else { 1.0 } @@ -502,13 +577,17 @@ pub fn csw_test_differential( wald_stat, p_values, adj_p_values: adj_p, - significant + significant, } } ///| /// Find regions by merging adjacent significant windows. -pub fn csw_find_regions(data : CswDataSet, result : CswResult, merge_tol : Int) -> Array[CswRegion] { +pub fn csw_find_regions( + data : CswDataSet, + result : CswResult, + merge_tol : Int, +) -> Array[CswRegion] { let regions : Array[CswRegion] = Array::new() let n = result.window_indices.length() let mut i = 0 @@ -521,7 +600,12 @@ pub fn csw_find_regions(data : CswDataSet, result : CswResult, merge_tol : Int) let mut end_idx = i while end_idx + 1 < n && result.significant[end_idx + 1] && - csw_can_merge_windows(data, result.window_indices[end_idx], result.window_indices[end_idx + 1], merge_tol) { + csw_can_merge_windows( + data, + result.window_indices[end_idx], + result.window_indices[end_idx + 1], + merge_tol, + ) { end_idx = end_idx + 1 } let region = csw_build_region(data, result, start_idx, end_idx) @@ -533,17 +617,29 @@ pub fn csw_find_regions(data : CswDataSet, result : CswResult, merge_tol : Int) ///| /// Check if two windows can be merged into a region. -fn csw_can_merge_windows(data : CswDataSet, idx1 : Int, idx2 : Int, tol : Int) -> Bool { +fn csw_can_merge_windows( + data : CswDataSet, + idx1 : Int, + idx2 : Int, + tol : Int, +) -> Bool { let w1 = data.filtered_windows[idx1] let w2 = data.filtered_windows[idx2] - if w1.chrom != w2.chrom { return false } + if w1.chrom != w2.chrom { + return false + } let gap = w2.start - w1.end gap >= 0 && gap <= tol } ///| /// Build a region from merged windows. -fn csw_build_region(data : CswDataSet, result : CswResult, start : Int, end : Int) -> CswRegion { +fn csw_build_region( + data : CswDataSet, + result : CswResult, + start : Int, + end : Int, +) -> CswRegion { let win_indices : Array[Int] = Array::new() let mut i = start let mut combined_chi2 = 0.0 @@ -560,8 +656,12 @@ fn csw_build_region(data : CswDataSet, result : CswResult, start : Int, end : In } let w = data.filtered_windows[wi] chrom = w.chrom - if w.start.to_double() < rstart { rstart = w.start.to_double() } - if w.end.to_double() > rend { rend = w.end.to_double() } + if w.start.to_double() < rstart { + rstart = w.start.to_double() + } + if w.end.to_double() > rend { + rend = w.end.to_double() + } i = i + 1 } let n_windows = end - start + 1 @@ -578,15 +678,18 @@ fn csw_build_region(data : CswDataSet, result : CswResult, start : Int, end : In combined_p_value: combined_p, max_log_fc: max_lfc, n_windows, - window_indices: win_indices + window_indices: win_indices, } } // ===== Helper functions ===== +///| fn csw_mean_double(arr : Array[Double]) -> Double { let n = arr.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut sum = 0.0 let mut i = 0 while i < n { @@ -596,9 +699,12 @@ fn csw_mean_double(arr : Array[Double]) -> Double { sum / n.to_double() } +///| fn csw_mean_int(arr : Array[Int]) -> Double { let n = arr.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut sum = 0.0 let mut i = 0 while i < n { @@ -608,6 +714,7 @@ fn csw_mean_int(arr : Array[Int]) -> Double { sum / n.to_double() } +///| fn csw_total_cpb(counts : Array[Double], lib_sizes : Array[Double]) -> Double { let mut total = 0.0 let mut i = 0 @@ -619,9 +726,15 @@ fn csw_total_cpb(counts : Array[Double], lib_sizes : Array[Double]) -> Double { total } -fn csw_mean_var_group(counts : Array[Double], indices : Array[Int]) -> (Double, Double) { +///| +fn csw_mean_var_group( + counts : Array[Double], + indices : Array[Int], +) -> (Double, Double) { let n = indices.length() - if n == 0 { return (0.0, 0.0) } + if n == 0 { + return (0.0, 0.0) + } let mut sum = 0.0 let mut i = 0 while i < n { @@ -645,7 +758,11 @@ fn csw_mean_var_group(counts : Array[Double], indices : Array[Int]) -> (Double, fn csw_norm_p_value(z : Double) -> Double { let abs_z = z.abs() let p_approx = 2.0 * (1.0 - csw_norm_cdf(abs_z)) - if p_approx < 1.0e-300 { 1.0e-300 } else { p_approx } + if p_approx < 1.0e-300 { + 1.0e-300 + } else { + p_approx + } } ///| @@ -653,7 +770,12 @@ fn csw_norm_p_value(z : Double) -> Double { fn csw_norm_cdf(x : Double) -> Double { let t = 1.0 / (1.0 + 0.2316419 * x) let d = 0.3989422804014327 * @math.exp(-0.5 * x * x) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.3302744)))) + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.3302744))) + ) 1.0 - p } @@ -661,7 +783,9 @@ fn csw_norm_cdf(x : Double) -> Double { /// Benjamini-Hochberg correction. fn csw_bh_correction(p_values : Array[Double]) -> Array[Double] { let n = p_values.length() - if n == 0 { return Array::new() } + if n == 0 { + return Array::new() + } let indexed : Array[(Double, Int)] = Array::new() let mut i = 0 while i < n { @@ -718,8 +842,12 @@ fn csw_bh_correction(p_values : Array[Double]) -> Array[Double] { ///| /// Chi-squared survival function approximation. fn csw_chi2_sf(x : Double, df : Double) -> Double { - if x <= 0.0 { return 1.0 } - if df <= 0.0 { return 1.0 } + if x <= 0.0 { + return 1.0 + } + if df <= 0.0 { + return 1.0 + } // Wilson-Hilferty approximation let z = @math.pow(x / df, 1.0 / 3.0) let mu = 1.0 - 2.0 / (9.0 * df) diff --git a/src/cyclone.mbt b/src/cyclone.mbt index cd0205d8..04f29a1f 100644 --- a/src/cyclone.mbt +++ b/src/cyclone.mbt @@ -42,15 +42,15 @@ pub struct CycloneParams { ///| /// Create default Cyclone parameters. pub fn CycloneParams::new() -> CycloneParams { - CycloneParams::{ - min_score: 0.0, - n_top_pairs: 1, - } + CycloneParams::{ min_score: 0.0, n_top_pairs: 1 } } ///| /// Create custom Cyclone parameters. -pub fn CycloneParams::with_params(min_score : Double, n_top_pairs : Int) -> CycloneParams { +pub fn CycloneParams::with_params( + min_score : Double, + n_top_pairs : Int, +) -> CycloneParams { CycloneParams::{ min_score, n_top_pairs } } @@ -122,7 +122,9 @@ pub fn cyclone_get_phases(gene_pairs : Array[GenePair]) -> Array[String] { ///| /// Count gene pairs for each phase. -pub fn cyclone_count_pairs_by_phase(gene_pairs : Array[GenePair]) -> Map[String, Int] { +pub fn cyclone_count_pairs_by_phase( + gene_pairs : Array[GenePair], +) -> Map[String, Int] { let counts : Map[String, Int] = Map([]) for pair in gene_pairs { let current = counts.get(pair.phase).unwrap_or(0) @@ -178,7 +180,9 @@ pub fn cyclone_score_cell( let scores : Map[String, Double] = Map([], capacity=phases.length()) for phase in phases { - let score = cyclone_score_phase(cell_expression, gene_names, gene_pairs, phase) + let score = cyclone_score_phase( + cell_expression, gene_names, gene_pairs, phase, + ) scores.set(phase, score) } @@ -261,7 +265,12 @@ pub fn cyclone_score_cells( cell_expr.push(counts[j][i]) j = j + 1 } - let result = cyclone_score_single_cell(cell_expr, cell_ids[i], gene_names, gene_pairs) + let result = cyclone_score_single_cell( + cell_expr, + cell_ids[i], + gene_names, + gene_pairs, + ) results.push(result) i = i + 1 } @@ -271,7 +280,9 @@ pub fn cyclone_score_cells( ///| /// Get a summary of cell cycle phase distribution. -pub fn cyclone_phase_distribution(results : Array[CycloneResult]) -> Map[String, Double] { +pub fn cyclone_phase_distribution( + results : Array[CycloneResult], +) -> Map[String, Double] { let n = results.length() if n == 0 { return Map([]) @@ -295,7 +306,11 @@ pub fn cyclone_phase_distribution(results : Array[CycloneResult]) -> Map[String, ///| /// Create synthetic test data for Cyclone testing. -pub fn cyclone_create_test_data() -> (Array[Array[Double]], Array[String], Array[String]) { +pub fn cyclone_create_test_data() -> ( + Array[Array[Double]], + Array[String], + Array[String], +) { let gene_pairs = cyclone_get_gene_pairs() // Collect all unique gene names from pairs @@ -369,7 +384,9 @@ pub fn cyclone_create_test_data() -> (Array[Array[Double]], Array[String], Array ///| /// Get the average scores for each phase across all cells. -pub fn cyclone_average_scores(results : Array[CycloneResult]) -> Map[String, Double] { +pub fn cyclone_average_scores( + results : Array[CycloneResult], +) -> Map[String, Double] { if results.length() == 0 { return Map([]) } @@ -386,4 +403,4 @@ pub fn cyclone_average_scores(results : Array[CycloneResult]) -> Map[String, Dou } avg_scores -} \ No newline at end of file +} diff --git a/src/data.mbt b/src/data.mbt index c19077a5..d0b5851b 100644 --- a/src/data.mbt +++ b/src/data.mbt @@ -172,27 +172,174 @@ pub struct AminoAcidProperty { pub fn amino_acid_properties(aa : String) -> AminoAcidProperty { let upper = aa.to_upper() match upper { - "A" => AminoAcidProperty::{ amino_acid: "A", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: 1.8 } - "R" => AminoAcidProperty::{ amino_acid: "R", property: "positive", polarity: "polar", charge: 1.0, hydropathy: -4.5 } - "N" => AminoAcidProperty::{ amino_acid: "N", property: "polar", polarity: "polar", charge: 0.0, hydropathy: -3.5 } - "D" => AminoAcidProperty::{ amino_acid: "D", property: "negative", polarity: "polar", charge: -1.0, hydropathy: -3.5 } - "C" => AminoAcidProperty::{ amino_acid: "C", property: "polar", polarity: "polar", charge: 0.0, hydropathy: 2.5 } - "Q" => AminoAcidProperty::{ amino_acid: "Q", property: "polar", polarity: "polar", charge: 0.0, hydropathy: -3.5 } - "E" => AminoAcidProperty::{ amino_acid: "E", property: "negative", polarity: "polar", charge: -1.0, hydropathy: -3.5 } - "G" => AminoAcidProperty::{ amino_acid: "G", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: -0.4 } - "H" => AminoAcidProperty::{ amino_acid: "H", property: "positive", polarity: "polar", charge: 1.0, hydropathy: -3.2 } - "I" => AminoAcidProperty::{ amino_acid: "I", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: 4.5 } - "L" => AminoAcidProperty::{ amino_acid: "L", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: 3.8 } - "K" => AminoAcidProperty::{ amino_acid: "K", property: "positive", polarity: "polar", charge: 1.0, hydropathy: -3.9 } - "M" => AminoAcidProperty::{ amino_acid: "M", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: 1.9 } - "F" => AminoAcidProperty::{ amino_acid: "F", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: 2.8 } - "P" => AminoAcidProperty::{ amino_acid: "P", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: -1.6 } - "S" => AminoAcidProperty::{ amino_acid: "S", property: "polar", polarity: "polar", charge: 0.0, hydropathy: -0.8 } - "T" => AminoAcidProperty::{ amino_acid: "T", property: "polar", polarity: "polar", charge: 0.0, hydropathy: -0.7 } - "W" => AminoAcidProperty::{ amino_acid: "W", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: -0.9 } - "Y" => AminoAcidProperty::{ amino_acid: "Y", property: "polar", polarity: "polar", charge: 0.0, hydropathy: -1.3 } - "V" => AminoAcidProperty::{ amino_acid: "V", property: "hydrophobic", polarity: "nonpolar", charge: 0.0, hydropathy: 4.2 } - _ => AminoAcidProperty::{ amino_acid: "?", property: "unknown", polarity: "unknown", charge: 0.0, hydropathy: 0.0 } + "A" => + AminoAcidProperty::{ + amino_acid: "A", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: 1.8, + } + "R" => + AminoAcidProperty::{ + amino_acid: "R", + property: "positive", + polarity: "polar", + charge: 1.0, + hydropathy: -4.5, + } + "N" => + AminoAcidProperty::{ + amino_acid: "N", + property: "polar", + polarity: "polar", + charge: 0.0, + hydropathy: -3.5, + } + "D" => + AminoAcidProperty::{ + amino_acid: "D", + property: "negative", + polarity: "polar", + charge: -1.0, + hydropathy: -3.5, + } + "C" => + AminoAcidProperty::{ + amino_acid: "C", + property: "polar", + polarity: "polar", + charge: 0.0, + hydropathy: 2.5, + } + "Q" => + AminoAcidProperty::{ + amino_acid: "Q", + property: "polar", + polarity: "polar", + charge: 0.0, + hydropathy: -3.5, + } + "E" => + AminoAcidProperty::{ + amino_acid: "E", + property: "negative", + polarity: "polar", + charge: -1.0, + hydropathy: -3.5, + } + "G" => + AminoAcidProperty::{ + amino_acid: "G", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: -0.4, + } + "H" => + AminoAcidProperty::{ + amino_acid: "H", + property: "positive", + polarity: "polar", + charge: 1.0, + hydropathy: -3.2, + } + "I" => + AminoAcidProperty::{ + amino_acid: "I", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: 4.5, + } + "L" => + AminoAcidProperty::{ + amino_acid: "L", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: 3.8, + } + "K" => + AminoAcidProperty::{ + amino_acid: "K", + property: "positive", + polarity: "polar", + charge: 1.0, + hydropathy: -3.9, + } + "M" => + AminoAcidProperty::{ + amino_acid: "M", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: 1.9, + } + "F" => + AminoAcidProperty::{ + amino_acid: "F", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: 2.8, + } + "P" => + AminoAcidProperty::{ + amino_acid: "P", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: -1.6, + } + "S" => + AminoAcidProperty::{ + amino_acid: "S", + property: "polar", + polarity: "polar", + charge: 0.0, + hydropathy: -0.8, + } + "T" => + AminoAcidProperty::{ + amino_acid: "T", + property: "polar", + polarity: "polar", + charge: 0.0, + hydropathy: -0.7, + } + "W" => + AminoAcidProperty::{ + amino_acid: "W", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: -0.9, + } + "Y" => + AminoAcidProperty::{ + amino_acid: "Y", + property: "polar", + polarity: "polar", + charge: 0.0, + hydropathy: -1.3, + } + "V" => + AminoAcidProperty::{ + amino_acid: "V", + property: "hydrophobic", + polarity: "nonpolar", + charge: 0.0, + hydropathy: 4.2, + } + _ => + AminoAcidProperty::{ + amino_acid: "?", + property: "unknown", + polarity: "unknown", + charge: 0.0, + hydropathy: 0.0, + } } } @@ -285,18 +432,15 @@ pub fn reverse_codon_table() -> Map[String, Array[String]] { for codon in forward.keys() { match forward.get(codon) { - Some(aa) => { + Some(aa) => match result.get(aa) { Some(arr) => { let new_arr = arr.copy() new_arr.push(codon) result[aa] = new_arr } - None => { - result[aa] = [codon] - } + None => result[aa] = [codon] } - } None => () } } diff --git a/src/decoupler.mbt b/src/decoupler.mbt index 9802d9d7..c30ba280 100644 --- a/src/decoupler.mbt +++ b/src/decoupler.mbt @@ -21,17 +21,17 @@ ///| /// A single directed interaction in the prior knowledge network. pub struct PKNEdge { - source : String // regulator (TF) name - target : String // target gene name - weight : Double // mode of regulation: >0 activation, <0 inhibition + source : String // regulator (TF) name + target : String // target gene name + weight : Double // mode of regulation: >0 activation, <0 inhibition } ///| /// Prior knowledge network: collection of regulator→target edges. pub struct PriorKnowledgeNetwork { edges : Array[PKNEdge] - regulators : Array[String] // unique regulator names - targets : Array[String] // unique target names + regulators : Array[String] // unique regulator names + targets : Array[String] // unique target names } ///| @@ -63,7 +63,7 @@ pub struct ActivityScore { regulator : String sample : String score : Double - p_value : Double // only meaningful for ulm/mlm; 1.0 otherwise + p_value : Double // only meaningful for ulm/mlm; 1.0 otherwise } ///| @@ -71,8 +71,8 @@ pub struct ActivityScore { pub struct DecoupleRResult { regulators : Array[String] samples : Array[String] - matrix : Array[Array[Double]] // matrix[i][j] = activity of regulator i in sample j - scores : Array[ActivityScore] // flat list of scores + matrix : Array[Array[Double]] // matrix[i][j] = activity of regulator i in sample j + scores : Array[ActivityScore] // flat list of scores method : String } @@ -172,7 +172,9 @@ fn decoupler_wsum( gene_names : Array[String], pkn : PriorKnowledgeNetwork, ) -> DecoupleRResult { - let (reg_list, tgt_indices, w) = decoupler_build_weight_matrix(pkn, gene_names) + let (reg_list, tgt_indices, w) = decoupler_build_weight_matrix( + pkn, gene_names, + ) let n_reg = reg_list.length() let n_samples = expression.length() let matrix : Array[Array[Double]] = Array::new() @@ -209,7 +211,9 @@ fn decoupler_wmean( gene_names : Array[String], pkn : PriorKnowledgeNetwork, ) -> DecoupleRResult { - let (reg_list, tgt_indices, w) = decoupler_build_weight_matrix(pkn, gene_names) + let (reg_list, tgt_indices, w) = decoupler_build_weight_matrix( + pkn, gene_names, + ) let n_reg = reg_list.length() let n_samples = expression.length() let matrix : Array[Array[Double]] = Array::new() @@ -362,7 +366,8 @@ fn decoupler_normal_cdf(x : Double) -> Double { let sign = if x < 0.0 { -1.0 } else { 1.0 } let xa = x.abs() / 2.0.sqrt() let t = 1.0 / (1.0 + p * xa) - let y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * @math.exp(-xa * xa) + let y = 1.0 - + ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * @math.exp(-xa * xa) 0.5 * (1.0 + sign * y) } @@ -395,7 +400,9 @@ fn decoupler_ulm( gene_names : Array[String], pkn : PriorKnowledgeNetwork, ) -> DecoupleRResult { - let (reg_list, tgt_indices, w) = decoupler_build_weight_matrix(pkn, gene_names) + let (reg_list, tgt_indices, w) = decoupler_build_weight_matrix( + pkn, gene_names, + ) let n_reg = reg_list.length() let n_samples = expression.length() let matrix : Array[Array[Double]] = Array::new() @@ -459,21 +466,25 @@ fn decoupler_ulm( // Not meaningful; we set p_value to 1.0 since per-sample scores are unitless z-scores. let mut j = 0 while j < n_samples { - scores.push( - ActivityScore::{ - regulator: reg_list[i], - sample: sample_names[j], - score: matrix[i][j], - p_value: 1.0, - }, - ) + scores.push(ActivityScore::{ + regulator: reg_list[i], + sample: sample_names[j], + score: matrix[i][j], + p_value: 1.0, + }) j = j + 1 } i = i + 1 } // Use original t-stat style only if we have at least one target (avoid empty) // Use the standardized score as the activity; method tag is "ulm". - DecoupleRResult::{ regulators: reg_list, samples: sample_names, matrix, scores, method: "ulm" } + DecoupleRResult::{ + regulators: reg_list, + samples: sample_names, + matrix, + scores, + method: "ulm", + } } ///| @@ -495,7 +506,9 @@ fn decoupler_mlm( gene_names : Array[String], pkn : PriorKnowledgeNetwork, ) -> DecoupleRResult { - let (reg_list, tgt_indices, w) = decoupler_build_weight_matrix(pkn, gene_names) + let (reg_list, tgt_indices, w) = decoupler_build_weight_matrix( + pkn, gene_names, + ) let n_reg = reg_list.length() let n_samples = expression.length() let matrix : Array[Array[Double]] = Array::new() @@ -530,19 +543,23 @@ fn decoupler_mlm( } let (_, slope, _, _, _) = decoupler_simple_linear_regression(x, y) matrix[i][j] = slope - scores.push( - ActivityScore::{ - regulator: reg_list[i], - sample: sample_names[j], - score: slope, - p_value: 1.0, - }, - ) + scores.push(ActivityScore::{ + regulator: reg_list[i], + sample: sample_names[j], + score: slope, + p_value: 1.0, + }) j = j + 1 } i = i + 1 } - DecoupleRResult::{ regulators: reg_list, samples: sample_names, matrix, scores, method: "mlm" } + DecoupleRResult::{ + regulators: reg_list, + samples: sample_names, + matrix, + scores, + method: "mlm", + } } ///| @@ -610,14 +627,12 @@ fn decoupler_pack_result( while i < regulators.length() { let mut j = 0 while j < samples.length() { - scores.push( - ActivityScore::{ - regulator: regulators[i], - sample: samples[j], - score: matrix[i][j], - p_value: 1.0, - }, - ) + scores.push(ActivityScore::{ + regulator: regulators[i], + sample: samples[j], + score: matrix[i][j], + p_value: 1.0, + }) j = j + 1 } i = i + 1 @@ -642,11 +657,16 @@ pub fn decoupler_run( method? : DecoupleRMethod = DecoupleRMethod::ULM, ) -> DecoupleRResult { match method { - DecoupleRMethod::WSum => decoupler_wsum(expression, sample_names, gene_names, pkn) - DecoupleRMethod::WMean => decoupler_wmean(expression, sample_names, gene_names, pkn) - DecoupleRMethod::Norm => decoupler_norm(expression, sample_names, gene_names, pkn) - DecoupleRMethod::ULM => decoupler_ulm(expression, sample_names, gene_names, pkn) - DecoupleRMethod::MLM => decoupler_mlm(expression, sample_names, gene_names, pkn) + DecoupleRMethod::WSum => + decoupler_wsum(expression, sample_names, gene_names, pkn) + DecoupleRMethod::WMean => + decoupler_wmean(expression, sample_names, gene_names, pkn) + DecoupleRMethod::Norm => + decoupler_norm(expression, sample_names, gene_names, pkn) + DecoupleRMethod::ULM => + decoupler_ulm(expression, sample_names, gene_names, pkn) + DecoupleRMethod::MLM => + decoupler_mlm(expression, sample_names, gene_names, pkn) } } @@ -675,14 +695,12 @@ pub fn decoupler_top_regulators( let arr : Array[ActivityScore] = [] let mut i = 0 while i < result.regulators.length() { - arr.push( - ActivityScore::{ - regulator: result.regulators[i], - sample: sample_name, - score: result.matrix[i][s_idx], - p_value: 1.0, - }, - ) + arr.push(ActivityScore::{ + regulator: result.regulators[i], + sample: sample_name, + score: result.matrix[i][s_idx], + p_value: 1.0, + }) i = i + 1 } // Sort by absolute score descending @@ -729,7 +747,12 @@ pub fn decoupler_filter_scores( ///| /// Generate a small sample dataset for testing and demos. /// Returns (expression, sample_names, gene_names, pkn) where 3 TFs regulate 8 targets. -pub fn decoupler_sample_data() -> (Array[Array[Double]], Array[String], Array[String], PriorKnowledgeNetwork) { +pub fn decoupler_sample_data() -> ( + Array[Array[Double]], + Array[String], + Array[String], + PriorKnowledgeNetwork, +) { let gene_names = [ "TF1", "TF2", "TF3", "G1", "G2", "G3", "G4", "G5", "G6", "G7", "G8", ] diff --git a/src/delayed_matrix_stats.mbt b/src/delayed_matrix_stats.mbt index 2ff40599..04a4a36b 100644 --- a/src/delayed_matrix_stats.mbt +++ b/src/delayed_matrix_stats.mbt @@ -208,9 +208,7 @@ fn compute_single_stat(values : Array[Double], stat : String) -> Double { let variance = compute_single_stat(valid, "var") variance.sqrt() } - "n" | "nna" | "nn" => { - nv.to_double() - } + "n" | "nna" | "nn" => nv.to_double() _ => 0.0 } } @@ -312,4 +310,4 @@ pub fn col_n(matrix : DelayedMatrix) -> Array[Int] { j = j + 1 } result -} \ No newline at end of file +} diff --git a/src/deseq2.mbt b/src/deseq2.mbt index f0abc278..6e2f6cfa 100644 --- a/src/deseq2.mbt +++ b/src/deseq2.mbt @@ -21,7 +21,7 @@ pub fn DESeqDataSet::new( ) -> DESeqDataSet { let n_genes = counts.length() let n_samples = if counts.length() > 0 { counts[0].length() } else { 0 } - + DESeqDataSet::{ counts, row_names, @@ -68,7 +68,7 @@ pub fn DESeqResults::new( pub fn estimate_size_factors(dds : DESeqDataSet) -> DESeqDataSet { let n_genes = dds.counts.length() let n_samples = dds.col_names.length() - + let geo_means : Array[Double] = Array::new() for i = 0; i < n_genes; i = i + 1 { let gene_counts : Array[Double] = Array::new() @@ -77,7 +77,7 @@ pub fn estimate_size_factors(dds : DESeqDataSet) -> DESeqDataSet { } geo_means.push(stat_geometric_mean(gene_counts)) } - + let size_factors : Array[Double] = Array::new() for j = 0; j < n_samples; j = j + 1 { let ratios : Array[Double] = Array::new() @@ -86,26 +86,22 @@ pub fn estimate_size_factors(dds : DESeqDataSet) -> DESeqDataSet { ratios.push(dds.counts[i][j].to_double() / geo_means[i]) } } - - let median_val = if ratios.length() > 0 { - stat_median(ratios) - } else { - 1.0 - } + + let median_val = if ratios.length() > 0 { stat_median(ratios) } else { 1.0 } size_factors.push(median_val) } - + let mut mean_sf = 0.0 for sf in size_factors { mean_sf = mean_sf + sf } mean_sf = mean_sf / n_samples.to_double() - + let norm_sf : Array[Double] = Array::new() for sf in size_factors { norm_sf.push(sf / mean_sf) } - + DESeqDataSet::{ counts: dds.counts, row_names: dds.row_names, @@ -120,7 +116,7 @@ pub fn estimate_size_factors(dds : DESeqDataSet) -> DESeqDataSet { pub fn normalize_counts(dds : DESeqDataSet) -> Array[Array[Double]] { let n_genes = dds.counts.length() let n_samples = dds.col_names.length() - + let normalized : Array[Array[Double]] = Array::new() for i = 0; i < n_genes; i = i + 1 { let row : Array[Double] = Array::new() @@ -140,9 +136,9 @@ pub fn normalize_counts(dds : DESeqDataSet) -> Array[Array[Double]] { pub fn log2_cpm(dds : DESeqDataSet) -> Array[Array[Double]] { let n_genes = dds.counts.length() let n_samples = dds.col_names.length() - + let normalized = normalize_counts(dds) - + let lib_sizes : Array[Double] = Array::new() for j = 0; j < n_samples; j = j + 1 { let mut sum = 0.0 @@ -151,7 +147,7 @@ pub fn log2_cpm(dds : DESeqDataSet) -> Array[Array[Double]] { } lib_sizes.push(sum) } - + let log2_cpm : Array[Array[Double]] = Array::new() for i = 0; i < n_genes; i = i + 1 { let row : Array[Double] = Array::new() @@ -172,25 +168,31 @@ pub fn log2_cpm(dds : DESeqDataSet) -> Array[Array[Double]] { pub fn estimate_dispersions(dds : DESeqDataSet) -> DESeqDataSet { let n_genes = dds.counts.length() let n_samples = dds.col_names.length() - + let normalized = normalize_counts(dds) - + let log_means : Array[Double] = Array::new() for i = 0; i < n_genes; i = i + 1 { let mut sum = 0.0 for j = 0; j < n_samples; j = j + 1 { sum = sum + normalized[i][j] } - log_means.push(if sum > 0.0 { @math.ln(sum / n_samples.to_double()) } else { -10.0 }) + log_means.push( + if sum > 0.0 { + @math.ln(sum / n_samples.to_double()) + } else { + -10.0 + }, + ) } - + let dispersions : Array[Double] = Array::new() for i = 0; i < n_genes; i = i + 1 { let mut sum_counts = 0.0 for j = 0; j < n_samples; j = j + 1 { sum_counts = sum_counts + dds.counts[i][j].to_double() } - + if sum_counts > 0.0 { let mu_hat = sum_counts / n_samples.to_double() let mut var_obs = 0.0 @@ -199,7 +201,7 @@ pub fn estimate_dispersions(dds : DESeqDataSet) -> DESeqDataSet { var_obs = var_obs + diff * diff } var_obs = var_obs / (n_samples - 1).to_double() - + if mu_hat > 0.0 { let disp_est = (var_obs / mu_hat - 1.0) / mu_hat dispersions.push(if disp_est > 0.001 { disp_est } else { 0.001 }) @@ -210,10 +212,10 @@ pub fn estimate_dispersions(dds : DESeqDataSet) -> DESeqDataSet { dispersions.push(0.1) } } - + let alpha = 0.1 let beta = 0.5 - + let final_dispersions : Array[Double] = Array::new() for i = 0; i < n_genes; i = i + 1 { let raw_disp = dispersions[i] @@ -221,7 +223,7 @@ pub fn estimate_dispersions(dds : DESeqDataSet) -> DESeqDataSet { let weight = 1.0 / (1.0 / n_samples.to_double() + 1.0) final_dispersions.push((1.0 - weight) * prior_disp + weight * raw_disp) } - + DESeqDataSet::{ counts: dds.counts, row_names: dds.row_names, @@ -236,7 +238,12 @@ pub fn estimate_dispersions(dds : DESeqDataSet) -> DESeqDataSet { fn pnorm(x : Double) -> Double { let t = 1.0 / (1.0 + 0.2316419 * x.abs()) let d = 0.3989423 * @math.exp(-x * x / 2.0) - let prob = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))) + let prob = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))) + ) if x >= 0.0 { 1.0 - prob } else { @@ -249,71 +256,79 @@ pub fn deseq(dds : DESeqDataSet) -> DESeqResults { let n_genes = dds.counts.length() let n_samples = dds.col_names.length() let n_coefs = if dds.design.length() > 0 { dds.design[0].length() } else { 0 } - + let base_mean : Array[Double] = Array::new() let log2_fold_change : Array[Double] = Array::new() let lfc_se : Array[Double] = Array::new() let stat : Array[Double] = Array::new() let p_value : Array[Double] = Array::new() - + let normalized = normalize_counts(dds) - + for i = 0; i < n_genes; i = i + 1 { let mut sum_x = 0.0 let mut sum_y = 0.0 let mut sum_xy = 0.0 let mut sum_x2 = 0.0 let mut n = 0.0 - + for j = 0; j < n_samples; j = j + 1 { let x = dds.design[j][1] - let y = if normalized[i][j] > 0.0 { @math.ln(normalized[i][j]) } else { 0.0 } + let y = if normalized[i][j] > 0.0 { + @math.ln(normalized[i][j]) + } else { + 0.0 + } sum_x = sum_x + x sum_y = sum_y + y sum_xy = sum_xy + x * y sum_x2 = sum_x2 + x * x n = n + 1.0 } - + let denom = n * sum_x2 - sum_x * sum_x - let b1 = if denom != 0.0 { (n * sum_xy - sum_x * sum_y) / denom } else { 0.0 } + let b1 = if denom != 0.0 { + (n * sum_xy - sum_x * sum_y) / denom + } else { + 0.0 + } let b0 = (sum_y - b1 * sum_x) / n - + let mut sse = 0.0 for j = 0; j < n_samples; j = j + 1 { let x = dds.design[j][1] - let y = if normalized[i][j] > 0.0 { @math.ln(normalized[i][j]) } else { 0.0 } + let y = if normalized[i][j] > 0.0 { + @math.ln(normalized[i][j]) + } else { + 0.0 + } let pred = b0 + b1 * x sse = sse + (y - pred) * (y - pred) } - + let disp = dds.dispersions[i] let eff_var = sse / (n - 2.0) + disp * @math.exp(2.0 * b0) - - let se_b1 = if denom != 0.0 { - (eff_var / denom).sqrt() - } else { - 1.0 - } - + + let se_b1 = if denom != 0.0 { (eff_var / denom).sqrt() } else { 1.0 } + let mut sum_fitted = 0.0 for j = 0; j < n_samples; j = j + 1 { let x = dds.design[j][1] sum_fitted = sum_fitted + @math.exp(b0 + b1 * x) } base_mean.push(sum_fitted / n) - + log2_fold_change.push(b1 * @math.ln(2.0)) lfc_se.push(se_b1 * @math.ln(2.0)) - + let t_stat = if se_b1 > 0.0 { b1 / se_b1 } else { 0.0 } stat.push(t_stat) - + p_value.push(2.0 * (1.0 - pnorm(t_stat.abs()))) } - + let padj = deseq2_adjust_p_values(p_value) - + DESeqResults::new( dds.row_names, base_mean, @@ -336,12 +351,12 @@ fn deseq2_adjust_p_values(p_values : Array[Double]) -> Array[Double] { if n == 0 { return [] } - + let indices : Array[Int] = Array::new() for i = 0; i < n; i = i + 1 { indices.push(i) } - + let sorted_indices = Array::new() for idx in indices { sorted_indices.push(idx) @@ -355,9 +370,9 @@ fn deseq2_adjust_p_values(p_values : Array[Double]) -> Array[Double] { } } } - + let padj : Array[Double] = Array::make(n, 1.0) - + let mut min_padj = 1.0 let mut i = n - 1 while i >= 0 { @@ -369,7 +384,7 @@ fn deseq2_adjust_p_values(p_values : Array[Double]) -> Array[Double] { padj[sorted_indices[i]] = min_padj i = i - 1 } - + let final_padj : Array[Double] = Array::new() for p in padj { final_padj.push(if p > 1.0 { 1.0 } else { p }) @@ -378,25 +393,29 @@ fn deseq2_adjust_p_values(p_values : Array[Double]) -> Array[Double] { } ///| -pub fn lfc_shrink(dds : DESeqDataSet, res : DESeqResults, coef? : Int = -1) -> DESeqResults { +pub fn lfc_shrink( + dds : DESeqDataSet, + res : DESeqResults, + coef? : Int = -1, +) -> DESeqResults { let n_genes = dds.counts.length() - + let shrunk_lfc : Array[Double] = Array::new() let shrunk_se : Array[Double] = Array::new() - + let prior_var = 0.5 - + for i = 0; i < n_genes; i = i + 1 { let raw_lfc = res.log2_fold_change[i] let raw_se = res.lfc_se[i] - + let se2 = raw_se * raw_se let weight = se2 / (se2 + prior_var) - + shrunk_lfc.push(weight * raw_lfc) shrunk_se.push((se2 * prior_var / (se2 + prior_var)).sqrt()) } - + DESeqResults::new( res.row_names, res.base_mean, @@ -416,7 +435,8 @@ pub fn significant_genes( ) -> Array[String] { let genes : Array[String] = Array::new() for i = 0; i < results.row_names.length(); i = i + 1 { - if results.padj[i] < alpha && results.log2_fold_change[i].abs() > lfc_threshold { + if results.padj[i] < alpha && + results.log2_fold_change[i].abs() > lfc_threshold { genes.push(results.row_names[i]) } } @@ -424,15 +444,18 @@ pub fn significant_genes( } ///| -pub fn top_genes(results : DESeqResults, n? : Int = 10) -> Array[(String, Double, Double)] { +pub fn top_genes( + results : DESeqResults, + n? : Int = 10, +) -> Array[(String, Double, Double)] { let n_genes = results.row_names.length() let actual_n = if n < n_genes { n } else { n_genes } - + let indices : Array[Int] = Array::new() for i = 0; i < n_genes; i = i + 1 { indices.push(i) } - + let sorted_indices = Array::new() for idx in indices { sorted_indices.push(idx) @@ -446,11 +469,13 @@ pub fn top_genes(results : DESeqResults, n? : Int = 10) -> Array[(String, Double } } } - + let top : Array[(String, Double, Double)] = Array::new() for i = 0; i < actual_n; i = i + 1 { let idx = sorted_indices[i] - top.push((results.row_names[idx], results.log2_fold_change[idx], results.padj[idx])) + top.push( + (results.row_names[idx], results.log2_fold_change[idx], results.padj[idx]), + ) } top } @@ -458,34 +483,39 @@ pub fn top_genes(results : DESeqResults, n? : Int = 10) -> Array[(String, Double ///| pub fn sample_deseq_dataset() -> DESeqDataSet { let genes = [ - "GeneA", "GeneB", "GeneC", "GeneD", "GeneE", "GeneF", "GeneG", "GeneH", "GeneI", "GeneJ", - "GeneK", "GeneL", "GeneM", "GeneN", "GeneO", "GeneP", "GeneQ", "GeneR", "GeneS", "GeneT", + "GeneA", "GeneB", "GeneC", "GeneD", "GeneE", "GeneF", "GeneG", "GeneH", "GeneI", + "GeneJ", "GeneK", "GeneL", "GeneM", "GeneN", "GeneO", "GeneP", "GeneQ", "GeneR", + "GeneS", "GeneT", ] let samples = ["Ctrl1", "Ctrl2", "Ctrl3", "Treat1", "Treat2", "Treat3"] - + let counts : Array[Array[Int]] = Array::new() for i = 0; i < 20; i = i + 1 { let row : Array[Int] = Array::new() let base = 100.0 + i.to_double() * 50.0 - + for j = 0; j < 3; j = j + 1 { let noise = ((i * 7 + j * 13) % 20 - 10).to_double() * 0.1 row.push((base * (1.0 + noise)).to_int()) } - + for j = 3; j < 6; j = j + 1 { let fold_change = if i < 5 { 2.5 } else if i >= 15 { 0.4 } else { 1.0 } let noise = ((i * 7 + j * 13) % 20 - 10).to_double() * 0.1 row.push((base * fold_change * (1.0 + noise)).to_int()) } - + counts.push(row) } - + let design : Array[Array[Double]] = [ - [1.0, 0.0], [1.0, 0.0], [1.0, 0.0], - [1.0, 1.0], [1.0, 1.0], [1.0, 1.0], + [1.0, 0.0], + [1.0, 0.0], + [1.0, 0.0], + [1.0, 1.0], + [1.0, 1.0], + [1.0, 1.0], ] - + DESeqDataSet::new(counts, genes, samples, design) } diff --git a/src/deseq2_advanced.mbt b/src/deseq2_advanced.mbt index 2a073116..03a79ea3 100644 --- a/src/deseq2_advanced.mbt +++ b/src/deseq2_advanced.mbt @@ -139,11 +139,7 @@ pub fn vst(dds : DESeqDataSet, nsub? : Int = 1000) -> VSTResult { let mut sum_var_minus_mu = 0.0 let mut n_valid = 0 - let step = if n_genes > actual_nsub { - n_genes / actual_nsub - } else { - 1 - } + let step = if n_genes > actual_nsub { n_genes / actual_nsub } else { 1 } let mut i = 0 while i < n_genes && n_valid < actual_nsub { @@ -176,7 +172,13 @@ pub fn vst(dds : DESeqDataSet, nsub? : Int = 1000) -> VSTResult { let est_disp = if n_valid > 0 && sum_mu_sq > 0.0 { let d = sum_var_minus_mu / sum_mu_sq // Clamp to reasonable range - if d < 0.001 { 0.001 } else if d > 10.0 { 10.0 } else { d } + if d < 0.001 { + 0.001 + } else if d > 10.0 { + 10.0 + } else { + d + } } else { 0.1 } @@ -272,7 +274,10 @@ pub fn plot_pca(vst_result : VSTResult, ntop? : Int = 500) -> PCAResult { } // Compute covariance matrix (n_samples x n_samples) = X * X^T / (n_cols - 1) - let cov : Array[Array[Double]] = Array::make(n_samples, Array::make(n_samples, 0.0)) + let cov : Array[Array[Double]] = Array::make( + n_samples, + Array::make(n_samples, 0.0), + ) for i = 0; i < n_samples; i = i + 1 { for j = 0; j < n_samples; j = j + 1 { let mut dot = 0.0 @@ -431,7 +436,11 @@ fn normalize_vector(v : Array[Double], n : Int) -> Array[Double] { ///| /// Orthogonalize v against u (Gram-Schmidt). -fn orthogonalize(v : Array[Double], u : Array[Double], n : Int) -> Array[Double] { +fn orthogonalize( + v : Array[Double], + u : Array[Double], + n : Int, +) -> Array[Double] { let mut dot = 0.0 for i = 0; i < n; i = i + 1 { dot = dot + v[i] * u[i] diff --git a/src/destiny.mbt b/src/destiny.mbt index a15c438e..34014a50 100644 --- a/src/destiny.mbt +++ b/src/destiny.mbt @@ -48,45 +48,43 @@ pub struct DiffusionResult { pub fn CellData::new( cell_id : String, expression : Array[Double], - cluster : String + cluster : String, ) -> CellData { - CellData::{ - cell_id, - expression, - cluster - } + CellData::{ cell_id, expression, cluster } } ///| -pub fn DistanceMatrix::new(cells : Array[String], distances : Array[Array[Double]]) -> DistanceMatrix { +pub fn DistanceMatrix::new( + cells : Array[String], + distances : Array[Array[Double]], +) -> DistanceMatrix { let n = cells.length() - DistanceMatrix::{ - cells, - distances, - n_cells: n - } + DistanceMatrix::{ cells, distances, n_cells: n } } ///| -pub fn KernelMatrix::new(cells : Array[String], kernel : Array[Array[Double]], bandwidth : Double) -> KernelMatrix { - KernelMatrix::{ - cells, - kernel, - bandwidth - } +pub fn KernelMatrix::new( + cells : Array[String], + kernel : Array[Array[Double]], + bandwidth : Double, +) -> KernelMatrix { + KernelMatrix::{ cells, kernel, bandwidth } } ///| -pub fn compute_distance_matrix(cells : Array[CellData], metric : String) -> DistanceMatrix { +pub fn compute_distance_matrix( + cells : Array[CellData], + metric : String, +) -> DistanceMatrix { let n = cells.length() let cell_ids : Array[String] = Array::new() - + let mut i = 0 while i < n { cell_ids.push(cells[i].cell_id) i = i + 1 } - + // Compute pairwise distances let distances : Array[Array[Double]] = Array::new() i = 0 @@ -94,21 +92,29 @@ pub fn compute_distance_matrix(cells : Array[CellData], metric : String) -> Dist let row : Array[Double] = Array::new() let mut j = 0 while j < n { - let dist = destiny_compute_distance(cells[i].expression, cells[j].expression, metric) + let dist = destiny_compute_distance( + cells[i].expression, + cells[j].expression, + metric, + ) row.push(dist) j = j + 1 } distances.push(row) i = i + 1 } - + DistanceMatrix::new(cell_ids, distances) } ///| -fn destiny_compute_distance(a : Array[Double], b : Array[Double], metric : String) -> Double { +fn destiny_compute_distance( + a : Array[Double], + b : Array[Double], + metric : String, +) -> Double { let n = a.length() - + match metric { "euclidean" => { let mut sum = 0.0 @@ -145,10 +151,13 @@ fn destiny_compute_distance(a : Array[Double], b : Array[Double], metric : Strin } ///| -pub fn compute_gaussian_kernel(dist_matrix : DistanceMatrix, sigma : Double) -> KernelMatrix { +pub fn compute_gaussian_kernel( + dist_matrix : DistanceMatrix, + sigma : Double, +) -> KernelMatrix { let n = dist_matrix.n_cells let cells = dist_matrix.cells - + let kernel : Array[Array[Double]] = Array::new() let mut i = 0 while i < n { @@ -163,7 +172,7 @@ pub fn compute_gaussian_kernel(dist_matrix : DistanceMatrix, sigma : Double) -> kernel.push(row) i = i + 1 } - + KernelMatrix::new(cells, kernel, sigma) } @@ -173,7 +182,7 @@ pub fn find_sigma_automatic(dist_matrix : DistanceMatrix) -> Double { if n < 2 { return 1.0 } - + // Calculate pairwise distances and use median let distances : Array[Double] = Array::new() let mut i = 0 @@ -185,52 +194,64 @@ pub fn find_sigma_automatic(dist_matrix : DistanceMatrix) -> Double { } i = i + 1 } - + // Sort and get median let sorted = destiny_sort_array(distances) let len = sorted.length() if len == 0 { return 1.0 } - + let median_idx = len / 2 let median = if len % 2 == 0 { (sorted[median_idx - 1] + sorted[median_idx]) / 2.0 } else { sorted[median_idx] } - + // Use median as sigma - if median < 0.001 { 1.0 } else { median } + if median < 0.001 { + 1.0 + } else { + median + } } ///| -pub fn compute_diffusion_map(cells : Array[CellData], n_components : Int, sigma : Double) -> DiffusionResult { +pub fn compute_diffusion_map( + cells : Array[CellData], + n_components : Int, + sigma : Double, +) -> DiffusionResult { let n = cells.length() let cell_ids : Array[String] = Array::new() - + let mut i = 0 while i < n { cell_ids.push(cells[i].cell_id) i = i + 1 } - + // Step 1: Compute distance matrix let dist_matrix = compute_distance_matrix(cells, "euclidean") - + // Step 2: Compute kernel let kernel = compute_gaussian_kernel(dist_matrix, sigma) - + // Step 3: Normalize kernel (markov matrix) let markov = destiny_normalize_kernel(kernel) - + // Step 4: Compute eigendecomposition let n_comp = if n_components > n - 1 { n - 1 } else { n_components } let eigen_result = destiny_eigen_decomposition(markov.kernel, n_comp) - + // Step 5: Compute diffusion components - let embedding = destiny_compute_embedding(eigen_result.eigen_vectors, eigen_result.eigen_values, n_comp) - + let embedding = destiny_compute_embedding( + eigen_result.eigen_vectors, + eigen_result.eigen_values, + n_comp, + ) + // Calculate explained variance let total_var = destiny_sum_array(eigen_result.eigen_values) let explained_variance : Array[Double] = Array::new() @@ -244,12 +265,12 @@ pub fn compute_diffusion_map(cells : Array[CellData], n_components : Int, sigma explained_variance.push(var) j = j + 1 } - + DiffusionResult::{ embedding, eigenvalues: eigen_result.eigen_values, cell_ids, - explained_variance + explained_variance, } } @@ -257,27 +278,23 @@ pub fn compute_diffusion_map(cells : Array[CellData], n_components : Int, sigma fn destiny_normalize_kernel(kernel : KernelMatrix) -> KernelMatrix { let n = kernel.cells.length() let normalized : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let row = kernel.kernel[i] let row_sum = destiny_sum_array(row) - + let normalized_row : Array[Double] = Array::new() let mut j = 0 while j < n { - let val = if row_sum > 0.0 { - row[j] / row_sum - } else { - 0.0 - } + let val = if row_sum > 0.0 { row[j] / row_sum } else { 0.0 } normalized_row.push(val) j = j + 1 } normalized.push(normalized_row) i = i + 1 } - + KernelMatrix::new(kernel.cells, normalized, kernel.bandwidth) } @@ -288,26 +305,31 @@ struct EigenResult { } ///| -fn destiny_eigen_decomposition(matrix : Array[Array[Double]], n_components : Int) -> EigenResult { +fn destiny_eigen_decomposition( + matrix : Array[Array[Double]], + n_components : Int, +) -> EigenResult { let n = matrix.length() - + // Use power iteration for eigenvalue computation let eigen_values : Array[Double] = Array::new() let eigen_vectors : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_components { // Initialize random vector let mut vector : Array[Double] = Array::new() let mut j = 0 while j < n { - vector.push(destiny_random_vector_component(j.to_double() + i.to_double() * 100.0)) + vector.push( + destiny_random_vector_component(j.to_double() + i.to_double() * 100.0), + ) j = j + 1 } - + // Normalize vector = destiny_normalize_vector(vector) - + let mut lambda = 0.0 let mut iteration = 0 while iteration < 50 { @@ -324,15 +346,15 @@ fn destiny_eigen_decomposition(matrix : Array[Array[Double]], n_components : Int new_vector.push(sum) k = k + 1 } - + lambda = destiny_vector_norm(new_vector) vector = destiny_normalize_vector(new_vector) - + iteration = iteration + 1 } - + eigen_values.push(lambda) - + // Store eigenvector let ev : Array[Double] = Array::new() let mut m = 0 @@ -341,7 +363,7 @@ fn destiny_eigen_decomposition(matrix : Array[Array[Double]], n_components : Int m = m + 1 } eigen_vectors.push(ev) - + // Deflate matrix let deflated : Array[Array[Double]] = Array::new() let mut p = 0 @@ -356,29 +378,34 @@ fn destiny_eigen_decomposition(matrix : Array[Array[Double]], n_components : Int deflated.push(row) p = p + 1 } - + // Update matrix for next iteration // Note: This modifies the original - in production would need copy // For simplicity, we re-assign - let _ = deflated // Just for reference - + let _ = deflated // Just for reference + i = i + 1 } - - EigenResult::{ - eigen_values, - eigen_vectors - } + + EigenResult::{ eigen_values, eigen_vectors } } ///| -fn destiny_compute_embedding(eigen_vectors : Array[Array[Double]], eigen_values : Array[Double], n_components : Int) -> Array[Array[Double]] { +fn destiny_compute_embedding( + eigen_vectors : Array[Array[Double]], + eigen_values : Array[Double], + n_components : Int, +) -> Array[Array[Double]] { // eigen_vectors has shape [n_components][n_cells] let n_components_actual = eigen_vectors.length() - let n_cells = if n_components_actual > 0 { eigen_vectors[0].length() } else { 0 } - + let n_cells = if n_components_actual > 0 { + eigen_vectors[0].length() + } else { + 0 + } + let embedding : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_cells { let cell_embedding : Array[Double] = Array::new() @@ -395,25 +422,32 @@ fn destiny_compute_embedding(eigen_vectors : Array[Array[Double]], eigen_values embedding.push(cell_embedding) i = i + 1 } - + embedding } ///| -pub fn destiny_create_embedding(cells : Array[CellData], n_components : Int) -> DiffusionResult { +pub fn destiny_create_embedding( + cells : Array[CellData], + n_components : Int, +) -> DiffusionResult { // Find optimal sigma let dist_matrix = compute_distance_matrix(cells, "euclidean") let sigma = find_sigma_automatic(dist_matrix) - + // Compute diffusion map compute_diffusion_map(cells, n_components, sigma) } ///| -pub fn destiny_plot_coordinates(result : DiffusionResult, component_x : Int, component_y : Int) -> Array[(String, Double, Double)] { +pub fn destiny_plot_coordinates( + result : DiffusionResult, + component_x : Int, + component_y : Int, +) -> Array[(String, Double, Double)] { let coordinates : Array[(String, Double, Double)] = Array::new() let n = result.cell_ids.length() - + let mut i = 0 while i < n { let x = result.embedding[i][component_x] @@ -421,7 +455,7 @@ pub fn destiny_plot_coordinates(result : DiffusionResult, component_x : Int, com coordinates.push((result.cell_ids[i], x, y)) i = i + 1 } - + coordinates } @@ -429,24 +463,35 @@ pub fn destiny_plot_coordinates(result : DiffusionResult, component_x : Int, com pub fn destiny_summary(result : DiffusionResult) -> String { let mut summary = "\nDiffusion Map Summary\n" summary = summary + "==============================\n" - summary = summary + "Number of cells: " + result.cell_ids.length().to_string() + "\n" - summary = summary + "Number of components: " + result.eigenvalues.length().to_string() + "\n" - + summary = summary + + "Number of cells: " + + result.cell_ids.length().to_string() + + "\n" + summary = summary + + "Number of components: " + + result.eigenvalues.length().to_string() + + "\n" + let mut i = 0 while i < result.eigenvalues.length() { - summary = summary + "Component " + (i + 1).to_string() + - ": eigenvalue = " + result.eigenvalues[i].to_string() + - ", explained variance = " + (result.explained_variance[i] * 100.0).to_string() + "%\n" + summary = summary + + "Component " + + (i + 1).to_string() + + ": eigenvalue = " + + result.eigenvalues[i].to_string() + + ", explained variance = " + + (result.explained_variance[i] * 100.0).to_string() + + "%\n" i = i + 1 } - + summary } ///| pub fn create_example_sc_data(n_cells : Int, n_genes : Int) -> Array[CellData] { let cells : Array[CellData] = Array::new() - + let mut i = 0 while i < n_cells { let expression : Array[Double] = Array::new() @@ -459,22 +504,27 @@ pub fn create_example_sc_data(n_cells : Int, n_genes : Int) -> Array[CellData] { expression.push(base + noise) j = j + 1 } - + let cell = CellData::new( "cell_" + i.to_string(), expression, - if i < n_cells / 2 { "cluster_1" } else { "cluster_2" } + if i < n_cells / 2 { + "cluster_1" + } else { + "cluster_2" + }, ) - + cells.push(cell) i = i + 1 } - + cells } // Helper functions +///| fn destiny_sort_array(arr : Array[Double]) -> Array[Double] { let sorted = arr // Simple bubble sort for small arrays @@ -495,6 +545,7 @@ fn destiny_sort_array(arr : Array[Double]) -> Array[Double] { sorted } +///| fn destiny_sum_array(arr : Array[Double]) -> Double { let mut sum = 0.0 let mut i = 0 @@ -505,6 +556,7 @@ fn destiny_sum_array(arr : Array[Double]) -> Double { sum } +///| fn destiny_normalize_vector(v : Array[Double]) -> Array[Double] { let norm = destiny_vector_norm(v) if norm == 0.0 { @@ -516,7 +568,7 @@ fn destiny_normalize_vector(v : Array[Double]) -> Array[Double] { } return result } - + let normalized : Array[Double] = Array::new() let mut i = 0 while i < v.length() { @@ -526,6 +578,7 @@ fn destiny_normalize_vector(v : Array[Double]) -> Array[Double] { normalized } +///| fn destiny_vector_norm(v : Array[Double]) -> Double { let mut sum = 0.0 let mut i = 0 @@ -536,9 +589,16 @@ fn destiny_vector_norm(v : Array[Double]) -> Double { sum.sqrt() } +///| fn destiny_random_vector_component(seed : Double) -> Double { // Simple deterministic pseudo-random generator let raw = seed * 99991.0 let x = (raw - raw.floor()) * 2.0 - 1.0 - if x < -1.0 { -1.0 } else if x > 1.0 { 1.0 } else { x } + if x < -1.0 { + -1.0 + } else if x > 1.0 { + 1.0 + } else { + x + } } diff --git a/src/dexseq.mbt b/src/dexseq.mbt index d1137602..7cad1226 100644 --- a/src/dexseq.mbt +++ b/src/dexseq.mbt @@ -9,7 +9,11 @@ pub struct ExonCount { } ///| -pub fn ExonCount::new(gene_id : String, exon_id : String, counts : Array[Int]) -> ExonCount { +pub fn ExonCount::new( + gene_id : String, + exon_id : String, + counts : Array[Int], +) -> ExonCount { ExonCount::{ gene_id, exon_id, counts } } @@ -21,17 +25,20 @@ pub struct DEXSeqDataSet { } ///| -pub fn DEXSeqDataSet::new(exon_counts : Array[ExonCount], sample_groups : Array[String]) -> DEXSeqDataSet { +pub fn DEXSeqDataSet::new( + exon_counts : Array[ExonCount], + sample_groups : Array[String], +) -> DEXSeqDataSet { let gene_ids : Array[String] = Array::new() let seen : Map[String, Bool] = Map([], capacity=100) - + for ec in exon_counts { if !seen.contains(ec.gene_id) { seen.set(ec.gene_id, true) gene_ids.push(ec.gene_id) } } - + DEXSeqDataSet::{ exon_counts, sample_groups, gene_ids } } @@ -48,14 +55,32 @@ pub struct DEXSeqResult { } ///| -pub fn DEXSeqResult::new(gene_id : String, exon_id : String, base_mean : Double, log2_fold_change : Double, lfc_se : Double, stat : Double, p_value : Double, adjusted_p_value : Double) -> DEXSeqResult { - DEXSeqResult::{ gene_id, exon_id, base_mean, log2_fold_change, lfc_se, stat, p_value, adjusted_p_value } +pub fn DEXSeqResult::new( + gene_id : String, + exon_id : String, + base_mean : Double, + log2_fold_change : Double, + lfc_se : Double, + stat : Double, + p_value : Double, + adjusted_p_value : Double, +) -> DEXSeqResult { + DEXSeqResult::{ + gene_id, + exon_id, + base_mean, + log2_fold_change, + lfc_se, + stat, + p_value, + adjusted_p_value, + } } ///| pub fn dexseq_normalize_counts(dataset : DEXSeqDataSet) -> DEXSeqDataSet { let normalized : Array[ExonCount] = Array::new() - + for ec in dataset.exon_counts { let mut total = 0 let mut i = 0 @@ -66,24 +91,30 @@ pub fn dexseq_normalize_counts(dataset : DEXSeqDataSet) -> DEXSeqDataSet { if total > 0 { let norm_counts : Array[Int] = Array::new() for count in ec.counts { - norm_counts.push((count * 1000000 / total)) + norm_counts.push(count * 1000000 / total) } normalized.push(ExonCount::new(ec.gene_id, ec.exon_id, norm_counts)) } else { normalized.push(ec) } } - - DEXSeqDataSet::{ exon_counts: normalized, sample_groups: dataset.sample_groups, gene_ids: dataset.gene_ids } + + DEXSeqDataSet::{ + exon_counts: normalized, + sample_groups: dataset.sample_groups, + gene_ids: dataset.gene_ids, + } } ///| -pub fn dexseq_test_for_exon_usage(dataset : DEXSeqDataSet) -> Array[DEXSeqResult] { +pub fn dexseq_test_for_exon_usage( + dataset : DEXSeqDataSet, +) -> Array[DEXSeqResult] { let results : Array[DEXSeqResult] = Array::new() - + let group0_indices : Array[Int] = Array::new() let group1_indices : Array[Int] = Array::new() - + let mut i = 0 while i < dataset.sample_groups.length() { if dataset.sample_groups[i] == "control" { @@ -93,39 +124,47 @@ pub fn dexseq_test_for_exon_usage(dataset : DEXSeqDataSet) -> Array[DEXSeqResult } i = i + 1 } - + for ec in dataset.exon_counts { let mut group0_sum = 0 for idx in group0_indices { group0_sum = group0_sum + ec.counts[idx] } - + let mut group1_sum = 0 for idx in group1_indices { group1_sum = group1_sum + ec.counts[idx] } - + let n0 = group0_indices.length() let n1 = group1_indices.length() - - let mean0 = if n0 > 0 { group0_sum.to_double() / n0.to_double() } else { 0.0 } - let mean1 = if n1 > 0 { group1_sum.to_double() / n1.to_double() } else { 0.0 } - + + let mean0 = if n0 > 0 { + group0_sum.to_double() / n0.to_double() + } else { + 0.0 + } + let mean1 = if n1 > 0 { + group1_sum.to_double() / n1.to_double() + } else { + 0.0 + } + let base_mean = (mean0 + mean1) / 2.0 - + let log2_fc = if mean0 > 0.0 && mean1 > 0.0 { - @math.log2(mean1 / mean0) - } else { - 0.0 - } - + @math.log2(mean1 / mean0) + } else { + 0.0 + } + let lfc_se = 0.1 let stat = log2_fc / lfc_se - + let p_value = 1.0 / (1.0 + stat * stat) - + let adjusted_p = p_value * 0.1 - + let result = DEXSeqResult::new( ec.gene_id, ec.exon_id, @@ -134,38 +173,45 @@ pub fn dexseq_test_for_exon_usage(dataset : DEXSeqDataSet) -> Array[DEXSeqResult lfc_se, stat, p_value, - adjusted_p + adjusted_p, ) results.push(result) } - + results } ///| -pub fn dexseq_filter_results(results : Array[DEXSeqResult], min_log2fc : Double, max_padj : Double) -> Array[DEXSeqResult] { +pub fn dexseq_filter_results( + results : Array[DEXSeqResult], + min_log2fc : Double, + max_padj : Double, +) -> Array[DEXSeqResult] { let filtered : Array[DEXSeqResult] = Array::new() - + for result in results { - if result.log2_fold_change.abs() >= min_log2fc && result.adjusted_p_value <= max_padj { + if result.log2_fold_change.abs() >= min_log2fc && + result.adjusted_p_value <= max_padj { filtered.push(result) } } - + filtered } ///| pub fn create_example_dexseq_dataset() -> DEXSeqDataSet { let exon_counts : Array[ExonCount] = Array::new() - + exon_counts.push(ExonCount::new("gene1", "exon1", [10, 12, 15, 8, 25, 30])) exon_counts.push(ExonCount::new("gene1", "exon2", [5, 6, 7, 4, 10, 12])) exon_counts.push(ExonCount::new("gene1", "exon3", [20, 22, 25, 18, 15, 12])) exon_counts.push(ExonCount::new("gene2", "exon1", [8, 10, 12, 6, 8, 10])) exon_counts.push(ExonCount::new("gene2", "exon2", [15, 18, 20, 12, 25, 30])) - - let sample_groups = ["control", "control", "control", "treatment", "treatment", "treatment"] - + + let sample_groups = [ + "control", "control", "control", "treatment", "treatment", "treatment", + ] + DEXSeqDataSet::new(exon_counts, sample_groups) -} \ No newline at end of file +} diff --git a/src/diffbind.mbt b/src/diffbind.mbt index fd0e3c02..ed1f9ac1 100644 --- a/src/diffbind.mbt +++ b/src/diffbind.mbt @@ -1411,7 +1411,10 @@ fn diffbind_transpose(matrix : Array[Array[Double]]) -> Array[Array[Double]] { } let n_rows = matrix.length() let n_cols = matrix[0].length() - let transposed : Array[Array[Double]] = Array::make(n_cols, Array::make(n_rows, 0.0)) + let transposed : Array[Array[Double]] = Array::make( + n_cols, + Array::make(n_rows, 0.0), + ) let mut i = 0 while i < n_rows { let mut j = 0 @@ -1441,7 +1444,10 @@ fn diffbind_mean(arr : Array[Double]) -> Double { ///| /// Extract column from matrix. -fn diffbind_extract_column(matrix : Array[Array[Double]], col_idx : Int) -> Array[Double] { +fn diffbind_extract_column( + matrix : Array[Array[Double]], + col_idx : Int, +) -> Array[Double] { let n_rows = matrix.length() let col : Array[Double] = Array::make(n_rows, 0.0) let mut i = 0 @@ -1502,15 +1508,20 @@ fn diffbind_correlation(x : Array[Double], y : Array[Double]) -> Double { ///| /// Compute PCA on a matrix (samples x peaks). /// Returns principal components (samples x components) and explained variance ratios. -fn diffbind_pca(matrix : Array[Array[Double]]) -> (Array[Array[Double]], Array[Double]) { +fn diffbind_pca( + matrix : Array[Array[Double]], +) -> (Array[Array[Double]], Array[Double]) { if matrix.length() == 0 || matrix[0].length() == 0 { return (Array::new(), Array::new()) } let n_samples = matrix.length() let n_peaks = matrix[0].length() let k = if n_samples < n_peaks { n_samples - 1 } else { 3 } - - let centered : Array[Array[Double]] = Array::make(n_samples, Array::make(n_peaks, 0.0)) + + let centered : Array[Array[Double]] = Array::make( + n_samples, + Array::make(n_peaks, 0.0), + ) let mut p = 0 while p < n_peaks { let peak_values : Array[Double] = Array::make(n_samples, 0.0) @@ -1527,8 +1538,11 @@ fn diffbind_pca(matrix : Array[Array[Double]]) -> (Array[Array[Double]], Array[D } p = p + 1 } - - let cov_matrix : Array[Array[Double]] = Array::make(n_peaks, Array::make(n_peaks, 0.0)) + + let cov_matrix : Array[Array[Double]] = Array::make( + n_peaks, + Array::make(n_peaks, 0.0), + ) let mut i = 0 while i < n_peaks { let mut j = i @@ -1542,15 +1556,15 @@ fn diffbind_pca(matrix : Array[Array[Double]]) -> (Array[Array[Double]], Array[D } i = i + 1 } - + let eigvals : Array[Double] = Array::make(k, 0.0) let eigvecs : Array[Array[Double]] = Array::make(k, Array::make(n_peaks, 0.0)) - + let mut comp = 0 while comp < k { let init_val = 1.0 / diffbind_sqrt(n_peaks.to_double()) let mut vec : Array[Double] = Array::make(n_peaks, init_val) - + let mut val = 0.0 let mut iter = 0 while iter < 100 { @@ -1566,16 +1580,16 @@ fn diffbind_pca(matrix : Array[Array[Double]]) -> (Array[Array[Double]], Array[D new_vec[p2] = sum p2 = p2 + 1 } - + let mut sum_sq = 0.0 let mut idx = 0 while idx < new_vec.length() { sum_sq = sum_sq + new_vec[idx] * new_vec[idx] idx = idx + 1 } - + let norm = diffbind_sqrt(sum_sq) - + let new_vec_norm : Array[Double] = Array::make(n_peaks, 0.0) if norm > 0.0 { let mut n_idx = 0 @@ -1584,12 +1598,12 @@ fn diffbind_pca(matrix : Array[Array[Double]]) -> (Array[Array[Double]], Array[D n_idx = n_idx + 1 } } - + vec = new_vec_norm val = sum_sq iter = iter + 1 } - + eigvals[comp] = val let mut v_idx = 0 while v_idx < n_peaks { @@ -1598,7 +1612,7 @@ fn diffbind_pca(matrix : Array[Array[Double]]) -> (Array[Array[Double]], Array[D } comp = comp + 1 } - + let mut total_var = 0.0 let mut r_idx = 0 while r_idx < cov_matrix.length() { @@ -1609,15 +1623,22 @@ fn diffbind_pca(matrix : Array[Array[Double]]) -> (Array[Array[Double]], Array[D } r_idx = r_idx + 1 } - + let explained_var : Array[Double] = Array::make(k, 0.0) let mut ev_idx = 0 while ev_idx < k { - explained_var[ev_idx] = if total_var > 0.0 { eigvals[ev_idx] / total_var } else { 0.0 } + explained_var[ev_idx] = if total_var > 0.0 { + eigvals[ev_idx] / total_var + } else { + 0.0 + } ev_idx = ev_idx + 1 } - - let pc_scores : Array[Array[Double]] = Array::make(n_samples, Array::make(k, 0.0)) + + let pc_scores : Array[Array[Double]] = Array::make( + n_samples, + Array::make(k, 0.0), + ) let mut s2 = 0 while s2 < n_samples { let mut comp2 = 0 @@ -1633,7 +1654,7 @@ fn diffbind_pca(matrix : Array[Array[Double]]) -> (Array[Array[Double]], Array[D } s2 = s2 + 1 } - + (pc_scores, explained_var) } @@ -1646,54 +1667,77 @@ pub fn diffbind_plot_pca(config : DBAConfig, method : String) -> String { } let counts = diffbind_normalize(config, method) let matrix = diffbind_transpose(counts) - + let (pc_scores, explained_var) = diffbind_pca(matrix) if pc_scores.length() == 0 || explained_var.length() < 2 { return "PCA Plot: Insufficient data for PCA\n" } - + let mut plot = "PCA Plot\n" plot = plot + "========\n\n" - plot = plot + "PC1: " + (explained_var[0] * 100.0).to_string() + "% variance\n" - plot = plot + "PC2: " + (explained_var[1] * 100.0).to_string() + "% variance\n\n" - + plot = plot + + "PC1: " + + (explained_var[0] * 100.0).to_string() + + "% variance\n" + plot = plot + + "PC2: " + + (explained_var[1] * 100.0).to_string() + + "% variance\n\n" + let mut min_x = pc_scores[0][0] let mut max_x = pc_scores[0][0] let mut min_y = pc_scores[0][1] let mut max_y = pc_scores[0][1] let mut i = 1 while i < pc_scores.length() { - if pc_scores[i][0] < min_x { min_x = pc_scores[i][0] } - if pc_scores[i][0] > max_x { max_x = pc_scores[i][0] } - if pc_scores[i][1] < min_y { min_y = pc_scores[i][1] } - if pc_scores[i][1] > max_y { max_y = pc_scores[i][1] } + if pc_scores[i][0] < min_x { + min_x = pc_scores[i][0] + } + if pc_scores[i][0] > max_x { + max_x = pc_scores[i][0] + } + if pc_scores[i][1] < min_y { + min_y = pc_scores[i][1] + } + if pc_scores[i][1] > max_y { + max_y = pc_scores[i][1] + } i = i + 1 } - + let padding = 0.1 min_x = min_x - (max_x - min_x) * padding max_x = max_x + (max_x - min_x) * padding min_y = min_y - (max_y - min_y) * padding max_y = max_y + (max_y - min_y) * padding - + let width = 40 let height = 20 - - let canvas : Array[Array[String]] = Array::make(height, Array::make(width, " ")) - + + let canvas : Array[Array[String]] = Array::make( + height, + Array::make(width, " "), + ) + let mut s = 0 while s < pc_scores.length() { let x = pc_scores[s][0] let y = pc_scores[s][1] let px = ((x - min_x) / (max_x - min_x) * (width - 1).to_double()).to_int() - let py = height - 1 - ((y - min_y) / (max_y - min_y) * (height - 1).to_double()).to_int() + let py = height - + 1 - + ((y - min_y) / (max_y - min_y) * (height - 1).to_double()).to_int() if px >= 0 && px < width && py >= 0 && py < height { let sample = config.samples[s] - canvas[py][px] = if sample.condition == config.conditions[0] { "A" } else { "B" } + canvas[py][px] = if sample.condition == config.conditions[0] { + "A" + } else { + "B" + } } s = s + 1 } - + plot = plot + "Y\n" let mut row = height - 1 while row >= 0 { @@ -1708,7 +1752,7 @@ pub fn diffbind_plot_pca(config : DBAConfig, method : String) -> String { } plot = plot + "+" + "-".repeat(width) + "+\n" plot = plot + "X\n\n" - + let colors : Map[String, String] = Map([], capacity=2) let mut cond_idx = 0 while cond_idx < config.conditions.length() { @@ -1722,7 +1766,7 @@ pub fn diffbind_plot_pca(config : DBAConfig, method : String) -> String { } cond_idx = cond_idx + 1 } - + plot = plot + "Legend:\n" let keys = colors.keys().collect() let mut k = 0 @@ -1730,7 +1774,7 @@ pub fn diffbind_plot_pca(config : DBAConfig, method : String) -> String { plot = plot + " " + colors[keys[k]] + " = " + keys[k] + "\n" k = k + 1 } - + plot } @@ -1740,26 +1784,34 @@ pub fn diffbind_plot_heatmap(result : DBAResult, top_n : Int) -> String { if result.peaks.length() == 0 { return "Heatmap: No peaks in result\n" } - - let n = if top_n < result.peaks.length() { top_n } else { result.peaks.length() } - + + let n = if top_n < result.peaks.length() { + top_n + } else { + result.peaks.length() + } + let mut heatmap = "Differential Binding Heatmap\n" heatmap = heatmap + "============================\n\n" heatmap = heatmap + "Top " + n.to_string() + " peaks\n\n" - + let width = if n > 30 { 30 } else { n } let height = 10 - + let mut min_fc = result.fold_changes[0] let mut max_fc = result.fold_changes[0] let mut i = 1 while i < result.fold_changes.length() { let fc = result.fold_changes[i] - if fc < min_fc { min_fc = fc } - if fc > max_fc { max_fc = fc } + if fc < min_fc { + min_fc = fc + } + if fc > max_fc { + max_fc = fc + } i = i + 1 } - + let mut row = 0 while row < height { heatmap = heatmap + "|" @@ -1768,17 +1820,35 @@ pub fn diffbind_plot_heatmap(result : DBAResult, top_n : Int) -> String { let idx = col % result.fold_changes.length() let fc = result.fold_changes[idx] let norm = (fc - min_fc) / (max_fc - min_fc + 0.0001) - let char = if norm < 0.2 { " " } else if norm < 0.4 { "." } else if norm < 0.6 { "+" } else if norm < 0.8 { "*" } else { "#" } + let char = if norm < 0.2 { + " " + } else if norm < 0.4 { + "." + } else if norm < 0.6 { + "+" + } else if norm < 0.8 { + "*" + } else { + "#" + } heatmap = heatmap + char col = col + 1 } heatmap = heatmap + "|\n" row = row + 1 } - + heatmap = heatmap + "\nColor scale (log2 fold change):\n" - heatmap = heatmap + " " + min_fc.to_string() + " <-" + " ".repeat(8) + ". + * #" + "-> " + max_fc.to_string() + "\n" - + heatmap = heatmap + + " " + + min_fc.to_string() + + " <-" + + " ".repeat(8) + + ". + * #" + + "-> " + + max_fc.to_string() + + "\n" + heatmap } @@ -1789,33 +1859,44 @@ pub fn diffbind_plot_volcano(result : DBAResult) -> String { if data.length() == 0 { return "Volcano Plot: No data\n" } - + let mut min_fc = data[0].0 let mut max_fc = data[0].0 let mut max_neg_log_p = data[0].1 let mut i = 1 while i < data.length() { - if data[i].0 < min_fc { min_fc = data[i].0 } - if data[i].0 > max_fc { max_fc = data[i].0 } - if data[i].1 > max_neg_log_p { max_neg_log_p = data[i].1 } + if data[i].0 < min_fc { + min_fc = data[i].0 + } + if data[i].0 > max_fc { + max_fc = data[i].0 + } + if data[i].1 > max_neg_log_p { + max_neg_log_p = data[i].1 + } i = i + 1 } - + let padding = 0.1 min_fc = min_fc - (max_fc - min_fc) * padding max_fc = max_fc + (max_fc - min_fc) * padding max_neg_log_p = max_neg_log_p + max_neg_log_p * padding - + let width = 50 let height = 20 - - let canvas : Array[Array[String]] = Array::make(height, Array::make(width, " ")) - + + let canvas : Array[Array[String]] = Array::make( + height, + Array::make(width, " "), + ) + let mut j = 0 while j < data.length() { let (fc, neg_log_p) = data[j] let px = ((fc - min_fc) / (max_fc - min_fc) * (width - 1).to_double()).to_int() - let py = height - 1 - (neg_log_p / max_neg_log_p * (height - 1).to_double()).to_int() + let py = height - + 1 - + (neg_log_p / max_neg_log_p * (height - 1).to_double()).to_int() if px >= 0 && px < width && py >= 0 && py < height { let idx = j let fdr = result.fdrs[idx] @@ -1823,7 +1904,7 @@ pub fn diffbind_plot_volcano(result : DBAResult) -> String { } j = j + 1 } - + let mid_x = ((0.0 - min_fc) / (max_fc - min_fc) * (width - 1).to_double()).to_int() let mut row = height - 1 while row >= 0 { @@ -1834,12 +1915,12 @@ pub fn diffbind_plot_volcano(result : DBAResult) -> String { } row = row - 1 } - + let mut plot = "Volcano Plot\n" plot = plot + "============\n\n" plot = plot + "Y: -log10(p-value)\n" plot = plot + "X: log2(fold change)\n\n" - + row = height - 1 while row >= 0 { plot = plot + "|" @@ -1851,13 +1932,18 @@ pub fn diffbind_plot_volcano(result : DBAResult) -> String { plot = plot + "|\n" row = row - 1 } - plot = plot + "+" + "-".repeat(mid_x) + "+" + "-".repeat(width - mid_x - 1) + "+\n" + plot = plot + + "+" + + "-".repeat(mid_x) + + "+" + + "-".repeat(width - mid_x - 1) + + "+\n" plot = plot + "X\n\n" - + plot = plot + "Legend:\n" plot = plot + " * = Significant (FDR < 0.05)\n" plot = plot + " . = Not significant\n\n" - + let mut sig_count = 0 let mut up_count = 0 let mut down_count = 0 @@ -1873,13 +1959,13 @@ pub fn diffbind_plot_volcano(result : DBAResult) -> String { } k = k + 1 } - + plot = plot + "Summary:\n" plot = plot + " Total peaks: " + result.peaks.length().to_string() + "\n" plot = plot + " Significant (FDR < 0.05): " + sig_count.to_string() + "\n" plot = plot + " Up-regulated: " + up_count.to_string() + "\n" plot = plot + " Down-regulated: " + down_count.to_string() + "\n" - + plot } @@ -1890,36 +1976,51 @@ pub fn diffbind_plot_ma(result : DBAResult) -> String { if data.length() == 0 { return "MA Plot: No data\n" } - + let mut min_mean = data[0].0 let mut max_mean = data[0].0 let mut min_fc = data[0].1 let mut max_fc = data[0].1 let mut i = 1 while i < data.length() { - if data[i].0 < min_mean { min_mean = data[i].0 } - if data[i].0 > max_mean { max_mean = data[i].0 } - if data[i].1 < min_fc { min_fc = data[i].1 } - if data[i].1 > max_fc { max_fc = data[i].1 } + if data[i].0 < min_mean { + min_mean = data[i].0 + } + if data[i].0 > max_mean { + max_mean = data[i].0 + } + if data[i].1 < min_fc { + min_fc = data[i].1 + } + if data[i].1 > max_fc { + max_fc = data[i].1 + } i = i + 1 } - + let padding = 0.1 min_mean = min_mean - (max_mean - min_mean) * padding max_mean = max_mean + (max_mean - min_mean) * padding min_fc = min_fc - (max_fc - min_fc) * padding max_fc = max_fc + (max_fc - min_fc) * padding - + let width = 50 let height = 20 - - let canvas : Array[Array[String]] = Array::make(height, Array::make(width, " ")) - + + let canvas : Array[Array[String]] = Array::make( + height, + Array::make(width, " "), + ) + let mut j = 0 while j < data.length() { let (mean_log2, fc) = data[j] - let px = ((mean_log2 - min_mean) / (max_mean - min_mean) * (width - 1).to_double()).to_int() - let py = height - 1 - ((fc - min_fc) / (max_fc - min_fc) * (height - 1).to_double()).to_int() + let px = ((mean_log2 - min_mean) / + (max_mean - min_mean) * + (width - 1).to_double()).to_int() + let py = height - + 1 - + ((fc - min_fc) / (max_fc - min_fc) * (height - 1).to_double()).to_int() if px >= 0 && px < width && py >= 0 && py < height { let idx = j let fdr = result.fdrs[idx] @@ -1927,7 +2028,7 @@ pub fn diffbind_plot_ma(result : DBAResult) -> String { } j = j + 1 } - + let mid_y = ((0.0 - min_fc) / (max_fc - min_fc) * (height - 1).to_double()).to_int() let mut row = height - 1 while row >= 0 { @@ -1940,12 +2041,12 @@ pub fn diffbind_plot_ma(result : DBAResult) -> String { } row = row - 1 } - + let mut plot = "MA Plot\n" plot = plot + "=======\n\n" plot = plot + "Y: log2(fold change)\n" plot = plot + "X: log2(mean expression)\n\n" - + row = height - 1 while row >= 0 { plot = plot + "|" @@ -1959,11 +2060,11 @@ pub fn diffbind_plot_ma(result : DBAResult) -> String { } plot = plot + "+" + "-".repeat(width) + "+\n" plot = plot + "X\n\n" - + plot = plot + "Legend:\n" plot = plot + " * = Significant (FDR < 0.05)\n" plot = plot + " . = Not significant\n" - + plot } diff --git a/src/diffcyt.mbt b/src/diffcyt.mbt index 6d36648d..3f3d6b3c 100644 --- a/src/diffcyt.mbt +++ b/src/diffcyt.mbt @@ -32,7 +32,7 @@ pub fn CytometryCell::new( cell_id : String, sample_id : String, condition : String, - marker_values : Array[Double] + marker_values : Array[Double], ) -> CytometryCell { CytometryCell::{ cell_id, @@ -289,7 +289,12 @@ fn dc_normal_cdf(x : Double) -> Double { } let t = 1.0 / (1.0 + 0.2316419 * dc_abs(x)) let d = 0.3989423 * @math.exp(-x * x / 2.0) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))) + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))) + ) if x >= 0.0 { 1.0 - p } else { @@ -336,7 +341,7 @@ fn dc_lcg_rand(state : Int) -> (Int, Double) { pub fn diffcyt_cluster_cells( cells : Array[CytometryCell], n_clusters : Int, - n_iterations : Int + n_iterations : Int, ) -> Array[Array[Double]] { let n_cells = cells.length() if n_cells == 0 || n_clusters <= 0 { @@ -375,7 +380,8 @@ pub fn diffcyt_cluster_cells( } // Update BMU toward the cell. for j in 0.. Unit { let n_clusters = codebooks.length() for ci in 0.. Array[Array[Int]] { let n_samples = sample_ids.length() // counts[sample_idx][cluster_idx] @@ -461,7 +467,7 @@ pub fn diffcyt_calc_medians_by_cluster_marker( cells : Array[CytometryCell], n_clusters : Int, n_markers : Int, - sample_ids : Array[String] + sample_ids : Array[String], ) -> Array[Array[Double]] { let n_samples = sample_ids.length() // Collect expression values per (sample, cluster, marker). @@ -541,7 +547,7 @@ fn dc_median(arr : Array[Double]) -> Double { /// indicator columns. Returns design[sample_idx][col_idx]. pub fn diffcyt_create_design_matrix( sample_ids : Array[String], - conditions : Array[String] + conditions : Array[String], ) -> Array[Array[Double]] { let n = sample_ids.length() // Collect unique conditions preserving order. @@ -609,7 +615,7 @@ pub fn diffcyt_testDA( counts : Array[Array[Int]], design : Array[Array[Double]], contrast_col : Int, - n_clusters : Int + n_clusters : Int, ) -> Array[DiffcytDAResult] { let n_samples = counts.length() let results : Array[DiffcytDAResult] = Array::new() @@ -736,7 +742,13 @@ pub fn diffcyt_testDA( // Wald test. let wald_stat = beta[contrast_col] / se let p_value = 2.0 * (1.0 - dc_normal_cdf(dc_abs(wald_stat))) - let p_value = if p_value < 0.0 { 0.0 } else if p_value > 1.0 { 1.0 } else { p_value } + let p_value = if p_value < 0.0 { + 0.0 + } else if p_value > 1.0 { + 1.0 + } else { + p_value + } results.push(DiffcytDAResult::{ cluster_id: cluster, log_fc: beta[contrast_col], @@ -770,12 +782,12 @@ pub fn diffcyt_testDS( conditions : Array[String], n_clusters : Int, n_markers : Int, - marker_names : Array[String] + marker_names : Array[String], ) -> Array[DiffcytDSResult] { let n_samples = sample_ids.length() // Collect per-sample-per-cluster-per-marker median expression. let medians = diffcyt_calc_medians_by_cluster_marker( - cells, n_clusters, n_markers, sample_ids + cells, n_clusters, n_markers, sample_ids, ) // Collect unique conditions. let unique_conditions : Array[String] = Array::new() @@ -820,15 +832,12 @@ pub fn diffcyt_testDS( let mut total_df = 0.0 for ci in 0.. 1 { - pooled_var = pooled_var + group_vars[ci] * (group_ns[ci] - 1).to_double() + pooled_var = pooled_var + + group_vars[ci] * (group_ns[ci] - 1).to_double() total_df = total_df + (group_ns[ci] - 1).to_double() } } - let pooled_var = if total_df > 0.0 { - pooled_var / total_df - } else { - 1.0 - } + let pooled_var = if total_df > 0.0 { pooled_var / total_df } else { 1.0 } if pooled_var > 0.0 { all_variances.push(pooled_var) all_df.push(total_df) @@ -841,7 +850,11 @@ pub fn diffcyt_testDS( } else { 1.0 } - let prior_mean_var = if prior_mean_var < 0.0000001 { 0.0000001 } else { prior_mean_var } + let prior_mean_var = if prior_mean_var < 0.0000001 { + 0.0000001 + } else { + prior_mean_var + } // Moderate variances: shrink toward prior. let prior_d0 = 10.0 // prior degrees of freedom for cluster in 0..= 2 && group_ns[0] > 0 && group_ns[1] > 0 { let mean_diff = group_means[1] - group_means[0] - let se = dc_sqrt(mod_var * (1.0 / group_ns[0].to_double() + 1.0 / group_ns[1].to_double())) + let se = dc_sqrt( + mod_var * + (1.0 / group_ns[0].to_double() + 1.0 / group_ns[1].to_double()), + ) let se = if se < 0.0000001 { 0.0000001 } else { se } let t_stat = mean_diff / se let df = prior_d0 + d0 // Convert t to p-value using normal approximation for large df. let p_value = 2.0 * (1.0 - dc_normal_cdf(dc_abs(t_stat))) - let p_value = if p_value < 0.0 { 0.0 } else if p_value > 1.0 { 1.0 } else { p_value } + let p_value = if p_value < 0.0 { + 0.0 + } else if p_value > 1.0 { + 1.0 + } else { + p_value + } let mname = if marker < marker_names.length() { marker_names[marker] } else { @@ -1008,7 +1030,7 @@ fn dc_bh_fdr_ds(results : Array[DiffcytDSResult]) -> Array[DiffcytDSResult] { pub fn diffcyt_mark_significant( da_results : Array[DiffcytDAResult], ds_results : Array[DiffcytDSResult], - fdr_threshold : Double + fdr_threshold : Double, ) -> (Array[DiffcytDAResult], Array[DiffcytDSResult]) { for r in da_results { r.significant = r.fdr < fdr_threshold @@ -1182,7 +1204,7 @@ fn dc_variance(arr : Array[Double]) -> Double { /// Extract top DA clusters sorted by p-value. pub fn diffcyt_top_clusters_da( da_results : Array[DiffcytDAResult], - n_top : Int + n_top : Int, ) -> Array[DiffcytDAResult] { // Copy and sort by p-value. let sorted : Array[DiffcytDAResult] = Array::new() @@ -1213,7 +1235,7 @@ pub fn diffcyt_top_clusters_da( /// Extract top DS cluster-marker pairs sorted by p-value. pub fn diffcyt_top_table_ds( ds_results : Array[DiffcytDSResult], - n_top : Int + n_top : Int, ) -> Array[DiffcytDSResult] { let sorted : Array[DiffcytDSResult] = Array::new() for r in ds_results { @@ -1253,11 +1275,14 @@ pub fn diffcyt_top_table_ds( pub fn diffcyt_run( cells : Array[CytometryCell], n_clusters : Int, - fdr_threshold : Double + fdr_threshold : Double, ) -> DiffcytSummary { let sample_ids = diffcyt_unique_samples(cells) let conditions_arr : Array[String] = Array::new() - let sample_condition_map : Map[String, String] = Map([], capacity=sample_ids.length()) + let sample_condition_map : Map[String, String] = Map( + [], + capacity=sample_ids.length(), + ) for cell in cells { sample_condition_map.set(cell.sample_id, cell.condition) } @@ -1282,11 +1307,11 @@ pub fn diffcyt_run( marker_names.push("marker_" + i.to_string()) } let ds_results = diffcyt_testDS( - cells, sample_ids, conditions_arr, n_clusters, n_markers, marker_names + cells, sample_ids, conditions_arr, n_clusters, n_markers, marker_names, ) // 7. Mark significant. let (da_results, ds_results) = diffcyt_mark_significant( - da_results, ds_results, fdr_threshold + da_results, ds_results, fdr_threshold, ) DiffcytSummary::{ n_cells: cells.length(), @@ -1333,7 +1358,7 @@ pub fn diffcyt_sample_data() -> Array[CytometryCell] { "cell_" + cell_counter.to_string(), samples[si], conditions[si], - marker_vals + marker_vals, ) cells.push(cell) cell_counter = cell_counter + 1 diff --git a/src/dnashape.mbt b/src/dnashape.mbt index fe314acc..2c2ddc46 100644 --- a/src/dnashape.mbt +++ b/src/dnashape.mbt @@ -374,10 +374,7 @@ pub fn dnashape_get_ep_table() -> Map[Int, Double] { ///| /// Look up a dinucleotide value from the appropriate table. -fn dnashape_lookup_dinuc( - dinuc_idx : Int, - feature : DnaShapeFeature, -) -> Double { +fn dnashape_lookup_dinuc(dinuc_idx : Int, feature : DnaShapeFeature) -> Double { match feature { ShapeMGW => { let t = dnashape_get_mgw_table() diff --git a/src/dorothea.mbt b/src/dorothea.mbt index 9df0c314..b0ef3261 100644 --- a/src/dorothea.mbt +++ b/src/dorothea.mbt @@ -47,21 +47,17 @@ pub struct DorotheaParams { ///| /// Create default dorothea parameters. pub fn DorotheaParams::new() -> DorotheaParams { - DorotheaParams::{ - n_permutations: 1000, - min_targets: 5, - significance: 0.05, - } + DorotheaParams::{ n_permutations: 1000, min_targets: 5, significance: 0.05 } } ///| /// Create custom dorothea parameters. -pub fn DorotheaParams::with_params(n_perms : Int, min_targets : Int, alpha : Double) -> DorotheaParams { - DorotheaParams::{ - n_permutations: n_perms, - min_targets, - significance: alpha, - } +pub fn DorotheaParams::with_params( + n_perms : Int, + min_targets : Int, + alpha : Double, +) -> DorotheaParams { + DorotheaParams::{ n_permutations: n_perms, min_targets, significance: alpha } } ///| @@ -322,8 +318,16 @@ pub fn dorothea_compute_viper_activity( } } - let activation_mean = if n_activation > 0 { activation_sum / n_activation.to_double() } else { 0.0 } - let repression_mean = if n_repression > 0 { repression_sum / n_repression.to_double() } else { 0.0 } + let activation_mean = if n_activation > 0 { + activation_sum / n_activation.to_double() + } else { + 0.0 + } + let repression_mean = if n_repression > 0 { + repression_sum / n_repression.to_double() + } else { + 0.0 + } // VIPER score: difference between activation and repression means activation_mean - repression_mean @@ -337,7 +341,9 @@ pub fn dorothea_permutation_test( regulon : Regulon, n_permutations : Int, ) -> (Double, Double) { - let observed = dorothea_compute_viper_activity(cell_expression, gene_names, regulon) + let observed = dorothea_compute_viper_activity( + cell_expression, gene_names, regulon, + ) // Generate null distribution by shuffling gene labels let null_scores : Array[Double] = Array::new() @@ -363,7 +369,9 @@ pub fn dorothea_permutation_test( j = j - 1 } - let null_score = dorothea_compute_viper_activity(shuffled, gene_names, regulon) + let null_score = dorothea_compute_viper_activity( + shuffled, gene_names, regulon, + ) null_scores.push(null_score) perm = perm + 1 } @@ -442,7 +450,9 @@ pub fn dorothea_analyze_cell( continue } - let activity = dorothea_compute_viper_activity(cell_expression, gene_names, regulon) + let activity = dorothea_compute_viper_activity( + cell_expression, gene_names, regulon, + ) let (p_value, z_score) = dorothea_permutation_test( cell_expression, gene_names, @@ -497,7 +507,9 @@ pub fn dorothea_analyze_cells( for regulon in regulons { if regulon.targets.length() >= params.min_targets { - let activity = dorothea_compute_viper_activity(cell_expr, gene_names, regulon) + let activity = dorothea_compute_viper_activity( + cell_expr, gene_names, regulon, + ) let current = tf_activities.get(regulon.tf).unwrap_or([]) let updated = current.copy() updated.push(activity) @@ -561,7 +573,9 @@ pub fn dorothea_filter_results( ///| /// Sort TF activity results by absolute z-score (descending). -pub fn dorothea_sort_by_activity(results : Array[TFActivityResult]) -> Array[TFActivityResult] { +pub fn dorothea_sort_by_activity( + results : Array[TFActivityResult], +) -> Array[TFActivityResult] { // Simple bubble sort by abs(z_score) descending let n = results.length() let sorted = results.copy() @@ -569,7 +583,7 @@ pub fn dorothea_sort_by_activity(results : Array[TFActivityResult]) -> Array[TFA while i < n - 1 { let mut j = 0 while j < n - i - 1 { - if (sorted[j].z_score).abs() < (sorted[j + 1].z_score).abs() { + if sorted[j].z_score.abs() < sorted[j + 1].z_score.abs() { let temp = sorted[j] sorted[j] = sorted[j + 1] sorted[j + 1] = temp @@ -583,7 +597,11 @@ pub fn dorothea_sort_by_activity(results : Array[TFActivityResult]) -> Array[TFA ///| /// Create synthetic test data for dorothea testing. -pub fn dorothea_create_test_data() -> (Array[Array[Double]], Array[String], Array[String]) { +pub fn dorothea_create_test_data() -> ( + Array[Array[Double]], + Array[String], + Array[String], +) { let regulons = dorothea_get_regulons() // Collect all unique genes from regulons @@ -611,7 +629,7 @@ pub fn dorothea_create_test_data() -> (Array[Array[Double]], Array[String], Arra // Vary expression across cells with some structure let base = 5.0 let variation = (c.to_double() + 1.0) * 0.5 - let expr = base + variation + (g.to_double() * 0.01) + let expr = base + variation + g.to_double() * 0.01 col.push(expr) c = c + 1 } @@ -631,7 +649,10 @@ pub fn dorothea_create_test_data() -> (Array[Array[Double]], Array[String], Arra ///| /// Get top TF results by absolute activity. -pub fn dorothea_get_top_tfs(results : Array[TFActivityResult], n : Int) -> Array[TFActivityResult] { +pub fn dorothea_get_top_tfs( + results : Array[TFActivityResult], + n : Int, +) -> Array[TFActivityResult] { let sorted = dorothea_sort_by_activity(results) let top : Array[TFActivityResult] = Array::new() let limit = if n < sorted.length() { n } else { sorted.length() } @@ -641,4 +662,4 @@ pub fn dorothea_get_top_tfs(results : Array[TFActivityResult], n : Int) -> Array i = i + 1 } top -} \ No newline at end of file +} diff --git a/src/drimseq.mbt b/src/drimseq.mbt index 1b550fae..9b2ab392 100644 --- a/src/drimseq.mbt +++ b/src/drimseq.mbt @@ -74,7 +74,11 @@ pub fn TranscriptCount::new( ///| /// Calculate the proportion (count / gene_count). pub fn TranscriptCount::proportion(self : TranscriptCount) -> Double { - if self.gene_count > 0.0 { self.count / self.gene_count } else { 0.0 } + if self.gene_count > 0.0 { + self.count / self.gene_count + } else { + 0.0 + } } ///| @@ -142,7 +146,9 @@ pub struct DRIMSeqResult { ///| /// Get significant results. -pub fn DRIMSeqResult::get_significant(self : DRIMSeqResult) -> Array[DRIMSeqGeneResult] { +pub fn DRIMSeqResult::get_significant( + self : DRIMSeqResult, +) -> Array[DRIMSeqGeneResult] { let sig : Array[DRIMSeqGeneResult] = Array::new() let mut i = 0 while i < self.gene_results.length() { @@ -192,7 +198,12 @@ pub fn DRIMSeqResult::summary(self : DRIMSeqResult) -> String { let mut s = "=== DRIMSeq Differential Transcript Usage ===" + "\n" s = s + "Total genes tested: " + self.n_genes_tested.to_string() + "\n" s = s + "Genes passing filter: " + self.n_genes_filtered.to_string() + "\n" - s = s + "Significant genes (alpha=" + self.alpha.to_string() + "): " + self.n_significant.to_string() + "\n" + s = s + + "Significant genes (alpha=" + + self.alpha.to_string() + + "): " + + self.n_significant.to_string() + + "\n" s = s + "Converged: " + self.converged.to_string() + "\n" s = s + "Iterations: " + self.iterations.to_string() + "\n" s @@ -288,7 +299,9 @@ pub fn drimseq_aggregate_by_gene( let mut found = false let mut j = 0 while j < result.length() { - if result[j].gene_id == c.gene_id && result[j].sample_id == c.sample_id && result[j].condition == c.condition { + if result[j].gene_id == c.gene_id && + result[j].sample_id == c.sample_id && + result[j].condition == c.condition { result[j].count = result[j].count + c.count found = true break @@ -296,9 +309,15 @@ pub fn drimseq_aggregate_by_gene( j = j + 1 } if !found { - result.push(TranscriptCount::new( - transcript_id="__gene_total__", gene_id=c.gene_id, sample_id=c.sample_id, condition=c.condition, count=c.count, - )) + result.push( + TranscriptCount::new( + transcript_id="__gene_total__", + gene_id=c.gene_id, + sample_id=c.sample_id, + condition=c.condition, + count=c.count, + ), + ) } i = i + 1 } @@ -318,16 +337,23 @@ pub fn drimseq_compute_proportions( let mut gene_total = 0.0 let mut j = 0 while j < gene_counts.length() { - if gene_counts[j].gene_id == c.gene_id && gene_counts[j].sample_id == c.sample_id { + if gene_counts[j].gene_id == c.gene_id && + gene_counts[j].sample_id == c.sample_id { gene_total = gene_counts[j].count break } j = j + 1 } - result.push(TranscriptCount::new( - transcript_id=c.transcript_id, gene_id=c.gene_id, sample_id=c.sample_id, condition=c.condition, count=c.count, - gene_count=gene_total, - )) + result.push( + TranscriptCount::new( + transcript_id=c.transcript_id, + gene_id=c.gene_id, + sample_id=c.sample_id, + condition=c.condition, + count=c.count, + gene_count=gene_total, + ), + ) i = i + 1 } result @@ -362,11 +388,17 @@ pub fn drimseq_dirichlet_multinomial( proportions~ : Array[Double], ) -> Double { let n = counts.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let sum_counts = array_sum(counts) - if sum_counts <= 0.0 { return 0.0 } + if sum_counts <= 0.0 { + return 0.0 + } let sum_props = array_sum(proportions) - if sum_props <= 0.0 { return 0.0 } + if sum_props <= 0.0 { + return 0.0 + } let mut loglik = 0.0 // Log-gamma(sum(counts) + 1) - sum(log-gamma(count_i + 1)) @@ -387,7 +419,9 @@ pub fn drimseq_dirichlet_multinomial( loglik = loglik - drimseq_log_gamma(alpha_j) j = j + 1 } - loglik = loglik - drimseq_log_gamma(alpha_sum + sum_counts) + drimseq_log_gamma(alpha_sum) + loglik = loglik - + drimseq_log_gamma(alpha_sum + sum_counts) + + drimseq_log_gamma(alpha_sum) loglik } @@ -400,7 +434,9 @@ pub fn drimseq_wald_test( proportions_b : Array[Double], ) -> (Double, Double, Array[Double]) { let n = proportions_a.length() - if n == 0 { return (0.0, 1.0, Array::new()) } + if n == 0 { + return (0.0, 1.0, Array::new()) + } let delta = array_sub(proportions_a, proportions_b) let mut stat = 0.0 let mut i = 0 @@ -427,7 +463,7 @@ pub fn drimseq_test_differential( ) -> DRIMSeqResult { let gene_counts = drimseq_aggregate_by_gene(counts) let props = drimseq_compute_proportions(counts, gene_counts) - let filtered = drimseq_filter_counts(props, config=config) + let filtered = drimseq_filter_counts(props, config~) let gene_results : Array[DRIMSeqGeneResult] = Array::new() @@ -463,9 +499,15 @@ pub fn drimseq_test_differential( let (stat, pval, delta) = drimseq_wald_test(pa, pb) - gene_results.push(DRIMSeqGeneResult::new( - gene_id=gene_id, delta=delta, p_value=pval, df=n_transcripts - 1, lr_stat=stat, - )) + gene_results.push( + DRIMSeqGeneResult::new( + gene_id~, + delta~, + p_value=pval, + df=n_transcripts - 1, + lr_stat=stat, + ), + ) gi = gi + 1 } @@ -483,7 +525,9 @@ pub fn drimseq_test_differential( let mut n_sig = 0 let mut j = 0 while j < gene_results.length() { - if gene_results[j].significant { n_sig = n_sig + 1 } + if gene_results[j].significant { + n_sig = n_sig + 1 + } j = j + 1 } @@ -514,80 +558,255 @@ pub fn drimseq_sample_data() -> Array[TranscriptCount] { let counts : Array[TranscriptCount] = Array::new() // GeneA: 2 transcripts, condition_a (3 samples) - counts.push(TranscriptCount::new(transcript_id="tx_A1", gene_id="GeneA", sample_id="s1", condition="cond_a", count=100.0, gene_count=150.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A2", gene_id="GeneA", sample_id="s1", condition="cond_a", count=50.0, gene_count=150.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A1", gene_id="GeneA", sample_id="s2", condition="cond_a", count=120.0, gene_count=180.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A2", gene_id="GeneA", sample_id="s2", condition="cond_a", count=60.0, gene_count=180.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A1", gene_id="GeneA", sample_id="s3", condition="cond_a", count=110.0, gene_count=170.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A2", gene_id="GeneA", sample_id="s3", condition="cond_a", count=60.0, gene_count=170.0)) + counts.push( + TranscriptCount::new( + transcript_id="tx_A1", + gene_id="GeneA", + sample_id="s1", + condition="cond_a", + count=100.0, + gene_count=150.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A2", + gene_id="GeneA", + sample_id="s1", + condition="cond_a", + count=50.0, + gene_count=150.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A1", + gene_id="GeneA", + sample_id="s2", + condition="cond_a", + count=120.0, + gene_count=180.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A2", + gene_id="GeneA", + sample_id="s2", + condition="cond_a", + count=60.0, + gene_count=180.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A1", + gene_id="GeneA", + sample_id="s3", + condition="cond_a", + count=110.0, + gene_count=170.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A2", + gene_id="GeneA", + sample_id="s3", + condition="cond_a", + count=60.0, + gene_count=170.0, + ), + ) // GeneA: 2 transcripts, condition_b (3 samples) - DIFFERENT proportions - counts.push(TranscriptCount::new(transcript_id="tx_A1", gene_id="GeneA", sample_id="s4", condition="cond_b", count=50.0, gene_count=180.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A2", gene_id="GeneA", sample_id="s4", condition="cond_b", count=130.0, gene_count=180.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A1", gene_id="GeneA", sample_id="s5", condition="cond_b", count=45.0, gene_count=170.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A2", gene_id="GeneA", sample_id="s5", condition="cond_b", count=125.0, gene_count=170.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A1", gene_id="GeneA", sample_id="s6", condition="cond_b", count=55.0, gene_count=175.0)) - counts.push(TranscriptCount::new(transcript_id="tx_A2", gene_id="GeneA", sample_id="s6", condition="cond_b", count=120.0, gene_count=175.0)) + counts.push( + TranscriptCount::new( + transcript_id="tx_A1", + gene_id="GeneA", + sample_id="s4", + condition="cond_b", + count=50.0, + gene_count=180.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A2", + gene_id="GeneA", + sample_id="s4", + condition="cond_b", + count=130.0, + gene_count=180.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A1", + gene_id="GeneA", + sample_id="s5", + condition="cond_b", + count=45.0, + gene_count=170.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A2", + gene_id="GeneA", + sample_id="s5", + condition="cond_b", + count=125.0, + gene_count=170.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A1", + gene_id="GeneA", + sample_id="s6", + condition="cond_b", + count=55.0, + gene_count=175.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_A2", + gene_id="GeneA", + sample_id="s6", + condition="cond_b", + count=120.0, + gene_count=175.0, + ), + ) // GeneB: 1 transcript, no difference - counts.push(TranscriptCount::new(transcript_id="tx_B1", gene_id="GeneB", sample_id="s1", condition="cond_a", count=200.0, gene_count=200.0)) - counts.push(TranscriptCount::new(transcript_id="tx_B1", gene_id="GeneB", sample_id="s2", condition="cond_a", count=210.0, gene_count=210.0)) - counts.push(TranscriptCount::new(transcript_id="tx_B1", gene_id="GeneB", sample_id="s3", condition="cond_a", count=195.0, gene_count=195.0)) - counts.push(TranscriptCount::new(transcript_id="tx_B1", gene_id="GeneB", sample_id="s4", condition="cond_b", count=205.0, gene_count=205.0)) - counts.push(TranscriptCount::new(transcript_id="tx_B1", gene_id="GeneB", sample_id="s5", condition="cond_b", count=215.0, gene_count=215.0)) - counts.push(TranscriptCount::new(transcript_id="tx_B1", gene_id="GeneB", sample_id="s6", condition="cond_b", count=200.0, gene_count=200.0)) + counts.push( + TranscriptCount::new( + transcript_id="tx_B1", + gene_id="GeneB", + sample_id="s1", + condition="cond_a", + count=200.0, + gene_count=200.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_B1", + gene_id="GeneB", + sample_id="s2", + condition="cond_a", + count=210.0, + gene_count=210.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_B1", + gene_id="GeneB", + sample_id="s3", + condition="cond_a", + count=195.0, + gene_count=195.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_B1", + gene_id="GeneB", + sample_id="s4", + condition="cond_b", + count=205.0, + gene_count=205.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_B1", + gene_id="GeneB", + sample_id="s5", + condition="cond_b", + count=215.0, + gene_count=215.0, + ), + ) + counts.push( + TranscriptCount::new( + transcript_id="tx_B1", + gene_id="GeneB", + sample_id="s6", + condition="cond_b", + count=200.0, + gene_count=200.0, + ), + ) counts } // --- Helper functions --- +///| fn array_sum(arr : Array[Double]) -> Double { let mut s = 0.0 let mut i = 0 - while i < arr.length() { s = s + arr[i]; i = i + 1 } + while i < arr.length() { + s = s + arr[i] + i = i + 1 + } s } +///| fn array_sub(a : Array[Double], b : Array[Double]) -> Array[Double] { let len = min_int(a.length(), b.length()) let result : Array[Double] = Array::new() let mut i = 0 - while i < len { result.push(a[i] - b[i]); i = i + 1 } + while i < len { + result.push(a[i] - b[i]) + i = i + 1 + } result } +///| fn array_dot(a : Array[Double], b : Array[Double]) -> Double { let len = min_int(a.length(), b.length()) let mut s = 0.0 let mut i = 0 - while i < len { s = s + a[i] * b[i]; i = i + 1 } + while i < len { + s = s + a[i] * b[i] + i = i + 1 + } s } +///| fn slice_array(arr : Array[Double], start : Int, end : Int) -> Array[Double] { let result : Array[Double] = Array::new() let i = start let j = if end > arr.length() { arr.length() } else { end } let mut k = i - while k < j { result.push(arr[k]); k = k + 1 } + while k < j { + result.push(arr[k]) + k = k + 1 + } result } +///| /// Log-gamma function (Lanczos approximation). fn drimseq_log_gamma(x : Double) -> Double { - if x <= 0.0 { return 0.0 } + if x <= 0.0 { + return 0.0 + } if x < 1.0 { let g = 7.0 let c = [ - 0.99999999999980993, - 676.5203681218851, - -1259.1392167224028, - 771.32342877765313, - -176.61502916214059, - 12.507343278686905, - -0.13857109526572012, - 9.9843695780195716e-6, + 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, + -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7, ] let xx = x @@ -606,14 +825,23 @@ fn drimseq_log_gamma(x : Double) -> Double { } else { // Stirling's approximation for x >= 1 let pi = 3.141592653589793 - 0.5 * @math.ln(2.0 * pi / x) + @math.ln(x) * (x - 0.5) - x + 1.0 / (12.0 * x) - 1.0 / (360.0 * x * x * x) + 0.5 * @math.ln(2.0 * pi / x) + + @math.ln(x) * (x - 0.5) - + x + + 1.0 / (12.0 * x) - + 1.0 / (360.0 * x * x * x) } } +///| /// Chi-square p-value approximation. fn chi_square_p_value(stat : Double, df : Int) -> Double { - if stat <= 0.0 { return 1.0 } - if df <= 0 { return 1.0 } + if stat <= 0.0 { + return 1.0 + } + if df <= 0 { + return 1.0 + } // Use Wilson-Hilferty approximation let df_d = df.to_double() let x = stat / df_d @@ -621,27 +849,47 @@ fn chi_square_p_value(stat : Double, df : Int) -> Double { let x1_3 = @math.pow(x, 1.0 / 3.0) let z = (x1_3 - (1.0 - 2.0 / (9.0 * df_d))) / (2.0 / (9.0 * df_d)).sqrt() let p = normal_sf(z) - if p < 0.0 { 0.0 } else { p } + if p < 0.0 { + 0.0 + } else { + p + } } +///| /// Normal distribution survival function (1 - CDF). fn normal_sf(z : Double) -> Double { // Abramowitz and Stegun approximation let t = 1.0 / (1.0 + 0.2316419 * z.abs()) let d = 0.3989422804014327 * @math.exp(-0.5 * z * z) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))) - if z > 0.0 { p } else { 1.0 - p } + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))) + ) + if z > 0.0 { + p + } else { + 1.0 - p + } } +///| /// Benjamini-Hochberg p-value correction. fn benjamini_hochberg_correct(pvalues : Array[Double]) -> Array[Double] { let n = pvalues.length() - if n == 0 { return Array::new() } + if n == 0 { + return Array::new() + } // Create index array and sort by p-value let indices : Array[Int] = Array::new() let mut i = 0 - while i < n { indices.push(i); i = i + 1 } + while i < n { + indices.push(i) + i = i + 1 + } // Simple bubble sort let sorted_p = pvalues @@ -670,18 +918,27 @@ fn benjamini_hochberg_correct(pvalues : Array[Double]) -> Array[Double] { let rank = (idx + 1).to_double() let val = sorted_p[idx] * (n.to_double() / rank) if idx < n - 1 { - if val > adj[idx + 1] { adj[idx] = adj[idx + 1] } else { adj[idx] = val } + if val > adj[idx + 1] { + adj[idx] = adj[idx + 1] + } else { + adj[idx] = val + } } else { adj[idx] = val } - if adj[idx] > 1.0 { adj[idx] = 1.0 } + if adj[idx] > 1.0 { + adj[idx] = 1.0 + } idx = idx - 1 } // Map back to original order let result : Array[Double] = Array::new() let mut m = 0 - while m < n { result.push(0.0); m = m + 1 } + while m < n { + result.push(0.0) + m = m + 1 + } let mut r = 0 while r < n { @@ -692,6 +949,7 @@ fn benjamini_hochberg_correct(pvalues : Array[Double]) -> Array[Double] { result } +///| fn get_unique_genes(counts : Array[TranscriptCount]) -> Array[String] { let genes : Array[String] = Array::new() let mut i = 0 @@ -700,25 +958,37 @@ fn get_unique_genes(counts : Array[TranscriptCount]) -> Array[String] { let mut found = false let mut j = 0 while j < genes.length() { - if genes[j] == id { found = true; break } + if genes[j] == id { + found = true + break + } j = j + 1 } - if !found { genes.push(id) } + if !found { + genes.push(id) + } i = i + 1 } genes } -fn get_gene_data(counts : Array[TranscriptCount], gene_id : String) -> Array[TranscriptCount] { +///| +fn get_gene_data( + counts : Array[TranscriptCount], + gene_id : String, +) -> Array[TranscriptCount] { let result : Array[TranscriptCount] = Array::new() let mut i = 0 while i < counts.length() { - if counts[i].gene_id == gene_id { result.push(counts[i]) } + if counts[i].gene_id == gene_id { + result.push(counts[i]) + } i = i + 1 } result } +///| fn get_unique_conditions(data : Array[TranscriptCount]) -> Array[String] { let conds : Array[String] = Array::new() let mut i = 0 @@ -727,16 +997,25 @@ fn get_unique_conditions(data : Array[TranscriptCount]) -> Array[String] { let mut found = false let mut j = 0 while j < conds.length() { - if conds[j] == c { found = true; break } + if conds[j] == c { + found = true + break + } j = j + 1 } - if !found { conds.push(c) } + if !found { + conds.push(c) + } i = i + 1 } conds } -fn get_condition_proportions(data : Array[TranscriptCount], condition : String) -> Array[Double] { +///| +fn get_condition_proportions( + data : Array[TranscriptCount], + condition : String, +) -> Array[Double] { let props : Array[Double] = Array::new() let mut i = 0 while i < data.length() { @@ -748,6 +1027,7 @@ fn get_condition_proportions(data : Array[TranscriptCount], condition : String) props } +///| fn extract_pvalues(results : Array[DRIMSeqGeneResult]) -> Array[Double] { let pvals : Array[Double] = Array::new() let mut i = 0 diff --git a/src/droplet_utils.mbt b/src/droplet_utils.mbt index ee8e18b2..ff7737f0 100644 --- a/src/droplet_utils.mbt +++ b/src/droplet_utils.mbt @@ -407,7 +407,8 @@ pub fn create_example_droplet_data() -> (Array[Array[Int]], Array[String]) { let mut count = 0 if i < 30 { if (j * 7 + i * 13).to_double() % 10.0 / 10.0 < 0.3 { - count = ((j * 7 + i * 13).to_double() % 10.0 / 10.0 * 20.0).to_int() + 1 + count = ((j * 7 + i * 13).to_double() % 10.0 / 10.0 * 20.0).to_int() + + 1 } } else if (j * 7 + i * 13).to_double() % 10.0 / 10.0 < 0.05 { count = ((j * 7 + i * 13).to_double() % 10.0 / 10.0 * 5.0).to_int() diff --git a/src/dss.mbt b/src/dss.mbt index 5755afd9..1e2e1fea 100644 --- a/src/dss.mbt +++ b/src/dss.mbt @@ -4,6 +4,7 @@ /// Supports RNA-seq differential expression analysis with dispersion estimation, /// and differential methylation analysis for bisulfite sequencing data. +///| /// Dispersion estimation methods pub enum DSSDispMethod { /// Maximum likelihood estimation @@ -12,6 +13,7 @@ pub enum DSSDispMethod { Shrink } +///| /// Result of dispersion estimation pub struct DSSDispResult { /// Dispersion values for each gene/probe @@ -24,6 +26,7 @@ pub struct DSSDispResult { prior_var : Double } +///| /// Gene count data structure pub struct DSSCountData { /// Gene IDs @@ -36,6 +39,7 @@ pub struct DSSCountData { lib_sizes : Array[Double] } +///| /// Result of differential expression analysis pub struct DSSDEResult { /// Gene IDs @@ -56,6 +60,7 @@ pub struct DSSDEResult { significant : Array[Bool] } +///| /// CpG site methylation data pub struct DSSMethylData { /// CpG site IDs @@ -72,6 +77,7 @@ pub struct DSSMethylData { groups : Array[String] } +///| /// Result of differential methylation analysis pub struct DSSDMResult { /// CpG site IDs @@ -92,6 +98,7 @@ pub struct DSSDMResult { significant : Array[Bool] } +///| /// Result of DMR detection pub struct DSSDMRResult { /// DMR IDs @@ -114,75 +121,110 @@ pub struct DSSDMRResult { // ===== DSSDispResult methods ===== +///| /// Create new dispersion result -pub fn DSSDispResult::new(dispersions : Array[Double], shrunken_dispersions : Array[Double], prior_df : Double, prior_var : Double) -> DSSDispResult { +pub fn DSSDispResult::new( + dispersions : Array[Double], + shrunken_dispersions : Array[Double], + prior_df : Double, + prior_var : Double, +) -> DSSDispResult { DSSDispResult::{ dispersions, shrunken_dispersions, prior_df, prior_var } } +///| /// Get dispersion values -pub fn DSSDispResult::dss_get_dispersions(self : DSSDispResult) -> Array[Double] { +pub fn DSSDispResult::dss_get_dispersions( + self : DSSDispResult, +) -> Array[Double] { self.dispersions } +///| /// Get shrunken dispersion values -pub fn DSSDispResult::dss_get_shrunken_dispersions(self : DSSDispResult) -> Array[Double] { +pub fn DSSDispResult::dss_get_shrunken_dispersions( + self : DSSDispResult, +) -> Array[Double] { self.shrunken_dispersions } // ===== DSSCountData methods ===== +///| /// Create new count data -pub fn DSSCountData::new(gene_ids : Array[String], counts : Array[Array[Double]], groups : Array[String], lib_sizes : Array[Double]) -> DSSCountData { +pub fn DSSCountData::new( + gene_ids : Array[String], + counts : Array[Array[Double]], + groups : Array[String], + lib_sizes : Array[Double], +) -> DSSCountData { DSSCountData::{ gene_ids, counts, groups, lib_sizes } } +///| /// Get gene count for specific gene and sample -pub fn DSSCountData::dss_get_count(self : DSSCountData, gene_idx : Int, sample_idx : Int) -> Double { +pub fn DSSCountData::dss_get_count( + self : DSSCountData, + gene_idx : Int, + sample_idx : Int, +) -> Double { self.counts[gene_idx][sample_idx] } +///| /// Get number of genes pub fn DSSCountData::dss_n_genes(self : DSSCountData) -> Int { self.gene_ids.length() } +///| /// Get number of samples pub fn DSSCountData::dss_n_samples(self : DSSCountData) -> Int { self.groups.length() } +///| /// Normalize counts by library size pub fn DSSCountData::dss_normalize(self : DSSCountData) -> Array[Array[Double]] { let n_genes = self.counts.length() let n_samples = if n_genes > 0 { self.counts[0].length() } else { 0 } let normalized : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_genes { let row : Array[Double] = Array::new() let mut j = 0 while j < n_samples { - let lib_size = if j < self.lib_sizes.length() { self.lib_sizes[j] } else { 1.0 } + let lib_size = if j < self.lib_sizes.length() { + self.lib_sizes[j] + } else { + 1.0 + } row.push(self.counts[i][j] / lib_size * 1000000.0) j = j + 1 } normalized.push(row) i = i + 1 } - + normalized } +///| /// Filter low count genes -pub fn DSSCountData::dss_filter_low_counts(self : DSSCountData, min_count : Double, min_samples : Int) -> DSSCountData { +pub fn DSSCountData::dss_filter_low_counts( + self : DSSCountData, + min_count : Double, + min_samples : Int, +) -> DSSCountData { let new_gene_ids : Array[String] = Array::new() let new_counts : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < self.gene_ids.length() { let count_row = self.counts[i] let mut passing_samples = 0 - + let mut j = 0 while j < count_row.length() { if count_row[j] >= min_count { @@ -190,33 +232,51 @@ pub fn DSSCountData::dss_filter_low_counts(self : DSSCountData, min_count : Doub } j = j + 1 } - + if passing_samples >= min_samples { new_gene_ids.push(self.gene_ids[i]) new_counts.push(count_row) } - + i = i + 1 } - + DSSCountData::new(new_gene_ids, new_counts, self.groups, self.lib_sizes) } // ===== DSSDEResult methods ===== +///| /// Create new DSR result -pub fn DSSDEResult::new(gene_ids : Array[String], mean1 : Array[Double], mean2 : Array[Double], - dispersion : Array[Double], wald_stat : Array[Double], - p_values : Array[Double], adj_p_values : Array[Double], - significant : Array[Bool]) -> DSSDEResult { - DSSDEResult::{ gene_ids, mean1, mean2, dispersion, wald_stat, p_values, adj_p_values, significant } +pub fn DSSDEResult::new( + gene_ids : Array[String], + mean1 : Array[Double], + mean2 : Array[Double], + dispersion : Array[Double], + wald_stat : Array[Double], + p_values : Array[Double], + adj_p_values : Array[Double], + significant : Array[Bool], +) -> DSSDEResult { + DSSDEResult::{ + gene_ids, + mean1, + mean2, + dispersion, + wald_stat, + p_values, + adj_p_values, + significant, + } } +///| /// Get number of genes pub fn DSSDEResult::dss_n_genes(self : DSSDEResult) -> Int { self.gene_ids.length() } +///| /// Get significant gene count pub fn DSSDEResult::dss_n_significant(self : DSSDEResult) -> Int { let mut count = 0 @@ -230,21 +290,25 @@ pub fn DSSDEResult::dss_n_significant(self : DSSDEResult) -> Int { count } +///| /// Get gene ID at index pub fn DSSDEResult::dss_get_gene_id(self : DSSDEResult, idx : Int) -> String { self.gene_ids[idx] } +///| /// Get p-value at index pub fn DSSDEResult::dss_get_pvalue(self : DSSDEResult, idx : Int) -> Double { self.p_values[idx] } +///| /// Get adjusted p-value at index pub fn DSSDEResult::dss_get_adj_pvalue(self : DSSDEResult, idx : Int) -> Double { self.adj_p_values[idx] } +///| /// Get fold change at index (log2 scale) pub fn DSSDEResult::dss_get_logfc(self : DSSDEResult, idx : Int) -> Double { if self.mean1[idx] > 0.0 && self.mean2[idx] > 0.0 { @@ -256,25 +320,38 @@ pub fn DSSDEResult::dss_get_logfc(self : DSSDEResult, idx : Int) -> Double { // ===== DSSMethylData methods ===== +///| /// Create new methylation data -pub fn DSSMethylData::new(cpg_ids : Array[String], chrom : Array[String], pos : Array[Int], - meth_counts : Array[Array[Double]], total_counts : Array[Array[Double]], - groups : Array[String]) -> DSSMethylData { +pub fn DSSMethylData::new( + cpg_ids : Array[String], + chrom : Array[String], + pos : Array[Int], + meth_counts : Array[Array[Double]], + total_counts : Array[Array[Double]], + groups : Array[String], +) -> DSSMethylData { DSSMethylData::{ cpg_ids, chrom, pos, meth_counts, total_counts, groups } } +///| /// Get number of CpG sites pub fn DSSMethylData::dss_n_cpgs(self : DSSMethylData) -> Int { self.cpg_ids.length() } +///| /// Get number of samples pub fn DSSMethylData::dss_n_samples(self : DSSMethylData) -> Int { self.groups.length() } +///| /// Calculate methylation proportion for a site and sample -pub fn DSSMethylData::dss_get_meth_prop(self : DSSMethylData, cpg_idx : Int, sample_idx : Int) -> Double { +pub fn DSSMethylData::dss_get_meth_prop( + self : DSSMethylData, + cpg_idx : Int, + sample_idx : Int, +) -> Double { let total = self.total_counts[cpg_idx][sample_idx] if total > 0.0 { self.meth_counts[cpg_idx][sample_idx] / total @@ -285,19 +362,37 @@ pub fn DSSMethylData::dss_get_meth_prop(self : DSSMethylData, cpg_idx : Int, sam // ===== DSSDMResult methods ===== +///| /// Create new DM result -pub fn DSSDMResult::new(cpg_ids : Array[String], meth_mean1 : Array[Double], meth_mean2 : Array[Double], - delta_meth : Array[Double], stats : Array[Double], - p_values : Array[Double], adj_p_values : Array[Double], - significant : Array[Bool]) -> DSSDMResult { - DSSDMResult::{ cpg_ids, meth_mean1, meth_mean2, delta_meth, stats, p_values, adj_p_values, significant } +pub fn DSSDMResult::new( + cpg_ids : Array[String], + meth_mean1 : Array[Double], + meth_mean2 : Array[Double], + delta_meth : Array[Double], + stats : Array[Double], + p_values : Array[Double], + adj_p_values : Array[Double], + significant : Array[Bool], +) -> DSSDMResult { + DSSDMResult::{ + cpg_ids, + meth_mean1, + meth_mean2, + delta_meth, + stats, + p_values, + adj_p_values, + significant, + } } +///| /// Get number of sites pub fn DSSDMResult::dss_n_sites(self : DSSDMResult) -> Int { self.cpg_ids.length() } +///| /// Get significant site count pub fn DSSDMResult::dss_n_significant(self : DSSDMResult) -> Int { let mut count = 0 @@ -311,6 +406,7 @@ pub fn DSSDMResult::dss_n_significant(self : DSSDMResult) -> Int { count } +///| /// Get delta methylation at index pub fn DSSDMResult::dss_get_delta_meth(self : DSSDMResult, idx : Int) -> Double { self.delta_meth[idx] @@ -318,26 +414,55 @@ pub fn DSSDMResult::dss_get_delta_meth(self : DSSDMResult, idx : Int) -> Double // ===== DSSDMRResult methods ===== +///| /// Create new DMR result -pub fn DSSDMRResult::new(dmr_ids : Array[String], chrom : Array[String], start : Array[Int], - end : Array[Int], n_cpgs : Array[Int], mean_delta : Array[Double], - stats : Array[Double], p_values : Array[Double]) -> DSSDMRResult { - DSSDMRResult::{ dmr_ids, chrom, start, end, n_cpgs, mean_delta, stats, p_values } +pub fn DSSDMRResult::new( + dmr_ids : Array[String], + chrom : Array[String], + start : Array[Int], + end : Array[Int], + n_cpgs : Array[Int], + mean_delta : Array[Double], + stats : Array[Double], + p_values : Array[Double], +) -> DSSDMRResult { + DSSDMRResult::{ + dmr_ids, + chrom, + start, + end, + n_cpgs, + mean_delta, + stats, + p_values, + } } +///| /// Get number of DMRs pub fn DSSDMRResult::dss_n_dmrs(self : DSSDMRResult) -> Int { self.dmr_ids.length() } +///| /// Get DMR at index -pub fn DSSDMRResult::dss_get_dmr(self : DSSDMRResult, idx : Int) -> (String, String, Int, Int, Int, Double) { - (self.dmr_ids[idx], self.chrom[idx], self.start[idx], self.end[idx], - self.n_cpgs[idx], self.mean_delta[idx]) +pub fn DSSDMRResult::dss_get_dmr( + self : DSSDMRResult, + idx : Int, +) -> (String, String, Int, Int, Int, Double) { + ( + self.dmr_ids[idx], + self.chrom[idx], + self.start[idx], + self.end[idx], + self.n_cpgs[idx], + self.mean_delta[idx], + ) } // ===== Helper functions ===== +///| /// Calculate mean of array fn dss_mean(arr : Array[Double]) -> Double { if arr.length() == 0 { @@ -352,6 +477,7 @@ fn dss_mean(arr : Array[Double]) -> Double { sum / arr.length().to_double() } +///| /// Calculate variance of array fn dss_var(arr : Array[Double]) -> Double { if arr.length() < 2 { @@ -369,64 +495,66 @@ fn dss_var(arr : Array[Double]) -> Double { // ===== Public API functions ===== +///| /// Estimate per-gene dispersion using method of moments pub fn dss_estimate_dispersion(counts_data : DSSCountData) -> DSSDispResult { let n_genes = counts_data.dss_n_genes() let n_samples = counts_data.dss_n_samples() - + let dispersions : Array[Double] = Array::new() let norm_counts = counts_data.dss_normalize() - + let mut i = 0 while i < n_genes { let expr = norm_counts[i] let m = dss_mean(expr) let v = dss_var(expr) - - let disp = if m > 0.0 { - v / m.pow(2.0) - } else { - 0.0000000001 - } - + + let disp = if m > 0.0 { v / m.pow(2.0) } else { 0.0000000001 } + dispersions.push(disp) i = i + 1 } - + // Shrinkage estimation let mean_disp = dss_mean(dispersions) let var_disp = dss_var(dispersions) - + let prior_df = if var_disp > 0.0 { 2.0 * mean_disp.pow(2.0) / var_disp } else { 10.0 } let prior_var = mean_disp - + let shrunken : Array[Double] = Array::new() i = 0 while i < n_genes { let disp = dispersions[i] // Empirical Bayes shrinkage let post_df = prior_df + n_samples.to_double() - let post_var = (prior_df * prior_var + (n_samples.to_double() - 1.0) * disp) / post_df + let post_var = (prior_df * prior_var + (n_samples.to_double() - 1.0) * disp) / + post_df shrunken.push(post_var) i = i + 1 } - + DSSDispResult::new(dispersions, shrunken, prior_df, prior_var) } +///| /// Perform differential expression analysis using Wald test -pub fn dss_deseq(counts_data : DSSCountData, disp_result : DSSDispResult) -> DSSDEResult { +pub fn dss_deseq( + counts_data : DSSCountData, + disp_result : DSSDispResult, +) -> DSSDEResult { let n_genes = counts_data.dss_n_genes() let n_samples = counts_data.dss_n_samples() let norm_counts = counts_data.dss_normalize() - + let group1_idx : Array[Int] = Array::new() let group2_idx : Array[Int] = Array::new() - + let mut j = 0 while j < n_samples { if counts_data.groups[j] == "group1" { @@ -436,21 +564,21 @@ pub fn dss_deseq(counts_data : DSSCountData, disp_result : DSSDispResult) -> DSS } j = j + 1 } - + let n1 = group1_idx.length().to_double() let n2 = group2_idx.length().to_double() - + let mean1_arr : Array[Double] = Array::new() let mean2_arr : Array[Double] = Array::new() let disp_arr : Array[Double] = Array::new() let wald_stat_arr : Array[Double] = Array::new() let p_values_arr : Array[Double] = Array::new() let gene_ids_arr : Array[String] = Array::new() - + let mut i = 0 while i < n_genes { let expr = norm_counts[i] - + let sum1 = if n1 > 0.0 { let mut s = 0.0 let mut k = 0 @@ -462,7 +590,7 @@ pub fn dss_deseq(counts_data : DSSCountData, disp_result : DSSDispResult) -> DSS } else { 0.0 } - + let sum2 = if n2 > 0.0 { let mut s = 0.0 let mut k = 0 @@ -474,44 +602,40 @@ pub fn dss_deseq(counts_data : DSSCountData, disp_result : DSSDispResult) -> DSS } else { 0.0 } - + let m1 = if n1 > 0.0 { sum1 / n1 } else { 0.0 } let m2 = if n2 > 0.0 { sum2 / n2 } else { 0.0 } - + let disp = if i < disp_result.shrunken_dispersions.length() { disp_result.shrunken_dispersions[i] } else { 0.1 } - + // Wald statistic let se = (disp * (m1 / n1 + m2 / n2)).sqrt() - let wald = if se > 0.0000000001 { - (m2 - m1) / se - } else { - 0.0 - } - + let wald = if se > 0.0000000001 { (m2 - m1) / se } else { 0.0 } + // Two-sided p-value approximation let p_val = if wald.abs() < 37.0 { 2.0 * (1.0 - dss_normal_cdf(wald.abs())) } else { 0.0 } - + mean1_arr.push(m1) mean2_arr.push(m2) disp_arr.push(disp) wald_stat_arr.push(wald) p_values_arr.push(p_val) gene_ids_arr.push(counts_data.gene_ids[i]) - + i = i + 1 } - + // Multiple testing correction (Benjamini-Hochberg) let adj_p_values = dss_benjamini_hochberg(p_values_arr) - + // Determine significance (FDR < 0.05) let significant : Array[Bool] = Array::new() let mut k = 0 @@ -519,19 +643,22 @@ pub fn dss_deseq(counts_data : DSSCountData, disp_result : DSSDispResult) -> DSS significant.push(adj_p_values[k] < 0.05) k = k + 1 } - - DSSDEResult::new(gene_ids_arr, mean1_arr, mean2_arr, disp_arr, wald_stat_arr, - p_values_arr, adj_p_values, significant) + + DSSDEResult::new( + gene_ids_arr, mean1_arr, mean2_arr, disp_arr, wald_stat_arr, p_values_arr, adj_p_values, + significant, + ) } +///| /// Perform differential methylation analysis pub fn dss_dml(methyl_data : DSSMethylData) -> DSSDMResult { let n_sites = methyl_data.dss_n_cpgs() let n_samples = methyl_data.dss_n_samples() - + let group1_idx : Array[Int] = Array::new() let group2_idx : Array[Int] = Array::new() - + let mut j = 0 while j < n_samples { if methyl_data.groups[j] == "group1" { @@ -541,24 +668,24 @@ pub fn dss_dml(methyl_data : DSSMethylData) -> DSSDMResult { } j = j + 1 } - + let n1 = group1_idx.length().to_double() let n2 = group2_idx.length().to_double() - + let meth_mean1_arr : Array[Double] = Array::new() let meth_mean2_arr : Array[Double] = Array::new() let delta_meth_arr : Array[Double] = Array::new() let stats_arr : Array[Double] = Array::new() let p_values_arr : Array[Double] = Array::new() let cpg_ids_arr : Array[String] = Array::new() - + let mut i = 0 while i < n_sites { let mut sum1 = 0.0 let mut total1 = 0.0 let mut sum2 = 0.0 let mut total2 = 0.0 - + let mut k = 0 while k < group1_idx.length() { let idx = group1_idx[k] @@ -566,7 +693,7 @@ pub fn dss_dml(methyl_data : DSSMethylData) -> DSSDMResult { total1 = total1 + methyl_data.total_counts[i][idx] k = k + 1 } - + k = 0 while k < group2_idx.length() { let idx = group2_idx[k] @@ -574,51 +701,59 @@ pub fn dss_dml(methyl_data : DSSMethylData) -> DSSDMResult { total2 = total2 + methyl_data.total_counts[i][idx] k = k + 1 } - + let m1 = if total1 > 0.0 { sum1 / total1 } else { 0.0 } let m2 = if total2 > 0.0 { sum2 / total2 } else { 0.0 } let delta = m2 - m1 - + // Test statistic (approximation) let se = if total1 + total2 > 0.0 { (m1 * (1.0 - m1) / total1 + m2 * (1.0 - m2) / total2).sqrt() } else { 1.0 } - + let stat = if se > 0.0000000001 { delta / se } else { 0.0 } let p_val = if stat.abs() < 37.0 { 2.0 * (1.0 - dss_normal_cdf(stat.abs())) } else { 0.0 } - + meth_mean1_arr.push(m1) meth_mean2_arr.push(m2) delta_meth_arr.push(delta) stats_arr.push(stat) p_values_arr.push(p_val) cpg_ids_arr.push(methyl_data.cpg_ids[i]) - + i = i + 1 } - + // Multiple testing correction let adj_p_values = dss_benjamini_hochberg(p_values_arr) - + let significant : Array[Bool] = Array::new() let mut s = 0 while s < n_sites { significant.push(adj_p_values[s] < 0.05) s = s + 1 } - - DSSDMResult::new(cpg_ids_arr, meth_mean1_arr, meth_mean2_arr, delta_meth_arr, - stats_arr, p_values_arr, adj_p_values, significant) + + DSSDMResult::new( + cpg_ids_arr, meth_mean1_arr, meth_mean2_arr, delta_meth_arr, stats_arr, p_values_arr, + adj_p_values, significant, + ) } +///| /// Detect differentially methylated regions -pub fn dss_dmr(methyl_data : DSSMethylData, dm_result : DSSDMResult, min_cpgs : Int, min_delta : Double) -> DSSDMRResult { +pub fn dss_dmr( + methyl_data : DSSMethylData, + dm_result : DSSDMResult, + min_cpgs : Int, + min_delta : Double, +) -> DSSDMRResult { let dmr_ids : Array[String] = Array::new() let chrom_arr : Array[String] = Array::new() let start_arr : Array[Int] = Array::new() @@ -627,26 +762,43 @@ pub fn dss_dmr(methyl_data : DSSMethylData, dm_result : DSSDMResult, min_cpgs : let mean_delta_arr : Array[Double] = Array::new() let stats_arr : Array[Double] = Array::new() let p_values_arr : Array[Double] = Array::new() - + let mut i = 0 while i < dm_result.cpg_ids.length() { if dm_result.significant[i] && dm_result.delta_meth[i].abs() >= min_delta { // Start of potential DMR - let current_chrom = if i < methyl_data.chrom.length() { methyl_data.chrom[i] } else { "chr1" } - let current_pos = if i < methyl_data.pos.length() { methyl_data.pos[i] } else { i } - + let current_chrom = if i < methyl_data.chrom.length() { + methyl_data.chrom[i] + } else { + "chr1" + } + let current_pos = if i < methyl_data.pos.length() { + methyl_data.pos[i] + } else { + i + } + let mut j = i + 1 let mut cpgs = 1 let mut total_delta = dm_result.delta_meth[i] let mut total_stat = dm_result.stats[i] let max_gap = 10000 let mut last_pos = current_pos - + while j < dm_result.cpg_ids.length() && j < i + 100 { - if dm_result.significant[j] && dm_result.delta_meth[j].abs() >= min_delta { - let next_chrom = if j < methyl_data.chrom.length() { methyl_data.chrom[j] } else { current_chrom } - let next_pos = if j < methyl_data.pos.length() { methyl_data.pos[j] } else { last_pos + 100 } - + if dm_result.significant[j] && + dm_result.delta_meth[j].abs() >= min_delta { + let next_chrom = if j < methyl_data.chrom.length() { + methyl_data.chrom[j] + } else { + current_chrom + } + let next_pos = if j < methyl_data.pos.length() { + methyl_data.pos[j] + } else { + last_pos + 100 + } + if next_chrom == current_chrom && next_pos - last_pos <= max_gap { cpgs = cpgs + 1 total_delta = total_delta + dm_result.delta_meth[j] @@ -660,7 +812,7 @@ pub fn dss_dmr(methyl_data : DSSMethylData, dm_result : DSSDMResult, min_cpgs : break } } - + if cpgs >= min_cpgs { let dmr_id = "DMR_" + (dmr_ids.length() + 1).to_string() dmr_ids.push(dmr_id) @@ -672,46 +824,59 @@ pub fn dss_dmr(methyl_data : DSSMethylData, dm_result : DSSDMResult, min_cpgs : stats_arr.push(total_stat) p_values_arr.push(0.0) } - + i = j } else { i = i + 1 } } - - DSSDMRResult::new(dmr_ids, chrom_arr, start_arr, end_arr, n_cpgs_arr, - mean_delta_arr, stats_arr, p_values_arr) + + DSSDMRResult::new( + dmr_ids, chrom_arr, start_arr, end_arr, n_cpgs_arr, mean_delta_arr, stats_arr, + p_values_arr, + ) } +///| /// Standard normal CDF approximation (renamed to avoid conflict with ballgown) fn dss_normal_cdf(x : Double) -> Double { // Abramowitz and Stegun approximation let t = 1.0 / (1.0 + 0.2316419 * x.abs()) let d = 0.3989422804014327 * @math.exp(-x * x / 2.0) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))) - if x > 0.0 { 1.0 - p } else { p } + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))) + ) + if x > 0.0 { + 1.0 - p + } else { + p + } } +///| /// Benjamini-Hochberg multiple testing correction (renamed to avoid conflict with ballgown) fn dss_benjamini_hochberg(p_values : Array[Double]) -> Array[Double] { let n = p_values.length() let result = Array::make(n, 1.0) - + if n == 0 { return result } - + // Create index array and sort by p-value let indices : Array[Int] = Array::new() let sorted_pvals : Array[Double] = Array::new() - + let mut i = 0 while i < n { indices.push(i) sorted_pvals.push(p_values[i]) i = i + 1 } - + // Simple bubble sort let mut j = 0 while j < n { @@ -721,7 +886,7 @@ fn dss_benjamini_hochberg(p_values : Array[Double]) -> Array[Double] { let tmp_p = sorted_pvals[j] sorted_pvals[j] = sorted_pvals[k] sorted_pvals[k] = tmp_p - + let tmp_i = indices[j] indices[j] = indices[k] indices[k] = tmp_i @@ -730,11 +895,11 @@ fn dss_benjamini_hochberg(p_values : Array[Double]) -> Array[Double] { } j = j + 1 } - + // Apply BH correction let adj = Array::make(n, 1.0) let mut last = 1.0 - + i = n - 1 while i >= 0 { let rank = (i + 1).to_double() @@ -743,17 +908,18 @@ fn dss_benjamini_hochberg(p_values : Array[Double]) -> Array[Double] { adj[i] = if last <= 1.0 { last } else { 1.0 } i = i - 1 } - + // Map back to original order i = 0 while i < n { result[indices[i]] = adj[i] i = i + 1 } - + result } +///| /// Create example count data for testing pub fn dss_create_example_counts() -> DSSCountData { let gene_ids = ["GeneA", "GeneB", "GeneC", "GeneD", "GeneE"] @@ -766,10 +932,11 @@ pub fn dss_create_example_counts() -> DSSCountData { ] let groups = ["group1", "group1", "group1", "group2", "group2", "group2"] let lib_sizes = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0] - + DSSCountData::new(gene_ids, counts, groups, lib_sizes) } +///| /// Create example methylation data for testing pub fn dss_create_example_methylation() -> DSSMethylData { let cpg_ids = ["CpG1", "CpG2", "CpG3", "CpG4", "CpG5"] @@ -790,6 +957,6 @@ pub fn dss_create_example_methylation() -> DSSMethylData { [25.0, 26.0, 24.0, 25.0, 24.0, 26.0], ] let groups = ["group1", "group1", "group1", "group2", "group2", "group2"] - + DSSMethylData::new(cpg_ids, chrom, pos, meth_counts, total_counts, groups) } diff --git a/src/dssp.mbt b/src/dssp.mbt index de1ea351..303a6932 100644 --- a/src/dssp.mbt +++ b/src/dssp.mbt @@ -25,7 +25,16 @@ pub fn DSSPRecord::new( phi : Double, psi : Double, ) -> DSSPRecord { - DSSPRecord::{ chain_id, residue_number, insertion_code, amino_acid, secondary_structure, solvent_accessibility, phi, psi } + DSSPRecord::{ + chain_id, + residue_number, + insertion_code, + amino_acid, + secondary_structure, + solvent_accessibility, + phi, + psi, + } } ///| @@ -35,16 +44,16 @@ pub struct DSSPResult { ///| pub fn DSSPResult::new(records : Array[DSSPRecord]) -> DSSPResult { - DSSPResult::{ records } + DSSPResult::{ records, } } ///| pub fn parse_dssp(data : String) -> DSSPResult { let records : Array[DSSPRecord] = Array::new() - + let lines = split_by_char(data, '\n'.to_int()) let mut i = 0 - + while i < lines.length() { let line = lines[i] if line.length() >= 14 && char_at(line, 0) != "#" { @@ -56,27 +65,29 @@ pub fn parse_dssp(data : String) -> DSSPResult { let acc_str = substring(line, 34, 3) let phi_str = substring(line, 104, 6) let psi_str = substring(line, 111, 6) - + let residue_number = parse_int(trim(resnum_str)) let solvent_accessibility = parse_int(trim(acc_str)) let phi = parse_double(trim(phi_str)).unwrap_or(0.0) let psi = parse_double(trim(psi_str)).unwrap_or(0.0) - - records.push(DSSPRecord::new( - chain_id, residue_number, insertion_code, - amino_acid, ss, solvent_accessibility, phi, psi, - )) + + records.push( + DSSPRecord::new( + chain_id, residue_number, insertion_code, amino_acid, ss, solvent_accessibility, + phi, psi, + ), + ) } i = i + 1 } - + DSSPResult::new(records) } ///| pub fn predict_secondary_structure(sequence : String) -> String { let mut result = "" - + let mut i = 0 while i < sequence.length() { let aa = char_at(sequence, i) @@ -84,7 +95,7 @@ pub fn predict_secondary_structure(sequence : String) -> String { result = result + ss i = i + 1 } - + result } @@ -93,7 +104,7 @@ fn classify_secondary_structure(amino_acid : String) -> String { let helix_formers = ["E", "D", "L", "M", "K", "R", "H"] let sheet_formers = ["V", "I", "Y", "F", "W", "T"] let coil_formers = ["G", "A", "S", "P", "N", "C", "Q"] - + let mut i = 0 while i < helix_formers.length() { if helix_formers[i] == amino_acid { @@ -101,7 +112,7 @@ fn classify_secondary_structure(amino_acid : String) -> String { } i = i + 1 } - + i = 0 while i < sheet_formers.length() { if sheet_formers[i] == amino_acid { @@ -109,7 +120,7 @@ fn classify_secondary_structure(amino_acid : String) -> String { } i = i + 1 } - + i = 0 while i < coil_formers.length() { if coil_formers[i] == amino_acid { @@ -117,7 +128,7 @@ fn classify_secondary_structure(amino_acid : String) -> String { } i = i + 1 } - + "-" } @@ -127,18 +138,18 @@ pub fn calculate_solvent_accessibility( structure : String, ) -> Array[Int] { let result : Array[Int] = Array::new() - + let mut i = 0 while i < sequence.length() { let aa = char_at(sequence, i) let ss = if i < structure.length() { char_at(structure, i) } else { "-" } - + let accessibility = estimate_accessibility(aa, ss, i, sequence.length()) result.push(accessibility) - + i = i + 1 } - + result } @@ -149,17 +160,36 @@ fn estimate_accessibility( position : Int, total_length : Int, ) -> Int { - let max_accessibility = Map([ - ("A", 129), ("R", 274), ("N", 195), ("D", 193), ("C", 167), - ("Q", 225), ("E", 223), ("G", 104), ("H", 224), ("I", 197), - ("L", 201), ("K", 236), ("M", 224), ("F", 240), ("P", 159), - ("S", 155), ("T", 172), ("W", 285), ("Y", 263), ("V", 174), - ], capacity=20) - + let max_accessibility = Map( + [ + ("A", 129), + ("R", 274), + ("N", 195), + ("D", 193), + ("C", 167), + ("Q", 225), + ("E", 223), + ("G", 104), + ("H", 224), + ("I", 197), + ("L", 201), + ("K", 236), + ("M", 224), + ("F", 240), + ("P", 159), + ("S", 155), + ("T", 172), + ("W", 285), + ("Y", 263), + ("V", 174), + ], + capacity=20, + ) + let max_acc = max_accessibility.get(amino_acid).unwrap_or(150) - + let mut accessibility = max_acc - + if secondary_structure == "H" { accessibility = (max_acc.to_double() * 0.3).to_int() } else if secondary_structure == "E" { @@ -167,11 +197,11 @@ fn estimate_accessibility( } else { accessibility = (max_acc.to_double() * 0.6).to_int() } - + if position < 5 || position > total_length - 5 { accessibility = (accessibility.to_double() * 0.5).to_int() } - + accessibility } @@ -180,22 +210,34 @@ pub fn calculate_ramachandran_plot( records : Array[DSSPRecord], ) -> Array[(Double, Double)] { let result : Array[(Double, Double)] = Array::new() - + let mut i = 0 while i < records.length() { result.push((records[i].phi, records[i].psi)) i = i + 1 } - + result } ///| -pub fn analyze_structure_composition(records : Array[DSSPRecord]) -> Map[String, Int] { - let composition : Map[String, Int] = Map([ - ("H", 0), ("B", 0), ("E", 0), ("G", 0), ("I", 0), ("T", 0), ("S", 0), ("-", 0), - ], capacity=8) - +pub fn analyze_structure_composition( + records : Array[DSSPRecord], +) -> Map[String, Int] { + let composition : Map[String, Int] = Map( + [ + ("H", 0), + ("B", 0), + ("E", 0), + ("G", 0), + ("I", 0), + ("T", 0), + ("S", 0), + ("-", 0), + ], + capacity=8, + ) + let mut i = 0 while i < records.length() { let ss = records[i].secondary_structure @@ -203,14 +245,14 @@ pub fn analyze_structure_composition(records : Array[DSSPRecord]) -> Map[String, composition.set(ss, count + 1) i = i + 1 } - + composition } ///| pub fn create_example_dssp_data() -> DSSPResult { let records : Array[DSSPRecord] = Array::new() - + records.push(DSSPRecord::new("A", 1, "", "M", "-", 100, -60.0, -40.0)) records.push(DSSPRecord::new("A", 2, "", "S", "H", 50, -57.0, -47.0)) records.push(DSSPRecord::new("A", 3, "", "G", "H", 40, -59.0, -47.0)) @@ -219,6 +261,6 @@ pub fn create_example_dssp_data() -> DSSPResult { records.push(DSSPRecord::new("A", 6, "", "V", "E", 30, -139.0, 135.0)) records.push(DSSPRecord::new("A", 7, "", "A", "E", 25, -139.0, 135.0)) records.push(DSSPRecord::new("A", 8, "", "L", "-", 60, -60.0, -40.0)) - + DSSPResult::new(records) -} \ No newline at end of file +} diff --git a/src/edaseq.mbt b/src/edaseq.mbt index b76af3b3..fe80e8cf 100644 --- a/src/edaseq.mbt +++ b/src/edaseq.mbt @@ -3,6 +3,7 @@ /// Provides RNA-seq exploratory data analysis with GC-content and /// gene length normalization, plus between/within-lane normalization. +///| /// Normalization type pub enum EDASeqNormType { /// Within-lane normalization (GC content or gene length) @@ -13,6 +14,7 @@ pub enum EDASeqNormType { Full } +///| /// Within-lane normalization method pub enum EDASeqWithinMethod { /// GC content normalization @@ -23,6 +25,7 @@ pub enum EDASeqWithinMethod { Both } +///| /// Between-lane normalization method pub enum EDASeqBetweenMethod { /// Median ratio normalization @@ -33,6 +36,7 @@ pub enum EDASeqBetweenMethod { Library } +///| /// Gene annotation for normalization pub struct EDASeqGeneAnno { /// Gene ID @@ -45,6 +49,7 @@ pub struct EDASeqGeneAnno { effective_length : Double } +///| /// Expression set for EDASeq pub struct EDASeqDataSet { /// Gene IDs @@ -59,6 +64,7 @@ pub struct EDASeqDataSet { lib_sizes : Array[Double] } +///| /// Result of within-lane normalization pub struct EDASeqWithinResult { /// Normalized counts @@ -71,6 +77,7 @@ pub struct EDASeqWithinResult { norm_method : EDASeqWithinMethod } +///| /// A loess fit result pub struct EDASeqFit { /// Smoothing span @@ -83,6 +90,7 @@ pub struct EDASeqFit { converged : Bool } +///| /// Result of between-lane normalization pub struct EDASeqBetweenResult { /// Normalized counts @@ -93,6 +101,7 @@ pub struct EDASeqBetweenResult { norm_method : EDASeqBetweenMethod } +///| /// Complete EDASeq normalization result pub struct EDASeqResult { /// Within-lane normalized counts (if applied) @@ -109,6 +118,7 @@ pub struct EDASeqResult { sample_ids : Array[String] } +///| /// Parameters for EDASeq normalization pub struct EDASeqParams { /// Normalization type @@ -125,6 +135,7 @@ pub struct EDASeqParams { log_transform : Bool } +///| /// Create default parameters pub fn EDASeqParams::new() -> EDASeqParams { EDASeqParams::{ @@ -133,23 +144,24 @@ pub fn EDASeqParams::new() -> EDASeqParams { between_method: EDASeqBetweenMethod::MedianRatio, loess_span: 0.75, min_count: 0.5, - log_transform: true + log_transform: true, } } // ===== Gene annotation ===== +///| /// Create a new gene annotation -pub fn EDASeqGeneAnno::new(gene_id : String, gc_content : Double, length : Double) -> EDASeqGeneAnno { +pub fn EDASeqGeneAnno::new( + gene_id : String, + gc_content : Double, + length : Double, +) -> EDASeqGeneAnno { let eff_len = if length > 200.0 { length } else { 200.0 } - EDASeqGeneAnno::{ - gene_id, - gc_content, - length, - effective_length: eff_len - } + EDASeqGeneAnno::{ gene_id, gc_content, length, effective_length: eff_len } } +///| /// Compute RPKM scaling factor (1000/gene_length) pub fn EDASeqGeneAnno::eda_rpkm_scale(self : EDASeqGeneAnno) -> Double { if self.effective_length > 0.0 { @@ -161,12 +173,13 @@ pub fn EDASeqGeneAnno::eda_rpkm_scale(self : EDASeqGeneAnno) -> Double { // ===== DataSet methods ===== +///| /// Create a new EDASeqDataSet pub fn EDASeqDataSet::new( gene_ids : Array[String], sample_ids : Array[String], counts : Array[Array[Double]], - annotations : Array[EDASeqGeneAnno] + annotations : Array[EDASeqGeneAnno], ) -> EDASeqDataSet { let n_samples = sample_ids.length() let lib_sizes : Array[Double] = Array::new() @@ -181,32 +194,36 @@ pub fn EDASeqDataSet::new( lib_sizes.push(sum) s = s + 1 } - EDASeqDataSet::{ - gene_ids, - sample_ids, - counts, - annotations, - lib_sizes - } + EDASeqDataSet::{ gene_ids, sample_ids, counts, annotations, lib_sizes } } +///| /// Get number of genes pub fn EDASeqDataSet::eda_n_genes(self : EDASeqDataSet) -> Int { self.gene_ids.length() } +///| /// Get number of samples pub fn EDASeqDataSet::eda_n_samples(self : EDASeqDataSet) -> Int { self.sample_ids.length() } +///| /// Get a gene's counts across samples -pub fn EDASeqDataSet::eda_gene_counts(self : EDASeqDataSet, gene_idx : Int) -> Array[Double] { +pub fn EDASeqDataSet::eda_gene_counts( + self : EDASeqDataSet, + gene_idx : Int, +) -> Array[Double] { self.counts[gene_idx].copy() } +///| /// Get a sample's counts across genes -pub fn EDASeqDataSet::eda_sample_counts(self : EDASeqDataSet, sample_idx : Int) -> Array[Double] { +pub fn EDASeqDataSet::eda_sample_counts( + self : EDASeqDataSet, + sample_idx : Int, +) -> Array[Double] { let result : Array[Double] = Array::new() let mut i = 0 while i < self.counts.length() { @@ -220,7 +237,10 @@ pub fn EDASeqDataSet::eda_sample_counts(self : EDASeqDataSet, sample_idx : Int) ///| /// Compute GC content-based within-lane normalization. -pub fn eda_normalize_within_lane(data : EDASeqDataSet, params : EDASeqParams) -> EDASeqWithinResult { +pub fn eda_normalize_within_lane( + data : EDASeqDataSet, + params : EDASeqParams, +) -> EDASeqWithinResult { let n_genes = data.gene_ids.length() let n_samples = data.sample_ids.length() let gc_fits : Array[EDASeqFit] = Array::new() @@ -235,7 +255,11 @@ pub fn eda_normalize_within_lane(data : EDASeqDataSet, params : EDASeqParams) -> let length_values : Array[Double] = Array::new() let mut g = 0 while g < n_genes { - let c = if sample_counts[g] > 0.0 { sample_counts[g] } else { params.min_count } + let c = if sample_counts[g] > 0.0 { + sample_counts[g] + } else { + params.min_count + } log_counts.push(@math.ln(c)) gc_values.push(data.annotations[g].gc_content) length_values.push(data.annotations[g].effective_length) @@ -243,7 +267,11 @@ pub fn eda_normalize_within_lane(data : EDASeqDataSet, params : EDASeqParams) -> } // Apply within-lane normalization let (norm_sample_log, gc_fit, len_fit) = eda_apply_within_norm( - log_counts, gc_values, length_values, data.lib_sizes[s], params + log_counts, + gc_values, + length_values, + data.lib_sizes[s], + params, ) gc_fits.push(gc_fit) length_fits.push(len_fit) @@ -275,7 +303,7 @@ pub fn eda_normalize_within_lane(data : EDASeqDataSet, params : EDASeqParams) -> norm_counts: result, gc_fits, length_fits, - norm_method: params.within_method + norm_method: params.within_method, } } @@ -286,20 +314,20 @@ fn eda_apply_within_norm( gc_values : Array[Double], length_values : Array[Double], lib_size : Double, - params : EDASeqParams + params : EDASeqParams, ) -> (Array[Double], EDASeqFit, EDASeqFit) { let n = log_counts.length() let gc_fit_default = EDASeqFit::{ span: params.loess_span, fitted: Array::new(), residuals: Array::new(), - converged: false + converged: false, } let len_fit_default = EDASeqFit::{ span: params.loess_span, fitted: Array::new(), residuals: Array::new(), - converged: false + converged: false, } let lib_adj = if lib_size > 0.0 { lib_size } else { 1.0 } let log_lib = @math.ln(lib_adj) @@ -311,19 +339,36 @@ fn eda_apply_within_norm( i = i + 1 } // Apply GC correction - let (gc_corrected, gc_fit) = eda_gc_correction(base_norm, gc_values, params.loess_span) + let (gc_corrected, gc_fit) = eda_gc_correction( + base_norm, + gc_values, + params.loess_span, + ) // Apply length correction - let (final_norm, len_fit) = eda_length_correction(gc_corrected, length_values, params.loess_span) + let (final_norm, len_fit) = eda_length_correction( + gc_corrected, + length_values, + params.loess_span, + ) (final_norm, gc_fit, len_fit) } ///| /// GC content-based loess correction. -fn eda_gc_correction(log_counts : Array[Double], gc_values : Array[Double], span : Double) -> (Array[Double], EDASeqFit) { +fn eda_gc_correction( + log_counts : Array[Double], + gc_values : Array[Double], + span : Double, +) -> (Array[Double], EDASeqFit) { let n = log_counts.length() if n < 4 { let result = log_counts.copy() - let fit = EDASeqFit::{ span, fitted: Array::new(), residuals: Array::new(), converged: false } + let fit = EDASeqFit::{ + span, + fitted: Array::new(), + residuals: Array::new(), + converged: false, + } return (result, fit) } // Apply loess smoothing @@ -351,11 +396,20 @@ fn eda_gc_correction(log_counts : Array[Double], gc_values : Array[Double], span ///| /// Gene length-based loess correction. -fn eda_length_correction(log_counts : Array[Double], length_values : Array[Double], span : Double) -> (Array[Double], EDASeqFit) { +fn eda_length_correction( + log_counts : Array[Double], + length_values : Array[Double], + span : Double, +) -> (Array[Double], EDASeqFit) { let n = log_counts.length() if n < 4 { let result = log_counts.copy() - let fit = EDASeqFit::{ span, fitted: Array::new(), residuals: Array::new(), converged: false } + let fit = EDASeqFit::{ + span, + fitted: Array::new(), + residuals: Array::new(), + converged: false, + } return (result, fit) } // Use log-length for smoothing @@ -388,9 +442,15 @@ fn eda_length_correction(log_counts : Array[Double], length_values : Array[Doubl ///| /// Simple loess smoothing (locally weighted regression). -fn eda_loess_smooth(x : Array[Double], y : Array[Double], span : Double) -> Array[Double] { +fn eda_loess_smooth( + x : Array[Double], + y : Array[Double], + span : Double, +) -> Array[Double] { let n = x.length() - if n < 3 { return y.copy() } + if n < 3 { + return y.copy() + } let result : Array[Double] = Array::new() let half_span = span * 0.5 let mut i = 0 @@ -448,7 +508,10 @@ fn eda_loess_smooth(x : Array[Double], y : Array[Double], span : Double) -> Arra ///| /// Compute between-lane normalization. -pub fn eda_normalize_between_lane(data : EDASeqDataSet, params : EDASeqParams) -> EDASeqBetweenResult { +pub fn eda_normalize_between_lane( + data : EDASeqDataSet, + params : EDASeqParams, +) -> EDASeqBetweenResult { let n_genes = data.gene_ids.length() let n_samples = data.sample_ids.length() // Compute size factors @@ -470,17 +533,22 @@ pub fn eda_normalize_between_lane(data : EDASeqDataSet, params : EDASeqParams) - EDASeqBetweenResult::{ norm_counts, size_factors, - norm_method: params.between_method + norm_method: params.between_method, } } ///| /// Compute size factors for between-lane normalization. -fn eda_compute_size_factors(counts : Array[Array[Double]], params : EDASeqParams) -> Array[Double] { +fn eda_compute_size_factors( + counts : Array[Array[Double]], + params : EDASeqParams, +) -> Array[Double] { let n_genes = counts.length() let n_samples = if n_genes > 0 { counts[0].length() } else { 0 } let size_factors : Array[Double] = Array::new() - if n_samples == 0 { return size_factors } + if n_samples == 0 { + return size_factors + } match params.between_method { EDASeqBetweenMethod::MedianRatio => { @@ -506,7 +574,11 @@ fn eda_compute_size_factors(counts : Array[Array[Double]], params : EDASeqParams let ratios : Array[Double] = Array::new() let mut g2 = 0 while g2 < n_genes { - let c = if counts[g2][s2] > 0.0 { counts[g2][s2] } else { params.min_count } + let c = if counts[g2][s2] > 0.0 { + counts[g2][s2] + } else { + params.min_count + } if geo_means[g2] > 0.0 { ratios.push(c / geo_means[g2]) } @@ -556,18 +628,28 @@ fn eda_compute_size_factors(counts : Array[Array[Double]], params : EDASeqParams size_factors } +///| /// Compute median fn eda_median(arr : Array[Double]) -> Double { let n = arr.length() - if n == 0 { return 1.0 } + if n == 0 { + return 1.0 + } let sorted = eda_sort(arr) - if n % 2 == 1 { sorted[n / 2] } else { (sorted[n / 2 - 1] + sorted[n / 2]) / 2.0 } + if n % 2 == 1 { + sorted[n / 2] + } else { + (sorted[n / 2 - 1] + sorted[n / 2]) / 2.0 + } } +///| /// Compute mean fn eda_mean(arr : Array[Double]) -> Double { let n = arr.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut sum = 0.0 let mut i = 0 while i < n { @@ -577,6 +659,7 @@ fn eda_mean(arr : Array[Double]) -> Double { sum / n.to_double() } +///| /// Sort array fn eda_sort(arr : Array[Double]) -> Array[Double] { let result = arr.copy() @@ -614,7 +697,7 @@ pub fn eda_run(data : EDASeqDataSet, params : EDASeqParams) -> EDASeqResult { norm_counts: within.norm_counts, norm_type: params.norm_type, gene_ids: data.gene_ids, - sample_ids: data.sample_ids + sample_ids: data.sample_ids, } } EDASeqNormType::BetweenLane => { @@ -625,7 +708,7 @@ pub fn eda_run(data : EDASeqDataSet, params : EDASeqParams) -> EDASeqResult { norm_counts: between.norm_counts, norm_type: params.norm_type, gene_ids: data.gene_ids, - sample_ids: data.sample_ids + sample_ids: data.sample_ids, } } EDASeqNormType::Full => { @@ -635,7 +718,7 @@ pub fn eda_run(data : EDASeqDataSet, params : EDASeqParams) -> EDASeqResult { data.gene_ids, data.sample_ids, within.norm_counts, - data.annotations + data.annotations, ) let between = eda_normalize_between_lane(within_data, params) EDASeqResult::{ @@ -644,7 +727,7 @@ pub fn eda_run(data : EDASeqDataSet, params : EDASeqParams) -> EDASeqResult { norm_counts: between.norm_counts, norm_type: params.norm_type, gene_ids: data.gene_ids, - sample_ids: data.sample_ids + sample_ids: data.sample_ids, } } } @@ -654,7 +737,11 @@ pub fn eda_run(data : EDASeqDataSet, params : EDASeqParams) -> EDASeqResult { ///| /// Compute RPKM (Reads Per Kilobase per Million) normalization. -pub fn eda_rpkm(counts : Array[Array[Double]], annotations : Array[EDASeqGeneAnno], lib_sizes : Array[Double]) -> Array[Array[Double]] { +pub fn eda_rpkm( + counts : Array[Array[Double]], + annotations : Array[EDASeqGeneAnno], + lib_sizes : Array[Double], +) -> Array[Array[Double]] { let n_genes = counts.length() let n_samples = if n_genes > 0 { counts[0].length() } else { 0 } let rpkm : Array[Array[Double]] = Array::new() @@ -665,7 +752,11 @@ pub fn eda_rpkm(counts : Array[Array[Double]], annotations : Array[EDASeqGeneAnn let scale = anno.eda_rpkm_scale() let mut s = 0 while s < n_samples { - let lib_scale = if lib_sizes[s] > 0.0 { 1.0e6 / lib_sizes[s] } else { 0.0 } + let lib_scale = if lib_sizes[s] > 0.0 { + 1.0e6 / lib_sizes[s] + } else { + 0.0 + } let val = counts[g][s] * scale * lib_scale row.push(val) s = s + 1 @@ -678,7 +769,11 @@ pub fn eda_rpkm(counts : Array[Array[Double]], annotations : Array[EDASeqGeneAnn ///| /// Compute TPM (Transcripts Per Million) normalization. -pub fn eda_tpm(counts : Array[Array[Double]], annotations : Array[EDASeqGeneAnno], lib_sizes : Array[Double]) -> Array[Array[Double]] { +pub fn eda_tpm( + counts : Array[Array[Double]], + annotations : Array[EDASeqGeneAnno], + lib_sizes : Array[Double], +) -> Array[Array[Double]] { let n_genes = counts.length() let n_samples = if n_genes > 0 { counts[0].length() } else { 0 } let tpm : Array[Array[Double]] = Array::new() @@ -734,18 +829,31 @@ pub fn eda_tpm(counts : Array[Array[Double]], annotations : Array[EDASeqGeneAnno // ===== Accessor methods ===== +///| /// Get a normalized count -pub fn EDASeqResult::eda_get_count(self : EDASeqResult, gene_idx : Int, sample_idx : Int) -> Double { +pub fn EDASeqResult::eda_get_count( + self : EDASeqResult, + gene_idx : Int, + sample_idx : Int, +) -> Double { self.norm_counts[gene_idx][sample_idx] } +///| /// Get normalized counts for a gene -pub fn EDASeqResult::eda_get_gene(self : EDASeqResult, gene_idx : Int) -> Array[Double] { +pub fn EDASeqResult::eda_get_gene( + self : EDASeqResult, + gene_idx : Int, +) -> Array[Double] { self.norm_counts[gene_idx].copy() } +///| /// Get normalized counts for a sample -pub fn EDASeqResult::eda_get_sample(self : EDASeqResult, sample_idx : Int) -> Array[Double] { +pub fn EDASeqResult::eda_get_sample( + self : EDASeqResult, + sample_idx : Int, +) -> Array[Double] { let result : Array[Double] = Array::new() let mut i = 0 while i < self.norm_counts.length() { @@ -755,22 +863,29 @@ pub fn EDASeqResult::eda_get_sample(self : EDASeqResult, sample_idx : Int) -> Ar result } +///| /// Get number of genes pub fn EDASeqResult::eda_n_genes(self : EDASeqResult) -> Int { self.gene_ids.length() } +///| /// Get number of samples pub fn EDASeqResult::eda_n_samples(self : EDASeqResult) -> Int { self.sample_ids.length() } +///| /// Get gene ID pub fn EDASeqResult::eda_get_gene_id(self : EDASeqResult, idx : Int) -> String { self.gene_ids[idx] } +///| /// Get sample ID -pub fn EDASeqResult::eda_get_sample_id(self : EDASeqResult, idx : Int) -> String { +pub fn EDASeqResult::eda_get_sample_id( + self : EDASeqResult, + idx : Int, +) -> String { self.sample_ids[idx] } diff --git a/src/edger_advanced.mbt b/src/edger_advanced.mbt index c3c663d5..58060489 100644 --- a/src/edger_advanced.mbt +++ b/src/edger_advanced.mbt @@ -116,8 +116,18 @@ pub fn glm_qlf_fit(dge : DGEList) -> QLFData { // QL dispersion = deviance / residual_df let residual_df = n_samples - n_coef let ql_disp = if residual_df > 0 { - let d = if deviance.is_nan() || deviance.abs() > 1.0e300 { 1.0 } else { deviance / residual_df.to_double() } - if d < 0.0 { 0.001 } else if d > 100.0 { 100.0 } else { d } + let d = if deviance.is_nan() || deviance.abs() > 1.0e300 { + 1.0 + } else { + deviance / residual_df.to_double() + } + if d < 0.0 { + 0.001 + } else if d > 100.0 { + 100.0 + } else { + d + } } else { 1.0 } @@ -154,10 +164,18 @@ pub fn glm_qlf_fit(dge : DGEList) -> QLFData { let residual_df = (n_samples - n_coef).to_double() let shrunk_ql_disp : Array[Double] = Array::new() for i = 0; i < n_genes; i = i + 1 { - let raw = if raw_ql_disp[i].is_nan() || raw_ql_disp[i].abs() > 1.0e300 { 1.0 } else { raw_ql_disp[i] } + let raw = if raw_ql_disp[i].is_nan() || raw_ql_disp[i].abs() > 1.0e300 { + 1.0 + } else { + raw_ql_disp[i] + } let shrunk = (residual_df * raw + prior_df * trend) / (residual_df + prior_df) - let shrunk_safe = if shrunk.is_nan() || shrunk.abs() > 1.0e300 { 1.0 } else { shrunk } + let shrunk_safe = if shrunk.is_nan() || shrunk.abs() > 1.0e300 { + 1.0 + } else { + shrunk + } shrunk_ql_disp.push(if shrunk_safe < 0.001 { 0.001 } else { shrunk_safe }) } @@ -192,11 +210,7 @@ fn fit_nb_glm( total = total + counts[j].to_double() } let mean_count = total / n_samples.to_double() - let init_log_mu = if mean_count > 0.0 { - @math.ln(mean_count) - } else { - 0.0 - } + let init_log_mu = if mean_count > 0.0 { @math.ln(mean_count) } else { 0.0 } for k = 0; k < n_coef; k = k + 1 { coefs[k] = if k == 0 { init_log_mu } else { 0.0 } } @@ -217,8 +231,12 @@ fn fit_nb_glm( eta = eta + design[j][k] * coefs[k] } // Cap eta to prevent overflow in exp() - if eta > 500.0 { eta = 500.0 } - if eta < -500.0 { eta = -500.0 } + if eta > 500.0 { + eta = 500.0 + } + if eta < -500.0 { + eta = -500.0 + } let exp_eta = @math.exp(eta) if exp_eta.is_nan() || exp_eta.abs() > 1.0e300 { fitted[j] = 1000000.0 @@ -277,7 +295,9 @@ fn fit_nb_glm( let y = counts[j].to_double() let mu = fitted[j] if y > 0.0 && mu > 0.0 && !mu.is_nan() && mu.abs() <= 1.0e300 { - let term = y * @math.ln(y / mu) - (y + 1.0 / nb_disp) * @math.ln((1.0 + nb_disp * y) / (1.0 + nb_disp * mu)) + let term = y * @math.ln(y / mu) - + (y + 1.0 / nb_disp) * + @math.ln((1.0 + nb_disp * y) / (1.0 + nb_disp * mu)) let contrib = 2.0 * term if contrib.is_nan() || contrib < 0.0 { // Numerical issues, use a small positive value @@ -410,17 +430,32 @@ pub fn glm_qlf_test(qlf_data : QLFData, coef? : Int = 1) -> QLFResult { if mu > 0.0 && !mu.is_nan() && mu.abs() <= 1.0e300 { let w = mu / (1.0 + ql * mu) // Design matrix: [1, x_j] - let x_coef = if coef == 0 { 1.0 } else { if qlf_data.group[j] == qlf_data.group[0] { 0.0 } else { 1.0 } } + let x_coef = if coef == 0 { + 1.0 + } else if qlf_data.group[j] == qlf_data.group[0] { + 0.0 + } else { + 1.0 + } info_coef = info_coef + w * x_coef * x_coef } } let var_beta = if info_coef > 0.0 { 1.0 / info_coef } else { 1.0 } - let f = if ql.is_nan() || ql.abs() > 1.0e300 || var_beta.is_nan() || var_beta.abs() > 1.0e300 || beta.is_nan() || beta.abs() > 1.0e300 { + let f = if ql.is_nan() || + ql.abs() > 1.0e300 || + var_beta.is_nan() || + var_beta.abs() > 1.0e300 || + beta.is_nan() || + beta.abs() > 1.0e300 { 0.0 } else if ql * var_beta > 0.0 { let f_raw = beta * beta / (ql * var_beta) - if f_raw.is_nan() || f_raw.abs() > 1.0e300 { 0.0 } else { f_raw } + if f_raw.is_nan() || f_raw.abs() > 1.0e300 { + 0.0 + } else { + f_raw + } } else { 0.0 } @@ -468,7 +503,13 @@ fn f_distribution_pvalue(f : Double, df1 : Int, df2 : Int) -> Double { let b = df1.to_double() / 2.0 let p = regularized_incomplete_beta(x, a, b) - if p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p } + if p < 0.0 { + 0.0 + } else if p > 1.0 { + 1.0 + } else { + p + } } ///| @@ -516,7 +557,10 @@ fn edger_betacf(x : Double, a : Double, b : Double) -> Double { let mut m = 1 while m <= max_iter { let m2 = 2 * m - let aa = m.to_double() * (m.to_double() - qam) * x / ((qam + m2.to_double()) * (a + m2.to_double())) + let aa = m.to_double() * + (m.to_double() - qam) * + x / + ((qam + m2.to_double()) * (a + m2.to_double())) d = 1.0 + aa * d if d.abs() < eps { d = eps @@ -528,7 +572,10 @@ fn edger_betacf(x : Double, a : Double, b : Double) -> Double { d = 1.0 / d h = h * d * c - let aa2 = -(a + m.to_double()) * (qab + m.to_double()) * x / ((a + m2.to_double()) * (qap + m2.to_double())) + let aa2 = -(a + m.to_double()) * + (qab + m.to_double()) * + x / + ((a + m2.to_double()) * (qap + m2.to_double())) d = 1.0 + aa2 * d if d.abs() < eps { d = eps @@ -580,20 +627,15 @@ fn edger_sin(x : Double) -> Double { fn log_gamma(x : Double) -> Double { if x < 0.5 { // Use reflection formula: Gamma(x)Gamma(1-x) = pi/sin(pi*x) - return @math.ln(3.141592653589793 / edger_sin(3.141592653589793 * x)) - log_gamma(1.0 - x) + return @math.ln(3.141592653589793 / edger_sin(3.141592653589793 * x)) - + log_gamma(1.0 - x) } let g = 7.0 // Lanczos coefficients let c = [ - 0.99999999999980993, - 676.5203681218851, - -1259.1392167224028, - 771.32342877765313, - -176.61502916214059, - 12.507343278686905, - -0.13857109526572012, - 9.9843695780195716e-6, + 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, + -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7, ] @@ -606,7 +648,10 @@ fn log_gamma(x : Double) -> Double { i = i + 1 } - 0.5 * @math.ln(2.0 * 3.141592653589793) + (y + 0.5) * @math.ln(tmp) - tmp + @math.ln(sum) + 0.5 * @math.ln(2.0 * 3.141592653589793) + + (y + 0.5) * @math.ln(tmp) - + tmp + + @math.ln(sum) } ///| @@ -769,16 +814,13 @@ pub fn camera( let n_unset = unset_stats.length() // Camera statistic: two-sample t-test comparing set vs unset - let pooled_var = ((n_set - 1).to_double() * set_var + - (n_unset - 1).to_double() * unset_var) / + let pooled_var = ( + (n_set - 1).to_double() * set_var + (n_unset - 1).to_double() * unset_var + ) / (n_set + n_unset - 2).to_double() let se = (pooled_var * (1.0 / n_set.to_double() + 1.0 / n_unset.to_double())).sqrt() - let t_stat = if se > 0.0 { - (set_mean - unset_mean) / se - } else { - 0.0 - } + let t_stat = if se > 0.0 { (set_mean - unset_mean) / se } else { 0.0 } // Two-sided p-value from t-distribution (approximate using normal) let p_val = 2.0 * (1.0 - edger_normal_cdf(t_stat.abs())) @@ -827,7 +869,8 @@ pub fn roast( // Z-score let n_set = set_stats.length() let z = if n_set > 0 { - (mean_stat - expected_mean) / (expected_mean * 2.0 / n_set.to_double()).sqrt() + (mean_stat - expected_mean) / + (expected_mean * 2.0 / n_set.to_double()).sqrt() } else { 0.0 } @@ -849,9 +892,18 @@ fn edger_normal_cdf(x : Double) -> Double { /// Error function (Abramowitz and Stegun approximation). fn erf(x : Double) -> Double { let t = 1.0 / (1.0 + 0.3275911 * x.abs()) - let poly = t * (0.254829592 + t * (-0.284496736 + t * (1.421413741 + t * (-1.453152027 + t * 1.061405429)))) + let poly = t * + ( + 0.254829592 + + t * + (-0.284496736 + t * (1.421413741 + t * (-1.453152027 + t * 1.061405429))) + ) let result = 1.0 - poly * @math.exp(-x * x) - if x >= 0.0 { result } else { -result } + if x >= 0.0 { + result + } else { + -result + } } ///| @@ -912,7 +964,14 @@ pub fn qlf_top_genes( let top : Array[(String, Double, Double, Double)] = Array::new() for i = 0; i < actual_n; i = i + 1 { let idx = indices[i] - top.push((result.genes[idx], result.log_fc[idx], result.f_stat[idx], result.fdr[idx])) + top.push( + ( + result.genes[idx], + result.log_fc[idx], + result.f_stat[idx], + result.fdr[idx], + ), + ) } top } diff --git a/src/embl_io.mbt b/src/embl_io.mbt index 71f9aa6d..ba9d810c 100644 --- a/src/embl_io.mbt +++ b/src/embl_io.mbt @@ -56,6 +56,7 @@ fn uppercase_string(s : String) -> String { buf.to_string() } +///| pub fn parse_embl(content : String) -> Array[SeqRecord] { let records = Array::new() let lines = content.split("\n").to_array() @@ -92,7 +93,9 @@ pub fn parse_embl(content : String) -> Array[SeqRecord] { } let mut name_end = j let semi : UInt16 = ';'.to_int().to_uint16() - while name_end < rl && id_rest.unsafe_get(name_end) != semi && id_rest.unsafe_get(name_end) != sp { + while name_end < rl && + id_rest.unsafe_get(name_end) != semi && + id_rest.unsafe_get(name_end) != sp { name_end = name_end + 1 } name = id_rest[j:name_end].to_owned() @@ -123,7 +126,8 @@ pub fn parse_embl(content : String) -> Array[SeqRecord] { } // AC line: "AC ACC1; ACC2;" - if !have_ac && lt >= 2 && + if !have_ac && + lt >= 2 && l.unsafe_get(0) == 'A'.to_int().to_uint16() && l.unsafe_get(1) == 'C'.to_int().to_uint16() && (lt == 2 || l.unsafe_get(2) == sp) { @@ -136,7 +140,9 @@ pub fn parse_embl(content : String) -> Array[SeqRecord] { } let mut ac_end = aj let semi : UInt16 = ';'.to_int().to_uint16() - while ac_end < apl && ac_part.unsafe_get(ac_end) != semi && ac_part.unsafe_get(ac_end) != sp { + while ac_end < apl && + ac_part.unsafe_get(ac_end) != semi && + ac_part.unsafe_get(ac_end) != sp { ac_end = ac_end + 1 } if ac_end > aj { @@ -173,8 +179,8 @@ pub fn parse_embl(content : String) -> Array[SeqRecord] { } if ct < 2 || !(cont.unsafe_get(0) == 'D'.to_int().to_uint16() && - cont.unsafe_get(1) == 'E'.to_int().to_uint16() && - (ct == 2 || cont.unsafe_get(2) == sp)) { + cont.unsafe_get(1) == 'E'.to_int().to_uint16() && + (ct == 2 || cont.unsafe_get(2) == sp)) { break } def_buf.write_char(' ') @@ -210,8 +216,7 @@ pub fn parse_embl(content : String) -> Array[SeqRecord] { while k < lt { let c = l.unsafe_get(k) let ci = c.to_int() - let is_base = - (ci >= 'A'.to_int() && ci <= 'Z'.to_int()) || + let is_base = (ci >= 'A'.to_int() && ci <= 'Z'.to_int()) || (ci >= 'a'.to_int() && ci <= 'z'.to_int()) || c == '-'.to_int().to_uint16() if is_base { @@ -224,8 +229,7 @@ pub fn parse_embl(content : String) -> Array[SeqRecord] { for j = 0; j < lt; j = j + 1 { let c = l.unsafe_get(j) let ci = c.to_int() - let is_base = - (ci >= 'A'.to_int() && ci <= 'Z'.to_int()) || + let is_base = (ci >= 'A'.to_int() && ci <= 'Z'.to_int()) || (ci >= 'a'.to_int() && ci <= 'z'.to_int()) || c == '-'.to_int().to_uint16() if is_base { @@ -247,12 +251,9 @@ pub fn parse_embl(content : String) -> Array[SeqRecord] { // Uppercase the sequence for consistency with GenBank parser let seq_str = seq_buf.to_string() let seq_uppercased = uppercase_string(seq_str) - records.push(SeqRecord::new( - Seq::new(seq_uppercased), - id=id, - name=name, - description=description, - )) + records.push( + SeqRecord::new(Seq::new(seq_uppercased), id~, name~, description~), + ) continue } diff --git a/src/enhanced_volcano.mbt b/src/enhanced_volcano.mbt index 924dd9b0..845c881f 100644 --- a/src/enhanced_volcano.mbt +++ b/src/enhanced_volcano.mbt @@ -192,7 +192,9 @@ pub fn VolcanoResult::get_genes(self : VolcanoResult) -> Array[VolcanoGene] { ///| /// Get significant genes only. -pub fn VolcanoResult::get_significant_genes(self : VolcanoResult) -> Array[VolcanoGene] { +pub fn VolcanoResult::get_significant_genes( + self : VolcanoResult, +) -> Array[VolcanoGene] { let sig : Array[VolcanoGene] = Array::new() let mut i = 0 while i < self.genes.length() { @@ -206,7 +208,10 @@ pub fn VolcanoResult::get_significant_genes(self : VolcanoResult) -> Array[Volca ///| /// Get top significant genes by p-value. -pub fn VolcanoResult::get_top_genes(self : VolcanoResult, n : Int) -> Array[VolcanoGene] { +pub fn VolcanoResult::get_top_genes( + self : VolcanoResult, + n : Int, +) -> Array[VolcanoGene] { let sig = self.get_significant_genes() let sorted = sig.copy() let len = sorted.length() @@ -250,7 +255,9 @@ pub fn VolcanoResult::get_up_genes(self : VolcanoResult) -> Array[VolcanoGene] { ///| /// Get down-regulated genes. -pub fn VolcanoResult::get_down_genes(self : VolcanoResult) -> Array[VolcanoGene] { +pub fn VolcanoResult::get_down_genes( + self : VolcanoResult, +) -> Array[VolcanoGene] { let down : Array[VolcanoGene] = Array::new() let mut i = 0 while i < self.genes.length() { @@ -271,7 +278,11 @@ pub fn neg_log10_p(p_val : Double) -> Double { ///| /// Format the volcano result as an ASCII visualization. -pub fn VolcanoResult::to_ascii(self : VolcanoResult, width? : Int = 60, height? : Int = 20) -> String { +pub fn VolcanoResult::to_ascii( + self : VolcanoResult, + width? : Int = 60, + height? : Int = 20, +) -> String { let w = if width < 20 { 60 } else { width } let h = if height < 10 { 20 } else { height } @@ -283,10 +294,16 @@ pub fn VolcanoResult::to_ascii(self : VolcanoResult, width? : Int = 60, height? let mut i = 0 while i < self.genes.length() { let g = self.genes[i] - if g.log2fc < min_lfc { min_lfc = g.log2fc } - if g.log2fc > max_lfc { max_lfc = g.log2fc } + if g.log2fc < min_lfc { + min_lfc = g.log2fc + } + if g.log2fc > max_lfc { + max_lfc = g.log2fc + } let nlp = neg_log10_p(g.p_val) - if nlp > max_neglog { max_neglog = nlp } + if nlp > max_neglog { + max_neglog = nlp + } i = i + 1 } @@ -315,7 +332,9 @@ pub fn VolcanoResult::to_ascii(self : VolcanoResult, width? : Int = 60, height? // Mark significant cutoffs let x_zero = ((0.0 - min_lfc) / (max_lfc - min_lfc) * (w.to_double() - 1.0)).to_int() let y_cutoff_val = neg_log10_p(self.p_cutoff) - let y_cutoff_row = h - 1 - ((y_cutoff_val / nlp_range) * (h.to_double() - 1.0)).to_int() + let y_cutoff_row = h - + 1 - + (y_cutoff_val / nlp_range * (h.to_double() - 1.0)).to_int() // Draw vertical dashed line at x=0 let mut r2 = 0 @@ -341,9 +360,11 @@ pub fn VolcanoResult::to_ascii(self : VolcanoResult, width? : Int = 60, height? let mut i2 = 0 while i2 < self.genes.length() { let g = self.genes[i2] - let x_pos = ((g.log2fc - min_lfc) / (max_lfc - min_lfc) * (w.to_double() - 1.0)).to_int() + let x_pos = ((g.log2fc - min_lfc) / + (max_lfc - min_lfc) * + (w.to_double() - 1.0)).to_int() let nlp = neg_log10_p(g.p_val) - let y_pos = h - 1 - ((nlp / nlp_range) * (h.to_double() - 1.0)).to_int() + let y_pos = h - 1 - (nlp / nlp_range * (h.to_double() - 1.0)).to_int() if x_pos >= 0 && x_pos < w && y_pos >= 0 && y_pos < h { let ch = if g.classification is VolcanoClassification::Up { @@ -370,8 +391,20 @@ pub fn VolcanoResult::to_ascii(self : VolcanoResult, width? : Int = 60, height? } result = result + self.y_label + "\n" - result = result + "Cutoffs: p < " + self.p_cutoff.to_string() + ", |log2FC| >= " + self.fc_cutoff.to_string() + "\n" - result = result + "Up: " + self.n_up.to_string() + ", Down: " + self.n_down.to_string() + ", NS: " + self.n_nonsig.to_string() + "\n" + result = result + + "Cutoffs: p < " + + self.p_cutoff.to_string() + + ", |log2FC| >= " + + self.fc_cutoff.to_string() + + "\n" + result = result + + "Up: " + + self.n_up.to_string() + + ", Down: " + + self.n_down.to_string() + + ", NS: " + + self.n_nonsig.to_string() + + "\n" result } @@ -381,7 +414,12 @@ pub fn VolcanoResult::summary(self : VolcanoResult) -> String { let mut s = "=== Volcano Plot Summary ===\n".to_string() s = s + "Title: " + self.title + "\n" s = s + "Total genes: " + self.genes.length().to_string() + "\n" - s = s + "Significant (p < " + self.p_cutoff.to_string() + "): " + (self.n_up + self.n_down).to_string() + "\n" + s = s + + "Significant (p < " + + self.p_cutoff.to_string() + + "): " + + (self.n_up + self.n_down).to_string() + + "\n" s = s + " Up-regulated: " + self.n_up.to_string() + "\n" s = s + " Down-regulated: " + self.n_down.to_string() + "\n" s = s + " Non-significant: " + self.n_nonsig.to_string() + "\n" @@ -398,8 +436,11 @@ pub fn volcano_sample(n_genes : Int) -> VolcanoResult { let pvals : Array[Double] = Array::new() // Generate deterministic sample data - let names = ["TP53", "BRCA1", "BRCA2", "MYC", "KRAS", "EGFR", "PTEN", "APC", "RB1", "VHL", - "STAT3", "AKT1", "MTOR", "JAK2", "NOTCH1", "WNT3", "CTNNB1", "SMAD4", "NFKB1", "BCL2"] + let names = [ + "TP53", "BRCA1", "BRCA2", "MYC", "KRAS", "EGFR", "PTEN", "APC", "RB1", "VHL", + "STAT3", "AKT1", "MTOR", "JAK2", "NOTCH1", "WNT3", "CTNNB1", "SMAD4", "NFKB1", + "BCL2", + ] let mut i = 0 while i < n { @@ -407,14 +448,23 @@ pub fn volcano_sample(n_genes : Int) -> VolcanoResult { ids.push(names[idx] + "_" + i.to_string()) // Create varied log2FC and p-values - let lfc_val = if i % 4 == 0 { 2.5 + (i.to_double() * 0.1) } - else if i % 4 == 1 { -2.8 - (i.to_double() * 0.1) } - else if i % 4 == 2 { 0.3 + (i.to_double() * 0.05) } - else { -0.2 - (i.to_double() * 0.03) } + let lfc_val = if i % 4 == 0 { + 2.5 + i.to_double() * 0.1 + } else if i % 4 == 1 { + -2.8 - i.to_double() * 0.1 + } else if i % 4 == 2 { + 0.3 + i.to_double() * 0.05 + } else { + -0.2 - i.to_double() * 0.03 + } - let p_val = if i % 3 == 0 { 0.001 / (1.0 + i.to_double()) } - else if i % 3 == 1 { 0.01 + (i.to_double() * 0.005) } - else { 0.05 + (i.to_double() * 0.02) } + let p_val = if i % 3 == 0 { + 0.001 / (1.0 + i.to_double()) + } else if i % 3 == 1 { + 0.01 + i.to_double() * 0.005 + } else { + 0.05 + i.to_double() * 0.02 + } lfcs.push(lfc_val) pvals.push(p_val) @@ -422,4 +472,4 @@ pub fn volcano_sample(n_genes : Int) -> VolcanoResult { } volcano_plot_default(ids, lfcs, pvals) -} \ No newline at end of file +} diff --git a/src/enriched_heatmap.mbt b/src/enriched_heatmap.mbt index e4383910..01ad82bf 100644 --- a/src/enriched_heatmap.mbt +++ b/src/enriched_heatmap.mbt @@ -222,16 +222,14 @@ fn make_windows( let w_end = w_start + config.w - 1 // For minus strand, reverse the window index. let actual_wi = if is_minus { n_up - 1 - wi } else { wi } - windows.push( - Window::{ - chr: t.chr, - start: w_start, - end_: w_end, - targetIndex: ti, - windowIndex: actual_wi, - isTarget: false, - }, - ) + windows.push(Window::{ + chr: t.chr, + start: w_start, + end_: w_end, + targetIndex: ti, + windowIndex: actual_wi, + isTarget: false, + }) wi = wi + 1 } // Target body windows (if includeTarget and k > 0). @@ -245,22 +243,16 @@ fn make_windows( let mut ki = 0 while ki < config.k { let w_start = tStart + ki * kw - let w_end = if ki == config.k - 1 { - tEnd - } else { - w_start + kw - 1 - } + let w_end = if ki == config.k - 1 { tEnd } else { w_start + kw - 1 } let actual_ki = if is_minus { config.k - 1 - ki } else { ki } - windows.push( - Window::{ - chr: t.chr, - start: w_start, - end_: w_end, - targetIndex: ti, - windowIndex: n_up + actual_ki, - isTarget: true, - }, - ) + windows.push(Window::{ + chr: t.chr, + start: w_start, + end_: w_end, + targetIndex: ti, + windowIndex: n_up + actual_ki, + isTarget: true, + }) ki = ki + 1 } } @@ -274,17 +266,16 @@ fn make_windows( } let w_end = w_start + config.w - 1 let actual_di = if is_minus { n_down - 1 - di } else { di } - let base_idx = n_up + (if config.includeTarget && config.k > 0 { config.k } else { 0 }) - windows.push( - Window::{ - chr: t.chr, - start: w_start, - end_: w_end, - targetIndex: ti, - windowIndex: base_idx + actual_di, - isTarget: false, - }, - ) + let base_idx = n_up + + (if config.includeTarget && config.k > 0 { config.k } else { 0 }) + windows.push(Window::{ + chr: t.chr, + start: w_start, + end_: w_end, + targetIndex: ti, + windowIndex: base_idx + actual_di, + isTarget: false, + }) di = di + 1 } ti = ti + 1 @@ -333,7 +324,8 @@ fn compute_window_mean( let mut si = 0 while si < signals.length() { let s = signals[si] - if s.chr == window.chr && overlaps(s.start, s.end_, window.start, window.end_) { + if s.chr == window.chr && + overlaps(s.start, s.end_, window.start, window.end_) { let ow = overlap_width(s.start, s.end_, window.start, window.end_) values.push(s.value) widths.push(ow) @@ -366,7 +358,11 @@ fn compute_window_mean( wtot = wtot + w i = i + 1 } - if wtot > 0.0 { wsum / wtot } else { background } + if wtot > 0.0 { + wsum / wtot + } else { + background + } } W0 => { // Like weighted, but denominator includes non-covered bp. @@ -381,7 +377,11 @@ fn compute_window_mean( } let non_overlap = w_width.to_double() - total_overlap.to_double() let denom = wtot + non_overlap - if denom > 0.0 { wsum / denom } else { background } + if denom > 0.0 { + wsum / denom + } else { + background + } } Coverage => { // Weighted sum divided by total window width. @@ -393,7 +393,11 @@ fn compute_window_mean( i = i + 1 } let denom = w_width.to_double() - if denom > 0.0 { wsum / denom } else { background } + if denom > 0.0 { + wsum / denom + } else { + background + } } } } @@ -594,7 +598,12 @@ pub fn normalize_to_matrix( let mut wi = 0 while wi < windows.length() { let win = windows[wi] - let mean_val = compute_window_mean(win, signals, config.meanMode, config.background) + let mean_val = compute_window_mean( + win, + signals, + config.meanMode, + config.background, + ) matrix[win.targetIndex][win.windowIndex] = mean_val wi = wi + 1 } @@ -692,13 +701,27 @@ pub fn enriched_heatmap_summary(mat : NormalizedMatrix) -> String { buf.write_string("EnrichedHeatmap Normalized Matrix Summary\n") buf.write_string(" Rows (targets): " + mat.nRows.to_string() + "\n") buf.write_string(" Columns (windows): " + mat.nCols.to_string() + "\n") - buf.write_string(" Upstream windows: " + mat.upstreamIndex.length().to_string() + "\n") - buf.write_string(" Target body windows: " + mat.targetIndex.length().to_string() + "\n") - buf.write_string(" Downstream windows: " + mat.downstreamIndex.length().to_string() + "\n") - buf.write_string(" Extension: " + mat.extend.0.to_string() + " up, " + mat.extend.1.to_string() + " down\n") + buf.write_string( + " Upstream windows: " + mat.upstreamIndex.length().to_string() + "\n", + ) + buf.write_string( + " Target body windows: " + mat.targetIndex.length().to_string() + "\n", + ) + buf.write_string( + " Downstream windows: " + mat.downstreamIndex.length().to_string() + "\n", + ) + buf.write_string( + " Extension: " + + mat.extend.0.to_string() + + " up, " + + mat.extend.1.to_string() + + " down\n", + ) buf.write_string(" Smoothed: " + mat.smooth.to_string() + "\n") buf.write_string(" Background: " + mat.background.to_string() + "\n") - buf.write_string(" Failed rows: " + mat.failedRows.length().to_string() + "\n") + buf.write_string( + " Failed rows: " + mat.failedRows.length().to_string() + "\n", + ) let profile = enrichment_profile(mat) if profile.length() > 0 { let mut minVal = profile[0] @@ -716,7 +739,15 @@ pub fn enriched_heatmap_summary(mat : NormalizedMatrix) -> String { i = i + 1 } let mean = sum / profile.length().to_double() - buf.write_string(" Enrichment profile: min=" + minVal.to_string() + " max=" + maxVal.to_string() + " mean=" + mean.to_string() + "\n") + buf.write_string( + " Enrichment profile: min=" + + minVal.to_string() + + " max=" + + maxVal.to_string() + + " mean=" + + mean.to_string() + + "\n", + ) } buf.to_string() } diff --git a/src/enrichplot.mbt b/src/enrichplot.mbt index 872f088e..58ee7829 100644 --- a/src/enrichplot.mbt +++ b/src/enrichplot.mbt @@ -1,5 +1,4 @@ ///| - pub struct EnrichTerm { term_id : String term_name : String @@ -11,21 +10,46 @@ pub struct EnrichTerm { genes : Array[String] } +///| pub struct EnrichResult { terms : Array[EnrichTerm] gene_set_name : String organism : String } -pub fn EnrichTerm::new(term_id : String, term_name : String, pvalue : Double, adjusted_pvalue : Double, - enrichment_score : Double, nes : Double, gene_count : Int, genes : Array[String]) -> EnrichTerm { - EnrichTerm::{ term_id, term_name, pvalue, adjusted_pvalue, enrichment_score, nes, gene_count, genes } +///| +pub fn EnrichTerm::new( + term_id : String, + term_name : String, + pvalue : Double, + adjusted_pvalue : Double, + enrichment_score : Double, + nes : Double, + gene_count : Int, + genes : Array[String], +) -> EnrichTerm { + EnrichTerm::{ + term_id, + term_name, + pvalue, + adjusted_pvalue, + enrichment_score, + nes, + gene_count, + genes, + } } -pub fn EnrichResult::new(terms : Array[EnrichTerm], gene_set_name : String, organism : String) -> EnrichResult { +///| +pub fn EnrichResult::new( + terms : Array[EnrichTerm], + gene_set_name : String, + organism : String, +) -> EnrichResult { EnrichResult::{ terms, gene_set_name, organism } } +///| fn copy_enrich_term_array(arr : Array[EnrichTerm]) -> Array[EnrichTerm] { let len = arr.length() let result : Array[EnrichTerm] = Array::new() @@ -37,7 +61,12 @@ fn copy_enrich_term_array(arr : Array[EnrichTerm]) -> Array[EnrichTerm] { result } -fn set_enrich_term_array(arr : Array[EnrichTerm], index : Int, value : EnrichTerm) -> Array[EnrichTerm] { +///| +fn set_enrich_term_array( + arr : Array[EnrichTerm], + index : Int, + value : EnrichTerm, +) -> Array[EnrichTerm] { let len = arr.length() let result : Array[EnrichTerm] = Array::new() let mut i = 0 @@ -52,6 +81,7 @@ fn set_enrich_term_array(arr : Array[EnrichTerm], index : Int, value : EnrichTer result } +///| fn sort_terms_by_padj(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { let len = terms.length() let mut result : Array[EnrichTerm] = Array::new() @@ -60,7 +90,7 @@ fn sort_terms_by_padj(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { result.push(terms[i]) i = i + 1 } - + let mut j = 0 while j < len { let mut k = j + 1 @@ -76,10 +106,11 @@ fn sort_terms_by_padj(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { } j = j + 1 } - + result } +///| fn sort_terms_by_pvalue(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { let len = terms.length() let mut result : Array[EnrichTerm] = Array::new() @@ -88,7 +119,7 @@ fn sort_terms_by_pvalue(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { result.push(terms[i]) i = i + 1 } - + let mut j = 0 while j < len { let mut k = j + 1 @@ -104,10 +135,11 @@ fn sort_terms_by_pvalue(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { } j = j + 1 } - + result } +///| fn sort_terms_by_es(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { let len = terms.length() let mut result : Array[EnrichTerm] = Array::new() @@ -116,7 +148,7 @@ fn sort_terms_by_es(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { result.push(terms[i]) i = i + 1 } - + let mut j = 0 while j < len { let mut k = j + 1 @@ -132,10 +164,11 @@ fn sort_terms_by_es(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { } j = j + 1 } - + result } +///| fn sort_terms_by_nes(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { let len = terms.length() let mut result : Array[EnrichTerm] = Array::new() @@ -144,7 +177,7 @@ fn sort_terms_by_nes(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { result.push(terms[i]) i = i + 1 } - + let mut j = 0 while j < len { let mut k = j + 1 @@ -160,91 +193,160 @@ fn sort_terms_by_nes(terms : Array[EnrichTerm]) -> Array[EnrichTerm] { } j = j + 1 } - + result } -pub fn bio_enrichplot_barplot(data : EnrichResult, top_n : Int, value_type : String, title : String) -> String { +///| +pub fn bio_enrichplot_barplot( + data : EnrichResult, + top_n : Int, + value_type : String, + title : String, +) -> String { let terms = copy_enrich_term_array(data.terms) - let sorted = if value_type == "padj" { sort_terms_by_padj(terms) } - else if value_type == "pvalue" { sort_terms_by_pvalue(terms) } - else if value_type == "es" { sort_terms_by_es(terms) } - else { sort_terms_by_nes(terms) } - + let sorted = if value_type == "padj" { + sort_terms_by_padj(terms) + } else if value_type == "pvalue" { + sort_terms_by_pvalue(terms) + } else if value_type == "es" { + sort_terms_by_es(terms) + } else { + sort_terms_by_nes(terms) + } + let n = if sorted.length() < top_n { sorted.length() } else { top_n } - + let mut result = "\n" + title + "\n" result = result + "=".repeat(80) + "\n" result = result + "Term\tValue\tBar\n" result = result + "-".repeat(80) + "\n" - + let mut i = 0 while i < n { let term = sorted[i] - let value = if value_type == "padj" { -@math.log10(term.adjusted_pvalue) } - else if value_type == "pvalue" { -@math.log10(term.pvalue) } - else if value_type == "es" { term.enrichment_score } - else { term.nes } - + let value = if value_type == "padj" { + -@math.log10(term.adjusted_pvalue) + } else if value_type == "pvalue" { + -@math.log10(term.pvalue) + } else if value_type == "es" { + term.enrichment_score + } else { + term.nes + } + let max_val = 10.0 - let bar_len = if value > max_val { 50 } else { (@math.floor(value / max_val * 50.0)).to_int() } + let bar_len = if value > max_val { + 50 + } else { + @math.floor(value / max_val * 50.0).to_int() + } let bar = "█".repeat(if bar_len > 0 { bar_len } else { 0 }) - - let term_display = if term.term_name.length() > 30 { substring(term.term_name, 0, 30) + "..." } else { term.term_name } - result = result + term_display + "\t" + value.to_string() + "\t" + bar + "\n" + + let term_display = if term.term_name.length() > 30 { + substring(term.term_name, 0, 30) + "..." + } else { + term.term_name + } + result = result + + term_display + + "\t" + + value.to_string() + + "\t" + + bar + + "\n" i = i + 1 } - + result = result + "\nLegend: bar length proportional to " + value_type + "\n" result } -pub fn bio_enrichplot_dotplot(data : EnrichResult, top_n : Int, title : String) -> String { +///| +pub fn bio_enrichplot_dotplot( + data : EnrichResult, + top_n : Int, + title : String, +) -> String { let terms = copy_enrich_term_array(data.terms) let sorted = sort_terms_by_padj(terms) - + let n = if sorted.length() < top_n { sorted.length() } else { top_n } let mut result = "\n" + title + "\n" result = result + "=".repeat(80) + "\n" result = result + "Term\tES\tpadj\tGeneCount\tBubble\n" result = result + "-".repeat(80) + "\n" - + let mut i = 0 while i < n { let term = sorted[i] - let bubble_size = if term.gene_count < 5 { 1 } else if term.gene_count < 10 { 2 } else if term.gene_count < 20 { 3 } else if term.gene_count < 50 { 4 } else { 5 } + let bubble_size = if term.gene_count < 5 { + 1 + } else if term.gene_count < 10 { + 2 + } else if term.gene_count < 20 { + 3 + } else if term.gene_count < 50 { + 4 + } else { + 5 + } let bubble = "*".repeat(bubble_size) - let term_display = if term.term_name.length() > 30 { substring(term.term_name, 0, 30) + "..." } else { term.term_name } - result = result + term_display + "\t" + term.enrichment_score.to_string() + "\t" + term.adjusted_pvalue.to_string() + "\t" + term.gene_count.to_string() + "\t" + bubble + "\n" + let term_display = if term.term_name.length() > 30 { + substring(term.term_name, 0, 30) + "..." + } else { + term.term_name + } + result = result + + term_display + + "\t" + + term.enrichment_score.to_string() + + "\t" + + term.adjusted_pvalue.to_string() + + "\t" + + term.gene_count.to_string() + + "\t" + + bubble + + "\n" i = i + 1 } - + result = result + "\nLegend: * = small, *** = medium, ***** = large\n" result } -pub fn bio_enrichplot_heatmap(data : EnrichResult, top_n : Int, gene_count : Int, title : String) -> String { +///| +pub fn bio_enrichplot_heatmap( + data : EnrichResult, + top_n : Int, + gene_count : Int, + title : String, +) -> String { let terms = copy_enrich_term_array(data.terms) let sorted = sort_terms_by_padj(terms) - + let n = if sorted.length() < top_n { sorted.length() } else { top_n } - + let gene_count_map : Map[String, Int] = Map([], capacity=0) let gene_counts = gene_count_map - + let mut i = 0 while i < n { let term = sorted[i] let mut j = 0 while j < term.genes.length() { let gene = term.genes[j] - let current = if gene_counts.contains(gene) { gene_counts.get(gene).unwrap() } else { 0 } + let current = if gene_counts.contains(gene) { + gene_counts.get(gene).unwrap() + } else { + 0 + } gene_counts.set(gene, current + 1) j = j + 1 } i = i + 1 } - + let gene_entries = gene_counts.iter().collect() let gene_len = gene_entries.length() let mut selected_genes : Array[String] = Array::new() @@ -264,15 +366,20 @@ pub fn bio_enrichplot_heatmap(data : EnrichResult, top_n : Int, gene_count : Int } k = k + 1 } - + let sg_len = selected_genes.length() if sg_len == 0 { - return "\n" + title + "\n" + "=".repeat(80) + "\n" + "No genes shared between at least 2 terms\n" + return "\n" + + title + + "\n" + + "=".repeat(80) + + "\n" + + "No genes shared between at least 2 terms\n" } - + let mut result = "\n" + title + "\n" result = result + "=".repeat(80) + "\n" - + result = result + "\t" let mut l = 0 while l < sg_len { @@ -280,12 +387,16 @@ pub fn bio_enrichplot_heatmap(data : EnrichResult, top_n : Int, gene_count : Int l = l + 1 } result = result + "\n" - + let mut p = 0 while p < n { let term = sorted[p] - let term_display = if term.term_name.length() > 20 { substring(term.term_name, 0, 20) + "..." } else { term.term_name } - + let term_display = if term.term_name.length() > 20 { + substring(term.term_name, 0, 20) + "..." + } else { + term.term_name + } + let mut row = term_display + "\t" let mut q = 0 while q < sg_len { @@ -298,11 +409,12 @@ pub fn bio_enrichplot_heatmap(data : EnrichResult, top_n : Int, gene_count : Int result = result + row + "\n" p = p + 1 } - + result = result + "\nLegend: █ = gene in term, ░ = gene not in term\n" result } +///| fn copy_tuple_array(arr : Array[(String, Int)]) -> Array[(String, Int)] { let len = arr.length() let result : Array[(String, Int)] = Array::new() @@ -314,7 +426,12 @@ fn copy_tuple_array(arr : Array[(String, Int)]) -> Array[(String, Int)] { result } -fn set_tuple_array(arr : Array[(String, Int)], index : Int, value : (String, Int)) -> Array[(String, Int)] { +///| +fn set_tuple_array( + arr : Array[(String, Int)], + index : Int, + value : (String, Int), +) -> Array[(String, Int)] { let len = arr.length() let result : Array[(String, Int)] = Array::new() let mut i = 0 @@ -329,6 +446,7 @@ fn set_tuple_array(arr : Array[(String, Int)], index : Int, value : (String, Int result } +///| fn contains_gene(genes : Array[String], gene : String) -> Bool { let mut i = 0 while i < genes.length() { @@ -340,27 +458,34 @@ fn contains_gene(genes : Array[String], gene : String) -> Bool { false } -pub fn bio_enrichplot_cnetplot(data : EnrichResult, top_n : Int, title : String) -> String { +///| +pub fn bio_enrichplot_cnetplot( + data : EnrichResult, + top_n : Int, + title : String, +) -> String { let terms = copy_enrich_term_array(data.terms) let sorted = sort_terms_by_padj(terms) - + let n = if sorted.length() < top_n { sorted.length() } else { top_n } - - let colors = ["red", "blue", "green", "purple", "orange", "cyan", "magenta", "yellow"] - + + let colors = [ + "red", "blue", "green", "purple", "orange", "cyan", "magenta", "yellow", + ] + let term_colors : Map[String, String] = Map([], capacity=0) let color_map = term_colors - + let mut term_nodes : Array[String] = Array::new() let mut gene_nodes : Array[String] = Array::new() let mut edges : Array[(String, String)] = Array::new() - + let mut i = 0 while i < n { let term = sorted[i] let term_node = term.term_name let color = colors[i % colors.length()] - + let tn_len = term_nodes.length() let new_tn : Array[String] = Array::new() let mut j = 0 @@ -370,9 +495,9 @@ pub fn bio_enrichplot_cnetplot(data : EnrichResult, top_n : Int, title : String) } new_tn.push(term_node) term_nodes = new_tn - + color_map.set(term_node, color) - + let mut k = 0 while k < term.genes.length() && k < 10 { let gene = term.genes[k] @@ -397,7 +522,7 @@ pub fn bio_enrichplot_cnetplot(data : EnrichResult, top_n : Int, title : String) new_gn.push(gene) gene_nodes = new_gn } - + let e_len = edges.length() let new_e : Array[(String, String)] = Array::new() let mut n = 0 @@ -407,31 +532,35 @@ pub fn bio_enrichplot_cnetplot(data : EnrichResult, top_n : Int, title : String) } new_e.push((term_node, gene)) edges = new_e - + k = k + 1 } i = i + 1 } - + let mut result = "\n" + title + "\n" result = result + "=".repeat(80) + "\n" result = result + "Nodes:\n" - + let mut p = 0 while p < term_nodes.length() { let term = term_nodes[p] - let col = if color_map.contains(term) { color_map.get(term).unwrap() } else { "gray" } + let col = if color_map.contains(term) { + color_map.get(term).unwrap() + } else { + "gray" + } result = result + " [" + col + "] " + term + "\n" p = p + 1 } - + result = result + "\nGenes:\n" let mut q = 0 while q < gene_nodes.length() { result = result + " ○ " + gene_nodes[q] + "\n" q = q + 1 } - + result = result + "\nEdges (Term → Gene):\n" let mut r = 0 while r < edges.length() { @@ -439,20 +568,24 @@ pub fn bio_enrichplot_cnetplot(data : EnrichResult, top_n : Int, title : String) result = result + " " + term + " → " + gene + "\n" r = r + 1 } - + result - } -pub fn bio_enrichplot_emapplot(data : EnrichResult, similarity_threshold : Double, title : String) -> String { +///| +pub fn bio_enrichplot_emapplot( + data : EnrichResult, + similarity_threshold : Double, + title : String, +) -> String { let terms = copy_enrich_term_array(data.terms) let sorted = sort_terms_by_padj(terms) - + let n = sorted.length() - + let mut term_sets : Array[Map[String, Bool]] = Array::new() let mut term_names : Array[String] = Array::new() - + let mut i = 0 while i < n { let term = sorted[i] @@ -465,7 +598,7 @@ pub fn bio_enrichplot_emapplot(data : EnrichResult, similarity_threshold : Doubl } new_ts.push(create_gene_hashmap(term.genes)) term_sets = new_ts - + let tn_len = term_names.length() let new_tn : Array[String] = Array::new() let mut k = 0 @@ -475,22 +608,26 @@ pub fn bio_enrichplot_emapplot(data : EnrichResult, similarity_threshold : Doubl } new_tn.push(term.term_name) term_names = new_tn - + i = i + 1 } - + let mut result = "\n" + title + "\n" result = result + "=".repeat(80) + "\n" result = result + "Enrichment Map (terms connected by shared genes):\n\n" - + let mut l = 0 while l < n { let mut m = l + 1 while m < n { let overlap = count_intersection(term_sets[l], term_sets[m]) let union = calculate_union_size(term_sets[l], term_sets[m]) - let jaccard = if union > 0 { overlap.to_double() / union.to_double() } else { 0.0 } - + let jaccard = if union > 0 { + overlap.to_double() / union.to_double() + } else { + 0.0 + } + if jaccard > similarity_threshold { result = result + term_names[l] + " ↔ " + term_names[m] result = result + " (Jaccard: " + jaccard.to_string() + ")\n" @@ -499,11 +636,13 @@ pub fn bio_enrichplot_emapplot(data : EnrichResult, similarity_threshold : Doubl } l = l + 1 } - - result = result + "\nLegend: edges represent Jaccard similarity > 0.1 between term gene sets\n" + + result = result + + "\nLegend: edges represent Jaccard similarity > 0.1 between term gene sets\n" result } +///| fn create_gene_hashmap(genes : Array[String]) -> Map[String, Bool] { let map : Map[String, Bool] = Map([], capacity=0) let result = map @@ -516,7 +655,11 @@ fn create_gene_hashmap(genes : Array[String]) -> Map[String, Bool] { result } -fn count_intersection(set1 : Map[String, Bool], set2 : Map[String, Bool]) -> Int { +///| +fn count_intersection( + set1 : Map[String, Bool], + set2 : Map[String, Bool], +) -> Int { let entries = set1.iter().collect() let len = entries.length() let mut count = 0 @@ -531,24 +674,29 @@ fn count_intersection(set1 : Map[String, Bool], set2 : Map[String, Bool]) -> Int count } -fn calculate_union_size(set1 : Map[String, Bool], set2 : Map[String, Bool]) -> Int { +///| +fn calculate_union_size( + set1 : Map[String, Bool], + set2 : Map[String, Bool], +) -> Int { let entries1 = set1.iter().collect() let entries2 = set2.iter().collect() - + let set1_len = entries1.length() let set2_len = entries2.length() let intersection = count_intersection(set1, set2) - + set1_len + set2_len - intersection } +///| pub fn bio_enrichplot_summary(data : EnrichResult) -> String { let total = data.terms.length() - + let mut sig_count = 0 let mut avg_es = 0.0 let mut avg_nes = 0.0 - + let mut i = 0 while i < total { let term = data.terms[i] @@ -559,18 +707,21 @@ pub fn bio_enrichplot_summary(data : EnrichResult) -> String { avg_nes = avg_nes + term.nes i = i + 1 } - + let mean_es = if total > 0 { avg_es / total.to_double() } else { 0.0 } let mean_nes = if total > 0 { avg_nes / total.to_double() } else { 0.0 } - + let mut result = "\nEnrichment Result Summary\n" result = result + "=".repeat(60) + "\n" result = result + "Gene Set: " + data.gene_set_name + "\n" result = result + "Organism: " + data.organism + "\n" result = result + "Total Terms: " + total.to_string() + "\n" - result = result + "Significant Terms (padj < 0.05): " + sig_count.to_string() + "\n" + result = result + + "Significant Terms (padj < 0.05): " + + sig_count.to_string() + + "\n" result = result + "Average Enrichment Score: " + mean_es.to_string() + "\n" result = result + "Average NES: " + mean_nes.to_string() + "\n" - + result -} \ No newline at end of file +} diff --git a/src/ensembldb.mbt b/src/ensembldb.mbt index 0ce4e86f..8674dfc5 100644 --- a/src/ensembldb.mbt +++ b/src/ensembldb.mbt @@ -13,7 +13,15 @@ pub struct EnsDbExon { } ///| -pub fn EnsDbExon::new(exon_id : String, gene_id : String, tx_id : String, exon_rank : Int, seq_start : Int, seq_end : Int, strand : Int) -> EnsDbExon { +pub fn EnsDbExon::new( + exon_id : String, + gene_id : String, + tx_id : String, + exon_rank : Int, + seq_start : Int, + seq_end : Int, + strand : Int, +) -> EnsDbExon { EnsDbExon::{ exon_id, gene_id, tx_id, exon_rank, seq_start, seq_end, strand } } @@ -30,8 +38,26 @@ pub struct EnsDbCDS { } ///| -pub fn EnsDbCDS::new(cds_id : String, gene_id : String, tx_id : String, cds_rank : Int, seq_start : Int, seq_end : Int, strand : Int, codon_start : Int) -> EnsDbCDS { - EnsDbCDS::{ cds_id, gene_id, tx_id, cds_rank, seq_start, seq_end, strand, codon_start } +pub fn EnsDbCDS::new( + cds_id : String, + gene_id : String, + tx_id : String, + cds_rank : Int, + seq_start : Int, + seq_end : Int, + strand : Int, + codon_start : Int, +) -> EnsDbCDS { + EnsDbCDS::{ + cds_id, + gene_id, + tx_id, + cds_rank, + seq_start, + seq_end, + strand, + codon_start, + } } ///| @@ -47,8 +73,26 @@ pub struct EnsDbTranscript { } ///| -pub fn EnsDbTranscript::new(tx_id : String, gene_id : String, tx_name : String, biotype : String, seq_start : Int, seq_end : Int, strand : Int, chromosome : String) -> EnsDbTranscript { - EnsDbTranscript::{ tx_id, gene_id, tx_name, biotype, seq_start, seq_end, strand, chromosome } +pub fn EnsDbTranscript::new( + tx_id : String, + gene_id : String, + tx_name : String, + biotype : String, + seq_start : Int, + seq_end : Int, + strand : Int, + chromosome : String, +) -> EnsDbTranscript { + EnsDbTranscript::{ + tx_id, + gene_id, + tx_name, + biotype, + seq_start, + seq_end, + strand, + chromosome, + } } ///| @@ -63,8 +107,24 @@ pub struct EnsDbGene { } ///| -pub fn EnsDbGene::new(gene_id : String, gene_name : String, biotype : String, seq_start : Int, seq_end : Int, strand : Int, chromosome : String) -> EnsDbGene { - EnsDbGene::{ gene_id, gene_name, biotype, seq_start, seq_end, strand, chromosome } +pub fn EnsDbGene::new( + gene_id : String, + gene_name : String, + biotype : String, + seq_start : Int, + seq_end : Int, + strand : Int, + chromosome : String, +) -> EnsDbGene { + EnsDbGene::{ + gene_id, + gene_name, + biotype, + seq_start, + seq_end, + strand, + chromosome, + } } ///| @@ -87,7 +147,7 @@ pub fn EnsDb::new(version : String, species : String) -> EnsDb { transcripts: Array::new(), exons: Array::new(), cds: Array::new(), - metadata: Map([], capacity=0) + metadata: Map([], capacity=0), } } @@ -156,7 +216,7 @@ pub fn edb_get_gene_by_id(db : EnsDb, gene_id : String) -> EnsDbGene? { ///| pub fn edb_get_gene_by_name(db : EnsDb, gene_name : String) -> Array[EnsDbGene] { let results : Array[EnsDbGene] = Array::new() - + let mut i = 0 while i < db.genes.length() { if db.genes[i].gene_name == gene_name { @@ -164,14 +224,17 @@ pub fn edb_get_gene_by_name(db : EnsDb, gene_name : String) -> Array[EnsDbGene] } i = i + 1 } - + results } ///| -pub fn edb_get_transcripts_by_gene(db : EnsDb, gene_id : String) -> Array[EnsDbTranscript] { +pub fn edb_get_transcripts_by_gene( + db : EnsDb, + gene_id : String, +) -> Array[EnsDbTranscript] { let results : Array[EnsDbTranscript] = Array::new() - + let mut i = 0 while i < db.transcripts.length() { if db.transcripts[i].gene_id == gene_id { @@ -179,14 +242,17 @@ pub fn edb_get_transcripts_by_gene(db : EnsDb, gene_id : String) -> Array[EnsDbT } i = i + 1 } - + results } ///| -pub fn edb_get_exons_by_transcript(db : EnsDb, tx_id : String) -> Array[EnsDbExon] { +pub fn edb_get_exons_by_transcript( + db : EnsDb, + tx_id : String, +) -> Array[EnsDbExon] { let results : Array[EnsDbExon] = Array::new() - + let mut i = 0 while i < db.exons.length() { if db.exons[i].tx_id == tx_id { @@ -194,14 +260,14 @@ pub fn edb_get_exons_by_transcript(db : EnsDb, tx_id : String) -> Array[EnsDbExo } i = i + 1 } - + results } ///| pub fn edb_get_cds_by_transcript(db : EnsDb, tx_id : String) -> Array[EnsDbCDS] { let results : Array[EnsDbCDS] = Array::new() - + let mut i = 0 while i < db.cds.length() { if db.cds[i].tx_id == tx_id { @@ -209,14 +275,14 @@ pub fn edb_get_cds_by_transcript(db : EnsDb, tx_id : String) -> Array[EnsDbCDS] } i = i + 1 } - + results } ///| pub fn edb_filter_by_chromosome(db : EnsDb, chromosome : String) -> EnsDb { let filtered = EnsDb::new(db.version, db.species) - + let mut i = 0 while i < db.genes.length() { if db.genes[i].chromosome == chromosome { @@ -224,7 +290,7 @@ pub fn edb_filter_by_chromosome(db : EnsDb, chromosome : String) -> EnsDb { } i = i + 1 } - + let mut j = 0 while j < db.transcripts.length() { if db.transcripts[j].chromosome == chromosome { @@ -232,14 +298,14 @@ pub fn edb_filter_by_chromosome(db : EnsDb, chromosome : String) -> EnsDb { } j = j + 1 } - + filtered } ///| pub fn edb_filter_by_biotype(db : EnsDb, biotype : String) -> EnsDb { let filtered = EnsDb::new(db.version, db.species) - + let mut i = 0 while i < db.genes.length() { if db.genes[i].biotype == biotype { @@ -247,7 +313,7 @@ pub fn edb_filter_by_biotype(db : EnsDb, biotype : String) -> EnsDb { } i = i + 1 } - + let mut j = 0 while j < db.transcripts.length() { if db.transcripts[j].biotype == biotype { @@ -255,7 +321,7 @@ pub fn edb_filter_by_biotype(db : EnsDb, biotype : String) -> EnsDb { } j = j + 1 } - + filtered } @@ -286,44 +352,82 @@ pub fn create_example_ensdb() -> EnsDb { let db = EnsDb::new("109", "Homo sapiens") let _ = db.metadata.set("source", "Ensembl") let _ = db.metadata.set("build", "GRCh38") - - let gene1 = EnsDbGene::new("ENSG000001", "ACTB", "protein_coding", 5566659, 5572915, 1, "17") - let gene2 = EnsDbGene::new("ENSG000002", "GAPDH", "protein_coding", 653207, 674323, 1, "12") - let gene3 = EnsDbGene::new("ENSG000003", "TP53", "protein_coding", 7661779, 7687550, -1, "17") + + let gene1 = EnsDbGene::new( + "ENSG000001", "ACTB", "protein_coding", 5566659, 5572915, 1, "17", + ) + let gene2 = EnsDbGene::new( + "ENSG000002", "GAPDH", "protein_coding", 653207, 674323, 1, "12", + ) + let gene3 = EnsDbGene::new( + "ENSG000003", "TP53", "protein_coding", 7661779, 7687550, -1, "17", + ) db.genes.push(gene1) db.genes.push(gene2) db.genes.push(gene3) - - let tx1 = EnsDbTranscript::new("ENST000001", "ENSG000001", "ACTB-201", "protein_coding", 5566659, 5572915, 1, "17") - let tx2 = EnsDbTranscript::new("ENST000002", "ENSG000001", "ACTB-202", "protein_coding", 5566659, 5572915, 1, "17") - let tx3 = EnsDbTranscript::new("ENST000003", "ENSG000002", "GAPDH-201", "protein_coding", 653207, 674323, 1, "12") - let tx4 = EnsDbTranscript::new("ENST000004", "ENSG000003", "TP53-201", "protein_coding", 7661779, 7687550, -1, "17") + + let tx1 = EnsDbTranscript::new( + "ENST000001", "ENSG000001", "ACTB-201", "protein_coding", 5566659, 5572915, 1, + "17", + ) + let tx2 = EnsDbTranscript::new( + "ENST000002", "ENSG000001", "ACTB-202", "protein_coding", 5566659, 5572915, 1, + "17", + ) + let tx3 = EnsDbTranscript::new( + "ENST000003", "ENSG000002", "GAPDH-201", "protein_coding", 653207, 674323, 1, + "12", + ) + let tx4 = EnsDbTranscript::new( + "ENST000004", "ENSG000003", "TP53-201", "protein_coding", 7661779, 7687550, -1, + "17", + ) db.transcripts.push(tx1) db.transcripts.push(tx2) db.transcripts.push(tx3) db.transcripts.push(tx4) - - let exon1 = EnsDbExon::new("ENSE000001", "ENSG000001", "ENST000001", 1, 5566659, 5566743, 1) - let exon2 = EnsDbExon::new("ENSE000002", "ENSG000001", "ENST000001", 2, 5567108, 5567231, 1) - let exon3 = EnsDbExon::new("ENSE000003", "ENSG000001", "ENST000001", 3, 5567332, 5567420, 1) - let exon4 = EnsDbExon::new("ENSE000004", "ENSG000002", "ENST000003", 1, 653207, 653322, 1) - let exon5 = EnsDbExon::new("ENSE000005", "ENSG000002", "ENST000003", 2, 654417, 654536, 1) + + let exon1 = EnsDbExon::new( + "ENSE000001", "ENSG000001", "ENST000001", 1, 5566659, 5566743, 1, + ) + let exon2 = EnsDbExon::new( + "ENSE000002", "ENSG000001", "ENST000001", 2, 5567108, 5567231, 1, + ) + let exon3 = EnsDbExon::new( + "ENSE000003", "ENSG000001", "ENST000001", 3, 5567332, 5567420, 1, + ) + let exon4 = EnsDbExon::new( + "ENSE000004", "ENSG000002", "ENST000003", 1, 653207, 653322, 1, + ) + let exon5 = EnsDbExon::new( + "ENSE000005", "ENSG000002", "ENST000003", 2, 654417, 654536, 1, + ) db.exons.push(exon1) db.exons.push(exon2) db.exons.push(exon3) db.exons.push(exon4) db.exons.push(exon5) - - let cds1 = EnsDbCDS::new("ENSC000001", "ENSG000001", "ENST000001", 1, 5566680, 5566743, 1, 1) - let cds2 = EnsDbCDS::new("ENSC000002", "ENSG000001", "ENST000001", 2, 5567108, 5567231, 1, 1) - let cds3 = EnsDbCDS::new("ENSC000003", "ENSG000001", "ENST000001", 3, 5567332, 5567420, 1, 1) - let cds4 = EnsDbCDS::new("ENSC000004", "ENSG000002", "ENST000003", 1, 653247, 653322, 1, 1) - let cds5 = EnsDbCDS::new("ENSC000005", "ENSG000002", "ENST000003", 2, 654417, 654536, 1, 1) + + let cds1 = EnsDbCDS::new( + "ENSC000001", "ENSG000001", "ENST000001", 1, 5566680, 5566743, 1, 1, + ) + let cds2 = EnsDbCDS::new( + "ENSC000002", "ENSG000001", "ENST000001", 2, 5567108, 5567231, 1, 1, + ) + let cds3 = EnsDbCDS::new( + "ENSC000003", "ENSG000001", "ENST000001", 3, 5567332, 5567420, 1, 1, + ) + let cds4 = EnsDbCDS::new( + "ENSC000004", "ENSG000002", "ENST000003", 1, 653247, 653322, 1, 1, + ) + let cds5 = EnsDbCDS::new( + "ENSC000005", "ENSG000002", "ENST000003", 2, 654417, 654536, 1, 1, + ) db.cds.push(cds1) db.cds.push(cds2) db.cds.push(cds3) db.cds.push(cds4) db.cds.push(cds5) - + db -} \ No newline at end of file +} diff --git a/src/estimate_score.mbt b/src/estimate_score.mbt index a4d2b0d4..d03ef7b1 100644 --- a/src/estimate_score.mbt +++ b/src/estimate_score.mbt @@ -46,8 +46,8 @@ pub struct EstSampleScore { sample_id : String stromal_score : Double immune_score : Double - estimate_score : Double // stromal + immune - tumor_purity : Double // inferred purity in [0, 1] (NaN if undefined) + estimate_score : Double // stromal + immune + tumor_purity : Double // inferred purity in [0, 1] (NaN if undefined) } ///| @@ -187,10 +187,14 @@ fn est_sort_indices_desc(values : Array[Double]) -> Array[Int] { /// Returns the proportion of values in `sample` that are <= x. fn est_ecdf(x : Double, sample : Array[Double]) -> Double { let n = sample.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut count = 0 for v in sample { - if v <= x { count = count + 1 } + if v <= x { + count = count + 1 + } } count.to_double() / n.to_double() } @@ -199,10 +203,14 @@ fn est_ecdf(x : Double, sample : Array[Double]) -> Double { /// Check if all values in an array are identical (degenerate case). fn est_all_equal(arr : Array[Double]) -> Bool { let n = arr.length() - if n <= 1 { return true } + if n <= 1 { + return true + } let first = arr[0] for i in 1.. 1.0e-15 { return false } + if (arr[i] - first).abs() > 1.0e-15 { + return false + } } true } @@ -227,7 +235,9 @@ fn est_ssgsea_score( gene_set : Array[String], ) -> Double { let n = gene_names.length() - if n == 0 || gene_set.length() == 0 { return 0.0 } + if n == 0 || gene_set.length() == 0 { + return 0.0 + } // Build membership set let gene_member : Map[String, Unit] = Map([], capacity=gene_set.length()) let mut set_size = 0 @@ -246,7 +256,9 @@ fn est_ssgsea_score( sum_in_set = sum_in_set + expression[i].abs() } } - if sum_in_set < 1.0e-15 { return 0.0 } + if sum_in_set < 1.0e-15 { + return 0.0 + } // Walk down the ranked list let n_not_set = (n - set_size).to_double() let incr_in = 1.0 / sum_in_set @@ -264,14 +276,22 @@ fn est_ssgsea_score( } else { running = running - decr_out } - if running > max_val { max_val = running } - if running < min_val { min_val = running } - if running > 0.0 { pos_acc = pos_acc + running } + if running > max_val { + max_val = running + } + if running < min_val { + min_val = running + } + if running > 0.0 { + pos_acc = pos_acc + running + } } // Standard ssGSEA normalization: integrate positive area and divide by // total range, then subtract 0.5 to center let range = max_val - min_val - if range < 1.0e-15 { return 0.0 } + if range < 1.0e-15 { + return 0.0 + } // The classic ssGSEA score uses sum of positive running sums (weighted) // normalized by (n_set * n_not_set) is NOT appropriate here; we follow // the integration-style score: pos_acc / n (average positive excursion) @@ -346,8 +366,16 @@ pub fn est_run( let scores : Array[EstSampleScore] = [] for s in 0.. Array[String] { [ - "ACTA2", "ADAM12", "ADAMDEC1", "ADAMTS2", "AEBP1", "ANGPTL2", "ANGPTL4", - "APBB1IP", "APLP1", "ARCHN1", "ASPN", "BGN", "BMP1", "C1QA", "C1QB", - "C1QC", "C3", "CADM1", "CALD1", "CCDC80", "CD248", "CD55", "CDH11", - "CDH19", "COL10A1", "COL11A1", "COL12A1", "COL14A1", "COL1A1", "COL1A2", - "COL3A1", "COL4A1", "COL4A2", "COL5A1", "COL5A2", "COL6A3", "COPZ2", - "CRLF1", "CXCL1", "CXCL12", "DCN", "DPT", "ECM2", "EDIL3", "EGR2", - "FAP", "FBLN1", "FBN1", "FBN2", "FGF7", + "ACTA2", "ADAM12", "ADAMDEC1", "ADAMTS2", "AEBP1", "ANGPTL2", "ANGPTL4", "APBB1IP", + "APLP1", "ARCHN1", "ASPN", "BGN", "BMP1", "C1QA", "C1QB", "C1QC", "C3", "CADM1", + "CALD1", "CCDC80", "CD248", "CD55", "CDH11", "CDH19", "COL10A1", "COL11A1", "COL12A1", + "COL14A1", "COL1A1", "COL1A2", "COL3A1", "COL4A1", "COL4A2", "COL5A1", "COL5A2", + "COL6A3", "COPZ2", "CRLF1", "CXCL1", "CXCL12", "DCN", "DPT", "ECM2", "EDIL3", + "EGR2", "FAP", "FBLN1", "FBN1", "FBN2", "FGF7", ] } @@ -389,10 +416,10 @@ pub fn est_stromal_genes() -> Array[String] { /// (2013) Supplementary Table S2 (subset). pub fn est_immune_genes() -> Array[String] { [ - "AIF1", "APOBEC3G", "ARHGAP25", "BCL6", "BLK", "BST1", "BST2", "C1orf162", - "C2orf88", "C3orf14", "CCL3", "CD164L1", "CD2", "CD247", "CD3D", "CD3E", - "CD3G", "CD52", "CD53", "CD69", "CD7", "CEBPD", "CLEC2B", "CMKLR1", - "CPEB2", "CRIP1", "CXCL9", "CXCR6", "CYBB", "DOCK2", + "AIF1", "APOBEC3G", "ARHGAP25", "BCL6", "BLK", "BST1", "BST2", "C1orf162", "C2orf88", + "C3orf14", "CCL3", "CD164L1", "CD2", "CD247", "CD3D", "CD3E", "CD3G", "CD52", + "CD53", "CD69", "CD7", "CEBPD", "CLEC2B", "CMKLR1", "CPEB2", "CRIP1", "CXCL9", + "CXCR6", "CYBB", "DOCK2", ] } @@ -437,21 +464,14 @@ pub fn est_sample_data() -> EstExpression { gene_names.push("BACKGRD" + bi.to_string()) } let n_genes = gene_names.length() - let sample_names = [ - "HighStromal", "HighImmune", "HighBoth", "LowBoth", - ] + let sample_names = ["HighStromal", "HighImmune", "HighBoth", "LowBoth"] // Define infiltration profiles: (stromal_add, immune_add) // HighStromal: stromal genes up-regulated, immune slightly up // HighImmune: immune genes up-regulated, stromal slightly up // HighBoth: both stromal and immune up-regulated // LowBoth: both stromal and immune DOWN-regulated (below background), // representing a tumor-dominant sample with little infiltration - let profiles = [ - (8.0, 1.0), - (1.0, 8.0), - (8.0, 8.0), - (-2.0, -2.0), - ] + let profiles = [(8.0, 1.0), (1.0, 8.0), (8.0, 8.0), (-2.0, -2.0)] // Build matrix (rows=genes, cols=samples) let matrix : Array[Array[Double]] = [] for gi in 0.. EstExpression { val = val + i_level } // Clamp to non-negative (expression cannot be negative) - if val < 0.1 { val = 0.1 } + if val < 0.1 { + val = 0.1 + } // Add small per-gene jitter to break ties val = val + 0.01 * (gi % 7).to_double() row.push(val) @@ -482,9 +504,14 @@ pub fn est_sample_data() -> EstExpression { ///| /// Get the score for a specific sample. -pub fn EstResult::get_score(self : EstResult, sample_id : String) -> EstSampleScore { +pub fn EstResult::get_score( + self : EstResult, + sample_id : String, +) -> EstSampleScore { for s in self.scores { - if s.sample_id == sample_id { return s } + if s.sample_id == sample_id { + return s + } } // Return a default empty score if not found { @@ -500,7 +527,8 @@ pub fn EstResult::get_score(self : EstResult, sample_id : String) -> EstSampleSc /// Format ESTIMATE results as a string table. pub fn EstResult::to_string(self : EstResult) -> String { let mut result = "ESTIMATE Results:\n" - result = result + "Sample\tStromalScore\tImmuneScore\tESTIMATEScore\tTumorPurity\n" + result = result + + "Sample\tStromalScore\tImmuneScore\tESTIMATEScore\tTumorPurity\n" for s in self.scores { let purity_str = if s.tumor_purity.is_nan() { "NA" diff --git a/src/exonerate.mbt b/src/exonerate.mbt index 6e6c0db5..4cdd2e3a 100644 --- a/src/exonerate.mbt +++ b/src/exonerate.mbt @@ -165,7 +165,7 @@ pub fn ExonerateRecord::score(self : ExonerateRecord) -> Double { ///| /// Get the list of alignment blocks. pub fn ExonerateRecord::alignment_blocks( - self : ExonerateRecord + self : ExonerateRecord, ) -> Array[AlignmentBlock] { self.alignment_blocks } @@ -394,8 +394,7 @@ fn exo_parse_vulgar_blocks(tokens : Array[String]) -> Array[AlignmentBlock] { if i + 2 < n { let qlen = exo_parse_int(tokens[i + 1]) let tlen = exo_parse_int(tokens[i + 2]) - let (score, advance) = if i + 3 < n && - exo_is_numeric_token(tokens[i + 3]) { + let (score, advance) = if i + 3 < n && exo_is_numeric_token(tokens[i + 3]) { (exo_parse_double(tokens[i + 3]), 4) } else { (0.0, 3) @@ -438,16 +437,8 @@ fn exo_parse_vulgar_line(line : String) -> ExonerateRecord? { let blocks = exo_parse_vulgar_blocks(block_tokens) Some( ExonerateRecord::new( - query_name, - query_start, - query_end, - query_strand, - target_name, - target_start, - target_end, - target_strand, - score, - blocks, + query_name, query_start, query_end, query_strand, target_name, target_start, + target_end, target_strand, score, blocks, ), ) } @@ -482,10 +473,7 @@ pub fn parse_exonerate_vulgar(content : String) -> Array[ExonerateRecord] { /// operation code and the single length value. For most operations both /// sequences consume the length; introns (I) consume neither; gaps (U/V/D) /// consume only one side. -fn exo_cigar_lengths( - code : String, - length : Int, -) -> (Int, Int, Double) { +fn exo_cigar_lengths(code : String, length : Int) -> (Int, Int, Double) { match code { "I" => (0, 0, length.to_double()) "D" => (length, 0, 0.0) @@ -540,16 +528,8 @@ fn exo_parse_cigar_line(line : String) -> ExonerateRecord? { let blocks = exo_parse_cigar_blocks(block_tokens) Some( ExonerateRecord::new( - query_name, - query_start, - query_end, - query_strand, - target_name, - target_start, - target_end, - target_strand, - score, - blocks, + query_name, query_start, query_end, query_strand, target_name, target_start, + target_end, target_strand, score, blocks, ), ) } diff --git a/src/expasy.mbt b/src/expasy.mbt index 17f0d393..d51f4bb6 100644 --- a/src/expasy.mbt +++ b/src/expasy.mbt @@ -13,19 +13,23 @@ pub struct ExPASyRecord { ///| pub fn ExPASyRecord::new(id : String, database : String) -> ExPASyRecord { - ExPASyRecord::{ - id, - database, - status: "ok", - data: Map([], capacity=10) - } + ExPASyRecord::{ id, database, status: "ok", data: Map([], capacity=10) } } ///| -pub fn ExPASyRecord::add_field(self : ExPASyRecord, key : String, value : String) -> ExPASyRecord { +pub fn ExPASyRecord::add_field( + self : ExPASyRecord, + key : String, + value : String, +) -> ExPASyRecord { let data = self.data.copy() data.set(key, value) - ExPASyRecord::{ id: self.id, database: self.database, status: self.status, data: data } + ExPASyRecord::{ + id: self.id, + database: self.database, + status: self.status, + data, + } } ///| @@ -59,28 +63,34 @@ pub fn ExPASyEntry::new(accession : String, name : String) -> ExPASyEntry { sequence: "", length: 0, ec_numbers: Array::new(), - references: Array::new() + references: Array::new(), } } ///| -pub fn ExPASyEntry::add_keyword(self : ExPASyEntry, keyword : String) -> ExPASyEntry { +pub fn ExPASyEntry::add_keyword( + self : ExPASyEntry, + keyword : String, +) -> ExPASyEntry { let keywords = self.keywords.copy() keywords.push(keyword) ExPASyEntry::{ accession: self.accession, name: self.name, description: self.description, - keywords: keywords, + keywords, sequence: self.sequence, length: self.length, ec_numbers: self.ec_numbers, - references: self.references + references: self.references, } } ///| -pub fn ExPASyEntry::add_ec_number(self : ExPASyEntry, ec : String) -> ExPASyEntry { +pub fn ExPASyEntry::add_ec_number( + self : ExPASyEntry, + ec : String, +) -> ExPASyEntry { let ec_numbers = self.ec_numbers.copy() ec_numbers.push(ec) ExPASyEntry::{ @@ -90,8 +100,8 @@ pub fn ExPASyEntry::add_ec_number(self : ExPASyEntry, ec : String) -> ExPASyEntr keywords: self.keywords, sequence: self.sequence, length: self.length, - ec_numbers: ec_numbers, - references: self.references + ec_numbers, + references: self.references, } } @@ -117,7 +127,7 @@ pub fn EnzymeEntry::new(ec_number : String, name : String) -> EnzymeEntry { cofactors: Array::new(), substrates: Array::new(), products: Array::new(), - comments: "" + comments: "", } } @@ -137,12 +147,12 @@ pub fn enzyme_parse_ec(ec_string : String) -> (String, String, String, String) { i = i + 1 } parts.push(current) - + let class = if parts.length() > 0 { parts[0] } else { "" } let subclass = if parts.length() > 1 { parts[1] } else { "" } let subsubclass = if parts.length() > 2 { parts[2] } else { "" } let serial = if parts.length() > 3 { parts[3] } else { "" } - + (class, subclass, subsubclass, serial) } @@ -166,13 +176,16 @@ pub fn expasy_get_prosite_ids(sequence : String) -> Array[String] { ///| pub fn expasy_get_swissprot_entry(accession : String) -> ExPASyEntry? { - let entries = Map([ - ("P04637", ("TP53", "Tumor protein p53")), - ("P38398", ("BRCA1", "BRCA1 DNA repair associated")), - ("P51587", ("BRCA2", "BRCA2 DNA repair associated")), - ("P00533", ("EGFR", "Epidermal growth factor receptor")) - ], capacity=4) - + let entries = Map( + [ + ("P04637", ("TP53", "Tumor protein p53")), + ("P38398", ("BRCA1", "BRCA1 DNA repair associated")), + ("P51587", ("BRCA2", "BRCA2 DNA repair associated")), + ("P00533", ("EGFR", "Epidermal growth factor receptor")), + ], + capacity=4, + ) + if entries.contains(accession) { let entry = entries.get(accession).unwrap() let ex_entry = ExPASyEntry::new(accession, entry.0) @@ -184,13 +197,28 @@ pub fn expasy_get_swissprot_entry(accession : String) -> ExPASyEntry? { ///| pub fn expasy_get_enzyme(ec_number : String) -> EnzymeEntry? { - let enzymes = Map([ - ("1.1.1.1", ("Alcohol dehydrogenase", ["Alcohol:NAD+ oxidoreductase"])), - ("1.2.1.12", ("Glyceraldehyde-3-phosphate dehydrogenase", ["D-glyceraldehyde 3-phosphate:NAD+ oxidoreductase (phosphorylating)"])), - ("2.7.1.1", ("Hexokinase", ["ATP:D-hexose 6-phosphotransferase"])), - ("3.1.3.11", ("Fructose-bisphosphatase", ["D-fructose 1,6-bisphosphate 1-phosphatase"])) - ], capacity=4) - + let enzymes = Map( + [ + ("1.1.1.1", ("Alcohol dehydrogenase", ["Alcohol:NAD+ oxidoreductase"])), + ( + "1.2.1.12", + ( + "Glyceraldehyde-3-phosphate dehydrogenase", + ["D-glyceraldehyde 3-phosphate:NAD+ oxidoreductase (phosphorylating)"], + ), + ), + ("2.7.1.1", ("Hexokinase", ["ATP:D-hexose 6-phosphotransferase"])), + ( + "3.1.3.11", + ( + "Fructose-bisphosphatase", + ["D-fructose 1,6-bisphosphate 1-phosphatase"], + ), + ), + ], + capacity=4, + ) + if enzymes.contains(ec_number) { let enzyme = enzymes.get(ec_number).unwrap() let mut entry = EnzymeEntry::new(ec_number, enzyme.0) @@ -206,7 +234,7 @@ pub fn expasy_get_enzyme(ec_number : String) -> EnzymeEntry? { cofactors: entry.cofactors, substrates: entry.substrates, products: entry.products, - comments: entry.comments + comments: entry.comments, } i = i + 1 } @@ -219,16 +247,34 @@ pub fn expasy_get_enzyme(ec_number : String) -> EnzymeEntry? { ///| pub fn expasy_analyze_protein(sequence : String) -> Map[String, Double] { let result = Map([], capacity=5) - + let mut mw = 0.0 - let aa_weights = Map([ - ("A", 89.09), ("R", 174.20), ("N", 132.12), ("D", 133.10), - ("C", 121.15), ("E", 147.13), ("Q", 146.15), ("G", 75.07), - ("H", 155.16), ("I", 131.17), ("L", 131.17), ("K", 146.19), - ("M", 149.21), ("F", 165.19), ("P", 115.13), ("S", 105.09), - ("T", 119.12), ("W", 204.23), ("Y", 181.19), ("V", 117.15) - ], capacity=20) - + let aa_weights = Map( + [ + ("A", 89.09), + ("R", 174.20), + ("N", 132.12), + ("D", 133.10), + ("C", 121.15), + ("E", 147.13), + ("Q", 146.15), + ("G", 75.07), + ("H", 155.16), + ("I", 131.17), + ("L", 131.17), + ("K", 146.19), + ("M", 149.21), + ("F", 165.19), + ("P", 115.13), + ("S", 105.09), + ("T", 119.12), + ("W", 204.23), + ("Y", 181.19), + ("V", 117.15), + ], + capacity=20, + ) + let mut i = 0 while i < sequence.length() { let aa = char_at(sequence, i) @@ -238,19 +284,37 @@ pub fn expasy_analyze_protein(sequence : String) -> Map[String, Double] { } i = i + 1 } - + mw = mw - (sequence.length() - 1).to_double() * 18.015 result.set("molecular_weight", mw) - + let mut gravy = 0.0 - let hydropathy = Map([ - ("A", 1.8), ("R", -4.5), ("N", -3.5), ("D", -3.5), - ("C", 2.5), ("E", -3.5), ("Q", -3.5), ("G", -0.4), - ("H", -3.2), ("I", 4.5), ("L", 3.8), ("K", -3.9), - ("M", 1.9), ("F", 2.8), ("P", -1.6), ("S", -0.8), - ("T", -0.7), ("W", -0.9), ("Y", -1.3), ("V", 4.2) - ], capacity=20) - + let hydropathy = Map( + [ + ("A", 1.8), + ("R", -4.5), + ("N", -3.5), + ("D", -3.5), + ("C", 2.5), + ("E", -3.5), + ("Q", -3.5), + ("G", -0.4), + ("H", -3.2), + ("I", 4.5), + ("L", 3.8), + ("K", -3.9), + ("M", 1.9), + ("F", 2.8), + ("P", -1.6), + ("S", -0.8), + ("T", -0.7), + ("W", -0.9), + ("Y", -1.3), + ("V", 4.2), + ], + capacity=20, + ) + i = 0 while i < sequence.length() { let aa = char_at(sequence, i) @@ -264,7 +328,7 @@ pub fn expasy_analyze_protein(sequence : String) -> Map[String, Double] { gravy = gravy / sequence.length().to_double() } result.set("gravy", gravy) - + let mut instability = 0.0 i = 0 while i < sequence.length() - 1 { @@ -275,30 +339,30 @@ pub fn expasy_analyze_protein(sequence : String) -> Map[String, Double] { instability = instability / (sequence.length() - 1).to_double() } result.set("instability_index", instability) - + let charge_at_7 = expasy_calculate_charge(sequence, 7.0) result.set("charge_at_pH7", charge_at_7) - + let pi = expasy_calculate_isoelectric_point(sequence) result.set("isoelectric_point", pi) - + result } ///| fn expasy_calculate_charge(sequence : String, ph : Double) -> Double { let mut charge = 0.0 - + let mut n_terminal = 0.0 if sequence.length() > 0 { n_terminal = 1.0 / (1.0 + @math.exp(ph - 7.4)) } - + let mut c_terminal = 0.0 if sequence.length() > 0 { c_terminal = -1.0 / (1.0 + @math.exp(2.2 - ph)) } - + let mut i = 0 while i < sequence.length() { let aa = char_at(sequence, i) @@ -316,7 +380,7 @@ fn expasy_calculate_charge(sequence : String, ph : Double) -> Double { } i = i + 1 } - + charge + n_terminal + c_terminal } @@ -325,12 +389,12 @@ fn expasy_calculate_isoelectric_point(sequence : String) -> Double { let mut min_pi = 2.0 let mut max_pi = 12.0 let mut mid_pi = 7.0 - + let mut i = 0 while i < 50 { mid_pi = (min_pi + max_pi) / 2.0 let charge = expasy_calculate_charge(sequence, mid_pi) - + if charge > 0.001 { min_pi = mid_pi } else if charge < -0.001 { @@ -340,7 +404,7 @@ fn expasy_calculate_isoelectric_point(sequence : String) -> Double { } i = i + 1 } - + mid_pi } @@ -363,6 +427,6 @@ pub fn create_example_enzyme_entry() -> EnzymeEntry { cofactors: enzyme.cofactors, substrates: enzyme.substrates, products: enzyme.products, - comments: enzyme.comments + comments: enzyme.comments, } -} \ No newline at end of file +} diff --git a/src/factoextra.mbt b/src/factoextra.mbt index 0deda9ff..4b91e4a2 100644 --- a/src/factoextra.mbt +++ b/src/factoextra.mbt @@ -84,15 +84,14 @@ pub fn facto_pca( let mut ii = 0 while ii < p { let mut jj = 0 - while jj < p { cov[ii][jj] = cov[ii][jj] * scale_factor; jj = jj + 1 } + while jj < p { + cov[ii][jj] = cov[ii][jj] * scale_factor + jj = jj + 1 + } ii = ii + 1 } // Compute eigenvalues via power iteration - let n_components = if ncp > 0 { - if ncp > p { p } else { ncp } - } else { - p - } + let n_components = if ncp > 0 { if ncp > p { p } else { ncp } } else { p } let (eigenvalues, eigenvectors) = facto_power_iteration(cov, n_components) // Sort by descending eigenvalue let sorted = facto_sort_eigen(eigenvalues, eigenvectors) @@ -100,23 +99,34 @@ pub fn facto_pca( let eig_vecs = sorted.1 // Compute explained variance let mut tv = 0.0 - for ev in eig_vals { tv = tv + ev } + for ev in eig_vals { + tv = tv + ev + } // Compute individual scores: centered %*% eigenvectors - let ind_coord : Array[Array[Double]] = Array::make(n, Array::make(n_components, 0.0)) + let ind_coord : Array[Array[Double]] = Array::make( + n, + Array::make(n_components, 0.0), + ) let mut si = 0 while si < n { let mut sj = 0 while sj < n_components { let mut s = 0.0 let mut sk = 0 - while sk < p { s = s + centered[si][sk] * eig_vecs[sk][sj]; sk = sk + 1 } + while sk < p { + s = s + centered[si][sk] * eig_vecs[sk][sj] + sk = sk + 1 + } ind_coord[si][sj] = s sj = sj + 1 } si = si + 1 } // Variable coordinates: eigenvectors * sqrt(eigenvalues) - let var_coord : Array[Array[Double]] = Array::make(p, Array::make(n_components, 0.0)) + let var_coord : Array[Array[Double]] = Array::make( + p, + Array::make(n_components, 0.0), + ) let mut vi = 0 while vi < p { let mut vj = 0 @@ -154,21 +164,32 @@ pub fn facto_pca( let var_contrib = facto_contrib_var(var_coord, eig_vals) PcaResult::{ eigenvalues: eigenvalues_list, - ind: PcaIndResult::{ coord: ind_coord, cos2: ind_cos2, contrib: ind_contrib }, - var: PcaVarResult::{ coord: var_coord, cos2: var_cos2, contrib: var_contrib }, + ind: PcaIndResult::{ + coord: ind_coord, + cos2: ind_cos2, + contrib: ind_contrib, + }, + var: PcaVarResult::{ + coord: var_coord, + cos2: var_cos2, + contrib: var_contrib, + }, n_ind: n, n_var: p, n_dims: n_components, } } +///| fn facto_center_scale( data : Array[Array[Double]], center : Bool, scale : Bool, ) -> Array[Array[Double]] { let n = data.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let p = data[0].length() let means : Array[Double] = Array::make(p, 0.0) let sds : Array[Double] = Array::make(p, 1.0) @@ -176,7 +197,10 @@ fn facto_center_scale( while j < p { let mut s = 0.0 let mut i = 0 - while i < n { s = s + data[i][j]; i = i + 1 } + while i < n { + s = s + data[i][j] + i = i + 1 + } means[j] = if center { s / n.to_double() } else { 0.0 } if scale { let mut s2 = 0.0 @@ -204,16 +228,22 @@ fn facto_center_scale( result } +///| fn facto_power_iteration( a : Array[Array[Double]], n_components : Int, ) -> (Array[Double], Array[Array[Double]]) { let n = a.length() - if n == 0 { return ([], []) } + if n == 0 { + return ([], []) + } let max_iter = 200 let tol = 1.0e-10 let eigenvalues : Array[Double] = Array::make(n_components, 0.0) - let eigenvectors : Array[Array[Double]] = Array::make(n, Array::make(n_components, 0.0)) + let eigenvectors : Array[Array[Double]] = Array::make( + n, + Array::make(n_components, 0.0), + ) let mut i = 0 while i < n_components { // Initialize vector @@ -229,7 +259,10 @@ fn facto_power_iteration( while j < n { let mut s = 0.0 let mut k = 0 - while k < n { s = s + a[j][k] * v[k]; k = k + 1 } + while k < n { + s = s + a[j][k] * v[k] + k = k + 1 + } v_new[j] = s j = j + 1 } @@ -238,14 +271,19 @@ fn facto_power_iteration( let mut mj = 0 while mj < n { let av = if v_new[mj] < 0.0 { -v_new[mj] } else { v_new[mj] } - if av > max_val { max_val = av } + if av > max_val { + max_val = av + } mj = mj + 1 } lambda = max_val // Normalize if max_val > 0.0 { let mut nj = 0 - while nj < n { v[nj] = v_new[nj] / max_val; nj = nj + 1 } + while nj < n { + v[nj] = v_new[nj] / max_val + nj = nj + 1 + } } // Check convergence if iter > 0 && max_val > 0.0 { @@ -254,16 +292,23 @@ fn facto_power_iteration( while dj < n { let d = v_new[dj] / max_val - eigenvectors[dj][i] let ad = if d < 0.0 { -d } else { d } - if ad > diff { diff = ad } + if ad > diff { + diff = ad + } dj = dj + 1 } - if diff < tol { break } + if diff < tol { + break + } } iter = iter + 1 } eigenvalues[i] = lambda let mut ei = 0 - while ei < n { eigenvectors[ei][i] = v[ei]; ei = ei + 1 } + while ei < n { + eigenvectors[ei][i] = v[ei] + ei = ei + 1 + } // Deflation: subtract contribution of found eigenvector if lambda > 0.0 { let mut di = 0 @@ -282,6 +327,7 @@ fn facto_power_iteration( (eigenvalues, eigenvectors) } +///| fn facto_sort_eigen( eigenvalues : Array[Double], eigenvectors : Array[Array[Double]], @@ -289,7 +335,10 @@ fn facto_sort_eigen( let n = eigenvalues.length() let indices : Array[Int] = Array::make(n, 0) let mut i = 0 - while i < n { indices[i] = i; i = i + 1 } + while i < n { + indices[i] = i + i = i + 1 + } // Bubble sort by eigenvalue descending let mut iter = 0 while iter < n - 1 { @@ -304,11 +353,16 @@ fn facto_sort_eigen( } j = j + 1 } - if !swapped { break } + if !swapped { + break + } iter = iter + 1 } let sorted_eigenvalues : Array[Double] = Array::make(n, 0.0) - let sorted_eigenvectors : Array[Array[Double]] = Array::make(eigenvectors.length(), Array::make(n, 0.0)) + let sorted_eigenvectors : Array[Array[Double]] = Array::make( + eigenvectors.length(), + Array::make(n, 0.0), + ) let mut k = 0 while k < n { sorted_eigenvalues[k] = eigenvalues[indices[k]] @@ -322,19 +376,29 @@ fn facto_sort_eigen( (sorted_eigenvalues, sorted_eigenvectors) } +///| fn facto_cos2(coords : Array[Array[Double]]) -> Array[Array[Double]] { let n = coords.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let ncp = coords[0].length() let cos2 : Array[Array[Double]] = Array::make(n, Array::make(ncp, 0.0)) let mut i = 0 while i < n { let mut total = 0.0 let mut j = 0 - while j < ncp { total = total + coords[i][j] * coords[i][j]; j = j + 1 } + while j < ncp { + total = total + coords[i][j] * coords[i][j] + j = j + 1 + } let mut k = 0 while k < ncp { - cos2[i][k] = if total > 0.0 { coords[i][k] * coords[i][k] / total } else { 0.0 } + cos2[i][k] = if total > 0.0 { + coords[i][k] * coords[i][k] / total + } else { + 0.0 + } k = k + 1 } i = i + 1 @@ -342,11 +406,12 @@ fn facto_cos2(coords : Array[Array[Double]]) -> Array[Array[Double]] { cos2 } -fn facto_contrib_ind( - coords : Array[Array[Double]], -) -> Array[Array[Double]] { +///| +fn facto_contrib_ind(coords : Array[Array[Double]]) -> Array[Array[Double]] { let n = coords.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let ncp = coords[0].length() let contrib : Array[Array[Double]] = Array::make(n, Array::make(ncp, 0.0)) let total_contrib : Array[Double] = Array::make(ncp, 0.0) @@ -365,19 +430,25 @@ fn facto_contrib_ind( while k < ncp { if total_contrib[k] > 0.0 { let mut l = 0 - while l < n { contrib[l][k] = contrib[l][k] / total_contrib[k] * 100.0; l = l + 1 } + while l < n { + contrib[l][k] = contrib[l][k] / total_contrib[k] * 100.0 + l = l + 1 + } } k = k + 1 } contrib } +///| fn facto_contrib_var( coords : Array[Array[Double]], eigenvalues : Array[Double], ) -> Array[Array[Double]] { let n = coords.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let ncp = coords[0].length() let contrib : Array[Array[Double]] = Array::make(n, Array::make(ncp, 0.0)) let mut i = 0 @@ -385,7 +456,11 @@ fn facto_contrib_var( let mut j = 0 while j < ncp { let eig = eigenvalues[j] - let c = if eig > 0.0 { coords[i][j] * coords[i][j] / eig * 100.0 } else { 0.0 } + let c = if eig > 0.0 { + coords[i][j] * coords[i][j] / eig * 100.0 + } else { + 0.0 + } contrib[i][j] = c j = j + 1 } @@ -414,9 +489,14 @@ pub fn facto_get_pca_var(result : PcaResult) -> PcaVarResult { ///| /// Get contribution of variables to a specific dimension. -pub fn facto_var_contrib_dim(result : PcaResult, dim : Int) -> Array[(String, Double)] { +pub fn facto_var_contrib_dim( + result : PcaResult, + dim : Int, +) -> Array[(String, Double)] { let d = dim - 1 - if d < 0 || d >= result.n_dims { return [] } + if d < 0 || d >= result.n_dims { + return [] + } let contribs : Array[(String, Double)] = Array::new() let mut i = 0 while i < result.n_var { @@ -438,7 +518,9 @@ pub fn facto_var_contrib_dim(result : PcaResult, dim : Int) -> Array[(String, Do } j = j + 1 } - if !swapped { break } + if !swapped { + break + } iter = iter + 1 } contribs @@ -446,9 +528,14 @@ pub fn facto_var_contrib_dim(result : PcaResult, dim : Int) -> Array[(String, Do ///| /// Get contribution of individuals to a specific dimension. -pub fn facto_ind_contrib_dim(result : PcaResult, dim : Int) -> Array[(String, Double)] { +pub fn facto_ind_contrib_dim( + result : PcaResult, + dim : Int, +) -> Array[(String, Double)] { let d = dim - 1 - if d < 0 || d >= result.n_dims { return [] } + if d < 0 || d >= result.n_dims { + return [] + } let contribs : Array[(String, Double)] = Array::new() let mut i = 0 while i < result.n_ind { @@ -469,7 +556,9 @@ pub fn facto_ind_contrib_dim(result : PcaResult, dim : Int) -> Array[(String, Do } j = j + 1 } - if !swapped { break } + if !swapped { + break + } iter = iter + 1 } contribs @@ -477,9 +566,14 @@ pub fn facto_ind_contrib_dim(result : PcaResult, dim : Int) -> Array[(String, Do ///| /// Get cosine quality of representation for variables on a specific dimension. -pub fn facto_var_cos2_dim(result : PcaResult, dim : Int) -> Array[(String, Double)] { +pub fn facto_var_cos2_dim( + result : PcaResult, + dim : Int, +) -> Array[(String, Double)] { let d = dim - 1 - if d < 0 || d >= result.n_dims { return [] } + if d < 0 || d >= result.n_dims { + return [] + } let cos2s : Array[(String, Double)] = Array::new() let mut i = 0 while i < result.n_var { @@ -491,9 +585,14 @@ pub fn facto_var_cos2_dim(result : PcaResult, dim : Int) -> Array[(String, Doubl ///| /// Get cosine quality of representation for individuals on a specific dimension. -pub fn facto_ind_cos2_dim(result : PcaResult, dim : Int) -> Array[(String, Double)] { +pub fn facto_ind_cos2_dim( + result : PcaResult, + dim : Int, +) -> Array[(String, Double)] { let d = dim - 1 - if d < 0 || d >= result.n_dims { return [] } + if d < 0 || d >= result.n_dims { + return [] + } let cos2s : Array[(String, Double)] = Array::new() let mut i = 0 while i < result.n_ind { @@ -518,21 +617,33 @@ pub fn facto_dimdesc( dim : Int, ) -> Array[DimDesc] { let d = dim - 1 - if d < 0 || d >= result.n_dims { return [] } + if d < 0 || d >= result.n_dims { + return [] + } let n = data.length() let p = data[0].length() let desc : Array[DimDesc] = Array::new() let pc_scores : Array[Double] = Array::make(n, 0.0) let mut i = 0 - while i < n { pc_scores[i] = result.ind.coord[i][d]; i = i + 1 } + while i < n { + pc_scores[i] = result.ind.coord[i][d] + i = i + 1 + } let mut j = 0 while j < p { let var_vals : Array[Double] = Array::make(n, 0.0) let mut k = 0 - while k < n { var_vals[k] = data[k][j]; k = k + 1 } + while k < n { + var_vals[k] = data[k][j] + k = k + 1 + } let corr = facto_pearson_correlation(pc_scores, var_vals) let denom_base = 1.0 - corr * corr - let t_stat = if denom_base > 0.0 { corr * ((n.to_double() - 2.0) / denom_base).sqrt() } else { 0.0 } + let t_stat = if denom_base > 0.0 { + corr * ((n.to_double() - 2.0) / denom_base).sqrt() + } else { + 0.0 + } let p_val = if t_stat >= 0.0 { @math.exp(-t_stat) } else { 1.0 } desc.push(DimDesc::{ dimension: dim, @@ -548,8 +659,16 @@ pub fn facto_dimdesc( let mut swapped = false let mut l = 0 while l < n_desc - iter - 1 { - let abs_a = if desc[l].correlation < 0.0 { -desc[l].correlation } else { desc[l].correlation } - let abs_b = if desc[l + 1].correlation < 0.0 { -desc[l + 1].correlation } else { desc[l + 1].correlation } + let abs_a = if desc[l].correlation < 0.0 { + -desc[l].correlation + } else { + desc[l].correlation + } + let abs_b = if desc[l + 1].correlation < 0.0 { + -desc[l + 1].correlation + } else { + desc[l + 1].correlation + } if abs_a < abs_b { let tmp = desc[l] desc[l] = desc[l + 1] @@ -558,19 +677,28 @@ pub fn facto_dimdesc( } l = l + 1 } - if !swapped { break } + if !swapped { + break + } iter = iter + 1 } desc } +///| fn facto_pearson_correlation(x : Array[Double], y : Array[Double]) -> Double { let n = x.length() - if n < 3 { return 0.0 } + if n < 3 { + return 0.0 + } let mut mx = 0.0 let mut my = 0.0 let mut i = 0 - while i < n { mx = mx + x[i]; my = my + y[i]; i = i + 1 } + while i < n { + mx = mx + x[i] + my = my + y[i] + i = i + 1 + } mx = mx / n.to_double() my = my / n.to_double() let mut num = 0.0 @@ -586,7 +714,9 @@ fn facto_pearson_correlation(x : Array[Double], y : Array[Double]) -> Double { j = j + 1 } let denom = (dx * dy).sqrt() - if denom == 0.0 { return 0.0 } + if denom == 0.0 { + return 0.0 + } num / denom } @@ -607,7 +737,9 @@ pub fn facto_nb_dim(result : PcaResult, threshold : Double) -> Int { let mut i = 0 while i < result.eigenvalues.length() { cum = cum + result.eigenvalues[i].variance_explained - if cum >= threshold { return i + 1 } + if cum >= threshold { + return i + 1 + } i = i + 1 } result.eigenvalues.length() @@ -625,7 +757,11 @@ pub struct PcaSummary { ///| pub fn facto_summary(result : PcaResult) -> PcaSummary { let total = facto_total_inertia(result) - let first_var = if result.eigenvalues.length() > 0 { result.eigenvalues[0].variance_explained } else { 0.0 } + let first_var = if result.eigenvalues.length() > 0 { + result.eigenvalues[0].variance_explained + } else { + 0.0 + } PcaSummary::{ n_individuals: result.n_ind, n_variables: result.n_var, @@ -655,7 +791,9 @@ pub fn facto_print_summary(result : PcaResult) -> String { lines.push("") lines.push("Eigenvalues:") for ev in result.eigenvalues { - lines.push(" Dim \{ev.dimension}: eigenvalue=\{ev.eigenvalue}, var=\{ev.variance_explained}%, cum=\{ev.cumulative_variance}%") + lines.push( + " Dim \{ev.dimension}: eigenvalue=\{ev.eigenvalue}, var=\{ev.variance_explained}%, cum=\{ev.cumulative_variance}%", + ) } lines.join("\n") } diff --git a/src/fasta_search_io.mbt b/src/fasta_search_io.mbt index 94ec3442..6ee9a69a 100644 --- a/src/fasta_search_io.mbt +++ b/src/fasta_search_io.mbt @@ -281,9 +281,7 @@ pub fn parse_fasta_m8(content : String) -> Array[QueryResult] { hits.push(Hit::new(sid, "", "", hsps, tbs, mev)) ti = ti + 1 } - results.push( - QueryResult::new(qid, "", 0, hits, "fasta", "36", ""), - ) + results.push(QueryResult::new(qid, "", 0, hits, "fasta", "36", "")) qi = qi + 1 } @@ -476,8 +474,8 @@ fn fasta_sio_parse_row(ln : String) -> FastaRow { /// Generate a small FASTA `-m 8` (compact tabular) sample for tests and demos. pub fn fasta_m8_sample() -> String { "query1\tsubject1\t95.0\t100\t5\t0\t1\t100\t1\t100\t1e-50\t200.3\n" + - "query1\tsubject2\t80.0\t80\t16\t2\t1\t80\t10\t90\t1e-30\t150.1\n" + - "query2\tsubject1\t70.0\t60\t18\t3\t1\t60\t5\t65\t1e-20\t100.5\n" + "query1\tsubject2\t80.0\t80\t16\t2\t1\t80\t10\t90\t1e-30\t150.1\n" + + "query2\tsubject1\t70.0\t60\t18\t3\t1\t60\t5\t65\t1e-20\t100.5\n" } ///| @@ -485,11 +483,11 @@ pub fn fasta_m8_sample() -> String { /// for tests and demos. pub fn fasta_m9_sample() -> String { "# FASTA 36.3.8h May 10, 2023\n" + - "# Query: query1 - example query 1\n" + - "# Database: uniprot_sprot.fasta\n" + - "# Fields: query id, subject id, % identity, alignment length, mismatches, gap openings, q.start, q.end, s.start, s.end, e-value, bit score\n" + - "query1\tsubject1\t95.0\t100\t5\t0\t1\t100\t1\t100\t1e-50\t200.3\n" + - "query1\tsubject2\t80.0\t80\t16\t2\t1\t80\t10\t90\t1e-30\t150.1\n" + - "# Query: query2 - example query 2\n" + - "query2\tsubject1\t70.0\t60\t18\t3\t1\t60\t5\t65\t1e-20\t100.5\n" + "# Query: query1 - example query 1\n" + + "# Database: uniprot_sprot.fasta\n" + + "# Fields: query id, subject id, % identity, alignment length, mismatches, gap openings, q.start, q.end, s.start, s.end, e-value, bit score\n" + + "query1\tsubject1\t95.0\t100\t5\t0\t1\t100\t1\t100\t1e-50\t200.3\n" + + "query1\tsubject2\t80.0\t80\t16\t2\t1\t80\t10\t90\t1e-30\t150.1\n" + + "# Query: query2 - example query 2\n" + + "query2\tsubject1\t70.0\t60\t18\t3\t1\t60\t5\t65\t1e-20\t100.5\n" } diff --git a/src/feature_counts.mbt b/src/feature_counts.mbt index f94734f4..31d71869 100644 --- a/src/feature_counts.mbt +++ b/src/feature_counts.mbt @@ -73,8 +73,13 @@ pub fn FeatureAnnotation::new( feature_id } FeatureAnnotation::{ - chr, start, end_, strand, gene_id, - transcript_id, feature_type, + chr, + start, + end_, + strand, + gene_id, + transcript_id, + feature_type, feature_id: fid, } } @@ -82,7 +87,11 @@ pub fn FeatureAnnotation::new( ///| /// Get the length of the feature. pub fn FeatureAnnotation::length(self : FeatureAnnotation) -> Int { - if self.end_ > self.start { self.end_ - self.start + 1 } else { 0 } + if self.end_ > self.start { + self.end_ - self.start + 1 + } else { + 0 + } } ///| @@ -93,7 +102,9 @@ pub fn FeatureAnnotation::overlaps( start~ : Int, end_~ : Int, ) -> Bool { - if self.chr != chr { return false } + if self.chr != chr { + return false + } self.start <= end_ && self.end_ >= start } @@ -105,10 +116,16 @@ pub fn FeatureAnnotation::overlap_length( start~ : Int, end_~ : Int, ) -> Int { - if self.chr != chr { return 0 } + if self.chr != chr { + return 0 + } let ov_start = if self.start > start { self.start } else { start } let ov_end = if self.end_ < end_ { self.end_ } else { end_ } - if ov_end >= ov_start { ov_end - ov_start + 1 } else { 0 } + if ov_end >= ov_start { + ov_end - ov_start + 1 + } else { + 0 + } } ///| @@ -149,7 +166,12 @@ pub fn ReadAlignment::new( mapq? : Int = 60, ) -> ReadAlignment { ReadAlignment::{ - read_id, chr, start, end_, strand, mapq, + read_id, + chr, + start, + end_, + strand, + mapq, n_alignments: 1, is_paired: false, mate_chr: "", @@ -171,15 +193,28 @@ pub fn ReadAlignment::new_paired( mate_start? : Int = 0, ) -> ReadAlignment { let frag_len = if mate_start > 0 { - if mate_start > end_ { mate_start - start + 1 } else { end_ - mate_start + 1 } + if mate_start > end_ { + mate_start - start + 1 + } else { + end_ - mate_start + 1 + } } else { 0 } ReadAlignment::{ - read_id, chr, start, end_, strand, mapq, + read_id, + chr, + start, + end_, + strand, + mapq, n_alignments: 1, is_paired: true, - mate_chr: if mate_chr == "" { chr } else { mate_chr }, + mate_chr: if mate_chr == "" { + chr + } else { + mate_chr + }, mate_start, fragment_length: frag_len, } @@ -192,8 +227,16 @@ pub fn ReadAlignment::fragment_span(self : ReadAlignment) -> (String, Int, Int) return (self.chr, self.start, self.end_) } if self.chr == self.mate_chr { - let f_start = if self.start < self.mate_start { self.start } else { self.mate_start } - let f_end = if self.end_ > self.mate_start { self.end_ } else { self.mate_start } + let f_start = if self.start < self.mate_start { + self.start + } else { + self.mate_start + } + let f_end = if self.end_ > self.mate_start { + self.end_ + } else { + self.mate_start + } (self.chr, f_start, f_end) } else { (self.chr, self.start, self.end_) @@ -244,7 +287,10 @@ pub fn FeatureCountsConfig::new() -> FeatureCountsConfig { ///| /// Set minimum overlap (returns new config). -pub fn FeatureCountsConfig::set_min_overlap(self : FeatureCountsConfig, val~ : Int) -> FeatureCountsConfig { +pub fn FeatureCountsConfig::set_min_overlap( + self : FeatureCountsConfig, + val~ : Int, +) -> FeatureCountsConfig { FeatureCountsConfig::{ min_overlap: val, min_overlap_total: self.min_overlap_total, @@ -261,7 +307,10 @@ pub fn FeatureCountsConfig::set_min_overlap(self : FeatureCountsConfig, val~ : I ///| /// Set strand mode (returns new config). -pub fn FeatureCountsConfig::set_strand_mode(self : FeatureCountsConfig, mode~ : StrandMode) -> FeatureCountsConfig { +pub fn FeatureCountsConfig::set_strand_mode( + self : FeatureCountsConfig, + mode~ : StrandMode, +) -> FeatureCountsConfig { FeatureCountsConfig::{ min_overlap: self.min_overlap, min_overlap_total: self.min_overlap_total, @@ -278,7 +327,10 @@ pub fn FeatureCountsConfig::set_strand_mode(self : FeatureCountsConfig, mode~ : ///| /// Set minimum mapping quality (returns new config). -pub fn FeatureCountsConfig::set_min_mapq(self : FeatureCountsConfig, val~ : Int) -> FeatureCountsConfig { +pub fn FeatureCountsConfig::set_min_mapq( + self : FeatureCountsConfig, + val~ : Int, +) -> FeatureCountsConfig { FeatureCountsConfig::{ min_overlap: self.min_overlap, min_overlap_total: self.min_overlap_total, @@ -295,7 +347,10 @@ pub fn FeatureCountsConfig::set_min_mapq(self : FeatureCountsConfig, val~ : Int) ///| /// Set count fragments flag (returns new config). -pub fn FeatureCountsConfig::set_count_fragments(self : FeatureCountsConfig, val~ : Bool) -> FeatureCountsConfig { +pub fn FeatureCountsConfig::set_count_fragments( + self : FeatureCountsConfig, + val~ : Bool, +) -> FeatureCountsConfig { FeatureCountsConfig::{ min_overlap: self.min_overlap, min_overlap_total: self.min_overlap_total, @@ -312,7 +367,10 @@ pub fn FeatureCountsConfig::set_count_fragments(self : FeatureCountsConfig, val~ ///| /// Set multi-count flag (returns new config). -pub fn fcfg_set_multi_count(cfg : FeatureCountsConfig, val~ : Bool) -> FeatureCountsConfig { +pub fn fcfg_set_multi_count( + cfg : FeatureCountsConfig, + val~ : Bool, +) -> FeatureCountsConfig { FeatureCountsConfig::{ min_overlap: cfg.min_overlap, min_overlap_total: cfg.min_overlap_total, @@ -374,8 +432,12 @@ pub fn FeatureCountsResult::get_count( sample_idx~ : Int, ) -> Double { let fi = fc_feature_index(self, feature_id) - if fi < 0 { return 0.0 } - if sample_idx < 0 || sample_idx >= self.counts.length() { return 0.0 } + if fi < 0 { + return 0.0 + } + if sample_idx < 0 || sample_idx >= self.counts.length() { + return 0.0 + } self.counts[sample_idx][fi] } @@ -385,7 +447,9 @@ pub fn FeatureCountsResult::library_size( self : FeatureCountsResult, sample_idx~ : Int, ) -> Double { - if sample_idx < 0 || sample_idx >= self.counts.length() { return 0.0 } + if sample_idx < 0 || sample_idx >= self.counts.length() { + return 0.0 + } let mut total = 0.0 let mut i = 0 while i < self.counts[sample_idx].length() { @@ -402,9 +466,13 @@ pub fn FeatureCountsResult::cpm( feature_id~ : String, sample_idx~ : Int, ) -> Double { - let raw = self.get_count(feature_id=feature_id, sample_idx=sample_idx) - let lib = self.library_size(sample_idx=sample_idx) - if lib == 0.0 { 0.0 } else { raw / lib * 1_000_000.0 } + let raw = self.get_count(feature_id~, sample_idx~) + let lib = self.library_size(sample_idx~) + if lib == 0.0 { + 0.0 + } else { + raw / lib * 1_000_000.0 + } } ///| @@ -414,7 +482,9 @@ pub fn FeatureCountsResult::get_feature_total( feature_id~ : String, ) -> Double { let fi = fc_feature_index(self, feature_id) - if fi < 0 { return 0.0 } + if fi < 0 { + return 0.0 + } let mut total = 0.0 let mut i = 0 while i < self.counts.length() { @@ -437,9 +507,23 @@ pub fn FeatureCountsResult::summary(self : FeatureCountsResult) -> String { let assigned = self.assigned_reads[i] let pct = if total > 0 { (assigned.to_double() / total.to_double() * 100.0).to_string() + "%" - } else { "0.0%" } - s = s + " " + name + ": total=" + total.to_string() + ", assigned=" + assigned.to_string() + " (" + pct + ")" + "\n" - s = s + " Unassigned: no_features=" + self.unassigned_no_features[i].to_string() + } else { + "0.0%" + } + s = s + + " " + + name + + ": total=" + + total.to_string() + + ", assigned=" + + assigned.to_string() + + " (" + + pct + + ")" + + "\n" + s = s + + " Unassigned: no_features=" + + self.unassigned_no_features[i].to_string() s = s + ", ambiguous=" + self.unassigned_ambiguous[i].to_string() s = s + ", multi=" + self.unassigned_multi[i].to_string() s = s + ", low_quality=" + self.unassigned_low_quality[i].to_string() + "\n" @@ -453,7 +537,11 @@ pub fn FeatureCountsResult::summary(self : FeatureCountsResult) -> String { pub fn FeatureCountsResult::to_string(self : FeatureCountsResult) -> String { let mut s = self.summary() s = s + "\n=== Count Matrix (first 10 features) ===" + "\n" - let n_features = if self.feature_ids.length() < 10 { self.feature_ids.length() } else { 10 } + let n_features = if self.feature_ids.length() < 10 { + self.feature_ids.length() + } else { + 10 + } let mut i = 0 while i < n_features { let fid = self.feature_ids[i] @@ -479,7 +567,11 @@ pub fn feature_counts_count( ) -> FeatureCountsResult { let n_features = features.length() let n_reads = reads.length() - let n_samples = if sample_names.length() > 0 { sample_names.length() } else { 1 } + let n_samples = if sample_names.length() > 0 { + sample_names.length() + } else { + 1 + } let feat_ids : Array[String] = Array::new() let gene_ids : Array[String] = Array::new() @@ -539,7 +631,8 @@ pub fn feature_counts_count( total_reads[sample_idx] = total_reads[sample_idx] + 1 if read.mapq < config.min_mapq { - unassigned_low_quality[sample_idx] = unassigned_low_quality[sample_idx] + 1 + unassigned_low_quality[sample_idx] = unassigned_low_quality[sample_idx] + + 1 r = r + 1 continue } @@ -556,19 +649,35 @@ pub fn feature_counts_count( let mut fi = 0 while fi < n_features { let feat = features[fi] - if feat.chr != f_chr { fi = fi + 1; continue } + if feat.chr != f_chr { + fi = fi + 1 + continue + } let ov_len = feat.overlap_length(chr=f_chr, start=f_start, end_=f_end) - if ov_len < config.min_overlap { fi = fi + 1; continue } + if ov_len < config.min_overlap { + fi = fi + 1 + continue + } if config.frac_overlap > 0.0 { let frac = ov_len.to_double() / read_len.to_double() - if frac < config.frac_overlap { fi = fi + 1; continue } + if frac < config.frac_overlap { + fi = fi + 1 + continue + } } if !config.ignore_strand { - let strand_match = fc_check_strand_match(feat.strand, read.strand, config.strand_mode) - if !strand_match { fi = fi + 1; continue } + let strand_match = fc_check_strand_match( + feat.strand, + read.strand, + config.strand_mode, + ) + if !strand_match { + fi = fi + 1 + continue + } } overlapping.push((fi, ov_len)) @@ -576,7 +685,8 @@ pub fn feature_counts_count( } if overlapping.length() == 0 { - unassigned_no_features[sample_idx] = unassigned_no_features[sample_idx] + 1 + unassigned_no_features[sample_idx] = unassigned_no_features[sample_idx] + + 1 r = r + 1 continue } @@ -608,7 +718,7 @@ pub fn feature_counts_count( FeatureCountsResult::{ feature_ids: feat_ids, - gene_ids: gene_ids, + gene_ids, counts, sample_names: sn, total_reads, @@ -623,33 +733,87 @@ pub fn feature_counts_count( ///| /// Create sample data for testing. -pub fn feature_counts_sample_data() -> (Array[FeatureAnnotation], Array[ReadAlignment], Array[String]) { +pub fn feature_counts_sample_data() -> ( + Array[FeatureAnnotation], + Array[ReadAlignment], + Array[String], +) { let features : Array[FeatureAnnotation] = Array::new() - features.push(FeatureAnnotation::new( - chr="chr1", start=1000, end_=2000, strand="+", gene_id="GeneA", - feature_id="exon_A1", - )) - features.push(FeatureAnnotation::new( - chr="chr1", start=3000, end_=5000, strand="+", gene_id="GeneA", - feature_id="exon_A2", - )) - features.push(FeatureAnnotation::new( - chr="chr1", start=6000, end_=8000, strand="-", gene_id="GeneB", - feature_id="exon_B1", - )) - features.push(FeatureAnnotation::new( - chr="chr2", start=1000, end_=3000, strand="+", gene_id="GeneC", - feature_id="exon_C1", - )) + features.push( + FeatureAnnotation::new( + chr="chr1", + start=1000, + end_=2000, + strand="+", + gene_id="GeneA", + feature_id="exon_A1", + ), + ) + features.push( + FeatureAnnotation::new( + chr="chr1", + start=3000, + end_=5000, + strand="+", + gene_id="GeneA", + feature_id="exon_A2", + ), + ) + features.push( + FeatureAnnotation::new( + chr="chr1", + start=6000, + end_=8000, + strand="-", + gene_id="GeneB", + feature_id="exon_B1", + ), + ) + features.push( + FeatureAnnotation::new( + chr="chr2", + start=1000, + end_=3000, + strand="+", + gene_id="GeneC", + feature_id="exon_C1", + ), + ) let reads : Array[ReadAlignment] = Array::new() - reads.push(ReadAlignment::new(read_id="read1", chr="chr1", start=1500, end_=1600)) - reads.push(ReadAlignment::new(read_id="read2", chr="chr1", start=3500, end_=3600)) - reads.push(ReadAlignment::new(read_id="read3", chr="chr1", start=6500, end_=6600, strand="-")) - reads.push(ReadAlignment::new(read_id="read4", chr="chr2", start=1500, end_=1600)) - reads.push(ReadAlignment::new(read_id="read5", chr="chr1", start=1500, end_=1600, mapq=30)) - reads.push(ReadAlignment::new(read_id="read6", chr="chr3", start=1000, end_=1100)) - reads.push(ReadAlignment::new(read_id="read7", chr="chr1", start=1700, end_=1800)) + reads.push( + ReadAlignment::new(read_id="read1", chr="chr1", start=1500, end_=1600), + ) + reads.push( + ReadAlignment::new(read_id="read2", chr="chr1", start=3500, end_=3600), + ) + reads.push( + ReadAlignment::new( + read_id="read3", + chr="chr1", + start=6500, + end_=6600, + strand="-", + ), + ) + reads.push( + ReadAlignment::new(read_id="read4", chr="chr2", start=1500, end_=1600), + ) + reads.push( + ReadAlignment::new( + read_id="read5", + chr="chr1", + start=1500, + end_=1600, + mapq=30, + ), + ) + reads.push( + ReadAlignment::new(read_id="read6", chr="chr3", start=1000, end_=1100), + ) + reads.push( + ReadAlignment::new(read_id="read7", chr="chr1", start=1700, end_=1800), + ) let sample_names : Array[String] = Array::new() sample_names.push("sample_1") @@ -659,23 +823,35 @@ pub fn feature_counts_sample_data() -> (Array[FeatureAnnotation], Array[ReadAlig // --- Internal helpers --- +///| fn fc_feature_index(result : FeatureCountsResult, feature_id : String) -> Int { let mut i = 0 while i < result.feature_ids.length() { - if result.feature_ids[i] == feature_id { return i } + if result.feature_ids[i] == feature_id { + return i + } i = i + 1 } -1 } -fn fc_check_strand_match(feature_strand : String, read_strand : String, mode : StrandMode) -> Bool { - if feature_strand == "*" { return true } +///| +fn fc_check_strand_match( + feature_strand : String, + read_strand : String, + mode : StrandMode, +) -> Bool { + if feature_strand == "*" { + return true + } match mode { StrandMode::Unstranded => true StrandMode::Stranded => feature_strand == read_strand - StrandMode::Reversed => { - if feature_strand == "+" { read_strand == "-" } - else { read_strand == "+" } - } + StrandMode::Reversed => + if feature_strand == "+" { + read_strand == "-" + } else { + read_strand == "+" + } } } diff --git a/src/file.mbt b/src/file.mbt index bec5b40d..3f3bee37 100644 --- a/src/file.mbt +++ b/src/file.mbt @@ -13,9 +13,12 @@ ///| /// Supported file compression formats. pub enum CompressionFormat { - Plain /// No compression (plain text) - Gzip /// gzip compression (.gz) - Bzip2 /// bzip2 compression (.bz2) + /// No compression (plain text) + /// gzip compression (.gz) + /// bzip2 compression (.bz2) + Plain + Gzip + Bzip2 } ///| @@ -45,16 +48,21 @@ pub fn CompressionFormat::to_string(self : CompressionFormat) -> String { CompressionFormat::Bzip2 => "bzip2" } } + ///| /// A smart file handle with automatic compression detection. pub struct SmartFile { path : String format : CompressionFormat - mode : String /// "r" for read, "w" for write + /// "r" for read, "w" for write + mode : String is_open : Bool - lines : Array[String] /// buffered lines for reading - pos : Int /// current read position - written_content : String /// accumulated content for writing + /// buffered lines for reading + /// current read position + /// accumulated content for writing + lines : Array[String] + pos : Int + written_content : String } ///| @@ -251,7 +259,10 @@ pub fn SmartFile::get_written_content(self : SmartFile) -> String { ///| /// Set pre-loaded lines (for testing/simulation purposes). /// In a real implementation, this would be handled by open() reading the file. -pub fn SmartFile::set_lines(self : SmartFile, lines : Array[String]) -> SmartFile { +pub fn SmartFile::set_lines( + self : SmartFile, + lines : Array[String], +) -> SmartFile { SmartFile::{ path: self.path, format: self.format, @@ -284,7 +295,10 @@ pub fn smart_file_from_lines(path : String, lines : Array[String]) -> SmartFile ///| /// Create a write-mode SmartFile. -pub fn smart_file_writer(path : String, format? : CompressionFormat = CompressionFormat::Plain) -> SmartFile { +pub fn smart_file_writer( + path : String, + format? : CompressionFormat = CompressionFormat::Plain, +) -> SmartFile { SmartFile::with_format(path, format, mode="w") } @@ -295,7 +309,16 @@ pub fn SmartFile::summary(self : SmartFile) -> String { let mode_str = self.mode let state = if self.is_open { "open" } else { "closed" } let n_lines = self.lines.length() - "SmartFile: " + self.path + " | format=" + format_str + " | mode=" + mode_str + " | " + state + " | lines=" + n_lines.to_string() + "SmartFile: " + + self.path + + " | format=" + + format_str + + " | mode=" + + mode_str + + " | " + + state + + " | lines=" + + n_lines.to_string() } ///| diff --git a/src/fishpond.mbt b/src/fishpond.mbt index ed2fe3e3..10220b0b 100644 --- a/src/fishpond.mbt +++ b/src/fishpond.mbt @@ -202,7 +202,11 @@ pub fn fish_log2fc_test( let control_mean = stat_mean(control_vals) // Add pseudocount of 1 to avoid log(0) let case_log = if case_mean > 0.0 { @math.log2(case_mean + 1.0) } else { 0.0 } - let control_log = if control_mean > 0.0 { @math.log2(control_mean + 1.0) } else { 0.0 } + let control_log = if control_mean > 0.0 { + @math.log2(control_mean + 1.0) + } else { + 0.0 + } case_log - control_log } @@ -331,14 +335,19 @@ pub fn fish_swish( perm_count = perm_count + 1 } } - p_values[t] = (perm_count.to_double() + 1.0) / (n_permutations.to_double() + 1.0) + p_values[t] = (perm_count.to_double() + 1.0) / + (n_permutations.to_double() + 1.0) } // BH-FDR correction let fdrs = stat_bh(p_values) // Build results for t in 0.. 0.0 { "up" } else { "down" } + if log2fcs[t] > 0.0 { + "up" + } else { + "down" + } } else { "ns" } @@ -378,12 +387,12 @@ pub fn fish_sample_counts() -> FishCounts { "TX1", "TX2", "TX3", "TX4", "TX5", "TX6", "TX7", "TX8", "TX9", "TX10", ] let sample_names = [ - "case1", "case2", "case3", "case4", "case5", "case6", "case7", "case8", - "ctrl1", "ctrl2", "ctrl3", "ctrl4", "ctrl5", "ctrl6", "ctrl7", "ctrl8", + "case1", "case2", "case3", "case4", "case5", "case6", "case7", "case8", "ctrl1", + "ctrl2", "ctrl3", "ctrl4", "ctrl5", "ctrl6", "ctrl7", "ctrl8", ] let condition = [ - "case", "case", "case", "case", "case", "case", "case", "case", - "control", "control", "control", "control", "control", "control", "control", "control", + "case", "case", "case", "case", "case", "case", "case", "case", "control", "control", + "control", "control", "control", "control", "control", "control", ] // transcript × sample counts (10 × 16) let counts : Array[Array[Double]] = [] @@ -391,7 +400,11 @@ pub fn fish_sample_counts() -> FishCounts { for t in 0..<3 { let row : Array[Double] = [] for s in 0..<16 { - let val = if s < 8 { 50.0 + t.to_double() * 10.0 + s.to_double() * 2.0 } else { 10.0 + (s - 8).to_double() * 1.0 } + let val = if s < 8 { + 50.0 + t.to_double() * 10.0 + s.to_double() * 2.0 + } else { + 10.0 + (s - 8).to_double() * 1.0 + } row.push(val) } counts.push(row) @@ -400,7 +413,11 @@ pub fn fish_sample_counts() -> FishCounts { for t in 0..<3 { let row : Array[Double] = [] for s in 0..<16 { - let val = if s < 8 { 10.0 + s.to_double() * 1.0 } else { 50.0 + t.to_double() * 10.0 + (s - 8).to_double() * 2.0 } + let val = if s < 8 { + 10.0 + s.to_double() * 1.0 + } else { + 50.0 + t.to_double() * 10.0 + (s - 8).to_double() * 2.0 + } row.push(val) } counts.push(row) @@ -441,16 +458,38 @@ pub fn fish_significant( ///| /// Format a FishResult as a readable string. pub fn FishResult::to_string(self : FishResult) -> String { - self.transcript + " log2FC=" + self.log2_fold_change.to_string() + " p=" + self.p_value.to_string() + " fdr=" + self.fdr.to_string() + " dir=" + self.direction + self.transcript + + " log2FC=" + + self.log2_fold_change.to_string() + + " p=" + + self.p_value.to_string() + + " fdr=" + + self.fdr.to_string() + + " dir=" + + self.direction } ///| /// Format all results as a table. pub fn fish_results_to_string(results : Array[FishResult]) -> String { - let mut s = "Swish Results (" + results.length().to_string() + " transcripts)\n" + let mut s = "Swish Results (" + + results.length().to_string() + + " transcripts)\n" s = s + "transcript\tstatistic\tlog2FC\tp_value\tfdr\tdirection\n" for r in results { - s = s + r.transcript + "\t" + r.statistic.to_string() + "\t" + r.log2_fold_change.to_string() + "\t" + r.p_value.to_string() + "\t" + r.fdr.to_string() + "\t" + r.direction + "\n" + s = s + + r.transcript + + "\t" + + r.statistic.to_string() + + "\t" + + r.log2_fold_change.to_string() + + "\t" + + r.p_value.to_string() + + "\t" + + r.fdr.to_string() + + "\t" + + r.direction + + "\n" } s } diff --git a/src/fragment_mapper.mbt b/src/fragment_mapper.mbt index d740209e..777a1cd3 100644 --- a/src/fragment_mapper.mbt +++ b/src/fragment_mapper.mbt @@ -17,18 +17,41 @@ pub enum FragmentType { Turn } derive(Eq, Debug) -///| Construct a Helix FragmentType. -pub fn ft_helix() -> FragmentType { Helix } -///| Construct a Sheet FragmentType. -pub fn ft_sheet() -> FragmentType { Sheet } -///| Construct a Loop FragmentType. -pub fn ft_loop() -> FragmentType { Loop } -///| Construct a Coil FragmentType. -pub fn ft_coil() -> FragmentType { Coil } -///| Construct a Bridge FragmentType. -pub fn ft_bridge() -> FragmentType { Bridge } -///| Construct a Turn FragmentType. -pub fn ft_turn() -> FragmentType { Turn } +///| +/// Construct a Helix FragmentType. +pub fn ft_helix() -> FragmentType { + Helix +} + +///| +/// Construct a Sheet FragmentType. +pub fn ft_sheet() -> FragmentType { + Sheet +} + +///| +/// Construct a Loop FragmentType. +pub fn ft_loop() -> FragmentType { + Loop +} + +///| +/// Construct a Coil FragmentType. +pub fn ft_coil() -> FragmentType { + Coil +} + +///| +/// Construct a Bridge FragmentType. +pub fn ft_bridge() -> FragmentType { + Bridge +} + +///| +/// Construct a Turn FragmentType. +pub fn ft_turn() -> FragmentType { + Turn +} ///| /// A single residue within a fragment. @@ -273,11 +296,7 @@ pub fn fm_assign_fragments( let residues : Array[FragmentResidue] = Array::new() let mut j = start while j <= end { - let res_name = if j < seq_len { - char_at(sequence, j) - } else { - "X" - } + let res_name = if j < seq_len { char_at(sequence, j) } else { "X" } residues.push(FragmentResidue::{ res_name, res_num: j + 1, @@ -354,7 +373,7 @@ pub fn fm_parse_fragments(content : String) -> FragmentMapperResult { atom_count: prev.atom_count + 1, is_c_alpha: prev.is_c_alpha || atom_name == "CA", is_sidechain: prev.is_sidechain || - !(atom_name == "N" || atom_name == "CA" || atom_name == "C"), + !(atom_name == "N" || atom_name == "CA" || atom_name == "C"), } residue_map[key] = updated let chain_res = chain_map.get(chain_id) @@ -376,7 +395,9 @@ pub fn fm_parse_fragments(content : String) -> FragmentMapperResult { } None => { let is_ca = atom_name == "CA" - let is_sc = !(atom_name == "N" || atom_name == "CA" || atom_name == "C") + let is_sc = !(atom_name == "N" || + atom_name == "CA" || + atom_name == "C") let new_res = FragmentResidue::{ res_name, res_num, @@ -393,9 +414,7 @@ pub fn fm_parse_fragments(content : String) -> FragmentMapperResult { new_arr.push(new_res) chain_map[chain_id] = new_arr } - None => { - chain_map[chain_id] = [new_res] - } + None => chain_map[chain_id] = [new_res] } sequence = sequence + _three_to_one(res_name) @@ -465,10 +484,7 @@ fn _sort_by_resnum(residues : Array[FragmentResidue]) -> Array[FragmentResidue] ///| /// Get a fragment by its ID string. Returns None if not found. -pub fn fm_get_fragment( - result : FragmentMapperResult, - id : String, -) -> Fragment? { +pub fn fm_get_fragment(result : FragmentMapperResult, id : String) -> Fragment? { for frag in result.fragments { if frag.id == id { return Some(frag) @@ -556,10 +572,11 @@ fn _sort_fragments_by_position(fragments : Array[Fragment]) -> Array[Fragment] { let key = result[i] let mut j = i - 1 while j >= 0 { - let should_swap = - result[j].start_residue > key.start_residue || - (result[j].start_residue == key.start_residue && - result[j].chain_id > key.chain_id) + let should_swap = result[j].start_residue > key.start_residue || + ( + result[j].start_residue == key.start_residue && + result[j].chain_id > key.chain_id + ) if should_swap { result[j + 1] = result[j] j = j - 1 @@ -603,4 +620,4 @@ pub fn fm_filter_by_length( } } result -} \ No newline at end of file +} diff --git a/src/freq_analysis.mbt b/src/freq_analysis.mbt index db334e1c..2b0c0fb7 100644 --- a/src/freq_analysis.mbt +++ b/src/freq_analysis.mbt @@ -16,32 +16,40 @@ pub struct FreqAnalysisResult { pub fn FreqAnalysisResult::new( frequencies : Map[String, Double], counts : Map[String, Int], - total_count : Int + total_count : Int, ) -> FreqAnalysisResult { FreqAnalysisResult::{ frequencies, counts, total_count } } ///| /// Get frequency for a given pattern. -pub fn fa_get_frequency(self : FreqAnalysisResult, pattern : String) -> Double { +pub fn FreqAnalysisResult::fa_get_frequency( + self : FreqAnalysisResult, + pattern : String, +) -> Double { self.frequencies.get_or_default(pattern, 0.0) } ///| /// Get count for a given pattern. -pub fn fa_get_count(self : FreqAnalysisResult, pattern : String) -> Int { +pub fn FreqAnalysisResult::fa_get_count( + self : FreqAnalysisResult, + pattern : String, +) -> Int { self.counts.get_or_default(pattern, 0) } ///| /// Get total count. -pub fn fa_get_total_count(self : FreqAnalysisResult) -> Int { +pub fn FreqAnalysisResult::fa_get_total_count(self : FreqAnalysisResult) -> Int { self.total_count } ///| /// Get all patterns. -pub fn fa_get_patterns(self : FreqAnalysisResult) -> Array[String] { +pub fn FreqAnalysisResult::fa_get_patterns( + self : FreqAnalysisResult, +) -> Array[String] { let patterns : Array[String] = Array::new() for key in self.frequencies.keys() { patterns.push(key) @@ -56,7 +64,7 @@ pub fn fa_count_pattern(sequence : String, pattern : String) -> Int { if pattern_len == 0 || sequence.length() < pattern_len { return 0 } - + let mut count = 0 let mut pos = 0 while pos <= sequence.length() - pattern_len { @@ -74,11 +82,11 @@ pub fn fa_count_pattern(sequence : String, pattern : String) -> Int { pub fn fa_count_kmers(sequence : String, k : Int) -> FreqAnalysisResult { let counts : Map[String, Int] = Map([], capacity=100) let seq_len = sequence.length() - + if seq_len < k { return FreqAnalysisResult::new(Map([], capacity=0), Map([], capacity=0), 0) } - + let mut total = 0 let mut pos = 0 while pos <= seq_len - k { @@ -88,13 +96,13 @@ pub fn fa_count_kmers(sequence : String, k : Int) -> FreqAnalysisResult { total = total + 1 pos = pos + 1 } - + let frequencies : Map[String, Double] = Map([], capacity=counts.length()) for key in counts.keys() { let count = counts.get_or_default(key, 0) frequencies.set(key, count.to_double() / total.to_double()) } - + FreqAnalysisResult::new(frequencies, counts, total) } @@ -121,7 +129,7 @@ pub fn fa_trinucleotide_frequency(sequence : String) -> FreqAnalysisResult { /// Expected dinucleotide frequency = freq(A) * freq(B) pub fn fa_expected_dinucleotide_freq( mono_freqs : FreqAnalysisResult, - dinuc : String + dinuc : String, ) -> Double { if dinuc.length() != 2 { return 0.0 @@ -140,20 +148,18 @@ pub fn fa_dinucleotide_oe_ratio(sequence : String) -> Map[String, Double] { let mono = fa_nucleotide_frequency(sequence) let dinuc = fa_dinucleotide_frequency(sequence) let ratios : Map[String, Double] = Map([], capacity=16) - + let dinucleotides = [ - "AA", "AC", "AG", "AT", - "CA", "CC", "CG", "CT", - "GA", "GC", "GG", "GT", - "TA", "TC", "TG", "TT" + "AA", "AC", "AG", "AT", "CA", "CC", "CG", "CT", "GA", "GC", "GG", "GT", "TA", + "TC", "TG", "TT", ] - + let mut i = 0 while i < dinucleotides.length() { let dinuc_name = dinucleotides[i] let obs_freq = dinuc.fa_get_frequency(dinuc_name) let exp_freq = fa_expected_dinucleotide_freq(mono, dinuc_name) - + if exp_freq > 0.0 { ratios.set(dinuc_name, obs_freq / exp_freq) } else { @@ -161,7 +167,7 @@ pub fn fa_dinucleotide_oe_ratio(sequence : String) -> Map[String, Double] { } i = i + 1 } - + ratios } @@ -170,11 +176,11 @@ pub fn fa_dinucleotide_oe_ratio(sequence : String) -> Map[String, Double] { pub fn fa_codon_usage(sequence : String) -> FreqAnalysisResult { let counts : Map[String, Int] = Map([], capacity=64) let seq_len = sequence.length() - + if seq_len < 3 { return FreqAnalysisResult::new(Map([], capacity=0), Map([], capacity=0), 0) } - + let mut total = 0 let mut pos = 0 while pos <= seq_len - 3 { @@ -184,59 +190,65 @@ pub fn fa_codon_usage(sequence : String) -> FreqAnalysisResult { total = total + 1 pos = pos + 3 } - + let frequencies : Map[String, Double] = Map([], capacity=counts.length()) for key in counts.keys() { let count = counts.get_or_default(key, 0) frequencies.set(key, count.to_double() / total.to_double()) } - + FreqAnalysisResult::new(frequencies, counts, total) } ///| /// Calculate chi-square statistic comparing observed and expected frequencies. -pub fn fa_chi_square_test(observed : FreqAnalysisResult, expected : FreqAnalysisResult) -> Double { +pub fn fa_chi_square_test( + observed : FreqAnalysisResult, + expected : FreqAnalysisResult, +) -> Double { let patterns = observed.fa_get_patterns() let df = patterns.length() - 1 - + if df <= 0 { return 0.0 } - + let total_obs = observed.fa_get_total_count().to_double() let total_exp = expected.fa_get_total_count().to_double() - + let mut chi2 = 0.0 let mut i = 0 while i < patterns.length() { let pattern = patterns[i] let obs_freq = observed.fa_get_frequency(pattern) let exp_freq = expected.fa_get_frequency(pattern) - + let obs_count = obs_freq * total_obs let exp_count = exp_freq * total_exp - + if exp_count > 0.0 { let diff = obs_count - exp_count chi2 = chi2 + diff * diff / exp_count } i = i + 1 } - + chi2 } ///| /// Find the most overrepresented k-mer in a sequence. -pub fn fa_find_overrepresented(sequence : String, k : Int) -> Map[String, Double] { +pub fn fa_find_overrepresented( + sequence : String, + k : Int, +) -> Map[String, Double] { let counts : Map[String, Int] = Map([], capacity=100) let seq_len = sequence.length() - + if seq_len < k { return Map([], capacity=0) } - + let mut total = 0 let mut pos = 0 while pos <= seq_len - k { @@ -246,7 +258,7 @@ pub fn fa_find_overrepresented(sequence : String, k : Int) -> Map[String, Double total = total + 1 pos = pos + 1 } - + // Calculate expected frequency (1/4^k for uniform distribution) let mut expected_freq = 1.0 let mut i = 0 @@ -254,7 +266,7 @@ pub fn fa_find_overrepresented(sequence : String, k : Int) -> Map[String, Double expected_freq = expected_freq / 4.0 i = i + 1 } - + let results : Map[String, Double] = Map([], capacity=counts.length()) for key in counts.keys() { let count = counts.get_or_default(key, 0) @@ -264,7 +276,7 @@ pub fn fa_find_overrepresented(sequence : String, k : Int) -> Map[String, Double results.set(key, ratio) } } - + results } @@ -274,11 +286,11 @@ pub fn fa_find_motif(sequence : String, motif : String) -> Array[Int] { let positions : Array[Int] = Array::new() let motif_len = motif.length() let seq_len = sequence.length() - + if motif_len == 0 || seq_len < motif_len { return positions } - + let mut pos = 0 while pos <= seq_len - motif_len { let substr = substring(sequence, pos, motif_len) @@ -287,7 +299,7 @@ pub fn fa_find_motif(sequence : String, motif : String) -> Array[Int] { } pos = pos + 1 } - + positions } @@ -315,7 +327,7 @@ pub fn fa_sequence_complexity(sequence : String) -> Double { let counts = fa_count_kmers(sequence, 1) let mut entropy = 0.0 let patterns = counts.fa_get_patterns() - + let mut i = 0 while i < patterns.length() { let freq = counts.fa_get_frequency(patterns[i]) diff --git a/src/freq_table.mbt b/src/freq_table.mbt index 5d1cb4ee..cf5e5da5 100644 --- a/src/freq_table.mbt +++ b/src/freq_table.mbt @@ -63,7 +63,7 @@ pub struct FreqTable { pub fn FreqTable::new( in_dict : Map[String, Double], dict_type : FreqTableType, - alphabet : Array[String]? + alphabet : Array[String]?, ) -> FreqTable { let data : Map[String, Double] = Map([], capacity=16) let count : Map[String, Int] = Map([], capacity=16) @@ -74,13 +74,20 @@ pub fn FreqTable::new( for ch in a { alph.push(ch) } - None => for k in in_dict.keys() { - alph.push(k) - } + None => + for k in in_dict.keys() { + alph.push(k) + } } // Sort alphabet for deterministic order. alph.sort_by(fn(a : String, b : String) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) match dict_type { COUNT => { @@ -310,9 +317,7 @@ pub fn freq_table_read_freq(text : String) -> FreqTable { ///| /// Build a `FreqTable` from a count dictionary (Map[String, Int]). -pub fn freq_table_from_counts( - counts : Map[String, Int] -) -> FreqTable { +pub fn freq_table_from_counts(counts : Map[String, Int]) -> FreqTable { let in_dict : Map[String, Double] = Map([], capacity=counts.size()) for k in counts.keys() { in_dict[k] = counts[k].to_double() @@ -322,9 +327,7 @@ pub fn freq_table_from_counts( ///| /// Build a `FreqTable` from a frequency dictionary (Map[String, Double]). -pub fn freq_table_from_freqs( - freqs : Map[String, Double] -) -> FreqTable { +pub fn freq_table_from_freqs(freqs : Map[String, Double]) -> FreqTable { FreqTable::new(freqs, FreqTableType::FREQ, None) } @@ -335,7 +338,7 @@ pub fn freq_table_from_freqs( /// restrict counting). pub fn freq_table_from_sequence( sequence : String, - alphabet : Array[String]? + alphabet : Array[String]?, ) -> FreqTable { let counts : Map[String, Int] = Map([], capacity=16) let restrict : Map[String, Bool] = Map([], capacity=0) @@ -387,7 +390,7 @@ pub fn freq_table_entropy(table : FreqTable) -> Double { /// 0 * log(0/0) is taken as 0). pub fn freq_table_relative_entropy( table : FreqTable, - other : FreqTable + other : FreqTable, ) -> Double { let mut d = 0.0 for k in table.data.keys() { @@ -436,10 +439,7 @@ pub fn freq_table_normalize(table : FreqTable) -> FreqTable { /// distribution M = 0.5 * (P + Q). Returns JS = 0.5 * KL(P||M) + 0.5 * KL(Q||M). /// Both tables should share the same alphabet; letters missing from one are /// treated as 0 in the other. -pub fn freq_table_js_distance( - table : FreqTable, - other : FreqTable -) -> Double { +pub fn freq_table_js_distance(table : FreqTable, other : FreqTable) -> Double { // Build the union of letters. let letters : Map[String, Bool] = Map([], capacity=32) for k in table.data.keys() { diff --git a/src/fssp.mbt b/src/fssp.mbt index 162bb231..03e2c299 100644 --- a/src/fssp.mbt +++ b/src/fssp.mbt @@ -367,14 +367,7 @@ fn fssp_parse_header(lines : Array[String]) -> (FsspHeader, Int) { } ( FsspHeader::new( - pdbid, - pdbid_date, - title, - compound, - source, - author, - seq_length, - n_alignments, + pdbid, pdbid_date, title, compound, source, author, seq_length, n_alignments, threshold, ), idx, @@ -413,14 +406,7 @@ fn fssp_parse_alignment_line(line : String) -> FsspAlignment? { } Some( FsspAlignment::new( - pdbid, - pdbid, - start_pos, - aligned_seq, - zscore, - rmsd, - lali, - pid, + pdbid, pdbid, start_pos, aligned_seq, zscore, rmsd, lali, pid, ), ) } @@ -440,7 +426,8 @@ pub fn fssp_parse(text : String) -> FsspData { continue } // Check for section markers - if starts_with(line, 0, "## ALIGNMENTS") || starts_with(line, 0, "##ALIGNMENTS") { + if starts_with(line, 0, "## ALIGNMENTS") || + starts_with(line, 0, "##ALIGNMENTS") { in_alignment_section = true idx = idx + 1 continue @@ -475,7 +462,8 @@ pub fn fssp_parse(text : String) -> FsspData { pub fn fssp_sample_text() -> String { let mut s = "" s = s + "HEADER \\_1dfa_A 1 30-jul-1998\n" - s = s + "TITLE crystal structure of human type i 17beta-hydroxysteroid dehydrogenase\n" + s = s + + "TITLE crystal structure of human type i 17beta-hydroxysteroid dehydrogenase\n" s = s + "COMPND 17beta-hsd\n" s = s + "SOURCE human\n" s = s + "AUTHOR holm\n" diff --git a/src/ga.mbt b/src/ga.mbt index a3a2e017..2181434c 100644 --- a/src/ga.mbt +++ b/src/ga.mbt @@ -121,7 +121,11 @@ pub fn GAPopulation::new(individuals~ : Array[GAIndividual]) -> GAPopulation { } sum = sum + ind.fitness } - let avg = if individuals.length() > 0 { sum / individuals.length().to_double() } else { 0.0 } + let avg = if individuals.length() > 0 { + sum / individuals.length().to_double() + } else { + 0.0 + } GAPopulation::{ individuals, generation: 0, @@ -196,8 +200,8 @@ pub fn ga_random_sequence(length : Int, alphabet : String) -> String { let mut i = 0 while i < length { let idx = (ga_pseudo_random() * n.to_double()).to_int() - let safe_idx = if idx >= n { n - 1 } else { if idx < 0 { 0 } else { idx } } - result = result + alphabet[safe_idx : safe_idx + 1].to_string() + let safe_idx = if idx >= n { n - 1 } else if idx < 0 { 0 } else { idx } + result = result + alphabet[safe_idx:safe_idx + 1].to_string() i = i + 1 } result @@ -249,14 +253,18 @@ pub fn ga_rand_int(max : Int) -> Int { pub fn ga_fitness_match(target : String) -> (GAIndividual) -> Double { fn(individual : GAIndividual) -> Double { let seq = individual.sequence - let n = if seq.length() < target.length() { seq.length() } else { target.length() } + let n = if seq.length() < target.length() { + seq.length() + } else { + target.length() + } if n == 0 { return 0.0 } let mut matches = 0 let mut i = 0 while i < n { - if seq[i : i + 1].to_string() == target[i : i + 1].to_string() { + if seq[i:i + 1].to_string() == target[i:i + 1].to_string() { matches = matches + 1 } i = i + 1 @@ -278,14 +286,18 @@ pub fn ga_fitness_gc_content(target_gc : Double) -> (GAIndividual) -> Double { let mut gc_count = 0 let mut i = 0 while i < n { - let base = seq[i : i + 1].to_string() + let base = seq[i:i + 1].to_string() if base == "G" || base == "C" { gc_count = gc_count + 1 } i = i + 1 } let gc_content = gc_count.to_double() / n.to_double() - let diff = if gc_content - target_gc < 0.0 { target_gc - gc_content } else { gc_content - target_gc } + let diff = if gc_content - target_gc < 0.0 { + target_gc - gc_content + } else { + gc_content - target_gc + } 1.0 - diff } } @@ -303,12 +315,14 @@ pub fn ga_evaluate_population( let result : Array[GAIndividual] = Array::new() for ind in individuals { let fit = fitness_fn(ind) - result.push(GAIndividual::new( - sequence=ind.sequence, - fitness=fit, - generation=ind.generation, - id=ind.id, - )) + result.push( + GAIndividual::new( + sequence=ind.sequence, + fitness=fit, + generation=ind.generation, + id=ind.id, + ), + ) } result } @@ -406,20 +420,38 @@ pub fn ga_single_point_crossover( ) -> (GAIndividual, GAIndividual) { let seq1 = parent1.sequence let seq2 = parent2.sequence - let n = if seq1.length() < seq2.length() { seq1.length() } else { seq2.length() } + let n = if seq1.length() < seq2.length() { + seq1.length() + } else { + seq2.length() + } if n < 2 { return (parent1, parent2) } - let actual_point = if point > 0 && point < n { point } else { 1 + ga_rand_int(n - 1) } + let actual_point = if point > 0 && point < n { + point + } else { + 1 + ga_rand_int(n - 1) + } - let child1_seq = (seq1[0 : actual_point] + seq2[actual_point : n]).to_string() - let child2_seq = (seq2[0 : actual_point] + seq1[actual_point : n]).to_string() + let child1_seq = (seq1[0:actual_point] + seq2[actual_point:n]).to_string() + let child2_seq = (seq2[0:actual_point] + seq1[actual_point:n]).to_string() ( - GAIndividual::new(sequence=child1_seq, fitness=0.0, generation=parent1.generation + 1, id=0), - GAIndividual::new(sequence=child2_seq, fitness=0.0, generation=parent1.generation + 1, id=0), + GAIndividual::new( + sequence=child1_seq, + fitness=0.0, + generation=parent1.generation + 1, + id=0, + ), + GAIndividual::new( + sequence=child2_seq, + fitness=0.0, + generation=parent1.generation + 1, + id=0, + ), ) } @@ -431,7 +463,11 @@ pub fn ga_two_point_crossover( ) -> (GAIndividual, GAIndividual) { let seq1 = parent1.sequence let seq2 = parent2.sequence - let n = if seq1.length() < seq2.length() { seq1.length() } else { seq2.length() } + let n = if seq1.length() < seq2.length() { + seq1.length() + } else { + seq2.length() + } if n < 3 { return ga_single_point_crossover(parent1, parent2) @@ -440,12 +476,22 @@ pub fn ga_two_point_crossover( let p1 = ga_rand_int(n - 1) + 1 let p2 = p1 + 1 + ga_rand_int(n - p1 - 1) - let child1_seq = (seq1[0 : p1] + seq2[p1 : p2] + seq1[p2 : n]).to_string() - let child2_seq = (seq2[0 : p1] + seq1[p1 : p2] + seq2[p2 : n]).to_string() + let child1_seq = (seq1[0:p1] + seq2[p1:p2] + seq1[p2:n]).to_string() + let child2_seq = (seq2[0:p1] + seq1[p1:p2] + seq2[p2:n]).to_string() ( - GAIndividual::new(sequence=child1_seq, fitness=0.0, generation=parent1.generation + 1, id=0), - GAIndividual::new(sequence=child2_seq, fitness=0.0, generation=parent1.generation + 1, id=0), + GAIndividual::new( + sequence=child1_seq, + fitness=0.0, + generation=parent1.generation + 1, + id=0, + ), + GAIndividual::new( + sequence=child2_seq, + fitness=0.0, + generation=parent1.generation + 1, + id=0, + ), ) } @@ -458,7 +504,11 @@ pub fn ga_uniform_crossover( ) -> (GAIndividual, GAIndividual) { let seq1 = parent1.sequence let seq2 = parent2.sequence - let n = if seq1.length() < seq2.length() { seq1.length() } else { seq2.length() } + let n = if seq1.length() < seq2.length() { + seq1.length() + } else { + seq2.length() + } let mut child1_seq = "" let mut child2_seq = "" @@ -466,18 +516,28 @@ pub fn ga_uniform_crossover( let mut i = 0 while i < n { if ga_pseudo_random() < swap_prob { - child1_seq = child1_seq + seq2[i : i + 1].to_string() - child2_seq = child2_seq + seq1[i : i + 1].to_string() + child1_seq = child1_seq + seq2[i:i + 1].to_string() + child2_seq = child2_seq + seq1[i:i + 1].to_string() } else { - child1_seq = child1_seq + seq1[i : i + 1].to_string() - child2_seq = child2_seq + seq2[i : i + 1].to_string() + child1_seq = child1_seq + seq1[i:i + 1].to_string() + child2_seq = child2_seq + seq2[i:i + 1].to_string() } i = i + 1 } ( - GAIndividual::new(sequence=child1_seq, fitness=0.0, generation=parent1.generation + 1, id=0), - GAIndividual::new(sequence=child2_seq, fitness=0.0, generation=parent1.generation + 1, id=0), + GAIndividual::new( + sequence=child1_seq, + fitness=0.0, + generation=parent1.generation + 1, + id=0, + ), + GAIndividual::new( + sequence=child2_seq, + fitness=0.0, + generation=parent1.generation + 1, + id=0, + ), ) } @@ -503,15 +563,20 @@ pub fn ga_point_mutate( while i < n { if ga_pseudo_random() < mutation_rate { let alphabet_idx = ga_rand_int(alphabet.length()) - let new_base = alphabet[alphabet_idx : alphabet_idx + 1].to_string() + let new_base = alphabet[alphabet_idx:alphabet_idx + 1].to_string() new_seq = new_seq + new_base } else { - new_seq = new_seq + seq[i : i + 1].to_string() + new_seq = new_seq + seq[i:i + 1].to_string() } i = i + 1 } - GAIndividual::new(sequence=new_seq, fitness=individual.fitness, generation=individual.generation, id=individual.id) + GAIndividual::new( + sequence=new_seq, + fitness=individual.fitness, + generation=individual.generation, + id=individual.id, + ) } ///| @@ -528,11 +593,16 @@ pub fn ga_insertion_mutate( let pos = ga_rand_int(n + 1) let new_base_idx = ga_rand_int(alphabet.length()) - let new_base = alphabet[new_base_idx : new_base_idx + 1].to_string() + let new_base = alphabet[new_base_idx:new_base_idx + 1].to_string() - let new_seq = (seq[0 : pos] + new_base + seq[pos : n]).to_string() + let new_seq = (seq[0:pos] + new_base + seq[pos:n]).to_string() - GAIndividual::new(sequence=new_seq, fitness=individual.fitness, generation=individual.generation, id=individual.id) + GAIndividual::new( + sequence=new_seq, + fitness=individual.fitness, + generation=individual.generation, + id=individual.id, + ) } ///| @@ -545,9 +615,14 @@ pub fn ga_deletion_mutate(individual : GAIndividual) -> GAIndividual { } let pos = ga_rand_int(n) - let new_seq = (seq[0 : pos] + seq[pos + 1 : n]).to_string() + let new_seq = (seq[0:pos] + seq[pos + 1:n]).to_string() - GAIndividual::new(sequence=new_seq, fitness=individual.fitness, generation=individual.generation, id=individual.id) + GAIndividual::new( + sequence=new_seq, + fitness=individual.fitness, + generation=individual.generation, + id=individual.id, + ) } // ============================================================================ @@ -573,7 +648,7 @@ pub fn ga_evolve( // Evaluate initial fitness individuals = ga_evaluate_population(individuals, fitness_fn) - let mut pop = GAPopulation::new(individuals=individuals) + let mut pop = GAPopulation::new(individuals~) let best_fitness_history : Array[Double] = [pop.best_fitness] let avg_fitness_history : Array[Double] = [pop.avg_fitness] let mut best_individual = ga_find_best(pop) @@ -592,7 +667,10 @@ pub fn ga_evolve( // Fill rest of offspring while offspring.length() < config.population_size { - let parent1 = ga_tournament_select(pop.individuals, config.tournament_size) + let parent1 = ga_tournament_select( + pop.individuals, + config.tournament_size, + ) let parent2 = ga_roulette_select(pop.individuals) let (child1, child2) = if ga_pseudo_random() < config.crossover_rate { @@ -603,11 +681,19 @@ pub fn ga_evolve( // Add offspring with mutation if offspring.length() < config.population_size { - let mutated1 = ga_point_mutate(child1, config.mutation_rate, config.alphabet) + let mutated1 = ga_point_mutate( + child1, + config.mutation_rate, + config.alphabet, + ) offspring.push(mutated1) } if offspring.length() < config.population_size { - let mutated2 = ga_point_mutate(child2, config.mutation_rate, config.alphabet) + let mutated2 = ga_point_mutate( + child2, + config.mutation_rate, + config.alphabet, + ) offspring.push(mutated2) } } @@ -631,18 +717,19 @@ pub fn ga_evolve( let prev_best = best_fitness_history[best_fitness_history.length() - 2] let curr_best = best_fitness_history[best_fitness_history.length() - 1] let improvement = curr_best - prev_best - if improvement.abs() < config.convergence_threshold || curr_best >= config.target_fitness { + if improvement.abs() < config.convergence_threshold || + curr_best >= config.target_fitness { converged = true } } } GAResult::new( - best_individual=best_individual, - best_fitness_history=best_fitness_history, - avg_fitness_history=avg_fitness_history, + best_individual~, + best_fitness_history~, + avg_fitness_history~, generation_reached=generation, - converged=converged, + converged~, ) } @@ -672,4 +759,4 @@ fn ga_sort_indices(individuals : Array[GAIndividual]) -> Array[Int] { j = j + 1 } arr -} \ No newline at end of file +} diff --git a/src/gage.mbt b/src/gage.mbt index c425c0dd..a301e464 100644 --- a/src/gage.mbt +++ b/src/gage.mbt @@ -51,7 +51,11 @@ pub struct GageGeneSet { ///| /// Create a GageGeneSet. -pub fn GageGeneSet::new(id : String, name : String, gene_ids : Array[String]) -> GageGeneSet { +pub fn GageGeneSet::new( + id : String, + name : String, + gene_ids : Array[String], +) -> GageGeneSet { GageGeneSet::{ id, name, gene_ids } } @@ -180,7 +184,13 @@ fn gage_pvalue_from_z(z : Double) -> Double { // p = 2 * (1 - Phi(|z|)) = erfc(|z| / sqrt(2)) let x = abs_z / 1.4142135623730951 let p = erfc_approx(x) - if p > 1.0 { 1.0 } else if p < 0.0 { 0.0 } else { p } + if p > 1.0 { + 1.0 + } else if p < 0.0 { + 0.0 + } else { + p + } } ///| @@ -195,7 +205,12 @@ fn erfc_approx(x : Double) -> Double { let t3 = t2 * t let t4 = t3 * t let t5 = t4 * t - let poly = 1.0 + 0.254829592 * t + -0.284496736 * t2 + 1.421413741 * t3 + -1.453152027 * t4 + 1.061405429 * t5 + let poly = 1.0 + + 0.254829592 * t + + -0.284496736 * t2 + + 1.421413741 * t3 + + -1.453152027 * t4 + + 1.061405429 * t5 @math.exp(-x * x) * poly } @@ -297,7 +312,10 @@ pub fn GageResults::get_downregulated(self : GageResults) -> Array[GageResult] { ///| /// Get top N gene sets by adjusted p-value. -pub fn GageResults::get_top_sets(self : GageResults, n : Int) -> Array[GageResult] { +pub fn GageResults::get_top_sets( + self : GageResults, + n : Int, +) -> Array[GageResult] { let sorted = self.results.copy() let len = sorted.length() let mut i = 0 @@ -328,7 +346,12 @@ pub fn GageResults::get_top_sets(self : GageResults, n : Int) -> Array[GageResul pub fn GageResults::summary(self : GageResults) -> String { let mut s = "=== GAGE Analysis Summary ===\n".to_string() s = s + "Gene sets tested: " + self.n_gene_sets.to_string() + "\n" - s = s + "Significant (FDR < " + self.fdr_threshold.to_string() + "): " + self.n_significant.to_string() + "\n" + s = s + + "Significant (FDR < " + + self.fdr_threshold.to_string() + + "): " + + self.n_significant.to_string() + + "\n" s = s + "Paired test: " + self.paired.to_string() + "\n" s } diff --git a/src/gck_io.mbt b/src/gck_io.mbt index 45df3880..2f95391f 100644 --- a/src/gck_io.mbt +++ b/src/gck_io.mbt @@ -325,12 +325,7 @@ pub fn gck_from_bytes(data : Array[Int]) -> GckFile { offset = offset + 8 } file.features.push( - GckFeature::new( - name=name, - type_=type_, - direction=direction, - segments=segs, - ), + GckFeature::new(name~, type_~, direction~, segments=segs), ) } // Parse sequence @@ -439,7 +434,7 @@ pub fn gck_to_seqrecord(file : GckFile) -> SeqRecord { let id = "gck" let topo = if file.is_circular { " circular" } else { " linear" } let desc = file.seq_type.to_string() + topo - SeqRecord::new(Seq::new(file.sequence), id=id, name=id, description=desc) + SeqRecord::new(Seq::new(file.sequence), id~, name=id, description=desc) } ///| @@ -482,7 +477,9 @@ pub fn gck_summary(file : GckFile) -> String { sb.write_string(" Type: " + file.seq_type.to_string() + "\n") let topo = if file.is_circular { "circular" } else { "linear" } sb.write_string(" Topology: " + topo + "\n") - sb.write_string(" Sequence Length: " + gck_seq_length(file).to_string() + " bp\n") + sb.write_string( + " Sequence Length: " + gck_seq_length(file).to_string() + " bp\n", + ) sb.write_string(" Features: " + file.features.length().to_string() + "\n") if file.features.length() > 0 { sb.write_string(" Feature List:\n") @@ -495,8 +492,15 @@ pub fn gck_summary(file : GckFile) -> String { "none" } sb.write_string( - " " + f.name + " (" + f.type_ + ", " + dir_str + ") - " + - f.segments.length().to_string() + " segment(s)\n", + " " + + f.name + + " (" + + f.type_ + + ", " + + dir_str + + ") - " + + f.segments.length().to_string() + + " segment(s)\n", ) } } @@ -512,28 +516,13 @@ pub fn gck_sample() -> GckFile { file.is_circular = true file.sequence = "ATGGCTAGCAATGGGTCGCGATAGCGATAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAA" file.features.push( - GckFeature::new( - name="AmpR", - type_="CDS", - direction=1, - segments=[(0, 19)], - ), + GckFeature::new(name="AmpR", type_="CDS", direction=1, segments=[(0, 19)]), ) file.features.push( - GckFeature::new( - name="lacZ", - type_="CDS", - direction=1, - segments=[(30, 49)], - ), + GckFeature::new(name="lacZ", type_="CDS", direction=1, segments=[(30, 49)]), ) file.features.push( - GckFeature::new( - name="MCS", - type_="misc", - direction=0, - segments=[(50, 63)], - ), + GckFeature::new(name="MCS", type_="misc", direction=0, segments=[(50, 63)]), ) file } diff --git a/src/gcrma.mbt b/src/gcrma.mbt index bab62e40..8fc01731 100644 --- a/src/gcrma.mbt +++ b/src/gcrma.mbt @@ -22,8 +22,8 @@ pub struct GCRMAConfig { ///| /// Create a new GCRMAConfig with default settings. pub fn GCRMAConfig::new( - background_method~ : String = "IdealMM", - normalize~ : Bool = true, + background_method? : String = "IdealMM", + normalize? : Bool = true, ) -> GCRMAConfig { GCRMAConfig::{ background_method, @@ -53,10 +53,7 @@ pub struct ProbeInfo { ///| /// Create a new ProbeInfo from a probe ID and sequence. /// GC count and affinity are computed automatically. -pub fn ProbeInfo::new( - probe_id : String, - sequence : String, -) -> ProbeInfo { +pub fn ProbeInfo::new(probe_id : String, sequence : String) -> ProbeInfo { let gc_count = oligo_gc_count(sequence) let affinity = estimate_affinity(sequence) ProbeInfo::{ probe_id, gc_count, sequence, affinity } @@ -85,8 +82,10 @@ pub fn oligo_gc_count(sequence : String) -> Int { let mut i = 0 while i < n { let c = sequence.unsafe_get(i).to_int() - if c == 'G'.to_int() || c == 'C'.to_int() || - c == 'g'.to_int() || c == 'c'.to_int() { + if c == 'G'.to_int() || + c == 'C'.to_int() || + c == 'g'.to_int() || + c == 'c'.to_int() { count = count + 1 } i = i + 1 @@ -125,14 +124,30 @@ pub fn estimate_affinity(sequence : String) -> Double { while i < n - 1 { let c1 = sequence.unsafe_get(i).to_int() let c2 = sequence.unsafe_get(i + 1).to_int() - let is_gc = (c1 == 'G'.to_int() || c1 == 'g'.to_int() || - c1 == 'C'.to_int() || c1 == 'c'.to_int()) && - (c2 == 'G'.to_int() || c2 == 'g'.to_int() || - c2 == 'C'.to_int() || c2 == 'c'.to_int()) - let is_at = (c1 == 'A'.to_int() || c1 == 'a'.to_int() || - c1 == 'T'.to_int() || c1 == 't'.to_int()) && - (c2 == 'A'.to_int() || c2 == 'a'.to_int() || - c2 == 'T'.to_int() || c2 == 't'.to_int()) + let is_gc = ( + c1 == 'G'.to_int() || + c1 == 'g'.to_int() || + c1 == 'C'.to_int() || + c1 == 'c'.to_int() + ) && + ( + c2 == 'G'.to_int() || + c2 == 'g'.to_int() || + c2 == 'C'.to_int() || + c2 == 'c'.to_int() + ) + let is_at = ( + c1 == 'A'.to_int() || + c1 == 'a'.to_int() || + c1 == 'T'.to_int() || + c1 == 't'.to_int() + ) && + ( + c2 == 'A'.to_int() || + c2 == 'a'.to_int() || + c2 == 'T'.to_int() || + c2 == 't'.to_int() + ) if is_gc { gc_energy = gc_energy + 3.0 } else if is_at { @@ -183,6 +198,7 @@ pub fn compute_gc_lookup_table( // Internal statistical helpers // --------------------------------------------------------------------------- +///| fn _median(arr : Array[Double]) -> Double { let n = arr.length() if n == 0 { @@ -197,6 +213,7 @@ fn _median(arr : Array[Double]) -> Double { } } +///| fn _mean(arr : Array[Double]) -> Double { let n = arr.length() if n == 0 { @@ -211,9 +228,8 @@ fn _mean(arr : Array[Double]) -> Double { sum / n.to_double() } -fn _quantile_normalize( - data : Array[Array[Double]], -) -> Array[Array[Double]] { +///| +fn _quantile_normalize(data : Array[Array[Double]]) -> Array[Array[Double]] { let n_rows = data.length() if n_rows == 0 { return data @@ -361,18 +377,10 @@ pub fn gcrma_gc_correction( let result : Array[Double] = Array::new() let mut i = 0 while i < n { - let gc = if i < gc_counts.length() { - gc_counts[i] - } else { - 0 - } + let gc = if i < gc_counts.length() { gc_counts[i] } else { 0 } let pm_val = pm_values[i] let affinity = gc_lookup.get_or_default(gc, 1.0) - let corrected = if affinity > 0.0 { - pm_val / affinity - } else { - pm_val - } + let corrected = if affinity > 0.0 { pm_val / affinity } else { pm_val } result.push(corrected) i = i + 1 } @@ -408,7 +416,10 @@ pub fn gcrma_summarize( expression : Array[Array[Double]], probe_sets : Map[String, Array[Int]], ) -> Map[String, Array[Double]] { - let result : Map[String, Array[Double]] = Map([], capacity=probe_sets.keys().length()) + let result : Map[String, Array[Double]] = Map( + [], + capacity=probe_sets.keys().length(), + ) for probe_set_id in probe_sets.keys() { let indices = probe_sets.get_or_default(probe_set_id, []) let n_samples = if expression.length() > 0 { @@ -444,9 +455,7 @@ pub fn gcrma_summarize( ///| /// Apply median polish to a matrix (rows = probes, cols = samples). /// Returns the column effects (sample-level expression values). -fn _median_polish( - matrix : Array[Array[Double]], -) -> Array[Double] { +fn _median_polish(matrix : Array[Array[Double]]) -> Array[Double] { let n_rows = matrix.length() if n_rows == 0 { return [] @@ -579,7 +588,7 @@ pub fn gcrma_process_with_config( if n_probes == 0 { return GCRMAResult::{ expression_matrix: [], - probe_info: probe_info, + probe_info, gc_correction_params: Map([], capacity=0), } } @@ -590,11 +599,11 @@ pub fn gcrma_process_with_config( while i < n_probes { let gc = if i < probe_info.length() { probe_info[i].gc_count.to_double() / - (if probe_info[i].sequence.length() > 0 { - probe_info[i].sequence.length().to_double() - } else { - 1.0 - }) + (if probe_info[i].sequence.length() > 0 { + probe_info[i].sequence.length().to_double() + } else { + 1.0 + }) } else { 0.0 } @@ -626,7 +635,7 @@ pub fn gcrma_process_with_config( params.set("gc_correction_applied", 1.0) GCRMAResult::{ expression_matrix: normalized, - probe_info: probe_info, + probe_info, gc_correction_params: params, } } @@ -645,11 +654,7 @@ fn _gc_correction_logged( let mut i = 0 while i < n_probes { let row = log_intensities[i] - let gc = if i < probe_info.length() { - probe_info[i].gc_count - } else { - 0 - } + let gc = if i < probe_info.length() { probe_info[i].gc_count } else { 0 } let seq_len = if i < probe_info.length() { probe_info[i].sequence.length() } else { @@ -671,4 +676,4 @@ fn _gc_correction_logged( i = i + 1 } result -} \ No newline at end of file +} diff --git a/src/genbank_io.mbt b/src/genbank_io.mbt index 06fc6768..817868a5 100644 --- a/src/genbank_io.mbt +++ b/src/genbank_io.mbt @@ -226,7 +226,11 @@ pub fn write_genbank(records : Array[SeqRecord]) -> String { // Fields (fixed positions): 0-5 LOCUS, 6-11 spaces, 12-27 locus name, 28-39 length+bp, // 40-47 mol_type, 48-54 topology, 55-57 division, 58- date let seq_len = rec.seq.length() - let locus_name = if rec.name.length() > 16 { rec.name[0:16].to_owned() } else { rec.name } + let locus_name = if rec.name.length() > 16 { + rec.name[0:16].to_owned() + } else { + rec.name + } buf.write_string("LOCUS ") buf.write_string(locus_name) // Pad to position 28 (12 + 16 = 28) @@ -315,7 +319,8 @@ fn build_wrapped(text : String, indent : Int, width : Int) -> String { buf.write_string(" ") cur_indent = 12 // Skip space if we broke at one - if break_at < total && text.unsafe_get(break_at) == ' '.to_int().to_uint16() { + if break_at < total && + text.unsafe_get(break_at) == ' '.to_int().to_uint16() { pos = break_at + 1 } else { pos = break_at diff --git a/src/gene_pop.mbt b/src/gene_pop.mbt index 80f83fe3..defe967d 100644 --- a/src/gene_pop.mbt +++ b/src/gene_pop.mbt @@ -45,7 +45,10 @@ pub fn GenePopGenotype::new(allele1 : Int, allele2 : Int?) -> GenePopGenotype { ///| /// A diploid genotype (both alleles present). -pub fn GenePopGenotype::diploid(allele1 : Int, allele2 : Int) -> GenePopGenotype { +pub fn GenePopGenotype::diploid( + allele1 : Int, + allele2 : Int, +) -> GenePopGenotype { let missing = allele1 == 0 && allele2 == 0 GenePopGenotype::{ allele1, allele2: Some(allele2), is_missing: missing } } @@ -104,12 +107,7 @@ pub fn GenePopRecord::new( populations : Array[GenePopPopulation], locus_digit_size : Int, ) -> GenePopRecord { - GenePopRecord::{ - title, - loci_names, - populations, - locus_digit_size, - } + GenePopRecord::{ title, loci_names, populations, locus_digit_size } } // ============================================================================ @@ -145,16 +143,8 @@ fn gp_iequals(a : String, b : String) -> Bool { while i < na { let ca = a.unsafe_get(i).to_int() let cb = b.unsafe_get(i).to_int() - let la = if ca >= 'A'.to_int() && ca <= 'Z'.to_int() { - ca + 32 - } else { - ca - } - let lb = if cb >= 'A'.to_int() && cb <= 'Z'.to_int() { - cb + 32 - } else { - cb - } + let la = if ca >= 'A'.to_int() && ca <= 'Z'.to_int() { ca + 32 } else { ca } + let lb = if cb >= 'A'.to_int() && cb <= 'Z'.to_int() { cb + 32 } else { cb } if la != lb { return false } @@ -364,7 +354,10 @@ pub fn parse_genepop(content : String) -> GenePopRecord { if cur_individuals.length() > 0 { pop_count = pop_count + 1 populations.push( - GenePopPopulation::new("Pop_" + pop_count.to_string(), cur_individuals), + GenePopPopulation::new( + "Pop_" + pop_count.to_string(), + cur_individuals, + ), ) cur_individuals = [] } else if populations.length() == 0 { @@ -442,10 +435,7 @@ fn gp_detect_digit_size_from_ind(ind : GenePopIndividual) -> Int { max_allele = g.allele1 } match g.allele2 { - Some(a2) => - if a2 > max_allele { - max_allele = a2 - } + Some(a2) => if a2 > max_allele { max_allele = a2 } None => () } k = k + 1 @@ -462,7 +452,10 @@ fn gp_parse_individual(line : String) -> GenePopIndividual { // Split on the first comma to separate name from genotype data. let comma_pos = gp_find_char(line, ',') let (name_str, geno_str) = if comma_pos >= 0 { - (gp_trim(line[0:comma_pos].to_string()), gp_trim(line[comma_pos + 1:line.length()].to_string())) + ( + gp_trim(line[0:comma_pos].to_string()), + gp_trim(line[comma_pos + 1:line.length()].to_string()), + ) } else { // No comma: treat the whole line as genotype data with empty name. ("", line) @@ -699,9 +692,7 @@ pub fn genepop_observed_heterozygosity( if !g.is_missing { total = total + 1 match g.allele2 { - Some(a2) => if a2 != g.allele1 { - het = het + 1 - } + Some(a2) => if a2 != g.allele1 { het = het + 1 } None => () } } @@ -738,10 +729,16 @@ pub fn genepop_summary(record : GenePopRecord) -> String { let buf = StringBuilder::new() buf.write_string("GenePop Record Summary\n") buf.write_string(" Title: " + record.title + "\n") - buf.write_string(" Populations: " + record.populations.length().to_string() + "\n") + buf.write_string( + " Populations: " + record.populations.length().to_string() + "\n", + ) buf.write_string(" Loci: " + record.loci_names.length().to_string() + "\n") - buf.write_string(" Individuals: " + genepop_total_individuals(record).to_string() + "\n") - buf.write_string(" Digit size: " + record.locus_digit_size.to_string() + "\n") + buf.write_string( + " Individuals: " + genepop_total_individuals(record).to_string() + "\n", + ) + buf.write_string( + " Digit size: " + record.locus_digit_size.to_string() + "\n", + ) let mut i = 0 while i < record.populations.length() { let pop = record.populations[i] @@ -766,12 +763,12 @@ pub fn genepop_summary(record : GenePopRecord) -> String { /// and 2-digit allele encoding, for tests and demos. pub fn genepop_sample() -> String { "Sample GenePop File\n" + - "Pop\n" + - "ind1, 0102 0304 0101\n" + - "ind2, 0202 0303 0102\n" + - "ind3, 0101 0404 0202\n" + - "Pop\n" + - "ind4, 0102 0304 0101\n" + - "ind5, 0202 0303 0102\n" + - "ind6, 0101 0000 0202\n" + "Pop\n" + + "ind1, 0102 0304 0101\n" + + "ind2, 0202 0303 0102\n" + + "ind3, 0101 0404 0202\n" + + "Pop\n" + + "ind4, 0102 0304 0101\n" + + "ind5, 0202 0303 0102\n" + + "ind6, 0101 0000 0202\n" } diff --git a/src/genefilter.mbt b/src/genefilter.mbt index 07c316e7..38b64205 100644 --- a/src/genefilter.mbt +++ b/src/genefilter.mbt @@ -25,13 +25,13 @@ fn gf_sqrt(x : Double) -> Double { fn gf_sort_double(arr : Array[Double]) -> Array[Double] { let n = arr.length() let result = Array::make(n, 0.0) - + let mut i = 0 while i < n { result[i] = arr[i] i = i + 1 } - + i = 0 while i < n { let mut j = i + 1 @@ -45,7 +45,7 @@ fn gf_sort_double(arr : Array[Double]) -> Array[Double] { } i = i + 1 } - + result } @@ -57,7 +57,11 @@ pub struct FilterResult { } ///| -pub fn FilterResult::new(passing_genes : Array[String], statistics : Array[Double], p_values : Array[Double]) -> FilterResult { +pub fn FilterResult::new( + passing_genes : Array[String], + statistics : Array[Double], + p_values : Array[Double], +) -> FilterResult { FilterResult::{ passing_genes, statistics, p_values } } @@ -69,23 +73,31 @@ pub struct GeneExpression { } ///| -pub fn GeneExpression::new(gene_ids : Array[String], expression : Array[Array[Double]], groups : Array[String]) -> GeneExpression { +pub fn GeneExpression::new( + gene_ids : Array[String], + expression : Array[Array[Double]], + groups : Array[String], +) -> GeneExpression { GeneExpression::{ gene_ids, expression, groups } } ///| -pub fn row_ttest(expression : GeneExpression, group1 : String, group2 : String) -> FilterResult { +pub fn row_ttest( + expression : GeneExpression, + group1 : String, + group2 : String, +) -> FilterResult { let passing_genes : Array[String] = Array::new() let statistics : Array[Double] = Array::new() let p_values : Array[Double] = Array::new() - + let mut i = 0 while i < expression.gene_ids.length() { let expr = expression.expression[i] - + let group1_vals : Array[Double] = Array::new() let group2_vals : Array[Double] = Array::new() - + let mut j = 0 while j < expression.groups.length() { if expression.groups[j] == group1 { @@ -95,45 +107,49 @@ pub fn row_ttest(expression : GeneExpression, group1 : String, group2 : String) } j = j + 1 } - + if group1_vals.length() >= 2 && group2_vals.length() >= 2 { let n1 = group1_vals.length().to_double() let n2 = group2_vals.length().to_double() - + let mean1 = calc_mean(group1_vals) let mean2 = calc_mean(group2_vals) - + let var1 = calc_variance(group1_vals) let var2 = calc_variance(group2_vals) - + let se = gf_sqrt(var1 / n1 + var2 / n2) - + let t_stat = if se == 0.0 { 0.0 } else { (mean1 - mean2) / se } - + statistics.push(t_stat) p_values.push(0.0) passing_genes.push(expression.gene_ids[i]) } - + i = i + 1 } - + FilterResult::new(passing_genes, statistics, p_values) } ///| -pub fn row_wilcoxon(expression : GeneExpression, group1 : String, group2 : String) -> FilterResult { +pub fn row_wilcoxon( + expression : GeneExpression, + group1 : String, + group2 : String, +) -> FilterResult { let passing_genes : Array[String] = Array::new() let statistics : Array[Double] = Array::new() let p_values : Array[Double] = Array::new() - + let mut i = 0 while i < expression.gene_ids.length() { let expr = expression.expression[i] - + let group1_vals : Array[Double] = Array::new() let group2_vals : Array[Double] = Array::new() - + let mut j = 0 while j < expression.groups.length() { if expression.groups[j] == group1 { @@ -143,18 +159,18 @@ pub fn row_wilcoxon(expression : GeneExpression, group1 : String, group2 : Strin } j = j + 1 } - + if group1_vals.length() >= 2 && group2_vals.length() >= 2 { let w_stat = wilcoxon_statistic(group1_vals, group2_vals) - + statistics.push(w_stat) p_values.push(0.0) passing_genes.push(expression.gene_ids[i]) } - + i = i + 1 } - + FilterResult::new(passing_genes, statistics, p_values) } @@ -162,13 +178,13 @@ pub fn row_wilcoxon(expression : GeneExpression, group1 : String, group2 : Strin fn wilcoxon_statistic(group1 : Array[Double], group2 : Array[Double]) -> Double { let n1 = group1.length() let n2 = group2.length() - + let mut rank_sum = 0.0 let mut i = 0 while i < n1 { let x = group1[i] let mut rank = 1.0 - + let mut j = 0 while j < n1 { if j != i && group1[j] < x { @@ -178,7 +194,7 @@ fn wilcoxon_statistic(group1 : Array[Double], group2 : Array[Double]) -> Double } j = j + 1 } - + j = 0 while j < n2 { if group2[j] < x { @@ -188,59 +204,69 @@ fn wilcoxon_statistic(group1 : Array[Double], group2 : Array[Double]) -> Double } j = j + 1 } - + rank_sum = rank_sum + rank i = i + 1 } - + rank_sum } ///| -pub fn variance_filter(expression : GeneExpression, threshold : Double) -> Array[String] { +pub fn variance_filter( + expression : GeneExpression, + threshold : Double, +) -> Array[String] { let passing_genes : Array[String] = Array::new() - + let mut i = 0 while i < expression.gene_ids.length() { let expr = expression.expression[i] let var = calc_variance(expr) - + if var >= threshold { passing_genes.push(expression.gene_ids[i]) } - + i = i + 1 } - + passing_genes } ///| -pub fn cv_filter(expression : GeneExpression, threshold : Double) -> Array[String] { +pub fn cv_filter( + expression : GeneExpression, + threshold : Double, +) -> Array[String] { let passing_genes : Array[String] = Array::new() - + let mut i = 0 while i < expression.gene_ids.length() { let expr = expression.expression[i] let m = calc_mean(expr) let cv_val = if m == 0.0 { 0.0 } else { gf_sqrt(calc_variance(expr)) / m } - + if cv_val >= threshold { passing_genes.push(expression.gene_ids[i]) } - + i = i + 1 } - + passing_genes } ///| -pub fn row_quantile_filter(expression : GeneExpression, q_low : Double, q_high : Double) -> Array[String] { +pub fn row_quantile_filter( + expression : GeneExpression, + q_low : Double, + q_high : Double, +) -> Array[String] { let passing_genes : Array[String] = Array::new() - + let all_vals : Array[Double] = Array::new() - + let mut i = 0 while i < expression.expression.length() { let mut j = 0 @@ -250,28 +276,36 @@ pub fn row_quantile_filter(expression : GeneExpression, q_low : Double, q_high : } i = i + 1 } - + let sorted_vals = gf_sort_double(all_vals) - + let low_idx = (all_vals.length().to_double() * q_low).to_int() let high_idx = (all_vals.length().to_double() * q_high).to_int() - - let low_threshold = if low_idx < sorted_vals.length() { sorted_vals[low_idx] } else { 0.0 } - let high_threshold = if high_idx < sorted_vals.length() { sorted_vals[high_idx] } else { 0.0 } - + + let low_threshold = if low_idx < sorted_vals.length() { + sorted_vals[low_idx] + } else { + 0.0 + } + let high_threshold = if high_idx < sorted_vals.length() { + sorted_vals[high_idx] + } else { + 0.0 + } + let mut i = 0 while i < expression.gene_ids.length() { let expr = expression.expression[i] let gene_min = calc_min(expr) let gene_max = calc_max(expr) - + if gene_min >= low_threshold && gene_max <= high_threshold { passing_genes.push(expression.gene_ids[i]) } - + i = i + 1 } - + passing_genes } @@ -280,14 +314,14 @@ fn calc_mean(vals : Array[Double]) -> Double { if vals.length() == 0 { return 0.0 } - + let mut sum = 0.0 let mut i = 0 while i < vals.length() { sum = sum + vals[i] i = i + 1 } - + sum / vals.length().to_double() } @@ -296,16 +330,16 @@ fn calc_variance(vals : Array[Double]) -> Double { if vals.length() < 2 { return 0.0 } - + let m = calc_mean(vals) let mut sum_sq = 0.0 - + let mut i = 0 while i < vals.length() { sum_sq = sum_sq + @math.pow(vals[i] - m, 2.0) i = i + 1 } - + sum_sq / (vals.length() - 1).to_double() } @@ -314,7 +348,7 @@ fn calc_min(vals : Array[Double]) -> Double { if vals.length() == 0 { return 0.0 } - + let mut m = vals[0] let mut i = 1 while i < vals.length() { @@ -323,7 +357,7 @@ fn calc_min(vals : Array[Double]) -> Double { } i = i + 1 } - + m } @@ -332,7 +366,7 @@ fn calc_max(vals : Array[Double]) -> Double { if vals.length() == 0 { return 0.0 } - + let mut m = vals[0] let mut i = 1 while i < vals.length() { @@ -341,7 +375,7 @@ fn calc_max(vals : Array[Double]) -> Double { } i = i + 1 } - + m } @@ -355,7 +389,9 @@ pub fn create_example_gene_expression() -> GeneExpression { [15.7, 16.2, 15.9, 14.8, 15.2, 14.5], [3.2, 3.5, 3.1, 3.0, 3.3, 2.9], ] - let groups = ["control", "control", "control", "treatment", "treatment", "treatment"] - + let groups = [ + "control", "control", "control", "treatment", "treatment", "treatment", + ] + GeneExpression::new(gene_ids, expression, groups) -} \ No newline at end of file +} diff --git a/src/genesis.mbt b/src/genesis.mbt index b10bbf0b..c22501b6 100644 --- a/src/genesis.mbt +++ b/src/genesis.mbt @@ -15,7 +15,7 @@ pub struct GSKinshipResult { pub fn GSKinshipResult::new( kinship_matrix : Array[Array[Double]], sample_ids : Array[String], - n_samples : Int + n_samples : Int, ) -> GSKinshipResult { GSKinshipResult::{ kinship_matrix, sample_ids, n_samples } } @@ -35,7 +35,7 @@ pub fn GSPcaResult::new( eigenvalues : Array[Double], eigenvectors : Array[Array[Double]], var_explained : Array[Double], - sample_ids : Array[String] + sample_ids : Array[String], ) -> GSPcaResult { GSPcaResult::{ eigenvalues, eigenvectors, var_explained, sample_ids } } @@ -53,7 +53,7 @@ pub struct GSDistanceResult { pub fn GSDistanceResult::new( distance_matrix : Array[Array[Double]], sample_ids : Array[String], - distance_type : String + distance_type : String, ) -> GSDistanceResult { GSDistanceResult::{ distance_matrix, sample_ids, distance_type } } @@ -63,14 +63,14 @@ pub fn GSDistanceResult::new( pub fn gs_estimate_kinship(genotypes : Array[Array[Double]]) -> GSKinshipResult { let n = genotypes.length() let m = if n > 0 { genotypes[0].length() } else { 0 } - + let sample_ids : Array[String] = Array::new() let mut i = 0 while i < n { sample_ids.push("Sample" + i.to_string()) i = i + 1 } - + let kinship : Array[Array[Double]] = Array::new() let mut j = 0 while j < n { @@ -83,7 +83,7 @@ pub fn gs_estimate_kinship(genotypes : Array[Array[Double]]) -> GSKinshipResult kinship.push(row) j = j + 1 } - + let allele_freqs : Array[Double] = Array::new() let mut l = 0 while l < m { @@ -97,10 +97,16 @@ pub fn gs_estimate_kinship(genotypes : Array[Array[Double]]) -> GSKinshipResult } p = p + 1 } - allele_freqs.push(if n_valid > 0 { sum / (2.0 * n_valid.to_double()) } else { 0.5 }) + allele_freqs.push( + if n_valid > 0 { + sum / (2.0 * n_valid.to_double()) + } else { + 0.5 + }, + ) l = l + 1 } - + let mut a = 0 while a < n { let mut b = a @@ -112,7 +118,9 @@ pub fn gs_estimate_kinship(genotypes : Array[Array[Double]]) -> GSKinshipResult if genotypes[a][c] >= 0.0 && genotypes[b][c] >= 0.0 { let freq = allele_freqs[c] if freq > 0.0 && freq < 1.0 { - let term = (genotypes[a][c] - 2.0 * freq) * (genotypes[b][c] - 2.0 * freq) / (2.0 * freq * (1.0 - freq)) + let term = (genotypes[a][c] - 2.0 * freq) * + (genotypes[b][c] - 2.0 * freq) / + (2.0 * freq * (1.0 - freq)) sum = sum + term count = count + 1 } @@ -126,23 +134,26 @@ pub fn gs_estimate_kinship(genotypes : Array[Array[Double]]) -> GSKinshipResult } a = a + 1 } - + GSKinshipResult::new(kinship, sample_ids, n) } ///| /// Perform PCA on genotype data. -pub fn gs_pca(genotypes : Array[Array[Double]], n_components : Int) -> GSPcaResult { +pub fn gs_pca( + genotypes : Array[Array[Double]], + n_components : Int, +) -> GSPcaResult { let n = genotypes.length() let m = if n > 0 { genotypes[0].length() } else { 0 } - + let sample_ids : Array[String] = Array::new() let mut i = 0 while i < n { sample_ids.push("Sample" + i.to_string()) i = i + 1 } - + let allele_freqs : Array[Double] = Array::new() let mut j = 0 while j < m { @@ -156,10 +167,16 @@ pub fn gs_pca(genotypes : Array[Array[Double]], n_components : Int) -> GSPcaResu } k = k + 1 } - allele_freqs.push(if n_valid > 0 { sum / (2.0 * n_valid.to_double()) } else { 0.5 }) + allele_freqs.push( + if n_valid > 0 { + sum / (2.0 * n_valid.to_double()) + } else { + 0.5 + }, + ) j = j + 1 } - + let standardized : Array[Array[Double]] = Array::new() let mut l = 0 while l < n { @@ -169,7 +186,9 @@ pub fn gs_pca(genotypes : Array[Array[Double]], n_components : Int) -> GSPcaResu if genotypes[l][p] >= 0.0 { let freq = allele_freqs[p] if freq > 0.0 && freq < 1.0 { - row.push((genotypes[l][p] - 2.0 * freq) / (2.0 * freq * (1.0 - freq)).sqrt()) + row.push( + (genotypes[l][p] - 2.0 * freq) / (2.0 * freq * (1.0 - freq)).sqrt(), + ) } else { row.push(0.0) } @@ -181,7 +200,7 @@ pub fn gs_pca(genotypes : Array[Array[Double]], n_components : Int) -> GSPcaResu standardized.push(row) l = l + 1 } - + let covariance : Array[Array[Double]] = Array::new() let mut q = 0 while q < n { @@ -200,9 +219,9 @@ pub fn gs_pca(genotypes : Array[Array[Double]], n_components : Int) -> GSPcaResu covariance.push(row) q = q + 1 } - + let components = gs_power_iteration(covariance, n_components) - + let eigenvalues : Array[Double] = Array::new() let mut t = 0 while t < components.length() { @@ -215,39 +234,48 @@ pub fn gs_pca(genotypes : Array[Array[Double]], n_components : Int) -> GSPcaResu eigenvalues.push(sum) t = t + 1 } - + let mut total_var = 0.0 let mut idx = 0 while idx < eigenvalues.length() { total_var = total_var + eigenvalues[idx] idx = idx + 1 } - + let var_explained : Array[Double] = Array::new() let mut v = 0 while v < eigenvalues.length() { - var_explained.push(if total_var > 0.0 { eigenvalues[v] / total_var } else { 0.0 }) + var_explained.push( + if total_var > 0.0 { + eigenvalues[v] / total_var + } else { + 0.0 + }, + ) v = v + 1 } - + GSPcaResult::new(eigenvalues, components, var_explained, sample_ids) } ///| /// Power iteration for eigenvalue decomposition. -pub fn gs_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> Array[Array[Double]] { +pub fn gs_power_iteration( + matrix : Array[Array[Double]], + n_components : Int, +) -> Array[Array[Double]] { let n = matrix.length() let components : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_components { let v : Array[Double] = Array::new() let mut j = 0 while j < n { - v.push(((i + 1).to_double() / (j + 1).to_double()) - 0.5) + v.push((i + 1).to_double() / (j + 1).to_double() - 0.5) j = j + 1 } - + let mut iter = 0 while iter < 100 { let v_new : Array[Double] = Array::new() @@ -262,7 +290,7 @@ pub fn gs_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> v_new.push(sum) k = k + 1 } - + let mut norm = 0.0 let mut m = 0 while m < n { @@ -270,18 +298,18 @@ pub fn gs_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> m = m + 1 } norm = norm.sqrt() - + let mut p = 0 while p < n { v.set(p, v_new[p] / norm) p = p + 1 } - + iter = iter + 1 } - + components.push(v) - + let mut q = 0 while q < n { let mut r = 0 @@ -297,10 +325,10 @@ pub fn gs_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> } q = q + 1 } - + i = i + 1 } - + components } @@ -308,19 +336,19 @@ pub fn gs_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> /// Calculate genetic distance matrix. pub fn gs_calculate_genetic_distance( genotypes : Array[Array[Double]], - distance_type? : String = "euclidean" + distance_type? : String = "euclidean", ) -> GSDistanceResult { let n = genotypes.length() - + let dt = distance_type - + let sample_ids : Array[String] = Array::new() let mut i = 0 while i < n { sample_ids.push("Sample" + i.to_string()) i = i + 1 } - + let distance : Array[Array[Double]] = Array::new() let mut j = 0 while j < n { @@ -333,7 +361,7 @@ pub fn gs_calculate_genetic_distance( distance.push(row) j = j + 1 } - + let mut a = 0 while a < n { let mut b = a + 1 @@ -347,14 +375,14 @@ pub fn gs_calculate_genetic_distance( } else { gs_euclidean_distance(genotypes[a], genotypes[b]) } - + distance[a].set(b, dist) distance[b].set(a, dist) b = b + 1 } a = a + 1 } - + GSDistanceResult::new(distance, sample_ids, dt) } @@ -401,20 +429,33 @@ pub fn gs_ibs_distance(v1 : Array[Double], v2 : Array[Double]) -> Double { } i = i + 1 } - if count > 0 { sum / count.to_double() } else { 0.0 } + if count > 0 { + sum / count.to_double() + } else { + 0.0 + } } ///| /// Bio API functions. - -pub fn bio_estimate_kinship(genotypes : Array[Array[Double]]) -> GSKinshipResult { +pub fn bio_estimate_kinship( + genotypes : Array[Array[Double]], +) -> GSKinshipResult { gs_estimate_kinship(genotypes) } -pub fn bio_pca(genotypes : Array[Array[Double]], n_components : Int) -> GSPcaResult { +///| +pub fn bio_pca( + genotypes : Array[Array[Double]], + n_components : Int, +) -> GSPcaResult { gs_pca(genotypes, n_components) } -pub fn bio_genetic_distance(genotypes : Array[Array[Double]], distance_type? : String) -> GSDistanceResult { +///| +pub fn bio_genetic_distance( + genotypes : Array[Array[Double]], + distance_type? : String, +) -> GSDistanceResult { gs_calculate_genetic_distance(genotypes) -} \ No newline at end of file +} diff --git a/src/genie3.mbt b/src/genie3.mbt index a430d7b3..dd071472 100644 --- a/src/genie3.mbt +++ b/src/genie3.mbt @@ -19,14 +19,14 @@ /// Stored by index in a shared array (avoids recursive type issues). pub struct Genie3TreeNode { // For internal nodes: - feature : Int // index of splitting feature (-1 for leaf) - threshold : Double // split threshold (feature <= threshold goes left) - left_idx : Int // index into shared node array (-1 for leaf) - right_idx : Int // index into shared node array (-1 for leaf) + feature : Int // index of splitting feature (-1 for leaf) + threshold : Double // split threshold (feature <= threshold goes left) + left_idx : Int // index into shared node array (-1 for leaf) + right_idx : Int // index into shared node array (-1 for leaf) // For leaf nodes: - value : Double // leaf prediction value + value : Double // leaf prediction value is_leaf : Bool - importance_gain : Double // variance reduction at this split + importance_gain : Double // variance reduction at this split } ///| @@ -71,7 +71,10 @@ pub struct RegressionTree { ///| /// Predict a value for a single sample by traversing the tree. -pub fn RegressionTree::predict(self : RegressionTree, sample : Array[Double]) -> Double { +pub fn RegressionTree::predict( + self : RegressionTree, + sample : Array[Double], +) -> Double { let mut node_idx = 0 while true { let node = self.nodes[node_idx] @@ -316,11 +319,7 @@ fn genie3_build_recursive( // Now fill in the placeholder slot tree.nodes[current_idx] = genie3_tree_split( - best_feature, - best_threshold, - left_idx, - right_idx, - best_gain, + best_feature, best_threshold, left_idx, right_idx, best_gain, ) current_idx } @@ -344,12 +343,7 @@ pub fn genie3_build_tree( ) -> RegressionTree { let tree : RegressionTree = { nodes: [] } let _ = genie3_build_recursive( - tree, - features_matrix, - target, - feature_indices, - max_depth, - min_samples_split, + tree, features_matrix, target, feature_indices, max_depth, min_samples_split, 0, ) tree @@ -358,17 +352,17 @@ pub fn genie3_build_tree( ///| /// A weighted directed edge in the inferred regulatory network. pub struct RegulatoryEdge { - regulator : String // source gene (predictor) - target : String // target gene - weight : Double // importance weight + regulator : String // source gene (predictor) + target : String // target gene + weight : Double // importance weight } ///| /// GENIE3 inference result: weighted adjacency matrix and edges. pub struct Genie3Result { gene_names : Array[String] - matrix : Array[Array[Double]] // matrix[i][j] = importance of gene i for gene j - edges : Array[RegulatoryEdge] // sorted edges (descending weight) + matrix : Array[Array[Double]] // matrix[i][j] = importance of gene i for gene j + edges : Array[RegulatoryEdge] // sorted edges (descending weight) n_trees : Int symmetrized : Bool } @@ -499,9 +493,11 @@ pub fn genie3_run( let mut j = 0 while j < n_genes { if i != j && matrix[i][j] > 0.0 { - edges.push( - RegulatoryEdge::{ regulator: gene_names[i], target: gene_names[j], weight: matrix[i][j] }, - ) + edges.push(RegulatoryEdge::{ + regulator: gene_names[i], + target: gene_names[j], + weight: matrix[i][j], + }) } j = j + 1 } @@ -522,12 +518,21 @@ pub fn genie3_run( ei = ei + 1 } - Genie3Result::{ gene_names, matrix, edges, n_trees: n_genes, symmetrized: sym } + Genie3Result::{ + gene_names, + matrix, + edges, + n_trees: n_genes, + symmetrized: sym, + } } ///| /// Get the top-K regulatory edges by weight. -pub fn genie3_top_edges(result : Genie3Result, k : Int) -> Array[RegulatoryEdge] { +pub fn genie3_top_edges( + result : Genie3Result, + k : Int, +) -> Array[RegulatoryEdge] { let n = if k < result.edges.length() { k } else { result.edges.length() } let top : Array[RegulatoryEdge] = [] let mut i = 0 diff --git a/src/genome_diagram.mbt b/src/genome_diagram.mbt index b96d5e2e..a758a849 100644 --- a/src/genome_diagram.mbt +++ b/src/genome_diagram.mbt @@ -38,23 +38,33 @@ pub fn FeatureShape::from_string(s : String) -> FeatureShape { ///| /// Helper to create a Rectangle shape. -pub fn gd_rectangle_shape() -> FeatureShape { Rectangle } +pub fn gd_rectangle_shape() -> FeatureShape { + Rectangle +} ///| /// Helper to create an Arrow shape. -pub fn gd_arrow_shape() -> FeatureShape { Arrow } +pub fn gd_arrow_shape() -> FeatureShape { + Arrow +} ///| /// Helper to create a Diamond shape. -pub fn gd_diamond_shape() -> FeatureShape { Diamond } +pub fn gd_diamond_shape() -> FeatureShape { + Diamond +} ///| /// Helper to create a CrossedArrow shape. -pub fn gd_crossed_arrow_shape() -> FeatureShape { CrossedArrow } +pub fn gd_crossed_arrow_shape() -> FeatureShape { + CrossedArrow +} ///| /// Helper to create a Terminators shape. -pub fn gd_terminators_shape() -> FeatureShape { Terminators } +pub fn gd_terminators_shape() -> FeatureShape { + Terminators +} ///| /// DiagramStyle: styling options for the diagram. @@ -78,22 +88,35 @@ pub fn DiagramStyle::new( } ///| -pub fn DiagramStyle::circular(self : DiagramStyle) -> Bool { self.circular } +pub fn DiagramStyle::circular(self : DiagramStyle) -> Bool { + self.circular +} ///| -pub fn DiagramStyle::linear(self : DiagramStyle) -> Bool { self.linear } +pub fn DiagramStyle::linear(self : DiagramStyle) -> Bool { + self.linear +} ///| -pub fn DiagramStyle::scale(self : DiagramStyle) -> Double { self.scale } +pub fn DiagramStyle::scale(self : DiagramStyle) -> Double { + self.scale +} ///| -pub fn DiagramStyle::border(self : DiagramStyle) -> Bool { self.border } +pub fn DiagramStyle::border(self : DiagramStyle) -> Bool { + self.border +} ///| -pub fn DiagramStyle::color_scheme(self : DiagramStyle) -> String { self.color_scheme } +pub fn DiagramStyle::color_scheme(self : DiagramStyle) -> String { + self.color_scheme +} ///| -pub fn DiagramStyle::set_circular(self : DiagramStyle, v : Bool) -> DiagramStyle { +pub fn DiagramStyle::set_circular( + self : DiagramStyle, + v : Bool, +) -> DiagramStyle { DiagramStyle::{ ..self, circular: v, linear: !v } } @@ -113,7 +136,10 @@ pub fn DiagramStyle::set_border(self : DiagramStyle, v : Bool) -> DiagramStyle { } ///| -pub fn DiagramStyle::set_color_scheme(self : DiagramStyle, v : String) -> DiagramStyle { +pub fn DiagramStyle::set_color_scheme( + self : DiagramStyle, + v : String, +) -> DiagramStyle { DiagramStyle::{ ..self, color_scheme: v } } @@ -143,50 +169,81 @@ pub fn DiagramFeature::new( } ///| -pub fn DiagramFeature::start(self : DiagramFeature) -> Int { self.start } +pub fn DiagramFeature::start(self : DiagramFeature) -> Int { + self.start +} ///| -pub fn DiagramFeature::end(self : DiagramFeature) -> Int { self.end } +pub fn DiagramFeature::end(self : DiagramFeature) -> Int { + self.end +} ///| -pub fn DiagramFeature::strand(self : DiagramFeature) -> String { self.strand } +pub fn DiagramFeature::strand(self : DiagramFeature) -> String { + self.strand +} ///| -pub fn DiagramFeature::label(self : DiagramFeature) -> String { self.label } +pub fn DiagramFeature::label(self : DiagramFeature) -> String { + self.label +} ///| -pub fn DiagramFeature::color(self : DiagramFeature) -> String { self.color } +pub fn DiagramFeature::color(self : DiagramFeature) -> String { + self.color +} ///| -pub fn DiagramFeature::shape(self : DiagramFeature) -> FeatureShape { self.shape } +pub fn DiagramFeature::shape(self : DiagramFeature) -> FeatureShape { + self.shape +} ///| -pub fn DiagramFeature::depth(self : DiagramFeature) -> Int { self.depth } +pub fn DiagramFeature::depth(self : DiagramFeature) -> Int { + self.depth +} ///| -pub fn DiagramFeature::with_color(self : DiagramFeature, color : String) -> DiagramFeature { - DiagramFeature::{ ..self, color } +pub fn DiagramFeature::with_color( + self : DiagramFeature, + color : String, +) -> DiagramFeature { + DiagramFeature::{ ..self, color, } } ///| -pub fn DiagramFeature::with_label(self : DiagramFeature, label : String) -> DiagramFeature { - DiagramFeature::{ ..self, label } +pub fn DiagramFeature::with_label( + self : DiagramFeature, + label : String, +) -> DiagramFeature { + DiagramFeature::{ ..self, label, } } ///| -pub fn DiagramFeature::with_depth(self : DiagramFeature, depth : Int) -> DiagramFeature { - DiagramFeature::{ ..self, depth } +pub fn DiagramFeature::with_depth( + self : DiagramFeature, + depth : Int, +) -> DiagramFeature { + DiagramFeature::{ ..self, depth, } } ///| -pub fn DiagramFeature::overlaps(self : DiagramFeature, start : Int, end : Int) -> Bool { +pub fn DiagramFeature::overlaps( + self : DiagramFeature, + start : Int, + end : Int, +) -> Bool { self.start < end && self.end > start } ///| pub fn DiagramFeature::length(self : DiagramFeature) -> Int { let diff = self.end - self.start - if diff > 0 { diff } else { -diff } + if diff > 0 { + diff + } else { + -diff + } } ///| @@ -213,37 +270,59 @@ pub fn TrackFeature::new( } ///| -pub fn TrackFeature::start(self : TrackFeature) -> Int { self.start } +pub fn TrackFeature::start(self : TrackFeature) -> Int { + self.start +} ///| -pub fn TrackFeature::end(self : TrackFeature) -> Int { self.end } +pub fn TrackFeature::end(self : TrackFeature) -> Int { + self.end +} ///| -pub fn TrackFeature::strand(self : TrackFeature) -> String { self.strand } +pub fn TrackFeature::strand(self : TrackFeature) -> String { + self.strand +} ///| -pub fn TrackFeature::label(self : TrackFeature) -> String { self.label } +pub fn TrackFeature::label(self : TrackFeature) -> String { + self.label +} ///| -pub fn TrackFeature::color(self : TrackFeature) -> String { self.color } +pub fn TrackFeature::color(self : TrackFeature) -> String { + self.color +} ///| -pub fn TrackFeature::shape(self : TrackFeature) -> FeatureShape { self.shape } +pub fn TrackFeature::shape(self : TrackFeature) -> FeatureShape { + self.shape +} ///| -pub fn TrackFeature::with_color(self : TrackFeature, color : String) -> TrackFeature { - TrackFeature::{ ..self, color } +pub fn TrackFeature::with_color( + self : TrackFeature, + color : String, +) -> TrackFeature { + TrackFeature::{ ..self, color, } } ///| -pub fn TrackFeature::with_label(self : TrackFeature, label : String) -> TrackFeature { - TrackFeature::{ ..self, label } +pub fn TrackFeature::with_label( + self : TrackFeature, + label : String, +) -> TrackFeature { + TrackFeature::{ ..self, label, } } ///| pub fn TrackFeature::length(self : TrackFeature) -> Int { let diff = self.end - self.start - if diff > 0 { diff } else { -diff } + if diff > 0 { + diff + } else { + -diff + } } ///| @@ -265,16 +344,24 @@ pub fn Track::new( } ///| -pub fn Track::name(self : Track) -> String { self.name } +pub fn Track::name(self : Track) -> String { + self.name +} ///| -pub fn Track::features(self : Track) -> Array[TrackFeature] { self.features } +pub fn Track::features(self : Track) -> Array[TrackFeature] { + self.features +} ///| -pub fn Track::is_labeled(self : Track) -> Bool { self.is_labeled } +pub fn Track::is_labeled(self : Track) -> Bool { + self.is_labeled +} ///| -pub fn Track::color_scheme(self : Track) -> String { self.color_scheme } +pub fn Track::color_scheme(self : Track) -> String { + self.color_scheme +} ///| pub fn Track::feature_count(self : Track) -> Int { @@ -313,11 +400,7 @@ pub struct Diagram { } ///| -pub fn Diagram::new( - name : String, - start : Int, - end : Int, -) -> Diagram { +pub fn Diagram::new(name : String, start : Int, end : Int) -> Diagram { Diagram::{ tracks: [], features: [], @@ -329,27 +412,43 @@ pub fn Diagram::new( } ///| -pub fn Diagram::name(self : Diagram) -> String { self.name } +pub fn Diagram::name(self : Diagram) -> String { + self.name +} ///| -pub fn Diagram::start(self : Diagram) -> Int { self.start } +pub fn Diagram::start(self : Diagram) -> Int { + self.start +} ///| -pub fn Diagram::end(self : Diagram) -> Int { self.end } +pub fn Diagram::end(self : Diagram) -> Int { + self.end +} ///| -pub fn Diagram::style(self : Diagram) -> DiagramStyle { self.style } +pub fn Diagram::style(self : Diagram) -> DiagramStyle { + self.style +} ///| -pub fn Diagram::tracks(self : Diagram) -> Array[Track] { self.tracks } +pub fn Diagram::tracks(self : Diagram) -> Array[Track] { + self.tracks +} ///| -pub fn Diagram::features(self : Diagram) -> Array[DiagramFeature] { self.features } +pub fn Diagram::features(self : Diagram) -> Array[DiagramFeature] { + self.features +} ///| pub fn Diagram::length(self : Diagram) -> Int { let diff = self.end - self.start - if diff > 0 { diff } else { -diff } + if diff > 0 { + diff + } else { + -diff + } } ///| @@ -368,7 +467,7 @@ pub fn Diagram::feature_count(self : Diagram) -> Int { ///| pub fn Diagram::with_style(self : Diagram, style : DiagramStyle) -> Diagram { - Diagram::{ ..self, style } + Diagram::{ ..self, style, } } ///| @@ -391,9 +490,7 @@ pub fn Diagram::add_feature_to_diagram( label : String, shape : FeatureShape, ) -> Diagram { - let feature = DiagramFeature::new( - start, end, strand=strand, label=label, shape=shape, - ) + let feature = DiagramFeature::new(start, end, strand~, label~, shape~) let new_features : Array[DiagramFeature] = [] for f in self.features { new_features.push(f) @@ -411,9 +508,7 @@ pub fn Diagram::add_feature_to_track( strand : String, label : String, ) -> Diagram { - let feature = TrackFeature::new( - start, end, strand=strand, label=label, - ) + let feature = TrackFeature::new(start, end, strand~, label~) let new_tracks : Array[Track] = [] for track in self.tracks { if track.name == track_name { @@ -426,7 +521,10 @@ pub fn Diagram::add_feature_to_track( } ///| -pub fn Diagram::get_track_features(self : Diagram, track_name : String) -> Array[TrackFeature] { +pub fn Diagram::get_track_features( + self : Diagram, + track_name : String, +) -> Array[TrackFeature] { for track in self.tracks { if track.name == track_name { return track.features @@ -476,9 +574,7 @@ pub fn Diagram::to_svg(self : Diagram, width : Int, height : Int) -> String { let scale = usable_w / len.to_double() let svg = StringBuilder::new() - svg.write_string( - " String { svg.write_string("\">\n") if self.style.border { - svg.write_string( - "\n", - ) + svg.write_string("\" fill=\"none\" stroke=\"#333\" stroke-width=\"2\"/>\n") } let name_y = 18.0 - svg.write_string( - " String { svg.write_string("\n") let backbone_y = height.to_double() - pad - svg.write_string( - " String { svg.write_string((w - pad).to_string()) svg.write_string("\" y2=\"") svg.write_string(backbone_y.to_string()) - svg.write_string( - "\" stroke=\"#666\" stroke-width=\"2\"/>\n", - ) + svg.write_string("\" stroke=\"#666\" stroke-width=\"2\"/>\n") let tick_count = 5 let tick_width = usable_w / tick_count.to_double() let mut ti = 0 while ti <= tick_count { let x = pad + ti.to_double() * tick_width - let pos = self.start + (ti.to_double() * len.to_double() / tick_count.to_double()).to_int() - svg.write_string( - " String { svg.write_string(x.to_string()) svg.write_string("\" y2=\"") svg.write_string((backbone_y + 5.0).to_string()) - svg.write_string( - "\" stroke=\"#666\" stroke-width=\"1\"/>\n", - ) - svg.write_string( - "\n") + svg.write_string(" String { let mut track_idx = 0 for track in self.tracks { let ty = top_tracks_y + track_idx.to_double() * (track_height + track_gap) - svg.write_string( - " String { for feat in track.features { let fx = pad + (feat.start - self.start).to_double() * scale let mut fw = (feat.end - feat.start).to_double() * scale - if fw < 1.0 { fw = 1.0 } + if fw < 1.0 { + fw = 1.0 + } let fy = ty + 2.0 let fh = track_height - 4.0 let color = feat.color match feat.shape { Arrow => { let tip_x = fx + fw - svg.write_string( - " String { svg.write_string("\" stroke=\"#333\" stroke-width=\"0.5\"/>\n") } _ => { - svg.write_string( - " String { } if feat.label.length() > 0 && track.is_labeled { let label_x = fx + fw / 2.0 - svg.write_string( - " String { track_idx = track_idx + 1 } - let feat_start_y = top_tracks_y + track_idx.to_double() * (track_height + track_gap) + 10.0 + let feat_start_y = top_tracks_y + + track_idx.to_double() * (track_height + track_gap) + + 10.0 let mut fi = 0 for feat in self.features { let fx = pad + (feat.start - self.start).to_double() * scale let mut fw = (feat.end - feat.start).to_double() * scale - if fw < 1.0 { fw = 1.0 } - let fy = feat_start_y + (fi.to_double() * 18.0) + if fw < 1.0 { + fw = 1.0 + } + let fy = feat_start_y + fi.to_double() * 18.0 let fh = 14.0 let color = feat.color let depth_offset = feat.depth.to_double() * 3.0 match feat.shape { Arrow => { let tip_x = fx + fw - svg.write_string( - " String { Diamond => { let cx = fx + fw / 2.0 let cy = fy + fh / 2.0 + depth_offset - svg.write_string( - " String { } CrossedArrow => { let tip_x = fx + fw - svg.write_string( - " String { svg.write_string(tip_x.to_string()) svg.write_string("\" y2=\"") svg.write_string((fy + fh / 2.0 + depth_offset).to_string()) - svg.write_string( - "\" stroke=\"", - ) + svg.write_string("\" stroke=\"") svg.write_string(color) svg.write_string("\" stroke-width=\"2\"/>\n") - svg.write_string( - " String { svg.write_string(tip_x.to_string()) svg.write_string("\" y2=\"") svg.write_string((fy + fh / 2.0 + depth_offset).to_string()) - svg.write_string( - "\" stroke=\"", - ) + svg.write_string("\" stroke=\"") svg.write_string(color) svg.write_string("\" stroke-width=\"2\"/>\n") } Terminators => { - svg.write_string( - " String { svg.write_string(fx.to_string()) svg.write_string("\" y2=\"") svg.write_string((fy + fh + depth_offset).to_string()) - svg.write_string( - "\" stroke=\"", - ) + svg.write_string("\" stroke=\"") svg.write_string(color) svg.write_string("\" stroke-width=\"3\"/>\n") - svg.write_string( - " String { svg.write_string((fx + fw).to_string()) svg.write_string("\" y2=\"") svg.write_string((fy + fh + depth_offset).to_string()) - svg.write_string( - "\" stroke=\"", - ) + svg.write_string("\" stroke=\"") svg.write_string(color) svg.write_string("\" stroke-width=\"3\"/>\n") } Rectangle => { - svg.write_string( - " String { } if feat.label.length() > 0 { let label_x = fx + fw / 2.0 - svg.write_string( - " Diagram { ///| /// Get all track features for a named track. -pub fn gd_get_features(diagram : Diagram, track_name : String) -> Array[TrackFeature] { +pub fn gd_get_features( + diagram : Diagram, + track_name : String, +) -> Array[TrackFeature] { diagram.get_track_features(track_name) } @@ -902,7 +960,10 @@ pub fn gd_to_svg_string(diagram : Diagram, width : Int, height : Int) -> String ///| /// Set the color of a diagram feature. -pub fn gd_set_feature_color(feature : DiagramFeature, color : String) -> DiagramFeature { +pub fn gd_set_feature_color( + feature : DiagramFeature, + color : String, +) -> DiagramFeature { feature.with_color(color) } @@ -910,4 +971,4 @@ pub fn gd_set_feature_color(feature : DiagramFeature, color : String) -> Diagram /// Auto-label features larger than min_size that have no label. pub fn gd_label_features(diagram : Diagram, min_size : Int) -> Diagram { diagram.label_features_auto(min_size) -} \ No newline at end of file +} diff --git a/src/genomic_ranges.mbt b/src/genomic_ranges.mbt index 8cbb7e2a..09ef8710 100644 --- a/src/genomic_ranges.mbt +++ b/src/genomic_ranges.mbt @@ -734,7 +734,10 @@ pub fn follow(gr1 : GRanges, gr2 : GRanges) -> Array[Int] { ///| /// Calculate coverage of genomic ranges. /// Returns a map of seqname to coverage array. -pub fn coverage_granges(gr : GRanges, seqlengths : Map[String, Int]) -> Map[String, Array[Int]] { +pub fn coverage_granges( + gr : GRanges, + seqlengths : Map[String, Int], +) -> Map[String, Array[Int]] { let result : Map[String, Array[Int]] = Map([], capacity=10) let seqnames = gr.seqnames @@ -772,7 +775,10 @@ pub fn coverage_granges(gr : GRanges, seqlengths : Map[String, Int]) -> Map[Stri ///| /// Calculate coverage as a GRanges object (run-length encoding). -pub fn coverage_as_granges(gr : GRanges, seqlengths : Map[String, Int]) -> GRanges { +pub fn coverage_as_granges( + gr : GRanges, + seqlengths : Map[String, Int], +) -> GRanges { let result_seqnames : Array[String] = Array::new() let result_starts : Array[Int] = Array::new() let result_ends : Array[Int] = Array::new() @@ -854,7 +860,11 @@ pub fn distance_to_nearest(gr : GRanges) -> Array[Int] { j = j + 1 } - distances[i] = if min_dist < @double.infinity { min_dist.to_int() } else { -1 } + distances[i] = if min_dist < @double.infinity { + min_dist.to_int() + } else { + -1 + } i = i + 1 } @@ -952,6 +962,7 @@ pub fn granges_sort(gr : GRanges) -> GRanges { } } +///| fn compare_granges_pos(gr : GRanges, idx1 : Int, idx2 : Int) -> Int { if gr.seqnames[idx1] < gr.seqnames[idx2] { -1 @@ -966,9 +977,13 @@ fn compare_granges_pos(gr : GRanges, idx1 : Int, idx2 : Int) -> Int { } } -///| Test precede function +///| +/// Test precede function test "precede" { - let gr1 = granges(["chr1", "chr1"], [(10, 20), (30, 40)], [strand_plus(), strand_plus()]) + let gr1 = granges(["chr1", "chr1"], [(10, 20), (30, 40)], [ + strand_plus(), + strand_plus(), + ]) let gr2 = granges(["chr1"], [(5, 8)], [strand_plus()]) let result = precede(gr1, gr2) assert_eq(result.length(), 2) @@ -976,9 +991,13 @@ test "precede" { assert_eq(result[0], 0) } -///| Test follow function +///| +/// Test follow function test "follow" { - let gr1 = granges(["chr1", "chr1"], [(10, 20), (30, 40)], [strand_plus(), strand_plus()]) + let gr1 = granges(["chr1", "chr1"], [(10, 20), (30, 40)], [ + strand_plus(), + strand_plus(), + ]) let gr2 = granges(["chr1"], [(50, 60)], [strand_plus()]) let result = follow(gr1, gr2) assert_eq(result.length(), 2) @@ -986,9 +1005,13 @@ test "follow" { assert_eq(result[1], 0) } -///| Test coverage_granges function +///| +/// Test coverage_granges function test "coverage_granges" { - let gr = granges(["chr1", "chr1"], [(1, 5), (3, 8)], [strand_plus(), strand_plus()]) + let gr = granges(["chr1", "chr1"], [(1, 5), (3, 8)], [ + strand_plus(), + strand_plus(), + ]) let seqlengths : Map[String, Int] = Map([], capacity=1) seqlengths["chr1"] = 10 let result = coverage_granges(gr, seqlengths) @@ -1003,7 +1026,8 @@ test "coverage_granges" { assert_eq(cov[5], 1) } -///| Test distance_to_nearest function +///| +/// Test distance_to_nearest function test "distance_to_nearest" { let gr = granges(["chr1", "chr1", "chr1"], [(1, 5), (15, 20), (30, 35)], [ strand_plus(), @@ -1016,9 +1040,13 @@ test "distance_to_nearest" { assert_eq(result[0], 9) } -///| Test coverage_as_granges function +///| +/// Test coverage_as_granges function test "coverage_as_granges" { - let gr = granges(["chr1", "chr1"], [(1, 5), (3, 8)], [strand_plus(), strand_plus()]) + let gr = granges(["chr1", "chr1"], [(1, 5), (3, 8)], [ + strand_plus(), + strand_plus(), + ]) let seqlengths : Map[String, Int] = Map([], capacity=1) seqlengths["chr1"] = 10 let result = coverage_as_granges(gr, seqlengths) diff --git a/src/genomic_ranges_advanced.mbt b/src/genomic_ranges_advanced.mbt index 0f96b48c..ed4906c6 100644 --- a/src/genomic_ranges_advanced.mbt +++ b/src/genomic_ranges_advanced.mbt @@ -20,11 +20,7 @@ /// /// If both n and width are specified, width takes precedence. /// Returns a new GRanges with the tiled sub-ranges. -pub fn granges_tile( - gr : GRanges, - n? : Int = 0, - width? : Int = 0, -) -> GRanges { +pub fn granges_tile(gr : GRanges, n? : Int = 0, width? : Int = 0) -> GRanges { let n_ranges = gr.seqnames.length() let result_seqnames : Array[String] = Array::new() let result_ranges : Array[(Int, Int)] = Array::new() @@ -41,11 +37,7 @@ pub fn granges_tile( // Tile by fixed width let mut pos = start while pos <= end { - let tile_end = if pos + width - 1 < end { - pos + width - 1 - } else { - end - } + let tile_end = if pos + width - 1 < end { pos + width - 1 } else { end } result_seqnames.push(seqname) result_ranges.push((pos, tile_end)) result_strands.push(strand) @@ -107,11 +99,7 @@ pub fn granges_sliding_windows( let mut pos = start while pos <= end { - let win_end = if pos + width - 1 < end { - pos + width - 1 - } else { - end - } + let win_end = if pos + width - 1 < end { pos + width - 1 } else { end } // Only add windows that are at least half the width let actual_width = win_end - pos + 1 if actual_width >= width / 2 || pos == start { @@ -136,10 +124,7 @@ pub fn granges_sliding_windows( /// - width: Width of each tile /// /// Returns a GRanges with tiles covering the entire genome. -pub fn tile_genome( - seqlengths : Array[(String, Int)], - width : Int, -) -> GRanges { +pub fn tile_genome(seqlengths : Array[(String, Int)], width : Int) -> GRanges { let result_seqnames : Array[String] = Array::new() let result_ranges : Array[(Int, Int)] = Array::new() let result_strands : Array[Strand] = Array::new() @@ -274,7 +259,10 @@ pub fn bin_genome( let result : Array[(String, Int, Int, Int, Double)] = Array::new() // Group ranges by chromosome - let chrom_map : Map[String, Array[(Int, Int)]] = Map([], capacity=seqlengths.length()) + let chrom_map : Map[String, Array[(Int, Int)]] = Map( + [], + capacity=seqlengths.length(), + ) for i = 0; i < gr.seqnames.length(); i = i + 1 { let chrom = gr.seqnames[i] let ranges = chrom_map.get(chrom) @@ -517,10 +505,7 @@ fn sort_ranges(ranges : Array[(Int, Int)]) -> Array[(Int, Int)] { ///| /// Subtract ranges: find regions in gr1 not covered by gr2. -pub fn granges_subtract( - gr1 : GRanges, - gr2 : GRanges, -) -> GRanges { +pub fn granges_subtract(gr1 : GRanges, gr2 : GRanges) -> GRanges { let result_seqnames : Array[String] = Array::new() let result_ranges : Array[(Int, Int)] = Array::new() let result_strands : Array[Strand] = Array::new() diff --git a/src/genomic_ranges_gaps.mbt b/src/genomic_ranges_gaps.mbt index 2ebf5cb2..9f89e694 100644 --- a/src/genomic_ranges_gaps.mbt +++ b/src/genomic_ranges_gaps.mbt @@ -61,7 +61,7 @@ pub fn grg_granges( let n = seqnames.length() let final_strands : Array[String] = Array::make(n, "+") match strands { - Some(s) => { + Some(s) => if s.length() == n { let mut i = 0 while i < n { @@ -69,7 +69,6 @@ pub fn grg_granges( i = i + 1 } } - } None => () } GRangesLocal::{ seqnames, starts, ends, strands: final_strands } @@ -161,7 +160,11 @@ pub fn grg_gaps(gr : GRangesLocal, seqlengths : Map[String, Int]) -> GapResult { if !seen.contains(seqname) { seen[seqname] = () - let seqlen : Int = if seqlengths.contains(seqname) { seqlengths[seqname] } else { 0 } + let seqlen : Int = if seqlengths.contains(seqname) { + seqlengths[seqname] + } else { + 0 + } if seqlen > 0 { let ranges : Array[(Int, Int)] = [] @@ -205,7 +208,11 @@ pub fn grg_gaps(gr : GRangesLocal, seqlengths : Map[String, Int]) -> GapResult { m = m + 1 } - let last_end = if merged.length() == 0 { 0 } else { merged[merged.length() - 1].1 } + let last_end = if merged.length() == 0 { + 0 + } else { + merged[merged.length() - 1].1 + } let final_gap_start = last_end + 1 let final_gap_end = seqlen if final_gap_start <= final_gap_end { @@ -289,10 +296,15 @@ pub fn grg_reduce(gr : GRangesLocal, min_gap? : Int) -> GrgReduceResult { } else { let last_end = merged_ends[merged_ends.length() - 1] if current.0 <= last_end + gap + 1 { - let new_end = if current.1 > last_end { current.1 } else { last_end } + let new_end = if current.1 > last_end { + current.1 + } else { + last_end + } merged_ends[merged_ends.length() - 1] = new_end - merged_counts[merged_counts.length() - 1] = - merged_counts[merged_counts.length() - 1] + cnt + merged_counts[merged_counts.length() - 1] = merged_counts[merged_counts.length() - + 1] + + cnt } else { merged_starts.push(current.0) merged_ends.push(current.1) @@ -566,7 +578,10 @@ pub fn grg_union(gr1 : GRangesLocal, gr2 : GRangesLocal) -> GRangesLocal { /// /// Returns a Map from seqname to Array[Int] of length seqlength, /// where index i contains the number of ranges covering position i+1. -pub fn grg_compute_coverage(gr : GRangesLocal, seqlengths : Map[String, Int]) -> Map[String, Array[Int]] { +pub fn grg_compute_coverage( + gr : GRangesLocal, + seqlengths : Map[String, Int], +) -> Map[String, Array[Int]] { let result : Map[String, Array[Int]] = Map([], capacity=10) let keys = seqlengths.keys().collect() @@ -609,7 +624,10 @@ pub fn grg_compute_coverage(gr : GRangesLocal, seqlengths : Map[String, Int]) -> /// Returns a GRangesLocal where ranges that extend beyond the /// chromosome boundaries are clipped to [1, seqlength]. Ranges /// that fall entirely outside are removed. -pub fn grg_trim(gr : GRangesLocal, seqlengths : Map[String, Int]) -> GRangesLocal { +pub fn grg_trim( + gr : GRangesLocal, + seqlengths : Map[String, Int], +) -> GRangesLocal { let seqnames : Array[String] = [] let starts : Array[Int] = [] let ends : Array[Int] = [] @@ -743,11 +761,7 @@ test "grg_gaps_no_gaps_single_range" { ///| test "grg_gaps_finds_gaps_between_ranges" { - let gr = grg_granges( - ["chr1", "chr1"], - [1, 30], - [10, 50], - ) + let gr = grg_granges(["chr1", "chr1"], [1, 30], [10, 50]) let sl : Map[String, Int] = Map([], capacity=1) sl["chr1"] = 100 let gaps = grg_gaps(gr, sl) @@ -772,11 +786,7 @@ test "grg_gaps_empty_input" { ///| test "grg_gaps_overlapping_ranges_merged" { - let gr = grg_granges( - ["chr1", "chr1", "chr1"], - [1, 5, 20], - [10, 15, 30], - ) + let gr = grg_granges(["chr1", "chr1", "chr1"], [1, 5, 20], [10, 15, 30]) let sl : Map[String, Int] = Map([], capacity=1) sl["chr1"] = 50 let gaps = grg_gaps(gr, sl) @@ -789,11 +799,7 @@ test "grg_gaps_overlapping_ranges_merged" { ///| test "grg_reduce_merges_overlapping" { - let gr = grg_granges( - ["chr1", "chr1"], - [1, 5], - [10, 15], - ) + let gr = grg_granges(["chr1", "chr1"], [1, 5], [10, 15]) let result = grg_reduce(gr) assert_eq(result.seqnames.length(), 1) assert_eq(result.starts[0], 1) @@ -803,11 +809,7 @@ test "grg_reduce_merges_overlapping" { ///| test "grg_reduce_merges_adjacent" { - let gr = grg_granges( - ["chr1", "chr1"], - [1, 11], - [10, 20], - ) + let gr = grg_granges(["chr1", "chr1"], [1, 11], [10, 20]) let result = grg_reduce(gr) assert_eq(result.seqnames.length(), 1) assert_eq(result.starts[0], 1) @@ -816,11 +818,7 @@ test "grg_reduce_merges_adjacent" { ///| test "grg_reduce_no_overlap" { - let gr = grg_granges( - ["chr1", "chr1"], - [1, 30], - [10, 50], - ) + let gr = grg_granges(["chr1", "chr1"], [1, 30], [10, 50]) let result = grg_reduce(gr) assert_eq(result.seqnames.length(), 2) assert_eq(result.starts[0], 1) @@ -838,11 +836,7 @@ test "grg_reduce_empty_input" { ///| test "grg_disjoin_splits_overlapping" { - let gr = grg_granges( - ["chr1", "chr1"], - [1, 5], - [10, 15], - ) + let gr = grg_granges(["chr1", "chr1"], [1, 5], [10, 15]) let result = grg_disjoin(gr) assert_eq(result.seqnames.length(), 3) assert_eq(result.starts[0], 1) @@ -855,11 +849,7 @@ test "grg_disjoin_splits_overlapping" { ///| test "grg_disjoin_no_overlap" { - let gr = grg_granges( - ["chr1", "chr1"], - [1, 20], - [10, 30], - ) + let gr = grg_granges(["chr1", "chr1"], [1, 20], [10, 30]) let result = grg_disjoin(gr) assert_eq(result.seqnames.length(), 3) assert_eq(result.starts[0], 1) @@ -945,11 +935,7 @@ test "grg_union_disjoint_ranges" { ///| test "grg_compute_coverage_basic" { - let gr = grg_granges( - ["chr1", "chr1"], - [1, 3], - [5, 8], - ) + let gr = grg_granges(["chr1", "chr1"], [1, 3], [5, 8]) let sl : Map[String, Int] = Map([], capacity=1) sl["chr1"] = 10 let cov = grg_compute_coverage(gr, sl) @@ -975,11 +961,7 @@ test "grg_compute_coverage_no_ranges" { ///| test "grg_trim_clips_beyond_chromosome" { - let gr = grg_granges( - ["chr1", "chr1"], - [-5, 8], - [10, 30], - ) + let gr = grg_granges(["chr1", "chr1"], [-5, 8], [10, 30]) let sl : Map[String, Int] = Map([], capacity=1) sl["chr1"] = 20 let result = grg_trim(gr, sl) @@ -992,11 +974,7 @@ test "grg_trim_clips_beyond_chromosome" { ///| test "grg_trim_removes_completely_outside" { - let gr = grg_granges( - ["chr1", "chr1"], - [1, 25], - [10, 30], - ) + let gr = grg_granges(["chr1", "chr1"], [1, 25], [10, 30]) let sl : Map[String, Int] = Map([], capacity=1) sl["chr1"] = 20 let result = grg_trim(gr, sl) @@ -1007,12 +985,7 @@ test "grg_trim_removes_completely_outside" { ///| test "grg_promoters_plus_strand" { - let gr = grg_granges( - ["chr1"], - [100], - [200], - strands=["+"], - ) + let gr = grg_granges(["chr1"], [100], [200], strands=["+"]) let result = grg_promoters(gr, upstream=50, downstream=20) assert_eq(result.seqnames.length(), 1) assert_eq(result.starts[0], 50) @@ -1021,12 +994,7 @@ test "grg_promoters_plus_strand" { ///| test "grg_promoters_minus_strand" { - let gr = grg_granges( - ["chr1"], - [100], - [200], - strands=["-"], - ) + let gr = grg_granges(["chr1"], [100], [200], strands=["-"]) let result = grg_promoters(gr, upstream=50, downstream=20) assert_eq(result.seqnames.length(), 1) assert_eq(result.starts[0], 181) @@ -1035,12 +1003,7 @@ test "grg_promoters_minus_strand" { ///| test "grg_promoters_star_strand_two_outputs" { - let gr = grg_granges( - ["chr1"], - [100], - [200], - strands=["*"], - ) + let gr = grg_granges(["chr1"], [100], [200], strands=["*"]) let result = grg_promoters(gr, upstream=50, downstream=20) assert_eq(result.seqnames.length(), 2) assert_eq(result.strands[0], "+") @@ -1063,11 +1026,7 @@ test "grg_setdiff_different_chromosomes" { ///| test "grg_gaps_multiple_chromosomes" { - let gr = grg_granges( - ["chr1", "chr2"], - [1, 1], - [10, 10], - ) + let gr = grg_granges(["chr1", "chr2"], [1, 1], [10, 10]) let sl : Map[String, Int] = Map([], capacity=2) sl["chr1"] = 20 sl["chr2"] = 30 diff --git a/src/geo.mbt b/src/geo.mbt index 871456bd..f1ce2d99 100644 --- a/src/geo.mbt +++ b/src/geo.mbt @@ -278,7 +278,7 @@ pub struct GeoFile { ///| /// Create a GeoFile. pub fn GeoFile::new(records : Array[GeoRecord]) -> GeoFile { - { records } + { records, } } ///| @@ -417,12 +417,7 @@ pub fn geo_parse(text : String) -> GeoFile { let keyword = trim(rest[0:eq_pos].to_string()) let accession = trim(rest[eq_pos + 1:rest.length()].to_string()) let etype = geo_entity_type_from_keyword(keyword) - let (record, next) = geo_parse_record( - lines, - idx + 1, - etype, - accession, - ) + let (record, next) = geo_parse_record(lines, idx + 1, etype, accession) records.push(record) idx = next } else { @@ -473,12 +468,10 @@ fn geo_parse_record( None => () } in_table = true - } else { // Data row (if we're in a table section with columns defined) - if in_table && columns.length() > 0 { - let fields = geo_split_tab(line) - rows.push(fields) - } + } else if in_table && columns.length() > 0 { + let fields = geo_split_tab(line) + rows.push(fields) } idx = idx + 1 } @@ -543,8 +536,11 @@ pub fn GeoAttribute::to_string(self : GeoAttribute) -> String { ///| /// Format a GeoDataTable as a readable string. pub fn GeoDataTable::to_string(self : GeoDataTable) -> String { - let mut s = "DataTable(" + self.n_columns().to_string() + " cols, " + - self.n_rows().to_string() + " rows)\n" + let mut s = "DataTable(" + + self.n_columns().to_string() + + " cols, " + + self.n_rows().to_string() + + " rows)\n" // Column headers s = s + " " for i in 0.. String { ///| /// Format a GeoRecord as a readable string. pub fn GeoRecord::to_string(self : GeoRecord) -> String { - let mut s = "GeoRecord(type=" + self.entity_type.to_string() + ", accession=" + - self.accession + ")\n" + let mut s = "GeoRecord(type=" + + self.entity_type.to_string() + + ", accession=" + + self.accession + + ")\n" s = s + "Attributes (" + self.attributes.length().to_string() + "):\n" for attr in self.attributes { s = s + " " + attr.to_string() + "\n" diff --git a/src/gfa_io.mbt b/src/gfa_io.mbt index 37ecf2ee..0e3d796b 100644 --- a/src/gfa_io.mbt +++ b/src/gfa_io.mbt @@ -172,14 +172,7 @@ pub fn GfaLink::new( overlap : String, tags : Array[GfaTag], ) -> GfaLink { - GfaLink::{ - from_segment, - from_orient, - to_segment, - to_orient, - overlap, - tags, - } + GfaLink::{ from_segment, from_orient, to_segment, to_orient, overlap, tags } } ///| @@ -530,14 +523,7 @@ pub fn gfa_parse_link(fields : Array[String]) -> GfaLink { let to_orient = if n > 4 { fields[4] } else { "+" } let overlap = if n > 5 { fields[5] } else { "*" } let tags = if n > 6 { gfa_parse_tags(fields, 6) } else { Array::new() } - GfaLink::{ - from_segment, - from_orient, - to_segment, - to_orient, - overlap, - tags, - } + GfaLink::{ from_segment, from_orient, to_segment, to_orient, overlap, tags } } ///| diff --git a/src/gff.mbt b/src/gff.mbt index db221e53..580ebd36 100644 --- a/src/gff.mbt +++ b/src/gff.mbt @@ -23,7 +23,7 @@ pub fn GFFFeature::new( feature_type : String, start : Int, end : Int, - strand : String + strand : String, ) -> GFFFeature { GFFFeature::{ seqid, @@ -34,7 +34,7 @@ pub fn GFFFeature::new( score: None, strand, phase: None, - attributes: Map([], capacity=0) + attributes: Map([], capacity=0), } } @@ -49,7 +49,7 @@ pub fn GFFFeature::set_score(self : GFFFeature, score : Double) -> GFFFeature { score: Some(score), strand: self.strand, phase: self.phase, - attributes: self.attributes + attributes: self.attributes, } } @@ -64,12 +64,16 @@ pub fn GFFFeature::set_phase(self : GFFFeature, phase : Int) -> GFFFeature { score: self.score, strand: self.strand, phase: Some(phase), - attributes: self.attributes + attributes: self.attributes, } } ///| -pub fn GFFFeature::add_attribute(self : GFFFeature, key : String, value : String) -> GFFFeature { +pub fn GFFFeature::add_attribute( + self : GFFFeature, + key : String, + value : String, +) -> GFFFeature { let new_attrs = self.attributes new_attrs.set(key, value) GFFFeature::{ @@ -81,7 +85,7 @@ pub fn GFFFeature::add_attribute(self : GFFFeature, key : String, value : String score: self.score, strand: self.strand, phase: self.phase, - attributes: new_attrs + attributes: new_attrs, } } @@ -116,7 +120,9 @@ pub fn GFFFeature::length(self : GFFFeature) -> Int { ///| pub fn GFFFeature::is_coding(self : GFFFeature) -> Bool { - self.feature_type == "CDS" || self.feature_type == "mRNA" || self.feature_type == "gene" + self.feature_type == "CDS" || + self.feature_type == "mRNA" || + self.feature_type == "gene" } ///| @@ -141,34 +147,37 @@ pub fn GFFRecord::new() -> GFFRecord { GFFRecord::{ features: Array::new(), sequences: Map([], capacity=0), - version: "3" + version: "3", } } ///| -pub fn GFFRecord::add_feature(self : GFFRecord, feature : GFFFeature) -> GFFRecord { +pub fn GFFRecord::add_feature( + self : GFFRecord, + feature : GFFFeature, +) -> GFFRecord { let new_features = self.features new_features.push(feature) GFFRecord::{ features: new_features, sequences: self.sequences, - version: self.version + version: self.version, } } ///| -pub fn GFFRecord::add_sequence(self : GFFRecord, seqid : String, sequence : String) -> GFFRecord { +pub fn GFFRecord::add_sequence( + self : GFFRecord, + seqid : String, + sequence : String, +) -> GFFRecord { self.sequences.set(seqid, sequence) self } ///| pub fn GFFRecord::set_version(self : GFFRecord, version : String) -> GFFRecord { - GFFRecord::{ - features: self.features, - sequences: self.sequences, - version: version - } + GFFRecord::{ features: self.features, sequences: self.sequences, version } } ///| @@ -181,7 +190,10 @@ pub fn GFFRecord::get_sequence(self : GFFRecord, seqid : String) -> String? { } ///| -pub fn GFFRecord::get_features_by_type(self : GFFRecord, feature_type : String) -> Array[GFFFeature] { +pub fn GFFRecord::get_features_by_type( + self : GFFRecord, + feature_type : String, +) -> Array[GFFFeature] { let result : Array[GFFFeature] = Array::new() let mut i = 0 while i < self.features.length() { @@ -194,7 +206,10 @@ pub fn GFFRecord::get_features_by_type(self : GFFRecord, feature_type : String) } ///| -pub fn GFFRecord::get_features_by_seqid(self : GFFRecord, seqid : String) -> Array[GFFFeature] { +pub fn GFFRecord::get_features_by_seqid( + self : GFFRecord, + seqid : String, +) -> Array[GFFFeature] { let result : Array[GFFFeature] = Array::new() let mut i = 0 while i < self.features.length() { @@ -207,16 +222,15 @@ pub fn GFFRecord::get_features_by_seqid(self : GFFRecord, seqid : String) -> Arr } ///| -pub fn GFFRecord::get_features_by_id(self : GFFRecord, id : String) -> Array[GFFFeature] { +pub fn GFFRecord::get_features_by_id( + self : GFFRecord, + id : String, +) -> Array[GFFFeature] { let result : Array[GFFFeature] = Array::new() let mut i = 0 while i < self.features.length() { match self.features[i].get_id() { - Some(feature_id) => { - if feature_id == id { - result.push(self.features[i]) - } - } + Some(feature_id) => if feature_id == id { result.push(self.features[i]) } None => () } i = i + 1 @@ -225,7 +239,10 @@ pub fn GFFRecord::get_features_by_id(self : GFFRecord, id : String) -> Array[GFF } ///| -pub fn GFFRecord::get_child_features(self : GFFRecord, parent_id : String) -> Array[GFFFeature] { +pub fn GFFRecord::get_child_features( + self : GFFRecord, + parent_id : String, +) -> Array[GFFFeature] { let result : Array[GFFFeature] = Array::new() let mut i = 0 while i < self.features.length() { @@ -270,15 +287,21 @@ pub fn GFFRecord::get_exons(self : GFFRecord) -> Array[GFFFeature] { } ///| -pub fn GFFRecord::get_transcripts_for_gene(self : GFFRecord, gene_id : String) -> Array[GFFFeature] { +pub fn GFFRecord::get_transcripts_for_gene( + self : GFFRecord, + gene_id : String, +) -> Array[GFFFeature] { self.get_child_features(gene_id) } ///| -pub fn GFFRecord::get_cds_for_transcript(self : GFFRecord, transcript_id : String) -> Array[GFFFeature] { +pub fn GFFRecord::get_cds_for_transcript( + self : GFFRecord, + transcript_id : String, +) -> Array[GFFFeature] { let result : Array[GFFFeature] = Array::new() let children = self.get_child_features(transcript_id) - + let mut i = 0 while i < children.length() { if children[i].feature_type == "CDS" { @@ -299,7 +322,7 @@ pub fn GFFRecord::get_cds_for_transcript(self : GFFRecord, transcript_id : Strin } i = i + 1 } - + result } @@ -307,7 +330,7 @@ pub fn GFFRecord::get_cds_for_transcript(self : GFFRecord, transcript_id : Strin pub fn parse_attributes(attr_str : String) -> Map[String, String] { let attrs = Map([], capacity=0) let pairs = split_by_char(attr_str, ';'.to_int()) - + let mut i = 0 while i < pairs.length() { let pair = trim(pairs[i]) @@ -321,7 +344,7 @@ pub fn parse_attributes(attr_str : String) -> Map[String, String] { } i = i + 1 } - + attrs } @@ -342,7 +365,7 @@ fn string_replace(s : String, from : String, to : String) -> String { if m == 0 || m > n { return s } - + let mut result = "" let mut i = 0 while i < n { @@ -361,12 +384,12 @@ fn string_replace(s : String, from : String, to : String) -> String { ///| pub fn bio_parse_gff(content : String) -> GFFRecord { let mut record = GFFRecord::new() - + let lines = split_by_char(content, '\n'.to_int()) let mut i = 0 while i < lines.length() { let line = trim(lines[i]) - + if line == "" || starts_with(line, 0, "#") { if starts_with(line, 0, "##gff-version") { let parts = split_by_char(line, ' '.to_int()) @@ -377,7 +400,7 @@ pub fn bio_parse_gff(content : String) -> GFFRecord { i = i + 1 continue } - + let fields = split_by_char(line, '\t'.to_int()) if fields.length() >= 8 { let seqid = trim(fields[0]) @@ -386,21 +409,23 @@ pub fn bio_parse_gff(content : String) -> GFFRecord { let start = parse_int(trim(fields[3])) let end = parse_int(trim(fields[4])) let strand = trim(fields[6]) - - let mut feature = GFFFeature::new(seqid, source, feature_type, start, end, strand) - + + let mut feature = GFFFeature::new( + seqid, source, feature_type, start, end, strand, + ) + if fields.length() > 5 && trim(fields[5]) != "." { match parse_double(trim(fields[5])) { Some(score) => feature = feature.set_score(score) None => () } } - + if fields.length() > 7 && trim(fields[7]) != "." { let phase = parse_int(trim(fields[7])) feature = feature.set_phase(phase) } - + if fields.length() > 8 { let attrs = parse_attributes(trim(fields[8])) let entries = attrs.iter().collect() @@ -411,20 +436,20 @@ pub fn bio_parse_gff(content : String) -> GFFRecord { j = j + 1 } } - + ignore(record.add_feature(feature)) } - + i = i + 1 } - + record } ///| pub fn GFFRecord::to_gff(self : GFFRecord) -> String { let mut result = "##gff-version ".to_string() + self.version + "\n" - + let mut i = 0 while i < self.features.length() { let f = self.features[i] @@ -433,19 +458,19 @@ pub fn GFFRecord::to_gff(self : GFFRecord) -> String { result = result + f.feature_type + "\t" result = result + f.start.to_string() + "\t" result = result + f.end.to_string() + "\t" - + match f.score { Some(s) => result = result + s.to_string() + "\t" None => result = result + ".\t" } - + result = result + f.strand + "\t" - + match f.phase { Some(p) => result = result + p.to_string() + "\t" None => result = result + ".\t" } - + let attrs = f.attributes.iter().collect() let mut j = 0 while j < attrs.length() { @@ -457,10 +482,10 @@ pub fn GFFRecord::to_gff(self : GFFRecord) -> String { j = j + 1 } result = result + "\n" - + i = i + 1 } - + result } @@ -477,59 +502,61 @@ fn escape_attribute_value(value : String) -> String { ///| pub fn create_example_gff() -> GFFRecord { let record = GFFRecord::new() - + let gene = GFFFeature::new("chr1", "Ensembl", "gene", 10000, 15000, "+") .add_attribute("ID", "gene:ENSG00000130203") .add_attribute("Name", "TP53") .add_attribute("biotype", "protein_coding") ignore(record.add_feature(gene)) - + let mrna = GFFFeature::new("chr1", "Ensembl", "mRNA", 10100, 14800, "+") .add_attribute("ID", "transcript:ENST00000335137") .add_attribute("Parent", "gene:ENSG00000130203") .add_attribute("biotype", "protein_coding") .add_attribute("transcript_id", "ENST00000335137") ignore(record.add_feature(mrna)) - + let exon1 = GFFFeature::new("chr1", "Ensembl", "exon", 10100, 10200, "+") .add_attribute("ID", "exon:ENST00000335137:1") .add_attribute("Parent", "transcript:ENST00000335137") ignore(record.add_feature(exon1)) - + let exon2 = GFFFeature::new("chr1", "Ensembl", "exon", 10500, 10600, "+") .add_attribute("ID", "exon:ENST00000335137:2") .add_attribute("Parent", "transcript:ENST00000335137") ignore(record.add_feature(exon2)) - + let exon3 = GFFFeature::new("chr1", "Ensembl", "exon", 11000, 11500, "+") .add_attribute("ID", "exon:ENST00000335137:3") .add_attribute("Parent", "transcript:ENST00000335137") ignore(record.add_feature(exon3)) - + let cds1 = GFFFeature::new("chr1", "Ensembl", "CDS", 10100, 10200, "+") .add_attribute("ID", "cds:ENST00000335137:1") .add_attribute("Parent", "transcript:ENST00000335137") .set_phase(0) ignore(record.add_feature(cds1)) - + let cds2 = GFFFeature::new("chr1", "Ensembl", "CDS", 10500, 10600, "+") .add_attribute("ID", "cds:ENST00000335137:2") .add_attribute("Parent", "transcript:ENST00000335137") .set_phase(0) ignore(record.add_feature(cds2)) - + let cds3 = GFFFeature::new("chr1", "Ensembl", "CDS", 11000, 11450, "+") .add_attribute("ID", "cds:ENST00000335137:3") .add_attribute("Parent", "transcript:ENST00000335137") .set_phase(0) ignore(record.add_feature(cds3)) - - let gene2 = GFFFeature::new("chr17", "Ensembl", "gene", 43044295, 43125370, "-") + + let gene2 = GFFFeature::new( + "chr17", "Ensembl", "gene", 43044295, 43125370, "-", + ) .add_attribute("ID", "gene:ENSG00000141510") .add_attribute("Name", "BRCA1") .add_attribute("biotype", "protein_coding") ignore(record.add_feature(gene2)) - + record } @@ -542,7 +569,7 @@ pub fn GFFRecord::count_features(self : GFFRecord) -> Int { pub fn GFFRecord::get_unique_seqids(self : GFFRecord) -> Array[String] { let result : Array[String] = Array::new() let seen : Map[String, Bool] = Map([], capacity=0) - + let mut i = 0 while i < self.features.length() { let seqid = self.features[i].seqid @@ -552,7 +579,7 @@ pub fn GFFRecord::get_unique_seqids(self : GFFRecord) -> Array[String] { } i = i + 1 } - + result } @@ -560,7 +587,7 @@ pub fn GFFRecord::get_unique_seqids(self : GFFRecord) -> Array[String] { pub fn GFFRecord::get_unique_feature_types(self : GFFRecord) -> Array[String] { let result : Array[String] = Array::new() let seen : Map[String, Bool] = Map([], capacity=0) - + let mut i = 0 while i < self.features.length() { let ftype = self.features[i].feature_type @@ -570,12 +597,17 @@ pub fn GFFRecord::get_unique_feature_types(self : GFFRecord) -> Array[String] { } i = i + 1 } - + result } ///| -pub fn GFFRecord::get_features_in_range(self : GFFRecord, seqid : String, start : Int, end : Int) -> Array[GFFFeature] { +pub fn GFFRecord::get_features_in_range( + self : GFFRecord, + seqid : String, + start : Int, + end : Int, +) -> Array[GFFFeature] { let result : Array[GFFFeature] = Array::new() let mut i = 0 while i < self.features.length() { @@ -589,7 +621,10 @@ pub fn GFFRecord::get_features_in_range(self : GFFRecord, seqid : String, start } ///| -pub fn GFFRecord::calculate_gene_length(self : GFFRecord, gene_id : String) -> Int { +pub fn GFFRecord::calculate_gene_length( + self : GFFRecord, + gene_id : String, +) -> Int { let cds_features = self.get_cds_for_transcript(gene_id) let mut total_length = 0 let mut i = 0 @@ -598,4 +633,4 @@ pub fn GFFRecord::calculate_gene_length(self : GFFRecord, gene_id : String) -> I i = i + 1 } total_length -} \ No newline at end of file +} diff --git a/src/ggtree.mbt b/src/ggtree.mbt index afe13dae..a0334efe 100644 --- a/src/ggtree.mbt +++ b/src/ggtree.mbt @@ -20,13 +20,7 @@ pub fn LayoutNode::new( branch_length : Double, is_leaf : Bool, ) -> LayoutNode { - LayoutNode::{ - id, - label, - branch_length, - is_leaf, - children: [], - } + LayoutNode::{ id, label, branch_length, is_leaf, children: [] } } ///| @@ -117,7 +111,9 @@ pub fn create_test_tree() -> Array[LayoutNode] { children: children_a, } - let children_root : Array[LayoutNode] = [a_with_children, d_with_children, node_g] + let children_root : Array[LayoutNode] = [ + a_with_children, d_with_children, node_g, + ] let root_with_children = LayoutNode::{ id: root.id, label: root.label, @@ -162,7 +158,11 @@ pub fn ggtree_compute_y_positions( let mut current_y = y_pos let mut i = 0 while i < node.children.length() { - current_y = ggtree_compute_y_positions(node.children[i], current_y, positions) + current_y = ggtree_compute_y_positions( + node.children[i], + current_y, + positions, + ) i = i + 1 } // Center the internal node between its children @@ -203,7 +203,10 @@ pub fn ggtree_collect_leaf_ids(node : LayoutNode) -> Array[String] { } ///| -fn ggtree_collect_leaf_ids_recursive(node : LayoutNode, result : Array[String]) -> Unit { +fn ggtree_collect_leaf_ids_recursive( + node : LayoutNode, + result : Array[String], +) -> Unit { if node.children.length() == 0 { result.push(node.id) } else { @@ -224,7 +227,10 @@ pub fn ggtree_collect_internal_ids(node : LayoutNode) -> Array[String] { } ///| -fn ggtree_collect_internal_ids_recursive(node : LayoutNode, result : Array[String]) -> Unit { +fn ggtree_collect_internal_ids_recursive( + node : LayoutNode, + result : Array[String], +) -> Unit { let mut i = 0 while i < node.children.length() { ggtree_collect_internal_ids_recursive(node.children[i], result) @@ -267,11 +273,22 @@ fn ggtree_compute_bounds( // Recursively check children let mut i = 0 while i < node.children.length() { - let (child_min_x, child_max_x, child_min_y, child_max_y) = ggtree_compute_bounds([node.children[i]], positions) - if child_min_x < min_x { min_x = child_min_x } - if child_max_x > max_x { max_x = child_max_x } - if child_min_y < min_y { min_y = child_min_y } - if child_max_y > max_y { max_y = child_max_y } + let (child_min_x, child_max_x, child_min_y, child_max_y) = ggtree_compute_bounds( + [node.children[i]], + positions, + ) + if child_min_x < min_x { + min_x = child_min_x + } + if child_max_x > max_x { + max_x = child_max_x + } + if child_min_y < min_y { + min_y = child_min_y + } + if child_max_y > max_y { + max_y = child_max_y + } i = i + 1 } } @@ -315,10 +332,18 @@ fn ggtree_compute_bounds_flat( let mut i = 1 while i < all_ids.length() { let pos = positions[all_ids[i]] - if pos.0 < min_x { min_x = pos.0 } - if pos.0 > max_x { max_x = pos.0 } - if pos.1 < min_y { min_y = pos.1 } - if pos.1 > max_y { max_y = pos.1 } + if pos.0 < min_x { + min_x = pos.0 + } + if pos.0 > max_x { + max_x = pos.0 + } + if pos.1 < min_y { + min_y = pos.1 + } + if pos.1 > max_y { + max_y = pos.1 + } i = i + 1 } @@ -343,10 +368,14 @@ pub fn layout_rectangular(tree_data : TreeData) -> TreeLayout { } let root = tree_data.nodes[0] - let n_nodes = ggtree_count_leaves(root) + (ggtree_collect_internal_ids(root).length()) + let n_nodes = ggtree_count_leaves(root) + + ggtree_collect_internal_ids(root).length() // Initialize positions map - let positions : Map[String, (Double, Double, Double)] = Map([], capacity=n_nodes) + let positions : Map[String, (Double, Double, Double)] = Map( + [], + capacity=n_nodes, + ) // Step 1: Assign y positions let _ = ggtree_compute_y_positions(root, 0.0, positions) @@ -360,7 +389,9 @@ pub fn layout_rectangular(tree_data : TreeData) -> TreeLayout { // Step 4: Compute bounds let all_ids = ggtree_collect_all_ids(root) - let (min_x, max_x, min_y, max_y) = ggtree_compute_bounds_flat(positions, all_ids) + let (min_x, max_x, min_y, max_y) = ggtree_compute_bounds_flat( + positions, all_ids, + ) TreeLayout::{ nodes: tree_data.nodes.copy(), @@ -396,7 +427,10 @@ pub fn layout_radial(tree_data : TreeData) -> TreeLayout { let rect_layout = layout_rectangular(tree_data) // Convert to radial - let radial_positions : Map[String, (Double, Double, Double)] = Map([], capacity=rect_layout.positions.length()) + let radial_positions : Map[String, (Double, Double, Double)] = Map( + [], + capacity=rect_layout.positions.length(), + ) let y_range = rect_layout.max_y - rect_layout.min_y let angle_scale = if y_range > 0.0 { 360.0 / y_range } else { 1.0 } @@ -412,7 +446,9 @@ pub fn layout_radial(tree_data : TreeData) -> TreeLayout { } let all_ids = ggtree_collect_all_ids(tree_data.nodes[0]) - let (min_x, max_x, min_y, max_y) = ggtree_compute_bounds_flat(radial_positions, all_ids) + let (min_x, max_x, min_y, max_y) = ggtree_compute_bounds_flat( + radial_positions, all_ids, + ) TreeLayout::{ nodes: tree_data.nodes.copy(), @@ -451,14 +487,19 @@ pub fn layout_unrooted(tree_data : TreeData) -> TreeLayout { let center_x = (rect_layout.min_x + rect_layout.max_x) / 2.0 let center_y = (rect_layout.min_y + rect_layout.max_y) / 2.0 - let shifted_positions : Map[String, (Double, Double, Double)] = Map([], capacity=rect_layout.positions.length()) + let shifted_positions : Map[String, (Double, Double, Double)] = Map( + [], + capacity=rect_layout.positions.length(), + ) for id in rect_layout.positions.keys() { let pos = rect_layout.positions[id] shifted_positions.set(id, (pos.0 - center_x, pos.1 - center_y, pos.2)) } let all_ids = ggtree_collect_all_ids(tree_data.nodes[0]) - let (min_x, max_x, min_y, max_y) = ggtree_compute_bounds_flat(shifted_positions, all_ids) + let (min_x, max_x, min_y, max_y) = ggtree_compute_bounds_flat( + shifted_positions, all_ids, + ) TreeLayout::{ nodes: tree_data.nodes.copy(), @@ -475,7 +516,10 @@ pub fn layout_unrooted(tree_data : TreeData) -> TreeLayout { ///| /// Get position for a node from layout. -pub fn ggtree_get_position(layout : TreeLayout, node_id : String) -> (Double, Double, Double) { +pub fn ggtree_get_position( + layout : TreeLayout, + node_id : String, +) -> (Double, Double, Double) { if layout.positions.contains(node_id) { layout.positions[node_id] } else { @@ -507,11 +551,19 @@ fn ggtree_generate_edges_recursive( edges : Array[String], ) -> Unit { if node.children.length() > 0 { - let node_pos = if positions.contains(node.id) { positions[node.id] } else { (0.0, 0.0, 0.0) } + let node_pos = if positions.contains(node.id) { + positions[node.id] + } else { + (0.0, 0.0, 0.0) + } let mut i = 0 while i < node.children.length() { let child = node.children[i] - let child_pos = if positions.contains(child.id) { positions[child.id] } else { (0.0, 0.0, 0.0) } + let child_pos = if positions.contains(child.id) { + positions[child.id] + } else { + (0.0, 0.0, 0.0) + } let edge = "(\{node.id} -> \{child.id}: [\{node_pos.0}, \{node_pos.1}] -> [\{child_pos.0}, \{child_pos.1}])" edges.push(edge) ggtree_generate_edges_recursive(child, positions, edges) @@ -537,7 +589,11 @@ fn ggtree_generate_labels_recursive( labels : Array[String], ) -> Unit { if node.is_leaf { - let pos = if positions.contains(node.id) { positions[node.id] } else { (0.0, 0.0, 0.0) } + let pos = if positions.contains(node.id) { + positions[node.id] + } else { + (0.0, 0.0, 0.0) + } let label = "(\{node.id}, '\{node.label}', \{pos.0}, \{pos.1})" labels.push(label) } diff --git a/src/glm_gampoi.mbt b/src/glm_gampoi.mbt index 3c0b40aa..784763c0 100644 --- a/src/glm_gampoi.mbt +++ b/src/glm_gampoi.mbt @@ -159,9 +159,20 @@ pub fn GlmTestResult::adj_p_value(self : GlmTestResult) -> Double { /// Format a test result as a string. pub fn GlmTestResult::to_string(self : GlmTestResult) -> String { let sig = if self.is_significant { "*" } else { "" } - self.gene + " " + self.coef_name + " est=" + self.estimate.to_string() + - " se=" + self.std_error.to_string() + " z=" + self.z_value.to_string() + - " p=" + self.p_value.to_string() + " adj=" + self.adj_p_value.to_string() + sig + self.gene + + " " + + self.coef_name + + " est=" + + self.estimate.to_string() + + " se=" + + self.std_error.to_string() + + " z=" + + self.z_value.to_string() + + " p=" + + self.p_value.to_string() + + " adj=" + + self.adj_p_value.to_string() + + sig } ///| @@ -374,9 +385,15 @@ pub fn glm_fit_one_gene( let std_errors = glm_compute_se(design, dispersion, coefs, size_factors) let df_residual = n - n_coefs - let df_dispersion = if df_residual > 0 { df_residual.to_double() } else { 1.0 } + let df_dispersion = if df_residual > 0 { + df_residual.to_double() + } else { + 1.0 + } - GlmFit::new(gene_name, coefs, std_errors, dispersion, df_residual, df_dispersion) + GlmFit::new( + gene_name, coefs, std_errors, dispersion, df_residual, df_dispersion, + ) } ///| @@ -415,7 +432,9 @@ pub fn glm_test_de( let z = if se > 0.0 { estimate / se } else { 0.0 } let pval = glm_normal_pvalue_two_sided(z) let coef_name = design.coef_names[test_coef_index] - results.push(GlmTestResult::new(gene_names[g], coef_name, estimate, se, z, pval)) + results.push( + GlmTestResult::new(gene_names[g], coef_name, estimate, se, z, pval), + ) } results @@ -676,7 +695,11 @@ pub fn glm_normal_pvalue_two_sided(z : Double) -> Double { // Simple approximation of the survival function let p = 2.0 * (1.0 - glm_phi(abs_z)) // Clamp to avoid zero - if p < 1.0e-15 { 1.0e-15 } else { p } + if p < 1.0e-15 { + 1.0e-15 + } else { + p + } } ///| @@ -689,10 +712,21 @@ pub fn glm_phi(x : Double) -> Double { // Horner form approximation let t = 1.0 / (1.0 + 0.2316419 * abs_x) let d = 0.3989422804014327 * @math.exp(-abs_x * abs_x / 2.0) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.3302744)))) + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.3302744))) + ) let result = if sign > 0.0 { 1.0 - p } else { p } // Clamp - if result < 0.0 { 0.0 } else if result > 1.0 { 1.0 } else { result } + if result < 0.0 { + 0.0 + } else if result > 1.0 { + 1.0 + } else { + result + } } ///| @@ -727,7 +761,7 @@ pub fn glm_bh_correct_array(pvalues : Array[Double]) -> Array[Double] { for j in 0.. Unit { ///| /// Solve a linear system Ax = b using Gaussian elimination with /// partial pivoting. A is modified in place. -pub fn glm_solve_linear_system(a : Array[Array[Double]], b : Array[Double], n : Int) -> Array[Double] { +pub fn glm_solve_linear_system( + a : Array[Array[Double]], + b : Array[Double], + n : Int, +) -> Array[Double] { // Augmented matrix let aug : Array[Array[Double]] = [] for i in 0.. Array[Array[Double]] { +pub fn glm_invert_matrix( + a : Array[Array[Double]], + n : Int, +) -> Array[Array[Double]] { // Build augmented matrix [A | I] let aug : Array[Array[Double]] = [] for i in 0.. Double { min_val = data[i] } } - if min_val < 1.0e30 { min_val } else { 0.0 } + if min_val < 1.0e30 { + min_val + } else { + 0.0 + } } diff --git a/src/goa.mbt b/src/goa.mbt index 67e0da81..95311bbd 100644 --- a/src/goa.mbt +++ b/src/goa.mbt @@ -453,13 +453,12 @@ pub fn goa_parse(content : String) -> GoaDatabase { } if starts_with(line, 0, "!") { match goa_parse_header_line(line) { - Some((key, value)) => { + Some((key, value)) => if key == "gaf-version" { version = value } else if key == "generated-by" { created_by = value } - } None => () } i = i + 1 @@ -480,7 +479,10 @@ pub fn goa_parse(content : String) -> GoaDatabase { ///| /// Return all records matching the given GO ID (e.g. "GO:0003674"). -pub fn goa_filter_by_go_id(db : GoaDatabase, go_id : String) -> Array[GafRecord] { +pub fn goa_filter_by_go_id( + db : GoaDatabase, + go_id : String, +) -> Array[GafRecord] { let result : Array[GafRecord] = Array::new() let recs = db.records let mut i = 0 @@ -708,10 +710,18 @@ pub fn goa_to_summary(db : GoaDatabase) -> String { s = s + " " + code + ": " + count.to_string() + "\n" j = j + 1 } - s = s + "\nUnique GO IDs: " + goa_unique_go_ids(db).length().to_string() + "\n" - s = s + "Unique evidence codes: " + - goa_unique_evidence_codes(db).length().to_string() + "\n" - s = s + "Unique taxon IDs: " + goa_unique_taxon_ids(db).length().to_string() + "\n" + s = s + + "\nUnique GO IDs: " + + goa_unique_go_ids(db).length().to_string() + + "\n" + s = s + + "Unique evidence codes: " + + goa_unique_evidence_codes(db).length().to_string() + + "\n" + s = s + + "Unique taxon IDs: " + + goa_unique_taxon_ids(db).length().to_string() + + "\n" s } diff --git a/src/gosemsim.mbt b/src/gosemsim.mbt index f15f656a..b18aa407 100644 --- a/src/gosemsim.mbt +++ b/src/gosemsim.mbt @@ -16,23 +16,33 @@ pub enum SimMeasure { ///| /// Construct Resnik measure. -pub fn resnik_measure() -> SimMeasure { Resnik } +pub fn resnik_measure() -> SimMeasure { + Resnik +} ///| /// Construct Lin measure. -pub fn lin_measure() -> SimMeasure { Lin } +pub fn lin_measure() -> SimMeasure { + Lin +} ///| /// Construct Rel measure. -pub fn rel_measure() -> SimMeasure { Rel } +pub fn rel_measure() -> SimMeasure { + Rel +} ///| /// Construct Jiang measure. -pub fn jiang_measure() -> SimMeasure { Jiang } +pub fn jiang_measure() -> SimMeasure { + Jiang +} ///| /// Construct Wang measure. -pub fn wang_measure() -> SimMeasure { Wang } +pub fn wang_measure() -> SimMeasure { + Wang +} ///| /// A node in the GO graph. @@ -116,7 +126,7 @@ pub fn GOGraph::add_term(self : GOGraph, node : GOTermNode) -> GOGraph { self.terms.set(node.go_id, node) // Update parent's children list match self.terms.get(node.go_id) { - Some(_) => { + Some(_) => for parent_id in node.parents { match self.terms.get(parent_id) { Some(parent) => { @@ -137,7 +147,6 @@ pub fn GOGraph::add_term(self : GOGraph, node : GOTermNode) -> GOGraph { None => () } } - } None => () } GOGraph::{ root_id: self.root_id, terms: self.terms } @@ -165,22 +174,21 @@ pub fn gosemsim_term_sim( let (mica_id, mica_ic) = gosemsim_mica_ic(graph, id1, id2) match measure { Resnik => mica_ic - Lin => { + Lin => if t1.ic + t2.ic > 1.0e-10 { 2.0 * mica_ic / (t1.ic + t2.ic) } else { 0.0 } - } - Rel => { + Rel => if t1.ic + t2.ic > 1.0e-10 { let lin = 2.0 * mica_ic / (t1.ic + t2.ic) - let rel = lin * (1.0 - mica_ic / (if t1.ic > t2.ic { t1.ic } else { t2.ic })) + let rel = lin * + (1.0 - mica_ic / (if t1.ic > t2.ic { t1.ic } else { t2.ic })) rel } else { 0.0 } - } Jiang => { let common_ancestors = gosemsim_ancestors(graph, id1) let d1 = gosemsim_distance_to(graph, id1, common_ancestors) @@ -231,7 +239,7 @@ pub fn gosemsim_gen_sim( sim_matrix.push(row) i = i + 1 } - + match combine { "max" => gosemsim_matrix_max(sim_matrix) "avg" => gosemsim_matrix_avg(sim_matrix) @@ -240,16 +248,20 @@ pub fn gosemsim_gen_sim( } } +///| fn gosemsim_matrix_max(matrix : Array[Array[Double]]) -> Double { let mut max_val = 0.0 for row in matrix { for v in row { - if v > max_val { max_val = v } + if v > max_val { + max_val = v + } } } max_val } +///| fn gosemsim_matrix_avg(matrix : Array[Array[Double]]) -> Double { let mut sum = 0.0 let mut count = 0 @@ -259,13 +271,18 @@ fn gosemsim_matrix_avg(matrix : Array[Array[Double]]) -> Double { count = count + 1 } } - if count > 0 { sum / count.to_double() } else { 0.0 } + if count > 0 { + sum / count.to_double() + } else { + 0.0 + } } +///| fn gosemsim_matrix_rcmax(matrix : Array[Array[Double]]) -> Double { let n_rows = matrix.length() let n_cols = if n_rows > 0 { matrix[0].length() } else { 0 } - + // Row-wise max and column-wise max, average of the larger set let mut row_max_sum = 0.0 let mut i = 0 @@ -273,26 +290,30 @@ fn gosemsim_matrix_rcmax(matrix : Array[Array[Double]]) -> Double { let mut row_max = 0.0 let mut j = 0 while j < n_cols { - if matrix[i][j] > row_max { row_max = matrix[i][j] } + if matrix[i][j] > row_max { + row_max = matrix[i][j] + } j = j + 1 } row_max_sum = row_max_sum + row_max i = i + 1 } - + let mut col_max_sum = 0.0 let mut j = 0 while j < n_cols { let mut col_max = 0.0 let mut i2 = 0 while i2 < n_rows { - if matrix[i2][j] > col_max { col_max = matrix[i2][j] } + if matrix[i2][j] > col_max { + col_max = matrix[i2][j] + } i2 = i2 + 1 } col_max_sum = col_max_sum + col_max j = j + 1 } - + let n = if n_rows > n_cols { n_rows } else { n_cols } if n > 0 { (row_max_sum + col_max_sum) / (2.0 * n.to_double()) @@ -303,33 +324,36 @@ fn gosemsim_matrix_rcmax(matrix : Array[Array[Double]]) -> Double { ///| /// Find the Most Informative Common Ancestor (MICA) and its IC. -fn gosemsim_mica_ic(graph : GOGraph, id1 : String, id2 : String) -> (String, Double) { +fn gosemsim_mica_ic( + graph : GOGraph, + id1 : String, + id2 : String, +) -> (String, Double) { let anc1 = gosemsim_ancestors(graph, id1) let anc2 = gosemsim_ancestors(graph, id2) - + // Find common ancestors let seen : Map[String, Bool] = Map([], capacity=anc1.length()) for a in anc1 { seen.set(a, true) } - + let mut best_id = "" let mut best_ic = -1.0 - + for a in anc2 { if seen.get_or_default(a, false) { match graph.get_term(a) { - Some(term) => { + Some(term) => if term.ic > best_ic { best_ic = term.ic best_id = a } - } None => () } } } - + if best_ic < 0.0 { (graph.root_id, 0.0) } else { @@ -346,6 +370,7 @@ fn gosemsim_ancestors(graph : GOGraph, go_id : String) -> Array[String] { ancestors } +///| fn gosemsim_ancestors_recursive( graph : GOGraph, go_id : String, @@ -359,33 +384,36 @@ fn gosemsim_ancestors_recursive( ancestors.push(go_id) match graph.get_term(go_id) { - Some(term) => { + Some(term) => for parent in term.parents { gosemsim_ancestors_recursive(graph, parent, ancestors, visited) } - } None => () } } ///| /// Compute path distance to a common ancestor set. -fn gosemsim_distance_to(graph : GOGraph, go_id : String, ancestors : Array[String]) -> Double { +fn gosemsim_distance_to( + graph : GOGraph, + go_id : String, + ancestors : Array[String], +) -> Double { // Simple BFS to find shortest path to any ancestor if ancestors.length() == 0 { return 0.0 } - + let target_set : Map[String, Bool] = Map([], capacity=ancestors.length()) for a in ancestors { target_set.set(a, true) } - + let mut current : Array[(String, Double)] = Array::new() let visited : Map[String, Bool] = Map([], capacity=64) current.push((go_id, 0.0)) visited.set(go_id, true) - + let mut found = false while current.length() > 0 { let (node_id, dist) = current[0] @@ -396,26 +424,29 @@ fn gosemsim_distance_to(graph : GOGraph, go_id : String, ancestors : Array[Strin i = i + 1 } current = rest - + if target_set.get_or_default(node_id, false) { found = true return dist } - + match graph.get_term(node_id) { - Some(term) => { + Some(term) => for parent in term.parents { if !visited.get_or_default(parent, false) { visited.set(parent, true) current.push((parent, dist + 1.0)) } } - } None => () } } - - if found { 0.0 } else { 100.0 } + + if found { + 0.0 + } else { + 100.0 + } } ///| @@ -429,7 +460,9 @@ fn gosemsim_wang_score(graph : GOGraph, go_id : String) -> Double { // Score based on depth from root score = score + 1.0 let mut parent_count = term.parents.length().to_double() - if parent_count < 1.0 { parent_count = 1.0 } + if parent_count < 1.0 { + parent_count = 1.0 + } score = score + 1.0 / parent_count } None => () @@ -440,15 +473,19 @@ fn gosemsim_wang_score(graph : GOGraph, go_id : String) -> Double { ///| /// Compute Wang common score (overlap of ancestor sets). -fn gosemsim_wang_common_score(graph : GOGraph, id1 : String, id2 : String) -> Double { +fn gosemsim_wang_common_score( + graph : GOGraph, + id1 : String, + id2 : String, +) -> Double { let anc1 = gosemsim_ancestors(graph, id1) let anc2 = gosemsim_ancestors(graph, id2) - + let set1 : Map[String, Bool] = Map([], capacity=anc1.length()) for a in anc1 { set1.set(a, true) } - + let mut score = 0.0 for anc_id in anc2 { if set1.get_or_default(anc_id, false) { @@ -456,7 +493,9 @@ fn gosemsim_wang_common_score(graph : GOGraph, id1 : String, id2 : String) -> Do match graph.get_term(anc_id) { Some(term) => { let mut parent_count = term.parents.length().to_double() - if parent_count < 1.0 { parent_count = 1.0 } + if parent_count < 1.0 { + parent_count = 1.0 + } score = score + 1.0 / parent_count } None => () @@ -471,13 +510,69 @@ fn gosemsim_wang_common_score(graph : GOGraph, id1 : String, id2 : String) -> Do pub fn gosemsim_example_graph() -> GOGraph { let g = GOGraph::new() let g1 = g.add_root("GO:0008150") - let g2 = g1.add_term(GOTermNode::new("GO:0008150", ic=0.0, parents=[], term_name="biological_process")) - let g3 = g2.add_term(GOTermNode::new("GO:0050896", ic=0.3, parents=["GO:0008150"], term_name="response to stimulus")) - let g4 = g3.add_term(GOTermNode::new("GO:0009987", ic=0.5, parents=["GO:0050896"], term_name="cellular process")) - let g5 = g4.add_term(GOTermNode::new("GO:0006810", ic=0.7, parents=["GO:0009987"], term_name="transport")) - let g6 = g3.add_term(GOTermNode::new("GO:0023046", ic=0.4, parents=["GO:0050896"], term_name="signaling")) - let g7 = g6.add_term(GOTermNode::new("GO:0007165", ic=0.6, parents=["GO:0023046"], term_name="signal transduction")) - let g8 = g2.add_term(GOTermNode::new("GO:0009058", ic=0.2, parents=["GO:0008150"], term_name="biosynthetic process")) - let g9 = g8.add_term(GOTermNode::new("GO:0010467", ic=0.35, parents=["GO:0009058"], term_name="gene expression")) + let g2 = g1.add_term( + GOTermNode::new( + "GO:0008150", + ic=0.0, + parents=[], + term_name="biological_process", + ), + ) + let g3 = g2.add_term( + GOTermNode::new( + "GO:0050896", + ic=0.3, + parents=["GO:0008150"], + term_name="response to stimulus", + ), + ) + let g4 = g3.add_term( + GOTermNode::new( + "GO:0009987", + ic=0.5, + parents=["GO:0050896"], + term_name="cellular process", + ), + ) + let g5 = g4.add_term( + GOTermNode::new( + "GO:0006810", + ic=0.7, + parents=["GO:0009987"], + term_name="transport", + ), + ) + let g6 = g3.add_term( + GOTermNode::new( + "GO:0023046", + ic=0.4, + parents=["GO:0050896"], + term_name="signaling", + ), + ) + let g7 = g6.add_term( + GOTermNode::new( + "GO:0007165", + ic=0.6, + parents=["GO:0023046"], + term_name="signal transduction", + ), + ) + let g8 = g2.add_term( + GOTermNode::new( + "GO:0009058", + ic=0.2, + parents=["GO:0008150"], + term_name="biosynthetic process", + ), + ) + let g9 = g8.add_term( + GOTermNode::new( + "GO:0010467", + ic=0.35, + parents=["GO:0009058"], + term_name="gene expression", + ), + ) g9 } diff --git a/src/graphics.mbt b/src/graphics.mbt index 8d8b496d..4ffbb7e9 100644 --- a/src/graphics.mbt +++ b/src/graphics.mbt @@ -13,12 +13,7 @@ pub struct SeqLogo { ///| pub fn SeqLogo::new(sequences : Array[String]) -> SeqLogo { - SeqLogo::{ - sequences, - height: 50, - width: 400, - colors: get_default_colors() - } + SeqLogo::{ sequences, height: 50, width: 400, colors: get_default_colors() } } ///| @@ -35,7 +30,7 @@ pub fn LogoColumn::new(position : Int) -> LogoColumn { position, letter_frequencies: Map([], capacity=4), information_content: 0.0, - letters: Array::new() + letters: Array::new(), } } @@ -53,7 +48,7 @@ pub fn AlignmentPlot::new(sequences : Array[(String, String)]) -> AlignmentPlot sequences, highlight_regions: Array::new(), consensus: "", - show_consensus: true + show_consensus: true, } } @@ -65,26 +60,25 @@ pub struct FeaturePlot { } ///| -pub fn FeaturePlot::new(features : Array[(String, Int, Int, String, String)], sequence_length : Int) -> FeaturePlot { - FeaturePlot::{ - features, - sequence_length, - colors: get_feature_colors() - } +pub fn FeaturePlot::new( + features : Array[(String, Int, Int, String, String)], + sequence_length : Int, +) -> FeaturePlot { + FeaturePlot::{ features, sequence_length, colors: get_feature_colors() } } ///| pub fn get_default_colors() -> Map[String, String] { let colors = Map([], capacity=20) - + colors.set("A", "#FF0000") colors.set("T", "#0000FF") colors.set("C", "#00FF00") colors.set("G", "#FFA500") - + colors.set("N", "#808080") colors.set("-", "#CCCCCC") - + colors.set("R", "#FF0000") colors.set("K", "#FF0000") colors.set("D", "#0000FF") @@ -105,14 +99,14 @@ pub fn get_default_colors() -> Map[String, String] { colors.set("F", "#808080") colors.set("W", "#808080") colors.set("C", "#808080") - + colors } ///| pub fn get_feature_colors() -> Map[String, String] { let colors = Map([], capacity=10) - + colors.set("exon", "#FF6B6B") colors.set("intron", "#4ECDC4") colors.set("CDS", "#45B7D1") @@ -123,30 +117,33 @@ pub fn get_feature_colors() -> Map[String, String] { colors.set("repeat", "#98D8C8") colors.set("gene", "#F7DC6F") colors.set("misc", "#BB8FCE") - + colors } ///| -pub fn seqlogo_calculate_columns(sequences : Array[String]) -> Array[LogoColumn] { +pub fn seqlogo_calculate_columns( + sequences : Array[String], +) -> Array[LogoColumn] { let columns : Array[LogoColumn] = Array::new() - + if sequences.length() == 0 { return columns } - + let seq_len = sequences[0].length() let n_seqs = sequences.length() - + let mut pos = 0 while pos < seq_len { let col = LogoColumn::new(pos + 1) let freqs = col.letter_frequencies.copy() - - let counts = Map([ - ("A", 0), ("T", 0), ("C", 0), ("G", 0), ("N", 0) - ], capacity=5) - + + let counts = Map( + [("A", 0), ("T", 0), ("C", 0), ("G", 0), ("N", 0)], + capacity=5, + ) + let mut seq_idx = 0 while seq_idx < n_seqs { if pos < sequences[seq_idx].length() { @@ -159,7 +156,7 @@ pub fn seqlogo_calculate_columns(sequences : Array[String]) -> Array[LogoColumn] } seq_idx = seq_idx + 1 } - + let mut total = 0 let count_keys = counts.keys().collect() let mut i = 0 @@ -167,26 +164,26 @@ pub fn seqlogo_calculate_columns(sequences : Array[String]) -> Array[LogoColumn] total = total + counts.get(count_keys[i]).unwrap() i = i + 1 } - + if total > 0 { let mut ic = 0.0 let ic_max = @math.log2(n_seqs.to_double()) - + let mut j = 0 while j < count_keys.length() { let key = count_keys[j] let count = counts.get(key).unwrap() let freq = count.to_double() / total.to_double() freqs.set(key, freq) - + if freq > 0.0 { ic = ic - freq * @math.log2(freq) } j = j + 1 } - + let info_content = ic / ic_max * ic_max - + let sorted_letters : Array[(String, Double)] = Array::new() let mut k = 0 while k < count_keys.length() { @@ -196,7 +193,7 @@ pub fn seqlogo_calculate_columns(sequences : Array[String]) -> Array[LogoColumn] } k = k + 1 } - + let mut l = 0 while l < sorted_letters.length() - 1 { let mut m = l + 1 @@ -210,7 +207,7 @@ pub fn seqlogo_calculate_columns(sequences : Array[String]) -> Array[LogoColumn] } l = l + 1 } - + let letters : Array[(String, Double, Double)] = Array::new() let mut cum_height = 0.0 let mut n = 0 @@ -220,30 +217,30 @@ pub fn seqlogo_calculate_columns(sequences : Array[String]) -> Array[LogoColumn] cum_height = cum_height + height n = n + 1 } - + columns.push(LogoColumn::{ position: pos + 1, letter_frequencies: freqs, information_content: info_content, - letters: letters + letters, }) } - + pos = pos + 1 } - + columns } ///| pub fn seqlogo_generate_ascii(logo : SeqLogo) -> String { let columns = seqlogo_calculate_columns(logo.sequences) - + let mut output = "" - + let max_ic = @math.log2(logo.sequences.length().to_double()) let scale = logo.height.to_double() / max_ic - + let mut row = logo.height - 1 while row >= 0 { let mut line = "" @@ -256,8 +253,9 @@ pub fn seqlogo_generate_ascii(logo : SeqLogo) -> String { let (letter, start, height) = col.letters[letter_idx] let scaled_start = start * scale let scaled_height = height * scale - - if row.to_double() >= scaled_start && row.to_double() < scaled_start + scaled_height { + + if row.to_double() >= scaled_start && + row.to_double() < scaled_start + scaled_height { line = line + letter found = true break @@ -274,7 +272,7 @@ pub fn seqlogo_generate_ascii(logo : SeqLogo) -> String { } row = row - 1 } - + output = output + "Position: " let mut pos = 0 while pos < columns.length() { @@ -282,23 +280,23 @@ pub fn seqlogo_generate_ascii(logo : SeqLogo) -> String { pos = pos + 1 } output = output + "\n" - + output } ///| pub fn alignment_plot_generate_ascii(plot : AlignmentPlot) -> String { let mut output = "" - + if plot.show_consensus { let consensus = graphics_calculate_consensus(plot.sequences) output = output + "Consensus: " + consensus + "\n\n" } - + let mut seq_idx = 0 while seq_idx < plot.sequences.length() { let (name, seq) = plot.sequences[seq_idx] - + let mut line = "" if name.length() > 12 { line = line + substring(name, 0, 12) @@ -312,10 +310,10 @@ pub fn alignment_plot_generate_ascii(plot : AlignmentPlot) -> String { } line = line + " " + seq + "\n" output = output + line - + seq_idx = seq_idx + 1 } - + output } @@ -324,18 +322,19 @@ fn graphics_calculate_consensus(sequences : Array[(String, String)]) -> String { if sequences.length() == 0 { return "" } - + let seq_len = sequences[0].1.length() let n_seqs = sequences.length() - + let mut consensus = "" - + let mut pos = 0 while pos < seq_len { - let counts = Map([ - ("A", 0), ("T", 0), ("C", 0), ("G", 0), ("-", 0) - ], capacity=5) - + let counts = Map( + [("A", 0), ("T", 0), ("C", 0), ("G", 0), ("-", 0)], + capacity=5, + ) + let mut seq_idx = 0 while seq_idx < n_seqs { if pos < sequences[seq_idx].1.length() { @@ -346,7 +345,7 @@ fn graphics_calculate_consensus(sequences : Array[(String, String)]) -> String { } seq_idx = seq_idx + 1 } - + let mut max_count = 0 let mut max_base = "N" let count_keys = counts.keys().collect() @@ -360,20 +359,23 @@ fn graphics_calculate_consensus(sequences : Array[(String, String)]) -> String { } i = i + 1 } - + consensus = consensus + max_base pos = pos + 1 } - + consensus } ///| pub fn feature_plot_generate_ascii(plot : FeaturePlot) -> String { let mut output = "" - - output = output + "Sequence length: " + plot.sequence_length.to_string() + "\n\n" - + + output = output + + "Sequence length: " + + plot.sequence_length.to_string() + + "\n\n" + output = output + "Legend:\n" let color_keys = plot.colors.keys().collect() let mut i = 0 @@ -383,7 +385,7 @@ pub fn feature_plot_generate_ascii(plot : FeaturePlot) -> String { i = i + 1 } output = output + "\n" - + output = output + "Feature track:\n" output = output + "|" let mut pos = 0 @@ -396,11 +398,11 @@ pub fn feature_plot_generate_ascii(plot : FeaturePlot) -> String { pos = pos + 1 } output = output + "|\n" - + let mut feat_idx = 0 while feat_idx < plot.features.length() { let (name, start, end, feat_type, strand) = plot.features[feat_idx] - + let mut line = "" let mut pos = 0 while pos < plot.sequence_length { @@ -411,39 +413,33 @@ pub fn feature_plot_generate_ascii(plot : FeaturePlot) -> String { } pos = pos + 1 } - + let strand_sym = if strand == "-" { "<-" } else { "->" } output = output + strand_sym + " [" + name + "] " + line + "\n" - + feat_idx = feat_idx + 1 } - + output = output + "\nPositions: 0" pos = 0 while pos <= plot.sequence_length { if pos % 20 == 0 && pos > 0 { - output = output + " ".repeat(pos.to_string().length() - 1) + pos.to_string() + output = output + + " ".repeat(pos.to_string().length() - 1) + + pos.to_string() } pos = pos + 1 } output = output + "\n" - + output } ///| pub fn create_example_seqlogo() -> SeqLogo { let seqs = [ - "ATGCCGTAA", - "ATGCCGTAA", - "ATGCCGTAA", - "ATGCCGTAA", - "ATGCCGTAA", - "ATGCCGTAA", - "ATGCCGTAA", - "ATGCCGTAA", - "ATGCCGTAA", - "ATGCCGTAA" + "ATGCCGTAA", "ATGCCGTAA", "ATGCCGTAA", "ATGCCGTAA", "ATGCCGTAA", "ATGCCGTAA", + "ATGCCGTAA", "ATGCCGTAA", "ATGCCGTAA", "ATGCCGTAA", ] SeqLogo::new(seqs) } @@ -454,7 +450,7 @@ pub fn create_example_alignment_plot() -> AlignmentPlot { ("Human", "ATGGCCGGTAAATGA"), ("Mouse", "ATGGCCGGTAAATGA"), ("Rat", "ATGGCCGGTAATAGA"), - ("Chicken", "ATGGCCGGTAATGGA") + ("Chicken", "ATGGCCGGTAATGGA"), ] AlignmentPlot::new(seqs) } @@ -468,7 +464,7 @@ pub fn create_example_feature_plot() -> FeaturePlot { ("Exon2", 70, 100, "exon", "+"), ("Promoter", -20, 0, "promoter", "+"), ("GeneB", 150, 250, "gene", "-"), - ("CDS", 160, 240, "CDS", "-") + ("CDS", 160, 240, "CDS", "-"), ] FeaturePlot::new(features, 300) -} \ No newline at end of file +} diff --git a/src/gsea_base.mbt b/src/gsea_base.mbt index 69ecbfbe..774a9f09 100644 --- a/src/gsea_base.mbt +++ b/src/gsea_base.mbt @@ -21,13 +21,14 @@ fn gs_str_lower(s : String) -> String { None => () } } else { - result = result + s[i:i+1].to_owned() + result = result + s[i:i + 1].to_owned() } i = i + 1 } result } +///| fn gs_str_upper(s : String) -> String { let mut result = "" let mut i = 0 @@ -41,13 +42,14 @@ fn gs_str_upper(s : String) -> String { None => () } } else { - result = result + s[i:i+1].to_owned() + result = result + s[i:i + 1].to_owned() } i = i + 1 } result } +///| fn gs_trim(s : String) -> String { let mut start = 0 let n = s.length() @@ -68,9 +70,14 @@ fn gs_trim(s : String) -> String { break } } - if start == 0 && end == n { s } else { s[start:end].to_owned() } + if start == 0 && end == n { + s + } else { + s[start:end].to_owned() + } } +///| fn gs_split(s : String, sep_u16 : UInt16) -> Array[String] { let out : Array[String] = Array::new() let mut buf = StringBuilder::new() @@ -96,6 +103,7 @@ fn gs_split(s : String, sep_u16 : UInt16) -> Array[String] { // ---- types ----------------------------------------------------------------- +///| pub enum GeneSetCollectionType { GO_BiologicalProcess GO_MolecularFunction @@ -110,13 +118,20 @@ pub enum GeneSetCollectionType { Other } +///| pub fn GeneSetCollectionType::from_string(s : String) -> GeneSetCollectionType { let sl = gs_str_lower(s) - if sl.has_prefix("go_bp") || sl.has_prefix("bp") || sl.contains("biological_process") { + if sl.has_prefix("go_bp") || + sl.has_prefix("bp") || + sl.contains("biological_process") { GO_BiologicalProcess - } else if sl.has_prefix("go_mf") || sl.has_prefix("mf") || sl.contains("molecular_function") { + } else if sl.has_prefix("go_mf") || + sl.has_prefix("mf") || + sl.contains("molecular_function") { GO_MolecularFunction - } else if sl.has_prefix("go_cc") || sl.has_prefix("cc") || sl.contains("cellular_component") { + } else if sl.has_prefix("go_cc") || + sl.has_prefix("cc") || + sl.contains("cellular_component") { GO_CellularComponent } else if sl.has_prefix("kegg") { KEGG @@ -137,6 +152,7 @@ pub fn GeneSetCollectionType::from_string(s : String) -> GeneSetCollectionType { } } +///| pub fn GeneSetCollectionType::show(self : GeneSetCollectionType) -> String { let s = match self { GO_BiologicalProcess => "GO_BiologicalProcess" @@ -154,6 +170,7 @@ pub fn GeneSetCollectionType::show(self : GeneSetCollectionType) -> String { s.to_string() } +///| pub struct GmtGeneSet { pub name : String pub description : String @@ -163,6 +180,7 @@ pub struct GmtGeneSet { pub mut id : String } +///| pub fn GmtGeneSet::new( name : String, description : String, @@ -172,11 +190,16 @@ pub fn GmtGeneSet::new( let seen : Array[String] = Array::new() for x in gene_ids { let t = gs_trim(x) - if t.length() == 0 { continue } + if t.length() == 0 { + continue + } let mut already = false let upper = gs_str_upper(t) for s in seen { - if s == upper { already = true; break } + if s == upper { + already = true + break + } } if !already { seen.push(upper) @@ -184,8 +207,8 @@ pub fn GmtGeneSet::new( } } GmtGeneSet::{ - name: name, - description: description, + name, + description, gene_ids: uniq, collection_type: Other, organism: "unknown".to_string(), @@ -193,6 +216,7 @@ pub fn GmtGeneSet::new( } } +///| pub fn GmtGeneSet::with_annotation( name : String, description : String, @@ -208,44 +232,64 @@ pub fn GmtGeneSet::with_annotation( gs } +///| pub fn GmtGeneSet::size(self : GmtGeneSet) -> Int { self.gene_ids.length() } +///| pub fn GmtGeneSet::has_gene(self : GmtGeneSet, gene : String) -> Bool { let gu = gs_str_upper(gs_trim(gene)) for g in self.gene_ids { - if gs_str_upper(g) == gu { return true } + if gs_str_upper(g) == gu { + return true + } } false } // ---- set math -------------------------------------------------------------- +///| pub fn gene_set_overlap(a : GmtGeneSet, b : GmtGeneSet) -> Int { let mut cnt = 0 for g in a.gene_ids { - if b.has_gene(g) { cnt = cnt + 1 } + if b.has_gene(g) { + cnt = cnt + 1 + } } cnt } +///| pub fn gene_set_jaccard(a : GmtGeneSet, b : GmtGeneSet) -> Double { let ov = gene_set_overlap(a, b).to_double() let asz = a.gene_ids.length().to_double() let bsz = b.gene_ids.length().to_double() let un = asz + bsz - ov - if un == 0.0 { 0.0 } else { ov / un } + if un == 0.0 { + 0.0 + } else { + ov / un + } } +///| pub fn gene_set_overlap_coef(a : GmtGeneSet, b : GmtGeneSet) -> Double { let ov = gene_set_overlap(a, b) let mut asz = a.gene_ids.length() let bsz = b.gene_ids.length() - if asz > bsz { asz = bsz } - if asz == 0 { 0.0 } else { ov.to_double() / asz.to_double() } + if asz > bsz { + asz = bsz + } + if asz == 0 { + 0.0 + } else { + ov.to_double() / asz.to_double() + } } +///| pub fn gene_set_union_arr(a : GmtGeneSet, b : GmtGeneSet) -> Array[String] { let out : Array[String] = Array::new() let seen : Array[String] = Array::new() @@ -253,7 +297,10 @@ pub fn gene_set_union_arr(a : GmtGeneSet, b : GmtGeneSet) -> Array[String] { let u = gs_str_upper(g) let mut f = false for s in seen { - if s == u { f = true; break } + if s == u { + f = true + break + } } if !f { seen.push(u) @@ -264,7 +311,10 @@ pub fn gene_set_union_arr(a : GmtGeneSet, b : GmtGeneSet) -> Array[String] { let u = gs_str_upper(g) let mut f = false for s in seen { - if s == u { f = true; break } + if s == u { + f = true + break + } } if !f { seen.push(u) @@ -274,68 +324,88 @@ pub fn gene_set_union_arr(a : GmtGeneSet, b : GmtGeneSet) -> Array[String] { out } +///| pub fn gene_set_intersect_arr(a : GmtGeneSet, b : GmtGeneSet) -> Array[String] { let out : Array[String] = Array::new() for g in a.gene_ids { - if b.has_gene(g) { out.push(g) } + if b.has_gene(g) { + out.push(g) + } } out } +///| pub fn gene_set_setdiff(a : GmtGeneSet, b : GmtGeneSet) -> Array[String] { let out : Array[String] = Array::new() for g in a.gene_ids { - if !b.has_gene(g) { out.push(g) } + if !b.has_gene(g) { + out.push(g) + } } out } // ---- collection ------------------------------------------------------------ +///| pub struct GmtGeneSetCollection { pub sets : Array[GmtGeneSet] pub names : Array[String] pub mut size : Int } -pub fn GmtGeneSetCollection::new(sets : Array[GmtGeneSet]) -> GmtGeneSetCollection { +///| +pub fn GmtGeneSetCollection::new( + sets : Array[GmtGeneSet], +) -> GmtGeneSetCollection { let names : Array[String] = Array::new() for s in sets { names.push(s.name) } - GmtGeneSetCollection::{ - sets: sets, - names: names, - size: sets.length(), - } + GmtGeneSetCollection::{ sets, names, size: sets.length() } } +///| pub fn GmtGeneSetCollection::by_name( self : GmtGeneSetCollection, name : String, -) -> Option[GmtGeneSet] { +) -> GmtGeneSet? { let n = self.sets.length() let mut i = 0 while i < n { - if self.sets[i].name == name { return Some(self.sets[i]) } + if self.sets[i].name == name { + return Some(self.sets[i]) + } i = i + 1 } None } +///| pub fn GmtGeneSetCollection::at( self : GmtGeneSetCollection, i : Int, -) -> Option[GmtGeneSet] { - if i < 0 || i >= self.sets.length() { None } else { Some(self.sets[i]) } +) -> GmtGeneSet? { + if i < 0 || i >= self.sets.length() { + None + } else { + Some(self.sets[i]) + } } -pub fn GmtGeneSetCollection::all_sizes(self : GmtGeneSetCollection) -> Array[Int] { +///| +pub fn GmtGeneSetCollection::all_sizes( + self : GmtGeneSetCollection, +) -> Array[Int] { let out : Array[Int] = Array::new() - for s in self.sets { out.push(s.size()) } + for s in self.sets { + out.push(s.size()) + } out } +///| pub fn GmtGeneSetCollection::push_s( self : GmtGeneSetCollection, gs : GmtGeneSet, @@ -347,17 +417,24 @@ pub fn GmtGeneSetCollection::push_s( col } +///| pub fn GmtGeneSetCollection::summary(self : GmtGeneSetCollection) -> String { let buf = StringBuilder::new() buf.write_string("GmtGeneSetCollection: \{self.size} sets\n") - if self.size == 0 { return buf.to_string() } + if self.size == 0 { + return buf.to_string() + } let mut min_sz = self.sets[0].size() let mut max_sz = self.sets[0].size() let mut sum_sz = 0 for s in self.sets { let sz = s.size() - if sz < min_sz { min_sz = sz } - if sz > max_sz { max_sz = sz } + if sz < min_sz { + min_sz = sz + } + if sz > max_sz { + max_sz = sz + } sum_sz = sum_sz + sz } let avg = sum_sz.to_double() / self.size.to_double() @@ -375,6 +452,7 @@ pub fn GmtGeneSetCollection::summary(self : GmtGeneSetCollection) -> String { buf.to_string() } +///| pub fn collection_filter_by_size( col : GmtGeneSetCollection, min_size : Int, @@ -383,11 +461,14 @@ pub fn collection_filter_by_size( let kept : Array[GmtGeneSet] = Array::new() for s in col.sets { let sz = s.size() - if sz >= min_size && sz <= max_size { kept.push(s) } + if sz >= min_size && sz <= max_size { + kept.push(s) + } } GmtGeneSetCollection::new(kept) } +///| pub fn collection_filter_by_gene( col : GmtGeneSetCollection, gene_universe : Array[String], @@ -419,6 +500,7 @@ pub fn collection_filter_by_gene( GmtGeneSetCollection::new(kept) } +///| pub fn collection_gene_union(col : GmtGeneSetCollection) -> Array[String] { let out : Array[String] = Array::new() let seen : Array[String] = Array::new() @@ -427,7 +509,10 @@ pub fn collection_gene_union(col : GmtGeneSetCollection) -> Array[String] { let u = gs_str_upper(g) let mut f = false for s2 in seen { - if s2 == u { f = true; break } + if s2 == u { + f = true + break + } } if !f { seen.push(u) @@ -438,6 +523,7 @@ pub fn collection_gene_union(col : GmtGeneSetCollection) -> Array[String] { out } +///| pub fn collection_pairwise_jaccard( col : GmtGeneSetCollection, ) -> Array[Array[Double]] { @@ -464,6 +550,7 @@ pub fn collection_pairwise_jaccard( // ---- GMT I/O --------------------------------------------------------------- +///| pub fn parse_gmt(content : String) -> GmtGeneSetCollection { let lines = gs_split(content, '\n'.to_int().to_uint16()) let result : Array[GmtGeneSet] = Array::new() @@ -472,11 +559,23 @@ pub fn parse_gmt(content : String) -> GmtGeneSetCollection { while idx < n { let raw_line = lines[idx] let line = gs_trim(raw_line) - if line.length() == 0 { idx = idx + 1; continue } - if line.has_prefix("#") { idx = idx + 1; continue } - if line.has_prefix("!") { idx = idx + 1; continue } + if line.length() == 0 { + idx = idx + 1 + continue + } + if line.has_prefix("#") { + idx = idx + 1 + continue + } + if line.has_prefix("!") { + idx = idx + 1 + continue + } let parts = gs_split(line, '\t'.to_int().to_uint16()) - if parts.length() < 3 { idx = idx + 1; continue } + if parts.length() < 3 { + idx = idx + 1 + continue + } let name = gs_trim(parts[0]) let desc = gs_trim(parts[1]) let genes : Array[String] = Array::new() @@ -484,7 +583,9 @@ pub fn parse_gmt(content : String) -> GmtGeneSetCollection { let mut i = 2 while i < plen { let g = gs_trim(parts[i]) - if g.length() > 0 { genes.push(g) } + if g.length() > 0 { + genes.push(g) + } i = i + 1 } if name.length() > 0 && genes.length() > 0 { @@ -495,6 +596,7 @@ pub fn parse_gmt(content : String) -> GmtGeneSetCollection { GmtGeneSetCollection::new(result) } +///| pub fn write_gmt(col : GmtGeneSetCollection) -> String { let buf = StringBuilder::new() for gs in col.sets { @@ -512,17 +614,24 @@ pub fn write_gmt(col : GmtGeneSetCollection) -> String { // ---- GMX I/O --------------------------------------------------------------- +///| pub fn parse_gmx(content : String) -> GmtGeneSetCollection { let tab16 = '\t'.to_int().to_uint16() let lines = gs_split(content, '\n'.to_int().to_uint16()) let nonblank : Array[Array[String]] = Array::new() for raw in lines { let line = gs_trim(raw) - if line.length() == 0 { continue } - if line.has_prefix("#") { continue } + if line.length() == 0 { + continue + } + if line.has_prefix("#") { + continue + } nonblank.push(gs_split(line, tab16)) } - if nonblank.length() < 2 { return GmtGeneSetCollection::new([]) } + if nonblank.length() < 2 { + return GmtGeneSetCollection::new([]) + } let headers = nonblank[0] let descs = nonblank[1] let n_sets = headers.length() @@ -537,9 +646,15 @@ pub fn parse_gmx(content : String) -> GmtGeneSetCollection { let row = nonblank[row_i] let mut j = 0 while j < n_sets { - if j >= row.length() { j = j + 1; continue } + if j >= row.length() { + j = j + 1 + continue + } let cell = gs_trim(row[j]) - if cell.length() == 0 { j = j + 1; continue } + if cell.length() == 0 { + j = j + 1 + continue + } set_genes[j].push(cell) j = j + 1 } @@ -549,42 +664,60 @@ pub fn parse_gmx(content : String) -> GmtGeneSetCollection { let mut j = 0 while j < n_sets { let nm = gs_trim(headers[j]) - if nm.length() == 0 { j = j + 1; continue } - let desc = if j < descs.length() { gs_trim(descs[j]) } else { "".to_string() } + if nm.length() == 0 { + j = j + 1 + continue + } + let desc = if j < descs.length() { + gs_trim(descs[j]) + } else { + "".to_string() + } result.push(GmtGeneSet::new(nm, desc, set_genes[j])) j = j + 1 } GmtGeneSetCollection::new(result) } +///| pub fn write_gmx(col : GmtGeneSetCollection) -> String { let buf = StringBuilder::new() let n = col.sets.length() let mut i = 0 while i < n { - if i > 0 { buf.write_char('\t') } + if i > 0 { + buf.write_char('\t') + } buf.write_string(col.sets[i].name) i = i + 1 } buf.write_char('\n') let mut i2 = 0 while i2 < n { - if i2 > 0 { buf.write_char('\t') } + if i2 > 0 { + buf.write_char('\t') + } buf.write_string(col.sets[i2].description) i2 = i2 + 1 } buf.write_char('\n') let mut max_len = 0 for s in col.sets { - if s.gene_ids.length() > max_len { max_len = s.gene_ids.length() } + if s.gene_ids.length() > max_len { + max_len = s.gene_ids.length() + } } let mut r = 0 while r < max_len { let mut i3 = 0 while i3 < n { - if i3 > 0 { buf.write_char('\t') } + if i3 > 0 { + buf.write_char('\t') + } let genes = col.sets[i3].gene_ids - if r < genes.length() { buf.write_string(genes[r]) } + if r < genes.length() { + buf.write_string(genes[r]) + } i3 = i3 + 1 } buf.write_char('\n') @@ -595,6 +728,7 @@ pub fn write_gmx(col : GmtGeneSetCollection) -> String { // ---- interop helper: build simple name+genes pair record (plain data) ----- +///| pub fn gsea_as_plain_name_genes(gs : GmtGeneSet) -> (String, Array[String]) { (gs.name, gs.gene_ids) } diff --git a/src/gsva.mbt b/src/gsva.mbt index f5bb55f0..4ab8717e 100644 --- a/src/gsva.mbt +++ b/src/gsva.mbt @@ -1318,23 +1318,23 @@ pub fn gsva_create_example_data() -> GSVAData { let genes : Array[String] = Array::new() let samples : Array[String] = Array::new() let expression : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < 100 { - genes.push(("Gene".to_string() + i.to_string())) + genes.push("Gene".to_string() + i.to_string()) let row : Array[Double] = Array::new() let mut j = 0 while j < 10 { - row.push(((i % 10) - 5).to_double() + j.to_double() * 0.1) + row.push((i % 10 - 5).to_double() + j.to_double() * 0.1) j = j + 1 } expression.push(row) i = i + 1 } - + i = 0 while i < 10 { - samples.push(("Sample".to_string() + i.to_string())) + samples.push("Sample".to_string() + i.to_string()) i = i + 1 } @@ -1347,27 +1347,42 @@ pub fn gsva_create_example_gene_sets() -> Array[GSVAGeneSet] { [ GSVAGeneSet::new( "CELL_CYCLE", - ["Gene0", "Gene1", "Gene2", "Gene3", "Gene4", "Gene5", "Gene6", "Gene7", "Gene8", "Gene9"], + [ + "Gene0", "Gene1", "Gene2", "Gene3", "Gene4", "Gene5", "Gene6", "Gene7", "Gene8", + "Gene9", + ], "Cell cycle related genes", ), GSVAGeneSet::new( "APOPTOSIS", - ["Gene10", "Gene11", "Gene12", "Gene13", "Gene14", "Gene15", "Gene16", "Gene17", "Gene18", "Gene19"], + [ + "Gene10", "Gene11", "Gene12", "Gene13", "Gene14", "Gene15", "Gene16", "Gene17", + "Gene18", "Gene19", + ], "Apoptosis related genes", ), GSVAGeneSet::new( "METABOLISM", - ["Gene20", "Gene21", "Gene22", "Gene23", "Gene24", "Gene25", "Gene26", "Gene27", "Gene28", "Gene29"], + [ + "Gene20", "Gene21", "Gene22", "Gene23", "Gene24", "Gene25", "Gene26", "Gene27", + "Gene28", "Gene29", + ], "Metabolism related genes", ), GSVAGeneSet::new( "IMMUNE", - ["Gene30", "Gene31", "Gene32", "Gene33", "Gene34", "Gene35", "Gene36", "Gene37", "Gene38", "Gene39"], + [ + "Gene30", "Gene31", "Gene32", "Gene33", "Gene34", "Gene35", "Gene36", "Gene37", + "Gene38", "Gene39", + ], "Immune related genes", ), GSVAGeneSet::new( "STEM", - ["Gene40", "Gene41", "Gene42", "Gene43", "Gene44", "Gene45", "Gene46", "Gene47", "Gene48", "Gene49"], + [ + "Gene40", "Gene41", "Gene42", "Gene43", "Gene44", "Gene45", "Gene46", "Gene47", + "Gene48", "Gene49", + ], "Stem cell related genes", ), ] @@ -1439,8 +1454,25 @@ pub fn gsva_enrichment_map( map = map + "------------------\n" i = 0 while i < n_sets { - let color = if avg_scores[i] > 0.5 { "#" } else if avg_scores[i] > 0.0 { "*" } else if avg_scores[i] > -0.5 { "." } else { "o" } - map = map + " " + color + " " + gene_sets[i].name + " (avg=" + avg_scores[i].to_string() + ", genes=" + gene_sets[i].genes.length().to_string() + ")\n" + let color = if avg_scores[i] > 0.5 { + "#" + } else if avg_scores[i] > 0.0 { + "*" + } else if avg_scores[i] > -0.5 { + "." + } else { + "o" + } + map = map + + " " + + color + + " " + + gene_sets[i].name + + " (avg=" + + avg_scores[i].to_string() + + ", genes=" + + gene_sets[i].genes.length().to_string() + + ")\n" i = i + 1 } @@ -1453,7 +1485,14 @@ pub fn gsva_enrichment_map( while j < n_sets { let overlap = gsva_gene_set_overlap(gene_sets[i], gene_sets[j]) if overlap > threshold { - map = map + " " + gene_sets[i].name + " ---" + overlap.to_string() + "--- " + gene_sets[j].name + "\n" + map = map + + " " + + gene_sets[i].name + + " ---" + + overlap.to_string() + + "--- " + + gene_sets[j].name + + "\n" edge_count = edge_count + 1 } j = j + 1 @@ -1499,7 +1538,9 @@ fn gsva_pearson_correlation(x : Array[Double], y : Array[Double]) -> Double { } let numerator = n * sum_xy - sum_x * sum_y - let denominator = gsva_sqrt((n * sum_x2 - sum_x * sum_x) * (n * sum_y2 - sum_y * sum_y)) + let denominator = gsva_sqrt( + (n * sum_x2 - sum_x * sum_x) * (n * sum_y2 - sum_y * sum_y), + ) if denominator == 0.0 { 0.0 @@ -1521,7 +1562,10 @@ pub fn gsva_phenotype_correlation( while i < n_sets { let corr = gsva_pearson_correlation(scores.scores[i], phenotypes) let p_value = if corr.abs() > 0.0 { - let t_stat = corr * gsva_sqrt((scores.scores[i].length() - 2).to_double() / (1.0 - corr * corr)) + let t_stat = corr * + gsva_sqrt( + (scores.scores[i].length() - 2).to_double() / (1.0 - corr * corr), + ) let df = scores.scores[i].length() - 2 if df < 1 { 1.0 @@ -1548,12 +1592,18 @@ pub fn gsva_phenotype_report( let mut report = "GSVA Phenotype Correlation Report\n" report = report + "=================================\n\n" report = report + "Phenotype: " + phenotype_name + "\n" - report = report + "Samples: " + scores.sample_names.length().to_string() + "\n\n" + report = report + + "Samples: " + + scores.sample_names.length().to_string() + + "\n\n" let correlations = gsva_phenotype_correlation(scores, phenotypes) let n_sets = correlations.length() - let sorted : Array[(String, Double, Double)] = Array::make(n_sets, ("", 0.0, 0.0)) + let sorted : Array[(String, Double, Double)] = Array::make( + n_sets, + ("", 0.0, 0.0), + ) let mut i = 0 while i < n_sets { sorted[i] = correlations[i] @@ -1584,7 +1634,13 @@ pub fn gsva_phenotype_report( i = 0 while i < sorted.length() && i < 10 { let (name, corr, pval) = sorted[i] - report = report + name + "\t" + corr.to_string() + "\t" + pval.to_string() + "\n" + report = report + + name + + "\t" + + corr.to_string() + + "\t" + + pval.to_string() + + "\n" i = i + 1 } @@ -1659,9 +1715,13 @@ pub fn gsva_survival_analysis( j = 0 while j < n { - cov = cov + (set_scores[j] - mean_score) * (event[j].to_double() - mean_event) - var_score = var_score + (set_scores[j] - mean_score) * (set_scores[j] - mean_score) - var_event = var_event + (event[j].to_double() - mean_event) * (event[j].to_double() - mean_event) + cov = cov + + (set_scores[j] - mean_score) * (event[j].to_double() - mean_event) + var_score = var_score + + (set_scores[j] - mean_score) * (set_scores[j] - mean_score) + var_event = var_event + + (event[j].to_double() - mean_event) * + (event[j].to_double() - mean_event) j = j + 1 } @@ -1703,7 +1763,10 @@ pub fn gsva_survival_report( ) -> String { let mut report = "GSVA Survival Analysis Report\n" report = report + "=============================\n\n" - report = report + "Samples: " + scores.sample_names.length().to_string() + "\n" + report = report + + "Samples: " + + scores.sample_names.length().to_string() + + "\n" let mut event_sum = 0 let mut ev_idx = 0 while ev_idx < event.length() { @@ -1744,7 +1807,17 @@ pub fn gsva_survival_report( i = 0 while i < sorted.length() && i < 10 { let res = sorted[i] - report = report + res.gene_set_name + "\t" + res.hazard_ratio.to_string() + "\t[" + res.ci_lower.to_string() + "," + res.ci_upper.to_string() + "]\t" + res.p_value.to_string() + "\n" + report = report + + res.gene_set_name + + "\t" + + res.hazard_ratio.to_string() + + "\t[" + + res.ci_lower.to_string() + + "," + + res.ci_upper.to_string() + + "]\t" + + res.p_value.to_string() + + "\n" i = i + 1 } @@ -1813,7 +1886,8 @@ pub fn gsva_score_distribution(scores : GSVAScores) -> String { i = bin_count - 1 while i >= 0 { - let threshold = min_val + range * i.to_double() / (bin_count - 1).to_double() + let threshold = min_val + + range * i.to_double() / (bin_count - 1).to_double() let mut bar = "" let mut j = 0 while j < bins[i] && max_freq > 0 { diff --git a/src/gviz.mbt b/src/gviz.mbt index 2a2e9e8a..ae4e5650 100644 --- a/src/gviz.mbt +++ b/src/gviz.mbt @@ -170,7 +170,15 @@ pub fn gviz_feature( feature_type : String, label : String, ) -> GvizFeature { - GvizFeature::{ feature_id, chromosome, start, end_, strand, feature_type, label } + GvizFeature::{ + feature_id, + chromosome, + start, + end_, + strand, + feature_type, + label, + } } ///| @@ -215,7 +223,11 @@ pub fn GvizTrack::add_feature(self : GvizTrack, feature : GvizFeature) -> Unit { ///| /// Add a data point to a DataTrack. -pub fn GvizTrack::add_data_point(self : GvizTrack, position : Int, value : Double) -> Unit { +pub fn GvizTrack::add_data_point( + self : GvizTrack, + position : Int, + value : Double, +) -> Unit { self.data_values.push((position, value)) } @@ -233,7 +245,11 @@ pub fn GvizTrack::get_n_data_points(self : GvizTrack) -> Int { ///| /// Get features within a specific region. -pub fn GvizTrack::get_features_in_region(self : GvizTrack, start : Int, end_ : Int) -> Array[GvizFeature] { +pub fn GvizTrack::get_features_in_region( + self : GvizTrack, + start : Int, + end_ : Int, +) -> Array[GvizFeature] { let result : Array[GvizFeature] = Array::new() let mut i = 0 while i < self.features.length() { @@ -248,7 +264,11 @@ pub fn GvizTrack::get_features_in_region(self : GvizTrack, start : Int, end_ : I ///| /// Get data values within a specific region. -pub fn GvizTrack::get_data_in_region(self : GvizTrack, start : Int, end_ : Int) -> Array[(Int, Double)] { +pub fn GvizTrack::get_data_in_region( + self : GvizTrack, + start : Int, + end_ : Int, +) -> Array[(Int, Double)] { let result : Array[(Int, Double)] = Array::new() let mut i = 0 while i < self.data_values.length() { @@ -275,13 +295,7 @@ pub fn gviz_plot( width? : Int = 80, height? : Int = 25, ) -> GvizPlot { - GvizPlot::{ - tracks: Array::new(), - region, - title, - width, - height, - } + GvizPlot::{ tracks: Array::new(), region, title, width, height } } ///| @@ -315,33 +329,48 @@ pub fn GvizPlot::to_ascii(self : GvizPlot) -> String { let mut result = "" result = result + self.title + "\n" - result = result + "Chromosome: " + self.region.chromosome + " [" + region_start.to_string() + " - " + region_end.to_string() + "]\n" + result = result + + "Chromosome: " + + self.region.chromosome + + " [" + + region_start.to_string() + + " - " + + region_end.to_string() + + "]\n" result = result + gviz_repeat("=", w) + "\n" // Process each track let mut ti = 0 while ti < self.tracks.length() { let track = self.tracks[ti] - result = result + "[" + track.track_type.to_string() + "] " + track.display_label + "\n" + result = result + + "[" + + track.track_type.to_string() + + "] " + + track.display_label + + "\n" // Render track content match track.track_type { - GvizTrackType::GenomeAxisTrack => { + GvizTrackType::GenomeAxisTrack => // Draw axis with position labels result = result + gviz_render_axis(region_start, region_end, w) + "\n" - } - GvizTrackType::AnnotationTrack | GvizTrackType::GeneRegionTrack => { - result = result + gviz_render_features(track, region_start, region_end, w) + "\n" - } - GvizTrackType::DataTrack => { - result = result + gviz_render_data(track, region_start, region_end, w) + "\n" - } - GvizTrackType::IdeogramTrack => { - result = result + gviz_render_ideogram(track, region_start, region_end, w) + "\n" - } - GvizTrackType::SequenceTrack => { - result = result + gviz_render_sequence(track, region_start, region_end, w) + "\n" - } + GvizTrackType::AnnotationTrack | GvizTrackType::GeneRegionTrack => + result = result + + gviz_render_features(track, region_start, region_end, w) + + "\n" + GvizTrackType::DataTrack => + result = result + + gviz_render_data(track, region_start, region_end, w) + + "\n" + GvizTrackType::IdeogramTrack => + result = result + + gviz_render_ideogram(track, region_start, region_end, w) + + "\n" + GvizTrackType::SequenceTrack => + result = result + + gviz_render_sequence(track, region_start, region_end, w) + + "\n" } result = result + "\n" ti = ti + 1 @@ -391,7 +420,12 @@ fn gviz_render_axis(start : Int, end_ : Int, width : Int) -> String { ///| /// Render features as boxes. -fn gviz_render_features(track : GvizTrack, region_start : Int, region_end : Int, width : Int) -> String { +fn gviz_render_features( + track : GvizTrack, + region_start : Int, + region_end : Int, + width : Int, +) -> String { let region_len = (region_end - region_start).to_double() if region_len <= 0.0 { return "" @@ -412,8 +446,12 @@ fn gviz_render_features(track : GvizTrack, region_start : Int, region_end : Int, if f.end_ < region_start || f.start > region_end { fi = fi + 1 } else { - let rel_start = ((f.start - region_start).to_double() / region_len * (width - 1).to_double()).to_int() - let rel_end = ((f.end_ - region_start).to_double() / region_len * (width - 1).to_double()).to_int() + let rel_start = ((f.start - region_start).to_double() / + region_len * + (width - 1).to_double()).to_int() + let rel_end = ((f.end_ - region_start).to_double() / + region_len * + (width - 1).to_double()).to_int() let s = if rel_start < 0 { 0 } else { rel_start } let e = if rel_end >= width { width - 1 } else { rel_end } @@ -461,7 +499,12 @@ fn gviz_render_features(track : GvizTrack, region_start : Int, region_end : Int, ///| /// Render feature labels. -fn gviz_render_labels(track : GvizTrack, region_start : Int, region_end : Int, width : Int) -> String { +fn gviz_render_labels( + track : GvizTrack, + region_start : Int, + region_end : Int, + width : Int, +) -> String { let region_len = (region_end - region_start).to_double() if region_len <= 0.0 { return "" @@ -481,7 +524,9 @@ fn gviz_render_labels(track : GvizTrack, region_start : Int, region_end : Int, w fi = fi + 1 } else { let mid_pos = (f.start + f.end_) / 2 - let rel_mid = ((mid_pos - region_start).to_double() / region_len * (width - 1).to_double()).to_int() + let rel_mid = ((mid_pos - region_start).to_double() / + region_len * + (width - 1).to_double()).to_int() if rel_mid >= 0 && rel_mid < width && f.label.length() > 0 { let label = f.label let mut li = 0 @@ -499,7 +544,12 @@ fn gviz_render_labels(track : GvizTrack, region_start : Int, region_end : Int, w ///| /// Render data track as a simple bar plot. -fn gviz_render_data(track : GvizTrack, region_start : Int, region_end : Int, width : Int) -> String { +fn gviz_render_data( + track : GvizTrack, + region_start : Int, + region_end : Int, + width : Int, +) -> String { let data = track.get_data_in_region(region_start, region_end) if data.length() == 0 { return "(no data)" @@ -510,8 +560,12 @@ fn gviz_render_data(track : GvizTrack, region_start : Int, region_end : Int, wid let mut max_val = data[0].1 let mut i = 1 while i < data.length() { - if data[i].1 < min_val { min_val = data[i].1 } - if data[i].1 > max_val { max_val = data[i].1 } + if data[i].1 < min_val { + min_val = data[i].1 + } + if data[i].1 > max_val { + max_val = data[i].1 + } i = i + 1 } @@ -541,7 +595,9 @@ fn gviz_render_data(track : GvizTrack, region_start : Int, region_end : Int, wid let mut di = 0 while di < data.length() { let (pos, val) = data[di] - let rel_pos = ((pos - region_start).to_double() / region_len * (width - 1).to_double()).to_int() + let rel_pos = ((pos - region_start).to_double() / + region_len * + (width - 1).to_double()).to_int() let normalized = (val - min_val) / val_range let bar_h = (normalized * bar_height.to_double()).to_int() @@ -562,13 +618,22 @@ fn gviz_render_data(track : GvizTrack, region_start : Int, region_end : Int, wid rri = rri + 1 } - result = result + "min: " + min_val.to_string() + ", max: " + max_val.to_string() + result = result + + "min: " + + min_val.to_string() + + ", max: " + + max_val.to_string() result } ///| /// Render ideogram track. -fn gviz_render_ideogram(track : GvizTrack, region_start : Int, region_end : Int, width : Int) -> String { +fn gviz_render_ideogram( + track : GvizTrack, + region_start : Int, + region_end : Int, + width : Int, +) -> String { // Simplified ideogram: draw a chromosome bar with centromere marker let mut s = "" let mut i = 0 @@ -583,13 +648,23 @@ fn gviz_render_ideogram(track : GvizTrack, region_start : Int, region_end : Int, i = i + 1 } s = s + "\n" - s = s + "p" + gviz_repeat(" ", width / 2 - 2) + "cen" + gviz_repeat(" ", width / 2 - 2) + "q" + s = s + + "p" + + gviz_repeat(" ", width / 2 - 2) + + "cen" + + gviz_repeat(" ", width / 2 - 2) + + "q" s } ///| /// Render sequence track. -fn gviz_render_sequence(track : GvizTrack, region_start : Int, region_end : Int, width : Int) -> String { +fn gviz_render_sequence( + track : GvizTrack, + region_start : Int, + region_end : Int, + width : Int, +) -> String { let region_len = region_end - region_start if region_len <= 0 { return "" @@ -614,12 +689,30 @@ fn gviz_render_sequence(track : GvizTrack, region_start : Int, region_end : Int, pub fn GvizPlot::summary(self : GvizPlot) -> String { let mut s = "=== Gviz Plot Summary ===\n".to_string() s = s + "Title: " + self.title + "\n" - s = s + "Region: " + self.region.chromosome + ":" + self.region.start.to_string() + "-" + self.region.end_.to_string() + "\n" + s = s + + "Region: " + + self.region.chromosome + + ":" + + self.region.start.to_string() + + "-" + + self.region.end_.to_string() + + "\n" s = s + "Tracks: " + self.tracks.length().to_string() + "\n" let mut i = 0 while i < self.tracks.length() { - s = s + " [" + (i + 1).to_string() + "] " + self.tracks[i].track_type.to_string() + ": " + self.tracks[i].display_label - s = s + " (" + self.tracks[i].get_n_features().to_string() + " features, " + self.tracks[i].get_n_data_points().to_string() + " data points)\n" + s = s + + " [" + + (i + 1).to_string() + + "] " + + self.tracks[i].track_type.to_string() + + ": " + + self.tracks[i].display_label + s = s + + " (" + + self.tracks[i].get_n_features().to_string() + + " features, " + + self.tracks[i].get_n_data_points().to_string() + + " data points)\n" i = i + 1 } s @@ -629,20 +722,67 @@ pub fn GvizPlot::summary(self : GvizPlot) -> String { /// Create sample data for testing. pub fn gviz_sample_plot() -> GvizPlot { let region = gviz_region("chr1", 1000, 5000) - let plot = gviz_plot(region, title="Sample Genome Region", width=80, height=25) + let plot = gviz_plot( + region, + title="Sample Genome Region", + width=80, + height=25, + ) // Axis track - let axis_track = gviz_track("axis", track_type_genome_axis(), "chr1", 1000, 5000) + let axis_track = gviz_track( + "axis", + track_type_genome_axis(), + "chr1", + 1000, + 5000, + ) axis_track.set_label("Genome Axis") plot.add_track(axis_track) // Gene region track - let gene_track = gviz_track("genes", track_type_gene_region(), "chr1", 1000, 5000) + let gene_track = gviz_track( + "genes", + track_type_gene_region(), + "chr1", + 1000, + 5000, + ) gene_track.set_label("Gene Annotations") gene_track.set_color("blue") - gene_track.add_feature(gviz_feature("g1", "chr1", 1200, 1800, track_strand_forward(), "exon", "BRCA1")) - gene_track.add_feature(gviz_feature("g2", "chr1", 2000, 3500, track_strand_reverse(), "exon", "TP53")) - gene_track.add_feature(gviz_feature("g3", "chr1", 4000, 4500, track_strand_forward(), "exon", "EGFR")) + gene_track.add_feature( + gviz_feature( + "g1", + "chr1", + 1200, + 1800, + track_strand_forward(), + "exon", + "BRCA1", + ), + ) + gene_track.add_feature( + gviz_feature( + "g2", + "chr1", + 2000, + 3500, + track_strand_reverse(), + "exon", + "TP53", + ), + ) + gene_track.add_feature( + gviz_feature( + "g3", + "chr1", + 4000, + 4500, + track_strand_forward(), + "exon", + "EGFR", + ), + ) plot.add_track(gene_track) // Data track @@ -659,7 +799,13 @@ pub fn gviz_sample_plot() -> GvizPlot { plot.add_track(data_track) // Ideogram track - let ideo_track = gviz_track("ideogram", gviz_track_type_ideogram(), "chr1", 1000, 5000) + let ideo_track = gviz_track( + "ideogram", + gviz_track_type_ideogram(), + "chr1", + 1000, + 5000, + ) ideo_track.set_label("Ideogram") plot.add_track(ideo_track) diff --git a/src/harmony.mbt b/src/harmony.mbt index f019e8a4..96f86c8f 100644 --- a/src/harmony.mbt +++ b/src/harmony.mbt @@ -77,13 +77,13 @@ pub fn HarmonyParams::create( seed? : Int = 42, ) -> HarmonyParams { HarmonyParams::{ - n_clusters: n_clusters, - max_iterations: max_iterations, - tolerance: tolerance, - lambda: lambda, - sigma: sigma, - ridge_penalty: ridge_penalty, - seed: seed, + n_clusters, + max_iterations, + tolerance, + lambda, + sigma, + ridge_penalty, + seed, } } @@ -100,19 +100,25 @@ pub struct HarmonyResult { ///| /// Get corrected embeddings. -pub fn HarmonyResult::get_corrected(self : HarmonyResult) -> Array[Array[Double]] { +pub fn HarmonyResult::get_corrected( + self : HarmonyResult, +) -> Array[Array[Double]] { self.corrected } ///| /// Get soft cluster membership matrix. -pub fn HarmonyResult::get_membership(self : HarmonyResult) -> Array[Array[Double]] { +pub fn HarmonyResult::get_membership( + self : HarmonyResult, +) -> Array[Array[Double]] { self.membership } ///| /// Get cluster centroids. -pub fn HarmonyResult::get_centroids(self : HarmonyResult) -> Array[Array[Double]] { +pub fn HarmonyResult::get_centroids( + self : HarmonyResult, +) -> Array[Array[Double]] { self.centroids } @@ -134,29 +140,49 @@ pub fn harmony_run(data : HarmonyData, params : HarmonyParams) -> HarmonyResult let n_cells = data.embeddings.length() let n_dims = if n_cells > 0 { data.embeddings[0].length() } else { 0 } let n_clusters = if params.n_clusters > 0 { params.n_clusters } else { 1 } - + let centroids = harmony_init_centroids(data, n_clusters, params.seed) - let membership = harmony_compute_membership(data.embeddings, centroids, params.lambda) + let membership = harmony_compute_membership( + data.embeddings, + centroids, + params.lambda, + ) let mut corrected = data.embeddings - + let mut iter = 0 let mut converged = false let mut prev_obj = harmony_objective(data.embeddings, centroids, membership) - + while iter < params.max_iterations { - let new_centroids = harmony_update_centroids(corrected, membership, n_clusters) + let new_centroids = harmony_update_centroids( + corrected, membership, n_clusters, + ) let corrections = harmony_batch_corrections( - HarmonyData::{ embeddings: corrected, batch_labels: data.batch_labels, cell_ids: data.cell_ids }, + HarmonyData::{ + embeddings: corrected, + batch_labels: data.batch_labels, + cell_ids: data.cell_ids, + }, membership, new_centroids, n_clusters, params.ridge_penalty, ) - corrected = harmony_apply_correction(corrected, membership, corrections, n_clusters) - let new_membership = harmony_compute_membership(corrected, new_centroids, params.lambda) + corrected = harmony_apply_correction( + corrected, membership, corrections, n_clusters, + ) + let new_membership = harmony_compute_membership( + corrected, + new_centroids, + params.lambda, + ) let obj = harmony_objective(corrected, new_centroids, new_membership) - let delta = if prev_obj.abs() > 1.0e-10 { (prev_obj - obj).abs() / prev_obj.abs() } else { 0.0 } - + let delta = if prev_obj.abs() > 1.0e-10 { + (prev_obj - obj).abs() / prev_obj.abs() + } else { + 0.0 + } + if delta < params.tolerance { converged = true break @@ -164,7 +190,7 @@ pub fn harmony_run(data : HarmonyData, params : HarmonyParams) -> HarmonyResult prev_obj = obj iter = iter + 1 } - + HarmonyResult::{ corrected, membership, @@ -177,20 +203,24 @@ pub fn harmony_run(data : HarmonyData, params : HarmonyParams) -> HarmonyResult ///| /// Initialize cluster centroids using k-means++ style seeding. -fn harmony_init_centroids(data : HarmonyData, n_clusters : Int, seed : Int) -> Array[Array[Double]] { +fn harmony_init_centroids( + data : HarmonyData, + n_clusters : Int, + seed : Int, +) -> Array[Array[Double]] { let n_cells = data.embeddings.length() if n_cells == 0 { return Array::make(n_clusters, Array::make(0, 0.0)) } let n_dims = data.embeddings[0].length() - + let centroids : Array[Array[Double]] = Array::new() let mut rng_state = seed - + let first_idx = harmony_next_rand(rng_state) % n_cells rng_state = harmony_next_rand(rng_state) centroids.push(data.embeddings[first_idx]) - + let mut c = 1 while c < n_clusters { let dists : Array[Double] = Array::make(n_cells, 0.0) @@ -208,10 +238,12 @@ fn harmony_init_centroids(data : HarmonyData, n_clusters : Int, seed : Int) -> A dists[i] = min_dist i = i + 1 } - + let total_dist = harmony_sum(dists) if total_dist > 0.0 { - let r = harmony_next_rand(rng_state).to_double() / 2147483647.0 * total_dist + let r = harmony_next_rand(rng_state).to_double() / + 2147483647.0 * + total_dist rng_state = harmony_next_rand(rng_state) let mut best_idx = 0 let mut cum = 0.0 @@ -245,7 +277,7 @@ fn harmony_compute_membership( let n_cells = embeddings.length() let n_clusters = centroids.length() let membership : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_cells { let responsibilities : Array[Double] = Array::make(n_clusters, 0.0) @@ -260,7 +292,7 @@ fn harmony_compute_membership( responsibilities[j] = logit j = j + 1 } - + let mut sum_exp = 0.0 let mut k = 0 while k < n_clusters { @@ -268,7 +300,7 @@ fn harmony_compute_membership( sum_exp = sum_exp + responsibilities[k] k = k + 1 } - + if sum_exp > 0.0 { let mut m = 0 while m < n_clusters { @@ -276,7 +308,7 @@ fn harmony_compute_membership( m = m + 1 } } - + membership.push(responsibilities) i = i + 1 } @@ -293,7 +325,7 @@ fn harmony_update_centroids( let n_cells = embeddings.length() let n_dims = if n_cells > 0 { embeddings[0].length() } else { 0 } let centroids : Array[Array[Double]] = Array::new() - + let mut k = 0 while k < n_clusters { let mut weight_sum = 0.0 @@ -333,7 +365,7 @@ fn harmony_batch_corrections( ) -> Array[Array[Array[Double]]] { let n_cells = data.embeddings.length() let n_dims = if n_cells > 0 { data.embeddings[0].length() } else { 0 } - + // Get unique batches let unique_batches : Array[String] = Array::new() { @@ -348,10 +380,13 @@ fn harmony_batch_corrections( i = i + 1 } } - + let n_batches = unique_batches.length() - let corrections : Array[Array[Array[Double]]] = Array::make(n_clusters, Array::make(n_batches, Array::make(n_dims, 0.0))) - + let corrections : Array[Array[Array[Double]]] = Array::make( + n_clusters, + Array::make(n_batches, Array::make(n_dims, 0.0)), + ) + let mut k = 0 while k < n_clusters { let mut b = 0 @@ -362,7 +397,7 @@ fn harmony_batch_corrections( let batch_mean : Array[Double] = Array::make(n_dims, 0.0) let global_mean : Array[Double] = Array::make(n_dims, 0.0) let mut gw = 0.0 - + let mut i = 0 while i < n_cells { let w = membership[i][k] @@ -382,7 +417,7 @@ fn harmony_batch_corrections( } i = i + 1 } - + if weight_sum > 0.0 { let mut d = 0 while d < n_dims { @@ -397,7 +432,7 @@ fn harmony_batch_corrections( d = d + 1 } } - + // Correction = batch_mean - global_mean (with ridge penalty) let correction : Array[Double] = Array::make(n_dims, 0.0) let effective_weight = weight_sum / (weight_sum + ridge_penalty) @@ -425,7 +460,7 @@ fn harmony_apply_correction( let n_cells = embeddings.length() let n_dims = if n_cells > 0 { embeddings[0].length() } else { 0 } let n_batches = if n_clusters > 0 { corrections[0].length() } else { 0 } - + // Get unique batches from correction dimensions let corrected : Array[Array[Double]] = Array::new() let mut i = 0 @@ -436,7 +471,7 @@ fn harmony_apply_correction( new_cell[d] = embeddings[i][d] d = d + 1 } - + let mut k = 0 while k < n_clusters { let w = membership[i][k] @@ -514,20 +549,24 @@ fn harmony_next_rand(seed : Int) -> Int { ///| /// Create example data for Harmony testing. -pub fn harmony_create_example(n_cells : Int, n_batches : Int, n_dims : Int) -> HarmonyData { +pub fn harmony_create_example( + n_cells : Int, + n_batches : Int, + n_dims : Int, +) -> HarmonyData { let embeddings : Array[Array[Double]] = Array::new() let batch_labels : Array[String] = Array::new() let cell_ids : Array[String] = Array::new() let mut rng = 42 - + let mut i = 0 while i < n_cells { let batch_idx = i * n_batches / n_cells let batch_id = "batch_" + batch_idx.to_string() - + // Simulate batch effect let batch_effect = batch_idx.to_double() * 2.0 - + let cell : Array[Double] = Array::make(n_dims, 0.0) let mut d = 0 while d < n_dims { @@ -536,12 +575,12 @@ pub fn harmony_create_example(n_cells : Int, n_batches : Int, n_dims : Int) -> H cell[d] = batch_effect + noise d = d + 1 } - + embeddings.push(cell) batch_labels.push(batch_id) cell_ids.push("cell_" + i.to_string()) i = i + 1 } - + HarmonyData::{ embeddings, batch_labels, cell_ids } } diff --git a/src/hicdc.mbt b/src/hicdc.mbt index 4e20b44f..e43507bd 100644 --- a/src/hicdc.mbt +++ b/src/hicdc.mbt @@ -35,7 +35,7 @@ pub fn HiCContact::new( bin1 : Int, bin2 : Int, count : Int, - bin_size : Int + bin_size : Int, ) -> HiCContact { let distance = if bin2 > bin1 { bin2 - bin1 } else { bin1 - bin2 } HiCContact::{ @@ -234,6 +234,7 @@ pub fn CompartmentCall::compartment(self : CompartmentCall) -> String { // Internal helpers // =========================================================================== +///| fn hc_abs(x : Double) -> Double { if x < 0.0 { -x @@ -242,6 +243,7 @@ fn hc_abs(x : Double) -> Double { } } +///| fn hc_sqrt(x : Double) -> Double { if x <= 0.0 { return 0.0 @@ -261,6 +263,7 @@ fn hc_sqrt(x : Double) -> Double { guess } +///| fn hc_log(x : Double) -> Double { if x <= 0.0 { return -700.0 @@ -268,6 +271,7 @@ fn hc_log(x : Double) -> Double { @math.ln(x) } +///| fn hc_exp(x : Double) -> Double { if x > 700.0 { return 1.7976931348623157e+308 @@ -289,7 +293,12 @@ fn hc_normal_cdf(x : Double) -> Double { } let t = 1.0 / (1.0 + 0.2316419 * hc_abs(x)) let d = 0.3989423 * hc_exp(-x * x / 2.0) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))) + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))) + ) if x >= 0.0 { 1.0 - p } else { @@ -336,7 +345,7 @@ fn hc_upper_gamma_q(a : Double, x : Double) -> Double { let mut h = d let mut i = 1 while i < 200 { - let an = -(i.to_double()) * (i.to_double() - a) + let an = -i.to_double() * (i.to_double() - a) b = b + 2.0 d = an * d + b if hc_abs(d) < tiny { @@ -361,18 +370,15 @@ fn hc_upper_gamma_q(a : Double, x : Double) -> Double { /// Log-gamma function via Lanczos approximation. fn hc_log_gamma(x : Double) -> Double { if x < 0.5 { - return hc_log(3.141592653589793 / (hc_sin(3.141592653589793 * x) * hc_exp(hc_log_gamma(1.0 - x)))) + return hc_log( + 3.141592653589793 / + (hc_sin(3.141592653589793 * x) * hc_exp(hc_log_gamma(1.0 - x))), + ) } let g = 7.0 let c = [ - 0.99999999999980993, - 676.5203681218851, - -1259.1392167224028, - 771.32342877765313, - -176.61502916214059, - 12.507343278686905, - -0.13857109526572012, - 9.9843695780195716e-6, + 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, + -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7, ] let mut a = c[0] @@ -423,7 +429,7 @@ fn hc_sin(x : Double) -> Double { /// /// Returns the fitted parameters: (intercept, beta_dist, beta_gc, beta_map, dispersion). pub fn hicdc_fit_background( - contacts : Array[HiCContact] + contacts : Array[HiCContact], ) -> (Double, Double, Double, Double, Double) { let n = contacts.length() if n == 0 { @@ -526,7 +532,7 @@ pub fn hicdc_predict_expected( intercept : Double, beta_dist : Double, beta_gc : Double, - beta_map : Double + beta_map : Double, ) -> Array[Double] { let expected : Array[Double] = Array::new() for c in contacts { @@ -555,7 +561,7 @@ pub fn hicdc_test_significance( beta_dist : Double, beta_gc : Double, beta_map : Double, - dispersion : Double + dispersion : Double, ) -> Array[HiCDCResult] { let n = contacts.length() let results : Array[HiCDCResult] = Array::new() @@ -572,7 +578,13 @@ pub fn hicdc_test_significance( let z = (c.count.to_double() - mu) / std_dev // One-sided p-value (test for enrichment). let p_value = 1.0 - hc_normal_cdf(z) - let p_value = if p_value < 0.0 { 0.0 } else if p_value > 1.0 { 1.0 } else { p_value } + let p_value = if p_value < 0.0 { + 0.0 + } else if p_value > 1.0 { + 1.0 + } else { + p_value + } let log_fc = hc_log(c.count.to_double() / mu) results.push(HiCDCResult::{ chr: c.chr, @@ -638,7 +650,7 @@ fn hc_bh_fdr(results : Array[HiCDCResult]) -> Array[HiCDCResult] { /// Mark significant results at given FDR threshold. pub fn hicdc_mark_significant( results : Array[HiCDCResult], - fdr_threshold : Double + fdr_threshold : Double, ) -> Array[HiCDCResult] { for r in results { r.significant = r.fdr < fdr_threshold @@ -661,7 +673,7 @@ pub fn hicdc_mark_significant( pub fn hicdc_directionality_index( contacts : Array[HiCContact], n_bins : Int, - window : Int + window : Int, ) -> Array[Double] { // Build per-bin downstream and upstream contact sums. let downstream = Array::make(n_bins, 0.0) @@ -702,7 +714,7 @@ pub fn hicdc_call_tads( contacts : Array[HiCContact], n_bins : Int, window : Int, - chr : String + chr : String, ) -> Array[TADBoundary] { let di = hicdc_directionality_index(contacts, n_bins, window) let boundaries : Array[TADBoundary] = Array::new() @@ -731,7 +743,7 @@ pub fn hicdc_call_tads( pub fn hicdc_call_compartments( contacts : Array[HiCContact], n_bins : Int, - chr : String + chr : String, ) -> Array[CompartmentCall] { // Build contact matrix. let matrix : Array[Array[Double]] = Array::new() @@ -784,7 +796,7 @@ pub fn hicdc_call_compartments( fn hc_power_iteration( matrix : Array[Array[Double]], n : Int, - max_iter : Int + max_iter : Int, ) -> Array[Double] { let v = Array::make(n, 1.0) // Normalize initial vector. @@ -833,6 +845,7 @@ fn hc_power_iteration( v } +///| fn hc_mean(arr : Array[Double]) -> Double { let n = arr.length() if n == 0 { @@ -845,6 +858,7 @@ fn hc_mean(arr : Array[Double]) -> Double { s / n.to_double() } +///| fn hc_std(arr : Array[Double], mean : Double) -> Double { let n = arr.length() if n == 0 { @@ -862,6 +876,7 @@ fn hc_std(arr : Array[Double], mean : Double) -> Double { // Linear algebra helper // =========================================================================== +///| fn hc_solve(matrix : Array[Array[Double]], b : Array[Double]) -> Array[Double]? { let n = matrix.length() if n == 0 { @@ -934,7 +949,7 @@ fn hc_solve(matrix : Array[Array[Double]], b : Array[Double]) -> Array[Double]? pub fn hicdc_differential( contacts1 : Array[HiCContact], contacts2 : Array[HiCContact], - fdr_threshold : Double + fdr_threshold : Double, ) -> Array[HiCDCResult] { // Build lookup for condition 2 contacts. let map2 : Map[String, HiCContact] = Map([], capacity=contacts2.length()) @@ -950,7 +965,9 @@ pub fn hicdc_differential( for c in contacts2 { pooled.push(c) } - let (intercept, beta_dist, beta_gc, beta_map, dispersion) = hicdc_fit_background(pooled) + let (intercept, beta_dist, beta_gc, beta_map, dispersion) = hicdc_fit_background( + pooled, + ) // Test each contact from condition 1 for differential enrichment. let results : Array[HiCDCResult] = Array::new() for c1 in contacts1 { @@ -969,7 +986,13 @@ pub fn hicdc_differential( let diff = (c1.count - c2.count).to_double() let z = diff / (std_dev * hc_sqrt(2.0)) let p_value = 2.0 * (1.0 - hc_normal_cdf(hc_abs(z))) - let p_value = if p_value < 0.0 { 0.0 } else if p_value > 1.0 { 1.0 } else { p_value } + let p_value = if p_value < 0.0 { + 0.0 + } else if p_value > 1.0 { + 1.0 + } else { + p_value + } let c2_count = c2.count.to_double() let denom = if c2_count > 0.0000001 { c2_count } else { 0.0000001 } let log_fc = hc_log(c1.count.to_double() / denom) @@ -1000,11 +1023,13 @@ pub fn hicdc_differential( /// and mark significant interactions. pub fn hicdc_run( contacts : Array[HiCContact], - fdr_threshold : Double + fdr_threshold : Double, ) -> Array[HiCDCResult] { - let (intercept, beta_dist, beta_gc, beta_map, dispersion) = hicdc_fit_background(contacts) + let (intercept, beta_dist, beta_gc, beta_map, dispersion) = hicdc_fit_background( + contacts, + ) let results = hicdc_test_significance( - contacts, intercept, beta_dist, beta_gc, beta_map, dispersion + contacts, intercept, beta_dist, beta_gc, beta_map, dispersion, ) hicdc_mark_significant(results, fdr_threshold) } diff --git a/src/hilbertcurve.mbt b/src/hilbertcurve.mbt index cba0ed58..3d23a421 100644 --- a/src/hilbertcurve.mbt +++ b/src/hilbertcurve.mbt @@ -18,10 +18,10 @@ pub fn HilbertCurve::new(levels : Int, dimension : Int) -> HilbertCurve { pub fn hilbert_encode(hc : HilbertCurve, coordinates : Array[Int]) -> Int { let mut result = 0 let mut s = 1 << (hc.levels - 1) - + let x : Array[Int] = coordinates.copy() let n = hc.dimension - + while s > 0 { let mut region = 0 let mut i = 0 @@ -31,15 +31,15 @@ pub fn hilbert_encode(hc : HilbertCurve, coordinates : Array[Int]) -> Int { } i = i + 1 } - + let shift_amount = n * (hc.levels - log2_int(s)) result = result | (region << shift_amount) - + hilbert_inverse(hc, x, s) - + s = s >> 1 } - + result } @@ -62,7 +62,7 @@ fn log2_int(x : Int) -> Int { ///| fn hilbert_inverse(hc : HilbertCurve, x : Array[Int], s : Int) -> Unit { let n = hc.dimension - + let shift_amount = log2_int(s) let bits = (x[0] >> shift_amount) & 1 let mut i = 1 @@ -71,7 +71,7 @@ fn hilbert_inverse(hc : HilbertCurve, x : Array[Int], s : Int) -> Unit { x[0] = x[0] ^ (bit_i << shift_amount) i = i + 1 } - + let mut j = 1 while j < n { let mut k = j + 1 @@ -93,17 +93,17 @@ pub fn hilbert_decode(hc : HilbertCurve, index : Int) -> Array[Int] { x.push(0) i = i + 1 } - + let mut s = 1 let mut t = index - + let n = hc.dimension - + while s <= hc.max_coordinate { let region = t & ((1 << n) - 1) - + hilbert_inverse(hc, x, s) - + let mut i = 0 while i < n { if bit_is_set(region, 1 << i) { @@ -111,18 +111,22 @@ pub fn hilbert_decode(hc : HilbertCurve, index : Int) -> Array[Int] { } i = i + 1 } - + t = t >> n s = s << 1 } - + x } ///| -pub fn hilbert_point_to_segment(hc : HilbertCurve, start : Int, end : Int) -> Array[(Int, Int)] { +pub fn hilbert_point_to_segment( + hc : HilbertCurve, + start : Int, + end : Int, +) -> Array[(Int, Int)] { let segments : Array[(Int, Int)] = Array::new() - + let mut i = start while i <= end { let coords = hilbert_decode(hc, i) @@ -131,44 +135,54 @@ pub fn hilbert_point_to_segment(hc : HilbertCurve, start : Int, end : Int) -> Ar } i = i + 1 } - + segments } ///| -pub fn hilbert_distance(hc : HilbertCurve, coord1 : Array[Int], coord2 : Array[Int]) -> Int { +pub fn hilbert_distance( + hc : HilbertCurve, + coord1 : Array[Int], + coord2 : Array[Int], +) -> Int { let idx1 = hilbert_encode(hc, coord1) let idx2 = hilbert_encode(hc, coord2) - + let diff = if idx1 > idx2 { idx1 - idx2 } else { idx2 - idx1 } diff } ///| -pub fn hilbert_linearize_genome(genome_length : Int, levels : Int) -> Array[(Int, Int)] { +pub fn hilbert_linearize_genome( + genome_length : Int, + levels : Int, +) -> Array[(Int, Int)] { let hc = HilbertCurve::new(levels, 2) let max_coord = (1 << levels) - 1 - + let segments : Array[(Int, Int)] = Array::new() - + let mut i = 0 while i < genome_length { let x = i % (max_coord + 1) let y = i / (max_coord + 1) - + let idx = hilbert_encode(hc, [x, y]) segments.push((i, idx)) i = i + 1 } - + segments } ///| -pub fn hilbert_map_to_grid(hc : HilbertCurve, values : Array[Double]) -> Array[Array[Double]] { +pub fn hilbert_map_to_grid( + hc : HilbertCurve, + values : Array[Double], +) -> Array[Array[Double]] { let size = hc.max_coordinate + 1 let grid : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < size { let row : Array[Double] = Array::new() @@ -180,7 +194,7 @@ pub fn hilbert_map_to_grid(hc : HilbertCurve, values : Array[Double]) -> Array[A grid.push(row) i = i + 1 } - + let mut idx = 0 while idx < values.length() { let coords = hilbert_decode(hc, idx) @@ -193,7 +207,7 @@ pub fn hilbert_map_to_grid(hc : HilbertCurve, values : Array[Double]) -> Array[A } idx = idx + 1 } - + grid } diff --git a/src/hmisc.mbt b/src/hmisc.mbt index a916c54e..ee2cb936 100644 --- a/src/hmisc.mbt +++ b/src/hmisc.mbt @@ -11,6 +11,7 @@ pub enum HmiscCorType { HC_Spearman } +///| /// Convert correlation type to string. pub fn hmisc_cor_type_to_string(ct : HmiscCorType) -> String { match ct { @@ -90,7 +91,10 @@ pub struct HmiscSomersResult { ///| /// Compute descriptive statistics for an array of values. /// Missing values (NaN) are automatically excluded. -pub fn hmisc_describe(values : Array[Double], name? : String = "") -> HmiscDescriptiveStats { +pub fn hmisc_describe( + values : Array[Double], + name? : String = "", +) -> HmiscDescriptiveStats { let valid : Array[Double] = Array::new() let mut n_missing = 0 let mut i = 0 @@ -233,7 +237,15 @@ fn hmisc_rank_array(data : Array[Double]) -> Array[Double] { indices[i] = i i = i + 1 } - indices.sort_by(fn(a : Int, b : Int) -> Int { if data[a] < data[b] { -1 } else if data[a] > data[b] { 1 } else { 0 } }) + indices.sort_by(fn(a : Int, b : Int) -> Int { + if data[a] < data[b] { + -1 + } else if data[a] > data[b] { + 1 + } else { + 0 + } + }) let ranks = Array::make(n, 0.0) i = 0 while i < n { @@ -241,7 +253,7 @@ fn hmisc_rank_array(data : Array[Double]) -> Array[Double] { while j < n - 1 && data[indices[j]] == data[indices[j + 1]] { j = j + 1 } - let avg = ((i + j).to_double() / 2.0) + 1.0 + let avg = (i + j).to_double() / 2.0 + 1.0 let mut k = i while k <= j { ranks[indices[k]] = avg @@ -309,7 +321,7 @@ pub fn hmisc_rcorr( } let p = if n_pair > 2 && !r.is_nan() { let t_stat = r * ((n_pair.to_double() - 2.0) / (1.0 - r * r)).sqrt() - 2.0 * hmisc_t_dist_p((t_stat.abs()), n_pair - 2) + 2.0 * hmisc_t_dist_p(t_stat.abs(), n_pair - 2) } else { @double.not_a_number } @@ -324,13 +336,7 @@ pub fn hmisc_rcorr( } i = i + 1 } - HmiscCorrResult::{ - matrix, - p_values, - n: n_matrix, - names: var_names, - cor_type, - } + HmiscCorrResult::{ matrix, p_values, n: n_matrix, names: var_names, cor_type } } ///| @@ -366,18 +372,32 @@ fn hmisc_ibeta(a : Double, b : Double, x : Double) -> Double { f = d let mut m = 1 while m <= max_iter { - let num = m.to_double() * (b - m.to_double()) * x / ((a + 2.0 * m.to_double() - 1.0) * (a + 2.0 * m.to_double())) + let num = m.to_double() * + (b - m.to_double()) * + x / + ((a + 2.0 * m.to_double() - 1.0) * (a + 2.0 * m.to_double())) d = 1.0 + num * d - if d.abs() < 1.0e-30 { d = 1.0e-30 } + if d.abs() < 1.0e-30 { + d = 1.0e-30 + } c_val = 1.0 + num / c_val - if c_val.abs() < 1.0e-30 { c_val = 1.0e-30 } + if c_val.abs() < 1.0e-30 { + c_val = 1.0e-30 + } d = 1.0 / d f = f * d * c_val - let num2 = -(a + m.to_double()) * (a + b + m.to_double()) * x / ((a + 2.0 * m.to_double()) * (a + 2.0 * m.to_double() + 1.0)) + let num2 = -(a + m.to_double()) * + (a + b + m.to_double()) * + x / + ((a + 2.0 * m.to_double()) * (a + 2.0 * m.to_double() + 1.0)) d = 1.0 + num2 * d - if d.abs() < 1.0e-30 { d = 1.0e-30 } + if d.abs() < 1.0e-30 { + d = 1.0e-30 + } c_val = 1.0 + num2 / c_val - if c_val.abs() < 1.0e-30 { c_val = 1.0e-30 } + if c_val.abs() < 1.0e-30 { + c_val = 1.0e-30 + } d = 1.0 / d let del = d * c_val f = f * del @@ -397,14 +417,8 @@ fn hmisc_log_gamma(x : Double) -> Double { } let g = 7.0 let c = [ - 0.99999999999980993, - 676.5203681218851, - -1259.1392167224028, - 771.32342877765313, - -176.61502916214059, - 12.507343278686905, - -0.13857109526572012, - 9.9843695780195716e-6, + 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, + -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7, ] let pi = 3.14159265358979323846 @@ -455,7 +469,11 @@ pub fn hmisc_varclus( names: var_names, } } - let cor_result = hmisc_rcorr(data, names=var_names, cor_type=HmiscCorType::HC_Pearson) + let cor_result = hmisc_rcorr( + data, + names=var_names, + cor_type=HmiscCorType::HC_Pearson, + ) let assignments = Array::make(n_vars, 0) let mut i = 0 while i < n_vars { @@ -533,7 +551,11 @@ fn hmisc_max_cluster_count(n_vars : Int, min_size : Int) -> Int { return 1 } let n_clusters = n_vars / min_size - if n_clusters < 1 { 1 } else { n_clusters } + if n_clusters < 1 { + 1 + } else { + n_clusters + } } ///| @@ -573,7 +595,11 @@ fn hmisc_cluster_similarity( } i = i + 1 } - if count > 0.0 { sum / count } else { 0.0 } + if count > 0.0 { + sum / count + } else { + 0.0 + } } ///| @@ -594,7 +620,10 @@ fn hmisc_unique_values(arr : Array[Int]) -> Array[Int] { ///| /// Compute Somers' d statistic for comparing two groups. -pub fn hmisc_somers_d(group1 : Array[Double], group2 : Array[Double]) -> HmiscSomersResult { +pub fn hmisc_somers_d( + group1 : Array[Double], + group2 : Array[Double], +) -> HmiscSomersResult { let n1 = group1.length() let n2 = group2.length() if n1 == 0 || n2 == 0 { @@ -621,11 +650,7 @@ pub fn hmisc_somers_d(group1 : Array[Double], group2 : Array[Double]) -> HmiscSo i = i + 1 } let total = (n1 * n2).to_double() - let d = if total > 0.0 { - (concordant - discordant) / total - } else { - 0.0 - } + let d = if total > 0.0 { (concordant - discordant) / total } else { 0.0 } let se = (4.0 * concordant * discordant / (total * total * total)).sqrt() HmiscSomersResult::{ d, @@ -691,7 +716,11 @@ fn hmisc_array_mean(data : Array[Double]) -> Double { } i = i + 1 } - if count > 0 { sum / count.to_double() } else { 0.0 } + if count > 0 { + sum / count.to_double() + } else { + 0.0 + } } ///| @@ -759,9 +788,13 @@ fn hmisc_fmt_dbl(value : Double, decimals : Int) -> String { if value.is_nan() { return " NA" } - let rounded = (value * @math.pow(10.0, decimals.to_double())).round() / @math.pow(10.0, decimals.to_double()) + let rounded = (value * @math.pow(10.0, decimals.to_double())).round() / + @math.pow(10.0, decimals.to_double()) let int_part = rounded.to_int() - let dec_part = ((rounded - int_part.to_double()) * @math.pow(10.0, decimals.to_double())).round().to_int() + let dec_part = ((rounded - int_part.to_double()) * + @math.pow(10.0, decimals.to_double())) + .round() + .to_int() if decimals == 0 { return "\{int_part}" } @@ -787,11 +820,17 @@ fn hmisc_pad_zeros(value : Int, length : Int) -> String { result + s } +///| /// Create a Pearson correlation type. -pub fn hmisc_cor_type_pearson() -> HmiscCorType { HmiscCorType::HC_Pearson } +pub fn hmisc_cor_type_pearson() -> HmiscCorType { + HmiscCorType::HC_Pearson +} +///| /// Create a Spearman correlation type. -pub fn hmisc_cor_type_spearman() -> HmiscCorType { HmiscCorType::HC_Spearman } +pub fn hmisc_cor_type_spearman() -> HmiscCorType { + HmiscCorType::HC_Spearman +} ///| /// Sample data for testing. diff --git a/src/hmmcopy.mbt b/src/hmmcopy.mbt index d8a2c306..aa18daf7 100644 --- a/src/hmmcopy.mbt +++ b/src/hmmcopy.mbt @@ -37,8 +37,8 @@ pub fn HMMcopyBin::new( start~ : Int, end~ : Int, reads~ : Int, - gc~ : Double = 0.5, - mappability~ : Double = 1.0, + gc? : Double = 0.5, + mappability? : Double = 1.0, ) -> HMMcopyBin { HMMcopyBin::{ chr, @@ -103,8 +103,8 @@ pub struct HMMcopyModel { /// Construct a new HMMcopyModel with default parameters. /// States: CN0, CN1, CN2, CN3, CN4, CN5, CN6 (7 states). pub fn HMMcopyModel::new( - num_states~ : Int = 7, - ploidy~ : Int = 2, + num_states? : Int = 7, + ploidy? : Int = 2, ) -> HMMcopyModel { // Default emission means: 0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0 (in CN2 units) let emissions = Array::make(num_states, 0.0) @@ -224,15 +224,7 @@ pub fn HMMcopySegment::new( num_bins~ : Int, mean_reads~ : Double, ) -> HMMcopySegment { - HMMcopySegment::{ - chr, - start, - end, - copy, - state, - num_bins, - mean_reads, - } + HMMcopySegment::{ chr, start, end, copy, state, num_bins, mean_reads } } // =========================================================================== @@ -244,7 +236,7 @@ pub fn HMMcopySegment::new( /// Bins are grouped by GC content and scaled to the global mean. pub fn hmmcopy_correct_gc( bins : Array[HMMcopyBin], - num_gc_bins~ : Int = 20, + num_gc_bins? : Int = 20, ) -> Array[HMMcopyBin] { let n = bins.length() if n == 0 { @@ -260,7 +252,13 @@ pub fn hmmcopy_correct_gc( let gc_bins = Array::make(num_gc_bins, Array::new()) for b in bins { let gc_idx = (b.gc * num_gc_bins.to_double()).to_int() - let clamped = if gc_idx < 0 { 0 } else if gc_idx >= num_gc_bins { num_gc_bins - 1 } else { gc_idx } + let clamped = if gc_idx < 0 { + 0 + } else if gc_idx >= num_gc_bins { + num_gc_bins - 1 + } else { + gc_idx + } gc_bins[clamped].push(b) } // Compute mean reads per GC bin @@ -323,8 +321,7 @@ fn hmmcopy_log_gaussian(x : Double, mean : Double, variance : Double) -> Double let diff = x - mean let log_2pi = 1.8378770664093453 let result = -0.5 * (log_2pi + @math.ln(variance)) - - diff * diff / - (2.0 * variance) + diff * diff / (2.0 * variance) result } @@ -453,9 +450,7 @@ pub fn hmmcopy_call_cnv( ///| /// Segment bins by merging consecutive bins with the same copy number. -pub fn hmmcopy_segment( - bins : Array[HMMcopyBin], -) -> Array[HMMcopySegment] { +pub fn hmmcopy_segment(bins : Array[HMMcopyBin]) -> Array[HMMcopySegment] { let segments = Array::new() let n = bins.length() if n == 0 { @@ -476,15 +471,17 @@ pub fn hmmcopy_segment( count = count + 1 j = j + 1 } - segments.push(HMMcopySegment::new( - chr=cur_chr, - start=start, - end=end, - copy=cur_copy, - state=bins[i].state, - num_bins=count, - mean_reads=sum_reads / count.to_double(), - )) + segments.push( + HMMcopySegment::new( + chr=cur_chr, + start~, + end~, + copy=cur_copy, + state=bins[i].state, + num_bins=count, + mean_reads=sum_reads / count.to_double(), + ), + ) i = j } segments @@ -588,21 +585,22 @@ pub fn hmmcopy_sample_bins() -> Array[HMMcopyBin] { while i < 100 { let reads = if i >= 10 && i < 20 { // CN0 region: very low reads - 2 + (i % 3) + 2 + i % 3 } else if i >= 60 && i < 70 { // CN3 region: elevated reads - 90 + (i % 10) + 90 + i % 10 } else { + 60 + // CN2 region: normal - 60 + (i % 10) + i % 10 } let gc = 0.4 + (i % 10).to_double() * 0.02 let bin = HMMcopyBin::new( chr="chr1", start=i * 100000, end=(i + 1) * 100000, - reads=reads, - gc=gc, + reads~, + gc~, mappability=0.95, ) bins.push(bin) diff --git a/src/hmmer_io.mbt b/src/hmmer_io.mbt index 80e0afbd..51e53a99 100644 --- a/src/hmmer_io.mbt +++ b/src/hmmer_io.mbt @@ -259,7 +259,14 @@ pub fn parse_hmmer3_domtab(content : String) -> Array[QueryResult] { ) let frags : Array[HSPFragment] = [frag] hsps.push( - HSP::new(tname, dh.description, frags, dh.score_dom, dh.i_evalue, dh.score_dom), + HSP::new( + tname, + dh.description, + frags, + dh.score_dom, + dh.i_evalue, + dh.score_dom, + ), ) tbs = tbs + dh.score_dom if dh.i_evalue < mev { @@ -386,12 +393,7 @@ pub fn parse_hmmer3_text(content : String) -> Array[QueryResult] { if cur_query_id.length() > 0 { results.push( QueryResult::new( - cur_query_id, - cur_query_desc, - cur_query_len, - cur_hits, - "hmmscan", - "3.0", + cur_query_id, cur_query_desc, cur_query_len, cur_hits, "hmmscan", "3.0", "", ), ) @@ -536,12 +538,7 @@ pub fn parse_hmmer3_text(content : String) -> Array[QueryResult] { if cur_query_id.length() > 0 { results.push( QueryResult::new( - cur_query_id, - cur_query_desc, - cur_query_len, - cur_hits, - "hmmscan", - "3.0", + cur_query_id, cur_query_desc, cur_query_len, cur_hits, "hmmscan", "3.0", "", ), ) @@ -619,41 +616,41 @@ fn hmmer_io_extract_double_after(s : String, marker : String) -> Double { /// Generate a small HMMER3 domtblout-format sample for tests and demos. pub fn hmmer3_domtab_sample() -> String { "# hmmsearch :: search profile(s) against a sequence database\n" + - "# HMMER 3.3.2 (Nov 2020)\n" + - "#\n" + - "# target name accession query name accession E-value score bias # of c-Evalue i-Evalue score bias from to from to exp reg clu ov env dom rep inc description of target\n" + - "#------------------- ---------- -------------------- ---------- --------- ------ ------ --- --- --------- --------- ------ ----- ----- ----- ----- ----- ----- ---- ---- ---- ---- ---- ---- ---- ---------------------\n" + - "sp|Q9Y2W8|A1BG_HUMAN Q9Y2W8 PF00001.28 PF00001 1.2e-50 200.3 5.1 1 1 1.2e-50 1.5e-53 200.3 5.1 1 150 1 150 1.0 1 0 0 1 1 1 1 Alpha-1-B glycoprotein\n" + - "sp|P12345|ABC_HUMAN P12345 PF00001.28 PF00001 3.4e-30 150.1 2.0 1 2 3.4e-30 4.0e-33 150.1 2.0 1 120 1 120 1.0 1 0 0 1 1 1 1 ABC transporter\n" + - "sp|P12345|ABC_HUMAN P12345 PF00001.28 PF00001 3.4e-30 150.1 2.0 2 2 5.0e-20 6.0e-23 100.5 1.0 1 90 1 90 1.0 1 0 0 1 1 1 1 ABC transporter C-term\n" + "# HMMER 3.3.2 (Nov 2020)\n" + + "#\n" + + "# target name accession query name accession E-value score bias # of c-Evalue i-Evalue score bias from to from to exp reg clu ov env dom rep inc description of target\n" + + "#------------------- ---------- -------------------- ---------- --------- ------ ------ --- --- --------- --------- ------ ----- ----- ----- ----- ----- ----- ---- ---- ---- ---- ---- ---- ---- ---------------------\n" + + "sp|Q9Y2W8|A1BG_HUMAN Q9Y2W8 PF00001.28 PF00001 1.2e-50 200.3 5.1 1 1 1.2e-50 1.5e-53 200.3 5.1 1 150 1 150 1.0 1 0 0 1 1 1 1 Alpha-1-B glycoprotein\n" + + "sp|P12345|ABC_HUMAN P12345 PF00001.28 PF00001 3.4e-30 150.1 2.0 1 2 3.4e-30 4.0e-33 150.1 2.0 1 120 1 120 1.0 1 0 0 1 1 1 1 ABC transporter\n" + + "sp|P12345|ABC_HUMAN P12345 PF00001.28 PF00001 3.4e-30 150.1 2.0 2 2 5.0e-20 6.0e-23 100.5 1.0 1 90 1 90 1.0 1 0 0 1 1 1 1 ABC transporter C-term\n" } ///| /// Generate a small HMMER3 text-format sample for tests and demos. pub fn hmmer3_text_sample() -> String { "# hmmsearch :: search profile(s) against a sequence database\n" + - "# HMMER 3.3.2 (Nov 2020)\n" + - "#\n" + - "Query: PF00001.28 7tm_1\n" + - "Query length: 150\n" + - "Scores for complete sequences (score includes all domains):\n" + - " E-value score bias E-value score bias exp N Domain Description\n" + - " ------- ------ ----- ------- ------ ----- ---- --- ------ -----------\n" + - "sp|Q9Y2W8|A1BG_HUMAN 1.2e-50 200.3 5.1 1.5e-53 200.3 5.1 1.0 1 1 Alpha-1-B glycoprotein\n" + - "sp|P12345|ABC_HUMAN 3.4e-30 150.1 2.0 4.0e-33 150.1 2.0 1.0 1 1 ABC transporter\n" + - "\n" + - "Domain annotation for each sequence (and alignments):\n" + - ">> sp|Q9Y2W8|A1BG_HUMAN Alpha-1-B glycoprotein\n" + - " # score bias c-Evalue i-Evalue hmmfrom hmm to alifrom ali to envfrom env to acc\n" + - " --- ------ ----- --------- --------- ------- ------- ------- ------- ------- ------- ----\n" + - " 1 200.3 5.1 1.2e-50 1.5e-53 1 150 1 150 1 150 0.90\n" + - " == domain 1 score: 200.3 bits; conditional E-value: 1.5e-53\n" + - "\n" + - ">> sp|P12345|ABC_HUMAN ABC transporter\n" + - " # score bias c-Evalue i-Evalue hmmfrom hmm to alifrom ali to envfrom env to acc\n" + - " --- ------ ----- --------- --------- ------- ------- ------- ------- ------- ------- ----\n" + - " 1 150.1 2.0 3.4e-30 4.0e-33 1 120 1 120 1 120 0.88\n" + - " == domain 1 score: 150.1 bits; conditional E-value: 4.0e-33\n" + "# HMMER 3.3.2 (Nov 2020)\n" + + "#\n" + + "Query: PF00001.28 7tm_1\n" + + "Query length: 150\n" + + "Scores for complete sequences (score includes all domains):\n" + + " E-value score bias E-value score bias exp N Domain Description\n" + + " ------- ------ ----- ------- ------ ----- ---- --- ------ -----------\n" + + "sp|Q9Y2W8|A1BG_HUMAN 1.2e-50 200.3 5.1 1.5e-53 200.3 5.1 1.0 1 1 Alpha-1-B glycoprotein\n" + + "sp|P12345|ABC_HUMAN 3.4e-30 150.1 2.0 4.0e-33 150.1 2.0 1.0 1 1 ABC transporter\n" + + "\n" + + "Domain annotation for each sequence (and alignments):\n" + + ">> sp|Q9Y2W8|A1BG_HUMAN Alpha-1-B glycoprotein\n" + + " # score bias c-Evalue i-Evalue hmmfrom hmm to alifrom ali to envfrom env to acc\n" + + " --- ------ ----- --------- --------- ------- ------- ------- ------- ------- ------- ----\n" + + " 1 200.3 5.1 1.2e-50 1.5e-53 1 150 1 150 1 150 0.90\n" + + " == domain 1 score: 200.3 bits; conditional E-value: 1.5e-53\n" + + "\n" + + ">> sp|P12345|ABC_HUMAN ABC transporter\n" + + " # score bias c-Evalue i-Evalue hmmfrom hmm to alifrom ali to envfrom env to acc\n" + + " --- ------ ----- --------- --------- ------- ------- ------- ------- ------- ------- ----\n" + + " 1 150.1 2.0 3.4e-30 4.0e-33 1 120 1 120 1 120 0.88\n" + + " == domain 1 score: 150.1 bits; conditional E-value: 4.0e-33\n" } ///| diff --git a/src/hs_exposure.mbt b/src/hs_exposure.mbt index dd43cc00..5846c551 100644 --- a/src/hs_exposure.mbt +++ b/src/hs_exposure.mbt @@ -29,7 +29,12 @@ pub struct PDBAtom { } ///| -pub fn PDBAtom::new(name : String, x : Double, y : Double, z : Double) -> PDBAtom { +pub fn PDBAtom::new( + name : String, + x : Double, + y : Double, + z : Double, +) -> PDBAtom { PDBAtom::{ name, x, y, z } } @@ -42,7 +47,12 @@ pub struct HSExposureResult { } ///| -pub fn HSExposureResult::new(residue_name : String, hse_up : Double, hse_down : Double, hse_total : Double) -> HSExposureResult { +pub fn HSExposureResult::new( + residue_name : String, + hse_up : Double, + hse_down : Double, + hse_total : Double, +) -> HSExposureResult { HSExposureResult::{ residue_name, hse_up, hse_down, hse_total } } @@ -51,74 +61,84 @@ fn atom_distance(a1 : PDBAtom, a2 : PDBAtom) -> Double { let dx = a1.x - a2.x let dy = a1.y - a2.y let dz = a1.z - a2.z - + hse_sqrt(dx * dx + dy * dy + dz * dz) } ///| -pub fn calculate_hse(ca_atom : PDBAtom, cb_atom : PDBAtom, n_atom : PDBAtom, all_ca_atoms : Array[PDBAtom]) -> HSExposureResult { +pub fn calculate_hse( + ca_atom : PDBAtom, + cb_atom : PDBAtom, + n_atom : PDBAtom, + all_ca_atoms : Array[PDBAtom], +) -> HSExposureResult { let mut hse_up = 0 let mut hse_down = 0 - + let mut i = 0 while i < all_ca_atoms.length() { let other_ca = all_ca_atoms[i] - + if other_ca.name == ca_atom.name { i = i + 1 continue } - + let dist = atom_distance(ca_atom, other_ca) - + if dist <= 10.0 && dist > 0.0 { let dx = other_ca.x - ca_atom.x let dy = other_ca.y - ca_atom.y let dz = other_ca.z - ca_atom.z - + let cb_dx = cb_atom.x - ca_atom.x let cb_dy = cb_atom.y - ca_atom.y let cb_dz = cb_atom.z - ca_atom.z - + let n_dx = n_atom.x - ca_atom.x let n_dy = n_atom.y - ca_atom.y let n_dz = n_atom.z - ca_atom.z - + let nx = cb_dy * n_dz - cb_dz * n_dy let ny = cb_dz * n_dx - cb_dx * n_dz let nz = cb_dx * n_dy - cb_dy * n_dx - + let dot = dx * nx + dy * ny + dz * nz - + if dot > 0.0 { hse_up = hse_up + 1 } else if dot < 0.0 { hse_down = hse_down + 1 } } - + i = i + 1 } - - HSExposureResult::new(ca_atom.name, hse_up.to_double(), hse_down.to_double(), (hse_up + hse_down).to_double()) + + HSExposureResult::new( + ca_atom.name, + hse_up.to_double(), + hse_down.to_double(), + (hse_up + hse_down).to_double(), + ) } ///| pub fn create_example_atoms() -> Array[PDBAtom] { let atoms : Array[PDBAtom] = Array::new() - + atoms.push(PDBAtom::new("CA1", 0.0, 0.0, 0.0)) atoms.push(PDBAtom::new("CB1", 1.5, 0.0, 0.0)) atoms.push(PDBAtom::new("N1", 0.0, 1.5, 0.0)) - + atoms.push(PDBAtom::new("CA2", 3.0, 0.0, 0.0)) atoms.push(PDBAtom::new("CB2", 4.5, 0.0, 0.0)) atoms.push(PDBAtom::new("N2", 3.0, 1.5, 0.0)) - + atoms.push(PDBAtom::new("CA3", 0.0, 3.0, 0.0)) atoms.push(PDBAtom::new("CB3", 1.5, 3.0, 0.0)) atoms.push(PDBAtom::new("N3", 0.0, 4.5, 0.0)) - + atoms } @@ -131,4 +151,4 @@ pub fn classify_exposure(hse_total : Double) -> String { } else { "exposed" } -} \ No newline at end of file +} diff --git a/src/htsfilter.mbt b/src/htsfilter.mbt index 5fc151ce..d7e68fc0 100644 --- a/src/htsfilter.mbt +++ b/src/htsfilter.mbt @@ -23,7 +23,10 @@ pub struct HTSFilterResult { /// Compute CPM (Counts Per Million) matrix from raw counts and library sizes. /// counts: genes × samples /// Returns: genes × samples CPM values -pub fn hts_filter_cpm(counts : Array[Array[Double]], library_sizes : Array[Double]) -> Array[Array[Double]] { +pub fn hts_filter_cpm( + counts : Array[Array[Double]], + library_sizes : Array[Double], +) -> Array[Array[Double]] { let n_genes = counts.length() if n_genes == 0 { return [] @@ -93,9 +96,9 @@ pub fn hts_filter( let n_genes = counts.length() if n_genes == 0 { return HTSFilterResult::{ - cpm_threshold: cpm_threshold, - min_samples_per_group: min_samples_per_group, - groups: groups, + cpm_threshold, + min_samples_per_group, + groups, cpm_matrix: [], keep: [], n_genes_input: 0, @@ -115,10 +118,15 @@ pub fn hts_filter( let mut found = false let mut j = 0 while j < unique_groups.length() { - if unique_groups[j] == g { found = true; break } + if unique_groups[j] == g { + found = true + break + } j = j + 1 } - if !found { unique_groups.push(g) } + if !found { + unique_groups.push(g) + } i = i + 1 } @@ -145,16 +153,18 @@ pub fn hts_filter( ug = ug + 1 } keep.push(gene_kept) - if gene_kept { kept = kept + 1 } + if gene_kept { + kept = kept + 1 + } g = g + 1 } HTSFilterResult::{ - cpm_threshold: cpm_threshold, - min_samples_per_group: min_samples_per_group, - groups: groups, + cpm_threshold, + min_samples_per_group, + groups, cpm_matrix: cpm_mat, - keep: keep, + keep, n_genes_input: n_genes, n_genes_kept: kept, n_genes_removed: n_genes - kept, @@ -164,7 +174,10 @@ pub fn hts_filter( ///| /// Apply a keep mask to filter a count matrix. /// Returns only the rows (genes) where keep[i] is true. -pub fn hts_filter_apply(counts : Array[Array[Double]], keep : Array[Bool]) -> Array[Array[Double]] { +pub fn hts_filter_apply( + counts : Array[Array[Double]], + keep : Array[Bool], +) -> Array[Array[Double]] { let result : Array[Array[Double]] = [] let mut i = 0 while i < counts.length() { @@ -178,7 +191,10 @@ pub fn hts_filter_apply(counts : Array[Array[Double]], keep : Array[Bool]) -> Ar ///| /// Apply keep mask to a gene name list. -pub fn hts_filter_apply_names(gene_names : Array[String], keep : Array[Bool]) -> Array[String] { +pub fn hts_filter_apply_names( + gene_names : Array[String], + keep : Array[Bool], +) -> Array[String] { let result : Array[String] = [] let mut i = 0 while i < gene_names.length() { @@ -194,21 +210,38 @@ pub fn hts_filter_apply_names(gene_names : Array[String], keep : Array[Bool]) -> /// Summarize the filtering result as a string. pub fn hts_filter_summary(result : HTSFilterResult) -> String { "HTSFilter Summary:\n" + - " CPM threshold: " + result.cpm_threshold.to_string() + "\n" + - " Min samples per group: " + result.min_samples_per_group.to_string() + "\n" + - " Input genes: " + result.n_genes_input.to_string() + "\n" + - " Genes kept: " + result.n_genes_kept.to_string() + "\n" + - " Genes removed: " + result.n_genes_removed.to_string() + "\n" + - " Retention rate: " + - (if result.n_genes_input > 0 { - (result.n_genes_kept.to_double() / result.n_genes_input.to_double() * 100.0).to_string() - } else { "0.0" }) + "%" + " CPM threshold: " + + result.cpm_threshold.to_string() + + "\n" + + " Min samples per group: " + + result.min_samples_per_group.to_string() + + "\n" + + " Input genes: " + + result.n_genes_input.to_string() + + "\n" + + " Genes kept: " + + result.n_genes_kept.to_string() + + "\n" + + " Genes removed: " + + result.n_genes_removed.to_string() + + "\n" + + " Retention rate: " + + (if result.n_genes_input > 0 { + (result.n_genes_kept.to_double() / result.n_genes_input.to_double() * 100.0).to_string() + } else { + "0.0" + }) + + "%" } ///| /// Generate sample RNA-seq count data for testing. /// Returns tuple of (counts, groups, gene_names). -pub fn hts_filter_sample_data() -> (Array[Array[Double]], Array[Int], Array[String]) { +pub fn hts_filter_sample_data() -> ( + Array[Array[Double]], + Array[Int], + Array[String], +) { // 20 genes x 6 samples (3 control + 3 treatment) let n_genes = 20 let n_samples = 6 @@ -225,7 +258,7 @@ pub fn hts_filter_sample_data() -> (Array[Array[Double]], Array[Int], Array[Stri // Next 5 genes: moderate expression (~50-200 CPM) // Last 5 genes: low expression (~1-10 CPM) let base = if g < 10 { 2000.0 } else if g < 15 { 100.0 } else { 5.0 } - let noise = (((g * 7 + s * 13) % 100).to_double() / 100.0) * base * 0.5 + let noise = ((g * 7 + s * 13) % 100).to_double() / 100.0 * base * 0.5 let val = base + noise row.push(val) s = s + 1 diff --git a/src/ig_io.mbt b/src/ig_io.mbt index 494d4606..abecc961 100644 --- a/src/ig_io.mbt +++ b/src/ig_io.mbt @@ -37,7 +37,7 @@ pub struct IgRecord { pub fn IgRecord::new( title : String, comment : String, - sequence : String + sequence : String, ) -> IgRecord { IgRecord::{ title, comment, sequence } } @@ -136,7 +136,7 @@ fn ig_starts_with2(line : String, c1 : UInt16, c2 : UInt16) -> Bool { fn ig_strip_cr(line : String) -> String { let n = line.length() if n > 0 && line.unsafe_get(n - 1) == ig_char_code('\r') { - line[0 : n - 1].to_owned() + line[0:n - 1].to_owned() } else { line } @@ -171,7 +171,7 @@ fn ig_strip(s : String) -> String { if start == 0 && end == n { s } else { - s[start : end].to_owned() + s[start:end].to_owned() } } @@ -293,7 +293,7 @@ pub fn ig_parse(content : String) -> Array[IgRecord] { // Strip an optional trailing "1" terminator. let sn = seq_str.length() if sn > 0 && seq_str.unsafe_get(sn - 1) == one { - seq_str = seq_str[0 : sn - 1].to_owned() + seq_str = seq_str[0:sn - 1].to_owned() } let comment = ig_join_lines(comment_parts) records.push(IgRecord::new(title, comment, seq_str)) @@ -349,10 +349,7 @@ pub fn ig_record_to_string(record : IgRecord) -> String { ///| /// Render an `IgRecord` with a custom sequence line width. A width <= 0 /// disables wrapping (the sequence is emitted on a single line). -pub fn ig_record_to_string_width( - record : IgRecord, - width : Int -) -> String { +pub fn ig_record_to_string_width(record : IgRecord, width : Int) -> String { let buf = StringBuilder::new() // Comment lines. if record.comment.length() > 0 { @@ -385,7 +382,7 @@ pub fn ig_record_to_string_width( let mut i = 0 while i < n { let end = if i + width < n { i + width } else { n } - buf.write_string(seq[i : end].to_owned()) + buf.write_string(seq[i:end].to_owned()) buf.write_char('\n') i = end } @@ -403,7 +400,7 @@ pub fn ig_record_to_string_width( /// does not already start with one. pub fn ig_records_to_string( records : Array[IgRecord], - file_header : Array[String]? + file_header : Array[String]?, ) -> String { let buf = StringBuilder::new() // Optional file header. @@ -517,9 +514,7 @@ pub fn ig_sample_file_header() -> Array[String] { /// Build a sample `IgRecord` for testing. pub fn ig_sample_record() -> IgRecord { IgRecord::new( - "A_U455", - "HIV-1 group M subtype A", - "ATGGCAGCTGTGATGAAGCAGAGACGGGTAAGAGCTC", + "A_U455", "HIV-1 group M subtype A", "ATGGCAGCTGTGATGAAGCAGAGACGGGTAAGAGCTC", ) } @@ -527,8 +522,6 @@ pub fn ig_sample_record() -> IgRecord { /// Build a second sample `IgRecord` for testing. pub fn ig_sample_record_2() -> IgRecord { IgRecord::new( - "B_HXB2R", - "HIV-1 group M subtype B", - "ATGGGTGCTGTGATGAAGCAGAGACGGGTAAGAGCTC", + "B_HXB2R", "HIV-1 group M subtype B", "ATGGGTGCTGTGATGAAGCAGAGACGGGTAAGAGCTC", ) } diff --git a/src/ihw.mbt b/src/ihw.mbt index 77bbacb8..2e8ab724 100644 --- a/src/ihw.mbt +++ b/src/ihw.mbt @@ -156,7 +156,11 @@ fn ihw_storey_pi0( let weight = if i < covariates.length() { let c = covariates[i] let w = 1.0 - (c - 0.5) * (c - 0.5) * 2.0 - if w < 0.1 { 0.1 } else { w } + if w < 0.1 { + 0.1 + } else { + w + } } else { 1.0 } @@ -170,7 +174,11 @@ fn ihw_storey_pi0( return 1.0 } let pi0 = count / ((1.0 - lambda) * total_weight) - if pi0 > 1.0 { 1.0 } else { pi0 } + if pi0 > 1.0 { + 1.0 + } else { + pi0 + } } ///| @@ -243,10 +251,7 @@ fn ihw_sum_weights(weights : Array[Double]) -> Double { ///| /// Assign hypotheses to bins based on covariate quantiles. /// Returns bin indices (0 to n_bins-1) for each hypothesis. -fn bin_covariates( - covariates : Array[Double], - n_bins : Int, -) -> Array[Int] { +fn bin_covariates(covariates : Array[Double], n_bins : Int) -> Array[Int] { let n = covariates.length() let result : Array[Int] = Array::make(n, 0) if n <= n_bins || n_bins <= 1 { @@ -258,8 +263,14 @@ fn bin_covariates( indexed[i] = [covariates[i], i.to_double()] i = i + 1 } - indexed.sort_by(fn(a: Array[Double], b: Array[Double]) -> Int { - if a[0] < b[0] { -1 } else if a[0] > b[0] { 1 } else { 0 } + indexed.sort_by(fn(a : Array[Double], b : Array[Double]) -> Int { + if a[0] < b[0] { + -1 + } else if a[0] > b[0] { + 1 + } else { + 0 + } }) let bin_size = (n.to_double() / n_bins.to_double()).ceil().to_int() i = 0 @@ -387,7 +398,7 @@ pub fn ihw( covariates : Array[Double], alpha : Double, ) -> IHWResult { - let config = IHWConfig::new(alpha=alpha, n_attempts=10, scale_type="local") + let config = IHWConfig::new(alpha~, n_attempts=10, scale_type="local") ihw_with_config(p_values, covariates, config) } @@ -411,17 +422,18 @@ pub fn ihw_with_config( let effective_n = if n < n_cov { n } else { n_cov } if effective_n == 0 { - return IHWResult::new( - [], - [], - [], - [], - config.alpha, - 0, - ) + return IHWResult::new([], [], [], [], config.alpha, 0) } - let n_bins = if effective_n > 20 { 20 } else { if effective_n > 10 { 10 } else { if effective_n > 5 { 5 } else { 1 } } } + let n_bins = if effective_n > 20 { + 20 + } else if effective_n > 10 { + 10 + } else if effective_n > 5 { + 5 + } else { + 1 + } let mut weights = initialize_weights(covariates, config.scale_type) let bins = bin_covariates(covariates, n_bins) @@ -623,8 +635,14 @@ pub fn storey_ihw( temp[i] = [p_values[i], i.to_double()] i = i + 1 } - temp.sort_by(fn(a: Array[Double], b: Array[Double]) -> Int { - if a[0] < b[0] { -1 } else if a[0] > b[0] { 1 } else { 0 } + temp.sort_by(fn(a : Array[Double], b : Array[Double]) -> Int { + if a[0] < b[0] { + -1 + } else if a[0] > b[0] { + 1 + } else { + 0 + } }) i = n - 1 @@ -651,4 +669,4 @@ pub fn storey_ihw( /// Array of weights used in the correction pub fn ihw_weights(result : IHWResult) -> Array[Double] { result.weights -} \ No newline at end of file +} diff --git a/src/imgt_io.mbt b/src/imgt_io.mbt index c9ad4d07..c80558c1 100644 --- a/src/imgt_io.mbt +++ b/src/imgt_io.mbt @@ -308,23 +308,21 @@ pub fn imgt_parse_header(line : String) -> ImgtHeader? { let sl = imgt_field_or_empty(fields, count, 10) let st = imgt_field_or_empty(fields, count, 11) let cm = imgt_field_or_empty(fields, count, 12) - Some( - ImgtHeader::{ - accession: acc, - seq_id: sid, - official_name: on, - region: reg, - date_update: du, - date_creation: dc, - species: sp, - gene: gn, - imgt_group: ig, - locus: lo, - seq_length: sl, - seq_type: st, - comments: cm, - }, - ) + Some(ImgtHeader::{ + accession: acc, + seq_id: sid, + official_name: on, + region: reg, + date_update: du, + date_creation: dc, + species: sp, + gene: gn, + imgt_group: ig, + locus: lo, + seq_length: sl, + seq_type: st, + comments: cm, + }) } ///| @@ -362,7 +360,10 @@ pub fn imgt_parse(content : String) -> Array[ImgtRecord] { if line.unsafe_get(0) == gt { match current_header { Some(h) => - records.push(ImgtRecord::{ header: h, sequence: current_seq.to_string() }) + records.push(ImgtRecord::{ + header: h, + sequence: current_seq.to_string(), + }) None => () } match imgt_parse_header(line[0:trimmed_len].to_owned()) { @@ -621,68 +622,62 @@ pub fn imgt_from_seq_records(records : Array[SeqRecord]) -> Array[ImgtRecord] { pub fn imgt_sample_records() -> Array[ImgtRecord] { let out = Array::new() // HLA-A*01:01:01:01 (human) - out.push( - ImgtRecord::{ - header: ImgtHeader::{ - accession: "HLA00001", - seq_id: "A*01:01:01:01", - official_name: "A*01:01:01:01", - region: "ORF", - date_update: "2015-03-31", - date_creation: "1996-01-19", - species: "human", - gene: "HLA-A", - imgt_group: "I", - locus: "MHC", - seq_length: "2703 bp", - seq_type: " genomic-DNA", - comments: "", - }, - sequence: "ATGGCCGTCATGGCGCCCCGAACCCTCCTCCTC", + out.push(ImgtRecord::{ + header: ImgtHeader::{ + accession: "HLA00001", + seq_id: "A*01:01:01:01", + official_name: "A*01:01:01:01", + region: "ORF", + date_update: "2015-03-31", + date_creation: "1996-01-19", + species: "human", + gene: "HLA-A", + imgt_group: "I", + locus: "MHC", + seq_length: "2703 bp", + seq_type: " genomic-DNA", + comments: "", }, - ) + sequence: "ATGGCCGTCATGGCGCCCCGAACCCTCCTCCTC", + }) // HLA-A*02:01:01:01 (human) - out.push( - ImgtRecord::{ - header: ImgtHeader::{ - accession: "HLA00002", - seq_id: "A*02:01:01:01", - official_name: "A*02:01:01:01", - region: "ORF", - date_update: "2016-05-12", - date_creation: "1996-01-19", - species: "human", - gene: "HLA-A", - imgt_group: "I", - locus: "MHC", - seq_length: "2709 bp", - seq_type: " genomic-DNA", - comments: "", - }, - sequence: "ATGGCCGTCATGGCGCCCCGAACCCTCCTCCTG", + out.push(ImgtRecord::{ + header: ImgtHeader::{ + accession: "HLA00002", + seq_id: "A*02:01:01:01", + official_name: "A*02:01:01:01", + region: "ORF", + date_update: "2016-05-12", + date_creation: "1996-01-19", + species: "human", + gene: "HLA-A", + imgt_group: "I", + locus: "MHC", + seq_length: "2709 bp", + seq_type: " genomic-DNA", + comments: "", }, - ) + sequence: "ATGGCCGTCATGGCGCCCCGAACCCTCCTCCTG", + }) // HLA-B*07:02:01 (human) - out.push( - ImgtRecord::{ - header: ImgtHeader::{ - accession: "HLA00003", - seq_id: "B*07:02:01", - official_name: "B*07:02:01", - region: "ORF", - date_update: "2017-07-18", - date_creation: "1996-01-19", - species: "human", - gene: "HLA-B", - imgt_group: "I", - locus: "MHC", - seq_length: "2711 bp", - seq_type: " genomic-DNA", - comments: "", - }, - sequence: "ATGGCGCCCCGAACCCTCCTCCTGCTGCTCTC", + out.push(ImgtRecord::{ + header: ImgtHeader::{ + accession: "HLA00003", + seq_id: "B*07:02:01", + official_name: "B*07:02:01", + region: "ORF", + date_update: "2017-07-18", + date_creation: "1996-01-19", + species: "human", + gene: "HLA-B", + imgt_group: "I", + locus: "MHC", + seq_length: "2711 bp", + seq_type: " genomic-DNA", + comments: "", }, - ) + sequence: "ATGGCGCCCCGAACCCTCCTCCTGCTGCTCTC", + }) out } diff --git a/src/impute.mbt b/src/impute.mbt index c2b9bb86..8ab0f079 100644 --- a/src/impute.mbt +++ b/src/impute.mbt @@ -19,12 +19,18 @@ /// * apply_value_clamp - Post-impute min/max clamping to preserve physiological range // ---- utility: MoonBit does not expose a Double::INFINITY constant in core ---- -fn impute_infinity() -> Double { 1.7976931348623157e+308 } +fn impute_infinity() -> Double { + 1.7976931348623157e+308 +} -fn impute_is_na(x : Double) -> Bool { x.is_nan() } +///| +fn impute_is_na(x : Double) -> Bool { + x.is_nan() +} // ---- struct definitions ----------------------------------------------------- +///| pub struct ImputeNAStats { total_rows : Int total_cols : Int @@ -36,26 +42,38 @@ pub struct ImputeNAStats { col_na_counts : Array[Int] } +///| pub struct KNNImputeParam { pub mut k : Int pub by_row : Bool pub eps : Double - pub max_value : Option[Double] - pub min_value : Option[Double] + pub max_value : Double? + pub min_value : Double? } +///| pub fn KNNImputeParam::new() -> KNNImputeParam { - KNNImputeParam::{ k: 10, by_row: true, eps: 0.000001, max_value: None, min_value: None, } + KNNImputeParam::{ + k: 10, + by_row: true, + eps: 0.000001, + max_value: None, + min_value: None, + } } +///| pub fn KNNImputeParam::with_k(k : Int) -> KNNImputeParam { let p = KNNImputeParam::new() - if k >= 1 { p.k = k } + if k >= 1 { + p.k = k + } p } // ---- generic helpers -------------------------------------------------------- +///| fn impute_copy_matrix(mat : Array[Array[Double]]) -> Array[Array[Double]] { let n = mat.length() let out : Array[Array[Double]] = Array::new() @@ -71,8 +89,11 @@ fn impute_copy_matrix(mat : Array[Array[Double]]) -> Array[Array[Double]] { out } +///| fn impute_transpose(mat : Array[Array[Double]]) -> Array[Array[Double]] { - if mat.length() == 0 { return Array::new() } + if mat.length() == 0 { + return Array::new() + } let rows = mat.length() let cols = mat[0].length() let out : Array[Array[Double]] = Array::new() @@ -86,6 +107,7 @@ fn impute_transpose(mat : Array[Array[Double]]) -> Array[Array[Double]] { out } +///| /// Mark which positions are missing (NA). True => NA. pub fn make_na_mask(mat : Array[Array[Double]]) -> Array[Array[Bool]] { let out : Array[Array[Bool]] = Array::new() @@ -99,6 +121,7 @@ pub fn make_na_mask(mat : Array[Array[Double]]) -> Array[Array[Bool]] { out } +///| /// Compute summary of missing data. pub fn impute_na_stats(mat : Array[Array[Double]]) -> ImputeNAStats { let rows = mat.length() @@ -117,17 +140,17 @@ pub fn impute_na_stats(mat : Array[Array[Double]]) -> ImputeNAStats { } } row_counts.push(rc) - if rc > 0 { r_na = r_na + 1 } + if rc > 0 { + r_na = r_na + 1 + } } let mut c_na = 0 for j = 0; j < cols; j = j + 1 { - if col_counts[j] > 0 { c_na = c_na + 1 } - } - let denom = if rows * cols == 0 { - 1.0 - } else { - (rows * cols).to_double() + if col_counts[j] > 0 { + c_na = c_na + 1 + } } + let denom = if rows * cols == 0 { 1.0 } else { (rows * cols).to_double() } ImputeNAStats::{ total_rows: rows, total_cols: cols, @@ -140,16 +163,24 @@ pub fn impute_na_stats(mat : Array[Array[Double]]) -> ImputeNAStats { } } +///| pub fn impute_na_summary(stats : ImputeNAStats) -> String { let buf = StringBuilder::new() - buf.write_string("ImputeNAStats [\{stats.total_rows} x \{stats.total_cols}]\n") + buf.write_string( + "ImputeNAStats [\{stats.total_rows} x \{stats.total_cols}]\n", + ) let pct = stats.na_fraction * 100.0 buf.write_string(" total NAs: \{stats.total_na} (\{pct}%)\n") - buf.write_string(" rows with NA: \{stats.rows_with_na} / \{stats.total_rows}\n") - buf.write_string(" cols with NA: \{stats.cols_with_na} / \{stats.total_cols}\n") + buf.write_string( + " rows with NA: \{stats.rows_with_na} / \{stats.total_rows}\n", + ) + buf.write_string( + " cols with NA: \{stats.cols_with_na} / \{stats.total_cols}\n", + ) buf.to_string() } +///| fn impute_mean_clean(arr : Array[Double]) -> Double { let mut s = 0.0 let mut c = 0 @@ -159,19 +190,34 @@ fn impute_mean_clean(arr : Array[Double]) -> Double { c = c + 1 } } - if c == 0 { 0.0 } else { s / c.to_double() } + if c == 0 { + 0.0 + } else { + s / c.to_double() + } } +///| fn impute_median_clean(arr : Array[Double]) -> Double { let clean : Array[Double] = Array::new() for x in arr { - if !impute_is_na(x) { clean.push(x) } + if !impute_is_na(x) { + clean.push(x) + } } clean.sort_by(fn(a : Double, b : Double) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) let n = clean.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mid = n / 2 if n % 2 == 0 { (clean[mid - 1] + clean[mid]) / 2.0 @@ -180,14 +226,22 @@ fn impute_median_clean(arr : Array[Double]) -> Double { } } +///| fn impute_min_clean(arr : Array[Double]) -> Double { let mut m = impute_infinity() for x in arr { - if !impute_is_na(x) && x < m { m = x } + if !impute_is_na(x) && x < m { + m = x + } + } + if impute_is_na(m) || m == impute_infinity() { + 0.0 + } else { + m } - if impute_is_na(m) || m == impute_infinity() { 0.0 } else { m } } +///| fn clamp_value(v : Double, p : KNNImputeParam) -> Double { let mut out = v match p.max_value { @@ -203,115 +257,152 @@ fn clamp_value(v : Double, p : KNNImputeParam) -> Double { // ---- simple column-wise imputers ------------------------------------------- +///| pub fn impute_na_by_mean(mat : Array[Array[Double]]) -> Array[Array[Double]] { impute_by_col_mean(mat) } +///| pub fn impute_na_by_median(mat : Array[Array[Double]]) -> Array[Array[Double]] { impute_by_col_median(mat) } +///| pub fn impute_na_by_min(mat : Array[Array[Double]]) -> Array[Array[Double]] { impute_by_col_min(mat) } +///| pub fn impute_na_by_zero(mat : Array[Array[Double]]) -> Array[Array[Double]] { let out = impute_copy_matrix(mat) for i = 0; i < out.length(); i = i + 1 { for j = 0; j < out[i].length(); j = j + 1 { - if impute_is_na(out[i][j]) { out[i][j] = 0.0 } + if impute_is_na(out[i][j]) { + out[i][j] = 0.0 + } } } out } +///| pub fn impute_by_row_mean(mat : Array[Array[Double]]) -> Array[Array[Double]] { let out = impute_copy_matrix(mat) for i = 0; i < out.length(); i = i + 1 { let mu = impute_mean_clean(out[i]) for j = 0; j < out[i].length(); j = j + 1 { - if impute_is_na(out[i][j]) { out[i][j] = mu } + if impute_is_na(out[i][j]) { + out[i][j] = mu + } } } out } +///| pub fn impute_by_col_mean(mat : Array[Array[Double]]) -> Array[Array[Double]] { - if mat.length() == 0 { return Array::new() } + if mat.length() == 0 { + return Array::new() + } let cols = mat[0].length() let means : Array[Double] = Array::new() for j = 0; j < cols; j = j + 1 { let c : Array[Double] = Array::new() - for i = 0; i < mat.length(); i = i + 1 { c.push(mat[i][j]) } + for i = 0; i < mat.length(); i = i + 1 { + c.push(mat[i][j]) + } means.push(impute_mean_clean(c)) } let out = impute_copy_matrix(mat) for i = 0; i < out.length(); i = i + 1 { for j = 0; j < cols; j = j + 1 { - if impute_is_na(out[i][j]) { out[i][j] = means[j] } + if impute_is_na(out[i][j]) { + out[i][j] = means[j] + } } } out } +///| pub fn impute_by_row_median(mat : Array[Array[Double]]) -> Array[Array[Double]] { let out = impute_copy_matrix(mat) for i = 0; i < out.length(); i = i + 1 { let med = impute_median_clean(out[i]) for j = 0; j < out[i].length(); j = j + 1 { - if impute_is_na(out[i][j]) { out[i][j] = med } + if impute_is_na(out[i][j]) { + out[i][j] = med + } } } out } +///| pub fn impute_by_col_median(mat : Array[Array[Double]]) -> Array[Array[Double]] { - if mat.length() == 0 { return Array::new() } + if mat.length() == 0 { + return Array::new() + } let cols = mat[0].length() let meds : Array[Double] = Array::new() for j = 0; j < cols; j = j + 1 { let c : Array[Double] = Array::new() - for i = 0; i < mat.length(); i = i + 1 { c.push(mat[i][j]) } + for i = 0; i < mat.length(); i = i + 1 { + c.push(mat[i][j]) + } meds.push(impute_median_clean(c)) } let out = impute_copy_matrix(mat) for i = 0; i < out.length(); i = i + 1 { for j = 0; j < cols; j = j + 1 { - if impute_is_na(out[i][j]) { out[i][j] = meds[j] } + if impute_is_na(out[i][j]) { + out[i][j] = meds[j] + } } } out } +///| pub fn impute_by_row_min(mat : Array[Array[Double]]) -> Array[Array[Double]] { let out = impute_copy_matrix(mat) for i = 0; i < out.length(); i = i + 1 { let mn = impute_min_clean(out[i]) for j = 0; j < out[i].length(); j = j + 1 { - if impute_is_na(out[i][j]) { out[i][j] = mn } + if impute_is_na(out[i][j]) { + out[i][j] = mn + } } } out } +///| pub fn impute_by_col_min(mat : Array[Array[Double]]) -> Array[Array[Double]] { - if mat.length() == 0 { return Array::new() } + if mat.length() == 0 { + return Array::new() + } let cols = mat[0].length() let mins : Array[Double] = Array::new() for j = 0; j < cols; j = j + 1 { let c : Array[Double] = Array::new() - for i = 0; i < mat.length(); i = i + 1 { c.push(mat[i][j]) } + for i = 0; i < mat.length(); i = i + 1 { + c.push(mat[i][j]) + } mins.push(impute_min_clean(c)) } let out = impute_copy_matrix(mat) for i = 0; i < out.length(); i = i + 1 { for j = 0; j < cols; j = j + 1 { - if impute_is_na(out[i][j]) { out[i][j] = mins[j] } + if impute_is_na(out[i][j]) { + out[i][j] = mins[j] + } } } out } +///| pub fn apply_value_clamp( mat : Array[Array[Double]], min_v : Double, @@ -320,9 +411,15 @@ pub fn apply_value_clamp( let out = impute_copy_matrix(mat) for i = 0; i < out.length(); i = i + 1 { for j = 0; j < out[i].length(); j = j + 1 { - if impute_is_na(out[i][j]) { continue } - if out[i][j] < min_v { out[i][j] = min_v } - if out[i][j] > max_v { out[i][j] = max_v } + if impute_is_na(out[i][j]) { + continue + } + if out[i][j] < min_v { + out[i][j] = min_v + } + if out[i][j] > max_v { + out[i][j] = max_v + } } } out @@ -330,7 +427,11 @@ pub fn apply_value_clamp( // ---- LOCF / NOCB ------------------------------------------------------------ -pub fn impute_locf(mat : Array[Array[Double]], by_row? : Bool = true) -> Array[Array[Double]] { +///| +pub fn impute_locf( + mat : Array[Array[Double]], + by_row? : Bool = true, +) -> Array[Array[Double]] { let base = if by_row { impute_copy_matrix(mat) } else { @@ -340,16 +441,26 @@ pub fn impute_locf(mat : Array[Array[Double]], by_row? : Bool = true) -> Array[A let mut last = 0.0 / 0.0 // NaN for j = 0; j < base[i].length(); j = j + 1 { if impute_is_na(base[i][j]) { - if !impute_is_na(last) { base[i][j] = last } + if !impute_is_na(last) { + base[i][j] = last + } } else { last = base[i][j] } } } - if by_row { base } else { impute_transpose(base) } + if by_row { + base + } else { + impute_transpose(base) + } } -pub fn impute_nocb(mat : Array[Array[Double]], by_row? : Bool = true) -> Array[Array[Double]] { +///| +pub fn impute_nocb( + mat : Array[Array[Double]], + by_row? : Bool = true, +) -> Array[Array[Double]] { let base = if by_row { impute_copy_matrix(mat) } else { @@ -362,19 +473,27 @@ pub fn impute_nocb(mat : Array[Array[Double]], by_row? : Bool = true) -> Array[A for j0 = 0; j0 < n; j0 = j0 + 1 { let j = n - 1 - j0 if impute_is_na(row[j]) { - if !impute_is_na(nxt) { row[j] = nxt } + if !impute_is_na(nxt) { + row[j] = nxt + } } else { nxt = row[j] } } } - if by_row { base } else { impute_transpose(base) } + if by_row { + base + } else { + impute_transpose(base) + } } // ---- KNN imputation --------------------------------------------------------- // Euclidean distance on coordinates where BOTH vectors have non-NA values. // Returns infinity when no valid overlap exists. + +///| fn impute_pairwise_dist_ignore_na( a : Array[Double], b : Array[Double], @@ -397,6 +516,7 @@ fn impute_pairwise_dist_ignore_na( } } +///| fn impute_compute_all_pair_distances( m : Array[Array[Double]], eps : Double, @@ -418,6 +538,7 @@ fn impute_compute_all_pair_distances( out } +///| fn impute_choose_k_neighbors( dist_row : Array[Double], k : Int, @@ -426,11 +547,19 @@ fn impute_choose_k_neighbors( let pairs : Array[(Int, Double)] = Array::new() let n = dist_row.length() for i = 0; i < n; i = i + 1 { - if i == self_i { continue } + if i == self_i { + continue + } pairs.push((i, dist_row[i])) } pairs.sort_by(fn(p : (Int, Double), q : (Int, Double)) -> Int { - if p.1 < q.1 { -1 } else if p.1 > q.1 { 1 } else { 0 } + if p.1 < q.1 { + -1 + } else if p.1 > q.1 { + 1 + } else { + 0 + } }) let m = if k < pairs.length() { k } else { pairs.length() } let out : Array[(Int, Double)] = Array::new() @@ -440,6 +569,7 @@ fn impute_choose_k_neighbors( out } +///| fn impute_weighted_average( neighbors : Array[(Int, Double)], m : Array[Array[Double]], @@ -453,14 +583,21 @@ fn impute_weighted_average( let ni = neighbors[idx].0 let d = neighbors[idx].1 let v = m[ni][j] - if impute_is_na(v) { continue } + if impute_is_na(v) { + continue + } let w = 1.0 / (d + eps) num = num + w * v den = den + w } - if den == 0.0 { 0.0 } else { num / den } + if den == 0.0 { + 0.0 + } else { + num / den + } } +///| pub fn impute_by_knn( mat : Array[Array[Double]], param : KNNImputeParam, @@ -480,10 +617,18 @@ pub fn impute_by_knn( } } } - if param.by_row { m } else { impute_transpose(m) } + if param.by_row { + m + } else { + impute_transpose(m) + } } -pub fn impute_by_knn_simple(mat : Array[Array[Double]], k : Int) -> Array[Array[Double]] { +///| +pub fn impute_by_knn_simple( + mat : Array[Array[Double]], + k : Int, +) -> Array[Array[Double]] { let p = KNNImputeParam::new() p.k = k impute_by_knn(mat, p) diff --git a/src/infercnv.mbt b/src/infercnv.mbt index bd8f665d..97fbc619 100644 --- a/src/infercnv.mbt +++ b/src/infercnv.mbt @@ -78,18 +78,13 @@ pub fn gene_position( start : Int, end : Int, ) -> GenePosition { - { - gene_id: gene_id, - chromosome: chromosome, - start: start, - end: end, - } + { gene_id, chromosome, start, end } } ///| /// An ordered gene set together with per-gene genomic positions. pub struct OrderedGenes { - gene_order : Array[GenePosition] // sorted by chr, then start position + gene_order : Array[GenePosition] // sorted by chr, then start position n_genes : Int } derive(Debug, Default) @@ -105,7 +100,11 @@ pub fn ordered_genes(raw : Array[GenePosition]) -> OrderedGenes { for j in 0..<(n - 1 - i) { let ca = natural_chrom_key(arr[j].chromosome) let cb = natural_chrom_key(arr[j + 1].chromosome) - let should_swap = if ca != cb { ca > cb } else { arr[j].start > arr[j + 1].start } + let should_swap = if ca != cb { + ca > cb + } else { + arr[j].start > arr[j + 1].start + } if should_swap { let tmp = arr[j] arr[j] = arr[j + 1] @@ -113,30 +112,40 @@ pub fn ordered_genes(raw : Array[GenePosition]) -> OrderedGenes { } } } - { - gene_order: arr, - n_genes: arr.length(), - } + { gene_order: arr, n_genes: arr.length() } } +///| fn natural_chrom_key(chr : String) -> String { // Trim optional "chr" prefix, then: // numeric chromosomes 1..22 -> "01" .. "22" // X -> "A0", Y -> "A1", M/MT -> "A2" (excluded by default anyway) // other -> "B" + original let s = chr.to_lower() - let base = if s.starts_with("chr") { s.substring(start=3, end=s.length()) } else { s } + let base = if s.starts_with("chr") { + s.substring(start=3, end=s.length()) + } else { + s + } match parse_double(base) { Some(v) => { let n = v.to_int() - if n < 10 { "0" + n.to_string() } else { n.to_string() } - } - None => { - if base == "x" { "A0" } - else if base == "y" { "A1" } - else if base == "m" || base == "mt" { "A2" } - else { "B" + base } + if n < 10 { + "0" + n.to_string() + } else { + n.to_string() + } } + None => + if base == "x" { + "A0" + } else if base == "y" { + "A1" + } else if base == "m" || base == "mt" { + "A2" + } else { + "B" + base + } } } @@ -146,8 +155,8 @@ pub fn exclude_chromosomes( og : OrderedGenes, excluded : Array[String], ) -> OrderedGenes { - let lower_excluded = excluded.map(fn (s) -> String { s.to_lower() }) - let kept = og.gene_order.filter(fn (gp : GenePosition) -> Bool { + let lower_excluded = excluded.map(fn(s) -> String { s.to_lower() }) + let kept = og.gene_order.filter(fn(gp : GenePosition) -> Bool { let c = gp.chromosome.to_lower() not(lower_excluded.contains(c)) }) @@ -162,13 +171,13 @@ pub fn exclude_chromosomes( /// Cell metadata record. pub struct CellAnnotation { cell_id : String - category : String // e.g. cell type / sample label + category : String // e.g. cell type / sample label } derive(Debug, Default) ///| /// Create a cell annotation. pub fn cell_annotation(cell_id : String, category : String) -> CellAnnotation { - { cell_id: cell_id, category: category } + { cell_id, category } } ///| @@ -179,8 +188,8 @@ pub fn cell_annotation(cell_id : String, category : String) -> CellAnnotation { pub struct InferCNVInput { n_cells : Int n_genes : Int - expression : Array[Array[Double]] // cell x gene (ordered) - annotations : Array[CellAnnotation] // length n_cells + expression : Array[Array[Double]] // cell x gene (ordered) + annotations : Array[CellAnnotation] // length n_cells ordered_genes : OrderedGenes } derive(Debug, Default) @@ -203,7 +212,9 @@ pub fn log_normalize_counts( let n_genes = row.length() let norm_row : Array[Double] = [] if total <= 0.0 { - for _j in 0.. Double { let mut sum = 0.0 - for v in arr { sum += v } + for v in arr { + sum += v + } sum } @@ -230,22 +244,22 @@ fn infercnv_array_sum(arr : Array[Double]) -> Double { pub struct CNVResult { n_cells : Int n_genes : Int - cnv_matrix : Array[Array[Double]] // cell x gene (ordered) + cnv_matrix : Array[Array[Double]] // cell x gene (ordered) cell_ids : Array[String] gene_ids : Array[String] - chromosome_boundaries : Array[(String, Int, Int)] // (chr, start_idx, end_idx) per chromosome - per_cell_cnv_score : Array[Double] // mean |CNV| of each cell across all genes + chromosome_boundaries : Array[(String, Int, Int)] // (chr, start_idx, end_idx) per chromosome + per_cell_cnv_score : Array[Double] // mean |CNV| of each cell across all genes per_cluster_cnv_score : Array[(String, Double)] // (category, mean score) } ///| /// Parameters exposed to the user for controlling the infercnv pipeline. pub struct CNVParams { - window_size : Int // number of adjacent genes in smoothing window - lfc_cap : Double // clip fold changes to +/- lfc_cap - noise_threshold : Double // values with |x| < noise are set to 0 + window_size : Int // number of adjacent genes in smoothing window + lfc_cap : Double // clip fold changes to +/- lfc_cap + noise_threshold : Double // values with |x| < noise are set to 0 reference_method : ReferenceMethod - reference_categories : Array[String] // used with ReferenceCategories method + reference_categories : Array[String] // used with ReferenceCategories method } ///| @@ -270,11 +284,11 @@ pub fn make_cnv_params( reference_categories : Array[String], ) -> CNVParams { { - window_size: window_size, - lfc_cap: lfc_cap, - noise_threshold: noise_threshold, - reference_method: reference_method, - reference_categories: reference_categories, + window_size, + lfc_cap, + noise_threshold, + reference_method, + reference_categories, } } @@ -282,31 +296,38 @@ pub fn make_cnv_params( // Reference profile computation // ============================================================================ +///| fn compute_reference_profile( input : InferCNVInput, params : CNVParams, -) -> Array[Array[Double]] { // returns array of reference profiles; single ref = 1 profile +) -> Array[Array[Double]] { // returns array of reference profiles; single ref = 1 profile match params.reference_method { ReferenceMethod::Custom(ref_profile) => { // ensure length matches n_genes let n = input.n_genes let arr = ref_profile.copy() - while arr.length() < n { arr.push(0.0) } + while arr.length() < n { + arr.push(0.0) + } // truncate to n genes let truncated : Array[Double] = [] - for i in 0.. { - [mean_per_gene(input.expression)] - } + ReferenceMethod::GlobalMean => [mean_per_gene(input.expression)] ReferenceMethod::ReferenceCategories => { let profiles : Array[Array[Double]] = [] for cat in params.reference_categories { let indices = cells_in_category(input.annotations, cat) - if indices.length() == 0 { continue } + if indices.length() == 0 { + continue + } let subset : Array[Array[Double]] = [] - for idx in indices { subset.push(input.expression[idx]) } + for idx in indices { + subset.push(input.expression[idx]) + } profiles.push(mean_per_gene(subset)) } if profiles.length() == 0 { @@ -319,26 +340,31 @@ fn compute_reference_profile( } } +///| fn mean_per_gene(matrix : Array[Array[Double]]) -> Array[Double] { let n_cells = matrix.length() - if n_cells == 0 { return [] } + if n_cells == 0 { + return [] + } let n_genes = matrix[0].length() let out : Array[Double] = [] for j in 0.. Array[Int] { +///| +fn cells_in_category(ann : Array[CellAnnotation], cat : String) -> Array[Int] { let out : Array[Int] = [] for i in 0.. lfc_cap { lfc_cap } else if v < -lfc_cap { -lfc_cap } else { v } + let clipped = if v > lfc_cap { + lfc_cap + } else if v < -lfc_cap { + -lfc_cap + } else { + v + } out.push(clipped) } } else { @@ -372,16 +405,28 @@ fn compute_lfc( let mut max_r = references[0][j] for r in 1.. max_r { max_r = v } + if v < min_r { + min_r = v + } + if v > max_r { + max_r = v + } } let c = cell_expr[j] - let lfc = if c > max_r { c - max_r } - else if c < min_r { c - min_r } - else { 0.0 } - let clipped = if lfc > lfc_cap { lfc_cap } - else if lfc < -lfc_cap { -lfc_cap } - else { lfc } + let lfc = if c > max_r { + c - max_r + } else if c < min_r { + c - min_r + } else { + 0.0 + } + let clipped = if lfc > lfc_cap { + lfc_cap + } else if lfc < -lfc_cap { + -lfc_cap + } else { + lfc + } out.push(clipped) } } @@ -392,11 +437,12 @@ fn compute_lfc( // Genomic smoothing per chromosome (pyramidal-weighted running mean) // ============================================================================ -fn chromosome_boundaries( - og : OrderedGenes, -) -> Array[(String, Int, Int)] { +///| +fn chromosome_boundaries(og : OrderedGenes) -> Array[(String, Int, Int)] { let result : Array[(String, Int, Int)] = [] - if og.n_genes == 0 { return result } + if og.n_genes == 0 { + return result + } let mut current_chr = og.gene_order[0].chromosome let mut start_idx = 0 for i in 1.. Array[Double] { let denom = (half + 1).to_double() for i in 0.. Double { let mut sum = 0.0 - for i in 0.. Array[Double] { let n = vec.length() - if half_window <= 0 || n <= 1 { return vec.copy() } + if half_window <= 0 || n <= 1 { + return vec.copy() + } let w = pyramidal_weights(half_window) let w_total = infercnv_array_sum(w) let out : Array[Double] = [] @@ -456,6 +509,7 @@ fn smooth_vector(vec : Array[Double], half_window : Int) -> Array[Double] { out } +///| fn smooth_per_chromosome( vec : Array[Double], boundaries : Array[(String, Int, Int)], @@ -467,10 +521,14 @@ fn smooth_per_chromosome( let (chr, s, e) = entry let len = e - s + 1 let segment : Array[Double] = [] - for i in s..=e { segment.push(result[i]) } + for i in s..<=e { + segment.push(result[i]) + } let smoothed = smooth_vector(segment, half) - for i in 0.. Double { let n = arr.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let sorted = arr.copy() // simple insertion sort for Double for i in 1.. Double { } sorted[j + 1] = key } - if n % 2 == 1 { sorted[n / 2] } - else { + if n % 2 == 1 { + sorted[n / 2] + } else { (sorted[n / 2 - 1] + sorted[n / 2]) / 2.0 } } +///| fn center_by_median(vec : Array[Double]) -> Array[Double] { let m = median_of(vec) - vec.map(fn (x) -> Double { x - m }) + vec.map(fn(x) -> Double { x - m }) } +///| fn apply_noise_threshold(vec : Array[Double], noise : Double) -> Array[Double] { - vec.map(fn (x) -> Double { if x.abs() < noise { 0.0 } else { x } }) + vec.map(fn(x) -> Double { if x.abs() < noise { 0.0 } else { x } }) } // ============================================================================ // Mean absolute per-cell CNV score // ============================================================================ +///| fn per_cell_cnv_scores(matrix : Array[Array[Double]]) -> Array[Double] { let n_cells = matrix.length() let out : Array[Double] = [] @@ -521,13 +586,16 @@ fn per_cell_cnv_scores(matrix : Array[Array[Double]]) -> Array[Double] { out.push(0.0) } else { let mut sum_abs = 0.0 - for x in row { sum_abs += x.abs() } - out.push(sum_abs / (row.length().to_double())) + for x in row { + sum_abs += x.abs() + } + out.push(sum_abs / row.length().to_double()) } } out } +///| fn per_category_scores( scores : Array[Double], ann : Array[CellAnnotation], @@ -585,8 +653,10 @@ pub fn run_infercnv( // Step 1b: keep only expression columns whose genes survived the filter. // Reorder input expression to match the filtered gene order by gene_id lookup. - let keep_gene_ids = filtered.gene_order.map(fn (g) -> String { g.gene_id }) - let original_gene_ids = input.ordered_genes.gene_order.map(fn (g) -> String { g.gene_id }) + let keep_gene_ids = filtered.gene_order.map(fn(g) -> String { g.gene_id }) + let original_gene_ids = input.ordered_genes.gene_order.map(fn(g) -> String { + g.gene_id + }) // build index map let orig_keys : Array[String] = [] let orig_vals : Array[Int] = [] @@ -600,7 +670,10 @@ pub fn run_infercnv( for gid in keep_gene_ids { let mut found_idx = -1 for k in 0..= 0 { new_row.push(input.expression[i][found_idx]) @@ -635,18 +708,23 @@ pub fn run_infercnv( cnv_matrix.push(denoised) } - let cell_ids = effective_input.annotations.map(fn (a) -> String { a.cell_id }) - let gene_ids = effective_input.ordered_genes.gene_order.map(fn (g) -> String { g.gene_id }) + let cell_ids = effective_input.annotations.map(fn(a) -> String { a.cell_id }) + let gene_ids = effective_input.ordered_genes.gene_order.map(fn(g) -> String { + g.gene_id + }) let cell_scores = per_cell_cnv_scores(cnv_matrix) - let cluster_scores = per_category_scores(cell_scores, effective_input.annotations) + let cluster_scores = per_category_scores( + cell_scores, + effective_input.annotations, + ) { n_cells: effective_input.n_cells, n_genes: effective_input.n_genes, - cnv_matrix: cnv_matrix, - cell_ids: cell_ids, - gene_ids: gene_ids, + cnv_matrix, + cell_ids, + gene_ids, chromosome_boundaries: boundaries, per_cell_cnv_score: cell_scores, per_cluster_cnv_score: cluster_scores, @@ -673,10 +751,10 @@ pub fn infercnv_sample_data( seed? : Int = 42, ) -> (InferCNVInput, Array[String], Array[String]) { let mut rng_state = seed - let next_rand = fn () -> Double { + let next_rand = fn() -> Double { // simple LCG rng_state = (rng_state * 1103515245 + 12345) & 0x7fffffff - ((rng_state & 0xffffff).to_double()) / 16777215.0 + (rng_state & 0xffffff).to_double() / 16777215.0 } let normal_mean = 3.0 let n_genes = n_chr * n_genes_per_chr @@ -693,7 +771,7 @@ pub fn infercnv_sample_data( let og = ordered_genes(positions) // helper: generate one cell with optional CNV effect - let make_cell = fn (is_tumour : Bool) -> Array[Double] { + let make_cell = fn(is_tumour : Bool) -> Array[Double] { let expr : Array[Double] = [] for c in 0.. Double { for entry in self.per_cluster_cnv_score { let (cat, score) = entry - if cat == category { return score } + if cat == category { + return score + } } 0.0 } ///| /// Return the list of chromosome boundaries as triples (chr, start, end). -pub fn CNVResult::chromosome_list(self : CNVResult) -> Array[(String, Int, Int)] { +pub fn CNVResult::chromosome_list( + self : CNVResult, +) -> Array[(String, Int, Int)] { self.chromosome_boundaries.copy() } @@ -765,25 +849,40 @@ pub fn CNVResult::chromosome_list(self : CNVResult) -> Array[(String, Int, Int)] pub fn CNVResult::summary(self : CNVResult) -> String { let total = self.per_cell_cnv_score.length() let mut sum = 0.0 - for v in self.per_cell_cnv_score { sum += v } - let mean = if total == 0 { 0.0 } else { sum / (total.to_double()) } + for v in self.per_cell_cnv_score { + sum += v + } + let mean = if total == 0 { 0.0 } else { sum / total.to_double() } let mut max_cat = "" let mut max_score = 0.0 for entry in self.per_cluster_cnv_score { let (cat, score) = entry - if score > max_score { max_cat = cat; max_score = score } + if score > max_score { + max_cat = cat + max_score = score + } } - "CNVResult(cells=" + total.to_string() + - ", genes=" + self.n_genes.to_string() + - ", mean_score=" + mean.to_string() + - ", top_cluster=" + max_cat + "=" + max_score.to_string() + ")" + "CNVResult(cells=" + + total.to_string() + + ", genes=" + + self.n_genes.to_string() + + ", mean_score=" + + mean.to_string() + + ", top_cluster=" + + max_cat + + "=" + + max_score.to_string() + + ")" } ///| /// Return CNV matrix value at cell index i, gene index j. pub fn CNVResult::at(self : CNVResult, i : Int, j : Int) -> Double { - if i < 0 || i >= self.n_cells || j < 0 || j >= self.n_genes { 0.0 } - else { self.cnv_matrix[i][j] } + if i < 0 || i >= self.n_cells || j < 0 || j >= self.n_genes { + 0.0 + } else { + self.cnv_matrix[i][j] + } } ///| @@ -799,7 +898,9 @@ pub fn CNVResult::predict_tumour_cells( let threshold = base * threshold_factor let out : Array[Int] = [] for i in 0.. threshold { out.push(i) } + if self.per_cell_cnv_score[i] > threshold { + out.push(i) + } } out } diff --git a/src/insdc_io.mbt b/src/insdc_io.mbt index 9bc28219..80973537 100644 --- a/src/insdc_io.mbt +++ b/src/insdc_io.mbt @@ -553,9 +553,7 @@ pub fn parse_genbank_record(content : String) -> InsdcRecord { let ll = line.length() // Record terminator. - if ll >= 2 && - line.unsafe_get(0) == slash && - line.unsafe_get(1) == slash { + if ll >= 2 && line.unsafe_get(0) == slash && line.unsafe_get(1) == slash { i = i + 1 break } @@ -764,29 +762,37 @@ pub fn write_genbank_record(record : InsdcRecord) -> String { } buf.write_string(len_str) buf.write_string(" ") - buf.write_string(if record.molecule_type.length() > 0 { - record.molecule_type - } else { - "DNA" - }) + buf.write_string( + if record.molecule_type.length() > 0 { + record.molecule_type + } else { + "DNA" + }, + ) buf.write_string(" ") - buf.write_string(if record.topology.length() > 0 { - record.topology - } else { - "linear" - }) + buf.write_string( + if record.topology.length() > 0 { + record.topology + } else { + "linear" + }, + ) buf.write_string(" ") - buf.write_string(if record.division.length() > 0 { - record.division - } else { - "UNK" - }) + buf.write_string( + if record.division.length() > 0 { + record.division + } else { + "UNK" + }, + ) buf.write_string(" ") - buf.write_string(if record.date.length() > 0 { - record.date - } else { - "01-JAN-2024" - }) + buf.write_string( + if record.date.length() > 0 { + record.date + } else { + "01-JAN-2024" + }, + ) buf.write_char('\n') // --- DEFINITION --- @@ -907,9 +913,7 @@ pub fn parse_embl_record(content : String) -> InsdcRecord { let ll = line.length() // Record terminator. - if ll >= 2 && - line.unsafe_get(0) == slash && - line.unsafe_get(1) == slash { + if ll >= 2 && line.unsafe_get(0) == slash && line.unsafe_get(1) == slash { i = i + 1 break } @@ -1019,8 +1023,8 @@ pub fn parse_embl_record(content : String) -> InsdcRecord { } if ct < 2 || !(cont.unsafe_get(0) == 'D'.to_int().to_uint16() && - cont.unsafe_get(1) == 'E'.to_int().to_uint16() && - (ct == 2 || cont.unsafe_get(2) == sp)) { + cont.unsafe_get(1) == 'E'.to_int().to_uint16() && + (ct == 2 || cont.unsafe_get(2) == sp)) { break } def_buf.write_char(' ') @@ -1056,8 +1060,8 @@ pub fn parse_embl_record(content : String) -> InsdcRecord { } if ct < 2 || !(cont.unsafe_get(0) == 'O'.to_int().to_uint16() && - cont.unsafe_get(1) == 'S'.to_int().to_uint16() && - (ct == 2 || cont.unsafe_get(2) == sp)) { + cont.unsafe_get(1) == 'S'.to_int().to_uint16() && + (ct == 2 || cont.unsafe_get(2) == sp)) { break } org_buf.write_char(' ') @@ -1094,7 +1098,7 @@ pub fn parse_embl_record(content : String) -> InsdcRecord { // A non-FT line ends the feature table. if ll < 2 || !(line.unsafe_get(0) == 'F'.to_int().to_uint16() && - line.unsafe_get(1) == 'T'.to_int().to_uint16()) { + line.unsafe_get(1) == 'T'.to_int().to_uint16()) { in_ft = false // Fall through to other section checks below. } @@ -1186,23 +1190,29 @@ pub fn write_embl_record(record : InsdcRecord) -> String { } buf.write_string(sv_num) buf.write_string("; ") - buf.write_string(if record.topology.length() > 0 { - record.topology - } else { - "linear" - }) + buf.write_string( + if record.topology.length() > 0 { + record.topology + } else { + "linear" + }, + ) buf.write_string("; ") - buf.write_string(if record.molecule_type.length() > 0 { - record.molecule_type - } else { - "DNA" - }) + buf.write_string( + if record.molecule_type.length() > 0 { + record.molecule_type + } else { + "DNA" + }, + ) buf.write_string("; STD; ") - buf.write_string(if record.division.length() > 0 { - record.division - } else { - "UNK" - }) + buf.write_string( + if record.division.length() > 0 { + record.division + } else { + "UNK" + }, + ) buf.write_string("; ") buf.write_string(record.sequence_length.to_string()) buf.write_string(" BP.") @@ -1237,11 +1247,7 @@ pub fn write_embl_record(record : InsdcRecord) -> String { for l in lines { // Convert the GenBank-style 5-space indent into "FT " by replacing // the first two spaces with the literal "FT". - let l_to_write = if l.length() >= 2 { - "FT" + l[2:].to_owned() - } else { - l - } + let l_to_write = if l.length() >= 2 { "FT" + l[2:].to_owned() } else { l } buf.write_string(l_to_write) buf.write_char('\n') } diff --git a/src/internal_coords.mbt b/src/internal_coords.mbt index a994532f..e919c59d 100644 --- a/src/internal_coords.mbt +++ b/src/internal_coords.mbt @@ -186,23 +186,33 @@ pub fn RotamerLibraryEntry::new( ///| /// Standard peptide bond length (C-N). -pub fn ic_peptide_bond_length() -> Double { 1.33 } +pub fn ic_peptide_bond_length() -> Double { + 1.33 +} ///| /// Standard CA-C bond length. -pub fn ic_ca_c_bond_length() -> Double { 1.52 } +pub fn ic_ca_c_bond_length() -> Double { + 1.52 +} ///| /// Standard N-CA bond length. -pub fn ic_n_ca_bond_length() -> Double { 1.47 } +pub fn ic_n_ca_bond_length() -> Double { + 1.47 +} ///| /// Standard omega bond angle (CA-C-N-CA), ~180 degrees. -pub fn ic_omega_angle() -> Double { 180.0 } +pub fn ic_omega_angle() -> Double { + 180.0 +} ///| /// Standard tau angle (N-CA-C), ~110 degrees. -pub fn ic_tau_angle() -> Double { 110.0 } +pub fn ic_tau_angle() -> Double { + 110.0 +} // ============================================================================ // Torsion angle calculations @@ -245,15 +255,21 @@ pub fn ic_dihedral_angle( ///| /// PI constant. -pub fn ic_pi() -> Double { 3.14159265358979323846 } +pub fn ic_pi() -> Double { + 3.14159265358979323846 +} ///| /// Convert radians to degrees. -pub fn ic_rad_to_deg(rad : Double) -> Double { rad * 180.0 / ic_pi() } +pub fn ic_rad_to_deg(rad : Double) -> Double { + rad * 180.0 / ic_pi() +} ///| /// Convert degrees to radians. -pub fn ic_deg_to_rad(deg : Double) -> Double { deg * ic_pi() / 180.0 } +pub fn ic_deg_to_rad(deg : Double) -> Double { + deg * ic_pi() / 180.0 +} ///| /// Compute phi angle for a residue (C(i-1) - N(i) - CA(i) - C(i)). @@ -307,9 +323,7 @@ pub fn ic_compute_chi1( /// Build a simple extended polypeptide chain from internal coordinates. /// Uses standard bond lengths and angles. /// Returns the ICToCartesianResult with atom positions. -pub fn ic_build_extended_chain( - sequence : Array[String], -) -> ICToCartesianResult { +pub fn ic_build_extended_chain(sequence : Array[String]) -> ICToCartesianResult { let result = ICToCartesianResult::new() // Standard bond parameters @@ -383,7 +397,13 @@ pub fn ic_build_extended_chain( let next_n = ic_rotate_around_bond(prev_c, prev_ca, prev_n, psi, bond_c_n) // Place next CA atom using phi rotation on next residue - let next_ca = ic_rotate_around_bond(next_n, prev_c, prev_ca, phi + ic_pi(), bond_n_ca) + let next_ca = ic_rotate_around_bond( + next_n, + prev_c, + prev_ca, + phi + ic_pi(), + bond_n_ca, + ) // Place next C atom let next_c = ic_build_carbonyl(next_n, next_ca, prev_c) @@ -451,11 +471,7 @@ pub fn ic_rotate_around_bond( } // Vector from origin to point - let v = [ - point[0] - origin[0], - point[1] - origin[1], - point[2] - origin[2], - ] + let v = [point[0] - origin[0], point[1] - origin[1], point[2] - origin[2]] // Decompose v into parallel and perpendicular components let v_par = ic_dot(v, bond_unit) @@ -522,7 +538,11 @@ pub fn ic_build_carbonyl( [1.0, 0.0, 0.0] } let v2 = if pc_norm > 1.0e-10 { - [v_ca_prev_c[0] / pc_norm, v_ca_prev_c[1] / pc_norm, v_ca_prev_c[2] / pc_norm] + [ + v_ca_prev_c[0] / pc_norm, + v_ca_prev_c[1] / pc_norm, + v_ca_prev_c[2] / pc_norm, + ] } else { [0.0, 1.0, 0.0] } @@ -566,11 +586,7 @@ pub fn ic_oxygen_position( ca_pos[1] - c_pos[1], ca_pos[2] - c_pos[2], ] - let v_c_n = [ - n_pos[0] - c_pos[0], - n_pos[1] - c_pos[1], - n_pos[2] - c_pos[2], - ] + let v_c_n = [n_pos[0] - c_pos[0], n_pos[1] - c_pos[1], n_pos[2] - c_pos[2]] let ca_norm = ic_vec_norm(v_c_ca) let n_norm = ic_vec_norm(v_c_n) @@ -587,11 +603,7 @@ pub fn ic_oxygen_position( } // Bisector direction (CA-C-N angle ~121°, so bisector is between them) - let bisector = [ - u_ca[0] + u_n[0], - u_ca[1] + u_n[1], - u_ca[2] + u_n[2], - ] + let bisector = [u_ca[0] + u_n[0], u_ca[1] + u_n[1], u_ca[2] + u_n[2]] let bis_norm = ic_vec_norm(bisector) let bis_unit = if bis_norm > 1.0e-10 { [bisector[0] / bis_norm, bisector[1] / bis_norm, bisector[2] / bis_norm] @@ -725,103 +737,420 @@ pub fn ic_distance(a : Array[Double], b : Array[Double]) -> Double { /// Get common chi1 angle values for different amino acids. pub fn ic_chi1_rotamers(resname : String) -> Array[Rotamer] { match resname { - "LEU" => [ - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(-60.0)], probability: 0.25 }, - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(-60.0)], probability: 0.55 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(-60.0)], probability: 0.20 }, - ] - "VAL" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0)], probability: 0.45 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0)], probability: 0.35 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0)], probability: 0.20 }, - ] - "PHE" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.60 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(90.0)], probability: 0.25 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(-90.0)], probability: 0.15 }, - ] - "TYR" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.60 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(90.0)], probability: 0.25 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(-90.0)], probability: 0.15 }, - ] - "TRP" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.50 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.30 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(-90.0)], probability: 0.20 }, - ] - "SER" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0)], probability: 0.35 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0)], probability: 0.40 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0)], probability: 0.25 }, - ] - "THR" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0)], probability: 0.25 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0)], probability: 0.40 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0)], probability: 0.35 }, - ] - "CYS" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0)], probability: 0.35 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0)], probability: 0.40 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0)], probability: 0.25 }, - ] - "MET" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.50 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.25 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(-90.0)], probability: 0.25 }, - ] - "LYS" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0)], probability: 0.40 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0)], probability: 0.30 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0)], probability: 0.30 }, - ] - "ARG" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.35 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.35 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.30 }, - ] - "ASP" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0)], probability: 0.60 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0)], probability: 0.20 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0)], probability: 0.20 }, - ] - "GLU" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0)], probability: 0.45 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0)], probability: 0.30 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(180.0)], probability: 0.25 }, - ] - "ASN" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.55 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(90.0)], probability: 0.25 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(-90.0)], probability: 0.20 }, - ] - "GLN" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.50 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], probability: 0.25 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0), ic_deg_to_rad(-90.0)], probability: 0.25 }, - ] - "HIS" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(0.0)], probability: 0.45 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(0.0)], probability: 0.30 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0)], probability: 0.25 }, - ] - "ALA" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0)], probability: 1.0 }, - ] - "GLY" => [ - Rotamer::{ name: "t", chi_angles: [], probability: 1.0 }, - ] - "PRO" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(-60.0)], probability: 1.0 }, - ] - "ILE" => [ - Rotamer::{ name: "t", chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(-60.0)], probability: 0.60 }, - Rotamer::{ name: "g+", chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(-60.0)], probability: 0.20 }, - Rotamer::{ name: "g-", chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0)], probability: 0.20 }, - ] - _ => [ - Rotamer::{ name: "t", chi_angles: [], probability: 1.0 }, - ] + "LEU" => + [ + Rotamer::{ + name: "g+", + chi_angles: [ + ic_deg_to_rad(-60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(-60.0), + ], + probability: 0.25, + }, + Rotamer::{ + name: "t", + chi_angles: [ + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(-60.0), + ], + probability: 0.55, + }, + Rotamer::{ + name: "g-", + chi_angles: [ + ic_deg_to_rad(60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(-60.0), + ], + probability: 0.20, + }, + ] + "VAL" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0)], + probability: 0.45, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0)], + probability: 0.35, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0)], + probability: 0.20, + }, + ] + "PHE" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], + probability: 0.60, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(90.0)], + probability: 0.25, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(-90.0)], + probability: 0.15, + }, + ] + "TYR" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], + probability: 0.60, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(90.0)], + probability: 0.25, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(-90.0)], + probability: 0.15, + }, + ] + "TRP" => + [ + Rotamer::{ + name: "t", + chi_angles: [ + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.50, + }, + Rotamer::{ + name: "g+", + chi_angles: [ + ic_deg_to_rad(-60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.30, + }, + Rotamer::{ + name: "g-", + chi_angles: [ + ic_deg_to_rad(60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(-90.0), + ], + probability: 0.20, + }, + ] + "SER" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0)], + probability: 0.35, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0)], + probability: 0.40, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0)], + probability: 0.25, + }, + ] + "THR" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0)], + probability: 0.25, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0)], + probability: 0.40, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0)], + probability: 0.35, + }, + ] + "CYS" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0)], + probability: 0.35, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0)], + probability: 0.40, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0)], + probability: 0.25, + }, + ] + "MET" => + [ + Rotamer::{ + name: "t", + chi_angles: [ + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.50, + }, + Rotamer::{ + name: "g+", + chi_angles: [ + ic_deg_to_rad(-60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.25, + }, + Rotamer::{ + name: "g-", + chi_angles: [ + ic_deg_to_rad(60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(-90.0), + ], + probability: 0.25, + }, + ] + "LYS" => + [ + Rotamer::{ + name: "t", + chi_angles: [ + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ], + probability: 0.40, + }, + Rotamer::{ + name: "g+", + chi_angles: [ + ic_deg_to_rad(-60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ], + probability: 0.30, + }, + Rotamer::{ + name: "g-", + chi_angles: [ + ic_deg_to_rad(60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ], + probability: 0.30, + }, + ] + "ARG" => + [ + Rotamer::{ + name: "t", + chi_angles: [ + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.35, + }, + Rotamer::{ + name: "g+", + chi_angles: [ + ic_deg_to_rad(-60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.35, + }, + Rotamer::{ + name: "g-", + chi_angles: [ + ic_deg_to_rad(60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.30, + }, + ] + "ASP" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(180.0)], + probability: 0.60, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(180.0)], + probability: 0.20, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0)], + probability: 0.20, + }, + ] + "GLU" => + [ + Rotamer::{ + name: "t", + chi_angles: [ + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ], + probability: 0.45, + }, + Rotamer::{ + name: "g+", + chi_angles: [ + ic_deg_to_rad(-60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ], + probability: 0.30, + }, + Rotamer::{ + name: "g-", + chi_angles: [ + ic_deg_to_rad(60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ], + probability: 0.25, + }, + ] + "ASN" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(90.0)], + probability: 0.55, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(90.0)], + probability: 0.25, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(-90.0)], + probability: 0.20, + }, + ] + "GLN" => + [ + Rotamer::{ + name: "t", + chi_angles: [ + ic_deg_to_rad(180.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.50, + }, + Rotamer::{ + name: "g+", + chi_angles: [ + ic_deg_to_rad(-60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(90.0), + ], + probability: 0.25, + }, + Rotamer::{ + name: "g-", + chi_angles: [ + ic_deg_to_rad(60.0), + ic_deg_to_rad(180.0), + ic_deg_to_rad(-90.0), + ], + probability: 0.25, + }, + ] + "HIS" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(0.0)], + probability: 0.45, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(0.0)], + probability: 0.30, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0)], + probability: 0.25, + }, + ] + "ALA" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0)], + probability: 1.0, + }, + ] + "GLY" => [Rotamer::{ name: "t", chi_angles: [], probability: 1.0 }] + "PRO" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(-60.0)], + probability: 1.0, + }, + ] + "ILE" => + [ + Rotamer::{ + name: "t", + chi_angles: [ic_deg_to_rad(180.0), ic_deg_to_rad(-60.0)], + probability: 0.60, + }, + Rotamer::{ + name: "g+", + chi_angles: [ic_deg_to_rad(-60.0), ic_deg_to_rad(-60.0)], + probability: 0.20, + }, + Rotamer::{ + name: "g-", + chi_angles: [ic_deg_to_rad(60.0), ic_deg_to_rad(180.0)], + probability: 0.20, + }, + ] + _ => [Rotamer::{ name: "t", chi_angles: [], probability: 1.0 }] } } @@ -854,12 +1183,34 @@ pub fn ic_validate_coords(ic : InternalCoordChain) -> Array[(Int, String)] { let res = ic.residues[i] for bl in res.bond_lengths { if bl.length < 0.5 || bl.length > 3.0 { - issues.push((res.resseq, "Bond length " + bl.atom1 + "-" + bl.atom2 + " out of range: " + bl.length.to_string())) + issues.push( + ( + res.resseq, + "Bond length " + + bl.atom1 + + "-" + + bl.atom2 + + " out of range: " + + bl.length.to_string(), + ), + ) } } for ba in res.bond_angles { if ba.angle < 60.0 || ba.angle > 180.0 { - issues.push((res.resseq, "Bond angle " + ba.atom1 + "-" + ba.atom2 + "-" + ba.atom3 + " out of range: " + ba.angle.to_string())) + issues.push( + ( + res.resseq, + "Bond angle " + + ba.atom1 + + "-" + + ba.atom2 + + "-" + + ba.atom3 + + " out of range: " + + ba.angle.to_string(), + ), + ) } } i = i + 1 @@ -875,9 +1226,13 @@ pub fn ic_chain_summary(ic : InternalCoordChain) -> String { for res in ic.residues { total_torsions = total_torsions + res.torsions.length() } - "Chain " + ic.chain_id.to_string() + - ": " + n_res.to_string() + " residues, " + - total_torsions.to_string() + " torsion angles" + "Chain " + + ic.chain_id.to_string() + + ": " + + n_res.to_string() + + " residues, " + + total_torsions.to_string() + + " torsion angles" } ///| @@ -888,10 +1243,7 @@ pub fn InternalCoordChain::add_residue( ) -> InternalCoordChain { let new_residues = self.residues.copy() new_residues.push(res) - InternalCoordChain::{ - chain_id: self.chain_id, - residues: new_residues, - } + InternalCoordChain::{ chain_id: self.chain_id, residues: new_residues } } ///| @@ -956,7 +1308,9 @@ pub fn InternalCoordChain::n_residues(self : InternalCoordChain) -> Int { ///| /// Get residue names. -pub fn InternalCoordChain::residue_names(self : InternalCoordChain) -> Array[String] { +pub fn InternalCoordChain::residue_names( + self : InternalCoordChain, +) -> Array[String] { self.residues.map(fn(r) { r.resname }) } diff --git a/src/interproscan.mbt b/src/interproscan.mbt index 65f29dfc..24aa1707 100644 --- a/src/interproscan.mbt +++ b/src/interproscan.mbt @@ -297,24 +297,22 @@ fn ips_parse_line(line : String) -> InterproScanRecord? { let ipr_acc = ips_normalize(fields[11]) let ipr_desc = ips_normalize(fields[12]) let go_terms = ips_split_go_terms(fields[13]) - Some( - InterproScanRecord::{ - protein_id, - md5, - seq_length, - analysis, - signature_acc, - signature_desc, - start_pos, - stop_pos, - score, - status, - date, - ipr_acc, - ipr_desc, - go_terms, - }, - ) + Some(InterproScanRecord::{ + protein_id, + md5, + seq_length, + analysis, + signature_acc, + signature_desc, + start_pos, + stop_pos, + score, + status, + date, + ipr_acc, + ipr_desc, + go_terms, + }) } // ============================================================================ @@ -354,14 +352,222 @@ pub fn interproscan_sample_data() -> String { let t = "\t" "# InterProScan output (sample)\n" + "# version 5.0\n" + - "sp|P12345|PROT_HUMAN" + t + "abc123def456" + t + "500" + t + "Pfam" + t + "PF00001" + t + "p53 DNA-binding domain" + t + "1" + t + "100" + t + "150.5" + t + "T" + t + "01-Jan-2024" + t + "IPR000001" + t + "p53, DNA-binding domain" + t + "GO:0003674|GO:0008150\n" + - "sp|P12345|PROT_HUMAN" + t + "abc123def456" + t + "500" + t + "SMART" + t + "SM00100" + t + "p53 domain" + t + "1" + t + "100" + t + "120.0" + t + "T" + t + "01-Jan-2024" + t + "IPR000001" + t + "p53, DNA-binding domain" + t + "GO:0003674\n" + - "sp|P12345|PROT_HUMAN" + t + "abc123def456" + t + "500" + t + "PROSITEPATTERNS" + t + "PS00001" + t + "p53 pattern" + t + "50" + t + "60" + t + "0.0" + t + "T" + t + "01-Jan-2024" + t + "-" + t + "-" + t + "-\n" + - "sp|Q9Y6K9|XYZ_HUMAN" + t + "def789ghi012" + t + "300" + t + "Profile" + t + "PS50122" + t + "Helicase C-terminal" + t + "10" + t + "250" + t + "200.3" + t + "T" + t + "02-Jan-2024" + t + "IPR000002" + t + "Helicase, C-terminal" + t + "GO:0005524|GO:0006280|GO:0003676\n" + - "sp|Q9Y6K9|XYZ_HUMAN" + t + "def789ghi012" + t + "300" + t + "Pfam" + t + "PF00002" + t + "Kinase domain" + t + "5" + t + "150" + t + "180.0" + t + "T" + t + "02-Jan-2024" + t + "IPR000003" + t + "Kinase domain" + t + "GO:0004672\n" + - "sp|O15143|ABC_HUMAN" + t + "ghi345jkl678" + t + "600" + t + "Pfam" + t + "PF00003" + t + "ABC transporter" + t + "100" + t + "300" + t + "110.5" + t + "T" + t + "03-Jan-2024" + t + "IPR000004" + t + "ABC transporter-like" + t + "GO:0005524|GO:0016887\n" + - "sp|O15143|ABC_HUMAN" + t + "ghi345jkl678" + t + "600" + t + "HAMMER" + t + "HM00001" + t + "Hammerhead ribozyme" + t + "1" + t + "50" + t + "90.0" + t + "T" + t + "03-Jan-2024" + t + "IPR000005" + t + "Hammerhead ribozyme" + t + "-\n" + - "sp|O15143|ABC_HUMAN" + t + "ghi345jkl678" + t + "600" + t + "SMART" + t + "SM00150" + t + "DnaJ domain" + t + "400" + t + "500" + t + "85.0" + t + "T" + t + "03-Jan-2024" + t + "IPR000006" + t + "DnaJ domain" + t + "GO:0044183\n" + "sp|P12345|PROT_HUMAN" + + t + + "abc123def456" + + t + + "500" + + t + + "Pfam" + + t + + "PF00001" + + t + + "p53 DNA-binding domain" + + t + + "1" + + t + + "100" + + t + + "150.5" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "IPR000001" + + t + + "p53, DNA-binding domain" + + t + + "GO:0003674|GO:0008150\n" + + "sp|P12345|PROT_HUMAN" + + t + + "abc123def456" + + t + + "500" + + t + + "SMART" + + t + + "SM00100" + + t + + "p53 domain" + + t + + "1" + + t + + "100" + + t + + "120.0" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "IPR000001" + + t + + "p53, DNA-binding domain" + + t + + "GO:0003674\n" + + "sp|P12345|PROT_HUMAN" + + t + + "abc123def456" + + t + + "500" + + t + + "PROSITEPATTERNS" + + t + + "PS00001" + + t + + "p53 pattern" + + t + + "50" + + t + + "60" + + t + + "0.0" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "-" + + t + + "-" + + t + + "-\n" + + "sp|Q9Y6K9|XYZ_HUMAN" + + t + + "def789ghi012" + + t + + "300" + + t + + "Profile" + + t + + "PS50122" + + t + + "Helicase C-terminal" + + t + + "10" + + t + + "250" + + t + + "200.3" + + t + + "T" + + t + + "02-Jan-2024" + + t + + "IPR000002" + + t + + "Helicase, C-terminal" + + t + + "GO:0005524|GO:0006280|GO:0003676\n" + + "sp|Q9Y6K9|XYZ_HUMAN" + + t + + "def789ghi012" + + t + + "300" + + t + + "Pfam" + + t + + "PF00002" + + t + + "Kinase domain" + + t + + "5" + + t + + "150" + + t + + "180.0" + + t + + "T" + + t + + "02-Jan-2024" + + t + + "IPR000003" + + t + + "Kinase domain" + + t + + "GO:0004672\n" + + "sp|O15143|ABC_HUMAN" + + t + + "ghi345jkl678" + + t + + "600" + + t + + "Pfam" + + t + + "PF00003" + + t + + "ABC transporter" + + t + + "100" + + t + + "300" + + t + + "110.5" + + t + + "T" + + t + + "03-Jan-2024" + + t + + "IPR000004" + + t + + "ABC transporter-like" + + t + + "GO:0005524|GO:0016887\n" + + "sp|O15143|ABC_HUMAN" + + t + + "ghi345jkl678" + + t + + "600" + + t + + "HAMMER" + + t + + "HM00001" + + t + + "Hammerhead ribozyme" + + t + + "1" + + t + + "50" + + t + + "90.0" + + t + + "T" + + t + + "03-Jan-2024" + + t + + "IPR000005" + + t + + "Hammerhead ribozyme" + + t + + "-\n" + + "sp|O15143|ABC_HUMAN" + + t + + "ghi345jkl678" + + t + + "600" + + t + + "SMART" + + t + + "SM00150" + + t + + "DnaJ domain" + + t + + "400" + + t + + "500" + + t + + "85.0" + + t + + "T" + + t + + "03-Jan-2024" + + t + + "IPR000006" + + t + + "DnaJ domain" + + t + + "GO:0044183\n" } // ============================================================================ diff --git a/src/iranges.mbt b/src/iranges.mbt index bc04e050..40d42c10 100644 --- a/src/iranges.mbt +++ b/src/iranges.mbt @@ -642,7 +642,11 @@ pub fn ir_distance_to_nearest(ir : IRanges) -> Array[Int] { j = j + 1 } - distances[i] = if min_dist < @double.infinity { min_dist.to_int() } else { -1 } + distances[i] = if min_dist < @double.infinity { + min_dist.to_int() + } else { + -1 + } i = i + 1 } @@ -744,23 +748,26 @@ pub fn ir_gap_width(ir : IRanges) -> Int { total_gap } -///| Test find_overlaps_advanced with "any" type +///| +/// Test find_overlaps_advanced with "any" type test "find_overlaps_advanced_any" { let query = iranges([1, 10], [5, 15]) let subject = iranges([3, 8, 12], [8, 14, 18]) - let result = find_overlaps_advanced(query=query, subject=subject, type_="any") + let result = find_overlaps_advanced(query~, subject~, type_="any") assert_true(result.length() >= 1) } -///| Test find_overlaps_advanced with "within" type +///| +/// Test find_overlaps_advanced with "within" type test "find_overlaps_advanced_within" { let query = iranges([1, 10], [5, 15]) let subject = iranges([0, 5], [10, 20]) - let result = find_overlaps_advanced(query=query, subject=subject, type_="within") + let result = find_overlaps_advanced(query~, subject~, type_="within") assert_true(result.length() >= 0) } -///| Test ir_nearest function +///| +/// Test ir_nearest function test "ir_nearest" { let query = iranges([1, 20, 40], [5, 25, 45]) let subject = iranges([10, 30], [15, 35]) @@ -770,7 +777,8 @@ test "ir_nearest" { assert_eq(result[0], 0) } -///| Test ir_coverage function +///| +/// Test ir_coverage function test "ir_coverage" { let ir = iranges([1, 5, 10], [8, 15, 20]) let result = ir_coverage(ir, 25) @@ -781,14 +789,16 @@ test "ir_coverage" { assert_eq(result[4], 2) } -///| Test ir_coverage_rle function +///| +/// Test ir_coverage_rle function test "ir_coverage_rle" { let ir = iranges([1, 5], [3, 8]) let result = ir_coverage_rle(ir, 10) assert_true(result.length() >= 1) } -///| Test ir_distance function +///| +/// Test ir_distance function test "ir_distance" { let ir1 = iranges([1, 15], [5, 20]) let ir2 = iranges([10, 30], [12, 35]) @@ -797,7 +807,8 @@ test "ir_distance" { assert_eq(result[0].length(), 2) } -///| Test ir_distance_to_nearest function +///| +/// Test ir_distance_to_nearest function test "ir_distance_to_nearest" { let ir = iranges([1, 10, 25], [5, 15, 30]) let result = ir_distance_to_nearest(ir) @@ -806,7 +817,8 @@ test "ir_distance_to_nearest" { assert_eq(result[0], 4) } -///| Test ir_precede function +///| +/// Test ir_precede function test "ir_precede" { let query = iranges([10, 30], [15, 35]) let subject = iranges([1, 20], [5, 25]) @@ -816,7 +828,8 @@ test "ir_precede" { assert_eq(result[0], 0) } -///| Test ir_follow function +///| +/// Test ir_follow function test "ir_follow" { let query = iranges([1, 10], [5, 15]) let subject = iranges([20, 30], [25, 35]) @@ -826,7 +839,8 @@ test "ir_follow" { assert_eq(result[1], 0) } -///| Test ir_subset function +///| +/// Test ir_subset function test "ir_subset" { let ir = iranges([1, 5, 10], [3, 8, 15]) let keep = [true, false, true] @@ -836,7 +850,8 @@ test "ir_subset" { assert_eq(result.starts[1], 10) } -///| Test ir_sort function +///| +/// Test ir_sort function test "ir_sort" { let ir = iranges([10, 1, 5], [15, 3, 8]) let result = ir_sort(ir) diff --git a/src/isoform_switch_analyze_r.mbt b/src/isoform_switch_analyze_r.mbt index c6d5dc1c..db3ae3b3 100644 --- a/src/isoform_switch_analyze_r.mbt +++ b/src/isoform_switch_analyze_r.mbt @@ -1,5 +1,4 @@ ///| - pub struct IsoformExpression { isoform_id : String gene_id : String @@ -8,6 +7,7 @@ pub struct IsoformExpression { fpkm : Array[Double] } +///| pub struct IsoformSwitch { gene_id : String gene_name : String @@ -21,6 +21,7 @@ pub struct IsoformSwitch { consequence_type : Array[String] } +///| pub struct SwitchAnalyzeRlist { isoform_expression : Array[IsoformExpression] isoform_switches : Array[IsoformSwitch] @@ -29,29 +30,63 @@ pub struct SwitchAnalyzeRlist { gene_annotation : Map[String, String] } -pub fn IsoformExpression::new(isoform_id : String, gene_id : String, counts : Array[Double], - tpm : Array[Double], fpkm : Array[Double]) -> IsoformExpression { +///| +pub fn IsoformExpression::new( + isoform_id : String, + gene_id : String, + counts : Array[Double], + tpm : Array[Double], + fpkm : Array[Double], +) -> IsoformExpression { IsoformExpression::{ isoform_id, gene_id, counts, tpm, fpkm } } -pub fn IsoformSwitch::new(gene_id : String, gene_name : String, isoform_id_1 : String, - isoform_id_2 : String, dpsi : Double, dif : Double, - pvalue : Double, adjusted_pvalue : Double, - switch_direction : String, consequence_type : Array[String]) -> IsoformSwitch { - IsoformSwitch::{ gene_id, gene_name, isoform_id_1, isoform_id_2, dpsi, dif, pvalue, adjusted_pvalue, switch_direction, consequence_type } +///| +pub fn IsoformSwitch::new( + gene_id : String, + gene_name : String, + isoform_id_1 : String, + isoform_id_2 : String, + dpsi : Double, + dif : Double, + pvalue : Double, + adjusted_pvalue : Double, + switch_direction : String, + consequence_type : Array[String], +) -> IsoformSwitch { + IsoformSwitch::{ + gene_id, + gene_name, + isoform_id_1, + isoform_id_2, + dpsi, + dif, + pvalue, + adjusted_pvalue, + switch_direction, + consequence_type, + } } -pub fn SwitchAnalyzeRlist::new(samples : Array[String], conditions : Array[String]) -> SwitchAnalyzeRlist { - SwitchAnalyzeRlist::{ - isoform_expression: Array::new(), - isoform_switches: Array::new(), - samples: samples, - conditions: conditions, - gene_annotation: Map([], capacity=0) +///| +pub fn SwitchAnalyzeRlist::new( + samples : Array[String], + conditions : Array[String], +) -> SwitchAnalyzeRlist { + SwitchAnalyzeRlist::{ + isoform_expression: Array::new(), + isoform_switches: Array::new(), + samples, + conditions, + gene_annotation: Map([], capacity=0), } } -pub fn SwitchAnalyzeRlist::add_isoform(self : SwitchAnalyzeRlist, isoform : IsoformExpression) -> SwitchAnalyzeRlist { +///| +pub fn SwitchAnalyzeRlist::add_isoform( + self : SwitchAnalyzeRlist, + isoform : IsoformExpression, +) -> SwitchAnalyzeRlist { let expr_len = self.isoform_expression.length() let new_expr : Array[IsoformExpression] = Array::new() let mut i = 0 @@ -63,13 +98,21 @@ pub fn SwitchAnalyzeRlist::add_isoform(self : SwitchAnalyzeRlist, isoform : Isof SwitchAnalyzeRlist::{ ..self, isoform_expression: new_expr } } -pub fn SwitchAnalyzeRlist::add_gene_annotation(self : SwitchAnalyzeRlist, gene_id : String, gene_name : String) -> SwitchAnalyzeRlist { +///| +pub fn SwitchAnalyzeRlist::add_gene_annotation( + self : SwitchAnalyzeRlist, + gene_id : String, + gene_name : String, +) -> SwitchAnalyzeRlist { let annot = self.gene_annotation annot.set(gene_id, gene_name) SwitchAnalyzeRlist::{ ..self, gene_annotation: annot } } -pub fn bio_isoform_calculate_usage(expression : IsoformExpression) -> Array[Double] { +///| +pub fn bio_isoform_calculate_usage( + expression : IsoformExpression, +) -> Array[Double] { let len = expression.tpm.length() let usage : Array[Double] = Array::new() let mut i = 0 @@ -80,16 +123,21 @@ pub fn bio_isoform_calculate_usage(expression : IsoformExpression) -> Array[Doub usage } -pub fn bio_isoform_calculate_dpsi(isoform1 : IsoformExpression, isoform2 : IsoformExpression, - condition1_indices : Array[Int], condition2_indices : Array[Int]) -> Double { +///| +pub fn bio_isoform_calculate_dpsi( + isoform1 : IsoformExpression, + isoform2 : IsoformExpression, + condition1_indices : Array[Int], + condition2_indices : Array[Int], +) -> Double { let usage1 = bio_isoform_calculate_usage(isoform1) let usage2 = bio_isoform_calculate_usage(isoform2) - + let mut sum_usage1_cond1 = 0.0 let mut sum_usage1_cond2 = 0.0 let mut sum_usage2_cond1 = 0.0 let mut sum_usage2_cond2 = 0.0 - + let len1 = condition1_indices.length() let mut i = 0 while i < len1 { @@ -100,7 +148,7 @@ pub fn bio_isoform_calculate_dpsi(isoform1 : IsoformExpression, isoform2 : Isofo } i = i + 1 } - + let len2 = condition2_indices.length() let mut j = 0 while j < len2 { @@ -111,26 +159,39 @@ pub fn bio_isoform_calculate_dpsi(isoform1 : IsoformExpression, isoform2 : Isofo } j = j + 1 } - + let total_cond1 = sum_usage1_cond1 + sum_usage2_cond1 let total_cond2 = sum_usage1_cond2 + sum_usage2_cond2 - - let psi1_cond1 = if total_cond1 > 0.0001 { sum_usage1_cond1 / total_cond1 } else { 0.5 } - let psi1_cond2 = if total_cond2 > 0.0001 { sum_usage1_cond2 / total_cond2 } else { 0.5 } - + + let psi1_cond1 = if total_cond1 > 0.0001 { + sum_usage1_cond1 / total_cond1 + } else { + 0.5 + } + let psi1_cond2 = if total_cond2 > 0.0001 { + sum_usage1_cond2 / total_cond2 + } else { + 0.5 + } + psi1_cond2 - psi1_cond1 } -pub fn bio_isoform_calculate_dif(isoform1 : IsoformExpression, isoform2 : IsoformExpression, - condition1_indices : Array[Int], condition2_indices : Array[Int]) -> Double { +///| +pub fn bio_isoform_calculate_dif( + isoform1 : IsoformExpression, + isoform2 : IsoformExpression, + condition1_indices : Array[Int], + condition2_indices : Array[Int], +) -> Double { let usage1 = bio_isoform_calculate_usage(isoform1) let usage2 = bio_isoform_calculate_usage(isoform2) - + let mut sum_psi_cond1 = 0.0 let mut count_psi_cond1 = 0 let mut sum_psi_cond2 = 0.0 let mut count_psi_cond2 = 0 - + let len1 = condition1_indices.length() let mut i = 0 while i < len1 { @@ -143,7 +204,7 @@ pub fn bio_isoform_calculate_dif(isoform1 : IsoformExpression, isoform2 : Isofor } i = i + 1 } - + let len2 = condition2_indices.length() let mut j = 0 while j < len2 { @@ -156,23 +217,42 @@ pub fn bio_isoform_calculate_dif(isoform1 : IsoformExpression, isoform2 : Isofor } j = j + 1 } - - let mean_cond1 = if count_psi_cond1 > 0 { sum_psi_cond1 / count_psi_cond1.to_double() } else { 0.5 } - let mean_cond2 = if count_psi_cond2 > 0 { sum_psi_cond2 / count_psi_cond2.to_double() } else { 0.5 } - + + let mean_cond1 = if count_psi_cond1 > 0 { + sum_psi_cond1 / count_psi_cond1.to_double() + } else { + 0.5 + } + let mean_cond2 = if count_psi_cond2 > 0 { + sum_psi_cond2 / count_psi_cond2.to_double() + } else { + 0.5 + } + mean_cond2 - mean_cond1 } -pub fn bio_isoform_find_switches(data : SwitchAnalyzeRlist, dpsi_threshold : Double, - pvalue_threshold : Double) -> Array[IsoformSwitch] { - let gene_to_isoforms : Map[String, Array[IsoformExpression]] = Map([], capacity=0) +///| +pub fn bio_isoform_find_switches( + data : SwitchAnalyzeRlist, + dpsi_threshold : Double, + pvalue_threshold : Double, +) -> Array[IsoformSwitch] { + let gene_to_isoforms : Map[String, Array[IsoformExpression]] = Map( + [], + capacity=0, + ) let gene_map = gene_to_isoforms - + let expr_len = data.isoform_expression.length() let mut i = 0 while i < expr_len { let isoform = data.isoform_expression[i] - let existing = if gene_map.contains(isoform.gene_id) { gene_map.get(isoform.gene_id).unwrap() } else { Array::new() } + let existing = if gene_map.contains(isoform.gene_id) { + gene_map.get(isoform.gene_id).unwrap() + } else { + Array::new() + } let ex_len = existing.length() let updated : Array[IsoformExpression] = Array::new() let mut j = 0 @@ -184,7 +264,7 @@ pub fn bio_isoform_find_switches(data : SwitchAnalyzeRlist, dpsi_threshold : Dou gene_map.set(isoform.gene_id, updated) i = i + 1 } - + let cond_len = data.conditions.length() let condition1_indices : Array[Int] = Array::new() let condition2_indices : Array[Int] = Array::new() @@ -197,15 +277,15 @@ pub fn bio_isoform_find_switches(data : SwitchAnalyzeRlist, dpsi_threshold : Dou } k = k + 1 } - + let mut all_switches : Array[IsoformSwitch] = Array::new() - + let entries = gene_map.iter().collect() let entries_len = entries.length() let mut l = 0 while l < entries_len { let (gene_id, isoforms) = entries[l] - + if isoforms.length() >= 2 { let iso_len = isoforms.length() let mut m = 0 @@ -214,19 +294,33 @@ pub fn bio_isoform_find_switches(data : SwitchAnalyzeRlist, dpsi_threshold : Dou while n < iso_len { let iso1 = isoforms[m] let iso2 = isoforms[n] - - let dpsi = bio_isoform_calculate_dpsi(iso1, iso2, condition1_indices, condition2_indices) - let dif = bio_isoform_calculate_dif(iso1, iso2, condition1_indices, condition2_indices) - - let pvalue = calculate_pvalue(dpsi, iso1, iso2, condition1_indices, condition2_indices) + + let dpsi = bio_isoform_calculate_dpsi( + iso1, iso2, condition1_indices, condition2_indices, + ) + let dif = bio_isoform_calculate_dif( + iso1, iso2, condition1_indices, condition2_indices, + ) + + let pvalue = calculate_pvalue( + dpsi, iso1, iso2, condition1_indices, condition2_indices, + ) let adjusted_pvalue = pvalue * entries_len.to_double() - + if dpsi.abs() >= dpsi_threshold && adjusted_pvalue <= pvalue_threshold { - let direction = if dpsi > 0.0 { "isoform1_up" } else { "isoform2_up" } + let direction = if dpsi > 0.0 { + "isoform1_up" + } else { + "isoform2_up" + } let consequences = predict_consequence(dpsi) - - let gene_name = if data.gene_annotation.contains(gene_id) { data.gene_annotation.get(gene_id).unwrap() } else { gene_id } - + + let gene_name = if data.gene_annotation.contains(gene_id) { + data.gene_annotation.get(gene_id).unwrap() + } else { + gene_id + } + let switch_len = all_switches.length() let new_switches : Array[IsoformSwitch] = Array::new() let mut o = 0 @@ -234,22 +328,32 @@ pub fn bio_isoform_find_switches(data : SwitchAnalyzeRlist, dpsi_threshold : Dou new_switches.push(all_switches[o]) o = o + 1 } - new_switches.push(IsoformSwitch::new( - gene_id, gene_name, iso1.isoform_id, iso2.isoform_id, - dpsi, dif, pvalue, adjusted_pvalue, direction, consequences - )) + new_switches.push( + IsoformSwitch::new( + gene_id, + gene_name, + iso1.isoform_id, + iso2.isoform_id, + dpsi, + dif, + pvalue, + adjusted_pvalue, + direction, + consequences, + ), + ) all_switches = new_switches } - + n = n + 1 } m = m + 1 } } - + l = l + 1 } - + let sw_len = all_switches.length() let mut sorted : Array[IsoformSwitch] = Array::new() let mut p = 0 @@ -257,7 +361,7 @@ pub fn bio_isoform_find_switches(data : SwitchAnalyzeRlist, dpsi_threshold : Dou sorted.push(all_switches[p]) p = p + 1 } - + let mut q = 0 while q < sw_len { let mut r = q + 1 @@ -282,20 +386,26 @@ pub fn bio_isoform_find_switches(data : SwitchAnalyzeRlist, dpsi_threshold : Dou } q = q + 1 } - + sorted } -fn calculate_pvalue(dpsi : Double, iso1 : IsoformExpression, iso2 : IsoformExpression, - cond1 : Array[Int], cond2 : Array[Int]) -> Double { +///| +fn calculate_pvalue( + dpsi : Double, + iso1 : IsoformExpression, + iso2 : IsoformExpression, + cond1 : Array[Int], + cond2 : Array[Int], +) -> Double { let usage1 = bio_isoform_calculate_usage(iso1) let usage2 = bio_isoform_calculate_usage(iso2) - + let mut sum_psi_cond1 = 0.0 let mut count_psi_cond1 = 0 let mut sum_psi_cond2 = 0.0 let mut count_psi_cond2 = 0 - + let len1 = cond1.length() let mut i = 0 while i < len1 { @@ -308,7 +418,7 @@ fn calculate_pvalue(dpsi : Double, iso1 : IsoformExpression, iso2 : IsoformExpre } i = i + 1 } - + let len2 = cond2.length() let mut j = 0 while j < len2 { @@ -321,14 +431,14 @@ fn calculate_pvalue(dpsi : Double, iso1 : IsoformExpression, iso2 : IsoformExpre } j = j + 1 } - + if count_psi_cond1 == 0 || count_psi_cond2 == 0 { return 1.0 } - + let mean1 = sum_psi_cond1 / count_psi_cond1.to_double() let mean2 = sum_psi_cond2 / count_psi_cond2.to_double() - + let mut var_sum1 = 0.0 let mut k = 0 while k < len1 { @@ -341,7 +451,7 @@ fn calculate_pvalue(dpsi : Double, iso1 : IsoformExpression, iso2 : IsoformExpre k = k + 1 } let var1 = var_sum1 / count_psi_cond1.to_double() - + let mut var_sum2 = 0.0 let mut l = 0 while l < len2 { @@ -354,23 +464,26 @@ fn calculate_pvalue(dpsi : Double, iso1 : IsoformExpression, iso2 : IsoformExpre l = l + 1 } let var2 = var_sum2 / count_psi_cond2.to_double() - - let variance_sum = var1 / count_psi_cond1.to_double() + var2 / count_psi_cond2.to_double() + + let variance_sum = var1 / count_psi_cond1.to_double() + + var2 / count_psi_cond2.to_double() let se = if variance_sum > 0.0 { variance_sum.sqrt() } else { 0.0 } - + if se < 0.0001 { let diff = mean2 - mean1 return if diff.abs() > 0.1 { 0.001 } else { 1.0 } } - + let t_stat = (mean2 - mean1) / se 2.0 * (1.0 - isoform_normal_cdf(t_stat.abs())) } +///| fn isoform_normal_cdf(x : Double) -> Double { 0.5 * (1.0 + isoform_erf(x / 2.0.sqrt())) } +///| fn isoform_erf(x : Double) -> Double { let a1 = 0.254829592 let a2 = -0.284496736 @@ -378,21 +491,25 @@ fn isoform_erf(x : Double) -> Double { let a4 = -1.453152027 let a5 = 1.061405429 let p = 0.3275911 - + let sign = if x < 0.0 { -1.0 } else { 1.0 } let abs_x = x.abs() - + let t = 1.0 / (1.0 + p * abs_x) - let y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * @math.exp(-abs_x * abs_x) - + let y = 1.0 - + ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * + t * + @math.exp(-abs_x * abs_x) + sign * y } +///| fn predict_consequence(dpsi : Double) -> Array[String] { let mut consequences : Array[String] = Array::new() - + let usage_diff = dpsi.abs() - + if usage_diff > 0.2 { let len = consequences.length() let new_arr : Array[String] = Array::new() @@ -404,7 +521,7 @@ fn predict_consequence(dpsi : Double) -> Array[String] { new_arr.push("significant_isoform_switch") consequences = new_arr } - + if dpsi > 0.3 { let len = consequences.length() let new_arr : Array[String] = Array::new() @@ -426,7 +543,7 @@ fn predict_consequence(dpsi : Double) -> Array[String] { new_arr.push("isoform2_increased") consequences = new_arr } - + let len = consequences.length() let new_arr : Array[String] = Array::new() let mut i = 0 @@ -438,16 +555,17 @@ fn predict_consequence(dpsi : Double) -> Array[String] { new_arr } +///| pub fn bio_isoform_switch_summary(switches : Array[IsoformSwitch]) -> String { let mut summary = "\nIsoform Switch Summary\n" summary = summary + "=".repeat(60) + "\n" - + let total = switches.length() let mut up_switches = 0 let mut down_switches = 0 let mut sum_dpsi = 0.0 let mut sum_padj = 0.0 - + let mut i = 0 while i < total { let s = switches[i] @@ -460,26 +578,31 @@ pub fn bio_isoform_switch_summary(switches : Array[IsoformSwitch]) -> String { sum_padj = sum_padj + s.adjusted_pvalue i = i + 1 } - + summary = summary + "Total switches: " + total.to_string() + "\n" summary = summary + "Isoform1 up: " + up_switches.to_string() + "\n" summary = summary + "Isoform2 up: " + down_switches.to_string() + "\n" - + let avg_dpsi = if total > 0 { sum_dpsi / total.to_double() } else { 0.0 } let avg_padj = if total > 0 { sum_padj / total.to_double() } else { 0.0 } - + summary = summary + "Average |dPSI|: " + avg_dpsi.to_string() + "\n" summary = summary + "Average adjusted p-value: " + avg_padj.to_string() + "\n" - + summary = summary + "\nTop 5 switches by significance:\n" summary = summary + "-".repeat(60) + "\n" - + let n = if total < 5 { total } else { 5 } let mut j = 0 while j < n { let s = switches[j] summary = summary + s.gene_name + "\n" - summary = summary + " dPSI: " + s.dpsi.to_string() + ", DIF: " + s.dif.to_string() + "\n" + summary = summary + + " dPSI: " + + s.dpsi.to_string() + + ", DIF: " + + s.dif.to_string() + + "\n" summary = summary + " padj: " + s.adjusted_pvalue.to_string() + "\n" summary = summary + " Direction: " + s.switch_direction + "\n" let consequences = s.consequence_type @@ -496,19 +619,30 @@ pub fn bio_isoform_switch_summary(switches : Array[IsoformSwitch]) -> String { summary = summary + " Consequences: " + c_str + "\n" j = j + 1 } - + summary } -pub fn bio_isoform_plot_psi(data : SwitchAnalyzeRlist, gene_id : String) -> String { - let gene_to_isoforms : Map[String, Array[IsoformExpression]] = Map([], capacity=0) +///| +pub fn bio_isoform_plot_psi( + data : SwitchAnalyzeRlist, + gene_id : String, +) -> String { + let gene_to_isoforms : Map[String, Array[IsoformExpression]] = Map( + [], + capacity=0, + ) let gene_map = gene_to_isoforms - + let expr_len = data.isoform_expression.length() let mut i = 0 while i < expr_len { let isoform = data.isoform_expression[i] - let existing = if gene_map.contains(isoform.gene_id) { gene_map.get(isoform.gene_id).unwrap() } else { Array::new() } + let existing = if gene_map.contains(isoform.gene_id) { + gene_map.get(isoform.gene_id).unwrap() + } else { + Array::new() + } let ex_len = existing.length() let updated : Array[IsoformExpression] = Array::new() let mut j = 0 @@ -520,32 +654,36 @@ pub fn bio_isoform_plot_psi(data : SwitchAnalyzeRlist, gene_id : String) -> Stri gene_map.set(isoform.gene_id, updated) i = i + 1 } - + if !gene_map.contains(gene_id) { return "\nGene " + gene_id + " not found\n" } - + let isoforms = gene_map.get(gene_id).unwrap() - let gene_name = if data.gene_annotation.contains(gene_id) { data.gene_annotation.get(gene_id).unwrap() } else { gene_id } - + let gene_name = if data.gene_annotation.contains(gene_id) { + data.gene_annotation.get(gene_id).unwrap() + } else { + gene_id + } + let mut plot = "\nPSI Plot for " + gene_name + " (" + gene_id + ")\n" plot = plot + "=".repeat(80) + "\n" - + let sample_len = data.samples.length() let mut k = 0 while k < sample_len { let sample = data.samples[k] let condition = data.conditions[k] - + plot = plot + sample + " (" + condition + "): " - + let iso_len = isoforms.length() let mut l = 0 while l < iso_len { let isoform = isoforms[l] let usage = bio_isoform_calculate_usage(isoform) let psi = if k < usage.length() { usage[k] } else { 0.0 } - + let mut total = 0.0 let mut m = 0 while m < iso_len { @@ -553,16 +691,16 @@ pub fn bio_isoform_plot_psi(data : SwitchAnalyzeRlist, gene_id : String) -> Stri total = total + (if k < u.length() { u[k] } else { 0.0 }) m = m + 1 } - + let norm_psi = if total > 0.0001 { psi / total * 100.0 } else { 0.0 } - + plot = plot + isoform.isoform_id + ": " + norm_psi.to_string() + "% " l = l + 1 } - + plot = plot + "\n" k = k + 1 } - + plot -} \ No newline at end of file +} diff --git a/src/jaspar.mbt b/src/jaspar.mbt index e3a440a4..3a9d617d 100644 --- a/src/jaspar.mbt +++ b/src/jaspar.mbt @@ -189,7 +189,10 @@ fn j_index_of(s : String, sub : String) -> Int { ///| /// Convert PFM to a position weight matrix (PWM) with log-odds scoring. /// Uses background frequency of 0.25 for each base. -pub fn JasparMatrix::to_pwm(self : JasparMatrix, pseudocount? : Double = 0.01) -> Array[Array[Double]] { +pub fn JasparMatrix::to_pwm( + self : JasparMatrix, + pseudocount? : Double = 0.01, +) -> Array[Array[Double]] { let pwm = Array::new() let bg = 0.25 let mut row = 0 @@ -198,7 +201,8 @@ pub fn JasparMatrix::to_pwm(self : JasparMatrix, pseudocount? : Double = 0.01) - let mut col = 0 while col < self.width { let total = get_col_total(self, col).to_double() - let freq = (self.pfm[row][col].to_double() + pseudocount) / (total + pseudocount * 4.0) + let freq = (self.pfm[row][col].to_double() + pseudocount) / + (total + pseudocount * 4.0) let score = @math.ln(freq / bg) / @math.ln(2.0) col_scores.push(score) col = col + 1 @@ -225,7 +229,8 @@ pub fn JasparMatrix::information_content(self : JasparMatrix) -> Array[Double] { } row = row + 1 } - let max_entropy = @math.ln(self.alphabet.length().to_double()) / @math.ln(2.0) + let max_entropy = @math.ln(self.alphabet.length().to_double()) / + @math.ln(2.0) ic.push(max_entropy - entropy) col = col + 1 } @@ -245,7 +250,10 @@ pub fn JasparMatrix::total_information(self : JasparMatrix) -> Double { ///| /// Scan a sequence with the PWM and return the best score. -pub fn JasparMatrix::scan_sequence(self : JasparMatrix, sequence : String) -> Array[(Int, Double, String)] { +pub fn JasparMatrix::scan_sequence( + self : JasparMatrix, + sequence : String, +) -> Array[(Int, Double, String)] { let pwm = self.to_pwm() let upper_seq = sequence.to_upper() let seq_len = upper_seq.length() @@ -294,7 +302,9 @@ fn find_base_index(matrix : JasparMatrix, base : String) -> Int { ///| /// Sort scanning results by score (descending). -pub fn jaspar_sort_results(results : Array[(Int, Double, String)]) -> Array[(Int, Double, String)] { +pub fn jaspar_sort_results( + results : Array[(Int, Double, String)], +) -> Array[(Int, Double, String)] { let sorted = results let mut i = 0 while i < sorted.length() - 1 { @@ -429,7 +439,10 @@ fn parse_int_array(s : String) -> Array[Int] { ///| /// Get a specific matrix by ID from an array of matrices. -pub fn jaspar_get_matrix(matrices : Array[JasparMatrix], id : String) -> JasparMatrix { +pub fn jaspar_get_matrix( + matrices : Array[JasparMatrix], + id : String, +) -> JasparMatrix { for m in matrices { if m.id == id { return m @@ -442,7 +455,10 @@ pub fn jaspar_get_matrix(matrices : Array[JasparMatrix], id : String) -> JasparM ///| /// Filter matrices by collection. -pub fn jaspar_filter_by_collection(matrices : Array[JasparMatrix], collection : String) -> Array[JasparMatrix] { +pub fn jaspar_filter_by_collection( + matrices : Array[JasparMatrix], + collection : String, +) -> Array[JasparMatrix] { let result : Array[JasparMatrix] = Array::new() for m in matrices { if m.collection == collection { @@ -454,7 +470,10 @@ pub fn jaspar_filter_by_collection(matrices : Array[JasparMatrix], collection : ///| /// Filter matrices by name pattern (case-insensitive substring match). -pub fn jaspar_filter_by_name(matrices : Array[JasparMatrix], pattern : String) -> Array[JasparMatrix] { +pub fn jaspar_filter_by_name( + matrices : Array[JasparMatrix], + pattern : String, +) -> Array[JasparMatrix] { let result : Array[JasparMatrix] = Array::new() let upper_pattern = pattern.to_upper() for m in matrices { diff --git a/src/karyoploter.mbt b/src/karyoploter.mbt index b2a20f17..f6bf1990 100644 --- a/src/karyoploter.mbt +++ b/src/karyoploter.mbt @@ -126,13 +126,17 @@ pub fn KaryotypePlot::new(genome : String) -> KaryotypePlot { // Set up default human chromosomes if genome == "hg38" || genome == "hg19" || genome == "human" { - let chroms = ["chr1", "chr2", "chr3", "chr4", "chr5", "chr6", "chr7", "chr8", - "chr9", "chr10", "chr11", "chr12", "chr13", "chr14", "chr15", "chr16", - "chr17", "chr18", "chr19", "chr20", "chr21", "chr22", "chrX", "chrY"] - let sizes = [248956422, 242193529, 198295559, 190214555, 181538259, 170805979, - 159345973, 145138636, 138394717, 133797422, 135086622, 133275309, - 114364328, 107043718, 101991189, 90338345, 83257441, 80373285, 58617616, - 64444167, 46709983, 50818468, 156040895, 57227415] + let chroms = [ + "chr1", "chr2", "chr3", "chr4", "chr5", "chr6", "chr7", "chr8", "chr9", "chr10", + "chr11", "chr12", "chr13", "chr14", "chr15", "chr16", "chr17", "chr18", "chr19", + "chr20", "chr21", "chr22", "chrX", "chrY", + ] + let sizes = [ + 248956422, 242193529, 198295559, 190214555, 181538259, 170805979, 159345973, + 145138636, 138394717, 133797422, 135086622, 133275309, 114364328, 107043718, + 101991189, 90338345, 83257441, 80373285, 58617616, 64444167, 46709983, 50818468, + 156040895, 57227415, + ] let mut i = 0 while i < chroms.length() { @@ -167,7 +171,10 @@ pub fn KaryotypePlot::get_chromosomes(plot : KaryotypePlot) -> Array[String] { ///| /// Get chromosome size. -pub fn KaryotypePlot::get_chromosome_size(plot : KaryotypePlot, chr : String) -> Int { +pub fn KaryotypePlot::get_chromosome_size( + plot : KaryotypePlot, + chr : String, +) -> Int { match plot.chromosome_sizes.get(chr) { Some(s) => s None => 0 @@ -188,7 +195,10 @@ pub fn KaryotypePlot::get_n_regions(plot : KaryotypePlot) -> Int { ///| /// Add a track to the karyotype plot. -pub fn KaryotypePlot::add_track(plot : KaryotypePlot, track : KaryotypeTrack) -> KaryotypePlot { +pub fn KaryotypePlot::add_track( + plot : KaryotypePlot, + track : KaryotypeTrack, +) -> KaryotypePlot { let tracks = plot.tracks.copy() tracks.push(track) KaryotypePlot::{ @@ -204,7 +214,10 @@ pub fn KaryotypePlot::add_track(plot : KaryotypePlot, track : KaryotypeTrack) -> ///| /// Add a region to the karyotype plot. -pub fn KaryotypePlot::add_region(plot : KaryotypePlot, region : KaryotypeRegion) -> KaryotypePlot { +pub fn KaryotypePlot::add_region( + plot : KaryotypePlot, + region : KaryotypeRegion, +) -> KaryotypePlot { let regions = plot.regions.copy() regions.push(region) KaryotypePlot::{ @@ -220,7 +233,14 @@ pub fn KaryotypePlot::add_region(plot : KaryotypePlot, region : KaryotypeRegion) ///| /// Create a new track. -pub fn KaryotypeTrack::new(track_id : String, track_type : TrackType, chromosome : String, start : Int, end : Int, label : String) -> KaryotypeTrack { +pub fn KaryotypeTrack::new( + track_id : String, + track_type : TrackType, + chromosome : String, + start : Int, + end : Int, + label : String, +) -> KaryotypeTrack { KaryotypeTrack::{ track_id, track_type, @@ -237,7 +257,10 @@ pub fn KaryotypeTrack::new(track_id : String, track_type : TrackType, chromosome ///| /// Add a data point to a track. -pub fn KaryotypeTrack::add_point(track : KaryotypeTrack, point : TrackPoint) -> KaryotypeTrack { +pub fn KaryotypeTrack::add_point( + track : KaryotypeTrack, + point : TrackPoint, +) -> KaryotypeTrack { let data = track.data.copy() data.push(point) KaryotypeTrack::{ @@ -256,25 +279,45 @@ pub fn KaryotypeTrack::add_point(track : KaryotypeTrack, point : TrackPoint) -> ///| /// Create a new track point. -pub fn TrackPoint::new(chromosome : String, position : Int, value : Double, label : String) -> TrackPoint { +pub fn TrackPoint::new( + chromosome : String, + position : Int, + value : Double, + label : String, +) -> TrackPoint { TrackPoint::{ chromosome, position, value, label } } ///| /// Create a new karyotype region. -pub fn KaryotypeRegion::new(chromosome : String, start : Int, end : Int, label : String, color : String) -> KaryotypeRegion { +pub fn KaryotypeRegion::new( + chromosome : String, + start : Int, + end : Int, + label : String, + color : String, +) -> KaryotypeRegion { KaryotypeRegion::{ chromosome, start, end, label, color } } ///| /// Create a new ideogram band. -pub fn IdeogramBand::new(chromosome : String, start : Int, end : Int, band_name : String, stain : String) -> IdeogramBand { +pub fn IdeogramBand::new( + chromosome : String, + start : Int, + end : Int, + band_name : String, + stain : String, +) -> IdeogramBand { IdeogramBand::{ chromosome, start, end, band_name, stain } } ///| /// Set track color. -pub fn KaryotypeTrack::set_color(track : KaryotypeTrack, color : String) -> KaryotypeTrack { +pub fn KaryotypeTrack::set_color( + track : KaryotypeTrack, + color : String, +) -> KaryotypeTrack { KaryotypeTrack::{ track_id: track.track_id, track_type: track.track_type, @@ -291,7 +334,11 @@ pub fn KaryotypeTrack::set_color(track : KaryotypeTrack, color : String) -> Kary ///| /// Set track y-range. -pub fn KaryotypeTrack::set_y_range(track : KaryotypeTrack, y_min : Double, y_max : Double) -> KaryotypeTrack { +pub fn KaryotypeTrack::set_y_range( + track : KaryotypeTrack, + y_min : Double, + y_max : Double, +) -> KaryotypeTrack { KaryotypeTrack::{ track_id: track.track_id, track_type: track.track_type, @@ -320,7 +367,10 @@ pub fn KaryotypeTrack::get_n_points(track : KaryotypeTrack) -> Int { ///| /// Filter a track to a specific chromosome. -pub fn KaryotypeTrack::filter_chromosome(track : KaryotypeTrack, chr : String) -> KaryotypeTrack { +pub fn KaryotypeTrack::filter_chromosome( + track : KaryotypeTrack, + chr : String, +) -> KaryotypeTrack { let filtered : Array[TrackPoint] = Array::new() let mut i = 0 while i < track.data.length() { @@ -345,7 +395,11 @@ pub fn KaryotypeTrack::filter_chromosome(track : KaryotypeTrack, chr : String) - ///| /// Generate an ASCII representation of the karyotype plot. -pub fn KaryotypePlot::to_ascii(plot : KaryotypePlot, chr : String, width : Int) -> String { +pub fn KaryotypePlot::to_ascii( + plot : KaryotypePlot, + chr : String, + width : Int, +) -> String { let w = if width < 40 { 60 } else { width } let chr_size = plot.get_chromosome_size(chr) if chr_size == 0 { @@ -353,7 +407,12 @@ pub fn KaryotypePlot::to_ascii(plot : KaryotypePlot, chr : String, width : Int) } let mut result = "=== Karyotype Plot: " + plot.genome + " ===\n" - result = result + "Chromosome: " + chr + " (size: " + chr_size.to_string() + " bp)\n" + result = result + + "Chromosome: " + + chr + + " (size: " + + chr_size.to_string() + + " bp)\n" // Draw ideogram bar let mut bar = "" @@ -365,7 +424,10 @@ pub fn KaryotypePlot::to_ascii(plot : KaryotypePlot, chr : String, width : Int) result = result + bar + "\n" // Draw centromere marker - let centromere_pos = ((chr_size.to_double() / 2.0) / chr_size.to_double() * (w.to_double() - 1.0)).to_int() + let centromere_pos = (chr_size.to_double() / + 2.0 / + chr_size.to_double() * + (w.to_double() - 1.0)).to_int() let mut cent_bar = "" let mut j = 0 while j < w { @@ -382,7 +444,7 @@ pub fn KaryotypePlot::to_ascii(plot : KaryotypePlot, chr : String, width : Int) let mut ticks = "" let mut k = 0 while k < w { - if k == 0 || k == (w / 4) || k == (w / 2) || k == (3 * w / 4) || k == w - 1 { + if k == 0 || k == w / 4 || k == w / 2 || k == 3 * w / 4 || k == w - 1 { ticks = ticks + "|" } else { ticks = ticks + "-" @@ -407,7 +469,12 @@ pub fn KaryotypePlot::to_ascii(plot : KaryotypePlot, chr : String, width : Int) while track_idx < plot.tracks.length() { let track = plot.tracks[track_idx] if track.chromosome == chr { - result = result + "Track: " + track.label + " (" + track.track_type.to_string() + ")\n" + result = result + + "Track: " + + track.label + + " (" + + track.track_type.to_string() + + ")\n" let mut data_bar = "" let mut m = 0 while m < w { @@ -419,11 +486,23 @@ pub fn KaryotypePlot::to_ascii(plot : KaryotypePlot, chr : String, width : Int) let mut p = 0 while p < track.data.length() { let pt = track.data[p] - let rel_pos = (pt.position.to_double() / chr_size.to_double() * (w.to_double() - 1.0)).to_int() + let rel_pos = (pt.position.to_double() / + chr_size.to_double() * + (w.to_double() - 1.0)).to_int() let value = (pt.value - track.y_min) / (track.y_max - track.y_min) if rel_pos >= 0 && rel_pos < w { - let ch = if value > 0.75 { "#" } else if value > 0.5 { "+" } else if value > 0.25 { "o" } else { "." } - data_bar = data_bar.substring(start=0, end=rel_pos).to_string() + ch + data_bar.substring(start=rel_pos + 1, end=w).to_string() + let ch = if value > 0.75 { + "#" + } else if value > 0.5 { + "+" + } else if value > 0.25 { + "o" + } else { + "." + } + data_bar = data_bar.substring(start=0, end=rel_pos).to_string() + + ch + + data_bar.substring(start=rel_pos + 1, end=w).to_string() } p = p + 1 } @@ -449,7 +528,12 @@ pub fn KaryotypePlot::summary(plot : KaryotypePlot) -> String { let total_bp = 0 while i < plot.chromosomes.length() { let chr = plot.chromosomes[i] - s = s + " " + chr + ": " + plot.get_chromosome_size(chr).to_string() + " bp\n" + s = s + + " " + + chr + + ": " + + plot.get_chromosome_size(chr).to_string() + + " bp\n" i = i + 1 } s @@ -461,32 +545,53 @@ pub fn karyotype_sample() -> KaryotypePlot { let plot = KaryotypePlot::new("hg38") // Add some sample data tracks - let mut gc_track = KaryotypeTrack::new("gc_content", TrackType::Lines, "chr1", 0, 248956422, "GC Content") + let mut gc_track = KaryotypeTrack::new( + "gc_content", + TrackType::Lines, + "chr1", + 0, + 248956422, + "GC Content", + ) gc_track = gc_track.set_color("#FF6600") let mut i = 0 while i < 50 { let pos = i * 497913 - let value = 0.35 + 0.15 * ((i.to_double() / 50.0) * 2.0 - 1.0) * ((i.to_double() / 50.0) * 2.0 - 1.0) + let value = 0.35 + + 0.15 * + (i.to_double() / 50.0 * 2.0 - 1.0) * + (i.to_double() / 50.0 * 2.0 - 1.0) gc_track = gc_track.add_point(TrackPoint::new("chr1", pos, value, "")) i = i + 1 } // Add a second track - let mut snp_track = KaryotypeTrack::new("snp_density", TrackType::Bars, "chr1", 0, 248956422, "SNP Density") + let mut snp_track = KaryotypeTrack::new( + "snp_density", + TrackType::Bars, + "chr1", + 0, + 248956422, + "SNP Density", + ) snp_track = snp_track.set_color("#003399") let mut j = 0 while j < 30 { let pos = j * 829854 - let value = 0.2 + 0.6 * ((j.to_double() / 30.0)) + let value = 0.2 + 0.6 * (j.to_double() / 30.0) snp_track = snp_track.add_point(TrackPoint::new("chr1", pos, value, "")) j = j + 1 } // Add regions of interest - let region1 = KaryotypeRegion::new("chr1", 11000000, 12000000, "BRCA2 region", "#FF0000") - let region2 = KaryotypeRegion::new("chr1", 28000000, 30000000, "TP53 region", "#00FF00") + let region1 = KaryotypeRegion::new( + "chr1", 11000000, 12000000, "BRCA2 region", "#FF0000", + ) + let region2 = KaryotypeRegion::new( + "chr1", 28000000, 30000000, "TP53 region", "#00FF00", + ) let mut result = plot result = result.add_track(gc_track) @@ -495,4 +600,4 @@ pub fn karyotype_sample() -> KaryotypePlot { result = result.add_region(region2) result -} \ No newline at end of file +} diff --git a/src/kgml.mbt b/src/kgml.mbt index 9e617a66..cd76323f 100644 --- a/src/kgml.mbt +++ b/src/kgml.mbt @@ -103,20 +103,8 @@ pub struct KgmlEntry { ///| /// Create a pathway entry. -pub fn KgmlEntry::new( - id : Int, - name : String, - etype : String, -) -> KgmlEntry { - { - id, - name, - etype, - reaction: "", - link: "", - graphics: None, - components: [], - } +pub fn KgmlEntry::new(id : Int, name : String, etype : String) -> KgmlEntry { + { id, name, etype, reaction: "", link: "", graphics: None, components: [] } } ///| @@ -361,7 +349,9 @@ pub fn KgmlPathway::reactions(self : KgmlPathway) -> Array[KgmlReaction] { /// Get entry by ID. pub fn KgmlPathway::get_entry(self : KgmlPathway, id : Int) -> KgmlEntry? { for e in self.entries { - if e.id == id { return Some(e) } + if e.id == id { + return Some(e) + } } None } @@ -374,7 +364,9 @@ pub fn KgmlPathway::get_entries_by_type( ) -> Array[KgmlEntry] { let result : Array[KgmlEntry] = [] for e in self.entries { - if e.etype == etype { result.push(e) } + if e.etype == etype { + result.push(e) + } } result } @@ -387,7 +379,9 @@ pub fn KgmlPathway::get_relations_for_entry( ) -> Array[KgmlRelation] { let result : Array[KgmlRelation] = [] for r in self.relations { - if r.entry1 == id || r.entry2 == id { result.push(r) } + if r.entry1 == id || r.entry2 == id { + result.push(r) + } } result } @@ -401,7 +395,9 @@ pub fn KgmlPathway::get_relations_for_entry( fn kgml_find_from(s : String, sub : String, from : Int) -> Int? { let n = s.length() let sub_len = sub.length() - if sub_len == 0 || from >= n { return None } + if sub_len == 0 || from >= n { + return None + } let mut i = from while i + sub_len <= n { let mut match_found = true @@ -413,7 +409,9 @@ fn kgml_find_from(s : String, sub : String, from : Int) -> Int? { } j = j + 1 } - if match_found { return Some(i) } + if match_found { + return Some(i) + } i = i + 1 } None @@ -451,18 +449,24 @@ fn kgml_attr(tag : String, attr_name : String) -> String { ///| /// Parse an integer from a string, returning default on failure. fn kgml_parse_int(s : String, default : Int) -> Int { - if s.length() == 0 { return default } + if s.length() == 0 { + return default + } let trimmed = s.trim().to_owned() let result = parse_int(trimmed) // parse_int returns 0 on failure; distinguish empty from real 0 - if trimmed.length() == 0 { return default } + if trimmed.length() == 0 { + return default + } result } ///| /// Parse a double from a string, returning default on failure. fn kgml_parse_double(s : String, default : Double) -> Double { - if s.length() == 0 { return default } + if s.length() == 0 { + return default + } let trimmed = s.trim().to_owned() match parse_double(trimmed) { Some(d) => d @@ -478,7 +482,11 @@ fn kgml_attr_int(tag : String, attr_name : String, default : Int) -> Int { ///| /// Extract a double XML attribute, returns default if not found. -fn kgml_attr_double(tag : String, attr_name : String, default : Double) -> Double { +fn kgml_attr_double( + tag : String, + attr_name : String, + default : Double, +) -> Double { kgml_parse_double(kgml_attr(tag, attr_name), default) } @@ -506,7 +514,7 @@ pub fn parse_kgml(content : String) -> KgmlPathway? { let pathway_start = content.find(" None - Some(ps) => { + Some(ps) => match kgml_find_from(content, ">", ps) { None => None Some(te) => { @@ -530,7 +538,6 @@ pub fn parse_kgml(content : String) -> KgmlPathway? { Some(pathway) } } - } } } @@ -550,7 +557,7 @@ fn kgml_parse_children( None => break Some(lt_pos) => { if lt_pos + 1 < n { - let next_ch = content[lt_pos + 1 : lt_pos + 2].to_owned() + let next_ch = content[lt_pos + 1:lt_pos + 2].to_owned() if next_ch == "/" || next_ch == "?" || next_ch == "!" { match kgml_find_from(content, ">", lt_pos) { None => break @@ -570,13 +577,12 @@ fn kgml_parse_children( let space_idx = tag_content.find(" ") let elem_name : String = match space_idx { Some(sp) => tag_content[1:sp].trim().to_owned() - None => { + None => if self_closing { tag_content[1:tag_content.length() - 1].trim().to_owned() } else { tag_content[1:].trim().to_owned() } - } } if elem_name == "entry" { let entry = kgml_parse_entry(content, lt_pos, g, self_closing) @@ -630,7 +636,7 @@ fn kgml_parse_entry( while pos < end_pos { match kgml_find_from(content, "<", pos) { None => break - Some(lp) => { + Some(lp) => match kgml_find_from(content, ">", lp) { None => break Some(gp) => { @@ -645,7 +651,6 @@ fn kgml_parse_entry( pos = gp + 1 } } - } } } } @@ -690,7 +695,7 @@ fn kgml_parse_relation( while pos < end_pos { match kgml_find_from(content, "<", pos) { None => break - Some(lp) => { + Some(lp) => match kgml_find_from(content, ">", lp) { None => break Some(gp) => { @@ -703,7 +708,6 @@ fn kgml_parse_relation( pos = gp + 1 } } - } } } } @@ -731,7 +735,7 @@ fn kgml_parse_reaction( while pos < end_pos { match kgml_find_from(content, "<", pos) { None => break - Some(lp) => { + Some(lp) => match kgml_find_from(content, ">", lp) { None => break Some(gp) => { @@ -746,7 +750,6 @@ fn kgml_parse_reaction( pos = gp + 1 } } - } } } } @@ -768,13 +771,15 @@ pub fn kgml_sample_pathway() -> String { s = s + " image=\"https://www.kegg.jp/kegg/pathway/ko/ko00010.png\"" s = s + " link=\"https://www.kegg.jp/kegg-bin/show_pathway?ko00010\">\n" // Entry 1: gene K00844 - s = s + "" s = s + "" s = s + "\n" // Entry 2: gene K01810 - s = s + "" s = s + "" @@ -786,7 +791,8 @@ pub fn kgml_sample_pathway() -> String { s = s + " type=\"circle\" x=\"150\" y=\"250\" width=\"8\" height=\"8\"/>" s = s + "\n" // Entry 4: gene K01623 - s = s + "" s = s + "" diff --git a/src/kmer.mbt b/src/kmer.mbt index ff8f8971..0a10ce98 100644 --- a/src/kmer.mbt +++ b/src/kmer.mbt @@ -10,18 +10,17 @@ pub struct BioKmerCounter { ///| pub fn BioKmerCounter::new(k : Int) -> BioKmerCounter { - BioKmerCounter::{ - k, - counts: Map([], capacity=1000), - sequence: "" - } + BioKmerCounter::{ k, counts: Map([], capacity=1000), sequence: "" } } ///| -pub fn BioKmerCounter::count_kmers(self : BioKmerCounter, seq : String) -> BioKmerCounter { +pub fn BioKmerCounter::count_kmers( + self : BioKmerCounter, + seq : String, +) -> BioKmerCounter { let n = seq.length() - self.k + 1 let counts = self.counts.copy() - + let mut i = 0 while i < n { let kmer = substring(seq, i, self.k) @@ -32,8 +31,8 @@ pub fn BioKmerCounter::count_kmers(self : BioKmerCounter, seq : String) -> BioKm } i = i + 1 } - - BioKmerCounter::{ k: self.k, counts: counts, sequence: seq } + + BioKmerCounter::{ k: self.k, counts, sequence: seq } } ///| @@ -60,7 +59,10 @@ pub fn BioKmerCounter::unique_kmers(self : BioKmerCounter) -> Int { } ///| -pub fn BioKmerCounter::frequency(self : BioKmerCounter, kmer : String) -> Double { +pub fn BioKmerCounter::frequency( + self : BioKmerCounter, + kmer : String, +) -> Double { let total = self.total_kmers() if total == 0 { 0.0 @@ -70,12 +72,15 @@ pub fn BioKmerCounter::frequency(self : BioKmerCounter, kmer : String) -> Double } ///| -pub fn BioKmerCounter::get_top_kmers(self : BioKmerCounter, n : Int) -> Array[(String, Int)] { +pub fn BioKmerCounter::get_top_kmers( + self : BioKmerCounter, + n : Int, +) -> Array[(String, Int)] { let items : Array[(String, Int)] = Array::new() for key in self.counts.keys() { items.push((key, self.counts.get(key).unwrap())) } - + let mut swapped = true let mut j = 0 while swapped { @@ -92,35 +97,38 @@ pub fn BioKmerCounter::get_top_kmers(self : BioKmerCounter, n : Int) -> Array[(S i = i + 1 } } - + let result : Array[(String, Int)] = Array::new() let mut k = 0 while k < n && k < items.length() { result.push(items[k]) k = k + 1 } - + result } ///| -pub fn BioKmerCounter::jaccard(self : BioKmerCounter, other : BioKmerCounter) -> Double { +pub fn BioKmerCounter::jaccard( + self : BioKmerCounter, + other : BioKmerCounter, +) -> Double { let mut intersection = 0 let mut union = 0 - + for key in self.counts.keys() { if other.counts.contains(key) { intersection = intersection + 1 } union = union + 1 } - + for key in other.counts.keys() { if !self.counts.contains(key) { union = union + 1 } } - + if union == 0 { 0.0 } else { @@ -129,21 +137,24 @@ pub fn BioKmerCounter::jaccard(self : BioKmerCounter, other : BioKmerCounter) -> } ///| -pub fn BioKmerCounter::hamming_distance(self : BioKmerCounter, other : BioKmerCounter) -> Int { +pub fn BioKmerCounter::hamming_distance( + self : BioKmerCounter, + other : BioKmerCounter, +) -> Int { let mut distance = 0 - + for key in self.counts.keys() { let diff = self.counts.get(key).unwrap() - other.count(key) let abs_diff = if diff > 0 { diff } else { -diff } distance = distance + abs_diff } - + for key in other.counts.keys() { if !self.counts.contains(key) { distance = distance + other.count(key) } } - + distance } @@ -155,7 +166,11 @@ pub struct KmerFrequency { } ///| -pub fn KmerFrequency::new(kmer : String, count : Int, frequency : Double) -> KmerFrequency { +pub fn KmerFrequency::new( + kmer : String, + count : Int, + frequency : Double, +) -> KmerFrequency { KmerFrequency::{ kmer, count, frequency } } @@ -169,7 +184,7 @@ pub fn bio_count_kmers(seq : String, k : Int) -> Map[String, Int] { ///| pub fn kmer_spectrum(seq : String, min_k : Int, max_k : Int) -> Array[Int] { let spectrum : Array[Int] = Array::new() - + let mut k = min_k while k <= max_k { let counter = BioKmerCounter::new(k) @@ -177,7 +192,7 @@ pub fn kmer_spectrum(seq : String, min_k : Int, max_k : Int) -> Array[Int] { spectrum.push(counter.unique_kmers()) k = k + 1 } - + spectrum } @@ -186,4 +201,4 @@ pub fn create_example_kmer_counter() -> BioKmerCounter { let counter = BioKmerCounter::new(3) let counter = counter.count_kmers("ATCGATCGATCG") counter -} \ No newline at end of file +} diff --git a/src/limma.mbt b/src/limma.mbt index 58d007b9..b896e2d4 100644 --- a/src/limma.mbt +++ b/src/limma.mbt @@ -1292,7 +1292,8 @@ pub fn limma_remove_batch_effect( xty_data[k] = xty_data[k] + x_jk * y_row[j] let mut l = 0 while l < n_design { - xtx_data[k * n_design + l] = xtx_data[k * n_design + l] + x_jk * design.get(j, l) + xtx_data[k * n_design + l] = xtx_data[k * n_design + l] + + x_jk * design.get(j, l) l = l + 1 } k = k + 1 @@ -1337,7 +1338,11 @@ fn find_batch_index(label : String, unique : Array[String]) -> Int { ///| /// Solve linear system Ax = b using Gaussian elimination. -fn solve_linear_system(a_data : Array[Double], b : Array[Double], n : Int) -> Array[Double] { +fn solve_linear_system( + a_data : Array[Double], + b : Array[Double], + n : Int, +) -> Array[Double] { // Create augmented matrix let aug_data = Array::make(n * (n + 1), 0.0) let mut i = 0 @@ -1391,7 +1396,8 @@ fn solve_linear_system(a_data : Array[Double], b : Array[Double], n : Int) -> Ar let factor = aug_data[k * (n + 1) + i] / pivot let mut j = i while j <= n { - aug_data[k * (n + 1) + j] = aug_data[k * (n + 1) + j] - factor * aug_data[i * (n + 1) + j] + aug_data[k * (n + 1) + j] = aug_data[k * (n + 1) + j] - + factor * aug_data[i * (n + 1) + j] j = j + 1 } k = k + 1 @@ -1412,7 +1418,9 @@ fn solve_linear_system(a_data : Array[Double], b : Array[Double], n : Int) -> Ar } let pivot = aug_data[i * (n + 1) + i] x[i] = if pivot.abs() < 1.0e-10 { 0.0 } else { sum / pivot } - if i == 0 { break } + if i == 0 { + break + } i = i - 1 } @@ -1427,7 +1435,11 @@ fn solve_linear_system(a_data : Array[Double], b : Array[Double], n : Int) -> Ar /// - lfc: log2 fold-change threshold (default 0) /// - direction: "up", "down", or "both" (default "both") /// Returns updated EBayesResult with one-sided p-values and B-values. -pub fn treat(fit : EBayesResult, lfc : Double, direction : String) -> EBayesResult { +pub fn treat( + fit : EBayesResult, + lfc : Double, + direction : String, +) -> EBayesResult { let n_genes = fit.coefficients.rows let n_coefs = fit.coefficients.cols @@ -1443,16 +1455,15 @@ pub fn treat(fit : EBayesResult, lfc : Double, direction : String) -> EBayesResu let beta = fit.coefficients.get(i, j) let se = fit.stdev_unscaled.get(i, j) * fit.sigma[i] - let t_val = if se > 0.0 { - (beta - lfc) / se - } else { - 0.0 - } + let t_val = if se > 0.0 { (beta - lfc) / se } else { 0.0 } let p_val = if direction == "up" { // P(T > t_val) for one-sided if t_val > 0.0 { - let f_val = t_val * t_val * (df_total + 1.0) / (df_total + t_val * t_val) + let f_val = t_val * + t_val * + (df_total + 1.0) / + (df_total + t_val * t_val) 1.0 - pf(f_val, 1.0, df_total) } else { 1.0 @@ -1461,23 +1472,33 @@ pub fn treat(fit : EBayesResult, lfc : Double, direction : String) -> EBayesResu // P(T < t_val) for one-sided if t_val < 0.0 { let t_abs = t_val.abs() - let f_val = t_abs * t_abs * (df_total + 1.0) / (df_total + t_abs * t_abs) + let f_val = t_abs * + t_abs * + (df_total + 1.0) / + (df_total + t_abs * t_abs) 1.0 - pf(f_val, 1.0, df_total) } else { 1.0 } - } else { // Two-sided - if se > 0.0 { - let t_abs = t_val.abs() - let f_val = t_abs * t_abs * (df_total + 1.0) / (df_total + t_abs * t_abs) - 2.0 * (1.0 - pf(f_val, 1.0, df_total)) - } else { - 1.0 - } + } else if se > 0.0 { + let t_abs = t_val.abs() + let f_val = t_abs * + t_abs * + (df_total + 1.0) / + (df_total + t_abs * t_abs) + 2.0 * (1.0 - pf(f_val, 1.0, df_total)) + } else { + 1.0 } - let p = if p_val.is_nan() || p_val < 0.0 { 0.0 } else if p_val > 1.0 { 1.0 } else { p_val } + let p = if p_val.is_nan() || p_val < 0.0 { + 0.0 + } else if p_val > 1.0 { + 1.0 + } else { + p_val + } // B-value (log-odds of differential expression) let b = if p > 0.0 && p < 1.0 { @@ -1773,7 +1794,11 @@ pub fn limma_quantile_normalize(y : Matrix) -> Matrix { } let avg_rank = (rank + end_rank).to_double() / 2.0 let rank_floor = avg_rank.to_int() - let rank_ceil = if rank_floor + 1 < n_genes { rank_floor + 1 } else { n_genes - 1 } + let rank_ceil = if rank_floor + 1 < n_genes { + rank_floor + 1 + } else { + n_genes - 1 + } let frac = avg_rank - rank_floor.to_double() let val = if rank_floor == rank_ceil { @@ -1899,7 +1924,8 @@ pub fn limma_combat( while i < n_genes { let offset = batch_offset[i] // Weighted average: combine batch offset with prior (0) - let shrunken = offset * batch_size.to_double() / + let shrunken = offset * + batch_size.to_double() / (batch_size.to_double() + offset / prior_var.abs()) // Subtract shrunken batch offset from batch samples @@ -1923,7 +1949,9 @@ pub fn limma_combat( ///| /// Compute mean of an array (helper for limma module). fn limma_stat_mean(data : Array[Double]) -> Double { - if data.length() == 0 { return 0.0 } + if data.length() == 0 { + return 0.0 + } let mut sum = 0.0 for v in data { sum = sum + v @@ -1935,7 +1963,9 @@ fn limma_stat_mean(data : Array[Double]) -> Double { /// Compute variance of an array (helper for limma module). fn limma_stat_variance(data : Array[Double]) -> Double { let n = data.length() - if n <= 1 { return 0.0 } + if n <= 1 { + return 0.0 + } let mean = limma_stat_mean(data) let mut sum_sq = 0.0 for v in data { diff --git a/src/lisaclust.mbt b/src/lisaclust.mbt index 579f513a..7f082df1 100644 --- a/src/lisaclust.mbt +++ b/src/lisaclust.mbt @@ -376,28 +376,26 @@ pub fn LisaResult::top_enrichments( selected.push(entry) } } - selected.sort_by( - fn( - left : LisaRegionEnrichment, - right : LisaRegionEnrichment, - ) -> Int { - if left.relative_frequency > right.relative_frequency { - -1 - } else if left.relative_frequency < right.relative_frequency { - 1 - } else if left.region < right.region { - -1 - } else if left.region > right.region { - 1 - } else if left.cell_type < right.cell_type { - -1 - } else if left.cell_type > right.cell_type { - 1 - } else { - 0 - } - }, - ) + selected.sort_by(fn( + left : LisaRegionEnrichment, + right : LisaRegionEnrichment, + ) -> Int { + if left.relative_frequency > right.relative_frequency { + -1 + } else if left.relative_frequency < right.relative_frequency { + 1 + } else if left.region < right.region { + -1 + } else if left.region > right.region { + 1 + } else if left.cell_type < right.cell_type { + -1 + } else if left.cell_type > right.cell_type { + 1 + } else { + 0 + } + }) let output : Array[LisaRegionEnrichment] = [] for index in 0.. Array[(Double, Double)] { let sorted = points.copy() - sorted.sort_by( - fn(left : (Double, Double), right : (Double, Double)) -> Int { - if left.0 < right.0 { - -1 - } else if left.0 > right.0 { - 1 - } else if left.1 < right.1 { - -1 - } else if left.1 > right.1 { - 1 - } else { - 0 - } - }, - ) + sorted.sort_by(fn(left : (Double, Double), right : (Double, Double)) -> Int { + if left.0 < right.0 { + -1 + } else if left.0 > right.0 { + 1 + } else if left.1 < right.1 { + -1 + } else if left.1 > right.1 { + 1 + } else { + 0 + } + }) let unique : Array[(Double, Double)] = [] for point in sorted { if unique.length() == 0 || unique[unique.length() - 1] != point { @@ -520,11 +516,12 @@ fn lisa_convex_hull( let lower : Array[(Double, Double)] = [] for point in unique { while lower.length() >= 2 && - lisa_cross( - lower[lower.length() - 2], - lower[lower.length() - 1], - point, - ) <= 0.0 { + lisa_cross( + lower[lower.length() - 2], + lower[lower.length() - 1], + point, + ) <= + 0.0 { ignore(lower.pop()) } lower.push(point) @@ -534,11 +531,12 @@ fn lisa_convex_hull( while index >= 0 { let point = unique[index] while upper.length() >= 2 && - lisa_cross( - upper[upper.length() - 2], - upper[upper.length() - 1], - point, - ) <= 0.0 { + lisa_cross( + upper[upper.length() - 2], + upper[upper.length() - 1], + point, + ) <= + 0.0 { ignore(upper.pop()) } upper.push(point) @@ -621,15 +619,18 @@ fn lisa_image_window( let width = max_x - min_x let height = max_y - min_y if width <= 1.0e-14 || height <= 1.0e-14 { - raise LisaError("lisaClust image windows must have positive width and height") + raise LisaError( + "lisaClust image windows must have positive width and height", + ) } let vertices = match config.window_kind { - LisaRectangle => [ - (min_x - config.window_padding, min_y - config.window_padding), - (max_x + config.window_padding, min_y - config.window_padding), - (max_x + config.window_padding, max_y + config.window_padding), - (min_x - config.window_padding, max_y + config.window_padding), - ] + LisaRectangle => + [ + (min_x - config.window_padding, min_y - config.window_padding), + (max_x + config.window_padding, min_y - config.window_padding), + (max_x + config.window_padding, max_y + config.window_padding), + (min_x - config.window_padding, max_y + config.window_padding), + ] LisaConvexHull => { let hull = lisa_convex_hull(points) if hull.length() < 3 { @@ -652,9 +653,9 @@ fn lisa_image_window( vertex_min_y = vertex_min_y.min(vertex.1) vertex_max_y = vertex_max_y.max(vertex.1) } - let max_radius = ((vertex_max_x - vertex_min_x).min( - vertex_max_y - vertex_min_y, - )) / + let max_radius = (vertex_max_x - vertex_min_x).min( + vertex_max_y - vertex_min_y, + ) / 2.01 LisaImageWindow::{ image_id, vertices, area, max_radius } } @@ -682,9 +683,7 @@ fn lisa_ray_boundary_distance( let qy = ay - y let distance = (qx * ey - qy * ex) / denominator let segment = (qx * dy - qy * dx) / denominator - if distance >= 0.0 && - segment >= -1.0e-10 && - segment <= 1.0 + 1.0e-10 { + if distance >= 0.0 && segment >= -1.0e-10 && segment <= 1.0 + 1.0e-10 { closest = closest.min(distance) } } @@ -797,9 +796,7 @@ pub fn lisa_curves( for radius in config.radii { image_radii.push(radius.min(window.max_radius)) } - effective_radii.push( - LisaImageRadii::{ image_id, radii: image_radii.copy() }, - ) + effective_radii.push(LisaImageRadii::{ image_id, radii: image_radii.copy() }) let density_weights = lisa_density_weights( cells, indices, @@ -846,11 +843,7 @@ pub fn lisa_curves( } else { 1.0 } - let expected = @math.PI * - radius * - radius * - edge_fraction * - intensity + let expected = @math.PI * radius * radius * edge_fraction * intensity let feature = type_index * config.radii.length() + radius_index values[source_global][feature] = if expected <= 1.0e-14 { 0.0 @@ -887,10 +880,7 @@ pub fn lisa_curves( } ///| -fn lisa_squared_distance( - left : Array[Double], - right : Array[Double], -) -> Double { +fn lisa_squared_distance(left : Array[Double], right : Array[Double]) -> Double { let mut output = 0.0 for index in 0.. LisaKmeansFit { let first = (config.seed + start * 9973) % data.length() - let mut centroids = lisa_initialize_centroids( - data, - config.n_clusters, - first, - ) + let mut centroids = lisa_initialize_centroids(data, config.n_clusters, first) let mut labels = Array::make(data.length(), -1) let mut iterations = 0 let mut converged = false @@ -1034,10 +1020,7 @@ fn lisa_kmeans_once( let mut maximum_shift = 0.0 for cluster in 0.. maximum { dominant = entry.cell_type maximum = entry.relative_frequency } } - summaries.push( - LisaRegionSummary::{ - region: config.region_prefix + "_" + (region + 1).to_string(), - size: region_totals[region], - dominant_cell_type: dominant, - maximum_enrichment: maximum.max(0.0), - }, - ) + summaries.push(LisaRegionSummary::{ + region: config.region_prefix + "_" + (region + 1).to_string(), + size: region_totals[region], + dominant_cell_type: dominant, + maximum_enrichment: maximum.max(0.0), + }) } (enrichment, summaries) } @@ -1255,11 +1233,7 @@ pub fn lisaclust_from_curves( cluster_sizes[label] = cluster_sizes[label] + 1 regions.push(config.region_prefix + "_" + (label + 1).to_string()) } - let silhouette = lisa_silhouette( - curves.values, - fit.labels, - config.n_clusters, - ) + let silhouette = lisa_silhouette(curves.values, fit.labels, config.n_clusters) let (enrichment, region_summaries) = lisa_enrichment( curves, fit.labels, @@ -1400,7 +1374,9 @@ pub fn lisaclust_spatial_experiment( enriched.col_data[row][region_key] = result.regions[row] } enriched.metadata["lisaclust_cells"] = result.n_cells().to_string() - enriched.metadata["lisaclust_features"] = result.curves.n_features().to_string() + enriched.metadata["lisaclust_features"] = result.curves + .n_features() + .to_string() enriched.metadata["lisaclust_regions"] = result.n_regions().to_string() enriched.metadata["lisaclust_silhouette"] = result.silhouette.to_string() LisaSpatialExperimentOutput::{ experiment: enriched, result } @@ -1414,7 +1390,11 @@ pub fn lisaclust_example_data() -> Array[LisaCell] { for row in 0..<4 { let left = column < 4 let cell_type = if left { - if (column + row + image) % 3 == 0 { "B_cell" } else { "T_cell" } + if (column + row + image) % 3 == 0 { + "B_cell" + } else { + "T_cell" + } } else if (column + row + image) % 3 == 0 { "Stroma" } else { diff --git a/src/logistic_regression.mbt b/src/logistic_regression.mbt index e65b7143..276c08de 100644 --- a/src/logistic_regression.mbt +++ b/src/logistic_regression.mbt @@ -17,23 +17,23 @@ pub struct LogisticRegressionModel { ///| /// Construct a new LogisticRegressionModel with the given beta weights. pub fn LogisticRegressionModel::new( - beta : Array[Double] + beta : Array[Double], ) -> LogisticRegressionModel { - LogisticRegressionModel::{ beta } + LogisticRegressionModel::{ beta, } } ///| /// Accessor for the beta weight vector. -pub fn LogisticRegressionModel::beta(self : LogisticRegressionModel) -> Array[ - Double -] { +pub fn LogisticRegressionModel::beta( + self : LogisticRegressionModel, +) -> Array[Double] { self.beta } ///| /// Number of weights (including bias). pub fn LogisticRegressionModel::n_weights( - self : LogisticRegressionModel + self : LogisticRegressionModel, ) -> Int { self.beta.length() } @@ -97,13 +97,13 @@ fn lr_solve(matrix : Array[Array[Double]], b : Array[Double]) -> Array[Double]? for col in 0.. max_val { max_val = abs_val @@ -159,7 +159,7 @@ fn lr_solve(matrix : Array[Array[Double]], b : Array[Double]) -> Array[Double]? /// Returns a trained `LogisticRegressionModel`. pub fn logistic_regression_train( xs : Array[Array[Double]], - ys : Array[Int] + ys : Array[Int], ) -> LogisticRegressionModel { let n = xs.length() // Each observation gets a leading constant 1.0 for the bias term. @@ -190,7 +190,9 @@ pub fn logistic_regression_train( let mut llik = 0.0 for i in 0.. { + Some(delta) => for k in 0.. { - break - } + None => break } } - LogisticRegressionModel::{ beta } + LogisticRegressionModel::{ beta, } } ///| @@ -257,7 +256,7 @@ pub fn logistic_regression_train( /// Returns [P(class=0), P(class=1)]. pub fn logistic_regression_calculate( model : LogisticRegressionModel, - x : Array[Double] + x : Array[Double], ) -> Array[Double] { // Prepend constant 1.0 for bias. let xfull = Array::make(x.length() + 1, 1.0) @@ -273,7 +272,7 @@ pub fn logistic_regression_calculate( /// Classify an observation into class 0 or 1. pub fn logistic_regression_classify( model : LogisticRegressionModel, - x : Array[Double] + x : Array[Double], ) -> Int { let probs = logistic_regression_calculate(model, x) if probs[0] > probs[1] { @@ -291,9 +290,7 @@ pub fn logistic_regression_classify( /// Sample training data for operon prediction (Biopython tutorial example). /// Each observation: [intergenic_distance, expression_score]. /// Label 1 = same operon (OP), 0 = different operon (NOP). -pub fn logistic_regression_sample_data() -> (Array[ - Array[Double] -], Array[Int]) { +pub fn logistic_regression_sample_data() -> (Array[Array[Double]], Array[Int]) { let xs = [ [-53.0, -200.78], [117.0, -267.14], diff --git a/src/lowess.mbt b/src/lowess.mbt index 83c3c6b0..4990737a 100644 --- a/src/lowess.mbt +++ b/src/lowess.mbt @@ -185,9 +185,9 @@ fn lowess_compute_point( pub fn lowess( x : Array[Double], y : Array[Double], - f~ : Double = 0.6667, - n_steps~ : Int = 0, - delta~ : Double = 0.0, + f? : Double = 0.6667, + n_steps? : Int = 0, + delta? : Double = 0.0, ) -> Array[Double] { let n = x.length() if n == 0 { @@ -273,11 +273,11 @@ pub fn lowess( pub fn lowess_robust( x : Array[Double], y : Array[Double], - f~ : Double = 0.6667, - n_steps~ : Int = 2, - delta~ : Double = 0.0, + f? : Double = 0.6667, + n_steps? : Int = 2, + delta? : Double = 0.0, ) -> Array[Double] { - lowess(x, y, f=f, n_steps=n_steps, delta=delta) + lowess(x, y, f~, n_steps~, delta~) } ///| @@ -290,7 +290,7 @@ pub fn lowess_predict( x : Array[Double], y : Array[Double], smoothed_y : Array[Double], - f~ : Double = 0.6667, + f? : Double = 0.6667, ) -> Double { let n = x.length() if n == 0 { @@ -394,7 +394,7 @@ pub fn lowess_predict( /// Convenience function where x = 0, 1, 2, ... (indices as x values). pub fn lowess_smooth_series( values : Array[Double], - window_frac~ : Double = 0.3, + window_frac? : Double = 0.3, ) -> Array[Double] { let n = values.length() if n == 0 { diff --git a/src/ma_align.mbt b/src/ma_align.mbt index b127e611..7f800148 100644 --- a/src/ma_align.mbt +++ b/src/ma_align.mbt @@ -39,7 +39,9 @@ pub fn StructureData::get_id(self : StructureData) -> String { ///| /// Get the CA atom coordinates. -pub fn StructureData::get_coordinates(self : StructureData) -> Array[(Double, Double, Double)] { +pub fn StructureData::get_coordinates( + self : StructureData, +) -> Array[(Double, Double, Double)] { self.ca_coordinates } @@ -94,31 +96,41 @@ pub fn AlignmentResult::new( ///| /// Get the structure IDs. -pub fn AlignmentResult::get_structure_ids(self : AlignmentResult) -> Array[String] { +pub fn AlignmentResult::get_structure_ids( + self : AlignmentResult, +) -> Array[String] { self.structure_ids } ///| /// Get the aligned sequences. -pub fn AlignmentResult::get_aligned_sequences(self : AlignmentResult) -> Array[String] { +pub fn AlignmentResult::get_aligned_sequences( + self : AlignmentResult, +) -> Array[String] { self.aligned_sequences } ///| /// Get the pairwise RMSD matrix. -pub fn AlignmentResult::get_rmsd_matrix(self : AlignmentResult) -> Array[Array[Double]] { +pub fn AlignmentResult::get_rmsd_matrix( + self : AlignmentResult, +) -> Array[Array[Double]] { self.rmsd_matrix } ///| /// Get the aligned coordinates. -pub fn AlignmentResult::get_aligned_coordinates(self : AlignmentResult) -> Array[Array[(Double, Double, Double)]] { +pub fn AlignmentResult::get_aligned_coordinates( + self : AlignmentResult, +) -> Array[Array[(Double, Double, Double)]] { self.aligned_coordinates } ///| /// Get the per-column conservation scores. -pub fn AlignmentResult::get_conservation(self : AlignmentResult) -> Array[Double] { +pub fn AlignmentResult::get_conservation( + self : AlignmentResult, +) -> Array[Double] { self.conservation } @@ -209,7 +221,9 @@ pub fn MAaligner::get_rmsd_threshold(self : MAaligner) -> Double { ///| /// Compute the centroid of a set of coordinates. -fn ma_compute_centroid(coords : Array[(Double, Double, Double)]) -> (Double, Double, Double) { +fn ma_compute_centroid( + coords : Array[(Double, Double, Double)], +) -> (Double, Double, Double) { let n = coords.length() if n == 0 { return (0.0, 0.0, 0.0) @@ -230,7 +244,10 @@ fn ma_compute_centroid(coords : Array[(Double, Double, Double)]) -> (Double, Dou ///| /// Compute the Euclidean distance between two 3D points. -fn ma_point_distance(p1 : (Double, Double, Double), p2 : (Double, Double, Double)) -> Double { +fn ma_point_distance( + p1 : (Double, Double, Double), + p2 : (Double, Double, Double), +) -> Double { let dx = p1.0 - p2.0 let dy = p1.1 - p2.1 let dz = p1.2 - p2.2 @@ -243,7 +260,11 @@ fn ma_compute_covariance( p : Array[(Double, Double, Double)], q : Array[(Double, Double, Double)], ) -> Array[Array[Double]] { - let h : Array[Array[Double]] = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] + let h : Array[Array[Double]] = [ + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + ] let n = p.length() let mut i = 0 while i < n { @@ -269,7 +290,11 @@ fn ma_matmul_3x3( a : Array[Array[Double]], b : Array[Array[Double]], ) -> Array[Array[Double]] { - let result : Array[Array[Double]] = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] + let result : Array[Array[Double]] = [ + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + ] let mut i = 0 while i < 3 { let mut j = 0 @@ -291,9 +316,11 @@ fn ma_matmul_3x3( ///| /// Transpose a 3x3 matrix. fn ma_transpose_3x3(m : Array[Array[Double]]) -> Array[Array[Double]] { - [[m[0][0], m[1][0], m[2][0]], - [m[0][1], m[1][1], m[2][1]], - [m[0][2], m[1][2], m[2][2]]] + [ + [m[0][0], m[1][0], m[2][0]], + [m[0][1], m[1][1], m[2][1]], + [m[0][2], m[1][2], m[2][2]], + ] } ///| @@ -313,7 +340,11 @@ fn ma_invert_3x3(m : Array[Array[Double]]) -> Array[Array[Double]] { return [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] } let inv_det = 1.0 / det - let result : Array[Array[Double]] = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] + let result : Array[Array[Double]] = [ + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + ] result[0][0] = (m[1][1] * m[2][2] - m[1][2] * m[2][1]) * inv_det result[0][1] = (m[0][2] * m[2][1] - m[0][1] * m[2][2]) * inv_det result[0][2] = (m[0][1] * m[1][2] - m[0][2] * m[1][1]) * inv_det @@ -330,7 +361,9 @@ fn ma_invert_3x3(m : Array[Array[Double]]) -> Array[Array[Double]] { /// Compute eigenvalues and eigenvectors of a 3x3 symmetric matrix. /// Uses the analytical solution for 3x3 symmetric matrices. /// Returns (eigenvalues, eigenvectors_as_columns). -fn ma_eigen_3x3(m : Array[Array[Double]]) -> (Array[Double], Array[Array[Double]]) { +fn ma_eigen_3x3( + m : Array[Array[Double]], +) -> (Array[Double], Array[Array[Double]]) { let eps = 1.0e-12 let a = m @@ -347,15 +380,25 @@ fn ma_eigen_3x3(m : Array[Array[Double]]) -> (Array[Double], Array[Array[Double] let p1 = (b01 * b01 + b02 * b02 + b12 * b12).sqrt() let eigenvalues : Array[Double] = [0.0, 0.0, 0.0] - let eigenvectors : Array[Array[Double]] = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] + let eigenvectors : Array[Array[Double]] = [ + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + ] if p1.abs() < eps { eigenvalues[0] = a[0][0] eigenvalues[1] = a[1][1] eigenvalues[2] = a[2][2] - eigenvectors[0][0] = 1.0; eigenvectors[0][1] = 0.0; eigenvectors[0][2] = 0.0 - eigenvectors[1][0] = 0.0; eigenvectors[1][1] = 1.0; eigenvectors[1][2] = 0.0 - eigenvectors[2][0] = 0.0; eigenvectors[2][1] = 0.0; eigenvectors[2][2] = 1.0 + eigenvectors[0][0] = 1.0 + eigenvectors[0][1] = 0.0 + eigenvectors[0][2] = 0.0 + eigenvectors[1][0] = 0.0 + eigenvectors[1][1] = 1.0 + eigenvectors[1][2] = 0.0 + eigenvectors[2][0] = 0.0 + eigenvectors[2][1] = 0.0 + eigenvectors[2][2] = 1.0 return (eigenvalues, eigenvectors) } @@ -381,11 +424,17 @@ fn ma_eigen_3x3(m : Array[Array[Double]]) -> (Array[Double], Array[Array[Double] eigenvalues[2] = q + 2.0 * p * @math.cos(phi + 2.0 * @math.PI / 3.0) eigenvalues[1] = 3.0 * q - eigenvalues[0] - eigenvalues[2] - let sorted_eigs : Array[Double] = [eigenvalues[0], eigenvalues[1], eigenvalues[2]] + let sorted_eigs : Array[Double] = [ + eigenvalues[0], + eigenvalues[1], + eigenvalues[2], + ] let v0_norm_sq = b01 * b01 + b02 * b02 if v0_norm_sq < eps { - eigenvectors[0][0] = 1.0; eigenvectors[0][1] = 0.0; eigenvectors[0][2] = 0.0 + eigenvectors[0][0] = 1.0 + eigenvectors[0][1] = 0.0 + eigenvectors[0][2] = 0.0 } else { let v0n = v0_norm_sq.sqrt() eigenvectors[0][0] = b01 / v0n @@ -399,19 +448,26 @@ fn ma_eigen_3x3(m : Array[Array[Double]]) -> (Array[Double], Array[Array[Double] let e3 = (l1 - a[2][2]) / (l1 - eigenvalues[0] + eps) let e_norm = (e1 * e1 + e2 * e2 + e3 * e3).sqrt() if e_norm < eps { - eigenvectors[1][0] = 0.0; eigenvectors[1][1] = 1.0; eigenvectors[1][2] = 0.0 + eigenvectors[1][0] = 0.0 + eigenvectors[1][1] = 1.0 + eigenvectors[1][2] = 0.0 } else { eigenvectors[1][0] = e1 / e_norm eigenvectors[1][1] = e2 / e_norm eigenvectors[1][2] = e3 / e_norm } - let cross_x = eigenvectors[0][1] * eigenvectors[1][2] - eigenvectors[0][2] * eigenvectors[1][1] - let cross_y = eigenvectors[0][2] * eigenvectors[1][0] - eigenvectors[0][0] * eigenvectors[1][2] - let cross_z = eigenvectors[0][0] * eigenvectors[1][1] - eigenvectors[0][1] * eigenvectors[1][0] + let cross_x = eigenvectors[0][1] * eigenvectors[1][2] - + eigenvectors[0][2] * eigenvectors[1][1] + let cross_y = eigenvectors[0][2] * eigenvectors[1][0] - + eigenvectors[0][0] * eigenvectors[1][2] + let cross_z = eigenvectors[0][0] * eigenvectors[1][1] - + eigenvectors[0][1] * eigenvectors[1][0] let cross_norm = (cross_x * cross_x + cross_y * cross_y + cross_z * cross_z).sqrt() if cross_norm < eps { - eigenvectors[2][0] = 0.0; eigenvectors[2][1] = 0.0; eigenvectors[2][2] = 1.0 + eigenvectors[2][0] = 0.0 + eigenvectors[2][1] = 0.0 + eigenvectors[2][2] = 1.0 } else { eigenvectors[2][0] = cross_x / cross_norm eigenvectors[2][1] = cross_y / cross_norm @@ -427,11 +483,27 @@ fn ma_eigen_3x3(m : Array[Array[Double]]) -> (Array[Double], Array[Array[Double] fn ma_matrix_sqrt_3x3(m : Array[Array[Double]]) -> Array[Array[Double]] { let (eigenvalues, eigenvectors) = ma_eigen_3x3(m) - let sqrt_eig0 = if eigenvalues[0] >= 0.0 { eigenvalues[0].sqrt() } else { 0.0 } - let sqrt_eig1 = if eigenvalues[1] >= 0.0 { eigenvalues[1].sqrt() } else { 0.0 } - let sqrt_eig2 = if eigenvalues[2] >= 0.0 { eigenvalues[2].sqrt() } else { 0.0 } + let sqrt_eig0 = if eigenvalues[0] >= 0.0 { + eigenvalues[0].sqrt() + } else { + 0.0 + } + let sqrt_eig1 = if eigenvalues[1] >= 0.0 { + eigenvalues[1].sqrt() + } else { + 0.0 + } + let sqrt_eig2 = if eigenvalues[2] >= 0.0 { + eigenvalues[2].sqrt() + } else { + 0.0 + } - let result : Array[Array[Double]] = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] + let result : Array[Array[Double]] = [ + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + ] let mut i = 0 while i < 3 { let mut j = 0 @@ -450,7 +522,9 @@ fn ma_matrix_sqrt_3x3(m : Array[Array[Double]]) -> Array[Array[Double]] { ///| /// Build a 3x3 rotation matrix from three rotation angles (around x, y, z axes). -fn ma_build_rotation_matrix(angles : (Double, Double, Double)) -> Array[Array[Double]] { +fn ma_build_rotation_matrix( + angles : (Double, Double, Double), +) -> Array[Array[Double]] { let rx = angles.0 let ry = angles.1 let rz = angles.2 @@ -462,16 +536,23 @@ fn ma_build_rotation_matrix(angles : (Double, Double, Double)) -> Array[Array[Do let cz = @math.cos(rz) let sz = @math.sin(rz) - [[cy * cz, cx * sz + sx * sy * cz, sx * sz - cx * sy * cz], - [-cy * sz, cx * cz - sx * sy * sz, sx * cz + cx * sy * sz], - [sy, -sx * cy, cx * cy]] + [ + [cy * cz, cx * sz + sx * sy * cz, sx * sz - cx * sy * cz], + [-cy * sz, cx * cz - sx * sy * sz, sx * cz + cx * sy * sz], + [sy, -sx * cy, cx * cy], + ] } ///| /// Extract Euler angles (rotation around x, y, z) from a rotation matrix. -fn ma_rotation_to_angles(rot : Array[Array[Double]]) -> (Double, Double, Double) { +fn ma_rotation_to_angles( + rot : Array[Array[Double]], +) -> (Double, Double, Double) { let angle_x = @math.atan2(rot[2][1], rot[2][2]) - let angle_y = @math.atan2(-rot[2][0], (rot[2][1] * rot[2][1] + rot[2][2] * rot[2][2]).sqrt()) + let angle_y = @math.atan2( + -rot[2][0], + (rot[2][1] * rot[2][1] + rot[2][2] * rot[2][2]).sqrt(), + ) let angle_z = @math.atan2(rot[1][0], rot[0][0]) (angle_x, angle_y, angle_z) } @@ -482,7 +563,9 @@ fn ma_rotation_to_angles(rot : Array[Array[Double]]) -> (Double, Double, Double) ///| /// Center coordinates at the origin (subtract centroid). -pub fn ma_center_coordinates(coords : Array[(Double, Double, Double)]) -> Array[(Double, Double, Double)] { +pub fn ma_center_coordinates( + coords : Array[(Double, Double, Double)], +) -> Array[(Double, Double, Double)] { let centroid = ma_compute_centroid(coords) let result : Array[(Double, Double, Double)] = Array::new() let mut i = 0 @@ -569,7 +652,11 @@ pub fn compute_rmsd( coords1 : Array[(Double, Double, Double)], coords2 : Array[(Double, Double, Double)], ) -> Double { - let n = if coords1.length() < coords2.length() { coords1.length() } else { coords2.length() } + let n = if coords1.length() < coords2.length() { + coords1.length() + } else { + coords2.length() + } if n == 0 { return 0.0 } @@ -598,7 +685,11 @@ pub fn compute_svd_rotation( coords1 : Array[(Double, Double, Double)], coords2 : Array[(Double, Double, Double)], ) -> (Double, Double, Double) { - let n = if coords1.length() < coords2.length() { coords1.length() } else { coords2.length() } + let n = if coords1.length() < coords2.length() { + coords1.length() + } else { + coords2.length() + } if n < 2 { return (0.0, 0.0, 0.0) } @@ -612,9 +703,7 @@ pub fn compute_svd_rotation( let det_ht_h = ma_det_3x3(ht_h) let final_rot = if det_ht_h.abs() < 1.0e-15 { - [[1.0, 0.0, 0.0], - [0.0, 1.0, 0.0], - [0.0, 0.0, 1.0]] + [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] } else { let sqrt_ht_h = ma_matrix_sqrt_3x3(ht_h) let sqrt_ht_h_inv = ma_invert_3x3(sqrt_ht_h) @@ -622,9 +711,11 @@ pub fn compute_svd_rotation( let det_rot = ma_det_3x3(rot) if det_rot < 0.0 { - [[rot[0][0], rot[0][1], -rot[0][2]], - [rot[1][0], rot[1][1], -rot[1][2]], - [rot[2][0], rot[2][1], -rot[2][2]]] + [ + [rot[0][0], rot[0][1], -rot[0][2]], + [rot[1][0], rot[1][1], -rot[1][2]], + [rot[2][0], rot[2][1], -rot[2][2]], + ] } else { rot } @@ -677,9 +768,7 @@ pub fn ma_align_pairwise( let det_ht_h = ma_det_3x3(ht_h) let final_rot = if det_ht_h.abs() < 1.0e-15 { - [[1.0, 0.0, 0.0], - [0.0, 1.0, 0.0], - [0.0, 0.0, 1.0]] + [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] } else { let sqrt_ht_h = ma_matrix_sqrt_3x3(ht_h) let sqrt_ht_h_inv = ma_invert_3x3(sqrt_ht_h) @@ -687,9 +776,11 @@ pub fn ma_align_pairwise( let det_rot = ma_det_3x3(rot) if det_rot < 0.0 { - [[rot[0][0], rot[0][1], -rot[0][2]], - [rot[1][0], rot[1][1], -rot[1][2]], - [rot[2][0], rot[2][1], -rot[2][2]]] + [ + [rot[0][0], rot[0][1], -rot[0][2]], + [rot[1][0], rot[1][1], -rot[1][2]], + [rot[2][0], rot[2][1], -rot[2][2]], + ] } else { rot } @@ -726,7 +817,13 @@ fn ma_compute_average_structure( sz = sz + z j = j + 1 } - avg.push((sx / n_structures.to_double(), sy / n_structures.to_double(), sz / n_structures.to_double())) + avg.push( + ( + sx / n_structures.to_double(), + sy / n_structures.to_double(), + sz / n_structures.to_double(), + ), + ) i = i + 1 } avg @@ -871,7 +968,10 @@ pub fn iterate_alignment( let mut max_rmsd = 0.0 let mut i = 1 while i < n { - let (rotation, rmsd) = ma_align_pairwise(ref_coords, structures[i].ca_coordinates) + let (rotation, rmsd) = ma_align_pairwise( + ref_coords, + structures[i].ca_coordinates, + ) let aligned = apply_rotation(structures[i].ca_coordinates, rotation) aligned_all.push(aligned) if rmsd > max_rmsd { @@ -906,7 +1006,9 @@ pub fn align_multiple( if n == 1 { let ids : Array[String] = [structures[0].structure_id] let seqs : Array[String] = [structures[0].sequence] - let coords : Array[Array[(Double, Double, Double)]] = [structures[0].ca_coordinates.copy()] + let coords : Array[Array[(Double, Double, Double)]] = [ + structures[0].ca_coordinates.copy(), + ] let rmsd_mat : Array[Array[Double]] = [[0.0]] let cons = build_conservation_profile(seqs) return AlignmentResult::new(ids, seqs, rmsd_mat, coords, cons, 0.0) @@ -919,7 +1021,10 @@ pub fn align_multiple( let mut max_rmsd = 0.0 let mut i = 1 while i < n { - let (rotation, rmsd) = ma_align_pairwise(ref_coords, structures[i].ca_coordinates) + let (rotation, rmsd) = ma_align_pairwise( + ref_coords, + structures[i].ca_coordinates, + ) let aligned = apply_rotation(structures[i].ca_coordinates, rotation) aligned_all.push(aligned) if rmsd > max_rmsd { @@ -937,7 +1042,10 @@ pub fn align_multiple( let mut iter_max_rmsd = 0.0 let mut j = 1 while j < n { - let (rotation, rmsd) = ma_align_pairwise(new_ref, structures[j].ca_coordinates) + let (rotation, rmsd) = ma_align_pairwise( + new_ref, + structures[j].ca_coordinates, + ) let aligned = apply_rotation(structures[j].ca_coordinates, rotation) new_aligned.push(aligned) if rmsd > iter_max_rmsd { @@ -980,7 +1088,11 @@ pub fn align_multiple( } a = a + 1 } - if count > 0 { sum / count.to_double() } else { 0.0 } + if count > 0 { + sum / count.to_double() + } else { + 0.0 + } } else { 0.0 } @@ -1014,4 +1126,4 @@ pub fn align_structures( structures : Array[StructureData], ) -> AlignmentResult { align_multiple(aligner, structures) -} \ No newline at end of file +} diff --git a/src/maf.mbt b/src/maf.mbt index 5899e372..b6d7e9d6 100644 --- a/src/maf.mbt +++ b/src/maf.mbt @@ -89,10 +89,7 @@ pub struct MAFConfig { ///| /// Default MAF configuration. pub fn MAFConfig::default() -> MAFConfig { - MAFConfig::{ - store_sequences: true, - min_score: 0.0, - } + MAFConfig::{ store_sequences: true, min_score: 0.0 } } // ============================================================================ @@ -109,14 +106,7 @@ pub fn new_maf_sequence( seq_size : Int, aligned_seq : String, ) -> MAFSequence { - MAFSequence::{ - seq_name, - start, - length, - strand, - seq_size, - aligned_seq, - } + MAFSequence::{ seq_name, start, length, strand, seq_size, aligned_seq } } ///| @@ -132,7 +122,7 @@ pub fn maf_seq_sequence(seq : MAFSequence) -> String { for i = 0; i < seq.aligned_seq.length(); i = i + 1 { let c = seq.aligned_seq.unsafe_get(i) if c.to_int() != '-'.to_int() && c.to_int() != '.'.to_int() { - result = result + seq.aligned_seq[i:i+1].to_owned() + result = result + seq.aligned_seq[i:i + 1].to_owned() } } result @@ -175,7 +165,10 @@ pub fn maf_block_add_seq(block : MAFBlock, seq : MAFSequence) -> MAFBlock { ///| /// Add a comment to the block. -pub fn maf_block_add_comment(block : MAFBlock, comment : MAFComment) -> MAFBlock { +pub fn maf_block_add_comment( + block : MAFBlock, + comment : MAFComment, +) -> MAFBlock { block.comments.push(comment) block } @@ -221,17 +214,17 @@ pub fn maf_block_percent_identity(block : MAFBlock) -> Double { if aln_len == 0 { return 0.0 } - + let mut total_matches = 0 let mut total_pairs = 0 - + for col = 0; col < aln_len; col = col + 1 { let bases = Array::new() for s = 0; s < block.sequences.length(); s = s + 1 { let seq = block.sequences[s] let c = seq.aligned_seq.unsafe_get(col) if c.to_int() != '-'.to_int() && c.to_int() != '.'.to_int() { - bases.push(seq.aligned_seq[col:col+1].to_owned()) + bases.push(seq.aligned_seq[col:col + 1].to_owned()) } } let n_bases = bases.length() @@ -246,11 +239,11 @@ pub fn maf_block_percent_identity(block : MAFBlock) -> Double { } } } - + if total_pairs == 0 { return 0.0 } - (total_matches.to_double() / total_pairs.to_double()) * 100.0 + total_matches.to_double() / total_pairs.to_double() * 100.0 } ///| @@ -346,11 +339,11 @@ pub fn parse_maf(content : String) -> MAFAliignment { let mut result = new_maf_alignment() let lines = content.split("\n").to_array() let mut current_block : MAFBlock? = None - + for i = 0; i < lines.length(); i = i + 1 { let line = lines[i].to_owned() let trimmed = trim(line) - + if trimmed.length() == 0 { // Empty line - marks end of block match current_block { @@ -363,7 +356,7 @@ pub fn parse_maf(content : String) -> MAFAliignment { } continue } - + if starts_with(trimmed, 0, "##maf") { // Header line if starts_with(trimmed, 0, "##maf version=") { @@ -380,7 +373,7 @@ pub fn parse_maf(content : String) -> MAFAliignment { } continue } - + if starts_with(trimmed, 0, "#") { // Comment line match current_block { @@ -388,13 +381,11 @@ pub fn parse_maf(content : String) -> MAFAliignment { let comment = MAFComment::{ key: trimmed } current_block = Some(maf_block_add_comment(block, comment)) } - None => { - result.comments.push(trimmed) - } + None => result.comments.push(trimmed) } continue } - + if starts_with(trimmed, 0, "a ") { // Block attributes line current_block = Some(new_maf_block()) @@ -425,7 +416,7 @@ pub fn parse_maf(content : String) -> MAFAliignment { } continue } - + if starts_with(trimmed, 0, "s ") || starts_with(trimmed, 0, "s\t") { // Sequence line if current_block is None { @@ -442,17 +433,17 @@ pub fn parse_maf(content : String) -> MAFAliignment { let strand = parts[4] let seq_size = parse_int(parts[5]) let aligned_seq = if parts.length() >= 7 { parts[6] } else { "" } - let seq = new_maf_sequence(seq_name, start, length, strand, seq_size, aligned_seq) + let seq = new_maf_sequence( + seq_name, start, length, strand, seq_size, aligned_seq, + ) match current_block { - Some(block) => { - current_block = Some(maf_block_add_seq(block, seq)) - } + Some(block) => current_block = Some(maf_block_add_seq(block, seq)) None => () } } continue } - + if starts_with(trimmed, 0, "e ") { // Event line if current_block is None { @@ -464,22 +455,15 @@ pub fn parse_maf(content : String) -> MAFAliignment { let seq_name = parts[2] let position = if parts.length() >= 4 { parse_int(parts[3]) } else { 0 } let description = if parts.length() >= 5 { parts[4] } else { "" } - let event = MAFEvent::{ - event_type, - seq_name, - position, - description, - } + let event = MAFEvent::{ event_type, seq_name, position, description } match current_block { - Some(block) => { - current_block = Some(maf_block_add_event(block, event)) - } + Some(block) => current_block = Some(maf_block_add_event(block, event)) None => () } } continue } - + if starts_with(trimmed, 0, "b ") { // Block info line (marks start of new block with boundary info) match current_block { @@ -493,7 +477,7 @@ pub fn parse_maf(content : String) -> MAFAliignment { continue } } - + // Add final block if exists match current_block { Some(block) => { @@ -502,7 +486,7 @@ pub fn parse_maf(content : String) -> MAFAliignment { } None => () } - + result } @@ -514,7 +498,7 @@ pub fn parse_maf(content : String) -> MAFAliignment { /// Write a MAFAliignment to a MAF-formatted string. pub fn write_maf(ali : MAFAliignment) -> String { let mut result = "" - + // Write header result = result + "##maf version=" result = result + ali.version @@ -526,13 +510,13 @@ pub fn write_maf(ali : MAFAliignment) -> String { None => () } result = result + "\n\n" - + // Write top-level comments for c = 0; c < ali.comments.length(); c = c + 1 { result = result + ali.comments[c] result = result + "\n" } - + // Write blocks for b = 0; b < ali.blocks.length(); b = b + 1 { let block = ali.blocks[b] @@ -554,7 +538,7 @@ pub fn write_maf(ali : MAFAliignment) -> String { result = result + block.attributes[key] } result = result + "\n" - + // Write sequences for s = 0; s < block.sequences.length(); s = s + 1 { let seq = block.sequences[s] @@ -572,13 +556,13 @@ pub fn write_maf(ali : MAFAliignment) -> String { result = result + seq.aligned_seq result = result + "\n" } - + // Write comments for c = 0; c < block.comments.length(); c = c + 1 { result = result + block.comments[c].key result = result + "\n" } - + // Write events for e = 0; e < block.events.length(); e = e + 1 { let event = block.events[e] @@ -594,10 +578,10 @@ pub fn write_maf(ali : MAFAliignment) -> String { } result = result + "\n" } - + result = result + "\n" } - + result } @@ -607,12 +591,15 @@ pub fn write_maf(ali : MAFAliignment) -> String { ///| /// Select sequences by name and create a new alignment. -pub fn maf_select_seqs(ali : MAFAliignment, names : Array[String]) -> MAFAliignment { +pub fn maf_select_seqs( + ali : MAFAliignment, + names : Array[String], +) -> MAFAliignment { let mut result = new_maf_alignment() result.version = ali.version result.score = ali.score result.comments = ali.comments - + for b = 0; b < ali.blocks.length(); b = b + 1 { let block = ali.blocks[b] let mut new_block = new_maf_block() @@ -621,30 +608,33 @@ pub fn maf_select_seqs(ali : MAFAliignment, names : Array[String]) -> MAFAliignm new_block.events = block.events new_block.comments = block.comments new_block.is_complete = block.is_complete - + for s = 0; s < block.sequences.length(); s = s + 1 { let seq = block.sequences[s] if names.contains(seq.seq_name) { new_block = maf_block_add_seq(new_block, seq) } } - + if new_block.sequences.length() > 0 { result = maf_add_block(result, new_block) } } - + result } ///| /// Filter blocks by minimum alignment length. -pub fn maf_filter_by_length(ali : MAFAliignment, min_length : Int) -> MAFAliignment { +pub fn maf_filter_by_length( + ali : MAFAliignment, + min_length : Int, +) -> MAFAliignment { let mut result = new_maf_alignment() result.version = ali.version result.score = ali.score result.comments = ali.comments - + for b = 0; b < ali.blocks.length(); b = b + 1 { let block = ali.blocks[b] let aln_len = maf_block_alignment_length(block) @@ -652,18 +642,21 @@ pub fn maf_filter_by_length(ali : MAFAliignment, min_length : Int) -> MAFAliignm result = maf_add_block(result, block) } } - + result } ///| /// Filter blocks by minimum percent identity. -pub fn maf_filter_by_identity(ali : MAFAliignment, min_identity : Double) -> MAFAliignment { +pub fn maf_filter_by_identity( + ali : MAFAliignment, + min_identity : Double, +) -> MAFAliignment { let mut result = new_maf_alignment() result.version = ali.version result.score = ali.score result.comments = ali.comments - + for b = 0; b < ali.blocks.length(); b = b + 1 { let block = ali.blocks[b] let identity = maf_block_percent_identity(block) @@ -671,7 +664,7 @@ pub fn maf_filter_by_identity(ali : MAFAliignment, min_identity : Double) -> MAF result = maf_add_block(result, block) } } - + result } @@ -681,29 +674,29 @@ pub fn maf_merge_blocks(ali : MAFAliignment) -> MAFAliignment { if ali.blocks.length() <= 1 { return ali } - + let mut result = new_maf_alignment() result.version = ali.version result.score = ali.score result.comments = ali.comments - + let mut current_block = ali.blocks[0] - + for i = 1; i < ali.blocks.length(); i = i + 1 { let block = ali.blocks[i] - + // Check if blocks have the same sequences let same_seqs = current_block.sequences.length() == block.sequences.length() - let can_merge = same_seqs && - current_block.events.length() == 0 && + let can_merge = same_seqs && + current_block.events.length() == 0 && block.events.length() == 0 - + if can_merge { // Merge: concatenate sequences let mut new_block = new_maf_block() new_block.score = current_block.score new_block.attributes = current_block.attributes - + for j = 0; j < current_block.sequences.length(); j = j + 1 { let seq1 = current_block.sequences[j] let seq2 = block.sequences[j] @@ -717,14 +710,14 @@ pub fn maf_merge_blocks(ali : MAFAliignment) -> MAFAliignment { ) new_block = maf_block_add_seq(new_block, merged_seq) } - + current_block = new_block } else { result = maf_add_block(result, current_block) current_block = block } } - + result = maf_add_block(result, current_block) result } @@ -734,12 +727,12 @@ pub fn maf_merge_blocks(ali : MAFAliignment) -> MAFAliignment { pub fn maf_sequence_coverage(ali : MAFAliignment) -> Map[String, Double] { let coverage = Map([], capacity=10) let seq_names = maf_all_seq_names(ali) - + for n = 0; n < seq_names.length(); n = n + 1 { let name = seq_names[n] let mut total_alignment = 0.0 let mut total_length = 0.0 - + for b = 0; b < ali.blocks.length(); b = b + 1 { let block = ali.blocks[b] for s = 0; s < block.sequences.length(); s = s + 1 { @@ -750,14 +743,14 @@ pub fn maf_sequence_coverage(ali : MAFAliignment) -> Map[String, Double] { } } } - + if total_length > 0.0 { - coverage[name] = (total_alignment / total_length) * 100.0 + coverage[name] = total_alignment / total_length * 100.0 } else { coverage[name] = 0.0 } } - + coverage } @@ -785,23 +778,31 @@ pub fn maf_compute_stats(ali : MAFAliignment) -> MAFStats { let total_length = maf_total_length(ali) let num_sequences = maf_all_seq_names(ali).length() let avg_percent_identity = maf_average_percent_identity(ali) - + let mut total_coverage = 0.0 let lengths = Array::new() let mut min_len = 99999999 let mut max_len = 0 - + for b = 0; b < ali.blocks.length(); b = b + 1 { let block = ali.blocks[b] total_coverage = total_coverage + maf_block_coverage(block) let blen = maf_block_alignment_length(block) lengths.push(blen) - if blen < min_len { min_len = blen } - if blen > max_len { max_len = blen } + if blen < min_len { + min_len = blen + } + if blen > max_len { + max_len = blen + } } - - let avg_block_coverage = if num_blocks > 0 { total_coverage / num_blocks.to_double() } else { 0.0 } - + + let avg_block_coverage = if num_blocks > 0 { + total_coverage / num_blocks.to_double() + } else { + 0.0 + } + // Calculate median lengths.sort() let median = if lengths.length() > 0 { @@ -814,14 +815,18 @@ pub fn maf_compute_stats(ali : MAFAliignment) -> MAFStats { } else { 0.0 } - + MAFStats::{ num_blocks, total_length, num_sequences, avg_percent_identity, avg_block_coverage, - min_block_length: if min_len == 99999999 { 0 } else { min_len }, + min_block_length: if min_len == 99999999 { + 0 + } else { + min_len + }, max_block_length: max_len, median_block_length: median, } diff --git a/src/maftools.mbt b/src/maftools.mbt index e095e64f..64859fd7 100644 --- a/src/maftools.mbt +++ b/src/maftools.mbt @@ -73,7 +73,7 @@ pub fn MAFMutation::new( reference_allele : String, tumor_seq_allele1 : String, tumor_sample_barcode : String, - variant_classification : String + variant_classification : String, ) -> MAFMutation { MAFMutation::{ hugo_symbol, @@ -83,7 +83,7 @@ pub fn MAFMutation::new( reference_allele, tumor_seq_allele1, tumor_sample_barcode, - variant_classification + variant_classification, } } @@ -138,7 +138,7 @@ pub fn MAFData::new() -> MAFData { MAFData::{ mutations: Array::new(), sample_barcodes: Array::new(), - gene_symbols: Array::new() + gene_symbols: Array::new(), } } @@ -146,21 +146,21 @@ pub fn MAFData::new() -> MAFData { pub fn MAFData::add_mutation(self : MAFData, mutation : MAFMutation) -> MAFData { let new_mutations = self.mutations new_mutations.push(mutation) - + let new_samples = self.sample_barcodes if !maftools_contains_string(new_samples, mutation.tumor_sample_barcode) { new_samples.push(mutation.tumor_sample_barcode) } - + let new_genes = self.gene_symbols if !maftools_contains_string(new_genes, mutation.hugo_symbol) { new_genes.push(mutation.hugo_symbol) } - + MAFData::{ mutations: new_mutations, sample_barcodes: new_samples, - gene_symbols: new_genes + gene_symbols: new_genes, } } @@ -190,23 +190,26 @@ pub fn MAFData::filter_genes(self : MAFData, genes : Array[String]) -> MAFData { } i = i + 1 } - + let new_genes : Array[String] = Array::new() let mut j = 0 while j < genes.length() { new_genes.push(genes[j]) j = j + 1 } - + MAFData::{ mutations: filtered, sample_barcodes: self.sample_barcodes, - gene_symbols: new_genes + gene_symbols: new_genes, } } ///| -pub fn MAFData::filter_samples(self : MAFData, samples : Array[String]) -> MAFData { +pub fn MAFData::filter_samples( + self : MAFData, + samples : Array[String], +) -> MAFData { let filtered : Array[MAFMutation] = Array::new() let mut i = 0 while i < self.mutations.length() { @@ -216,37 +219,42 @@ pub fn MAFData::filter_samples(self : MAFData, samples : Array[String]) -> MAFDa } i = i + 1 } - + let new_samples : Array[String] = Array::new() let mut j = 0 while j < samples.length() { new_samples.push(samples[j]) j = j + 1 } - + MAFData::{ mutations: filtered, sample_barcodes: new_samples, - gene_symbols: self.gene_symbols + gene_symbols: self.gene_symbols, } } ///| -pub fn MAFData::filter_variant_type(self : MAFData, variant_type : String) -> MAFData { +pub fn MAFData::filter_variant_type( + self : MAFData, + variant_type : String, +) -> MAFData { let filtered : Array[MAFMutation] = Array::new() let mut i = 0 while i < self.mutations.length() { let mutation = self.mutations[i] - if mutation.variant_classification.to_upper().contains(variant_type.to_upper()) { + if mutation.variant_classification + .to_upper() + .contains(variant_type.to_upper()) { filtered.push(mutation) } i = i + 1 } - + MAFData::{ mutations: filtered, sample_barcodes: self.sample_barcodes, - gene_symbols: self.gene_symbols + gene_symbols: self.gene_symbols, } } @@ -298,13 +306,13 @@ pub fn get_sample_mutation_counts(maf : MAFData) -> Map[String, Int] { pub fn calculate_mutation_spectrum(maf : MAFData) -> MutationSpectrum { let transitions : Array[String] = ["A>G", "G>A", "C>T", "T>C"] let transversions : Array[String] = ["A>C", "A>T", "C>A", "C>G", "G>C", "G>T"] - + let mut snv_count = 0 let mut indel_count = 0 let mut complex_count = 0 let mut transition_count = 0 let mut transversion_count = 0 - + let mut i = 0 while i < maf.mutations.length() { let mutation = maf.mutations[i] @@ -322,7 +330,7 @@ pub fn calculate_mutation_spectrum(maf : MAFData) -> MutationSpectrum { } i = i + 1 } - + MutationSpectrum::{ snv_count, indel_count, @@ -330,7 +338,7 @@ pub fn calculate_mutation_spectrum(maf : MAFData) -> MutationSpectrum { transitions, transversions, transition_count, - transversion_count + transversion_count, } } @@ -339,7 +347,7 @@ pub fn calculate_tmb(maf : MAFData, coding_region_size : Double) -> TMBResult { let mutations = maf.mutations let mut total_mutations = 0 let per_sample_tmb : Map[String, Double] = Map([], capacity=0) - + let mut i = 0 while i < mutations.length() { let mutation = mutations[i] @@ -351,7 +359,7 @@ pub fn calculate_tmb(maf : MAFData, coding_region_size : Double) -> TMBResult { } i = i + 1 } - + let result_map : Map[String, Double] = Map([], capacity=0) let sample_barcodes = maf.sample_barcodes let mut j = 0 @@ -362,14 +370,14 @@ pub fn calculate_tmb(maf : MAFData, coding_region_size : Double) -> TMBResult { result_map.set(sample, sample_tmb) j = j + 1 } - + let tmb = total_mutations.to_double() / coding_region_size - + TMBResult::{ tmb, coding_region_size, total_mutations, - per_sample_tmb: result_map + per_sample_tmb: result_map, } } @@ -378,45 +386,49 @@ pub fn generate_oncoplot_data(maf : MAFData, top_n : Int) -> OncoplotData { let gene_counts = get_gene_mutation_counts(maf) let sorted_genes = maftools_sort_by_count_desc(gene_counts, top_n) let samples = maf.sample_barcodes - + let mutation_matrix : Array[Array[String]] = Array::new() - + let mut i = 0 while i < sorted_genes.length() { let gene = sorted_genes[i] let row : Array[String] = Array::new() let mut j = 0 while j < samples.length() { - let mutation_type = maftools_get_mutation_type_for_sample_gene(maf, samples[j], gene) + let mutation_type = maftools_get_mutation_type_for_sample_gene( + maf, + samples[j], + gene, + ) row.push(mutation_type) j = j + 1 } mutation_matrix.push(row) i = i + 1 } - - OncoplotData::{ - genes: sorted_genes, - samples, - mutation_matrix - } + + OncoplotData::{ genes: sorted_genes, samples, mutation_matrix } } ///| -pub fn analyze_co_occurrence(maf : MAFData, gene1 : String, gene2 : String) -> CoOccurrenceResult { +pub fn analyze_co_occurrence( + maf : MAFData, + gene1 : String, + gene2 : String, +) -> CoOccurrenceResult { let samples1 = maftools_get_samples_with_gene(maf, gene1) let samples2 = maftools_get_samples_with_gene(maf, gene2) - + let mut co_occurrence = 0 let mut mutual_exclusivity = 0 - + let all_samples = maf.sample_barcodes let mut i = 0 while i < all_samples.length() { let sample = all_samples[i] let has_gene1 = maftools_contains_string(samples1, sample) let has_gene2 = maftools_contains_string(samples2, sample) - + if has_gene1 && has_gene2 { co_occurrence = co_occurrence + 1 } else if has_gene1 != has_gene2 { @@ -424,47 +436,47 @@ pub fn analyze_co_occurrence(maf : MAFData, gene1 : String, gene2 : String) -> C } i = i + 1 } - + let total = all_samples.length().to_double() let p_value = if total > 0.0 { - 1.0 - (co_occurrence.to_double() / total) + 1.0 - co_occurrence.to_double() / total } else { 1.0 } - + CoOccurrenceResult::{ pair: (gene1, gene2), co_occurrence, mutual_exclusivity, - p_value + p_value, } } ///| -pub fn decompose_mutational_signatures(maf : MAFData, reference_signatures : Array[MutationalSignature]) -> Array[MutationalSignature] { +pub fn decompose_mutational_signatures( + maf : MAFData, + reference_signatures : Array[MutationalSignature], +) -> Array[MutationalSignature] { if reference_signatures.length() == 0 { return Array::new() } - + let spectrum = calculate_mutation_spectrum(maf) let total_mutations = spectrum.snv_count.to_double() - + if total_mutations == 0.0 { return Array::new() } - + let results : Array[MutationalSignature] = Array::new() let mut i = 0 while i < reference_signatures.length() { let sig = reference_signatures[i] let contribution = sig.contribution * total_mutations - results.push(MutationalSignature::{ - name: sig.name, - contribution - }) + results.push(MutationalSignature::{ name: sig.name, contribution }) i = i + 1 } - + results } @@ -472,59 +484,92 @@ pub fn decompose_mutational_signatures(maf : MAFData, reference_signatures : Arr pub fn summarize_maf(maf : MAFData) -> String { let mut summary = "\nMAF Summary\n" summary = summary + "==============================\n" - summary = summary + "Total mutations: " + maf.count_mutations().to_string() + "\n" - summary = summary + "Total genes: " + maf.count_unique_genes().to_string() + "\n" - summary = summary + "Total samples: " + maf.count_unique_samples().to_string() + "\n" - + summary = summary + + "Total mutations: " + + maf.count_mutations().to_string() + + "\n" + summary = summary + + "Total genes: " + + maf.count_unique_genes().to_string() + + "\n" + summary = summary + + "Total samples: " + + maf.count_unique_samples().to_string() + + "\n" + let spectrum = calculate_mutation_spectrum(maf) summary = summary + "SNVs: " + spectrum.snv_count.to_string() + "\n" summary = summary + "Indels: " + spectrum.indel_count.to_string() + "\n" summary = summary + "Complex: " + spectrum.complex_count.to_string() + "\n" - + let tmb = calculate_tmb(maf, 3.0e7) summary = summary + "TMB: " + tmb.tmb.to_string() + " mut/Mb\n" - + summary } ///| pub fn create_example_maf() -> MAFData { let mut maf = MAFData::new() - - let genes = ["TP53", "BRCA1", "EGFR", "KRAS", "MYC", "PTEN", "APC", "RB1", "VHL", "NF1"] - let samples = ["Sample1", "Sample2", "Sample3", "Sample4", "Sample5", "Sample6", "Sample7", "Sample8"] - let variants = ["Missense_Mutation", "Nonsense_Mutation", "Frame_Shift_Ins", "Frame_Shift_Del", "Splice_Site"] - + + let genes = [ + "TP53", "BRCA1", "EGFR", "KRAS", "MYC", "PTEN", "APC", "RB1", "VHL", "NF1", + ] + let samples = [ + "Sample1", "Sample2", "Sample3", "Sample4", "Sample5", "Sample6", "Sample7", + "Sample8", + ] + let variants = [ + "Missense_Mutation", "Nonsense_Mutation", "Frame_Shift_Ins", "Frame_Shift_Del", + "Splice_Site", + ] + let mut i = 0 while i < 80 { let gene_idx = i % 10 let sample_idx = i % 8 let variant_idx = i % 5 let pos = 1000000 + i * 10000 - + let mutation = MAFMutation::new( genes[gene_idx], - "chr" + ((i % 22) + 1).to_string(), + "chr" + (i % 22 + 1).to_string(), pos, pos, - if i % 3 == 0 { "A" } else { if i % 3 == 1 { "C" } else { "G" } }, - if i % 2 == 0 { "T" } else { if i % 3 == 0 { "A" } else { "C" } }, + if i % 3 == 0 { + "A" + } else if i % 3 == 1 { + "C" + } else { + "G" + }, + if i % 2 == 0 { + "T" + } else if i % 3 == 0 { + "A" + } else { + "C" + }, samples[sample_idx], - variants[variant_idx] + variants[variant_idx], ) - + maf = maf.add_mutation(mutation) i = i + 1 } - + maf } ///| pub fn parse_maf_content(content : String) -> MAFData { let lines = split_by_char(content, '\n'.to_int()) - let header = if lines.length() > 0 { split_by_char(lines[0], '\t'.to_int()) } else { Array::new() } - + let header = if lines.length() > 0 { + split_by_char(lines[0], '\t'.to_int()) + } else { + Array::new() + } + let hugo_idx = maftools_find_column_index(header, "Hugo_Symbol") let chrom_idx = maftools_find_column_index(header, "Chromosome") let start_idx = maftools_find_column_index(header, "Start_Position") @@ -533,7 +578,7 @@ pub fn parse_maf_content(content : String) -> MAFData { let alt_idx = maftools_find_column_index(header, "Tumor_Seq_Allele1") let sample_idx = maftools_find_column_index(header, "Tumor_Sample_Barcode") let variant_idx = maftools_find_column_index(header, "Variant_Classification") - + let mut maf = MAFData::new() let mut i = 1 while i < lines.length() { @@ -542,26 +587,59 @@ pub fn parse_maf_content(content : String) -> MAFData { let fields = split_by_char(line, '\t'.to_int()) if fields.length() >= 8 { let mutation = MAFMutation::new( - if hugo_idx >= 0 { fields[hugo_idx] } else { "" }, - if chrom_idx >= 0 { fields[chrom_idx] } else { "" }, - if start_idx >= 0 { maftools_parse_int(fields[start_idx]) } else { 0 }, - if end_idx >= 0 { maftools_parse_int(fields[end_idx]) } else { 0 }, - if ref_idx >= 0 { fields[ref_idx] } else { "" }, - if alt_idx >= 0 { fields[alt_idx] } else { "" }, - if sample_idx >= 0 { fields[sample_idx] } else { "" }, - if variant_idx >= 0 { fields[variant_idx] } else { "" } + if hugo_idx >= 0 { + fields[hugo_idx] + } else { + "" + }, + if chrom_idx >= 0 { + fields[chrom_idx] + } else { + "" + }, + if start_idx >= 0 { + maftools_parse_int(fields[start_idx]) + } else { + 0 + }, + if end_idx >= 0 { + maftools_parse_int(fields[end_idx]) + } else { + 0 + }, + if ref_idx >= 0 { + fields[ref_idx] + } else { + "" + }, + if alt_idx >= 0 { + fields[alt_idx] + } else { + "" + }, + if sample_idx >= 0 { + fields[sample_idx] + } else { + "" + }, + if variant_idx >= 0 { + fields[variant_idx] + } else { + "" + }, ) maf = maf.add_mutation(mutation) } } i = i + 1 } - + maf } // Helper functions +///| fn maftools_contains_string(arr : Array[String], value : String) -> Bool { let mut i = 0 while i < arr.length() { @@ -573,7 +651,11 @@ fn maftools_contains_string(arr : Array[String], value : String) -> Bool { false } -fn maftools_find_column_index(header : Array[String], column_name : String) -> Int { +///| +fn maftools_find_column_index( + header : Array[String], + column_name : String, +) -> Int { let mut i = 0 while i < header.length() { if header[i].to_upper() == column_name.to_upper() { @@ -584,21 +666,26 @@ fn maftools_find_column_index(header : Array[String], column_name : String) -> I -1 } +///| fn maftools_parse_int(s : String) -> Int { parse_int(s) } -fn maftools_sort_by_count_desc(counts : Map[String, Int], top_n : Int) -> Array[String] { +///| +fn maftools_sort_by_count_desc( + counts : Map[String, Int], + top_n : Int, +) -> Array[String] { let entries = counts.iter().collect() let sorted : Array[(String, Int)] = Array::new() - + let mut i = 0 while i < entries.length() { let (key, value) = entries[i] sorted.push((key, value)) i = i + 1 } - + // Simple bubble sort by count descending let len = sorted.length() let mut j = 0 @@ -619,7 +706,7 @@ fn maftools_sort_by_count_desc(counts : Map[String, Int], top_n : Int) -> Array[ } j = j + 1 } - + let result : Array[String] = Array::new() let count = if top_n < sorted.length() { top_n } else { sorted.length() } let mut l = 0 @@ -627,11 +714,16 @@ fn maftools_sort_by_count_desc(counts : Map[String, Int], top_n : Int) -> Array[ result.push(sorted[l].0) l = l + 1 } - + result } -fn maftools_get_mutation_type_for_sample_gene(maf : MAFData, sample : String, gene : String) -> String { +///| +fn maftools_get_mutation_type_for_sample_gene( + maf : MAFData, + sample : String, + gene : String, +) -> String { let mut i = 0 while i < maf.mutations.length() { let mutation = maf.mutations[i] @@ -643,7 +735,11 @@ fn maftools_get_mutation_type_for_sample_gene(maf : MAFData, sample : String, ge "" } -fn maftools_get_samples_with_gene(maf : MAFData, gene : String) -> Array[String] { +///| +fn maftools_get_samples_with_gene( + maf : MAFData, + gene : String, +) -> Array[String] { let samples : Array[String] = Array::new() let mut i = 0 while i < maf.mutations.length() { diff --git a/src/markov.mbt b/src/markov.mbt index 03facf3a..174b5efa 100644 --- a/src/markov.mbt +++ b/src/markov.mbt @@ -41,14 +41,17 @@ pub struct MarkovModel { pseudo_count : Double } +///| fn markov_empty_map_kv() -> Map[String, Map[String, Double]] { Map([], capacity=16) } +///| fn markov_empty_map_d() -> Map[String, Double] { Map([], capacity=16) } +///| fn markov_empty_map_u() -> Map[String, Unit] { Map([], capacity=16) } @@ -88,8 +91,8 @@ pub fn MarkovModel::default_protein() -> MarkovModel { order: 1, chain_type: FirstOrder, states: [ - "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", - "M", "N", "P", "Q", "R", "S", "T", "V", "W", "Y", + "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", "M", "N", "P", "Q", "R", + "S", "T", "V", "W", "Y", ], transition_counts: markov_empty_map_kv(), transition_probs: markov_empty_map_kv(), @@ -123,7 +126,10 @@ pub fn MarkovModel::set_order(self : MarkovModel, val : Int) -> MarkovModel { ///| /// Set states, returning new model. -pub fn MarkovModel::set_states(self : MarkovModel, states~ : Array[String]) -> MarkovModel { +pub fn MarkovModel::set_states( + self : MarkovModel, + states~ : Array[String], +) -> MarkovModel { MarkovModel::{ order: self.order, chain_type: self.chain_type, @@ -137,7 +143,10 @@ pub fn MarkovModel::set_states(self : MarkovModel, states~ : Array[String]) -> M ///| /// Set chain_type, returning new model. -pub fn MarkovModel::set_chain_type(self : MarkovModel, val~ : ChainType) -> MarkovModel { +pub fn MarkovModel::set_chain_type( + self : MarkovModel, + val~ : ChainType, +) -> MarkovModel { let ord = match val { FirstOrder => 1 SecondOrder => 2 @@ -156,7 +165,10 @@ pub fn MarkovModel::set_chain_type(self : MarkovModel, val~ : ChainType) -> Mark ///| /// Set pseudo_count, returning new model. -pub fn MarkovModel::set_pseudo_count(self : MarkovModel, val : Double) -> MarkovModel { +pub fn MarkovModel::set_pseudo_count( + self : MarkovModel, + val : Double, +) -> MarkovModel { MarkovModel::{ order: self.order, chain_type: self.chain_type, @@ -221,7 +233,10 @@ pub fn markov_build_model( if n > actual_order { let start_kmer = substring(seq, 0, actual_order) if initial_counts.contains(start_kmer) { - initial_counts.set(start_kmer, initial_counts.get(start_kmer).unwrap() + 1.0) + initial_counts.set( + start_kmer, + initial_counts.get(start_kmer).unwrap() + 1.0, + ) } else { initial_counts.set(start_kmer, 1.0) } @@ -344,14 +359,22 @@ fn markov_get_trans_prob( vi = vi + 1 } let denom = row_total + model.pseudo_count * n - if denom > 0.0 { model.pseudo_count / denom } else { 1.0 / n } + if denom > 0.0 { + model.pseudo_count / denom + } else { + 1.0 / n + } } } None => { // Completely unseen context. Use pseudo-weighted uniform: // P = pseudo / (1 + pseudo * N). Higher pseudo -> higher prob, closer to 1/N. let denom = 1.0 + model.pseudo_count * n - if denom > 0.0 { model.pseudo_count / denom } else { 1.0 / n } + if denom > 0.0 { + model.pseudo_count / denom + } else { + 1.0 / n + } } } } @@ -365,7 +388,11 @@ fn markov_get_init_prob(model : MarkovModel, kmer : String) -> Double { let n = model.initial_probs.length() if n > 0 { let denom = model.pseudo_count * (n + 1).to_double() - if denom > 0.0 { model.pseudo_count / denom } else { 1.0 / n.to_double() } + if denom > 0.0 { + model.pseudo_count / denom + } else { + 1.0 / n.to_double() + } } else { 1.0 / model.states.length().to_double() } @@ -398,7 +425,10 @@ pub fn markov_score_sequence(model : MarkovModel, sequence : String) -> Double { ///| /// Compute per-position log probabilities. -pub fn markov_score_per_base(model : MarkovModel, sequence : String) -> Array[Double] { +pub fn markov_score_per_base( + model : MarkovModel, + sequence : String, +) -> Array[Double] { let n = sequence.length() let result : Array[Double] = Array::new() if n <= model.order { @@ -435,7 +465,11 @@ fn markov_weighted_sample( } si = si + 1 } - if states.length() > 0 { states[states.length() - 1] } else { "" } + if states.length() > 0 { + states[states.length() - 1] + } else { + "" + } } ///| @@ -494,7 +528,11 @@ pub fn markov_generate_sequence( } let take = if model.order > length { length } else { model.order } - let mut result = if context.length() >= take { substring(context, 0, take) } else { context } + let mut result = if context.length() >= take { + substring(context, 0, take) + } else { + context + } let mut step = result.length() while step < length { @@ -507,7 +545,7 @@ pub fn markov_generate_sequence( let r_next = rng_state.to_double() / modulus let next_char = match model.transition_probs.get(ctx) { Some(row) => markov_weighted_sample(row, model.states, r_next) - None => { + None => if n_states > 0 { let idx_f = r_next * n_states.to_double() let idx = idx_f.to_int() @@ -517,7 +555,6 @@ pub fn markov_generate_sequence( } else { "" } - } } result = result + next_char step = step + 1 @@ -544,7 +581,9 @@ pub fn markov_log_odds( ///| /// Compute stationary distribution via iterative multiplication. -pub fn markov_stationary_distribution(model : MarkovModel) -> Map[String, Double] { +pub fn markov_stationary_distribution( + model : MarkovModel, +) -> Map[String, Double] { let states = model.states let n = states.length() let dist = markov_empty_map_d() diff --git a/src/mast_motif.mbt b/src/mast_motif.mbt index 2c031846..ecf4647e 100644 --- a/src/mast_motif.mbt +++ b/src/mast_motif.mbt @@ -227,7 +227,8 @@ pub fn mast_motif_parse(text : String) -> MastMotifRecord { for p in parts { let s = p.trim().to_string() if s.length() > 0 { - if s.starts_with("v") || (s[0:1].to_string() >= "0" && s[0:1].to_string() <= "9") { + if s.starts_with("v") || + (s[0:1].to_string() >= "0" && s[0:1].to_string() <= "9") { record.version = s } } @@ -278,9 +279,9 @@ pub fn mast_motif_parse(text : String) -> MastMotifRecord { } } // Sequence match lines (in SECTION III or similar) - if section.contains("III") || section.contains("RESULT") || section.contains( - "DETAILED", - ) { + if section.contains("III") || + section.contains("RESULT") || + section.contains("DETAILED") { // Parse sequence lines with p-values // Format: "sequence_name description length p-value e-value" let parts = trimmed.split(" ").to_array() @@ -390,7 +391,9 @@ pub fn mast_motif_record_to_string(record : MastMotifRecord) -> String { sb.write_string(" Version: " + record.version + "\n") sb.write_string(" Database: " + record.database + "\n") sb.write_string(" Motifs: " + record.motif_count.to_string() + "\n") - sb.write_string(" Sequences with hits: " + record.hit_count.to_string() + "\n") + sb.write_string( + " Sequences with hits: " + record.hit_count.to_string() + "\n", + ) sb.write_string("\nMotif summary:\n") for m in record.motifs { sb.write_string(" " + m.id + " (width=" + m.width.to_string() + ")\n") diff --git a/src/matrix.mbt b/src/matrix.mbt index f44049d1..48acc3ab 100644 --- a/src/matrix.mbt +++ b/src/matrix.mbt @@ -23,7 +23,11 @@ pub struct BiocMatrix { } ///| -pub fn BiocMatrix::new(matrix_type : BiocMatrixType, nrow : Int, ncol : Int) -> BiocMatrix { +pub fn BiocMatrix::new( + matrix_type : BiocMatrixType, + nrow : Int, + ncol : Int, +) -> BiocMatrix { BiocMatrix::{ matrix_type, nrow, @@ -31,7 +35,7 @@ pub fn BiocMatrix::new(matrix_type : BiocMatrixType, nrow : Int, ncol : Int) -> data: Array::new(), row_indices: Array::new(), col_indices: Array::new(), - ptr: Array::new() + ptr: Array::new(), } } @@ -39,7 +43,7 @@ pub fn BiocMatrix::new(matrix_type : BiocMatrixType, nrow : Int, ncol : Int) -> pub fn BiocMatrix::dense_from_array(data : Array[Array[Double]]) -> BiocMatrix { let nrow = data.length() let ncol = if nrow > 0 { data[0].length() } else { 0 } - + let flat_data : Array[Double] = Array::new() let mut i = 0 while i < nrow { @@ -50,7 +54,7 @@ pub fn BiocMatrix::dense_from_array(data : Array[Array[Double]]) -> BiocMatrix { } i = i + 1 } - + BiocMatrix::{ matrix_type: BiocDenseMatrix, nrow, @@ -58,24 +62,30 @@ pub fn BiocMatrix::dense_from_array(data : Array[Array[Double]]) -> BiocMatrix { data: flat_data, row_indices: Array::new(), col_indices: Array::new(), - ptr: Array::new() + ptr: Array::new(), } } ///| -pub fn BiocMatrix::csc_from_triplets(row_idx : Array[Int], col_idx : Array[Int], values : Array[Double], nrow : Int, ncol : Int) -> BiocMatrix { +pub fn BiocMatrix::csc_from_triplets( + row_idx : Array[Int], + col_idx : Array[Int], + values : Array[Double], + nrow : Int, + ncol : Int, +) -> BiocMatrix { let sorted_indices = sort_triplets(row_idx, col_idx, values) let sorted_rows = sorted_indices.0 let sorted_cols = sorted_indices.1 let sorted_values = sorted_indices.2 - + let ptr : Array[Int] = Array::new() ptr.push(0) - + let mut current_col = 0 let mut count = 0 let mut i = 0 - + while i < sorted_cols.length() { if sorted_cols[i] == current_col { count = count + 1 @@ -87,7 +97,7 @@ pub fn BiocMatrix::csc_from_triplets(row_idx : Array[Int], col_idx : Array[Int], i = i + 1 } ptr.push(ptr[ptr.length() - 1] + count) - + BiocMatrix::{ matrix_type: BiocSparseMatrixCSC, nrow, @@ -95,24 +105,30 @@ pub fn BiocMatrix::csc_from_triplets(row_idx : Array[Int], col_idx : Array[Int], data: sorted_values, row_indices: sorted_rows, col_indices: sorted_cols, - ptr: ptr + ptr, } } ///| -pub fn BiocMatrix::csr_from_triplets(row_idx : Array[Int], col_idx : Array[Int], values : Array[Double], nrow : Int, ncol : Int) -> BiocMatrix { +pub fn BiocMatrix::csr_from_triplets( + row_idx : Array[Int], + col_idx : Array[Int], + values : Array[Double], + nrow : Int, + ncol : Int, +) -> BiocMatrix { let sorted_indices = sort_triplets_by_row(row_idx, col_idx, values) let sorted_rows = sorted_indices.0 let sorted_cols = sorted_indices.1 let sorted_values = sorted_indices.2 - + let ptr : Array[Int] = Array::new() ptr.push(0) - + let mut current_row = 0 let mut count = 0 let mut i = 0 - + while i < sorted_rows.length() { if sorted_rows[i] == current_row { count = count + 1 @@ -124,7 +140,7 @@ pub fn BiocMatrix::csr_from_triplets(row_idx : Array[Int], col_idx : Array[Int], i = i + 1 } ptr.push(ptr[ptr.length() - 1] + count) - + BiocMatrix::{ matrix_type: BiocSparseMatrixCSR, nrow, @@ -132,12 +148,16 @@ pub fn BiocMatrix::csr_from_triplets(row_idx : Array[Int], col_idx : Array[Int], data: sorted_values, row_indices: sorted_rows, col_indices: sorted_cols, - ptr: ptr + ptr, } } ///| -fn sort_triplets(row_idx : Array[Int], col_idx : Array[Int], values : Array[Double]) -> (Array[Int], Array[Int], Array[Double]) { +fn sort_triplets( + row_idx : Array[Int], + col_idx : Array[Int], + values : Array[Double], +) -> (Array[Int], Array[Int], Array[Double]) { let n = row_idx.length() let indices : Array[Int] = Array::new() let mut i = 0 @@ -145,15 +165,18 @@ fn sort_triplets(row_idx : Array[Int], col_idx : Array[Int], values : Array[Doub indices.push(i) i = i + 1 } - + let mut sorted = false while !sorted { sorted = true i = 0 while i < n - 1 { let j = i + 1 - if col_idx[indices[i]] > col_idx[indices[j]] || - (col_idx[indices[i]] == col_idx[indices[j]] && row_idx[indices[i]] > row_idx[indices[j]]) { + if col_idx[indices[i]] > col_idx[indices[j]] || + ( + col_idx[indices[i]] == col_idx[indices[j]] && + row_idx[indices[i]] > row_idx[indices[j]] + ) { let temp = indices[i] indices[i] = indices[j] indices[j] = temp @@ -162,11 +185,11 @@ fn sort_triplets(row_idx : Array[Int], col_idx : Array[Int], values : Array[Doub i = i + 1 } } - + let sorted_rows : Array[Int] = Array::new() let sorted_cols : Array[Int] = Array::new() let sorted_values : Array[Double] = Array::new() - + i = 0 while i < n { sorted_rows.push(row_idx[indices[i]]) @@ -174,12 +197,16 @@ fn sort_triplets(row_idx : Array[Int], col_idx : Array[Int], values : Array[Doub sorted_values.push(values[indices[i]]) i = i + 1 } - + (sorted_rows, sorted_cols, sorted_values) } ///| -fn sort_triplets_by_row(row_idx : Array[Int], col_idx : Array[Int], values : Array[Double]) -> (Array[Int], Array[Int], Array[Double]) { +fn sort_triplets_by_row( + row_idx : Array[Int], + col_idx : Array[Int], + values : Array[Double], +) -> (Array[Int], Array[Int], Array[Double]) { let n = row_idx.length() let indices : Array[Int] = Array::new() let mut i = 0 @@ -187,15 +214,18 @@ fn sort_triplets_by_row(row_idx : Array[Int], col_idx : Array[Int], values : Arr indices.push(i) i = i + 1 } - + let mut sorted = false while !sorted { sorted = true i = 0 while i < n - 1 { let j = i + 1 - if row_idx[indices[i]] > row_idx[indices[j]] || - (row_idx[indices[i]] == row_idx[indices[j]] && col_idx[indices[i]] > col_idx[indices[j]]) { + if row_idx[indices[i]] > row_idx[indices[j]] || + ( + row_idx[indices[i]] == row_idx[indices[j]] && + col_idx[indices[i]] > col_idx[indices[j]] + ) { let temp = indices[i] indices[i] = indices[j] indices[j] = temp @@ -204,11 +234,11 @@ fn sort_triplets_by_row(row_idx : Array[Int], col_idx : Array[Int], values : Arr i = i + 1 } } - + let sorted_rows : Array[Int] = Array::new() let sorted_cols : Array[Int] = Array::new() let sorted_values : Array[Double] = Array::new() - + i = 0 while i < n { sorted_rows.push(row_idx[indices[i]]) @@ -216,7 +246,7 @@ fn sort_triplets_by_row(row_idx : Array[Int], col_idx : Array[Int], values : Arr sorted_values.push(values[indices[i]]) i = i + 1 } - + (sorted_rows, sorted_cols, sorted_values) } @@ -225,7 +255,7 @@ pub fn BiocMatrix::get(self : BiocMatrix, i : Int, j : Int) -> Double { if i < 0 || i >= self.nrow || j < 0 || j >= self.ncol { return 0.0 } - + match self.matrix_type { BiocDenseMatrix => { let idx = i * self.ncol + j @@ -259,22 +289,26 @@ pub fn BiocMatrix::get(self : BiocMatrix, i : Int, j : Int) -> Double { } 0.0 } - BiocDiagonalMatrix => { + BiocDiagonalMatrix => if i == j && i < self.data.length() { self.data[i] } else { 0.0 } - } } } ///| -pub fn BiocMatrix::set(self : BiocMatrix, i : Int, j : Int, value : Double) -> BiocMatrix { +pub fn BiocMatrix::set( + self : BiocMatrix, + i : Int, + j : Int, + value : Double, +) -> BiocMatrix { if i < 0 || i >= self.nrow || j < 0 || j >= self.ncol { return self } - + match self.matrix_type { BiocDenseMatrix => { let idx = i * self.ncol + j @@ -289,7 +323,7 @@ pub fn BiocMatrix::set(self : BiocMatrix, i : Int, j : Int, value : Double) -> B data: new_data, row_indices: self.row_indices, col_indices: self.col_indices, - ptr: self.ptr + ptr: self.ptr, } } _ => self @@ -314,12 +348,22 @@ pub fn BiocMatrix::transpose(self : BiocMatrix) -> BiocMatrix { } BiocMatrix::dense_from_array(result_data) } - BiocSparseMatrixCSC => { - BiocMatrix::csr_from_triplets(self.col_indices, self.row_indices, self.data, self.ncol, self.nrow) - } - BiocSparseMatrixCSR => { - BiocMatrix::csc_from_triplets(self.col_indices, self.row_indices, self.data, self.ncol, self.nrow) - } + BiocSparseMatrixCSC => + BiocMatrix::csr_from_triplets( + self.col_indices, + self.row_indices, + self.data, + self.ncol, + self.nrow, + ) + BiocSparseMatrixCSR => + BiocMatrix::csc_from_triplets( + self.col_indices, + self.row_indices, + self.data, + self.ncol, + self.nrow, + ) BiocDiagonalMatrix => self } } @@ -329,7 +373,7 @@ pub fn BiocMatrix::add(self : BiocMatrix, other : BiocMatrix) -> BiocMatrix? { if self.nrow != other.nrow || self.ncol != other.ncol { return None } - + let result_data : Array[Array[Double]] = Array::new() let mut i = 0 while i < self.nrow { @@ -342,16 +386,19 @@ pub fn BiocMatrix::add(self : BiocMatrix, other : BiocMatrix) -> BiocMatrix? { result_data.push(row) i = i + 1 } - + Some(BiocMatrix::dense_from_array(result_data)) } ///| -pub fn BiocMatrix::multiply(self : BiocMatrix, other : BiocMatrix) -> BiocMatrix? { +pub fn BiocMatrix::multiply( + self : BiocMatrix, + other : BiocMatrix, +) -> BiocMatrix? { if self.ncol != other.nrow { return None } - + let result_data : Array[Array[Double]] = Array::new() let mut i = 0 while i < self.nrow { @@ -370,7 +417,7 @@ pub fn BiocMatrix::multiply(self : BiocMatrix, other : BiocMatrix) -> BiocMatrix result_data.push(row) i = i + 1 } - + Some(BiocMatrix::dense_from_array(result_data)) } @@ -435,7 +482,7 @@ pub fn BiocMatrix::col_means(self : BiocMatrix) -> Array[Double] { ///| pub fn BiocMatrix::norm(self : BiocMatrix, p : Double) -> Double { let mut sum = 0.0 - + match self.matrix_type { BiocDenseMatrix => { let mut i = 0 @@ -459,7 +506,7 @@ pub fn BiocMatrix::norm(self : BiocMatrix, p : Double) -> Double { } } } - + @math.pow(sum, 1.0 / p) } @@ -488,7 +535,7 @@ pub fn create_example_dense_matrix() -> BiocMatrix { BiocMatrix::dense_from_array([ [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], - [7.0, 8.0, 9.0] + [7.0, 8.0, 9.0], ]) } @@ -499,6 +546,6 @@ pub fn create_example_sparse_matrix() -> BiocMatrix { [0, 0, 0, 1, 1, 1], [1.0, 4.0, 7.0, 2.0, 5.0, 8.0], 3, - 2 + 2, ) } diff --git a/src/matrix_generics.mbt b/src/matrix_generics.mbt index 9194c6f6..fa81e0a8 100644 --- a/src/matrix_generics.mbt +++ b/src/matrix_generics.mbt @@ -432,7 +432,11 @@ pub fn mg_block_apply_rows( let result : Array[Double] = Array::make(n_rows, 0.0) let mut start = 0 while start < n_rows { - let end = if start + block_size < n_rows { start + block_size } else { n_rows } + let end = if start + block_size < n_rows { + start + block_size + } else { + n_rows + } let block_data : Array[Array[Double]] = [] let mut i = start while i < end { @@ -469,7 +473,11 @@ pub fn mg_block_apply_cols( let result : Array[Double] = Array::make(n_cols, 0.0) let mut start = 0 while start < n_cols { - let end = if start + block_size < n_cols { start + block_size } else { n_cols } + let end = if start + block_size < n_cols { + start + block_size + } else { + n_cols + } let block_data : Array[Array[Double]] = [] let mut i = 0 while i < n_rows { diff --git a/src/mauve.mbt b/src/mauve.mbt index 00b54ed4..35086e82 100644 --- a/src/mauve.mbt +++ b/src/mauve.mbt @@ -153,7 +153,7 @@ pub fn mauve_seq_coverage(seq : MauveSequence) -> Double { if seq.seq_size == 0 { return 0.0 } - (seq.length.to_double() / seq.seq_size.to_double()) * 100.0 + seq.length.to_double() / seq.seq_size.to_double() * 100.0 } // ============================================================================ @@ -163,12 +163,7 @@ pub fn mauve_seq_coverage(seq : MauveSequence) -> Double { ///| /// Create a new empty MauveLCB. pub fn new_mauve_lcb(id : String) -> MauveLCB { - MauveLCB::{ - id, - score: 0.0, - sequences: Array::new(), - is_collinear: true, - } + MauveLCB::{ id, score: 0.0, sequences: Array::new(), is_collinear: true } } ///| @@ -261,7 +256,10 @@ pub fn mauve_all_seq_names(ali : MauveAlignment) -> Array[String] { ///| /// Get sequences for a specific genome. -pub fn mauve_get_genome_seqs(ali : MauveAlignment, genome_name : String) -> Array[MauveSequence] { +pub fn mauve_get_genome_seqs( + ali : MauveAlignment, + genome_name : String, +) -> Array[MauveSequence] { let seqs = Array::new() let prefix_len = genome_name.length() for l = 0; l < ali.lcbs.length(); l = l + 1 { @@ -292,11 +290,11 @@ pub fn parse_mauve(content : String) -> MauveAlignment { let lines = content.split("\n").to_array() let mut current_lcb : MauveLCB? = None let mut lcb_counter = 0 - + for i = 0; i < lines.length(); i = i + 1 { let line = lines[i].to_owned() let trimmed = trim(line) - + if trimmed.length() == 0 { match current_lcb { Some(lcb) => { @@ -308,25 +306,28 @@ pub fn parse_mauve(content : String) -> MauveAlignment { } continue } - + if starts_with(trimmed, 0, "##maf") || starts_with(trimmed, 0, "##mauve") { if contains(trimmed, "version=") { let parts = split_by_char(trimmed, ' '.to_int()) for p = 0; p < parts.length(); p = p + 1 { let part = parts[p] if starts_with(part, 0, "version=") { - result = MauveAlignment::{ ..result, version: part[8:part.length()].to_owned() } + result = MauveAlignment::{ + ..result, + version: part[8:part.length()].to_owned(), + } } } } continue } - + if starts_with(trimmed, 0, "a ") { lcb_counter = lcb_counter + 1 let lcb_id = "" + "lcb_" + lcb_counter.to_string() current_lcb = Some(new_mauve_lcb(lcb_id)) - + let parts = split_by_char(trimmed, ' '.to_int()) for p = 0; p < parts.length(); p = p + 1 { let part = parts[p] @@ -334,8 +335,12 @@ pub fn parse_mauve(content : String) -> MauveAlignment { let score_val = parse_double(part[6:part.length()].to_owned()) match current_lcb { Some(lcb) => { - let score = if score_val is Some(_) { score_val.unwrap() } else { 0.0 } - let new_lcb = MauveLCB::{ ..lcb, score: score } + let score = if score_val is Some(_) { + score_val.unwrap() + } else { + 0.0 + } + let new_lcb = MauveLCB::{ ..lcb, score, } current_lcb = Some(new_lcb) ignore(()) } @@ -345,7 +350,10 @@ pub fn parse_mauve(content : String) -> MauveAlignment { let val = part[10:part.length()].to_owned() match current_lcb { Some(lcb) => { - let new_lcb = MauveLCB::{ ..lcb, is_collinear: val == "yes" || val == "1" } + let new_lcb = MauveLCB::{ + ..lcb, + is_collinear: val == "yes" || val == "1", + } current_lcb = Some(new_lcb) ignore(()) } @@ -355,13 +363,13 @@ pub fn parse_mauve(content : String) -> MauveAlignment { } continue } - + if starts_with(trimmed, 0, "s ") || starts_with(trimmed, 0, "s\t") { if current_lcb is None { lcb_counter = lcb_counter + 1 current_lcb = Some(new_mauve_lcb("lcb_" + lcb_counter.to_string())) } - + let mut parts = split_by_tab(trimmed) if parts.length() < 6 { parts = split_by_char(trimmed, ' '.to_int()) @@ -373,7 +381,7 @@ pub fn parse_mauve(content : String) -> MauveAlignment { let strand = parts[4] let seq_size = parse_int(parts[5]) let end = start + length - + let seq = new_mauve_sequence(name, start, end, strand, seq_size) match current_lcb { Some(lcb) => { @@ -386,7 +394,7 @@ pub fn parse_mauve(content : String) -> MauveAlignment { } continue } - + if starts_with(trimmed, 0, "g ") { let parts = split_by_char(trimmed, ' '.to_int()) if parts.length() >= 3 { @@ -405,7 +413,7 @@ pub fn parse_mauve(content : String) -> MauveAlignment { continue } } - + match current_lcb { Some(lcb) => { result.lcbs.push(lcb) @@ -413,10 +421,10 @@ pub fn parse_mauve(content : String) -> MauveAlignment { } None => ignore(()) } - + result = detect_mauve_inversions(result) result = detect_mauve_breakpoints(result) - + result } @@ -429,41 +437,51 @@ pub fn parse_mauve(content : String) -> MauveAlignment { pub fn detect_mauve_inversions(ali : MauveAlignment) -> MauveAlignment { let result = ali let seq_names = mauve_all_seq_names(result) - + for n = 0; n < seq_names.length(); n = n + 1 { let name = seq_names[n] let seqs = mauve_get_genome_seqs(result, name) if seqs.length() < 2 { continue } - + for i = 1; i < seqs.length(); i = i + 1 { let prev = seqs[i - 1] let curr = seqs[i] - + if prev.strand != curr.strand { - let inv_start = if prev.start < curr.start { prev.start } else { curr.start } + let inv_start = if prev.start < curr.start { + prev.start + } else { + curr.start + } let inv_end = if prev.end > curr.end { prev.end } else { curr.end } let inv = MauveInversion::{ seq_name: name, start: inv_start, end: inv_end, - length: if curr.end - prev.start > 0 { curr.end - prev.start } else { prev.start - curr.end }, + length: if curr.end - prev.start > 0 { + curr.end - prev.start + } else { + prev.start - curr.end + }, affected_lcbs: Array::new(), } - + for l = 0; l < result.lcbs.length(); l = l + 1 { let lcb = result.lcbs[l] for s = 0; s < lcb.sequences.length(); s = s + 1 { let seq = lcb.sequences[s] - if seq.name == name && - ((seq.start >= inv.start && seq.end <= inv.end) || - (seq.end >= inv.start && seq.start <= inv.end)) { + if seq.name == name && + ( + (seq.start >= inv.start && seq.end <= inv.end) || + (seq.end >= inv.start && seq.start <= inv.end) + ) { inv.affected_lcbs.push(lcb.id) } } } - + result.inversions.push(inv) } } @@ -478,21 +496,33 @@ pub fn detect_mauve_breakpoints(ali : MauveAlignment) -> MauveAlignment { if result.lcbs.length() < 2 { return result } - + for i = 1; i < result.lcbs.length(); i = i + 1 { let prev_lcb = result.lcbs[i - 1] let curr_lcb = result.lcbs[i] - + for ps = 0; ps < prev_lcb.sequences.length(); ps = ps + 1 { let prev_seq = prev_lcb.sequences[ps] for cs = 0; cs < curr_lcb.sequences.length(); cs = cs + 1 { let curr_seq = curr_lcb.sequences[cs] if prev_seq.name == curr_seq.name { - let gap_start = if prev_seq.end > curr_seq.start { prev_seq.end } else { curr_seq.start } - let gap_end = if prev_seq.start < curr_seq.end { prev_seq.start } else { curr_seq.end } - + let gap_start = if prev_seq.end > curr_seq.start { + prev_seq.end + } else { + curr_seq.start + } + let gap_end = if prev_seq.start < curr_seq.end { + prev_seq.start + } else { + curr_seq.end + } + if gap_start > gap_end { - let bp_type = if prev_seq.strand != curr_seq.strand { "inversion" } else { "translocation" } + let bp_type = if prev_seq.strand != curr_seq.strand { + "inversion" + } else { + "translocation" + } let bp = MauveBreakpoint::{ lcb1_id: prev_lcb.id, lcb2_id: curr_lcb.id, @@ -521,13 +551,7 @@ pub fn new_mauve_inversion( end : Int, length : Int, ) -> MauveInversion { - MauveInversion::{ - seq_name, - start, - end, - length, - affected_lcbs: Array::new(), - } + MauveInversion::{ seq_name, start, end, length, affected_lcbs: Array::new() } } ///| @@ -535,29 +559,33 @@ pub fn new_mauve_inversion( pub fn mauve_genome_coverage(ali : MauveAlignment) -> Map[String, Double] { let coverage = Map([], capacity=10) let seq_names = mauve_all_seq_names(ali) - + for n = 0; n < seq_names.length(); n = n + 1 { let name = seq_names[n] let seqs = mauve_get_genome_seqs(ali, name) let mut total_aligned = 0.0 let mut max_end = 0 let mut min_start = 99999999 - + for s = 0; s < seqs.length(); s = s + 1 { let seq = seqs[s] total_aligned = total_aligned + seq.length.to_double() - if seq.end > max_end { max_end = seq.end } - if seq.start < min_start { min_start = seq.start } + if seq.end > max_end { + max_end = seq.end + } + if seq.start < min_start { + min_start = seq.start + } } - + let total_range = (max_end - min_start).to_double() if total_range > 0.0 { - coverage[name] = (total_aligned / total_range) * 100.0 + coverage[name] = total_aligned / total_range * 100.0 } else { coverage[name] = 0.0 } } - + coverage } @@ -566,13 +594,13 @@ pub fn mauve_genome_coverage(ali : MauveAlignment) -> Map[String, Double] { pub fn mauve_conserved_segments(ali : MauveAlignment) -> Map[String, Int] { let segments = Map([], capacity=10) let seq_names = mauve_all_seq_names(ali) - + for n = 0; n < seq_names.length(); n = n + 1 { let name = seq_names[n] let count = mauve_get_genome_seqs(ali, name).length() segments[name] = count } - + segments } @@ -583,7 +611,7 @@ pub fn mauve_rearrangement_rate(ali : MauveAlignment) -> Double { if total_size == 0 { return 0.0 } - (ali.breakpoints.length().to_double() / total_size.to_double()) * 1000000.0 + ali.breakpoints.length().to_double() / total_size.to_double() * 1000000.0 } ///| @@ -592,7 +620,7 @@ pub fn mauve_syntenic_regions(ali : MauveAlignment) -> Array[Array[String]] { let regions = Array::new() let mut current_region = Array::new() let mut prev_collinear = true - + for l = 0; l < ali.lcbs.length(); l = l + 1 { let lcb = ali.lcbs[l] if lcb.is_collinear && prev_collinear { @@ -608,29 +636,37 @@ pub fn mauve_syntenic_regions(ali : MauveAlignment) -> Array[Array[String]] { } prev_collinear = lcb.is_collinear } - + if current_region.length() > 0 { regions.push(current_region) } - + regions } ///| /// Filter LCBs by score threshold. -pub fn mauve_filter_lcbs(ali : MauveAlignment, min_score : Double) -> MauveAlignment { - let mut result = MauveAlignment::{ ..ali, lcbs: Array::new(), inversions: Array::new(), breakpoints: Array::new() } - +pub fn mauve_filter_lcbs( + ali : MauveAlignment, + min_score : Double, +) -> MauveAlignment { + let mut result = MauveAlignment::{ + ..ali, + lcbs: Array::new(), + inversions: Array::new(), + breakpoints: Array::new(), + } + for l = 0; l < ali.lcbs.length(); l = l + 1 { let lcb = ali.lcbs[l] if lcb.score >= min_score { result.lcbs.push(lcb) } } - + result = detect_mauve_inversions(result) result = detect_mauve_breakpoints(result) - + result } @@ -661,7 +697,10 @@ pub fn new_mauve_progressive_aligner() -> MauveProgressiveAligner { ///| /// Add a sequence to the progressive alignment. -pub fn mauve_add_sequence(aligner : MauveProgressiveAligner, seq_name : String) -> Unit { +pub fn mauve_add_sequence( + aligner : MauveProgressiveAligner, + seq_name : String, +) -> Unit { aligner.pending_seqs.push(seq_name) } @@ -679,15 +718,17 @@ pub fn mauve_build_guide_tree(aligner : MauveProgressiveAligner) -> Unit { ///| /// Execute progressive alignment by adding sequences one at a time. -pub fn mauve_execute_progressive(aligner : MauveProgressiveAligner) -> MauveAlignment { +pub fn mauve_execute_progressive( + aligner : MauveProgressiveAligner, +) -> MauveAlignment { mauve_build_guide_tree(aligner) - + let result = aligner.alignment - + for i = 0; i < aligner.guide_tree.length(); i = i + 1 { result.groups[i] = aligner.guide_tree[i] } - + result } @@ -701,15 +742,15 @@ pub fn mauve_summary(ali : MauveAlignment) -> String { let mut result = "" result = result + "Mauve Alignment Summary\n" result = result + "====================\n\n" - + result = result + "Version: " result = result + ali.version result = result + "\n\n" - + result = result + "Locally Collinear Blocks (LCBs): " result = result + ali.lcbs.length().to_string() result = result + "\n\n" - + result = result + "Genomes aligned:\n" let seq_names = mauve_all_seq_names(ali) let coverage = mauve_genome_coverage(ali) @@ -721,12 +762,12 @@ pub fn mauve_summary(ali : MauveAlignment) -> String { result = result + coverage[name].to_string() result = result + "%)\n" } - + result = result + "\n" result = result + "Inversions detected: " result = result + ali.inversions.length().to_string() result = result + "\n" - + for i = 0; i < ali.inversions.length(); i = i + 1 { let inv = ali.inversions[i] result = result + " - " @@ -739,12 +780,12 @@ pub fn mauve_summary(ali : MauveAlignment) -> String { result = result + inv.length.to_string() result = result + " bp)\n" } - + result = result + "\n" result = result + "Breakpoints detected: " result = result + ali.breakpoints.length().to_string() result = result + "\n" - + let bp_types = Map([], capacity=5) for b = 0; b < ali.breakpoints.length(); b = b + 1 { let bp = ali.breakpoints[b] @@ -755,7 +796,7 @@ pub fn mauve_summary(ali : MauveAlignment) -> String { bp_types[bp.breakpoint_type] = 1 } } - + let bp_keys = bp_types.keys().collect() for k = 0; k < bp_keys.length(); k = k + 1 { let key = bp_keys[k] @@ -765,14 +806,14 @@ pub fn mauve_summary(ali : MauveAlignment) -> String { result = result + bp_types[key].to_string() result = result + "\n" } - + result = result + "\n" result = result + "Syntenic regions:\n" let syntenic = mauve_syntenic_regions(ali) result = result + " Number: " result = result + syntenic.length().to_string() result = result + "\n" - + let segments = mauve_conserved_segments(ali) result = result + "\nConserved segments per genome:\n" let seg_keys = segments.keys().collect() @@ -784,11 +825,11 @@ pub fn mauve_summary(ali : MauveAlignment) -> String { result = result + segments[key].to_string() result = result + " segments\n" } - + result = result + "\nRearrangement rate: " result = result + mauve_rearrangement_rate(ali).to_string() result = result + " breakpoints/Mb\n" - + result } @@ -796,8 +837,9 @@ pub fn mauve_summary(ali : MauveAlignment) -> String { /// Export alignment to BED format for visualization. pub fn mauve_to_bed(ali : MauveAlignment) -> String { let mut result = "" - result = result + "track name=\"MauveAlignment\" description=\"Mauve Alignment Blocks\"\n" - + result = result + + "track name=\"MauveAlignment\" description=\"Mauve Alignment Blocks\"\n" + for l = 0; l < ali.lcbs.length(); l = l + 1 { let lcb = ali.lcbs[l] for s = 0; s < lcb.sequences.length(); s = s + 1 { @@ -816,7 +858,7 @@ pub fn mauve_to_bed(ali : MauveAlignment) -> String { result = result + "\n" } } - + result } @@ -825,7 +867,7 @@ pub fn mauve_to_bed(ali : MauveAlignment) -> String { pub fn mauve_inversions_to_bed(ali : MauveAlignment) -> String { let mut result = "" result = result + "track name=\"Inversions\" color=\"100,0,0\"\n" - + for i = 0; i < ali.inversions.length(); i = i + 1 { let inv = ali.inversions[i] result = result + inv.seq_name @@ -837,6 +879,6 @@ pub fn mauve_inversions_to_bed(ali : MauveAlignment) -> String { result = result + inv.length.to_string() result = result + "\t-\n" } - + result -} \ No newline at end of file +} diff --git a/src/max_entropy.mbt b/src/max_entropy.mbt index 5639f4c4..83b76cd9 100644 --- a/src/max_entropy.mbt +++ b/src/max_entropy.mbt @@ -24,7 +24,7 @@ pub struct MaxEntFeature { pub fn MaxEntFeature::new( attribute_index : Int, attribute_value : String, - class_label : String + class_label : String, ) -> MaxEntFeature { MaxEntFeature::{ attribute_index, attribute_value, class_label } } @@ -53,7 +53,7 @@ pub fn MaxEntFeature::class_label(self : MaxEntFeature) -> String { pub fn max_ent_eval_feature( feature : MaxEntFeature, observation : Array[String], - class_label : String + class_label : String, ) -> Int { if feature.attribute_index >= 0 && feature.attribute_index < observation.length() && @@ -92,7 +92,7 @@ pub fn MaxEntropyModel::alphas(self : MaxEntropyModel) -> Array[Double] { ///| /// Accessor for the features. pub fn MaxEntropyModel::features( - self : MaxEntropyModel + self : MaxEntropyModel, ) -> Array[MaxEntFeature] { self.features } @@ -135,7 +135,7 @@ fn me_safe_log(x : Double) -> Double { /// matches and we're summing over the class that the feature refers to). fn me_f_correction( feature : MaxEntFeature, - observation : Array[String] + observation : Array[String], ) -> Double { // f^#(x) = sum_y f(x, y). Since f is 1 only for one class, f^# is at most 1. if feature.attribute_index >= 0 && @@ -157,16 +157,14 @@ fn me_f_correction( /// `model.classes`. pub fn max_entropy_calculate( model : MaxEntropyModel, - observation : Array[String] + observation : Array[String], ) -> Array[Double] { let scores = Array::make(model.classes.length(), 0.0) for ci in 0.. String { let scores = max_entropy_calculate(model, observation) let mut best_idx = 0 @@ -203,7 +201,7 @@ pub fn max_entropy_classify( pub fn max_entropy_train( training_set : Array[Array[String]], results : Array[String], - features : Array[MaxEntFeature] + features : Array[MaxEntFeature], ) -> MaxEntropyModel { let n = training_set.length() // Collect unique classes. @@ -222,9 +220,8 @@ pub fn max_entropy_train( for fi in 0.. (Array[ - Array[String] -], Array[String], Array[MaxEntFeature]) { +pub fn max_entropy_sample_data() -> ( + Array[Array[String]], + Array[String], + Array[MaxEntFeature], +) { let xs = [ ["Red", "Sports", "Domestic"], ["Red", "Sports", "Domestic"], @@ -329,9 +332,7 @@ pub fn max_entropy_sample_data() -> (Array[ ["Red", "SUV", "Imported"], ["Red", "Sports", "Imported"], ] - let ys = [ - "Yes", "No", "Yes", "No", "Yes", "No", "Yes", "No", "No", "Yes", - ] + let ys = ["Yes", "No", "Yes", "No", "Yes", "No", "Yes", "No", "No", "Yes"] let features = [ MaxEntFeature::new(0, "Red", "Yes"), MaxEntFeature::new(0, "Red", "No"), diff --git a/src/mcp_counter.mbt b/src/mcp_counter.mbt index 5189b988..d42eea97 100644 --- a/src/mcp_counter.mbt +++ b/src/mcp_counter.mbt @@ -77,13 +77,21 @@ pub fn McpResult::get_score( ) -> Double { let mut pop_idx = -1 for i in 0.. Array[Double] { let mut idx = -1 for i in 0.. Double { let n = values.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut sum_log = 0.0 let mut count = 0 for v in values { @@ -120,7 +135,9 @@ fn mcp_geometric_mean(values : Array[Double]) -> Double { count = count + 1 } } - if count == 0 { return 0.0 } + if count == 0 { + return 0.0 + } @math.exp(sum_log / count.to_double()) } @@ -181,7 +198,9 @@ pub fn mcp_default_populations() -> Array[McpCellPopulation] { pub fn mcp_population_names() -> Array[String] { let pops = mcp_default_populations() let names : Array[String] = [] - for p in pops { names.push(p.name) } + for p in pops { + names.push(p.name) + } names } @@ -273,9 +292,14 @@ pub fn mcp_sample_data() -> (Array[String], Array[String], Array[Array[Double]]) for m in pop.markers { let mut found = false for existing in all_markers { - if existing == m { found = true; break } + if existing == m { + found = true + break + } + } + if !found { + all_markers.push(m) } - if !found { all_markers.push(m) } } } let sample_names = ["Tumor_A", "Tumor_B", "Tumor_C"] @@ -290,7 +314,10 @@ pub fn mcp_sample_data() -> (Array[String], Array[String], Array[Array[Double]]) let mut pi = 0 while pi < pops.length() && pop_idx < 0 { for m in pops[pi].markers { - if m == gene { pop_idx = pi; break } + if m == gene { + pop_idx = pi + break + } } pi = pi + 1 } @@ -300,13 +327,19 @@ pub fn mcp_sample_data() -> (Array[String], Array[String], Array[Array[Double]]) let base_exprs = [5.0, 4.0, 3.0, 6.0, 2.0, 3.0, 2.0, 1.0, 1.0, 7.0] let val_a = if pop_idx == 0 || pop_idx == 1 || pop_idx == 2 { base_exprs[pop_idx] + 5.0 - } else { base_exprs[pop_idx] * 0.3 } + } else { + base_exprs[pop_idx] * 0.3 + } let val_b = if pop_idx == 3 { base_exprs[pop_idx] + 5.0 - } else { base_exprs[pop_idx] * 0.3 } + } else { + base_exprs[pop_idx] * 0.3 + } let val_c = if pop_idx == 9 { base_exprs[pop_idx] + 5.0 - } else { base_exprs[pop_idx] * 0.3 } + } else { + base_exprs[pop_idx] * 0.3 + } row.push(val_a) row.push(val_b) row.push(val_c) diff --git a/src/melting_temp.mbt b/src/melting_temp.mbt index d7f7fcbc..b4c706fd 100644 --- a/src/melting_temp.mbt +++ b/src/melting_temp.mbt @@ -8,17 +8,20 @@ pub struct MeltingTempResult { } ///| -pub fn MeltingTempResult::new(tm : Double, method : String) -> MeltingTempResult { +pub fn MeltingTempResult::new( + tm : Double, + method : String, +) -> MeltingTempResult { MeltingTempResult::{ tm, method } } ///| pub fn mt_wallace(seq : String) -> MeltingTempResult { let seq_upper = seq.to_upper() - + let mut gc_count = 0 let mut at_count = 0 - + let mut idx = 0 while idx < seq_upper.length() { let c = substring(seq_upper, idx, 1) @@ -29,9 +32,9 @@ pub fn mt_wallace(seq : String) -> MeltingTempResult { } idx = idx + 1 } - + let tm = 4.0 * gc_count.to_double() + 2.0 * at_count.to_double() - + MeltingTempResult::new(tm, "wallace") } @@ -39,9 +42,9 @@ pub fn mt_wallace(seq : String) -> MeltingTempResult { pub fn mt_gc_content(seq : String) -> MeltingTempResult { let seq_upper = seq.to_upper() let length = seq_upper.length().to_double() - + let mut gc_count = 0 - + let mut idx = 0 while idx < seq_upper.length() { let c = substring(seq_upper, idx, 1) @@ -50,9 +53,9 @@ pub fn mt_gc_content(seq : String) -> MeltingTempResult { } idx = idx + 1 } - + let tm = 64.9 + 41.0 * (gc_count.to_double() - 16.4) / length - + MeltingTempResult::new(tm, "gc_content") } @@ -64,10 +67,10 @@ pub fn create_example_dna() -> String { ///| pub fn recommend_tm_method(seq : String) -> String { let length = seq.length() - + if length <= 14 { "wallace" } else { "gc_content" } -} \ No newline at end of file +} diff --git a/src/meme.mbt b/src/meme.mbt index f0678a10..1d92bc94 100644 --- a/src/meme.mbt +++ b/src/meme.mbt @@ -44,7 +44,7 @@ pub struct MemeMotif { pub fn MemeMotif::new( name : String, pspm : Array[Array[Double]], - alphabet~ : String = "ACGT", + alphabet? : String = "ACGT", ) -> MemeMotif { let width = if pspm.length() > 0 { pspm.length() } else { 0 } MemeMotif::{ @@ -275,22 +275,18 @@ pub fn meme_parse(text : String) -> MemeRecord { // If we were building a motif, save it first if has_motif { finalize_motif( - record, - has_motif, - m_name, - m_alt_name, - m_alphabet, - m_nsites, - m_evalue, - m_url, - m_strands, - matrix_rows, + record, has_motif, m_name, m_alt_name, m_alphabet, m_nsites, m_evalue, + m_url, m_strands, matrix_rows, ) } in_matrix = false matrix_rows = Array::new() let parts = line.split(" ").to_array() - m_name = if parts.length() >= 2 { parts[1].trim().to_string() } else { "" } + m_name = if parts.length() >= 2 { + parts[1].trim().to_string() + } else { + "" + } m_alt_name = if parts.length() >= 3 { parts[2].trim().to_string() } else { @@ -323,16 +319,8 @@ pub fn meme_parse(text : String) -> MemeRecord { m_url = line.substring(start=4).trim().to_string() in_matrix = false finalize_motif( - record, - has_motif, - m_name, - m_alt_name, - m_alphabet, - m_nsites, - m_evalue, - m_url, - m_strands, - matrix_rows, + record, has_motif, m_name, m_alt_name, m_alphabet, m_nsites, m_evalue, m_url, + m_strands, matrix_rows, ) has_motif = false i = i + 1 @@ -449,7 +437,10 @@ fn parse_meme_double_field(text : String, field : String) -> Double { let mut i = 0 while i < rest.length() { let ch = rest[i:i + 1].to_string() - if (ch >= "0" && ch <= "9") || ch == "." || ch == "-" || ch == "+" || + if (ch >= "0" && ch <= "9") || + ch == "." || + ch == "-" || + ch == "+" || ch == "e" || ch == "E" { num_str.write_string(ch) diff --git a/src/metagenomeseq.mbt b/src/metagenomeseq.mbt index a3d7ce5d..8141dc2e 100644 --- a/src/metagenomeseq.mbt +++ b/src/metagenomeseq.mbt @@ -10,12 +10,16 @@ pub struct MRexperiment { } ///| -pub fn MRexperiment::new(counts : Array[Array[Int]], taxa_names : Array[String], sample_names : Array[String]) -> MRexperiment { +pub fn MRexperiment::new( + counts : Array[Array[Int]], + taxa_names : Array[String], + sample_names : Array[String], +) -> MRexperiment { MRexperiment::{ counts, taxa_names, sample_names, - sample_data: Map([], capacity=10) + sample_data: Map([], capacity=10), } } @@ -42,8 +46,22 @@ pub struct MGResult { } ///| -pub fn MGResult::new(taxa_name : String, log2_fold_change : Double, p_value : Double, adjusted_p_value : Double, zero_inflation_prob : Double, abundance_mean : Double) -> MGResult { - MGResult::{ taxa_name, log2_fold_change, p_value, adjusted_p_value, zero_inflation_prob, abundance_mean } +pub fn MGResult::new( + taxa_name : String, + log2_fold_change : Double, + p_value : Double, + adjusted_p_value : Double, + zero_inflation_prob : Double, + abundance_mean : Double, +) -> MGResult { + MGResult::{ + taxa_name, + log2_fold_change, + p_value, + adjusted_p_value, + zero_inflation_prob, + abundance_mean, + } } ///| @@ -60,9 +78,9 @@ pub fn mg_normalize_counts(obj : MRexperiment) -> MRexperiment { total_counts.push(sum) j = j + 1 } - + let median_depth = median_int(total_counts) - + let normalized : Array[Array[Int]] = Array::new() let mut i = 0 while i < obj.taxa_names.length() { @@ -70,7 +88,7 @@ pub fn mg_normalize_counts(obj : MRexperiment) -> MRexperiment { let mut j = 0 while j < obj.sample_names.length() { if total_counts[j] > 0 { - row.push((obj.counts[i][j] * median_depth) / total_counts[j]) + row.push(obj.counts[i][j] * median_depth / total_counts[j]) } else { row.push(0) } @@ -79,8 +97,13 @@ pub fn mg_normalize_counts(obj : MRexperiment) -> MRexperiment { normalized.push(row) i = i + 1 } - - MRexperiment::{ counts: normalized, taxa_names: obj.taxa_names, sample_names: obj.sample_names, sample_data: obj.sample_data } + + MRexperiment::{ + counts: normalized, + taxa_names: obj.taxa_names, + sample_names: obj.sample_names, + sample_data: obj.sample_data, + } } ///| @@ -102,7 +125,7 @@ fn median_int(arr : Array[Int]) -> Int { } n = n - 1 } - + if sorted.length() % 2 == 1 { sorted[sorted.length() / 2] } else { @@ -113,7 +136,7 @@ fn median_int(arr : Array[Int]) -> Int { ///| pub fn mg_calculate_zero_inflation(obj : MRexperiment) -> Array[Double] { let zero_probs : Array[Double] = Array::new() - + let mut i = 0 while i < obj.taxa_names.length() { let mut zeros = 0 @@ -127,17 +150,20 @@ pub fn mg_calculate_zero_inflation(obj : MRexperiment) -> Array[Double] { zero_probs.push(zeros.to_double() / obj.sample_names.length().to_double()) i = i + 1 } - + zero_probs } ///| -pub fn mg_test_zero_inflated(obj : MRexperiment, group : Array[String]) -> Array[MGResult] { +pub fn mg_test_zero_inflated( + obj : MRexperiment, + group : Array[String], +) -> Array[MGResult] { let results : Array[MGResult] = Array::new() - + let group0_indices : Array[Int] = Array::new() let group1_indices : Array[Int] = Array::new() - + let mut i = 0 while i < group.length() { if group[i] == "control" { @@ -147,51 +173,59 @@ pub fn mg_test_zero_inflated(obj : MRexperiment, group : Array[String]) -> Array } i = i + 1 } - + let zero_probs = mg_calculate_zero_inflation(obj) - + let mut t = 0 while t < obj.taxa_names.length() { let mut group0_sum = 0 for idx in group0_indices { group0_sum = group0_sum + obj.counts[t][idx] } - + let mut group1_sum = 0 for idx in group1_indices { group1_sum = group1_sum + obj.counts[t][idx] } - + let n0 = group0_indices.length() let n1 = group1_indices.length() - - let mean0 = if n0 > 0 { group0_sum.to_double() / n0.to_double() } else { 0.0 } - let mean1 = if n1 > 0 { group1_sum.to_double() / n1.to_double() } else { 0.0 } - + + let mean0 = if n0 > 0 { + group0_sum.to_double() / n0.to_double() + } else { + 0.0 + } + let mean1 = if n1 > 0 { + group1_sum.to_double() / n1.to_double() + } else { + 0.0 + } + let log2_fc = if mean0 > 0.0 && mean1 > 0.0 { - @math.log2(mean1 / mean0) - } else { - 0.0 - } - + @math.log2(mean1 / mean0) + } else { + 0.0 + } + let zero_prob = zero_probs[t] - + let p_value = 1.0 / (1.0 + log2_fc * log2_fc * (1.0 - zero_prob)) - + let adjusted_p = p_value * 0.1 - + let result = MGResult::new( obj.taxa_names[t], log2_fc, p_value, adjusted_p, zero_prob, - (mean0 + mean1) / 2.0 + (mean0 + mean1) / 2.0, ) results.push(result) t = t + 1 } - + results } @@ -203,11 +237,16 @@ pub fn create_example_mrexperiment() -> MRexperiment { [200, 220, 250, 200, 180, 150], [0, 0, 10, 50, 80, 100], [10, 5, 0, 0, 0, 0], - [80, 90, 100, 70, 60, 50] + [80, 90, 100, 70, 60, 50], + ] + + let taxa_names = [ + "Bacteroides", "Firmicutes", "Actinobacteria", "Proteobacteria", "Fusobacteria", + "Verrucomicrobia", + ] + let sample_names = [ + "control1", "control2", "control3", "treatment1", "treatment2", "treatment3", ] - - let taxa_names = ["Bacteroides", "Firmicutes", "Actinobacteria", "Proteobacteria", "Fusobacteria", "Verrucomicrobia"] - let sample_names = ["control1", "control2", "control3", "treatment1", "treatment2", "treatment3"] - + MRexperiment::new(counts, taxa_names, sample_names) -} \ No newline at end of file +} diff --git a/src/methyl_seekr.mbt b/src/methyl_seekr.mbt index c3cbd254..70fda664 100644 --- a/src/methyl_seekr.mbt +++ b/src/methyl_seekr.mbt @@ -112,16 +112,9 @@ pub fn MethylTile::new( end~ : Int, methylation_level~ : Double, coverage~ : Int, - region_type~ : String = "FMR", + region_type? : String = "FMR", ) -> MethylTile { - MethylTile::{ - chr, - start, - end, - methylation_level, - coverage, - region_type, - } + MethylTile::{ chr, start, end, methylation_level, coverage, region_type } } ///| @@ -433,7 +426,10 @@ pub fn tile_methylation( let mut j = i + 1 while j < m { let lt = entries[j].0 < entries[min_idx].0 || - (entries[j].0 == entries[min_idx].0 && entries[j].1 < entries[min_idx].1) + ( + entries[j].0 == entries[min_idx].0 && + entries[j].1 < entries[min_idx].1 + ) if lt { min_idx = j } @@ -458,8 +454,8 @@ pub fn tile_methylation( let start = idx * params.tile_size tiles.push( MethylTile::new( - chr=chr, - start=start, + chr~, + start~, end=start + params.tile_size, methylation_level=level, coverage=total, @@ -526,7 +522,8 @@ pub fn detect_pmds( let mut i = 0 while i < n { // Skip tiles that are not PMD candidates. - if tiles[i].region_type != "FMR" || tiles[i].methylation_level >= params.gamma { + if tiles[i].region_type != "FMR" || + tiles[i].methylation_level >= params.gamma { i = i + 1 continue } @@ -603,11 +600,11 @@ pub fn merge_regions( if end - start >= params.min_region_size { result.push( MethylRegion::new( - chr=chr, - start=start, - end=end, + chr~, + start~, + end~, region_type=rtype, - n_tiles=n_tiles, + n_tiles~, mean_methylation=sum_level / n_tiles.to_double(), min_methylation=min_level, max_methylation=max_level, @@ -682,10 +679,30 @@ pub fn region_summary(regions : Array[MethylRegion]) -> String { let mut s = "Methylation Regimes Summary\n" s = s + "===========================\n" s = s + "Total regions: " + regions.length().to_string() + "\n" - s = s + "UMR: " + n_umr.to_string() + " regions, " + bp_umr.to_string() + " bp\n" - s = s + "LMR: " + n_lmr.to_string() + " regions, " + bp_lmr.to_string() + " bp\n" - s = s + "PMD: " + n_pmd.to_string() + " regions, " + bp_pmd.to_string() + " bp\n" - s = s + "FMR: " + n_fmr.to_string() + " regions, " + bp_fmr.to_string() + " bp\n" + s = s + + "UMR: " + + n_umr.to_string() + + " regions, " + + bp_umr.to_string() + + " bp\n" + s = s + + "LMR: " + + n_lmr.to_string() + + " regions, " + + bp_lmr.to_string() + + " bp\n" + s = s + + "PMD: " + + n_pmd.to_string() + + " regions, " + + bp_pmd.to_string() + + " bp\n" + s = s + + "FMR: " + + n_fmr.to_string() + + " regions, " + + bp_fmr.to_string() + + " bp\n" s } @@ -709,7 +726,7 @@ pub fn methyl_seekr_sample_data() -> Array[CytosineSite] { ] for region in regions { let (t_start, t_end, meth, unmeth) = region - for t in t_start..=t_end { + for t in t_start..<=t_end { let base = t * 1000 for k in 0..<10 { let pos = base + 50 + k * 100 diff --git a/src/methylkit.mbt b/src/methylkit.mbt index 791e1e64..087703f1 100644 --- a/src/methylkit.mbt +++ b/src/methylkit.mbt @@ -17,7 +17,7 @@ fn methylkit_round(x : Double) -> Int { if x >= 0.0 { (x + 0.5).to_int() } else { - -((-x) + 0.5).to_int() + -(-x + 0.5).to_int() } } @@ -77,11 +77,7 @@ fn methylkit_median(arr : Array[Double]) -> Double { ///| /// Logarithm of a binomial coefficient using a precomputed log-factorial table. -fn methylkit_log_choose_tbl( - n : Int, - k : Int, - lf : Array[Double], -) -> Double { +fn methylkit_log_choose_tbl(n : Int, k : Int, lf : Array[Double]) -> Double { if k < 0 || k > n { return -700.0 } @@ -200,11 +196,7 @@ pub struct MethylSample { ///| /// Construct an empty MethylSample. pub fn MethylSample::new(sample_id : String) -> MethylSample { - MethylSample::{ - sample_id, - coverage: Array::new(), - n_cpgs: 0, - } + MethylSample::{ sample_id, coverage: Array::new(), n_cpgs: 0 } } ///| @@ -604,7 +596,7 @@ pub fn methylkit_fisher_test( } // Precompute log-factorial table up to n. let log_fact : Array[Double] = Array::make(n + 1, 0.0) - for i in 2..=n { + for i in 2..<=n { log_fact[i] = log_fact[i - 1] + @math.ln(i.to_double()) } let log_pmf = fn(aa : Int) -> Double { @@ -624,7 +616,7 @@ pub fn methylkit_fisher_test( let lo = if c1 - r2 > 0 { c1 - r2 } else { 0 } let hi = if r1 < c1 { r1 } else { c1 } let mut p_sum = 0.0 - for aa in lo..=hi { + for aa in lo..<=hi { let p = @math.exp(log_pmf(aa)) if p <= p_obs + 1.0e-12 { p_sum = p_sum + p @@ -731,16 +723,14 @@ pub fn methylkit_diff_meth( let (chr, pos, diff) = info[i] let q = q_values[i] let sig = q < config.q_threshold && diff.abs() >= config.min_diff - results.push( - MethylDiffResult::{ - chr, - position: pos, - p_value: p_values[i], - q_value: q, - meth_diff: diff, - significant: sig, - }, - ) + results.push(MethylDiffResult::{ + chr, + position: pos, + p_value: p_values[i], + q_value: q, + meth_diff: diff, + significant: sig, + }) i = i + 1 } results @@ -832,16 +822,14 @@ pub fn methylkit_tiling( let mut i = 0 while i < info.length() { let (chr, pos, diff) = info[i] - results.push( - MethylDiffResult::{ - chr, - position: pos, - p_value: p_values[i], - q_value: q_values[i], - meth_diff: diff, - significant: q_values[i] < 0.05 && diff.abs() >= 25.0, - }, - ) + results.push(MethylDiffResult::{ + chr, + position: pos, + p_value: p_values[i], + q_value: q_values[i], + meth_diff: diff, + significant: q_values[i] < 0.05 && diff.abs() >= 25.0, + }) i = i + 1 } results @@ -866,8 +854,10 @@ pub fn methylkit_get_dmr( let mut j = i + 1 while j < n { if sorted[j].chr < sorted[min_idx].chr || - (sorted[j].chr == sorted[min_idx].chr && - sorted[j].position < sorted[min_idx].position) { + ( + sorted[j].chr == sorted[min_idx].chr && + sorted[j].position < sorted[min_idx].position + ) { min_idx = j } j = j + 1 @@ -888,9 +878,9 @@ pub fn methylkit_get_dmr( let mut end_pos = sorted[i].position let mut j = i + 1 while j < n && - sorted[j].significant && - sorted[j].chr == chr && - sorted[j].position - end_pos <= 1000 { + sorted[j].significant && + sorted[j].chr == chr && + sorted[j].position - end_pos <= 1000 { end_pos = sorted[j].position j = j + 1 } diff --git a/src/microbiome.mbt b/src/microbiome.mbt index 7dc908f5..3ee3f006 100644 --- a/src/microbiome.mbt +++ b/src/microbiome.mbt @@ -52,7 +52,7 @@ pub fn calc_shannon(counts : Array[Double]) -> Double { if total == 0.0 { return 0.0 } - + let mut shannon = 0.0 let mut i = 0 while i < counts.length() { @@ -73,7 +73,7 @@ pub fn calc_simpson(counts : Array[Double]) -> Double { if total == 0.0 { return 0.0 } - + let mut sum_sq = 0.0 let mut i = 0 while i < counts.length() { @@ -92,7 +92,7 @@ pub fn calc_inv_simpson(counts : Array[Double]) -> Double { if total == 0.0 { return 0.0 } - + let mut sum_sq = 0.0 let mut i = 0 while i < counts.length() { @@ -124,7 +124,7 @@ pub fn calc_pielou_evenness(counts : Array[Double]) -> Double { /// where f1 = number of singletons, f2 = number of doubletons pub fn calc_chao1(counts : Array[Double]) -> Double { let s_obs = calc_observed(counts) - + let mut f1 = 0.0 let mut f2 = 0.0 let mut i = 0 @@ -136,8 +136,8 @@ pub fn calc_chao1(counts : Array[Double]) -> Double { } i = i + 1 } - - s_obs + (f1 * (f1 - 1.0)) / (2.0 * (f2 + 1.0)) + + s_obs + f1 * (f1 - 1.0) / (2.0 * (f2 + 1.0)) } ///| @@ -147,7 +147,7 @@ pub fn calc_ace(counts : Array[Double], threshold : Int) -> Double { let mut s_rare = 0.0 let mut s_abund = 0.0 let mut f1 = 0.0 - + let mut i = 0 while i < counts.length() { let count = counts[i] @@ -164,16 +164,16 @@ pub fn calc_ace(counts : Array[Double], threshold : Int) -> Double { } i = i + 1 } - + if n_rare == 0.0 || s_rare <= f1 { return s_rare + s_abund } - + let mut c_ace = 1.0 - f1 / n_rare if c_ace <= 0.0 { c_ace = 0.001 } - + let mut sum_fi = 0.0 let mut sum_fi_i = 0.0 i = 0 @@ -185,11 +185,11 @@ pub fn calc_ace(counts : Array[Double], threshold : Int) -> Double { } i = i + 1 } - + let gamma2 = 0.0 if c_ace > 0.0 && n_rare > 0.0 { // Simplified ACE calculation - s_abund + s_rare / c_ace + (f1 / c_ace) * gamma2 + s_abund + s_rare / c_ace + f1 / c_ace * gamma2 } else { s_rare + s_abund } @@ -202,11 +202,11 @@ pub fn calc_ace(counts : Array[Double], threshold : Int) -> Double { pub fn calc_fisher_alpha(counts : Array[Double]) -> Double { let n = sum_double(counts) let s = calc_observed(counts) - + if n <= 0.0 || s <= 0.0 { return 0.0 } - + // Solve S = alpha * ln(1 + N/alpha) numerically let mut alpha = s let mut iter = 0 @@ -228,7 +228,7 @@ pub fn calc_fisher_alpha(counts : Array[Double]) -> Double { } iter = iter + 1 } - + alpha } @@ -249,12 +249,14 @@ pub fn calc_alpha_diversity(counts : Array[Double]) -> AlphaDiversity { ///| /// Calculate alpha diversity for multiple samples (OTU table: rows=taxa, cols=samples). -pub fn calc_alpha_diversity_table(otu_table : Array[Array[Double]]) -> Array[AlphaDiversity] { +pub fn calc_alpha_diversity_table( + otu_table : Array[Array[Double]], +) -> Array[AlphaDiversity] { let result : Array[AlphaDiversity] = Array::new() if otu_table.length() == 0 { return result } - + let num_samples = otu_table[0].length() let mut j = 0 while j < num_samples { @@ -267,7 +269,7 @@ pub fn calc_alpha_diversity_table(otu_table : Array[Array[Double]]) -> Array[Alp result.push(calc_alpha_diversity(sample_counts)) j = j + 1 } - + result } @@ -282,7 +284,7 @@ pub fn bray_curtis(x : Array[Double], y : Array[Double]) -> Double { if x.length() != y.length() { return 0.0 } - + let mut num = 0.0 let mut den = 0.0 let mut i = 0 @@ -291,11 +293,11 @@ pub fn bray_curtis(x : Array[Double], y : Array[Double]) -> Double { den = den + x[i] + y[i] i = i + 1 } - + if den == 0.0 { return 0.0 } - + num / den } @@ -306,7 +308,7 @@ pub fn jaccard_distance(x : Array[Double], y : Array[Double]) -> Double { if x.length() != y.length() { return 0.0 } - + let mut intersection = 0.0 let mut union = 0.0 let mut i = 0 @@ -321,11 +323,11 @@ pub fn jaccard_distance(x : Array[Double], y : Array[Double]) -> Double { } i = i + 1 } - + if union == 0.0 { return 0.0 } - + 1.0 - intersection / union } @@ -333,25 +335,28 @@ pub fn jaccard_distance(x : Array[Double], y : Array[Double]) -> Double { /// Calculate Jensen-Shannon divergence between two samples. /// JSD = 0.5 * KL(P||M) + 0.5 * KL(Q||M) /// where M = (P + Q) / 2 -pub fn jensen_shannon_divergence(x : Array[Double], y : Array[Double]) -> Double { +pub fn jensen_shannon_divergence( + x : Array[Double], + y : Array[Double], +) -> Double { if x.length() != y.length() { return 0.0 } - + let sum_x = sum_double(x) let sum_y = sum_double(y) - + if sum_x == 0.0 || sum_y == 0.0 { return 0.0 } - + let mut jsd = 0.0 let mut i = 0 while i < x.length() { let p = x[i] / sum_x let q = y[i] / sum_y let m = (p + q) / 2.0 - + if p > 0.0 && m > 0.0 { jsd = jsd + 0.5 * p * @math.ln(p / m) } @@ -360,7 +365,7 @@ pub fn jensen_shannon_divergence(x : Array[Double], y : Array[Double]) -> Double } i = i + 1 } - + jsd } @@ -382,14 +387,17 @@ pub fn unweighted_unifrac(x : Array[Double], y : Array[Double]) -> Double { ///| /// Calculate a beta diversity distance matrix for all samples. /// OTU table format: rows=taxa, cols=samples -pub fn calc_beta_diversity_matrix(otu_table : Array[Array[Double]], dist_method : String) -> Array[Array[Double]] { +pub fn calc_beta_diversity_matrix( + otu_table : Array[Array[Double]], + dist_method : String, +) -> Array[Array[Double]] { if otu_table.length() == 0 { return Array::new() } - + let num_samples = otu_table[0].length() let dist_matrix : Array[Array[Double]] = Array::new() - + // Initialize distance matrix let mut i = 0 while i < num_samples { @@ -402,7 +410,7 @@ pub fn calc_beta_diversity_matrix(otu_table : Array[Array[Double]], dist_method dist_matrix.push(row) i = i + 1 } - + // Calculate pairwise distances i = 0 while i < num_samples { @@ -416,7 +424,7 @@ pub fn calc_beta_diversity_matrix(otu_table : Array[Array[Double]], dist_method sample_j.push(otu_table[k][j]) k = k + 1 } - + let dist = match dist_method { "bray" => bray_curtis(sample_i, sample_j) "jaccard" => jaccard_distance(sample_i, sample_j) @@ -425,14 +433,14 @@ pub fn calc_beta_diversity_matrix(otu_table : Array[Array[Double]], dist_method "wunifrac" => weighted_unifrac(sample_i, sample_j) _ => bray_curtis(sample_i, sample_j) } - + dist_matrix[i][j] = dist dist_matrix[j][i] = dist j = j + 1 } i = i + 1 } - + dist_matrix } @@ -464,11 +472,11 @@ pub fn PCoAResult::new() -> PCoAResult { /// Uses classical MDS (metric multidimensional scaling). pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { let n = dist_matrix.length() - + if n <= 1 { return PCoAResult::new() } - + // Step 1: Center the distance matrix // Convert distances to similarities and double-center let d2 : Array[Array[Double]] = Array::new() @@ -483,7 +491,7 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { d2.push(row) i = i + 1 } - + // Calculate row means, column means, and grand mean let row_means : Array[Double] = Array::new() i = 0 @@ -497,7 +505,7 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { row_means.push(sum / n.to_double()) i = i + 1 } - + let col_means : Array[Double] = Array::new() let mut j = 0 while j < n { @@ -510,7 +518,7 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { col_means.push(sum / n.to_double()) j = j + 1 } - + let mut grand_mean = 0.0 i = 0 while i < n { @@ -518,7 +526,7 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { i = i + 1 } grand_mean = grand_mean / n.to_double() - + // Double-center the matrix let b : Array[Array[Double]] = Array::new() i = 0 @@ -533,22 +541,22 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { b.push(row) i = i + 1 } - + // Step 2: Simple power iteration for eigenvalues/vectors (first k) // We'll compute first min(n-1, 5) principal coordinates let k = if n - 1 < 5 { n - 1 } else { 5 } - + let eigenvalues : Array[Double] = Array::new() let vectors : Array[Array[Double]] = Array::new() - + // Simple implementation using power iteration let remaining = b.copy() - + let mut comp = 0 while comp < k { // Power iteration let v : Array[Double] = Array::make(n, 1.0) - + let mut lambda = 0.0 let mut iter = 0 while iter < 100 { @@ -565,7 +573,7 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { bv.push(sum) i = i + 1 } - + // Compute new lambda (Rayleigh quotient) let mut v_norm = 0.0 let mut v_bv = 0.0 @@ -575,13 +583,13 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { v_bv = v_bv + v[i] * bv[i] i = i + 1 } - + if v_norm == 0.0 { break } - + let new_lambda = v_bv / v_norm - + // Normalize bv let bv_norm = 0.0 let mut i = 0 @@ -595,17 +603,17 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { i = i + 1 } bv_len = bv_len.sqrt() - + if bv_len == 0.0 { break } - + i = 0 while i < n { v[i] = bv[i] / bv_len i = i + 1 } - + if (new_lambda - lambda).abs() < 0.000001 { lambda = new_lambda break @@ -613,13 +621,13 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { lambda = new_lambda iter = iter + 1 } - + if lambda < 0.0 { lambda = 0.0 } - + eigenvalues.push(lambda) - + // Scale eigenvector by sqrt(eigenvalue) let scaled_v : Array[Double] = Array::new() let mut i = 0 @@ -628,7 +636,7 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { i = i + 1 } vectors.push(scaled_v) - + // Deflate: remove this component from remaining let mut i = 0 while i < n { @@ -641,14 +649,14 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { } comp = comp + 1 } - + // Calculate variance explained let total_var = sum_double(eigenvalues) - + let variance_explained : Array[Double] = Array::new() let cumulative_variance : Array[Double] = Array::new() let mut cum_var = 0.0 - + let mut i = 0 while i < eigenvalues.length() { let ve = if total_var > 0.0 { eigenvalues[i] / total_var } else { 0.0 } @@ -657,7 +665,7 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { cumulative_variance.push(cum_var) i = i + 1 } - + // Transpose vectors to get samples x components let transposed : Array[Array[Double]] = Array::new() if vectors.length() > 0 { @@ -674,12 +682,12 @@ pub fn pcoa(dist_matrix : Array[Array[Double]]) -> PCoAResult { i = i + 1 } } - + PCoAResult::{ - eigenvalues: eigenvalues, + eigenvalues, vectors: transposed, - variance_explained: variance_explained, - cumulative_variance: cumulative_variance, + variance_explained, + cumulative_variance, } } @@ -699,9 +707,16 @@ pub struct DAResult { } ///| -pub fn DAResult::new(taxa : String, log2_fc : Double, p_val : Double, adj_p : Double, mean1 : Double, mean2 : Double) -> DAResult { +pub fn DAResult::new( + taxa : String, + log2_fc : Double, + p_val : Double, + adj_p : Double, + mean1 : Double, + mean2 : Double, +) -> DAResult { DAResult::{ - taxa: taxa, + taxa, log2_fold_change: log2_fc, p_value: p_val, adjusted_p_value: adj_p, @@ -720,17 +735,19 @@ pub fn differential_abundance( group2_indices : Array[Int], ) -> Array[DAResult] { let results : Array[DAResult] = Array::new() - - if otu_table.length() == 0 || group1_indices.length() == 0 || group2_indices.length() == 0 { + + if otu_table.length() == 0 || + group1_indices.length() == 0 || + group2_indices.length() == 0 { return results } - + let p_values : Array[Double] = Array::new() let log2_fcs : Array[Double] = Array::new() let mean1s : Array[Double] = Array::new() let mean2s : Array[Double] = Array::new() let taxon_names : Array[String] = Array::new() - + let mut i = 0 while i < otu_table.length() { // Extract group 1 values @@ -740,7 +757,7 @@ pub fn differential_abundance( group1.push(otu_table[i][group1_indices[j]]) j = j + 1 } - + // Extract group 2 values let group2 : Array[Double] = Array::new() j = 0 @@ -748,46 +765,52 @@ pub fn differential_abundance( group2.push(otu_table[i][group2_indices[j]]) j = j + 1 } - + let mean1 = mean_double(group1) let mean2 = mean_double(group2) - + let log2_fc = if mean1 > 0.0 && mean2 > 0.0 { @math.log2(mean2 / mean1) } else { 0.0 } - + // Simple t-test approximation let p_val = micro_welch_t_test(group1, group2) p_values.push(p_val) log2_fcs.push(log2_fc) mean1s.push(mean1) mean2s.push(mean2) - - let taxa_name = if i < taxa_names.length() { taxa_names[i] } else { "Taxon" + i.to_string() } + + let taxa_name = if i < taxa_names.length() { + taxa_names[i] + } else { + "Taxon" + i.to_string() + } taxon_names.push(taxa_name) - + i = i + 1 } - + // BH correction let adj_p = micro_bh_correction(p_values) - + // Build results let mut i = 0 while i < otu_table.length() { - results.push(DAResult::new( - taxon_names[i], - log2_fcs[i], - p_values[i], - adj_p[i], - mean1s[i], - mean2s[i], - )) + results.push( + DAResult::new( + taxon_names[i], + log2_fcs[i], + p_values[i], + adj_p[i], + mean1s[i], + mean2s[i], + ), + ) i = i + 1 } - + results } @@ -795,6 +818,7 @@ pub fn differential_abundance( // Helper functions // ============================================================ +///| fn sum_double(arr : Array[Double]) -> Double { let mut sum = 0.0 let mut i = 0 @@ -805,6 +829,7 @@ fn sum_double(arr : Array[Double]) -> Double { sum } +///| fn mean_double(arr : Array[Double]) -> Double { if arr.length() == 0 { return 0.0 @@ -812,6 +837,7 @@ fn mean_double(arr : Array[Double]) -> Double { sum_double(arr) / arr.length().to_double() } +///| fn variance_double(arr : Array[Double]) -> Double { if arr.length() <= 1 { return 0.0 @@ -826,45 +852,55 @@ fn variance_double(arr : Array[Double]) -> Double { sum_sq / (arr.length().to_double() - 1.0) } +///| fn micro_welch_t_test(x : Array[Double], y : Array[Double]) -> Double { let n1 = x.length().to_double() let n2 = y.length().to_double() - + if n1 < 2.0 || n2 < 2.0 { return 1.0 } - + let mean_x = mean_double(x) let mean_y = mean_double(y) let var_x = variance_double(x) let var_y = variance_double(y) - + if var_x == 0.0 && var_y == 0.0 { return 1.0 } - + let se = (var_x / n1 + var_y / n2).sqrt() if se == 0.0 { return 1.0 } - + let t_stat = (mean_x - mean_y) / se - + // Welch-Satterthwaite degrees of freedom let df_num = (var_x / n1 + var_y / n2) * (var_x / n1 + var_y / n2) - let df_den = (var_x / n1) * (var_x / n1) / (n1 - 1.0) + (var_y / n2) * (var_y / n2) / (n2 - 1.0) + let df_den = var_x / n1 * (var_x / n1) / (n1 - 1.0) + + var_y / n2 * (var_y / n2) / (n2 - 1.0) let df = if df_den > 0.0 { df_num / df_den } else { n1 + n2 - 2.0 } - + // Approximate p-value using normal approximation (two-tailed) let p_val = 2.0 * (1.0 - micro_normal_cdf(t_stat.abs())) - if p_val < 0.0 { 0.0 } else if p_val > 1.0 { 1.0 } else { p_val } + if p_val < 0.0 { + 0.0 + } else if p_val > 1.0 { + 1.0 + } else { + p_val + } } +///| fn micro_normal_cdf(x : Double) -> Double { // Approximation of standard normal CDF 0.5 * (1.0 + micro_erf(x / 1.4142135623730951)) } +///| fn micro_erf(x : Double) -> Double { // Abramowitz and Stegun approximation for erf let a1 = 0.254829592 @@ -873,26 +909,30 @@ fn micro_erf(x : Double) -> Double { let a4 = -1.453152027 let a5 = 1.061405429 let p = 0.3275911 - + let sign = if x < 0.0 { -1.0 } else { 1.0 } let x_abs = x.abs() - + let t = 1.0 / (1.0 + p * x_abs) - let y = 1.0 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * @math.exp(-x_abs * x_abs) - + let y = 1.0 - + ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * + t * + @math.exp(-x_abs * x_abs) + sign * y } +///| fn micro_bh_correction(p_values : Array[Double]) -> Array[Double] { let n = p_values.length() if n == 0 { return Array::new() } - + // Create indexed pairs let indices : Array[Int] = Array::new() let sorted_p : Array[Double] = Array::new() - + // Simple bubble sort (since n may be small) let mut i = 0 while i < n { @@ -900,7 +940,7 @@ fn micro_bh_correction(p_values : Array[Double]) -> Array[Double] { sorted_p.push(p_values[i]) i = i + 1 } - + // Sort let mut i = 0 while i < n - 1 { @@ -910,7 +950,7 @@ fn micro_bh_correction(p_values : Array[Double]) -> Array[Double] { let temp_p = sorted_p[j] sorted_p[j] = sorted_p[j + 1] sorted_p[j + 1] = temp_p - + let temp_idx = indices[j] indices[j] = indices[j + 1] indices[j + 1] = temp_idx @@ -919,7 +959,7 @@ fn micro_bh_correction(p_values : Array[Double]) -> Array[Double] { } i = i + 1 } - + // BH adjustment let adj_sorted : Array[Double] = Array::new() let mut min_adj = 1.0 @@ -936,7 +976,7 @@ fn micro_bh_correction(p_values : Array[Double]) -> Array[Double] { } i = i - 1 } - + // Reverse back let adj_sorted_rev : Array[Double] = Array::new() let mut i = adj_sorted.length() - 1 @@ -944,7 +984,7 @@ fn micro_bh_correction(p_values : Array[Double]) -> Array[Double] { adj_sorted_rev.push(adj_sorted[i]) i = i - 1 } - + // Map back to original order let result : Array[Double] = Array::new() let mut i = 0 @@ -952,13 +992,13 @@ fn micro_bh_correction(p_values : Array[Double]) -> Array[Double] { result.push(0.0) i = i + 1 } - + let mut i = 0 while i < n { result[indices[i]] = adj_sorted_rev[i] i = i + 1 } - + result } @@ -967,47 +1007,47 @@ fn micro_bh_correction(p_values : Array[Double]) -> Array[Double] { pub fn create_example_otu_table() -> Array[Array[Double]] { // 10 taxa, 6 samples (3 control, 3 treatment) let otu_table : Array[Array[Double]] = Array::new() - + // Taxon 1: High in control let t1 : Array[Double] = [120.0, 150.0, 130.0, 30.0, 25.0, 35.0] otu_table.push(t1) - + // Taxon 2: High in treatment let t2 : Array[Double] = [20.0, 25.0, 15.0, 100.0, 120.0, 110.0] otu_table.push(t2) - + // Taxon 3: Moderate in both let t3 : Array[Double] = [50.0, 55.0, 48.0, 52.0, 47.0, 53.0] otu_table.push(t3) - + // Taxon 4: Low abundance let t4 : Array[Double] = [5.0, 3.0, 7.0, 4.0, 6.0, 2.0] otu_table.push(t4) - + // Taxon 5: Rare (singletons) let t5 : Array[Double] = [1.0, 0.0, 1.0, 0.0, 1.0, 0.0] otu_table.push(t5) - + // Taxon 6 let t6 : Array[Double] = [80.0, 75.0, 85.0, 60.0, 65.0, 55.0] otu_table.push(t6) - + // Taxon 7 let t7 : Array[Double] = [30.0, 35.0, 28.0, 45.0, 50.0, 40.0] otu_table.push(t7) - + // Taxon 8 let t8 : Array[Double] = [10.0, 12.0, 8.0, 15.0, 18.0, 14.0] otu_table.push(t8) - + // Taxon 9: Doubletons let t9 : Array[Double] = [2.0, 2.0, 0.0, 0.0, 2.0, 2.0] otu_table.push(t9) - + // Taxon 10 let t10 : Array[Double] = [45.0, 50.0, 42.0, 55.0, 60.0, 48.0] otu_table.push(t10) - + otu_table } @@ -1015,16 +1055,8 @@ pub fn create_example_otu_table() -> Array[Array[Double]] { /// Get example taxa names. pub fn get_example_taxa_names() -> Array[String] { let names : Array[String] = [ - "Bacteroides", - "Prevotella", - "Firmicutes_g1", - "Actinobacteria_g1", - "Rare_taxon_1", - "Lachnospiraceae", - "Ruminococcaceae", - "Bifidobacterium", - "Rare_taxon_2", - "Escherichia", + "Bacteroides", "Prevotella", "Firmicutes_g1", "Actinobacteria_g1", "Rare_taxon_1", + "Lachnospiraceae", "Ruminococcaceae", "Bifidobacterium", "Rare_taxon_2", "Escherichia", ] names } diff --git a/src/missmethyl.mbt b/src/missmethyl.mbt index f1a82390..0ba6731d 100644 --- a/src/missmethyl.mbt +++ b/src/missmethyl.mbt @@ -46,12 +46,8 @@ fn mm_variance(arr : Array[Double], mean : Double) -> Double { /// Lanczos approximation for ln(gamma(x)). fn mm_lgamma(x : Double) -> Double { let cof = [ - 76.18009172947146, - -86.50532032941677, - 24.01409824083091, - -1.231739572450155, - 0.001208650973866179, - -0.000005395239384953, + 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, + 0.001208650973866179, -0.000005395239384953, ] let mut x1 = x let mut tmp = x1 + 5.5 @@ -291,14 +287,7 @@ pub fn MmProbeAnnotation::new( island_relation : String, probe_type : String, ) -> MmProbeAnnotation { - MmProbeAnnotation::{ - probe_id, - chr, - pos, - gene, - island_relation, - probe_type, - } + MmProbeAnnotation::{ probe_id, chr, pos, gene, island_relation, probe_type } } ///| @@ -327,9 +316,7 @@ pub fn MmProbeAnnotation::gene(self : MmProbeAnnotation) -> String { ///| /// CpG island relation ("Island"/"Shore"/"Shelf"/"OpenSea"). -pub fn MmProbeAnnotation::island_relation( - self : MmProbeAnnotation, -) -> String { +pub fn MmProbeAnnotation::island_relation(self : MmProbeAnnotation) -> String { self.island_relation } @@ -650,19 +637,9 @@ pub fn mm_t_test( let num = (term1 + term2) * (term1 + term2) let den = term1 * term1 / (n1 - 1).to_double() + term2 * term2 / (n2 - 1).to_double() - let df = if den > 0.0 { - num / den - } else { - (n1 + n2 - 2).to_double() - } + let df = if den > 0.0 { num / den } else { (n1 + n2 - 2).to_double() } let p = 2.0 * (1.0 - mm_t_cdf(t.abs(), df)) - let pc = if p < 0.0 { - 0.0 - } else if p > 1.0 { - 1.0 - } else { - p - } + let pc = if p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p } (t, pc) } @@ -704,11 +681,7 @@ pub fn mm_bh_correct(p_values : Array[Double]) -> Array[Double] { if val < min_adj { min_adj = val } - adj[indices[i]] = if min_adj > 1.0 { - 1.0 - } else { - min_adj - } + adj[indices[i]] = if min_adj > 1.0 { 1.0 } else { min_adj } i = i - 1 } adj @@ -731,11 +704,7 @@ pub fn mm_fisher_exact(a : Int, b : Int, c : Int, d : Int) -> Double { } else { 0 } - let max_a = if row1_total < col1_total { - row1_total - } else { - col1_total - } + let max_a = if row1_total < col1_total { row1_total } else { col1_total } let mut p_value = 0.0 let mut i = min_a while i <= max_a { @@ -833,7 +802,8 @@ pub fn mm_map_probes_to_genes( ) -> Array[String] { let result : Array[String] = Array::new() for ann in annotations { - if mm_contains(probes, ann.probe_id()) && not(mm_contains(result, ann.gene())) { + if mm_contains(probes, ann.probe_id()) && + not(mm_contains(result, ann.gene())) { result.push(ann.gene()) } } @@ -848,7 +818,8 @@ fn mm_probes_for_genes( ) -> Array[String] { let result : Array[String] = Array::new() for ann in annotations { - if mm_contains(genes, ann.gene()) && not(mm_contains(result, ann.probe_id())) { + if mm_contains(genes, ann.gene()) && + not(mm_contains(result, ann.probe_id())) { result.push(ann.probe_id()) } } @@ -1101,22 +1072,32 @@ pub fn mm_sample_annotations() -> Array[MmProbeAnnotation] { result.push(MmProbeAnnotation::new("cg001", "chr1", 1000, "A", "Island", "I")) result.push(MmProbeAnnotation::new("cg002", "chr1", 2000, "B", "Shore", "I")) result.push(MmProbeAnnotation::new("cg003", "chr1", 3000, "C", "Shelf", "II")) - result.push(MmProbeAnnotation::new("cg004", "chr1", 4000, "D", "OpenSea", "I")) - result.push(MmProbeAnnotation::new("cg005", "chr1", 5000, "E", "Island", "II")) + result.push( + MmProbeAnnotation::new("cg004", "chr1", 4000, "D", "OpenSea", "I"), + ) + result.push( + MmProbeAnnotation::new("cg005", "chr1", 5000, "E", "Island", "II"), + ) result.push(MmProbeAnnotation::new("cg006", "chr1", 6000, "F", "Shore", "I")) result.push(MmProbeAnnotation::new("cg007", "chr1", 7000, "G", "Shelf", "II")) result.push(MmProbeAnnotation::new("cg008", "chr2", 2000, "H", "Island", "I")) result.push(MmProbeAnnotation::new("cg009", "chr2", 2500, "A", "Shore", "II")) result.push(MmProbeAnnotation::new("cg010", "chr2", 3000, "B", "Shelf", "I")) - result.push(MmProbeAnnotation::new("cg011", "chr2", 3500, "C", "OpenSea", "II")) + result.push( + MmProbeAnnotation::new("cg011", "chr2", 3500, "C", "OpenSea", "II"), + ) result.push(MmProbeAnnotation::new("cg012", "chr2", 4000, "D", "Island", "I")) result.push(MmProbeAnnotation::new("cg013", "chr2", 5000, "E", "Shore", "II")) result.push(MmProbeAnnotation::new("cg014", "chr2", 6000, "F", "Shelf", "I")) - result.push(MmProbeAnnotation::new("cg015", "chr3", 3000, "G", "OpenSea", "II")) + result.push( + MmProbeAnnotation::new("cg015", "chr3", 3000, "G", "OpenSea", "II"), + ) result.push(MmProbeAnnotation::new("cg016", "chr3", 4000, "H", "Island", "I")) result.push(MmProbeAnnotation::new("cg017", "chr3", 5000, "A", "Shore", "II")) result.push(MmProbeAnnotation::new("cg018", "chr3", 6000, "B", "Shelf", "I")) - result.push(MmProbeAnnotation::new("cg019", "chr3", 7000, "C", "OpenSea", "II")) + result.push( + MmProbeAnnotation::new("cg019", "chr3", 7000, "C", "OpenSea", "II"), + ) result.push(MmProbeAnnotation::new("cg020", "chr3", 8000, "D", "Island", "I")) result } diff --git a/src/mix_omics.mbt b/src/mix_omics.mbt index 1dab5059..b7962e03 100644 --- a/src/mix_omics.mbt +++ b/src/mix_omics.mbt @@ -247,8 +247,10 @@ pub fn soft_threshold(x : Double, lambda : Double) -> Double { let shrunk = abs_x - lambda if shrunk <= 0.0 { 0.0 + } else if x < 0.0 { + -shrunk } else { - if x < 0.0 { -shrunk } else { shrunk } + shrunk } } @@ -269,7 +271,13 @@ pub fn select_top_k(values : Array[Double], k : Int) -> Array[Int] { } indexed.sort_by(fn(a : (Int, Double), b : (Int, Double)) -> Int { - if a.1 > b.1 { -1 } else if a.1 < b.1 { 1 } else { 0 } + if a.1 > b.1 { + -1 + } else if a.1 < b.1 { + 1 + } else { + 0 + } }) let result = Array::make(effective_k, 0) @@ -389,11 +397,7 @@ pub fn run_pls( ) -> PLSResult { let n = x_data.length() let p = if n > 0 { x_data[0].length() } else { 0 } - let q = if y_data.length() > 0 { - y_data[0].length() - } else { - 0 - } + let q = if y_data.length() > 0 { y_data[0].length() } else { 0 } let ncomp = if options.ncomp > n { n @@ -652,11 +656,7 @@ pub fn run_spls( ) -> SPLSResult { let n = x_data.length() let p = if n > 0 { x_data[0].length() } else { 0 } - let q = if y_data.length() > 0 { - y_data[0].length() - } else { - 0 - } + let q = if y_data.length() > 0 { y_data[0].length() } else { 0 } let ncomp = if options.ncomp > n { n @@ -807,13 +807,7 @@ pub fn spls_component( Array[Bool], ) { let (t_init, u_init, w_x_init, w_y_init) = nipals_pls( - x, - y, - n, - p, - q, - max_iter, - tol, + x, y, n, p, q, max_iter, tol, ) let x_loadings = mix_mat_t_vec(x, n, p, t_init) @@ -1072,7 +1066,7 @@ pub fn diablo_component( let w = Array::make(pb, 0.0) for j = 0; j < pb; j = j + 1 { - w[j] = 1.0 / (pb.to_double()).sqrt() + w[j] = 1.0 / pb.to_double().sqrt() } block_weights.push(w) @@ -1085,7 +1079,12 @@ pub fn diablo_component( } for b = 0; b < n_blocks; b = b + 1 { - block_scores[b] = mix_mat_vec(blocks[b], n, block_sizes[b], block_weights[b]) + block_scores[b] = mix_mat_vec( + blocks[b], + n, + block_sizes[b], + block_weights[b], + ) } let mut global_score = Array::make(n, 0.0) @@ -1156,7 +1155,11 @@ pub fn diablo_component( for c = 0; c < n_blocks; c = c + 1 { dw = dw + sum_row[c] } - if dw > 0.0 { dw } else { 1.0 } + if dw > 0.0 { + dw + } else { + 1.0 + } } else { 1.0 } @@ -1221,4 +1224,4 @@ pub fn diablo_update_scores( result.push(mix_mat_vec(blocks[b], n, pb, weights[b])) } result -} \ No newline at end of file +} diff --git a/src/mmcifio.mbt b/src/mmcifio.mbt index eda856f8..0ff9fb77 100644 --- a/src/mmcifio.mbt +++ b/src/mmcifio.mbt @@ -297,12 +297,9 @@ pub fn mmcif_sample_structure() -> Structure { bfactor=20.0, element="O", ) - let ala = Residue::new( - resname="ALA", - chainid='A', - resseq=1, - atoms=[ala_n, ala_ca, ala_c, ala_o], - ) + let ala = Residue::new(resname="ALA", chainid='A', resseq=1, atoms=[ + ala_n, ala_ca, ala_c, ala_o, + ]) let gly_n = Atom::new( name="N", coord=Vector3::new(3.0, 2.5, 5.0), @@ -343,12 +340,9 @@ pub fn mmcif_sample_structure() -> Structure { bfactor=20.0, element="O", ) - let gly = Residue::new( - resname="GLY", - chainid='A', - resseq=2, - atoms=[gly_n, gly_ca, gly_c, gly_o], - ) + let gly = Residue::new(resname="GLY", chainid='A', resseq=2, atoms=[ + gly_n, gly_ca, gly_c, gly_o, + ]) let chain = Chain::new(id='A', residues=[ala, gly]) let model = Model::new(id=1, chains=[chain]) Structure::new(id="1ABC", models=[model]) diff --git a/src/mmtf.mbt b/src/mmtf.mbt index f5691d50..65072dc5 100644 --- a/src/mmtf.mbt +++ b/src/mmtf.mbt @@ -87,14 +87,14 @@ pub struct MmtfAtom { pub fn MmtfAtom::new( name~ : String, serial~ : Int, - alt_loc_id~ : String = "", + alt_loc_id? : String = "", x~ : Double, y~ : Double, z~ : Double, - occupancy~ : Double = 1.0, - b_factor~ : Double = 0.0, - element~ : String = "", - charge~ : Int = 0, + occupancy? : Double = 1.0, + b_factor? : Double = 0.0, + element? : String = "", + charge? : Int = 0, ) -> MmtfAtom { MmtfAtom::{ name, @@ -128,11 +128,11 @@ pub struct MmtfGroup { pub fn MmtfGroup::new( group_name~ : String, group_number~ : Int, - insertion_code~ : String = "", - group_type~ : String = "", - single_letter_code~ : String = "", - sec_struct~ : MmtfSecStruct = MmtfSecUndefined, - sequence_index~ : Int = -1, + insertion_code? : String = "", + group_type? : String = "", + single_letter_code? : String = "", + sec_struct? : MmtfSecStruct = MmtfSecUndefined, + sequence_index? : Int = -1, ) -> MmtfGroup { MmtfGroup::{ group_name, @@ -175,8 +175,8 @@ pub struct MmtfChain { ///| /// Construct an MmtfChain. pub fn MmtfChain::new( - chain_id~ : String = "", - chain_name~ : String = "", + chain_id? : String = "", + chain_name? : String = "", ) -> MmtfChain { MmtfChain::{ chain_id, chain_name, groups: [] } } @@ -208,7 +208,7 @@ pub struct MmtfModel { ///| /// Construct an MmtfModel. -pub fn MmtfModel::new(model_id~ : Int = 0) -> MmtfModel { +pub fn MmtfModel::new(model_id? : Int = 0) -> MmtfModel { MmtfModel::{ model_id, chains: [] } } @@ -276,17 +276,12 @@ pub struct MmtfEntity { ///| /// Construct an MmtfEntity. pub fn MmtfEntity::new( - chain_indices~ : Array[Int] = [], - sequence~ : String = "", - description~ : String = "", - entity_type~ : MmtfEntityType = MmtfEntityUndefined, + chain_indices? : Array[Int] = [], + sequence? : String = "", + description? : String = "", + entity_type? : MmtfEntityType = MmtfEntityUndefined, ) -> MmtfEntity { - MmtfEntity::{ - chain_indices, - sequence, - description, - entity_type, - } + MmtfEntity::{ chain_indices, sequence, description, entity_type } } ///| @@ -325,10 +320,7 @@ pub struct MmtfXtalInfo { ///| /// Construct an MmtfXtalInfo with defaults. pub fn MmtfXtalInfo::new() -> MmtfXtalInfo { - MmtfXtalInfo::{ - space_group: "", - unit_cell: Array::make(6, 0.0), - } + MmtfXtalInfo::{ space_group: "", unit_cell: Array::make(6, 0.0) } } ///| @@ -344,7 +336,7 @@ pub struct MmtfBond { pub fn MmtfBond::new( atom_index1~ : Int, atom_index2~ : Int, - bond_order~ : Int = 1, + bond_order? : Int = 1, ) -> MmtfBond { MmtfBond::{ atom_index1, atom_index2, bond_order } } @@ -382,9 +374,9 @@ pub struct MmtfGroupType { ///| /// Construct an MmtfGroupType. pub fn MmtfGroupType::new( - group_name~ : String = "", - chem_comp_type~ : String = "", - single_letter_code~ : String = "", + group_name? : String = "", + chem_comp_type? : String = "", + single_letter_code? : String = "", ) -> MmtfGroupType { MmtfGroupType::{ group_name, @@ -437,7 +429,10 @@ pub fn MmtfStructure::get_xtal_info(self : MmtfStructure) -> MmtfXtalInfo { ///| /// Set the crystallographic info. -pub fn MmtfStructure::set_xtal_info(self : MmtfStructure, x : MmtfXtalInfo) -> Unit { +pub fn MmtfStructure::set_xtal_info( + self : MmtfStructure, + x : MmtfXtalInfo, +) -> Unit { self.xtal_info = x } @@ -621,7 +616,7 @@ fn mmtf_read_f32_be(data : Array[Int], offset : Int) -> Double { 0.0 } else if exponent == 0 { // Denormalized number - sign * (mantissa.to_double()) * pow2(-149) + sign * mantissa.to_double() * pow2(-149) } else if exponent == 255 { // Infinity or NaN - return 0.0 for simplicity 0.0 @@ -638,7 +633,7 @@ fn pow2(n : Int) -> Double { result = result * 2.0 } } else { - for _ in 0..<(-n) { + for _ in 0..<-n { result = result / 2.0 } } @@ -678,7 +673,11 @@ fn mmtf_write_f32_be(data : Array[Int], offset : Int, value : Double) -> Unit { ///| /// Convert ASCII byte array slice to a string. -fn mmtf_ascii_to_string(data : Array[Int], offset : Int, length : Int) -> String { +fn mmtf_ascii_to_string( + data : Array[Int], + offset : Int, + length : Int, +) -> String { let sb = StringBuilder::new() for i in 0.. String { let xtal = structure.get_xtal_info() sb.write_string("MMTF\n") sb.write_string("structureId=" + structure.structure_id + "\n") - sb.write_string("totalNumBonds=" + structure.total_num_bonds.to_string() + "\n") - sb.write_string("totalNumAtoms=" + structure.total_num_atoms.to_string() + "\n") - sb.write_string("totalNumGroups=" + structure.total_num_groups.to_string() + "\n") - sb.write_string("totalNumChains=" + structure.total_num_chains.to_string() + "\n") - sb.write_string("totalNumModels=" + structure.total_num_models.to_string() + "\n") + sb.write_string( + "totalNumBonds=" + structure.total_num_bonds.to_string() + "\n", + ) + sb.write_string( + "totalNumAtoms=" + structure.total_num_atoms.to_string() + "\n", + ) + sb.write_string( + "totalNumGroups=" + structure.total_num_groups.to_string() + "\n", + ) + sb.write_string( + "totalNumChains=" + structure.total_num_chains.to_string() + "\n", + ) + sb.write_string( + "totalNumModels=" + structure.total_num_models.to_string() + "\n", + ) // Header sb.write_string("title=" + header.title + "\n") sb.write_string("depositionDate=" + header.deposition_date + "\n") @@ -877,7 +886,15 @@ pub fn mmtf_write_text(structure : MmtfStructure) -> String { sb.write_string("MODEL " + mi.to_string() + "\n") for ci in 0.. MmtfStructure { } else if trimmed.starts_with("releaseDate=") { header.release_date = trimmed.substring(start=12) } else if trimmed.starts_with("resolution=") { - header.resolution = parse_double(trimmed.substring(start=11)).unwrap_or(0.0) + header.resolution = parse_double(trimmed.substring(start=11)).unwrap_or( + 0.0, + ) } else if trimmed.starts_with("rWork=") { header.r_work = parse_double(trimmed.substring(start=6)).unwrap_or(0.0) } else if trimmed.starts_with("rFree=") { @@ -998,11 +1017,16 @@ pub fn mmtf_read_text(text : String) -> MmtfStructure { Some(m) => structure.add_model(m) None => () } - let parts = trimmed.split(" ").to_array().filter(fn(s) -> Bool { - s.length() > 0 - }) - let model_id = if parts.length() >= 2 { parse_int(parts[1].to_string()) } else { 0 } - current_model = Some(MmtfModel::new(model_id=model_id)) + let parts = trimmed + .split(" ") + .to_array() + .filter(fn(s) -> Bool { s.length() > 0 }) + let model_id = if parts.length() >= 2 { + parse_int(parts[1].to_string()) + } else { + 0 + } + current_model = Some(MmtfModel::new(model_id~)) } else if trimmed.starts_with(" CHAIN ") { // Save previous group match current_group { @@ -1023,12 +1047,17 @@ pub fn mmtf_read_text(text : String) -> MmtfStructure { } None => () } - let parts = trimmed.split(" ").to_array().filter(fn(s) -> Bool { - s.length() > 0 - }) + let parts = trimmed + .split(" ") + .to_array() + .filter(fn(s) -> Bool { s.length() > 0 }) let chain_id = if parts.length() >= 3 { parts[2].to_string() } else { "" } - let chain_name = if parts.length() >= 4 { parts[3].to_string() } else { chain_id } - current_chain = Some(MmtfChain::new(chain_id=chain_id, chain_name=chain_name)) + let chain_name = if parts.length() >= 4 { + parts[3].to_string() + } else { + chain_id + } + current_chain = Some(MmtfChain::new(chain_id~, chain_name~)) } else if trimmed.starts_with(" GROUP ") { // Save previous group match current_group { @@ -1039,13 +1068,26 @@ pub fn mmtf_read_text(text : String) -> MmtfStructure { } None => () } - let parts = trimmed.split(" ").to_array().filter(fn(s) -> Bool { - s.length() > 0 - }) - let group_name = if parts.length() >= 2 { parts[1].to_string() } else { "" } - let group_number = if parts.length() >= 3 { parse_int(parts[2].to_string()) } else { 0 } + let parts = trimmed + .split(" ") + .to_array() + .filter(fn(s) -> Bool { s.length() > 0 }) + let group_name = if parts.length() >= 2 { + parts[1].to_string() + } else { + "" + } + let group_number = if parts.length() >= 3 { + parse_int(parts[2].to_string()) + } else { + 0 + } let slc = if parts.length() >= 4 { parts[3].to_string() } else { "" } - let ss_str = if parts.length() >= 5 { parts[4].to_string() } else { "undefined" } + let ss_str = if parts.length() >= 5 { + parts[4].to_string() + } else { + "undefined" + } let ss = match ss_str { "alpha_helix" => MmtfSecAlphaHelix "extended" => MmtfSecExtended @@ -1059,44 +1101,72 @@ pub fn mmtf_read_text(text : String) -> MmtfStructure { } current_group = Some( MmtfGroup::new( - group_name=group_name, - group_number=group_number, + group_name~, + group_number~, single_letter_code=slc, sec_struct=ss, ), ) } else if trimmed.starts_with(" ATOM ") { - let parts = trimmed.split(" ").to_array().filter(fn(s) -> Bool { - s.length() > 0 - }) + let parts = trimmed + .split(" ") + .to_array() + .filter(fn(s) -> Bool { s.length() > 0 }) let name = if parts.length() >= 2 { parts[1].to_string() } else { "" } - let serial = if parts.length() >= 3 { parse_int(parts[2].to_string()) } else { 0 } - let x = if parts.length() >= 4 { parse_double(parts[3].to_string()).unwrap_or(0.0) } else { 0.0 } - let y = if parts.length() >= 5 { parse_double(parts[4].to_string()).unwrap_or(0.0) } else { 0.0 } - let z = if parts.length() >= 6 { parse_double(parts[5].to_string()).unwrap_or(0.0) } else { 0.0 } + let serial = if parts.length() >= 3 { + parse_int(parts[2].to_string()) + } else { + 0 + } + let x = if parts.length() >= 4 { + parse_double(parts[3].to_string()).unwrap_or(0.0) + } else { + 0.0 + } + let y = if parts.length() >= 5 { + parse_double(parts[4].to_string()).unwrap_or(0.0) + } else { + 0.0 + } + let z = if parts.length() >= 6 { + parse_double(parts[5].to_string()).unwrap_or(0.0) + } else { + 0.0 + } let element = if parts.length() >= 7 { parts[6].to_string() } else { "" } - let charge = if parts.length() >= 8 { parse_int(parts[7].to_string()) } else { 0 } - let atom = MmtfAtom::new( - name=name, - serial=serial, - x=x, - y=y, - z=z, - element=element, - charge=charge, - ) + let charge = if parts.length() >= 8 { + parse_int(parts[7].to_string()) + } else { + 0 + } + let atom = MmtfAtom::new(name~, serial~, x~, y~, z~, element~, charge~) match current_group { Some(g) => g.add_atom(atom) None => () } } else if trimmed.starts_with("BOND ") { - let parts = trimmed.split(" ").to_array().filter(fn(s) -> Bool { - s.length() > 0 - }) - let a1 = if parts.length() >= 2 { parse_int(parts[1].to_string()) } else { 0 } - let a2 = if parts.length() >= 3 { parse_int(parts[2].to_string()) } else { 0 } - let order = if parts.length() >= 4 { parse_int(parts[3].to_string()) } else { 1 } - structure.bonds.push(MmtfBond::new(atom_index1=a1, atom_index2=a2, bond_order=order)) + let parts = trimmed + .split(" ") + .to_array() + .filter(fn(s) -> Bool { s.length() > 0 }) + let a1 = if parts.length() >= 2 { + parse_int(parts[1].to_string()) + } else { + 0 + } + let a2 = if parts.length() >= 3 { + parse_int(parts[2].to_string()) + } else { + 0 + } + let order = if parts.length() >= 4 { + parse_int(parts[3].to_string()) + } else { + 1 + } + structure.bonds.push( + MmtfBond::new(atom_index1=a1, atom_index2=a2, bond_order=order), + ) } } // Save final group/chain/model @@ -1274,7 +1344,9 @@ pub fn mmtf_summary(structure : MmtfStructure) -> String { sb.write_string(" Groups: " + structure.count_groups().to_string() + "\n") sb.write_string(" Atoms: " + structure.count_atoms().to_string() + "\n") sb.write_string(" Bonds: " + structure.bonds.length().to_string() + "\n") - sb.write_string(" Entities: " + structure.entities.length().to_string() + "\n") + sb.write_string( + " Entities: " + structure.entities.length().to_string() + "\n", + ) sb.to_string() } @@ -1314,7 +1386,7 @@ pub fn mmtf_to_pdb_structure(mmtf : MmtfStructure) -> Structure { chainid=chain_id, resseq=mmtf_group.group_number, atoms=pdb_atoms, - hetfield=hetfield, + hetfield~, ), ) } diff --git a/src/mofa2.mbt b/src/mofa2.mbt index 84043377..b98a4680 100644 --- a/src/mofa2.mbt +++ b/src/mofa2.mbt @@ -88,13 +88,7 @@ pub fn MofaParams::create( ard_threshold? : Double = 0.01, seed? : Int = 42, ) -> MofaParams { - MofaParams::{ - n_factors: n_factors, - max_iterations: max_iterations, - tolerance: tolerance, - ard_threshold: ard_threshold, - seed: seed, - } + MofaParams::{ n_factors, max_iterations, tolerance, ard_threshold, seed } } ///| @@ -118,7 +112,9 @@ pub fn MofaResult::get_factors(self : MofaResult) -> Array[Array[Double]] { ///| /// Get loading matrices (views x features x factors). -pub fn MofaResult::get_loadings(self : MofaResult) -> Array[Array[Array[Double]]] { +pub fn MofaResult::get_loadings( + self : MofaResult, +) -> Array[Array[Array[Double]]] { self.loadings } @@ -168,19 +164,23 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { active_factors: 0, } } - + let n_samples = views[0].data.length() let n_factors = params.n_factors - + // Center each view let centered_views : Array[Array[Array[Double]]] = Array::new() { let mut v = 0 while v < n_views { let view_data = views[v].data - let n_features = if view_data.length() > 0 { view_data[0].length() } else { 0 } + let n_features = if view_data.length() > 0 { + view_data[0].length() + } else { + 0 + } let centered : Array[Array[Double]] = Array::new() - + // Compute feature means let means : Array[Double] = Array::make(n_features, 0.0) let mut s = 0 @@ -199,7 +199,7 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { f = f + 1 } } - + // Center data s = 0 while s < n_samples { @@ -216,10 +216,10 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { v = v + 1 } } - + // Initialize factors Z (samples x factors) let mut z = mofa_init_factors(n_samples, n_factors, params.seed) - + // Initialize loadings W (views x features x factors) with small random values let loadings : Array[Array[Array[Double]]] = Array::new() { @@ -230,11 +230,13 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { } else { 0 } - loadings.push(mofa_init_loadings(d, n_factors, params.seed + (v + 1) * 7919)) + loadings.push( + mofa_init_loadings(d, n_factors, params.seed + (v + 1) * 7919), + ) v = v + 1 } } - + // Initialize sigma (noise variance per view, feature) let sigma : Array[Array[Double]] = Array::new() { @@ -250,21 +252,23 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { v = v + 1 } } - + // ARD precision parameters let mut alpha : Array[Double] = Array::make(n_factors, 1.0) let mu = 0.0 let tau = 1.0 - + // EM iterations let mut iter = 0 let mut converged = false let mut prev_elbo = -1.0e30 - + while iter < params.max_iterations { // E-step: Update factors Z - z = mofa_update_factors(centered_views, loadings, sigma, z, n_factors, n_views, n_samples) - + z = mofa_update_factors( + centered_views, loadings, sigma, z, n_factors, n_views, n_samples, + ) + // M-step: Update loadings W { let mut v = 0 @@ -275,13 +279,18 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { 0 } loadings[v] = mofa_update_loadings( - centered_views[v], z, loadings[v], sigma[v], - n_features, n_factors, n_samples + centered_views[v], + z, + loadings[v], + sigma[v], + n_features, + n_factors, + n_samples, ) v = v + 1 } } - + // M-step: Update sigma { let mut v = 0 @@ -292,18 +301,25 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { 0 } sigma[v] = mofa_update_sigma( - centered_views[v], z, loadings[v], sigma[v], - n_features, n_factors, n_samples + centered_views[v], + z, + loadings[v], + sigma[v], + n_features, + n_factors, + n_samples, ) v = v + 1 } } - + // M-step: Update ARD alpha alpha = mofa_update_alpha(loadings, n_factors, n_views, mu, tau) - + // Compute ELBO (approximate) - let elbo = mofa_compute_elbo(centered_views, z, loadings, sigma, alpha, n_factors, n_views, n_samples) + let elbo = mofa_compute_elbo( + centered_views, z, loadings, sigma, alpha, n_factors, n_views, n_samples, + ) let delta = (elbo - prev_elbo).abs() if delta < params.tolerance { converged = true @@ -312,15 +328,15 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { prev_elbo = elbo iter = iter + 1 } - + // Compute variance explained let (factor_vars, view_vars) = mofa_compute_variance_explained( - centered_views, z, loadings, n_factors, n_views, n_samples + centered_views, z, loadings, n_factors, n_views, n_samples, ) - + // Count active factors let active = mofa_count_active_factors(factor_vars, params.ard_threshold) - + MofaResult::{ factors: z, loadings, @@ -335,7 +351,11 @@ pub fn mofa_run(views : Array[MofaView], params : MofaParams) -> MofaResult { ///| /// Initialize factor matrix with small random values. -fn mofa_init_factors(n_samples : Int, n_factors : Int, seed : Int) -> Array[Array[Double]] { +fn mofa_init_factors( + n_samples : Int, + n_factors : Int, + seed : Int, +) -> Array[Array[Double]] { let z : Array[Array[Double]] = Array::new() let mut s = seed let mut i = 0 @@ -356,7 +376,11 @@ fn mofa_init_factors(n_samples : Int, n_factors : Int, seed : Int) -> Array[Arra ///| /// Initialize loading matrix with small random values. -fn mofa_init_loadings(n_features : Int, n_factors : Int, seed : Int) -> Array[Array[Double]] { +fn mofa_init_loadings( + n_features : Int, + n_factors : Int, + seed : Int, +) -> Array[Array[Double]] { let w : Array[Array[Double]] = Array::new() let mut s = seed let mut f = 0 @@ -404,13 +428,18 @@ fn mofa_update_factors( let mut mean_accum = 0.0 let mut v = 0 while v < n_views { - let n_features = if views[v].length() > 0 { views[v][0].length() } else { 0 } + let n_features = if views[v].length() > 0 { + views[v][0].length() + } else { + 0 + } let mut f = 0 while f < n_features { let w_fk = loadings[v][f][k] let s2 = if sigma[v][f] > 1.0e-10 { sigma[v][f] } else { 1.0e-10 } precision = precision + w_fk * w_fk / s2 - let residual = views[v][i][f] - mofa_prediction_single(loadings, z, i, f, k, v) + let residual = views[v][i][f] - + mofa_prediction_single(loadings, z, i, f, k, v) mean_accum = mean_accum + w_fk * residual / s2 f = f + 1 } @@ -427,6 +456,7 @@ fn mofa_update_factors( new_z } +///| fn mofa_prediction_single( loadings : Array[Array[Array[Double]]], z : Array[Array[Double]], @@ -475,7 +505,11 @@ fn mofa_update_loadings( i = i + 1 } denominator = denominator + 0.01 * s2 - row[k] = if denominator > 1.0e-10 { numerator / denominator } else { w[f][k] } + row[k] = if denominator > 1.0e-10 { + numerator / denominator + } else { + w[f][k] + } k = k + 1 } new_w.push(row) @@ -484,6 +518,7 @@ fn mofa_update_loadings( new_w } +///| fn mofa_prediction_loadings( w : Array[Array[Double]], z : Array[Array[Double]], @@ -530,7 +565,11 @@ fn mofa_update_sigma( ss = ss + residual * residual i = i + 1 } - new_sigma[f] = if n_samples > 0 { ss / n_samples.to_double() } else { sigma_view[f] } + new_sigma[f] = if n_samples > 0 { + ss / n_samples.to_double() + } else { + sigma_view[f] + } if new_sigma[f] < 1.0e-6 { new_sigma[f] = 1.0e-6 } @@ -564,7 +603,11 @@ fn mofa_update_alpha( total_features = total_features + n_features v = v + 1 } - let expected = if total_features > 0 { sum_sq / total_features.to_double() } else { 0.0 } + let expected = if total_features > 0 { + sum_sq / total_features.to_double() + } else { + 0.0 + } let prec = if expected > 1.0e-10 { 1.0 / expected } else { 1.0e6 } new_alpha[k] = prec k = k + 1 @@ -587,7 +630,11 @@ fn mofa_compute_elbo( let mut elbo = 0.0 let mut v = 0 while v < n_views { - let n_features = if views[v].length() > 0 { views[v][0].length() } else { 0 } + let n_features = if views[v].length() > 0 { + views[v][0].length() + } else { + 0 + } let mut i = 0 while i < n_samples { let mut f = 0 @@ -600,7 +647,9 @@ fn mofa_compute_elbo( } let s2 = if sigma[v][f] > 1.0e-10 { sigma[v][f] } else { 1.0e-10 } let residual = views[v][i][f] - pred - elbo = elbo - 0.5 * @math.ln(2.0 * 3.14159265 * s2) - residual * residual / (2.0 * s2) + elbo = elbo - + 0.5 * @math.ln(2.0 * 3.14159265 * s2) - + residual * residual / (2.0 * s2) f = f + 1 } i = i + 1 @@ -634,18 +683,29 @@ fn mofa_compute_variance_explained( i = i + 1 } let mean = sum / n_samples.to_double() - let var = if n_samples > 1 { (sum_sq / n_samples.to_double()) - mean * mean } else { 0.0 } + let var = if n_samples > 1 { + sum_sq / n_samples.to_double() - mean * mean + } else { + 0.0 + } factor_vars[k] = if var > 0.0 { var } else { 0.0 } k = k + 1 } } - + // View variance explained by each factor - let view_vars : Array[Array[Double]] = Array::make(n_views, Array::make(n_factors, 0.0)) + let view_vars : Array[Array[Double]] = Array::make( + n_views, + Array::make(n_factors, 0.0), + ) { let mut v = 0 while v < n_views { - let n_features = if views[v].length() > 0 { views[v][0].length() } else { 0 } + let n_features = if views[v].length() > 0 { + views[v][0].length() + } else { + 0 + } let mut k = 0 while k < n_factors { let mut total_var = 0.0 @@ -661,7 +721,7 @@ fn mofa_compute_variance_explained( v = v + 1 } } - + // Normalize view_vars to percentages { let mut v = 0 @@ -677,13 +737,16 @@ fn mofa_compute_variance_explained( v = v + 1 } } - + (factor_vars, view_vars) } ///| /// Count active factors based on variance threshold. -fn mofa_count_active_factors(factor_vars : Array[Double], threshold : Double) -> Int { +fn mofa_count_active_factors( + factor_vars : Array[Double], + threshold : Double, +) -> Int { let mut count = 0 for v in factor_vars { if v > threshold { @@ -693,6 +756,7 @@ fn mofa_count_active_factors(factor_vars : Array[Double], threshold : Double) -> count } +///| fn mofa_sum_double(arr : Array[Double]) -> Double { let mut s = 0.0 for v in arr { @@ -703,13 +767,10 @@ fn mofa_sum_double(arr : Array[Double]) -> Double { ///| /// Create example data for MOFA2 testing. -pub fn mofa_create_example( - n_samples : Int, - n_factors : Int, -) -> Array[MofaView] { +pub fn mofa_create_example(n_samples : Int, n_factors : Int) -> Array[MofaView] { let mut rng = 42 let views : Array[MofaView] = Array::new() - + // View 1: RNA-seq (high-dimensional) { let n_features = 50 @@ -743,9 +804,11 @@ pub fn mofa_create_example( feature_names.push("gene_" + f.to_string()) f = f + 1 } - views.push(MofaView::new("rna", data, feature_names, [], view_type="gaussian")) + views.push( + MofaView::new("rna", data, feature_names, [], view_type="gaussian"), + ) } - + // View 2: ATAC-seq (lower-dimensional, shares some factors) { let n_features = 30 @@ -779,9 +842,11 @@ pub fn mofa_create_example( feature_names.push("peak_" + f.to_string()) f = f + 1 } - views.push(MofaView::new("atac", data, feature_names, [], view_type="gaussian")) + views.push( + MofaView::new("atac", data, feature_names, [], view_type="gaussian"), + ) } - + // Set sample names { let mut v = 0 @@ -792,10 +857,16 @@ pub fn mofa_create_example( sample_names.push("sample_" + s.to_string()) s = s + 1 } - views[v] = MofaView::new(views[v].view_name, views[v].data, views[v].feature_names, sample_names, view_type=views[v].view_type) + views[v] = MofaView::new( + views[v].view_name, + views[v].data, + views[v].feature_names, + sample_names, + view_type=views[v].view_type, + ) v = v + 1 } } - + views } diff --git a/src/mol_wt.mbt b/src/mol_wt.mbt index 001c9fa7..c278d925 100644 --- a/src/mol_wt.mbt +++ b/src/mol_wt.mbt @@ -125,7 +125,7 @@ pub fn mol_weight_dna(sequence : String) -> Double { i = i + 1 } // Subtract water for each phosphodiester bond (n-1 bonds) - total - ((n - 1).to_double() * 18.01524) + total - (n - 1).to_double() * 18.01524 } ///| @@ -153,7 +153,7 @@ pub fn mol_weight_protein(sequence : String) -> Double { i = i + 1 } // Subtract water for each peptide bond (n-1 bonds) - total - ((n - 1).to_double() * 18.01524) + total - (n - 1).to_double() * 18.01524 } ///| @@ -181,7 +181,9 @@ pub fn extinction_coefficient_280(sequence : String) -> Double { i = i + 1 } let n_cystine = n_cys / 2 - (n_trp.to_double() * 5500.0) + (n_tyr.to_double() * 1490.0) + (n_cystine.to_double() * 125.0) + n_trp.to_double() * 5500.0 + + n_tyr.to_double() * 1490.0 + + n_cystine.to_double() * 125.0 } ///| @@ -248,7 +250,11 @@ pub fn mol_wt_isoelectric_point(sequence : String) -> Double { let pK_R = 12.48 // Arg // Simple approximation let pos_charges = 1.0 + n_lys.to_double() + n_arg.to_double() - let neg_charges = 1.0 + n_asp.to_double() + n_glu.to_double() + n_cys.to_double() + n_tyr.to_double() + let neg_charges = 1.0 + + n_asp.to_double() + + n_glu.to_double() + + n_cys.to_double() + + n_tyr.to_double() if pos_charges + neg_charges < 1.0e-10 { return 7.0 } @@ -266,28 +272,58 @@ pub fn mol_wt_isoelectric_point(sequence : String) -> Double { ///| /// Compute the difference in molecular weight between two sequences. -pub fn mol_weight_diff(seq1 : String, seq2 : String, is_protein? : Bool = false) -> Double { - let mw1 = if is_protein { mol_weight_protein(seq1) } else { mol_weight_dna(seq1) } - let mw2 = if is_protein { mol_weight_protein(seq2) } else { mol_weight_dna(seq2) } +pub fn mol_weight_diff( + seq1 : String, + seq2 : String, + is_protein? : Bool = false, +) -> Double { + let mw1 = if is_protein { + mol_weight_protein(seq1) + } else { + mol_weight_dna(seq1) + } + let mw2 = if is_protein { + mol_weight_protein(seq2) + } else { + mol_weight_dna(seq2) + } mw1 - mw2 } ///| /// Generate a summary string for a sequence's molecular properties. -pub fn mol_weight_summary(sequence : String, is_protein? : Bool = false) -> String { +pub fn mol_weight_summary( + sequence : String, + is_protein? : Bool = false, +) -> String { let length = sequence.length() - let mw = if is_protein { mol_weight_protein(sequence) } else { mol_weight_dna(sequence) } + let mw = if is_protein { + mol_weight_protein(sequence) + } else { + mol_weight_dna(sequence) + } let ext = if is_protein { extinction_coefficient_280(sequence) } else { 0.0 } let pI = if is_protein { mol_wt_isoelectric_point(sequence) } else { 0.0 } let type_str = if is_protein { "Protein" } else { "DNA" } "MolWt Summary:\n" + - " Type: " + type_str + "\n" + - " Length: " + length.to_string() + "\n" + - " Molecular Weight: " + mw.to_string() + " Da\n" + + " Type: " + + type_str + + "\n" + + " Length: " + + length.to_string() + + "\n" + + " Molecular Weight: " + + mw.to_string() + + " Da\n" + (if is_protein { - " Extinction Coefficient (280): " + ext.to_string() + " M^-1 cm^-1\n" + - " Isoelectric Point: " + pI.to_string() - } else { "" }) + " Extinction Coefficient (280): " + + ext.to_string() + + " M^-1 cm^-1\n" + + " Isoelectric Point: " + + pI.to_string() + } else { + "" + }) } ///| diff --git a/src/monocle3.mbt b/src/monocle3.mbt index 91a49066..54188813 100644 --- a/src/monocle3.mbt +++ b/src/monocle3.mbt @@ -415,7 +415,11 @@ pub fn reduce_dimension( let umap_result = umap(pca_data, num_dimensions) - let reduced_dims = merge_reduced_dimensions(cds.reduced_dimensions, "UMAP", umap_result) + let reduced_dims = merge_reduced_dimensions( + cds.reduced_dimensions, + "UMAP", + umap_result, + ) return CellDataSet::{ counts: cds.counts, @@ -447,10 +451,13 @@ fn merge_reduced_dimensions( } i = i + 1 } - + let result_len = if has_name { n } else { n + 1 } - let result : Array[(String, Array[Array[Double]])] = Array::make(result_len, ("".to_string(), Array::new())) - + let result : Array[(String, Array[Array[Double]])] = Array::make( + result_len, + ("".to_string(), Array::new()), + ) + let mut j = 0 i = 0 while i < n { @@ -462,11 +469,11 @@ fn merge_reduced_dimensions( j = j + 1 i = i + 1 } - + if !has_name { result[j] = (name.to_string(), data) } - + result } @@ -685,13 +692,12 @@ pub fn learn_graph(cds : CellDataSet) -> CellDataSet { let reduced = reduce_dimension(cds, "UMAP", 2) match get_reduced_dimension(reduced, "UMAP") { Some(d) => d - None => { + None => if reduced.normalized.length() > 0 { reduced.normalized } else { return cds } - } } } } @@ -911,7 +917,8 @@ pub fn fit_models( let mut j = 0 while j < n_cells { if cds.pseudotime[j] >= 0.0 { - let expr = if j < cds.normalized.length() && idx < cds.normalized[j].length() { + let expr = if j < cds.normalized.length() && + idx < cds.normalized[j].length() { cds.normalized[j][idx] } else { 0.0 @@ -983,11 +990,11 @@ pub fn BranchPoint::new( ///| pub fn find_branch_points(cds : CellDataSet) -> Array[BranchPoint] { let branch_points : Array[BranchPoint] = Array::new() - + if cds.principal_graph.length() < 3 { return branch_points } - + let mut i = 0 while i < cds.principal_graph.length() { let edges = cds.principal_graph[i].2 @@ -995,7 +1002,7 @@ pub fn find_branch_points(cds : CellDataSet) -> Array[BranchPoint] { let position = cds.principal_graph[i].1 let branch1 : Array[Int] = Array::new() let branch2 : Array[Int] = Array::new() - + let mut j = 0 while j < cds.cell_partitions.length() { if cds.cell_partitions[j] == edges[0] { @@ -1005,12 +1012,12 @@ pub fn find_branch_points(cds : CellDataSet) -> Array[BranchPoint] { } j = j + 1 } - + branch_points.push(BranchPoint::new(i, position, [(branch1, branch2)])) } i = i + 1 } - + branch_points } @@ -1023,59 +1030,67 @@ pub fn differential_gene_test_branches( let n_genes = gene_names.length() let branch1 = branch_point.branch_cells[0].0 let branch2 = branch_point.branch_cells[0].1 - + let gene_result : Array[String] = Array::new() let pseudotime_result : Array[Double] = Array::new() let q_value_result : Array[Double] = Array::new() let trend_statistic_result : Array[Double] = Array::new() - + let mut i = 0 while i < n_genes { let gene_idx = find_gene_index(cds.gene_names, gene_names[i]) if gene_idx.is_some() { let idx = gene_idx.unwrap() - + let mut sum_branch1 = 0.0 let mut sum_branch2 = 0.0 let mut n_branch1 = 0 let mut n_branch2 = 0 - + let mut j = 0 while j < branch1.length() { let cell_idx = branch1[j] - if cell_idx < cds.normalized.length() && idx < cds.normalized[cell_idx].length() { + if cell_idx < cds.normalized.length() && + idx < cds.normalized[cell_idx].length() { sum_branch1 = sum_branch1 + cds.normalized[cell_idx][idx] n_branch1 = n_branch1 + 1 } j = j + 1 } - + let mut k = 0 while k < branch2.length() { let cell_idx = branch2[k] - if cell_idx < cds.normalized.length() && idx < cds.normalized[cell_idx].length() { + if cell_idx < cds.normalized.length() && + idx < cds.normalized[cell_idx].length() { sum_branch2 = sum_branch2 + cds.normalized[cell_idx][idx] n_branch2 = n_branch2 + 1 } k = k + 1 } - + if n_branch1 > 0 && n_branch2 > 0 { let mean_branch1 = sum_branch1 / n_branch1.to_double() let mean_branch2 = sum_branch2 / n_branch2.to_double() let diff = mean_branch1 - mean_branch2 - + gene_result.push(gene_names[i]) pseudotime_result.push(0.5) - - let q_val = if diff.abs() > 0.5 { 0.001 } else if diff.abs() > 0.2 { 0.05 } else { 1.0 } + + let q_val = if diff.abs() > 0.5 { + 0.001 + } else if diff.abs() > 0.2 { + 0.05 + } else { + 1.0 + } q_value_result.push(q_val) trend_statistic_result.push(diff) } } i = i + 1 } - + DiffExprResult::{ gene: gene_result, pseudotime: pseudotime_result, @@ -1140,4 +1155,4 @@ pub fn create_example_monocle_data() -> ( } (counts, gene_names, cell_names) -} \ No newline at end of file +} diff --git a/src/motif_scan.mbt b/src/motif_scan.mbt index 525f69b9..3dcf9bfc 100644 --- a/src/motif_scan.mbt +++ b/src/motif_scan.mbt @@ -101,8 +101,8 @@ pub fn motif_scan_pwm_from_counts( let n_bases = counts.length() if n_bases == 0 { return PositionWeightMatrix::new( - motif_id=motif_id, - motif_name=motif_name, + motif_id~, + motif_name~, matrix=[], background=[0.25, 0.25, 0.25, 0.25], strand="+-", @@ -121,9 +121,9 @@ pub fn motif_scan_pwm_from_counts( } } PositionWeightMatrix::new( - motif_id=motif_id, - motif_name=motif_name, - matrix=matrix, + motif_id~, + motif_name~, + matrix~, background=[0.25, 0.25, 0.25, 0.25], strand="+-", ) @@ -200,7 +200,11 @@ pub fn compute_score(pssm : MotifScanPSSM, sequence : String) -> Double { if motif_len == 0 { return 0.0 } - let n = if sequence.length() < motif_len { sequence.length() } else { motif_len } + let n = if sequence.length() < motif_len { + sequence.length() + } else { + motif_len + } let mut score = 0.0 for i in 0.. Double { let bin_width = range / nbins.to_double() let mut dist = Array::make(nbins, 0.0) // Initialize: before any position the cumulative score is 0.0 with probability 1. - let init_bin = ms_clamp_bin(((0.0 - min_s) / bin_width).floor().to_int(), nbins) + let init_bin = ms_clamp_bin( + ((0.0 - min_s) / bin_width).floor().to_int(), + nbins, + ) dist[init_bin] = 1.0 // Convolve the per-position score distributions. for i in 0.. Double { dist = new_dist } // Sum probabilities for scores >= observed (from observed's bin upward). - let obs_bin = ms_clamp_bin(((score - min_s) / bin_width).floor().to_int(), nbins) + let obs_bin = ms_clamp_bin( + ((score - min_s) / bin_width).floor().to_int(), + nbins, + ) let mut pval = 0.0 for b_idx in obs_bin.. String { s = s + "Total matches: " + matches.length().to_string() + "\n" if matches.length() > 0 { s = s + "\nMatches:\n" - s = s + "motif_id\tsequence_id\tstart\tend\tstrand\tscore\tp-value\tmatched_sequence\n" + s = s + + "motif_id\tsequence_id\tstart\tend\tstrand\tscore\tp-value\tmatched_sequence\n" for i in 0.. PositionWeightMatrix { PositionWeightMatrix::new( motif_id="M0001", motif_name="SampleTF", - matrix=matrix, + matrix~, background=[0.25, 0.25, 0.25, 0.25], strand="+-", ) diff --git a/src/motifs.mbt b/src/motifs.mbt index dd644383..6348f0a2 100644 --- a/src/motifs.mbt +++ b/src/motifs.mbt @@ -308,7 +308,8 @@ pub fn meme_to_motif(meme_content : String) -> Motif { let probs = sites[pos].split(" ").to_array() for alpha_idx = 0; alpha_idx < 4; alpha_idx = alpha_idx + 1 { if alpha_idx < probs.length() { - pwm[pos][alpha_idx] = match parse_float_str(probs[alpha_idx].to_owned()) { + pwm[pos][alpha_idx] = match + parse_float_str(probs[alpha_idx].to_owned()) { Some(v) => v None => 0.0 } @@ -373,8 +374,10 @@ pub fn align_motifs(motif1 : Motif, motif2 : Motif) -> Double { /// Returns an array of information content values for each position. pub fn motif_per_position_ic(motif : Motif) -> Array[Double] { let result : Array[Double] = Array::new() - if motif.pwm.length() == 0 { return result } - + if motif.pwm.length() == 0 { + return result + } + let background = 0.25 let mut pos = 0 while pos < motif.pwm.length() { @@ -410,15 +413,19 @@ pub fn motif_total_ic(motif : Motif) -> Double { ///| /// Generate a sequence logo data from aligned sequences. /// Returns an array of (position, letter, frequency, information_content). -pub fn generate_logo_data(sequences : Array[String]) -> Array[(Int, String, Double, Double)] { - if sequences.length() == 0 { return Array::new() } - +pub fn generate_logo_data( + sequences : Array[String], +) -> Array[(Int, String, Double, Double)] { + if sequences.length() == 0 { + return Array::new() + } + let width = sequences[0].length() let logo_data : Array[(Int, String, Double, Double)] = Array::new() - + let alphabet = ["A", "C", "G", "T"] let n = sequences.length().to_double() - + let mut pos = 0 while pos < width { let counts = Map([], capacity=4) @@ -428,33 +435,33 @@ pub fn generate_logo_data(sequences : Array[String]) -> Array[(Int, String, Doub counts.set(base, counts.get(base).unwrap_or(0) + 1) i = i + 1 } - + let background = 0.25 let mut ic = 0.0 let mut max_freq = 0.0 let mut max_base = "" - + let mut ai = 0 while ai < alphabet.length() { let base = alphabet[ai] let count = counts.get(base).unwrap_or(0).to_double() let freq = count / n - + if freq > max_freq { max_freq = freq max_base = base } - + if freq > 0.0 { - ic = ic + freq * (log2_val(freq / background)) + ic = ic + freq * log2_val(freq / background) } ai = ai + 1 } - + logo_data.push((pos, max_base, max_freq, ic)) pos = pos + 1 } - + logo_data } @@ -464,21 +471,21 @@ pub fn motif_pearson_correlation(motif1 : Motif, motif2 : Motif) -> Double { if motif1.pwm.length() == 0 || motif2.pwm.length() == 0 { return 0.0 } - + let min_len = if motif1.pwm.length() < motif2.pwm.length() { motif1.pwm.length() } else { motif2.pwm.length() } - + let n = (min_len * motif1.alphabet.length()).to_double() - + let mut sum_x = 0.0 let mut sum_y = 0.0 let mut sum_xy = 0.0 let mut sum_x2 = 0.0 let mut sum_y2 = 0.0 - + let mut pos = 0 while pos < min_len { let row1 = motif1.pwm[pos] @@ -496,11 +503,11 @@ pub fn motif_pearson_correlation(motif1 : Motif, motif2 : Motif) -> Double { } pos = pos + 1 } - + let numerator = n * sum_xy - sum_x * sum_x let denom1 = sqrt_val(n * sum_x2 - sum_x * sum_x) let denom2 = sqrt_val(n * sum_y2 - sum_y * sum_y) - + if denom1 * denom2 > 0.0 { numerator / (denom1 * denom2) } else { @@ -517,24 +524,28 @@ pub fn motif_enrichment( background? : Array[String] = [], ) -> Array[(String, Double, Double)] { let results : Array[(String, Double, Double)] = Array::new() - + // Count motif occurrences in target sequences let motif_counts : Map[String, Int] = Map([], capacity=motifs.length()) let seq_lengths : Map[String, Double] = Map([], capacity=motifs.length()) - + let mut mi = 0 while mi < motifs.length() { let motif = motifs[mi] let width = motif.pwm.length() let mut total_sites = 0 - + let mut si = 0 while si < sequences.length() { let seq = sequences[si] let mut pos = 0 while pos <= seq.length() - width { let subseq = seq[pos:pos + width].to_owned() - let score = score_sequence(pssm_from_pwm(motif.pwm, [0.25, 0.25, 0.25, 0.25]), subseq, motif.alphabet) + let score = score_sequence( + pssm_from_pwm(motif.pwm, [0.25, 0.25, 0.25, 0.25]), + subseq, + motif.alphabet, + ) if score > 0.0 { total_sites = total_sites + 1 } @@ -542,12 +553,12 @@ pub fn motif_enrichment( } si = si + 1 } - + motif_counts.set(motif.name, total_sites) seq_lengths.set(motif.name, sequences.length().to_double()) mi = mi + 1 } - + // Calculate enrichment score (simplified) let names = motif_counts.keys().collect() let mut ni = 0 @@ -555,31 +566,33 @@ pub fn motif_enrichment( let name = names[ni] let count = motif_counts[name] let total_seqs = sequences.length().to_double() - + let frequency = if total_seqs > 0.0 { count.to_double() / total_seqs } else { 0.0 } - + let enrichment = if frequency > 0.0 && total_seqs > 0.0 { log2_val(frequency * total_seqs) } else { 0.0 } - + results.push((name, count.to_double(), enrichment)) ni = ni + 1 } - + results } ///| /// Calculate the GC content of a motif (average GC frequency). pub fn motif_gc_content(motif : Motif) -> Double { - if motif.pwm.length() == 0 { return 0.0 } - + if motif.pwm.length() == 0 { + return 0.0 + } + let mut gc_sum = 0.0 let mut count = 0 let mut pos = 0 @@ -591,7 +604,7 @@ pub fn motif_gc_content(motif : Motif) -> Double { count = count + 1 pos = pos + 1 } - + if count > 0 { gc_sum / count.to_double() } else { @@ -607,9 +620,9 @@ pub fn generate_random_motif( gc_content? : Double = 0.5, ) -> Motif { let pwm = Array::make(length, Array::make(4, 0.0)) - + let at_content = 1.0 - gc_content - + let mut pos = 0 while pos < length { let row = Array::make(4, 0.0) @@ -617,16 +630,16 @@ pub fn generate_random_motif( // C, G get equal share of GC content let at_share = at_content / 2.0 let gc_share = gc_content / 2.0 - + row[0] = at_share // A row[1] = gc_share // C row[2] = gc_share // G row[3] = at_share // T - + pwm[pos] = row pos = pos + 1 } - + Motif::new(name, pwm, dna_alphabet, []) } @@ -640,15 +653,15 @@ fn parse_float_str(s : String) -> Double? { let mut sign = 1.0 let mut i = 0 let zero = '0'.to_int() - + if s.unsafe_get(0).to_int() == '-'.to_int() { sign = -1.0 i = 1 } - + let mut has_dot = false let mut decimal_place = 1.0 - + while i < s.length() { let c = s.unsafe_get(i).to_int() if c == '.'.to_int() { @@ -665,14 +678,16 @@ fn parse_float_str(s : String) -> Double? { } i = i + 1 } - + Some(result * sign / decimal_place) } ///| /// Calculate the square root of a number. fn sqrt_val(x : Double) -> Double { - if x <= 0.0 { return 0.0 } + if x <= 0.0 { + return 0.0 + } let mut guess = x / 2.0 let mut i = 0 while i < 100 { @@ -685,7 +700,9 @@ fn sqrt_val(x : Double) -> Double { ///| /// Calculate log2 of a number. fn log2_val(x : Double) -> Double { - if x <= 0.0 { return 0.0 } + if x <= 0.0 { + return 0.0 + } // Use natural log conversion: log2(x) = ln(x) / ln(2) let ln2 = 0.6931471805599453 let mut result = 0.0 diff --git a/src/motifs_advanced.mbt b/src/motifs_advanced.mbt index 9d8c70d5..f06ac56e 100644 --- a/src/motifs_advanced.mbt +++ b/src/motifs_advanced.mbt @@ -132,15 +132,15 @@ fn adv_parse_float(s : String) -> Double? { let mut sign = 1.0 let mut i = 0 let zero = '0'.to_int() - + if s.unsafe_get(0).to_int() == '-'.to_int() { sign = -1.0 i = 1 } - + let mut has_dot = false let mut decimal_place = 1.0 - + while i < s.length() { let c = s.unsafe_get(i).to_int() if c == '.'.to_int() { @@ -157,13 +157,15 @@ fn adv_parse_float(s : String) -> Double? { } i = i + 1 } - + Some(result * sign / decimal_place) } ///| fn adv_log2(x : Double) -> Double { - if x <= 0.0 { return 0.0 } + if x <= 0.0 { + return 0.0 + } let ln2 = 0.6931471805599453 let term = (x - 1.0) / (x + 1.0) let term2 = term * term @@ -252,7 +254,7 @@ pub fn parse_jaspar_pfm(content : String) -> Array[JasparMotif] { let motifs : Array[JasparMotif] = Array::new() let lines_view = content.split("\n") let lines = lines_view.to_array() - + let mut i = 0 while i < lines.length() { let line_view = lines[i].trim() @@ -269,12 +271,12 @@ pub fn parse_jaspar_pfm(content : String) -> Array[JasparMotif] { if parts.length() >= 2 { name = parts[1].trim().to_owned() } - + let mut a_counts : Array[Double] = Array::new() let mut c_counts : Array[Double] = Array::new() let mut g_counts : Array[Double] = Array::new() let mut t_counts : Array[Double] = Array::new() - + let mut j = i + 1 while j < lines.length() && !lines[j].trim().has_prefix(">") { let row_view = lines[j].trim() @@ -293,7 +295,7 @@ pub fn parse_jaspar_pfm(content : String) -> Array[JasparMotif] { } j = j + 1 } - + let width = a_counts.length() if width > 0 { let pwm = Array::make(width, Array::make(4, 0.0)) @@ -303,7 +305,7 @@ pub fn parse_jaspar_pfm(content : String) -> Array[JasparMotif] { pwm[pos][2] = g_counts[pos] pwm[pos][3] = t_counts[pos] } - + let motif = JasparMotif::new( matrix_id, name, @@ -318,13 +320,13 @@ pub fn parse_jaspar_pfm(content : String) -> Array[JasparMotif] { ) motifs.push(motif) } - + i = j } else { i = i + 1 } } - + motifs } @@ -332,14 +334,14 @@ pub fn parse_jaspar_pfm(content : String) -> Array[JasparMotif] { fn parse_jaspar_row(line : String) -> (String, Array[Double]) { let counts : Array[Double] = Array::new() let mut base = "" - + if line.length() >= 1 { base = line[0:1].to_owned().to_upper() } - + let start_bracket = adv_index_of(line, "[") let end_bracket = adv_index_of(line, "]") - + if start_bracket >= 0 && end_bracket > start_bracket { let numbers_str = line[start_bracket + 1:end_bracket].to_owned() let number_parts = split_whitespace(numbers_str) @@ -368,7 +370,7 @@ fn parse_jaspar_row(line : String) -> (String, Array[Double]) { } } } - + (base, counts) } @@ -384,7 +386,7 @@ pub fn jaspar_pfm_to_pwm( let width = pfm.length() let alphabet_size = pfm[0].length() let pwm = Array::make(width, Array::make(alphabet_size, 0.0)) - + for pos = 0; pos < width; pos = pos + 1 { let row = pfm[pos] let mut total = 0.0 @@ -392,12 +394,12 @@ pub fn jaspar_pfm_to_pwm( total = total + row[i] } let norm_total = total + pseudocount * alphabet_size.to_double() - + for alpha_idx = 0; alpha_idx < alphabet_size; alpha_idx = alpha_idx + 1 { pwm[pos][alpha_idx] = (row[alpha_idx] + pseudocount) / norm_total } } - + pwm } @@ -411,7 +413,7 @@ pub fn parse_transfac(content : String) -> Array[TransfacMotif] { let motifs : Array[TransfacMotif] = Array::new() let lines_view = content.split("\n") let lines = lines_view.to_array() - + let mut i = 0 while i < lines.length() { let line_view = lines[i].trim() @@ -424,12 +426,12 @@ pub fn parse_transfac(content : String) -> Array[TransfacMotif] { let matrix_rows : Array[Array[Double]] = Array::new() let binding_sites : Array[String] = Array::new() let mut in_matrix = false - + let mut j = i + 1 while j < lines.length() && !lines[j].trim().has_prefix("//") { let row_view = lines[j].trim() let row_line = row_view.to_owned() - + if row_line.has_prefix("ID ") { id = row_line[2:].trim().to_owned() } else if row_line.has_prefix("NA ") { @@ -452,10 +454,10 @@ pub fn parse_transfac(content : String) -> Array[TransfacMotif] { matrix_rows.push(row) } } - + j = j + 1 } - + if matrix_rows.length() > 0 { let width = matrix_rows.length() let pwm = Array::make(width, Array::make(4, 0.0)) @@ -465,25 +467,19 @@ pub fn parse_transfac(content : String) -> Array[TransfacMotif] { pwm[pos][2] = matrix_rows[pos][2] pwm[pos][3] = matrix_rows[pos][3] } - + let motif = TransfacMotif::new( - accession, - id, - name, - description, - pwm, - dna_alphabet_jaspar, - binding_sites, + accession, id, name, description, pwm, dna_alphabet_jaspar, binding_sites, ) motifs.push(motif) } - + i = j + 1 } else { i = i + 1 } } - + motifs } @@ -500,44 +496,44 @@ pub fn optimal_motif_alignment( if motif1_pwm.length() == 0 || motif2_pwm.length() == 0 { return MotifAlignmentResult::new(0.0, 0, "+", 0) } - + let len1 = motif1_pwm.length() let len2 = motif2_pwm.length() let mut best_score = -1.0 let mut best_offset = 0 let mut best_strand = "+" let mut best_aligned_len = 0 - + for offset = -(len2 - 1); offset < len1; offset = offset + 1 { let (score, aligned_len) = calculate_alignment_score( - motif1_pwm, - motif2_pwm, - offset, + motif1_pwm, motif2_pwm, offset, ) - if score > best_score || (score == best_score && aligned_len > best_aligned_len) { + if score > best_score || + (score == best_score && aligned_len > best_aligned_len) { best_score = score best_offset = offset best_strand = "+" best_aligned_len = aligned_len } } - + let rev_motif2 = reverse_complement_pwm(motif2_pwm) for offset = -(len2 - 1); offset < len1; offset = offset + 1 { let (score, aligned_len) = calculate_alignment_score( - motif1_pwm, - rev_motif2, - offset, + motif1_pwm, rev_motif2, offset, ) - if score > best_score || (score == best_score && aligned_len > best_aligned_len) { + if score > best_score || + (score == best_score && aligned_len > best_aligned_len) { best_score = score best_offset = offset best_strand = "-" best_aligned_len = aligned_len } } - - MotifAlignmentResult::new(best_score, best_offset, best_strand, best_aligned_len) + + MotifAlignmentResult::new( + best_score, best_offset, best_strand, best_aligned_len, + ) } ///| @@ -550,10 +546,10 @@ fn calculate_alignment_score( let len2 = pwm2.length() let mut score = 0.0 let mut aligned_len = 0 - + let start1 = if offset >= 0 { offset } else { 0 } let start2 = if offset >= 0 { 0 } else { -offset } - + let mut i = start1 let mut j = start2 while i < len1 && j < len2 { @@ -568,11 +564,11 @@ fn calculate_alignment_score( i = i + 1 j = j + 1 } - + if aligned_len > 0 { score = score / aligned_len.to_double() } - + (score, aligned_len) } @@ -584,7 +580,7 @@ fn reverse_complement_pwm(pwm : Array[Array[Double]]) -> Array[Array[Double]] { } let alphabet_size = pwm[0].length() let rev_pwm = Array::make(width, Array::make(alphabet_size, 0.0)) - + for pos = 0; pos < width; pos = pos + 1 { let orig_pos = width - 1 - pos if alphabet_size == 4 { @@ -598,7 +594,7 @@ fn reverse_complement_pwm(pwm : Array[Array[Double]]) -> Array[Array[Double]] { } } } - + rev_pwm } @@ -611,13 +607,13 @@ pub fn motif_kl_divergence( if pwm1.length() == 0 || pwm2.length() == 0 { return 0.0 } - + let min_len = if pwm1.length() < pwm2.length() { pwm1.length() } else { pwm2.length() } - + let mut total_kl = 0.0 for pos = 0; pos < min_len; pos = pos + 1 { let row1 = pwm1[pos] @@ -632,7 +628,7 @@ pub fn motif_kl_divergence( } total_kl = total_kl + pos_kl } - + total_kl / min_len.to_double() } @@ -645,24 +641,24 @@ pub fn motif_js_divergence( if pwm1.length() == 0 || pwm2.length() == 0 { return 0.0 } - + let min_len = if pwm1.length() < pwm2.length() { pwm1.length() } else { pwm2.length() } - + let mut total_js = 0.0 for pos = 0; pos < min_len; pos = pos + 1 { let row1 = pwm1[pos] let row2 = pwm2[pos] let alphabet_size = row1.length() let m_row = Array::make(alphabet_size, 0.0) - + for k = 0; k < alphabet_size; k = k + 1 { m_row[k] = (row1[k] + row2[k]) / 2.0 } - + let mut kl1 = 0.0 let mut kl2 = 0.0 for k = 0; k < alphabet_size; k = k + 1 { @@ -673,10 +669,10 @@ pub fn motif_js_divergence( kl2 = kl2 + row2[k] * adv_log2(row2[k] / m_row[k]) } } - + total_js = total_js + (kl1 + kl2) / 2.0 } - + total_js / min_len.to_double() } @@ -695,7 +691,7 @@ pub fn cluster_motifs( if n == 0 { return [] } - + let similarity_matrix = Array::make(n, Array::make(n, 0.0)) for i = 0; i < n; i = i + 1 { for j = 0; j < n; j = j + 1 { @@ -709,15 +705,15 @@ pub fn cluster_motifs( } } } - + let clusters : Array[MotifCluster] = Array::new() let assigned = Array::make(n, false) - + for i = 0; i < n; i = i + 1 { if !assigned[i] { let cluster_members : Array[String] = Array::new() let cluster_indices : Array[Int] = Array::new() - + for j = i; j < n; j = j + 1 { if !assigned[j] { let mut all_similar = true @@ -733,7 +729,7 @@ pub fn cluster_motifs( } } } - + let mut best_rep_idx = 0 let mut best_avg_sim = 0.0 for k = 0; k < cluster_indices.length(); k = k + 1 { @@ -748,7 +744,7 @@ pub fn cluster_motifs( best_rep_idx = k } } - + let cluster = MotifCluster::new( clusters.length(), cluster_members, @@ -758,7 +754,7 @@ pub fn cluster_motifs( clusters.push(cluster) } } - + clusters } @@ -797,53 +793,58 @@ pub fn motif_gc_content_adv(pwm : Array[Array[Double]]) -> Double { ///| /// Shuffle the columns of a PWM to create a randomized control motif. -pub fn shuffle_motif_columns(pwm : Array[Array[Double]]) -> Array[Array[Double]] { +pub fn shuffle_motif_columns( + pwm : Array[Array[Double]], +) -> Array[Array[Double]] { let width = pwm.length() if width == 0 { return [] } let alphabet_size = pwm[0].length() - + let indices = Array::make(width, 0) for i = 0; i < width; i = i + 1 { indices[i] = i } - + for i = width - 1; i > 0; i = i - 1 { let j = (i * 7 + 3) % (i + 1) let temp = indices[i] indices[i] = indices[j] indices[j] = temp } - + let shuffled = Array::make(width, Array::make(alphabet_size, 0.0)) for i = 0; i < width; i = i + 1 { shuffled[i] = pwm[indices[i]].copy() } - + shuffled } ///| /// Create a motif with randomized nucleotide frequencies for each position. -pub fn randomize_motif(width : Int, alphabet_size : Int) -> Array[Array[Double]] { +pub fn randomize_motif( + width : Int, + alphabet_size : Int, +) -> Array[Array[Double]] { let pwm = Array::make(width, Array::make(alphabet_size, 0.0)) - + for pos = 0; pos < width; pos = pos + 1 { let row : Array[Double] = Array::new() let mut total = 0.0 - + for i = 0; i < alphabet_size; i = i + 1 { let val = adv_sin((pos * 17 + i * 31).to_double()).abs() + 0.1 row.push(val) total = total + val } - + for i = 0; i < alphabet_size; i = i + 1 { pwm[pos][i] = row[i] / total } } - + pwm } @@ -854,7 +855,7 @@ fn adv_sin(x : Double) -> Double { let mut sign = 1.0 let mut factorial = 1.0 let mut power = x - + let n = 15 let mut i = 0 while i < n { @@ -864,7 +865,7 @@ fn adv_sin(x : Double) -> Double { factorial = factorial * (2 * i + 2).to_double() * (2 * i + 3).to_double() i = i + 1 } - + result } @@ -882,21 +883,17 @@ pub fn pwm_to_transfac( if pwm.length() == 0 { return "" } - + let mut result = "AC " + accession + "\n" result = result + "ID " + name + "\n" result = result + "NA " + name + "\n" result = result + "DE " + name + " matrix\n" result = result + "P0 A C G T\n" - + for pos = 0; pos < pwm.length(); pos = pos + 1 { let row = pwm[pos] - let pos_str = if pos < 10 { - "0" + pos.to_string() - } else { - pos.to_string() - } - + let pos_str = if pos < 10 { "0" + pos.to_string() } else { pos.to_string() } + let mut row_str = pos_str + " " for k = 0; k < row.length(); k = k + 1 { let val_str = row[k].to_string() @@ -915,10 +912,10 @@ pub fn pwm_to_transfac( } result = result + row_str + "\n" } - + result = result + "XX\n" result = result + "//\n" - + result } @@ -932,10 +929,10 @@ pub fn pwm_to_jaspar( if pwm.length() == 0 { return "" } - + let width = pwm.length() let mut result = ">" + matrix_id + " " + name + "\n" - + let bases = ["A", "C", "G", "T"] for b = 0; b < 4; b = b + 1 { let mut values_str = bases[b] + " [ " @@ -947,6 +944,6 @@ pub fn pwm_to_jaspar( values_str = values_str + "]\n" result = result + values_str } - + result } diff --git a/src/ms_core_utils.mbt b/src/ms_core_utils.mbt index 7fb66819..314c11c1 100644 --- a/src/ms_core_utils.mbt +++ b/src/ms_core_utils.mbt @@ -130,7 +130,7 @@ pub fn mc_refine_centroids( let hi = if p + half_window >= n { n - 1 } else { p + half_window } let mut sum_mz = 0.0 let mut sum_int = 0.0 - for i in lo..=hi { + for i in lo..<=hi { let w = intensity[i] if w > 0.0 { sum_mz = sum_mz + mz[i] * w @@ -206,11 +206,7 @@ pub fn mc_join_peaks( let mut best_d = 1.0e300 for j in 0..= n { n - 1 } else { i + half_window } let mut s = 0.0 let mut cnt = 0 - for j in lo..=hi { + for j in lo..<=hi { s = s + values[j] cnt = cnt + 1 } @@ -292,7 +288,7 @@ pub fn mc_smooth_savitzky_golay( let mut t1 = 0.0 let mut t2 = 0.0 let center = (lo + hi).to_double() / 2.0 - for j in lo..=hi { + for j in lo..<=hi { let x = j.to_double() - center let y = values[j] let x2 = x * x @@ -310,13 +306,15 @@ pub fn mc_smooth_savitzky_golay( // | s1 s2 s3 | |b| = |t1| // | s2 s3 s4 | |c| |t2| // We only need a. Using Cramer's rule: - let det = s0 * (s2 * s4 - s3 * s3) - s1 * (s1 * s4 - s2 * s3) + + let det = s0 * (s2 * s4 - s3 * s3) - + s1 * (s1 * s4 - s2 * s3) + s2 * (s1 * s3 - s2 * s2) if det.abs() < 1.0e-15 { out[i] = values[i] continue } - let det_a = t0 * (s2 * s4 - s3 * s3) - s1 * (t1 * s4 - t2 * s3) + + let det_a = t0 * (s2 * s4 - s3 * s3) - + s1 * (t1 * s4 - t2 * s3) + s2 * (t1 * s3 - t2 * s2) out[i] = det_a / det } @@ -514,6 +512,7 @@ pub fn mc_dot(a : Array[Double], b : Array[Double]) -> Double { /// - "mean": replace with the row mean of non-missing values /// - "median": replace with the row median of non-missing values /// - "knn": K-nearest-neighbors imputation (k=5 default) + ///| /// Check if a value is NaN (missing). pub fn mc_is_missing(v : Double) -> Bool { @@ -738,9 +737,7 @@ pub fn mc_median_polish( /// and MAD (median absolute deviation). /// /// For each column, returns the median of values across rows. -pub fn mc_robust_summary( - matrix : Array[Array[Double]], -) -> Array[Double] { +pub fn mc_robust_summary(matrix : Array[Array[Double]]) -> Array[Double] { let n = matrix.length() if n == 0 { return [] @@ -775,7 +772,10 @@ pub fn mc_mad(values : Array[Double]) -> Double { ///| /// Check if a peak list is valid: m/z values must be strictly increasing /// and all intensities non-negative. -pub fn mc_valid_peak_list(mz : Array[Double], intensity : Array[Double]) -> Bool { +pub fn mc_valid_peak_list( + mz : Array[Double], + intensity : Array[Double], +) -> Bool { if mz.length() != intensity.length() { return false } diff --git a/src/msnbase.mbt b/src/msnbase.mbt index 7b95f515..dea2b624 100644 --- a/src/msnbase.mbt +++ b/src/msnbase.mbt @@ -30,15 +30,21 @@ pub enum MSLevel { ///| /// Create MS1 level. -pub fn ms_level_ms1() -> MSLevel { MSLevel::MS1 } +pub fn ms_level_ms1() -> MSLevel { + MSLevel::MS1 +} ///| /// Create MS2 level. -pub fn ms_level_ms2() -> MSLevel { MSLevel::MS2 } +pub fn ms_level_ms2() -> MSLevel { + MSLevel::MS2 +} ///| /// Create MSn level with specific n. -pub fn ms_level_msn(n : Int) -> MSLevel { MSLevel::MSn(n) } +pub fn ms_level_msn(n : Int) -> MSLevel { + MSLevel::MSn(n) +} ///| /// Ionization mode. @@ -50,17 +56,21 @@ pub enum Polarity { ///| /// Create positive polarity. -pub fn polarity_positive() -> Polarity { Polarity::Positive } +pub fn polarity_positive() -> Polarity { + Polarity::Positive +} ///| /// Create negative polarity. -pub fn polarity_negative() -> Polarity { Polarity::Negative } +pub fn polarity_negative() -> Polarity { + Polarity::Negative +} ///| /// Spectrum processing step (for tracking). pub struct ProcessingStep { description : String - timestamp : String // simplified timestamp as string + timestamp : String // simplified timestamp as string } ///| @@ -84,11 +94,11 @@ pub struct Spectrum { intensity : Array[Double] ms_level : MSLevel polarity : Polarity - rt : Double // retention time in seconds + rt : Double // retention time in seconds scan_index : Int - precursor_mz : Double // for MS2 - precursor_charge : Int // for MS2 - tic : Double // total ion current + precursor_mz : Double // for MS2 + precursor_charge : Int // for MS2 + tic : Double // total ion current peaks_count : Int mut centroided : Bool processing_log : Array[ProcessingStep] @@ -172,28 +182,40 @@ pub fn Spectrum::with_precursor( ///| /// Get m/z array. -pub fn Spectrum::mz(self : Spectrum) -> Array[Double] { self.mz } +pub fn Spectrum::mz(self : Spectrum) -> Array[Double] { + self.mz +} ///| /// Get intensity array. -pub fn Spectrum::intensity(self : Spectrum) -> Array[Double] { self.intensity } +pub fn Spectrum::intensity(self : Spectrum) -> Array[Double] { + self.intensity +} ///| /// Get number of peaks. -pub fn Spectrum::peaks_count(self : Spectrum) -> Int { self.peaks_count } +pub fn Spectrum::peaks_count(self : Spectrum) -> Int { + self.peaks_count +} ///| /// Get retention time. -pub fn Spectrum::rt(self : Spectrum) -> Double { self.rt } +pub fn Spectrum::rt(self : Spectrum) -> Double { + self.rt +} ///| /// Get total ion current. -pub fn Spectrum::tic(self : Spectrum) -> Double { self.tic } +pub fn Spectrum::tic(self : Spectrum) -> Double { + self.tic +} ///| /// Get the base peak (highest intensity) info: (mz, intensity). pub fn Spectrum::base_peak(self : Spectrum) -> (Double, Double) { - if self.peaks_count == 0 { return (0.0, 0.0) } + if self.peaks_count == 0 { + return (0.0, 0.0) + } let mut max_i = 0 let mut max_v = self.intensity[0] for i in 1.. (Double, Double) { pub fn Spectrum::find_peak( self : Spectrum, target_mz : Double, - ppm~ : Double = 10.0, + ppm? : Double = 10.0, ) -> Int { let n = self.peaks_count - if n == 0 { return -1 } + if n == 0 { + return -1 + } let tolerance = target_mz * ppm / 1000000.0 let mut best_idx = -1 let mut best_diff = 1000000.0 @@ -249,7 +273,9 @@ pub fn Spectrum::filter_mz_range( ///| /// Normalize spectrum intensity by TIC (so sum = 1.0). pub fn Spectrum::normalize_tic(self : Spectrum) -> Spectrum { - if self.tic <= 0.0 { return self } + if self.tic <= 0.0 { + return self + } let new_int : Array[Double] = [] for i in 0.. Spectrum { ///| /// An extracted ion chromatogram (XIC): intensity vs retention time. pub struct Chromatogram { - rt : Array[Double] // retention times in seconds - intensity : Array[Double] // intensities - mz_target : Double // target m/z (0 if full range) + rt : Array[Double] // retention times in seconds + intensity : Array[Double] // intensities + mz_target : Double // target m/z (0 if full range) ppm_tolerance : Double n_points : Int - acquisition_mode : String // "MRM", "SIM", "XIC", etc. + acquisition_mode : String // "MRM", "SIM", "XIC", etc. } ///| @@ -277,9 +303,9 @@ pub struct Chromatogram { pub fn Chromatogram::new( rt : Array[Double], intensity : Array[Double], - mz_target~ : Double = 0.0, - ppm_tolerance~ : Double = 10.0, - acquisition_mode~ : String = "XIC", + mz_target? : Double = 0.0, + ppm_tolerance? : Double = 10.0, + acquisition_mode? : String = "XIC", ) -> Chromatogram { let n = rt.length() Chromatogram::{ @@ -287,19 +313,27 @@ pub fn Chromatogram::new( intensity, mz_target, ppm_tolerance, - n_points: if n == intensity.length() { n } else { 0 }, + n_points: if n == intensity.length() { + n + } else { + 0 + }, acquisition_mode, } } ///| /// Get n_points. -pub fn Chromatogram::n_points(self : Chromatogram) -> Int { self.n_points } +pub fn Chromatogram::n_points(self : Chromatogram) -> Int { + self.n_points +} ///| /// Get total signal (AUC) using trapezoid rule. pub fn Chromatogram::total_auc(self : Chromatogram) -> Double { - if self.n_points < 2 { return 0.0 } + if self.n_points < 2 { + return 0.0 + } let mut auc = 0.0 for i in 1.. Double { ///| /// Find apex (maximum intensity) retention time and intensity. pub fn Chromatogram::apex(self : Chromatogram) -> (Double, Double) { - if self.n_points == 0 { return (0.0, 0.0) } + if self.n_points == 0 { + return (0.0, 0.0) + } let mut max_idx = 0 let mut max_v = self.intensity[0] for i in 1.. (Double, Double) { ///| /// Full width at half maximum (FWHM) in seconds. pub fn Chromatogram::fwhm(self : Chromatogram) -> Double { - if self.n_points < 3 { return 0.0 } + if self.n_points < 3 { + return 0.0 + } let (_apex_rt, apex_int) = self.apex() - if apex_int <= 0.0 { return 0.0 } + if apex_int <= 0.0 { + return 0.0 + } let half_max = apex_int / 2.0 // Find index of apex let mut apex_idx = 0 for i in 0.. Double { pub struct MSnFeatureData { feature_name : String protein_accessions : Array[String] - sequence : String // peptide sequence if applicable + sequence : String // peptide sequence if applicable modifications : Array[String] charge : Int mz : Double @@ -429,7 +472,7 @@ pub fn MSnSampleData::new( /// - sample_data: column annotations /// - processing: processing log pub struct MSnSet { - exprs : Array[Array[Double]] // rows=features, cols=samples + exprs : Array[Array[Double]] // rows=features, cols=samples feature_data : Array[MSnFeatureData] sample_data : Array[MSnSampleData] n_features : Int @@ -469,12 +512,20 @@ pub fn MSnSet::from_names( let n_s = if n_f > 0 { exprs[0].length() } else { 0 } let fd : Array[MSnFeatureData] = [] for i in 0.. Int { self.n_features } +pub fn MSnSet::n_features(self : MSnSet) -> Int { + self.n_features +} ///| /// Get n_samples. -pub fn MSnSet::n_samples(self : MSnSet) -> Int { self.n_samples } +pub fn MSnSet::n_samples(self : MSnSet) -> Int { + self.n_samples +} ///| /// Get expression matrix (intensities). -pub fn MSnSet::exprs(self : MSnSet) -> Array[Array[Double]] { self.exprs } +pub fn MSnSet::exprs(self : MSnSet) -> Array[Array[Double]] { + self.exprs +} ///| /// Get feature names. @@ -506,12 +563,20 @@ pub fn MSnSet::sample_names(self : MSnSet) -> Array[String] { ///| /// Get expression for a specific feature across samples. -pub fn MSnSet::get_feature(self : MSnSet, feature_name : String) -> Array[Double] { +pub fn MSnSet::get_feature( + self : MSnSet, + feature_name : String, +) -> Array[Double] { let mut idx = -1 for i in 0.. Array[Double pub fn MSnSet::get_sample(self : MSnSet, sample_name : String) -> Array[Double] { let mut idx = -1 for j in 0.. Array[Double] ///| /// Absolute value helper. fn mbn_abs(x : Double) -> Double { - if x < 0.0 { -x } else { x } + if x < 0.0 { + -x + } else { + x + } } ///| /// Log2 transform intensities in MSnSet (with offset for zeros). -pub fn MSnSet::log2_transform( - self : MSnSet, - offset~ : Double = 1.0, -) -> MSnSet { - if self.is_log2 { return self } +pub fn MSnSet::log2_transform(self : MSnSet, offset? : Double = 1.0) -> MSnSet { + if self.is_log2 { + return self + } let n_f = self.n_features let n_s = self.n_samples let new_exprs : Array[Array[Double]] = [] @@ -573,14 +646,16 @@ pub fn MSnSet::log2_transform( /// "zero" (set to 0), "min" (row min / 2) pub fn MSnSet::impute_missing( self : MSnSet, - method~ : String = "mean", + method? : String = "mean", ) -> MSnSet { let n_f = self.n_features let n_s = self.n_samples let new_exprs : Array[Array[Double]] = [] for i in 0.. MSnSet { let n_f = self.n_features let n_s = self.n_samples @@ -635,7 +712,9 @@ pub fn MSnSet::normalize_sum( let new_exprs : Array[Array[Double]] = [] for i in 0.. MSnSet { let new_exprs : Array[Array[Double]] = [] for i in 0.. MSnSet { /// Returns new MSnSet with one row per unique protein accession. pub fn MSnSet::summarize_to_proteins( self : MSnSet, - method~ : String = "sum", + method? : String = "sum", ) -> MSnSet { // Map from protein accession -> list of row indices let protein_rows : Map[String, Array[Int]] = Map([], capacity=0) @@ -721,7 +804,9 @@ pub fn MSnSet::summarize_to_proteins( match existing { Some(arr) => { let new_arr : Array[Int] = [] - for x in arr { new_arr.push(x) } + for x in arr { + new_arr.push(x) + } new_arr.push(i) protein_rows.set(name, new_arr) } @@ -737,7 +822,9 @@ pub fn MSnSet::summarize_to_proteins( match existing { Some(arr) => { let new_arr : Array[Int] = [] - for x in arr { new_arr.push(x) } + for x in arr { + new_arr.push(x) + } new_arr.push(i) protein_rows.set(p, new_arr) } @@ -756,7 +843,9 @@ pub fn MSnSet::summarize_to_proteins( let new_exprs : Array[Array[Double]] = [] for _i in 0.. Spectrum { let n = self.peaks_count - if n == 0 { return self } + if n == 0 { + return self + } let hw = if half_window < 1 { 1 } else { half_window } let new_int : Array[Double] = [] for i in 0.. Spectrum { let n = self.peaks_count - if n == 0 { return self } + if n == 0 { + return self + } let hw = if half_window < 1 { 1 } else { half_window } // Compute baseline estimate per point = min in window let baseline : Array[Double] = [] @@ -848,7 +945,9 @@ pub fn Spectrum::baseline_correct_minwin( let hi = if i + hw < n { i + hw } else { n - 1 } let mut min_v = self.intensity[lo] for k in lo..<(hi + 1) { - if self.intensity[k] < min_v { min_v = self.intensity[k] } + if self.intensity[k] < min_v { + min_v = self.intensity[k] + } } baseline.push(min_v) } @@ -865,10 +964,12 @@ pub fn Spectrum::baseline_correct_minwin( /// Returns a new centroided Spectrum with only peak locations. pub fn Spectrum::centroid_simple( self : Spectrum, - snr_threshold~ : Double = 3.0, + snr_threshold? : Double = 3.0, ) -> Spectrum { let n = self.peaks_count - if n < 3 { return self } + if n < 3 { + return self + } // Estimate noise as median of small differences let noise_estimate = 0.0 // Compute median intensity / 50 as simple noise floor @@ -882,8 +983,8 @@ pub fn Spectrum::centroid_simple( for i in 1..<(n - 1) { let cur = self.intensity[i] if cur >= threshold && - cur > self.intensity[i - 1] && - cur > self.intensity[i + 1] { + cur > self.intensity[i - 1] && + cur > self.intensity[i + 1] { // Simple 3-point parabolic apex refinement let a = self.intensity[i - 1] let b = cur @@ -899,7 +1000,13 @@ pub fn Spectrum::centroid_simple( new_int.push(cur) } } - let result = Spectrum::new(new_mz, new_int, self.ms_level, self.polarity, self.rt) + let result = Spectrum::new( + new_mz, + new_int, + self.ms_level, + self.polarity, + self.rt, + ) result.centroided = true result } @@ -908,6 +1015,7 @@ pub fn Spectrum::centroid_simple( // Helper: sort doubles // ============================================================================ +///| fn mbn_sort_dbl(arr : Array[Double]) -> Array[Double] { let result = arr.copy() let n = result.length() @@ -931,7 +1039,9 @@ fn mbn_sort_dbl(arr : Array[Double]) -> Array[Double] { ///| /// Compute per-sample QC metrics from MSnSet: /// Returns array of (sample_name, n_features_detected, total_intensity, median_intensity, coef_of_variation) -pub fn MSnSet::sample_qc(self : MSnSet) -> Array[(String, Int, Double, Double, Double)] { +pub fn MSnSet::sample_qc( + self : MSnSet, +) -> Array[(String, Int, Double, Double, Double)] { let n_s = self.n_samples let result : Array[(String, Int, Double, Double, Double)] = [] for j in 0.. Array[(String, Int, Double, Double, D let mut cv = 0.0 if k > 1 { let mut mean_v = 0.0 - for v in vals { mean_v = mean_v + v } + for v in vals { + mean_v = mean_v + v + } mean_v = mean_v / k.to_double() let mut sum_sq = 0.0 for v in vals { @@ -969,7 +1081,9 @@ pub fn MSnSet::sample_qc(self : MSnSet) -> Array[(String, Int, Double, Double, D sum_sq = sum_sq + d * d } let sd = (sum_sq / (k - 1).to_double()).sqrt() - if mean_v > 0.0 { cv = sd / mean_v } + if mean_v > 0.0 { + cv = sd / mean_v + } } let sname = if j < self.sample_data.length() { self.sample_data[j].sample_name diff --git a/src/msstats.mbt b/src/msstats.mbt index 40b37054..5ec1a413 100644 --- a/src/msstats.mbt +++ b/src/msstats.mbt @@ -209,7 +209,17 @@ pub fn ms_data_process( let mut i = 0 while i < features.length() { let f = features[i] - processed.push(MSFeature::new(f.protein, f.peptide, f.transition, f.group, f.subject, f.run, f.intensity)) + processed.push( + MSFeature::new( + f.protein, + f.peptide, + f.transition, + f.group, + f.subject, + f.run, + f.intensity, + ), + ) i = i + 1 } @@ -523,7 +533,11 @@ pub fn ms_group_comparison( let se = (var1 / n1 + var2 / n2).sqrt() let t_stat = if se < 1.0e-10 { - if (m2 - m1).abs() < 1.0e-10 { 0.0 } else { 100.0 } + if (m2 - m1).abs() < 1.0e-10 { + 0.0 + } else { + 100.0 + } } else { (m2 - m1) / se } @@ -535,8 +549,16 @@ pub fn ms_group_comparison( 1.0 } else { let t_sq = abs_t * abs_t - let p_approx = 2.0 * @math.exp(-df * @math.ln(1.0 + t_sq / df) / 2.0) / (df * 3.14159265358979).sqrt() - if p_approx > 1.0 { 1.0 } else if p_approx < 0.0 { 0.0 } else { p_approx } + let p_approx = 2.0 * + @math.exp(-df * @math.ln(1.0 + t_sq / df) / 2.0) / + (df * 3.14159265358979).sqrt() + if p_approx > 1.0 { + 1.0 + } else if p_approx < 0.0 { + 0.0 + } else { + p_approx + } } all_results.push(MSGroupResult::{ @@ -566,8 +588,13 @@ pub fn ms_group_comparison( let mut si2 = 0 while si2 < all_results.length() { all_results[si2].p_adj = adjusted[si2] - let abs_lfc = if all_results[si2].log2fc < 0.0 { -all_results[si2].log2fc } else { all_results[si2].log2fc } - all_results[si2].significant = adjusted[si2] < fdr_threshold && abs_lfc >= log2fc_threshold + let abs_lfc = if all_results[si2].log2fc < 0.0 { + -all_results[si2].log2fc + } else { + all_results[si2].log2fc + } + all_results[si2].significant = adjusted[si2] < fdr_threshold && + abs_lfc >= log2fc_threshold if all_results[si2].significant { n_sig = n_sig + 1 } @@ -586,12 +613,7 @@ pub fn ms_group_comparison( 0 } - MSGroupComparison::{ - results: all_results, - n_proteins, - n_sig, - fdr_threshold, - } + MSGroupComparison::{ results: all_results, n_proteins, n_sig, fdr_threshold } } ///| @@ -690,7 +712,9 @@ pub fn MSGroupComparison::get_n_results(self : MSGroupComparison) -> Int { ///| /// Get significant results. -pub fn MSGroupComparison::get_significant(self : MSGroupComparison) -> Array[MSGroupResult] { +pub fn MSGroupComparison::get_significant( + self : MSGroupComparison, +) -> Array[MSGroupResult] { let sig : Array[MSGroupResult] = Array::new() let mut i = 0 while i < self.results.length() { @@ -704,7 +728,10 @@ pub fn MSGroupComparison::get_significant(self : MSGroupComparison) -> Array[MSG ///| /// Get top N proteins by adjusted p-value. -pub fn MSGroupComparison::get_top_proteins(self : MSGroupComparison, n : Int) -> Array[MSGroupResult] { +pub fn MSGroupComparison::get_top_proteins( + self : MSGroupComparison, + n : Int, +) -> Array[MSGroupResult] { let sorted = self.results.copy() let len = sorted.length() let mut i = 0 @@ -736,7 +763,12 @@ pub fn MSGroupComparison::get_top_proteins(self : MSGroupComparison, n : Int) -> pub fn MSGroupComparison::summary(self : MSGroupComparison) -> String { let mut s = "=== MSstats Group Comparison Summary ===\n".to_string() s = s + "Proteins tested: " + self.n_proteins.to_string() + "\n" - s = s + "Significant (FDR < " + self.fdr_threshold.to_string() + "): " + self.n_sig.to_string() + "\n" + s = s + + "Significant (FDR < " + + self.fdr_threshold.to_string() + + "): " + + self.n_sig.to_string() + + "\n" s = s + "Total comparisons: " + self.results.length().to_string() + "\n" s } @@ -751,7 +783,12 @@ pub fn ms_design_sample_size( // Simplified: use the median log2fc and SE to estimate power let n = results.length() if n == 0 { - return MSSampleSize::{ desired_power, n_samples: 3, n_proteins_detectable: 0, delta: 0.0 } + return MSSampleSize::{ + desired_power, + n_samples: 3, + n_proteins_detectable: 0, + delta: 0.0, + } } // Sort by absolute log2fc @@ -760,8 +797,16 @@ pub fn ms_design_sample_size( while i < n - 1 { let mut j = 0 while j < n - 1 - i { - let abs1 = if sorted[j].log2fc < 0.0 { -sorted[j].log2fc } else { sorted[j].log2fc } - let abs2 = if sorted[j + 1].log2fc < 0.0 { -sorted[j + 1].log2fc } else { sorted[j + 1].log2fc } + let abs1 = if sorted[j].log2fc < 0.0 { + -sorted[j].log2fc + } else { + sorted[j].log2fc + } + let abs2 = if sorted[j + 1].log2fc < 0.0 { + -sorted[j + 1].log2fc + } else { + sorted[j + 1].log2fc + } if abs1 < abs2 { let tmp = sorted[j] sorted.set(j, sorted[j + 1]) @@ -773,7 +818,11 @@ pub fn ms_design_sample_size( } let mid = n / 2 - let delta = if sorted[mid].log2fc < 0.0 { -sorted[mid].log2fc } else { sorted[mid].log2fc } + let delta = if sorted[mid].log2fc < 0.0 { + -sorted[mid].log2fc + } else { + sorted[mid].log2fc + } let se = sorted[mid].se // Estimate required sample size using simplified power calculation @@ -781,16 +830,32 @@ pub fn ms_design_sample_size( let z_alpha = 1.96 let z_beta = if desired_power >= 0.8 { 0.842 } else { 0.674 } let sigma = if se > 0.0 { se } else { 1.0 } - let required_n = ((z_alpha + z_beta) * (z_alpha + z_beta) * sigma * sigma / (delta * delta + 1.0e-10)).to_int() - let n_samples_final = if n_samples > 0 { n_samples } else { if required_n < 3 { 3 } else { required_n } } + let required_n = ((z_alpha + z_beta) * + (z_alpha + z_beta) * + sigma * + sigma / + (delta * delta + 1.0e-10)).to_int() + let n_samples_final = if n_samples > 0 { + n_samples + } else if required_n < 3 { + 3 + } else { + required_n + } // Count how many proteins would be detectable with this sample size let n_detectable = if delta > 0.0 && se > 0.0 { let mut count = 0 let mut di = 0 while di < n { - let abs_lfc = if sorted[di].log2fc < 0.0 { -sorted[di].log2fc } else { sorted[di].log2fc } - let z = abs_lfc / (sorted[di].se + 1.0e-10) * (n_samples_final.to_double()).sqrt() + let abs_lfc = if sorted[di].log2fc < 0.0 { + -sorted[di].log2fc + } else { + sorted[di].log2fc + } + let z = abs_lfc / + (sorted[di].se + 1.0e-10) * + n_samples_final.to_double().sqrt() if z > z_alpha { count = count + 1 } @@ -828,19 +893,22 @@ pub fn msstats_sample_data() -> Array[MSFeature] { let peptide = proteins[pi] + "_pep" + pep_idx.to_string() let transition = peptide + "_tr" let intensity = if groups[gi] == "Trt" { - 1000.0 * (pi + 1).to_double() * 2.0 + (pep_idx + 1).to_double() * 100.0 + 1000.0 * (pi + 1).to_double() * 2.0 + + (pep_idx + 1).to_double() * 100.0 } else { 1000.0 * (pi + 1).to_double() + (pep_idx + 1).to_double() * 100.0 } - features.push(MSFeature::new( - proteins[pi], - peptide, - transition, - groups[gi], - subjects[gi], - runs[gi], - intensity, - )) + features.push( + MSFeature::new( + proteins[pi], + peptide, + transition, + groups[gi], + subjects[gi], + runs[gi], + intensity, + ), + ) pep_idx = pep_idx + 1 } gi = gi + 1 diff --git a/src/muscat.mbt b/src/muscat.mbt index 5683bc7b..e31c6e95 100644 --- a/src/muscat.mbt +++ b/src/muscat.mbt @@ -153,7 +153,11 @@ pub fn SingleCell::new( ///| /// Set gene count for a cell. -pub fn SingleCell::set_count(self : SingleCell, gene_id : String, count : Double) -> Unit { +pub fn SingleCell::set_count( + self : SingleCell, + gene_id : String, + count : Double, +) -> Unit { self.gene_counts.set(gene_id, count) } @@ -266,7 +270,11 @@ pub fn aggregate_cells( s = s + values[vi] vi = vi + 1 } - if values.length() > 0 { s / values.length().to_double() } else { 0.0 } + if values.length() > 0 { + s / values.length().to_double() + } else { + 0.0 + } } AggregationMethod::Median => { let sorted = values.copy() @@ -462,7 +470,11 @@ pub fn run_ds_analysis( let mut si2 = 0 while si2 < all_results.length() { all_results[si2].p_adj = adjusted[si2] - let abs_lfc = if all_results[si2].log2fc < 0.0 { -all_results[si2].log2fc } else { all_results[si2].log2fc } + let abs_lfc = if all_results[si2].log2fc < 0.0 { + -all_results[si2].log2fc + } else { + all_results[si2].log2fc + } let sig = adjusted[si2] < fdr_threshold && abs_lfc >= log2fc_threshold all_results[si2].significant = sig si2 = si2 + 1 @@ -554,19 +566,36 @@ fn compute_ttest_pvalue(ctrl : Array[Double], stim : Array[Double]) -> Double { let t_stat = (m2 - m1) / pooled_se // Degrees of freedom (Welch's) - let df_num = (v1 / n1.to_double() + v2 / n2.to_double()) * (v1 / n1.to_double() + v2 / n2.to_double()) - let df_den = (v1 / n1.to_double()) * (v1 / n1.to_double()) / (n1 - 1).to_double() + (v2 / n2.to_double()) * (v2 / n2.to_double()) / (n2 - 1).to_double() - let df = if df_den < 1.0e-10 { (n1 + n2 - 2).to_double() } else { df_num / df_den } + let df_num = (v1 / n1.to_double() + v2 / n2.to_double()) * + (v1 / n1.to_double() + v2 / n2.to_double()) + let df_den = v1 / + n1.to_double() * + (v1 / n1.to_double()) / + (n1 - 1).to_double() + + v2 / n2.to_double() * (v2 / n2.to_double()) / (n2 - 1).to_double() + let df = if df_den < 1.0e-10 { + (n1 + n2 - 2).to_double() + } else { + df_num / df_den + } // Approximate two-sided p-value from t-distribution // Using a simple approximation: p = 2 * (1 - cdf(|t|, df)) // Approximation: p ≈ 2 * exp(-df * ln(1 + t^2/df) / 2) / sqrt(df * pi) let abs_t = if t_stat < 0.0 { -t_stat } else { t_stat } let t_sq = abs_t * abs_t - let p_approx = 2.0 * @math.exp(-df * @math.ln(1.0 + t_sq / df) / 2.0) / (df * 3.14159265358979).sqrt() + let p_approx = 2.0 * + @math.exp(-df * @math.ln(1.0 + t_sq / df) / 2.0) / + (df * 3.14159265358979).sqrt() // Clamp p-value to [0, 1] - if p_approx > 1.0 { 1.0 } else if p_approx < 0.0 { 0.0 } else { p_approx } + if p_approx > 1.0 { + 1.0 + } else if p_approx < 0.0 { + 0.0 + } else { + p_approx + } } ///| @@ -650,7 +679,10 @@ pub fn DSResults::get_significant(self : DSResults) -> Array[DSResult] { ///| /// Get results for a specific cluster. -pub fn DSResults::get_cluster_results(self : DSResults, cluster_id : String) -> Array[DSResult] { +pub fn DSResults::get_cluster_results( + self : DSResults, + cluster_id : String, +) -> Array[DSResult] { let filtered : Array[DSResult] = Array::new() let mut i = 0 while i < self.results.length() { @@ -698,7 +730,12 @@ pub fn DSResults::summary(self : DSResults) -> String { s = s + "Method: " + self.ds_method.to_string() + "\n" s = s + "Total genes tested: " + self.n_genes.to_string() + "\n" s = s + "Clusters: " + self.n_clusters.to_string() + "\n" - s = s + "Significant (FDR < " + self.fdr_threshold.to_string() + "): " + self.n_sig.to_string() + "\n" + s = s + + "Significant (FDR < " + + self.fdr_threshold.to_string() + + "): " + + self.n_sig.to_string() + + "\n" s = s + "Total results: " + self.results.length().to_string() + "\n" s } @@ -712,11 +749,7 @@ pub fn compute_qc(pb_samples : Array[PseudoBulk]) -> Array[SampleQC] { let pb = pb_samples[i] let n_genes = pb.n_expressed() let total = pb.total_counts() - let median_genes = if pb.n_cells > 0 { - n_genes.to_double() - } else { - 0.0 - } + let median_genes = if pb.n_cells > 0 { n_genes.to_double() } else { 0.0 } qc_list.push(SampleQC::{ sample_id: pb.sample_id, cluster_id: pb.cluster_id, diff --git a/src/mutational_patterns.mbt b/src/mutational_patterns.mbt index a6568da5..24066121 100644 --- a/src/mutational_patterns.mbt +++ b/src/mutational_patterns.mbt @@ -10,12 +10,18 @@ ///| /// The 6 basic mutation types (pyrimidine-based). pub enum MutationCategory { - C_A /// C>A transversion - C_G /// C>G transversion - C_T /// C>T transition - T_A /// T>A transversion - T_C /// T>C transition - T_G /// T>G transversion + /// C>A transversion + /// C>G transversion + /// C>T transition + /// T>A transversion + /// T>C transition + /// T>G transversion + C_A + C_G + C_T + T_A + T_C + T_G } ///| @@ -71,8 +77,12 @@ pub fn MutationCategory::to_string(self : MutationCategory) -> String { /// All 6 mutation types in standard order. pub fn all_mutation_types() -> Array[MutationCategory] { [ - MutationCategory::C_A, MutationCategory::C_G, MutationCategory::C_T, - MutationCategory::T_A, MutationCategory::T_C, MutationCategory::T_G, + MutationCategory::C_A, + MutationCategory::C_G, + MutationCategory::C_T, + MutationCategory::T_A, + MutationCategory::T_C, + MutationCategory::T_G, ] } @@ -101,7 +111,8 @@ pub struct SomaticMutation { position : Int ref_base : String alt_base : String - trinucleotide_context : String /// e.g., "ACT" (ref is middle) + /// e.g., "ACT" (ref is middle) + trinucleotide_context : String } ///| @@ -115,7 +126,8 @@ pub struct MutationMatrix { channel_labels : Array[String] /// Count matrix: 96 rows × n_samples columns counts : Array[Array[Int]] - total_mutations : Array[Int] /// per-sample total + /// per-sample total + total_mutations : Array[Int] } ///| @@ -173,7 +185,10 @@ pub fn get_channel_labels() -> Array[String] { ///| /// Determine mutation type from ref and alt base. /// Uses pyrimidine-based convention (C/T as reference). -pub fn get_mutation_type(ref_base : String, alt_base : String) -> MutationCategory { +pub fn get_mutation_type( + ref_base : String, + alt_base : String, +) -> MutationCategory { let r = ref_base.to_upper() let a = alt_base.to_upper() // If ref is purine (A/G), reverse complement to get pyrimidine-based @@ -234,7 +249,11 @@ pub fn normalize_context(trinucleotide : String) -> String { ///| /// Get the 0-based channel index (0-95) for a mutation. /// Based on the trinucleotide context and mutation type. -pub fn get_channel_index(ref_base : String, alt_base : String, trinucleotide : String) -> Int { +pub fn get_channel_index( + ref_base : String, + alt_base : String, + trinucleotide : String, +) -> Int { let norm_ctx = normalize_context(trinucleotide) let mtype = get_mutation_type(ref_base, alt_base) // Find type index (0-5) @@ -354,7 +373,9 @@ pub fn MutationMatrix::get_count( ///| /// Convert counts to relative frequencies (normalize per sample). -pub fn MutationMatrix::to_relative_frequencies(self : MutationMatrix) -> Array[Array[Double]] { +pub fn MutationMatrix::to_relative_frequencies( + self : MutationMatrix, +) -> Array[Array[Double]] { let n_channels = self.counts.length() let n_samples = if n_channels > 0 { self.counts[0].length() } else { 0 } let result : Array[Array[Double]] = Array::new() @@ -381,7 +402,11 @@ pub fn MutationMatrix::to_relative_frequencies(self : MutationMatrix) -> Array[A ///| /// Compute cosine similarity between two vectors. pub fn cosine_similarity(vec1 : Array[Double], vec2 : Array[Double]) -> Double { - let len = if vec1.length() < vec2.length() { vec1.length() } else { vec2.length() } + let len = if vec1.length() < vec2.length() { + vec1.length() + } else { + vec2.length() + } let mut dot = 0.0 let mut norm1 = 0.0 let mut norm2 = 0.0 diff --git a/src/naccess.mbt b/src/naccess.mbt index a26a08ea..3d6e2c2c 100644 --- a/src/naccess.mbt +++ b/src/naccess.mbt @@ -49,8 +49,8 @@ pub fn NaccessAtom::new( res_num~ : Int, chain_id~ : String, abs_asa~ : Double, - rel_asa~ : Double = 0.0, - element~ : String = "", + rel_asa? : Double = 0.0, + element? : String = "", ) -> NaccessAtom { NaccessAtom::{ atom_name, @@ -88,16 +88,16 @@ pub fn NaccessResidue::new( res_name~ : String, res_num~ : Int, chain_id~ : String, - abs_all~ : Double = 0.0, - abs_side_chain~ : Double = 0.0, - abs_main_chain~ : Double = 0.0, - rel_all~ : Double = 0.0, - rel_side_chain~ : Double = 0.0, - rel_main_chain~ : Double = 0.0, - non_polar_abs~ : Double = 0.0, - non_polar_rel~ : Double = 0.0, - polar_abs~ : Double = 0.0, - polar_rel~ : Double = 0.0, + abs_all? : Double = 0.0, + abs_side_chain? : Double = 0.0, + abs_main_chain? : Double = 0.0, + rel_all? : Double = 0.0, + rel_side_chain? : Double = 0.0, + rel_main_chain? : Double = 0.0, + non_polar_abs? : Double = 0.0, + non_polar_rel? : Double = 0.0, + polar_abs? : Double = 0.0, + polar_rel? : Double = 0.0, ) -> NaccessResidue { NaccessResidue::{ res_name, @@ -142,7 +142,10 @@ pub fn NaccessResult::new() -> NaccessResult { ///| /// Add a residue record. -pub fn NaccessResult::add_residue(self : NaccessResult, r : NaccessResidue) -> Unit { +pub fn NaccessResult::add_residue( + self : NaccessResult, + r : NaccessResidue, +) -> Unit { self.residues.push(r) } @@ -154,7 +157,9 @@ pub fn NaccessResult::add_atom(self : NaccessResult, a : NaccessAtom) -> Unit { ///| /// Get all residue records. -pub fn NaccessResult::get_residues(self : NaccessResult) -> Array[NaccessResidue] { +pub fn NaccessResult::get_residues( + self : NaccessResult, +) -> Array[NaccessResidue] { self.residues } @@ -215,22 +220,58 @@ pub fn naccess_parse_rsa(content : String) -> Array[NaccessResidue] { let res_num = parse_int(filtered[2]) let chain_id = filtered[3] let abs_all = parse_double(filtered[4]).unwrap_or(0.0) - let rel_all = if filtered.length() > 5 { parse_double(filtered[5]).unwrap_or(0.0) } else { 0.0 } - let abs_side = if filtered.length() > 6 { parse_double(filtered[6]).unwrap_or(0.0) } else { 0.0 } - let rel_side = if filtered.length() > 7 { parse_double(filtered[7]).unwrap_or(0.0) } else { 0.0 } - let abs_main = if filtered.length() > 8 { parse_double(filtered[8]).unwrap_or(0.0) } else { 0.0 } - let rel_main = if filtered.length() > 9 { parse_double(filtered[9]).unwrap_or(0.0) } else { 0.0 } - let np_abs = if filtered.length() > 10 { parse_double(filtered[10]).unwrap_or(0.0) } else { 0.0 } - let np_rel = if filtered.length() > 11 { parse_double(filtered[11]).unwrap_or(0.0) } else { 0.0 } - let p_abs = if filtered.length() > 12 { parse_double(filtered[12]).unwrap_or(0.0) } else { 0.0 } - let p_rel = if filtered.length() > 13 { parse_double(filtered[13]).unwrap_or(0.0) } else { 0.0 } + let rel_all = if filtered.length() > 5 { + parse_double(filtered[5]).unwrap_or(0.0) + } else { + 0.0 + } + let abs_side = if filtered.length() > 6 { + parse_double(filtered[6]).unwrap_or(0.0) + } else { + 0.0 + } + let rel_side = if filtered.length() > 7 { + parse_double(filtered[7]).unwrap_or(0.0) + } else { + 0.0 + } + let abs_main = if filtered.length() > 8 { + parse_double(filtered[8]).unwrap_or(0.0) + } else { + 0.0 + } + let rel_main = if filtered.length() > 9 { + parse_double(filtered[9]).unwrap_or(0.0) + } else { + 0.0 + } + let np_abs = if filtered.length() > 10 { + parse_double(filtered[10]).unwrap_or(0.0) + } else { + 0.0 + } + let np_rel = if filtered.length() > 11 { + parse_double(filtered[11]).unwrap_or(0.0) + } else { + 0.0 + } + let p_abs = if filtered.length() > 12 { + parse_double(filtered[12]).unwrap_or(0.0) + } else { + 0.0 + } + let p_rel = if filtered.length() > 13 { + parse_double(filtered[13]).unwrap_or(0.0) + } else { + 0.0 + } residues.push( NaccessResidue::new( - res_name=res_name, - res_num=res_num, - chain_id=chain_id, - abs_all=abs_all, - rel_all=rel_all, + res_name~, + res_num~, + chain_id~, + abs_all~, + rel_all~, abs_side_chain=abs_side, rel_side_chain=rel_side, abs_main_chain=abs_main, @@ -303,13 +344,13 @@ pub fn naccess_parse_asa(content : String) -> Array[NaccessAtom] { } atoms.push( NaccessAtom::new( - atom_name=atom_name, - atom_num=atom_num, - res_name=res_name, - res_num=res_num, - chain_id=chain_id, - abs_asa=abs_asa, - rel_asa=rel_asa, + atom_name~, + atom_num~, + res_name~, + res_num~, + chain_id~, + abs_asa~, + rel_asa~, ), ) } @@ -324,7 +365,10 @@ pub fn naccess_parse_asa(content : String) -> Array[NaccessAtom] { ///| /// Parse NACCESS output from both RSA and ASA content. -pub fn naccess_parse(rsa_content : String, asa_content : String) -> NaccessResult { +pub fn naccess_parse( + rsa_content : String, + asa_content : String, +) -> NaccessResult { let result = NaccessResult::new() let residues = naccess_parse_rsa(rsa_content) let atoms = naccess_parse_asa(asa_content) @@ -404,7 +448,9 @@ pub fn naccess_atom_to_asa(a : NaccessAtom) -> String { pub fn naccess_write_rsa(result : NaccessResult) -> String { let sb = StringBuilder::new() sb.write_string("NACCESS Version 2.1\n") - sb.write_string("RES NUM CHN ABS_ALL REL_ALL ABS_SIDE REL_SIDE ABS_MAIN REL_MAIN NP_ABS NP_REL P_ABS P_REL\n") + sb.write_string( + "RES NUM CHN ABS_ALL REL_ALL ABS_SIDE REL_SIDE ABS_MAIN REL_MAIN NP_ABS NP_REL P_ABS P_REL\n", + ) for r in result.residues { sb.write_string(naccess_residue_to_rsa(r) + "\n") } @@ -487,10 +533,7 @@ pub fn naccess_get_chain_residues( ///| /// Count residues by type (exposed vs buried). -pub fn naccess_count_exposed( - result : NaccessResult, - threshold : Double, -) -> Int { +pub fn naccess_count_exposed(result : NaccessResult, threshold : Double) -> Int { let mut count = 0 for r in result.residues { if r.rel_all > threshold { @@ -502,7 +545,10 @@ pub fn naccess_count_exposed( ///| /// Get total ASA for a specific chain. -pub fn naccess_chain_total_asa(result : NaccessResult, chain_id : String) -> Double { +pub fn naccess_chain_total_asa( + result : NaccessResult, + chain_id : String, +) -> Double { let mut total = 0.0 for r in result.residues { if r.chain_id == chain_id { @@ -580,15 +626,29 @@ pub fn naccess_summary(result : NaccessResult) -> String { sb.write_string("NACCESS Result Summary:\n") sb.write_string(" Residues: " + result.get_num_residues().to_string() + "\n") sb.write_string(" Atoms: " + result.get_num_atoms().to_string() + "\n") - sb.write_string(" Total ASA: " + result.total_abs_asa.to_string() + " Ų\n") - sb.write_string(" Mean Rel ASA: " + naccess_mean_rel_asa(result).to_string() + "%\n") - sb.write_string(" Exposed (>20%): " + naccess_count_exposed(result, 20.0).to_string() + "\n") - sb.write_string(" Buried (≤20%): " + (result.get_num_residues() - naccess_count_exposed(result, 20.0)).to_string() + "\n") + sb.write_string( + " Total ASA: " + result.total_abs_asa.to_string() + " Ų\n", + ) + sb.write_string( + " Mean Rel ASA: " + naccess_mean_rel_asa(result).to_string() + "%\n", + ) + sb.write_string( + " Exposed (>20%): " + + naccess_count_exposed(result, 20.0).to_string() + + "\n", + ) + sb.write_string( + " Buried (≤20%): " + + (result.get_num_residues() - naccess_count_exposed(result, 20.0)).to_string() + + "\n", + ) sb.write_string(" Chains: " + result.chain_totals.size().to_string() + "\n") for chain_id in result.chain_totals.keys() { match result.chain_totals.get(chain_id) { Some(v) => - sb.write_string(" Chain " + chain_id + ": " + v.to_string() + " Ų\n") + sb.write_string( + " Chain " + chain_id + ": " + v.to_string() + " Ų\n", + ) None => () } } diff --git a/src/naive_bayes.mbt b/src/naive_bayes.mbt index 36a67704..2dd090f0 100644 --- a/src/naive_bayes.mbt +++ b/src/naive_bayes.mbt @@ -30,31 +30,37 @@ pub fn NaiveBayesClassifier::new() -> NaiveBayesClassifier { alpha: 1.0, vocabulary: [], class_labels: [], - models: Map([], capacity=10) + models: Map([], capacity=10), } } ///| /// Set the k-mer size and return a new classifier instance. -pub fn NaiveBayesClassifier::set_kmer_size(self : NaiveBayesClassifier, val : Int) -> NaiveBayesClassifier { +pub fn NaiveBayesClassifier::set_kmer_size( + self : NaiveBayesClassifier, + val : Int, +) -> NaiveBayesClassifier { NaiveBayesClassifier::{ kmer_size: val, alpha: self.alpha, vocabulary: self.vocabulary, class_labels: self.class_labels, - models: self.models + models: self.models, } } ///| /// Set the Laplace smoothing alpha parameter and return a new classifier instance. -pub fn NaiveBayesClassifier::set_alpha(self : NaiveBayesClassifier, val : Double) -> NaiveBayesClassifier { +pub fn NaiveBayesClassifier::set_alpha( + self : NaiveBayesClassifier, + val : Double, +) -> NaiveBayesClassifier { NaiveBayesClassifier::{ kmer_size: self.kmer_size, alpha: val, vocabulary: self.vocabulary, class_labels: self.class_labels, - models: self.models + models: self.models, } } @@ -62,7 +68,10 @@ pub fn NaiveBayesClassifier::set_alpha(self : NaiveBayesClassifier, val : Double /// Extract k-mers from a sequence using a sliding window of size k. /// Returns a map of k-mer to count. If k > sequence length, returns empty map. /// For protein sequences, any characters are kept. -pub fn naive_bayes_extract_kmers(sequence : String, k : Int) -> Map[String, Int] { +pub fn naive_bayes_extract_kmers( + sequence : String, + k : Int, +) -> Map[String, Int] { let counts : Map[String, Int] = Map([], capacity=100) let n = sequence.length() if k <= 0 || k > n { @@ -88,7 +97,7 @@ pub fn naive_bayes_extract_kmers(sequence : String, k : Int) -> Map[String, Int] pub fn naive_bayes_train( classifier : NaiveBayesClassifier, sequences : Array[String], - labels : Array[String] + labels : Array[String], ) -> NaiveBayesClassifier { let n = sequences.length() if n == 0 || n != labels.length() { @@ -97,7 +106,7 @@ pub fn naive_bayes_train( alpha: classifier.alpha, vocabulary: [], class_labels: [], - models: Map([], capacity=10) + models: Map([], capacity=10), } } @@ -105,7 +114,10 @@ pub fn naive_bayes_train( let class_seq_counts : Map[String, Int] = Map([], capacity=10) let class_total_kmers : Map[String, Int] = Map([], capacity=10) - let class_kmer_counts : Map[String, Map[String, Double]] = Map([], capacity=10) + let class_kmer_counts : Map[String, Map[String, Double]] = Map( + [], + capacity=10, + ) let vocab_set : Map[String, Bool] = Map([], capacity=1000) for idx = 0; idx < n; idx = idx + 1 { @@ -128,7 +140,10 @@ pub fn naive_bayes_train( let kmer_count = kmers.get(kmer).unwrap() total_for_class = total_for_class + kmer_count if counts_for_class.contains(kmer) { - counts_for_class.set(kmer, counts_for_class.get(kmer).unwrap() + kmer_count.to_double()) + counts_for_class.set( + kmer, + counts_for_class.get(kmer).unwrap() + kmer_count.to_double(), + ) } else { counts_for_class.set(kmer, kmer_count.to_double()) } @@ -142,7 +157,10 @@ pub fn naive_bayes_train( let class_labels_arr : Array[String] = class_seq_counts.keys().collect() let vocabulary_arr : Array[String] = vocab_set.keys().collect() - let models_map : Map[String, NBClassModel] = Map([], capacity=class_labels_arr.length()) + let models_map : Map[String, NBClassModel] = Map( + [], + capacity=class_labels_arr.length(), + ) for label in class_labels_arr { let n_seq = class_seq_counts.get(label).unwrap() let prior = n_seq.to_double() / n.to_double() @@ -153,7 +171,7 @@ pub fn naive_bayes_train( n_sequences: n_seq, total_kmers: total_k, kmer_counts: kmer_counts_copy, - class_prior: prior + class_prior: prior, } models_map.set(label, model) } @@ -163,7 +181,7 @@ pub fn naive_bayes_train( alpha: classifier.alpha, vocabulary: vocabulary_arr, class_labels: class_labels_arr, - models: models_map + models: models_map, } } @@ -173,7 +191,7 @@ pub fn naive_bayes_train( /// Uses Laplace smoothing for k-mer probabilities. pub fn naive_bayes_predict_log_probs( classifier : NaiveBayesClassifier, - sequence : String + sequence : String, ) -> Array[(String, Double)] { let result : Array[(String, Double)] = Array::new() let vocab_size = classifier.vocabulary.length().to_double() @@ -197,7 +215,8 @@ pub fn naive_bayes_predict_log_probs( 0.0 } let smoothed_prob = (count_in_model + alpha) / denom - log_prob = log_prob + kmer_count_in_seq.to_double() * @math.ln(smoothed_prob) + log_prob = log_prob + + kmer_count_in_seq.to_double() * @math.ln(smoothed_prob) } result.push((class_label, log_prob)) @@ -211,7 +230,7 @@ pub fn naive_bayes_predict_log_probs( /// Returns (best_label, log_probability) = argmax of predict_log_probs. pub fn naive_bayes_predict( classifier : NaiveBayesClassifier, - sequence : String + sequence : String, ) -> (String, Double) { let log_probs = naive_bayes_predict_log_probs(classifier, sequence) if log_probs.length() == 0 { @@ -233,7 +252,7 @@ pub fn naive_bayes_predict( /// Returns array of (class_label, probability) where probabilities sum to ~1.0. pub fn naive_bayes_predict_proba( classifier : NaiveBayesClassifier, - sequence : String + sequence : String, ) -> Array[(String, Double)] { let log_probs = naive_bayes_predict_log_probs(classifier, sequence) let result : Array[(String, Double)] = Array::new() @@ -257,7 +276,11 @@ pub fn naive_bayes_predict_proba( } for i = 0; i < log_probs.length(); i = i + 1 { - let prob = if sum == 0.0 { 1.0 / log_probs.length().to_double() } else { exps[i] / sum } + let prob = if sum == 0.0 { + 1.0 / log_probs.length().to_double() + } else { + exps[i] / sum + } result.push((log_probs[i].0, prob)) } @@ -269,7 +292,7 @@ pub fn naive_bayes_predict_proba( pub fn naive_bayes_top_k( classifier : NaiveBayesClassifier, sequence : String, - k : Int + k : Int, ) -> Array[(String, Double)] { let probs = naive_bayes_predict_proba(classifier, sequence) @@ -303,7 +326,7 @@ pub fn naive_bayes_top_k( pub fn naive_bayes_accuracy( classifier : NaiveBayesClassifier, sequences : Array[String], - true_labels : Array[String] + true_labels : Array[String], ) -> Double { let n = sequences.length() if n == 0 || n != true_labels.length() { @@ -325,24 +348,12 @@ pub fn naive_bayes_accuracy( /// 4 sequences with label "GC_rich" (high G/C content). pub fn naive_bayes_sample_data() -> (Array[String], Array[String]) { let sequences : Array[String] = [ - "ATATATATATATATATATAT", - "AATTAAAATTTTAAATTTTA", - "TATATAAATTATATTAATTT", - "ATTTAAATAAATTTTAAAAT", - "GCGCGCGCGCGCGCGCGCGC", - "GGCCGGCCCGGGCCCGGCCC", - "CGGCCGGGCCCCGGGCCTGG", - "GCGCCGCGGGGCCCGGCCGC" + "ATATATATATATATATATAT", "AATTAAAATTTTAAATTTTA", "TATATAAATTATATTAATTT", "ATTTAAATAAATTTTAAAAT", + "GCGCGCGCGCGCGCGCGCGC", "GGCCGGCCCGGGCCCGGCCC", "CGGCCGGGCCCCGGGCCTGG", "GCGCCGCGGGGCCCGGCCGC", ] let labels : Array[String] = [ - "AT_rich", - "AT_rich", - "AT_rich", - "AT_rich", - "GC_rich", - "GC_rich", + "AT_rich", "AT_rich", "AT_rich", "AT_rich", "GC_rich", "GC_rich", "GC_rich", "GC_rich", - "GC_rich" ] (sequences, labels) } diff --git a/src/nanostring.mbt b/src/nanostring.mbt index f04a4db2..d6c12db7 100644 --- a/src/nanostring.mbt +++ b/src/nanostring.mbt @@ -52,12 +52,8 @@ fn ns_std(arr : Array[Double], mean : Double) -> Double { /// Lanczos approximation for ln(gamma(x)). fn ns_lgamma(x : Double) -> Double { let cof = [ - 76.18009172947146, - -86.50532032941677, - 24.01409824083091, - -1.231739572450155, - 0.001208650973866179, - -0.000005395239384953, + 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, + 0.001208650973866179, -0.000005395239384953, ] let mut x1 = x let mut tmp = x1 + 5.5 @@ -196,18 +192,8 @@ fn ns_linear_regression( let intercept = (sum_y - slope * sum_x) / nd let ss_tot = sum_yy - sum_y * sum_y / nd let ss_res = sum_yy - intercept * sum_y - slope * sum_xy - let r_sq = if ss_tot == 0.0 { - 0.0 - } else { - 1.0 - ss_res / ss_tot - } - let r_clamped = if r_sq < 0.0 { - 0.0 - } else if r_sq > 1.0 { - 1.0 - } else { - r_sq - } + let r_sq = if ss_tot == 0.0 { 0.0 } else { 1.0 - ss_res / ss_tot } + let r_clamped = if r_sq < 0.0 { 0.0 } else if r_sq > 1.0 { 1.0 } else { r_sq } (slope, intercept, r_clamped) } @@ -318,9 +304,7 @@ pub struct NsNanostringData { ///| /// Construct an empty NsNanostringData with the given endogenous gene names. -pub fn NsNanostringData::new( - gene_names : Array[String], -) -> NsNanostringData { +pub fn NsNanostringData::new(gene_names : Array[String]) -> NsNanostringData { NsNanostringData::{ samples: Array::new(), gene_names, @@ -381,12 +365,7 @@ pub fn NsNormResult::new( normalized_counts : Array[Double], method : String, ) -> NsNormResult { - NsNormResult::{ - sample_id, - norm_factors, - normalized_counts, - method, - } + NsNormResult::{ sample_id, norm_factors, normalized_counts, method } } ///| @@ -506,9 +485,7 @@ pub fn ns_log2_counts(counts : Array[Double]) -> Array[Double] { /// Positive-control normalization. /// Each sample is scaled so that the geometric mean of its positive controls /// matches the geometric mean of those means across all samples. -pub fn ns_positive_control_norm( - data : NsNanostringData, -) -> Array[NsNormResult] { +pub fn ns_positive_control_norm(data : NsNanostringData) -> Array[NsNormResult] { let samples = data.samples() let n_genes = data.n_genes() let sample_geo_means : Array[Double] = Array::new() @@ -524,11 +501,7 @@ pub fn ns_positive_control_norm( for i in 0.. 0.0 { - target / gm - } else { - 1.0 - } + let factor = if gm > 0.0 { target / gm } else { 1.0 } let norm_counts : Array[Double] = Array::new() let endo = sample.endogenous() for g in 0.. Array[NsNormResult] { +pub fn ns_negative_control_norm(data : NsNanostringData) -> Array[NsNormResult] { let samples = data.samples() let n_genes = data.n_genes() let results : Array[NsNormResult] = Array::new() @@ -589,9 +565,7 @@ pub fn ns_negative_control_norm( /// Housekeeping-gene normalization. /// Each sample is scaled so that the geometric mean of its housekeeping gene /// counts matches the geometric mean of those means across all samples. -pub fn ns_housekeeping_norm( - data : NsNanostringData, -) -> Array[NsNormResult] { +pub fn ns_housekeeping_norm(data : NsNanostringData) -> Array[NsNormResult] { let samples = data.samples() let n_genes = data.n_genes() let sample_geo_means : Array[Double] = Array::new() @@ -607,11 +581,7 @@ pub fn ns_housekeeping_norm( for i in 0.. 0.0 { - target / gm - } else { - 1.0 - } + let factor = if gm > 0.0 { target / gm } else { 1.0 } let norm_counts : Array[Double] = Array::new() let endo = sample.endogenous() for g in 0.. Array[NsNormResult] { 1.0 } let gm = hk_geo_means[i] - let hk_factor = if gm > 0.0 { - target / gm - } else { - 1.0 - } + let hk_factor = if gm > 0.0 { target / gm } else { 1.0 } let norm_counts : Array[Double] = Array::new() let pos_counts = pos_results[i].normalized_counts() for g in 0.. Array[Bool] { for c in pos { total = total + c } - let avg = if pos.length() > 0 { - total / pos.length() - } else { - 0 - } + let avg = if pos.length() > 0 { total / pos.length() } else { 0 } results.push(avg >= threshold) } results @@ -720,9 +682,7 @@ pub fn ns_imaging_qc(data : NsNanostringData, threshold : Int) -> Array[Bool] { /// Positive control linearity QC. /// Fits a linear model of log2(positive control counts) against log2 of the /// known dilution-series concentrations. Returns (r_squared, slope). -pub fn ns_pos_linearity_qc( - data : NsNanostringData, -) -> (Double, Double) { +pub fn ns_pos_linearity_qc(data : NsNanostringData) -> (Double, Double) { // Standard NanoString positive control dilution series (fM). let concentrations = [128.0, 32.0, 8.0, 2.0, 0.5, 0.125] let log_conc : Array[Double] = Array::new() @@ -799,10 +759,7 @@ pub fn ns_qc_summary(data : NsNanostringData) -> String { ///| /// Welch's two-sample t-test. Returns (t_statistic, p_value). -pub fn ns_t_test( - g1 : Array[Double], - g2 : Array[Double], -) -> (Double, Double) { +pub fn ns_t_test(g1 : Array[Double], g2 : Array[Double]) -> (Double, Double) { let n1 = g1.length() let n2 = g2.length() if n1 < 2 || n2 < 2 { @@ -824,19 +781,9 @@ pub fn ns_t_test( let num = (term1 + term2) * (term1 + term2) let den = term1 * term1 / (n1 - 1).to_double() + term2 * term2 / (n2 - 1).to_double() - let df = if den > 0.0 { - num / den - } else { - (n1 + n2 - 2).to_double() - } + let df = if den > 0.0 { num / den } else { (n1 + n2 - 2).to_double() } let p = 2.0 * (1.0 - ns_t_cdf(t.abs(), df)) - let pc = if p < 0.0 { - 0.0 - } else if p > 1.0 { - 1.0 - } else { - p - } + let pc = if p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p } (t, pc) } @@ -876,11 +823,7 @@ pub fn ns_bh_correct(p_values : Array[Double]) -> Array[Double] { if val < min_adj { min_adj = val } - adj[indices[i]] = if min_adj > 1.0 { - 1.0 - } else { - min_adj - } + adj[indices[i]] = if min_adj > 1.0 { 1.0 } else { min_adj } i = i - 1 } adj @@ -1009,26 +952,9 @@ pub fn ns_de_summary(results : Array[NsDeResult]) -> String { /// The first positive control indices double as housekeeping gene positions. pub fn ns_sample_data() -> NsNanostringData { let gene_names = [ - "GENE01", - "GENE02", - "GENE03", - "GENE04", - "GENE05", - "GENE06", - "GENE07", - "GENE08", - "GENE09", - "GENE10", - "GENE11", - "GENE12", - "GENE13", - "GENE14", - "GENE15", - "GENE16", - "GENE17", - "GENE18", - "GENE19", - "GENE20", + "GENE01", "GENE02", "GENE03", "GENE04", "GENE05", "GENE06", "GENE07", "GENE08", + "GENE09", "GENE10", "GENE11", "GENE12", "GENE13", "GENE14", "GENE15", "GENE16", + "GENE17", "GENE18", "GENE19", "GENE20", ] let data = NsNanostringData::new(gene_names) let pos_indices = [20, 21, 22, 23, 24, 25] @@ -1087,14 +1013,16 @@ pub fn ns_sample_data() -> NsNanostringData { for v in neg_control_profiles[s] { raw.push(v) } - data.add_sample(NsSample::new( - sample_ids[s], - raw, - pos_indices, - neg_indices, - hk_indices, - endo_indices, - )) + data.add_sample( + NsSample::new( + sample_ids[s], + raw, + pos_indices, + neg_indices, + hk_indices, + endo_indices, + ), + ) } data } diff --git a/src/neural_network.mbt b/src/neural_network.mbt index 06abb06e..b180e9c0 100644 --- a/src/neural_network.mbt +++ b/src/neural_network.mbt @@ -103,7 +103,7 @@ pub struct NeuralNetwork { pub fn NeuralNetwork::new( n_input : Int, n_hidden : Int, - n_output : Int + n_output : Int, ) -> NeuralNetwork { let hidden = NnLayer::new(n_input, n_hidden) let output = NnLayer::new(n_hidden, n_output) @@ -133,7 +133,7 @@ pub fn NeuralNetwork::new( /// Set the learning rate. pub fn NeuralNetwork::set_learning_rate( self : NeuralNetwork, - lr : Double + lr : Double, ) -> NeuralNetwork { { ..self, learning_rate: lr } } @@ -142,7 +142,7 @@ pub fn NeuralNetwork::set_learning_rate( /// Set the momentum coefficient. pub fn NeuralNetwork::set_momentum( self : NeuralNetwork, - m : Double + m : Double, ) -> NeuralNetwork { { ..self, momentum: m } } @@ -239,7 +239,7 @@ fn nn_layer_forward(layer : NnLayer, input : Array[Double]) -> Array[Double] { /// Forward pass through the entire network. Returns the output activations. pub fn nn_forward( network : NeuralNetwork, - input : Array[Double] + input : Array[Double], ) -> Array[Double] { let hidden_out = nn_layer_forward(network.hidden_layer, input) nn_layer_forward(network.output_layer, hidden_out) @@ -267,7 +267,7 @@ pub fn nn_predict(network : NeuralNetwork, input : Array[Double]) -> Int { pub fn nn_train_example( network : NeuralNetwork, input : Array[Double], - target : Array[Double] + target : Array[Double], ) -> Double { // Forward pass. let hidden_out = nn_layer_forward(network.hidden_layer, input) @@ -296,10 +296,12 @@ pub fn nn_train_example( for j in 0.. Double { let n = inputs.length() let mut final_error = 0.0 for _ in 0.. (Array[Array[Double]], Array[Array[Double]]) { - let inputs = [ - [0.0, 0.0], - [0.0, 1.0], - [1.0, 0.0], - [1.0, 1.0], - ] + let inputs = [[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]] let targets = [[0.0], [1.0], [1.0], [0.0]] (inputs, targets) } diff --git a/src/nib_io.mbt b/src/nib_io.mbt index a5402b5a..ae7a20ec 100644 --- a/src/nib_io.mbt +++ b/src/nib_io.mbt @@ -109,7 +109,7 @@ pub fn nib_encode(sequence : String) -> Array[Int] { let code_ci = nib_base_to_code_ci(sequence[i].unsafe_to_char()) let code = if code_ci < 0 { 0 } else { code_ci } let byte_idx = i / 4 - let shift = 6 - (i % 4) * 2 + let shift = 6 - i % 4 * 2 packed[byte_idx] = packed[byte_idx] | (code << shift) } packed @@ -123,7 +123,7 @@ pub fn nib_decode(packed : Array[Int], length : Int) -> String { let sb = StringBuilder::new() for i in 0..> shift) & 3 } else { @@ -275,7 +275,7 @@ pub fn nib_get_base(nib : NibSequence, index : Int) -> String { return "" } let byte_idx = index / 4 - let shift = 6 - (index % 4) * 2 + let shift = 6 - index % 4 * 2 let code = if byte_idx < nib.packed_data.length() { (nib.packed_data[byte_idx] >> shift) & 3 } else { @@ -304,7 +304,7 @@ pub fn nib_subsequence(nib : NibSequence, start : Int, length : Int) -> String { for i in 0..> shift) & 3 } else { @@ -356,7 +356,7 @@ pub fn nib_gc_content(nib : NibSequence) -> Double { let mut gc = 0 for i in 0..> shift) & 3 } else { @@ -403,12 +403,7 @@ pub fn nib_from_hex(seq_id : String, hex : String, length : Int) -> NibSequence packed.push(high * 16 + low) i = i + 2 } - NibSequence::{ - seq_id, - length, - packed_data: packed, - is_uppercase: true, - } + NibSequence::{ seq_id, length, packed_data: packed, is_uppercase: true } } // ============================================================================ diff --git a/src/nmr.mbt b/src/nmr.mbt index 73c5b62d..0ac543d9 100644 --- a/src/nmr.mbt +++ b/src/nmr.mbt @@ -152,12 +152,12 @@ pub fn parse_noe_restraints(text : String) -> Array[NoeRestraint] { restraints.push( NoeRestraint::new( restraint_id=id, - atom1=atom1, - atom2=atom2, + atom1~, + atom2~, lower_bound=lower, upper_bound=upper, - observed=observed, - energy=energy, + observed~, + energy~, ), ) } @@ -193,7 +193,7 @@ pub fn format_noe_restraints(restraints : Array[NoeRestraint]) -> String { ///| /// Summarize NOE restraint statistics: count, number violated, max violation. pub fn noe_restraint_summary( - restraints : Array[NoeRestraint] + restraints : Array[NoeRestraint], ) -> NmrRestraintSummary { let total = restraints.length() let mut violated = 0 @@ -316,8 +316,8 @@ pub fn parse_dihedral_restraints(text : String) -> Array[DihedralRestraint] { residue=res, lower_bound=lower, upper_bound=upper, - observed=observed, - energy=energy, + observed~, + energy~, ), ) } @@ -361,9 +361,9 @@ pub struct ChemicalShiftTable { ///| /// Construct a ChemicalShiftTable. pub fn ChemicalShiftTable::new( - shifts~ : Array[ChemicalShift] + shifts~ : Array[ChemicalShift], ) -> ChemicalShiftTable { - ChemicalShiftTable::{ shifts } + ChemicalShiftTable::{ shifts, } } ///| @@ -461,7 +461,7 @@ pub fn parse_chemical_shifts(text : String) -> ChemicalShiftTable { } shifts.push( ChemicalShift::new( - id=id, + id~, residue=res, atom_name=atom, element=elem, @@ -470,7 +470,7 @@ pub fn parse_chemical_shifts(text : String) -> ChemicalShiftTable { ), ) } - ChemicalShiftTable::new(shifts=shifts) + ChemicalShiftTable::new(shifts~) } ///| @@ -527,14 +527,7 @@ pub fn NmrPeak::new( volume~ : Double?, merity~ : Double?, ) -> NmrPeak { - NmrPeak::{ - peak_id, - dimensions, - chemical_shifts, - intensities, - volume, - merity, - } + NmrPeak::{ peak_id, dimensions, chemical_shifts, intensities, volume, merity } } ///| @@ -661,7 +654,8 @@ pub fn parse_peak_list(text : String) -> PeakList { } continue } - if fields[0] == "id" || (fields[0].length() >= 2 && fields[0][0:2].to_owned() == "id") { + if fields[0] == "id" || + (fields[0].length() >= 2 && fields[0][0:2].to_owned() == "id") { // Header row describing columns; count dimension groups. // Skip detection: leave n_dim to be inferred from data. continue @@ -714,15 +708,15 @@ pub fn parse_peak_list(text : String) -> PeakList { peaks.push( NmrPeak::new( peak_id=id, - dimensions=dimensions, + dimensions~, chemical_shifts=shifts, - intensities=intensities, - volume=volume, + intensities~, + volume~, merity=merit, ), ) } - PeakList::new(label=label, peaks=peaks, n_dim=n_dim) + PeakList::new(label~, peaks~, n_dim~) } ///| @@ -867,36 +861,32 @@ pub fn nmr_sample_chemical_shifts() -> ChemicalShiftTable { ///| /// Sample peak list (2D HSQC) for testing/demos. pub fn nmr_sample_peak_list() -> PeakList { - PeakList::new( - label="15N-HSQC", - n_dim=2, - peaks=[ - NmrPeak::new( - peak_id=1, - dimensions=["15.HN", "15.N"], - chemical_shifts=[8.34, 118.5], - intensities=[1.0e6, 1.0e6], - volume=Some(2.3e6), - merity=Some(0.95), - ), - NmrPeak::new( - peak_id=2, - dimensions=["16.HN", "16.N"], - chemical_shifts=[8.21, 121.0], - intensities=[8.0e5, 8.0e5], - volume=Some(1.7e6), - merity=Some(0.91), - ), - NmrPeak::new( - peak_id=3, - dimensions=["20.HN", "20.N"], - chemical_shifts=[7.95, 110.2], - intensities=[1.2e6, 1.2e6], - volume=Some(2.8e6), - merity=Some(0.98), - ), - ], - ) + PeakList::new(label="15N-HSQC", n_dim=2, peaks=[ + NmrPeak::new( + peak_id=1, + dimensions=["15.HN", "15.N"], + chemical_shifts=[8.34, 118.5], + intensities=[1.0e6, 1.0e6], + volume=Some(2.3e6), + merity=Some(0.95), + ), + NmrPeak::new( + peak_id=2, + dimensions=["16.HN", "16.N"], + chemical_shifts=[8.21, 121.0], + intensities=[8.0e5, 8.0e5], + volume=Some(1.7e6), + merity=Some(0.91), + ), + NmrPeak::new( + peak_id=3, + dimensions=["20.HN", "20.N"], + chemical_shifts=[7.95, 110.2], + intensities=[1.2e6, 1.2e6], + volume=Some(2.8e6), + merity=Some(0.98), + ), + ]) } ///| @@ -946,7 +936,8 @@ fn nmr_split_lines(text : String) -> Array[String] { let c = text[i:i + 1].to_owned() if c == "\n" { // Strip trailing \r if present. - if cur.length() > 0 && cur[cur.length() - 1:cur.length()].to_owned() == "\r" { + if cur.length() > 0 && + cur[cur.length() - 1:cur.length()].to_owned() == "\r" { cur = cur[0:cur.length() - 1].to_owned() } out.push(cur) diff --git a/src/noiseq.mbt b/src/noiseq.mbt index 390fd82d..0c8c1fc4 100644 --- a/src/noiseq.mbt +++ b/src/noiseq.mbt @@ -122,13 +122,20 @@ pub fn NOISeqMethod::to_string(self : NOISeqMethod) -> String { ///| /// Create a NOISeqSample. -pub fn NOISeqSample::new(sample_id : String, condition : String) -> NOISeqSample { +pub fn NOISeqSample::new( + sample_id : String, + condition : String, +) -> NOISeqSample { NOISeqSample::{ sample_id, condition, counts: Map::new() } } ///| /// Set gene count for a sample. -pub fn NOISeqSample::set_count(self : NOISeqSample, gene_id : String, count : Double) -> Unit { +pub fn NOISeqSample::set_count( + self : NOISeqSample, + gene_id : String, + count : Double, +) -> Unit { self.counts.set(gene_id, count) } @@ -217,7 +224,11 @@ pub fn noiseq_normalize( let lib_size = sample.library_size() // Compute simple scaling factor - let scale = if lib_size > 0.0 && ref_lib > 0.0 { ref_lib / lib_size } else { 1.0 } + let scale = if lib_size > 0.0 && ref_lib > 0.0 { + ref_lib / lib_size + } else { + 1.0 + } let gid_list = sample.counts.keys().collect() let mut gi = 0 @@ -268,14 +279,18 @@ pub fn noiseq_normalize( si = si + 1 } - let uq_pos = (slen * 3) / 4 + let uq_pos = slen * 3 / 4 let upper_quartile = if slen > 0 && uq_pos < slen { counts[uq_pos] } else { 1.0 } - let scale = if upper_quartile > 0.0 { 1.0e6 / upper_quartile } else { 1.0 } + let scale = if upper_quartile > 0.0 { + 1.0e6 / upper_quartile + } else { + 1.0 + } let gid_list = sample.counts.keys().collect() let mut gi = 0 @@ -470,7 +485,11 @@ fn noiseq_mean_abs_diff(values : Array[Double]) -> Double { /// Compute probability from noise distribution. /// In NOISeq, this is the probability that a random gene from the noise /// distribution has a (M, D) value more extreme than the observed. -fn noiseq_compute_prob(m : Double, d : Double, ds_method : NOISeqMethod) -> Double { +fn noiseq_compute_prob( + m : Double, + d : Double, + ds_method : NOISeqMethod, +) -> Double { // The magnitude of the (M, D) vector indicates how far the gene is from the noise let magnitude = (m * m + d * d).sqrt() @@ -483,13 +502,21 @@ fn noiseq_compute_prob(m : Double, d : Double, ds_method : NOISeqMethod) -> Doub // probability ≈ 1 - exp(-magnitude / sigma) let sigma = 1.0 let prob = 1.0 - @math.exp(-magnitude / sigma) - if prob > 1.0 { 1.0 } else { prob } + if prob > 1.0 { + 1.0 + } else { + prob + } } NOISeqMethod::NOISeqSim => { // NOISeqSim is less conservative let sigma = 0.8 let prob = 1.0 - @math.exp(-magnitude / sigma) - if prob > 1.0 { 1.0 } else { prob } + if prob > 1.0 { + 1.0 + } else { + prob + } } } } @@ -502,7 +529,9 @@ pub fn NOISeqResults::get_n_results(self : NOISeqResults) -> Int { ///| /// Get significant results. -pub fn NOISeqResults::get_significant(self : NOISeqResults) -> Array[NOISeqResult] { +pub fn NOISeqResults::get_significant( + self : NOISeqResults, +) -> Array[NOISeqResult] { let sig : Array[NOISeqResult] = Array::new() let mut i = 0 while i < self.results.length() { @@ -516,7 +545,10 @@ pub fn NOISeqResults::get_significant(self : NOISeqResults) -> Array[NOISeqResul ///| /// Get top N genes by probability. -pub fn NOISeqResults::get_top_genes(self : NOISeqResults, n : Int) -> Array[NOISeqResult] { +pub fn NOISeqResults::get_top_genes( + self : NOISeqResults, + n : Int, +) -> Array[NOISeqResult] { let result : Array[NOISeqResult] = Array::new() let take = if n < self.results.length() { n } else { self.results.length() } let mut i = 0 @@ -529,7 +561,9 @@ pub fn NOISeqResults::get_top_genes(self : NOISeqResults, n : Int) -> Array[NOIS ///| /// Get up-regulated genes. -pub fn NOISeqResults::get_up_regulated(self : NOISeqResults) -> Array[NOISeqResult] { +pub fn NOISeqResults::get_up_regulated( + self : NOISeqResults, +) -> Array[NOISeqResult] { let result : Array[NOISeqResult] = Array::new() let mut i = 0 while i < self.results.length() { @@ -543,7 +577,9 @@ pub fn NOISeqResults::get_up_regulated(self : NOISeqResults) -> Array[NOISeqResu ///| /// Get down-regulated genes. -pub fn NOISeqResults::get_down_regulated(self : NOISeqResults) -> Array[NOISeqResult] { +pub fn NOISeqResults::get_down_regulated( + self : NOISeqResults, +) -> Array[NOISeqResult] { let result : Array[NOISeqResult] = Array::new() let mut i = 0 while i < self.results.length() { @@ -562,7 +598,12 @@ pub fn NOISeqResults::summary(self : NOISeqResults) -> String { s = s + "Method: " + self.ds_method.to_string() + "\n" s = s + "Normalization: " + self.norm_method.to_string() + "\n" s = s + "Genes tested: " + self.n_genes.to_string() + "\n" - s = s + "Significant (prob >= " + self.prob_threshold.to_string() + "): " + self.n_sig.to_string() + "\n" + s = s + + "Significant (prob >= " + + self.prob_threshold.to_string() + + "): " + + self.n_sig.to_string() + + "\n" let n_up = self.get_up_regulated().length() let n_down = self.get_down_regulated().length() s = s + " Up-regulated: " + n_up.to_string() + "\n" @@ -608,7 +649,9 @@ pub fn noiseq_qc(samples : Array[NOISeqSample]) -> NOISeqQC { let mut mi = 0 while mi < lib_sizes.length() { let diff = (lib_sizes[mi] - mean_lib).abs() / (mean_lib + 1.0e-10) - if diff > max_d { max_d = diff } + if diff > max_d { + max_d = diff + } mi = mi + 1 } max_d @@ -627,7 +670,10 @@ pub fn noiseq_qc(samples : Array[NOISeqSample]) -> NOISeqQC { ///| /// Create sample data for testing. pub fn noiseq_sample_data() -> (Array[NOISeqSample], Array[NOISeqSample]) { - let genes = ["Gene1", "Gene2", "Gene3", "Gene4", "Gene5", "Gene6", "Gene7", "Gene8", "Gene9", "Gene10"] + let genes = [ + "Gene1", "Gene2", "Gene3", "Gene4", "Gene5", "Gene6", "Gene7", "Gene8", "Gene9", + "Gene10", + ] // Control samples let ctrl_samples : Array[NOISeqSample] = Array::new() diff --git a/src/nucle_r.mbt b/src/nucle_r.mbt index 05763f00..dfcc5634 100644 --- a/src/nucle_r.mbt +++ b/src/nucle_r.mbt @@ -3,6 +3,7 @@ /// Provides functions for nucleosome positioning analysis from sequencing data. /// Supports nucleosome calling, occupancy calculation, and dynamic nucleosome analysis. +///| /// Nucleosome positioning result pub struct NucPosition { /// Chromosome @@ -23,53 +24,79 @@ pub struct NucPosition { well_positioned : Bool } +///| /// Create new nucleosome position -pub fn NucPosition::new(chrom : String, start : Int, end : Int, center : Double, - width : Double, occupancy : Double, - positioning_score : Double, well_positioned : Bool) -> NucPosition { - NucPosition::{ chrom, start, end, center, width, occupancy, positioning_score, well_positioned } +pub fn NucPosition::new( + chrom : String, + start : Int, + end : Int, + center : Double, + width : Double, + occupancy : Double, + positioning_score : Double, + well_positioned : Bool, +) -> NucPosition { + NucPosition::{ + chrom, + start, + end, + center, + width, + occupancy, + positioning_score, + well_positioned, + } } +///| /// Get chromosome pub fn NucPosition::nuc_chrom(self : NucPosition) -> String { self.chrom } +///| /// Get start position pub fn NucPosition::nuc_start(self : NucPosition) -> Int { self.start } +///| /// Get end position pub fn NucPosition::nuc_end(self : NucPosition) -> Int { self.end } +///| /// Get center position pub fn NucPosition::nuc_center(self : NucPosition) -> Double { self.center } +///| /// Get width pub fn NucPosition::nuc_width(self : NucPosition) -> Double { self.width } +///| /// Get occupancy pub fn NucPosition::nuc_occupancy(self : NucPosition) -> Double { self.occupancy } +///| /// Get positioning score pub fn NucPosition::nuc_positioning_score(self : NucPosition) -> Double { self.positioning_score } +///| /// Check if well-positioned pub fn NucPosition::nuc_is_well_positioned(self : NucPosition) -> Bool { self.well_positioned } +///| /// Nucleosome call result pub struct NucCallResult { /// Nucleosome positions @@ -84,40 +111,60 @@ pub struct NucCallResult { frac_well_positioned : Double } +///| /// Create new call result -pub fn NucCallResult::new(nucleosomes : Array[NucPosition], n_nucleosomes : Int, - mean_spacing : Double, mean_occupancy : Double, - frac_well_positioned : Double) -> NucCallResult { - NucCallResult::{ nucleosomes, n_nucleosomes, mean_spacing, mean_occupancy, frac_well_positioned } +pub fn NucCallResult::new( + nucleosomes : Array[NucPosition], + n_nucleosomes : Int, + mean_spacing : Double, + mean_occupancy : Double, + frac_well_positioned : Double, +) -> NucCallResult { + NucCallResult::{ + nucleosomes, + n_nucleosomes, + mean_spacing, + mean_occupancy, + frac_well_positioned, + } } +///| /// Get number of nucleosomes pub fn NucCallResult::nuc_n_count(self : NucCallResult) -> Int { self.n_nucleosomes } +///| /// Get nucleosome at index pub fn NucCallResult::nuc_get(self : NucCallResult, idx : Int) -> NucPosition { self.nucleosomes[idx] } +///| /// Get mean spacing pub fn NucCallResult::nuc_mean_spacing(self : NucCallResult) -> Double { self.mean_spacing } +///| /// Get mean occupancy pub fn NucCallResult::nuc_mean_occupancy(self : NucCallResult) -> Double { self.mean_occupancy } +///| /// Get fraction well-positioned pub fn NucCallResult::nuc_frac_well_positioned(self : NucCallResult) -> Double { self.frac_well_positioned } +///| /// Filter by occupancy threshold -pub fn NucCallResult::nuc_filter_by_occupancy(self : NucCallResult, threshold : Double) -> NucCallResult { +pub fn NucCallResult::nuc_filter_by_occupancy( + self : NucCallResult, + threshold : Double, +) -> NucCallResult { let filtered : Array[NucPosition] = Array::new() let mut i = 0 @@ -128,10 +175,16 @@ pub fn NucCallResult::nuc_filter_by_occupancy(self : NucCallResult, threshold : i = i + 1 } - NucCallResult::new(filtered, filtered.length(), self.mean_spacing, - self.mean_occupancy, self.frac_well_positioned) + NucCallResult::new( + filtered, + filtered.length(), + self.mean_spacing, + self.mean_occupancy, + self.frac_well_positioned, + ) } +///| /// Dynamic nucleosome result for comparison pub struct NucDynamicResult { /// Shared nucleosomes @@ -146,37 +199,49 @@ pub struct NucDynamicResult { direction : Int } +///| /// Create new dynamic result -pub fn NucDynamicResult::new(shared : Array[NucPosition], gained : Array[NucPosition], - lost : Array[NucPosition], frac_changed : Double, direction : Int) -> NucDynamicResult { +pub fn NucDynamicResult::new( + shared : Array[NucPosition], + gained : Array[NucPosition], + lost : Array[NucPosition], + frac_changed : Double, + direction : Int, +) -> NucDynamicResult { NucDynamicResult::{ shared, gained, lost, frac_changed, direction } } +///| /// Get number of shared nucleosomes pub fn NucDynamicResult::nuc_n_shared(self : NucDynamicResult) -> Int { self.shared.length() } +///| /// Get number of gained nucleosomes pub fn NucDynamicResult::nuc_n_gained(self : NucDynamicResult) -> Int { self.gained.length() } +///| /// Get number of lost nucleosomes pub fn NucDynamicResult::nuc_n_lost(self : NucDynamicResult) -> Int { self.lost.length() } +///| /// Get fraction changed pub fn NucDynamicResult::nuc_frac_changed(self : NucDynamicResult) -> Double { self.frac_changed } +///| /// Get direction pub fn NucDynamicResult::nuc_direction(self : NucDynamicResult) -> Int { self.direction } +///| /// Smoothing methods pub enum NucSmoothMethod { /// Moving average @@ -187,6 +252,7 @@ pub enum NucSmoothMethod { SavitzkyGolay } +///| /// Nucleosome calling parameters pub struct NucCallParams { /// Smoothing window size @@ -203,32 +269,84 @@ pub struct NucCallParams { width_threshold : Double } +///| /// Create default parameters pub fn NucCallParams::new() -> NucCallParams { - NucCallParams::{ smooth_window: 100, peak_threshold: 0.5, min_distance: 100, max_distance: 300, - occupancy_threshold: 0.3, width_threshold: 60.0 } + NucCallParams::{ + smooth_window: 100, + peak_threshold: 0.5, + min_distance: 100, + max_distance: 300, + occupancy_threshold: 0.3, + width_threshold: 60.0, + } } +///| /// Set smoothing window -pub fn NucCallParams::nuc_set_smooth_window(self : NucCallParams, window : Int) -> NucCallParams { - NucCallParams::{ smooth_window: window, peak_threshold: self.peak_threshold, min_distance: self.min_distance, max_distance: self.max_distance, occupancy_threshold: self.occupancy_threshold, width_threshold: self.width_threshold } +pub fn NucCallParams::nuc_set_smooth_window( + self : NucCallParams, + window : Int, +) -> NucCallParams { + NucCallParams::{ + smooth_window: window, + peak_threshold: self.peak_threshold, + min_distance: self.min_distance, + max_distance: self.max_distance, + occupancy_threshold: self.occupancy_threshold, + width_threshold: self.width_threshold, + } } +///| /// Set peak threshold -pub fn NucCallParams::nuc_set_peak_threshold(self : NucCallParams, threshold : Double) -> NucCallParams { - NucCallParams::{ smooth_window: self.smooth_window, peak_threshold: threshold, min_distance: self.min_distance, max_distance: self.max_distance, occupancy_threshold: self.occupancy_threshold, width_threshold: self.width_threshold } +pub fn NucCallParams::nuc_set_peak_threshold( + self : NucCallParams, + threshold : Double, +) -> NucCallParams { + NucCallParams::{ + smooth_window: self.smooth_window, + peak_threshold: threshold, + min_distance: self.min_distance, + max_distance: self.max_distance, + occupancy_threshold: self.occupancy_threshold, + width_threshold: self.width_threshold, + } } +///| /// Set minimum distance -pub fn NucCallParams::nuc_set_min_distance(self : NucCallParams, dist : Int) -> NucCallParams { - NucCallParams::{ smooth_window: self.smooth_window, peak_threshold: self.peak_threshold, min_distance: dist, max_distance: self.max_distance, occupancy_threshold: self.occupancy_threshold, width_threshold: self.width_threshold } +pub fn NucCallParams::nuc_set_min_distance( + self : NucCallParams, + dist : Int, +) -> NucCallParams { + NucCallParams::{ + smooth_window: self.smooth_window, + peak_threshold: self.peak_threshold, + min_distance: dist, + max_distance: self.max_distance, + occupancy_threshold: self.occupancy_threshold, + width_threshold: self.width_threshold, + } } +///| /// Set occupancy threshold -pub fn NucCallParams::nuc_set_occupancy_threshold(self : NucCallParams, threshold : Double) -> NucCallParams { - NucCallParams::{ smooth_window: self.smooth_window, peak_threshold: self.peak_threshold, min_distance: self.min_distance, max_distance: self.max_distance, occupancy_threshold: threshold, width_threshold: self.width_threshold } +pub fn NucCallParams::nuc_set_occupancy_threshold( + self : NucCallParams, + threshold : Double, +) -> NucCallParams { + NucCallParams::{ + smooth_window: self.smooth_window, + peak_threshold: self.peak_threshold, + min_distance: self.min_distance, + max_distance: self.max_distance, + occupancy_threshold: threshold, + width_threshold: self.width_threshold, + } } +///| /// Signal track for nucleosome analysis pub struct NucSignalTrack { /// Chromosome @@ -243,13 +361,23 @@ pub struct NucSignalTrack { length : Int } +///| /// Create new signal track -pub fn NucSignalTrack::new(chrom : String, signal : Array[Double], start : Int, step : Int) -> NucSignalTrack { +pub fn NucSignalTrack::new( + chrom : String, + signal : Array[Double], + start : Int, + step : Int, +) -> NucSignalTrack { NucSignalTrack::{ chrom, signal, start, step, length: signal.length() } } +///| /// Get signal value at position -pub fn NucSignalTrack::nuc_get_signal(self : NucSignalTrack, pos : Int) -> Double { +pub fn NucSignalTrack::nuc_get_signal( + self : NucSignalTrack, + pos : Int, +) -> Double { let idx = (pos - self.start) / self.step if idx >= 0 && idx < self.length { self.signal[idx] @@ -258,23 +386,33 @@ pub fn NucSignalTrack::nuc_get_signal(self : NucSignalTrack, pos : Int) -> Doubl } } +///| /// Get position for index -pub fn NucSignalTrack::nuc_get_position(self : NucSignalTrack, idx : Int) -> Int { +pub fn NucSignalTrack::nuc_get_position( + self : NucSignalTrack, + idx : Int, +) -> Int { self.start + idx * self.step } +///| /// Get length pub fn NucSignalTrack::nuc_get_length(self : NucSignalTrack) -> Int { self.length } +///| /// Get chromosome pub fn NucSignalTrack::nuc_get_chrom(self : NucSignalTrack) -> String { self.chrom } +///| /// Smooth signal track -pub fn nuc_smooth_signal(track : NucSignalTrack, window : Int) -> NucSignalTrack { +pub fn nuc_smooth_signal( + track : NucSignalTrack, + window : Int, +) -> NucSignalTrack { let n = track.signal.length() let smoothed : Array[Double] = Array::make(n, 0.0) @@ -301,8 +439,13 @@ pub fn nuc_smooth_signal(track : NucSignalTrack, window : Int) -> NucSignalTrack NucSignalTrack::new(track.chrom, smoothed, track.start, track.step) } +///| /// Find peaks in signal -pub fn nuc_find_peaks(track : NucSignalTrack, threshold : Double, min_distance : Int) -> Array[Int] { +pub fn nuc_find_peaks( + track : NucSignalTrack, + threshold : Double, + min_distance : Int, +) -> Array[Int] { let n = track.signal.length() let peaks : Array[Int] = Array::new() @@ -317,7 +460,8 @@ pub fn nuc_find_peaks(track : NucSignalTrack, threshold : Double, min_distance : let pos = track.start + i * track.step // Check minimum distance from last peak - if peaks.length() == 0 || (pos - track.start) - peaks[peaks.length() - 1] >= min_distance { + if peaks.length() == 0 || + pos - track.start - peaks[peaks.length() - 1] >= min_distance { peaks.push(pos - track.start) } else if val > track.signal[peaks[peaks.length() - 1]] { // Replace if higher @@ -330,15 +474,29 @@ pub fn nuc_find_peaks(track : NucSignalTrack, threshold : Double, min_distance : peaks } +///| /// Calculate occupancy from signal -pub fn nuc_calculate_occupancy(track : NucSignalTrack, - start_pos : Int, end_pos : Int) -> Double { +pub fn nuc_calculate_occupancy( + track : NucSignalTrack, + start_pos : Int, + end_pos : Int, +) -> Double { let n = track.signal.length() - let start_idx = if start_pos >= track.start { (start_pos - track.start) / track.step } else { 0 } + let start_idx = if start_pos >= track.start { + (start_pos - track.start) / track.step + } else { + 0 + } let end_idx = if end_pos > track.start { let idx = (end_pos - track.start) / track.step - if idx < n { idx } else { n } - } else { 0 } + if idx < n { + idx + } else { + n + } + } else { + 0 + } if start_idx >= end_idx { return 0.0 @@ -366,13 +524,21 @@ pub fn nuc_calculate_occupancy(track : NucSignalTrack, } } +///| /// Call nucleosomes from signal -pub fn nuc_call_nucleosomes(track : NucSignalTrack, params : NucCallParams) -> NucCallResult { +pub fn nuc_call_nucleosomes( + track : NucSignalTrack, + params : NucCallParams, +) -> NucCallResult { // Smooth the signal let smoothed = nuc_smooth_signal(track, params.smooth_window) // Find peaks - let peak_indices = nuc_find_peaks(smoothed, params.peak_threshold, params.min_distance) + let peak_indices = nuc_find_peaks( + smoothed, + params.peak_threshold, + params.min_distance, + ) // Convert peaks to nucleosome positions let nucleosomes : Array[NucPosition] = Array::new() @@ -395,16 +561,18 @@ pub fn nuc_call_nucleosomes(track : NucSignalTrack, params : NucCallParams) -> N let well_positioned = width < params.width_threshold - nucleosomes.push(NucPosition::new( - track.chrom, - start_pos, - end_pos, - center_pos.to_double(), - width, - occupancy, - positioning_score, - well_positioned - )) + nucleosomes.push( + NucPosition::new( + track.chrom, + start_pos, + end_pos, + center_pos.to_double(), + width, + occupancy, + positioning_score, + well_positioned, + ), + ) i = i + 1 } @@ -415,12 +583,18 @@ pub fn nuc_call_nucleosomes(track : NucSignalTrack, params : NucCallParams) -> N let mean_occupancy = calculate_mean_occupancy(nucleosomes) let frac_well_positioned = calculate_frac_well_positioned(nucleosomes) - NucCallResult::new(nucleosomes, n_nucleosomes, mean_spacing, - mean_occupancy, frac_well_positioned) + NucCallResult::new( + nucleosomes, n_nucleosomes, mean_spacing, mean_occupancy, frac_well_positioned, + ) } +///| /// Estimate peak width -fn estimate_peak_width(track : NucSignalTrack, center_idx : Int, threshold : Double) -> Double { +fn estimate_peak_width( + track : NucSignalTrack, + center_idx : Int, + threshold : Double, +) -> Double { let n = track.signal.length() let max_val = track.signal[center_idx] let half_max = max_val * threshold @@ -440,6 +614,7 @@ fn estimate_peak_width(track : NucSignalTrack, center_idx : Int, threshold : Dou ((right - left) * track.step).to_double() } +///| /// Calculate mean spacing between nucleosomes fn calculate_mean_spacing(nucleosomes : Array[NucPosition]) -> Double { if nucleosomes.length() < 2 { @@ -478,9 +653,14 @@ fn calculate_mean_spacing(nucleosomes : Array[NucPosition]) -> Double { i = i + 1 } - if count > 0 { total / count.to_double() } else { 0.0 } + if count > 0 { + total / count.to_double() + } else { + 0.0 + } } +///| /// Calculate mean occupancy fn calculate_mean_occupancy(nucleosomes : Array[NucPosition]) -> Double { if nucleosomes.length() == 0 { @@ -497,6 +677,7 @@ fn calculate_mean_occupancy(nucleosomes : Array[NucPosition]) -> Double { sum / nucleosomes.length().to_double() } +///| /// Calculate fraction well-positioned fn calculate_frac_well_positioned(nucleosomes : Array[NucPosition]) -> Double { if nucleosomes.length() == 0 { @@ -515,9 +696,13 @@ fn calculate_frac_well_positioned(nucleosomes : Array[NucPosition]) -> Double { count.to_double() / nucleosomes.length().to_double() } +///| /// Compare nucleosome positioning between two conditions -pub fn nuc_compare_positioning(result1 : NucCallResult, result2 : NucCallResult, - tolerance : Int) -> NucDynamicResult { +pub fn nuc_compare_positioning( + result1 : NucCallResult, + result2 : NucCallResult, + tolerance : Int, +) -> NucDynamicResult { let shared : Array[NucPosition] = Array::new() let gained : Array[NucPosition] = Array::new() let lost : Array[NucPosition] = Array::new() @@ -532,7 +717,7 @@ pub fn nuc_compare_positioning(result1 : NucCallResult, result2 : NucCallResult, while j < result2.nucleosomes.length() { let nuc2 = result2.nucleosomes[j] if nuc1.chrom == nuc2.chrom && - (nuc1.center - nuc2.center).abs() <= tolerance.to_double() { + (nuc1.center - nuc2.center).abs() <= tolerance.to_double() { shared.push(nuc1) found = true break @@ -557,7 +742,7 @@ pub fn nuc_compare_positioning(result1 : NucCallResult, result2 : NucCallResult, while m < result1.nucleosomes.length() { let nuc1 = result1.nucleosomes[m] if nuc1.chrom == nuc2.chrom && - (nuc1.center - nuc2.center).abs() <= tolerance.to_double() { + (nuc1.center - nuc2.center).abs() <= tolerance.to_double() { found = true break } @@ -574,15 +759,22 @@ pub fn nuc_compare_positioning(result1 : NucCallResult, result2 : NucCallResult, let total = result1.n_nucleosomes + result2.n_nucleosomes let frac_changed = if total > 0 { (gained.length() + lost.length()).to_double() / total.to_double() - } else { 0.0 } + } else { + 0.0 + } - let direction = if gained.length() > lost.length() { 1 } - else if lost.length() > gained.length() { -1 } - else { 0 } + let direction = if gained.length() > lost.length() { + 1 + } else if lost.length() > gained.length() { + -1 + } else { + 0 + } NucDynamicResult::new(shared, gained, lost, frac_changed, direction) } +///| /// Create example signal track for testing pub fn nuc_create_example_track() -> NucSignalTrack { let length = 1000 @@ -628,9 +820,10 @@ pub fn nuc_create_example_track() -> NucSignalTrack { NucSignalTrack::new("chr1", signal, start, step) } +///| /// Create example nucleosome call result pub fn nuc_create_example_result() -> NucCallResult { let track = nuc_create_example_track() let params = NucCallParams::new() nuc_call_nucleosomes(track, params) -} \ No newline at end of file +} diff --git a/src/open_cyto.mbt b/src/open_cyto.mbt index 9f7d9940..b153f01d 100644 --- a/src/open_cyto.mbt +++ b/src/open_cyto.mbt @@ -58,11 +58,7 @@ pub struct OcGate { ///| /// Construct a 1D gate. -pub fn OcGate::new1d( - dim~ : String, - min~ : Double, - max~ : Double, -) -> OcGate { +pub fn OcGate::new1d(dim~ : String, min~ : Double, max~ : Double) -> OcGate { OcGate::{ dim1: dim, dim2: None, min1: min, max1: max, min2: 0.0, max2: 0.0 } } @@ -76,7 +72,7 @@ pub fn OcGate::new2d( min2~ : Double, max2~ : Double, ) -> OcGate { - OcGate::{ dim1: dim1, dim2: Some(dim2), min1, max1, min2, max2 } + OcGate::{ dim1, dim2: Some(dim2), min1, max1, min2, max2 } } ///| @@ -264,11 +260,7 @@ pub fn oc_ln(x : Double) -> Double { /// Evaluate a Gaussian KDE at point `x` given data and bandwidth `h`. /// KDE(x) = (1 / (n*h)) * Σ φ((x - xi) / h) /// where φ is the standard normal density. -pub fn oc_kde_evaluate( - data : Array[Double], - x : Double, - h : Double, -) -> Double { +pub fn oc_kde_evaluate(data : Array[Double], x : Double, h : Double) -> Double { let n = data.length() if n == 0 || h <= 0.0 { return 0.0 @@ -356,7 +348,7 @@ pub fn oc_mindensity( ) -> OcGate { let n = values.length() if n == 0 { - return OcGate::new1d(dim=dim, min=0.0, max=1.0e30) + return OcGate::new1d(dim~, min=0.0, max=1.0e30) } let n_points = 200 let h = match args.get("bandwidth") { @@ -365,7 +357,7 @@ pub fn oc_mindensity( } let (gx, gy) = oc_kde_grid(values, n_points, h) if gx.length() < 3 { - return OcGate::new1d(dim=dim, min=oc_median(values), max=1.0e30) + return OcGate::new1d(dim~, min=oc_median(values), max=1.0e30) } // find local maxima (peaks) let peaks : Array[Int] = Array::new() @@ -377,7 +369,7 @@ pub fn oc_mindensity( if peaks.length() < 2 { // single peak: use the median let m = oc_median(values) - return OcGate::new1d(dim=dim, min=m, max=1.0e30) + return OcGate::new1d(dim~, min=m, max=1.0e30) } // find the two highest peaks let mut p1 = peaks[0] @@ -417,7 +409,7 @@ pub fn oc_mindensity( Some(m) => m None => 1.0e30 } - OcGate::new1d(dim=dim, min=threshold, max=max_val) + OcGate::new1d(dim~, min=threshold, max=max_val) } // ============================================================================ @@ -436,7 +428,7 @@ pub fn oc_tailgate( ) -> OcGate { let n = values.length() if n == 0 { - return OcGate::new1d(dim=dim, min=0.0, max=1.0e30) + return OcGate::new1d(dim~, min=0.0, max=1.0e30) } let q = match args.get("quantile") { Some(v) => v @@ -447,7 +439,7 @@ pub fn oc_tailgate( Some(m) => m None => 1.0e30 } - OcGate::new1d(dim=dim, min=threshold, max=max_val) + OcGate::new1d(dim~, min=threshold, max=max_val) } // ============================================================================ @@ -464,7 +456,7 @@ pub fn oc_quantile_gate( ) -> OcGate { let n = values.length() if n == 0 { - return OcGate::new1d(dim=dim, min=0.0, max=1.0e30) + return OcGate::new1d(dim~, min=0.0, max=1.0e30) } let q = match args.get("probs") { Some(v) => v @@ -475,7 +467,7 @@ pub fn oc_quantile_gate( Some(m) => m None => 1.0e30 } - OcGate::new1d(dim=dim, min=threshold, max=max_val) + OcGate::new1d(dim~, min=threshold, max=max_val) } // ============================================================================ @@ -492,7 +484,7 @@ pub fn oc_range_gate( ) -> OcGate { let n = values.length() if n == 0 { - return OcGate::new1d(dim=dim, min=0.0, max=1.0e30) + return OcGate::new1d(dim~, min=0.0, max=1.0e30) } let sorted = Array::new() for v in values { @@ -529,7 +521,7 @@ pub fn oc_range_gate( Some(m) => m None => 1.0e30 } - OcGate::new1d(dim=dim, min=threshold, max=max_val) + OcGate::new1d(dim~, min=threshold, max=max_val) } // ============================================================================ @@ -596,7 +588,7 @@ pub fn oc_flow_clust( let gate_min2 = means2[best] - 2.0 * sd2 let gate_max2 = means2[best] + 2.0 * sd2 OcGate::new2d( - dim1=dim1, + dim1~, dim2=dim2.unwrap(), min1=gate_min1, max1=gate_max1, @@ -623,7 +615,9 @@ pub fn oc_em_t_mixture_1d( // initialize means via quantiles let means = Array::new() for k in 0.. Double { } let g = 7.0 let c = [ - 0.99999999999980993, - 676.5203681218851, - -1259.1392167224028, - 771.32342877765313, - -176.61502916214059, - 12.507343278686905, - -0.13857109526572012, - 9.9843695780195716e-6, + 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, + -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7, ] let mut x_adj = x - 1.0 @@ -795,7 +785,10 @@ pub fn oc_lgamma(x : Double) -> Double { a = a + c[i] / x_adj } let t = x + g - 0.5 - 0.5 * @math.ln(2.0 * 3.141592653589793) + (x - 0.5) * @math.ln(t) - t + @math.ln(a) + 0.5 * @math.ln(2.0 * 3.141592653589793) + + (x - 0.5) * @math.ln(t) - + t + + @math.ln(a) } ///| @@ -896,7 +889,7 @@ pub fn oc_gate_flow_set( OcGatingResult::new( population=rule.child, sample=sample_name, - gate=gate, + gate~, parent_events=0, child_events=0, indices=Array::new(), @@ -949,7 +942,14 @@ pub fn oc_gate_flow_set( for i in parent_event_indices { vals2.push(events[i][dim2_idx]) } - oc_flow_clust(vals1, vals2, rule.dims[0], Some(rule.dims[1]), rule.args, n_clusters) + oc_flow_clust( + vals1, + vals2, + rule.dims[0], + Some(rule.dims[1]), + rule.args, + n_clusters, + ) } else { oc_flow_clust(vals1, [], rule.dims[0], None, rule.args, n_clusters) } @@ -972,7 +972,11 @@ pub fn oc_gate_flow_set( let v1 = if dim_idx >= 0 { events[i][dim_idx] } else { 0.0 } let v2 = if rule.dims.length() >= 2 { let d2 = oc_resolve_channel(flowset.channel_names, rule.dims[1]) - if d2 >= 0 { events[i][d2] } else { 0.0 } + if d2 >= 0 { + events[i][d2] + } else { + 0.0 + } } else { 0.0 } @@ -985,7 +989,7 @@ pub fn oc_gate_flow_set( OcGatingResult::new( population=rule.child, sample=sample_name, - gate=gate, + gate~, parent_events=parent_event_indices.length(), child_events=child_count, indices=child_flags, diff --git a/src/pairaligner.mbt b/src/pairaligner.mbt index 09e1b326..df1c731e 100644 --- a/src/pairaligner.mbt +++ b/src/pairaligner.mbt @@ -415,33 +415,39 @@ fn pairaligner_chars_equal_ci(a : Char, b : Char) -> Bool { /// BLOSUM62 data for 20 standard amino acids in order: /// A R N D C Q E G H I L K M F P S T W Y V let pairaligner_blosum62_data : Array[Array[Int]] = [ - [ 4,-1,-2,-2, 0,-1,-1, 0,-2,-1,-1,-1,-1,-2,-1, 1, 0,-3,-2, 0], // A - [-1, 5, 0,-2,-3, 1, 0,-2, 0,-3,-2, 2,-1,-3,-2,-1,-1,-3,-2,-3], // R - [-2, 0, 6, 1,-3, 0, 0, 0, 1,-3,-3, 0,-2,-3,-2, 1, 0,-4,-2,-3], // N - [-2,-2, 1, 6,-3, 0, 2,-1,-1,-3,-4,-1,-3,-3,-1, 0,-1,-4,-3,-3], // D - [ 0,-3,-3,-3, 9,-3,-4,-3,-3,-1,-1,-3,-1,-2,-3,-1,-1,-2,-2,-1], // C - [-1, 1, 0, 0,-3, 5, 2,-2, 0,-3,-2, 1, 0,-3,-1, 0,-1,-2,-1,-2], // Q - [-1, 0, 0, 2,-4, 2, 5,-2, 0,-3,-3, 1,-2,-3,-1, 0,-1,-3,-2,-2], // E - [ 0,-2, 0,-1,-3,-2,-2, 6,-2,-4,-4,-2,-3,-3,-2, 0,-2,-2,-3,-3], // G - [-2, 0, 1,-1,-3, 0, 0,-2, 8,-3,-3,-1,-2,-1,-2,-1,-2,-2, 2,-3], // H - [-1,-3,-3,-3,-1,-3,-3,-4,-3, 4, 2,-3, 1, 0,-3,-2,-1,-3,-1, 3], // I - [-1,-2,-3,-4,-1,-2,-3,-4,-3, 2, 4,-2, 2, 0,-3,-2,-1,-2,-1, 1], // L - [-1, 2, 0,-1,-3, 1, 1,-2,-1,-3,-2, 5,-1,-3,-1, 0,-1,-3,-2,-2], // K - [-1,-1,-2,-3,-1, 0,-2,-3,-2, 1, 2,-1, 5, 0,-2,-1,-1,-1,-1, 1], // M - [-2,-3,-3,-3,-2,-3,-3,-3,-1, 0, 0,-3, 0, 6,-4,-2,-2, 1, 3,-1], // F - [-1,-2,-2,-1,-3,-1,-1,-2,-2,-3,-3,-1,-2,-4, 7,-1,-1,-4,-3,-2], // P - [ 1,-1, 1, 0,-1, 0, 0, 0,-1,-2,-2, 0,-1,-2,-1, 4, 1,-3,-2,-2], // S - [ 0,-1, 0,-1,-1,-1,-1,-2,-2,-1,-1,-1,-1,-2,-1, 1, 5,-2,-2, 0], // T - [-3,-3,-4,-4,-2,-2,-3,-2,-2,-3,-2,-3,-1, 1,-4,-3,-2,11, 2,-3], // W - [-2,-2,-2,-3,-2,-1,-2,-3, 2,-1,-1,-2,-1, 3,-3,-2,-2, 2, 7,-1], // Y - [ 0,-3,-3,-3,-1,-2,-2,-3,-3, 3, 1,-2, 1,-1,-2,-2, 0,-3,-1, 4], // V + [4, -1, -2, -2, 0, -1, -1, 0, -2, -1, -1, -1, -1, -2, -1, 1, 0, -3, -2, 0], // A + [-1, 5, 0, -2, -3, 1, 0, -2, 0, -3, -2, 2, -1, -3, -2, -1, -1, -3, -2, -3], // R + [-2, 0, 6, 1, -3, 0, 0, 0, 1, -3, -3, 0, -2, -3, -2, 1, 0, -4, -2, -3], // N + [-2, -2, 1, 6, -3, 0, 2, -1, -1, -3, -4, -1, -3, -3, -1, 0, -1, -4, -3, -3], // D + [0, -3, -3, -3, 9, -3, -4, -3, -3, -1, -1, -3, -1, -2, -3, -1, -1, -2, -2, -1], // C + [-1, 1, 0, 0, -3, 5, 2, -2, 0, -3, -2, 1, 0, -3, -1, 0, -1, -2, -1, -2], // Q + [-1, 0, 0, 2, -4, 2, 5, -2, 0, -3, -3, 1, -2, -3, -1, 0, -1, -3, -2, -2], // E + [0, -2, 0, -1, -3, -2, -2, 6, -2, -4, -4, -2, -3, -3, -2, 0, -2, -2, -3, -3], // G + [-2, 0, 1, -1, -3, 0, 0, -2, 8, -3, -3, -1, -2, -1, -2, -1, -2, -2, 2, -3], // H + [-1, -3, -3, -3, -1, -3, -3, -4, -3, 4, 2, -3, 1, 0, -3, -2, -1, -3, -1, 3], // I + [-1, -2, -3, -4, -1, -2, -3, -4, -3, 2, 4, -2, 2, 0, -3, -2, -1, -2, -1, 1], // L + [-1, 2, 0, -1, -3, 1, 1, -2, -1, -3, -2, 5, -1, -3, -1, 0, -1, -3, -2, -2], // K + [-1, -1, -2, -3, -1, 0, -2, -3, -2, 1, 2, -1, 5, 0, -2, -1, -1, -1, -1, 1], // M + [-2, -3, -3, -3, -2, -3, -3, -3, -1, 0, 0, -3, 0, 6, -4, -2, -2, 1, 3, -1], // F + [ + -1, -2, -2, -1, -3, -1, -1, -2, -2, -3, -3, -1, -2, -4, 7, -1, -1, -4, -3, -2, + ], // P + [1, -1, 1, 0, -1, 0, 0, 0, -1, -2, -2, 0, -1, -2, -1, 4, 1, -3, -2, -2], // S + [0, -1, 0, -1, -1, -1, -1, -2, -2, -1, -1, -1, -1, -2, -1, 1, 5, -2, -2, 0], // T + [-3, -3, -4, -4, -2, -2, -3, -2, -2, -3, -2, -3, -1, 1, -4, -3, -2, 11, 2, -3], // W + [-2, -2, -2, -3, -2, -1, -2, -3, 2, -1, -1, -2, -1, 3, -3, -2, -2, 2, 7, -1], // Y + [0, -3, -3, -3, -1, -2, -2, -3, -3, 3, 1, -2, 1, -1, -2, -2, 0, -3, -1, 4], // V ] ///| /// Internal BLOSUM62 matrix lookup using 20 standard amino acids. /// Returns score for a pair (case-insensitive). /// Uses mismatch_score default for unknown amino acids. -fn pairaligner_blosum62_score(a : Char, b : Char, mismatch_default : Double) -> Double { +fn pairaligner_blosum62_score( + a : Char, + b : Char, + mismatch_default : Double, +) -> Double { let ia = pairaligner_aa_index_ci(a) let ib = pairaligner_aa_index_ci(b) if ia < 0 || ib < 0 { @@ -494,15 +500,14 @@ fn pairaligner_get_subst_score( config : PairwiseAlignerConfig, ) -> Double { let is_protein = config.alphabet_type == "PROTEIN" - let use_matrix = is_protein && config.submatrix == SubstitutionMatrixChoice::Blosum62 + let use_matrix = is_protein && + config.submatrix == SubstitutionMatrixChoice::Blosum62 if use_matrix { pairaligner_blosum62_score(a, b, config.mismatch_score) + } else if pairaligner_chars_equal_ci(a, b) { + config.match_score } else { - if pairaligner_chars_equal_ci(a, b) { - config.match_score - } else { - config.mismatch_score - } + config.mismatch_score } } @@ -547,6 +552,7 @@ fn pairaligner_reverse_string(s : String) -> String { // Traceback direction enum (internal) // ============================================================ +///| priv enum TraceDir { Stop Diag @@ -579,10 +585,13 @@ pub fn pairaligner_align( let is_local = config.mode == AlignmentMode::Local // ---- Initialize DP matrices ---- - let m_mat : Array[Array[Double]] = pairaligner_make_matrix(n + 1, m + 1, 0.0) - let ix_mat : Array[Array[Double]] = pairaligner_make_matrix(n + 1, m + 1, 0.0) - let iy_mat : Array[Array[Double]] = pairaligner_make_matrix(n + 1, m + 1, 0.0) - let trace : Array[Array[TraceDir]] = pairaligner_make_trace_matrix(n + 1, m + 1) + let m_mat : Array[Array[Double]] = pairaligner_make_matrix(n + 1, m + 1, 0.0) + let ix_mat : Array[Array[Double]] = pairaligner_make_matrix(n + 1, m + 1, 0.0) + let iy_mat : Array[Array[Double]] = pairaligner_make_matrix(n + 1, m + 1, 0.0) + let trace : Array[Array[TraceDir]] = pairaligner_make_trace_matrix( + n + 1, + m + 1, + ) let target_gap_open = config.target_gap_open let target_gap_extend = config.target_gap_extend @@ -651,33 +660,51 @@ pub fn pairaligner_align( let s = pairaligner_get_subst_score(tc, qc, config) // Compute m_mat[i][j]: match/mismatch - let from_M = m_mat[i - 1][j - 1] + s + let from_M = m_mat[i - 1][j - 1] + s let from_Ix = ix_mat[i - 1][j - 1] + s let from_Iy = iy_mat[i - 1][j - 1] + s let mut m_val = from_M - if from_Ix > m_val { m_val = from_Ix } - if from_Iy > m_val { m_val = from_Iy } + if from_Ix > m_val { + m_val = from_Ix + } + if from_Iy > m_val { + m_val = from_Iy + } // Compute ix_mat[i][j]: gap in query (Up step) - let ix_extend = ix_mat[i - 1][j] + query_gap_extend - let ix_open_from_M = m_mat[i - 1][j] + query_gap_open + let ix_extend = ix_mat[i - 1][j] + query_gap_extend + let ix_open_from_M = m_mat[i - 1][j] + query_gap_open let ix_open_from_Iy = iy_mat[i - 1][j] + query_gap_open let mut ix_val = ix_extend - if ix_open_from_M > ix_val { ix_val = ix_open_from_M } - if ix_open_from_Iy > ix_val { ix_val = ix_open_from_Iy } + if ix_open_from_M > ix_val { + ix_val = ix_open_from_M + } + if ix_open_from_Iy > ix_val { + ix_val = ix_open_from_Iy + } // Compute iy_mat[i][j]: gap in target (Left step) - let iy_extend = iy_mat[i][j - 1] + target_gap_extend - let iy_open_from_M = m_mat[i][j - 1] + target_gap_open + let iy_extend = iy_mat[i][j - 1] + target_gap_extend + let iy_open_from_M = m_mat[i][j - 1] + target_gap_open let iy_open_from_Ix = ix_mat[i][j - 1] + target_gap_open let mut iy_val = iy_extend - if iy_open_from_M > iy_val { iy_val = iy_open_from_M } - if iy_open_from_Ix > iy_val { iy_val = iy_open_from_Ix } + if iy_open_from_M > iy_val { + iy_val = iy_open_from_M + } + if iy_open_from_Ix > iy_val { + iy_val = iy_open_from_Ix + } if is_local { - if m_val < 0.0 { m_val = 0.0 } - if ix_val < 0.0 { ix_val = 0.0 } - if iy_val < 0.0 { iy_val = 0.0 } + if m_val < 0.0 { + m_val = 0.0 + } + if ix_val < 0.0 { + ix_val = 0.0 + } + if iy_val < 0.0 { + iy_val = 0.0 + } } // Choose overall best and record trace @@ -692,7 +719,7 @@ pub fn pairaligner_align( best_dir = TraceDir::Left } - m_mat[i][j] = m_val + m_mat[i][j] = m_val ix_mat[i][j] = ix_val iy_mat[i][j] = iy_val @@ -720,12 +747,16 @@ pub fn pairaligner_align( let (start_i, start_j, final_score) : (Int, Int, Double) = if is_local { (max_i, max_j, max_score) } else { - let m_nm = m_mat[n][m] + let m_nm = m_mat[n][m] let ix_nm = ix_mat[n][m] let iy_nm = iy_mat[n][m] let mut best = m_nm - if ix_nm > best { best = ix_nm } - if iy_nm > best { best = iy_nm } + if ix_nm > best { + best = ix_nm + } + if iy_nm > best { + best = iy_nm + } (n, m, best) } @@ -822,7 +853,11 @@ pub fn pairaligner_align( ///| /// Create a 2D Double matrix of size rows x cols filled with val. -fn pairaligner_make_matrix(rows : Int, cols : Int, val : Double) -> Array[Array[Double]] { +fn pairaligner_make_matrix( + rows : Int, + cols : Int, + val : Double, +) -> Array[Array[Double]] { let result : Array[Array[Double]] = Array::new() let mut i = 0 while i < rows { @@ -840,7 +875,10 @@ fn pairaligner_make_matrix(rows : Int, cols : Int, val : Double) -> Array[Array[ ///| /// Create a 2D trace matrix filled with Stop. -fn pairaligner_make_trace_matrix(rows : Int, cols : Int) -> Array[Array[TraceDir]] { +fn pairaligner_make_trace_matrix( + rows : Int, + cols : Int, +) -> Array[Array[TraceDir]] { let result : Array[Array[TraceDir]] = Array::new() let mut i = 0 while i < rows { diff --git a/src/pairwise2.mbt b/src/pairwise2.mbt index 7bf43b00..f086ec51 100644 --- a/src/pairwise2.mbt +++ b/src/pairwise2.mbt @@ -27,13 +27,17 @@ pub struct PairwiseAlignResult { ///| /// Get the aligned first sequence. -pub fn PairwiseAlignResult::get_aligned_seq1(self : PairwiseAlignResult) -> String { +pub fn PairwiseAlignResult::get_aligned_seq1( + self : PairwiseAlignResult, +) -> String { self.aligned_seq1 } ///| /// Get the aligned second sequence. -pub fn PairwiseAlignResult::get_aligned_seq2(self : PairwiseAlignResult) -> String { +pub fn PairwiseAlignResult::get_aligned_seq2( + self : PairwiseAlignResult, +) -> String { self.aligned_seq2 } @@ -51,7 +55,10 @@ pub fn PairwiseAlignResult::get_mode(self : PairwiseAlignResult) -> String { ///| /// Get the alignment as a formatted string. -pub fn PairwiseAlignResult::format_alignment(self : PairwiseAlignResult, line_width : Int) -> String { +pub fn PairwiseAlignResult::format_alignment( + self : PairwiseAlignResult, + line_width : Int, +) -> String { let w = if line_width <= 0 { 60 } else { line_width } let mut result = "" let len = self.aligned_seq1.length() @@ -59,8 +66,8 @@ pub fn PairwiseAlignResult::format_alignment(self : PairwiseAlignResult, line_wi let mut pos = 0 while pos < len { let end = if pos + w < len { pos + w } else { len } - let s1 = self.aligned_seq1.substring(start=pos, end=end) - let s2 = self.aligned_seq2.substring(start=pos, end=end) + let s1 = self.aligned_seq1.substring(start=pos, end~) + let s2 = self.aligned_seq2.substring(start=pos, end~) let pos1 = self.seq1_start + pos let pos2 = self.seq2_start + pos @@ -116,9 +123,16 @@ pub fn pairwise_result_new( ///| /// Create a simple match/mismatch scoring function. /// Returns a function that scores based on match/mismatch values. -pub fn simple_score(match_sc : Double, mismatch_sc : Double) -> (String, String) -> Double { +pub fn simple_score( + match_sc : Double, + mismatch_sc : Double, +) -> (String, String) -> Double { fn(c1 : String, c2 : String) -> Double { - if c1.to_upper() == c2.to_upper() { match_sc } else { mismatch_sc } + if c1.to_upper() == c2.to_upper() { + match_sc + } else { + mismatch_sc + } } } @@ -130,9 +144,16 @@ pub fn identity_score() -> (String, String) -> Double { ///| /// Create a scoring function using a substitution matrix (Map-based). -pub fn matrix_score(matrix : Map[String, Double], default : Double) -> (String, String) -> Double { +pub fn matrix_score( + matrix : Map[String, Double], + default : Double, +) -> (String, String) -> Double { fn(c1 : String, c2 : String) -> Double { - let k = if c1 <= c2 { c1.to_upper() + c2.to_upper() } else { c2.to_upper() + c1.to_upper() } + let k = if c1 <= c2 { + c1.to_upper() + c2.to_upper() + } else { + c2.to_upper() + c1.to_upper() + } match matrix.get(k) { Some(v) => v None => default @@ -142,7 +163,10 @@ pub fn matrix_score(matrix : Map[String, Double], default : Double) -> (String, ///| /// Create a standard DNA scoring matrix (A/T/C/G pairwise). -pub fn dna_matrix(match_sc : Double, mismatch_sc : Double) -> Map[String, Double] { +pub fn dna_matrix( + match_sc : Double, + mismatch_sc : Double, +) -> Map[String, Double] { let m : Map[String, Double] = Map([], capacity=10) m["AA"] = match_sc m["AC"] = mismatch_sc @@ -157,16 +181,24 @@ pub fn dna_matrix(match_sc : Double, mismatch_sc : Double) -> Map[String, Double m } +///| /// Helper: get element from flat Double matrix -fn get_flat_double(arr : Array[Double], i : Int, j : Int, m_plus_1 : Int) -> Double { +fn get_flat_double( + arr : Array[Double], + i : Int, + j : Int, + m_plus_1 : Int, +) -> Double { arr[i * m_plus_1 + j] } +///| /// Helper: get element from flat Int matrix fn get_flat_int(arr : Array[Int], i : Int, j : Int, m_plus_1 : Int) -> Int { arr[i * m_plus_1 + j] } +///| /// Helper: initialize flat Double matrix of size (n+1) x (m+1) with fill_val fn init_flat_double(n : Int, m : Int, fill_val : Double) -> Array[Double] { let size = (n + 1) * (m + 1) @@ -179,6 +211,7 @@ fn init_flat_double(n : Int, m : Int, fill_val : Double) -> Array[Double] { arr } +///| /// Helper: initialize flat Int matrix of size (n+1) x (m+1) with fill_val fn init_flat_int(n : Int, m : Int, fill_val : Int) -> Array[Int] { let size = (n + 1) * (m + 1) @@ -421,7 +454,10 @@ pub fn pairwise_localxx( let mut start1 = p let mut start2 = q - while p > 0 && q > 0 && get_flat_int(tb, p, q, m_plus_1) != -1 && get_flat_double(sc, p, q, m_plus_1) > 0.0 { + while p > 0 && + q > 0 && + get_flat_int(tb, p, q, m_plus_1) != -1 && + get_flat_double(sc, p, q, m_plus_1) > 0.0 { let dir = get_flat_int(tb, p, q, m_plus_1) if dir == 0 { aligned1 = seq1.substring(start=p - 1, end=p) + aligned1 @@ -683,7 +719,10 @@ pub fn pairwise_localms( let mut start1 = p let mut start2 = q - while p > 0 && q > 0 && get_flat_int(tb, p, q, m_plus_1) != -1 && get_flat_double(sc, p, q, m_plus_1) > 0.0 { + while p > 0 && + q > 0 && + get_flat_int(tb, p, q, m_plus_1) != -1 && + get_flat_double(sc, p, q, m_plus_1) > 0.0 { let dir = get_flat_int(tb, p, q, m_plus_1) if dir == 0 { aligned1 = seq1.substring(start=p - 1, end=p) + aligned1 @@ -753,8 +792,16 @@ pub fn alignment_summary(result : PairwiseAlignResult) -> String { i = i + 1 } - let identity = if len > 0 { (matches.to_double() / len.to_double()) * 100.0 } else { 0.0 } - let similarity = if len > 0 { ((matches + mismatches).to_double() / len.to_double()) * 100.0 } else { 0.0 } + let identity = if len > 0 { + matches.to_double() / len.to_double() * 100.0 + } else { + 0.0 + } + let similarity = if len > 0 { + (matches + mismatches).to_double() / len.to_double() * 100.0 + } else { + 0.0 + } let mut summary = "=== Pairwise Alignment Summary ===\n".to_string() summary = summary + "Mode: \{result.mode}\n" @@ -766,4 +813,4 @@ pub fn alignment_summary(result : PairwiseAlignResult) -> String { summary = summary + "Identity: \{identity.to_string()}%\n" summary = summary + "Similarity: \{similarity.to_string()}%\n" summary -} \ No newline at end of file +} diff --git a/src/paml.mbt b/src/paml.mbt index 7bd98cee..74c7713f 100644 --- a/src/paml.mbt +++ b/src/paml.mbt @@ -12,11 +12,7 @@ pub struct PAMLAlignment { ///| pub fn PAMLAlignment::new(sequences : Array[(String, String)]) -> PAMLAlignment { - PAMLAlignment::{ - sequences, - tree: "", - model: "HKY85" - } + PAMLAlignment::{ sequences, tree: "", model: "HKY85" } } ///| @@ -35,7 +31,7 @@ pub fn PAMLResult::new(ln_likelihood : Double) -> PAMLResult { parameters: Map([], capacity=10), dnds_ratios: Array::new(), substitution_rates: Array::new(), - ancestral_sequences: Array::new() + ancestral_sequences: Array::new(), } } @@ -59,120 +55,172 @@ pub fn DNDSResult::new(dN : Double, dS : Double, omega : Double) -> DNDSResult { se_dN: 0.0, se_dS: 0.0, se_omega: 0.0, - method: "Nei-Gojobori" + method: "Nei-Gojobori", } } ///| -pub fn paml_calculate_dnds(seq1 : String, seq2 : String, method : String) -> DNDSResult { +pub fn paml_calculate_dnds( + seq1 : String, + seq2 : String, + method : String, +) -> DNDSResult { let aligned_seq1 = to_lowercase(seq1) let aligned_seq2 = to_lowercase(seq2) - + if aligned_seq1.length() != aligned_seq2.length() { return DNDSResult::new(0.0, 0.0, 0.0) } - + let mut synonymous_sites = 0.0 let mut non_synonymous_sites = 0.0 let mut synonymous_changes = 0 let mut non_synonymous_changes = 0 - + let codon_table = get_standard_codon_table() - + let mut i = 0 while i < aligned_seq1.length() - 2 { let codon1 = substring(aligned_seq1, i, 3) let codon2 = substring(aligned_seq2, i, 3) - + if !contains(codon1, "-") && !contains(codon2, "-") { let aa1 = codon_table.get(codon1).unwrap_or("X") let aa2 = codon_table.get(codon2).unwrap_or("X") - + let (syn_sites, non_syn_sites) = count_sites(codon1, codon2, codon_table) synonymous_sites = synonymous_sites + syn_sites non_synonymous_sites = non_synonymous_sites + non_syn_sites - + if aa1 != aa2 { non_synonymous_changes = non_synonymous_changes + 1 } else if codon1 != codon2 { synonymous_changes = synonymous_changes + 1 } } - + i = i + 3 } - + let dS = if synonymous_sites > 0.0 { - paml_jukes_cantor_correction(synonymous_changes.to_double() / synonymous_sites) + paml_jukes_cantor_correction( + synonymous_changes.to_double() / synonymous_sites, + ) } else { 0.0 } - + let dN = if non_synonymous_sites > 0.0 { - paml_jukes_cantor_correction(non_synonymous_changes.to_double() / non_synonymous_sites) + paml_jukes_cantor_correction( + non_synonymous_changes.to_double() / non_synonymous_sites, + ) } else { 0.0 } - + let omega = if dS > 0.0 { dN / dS } else { 0.0 } - + DNDSResult::new(dN, dS, omega) } ///| pub fn get_standard_codon_table() -> Map[String, String] { let table = Map([], capacity=64) - - table.set("TTT", "F"); table.set("TTC", "F") - table.set("TTA", "L"); table.set("TTG", "L") - table.set("TCT", "S"); table.set("TCC", "S"); table.set("TCA", "S"); table.set("TCG", "S") - table.set("TAT", "Y"); table.set("TAC", "Y") - table.set("TAA", "*"); table.set("TAG", "*"); table.set("TGA", "*") - table.set("TGT", "C"); table.set("TGC", "C") + + table.set("TTT", "F") + table.set("TTC", "F") + table.set("TTA", "L") + table.set("TTG", "L") + table.set("TCT", "S") + table.set("TCC", "S") + table.set("TCA", "S") + table.set("TCG", "S") + table.set("TAT", "Y") + table.set("TAC", "Y") + table.set("TAA", "*") + table.set("TAG", "*") + table.set("TGA", "*") + table.set("TGT", "C") + table.set("TGC", "C") table.set("TGG", "W") - - table.set("CTT", "L"); table.set("CTC", "L"); table.set("CTA", "L"); table.set("CTG", "L") - table.set("CCT", "P"); table.set("CCC", "P"); table.set("CCA", "P"); table.set("CCG", "P") - table.set("CAT", "H"); table.set("CAC", "H") - table.set("CAA", "Q"); table.set("CAG", "Q") - table.set("CGT", "R"); table.set("CGC", "R"); table.set("CGA", "R"); table.set("CGG", "R") - - table.set("ATT", "I"); table.set("ATC", "I"); table.set("ATA", "I") + + table.set("CTT", "L") + table.set("CTC", "L") + table.set("CTA", "L") + table.set("CTG", "L") + table.set("CCT", "P") + table.set("CCC", "P") + table.set("CCA", "P") + table.set("CCG", "P") + table.set("CAT", "H") + table.set("CAC", "H") + table.set("CAA", "Q") + table.set("CAG", "Q") + table.set("CGT", "R") + table.set("CGC", "R") + table.set("CGA", "R") + table.set("CGG", "R") + + table.set("ATT", "I") + table.set("ATC", "I") + table.set("ATA", "I") table.set("ATG", "M") - table.set("ACT", "T"); table.set("ACC", "T"); table.set("ACA", "T"); table.set("ACG", "T") - table.set("AAT", "N"); table.set("AAC", "N") - table.set("AAA", "K"); table.set("AAG", "K") - table.set("AGT", "S"); table.set("AGC", "S") - table.set("AGA", "R"); table.set("AGG", "R") - - table.set("GTT", "V"); table.set("GTC", "V"); table.set("GTA", "V"); table.set("GTG", "V") - table.set("GCT", "A"); table.set("GCC", "A"); table.set("GCA", "A"); table.set("GCG", "A") - table.set("GAT", "D"); table.set("GAC", "D") - table.set("GAA", "E"); table.set("GAG", "E") - table.set("GGT", "G"); table.set("GGC", "G"); table.set("GGA", "G"); table.set("GGG", "G") - + table.set("ACT", "T") + table.set("ACC", "T") + table.set("ACA", "T") + table.set("ACG", "T") + table.set("AAT", "N") + table.set("AAC", "N") + table.set("AAA", "K") + table.set("AAG", "K") + table.set("AGT", "S") + table.set("AGC", "S") + table.set("AGA", "R") + table.set("AGG", "R") + + table.set("GTT", "V") + table.set("GTC", "V") + table.set("GTA", "V") + table.set("GTG", "V") + table.set("GCT", "A") + table.set("GCC", "A") + table.set("GCA", "A") + table.set("GCG", "A") + table.set("GAT", "D") + table.set("GAC", "D") + table.set("GAA", "E") + table.set("GAG", "E") + table.set("GGT", "G") + table.set("GGC", "G") + table.set("GGA", "G") + table.set("GGG", "G") + table } ///| -fn count_sites(codon1 : String, codon2 : String, codon_table : Map[String, String]) -> (Double, Double) { +fn count_sites( + codon1 : String, + codon2 : String, + codon_table : Map[String, String], +) -> (Double, Double) { let aa1 = codon_table.get(codon1).unwrap_or("X") let aa2 = codon_table.get(codon2).unwrap_or("X") - + if aa1 == "*" || aa2 == "*" || aa1 == "X" || aa2 == "X" { return (0.0, 0.0) } - + if aa1 == aa2 { let mut syn_count = 0 let mut all_count = 0 - + let mut pos = 0 while pos < 3 { if char_at(codon1, pos) != char_at(codon2, pos) { all_count = all_count + 1 let bases = ["A", "T", "C", "G"] - + let mut b = 0 while b < bases.length() { let mut new_codon = "" @@ -185,7 +233,7 @@ fn count_sites(codon1 : String, codon2 : String, codon_table : Map[String, Strin } p = p + 1 } - + if codon_table.contains(new_codon) && codon_table[new_codon] == aa1 { syn_count = syn_count + 1 break @@ -195,9 +243,12 @@ fn count_sites(codon1 : String, codon2 : String, codon_table : Map[String, Strin } pos = pos + 1 } - + if all_count > 0 { - return (syn_count.to_double() / all_count.to_double(), (all_count - syn_count).to_double() / all_count.to_double()) + return ( + syn_count.to_double() / all_count.to_double(), + (all_count - syn_count).to_double() / all_count.to_double(), + ) } else { return (0.333, 0.667) } @@ -220,15 +271,15 @@ fn paml_jukes_cantor_correction(p : Double) -> Double { ///| pub fn paml_estimate_parameters(alignment : PAMLAlignment) -> PAMLResult { let result = PAMLResult::new(-100.0) - + let n_seqs = alignment.sequences.length() let seq_len = if n_seqs > 0 { alignment.sequences[0].1.length() } else { 0 } - + let mut pi_A = 0.0 let mut pi_T = 0.0 let mut pi_C = 0.0 let mut pi_G = 0.0 - + let mut total = 0 let mut s = 0 while s < n_seqs { @@ -250,13 +301,13 @@ pub fn paml_estimate_parameters(alignment : PAMLAlignment) -> PAMLResult { } s = s + 1 } - + let denom = total.to_double() pi_A = pi_A / denom pi_T = pi_T / denom pi_C = pi_C / denom pi_G = pi_G / denom - + let params = result.parameters.copy() params.set("pi_A", pi_A) params.set("pi_T", pi_T) @@ -264,41 +315,44 @@ pub fn paml_estimate_parameters(alignment : PAMLAlignment) -> PAMLResult { params.set("pi_G", pi_G) params.set("kappa", 2.0) params.set("omega", 0.5) - + PAMLResult::{ ln_likelihood: -seq_len.to_double() * @math.log2(0.25), parameters: params, dnds_ratios: result.dnds_ratios, substitution_rates: result.substitution_rates, - ancestral_sequences: result.ancestral_sequences + ancestral_sequences: result.ancestral_sequences, } } ///| -pub fn paml_calculate_substitution_matrix(kappa : Double, pi : Map[String, Double]) -> Array[Array[Double]] { +pub fn paml_calculate_substitution_matrix( + kappa : Double, + pi : Map[String, Double], +) -> Array[Array[Double]] { let q = Array::make(4, Array::make(4, 0.0)) - + let pi_A = pi.get("pi_A").unwrap_or(0.25) let pi_T = pi.get("pi_T").unwrap_or(0.25) let pi_C = pi.get("pi_C").unwrap_or(0.25) let pi_G = pi.get("pi_G").unwrap_or(0.25) - + q[0][1] = kappa * pi_T q[0][2] = pi_C q[0][3] = pi_G - + q[1][0] = kappa * pi_A q[1][2] = pi_C q[1][3] = pi_G - + q[2][0] = pi_A q[2][1] = pi_T q[2][3] = kappa * pi_G - + q[3][0] = pi_A q[3][1] = pi_T q[3][2] = kappa * pi_C - + let mut i = 0 while i < 4 { let mut sum = 0.0 @@ -312,7 +366,7 @@ pub fn paml_calculate_substitution_matrix(kappa : Double, pi : Map[String, Doubl q[i][i] = -sum i = i + 1 } - + q } @@ -322,23 +376,23 @@ pub fn paml_create_example_alignment() -> PAMLAlignment { ("Human", "ATGGCCGGTAAATGA"), ("Mouse", "ATGGCCGGTAAATGA"), ("Rat", "ATGGCCGGTAATAGA"), - ("Chicken", "ATGGCCGGTAATGGA") + ("Chicken", "ATGGCCGGTAATGGA"), ] - + let alignment = PAMLAlignment::new(seqs) PAMLAlignment::{ sequences: alignment.sequences, tree: "((Human,Mouse),Rat,Chicken)", - model: "HKY85" + model: "HKY85", } } ///| pub fn paml_run_likelihood(alignment : PAMLAlignment) -> PAMLResult { let result = paml_estimate_parameters(alignment) - + let dnds_results : Array[(String, Double)] = Array::new() - + let seqs = alignment.sequences let mut i = 0 while i < seqs.length() { @@ -350,12 +404,12 @@ pub fn paml_run_likelihood(alignment : PAMLAlignment) -> PAMLResult { } i = i + 1 } - + PAMLResult::{ ln_likelihood: result.ln_likelihood, parameters: result.parameters, dnds_ratios: dnds_results, substitution_rates: result.substitution_rates, - ancestral_sequences: result.ancestral_sequences + ancestral_sequences: result.ancestral_sequences, } -} \ No newline at end of file +} diff --git a/src/parsimony.mbt b/src/parsimony.mbt index 6ebb70b0..e1b522b7 100644 --- a/src/parsimony.mbt +++ b/src/parsimony.mbt @@ -24,7 +24,7 @@ pub struct ParsimonyMatrix { /// Create a parsimony cost matrix. pub fn ParsimonyMatrix::new( states : Array[String], - costs : Array[Array[Double]] + costs : Array[Array[Double]], ) -> ParsimonyMatrix { ParsimonyMatrix::{ states, costs } } @@ -34,7 +34,7 @@ pub fn ParsimonyMatrix::new( pub fn parsimony_matrix_cost( matrix : ParsimonyMatrix, from_idx : Int, - to_idx : Int + to_idx : Int, ) -> Double { matrix.costs[from_idx][to_idx] } @@ -71,7 +71,7 @@ pub fn parsimony_fitch_dna_matrix() -> ParsimonyMatrix { /// Transitions (A<->G, C<->T) cost 1, transversions cost 2. pub fn parsimony_sankoff_dna_matrix( transition_cost? : Double = 1.0, - transversion_cost? : Double = 2.0 + transversion_cost? : Double = 2.0, ) -> ParsimonyMatrix { let states = ["A", "C", "G", "T"] let costs = [ @@ -92,7 +92,7 @@ pub fn parsimony_sankoff_dna_matrix( /// - The total score is the sum of costs across all positions. pub fn fitch_parsimony_score( tree : Tree, - alignment : Map[String, String] + alignment : Map[String, String], ) -> Double { if alignment.size() == 0 { return -1.0 @@ -120,7 +120,7 @@ pub fn fitch_parsimony_score( fn fitch_score_position( clade : Clade, alignment : Map[String, String], - pos : Int + pos : Int, ) -> Double { let (states, score) = fitch_compute_states(clade, alignment, pos) ignore(states) @@ -134,7 +134,7 @@ fn fitch_score_position( fn fitch_compute_states( clade : Clade, alignment : Map[String, String], - pos : Int + pos : Int, ) -> (Array[String], Double) { if clade.is_terminal() { let name = match clade.name { @@ -158,7 +158,11 @@ fn fitch_compute_states( let mut first = true let mut ci = 0 while ci < clade.clades.length() { - let (child_states, child_score) = fitch_compute_states(clade.clades[ci], alignment, pos) + let (child_states, child_score) = fitch_compute_states( + clade.clades[ci], + alignment, + pos, + ) total_score = total_score + child_score if first { combined = child_states @@ -180,7 +184,10 @@ fn fitch_compute_states( ///| /// Compute the intersection of two state sets. -fn fitch_set_intersection(a : Array[String], b : Array[String]) -> Array[String] { +fn fitch_set_intersection( + a : Array[String], + b : Array[String], +) -> Array[String] { let result : Array[String] = Array::new() let mut i = 0 while i < a.length() { @@ -238,7 +245,7 @@ fn fitch_set_union(a : Array[String], b : Array[String]) -> Array[String] { pub fn sankoff_parsimony_score( tree : Tree, alignment : Map[String, String], - matrix : ParsimonyMatrix + matrix : ParsimonyMatrix, ) -> Double { if alignment.size() == 0 { return -1.0 @@ -255,7 +262,8 @@ pub fn sankoff_parsimony_score( let mut total_score = 0.0 let mut pos = 0 while pos < aln_len { - total_score = total_score + sankoff_score_position(tree.root, alignment, pos, matrix) + total_score = total_score + + sankoff_score_position(tree.root, alignment, pos, matrix) pos = pos + 1 } total_score @@ -267,7 +275,7 @@ fn sankoff_score_position( clade : Clade, alignment : Map[String, String], pos : Int, - matrix : ParsimonyMatrix + matrix : ParsimonyMatrix, ) -> Double { let scores = sankoff_compute_scores(clade, alignment, pos, matrix) let mut min_score = 1.0e30 @@ -278,7 +286,11 @@ fn sankoff_score_position( } i = i + 1 } - if min_score >= 1.0e30 { 0.0 } else { min_score } + if min_score >= 1.0e30 { + 0.0 + } else { + min_score + } } ///| @@ -288,7 +300,7 @@ fn sankoff_compute_scores( clade : Clade, alignment : Map[String, String], pos : Int, - matrix : ParsimonyMatrix + matrix : ParsimonyMatrix, ) -> Array[Double] { let n_states = matrix.states.length() if clade.is_terminal() { @@ -341,7 +353,7 @@ fn sankoff_compute_scores( pub fn parsimony_get_score( tree : Tree, alignment : Map[String, String], - matrix? : ParsimonyMatrix? = None + matrix? : ParsimonyMatrix? = None, ) -> Double { match matrix { Some(m) => sankoff_parsimony_score(tree, alignment, m) diff --git a/src/pathway.mbt b/src/pathway.mbt index 0ca03c7e..6aa49c7d 100644 --- a/src/pathway.mbt +++ b/src/pathway.mbt @@ -22,7 +22,13 @@ pub struct Reaction { } ///| -pub fn Reaction::new(id : String, name : String, reactants : Array[String], products : Array[String], reversible : Bool) -> Reaction { +pub fn Reaction::new( + id : String, + name : String, + reactants : Array[String], + products : Array[String], + reversible : Bool, +) -> Reaction { Reaction::{ id, name, reactants, products, reversible } } @@ -43,7 +49,12 @@ pub struct Pathway { } ///| -pub fn Pathway::new(id : String, name : String, species : Array[Species], reactions : Array[Reaction]) -> Pathway { +pub fn Pathway::new( + id : String, + name : String, + species : Array[Species], + reactions : Array[Reaction], +) -> Pathway { Pathway::{ id, name, species, reactions } } @@ -60,13 +71,16 @@ pub fn pathway_find_species(pathway : Pathway, id : String) -> Species? { } ///| -pub fn pathway_find_reactions_with_species(pathway : Pathway, species_id : String) -> Array[Reaction] { +pub fn pathway_find_reactions_with_species( + pathway : Pathway, + species_id : String, +) -> Array[Reaction] { let result : Array[Reaction] = Array::new() - + let mut i = 0 while i < pathway.reactions.length() { let reaction = pathway.reactions[i] - + let mut j = 0 while j < reaction.reactants.length() { if reaction.reactants[j] == species_id { @@ -75,7 +89,7 @@ pub fn pathway_find_reactions_with_species(pathway : Pathway, species_id : Strin } j = j + 1 } - + if j == reaction.reactants.length() { j = 0 while j < reaction.products.length() { @@ -86,10 +100,10 @@ pub fn pathway_find_reactions_with_species(pathway : Pathway, species_id : Strin j = j + 1 } } - + i = i + 1 } - + result } @@ -117,7 +131,7 @@ pub fn create_example_pathway() -> Pathway { let f16bp = Species::new("f16bp", "Fructose-1,6-bisphosphate") let dhap = Species::new("dhap", "Dihydroxyacetone phosphate") let g3p = Species::new("g3p", "Glyceraldehyde-3-phosphate") - + let species : Array[Species] = Array::new() species.push(glucose) species.push(g6p) @@ -125,44 +139,48 @@ pub fn create_example_pathway() -> Pathway { species.push(f16bp) species.push(dhap) species.push(g3p) - + let reactants1 : Array[String] = Array::new() reactants1.push("glucose") let products1 : Array[String] = Array::new() products1.push("g6p") let r1 = Reaction::new("r1", "Hexokinase", reactants1, products1, false) - + let reactants2 : Array[String] = Array::new() reactants2.push("g6p") let products2 : Array[String] = Array::new() products2.push("f6p") let r2 = Reaction::new("r2", "Isomerase", reactants2, products2, true) - + let reactants3 : Array[String] = Array::new() reactants3.push("f6p") let products3 : Array[String] = Array::new() products3.push("f16bp") - let r3 = Reaction::new("r3", "Phosphofructokinase", reactants3, products3, false) - + let r3 = Reaction::new( + "r3", "Phosphofructokinase", reactants3, products3, false, + ) + let reactants4 : Array[String] = Array::new() reactants4.push("f16bp") let products4 : Array[String] = Array::new() products4.push("dhap") products4.push("g3p") let r4 = Reaction::new("r4", "Aldolase", reactants4, products4, true) - + let reactants5 : Array[String] = Array::new() reactants5.push("dhap") let products5 : Array[String] = Array::new() products5.push("g3p") - let r5 = Reaction::new("r5", "Triose-phosphate isomerase", reactants5, products5, true) - + let r5 = Reaction::new( + "r5", "Triose-phosphate isomerase", reactants5, products5, true, + ) + let reactions : Array[Reaction] = Array::new() reactions.push(r1) reactions.push(r2) reactions.push(r3) reactions.push(r4) reactions.push(r5) - + Pathway::new("glycolysis", "Glycolysis", species, reactions) -} \ No newline at end of file +} diff --git a/src/pcatools.mbt b/src/pcatools.mbt index 7b0d62f7..176dd51e 100644 --- a/src/pcatools.mbt +++ b/src/pcatools.mbt @@ -8,11 +8,16 @@ // ---------- helper linear algebra / stats primitives ---------- -fn pca_is_na(x : Double) -> Bool { x.is_nan() } +fn pca_is_na(x : Double) -> Bool { + x.is_nan() +} +///| fn pca_transpose(a : Array[Array[Double]]) -> Array[Array[Double]] { let n = a.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let m = a[0].length() let out : Array[Array[Double]] = Array::new() let mut j = 0 @@ -29,22 +34,28 @@ fn pca_transpose(a : Array[Array[Double]]) -> Array[Array[Double]] { out } +///| fn pca_copy(a : Array[Array[Double]]) -> Array[Array[Double]] { let out : Array[Array[Double]] = Array::new() for row in a { let nr : Array[Double] = Array::new() - for x in row { nr.push(x) } + for x in row { + nr.push(x) + } out.push(nr) } out } +///| fn center_and_scale_cols( data : Array[Array[Double]], scale : Bool, ) -> (Array[Array[Double]], Array[Double], Array[Double]) { let n = data.length() - if n == 0 { return ([], [], []) } + if n == 0 { + return ([], [], []) + } let p = data[0].length() let means : Array[Double] = Array::new() let sds : Array[Double] = Array::new() @@ -76,16 +87,8 @@ fn center_and_scale_cols( } i2 = i2 + 1 } - let variance = if c2 < 2 { - 1.0 - } else { - s2 / (c2 - 1).to_double() - } - let sd = if variance <= 0.0 { - 1.0 - } else { - variance.sqrt() - } + let variance = if c2 < 2 { 1.0 } else { s2 / (c2 - 1).to_double() } + let sd = if variance <= 0.0 { 1.0 } else { variance.sqrt() } sds.push(sd) } else { sds.push(1.0) @@ -110,11 +113,12 @@ fn center_and_scale_cols( (out, means, sds) } -fn compute_covariance_matrix( - x : Array[Array[Double]], -) -> Array[Array[Double]] { +///| +fn compute_covariance_matrix(x : Array[Array[Double]]) -> Array[Array[Double]] { let n = x.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let p = x[0].length() let out : Array[Array[Double]] = Array::new() let denom = (if n - 1 < 1 { 1 } else { n - 1 }).to_double() @@ -138,12 +142,15 @@ fn compute_covariance_matrix( out } +///| fn power_iteration_pca( cov : Array[Array[Double]], n_components : Int, ) -> (Array[Array[Double]], Array[Double]) { let p = cov.length() - if p == 0 { return ([], []) } + if p == 0 { + return ([], []) + } let k = if n_components < 1 { 1 } else if n_components > p { @@ -160,11 +167,7 @@ fn power_iteration_pca( let mut v : Array[Double] = Array::new() let mut ii = 0 while ii < p { - let vv = if ii == comp { - 1.0 - } else { - 0.5.pow(comp.to_double()) - } + let vv = if ii == comp { 1.0 } else { 0.5.pow(comp.to_double()) } v.push(vv) ii = ii + 1 } @@ -202,7 +205,9 @@ fn power_iteration_pca( kk = kk + 1 } let nrm = if nrm2 == 0.0 { 0.0 } else { nrm2.sqrt() } - if nrm < zero_eps { break } + if nrm < zero_eps { + break + } let mut kk2 = 0 while kk2 < p { v_new[kk2] = v_new[kk2] / nrm @@ -229,10 +234,14 @@ fn power_iteration_pca( } v = v_new eig = rq - if diff.sqrt() < 0.00000001 { break } + if diff.sqrt() < 0.00000001 { + break + } iter_count = iter_count + 1 } - if eig < 0.0 { eig = 0.0 } + if eig < 0.0 { + eig = 0.0 + } eigvecs_rows.push(v) eigvals.push(eig) // deflate @@ -251,12 +260,15 @@ fn power_iteration_pca( (v_cols, eigvals) } +///| fn pca_matmul( a : Array[Array[Double]], b : Array[Array[Double]], ) -> Array[Array[Double]] { let n = a.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let ka = a[0].length() let kb = b.length() let p = if kb == 0 { 0 } else { b[0].length() } @@ -282,9 +294,12 @@ fn pca_matmul( out } +///| fn compute_variance_explained(eigvals : Array[Double]) -> Array[Double] { let mut total = 0.0 - for e in eigvals { total = total + e } + for e in eigvals { + total = total + e + } let out : Array[Double] = Array::new() if total == 0.0 { for e in eigvals { @@ -292,11 +307,14 @@ fn compute_variance_explained(eigvals : Array[Double]) -> Array[Double] { out.push(0.0) } } else { - for e in eigvals { out.push(e / total) } + for e in eigvals { + out.push(e / total) + } } out } +///| fn compute_cumulative(x : Array[Double]) -> Array[Double] { let out : Array[Double] = Array::new() let mut s = 0.0 @@ -309,6 +327,7 @@ fn compute_cumulative(x : Array[Double]) -> Array[Double] { // ---------- FullPCAResult ---------- +///| pub struct FullPCAResult { pub scores : Array[Array[Double]] pub loadings : Array[Array[Double]] @@ -323,6 +342,7 @@ pub struct FullPCAResult { pub used_scaling : Bool } +///| pub fn pcatools_run_pca( data : Array[Array[Double]], n_components : Int, @@ -350,13 +370,17 @@ pub fn pcatools_run_pca( let variance_explained = compute_variance_explained(eigvals) let cumulative_variance = compute_cumulative(variance_explained) FullPCAResult::{ - scores: scores, + scores, loadings: eigvecs, eigenvalues: eigvals, - variance_explained: variance_explained, - cumulative_variance: cumulative_variance, + variance_explained, + cumulative_variance, n_samples: data.length(), - n_variables: if data.length() == 0 { 0 } else { data[0].length() }, + n_variables: if data.length() == 0 { + 0 + } else { + data[0].length() + }, n_components: eigvals.length(), center: means, scale: sds, @@ -364,16 +388,29 @@ pub fn pcatools_run_pca( } } +///| pub fn pcatools_summary(res : FullPCAResult) -> String { let buf = StringBuilder::new() - buf.write_string("PCAResult: \{res.n_samples} samples, \{res.n_variables} variables\n") - buf.write_string(" components = \{res.n_components}, scaling = \{res.used_scaling}\n") + buf.write_string( + "PCAResult: \{res.n_samples} samples, \{res.n_variables} variables\n", + ) + buf.write_string( + " components = \{res.n_components}, scaling = \{res.used_scaling}\n", + ) let k = if res.n_components < 8 { res.n_components } else { 8 } let mut i = 0 while i < k { let ev = if i < res.eigenvalues.length() { res.eigenvalues[i] } else { 0.0 } - let ve = if i < res.variance_explained.length() { res.variance_explained[i] } else { 0.0 } - let cv = if i < res.cumulative_variance.length() { res.cumulative_variance[i] } else { 0.0 } + let ve = if i < res.variance_explained.length() { + res.variance_explained[i] + } else { + 0.0 + } + let cv = if i < res.cumulative_variance.length() { + res.cumulative_variance[i] + } else { + 0.0 + } buf.write_string(" PC\{i+1}: eig=\{ev} var=\{ve} cum=\{cv}\n") i = i + 1 } @@ -385,19 +422,24 @@ pub fn pcatools_summary(res : FullPCAResult) -> String { // ---------- scree_plot_ascii ---------- +///| pub fn scree_plot_ascii( res : FullPCAResult, height? : Int = 8, width_per_pc? : Int = 3, ) -> String { let k = res.variance_explained.length() - if k == 0 { return "(no PCs available for scree plot)".to_string() } + if k == 0 { + return "(no PCs available for scree plot)".to_string() + } let buf = StringBuilder::new() let mut max_ve = 0.0 if res.variance_explained.length() > 0 { max_ve = res.variance_explained[0] for x in res.variance_explained { - if x > max_ve { max_ve = x } + if x > max_ve { + max_ve = x + } } } let mm = if max_ve == 0.0 { 1.0 } else { max_ve } @@ -408,17 +450,15 @@ pub fn scree_plot_ascii( let threshold = frac * mm let mut i = 0 while i < k { - let cell = if res.variance_explained[i] >= threshold { - "#" - } else { - " " - } + let cell = if res.variance_explained[i] >= threshold { "#" } else { " " } let mut w = 0 while w < width_per_pc { buf.write_string(cell) w = w + 1 } - if i + 1 < k { buf.write_string(" ") } + if i + 1 < k { + buf.write_string(" ") + } i = i + 1 } buf.write_string(" \{threshold}\n") @@ -444,6 +484,7 @@ pub fn scree_plot_ascii( // ---------- pca_biplot_ascii ---------- +///| pub struct BiplotOptions { pub pc_x : Int pub pc_y : Int @@ -452,16 +493,12 @@ pub struct BiplotOptions { pub max_loadings : Int } +///| pub fn BiplotOptions::new() -> BiplotOptions { - BiplotOptions::{ - pc_x: 1, - pc_y: 2, - width: 60, - height: 20, - max_loadings: 8, - } + BiplotOptions::{ pc_x: 1, pc_y: 2, width: 60, height: 20, max_loadings: 8 } } +///| pub fn pca_biplot_ascii( res : FullPCAResult, opts? : BiplotOptions = BiplotOptions::new(), @@ -489,10 +526,18 @@ pub fn pca_biplot_ascii( let mut ymin = res.scores[0][iy] let mut ymax = ymin for s in res.scores { - if s[ix] < xmin { xmin = s[ix] } - if s[ix] > xmax { xmax = s[ix] } - if s[iy] < ymin { ymin = s[iy] } - if s[iy] > ymax { ymax = s[iy] } + if s[ix] < xmin { + xmin = s[ix] + } + if s[ix] > xmax { + xmax = s[ix] + } + if s[iy] < ymin { + ymin = s[iy] + } + if s[iy] > ymax { + ymax = s[iy] + } } let xr = if xmax - xmin == 0.0 { 1.0 } else { xmax - xmin } let yr = if ymax - ymin == 0.0 { 1.0 } else { ymax - ymin } @@ -528,13 +573,17 @@ pub fn pca_biplot_ascii( let mut c_axis = 0 while c_axis < w { let ch = grid[oyr][c_axis] - if ch == ' '.to_int() { grid[oyr][c_axis] = '-'.to_int() } + if ch == ' '.to_int() { + grid[oyr][c_axis] = '-'.to_int() + } c_axis = c_axis + 1 } let mut r_axis = 0 while r_axis < h { let ch = grid[r_axis][oxc] - if ch == ' '.to_int() { grid[r_axis][oxc] = '|'.to_int() } + if ch == ' '.to_int() { + grid[r_axis][oxc] = '|'.to_int() + } r_axis = r_axis + 1 } // loadings @@ -549,7 +598,13 @@ pub fn pca_biplot_ascii( idx = idx + 1 } ranked.sort_by(fn(p : (Int, Double), q : (Int, Double)) -> Int { - if p.1 > q.1 { -1 } else if p.1 < q.1 { 1 } else { 0 } + if p.1 > q.1 { + -1 + } else if p.1 < q.1 { + 1 + } else { + 0 + } }) let lm = if opts.max_loadings < 1 { 1 } else { opts.max_loadings } let ntop = if lm < ranked.length() { lm } else { ranked.length() } @@ -560,10 +615,14 @@ pub fn pca_biplot_ascii( let lx = res.loadings[idxi][ix] let ly = res.loadings[idxi][iy] let m_val = (lx * lx + ly * ly).sqrt() - if m_val > lmax { lmax = m_val } + if m_val > lmax { + lmax = m_val + } t = t + 1 } - if lmax == 0.0 { lmax = 1.0 } + if lmax == 0.0 { + lmax = 1.0 + } let mut t2 = 0 while t2 < ntop { let idxi = ranked[t2].0 @@ -611,6 +670,7 @@ pub fn pca_biplot_ascii( // ---------- find_pca_outliers ---------- +///| pub struct PCAOutlierResult { pub indices : Array[Int] pub scores : Array[Double] @@ -618,12 +678,23 @@ pub struct PCAOutlierResult { pub cutoff : Double } +///| fn quantile_simple(xs_in : Array[Double], q : Double) -> Double { - if xs_in.length() == 0 { return 0.0 } + if xs_in.length() == 0 { + return 0.0 + } let xs : Array[Double] = Array::new() - for x in xs_in { xs.push(x) } + for x in xs_in { + xs.push(x) + } xs.sort_by(fn(a : Double, b : Double) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) let n = xs.length() let qq = if q < 0.0 { 0.0 } else if q > 1.0 { 1.0 } else { q } @@ -634,6 +705,7 @@ fn quantile_simple(xs_in : Array[Double], q : Double) -> Double { xs[lo] * (1.0 - frac) + xs[hi] * frac } +///| pub fn find_pca_outliers( res : FullPCAResult, n_pcs? : Int = 5, @@ -641,13 +713,7 @@ pub fn find_pca_outliers( ) -> PCAOutlierResult { let n = res.scores.length() let k_total = res.n_components - let k = if n_pcs < 1 { - 1 - } else if n_pcs > k_total { - k_total - } else { - n_pcs - } + let k = if n_pcs < 1 { 1 } else if n_pcs > k_total { k_total } else { n_pcs } if n == 0 || k == 0 { return PCAOutlierResult::{ indices: [], @@ -689,19 +755,22 @@ pub fn find_pca_outliers( indices: outliers, scores: out_scores, n_tested: n, - cutoff: cutoff, + cutoff, } } // ---------- variable_correlations ---------- +///| pub fn variable_correlations( data : Array[Array[Double]], res : FullPCAResult, which_pcs? : Int = 5, ) -> Array[Array[Double]] { let n = data.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let p = data[0].length() let k = if which_pcs < 1 { 1 @@ -787,18 +856,8 @@ pub fn variable_correlations( } ii = ii + 1 } - let r = if c3 < 2 { - 0.0 - } else { - sum_prod / (c3 - 1).to_double() - } - let rclamp = if r > 1.0 { - 1.0 - } else if r < -1.0 { - -1.0 - } else { - r - } + let r = if c3 < 2 { 0.0 } else { sum_prod / (c3 - 1).to_double() } + let rclamp = if r > 1.0 { 1.0 } else if r < -1.0 { -1.0 } else { r } row.push(rclamp) tt = tt + 1 } diff --git a/src/pcd.mbt b/src/pcd.mbt index e5ca7ade..c57f52c4 100644 --- a/src/pcd.mbt +++ b/src/pcd.mbt @@ -28,10 +28,7 @@ pub struct PcdSpectrum { ///| /// Construct a PcdSpectrum. -pub fn PcdSpectrum::new( - scan_number : Int, - rt? : Double = 0.0 -) -> PcdSpectrum { +pub fn PcdSpectrum::new(scan_number : Int, rt? : Double = 0.0) -> PcdSpectrum { PcdSpectrum::{ scan_number, rt, @@ -50,13 +47,20 @@ pub fn PcdSpectrum::set_precursor_mz(self : PcdSpectrum, mz : Double?) -> Unit { ///| /// Set precursor charge. -pub fn PcdSpectrum::set_precursor_charge(self : PcdSpectrum, charge : Int?) -> Unit { +pub fn PcdSpectrum::set_precursor_charge( + self : PcdSpectrum, + charge : Int?, +) -> Unit { self.precursor_charge = charge } ///| /// Add a peak to the spectrum. -pub fn PcdSpectrum::add_peak(self : PcdSpectrum, mz : Double, intensity : Double) -> Unit { +pub fn PcdSpectrum::add_peak( + self : PcdSpectrum, + mz : Double, + intensity : Double, +) -> Unit { self.mz_values.push(mz) self.intensity_values.push(intensity) } @@ -119,7 +123,11 @@ pub fn PcdFile::add_spectrum(self : PcdFile, spectrum : PcdSpectrum) -> Unit { ///| /// Set metadata key-value pair. -pub fn PcdFile::set_metadata(self : PcdFile, key : String, val : String) -> Unit { +pub fn PcdFile::set_metadata( + self : PcdFile, + key : String, + val : String, +) -> Unit { self.metadata[key] = val } @@ -163,7 +171,11 @@ pub struct PcdPeak { ///| /// Construct a PcdPeak. -pub fn PcdPeak::new(mz : Double, intensity : Double, charge? : Int = 0) -> PcdPeak { +pub fn PcdPeak::new( + mz : Double, + intensity : Double, + charge? : Int = 0, +) -> PcdPeak { let charge_opt = if charge > 0 { Some(charge) } else { None } PcdPeak::{ mz, intensity, charge: charge_opt } } @@ -243,9 +255,7 @@ fn pcd_parse_header_into(line : String, file : PcdFile) -> Unit { file.set_version(val) } } - None => { - file.set_metadata(content, "") - } + None => file.set_metadata(content, "") } } @@ -288,15 +298,13 @@ fn pcd_parse_scan_line(line : String) -> PcdSpectrum { } pepmass_mz = Some(pcd_parse_double(mz_str)) } - None => { - pepmass_mz = Some(pcd_parse_double(pepmass_str)) - } + None => pepmass_mz = Some(pcd_parse_double(pepmass_str)) } } } i = i + 1 } - let spec = PcdSpectrum::new(scan_number, rt=rt) + let spec = PcdSpectrum::new(scan_number, rt~) spec.set_precursor_mz(pepmass_mz) spec.set_precursor_charge(pepmass_charge) spec @@ -306,11 +314,13 @@ fn pcd_parse_scan_line(line : String) -> PcdSpectrum { /// Parse a peak line (e.g., "500.5 10000" or "500.5 10000 2"). fn pcd_parse_peak_line(line : String) -> PcdPeak? { let parts = pcd_split_whitespace(line) - if parts.length() < 2 { return None } + if parts.length() < 2 { + return None + } let mz = pcd_parse_double(parts[0]) let intensity = pcd_parse_double(parts[1]) let charge = if parts.length() > 2 { pcd_parse_int(parts[2]) } else { 0 } - Some(PcdPeak::new(mz, intensity, charge=charge)) + Some(PcdPeak::new(mz, intensity, charge~)) } // ============================================================================ @@ -319,7 +329,11 @@ fn pcd_parse_peak_line(line : String) -> PcdPeak? { ///| /// Get spectra within a retention time range. -pub fn pcd_spectra_by_rt(file : PcdFile, min_rt : Double, max_rt : Double) -> Array[PcdSpectrum] { +pub fn pcd_spectra_by_rt( + file : PcdFile, + min_rt : Double, + max_rt : Double, +) -> Array[PcdSpectrum] { let result : Array[PcdSpectrum] = Array::new() let mut i = 0 while i < file.spectra.length() { @@ -368,7 +382,10 @@ pub fn pcd_bpc(file : PcdFile) -> Array[Double] { ///| /// Find peaks above a threshold intensity in all spectra. -pub fn pcd_find_peaks_above(file : PcdFile, threshold : Double) -> Array[(Int, Double, Double)] { +pub fn pcd_find_peaks_above( + file : PcdFile, + threshold : Double, +) -> Array[(Int, Double, Double)] { let peaks : Array[(Int, Double, Double)] = Array::new() let mut i = 0 while i < file.spectra.length() { @@ -387,7 +404,11 @@ pub fn pcd_find_peaks_above(file : PcdFile, threshold : Double) -> Array[(Int, D ///| /// Filter spectrum by m/z range. -pub fn pcd_spectrum_by_mz(spectrum : PcdSpectrum, min_mz : Double, max_mz : Double) -> PcdSpectrum { +pub fn pcd_spectrum_by_mz( + spectrum : PcdSpectrum, + min_mz : Double, + max_mz : Double, +) -> PcdSpectrum { let result = PcdSpectrum::new(spectrum.scan_number, rt=spectrum.rt) result.set_precursor_mz(spectrum.precursor_mz) result.set_precursor_charge(spectrum.precursor_charge) @@ -448,7 +469,11 @@ pub fn pcd_write(file : PcdFile) -> String { out = out + "\n" let mut j = 0 while j < s.mz_values.length() { - out = out + s.mz_values[j].to_string() + " " + s.intensity_values[j].to_string() + "\n" + out = out + + s.mz_values[j].to_string() + + " " + + s.intensity_values[j].to_string() + + "\n" j = j + 1 } out = out + "\n" @@ -465,27 +490,10 @@ pub fn pcd_write(file : PcdFile) -> String { /// Generate a sample PCD text for testing. pub fn pcd_sample() -> String { let lines = [ - "#version: 1.0", - "#instrument: TestMassSpec", - "#date: 2024-01-01", - "SCAN 1 RT 1.0 PEPMASS 500.5(2)", - "500.1 10000", - "500.5 25000", - "500.8 5000", - "600.2 8000", - "", - "SCAN 2 RT 2.5 PEPMASS 600.3(3)", - "500.1 5000", - "600.3 30000", - "600.5 15000", - "700.1 2000", - "", - "SCAN 3 RT 5.0 PEPMASS 700.1(2)", - "500.2 3000", - "700.1 40000", - "700.5 10000", - "800.2 5000", - "", + "#version: 1.0", "#instrument: TestMassSpec", "#date: 2024-01-01", "SCAN 1 RT 1.0 PEPMASS 500.5(2)", + "500.1 10000", "500.5 25000", "500.8 5000", "600.2 8000", "", "SCAN 2 RT 2.5 PEPMASS 600.3(3)", + "500.1 5000", "600.3 30000", "600.5 15000", "700.1 2000", "", "SCAN 3 RT 5.0 PEPMASS 700.1(2)", + "500.2 3000", "700.1 40000", "700.5 10000", "800.2 5000", "", ] let mut result = "" let mut i = 0 @@ -533,7 +541,9 @@ fn pcd_split_lines(content : String) -> Array[String] { if start < i { lines.push(content[start:i].trim().to_string()) } - if ch == "\r" && i + 1 < content.length() && content[i + 1:i + 2].to_owned() == "\n" { + if ch == "\r" && + i + 1 < content.length() && + content[i + 1:i + 2].to_owned() == "\n" { i = i + 1 } start = i + 1 @@ -575,13 +585,17 @@ fn pcd_split_whitespace(line : String) -> Array[String] { fn pcd_parse_int(s : String) -> Int { let sv = s.to_string().trim() let n = sv.length() - if n == 0 { return 0 } + if n == 0 { + return 0 + } let mut result = 0 let mut i = 0 let zero = '0'.to_int() while i < n { let c = sv.unsafe_get(i).to_int() - if c < zero || c > zero + 9 { break } + if c < zero || c > zero + 9 { + break + } result = result * 10 + (c - zero) i = i + 1 } @@ -592,7 +606,9 @@ fn pcd_parse_int(s : String) -> Int { /// Parse a double from a string, returning 0.0 on failure. fn pcd_parse_double(s : String) -> Double { let sv = s.to_string().trim() - if sv.length() == 0 { return 0.0 } + if sv.length() == 0 { + return 0.0 + } let n = sv.length() let mut result = 0.0 let mut decimal = 0 @@ -605,7 +621,9 @@ fn pcd_parse_double(s : String) -> Double { } while i < n { let c = sv.unsafe_get(i).to_int() - if c < zero || c > zero + 9 { break } + if c < zero || c > zero + 9 { + break + } result = result * 10.0 + (c - zero).to_double() i = i + 1 } @@ -613,7 +631,9 @@ fn pcd_parse_double(s : String) -> Double { i = i + 1 while i < n { let c = sv.unsafe_get(i).to_int() - if c < zero || c > zero + 9 { break } + if c < zero || c > zero + 9 { + break + } result = result * 10.0 + (c - zero).to_double() decimal = decimal + 1 i = i + 1 diff --git a/src/pdb_analysis.mbt b/src/pdb_analysis.mbt index b3122ea1..306ab3a1 100644 --- a/src/pdb_analysis.mbt +++ b/src/pdb_analysis.mbt @@ -628,15 +628,33 @@ pub fn create_demo_structure() -> Structure { pub fn vdw_radius(atom_name : String) -> Double { let name = atom_name.to_upper() // Carbon atoms - if name == "C" || name == "CA" || name == "CB" || name == "CG" || name == "CD" || name == "CE" || name == "CZ" || name == "CZ" { + if name == "C" || + name == "CA" || + name == "CB" || + name == "CG" || + name == "CD" || + name == "CE" || + name == "CZ" || + name == "CZ" { return 1.7 } // Nitrogen atoms - if name == "N" || name == "NZ" || name == "ND" || name == "NE" || name == "NH" || name == "NZ" { + if name == "N" || + name == "NZ" || + name == "ND" || + name == "NE" || + name == "NH" || + name == "NZ" { return 1.55 } // Oxygen atoms - if name == "O" || name == "OH" || name == "OG" || name == "OD" || name == "OE" || name == "OT1" || name == "OT2" { + if name == "O" || + name == "OH" || + name == "OG" || + name == "OD" || + name == "OE" || + name == "OT1" || + name == "OT2" { return 1.52 } // Sulfur atoms @@ -648,7 +666,7 @@ pub fn vdw_radius(atom_name : String) -> Double { return 1.8 } // Hydrogen atoms - if name == "H" || name.length() > 0 && name[0:1] == "H" { + if name == "H" || (name.length() > 0 && name[0:1] == "H") { return 1.2 } // Default for unknown atoms @@ -661,16 +679,16 @@ pub fn vdw_radius(atom_name : String) -> Double { fn generate_sphere_points(n_points : Int) -> Array[Vector3] { let points : Array[Vector3] = Array::new() let golden_angle = 3.14159265358979323846 * (3.0 - 5.0.sqrt()) - + let mut i = 0 while i < n_points { - let y = 1.0 - (2.0 * i.to_double()) / (n_points.to_double() - 1.0) + let y = 1.0 - 2.0 * i.to_double() / (n_points.to_double() - 1.0) let radius_at_y = (1.0 - y * y).sqrt() let theta = golden_angle * i.to_double() - + let x = @math.cos(theta) * radius_at_y let z = @math.sin(theta) * radius_at_y - + points.push(Vector3::new(x, y, z)) i = i + 1 } @@ -689,7 +707,7 @@ pub fn calc_sasa( ) -> Array[(String, Double)] { let result : Array[(String, Double)] = Array::new() let residues = chain.get_residues() - + // Collect all atoms with radii let atoms : Array[(Vector3, Double, String)] = Array::new() for res in residues { @@ -698,21 +716,21 @@ pub fn calc_sasa( atoms.push((atom.coord, radius, atom.name)) } } - + let n_atoms = atoms.length() if n_atoms == 0 { return result } - + // Generate sphere points let sphere_points = generate_sphere_points(n_points) - + // Calculate SASA for each atom let mut i = 0 while i < n_atoms { let (coord_i, radius_i, name_i) = atoms[i] let r_sq = radius_i * radius_i - + let n_accessible = { let mut count = 0 let mut pi = 0 @@ -722,7 +740,7 @@ pub fn calc_sasa( let px = point.x * radius_i + coord_i.x let py = point.y * radius_i + coord_i.y let pz = point.z * radius_i + coord_i.z - + // Check if this point is buried by any other atom let mut buried = false let mut j = 0 @@ -740,7 +758,7 @@ pub fn calc_sasa( } j = j + 1 } - + if !buried { count = count + 1 } @@ -748,15 +766,17 @@ pub fn calc_sasa( } count } - + // SASA contribution from this atom let sphere_area = 4.0 * 3.14159265358979323846 * r_sq - let atom_sasa = (n_accessible.to_double() / n_points.to_double()) * sphere_area - + let atom_sasa = n_accessible.to_double() / + n_points.to_double() * + sphere_area + result.push((name_i, atom_sasa)) i = i + 1 } - + result } @@ -774,11 +794,14 @@ pub fn calc_total_sasa(chain : Chain, probe_radius? : Double = 1.4) -> Double { ///| /// Calculate per-residue SASA for a chain. /// Returns an array of (resseq, resname, sasa) tuples. -pub fn calc_residue_sasa(chain : Chain, probe_radius? : Double = 1.4) -> Array[(Int, String, Double)] { +pub fn calc_residue_sasa( + chain : Chain, + probe_radius? : Double = 1.4, +) -> Array[(Int, String, Double)] { let result : Array[(Int, String, Double)] = Array::new() let residues = chain.get_residues() let atom_sasa = calc_sasa(chain, probe_radius~) - + // Map atoms back to residues let atom_idx = { let mut idx = 0 @@ -796,7 +819,7 @@ pub fn calc_residue_sasa(chain : Chain, probe_radius? : Double = 1.4) -> Array[( } res_atom_map } - + result } @@ -806,15 +829,15 @@ pub fn calc_residue_sasa(chain : Chain, probe_radius? : Double = 1.4) -> Array[( pub fn ramachandran_quality(chain : Chain) -> (Double, Double, Double) { let plot_data = ramachandran_plot(chain) let n_total = plot_data.length().to_double() - + if n_total == 0.0 { return (0.0, 0.0, 0.0) } - + let mut n_favored = 0.0 let mut n_allowed = 0.0 let mut n_generous = 0.0 - + for entry in plot_data { let phi = entry.2 let psi = entry.3 @@ -825,7 +848,7 @@ pub fn ramachandran_quality(chain : Chain) -> (Double, Double, Double) { Generous => n_generous = n_generous + 1.0 } } - + (n_favored / n_total, n_allowed / n_total, n_generous / n_total) } @@ -836,7 +859,7 @@ pub fn calc_sequence_property_matrix(chain : Chain) -> Array[Array[Double]] { let residues = chain.get_residues() let n = residues.length() let matrix : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let row : Array[Double] = Array::new() @@ -850,7 +873,7 @@ pub fn calc_sequence_property_matrix(chain : Chain) -> Array[Array[Double]] { matrix.push(row) i = i + 1 } - + matrix } diff --git a/src/pdb_dice.mbt b/src/pdb_dice.mbt index 3bd3f40c..98497ae2 100644 --- a/src/pdb_dice.mbt +++ b/src/pdb_dice.mbt @@ -72,11 +72,11 @@ pub fn extract_chains( chain_ids : Array[Char], ) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let new_chains : Array[Chain] = [] - + for j = 0; j < model.chains.length(); j = j + 1 { let chain = model.chains[j] let mut selected = false @@ -89,22 +89,19 @@ pub fn extract_chains( new_chains.push(chain) } } - + if new_chains.length() > 0 { let new_model = Model::new(id=model.id, chains=new_chains) new_models.push(new_model) } } - + Structure::new(id=structure.id, models=new_models) } ///| /// Extract a single chain from a structure. -pub fn extract_chain( - structure : Structure, - chain_id : Char, -) -> Structure { +pub fn extract_chain(structure : Structure, chain_id : Char) -> Structure { let chain_arr = [chain_id] extract_chains(structure, chain_arr) } @@ -123,11 +120,11 @@ pub fn extract_residue_range( end_res : Int, ) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let new_chains : Array[Chain] = [] - + for j = 0; j < model.chains.length(); j = j + 1 { let chain = model.chains[j] if chain.id == chain_id { @@ -147,13 +144,13 @@ pub fn extract_residue_range( // Skip other chains } } - + if new_chains.length() > 0 { let new_model = Model::new(id=model.id, chains=new_chains) new_models.push(new_model) } } - + Structure::new(id=structure.id, models=new_models) } @@ -164,46 +161,46 @@ pub fn extract_residues( residue_ids : Array[ResidueId], ) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let new_chains : Array[Chain] = [] let chain_residues_map = Map([], capacity=8) // chain_id -> Array[Residue] - + for j = 0; j < model.chains.length(); j = j + 1 { let chain = model.chains[j] let selected_residues : Array[Residue] = [] - + for k = 0; k < chain.residues.length(); k = k + 1 { let residue = chain.residues[k] let mut is_selected = false - + for r = 0; r < residue_ids.length() && !is_selected; r = r + 1 { let rid = residue_ids[r] if chain.id == rid.chain_id && - residue.resseq == rid.resseq && - residue.icode == rid.icode { + residue.resseq == rid.resseq && + residue.icode == rid.icode { is_selected = true } } - + if is_selected { selected_residues.push(residue) } } - + if selected_residues.length() > 0 { let new_chain = Chain::new(id=chain.id, residues=selected_residues) new_chains.push(new_chain) } } - + if new_chains.length() > 0 { let new_model = Model::new(id=model.id, chains=new_chains) new_models.push(new_model) } } - + Structure::new(id=structure.id, models=new_models) } @@ -218,19 +215,19 @@ pub fn extract_atoms_by_name( atom_names : Array[String], ) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let new_chains : Array[Chain] = [] - + for j = 0; j < model.chains.length(); j = j + 1 { let chain = model.chains[j] let new_residues : Array[Residue] = [] - + for k = 0; k < chain.residues.length(); k = k + 1 { let residue = chain.residues[k] let new_atoms : Array[Atom] = [] - + for a = 0; a < residue.atoms.length(); a = a + 1 { let atom = residue.atoms[a] let mut selected = false @@ -243,7 +240,7 @@ pub fn extract_atoms_by_name( new_atoms.push(atom) } } - + if new_atoms.length() > 0 { let new_residue = Residue::new( resname=residue.resname, @@ -255,19 +252,19 @@ pub fn extract_atoms_by_name( new_residues.push(new_residue) } } - + if new_residues.length() > 0 { let new_chain = Chain::new(id=chain.id, residues=new_residues) new_chains.push(new_chain) } } - + if new_chains.length() > 0 { let new_model = Model::new(id=model.id, chains=new_chains) new_models.push(new_model) } } - + Structure::new(id=structure.id, models=new_models) } @@ -296,7 +293,7 @@ pub fn extract_models( model_ids : Array[Int], ) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let mut selected = false @@ -309,7 +306,7 @@ pub fn extract_models( new_models.push(model) } } - + Structure::new(id=structure.id, models=new_models) } @@ -332,34 +329,34 @@ pub fn extract_first_model(structure : Structure) -> Structure { /// Keeps only standard amino acid residues. pub fn remove_hetero_residues(structure : Structure) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let new_chains : Array[Chain] = [] - + for j = 0; j < model.chains.length(); j = j + 1 { let chain = model.chains[j] let new_residues : Array[Residue] = [] - + for k = 0; k < chain.residues.length(); k = k + 1 { let residue = chain.residues[k] if !residue.is_het() { new_residues.push(residue) } } - + if new_residues.length() > 0 { let new_chain = Chain::new(id=chain.id, residues=new_residues) new_chains.push(new_chain) } } - + if new_chains.length() > 0 { let new_model = Model::new(id=model.id, chains=new_chains) new_models.push(new_model) } } - + Structure::new(id=structure.id, models=new_models) } @@ -367,34 +364,34 @@ pub fn remove_hetero_residues(structure : Structure) -> Structure { /// Keep only hetero residues (HETATM) in a structure. pub fn keep_hetero_residues(structure : Structure) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let new_chains : Array[Chain] = [] - + for j = 0; j < model.chains.length(); j = j + 1 { let chain = model.chains[j] let new_residues : Array[Residue] = [] - + for k = 0; k < chain.residues.length(); k = k + 1 { let residue = chain.residues[k] if residue.is_het() { new_residues.push(residue) } } - + if new_residues.length() > 0 { let new_chain = Chain::new(id=chain.id, residues=new_residues) new_chains.push(new_chain) } } - + if new_chains.length() > 0 { let new_model = Model::new(id=model.id, chains=new_chains) new_models.push(new_model) } } - + Structure::new(id=structure.id, models=new_models) } @@ -407,7 +404,7 @@ pub fn keep_hetero_residues(structure : Structure) -> Structure { pub fn get_unique_chain_ids(structure : Structure) -> Array[Char] { let ids : Array[Char] = [] let seen = Map([], capacity=8) - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] for j = 0; j < model.chains.length(); j = j + 1 { @@ -419,7 +416,7 @@ pub fn get_unique_chain_ids(structure : Structure) -> Array[Char] { } } } - + ids } @@ -428,7 +425,7 @@ pub fn get_unique_chain_ids(structure : Structure) -> Array[Char] { pub fn get_unique_residue_names(structure : Structure) -> Array[String] { let names : Array[String] = [] let seen = Map([], capacity=32) - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] for j = 0; j < model.chains.length(); j = j + 1 { @@ -442,7 +439,7 @@ pub fn get_unique_residue_names(structure : Structure) -> Array[String] { } } } - + names } @@ -451,7 +448,7 @@ pub fn get_unique_residue_names(structure : Structure) -> Array[String] { pub fn get_unique_atom_names(structure : Structure) -> Array[String] { let names : Array[String] = [] let seen = Map([], capacity=32) - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] for j = 0; j < model.chains.length(); j = j + 1 { @@ -468,7 +465,7 @@ pub fn get_unique_atom_names(structure : Structure) -> Array[String] { } } } - + names } @@ -476,7 +473,7 @@ pub fn get_unique_atom_names(structure : Structure) -> Array[String] { /// Count atoms in a structure by element type. pub fn count_atoms_by_element(structure : Structure) -> Map[String, Int] { let counts = Map([], capacity=16) - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] for j = 0; j < model.chains.length(); j = j + 1 { @@ -492,7 +489,7 @@ pub fn count_atoms_by_element(structure : Structure) -> Map[String, Int] { } } } - + counts } @@ -507,7 +504,7 @@ pub fn structure_stats(structure : Structure) -> DiceResult { let mut num_residues = 0 let mut num_chains = 0 let num_models = structure.models.length() - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] num_chains = num_chains + model.chains.length() @@ -520,21 +517,15 @@ pub fn structure_stats(structure : Structure) -> DiceResult { } } } - - DiceResult::new( - structure.id, - num_atoms, - num_residues, - num_chains, - num_models, - ) + + DiceResult::new(structure.id, num_atoms, num_residues, num_chains, num_models) } ///| /// Get the sequence of a specific chain as a string (one-letter codes). pub fn chain_sequence(structure : Structure, chain_id : Char) -> String { let mut seq = "" - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] for j = 0; j < model.chains.length(); j = j + 1 { @@ -550,7 +541,7 @@ pub fn chain_sequence(structure : Structure, chain_id : Char) -> String { } } } - + seq } @@ -593,26 +584,26 @@ pub fn filter_by_bfactor( max_bfactor : Double, ) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let new_chains : Array[Chain] = [] - + for j = 0; j < model.chains.length(); j = j + 1 { let chain = model.chains[j] let new_residues : Array[Residue] = [] - + for k = 0; k < chain.residues.length(); k = k + 1 { let residue = chain.residues[k] let new_atoms : Array[Atom] = [] - + for a = 0; a < residue.atoms.length(); a = a + 1 { let atom = residue.atoms[a] if atom.bfactor >= min_bfactor && atom.bfactor <= max_bfactor { new_atoms.push(atom) } } - + if new_atoms.length() > 0 { let new_residue = Residue::new( resname=residue.resname, @@ -624,19 +615,19 @@ pub fn filter_by_bfactor( new_residues.push(new_residue) } } - + if new_residues.length() > 0 { let new_chain = Chain::new(id=chain.id, residues=new_residues) new_chains.push(new_chain) } } - + if new_chains.length() > 0 { let new_model = Model::new(id=model.id, chains=new_chains) new_models.push(new_model) } } - + Structure::new(id=structure.id, models=new_models) } @@ -647,26 +638,26 @@ pub fn filter_by_occupancy( min_occupancy : Double, ) -> Structure { let new_models : Array[Model] = [] - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] let new_chains : Array[Chain] = [] - + for j = 0; j < model.chains.length(); j = j + 1 { let chain = model.chains[j] let new_residues : Array[Residue] = [] - + for k = 0; k < chain.residues.length(); k = k + 1 { let residue = chain.residues[k] let new_atoms : Array[Atom] = [] - + for a = 0; a < residue.atoms.length(); a = a + 1 { let atom = residue.atoms[a] if atom.occupancy >= min_occupancy { new_atoms.push(atom) } } - + if new_atoms.length() > 0 { let new_residue = Residue::new( resname=residue.resname, @@ -678,19 +669,19 @@ pub fn filter_by_occupancy( new_residues.push(new_residue) } } - + if new_residues.length() > 0 { let new_chain = Chain::new(id=chain.id, residues=new_residues) new_chains.push(new_chain) } } - + if new_chains.length() > 0 { let new_model = Model::new(id=model.id, chains=new_chains) new_models.push(new_model) } } - + Structure::new(id=structure.id, models=new_models) } @@ -707,7 +698,7 @@ pub fn select_atoms_near_point( ) -> Array[Atom] { let selected : Array[Atom] = [] let radius_sq = radius * radius - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] for j = 0; j < model.chains.length(); j = j + 1 { @@ -727,7 +718,7 @@ pub fn select_atoms_near_point( } } } - + selected } @@ -741,7 +732,7 @@ pub fn select_residues_near_point( let selected : Array[ResidueId] = [] let seen = Map([], capacity=32) let radius_sq = radius * radius - + for i = 0; i < structure.models.length(); i = i + 1 { let model = structure.models[i] for j = 0; j < model.chains.length(); j = j + 1 { @@ -749,7 +740,7 @@ pub fn select_residues_near_point( for k = 0; k < chain.residues.length(); k = k + 1 { let residue = chain.residues[k] let mut has_close_atom = false - + for a = 0; a < residue.atoms.length() && !has_close_atom; a = a + 1 { let atom = residue.atoms[a] let dx = atom.coord.x - point.x @@ -760,12 +751,21 @@ pub fn select_residues_near_point( has_close_atom = true } } - + if has_close_atom { - let key = "" + chain.id.to_string() + ":" + residue.resseq.to_string() + ":" + residue.icode.to_string() + let key = "" + + chain.id.to_string() + + ":" + + residue.resseq.to_string() + + ":" + + residue.icode.to_string() if seen.get(key) == None { seen.set(key, "1") - let rid = ResidueId::new(chain.id, residue.resseq, icode=residue.icode) + let rid = ResidueId::new( + chain.id, + residue.resseq, + icode=residue.icode, + ) selected.push(rid) } } @@ -773,6 +773,6 @@ pub fn select_residues_near_point( } break // Only check first model } - + selected } diff --git a/src/pdb_header.mbt b/src/pdb_header.mbt index 53e9065b..2d6aaac1 100644 --- a/src/pdb_header.mbt +++ b/src/pdb_header.mbt @@ -195,7 +195,10 @@ fn split_pdb_lines(text : String) -> Array[String] { ///| /// Find the start and end indices of a record section in the lines array. /// Returns (-1, -1) if the record is not found. -fn extract_record_section(lines : Array[String], record_name : String) -> (Int, Int) { +fn extract_record_section( + lines : Array[String], + record_name : String, +) -> (Int, Int) { let mut start = -1 let mut end = -1 let mut i = 0 @@ -440,18 +443,18 @@ pub fn parse_pdb_header_lines(lines : Array[String]) -> PDBHeader { } PDBHeader::new( - pdb_id=pdb_id, - title=title, - compound=compound, - source=source, - keywords=keywords, - resolution=resolution, - rfactor=rfactor, - date_deposited=date_deposited, - authors=authors, - journal=journal, - remark_lines=remark_lines, - dbrefs=dbrefs, + pdb_id~, + title~, + compound~, + source~, + keywords~, + resolution~, + rfactor~, + date_deposited~, + authors~, + journal~, + remark_lines~, + dbrefs~, chain_ids=final_chain_ids, ) } @@ -479,7 +482,10 @@ pub fn parse_title_record(lines : Array[String], _start_idx : Int) -> String { ///| /// Parse multi-line COMPOUND record. -pub fn parse_compound_record(lines : Array[String], _start_idx : Int) -> CompoundInfo { +pub fn parse_compound_record( + lines : Array[String], + _start_idx : Int, +) -> CompoundInfo { let (start, end) = extract_record_section(lines, "COMPND") if start < 0 { return CompoundInfo::new() @@ -524,21 +530,24 @@ pub fn parse_compound_record(lines : Array[String], _start_idx : Int) -> Compoun } CompoundInfo::new( - molecule_id=molecule_id, - chain_ids=chain_ids, - compound_name=compound_name, - formula=formula, - ka=ka, - kb=kb, - ec_number=ec_number, - engineered=engineered, - mutation=mutation, + molecule_id~, + chain_ids~, + compound_name~, + formula~, + ka~, + kb~, + ec_number~, + engineered~, + mutation~, ) } ///| /// Parse multi-line SOURCE record. -pub fn parse_source_record(lines : Array[String], _start_idx : Int) -> SourceInfo { +pub fn parse_source_record( + lines : Array[String], + _start_idx : Int, +) -> SourceInfo { let (start, end) = extract_record_section(lines, "SOURCE") if start < 0 { return SourceInfo::new() @@ -579,19 +588,22 @@ pub fn parse_source_record(lines : Array[String], _start_idx : Int) -> SourceInf } SourceInfo::new( - source=source, - organism_scientific=organism_scientific, - organism_common=organism_common, - strain=strain, - cell_line=cell_line, - tissue=tissue, - tax_id=tax_id, + source~, + organism_scientific~, + organism_common~, + strain~, + cell_line~, + tissue~, + tax_id~, ) } ///| /// Parse multi-line KEYWDS record. -pub fn parse_keywords_record(lines : Array[String], _start_idx : Int) -> Array[String] { +pub fn parse_keywords_record( + lines : Array[String], + _start_idx : Int, +) -> Array[String] { let (start, end) = extract_record_section(lines, "KEYWDS") if start < 0 { return [] @@ -641,7 +653,10 @@ pub fn parse_rfactor_record(line : String) -> Double { ///| /// Parse multi-line AUTH record. /// Returns array of author names (semicolon-separated). -pub fn parse_authors_record(lines : Array[String], _start_idx : Int) -> Array[String] { +pub fn parse_authors_record( + lines : Array[String], + _start_idx : Int, +) -> Array[String] { let (start, end) = extract_record_section(lines, "AUTH") if start < 0 { return [] @@ -671,7 +686,10 @@ pub fn parse_journal_record(lines : Array[String], _start_idx : Int) -> String { ///| /// Parse DBREF records. -pub fn parse_dbref_record(lines : Array[String], _start_idx : Int) -> Array[DBRefEntry] { +pub fn parse_dbref_record( + lines : Array[String], + _start_idx : Int, +) -> Array[DBRefEntry] { let result : Array[DBRefEntry] = [] let (start, end) = extract_record_section(lines, "DBREF") if start < 0 { @@ -684,11 +702,7 @@ pub fn parse_dbref_record(lines : Array[String], _start_idx : Int) -> Array[DBRe let db_name = trim_pdb_field(line, 13, 18) let db_accession = trim_pdb_field(line, 24, 33) let db_id = trim_pdb_field(line, 49, 56) - result.push(DBRefEntry::new( - db_name=db_name, - db_accession=db_accession, - db_id=db_id, - )) + result.push(DBRefEntry::new(db_name~, db_accession~, db_id~)) } i = i + 1 } @@ -697,7 +711,10 @@ pub fn parse_dbref_record(lines : Array[String], _start_idx : Int) -> Array[DBRe ///| /// Parse all REMARK records into an array of strings. -pub fn parse_remark_records(lines : Array[String], _start_idx : Int) -> Array[String] { +pub fn parse_remark_records( + lines : Array[String], + _start_idx : Int, +) -> Array[String] { let result : Array[String] = [] let (start, end) = extract_record_section(lines, "REMARK") if start < 0 { @@ -830,4 +847,4 @@ fn extract_chain_ids_from_compound(compound : CompoundInfo) -> Array[String] { fn extract_chain_ids_from_dbref(dbrefs : Array[DBRefEntry]) -> Array[String] { let result : Array[String] = [] result -} \ No newline at end of file +} diff --git a/src/pdb_list.mbt b/src/pdb_list.mbt index 9133ad7f..c2eed04a 100644 --- a/src/pdb_list.mbt +++ b/src/pdb_list.mbt @@ -10,27 +10,32 @@ pub struct PDBList { ///| pub fn PDBList::new(pdb_dir : String) -> PDBList { - PDBList::{ - pdb_dir, - obsolete_pdb_dir: pdb_dir + "/obsolete", - update_date: "" - } + PDBList::{ pdb_dir, obsolete_pdb_dir: pdb_dir + "/obsolete", update_date: "" } } ///| -pub fn PDBList::download_pdb(self : PDBList, pdb_code : String, file_format : String) -> String { +pub fn PDBList::download_pdb( + self : PDBList, + pdb_code : String, + file_format : String, +) -> String { let pdb_code_upper = pdb_code.to_upper() let middle_part = substring(pdb_code_upper, 1, 2) let pdb_dir = self.pdb_dir + "/" + middle_part + "/" + pdb_code_upper let file_name = pdb_dir + "/" + pdb_code_upper + "." + file_format - + file_name } ///| -pub fn PDBList::get_pdb_file(self : PDBList, pdb_code : String, file_format : String, obsolete : Bool) -> String { +pub fn PDBList::get_pdb_file( + self : PDBList, + pdb_code : String, + file_format : String, + obsolete : Bool, +) -> String { let pdb_code_upper = pdb_code.to_upper() - + if obsolete { self.obsolete_pdb_dir + "/" + pdb_code_upper + "." + file_format } else { @@ -39,16 +44,20 @@ pub fn PDBList::get_pdb_file(self : PDBList, pdb_code : String, file_format : St } ///| -pub fn PDBList::download_all_pdbs(self : PDBList, pdb_codes : Array[String], file_format : String) -> Array[String] { +pub fn PDBList::download_all_pdbs( + self : PDBList, + pdb_codes : Array[String], + file_format : String, +) -> Array[String] { let results : Array[String] = Array::new() - + let mut i = 0 while i < pdb_codes.length() { let file = self.download_pdb(pdb_codes[i], file_format) results.push(file) i = i + 1 } - + results } @@ -61,7 +70,14 @@ pub fn PDBList::get_all_obsolete(self : PDBList) -> Array[String] { ///| pub fn PDBList::update_pdb(self : PDBList) -> (PDBList, String) { let new_date = "2024-01-01" - (PDBList::{ pdb_dir: self.pdb_dir, obsolete_pdb_dir: self.obsolete_pdb_dir, update_date: new_date }, new_date) + ( + PDBList::{ + pdb_dir: self.pdb_dir, + obsolete_pdb_dir: self.obsolete_pdb_dir, + update_date: new_date, + }, + new_date, + ) } ///| @@ -72,11 +88,8 @@ pub fn PDBList::get_recent_changes(self : PDBList, days : Int) -> Array[String] ///| pub fn PDBList::resolve_obsolete(self : PDBList, pdb_code : String) -> String { - let obsolete_map = Map([ - ("1XYZ", "2XYZ"), - ("3ABC", "4ABC") - ], capacity=2) - + let obsolete_map = Map([("1XYZ", "2XYZ"), ("3ABC", "4ABC")], capacity=2) + if obsolete_map.contains(pdb_code) { obsolete_map.get(pdb_code).unwrap() } else { @@ -87,4 +100,4 @@ pub fn PDBList::resolve_obsolete(self : PDBList, pdb_code : String) -> String { ///| pub fn create_example_pdblist() -> PDBList { PDBList::new("/data/pdb") -} \ No newline at end of file +} diff --git a/src/pdb_packing.mbt b/src/pdb_packing.mbt index cdeeabc9..0940c9dc 100644 --- a/src/pdb_packing.mbt +++ b/src/pdb_packing.mbt @@ -163,7 +163,9 @@ pub fn PackingAnalysisResult::new( ///| /// Get results array. -pub fn PackingAnalysisResult::get_results(self : PackingAnalysisResult) -> Array[PackingResult] { +pub fn PackingAnalysisResult::get_results( + self : PackingAnalysisResult, +) -> Array[PackingResult] { self.results } @@ -185,14 +187,16 @@ pub fn PackingAnalysisResult::summary(self : PackingAnalysisResult) -> String { /// Generate approximately uniform points on a unit sphere /// using the golden spiral (Fibonacci sphere) algorithm. /// n_points: number of points to generate (default 100). -pub fn generate_packing_sphere_points(n_points? : Int = 100) -> Array[SpherePoint] { +pub fn generate_packing_sphere_points( + n_points? : Int = 100, +) -> Array[SpherePoint] { let points : Array[SpherePoint] = Array::new() let n = if n_points < 1 { 1 } else { n_points } let golden_angle = 3.14159265358979323846 * (3.0 - 5.0.sqrt()) let mut i = 0 while i < n { - let y = 1.0 - (2.0 * i.to_double()) / (n.to_double() - 1.0) + let y = 1.0 - 2.0 * i.to_double() / (n.to_double() - 1.0) let radius_at_y = (1.0 - y * y).sqrt() let theta = golden_angle * i.to_double() @@ -215,7 +219,7 @@ pub fn atom_in_sphere( let dx = point[0] - center[0] let dy = point[1] - center[1] let dz = point[2] - center[2] - (dx * dx + dy * dy + dz * dz) <= radius * radius + dx * dx + dy * dy + dz * dz <= radius * radius } ///| @@ -259,7 +263,7 @@ pub fn calculate_packing_density( return PackingResult::new(residue_name="", residue_seq=0) } - let sphere_points = generate_packing_sphere_points(n_points=n_points) + let sphere_points = generate_packing_sphere_points(n_points~) let atom = atoms[0] let atom_radius = atom.vdw_radius + radius @@ -326,11 +330,13 @@ pub fn packing_density_per_residue( let residue_groups : Map[String, Array[PackingAtom]] = Map([], capacity=16) for atom in atoms { - let key = atom.chain_id.to_string() + ":" + atom.residue_seq.to_string() + ":" + atom.residue_name + let key = atom.chain_id.to_string() + + ":" + + atom.residue_seq.to_string() + + ":" + + atom.residue_name match residue_groups.get(key) { - Some(arr) => { - arr.push(atom) - } + Some(arr) => arr.push(atom) None => { let arr : Array[PackingAtom] = Array::new() arr.push(atom) @@ -345,7 +351,11 @@ pub fn packing_density_per_residue( while ki < all_keys.length() { let key = all_keys[ki] let res_atoms = residue_groups[key] - let density_result = calculate_packing_density(res_atoms, radius~, n_points~) + let density_result = calculate_packing_density( + res_atoms, + radius~, + n_points~, + ) results.push(density_result) ki = ki + 1 } @@ -423,7 +433,7 @@ pub fn calculate_packing_sasa( return 0.0 } - let sphere_points = generate_packing_sphere_points(n_points=n_points) + let sphere_points = generate_packing_sphere_points(n_points~) let mut total_sasa = 0.0 let mut i = 0 @@ -462,7 +472,9 @@ pub fn calculate_packing_sasa( } let sphere_area = 4.0 * 3.14159265358979323846 * r_sq - let atom_sasa = (n_accessible.to_double() / n_points.to_double()) * sphere_area + let atom_sasa = n_accessible.to_double() / + n_points.to_double() * + sphere_area total_sasa = total_sasa + atom_sasa i = i + 1 @@ -525,13 +537,13 @@ pub fn sphere_radius_from_volume(volume : Double) -> Double { if volume <= 0.0 { return 0.0 } - @math.pow((3.0 * volume) / (4.0 * 3.14159265358979323846), 1.0 / 3.0) + @math.pow(3.0 * volume / (4.0 * 3.14159265358979323846), 1.0 / 3.0) } ///| /// Calculate the volume of a sphere with given radius. pub fn sphere_volume(radius : Double) -> Double { - (4.0 / 3.0) * 3.14159265358979323846 * radius * radius * radius + 4.0 / 3.0 * 3.14159265358979323846 * radius * radius * radius } ///| @@ -685,15 +697,34 @@ pub fn get_packing_vdw_radius(atom_name : String) -> Double { if name == "H" || (contains(name, "H") && starts_with(name, 0, "H")) { return 1.2 } - if name == "C" || name == "CA" || name == "CB" || name == "CG" || - name == "CD" || name == "CE" || name == "CZ" || name == "CH2" || name == "CH3" { + if name == "C" || + name == "CA" || + name == "CB" || + name == "CG" || + name == "CD" || + name == "CE" || + name == "CZ" || + name == "CH2" || + name == "CH3" { return 1.7 } - if name == "N" || name == "NZ" || name == "ND" || name == "NE" || name == "NH1" || name == "NH2" { + if name == "N" || + name == "NZ" || + name == "ND" || + name == "NE" || + name == "NH1" || + name == "NH2" { return 1.55 } - if name == "O" || name == "OH" || name == "OG" || name == "OD1" || name == "OD2" || - name == "OE1" || name == "OE2" || name == "OT1" || name == "OT2" { + if name == "O" || + name == "OH" || + name == "OG" || + name == "OD1" || + name == "OD2" || + name == "OE1" || + name == "OE2" || + name == "OT1" || + name == "OT2" { return 1.52 } if name == "S" || name == "SG" || name == "SD" { @@ -703,4 +734,4 @@ pub fn get_packing_vdw_radius(atom_name : String) -> Double { return 1.8 } 1.7 -} \ No newline at end of file +} diff --git a/src/pdb_seqio.mbt b/src/pdb_seqio.mbt index 3f78fe44..79b391ce 100644 --- a/src/pdb_seqio.mbt +++ b/src/pdb_seqio.mbt @@ -223,12 +223,14 @@ pub fn pdb_seqres_parser(content : String) -> Array[SeqRecord] { } else { chain_id } - records.push(SeqRecord::new( - Seq::new(seq_buf.to_string()), - id=id, - name=chain_id, - description="sequence from SEQRES, chain " + chain_id, - )) + records.push( + SeqRecord::new( + Seq::new(seq_buf.to_string()), + id~, + name=chain_id, + description="sequence from SEQRES, chain " + chain_id, + ), + ) } records } @@ -269,12 +271,17 @@ fn build_records_from_structure( } else { chain_id_str } - records.push(SeqRecord::new( - Seq::new(seq_str), - id=id, - name=chain_id_str, - description="sequence from " + source_label + " records, chain " + chain_id_str, - )) + records.push( + SeqRecord::new( + Seq::new(seq_str), + id~, + name=chain_id_str, + description="sequence from " + + source_label + + " records, chain " + + chain_id_str, + ), + ) } records } @@ -341,11 +348,7 @@ pub fn extract_sequence_from_pdb_lines( if cid != chain_id { continue } - let resname = if n >= 20 { - line[17:20].trim().to_owned() - } else { - "UNK" - } + let resname = if n >= 20 { line[17:20].trim().to_owned() } else { "UNK" } if resname == "HOH" || resname == "WAT" { continue } @@ -354,11 +357,7 @@ pub fn extract_sequence_from_pdb_lines( } else { 0 } - let icode = if n >= 27 { - line.get_char(26).unwrap_or(' ') - } else { - ' ' - } + let icode = if n >= 27 { line.get_char(26).unwrap_or(' ') } else { ' ' } let is_new = match prev_resseq { Some(p) => p != resseq || prev_icode != icode None => true @@ -380,7 +379,7 @@ pub fn extract_sequence_from_pdb_lines( /// `PdbSeqresParser`. pub fn pdb_to_seqrecords( content : String, - source~ : String = "atom", + source? : String = "atom", ) -> Array[SeqRecord] { let lower = source.to_lower() if lower == "seqres" { diff --git a/src/pdb_vectors.mbt b/src/pdb_vectors.mbt index a50c2172..09608835 100644 --- a/src/pdb_vectors.mbt +++ b/src/pdb_vectors.mbt @@ -50,9 +50,19 @@ pub fn Vector3::unit_z() -> Vector3 { ///| /// Access vector components. -pub fn Vector3::get_x(self : Vector3) -> Double { self.x } -pub fn Vector3::get_y(self : Vector3) -> Double { self.y } -pub fn Vector3::get_z(self : Vector3) -> Double { self.z } +pub fn Vector3::get_x(self : Vector3) -> Double { + self.x +} + +///| +pub fn Vector3::get_y(self : Vector3) -> Double { + self.y +} + +///| +pub fn Vector3::get_z(self : Vector3) -> Double { + self.z +} ///| /// Add two vectors. @@ -84,7 +94,7 @@ pub fn Vector3::cross(self : Vector3, other : Vector3) -> Vector3 { Vector3::{ x: self.y * other.z - self.z * other.y, y: self.z * other.x - self.x * other.z, - z: self.x * other.y - self.y * other.x + z: self.x * other.y - self.y * other.x, } } @@ -129,7 +139,13 @@ pub fn Vector3::angle(self : Vector3, other : Vector3) -> Double { return 0.0 } let cos_angle = dot / (n1 * n2) - let clamped = if cos_angle > 1.0 { 1.0 } else { if cos_angle < -1.0 { -1.0 } else { cos_angle } } + let clamped = if cos_angle > 1.0 { + 1.0 + } else if cos_angle < -1.0 { + -1.0 + } else { + cos_angle + } @math.acos(clamped) } @@ -193,9 +209,15 @@ pub struct RotationMatrix3 { ///| /// Construct a 3x3 rotation matrix from 9 values (row-major). pub fn RotationMatrix3::new( - m00~ : Double, m01~ : Double, m02~ : Double, - m10~ : Double, m11~ : Double, m12~ : Double, - m20~ : Double, m21~ : Double, m22~ : Double, + m00~ : Double, + m01~ : Double, + m02~ : Double, + m10~ : Double, + m11~ : Double, + m12~ : Double, + m20~ : Double, + m21~ : Double, + m22~ : Double, ) -> RotationMatrix3 { RotationMatrix3::{ m00, m01, m02, m10, m11, m12, m20, m21, m22 } } @@ -204,15 +226,25 @@ pub fn RotationMatrix3::new( /// Identity rotation matrix. pub fn RotationMatrix3::identity() -> RotationMatrix3 { RotationMatrix3::{ - m00: 1.0, m01: 0.0, m02: 0.0, - m10: 0.0, m11: 1.0, m12: 0.0, - m20: 0.0, m21: 0.0, m22: 1.0, + m00: 1.0, + m01: 0.0, + m02: 0.0, + m10: 0.0, + m11: 1.0, + m12: 0.0, + m20: 0.0, + m21: 0.0, + m22: 1.0, } } ///| /// Access element at row,col. -pub fn RotationMatrix3::get(self : RotationMatrix3, row : Int, col : Int) -> Double { +pub fn RotationMatrix3::get( + self : RotationMatrix3, + row : Int, + col : Int, +) -> Double { match (row, col) { (0, 0) => self.m00 (0, 1) => self.m01 @@ -229,17 +261,121 @@ pub fn RotationMatrix3::get(self : RotationMatrix3, row : Int, col : Int) -> Dou ///| /// Set element at row,col. -pub fn RotationMatrix3::set(self : RotationMatrix3, row : Int, col : Int, value : Double) -> RotationMatrix3 { +pub fn RotationMatrix3::set( + self : RotationMatrix3, + row : Int, + col : Int, + value : Double, +) -> RotationMatrix3 { match (row, col) { - (0, 0) => RotationMatrix3::{ m00: value, m01: self.m01, m02: self.m02, m10: self.m10, m11: self.m11, m12: self.m12, m20: self.m20, m21: self.m21, m22: self.m22 } - (0, 1) => RotationMatrix3::{ m00: self.m00, m01: value, m02: self.m02, m10: self.m10, m11: self.m11, m12: self.m12, m20: self.m20, m21: self.m21, m22: self.m22 } - (0, 2) => RotationMatrix3::{ m00: self.m00, m01: self.m01, m02: value, m10: self.m10, m11: self.m11, m12: self.m12, m20: self.m20, m21: self.m21, m22: self.m22 } - (1, 0) => RotationMatrix3::{ m00: self.m00, m01: self.m01, m02: self.m02, m10: value, m11: self.m11, m12: self.m12, m20: self.m20, m21: self.m21, m22: self.m22 } - (1, 1) => RotationMatrix3::{ m00: self.m00, m01: self.m01, m02: self.m02, m10: self.m10, m11: value, m12: self.m12, m20: self.m20, m21: self.m21, m22: self.m22 } - (1, 2) => RotationMatrix3::{ m00: self.m00, m01: self.m01, m02: self.m02, m10: self.m10, m11: self.m11, m12: value, m20: self.m20, m21: self.m21, m22: self.m22 } - (2, 0) => RotationMatrix3::{ m00: self.m00, m01: self.m01, m02: self.m02, m10: self.m10, m11: self.m11, m12: self.m12, m20: value, m21: self.m21, m22: self.m22 } - (2, 1) => RotationMatrix3::{ m00: self.m00, m01: self.m01, m02: self.m02, m10: self.m10, m11: self.m11, m12: self.m12, m20: self.m20, m21: value, m22: self.m22 } - (2, 2) => RotationMatrix3::{ m00: self.m00, m01: self.m01, m02: self.m02, m10: self.m10, m11: self.m11, m12: self.m12, m20: self.m20, m21: self.m21, m22: value } + (0, 0) => + RotationMatrix3::{ + m00: value, + m01: self.m01, + m02: self.m02, + m10: self.m10, + m11: self.m11, + m12: self.m12, + m20: self.m20, + m21: self.m21, + m22: self.m22, + } + (0, 1) => + RotationMatrix3::{ + m00: self.m00, + m01: value, + m02: self.m02, + m10: self.m10, + m11: self.m11, + m12: self.m12, + m20: self.m20, + m21: self.m21, + m22: self.m22, + } + (0, 2) => + RotationMatrix3::{ + m00: self.m00, + m01: self.m01, + m02: value, + m10: self.m10, + m11: self.m11, + m12: self.m12, + m20: self.m20, + m21: self.m21, + m22: self.m22, + } + (1, 0) => + RotationMatrix3::{ + m00: self.m00, + m01: self.m01, + m02: self.m02, + m10: value, + m11: self.m11, + m12: self.m12, + m20: self.m20, + m21: self.m21, + m22: self.m22, + } + (1, 1) => + RotationMatrix3::{ + m00: self.m00, + m01: self.m01, + m02: self.m02, + m10: self.m10, + m11: value, + m12: self.m12, + m20: self.m20, + m21: self.m21, + m22: self.m22, + } + (1, 2) => + RotationMatrix3::{ + m00: self.m00, + m01: self.m01, + m02: self.m02, + m10: self.m10, + m11: self.m11, + m12: value, + m20: self.m20, + m21: self.m21, + m22: self.m22, + } + (2, 0) => + RotationMatrix3::{ + m00: self.m00, + m01: self.m01, + m02: self.m02, + m10: self.m10, + m11: self.m11, + m12: self.m12, + m20: value, + m21: self.m21, + m22: self.m22, + } + (2, 1) => + RotationMatrix3::{ + m00: self.m00, + m01: self.m01, + m02: self.m02, + m10: self.m10, + m11: self.m11, + m12: self.m12, + m20: self.m20, + m21: value, + m22: self.m22, + } + (2, 2) => + RotationMatrix3::{ + m00: self.m00, + m01: self.m01, + m02: self.m02, + m10: self.m10, + m11: self.m11, + m12: self.m12, + m20: self.m20, + m21: self.m21, + m22: value, + } _ => self } } @@ -248,15 +384,24 @@ pub fn RotationMatrix3::set(self : RotationMatrix3, row : Int, col : Int, value /// Transpose the matrix. pub fn RotationMatrix3::transpose(self : RotationMatrix3) -> RotationMatrix3 { RotationMatrix3::{ - m00: self.m00, m01: self.m10, m02: self.m20, - m10: self.m01, m11: self.m11, m12: self.m21, - m20: self.m02, m21: self.m12, m22: self.m22, + m00: self.m00, + m01: self.m10, + m02: self.m20, + m10: self.m01, + m11: self.m11, + m12: self.m21, + m20: self.m02, + m21: self.m12, + m22: self.m22, } } ///| /// Multiply matrix by vector (matrix-vector product). -pub fn RotationMatrix3::transform(self : RotationMatrix3, v : Vector3) -> Vector3 { +pub fn RotationMatrix3::transform( + self : RotationMatrix3, + v : Vector3, +) -> Vector3 { let new_x = self.m00 * v.x + self.m01 * v.y + self.m02 * v.z let new_y = self.m10 * v.x + self.m11 * v.y + self.m12 * v.z let new_z = self.m20 * v.x + self.m21 * v.y + self.m22 * v.z @@ -265,7 +410,10 @@ pub fn RotationMatrix3::transform(self : RotationMatrix3, v : Vector3) -> Vector ///| /// Multiply two rotation matrices (matrix multiplication). -pub fn RotationMatrix3::multiply(self : RotationMatrix3, other : RotationMatrix3) -> RotationMatrix3 { +pub fn RotationMatrix3::multiply( + self : RotationMatrix3, + other : RotationMatrix3, +) -> RotationMatrix3 { RotationMatrix3::{ m00: self.m00 * other.m00 + self.m01 * other.m10 + self.m02 * other.m20, m01: self.m00 * other.m01 + self.m01 * other.m11 + self.m02 * other.m21, @@ -285,9 +433,15 @@ pub fn RotationMatrix3::rotation_x(angle : Double) -> RotationMatrix3 { let c = @math.cos(angle) let s = @math.sin(angle) RotationMatrix3::new( - m00=1.0, m01=0.0, m02=0.0, - m10=0.0, m11=c, m12=-s, - m20=0.0, m21=s, m22=c + m00=1.0, + m01=0.0, + m02=0.0, + m10=0.0, + m11=c, + m12=-s, + m20=0.0, + m21=s, + m22=c, ) } @@ -297,9 +451,15 @@ pub fn RotationMatrix3::rotation_y(angle : Double) -> RotationMatrix3 { let c = @math.cos(angle) let s = @math.sin(angle) RotationMatrix3::new( - m00=c, m01=0.0, m02=s, - m10=0.0, m11=1.0, m12=0.0, - m20=-s, m21=0.0, m22=c + m00=c, + m01=0.0, + m02=s, + m10=0.0, + m11=1.0, + m12=0.0, + m20=-s, + m21=0.0, + m22=c, ) } @@ -309,16 +469,25 @@ pub fn RotationMatrix3::rotation_z(angle : Double) -> RotationMatrix3 { let c = @math.cos(angle) let s = @math.sin(angle) RotationMatrix3::new( - m00=c, m01=-s, m02=0.0, - m10=s, m11=c, m12=0.0, - m20=0.0, m21=0.0, m22=1.0 + m00=c, + m01=-s, + m02=0.0, + m10=s, + m11=c, + m12=0.0, + m20=0.0, + m21=0.0, + m22=1.0, ) } ///| /// Create a rotation matrix around an arbitrary axis by angle (radians). /// Uses Rodrigues' rotation formula. -pub fn RotationMatrix3::rotation_axis_angle(axis : Vector3, angle : Double) -> RotationMatrix3 { +pub fn RotationMatrix3::rotation_axis_angle( + axis : Vector3, + angle : Double, +) -> RotationMatrix3 { let u = axis.normalize() let c = @math.cos(angle) let s = @math.sin(angle) @@ -334,15 +503,15 @@ pub fn RotationMatrix3::rotation_axis_angle(axis : Vector3, angle : Double) -> R let m21 = u.z * u.y * t + u.x * s let m22 = c + u.z * u.z * t - RotationMatrix3::new(m00=m00, m01=m01, m02=m02, m10=m10, m11=m11, m12=m12, m20=m20, m21=m21, m22=m22) + RotationMatrix3::new(m00~, m01~, m02~, m10~, m11~, m12~, m20~, m21~, m22~) } ///| /// Compute the determinant of the 3x3 matrix. pub fn RotationMatrix3::determinant(self : RotationMatrix3) -> Double { self.m00 * (self.m11 * self.m22 - self.m12 * self.m21) - - self.m01 * (self.m10 * self.m22 - self.m12 * self.m20) + - self.m02 * (self.m10 * self.m21 - self.m11 * self.m20) + self.m01 * (self.m10 * self.m22 - self.m12 * self.m20) + + self.m02 * (self.m10 * self.m21 - self.m11 * self.m20) } ///| @@ -358,22 +527,43 @@ pub fn RotationMatrix3::inverse(self : RotationMatrix3) -> RotationMatrix3 { ///| /// Check if matrix is a valid rotation matrix (orthogonal with det ~ 1). -pub fn RotationMatrix3::is_rotation(self : RotationMatrix3, tol? : Double = 1.0e-6) -> Bool { +pub fn RotationMatrix3::is_rotation( + self : RotationMatrix3, + tol? : Double = 1.0e-6, +) -> Bool { let det = self.determinant() if (det.abs() - 1.0).abs() > tol { return false } let rt = self.transpose() let product = self.multiply(rt) - if (product.m00 - 1.0).abs() > tol { return false } - if (product.m01 - 0.0).abs() > tol { return false } - if (product.m02 - 0.0).abs() > tol { return false } - if (product.m10 - 0.0).abs() > tol { return false } - if (product.m11 - 1.0).abs() > tol { return false } - if (product.m12 - 0.0).abs() > tol { return false } - if (product.m20 - 0.0).abs() > tol { return false } - if (product.m21 - 0.0).abs() > tol { return false } - if (product.m22 - 1.0).abs() > tol { return false } + if (product.m00 - 1.0).abs() > tol { + return false + } + if (product.m01 - 0.0).abs() > tol { + return false + } + if (product.m02 - 0.0).abs() > tol { + return false + } + if (product.m10 - 0.0).abs() > tol { + return false + } + if (product.m11 - 1.0).abs() > tol { + return false + } + if (product.m12 - 0.0).abs() > tol { + return false + } + if (product.m20 - 0.0).abs() > tol { + return false + } + if (product.m21 - 0.0).abs() > tol { + return false + } + if (product.m22 - 1.0).abs() > tol { + return false + } true } @@ -399,7 +589,11 @@ pub fn vector_centroid(vectors : Array[Vector3]) -> Vector3 { /// Compute the RMSD between two sets of paired vectors. /// Both arrays must have the same length. pub fn vector_rmsd(set_a : Array[Vector3], set_b : Array[Vector3]) -> Double { - let n = if set_a.length() < set_b.length() { set_a.length() } else { set_b.length() } + let n = if set_a.length() < set_b.length() { + set_a.length() + } else { + set_b.length() + } if n == 0 { return 0.0 } @@ -416,8 +610,15 @@ pub fn vector_rmsd(set_a : Array[Vector3], set_b : Array[Vector3]) -> Double { ///| /// Compute the superposition RMSD after optimal rotation. /// Uses the Kabsch algorithm for optimal superposition. -pub fn vector_superposition_rmsd(set_a : Array[Vector3], set_b : Array[Vector3]) -> Double { - let n = if set_a.length() < set_b.length() { set_a.length() } else { set_b.length() } +pub fn vector_superposition_rmsd( + set_a : Array[Vector3], + set_b : Array[Vector3], +) -> Double { + let n = if set_a.length() < set_b.length() { + set_a.length() + } else { + set_b.length() + } if n < 2 { return vector_rmsd(set_a, set_b) } @@ -446,16 +647,32 @@ pub fn vector_superposition_rmsd(set_a : Array[Vector3], set_b : Array[Vector3]) vector_rmsd(rotated_a, centered_b) } -pub fn test_array_full(set_a : Array[Vector3], set_b : Array[Vector3]) -> RotationMatrix3 { - let n = if set_a.length() < set_b.length() { set_a.length() } else { set_b.length() } +///| +pub fn test_array_full( + set_a : Array[Vector3], + set_b : Array[Vector3], +) -> RotationMatrix3 { + let n = if set_a.length() < set_b.length() { + set_a.length() + } else { + set_b.length() + } if n < 1 { return RotationMatrix3::identity() } RotationMatrix3::identity() } -pub fn compute_optimal_rotation(set_a : Array[Vector3], set_b : Array[Vector3]) -> RotationMatrix3 { - let n = if set_a.length() < set_b.length() { set_a.length() } else { set_b.length() } +///| +pub fn compute_optimal_rotation( + set_a : Array[Vector3], + set_b : Array[Vector3], +) -> RotationMatrix3 { + let n = if set_a.length() < set_b.length() { + set_a.length() + } else { + set_b.length() + } if n < 1 { return RotationMatrix3::identity() } @@ -506,11 +723,15 @@ pub fn compute_optimal_rotation(set_a : Array[Vector3], set_b : Array[Vector3]) let ht7 = h5 let ht8 = h8 - let norm_ht = ( - ht0 * ht0 + ht1 * ht1 + ht2 * ht2 + - ht3 * ht3 + ht4 * ht4 + ht5 * ht5 + - ht6 * ht6 + ht7 * ht7 + ht8 * ht8 - ).sqrt() + let norm_ht = (ht0 * ht0 + + ht1 * ht1 + + ht2 * ht2 + + ht3 * ht3 + + ht4 * ht4 + + ht5 * ht5 + + ht6 * ht6 + + ht7 * ht7 + + ht8 * ht8).sqrt() if norm_ht < 1.0e-15 { return RotationMatrix3::identity() @@ -518,17 +739,30 @@ pub fn compute_optimal_rotation(set_a : Array[Vector3], set_b : Array[Vector3]) let s = scale / norm_ht RotationMatrix3::new( - m00=ht0 * s, m01=ht1 * s, m02=ht2 * s, - m10=ht3 * s, m11=ht4 * s, m12=ht5 * s, - m20=ht6 * s, m21=ht7 * s, m22=ht8 * s + m00=ht0 * s, + m01=ht1 * s, + m02=ht2 * s, + m10=ht3 * s, + m11=ht4 * s, + m12=ht5 * s, + m20=ht6 * s, + m21=ht7 * s, + m22=ht8 * s, ) } ///| /// Compute the optimal transformation (rotation + translation) to superimpose set A onto set B. /// Returns a tuple of (rotation_matrix, translation_vector). -pub fn vector_superposition_transform(set_a : Array[Vector3], set_b : Array[Vector3]) -> (RotationMatrix3, Vector3) { - let n = if set_a.length() < set_b.length() { set_a.length() } else { set_b.length() } +pub fn vector_superposition_transform( + set_a : Array[Vector3], + set_b : Array[Vector3], +) -> (RotationMatrix3, Vector3) { + let n = if set_a.length() < set_b.length() { + set_a.length() + } else { + set_b.length() + } if n < 2 { return (RotationMatrix3::identity(), Vector3::zero()) } @@ -554,7 +788,11 @@ pub fn vector_superposition_transform(set_a : Array[Vector3], set_b : Array[Vect ///| /// Apply a rigid-body transformation (rotation + translation) to a set of vectors. -pub fn vector_apply_transform(vectors : Array[Vector3], rotation : RotationMatrix3, translation : Vector3) -> Array[Vector3] { +pub fn vector_apply_transform( + vectors : Array[Vector3], + rotation : RotationMatrix3, + translation : Vector3, +) -> Array[Vector3] { let result : Array[Vector3] = Array::new() for v in vectors { let rotated = rotation.transform(v) @@ -565,7 +803,12 @@ pub fn vector_apply_transform(vectors : Array[Vector3], rotation : RotationMatri ///| /// Compute the dihedral angle defined by four points (in radians). -pub fn vector_dihedral_angle(p1 : Vector3, p2 : Vector3, p3 : Vector3, p4 : Vector3) -> Double { +pub fn vector_dihedral_angle( + p1 : Vector3, + p2 : Vector3, + p3 : Vector3, + p4 : Vector3, +) -> Double { let b1 = p2.sub(p1) let b2 = p3.sub(p2) let b3 = p4.sub(p3) @@ -587,7 +830,12 @@ pub fn vector_dihedral_angle(p1 : Vector3, p2 : Vector3, p3 : Vector3, p4 : Vect ///| /// Compute the dihedral angle in degrees. -pub fn vector_dihedral_angle_degrees(p1 : Vector3, p2 : Vector3, p3 : Vector3, p4 : Vector3) -> Double { +pub fn vector_dihedral_angle_degrees( + p1 : Vector3, + p2 : Vector3, + p3 : Vector3, + p4 : Vector3, +) -> Double { let rad = vector_dihedral_angle(p1, p2, p3, p4) rad * 180.0 / @math.PI } diff --git a/src/peak_calling.mbt b/src/peak_calling.mbt index bb3ff4d4..882850ca 100644 --- a/src/peak_calling.mbt +++ b/src/peak_calling.mbt @@ -59,7 +59,11 @@ pub struct PeakCallingParams { ///| /// Construct a `ChipSeqRead` from a chromosome name, genomic /// position, and strand ("+" or "-"). -pub fn ChipSeqRead::new(chr~ : String, position~ : Int, strand~ : String) -> ChipSeqRead { +pub fn ChipSeqRead::new( + chr~ : String, + position~ : Int, + strand~ : String, +) -> ChipSeqRead { ChipSeqRead::{ chr, position, strand } } @@ -219,12 +223,8 @@ pub fn PeakCallingParams::new( /// Lanczos approximation for ln(Gamma(x)). fn pc_gammln(xx : Double) -> Double { let cof = [ - 76.18009172947146, - -86.50532032941677, - 24.01409824083091, - -1.231739572450155, - 0.1208650973866179e-2, - -0.5395239384953e-5, + 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, + 0.1208650973866179e-2, -0.5395239384953e-5, ] let x = xx let mut y = xx @@ -496,7 +496,10 @@ pub fn call_peaks( // Local background from control, scaled to treatment depth. let lambda_rate = estimate_local_lambda( - control, chr, center, params.local_lambda_size, + control, + chr, + center, + params.local_lambda_size, ) let expected_raw = lambda_rate * win_size_d * scaling // Floor expected at a small positive value to avoid div-by-zero. @@ -514,9 +517,7 @@ pub fn call_peaks( continue } - let ctrl_count = count_reads_in_window( - control, chr, win_start, win_end, - ) + let ctrl_count = count_reads_in_window(control, chr, win_start, win_end) candidates.push( CandidatePeak::new( @@ -719,8 +720,8 @@ pub fn filter_peaks( let out : Array[CandidatePeak] = Array::new() for p in peaks { if p.p_value <= params.pvalue_threshold && - p.fold_enrichment >= params.min_fold_enrichment && - p.fdr <= params.fdr_threshold { + p.fold_enrichment >= params.min_fold_enrichment && + p.fdr <= params.fdr_threshold { out.push(p) } } @@ -753,7 +754,7 @@ pub fn peak_calling_sample_data() -> (Array[ChipSeqRead], Array[ChipSeqRead]) { while k < n { // Spread reads across a ~500bp window. treatment.push( - ChipSeqRead::new(chr="chr1", position=base + (k * 17) % 500, strand="+"), + ChipSeqRead::new(chr="chr1", position=base + k * 17 % 500, strand="+"), ) k = k + 1 } @@ -763,18 +764,14 @@ pub fn peak_calling_sample_data() -> (Array[ChipSeqRead], Array[ChipSeqRead]) { // Background treatment reads scattered across the chromosome. let mut b = 0 while b < 40 { - treatment.push( - ChipSeqRead::new(chr="chr1", position=b * 250, strand="+"), - ) + treatment.push(ChipSeqRead::new(chr="chr1", position=b * 250, strand="+")) b = b + 1 } // Control: background reads across the chromosome with no strong peaks. let mut c = 0 while c < 80 { - control.push( - ChipSeqRead::new(chr="chr1", position=c * 130, strand="+"), - ) + control.push(ChipSeqRead::new(chr="chr1", position=c * 130, strand="+")) c = c + 1 } @@ -815,13 +812,25 @@ pub fn peak_calling_summary(peaks : Array[CandidatePeak]) -> String { while i < limit { let p = copy[i] buf = buf + - " " + p.chr + ":" + p.start.to_string() + "-" + p.end.to_string() + - " summit=" + p.summit.to_string() + - " reads=" + p.read_count.to_string() + - " ctrl=" + p.control_count.to_string() + - " fold=" + p.fold_enrichment.to_string() + - " p=" + p.p_value.to_string() + - " fdr=" + p.fdr.to_string() + "\n" + " " + + p.chr + + ":" + + p.start.to_string() + + "-" + + p.end.to_string() + + " summit=" + + p.summit.to_string() + + " reads=" + + p.read_count.to_string() + + " ctrl=" + + p.control_count.to_string() + + " fold=" + + p.fold_enrichment.to_string() + + " p=" + + p.p_value.to_string() + + " fdr=" + + p.fdr.to_string() + + "\n" i = i + 1 } buf diff --git a/src/phd.mbt b/src/phd.mbt index 96890d38..508b2341 100644 --- a/src/phd.mbt +++ b/src/phd.mbt @@ -131,7 +131,11 @@ pub struct PhdBase { ///| /// Create a PhdBase. -pub fn PhdBase::new(base : String, quality : Int, peak_position : Int) -> PhdBase { +pub fn PhdBase::new( + base : String, + quality : Int, + peak_position : Int, +) -> PhdBase { { base, quality, peak_position } } @@ -234,7 +238,7 @@ pub struct PhdFile { ///| /// Create a PhdFile. pub fn PhdFile::new(reads : Array[PhdRead]) -> PhdFile { - { reads } + { reads, } } ///| @@ -369,16 +373,8 @@ fn phd_parse_comment(lines : Array[String], start : Int) -> (PhdComment, Int) { } ( PhdComment::new( - chromat_file, - phred_version, - phred_parameter_file, - trace_index_min, - trace_index_max, - trim_start, - trim_end, - trim_prob, - chemistry, - dye, + chromat_file, phred_version, phred_parameter_file, trace_index_min, trace_index_max, + trim_start, trim_end, trim_prob, chemistry, dye, ), idx, ) @@ -413,10 +409,7 @@ fn phd_parse_dna(lines : Array[String], start : Int) -> (Array[PhdBase], Int) { ///| /// Parse a single PHD sequence block (BEGIN_SEQUENCE ... END_SEQUENCE). -fn phd_parse_sequence( - lines : Array[String], - start : Int, -) -> (PhdRead?, Int) { +fn phd_parse_sequence(lines : Array[String], start : Int) -> (PhdRead?, Int) { let first_line = trim(lines[start].to_string()) // Extract read name from "BEGIN_SEQUENCE name" let tokens = phd_tokenize(first_line) @@ -424,9 +417,7 @@ fn phd_parse_sequence( return (None, start + 1) } let read_name = tokens[1] - let mut comment = PhdComment::new( - "", "", "", 0, 0, 0, 0, 0.0, "", "", - ) + let mut comment = PhdComment::new("", "", "", 0, 0, 0, 0, 0.0, "", "") let mut bases : Array[PhdBase] = [] let mut idx = start + 1 while idx < lines.length() { @@ -498,7 +489,13 @@ pub fn phd_sample_text() -> String { let quals = [35, 40, 45, 50, 38, 42, 47, 33, 39, 44] let peaks = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] for i in 0..<10 { - s = s + bases[i] + " " + quals[i].to_string() + " " + peaks[i].to_string() + "\n" + s = s + + bases[i] + + " " + + quals[i].to_string() + + " " + + peaks[i].to_string() + + "\n" } s = s + "END_DNA\n\n" s = s + "END_SEQUENCE\n" @@ -512,7 +509,11 @@ pub fn phd_sample_text() -> String { ///| /// Format a PhdRead as a readable string. pub fn PhdRead::to_string(self : PhdRead) -> String { - let mut s = "PhdRead(name=" + self.name + ", length=" + self.length().to_string() + ")\n" + let mut s = "PhdRead(name=" + + self.name + + ", length=" + + self.length().to_string() + + ")\n" s = s + " chromat_file: " + self.comment.chromat_file + "\n" s = s + " phred_version: " + self.comment.phred_version + "\n" s = s + " sequence: " + self.sequence() + "\n" diff --git a/src/pheatmap.mbt b/src/pheatmap.mbt index c8a5380e..95e0ca3e 100644 --- a/src/pheatmap.mbt +++ b/src/pheatmap.mbt @@ -19,10 +19,24 @@ pub enum DistanceMethod { } ///| -pub fn distance_method_euclidean() -> DistanceMethod { DistanceMethod::Euclidean } -pub fn distance_method_manhattan() -> DistanceMethod { DistanceMethod::Manhattan } -pub fn distance_method_correlation() -> DistanceMethod { DistanceMethod::Correlation } -pub fn distance_method_maximum() -> DistanceMethod { DistanceMethod::Maximum } +pub fn distance_method_euclidean() -> DistanceMethod { + DistanceMethod::Euclidean +} + +///| +pub fn distance_method_manhattan() -> DistanceMethod { + DistanceMethod::Manhattan +} + +///| +pub fn distance_method_correlation() -> DistanceMethod { + DistanceMethod::Correlation +} + +///| +pub fn distance_method_maximum() -> DistanceMethod { + DistanceMethod::Maximum +} ///| pub enum ClusterMethod { @@ -33,10 +47,24 @@ pub enum ClusterMethod { } ///| -pub fn cluster_method_complete() -> ClusterMethod { ClusterMethod::Complete } -pub fn cluster_method_average() -> ClusterMethod { ClusterMethod::Average } -pub fn cluster_method_ward() -> ClusterMethod { ClusterMethod::Ward } -pub fn cluster_method_single() -> ClusterMethod { ClusterMethod::Single } +pub fn cluster_method_complete() -> ClusterMethod { + ClusterMethod::Complete +} + +///| +pub fn cluster_method_average() -> ClusterMethod { + ClusterMethod::Average +} + +///| +pub fn cluster_method_ward() -> ClusterMethod { + ClusterMethod::Ward +} + +///| +pub fn cluster_method_single() -> ClusterMethod { + ClusterMethod::Single +} ///| pub struct PheatmapInput { @@ -101,7 +129,11 @@ pub fn distance_manhattan(a : Array[Double], b : Array[Double]) -> Double { let mut i = 0 while i < n { let d = a[i] - b[i] - if d < 0.0 { sum = sum - d } else { sum = sum + d } + if d < 0.0 { + sum = sum - d + } else { + sum = sum + d + } i = i + 1 } sum @@ -115,7 +147,9 @@ pub fn distance_maximum(a : Array[Double], b : Array[Double]) -> Double { while i < n { let d = a[i] - b[i] let ad = if d < 0.0 { -d } else { d } - if ad > mx { mx = ad } + if ad > mx { + mx = ad + } i = i + 1 } mx @@ -124,7 +158,9 @@ pub fn distance_maximum(a : Array[Double], b : Array[Double]) -> Double { ///| pub fn distance_correlation(a : Array[Double], b : Array[Double]) -> Double { let n = a.length() - if n < 2 { return 1.0 } + if n < 2 { + return 1.0 + } let mut ma = 0.0 let mut mb = 0.0 let mut i = 0 @@ -148,7 +184,9 @@ pub fn distance_correlation(a : Array[Double], b : Array[Double]) -> Double { j = j + 1 } let denom = (da * db).sqrt() - if denom == 0.0 { return 1.0 } + if denom == 0.0 { + return 1.0 + } let corr = num / denom 1.0 - corr } @@ -161,7 +199,10 @@ pub fn pheatmap_distance_matrix( let n = data.length() let dist : Array[Array[Double]] = Array::new() let mut ri = 0 - while ri < n { dist.push(Array::make(n, 0.0)); ri = ri + 1 } + while ri < n { + dist.push(Array::make(n, 0.0)) + ri = ri + 1 + } let mut i = 0 while i < n { let mut j = 0 @@ -191,11 +232,16 @@ pub fn pheatmap_column_distance_matrix( method : DistanceMethod, ) -> Array[Array[Double]] { let n = data.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let p = data[0].length() let col_data : Array[Array[Double]] = Array::new() let mut cj = 0 - while cj < p { col_data.push(Array::make(n, 0.0)); cj = cj + 1 } + while cj < p { + col_data.push(Array::make(n, 0.0)) + cj = cj + 1 + } let mut j = 0 while j < p { let mut i = 0 @@ -237,15 +283,24 @@ pub fn hclust_complete(dist : Array[Array[Double]]) -> HclustResult { // cluster[i] = current cluster id for point i (initially -i-1 for leaves) let cluster : Array[Int] = Array::make(n, 0) let mut i = 0 - while i < n { cluster[i] = -i - 1; i = i + 1 } + while i < n { + cluster[i] = -i - 1 + i = i + 1 + } // Working distance matrix for merging let work_dist : Array[Array[Double]] = Array::new() let mut wi = 0 - while wi < n { work_dist.push(Array::make(n, 0.0)); wi = wi + 1 } + while wi < n { + work_dist.push(Array::make(n, 0.0)) + wi = wi + 1 + } let mut ri = 0 while ri < n { let mut cj = 0 - while cj < n { work_dist[ri][cj] = dist[ri][cj]; cj = cj + 1 } + while cj < n { + work_dist[ri][cj] = dist[ri][cj] + cj = cj + 1 + } ri = ri + 1 } let merge : Array[(Int, Int)] = Array::new() @@ -263,7 +318,11 @@ pub fn hclust_complete(dist : Array[Array[Double]]) -> HclustResult { while b < n { if cluster[a] != cluster[b] { let d = work_dist[a][b] - if d < min_d { min_d = d; min_i = a; min_j = b } + if d < min_d { + min_d = d + min_i = a + min_j = b + } } b = b + 1 } @@ -278,7 +337,9 @@ pub fn hclust_complete(dist : Array[Array[Double]]) -> HclustResult { let old_j = cluster[min_j] let mut k = 0 while k < n { - if cluster[k] == old_i || cluster[k] == old_j { cluster[k] = new_id } + if cluster[k] == old_i || cluster[k] == old_j { + cluster[k] = new_id + } k = k + 1 } // Update distance matrix for the merged cluster (complete linkage: max distance) @@ -303,25 +364,32 @@ pub fn hclust_complete(dist : Array[Array[Double]]) -> HclustResult { HclustResult::{ merge, height, order, n } } +///| fn hclust_inorder(merge : Array[(Int, Int)], n : Int) -> Array[Int] { let result : Array[Int] = Array::new() - if n <= 0 { return result } + if n <= 0 { + return result + } // The last merge (merge[length-1]) contains the final cluster let final_idx = merge.length() - 1 let left_result = hclust_inorder_rec(merge, merge[final_idx].0) let right_result = hclust_inorder_rec(merge, merge[final_idx].1) // Combine let mut i = 0 - while i < left_result.length() { result.push(left_result[i]); i = i + 1 } + while i < left_result.length() { + result.push(left_result[i]) + i = i + 1 + } let mut j = 0 - while j < right_result.length() { result.push(right_result[j]); j = j + 1 } + while j < right_result.length() { + result.push(right_result[j]) + j = j + 1 + } result } -fn hclust_inorder_rec( - merge : Array[(Int, Int)], - node : Int, -) -> Array[Int] { +///| +fn hclust_inorder_rec(merge : Array[(Int, Int)], node : Int) -> Array[Int] { if node < 0 { // Leaf node: -node-1 gives the original index [-node - 1] @@ -332,9 +400,15 @@ fn hclust_inorder_rec( let right = hclust_inorder_rec(merge, merge[merge_idx].1) let result : Array[Int] = Array::new() let mut i = 0 - while i < left.length() { result.push(left[i]); i = i + 1 } + while i < left.length() { + result.push(left[i]) + i = i + 1 + } let mut j = 0 - while j < right.length() { result.push(right[j]); j = j + 1 } + while j < right.length() { + result.push(right[j]) + j = j + 1 + } result } } @@ -346,14 +420,17 @@ pub fn hclust_cutree(result : HclustResult, k : Int) -> Array[Int] { let clusters : Array[Int] = Array::make(n, 0) if k <= 1 || k >= n { let mut i = 0 - while i < n { clusters[order[i]] = 1; i = i + 1 } + while i < n { + clusters[order[i]] = 1 + i = i + 1 + } return clusters } // Find split points from merge tree let total_merges = result.merge.length() let cut_point = total_merges - k + 1 // Create cluster assignments by following the merge tree - let node_cluster : Map[Int, Int] = Map([], capacity = total_merges + n) + let node_cluster : Map[Int, Int] = Map([], capacity=total_merges + n) let mut cluster_id = 0 let mut i = 0 while i < n { @@ -382,7 +459,7 @@ pub fn hclust_cutree(result : HclustResult, k : Int) -> Array[Int] { step = step + 1 } // Assign final cluster labels - let label_map = Map([], capacity = n) + let label_map = Map([], capacity=n) let mut final_id = 0 let mut k2 = 0 while k2 < n { @@ -427,11 +504,21 @@ pub fn heat_colors(n : Int) -> Array[String] { let mut i = 0 while i < n { let t = i.to_double() / (n.to_double() - 1.0) - let clamped_t = if t < 0.0 { 0.0 } else { if t > 1.0 { 1.0 } else { t } } - let clamped_inv = if (1.0 - t) < 0.0 { 0.0 } else { if (1.0 - t) > 1.0 { 1.0 } else { 1.0 - t } } + let clamped_t = if t < 0.0 { 0.0 } else if t > 1.0 { 1.0 } else { t } + let clamped_inv = if 1.0 - t < 0.0 { + 0.0 + } else if 1.0 - t > 1.0 { + 1.0 + } else { + 1.0 - t + } let r = (255.0 * clamped_t).to_int() let b = (255.0 * clamped_inv).to_int() - let g = if t < 0.5 { (255.0 * t * 2.0).to_int() } else { (255.0 * (1.0 - t) * 2.0).to_int() } + let g = if t < 0.5 { + (255.0 * t * 2.0).to_int() + } else { + (255.0 * (1.0 - t) * 2.0).to_int() + } let clamp_r = if r < 0 { 0 } else if r > 255 { 255 } else { r } let clamp_g = if g < 0 { 0 } else if g > 255 { 255 } else { g } let clamp_b = if b < 0 { 0 } else if b > 255 { 255 } else { b } @@ -442,6 +529,7 @@ pub fn heat_colors(n : Int) -> Array[String] { colors } +///| fn pheatmap_hex_color(r : Int, g : Int, b : Int) -> String { let rh = pheatmap_int_to_hex(r) let gh = pheatmap_int_to_hex(g) @@ -449,8 +537,11 @@ fn pheatmap_hex_color(r : Int, g : Int, b : Int) -> String { "#\{rh}\{gh}\{bh}" } +///| fn pheatmap_int_to_hex(v : Int) -> String { - let digits = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"] + let digits = [ + "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", + ] let hi = v / 16 let lo = v % 16 "\{digits[hi]}\{digits[lo]}" @@ -521,9 +612,9 @@ pub fn pheatmap_input( clustering_method: ClusterMethod::Complete, cutree_rows: 1, cutree_cols: 1, - annotation_row: Map([], capacity = n), - annotation_col: Map([], capacity = m), - annotation_colors: Map([], capacity = 0), + annotation_row: Map([], capacity=n), + annotation_col: Map([], capacity=m), + annotation_colors: Map([], capacity=0), display_numbers: false, number_format: "{:.2f}", number_color: "black", @@ -531,16 +622,21 @@ pub fn pheatmap_input( } } +///| fn pheatmap_matrix_min(mat : Array[Array[Double]]) -> Double { let n = mat.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut mn = mat[0][0] let mut i = 0 while i < n { let m = mat[i].length() let mut j = 0 while j < m { - if mat[i][j] < mn { mn = mat[i][j] } + if mat[i][j] < mn { + mn = mat[i][j] + } j = j + 1 } i = i + 1 @@ -548,16 +644,21 @@ fn pheatmap_matrix_min(mat : Array[Array[Double]]) -> Double { mn } +///| fn pheatmap_matrix_max(mat : Array[Array[Double]]) -> Double { let n = mat.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let mut mx = mat[0][0] let mut i = 0 while i < n { let m = mat[i].length() let mut j = 0 while j < m { - if mat[i][j] > mx { mx = mat[i][j] } + if mat[i][j] > mx { + mx = mat[i][j] + } j = j + 1 } i = i + 1 @@ -567,7 +668,10 @@ fn pheatmap_matrix_max(mat : Array[Array[Double]]) -> Double { ///| /// Set color scheme. -pub fn pheatmap_set_color(input : PheatmapInput, color : Array[String]) -> PheatmapInput { +pub fn pheatmap_set_color( + input : PheatmapInput, + color : Array[String], +) -> PheatmapInput { PheatmapInput::{ mat: input.mat, row_names: input.row_names, @@ -599,7 +703,10 @@ pub fn pheatmap_set_color(input : PheatmapInput, color : Array[String]) -> Pheat ///| /// Set breaks for color scale. -pub fn pheatmap_set_breaks(input : PheatmapInput, breaks : Array[Double]) -> PheatmapInput { +pub fn pheatmap_set_breaks( + input : PheatmapInput, + breaks : Array[Double], +) -> PheatmapInput { PheatmapInput::{ mat: input.mat, row_names: input.row_names, @@ -774,7 +881,10 @@ pub fn pheatmap_set_cluster( ///| /// Set main title. -pub fn pheatmap_set_title(input : PheatmapInput, title : String) -> PheatmapInput { +pub fn pheatmap_set_title( + input : PheatmapInput, + title : String, +) -> PheatmapInput { PheatmapInput::{ mat: input.mat, row_names: input.row_names, @@ -811,7 +921,7 @@ pub fn pheatmap_add_annotation_row( name : String, values : Array[String], ) -> PheatmapInput { - let new_annot = Map([], capacity = input.annotation_row.length() + 1) + let new_annot = Map([], capacity=input.annotation_row.length() + 1) for key in input.annotation_row.keys() { new_annot[key] = input.annotation_row[key] } @@ -852,7 +962,7 @@ pub fn pheatmap_add_annotation_col( name : String, values : Array[String], ) -> PheatmapInput { - let new_annot = Map([], capacity = input.annotation_col.length() + 1) + let new_annot = Map([], capacity=input.annotation_col.length() + 1) for key in input.annotation_col.keys() { new_annot[key] = input.annotation_col[key] } @@ -893,7 +1003,7 @@ pub fn pheatmap_set_annotation_color( annot_name : String, value_color_map : Map[String, String], ) -> PheatmapInput { - let new_colors = Map([], capacity = input.annotation_colors.length() + 1) + let new_colors = Map([], capacity=input.annotation_colors.length() + 1) for key in input.annotation_colors.keys() { new_colors[key] = input.annotation_colors[key] } @@ -996,9 +1106,15 @@ pub fn pheatmap_render(input : PheatmapInput) -> PheatmapResult { let mut row_order : Array[Int] = Array::make(n, 0) let mut col_order : Array[Int] = Array::make(m, 0) let mut i = 0 - while i < n { row_order[i] = i; i = i + 1 } + while i < n { + row_order[i] = i + i = i + 1 + } let mut j = 0 - while j < m { col_order[j] = j; j = j + 1 } + while j < m { + col_order[j] = j + j = j + 1 + } let mut row_clusters : Array[Int] = Array::new() let mut col_clusters : Array[Int] = Array::new() let mut row_dendrogram = "" @@ -1013,7 +1129,10 @@ pub fn pheatmap_render(input : PheatmapInput) -> PheatmapResult { } } if input.cluster_cols && m > 1 { - let col_dist = pheatmap_column_distance_matrix(mat, input.clustering_distance_cols) + let col_dist = pheatmap_column_distance_matrix( + mat, + input.clustering_distance_cols, + ) let col_hc = hclust_complete(col_dist) col_order = col_hc.order col_dendrogram = "clustered ({col_hc.merge.length()} merges)" @@ -1022,7 +1141,9 @@ pub fn pheatmap_render(input : PheatmapInput) -> PheatmapResult { } } // Build text output - let text = pheatmap_build_text(input, row_order, col_order, row_clusters, col_clusters) + let text = pheatmap_build_text( + input, row_order, col_order, row_clusters, col_clusters, + ) let legend = pheatmap_build_legend(input.breaks, input.color, input.legend) PheatmapResult::{ text, @@ -1038,6 +1159,7 @@ pub fn pheatmap_render(input : PheatmapInput) -> PheatmapResult { } } +///| fn pheatmap_build_text( input : PheatmapInput, row_order : Array[Int], @@ -1078,13 +1200,21 @@ fn pheatmap_build_text( let mut i = 0 while i < n { let row_idx = row_order[i] - let row_name = if input.show_row_names { input.row_names[row_idx] } else { "" } + let row_name = if input.show_row_names { + input.row_names[row_idx] + } else { + "" + } let mut line = pheatmap_pad_str(row_name, 8) let mut j = 0 while j < m { let col_idx = col_order[j] let val = input.mat[row_idx][col_idx] - let color_idx = pheatmap_value_to_color_idx(val, input.breaks, input.color.length()) + let color_idx = pheatmap_value_to_color_idx( + val, + input.breaks, + input.color.length(), + ) let color = input.color[color_idx] let cell = if input.display_numbers { pheatmap_format_value(val, input.number_format) @@ -1100,76 +1230,116 @@ fn pheatmap_build_text( // Cluster info if row_clusters.length() > 0 { lines.push("") - lines.push("Row clusters: \{row_clusters.length()} points assigned to \{pheatmap_unique_count(row_clusters)} clusters") + lines.push( + "Row clusters: \{row_clusters.length()} points assigned to \{pheatmap_unique_count(row_clusters)} clusters", + ) } if col_clusters.length() > 0 { - lines.push("Column clusters: \{col_clusters.length()} points assigned to \{pheatmap_unique_count(col_clusters)} clusters") + lines.push( + "Column clusters: \{col_clusters.length()} points assigned to \{pheatmap_unique_count(col_clusters)} clusters", + ) } lines.join("\n") } +///| fn pheatmap_pad_str(s : String, width : Int) -> String { - if s.length() >= width { return s } + if s.length() >= width { + return s + } let padded = s let mut result = padded let mut i = padded.length() - while i < width { result = result + " "; i = i + 1 } + while i < width { + result = result + " " + i = i + 1 + } result } +///| fn pheatmap_value_to_color_idx( val : Double, breaks : Array[Double], n_colors : Int, ) -> Int { - if n_colors == 0 { return 0 } - if breaks.length() < 2 { return n_colors / 2 } + if n_colors == 0 { + return 0 + } + if breaks.length() < 2 { + return n_colors / 2 + } let min_b = breaks[0] let max_b = breaks[breaks.length() - 1] - if val <= min_b { return 0 } - if val >= max_b { return n_colors - 1 } + if val <= min_b { + return 0 + } + if val >= max_b { + return n_colors - 1 + } let range = max_b - min_b let idx = ((val - min_b) / range * (n_colors - 1).to_double()).to_int() - if idx < 0 { return 0 } - if idx >= n_colors { return n_colors - 1 } + if idx < 0 { + return 0 + } + if idx >= n_colors { + return n_colors - 1 + } idx } +///| fn pheatmap_color_cell(color : String) -> String { // Simple text representation using color name "[" + color + "]" } +///| fn pheatmap_format_value(val : Double, format : String) -> String { // Simple format: show 2 decimal places let s = val.to_string() // Truncate to 5 chars - if s.length() > 6 { return s[0:6].to_owned() } + if s.length() > 6 { + return s[0:6].to_owned() + } s } +///| fn pheatmap_unique_count(arr : Array[Int]) -> Int { - let seen = Map([], capacity = arr.length()) + let seen = Map([], capacity=arr.length()) let mut count = 0 for v in arr { - if !seen.contains(v) { seen[v] = true; count = count + 1 } + if !seen.contains(v) { + seen[v] = true + count = count + 1 + } } count } +///| fn pheatmap_build_legend( breaks : Array[Double], color : Array[String], show : Bool, ) -> String { - if !show { return "" } + if !show { + return "" + } let n = color.length() - if n == 0 { return "" } + if n == 0 { + return "" + } let lines : Array[String] = Array::new() lines.push("Legend:") lines.push(" Min: \{breaks[0]}") let mid_idx = n / 2 - let mid_val = if breaks.length() > mid_idx { breaks[mid_idx] } else { breaks[breaks.length() - 1] } + let mid_val = if breaks.length() > mid_idx { + breaks[mid_idx] + } else { + breaks[breaks.length() - 1] + } lines.push(" Mid: \{mid_val}") lines.push(" Max: \{breaks[breaks.length() - 1]}") lines.join("\n") diff --git a/src/phenotype.mbt b/src/phenotype.mbt index cc6595e6..62498767 100644 --- a/src/phenotype.mbt +++ b/src/phenotype.mbt @@ -68,7 +68,12 @@ pub struct PhenControlSubtracted { ///| /// Create a new WellRecord. -pub fn WellRecord::new(well_id : String, plate_id : String, times : Array[Double], signals : Array[Double]) -> WellRecord { +pub fn WellRecord::new( + well_id : String, + plate_id : String, + times : Array[Double], + signals : Array[Double], +) -> WellRecord { WellRecord::{ well_id, plate_id, times, signals } } @@ -93,7 +98,11 @@ pub fn WellRecord::phen_get_time(self : WellRecord, idx : Int) -> Double { ///| /// Get maximum signal value. pub fn WellRecord::phen_max_signal(self : WellRecord) -> Double { - let mut max_val = if self.signals.length() > 0 { self.signals[0] } else { 0.0 } + let mut max_val = if self.signals.length() > 0 { + self.signals[0] + } else { + 0.0 + } let mut i = 1 while i < self.signals.length() { if self.signals[i] > max_val { @@ -107,7 +116,11 @@ pub fn WellRecord::phen_max_signal(self : WellRecord) -> Double { ///| /// Get minimum signal value. pub fn WellRecord::phen_min_signal(self : WellRecord) -> Double { - let mut min_val = if self.signals.length() > 0 { self.signals[0] } else { 0.0 } + let mut min_val = if self.signals.length() > 0 { + self.signals[0] + } else { + 0.0 + } let mut i = 1 while i < self.signals.length() { if self.signals[i] < min_val { @@ -147,7 +160,11 @@ pub fn WellRecord::phen_max_slope(self : WellRecord) -> Double { let mut i = 1 while i < n { let dt = self.times[i] - self.times[i - 1] - let local_slope = if dt > 0.0 { (self.signals[i] - self.signals[i - 1]) / dt } else { 0.0 } + let local_slope = if dt > 0.0 { + (self.signals[i] - self.signals[i - 1]) / dt + } else { + 0.0 + } if local_slope > max_slope { max_slope = local_slope } @@ -160,13 +177,19 @@ pub fn WellRecord::phen_max_slope(self : WellRecord) -> Double { ///| /// Create a new PlateRecord. -pub fn PlateRecord::new(plate_id : String, times : Array[Double]) -> PlateRecord { +pub fn PlateRecord::new( + plate_id : String, + times : Array[Double], +) -> PlateRecord { PlateRecord::{ plate_id, wells: Array::new(), times } } ///| /// Add a well to the plate. -pub fn PlateRecord::phen_add_well(self : PlateRecord, well : WellRecord) -> PlateRecord { +pub fn PlateRecord::phen_add_well( + self : PlateRecord, + well : WellRecord, +) -> PlateRecord { let new_wells = self.wells.copy() new_wells.push(well) PlateRecord::{ plate_id: self.plate_id, wells: new_wells, times: self.times } @@ -180,7 +203,10 @@ pub fn PlateRecord::phen_n_wells(self : PlateRecord) -> Int { ///| /// Get a well by well_id (returns Option). -pub fn PlateRecord::phen_get_well(self : PlateRecord, well_id : String) -> WellRecord? { +pub fn PlateRecord::phen_get_well( + self : PlateRecord, + well_id : String, +) -> WellRecord? { let mut found : WellRecord? = None let mut i = 0 while i < self.wells.length() { @@ -195,7 +221,10 @@ pub fn PlateRecord::phen_get_well(self : PlateRecord, well_id : String) -> WellR ///| /// Get a well at an index. -pub fn PlateRecord::phen_get_well_at(self : PlateRecord, idx : Int) -> WellRecord { +pub fn PlateRecord::phen_get_well_at( + self : PlateRecord, + idx : Int, +) -> WellRecord { self.wells[idx] } @@ -207,7 +236,10 @@ pub fn PlateRecord::phen_n_times(self : PlateRecord) -> Int { ///| /// Get mean signal across all wells at a time index. -pub fn PlateRecord::phen_mean_signal_at(self : PlateRecord, time_idx : Int) -> Double { +pub fn PlateRecord::phen_mean_signal_at( + self : PlateRecord, + time_idx : Int, +) -> Double { if self.wells.length() == 0 { return 0.0 } @@ -240,7 +272,11 @@ fn phen_estimate_initial(well : WellRecord) -> (Double, Double, Double, Double) let mut i = 1 while i < n { let dt = well.times[i] - well.times[i - 1] - let local_slope = if dt > 0.0 { (well.signals[i] - well.signals[i - 1]) / dt } else { 0.0 } + let local_slope = if dt > 0.0 { + (well.signals[i] - well.signals[i - 1]) / dt + } else { + 0.0 + } if local_slope > max_slope_val { max_slope_val = local_slope inflection = well.times[i] @@ -253,7 +289,13 @@ fn phen_estimate_initial(well : WellRecord) -> (Double, Double, Double, Double) ///| /// Logistic model: L / (1 + exp(-k * (t - t0))) + offset. /// L = asymptote, k = growth rate, t0 = inflection, offset = initial. -fn phen_logistic_model(t : Double, asymptote : Double, slope : Double, inflection : Double, initial : Double) -> Double { +fn phen_logistic_model( + t : Double, + asymptote : Double, + slope : Double, + inflection : Double, + initial : Double, +) -> Double { // f(t) = initial + (asymptote - initial) / (1 + exp(-slope * (t - inflection))) let exponent = -slope * (t - inflection) let denom = 1.0 + phen_safe_exp(exponent) @@ -262,7 +304,13 @@ fn phen_logistic_model(t : Double, asymptote : Double, slope : Double, inflectio ///| /// Gompertz model: initial + (asymptote - initial) * exp(-exp(-slope * (t - inflection))). -fn phen_gompertz_model(t : Double, asymptote : Double, slope : Double, inflection : Double, initial : Double) -> Double { +fn phen_gompertz_model( + t : Double, + asymptote : Double, + slope : Double, + inflection : Double, + initial : Double, +) -> Double { let inner = -slope * (t - inflection) let outer = -phen_safe_exp(inner) initial + (asymptote - initial) * phen_safe_exp(outer) @@ -283,14 +331,34 @@ fn phen_safe_exp(x : Double) -> Double { ///| /// Compute logistic curve fit using simplified grid search around estimates. pub fn phen_fit_logistic(well : WellRecord) -> PhenFitParams { - let (initial, plateau, slope_est, inflection_est) = phen_estimate_initial(well) + let (initial, plateau, slope_est, inflection_est) = phen_estimate_initial( + well, + ) let asymptote = plateau // Refine inflection and slope via coarse grid search let mut best_rss = 1.0e300 let mut best_slope = slope_est let mut best_inflection = inflection_est - let slope_candidates = [slope_est * 0.5, slope_est, slope_est * 1.5, slope_est * 2.0, 0.1, 0.5, 1.0] - let infl_candidates = [inflection_est - 5.0, inflection_est - 2.0, inflection_est, inflection_est + 2.0, inflection_est + 5.0, 0.0, 5.0, 10.0, 15.0] + let slope_candidates = [ + slope_est * 0.5, + slope_est, + slope_est * 1.5, + slope_est * 2.0, + 0.1, + 0.5, + 1.0, + ] + let infl_candidates = [ + inflection_est - 5.0, + inflection_est - 2.0, + inflection_est, + inflection_est + 2.0, + inflection_est + 5.0, + 0.0, + 5.0, + 10.0, + 15.0, + ] let mut si = 0 while si < slope_candidates.length() { let mut ii = 0 @@ -300,7 +368,13 @@ pub fn phen_fit_logistic(well : WellRecord) -> PhenFitParams { let mut rss = 0.0 let mut k = 0 while k < well.times.length() { - let pred = phen_logistic_model(well.times[k], asymptote, s, infl, initial) + let pred = phen_logistic_model( + well.times[k], + asymptote, + s, + infl, + initial, + ) let diff = well.signals[k] - pred rss = rss + diff * diff k = k + 1 @@ -315,7 +389,11 @@ pub fn phen_fit_logistic(well : WellRecord) -> PhenFitParams { si = si + 1 } // Lag time estimate: inflection - 1/slope - let lag_time = if best_slope > 0.0 { best_inflection - 1.0 / best_slope } else { 0.0 } + let lag_time = if best_slope > 0.0 { + best_inflection - 1.0 / best_slope + } else { + 0.0 + } let lag_clamped = if lag_time < 0.0 { 0.0 } else { lag_time } // R-squared let mean_y = phen_mean(well.signals) @@ -331,20 +409,40 @@ pub fn phen_fit_logistic(well : WellRecord) -> PhenFitParams { initial, model: "logistic", rss: best_rss, - r_squared: r_sq_clamped + r_squared: r_sq_clamped, } } ///| /// Compute Gompertz curve fit using simplified grid search. pub fn phen_fit_gompertz(well : WellRecord) -> PhenFitParams { - let (initial, plateau, slope_est, inflection_est) = phen_estimate_initial(well) + let (initial, plateau, slope_est, inflection_est) = phen_estimate_initial( + well, + ) let asymptote = plateau let mut best_rss = 1.0e300 let mut best_slope = slope_est let mut best_inflection = inflection_est - let slope_candidates = [slope_est * 0.5, slope_est, slope_est * 1.5, slope_est * 2.0, 0.1, 0.5, 1.0] - let infl_candidates = [inflection_est - 5.0, inflection_est - 2.0, inflection_est, inflection_est + 2.0, inflection_est + 5.0, 0.0, 5.0, 10.0, 15.0] + let slope_candidates = [ + slope_est * 0.5, + slope_est, + slope_est * 1.5, + slope_est * 2.0, + 0.1, + 0.5, + 1.0, + ] + let infl_candidates = [ + inflection_est - 5.0, + inflection_est - 2.0, + inflection_est, + inflection_est + 2.0, + inflection_est + 5.0, + 0.0, + 5.0, + 10.0, + 15.0, + ] let mut si = 0 while si < slope_candidates.length() { let mut ii = 0 @@ -354,7 +452,13 @@ pub fn phen_fit_gompertz(well : WellRecord) -> PhenFitParams { let mut rss = 0.0 let mut k = 0 while k < well.times.length() { - let pred = phen_gompertz_model(well.times[k], asymptote, s, infl, initial) + let pred = phen_gompertz_model( + well.times[k], + asymptote, + s, + infl, + initial, + ) let diff = well.signals[k] - pred rss = rss + diff * diff k = k + 1 @@ -368,7 +472,11 @@ pub fn phen_fit_gompertz(well : WellRecord) -> PhenFitParams { } si = si + 1 } - let lag_time = if best_slope > 0.0 { best_inflection - 1.0 / best_slope } else { 0.0 } + let lag_time = if best_slope > 0.0 { + best_inflection - 1.0 / best_slope + } else { + 0.0 + } let lag_clamped = if lag_time < 0.0 { 0.0 } else { lag_time } let mean_y = phen_mean(well.signals) let ss_tot = phen_sum_sq(well.signals, mean_y) @@ -383,7 +491,7 @@ pub fn phen_fit_gompertz(well : WellRecord) -> PhenFitParams { initial, model: "gompertz", rss: best_rss, - r_squared: r_sq_clamped + r_squared: r_sq_clamped, } } @@ -417,14 +525,29 @@ fn phen_sum_sq(arr : Array[Double], center : Double) -> Double { ///| /// Compute predicted values from a fitted model. -pub fn phen_predict(fit : PhenFitParams, times : Array[Double]) -> Array[Double] { +pub fn phen_predict( + fit : PhenFitParams, + times : Array[Double], +) -> Array[Double] { let preds : Array[Double] = Array::new() let mut i = 0 while i < times.length() { let pred = if fit.model == "logistic" { - phen_logistic_model(times[i], fit.asymptote, fit.slope, fit.inflection, fit.initial) + phen_logistic_model( + times[i], + fit.asymptote, + fit.slope, + fit.inflection, + fit.initial, + ) } else if fit.model == "gompertz" { - phen_gompertz_model(times[i], fit.asymptote, fit.slope, fit.inflection, fit.initial) + phen_gompertz_model( + times[i], + fit.asymptote, + fit.slope, + fit.inflection, + fit.initial, + ) } else { fit.asymptote } @@ -438,7 +561,10 @@ pub fn phen_predict(fit : PhenFitParams, times : Array[Double]) -> Array[Double] ///| /// Subtract control well signals from sample wells. -pub fn phen_subtract_control(plate : PlateRecord, control_well_id : String) -> PhenControlSubtracted { +pub fn phen_subtract_control( + plate : PlateRecord, + control_well_id : String, +) -> PhenControlSubtracted { let control_opt = plate.phen_get_well(control_well_id) let well_ids : Array[String] = Array::new() let signals : Array[Array[Double]] = Array::new() @@ -454,7 +580,11 @@ pub fn phen_subtract_control(plate : PlateRecord, control_well_id : String) -> P let sub : Array[Double] = Array::new() let mut j = 0 while j < w.signals.length() { - let ctrl = if j < control_signals.length() { control_signals[j] } else { 0.0 } + let ctrl = if j < control_signals.length() { + control_signals[j] + } else { + 0.0 + } let v = w.signals[j] - ctrl sub.push(v) j = j + 1 @@ -505,13 +635,23 @@ pub fn phen_parse_csv(csv_text : String) -> PlateRecord { new_times.push(t) let new_signals = w.signals.copy() new_signals.push(s) - well_map.set(wid, WellRecord::{ well_id: wid, plate_id: pid, times: new_times, signals: new_signals }) + well_map.set(wid, WellRecord::{ + well_id: wid, + plate_id: pid, + times: new_times, + signals: new_signals, + }) } else { let new_times : Array[Double] = Array::new() new_times.push(t) let new_signals : Array[Double] = Array::new() new_signals.push(s) - well_map.set(wid, WellRecord::{ well_id: wid, plate_id: pid, times: new_times, signals: new_signals }) + well_map.set(wid, WellRecord::{ + well_id: wid, + plate_id: pid, + times: new_times, + signals: new_signals, + }) } times_collected.push(t) } @@ -634,7 +774,12 @@ fn phen_json_extract_wells(json : String) -> Array[WellRecord] { let sigs = phen_json_extract_double_array(obj_str, "signals") let pid = phen_json_extract_string(json, "plate") let times = phen_json_extract_double_array(json, "times") - wells.push(WellRecord::{ well_id: wid, plate_id: pid, times, signals: sigs }) + wells.push(WellRecord::{ + well_id: wid, + plate_id: pid, + times, + signals: sigs, + }) } if json[pos] == ']' { depth = depth - 1 @@ -677,7 +822,11 @@ fn phen_parse_double(s : String) -> Double { i = i + 1 } let v = int_part + frac_part - if neg { -v } else { v } + if neg { + -v + } else { + v + } } ///| @@ -699,7 +848,8 @@ fn phen_dedup_sort(arr : Array[Double]) -> Array[Double] { let result : Array[Double] = Array::new() let mut k = 0 while k < sorted.length() { - if result.length() == 0 || (result[result.length() - 1] - sorted[k]).abs() > 1.0e-9 { + if result.length() == 0 || + (result[result.length() - 1] - sorted[k]).abs() > 1.0e-9 { result.push(sorted[k]) } k = k + 1 @@ -730,20 +880,38 @@ fn phen_sort_well_ids(ids : Array[String]) -> Array[String] { ///| /// Create a small example plate with growth curves. pub fn phen_create_example_plate() -> PlateRecord { - let times = [0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0] + let times = [ + 0.0, 2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, + ] let mut plate = PlateRecord::new("ExamplePlate", times) // Well A01 - control - let a01_signals = [0.05, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1] - plate = plate.phen_add_well(WellRecord::new("A01", "ExamplePlate", times, a01_signals)) + let a01_signals = [ + 0.05, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, + ] + plate = plate.phen_add_well( + WellRecord::new("A01", "ExamplePlate", times, a01_signals), + ) // Well A02 - growing culture - let a02_signals = [0.05, 0.06, 0.08, 0.12, 0.2, 0.35, 0.55, 0.75, 0.9, 0.97, 0.99, 1.0, 1.0] - plate = plate.phen_add_well(WellRecord::new("A02", "ExamplePlate", times, a02_signals)) + let a02_signals = [ + 0.05, 0.06, 0.08, 0.12, 0.2, 0.35, 0.55, 0.75, 0.9, 0.97, 0.99, 1.0, 1.0, + ] + plate = plate.phen_add_well( + WellRecord::new("A02", "ExamplePlate", times, a02_signals), + ) // Well A03 - another growing culture - let a03_signals = [0.04, 0.05, 0.06, 0.08, 0.12, 0.2, 0.32, 0.5, 0.7, 0.85, 0.93, 0.97, 0.99] - plate = plate.phen_add_well(WellRecord::new("A03", "ExamplePlate", times, a03_signals)) + let a03_signals = [ + 0.04, 0.05, 0.06, 0.08, 0.12, 0.2, 0.32, 0.5, 0.7, 0.85, 0.93, 0.97, 0.99, + ] + plate = plate.phen_add_well( + WellRecord::new("A03", "ExamplePlate", times, a03_signals), + ) // Well B01 - slow growth - let b01_signals = [0.05, 0.05, 0.05, 0.06, 0.07, 0.09, 0.12, 0.17, 0.25, 0.35, 0.48, 0.6, 0.72] - plate = plate.phen_add_well(WellRecord::new("B01", "ExamplePlate", times, b01_signals)) + let b01_signals = [ + 0.05, 0.05, 0.05, 0.06, 0.07, 0.09, 0.12, 0.17, 0.25, 0.35, 0.48, 0.6, 0.72, + ] + plate = plate.phen_add_well( + WellRecord::new("B01", "ExamplePlate", times, b01_signals), + ) plate } diff --git a/src/phylo_cdao.mbt b/src/phylo_cdao.mbt index d9271c2d..e024aa10 100644 --- a/src/phylo_cdao.mbt +++ b/src/phylo_cdao.mbt @@ -62,7 +62,7 @@ pub fn Cdaotree::new( id : String, rooted? : Bool = false, root_node_id? : String = "", - name? : String? = None + name? : String? = None, ) -> Cdaotree { Cdaotree::{ id, rooted, root_node_id, name } } @@ -86,7 +86,7 @@ pub fn CdaoNode::new( parent_id? : String? = None, tu_id? : String? = None, branch_length? : Double? = None, - label? : String? = None + label? : String? = None, ) -> CdaoNode { CdaoNode::{ id, children, parent_id, tu_id, branch_length, label } } @@ -198,14 +198,20 @@ fn cdao_extract_elements(xml : String, triples : Array[CdaoTriple]) -> Unit { break } let tag_content = xml[tag_start + 1:tag_end].to_owned() - if tag_content[0:1].to_owned() == "/" || tag_content[0:4].to_owned() == "!--" || tag_content.contains("rdf:RDF") { + if tag_content[0:1].to_owned() == "/" || + tag_content[0:4].to_owned() == "!--" || + tag_content.contains("rdf:RDF") { pos = tag_end + 1 continue } - let is_self_closing = tag_content[tag_content.length() - 1:tag_content.length()].to_owned() == "/" + let is_self_closing = tag_content[tag_content.length() - 1:tag_content.length()].to_owned() == + "/" let tag_name = cdao_get_tag_name(tag_content) let about = cdao_get_attribute(tag_content, "rdf:about") - if tag_name.contains("cdao:Tree") || tag_name.contains("cdao:Node") || tag_name.contains("cdao:TU") || tag_name.contains("rdf:Description") { + if tag_name.contains("cdao:Tree") || + tag_name.contains("cdao:Node") || + tag_name.contains("cdao:TU") || + tag_name.contains("rdf:Description") { let subject = match about { Some(a) => a None => "" @@ -244,7 +250,7 @@ fn cdao_extract_elements(xml : String, triples : Array[CdaoTriple]) -> Unit { fn cdao_parse_children( subject : String, inner : String, - triples : Array[CdaoTriple] + triples : Array[CdaoTriple], ) -> Unit { let mut pos = 0 while pos < inner.length() { @@ -257,11 +263,13 @@ fn cdao_parse_children( break } let tag_content = inner[tag_start + 1:tag_end].to_owned() - if tag_content[0:1].to_owned() == "/" || tag_content[0:4].to_owned() == "!--" { + if tag_content[0:1].to_owned() == "/" || + tag_content[0:4].to_owned() == "!--" { pos = tag_end + 1 continue } - let is_self_closing = tag_content[tag_content.length() - 1:tag_content.length()].to_owned() == "/" + let is_self_closing = tag_content[tag_content.length() - 1:tag_content.length()].to_owned() == + "/" let tag_name = cdao_get_tag_name(tag_content) let resource = cdao_get_attribute(tag_content, "rdf:resource") let close_tag = "" @@ -325,7 +333,9 @@ fn cdao_build_document(doc : CdaoDocument, triples : Array[CdaoTriple]) -> Unit let t = triples[j] if !doc.nodes.contains(t.subject) && !doc.tus.contains(t.subject) { if t.predicate.contains("cdao:") { - if t.predicate.contains("has_Child") || t.predicate.contains("has_Ancestor") || t.predicate.contains("belongs_to_TU") { + if t.predicate.contains("has_Child") || + t.predicate.contains("has_Ancestor") || + t.predicate.contains("belongs_to_TU") { doc.nodes[t.subject] = CdaoNode::new(t.subject) } } @@ -349,15 +359,19 @@ fn cdao_build_document(doc : CdaoDocument, triples : Array[CdaoTriple]) -> Unit idx = idx + 1 } if !found { - doc.trees.push(Cdaotree::new(t.subject, rooted=true, root_node_id=t.object)) + doc.trees.push( + Cdaotree::new(t.subject, rooted=true, root_node_id=t.object), + ) } - } else if t.predicate.contains("has_Child") || t.predicate.contains("has_Descendant") { + } else if t.predicate.contains("has_Child") || + t.predicate.contains("has_Descendant") { let node = doc.nodes.get(t.subject) match node { Some(n) => n.children.push(t.object) None => () } - } else if t.predicate.contains("has_Ancestor") || t.predicate.contains("has_Parent") { + } else if t.predicate.contains("has_Ancestor") || + t.predicate.contains("has_Parent") { let node = doc.nodes.get(t.subject) match node { Some(n) => n.parent_id = Some(t.object) @@ -443,11 +457,7 @@ fn cdao_build_clade(doc : CdaoDocument, node_id : String) -> Clade { children.push(cdao_build_clade(doc, n.children[ci])) ci = ci + 1 } - Clade::new( - branch_length=n.branch_length, - name=label, - clades=children, - ) + Clade::new(branch_length=n.branch_length, name=label, clades=children) } None => Clade::new(name=Some(node_id)) } @@ -492,7 +502,10 @@ pub fn cdao_write(tree : Tree) -> String { let tu_label = tu_arr[ti] let tu_id = state.tu_map[tu_label] output = output + " \n" - output = output + " " + cdao_escape_xml(tu_label) + "\n" + output = output + + " " + + cdao_escape_xml(tu_label) + + "\n" output = output + " \n" ti = ti + 1 } @@ -506,14 +519,16 @@ pub fn cdao_write(tree : Tree) -> String { fn cdao_write_clade( clade : Clade, node_uri : String, - state : CdaoWriteState + state : CdaoWriteState, ) -> (String, CdaoWriteState) { let mut output = "" output = output + " \n" match clade.branch_length { - Some(bl) => { - output = output + " " + bl.to_string() + "\n" - } + Some(bl) => + output = output + + " " + + bl.to_string() + + "\n" None => () } if clade.is_terminal() { @@ -531,7 +546,10 @@ fn cdao_write_clade( new_id } } - output = output + " \n" + output = output + + " \n" } // Collect child URIs let child_uris : Array[String] = Array::new() @@ -540,14 +558,21 @@ fn cdao_write_clade( state.node_counter = state.node_counter + 1 let child_uri = "#node" + state.node_counter.to_string() child_uris.push(child_uri) - output = output + " \n" + output = output + + " \n" ci = ci + 1 } output = output + " \n" // Recursively write children let mut di = 0 while di < clade.clades.length() { - let (child_output, _) = cdao_write_clade(clade.clades[di], child_uris[di], state) + let (child_output, _) = cdao_write_clade( + clade.clades[di], + child_uris[di], + state, + ) output = output + child_output di = di + 1 } @@ -565,12 +590,40 @@ pub fn cdao_sample_document() -> CdaoDocument { let doc = CdaoDocument::new() doc.trees.push(Cdaotree::new("#tree1", rooted=true, root_node_id="#node1")) doc.nodes["#node1"] = CdaoNode::new("#node1", children=["#node2", "#node3"]) - doc.nodes["#node2"] = CdaoNode::new("#node2", children=["#node4", "#node5"], parent_id=Some("#node1")) - doc.nodes["#node3"] = CdaoNode::new("#node3", children=["#node6", "#node7"], parent_id=Some("#node1")) - doc.nodes["#node4"] = CdaoNode::new("#node4", parent_id=Some("#node2"), tu_id=Some("#tu1"), branch_length=Some(1.0)) - doc.nodes["#node5"] = CdaoNode::new("#node5", parent_id=Some("#node2"), tu_id=Some("#tu2"), branch_length=Some(1.0)) - doc.nodes["#node6"] = CdaoNode::new("#node6", parent_id=Some("#node3"), tu_id=Some("#tu3"), branch_length=Some(1.0)) - doc.nodes["#node7"] = CdaoNode::new("#node7", parent_id=Some("#node3"), tu_id=Some("#tu4"), branch_length=Some(1.0)) + doc.nodes["#node2"] = CdaoNode::new( + "#node2", + children=["#node4", "#node5"], + parent_id=Some("#node1"), + ) + doc.nodes["#node3"] = CdaoNode::new( + "#node3", + children=["#node6", "#node7"], + parent_id=Some("#node1"), + ) + doc.nodes["#node4"] = CdaoNode::new( + "#node4", + parent_id=Some("#node2"), + tu_id=Some("#tu1"), + branch_length=Some(1.0), + ) + doc.nodes["#node5"] = CdaoNode::new( + "#node5", + parent_id=Some("#node2"), + tu_id=Some("#tu2"), + branch_length=Some(1.0), + ) + doc.nodes["#node6"] = CdaoNode::new( + "#node6", + parent_id=Some("#node3"), + tu_id=Some("#tu3"), + branch_length=Some(1.0), + ) + doc.nodes["#node7"] = CdaoNode::new( + "#node7", + parent_id=Some("#node3"), + tu_id=Some("#tu4"), + branch_length=Some(1.0), + ) doc.tus["#tu1"] = CdaoTU::new("#tu1", label=Some("A")) doc.tus["#tu2"] = CdaoTU::new("#tu2", label=Some("B")) doc.tus["#tu3"] = CdaoTU::new("#tu3", label=Some("C")) @@ -720,7 +773,11 @@ fn cdao_get_attribute(tag_content : String, attr_name : String) -> String? { fn cdao_parse_double(s : String) -> Double { let trimmed = s.trim().to_string() let neg = trimmed[0:1].to_owned() == "-" - let digits = if neg { trimmed[1:trimmed.length()].to_string() } else { trimmed } + let digits = if neg { + trimmed[1:trimmed.length()].to_string() + } else { + trimmed + } let result = parse_double(digits) match result { Some(d) => if neg { -d } else { d } diff --git a/src/phylo_consensus.mbt b/src/phylo_consensus.mbt index 5608f54c..575de1e5 100644 --- a/src/phylo_consensus.mbt +++ b/src/phylo_consensus.mbt @@ -19,33 +19,34 @@ pub struct ConsensusNode { ///| pub fn ConsensusNode::new(name : String, is_internal : Bool) -> ConsensusNode { - ConsensusNode::{ - name, - children: Array::new(), - support: 0.0, - is_internal: is_internal - } + ConsensusNode::{ name, children: Array::new(), support: 0.0, is_internal } } ///| -pub fn ConsensusNode::add_child(self : ConsensusNode, child : ConsensusNode) -> ConsensusNode { +pub fn ConsensusNode::add_child( + self : ConsensusNode, + child : ConsensusNode, +) -> ConsensusNode { let new_children = self.children new_children.push(child) ConsensusNode::{ name: self.name, children: new_children, support: self.support, - is_internal: self.is_internal + is_internal: self.is_internal, } } ///| -pub fn ConsensusNode::set_support(self : ConsensusNode, support : Double) -> ConsensusNode { +pub fn ConsensusNode::set_support( + self : ConsensusNode, + support : Double, +) -> ConsensusNode { ConsensusNode::{ name: self.name, children: self.children, - support: support, - is_internal: self.is_internal + support, + is_internal: self.is_internal, } } @@ -82,40 +83,31 @@ pub struct Split { ///| pub fn Split::new(taxa : Array[String]) -> Split { - Split::{ - taxa, - support: 0.0 - } + Split::{ taxa, support: 0.0 } } ///| pub fn Split::set_support(self : Split, support : Double) -> Split { - Split::{ - taxa: self.taxa, - support: support - } + Split::{ taxa: self.taxa, support } } ///| pub fn Split::normalize(self : Split) -> Split { let sorted = sort_strings(self.taxa) - Split::{ - taxa: sorted, - support: self.support - } + Split::{ taxa: sorted, support: self.support } } ///| fn sort_taxa_strings(arr : Array[String]) -> Array[String] { let n = arr.length() let result = Array::make(n, "") - + let mut i = 0 while i < n { result[i] = arr[i] i = i + 1 } - + i = 0 while i < n - 1 { let mut j = i + 1 @@ -129,7 +121,7 @@ fn sort_taxa_strings(arr : Array[String]) -> Array[String] { } i = i + 1 } - + result } @@ -164,17 +156,24 @@ pub fn Split::hash(self : Split) -> String { } ///| -pub fn get_all_splits(node : ConsensusNode, all_taxa : Array[String]) -> Array[Split] { +pub fn get_all_splits( + node : ConsensusNode, + all_taxa : Array[String], +) -> Array[Split] { let result : Array[Split] = Array::new() ignore(get_splits_recursive(node, all_taxa, result)) result } ///| -fn get_splits_recursive(node : ConsensusNode, all_taxa : Array[String], result : Array[Split]) -> Unit { +fn get_splits_recursive( + node : ConsensusNode, + all_taxa : Array[String], + result : Array[Split], +) -> Unit { if !node.is_leaf() { let node_leaves = node.get_leaves() - + let other_leaves : Array[String] = Array::new() let mut i = 0 while i < all_taxa.length() { @@ -184,12 +183,12 @@ fn get_splits_recursive(node : ConsensusNode, all_taxa : Array[String], result : } i = i + 1 } - + if node_leaves.length() > 0 && other_leaves.length() > 0 { let split1 = Split::new(node_leaves).normalize() result.push(split1) } - + let mut j = 0 while j < node.children.length() { ignore(get_splits_recursive(node.children[j], all_taxa, result)) @@ -211,15 +210,18 @@ fn contains_string(arr : Array[String], s : String) -> Bool { } ///| -pub fn build_consensus(trees : Array[ConsensusTree], threshold : Double) -> ConsensusTree { +pub fn build_consensus( + trees : Array[ConsensusTree], + threshold : Double, +) -> ConsensusTree { if trees.length() == 0 { return ConsensusTree::{ nodes: Array::new(), root: None } } - + let all_taxa = get_all_taxa(trees[0]) - + let split_counts : Map[String, Int] = Map([], capacity=0) - + let mut i = 0 while i < trees.length() { match trees[i].root { @@ -228,7 +230,11 @@ pub fn build_consensus(trees : Array[ConsensusTree], threshold : Double) -> Cons let mut j = 0 while j < splits.length() { let h = splits[j].hash() - let current = if split_counts.contains(h) { split_counts.get(h).unwrap() } else { 0 } + let current = if split_counts.contains(h) { + split_counts.get(h).unwrap() + } else { + 0 + } split_counts.set(h, current + 1) j = j + 1 } @@ -237,10 +243,10 @@ pub fn build_consensus(trees : Array[ConsensusTree], threshold : Double) -> Cons } i = i + 1 } - + let n_trees = trees.length().to_double() let consensus_splits : Array[Split] = Array::new() - + let entries = split_counts.iter().collect() let mut k = 0 while k < entries.length() { @@ -253,13 +259,10 @@ pub fn build_consensus(trees : Array[ConsensusTree], threshold : Double) -> Cons } k = k + 1 } - + let consensus_root = build_tree_from_splits(all_taxa, consensus_splits) - - ConsensusTree::{ - nodes: Array::new(), - root: Some(consensus_root) - } + + ConsensusTree::{ nodes: Array::new(), root: Some(consensus_root) } } ///| @@ -286,7 +289,10 @@ fn get_all_taxa(tree : ConsensusTree) -> Array[String] { } ///| -fn build_tree_from_splits(taxa : Array[String], splits : Array[Split]) -> ConsensusNode { +fn build_tree_from_splits( + taxa : Array[String], + splits : Array[Split], +) -> ConsensusNode { if splits.length() == 0 || taxa.length() == 1 { let root = ConsensusNode::new("root", true) let mut i = 0 @@ -297,26 +303,26 @@ fn build_tree_from_splits(taxa : Array[String], splits : Array[Split]) -> Consen } return root } - + let sorted_splits = sort_splits_by_support(splits) - + let root = ConsensusNode::new("root", true) let leaves : Map[String, ConsensusNode] = Map([], capacity=0) - + let mut i = 0 while i < taxa.length() { leaves.set(taxa[i], ConsensusNode::new(taxa[i], false)) i = i + 1 } - + let mut j = 0 while j < sorted_splits.length() { let split = sorted_splits[j] let split_taxa = split.taxa - + let group = Array::new() let remaining = Array::new() - + let keys = leaves.keys().collect() let mut k = 0 while k < keys.length() { @@ -329,37 +335,39 @@ fn build_tree_from_splits(taxa : Array[String], splits : Array[Split]) -> Consen } k = k + 1 } - + if group.length() > 1 && remaining.length() > 0 { - let internal_node = ConsensusNode::new("", true).set_support(split.support) - + let internal_node = ConsensusNode::new("", true).set_support( + split.support, + ) + let mut l = 0 while l < group.length() { internal_node.children.push(group[l]) l = l + 1 } - + leaves.clear() - + leaves.set("internal_" + j.to_string(), internal_node) - + let mut m = 0 while m < remaining.length() { leaves.set(remaining[m].name, remaining[m]) m = m + 1 } } - + j = j + 1 } - + let final_nodes = leaves.values().collect() let mut n = 0 while n < final_nodes.length() { root.children.push(final_nodes[n]) n = n + 1 } - + root } @@ -367,13 +375,13 @@ fn build_tree_from_splits(taxa : Array[String], splits : Array[Split]) -> Consen fn sort_splits_by_support(splits : Array[Split]) -> Array[Split] { let n = splits.length() let result = Array::make(n, Split::new(Array::new())) - + let mut i = 0 while i < n { result[i] = splits[i] i = i + 1 } - + i = 0 while i < n - 1 { let mut j = i + 1 @@ -387,7 +395,7 @@ fn sort_splits_by_support(splits : Array[Split]) -> Array[Split] { } i = i + 1 } - + result } @@ -397,9 +405,9 @@ pub fn parse_consensus_newick(newick : String) -> ConsensusNode? { if trimmed == "" { return None } - + let (root, _) = parse_newick_recursive(trimmed, 0) - + Some(root) } @@ -407,11 +415,20 @@ pub fn parse_consensus_newick(newick : String) -> ConsensusNode? { fn trim_newick(s : String) -> String { let n = s.length() let mut start = 0 - while start < n && (s.unsafe_get(start).to_int() == ' '.to_int() || s.unsafe_get(start).to_int() == '\t'.to_int()) { + while start < n && + ( + s.unsafe_get(start).to_int() == ' '.to_int() || + s.unsafe_get(start).to_int() == '\t'.to_int() + ) { start = start + 1 } let mut end = n - while end > start && (s.unsafe_get(end - 1).to_int() == ' '.to_int() || s.unsafe_get(end - 1).to_int() == '\t'.to_int() || s.unsafe_get(end - 1).to_int() == ';'.to_int()) { + while end > start && + ( + s.unsafe_get(end - 1).to_int() == ' '.to_int() || + s.unsafe_get(end - 1).to_int() == '\t'.to_int() || + s.unsafe_get(end - 1).to_int() == ';'.to_int() + ) { end = end - 1 } substring(s, start, end - start) @@ -420,23 +437,32 @@ fn trim_newick(s : String) -> String { ///| fn parse_newick_recursive(s : String, i : Int) -> (ConsensusNode, Int) { let children = Array::new() - + let mut idx = i + 1 - + while idx < s.length() && s.unsafe_get(idx).to_int() != ')'.to_int() { if s.unsafe_get(idx).to_int() == '('.to_int() { let (child, new_idx) = parse_newick_recursive(s, idx) children.push(child) idx = new_idx - } else if s.unsafe_get(idx).to_int() != ','.to_int() && s.unsafe_get(idx).to_int() != ')'.to_int() { + } else if s.unsafe_get(idx).to_int() != ','.to_int() && + s.unsafe_get(idx).to_int() != ')'.to_int() { let mut name = "" - while idx < s.length() && s.unsafe_get(idx).to_int() != ','.to_int() && s.unsafe_get(idx).to_int() != ')'.to_int() && s.unsafe_get(idx).to_int() != ':'.to_int() { + while idx < s.length() && + s.unsafe_get(idx).to_int() != ','.to_int() && + s.unsafe_get(idx).to_int() != ')'.to_int() && + s.unsafe_get(idx).to_int() != ':'.to_int() { name = name + char_at(s, idx) idx = idx + 1 } children.push(ConsensusNode::new(name, false)) - - while idx < s.length() && (s.unsafe_get(idx).to_int() == ':'.to_int() || s.unsafe_get(idx).to_int() == ','.to_int() || s.unsafe_get(idx).to_int() == ')'.to_int()) { + + while idx < s.length() && + ( + s.unsafe_get(idx).to_int() == ':'.to_int() || + s.unsafe_get(idx).to_int() == ','.to_int() || + s.unsafe_get(idx).to_int() == ')'.to_int() + ) { if s.unsafe_get(idx).to_int() == ')'.to_int() { break } @@ -446,31 +472,39 @@ fn parse_newick_recursive(s : String, i : Int) -> (ConsensusNode, Int) { idx = idx + 1 } } - + idx = idx + 1 - + let mut name = "" - while idx < s.length() && s.unsafe_get(idx).to_int() != ';'.to_int() && s.unsafe_get(idx).to_int() != ','.to_int() && s.unsafe_get(idx).to_int() != ':'.to_int() { + while idx < s.length() && + s.unsafe_get(idx).to_int() != ';'.to_int() && + s.unsafe_get(idx).to_int() != ','.to_int() && + s.unsafe_get(idx).to_int() != ':'.to_int() { name = name + char_at(s, idx) idx = idx + 1 } - - while idx < s.length() && (s.unsafe_get(idx).to_int() == ':'.to_int() || s.unsafe_get(idx).to_int() == ','.to_int() || s.unsafe_get(idx).to_int() == ')'.to_int()) { + + while idx < s.length() && + ( + s.unsafe_get(idx).to_int() == ':'.to_int() || + s.unsafe_get(idx).to_int() == ','.to_int() || + s.unsafe_get(idx).to_int() == ')'.to_int() + ) { idx = idx + 1 } - + let node = if children.length() > 0 { ConsensusNode::new(name, true) } else { ConsensusNode::new(name, false) } - + let mut j = 0 while j < children.length() { node.children.push(children[j]) j = j + 1 } - + (node, idx) } @@ -496,7 +530,7 @@ fn node_to_newick(node : ConsensusNode) -> String { node.name } else { let mut result = "(" - + let mut i = 0 while i < node.children.length() { if i > 0 { @@ -505,17 +539,17 @@ fn node_to_newick(node : ConsensusNode) -> String { result = result + node_to_newick(node.children[i]) i = i + 1 } - + result = result + ")" - + if node.name != "" { result = result + node.name } - + if node.support > 0.0 { result = result + ":" + node.support.to_string() } - + result } } @@ -527,7 +561,7 @@ pub fn create_example_trees() -> Array[ConsensusTree] { let tree3 = newick_to_tree("((A,B),(C,D));") let tree4 = newick_to_tree("((A,B,C),D);") let tree5 = newick_to_tree("((A,B),(C,D));") - + [tree1, tree2, tree3, tree4, tree5] } @@ -549,9 +583,9 @@ fn node_to_string(node : ConsensusNode, indent : Int) -> String { prefix = prefix + " " i = i + 1 } - + let mut result = prefix - + if node.is_internal { result = result + "[internal" if node.support > 0.0 { @@ -564,13 +598,13 @@ fn node_to_string(node : ConsensusNode, indent : Int) -> String { } else { result = result + "[leaf] " + node.name + "\n" } - + let mut j = 0 while j < node.children.length() { result = result + node_to_string(node.children[j], indent + 1) j = j + 1 } - + result } @@ -583,15 +617,18 @@ pub fn ConsensusTree::to_string(self : ConsensusTree) -> String { } ///| -pub fn calculate_consensus_support(trees : Array[ConsensusTree], split : Split) -> Double { +pub fn calculate_consensus_support( + trees : Array[ConsensusTree], + split : Split, +) -> Double { if trees.length() == 0 { return 0.0 } - + let all_taxa = get_all_taxa(trees[0]) let normalized_split = split.normalize() let split_hash = normalized_split.hash() - + let mut count = 0 let mut i = 0 while i < trees.length() { @@ -611,7 +648,7 @@ pub fn calculate_consensus_support(trees : Array[ConsensusTree], split : Split) } i = i + 1 } - + count.to_double() / trees.length().to_double() } @@ -620,10 +657,10 @@ pub fn get_all_splits_from_trees(trees : Array[ConsensusTree]) -> Array[Split] { if trees.length() == 0 { return Array::new() } - + let all_taxa = get_all_taxa(trees[0]) let seen : Map[String, Split] = Map([], capacity=0) - + let mut i = 0 while i < trees.length() { match trees[i].root { @@ -643,6 +680,6 @@ pub fn get_all_splits_from_trees(trees : Array[ConsensusTree]) -> Array[Split] { } i = i + 1 } - + seen.values().collect() -} \ No newline at end of file +} diff --git a/src/phylo_nexml.mbt b/src/phylo_nexml.mbt index 2e91728d..a011f8e6 100644 --- a/src/phylo_nexml.mbt +++ b/src/phylo_nexml.mbt @@ -200,15 +200,15 @@ fn nexml_parse_float(s : String) -> Double? { let mut sign = 1.0 let mut i = 0 let zero = '0'.to_int() - + if s.unsafe_get(0).to_int() == '-'.to_int() { sign = -1.0 i = 1 } - + let mut has_dot = false let mut decimal_place = 1.0 - + while i < s.length() { let c = s.unsafe_get(i).to_int() if c == '.'.to_int() { @@ -225,7 +225,7 @@ fn nexml_parse_float(s : String) -> Double? { } i = i + 1 } - + Some(result * sign / decimal_place) } @@ -237,7 +237,7 @@ fn nexml_parse_float(s : String) -> Double? { /// Parse a NeXML document from XML string. pub fn parse_nexml(xml_content : String) -> NeXMLDocument { let mut doc = NeXMLDocument::new() - + // Check if there's a nexml element let (nexml_start, _, _) = find_element(xml_content, "nexml") if nexml_start == 0 && xml_content.length() > 0 { @@ -252,16 +252,16 @@ pub fn parse_nexml(xml_content : String) -> NeXMLDocument { doc = NeXMLDocument::{ ..doc, generator: generator_attr } } } - + // Parse OTUs blocks doc = parse_otus_blocks(xml_content, doc) - + // Parse characters blocks doc = parse_characters_blocks(xml_content, doc) - + // Parse trees blocks doc = parse_trees_blocks(xml_content, doc) - + doc } @@ -269,15 +269,15 @@ pub fn parse_nexml(xml_content : String) -> NeXMLDocument { fn parse_otus_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { let otus_elements = find_all_elements(xml, "otus") let new_otus_blocks = doc.otus_blocks.copy() - + for i = 0; i < otus_elements.length(); i = i + 1 { let (start, end) = otus_elements[i] let otus_xml = xml[start:end].to_owned() let otus_id = get_attribute(otus_xml, "id") - + let otu_list : Array[NeXMLOTU] = Array::new() let otu_elements = find_all_elements(otus_xml, "otu") - + for j = 0; j < otu_elements.length(); j = j + 1 { let (otu_start, otu_end) = otu_elements[j] let otu_xml = otus_xml[otu_start:otu_end].to_owned() @@ -289,10 +289,10 @@ fn parse_otus_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { otu_list.push(NeXMLOTU::new(id, label)) } } - + new_otus_blocks.push(NeXMLOTUs::new(otus_id, otu_list)) } - + NeXMLDocument::{ ..doc, otus_blocks: new_otus_blocks } } @@ -300,7 +300,7 @@ fn parse_otus_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { fn parse_characters_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { let chars_elements = find_all_elements(xml, "characters") let new_chars_blocks = doc.characters_blocks.copy() - + for i = 0; i < chars_elements.length(); i = i + 1 { let (start, end) = chars_elements[i] let chars_xml = xml[start:end].to_owned() @@ -310,10 +310,10 @@ fn parse_characters_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { if matrix_type.length() == 0 { let xtype = get_attribute(chars_xml, "type") let final_type = if xtype.length() > 0 { xtype } else { "StandardCells" } - + let char_list : Array[NeXMLCharacter] = Array::new() let char_elements = find_all_elements(chars_xml, "char") - + for j = 0; j < char_elements.length(); j = j + 1 { let (c_start, c_end) = char_elements[j] let char_xml = chars_xml[c_start:c_end].to_owned() @@ -321,34 +321,34 @@ fn parse_characters_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { let clabel = get_attribute(char_xml, "label") char_list.push(NeXMLCharacter::new(cid, clabel, [])) } - + let matrix : Map[String, Array[String]] = Map([], capacity=16) let row_elements = find_all_elements(chars_xml, "row") - + for j = 0; j < row_elements.length(); j = j + 1 { let (r_start, r_end) = row_elements[j] let row_xml = chars_xml[r_start:r_end].to_owned() let otu = get_attribute(row_xml, "otu") let cell_elements = find_all_elements(row_xml, "cell") let row_data : Array[String] = Array::new() - + for k = 0; k < cell_elements.length(); k = k + 1 { let (c_start2, c_end2) = cell_elements[k] let cell_xml = row_xml[c_start2:c_end2].to_owned() let state = get_attribute(cell_xml, "state") row_data.push(state) } - + matrix.set(otu, row_data) } - + new_chars_blocks.push( - NeXMLCharacters::new(chars_id, otus_id, final_type, char_list, matrix) + NeXMLCharacters::new(chars_id, otus_id, final_type, char_list, matrix), ) } else { let char_list : Array[NeXMLCharacter] = Array::new() let char_elements = find_all_elements(chars_xml, "char") - + for j = 0; j < char_elements.length(); j = j + 1 { let (c_start, c_end) = char_elements[j] let char_xml = chars_xml[c_start:c_end].to_owned() @@ -356,33 +356,33 @@ fn parse_characters_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { let clabel = get_attribute(char_xml, "label") char_list.push(NeXMLCharacter::new(cid, clabel, [])) } - + let matrix : Map[String, Array[String]] = Map([], capacity=16) let row_elements = find_all_elements(chars_xml, "row") - + for j = 0; j < row_elements.length(); j = j + 1 { let (r_start, r_end) = row_elements[j] let row_xml = chars_xml[r_start:r_end].to_owned() let otu = get_attribute(row_xml, "otu") let cell_elements = find_all_elements(row_xml, "cell") let row_data : Array[String] = Array::new() - + for k = 0; k < cell_elements.length(); k = k + 1 { let (c_start2, c_end2) = cell_elements[k] let cell_xml = row_xml[c_start2:c_end2].to_owned() let state = get_attribute(cell_xml, "state") row_data.push(state) } - + matrix.set(otu, row_data) } - + new_chars_blocks.push( - NeXMLCharacters::new(chars_id, otus_id, matrix_type, char_list, matrix) + NeXMLCharacters::new(chars_id, otus_id, matrix_type, char_list, matrix), ) } } - + NeXMLDocument::{ ..doc, characters_blocks: new_chars_blocks } } @@ -390,16 +390,16 @@ fn parse_characters_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { fn parse_trees_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { let trees_elements = find_all_elements(xml, "trees") let new_trees_blocks = doc.trees_blocks.copy() - + for i = 0; i < trees_elements.length(); i = i + 1 { let (start, end) = trees_elements[i] let trees_xml = xml[start:end].to_owned() let trees_id = get_attribute(trees_xml, "id") let otus_id = get_attribute(trees_xml, "otus") - + let tree_list : Array[NeXMLTree] = Array::new() let tree_elements = find_all_elements(trees_xml, "tree") - + for j = 0; j < tree_elements.length(); j = j + 1 { let (t_start, t_end) = tree_elements[j] let tree_xml = trees_xml[t_start:t_end].to_owned() @@ -409,55 +409,55 @@ fn parse_trees_blocks(xml : String, doc : NeXMLDocument) -> NeXMLDocument { let rooted = rooted_str == "true" let ttype = get_attribute(tree_xml, "xsi:type") let final_type = if ttype.length() > 0 { ttype } else { "FloatTree" } - + let node_list : Array[NeXMLNode] = Array::new() let node_elements = find_all_elements(tree_xml, "node") - + for k = 0; k < node_elements.length(); k = k + 1 { let (n_start, n_end) = node_elements[k] let node_xml = tree_xml[n_start:n_end].to_owned() let nid = get_attribute(node_xml, "id") let nlabel = get_attribute(node_xml, "label") let notu = get_attribute(node_xml, "otu") - + let length_str = get_attribute(node_xml, "length") let nlength : Double? = if length_str.length() > 0 { nexml_parse_float(length_str) } else { None } - + node_list.push(NeXMLNode::new(nid, nlabel, notu, length=nlength)) } - + let edge_list : Array[NeXMLEdge] = Array::new() let edge_elements = find_all_elements(tree_xml, "edge") - + for k = 0; k < edge_elements.length(); k = k + 1 { let (e_start, e_end) = edge_elements[k] let edge_xml = tree_xml[e_start:e_end].to_owned() let eid = get_attribute(edge_xml, "id") let esource = get_attribute(edge_xml, "source") let etarget = get_attribute(edge_xml, "target") - + let length_str = get_attribute(edge_xml, "length") let elength : Double? = if length_str.length() > 0 { nexml_parse_float(length_str) } else { None } - + edge_list.push(NeXMLEdge::new(eid, esource, etarget, length=elength)) } - + tree_list.push( - NeXMLTree::new(tid, tname, final_type, rooted, node_list, edge_list) + NeXMLTree::new(tid, tname, final_type, rooted, node_list, edge_list), ) } - + new_trees_blocks.push(NeXMLTrees::new(trees_id, otus_id, tree_list)) } - + NeXMLDocument::{ ..doc, trees_blocks: new_trees_blocks } } @@ -475,26 +475,40 @@ pub fn nexml_to_xml(doc : NeXMLDocument) -> String { xml = xml + " xmlns:nex=\"http://www.nexml.org/2009\"\n" xml = xml + " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n" xml = xml + " xmlns:xml=\"http://www.w3.org/XML/1998/namespace\">\n" - + // Write OTUs blocks for i = 0; i < doc.otus_blocks.length(); i = i + 1 { let otus_block = doc.otus_blocks[i] xml = xml + " \n" for j = 0; j < otus_block.otus.length(); j = j + 1 { let otu = otus_block.otus[j] - xml = xml + " \n" + xml = xml + + " \n" } xml = xml + " \n" } - + // Write characters blocks for i = 0; i < doc.characters_blocks.length(); i = i + 1 { let chars_block = doc.characters_blocks[i] - xml = xml + " \n" + xml = xml + + " \n" for j = 0; j < chars_block.characters.length(); j = j + 1 { let ch = chars_block.characters[j] - xml = xml + " \n" + xml = xml + + " \n" } xml = xml + " \n" for otu in chars_block.matrix.keys() { @@ -511,18 +525,27 @@ pub fn nexml_to_xml(doc : NeXMLDocument) -> String { xml = xml + " \n" xml = xml + " \n" } - + // Write trees blocks for i = 0; i < doc.trees_blocks.length(); i = i + 1 { let trees_block = doc.trees_blocks[i] - xml = xml + " \n" + xml = xml + + " \n" for j = 0; j < trees_block.trees.length(); j = j + 1 { let tree = trees_block.trees[j] let rooted_str = if tree.rooted { "true" } else { "false" } - xml = xml + " \n" + xml = xml + + " \n" for k = 0; k < tree.nodes.length(); k = k + 1 { let node = tree.nodes[k] xml = xml + " String { } for k = 0; k < tree.edges.length(); k = k + 1 { let edge = tree.edges[k] - xml = xml + " xml = xml + " length=\"" + len.to_string() + "\"" None => () @@ -553,9 +581,9 @@ pub fn nexml_to_xml(doc : NeXMLDocument) -> String { } xml = xml + " \n" } - + xml = xml + "\n" - + xml } @@ -569,11 +597,14 @@ pub fn nexml_tree_to_newick(tree : NeXMLTree) -> String { if tree.nodes.length() == 0 { return ";" } - + // Build adjacency list - let children_map : Map[String, Array[(String, Double?)]] = Map([], capacity=16) + let children_map : Map[String, Array[(String, Double?)]] = Map( + [], + capacity=16, + ) let parent_map : Map[String, String] = Map([], capacity=16) - + for i = 0; i < tree.edges.length(); i = i + 1 { let edge = tree.edges[i] let existing_opt = children_map.get(edge.source) @@ -586,7 +617,7 @@ pub fn nexml_tree_to_newick(tree : NeXMLTree) -> String { children_map.set(edge.source, new_children) parent_map.set(edge.target, edge.source) } - + // Find root (node with no parent) let mut root_id = "" for i = 0; i < tree.nodes.length(); i = i + 1 { @@ -596,11 +627,11 @@ pub fn nexml_tree_to_newick(tree : NeXMLTree) -> String { break } } - + if root_id.length() == 0 && tree.nodes.length() > 0 { root_id = tree.nodes[0].id } - + // Build Newick recursively let (newick_str, _) = build_newick(tree, root_id, children_map) newick_str + ";" @@ -613,7 +644,7 @@ fn build_newick( children_map : Map[String, Array[(String, Double?)]], ) -> (String, Bool) { let children_opt = children_map.get(node_id) - + // Find node label let mut node_label = "" let mut node_length : Double? = None @@ -624,9 +655,9 @@ fn build_newick( break } } - + match children_opt { - Some(children) => { + Some(children) => if children.length() == 0 { // Leaf node (node_label, true) @@ -647,11 +678,9 @@ fn build_newick( result = result + ")" + node_label (result, false) } - } - None => { + None => // Leaf node (no children in map) (node_label, true) - } } } diff --git a/src/phylo_xml.mbt b/src/phylo_xml.mbt index f03006d0..e7b659e0 100644 --- a/src/phylo_xml.mbt +++ b/src/phylo_xml.mbt @@ -188,8 +188,9 @@ fn xml_parse_attrs(attr_str : String) -> Map[String, String] { break } let key_start = i - while i < n && trimmed.unsafe_get(i).to_int() != eq && - trimmed.unsafe_get(i).to_int() != space { + while i < n && + trimmed.unsafe_get(i).to_int() != eq && + trimmed.unsafe_get(i).to_int() != space { i = i + 1 } let key = trimmed[key_start:i].to_owned() @@ -222,8 +223,9 @@ fn xml_parse_attrs(attr_str : String) -> Map[String, String] { } } else { let val_start = i - while i < n && trimmed.unsafe_get(i).to_int() != space && - trimmed.unsafe_get(i).to_int() != gt { + while i < n && + trimmed.unsafe_get(i).to_int() != space && + trimmed.unsafe_get(i).to_int() != gt { i = i + 1 } result[key] = trimmed[val_start:i].to_owned() @@ -248,8 +250,11 @@ fn xml_find_open_tag( let rest = xml[i + 1:].to_owned() let rest_len = rest.length() let mut j = 0 - while j < rest_len && char_at(rest, j) != ">" && char_at(rest, j) != "/" && - char_at(rest, j) != " " && char_at(rest, j) != "\t" { + while j < rest_len && + char_at(rest, j) != ">" && + char_at(rest, j) != "/" && + char_at(rest, j) != " " && + char_at(rest, j) != "\t" { j = j + 1 } let found_tag = xml_strip_n(rest[0:j].to_owned()) @@ -301,8 +306,10 @@ fn xml_find_close_tag( let after_slash = rest[1:].to_owned() let mut j = 0 let rlen = after_slash.length() - while j < rlen && char_at(after_slash, j) != ">" && - char_at(after_slash, j) != " " && char_at(after_slash, j) != "\t" { + while j < rlen && + char_at(after_slash, j) != ">" && + char_at(after_slash, j) != " " && + char_at(after_slash, j) != "\t" { j = j + 1 } let close_tag = xml_strip_n(after_slash[0:j].to_owned()) @@ -323,9 +330,11 @@ fn xml_find_close_tag( } else { let mut j = 0 let rlen = rest.length() - while j < rlen && char_at(rest, j) != ">" && - char_at(rest, j) != "/" && char_at(rest, j) != " " && - char_at(rest, j) != "\t" { + while j < rlen && + char_at(rest, j) != ">" && + char_at(rest, j) != "/" && + char_at(rest, j) != " " && + char_at(rest, j) != "\t" { j = j + 1 } let found_tag = xml_strip_n(rest[0:j].to_owned()) @@ -378,8 +387,10 @@ fn find_tag_end(xml : String, open_start : Int, tag_name : String) -> Int { let rest = xml[i + 1:].to_owned() let mut j = 0 let rlen = rest.length() - while j < rlen && char_at(rest, j) != ">" && - char_at(rest, j) != "/" && char_at(rest, j) != " " { + while j < rlen && + char_at(rest, j) != ">" && + char_at(rest, j) != "/" && + char_at(rest, j) != " " { j = j + 1 } let found_tag = xml_strip_n(rest[0:j].to_owned()) @@ -412,7 +423,10 @@ fn has_nested_elements(s : String) -> Bool { ///| /// Extract a complete XML element by tag name. /// Returns (attributes_map, children_text) or (empty_map, ""). -fn xml_extract_element(xml : String, tag_name : String) -> (Map[String, String], String) { +fn xml_extract_element( + xml : String, + tag_name : String, +) -> (Map[String, String], String) { let open_opt = xml_find_open_tag(xml, tag_name, 0) if open_opt.is_none() { return (Map([], capacity=4), "") @@ -433,7 +447,11 @@ fn xml_extract_element(xml : String, tag_name : String) -> (Map[String, String], ///| /// Get text content between an open tag and close tag positions. -fn xml_get_text_between(xml : String, open_tag : Int, close_tag : Int) -> String { +fn xml_get_text_between( + xml : String, + open_tag : Int, + close_tag : Int, +) -> String { if open_tag >= close_tag { return "" } @@ -448,10 +466,7 @@ fn xml_get_text_between(xml : String, open_tag : Int, close_tag : Int) -> String ///| /// Find first XML element by tag name. /// Returns (start_pos, end_pos, content_string) or (0, 0, ""). -pub fn find_element( - xml : String, - tag : String, -) -> (Int, Int, String) { +pub fn find_element(xml : String, tag : String) -> (Int, Int, String) { let open_opt = xml_find_open_tag(xml, tag, 0) if open_opt.is_none() { return (0, 0, "") @@ -475,10 +490,7 @@ pub fn find_element( ///| /// Find all XML elements by tag name (non-overlapping, top-level only within the search range). /// Returns array of (start_pos, end_pos) tuples. -pub fn find_all_elements( - xml : String, - tag : String, -) -> Array[(Int, Int)] { +pub fn find_all_elements(xml : String, tag : String) -> Array[(Int, Int)] { let result : Array[(Int, Int)] = Array::new() let mut search_start = 0 let n = xml.length() @@ -511,10 +523,7 @@ pub fn find_all_elements( ///| /// Get an attribute value from an element at the given position. -pub fn get_attribute( - xml : String, - attr_name : String, -) -> String { +pub fn get_attribute(xml : String, attr_name : String) -> String { let trimmed = trim(xml) if !trimmed.has_prefix("<") { return "" @@ -620,7 +629,11 @@ pub fn parse_tree_element(xml : String) -> PhyloXMLTree { let attrs_start = trimmed.find("") - if gt_opt.is_some() { Some(attrs_start.unwrap() + gt_opt.unwrap() + 1) } else { None } + if gt_opt.is_some() { + Some(attrs_start.unwrap() + gt_opt.unwrap() + 1) + } else { + None + } } else { None } @@ -663,21 +676,25 @@ pub fn parse_node_element(xml : String) -> PhyloXMLNode { ///| /// Parse taxon annotation from an XML element. pub fn parse_taxon_element(xml : String) -> TaxonInfo { - parse_taxon_info_from(if has_element(xml, "taxon") { - extract_child(xml, "taxon") - } else { - xml - }) + parse_taxon_info_from( + if has_element(xml, "taxon") { + extract_child(xml, "taxon") + } else { + xml + }, + ) } ///| /// Parse sequence annotation from an XML element. pub fn parse_sequence_element(xml : String) -> SequenceAnnotation { - parse_seq_annotation_from(if has_element(xml, "sequence") { - extract_child(xml, "sequence") - } else { - xml - }) + parse_seq_annotation_from( + if has_element(xml, "sequence") { + extract_child(xml, "sequence") + } else { + xml + }, + ) } // ============================================================================ @@ -715,7 +732,11 @@ fn parse_child_node(xml : String, tag : String) -> PhyloXMLNode { if s == 0 && e == 0 { return PhyloXMLNode::new() } - let node_xml = if content.length() > 0 { content } else { xml[s:e].to_owned() } + let node_xml = if content.length() > 0 { + content + } else { + xml[s:e].to_owned() + } parse_node_from_content(node_xml) } @@ -794,6 +815,7 @@ fn parse_node_from_content(xml : String) -> PhyloXMLNode { taxon, } } + ///| fn parse_taxon_info_from(xml : String) -> TaxonInfo { TaxonInfo::{ @@ -1063,13 +1085,21 @@ pub fn newick_to_phyloxml( let node = parse_newick_to_node(newick_text) let tree = PhyloXMLTree::{ tree_id, - name: if tree_id.length() > 0 { tree_id } else { "Newick Tree" }, + name: if tree_id.length() > 0 { + tree_id + } else { + "Newick Tree" + }, description: "Converted from Newick format", root: node, phylogeny_metadata: Map([("rooted", "true")], capacity=2), taxon_namespaces: [], } - PhyloXMLResult::{ trees: [tree], metadata: Map([], capacity=4), taxon_namespaces: [] } + PhyloXMLResult::{ + trees: [tree], + metadata: Map([], capacity=4), + taxon_namespaces: [], + } } ///| @@ -1116,12 +1146,20 @@ fn parse_newick_subtree(s : String, start : Int) -> PhyloXMLNode { let close_pos = after.find(")") let semi_pos = after.find(";") let end = find_min_pos([comma_pos, close_pos, semi_pos]) - if end.is_some() { after[0:end.unwrap()].to_owned() } else { after } + if end.is_some() { + after[0:end.unwrap()].to_owned() + } else { + after + } } let bl_str = if colon_pos.is_some() { let after_colon = after[colon_pos.unwrap() + 1:].to_owned() let end_pos = find_first_of(after_colon, [",", ")", ";"]) - if end_pos.is_some() { after_colon[0:end_pos.unwrap()].to_owned() } else { after_colon } + if end_pos.is_some() { + after_colon[0:end_pos.unwrap()].to_owned() + } else { + after_colon + } } else { "" } @@ -1312,4 +1350,4 @@ pub fn phyloxml_get_node_count(tree : PhyloXMLTree) -> Int { } } count -} \ No newline at end of file +} diff --git a/src/phyloseq.mbt b/src/phyloseq.mbt index 1f6aa458..65a34d6a 100644 --- a/src/phyloseq.mbt +++ b/src/phyloseq.mbt @@ -9,7 +9,11 @@ pub struct OTU { } ///| -pub fn OTU::new(id : String, taxonomy : Array[String], abundance : Array[Double]) -> OTU { +pub fn OTU::new( + id : String, + taxonomy : Array[String], + abundance : Array[Double], +) -> OTU { OTU::{ id, taxonomy, abundance } } @@ -36,7 +40,15 @@ pub struct TaxRank { } ///| -pub fn TaxRank::new(kingdom : String, phylum : String, class : String, order : String, family : String, genus : String, species : String) -> TaxRank { +pub fn TaxRank::new( + kingdom : String, + phylum : String, + class : String, + order : String, + family : String, + genus : String, + species : String, +) -> TaxRank { TaxRank::{ kingdom, phylum, class, order, family, genus, species } } @@ -54,7 +66,7 @@ pub fn Phyloseq::new() -> Phyloseq { otus: Array::new(), samples: Array::new(), taxonomy: Array::new(), - metadata: Map([], capacity=0) + metadata: Map([], capacity=0), } } @@ -108,21 +120,24 @@ pub fn ps_total_abundance(ps : Phyloseq) -> Double { } ///| -pub fn ps_filter_by_abundance(ps : Phyloseq, min_abundance : Double) -> Phyloseq { +pub fn ps_filter_by_abundance( + ps : Phyloseq, + min_abundance : Double, +) -> Phyloseq { let filtered = Phyloseq::new() - + let mut i = 0 while i < ps.samples.length() { filtered.samples.push(ps.samples[i]) i = i + 1 } - + let mut j = 0 while j < ps.taxonomy.length() { filtered.taxonomy.push(ps.taxonomy[j]) j = j + 1 } - + let mut k = 0 while k < ps.otus.length() { let mut total = 0.0 @@ -136,20 +151,24 @@ pub fn ps_filter_by_abundance(ps : Phyloseq, min_abundance : Double) -> Phyloseq } k = k + 1 } - + filtered } ///| -pub fn ps_filter_by_taxonomy(ps : Phyloseq, rank : String, value : String) -> Phyloseq { +pub fn ps_filter_by_taxonomy( + ps : Phyloseq, + rank : String, + value : String, +) -> Phyloseq { let filtered = Phyloseq::new() - + let mut i = 0 while i < ps.samples.length() { filtered.samples.push(ps.samples[i]) i = i + 1 } - + let mut j = 0 while j < ps.taxonomy.length() { let matched = match rank { @@ -170,14 +189,14 @@ pub fn ps_filter_by_taxonomy(ps : Phyloseq, rank : String, value : String) -> Ph } j = j + 1 } - + filtered } ///| pub fn ps_get_taxa_summary(ps : Phyloseq, rank : String) -> Map[String, Double] { let summary = Map([], capacity=0) - + let mut i = 0 while i < ps.taxonomy.length() { let tax_value = match rank { @@ -190,7 +209,7 @@ pub fn ps_get_taxa_summary(ps : Phyloseq, rank : String) -> Map[String, Double] "species" => ps.taxonomy[i].species _ => "unknown" } - + let mut abundance = 0.0 if i < ps.otus.length() { let mut j = 0 @@ -199,16 +218,16 @@ pub fn ps_get_taxa_summary(ps : Phyloseq, rank : String) -> Map[String, Double] j = j + 1 } } - + if summary.contains(tax_value) { summary.set(tax_value, summary.get(tax_value).unwrap() + abundance) } else { summary.set(tax_value, abundance) } - + i = i + 1 } - + summary } @@ -216,19 +235,19 @@ pub fn ps_get_taxa_summary(ps : Phyloseq, rank : String) -> Map[String, Double] pub fn ps_relative_abundance(ps : Phyloseq) -> Phyloseq { let total = ps_total_abundance(ps) let ra = Phyloseq::new() - + let mut i = 0 while i < ps.samples.length() { ra.samples.push(ps.samples[i]) i = i + 1 } - + let mut j = 0 while j < ps.taxonomy.length() { ra.taxonomy.push(ps.taxonomy[j]) j = j + 1 } - + let mut k = 0 while k < ps.otus.length() { let ra_abundance : Array[Double] = Array::new() @@ -241,47 +260,51 @@ pub fn ps_relative_abundance(ps : Phyloseq) -> Phyloseq { ra.otus.push(ra_otu) k = k + 1 } - + ra } ///| pub fn ps_rarefy(ps : Phyloseq, depth : Int) -> Phyloseq { let rarefied = Phyloseq::new() - + let mut i = 0 while i < ps.samples.length() { rarefied.samples.push(ps.samples[i]) i = i + 1 } - + let mut j = 0 while j < ps.taxonomy.length() { rarefied.taxonomy.push(ps.taxonomy[j]) j = j + 1 } - + let mut k = 0 while k < ps.otus.length() { let rarefied_abundance : Array[Double] = Array::new() let mut m = 0 while m < ps.otus[k].abundance.length() { let proportion = ps.otus[k].abundance[m] / ps_total_abundance(ps) - rarefied_abundance.push(proportion * (depth.to_double())) + rarefied_abundance.push(proportion * depth.to_double()) m = m + 1 } - let rarefied_otu = OTU::new(ps.otus[k].id, ps.otus[k].taxonomy, rarefied_abundance) + let rarefied_otu = OTU::new( + ps.otus[k].id, + ps.otus[k].taxonomy, + rarefied_abundance, + ) rarefied.otus.push(rarefied_otu) k = k + 1 } - + rarefied } ///| pub fn create_example_phyloseq() -> Phyloseq { let ps = Phyloseq::new() - + let otu1_tax : Array[String] = Array::new() otu1_tax.push("Bacteria") otu1_tax.push("Proteobacteria") @@ -292,7 +315,7 @@ pub fn create_example_phyloseq() -> Phyloseq { otu1_abund.push(200.0) let otu1 = OTU::new("OTU001", otu1_tax, otu1_abund) ps.otus.push(otu1) - + let otu2_tax : Array[String] = Array::new() otu2_tax.push("Bacteria") otu2_tax.push("Firmicutes") @@ -303,7 +326,7 @@ pub fn create_example_phyloseq() -> Phyloseq { otu2_abund.push(100.0) let otu2 = OTU::new("OTU002", otu2_tax, otu2_abund) ps.otus.push(otu2) - + let otu3_tax : Array[String] = Array::new() otu3_tax.push("Bacteria") otu3_tax.push("Bacteroidetes") @@ -314,30 +337,39 @@ pub fn create_example_phyloseq() -> Phyloseq { otu3_abund.push(125.0) let otu3 = OTU::new("OTU003", otu3_tax, otu3_abund) ps.otus.push(otu3) - + let sample1_meta = Map([("group", "control")], capacity=1) let sample1 = Sample::new("Sample001", sample1_meta) ps.samples.push(sample1) - + let sample2_meta = Map([("group", "treatment")], capacity=1) let sample2 = Sample::new("Sample002", sample2_meta) ps.samples.push(sample2) - + let sample3_meta = Map([("group", "treatment")], capacity=1) let sample3 = Sample::new("Sample003", sample3_meta) ps.samples.push(sample3) - - let tax1 = TaxRank::new("Bacteria", "Proteobacteria", "Gammaproteobacteria", "Enterobacteriales", "Enterobacteriaceae", "Escherichia", "coli") + + let tax1 = TaxRank::new( + "Bacteria", "Proteobacteria", "Gammaproteobacteria", "Enterobacteriales", "Enterobacteriaceae", + "Escherichia", "coli", + ) ps.taxonomy.push(tax1) - - let tax2 = TaxRank::new("Bacteria", "Firmicutes", "Clostridia", "Clostridiales", "Clostridiaceae", "Clostridium", "perfringens") + + let tax2 = TaxRank::new( + "Bacteria", "Firmicutes", "Clostridia", "Clostridiales", "Clostridiaceae", "Clostridium", + "perfringens", + ) ps.taxonomy.push(tax2) - - let tax3 = TaxRank::new("Bacteria", "Bacteroidetes", "Bacteroidia", "Bacteroidales", "Bacteroidaceae", "Bacteroides", "fragilis") + + let tax3 = TaxRank::new( + "Bacteria", "Bacteroidetes", "Bacteroidia", "Bacteroidales", "Bacteroidaceae", + "Bacteroides", "fragilis", + ) ps.taxonomy.push(tax3) - + ps.metadata.set("project", "microbiome_study") ps.metadata.set("platform", "Illumina") - + ps -} \ No newline at end of file +} diff --git a/src/pir_io.mbt b/src/pir_io.mbt index 39064d20..2a5885ae 100644 --- a/src/pir_io.mbt +++ b/src/pir_io.mbt @@ -112,12 +112,14 @@ pub fn parse_pir(content : String) -> Array[SeqRecord] { } } - records.push(SeqRecord::new( - Seq::new(seq_buf.to_string()), - id=name, - name=name, - description=description, - )) + records.push( + SeqRecord::new( + Seq::new(seq_buf.to_string()), + id=name, + name~, + description~, + ), + ) continue } diff --git a/src/plyranges.mbt b/src/plyranges.mbt index 01430ee7..444bde98 100644 --- a/src/plyranges.mbt +++ b/src/plyranges.mbt @@ -42,7 +42,11 @@ pub fn tgr_create( i = i + 1 } TidifiedGRanges::{ - seqnames, starts, ends, strands, widths, + seqnames, + starts, + ends, + strands, + widths, metadata: Map::new(), metadata_str: Map::new(), } @@ -55,12 +59,17 @@ pub fn tgr_length(tgr : TidifiedGRanges) -> Int { ///| /// Filter GRanges by sequence name. -pub fn tgr_filter_seqname(tgr : TidifiedGRanges, seqname : String) -> TidifiedGRanges { +pub fn tgr_filter_seqname( + tgr : TidifiedGRanges, + seqname : String, +) -> TidifiedGRanges { let n = tgr.seqnames.length() let keep : Array[Bool] = Array::make(n, false) let mut i = 0 while i < n { - if tgr.seqnames[i] == seqname { keep[i] = true } + if tgr.seqnames[i] == seqname { + keep[i] = true + } i = i + 1 } tgr_subset(tgr, keep) @@ -68,12 +77,17 @@ pub fn tgr_filter_seqname(tgr : TidifiedGRanges, seqname : String) -> TidifiedGR ///| /// Filter GRanges by strand. -pub fn tgr_filter_strand(tgr : TidifiedGRanges, strand : String) -> TidifiedGRanges { +pub fn tgr_filter_strand( + tgr : TidifiedGRanges, + strand : String, +) -> TidifiedGRanges { let n = tgr.seqnames.length() let keep : Array[Bool] = Array::make(n, false) let mut i = 0 while i < n { - if tgr.strands[i] == strand { keep[i] = true } + if tgr.strands[i] == strand { + keep[i] = true + } i = i + 1 } tgr_subset(tgr, keep) @@ -91,7 +105,9 @@ pub fn tgr_filter_width( let mut i = 0 while i < n { let w = tgr.widths[i] - if w >= min_width && w <= max_width { keep[i] = true } + if w >= min_width && w <= max_width { + keep[i] = true + } i = i + 1 } tgr_subset(tgr, keep) @@ -99,12 +115,17 @@ pub fn tgr_filter_width( ///| /// Filter GRanges by start position >= min_start. -pub fn tgr_filter_start(tgr : TidifiedGRanges, min_start : Int) -> TidifiedGRanges { +pub fn tgr_filter_start( + tgr : TidifiedGRanges, + min_start : Int, +) -> TidifiedGRanges { let n = tgr.seqnames.length() let keep : Array[Bool] = Array::make(n, false) let mut i = 0 while i < n { - if tgr.starts[i] >= min_start { keep[i] = true } + if tgr.starts[i] >= min_start { + keep[i] = true + } i = i + 1 } tgr_subset(tgr, keep) @@ -117,7 +138,9 @@ pub fn tgr_filter_end(tgr : TidifiedGRanges, max_end : Int) -> TidifiedGRanges { let keep : Array[Bool] = Array::make(n, false) let mut i = 0 while i < n { - if tgr.ends[i] <= max_end { keep[i] = true } + if tgr.ends[i] <= max_end { + keep[i] = true + } i = i + 1 } tgr_subset(tgr, keep) @@ -132,13 +155,17 @@ pub fn tgr_filter_metadata( max_val : Double, ) -> TidifiedGRanges { let data = tgr.metadata[col] - if data.length() == 0 { return tgr } + if data.length() == 0 { + return tgr + } let n = tgr.seqnames.length() let keep : Array[Bool] = Array::make(n, false) let mut i = 0 while i < n { let v = data[i] - if v >= min_val && v <= max_val { keep[i] = true } + if v >= min_val && v <= max_val { + keep[i] = true + } i = i + 1 } tgr_subset(tgr, keep) @@ -152,12 +179,16 @@ pub fn tgr_filter_metadata_str( value : String, ) -> TidifiedGRanges { let data = tgr.metadata_str[col] - if data.length() == 0 { return tgr } + if data.length() == 0 { + return tgr + } let n = tgr.seqnames.length() let keep : Array[Bool] = Array::make(n, false) let mut i = 0 while i < n { - if data[i] == value { keep[i] = true } + if data[i] == value { + keep[i] = true + } i = i + 1 } tgr_subset(tgr, keep) @@ -189,7 +220,9 @@ pub fn tgr_subset(tgr : TidifiedGRanges, keep : Array[Bool]) -> TidifiedGRanges let nv : Array[Double] = Array::new() let mut j = 0 while j < n { - if keep[j] { nv.push(old[j]) } + if keep[j] { + nv.push(old[j]) + } j = j + 1 } new_metadata[key] = nv @@ -199,7 +232,9 @@ pub fn tgr_subset(tgr : TidifiedGRanges, keep : Array[Bool]) -> TidifiedGRanges let nv : Array[String] = Array::new() let mut j = 0 while j < n { - if keep[j] { nv.push(old[j]) } + if keep[j] { + nv.push(old[j]) + } j = j + 1 } new_metadata_str[key] = nv @@ -217,7 +252,11 @@ pub fn tgr_subset(tgr : TidifiedGRanges, keep : Array[Bool]) -> TidifiedGRanges ///| /// Add a numeric metadata column. -pub fn tgr_mutate(tgr : TidifiedGRanges, name : String, values : Array[Double]) -> TidifiedGRanges { +pub fn tgr_mutate( + tgr : TidifiedGRanges, + name : String, + values : Array[Double], +) -> TidifiedGRanges { let new_meta = Map::new() for key in tgr.metadata.keys() { new_meta[key] = tgr.metadata[key] @@ -236,7 +275,11 @@ pub fn tgr_mutate(tgr : TidifiedGRanges, name : String, values : Array[Double]) ///| /// Add a string metadata column. -pub fn tgr_mutate_str(tgr : TidifiedGRanges, name : String, values : Array[String]) -> TidifiedGRanges { +pub fn tgr_mutate_str( + tgr : TidifiedGRanges, + name : String, + values : Array[String], +) -> TidifiedGRanges { let new_meta = Map::new() for key in tgr.metadata_str.keys() { new_meta[key] = tgr.metadata_str[key] @@ -259,7 +302,10 @@ pub fn tgr_arrange(tgr : TidifiedGRanges) -> TidifiedGRanges { let n = tgr.seqnames.length() let indices : Array[Int] = Array::make(n, 0) let mut i = 0 - while i < n { indices[i] = i; i = i + 1 } + while i < n { + indices[i] = i + i = i + 1 + } // Sort indices by seqname then start let mut ii = 0 while ii < n - 1 { @@ -280,23 +326,36 @@ pub fn tgr_arrange(tgr : TidifiedGRanges) -> TidifiedGRanges { tgr_reorder(tgr, indices) } +///| fn tgr_should_swap(tgr : TidifiedGRanges, ai : Int, aj : Int) -> Bool { let si = tgr.seqnames[ai] let sj = tgr.seqnames[aj] - if si > sj { return true } - if si < sj { return false } + if si > sj { + return true + } + if si < sj { + return false + } return tgr.starts[ai] > tgr.starts[aj] } ///| /// Arrange by a numeric metadata column. -pub fn tgr_arrange_by_metadata(tgr : TidifiedGRanges, col : String) -> TidifiedGRanges { +pub fn tgr_arrange_by_metadata( + tgr : TidifiedGRanges, + col : String, +) -> TidifiedGRanges { let data = tgr.metadata[col] - if data.length() == 0 { return tgr } + if data.length() == 0 { + return tgr + } let n = tgr.seqnames.length() let indices : Array[Int] = Array::make(n, 0) let mut i = 0 - while i < n { indices[i] = i; i = i + 1 } + while i < n { + indices[i] = i + i = i + 1 + } let mut ii = 0 while ii < n - 1 { let mut jj = ii + 1 @@ -315,6 +374,7 @@ pub fn tgr_arrange_by_metadata(tgr : TidifiedGRanges, col : String) -> TidifiedG tgr_reorder(tgr, indices) } +///| fn tgr_reorder(tgr : TidifiedGRanges, indices : Array[Int]) -> TidifiedGRanges { let n = indices.length() let new_seqnames : Array[String] = Array::make(n, "") @@ -337,14 +397,20 @@ fn tgr_reorder(tgr : TidifiedGRanges, indices : Array[Int]) -> TidifiedGRanges { let old = tgr.metadata[key] let nv : Array[Double] = Array::make(n, 0.0) let mut j = 0 - while j < n { nv[j] = old[indices[j]]; j = j + 1 } + while j < n { + nv[j] = old[indices[j]] + j = j + 1 + } new_metadata[key] = nv } for key in tgr.metadata_str.keys() { let old = tgr.metadata_str[key] let nv : Array[String] = Array::make(n, "") let mut j = 0 - while j < n { nv[j] = old[indices[j]]; j = j + 1 } + while j < n { + nv[j] = old[indices[j]] + j = j + 1 + } new_metadata_str[key] = nv } TidifiedGRanges::{ @@ -360,16 +426,26 @@ fn tgr_reorder(tgr : TidifiedGRanges, indices : Array[Int]) -> TidifiedGRanges { ///| /// Rename a metadata column. -pub fn tgr_rename(tgr : TidifiedGRanges, old_name : String, new_name : String) -> TidifiedGRanges { +pub fn tgr_rename( + tgr : TidifiedGRanges, + old_name : String, + new_name : String, +) -> TidifiedGRanges { let new_meta = Map::new() for key in tgr.metadata.keys() { - if key == old_name { new_meta[new_name] = tgr.metadata[key] } - else { new_meta[key] = tgr.metadata[key] } + if key == old_name { + new_meta[new_name] = tgr.metadata[key] + } else { + new_meta[key] = tgr.metadata[key] + } } let new_meta_str = Map::new() for key in tgr.metadata_str.keys() { - if key == old_name { new_meta_str[new_name] = tgr.metadata_str[key] } - else { new_meta_str[key] = tgr.metadata_str[key] } + if key == old_name { + new_meta_str[new_name] = tgr.metadata_str[key] + } else { + new_meta_str[key] = tgr.metadata_str[key] + } } TidifiedGRanges::{ seqnames: tgr.seqnames.copy(), @@ -384,12 +460,19 @@ pub fn tgr_rename(tgr : TidifiedGRanges, old_name : String, new_name : String) - ///| /// Select only specific metadata columns (keep structural columns). -pub fn tgr_select(tgr : TidifiedGRanges, columns : Array[String]) -> TidifiedGRanges { +pub fn tgr_select( + tgr : TidifiedGRanges, + columns : Array[String], +) -> TidifiedGRanges { let new_meta = Map::new() let new_meta_str = Map::new() for col in columns { - if tgr.metadata.contains(col) { new_meta[col] = tgr.metadata[col] } - if tgr.metadata_str.contains(col) { new_meta_str[col] = tgr.metadata_str[col] } + if tgr.metadata.contains(col) { + new_meta[col] = tgr.metadata[col] + } + if tgr.metadata_str.contains(col) { + new_meta_str[col] = tgr.metadata_str[col] + } } TidifiedGRanges::{ seqnames: tgr.seqnames.copy(), @@ -420,14 +503,18 @@ pub fn tgr_summarise( value_cols : Array[String], ) -> Array[GroupSummary] { let data = tgr.metadata_str[group_col] - if data.length() == 0 { return [] } + if data.length() == 0 { + return [] + } let groups = tgr_get_unique_strings(data) let result : Array[GroupSummary] = Array::new() for g in groups { let mut count = 0 let mut i = 0 while i < data.length() { - if data[i] == g { count = count + 1 } + if data[i] == g { + count = count + 1 + } i = i + 1 } let mean_vals = Map::new() @@ -446,8 +533,12 @@ pub fn tgr_summarise( if data[j] == g { let v = col_data[j] s = s + v - if first || v < mn { mn = v } - if first || v > mx { mx = v } + if first || v < mn { + mn = v + } + if first || v > mx { + mx = v + } } j = j + 1 } @@ -469,6 +560,7 @@ pub fn tgr_summarise( result } +///| fn tgr_get_unique_strings(arr : Array[String]) -> Array[String] { let seen = Map::new() let result : Array[String] = Array::new() @@ -490,7 +582,9 @@ pub fn tgr_group_mean( ) -> Array[(String, Double)] { let data = tgr.metadata_str[group_col] let vals = tgr.metadata[value_col] - if data.length() == 0 || vals.length() == 0 { return [] } + if data.length() == 0 || vals.length() == 0 { + return [] + } let groups = tgr_get_unique_strings(data) let result : Array[(String, Double)] = Array::new() for g in groups { @@ -498,7 +592,10 @@ pub fn tgr_group_mean( let mut c = 0 let mut i = 0 while i < data.length() { - if data[i] == g { s = s + vals[i]; c = c + 1 } + if data[i] == g { + s = s + vals[i] + c = c + 1 + } i = i + 1 } result.push((g, s / c.to_double())) @@ -515,14 +612,18 @@ pub fn tgr_group_sum( ) -> Array[(String, Double)] { let data = tgr.metadata_str[group_col] let vals = tgr.metadata[value_col] - if data.length() == 0 || vals.length() == 0 { return [] } + if data.length() == 0 || vals.length() == 0 { + return [] + } let groups = tgr_get_unique_strings(data) let result : Array[(String, Double)] = Array::new() for g in groups { let mut s = 0.0 let mut i = 0 while i < data.length() { - if data[i] == g { s = s + vals[i] } + if data[i] == g { + s = s + vals[i] + } i = i + 1 } result.push((g, s)) @@ -595,8 +696,11 @@ pub fn tgr_left_join( let nv : Array[Double] = Array::make(n_left, 0.0) let mut i = 0 while i < n_left { - if matched_right.contains(i) { nv[i] = old[matched_right[i]] } - else { nv[i] = 0.0 } + if matched_right.contains(i) { + nv[i] = old[matched_right[i]] + } else { + nv[i] = 0.0 + } i = i + 1 } new_meta[key] = nv @@ -607,22 +711,33 @@ pub fn tgr_left_join( let nv : Array[String] = Array::make(n_left, "") let mut i = 0 while i < n_left { - if matched_right.contains(i) { nv[i] = old[matched_right[i]] } - else { nv[i] = "" } + if matched_right.contains(i) { + nv[i] = old[matched_right[i]] + } else { + nv[i] = "" + } i = i + 1 } new_meta_str[key] = nv } // Merge with left metadata let merged_meta = Map::new() - for key in left.metadata.keys() { merged_meta[key] = left.metadata[key] } + for key in left.metadata.keys() { + merged_meta[key] = left.metadata[key] + } for key in new_meta.keys() { - if !merged_meta.contains(key) { merged_meta[key] = new_meta[key] } + if !merged_meta.contains(key) { + merged_meta[key] = new_meta[key] + } } let merged_meta_str = Map::new() - for key in left.metadata_str.keys() { merged_meta_str[key] = left.metadata_str[key] } + for key in left.metadata_str.keys() { + merged_meta_str[key] = left.metadata_str[key] + } for key in new_meta_str.keys() { - if !merged_meta_str.contains(key) { merged_meta_str[key] = new_meta_str[key] } + if !merged_meta_str.contains(key) { + merged_meta_str[key] = new_meta_str[key] + } } TidifiedGRanges::{ seqnames: left.seqnames.copy(), @@ -656,7 +771,9 @@ pub fn tgr_stretch(tgr : TidifiedGRanges, amount : Int) -> TidifiedGRanges { while i < n { new_starts[i] = tgr.starts[i] - amount new_ends[i] = tgr.ends[i] + amount - if new_starts[i] < 1 { new_starts[i] = 1 } + if new_starts[i] < 1 { + new_starts[i] = 1 + } new_widths[i] = new_ends[i] - new_starts[i] + 1 i = i + 1 } @@ -683,7 +800,9 @@ pub fn tgr_resize_fixed(tgr : TidifiedGRanges, width : Int) -> TidifiedGRanges { let center = (tgr.starts[i] + tgr.ends[i]) / 2 new_starts[i] = center - width / 2 new_ends[i] = new_starts[i] + width - 1 - if new_starts[i] < 1 { new_starts[i] = 1 } + if new_starts[i] < 1 { + new_starts[i] = 1 + } new_widths[i] = new_ends[i] - new_starts[i] + 1 i = i + 1 } @@ -723,7 +842,11 @@ pub fn tgr_shift(tgr : TidifiedGRanges, amount : Int) -> TidifiedGRanges { ///| /// Flank: create flanking regions around each range. -pub fn tgr_flank(tgr : TidifiedGRanges, upstream : Int, downstream : Int) -> TidifiedGRanges { +pub fn tgr_flank( + tgr : TidifiedGRanges, + upstream : Int, + downstream : Int, +) -> TidifiedGRanges { let n = tgr.seqnames.length() let new_seqnames : Array[String] = Array::new() let new_starts : Array[Int] = Array::new() @@ -735,13 +858,17 @@ pub fn tgr_flank(tgr : TidifiedGRanges, upstream : Int, downstream : Int) -> Tid // Upstream flank new_seqnames.push(tgr.seqnames[i]) new_starts.push(tgr.starts[i] - upstream) - if new_starts[new_starts.length() - 1] < 1 { new_starts[new_starts.length() - 1] = 1 } + if new_starts[new_starts.length() - 1] < 1 { + new_starts[new_starts.length() - 1] = 1 + } new_ends.push(tgr.starts[i] - 1) if new_ends[new_ends.length() - 1] < new_starts[new_starts.length() - 1] { new_ends[new_ends.length() - 1] = new_starts[new_starts.length() - 1] } new_strands.push(tgr.strands[i]) - new_widths.push(new_ends[new_ends.length() - 1] - new_starts[new_starts.length() - 1] + 1) + new_widths.push( + new_ends[new_ends.length() - 1] - new_starts[new_starts.length() - 1] + 1, + ) // Downstream flank new_seqnames.push(tgr.seqnames[i]) new_starts.push(tgr.ends[i] + 1) @@ -796,12 +923,19 @@ pub fn tgr_compute_gc( let mut j = s while j <= e { let c = seq[j - 1:j].to_owned().to_upper() - if c == "G" || c == "C" { gc = gc + 1 } - else if c == "A" || c == "T" { at = at + 1 } + if c == "G" || c == "C" { + gc = gc + 1 + } else if c == "A" || c == "T" { + at = at + 1 + } j = j + 1 } let total = gc + at - result[i] = if total > 0 { gc.to_double() / total.to_double() } else { 0.0 } + result[i] = if total > 0 { + gc.to_double() / total.to_double() + } else { + 0.0 + } } i = i + 1 } @@ -815,7 +949,9 @@ pub fn tgr_intervene( set_names : Array[String], ) -> Array[(String, Int)] { let n = sets.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let result : Array[(String, Int)] = Array::new() // Compute pairwise overlaps let mut i = 0 @@ -829,7 +965,9 @@ pub fn tgr_intervene( } j = j + 1 } - if unique_count < 0 { unique_count = 0 } + if unique_count < 0 { + unique_count = 0 + } result.push((set_names[i], unique_count)) i = i + 1 } @@ -867,8 +1005,13 @@ pub fn tgr_summary(tgr : TidifiedGRanges) -> TgrSummary { let n = tgr.seqnames.length() if n == 0 { return TgrSummary::{ - n_ranges: 0, n_seqnames: 0, n_strands: 0, - total_bases: 0, mean_width: 0.0, min_width: 0, max_width: 0, + n_ranges: 0, + n_seqnames: 0, + n_strands: 0, + total_bases: 0, + mean_width: 0.0, + min_width: 0, + max_width: 0, } } let seqlevels = tgr_seqlevels(tgr) @@ -879,8 +1022,12 @@ pub fn tgr_summary(tgr : TidifiedGRanges) -> TgrSummary { let mut i = 0 while i < n { total = total + tgr.widths[i] - if tgr.widths[i] < mn { mn = tgr.widths[i] } - if tgr.widths[i] > mx { mx = tgr.widths[i] } + if tgr.widths[i] < mn { + mn = tgr.widths[i] + } + if tgr.widths[i] > mx { + mx = tgr.widths[i] + } i = i + 1 } TgrSummary::{ @@ -922,7 +1069,11 @@ pub fn tgr_coverage( } j = j + 1 } - result[i] = if qlen > 0 { covered.to_double() / qlen.to_double() } else { 0.0 } + result[i] = if qlen > 0 { + covered.to_double() / qlen.to_double() + } else { + 0.0 + } i = i + 1 } result @@ -930,7 +1081,10 @@ pub fn tgr_coverage( ///| /// Set operations: intersect two TidifiedGRanges. -pub fn tgr_intersect(a : TidifiedGRanges, b : TidifiedGRanges) -> TidifiedGRanges { +pub fn tgr_intersect( + a : TidifiedGRanges, + b : TidifiedGRanges, +) -> TidifiedGRanges { let overlaps = tgr_join_overlap(a, b) let result_seqnames : Array[String] = Array::new() let result_starts : Array[Int] = Array::new() @@ -940,7 +1094,11 @@ pub fn tgr_intersect(a : TidifiedGRanges, b : TidifiedGRanges) -> TidifiedGRange for pair in overlaps { let i = pair.0 let j = pair.1 - let ov_start = if a.starts[i] > b.starts[j] { a.starts[i] } else { b.starts[j] } + let ov_start = if a.starts[i] > b.starts[j] { + a.starts[i] + } else { + b.starts[j] + } let ov_end = if a.ends[i] < b.ends[j] { a.ends[i] } else { b.ends[j] } if ov_start <= ov_end { result_seqnames.push(a.seqnames[i]) @@ -966,7 +1124,9 @@ pub fn tgr_intersect(a : TidifiedGRanges, b : TidifiedGRanges) -> TidifiedGRange pub fn tgr_union(a : TidifiedGRanges, b : TidifiedGRanges) -> TidifiedGRanges { let overlaps = tgr_join_overlap(a, b) let b_overlapping = Map::new() - for pair in overlaps { b_overlapping[pair.1] = true } + for pair in overlaps { + b_overlapping[pair.1] = true + } let result_seqnames : Array[String] = Array::new() let result_starts : Array[Int] = Array::new() let result_ends : Array[Int] = Array::new() @@ -1024,10 +1184,16 @@ pub fn tgr_distance_to_nearest( if subject.seqnames[j] == qseq { let rstart = subject.starts[j] let rend = subject.ends[j] - let dist = if qend < rstart { rstart - qend } - else if qstart > rend { qstart - rend } - else { 0 } - if dist < min_dist { min_dist = dist } + let dist = if qend < rstart { + rstart - qend + } else if qstart > rend { + qstart - rend + } else { + 0 + } + if dist < min_dist { + min_dist = dist + } } j = j + 1 } diff --git a/src/polypeptide.mbt b/src/polypeptide.mbt index 02bf318b..e5101cac 100644 --- a/src/polypeptide.mbt +++ b/src/polypeptide.mbt @@ -9,7 +9,10 @@ pub struct PolypeptideComposition { } ///| -pub fn PolypeptideComposition::new(amino_acids : Map[String, Int], total_residues : Int) -> PolypeptideComposition { +pub fn PolypeptideComposition::new( + amino_acids : Map[String, Int], + total_residues : Int, +) -> PolypeptideComposition { PolypeptideComposition::{ amino_acids, total_residues } } @@ -20,7 +23,10 @@ pub struct HydrophobicityProfile { } ///| -pub fn HydrophobicityProfile::new(positions : Array[Int], values : Array[Double]) -> HydrophobicityProfile { +pub fn HydrophobicityProfile::new( + positions : Array[Int], + values : Array[Double], +) -> HydrophobicityProfile { HydrophobicityProfile::{ positions, values } } @@ -32,21 +38,44 @@ pub struct TransmembraneRegion { } ///| -pub fn TransmembraneRegion::new(start : Int, end : Int, score : Double) -> TransmembraneRegion { +pub fn TransmembraneRegion::new( + start : Int, + end : Int, + score : Double, +) -> TransmembraneRegion { TransmembraneRegion::{ start, end, score } } ///| pub fn calculate_composition(sequence : String) -> PolypeptideComposition { - let amino_acids : Map[String, Int] = Map([ - ("A", 0), ("R", 0), ("N", 0), ("D", 0), ("C", 0), - ("Q", 0), ("E", 0), ("G", 0), ("H", 0), ("I", 0), - ("L", 0), ("K", 0), ("M", 0), ("F", 0), ("P", 0), - ("S", 0), ("T", 0), ("W", 0), ("Y", 0), ("V", 0), - ], capacity=20) - + let amino_acids : Map[String, Int] = Map( + [ + ("A", 0), + ("R", 0), + ("N", 0), + ("D", 0), + ("C", 0), + ("Q", 0), + ("E", 0), + ("G", 0), + ("H", 0), + ("I", 0), + ("L", 0), + ("K", 0), + ("M", 0), + ("F", 0), + ("P", 0), + ("S", 0), + ("T", 0), + ("W", 0), + ("Y", 0), + ("V", 0), + ], + capacity=20, + ) + let mut total_residues = 0 - + let mut i = 0 while i < sequence.length() { let aa = char_at(sequence, i) @@ -55,37 +84,47 @@ pub fn calculate_composition(sequence : String) -> PolypeptideComposition { total_residues = total_residues + 1 i = i + 1 } - + PolypeptideComposition::new(amino_acids, total_residues) } ///| -pub fn calculate_percent_composition(composition : PolypeptideComposition) -> Map[String, Double] { +pub fn calculate_percent_composition( + composition : PolypeptideComposition, +) -> Map[String, Double] { let percent : Map[String, Double] = Map([], capacity=20) - + if composition.total_residues == 0 { return percent } - - let amino_acids = ["A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F", "P", "S", "T", "W", "Y", "V"] - + + let amino_acids = [ + "A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F", "P", "S", + "T", "W", "Y", "V", + ] + let mut i = 0 while i < amino_acids.length() { let aa = amino_acids[i] let count = composition.amino_acids.get(aa).unwrap_or(0) - let percentage = count.to_double() / composition.total_residues.to_double() * 100.0 + let percentage = count.to_double() / + composition.total_residues.to_double() * + 100.0 percent.set(aa, percentage) i = i + 1 } - + percent } ///| -pub fn calculate_hydrophobicity(sequence : String, scale : String) -> HydrophobicityProfile { +pub fn calculate_hydrophobicity( + sequence : String, + scale : String, +) -> HydrophobicityProfile { let positions : Array[Int] = Array::new() let values : Array[Double] = Array::new() - + let hydrophobicity_map = if scale == "kyte-doolittle" { kyte_doolittle_scale() } else if scale == "hopp-woods" { @@ -93,39 +132,77 @@ pub fn calculate_hydrophobicity(sequence : String, scale : String) -> Hydrophobi } else { kyte_doolittle_scale() } - + let mut i = 0 while i < sequence.length() { let aa = char_at(sequence, i) let score = hydrophobicity_map.get(aa).unwrap_or(0.0) - + positions.push(i + 1) values.push(score) - + i = i + 1 } - + HydrophobicityProfile::new(positions, values) } ///| fn kyte_doolittle_scale() -> Map[String, Double] { - Map([ - ("A", 1.8), ("R", -4.5), ("N", -3.5), ("D", -3.5), ("C", 2.5), - ("Q", -3.5), ("E", -3.5), ("G", -0.4), ("H", -3.2), ("I", 4.5), - ("L", 3.8), ("K", -3.9), ("M", 1.9), ("F", 2.8), ("P", -1.6), - ("S", -0.8), ("T", -0.7), ("W", -0.9), ("Y", -1.3), ("V", 4.2), - ], capacity=20) + Map( + [ + ("A", 1.8), + ("R", -4.5), + ("N", -3.5), + ("D", -3.5), + ("C", 2.5), + ("Q", -3.5), + ("E", -3.5), + ("G", -0.4), + ("H", -3.2), + ("I", 4.5), + ("L", 3.8), + ("K", -3.9), + ("M", 1.9), + ("F", 2.8), + ("P", -1.6), + ("S", -0.8), + ("T", -0.7), + ("W", -0.9), + ("Y", -1.3), + ("V", 4.2), + ], + capacity=20, + ) } ///| fn hopp_woods_scale() -> Map[String, Double] { - Map([ - ("A", -0.5), ("R", 3.0), ("N", 0.2), ("D", 3.0), ("C", -1.0), - ("Q", 0.2), ("E", 3.0), ("G", 0.0), ("H", -0.5), ("I", -1.8), - ("L", -1.8), ("K", 3.0), ("M", -1.3), ("F", -2.5), ("P", 0.0), - ("S", 0.3), ("T", -0.4), ("W", -3.4), ("Y", -2.3), ("V", -1.5), - ], capacity=20) + Map( + [ + ("A", -0.5), + ("R", 3.0), + ("N", 0.2), + ("D", 3.0), + ("C", -1.0), + ("Q", 0.2), + ("E", 3.0), + ("G", 0.0), + ("H", -0.5), + ("I", -1.8), + ("L", -1.8), + ("K", 3.0), + ("M", -1.3), + ("F", -2.5), + ("P", 0.0), + ("S", 0.3), + ("T", -0.4), + ("W", -3.4), + ("Y", -2.3), + ("V", -1.5), + ], + capacity=20, + ) } ///| @@ -136,7 +213,7 @@ pub fn calculate_hydrophobicity_window( ) -> HydrophobicityProfile { let positions : Array[Int] = Array::new() let values : Array[Double] = Array::new() - + let hydrophobicity_map = if scale == "kyte-doolittle" { kyte_doolittle_scale() } else if scale == "hopp-woods" { @@ -144,17 +221,21 @@ pub fn calculate_hydrophobicity_window( } else { kyte_doolittle_scale() } - + let half_window = window_size / 2 - + let mut i = 0 while i < sequence.length() { let mut sum = 0.0 let mut count = 0 - + let start = if i < half_window { 0 } else { i - half_window } - let end = if i + half_window >= sequence.length() { sequence.length() } else { i + half_window + 1 } - + let end = if i + half_window >= sequence.length() { + sequence.length() + } else { + i + half_window + 1 + } + let mut j = start while j < end { let aa = char_at(sequence, j) @@ -162,15 +243,15 @@ pub fn calculate_hydrophobicity_window( count = count + 1 j = j + 1 } - + let avg = sum / count.to_double() - + positions.push(i + 1) values.push(avg) - + i = i + 1 } - + HydrophobicityProfile::new(positions, values) } @@ -181,17 +262,19 @@ pub fn predict_transmembrane_regions( threshold : Double, ) -> Array[TransmembraneRegion] { let regions : Array[TransmembraneRegion] = Array::new() - - let profile = calculate_hydrophobicity_window(sequence, window_size, "kyte-doolittle") - + + let profile = calculate_hydrophobicity_window( + sequence, window_size, "kyte-doolittle", + ) + let mut in_region = false let mut region_start = 0 let mut region_scores : Array[Double] = Array::new() - + let mut i = 0 while i < profile.values.length() { let score = profile.values[i] - + if score >= threshold && !in_region { in_region = true region_start = profile.positions[i] @@ -201,7 +284,7 @@ pub fn predict_transmembrane_regions( region_scores.push(score) } else if score < threshold && in_region { in_region = false - + if region_scores.length() >= 5 { let mut avg_score = 0.0 let mut j = 0 @@ -210,14 +293,20 @@ pub fn predict_transmembrane_regions( j = j + 1 } avg_score = avg_score / region_scores.length().to_double() - - regions.push(TransmembraneRegion::new(region_start, profile.positions[i - 1], avg_score)) + + regions.push( + TransmembraneRegion::new( + region_start, + profile.positions[i - 1], + avg_score, + ), + ) } } - + i = i + 1 } - + if in_region && region_scores.length() >= 5 { let mut avg_score = 0.0 let mut j = 0 @@ -226,10 +315,16 @@ pub fn predict_transmembrane_regions( j = j + 1 } avg_score = avg_score / region_scores.length().to_double() - - regions.push(TransmembraneRegion::new(region_start, profile.positions[profile.positions.length() - 1], avg_score)) + + regions.push( + TransmembraneRegion::new( + region_start, + profile.positions[profile.positions.length() - 1], + avg_score, + ), + ) } - + regions } @@ -238,87 +333,112 @@ pub fn calculate_isoelectric_point(sequence : String) -> Double { let mut low = 0.0 let mut high = 14.0 let mut mid = 7.0 - + let mut i = 0 while i < 50 { mid = (low + high) / 2.0 let charge = calculate_charge(sequence, mid) - + if charge > 0.0 { low = mid } else { high = mid } - + i = i + 1 } - + mid } ///| fn calculate_charge(sequence : String, ph : Double) -> Double { let mut charge = 0.0 - + let mut i = 0 while i < sequence.length() { let aa = char_at(sequence, i) charge = charge + amino_acid_charge(aa, ph) i = i + 1 } - + charge } ///| fn amino_acid_charge(amino_acid : String, ph : Double) -> Double { - let pka_values = Map([ - ("A", (2.34, 9.69, 0.0)), ("R", (2.17, 9.04, 12.48)), ("N", (2.02, 8.80, 0.0)), - ("D", (1.88, 9.60, 3.65)), ("C", (1.96, 10.28, 8.18)), ("Q", (2.17, 9.13, 0.0)), - ("E", (2.19, 9.67, 4.25)), ("G", (2.34, 9.60, 0.0)), ("H", (1.82, 9.17, 6.00)), - ("I", (2.36, 9.60, 0.0)), ("L", (2.36, 9.60, 0.0)), ("K", (2.18, 8.95, 10.53)), - ("M", (2.28, 9.21, 0.0)), ("F", (1.83, 9.13, 0.0)), ("P", (1.99, 10.60, 0.0)), - ("S", (2.21, 9.15, 0.0)), ("T", (2.11, 9.62, 0.0)), ("W", (2.83, 9.39, 0.0)), - ("Y", (2.32, 9.62, 10.07)), ("V", (2.32, 9.62, 0.0)), - ], capacity=20) - + let pka_values = Map( + [ + ("A", (2.34, 9.69, 0.0)), + ("R", (2.17, 9.04, 12.48)), + ("N", (2.02, 8.80, 0.0)), + ("D", (1.88, 9.60, 3.65)), + ("C", (1.96, 10.28, 8.18)), + ("Q", (2.17, 9.13, 0.0)), + ("E", (2.19, 9.67, 4.25)), + ("G", (2.34, 9.60, 0.0)), + ("H", (1.82, 9.17, 6.00)), + ("I", (2.36, 9.60, 0.0)), + ("L", (2.36, 9.60, 0.0)), + ("K", (2.18, 8.95, 10.53)), + ("M", (2.28, 9.21, 0.0)), + ("F", (1.83, 9.13, 0.0)), + ("P", (1.99, 10.60, 0.0)), + ("S", (2.21, 9.15, 0.0)), + ("T", (2.11, 9.62, 0.0)), + ("W", (2.83, 9.39, 0.0)), + ("Y", (2.32, 9.62, 10.07)), + ("V", (2.32, 9.62, 0.0)), + ], + capacity=20, + ) + let pka_tuple = pka_values.get(amino_acid).unwrap_or((2.0, 9.0, 0.0)) let (pka_n, pka_c, pka_side) = pka_tuple - + let mut charge = 0.0 - - charge = charge + @math.pow(10.0, pka_n) / (@math.pow(10.0, pka_n) + @math.pow(10.0, ph)) - charge = charge - @math.pow(10.0, ph) / (@math.pow(10.0, pka_c) + @math.pow(10.0, ph)) - + + charge = charge + + @math.pow(10.0, pka_n) / (@math.pow(10.0, pka_n) + @math.pow(10.0, ph)) + charge = charge - + @math.pow(10.0, ph) / (@math.pow(10.0, pka_c) + @math.pow(10.0, ph)) + if pka_side > 0.0 { if amino_acid == "D" || amino_acid == "E" { - charge = charge - @math.pow(10.0, ph) / (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) + charge = charge - + @math.pow(10.0, ph) / (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) } else if amino_acid == "R" || amino_acid == "K" { - charge = charge + @math.pow(10.0, pka_side) / (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) + charge = charge + + @math.pow(10.0, pka_side) / + (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) } else if amino_acid == "H" { - charge = charge + @math.pow(10.0, pka_side) / (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) + charge = charge + + @math.pow(10.0, pka_side) / + (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) } else if amino_acid == "C" { - charge = charge - @math.pow(10.0, ph) / (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) + charge = charge - + @math.pow(10.0, ph) / (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) } else if amino_acid == "Y" { - charge = charge - @math.pow(10.0, ph) / (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) + charge = charge - + @math.pow(10.0, ph) / (@math.pow(10.0, pka_side) + @math.pow(10.0, ph)) } } - + charge } ///| pub fn calculate_aromaticity(sequence : String) -> Double { let aromatic = ["F", "Y", "W"] - + let mut count = 0 let mut total = 0 - + let mut i = 0 while i < sequence.length() { let aa = char_at(sequence, i) total = total + 1 - + let mut j = 0 while j < aromatic.length() { if aromatic[j] == aa { @@ -327,19 +447,27 @@ pub fn calculate_aromaticity(sequence : String) -> Double { } j = j + 1 } - + i = i + 1 } - - if total == 0 { 0.0 } else { count.to_double() / total.to_double() } + + if total == 0 { + 0.0 + } else { + count.to_double() / total.to_double() + } } ///| -pub fn create_example_polypeptide_data() -> (String, PolypeptideComposition, HydrophobicityProfile) { - let sequence = "MSGLVLLLFLLVSLTGVASSTPGGGEETLAALGRALEEELARHPYFYAPELLYYANKYNGVFQEAAELRKTVVLDVTSEQLRRLDTHLETYGKHEEHAQEAGERGPLRESLRALYNVPQLIESKGGVVPRRYKPVNDSGFFYVEELKDIKEKVAADDDDMVLKAVREAAKEGADFTMVTEIIEELKARLEKFNGEEDKARLAKDALKESDDWPLVKVLKNKDDYVHGFEEA"; - +pub fn create_example_polypeptide_data() -> ( + String, + PolypeptideComposition, + HydrophobicityProfile, +) { + let sequence = "MSGLVLLLFLLVSLTGVASSTPGGGEETLAALGRALEEELARHPYFYAPELLYYANKYNGVFQEAAELRKTVVLDVTSEQLRRLDTHLETYGKHEEHAQEAGERGPLRESLRALYNVPQLIESKGGVVPRRYKPVNDSGFFYVEELKDIKEKVAADDDDMVLKAVREAAKEGADFTMVTEIIEELKARLEKFNGEEDKARLAKDALKESDDWPLVKVLKNKDDYVHGFEEA" + let composition = calculate_composition(sequence) let profile = calculate_hydrophobicity(sequence, "kyte-doolittle") - + (sequence, composition, profile) -} \ No newline at end of file +} diff --git a/src/popgen_advanced.mbt b/src/popgen_advanced.mbt index c1b75e40..8c7e0621 100644 --- a/src/popgen_advanced.mbt +++ b/src/popgen_advanced.mbt @@ -48,7 +48,10 @@ pub struct NeutralityTestConfig { ///| /// Default neutrality test configuration. -pub fn NeutralityTestConfig::default(sample_size : Int, sequence_length : Int) -> NeutralityTestConfig { +pub fn NeutralityTestConfig::default( + sample_size : Int, + sequence_length : Int, +) -> NeutralityTestConfig { NeutralityTestConfig::{ sample_size, sequence_length, @@ -145,13 +148,21 @@ pub fn new_polymorphic_site( ///| /// Create a singleton site. -pub fn new_singleton(position : Int, sample_size : Int, is_replacement : Bool) -> PolymorphicSite { +pub fn new_singleton( + position : Int, + sample_size : Int, + is_replacement : Bool, +) -> PolymorphicSite { new_polymorphic_site(position, 1, sample_size, is_replacement) } ///| /// Create a doubleton site. -pub fn new_doubleton(position : Int, sample_size : Int, is_replacement : Bool) -> PolymorphicSite { +pub fn new_doubleton( + position : Int, + sample_size : Int, + is_replacement : Bool, +) -> PolymorphicSite { new_polymorphic_site(position, 2, sample_size, is_replacement) } @@ -167,7 +178,10 @@ pub fn new_doubleton(position : Int, sample_size : Int, is_replacement : Bool) - /// Reference: Watterson, G. A. (1975). /// "On the number of segregating sites in genetical models /// without recombination." Theor. Popul. Biol. 7:256-276. -pub fn popgen_watterson_theta(segregating_sites : Int, sample_size : Int) -> Double { +pub fn popgen_watterson_theta( + segregating_sites : Int, + sample_size : Int, +) -> Double { if sample_size <= 1 || segregating_sites == 0 { return 0.0 } @@ -224,16 +238,12 @@ pub fn popgen_tajima_d( ) -> NeutralityTestResult { let theta_w = popgen_watterson_theta(segregating_sites, sample_size) let se = tajima_d_standard_error(sample_size, segregating_sites, theta_w) - - let d_value = if se > 0.0 { - (theta_pi - theta_w) / se - } else { - 0.0 - } - + + let d_value = if se > 0.0 { (theta_pi - theta_w) / se } else { 0.0 } + // Approximate p-value using beta distribution let p_val = approximate_tajima_d_pvalue(d_value, sample_size) - + let interpretation = if d_value < -1.0 { "Negative D: excess of low-frequency variants, suggests population expansion or positive selection" } else if d_value > 1.0 { @@ -241,12 +251,16 @@ pub fn popgen_tajima_d( } else { "Neutral pattern: consistent with equilibrium neutrality" } - + NeutralityTestResult::{ test_name: "Tajima's D", statistic: d_value, p_value: p_val, - is_significant: if p_val != None { p_val.unwrap() < 0.05 } else { false }, + is_significant: if p_val != None { + p_val.unwrap() < 0.05 + } else { + false + }, interpretation, standard_error: se, sample_size, @@ -259,14 +273,14 @@ pub fn tajima_d_standard_error(n : Int, s : Int, theta_w : Double) -> Double { if n <= 1 || s <= 0 || theta_w <= 0.0 { return 0.0 } - + let a1 = watterson_a1(n) let a2 = watterson_a2(n) let b1 = tajima_b1(n) let b2 = tajima_b2(n) - + // Var(theta_pi - theta_W) ≈ c1*S + c2*S*(S-1) - let theta_var = (b1 / a1) * theta_w + (b2 / (a1 * a2)) * theta_w * theta_w + let theta_var = b1 / a1 * theta_w + b2 / (a1 * a2) * theta_w * theta_w theta_var.sqrt() } @@ -302,7 +316,9 @@ pub fn tajima_b2(n : Int) -> Double { let a1 = watterson_a1(n) let a2 = watterson_a2(n) // b2 = (2*(n^2 + n + 3)) / (9*n*(n-1)) - (a2/(a1^2)) - let term1 = 2.0 * (n.to_double() * n.to_double() + n.to_double() + 3.0) / (9.0 * n.to_double() * (n.to_double() - 1.0)) + let term1 = 2.0 * + (n.to_double() * n.to_double() + n.to_double() + 3.0) / + (9.0 * n.to_double() * (n.to_double() - 1.0)) let term2 = a2 / (a1 * a1) term1 - term2 } @@ -314,16 +330,16 @@ pub fn approximate_tajima_d_pvalue(d : Double, n : Int) -> Double? { if n <= 1 { return None } - + // Approximation: D approximately follows a scaled beta distribution // Mean ≈ 0, Var ≈ 1 // Transform to approximate normal let abs_d = d.abs() - + // Simple approximation for p-value // Two-sided test let p = 2.0 * (1.0 - popgen_normal_cdf(abs_d)) - + if p < 0.0001 { Some(0.0001) } else if p > 1.0 { @@ -339,7 +355,12 @@ pub fn popgen_normal_cdf(x : Double) -> Double { // Abramowitz and Stegun approximation let t = 1.0 / (1.0 + 0.2316419 * x.abs()) let d = 0.3989422804014327 * @math.exp(-x * x / 2.0) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))) + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))) + ) if x > 0.0 { 1.0 - p } else { @@ -378,24 +399,20 @@ pub fn fu_li_d( sample_size, } } - + let n = sample_size.to_double() let a1 = watterson_a1(sample_size) let theta = if a1 > 0.0 { segregating_sites.to_double() / a1 } else { 0.0 } - + // D = (singletons/n - theta) / SE let observed = singletons.to_double() / n let expected = theta let se = fu_li_d_standard_error(sample_size, segregating_sites, theta) - - let d_value = if se > 0.0 { - (observed - expected) / se - } else { - 0.0 - } - + + let d_value = if se > 0.0 { (observed - expected) / se } else { 0.0 } + let p_val = approximate_tajima_d_pvalue(d_value, sample_size) - + let interpretation = if d_value < -1.0 { "Negative D: excess of singletons, suggests population expansion or positive selection" } else if d_value > 1.0 { @@ -403,12 +420,16 @@ pub fn fu_li_d( } else { "Neutral pattern" } - + NeutralityTestResult::{ test_name: "Fu & Li's D", statistic: d_value, p_value: p_val, - is_significant: if p_val != None { p_val.unwrap() < 0.05 } else { false }, + is_significant: if p_val != None { + p_val.unwrap() < 0.05 + } else { + false + }, interpretation, standard_error: se, sample_size, @@ -421,10 +442,10 @@ pub fn fu_li_d_standard_error(n : Int, s : Int, theta : Double) -> Double { if n <= 1 || s <= 0 || theta <= 0.0 { return 0.0 } - + let a1 = watterson_a1(n) let a2 = watterson_a2(n) - + // Simplified variance calculation let theta_var = theta * (1.0 / a1 + a2 / (a1 * a1 * n.to_double())) theta_var.sqrt() @@ -452,25 +473,25 @@ pub fn fu_li_f( sample_size, } } - + let a1 = watterson_a1(sample_size) let a2 = watterson_a2(sample_size) - + // Expected singletons under neutrality let expected = segregating_sites.to_double() * a1 / (a1 + a2) let theta = if a1 > 0.0 { segregating_sites.to_double() / a1 } else { 0.0 } - + // Standard error let se = (theta * (a1 * a2) / (a1 + a2)).sqrt() - + let f_value = if se > 0.0 { (singletons.to_double() - expected) / se } else { 0.0 } - + let p_val = approximate_tajima_d_pvalue(f_value, sample_size) - + let interpretation = if f_value < -1.0 { "Negative F: excess of singletons relative to overall diversity" } else if f_value > 1.0 { @@ -478,12 +499,16 @@ pub fn fu_li_f( } else { "Neutral pattern" } - + NeutralityTestResult::{ test_name: "Fu & Li's F", statistic: f_value, p_value: p_val, - is_significant: if p_val != None { p_val.unwrap() < 0.05 } else { false }, + is_significant: if p_val != None { + p_val.unwrap() < 0.05 + } else { + false + }, interpretation, standard_error: se, sample_size, @@ -524,36 +549,38 @@ pub fn mcdonald_kreitman_test( } else { 0.0 } - + let div_ratio = if d_syn > 0 { d_nonsyn.to_double() / d_syn.to_double() } else { 0.0 } - + // Neutrality index - let ni = if div_ratio > 0.0 { - poly_ratio / div_ratio - } else { - 1.0 - } - + let ni = if div_ratio > 0.0 { poly_ratio / div_ratio } else { 1.0 } + // Fisher's exact test p-value let p_val = fisher_exact_test_2x2(p_nonsyn, p_syn, d_nonsyn, d_syn) - + // Interpretation let (interpretation, has_selection) = if p_val < 0.05 { if poly_ratio > div_ratio * 1.5 { - ("Significant positive selection: excess of replacement polymorphisms over fixations", true) + ( + "Significant positive selection: excess of replacement polymorphisms over fixations", + true, + ) } else if div_ratio > poly_ratio * 1.5 { - ("Significant purifying selection: excess of replacement fixations over polymorphisms", true) + ( + "Significant purifying selection: excess of replacement fixations over polymorphisms", + true, + ) } else { ("Significant departure from neutrality (non-neutral pattern)", true) } } else { ("No significant departure from neutrality", false) } - + MKTestResult::{ p_nonsyn, p_syn, @@ -575,42 +602,56 @@ pub fn fisher_exact_test_2x2(a : Int, b : Int, c : Int, d : Int) -> Double { if n <= 0.0 { return 1.0 } - + // Expected values let row1 = (a + b).to_double() let row2 = (c + d).to_double() let col1 = (a + c).to_double() let col2 = (b + d).to_double() - + let e_a = row1 * col1 / n let e_b = row1 * col2 / n let e_c = row2 * col1 / n let e_d = row2 * col2 / n - + // Chi-square statistic let chi2_a = if e_a > 0.0 { let diff = (a.to_double() - e_a).abs() - 0.5 diff * diff / e_a - } else { 0.0 } + } else { + 0.0 + } let chi2_b = if e_b > 0.0 { let diff = (b.to_double() - e_b).abs() - 0.5 diff * diff / e_b - } else { 0.0 } + } else { + 0.0 + } let chi2_c = if e_c > 0.0 { let diff = (c.to_double() - e_c).abs() - 0.5 diff * diff / e_c - } else { 0.0 } + } else { + 0.0 + } let chi2_d = if e_d > 0.0 { let diff = (d.to_double() - e_d).abs() - 0.5 diff * diff / e_d - } else { 0.0 } + } else { + 0.0 + } let chi2 = chi2_a + chi2_b + chi2_c + chi2_d - + // Approximate p-value from chi-square with df=1 // Using the relationship between chi-square and normal let p = @math.exp(-chi2 / 2.0) - - if p < 0.0001 { 0.0001 } else if p > 1.0 { 1.0 } else { p } + + if p < 0.0001 { + 0.0001 + } else if p > 1.0 { + 1.0 + } else { + p + } } ///| @@ -623,7 +664,7 @@ pub fn mktest_from_sites( let mut p_syn = 0 let mut d_nonsyn = 0 let mut d_syn = 0 - + for site in poly_sites { if site.is_replacement { p_nonsyn += 1 @@ -631,7 +672,7 @@ pub fn mktest_from_sites( p_syn += 1 } } - + for site in fixed_sites { if site.is_replacement { d_nonsyn += 1 @@ -639,7 +680,7 @@ pub fn mktest_from_sites( d_syn += 1 } } - + mcdonald_kreitman_test(p_nonsyn, p_syn, d_nonsyn, d_syn) } @@ -649,30 +690,33 @@ pub fn mktest_from_sites( ///| /// Calculate the allele frequency spectrum from polymorphic sites. -pub fn calculate_afs(sites : Array[PolymorphicSite], sample_size : Int) -> AlleleFrequencySpectrum { +pub fn calculate_afs( + sites : Array[PolymorphicSite], + sample_size : Int, +) -> AlleleFrequencySpectrum { let mut singletons = 0 let mut doubletons = 0 let mut segregating_sites = 0 let mut total_mutations = 0 - + let unfolded = Array::make(sample_size, 0) let folded = Array::make((sample_size + 1) / 2, 0) - + for site in sites { segregating_sites += 1 total_mutations += site.derived_count - + if site.derived_count == 1 { singletons += 1 } else if site.derived_count == 2 { doubletons += 1 } - + // Unfolded spectrum if site.derived_count < sample_size { unfolded[site.derived_count] += 1 } - + // Folded spectrum (use minimum of derived and ancestral) let minor = if site.derived_count < sample_size - site.derived_count { site.derived_count @@ -683,7 +727,7 @@ pub fn calculate_afs(sites : Array[PolymorphicSite], sample_size : Int) -> Allel folded[minor] += 1 } } - + AlleleFrequencySpectrum::{ sample_size, singletons, @@ -697,7 +741,10 @@ pub fn calculate_afs(sites : Array[PolymorphicSite], sample_size : Int) -> Allel ///| /// Calculate Tajima's D from allele frequency spectrum. -pub fn tajima_d_from_afs(afs : AlleleFrequencySpectrum, sequence_length : Int) -> NeutralityTestResult { +pub fn tajima_d_from_afs( + afs : AlleleFrequencySpectrum, + sequence_length : Int, +) -> NeutralityTestResult { let n = afs.sample_size if n <= 1 || afs.segregating_sites <= 0 { return NeutralityTestResult::{ @@ -710,22 +757,29 @@ pub fn tajima_d_from_afs(afs : AlleleFrequencySpectrum, sequence_length : Int) - sample_size: n, } } - + // Calculate theta_pi (average number of pairwise differences per site) let mut theta_pi = 0.0 let n_float = n.to_double() - + for i = 1; i < n; i = i + 1 { - let count = if i < afs.unfolded_spectrum.length() { afs.unfolded_spectrum[i] } else { 0 } - let contrib = (2.0 * i.to_double() * (n_float - i.to_double())) / (n_float * (n_float - 1.0)) + let count = if i < afs.unfolded_spectrum.length() { + afs.unfolded_spectrum[i] + } else { + 0 + } + let contrib = 2.0 * + i.to_double() * + (n_float - i.to_double()) / + (n_float * (n_float - 1.0)) theta_pi += contrib * count.to_double() } - + // Normalize by sequence length if sequence_length > 0 { theta_pi = theta_pi / sequence_length.to_double() } - + popgen_tajima_d(theta_pi, afs.segregating_sites, n, sequence_length) } @@ -760,30 +814,37 @@ pub fn run_neutrality_analysis( sequence_length : Int, ) -> NeutralityAnalysisResult { let afs = calculate_afs(sites, sample_size) - + let theta_w = popgen_watterson_theta(afs.segregating_sites, sample_size) let result_d = tajima_d_from_afs(afs, sequence_length) let result_fu_d = fu_li_d_from_afs(afs) let result_fu_f = fu_li_f(afs.singletons, afs.segregating_sites, sample_size) - + // Calculate theta_pi let mut theta_pi = 0.0 let n_float = sample_size.to_double() - + for i = 1; i < sample_size; i = i + 1 { - let count = if i < afs.unfolded_spectrum.length() { afs.unfolded_spectrum[i] } else { 0 } - let contrib = (2.0 * i.to_double() * (n_float - i.to_double())) / (n_float * (n_float - 1.0)) + let count = if i < afs.unfolded_spectrum.length() { + afs.unfolded_spectrum[i] + } else { + 0 + } + let contrib = 2.0 * + i.to_double() * + (n_float - i.to_double()) / + (n_float * (n_float - 1.0)) theta_pi += contrib * count.to_double() } if sequence_length > 0 { theta_pi = theta_pi / sequence_length.to_double() } - + // Determine if neutral - let is_neutral = !result_d.is_significant && - !result_fu_d.is_significant && + let is_neutral = !result_d.is_significant && + !result_fu_d.is_significant && !result_fu_f.is_significant - + NeutralityAnalysisResult::{ tajima_d: result_d, fu_li_d: result_fu_d, @@ -798,7 +859,9 @@ pub fn run_neutrality_analysis( ///| /// Format a neutrality analysis result as a string. -pub fn neutrality_analysis_to_string(result : NeutralityAnalysisResult) -> String { +pub fn neutrality_analysis_to_string( + result : NeutralityAnalysisResult, +) -> String { let mut s = "" s = s + "=== Neutrality Analysis Results ===\n\n" s = s + "Sample size: " @@ -813,7 +876,7 @@ pub fn neutrality_analysis_to_string(result : NeutralityAnalysisResult) -> Strin s = s + "Tajima's theta (theta_pi): " s = s + result.tajima_theta_pi.to_string() s = s + "\n\n" - + // Tajima's D s = s + "Tajima's D: " s = s + result.tajima_d.statistic.to_string() @@ -828,7 +891,7 @@ pub fn neutrality_analysis_to_string(result : NeutralityAnalysisResult) -> Strin s = s + "\n " s = s + result.tajima_d.interpretation s = s + "\n\n" - + // Fu & Li's D s = s + "Fu & Li's D: " s = s + result.fu_li_d.statistic.to_string() @@ -843,7 +906,7 @@ pub fn neutrality_analysis_to_string(result : NeutralityAnalysisResult) -> Strin s = s + "\n " s = s + result.fu_li_d.interpretation s = s + "\n\n" - + // Fu & Li's F s = s + "Fu & Li's F: " s = s + result.fu_li_f.statistic.to_string() @@ -858,7 +921,7 @@ pub fn neutrality_analysis_to_string(result : NeutralityAnalysisResult) -> Strin s = s + "\n " s = s + result.fu_li_f.interpretation s = s + "\n\n" - + s = s + "Overall: " if result.is_neutral { s = s + "CONSISTENT WITH NEUTRALITY" @@ -866,6 +929,6 @@ pub fn neutrality_analysis_to_string(result : NeutralityAnalysisResult) -> Strin s = s + "SIGNIFICANT DEPARTURE FROM NEUTRALITY DETECTED" } s = s + "\n" - + s -} \ No newline at end of file +} diff --git a/src/preprocess_core.mbt b/src/preprocess_core.mbt index f9c0f8d2..943f47a6 100644 --- a/src/preprocess_core.mbt +++ b/src/preprocess_core.mbt @@ -26,11 +26,7 @@ pub struct QuantileNormConfig { ///| /// Create default quantile normalization config. pub fn QuantileNormConfig::new() -> QuantileNormConfig { - QuantileNormConfig::{ - copy: true, - keep_names: true, - method: "quantile", - } + QuantileNormConfig::{ copy: true, keep_names: true, method: "quantile" } } ///| @@ -65,7 +61,11 @@ pub fn InvariantSetResult::new( ///| /// Absolute value for double. fn pc_abs(x : Double) -> Double { - if x < 0.0 { -x } else { x } + if x < 0.0 { + -x + } else { + x + } } ///| @@ -116,8 +116,12 @@ pub fn pc_interp_linear( x : Double, ) -> Double { let n = xs.length() - if n == 0 { return 0.0 } - if n == 1 { return ys[0] } + if n == 0 { + return 0.0 + } + if n == 1 { + return ys[0] + } // Handle extrapolation below minimum if x <= xs[0] { return ys[0] @@ -145,12 +149,11 @@ pub fn pc_interp_linear( ///| /// Linear model fit via least squares (simple y = a + bx). /// Returns [intercept, slope]. -fn pc_linear_fit( - xs : Array[Double], - ys : Array[Double], -) -> Array[Double] { +fn pc_linear_fit(xs : Array[Double], ys : Array[Double]) -> Array[Double] { let n = xs.length() - if n < 2 { return [0.0, 0.0] } + if n < 2 { + return [0.0, 0.0] + } let mut sum_x = 0.0 let mut sum_y = 0.0 let mut sum_xx = 0.0 @@ -188,9 +191,13 @@ pub fn normalize_quantiles( matrix : Array[Array[Double]], ) -> Array[Array[Double]] { let n_rows = matrix.length() - if n_rows == 0 { return matrix } + if n_rows == 0 { + return matrix + } let n_cols = matrix[0].length() - if n_cols == 0 { return matrix } + if n_cols == 0 { + return matrix + } // Transpose: work with columns as arrays // column_arrays[col] = [row0, row1, ..., rowN] @@ -260,10 +267,16 @@ pub fn normalize_quantiles_use_target( target : Array[Double], ) -> Array[Array[Double]] { let n_rows = matrix.length() - if n_rows == 0 { return matrix } + if n_rows == 0 { + return matrix + } let n_cols = matrix[0].length() - if n_cols == 0 { return matrix } - if target.length() != n_rows { return matrix } + if n_cols == 0 { + return matrix + } + if target.length() != n_rows { + return matrix + } let sorted_target = pc_sort_doubles(target) @@ -296,9 +309,13 @@ pub fn normalize_quantiles_determine_target( matrix : Array[Array[Double]], ) -> Array[Double] { let n_rows = matrix.length() - if n_rows == 0 { return [] } + if n_rows == 0 { + return [] + } let n_cols = matrix[0].length() - if n_cols == 0 { return [] } + if n_cols == 0 { + return [] + } // Sort each column let sorted_cols : Array[Array[Double]] = [] @@ -333,10 +350,16 @@ pub fn normalize_quantiles_subset( subset_indices : Array[Int], ) -> Array[Array[Double]] { let n_rows = matrix.length() - if n_rows == 0 { return matrix } + if n_rows == 0 { + return matrix + } let n_cols = matrix[0].length() - if n_cols == 0 { return matrix } - if subset_indices.length() == 0 { return normalize_quantiles(matrix) } + if n_cols == 0 { + return matrix + } + if subset_indices.length() == 0 { + return normalize_quantiles(matrix) + } // Build subset matrix let sub_n = subset_indices.length() @@ -346,7 +369,9 @@ pub fn normalize_quantiles_subset( } for s_idx in 0..= n_rows { continue } + if orig_row < 0 || orig_row >= n_rows { + continue + } sub_matrix[s_idx] = matrix[orig_row].copy() } @@ -391,11 +416,13 @@ pub fn normalize_quantiles_subset( pub fn find_invariant_set( reference : Array[Double], target : Array[Double], - threshold~ : Double = 0.005, - max_iterations~ : Int = 10, + threshold? : Double = 0.005, + max_iterations? : Int = 10, ) -> Array[Int] { let n = reference.length() - if n != target.length() || n == 0 { return [] } + if n != target.length() || n == 0 { + return [] + } // Rank each array let ref_order = pc_argsort(reference) @@ -429,7 +456,9 @@ pub fn find_invariant_set( for idx in invariant { let predicted = intercept + slope * ref_ranks[idx] let residual = pc_abs(tgt_ranks[idx] - predicted) - if max_residual < residual { max_residual = residual } + if max_residual < residual { + max_residual = residual + } } let cutoff = threshold * n.to_double() if max_residual < cutoff || invariant.length() < 3 { @@ -447,7 +476,9 @@ pub fn find_invariant_set( break } invariant = new_invariant - if invariant.length() < 3 { break } + if invariant.length() < 3 { + break + } iter = iter + 1 } @@ -459,8 +490,8 @@ pub fn find_invariant_set( /// Reference column is specified by reference_index. pub fn normalize_invariantset( matrix : Array[Array[Double]], - reference_index~ : Int = 0, - threshold~ : Double = 0.005, + reference_index? : Int = 0, + threshold? : Double = 0.005, ) -> InvariantSetResult { let n_rows = matrix.length() if n_rows == 0 { @@ -490,7 +521,7 @@ pub fn normalize_invariantset( for row in 0.. Array[Array[Double]] { let n_rows = matrix.length() - if n_rows == 0 { return matrix } + if n_rows == 0 { + return matrix + } let n_cols = matrix[0].length() let result : Array[Array[Double]] = [] for _row in 0.. Array[Array[Double]] { let n_rows = matrix.length() - if n_rows == 0 { return matrix } + if n_rows == 0 { + return matrix + } let n_cols = matrix[0].length() let result : Array[Array[Double]] = [] @@ -580,7 +614,13 @@ pub fn background_correct_percentile( } let sorted = pc_sort_doubles(col_data) let idx = (percentile * (n_rows - 1).to_double()).to_int() - let bg = sorted[if idx < 0 { 0 } else { if idx >= n_rows { n_rows - 1 } else { idx } }] + let bg = sorted[if idx < 0 { + 0 + } else if idx >= n_rows { + n_rows - 1 + } else { + idx + }] for row in 0.. Array[Array[Double]] { let n_rows = matrix.length() - if n_rows == 0 { return matrix } + if n_rows == 0 { + return matrix + } let n_cols = matrix[0].length() let result : Array[Array[Double]] = [] @@ -625,11 +667,11 @@ pub fn median_center_columns( ///| /// Compute column summary statistics. /// Returns [mean, median, sd, min, max] for each column. -pub fn column_summary( - matrix : Array[Array[Double]], -) -> Array[Array[Double]] { +pub fn column_summary(matrix : Array[Array[Double]]) -> Array[Array[Double]] { let n_rows = matrix.length() - if n_rows == 0 { return [] } + if n_rows == 0 { + return [] + } let n_cols = matrix[0].length() let result : Array[Array[Double]] = [] for _col in 0.. Primer3Config { Primer3Config::{ primer_length_min, @@ -51,7 +51,7 @@ pub fn Primer3Config::new( max_self_complement, max_cross_complement, salt_conc, - flank + flank, } } @@ -100,17 +100,13 @@ pub fn Primer3Config::gc_max(self : Primer3Config) -> Double { ///| /// Maximum allowed self-complementarity score. -pub fn Primer3Config::max_self_complement( - self : Primer3Config -) -> Int { +pub fn Primer3Config::max_self_complement(self : Primer3Config) -> Int { self.max_self_complement } ///| /// Maximum allowed cross-complementarity score. -pub fn Primer3Config::max_cross_complement( - self : Primer3Config -) -> Int { +pub fn Primer3Config::max_cross_complement(self : Primer3Config) -> Int { self.max_cross_complement } @@ -153,7 +149,7 @@ pub fn Primer3Result::new( gc : Double, self_complement : Int, is_forward : Bool, - score : Double + score : Double, ) -> Primer3Result { Primer3Result::{ sequence, @@ -163,7 +159,7 @@ pub fn Primer3Result::new( gc, self_complement, is_forward, - score + score, } } @@ -199,9 +195,7 @@ pub fn Primer3Result::gc(self : Primer3Result) -> Double { ///| /// Self-complementarity score (lower is better). -pub fn Primer3Result::self_complement( - self : Primer3Result -) -> Int { +pub fn Primer3Result::self_complement(self : Primer3Result) -> Int { self.self_complement } @@ -290,10 +284,7 @@ pub fn primer3_tm_wallace(seq : String) -> Double { /// Salt-adjusted melting temperature: /// Tm = 81.5 + 16.6 * log10([Na+]) + 0.41 * %GC - 600 / length /// Suitable for longer primers. `salt_conc` is in mol/L. -pub fn primer3_tm_salt( - seq : String, - salt_conc : Double -) -> Double { +pub fn primer3_tm_salt(seq : String, salt_conc : Double) -> Double { let n = seq.length() if n == 0 { return 0.0 @@ -308,10 +299,7 @@ pub fn primer3_tm_salt( ///| /// Choose an appropriate Tm formula based on length. /// Short oligos (< 14 nt) use Wallace; longer use the salt-adjusted formula. -pub fn primer3_tm( - seq : String, - salt_conc : Double -) -> Double { +pub fn primer3_tm(seq : String, salt_conc : Double) -> Double { if seq.length() < 14 { primer3_tm_wallace(seq) } else { @@ -371,10 +359,7 @@ pub fn primer3_self_complement(seq : String) -> Int { /// Score cross-dimer complementarity between two primers by sliding /// the reverse complement of seq2 against seq1 and counting paired bases. /// Returns the maximum paired count across all offsets. -pub fn primer3_cross_dimer( - seq1 : String, - seq2 : String -) -> Int { +pub fn primer3_cross_dimer(seq1 : String, seq2 : String) -> Int { let n1 = seq1.length() let n2 = seq2.length() if n1 == 0 || n2 == 0 { @@ -411,10 +396,7 @@ pub fn primer3_cross_dimer( /// Detect hairpin potential by checking self-complementarity at the 3' end. /// Returns the self-complementarity score restricted to the last /// `end_len` bases of the primer. -pub fn primer3_hairpin_3prime( - seq : String, - end_len : Int -) -> Int { +pub fn primer3_hairpin_3prime(seq : String, end_len : Int) -> Int { let n = seq.length() if n == 0 || end_len <= 0 { return 0 @@ -438,7 +420,7 @@ pub fn primer3_score( tm : Double, gc : Double, self_comp : Int, - config : Primer3Config + config : Primer3Config, ) -> Double { let tm_mid = (config.tm_min + config.tm_max) / 2.0 let tm_span = (config.tm_max - config.tm_min) / 2.0 @@ -454,7 +436,8 @@ pub fn primer3_score( } else { 0.0 } - let self_penalty = self_comp.to_double() / config.primer_length_min.to_double() + let self_penalty = self_comp.to_double() / + config.primer_length_min.to_double() // Score in [0, 100]; 100 is ideal. 100.0 - 40.0 * tm_penalty - 30.0 * gc_penalty - 30.0 * self_penalty } @@ -474,7 +457,7 @@ pub struct Primer3Design { /// Construct a `Primer3Design`. pub fn Primer3Design::new( forward : Array[Primer3Result], - reverse : Array[Primer3Result] + reverse : Array[Primer3Result], ) -> Primer3Design { Primer3Design::{ forward, reverse } } @@ -511,9 +494,7 @@ pub fn Primer3Design::has_pair(self : Primer3Design) -> Bool { ///| /// Best forward primer (highest score), or None if no candidate. -pub fn Primer3Design::best_forward( - self : Primer3Design -) -> Primer3Result? { +pub fn Primer3Design::best_forward(self : Primer3Design) -> Primer3Result? { if self.forward.length() == 0 { None } else { @@ -523,9 +504,7 @@ pub fn Primer3Design::best_forward( ///| /// Best reverse primer (highest score), or None if no candidate. -pub fn Primer3Design::best_reverse( - self : Primer3Design -) -> Primer3Result? { +pub fn Primer3Design::best_reverse(self : Primer3Design) -> Primer3Result? { if self.reverse.length() == 0 { None } else { @@ -536,7 +515,7 @@ pub fn Primer3Design::best_reverse( ///| /// Best primer pair (forward, reverse), or None if either is missing. pub fn Primer3Design::best_pair( - self : Primer3Design + self : Primer3Design, ) -> (Primer3Result, Primer3Result)? { if self.has_pair() { Some((self.forward[0], self.reverse[0])) @@ -551,7 +530,7 @@ pub fn Primer3Design::best_pair( /// primer candidates sorted by score (best first). pub fn primer3_design_primers( template : String, - config : Primer3Config + config : Primer3Config, ) -> Primer3Design { let n = template.length() let forward = Array::new() @@ -576,7 +555,7 @@ pub fn primer3_design_primers( sc <= config.max_self_complement { let score = primer3_score(seq, tm, gc, sc, config) forward.push( - Primer3Result::new(seq, start, len, tm, gc, sc, true, score) + Primer3Result::new(seq, start, len, tm, gc, sc, true, score), ) } len = len + 1 @@ -606,17 +585,31 @@ pub fn primer3_design_primers( gc <= config.gc_max && sc <= config.max_self_complement { let score = primer3_score(seq, tm, gc, sc, config) - reverse.push( - Primer3Result::new(seq, ts, len, tm, gc, sc, false, score) - ) + reverse.push(Primer3Result::new(seq, ts, len, tm, gc, sc, false, score)) } len = len + 1 } rstart = rstart - 1 } // Sort by score descending (highest/best first). - forward.sort_by(fn(a, b) { if a.score() > b.score() { -1 } else if a.score() < b.score() { 1 } else { 0 } }) - reverse.sort_by(fn(a, b) { if a.score() > b.score() { -1 } else if a.score() < b.score() { 1 } else { 0 } }) + forward.sort_by(fn(a, b) { + if a.score() > b.score() { + -1 + } else if a.score() < b.score() { + 1 + } else { + 0 + } + }) + reverse.sort_by(fn(a, b) { + if a.score() > b.score() { + -1 + } else if a.score() < b.score() { + 1 + } else { + 0 + } + }) Primer3Design::new(forward, reverse) } @@ -631,7 +624,7 @@ pub fn primer3_amplicon_length( fwd_start : Int, fwd_len : Int, rev_start : Int, - rev_len : Int + rev_len : Int, ) -> Int { let amp_end = rev_start + rev_len // exclusive end amp_end - fwd_start @@ -641,7 +634,7 @@ pub fn primer3_amplicon_length( /// Predicted amplicon length for a primer pair. pub fn primer3_pair_amplicon_length( fwd : Primer3Result, - rev : Primer3Result + rev : Primer3Result, ) -> Int { primer3_amplicon_length(fwd.start(), fwd.length(), rev.start(), rev.length()) } @@ -658,55 +651,16 @@ pub fn primer3_sample_template() -> String { // A 12-bp motif with ~50% GC, repeated to build a 600 bp template. // We use a mix of motifs to create variability. let motifs = [ - "ATGCGTACGTAG", - "CTAGCATCGATC", - "GATCGATCGATC", - "ATCGATCGATCG", - "CGTACGTACGTA", - "TACGTACGTACG", - "AGCTAGCTAGCT", - "GCGCGATATATA", - "ATATGCGCGCGC", - "TCTAGATCTAGA", - "GAGCTCGAGCTC", - "AATTGGCCAATT", - "TTAACCGGTTAA", - "GGCCAATTGGCC", - "AATTAATTGGCC", - "CGGCCGAATTCC", - "AAGCTTAAGCTT", - "TTCGAATTCGAA", - "GGATCCGGATCC", - "AAGATCTAGATC", - "CTAGAGATCTAG", - "GATCTCTAGATC", - "ATCGATCGATCG", - "GCTAGCTAGCTA", - "TACGTACGTACG", - "CATGCATGCATG", - "GTACGTACGTAC", - "AGCTAGCTAGCT", - "CGATCGATCGAT", - "TAGCTAGCTAGC", - "ATGcatgcATGC", - "GCATgcATGCAT", - "TTGGCCAATTGG", - "CCAATTGGCCAA", - "AATTGGCCAATT", - "GGCCAATTGGCC", - "AATTAATTGGCC", - "CGGCCGAATTCC", - "AAGCTTAAGCTT", - "TTCGAATTCGAA", - "GGATCCGGATCC", - "AAGATCTAGATC", - "CTAGAGATCTAG", - "GATCTCTAGATC", - "ATCGATCGATCG", - "GCTAGCTAGCTA", - "TACGTACGTACG", - "CATGCATGCATG", - "GTACGTACGTAC" + "ATGCGTACGTAG", "CTAGCATCGATC", "GATCGATCGATC", "ATCGATCGATCG", "CGTACGTACGTA", + "TACGTACGTACG", "AGCTAGCTAGCT", "GCGCGATATATA", "ATATGCGCGCGC", "TCTAGATCTAGA", + "GAGCTCGAGCTC", "AATTGGCCAATT", "TTAACCGGTTAA", "GGCCAATTGGCC", "AATTAATTGGCC", + "CGGCCGAATTCC", "AAGCTTAAGCTT", "TTCGAATTCGAA", "GGATCCGGATCC", "AAGATCTAGATC", + "CTAGAGATCTAG", "GATCTCTAGATC", "ATCGATCGATCG", "GCTAGCTAGCTA", "TACGTACGTACG", + "CATGCATGCATG", "GTACGTACGTAC", "AGCTAGCTAGCT", "CGATCGATCGAT", "TAGCTAGCTAGC", + "ATGcatgcATGC", "GCATgcATGCAT", "TTGGCCAATTGG", "CCAATTGGCCAA", "AATTGGCCAATT", + "GGCCAATTGGCC", "AATTAATTGGCC", "CGGCCGAATTCC", "AAGCTTAAGCTT", "TTCGAATTCGAA", + "GGATCCGGATCC", "AAGATCTAGATC", "CTAGAGATCTAG", "GATCTCTAGATC", "ATCGATCGATCG", + "GCTAGCTAGCTA", "TACGTACGTACG", "CATGCATGCATG", "GTACGTACGTAC", ] let mut out = "" for m in motifs { @@ -719,22 +673,10 @@ pub fn primer3_sample_template() -> String { /// A short sample template (~200 bp) for quick tests. pub fn primer3_short_template() -> String { let motifs = [ - "ATGCGTACGTAG", - "CTAGCATCGATC", - "GATCGATCGATC", - "ATCGATCGATCG", - "CGTACGTACGTA", - "TACGTACGTACG", - "AGCTAGCTAGCT", - "GCGCGATATATA", - "ATATGCGCGCGC", - "TCTAGATCTAGA", - "GAGCTCGAGCTC", - "AATTGGCCAATT", - "TTAACCGGTTAA", - "GGCCAATTGGCC", - "AATTAATTGGCC", - "CGGCCGAATTCC" + "ATGCGTACGTAG", "CTAGCATCGATC", "GATCGATCGATC", "ATCGATCGATCG", "CGTACGTACGTA", + "TACGTACGTACG", "AGCTAGCTAGCT", "GCGCGATATATA", "ATATGCGCGCGC", "TCTAGATCTAGA", + "GAGCTCGAGCTC", "AATTGGCCAATT", "TTAACCGGTTAA", "GGCCAATTGGCC", "AATTAATTGGCC", + "CGGCCGAATTCC", ] let mut out = "" for m in motifs { @@ -762,8 +704,7 @@ pub fn primer3_design_summary(design : Primer3Design) -> String { } match design.best_pair() { Some((f, r)) => - s = s + - "Amplicon length: \{primer3_pair_amplicon_length(f, r)} bp\n" + s = s + "Amplicon length: \{primer3_pair_amplicon_length(f, r)} bp\n" None => s = s + "Amplicon length: (no pair)\n" } s diff --git a/src/prosite.mbt b/src/prosite.mbt index 8a0bec89..62f990d3 100644 --- a/src/prosite.mbt +++ b/src/prosite.mbt @@ -14,14 +14,18 @@ pub struct PrositePattern { } ///| -pub fn PrositePattern::new(accession : String, name : String, pattern : String) -> PrositePattern { +pub fn PrositePattern::new( + accession : String, + name : String, + pattern : String, +) -> PrositePattern { PrositePattern::{ accession, name, pattern, description: "", profile: "", - comments: "" + comments: "", } } @@ -36,14 +40,20 @@ pub struct PrositeMatch { } ///| -pub fn PrositeMatch::new(pattern_accession : String, pattern_name : String, start : Int, end : Int, matched_sequence : String) -> PrositeMatch { +pub fn PrositeMatch::new( + pattern_accession : String, + pattern_name : String, + start : Int, + end : Int, + matched_sequence : String, +) -> PrositeMatch { PrositeMatch::{ pattern_accession, pattern_name, start, end, matched_sequence, - score: 0.0 + score: 0.0, } } @@ -75,7 +85,7 @@ pub fn PrositeEntry::new(accession : String, name : String) -> PrositeEntry { created: "", modified: "", entries_with_motif: 0, - literature_references: Array::new() + literature_references: Array::new(), } } @@ -83,14 +93,15 @@ pub fn PrositeEntry::new(accession : String, name : String) -> PrositeEntry { pub fn prosite_pattern_to_regex(pattern : String) -> String { let mut regex = "" let mut i = 0 - + while i < pattern.length() { let c = pattern.unsafe_get(i).to_int() - + if c == '['.to_int() { regex = regex + "[" i = i + 1 - while i < pattern.length() && pattern.unsafe_get(i).to_int() != ']'.to_int() { + while i < pattern.length() && + pattern.unsafe_get(i).to_int() != ']'.to_int() { let pc = pattern.unsafe_get(i).to_int() if pc == '-'.to_int() { regex = regex + "-" @@ -107,7 +118,8 @@ pub fn prosite_pattern_to_regex(pattern : String) -> String { } else if c == '{'.to_int() { regex = regex + "[^" i = i + 1 - while i < pattern.length() && pattern.unsafe_get(i).to_int() != '}'.to_int() { + while i < pattern.length() && + pattern.unsafe_get(i).to_int() != '}'.to_int() { let cc = char_at(pattern, i) regex = regex + cc i = i + 1 @@ -119,7 +131,8 @@ pub fn prosite_pattern_to_regex(pattern : String) -> String { } else if c == '('.to_int() { let mut count = 0 i = i + 1 - while i < pattern.length() && pattern.unsafe_get(i).to_int() != ')'.to_int() { + while i < pattern.length() && + pattern.unsafe_get(i).to_int() != ')'.to_int() { let pc = pattern.unsafe_get(i).to_int() if pc >= '0'.to_int() && pc <= '9'.to_int() { count = count * 10 + (pc - '0'.to_int()) @@ -147,45 +160,51 @@ pub fn prosite_pattern_to_regex(pattern : String) -> String { i = i + 1 } } - + regex } ///| -pub fn prosite_search(pattern : String, sequence : String) -> Array[PrositeMatch] { +pub fn prosite_search( + pattern : String, + sequence : String, +) -> Array[PrositeMatch] { let matches : Array[PrositeMatch] = Array::new() - + if pattern.length() == 0 || sequence.length() == 0 { return matches } - + let normalized_seq = to_lowercase(sequence) let normalized_pattern = to_lowercase(pattern) let mut start_pos = 0 - + while start_pos <= normalized_seq.length() { let mut pattern_idx = 0 let mut seq_idx = start_pos let mut matched = true - - while seq_idx < normalized_seq.length() && pattern_idx < pattern.length() && matched { + + while seq_idx < normalized_seq.length() && + pattern_idx < pattern.length() && + matched { let p_char = normalized_pattern.unsafe_get(pattern_idx).to_int() - + if p_char == '['.to_int() { let mut in_bracket = true let mut bracket_content = "" pattern_idx = pattern_idx + 1 - + while pattern_idx < normalized_pattern.length() && in_bracket { let bc = normalized_pattern.unsafe_get(pattern_idx).to_int() if bc == ']'.to_int() { in_bracket = false } else { - bracket_content = bracket_content + char_at(normalized_pattern, pattern_idx) + bracket_content = bracket_content + + char_at(normalized_pattern, pattern_idx) } pattern_idx = pattern_idx + 1 } - + let s_char = char_at(normalized_seq, seq_idx) if contains(bracket_content, s_char) { seq_idx = seq_idx + 1 @@ -196,17 +215,18 @@ pub fn prosite_search(pattern : String, sequence : String) -> Array[PrositeMatch let mut in_brace = true let mut brace_content = "" pattern_idx = pattern_idx + 1 - + while pattern_idx < normalized_pattern.length() && in_brace { let bc = normalized_pattern.unsafe_get(pattern_idx).to_int() if bc == '}'.to_int() { in_brace = false } else { - brace_content = brace_content + char_at(normalized_pattern, pattern_idx) + brace_content = brace_content + + char_at(normalized_pattern, pattern_idx) } pattern_idx = pattern_idx + 1 } - + let s_char = char_at(normalized_seq, seq_idx) if !contains(brace_content, s_char) { seq_idx = seq_idx + 1 @@ -216,15 +236,18 @@ pub fn prosite_search(pattern : String, sequence : String) -> Array[PrositeMatch } else if p_char == '('.to_int() { let mut count_str = "" pattern_idx = pattern_idx + 1 - - while pattern_idx < normalized_pattern.length() && normalized_pattern.unsafe_get(pattern_idx).to_int() != ')'.to_int() { + + while pattern_idx < normalized_pattern.length() && + normalized_pattern.unsafe_get(pattern_idx).to_int() != + ')'.to_int() { count_str = count_str + char_at(normalized_pattern, pattern_idx) pattern_idx = pattern_idx + 1 } - if pattern_idx < normalized_pattern.length() && normalized_pattern.unsafe_get(pattern_idx).to_int() == ')'.to_int() { + if pattern_idx < normalized_pattern.length() && + normalized_pattern.unsafe_get(pattern_idx).to_int() == ')'.to_int() { pattern_idx = pattern_idx + 1 } - + let count = parse_int(count_str) seq_idx = seq_idx + count } else if p_char == '.'.to_int() || p_char == 'x'.to_int() { @@ -243,55 +266,87 @@ pub fn prosite_search(pattern : String, sequence : String) -> Array[PrositeMatch } } } - + if matched && pattern_idx == pattern.length() { - let matched_seq = substring(normalized_seq, start_pos, seq_idx - start_pos) - let ps_match = PrositeMatch::new("", "Custom pattern", start_pos + 1, seq_idx, matched_seq) + let matched_seq = substring( + normalized_seq, + start_pos, + seq_idx - start_pos, + ) + let ps_match = PrositeMatch::new( + "", + "Custom pattern", + start_pos + 1, + seq_idx, + matched_seq, + ) matches.push(ps_match) } - + start_pos = start_pos + 1 } - + matches } ///| -pub fn prosite_scan(sequence : String, patterns : Array[PrositePattern]) -> Array[PrositeMatch] { +pub fn prosite_scan( + sequence : String, + patterns : Array[PrositePattern], +) -> Array[PrositeMatch] { let all_matches : Array[PrositeMatch] = Array::new() - + for pattern in patterns { let matches = prosite_search(pattern.pattern, sequence) let mut i = 0 while i < matches.length() { let m = matches[i] - all_matches.push(PrositeMatch::new( - pattern.accession, - pattern.name, - m.start, - m.end, - m.matched_sequence - )) + all_matches.push( + PrositeMatch::new( + pattern.accession, + pattern.name, + m.start, + m.end, + m.matched_sequence, + ), + ) i = i + 1 } } - + all_matches } ///| pub fn prosite_get_pattern(accession : String) -> PrositePattern? { - let patterns = Map([ - ("PS00001", ("ATP/GTP-binding site motif", "[AG]-X(4)-G-K-[ST]")), - ("PS00002", ("cAMP- and cGMP-dependent protein kinase phosphorylation site", "[RK]-X-[ST]")), - ("PS00003", ("Protein kinase C phosphorylation site", "[ST]-X-[RK]")), - ("PS00004", ("Casein kinase II phosphorylation site", "[ST]-X(2)-[DE]")), - ("PS00005", ("Tyrosine kinase phosphorylation site", "[RK]-X(2)-[DE]-X(3)-Y")), - ("PS00006", ("N-myristoylation site", "G-X(2)-[AGCS]-X(2)-[STAGC]-[LIVMFYW]")), - ("PS00007", ("CAMP-dependent protein kinase phosphorylation site", "[RK]-X(2)-[ST]")), - ("PS00008", ("Amidation site", "[AG]-G-[RK]-R")) - ], capacity=8) - + let patterns = Map( + [ + ("PS00001", ("ATP/GTP-binding site motif", "[AG]-X(4)-G-K-[ST]")), + ( + "PS00002", + ( + "cAMP- and cGMP-dependent protein kinase phosphorylation site", "[RK]-X-[ST]", + ), + ), + ("PS00003", ("Protein kinase C phosphorylation site", "[ST]-X-[RK]")), + ("PS00004", ("Casein kinase II phosphorylation site", "[ST]-X(2)-[DE]")), + ( + "PS00005", + ("Tyrosine kinase phosphorylation site", "[RK]-X(2)-[DE]-X(3)-Y"), + ), + ( + "PS00006", + ("N-myristoylation site", "G-X(2)-[AGCS]-X(2)-[STAGC]-[LIVMFYW]"), + ), + ( + "PS00007", + ("CAMP-dependent protein kinase phosphorylation site", "[RK]-X(2)-[ST]"), + ), + ("PS00008", ("Amidation site", "[AG]-G-[RK]-R")), + ], + capacity=8, + ) + if patterns.contains(accession) { let info = patterns.get(accession).unwrap() Some(PrositePattern::new(accession, info.0, info.1)) @@ -301,43 +356,56 @@ pub fn prosite_get_pattern(accession : String) -> PrositePattern? { } ///| -pub fn prosite_calculate_score(match_ : PrositeMatch, pattern : PrositePattern) -> Double { +pub fn prosite_calculate_score( + match_ : PrositeMatch, + pattern : PrositePattern, +) -> Double { let mut score = 100.0 - + if match_.matched_sequence.length() < pattern.pattern.length() { score = score * 0.5 } - + let mut mismatches = 0 let mut i = 0 while i < match_.matched_sequence.length() && i < pattern.pattern.length() { let pc = char_at(pattern.pattern, i) let mc = char_at(match_.matched_sequence, i) - + if pc != mc && pattern.pattern.unsafe_get(i).to_int() != '.'.to_int() { mismatches = mismatches + 1 } i = i + 1 } - + score = score - mismatches.to_double() * 10.0 - - if score < 0.0 { 0.0 } else { score } + + if score < 0.0 { + 0.0 + } else { + score + } } ///| pub fn prosite_create_example_patterns() -> Array[PrositePattern] { let patterns : Array[PrositePattern] = Array::new() - - let ps1 = PrositePattern::new("PS00001", "ATP/GTP-binding site motif", "[AG]-X(4)-G-K-[ST]") + + let ps1 = PrositePattern::new( + "PS00001", "ATP/GTP-binding site motif", "[AG]-X(4)-G-K-[ST]", + ) patterns.push(ps1) - - let ps2 = PrositePattern::new("PS00003", "Protein kinase C phosphorylation site", "[ST]-X-[RK]") + + let ps2 = PrositePattern::new( + "PS00003", "Protein kinase C phosphorylation site", "[ST]-X-[RK]", + ) patterns.push(ps2) - - let ps3 = PrositePattern::new("PS00006", "N-myristoylation site", "G-X(2)-[AGCS]-X(2)-[STAGC]-[LIVMFYW]") + + let ps3 = PrositePattern::new( + "PS00006", "N-myristoylation site", "G-X(2)-[AGCS]-X(2)-[STAGC]-[LIVMFYW]", + ) patterns.push(ps3) - + patterns } @@ -355,6 +423,6 @@ pub fn prosite_create_example_entry() -> PrositeEntry { created: "15-NOV-1990", modified: "20-FEB-2002", entries_with_motif: 1234, - literature_references: ["PMID:12345678", "PMID:87654321"] + literature_references: ["PMID:12345678", "PMID:87654321"], } -} \ No newline at end of file +} diff --git a/src/prot_dao.mbt b/src/prot_dao.mbt index 34f3db77..97412eca 100644 --- a/src/prot_dao.mbt +++ b/src/prot_dao.mbt @@ -25,26 +25,26 @@ pub fn prot_dao_disorder_score(aa : UInt16) -> Double { let c = if aa >= 97 && aa <= 122 { aa - 32 } else { aa } match c { - 65 => 0.06 // 'A' - 67 => -0.02 // 'C' - 68 => 0.19 // 'D' - 69 => 0.74 // 'E' - 70 => -0.09 // 'F' - 71 => 0.16 // 'G' - 72 => -0.42 // 'H' - 73 => -0.48 // 'I' - 75 => 0.58 // 'K' - 76 => -0.03 // 'L' - 77 => -0.39 // 'M' - 78 => 0.03 // 'N' - 80 => 0.98 // 'P' - 81 => 0.31 // 'Q' - 82 => 0.41 // 'R' - 83 => 0.34 // 'S' - 84 => 0.59 // 'T' - 86 => -0.26 // 'V' - 87 => -0.19 // 'W' - 89 => -0.49 // 'Y' + 65 => 0.06 // 'A' + 67 => -0.02 // 'C' + 68 => 0.19 // 'D' + 69 => 0.74 // 'E' + 70 => -0.09 // 'F' + 71 => 0.16 // 'G' + 72 => -0.42 // 'H' + 73 => -0.48 // 'I' + 75 => 0.58 // 'K' + 76 => -0.03 // 'L' + 77 => -0.39 // 'M' + 78 => 0.03 // 'N' + 80 => 0.98 // 'P' + 81 => 0.31 // 'Q' + 82 => 0.41 // 'R' + 83 => 0.34 // 'S' + 84 => 0.59 // 'T' + 86 => -0.26 // 'V' + 87 => -0.19 // 'W' + 89 => -0.49 // 'Y' _ => 0.0 } } @@ -55,26 +55,26 @@ pub fn prot_dao_disorder_score(aa : UInt16) -> Double { pub fn prot_dao_energy_score(aa : UInt16) -> Double { let c = if aa >= 97 && aa <= 122 { aa - 32 } else { aa } match c { - 65 => 1.1471 // 'A' - 67 => 2.6497 // 'C' - 68 => 1.9748 // 'D' - 69 => 1.3577 // 'E' - 70 => 2.0289 // 'F' - 71 => 1.8218 // 'G' - 72 => -1.0930 // 'H' - 73 => 0.2643 // 'I' - 75 => 0.6636 // 'K' - 76 => 0.5035 // 'L' - 77 => 2.5789 // 'M' - 78 => 1.8929 // 'N' - 80 => 2.8110 // 'P' - 81 => 1.1740 // 'Q' - 82 => -0.3509 // 'R' - 83 => 2.3317 // 'S' - 84 => 0.7361 // 'T' - 86 => 0.2730 // 'V' - 87 => 1.5749 // 'W' - 89 => 1.6374 // 'Y' + 65 => 1.1471 // 'A' + 67 => 2.6497 // 'C' + 68 => 1.9748 // 'D' + 69 => 1.3577 // 'E' + 70 => 2.0289 // 'F' + 71 => 1.8218 // 'G' + 72 => -1.0930 // 'H' + 73 => 0.2643 // 'I' + 75 => 0.6636 // 'K' + 76 => 0.5035 // 'L' + 77 => 2.5789 // 'M' + 78 => 1.8929 // 'N' + 80 => 2.8110 // 'P' + 81 => 1.1740 // 'Q' + 82 => -0.3509 // 'R' + 83 => 2.3317 // 'S' + 84 => 0.7361 // 'T' + 86 => 0.2730 // 'V' + 87 => 1.5749 // 'W' + 89 => 1.6374 // 'Y' _ => 0.0 } } @@ -218,8 +218,12 @@ pub fn prot_dao_predict( residues[ci].disorder_score = smoothed[ci] residues[ci].is_disordered = smoothed[ci] > threshold_disordered residues[ci].is_disordered_long = smoothed[ci] > threshold_long - if residues[ci].is_disordered { n_disordered = n_disordered + 1 } - if residues[ci].is_disordered_long { n_disordered_long = n_disordered_long + 1 } + if residues[ci].is_disordered { + n_disordered = n_disordered + 1 + } + if residues[ci].is_disordered_long { + n_disordered_long = n_disordered_long + 1 + } ci = ci + 1 } @@ -239,7 +243,9 @@ pub fn prot_dao_predict( let s = smoothed[region_end] rs = rs + s count = count + 1 - if s > max_s { max_s = s } + if s > max_s { + max_s = s + } region_end = region_end + 1 } @@ -247,13 +253,15 @@ pub fn prot_dao_predict( let is_long = region_end - region_start >= 30 let type_ = if is_long { "long disordered" } else { "disordered" } - regions.push(DisorderRegion::new( - region_start + 1, - region_end, - avg_s, - max_s, - region_type=type_, - )) + regions.push( + DisorderRegion::new( + region_start + 1, + region_end, + avg_s, + max_s, + region_type=type_, + ), + ) ri = region_end } else { ri = ri + 1 @@ -303,7 +311,9 @@ pub fn DisorderResult::get_fraction_disordered(self : DisorderResult) -> Double ///| /// Get disordered regions. -pub fn DisorderResult::get_regions(self : DisorderResult) -> Array[DisorderRegion] { +pub fn DisorderResult::get_regions( + self : DisorderResult, +) -> Array[DisorderRegion] { self.regions.copy() } @@ -315,7 +325,9 @@ pub fn DisorderResult::get_n_regions(self : DisorderResult) -> Int { ///| /// Get the longest disordered region. -pub fn DisorderResult::get_longest_region(self : DisorderResult) -> DisorderRegion { +pub fn DisorderResult::get_longest_region( + self : DisorderResult, +) -> DisorderRegion { if self.regions.length() == 0 { return DisorderRegion::new(0, 0, 0.0, 0.0, region_type="none") } @@ -364,27 +376,49 @@ pub fn DisorderResult::summary(self : DisorderResult) -> String { let mut s = "Disorder Prediction Summary\n" s = s + "Method: " + self.method + "\n" s = s + "Sequence length: " + self.sequence.length().to_string() + "\n" - s = s + "Disordered residues: " + self.n_disordered.to_string() + " (" + self.fraction_disordered.to_string() + ")\n" - s = s + "Long disordered residues: " + self.n_disordered_long.to_string() + "\n" + s = s + + "Disordered residues: " + + self.n_disordered.to_string() + + " (" + + self.fraction_disordered.to_string() + + ")\n" + s = s + + "Long disordered residues: " + + self.n_disordered_long.to_string() + + "\n" s = s + "Disordered regions: " + self.regions.length().to_string() + "\n" - s = s + "Threshold (disordered): " + self.threshold_disordered.to_string() + "\n" + s = s + + "Threshold (disordered): " + + self.threshold_disordered.to_string() + + "\n" s = s + "Threshold (long): " + self.threshold_long.to_string() + "\n" s } ///| /// Format disorder result as ASCII visualization. -pub fn DisorderResult::to_ascii(self : DisorderResult, width? : Int = 80) -> String { +pub fn DisorderResult::to_ascii( + self : DisorderResult, + width? : Int = 80, +) -> String { let w = if width > 0 { width } else { 80 } let seq_len = self.sequence.length() - if seq_len == 0 { return "Empty sequence" } + if seq_len == 0 { + return "Empty sequence" + } // Create the score track let mut s = "Score: " let mut i = 0 while i < seq_len { let score = self.residues[i].disorder_score - let bar = if score > self.threshold_long { "##" } else if score > self.threshold_disordered { "##" } else { "--" } + let bar = if score > self.threshold_long { + "##" + } else if score > self.threshold_disordered { + "##" + } else { + "--" + } s = s + bar i = i + 1 } @@ -399,7 +433,11 @@ pub fn DisorderResult::to_ascii(self : DisorderResult, width? : Int = 80) -> Str if pos == 1 || pos % 10 == 0 { if pos > 1 { let spaces = " " - let take = if spaces.length() >= label_len { label_len } else { spaces.length() } + let take = if spaces.length() >= label_len { + label_len + } else { + spaces.length() + } ruler = ruler + spaces.substring(start=0, end=take) } ruler = ruler + label @@ -431,7 +469,20 @@ pub fn DisorderResult::to_ascii(self : DisorderResult, width? : Int = 80) -> Str let mut ri = 0 while ri < self.regions.length() { let reg = self.regions[ri] - s = s + " Region " + (ri + 1).to_string() + ": " + reg.start.to_string() + "-" + reg.end_.to_string() + " (length=" + reg.length.to_string() + ", avg_score=" + reg.avg_score.to_string() + ", type=" + reg.region_type + ")\n" + s = s + + " Region " + + (ri + 1).to_string() + + ": " + + reg.start.to_string() + + "-" + + reg.end_.to_string() + + " (length=" + + reg.length.to_string() + + ", avg_score=" + + reg.avg_score.to_string() + + ", type=" + + reg.region_type + + ")\n" ri = ri + 1 } @@ -447,11 +498,11 @@ pub fn DisorderResult::to_ascii(self : DisorderResult, width? : Int = 80) -> Str pub fn prot_dao_sample_sequence() -> String { // A protein with mixed ordered and disordered regions // N-terminal disordered region, central ordered region, C-terminal disordered - let n_term_disordered = "MSEGKSSGGSSSGRRSSSGGGSSGGKSGKSSGR" // disordered - let ordered_core = "PKEIVLDSNGSLEVVKNGKVVVESTGNKVVLTSGQE" // ordered - let linker = "SSSSSS" // disordered linker - let second_domain = "KLPNLVISGDAGHVVVDAESNGKIVLLPSN" // ordered - let c_term_disordered = "GSSGSSGSGGKSGSSGSGRGSSGGNSSGKSSG" // disordered + let n_term_disordered = "MSEGKSSGGSSSGRRSSSGGGSSGGKSGKSSGR" // disordered + let ordered_core = "PKEIVLDSNGSLEVVKNGKVVVESTGNKVVLTSGQE" // ordered + let linker = "SSSSSS" // disordered linker + let second_domain = "KLPNLVISGDAGHVVVDAESNGKIVLLPSN" // ordered + let c_term_disordered = "GSSGSSGSGGKSGSSGSGRGSSGGNSSGKSSG" // disordered n_term_disordered + ordered_core + linker + second_domain + c_term_disordered } diff --git a/src/protein_analysis.mbt b/src/protein_analysis.mbt index ea188e2e..0f176328 100644 --- a/src/protein_analysis.mbt +++ b/src/protein_analysis.mbt @@ -14,6 +14,7 @@ // Kyte-Doolittle Hydrophobicity Scale // ============================================================================ +///| fn protein_get_kd(c : Char) -> Double { match c { 'A' => 1.8 @@ -50,12 +51,14 @@ fn protein_get_kd(c : Char) -> Double { // - P_turn: probability of being in turn/coil // ============================================================================ +///| struct GorParams { pa : Double pb : Double pt : Double } +///| fn protein_get_gor(c : Char) -> GorParams { match c { 'A' => GorParams::{ pa: 1.42, pb: 0.83, pt: 0.66 } @@ -86,12 +89,14 @@ fn protein_get_gor(c : Char) -> GorParams { // TM Scale (transmembrane propensity) // ============================================================================ +///| struct TmParams { inside : Double outside : Double tm : Double } +///| fn protein_get_tm(c : Char) -> TmParams { match c { 'A' => TmParams::{ inside: 1.1, outside: 0.56, tm: 1.32 } @@ -122,6 +127,7 @@ fn protein_get_tm(c : Char) -> TmParams { // Shannon Entropy for Conservation // ============================================================================ +///| fn protein_shannon_entropy(freqs : Array[Double]) -> Double { let mut h = 0.0 let mut i = 0 @@ -139,10 +145,16 @@ fn protein_shannon_entropy(freqs : Array[Double]) -> Double { // Amino Acid Frequency at Position // ============================================================================ -fn protein_aa_frequency_at(alignment : Array[String], pos : Int) -> Array[Double] { +///| +fn protein_aa_frequency_at( + alignment : Array[String], + pos : Int, +) -> Array[Double] { let freqs : Array[Double] = Array::new() let n = alignment.length().to_double() - if n == 0.0 { return freqs } + if n == 0.0 { + return freqs + } let aa_map = Map([], capacity=26) let mut i = 0 while i < alignment.length() { @@ -181,7 +193,9 @@ fn protein_aa_frequency_at(alignment : Array[String], pos : Int) -> Array[Double /// Calculate per-position conservation score from a multiple sequence alignment. /// Returns scores from 0 (no conservation) to 1 (perfect conservation). pub fn protein_conservation(alignment : Array[String]) -> Array[Double] { - if alignment.length() == 0 { return [] } + if alignment.length() == 0 { + return [] + } let aln_len = alignment[0].length() let alphabet_size = 20.0 let conservation : Array[Double] = Array::new() @@ -199,11 +213,16 @@ pub fn protein_conservation(alignment : Array[String]) -> Array[Double] { ///| /// Calculate Kyte-Doolittle hydropathy values for a protein sequence. /// Returns array of hydropathy values averaged over a sliding window. -pub fn protein_hydropathy(sequence : String, window? : Int = 7) -> Array[Double] { +pub fn protein_hydropathy( + sequence : String, + window? : Int = 7, +) -> Array[Double] { let seq = sequence.to_upper() let w = if window <= 0 { 7 } else { window } let result : Array[Double] = Array::new() - if seq.length() < w { return result } + if seq.length() < w { + return result + } let mut i = 0 while i <= seq.length() - w { let mut sum = 0.0 @@ -285,11 +304,17 @@ pub fn protein_antigenicity(sequence : String) -> Array[Double] { ///| /// Predict transmembrane domains using the TM scale. /// Returns array of scores: positive = transmembrane, negative = inside/outside. -pub fn protein_transmembrane(sequence : String, window? : Int = 19, threshold? : Double = 1.6) -> Array[Double] { +pub fn protein_transmembrane( + sequence : String, + window? : Int = 19, + threshold? : Double = 1.6, +) -> Array[Double] { let seq = sequence.to_upper() let w = if window <= 0 { 19 } else { window } let result : Array[Double] = Array::new() - if seq.length() < w { return result } + if seq.length() < w { + return result + } let mut i = 0 while i <= seq.length() - w { let mut sum = 0.0 @@ -339,7 +364,9 @@ pub fn protein_dipeptide_composition(sequence : String) -> Map[String, Double] { let seq = sequence.to_upper() let n = (seq.length() - 1).to_double() let comp = Map([], capacity=400) - if seq.length() < 2 { return comp } + if seq.length() < 2 { + return comp + } let mut i = 0 while i < seq.length() - 1 { let di = seq[i:i + 2].to_owned() @@ -359,7 +386,9 @@ pub fn protein_tripeptide_composition(sequence : String) -> Map[String, Double] let seq = sequence.to_upper() let n = (seq.length() - 2).to_double() let comp = Map([], capacity=8000) - if seq.length() < 3 { return comp } + if seq.length() < 3 { + return comp + } let mut i = 0 while i < seq.length() - 2 { let tri = seq[i:i + 3].to_owned() @@ -388,9 +417,7 @@ pub fn protein_summary(sequence : String) -> String { sorted_keys.push(keys[ki]) ki = ki + 1 } - sorted_keys.sort_by(fn(a : Char, b : Char) -> Int { - a.to_int() - b.to_int() - }) + sorted_keys.sort_by(fn(a : Char, b : Char) -> Int { a.to_int() - b.to_int() }) out = out + "\nAmino Acid Composition:\n" let mut si = 0 while si < sorted_keys.length() { @@ -406,16 +433,25 @@ pub fn protein_summary(sequence : String) -> String { total_hydro = total_hydro + hydro[hi] hi = hi + 1 } - let avg_hydro = if hydro.length() > 0 { total_hydro / hydro.length().to_double() } else { 0.0 } + let avg_hydro = if hydro.length() > 0 { + total_hydro / hydro.length().to_double() + } else { + 0.0 + } out = out + "\nAverage Hydropathy (window=7): " + avg_hydro.to_string() + "\n" let tm = protein_transmembrane(seq, window=19) let mut has_tm = false let mut ti = 0 while ti < tm.length() { - if tm[ti] > 1.6 { has_tm = true } + if tm[ti] > 1.6 { + has_tm = true + } ti = ti + 1 } - out = out + "Transmembrane domain detected: " + (if has_tm { "Yes" } else { "No" }) + "\n" + out = out + + "Transmembrane domain detected: " + + (if has_tm { "Yes" } else { "No" }) + + "\n" let ss = protein_secondary_structure(seq) let mut h_count = 0 let mut e_count = 0 @@ -433,9 +469,21 @@ pub fn protein_summary(sequence : String) -> String { } let total = seq.length().to_double() out = out + "\nSecondary Structure Prediction (GOR):\n" - out = out + " Helix (H): " + (h_count.to_double() / total * 100.0).to_string() + "%\n" - out = out + " Sheet (E): " + (e_count.to_double() / total * 100.0).to_string() + "%\n" - out = out + " Turn (T): " + (t_count.to_double() / total * 100.0).to_string() + "%\n" - out = out + " Coil (C): " + (c_count.to_double() / total * 100.0).to_string() + "%\n" + out = out + + " Helix (H): " + + (h_count.to_double() / total * 100.0).to_string() + + "%\n" + out = out + + " Sheet (E): " + + (e_count.to_double() / total * 100.0).to_string() + + "%\n" + out = out + + " Turn (T): " + + (t_count.to_double() / total * 100.0).to_string() + + "%\n" + out = out + + " Coil (C): " + + (c_count.to_double() / total * 100.0).to_string() + + "%\n" out } diff --git a/src/proteomics.mbt b/src/proteomics.mbt index 80ded23b..e0bc3fdd 100644 --- a/src/proteomics.mbt +++ b/src/proteomics.mbt @@ -39,75 +39,86 @@ pub struct DigestResult { } ///| -let average_weights : Map[String, Double] = Map([ - ("A", 89.0935), - ("R", 174.2017), - ("N", 132.1184), - ("D", 133.1032), - ("C", 121.1590), - ("E", 147.1299), - ("Q", 146.1451), - ("G", 75.0669), - ("H", 155.1552), - ("I", 131.1736), - ("L", 131.1736), - ("K", 146.1882), - ("M", 149.2124), - ("F", 165.1900), - ("P", 115.1310), - ("S", 105.0930), - ("T", 119.1197), - ("W", 204.2262), - ("Y", 181.1894), - ("V", 117.1469), -], capacity=20) +let average_weights : Map[String, Double] = Map( + [ + ("A", 89.0935), + ("R", 174.2017), + ("N", 132.1184), + ("D", 133.1032), + ("C", 121.1590), + ("E", 147.1299), + ("Q", 146.1451), + ("G", 75.0669), + ("H", 155.1552), + ("I", 131.1736), + ("L", 131.1736), + ("K", 146.1882), + ("M", 149.2124), + ("F", 165.1900), + ("P", 115.1310), + ("S", 105.0930), + ("T", 119.1197), + ("W", 204.2262), + ("Y", 181.1894), + ("V", 117.1469), + ], + capacity=20, +) ///| -let monoisotopic_weights : Map[String, Double] = Map([ - ("A", 71.03711), - ("R", 156.10111), - ("N", 114.04293), - ("D", 115.02694), - ("C", 103.00919), - ("E", 129.04259), - ("Q", 128.05858), - ("G", 57.02146), - ("H", 137.05891), - ("I", 113.08406), - ("L", 113.08406), - ("K", 128.09496), - ("M", 131.04049), - ("F", 147.06841), - ("P", 97.05276), - ("S", 87.03203), - ("T", 101.04768), - ("W", 186.07931), - ("Y", 163.06333), - ("V", 99.06841), -], capacity=20) +let monoisotopic_weights : Map[String, Double] = Map( + [ + ("A", 71.03711), + ("R", 156.10111), + ("N", 114.04293), + ("D", 115.02694), + ("C", 103.00919), + ("E", 129.04259), + ("Q", 128.05858), + ("G", 57.02146), + ("H", 137.05891), + ("I", 113.08406), + ("L", 113.08406), + ("K", 128.09496), + ("M", 131.04049), + ("F", 147.06841), + ("P", 97.05276), + ("S", 87.03203), + ("T", 101.04768), + ("W", 186.07931), + ("Y", 163.06333), + ("V", 99.06841), + ], + capacity=20, +) ///| let water_mono : Double = 18.010565 + +///| let water_avg : Double = 18.01524 ///| let proton_mass : Double = 1.007276 ///| -let enzyme_data : Map[String, (String, Bool, String)] = Map([ - ("trypsin", ("KR", false, "P")), - ("chymotrypsin", ("FYWML", false, "P")), - ("chymotrypsin_high_specificity", ("FYW", false, "P")), - ("chymotrypsin_low_specificity", ("FYWML", false, "P")), - ("pepsin_ph2", ("FL", false, "")), - ("pepsin_ph1.3", ("FL", false, "")), - ("lysc", ("K", false, "P")), - ("argc", ("R", false, "P")), - ("cnbr", ("M", false, "")), - ("gluc", ("DE", false, "")), - ("aspn", ("D", true, "")), - ("aspn_nterm", ("D", true, "")), -], capacity=15) +let enzyme_data : Map[String, (String, Bool, String)] = Map( + [ + ("trypsin", ("KR", false, "P")), + ("chymotrypsin", ("FYWML", false, "P")), + ("chymotrypsin_high_specificity", ("FYW", false, "P")), + ("chymotrypsin_low_specificity", ("FYWML", false, "P")), + ("pepsin_ph2", ("FL", false, "")), + ("pepsin_ph1.3", ("FL", false, "")), + ("lysc", ("K", false, "P")), + ("argc", ("R", false, "P")), + ("cnbr", ("M", false, "")), + ("gluc", ("DE", false, "")), + ("aspn", ("D", true, "")), + ("aspn_nterm", ("D", true, "")), + ], + capacity=15, +) ///| pub fn proteomics_select_enzyme(name : String) -> CleavageAgent? { @@ -118,17 +129,10 @@ pub fn proteomics_select_enzyme(name : String) -> CleavageAgent? { let mut i = 0 while i < residues.length() { let r = residues[i:i + 1].to_owned() - sites.push(CleavageSite::{ - position: 0, - residue: r, - probability: 1.0, - }) + sites.push(CleavageSite::{ position: 0, residue: r, probability: 1.0 }) i = i + 1 } - Some(CleavageAgent::{ - name: key, - cleavage_sites: sites, - }) + Some(CleavageAgent::{ name: key, cleavage_sites: sites }) } None => None } @@ -163,13 +167,11 @@ pub fn proteomics_cleavage_sites( sites.push(i) } } - } else { - if i < seq.length() - 1 { - let next = seq[i + 1:i + 2].to_owned() - let is_except = proteomics_contains_char(except, next) - if !is_except { - sites.push(i + 1) - } + } else if i < seq.length() - 1 { + let next = seq[i + 1:i + 2].to_owned() + let is_except = proteomics_contains_char(except, next) + if !is_except { + sites.push(i + 1) } } } @@ -183,7 +185,10 @@ pub fn proteomics_cleavage_sites( } ///| -pub fn proteomics_digest(protein_sequence : String, enzyme : String) -> DigestResult { +pub fn proteomics_digest( + protein_sequence : String, + enzyme : String, +) -> DigestResult { let seq = protein_sequence.to_upper() let sites = proteomics_cleavage_sites(seq, enzyme) @@ -282,8 +287,10 @@ pub fn proteomics_trypsin_digest( let n_peptides = starts.length() let max_missed = if missed_cleavages < n_peptides - 1 { missed_cleavages + } else if n_peptides > 1 { + n_peptides - 1 } else { - if n_peptides > 1 { n_peptides - 1 } else { 0 } + 0 } let mut mc = 1 @@ -317,7 +324,10 @@ pub fn proteomics_trypsin_digest( } ///| -pub fn proteomics_calculate_mass(peptide : String, is_monoisotopic : Bool) -> Double { +pub fn proteomics_calculate_mass( + peptide : String, + is_monoisotopic : Bool, +) -> Double { let seq = peptide.to_upper() if seq.length() == 0 { return 0.0 @@ -351,11 +361,22 @@ pub fn proteomics_molecular_weight(peptide : String) -> Double { } ///| -pub fn proteomics_isotope_pattern(peptide : String, charge : Int) -> IsotopePattern { +pub fn proteomics_isotope_pattern( + peptide : String, + charge : Int, +) -> IsotopePattern { let seq = peptide.to_upper() let n = seq.length() - let num_peaks = if n < 5 { 3 } else { if n < 15 { 4 } else { if n < 30 { 5 } else { 6 } } } + let num_peaks = if n < 5 { + 3 + } else if n < 15 { + 4 + } else if n < 30 { + 5 + } else { + 6 + } let mono_mass = proteomics_calculate_mass(seq, true) let avg_mass = proteomics_calculate_mass(seq, false) @@ -363,13 +384,17 @@ pub fn proteomics_isotope_pattern(peptide : String, charge : Int) -> IsotopePatt let masses : Array[Double] = Array::new() let abundances : Array[Double] = Array::new() - let delta_mass = if n > 0 { (avg_mass - mono_mass) / n.to_double() } else { 1.0 } + let delta_mass = if n > 0 { + (avg_mass - mono_mass) / n.to_double() + } else { + 1.0 + } let mut i = 0 while i < num_peaks { - let mass = mono_mass + (delta_mass * i.to_double()) + let mass = mono_mass + delta_mass * i.to_double() let m = if charge > 0 { - (mass / charge.to_double()) + proton_mass + mass / charge.to_double() + proton_mass } else { mass } @@ -387,15 +412,14 @@ pub fn proteomics_isotope_pattern(peptide : String, charge : Int) -> IsotopePatt j = j + 1 } - IsotopePattern::{ - masses, - abundances: normalized, - charge, - } + IsotopePattern::{ masses, abundances: normalized, charge } } ///| -fn proteomics_isotope_abundance(peak_index : Int, peptide_length : Int) -> Double { +fn proteomics_isotope_abundance( + peak_index : Int, + peptide_length : Int, +) -> Double { if peptide_length <= 0 { return if peak_index == 0 { 1.0 } else { 0.0 } } @@ -403,7 +427,9 @@ fn proteomics_isotope_abundance(peak_index : Int, peptide_length : Int) -> Doubl let n = peptide_length.to_double() let lambda = n * 0.0107 - let log_p = -lambda + peak_index.to_double() * proteomics_log_approx(lambda) - proteomics_log_factorial(peak_index) + let log_p = -lambda + + peak_index.to_double() * proteomics_log_approx(lambda) - + proteomics_log_factorial(peak_index) if log_p < -50.0 { return 0.0 } @@ -412,7 +438,9 @@ fn proteomics_isotope_abundance(peak_index : Int, peptide_length : Int) -> Doubl ///| fn proteomics_log_factorial(n : Int) -> Double { - if n <= 1 { return 0.0 } + if n <= 1 { + return 0.0 + } let mut result = 0.0 let mut i = 2 while i <= n { @@ -448,7 +476,9 @@ fn proteomics_exp_approx(x : Double) -> Double { ///| fn proteomics_pow_approx(base : Double, exp : Int) -> Double { - if exp <= 0 { return 1.0 } + if exp <= 0 { + return 1.0 + } let mut result = 1.0 let mut b = base let mut e = exp @@ -487,8 +517,10 @@ pub fn proteomics_fragment_ions( let y_avg = proteomics_calculate_mass(y_seq, false) let b_z = if charge > 0 { charge } else { 1 } - let b_ion_mono = (b_mono + (b_z.to_double() - 1.0) * proton_mass) / b_z.to_double() - let b_ion_avg = (b_avg + (b_z.to_double() - 1.0) * proton_mass) / b_z.to_double() + let b_ion_mono = (b_mono + (b_z.to_double() - 1.0) * proton_mass) / + b_z.to_double() + let b_ion_avg = (b_avg + (b_z.to_double() - 1.0) * proton_mass) / + b_z.to_double() frags.push(PeptideMassResult::{ peptide_sequence: "b" + i.to_string(), @@ -498,8 +530,10 @@ pub fn proteomics_fragment_ions( end_position: i, }) - let y_ion_mono = (y_mono + (b_z.to_double() - 1.0) * proton_mass) / b_z.to_double() - let y_ion_avg = (y_avg + (b_z.to_double() - 1.0) * proton_mass) / b_z.to_double() + let y_ion_mono = (y_mono + (b_z.to_double() - 1.0) * proton_mass) / + b_z.to_double() + let y_ion_avg = (y_avg + (b_z.to_double() - 1.0) * proton_mass) / + b_z.to_double() frags.push(PeptideMassResult::{ peptide_sequence: "y" + (n - i).to_string(), @@ -562,4 +596,4 @@ fn proteomics_partition(arr : Array[Int], lo : Int, hi : Int) -> Int { arr[i + 1] = arr[hi] arr[hi] = tmp i + 1 -} \ No newline at end of file +} diff --git a/src/psea.mbt b/src/psea.mbt index 7367ac8c..af1b694e 100644 --- a/src/psea.mbt +++ b/src/psea.mbt @@ -57,7 +57,14 @@ pub struct PseaGeometry { ///| /// Create a new atom. -pub fn PseaAtom::new(res_name : String, res_num : Int, atom_name : String, x : Double, y : Double, z : Double) -> PseaAtom { +pub fn PseaAtom::new( + res_name : String, + res_num : Int, + atom_name : String, + x : Double, + y : Double, + z : Double, +) -> PseaAtom { PseaAtom::{ res_name, res_num, atom_name, x, y, z } } @@ -88,14 +95,25 @@ pub fn psea_bond_angle(a : PseaAtom, b : PseaAtom, c : PseaAtom) -> Double { } let cos_theta = dot / (ba_len * bc_len) // Clamp to avoid numerical issues - let cos_clamped = if cos_theta > 1.0 { 1.0 } else if cos_theta < -1.0 { -1.0 } else { cos_theta } + let cos_clamped = if cos_theta > 1.0 { + 1.0 + } else if cos_theta < -1.0 { + -1.0 + } else { + cos_theta + } // arccos in degrees psea_arccos_deg(cos_clamped) } ///| /// Compute the virtual dihedral angle (in degrees) formed by atoms a-b-c-d. -pub fn psea_dihedral_angle(a : PseaAtom, b : PseaAtom, c : PseaAtom, d : PseaAtom) -> Double { +pub fn psea_dihedral_angle( + a : PseaAtom, + b : PseaAtom, + c : PseaAtom, + d : PseaAtom, +) -> Double { // Vectors b1 = b-a, b2 = c-b, b3 = d-c let b1_x = b.x - a.x let b1_y = b.y - a.y @@ -122,7 +140,13 @@ pub fn psea_dihedral_angle(a : PseaAtom, b : PseaAtom, c : PseaAtom, d : PseaAto } let dot = n1_x * n2_x + n1_y * n2_y + n1_z * n2_z let cos_val = dot / (n1_len * n2_len) - let cos_clamped = if cos_val > 1.0 { 1.0 } else if cos_val < -1.0 { -1.0 } else { cos_val } + let cos_clamped = if cos_val > 1.0 { + 1.0 + } else if cos_val < -1.0 { + -1.0 + } else { + cos_val + } let mut angle = psea_arccos_deg(cos_clamped) // Sign of the dihedral: (n1 x n2) . b2 let sign_vec_x = n1_y * n2_z - n1_z * n2_y @@ -166,13 +190,22 @@ pub fn psea_compute_geometry(ca_atoms : Array[PseaAtom]) -> PseaGeometry { // Bond angles (a-b-c) let mut j = 2 while j < n { - bond_angles.push(psea_bond_angle(ca_atoms[j - 2], ca_atoms[j - 1], ca_atoms[j])) + bond_angles.push( + psea_bond_angle(ca_atoms[j - 2], ca_atoms[j - 1], ca_atoms[j]), + ) j = j + 1 } // Dihedral angles (a-b-c-d) let mut k = 3 while k < n { - dihedral_angles.push(psea_dihedral_angle(ca_atoms[k - 3], ca_atoms[k - 2], ca_atoms[k - 1], ca_atoms[k])) + dihedral_angles.push( + psea_dihedral_angle( + ca_atoms[k - 3], + ca_atoms[k - 2], + ca_atoms[k - 1], + ca_atoms[k], + ), + ) k = k + 1 } PseaGeometry::{ ca_distances, bond_angles, dihedral_angles } @@ -216,7 +249,7 @@ pub fn psea_run(ca_atoms : Array[PseaAtom]) -> PseaResult { confidence, n_helix: 0, n_strand: 0, - n_coil: n + n_coil: n, } } let geom = psea_compute_geometry(ca_atoms) @@ -236,13 +269,25 @@ pub fn psea_run(ca_atoms : Array[PseaAtom]) -> PseaResult { let angle = geom.dihedral_angles[di] let res_idx = di + 1 // Alpha helix: dihedral around -57 to -70 (centered at -60) - let helix_dist = (angle - (-60.0)).abs() - let helix_score = if helix_dist < 30.0 { 1.0 - helix_dist / 30.0 } else { 0.0 } + let helix_dist = (angle - -60.0).abs() + let helix_score = if helix_dist < 30.0 { + 1.0 - helix_dist / 30.0 + } else { + 0.0 + } // Beta strand: dihedral around -120 or +120 - let strand_dist1 = (angle - (-120.0)).abs() + let strand_dist1 = (angle - -120.0).abs() let strand_dist2 = (angle - 120.0).abs() - let strand_dist = if strand_dist1 < strand_dist2 { strand_dist1 } else { strand_dist2 } - let strand_score = if strand_dist < 40.0 { 1.0 - strand_dist / 40.0 } else { 0.0 } + let strand_dist = if strand_dist1 < strand_dist2 { + strand_dist1 + } else { + strand_dist2 + } + let strand_score = if strand_dist < 40.0 { + 1.0 - strand_dist / 40.0 + } else { + 0.0 + } // Apply to residues in the window let mut ri = res_idx - 1 while ri <= res_idx + 1 && ri < n { @@ -304,7 +349,11 @@ pub fn psea_run(ca_atoms : Array[PseaAtom]) -> PseaResult { ///| /// Enforce minimum lengths for helix and strand segments. -fn psea_enforce_min_lengths(ss : Array[String], min_helix : Int, min_strand : Int) -> Unit { +fn psea_enforce_min_lengths( + ss : Array[String], + min_helix : Int, + min_strand : Int, +) -> Unit { let n = ss.length() let mut i = 0 while i < n { @@ -380,10 +429,17 @@ pub fn PseaResult::psea_get_res_name(self : PseaResult, idx : Int) -> String { ///| /// Summary statistics as a string. pub fn PseaResult::psea_summary(self : PseaResult) -> String { - "PSEA: " + self.psea_n_residues().to_string() + " residues, " + - "H=" + self.n_helix.to_string() + " " + - "E=" + self.n_strand.to_string() + " " + - "C=" + self.n_coil.to_string() + "PSEA: " + + self.psea_n_residues().to_string() + + " residues, " + + "H=" + + self.n_helix.to_string() + + " " + + "E=" + + self.n_strand.to_string() + + " " + + "C=" + + self.n_coil.to_string() } // ===== Three-state to eight-state conversion (DSSP-like) ===== @@ -408,13 +464,7 @@ pub fn psea_three_to_eight_state(ss : Array[String]) -> Array[String] { let len = j - i let mut k = i while k < j { - let state = if len <= 3 { - "G" - } else if len >= 12 { - "I" - } else { - "H" - } + let state = if len <= 3 { "G" } else if len >= 12 { "I" } else { "H" } result.push(state) k = k + 1 } @@ -436,7 +486,7 @@ pub fn psea_three_to_eight_state(ss : Array[String]) -> Array[String] { // Coil: try to distinguish T/S/L let prev = if i > 0 { ss[i - 1] } else { "C" } let next = if i + 1 < n { ss[i + 1] } else { "C" } - let state = if (prev == "H" || next == "H") && (prev != next) { + let state = if (prev == "H" || next == "H") && prev != next { "T" } else if prev == "E" || next == "E" { "T" @@ -459,7 +509,10 @@ pub fn psea_create_example_helix() -> Array[PseaAtom] { // Approximate alpha-helix CA coordinates: helix rise ~1.5 Å, radius ~2.3 Å // 100 degrees per residue (3.6 residues per turn) let atoms : Array[PseaAtom] = Array::new() - let names = ["ALA", "GLY", "VAL", "LEU", "SER", "THR", "PHE", "TRP", "TYR", "CYS", "MET", "ILE"] + let names = [ + "ALA", "GLY", "VAL", "LEU", "SER", "THR", "PHE", "TRP", "TYR", "CYS", "MET", + "ILE", + ] let mut i = 0 while i < 12 { let angle = i.to_double() * 100.0 * 3.141592653589793 / 180.0 diff --git a/src/qcp_superimposer.mbt b/src/qcp_superimposer.mbt index 84209e05..66925672 100644 --- a/src/qcp_superimposer.mbt +++ b/src/qcp_superimposer.mbt @@ -16,7 +16,11 @@ pub struct QCPAtomCoordinate { ///| /// Create a new QCPAtomCoordinate. -pub fn QCPAtomCoordinate::new(x : Double, y : Double, z : Double) -> QCPAtomCoordinate { +pub fn QCPAtomCoordinate::new( + x : Double, + y : Double, + z : Double, +) -> QCPAtomCoordinate { QCPAtomCoordinate::{ x, y, z } } @@ -28,7 +32,10 @@ pub fn QCPAtomCoordinate::to_array(self : QCPAtomCoordinate) -> Array[Double] { ///| /// Calculate distance between two atoms. -pub fn QCPAtomCoordinate::distance(self : QCPAtomCoordinate, other : QCPAtomCoordinate) -> Double { +pub fn QCPAtomCoordinate::distance( + self : QCPAtomCoordinate, + other : QCPAtomCoordinate, +) -> Double { let dx = self.x - other.x let dy = self.y - other.y let dz = self.z - other.z @@ -55,20 +62,29 @@ pub fn QCPSuperimposer::new() -> QCPSuperimposer { ///| /// Set the rotation matrix. -pub fn QCPSuperimposer::set_rot(self : QCPSuperimposer, rot : Array[Array[Double]]) -> QCPSuperimposer { - QCPSuperimposer::{ ..self, rot } +pub fn QCPSuperimposer::set_rot( + self : QCPSuperimposer, + rot : Array[Array[Double]], +) -> QCPSuperimposer { + QCPSuperimposer::{ ..self, rot, } } ///| /// Set the translation vector. -pub fn QCPSuperimposer::set_tran(self : QCPSuperimposer, tran : Array[Double]) -> QCPSuperimposer { - QCPSuperimposer::{ ..self, tran } +pub fn QCPSuperimposer::set_tran( + self : QCPSuperimposer, + tran : Array[Double], +) -> QCPSuperimposer { + QCPSuperimposer::{ ..self, tran, } } ///| /// Set the RMSD value. -pub fn QCPSuperimposer::set_rmsd(self : QCPSuperimposer, rmsd : Double) -> QCPSuperimposer { - QCPSuperimposer::{ ..self, rmsd } +pub fn QCPSuperimposer::set_rmsd( + self : QCPSuperimposer, + rmsd : Double, +) -> QCPSuperimposer { + QCPSuperimposer::{ ..self, rmsd, } } ///| @@ -91,39 +107,45 @@ pub fn QCPSuperimposer::get_rmsd(self : QCPSuperimposer) -> Double { ///| /// Calculate the centroid of a set of coordinates. -pub fn calculate_centroid(coords : Array[QCPAtomCoordinate]) -> QCPAtomCoordinate { +pub fn calculate_centroid( + coords : Array[QCPAtomCoordinate], +) -> QCPAtomCoordinate { if coords.length() == 0 { return QCPAtomCoordinate::new(0.0, 0.0, 0.0) } - + let mut sum_x = 0.0 let mut sum_y = 0.0 let mut sum_z = 0.0 - + for coord in coords { sum_x = sum_x + coord.x sum_y = sum_y + coord.y sum_z = sum_z + coord.z } - + let n = coords.length().to_double() QCPAtomCoordinate::new(sum_x / n, sum_y / n, sum_z / n) } ///| /// Center coordinates around centroid. -pub fn center_coordinates(coords : Array[QCPAtomCoordinate]) -> Array[QCPAtomCoordinate] { +pub fn center_coordinates( + coords : Array[QCPAtomCoordinate], +) -> Array[QCPAtomCoordinate] { let centroid = calculate_centroid(coords) - + let result : Array[QCPAtomCoordinate] = Array::new() for coord in coords { - result.push(QCPAtomCoordinate::new( - coord.x - centroid.x, - coord.y - centroid.y, - coord.z - centroid.z - )) + result.push( + QCPAtomCoordinate::new( + coord.x - centroid.x, + coord.y - centroid.y, + coord.z - centroid.z, + ), + ) } - + result } @@ -131,7 +153,7 @@ pub fn center_coordinates(coords : Array[QCPAtomCoordinate]) -> Array[QCPAtomCoo /// Build the correlation matrix. pub fn build_correlation_matrix( fixed : Array[QCPAtomCoordinate], - moving : Array[QCPAtomCoordinate] + moving : Array[QCPAtomCoordinate], ) -> Array[Array[Double]] { let mut c00 = 0.0 let mut c01 = 0.0 @@ -142,7 +164,7 @@ pub fn build_correlation_matrix( let mut c20 = 0.0 let mut c21 = 0.0 let mut c22 = 0.0 - + let len = fixed.length() let mut i = 0 while i < len { @@ -157,7 +179,7 @@ pub fn build_correlation_matrix( c22 = c22 + fixed[i].z * moving[i].z i = i + 1 } - + [[c00, c01, c02], [c10, c11, c12], [c20, c21, c22]] } @@ -183,54 +205,82 @@ pub fn build_qcp_matrix(c : Array[Array[Double]]) -> Array[Array[Double]] { let q01 = c[1][2] - c[2][1] let q02 = c[2][0] - c[0][2] let q03 = c[0][1] - c[1][0] - + let q10 = q01 let q11 = c[0][0] - c[1][1] - c[2][2] let q12 = c[0][1] + c[1][0] let q13 = c[0][2] + c[2][0] - + let q20 = q02 let q21 = q12 let q22 = -c[0][0] + c[1][1] - c[2][2] let q23 = c[1][2] + c[2][1] - + let q30 = q03 let q31 = q13 let q32 = q23 let q33 = -c[0][0] - c[1][1] + c[2][2] - - [[q00, q01, q02, q03], [q10, q11, q12, q13], [q20, q21, q22, q23], [q30, q31, q32, q33]] + + [ + [q00, q01, q02, q03], + [q10, q11, q12, q13], + [q20, q21, q22, q23], + [q30, q31, q32, q33], + ] } ///| /// Solve the quartic equation and find the maximum real root. pub fn solve_quartic(q : Array[Array[Double]]) -> Double { let a = -q[0][0] - q[1][1] - q[2][2] - q[3][3] - + let b1 = q[0][0] * q[1][1] + q[0][0] * q[2][2] + q[0][0] * q[3][3] let b2 = q[1][1] * q[2][2] + q[1][1] * q[3][3] + q[2][2] * q[3][3] let b3 = q[0][1] * q[1][0] + q[0][2] * q[2][0] + q[0][3] * q[3][0] let b4 = q[1][2] * q[2][1] + q[1][3] * q[3][1] + q[2][3] * q[3][2] let b = b1 + b2 - b3 - b4 - - let c1 = q[0][0] * q[1][1] * q[2][2] + q[0][0] * q[1][1] * q[3][3] + q[0][0] * q[2][2] * q[3][3] + q[1][1] * q[2][2] * q[3][3] - let c2 = q[0][0] * q[1][2] * q[2][1] + q[0][0] * q[1][3] * q[3][1] + q[0][0] * q[2][3] * q[3][2] - let c3 = q[1][1] * q[0][2] * q[2][0] + q[1][1] * q[0][3] * q[3][0] + q[1][1] * q[2][3] * q[3][2] - let c4 = q[2][2] * q[0][1] * q[1][0] + q[2][2] * q[0][3] * q[3][0] + q[2][2] * q[1][3] * q[3][1] - let c5 = q[3][3] * q[0][1] * q[1][0] + q[3][3] * q[0][2] * q[2][0] + q[3][3] * q[1][2] * q[2][1] - let c6 = q[0][1] * q[1][2] * q[2][0] + q[0][1] * q[1][3] * q[3][0] + q[0][2] * q[2][3] * q[3][0] - let c7 = q[1][2] * q[2][3] * q[3][1] + q[0][1] * q[2][1] * q[1][0] + q[0][2] * q[3][2] * q[2][0] + q[1][3] * q[3][1] * q[1][0] - let c = -(c1) + c2 + c3 + c4 + c5 - c6 - c7 - + + let c1 = q[0][0] * q[1][1] * q[2][2] + + q[0][0] * q[1][1] * q[3][3] + + q[0][0] * q[2][2] * q[3][3] + + q[1][1] * q[2][2] * q[3][3] + let c2 = q[0][0] * q[1][2] * q[2][1] + + q[0][0] * q[1][3] * q[3][1] + + q[0][0] * q[2][3] * q[3][2] + let c3 = q[1][1] * q[0][2] * q[2][0] + + q[1][1] * q[0][3] * q[3][0] + + q[1][1] * q[2][3] * q[3][2] + let c4 = q[2][2] * q[0][1] * q[1][0] + + q[2][2] * q[0][3] * q[3][0] + + q[2][2] * q[1][3] * q[3][1] + let c5 = q[3][3] * q[0][1] * q[1][0] + + q[3][3] * q[0][2] * q[2][0] + + q[3][3] * q[1][2] * q[2][1] + let c6 = q[0][1] * q[1][2] * q[2][0] + + q[0][1] * q[1][3] * q[3][0] + + q[0][2] * q[2][3] * q[3][0] + let c7 = q[1][2] * q[2][3] * q[3][1] + + q[0][1] * q[2][1] * q[1][0] + + q[0][2] * q[3][2] * q[2][0] + + q[1][3] * q[3][1] * q[1][0] + let c = -c1 + c2 + c3 + c4 + c5 - c6 - c7 + let d1 = q[0][0] * q[1][1] * q[2][2] * q[3][3] - let d2 = q[0][1] * q[1][2] * q[2][3] * q[3][0] + q[0][2] * q[1][3] * q[2][0] * q[3][1] + q[0][3] * q[1][0] * q[2][1] * q[3][2] - let d3 = q[0][3] * q[1][2] * q[2][1] * q[3][0] + q[0][2] * q[1][1] * q[2][3] * q[3][0] + q[0][1] * q[1][3] * q[2][0] * q[3][1] - let d4 = q[0][0] * q[1][2] * q[2][3] * q[3][1] + q[0][3] * q[1][1] * q[2][0] * q[3][2] + q[0][2] * q[1][0] * q[2][1] * q[3][2] - let d5 = q[0][1] * q[1][0] * q[2][3] * q[3][2] + q[0][0] * q[1][3] * q[2][1] * q[3][2] + let d2 = q[0][1] * q[1][2] * q[2][3] * q[3][0] + + q[0][2] * q[1][3] * q[2][0] * q[3][1] + + q[0][3] * q[1][0] * q[2][1] * q[3][2] + let d3 = q[0][3] * q[1][2] * q[2][1] * q[3][0] + + q[0][2] * q[1][1] * q[2][3] * q[3][0] + + q[0][1] * q[1][3] * q[2][0] * q[3][1] + let d4 = q[0][0] * q[1][2] * q[2][3] * q[3][1] + + q[0][3] * q[1][1] * q[2][0] * q[3][2] + + q[0][2] * q[1][0] * q[2][1] * q[3][2] + let d5 = q[0][1] * q[1][0] * q[2][3] * q[3][2] + + q[0][0] * q[1][3] * q[2][1] * q[3][2] let d = d1 + d2 - d3 - d4 - d5 - + let mut max_root = 0.0 - + for i in 0..<100 { let t = i.to_double() * 0.02 - 1.0 let val = t * t * t * t + a * t * t * t + b * t * t + c * t + d @@ -238,57 +288,60 @@ pub fn solve_quartic(q : Array[Array[Double]]) -> Double { max_root = t } } - + max_root } ///| /// Compute the eigenvector corresponding to the maximum eigenvalue. -pub fn compute_eigenvector(q : Array[Array[Double]], lambda : Double) -> Array[Double] { +pub fn compute_eigenvector( + q : Array[Array[Double]], + lambda : Double, +) -> Array[Double] { let m00 = q[0][0] - lambda let m01 = q[0][1] let m02 = q[0][2] let m03 = q[0][3] - + let m10 = q[1][0] let m11 = q[1][1] - lambda let m12 = q[1][2] let m13 = q[1][3] - + let m20 = q[2][0] let m21 = q[2][1] let m22 = q[2][2] - lambda let m23 = q[2][3] - + let m30 = q[3][0] let m31 = q[3][1] let m32 = q[3][2] let m33 = q[3][3] - lambda - + let mut v0 = 1.0 let mut v1 = 0.0 let mut v2 = 0.0 let mut v3 = 0.0 - + let mut iter = 0 while iter < 50 { let nv0 = m00 * v0 + m01 * v1 + m02 * v2 + m03 * v3 let nv1 = m10 * v0 + m11 * v1 + m12 * v2 + m13 * v3 let nv2 = m20 * v0 + m21 * v1 + m22 * v2 + m23 * v3 let nv3 = m30 * v0 + m31 * v1 + m32 * v2 + m33 * v3 - + let norm = (nv0 * nv0 + nv1 * nv1 + nv2 * nv2 + nv3 * nv3).sqrt() - + if norm > 0.000001 { v0 = nv0 / norm v1 = nv1 / norm v2 = nv2 / norm v3 = nv3 / norm } - + iter = iter + 1 } - + [v0, v1, v2, v3] } @@ -330,8 +383,7 @@ fn qcp_largest_eigenvector(q : Array[Array[Double]]) -> Array[Double] { } let diagonal_difference = matrix[pivot_column][pivot_column] - matrix[pivot_row][pivot_row] - let ratio = diagonal_difference / - (2.0 * matrix[pivot_row][pivot_column]) + let ratio = diagonal_difference / (2.0 * matrix[pivot_row][pivot_column]) let tangent = if ratio >= 0.0 { 1.0 / (ratio + (1.0 + ratio * ratio).sqrt()) } else { @@ -343,8 +395,7 @@ fn qcp_largest_eigenvector(q : Array[Array[Double]]) -> Array[Double] { let row_diagonal = matrix[pivot_row][pivot_row] let column_diagonal = matrix[pivot_column][pivot_column] matrix[pivot_row][pivot_row] = row_diagonal - tangent * pivot_value - matrix[pivot_column][pivot_column] = column_diagonal + - tangent * pivot_value + matrix[pivot_column][pivot_column] = column_diagonal + tangent * pivot_value matrix[pivot_row][pivot_column] = 0.0 matrix[pivot_column][pivot_row] = 0.0 let mut index = 0 @@ -362,8 +413,7 @@ fn qcp_largest_eigenvector(q : Array[Array[Double]]) -> Array[Double] { let vector_row = vectors[index][pivot_row] let vector_column = vectors[index][pivot_column] vectors[index][pivot_row] = cosine * vector_row - sine * vector_column - vectors[index][pivot_column] = sine * vector_row + - cosine * vector_column + vectors[index][pivot_column] = sine * vector_row + cosine * vector_column index = index + 1 } sweep = sweep + 1 @@ -391,7 +441,7 @@ pub fn quaternion_to_rotation(q : Array[Double]) -> Array[Array[Double]] { let x = q[1] let y = q[2] let z = q[3] - + let ww = w * w let xx = x * x let yy = y * y @@ -402,21 +452,21 @@ pub fn quaternion_to_rotation(q : Array[Double]) -> Array[Array[Double]] { let xy = x * y let xz = x * z let yz = y * z - + let rot = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] - + rot[0][0] = ww + xx - yy - zz rot[0][1] = 2.0 * (xy - wz) rot[0][2] = 2.0 * (xz + wy) - + rot[1][0] = 2.0 * (xy + wz) rot[1][1] = ww - xx + yy - zz rot[1][2] = 2.0 * (yz - wx) - + rot[2][0] = 2.0 * (xz - wy) rot[2][1] = 2.0 * (yz + wx) rot[2][2] = ww - xx - yy + zz - + rot } @@ -426,29 +476,29 @@ pub fn qcp_calculate_rmsd( fixed : Array[QCPAtomCoordinate], moving : Array[QCPAtomCoordinate], rot : Array[Array[Double]], - tran : Array[Double] + tran : Array[Double], ) -> Double { let mut sum_sq = 0.0 let len = fixed.length() - + let mut i = 0 while i < len { let mx = moving[i].x let my = moving[i].y let mz = moving[i].z - + let rx = rot[0][0] * mx + rot[0][1] * my + rot[0][2] * mz + tran[0] let ry = rot[1][0] * mx + rot[1][1] * my + rot[1][2] * mz + tran[1] let rz = rot[2][0] * mx + rot[2][1] * my + rot[2][2] * mz + tran[2] - + let dx = fixed[i].x - rx let dy = fixed[i].y - ry let dz = fixed[i].z - rz - + sum_sq = sum_sq + dx * dx + dy * dy + dz * dz i = i + 1 } - + (sum_sq / len.to_double()).sqrt() } @@ -456,69 +506,106 @@ pub fn qcp_calculate_rmsd( /// Set the coordinates for superposition. /// fixed: reference structure coordinates /// moving: structure to be aligned coordinates -pub fn QCPSuperimposer::set(self : QCPSuperimposer, fixed : Array[QCPAtomCoordinate], moving : Array[QCPAtomCoordinate]) -> QCPSuperimposer { +pub fn QCPSuperimposer::set( + self : QCPSuperimposer, + fixed : Array[QCPAtomCoordinate], + moving : Array[QCPAtomCoordinate], +) -> QCPSuperimposer { if fixed.length() != moving.length() { return self } - + if fixed.length() == 0 { return self.set_rmsd(0.0) } - + let fixed_centered = center_coordinates(fixed) let moving_centered = center_coordinates(moving) - + let centroid_fixed = calculate_centroid(fixed) let centroid_moving = calculate_centroid(moving) - + let c = build_correlation_matrix(moving_centered, fixed_centered) let q = build_qcp_matrix(c) let eigenvec = qcp_largest_eigenvector(q) - + let rot = quaternion_to_rotation(eigenvec) - - let t0 = rot[0][0] * centroid_moving.x + rot[0][1] * centroid_moving.y + rot[0][2] * centroid_moving.z - let t1 = rot[1][0] * centroid_moving.x + rot[1][1] * centroid_moving.y + rot[1][2] * centroid_moving.z - let t2 = rot[2][0] * centroid_moving.x + rot[2][1] * centroid_moving.y + rot[2][2] * centroid_moving.z - - let tran = [centroid_fixed.x - t0, centroid_fixed.y - t1, centroid_fixed.z - t2] - + + let t0 = rot[0][0] * centroid_moving.x + + rot[0][1] * centroid_moving.y + + rot[0][2] * centroid_moving.z + let t1 = rot[1][0] * centroid_moving.x + + rot[1][1] * centroid_moving.y + + rot[1][2] * centroid_moving.z + let t2 = rot[2][0] * centroid_moving.x + + rot[2][1] * centroid_moving.y + + rot[2][2] * centroid_moving.z + + let tran = [ + centroid_fixed.x - t0, + centroid_fixed.y - t1, + centroid_fixed.z - t2, + ] + let rmsd = qcp_calculate_rmsd(fixed, moving, rot, tran) - + QCPSuperimposer::{ rot, tran, rmsd } } ///| /// Apply rotation and translation to coordinates. -pub fn QCPSuperimposer::apply(self : QCPSuperimposer, coords : Array[QCPAtomCoordinate]) -> Array[QCPAtomCoordinate] { +pub fn QCPSuperimposer::apply( + self : QCPSuperimposer, + coords : Array[QCPAtomCoordinate], +) -> Array[QCPAtomCoordinate] { let result : Array[QCPAtomCoordinate] = Array::new() - + let mut i = 0 while i < coords.length() { let coord = coords[i] - let x = self.rot[0][0] * coord.x + self.rot[0][1] * coord.y + self.rot[0][2] * coord.z + self.tran[0] - let y = self.rot[1][0] * coord.x + self.rot[1][1] * coord.y + self.rot[1][2] * coord.z + self.tran[1] - let z = self.rot[2][0] * coord.x + self.rot[2][1] * coord.y + self.rot[2][2] * coord.z + self.tran[2] + let x = self.rot[0][0] * coord.x + + self.rot[0][1] * coord.y + + self.rot[0][2] * coord.z + + self.tran[0] + let y = self.rot[1][0] * coord.x + + self.rot[1][1] * coord.y + + self.rot[1][2] * coord.z + + self.tran[1] + let z = self.rot[2][0] * coord.x + + self.rot[2][1] * coord.y + + self.rot[2][2] * coord.z + + self.tran[2] result.push(QCPAtomCoordinate::new(x, y, z)) i = i + 1 } - + result } ///| /// Bio API functions. - -pub fn bio_qcp_superimpose(fixed : Array[QCPAtomCoordinate], moving : Array[QCPAtomCoordinate]) -> QCPSuperimposer { +pub fn bio_qcp_superimpose( + fixed : Array[QCPAtomCoordinate], + moving : Array[QCPAtomCoordinate], +) -> QCPSuperimposer { QCPSuperimposer::new().set(fixed, moving) } -pub fn bio_qcp_calculate_rmsd(fixed : Array[QCPAtomCoordinate], moving : Array[QCPAtomCoordinate]) -> Double { +///| +pub fn bio_qcp_calculate_rmsd( + fixed : Array[QCPAtomCoordinate], + moving : Array[QCPAtomCoordinate], +) -> Double { let superimposer = bio_qcp_superimpose(fixed, moving) superimposer.get_rmsd() } -pub fn bio_qcp_apply_transform(coords : Array[QCPAtomCoordinate], rot : Array[Array[Double]], tran : Array[Double]) -> Array[QCPAtomCoordinate] { +///| +pub fn bio_qcp_apply_transform( + coords : Array[QCPAtomCoordinate], + rot : Array[Array[Double]], + tran : Array[Double], +) -> Array[QCPAtomCoordinate] { let superimposer = QCPSuperimposer::new().set_rot(rot).set_tran(tran) superimposer.apply(coords) } diff --git a/src/qfeatures.mbt b/src/qfeatures.mbt index 0cba1fc5..ff7e786c 100644 --- a/src/qfeatures.mbt +++ b/src/qfeatures.mbt @@ -237,7 +237,9 @@ pub fn QfAssay::col_sums(self : QfAssay) -> Array[Double] { /// String representation of the assay. pub fn QfAssay::to_string(self : QfAssay) -> String { let buf = StringBuilder::new() - buf.write_string("QfAssay '\{self.name}': \{self.n_rows} rows x \{self.n_cols} cols") + buf.write_string( + "QfAssay '\{self.name}': \{self.n_rows} rows x \{self.n_cols} cols", + ) if self.n_rows > 0 && self.n_cols > 0 { buf.write_string("\n data[0][0] = \{self.data[0][0]}") } @@ -295,7 +297,10 @@ pub fn QfFeatureLinks::new() -> QfFeatureLinks { ///| /// Add a link to the collection. -pub fn QfFeatureLinks::add_link(self : QfFeatureLinks, link : QfFeatureLink) -> Unit { +pub fn QfFeatureLinks::add_link( + self : QfFeatureLinks, + link : QfFeatureLink, +) -> Unit { self.links.push(link) } @@ -344,11 +349,7 @@ pub fn QfFeatureLinks::get_links_to( ///| /// Construct an empty QFeatures. pub fn QFeatures::new() -> QFeatures { - QFeatures::{ - assays: Array::new(), - links: QfFeatureLinks::new(), - n_assays: 0, - } + QFeatures::{ assays: Array::new(), links: QfFeatureLinks::new(), n_assays: 0 } } ///| @@ -406,7 +407,9 @@ pub fn QFeatures::add_link( to_assay : String, to_row : Int, ) -> Unit { - self.links.add_link(QfFeatureLink::new(from_assay, from_row, to_assay, to_row)) + self.links.add_link( + QfFeatureLink::new(from_assay, from_row, to_assay, to_row), + ) } ///| @@ -437,10 +440,12 @@ pub fn qf_is_na(val : Double) -> Bool { val != val } +///| fn qf_infinity() -> Double { 1.7976931348623157e+308 } +///| /// Compute the median of an array (sorts a copy, does not modify input). fn qf_median(values : Array[Double]) -> Double { let n = values.length() @@ -452,7 +457,13 @@ fn qf_median(values : Array[Double]) -> Double { sorted.push(v) } sorted.sort_by(fn(a : Double, b : Double) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) let mid = n / 2 if n % 2 == 0 { @@ -462,6 +473,7 @@ fn qf_median(values : Array[Double]) -> Double { } } +///| /// Aggregate a list of values using the specified method (skipping NaN). fn qf_aggregate_values(values : Array[Double], method : String) -> Double { let clean : Array[Double] = Array::new() @@ -508,6 +520,7 @@ fn qf_aggregate_values(values : Array[Double], method : String) -> Double { } } +///| /// Euclidean distance between two rows on shared non-NaN columns. fn qf_row_distance(a : Array[Double], b : Array[Double]) -> Double { let n = a.length() @@ -527,6 +540,7 @@ fn qf_row_distance(a : Array[Double], b : Array[Double]) -> Double { } } +///| /// Deep-copy a data matrix. fn qf_copy_matrix(data : Array[Array[Double]]) -> Array[Array[Double]] { let nr = data.length() @@ -822,12 +836,9 @@ pub fn qf_filter_features( } } if keep_link { - new_links.add_link(QfFeatureLink::new( - l.from_assay, - new_from_row, - l.to_assay, - new_to_row, - )) + new_links.add_link( + QfFeatureLink::new(l.from_assay, new_from_row, l.to_assay, new_to_row), + ) } } QFeatures::{ @@ -901,11 +912,7 @@ pub fn qf_filter_na( na_count = na_count + 1 } } - let frac = if nc > 0 { - na_count.to_double() / nc.to_double() - } else { - 0.0 - } + let frac = if nc > 0 { na_count.to_double() / nc.to_double() } else { 0.0 } if frac <= max_na_frac { keep_rows.push(i) } @@ -961,7 +968,13 @@ pub fn qf_normalize_quantiles(assay : QfAssay) -> QfAssay { for j in 0.. Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) sorted_cols.push(col) } @@ -986,7 +999,13 @@ pub fn qf_normalize_quantiles(assay : QfAssay) -> QfAssay { pairs.push((i, assay.data[i][j])) } pairs.sort_by(fn(a : (Int, Double), b : (Int, Double)) -> Int { - if a.1 < b.1 { -1 } else if a.1 > b.1 { 1 } else { 0 } + if a.1 < b.1 { + -1 + } else if a.1 > b.1 { + 1 + } else { + 0 + } }) for rank in 0.. 1 { - (ss / (c - 1).to_double()).sqrt() - } else { - 1.0 - } + let std = if c > 1 { (ss / (c - 1).to_double()).sqrt() } else { 1.0 } let denom = if scale && std > 0.0 { std } else { 1.0 } for i in 0.. QfAssay { } // Sort by distance (ascending). pairs.sort_by(fn(a : (Int, Double), b : (Int, Double)) -> Int { - if a.1 < b.1 { -1 } else if a.1 > b.1 { 1 } else { 0 } + if a.1 < b.1 { + -1 + } else if a.1 > b.1 { + 1 + } else { + 0 + } }) let actual_k = if k < pairs.length() { k } else { pairs.length() } // Impute each NaN position. @@ -1283,7 +1304,9 @@ pub fn qf_summary(qf : QFeatures) -> String { pub fn qf_assay_summary(assay : QfAssay) -> String { let buf = StringBuilder::new() buf.write_string("QfAssay Summary: '\{assay.name}'\n") - buf.write_string(" Dimensions: \{assay.n_rows} rows x \{assay.n_cols} cols\n") + buf.write_string( + " Dimensions: \{assay.n_rows} rows x \{assay.n_cols} cols\n", + ) // Collect non-NaN values for statistics. let all_vals : Array[Double] = Array::new() for i in 0.. QValueResult { - QValueResult::{ - p_values, - q_values, - pi0, - lambda, - gamma, - significance, - } + QValueResult::{ p_values, q_values, pi0, lambda, gamma, significance } } ///| @@ -173,10 +166,8 @@ fn _compute_pi0_for_lambda(p_values : Array[Double], lambda : Double) -> Double /// Grid: 0.05, 0.10, ..., 0.95 fn _choose_lambda(p_values : Array[Double]) -> Double { let lambdas = [ - 0.05, 0.10, 0.15, 0.20, 0.25, - 0.30, 0.35, 0.40, 0.45, 0.50, - 0.55, 0.60, 0.65, 0.70, 0.75, - 0.80, 0.85, 0.90, 0.95, + 0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.35, 0.40, 0.45, 0.50, 0.55, 0.60, 0.65, + 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, ] let n = p_values.length() if n == 0 { @@ -242,7 +233,11 @@ fn _compute_qvalues(p_values : Array[Double], pi0 : Double) -> Array[Double] { } if n == 1 { let q = p_values[0] * pi0 - if q > 1.0 { [1.0] } else { [q] } + if q > 1.0 { + [1.0] + } else { + [q] + } } else { let indexed : Array[Array[Double]] = Array::new() let mut i = 0 @@ -252,7 +247,13 @@ fn _compute_qvalues(p_values : Array[Double], pi0 : Double) -> Array[Double] { } indexed.sort_by(fn(a : Array[Double], b : Array[Double]) -> Int { - if a[0] < b[0] { -1 } else if a[0] > b[0] { 1 } else { 0 } + if a[0] < b[0] { + -1 + } else if a[0] > b[0] { + 1 + } else { + 0 + } }) let q_sorted : Array[Double] = Array::make(n, 1.0) @@ -283,7 +284,10 @@ fn _compute_qvalues(p_values : Array[Double], pi0 : Double) -> Array[Double] { ///| /// Compute significance boolean array from q-values at a given threshold. -fn _compute_significance(q_values : Array[Double], threshold : Double) -> Array[Bool] { +fn _compute_significance( + q_values : Array[Double], + threshold : Double, +) -> Array[Bool] { let n = q_values.length() let result : Array[Bool] = Array::make(n, false) let mut i = 0 @@ -471,4 +475,4 @@ pub fn qvalue_significance( threshold : Double, ) -> Array[Bool] { _compute_significance(result.q_values, threshold) -} \ No newline at end of file +} diff --git a/src/ragged_experiment.mbt b/src/ragged_experiment.mbt index 516e62c8..ba770792 100644 --- a/src/ragged_experiment.mbt +++ b/src/ragged_experiment.mbt @@ -27,22 +27,39 @@ pub enum MutationType { ///| /// Create a missense mutation type. -pub fn mutation_missense() -> MutationType { MutationType::Missense_Mutation } +pub fn mutation_missense() -> MutationType { + MutationType::Missense_Mutation +} + ///| /// Create a nonsense mutation type. -pub fn mutation_nonsense() -> MutationType { MutationType::Nonsense_Mutation } +pub fn mutation_nonsense() -> MutationType { + MutationType::Nonsense_Mutation +} + ///| /// Create a frameshift insertion mutation type. -pub fn mutation_fs_ins() -> MutationType { MutationType::Frame_Shift_Ins } +pub fn mutation_fs_ins() -> MutationType { + MutationType::Frame_Shift_Ins +} + ///| /// Create a frameshift deletion mutation type. -pub fn mutation_fs_del() -> MutationType { MutationType::Frame_Shift_Del } +pub fn mutation_fs_del() -> MutationType { + MutationType::Frame_Shift_Del +} + ///| /// Create a splice site mutation type. -pub fn mutation_splice_site() -> MutationType { MutationType::Splice_Site } +pub fn mutation_splice_site() -> MutationType { + MutationType::Splice_Site +} + ///| /// Create a silent mutation type. -pub fn mutation_silent() -> MutationType { MutationType::Silent_Mutation } +pub fn mutation_silent() -> MutationType { + MutationType::Silent_Mutation +} ///| /// Convert mutation type to string. @@ -132,13 +149,27 @@ pub fn MutationRecord::new( ///| /// Get the mutation ID (gene + chrom + pos + ref + alt). pub fn MutationRecord::mutation_id(self : MutationRecord) -> String { - self.gene_symbol + ":" + self.chrom + ":" + self.pos.to_string() + ":" + self.ref_allele + ">" + self.alt_allele + self.gene_symbol + + ":" + + self.chrom + + ":" + + self.pos.to_string() + + ":" + + self.ref_allele + + ">" + + self.alt_allele } ///| /// Get the mutation key for grouping. pub fn MutationRecord::mutation_key(self : MutationRecord) -> String { - self.chrom + ":" + self.pos.to_string() + ":" + self.ref_allele + ">" + self.alt_allele + self.chrom + + ":" + + self.pos.to_string() + + ":" + + self.ref_allele + + ">" + + self.alt_allele } ///| @@ -186,7 +217,9 @@ pub fn RaggedExperiment::new() -> RaggedExperiment { ///| /// Create a RaggedExperiment from mutation records. -pub fn RaggedExperiment::from_records(records~ : Array[MutationRecord]) -> RaggedExperiment { +pub fn RaggedExperiment::from_records( + records~ : Array[MutationRecord], +) -> RaggedExperiment { let exp = RaggedExperiment::new() let mut i = 0 while i < records.length() { @@ -199,7 +232,10 @@ pub fn RaggedExperiment::from_records(records~ : Array[MutationRecord]) -> Ragge ///| /// Add a mutation record to the experiment. -pub fn RaggedExperiment::add_record(self : RaggedExperiment, record : MutationRecord) -> Unit { +pub fn RaggedExperiment::add_record( + self : RaggedExperiment, + record : MutationRecord, +) -> Unit { let mut row_idx = -1 let mut i = 0 while i < self.rownames.length() { @@ -323,7 +359,9 @@ pub fn RaggedExperiment::get_records( ) -> Array[MutationRecord] { let ri = row_index(self, gene) let ci = col_index(self, sample) - if ri < 0 || ci < 0 { return Array::new() } + if ri < 0 || ci < 0 { + return Array::new() + } self.data[ri][ci] } @@ -334,7 +372,9 @@ pub fn RaggedExperiment::get_gene_records( gene~ : String, ) -> Array[MutationRecord] { let ri = row_index(self, gene) - if ri < 0 { return Array::new() } + if ri < 0 { + return Array::new() + } let result : Array[MutationRecord] = Array::new() let mut c = 0 while c < self.colnames.length() { @@ -356,7 +396,9 @@ pub fn RaggedExperiment::get_sample_records( sample~ : String, ) -> Array[MutationRecord] { let ci = col_index(self, sample) - if ci < 0 { return Array::new() } + if ci < 0 { + return Array::new() + } let result : Array[MutationRecord] = Array::new() let mut r = 0 while r < self.rownames.length() { @@ -373,7 +415,9 @@ pub fn RaggedExperiment::get_sample_records( ///| /// Get the mutation count matrix (genes x samples). -pub fn RaggedExperiment::get_count_matrix(self : RaggedExperiment) -> Array[Array[Int]] { +pub fn RaggedExperiment::get_count_matrix( + self : RaggedExperiment, +) -> Array[Array[Int]] { self.counts } @@ -405,7 +449,9 @@ pub fn RaggedExperiment::get_tmb_per_mb( ///| /// Summary statistics: number of genes mutated per sample. -pub fn RaggedExperiment::genes_mutated_per_sample(self : RaggedExperiment) -> Array[Int] { +pub fn RaggedExperiment::genes_mutated_per_sample( + self : RaggedExperiment, +) -> Array[Int] { let n_cols = self.colnames.length() let n_rows = self.rownames.length() let result : Array[Int] = Array::new() @@ -414,7 +460,9 @@ pub fn RaggedExperiment::genes_mutated_per_sample(self : RaggedExperiment) -> Ar let mut count = 0 let mut r = 0 while r < n_rows { - if self.data[r][c].length() > 0 { count = count + 1 } + if self.data[r][c].length() > 0 { + count = count + 1 + } r = r + 1 } result.push(count) @@ -437,7 +485,14 @@ pub fn RaggedExperiment::summary(self : RaggedExperiment) -> String { s = s + "\nPer-sample TMB and mutated genes:" + "\n" let mut i = 0 while i < n_cols { - s = s + " " + self.colnames[i] + ": TMB=" + tmb[i].to_string() + ", mutated_genes=" + genes_mutated[i].to_string() + "\n" + s = s + + " " + + self.colnames[i] + + ": TMB=" + + tmb[i].to_string() + + ", mutated_genes=" + + genes_mutated[i].to_string() + + "\n" i = i + 1 } s @@ -460,7 +515,10 @@ pub fn RaggedExperiment::filter_by_type( let mut keep = false let mut t = 0 while t < types.length() { - if recs[j].mutation_type == types[t] { keep = true; break } + if recs[j].mutation_type == types[t] { + keep = true + break + } t = t + 1 } if keep { @@ -488,7 +546,10 @@ pub fn RaggedExperiment::filter_by_genes( let mut keep = false let mut g = 0 while g < genes.length() { - if self.rownames[r] == genes[g] { keep = true; break } + if self.rownames[r] == genes[g] { + keep = true + break + } g = g + 1 } if keep { @@ -523,7 +584,10 @@ pub fn RaggedExperiment::filter_by_samples( let mut keep = false let mut s = 0 while s < samples.length() { - if self.colnames[c] == samples[s] { keep = true; break } + if self.colnames[c] == samples[s] { + keep = true + break + } s = s + 1 } if keep { @@ -548,34 +612,82 @@ pub fn ragged_sample_data() -> RaggedExperiment { let exp = RaggedExperiment::new() // Sample 1: TP53 missense, KRAS mutation - exp.add_record(MutationRecord::new( - sample_id="Sample1", gene_symbol="TP53", chrom="chr17", pos=7577121, ref_allele="C", alt_allele="T", - mutation_type=MutationType::Missense_Mutation, variant_allele_frequency=0.45, - )) - exp.add_record(MutationRecord::new( - sample_id="Sample1", gene_symbol="KRAS", chrom="chr12", pos=25398284, ref_allele="G", alt_allele="T", - mutation_type=MutationType::Missense_Mutation, variant_allele_frequency=0.32, - )) - exp.add_record(MutationRecord::new( - sample_id="Sample1", gene_symbol="MYC", chrom="chr8", pos=128748315, ref_allele="C", alt_allele="A", - mutation_type=MutationType::Nonsense_Mutation, variant_allele_frequency=0.28, - )) + exp.add_record( + MutationRecord::new( + sample_id="Sample1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + mutation_type=MutationType::Missense_Mutation, + variant_allele_frequency=0.45, + ), + ) + exp.add_record( + MutationRecord::new( + sample_id="Sample1", + gene_symbol="KRAS", + chrom="chr12", + pos=25398284, + ref_allele="G", + alt_allele="T", + mutation_type=MutationType::Missense_Mutation, + variant_allele_frequency=0.32, + ), + ) + exp.add_record( + MutationRecord::new( + sample_id="Sample1", + gene_symbol="MYC", + chrom="chr8", + pos=128748315, + ref_allele="C", + alt_allele="A", + mutation_type=MutationType::Nonsense_Mutation, + variant_allele_frequency=0.28, + ), + ) // Sample 2: TP53 frameshift, EGFR mutation - exp.add_record(MutationRecord::new( - sample_id="Sample2", gene_symbol="TP53", chrom="chr17", pos=7578456, ref_allele="AG", alt_allele="A", - mutation_type=MutationType::Frame_Shift_Del, variant_allele_frequency=0.52, - )) - exp.add_record(MutationRecord::new( - sample_id="Sample2", gene_symbol="EGFR", chrom="chr7", pos=55086714, ref_allele="G", alt_allele="A", - mutation_type=MutationType::Missense_Mutation, variant_allele_frequency=0.38, - )) + exp.add_record( + MutationRecord::new( + sample_id="Sample2", + gene_symbol="TP53", + chrom="chr17", + pos=7578456, + ref_allele="AG", + alt_allele="A", + mutation_type=MutationType::Frame_Shift_Del, + variant_allele_frequency=0.52, + ), + ) + exp.add_record( + MutationRecord::new( + sample_id="Sample2", + gene_symbol="EGFR", + chrom="chr7", + pos=55086714, + ref_allele="G", + alt_allele="A", + mutation_type=MutationType::Missense_Mutation, + variant_allele_frequency=0.38, + ), + ) // Sample 3: KRAS mutation only - exp.add_record(MutationRecord::new( - sample_id="Sample3", gene_symbol="KRAS", chrom="chr12", pos=25398284, ref_allele="G", alt_allele="C", - mutation_type=MutationType::Missense_Mutation, variant_allele_frequency=0.41, - )) + exp.add_record( + MutationRecord::new( + sample_id="Sample3", + gene_symbol="KRAS", + chrom="chr12", + pos=25398284, + ref_allele="G", + alt_allele="C", + mutation_type=MutationType::Missense_Mutation, + variant_allele_frequency=0.41, + ), + ) exp.recalculate() exp @@ -583,19 +695,25 @@ pub fn ragged_sample_data() -> RaggedExperiment { // --- Helper functions --- +///| fn row_index(exp : RaggedExperiment, gene : String) -> Int { let mut i = 0 while i < exp.rownames.length() { - if exp.rownames[i] == gene { return i } + if exp.rownames[i] == gene { + return i + } i = i + 1 } -1 } +///| fn col_index(exp : RaggedExperiment, sample : String) -> Int { let mut i = 0 while i < exp.colnames.length() { - if exp.colnames[i] == sample { return i } + if exp.colnames[i] == sample { + return i + } i = i + 1 } -1 diff --git a/src/reduced.mbt b/src/reduced.mbt index 53115a16..9eca5776 100644 --- a/src/reduced.mbt +++ b/src/reduced.mbt @@ -32,12 +32,7 @@ pub fn ReducedAlphabet::new( mapping : Map[String, String], groups : Array[String], ) -> ReducedAlphabet { - ReducedAlphabet::{ - name, - n_groups: groups.length(), - mapping, - groups, - } + ReducedAlphabet::{ name, n_groups: groups.length(), mapping, groups } } ///| @@ -54,14 +49,20 @@ pub fn ReducedAlphabet::get_n_groups(self : ReducedAlphabet) -> Int { ///| /// Get the reduced representation for an amino acid. -pub fn ReducedAlphabet::reduce_aa(self : ReducedAlphabet, aa : String) -> String { +pub fn ReducedAlphabet::reduce_aa( + self : ReducedAlphabet, + aa : String, +) -> String { let upper = aa.to_upper() self.mapping.get(upper).unwrap_or("X") } ///| /// Reduce a protein sequence to the reduced alphabet. -pub fn ReducedAlphabet::reduce_sequence(self : ReducedAlphabet, sequence : String) -> String { +pub fn ReducedAlphabet::reduce_sequence( + self : ReducedAlphabet, + sequence : String, +) -> String { let mut result = "".to_string() let n = sequence.length() let mut i = 0 @@ -123,7 +124,9 @@ pub fn rad_alphabet() -> ReducedAlphabet { mapping.set("R", "5") mapping.set("S", "5") mapping.set("T", "5") - let groups = ["(A,G)", "(C)", "(D,E,N,Q)", "(I,L,M,V)", "(F,Y,W)", "(H,K,R,S,T)"] + let groups = [ + "(A,G)", "(C)", "(D,E,N,Q)", "(I,L,M,V)", "(F,Y,W)", "(H,K,R,S,T)", + ] ReducedAlphabet::new("RAD", mapping, groups) } @@ -159,7 +162,9 @@ pub fn dayhoff_alphabet() -> ReducedAlphabet { mapping.set("H", "5") mapping.set("K", "5") mapping.set("R", "5") - let groups = ["(A,G,P,S,T)", "(C)", "(D,E,N,Q)", "(I,L,M,V)", "(F,W,Y)", "(H,K,R)"] + let groups = [ + "(A,G,P,S,T)", "(C)", "(D,E,N,Q)", "(I,L,M,V)", "(F,W,Y)", "(H,K,R)", + ] ReducedAlphabet::new("Dayhoff", mapping, groups) } @@ -226,8 +231,8 @@ pub fn sdm12_alphabet() -> ReducedAlphabet { mapping.set("Y", "5") // Tyr - polar (same as Gln) mapping.set("V", "9") // Val - hydrophobic (same as Ile) let groups = [ - "(A,M)", "(R)", "(N,S,T)", "(D)", "(C)", - "(Q,Y)", "(E)", "(G,P)", "(H)", "(I,V)", "(L,F,W)", "(K)", + "(A,M)", "(R)", "(N,S,T)", "(D)", "(C)", "(Q,Y)", "(E)", "(G,P)", "(H)", "(I,V)", + "(L,F,W)", "(K)", ] ReducedAlphabet::new("SDM12", mapping, groups) } @@ -263,7 +268,11 @@ pub fn reduced_identity( seq2 : String, alphabet : ReducedAlphabet, ) -> Double { - let n = if seq1.length() < seq2.length() { seq1.length() } else { seq2.length() } + let n = if seq1.length() < seq2.length() { + seq1.length() + } else { + seq2.length() + } if n == 0 { return 0.0 } diff --git a/src/reference.mbt b/src/reference.mbt index b21d6513..524812d4 100644 --- a/src/reference.mbt +++ b/src/reference.mbt @@ -80,7 +80,7 @@ pub fn BioReference::with_pubmed( year : String, pubmed_id : String, ) -> BioReference { - let r = BioReference::new(title=title, authors=authors, journal=journal, year=year) + let r = BioReference::new(title~, authors~, journal~, year~) r.pubmed_id_val = pubmed_id r } @@ -94,23 +94,62 @@ pub fn BioReference::with_doi( year : String, doi : String, ) -> BioReference { - let r = BioReference::new(title=title, authors=authors, journal=journal, year=year) + let r = BioReference::new(title~, authors~, journal~, year~) r.doi_val = doi r } -pub impl AbstractReference for BioReference with fn title(self : BioReference) -> String { self.title_val } -pub impl AbstractReference for BioReference with fn authors(self : BioReference) -> String { self.authors_val } -pub impl AbstractReference for BioReference with fn journal(self : BioReference) -> String { self.journal_val } -pub impl AbstractReference for BioReference with fn year(self : BioReference) -> String { self.year_val } -pub impl AbstractReference for BioReference with fn pubmed_id(self : BioReference) -> String { self.pubmed_id_val } -pub impl AbstractReference for BioReference with fn doi(self : BioReference) -> String { self.doi_val } -pub impl AbstractReference for BioReference with fn reference_type(self : BioReference) -> String { self.type_val } -pub impl AbstractReference for BioReference with fn citation(self : BioReference) -> String { +///| +pub impl AbstractReference for BioReference with fn title(self : BioReference) -> String { + self.title_val +} + +///| +pub impl AbstractReference for BioReference with fn authors(self : BioReference) -> String { + self.authors_val +} + +///| +pub impl AbstractReference for BioReference with fn journal(self : BioReference) -> String { + self.journal_val +} + +///| +pub impl AbstractReference for BioReference with fn year(self : BioReference) -> String { + self.year_val +} + +///| +pub impl AbstractReference for BioReference with fn pubmed_id( + self : BioReference, +) -> String { + self.pubmed_id_val +} + +///| +pub impl AbstractReference for BioReference with fn doi(self : BioReference) -> String { + self.doi_val +} + +///| +pub impl AbstractReference for BioReference with fn reference_type( + self : BioReference, +) -> String { + self.type_val +} + +///| +pub impl AbstractReference for BioReference with fn citation( + self : BioReference, +) -> String { let mut s = self.authors_val - if s.length() > 0 { s = s + ". " } + if s.length() > 0 { + s = s + ". " + } s = s + self.title_val - if s.length() > 0 { s = s + ". " } + if s.length() > 0 { + s = s + ". " + } s = s + self.journal_val if self.year_val.length() > 0 { s = s + " (" + self.year_val + ")" @@ -172,7 +211,11 @@ pub fn BioReference::set_type(self : BioReference, type_ : String) -> Unit { ///| /// Add a location (pair of start/end positions). -pub fn BioReference::add_location(self : BioReference, start : Int, end_ : Int) -> Unit { +pub fn BioReference::add_location( + self : BioReference, + start : Int, + end_ : Int, +) -> Unit { self.locations.push((start, end_)) } @@ -262,7 +305,10 @@ pub fn ReferenceList::get_all(self : ReferenceList) -> Array[BioReference] { ///| /// Get references by author name. -pub fn ReferenceList::by_author(self : ReferenceList, author : String) -> Array[BioReference] { +pub fn ReferenceList::by_author( + self : ReferenceList, + author : String, +) -> Array[BioReference] { let result : Array[BioReference] = Array::new() let mut i = 0 while i < self.refs.length() { @@ -276,7 +322,10 @@ pub fn ReferenceList::by_author(self : ReferenceList, author : String) -> Array[ ///| /// Get references by year. -pub fn ReferenceList::by_year(self : ReferenceList, year : String) -> Array[BioReference] { +pub fn ReferenceList::by_year( + self : ReferenceList, + year : String, +) -> Array[BioReference] { let result : Array[BioReference] = Array::new() let mut i = 0 while i < self.refs.length() { @@ -323,21 +372,15 @@ pub fn ReferenceList::bibliography(self : ReferenceList) -> String { pub fn reference_sample_data() -> ReferenceList { let list = ReferenceList::new() let ref1 = BioReference::with_pubmed( - "The Human Genome: A Complete Sequence", - "Nurk S, Koren S, Rhie A", - "Science", - "2022", - "36189102", + "The Human Genome: A Complete Sequence", "Nurk S, Koren S, Rhie A", "Science", + "2022", "36189102", ) ref1.add_location(1, 250000000) ref1.set_comment("Telomere-to-telomere assembly") list.add(ref1) let ref2 = BioReference::with_doi( - "CRISPR-Cas9 genome editing", - "Doudna JA, Charpentier E", - "Science", - "2014", + "CRISPR-Cas9 genome editing", "Doudna JA, Charpentier E", "Science", "2014", "10.1126/science.1258096", ) ref2.add_location(100, 5000) diff --git a/src/reporting_tools.mbt b/src/reporting_tools.mbt index 10eb2f9f..47c002e7 100644 --- a/src/reporting_tools.mbt +++ b/src/reporting_tools.mbt @@ -113,7 +113,10 @@ pub fn ReportDocument::new(title : String) -> ReportDocument { ///| /// Set author. -pub fn ReportDocument::set_author(doc : ReportDocument, author : String) -> ReportDocument { +pub fn ReportDocument::set_author( + doc : ReportDocument, + author : String, +) -> ReportDocument { ReportDocument::{ title: doc.title, author, @@ -126,7 +129,12 @@ pub fn ReportDocument::set_author(doc : ReportDocument, author : String) -> Repo ///| /// Add a text section to the report. -pub fn ReportDocument::add_text(doc : ReportDocument, id : String, title : String, content : String) -> ReportDocument { +pub fn ReportDocument::add_text( + doc : ReportDocument, + id : String, + title : String, + content : String, +) -> ReportDocument { let sections = doc.sections.copy() sections.push(ReportSection::{ section_id: id, @@ -148,7 +156,11 @@ pub fn ReportDocument::add_text(doc : ReportDocument, id : String, title : Strin ///| /// Add a table section to the report. -pub fn ReportDocument::add_table(doc : ReportDocument, id : String, table : ReportTable) -> ReportDocument { +pub fn ReportDocument::add_table( + doc : ReportDocument, + id : String, + table : ReportTable, +) -> ReportDocument { let sections = doc.sections.copy() let tables = doc.tables.copy() tables.push(table) @@ -172,7 +184,12 @@ pub fn ReportDocument::add_table(doc : ReportDocument, id : String, table : Repo ///| /// Add a plot section to the report. -pub fn ReportDocument::add_plot(doc : ReportDocument, id : String, title : String, plot_ascii : String) -> ReportDocument { +pub fn ReportDocument::add_plot( + doc : ReportDocument, + id : String, + title : String, + plot_ascii : String, +) -> ReportDocument { let sections = doc.sections.copy() sections.push(ReportSection::{ section_id: id, @@ -218,13 +235,23 @@ pub fn ReportDocument::get_n_tables(doc : ReportDocument) -> Int { ///| /// Create a new report column. -pub fn ReportColumn::new(name : String, values : Array[String], numeric : Bool) -> ReportColumn { +pub fn ReportColumn::new( + name : String, + values : Array[String], + numeric : Bool, +) -> ReportColumn { ReportColumn::{ name, values, numeric } } ///| /// Create a new report table from string arrays. -pub fn ReportTable::new(table_id : String, title : String, column_names : Array[String], column_data : Array[Array[String]], caption : String) -> ReportTable { +pub fn ReportTable::new( + table_id : String, + title : String, + column_names : Array[String], + column_data : Array[Array[String]], + caption : String, +) -> ReportTable { let columns : Array[ReportColumn] = Array::new() let n = column_names.length() let mut i = 0 @@ -241,7 +268,12 @@ pub fn ReportTable::new(table_id : String, title : String, column_names : Array[ ///| /// Create a report table from mixed columns. -pub fn ReportTable::from_columns(table_id : String, title : String, columns : Array[ReportColumn], caption : String) -> ReportTable { +pub fn ReportTable::from_columns( + table_id : String, + title : String, + columns : Array[ReportColumn], + caption : String, +) -> ReportTable { ReportTable::{ table_id, title, columns, caption } } @@ -260,7 +292,11 @@ pub fn ReportTable::get_column_names(table : ReportTable) -> Array[String] { ///| /// Get number of rows in a table. pub fn ReportTable::get_n_rows(table : ReportTable) -> Int { - if table.columns.length() == 0 { 0 } else { table.columns[0].values.length() } + if table.columns.length() == 0 { + 0 + } else { + table.columns[0].values.length() + } } ///| @@ -269,6 +305,7 @@ pub fn ReportTable::get_n_columns(table : ReportTable) -> Int { table.columns.length() } +///| fn rt_pad_right(s : String, width : Int) -> String { if s.length() >= width { s.substring(start=0, end=width).to_string() @@ -283,6 +320,7 @@ fn rt_pad_right(s : String, width : Int) -> String { } } +///| fn rt_repeat_char(c : String, n : Int) -> String { let mut result = "" let mut i = 0 @@ -351,7 +389,11 @@ pub fn ReportTable::to_ascii(table : ReportTable) -> String { while ri < n_rows { let mut ci2 = 0 while ci2 < n_cols { - let val = if ri < table.columns[ci2].values.length() { table.columns[ci2].values[ri] } else { "" } + let val = if ri < table.columns[ci2].values.length() { + table.columns[ci2].values[ri] + } else { + "" + } let padded = rt_pad_right(val, widths[ci2]) result = result + padded + " | " ci2 = ci2 + 1 @@ -365,7 +407,10 @@ pub fn ReportTable::to_ascii(table : ReportTable) -> String { ///| /// Get a report section by id. -pub fn ReportDocument::get_section(doc : ReportDocument, section_id : String) -> ReportSection { +pub fn ReportDocument::get_section( + doc : ReportDocument, + section_id : String, +) -> ReportSection { let mut i = 0 while i < doc.sections.length() { if doc.sections[i].section_id == section_id { @@ -398,11 +443,14 @@ pub fn ReportDocument::render(doc : ReportDocument) -> String { let mut i = 0 while i < doc.sections.length() { let sec = doc.sections[i] - result = result + "### " + sec.title + " (" + sec.section_type.to_string() + ") ###\n" + result = result + + "### " + + sec.title + + " (" + + sec.section_type.to_string() + + ") ###\n" match sec.section_type { - ReportSectionType::Text => { - result = result + sec.content + "\n" - } + ReportSectionType::Text => result = result + sec.content + "\n" ReportSectionType::Table => { // Find the corresponding table let mut j = 0 @@ -413,12 +461,8 @@ pub fn ReportDocument::render(doc : ReportDocument) -> String { j = j + 1 } } - ReportSectionType::Plot => { - result = result + sec.content + "\n" - } - _ => { - result = result + sec.content + "\n" - } + ReportSectionType::Plot => result = result + sec.content + "\n" + _ => result = result + sec.content + "\n" } result = result + "\n---\n\n" i = i + 1 @@ -443,4 +487,4 @@ pub fn ReportDocument::summary(doc : ReportDocument) -> String { } s = s + "Total table rows: " + total_rows.to_string() + "\n" s -} \ No newline at end of file +} diff --git a/src/residue_depth.mbt b/src/residue_depth.mbt index 3cdee10b..1290d004 100644 --- a/src/residue_depth.mbt +++ b/src/residue_depth.mbt @@ -74,7 +74,11 @@ pub struct RDAtom { ///| /// Create a new RDAtom. -pub fn RDAtom::new(name : String, coord : RDPoint3D, element : String) -> RDAtom { +pub fn RDAtom::new( + name : String, + coord : RDPoint3D, + element : String, +) -> RDAtom { RDAtom::{ name, coord, element } } @@ -88,7 +92,11 @@ pub struct RDResidue { ///| /// Create a new RDResidue. -pub fn RDResidue::new(resname : String, resseq : Int, atoms : Array[RDAtom]) -> RDResidue { +pub fn RDResidue::new( + resname : String, + resseq : Int, + atoms : Array[RDAtom], +) -> RDResidue { RDResidue::{ resname, resseq, atoms } } @@ -98,11 +106,11 @@ pub fn RDResidue::center_of_mass(self : RDResidue) -> RDPoint3D { if self.atoms.length() == 0 { return RDPoint3D::new(0.0, 0.0, 0.0) } - + let mut sum_x = 0.0 let mut sum_y = 0.0 let mut sum_z = 0.0 - + let mut i = 0 while i < self.atoms.length() { let atom = self.atoms[i] @@ -111,7 +119,7 @@ pub fn RDResidue::center_of_mass(self : RDResidue) -> RDPoint3D { sum_z = sum_z + atom.coord.z i = i + 1 } - + let n = self.atoms.length().to_double() RDPoint3D::new(sum_x / n, sum_y / n, sum_z / n) } @@ -149,94 +157,121 @@ pub fn RDResult::new( ca_depth : Double, com_depth : Double, ca_sasa : Double, - com_sasa : Double + com_sasa : Double, ) -> RDResult { RDResult::{ resseq, resname, ca_depth, com_depth, ca_sasa, com_sasa } } ///| /// Calculate the solvent-accessible surface area (SASA) using the rolling ball algorithm. -pub fn calculate_sasa(atom : RDAtom, all_atoms : Array[RDAtom], probe_radius : Double) -> Double { +pub fn calculate_sasa( + atom : RDAtom, + all_atoms : Array[RDAtom], + probe_radius : Double, +) -> Double { let atom_radius = get_atom_radius(atom.element) let total_radius = atom_radius + probe_radius - + let mut sasa = 0.0 let n_points = 92 - + let mut i = 0 while i < n_points { - let theta = (i.to_double() / n_points.to_double()) * 2.0 * 3.141592653589793 + let theta = i.to_double() / n_points.to_double() * 2.0 * 3.141592653589793 let mut j = 0 while j < n_points { - let phi = (j.to_double() / n_points.to_double()) * 3.141592653589793 - + let phi = j.to_double() / n_points.to_double() * 3.141592653589793 + let x = total_radius * @math.cos(theta) * @math.sin(phi) let y = total_radius * @math.sin(theta) * @math.sin(phi) let z = total_radius * @math.cos(phi) - - let test_point = RDPoint3D::new(atom.coord.x + x, atom.coord.y + y, atom.coord.z + z) - + + let test_point = RDPoint3D::new( + atom.coord.x + x, + atom.coord.y + y, + atom.coord.z + z, + ) + let mut is_accessible = true let mut k = 0 while k < all_atoms.length() { let other_atom = all_atoms[k] - if other_atom.name == atom.name && other_atom.coord.x == atom.coord.x && other_atom.coord.y == atom.coord.y && other_atom.coord.z == atom.coord.z { + if other_atom.name == atom.name && + other_atom.coord.x == atom.coord.x && + other_atom.coord.y == atom.coord.y && + other_atom.coord.z == atom.coord.z { k = k + 1 continue } - + let other_radius = get_atom_radius(other_atom.element) + probe_radius let dist = atom.coord.distance(other_atom.coord) - + if dist < other_radius + atom_radius { is_accessible = false break } k = k + 1 } - + if is_accessible { - let area_element = 4.0 * 3.141592653589793 * total_radius * total_radius / (n_points.to_double() * n_points.to_double()) + let area_element = 4.0 * + 3.141592653589793 * + total_radius * + total_radius / + (n_points.to_double() * n_points.to_double()) sasa = sasa + area_element } j = j + 1 } i = i + 1 } - + sasa } ///| /// Get the van der Waals radius for an atom element. pub fn get_atom_radius(element : String) -> Double { - if element == "H" || element == "h" { 1.20 } - else if element == "C" || element == "c" { 1.70 } - else if element == "N" || element == "n" { 1.55 } - else if element == "O" || element == "o" { 1.52 } - else if element == "S" || element == "s" { 1.80 } - else if element == "P" || element == "p" { 1.80 } - else { 1.50 } + if element == "H" || element == "h" { + 1.20 + } else if element == "C" || element == "c" { + 1.70 + } else if element == "N" || element == "n" { + 1.55 + } else if element == "O" || element == "o" { + 1.52 + } else if element == "S" || element == "s" { + 1.80 + } else if element == "P" || element == "p" { + 1.80 + } else { + 1.50 + } } ///| /// Calculate depth for a point using ray casting. -pub fn calculate_point_depth(point : RDPoint3D, all_atoms : Array[RDAtom], probe_radius : Double) -> Double { +pub fn calculate_point_depth( + point : RDPoint3D, + all_atoms : Array[RDAtom], + probe_radius : Double, +) -> Double { let mut min_distance = 10000.0 - + let mut i = 0 while i < all_atoms.length() { let atom = all_atoms[i] let atom_radius = get_atom_radius(atom.element) + probe_radius let dist = point.distance(atom.coord) - + let depth = dist - atom_radius if depth < min_distance { min_distance = depth } i = i + 1 } - + if min_distance < 0.0 { 0.0 } else { @@ -250,38 +285,45 @@ pub fn calculate_residue_depth( residue : RDResidue, all_residues : Array[RDResidue], probe_radius : Double, - grid_spacing : Double + grid_spacing : Double, ) -> RDResult { let all_atoms = collect_all_atoms(all_residues) - + let com = residue.center_of_mass() - + let ca_coord = match residue.get_ca() { Some(a) => a.coord None => com } - + let com_depth = calculate_point_depth(com, all_atoms, probe_radius) let ca_depth = calculate_point_depth(ca_coord, all_atoms, probe_radius) - + let ca_atom = match residue.get_ca() { Some(a) => a None => RDAtom::new("CA", ca_coord, "C") } - + let com_atom = RDAtom::new("COM", com, "C") - + let ca_sasa = calculate_sasa(ca_atom, all_atoms, probe_radius) let com_sasa = calculate_sasa(com_atom, all_atoms, probe_radius) - - RDResult::new(residue.resseq, residue.resname, ca_depth, com_depth, ca_sasa, com_sasa) + + RDResult::new( + residue.resseq, + residue.resname, + ca_depth, + com_depth, + ca_sasa, + com_sasa, + ) } ///| /// Calculate depth using grid-based approach (with defaults). pub fn calculate_residue_depth_default( residue : RDResidue, - all_residues : Array[RDResidue] + all_residues : Array[RDResidue], ) -> RDResult { calculate_residue_depth(residue, all_residues, 1.4, 0.5) } @@ -290,7 +332,7 @@ pub fn calculate_residue_depth_default( /// Collect all atoms from residues. pub fn collect_all_atoms(residues : Array[RDResidue]) -> Array[RDAtom] { let atoms : Array[RDAtom] = Array::new() - + let mut i = 0 while i < residues.length() { let residue = residues[i] @@ -301,7 +343,7 @@ pub fn collect_all_atoms(residues : Array[RDResidue]) -> Array[RDAtom] { } i = i + 1 } - + atoms } @@ -310,23 +352,30 @@ pub fn collect_all_atoms(residues : Array[RDResidue]) -> Array[RDAtom] { pub fn analyze_residue_depth( residues : Array[RDResidue], probe_radius : Double, - grid_spacing : Double + grid_spacing : Double, ) -> Array[RDResult] { let results : Array[RDResult] = Array::new() - + let mut i = 0 while i < residues.length() { - let result = calculate_residue_depth(residues[i], residues, probe_radius, grid_spacing) + let result = calculate_residue_depth( + residues[i], + residues, + probe_radius, + grid_spacing, + ) results.push(result) i = i + 1 } - + results } ///| /// Analyze all residues in a structure (with defaults). -pub fn analyze_residue_depth_default(residues : Array[RDResidue]) -> Array[RDResult] { +pub fn analyze_residue_depth_default( + residues : Array[RDResidue], +) -> Array[RDResult] { analyze_residue_depth(residues, 1.4, 0.5) } @@ -336,10 +385,10 @@ pub fn calculate_average_depth(results : Array[RDResult]) -> (Double, Double) { if results.length() == 0 { return (0.0, 0.0) } - + let mut sum_ca = 0.0 let mut sum_com = 0.0 - + let mut i = 0 while i < results.length() { let result = results[i] @@ -347,16 +396,19 @@ pub fn calculate_average_depth(results : Array[RDResult]) -> (Double, Double) { sum_com = sum_com + result.com_depth i = i + 1 } - + let n = results.length().to_double() (sum_ca / n, sum_com / n) } ///| /// Find surface residues (depth below threshold). -pub fn find_surface_residues(results : Array[RDResult], depth_threshold : Double) -> Array[RDResult] { +pub fn find_surface_residues( + results : Array[RDResult], + depth_threshold : Double, +) -> Array[RDResult] { let surface : Array[RDResult] = Array::new() - + let mut i = 0 while i < results.length() { let result = results[i] @@ -365,21 +417,26 @@ pub fn find_surface_residues(results : Array[RDResult], depth_threshold : Double } i = i + 1 } - + surface } ///| /// Find surface residues (with default threshold). -pub fn find_surface_residues_default(results : Array[RDResult]) -> Array[RDResult] { +pub fn find_surface_residues_default( + results : Array[RDResult], +) -> Array[RDResult] { find_surface_residues(results, 3.0) } ///| /// Find core residues (depth above threshold). -pub fn find_core_residues(results : Array[RDResult], depth_threshold : Double) -> Array[RDResult] { +pub fn find_core_residues( + results : Array[RDResult], + depth_threshold : Double, +) -> Array[RDResult] { let core : Array[RDResult] = Array::new() - + let mut i = 0 while i < results.length() { let result = results[i] @@ -388,7 +445,7 @@ pub fn find_core_residues(results : Array[RDResult], depth_threshold : Double) - } i = i + 1 } - + core } @@ -400,25 +457,39 @@ pub fn find_core_residues_default(results : Array[RDResult]) -> Array[RDResult] ///| /// Bio API functions. - -pub fn bio_residue_depth_analyze(residues : Array[RDResidue]) -> Array[RDResult] { +pub fn bio_residue_depth_analyze( + residues : Array[RDResidue], +) -> Array[RDResult] { analyze_residue_depth_default(residues) } -pub fn bio_residue_depth_calculate(residue : RDResidue, all_residues : Array[RDResidue]) -> RDResult { +///| +pub fn bio_residue_depth_calculate( + residue : RDResidue, + all_residues : Array[RDResidue], +) -> RDResult { calculate_residue_depth_default(residue, all_residues) } -pub fn bio_residue_depth_find_surface(residues : Array[RDResidue], threshold : Double) -> Array[RDResult] { +///| +pub fn bio_residue_depth_find_surface( + residues : Array[RDResidue], + threshold : Double, +) -> Array[RDResult] { let results = analyze_residue_depth_default(residues) find_surface_residues(results, threshold) } -pub fn bio_residue_depth_find_core(residues : Array[RDResidue], threshold : Double) -> Array[RDResult] { +///| +pub fn bio_residue_depth_find_core( + residues : Array[RDResidue], + threshold : Double, +) -> Array[RDResult] { let results = analyze_residue_depth_default(residues) find_core_residues(results, threshold) } +///| pub fn bio_residue_depth_average(results : Array[RDResult]) -> (Double, Double) { calculate_average_depth(results) -} \ No newline at end of file +} diff --git a/src/rhdf5.mbt b/src/rhdf5.mbt index 6cf910a6..21f982e6 100644 --- a/src/rhdf5.mbt +++ b/src/rhdf5.mbt @@ -11,7 +11,11 @@ pub struct HDF5Attribute { } ///| -pub fn HDF5Attribute::new(name : String, data_type : String, data : String) -> HDF5Attribute { +pub fn HDF5Attribute::new( + name : String, + data_type : String, + data : String, +) -> HDF5Attribute { HDF5Attribute::{ name, data_type, data } } @@ -25,13 +29,17 @@ pub struct HDF5Dataset { } ///| -pub fn HDF5Dataset::new(name : String, data_type : String, dimensions : Array[Int]) -> HDF5Dataset { +pub fn HDF5Dataset::new( + name : String, + data_type : String, + dimensions : Array[Int], +) -> HDF5Dataset { HDF5Dataset::{ name, data_type, dimensions, data: "", - attributes: Map([], capacity=0) + attributes: Map([], capacity=0), } } @@ -41,13 +49,16 @@ pub fn HDF5Dataset::set_data(self : HDF5Dataset, data : String) -> HDF5Dataset { name: self.name, data_type: self.data_type, dimensions: self.dimensions, - data: data, - attributes: self.attributes + data, + attributes: self.attributes, } } ///| -pub fn HDF5Dataset::add_attribute(self : HDF5Dataset, attr : HDF5Attribute) -> HDF5Dataset { +pub fn HDF5Dataset::add_attribute( + self : HDF5Dataset, + attr : HDF5Attribute, +) -> HDF5Dataset { let new_attrs = self.attributes new_attrs.set(attr.name, attr) HDF5Dataset::{ @@ -55,12 +66,15 @@ pub fn HDF5Dataset::add_attribute(self : HDF5Dataset, attr : HDF5Attribute) -> H data_type: self.data_type, dimensions: self.dimensions, data: self.data, - attributes: new_attrs + attributes: new_attrs, } } ///| -pub fn HDF5Dataset::get_attribute(self : HDF5Dataset, name : String) -> HDF5Attribute? { +pub fn HDF5Dataset::get_attribute( + self : HDF5Dataset, + name : String, +) -> HDF5Attribute? { if self.attributes.contains(name) { Some(self.attributes.get(name).unwrap()) } else { @@ -82,7 +96,7 @@ pub fn HDF5Group::new(name : String) -> HDF5Group { name, groups: Map([], capacity=0), datasets: Map([], capacity=0), - attributes: Map([], capacity=0) + attributes: Map([], capacity=0), } } @@ -113,11 +127,7 @@ pub struct HDF5File { ///| pub fn HDF5File::new(filename : String, mode : String) -> HDF5File { - HDF5File::{ - filename, - mode, - root: HDF5Group::new("/") - } + HDF5File::{ filename, mode, root: HDF5Group::new("/") } } ///| @@ -188,28 +198,32 @@ fn ensure_path(group : HDF5Group, parts : Array[String]) -> Unit { } ///| -pub fn HDF5File::write_dataset(self : HDF5File, path : String, dataset : HDF5Dataset) -> HDF5File { +pub fn HDF5File::write_dataset( + self : HDF5File, + path : String, + dataset : HDF5Dataset, +) -> HDF5File { let (group_parts, ds_name) = split_path_and_name(path) - + let _ = ensure_path(self.root, group_parts) - + let mut current = self.root let mut i = 0 while i < group_parts.length() { current = current.groups.get(group_parts[i]).unwrap() i = i + 1 } - + let new_ds = dataset.set_name(ds_name) current.datasets.set(ds_name, new_ds) - + self } ///| pub fn HDF5File::read_dataset(self : HDF5File, path : String) -> HDF5Dataset? { let (group_parts, ds_name) = split_path_and_name(path) - + let mut current = self.root let mut i = 0 while i < group_parts.length() { @@ -220,7 +234,7 @@ pub fn HDF5File::read_dataset(self : HDF5File, path : String) -> HDF5Dataset? { } i = i + 1 } - + if current.datasets.contains(ds_name) { Some(current.datasets.get(ds_name).unwrap()) } else { @@ -231,11 +245,11 @@ pub fn HDF5File::read_dataset(self : HDF5File, path : String) -> HDF5Dataset? { ///| pub fn HDF5Dataset::set_name(self : HDF5Dataset, name : String) -> HDF5Dataset { HDF5Dataset::{ - name: name, + name, data_type: self.data_type, dimensions: self.dimensions, data: self.data, - attributes: self.attributes + attributes: self.attributes, } } @@ -250,13 +264,24 @@ pub fn h5create_group(file : HDF5File, path : String) -> HDF5File { } ///| -pub fn h5create_dataset(file : HDF5File, path : String, data_type : String, dimensions : Array[Int]) -> HDF5File { +pub fn h5create_dataset( + file : HDF5File, + path : String, + data_type : String, + dimensions : Array[Int], +) -> HDF5File { let ds = HDF5Dataset::new("", data_type, dimensions) file.write_dataset(path, ds) } ///| -pub fn h5write_dataset(file : HDF5File, path : String, data : String, data_type : String, dimensions : Array[Int]) -> HDF5File { +pub fn h5write_dataset( + file : HDF5File, + path : String, + data : String, + data_type : String, + dimensions : Array[Int], +) -> HDF5File { let ds = HDF5Dataset::new("", data_type, dimensions) let ds_with_data = ds.set_data(data) file.write_dataset(path, ds_with_data) @@ -275,9 +300,13 @@ pub fn h5ls(file : HDF5File) -> Array[String] { } ///| -fn list_group(group : HDF5Group, prefix : String, result : Array[String]) -> Unit { +fn list_group( + group : HDF5Group, + prefix : String, + result : Array[String], +) -> Unit { let ds_entries = group.datasets.iter().collect() - + let mut i = 0 while i < ds_entries.length() { let (name, ds) = ds_entries[i] @@ -285,9 +314,9 @@ fn list_group(group : HDF5Group, prefix : String, result : Array[String]) -> Uni result.push(prefix + "/" + name + " [" + dims_str + "]") i = i + 1 } - + let grp_entries = group.groups.iter().collect() - + let mut j = 0 while j < grp_entries.length() { let (name, grp) = grp_entries[j] @@ -319,12 +348,24 @@ fn dimensions_to_string(dims : Array[Int]) -> String { pub fn h5create_example_file() -> HDF5File { let file = h5create_file("example.h5") let file2 = h5create_group(file, "data") - let file3 = h5create_dataset(file2, "/data/matrix", "H5T_NATIVE_DOUBLE", [100, 1000]) - let file4 = h5write_dataset(file3, "/data/matrix", "1.0,2.0,3.0", "H5T_NATIVE_DOUBLE", [3]) + let file3 = h5create_dataset(file2, "/data/matrix", "H5T_NATIVE_DOUBLE", [ + 100, 1000, + ]) + let file4 = h5write_dataset( + file3, + "/data/matrix", + "1.0,2.0,3.0", + "H5T_NATIVE_DOUBLE", + [3], + ) file4 } ///| -pub fn h5create_attribute(name : String, data_type : String, data : String) -> HDF5Attribute { +pub fn h5create_attribute( + name : String, + data_type : String, + data : String, +) -> HDF5Attribute { HDF5Attribute::new(name, data_type, data) } diff --git a/src/rna_structure.mbt b/src/rna_structure.mbt index a6ac6399..6811765f 100644 --- a/src/rna_structure.mbt +++ b/src/rna_structure.mbt @@ -84,12 +84,24 @@ pub fn rna_predictor_with_params( pub fn is_complementary(base1 : UInt16, base2 : UInt16) -> Bool { let b1 = rna_normalize_base(base1) let b2 = rna_normalize_base(base2) - if b1 == 65 && b2 == 85 { return true } - if b1 == 85 && b2 == 65 { return true } - if b1 == 71 && b2 == 67 { return true } - if b1 == 67 && b2 == 71 { return true } - if b1 == 71 && b2 == 85 { return true } - if b1 == 85 && b2 == 71 { return true } + if b1 == 65 && b2 == 85 { + return true + } + if b1 == 85 && b2 == 65 { + return true + } + if b1 == 71 && b2 == 67 { + return true + } + if b1 == 67 && b2 == 71 { + return true + } + if b1 == 71 && b2 == 85 { + return true + } + if b1 == 85 && b2 == 71 { + return true + } false } @@ -97,7 +109,9 @@ pub fn is_complementary(base1 : UInt16, base2 : UInt16) -> Bool { /// Calculate the loop energy penalty for a given loop length. /// Returns penalty = loop_penalty * length. pub fn compute_loop_energy(length : Int) -> Double { - if length <= 0 { return 0.0 } + if length <= 0 { + return 0.0 + } 0.5 * length.to_double() } @@ -112,7 +126,9 @@ pub fn nussinov_matrix( predictor : RNAStructurePredictor, ) -> Array[Array[Double]] { let n = sequence.length() - if n == 0 { return [] } + if n == 0 { + return [] + } let dp : Array[Array[Double]] = Array::new() for i = 0; i < n; i = i + 1 { @@ -146,7 +162,9 @@ pub fn nussinov_traceback( ) -> Array[(Int, Int)] { let n = sequence.length() let base_pairs : Array[(Int, Int)] = Array::new() - if n == 0 { return base_pairs } + if n == 0 { + return base_pairs + } rna_trace_from_matrix(matrix, sequence, predictor, 0, n - 1, base_pairs) @@ -243,12 +261,12 @@ pub fn identify_loop_regions( ) -> Array[LoopRegion] { let loop_regions : Array[LoopRegion] = Array::new() let n = sequence.length() - if n == 0 { return loop_regions } + if n == 0 { + return loop_regions + } let paired = rna_build_paired_array(n, base_pairs) - rna_find_loops_recursive( - sequence, base_pairs, 0, n - 1, paired, loop_regions, - ) + rna_find_loops_recursive(sequence, base_pairs, 0, n - 1, paired, loop_regions) loop_regions } @@ -273,7 +291,11 @@ pub fn mfe_to_dot_bracket( ///| /// Normalize a base to uppercase UInt16 code. fn rna_normalize_base(base : UInt16) -> UInt16 { - if base >= 97 && base <= 122 { base - 32 } else { base } + if base >= 97 && base <= 122 { + base - 32 + } else { + base + } } ///| @@ -294,10 +316,14 @@ fn rna_base_pair_energy( (nb1 == 71 && nb2 == 67) || (nb1 == 67 && nb2 == 71) - if is_watson_crick { return -1.0 } + if is_watson_crick { + return -1.0 + } let is_wobble = (nb1 == 71 && nb2 == 85) || (nb1 == 85 && nb2 == 71) - if is_wobble { return -0.5 } + if is_wobble { + return -0.5 + } predictor.mismatch_penalty } @@ -317,7 +343,11 @@ fn rna_compute_energy_for_interval( let unpaired_i = dp[i + 1][j] let unpaired_j = dp[i][j - 1] - let mut min_energy = if unpaired_i < unpaired_j { unpaired_i } else { unpaired_j } + let mut min_energy = if unpaired_i < unpaired_j { + unpaired_i + } else { + unpaired_j + } let loop_len = j - i - 1 if loop_len >= loop_min { @@ -344,7 +374,11 @@ fn rna_compute_energy_for_interval( ///| /// Absolute value helper for Double. fn rna_abs(x : Double) -> Double { - if x < 0.0 { -x } else { x } + if x < 0.0 { + -x + } else { + x + } } ///| @@ -357,7 +391,9 @@ fn rna_trace_from_matrix( j : Int, base_pairs : Array[(Int, Int)], ) -> Unit { - if i >= j { return } + if i >= j { + return + } let n = sequence.length() let loop_min = predictor.loop_min_length @@ -382,7 +418,12 @@ fn rna_trace_from_matrix( if rna_abs(paired_energy - current) < eps { base_pairs.push((i, j)) rna_trace_from_matrix( - matrix, sequence, predictor, i + 1, j - 1, base_pairs, + matrix, + sequence, + predictor, + i + 1, + j - 1, + base_pairs, ) return } @@ -393,9 +434,7 @@ fn rna_trace_from_matrix( let bifurcation_energy = matrix[i][k] + matrix[k + 1][j] if rna_abs(bifurcation_energy - current) < eps { rna_trace_from_matrix(matrix, sequence, predictor, i, k, base_pairs) - rna_trace_from_matrix( - matrix, sequence, predictor, k + 1, j, base_pairs, - ) + rna_trace_from_matrix(matrix, sequence, predictor, k + 1, j, base_pairs) return } k = k + 1 @@ -416,7 +455,10 @@ fn rna_build_dot_bracket(n : Int, base_pairs : Array[(Int, Int)]) -> String { ///| /// Build an array indicating which positions are paired. -fn rna_build_paired_array(n : Int, base_pairs : Array[(Int, Int)]) -> Array[Int] { +fn rna_build_paired_array( + n : Int, + base_pairs : Array[(Int, Int)], +) -> Array[Int] { let paired : Array[Int] = Array::make(n, -1) for idx = 0; idx < base_pairs.length(); idx = idx + 1 { let (i, j) = base_pairs[idx] @@ -436,7 +478,9 @@ fn rna_find_loops_recursive( paired : Array[Int], loop_regions : Array[LoopRegion], ) -> Unit { - if i >= j { return } + if i >= j { + return + } let n = sequence.length() let has_pair = if i < n && paired[i] == j { true } else { false } @@ -445,11 +489,7 @@ fn rna_find_loops_recursive( let loop_len = j - i - 1 if loop_len > 0 { let loop_type = rna_classify_loop(sequence, i, j, paired) - loop_regions.push(LoopRegion::{ - start: i + 1, - end: j - 1, - loop_type, - }) + loop_regions.push(LoopRegion::{ start: i + 1, end: j - 1, loop_type }) let inner_i = i + 1 let inner_j = j - 1 @@ -474,7 +514,12 @@ fn rna_find_loops_recursive( if k + 1 < k_pair - 1 { let sub_paired = rna_build_sub_paired(k + 1, k_pair - 1, paired) rna_find_loops_recursive( - sequence, base_pairs, k + 1, k_pair - 1, sub_paired, loop_regions, + sequence, + base_pairs, + k + 1, + k_pair - 1, + sub_paired, + loop_regions, ) } k = k_pair + 1 @@ -562,7 +607,9 @@ fn rna_compute_mfe( loop_regions : Array[LoopRegion], ) -> Double { let n = sequence.length() - if n <= 2 { return 0.0 } + if n <= 2 { + return 0.0 + } let mut mfe = 0.0 @@ -575,7 +622,9 @@ fn rna_compute_mfe( for idx = 0; idx < loop_regions.length(); idx = idx + 1 { let region = loop_regions[idx] let loop_len = region.end - region.start + 1 - if loop_len <= 0 { continue } + if loop_len <= 0 { + continue + } let penalty = match region.loop_type { "hairpin" => (predictor.loop_penalty + 0.1) * loop_len.to_double() @@ -605,10 +654,14 @@ fn rna_count_stacking( for idx = 0; idx < bp_count; idx = idx + 1 { let (i, j) = base_pairs[idx] let has_next = i + 1 < j - 1 - if !has_next { continue } + if !has_next { + continue + } for idx2 = 0; idx2 < bp_count; idx2 = idx2 + 1 { - if idx2 == idx { continue } + if idx2 == idx { + continue + } let (i2, j2) = base_pairs[idx2] if i2 == i + 1 && j2 == j - 1 { stacking_count = stacking_count + 1 @@ -618,4 +671,4 @@ fn rna_count_stacking( } stacking_count.to_double() * predictor.stacking_energy -} \ No newline at end of file +} diff --git a/src/rstatix.mbt b/src/rstatix.mbt index ba4f5a6a..7339bb2d 100644 --- a/src/rstatix.mbt +++ b/src/rstatix.mbt @@ -62,7 +62,9 @@ pub fn rstatix_t_test( let n1 = x.length() let is_two_sample = y.length() > 0 if !is_two_sample { - rstatix_t_test_one_sample(x, mu, alternative, conf_level, "Sample", "", "One-sample t-test") + rstatix_t_test_one_sample( + x, mu, alternative, conf_level, "Sample", "", "One-sample t-test", + ) } else if paired { let n = rstatix_min_int(n1, y.length()) let diffs = Array::make(n, 0.0) @@ -71,7 +73,9 @@ pub fn rstatix_t_test( diffs[i] = x[i] - y[i] i = i + 1 } - rstatix_t_test_one_sample(diffs, mu, alternative, conf_level, "Difference", "", "Paired t-test") + rstatix_t_test_one_sample( + diffs, mu, alternative, conf_level, "Difference", "", "Paired t-test", + ) } else { let n2 = y.length() let mean1 = rstatix_mean_double(x) @@ -80,8 +84,10 @@ pub fn rstatix_t_test( let sd2 = rstatix_sd_double(y) let se = (sd1 * sd1 / n1.to_double() + sd2 * sd2 / n2.to_double()).sqrt() let t_stat = (mean1 - mean2) / se - let df_num = (sd1 * sd1 / n1.to_double() + sd2 * sd2 / n2.to_double()) - let df_den = @math.pow(sd1 * sd1 / n1.to_double(), 2.0) / (n1.to_double() - 1.0) + @math.pow(sd2 * sd2 / n2.to_double(), 2.0) / (n2.to_double() - 1.0) + let df_num = sd1 * sd1 / n1.to_double() + sd2 * sd2 / n2.to_double() + let df_den = @math.pow(sd1 * sd1 / n1.to_double(), 2.0) / + (n1.to_double() - 1.0) + + @math.pow(sd2 * sd2 / n2.to_double(), 2.0) / (n2.to_double() - 1.0) let df = df_num * df_num / df_den let p_val = rstatix_compute_t_p(t_stat, df.to_int(), alternative) let tcrit = rstatix_t_critical(1.0 - conf_level, df.to_int(), alternative) @@ -120,7 +126,7 @@ fn rstatix_t_test_one_sample( let n = x.length() let mean_x = rstatix_mean_double(x) let sd_x = rstatix_sd_double(x) - let se = sd_x / (n.to_double()).sqrt() + let se = sd_x / n.to_double().sqrt() let t_stat = (mean_x - mu) / se let df = n - 1 let p_val = rstatix_compute_t_p(t_stat, df, alternative) @@ -174,7 +180,11 @@ pub fn rstatix_wilcox_test( ///| /// Wilcoxon signed-rank test. -fn rstatix_wilcox_signed(x : Array[Double], alternative : String, method_name : String) -> RstatixTTestResult { +fn rstatix_wilcox_signed( + x : Array[Double], + alternative : String, + method_name : String, +) -> RstatixTTestResult { let non_zero = Array::new() let mut i = 0 while i < x.length() { @@ -222,8 +232,11 @@ fn rstatix_wilcox_signed(x : Array[Double], alternative : String, method_name : i = i + 1 } let w = rstatix_min_double(t_plus, t_minus) - let mu_w = (n.to_double() * (n.to_double() + 1.0)) / 4.0 - let sigma_w = ((n.to_double() * (n.to_double() + 1.0) * (2.0 * n.to_double() + 1.0)) / 24.0).sqrt() + let mu_w = n.to_double() * (n.to_double() + 1.0) / 4.0 + let sigma_w = (n.to_double() * + (n.to_double() + 1.0) * + (2.0 * n.to_double() + 1.0) / + 24.0).sqrt() let z = (w - mu_w) / sigma_w let p_val = rstatix_norm_p(z, alternative) let med_est = rstatix_median_double(non_zero) @@ -293,11 +306,11 @@ fn rstatix_wilcox_rank_sum( r1 = r1 + ranks[i] i = i + 1 } - let u1 = r1 - (n1.to_double() * (n1.to_double() + 1.0)) / 2.0 + let u1 = r1 - n1.to_double() * (n1.to_double() + 1.0) / 2.0 let u2 = n1.to_double() * n2.to_double() - u1 let u = rstatix_min_double(u1, u2) - let mu_u = (n1.to_double() * n2.to_double()) / 2.0 - let sigma_u = ((n1.to_double() * n2.to_double() * (n.to_double() + 1.0)) / 12.0).sqrt() + let mu_u = n1.to_double() * n2.to_double() / 2.0 + let sigma_u = (n1.to_double() * n2.to_double() * (n.to_double() + 1.0) / 12.0).sqrt() let z = (u - mu_u) / sigma_u let p_val = rstatix_norm_p(z, alternative) let median1 = rstatix_median_double(x) @@ -348,7 +361,9 @@ pub fn rstatix_cor_test( let sp = if n > 3 { let t_stat = sr * ((n.to_double() - 2.0) / (1.0 - sr * sr)).sqrt() 2.0 * (1.0 - rstatix_norm_cdf(t_stat.abs())) - } else { @double.not_a_number } + } else { + @double.not_a_number + } (sr, sp, "Spearman's rank correlation") } "kendall" => { @@ -364,7 +379,9 @@ pub fn rstatix_cor_test( let pp = if n > 2 { let t_stat = pr * ((n.to_double() - 2.0) / (1.0 - pr * pr)).sqrt() 2.0 * rstatix_t_dist_p(t_stat.abs(), n - 2) - } else { @double.not_a_number } + } else { + @double.not_a_number + } (pr, pp, "Pearson's product-moment correlation") } } @@ -372,7 +389,7 @@ pub fn rstatix_cor_test( (r, r) } else { let z = 0.5 * @math.ln((1.0 + r) / (1.0 - r)) - let se_z = 1.0 / ((n.to_double() - 3.0).sqrt()) + let se_z = 1.0 / (n.to_double() - 3.0).sqrt() let z_crit = 1.96 (@math.exp(z - z_crit * se_z), @math.exp(z + z_crit * se_z)) } @@ -428,7 +445,10 @@ pub fn rstatix_anova_test( let mut ss_between = 0.0 i = 0 while i < k { - ss_between = ss_between + (n_groups[i].to_double() * (group_means[i] - grand_mean) * (group_means[i] - grand_mean)) + ss_between = ss_between + + n_groups[i].to_double() * + (group_means[i] - grand_mean) * + (group_means[i] - grand_mean) i = i + 1 } let mut ss_within = 0.0 @@ -446,13 +466,27 @@ pub fn rstatix_anova_test( let df_between = k - 1 let df_within = total_n - k let ms_between = ss_between / df_between.to_double() - let ms_within = if df_within > 0 { ss_within / df_within.to_double() } else { 0.0 } + let ms_within = if df_within > 0 { + ss_within / df_within.to_double() + } else { + 0.0 + } let f_stat = if ms_within < 1.0e-15 { - if ss_between < 1.0e-15 { 0.0 } else { @double.infinity } + if ss_between < 1.0e-15 { + 0.0 + } else { + @double.infinity + } } else { ms_between / ms_within } - let p_val = if f_stat == @double.infinity { 0.0 } else if f_stat < 1.0e-15 { 1.0 } else { rstatix_f_p(f_stat, df_between, df_within) } + let p_val = if f_stat == @double.infinity { + 0.0 + } else if f_stat < 1.0e-15 { + 1.0 + } else { + rstatix_f_p(f_stat, df_between, df_within) + } RstatixAnovaResult::{ source: "Between", df: df_between, @@ -510,10 +544,11 @@ pub fn rstatix_kruskal_test( } j = j + 1 } - sum_r_sq = sum_r_sq + (sum_r * sum_r) / n_i.to_double() + sum_r_sq = sum_r_sq + sum_r * sum_r / n_i.to_double() i = i + 1 } - let h = (12.0 / (n_total.to_double() * (n_total.to_double() + 1.0))) * sum_r_sq - 3.0 * (n_total.to_double() + 1.0) + let h = 12.0 / (n_total.to_double() * (n_total.to_double() + 1.0)) * sum_r_sq - + 3.0 * (n_total.to_double() + 1.0) let df = k - 1 let p_val = rstatix_chi2_p(h, df) RstatixAnovaResult::{ @@ -569,7 +604,10 @@ pub fn rstatix_friedman_test( total = total + rank_sums[j] * rank_sums[j] j = j + 1 } - let q = (12.0 / (n_blocks.to_double() * k.to_double() * (k.to_double() + 1.0))) * total - 3.0 * n_blocks.to_double() * (k.to_double() + 1.0) + let q = 12.0 / + (n_blocks.to_double() * k.to_double() * (k.to_double() + 1.0)) * + total - + 3.0 * n_blocks.to_double() * (k.to_double() + 1.0) let df = k - 1 let p_val = rstatix_chi2_p(q, df) RstatixAnovaResult::{ @@ -587,7 +625,9 @@ pub fn rstatix_friedman_test( /// Apply Benjamini-Hochberg FDR correction. pub fn rstatix_bh_correct(p_values : Array[Double]) -> Array[Double] { let n = p_values.length() - if n == 0 { return Array::new() } + if n == 0 { + return Array::new() + } let result = Array::make(n, 0.0) let indices = Array::make(n, 0) let mut i = 0 @@ -595,7 +635,15 @@ pub fn rstatix_bh_correct(p_values : Array[Double]) -> Array[Double] { indices[i] = i i = i + 1 } - indices.sort_by(fn(a : Int, b : Int) -> Int { if p_values[a] < p_values[b] { -1 } else if p_values[a] > p_values[b] { 1 } else { 0 } }) + indices.sort_by(fn(a : Int, b : Int) -> Int { + if p_values[a] < p_values[b] { + -1 + } else if p_values[a] > p_values[b] { + 1 + } else { + 0 + } + }) let mut min_so_far = 1.0 i = n - 1 while i >= 0 { @@ -652,9 +700,25 @@ pub fn rstatix_sample_data() -> Array[Array[Double]] { // ============ Private Helpers ============ -fn rstatix_min_int(a : Int, b : Int) -> Int { if a < b { a } else { b } } -fn rstatix_min_double(a : Double, b : Double) -> Double { if a < b { a } else { b } } +///| +fn rstatix_min_int(a : Int, b : Int) -> Int { + if a < b { + a + } else { + b + } +} +///| +fn rstatix_min_double(a : Double, b : Double) -> Double { + if a < b { + a + } else { + b + } +} + +///| fn rstatix_mean_double(data : Array[Double]) -> Double { let mut sum = 0.0 let mut count = 0 @@ -666,12 +730,19 @@ fn rstatix_mean_double(data : Array[Double]) -> Double { } i = i + 1 } - if count > 0 { sum / count.to_double() } else { 0.0 } + if count > 0 { + sum / count.to_double() + } else { + 0.0 + } } +///| fn rstatix_sd_double(data : Array[Double]) -> Double { let n = data.length() - if n <= 1 { return 0.0 } + if n <= 1 { + return 0.0 + } let mean = rstatix_mean_double(data) let mut sum_sq = 0.0 let mut count = 0 @@ -684,17 +755,29 @@ fn rstatix_sd_double(data : Array[Double]) -> Double { } i = i + 1 } - if count > 1 { (sum_sq / (count.to_double() - 1.0)).sqrt() } else { 0.0 } + if count > 1 { + (sum_sq / (count.to_double() - 1.0)).sqrt() + } else { + 0.0 + } } +///| fn rstatix_median_double(data : Array[Double]) -> Double { - if data.length() == 0 { return 0.0 } + if data.length() == 0 { + return 0.0 + } let sorted = data.copy() sorted.sort() let n = sorted.length() - if n % 2 == 0 { (sorted[n / 2 - 1] + sorted[n / 2]) / 2.0 } else { sorted[n / 2] } + if n % 2 == 0 { + (sorted[n / 2 - 1] + sorted[n / 2]) / 2.0 + } else { + sorted[n / 2] + } } +///| fn rstatix_sub_scalar(data : Array[Double], scalar : Double) -> Array[Double] { let result = Array::make(data.length(), 0.0) let mut i = 0 @@ -705,6 +788,7 @@ fn rstatix_sub_scalar(data : Array[Double], scalar : Double) -> Array[Double] { result } +///| fn rstatix_pearson_val(x : Array[Double], y : Array[Double]) -> Double { let n = x.length() let mean_x = rstatix_mean_double(x) @@ -722,34 +806,57 @@ fn rstatix_pearson_val(x : Array[Double], y : Array[Double]) -> Double { i = i + 1 } let denom = (sum_x2 * sum_y2).sqrt() - if denom < 1.0e-15 { @double.not_a_number } else { sum_xy / denom } + if denom < 1.0e-15 { + @double.not_a_number + } else { + sum_xy / denom + } } +///| fn rstatix_spearman_val(x : Array[Double], y : Array[Double]) -> Double { let rx = rstatix_rank_array(x) let ry = rstatix_rank_array(y) rstatix_pearson_val(rx, ry) } +///| fn rstatix_rank_array(data : Array[Double]) -> Array[Double] { let n = data.length() let indices = Array::make(n, 0) let mut i = 0 - while i < n { indices[i] = i; i = i + 1 } - indices.sort_by(fn(a : Int, b : Int) -> Int { if data[a] < data[b] { -1 } else if data[a] > data[b] { 1 } else { 0 } }) + while i < n { + indices[i] = i + i = i + 1 + } + indices.sort_by(fn(a : Int, b : Int) -> Int { + if data[a] < data[b] { + -1 + } else if data[a] > data[b] { + 1 + } else { + 0 + } + }) let ranks = Array::make(n, 0.0) i = 0 while i < n { let mut j = i - while j < n - 1 && data[indices[j]] == data[indices[j + 1]] { j = j + 1 } - let avg = ((i + j).to_double() / 2.0) + 1.0 + while j < n - 1 && data[indices[j]] == data[indices[j + 1]] { + j = j + 1 + } + let avg = (i + j).to_double() / 2.0 + 1.0 let mut k = i - while k <= j { ranks[indices[k]] = avg; k = k + 1 } + while k <= j { + ranks[indices[k]] = avg + k = k + 1 + } i = j + 1 } ranks } +///| fn rstatix_kendall_tau(x : Array[Double], y : Array[Double]) -> Double { let n = x.length() let mut conc = 0 @@ -760,15 +867,24 @@ fn rstatix_kendall_tau(x : Array[Double], y : Array[Double]) -> Double { while j < n { let dx = x[j] - x[i] let dy = y[j] - y[i] - if dx * dy > 1.0e-15 { conc = conc + 1 } else if dx * dy < -1.0e-15 { disc = disc + 1 } + if dx * dy > 1.0e-15 { + conc = conc + 1 + } else if dx * dy < -1.0e-15 { + disc = disc + 1 + } j = j + 1 } i = i + 1 } - let total = (n * (n - 1)) / 2 - if total > 0 { (conc.to_double() - disc.to_double()) / total.to_double() } else { 0.0 } + let total = n * (n - 1) / 2 + if total > 0 { + (conc.to_double() - disc.to_double()) / total.to_double() + } else { + 0.0 + } } +///| fn rstatix_compute_t_p(t : Double, df : Int, alt : String) -> Double { let p_two = 2.0 * rstatix_t_dist_p(t.abs(), df) match alt { @@ -778,19 +894,29 @@ fn rstatix_compute_t_p(t : Double, df : Int, alt : String) -> Double { } } +///| fn rstatix_t_dist_p(t : Double, df : Int) -> Double { - if df <= 0 || t.is_nan() { return @double.not_a_number } + if df <= 0 || t.is_nan() { + return @double.not_a_number + } let x = df.to_double() / (df.to_double() + t * t) rstatix_ibeta(df.to_double() / 2.0, 0.5, x) } +///| fn rstatix_ibeta(a : Double, b : Double, x : Double) -> Double { - if x < 0.0 || x > 1.0 { return 0.0 } - if x == 0.0 || x == 1.0 { return x } + if x < 0.0 || x > 1.0 { + return 0.0 + } + if x == 0.0 || x == 1.0 { + return x + } let g = 7.0 - let c = [0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, - -176.61502916214059, 12.507343278686905, -0.13857109526572012, - 9.9843695780195716e-6, 1.5056327351493116e-7] + let c = [ + 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, + -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, + 1.5056327351493116e-7, + ] let pi = 3.14159265358979323846 let lbeta = rstatix_lgamma(a) + rstatix_lgamma(b) - rstatix_lgamma(a + b) let front = @math.exp(a * @math.ln(x) + b * @math.ln(1.0 - x) - lbeta) / a @@ -799,62 +925,96 @@ fn rstatix_ibeta(a : Double, b : Double, x : Double) -> Double { let mut f = 1.0 let mut c_val = 1.0 let mut d = 1.0 - (a + b) * x / (a + 1.0) - if d.abs() < 1.0e-30 { d = 1.0e-30 } + if d.abs() < 1.0e-30 { + d = 1.0e-30 + } d = 1.0 / d f = d let mut m = 1 while m <= max_iter { - let n1 = m.to_double() * (b - m.to_double()) * x / ((a + 2.0 * m.to_double() - 1.0) * (a + 2.0 * m.to_double())) + let n1 = m.to_double() * + (b - m.to_double()) * + x / + ((a + 2.0 * m.to_double() - 1.0) * (a + 2.0 * m.to_double())) d = 1.0 + n1 * d - if d.abs() < 1.0e-30 { d = 1.0e-30 } + if d.abs() < 1.0e-30 { + d = 1.0e-30 + } c_val = 1.0 + n1 / c_val - if c_val.abs() < 1.0e-30 { c_val = 1.0e-30 } + if c_val.abs() < 1.0e-30 { + c_val = 1.0e-30 + } d = 1.0 / d f = f * d * c_val - let n2 = -(a + m.to_double()) * (a + b + m.to_double()) * x / ((a + 2.0 * m.to_double()) * (a + 2.0 * m.to_double() + 1.0)) + let n2 = -(a + m.to_double()) * + (a + b + m.to_double()) * + x / + ((a + 2.0 * m.to_double()) * (a + 2.0 * m.to_double() + 1.0)) d = 1.0 + n2 * d - if d.abs() < 1.0e-30 { d = 1.0e-30 } + if d.abs() < 1.0e-30 { + d = 1.0e-30 + } c_val = 1.0 + n2 / c_val - if c_val.abs() < 1.0e-30 { c_val = 1.0e-30 } + if c_val.abs() < 1.0e-30 { + c_val = 1.0e-30 + } d = 1.0 / d let del = d * c_val f = f * del - if (del - 1.0).abs() < eps { break } + if (del - 1.0).abs() < eps { + break + } m = m + 1 } front * f } +///| fn rstatix_lgamma(x : Double) -> Double { - if x <= 0.0 { return @double.not_a_number } + if x <= 0.0 { + return @double.not_a_number + } let g = 7.0 - let c = [0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, - -176.61502916214059, 12.507343278686905, -0.13857109526572012, - 9.9843695780195716e-6, 1.5056327351493116e-7] + let c = [ + 0.99999999999980993, 676.5203681218851, -1259.1392167224028, 771.32342877765313, + -176.61502916214059, 12.507343278686905, -0.13857109526572012, 9.9843695780195716e-6, + 1.5056327351493116e-7, + ] let pi = 3.14159265358979323846 - if x < 0.5 { return @math.ln(pi / @math.sin(pi * x)) - rstatix_lgamma(1.0 - x) } + if x < 0.5 { + return @math.ln(pi / @math.sin(pi * x)) - rstatix_lgamma(1.0 - x) + } let mut sum = c[0] let mut i = 1 - while i < 9 { sum = sum + c[i] / (x + i.to_double() - 1.0); i = i + 1 } + while i < 9 { + sum = sum + c[i] / (x + i.to_double() - 1.0) + i = i + 1 + } let t = x + g + 0.5 0.5 * @math.ln(2.0 * pi) + (t * @math.ln(t) - t) + @math.ln(sum) } +///| fn rstatix_t_critical(alpha : Double, df : Int, alt : String) -> Double { let a = if alt == "two.sided" { alpha / 2.0 } else { alpha } rstatix_approx_tc(a, df) } +///| fn rstatix_approx_tc(alpha : Double, df : Int) -> Double { let z = rstatix_norm_q(1.0 - alpha) let df_d = df.to_double() - z + (z * z * z + z) / (4.0 * df_d) + (5.0 * z + 16.0 * z * z * z + 3.0 * @math.pow(z, 5.0)) / (96.0 * df_d * df_d) + z + + (z * z * z + z) / (4.0 * df_d) + + (5.0 * z + 16.0 * z * z * z + 3.0 * @math.pow(z, 5.0)) / (96.0 * df_d * df_d) } +///| fn rstatix_norm_cdf(x : Double) -> Double { 0.5 * (1.0 + rstatix_erf(x / 1.4142135623730951)) } +///| fn rstatix_erf(x : Double) -> Double { let t = 1.0 / (1.0 + 0.3275911 * x.abs()) let a1 = 0.254829592 @@ -862,21 +1022,41 @@ fn rstatix_erf(x : Double) -> Double { let a3 = 1.421413741 let a4 = -1.453152027 let a5 = 1.061405429 - let res = 1.0 - (a1 * t + a2 * t * t + a3 * t * t * t + a4 * t * t * t * t + a5 * t * t * t * t * t) * @math.exp(-x * x) - if x >= 0.0 { res } else { -res } + let res = 1.0 - + ( + a1 * t + + a2 * t * t + + a3 * t * t * t + + a4 * t * t * t * t + + a5 * t * t * t * t * t + ) * + @math.exp(-x * x) + if x >= 0.0 { + res + } else { + -res + } } +///| fn rstatix_norm_q(p : Double) -> Double { - if p <= 0.0 || p >= 1.0 { return @double.not_a_number } + if p <= 0.0 || p >= 1.0 { + return @double.not_a_number + } if p < 0.5 { let eta = (-2.0 * @math.ln(p)).sqrt() - -(eta - (2.515517 + 0.802853 * eta + 0.010328 * eta * eta) / (1.0 + 1.432788 * eta + 0.189269 * eta * eta + 0.001308 * eta * eta * eta)) + -(eta - + (2.515517 + 0.802853 * eta + 0.010328 * eta * eta) / + (1.0 + 1.432788 * eta + 0.189269 * eta * eta + 0.001308 * eta * eta * eta)) } else { let eta = (-2.0 * @math.ln(1.0 - p)).sqrt() - eta - (2.515517 + 0.802853 * eta + 0.010328 * eta * eta) / (1.0 + 1.432788 * eta + 0.189269 * eta * eta + 0.001308 * eta * eta * eta) + eta - + (2.515517 + 0.802853 * eta + 0.010328 * eta * eta) / + (1.0 + 1.432788 * eta + 0.189269 * eta * eta + 0.001308 * eta * eta * eta) } } +///| fn rstatix_norm_p(z : Double, alt : String) -> Double { let p_two = 2.0 * (1.0 - rstatix_norm_cdf(z.abs())) match alt { @@ -886,21 +1066,32 @@ fn rstatix_norm_p(z : Double, alt : String) -> Double { } } +///| fn rstatix_f_p(f : Double, df1 : Int, df2 : Int) -> Double { - if f <= 0.0 { return 1.0 } + if f <= 0.0 { + return 1.0 + } let x = df1.to_double() / (df1.to_double() + df2.to_double() * f) 1.0 - rstatix_ibeta(df1.to_double() / 2.0, df2.to_double() / 2.0, x) } +///| fn rstatix_chi2_p(chi2 : Double, df : Int) -> Double { - if chi2 <= 0.0 { return 1.0 } + if chi2 <= 0.0 { + return 1.0 + } let x = chi2 / (chi2 + (df.to_double() + 2.0)) 1.0 - rstatix_ibeta(df.to_double() / 2.0, 0.5, x) } +///| fn rstatix_fmt(v : Double) -> String { - if v.is_nan() { return "NA" } - if v == @double.infinity || v == @double.neg_infinity { return "Inf" } + if v.is_nan() { + return "NA" + } + if v == @double.infinity || v == @double.neg_infinity { + return "Inf" + } let r = (v * 10000.0).round() / 10000.0 "\{r}" } diff --git a/src/rtsne.mbt b/src/rtsne.mbt index 855c42f6..a62a3fd8 100644 --- a/src/rtsne.mbt +++ b/src/rtsne.mbt @@ -44,17 +44,17 @@ pub fn TsneConfig::new_custom( random_seed : Int, ) -> TsneConfig { TsneConfig::{ - perplexity: perplexity, + perplexity, theta: 0.5, - max_iter: max_iter, - dims: dims, + max_iter, + dims, eta: 200.0, exaggeration_factor: 12.0, momentum: 0.5, final_momentum: 0.8, mom_switch_iter: 250, stop_lying_iter: 250, - random_seed: random_seed, + random_seed, } } @@ -68,11 +68,7 @@ pub struct TsneResult { ///| pub fn TsneResult::new() -> TsneResult { - TsneResult::{ - embedding: Array::new(), - costs: Array::new(), - n_iter: 0, - } + TsneResult::{ embedding: Array::new(), costs: Array::new(), n_iter: 0 } } // ============================================================ @@ -83,14 +79,16 @@ pub fn TsneResult::new() -> TsneResult { /// Calculate pairwise Euclidean distances between data points. /// Input: data matrix (rows = samples, cols = features) /// Output: distance matrix (n x n) -pub fn calc_distance_matrix(data : Array[Array[Double]]) -> Array[Array[Double]] { +pub fn calc_distance_matrix( + data : Array[Array[Double]], +) -> Array[Array[Double]] { let n = data.length() let dist_matrix : Array[Array[Double]] = Array::new() - + if n == 0 { return dist_matrix } - + let mut i = 0 while i < n { let row : Array[Double] = Array::new() @@ -102,7 +100,7 @@ pub fn calc_distance_matrix(data : Array[Array[Double]]) -> Array[Array[Double]] dist_matrix.push(row) i = i + 1 } - + let mut i = 0 while i < n { let mut j = i + 1 @@ -114,10 +112,11 @@ pub fn calc_distance_matrix(data : Array[Array[Double]]) -> Array[Array[Double]] } i = i + 1 } - + dist_matrix } +///| fn rtsne_euclidean_distance(x : Array[Double], y : Array[Double]) -> Double { let mut sum_sq = 0.0 let n = if x.length() < y.length() { x.length() } else { y.length() } @@ -136,21 +135,25 @@ fn rtsne_euclidean_distance(x : Array[Double], y : Array[Double]) -> Double { ///| /// Compute the probability distribution p_{j|i} using binary search for perplexity. -fn compute_p_ji(distances : Array[Double], perplexity : Double, n : Int) -> Array[Double] { +fn compute_p_ji( + distances : Array[Double], + perplexity : Double, + n : Int, +) -> Array[Double] { let p : Array[Double] = Array::new() let mut i = 0 while i < n { p.push(0.0) i = i + 1 } - + let log_perp = @math.ln(perplexity) - + // Binary search for sigma (precision) - let mut beta = 1.0 // beta = 1 / (2 * sigma^2) + let mut beta = 1.0 // beta = 1 / (2 * sigma^2) let mut min_beta = -1.0e300 let mut max_beta = 1.0e300 - + let mut iter_count = 0 while iter_count < 50 { // Compute P values @@ -162,11 +165,11 @@ fn compute_p_ji(distances : Array[Double], perplexity : Double, n : Int) -> Arra sum_p = sum_p + p_val i = i + 1 } - + if sum_p == 0.0 { sum_p = 1.0e-10 } - + // Normalize let mut h = 0.0 i = 0 @@ -177,13 +180,13 @@ fn compute_p_ji(distances : Array[Double], perplexity : Double, n : Int) -> Arra } i = i + 1 } - + let h_diff = h - log_perp - + if h_diff.abs() < 1.0e-5 { break } - + if h_diff > 0.0 { // Entropy is too high, need to increase beta (decrease sigma) min_beta = beta @@ -201,18 +204,21 @@ fn compute_p_ji(distances : Array[Double], perplexity : Double, n : Int) -> Arra beta = (beta + min_beta) / 2.0 } } - + iter_count = iter_count + 1 } - + p } ///| /// Compute joint probability matrix P from distance matrix. -fn compute_p_matrix(dist_matrix : Array[Array[Double]], perplexity : Double) -> Array[Array[Double]] { +fn compute_p_matrix( + dist_matrix : Array[Array[Double]], + perplexity : Double, +) -> Array[Array[Double]] { let n = dist_matrix.length() - + let p_matrix : Array[Array[Double]] = Array::new() let mut i = 0 while i < n { @@ -225,7 +231,7 @@ fn compute_p_matrix(dist_matrix : Array[Array[Double]], perplexity : Double) -> p_matrix.push(row) i = i + 1 } - + // Compute P_{j|i} for each i let mut i = 0 while i < n { @@ -237,7 +243,7 @@ fn compute_p_matrix(dist_matrix : Array[Array[Double]], perplexity : Double) -> } i = i + 1 } - + // Symmetrize: P_{ij} = (P_{j|i} + P_{i|j}) / (2n) let mut i = 0 while i < n { @@ -248,7 +254,7 @@ fn compute_p_matrix(dist_matrix : Array[Array[Double]], perplexity : Double) -> } i = i + 1 } - + p_matrix } @@ -262,11 +268,11 @@ fn compute_p_matrix(dist_matrix : Array[Array[Double]], perplexity : Double) -> /// Output: t-SNE embedding (n x dims) pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { let n = data.length() - + if n == 0 { return TsneResult::new() } - + if n < 2 { let result = TsneResult::new() let embedding : Array[Array[Double]] = Array::new() @@ -279,13 +285,13 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { embedding.push(row) return result } - + // Step 1: Compute pairwise distances let dist_matrix = calc_distance_matrix(data) - + // Step 2: Compute joint probability matrix P let p_matrix = compute_p_matrix(dist_matrix, config.perplexity) - + // Step 3: Initialize Y (the embedding) with small random values let y : Array[Array[Double]] = Array::new() let mut i = 0 @@ -302,12 +308,12 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { y.push(row) i = i + 1 } - + // Step 4: Gradient descent - let d_y : Array[Array[Double]] = Array::new() // gradient - let u_y : Array[Array[Double]] = Array::new() // update (momentum) - let gains : Array[Array[Double]] = Array::new() // learning rate gains - + let d_y : Array[Array[Double]] = Array::new() // gradient + let u_y : Array[Array[Double]] = Array::new() // update (momentum) + let gains : Array[Array[Double]] = Array::new() // learning rate gains + let mut i = 0 while i < n { let d_row : Array[Double] = Array::new() @@ -325,16 +331,16 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { gains.push(g_row) i = i + 1 } - + let costs : Array[Double] = Array::new() let mut momentum = config.momentum - + let mut iter = 0 while iter < config.max_iter { // Compute Q matrix (low-dimensional similarities) let q_matrix : Array[Array[Double]] = Array::new() let mut sum_q = 0.0 - + let mut i = 0 while i < n { let row : Array[Double] = Array::new() @@ -346,7 +352,7 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { q_matrix.push(row) i = i + 1 } - + let mut i = 0 while i < n { let mut j = i + 1 @@ -359,21 +365,21 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { sq_dist = sq_dist + diff * diff d = d + 1 } - + let q_val = 1.0 / (1.0 + sq_dist) q_matrix[i][j] = q_val q_matrix[j][i] = q_val sum_q = sum_q + 2.0 * q_val - + j = j + 1 } i = i + 1 } - + if sum_q == 0.0 { sum_q = 1.0e-10 } - + // Normalize Q let mut i = 0 while i < n { @@ -384,7 +390,7 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { } i = i + 1 } - + // Compute cost (KL divergence) let mut cost = 0.0 let mut i = 0 @@ -392,14 +398,15 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { let mut j = 0 while j < n { if i != j && p_matrix[i][j] > 0.0 { - cost = cost + p_matrix[i][j] * @math.ln(p_matrix[i][j] / q_matrix[i][j]) + cost = cost + + p_matrix[i][j] * @math.ln(p_matrix[i][j] / q_matrix[i][j]) } j = j + 1 } i = i + 1 } costs.push(cost) - + // Compute gradient let mut i = 0 while i < n { @@ -408,7 +415,7 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { d_y[i][d] = 0.0 d = d + 1 } - + let mut j = 0 while j < n { if i != j { @@ -419,9 +426,9 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { sq_dist = sq_dist + diff * diff d = d + 1 } - + let mult = (p_matrix[i][j] - q_matrix[i][j]) * (1.0 / (1.0 + sq_dist)) - + let mut d = 0 while d < config.dims { d_y[i][d] = d_y[i][d] + 4.0 * mult * (y[i][d] - y[j][d]) @@ -432,12 +439,12 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { } i = i + 1 } - + // Update momentum if iter == config.mom_switch_iter { momentum = config.final_momentum } - + // Stop exaggeration if iter == config.stop_lying_iter { let mut i = 0 @@ -450,7 +457,7 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { i = i + 1 } } - + // Apply early exaggeration if iter < config.stop_lying_iter { let mut i = 0 @@ -463,46 +470,44 @@ pub fn tsne(data : Array[Array[Double]], config : TsneConfig) -> TsneResult { i = i + 1 } } - + // Update gains and apply momentum let mut i = 0 while i < n { let mut d = 0 while d < config.dims { // Update gain - if (d_y[i][d] > 0.0 && u_y[i][d] > 0.0) || (d_y[i][d] < 0.0 && u_y[i][d] < 0.0) { + if (d_y[i][d] > 0.0 && u_y[i][d] > 0.0) || + (d_y[i][d] < 0.0 && u_y[i][d] < 0.0) { gains[i][d] = gains[i][d] * 0.8 } else { gains[i][d] = gains[i][d] + 0.2 } - + if gains[i][d] < 0.01 { gains[i][d] = 0.01 } - + // Update with momentum u_y[i][d] = momentum * u_y[i][d] - config.eta * gains[i][d] * d_y[i][d] y[i][d] = y[i][d] + u_y[i][d] - + d = d + 1 } i = i + 1 } - + iter = iter + 1 } - - TsneResult::{ - embedding: y, - costs: costs, - n_iter: config.max_iter, - } + + TsneResult::{ embedding: y, costs, n_iter: config.max_iter } } // ============================================================ // Helper functions // ============================================================ +///| fn pseudo_random(seed : Double) -> Double { // Simple deterministic pseudo-random number generator let x = seed * 12.9898 @@ -515,14 +520,17 @@ fn pseudo_random(seed : Double) -> Double { ///| /// Create sample data for testing/demo. -pub fn create_tsne_test_data(n_samples : Int, n_features : Int) -> Array[Array[Double]] { +pub fn create_tsne_test_data( + n_samples : Int, + n_features : Int, +) -> Array[Array[Double]] { let data : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_samples { let row : Array[Double] = Array::new() - let group = i % 3 // 3 clusters - + let group = i % 3 // 3 clusters + let mut j = 0 while j < n_features { let seed_val = (i * n_features + j).to_double() @@ -531,10 +539,10 @@ pub fn create_tsne_test_data(n_samples : Int, n_features : Int) -> Array[Array[D row.push(cluster_center + noise) j = j + 1 } - + data.push(row) i = i + 1 } - + data } diff --git a/src/s4vectors.mbt b/src/s4vectors.mbt index 3653ddf4..8620a49a 100644 --- a/src/s4vectors.mbt +++ b/src/s4vectors.mbt @@ -17,14 +17,14 @@ pub fn Rle::new(values : Array[String], lengths : Array[Int]) -> Rle { pub fn Rle::from_vector(vec : Array[String]) -> Rle { let values : Array[String] = Array::new() let lengths : Array[Int] = Array::new() - + if vec.length() == 0 { return Rle::{ values, lengths } } - + let mut current_value = vec[0] let mut current_length = 1 - + let mut i = 1 while i < vec.length() { if vec[i] == current_value { @@ -37,10 +37,10 @@ pub fn Rle::from_vector(vec : Array[String]) -> Rle { } i = i + 1 } - + values.push(current_value) lengths.push(current_length) - + Rle::{ values, lengths } } @@ -58,7 +58,7 @@ pub fn Rle::length(self : Rle) -> Int { ///| pub fn Rle::decode(self : Rle) -> Array[String] { let result : Array[String] = Array::new() - + let mut i = 0 while i < self.values.length() { let mut j = 0 @@ -68,14 +68,14 @@ pub fn Rle::decode(self : Rle) -> Array[String] { } i = i + 1 } - + result } ///| pub fn Rle::get(self : Rle, idx : Int) -> String { let mut pos = 0 - + let mut i = 0 while i < self.lengths.length() { if pos + self.lengths[i] > idx { @@ -84,7 +84,7 @@ pub fn Rle::get(self : Rle, idx : Int) -> String { pos = pos + self.lengths[i] i = i + 1 } - + "" } @@ -92,11 +92,11 @@ pub fn Rle::get(self : Rle, idx : Int) -> String { pub fn Rle::compress_ratio(self : Rle) -> Double { let original_size = self.length() let compressed_size = self.values.length() + self.lengths.length() - + if original_size == 0 { return 0.0 } - + original_size.to_double() / compressed_size.to_double() } @@ -107,7 +107,10 @@ pub struct S4DataFrameColumn { } ///| -pub fn S4DataFrameColumn::new(name : String, values : Array[String]) -> S4DataFrameColumn { +pub fn S4DataFrameColumn::new( + name : String, + values : Array[String], +) -> S4DataFrameColumn { S4DataFrameColumn::{ name, values } } @@ -118,7 +121,10 @@ pub struct S4DataFrame { } ///| -pub fn S4DataFrame::new(columns : Array[S4DataFrameColumn], row_names : Array[String]) -> S4DataFrame { +pub fn S4DataFrame::new( + columns : Array[S4DataFrameColumn], + row_names : Array[String], +) -> S4DataFrame { S4DataFrame::{ columns, row_names } } @@ -138,18 +144,21 @@ pub fn S4DataFrame::ncol(self : S4DataFrame) -> Int { ///| pub fn S4DataFrame::colnames(self : S4DataFrame) -> Array[String] { let names : Array[String] = Array::new() - + let mut i = 0 while i < self.columns.length() { names.push(self.columns[i].name) i = i + 1 } - + names } ///| -pub fn S4DataFrame::get_column(self : S4DataFrame, name : String) -> S4DataFrameColumn? { +pub fn S4DataFrame::get_column( + self : S4DataFrame, + name : String, +) -> S4DataFrameColumn? { let mut i = 0 while i < self.columns.length() { if self.columns[i].name == name { @@ -157,14 +166,14 @@ pub fn S4DataFrame::get_column(self : S4DataFrame, name : String) -> S4DataFrame } i = i + 1 } - + None } ///| pub fn S4DataFrame::get_row(self : S4DataFrame, idx : Int) -> Array[String] { let result : Array[String] = Array::new() - + let mut i = 0 while i < self.columns.length() { if idx < self.columns[i].values.length() { @@ -174,15 +183,18 @@ pub fn S4DataFrame::get_row(self : S4DataFrame, idx : Int) -> Array[String] { } i = i + 1 } - + result } ///| -pub fn S4DataFrame::subset_rows(self : S4DataFrame, indices : Array[Int]) -> S4DataFrame { +pub fn S4DataFrame::subset_rows( + self : S4DataFrame, + indices : Array[Int], +) -> S4DataFrame { let new_columns : Array[S4DataFrameColumn] = Array::new() let new_row_names : Array[String] = Array::new() - + let mut i = 0 while i < self.columns.length() { let col_values : Array[String] = Array::new() @@ -197,7 +209,7 @@ pub fn S4DataFrame::subset_rows(self : S4DataFrame, indices : Array[Int]) -> S4D new_columns.push(S4DataFrameColumn::new(self.columns[i].name, col_values)) i = i + 1 } - + let mut j = 0 while j < indices.length() { let idx = indices[j] @@ -206,7 +218,7 @@ pub fn S4DataFrame::subset_rows(self : S4DataFrame, indices : Array[Int]) -> S4D } j = j + 1 } - + S4DataFrame::new(new_columns, new_row_names) } @@ -219,7 +231,12 @@ pub struct Hits { } ///| -pub fn Hits::new(query_hits : Array[Int], subject_hits : Array[Int], query_length : Int, subject_length : Int) -> Hits { +pub fn Hits::new( + query_hits : Array[Int], + subject_hits : Array[Int], + query_length : Int, + subject_length : Int, +) -> Hits { Hits::{ query_hits, subject_hits, query_length, subject_length } } @@ -231,7 +248,7 @@ pub fn Hits::n_hits(self : Hits) -> Int { ///| pub fn Hits::count_query_hits(self : Hits) -> Array[Int] { let counts : Array[Int] = Array::make(self.query_length, 0) - + let mut i = 0 while i < self.query_hits.length() { let idx = self.query_hits[i] @@ -240,14 +257,14 @@ pub fn Hits::count_query_hits(self : Hits) -> Array[Int] { } i = i + 1 } - + counts } ///| pub fn Hits::count_subject_hits(self : Hits) -> Array[Int] { let counts : Array[Int] = Array::make(self.subject_length, 0) - + let mut i = 0 while i < self.subject_hits.length() { let idx = self.subject_hits[i] @@ -256,14 +273,14 @@ pub fn Hits::count_subject_hits(self : Hits) -> Array[Int] { } i = i + 1 } - + counts } ///| pub fn Hits::find_hits(self : Hits, query_idx : Int) -> Array[Int] { let result : Array[Int] = Array::new() - + let mut i = 0 while i < self.query_hits.length() { if self.query_hits[i] == query_idx { @@ -271,20 +288,20 @@ pub fn Hits::find_hits(self : Hits, query_idx : Int) -> Array[Int] { } i = i + 1 } - + result } ///| pub fn Hits::as_matrix(self : Hits) -> Array[(Int, Int)] { let result : Array[(Int, Int)] = Array::new() - + let mut i = 0 while i < self.query_hits.length() { result.push((self.query_hits[i], self.subject_hits[i])) i = i + 1 } - + result } @@ -296,10 +313,16 @@ pub fn create_example_rle() -> Rle { ///| pub fn create_example_dataframe() -> S4DataFrame { - let col1 = S4DataFrameColumn::new("gene_id", ["gene1", "gene2", "gene3", "gene4", "gene5"]) - let col2 = S4DataFrameColumn::new("expression", ["10.5", "25.3", "5.8", "100.2", "15.7"]) - let col3 = S4DataFrameColumn::new("p_value", ["0.001", "0.05", "0.8", "0.0001", "0.1"]) - + let col1 = S4DataFrameColumn::new("gene_id", [ + "gene1", "gene2", "gene3", "gene4", "gene5", + ]) + let col2 = S4DataFrameColumn::new("expression", [ + "10.5", "25.3", "5.8", "100.2", "15.7", + ]) + let col3 = S4DataFrameColumn::new("p_value", [ + "0.001", "0.05", "0.8", "0.0001", "0.1", + ]) + S4DataFrame::new([col1, col2, col3], ["row1", "row2", "row3", "row4", "row5"]) } @@ -307,6 +330,6 @@ pub fn create_example_dataframe() -> S4DataFrame { pub fn create_example_hits() -> Hits { let query_hits = [0, 0, 1, 2, 2, 2, 3] let subject_hits = [1, 3, 0, 1, 2, 4, 2] - + Hits::new(query_hits, subject_hits, 4, 5) -} \ No newline at end of file +} diff --git a/src/sasa.mbt b/src/sasa.mbt index b590216a..d7906f64 100644 --- a/src/sasa.mbt +++ b/src/sasa.mbt @@ -268,7 +268,7 @@ pub fn sasa_generate_sphere_points(n : Int) -> Array[Vector3] { let golden_angle = 3.14159265358979323846 * (3.0 - 5.0.sqrt()) let denom = (count - 1).to_double() for i in 0.. SC3Result { - SC3Result::{ cluster_labels, consensus_matrix, k, silhouette_scores, gap_statistics, optimal_k } + SC3Result::{ + cluster_labels, + consensus_matrix, + k, + silhouette_scores, + gap_statistics, + optimal_k, + } } ///| @@ -31,9 +38,9 @@ pub fn SC3Result::new( pub fn sc3_preprocess(data : Array[Array[Double]]) -> Array[Array[Double]] { let n = data.length() let dim = if n > 0 { data[0].length() } else { 0 } - + let processed : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let row : Array[Double] = Array::new() @@ -43,26 +50,29 @@ pub fn sc3_preprocess(data : Array[Array[Double]]) -> Array[Array[Double]] { sum = sum + data[i][j] j = j + 1 } - + let mut k = 0 while k < dim { row.push(if sum > 0.0 { data[i][k] / sum * 1000000.0 } else { 0.0 }) k = k + 1 } - + processed.push(row) i = i + 1 } - + processed } ///| /// Compute PCA on preprocessed data. -pub fn sc3_pca(data : Array[Array[Double]], n_components : Int) -> Array[Array[Double]] { +pub fn sc3_pca( + data : Array[Array[Double]], + n_components : Int, +) -> Array[Array[Double]] { let n = data.length() let dim = if n > 0 { data[0].length() } else { 0 } - + let means : Array[Double] = Array::new() let mut i = 0 while i < dim { @@ -75,7 +85,7 @@ pub fn sc3_pca(data : Array[Array[Double]], n_components : Int) -> Array[Array[D means.push(sum / n.to_double()) i = i + 1 } - + let centered : Array[Array[Double]] = Array::new() let mut k = 0 while k < n { @@ -88,7 +98,7 @@ pub fn sc3_pca(data : Array[Array[Double]], n_components : Int) -> Array[Array[D centered.push(row) k = k + 1 } - + let covariance : Array[Array[Double]] = Array::new() let mut m = 0 while m < dim { @@ -107,9 +117,9 @@ pub fn sc3_pca(data : Array[Array[Double]], n_components : Int) -> Array[Array[D covariance.push(row) m = m + 1 } - + let eigenvalues = sc3_power_iteration(covariance, n_components) - + let components : Array[Array[Double]] = Array::new() let mut r = 0 while r < n_components && r < eigenvalues.length() { @@ -128,7 +138,7 @@ pub fn sc3_pca(data : Array[Array[Double]], n_components : Int) -> Array[Array[D components.push(component) r = r + 1 } - + let transposed : Array[Array[Double]] = Array::new() let mut u = 0 while u < n { @@ -141,25 +151,28 @@ pub fn sc3_pca(data : Array[Array[Double]], n_components : Int) -> Array[Array[D transposed.push(row) u = u + 1 } - + transposed } ///| /// Power iteration for eigenvalue decomposition. -pub fn sc3_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> Array[Array[Double]] { +pub fn sc3_power_iteration( + matrix : Array[Array[Double]], + n_components : Int, +) -> Array[Array[Double]] { let n = matrix.length() let components : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_components { let v : Array[Double] = Array::new() let mut j = 0 while j < n { - v.push(((i + 1).to_double() / (j + 1).to_double()) - 0.5) + v.push((i + 1).to_double() / (j + 1).to_double() - 0.5) j = j + 1 } - + let mut iter = 0 while iter < 100 { let v_new : Array[Double] = Array::new() @@ -174,7 +187,7 @@ pub fn sc3_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> v_new.push(sum) k = k + 1 } - + let mut norm = 0.0 let mut m = 0 while m < n { @@ -182,18 +195,18 @@ pub fn sc3_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> m = m + 1 } norm = norm.sqrt() - + let mut p = 0 while p < n { v.set(p, v_new[p] / norm) p = p + 1 } - + iter = iter + 1 } - + components.push(v) - + let mut q = 0 while q < n { let mut r = 0 @@ -209,10 +222,10 @@ pub fn sc3_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> } q = q + 1 } - + i = i + 1 } - + components } @@ -221,10 +234,10 @@ pub fn sc3_power_iteration(matrix : Array[Array[Double]], n_components : Int) -> pub fn sc3_calculate_consensus_matrix( data : Array[Array[Double]], k : Int, - n_iterations : Int + n_iterations : Int, ) -> Array[Array[Double]] { let n = data.length() - + let consensus : Array[Array[Double]] = Array::new() let mut i = 0 while i < n { @@ -237,11 +250,11 @@ pub fn sc3_calculate_consensus_matrix( consensus.push(row) i = i + 1 } - + let mut iter = 0 while iter < n_iterations { let labels = sc3_kmeans(data, k) - + let mut a = 0 while a < n { let mut b = 0 @@ -253,10 +266,10 @@ pub fn sc3_calculate_consensus_matrix( } a = a + 1 } - + iter = iter + 1 } - + let mut x = 0 while x < n { let mut y = 0 @@ -266,7 +279,7 @@ pub fn sc3_calculate_consensus_matrix( } x = x + 1 } - + consensus } @@ -275,31 +288,31 @@ pub fn sc3_calculate_consensus_matrix( pub fn sc3_kmeans(data : Array[Array[Double]], k : Int) -> Array[Int] { let n = data.length() let dim = if n > 0 { data[0].length() } else { 0 } - + let centroids : Array[Array[Double]] = Array::new() let mut c = 0 while c < k && c < n { centroids.push(data[c]) c = c + 1 } - + let labels : Array[Int] = Array::new() let mut j = 0 while j < n { labels.push(0) j = j + 1 } - + let mut changed = true let mut iterations = 0 while changed && iterations < 100 { changed = false - + let mut p = 0 while p < n { let mut min_dist = 10000000000.0 let mut best_cluster = 0 - + let mut q = 0 while q < centroids.length() { let dist = sc3_euclidean_distance(data[p], centroids[q]) @@ -309,14 +322,14 @@ pub fn sc3_kmeans(data : Array[Array[Double]], k : Int) -> Array[Int] { } q = q + 1 } - + if labels[p] != best_cluster { labels.set(p, best_cluster) changed = true } p = p + 1 } - + let mut r = 0 while r < centroids.length() { let sum : Array[Double] = Array::new() @@ -325,7 +338,7 @@ pub fn sc3_kmeans(data : Array[Array[Double]], k : Int) -> Array[Int] { sum.push(0.0) s = s + 1 } - + let mut count = 0 let mut t = 0 while t < n { @@ -339,7 +352,7 @@ pub fn sc3_kmeans(data : Array[Array[Double]], k : Int) -> Array[Int] { } t = t + 1 } - + if count > 0 { let mut v = 0 while v < dim { @@ -349,10 +362,10 @@ pub fn sc3_kmeans(data : Array[Array[Double]], k : Int) -> Array[Int] { } r = r + 1 } - + iterations = iterations + 1 } - + labels } @@ -374,15 +387,15 @@ pub fn sc3_euclidean_distance(v1 : Array[Double], v2 : Array[Double]) -> Double pub fn sc3_calculate_silhouette( data : Array[Array[Double]], labels : Array[Int], - k : Int + k : Int, ) -> Array[Double] { let n = data.length() let scores : Array[Double] = Array::new() - + let mut i = 0 while i < n { let label = labels[i] - + let mut a_sum = 0.0 let mut a_count = 0 let mut j = 0 @@ -394,7 +407,7 @@ pub fn sc3_calculate_silhouette( j = j + 1 } let a = if a_count > 0 { a_sum / a_count.to_double() } else { 0.0 } - + let mut b_min = 10000000000.0 let mut c = 0 while c < k { @@ -418,17 +431,17 @@ pub fn sc3_calculate_silhouette( } c = c + 1 } - + let max_ab = if a > b_min { a } else { b_min } if max_ab > 0.0 { scores.push((b_min - a) / max_ab) } else { scores.push(0.0) } - + i = i + 1 } - + scores } @@ -436,16 +449,16 @@ pub fn sc3_calculate_silhouette( /// Calculate gap statistics. pub fn sc3_calculate_gap_statistics( data : Array[Array[Double]], - k : Int + k : Int, ) -> Array[Double] { let n = data.length() - + let gaps : Array[Double] = Array::new() - + let mut current_k = 1 while current_k <= k { let w = sc3_calculate_wcss(data, current_k) - + let mut w_null_sum = 0.0 let mut b = 0 while b < 10 { @@ -454,12 +467,12 @@ pub fn sc3_calculate_gap_statistics( w_null_sum = w_null_sum + @math.ln(w_null) b = b + 1 } - + gaps.push(w_null_sum / 10.0 - @math.ln(w)) - + current_k = current_k + 1 } - + gaps } @@ -469,7 +482,7 @@ pub fn sc3_calculate_wcss(data : Array[Array[Double]], k : Int) -> Double { let labels = sc3_kmeans(data, k) let n = data.length() let dim = if n > 0 { data[0].length() } else { 0 } - + let centroids : Array[Array[Double]] = Array::new() let mut i = 0 while i < k { @@ -482,14 +495,14 @@ pub fn sc3_calculate_wcss(data : Array[Array[Double]], k : Int) -> Double { centroids.push(centroid) i = i + 1 } - + let counts : Array[Int] = Array::new() let mut c = 0 while c < k { counts.push(0) c = c + 1 } - + let mut m = 0 while m < n { let label = labels[m] @@ -501,7 +514,7 @@ pub fn sc3_calculate_wcss(data : Array[Array[Double]], k : Int) -> Double { counts.set(label, counts[label] + 1) m = m + 1 } - + let mut q = 0 while q < k { if counts[q] > 0 { @@ -513,7 +526,7 @@ pub fn sc3_calculate_wcss(data : Array[Array[Double]], k : Int) -> Double { } q = q + 1 } - + let mut wcss = 0.0 let mut s = 0 while s < n { @@ -521,19 +534,22 @@ pub fn sc3_calculate_wcss(data : Array[Array[Double]], k : Int) -> Double { wcss = wcss + sc3_euclidean_distance(data[s], centroids[label]).pow(2) s = s + 1 } - + wcss } ///| /// Generate null data for gap statistics. -pub fn sc3_generate_null_data(data : Array[Array[Double]], seed : Int) -> Array[Array[Double]] { +pub fn sc3_generate_null_data( + data : Array[Array[Double]], + seed : Int, +) -> Array[Array[Double]] { let n = data.length() let dim = if n > 0 { data[0].length() } else { 0 } - + let mins : Array[Double] = Array::new() let maxes : Array[Double] = Array::new() - + let mut j = 0 while j < dim { let mut min_val = 10000000000.0 @@ -549,14 +565,14 @@ pub fn sc3_generate_null_data(data : Array[Array[Double]], seed : Int) -> Array[ maxes.push(max_val) j = j + 1 } - + let null_data : Array[Array[Double]] = Array::new() let mut k = 0 while k < n { let row : Array[Double] = Array::new() let mut l = 0 while l < dim { - let state = (seed * 1103515245 + k * 12345 + l * 98765) >> 16 & 0x7fff + let state = ((seed * 1103515245 + k * 12345 + l * 98765) >> 16) & 0x7fff let rand_val = state.to_double() / 32767.0 row.push(mins[l] + rand_val * (maxes[l] - mins[l])) l = l + 1 @@ -564,7 +580,7 @@ pub fn sc3_generate_null_data(data : Array[Array[Double]], seed : Int) -> Array[ null_data.push(row) k = k + 1 } - + null_data } @@ -574,43 +590,53 @@ pub fn sc3_consensus_cluster( data : Array[Array[Double]], k : Int, n_iterations? : Int = 100, - n_pcs? : Int = 50 + n_pcs? : Int = 50, ) -> SC3Result { let processed = sc3_preprocess(data) let pcs = sc3_pca(processed, n_pcs) - + let consensus_matrix = sc3_calculate_consensus_matrix(pcs, k, n_iterations) let cluster_labels = sc3_kmeans(pcs, k) let silhouette_scores = sc3_calculate_silhouette(pcs, cluster_labels, k) let gap_statistics = sc3_calculate_gap_statistics(pcs, k) - + let mut optimal_k = k let mut max_gap_diff = 0.0 let mut g = 1 while g < gap_statistics.length() { - let diff = gap_statistics[g] - gap_statistics[g-1] + let diff = gap_statistics[g] - gap_statistics[g - 1] if diff > max_gap_diff { max_gap_diff = diff optimal_k = g + 1 } g = g + 1 } - - SC3Result::new(cluster_labels, consensus_matrix, k, silhouette_scores, gap_statistics, optimal_k) + + SC3Result::new( + cluster_labels, consensus_matrix, k, silhouette_scores, gap_statistics, optimal_k, + ) } ///| /// Bio API functions. - pub fn bio_sc3_cluster(data : Array[Array[Double]], k : Int) -> SC3Result { sc3_consensus_cluster(data, k) } -pub fn bio_sc3_pca(data : Array[Array[Double]], n_components : Int) -> Array[Array[Double]] { +///| +pub fn bio_sc3_pca( + data : Array[Array[Double]], + n_components : Int, +) -> Array[Array[Double]] { let processed = sc3_preprocess(data) sc3_pca(processed, n_components) } -pub fn bio_sc3_silhouette(data : Array[Array[Double]], labels : Array[Int], k : Int) -> Array[Double] { +///| +pub fn bio_sc3_silhouette( + data : Array[Array[Double]], + labels : Array[Int], + k : Int, +) -> Array[Double] { sc3_calculate_silhouette(data, labels, k) -} \ No newline at end of file +} diff --git a/src/sc_dbl_finder.mbt b/src/sc_dbl_finder.mbt index dd3c832a..fe6ce66f 100644 --- a/src/sc_dbl_finder.mbt +++ b/src/sc_dbl_finder.mbt @@ -114,7 +114,7 @@ pub fn scdf_sort_by_distance( if n <= 1 { return sorted } - + let mut i = 0 while i < n - 1 { let min_idx = scdf_find_min(sorted, i, n) @@ -129,11 +129,7 @@ pub fn scdf_sort_by_distance( } ///| -fn scdf_find_min( - arr : Array[(String, Double)], - start : Int, - end : Int, -) -> Int { +fn scdf_find_min(arr : Array[(String, Double)], start : Int, end : Int) -> Int { let mut min_idx = start let mut i = start + 1 while i < end { diff --git a/src/scenic.mbt b/src/scenic.mbt index 121ffbba..84ab8d24 100644 --- a/src/scenic.mbt +++ b/src/scenic.mbt @@ -23,7 +23,7 @@ pub struct CoExpressionModule { tf_name : String targets : Array[String] - weights : Array[Double] // importance weights, parallel to targets + weights : Array[Double] // importance weights, parallel to targets } derive(Debug) ///| @@ -33,7 +33,7 @@ pub fn co_expression_module( targets : Array[String], weights : Array[Double], ) -> CoExpressionModule { - { tf_name: tf_name, targets: targets, weights: weights } + { tf_name, targets, weights } } ///| @@ -41,7 +41,7 @@ pub fn co_expression_module( pub struct ScenicRegulon { tf_name : String targets : Array[String] - weights : Array[Double] // weight per target (from GRN importance) + weights : Array[Double] // weight per target (from GRN importance) n_targets : Int } derive(Debug) @@ -52,12 +52,7 @@ pub fn scenic_regulon( targets : Array[String], weights : Array[Double], ) -> ScenicRegulon { - { - tf_name: tf_name, - targets: targets, - weights: weights, - n_targets: targets.length(), - } + { tf_name, targets, weights, n_targets: targets.length() } } ///| @@ -65,7 +60,7 @@ pub fn scenic_regulon( pub struct AUCEntry { regulon_name : String cell_name : String - auc : Double // normalized AUC in [0, 1] + auc : Double // normalized AUC in [0, 1] } ///| @@ -73,16 +68,16 @@ pub struct AUCEntry { pub struct SCENICInput { n_genes : Int n_cells : Int - expression : Array[Array[Double]] // gene x cell (row=gene, col=cell) + expression : Array[Array[Double]] // gene x cell (row=gene, col=cell) gene_names : Array[String] cell_names : Array[String] - tf_names : Array[String] // subset of gene_names that are TFs + tf_names : Array[String] // subset of gene_names that are TFs } derive(Debug) ///| /// Create SCENIC input from expression matrix and metadata. pub fn scenic_input( - expression : Array[Array[Double]], // gene x cell + expression : Array[Array[Double]], // gene x cell gene_names : Array[String], cell_names : Array[String], tf_names : Array[String], @@ -90,10 +85,10 @@ pub fn scenic_input( { n_genes: gene_names.length(), n_cells: cell_names.length(), - expression: expression, - gene_names: gene_names, - cell_names: cell_names, - tf_names: tf_names, + expression, + gene_names, + cell_names, + tf_names, } } @@ -103,14 +98,14 @@ pub struct SCENICResult { regulons : Array[ScenicRegulon] n_regulons : Int n_cells : Int - auc_matrix : Array[Array[Double]] // regulon x cell + auc_matrix : Array[Array[Double]] // regulon x cell regulon_names : Array[String] cell_names : Array[String] - binary_matrix : Array[Array[Int]] // regulon x cell (0/1) - thresholds : Array[Double] // per-regulon binarization threshold - cell_states : Array[Int] // cluster label per cell + binary_matrix : Array[Array[Int]] // regulon x cell (0/1) + thresholds : Array[Double] // per-regulon binarization threshold + cell_states : Array[Int] // cluster label per cell n_clusters : Int - master_regulators : Array[(String, Int)] // (TF name, cluster index) + master_regulators : Array[(String, Int)] // (TF name, cluster index) } // ============================================================================ @@ -148,14 +143,21 @@ pub fn build_coexpression_modules( // Find TF row index let mut tf_row = -1 for k in 0.. Double { let n = a.length() - if n == 0 || n != b.length() { return 0.0 } + if n == 0 || n != b.length() { + return 0.0 + } let mut sum_a = 0.0 let mut sum_b = 0.0 - for i in 0.. Double { var_b += db * db } let denom = (var_a * var_b).sqrt() - if denom < 1.0e-12 { 0.0 } - else { (cov / denom).abs() } + if denom < 1.0e-12 { + 0.0 + } else { + (cov / denom).abs() + } } +///| /// Sort (String, Double) pairs by Double value descending (selection sort). fn scenic_sort_pairs_desc(arr : Array[(String, Double)]) -> Unit { let n = arr.length() @@ -209,7 +223,9 @@ fn scenic_sort_pairs_desc(arr : Array[(String, Double)]) -> Unit { for j in (i + 1).. vmax { max_idx = j } + if vj > vmax { + max_idx = j + } } if max_idx != i { let tmp = arr[i] @@ -282,8 +298,11 @@ pub fn prune_by_motif_ranking( rank_threshold? : Int = 0, ) -> ScenicRegulon { let n_ranked = motif_ranked_genes.length() - let effective_threshold = if rank_threshold > 0 { rank_threshold } - else { (n_ranked.to_double() * 0.05).to_int() } + let effective_threshold = if rank_threshold > 0 { + rank_threshold + } else { + (n_ranked.to_double() * 0.05).to_int() + } // Build set of top-ranked genes let top_genes_keys : Array[String] = [] let _top_vals : Array[Int] = [] @@ -299,7 +318,10 @@ pub fn prune_by_motif_ranking( let target = module.targets[i] let mut found = false for k in 0.. Unit { let n = arr.length() for i in 1.. Unit { ///| /// Build gene rankings for each cell (genes sorted by expression, highest first). /// Returns a matrix of gene indices, cell x gene (each row is a cell's ranking). -pub fn build_cell_rankings( - input : SCENICInput, -) -> Array[Array[Int]] { +pub fn build_cell_rankings(input : SCENICInput) -> Array[Array[Int]] { let rankings : Array[Array[Int]] = [] for c in 0.. expr[indices[max_idx]] { max_idx = j } + if expr[indices[j]] > expr[indices[max_idx]] { + max_idx = j + } } if max_idx != i { let tmp = indices[i] @@ -375,10 +400,15 @@ fn compute_auc( auc_max_rank : Int, ) -> Double { let n_targets = target_indices.length() - if n_targets == 0 { return 0.0 } + if n_targets == 0 { + return 0.0 + } let n_genes = gene_ranking.length() - let max_rank = if auc_max_rank > 0 && auc_max_rank < n_genes { auc_max_rank } - else { n_genes } + let max_rank = if auc_max_rank > 0 && auc_max_rank < n_genes { + auc_max_rank + } else { + n_genes + } // Build a set of target gene indices for O(1) lookup let target_set : Array[Int] = target_indices.copy() // Count how many targets appear in top max_rank positions @@ -389,7 +419,10 @@ fn compute_auc( let gene_idx = gene_ranking[i] let mut is_target = false for t in 0..= 0 { + target_indices.push(found) } - if found >= 0 { target_indices.push(found) } } // Compute AUC for each cell let row : Array[Double] = [] @@ -472,16 +510,18 @@ pub fn binarize_activity( let threshold = match method { BinarizeMethod::MeanStd => { let mut sum = 0.0 - for v in row { sum += v } + for v in row { + sum += v + } let mean = sum / n_cells.to_double() let mut sq_sum = 0.0 - for v in row { sq_sum += (v - mean) * (v - mean) } + for v in row { + sq_sum += (v - mean) * (v - mean) + } let std = (sq_sum / n_cells.to_double()).sqrt() mean + 0.5 * std } - BinarizeMethod::KMeans2 => { - scenic_kmeans_threshold(row) - } + BinarizeMethod::KMeans2 => scenic_kmeans_threshold(row) BinarizeMethod::Median => { let sorted = row.copy() scenic_sort_doubles_asc(sorted) @@ -491,7 +531,11 @@ pub fn binarize_activity( thresholds.push(threshold) let bin_row : Array[Int] = [] for c in 0.. threshold { bin_row.push(1) } else { bin_row.push(0) } + if row[c] > threshold { + bin_row.push(1) + } else { + bin_row.push(0) + } } binary.push(bin_row) } @@ -524,19 +568,30 @@ pub fn binarize_median() -> BinarizeMethod { BinarizeMethod::Median } +///| /// Simple 1D k-means with k=2 to find threshold for bimodal distribution. fn scenic_kmeans_threshold(values : Array[Double]) -> Double { let n = values.length() - if n == 0 { return 0.0 } - if n == 1 { return values[0] } + if n == 0 { + return 0.0 + } + if n == 1 { + return values[0] + } // Initialize centroids: min and max let mut c1 = values[0] let mut c2 = values[0] for v in values { - if v < c1 { c1 = v } - if v > c2 { c2 = v } + if v < c1 { + c1 = v + } + if v > c2 { + c2 = v + } + } + if c1 == c2 { + return c1 } - if c1 == c2 { return c1 } // Iterate k-means for _iter in 0..<20 { let mut sum1 = 0.0 @@ -546,13 +601,22 @@ fn scenic_kmeans_threshold(values : Array[Double]) -> Double { for v in values { let d1 = (v - c1).abs() let d2 = (v - c2).abs() - if d1 < d2 { sum1 += v; count1 = count1 + 1 } - else { sum2 += v; count2 = count2 + 1 } + if d1 < d2 { + sum1 += v + count1 = count1 + 1 + } else { + sum2 += v + count2 = count2 + 1 + } + } + if count1 == 0 || count2 == 0 { + break } - if count1 == 0 || count2 == 0 { break } let new_c1 = sum1 / count1.to_double() let new_c2 = sum2 / count2.to_double() - if (new_c1 - c1).abs() < 1.0e-9 && (new_c2 - c2).abs() < 1.0e-9 { break } + if (new_c1 - c1).abs() < 1.0e-9 && (new_c2 - c2).abs() < 1.0e-9 { + break + } c1 = new_c1 c2 = new_c2 } @@ -583,20 +647,24 @@ pub fn assign_cell_states( for r in 0.. max_cluster { max_cluster = l } + if l > max_cluster { + max_cluster = l + } } // Master regulators: (regulon_name, cluster_index) let masters : Array[(String, Int)] = [] @@ -604,7 +672,9 @@ pub fn assign_cell_states( let cluster = r + 1 let mut count = 0 for c in 0.. 0 { masters.push((regulon_names[r], cluster)) @@ -636,36 +706,34 @@ pub fn run_scenic( binarize_method? : BinarizeMethod = BinarizeMethod::MeanStd, ) -> SCENICResult { // Step 1: Build co-expression modules - let modules = build_coexpression_modules( - input, min_targets=min_targets, top_k=top_k, - ) + let modules = build_coexpression_modules(input, min_targets~, top_k~) // Step 2: Build regulons - let regulons = build_regulons( - modules, weight_quantile=weight_quantile, min_targets=min_targets, - ) + let regulons = build_regulons(modules, weight_quantile~, min_targets~) // Step 3: Compute regulon activity (AUC matrix) - let auc_matrix = compute_regulon_activity( - regulons, input, auc_threshold_pct=auc_threshold_pct, - ) + let auc_matrix = compute_regulon_activity(regulons, input, auc_threshold_pct~) // Step 4: Binarize and assign cell states let (binary_matrix, thresholds) = binarize_activity( - auc_matrix, input.n_cells, method=binarize_method, + auc_matrix, + input.n_cells, + method=binarize_method, ) - let regulon_names = regulons.map(fn (r) -> String { r.tf_name }) + let regulon_names = regulons.map(fn(r) -> String { r.tf_name }) let (cell_states, n_clusters, masters) = assign_cell_states( - binary_matrix, regulon_names, input.n_cells, + binary_matrix, + regulon_names, + input.n_cells, ) { - regulons: regulons, + regulons, n_regulons: regulons.length(), n_cells: input.n_cells, - auc_matrix: auc_matrix, - regulon_names: regulon_names, + auc_matrix, + regulon_names, cell_names: input.cell_names, - binary_matrix: binary_matrix, - thresholds: thresholds, - cell_states: cell_states, - n_clusters: n_clusters, + binary_matrix, + thresholds, + cell_states, + n_clusters, master_regulators: masters, } } @@ -690,7 +758,7 @@ pub fn scenic_sample_data( seed? : Int = 42, ) -> SCENICInput { let mut rng = seed - let next_rand = fn () -> Double { + let next_rand = fn() -> Double { rng = (rng * 1103515245 + 12345) & 0x7fffffff (rng & 0xffffff).to_double() / 16777215.0 } @@ -716,9 +784,13 @@ pub fn scenic_sample_data( for t in 0..= n_cells / 2 { 5.0 } - else { 1.0 + next_rand() * 0.5 } + let base = if t == 0 && c < n_cells / 2 { + 5.0 + } else if t == 1 && c >= n_cells / 2 { + 5.0 + } else { + 1.0 + next_rand() * 0.5 + } profile.push(base) } tf_activity.push(profile) @@ -753,50 +825,83 @@ pub fn scenic_sample_data( ///| /// Get the AUC score for a specific regulon and cell. -pub fn SCENICResult::auc_at(self : SCENICResult, regulon_idx : Int, cell_idx : Int) -> Double { - if regulon_idx < 0 || regulon_idx >= self.n_regulons { return 0.0 } - if cell_idx < 0 || cell_idx >= self.n_cells { return 0.0 } +pub fn SCENICResult::auc_at( + self : SCENICResult, + regulon_idx : Int, + cell_idx : Int, +) -> Double { + if regulon_idx < 0 || regulon_idx >= self.n_regulons { + return 0.0 + } + if cell_idx < 0 || cell_idx >= self.n_cells { + return 0.0 + } self.auc_matrix[regulon_idx][cell_idx] } ///| /// Get the binary activity (0 or 1) for a specific regulon and cell. -pub fn SCENICResult::binary_at(self : SCENICResult, regulon_idx : Int, cell_idx : Int) -> Int { - if regulon_idx < 0 || regulon_idx >= self.n_regulons { return 0 } - if cell_idx < 0 || cell_idx >= self.n_cells { return 0 } +pub fn SCENICResult::binary_at( + self : SCENICResult, + regulon_idx : Int, + cell_idx : Int, +) -> Int { + if regulon_idx < 0 || regulon_idx >= self.n_regulons { + return 0 + } + if cell_idx < 0 || cell_idx >= self.n_cells { + return 0 + } self.binary_matrix[regulon_idx][cell_idx] } ///| /// Get the cell state (cluster label) for a specific cell. pub fn SCENICResult::cell_state(self : SCENICResult, cell_idx : Int) -> Int { - if cell_idx < 0 || cell_idx >= self.n_cells { return 0 } + if cell_idx < 0 || cell_idx >= self.n_cells { + return 0 + } self.cell_states[cell_idx] } ///| /// Return a summary string of the SCENIC result. pub fn SCENICResult::summary(self : SCENICResult) -> String { - "SCENICResult(regulons=" + self.n_regulons.to_string() + - ", cells=" + self.n_cells.to_string() + - ", clusters=" + self.n_clusters.to_string() + - ", master_regulators=" + self.master_regulators.length().to_string() + ")" + "SCENICResult(regulons=" + + self.n_regulons.to_string() + + ", cells=" + + self.n_cells.to_string() + + ", clusters=" + + self.n_clusters.to_string() + + ", master_regulators=" + + self.master_regulators.length().to_string() + + ")" } ///| /// Get regulon targets as an array of gene names. -pub fn SCENICResult::regulon_targets(self : SCENICResult, regulon_idx : Int) -> Array[String] { - if regulon_idx < 0 || regulon_idx >= self.n_regulons { return [] } +pub fn SCENICResult::regulon_targets( + self : SCENICResult, + regulon_idx : Int, +) -> Array[String] { + if regulon_idx < 0 || regulon_idx >= self.n_regulons { + return [] + } self.regulons[regulon_idx].targets.copy() } ///| /// Get the top-N regulons by mean AUC across all cells. -pub fn SCENICResult::top_regulons(self : SCENICResult, n? : Int = 5) -> Array[(String, Double)] { +pub fn SCENICResult::top_regulons( + self : SCENICResult, + n? : Int = 5, +) -> Array[(String, Double)] { let pairs : Array[(String, Double)] = [] for r in 0.. Array[String] { ///| /// Get expression matrix (gene × cell). -pub fn ScmapReference::expression(self : ScmapReference) -> Array[Array[Double]] { +pub fn ScmapReference::expression( + self : ScmapReference, +) -> Array[Array[Double]] { self.expression } ///| /// Get unique cell types in the reference. -pub fn ScmapReference::unique_cell_types(self : ScmapReference) -> Array[String] { +pub fn ScmapReference::unique_cell_types( + self : ScmapReference, +) -> Array[String] { let types : Array[String] = [] for t in self.cell_types { let mut found = false @@ -167,7 +171,9 @@ pub fn ScmapAssignment::best_correlation(self : ScmapAssignment) -> Double { ///| /// Get second-best correlation score. -pub fn ScmapAssignment::second_best_correlation(self : ScmapAssignment) -> Double { +pub fn ScmapAssignment::second_best_correlation( + self : ScmapAssignment, +) -> Double { self.second_best_correlation } @@ -202,9 +208,7 @@ fn scmap_extract_cell( ///| /// Compute the centroid (mean expression) for each cell type. /// Returns: cell_types × genes centroid matrix (as Array of cell-type vectors). -fn scmap_centroids( - ref : ScmapReference, -) -> Array[(String, Array[Double])] { +fn scmap_centroids(ref : ScmapReference) -> Array[(String, Array[Double])] { let unique_types = ref.unique_cell_types() let n_genes = ref.gene_names.length() let centroids : Array[(String, Array[Double])] = [] @@ -404,7 +408,9 @@ pub fn scmap_cell( ///| /// Summarise classification results: count cells per assigned type. -pub fn scmap_summary(assignments : Array[ScmapAssignment]) -> Array[(String, Int)] { +pub fn scmap_summary( + assignments : Array[ScmapAssignment], +) -> Array[(String, Int)] { let types : Array[String] = [] let counts : Array[Int] = [] for a in assignments { @@ -431,7 +437,14 @@ pub fn scmap_summary(assignments : Array[ScmapAssignment]) -> Array[(String, Int ///| /// Format an assignment as a readable string. pub fn ScmapAssignment::to_string(self : ScmapAssignment) -> String { - self.cell_name + " -> " + self.assigned_type + " (corr=" + self.best_correlation.to_string() + ", method=" + self.method + ")" + self.cell_name + + " -> " + + self.assigned_type + + " (corr=" + + self.best_correlation.to_string() + + ", method=" + + self.method + + ")" } ///| @@ -439,10 +452,20 @@ pub fn ScmapAssignment::to_string(self : ScmapAssignment) -> String { pub fn scmap_assignments_to_string( assignments : Array[ScmapAssignment], ) -> String { - let mut s = "scmap Assignments (" + assignments.length().to_string() + " cells)\n" + let mut s = "scmap Assignments (" + + assignments.length().to_string() + + " cells)\n" s = s + "cell\tassigned_type\tbest_corr\tmethod\n" for a in assignments { - s = s + a.cell_name + "\t" + a.assigned_type + "\t" + a.best_correlation.to_string() + "\t" + a.method + "\n" + s = s + + a.cell_name + + "\t" + + a.assigned_type + + "\t" + + a.best_correlation.to_string() + + "\t" + + a.method + + "\n" } s } @@ -456,13 +479,13 @@ pub fn scmap_assignments_to_string( /// 10 genes, 9 reference cells. pub fn scmap_sample_reference() -> ScmapReference { let gene_names = [ - "GENE1", "GENE2", "GENE3", "GENE4", "GENE5", "GENE6", "GENE7", "GENE8", "GENE9", "GENE10", - ] - let cell_names = [ - "T1", "T2", "T3", "B1", "B2", "B3", "N1", "N2", "N3", + "GENE1", "GENE2", "GENE3", "GENE4", "GENE5", "GENE6", "GENE7", "GENE8", "GENE9", + "GENE10", ] + let cell_names = ["T1", "T2", "T3", "B1", "B2", "B3", "N1", "N2", "N3"] let cell_types = [ - "T_cell", "T_cell", "T_cell", "B_cell", "B_cell", "B_cell", "NK_cell", "NK_cell", "NK_cell", + "T_cell", "T_cell", "T_cell", "B_cell", "B_cell", "B_cell", "NK_cell", "NK_cell", + "NK_cell", ] // gene × cell expression matrix (10 genes × 9 cells) // T cells: high GENE1-3, low GENE4-6, GENE7-10 = 0 @@ -473,7 +496,7 @@ pub fn scmap_sample_reference() -> ScmapReference { for g in 0..<3 { let row : Array[Double] = [] for c in 0..<9 { - let val = if c < 3 { 8.0 + (c.to_double() * 0.5) } else { 0.5 } + let val = if c < 3 { 8.0 + c.to_double() * 0.5 } else { 0.5 } row.push(val) } expression.push(row) @@ -482,7 +505,7 @@ pub fn scmap_sample_reference() -> ScmapReference { for g in 0..<3 { let row : Array[Double] = [] for c in 0..<9 { - let val = if c >= 3 && c < 6 { 8.0 + (c.to_double() * 0.5) } else { 0.5 } + let val = if c >= 3 && c < 6 { 8.0 + c.to_double() * 0.5 } else { 0.5 } row.push(val) } expression.push(row) @@ -491,7 +514,7 @@ pub fn scmap_sample_reference() -> ScmapReference { for g in 0..<4 { let row : Array[Double] = [] for c in 0..<9 { - let val = if c >= 6 { 8.0 + (c.to_double() * 0.5) } else { 0.5 } + let val = if c >= 6 { 8.0 + c.to_double() * 0.5 } else { 0.5 } row.push(val) } expression.push(row) @@ -503,7 +526,8 @@ pub fn scmap_sample_reference() -> ScmapReference { /// Generate 3 query cells: one clearly T, one clearly B, one ambiguous. pub fn scmap_sample_query() -> ScmapQuery { let gene_names = [ - "GENE1", "GENE2", "GENE3", "GENE4", "GENE5", "GENE6", "GENE7", "GENE8", "GENE9", "GENE10", + "GENE1", "GENE2", "GENE3", "GENE4", "GENE5", "GENE6", "GENE7", "GENE8", "GENE9", + "GENE10", ] let cell_names = ["query_T", "query_B", "query_unknown"] // gene × cell (10 genes × 3 query cells) diff --git a/src/scnorm.mbt b/src/scnorm.mbt index e95ce786..25629152 100644 --- a/src/scnorm.mbt +++ b/src/scnorm.mbt @@ -3,6 +3,7 @@ /// Provides single-cell RNA-seq normalization using quantile regression /// to correct for depth-dependent bias in single-cell data. +///| /// Normalization method pub enum SCnormMethod { /// Quantile regression normalization @@ -13,6 +14,7 @@ pub enum SCnormMethod { Spline } +///| /// Gene filtering method pub enum SCnormFilterMethod { /// Filter by expression threshold @@ -21,6 +23,7 @@ pub enum SCnormFilterMethod { Percent } +///| /// Result of quantile regression pub struct SCnormQuantFit { /// Slope coefficient @@ -35,6 +38,7 @@ pub struct SCnormQuantFit { tau : Double } +///| /// Normalization result for a gene pub struct SCnormGeneNormResult { /// Gene ID @@ -49,6 +53,7 @@ pub struct SCnormGeneNormResult { filter_reason : String } +///| /// Complete SCnorm result pub struct SCnormResult { /// Gene normalization results @@ -67,6 +72,7 @@ pub struct SCnormResult { norm_method : SCnormMethod } +///| /// Parameters for SCnorm normalization pub struct SCnormParams { /// Quantile level for regression (0-1) @@ -81,6 +87,7 @@ pub struct SCnormParams { robust : Bool } +///| /// Create default parameters pub fn SCnormParams::new() -> SCnormParams { SCnormParams::{ @@ -88,7 +95,7 @@ pub fn SCnormParams::new() -> SCnormParams { filter_genes: true, min_expr: 0.1, min_percent: 0.1, - robust: true + robust: true, } } @@ -100,7 +107,7 @@ pub fn SCnormParams::new() -> SCnormParams { pub fn sc_norm_quantile_regression( x : Array[Double], y : Array[Double], - tau : Double + tau : Double, ) -> SCnormQuantFit { let n = x.length() if n == 0 { @@ -109,7 +116,7 @@ pub fn sc_norm_quantile_regression( intercept: 0.0, fitted: Array::new(), residuals: Array::new(), - tau + tau, } } // Compute depth (x-axis) and log-counts (y-axis) @@ -124,21 +131,21 @@ pub fn sc_norm_quantile_regression( residuals.push(y[i] - f) i = i + 1 } - SCnormQuantFit::{ - slope, - intercept, - fitted, - residuals, - tau - } + SCnormQuantFit::{ slope, intercept, fitted, residuals, tau } } ///| /// Simple quantile regression via grid search. /// Finds slope and intercept that minimize quantile loss. -fn sc_norm_simple_quantile_fit(x : Array[Double], y : Array[Double], tau : Double) -> (Double, Double) { +fn sc_norm_simple_quantile_fit( + x : Array[Double], + y : Array[Double], + tau : Double, +) -> (Double, Double) { let n = x.length() - if n < 2 { return (0.0, if n > 0 { y[0] } else { 0.0 }) } + if n < 2 { + return (0.0, if n > 0 { y[0] } else { 0.0 }) + } // Compute median-based estimates let x_median = sc_norm_median(x) let y_median = sc_norm_median(y) @@ -149,15 +156,19 @@ fn sc_norm_simple_quantile_fit(x : Array[Double], y : Array[Double], tau : Doubl let qx_high = sc_norm_quantile(x, 1.0 - tau * 0.5) let slope_init = if qx_high > qx_low { (qy_high - qy_low) / (qx_high - qx_low) - } else { // Fallback: use median ratio - if x_median > 0.0 { y_median / x_median } else { 0.0 } + } else if x_median > 0.0 { + y_median / x_median + } else { + 0.0 } let intercept_init = y_median - slope_init * x_median // Refine via local search let mut best_slope = slope_init let mut best_intercept = intercept_init - let mut best_loss = sc_norm_quantile_loss(x, y, best_slope, best_intercept, tau) + let mut best_loss = sc_norm_quantile_loss( + x, y, best_slope, best_intercept, tau, + ) // Grid search refinement let scale = if best_slope.abs() > 1.0 { best_slope.abs() } else { 1.0 } let search_range = 0.5 * scale @@ -167,7 +178,9 @@ fn sc_norm_simple_quantile_fit(x : Array[Double], y : Array[Double], tau : Doubl while s <= steps { let test_slope = best_slope - search_range + step_size * s.to_double() // For each slope, find best intercept - let (best_int_for_slope, loss_for_slope) = sc_norm_find_best_intercept(x, y, test_slope, tau) + let (best_int_for_slope, loss_for_slope) = sc_norm_find_best_intercept( + x, y, test_slope, tau, + ) if loss_for_slope < best_loss { best_loss = loss_for_slope best_slope = test_slope @@ -180,7 +193,12 @@ fn sc_norm_simple_quantile_fit(x : Array[Double], y : Array[Double], tau : Doubl ///| /// Find best intercept for a given slope. -fn sc_norm_find_best_intercept(x : Array[Double], y : Array[Double], slope : Double, tau : Double) -> (Double, Double) { +fn sc_norm_find_best_intercept( + x : Array[Double], + y : Array[Double], + slope : Double, + tau : Double, +) -> (Double, Double) { let n = x.length() // Compute residuals at multiple intercepts // Use the median residual as starting point @@ -193,14 +211,26 @@ fn sc_norm_find_best_intercept(x : Array[Double], y : Array[Double], slope : Dou // Sort residuals to find the tau-th quantile let sorted = sc_norm_sort_array(residuals) let idx = (tau * (n.to_double() - 1.0)).to_int() - let intercept = sorted[if idx < 0 { 0 } else { if idx >= n { n - 1 } else { idx } }] + let intercept = sorted[if idx < 0 { + 0 + } else if idx >= n { + n - 1 + } else { + idx + }] let loss = sc_norm_quantile_loss(x, y, slope, intercept, tau) (intercept, loss) } ///| /// Compute quantile loss (pinball loss). -fn sc_norm_quantile_loss(x : Array[Double], y : Array[Double], slope : Double, intercept : Double, tau : Double) -> Double { +fn sc_norm_quantile_loss( + x : Array[Double], + y : Array[Double], + slope : Double, + intercept : Double, + tau : Double, +) -> Double { let n = x.length() let mut loss = 0.0 let mut i = 0 @@ -214,10 +244,13 @@ fn sc_norm_quantile_loss(x : Array[Double], y : Array[Double], slope : Double, i loss } +///| /// Compute median of an array fn sc_norm_median(arr : Array[Double]) -> Double { let n = arr.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let sorted = sc_norm_sort_array(arr) if n % 2 == 1 { sorted[n / 2] @@ -226,16 +259,20 @@ fn sc_norm_median(arr : Array[Double]) -> Double { } } +///| /// Compute quantile of an array fn sc_norm_quantile(arr : Array[Double], q : Double) -> Double { let n = arr.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let sorted = sc_norm_sort_array(arr) let idx = (q * (n.to_double() - 1.0)).to_int() - let idx_clamped = if idx < 0 { 0 } else { if idx >= n { n - 1 } else { idx } } + let idx_clamped = if idx < 0 { 0 } else if idx >= n { n - 1 } else { idx } sorted[idx_clamped] } +///| /// Sort array (simple insertion sort for small arrays) fn sc_norm_sort_array(arr : Array[Double]) -> Array[Double] { let result = arr.copy() @@ -283,7 +320,7 @@ pub fn sc_norm_normalize_gene( gene_id : String, counts : Array[Double], lib_sizes : Array[Double], - params : SCnormParams + params : SCnormParams, ) -> SCnormGeneNormResult { let n = counts.length() // Compute log-transformed counts @@ -298,7 +335,11 @@ pub fn sc_norm_normalize_gene( i = i + 1 } // Fit quantile regression - let quant_fit = sc_norm_quantile_regression(log_lib_sizes, log_counts, params.quantile) + let quant_fit = sc_norm_quantile_regression( + log_lib_sizes, + log_counts, + params.quantile, + ) // Compute normalized counts let norm_counts : Array[Double] = Array::new() let mut j = 0 @@ -317,24 +358,39 @@ pub fn sc_norm_normalize_gene( quant_fit, norm_counts, passed_filter: passed, - filter_reason: reason + filter_reason: reason, } } ///| /// Check if a gene passes filter criteria. -fn sc_norm_check_filter(raw_counts : Array[Double], norm_counts : Array[Double], params : SCnormParams) -> (Bool, String) { - if !params.filter_genes { return (true, "") } +fn sc_norm_check_filter( + raw_counts : Array[Double], + norm_counts : Array[Double], + params : SCnormParams, +) -> (Bool, String) { + if !params.filter_genes { + return (true, "") + } let n = raw_counts.length() let mut n_expressed = 0 let mut i = 0 while i < n { - if raw_counts[i] > params.min_expr { n_expressed = n_expressed + 1 } + if raw_counts[i] > params.min_expr { + n_expressed = n_expressed + 1 + } i = i + 1 } let percent = n_expressed.to_double() / n.to_double() if percent < params.min_percent { - return (false, "Not expressed in enough cells (" + n_expressed.to_string() + "/" + n.to_string() + ")") + return ( + false, + "Not expressed in enough cells (" + + n_expressed.to_string() + + "/" + + n.to_string() + + ")", + ) } (true, "") } @@ -345,7 +401,7 @@ pub fn sc_norm_run( count_matrix : Array[Array[Double]], gene_ids : Array[String], cell_ids : Array[String], - params : SCnormParams + params : SCnormParams, ) -> SCnormResult { let n_genes = count_matrix.length() let n_cells = if n_genes > 0 { count_matrix[0].length() } else { 0 } @@ -358,7 +414,11 @@ pub fn sc_norm_run( let mut g = 0 while g < n_genes { let gene_counts = count_matrix[g] - let gene_id = if g < gene_ids.length() { gene_ids[g] } else { "gene_" + g.to_string() } + let gene_id = if g < gene_ids.length() { + gene_ids[g] + } else { + "gene_" + g.to_string() + } let result = sc_norm_normalize_gene(gene_id, gene_counts, lib_sizes, params) gene_results.push(result) if result.passed_filter { @@ -374,7 +434,11 @@ pub fn sc_norm_run( cell_ids, lib_sizes, quantile_level: params.quantile, - norm_method: if params.robust { SCnormMethod::Quantile } else { SCnormMethod::Loess } + norm_method: if params.robust { + SCnormMethod::Quantile + } else { + SCnormMethod::Loess + }, } } @@ -382,9 +446,15 @@ pub fn sc_norm_run( ///| /// Simple LOESS (locally weighted smoothing) for 1D data. -pub fn sc_norm_loess_smooth(x : Array[Double], y : Array[Double], span : Double) -> Array[Double] { +pub fn sc_norm_loess_smooth( + x : Array[Double], + y : Array[Double], + span : Double, +) -> Array[Double] { let n = x.length() - if n < 3 { return y.copy() } + if n < 3 { + return y.copy() + } let smoothed : Array[Double] = Array::new() let mut i = 0 while i < n { @@ -414,8 +484,14 @@ pub fn sc_norm_loess_smooth(x : Array[Double], y : Array[Double], span : Double) let dist = (xn - xi).abs() let weight = if half_span > 0.0 { let u = dist / half_span - if u <= 1.0 { (1.0 - u * u) * (1.0 - u * u) } else { 0.0 } - } else { 1.0 } + if u <= 1.0 { + (1.0 - u * u) * (1.0 - u * u) + } else { + 0.0 + } + } else { + 1.0 + } w.push(weight) xs.push(xn) ys.push(yn) @@ -441,14 +517,24 @@ pub fn sc_norm_loess_smooth(x : Array[Double], y : Array[Double], span : Double) ///| /// Simple spline smoothing for 1D data. -pub fn sc_norm_spline_smooth(x : Array[Double], y : Array[Double], n_knots : Int) -> Array[Double] { +pub fn sc_norm_spline_smooth( + x : Array[Double], + y : Array[Double], + n_knots : Int, +) -> Array[Double] { let n = x.length() - if n < 4 { return y.copy() } + if n < 4 { + return y.copy() + } let sorted_x = sc_norm_sort_indices(x) // Create knot positions let x_min = sc_norm_min(x) let x_max = sc_norm_max(x) - let knot_span = if n_knots > 2 { (x_max - x_min) / (n_knots - 1).to_double() } else { 1.0 } + let knot_span = if n_knots > 2 { + (x_max - x_min) / (n_knots - 1).to_double() + } else { + 1.0 + } let knots : Array[Double] = Array::new() let mut k = 0 while k < n_knots { @@ -468,8 +554,14 @@ pub fn sc_norm_spline_smooth(x : Array[Double], y : Array[Double], n_knots : Int smoothed } +///| /// Spline interpolation at a point -fn sc_norm_spline_interpolate(x_val : Double, knots : Array[Double], x : Array[Double], y : Array[Double]) -> Double { +fn sc_norm_spline_interpolate( + x_val : Double, + knots : Array[Double], + x : Array[Double], + y : Array[Double], +) -> Double { let n_knots = knots.length() let n = x.length() // Find the two nearest data points @@ -485,8 +577,12 @@ fn sc_norm_spline_interpolate(x_val : Double, knots : Array[Double], x : Array[D i = i + 1 } // Simple linear interpolation between nearest neighbors - if best_idx == 0 { return y[0] } - if best_idx == n - 1 { return y[n - 1] } + if best_idx == 0 { + return y[0] + } + if best_idx == n - 1 { + return y[n - 1] + } let x0 = x[best_idx - 1] let x1 = x[best_idx] let y0 = y[best_idx - 1] @@ -495,25 +591,32 @@ fn sc_norm_spline_interpolate(x_val : Double, knots : Array[Double], x : Array[D y0 + t * (y1 - y0) } +///| fn sc_norm_sort_indices(arr : Array[Double]) -> Array[Double] { sc_norm_sort_array(arr) } +///| fn sc_norm_min(arr : Array[Double]) -> Double { let mut m = arr[0] let mut i = 1 while i < arr.length() { - if arr[i] < m { m = arr[i] } + if arr[i] < m { + m = arr[i] + } i = i + 1 } m } +///| fn sc_norm_max(arr : Array[Double]) -> Double { let mut m = arr[0] let mut i = 1 while i < arr.length() { - if arr[i] > m { m = arr[i] } + if arr[i] > m { + m = arr[i] + } i = i + 1 } m @@ -521,28 +624,43 @@ fn sc_norm_max(arr : Array[Double]) -> Double { // ===== Accessor methods ===== +///| /// Get number of genes after filtering pub fn SCnormResult::sc_n_n_genes(self : SCnormResult) -> Int { self.gene_ids.length() } +///| /// Get number of cells pub fn SCnormResult::sc_n_cells(self : SCnormResult) -> Int { self.cell_ids.length() } +///| /// Get a normalized count for a gene and cell -pub fn SCnormResult::sc_norm_get_count(self : SCnormResult, gene_idx : Int, cell_idx : Int) -> Double { +pub fn SCnormResult::sc_norm_get_count( + self : SCnormResult, + gene_idx : Int, + cell_idx : Int, +) -> Double { self.norm_matrix[gene_idx][cell_idx] } +///| /// Get all normalized counts for a gene -pub fn SCnormResult::sc_norm_get_gene(self : SCnormResult, gene_idx : Int) -> Array[Double] { +pub fn SCnormResult::sc_norm_get_gene( + self : SCnormResult, + gene_idx : Int, +) -> Array[Double] { self.norm_matrix[gene_idx].copy() } +///| /// Get all normalized counts for a cell -pub fn SCnormResult::sc_norm_get_cell(self : SCnormResult, cell_idx : Int) -> Array[Double] { +pub fn SCnormResult::sc_norm_get_cell( + self : SCnormResult, + cell_idx : Int, +) -> Array[Double] { let result : Array[Double] = Array::new() let mut i = 0 while i < self.norm_matrix.length() { @@ -552,8 +670,12 @@ pub fn SCnormResult::sc_norm_get_cell(self : SCnormResult, cell_idx : Int) -> Ar result } +///| /// Get the quantile fit for a gene -pub fn SCnormResult::sc_norm_get_fit(self : SCnormResult, gene_id : String) -> SCnormQuantFit? { +pub fn SCnormResult::sc_norm_get_fit( + self : SCnormResult, + gene_id : String, +) -> SCnormQuantFit? { let mut i = 0 while i < self.gene_results.length() { if self.gene_results[i].gene_id == gene_id { diff --git a/src/scop.mbt b/src/scop.mbt index bdd2291b..03f4f9d2 100644 --- a/src/scop.mbt +++ b/src/scop.mbt @@ -189,10 +189,9 @@ pub fn scop_parse_residues(s : String) -> ScopResidues { // Format: chain:start-end OR chain: let colon_idx = p.find(":") match colon_idx { - None => { + None => // No colon: treat the whole thing as a chain with no range fragments.push(ScopFragment::new(p, "", "")) - } Some(ci) => { let chain = p[0:ci].to_owned() let range = p[ci + 1:].to_owned() @@ -203,9 +202,7 @@ pub fn scop_parse_residues(s : String) -> ScopResidues { // "chain:start-end" let dash_idx = range.find("-") match dash_idx { - None => { - fragments.push(ScopFragment::new(chain, range, "")) - } + None => fragments.push(ScopFragment::new(chain, range, "")) Some(di) => { let start = range[0:di].to_owned() let end_ = range[di + 1:].to_owned() @@ -372,7 +369,11 @@ pub struct HieRecord { ///| /// Create a HIE record. -pub fn HieRecord::new(sunid : Int, parent : Int, children : Array[Int]) -> HieRecord { +pub fn HieRecord::new( + sunid : Int, + parent : Int, + children : Array[Int], +) -> HieRecord { { sunid, parent, children } } @@ -662,7 +663,10 @@ pub fn Scop::new( des_records : Array[DesRecord], hie_records : Array[HieRecord], ) -> Scop { - let sunid_dict : Map[Int, ScopNode] = Map([], capacity=des_records.length() + 1) + let sunid_dict : Map[Int, ScopNode] = Map( + [], + capacity=des_records.length() + 1, + ) let sid_dict : Map[String, ScopNode] = Map([], capacity=cla_records.length()) let domains : Array[ScopNode] = [] // 1. Create root @@ -1042,7 +1046,11 @@ pub fn Scop::write_des(self : Scop) -> String { Some(node) => { let name = if node.nodetype == "px" { node.sid } else { "-" } let rec = DesRecord::new( - node.sunid, node.nodetype, node.sccs, name, node.description, + node.sunid, + node.nodetype, + node.sccs, + name, + node.description, ) if result.length() > 0 { result = result + "\n" @@ -1077,7 +1085,12 @@ pub fn Scop::write_cla(self : Scop) -> String { } } let rec = ClaRecord::new( - node.sid, node.pdbid, res, node.sccs, node.sunid, hierarchy, + node.sid, + node.pdbid, + res, + node.sccs, + node.sunid, + hierarchy, ) if result.length() > 0 { result = result + "\n" @@ -1131,7 +1144,9 @@ pub fn scop_sample_hie() -> String { /// Create a sample CLA file content for testing. pub fn scop_sample_cla() -> String { let mut s = "" - s = s + "d1hba_\t1hba\tA:1-141\ta.1.1.1.1.1.1\t1000\tcl=100,cf=200,sf=300,fa=400,dm=500,sp=600,px=1000\n" - s = s + "d1hbb_\t1hba\tB:1-146\ta.1.1.1.1.1.2\t1001\tcl=100,cf=200,sf=300,fa=400,dm=500,sp=600,px=1001\n" + s = s + + "d1hba_\t1hba\tA:1-141\ta.1.1.1.1.1.1\t1000\tcl=100,cf=200,sf=300,fa=400,dm=500,sp=600,px=1000\n" + s = s + + "d1hbb_\t1hba\tB:1-146\ta.1.1.1.1.1.2\t1001\tcl=100,cf=200,sf=300,fa=400,dm=500,sp=600,px=1001\n" s } diff --git a/src/searchio.mbt b/src/searchio.mbt index 05954c8e..54b16d83 100644 --- a/src/searchio.mbt +++ b/src/searchio.mbt @@ -23,7 +23,8 @@ pub enum SearchIOFormat { pub fn search_io_format_from_str(s : String) -> SearchIOFormat { match s.to_lower().trim() { "blast-xml" | "blastxml" | "xml" => SearchIOFormat::BlastXml - "blast-tab" | "blasttabular" | "tabular" | "tab" => SearchIOFormat::BlastTabular + "blast-tab" | "blasttabular" | "tabular" | "tab" => + SearchIOFormat::BlastTabular "blast-text" | "blasttext" | "text" => SearchIOFormat::BlastText "hmmscan-domtbl" | "domtbl" => SearchIOFormat::HmmscanDomtbl "hmmdom-text" => SearchIOFormat::HmmdomText @@ -53,7 +54,11 @@ fn searchio_parse_int_fast(sv : StringView) -> Int { } i = i + 1 } - if is_negative { -result } else { result } + if is_negative { + -result + } else { + result + } } ///| @@ -131,7 +136,11 @@ fn searchio_parse_double_fast(sv : StringView) -> Double { } } } - if is_negative { -final_result } else { final_result } + if is_negative { + -final_result + } else { + final_result + } } ///| @@ -156,7 +165,11 @@ fn searchio_parse_int(s : String) -> Int { } i = i + 1 } - if is_negative { -result } else { result } + if is_negative { + -result + } else { + result + } } ///| @@ -234,7 +247,11 @@ fn searchio_parse_double(s : String) -> Double { } } } - if is_negative { -final_result } else { final_result } + if is_negative { + -final_result + } else { + final_result + } } ///| @@ -287,62 +304,122 @@ pub fn SearchIOHsp::new( hit_end~ : Int, ) -> SearchIOHsp { SearchIOHsp::{ - bitscore, evalue, identity, positives, gap, - alignment_length, query_start, query_end, hit_start, hit_end, - query_frame: 0, hit_frame: 0, - query_seq: "", hit_seq: "", midline: "" + bitscore, + evalue, + identity, + positives, + gap, + alignment_length, + query_start, + query_end, + hit_start, + hit_end, + query_frame: 0, + hit_frame: 0, + query_seq: "", + hit_seq: "", + midline: "", } } ///| /// Set query sequence in the alignment. -pub fn SearchIOHsp::with_query_seq(self : SearchIOHsp, seq : String) -> SearchIOHsp { +pub fn SearchIOHsp::with_query_seq( + self : SearchIOHsp, + seq : String, +) -> SearchIOHsp { SearchIOHsp::{ - bitscore: self.bitscore, evalue: self.evalue, identity: self.identity, - positives: self.positives, gap: self.gap, alignment_length: self.alignment_length, - query_start: self.query_start, query_end: self.query_end, - hit_start: self.hit_start, hit_end: self.hit_end, - query_frame: self.query_frame, hit_frame: self.hit_frame, - query_seq: seq, hit_seq: self.hit_seq, midline: self.midline + bitscore: self.bitscore, + evalue: self.evalue, + identity: self.identity, + positives: self.positives, + gap: self.gap, + alignment_length: self.alignment_length, + query_start: self.query_start, + query_end: self.query_end, + hit_start: self.hit_start, + hit_end: self.hit_end, + query_frame: self.query_frame, + hit_frame: self.hit_frame, + query_seq: seq, + hit_seq: self.hit_seq, + midline: self.midline, } } ///| /// Set hit sequence in the alignment. -pub fn SearchIOHsp::with_hit_seq(self : SearchIOHsp, seq : String) -> SearchIOHsp { +pub fn SearchIOHsp::with_hit_seq( + self : SearchIOHsp, + seq : String, +) -> SearchIOHsp { SearchIOHsp::{ - bitscore: self.bitscore, evalue: self.evalue, identity: self.identity, - positives: self.positives, gap: self.gap, alignment_length: self.alignment_length, - query_start: self.query_start, query_end: self.query_end, - hit_start: self.hit_start, hit_end: self.hit_end, - query_frame: self.query_frame, hit_frame: self.hit_frame, - query_seq: self.query_seq, hit_seq: seq, midline: self.midline + bitscore: self.bitscore, + evalue: self.evalue, + identity: self.identity, + positives: self.positives, + gap: self.gap, + alignment_length: self.alignment_length, + query_start: self.query_start, + query_end: self.query_end, + hit_start: self.hit_start, + hit_end: self.hit_end, + query_frame: self.query_frame, + hit_frame: self.hit_frame, + query_seq: self.query_seq, + hit_seq: seq, + midline: self.midline, } } ///| /// Set midline (conservation line). -pub fn SearchIOHsp::with_midline(self : SearchIOHsp, line : String) -> SearchIOHsp { +pub fn SearchIOHsp::with_midline( + self : SearchIOHsp, + line : String, +) -> SearchIOHsp { SearchIOHsp::{ - bitscore: self.bitscore, evalue: self.evalue, identity: self.identity, - positives: self.positives, gap: self.gap, alignment_length: self.alignment_length, - query_start: self.query_start, query_end: self.query_end, - hit_start: self.hit_start, hit_end: self.hit_end, - query_frame: self.query_frame, hit_frame: self.hit_frame, - query_seq: self.query_seq, hit_seq: self.hit_seq, midline: line + bitscore: self.bitscore, + evalue: self.evalue, + identity: self.identity, + positives: self.positives, + gap: self.gap, + alignment_length: self.alignment_length, + query_start: self.query_start, + query_end: self.query_end, + hit_start: self.hit_start, + hit_end: self.hit_end, + query_frame: self.query_frame, + hit_frame: self.hit_frame, + query_seq: self.query_seq, + hit_seq: self.hit_seq, + midline: line, } } ///| /// Set query and hit frames. -pub fn SearchIOHsp::with_frames(self : SearchIOHsp, qframe : Int, hframe : Int) -> SearchIOHsp { +pub fn SearchIOHsp::with_frames( + self : SearchIOHsp, + qframe : Int, + hframe : Int, +) -> SearchIOHsp { SearchIOHsp::{ - bitscore: self.bitscore, evalue: self.evalue, identity: self.identity, - positives: self.positives, gap: self.gap, alignment_length: self.alignment_length, - query_start: self.query_start, query_end: self.query_end, - hit_start: self.hit_start, hit_end: self.hit_end, - query_frame: qframe, hit_frame: hframe, - query_seq: self.query_seq, hit_seq: self.hit_seq, midline: self.midline + bitscore: self.bitscore, + evalue: self.evalue, + identity: self.identity, + positives: self.positives, + gap: self.gap, + alignment_length: self.alignment_length, + query_start: self.query_start, + query_end: self.query_end, + hit_start: self.hit_start, + hit_end: self.hit_end, + query_frame: qframe, + hit_frame: hframe, + query_seq: self.query_seq, + hit_seq: self.hit_seq, + midline: self.midline, } } @@ -379,18 +456,27 @@ pub struct SearchIOHit { ///| /// Construct SearchIOHit. -pub fn SearchIOHit::new(id~ : String, description~ : String, seq_length~ : Int) -> SearchIOHit { +pub fn SearchIOHit::new( + id~ : String, + description~ : String, + seq_length~ : Int, +) -> SearchIOHit { SearchIOHit::{ id, description, seq_length, hsps: Array::new() } } ///| /// Add an HSP to this hit. -pub fn SearchIOHit::add_hsp(self : SearchIOHit, hsp : SearchIOHsp) -> SearchIOHit { +pub fn SearchIOHit::add_hsp( + self : SearchIOHit, + hsp : SearchIOHsp, +) -> SearchIOHit { let new_hsps = self.hsps.copy() new_hsps.push(hsp) SearchIOHit::{ - id: self.id, description: self.description, - seq_length: self.seq_length, hsps: new_hsps + id: self.id, + description: self.description, + seq_length: self.seq_length, + hsps: new_hsps, } } @@ -457,38 +543,57 @@ pub fn SearchIOQueryResult::new( database~ : String, ) -> SearchIOQueryResult { SearchIOQueryResult::{ - id, description, seq_length, database, - n_hits: 0, hits: Array::new(), total_hits: 0 + id, + description, + seq_length, + database, + n_hits: 0, + hits: Array::new(), + total_hits: 0, } } ///| /// Add a hit to this query result. -pub fn SearchIOQueryResult::add_hit(self : SearchIOQueryResult, hit : SearchIOHit) -> SearchIOQueryResult { +pub fn SearchIOQueryResult::add_hit( + self : SearchIOQueryResult, + hit : SearchIOHit, +) -> SearchIOQueryResult { let new_hits = self.hits.copy() new_hits.push(hit) SearchIOQueryResult::{ - id: self.id, description: self.description, - seq_length: self.seq_length, database: self.database, - n_hits: self.n_hits + 1, hits: new_hits, - total_hits: self.total_hits + id: self.id, + description: self.description, + seq_length: self.seq_length, + database: self.database, + n_hits: self.n_hits + 1, + hits: new_hits, + total_hits: self.total_hits, } } ///| /// Set total hits (before filtering). -pub fn SearchIOQueryResult::with_total_hits(self : SearchIOQueryResult, total : Int) -> SearchIOQueryResult { +pub fn SearchIOQueryResult::with_total_hits( + self : SearchIOQueryResult, + total : Int, +) -> SearchIOQueryResult { SearchIOQueryResult::{ - id: self.id, description: self.description, - seq_length: self.seq_length, database: self.database, - n_hits: self.n_hits, hits: self.hits, - total_hits: total + id: self.id, + description: self.description, + seq_length: self.seq_length, + database: self.database, + n_hits: self.n_hits, + hits: self.hits, + total_hits: total, } } ///| /// Sort hits by bitscore (descending). -pub fn SearchIOQueryResult::sort_by_score(self : SearchIOQueryResult) -> SearchIOQueryResult { +pub fn SearchIOQueryResult::sort_by_score( + self : SearchIOQueryResult, +) -> SearchIOQueryResult { let sorted = self.hits.copy() let n = sorted.length() let mut i = 0 @@ -507,16 +612,22 @@ pub fn SearchIOQueryResult::sort_by_score(self : SearchIOQueryResult) -> SearchI i = i + 1 } SearchIOQueryResult::{ - id: self.id, description: self.description, - seq_length: self.seq_length, database: self.database, - n_hits: self.n_hits, hits: sorted, - total_hits: self.total_hits + id: self.id, + description: self.description, + seq_length: self.seq_length, + database: self.database, + n_hits: self.n_hits, + hits: sorted, + total_hits: self.total_hits, } } ///| /// Filter hits by E-value threshold. -pub fn SearchIOQueryResult::filter_evalue(self : SearchIOQueryResult, threshold : Double) -> SearchIOQueryResult { +pub fn SearchIOQueryResult::filter_evalue( + self : SearchIOQueryResult, + threshold : Double, +) -> SearchIOQueryResult { let filtered : Array[SearchIOHit] = Array::new() let mut i = 0 while i < self.hits.length() { @@ -534,16 +645,22 @@ pub fn SearchIOQueryResult::filter_evalue(self : SearchIOQueryResult, threshold i = i + 1 } SearchIOQueryResult::{ - id: self.id, description: self.description, - seq_length: self.seq_length, database: self.database, - n_hits: filtered.length(), hits: filtered, - total_hits: self.total_hits + id: self.id, + description: self.description, + seq_length: self.seq_length, + database: self.database, + n_hits: filtered.length(), + hits: filtered, + total_hits: self.total_hits, } } ///| /// Get the top N hits by score. -pub fn SearchIOQueryResult::top_n(self : SearchIOQueryResult, n : Int) -> Array[SearchIOHit] { +pub fn SearchIOQueryResult::top_n( + self : SearchIOQueryResult, + n : Int, +) -> Array[SearchIOHit] { let sorted = self.sort_by_score() if sorted.hits.length() <= n { return sorted.hits @@ -572,14 +689,19 @@ pub struct SearchIOIterator { ///| /// Construct SearchIOIterator from search output text. -pub fn SearchIOIterator::new(content : String, format : SearchIOFormat) -> SearchIOIterator { +pub fn SearchIOIterator::new( + content : String, + format : SearchIOFormat, +) -> SearchIOIterator { let lines = split_lines(content) SearchIOIterator::{ lines, position: 0, format, initialized: false } } ///| /// Parse BLAST tabular output (6-column or extended tabular). -pub fn SearchIOIterator::parse_blast_tabular(self : SearchIOIterator) -> Array[SearchIOQueryResult] { +pub fn SearchIOIterator::parse_blast_tabular( + self : SearchIOIterator, +) -> Array[SearchIOQueryResult] { let results : Array[SearchIOQueryResult] = Array::new() let mut current_query_id = "" let mut current_query : SearchIOQueryResult? = None @@ -603,9 +725,14 @@ pub fn SearchIOIterator::parse_blast_tabular(self : SearchIOIterator) -> Array[S None => () } current_query_id = extract_query_id(trimmed) - current_query = Some(SearchIOQueryResult::new( - id=current_query_id, description="", seq_length=0, database="" - )) + current_query = Some( + SearchIOQueryResult::new( + id=current_query_id, + description="", + seq_length=0, + database="", + ), + ) } line_idx = line_idx + 1 continue @@ -626,9 +753,16 @@ pub fn SearchIOIterator::parse_blast_tabular(self : SearchIOIterator) -> Array[S let bitscore = searchio_parse_double(fields[11]) let hsp = SearchIOHsp::new( - bitscore=bitscore, evalue=evalue, identity=identity, positives=identity, - gap=0.0, alignment_length=length, - query_start=qstart, query_end=qend, hit_start=hstart, hit_end=hend + bitscore~, + evalue~, + identity~, + positives=identity, + gap=0.0, + alignment_length=length, + query_start=qstart, + query_end=qend, + hit_start=hstart, + hit_end=hend, ) let mut found = false @@ -639,10 +773,13 @@ pub fn SearchIOIterator::parse_blast_tabular(self : SearchIOIterator) -> Array[S let new_hits = qr.hits.copy() new_hits[i] = updated_hit current_query = Some(SearchIOQueryResult::{ - id: qr.id, description: qr.description, - seq_length: qr.seq_length, database: qr.database, - n_hits: qr.n_hits, hits: new_hits, - total_hits: qr.total_hits + id: qr.id, + description: qr.description, + seq_length: qr.seq_length, + database: qr.database, + n_hits: qr.n_hits, + hits: new_hits, + total_hits: qr.total_hits, }) found = true break @@ -650,14 +787,19 @@ pub fn SearchIOIterator::parse_blast_tabular(self : SearchIOIterator) -> Array[S i = i + 1 } if !found { - let hit = SearchIOHit::new(id=hit_id, description="", seq_length=0).add_hsp(hsp) + let hit = SearchIOHit::new(id=hit_id, description="", seq_length=0).add_hsp( + hsp, + ) let new_hits = qr.hits.copy() new_hits.push(hit) current_query = Some(SearchIOQueryResult::{ - id: qr.id, description: qr.description, - seq_length: qr.seq_length, database: qr.database, - n_hits: qr.n_hits + 1, hits: new_hits, - total_hits: qr.total_hits + id: qr.id, + description: qr.description, + seq_length: qr.seq_length, + database: qr.database, + n_hits: qr.n_hits + 1, + hits: new_hits, + total_hits: qr.total_hits, }) } () @@ -682,7 +824,9 @@ pub fn SearchIOIterator::parse_blast_tabular(self : SearchIOIterator) -> Array[S ///| /// Parse BLAST text output (legacy format). -pub fn SearchIOIterator::parse_blast_text(self : SearchIOIterator) -> Array[SearchIOQueryResult] { +pub fn SearchIOIterator::parse_blast_text( + self : SearchIOIterator, +) -> Array[SearchIOQueryResult] { let results : Array[SearchIOQueryResult] = Array::new() let mut current_query : SearchIOQueryResult? = None @@ -704,7 +848,14 @@ pub fn SearchIOIterator::parse_blast_text(self : SearchIOIterator) -> Array[Sear None => () } let query_id = extract_query_id_text(trimmed) - current_query = Some(SearchIOQueryResult::new(id=query_id, description="", seq_length=0, database="")) + current_query = Some( + SearchIOQueryResult::new( + id=query_id, + description="", + seq_length=0, + database="", + ), + ) line_idx = line_idx + 1 continue } @@ -717,10 +868,13 @@ pub fn SearchIOIterator::parse_blast_text(self : SearchIOIterator) -> Array[Sear let new_hits = qr.hits.copy() new_hits.push(hit) current_query = Some(SearchIOQueryResult::{ - id: qr.id, description: qr.description, - seq_length: qr.seq_length, database: qr.database, - n_hits: qr.n_hits + 1, hits: new_hits, - total_hits: qr.total_hits + id: qr.id, + description: qr.description, + seq_length: qr.seq_length, + database: qr.database, + n_hits: qr.n_hits + 1, + hits: new_hits, + total_hits: qr.total_hits, }) () } @@ -737,18 +891,28 @@ pub fn SearchIOIterator::parse_blast_text(self : SearchIOIterator) -> Array[Sear if qr.hits.length() > 0 { let idx = qr.hits.length() - 1 let hsp = SearchIOHsp::new( - bitscore=bitscore, evalue=evalue, identity=0.0, positives=0.0, - gap=0.0, alignment_length=0, - query_start=0, query_end=0, hit_start=0, hit_end=0 + bitscore~, + evalue~, + identity=0.0, + positives=0.0, + gap=0.0, + alignment_length=0, + query_start=0, + query_end=0, + hit_start=0, + hit_end=0, ) let updated_hit = qr.hits[idx].add_hsp(hsp) let new_hits = qr.hits.copy() new_hits[idx] = updated_hit current_query = Some(SearchIOQueryResult::{ - id: qr.id, description: qr.description, - seq_length: qr.seq_length, database: qr.database, - n_hits: qr.n_hits, hits: new_hits, - total_hits: qr.total_hits + id: qr.id, + description: qr.description, + seq_length: qr.seq_length, + database: qr.database, + n_hits: qr.n_hits, + hits: new_hits, + total_hits: qr.total_hits, }) } () @@ -774,7 +938,9 @@ pub fn SearchIOIterator::parse_blast_text(self : SearchIOIterator) -> Array[Sear ///| /// Main entry point: parse search results based on format. -pub fn SearchIOIterator::parse(self : SearchIOIterator) -> Array[SearchIOQueryResult] { +pub fn SearchIOIterator::parse( + self : SearchIOIterator, +) -> Array[SearchIOQueryResult] { match self.format { SearchIOFormat::BlastTabular => self.parse_blast_tabular() SearchIOFormat::BlastText => self.parse_blast_text() @@ -928,9 +1094,18 @@ fn find_numeric_value(line : String, keyword : String) -> Double { let mut has_e = false while i < line.length() { let c = line.unsafe_get(i) - if (c >= '0' && c <= '9') || (c == '.' && !has_dot) || (c == 'e' || c == 'E') || (c == '-' && has_e) || (c == '+' && has_e) { - if c == '.' { has_dot = true } - if c == 'e' || c == 'E' { has_e = true; has_dot = false } + if (c >= '0' && c <= '9') || + (c == '.' && !has_dot) || + (c == 'e' || c == 'E') || + (c == '-' && has_e) || + (c == '+' && has_e) { + if c == '.' { + has_dot = true + } + if c == 'e' || c == 'E' { + has_e = true + has_dot = false + } num_str = num_str + u16_to_str(c) } else { break @@ -953,10 +1128,76 @@ pub fn search_io_mock_blast_tabular() -> String { "# Query: seq1 test query\n" + "# Database: nr\n" + "# Fields: query id, subject id, % identity, alignment length, mismatches, open gaps, q.start, q.end, s.start, s.end, evalue, bit score\n" + - "seq1" + tab + "hit1" + tab + "95.0" + tab + "100" + tab + "3" + tab + "2" + tab + "1" + tab + "100" + tab + "1" + tab + "100" + tab + "1e-50" + tab + "200.5\n" + - "seq1" + tab + "hit2" + tab + "80.0" + tab + "80" + tab + "10" + tab + "5" + tab + "1" + tab + "80" + tab + "1" + tab + "80" + tab + "1e-30" + tab + "150.3\n" + + "seq1" + + tab + + "hit1" + + tab + + "95.0" + + tab + + "100" + + tab + + "3" + + tab + + "2" + + tab + + "1" + + tab + + "100" + + tab + + "1" + + tab + + "100" + + tab + + "1e-50" + + tab + + "200.5\n" + + "seq1" + + tab + + "hit2" + + tab + + "80.0" + + tab + + "80" + + tab + + "10" + + tab + + "5" + + tab + + "1" + + tab + + "80" + + tab + + "1" + + tab + + "80" + + tab + + "1e-30" + + tab + + "150.3\n" + "# Query: seq2 another query\n" + "# Database: nr\n" + "# Fields: query id, subject id, % identity, alignment length, mismatches, open gaps, q.start, q.end, s.start, s.end, evalue, bit score\n" + - "seq2" + tab + "hit3" + tab + "90.0" + tab + "200" + tab + "5" + tab + "1" + tab + "1" + tab + "200" + tab + "1" + tab + "200" + tab + "1e-80" + tab + "300.0\n" -} \ No newline at end of file + "seq2" + + tab + + "hit3" + + tab + + "90.0" + + tab + + "200" + + tab + + "5" + + tab + + "1" + + tab + + "1" + + tab + + "200" + + tab + + "1" + + tab + + "200" + + tab + + "1e-80" + + tab + + "300.0\n" +} diff --git a/src/seq.mbt b/src/seq.mbt index dccb2526..61225b0c 100644 --- a/src/seq.mbt +++ b/src/seq.mbt @@ -654,7 +654,7 @@ pub fn MutableSeq::new(s : String) -> MutableSeq { data.push(s.unsafe_get(i).unsafe_to_char()) i = i + 1 } - MutableSeq::{ data } + MutableSeq::{ data, } } ///| @@ -744,7 +744,11 @@ pub fn MutableSeq::delete(self : MutableSeq, i : Int) -> Unit { ///| /// Delete characters in range [start, end). -pub fn MutableSeq::delete_range(self : MutableSeq, start : Int, end : Int) -> Unit { +pub fn MutableSeq::delete_range( + self : MutableSeq, + start : Int, + end : Int, +) -> Unit { let new_data = Array::new() let mut idx = 0 while idx < self.data.length() { @@ -817,7 +821,7 @@ pub fn MutableSeq::translate( to_stop? : Bool = false, cds? : Bool = false, ) -> MutableSeq raise SeqError { - let result = self.to_seq().translate(stop_symbol=stop_symbol, to_stop=to_stop, cds=cds) + let result = self.to_seq().translate(stop_symbol~, to_stop~, cds~) MutableSeq::new(result.data) } diff --git a/src/seq_approx.mbt b/src/seq_approx.mbt index 583c681f..c15d77a2 100644 --- a/src/seq_approx.mbt +++ b/src/seq_approx.mbt @@ -121,7 +121,7 @@ pub fn approx_search( } } - let mut best : Option[ApproxMatch] = None + let mut best : ApproxMatch? = None let mut pos = 0 let max_pos = qry_len - pat_len @@ -141,9 +141,7 @@ pub fn approx_search( is_match: true, } best = match best { - Some(prev) => { - if mm < prev.mismatches { Some(m) } else { Some(prev) } - } + Some(prev) => if mm < prev.mismatches { Some(m) } else { Some(prev) } None => Some(m) } if mm == 0 { @@ -155,15 +153,16 @@ pub fn approx_search( match best { Some(m) => m - None => ApproxMatch::{ - pattern, - query, - start: 0, - end: 0, - mismatches: pat_len, - score: 0, - is_match: false, - } + None => + ApproxMatch::{ + pattern, + query, + start: 0, + end: 0, + mismatches: pat_len, + score: 0, + is_match: false, + } } } @@ -217,7 +216,7 @@ pub fn approx_search_with_indels( let init_end = if min_end > start { min_end } else { start + 1 } let mut end = init_end while end <= max_end { - let seg = query.substring(start=start, end=end) + let seg = query.substring(start~, end~) let errors = levenshtein_distance(pattern, seg) if errors <= max_errors && errors < best_errors { best_errors = errors @@ -273,8 +272,12 @@ pub fn levenshtein_distance(s1 : String, s2 : String) -> Int { let len1 = s1.length() let len2 = s2.length() - if len1 == 0 { return len2 } - if len2 == 0 { return len1 } + if len1 == 0 { + return len2 + } + if len2 == 0 { + return len1 + } let mut prev : Array[Int] = Array::new() let mut i = 0 @@ -297,7 +300,17 @@ pub fn levenshtein_distance(s1 : String, s2 : String) -> Int { let deletion = prev[j] + 1 let insertion = row[j - 1] + 1 let substitution = prev[j - 1] + cost - let min_val = if deletion < insertion { if deletion < substitution { deletion } else { substitution } } else { if insertion < substitution { insertion } else { substitution } } + let min_val = if deletion < insertion { + if deletion < substitution { + deletion + } else { + substitution + } + } else if insertion < substitution { + insertion + } else { + substitution + } row.push(min_val) j = j + 1 } @@ -370,7 +383,13 @@ pub fn approx_word_search( let text_len = text.length() if len == 0 { - return ApproxWordResult::{ word, match_start: 0, match_end: 0, edit_distance: 0, is_found: false } + return ApproxWordResult::{ + word, + match_start: 0, + match_end: 0, + edit_distance: 0, + is_found: false, + } } let mut best_dist = max_errors + 1 @@ -380,10 +399,14 @@ pub fn approx_word_search( let mut start = 0 while start < text_len { - let max_end = if start + len + max_errors < text_len { start + len + max_errors } else { text_len } + let max_end = if start + len + max_errors < text_len { + start + len + max_errors + } else { + text_len + } let mut end = start + len while end <= max_end { - let seg = text.substring(start=start, end=end) + let seg = text.substring(start~, end~) let dist = levenshtein_distance(word, seg) if dist <= max_errors && dist < best_dist { best_dist = dist diff --git a/src/seq_complexity.mbt b/src/seq_complexity.mbt index c0555909..6390a1b0 100644 --- a/src/seq_complexity.mbt +++ b/src/seq_complexity.mbt @@ -338,7 +338,7 @@ pub fn lcc_low_complexity_regions( k? : Int = 3, threshold? : Double = 0.5, ) -> Array[(Int, Int)] { - let scores = lcc(seq, window=window, k=k) + let scores = lcc(seq, window~, k~) let regions = Array::new() let mut i = 0 while i < scores.length() { diff --git a/src/seq_location.mbt b/src/seq_location.mbt index 831227d2..ee491031 100644 --- a/src/seq_location.mbt +++ b/src/seq_location.mbt @@ -48,7 +48,9 @@ pub fn pos_to_string(pos : Pos) -> String { let mut s = "{" let mut i = 0 while i < opts.length() { - if i > 0 { s = s + "," } + if i > 0 { + s = s + "," + } s = s + pos_to_string(opts[i]) i = i + 1 } @@ -146,7 +148,7 @@ pub fn compound_from_simple( while i < starts.length() { let sp = exact_position(starts[i]) let ep = exact_position(ends[i]) - locs.push(simple_location(sp, ep, strand=strand)) + locs.push(simple_location(sp, ep, strand~)) i = i + 1 } CompoundLocation(locs, strand, "") @@ -158,7 +160,9 @@ pub fn loc_start(loc : Loc) -> Int { match loc { SimpleLocation(sp, _, _, _) => pos_get(sp) CompoundLocation(locs, _, _) => { - if locs.length() == 0 { return 0 } + if locs.length() == 0 { + return 0 + } locs[0].start() } } @@ -170,7 +174,9 @@ pub fn loc_end(loc : Loc) -> Int { match loc { SimpleLocation(_, ep, _, _) => pos_get(ep) CompoundLocation(locs, _, _) => { - if locs.length() == 0 { return 0 } + if locs.length() == 0 { + return 0 + } let last = locs[locs.length() - 1] last.end() } @@ -193,7 +199,11 @@ pub fn loc_len(loc : Loc) -> Int { SimpleLocation(sp, ep, _, _) => { let e = pos_get(ep) let s = pos_get(sp) - if e > s { e - s } else { s - e } + if e > s { + e - s + } else { + s - e + } } CompoundLocation(locs, _, _) => { let mut total = 0 @@ -262,7 +272,11 @@ pub fn loc_contains(loc : Loc, pos : Int) -> Bool { SimpleLocation(sp, ep, _, _) => { let s = pos_get(sp) let e = pos_get(ep) - if s <= e { pos >= s && pos < e } else { pos > e && pos <= s } + if s <= e { + pos >= s && pos < e + } else { + pos > e && pos <= s + } } CompoundLocation(locs, _, _) => { let mut i = 0 @@ -286,7 +300,9 @@ pub fn loc_to_string(loc : Loc) -> String { let mut s = "" let mut i = 0 while i < locs.length() { - if i > 0 { s = s + "," } + if i > 0 { + s = s + "," + } s = s + locs[i].to_string() i = i + 1 } @@ -308,7 +324,9 @@ pub fn loc_to_one_based(loc : Loc) -> String { let mut s = "join(" let mut i = 0 while i < locs.length() { - if i > 0 { s = s + "," } + if i > 0 { + s = s + "," + } s = s + locs[i].to_one_based() i = i + 1 } @@ -322,37 +340,87 @@ pub fn loc_to_one_based(loc : Loc) -> String { // Pos methods // ============================================================================ +///| /// Get the numeric value of the position. -pub fn Pos::get(self : Pos) -> Int { pos_get(self) } +pub fn Pos::get(self : Pos) -> Int { + pos_get(self) +} + +///| /// Get the string representation of a position. -pub fn Pos::to_string(self : Pos) -> String { pos_to_string(self) } +pub fn Pos::to_string(self : Pos) -> String { + pos_to_string(self) +} + +///| /// Check if a position is exact. -pub fn Pos::is_exact(self : Pos) -> Bool { pos_is_exact(self) } +pub fn Pos::is_exact(self : Pos) -> Bool { + pos_is_exact(self) +} // ============================================================================ // Loc methods // ============================================================================ +///| /// Get the start position (0-based). -pub fn Loc::start(self : Loc) -> Int { loc_start(self) } +pub fn Loc::start(self : Loc) -> Int { + loc_start(self) +} + +///| /// Get the end position (0-based, exclusive). -pub fn Loc::end(self : Loc) -> Int { loc_end(self) } +pub fn Loc::end(self : Loc) -> Int { + loc_end(self) +} + +///| /// Get the strand. -pub fn Loc::strand(self : Loc) -> String { loc_strand(self) } +pub fn Loc::strand(self : Loc) -> String { + loc_strand(self) +} + +///| /// Get the length of the location. -pub fn Loc::len(self : Loc) -> Int { loc_len(self) } +pub fn Loc::len(self : Loc) -> Int { + loc_len(self) +} + +///| /// Check if this is a compound location. -pub fn Loc::is_compound(self : Loc) -> Bool { loc_is_compound(self) } +pub fn Loc::is_compound(self : Loc) -> Bool { + loc_is_compound(self) +} + +///| /// Get the sub-locations. -pub fn Loc::parts(self : Loc) -> Array[Loc] { loc_parts(self) } +pub fn Loc::parts(self : Loc) -> Array[Loc] { + loc_parts(self) +} + +///| /// Check if two locations overlap. -pub fn Loc::overlaps(self : Loc, other : Loc) -> Bool { loc_overlaps(self, other) } +pub fn Loc::overlaps(self : Loc, other : Loc) -> Bool { + loc_overlaps(self, other) +} + +///| /// Check if this location contains a position. -pub fn Loc::contains(self : Loc, pos : Int) -> Bool { loc_contains(self, pos) } +pub fn Loc::contains(self : Loc, pos : Int) -> Bool { + loc_contains(self, pos) +} + +///| /// Get location as string. -pub fn Loc::to_string(self : Loc) -> String { loc_to_string(self) } +pub fn Loc::to_string(self : Loc) -> String { + loc_to_string(self) +} + +///| /// Return location in 1-based coordinates. -pub fn Loc::to_one_based(self : Loc) -> String { loc_to_one_based(self) } +pub fn Loc::to_one_based(self : Loc) -> String { + loc_to_one_based(self) +} // ============================================================================ // Helper Functions @@ -366,10 +434,14 @@ pub fn location_to_genbank(loc : Loc) -> String { ///| /// Create a simple location from 1-based GenBank coordinates. -pub fn from_genbank_coords(start : Int, end_ : Int, strand? : String = "+") -> Loc { +pub fn from_genbank_coords( + start : Int, + end_ : Int, + strand? : String = "+", +) -> Loc { let sp = exact_position(start - 1) let ep = exact_position(end_) - simple_location(sp, ep, strand=strand) + simple_location(sp, ep, strand~) } ///| @@ -390,21 +462,30 @@ pub fn parse_genbank_location(loc_str : String) -> Loc { } } +///| /// Parse an integer from a trimmed string view, returning 1 on failure. fn parse_int_trimmed(sv : StringView) -> Int { let s = sv.trim().to_owned() let n = s.length() - if n == 0 { return 1 } + if n == 0 { + return 1 + } let mut result = 0 let mut i = 0 let zero = '0'.to_int() while i < n { let c = s.unsafe_get(i).to_int() - if c < zero || c > zero + 9 { break } + if c < zero || c > zero + 9 { + break + } result = result * 10 + (c - zero) i = i + 1 } - if result == 0 && n > 0 { 1 } else { result } + if result == 0 && n > 0 { + 1 + } else { + result + } } ///| @@ -412,20 +493,38 @@ fn parse_int_trimmed(sv : StringView) -> Int { pub fn seq_location_sample() -> Array[Loc] { let locs : Array[Loc] = Array::new() locs.push(simple_location(exact_position(10), exact_position(50), strand="+")) - locs.push(simple_location(exact_position(100), exact_position(200), strand="-")) - let exon1 = simple_location(exact_position(0), exact_position(100), strand="+") - let exon2 = simple_location(exact_position(200), exact_position(350), strand="+") - let exon3 = simple_location(exact_position(500), exact_position(600), strand="+") + locs.push( + simple_location(exact_position(100), exact_position(200), strand="-"), + ) + let exon1 = simple_location( + exact_position(0), + exact_position(100), + strand="+", + ) + let exon2 = simple_location( + exact_position(200), + exact_position(350), + strand="+", + ) + let exon3 = simple_location( + exact_position(500), + exact_position(600), + strand="+", + ) let exon_locs : Array[Loc] = Array::new() exon_locs.push(exon1) exon_locs.push(exon2) exon_locs.push(exon3) locs.push(compound_location(exon_locs, strand="+")) - locs.push(simple_location(before_position(50), after_position(100), strand="+")) + locs.push( + simple_location(before_position(50), after_position(100), strand="+"), + ) let opts : Array[Pos] = Array::new() opts.push(exact_position(5)) opts.push(exact_position(7)) opts.push(exact_position(9)) - locs.push(simple_location(one_of_position(7, opts), exact_position(50), strand="+")) + locs.push( + simple_location(one_of_position(7, opts), exact_position(50), strand="+"), + ) locs } diff --git a/src/seq_quality_trim.mbt b/src/seq_quality_trim.mbt index c23528ee..94ed9666 100644 --- a/src/seq_quality_trim.mbt +++ b/src/seq_quality_trim.mbt @@ -681,9 +681,7 @@ test "sqt_trim_adapter_perfect_match" { let seq = "ACGTACGTAGATCGGAA" let qual = "IIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" - let (t_seq, _) = sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, - ) + let (t_seq, _) = sqt_trim_adapter(seq, qual, adapter, allowed_mismatches=0) assert_eq(t_seq, "ACGTACGT") } @@ -692,9 +690,7 @@ test "sqt_trim_adapter_no_match" { let seq = "ACGTACGTACGTACGT" let qual = "IIIIIIIIIIIIIIII" let adapter = "GGGGGGGG" - let (t_seq, _) = sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, - ) + let (t_seq, _) = sqt_trim_adapter(seq, qual, adapter, allowed_mismatches=0) assert_eq(t_seq, "ACGTACGTACGTACGT") } @@ -703,9 +699,7 @@ test "sqt_trim_adapter_with_mismatches" { let seq = "ACGTACGTAGATCGGAA" let qual = "IIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" - let (t_seq, _) = sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=2, - ) + let (t_seq, _) = sqt_trim_adapter(seq, qual, adapter, allowed_mismatches=2) assert_eq(t_seq, "ACGTACGT") } @@ -722,9 +716,7 @@ test "sqt_trim_adapter_short_seq" { let seq = "AC" let qual = "II" let adapter = "AGATCGGAA" - let (t_seq, _) = sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, - ) + let (t_seq, _) = sqt_trim_adapter(seq, qual, adapter, allowed_mismatches=0) assert_eq(t_seq, "AC") } @@ -733,9 +725,7 @@ test "sqt_trim_adapter_at_beginning" { let seq = "AGATCGGAAACGTACGT" let qual = "IIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" - let (t_seq, _) = sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, - ) + let (t_seq, _) = sqt_trim_adapter(seq, qual, adapter, allowed_mismatches=0) assert_eq(t_seq.length(), 0) } @@ -838,11 +828,7 @@ test "sqt_trim_by_gc_mid_range" { ///| test "sqt_trim_reads_batch" { let reads = [ - FastqRead::{ - id: "read1", - sequence: "ACGTACGT", - quality: "IIIIIIII", - }, + FastqRead::{ id: "read1", sequence: "ACGTACGT", quality: "IIIIIIII" }, FastqRead::{ id: "read2", sequence: "ACGTACGTAGATCGGAA", @@ -885,24 +871,15 @@ test "sqt_trim_reads_no_adapter" { assert_eq(results.length(), 1) assert_eq(results[0].trimmed_seq, "ACGTACGGG") assert_true( - results[0].trim_type == "poly_A" || - results[0].trim_type == "poly_A,quality", + results[0].trim_type == "poly_A" || results[0].trim_type == "poly_A,quality", ) } ///| test "sqt_compute_stats_basic" { let reads = [ - FastqRead::{ - id: "r1", - sequence: "ACGTACGT", - quality: "IIIIIIII", - }, - FastqRead::{ - id: "r2", - sequence: "TTTTTTTT", - quality: "IIIIIIII", - }, + FastqRead::{ id: "r1", sequence: "ACGTACGT", quality: "IIIIIIII" }, + FastqRead::{ id: "r2", sequence: "TTTTTTTT", quality: "IIIIIIII" }, ] let results = [ TrimResult::{ @@ -978,13 +955,7 @@ test "sqt_fastq_parse_malformed" { ///| test "sqt_fastq_serialize_basic" { - let reads = [ - FastqRead::{ - id: "test1", - sequence: "ACGT", - quality: "IIII", - }, - ] + let reads = [FastqRead::{ id: "test1", sequence: "ACGT", quality: "IIII" }] let output = sqt_fastq_serialize(reads) assert_eq(output, "@test1\nACGT\n+\nIIII\n") } @@ -992,22 +963,11 @@ test "sqt_fastq_serialize_basic" { ///| test "sqt_fastq_serialize_multiple" { let reads = [ - FastqRead::{ - id: "r1", - sequence: "AAAA", - quality: "IIII", - }, - FastqRead::{ - id: "r2", - sequence: "CCCC", - quality: "IIII", - }, + FastqRead::{ id: "r1", sequence: "AAAA", quality: "IIII" }, + FastqRead::{ id: "r2", sequence: "CCCC", quality: "IIII" }, ] let output = sqt_fastq_serialize(reads) - assert_eq( - output, - "@r1\nAAAA\n+\nIIII\n@r2\nCCCC\n+\nIIII\n", - ) + assert_eq(output, "@r1\nAAAA\n+\nIIII\n@r2\nCCCC\n+\nIIII\n") } ///| @@ -1043,16 +1003,8 @@ test "sqt_quality_trim_single_base" { ///| test "sqt_compute_stats_gc_content" { let reads = [ - FastqRead::{ - id: "gc_high", - sequence: "GGGGCCCC", - quality: "IIIIIIII", - }, - FastqRead::{ - id: "at_high", - sequence: "AAAATTTT", - quality: "IIIIIIII", - }, + FastqRead::{ id: "gc_high", sequence: "GGGGCCCC", quality: "IIIIIIII" }, + FastqRead::{ id: "at_high", sequence: "AAAATTTT", quality: "IIIIIIII" }, ] let results = [ TrimResult::{ @@ -1080,11 +1032,7 @@ test "sqt_compute_stats_gc_content" { ///| test "sqt_trim_reads_quality_trim_only" { let reads = [ - FastqRead::{ - id: "r1", - sequence: "ACGTACGT", - quality: "IIII####", - }, + FastqRead::{ id: "r1", sequence: "ACGTACGT", quality: "IIII####" }, ] let qual_config = QualityConfig::{ min_quality: 20, @@ -1102,9 +1050,7 @@ test "sqt_trim_adapter_partial_overlap" { let seq = "ACGTACGTAGATCGGAA" let qual = "IIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" - let (t_seq, _) = sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=1, - ) + let (t_seq, _) = sqt_trim_adapter(seq, qual, adapter, allowed_mismatches=1) assert_eq(t_seq, "ACGTACGT") } @@ -1153,13 +1099,7 @@ test "sqt_fastq_parse_crlf" { ///| test "sqt_compute_stats_all_discarded" { - let reads = [ - FastqRead::{ - id: "r1", - sequence: "ACGT", - quality: "IIII", - }, - ] + let reads = [FastqRead::{ id: "r1", sequence: "ACGT", quality: "IIII" }] let results = [ TrimResult::{ read_id: "r1", @@ -1176,4 +1116,4 @@ test "sqt_compute_stats_all_discarded" { assert_eq(stats.discarded_reads, 1) assert_eq(stats.total_bp_after, 0) assert_eq(stats.gc_content_after, 0.0) -} \ No newline at end of file +} diff --git a/src/seq_utils.mbt b/src/seq_utils.mbt index 9e4ecf4d..6f4be588 100644 --- a/src/seq_utils.mbt +++ b/src/seq_utils.mbt @@ -364,11 +364,17 @@ pub fn reverse_complement(seq : String) -> String { ///| /// Calculate GC skew of a DNA sequence in a sliding window. /// GC skew = (G - C) / (G + C) -pub fn gc_skew(seq : String, window_size : Int, step_size : Int) -> Array[Double] { +pub fn gc_skew( + seq : String, + window_size : Int, + step_size : Int, +) -> Array[Double] { let result : Array[Double] = Array::new() let len = seq.length() - if len < window_size { return result } - + if len < window_size { + return result + } + let mut i = 0 while i <= len - window_size { let window = seq[i:i + window_size].to_owned().to_upper() @@ -377,8 +383,12 @@ pub fn gc_skew(seq : String, window_size : Int, step_size : Int) -> Array[Double let mut j = 0 while j < window.length() { let c = window[j:j + 1] - if c == "G" { g_count = g_count + 1 } - if c == "C" { c_count = c_count + 1 } + if c == "G" { + g_count = g_count + 1 + } + if c == "C" { + c_count = c_count + 1 + } j = j + 1 } let gc_total = g_count.to_double() + c_count.to_double() @@ -395,11 +405,17 @@ pub fn gc_skew(seq : String, window_size : Int, step_size : Int) -> Array[Double ///| /// Calculate AT skew of a DNA sequence in a sliding window. /// AT skew = (A - T) / (A + T) -pub fn at_skew(seq : String, window_size : Int, step_size : Int) -> Array[Double] { +pub fn at_skew( + seq : String, + window_size : Int, + step_size : Int, +) -> Array[Double] { let result : Array[Double] = Array::new() let len = seq.length() - if len < window_size { return result } - + if len < window_size { + return result + } + let mut i = 0 while i <= len - window_size { let window = seq[i:i + window_size].to_owned().to_upper() @@ -408,8 +424,12 @@ pub fn at_skew(seq : String, window_size : Int, step_size : Int) -> Array[Double let mut j = 0 while j < window.length() { let c = window[j:j + 1] - if c == "A" { a_count = a_count + 1 } - if c == "T" { t_count = t_count + 1 } + if c == "A" { + a_count = a_count + 1 + } + if c == "T" { + t_count = t_count + 1 + } j = j + 1 } let at_total = a_count.to_double() + t_count.to_double() @@ -427,8 +447,10 @@ pub fn at_skew(seq : String, window_size : Int, step_size : Int) -> Array[Double /// Calculate sequence similarity between two sequences. pub fn sequence_similarity(seq1 : String, seq2 : String) -> Double { let len = min_val(seq1.length().to_double(), seq2.length().to_double()) - if len == 0.0 { return 0.0 } - + if len == 0.0 { + return 0.0 + } + let mut matches = 0.0 let mut i = 0 while i < len.to_int() { @@ -445,25 +467,29 @@ pub fn sequence_similarity(seq1 : String, seq2 : String) -> Double { pub fn edit_distance(seq1 : String, seq2 : String) -> Int { let m = seq1.length() let n = seq2.length() - - if m == 0 { return n } - if n == 0 { return m } - + + if m == 0 { + return n + } + if n == 0 { + return m + } + // Dynamic programming approach let dp : Array[Array[Int]] = Array::make(m + 1, Array::make(n + 1, 0)) - + let mut i = 0 while i <= m { dp[i][0] = i i = i + 1 } - + let mut j = 0 while j <= n { dp[0][j] = j j = j + 1 } - + i = 1 while i <= m { j = 1 @@ -481,18 +507,29 @@ pub fn edit_distance(seq1 : String, seq2 : String) -> Int { } i = i + 1 } - + dp[m][n] } +///| fn min_val(a : Double, b : Double) -> Double { - if a < b { a } else { b } + if a < b { + a + } else { + b + } } +///| fn min_val_int(a : Int, b : Int) -> Int { - if a < b { a } else { b } + if a < b { + a + } else { + b + } } +///| fn min_val3(a : Int, b : Int, c : Int) -> Int { min_val_int(min_val_int(a, b), c) } diff --git a/src/seqfeature_advanced.mbt b/src/seqfeature_advanced.mbt index 28fc1ae1..85a7db12 100644 --- a/src/seqfeature_advanced.mbt +++ b/src/seqfeature_advanced.mbt @@ -90,11 +90,7 @@ fn parse_int_at(s : String, pos : Int) -> (Int, Int) raise LocationParserError { } if !found { raise LocationParserError( - "Expected integer at position " + - pos.to_string() + - " in '" + - s + - "'", + "Expected integer at position " + pos.to_string() + " in '" + s + "'", ) } (result, i) @@ -217,7 +213,7 @@ pub fn CompoundLocation::order( ///| /// Get the start position of the first part in this compound location. -pub fn compound_start(self : CompoundLocation) -> Position { +pub fn CompoundLocation::compound_start(self : CompoundLocation) -> Position { if self.parts.length() == 0 { return UnknownPosition } @@ -226,7 +222,7 @@ pub fn compound_start(self : CompoundLocation) -> Position { ///| /// Get the end position of the last part in this compound location. -pub fn compound_end(self : CompoundLocation) -> Position { +pub fn CompoundLocation::compound_end(self : CompoundLocation) -> Position { if self.parts.length() == 0 { return UnknownPosition } @@ -237,7 +233,7 @@ pub fn compound_end(self : CompoundLocation) -> Position { /// Extract the compound feature sequence from a parent sequence. /// Each part's sequence is extracted and concatenated in order. /// If any part has strand -1, that part is reverse-complemented. -pub fn compound_extract( +pub fn CompoundLocation::compound_extract( self : CompoundLocation, parent_sequence : Seq, ) -> String raise LocationParserError { @@ -255,7 +251,7 @@ pub fn compound_extract( ///| /// Generate a GenBank-format string representation of this compound location. /// Example: "join(1..100,complement(200..300))" -pub fn compound_to_string(self : CompoundLocation) -> String { +pub fn CompoundLocation::compound_to_string(self : CompoundLocation) -> String { let buf = StringBuilder::new() let strand = self._compound_strand() if strand == Some(-1) { @@ -280,7 +276,7 @@ pub fn compound_to_string(self : CompoundLocation) -> String { /// Determine the compound strand by checking all parts. /// If all parts share the same strand, return that strand. /// Otherwise return None. -fn _compound_strand(self : CompoundLocation) -> Int? { +fn CompoundLocation::_compound_strand(self : CompoundLocation) -> Int? { if self.parts.length() == 0 { return None } @@ -323,13 +319,7 @@ fn _position_gb_string(pos : Position) -> String { BeforePosition(p) => "<" + p.to_string() AfterPosition(p) => ">" + p.to_string() WithinPosition(p, fs, fe) => - "<" + - fs.to_string() + - ".." + - p.to_string() + - ".." + - fe.to_string() + - ">" + "<" + fs.to_string() + ".." + p.to_string() + ".." + fe.to_string() + ">" UncertainPosition(p) => "?" + p.to_string() + "?" UnknownPosition => "?" } @@ -409,9 +399,7 @@ pub fn parse_simple_location( let dot_pos = match trimmed.find(dots) { Some(p) => p None => - raise LocationParserError( - "Expected '..' in location string: " + trimmed, - ) + raise LocationParserError("Expected '..' in location string: " + trimmed) } let start_str = trim_whitespace(trimmed[0:dot_pos].to_owned()) let end_str = trim_whitespace( @@ -435,9 +423,7 @@ pub fn parse_complement_location( let trimmed = trim_whitespace(loc_string) let prefix = "complement(" if !trimmed.starts_with(prefix) { - raise LocationParserError( - "Expected 'complement(' prefix in: " + trimmed, - ) + raise LocationParserError("Expected 'complement(' prefix in: " + trimmed) } let paren_start = prefix.length() - 1 let after_prefix = trim_whitespace( @@ -470,18 +456,13 @@ pub fn parse_join_location( } else if trimmed.starts_with("order(") { ("order", trimmed[5:trimmed.length()].to_owned()) } else { - raise LocationParserError( - "Expected 'join(' or 'order(' in: " + trimmed, - ) + raise LocationParserError("Expected 'join(' or 'order(' in: " + trimmed) } let close_paren = match find_matching_paren(after_op, 0) { Some(p) => p None => raise LocationParserError( - "Missing closing parenthesis in " + - operator + - ": " + - trimmed, + "Missing closing parenthesis in " + operator + ": " + trimmed, ) } let inner = trim_whitespace(after_op[1:close_paren].to_owned()) @@ -493,9 +474,7 @@ pub fn parse_join_location( } let parsed = parse_location_string(part_str) match parsed { - ParsedFeatureLocation(loc) => { - parts.push(loc) - } + ParsedFeatureLocation(loc) => parts.push(loc) ParsedCompoundLocation(_) => raise LocationParserError( "Nested compound locations are not supported in " + @@ -505,12 +484,7 @@ pub fn parse_join_location( ) } } - CompoundLocation::{ - parts, - operator, - ref_seq: None, - ref_db: None, - } + CompoundLocation::{ parts, operator, ref_seq: None, ref_db: None } } ///| @@ -624,7 +598,9 @@ pub fn SeqFeatureExtended::new( ///| /// Get the feature location. -pub fn SeqFeatureExtended::location(self : SeqFeatureExtended) -> FeatureLocation { +pub fn SeqFeatureExtended::location( + self : SeqFeatureExtended, +) -> FeatureLocation { self.location } @@ -657,7 +633,7 @@ pub fn SeqFeatureExtended::qualifiers( ///| /// Add a qualifier key-value pair to this feature. /// If the key already exists, the value is appended to the existing array. -pub fn add_qualifier( +pub fn SeqFeatureExtended::add_qualifier( self : SeqFeatureExtended, key : String, value : String, @@ -675,9 +651,7 @@ pub fn add_qualifier( new_arr.push(value) new_quals[key] = new_arr } - None => { - new_quals[key] = [value] - } + None => new_quals[key] = [value] } SeqFeatureExtended::{ ..self, qualifiers: new_quals } } @@ -685,7 +659,7 @@ pub fn add_qualifier( ///| /// Get qualifier values for a given key. /// Returns an empty array if the key does not exist. -pub fn get_qualifier( +pub fn SeqFeatureExtended::get_qualifier( self : SeqFeatureExtended, key : String, ) -> Array[String] { @@ -702,7 +676,9 @@ pub fn get_qualifier( /// type location /// /key="value" /// /key="value" -pub fn seq_feature_to_string(self : SeqFeatureExtended) -> String { +pub fn SeqFeatureExtended::seq_feature_to_string( + self : SeqFeatureExtended, +) -> String { let buf = StringBuilder::new() buf.write_string(self.type_) buf.write_char(' ') @@ -742,9 +718,7 @@ pub fn location_to_string(loc : FeatureLocation) -> String { /// - strand +1 becomes -1 /// - strand -1 becomes +1 /// - strand 0 or None stays the same -pub fn feature_location_complement( - loc : FeatureLocation, -) -> FeatureLocation { +pub fn feature_location_complement(loc : FeatureLocation) -> FeatureLocation { let new_strand = match loc.strand { Some(s) => if s == 1 { @@ -833,16 +807,8 @@ pub fn merge_locations( let start2 = loc2.start.to_int() let end1 = loc1.end.to_int() let end2 = loc2.end.to_int() - let new_start = if start1 <= start2 { - loc1.start - } else { - loc2.start - } - let new_end = if end1 >= end2 { - loc1.end - } else { - loc2.end - } + let new_start = if start1 <= start2 { loc1.start } else { loc2.start } + let new_end = if end1 >= end2 { loc1.end } else { loc2.end } FeatureLocation::{ start: new_start, end: new_end, @@ -850,4 +816,4 @@ pub fn merge_locations( ref_seq: loc1.ref_seq, ref_db: loc1.ref_db, } -} \ No newline at end of file +} diff --git a/src/seqlogo.mbt b/src/seqlogo.mbt index 46916f9b..8f9f9062 100644 --- a/src/seqlogo.mbt +++ b/src/seqlogo.mbt @@ -60,9 +60,7 @@ fn seqlogo_to_lower(c : Char) -> Char { ///| /// Sort (frequency, base) pairs by frequency descending (selection sort). -fn seqlogo_sort_desc( - pairs : Array[(Double, Int)], -) -> Array[(Double, Int)] { +fn seqlogo_sort_desc(pairs : Array[(Double, Int)]) -> Array[(Double, Int)] { let sorted = pairs.copy() let n = sorted.length() let mut i = 0 @@ -102,24 +100,13 @@ pub struct SeqLogoPwm { /// Construct a PWM from a 4 x L matrix (row 0 = A, 1 = C, 2 = G, 3 = T). pub fn SeqLogoPwm::new(matrix : Array[Array[Double]]) -> SeqLogoPwm { let alphabet_size = matrix.length() - let width = if alphabet_size > 0 { - matrix[0].length() - } else { - 0 - } - SeqLogoPwm::{ - matrix, - width, - alphabet_size, - alphabet: ["A", "C", "G", "T"], - } + let width = if alphabet_size > 0 { matrix[0].length() } else { 0 } + SeqLogoPwm::{ matrix, width, alphabet_size, alphabet: ["A", "C", "G", "T"] } } ///| /// Build a PWM from a set of equal-length aligned DNA sequences. -pub fn SeqLogoPwm::from_sequences( - sequences : Array[String], -) -> SeqLogoPwm { +pub fn SeqLogoPwm::from_sequences(sequences : Array[String]) -> SeqLogoPwm { let n = sequences.length() if n == 0 { return SeqLogoPwm::new(Array::new()) @@ -174,10 +161,7 @@ pub fn SeqLogoPwm::alphabet(self : SeqLogoPwm) -> Array[String] { ///| /// Frequency of `base` (0-3) at `pos`. pub fn SeqLogoPwm::get(self : SeqLogoPwm, base : Int, pos : Int) -> Double { - if base >= 0 && - base < self.alphabet_size && - pos >= 0 && - pos < self.width { + if base >= 0 && base < self.alphabet_size && pos >= 0 && pos < self.width { self.matrix[base][pos] } else { 0.0 @@ -255,11 +239,7 @@ pub fn SeqLogoColumn::new( position : Int, info_content : Double, ) -> SeqLogoColumn { - SeqLogoColumn::{ - letters: Array::new(), - info_content, - position, - } + SeqLogoColumn::{ letters: Array::new(), info_content, position } } ///| @@ -300,9 +280,7 @@ pub struct SeqLogoResult { ///| /// Construct a SeqLogoResult, computing total IC and width from the columns. -pub fn SeqLogoResult::new( - columns : Array[SeqLogoColumn], -) -> SeqLogoResult { +pub fn SeqLogoResult::new(columns : Array[SeqLogoColumn]) -> SeqLogoResult { let mut total_ic = 0.0 for col in columns { total_ic = total_ic + col.info_content() @@ -476,19 +454,12 @@ pub fn seqlogo_compute_logo_bg( /// information contribution. Uppercase letters mark large contributions and /// lowercase letters mark small ones. `max_height` is the row count used for /// the tallest possible column (2 bits for DNA). -pub fn seqlogo_to_ascii( - logo : SeqLogoResult, - max_height : Int, -) -> String { +pub fn seqlogo_to_ascii(logo : SeqLogoResult, max_height : Int) -> String { if max_height <= 0 { return "" } let max_ic = seqlogo_max_information_content(4) - let scale = if max_ic > 0.0 { - max_height.to_double() / max_ic - } else { - 0.0 - } + let scale = if max_ic > 0.0 { max_height.to_double() / max_ic } else { 0.0 } // Build a per-column stack of characters from bottom (index 0) to top. let stacks : Array[Array[Char]] = Array::new() for col in logo.columns() { @@ -627,21 +598,13 @@ pub fn seqlogo_sample_pwm() -> SeqLogoPwm { // 4 rows (A, C, G, T) x 10 columns. let matrix = [ // A - [ - 0.90, 0.10, 0.25, 0.05, 0.20, 0.01, 0.40, 0.85, 0.15, 0.30, - ], + [0.90, 0.10, 0.25, 0.05, 0.20, 0.01, 0.40, 0.85, 0.15, 0.30], // C - [ - 0.03, 0.10, 0.25, 0.90, 0.30, 0.02, 0.40, 0.05, 0.15, 0.30, - ], + [0.03, 0.10, 0.25, 0.90, 0.30, 0.02, 0.40, 0.05, 0.15, 0.30], // G - [ - 0.04, 0.70, 0.25, 0.03, 0.30, 0.03, 0.10, 0.05, 0.55, 0.20, - ], + [0.04, 0.70, 0.25, 0.03, 0.30, 0.03, 0.10, 0.05, 0.55, 0.20], // T - [ - 0.03, 0.10, 0.25, 0.02, 0.20, 0.94, 0.10, 0.05, 0.15, 0.20, - ], + [0.03, 0.10, 0.25, 0.02, 0.20, 0.94, 0.10, 0.05, 0.15, 0.20], ] SeqLogoPwm::new(matrix) } @@ -650,25 +613,9 @@ pub fn seqlogo_sample_pwm() -> SeqLogoPwm { /// Twenty aligned DNA sequences of length 10 used to build a sample PWM. pub fn seqlogo_sample_sequences() -> Array[String] { [ - "AGACATGAGC", - "AGACATGAGG", - "CGACGTGAGT", - "AGTCATGAGC", - "GGACATGAGC", - "AGGCATGAGC", - "AGACGTGATC", - "AGACATGTGC", - "AGACATGCGC", - "TGACATGAGC", - "AGACATGAGA", - "AGACATGAGC", - "CGACATGAGG", - "AGATATGAGC", - "AGACACGAGC", - "AGAGATGAGC", - "AGACATGAGG", - "AGACATGACC", - "AGACATGTGC", - "AAACATGAGC", + "AGACATGAGC", "AGACATGAGG", "CGACGTGAGT", "AGTCATGAGC", "GGACATGAGC", "AGGCATGAGC", + "AGACGTGATC", "AGACATGTGC", "AGACATGCGC", "TGACATGAGC", "AGACATGAGA", "AGACATGAGC", + "CGACATGAGG", "AGATATGAGC", "AGACACGAGC", "AGAGATGAGC", "AGACATGAGG", "AGACATGACC", + "AGACATGTGC", "AAACATGAGC", ] } diff --git a/src/seqxml_io.mbt b/src/seqxml_io.mbt index 439582b8..f984ab22 100644 --- a/src/seqxml_io.mbt +++ b/src/seqxml_io.mbt @@ -281,11 +281,7 @@ fn seqxml_is_tag_delim(c : UInt16) -> Bool { /// Find the next opening tag named `tag_name` at or after position `from`. /// Returns the position of the "<" or None. A tag boundary (whitespace, ">", /// or "/") must follow the tag name to avoid prefix matches. -fn seqxml_find_tag( - content : String, - tag_name : String, - from : Int, -) -> Int? { +fn seqxml_find_tag(content : String, tag_name : String, from : Int) -> Int? { let pattern = "<" + tag_name let plen = pattern.length() let n = content.length() @@ -410,11 +406,7 @@ fn seqxml_extract_attr_value(tag : String, attr : String) -> String? { ///| /// Extract an attribute value and XML-unescape it, returning `default` /// when the attribute is absent. -fn seqxml_attr_or( - tag : String, - attr : String, - default : String, -) -> String { +fn seqxml_attr_or(tag : String, attr : String, default : String) -> String { match seqxml_extract_attr_value(tag, attr) { Some(v) => seqxml_unescape(v) None => default @@ -424,30 +416,33 @@ fn seqxml_attr_or( ///| /// Escape a string for use inside an XML attribute value. fn seqxml_escape_attr(s : String) -> String { - s.replace(old="&", new="&") - .replace(old="<", new="<") - .replace(old=">", new=">") - .replace(old="\"", new=""") - .replace(old="'", new="'") + s + .replace(old="&", new="&") + .replace(old="<", new="<") + .replace(old=">", new=">") + .replace(old="\"", new=""") + .replace(old="'", new="'") } ///| /// Escape a string for use as XML text content. fn seqxml_escape_text(s : String) -> String { - s.replace(old="&", new="&") - .replace(old="<", new="<") - .replace(old=">", new=">") + s + .replace(old="&", new="&") + .replace(old="<", new="<") + .replace(old=">", new=">") } ///| /// Decode XML entities (& < > " ') back to characters. /// & is decoded last to avoid double-decoding. fn seqxml_unescape(s : String) -> String { - s.replace(old="<", new="<") - .replace(old=">", new=">") - .replace(old=""", new="\"") - .replace(old="'", new="'") - .replace(old="&", new="&") + s + .replace(old="<", new="<") + .replace(old=">", new=">") + .replace(old=""", new="\"") + .replace(old="'", new="'") + .replace(old="&", new="&") } ///| @@ -492,9 +487,9 @@ fn seqxml_parse_header(content : String, doc : SeqXmlDocument) -> Unit { Some(start) => match seqxml_find_tag_end(content, start) { Some(gt_pos) => { - let body = content[start + 1 : gt_pos].to_owned() + let body = content[start + 1:gt_pos].to_owned() let clean = if body.has_suffix("/") { - body[0 : body.length() - 1].to_owned() + body[0:body.length() - 1].to_owned() } else { body } @@ -510,9 +505,9 @@ fn seqxml_parse_header(content : String, doc : SeqXmlDocument) -> Unit { Some(start) => match seqxml_find_tag_end(content, start) { Some(gt_pos) => { - let body = content[start + 1 : gt_pos].to_owned() + let body = content[start + 1:gt_pos].to_owned() let clean = if body.has_suffix("/") { - body[0 : body.length() - 1].to_owned() + body[0:body.length() - 1].to_owned() } else { body } @@ -537,7 +532,7 @@ fn seqxml_extract_element_text(inner : String, tag : String) -> String? { let close_tag = "" match seqxml_index_of_from(inner, close_tag, content_start) { Some(close_pos) => { - let text = inner[content_start : close_pos].to_owned() + let text = inner[content_start:close_pos].to_owned() Some(seqxml_unescape(seqxml_trim_ws(text))) } None => None @@ -581,9 +576,9 @@ fn seqxml_parse_properties(inner : String) -> Array[(String, String)] { Some(prop_start) => match seqxml_find_tag_end(inner, prop_start) { Some(gt_pos) => { - let body = inner[prop_start + 1 : gt_pos].to_owned() + let body = inner[prop_start + 1:gt_pos].to_owned() let clean = if body.has_suffix("/") { - body[0 : body.length() - 1].to_owned() + body[0:body.length() - 1].to_owned() } else { body } @@ -623,10 +618,10 @@ pub fn seqxml_parse(content : String) -> SeqXmlDocument { match seqxml_find_tag_end(content, entry_start) { None => break Some(gt_pos) => { - let body = content[entry_start + 1 : gt_pos].to_owned() + let body = content[entry_start + 1:gt_pos].to_owned() let self_closing = body.has_suffix("/") let clean_body = if self_closing { - body[0 : body.length() - 1].to_owned() + body[0:body.length() - 1].to_owned() } else { body } @@ -640,7 +635,7 @@ pub fn seqxml_parse(content : String) -> SeqXmlDocument { } let (seq_type, sequence, properties) = match close_pos_opt { Some(close_pos) => { - let inner = content[inner_start : close_pos].to_owned() + let inner = content[inner_start:close_pos].to_owned() let (st, seq) = seqxml_parse_sequence(inner) let props = seqxml_parse_properties(inner) (st, seq, props) @@ -677,9 +672,9 @@ pub fn seqxml_parse_entry_id(line : String) -> String? { Some(start) => match seqxml_find_tag_end(line, start) { Some(gt_pos) => { - let body = line[start + 1 : gt_pos].to_owned() + let body = line[start + 1:gt_pos].to_owned() let clean = if body.has_suffix("/") { - body[0 : body.length() - 1].to_owned() + body[0:body.length() - 1].to_owned() } else { body } diff --git a/src/seurat.mbt b/src/seurat.mbt index 239bd794..723c2611 100644 --- a/src/seurat.mbt +++ b/src/seurat.mbt @@ -48,7 +48,7 @@ pub fn SeuratObject::new( pub fn normalize_total(obj : SeuratObject) -> SeuratObject { let n_genes = obj.row_names.length() let n_cells = obj.col_names.length() - + // Precompute column sums (O(n_genes * n_cells) instead of O(n_genes^2 * n_cells)) let col_sums : Array[Double] = Array::make(n_cells, 0.0) let mut i = 0 @@ -60,7 +60,7 @@ pub fn normalize_total(obj : SeuratObject) -> SeuratObject { } i = i + 1 } - + let data : Array[Array[Double]] = Array::new() i = 0 while i < n_genes { @@ -84,24 +84,21 @@ pub fn normalize_total(obj : SeuratObject) -> SeuratObject { data.push(gene_data) i = i + 1 } - - SeuratObject::{ - ..obj, - data, - } + + SeuratObject::{ ..obj, data, } } ///| pub fn find_variable_features(obj : SeuratObject) -> SeuratObject { let n_genes = obj.row_names.length() let n_cells = obj.col_names.length() - + let gene_indices : Array[(Double, Int)] = Array::new() let mut k = 0 while k < n_genes { let row_data = obj.data[k] let (mean_val, var_val) = stat_mean_var(row_data) - + let vst_score = if mean_val > 0.0 && var_val > 0.0 { let expected_var = mean_val + mean_val * mean_val * 0.5 @math.ln(var_val / expected_var) @@ -111,9 +108,9 @@ pub fn find_variable_features(obj : SeuratObject) -> SeuratObject { gene_indices.push((vst_score, k)) k = k + 1 } - + let sorted_indices = stat_sort_indices_desc(gene_indices) - + let var_features : Array[String] = Array::new() let nfeatures = if n_genes < 2000 { n_genes } else { 2000 } let mut n_selected = 0 @@ -121,25 +118,22 @@ pub fn find_variable_features(obj : SeuratObject) -> SeuratObject { var_features.push(obj.row_names[sorted_indices[n_selected].1]) n_selected = n_selected + 1 } - - SeuratObject::{ - ..obj, - var_features, - } + + SeuratObject::{ ..obj, var_features, } } ///| pub fn scale_data(obj : SeuratObject) -> SeuratObject { let n_genes = obj.row_names.length() let n_cells = obj.col_names.length() - + let scaled_data : Array[Array[Double]] = Array::new() let mut i = 0 while i < n_genes { let row_data = obj.data[i] let (mean_val, var_val) = stat_mean_var(row_data) let std_val = if var_val > 0.0 { var_val.sqrt() } else { 1.0 } - + let gene_scaled : Array[Double] = Array::new() let mut j = 0 while j < n_cells { @@ -149,24 +143,21 @@ pub fn scale_data(obj : SeuratObject) -> SeuratObject { scaled_data.push(gene_scaled) i = i + 1 } - - SeuratObject::{ - ..obj, - scaled_data, - } + + SeuratObject::{ ..obj, scaled_data, } } ///| pub fn run_pca(obj : SeuratObject) -> SeuratObject { let n_genes = obj.row_names.length() let n_cells = obj.col_names.length() - + let use_features = if obj.var_features.length() > 0 { obj.var_features } else { obj.row_names } - + let feature_indices : Array[Int] = Array::new() for feature in use_features { let mut idx = 0 @@ -178,19 +169,25 @@ pub fn run_pca(obj : SeuratObject) -> SeuratObject { idx = idx + 1 } } - + let n_features = feature_indices.length() let npcs = if n_features < 50 { n_features } else { 50 } - - let pca = compute_pca_simple(obj.scaled_data, feature_indices, n_features, n_cells, npcs) - + + let pca = compute_pca_simple( + obj.scaled_data, + feature_indices, + n_features, + n_cells, + npcs, + ) + let var_explained : Array[Double] = Array::new() let mut m = 0 while m < npcs { var_explained.push((1.0 - m.to_double() / npcs.to_double()) * 0.3) m = m + 1 } - + let pca_loadings : Array[Array[Double]] = Array::new() let mut n = 0 while n < n_features { @@ -203,15 +200,11 @@ pub fn run_pca(obj : SeuratObject) -> SeuratObject { pca_loadings.push(loading) n = n + 1 } - - SeuratObject::{ - ..obj, - pca, - pca_loadings, - var_explained, - } + + SeuratObject::{ ..obj, pca, pca_loadings, var_explained } } +///| fn compute_pca_simple( scaled_data : Array[Array[Double]], feature_indices : Array[Int], @@ -220,11 +213,11 @@ fn compute_pca_simple( npcs : Int, ) -> Array[Array[Double]] { let pca : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_cells { let pc : Array[Double] = Array::new() - + let mut j = 0 while j < npcs && j < n_features { let mut score = 0.0 @@ -237,17 +230,17 @@ fn compute_pca_simple( pc.push(score) j = j + 1 } - + let mut pad = j while pad < npcs { pc.push(0.0) pad = pad + 1 } - + pca.push(pc) i = i + 1 } - + pca } @@ -258,15 +251,13 @@ pub fn find_neighbors(obj : SeuratObject) -> SeuratObject { return obj } let n_dims = obj.pca[0].length() - + let neighbors = find_neighbors_helper(obj.pca, n_cells, n_dims, 20) - - SeuratObject::{ - ..obj, - neighbors, - } + + SeuratObject::{ ..obj, neighbors, } } +///| fn find_neighbors_helper( pca : Array[Array[Double]], n_cells : Int, @@ -292,6 +283,7 @@ fn find_neighbors_helper( neighbors } +///| fn sort_distances(arr : Array[(Double, Int)]) -> Array[(Double, Int)] { stat_sort_indices_desc(arr) } @@ -299,11 +291,11 @@ fn sort_distances(arr : Array[(Double, Int)]) -> Array[(Double, Int)] { ///| pub fn find_clusters(obj : SeuratObject) -> SeuratObject { let n_cells = obj.col_names.length() - + if obj.clusters.length() > 0 && obj.clusters[0] != -1 { return obj } - + let clusters : Array[Int] = Array::new() let n_clusters = 4 let mut i = 0 @@ -311,11 +303,8 @@ pub fn find_clusters(obj : SeuratObject) -> SeuratObject { clusters.push(i / (n_cells / n_clusters)) i = i + 1 } - - SeuratObject::{ - ..obj, - clusters, - } + + SeuratObject::{ ..obj, clusters, } } ///| @@ -325,15 +314,13 @@ pub fn run_umap(obj : SeuratObject) -> SeuratObject { return obj } let n_components = 2 - + let umap = init_umap_coords(n_cells, n_components) - - SeuratObject::{ - ..obj, - umap, - } + + SeuratObject::{ ..obj, umap, } } +///| fn init_umap_coords(n_cells : Int, n_components : Int) -> Array[Array[Double]] { let coords : Array[Array[Double]] = Array::new() let mut seed = 42 @@ -367,7 +354,11 @@ pub struct IntegrationAnchor { } ///| -pub fn IntegrationAnchor::new(cell1 : Int, cell2 : Int, score : Double) -> IntegrationAnchor { +pub fn IntegrationAnchor::new( + cell1 : Int, + cell2 : Int, + score : Double, +) -> IntegrationAnchor { IntegrationAnchor::{ cell1, cell2, score } } @@ -395,29 +386,34 @@ pub fn find_integration_anchors( ) -> IntegrationAnchors { let n_ref_cells = reference_obj.col_names.length() let n_query_cells = query_obj.col_names.length() - + let anchors : Array[IntegrationAnchor] = Array::new() let reference_indices : Array[Int] = Array::new() let query_indices : Array[Int] = Array::new() - + if reference_obj.pca.length() == 0 || query_obj.pca.length() == 0 { return IntegrationAnchors::new(anchors, reference_indices, query_indices) } - - let n_anchors = if n_ref_cells < n_query_cells { n_ref_cells / 10 } else { n_query_cells / 10 } - + + let n_anchors = if n_ref_cells < n_query_cells { + n_ref_cells / 10 + } else { + n_query_cells / 10 + } + let mut i = 0 while i < n_anchors && i < n_ref_cells && i < n_query_cells { let ref_idx = i let query_idx = i - + let mut dist = 0.0 let mut dim_count = 0 - + let mut j = 0 while j < dims.length() { let d = dims[j] - if ref_idx < reference_obj.pca.length() && query_idx < query_obj.pca.length() { + if ref_idx < reference_obj.pca.length() && + query_idx < query_obj.pca.length() { let ref_pca = reference_obj.pca[ref_idx] let query_pca = query_obj.pca[query_idx] if d < ref_pca.length() && d < query_pca.length() { @@ -428,16 +424,20 @@ pub fn find_integration_anchors( } j = j + 1 } - - let score = if dist > 0.0 && dim_count > 0 { 1.0 / dist.sqrt() } else { 1.0 } - + + let score = if dist > 0.0 && dim_count > 0 { + 1.0 / dist.sqrt() + } else { + 1.0 + } + anchors.push(IntegrationAnchor::new(ref_idx, query_idx, score)) reference_indices.push(ref_idx) query_indices.push(query_idx) - + i = i + 1 } - + IntegrationAnchors::new(anchors, reference_indices, query_indices) } @@ -449,7 +449,7 @@ pub fn integrate_data( ) -> SeuratObject { let n_ref_genes = reference_obj.row_names.length() let n_query_genes = query_obj.row_names.length() - + let common_genes : Array[String] = Array::new() for gene in reference_obj.row_names { let mut found = false @@ -465,32 +465,32 @@ pub fn integrate_data( common_genes.push(gene) } } - + let n_common = common_genes.length() let n_ref_cells = reference_obj.col_names.length() let n_query_cells = query_obj.col_names.length() let n_total_cells = n_ref_cells + n_query_cells - + let integrated_counts : Array[Array[Int]] = Array::new() let row_names : Array[String] = Array::new() let col_names : Array[String] = Array::new() - + let mut i = 0 while i < n_common { let gene = common_genes[i] - + let mut ref_idx = 0 while ref_idx < n_ref_genes && reference_obj.row_names[ref_idx] != gene { ref_idx = ref_idx + 1 } - + let mut query_idx = 0 while query_idx < n_query_genes && query_obj.row_names[query_idx] != gene { query_idx = query_idx + 1 } - + row_names.push(gene) - + let gene_counts : Array[Int] = Array::new() let mut j = 0 while j < n_ref_cells { @@ -503,10 +503,10 @@ pub fn integrate_data( k = k + 1 } integrated_counts.push(gene_counts) - + i = i + 1 } - + let mut l = 0 while l < n_ref_cells { col_names.push("ref_" + reference_obj.col_names[l]) @@ -517,9 +517,11 @@ pub fn integrate_data( col_names.push("query_" + query_obj.col_names[m]) m = m + 1 } - - let integrated_obj = SeuratObject::new(integrated_counts, row_names, col_names) - + + let integrated_obj = SeuratObject::new( + integrated_counts, row_names, col_names, + ) + let clusters : Array[Int] = Array::new() let mut n = 0 while n < n_ref_cells { @@ -528,15 +530,16 @@ pub fn integrate_data( } let mut o = 0 while o < n_query_cells { - let offset = if query_obj.clusters.length() > 0 { query_obj.clusters[o] + 10 } else { 10 } + let offset = if query_obj.clusters.length() > 0 { + query_obj.clusters[o] + 10 + } else { + 10 + } clusters.push(offset) o = o + 1 } - - SeuratObject::{ - ..integrated_obj, - clusters, - } + + SeuratObject::{ ..integrated_obj, clusters, } } ///| @@ -558,62 +561,62 @@ pub fn MarkerResult::new( p_value : Double, adjusted_p_value : Double, ) -> MarkerResult { - MarkerResult::{ - gene, - avg_log2_fc, - pct_1, - pct_2, - p_value, - adjusted_p_value, - } + MarkerResult::{ gene, avg_log2_fc, pct_1, pct_2, p_value, adjusted_p_value } } ///| pub fn find_all_markers(obj : SeuratObject) -> Array[MarkerResult] { let markers : Array[MarkerResult] = Array::new() - + let n_clusters = 4 let mut i = 0 while i < n_clusters && i < obj.row_names.length() { - markers.push(MarkerResult::new( - obj.row_names[i * 100], - 2.0 + i.to_double() * 0.5, - 0.8 + i.to_double() * 0.05, - 0.2 + i.to_double() * 0.05, - 0.001 / (i.to_double() + 1.0), - 0.01 / (i.to_double() + 1.0), - )) + markers.push( + MarkerResult::new( + obj.row_names[i * 100], + 2.0 + i.to_double() * 0.5, + 0.8 + i.to_double() * 0.05, + 0.2 + i.to_double() * 0.05, + 0.001 / (i.to_double() + 1.0), + 0.01 / (i.to_double() + 1.0), + ), + ) i = i + 1 } - + markers } ///| -pub fn get_top_markers(markers : Array[MarkerResult], n : Int) -> Array[MarkerResult] { +pub fn get_top_markers( + markers : Array[MarkerResult], + n : Int, +) -> Array[MarkerResult] { let indexed : Array[(Double, Int)] = Array::new() let mut i = 0 while i < markers.length() { indexed.push((markers[i].adjusted_p_value, i)) i = i + 1 } - + let sorted = sort_by_p_value(indexed) - + let result : Array[MarkerResult] = Array::new() let mut j = 0 while j < n && j < sorted.length() { result.push(markers[sorted[j].1]) j = j + 1 } - + result } +///| fn sort_by_p_value(arr : Array[(Double, Int)]) -> Array[(Double, Int)] { stat_sort_indices_asc(arr) } +///| fn sort_indices_desc(arr : Array[(Double, Int)]) -> Array[(Double, Int)] { stat_sort_indices_desc(arr) } @@ -622,17 +625,18 @@ fn sort_indices_desc(arr : Array[(Double, Int)]) -> Array[(Double, Int)] { fn t_cdf(t : Double, df : Double) -> Double { let x = t / (1.0 + t * t / df).sqrt() let z = (1.0 + x) / 2.0 - + let mut sum = z let mut term = z * (1.0 - z) let mut i = 1 while i <= 50 { - let coeff = ((df - 1.0) / 2.0 + i.to_double() - 1.0) / (i.to_double() * (df / 2.0 + i.to_double() - 1.0)) + let coeff = ((df - 1.0) / 2.0 + i.to_double() - 1.0) / + (i.to_double() * (df / 2.0 + i.to_double() - 1.0)) sum = sum + coeff * term term = term * (1.0 - z) * z i = i + 1 } - + 0.5 * (1.0 + sum) } @@ -641,23 +645,27 @@ pub fn seurat_create_example_data() -> SeuratObject { let n_cells = 200 let n_genes = 500 let n_clusters = 4 - + let counts : Array[Array[Int]] = Array::new() let row_names : Array[String] = Array::new() let col_names : Array[String] = Array::new() - + let mut seed = 12345 let mut i = 0 while i < n_genes { row_names.push("gene_" + i.to_string()) let gene_counts : Array[Int] = Array::new() - + let mut j = 0 while j < n_cells { let cluster_id = j / (n_cells / n_clusters) let marker_gene_cluster = i % n_clusters - let cluster_factor = if marker_gene_cluster == cluster_id { 3.0 } else { 0.5 } - + let cluster_factor = if marker_gene_cluster == cluster_id { + 3.0 + } else { + 0.5 + } + let mut x = 0.0 let mut k = 0 while k < 12 { @@ -667,33 +675,30 @@ pub fn seurat_create_example_data() -> SeuratObject { k = k + 1 } x = x - 6.0 - + let base_count = (@math.exp(x) * cluster_factor).to_int() gene_counts.push(if base_count > 0 { base_count } else { 0 }) j = j + 1 } - + counts.push(gene_counts) i = i + 1 } - + let mut l = 0 while l < n_cells { col_names.push("cell_" + l.to_string()) l = l + 1 } - + let obj = SeuratObject::new(counts, row_names, col_names) - + let clusters : Array[Int] = Array::new() let mut m = 0 while m < n_cells { clusters.push(m / (n_cells / n_clusters)) m = m + 1 } - - SeuratObject::{ - ..obj, - clusters, - } + + SeuratObject::{ ..obj, clusters, } } diff --git a/src/sff_io.mbt b/src/sff_io.mbt index 87844cb8..6334944b 100644 --- a/src/sff_io.mbt +++ b/src/sff_io.mbt @@ -87,7 +87,12 @@ pub struct SffFile { ///| /// Create a new SFF header. -pub fn SffHeader::new(n_reads : Int, n_flows : Int, flow_chars : String, key_sequence : String) -> SffHeader { +pub fn SffHeader::new( + n_reads : Int, + n_flows : Int, + flow_chars : String, + key_sequence : String, +) -> SffHeader { let key_length = key_sequence.length() // Fixed header is 32 bytes + n_flows + key_length, padded to multiple of 8 let base_length = 32 + n_flows + key_length @@ -103,7 +108,7 @@ pub fn SffHeader::new(n_reads : Int, n_flows : Int, flow_chars : String, key_seq n_flows, flowgram_format: sff_flowgram_format_u16, flow_chars, - key_sequence + key_sequence, } } @@ -136,19 +141,37 @@ pub fn SffHeader::sff_key_sequence(self : SffHeader) -> String { pub fn SffHeader::sff_validate(self : SffHeader) -> Array[String] { let errors : Array[String] = Array::new() if self.magic != sff_magic { - errors.push("Invalid magic number: expected " + sff_magic.to_string() + ", got " + self.magic.to_string()) + errors.push( + "Invalid magic number: expected " + + sff_magic.to_string() + + ", got " + + self.magic.to_string(), + ) } if self.version != sff_version { errors.push("Unsupported version: " + self.version.to_string()) } if self.header_length % 8 != 0 { - errors.push("Header length must be a multiple of 8, got " + self.header_length.to_string()) + errors.push( + "Header length must be a multiple of 8, got " + + self.header_length.to_string(), + ) } if self.flowgram_format != sff_flowgram_format_u16 { - errors.push("Unsupported flowgram format: " + self.flowgram_format.to_string() + " (only format 1/u16 is supported)") + errors.push( + "Unsupported flowgram format: " + + self.flowgram_format.to_string() + + " (only format 1/u16 is supported)", + ) } if self.flow_chars.length() != self.n_flows { - errors.push("Flow chars length (" + self.flow_chars.length().to_string() + ") does not match n_flows (" + self.n_flows.to_string() + ")") + errors.push( + "Flow chars length (" + + self.flow_chars.length().to_string() + + ") does not match n_flows (" + + self.n_flows.to_string() + + ")", + ) } if self.key_sequence.length() != self.key_length { errors.push("Key sequence length does not match key_length") @@ -160,7 +183,17 @@ pub fn SffHeader::sff_validate(self : SffHeader) -> Array[String] { ///| /// Create a new SFF read record. -pub fn SffRead::new(name : String, bases : String, qualities : Array[Int], flowgram : Array[Double], flow_index : Array[Int], clip_qual_left : Int, clip_qual_right : Int, clip_adapter_left : Int, clip_adapter_right : Int) -> SffRead { +pub fn SffRead::new( + name : String, + bases : String, + qualities : Array[Int], + flowgram : Array[Double], + flow_index : Array[Int], + clip_qual_left : Int, + clip_qual_right : Int, + clip_adapter_left : Int, + clip_adapter_right : Int, +) -> SffRead { let name_length = name.length() let n_bases = bases.length() // read_header_length = 16 (fixed) + name_length, padded to multiple of 8 @@ -178,7 +211,7 @@ pub fn SffRead::new(name : String, bases : String, qualities : Array[Int], flowg flowgram, flow_index, bases, - qualities + qualities, } } @@ -222,7 +255,11 @@ pub fn SffRead::sff_flow_index(self : SffRead) -> Array[Int] { /// Get the clipped sequence (after applying quality clipping). pub fn SffRead::sff_clipped_bases(self : SffRead) -> String { let left = if self.clip_qual_left > 0 { self.clip_qual_left - 1 } else { 0 } - let right = if self.clip_qual_right > 0 { self.clip_qual_right } else { self.n_bases } + let right = if self.clip_qual_right > 0 { + self.clip_qual_right + } else { + self.n_bases + } if left >= right || left >= self.n_bases { return "" } @@ -234,7 +271,11 @@ pub fn SffRead::sff_clipped_bases(self : SffRead) -> String { /// Get the clipped quality scores. pub fn SffRead::sff_clipped_qualities(self : SffRead) -> Array[Int] { let left = if self.clip_qual_left > 0 { self.clip_qual_left - 1 } else { 0 } - let right = if self.clip_qual_right > 0 { self.clip_qual_right } else { self.n_bases } + let right = if self.clip_qual_right > 0 { + self.clip_qual_right + } else { + self.n_bases + } let result : Array[Int] = Array::new() if left >= right || left >= self.n_bases { return result @@ -329,24 +370,23 @@ pub fn SffFile::sff_total_bases(self : SffFile) -> Int { /// Pad a length up to the next multiple of 8. fn sff_pad_to_8(n : Int) -> Int { let rem = n % 8 - if rem == 0 { n } else { n + (8 - rem) } + if rem == 0 { + n + } else { + n + (8 - rem) + } } ///| /// Encode a 32-bit unsigned integer as 4 big-endian bytes. fn sff_encode_u32(v : Int) -> Array[Int] { - [ - (v / 16777216) % 256, - (v / 65536) % 256, - (v / 256) % 256, - v % 256 - ] + [v / 16777216 % 256, v / 65536 % 256, v / 256 % 256, v % 256] } ///| /// Encode a 16-bit unsigned integer as 2 big-endian bytes. fn sff_encode_u16(v : Int) -> Array[Int] { - [(v / 256) % 256, v % 256] + [v / 256 % 256, v % 256] } ///| @@ -361,7 +401,10 @@ fn sff_encode_u64(v : Int) -> Array[Int] { ///| /// Read a 32-bit big-endian unsigned integer from a byte array at a position. fn sff_read_u32(bytes : Array[Int], pos : Int) -> Int { - bytes[pos] * 16777216 + bytes[pos + 1] * 65536 + bytes[pos + 2] * 256 + bytes[pos + 3] + bytes[pos] * 16777216 + + bytes[pos + 1] * 65536 + + bytes[pos + 2] * 256 + + bytes[pos + 3] } ///| @@ -547,7 +590,10 @@ pub fn sff_encode(file : SffFile) -> Array[Int] { qi = qi + 1 } // Padding to multiple of 8 for read data section - let data_len = read.flowgram.length() * 2 + read.flow_index.length() + read.bases.length() + read.qualities.length() + let data_len = read.flowgram.length() * 2 + + read.flow_index.length() + + read.bases.length() + + read.qualities.length() let data_pad = sff_pad_to_8(data_len) - data_len let mut dp = 0 while dp < data_pad { @@ -597,7 +643,7 @@ pub fn sff_parse(bytes : Array[Int]) -> SffFile? { n_flows, flowgram_format, flow_chars, - key_sequence + key_sequence, } // ===== Per-read data ===== let reads : Array[SffRead] = Array::new() @@ -656,7 +702,7 @@ pub fn sff_parse(bytes : Array[Int]) -> SffFile? { flowgram, flow_index, bases, - qualities + qualities, }) // Advance to next read (with padding) let data_len = n_flows * 2 + n_bases + n_bases + n_bases @@ -696,7 +742,7 @@ pub fn sff_create_example_file() -> SffFile { 1, 10, 0, - 0 + 0, ) let read2 = SffRead::new( "READ0002", @@ -707,7 +753,7 @@ pub fn sff_create_example_file() -> SffFile { 1, 10, 0, - 0 + 0, ) SffFile::new(header, [read1, read2]) } @@ -724,7 +770,7 @@ pub fn sff_create_example_read() -> SffRead { 1, 8, 0, - 0 + 0, ) } diff --git a/src/sgseq.mbt b/src/sgseq.mbt index 572c482b..dd0b3c51 100644 --- a/src/sgseq.mbt +++ b/src/sgseq.mbt @@ -68,8 +68,8 @@ pub fn SGSeqJunction::new( chr~ : String, start~ : Int, end~ : Int, - strand~ : String = "+", - count~ : Int = 1, + strand? : String = "+", + count? : Int = 1, ) -> SGSeqJunction { SGSeqJunction::{ chr, start, end, strand, count } } @@ -115,16 +115,9 @@ pub fn SGSeqExon::new( chr~ : String, start~ : Int, end~ : Int, - strand~ : String = "+", + strand? : String = "+", ) -> SGSeqExon { - SGSeqExon::{ - chr, - start, - end, - strand, - count: 0, - is_cassette: false, - } + SGSeqExon::{ chr, start, end, strand, count: 0, is_cassette: false } } ///| @@ -157,8 +150,8 @@ pub fn SGSeqFeature::new( chr~ : String, start~ : Int, end~ : Int, - strand~ : String = "+", - count~ : Int = 0, + strand? : String = "+", + count? : Int = 0, ) -> SGSeqFeature { SGSeqFeature::{ type_, chr, start, end, strand, count } } @@ -183,7 +176,7 @@ pub fn SGSeqVariant::new( chr~ : String, start~ : Int, end~ : Int, - strand~ : String = "+", + strand? : String = "+", variant_type~ : SGSeqVariantType, ) -> SGSeqVariant { SGSeqVariant::{ @@ -207,13 +200,19 @@ pub fn SGSeqVariant::type_name(self : SGSeqVariant) -> String { ///| /// Set inclusion count. -pub fn SGSeqVariant::set_inclusion_count(self : SGSeqVariant, val : Int) -> Unit { +pub fn SGSeqVariant::set_inclusion_count( + self : SGSeqVariant, + val : Int, +) -> Unit { self.inclusion_count = val } ///| /// Set exclusion count. -pub fn SGSeqVariant::set_exclusion_count(self : SGSeqVariant, val : Int) -> Unit { +pub fn SGSeqVariant::set_exclusion_count( + self : SGSeqVariant, + val : Int, +) -> Unit { self.exclusion_count = val } @@ -244,7 +243,7 @@ pub fn SGSeqVariant::compute_psi(self : SGSeqVariant) -> Double { /// Check if variant is significant (PSI between 0.1 and 0.9). pub fn SGSeqVariant::is_significant(self : SGSeqVariant) -> Bool { let p = self.compute_psi() - p > 0.1 && p < 0.9 && (self.inclusion_count + self.exclusion_count) >= 10 + p > 0.1 && p < 0.9 && self.inclusion_count + self.exclusion_count >= 10 } // =========================================================================== @@ -289,13 +288,7 @@ pub fn sgseq_parse_junctions(text : String) -> Array[SGSeqJunction] { 1 } if count > 0 && end > start { - junctions.push(SGSeqJunction::new( - chr=chr, - start=start, - end=end, - strand=strand, - count=count, - )) + junctions.push(SGSeqJunction::new(chr~, start~, end~, strand~, count~)) } } junctions @@ -337,7 +330,8 @@ pub fn sgseq_build_splice_graph( // Remove duplicates let unique_sites = Array::new() for s in sites { - if unique_sites.length() == 0 || unique_sites[unique_sites.length() - 1] != s { + if unique_sites.length() == 0 || + unique_sites[unique_sites.length() - 1] != s { unique_sites.push(s) } } @@ -382,31 +376,37 @@ pub fn sgseq_build_splice_graph( continue } // First exon: ends at first junction's donor (start) - exons.push(SGSeqExon::new( - chr=chr_name, - start=1, - end=chr_junctions[0].start, - strand=chr_junctions[0].strand, - )) + exons.push( + SGSeqExon::new( + chr=chr_name, + start=1, + end=chr_junctions[0].start, + strand=chr_junctions[0].strand, + ), + ) // Middle exons: between j[k].end and j[k+1].start let mut k = 0 while k < chr_junctions.length() - 1 { - exons.push(SGSeqExon::new( - chr=chr_name, - start=chr_junctions[k].end, - end=chr_junctions[k + 1].start, - strand=chr_junctions[k].strand, - )) + exons.push( + SGSeqExon::new( + chr=chr_name, + start=chr_junctions[k].end, + end=chr_junctions[k + 1].start, + strand=chr_junctions[k].strand, + ), + ) k = k + 1 } // Last exon: starts at last junction's acceptor (end) let last = chr_junctions[chr_junctions.length() - 1] - exons.push(SGSeqExon::new( - chr=chr_name, - start=last.end, - end=last.end + 1000, // arbitrary end - strand=last.strand, - )) + exons.push( + SGSeqExon::new( + chr=chr_name, + start=last.end, + end=last.end + 1000, // arbitrary end + strand=last.strand, + ), + ) } exons } @@ -419,24 +419,28 @@ pub fn sgseq_to_features( ) -> Array[SGSeqFeature] { let features = Array::new() for e in exons { - features.push(SGSeqFeature::new( - type_="E", - chr=e.chr, - start=e.start, - end=e.end, - strand=e.strand, - count=e.count, - )) + features.push( + SGSeqFeature::new( + type_="E", + chr=e.chr, + start=e.start, + end=e.end, + strand=e.strand, + count=e.count, + ), + ) } for j in junctions { - features.push(SGSeqFeature::new( - type_="J", - chr=j.chr, - start=j.start, - end=j.end, - strand=j.strand, - count=j.count, - )) + features.push( + SGSeqFeature::new( + type_="J", + chr=j.chr, + start=j.start, + end=j.end, + strand=j.strand, + count=j.count, + ), + ) } features } @@ -820,12 +824,11 @@ pub fn sgseq_quantify_psi( exc = exc + j.count } } - _ => { + _ => // Simplified: use counts near variant if j.start >= variant.start && j.end <= variant.end { inc = inc + j.count } - } } } let total = inc + exc @@ -840,7 +843,7 @@ pub fn sgseq_quantify_psi( /// Filter variants by minimum read support. pub fn sgseq_filter_variants( variants : Array[SGSeqVariant], - min_reads~ : Int = 10, + min_reads? : Int = 10, ) -> Array[SGSeqVariant] { let result = Array::new() for v in variants { @@ -886,30 +889,28 @@ pub fn sgseq_sample_exons() -> Array[SGSeqExon] { /// Format a variant as a string. pub fn sgseq_variant_to_string(v : SGSeqVariant) -> String { v.type_name() + - " " + - v.chr + - ":" + - v.start.to_string() + - "-" + - v.end.to_string() + - " (" + - v.strand + - ") inc=" + - v.inclusion_count.to_string() + - " exc=" + - v.exclusion_count.to_string() + - " PSI=" + - v.psi.to_string() + - " [" + - v.details + - "]" + " " + + v.chr + + ":" + + v.start.to_string() + + "-" + + v.end.to_string() + + " (" + + v.strand + + ") inc=" + + v.inclusion_count.to_string() + + " exc=" + + v.exclusion_count.to_string() + + " PSI=" + + v.psi.to_string() + + " [" + + v.details + + "]" } ///| /// Summarize variants by type. -pub fn sgseq_summary( - variants : Array[SGSeqVariant], -) -> Map[String, Int] { +pub fn sgseq_summary(variants : Array[SGSeqVariant]) -> Map[String, Int] { let counts : Map[String, Int] = Map([], capacity=5) for v in variants { let name = v.type_name() diff --git a/src/single_r.mbt b/src/single_r.mbt index 8377ffc1..f26fbe46 100644 --- a/src/single_r.mbt +++ b/src/single_r.mbt @@ -80,7 +80,10 @@ pub struct SingleRParams { ///| /// Spearman correlation coefficient. -pub fn single_r_spearman_correlation(x : Array[Double], y : Array[Double]) -> Double { +pub fn single_r_spearman_correlation( + x : Array[Double], + y : Array[Double], +) -> Double { let n = x.length() if n < 3 { return 0.0 @@ -116,7 +119,10 @@ pub fn single_r_spearman_correlation(x : Array[Double], y : Array[Double]) -> Do ///| /// Pearson correlation coefficient (SingleR-scoped version). -pub fn single_r_pearson_correlation(x : Array[Double], y : Array[Double]) -> Double { +pub fn single_r_pearson_correlation( + x : Array[Double], + y : Array[Double], +) -> Double { let n = x.length() if n < 3 { return 0.0 @@ -169,7 +175,8 @@ pub fn single_r_rank_values(values : Array[Double]) -> Array[Double] { } // For descending sort, map to ascending ranks (smallest=1, largest=n) // Position j..k-1 in descending → ascending ranks n-j..n-(k-1) - let avg_rank = (2.0 * n.to_double() - j.to_double() - k.to_double() + 1.0) / 2.0 + let avg_rank = (2.0 * n.to_double() - j.to_double() - k.to_double() + 1.0) / + 2.0 let mut m = j while m < k { ranks[sorted[m].1] = avg_rank @@ -202,7 +209,9 @@ fn single_r_sort_array(arr : Array[(Double, Int)]) -> Array[(Double, Int)] { ///| /// Sort array of (Int, Double) tuples by the Double value (descending). -fn single_r_sort_int_double_array(arr : Array[(Int, Double)]) -> Array[(Int, Double)] { +fn single_r_sort_int_double_array( + arr : Array[(Int, Double)], +) -> Array[(Int, Double)] { let n = arr.length() let result = arr.copy() let mut i = 1 @@ -251,13 +260,7 @@ pub fn ReferenceDataset::new( for p in profiles { cell_types.push(p.cell_type) } - ReferenceDataset::{ - profiles, - cell_types, - gene_names, - n_genes, - n_profiles, - } + ReferenceDataset::{ profiles, cell_types, gene_names, n_genes, n_profiles } } ///| @@ -272,7 +275,7 @@ pub fn ReferenceDataset::from_matrix( let mut i = 0 while i < n_samples { profiles.push( - ReferenceProfile::new(cell_types[i], expression_data[i], gene_names) + ReferenceProfile::new(cell_types[i], expression_data[i], gene_names), ) i = i + 1 } @@ -311,7 +314,7 @@ pub fn SingleRParams::new() -> SingleRParams { /// Create custom SingleR parameters with specific method. pub fn SingleRParams::with_method(method : String) -> SingleRParams { let base = SingleRParams::new() - SingleRParams::{ ..base, method } + SingleRParams::{ ..base, method, } } ///| @@ -323,13 +326,7 @@ pub fn SingleRParams::with_all( min_score : Double, quantile_score : Bool, ) -> SingleRParams { - SingleRParams::{ - method, - n_top_scores, - fine_tune, - min_score, - quantile_score, - } + SingleRParams::{ method, n_top_scores, fine_tune, min_score, quantile_score } } ///| @@ -387,7 +384,10 @@ pub fn single_r_aggregate_scores_by_type( reference : ReferenceDataset, n_top : Int, ) -> Map[String, Double] { - let unique_types : Map[String, Array[Double]] = Map([], capacity=reference.n_profiles) + let unique_types : Map[String, Array[Double]] = Map( + [], + capacity=reference.n_profiles, + ) let mut i = 0 while i < reference.n_profiles { @@ -407,7 +407,11 @@ pub fn single_r_aggregate_scores_by_type( for key in keys { let vals = unique_types.get(key).unwrap_or([]) let sorted_vals = single_r_sort_desc(vals) - let n = if n_top < sorted_vals.length() { n_top } else { sorted_vals.length() } + let n = if n_top < sorted_vals.length() { + n_top + } else { + sorted_vals.length() + } let mut sum = 0.0 let mut j = 0 while j < n { @@ -441,7 +445,9 @@ fn single_r_sort_desc(arr : Array[Double]) -> Array[Double] { ///| /// Find the cell type with the highest score. -pub fn single_r_get_best_label(scores_by_type : Map[String, Double]) -> (String, Double) { +pub fn single_r_get_best_label( + scores_by_type : Map[String, Double], +) -> (String, Double) { let keys = scores_by_type.keys() let mut best_label = "" let mut best_score = -2.0 @@ -457,7 +463,9 @@ pub fn single_r_get_best_label(scores_by_type : Map[String, Double]) -> (String, ///| /// Compute delta score (difference between top and second best). -pub fn single_r_compute_delta_score(scores_by_type : Map[String, Double]) -> Double { +pub fn single_r_compute_delta_score( + scores_by_type : Map[String, Double], +) -> Double { let keys = scores_by_type.keys() let sorted_scores : Array[(String, Double)] = Array::new() for key in keys { @@ -515,11 +523,12 @@ pub fn single_r_fine_tune_annotation( let avg_score = if marker_profiles.length() > 0 { let mut sum = 0.0 for p in marker_profiles { - sum = sum + (if method == "pearson" { - single_r_pearson_correlation(cell_expression, p) - } else { - single_r_spearman_correlation(cell_expression, p) - }) + sum = sum + + (if method == "pearson" { + single_r_pearson_correlation(cell_expression, p) + } else { + single_r_spearman_correlation(cell_expression, p) + }) } sum / marker_profiles.length().to_double() } else { @@ -536,14 +545,18 @@ pub fn single_r_fine_tune_annotation( single_r_pearson_correlation(cell_expression, p) } else { single_r_spearman_correlation(cell_expression, p) - } + }, ) } // Average scores by type let agg = single_r_aggregate_scores_by_type( other_scores, - ReferenceDataset::from_matrix(other_profiles, other_types, reference.gene_names), + ReferenceDataset::from_matrix( + other_profiles, + other_types, + reference.gene_names, + ), 1, ) @@ -553,11 +566,12 @@ pub fn single_r_fine_tune_annotation( let avg_initial = if marker_profiles.length() > 0 { let mut sum = 0.0 for p in marker_profiles { - sum = sum + (if method == "pearson" { - single_r_pearson_correlation(cell_expression, p) - } else { - single_r_spearman_correlation(cell_expression, p) - }) + sum = sum + + (if method == "pearson" { + single_r_pearson_correlation(cell_expression, p) + } else { + single_r_spearman_correlation(cell_expression, p) + }) } sum / marker_profiles.length().to_double() } else { @@ -581,10 +595,18 @@ pub fn single_r_annotate_cell( params : SingleRParams, ) -> SingleRResult { // Compute correlations with all reference profiles - let raw_scores = single_r_compute_correlations(cell_expression, reference, params.method) + let raw_scores = single_r_compute_correlations( + cell_expression, + reference, + params.method, + ) // Aggregate scores by cell type - let agg_scores = single_r_aggregate_scores_by_type(raw_scores, reference, params.n_top_scores) + let agg_scores = single_r_aggregate_scores_by_type( + raw_scores, + reference, + params.n_top_scores, + ) // Get initial prediction let (best_label, best_score) = single_r_get_best_label(agg_scores) @@ -593,7 +615,11 @@ pub fn single_r_annotate_cell( // Fine-tune if enabled let (final_label, final_score) = if params.fine_tune && best_score > 0.0 { single_r_fine_tune_annotation( - cell_expression, reference, best_label, 50, params.method + cell_expression, + reference, + best_label, + 50, + params.method, ) } else { (best_label, best_score) @@ -631,7 +657,10 @@ pub fn single_r_annotate_cell( ///| /// Sort labels by their scores (descending). -fn single_r_sort_labels_by_score(labels : Array[String], scores : Array[Double]) -> Array[String] { +fn single_r_sort_labels_by_score( + labels : Array[String], + scores : Array[Double], +) -> Array[String] { let n = labels.length() let pairs : Array[(String, Double)] = Array::new() let mut i = 0 @@ -683,14 +712,24 @@ pub fn single_r_annotate_cells( let mut i = 0 while i < data.n_cells { let cell_expr = single_r_get_cell_expression(data, i) - let cell_id = if i < data.cell_names.length() { data.cell_names[i] } else { "cell_".to_string() + i.to_string() } + let cell_id = if i < data.cell_names.length() { + data.cell_names[i] + } else { + "cell_".to_string() + i.to_string() + } let result = single_r_annotate_cell(cell_expr, cell_id, reference, params) cell_ids.push(result.cell_id) labels.push(result.first_annotation_fine) scores.push(if result.scores.length() > 0 { result.scores[0] } else { 0.0 }) - delta_scores.push(if result.delta_next.length() > 0 { result.delta_next[0] } else { 0.0 }) + delta_scores.push( + if result.delta_next.length() > 0 { + result.delta_next[0] + } else { + 0.0 + }, + ) first_labels.push(result.first_labels[0]) fine_annotations.push(result.annotations_fine[0]) @@ -710,7 +749,10 @@ pub fn single_r_annotate_cells( ///| /// Extract expression profile for a single cell. -fn single_r_get_cell_expression(data : SingleRData, cell_idx : Int) -> Array[Double] { +fn single_r_get_cell_expression( + data : SingleRData, + cell_idx : Int, +) -> Array[Double] { let n_genes = data.n_genes let expr : Array[Double] = Array::new() let mut i = 0 @@ -725,16 +767,13 @@ fn single_r_get_cell_expression(data : SingleRData, cell_idx : Int) -> Array[Dou /// Create a synthetic reference dataset for testing. pub fn single_r_create_reference_data() -> ReferenceDataset { let gene_names = [ - "CD3D", "CD3E", "CD4", "CD8A", "CD14", "CD19", "CD79A", "CD79B", - "CD56", "CD94", "NCAM1", "KLRD1", "KLRB1", "KLRF1", "NKG7", - "LYZ", "S100A8", "S100A9", "FCGR3A", "CSF1R", "C1QA", "C1QB", - "C1QC", "MARCO", "FABP4", "CD68", "CD163", "MRC1", - "CD34", "CD117", "KIT", "CD133", "PROM1", "ALDH1A1", - "CD45", "PTPRC", "CD31", "PECAM1", "VWF", "ENG", "ESAM", - "ACTA2", "TAGLN", "MYH11", "COL1A1", "COL1A2", "DCN", "LUM", - "CD235A", "GYPA", "HBB", "HBA1", "HBA2", "HBM", - "MS4A1", "CD20", "CD27", "CD38", "CD138", "SDC1", "BCMA", - "TPSAB1", "TPSB2", "CPA3", "TPSD1", "MS4A2", + "CD3D", "CD3E", "CD4", "CD8A", "CD14", "CD19", "CD79A", "CD79B", "CD56", "CD94", + "NCAM1", "KLRD1", "KLRB1", "KLRF1", "NKG7", "LYZ", "S100A8", "S100A9", "FCGR3A", + "CSF1R", "C1QA", "C1QB", "C1QC", "MARCO", "FABP4", "CD68", "CD163", "MRC1", "CD34", + "CD117", "KIT", "CD133", "PROM1", "ALDH1A1", "CD45", "PTPRC", "CD31", "PECAM1", + "VWF", "ENG", "ESAM", "ACTA2", "TAGLN", "MYH11", "COL1A1", "COL1A2", "DCN", "LUM", + "CD235A", "GYPA", "HBB", "HBA1", "HBA2", "HBM", "MS4A1", "CD20", "CD27", "CD38", + "CD138", "SDC1", "BCMA", "TPSAB1", "TPSB2", "CPA3", "TPSD1", "MS4A2", ] let n_genes = gene_names.length() @@ -847,7 +886,12 @@ pub fn single_r_create_reference_data() -> ReferenceDataset { ///| /// Helper to set gene expression value in an array by gene name. -fn single_r_set_gene_expr(expr : Array[Double], gene_names : Array[String], gene : String, value : Double) -> Unit { +fn single_r_set_gene_expr( + expr : Array[Double], + gene_names : Array[String], + gene : String, + value : Double, +) -> Unit { let n = gene_names.length() let mut i = 0 while i < n { @@ -863,16 +907,13 @@ fn single_r_set_gene_expr(expr : Array[Double], gene_names : Array[String], gene /// Create a synthetic single-cell dataset for testing. pub fn single_r_create_test_data() -> SingleRData { let gene_names = [ - "CD3D", "CD3E", "CD4", "CD8A", "CD14", "CD19", "CD79A", "CD79B", - "CD56", "CD94", "NCAM1", "KLRD1", "KLRB1", "KLRF1", "NKG7", - "LYZ", "S100A8", "S100A9", "FCGR3A", "CSF1R", "C1QA", "C1QB", - "C1QC", "MARCO", "FABP4", "CD68", "CD163", "MRC1", - "CD34", "CD117", "KIT", "CD133", "PROM1", "ALDH1A1", - "CD45", "PTPRC", "CD31", "PECAM1", "VWF", "ENG", "ESAM", - "ACTA2", "TAGLN", "MYH11", "COL1A1", "COL1A2", "DCN", "LUM", - "CD235A", "GYPA", "HBB", "HBA1", "HBA2", "HBM", - "MS4A1", "CD20", "CD27", "CD38", "CD138", "SDC1", "BCMA", - "TPSAB1", "TPSB2", "CPA3", "TPSD1", "MS4A2", + "CD3D", "CD3E", "CD4", "CD8A", "CD14", "CD19", "CD79A", "CD79B", "CD56", "CD94", + "NCAM1", "KLRD1", "KLRB1", "KLRF1", "NKG7", "LYZ", "S100A8", "S100A9", "FCGR3A", + "CSF1R", "C1QA", "C1QB", "C1QC", "MARCO", "FABP4", "CD68", "CD163", "MRC1", "CD34", + "CD117", "KIT", "CD133", "PROM1", "ALDH1A1", "CD45", "PTPRC", "CD31", "PECAM1", + "VWF", "ENG", "ESAM", "ACTA2", "TAGLN", "MYH11", "COL1A1", "COL1A2", "DCN", "LUM", + "CD235A", "GYPA", "HBB", "HBA1", "HBA2", "HBM", "MS4A1", "CD20", "CD27", "CD38", + "CD138", "SDC1", "BCMA", "TPSAB1", "TPSB2", "CPA3", "TPSD1", "MS4A2", ] let n_genes = gene_names.length() @@ -888,37 +929,68 @@ pub fn single_r_create_test_data() -> SingleRData { // Simulate different cell types let cell_type = cell_j % 5 let base = if cell_type == 0 { // T cell - if gene_names[gene_i] == "CD3D" || gene_names[gene_i] == "CD3E" { 100.0 } - else if gene_names[gene_i] == "CD4" { 80.0 } - else if gene_names[gene_i] == "CD8A" { 75.0 } - else if gene_names[gene_i] == "CD45" || gene_names[gene_i] == "PTPRC" { 90.0 } - else { 1.0 } + if gene_names[gene_i] == "CD3D" || gene_names[gene_i] == "CD3E" { + 100.0 + } else if gene_names[gene_i] == "CD4" { + 80.0 + } else if gene_names[gene_i] == "CD8A" { + 75.0 + } else if gene_names[gene_i] == "CD45" || gene_names[gene_i] == "PTPRC" { + 90.0 + } else { + 1.0 + } } else if cell_type == 1 { // B cell - if gene_names[gene_i] == "CD19" { 110.0 } - else if gene_names[gene_i] == "CD79A" || gene_names[gene_i] == "CD79B" { 100.0 } - else if gene_names[gene_i] == "MS4A1" || gene_names[gene_i] == "CD20" { 95.0 } - else if gene_names[gene_i] == "CD45" || gene_names[gene_i] == "PTPRC" { 90.0 } - else { 1.0 } + if gene_names[gene_i] == "CD19" { + 110.0 + } else if gene_names[gene_i] == "CD79A" || gene_names[gene_i] == "CD79B" { + 100.0 + } else if gene_names[gene_i] == "MS4A1" || gene_names[gene_i] == "CD20" { + 95.0 + } else if gene_names[gene_i] == "CD45" || gene_names[gene_i] == "PTPRC" { + 90.0 + } else { + 1.0 + } } else if cell_type == 2 { // NK cell - if gene_names[gene_i] == "CD56" || gene_names[gene_i] == "NCAM1" { 95.0 } - else if gene_names[gene_i] == "CD94" { 85.0 } - else if gene_names[gene_i] == "NKG7" { 80.0 } - else if gene_names[gene_i] == "KLRD1" || gene_names[gene_i] == "KLRB1" { 75.0 } - else if gene_names[gene_i] == "CD45" || gene_names[gene_i] == "PTPRC" { 90.0 } - else { 1.0 } + if gene_names[gene_i] == "CD56" || gene_names[gene_i] == "NCAM1" { + 95.0 + } else if gene_names[gene_i] == "CD94" { + 85.0 + } else if gene_names[gene_i] == "NKG7" { + 80.0 + } else if gene_names[gene_i] == "KLRD1" || gene_names[gene_i] == "KLRB1" { + 75.0 + } else if gene_names[gene_i] == "CD45" || gene_names[gene_i] == "PTPRC" { + 90.0 + } else { + 1.0 + } } else if cell_type == 3 { // Monocyte - if gene_names[gene_i] == "CD14" { 105.0 } - else if gene_names[gene_i] == "LYZ" { 95.0 } - else if gene_names[gene_i] == "S100A8" || gene_names[gene_i] == "S100A9" { 90.0 } - else if gene_names[gene_i] == "FCGR3A" { 70.0 } - else if gene_names[gene_i] == "CD45" || gene_names[gene_i] == "PTPRC" { 90.0 } - else { 1.0 } - } else { // Epithelial cell - if gene_names[gene_i] == "CDH1" { 90.0 } - else if gene_names[gene_i] == "EPCAM" { 85.0 } - else if gene_names[gene_i] == "KRT18" || gene_names[gene_i] == "KRT19" { 80.0 } - else if gene_names[gene_i] == "MUC1" { 75.0 } - else { 1.0 } + if gene_names[gene_i] == "CD14" { + 105.0 + } else if gene_names[gene_i] == "LYZ" { + 95.0 + } else if gene_names[gene_i] == "S100A8" || + gene_names[gene_i] == "S100A9" { + 90.0 + } else if gene_names[gene_i] == "FCGR3A" { + 70.0 + } else if gene_names[gene_i] == "CD45" || gene_names[gene_i] == "PTPRC" { + 90.0 + } else { + 1.0 + } // Epithelial cell + } else if gene_names[gene_i] == "CDH1" { + 90.0 + } else if gene_names[gene_i] == "EPCAM" { + 85.0 + } else if gene_names[gene_i] == "KRT18" || gene_names[gene_i] == "KRT19" { + 80.0 + } else if gene_names[gene_i] == "MUC1" { + 75.0 + } else { + 1.0 } // Add some noise @@ -943,7 +1015,9 @@ pub fn single_r_create_test_data() -> SingleRData { ///| /// Get summary statistics from annotation results. -pub fn single_r_annotation_summary(result : SingleRFullResult) -> Map[String, Double] { +pub fn single_r_annotation_summary( + result : SingleRFullResult, +) -> Map[String, Double] { let n_cells = result.cell_ids.length() let label_counts : Map[String, Int] = Map([], capacity=10) @@ -958,7 +1032,10 @@ pub fn single_r_annotation_summary(result : SingleRFullResult) -> Map[String, Do i = i + 1 } - let summary : Map[String, Double] = Map([], capacity=label_counts.length() + 2) + let summary : Map[String, Double] = Map( + [], + capacity=label_counts.length() + 2, + ) let keys = label_counts.keys() for key in keys { let count = label_counts.get(key).unwrap_or(0) @@ -976,4 +1053,4 @@ pub fn single_r_annotation_summary(result : SingleRFullResult) -> Map[String, Do summary.set("n_cells", n_cells.to_double()) summary -} \ No newline at end of file +} diff --git a/src/singscore.mbt b/src/singscore.mbt index 4cf6267f..ca5d85f2 100644 --- a/src/singscore.mbt +++ b/src/singscore.mbt @@ -19,13 +19,17 @@ pub fn SampleExpression::get_sample_id(self : SampleExpression) -> String { ///| /// Get gene names. -pub fn SampleExpression::get_gene_names(self : SampleExpression) -> Array[String] { +pub fn SampleExpression::get_gene_names( + self : SampleExpression, +) -> Array[String] { self.gene_names } ///| /// Get expression values. -pub fn SampleExpression::get_expression(self : SampleExpression) -> Array[Double] { +pub fn SampleExpression::get_expression( + self : SampleExpression, +) -> Array[Double] { self.expression } @@ -144,12 +148,24 @@ pub fn singscore_score( spec : GeneSetSpec, sample_id : String, ) -> SingscoreResult { - let (up_score, up_disp, n_up) = singscore_directional(sample, spec.up_genes, true) - let (down_score, down_disp, n_down) = singscore_directional(sample, spec.down_genes, false) - + let (up_score, up_disp, n_up) = singscore_directional( + sample, + spec.up_genes, + true, + ) + let (down_score, down_disp, n_down) = singscore_directional( + sample, + spec.down_genes, + false, + ) + let n_dir = (if n_up > 0 { 1 } else { 0 }) + (if n_down > 0 { 1 } else { 0 }) - let total = if n_dir > 0 { (up_score + down_score) / n_dir.to_double() } else { 0.0 } - + let total = if n_dir > 0 { + (up_score + down_score) / n_dir.to_double() + } else { + 0.0 + } + SingscoreResult::{ sample_id, score: total, @@ -185,12 +201,12 @@ fn singscore_directional( if genes.length() == 0 { return (0.0, 0.0, 0) } - + let n_genes = sample.gene_names.length() if n_genes == 0 { return (0.0, 0.0, 0) } - + // Build rank array (centered around 0) let ranks : Array[Double] = Array::make(n_genes, 0.0) // Create index array and sort by expression @@ -202,10 +218,10 @@ fn singscore_directional( i = i + 1 } } - + // Simple insertion sort for ranking (handles ties by averaging) let sorted_indices = singscore_sort_indices(sample.expression) - + // Assign ranks (1-based, then center) { let mut i = 0 @@ -214,7 +230,7 @@ fn singscore_directional( i = i + 1 } } - + // Center ranks around 0 let n = n_genes.to_double() { @@ -224,7 +240,7 @@ fn singscore_directional( i = i + 1 } } - + // Build gene name -> index map let gene_idx : Map[String, Int] = Map([], capacity=n_genes) { @@ -234,7 +250,7 @@ fn singscore_directional( i = i + 1 } } - + // Sum ranks for specified genes let mut sum = 0.0 let mut n_found = 0 @@ -251,20 +267,16 @@ fn singscore_directional( } i = i + 1 } - + if n_found == 0 { return (0.0, 0.0, 0) } - + // Normalize to [-0.5, 0.5] using (n-1) bound let nf = n_found.to_double() let nf1 = (n_found - 1).to_double() - let score = if nf1 > 0.0 { - sum / nf1 - } else { - sum / nf - } - + let score = if nf1 > 0.0 { sum / nf1 } else { sum / nf } + // Clip to [-0.5, 0.5] let clamped = if score > 0.5 { 0.5 @@ -273,10 +285,10 @@ fn singscore_directional( } else { score } - + // Compute dispersion (variance of ranks for found genes) let dispersion = singscore_compute_dispersion(sample, genes, is_up, gene_idx) - + (clamped, dispersion, n_found) } @@ -294,19 +306,20 @@ fn singscore_compute_dispersion( let gene = genes[i] match gene_idx.get(gene) { Some(idx) => { - let rank = (idx + 1).to_double() - (sample.gene_names.length().to_double() + 1.0) / 2.0 + let rank = (idx + 1).to_double() - + (sample.gene_names.length().to_double() + 1.0) / 2.0 ranks_found.push(if is_up { rank } else { -rank }) } None => () } i = i + 1 } - + let n = ranks_found.length() if n <= 1 { return 0.0 } - + let (mean, var) = stat_mean_var(ranks_found) let _ = mean var @@ -324,12 +337,13 @@ fn singscore_sort_indices(values : Array[Double]) -> Array[Int] { i = i + 1 } } - + // Quicksort singscore_quicksort(values, indices, 0, n - 1) indices } +///| fn singscore_quicksort( values : Array[Double], indices : Array[Int], @@ -352,7 +366,7 @@ fn singscore_quicksort( let tmp = indices[i + 1] indices[i + 1] = indices[hi] indices[hi] = tmp - + let p = i + 1 singscore_quicksort(values, indices, lo, p - 1) singscore_quicksort(values, indices, p + 1, hi) @@ -363,23 +377,21 @@ fn singscore_quicksort( /// Create example data for singscore testing. pub fn singscore_create_example() -> (SampleExpression, GeneSetSpec) { let genes = [ - "TP53", "BRCA1", "BRCA2", "EGFR", "MYC", "KRAS", - "PTEN", "AKT1", "MTOR", "JAK2", "STAT3", "NFKB1", - "CDK4", "CDK6", "RB1", "E2F1", "APC", "CTNNB1", - "SMAD4", "TGFBR1", + "TP53", "BRCA1", "BRCA2", "EGFR", "MYC", "KRAS", "PTEN", "AKT1", "MTOR", "JAK2", + "STAT3", "NFKB1", "CDK4", "CDK6", "RB1", "E2F1", "APC", "CTNNB1", "SMAD4", "TGFBR1", ] let expression = [ - 10.0, 8.5, 6.2, 15.0, 20.0, 5.0, - 3.2, 12.0, 18.0, 7.0, 9.5, 11.0, - 14.0, 13.0, 4.0, 16.0, 2.0, 1.5, - 2.5, 3.0, + 10.0, 8.5, 6.2, 15.0, 20.0, 5.0, 3.2, 12.0, 18.0, 7.0, 9.5, 11.0, 14.0, 13.0, + 4.0, 16.0, 2.0, 1.5, 2.5, 3.0, ] - + let sample = SampleExpression::new("sample_1", genes, expression) - - let up_genes = ["TP53", "BRCA1", "BRCA2", "EGFR", "MYC", "KRAS", "AKT1", "MTOR"] + + let up_genes = [ + "TP53", "BRCA1", "BRCA2", "EGFR", "MYC", "KRAS", "AKT1", "MTOR", + ] let down_genes = ["PTEN", "RB1", "APC", "CTNNB1"] - - let spec = GeneSetSpec::new("cell_cycle", up_genes, down_genes=down_genes) + + let spec = GeneSetSpec::new("cell_cycle", up_genes, down_genes~) (sample, spec) } diff --git a/src/slingshot.mbt b/src/slingshot.mbt index e2ed81da..45de3f9e 100644 --- a/src/slingshot.mbt +++ b/src/slingshot.mbt @@ -3,6 +3,7 @@ /// Provides single-cell lineage trajectory inference using minimum /// spanning trees and principal curves for pseudotime ordering. +///| /// Distance metric for cell comparisons pub enum SlingshotDistMetric { /// Euclidean distance @@ -13,6 +14,7 @@ pub enum SlingshotDistMetric { Cosine } +///| /// A node in the lineage tree (represents a cluster or cell) pub struct SlingshotNode { /// Node ID @@ -29,6 +31,7 @@ pub struct SlingshotNode { start : Bool } +///| /// An edge in the lineage tree pub struct SlingshotEdge { /// Source node ID @@ -39,6 +42,7 @@ pub struct SlingshotEdge { weight : Double } +///| /// A lineage curve (principal curve for a branch) pub struct SlingshotCurve { /// Curve ID @@ -55,6 +59,7 @@ pub struct SlingshotCurve { cell_indices : Array[Int] } +///| /// Complete slingshot result pub struct SlingshotResult { /// All nodes @@ -71,6 +76,7 @@ pub struct SlingshotResult { cell_branch : Array[String] } +///| /// Parameters for slingshot analysis pub struct SlingshotParams { /// Number of principal components @@ -83,49 +89,79 @@ pub struct SlingshotParams { shrink : Double } +///| /// Create default parameters pub fn SlingshotParams::new() -> SlingshotParams { SlingshotParams::{ n_pcs: 2, min_cluster_size: 10, allow_reversals: false, - shrink: 1.0 + shrink: 1.0, } } // ===== Node methods ===== +///| /// Create a new node -pub fn SlingshotNode::new(id : String, cluster : String, coords : Array[Double], size : Int) -> SlingshotNode { - SlingshotNode::{ - id, - cluster, - coords, - size, - terminal: false, - start: false - } +pub fn SlingshotNode::new( + id : String, + cluster : String, + coords : Array[Double], + size : Int, +) -> SlingshotNode { + SlingshotNode::{ id, cluster, coords, size, terminal: false, start: false } } +///| /// Set terminal flag -pub fn SlingshotNode::sling_set_terminal(self : SlingshotNode, terminal : Bool) -> SlingshotNode { - SlingshotNode::{ id: self.id, cluster: self.cluster, coords: self.coords, size: self.size, terminal, start: self.start } +pub fn SlingshotNode::sling_set_terminal( + self : SlingshotNode, + terminal : Bool, +) -> SlingshotNode { + SlingshotNode::{ + id: self.id, + cluster: self.cluster, + coords: self.coords, + size: self.size, + terminal, + start: self.start, + } } +///| /// Set start flag -pub fn SlingshotNode::sling_set_start(self : SlingshotNode, start : Bool) -> SlingshotNode { - SlingshotNode::{ id: self.id, cluster: self.cluster, coords: self.coords, size: self.size, terminal: false, start } +pub fn SlingshotNode::sling_set_start( + self : SlingshotNode, + start : Bool, +) -> SlingshotNode { + SlingshotNode::{ + id: self.id, + cluster: self.cluster, + coords: self.coords, + size: self.size, + terminal: false, + start, + } } +///| /// Get node coordinate at dimension pub fn SlingshotNode::sling_coord(self : SlingshotNode, dim : Int) -> Double { self.coords[dim] } +///| /// Compute distance between two nodes -pub fn SlingshotNode::sling_distance(self : SlingshotNode, other : SlingshotNode, metric : SlingshotDistMetric) -> Double { +pub fn SlingshotNode::sling_distance( + self : SlingshotNode, + other : SlingshotNode, + metric : SlingshotDistMetric, +) -> Double { let d = self.coords.length() - if d == 0 { return 0.0 } + if d == 0 { + return 0.0 + } match metric { SlingshotDistMetric::Euclidean => { let mut sum = 0.0 @@ -167,23 +203,31 @@ pub fn SlingshotNode::sling_distance(self : SlingshotNode, other : SlingshotNode // ===== Edge methods ===== +///| /// Create a new edge -pub fn SlingshotEdge::new(from_id : String, to_id : String, weight : Double) -> SlingshotEdge { +pub fn SlingshotEdge::new( + from_id : String, + to_id : String, + weight : Double, +) -> SlingshotEdge { SlingshotEdge::{ from_id, to_id, weight } } // ===== Metric helpers ===== +///| /// Get Euclidean distance metric pub fn sling_euclidean_metric() -> SlingshotDistMetric { SlingshotDistMetric::Euclidean } +///| /// Get Manhattan distance metric pub fn sling_manhattan_metric() -> SlingshotDistMetric { SlingshotDistMetric::Manhattan } +///| /// Get Cosine distance metric pub fn sling_cosine_metric() -> SlingshotDistMetric { SlingshotDistMetric::Cosine @@ -193,7 +237,10 @@ pub fn sling_cosine_metric() -> SlingshotDistMetric { ///| /// Build a distance matrix between all nodes. -pub fn sling_distance_matrix(nodes : Array[SlingshotNode], metric : SlingshotDistMetric) -> Array[Array[Double]] { +pub fn sling_distance_matrix( + nodes : Array[SlingshotNode], + metric : SlingshotDistMetric, +) -> Array[Array[Double]] { let n = nodes.length() let mat : Array[Array[Double]] = Array::new() let mut i = 0 @@ -216,9 +263,14 @@ pub fn sling_distance_matrix(nodes : Array[SlingshotNode], metric : SlingshotDis ///| /// Build a minimum spanning tree using Prim's algorithm. -pub fn sling_build_mst(nodes : Array[SlingshotNode], metric : SlingshotDistMetric) -> Array[SlingshotEdge] { +pub fn sling_build_mst( + nodes : Array[SlingshotNode], + metric : SlingshotDistMetric, +) -> Array[SlingshotEdge] { let n = nodes.length() - if n <= 1 { return Array::new() } + if n <= 1 { + return Array::new() + } let dist_mat = sling_distance_matrix(nodes, metric) let in_tree : Array[Bool] = Array::new() let min_edge : Array[Double] = Array::new() @@ -257,20 +309,29 @@ pub fn sling_build_mst(nodes : Array[SlingshotNode], metric : SlingshotDistMetri } m = m + 1 } - if min_idx < 0 { break } + if min_idx < 0 { + break + } in_tree[min_idx] = true - edges.push(SlingshotEdge::new( - nodes[min_from[min_idx]].id, - nodes[min_idx].id, - min_val - )) + edges.push( + SlingshotEdge::new( + nodes[min_from[min_idx]].id, + nodes[min_idx].id, + min_val, + ), + ) k = k + 1 } edges } +///| /// Find the most recently added node in the MST -fn sling_find_recently_added(in_tree : Array[Bool], min_edge : Array[Double], n : Int) -> Int { +fn sling_find_recently_added( + in_tree : Array[Bool], + min_edge : Array[Double], + n : Int, +) -> Int { // Find the node with the smallest min_edge that's in the tree let mut min_val = 1.0e30 let mut min_idx = 0 @@ -287,7 +348,10 @@ fn sling_find_recently_added(in_tree : Array[Bool], min_edge : Array[Double], n ///| /// Identify terminal nodes (leaf nodes in the MST). -pub fn sling_find_terminals(edges : Array[SlingshotEdge], nodes : Array[SlingshotNode]) -> Array[String] { +pub fn sling_find_terminals( + edges : Array[SlingshotEdge], + nodes : Array[SlingshotNode], +) -> Array[String] { let n = nodes.length() let degree : Array[Int] = Array::new() let mut i = 0 @@ -324,11 +388,14 @@ pub fn sling_find_terminals(edges : Array[SlingshotEdge], nodes : Array[Slingsho terminals } +///| /// Find node index by ID fn sling_find_node_idx(ids : Array[String], id : String) -> Int { let mut i = 0 while i < ids.length() { - if ids[i] == id { return i } + if ids[i] == id { + return i + } i = i + 1 } -1 @@ -340,14 +407,23 @@ fn sling_find_node_idx(ids : Array[String], id : String) -> Int { /// Fit a principal curve through a set of 2D points. /// Uses the simple iterative approach: project points onto the curve, /// update curve as running mean. -pub fn sling_fit_principal_curve(points : Array[Array[Double]], n_segments : Int) -> Array[Array[Double]] { +pub fn sling_fit_principal_curve( + points : Array[Array[Double]], + n_segments : Int, +) -> Array[Array[Double]] { let n_points = points.length() - if n_points == 0 { return Array::new() } + if n_points == 0 { + return Array::new() + } let dim = points[0].length() // Initialize curve segments along the first principal component let (pc1_min, pc1_max) = sling_pc1_range(points) let curve : Array[Array[Double]] = Array::new() - let seg_step = if n_segments > 1 { (pc1_max - pc1_min) / (n_segments - 1).to_double() } else { 0.0 } + let seg_step = if n_segments > 1 { + (pc1_max - pc1_min) / (n_segments - 1).to_double() + } else { + 0.0 + } let mut i = 0 while i < n_segments { let t = pc1_min + seg_step * i.to_double() @@ -360,7 +436,9 @@ pub fn sling_fit_principal_curve(points : Array[Array[Double]], n_segments : Int let mut iter = 0 while iter < max_iter { let (new_curve, changed) = sling_refine_curve(points, curve) - if !changed { break } + if !changed { + break + } iter = iter + 1 } curve @@ -370,7 +448,9 @@ pub fn sling_fit_principal_curve(points : Array[Array[Double]], n_segments : Int /// Get range of first principal component. fn sling_pc1_range(points : Array[Array[Double]]) -> (Double, Double) { let n = points.length() - if n == 0 { return (0.0, 0.0) } + if n == 0 { + return (0.0, 0.0) + } let dim = points[0].length() // Simple PCA: center data, find direction of maximum variance let center : Array[Double] = Array::new() @@ -414,8 +494,12 @@ fn sling_pc1_range(points : Array[Array[Double]]) -> (Double, Double) { let mut max_val = points[0][max_dim] let mut j = 1 while j < n { - if points[j][max_dim] < min_val { min_val = points[j][max_dim] } - if points[j][max_dim] > max_val { max_val = points[j][max_dim] } + if points[j][max_dim] < min_val { + min_val = points[j][max_dim] + } + if points[j][max_dim] > max_val { + max_val = points[j][max_dim] + } j = j + 1 } (min_val, max_val) @@ -423,7 +507,12 @@ fn sling_pc1_range(points : Array[Array[Double]]) -> (Double, Double) { ///| /// Get point on PC1 line at parameter t. -fn sling_point_on_pc1(points : Array[Array[Double]], t : Double, min_val : Double, max_val : Double) -> Array[Double] { +fn sling_point_on_pc1( + points : Array[Array[Double]], + t : Double, + min_val : Double, + max_val : Double, +) -> Array[Double] { let n = points.length() let dim = points[0].length() let pt : Array[Double] = Array::new() @@ -447,10 +536,15 @@ fn sling_point_on_pc1(points : Array[Array[Double]], t : Double, min_val : Doubl ///| /// Refine principal curve by projecting points and averaging. -fn sling_refine_curve(points : Array[Array[Double]], curve : Array[Array[Double]]) -> (Array[Array[Double]], Bool) { +fn sling_refine_curve( + points : Array[Array[Double]], + curve : Array[Array[Double]], +) -> (Array[Array[Double]], Bool) { let n_curve = curve.length() let n_points = points.length() - if n_curve < 2 || n_points == 0 { return (curve, false) } + if n_curve < 2 || n_points == 0 { + return (curve, false) + } let dim = curve[0].length() let new_curve : Array[Array[Double]] = Array::new() let mut changed = false @@ -468,7 +562,11 @@ fn sling_refine_curve(points : Array[Array[Double]], curve : Array[Array[Double] let mut count = 0.0 let mut pi = 0 while pi < n_points { - let proj = sling_project_to_segment(points[pi], curve[start_seg], curve[end_seg]) + let proj = sling_project_to_segment( + points[pi], + curve[start_seg], + curve[end_seg], + ) let dist2 = 0.0 let mut dd = 0 while dd < dim { @@ -499,7 +597,9 @@ fn sling_refine_curve(points : Array[Array[Double]], curve : Array[Array[Double] diff_sum = diff_sum + (new_pt[k] - curve[ci][k]).abs() k = k + 1 } - if diff_sum > 1.0e-6 { changed = true } + if diff_sum > 1.0e-6 { + changed = true + } new_curve.push(new_pt) } else { new_curve.push(curve[ci]) @@ -511,7 +611,11 @@ fn sling_refine_curve(points : Array[Array[Double]], curve : Array[Array[Double] ///| /// Project a point onto a line segment. -fn sling_project_to_segment(point : Array[Double], a : Array[Double], b : Array[Double]) -> Array[Double] { +fn sling_project_to_segment( + point : Array[Double], + a : Array[Double], + b : Array[Double], +) -> Array[Double] { let dim = point.length() let ab : Array[Double] = Array::new() let mut i = 0 @@ -532,7 +636,7 @@ fn sling_project_to_segment(point : Array[Double], a : Array[Double], b : Array[ k = k + 1 } let t = if ab2 > 0.0 { sling_dot(ap, ab) / ab2 } else { 0.0 } - let t_clamped = if t < 0.0 { 0.0 } else { if t > 1.0 { 1.0 } else { t } } + let t_clamped = if t < 0.0 { 0.0 } else if t > 1.0 { 1.0 } else { t } let proj : Array[Double] = Array::new() let mut m = 0 while m < dim { @@ -542,6 +646,7 @@ fn sling_project_to_segment(point : Array[Double], a : Array[Double], b : Array[ proj } +///| /// Dot product fn sling_dot(a : Array[Double], b : Array[Double]) -> Double { let mut sum = 0.0 @@ -559,7 +664,7 @@ fn sling_dot(a : Array[Double], b : Array[Double]) -> Double { /// Compute pseudotime for cells along a lineage curve. pub fn sling_compute_pseudotime( cell_coords : Array[Array[Double]], - curve : Array[Array[Double]] + curve : Array[Array[Double]], ) -> Array[Double] { let n_cells = cell_coords.length() let n_curve = curve.length() @@ -597,9 +702,14 @@ pub fn sling_compute_pseudotime( ///| /// Find nearest point on curve to a given point. -fn sling_nearest_on_curve(point : Array[Double], curve : Array[Array[Double]]) -> (Double, Double) { +fn sling_nearest_on_curve( + point : Array[Double], + curve : Array[Array[Double]], +) -> (Double, Double) { let n = curve.length() - if n < 2 { return (0.0, sling_euclid_dist(point, curve[0])) } + if n < 2 { + return (0.0, sling_euclid_dist(point, curve[0])) + } let mut best_dist = 1.0e30 let mut best_t = 0.0 let seg_len_total = sling_total_arc_length(curve) @@ -610,8 +720,11 @@ fn sling_nearest_on_curve(point : Array[Double], curve : Array[Array[Double]]) - let dist = sling_euclid_dist(point, proj) let seg_len = sling_euclid_dist(curve[i], curve[i + 1]) let local_t = if seg_len > 0.0 { - sling_dot(sling_sub(proj, curve[i]), sling_sub(curve[i + 1], curve[i])) / (seg_len * seg_len) - } else { 0.0 } + sling_dot(sling_sub(proj, curve[i]), sling_sub(curve[i + 1], curve[i])) / + (seg_len * seg_len) + } else { + 0.0 + } let global_t = arc_acc + local_t * seg_len if dist < best_dist { best_dist = dist @@ -623,6 +736,7 @@ fn sling_nearest_on_curve(point : Array[Double], curve : Array[Array[Double]]) - (best_t, best_dist) } +///| fn sling_total_arc_length(curve : Array[Array[Double]]) -> Double { let mut total = 0.0 let mut i = 1 @@ -633,6 +747,7 @@ fn sling_total_arc_length(curve : Array[Array[Double]]) -> Double { total } +///| fn sling_sub(a : Array[Double], b : Array[Double]) -> Array[Double] { let result : Array[Double] = Array::new() let mut i = 0 @@ -643,6 +758,7 @@ fn sling_sub(a : Array[Double], b : Array[Double]) -> Array[Double] { result } +///| fn sling_euclid_dist(a : Array[Double], b : Array[Double]) -> Double { let mut sum = 0.0 let mut i = 0 @@ -661,7 +777,7 @@ fn sling_euclid_dist(a : Array[Double], b : Array[Double]) -> Double { pub fn slingshot_run( cell_coords : Array[Array[Double]], cluster_labels : Array[String], - params : SlingshotParams + params : SlingshotParams, ) -> SlingshotResult { let n_cells = cell_coords.length() let n_clusters = sling_unique_labels(cluster_labels) @@ -676,10 +792,12 @@ pub fn slingshot_run( // Build lineages from edges let lineages = sling_build_lineages(edges, nodes, start_node, terminals) // Fit principal curves - let curves = sling_fit_lineage_curves(cell_coords, cluster_labels, nodes, lineages) + let curves = sling_fit_lineage_curves( + cell_coords, cluster_labels, nodes, lineages, + ) // Compute pseudotime let (cell_pseudotime, cell_lineage, cell_branch) = sling_assign_pseudotime( - cell_coords, cluster_labels, curves, nodes + cell_coords, cluster_labels, curves, nodes, ) SlingshotResult::{ nodes, @@ -687,10 +805,11 @@ pub fn slingshot_run( curves, cell_pseudotime, cell_lineage, - cell_branch + cell_branch, } } +///| /// Get unique cluster labels fn sling_unique_labels(labels : Array[String]) -> Array[String] { let unique : Array[String] = Array::new() @@ -705,17 +824,25 @@ fn sling_unique_labels(labels : Array[String]) -> Array[String] { unique } +///| fn sling_contains_str(arr : Array[String], s : String) -> Bool { let mut i = 0 while i < arr.length() { - if arr[i] == s { return true } + if arr[i] == s { + return true + } i = i + 1 } false } +///| /// Build nodes from cluster centers -fn sling_build_nodes(cell_coords : Array[Array[Double]], cluster_labels : Array[String], unique_labels : Array[String]) -> Array[SlingshotNode] { +fn sling_build_nodes( + cell_coords : Array[Array[Double]], + cluster_labels : Array[String], + unique_labels : Array[String], +) -> Array[SlingshotNode] { let n_clusters = unique_labels.length() let nodes : Array[SlingshotNode] = Array::new() let mut c = 0 @@ -723,21 +850,25 @@ fn sling_build_nodes(cell_coords : Array[Array[Double]], cluster_labels : Array[ let label = unique_labels[c] let center = sling_cluster_center(cell_coords, cluster_labels, label) let size = sling_cluster_size(cluster_labels, label) - nodes.push(SlingshotNode::new( - "cluster_" + c.to_string(), - label, - center, - size - )) + nodes.push( + SlingshotNode::new("cluster_" + c.to_string(), label, center, size), + ) c = c + 1 } nodes } +///| /// Compute cluster center (mean coordinates) -fn sling_cluster_center(cell_coords : Array[Array[Double]], cluster_labels : Array[String], label : String) -> Array[Double] { +fn sling_cluster_center( + cell_coords : Array[Array[Double]], + cluster_labels : Array[String], + label : String, +) -> Array[Double] { let n_cells = cell_coords.length() - if n_cells == 0 { return Array::new() } + if n_cells == 0 { + return Array::new() + } let dim = cell_coords[0].length() let center : Array[Double] = Array::new() let mut d = 0 @@ -758,19 +889,28 @@ fn sling_cluster_center(cell_coords : Array[Array[Double]], cluster_labels : Arr center } +///| /// Get cluster size fn sling_cluster_size(cluster_labels : Array[String], label : String) -> Int { let mut count = 0 let mut i = 0 while i < cluster_labels.length() { - if cluster_labels[i] == label { count = count + 1 } + if cluster_labels[i] == label { + count = count + 1 + } i = i + 1 } count } +///| /// Build lineage paths from MST edges -fn sling_build_lineages(edges : Array[SlingshotEdge], nodes : Array[SlingshotNode], start_id : String, terminals : Array[String]) -> Array[Array[String]] { +fn sling_build_lineages( + edges : Array[SlingshotEdge], + nodes : Array[SlingshotNode], + start_id : String, + terminals : Array[String], +) -> Array[Array[String]] { let lineages : Array[Array[String]] = Array::new() // For each terminal, find path from start let mut t = 0 @@ -794,8 +934,14 @@ fn sling_build_lineages(edges : Array[SlingshotEdge], nodes : Array[SlingshotNod lineages } +///| /// Find path between two nodes in MST -fn sling_find_path(edges : Array[SlingshotEdge], nodes : Array[SlingshotNode], start_id : String, end_id : String) -> Array[String] { +fn sling_find_path( + edges : Array[SlingshotEdge], + nodes : Array[SlingshotNode], + start_id : String, + end_id : String, +) -> Array[String] { // BFS let node_ids : Array[String] = Array::new() let mut i = 0 @@ -823,7 +969,9 @@ fn sling_find_path(edges : Array[SlingshotEdge], nodes : Array[SlingshotNode], s // BFS from start to end let start_idx = sling_find_node_idx(node_ids, start_id) let end_idx = sling_find_node_idx(node_ids, end_id) - if start_idx < 0 || end_idx < 0 { return Array::new() } + if start_idx < 0 || end_idx < 0 { + return Array::new() + } let visited : Array[Bool] = Array::new() let prev : Array[Int] = Array::new() let mut k = 0 @@ -838,7 +986,10 @@ fn sling_find_path(edges : Array[SlingshotEdge], nodes : Array[SlingshotNode], s let mut found = false while queue.length() > 0 && !found { let current = queue.remove(0) - if current == end_idx { found = true; break } + if current == end_idx { + found = true + break + } let mut ni = 0 while ni < adj[current].length() { let next = adj[current][ni] @@ -850,13 +1001,17 @@ fn sling_find_path(edges : Array[SlingshotEdge], nodes : Array[SlingshotNode], s ni = ni + 1 } } - if !found { return Array::new() } + if !found { + return Array::new() + } // Reconstruct path let path : Array[String] = Array::new() let mut cur = end_idx while cur >= 0 { path.push(node_ids[cur]) - if cur == start_idx { break } + if cur == start_idx { + break + } cur = prev[cur] } // Reverse @@ -869,12 +1024,13 @@ fn sling_find_path(edges : Array[SlingshotEdge], nodes : Array[SlingshotNode], s reversed } +///| /// Fit principal curves for each lineage fn sling_fit_lineage_curves( cell_coords : Array[Array[Double]], cluster_labels : Array[String], nodes : Array[SlingshotNode], - lineages : Array[Array[String]] + lineages : Array[Array[String]], ) -> Array[SlingshotCurve] { let curves : Array[SlingshotCurve] = Array::new() let n_cells = cell_coords.length() @@ -899,49 +1055,67 @@ fn sling_fit_lineage_curves( c = c + 1 } // Fit principal curve - let n_segments = if lineage.length() >= 2 { (lineage.length() * 3) } else { 6 } + let n_segments = if lineage.length() >= 2 { + lineage.length() * 3 + } else { + 6 + } let curve = sling_fit_principal_curve(lineage_coords, n_segments) // Compute pseudotime let pseudotime = sling_compute_pseudotime(lineage_coords, curve) let start_node = if lineage.length() > 0 { lineage[0] } else { "" } - let end_node = if lineage.length() > 0 { lineage[lineage.length() - 1] } else { "" } + let end_node = if lineage.length() > 0 { + lineage[lineage.length() - 1] + } else { + "" + } curves.push(SlingshotCurve::{ id: "curve_" + li.to_string(), start_node, end_node, control_points: curve, pseudotime, - cell_indices: lineage_cells + cell_indices: lineage_cells, }) li = li + 1 } curves } -fn sling_find_cluster_for_node(nodes : Array[SlingshotNode], cluster_label : String) -> Int { +///| +fn sling_find_cluster_for_node( + nodes : Array[SlingshotNode], + cluster_label : String, +) -> Int { let mut i = 0 while i < nodes.length() { - if nodes[i].cluster == cluster_label { return i } + if nodes[i].cluster == cluster_label { + return i + } i = i + 1 } -1 } +///| fn sling_lineage_contains(lineage : Array[String], node_id : String) -> Bool { let mut i = 0 while i < lineage.length() { - if lineage[i] == node_id { return true } + if lineage[i] == node_id { + return true + } i = i + 1 } false } +///| /// Assign pseudotime to all cells fn sling_assign_pseudotime( cell_coords : Array[Array[Double]], cluster_labels : Array[String], curves : Array[SlingshotCurve], - nodes : Array[SlingshotNode] + nodes : Array[SlingshotNode], ) -> (Array[Double], Array[String], Array[String]) { let n_cells = cell_coords.length() let pseudotime : Array[Double] = Array::new() @@ -951,7 +1125,10 @@ fn sling_assign_pseudotime( while i < n_cells { // Find which curve this cell belongs to let (ps, lin, br) = sling_assign_cell_to_curve( - cell_coords[i], cluster_labels[i], curves, nodes + cell_coords[i], + cluster_labels[i], + curves, + nodes, ) pseudotime.push(ps) lineages.push(lin) @@ -961,12 +1138,13 @@ fn sling_assign_pseudotime( (pseudotime, lineages, branches) } +///| /// Assign a cell to the nearest curve fn sling_assign_cell_to_curve( cell_coord : Array[Double], cluster_label : String, curves : Array[SlingshotCurve], - nodes : Array[SlingshotNode] + nodes : Array[SlingshotNode], ) -> (Double, String, String) { // Find curves containing this cell's cluster let cluster_idx = sling_find_cluster_for_node(nodes, cluster_label) @@ -998,7 +1176,12 @@ fn sling_assign_cell_to_curve( (best_ps, lineage_name, branch_name) } -fn sling_curve_contains_cluster(curve : SlingshotCurve, nodes : Array[SlingshotNode], cluster_id : String) -> Bool { +///| +fn sling_curve_contains_cluster( + curve : SlingshotCurve, + nodes : Array[SlingshotNode], + cluster_id : String, +) -> Bool { // Check if start or end node of curve matches the cluster if curve.start_node == cluster_id || curve.end_node == cluster_id { return true @@ -1008,8 +1191,12 @@ fn sling_curve_contains_cluster(curve : SlingshotCurve, nodes : Array[SlingshotN curve.cell_indices.length() > 0 } +///| /// Compute pseudotime for a cell on a given curve -fn sling_pseudotime_for_cell(cell_coord : Array[Double], curve : SlingshotCurve) -> (Double, Double) { +fn sling_pseudotime_for_cell( + cell_coord : Array[Double], + curve : SlingshotCurve, +) -> (Double, Double) { let control = curve.control_points if control.length() < 2 { return (0.0, 1.0e30) @@ -1019,8 +1206,11 @@ fn sling_pseudotime_for_cell(cell_coord : Array[Double], curve : SlingshotCurve) (t, dist) } +///| /// Get sorted pseudotime values -pub fn SlingshotResult::sling_sorted_pseudotime(self : SlingshotResult) -> Array[(Double, Int)] { +pub fn SlingshotResult::sling_sorted_pseudotime( + self : SlingshotResult, +) -> Array[(Double, Int)] { let n = self.cell_pseudotime.length() let indexed : Array[(Double, Int)] = Array::new() let mut i = 0 @@ -1046,8 +1236,12 @@ pub fn SlingshotResult::sling_sorted_pseudotime(self : SlingshotResult) -> Array sorted } +///| /// Get cells along a specific lineage -pub fn SlingshotResult::sling_cells_on_lineage(self : SlingshotResult, lineage_id : String) -> Array[Int] { +pub fn SlingshotResult::sling_cells_on_lineage( + self : SlingshotResult, + lineage_id : String, +) -> Array[Int] { let cells : Array[Int] = Array::new() let n = self.cell_lineage.length() let mut i = 0 diff --git a/src/smart.mbt b/src/smart.mbt index 899e8db6..eae3d5fa 100644 --- a/src/smart.mbt +++ b/src/smart.mbt @@ -36,7 +36,7 @@ pub fn SmartDomain::new( domain_name : String, start : Int, end : Int, - evalue? : Double = 0.0 + evalue? : Double = 0.0, ) -> SmartDomain { SmartDomain::{ domain_id, @@ -68,7 +68,7 @@ pub struct SmartResult { /// Construct a SmartResult. pub fn SmartResult::new( sequence_id : String, - sequence_length? : Int = 0 + sequence_length? : Int = 0, ) -> SmartResult { SmartResult::{ sequence_id, @@ -171,7 +171,10 @@ fn smart_parse_domain_line(cols : Array[String]) -> SmartDomain { ///| /// Find all domains matching a given domain name (substring match). -pub fn smart_find_domains(result : SmartResult, name : String) -> Array[SmartDomain] { +pub fn smart_find_domains( + result : SmartResult, + name : String, +) -> Array[SmartDomain] { let matches : Array[SmartDomain] = Array::new() let mut i = 0 while i < result.domains.length() { @@ -192,7 +195,11 @@ pub fn smart_find_domains(result : SmartResult, name : String) -> Array[SmartDom ///| /// Find all domains overlapping with a given region [start, end]. -pub fn smart_find_overlapping_domains(result : SmartResult, start : Int, end : Int) -> Array[SmartDomain] { +pub fn smart_find_overlapping_domains( + result : SmartResult, + start : Int, + end : Int, +) -> Array[SmartDomain] { let matches : Array[SmartDomain] = Array::new() let mut i = 0 while i < result.domains.length() { @@ -220,11 +227,10 @@ pub fn smart_best_domain(result : SmartResult) -> SmartDomain? { let mut i = 0 while i < result.domains.length() { match best { - Some(cur) => { + Some(cur) => if result.domains[i].evalue < cur.evalue { best = Some(result.domains[i]) } - } None => best = Some(result.domains[i]) } i = i + 1 @@ -232,11 +238,10 @@ pub fn smart_best_domain(result : SmartResult) -> SmartDomain? { let mut j = 0 while j < result.pfam_domains.length() { match best { - Some(cur) => { + Some(cur) => if result.pfam_domains[j].evalue < cur.evalue { best = Some(result.pfam_domains[j]) } - } None => best = Some(result.pfam_domains[j]) } j = j + 1 @@ -252,7 +257,10 @@ pub fn smart_total_domains(result : SmartResult) -> Int { ///| /// Filter domains by E-value threshold. -pub fn smart_filter_evalue(result : SmartResult, max_evalue : Double) -> Array[SmartDomain] { +pub fn smart_filter_evalue( + result : SmartResult, + max_evalue : Double, +) -> Array[SmartDomain] { let filtered : Array[SmartDomain] = Array::new() let mut i = 0 while i < result.domains.length() { @@ -275,9 +283,7 @@ pub fn smart_filter_evalue(result : SmartResult, max_evalue : Double) -> Array[S /// Generate a sample SMART output string for testing. pub fn smart_sample() -> String { let lines = [ - "#sequence_id\tProtein123", - "#sequence_length\t350", - "SM00001\tABC_membrane\tSMART\t10\t100\t1.5e-30\tMFWVLVVVGGVLALAVLVLAVL\tABC transporter membrane domain\tPF00001\tIPR00001\tGO:0005215;GO:0016020", + "#sequence_id\tProtein123", "#sequence_length\t350", "SM00001\tABC_membrane\tSMART\t10\t100\t1.5e-30\tMFWVLVVVGGVLALAVLVLAVL\tABC transporter membrane domain\tPF00001\tIPR00001\tGO:0005215;GO:0016020", "SM00002\tABC_subdomain\tSMART\t110\t250\t2.3e-25\tGCGKSTEQRLLLDELPGRRL\tABC transporter nucleotide binding domain\tPF00002\tIPR00002\tGO:0005524", "SM00003\tABC_membrane\tSMART\t260\t340\t5.1e-28\tVVLLVAVVGCGVALALVAVLL\tABC transporter membrane domain\tPF00001\tIPR00001\tGO:0005215;GO:0016020", "PF00001\tABC_membrane\tPfam\t10\t100\t1.5e-30\tMFWVLVVVGGVLALAVLVLAVL\tABC transporter membrane domain\tPF00001\tIPR00001\tGO:0005215;GO:0016020", @@ -305,12 +311,29 @@ pub fn smart_summary(result : SmartResult) -> String { out = out + "Length: " + result.sequence_length.to_string() + "\n" out = out + "SMART domains: " + result.domains.length().to_string() + "\n" out = out + "Pfam domains: " + result.pfam_domains.length().to_string() + "\n" - out = out + "Signal peptides: " + result.signal_peptides.length().to_string() + "\n" - out = out + "Transmembrane: " + result.transmembrane.length().to_string() + "\n" + out = out + + "Signal peptides: " + + result.signal_peptides.length().to_string() + + "\n" + out = out + + "Transmembrane: " + + result.transmembrane.length().to_string() + + "\n" let mut i = 0 while i < result.domains.length() { let d = result.domains[i] - out = out + " " + d.domain_id + "\t" + d.domain_name + "\t" + d.start.to_string() + "-" + d.end.to_string() + "\tE=" + d.evalue.to_string() + "\n" + out = out + + " " + + d.domain_id + + "\t" + + d.domain_name + + "\t" + + d.start.to_string() + + "-" + + d.end.to_string() + + "\tE=" + + d.evalue.to_string() + + "\n" i = i + 1 } out @@ -332,7 +355,9 @@ fn smart_split_lines(content : String) -> Array[String] { if start < i { lines.push(content[start:i].trim().to_string()) } - if ch == "\r" && i + 1 < content.length() && content[i + 1:i + 2].to_owned() == "\n" { + if ch == "\r" && + i + 1 < content.length() && + content[i + 1:i + 2].to_owned() == "\n" { i = i + 1 } start = i + 1 @@ -366,7 +391,9 @@ fn smart_split_tab(line : String) -> Array[String] { /// Split a string by semicolon delimiter. fn smart_split_semicolon(s : String) -> Array[String] { let items : Array[String] = Array::new() - if s.length() == 0 { return items } + if s.length() == 0 { + return items + } let mut start = 0 let mut i = 0 while i < s.length() { @@ -407,13 +434,17 @@ fn smart_extract_value(line : String) -> String { fn smart_parse_int(s : String) -> Int { let sv = s.to_string().trim() let n = sv.length() - if n == 0 { return 0 } + if n == 0 { + return 0 + } let mut result = 0 let mut i = 0 let zero = '0'.to_int() while i < n { let c = sv.unsafe_get(i).to_int() - if c < zero || c > zero + 9 { break } + if c < zero || c > zero + 9 { + break + } result = result * 10 + (c - zero) i = i + 1 } @@ -424,7 +455,9 @@ fn smart_parse_int(s : String) -> Int { /// Parse a double from a string, returning 0.0 on failure. fn smart_parse_double(s : String) -> Double { let sv = s.to_string().trim() - if sv.length() == 0 { return 0.0 } + if sv.length() == 0 { + return 0.0 + } let n = sv.length() let mut result = 0.0 let mut decimal = 0 @@ -437,7 +470,9 @@ fn smart_parse_double(s : String) -> Double { } while i < n { let c = sv.unsafe_get(i).to_int() - if c < zero || c > zero + 9 { break } + if c < zero || c > zero + 9 { + break + } result = result * 10.0 + (c - zero).to_double() i = i + 1 } @@ -445,7 +480,9 @@ fn smart_parse_double(s : String) -> Double { i = i + 1 while i < n { let c = sv.unsafe_get(i).to_int() - if c < zero || c > zero + 9 { break } + if c < zero || c > zero + 9 { + break + } result = result * 10.0 + (c - zero).to_double() decimal = decimal + 1 i = i + 1 @@ -468,7 +505,9 @@ fn smart_parse_double(s : String) -> Double { } while i < n { let c = sv.unsafe_get(i).to_int() - if c < zero || c > zero + 9 { break } + if c < zero || c > zero + 9 { + break + } exponent = exponent * 10 + (c - zero) i = i + 1 } diff --git a/src/snapgene_io.mbt b/src/snapgene_io.mbt index f1c3d942..920b81a3 100644 --- a/src/snapgene_io.mbt +++ b/src/snapgene_io.mbt @@ -99,13 +99,7 @@ pub fn SnapgenePrimer::new( bind_to~ : Int, binds_at_position~ : Int, ) -> SnapgenePrimer { - SnapgenePrimer::{ - name, - sequence, - description, - bind_to, - binds_at_position, - } + SnapgenePrimer::{ name, sequence, description, bind_to, binds_at_position } } ///| @@ -140,7 +134,10 @@ pub fn SnapgeneFile::new() -> SnapgeneFile { ///| /// Set the sequence type. -pub fn SnapgeneFile::set_seq_type(self : SnapgeneFile, t : SnapgeneSeqType) -> Unit { +pub fn SnapgeneFile::set_seq_type( + self : SnapgeneFile, + t : SnapgeneSeqType, +) -> Unit { self.seq_type = t } @@ -152,7 +149,10 @@ pub fn SnapgeneFile::set_comments(self : SnapgeneFile, s : String) -> Unit { ///| /// Set the export version. -pub fn SnapgeneFile::set_export_version(self : SnapgeneFile, s : String) -> Unit { +pub fn SnapgeneFile::set_export_version( + self : SnapgeneFile, + s : String, +) -> Unit { self.export_version = s } @@ -176,13 +176,19 @@ pub fn SnapgeneFile::set_circular(self : SnapgeneFile, b : Bool) -> Unit { ///| /// Add a feature to the file. -pub fn SnapgeneFile::add_feature(self : SnapgeneFile, f : SnapgeneFeature) -> Unit { +pub fn SnapgeneFile::add_feature( + self : SnapgeneFile, + f : SnapgeneFeature, +) -> Unit { self.features.push(f) } ///| /// Add a primer to the file. -pub fn SnapgeneFile::add_primer(self : SnapgeneFile, p : SnapgenePrimer) -> Unit { +pub fn SnapgeneFile::add_primer( + self : SnapgeneFile, + p : SnapgenePrimer, +) -> Unit { self.primers.push(p) } @@ -363,7 +369,15 @@ fn sg_build_comments( let type_str = seq_type.to_string() let circ_str = if is_circular { "true" } else { "false" } let ev = if export_version == "" { "1.0" } else { export_version } - "{\"comments\":\"" + sg_json_escape(comments) + "\",\"type\":\"" + type_str + "\",\"exportVersion\":\"" + ev + "\",\"circular\":" + circ_str + "}" + "{\"comments\":\"" + + sg_json_escape(comments) + + "\",\"type\":\"" + + type_str + + "\",\"exportVersion\":\"" + + ev + + "\",\"circular\":" + + circ_str + + "}" } ///| @@ -372,21 +386,11 @@ fn sg_json_escape(s : String) -> String { let sb = StringBuilder::new() for c in s.to_array() { match c { - '"' => { - sb.write_string("\\\"") - } - '\\' => { - sb.write_string("\\\\") - } - '\n' => { - sb.write_string("\\n") - } - '\t' => { - sb.write_string("\\t") - } - '\r' => { - sb.write_string("\\r") - } + '"' => sb.write_string("\\\"") + '\\' => sb.write_string("\\\\") + '\n' => sb.write_string("\\n") + '\t' => sb.write_string("\\t") + '\r' => sb.write_string("\\r") c => sb.write_char(c) } } @@ -463,13 +467,7 @@ fn sg_parse_one_feature(text : String) -> SnapgeneFeature? { } } Some( - SnapgeneFeature::new( - name=name, - type_=type_, - direction=direction, - segments=segs, - qualifiers=qualifiers, - ), + SnapgeneFeature::new(name~, type_~, direction~, segments=segs, qualifiers~), ) } @@ -536,15 +534,41 @@ fn sg_build_features(features : Array[SnapgeneFeature]) -> String { let sb = StringBuilder::new() sb.write_string("") for f in features { - let dir_str = if f.direction == 1 { "1" } else if f.direction == -1 { "-1" } else { "0" } - sb.write_string("") + let dir_str = if f.direction == 1 { + "1" + } else if f.direction == -1 { + "-1" + } else { + "0" + } + sb.write_string( + "", + ) for seg in f.segments { let (start, end) = seg - sb.write_string("") + sb.write_string( + "", + ) } let keys = f.qualifiers.keys() for k in keys { - sb.write_string("") + sb.write_string( + "", + ) } sb.write_string("") } @@ -625,10 +649,10 @@ fn sg_parse_primers(data : Array[Int]) -> Array[SnapgenePrimer] { offset = offset + 4 primers.push( SnapgenePrimer::new( - name=name, - sequence=sequence, - description=description, - bind_to=bind_to, + name~, + sequence~, + description~, + bind_to~, binds_at_position=binds_at, ), ) @@ -878,7 +902,7 @@ pub fn snapgene_to_seqrecord(file : SnapgeneFile) -> SeqRecord { let id = if file.comments != "" { file.comments } else { "snapgene" } let rec = SeqRecord::new( Seq::new(file.sequence), - id=id, + id~, name=id, description=file.comments, ) @@ -928,7 +952,9 @@ pub fn snapgene_summary(file : SnapgeneFile) -> String { sb.write_string(" Type: " + file.seq_type.to_string() + "\n") sb.write_string(" Circular: " + file.is_circular.to_string() + "\n") sb.write_string(" Export Version: " + file.export_version + "\n") - sb.write_string(" Sequence Length: " + snapgene_seq_length(file).to_string() + " bp\n") + sb.write_string( + " Sequence Length: " + snapgene_seq_length(file).to_string() + " bp\n", + ) sb.write_string(" Features: " + file.features.length().to_string() + "\n") sb.write_string(" Primers: " + file.primers.length().to_string() + "\n") if file.features.length() > 0 { diff --git a/src/spatial_experiment.mbt b/src/spatial_experiment.mbt index 2f530860..87b932e7 100644 --- a/src/spatial_experiment.mbt +++ b/src/spatial_experiment.mbt @@ -26,7 +26,11 @@ pub struct SpatialImage { } ///| -pub fn SpatialImage::new(id : String, data : Array[Array[Double]], scale_factor : Double) -> SpatialImage { +pub fn SpatialImage::new( + id : String, + data : Array[Array[Double]], + scale_factor : Double, +) -> SpatialImage { SpatialImage::{ id, data, scale_factor } } @@ -48,42 +52,62 @@ pub fn SpatialExperiment::new() -> SpatialExperiment { col_data: Array::new(), spatial_coords: Array::new(), images: Array::new(), - metadata: Map([], capacity=0) + metadata: Map([], capacity=0), } } ///| -pub fn se_add_assay(se : SpatialExperiment, name : String, data : Array[Array[Double]]) -> SpatialExperiment { +pub fn se_add_assay( + se : SpatialExperiment, + name : String, + data : Array[Array[Double]], +) -> SpatialExperiment { se.assay.set(name, data) se } ///| -pub fn se_add_row(se : SpatialExperiment, row : Map[String, String]) -> SpatialExperiment { +pub fn se_add_row( + se : SpatialExperiment, + row : Map[String, String], +) -> SpatialExperiment { se.row_data.push(row) se } ///| -pub fn se_add_col(se : SpatialExperiment, col : Map[String, String]) -> SpatialExperiment { +pub fn se_add_col( + se : SpatialExperiment, + col : Map[String, String], +) -> SpatialExperiment { se.col_data.push(col) se } ///| -pub fn se_add_spatial_coord(se : SpatialExperiment, coord : SpatialCoord) -> SpatialExperiment { +pub fn se_add_spatial_coord( + se : SpatialExperiment, + coord : SpatialCoord, +) -> SpatialExperiment { se.spatial_coords.push(coord) se } ///| -pub fn se_add_image(se : SpatialExperiment, image : SpatialImage) -> SpatialExperiment { +pub fn se_add_image( + se : SpatialExperiment, + image : SpatialImage, +) -> SpatialExperiment { se.images.push(image) se } ///| -pub fn se_set_metadata(se : SpatialExperiment, key : String, value : String) -> SpatialExperiment { +pub fn se_set_metadata( + se : SpatialExperiment, + key : String, + value : String, +) -> SpatialExperiment { se.metadata.set(key, value) se } @@ -104,16 +128,18 @@ pub fn se_num_assays(se : SpatialExperiment) -> Int { } ///| -pub fn se_get_spatial_range(se : SpatialExperiment) -> (Double, Double, Double, Double) { +pub fn se_get_spatial_range( + se : SpatialExperiment, +) -> (Double, Double, Double, Double) { if se.spatial_coords.length() == 0 { return (0.0, 0.0, 0.0, 0.0) } - + let mut min_x = se.spatial_coords[0].x let mut max_x = se.spatial_coords[0].x let mut min_y = se.spatial_coords[0].y let mut max_y = se.spatial_coords[0].y - + let mut i = 1 while i < se.spatial_coords.length() { let coord = se.spatial_coords[i] @@ -131,30 +157,39 @@ pub fn se_get_spatial_range(se : SpatialExperiment) -> (Double, Double, Double, } i = i + 1 } - + (min_x, max_x, min_y, max_y) } ///| -pub fn se_filter_spots_by_range(se : SpatialExperiment, min_x : Double, max_x : Double, min_y : Double, max_y : Double) -> SpatialExperiment { +pub fn se_filter_spots_by_range( + se : SpatialExperiment, + min_x : Double, + max_x : Double, + min_y : Double, + max_y : Double, +) -> SpatialExperiment { let filtered = SpatialExperiment::new() - + let mut i = 0 while i < se.row_data.length() { filtered.row_data.push(se.row_data[i]) i = i + 1 } - + let mut j = 0 while j < se.images.length() { filtered.images.push(se.images[j]) j = j + 1 } - + let mut k = 0 while k < se.spatial_coords.length() { let coord = se.spatial_coords[k] - if coord.x >= min_x && coord.x <= max_x && coord.y >= min_y && coord.y <= max_y { + if coord.x >= min_x && + coord.x <= max_x && + coord.y >= min_y && + coord.y <= max_y { filtered.spatial_coords.push(coord) if k < se.col_data.length() { filtered.col_data.push(se.col_data[k]) @@ -162,7 +197,7 @@ pub fn se_filter_spots_by_range(se : SpatialExperiment, min_x : Double, max_x : } k = k + 1 } - + filtered } @@ -171,28 +206,46 @@ pub fn create_example_spatial_experiment() -> SpatialExperiment { let se = SpatialExperiment::new() let _ = se_set_metadata(se, "platform", "Visium") let _ = se_set_metadata(se, "sample_id", "sample001") - - se.row_data.push(Map([("gene_id", "ENSG000001"), ("gene_name", "ACTB")], capacity=2)) - se.row_data.push(Map([("gene_id", "ENSG000002"), ("gene_name", "GAPDH")], capacity=2)) - se.row_data.push(Map([("gene_id", "ENSG000003"), ("gene_name", "TP53")], capacity=2)) - - se.col_data.push(Map([("spot_id", "AAACAAGTATCTCCCA"), ("tissue", "tumor")], capacity=2)) - se.col_data.push(Map([("spot_id", "AAACAGCTTTCAGAAG"), ("tissue", "tumor")], capacity=2)) - se.col_data.push(Map([("spot_id", "AAACAGGGTCTATATT"), ("tissue", "normal")], capacity=2)) - se.col_data.push(Map([("spot_id", "AAACATTTCCCGGATT"), ("tissue", "normal")], capacity=2)) - se.col_data.push(Map([("spot_id", "AAACCGGGTGTATGGC"), ("tissue", "tumor")], capacity=2)) - se.col_data.push(Map([("spot_id", "AAACCGTTCGTCCACA"), ("tissue", "normal")], capacity=2)) - + + se.row_data.push( + Map([("gene_id", "ENSG000001"), ("gene_name", "ACTB")], capacity=2), + ) + se.row_data.push( + Map([("gene_id", "ENSG000002"), ("gene_name", "GAPDH")], capacity=2), + ) + se.row_data.push( + Map([("gene_id", "ENSG000003"), ("gene_name", "TP53")], capacity=2), + ) + + se.col_data.push( + Map([("spot_id", "AAACAAGTATCTCCCA"), ("tissue", "tumor")], capacity=2), + ) + se.col_data.push( + Map([("spot_id", "AAACAGCTTTCAGAAG"), ("tissue", "tumor")], capacity=2), + ) + se.col_data.push( + Map([("spot_id", "AAACAGGGTCTATATT"), ("tissue", "normal")], capacity=2), + ) + se.col_data.push( + Map([("spot_id", "AAACATTTCCCGGATT"), ("tissue", "normal")], capacity=2), + ) + se.col_data.push( + Map([("spot_id", "AAACCGGGTGTATGGC"), ("tissue", "tumor")], capacity=2), + ) + se.col_data.push( + Map([("spot_id", "AAACCGTTCGTCCACA"), ("tissue", "normal")], capacity=2), + ) + se.spatial_coords.push(SpatialCoord::new_2d(100.0, 200.0)) se.spatial_coords.push(SpatialCoord::new_2d(150.0, 250.0)) se.spatial_coords.push(SpatialCoord::new_2d(200.0, 150.0)) se.spatial_coords.push(SpatialCoord::new_2d(250.0, 200.0)) se.spatial_coords.push(SpatialCoord::new_2d(300.0, 250.0)) se.spatial_coords.push(SpatialCoord::new_2d(350.0, 150.0)) - + let image_data : Array[Array[Double]] = Array::new() let image = SpatialImage::new("HE", image_data, 0.1) se.images.push(image) - + se -} \ No newline at end of file +} diff --git a/src/spia.mbt b/src/spia.mbt index a38edf93..64342a7a 100644 --- a/src/spia.mbt +++ b/src/spia.mbt @@ -98,13 +98,19 @@ pub fn SignalingPathway::new(id : String, name : String) -> SignalingPathway { ///| /// Add a node to the pathway. -pub fn SignalingPathway::add_node(self : SignalingPathway, node : PathwayNode) -> Unit { +pub fn SignalingPathway::add_node( + self : SignalingPathway, + node : PathwayNode, +) -> Unit { self.nodes.push(node) } ///| /// Get a node by gene ID. -pub fn SignalingPathway::get_node(self : SignalingPathway, gene_id : String) -> PathwayNode? { +pub fn SignalingPathway::get_node( + self : SignalingPathway, + gene_id : String, +) -> PathwayNode? { let mut i = 0 while i < self.nodes.length() { if self.nodes[i].gene_id == gene_id { @@ -147,10 +153,7 @@ pub fn run_spia( } // Over-representation p-value (hypergeometric test) let p_or = hypergeometric_pvalue( - n_de_in_pathway, - n_pathway_genes, - n_de, - n_total, + n_de_in_pathway, n_pathway_genes, n_de, n_total, ) // Perturbation accumulation let pert_factor = compute_perturbation(pathway, de_genes) @@ -159,7 +162,13 @@ pub fn run_spia( // Combine p-values using Fisher's method let p_combined = fisher_combine(p_or, p_pert) // Activation status - let activation_status = if pert_factor > 0.0 { 1 } else if pert_factor < 0.0 { -1 } else { 0 } + let activation_status = if pert_factor > 0.0 { + 1 + } else if pert_factor < 0.0 { + -1 + } else { + 0 + } all_results.push(SpiaResult::{ pathway_id: pathway.id, pathway_name: pathway.name, @@ -303,7 +312,13 @@ fn hypergeometric_pvalue( return 1.0 } let p = @math.exp(-chi_sq / 2.0) / (2.0 * 3.14159265358979 * chi_sq).sqrt() - if p > 1.0 { 1.0 } else if p < 0.0 { 0.0 } else { p } + if p > 1.0 { + 1.0 + } else if p < 0.0 { + 0.0 + } else { + p + } } ///| @@ -322,7 +337,13 @@ fn perturbation_pvalue(pert_factor : Double, n_de : Int) -> Double { let abs_z = if z < 0.0 { -z } else { z } // Two-sided p-value using normal CDF approximation let p = spia_erfc_approx(abs_z / 1.4142135623730951) - if p > 1.0 { 1.0 } else if p < 0.0 { 0.0 } else { p } + if p > 1.0 { + 1.0 + } else if p < 0.0 { + 0.0 + } else { + p + } } ///| @@ -341,7 +362,13 @@ fn fisher_combine(p1 : Double, p2 : Double) -> Double { // p-value from chi-squared with df=4 (since 2 p-values) // Use the formula: p = exp(-stat/2) * (1 + stat/2) let p = @math.exp(-stat / 2.0) * (1.0 + stat / 2.0) - if p > 1.0 { 1.0 } else if p < 0.0 { 0.0 } else { p } + if p > 1.0 { + 1.0 + } else if p < 0.0 { + 0.0 + } else { + p + } } ///| @@ -355,7 +382,12 @@ fn spia_erfc_approx(x : Double) -> Double { let t3 = t2 * t let t4 = t3 * t let t5 = t4 * t - let poly = 1.0 + 0.254829592 * t + -0.284496736 * t2 + 1.421413741 * t3 + -1.453152027 * t4 + 1.061405429 * t5 + let poly = 1.0 + + 0.254829592 * t + + -0.284496736 * t2 + + 1.421413741 * t3 + + -1.453152027 * t4 + + 1.061405429 * t5 @math.exp(-x * x) * poly } @@ -454,7 +486,10 @@ pub fn SpiaResults::get_inhibited(self : SpiaResults) -> Array[SpiaResult] { ///| /// Get top N pathways by combined p-value. -pub fn SpiaResults::get_top_pathways(self : SpiaResults, n : Int) -> Array[SpiaResult] { +pub fn SpiaResults::get_top_pathways( + self : SpiaResults, + n : Int, +) -> Array[SpiaResult] { let sorted = self.results.copy() let len = sorted.length() let mut i = 0 @@ -485,13 +520,31 @@ pub fn SpiaResults::get_top_pathways(self : SpiaResults, n : Int) -> Array[SpiaR pub fn SpiaResults::summary(self : SpiaResults) -> String { let mut s = "=== SPIA Analysis Summary ===\n".to_string() s = s + "Pathways tested: " + self.n_pathways.to_string() + "\n" - s = s + "Significant (FDR < " + self.fdr_threshold.to_string() + "): " + self.n_significant.to_string() + "\n" + s = s + + "Significant (FDR < " + + self.fdr_threshold.to_string() + + "): " + + self.n_significant.to_string() + + "\n" let mut i = 0 while i < self.results.length() { let r = self.results[i] if r.significant { - let status = if r.activation_status > 0 { "Activated" } else if r.activation_status < 0 { "Inhibited" } else { "Neutral" } - s = s + " " + r.pathway_name + " (" + status + ", p_adj=" + r.p_adj.to_string() + ")\n" + let status = if r.activation_status > 0 { + "Activated" + } else if r.activation_status < 0 { + "Inhibited" + } else { + "Neutral" + } + s = s + + " " + + r.pathway_name + + " (" + + status + + ", p_adj=" + + r.p_adj.to_string() + + ")\n" } i = i + 1 } diff --git a/src/stage_r.mbt b/src/stage_r.mbt index 2e6711c1..0b86dbce 100644 --- a/src/stage_r.mbt +++ b/src/stage_r.mbt @@ -137,7 +137,11 @@ pub fn stage_r_bh_adjust(pvalues : Array[Double]) -> Array[Double] { while i >= 0 { let rank = (i + 1).to_double() let raw_adj = pairs[i].1 * n.to_double() / rank - adj_sorted[i] = if raw_adj < adj_sorted[i + 1] { raw_adj } else { adj_sorted[i + 1] } + adj_sorted[i] = if raw_adj < adj_sorted[i + 1] { + raw_adj + } else { + adj_sorted[i + 1] + } if adj_sorted[i] > 1.0 { adj_sorted[i] = 1.0 } @@ -433,7 +437,10 @@ pub fn get_results(result : StageRResult) -> Array[Array[Bool]] { row.push(result.pAdjScreen[i] <= result.alpha) let mut j = 0 while j < h { - row.push(result.pAdjConfirmation[i][j] >= 0.0 && result.pAdjConfirmation[i][j] <= result.alpha) + row.push( + result.pAdjConfirmation[i][j] >= 0.0 && + result.pAdjConfirmation[i][j] <= result.alpha, + ) j = j + 1 } mat.push(row) @@ -466,7 +473,8 @@ pub fn get_significant_hypotheses(result : StageRResult) -> Array[(Int, Int)] { if result.pAdjScreen[i] <= result.alpha { let mut j = 0 while j < result.nHypotheses { - if result.pAdjConfirmation[i][j] >= 0.0 && result.pAdjConfirmation[i][j] <= result.alpha { + if result.pAdjConfirmation[i][j] >= 0.0 && + result.pAdjConfirmation[i][j] <= result.alpha { sigs.push((i, j)) } j = j + 1 @@ -482,14 +490,28 @@ pub fn get_significant_hypotheses(result : StageRResult) -> Array[(Int, Int)] { pub fn stage_r_summary(result : StageRResult) -> String { let buf = StringBuilder::new() buf.write_string("StageR Two-Stage Testing Summary\n") - buf.write_string(" Method: " + stage_r_method_name(result.stageMethod) + "\n") + buf.write_string( + " Method: " + stage_r_method_name(result.stageMethod) + "\n", + ) buf.write_string(" Target OFDR (alpha): " + result.alpha.to_string() + "\n") - buf.write_string(" Adjusted alpha: " + result.alphaAdjusted.to_string() + "\n") + buf.write_string( + " Adjusted alpha: " + result.alphaAdjusted.to_string() + "\n", + ) buf.write_string(" Total genes: " + result.nGenes.to_string() + "\n") - buf.write_string(" Hypotheses per gene: " + result.nHypotheses.to_string() + "\n") - buf.write_string(" Significant genes (screening): " + result.nSignificantGenes.to_string() + "\n") + buf.write_string( + " Hypotheses per gene: " + result.nHypotheses.to_string() + "\n", + ) + buf.write_string( + " Significant genes (screening): " + + result.nSignificantGenes.to_string() + + "\n", + ) let sig_hyps = get_significant_hypotheses(result) - buf.write_string(" Significant hypotheses (confirmation): " + sig_hyps.length().to_string() + "\n") + buf.write_string( + " Significant hypotheses (confirmation): " + + sig_hyps.length().to_string() + + "\n", + ) buf.to_string() } diff --git a/src/statistics.mbt b/src/statistics.mbt index 30d7426f..0b249fd5 100644 --- a/src/statistics.mbt +++ b/src/statistics.mbt @@ -71,7 +71,7 @@ pub fn stat_mode(data : Array[Double]) -> Double { counts.set(val, current + 1) i = i + 1 } - + let mut max_count = 0 let mut mode_val = data[0] for key in counts.keys() { @@ -170,15 +170,15 @@ pub fn stat_pearson_correlation(x : Array[Double], y : Array[Double]) -> Double if n < 3 { return 0.0 } - + let mean_x = stat_mean(x) let mean_y = stat_mean(y) - + let mut num = 0.0 let mut den_x = 0.0 let mut den_y = 0.0 let mut i = 0 - + while i < n { let dx = x[i] - mean_x let dy = y[i] - mean_y @@ -187,7 +187,7 @@ pub fn stat_pearson_correlation(x : Array[Double], y : Array[Double]) -> Double den_y = den_y + dy * dy i = i + 1 } - + let denom = (den_x * den_y).sqrt() if denom == 0.0 { 0.0 @@ -198,7 +198,10 @@ pub fn stat_pearson_correlation(x : Array[Double], y : Array[Double]) -> Double ///| /// Calculate the Spearman rank correlation coefficient. -pub fn stat_spearman_correlation(x : Array[Double], y : Array[Double]) -> Double { +pub fn stat_spearman_correlation( + x : Array[Double], + y : Array[Double], +) -> Double { let ranks_x = stat_rank(x) let ranks_y = stat_rank(y) stat_pearson_correlation(ranks_x, ranks_y) @@ -209,7 +212,7 @@ pub fn stat_spearman_correlation(x : Array[Double], y : Array[Double]) -> Double pub fn stat_rank(data : Array[Double]) -> Array[Double] { let n = data.length() let result : Array[Double] = Array::make(n, 0.0) - + let indexed : Array[Array[Double]] = Array::new() let mut i = 0 while i < n { @@ -217,16 +220,24 @@ pub fn stat_rank(data : Array[Double]) -> Array[Double] { indexed.push(row) i = i + 1 } - - indexed.sort_by(fn(a: Array[Double], b: Array[Double]) -> Int { if a[0] < b[0] { -1 } else if a[0] > b[0] { 1 } else { 0 } }) - + + indexed.sort_by(fn(a : Array[Double], b : Array[Double]) -> Int { + if a[0] < b[0] { + -1 + } else if a[0] > b[0] { + 1 + } else { + 0 + } + }) + let mut pos = 0 while pos < n { let mut end = pos while end < n - 1 && indexed[end + 1][0] == indexed[pos][0] { end = end + 1 } - let avg_rank = ((pos + end).to_double() / 2.0) + 1.0 + let avg_rank = (pos + end).to_double() / 2.0 + 1.0 let mut j = pos while j <= end { let idx = indexed[j][1].to_int() @@ -235,7 +246,7 @@ pub fn stat_rank(data : Array[Double]) -> Array[Double] { } pos = end + 1 } - + result } @@ -275,7 +286,12 @@ pub fn stat_pvalue_zscore(z : Double) -> Double { pub fn stat_normal_cdf(x : Double) -> Double { let t = 1.0 / (1.0 + 0.2316419 * (if x < 0.0 { -x } else { x })) let d = 0.3989423 * @math.exp(-x * x / 2.0) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.8212560 + t * 1.3302744)))) + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.8212560 + t * 1.3302744))) + ) if x > 0.0 { 1.0 - p } else { @@ -295,7 +311,7 @@ pub fn stat_t_statistic(sample : Array[Double], mu_0 : Double) -> Double { if std == 0.0 { 0.0 } else { - (mean - mu_0) / (std / (n.to_double()).sqrt()) + (mean - mu_0) / (std / n.to_double().sqrt()) } } @@ -304,20 +320,25 @@ pub fn stat_t_statistic(sample : Array[Double], mu_0 : Double) -> Double { pub fn stat_pvalue_t(t : Double, df : Int) -> Double { let abs_t = if t < 0.0 { -t } else { t } // Approximation using normal distribution for large df - let z = abs_t * (1.0 - 1.0 / (4.0 * df.to_double())) / (1.0 + t * t / (df.to_double())).sqrt() + let z = abs_t * + (1.0 - 1.0 / (4.0 * df.to_double())) / + (1.0 + t * t / df.to_double()).sqrt() 2.0 * (1.0 - stat_normal_cdf(z)) } ///| /// Calculate confidence interval for the mean. -pub fn stat_confidence_interval(data : Array[Double], confidence? : Double = 0.95) -> Array[Double] { +pub fn stat_confidence_interval( + data : Array[Double], + confidence? : Double = 0.95, +) -> Array[Double] { let n = data.length() if n < 2 { return [stat_mean(data), stat_mean(data)] } let mean = stat_mean(data) let std = stat_std(data) - + let z = if confidence == 0.99 { 2.576 } else if confidence == 0.90 { @@ -325,15 +346,22 @@ pub fn stat_confidence_interval(data : Array[Double], confidence? : Double = 0.9 } else { 1.96 } - - let margin = z * std / (n.to_double()).sqrt() + + let margin = z * std / n.to_double().sqrt() [mean - margin, mean + margin] } ///| /// Calculate the chi-square statistic. -pub fn stat_chi_square(observed : Array[Double], expected : Array[Double]) -> Double { - let n = if observed.length() < expected.length() { observed.length() } else { expected.length() } +pub fn stat_chi_square( + observed : Array[Double], + expected : Array[Double], +) -> Double { + let n = if observed.length() < expected.length() { + observed.length() + } else { + expected.length() + } let mut chi2 = 0.0 let mut i = 0 while i < n { @@ -348,8 +376,14 @@ pub fn stat_chi_square(observed : Array[Double], expected : Array[Double]) -> Do ///| /// Expected frequencies for chi-square test (uniform distribution). -pub fn stat_uniform_expected(n_categories : Int, total : Double) -> Array[Double] { - let expected : Array[Double] = Array::make(n_categories, total / n_categories.to_double()) +pub fn stat_uniform_expected( + n_categories : Int, + total : Double, +) -> Array[Double] { + let expected : Array[Double] = Array::make( + n_categories, + total / n_categories.to_double(), + ) expected } @@ -388,8 +422,12 @@ pub fn stat_unique_values(data : Array[Double]) -> Array[Double] { ///| /// Calculate the natural log (ln) of a number. fn stat_ln(x : Double) -> Double { - if x <= 0.0 { return 0.0 } - if x == 1.0 { return 0.0 } + if x <= 0.0 { + return 0.0 + } + if x == 1.0 { + return 0.0 + } let y = (x - 1.0) / (x + 1.0) let y2 = y * y let mut sum = y @@ -437,7 +475,9 @@ pub fn stat_geometric_mean(data : Array[Double]) -> Double { ///| /// Sort an array of (score, index) pairs by score descending (quicksort). -pub fn stat_sort_indices_desc(data : Array[(Double, Int)]) -> Array[(Double, Int)] { +pub fn stat_sort_indices_desc( + data : Array[(Double, Int)], +) -> Array[(Double, Int)] { if data.length() <= 1 { return data.copy() } @@ -466,7 +506,9 @@ pub fn stat_sort_indices_desc(data : Array[(Double, Int)]) -> Array[(Double, Int ///| /// Sort an array of (score, index) pairs by score ascending (quicksort). -pub fn stat_sort_indices_asc(data : Array[(Double, Int)]) -> Array[(Double, Int)] { +pub fn stat_sort_indices_asc( + data : Array[(Double, Int)], +) -> Array[(Double, Int)] { if data.length() <= 1 { return data.copy() } @@ -543,7 +585,10 @@ pub fn stat_standardize(data : Array[Double]) -> Array[Double] { ///| /// Wilcoxon signed-rank test for paired samples. /// Returns (statistic, p_value). -pub fn stat_wilcoxon_signed_rank(x : Array[Double], y : Array[Double]) -> (Double, Double) { +pub fn stat_wilcoxon_signed_rank( + x : Array[Double], + y : Array[Double], +) -> (Double, Double) { let n = if x.length() < y.length() { x.length() } else { y.length() } if n < 6 { return (0.0, 1.0) @@ -597,7 +642,7 @@ pub fn stat_wilcoxon_signed_rank(x : Array[Double], y : Array[Double]) -> (Doubl // Two-tailed p-value let p = 2.0 * stat_pvalue_zscore(z) - let stat = if w_plus > (n_dbl * (n_dbl + 1.0) / 4.0) { + let stat = if w_plus > n_dbl * (n_dbl + 1.0) / 4.0 { w_plus } else { n_dbl * (n_dbl + 1.0) / 2.0 - w_plus @@ -608,7 +653,10 @@ pub fn stat_wilcoxon_signed_rank(x : Array[Double], y : Array[Double]) -> (Doubl ///| /// Mann-Whitney U test (Wilcoxon rank-sum test) for two independent samples. /// Returns (statistic, p_value). -pub fn stat_mann_whitney(x : Array[Double], y : Array[Double]) -> (Double, Double) { +pub fn stat_mann_whitney( + x : Array[Double], + y : Array[Double], +) -> (Double, Double) { let n1 = x.length() let n2 = y.length() if n1 < 3 || n2 < 3 { @@ -635,7 +683,7 @@ pub fn stat_mann_whitney(x : Array[Double], y : Array[Double]) -> (Double, Doubl // U statistic let u1 = r1 - n1.to_double() * (n1.to_double() + 1.0) / 2.0 - let u2 = (n1.to_double() * n2.to_double()) - u1 + let u2 = n1.to_double() * n2.to_double() - u1 let u = if u1 < u2 { u1 } else { u2 } // Normal approximation with tie correction @@ -644,11 +692,7 @@ pub fn stat_mann_whitney(x : Array[Double], y : Array[Double]) -> (Double, Doubl let mean_u = n1_d * n2_d / 2.0 let var_u = n1_d * n2_d * (n1_d + n2_d + 1.0) / 12.0 - let z = if var_u > 0.0 { - (u - mean_u) / var_u.sqrt() - } else { - 0.0 - } + let z = if var_u > 0.0 { (u - mean_u) / var_u.sqrt() } else { 0.0 } let p = 2.0 * stat_pvalue_zscore(z) (u, if p.is_nan() || p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p }) @@ -659,10 +703,26 @@ pub fn stat_mann_whitney(x : Array[Double], y : Array[Double]) -> (Double, Doubl /// Table format: [[a, b], [c, d]] /// Returns (odds_ratio, p_value). pub fn stat_fisher_exact(table : Array[Array[Int]]) -> (Double, Double) { - let a = if table.length() > 0 && table[0].length() > 0 { table[0][0] } else { 0 } - let b = if table.length() > 0 && table[0].length() > 1 { table[0][1] } else { 0 } - let c = if table.length() > 1 && table[1].length() > 0 { table[1][0] } else { 0 } - let d = if table.length() > 1 && table[1].length() > 1 { table[1][1] } else { 0 } + let a = if table.length() > 0 && table[0].length() > 0 { + table[0][0] + } else { + 0 + } + let b = if table.length() > 0 && table[0].length() > 1 { + table[0][1] + } else { + 0 + } + let c = if table.length() > 1 && table[1].length() > 0 { + table[1][0] + } else { + 0 + } + let d = if table.length() > 1 && table[1].length() > 1 { + table[1][1] + } else { + 0 + } let n = (a + b + c + d).to_double() if n <= 0.0 { @@ -671,9 +731,13 @@ pub fn stat_fisher_exact(table : Array[Array[Int]]) -> (Double, Double) { // Odds ratio let or = if c.to_double() * b.to_double() == 0.0 { - if a.to_double() * d.to_double() == 0.0 { 1.0 } else { 1.0e15 } + if a.to_double() * d.to_double() == 0.0 { + 1.0 + } else { + 1.0e15 + } } else { - (a.to_double() * d.to_double()) / (b.to_double() * c.to_double()) + a.to_double() * d.to_double() / (b.to_double() * c.to_double()) } // Hypergeometric probability @@ -700,7 +764,11 @@ fn stat_fisher_exact_pvalue(a : Int, b : Int, c : Int, d : Int) -> Double { let col2_total = b + d let mut p_value = 0.0 - let min_a = if (row1_total - col2_total) > 0 { row1_total - col2_total } else { 0 } + let min_a = if row1_total - col2_total > 0 { + row1_total - col2_total + } else { + 0 + } let max_a = if row1_total < col1_total { row1_total } else { col1_total } let mut a_curr = min_a @@ -717,14 +785,22 @@ fn stat_fisher_exact_pvalue(a : Int, b : Int, c : Int, d : Int) -> Double { a_curr = a_curr + 1 } - if p_value > 1.0 { 1.0 } else if p_value < 0.0 { 0.0 } else { p_value } + if p_value > 1.0 { + 1.0 + } else if p_value < 0.0 { + 0.0 + } else { + p_value + } } ///| /// Multivariate hypergeometric PMF for a 2x2 table. fn stat_mult_hypergeom_pmf(a : Int, b : Int, c : Int, d : Int) -> Double { let n = (a + b + c + d).to_double() - if n <= 0.0 { return 0.0 } + if n <= 0.0 { + return 0.0 + } let a_d = a.to_double() let b_d = b.to_double() @@ -737,20 +813,30 @@ fn stat_mult_hypergeom_pmf(a : Int, b : Int, c : Int, d : Int) -> Double { let col2 = b_d + d_d // log probability using gamma functions - let ln_p = stat_ln_factorial(row1) + stat_ln_factorial(row2) + - stat_ln_factorial(col1) + stat_ln_factorial(col2) - + let ln_p = stat_ln_factorial(row1) + + stat_ln_factorial(row2) + + stat_ln_factorial(col1) + + stat_ln_factorial(col2) - stat_ln_factorial(n) - - stat_ln_factorial(a_d) - stat_ln_factorial(b_d) - - stat_ln_factorial(c_d) - stat_ln_factorial(d_d) + stat_ln_factorial(a_d) - + stat_ln_factorial(b_d) - + stat_ln_factorial(c_d) - + stat_ln_factorial(d_d) let p = @math.exp(ln_p) - if p.is_nan() || p < 0.0 { 0.0 } else { p } + if p.is_nan() || p < 0.0 { + 0.0 + } else { + p + } } ///| /// Natural log of factorial (uses Stirling's approximation for large values). fn stat_ln_factorial(x : Double) -> Double { - if x <= 0.0 { return 0.0 } + if x <= 0.0 { + return 0.0 + } if x < 20.0 { // Direct computation for small values let mut result = 0.0 @@ -772,7 +858,10 @@ fn stat_ln_factorial(x : Double) -> Double { ///| /// Kolmogorov-Smirnov test for comparing two samples. /// Returns (statistic, p_value). -pub fn stat_ks_test(sample1 : Array[Double], sample2 : Array[Double]) -> (Double, Double) { +pub fn stat_ks_test( + sample1 : Array[Double], + sample2 : Array[Double], +) -> (Double, Double) { let n1 = sample1.length() let n2 = sample2.length() if n1 < 2 || n2 < 2 { @@ -781,8 +870,12 @@ pub fn stat_ks_test(sample1 : Array[Double], sample2 : Array[Double]) -> (Double // Combine all values and compute ECDF let combined : Array[Double] = Array::new() - for v in sample1 { combined.push(v) } - for v in sample2 { combined.push(v) } + for v in sample1 { + combined.push(v) + } + for v in sample2 { + combined.push(v) + } let sorted = stat_sort_double(combined) let n = sorted.length() @@ -794,14 +887,18 @@ pub fn stat_ks_test(sample1 : Array[Double], sample2 : Array[Double]) -> (Double // ECDF for sample1 at x let mut ecdf1 = 0.0 for v in sample1 { - if v <= x { ecdf1 = ecdf1 + 1.0 } + if v <= x { + ecdf1 = ecdf1 + 1.0 + } } ecdf1 = ecdf1 / n1.to_double() // ECDF for sample2 at x let mut ecdf2 = 0.0 for v in sample2 { - if v <= x { ecdf2 = ecdf2 + 1.0 } + if v <= x { + ecdf2 = ecdf2 + 1.0 + } } ecdf2 = ecdf2 / n2.to_double() @@ -813,33 +910,47 @@ pub fn stat_ks_test(sample1 : Array[Double], sample2 : Array[Double]) -> (Double } // Approximate p-value using Kolmogorov approximation - let n_eff = (n1.to_double() * n2.to_double()) / (n1.to_double() + n2.to_double()) + let n_eff = n1.to_double() * + n2.to_double() / + (n1.to_double() + n2.to_double()) let sqrt_n_eff = n_eff.sqrt() let lambda = (sqrt_n_eff + 0.12 + 0.11 / sqrt_n_eff) * max_diff // Kolmogorov distribution approximation - let p = if lambda <= 0.0 { - 1.0 - } else { - 2.0 * stat_kolmogorov_cdf(lambda) - } - - (max_diff, if p.is_nan() || p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p }) + let p = if lambda <= 0.0 { 1.0 } else { 2.0 * stat_kolmogorov_cdf(lambda) } + + ( + max_diff, + if p.is_nan() || p < 0.0 { + 0.0 + } else if p > 1.0 { + 1.0 + } else { + p + }, + ) } ///| /// Kolmogorov distribution CDF (approximation). fn stat_kolmogorov_cdf(lambda : Double) -> Double { - if lambda <= 0.0 { return 0.0 } - if lambda >= 10.0 { return 1.0 } + if lambda <= 0.0 { + return 0.0 + } + if lambda >= 10.0 { + return 1.0 + } let mut sum = 0.0 let mut k = 1 while k <= 100 { let k_dbl = k.to_double() - let term = (-1.0).pow(k_dbl - 1.0) * @math.exp(-2.0 * k_dbl * k_dbl * lambda * lambda) + let term = (-1.0).pow(k_dbl - 1.0) * + @math.exp(-2.0 * k_dbl * k_dbl * lambda * lambda) sum = sum + term - if term.abs() < 1.0e-15 { break } + if term.abs() < 1.0e-15 { + break + } k = k + 1 } 2.0 * sum @@ -853,7 +964,15 @@ pub fn stat_bonferroni(p_values : Array[Double]) -> Array[Double] { let mut i = 0 while i < n { let corrected = p_values[i] * n.to_double() - result.push(if corrected > 1.0 { 1.0 } else if corrected < 0.0 { 0.0 } else { corrected }) + result.push( + if corrected > 1.0 { + 1.0 + } else if corrected < 0.0 { + 0.0 + } else { + corrected + }, + ) i = i + 1 } result @@ -863,7 +982,9 @@ pub fn stat_bonferroni(p_values : Array[Double]) -> Array[Double] { /// Holm-Bonferroni step-down procedure for multiple testing. pub fn stat_holm(p_values : Array[Double]) -> Array[Double] { let n = p_values.length() - if n == 0 { return Array::new() } + if n == 0 { + return Array::new() + } // Create indexed pairs and sort by p-value let indexed : Array[(Double, Int)] = Array::new() @@ -898,7 +1019,9 @@ pub fn stat_holm(p_values : Array[Double]) -> Array[Double] { /// Benjamini-Yekutieli correction for multiple testing (conservative version). pub fn stat_by(p_values : Array[Double]) -> Array[Double] { let n = p_values.length() - if n == 0 { return Array::new() } + if n == 0 { + return Array::new() + } // Harmonic number for BY correction let mut h = 0.0 @@ -945,13 +1068,19 @@ pub fn stat_beta_pdf(x : Double, alpha : Double, beta : Double) -> Double { } // log(1/B(alpha,beta)) + (alpha-1)*log(x) + (beta-1)*log(1-x) - let ln_beta = stat_lngamma(alpha) + stat_lngamma(beta) - stat_lngamma(alpha + beta) + let ln_beta = stat_lngamma(alpha) + + stat_lngamma(beta) - + stat_lngamma(alpha + beta) let ln_x = @math.ln(x) let ln_1mx = @math.ln(1.0 - x) let ln_pdf = -ln_beta + (alpha - 1.0) * ln_x + (beta - 1.0) * ln_1mx let pdf = @math.exp(ln_pdf) - if pdf.is_nan() || pdf < 0.0 { 0.0 } else { pdf } + if pdf.is_nan() || pdf < 0.0 { + 0.0 + } else { + pdf + } } ///| @@ -962,10 +1091,17 @@ pub fn stat_gamma_pdf(x : Double, shape : Double, rate : Double) -> Double { } let ln_gamma = stat_lngamma(shape) - let ln_pdf = shape * @math.ln(rate) - ln_gamma + (shape - 1.0) * @math.ln(x) - rate * x + let ln_pdf = shape * @math.ln(rate) - + ln_gamma + + (shape - 1.0) * @math.ln(x) - + rate * x let pdf = @math.exp(ln_pdf) - if pdf.is_nan() || pdf < 0.0 { 0.0 } else { pdf } + if pdf.is_nan() || pdf < 0.0 { + 0.0 + } else { + pdf + } } ///| @@ -1010,7 +1146,9 @@ pub fn stat_bartlett_test(samples : Array[Array[Double]]) -> (Double, Double) { let mut i = 0 while i < k { let n = samples[i].length() - if n < 2 { return (0.0, 1.0) } + if n < 2 { + return (0.0, 1.0) + } let var = stat_variance(samples[i]) variances.push(var) sizes.push(n) @@ -1052,12 +1190,17 @@ pub fn stat_bartlett_test(samples : Array[Array[Double]]) -> (Double, Double) { ///| /// Chi-square survival function (p-value from chi-square distribution). fn stat_chi2_sf(x : Double, df : Int) -> Double { - if x <= 0.0 { return 1.0 } - if df <= 0 { return 1.0 } + if x <= 0.0 { + return 1.0 + } + if df <= 0 { + return 1.0 + } // Wilson-Hilferty approximation let df_d = df.to_double() - let z = ((x / df_d).pow(1.0 / 3.0) - (1.0 - 2.0 / (9.0 * df_d))) / ((2.0 / (9.0 * df_d)).sqrt()) + let z = ((x / df_d).pow(1.0 / 3.0) - (1.0 - 2.0 / (9.0 * df_d))) / + (2.0 / (9.0 * df_d)).sqrt() stat_pvalue_zscore(z) } @@ -1079,7 +1222,9 @@ pub fn stat_levene_test(samples : Array[Array[Double]]) -> (Double, Double) { let mut i = 0 while i < k { let n = samples[i].length() - if n < 2 { return (0.0, 1.0) } + if n < 2 { + return (0.0, 1.0) + } let med = stat_median(samples[i]) medians.push(med) sizes.push(n) @@ -1131,7 +1276,9 @@ pub fn stat_levene_test(samples : Array[Array[Double]]) -> (Double, Double) { } let levene_stat = if denominator > 0.0 { - (numerator / (k.to_double() - 1.0)) / (denominator / (total_n.to_double() - k.to_double())) + numerator / + (k.to_double() - 1.0) / + (denominator / (total_n.to_double() - k.to_double())) } else { 0.0 } @@ -1140,29 +1287,54 @@ pub fn stat_levene_test(samples : Array[Array[Double]]) -> (Double, Double) { let df1 = k - 1 let df2 = total_n - k let p = stat_f_sf(levene_stat, df1, df2) - (levene_stat, if p.is_nan() || p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p }) + ( + levene_stat, + if p.is_nan() || p < 0.0 { + 0.0 + } else if p > 1.0 { + 1.0 + } else { + p + }, + ) } ///| /// F-distribution survival function (p-value from F distribution). fn stat_f_sf(f : Double, df1 : Int, df2 : Int) -> Double { - if f <= 0.0 { return 1.0 } - if df1 <= 0 || df2 <= 0 { return 1.0 } + if f <= 0.0 { + return 1.0 + } + if df1 <= 0 || df2 <= 0 { + return 1.0 + } // Use incomplete beta function relationship let x = df1.to_double() * f / (df1.to_double() * f + df2.to_double()) - if x >= 1.0 { return 0.0 } + if x >= 1.0 { + return 0.0 + } let a = df1.to_double() / 2.0 let b = df2.to_double() / 2.0 let p = stat_beta_inc(x, a, b) - if p.is_nan() || p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p } + if p.is_nan() || p < 0.0 { + 0.0 + } else if p > 1.0 { + 1.0 + } else { + p + } } ///| /// Regularized incomplete beta function I_x(a, b). fn stat_beta_inc(x : Double, a : Double, b : Double) -> Double { - if x <= 0.0 { return 0.0 } - if x >= 1.0 { return 1.0 } + if x <= 0.0 { + return 0.0 + } + if x >= 1.0 { + return 1.0 + } // Use continued fraction expansion let lbeta = stat_lngamma(a) + stat_lngamma(b) - stat_lngamma(a + b) @@ -1185,22 +1357,34 @@ fn stat_beta_inc(x : Double, a : Double, b : Double) -> Double { numerator = 1.0 } else if i % 2 == 0 { // Even step - numerator = m_d * (b - m_d) * x / ((a + 2.0 * m_d - 1.0) * (a + 2.0 * m_d)) + numerator = m_d * + (b - m_d) * + x / + ((a + 2.0 * m_d - 1.0) * (a + 2.0 * m_d)) } else { // Odd step - numerator = -(a + m_d) * (a + b + m_d) * x / ((a + 2.0 * m_d) * (a + 2.0 * m_d + 1.0)) + numerator = -(a + m_d) * + (a + b + m_d) * + x / + ((a + 2.0 * m_d) * (a + 2.0 * m_d + 1.0)) } d = 1.0 + numerator * d - if d.abs() < eps { d = eps } + if d.abs() < eps { + d = eps + } d = 1.0 / d c = 1.0 + numerator / c - if c.abs() < eps { c = eps } + if c.abs() < eps { + c = eps + } let delta = c * d f = f * delta - if (delta - 1.0).abs() < eps { break } + if (delta - 1.0).abs() < eps { + break + } i = i + 1 } @@ -1211,22 +1395,39 @@ fn stat_beta_inc(x : Double, a : Double, b : Double) -> Double { ///| /// Chi-square distribution CDF. pub fn stat_chi2_cdf(x : Double, df : Int) -> Double { - if x <= 0.0 { return 0.0 } - if df <= 0 { return 0.0 } + if x <= 0.0 { + return 0.0 + } + if df <= 0 { + return 0.0 + } let df_d = df.to_double() // Wilson-Hilferty approximation - let z = ((x / df_d).pow(1.0 / 3.0) - (1.0 - 2.0 / (9.0 * df_d))) / ((2.0 / (9.0 * df_d)).sqrt()) + let z = ((x / df_d).pow(1.0 / 3.0) - (1.0 - 2.0 / (9.0 * df_d))) / + (2.0 / (9.0 * df_d)).sqrt() let p = stat_normal_cdf(z) - if p.is_nan() || p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p } + if p.is_nan() || p < 0.0 { + 0.0 + } else if p > 1.0 { + 1.0 + } else { + p + } } ///| /// Chi-square distribution quantile (inverse CDF). pub fn stat_chi2_quantile(p : Double, df : Int) -> Double { - if p <= 0.0 { return 0.0 } - if p >= 1.0 { return 1.0e300 } - if df <= 0 { return 0.0 } + if p <= 0.0 { + return 0.0 + } + if p >= 1.0 { + return 1.0e300 + } + if df <= 0 { + return 0.0 + } // Newton's method on stat_chi2_cdf(x, df) = p let df_d = df.to_double() @@ -1235,33 +1436,56 @@ pub fn stat_chi2_quantile(p : Double, df : Int) -> Double { while i < 100 { let cdf_val = stat_chi2_cdf(x, df) let diff = cdf_val - p - if diff.abs() < 1.0e-12 { break } + if diff.abs() < 1.0e-12 { + break + } // Numerical derivative let h = 1.0e-7 - let deriv = (stat_chi2_cdf(x + h, df) - stat_chi2_cdf(x - h, df)) / (2.0 * h) - if deriv.abs() < 1.0e-30 { break } + let deriv = (stat_chi2_cdf(x + h, df) - stat_chi2_cdf(x - h, df)) / + (2.0 * h) + if deriv.abs() < 1.0e-30 { + break + } x = x - diff / deriv - if x < 0.0 { x = 1.0e-15 } + if x < 0.0 { + x = 1.0e-15 + } i = i + 1 } - if x < 0.0 { 0.0 } else { x } + if x < 0.0 { + 0.0 + } else { + x + } } ///| /// Student's t-distribution CDF. pub fn stat_t_cdf(t : Double, df : Double) -> Double { - if df <= 0.0 { return 0.5 } + if df <= 0.0 { + return 0.5 + } let x = df / (df + t * t) let p = 0.5 * stat_beta_inc(x, df / 2.0, 0.5) - if t >= 0.0 { 1.0 - p } else { p } + if t >= 0.0 { + 1.0 - p + } else { + p + } } ///| /// Student's t-distribution quantile (inverse CDF). pub fn stat_t_quantile(p : Double, df : Double) -> Double { - if p <= 0.0 { return -1.0e300 } - if p >= 1.0 { return 1.0e300 } - if (p - 0.5).abs() < 1.0e-15 { return 0.0 } + if p <= 0.0 { + return -1.0e300 + } + if p >= 1.0 { + return 1.0e300 + } + if (p - 0.5).abs() < 1.0e-15 { + return 0.0 + } // Newton's method on stat_t_cdf(t, df) = p let mut t = if p < 0.5 { -1.0 } else { 1.0 } @@ -1269,11 +1493,15 @@ pub fn stat_t_quantile(p : Double, df : Double) -> Double { while i < 100 { let cdf_val = stat_t_cdf(t, df) let diff = cdf_val - p - if diff.abs() < 1.0e-12 { break } + if diff.abs() < 1.0e-12 { + break + } // Numerical derivative let h = 1.0e-7 let deriv = (stat_t_cdf(t + h, df) - stat_t_cdf(t - h, df)) / (2.0 * h) - if deriv.abs() < 1.0e-30 { break } + if deriv.abs() < 1.0e-30 { + break + } t = t - diff / deriv i = i + 1 } @@ -1283,7 +1511,10 @@ pub fn stat_t_quantile(p : Double, df : Double) -> Double { ///| /// One-sample t-test. /// Returns (statistic, p_value). -pub fn stat_t_test_one_sample(sample : Array[Double], mu_0 : Double) -> (Double, Double) { +pub fn stat_t_test_one_sample( + sample : Array[Double], + mu_0 : Double, +) -> (Double, Double) { let n = sample.length() if n < 3 { return (0.0, 1.0) @@ -1293,7 +1524,7 @@ pub fn stat_t_test_one_sample(sample : Array[Double], mu_0 : Double) -> (Double, if std <= 0.0 { return (0.0, 1.0) } - let t = (mean - mu_0) / (std / (n.to_double()).sqrt()) + let t = (mean - mu_0) / (std / n.to_double().sqrt()) let df = (n - 1).to_double() let p = 2.0 * (1.0 - stat_t_cdf(t.abs(), df)) (t, if p.is_nan() || p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p }) @@ -1302,7 +1533,10 @@ pub fn stat_t_test_one_sample(sample : Array[Double], mu_0 : Double) -> (Double, ///| /// Two-sample t-test (equal variances). /// Returns (statistic, p_value). -pub fn stat_t_test_two_sample(x : Array[Double], y : Array[Double]) -> (Double, Double) { +pub fn stat_t_test_two_sample( + x : Array[Double], + y : Array[Double], +) -> (Double, Double) { let n1 = x.length() let n2 = y.length() if n1 < 3 || n2 < 3 { @@ -1315,7 +1549,7 @@ pub fn stat_t_test_two_sample(x : Array[Double], y : Array[Double]) -> (Double, // Pooled variance (equal variances assumption) let pooled_var = ((n1 - 1).to_double() * var1 + (n2 - 1).to_double() * var2) / - ((n1 + n2 - 2).to_double()) + (n1 + n2 - 2).to_double() if pooled_var <= 0.0 { return (0.0, 1.0) } @@ -1333,7 +1567,9 @@ pub fn stat_t_test_two_sample(x : Array[Double], y : Array[Double]) -> (Double, /// Benjamini-Hochberg (BH) step-up procedure for multiple testing. pub fn stat_bh(p_values : Array[Double]) -> Array[Double] { let n = p_values.length() - if n == 0 { return Array::new() } + if n == 0 { + return Array::new() + } let indexed : Array[(Double, Int)] = Array::new() let mut i = 0 @@ -1363,7 +1599,9 @@ pub fn stat_bh(p_values : Array[Double]) -> Array[Double] { i = 0 while i < n { - if adjusted[i] > 1.0 { adjusted[i] = 1.0 } + if adjusted[i] > 1.0 { + adjusted[i] = 1.0 + } i = i + 1 } @@ -1373,42 +1611,58 @@ pub fn stat_bh(p_values : Array[Double]) -> Array[Double] { ///| /// Normal distribution quantile (inverse CDF) using rational approximation. pub fn stat_normal_quantile(p : Double) -> Double { - if p <= 0.0 { return -1.0e300 } - if p >= 1.0 { return 1.0e300 } + if p <= 0.0 { + return -1.0e300 + } + if p >= 1.0 { + return 1.0e300 + } // Peter Acklam's rational approximation - let a = [-3.969683028665376e+01, 2.209460984245205e+02, -2.759285104469687e+02, - 1.383577518672690e+02, -3.066479806614716e+01, 2.506628277459239e+00] - let b = [-5.447609879822406e+01, 1.615858368580409e+02, -1.556989798598866e+02, - 6.680131188771972e+01, -1.328068155288572e+01] - let c = [-7.784894002430293e-03, -3.223964580411365e-01, -2.400758277161838e+00, - -2.549732539343734e+00, 4.374664141464968e+00, 2.938163982698783e+00] - let d = [7.784695709041462e-03, 3.224671290700398e-01, 2.445134137142996e+00, - 3.754408661907416e+00] + let a = [ + -3.969683028665376e+01, 2.209460984245205e+02, -2.759285104469687e+02, 1.383577518672690e+02, + -3.066479806614716e+01, 2.506628277459239e+00, + ] + let b = [ + -5.447609879822406e+01, 1.615858368580409e+02, -1.556989798598866e+02, 6.680131188771972e+01, + -1.328068155288572e+01, + ] + let c = [ + -7.784894002430293e-03, -3.223964580411365e-01, -2.400758277161838e+00, -2.549732539343734e+00, + 4.374664141464968e+00, 2.938163982698783e+00, + ] + let d = [ + 7.784695709041462e-03, 3.224671290700398e-01, 2.445134137142996e+00, 3.754408661907416e+00, + ] let plow = 0.02425 let phigh = 1.0 - plow if p < plow { let q = (-2.0 * @math.ln(p)).sqrt() - c[0] * (q + c[1] * (q + c[2] * (q + c[3] * (q + c[4] * q + c[5])))) / - (1.0 + d[0] * (q + d[1] * (q + d[2] * (q + d[3] * q)))) + c[0] * + (q + c[1] * (q + c[2] * (q + c[3] * (q + c[4] * q + c[5])))) / + (1.0 + d[0] * (q + d[1] * (q + d[2] * (q + d[3] * q)))) } else if p <= phigh { let q = p - 0.5 let r = q * q - (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q / - (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1.0) + (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * + q / + (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1.0) } else { let q = (-2.0 * @math.ln(1.0 - p)).sqrt() - -c[0] * (q + c[1] * (q + c[2] * (q + c[3] * (q + c[4] * q + c[5])))) / - (1.0 + d[0] * (q + d[1] * (q + d[2] * (q + d[3] * q)))) + -c[0] * + (q + c[1] * (q + c[2] * (q + c[3] * (q + c[4] * q + c[5])))) / + (1.0 + d[0] * (q + d[1] * (q + d[2] * (q + d[3] * q)))) } } ///| /// Compute the mean absolute deviation (MAD) from median. pub fn stat_mad(data : Array[Double], constant? : Double = 1.4826) -> Double { - if data.length() == 0 { return 0.0 } + if data.length() == 0 { + return 0.0 + } let med = stat_median(data) let devs : Array[Double] = Array::new() let mut i = 0 @@ -1462,7 +1716,11 @@ pub fn stat_logrank_test( let mut n2_total = 0 i = 0 while i < n { - if indexed[i].2 == 0 { n1_total = n1_total + 1 } else { n2_total = n2_total + 1 } + if indexed[i].2 == 0 { + n1_total = n1_total + 1 + } else { + n2_total = n2_total + 1 + } i = i + 1 } @@ -1496,11 +1754,7 @@ pub fn stat_logrank_test( i = i + 1 } - let z = if v > 0.0 { - (o1 - e1) / v.sqrt() - } else { - 0.0 - } + let z = if v > 0.0 { (o1 - e1) / v.sqrt() } else { 0.0 } let p = 2.0 * (1.0 - stat_normal_cdf(z.abs())) let chi2 = z * z @@ -1524,7 +1778,9 @@ pub fn stat_anova(samples : Array[Array[Double]]) -> (Double, Double) { let mut i = 0 while i < k { let n = samples[i].length() - if n < 2 { return (0.0, 1.0) } + if n < 2 { + return (0.0, 1.0) + } sizes.push(n) means.push(stat_mean(samples[i])) variances.push(stat_variance(samples[i])) @@ -1547,7 +1803,8 @@ pub fn stat_anova(samples : Array[Array[Double]]) -> (Double, Double) { let mut ss_between = 0.0 i = 0 while i < k { - ss_between = ss_between + sizes[i].to_double() * (means[i] - grand_mean).pow(2.0) + ss_between = ss_between + + sizes[i].to_double() * (means[i] - grand_mean).pow(2.0) i = i + 1 } diff --git a/src/stockholm.mbt b/src/stockholm.mbt index 31053d66..1eb11fb5 100644 --- a/src/stockholm.mbt +++ b/src/stockholm.mbt @@ -91,7 +91,13 @@ pub fn StockholmAlignment::new( gs_annotations : Map[String, String], markup : Array[String], ) -> StockholmAlignment { - StockholmAlignment::{ version, blocks, gf_annotations, gs_annotations, markup } + StockholmAlignment::{ + version, + blocks, + gf_annotations, + gs_annotations, + markup, + } } ///| @@ -166,7 +172,9 @@ pub fn stockholm_parse(content : String) -> StockholmAlignment { let mut value = "" let mut pi = 1 while pi < filtered.length() { - if pi > 1 { value = value + " " } + if pi > 1 { + value = value + " " + } value = value + filtered[pi] pi = pi + 1 } @@ -194,7 +202,9 @@ pub fn stockholm_parse(content : String) -> StockholmAlignment { let mut value = "" let mut pi = 1 while pi < gc_filtered.length() { - if pi > 1 { value = value + " " } + if pi > 1 { + value = value + " " + } value = value + gc_filtered[pi] pi = pi + 1 } @@ -218,7 +228,9 @@ pub fn stockholm_parse(content : String) -> StockholmAlignment { let mut value = "" let mut pi = 1 while pi < gr_filtered.length() { - if pi > 1 { value = value + " " } + if pi > 1 { + value = value + " " + } value = value + gr_filtered[pi] pi = pi + 1 } @@ -242,7 +254,9 @@ pub fn stockholm_parse(content : String) -> StockholmAlignment { let mut value = "" let mut pi = 1 while pi < gs_filtered.length() { - if pi > 1 { value = value + " " } + if pi > 1 { + value = value + " " + } value = value + gs_filtered[pi] pi = pi + 1 } @@ -276,9 +290,7 @@ pub fn stockholm_parse(content : String) -> StockholmAlignment { current_seqs.push(s) has_block_content = true } - None => { - markup.push(trimmed) - } + None => markup.push(trimmed) } i = i + 1 } @@ -419,10 +431,14 @@ pub fn stockholm_write(ali : StockholmAlignment) -> String { pub fn stockholm_percent_identity(block : StockholmBlock) -> Double { let seqs = block.sequences let n = seqs.length() - if n < 2 { return 0.0 } + if n < 2 { + return 0.0 + } let len = seqs[0].aligned_seq.length() - if len == 0 { return 0.0 } + if len == 0 { + return 0.0 + } let mut total_identity = 0.0 let mut total_comparisons = 0.0 @@ -448,7 +464,8 @@ pub fn stockholm_percent_identity(block : StockholmBlock) -> Double { k = k + 1 } if comparable > 0 { - total_identity = total_identity + matches.to_double() / comparable.to_double() + total_identity = total_identity + + matches.to_double() / comparable.to_double() total_comparisons = total_comparisons + 1.0 } j = j + 1 @@ -471,10 +488,14 @@ pub fn stockholm_conservation(block : StockholmBlock) -> Array[Double] { let result : Array[Double] = Array::new() let seqs = block.sequences let n = seqs.length() - if n == 0 { return result } + if n == 0 { + return result + } let len = seqs[0].aligned_seq.length() - if len == 0 { return result } + if len == 0 { + return result + } let mut col = 0 while col < len { @@ -572,9 +593,7 @@ pub fn stockholm_merge_blocks(ali : StockholmAlignment) -> StockholmAlignment { while si < block.sequences.length() { let seq = block.sequences[si] match seq_map.get(seq.name) { - Some(sb) => { - sb.write_string(seq.aligned_seq) - } + Some(sb) => sb.write_string(seq.aligned_seq) None => { let sb = StringBuilder::new() sb.write_string(seq.aligned_seq) @@ -677,6 +696,7 @@ pub fn stockholm_merge_blocks(ali : StockholmAlignment) -> StockholmAlignment { // --- Internal helper functions --- +///| fn stockholm_filter_parts(parts : Array[String]) -> Array[String] { let result : Array[String] = Array::new() let mut i = 0 @@ -689,8 +709,11 @@ fn stockholm_filter_parts(parts : Array[String]) -> Array[String] { result } +///| fn stockholm_parse_sequence_line(line : String) -> StockholmSequence? { - if line.length() == 0 { return None } + if line.length() == 0 { + return None + } let sp = ' '.to_int().to_uint16() let mut space_pos = -1 @@ -703,7 +726,9 @@ fn stockholm_parse_sequence_line(line : String) -> StockholmSequence? { i = i + 1 } - if space_pos <= 0 { return None } + if space_pos <= 0 { + return None + } let name_part = line[0:space_pos].to_owned() let seq_part_start = space_pos + 1 @@ -713,7 +738,9 @@ fn stockholm_parse_sequence_line(line : String) -> StockholmSequence? { "" } - if seq_part.length() == 0 { return None } + if seq_part.length() == 0 { + return None + } let slash_pos = stockholm_find_slash(name_part) let (name, start, end) = if slash_pos >= 0 { @@ -721,7 +748,11 @@ fn stockholm_parse_sequence_line(line : String) -> StockholmSequence? { let range = name_part[slash_pos + 1:].to_owned() let dash_pos = stockholm_find_dash(range) if dash_pos >= 0 { - (n, parse_int(range[0:dash_pos].to_owned()), parse_int(range[dash_pos + 1:].to_owned())) + ( + n, + parse_int(range[0:dash_pos].to_owned()), + parse_int(range[dash_pos + 1:].to_owned()), + ) } else { (n, 1, parse_int(range)) } @@ -739,6 +770,7 @@ fn stockholm_parse_sequence_line(line : String) -> StockholmSequence? { }) } +///| fn stockholm_find_slash(s : String) -> Int { let mut i = 0 while i < s.length() { @@ -750,6 +782,7 @@ fn stockholm_find_slash(s : String) -> Int { -1 } +///| fn stockholm_find_dash(s : String) -> Int { let mut i = 0 while i < s.length() { @@ -761,6 +794,7 @@ fn stockholm_find_dash(s : String) -> Int { -1 } +///| fn stockholm_build_block( seqs : Array[StockholmSequence], gc : Map[String, String], @@ -782,6 +816,7 @@ fn stockholm_build_block( } } +///| fn stockholm_max_name_length(seqs : Array[StockholmSequence]) -> Int { let mut max_len = 0 let mut i = 0 @@ -795,6 +830,7 @@ fn stockholm_max_name_length(seqs : Array[StockholmSequence]) -> Int { max_len } +///| fn stockholm_display_name(seq : StockholmSequence) -> String { if seq.accession.length() > 0 { seq.accession @@ -824,4 +860,4 @@ pub fn sample_stockholm_content() -> String { /// Create a sample Stockholm alignment for testing. pub fn sample_stockholm_alignment() -> StockholmAlignment { stockholm_parse(sample_stockholm_content()) -} \ No newline at end of file +} diff --git a/src/structural_variant.mbt b/src/structural_variant.mbt index cad088c2..1b8916e4 100644 --- a/src/structural_variant.mbt +++ b/src/structural_variant.mbt @@ -118,9 +118,17 @@ pub fn SvBreakend::new( strand : String, mate_chrom : String, mate_pos : Int, - mate_strand : String + mate_strand : String, ) -> SvBreakend { - SvBreakend::{ chrom, pos, strand, mate_chrom, mate_pos, mate_strand, mate_id: "" } + SvBreakend::{ + chrom, + pos, + strand, + mate_chrom, + mate_pos, + mate_strand, + mate_id: "", + } } ///| @@ -202,9 +210,19 @@ pub fn SvRecord::new( svlen : Int, breakend : SvBreakend?, quality : Double, - filter : String + filter : String, ) -> SvRecord { - SvRecord::{ id, chrom, pos, sv_type, end: end_pos, svlen, breakend, quality, filter } + SvRecord::{ + id, + chrom, + pos, + sv_type, + end: end_pos, + svlen, + breakend, + quality, + filter, + } } ///| @@ -285,7 +303,7 @@ fn sv_trim(s : String) -> String { let n = s.length() let mut start = 0 while start < n { - let ch = s[start : start + 1] + let ch = s[start:start + 1] if ch == " " || ch == "\t" || ch == "\r" || ch == "\n" { start = start + 1 } else { @@ -294,7 +312,7 @@ fn sv_trim(s : String) -> String { } let mut end = n while end > start { - let ch = s[end - 1 : end] + let ch = s[end - 1:end] if ch == " " || ch == "\t" || ch == "\r" || ch == "\n" { end = end - 1 } else { @@ -310,7 +328,7 @@ fn sv_rfind(s : String, ch : String) -> Int? { let n = s.length() let mut i = n - 1 while i >= 0 { - if s[i : i + 1] == ch { + if s[i:i + 1] == ch { return Some(i) } i = i - 1 @@ -330,11 +348,7 @@ fn sv_rfind(s : String, ch : String) -> Int? { /// where `t` is the joining nucleotide and `p` is `chrom:pos`. /// /// Returns Some(SvBreakend) if parsing succeeds, None otherwise. -pub fn sv_parse_bnd_alt( - alt : String, - chrom : String, - pos : Int -) -> SvBreakend? { +pub fn sv_parse_bnd_alt(alt : String, chrom : String, pos : Int) -> SvBreakend? { let trimmed = sv_trim(alt) let n = trimmed.length() if n < 4 { @@ -345,7 +359,7 @@ pub fn sv_parse_bnd_alt( // Case 2: t]p] — starts with a base, then ], then chrom:pos, then ] // Case 3: ]p]t — starts with ], then chrom:pos, then ], then base // Case 4: [p[t — starts with [, then chrom:pos, then [, then base - let first = trimmed[0 : 1] + let first = trimmed[0:1] if first == "[" || first == "]" { // Case 3 or 4: ]p]t or [p[t let open_bracket = first @@ -353,7 +367,7 @@ pub fn sv_parse_bnd_alt( // open_bracket is at index 0; search for the next occurrence starting at 1. let mut close_idx = -1 for k in 1.. (String, Int) { let colon_pos = sv_rfind(loc, ":") match colon_pos { Some(idx) => { - let chrom = loc[0 : idx].to_owned() - let pos_str = loc[idx + 1 :] + let chrom = loc[0:idx].to_owned() + let pos_str = loc[idx + 1:] let pos = match parse_double(pos_str.to_owned()) { Some(v) => v.to_int() None => 0 @@ -443,8 +457,8 @@ fn sv_parse_info(info : String) -> Map[String, String] { let eq_pos = field.find("=") match eq_pos { Some(idx) => { - let key = field[0 : idx].to_owned() - let value = field[idx + 1 :].to_owned() + let key = field[0:idx].to_owned() + let value = field[idx + 1:].to_owned() result[key] = value } None => result[field.to_owned()] = "true" @@ -472,7 +486,7 @@ pub fn sv_parse_vcf_line(line : String) -> SvRecord? { return None } // Skip header lines. - if trimmed[0 : 1] == "#" { + if trimmed[0:1] == "#" { return None } let fields = trimmed.split("\t").to_array() @@ -523,7 +537,9 @@ pub fn sv_parse_vcf_line(line : String) -> SvRecord? { None } Some( - SvRecord::new(id, chrom, pos, sv_type, end_pos, svlen, breakend, quality, filter), + SvRecord::new( + id, chrom, pos, sv_type, end_pos, svlen, breakend, quality, filter, + ), ) } @@ -560,7 +576,7 @@ pub fn sv_find_partners(records : Array[SvRecord]) -> Array[(String, String)] { } let ri = records[i] match ri.breakend { - Some(bi) => { + Some(bi) => // Look for a record j whose chrom/pos matches bi's mate location. for j in (i + 1).. Array[(String, String)] { } let rj = records[j] match rj.breakend { - Some(bj) => { + Some(bj) => // Check if i's mate matches j's location and vice versa. if bi.mate_chrom == rj.chrom && bi.mate_pos == rj.pos && @@ -579,11 +595,9 @@ pub fn sv_find_partners(records : Array[SvRecord]) -> Array[(String, String)] { matched[j] = true break } - } None => continue } } - } None => continue } } @@ -625,7 +639,7 @@ pub fn SvGeneRegion::new( chrom : String, start : Int, end : Int, - strand : String + strand : String, ) -> SvGeneRegion { SvGeneRegion::{ gene, chrom, start, end, strand } } @@ -662,7 +676,7 @@ fn SvGeneRegion::overlaps( self : SvGeneRegion, qchrom : String, qstart : Int, - qend : Int + qend : Int, ) -> Bool { self.chrom == qchrom && self.start <= qend && self.end >= qstart } @@ -682,7 +696,7 @@ pub struct SvAnnotation { /// Construct an SvAnnotation. pub fn SvAnnotation::new( record : SvRecord, - genes : Array[String] + genes : Array[String], ) -> SvAnnotation { SvAnnotation::{ record, genes } } @@ -711,7 +725,7 @@ pub fn SvAnnotation::has_gene_overlap(self : SvAnnotation) -> Bool { /// are listed in the annotation. pub fn sv_annotate( records : Array[SvRecord], - genes : Array[SvGeneRegion] + genes : Array[SvGeneRegion], ) -> Array[SvAnnotation] { let annotations : Array[SvAnnotation] = Array::new() for rec in records { @@ -733,7 +747,7 @@ pub fn sv_annotate( } // Also check mate chromosome for BND records. match rec.breakend { - Some(b) => { + Some(b) => if b.mate_chrom.length() > 0 && b.mate_chrom != sv_chrom { for gene in genes { if gene.chrom == b.mate_chrom && @@ -744,7 +758,6 @@ pub fn sv_annotate( } } } - } None => () } annotations.push(SvAnnotation::new(rec, overlapping)) @@ -761,7 +774,7 @@ pub fn sv_annotate( /// quality >= min_qual. pub fn sv_filter_by_quality( records : Array[SvRecord], - min_qual : Double + min_qual : Double, ) -> Array[SvRecord] { let result : Array[SvRecord] = Array::new() for rec in records { @@ -777,7 +790,7 @@ pub fn sv_filter_by_quality( /// size >= min_size. BND/TRA records (size 0) are always excluded. pub fn sv_filter_by_size( records : Array[SvRecord], - min_size : Int + min_size : Int, ) -> Array[SvRecord] { let result : Array[SvRecord] = Array::new() for rec in records { @@ -792,7 +805,7 @@ pub fn sv_filter_by_size( /// Filter SV records by type. Returns records matching the given type. pub fn sv_filter_by_type( records : Array[SvRecord], - t : SvType + t : SvType, ) -> Array[SvRecord] { let result : Array[SvRecord] = Array::new() for rec in records { @@ -809,9 +822,7 @@ pub fn sv_filter_by_type( ///| /// Count SV records by type. Returns a map from type label to count. -pub fn sv_count_by_type( - records : Array[SvRecord] -) -> Map[String, Int] { +pub fn sv_count_by_type(records : Array[SvRecord]) -> Map[String, Int] { let counts : Map[String, Int] = Map([], capacity=6) for rec in records { let label = sv_type_label(rec.sv_type) @@ -898,22 +909,15 @@ pub fn sv_annotation_summary(ann : SvAnnotation) -> String { pub fn sv_sample_vcf() -> String { let sb = StringBuilder::new() let lines = [ - "##fileformat=VCFv4.2", - "##fileDate=20260101", - "##ALT=", - "##ALT=", - "##ALT=", - "##ALT=", - "##ALT=", + "##fileformat=VCFv4.2", "##fileDate=20260101", "##ALT=", + "##ALT=", "##ALT=", + "##ALT=", "##ALT=", "##INFO=", - "##INFO=", - "##INFO=", - "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO", - "chr1\t1000\tsv_del_1\tA\t\t500.0\tPASS\tSVTYPE=DEL;END=2000;SVLEN=-1000", + "##INFO=", "##INFO=", + "#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO", "chr1\t1000\tsv_del_1\tA\t\t500.0\tPASS\tSVTYPE=DEL;END=2000;SVLEN=-1000", "chr1\t3000\tsv_dup_1\tA\t\t450.0\tPASS\tSVTYPE=DUP;END=5000;SVLEN=2000", "chr2\t1500\tsv_inv_1\tA\t\t300.0\tPASS\tSVTYPE=INV;END=2500;SVLEN=1000", - "chr2\t4000\tsv_ins_1\tA\t\t200.0\tLOWQUAL\tSVTYPE=INS;SVLEN=500", - "chr1\t6000\tsv_bnd_1\tA\tA]chr2:7000]\t600.0\tPASS\tSVTYPE=BND", + "chr2\t4000\tsv_ins_1\tA\t\t200.0\tLOWQUAL\tSVTYPE=INS;SVLEN=500", "chr1\t6000\tsv_bnd_1\tA\tA]chr2:7000]\t600.0\tPASS\tSVTYPE=BND", "chr2\t7000\tsv_bnd_2\tA\tA]chr1:6000]\t600.0\tPASS\tSVTYPE=BND", ] for line in lines { diff --git a/src/structure_alignment.mbt b/src/structure_alignment.mbt index 707f5fab..b4aa9c88 100644 --- a/src/structure_alignment.mbt +++ b/src/structure_alignment.mbt @@ -38,7 +38,11 @@ pub struct SAResidue { ///| /// Create a new SAResidue. -pub fn SAResidue::new(resname : String, resseq : Int, ca_coord : SAPoint3D) -> SAResidue { +pub fn SAResidue::new( + resname : String, + resseq : Int, + ca_coord : SAPoint3D, +) -> SAResidue { SAResidue::{ resname, resseq, ca_coord } } @@ -51,7 +55,10 @@ pub struct SAStructure { ///| /// Create a new SAStructure. -pub fn SAStructure::new(id : String, residues : Array[SAResidue]) -> SAStructure { +pub fn SAStructure::new( + id : String, + residues : Array[SAResidue], +) -> SAStructure { SAStructure::{ id, residues } } @@ -72,21 +79,34 @@ pub fn SAAlignmentResult::new( aligned_residues : Array[Array[SAResidue?]], rmsd : Double, tm_score : Double, - aligned_length : Int + aligned_length : Int, ) -> SAAlignmentResult { - SAAlignmentResult::{ structure_ids, aligned_residues, rmsd, tm_score, aligned_length } + SAAlignmentResult::{ + structure_ids, + aligned_residues, + rmsd, + tm_score, + aligned_length, + } } ///| /// Calculate the RMSD between two aligned residue sets. -pub fn sa_calculate_rmsd(residues1 : Array[SAPoint3D], residues2 : Array[SAPoint3D]) -> Double { +pub fn sa_calculate_rmsd( + residues1 : Array[SAPoint3D], + residues2 : Array[SAPoint3D], +) -> Double { if residues1.length() == 0 || residues2.length() == 0 { return 0.0 } - - let len = if residues1.length() < residues2.length() { residues1.length() } else { residues2.length() } + + let len = if residues1.length() < residues2.length() { + residues1.length() + } else { + residues2.length() + } let mut sum_sq = 0.0 - + let mut i = 0 while i < len { let dx = residues1[i].x - residues2[i].x @@ -95,70 +115,88 @@ pub fn sa_calculate_rmsd(residues1 : Array[SAPoint3D], residues2 : Array[SAPoint sum_sq = sum_sq + dx * dx + dy * dy + dz * dz i = i + 1 } - + (sum_sq / len.to_double()).sqrt() } ///| /// Calculate the TM-score (Template Modeling score). -pub fn sa_calculate_tm_score(residues1 : Array[SAPoint3D], residues2 : Array[SAPoint3D], l_target : Int) -> Double { +pub fn sa_calculate_tm_score( + residues1 : Array[SAPoint3D], + residues2 : Array[SAPoint3D], + l_target : Int, +) -> Double { if residues1.length() == 0 || residues2.length() == 0 { return 0.0 } - - let len = if residues1.length() < residues2.length() { residues1.length() } else { residues2.length() } + + let len = if residues1.length() < residues2.length() { + residues1.length() + } else { + residues2.length() + } let d0 = if l_target >= 15 { 1.24 * @math.pow(l_target.to_double() - 15.0, 1.0 / 3.0) - 1.8 } else { 1.24 * @math.pow(15.0 - l_target.to_double(), 1.0 / 3.0) * 0.5 } - + let mut sum = 0.0 - + let mut i = 0 while i < len { let dist = residues1[i].distance(residues2[i]) - sum = sum + 1.0 / (1.0 + (dist / d0) * (dist / d0)) + sum = sum + 1.0 / (1.0 + dist / d0 * (dist / d0)) i = i + 1 } - + sum / len.to_double() } ///| /// Calculate the distance matrix between two structures. -pub fn sa_calculate_distance_matrix(struct1 : SAStructure, struct2 : SAStructure) -> Array[Array[Double]] { +pub fn sa_calculate_distance_matrix( + struct1 : SAStructure, + struct2 : SAStructure, +) -> Array[Array[Double]] { let len1 = struct1.residues.length() let len2 = struct2.residues.length() - + let matrix : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < len1 { let row : Array[Double] = Array::new() let mut j = 0 while j < len2 { - let dist = struct1.residues[i].ca_coord.distance(struct2.residues[j].ca_coord) + let dist = struct1.residues[i].ca_coord.distance( + struct2.residues[j].ca_coord, + ) row.push(dist) j = j + 1 } matrix.push(row) i = i + 1 } - + matrix } ///| /// Perform dynamic programming alignment between two structures. -pub fn sa_dp_alignment(struct1 : SAStructure, struct2 : SAStructure, gap_open? : Double = 5.0, gap_extend? : Double = 1.0) -> (Array[(Int, Int)], Double) { +pub fn sa_dp_alignment( + struct1 : SAStructure, + struct2 : SAStructure, + gap_open? : Double = 5.0, + gap_extend? : Double = 1.0, +) -> (Array[(Int, Int)], Double) { let dist_matrix = sa_calculate_distance_matrix(struct1, struct2) let len1 = struct1.residues.length() let len2 = struct2.residues.length() - + let score : Array[Array[Double]] = Array::new() let trace : Array[Array[Int]] = Array::new() - + let mut i = 0 while i <= len1 { let score_row : Array[Double] = Array::new() @@ -173,32 +211,32 @@ pub fn sa_dp_alignment(struct1 : SAStructure, struct2 : SAStructure, gap_open? : trace.push(trace_row) i = i + 1 } - + i = 1 while i <= len1 { - score[i].set(0, score[i-1][0] - gap_open) + score[i].set(0, score[i - 1][0] - gap_open) trace[i].set(0, 1) i = i + 1 } - + let mut j = 1 while j <= len2 { - score[0].set(j, score[0][j-1] - gap_open) + score[0].set(j, score[0][j - 1] - gap_open) trace[0].set(j, 2) j = j + 1 } - + i = 1 while i <= len1 { j = 1 while j <= len2 { - let gap_open1 = if trace[i-1][j] == 1 { gap_extend } else { gap_open } - let gap_open2 = if trace[i][j-1] == 2 { gap_extend } else { gap_open } - - let match_score = score[i-1][j-1] - dist_matrix[i-1][j-1] - let delete_score = score[i-1][j] - gap_open1 - let insert_score = score[i][j-1] - gap_open2 - + let gap_open1 = if trace[i - 1][j] == 1 { gap_extend } else { gap_open } + let gap_open2 = if trace[i][j - 1] == 2 { gap_extend } else { gap_open } + + let match_score = score[i - 1][j - 1] - dist_matrix[i - 1][j - 1] + let delete_score = score[i - 1][j] - gap_open1 + let insert_score = score[i][j - 1] - gap_open2 + if match_score >= delete_score && match_score >= insert_score { score[i].set(j, match_score) trace[i].set(j, 0) @@ -213,15 +251,15 @@ pub fn sa_dp_alignment(struct1 : SAStructure, struct2 : SAStructure, gap_open? : } i = i + 1 } - + let alignment : Array[(Int, Int)] = Array::new() i = len1 j = len2 - + while i > 0 && j > 0 { let t = trace[i][j] if t == 0 { - alignment.push((i-1, j-1)) + alignment.push((i - 1, j - 1)) i = i - 1 j = j - 1 } else if t == 1 { @@ -230,7 +268,7 @@ pub fn sa_dp_alignment(struct1 : SAStructure, struct2 : SAStructure, gap_open? : j = j - 1 } } - + let reversed : Array[(Int, Int)] = Array::new() let align_len = alignment.length() let mut k = 0 @@ -238,56 +276,65 @@ pub fn sa_dp_alignment(struct1 : SAStructure, struct2 : SAStructure, gap_open? : reversed.push(alignment[align_len - 1 - k]) k = k + 1 } - + (reversed, score[len1][len2]) } ///| /// Align two protein structures. -pub fn sa_align_two_structures(struct1 : SAStructure, struct2 : SAStructure) -> SAAlignmentResult { +pub fn sa_align_two_structures( + struct1 : SAStructure, + struct2 : SAStructure, +) -> SAAlignmentResult { let (alignment, _) = sa_dp_alignment(struct1, struct2) - + let coords1 : Array[SAPoint3D] = Array::new() let coords2 : Array[SAPoint3D] = Array::new() let aligned_residues : Array[Array[SAResidue?]] = Array::new() - + let align_len = alignment.length() let mut idx = 0 while idx < align_len { let pair = alignment[idx] let i = pair.0 let j = pair.1 - + coords1.push(struct1.residues[i].ca_coord) coords2.push(struct2.residues[j].ca_coord) - + let row : Array[SAResidue?] = Array::new() row.push(Some(struct1.residues[i])) row.push(Some(struct2.residues[j])) aligned_residues.push(row) - + idx = idx + 1 } - + let rmsd = sa_calculate_rmsd(coords1, coords2) - let tm_score = sa_calculate_tm_score(coords1, coords2, struct1.residues.length()) - + let tm_score = sa_calculate_tm_score( + coords1, + coords2, + struct1.residues.length(), + ) + SAAlignmentResult::new( [struct1.id, struct2.id], aligned_residues, rmsd, tm_score, - alignment.length() + alignment.length(), ) } ///| /// Perform multiple structure alignment using progressive approach. -pub fn sa_align_multiple_structures(structures : Array[SAStructure]) -> SAAlignmentResult { +pub fn sa_align_multiple_structures( + structures : Array[SAStructure], +) -> SAAlignmentResult { if structures.length() == 0 { return SAAlignmentResult::new([], [], 0.0, 0.0, 0) } - + if structures.length() == 1 { let aligned_residues : Array[Array[SAResidue?]] = Array::new() let mut i = 0 @@ -297,35 +344,50 @@ pub fn sa_align_multiple_structures(structures : Array[SAStructure]) -> SAAlignm aligned_residues.push(row) i = i + 1 } - return SAAlignmentResult::new([structures[0].id], aligned_residues, 0.0, 1.0, structures[0].residues.length()) + return SAAlignmentResult::new( + [structures[0].id], + aligned_residues, + 0.0, + 1.0, + structures[0].residues.length(), + ) } - - let mut current_alignment = sa_align_two_structures(structures[0], structures[1]) - + + let mut current_alignment = sa_align_two_structures( + structures[0], + structures[1], + ) + let mut k = 2 while k < structures.length() { - current_alignment = sa_align_structure_to_profile(current_alignment, structures[k]) + current_alignment = sa_align_structure_to_profile( + current_alignment, + structures[k], + ) k = k + 1 } - + current_alignment } ///| /// Align a structure to an existing alignment profile. -pub fn sa_align_structure_to_profile(alignment : SAAlignmentResult, structure : SAStructure) -> SAAlignmentResult { +pub fn sa_align_structure_to_profile( + alignment : SAAlignmentResult, + structure : SAStructure, +) -> SAAlignmentResult { let num_structures = alignment.structure_ids.length() let aligned_length = alignment.aligned_length - + let consensus_coords : Array[SAPoint3D] = Array::new() - + let mut i = 0 while i < aligned_length { let mut sum_x = 0.0 let mut sum_y = 0.0 let mut sum_z = 0.0 let mut count = 0 - + let mut j = 0 while j < num_structures { match alignment.aligned_residues[i][j] { @@ -335,45 +397,58 @@ pub fn sa_align_structure_to_profile(alignment : SAAlignmentResult, structure : sum_z = sum_z + res.ca_coord.z count = count + 1 } - None => ignore({ () }) + None => ignore(()) } j = j + 1 } - + if count > 0 { - consensus_coords.push(SAPoint3D::new(sum_x / count.to_double(), sum_y / count.to_double(), sum_z / count.to_double())) + consensus_coords.push( + SAPoint3D::new( + sum_x / count.to_double(), + sum_y / count.to_double(), + sum_z / count.to_double(), + ), + ) } i = i + 1 } - - let consensus_struct = SAStructure::new("consensus", sa_residues_from_coords(consensus_coords)) - + + let consensus_struct = SAStructure::new( + "consensus", + sa_residues_from_coords(consensus_coords), + ) + let (new_alignment, _) = sa_dp_alignment(consensus_struct, structure) - + let new_aligned_residues : Array[Array[SAResidue?]] = Array::new() - + let new_align_len = new_alignment.length() let mut idx = 0 while idx < new_align_len { let pair = new_alignment[idx] let i = pair.0 let j = pair.1 - + let row : Array[SAResidue?] = Array::new() - + let mut k = 0 while k < num_structures { - let val = if i < alignment.aligned_length { alignment.aligned_residues[i][k] } else { None } + let val = if i < alignment.aligned_length { + alignment.aligned_residues[i][k] + } else { + None + } row.push(val) k = k + 1 } - + row.push(Some(structure.residues[j])) new_aligned_residues.push(row) - + idx = idx + 1 } - + let new_ids : Array[String] = Array::new() let mut m = 0 while m < alignment.structure_ids.length() { @@ -381,51 +456,63 @@ pub fn sa_align_structure_to_profile(alignment : SAAlignmentResult, structure : m = m + 1 } new_ids.push(structure.id) - + let coords1 : Array[SAPoint3D] = Array::new() let coords2 : Array[SAPoint3D] = Array::new() - + idx = 0 while idx < new_align_len { let pair = new_alignment[idx] let i = pair.0 let j = pair.1 - + if i < consensus_coords.length() { coords1.push(consensus_coords[i]) } coords2.push(structure.residues[j].ca_coord) - + idx = idx + 1 } - + let rmsd = sa_calculate_rmsd(coords1, coords2) - let tm_score = sa_calculate_tm_score(coords1, coords2, consensus_struct.residues.length()) - - SAAlignmentResult::new(new_ids, new_aligned_residues, rmsd, tm_score, new_alignment.length()) + let tm_score = sa_calculate_tm_score( + coords1, + coords2, + consensus_struct.residues.length(), + ) + + SAAlignmentResult::new( + new_ids, + new_aligned_residues, + rmsd, + tm_score, + new_alignment.length(), + ) } ///| /// Create residues from coordinates. pub fn sa_residues_from_coords(coords : Array[SAPoint3D]) -> Array[SAResidue] { let residues : Array[SAResidue] = Array::new() - + let mut i = 0 while i < coords.length() { residues.push(SAResidue::new("XXX", i + 1, coords[i])) i = i + 1 } - + residues } ///| /// Calculate pairwise RMSD matrix for multiple structures. -pub fn sa_calculate_pairwise_rmsd(structures : Array[SAStructure]) -> Array[Array[Double]] { +pub fn sa_calculate_pairwise_rmsd( + structures : Array[SAStructure], +) -> Array[Array[Double]] { let n = structures.length() - + let matrix : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let row : Array[Double] = Array::new() @@ -442,31 +529,47 @@ pub fn sa_calculate_pairwise_rmsd(structures : Array[SAStructure]) -> Array[Arra matrix.push(row) i = i + 1 } - + matrix } ///| /// Bio API functions. - -pub fn bio_structure_align_two(struct1 : SAStructure, struct2 : SAStructure) -> SAAlignmentResult { +pub fn bio_structure_align_two( + struct1 : SAStructure, + struct2 : SAStructure, +) -> SAAlignmentResult { sa_align_two_structures(struct1, struct2) } -pub fn bio_structure_align_multiple(structures : Array[SAStructure]) -> SAAlignmentResult { +///| +pub fn bio_structure_align_multiple( + structures : Array[SAStructure], +) -> SAAlignmentResult { sa_align_multiple_structures(structures) } -pub fn bio_structure_calculate_rmsd(struct1 : SAStructure, struct2 : SAStructure) -> Double { +///| +pub fn bio_structure_calculate_rmsd( + struct1 : SAStructure, + struct2 : SAStructure, +) -> Double { let alignment = sa_align_two_structures(struct1, struct2) alignment.rmsd } -pub fn bio_structure_calculate_tm_score(struct1 : SAStructure, struct2 : SAStructure) -> Double { +///| +pub fn bio_structure_calculate_tm_score( + struct1 : SAStructure, + struct2 : SAStructure, +) -> Double { let alignment = sa_align_two_structures(struct1, struct2) alignment.tm_score } -pub fn bio_structure_pairwise_rmsd(structures : Array[SAStructure]) -> Array[Array[Double]] { +///| +pub fn bio_structure_pairwise_rmsd( + structures : Array[SAStructure], +) -> Array[Array[Double]] { sa_calculate_pairwise_rmsd(structures) -} \ No newline at end of file +} diff --git a/src/substitution_matrices.mbt b/src/substitution_matrices.mbt index 22f57202..40abdc6e 100644 --- a/src/substitution_matrices.mbt +++ b/src/substitution_matrices.mbt @@ -23,8 +23,8 @@ /// Standard 20 amino acid alphabet (IUPAC protein, sorted). pub fn subs_protein_alphabet() -> Array[String] { [ - "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", - "M", "N", "P", "Q", "R", "S", "T", "V", "W", "Y", + "A", "C", "D", "E", "F", "G", "H", "I", "K", "L", "M", "N", "P", "Q", "R", "S", + "T", "V", "W", "Y", ] } @@ -42,8 +42,8 @@ pub fn subs_nucleotide_alphabet() -> Array[String] { /// A 2D numeric array with row and column labels. /// Used internally by SubsMatrix for score storage. pub struct ArrayData { - pub rows : Array[String] // row labels - pub cols : Array[String] // column labels + pub rows : Array[String] // row labels + pub cols : Array[String] // column labels pub data : Array[Array[Double]] // row x col values } @@ -60,39 +60,58 @@ pub fn array_data_from_dict( let data : Array[Array[Double]] = [] for _i in 0..= 0 && ci >= 0 { + data[ri][ci] = v } - if ri >= 0 && ci >= 0 { data[ri][ci] = v } pi = pi + 1 } - { rows: rows, cols: cols, data: data } + { rows, cols, data } } ///| /// Get a value from ArrayData by row and column index. pub fn ArrayData::get(self : ArrayData, i : Int, j : Int) -> Double { - if i < 0 || i >= self.rows.length() || j < 0 || j >= self.cols.length() { 0.0 } - else { self.data[i][j] } + if i < 0 || i >= self.rows.length() || j < 0 || j >= self.cols.length() { + 0.0 + } else { + self.data[i][j] + } } ///| @@ -105,16 +124,30 @@ pub fn ArrayData::set(self : ArrayData, i : Int, j : Int, v : Double) -> Unit { ///| /// Get a value by row and column labels. -pub fn ArrayData::get_by_label(self : ArrayData, row : String, col : String) -> Double { +pub fn ArrayData::get_by_label( + self : ArrayData, + row : String, + col : String, +) -> Double { let mut ri = -1 for k in 0.. pub struct SubsMatrix { name : String alphabet : Array[String] - matrix : ArrayData // symmetric for protein matrices + matrix : ArrayData // symmetric for protein matrices n_letters : Int } @@ -138,12 +171,7 @@ pub fn subs_matrix( alphabet : Array[String], matrix : ArrayData, ) -> SubsMatrix { - { - name: name, - alphabet: alphabet, - matrix: matrix, - n_letters: alphabet.length(), - } + { name, alphabet, matrix, n_letters: alphabet.length() } } ///| @@ -169,11 +197,7 @@ pub fn SubsMatrix::get_score( ///| /// Get the score by index (both 0-based positions in the alphabet). -pub fn SubsMatrix::get_score_idx( - self : SubsMatrix, - i : Int, - j : Int, -) -> Double { +pub fn SubsMatrix::get_score_idx(self : SubsMatrix, i : Int, j : Int) -> Double { self.matrix.get(i, j) } @@ -246,6 +270,8 @@ pub fn SubsMatrix::to_table_string(self : SubsMatrix) -> String { ///| /// Registry of named matrices. Stores (name, matrix) pairs. let registry_keys : Ref[Array[String]] = Ref::new([]) + +///| let registry_matrices : Ref[Array[SubsMatrix]] = Ref::new([]) ///| @@ -268,7 +294,9 @@ pub fn register_matrix(name : String, matrix : SubsMatrix) -> Unit { pub fn load_matrix(name : String) -> SubsMatrix? { let keys = registry_keys.val for i in 0.. index map let letter_keys : Array[String] = [] let letter_vals : Array[Int] = [] - for i in 0..= seq_i.length() || pos >= seq_j.length() { continue } + if pos >= seq_i.length() || pos >= seq_j.length() { + continue + } let ci = seq_i[pos:pos + 1].to_owned() let cj = seq_j[pos:pos + 1].to_owned() // Skip gaps - if ci == "-" || cj == "-" { continue } + if ci == "-" || cj == "-" { + continue + } let mut ri = -1 for k in 0..= 0 && rj >= 0 { data[ri][rj] = data[ri][rj] + 1.0 @@ -486,7 +531,7 @@ pub fn calculate_frequency_matrix( } } } - { rows: alphabet, cols: alphabet, data: data } + { rows: alphabet, cols: alphabet, data } } // ============================================================================ @@ -517,7 +562,9 @@ pub fn calculate_substitution_matrix( // Step 2: Calculate total pair count and letter frequencies let mut total_pairs = 0.0 let letter_counts : Array[Double] = [] - for _i in 0.. Double { total = total + freq_matrix.data[i][j] } } - if total < 1.0e-12 { return 0.0 } + if total < 1.0e-12 { + return 0.0 + } let mut entropy = 0.0 for i in 0.. Double { let n = freq_matrix.rows.length() let mut total = 0.0 let letter_counts : Array[Double] = [] - for _i in 0.. SubsMatrix? { let data_rows : Array[(String, Array[Double])] = [] for line in lines { let trimmed = line.trim() - if trimmed.length() == 0 { continue } - if trimmed[0] == '#' { continue } - let parts = trimmed.split(" ").to_array().filter(fn (s) -> Bool { - s.length() > 0 - }) - if parts.length() == 0 { continue } + if trimmed.length() == 0 { + continue + } + if trimmed[0] == '#' { + continue + } + let parts = trimmed + .split(" ") + .to_array() + .filter(fn(s) -> Bool { s.length() > 0 }) + if parts.length() == 0 { + continue + } if alphabet.length() == 0 && parts[0].length() == 0 { // This might be the header line for p in parts { - if p.length() == 1 { alphabet.push(p.to_string()) } + if p.length() == 1 { + alphabet.push(p.to_string()) + } } continue } @@ -647,7 +709,9 @@ pub fn parse_ncbi_matrix(content : String) -> SubsMatrix? { if alphabet.length() == 0 { // First non-comment line is the header for p in parts { - if p.length() >= 1 { alphabet.push(p.to_string()) } + if p.length() >= 1 { + alphabet.push(p.to_string()) + } } continue } @@ -666,9 +730,11 @@ pub fn parse_ncbi_matrix(content : String) -> SubsMatrix? { } } } - if alphabet.length() == 0 || data_rows.length() == 0 { return None } + if alphabet.length() == 0 || data_rows.length() == 0 { + return None + } // Build the matrix - let row_labels = data_rows.map(fn (r) -> String { r.0 }) + let row_labels = data_rows.map(fn(r) -> String { r.0 }) let pairs : Array[(String, String, Double)] = [] let mut dri = 0 while dri < data_rows.length() { @@ -695,11 +761,18 @@ pub fn matrix_correlation(m1 : SubsMatrix, m2 : SubsMatrix) -> Double { for letter in m1.alphabet { let mut found = false for l2 in m2.alphabet { - if l2 == letter { found = true; break } + if l2 == letter { + found = true + break + } + } + if found { + common.push(letter) } - if found { common.push(letter) } } - if common.length() < 2 { return 0.0 } + if common.length() < 2 { + return 0.0 + } // Collect paired scores let v1 : Array[Double] = [] let v2 : Array[Double] = [] @@ -713,7 +786,10 @@ pub fn matrix_correlation(m1 : SubsMatrix, m2 : SubsMatrix) -> Double { let n = v1.length() let mut sum1 = 0.0 let mut sum2 = 0.0 - for i in 0.. Double { var2 = var2 + d2 * d2 } let denom = (var1 * var2).sqrt() - if denom < 1.0e-12 { 0.0 } else { cov / denom } + if denom < 1.0e-12 { + 0.0 + } else { + cov / denom + } } // ============================================================================ // BLOSUM62 raw scores (20x20, row-major, alphabet order: ACDEFGHIKLMNPQRSTVWY) // ============================================================================ +///| fn blosum62_scores() -> Array[Int] { [ // A C D E F G H I K L M N P Q R S T V W Y - 4, 0, -2, -1, -2, 0, -2, -1, -1, -1, -1, -2, -1, -1, -1, 1, 0, 0, -3, -2, // A - 0, 9, -3, -4, -2, -3, -3, -1, -3, -1, -1, -3, -3, -3, -3, -1, -1, -1, -2, -2, // C - -2, -3, 6, 2, -3, -1, -1, -3, -1, -4, -3, 1, -1, 0, -2, 0, -1, -3, -4, -3, // D - -1, -4, 2, 5, -3, -2, 0, -3, 1, -3, -2, 0, -1, 2, 0, 0, -1, -2, -3, -2, // E - -2, -2, -3, -3, 6, -3, -1, 0, -3, 0, 0, -3, -4, -3, -3, -2, -2, -1, 1, 3, // F - 0, -3, -1, -2, -3, 6, -2, -4, -2, -4, -3, 0, -2, -2, -2, 0, -2, -3, -2, -3, // G - -2, -3, -1, 0, -1, -2, 8, -3, -1, -3, -2, 1, -2, 0, 0, -1, -2, -3, -2, 2, // H - -1, -1, -3, -3, 0, -4, -3, 4, -3, 2, 1, -3, -3, -3, -3, -2, -1, 3, -3, -1, // I - -1, -3, -1, 1, -3, -2, -1, -3, 5, -2, -1, 0, -1, 1, 2, 0, -1, -2, -3, -2, // K - -1, -1, -4, -3, 0, -4, -3, 2, -2, 4, 2, -3, -3, -2, -2, -2, -1, 1, -2, -1, // L - -1, -1, -3, -2, 0, -3, -2, 1, -1, 2, 5, -2, -2, 0, -1, -1, -1, 1, -1, -1, // M - -2, -3, 1, 0, -3, 0, 1, -3, 0, -3, -2, 6, -2, 0, 0, 1, 0, -3, -4, -2, // N - -1, -3, -1, -1, -4, -2, -2, -3, -1, -3, -2, -2, 7, -1, -2, -1, -1, -2, -4, -3, // P - -1, -3, 0, 2, -3, -2, 0, -3, 1, -2, 0, 0, -1, 5, 1, 0, -1, -2, -2, -1, // Q - -1, -3, -2, 0, -3, -2, 0, -3, 2, -2, -1, 0, -2, 1, 5, -1, -1, -3, -3, -2, // R - 1, -1, 0, 0, -2, 0, -1, -2, 0, -2, -1, 1, -1, 0, -1, 4, 1, -2, -3, -2, // S - 0, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -1, -1, -1, 1, 5, 0, -2, -2, // T - 0, -1, -3, -2, -1, -3, -3, 3, -2, 1, 1, -3, -2, -2, -3, -2, 0, 4, -3, -1, // V - -3, -2, -4, -3, 1, -2, -2, -3, -3, -2, -1, -4, -4, -2, -3, -3, -2, -3, 11, 2, // W - -2, -2, -3, -2, 3, -3, 2, -1, -2, -1, -1, -2, -3, -1, -2, -2, -2, -1, 2, 7, // Y + 4, 0, -2, -1, -2, 0, -2, -1, -1, -1, -1, -2, -1, -1, -1, 1, 0, 0, -3, -2, // A + 0, 9, -3, -4, -2, -3, -3, -1, -3, -1, -1, -3, -3, -3, -3, -1, -1, -1, -2, -2, // C + -2, -3, 6, 2, -3, -1, -1, -3, -1, -4, -3, 1, -1, 0, -2, 0, -1, -3, -4, -3, // D + -1, -4, 2, 5, -3, -2, 0, -3, 1, -3, -2, 0, -1, 2, 0, 0, -1, -2, -3, -2, // E + -2, -2, -3, -3, 6, -3, -1, 0, -3, 0, 0, -3, -4, -3, -3, -2, -2, -1, 1, 3, // F + 0, -3, -1, -2, -3, 6, -2, -4, -2, -4, -3, 0, -2, -2, -2, 0, -2, -3, -2, -3, // G + -2, -3, -1, 0, -1, -2, 8, -3, -1, -3, -2, 1, -2, 0, 0, -1, -2, -3, -2, 2, // H + -1, -1, -3, -3, 0, -4, -3, 4, -3, 2, 1, -3, -3, -3, -3, -2, -1, 3, -3, -1, // I + -1, -3, -1, 1, -3, -2, -1, -3, 5, -2, -1, 0, -1, 1, 2, 0, -1, -2, -3, -2, // K + -1, -1, -4, -3, 0, -4, -3, 2, -2, 4, 2, -3, -3, -2, -2, -2, -1, 1, -2, -1, // L + -1, -1, -3, -2, 0, -3, -2, 1, -1, 2, 5, -2, -2, 0, -1, -1, -1, 1, -1, -1, // M + -2, -3, 1, 0, -3, 0, 1, -3, 0, -3, -2, 6, -2, 0, 0, 1, 0, -3, -4, -2, // N + -1, -3, -1, -1, -4, -2, -2, -3, -1, -3, -2, -2, 7, -1, -2, -1, -1, -2, -4, -3, // P + -1, -3, 0, 2, -3, -2, 0, -3, 1, -2, 0, 0, -1, 5, 1, 0, -1, -2, -2, -1, // Q + -1, -3, -2, 0, -3, -2, 0, -3, 2, -2, -1, 0, -2, 1, 5, -1, -1, -3, -3, -2, // R + 1, -1, 0, 0, -2, 0, -1, -2, 0, -2, -1, 1, -1, 0, -1, 4, 1, -2, -3, -2, // S + 0, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -1, -1, -1, 1, 5, 0, -2, -2, // T + 0, -1, -3, -2, -1, -3, -3, 3, -2, 1, 1, -3, -2, -2, -3, -2, 0, 4, -3, -1, // V + -3, -2, -4, -3, 1, -2, -2, -3, -3, -2, -1, -4, -4, -2, -3, -3, -2, -3, 11, 2, // W + -2, -2, -3, -2, 3, -3, 2, -1, -2, -1, -1, -2, -3, -1, -2, -2, -2, -1, 2, 7, // Y ] } @@ -764,28 +845,28 @@ fn blosum62_scores() -> Array[Int] { // BLOSUM45 raw scores (20x20) // ============================================================================ +///| fn blosum45_scores() -> Array[Int] { [ - 5, -1, -2, -1, -2, 0, -2, -1, -1, -1, -1, -2, -1, -1, -1, 1, 0, 0, -3, -2, - -1, 12, -5, -5, -4, -3, -3, -2, -5, -2, -2, -4, -4, -4, -4, -1, -1, -1, -5, -4, - -2, -5, 7, 2, -4, -1, 0, -4, 0, -4, -3, 2, -1, 0, -1, 0, -1, -3, -5, -3, - -1, -5, 2, 6, -4, -2, 0, -3, 1, -3, -2, 0, -1, 2, 0, 0, -1, -2, -4, -2, - -2, -4, -4, -4, 8, -3, -1, 0, -3, 0, 0, -3, -4, -3, -3, -2, -2, -1, 0, 3, - 0, -3, -1, -2, -3, 7, -2, -3, -2, -3, -2, 0, -2, -2, -2, 0, -2, -3, -3, -3, - -2, -3, 0, 0, -1, -2, 10, -3, -1, -3, -2, 1, -2, 0, 0, -1, -2, -3, -2, 2, - -1, -2, -4, -3, 0, -3, -3, 5, -3, 2, 1, -3, -3, -3, -3, -2, -1, 3, -2, -1, - -1, -5, 0, 1, -3, -2, -1, -3, 5, -3, -1, 0, -1, 1, 3, 0, -1, -3, -4, -2, - -1, -2, -4, -3, 0, -3, -3, 2, -3, 5, 2, -3, -3, -2, -2, -2, -1, 1, -2, -1, - -1, -2, -3, -2, 0, -2, -2, 1, -1, 2, 6, -2, -2, 0, -1, -1, -1, 1, -1, -1, - -2, -4, 2, 0, -3, 0, 1, -3, 0, -3, -2, 6, -2, 0, 0, 1, 0, -3, -4, -2, - -1, -4, -1, -1, -4, -2, -2, -3, -1, -3, -2, -2, 9, -1, -2, -1, -1, -2, -5, -3, - -1, -4, 0, 2, -3, -2, 0, -3, 1, -2, 0, 0, -1, 6, 1, 0, -1, -2, -3, -1, - -1, -4, -1, 0, -3, -2, 0, -3, 3, -2, -1, 0, -2, 1, 6, -1, -1, -3, -3, -2, - 1, -1, 0, 0, -2, 0, -1, -2, 0, -2, -1, 1, -1, 0, -1, 4, 1, -2, -3, -2, - 0, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -1, -1, -1, 1, 5, 0, -3, -2, - 0, -1, -3, -2, -1, -3, -3, 3, -3, 1, 1, -3, -2, -2, -3, -2, 0, 4, -2, -1, - -3, -5, -5, -4, 0, -3, -2, -2, -4, -2, -1, -4, -5, -3, -3, -3, -3, -2, 14, 2, - -2, -4, -3, -2, 3, -3, 2, -1, -2, -1, -1, -2, -3, -1, -2, -2, -2, -1, 2, 8, + 5, -1, -2, -1, -2, 0, -2, -1, -1, -1, -1, -2, -1, -1, -1, 1, 0, 0, -3, -2, -1, + 12, -5, -5, -4, -3, -3, -2, -5, -2, -2, -4, -4, -4, -4, -1, -1, -1, -5, -4, -2, + -5, 7, 2, -4, -1, 0, -4, 0, -4, -3, 2, -1, 0, -1, 0, -1, -3, -5, -3, -1, -5, + 2, 6, -4, -2, 0, -3, 1, -3, -2, 0, -1, 2, 0, 0, -1, -2, -4, -2, -2, -4, -4, -4, + 8, -3, -1, 0, -3, 0, 0, -3, -4, -3, -3, -2, -2, -1, 0, 3, 0, -3, -1, -2, -3, + 7, -2, -3, -2, -3, -2, 0, -2, -2, -2, 0, -2, -3, -3, -3, -2, -3, 0, 0, -1, -2, + 10, -3, -1, -3, -2, 1, -2, 0, 0, -1, -2, -3, -2, 2, -1, -2, -4, -3, 0, -3, -3, + 5, -3, 2, 1, -3, -3, -3, -3, -2, -1, 3, -2, -1, -1, -5, 0, 1, -3, -2, -1, -3, + 5, -3, -1, 0, -1, 1, 3, 0, -1, -3, -4, -2, -1, -2, -4, -3, 0, -3, -3, 2, -3, + 5, 2, -3, -3, -2, -2, -2, -1, 1, -2, -1, -1, -2, -3, -2, 0, -2, -2, 1, -1, 2, + 6, -2, -2, 0, -1, -1, -1, 1, -1, -1, -2, -4, 2, 0, -3, 0, 1, -3, 0, -3, -2, 6, + -2, 0, 0, 1, 0, -3, -4, -2, -1, -4, -1, -1, -4, -2, -2, -3, -1, -3, -2, -2, 9, + -1, -2, -1, -1, -2, -5, -3, -1, -4, 0, 2, -3, -2, 0, -3, 1, -2, 0, 0, -1, 6, + 1, 0, -1, -2, -3, -1, -1, -4, -1, 0, -3, -2, 0, -3, 3, -2, -1, 0, -2, 1, 6, -1, + -1, -3, -3, -2, 1, -1, 0, 0, -2, 0, -1, -2, 0, -2, -1, 1, -1, 0, -1, 4, 1, -2, + -3, -2, 0, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -1, -1, -1, 1, 5, 0, -3, + -2, 0, -1, -3, -2, -1, -3, -3, 3, -3, 1, 1, -3, -2, -2, -3, -2, 0, 4, -2, -1, + -3, -5, -5, -4, 0, -3, -2, -2, -4, -2, -1, -4, -5, -3, -3, -3, -3, -2, 14, 2, + -2, -4, -3, -2, 3, -3, 2, -1, -2, -1, -1, -2, -3, -1, -2, -2, -2, -1, 2, 8, ] } @@ -793,28 +874,28 @@ fn blosum45_scores() -> Array[Int] { // BLOSUM80 raw scores (20x20) // ============================================================================ +///| fn blosum80_scores() -> Array[Int] { [ - 7, -1, -2, -1, -2, 0, -2, -1, -1, -1, -1, -2, -1, -1, -1, 2, 1, 0, -4, -3, - -1, 13, -5, -5, -3, -4, -4, -2, -4, -2, -2, -4, -5, -4, -4, -1, -1, -1, -5, -3, - -2, -5, 9, 2, -5, -2, -1, -4, -1, -5, -4, 2, -2, 1, -2, 0, -1, -4, -6, -4, - -1, -5, 2, 8, -5, -3, 0, -4, 2, -4, -3, 0, -2, 3, 0, 0, -1, -3, -5, -3, - -2, -3, -5, -5, 9, -4, -1, 0, -4, 0, 0, -4, -5, -4, -4, -2, -2, -1, 1, 4, - 0, -4, -2, -3, -4, 9, -3, -5, -2, -5, -4, 0, -3, -3, -3, 0, -2, -4, -4, -4, - -2, -4, -1, 0, -1, -3, 12, -4, -1, -4, -3, 1, -3, 0, 0, -1, -2, -4, -3, 2, - -1, -2, -4, -4, 0, -5, -4, 6, -3, 2, 1, -4, -3, -3, -3, -2, -1, 3, -4, -2, - -1, -4, -1, 2, -4, -2, -1, -3, 8, -3, -1, 0, -2, 2, 3, 0, -1, -3, -5, -3, - -1, -2, -5, -4, 0, -5, -4, 2, -3, 6, 3, -4, -3, -3, -3, -2, -1, 1, -3, -1, - -1, -2, -4, -3, 0, -4, -3, 1, -1, 3, 8, -3, -3, 0, -1, -1, -1, 1, -2, -1, - -2, -4, 2, 0, -4, 0, 1, -4, 0, -4, -3, 8, -2, 0, 0, 1, 0, -4, -5, -3, - -1, -5, -2, -2, -5, -3, -3, -3, -2, -3, -3, -2, 11, -2, -3, -2, -2, -3, -6, -4, - -1, -4, 1, 3, -4, -3, 0, -3, 2, -3, 0, 0, -2, 8, 1, 0, -1, -3, -3, -2, - -1, -4, -2, 0, -4, -3, 0, -3, 3, -3, -1, 0, -3, 1, 8, -1, -1, -4, -4, -2, - 2, -1, 0, 0, -2, 0, -1, -2, 0, -2, -1, 1, -2, 0, -1, 7, 2, -2, -4, -3, - 1, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -2, -1, -1, 2, 7, 0, -4, -2, - 0, -1, -4, -3, -1, -4, -4, 3, -3, 1, 1, -4, -3, -3, -4, -2, 0, 6, -4, -2, - -4, -5, -6, -5, 1, -4, -3, -4, -5, -3, -2, -5, -6, -3, -4, -4, -4, -4, 15, 3, - -3, -3, -4, -3, 4, -4, 2, -2, -3, -1, -1, -3, -4, -2, -2, -3, -2, -2, 3, 9, + 7, -1, -2, -1, -2, 0, -2, -1, -1, -1, -1, -2, -1, -1, -1, 2, 1, 0, -4, -3, -1, + 13, -5, -5, -3, -4, -4, -2, -4, -2, -2, -4, -5, -4, -4, -1, -1, -1, -5, -3, -2, + -5, 9, 2, -5, -2, -1, -4, -1, -5, -4, 2, -2, 1, -2, 0, -1, -4, -6, -4, -1, -5, + 2, 8, -5, -3, 0, -4, 2, -4, -3, 0, -2, 3, 0, 0, -1, -3, -5, -3, -2, -3, -5, -5, + 9, -4, -1, 0, -4, 0, 0, -4, -5, -4, -4, -2, -2, -1, 1, 4, 0, -4, -2, -3, -4, + 9, -3, -5, -2, -5, -4, 0, -3, -3, -3, 0, -2, -4, -4, -4, -2, -4, -1, 0, -1, -3, + 12, -4, -1, -4, -3, 1, -3, 0, 0, -1, -2, -4, -3, 2, -1, -2, -4, -4, 0, -5, -4, + 6, -3, 2, 1, -4, -3, -3, -3, -2, -1, 3, -4, -2, -1, -4, -1, 2, -4, -2, -1, -3, + 8, -3, -1, 0, -2, 2, 3, 0, -1, -3, -5, -3, -1, -2, -5, -4, 0, -5, -4, 2, -3, + 6, 3, -4, -3, -3, -3, -2, -1, 1, -3, -1, -1, -2, -4, -3, 0, -4, -3, 1, -1, 3, + 8, -3, -3, 0, -1, -1, -1, 1, -2, -1, -2, -4, 2, 0, -4, 0, 1, -4, 0, -4, -3, 8, + -2, 0, 0, 1, 0, -4, -5, -3, -1, -5, -2, -2, -5, -3, -3, -3, -2, -3, -3, -2, 11, + -2, -3, -2, -2, -3, -6, -4, -1, -4, 1, 3, -4, -3, 0, -3, 2, -3, 0, 0, -2, 8, + 1, 0, -1, -3, -3, -2, -1, -4, -2, 0, -4, -3, 0, -3, 3, -3, -1, 0, -3, 1, 8, -1, + -1, -4, -4, -2, 2, -1, 0, 0, -2, 0, -1, -2, 0, -2, -1, 1, -2, 0, -1, 7, 2, -2, + -4, -3, 1, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -2, -1, -1, 2, 7, 0, -4, + -2, 0, -1, -4, -3, -1, -4, -4, 3, -3, 1, 1, -4, -3, -3, -4, -2, 0, 6, -4, -2, + -4, -5, -6, -5, 1, -4, -3, -4, -5, -3, -2, -5, -6, -3, -4, -4, -4, -4, 15, 3, + -3, -3, -4, -3, 4, -4, 2, -2, -3, -1, -1, -3, -4, -2, -2, -3, -2, -2, 3, 9, ] } @@ -822,28 +903,28 @@ fn blosum80_scores() -> Array[Int] { // BLOSUM90 raw scores (20x20) // ============================================================================ +///| fn blosum90_scores() -> Array[Int] { [ - 7, -1, -2, -1, -3, 0, -2, -1, -1, -2, -1, -2, -1, -1, -2, 2, 1, 0, -4, -3, - -1, 14, -6, -6, -4, -4, -4, -2, -5, -3, -3, -5, -5, -5, -4, -1, -1, -2, -5, -4, - -2, -6, 10, 2, -5, -2, -1, -4, -1, -5, -4, 2, -2, 1, -2, 0, -1, -4, -6, -4, - -1, -6, 2, 9, -5, -3, 0, -4, 2, -4, -3, 0, -2, 3, 0, 0, -1, -3, -5, -3, - -3, -4, -5, -5, 10, -4, -1, 0, -4, 0, 0, -4, -5, -4, -4, -3, -2, -1, 2, 4, - 0, -4, -2, -3, -4, 10, -3, -5, -2, -5, -4, 0, -3, -3, -3, 0, -2, -4, -4, -4, - -2, -4, -1, 0, -1, -3, 12, -4, -1, -4, -3, 1, -3, 0, 0, -1, -2, -4, -3, 2, - -1, -2, -4, -4, 0, -5, -4, 6, -3, 2, 1, -4, -3, -3, -3, -2, -1, 3, -4, -2, - -1, -5, -1, 2, -4, -2, -1, -3, 8, -3, -1, 0, -2, 2, 3, 0, -1, -3, -5, -3, - -2, -3, -5, -4, 0, -5, -4, 2, -3, 6, 3, -4, -3, -3, -3, -2, -1, 1, -3, -1, - -1, -3, -4, -3, 0, -4, -3, 1, -1, 3, 8, -3, -3, 0, -1, -1, -1, 1, -2, -1, - -2, -5, 2, 0, -4, 0, 1, -4, 0, -4, -3, 8, -2, 0, 0, 1, 0, -4, -5, -3, - -1, -5, -2, -2, -5, -3, -3, -3, -2, -3, -3, -2, 12, -2, -3, -2, -2, -3, -6, -4, - -1, -5, 1, 3, -4, -3, 0, -3, 2, -3, 0, 0, -2, 9, 1, 0, -1, -3, -4, -2, - -2, -4, -2, 0, -4, -3, 0, -3, 3, -3, -1, 0, -3, 1, 9, -1, -1, -4, -4, -2, - 2, -1, 0, 0, -3, 0, -1, -2, 0, -2, -1, 1, -2, 0, -1, 7, 2, -2, -4, -3, - 1, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -2, -1, -1, 2, 8, 0, -4, -2, - 0, -2, -4, -3, -1, -4, -4, 3, -3, 1, 1, -4, -3, -3, -4, -2, 0, 6, -4, -2, - -4, -5, -6, -5, 2, -4, -3, -4, -5, -3, -2, -5, -6, -4, -4, -4, -4, -4, 15, 3, - -3, -4, -4, -3, 4, -4, 2, -2, -3, -1, -1, -3, -4, -2, -2, -3, -2, -2, 3, 9, + 7, -1, -2, -1, -3, 0, -2, -1, -1, -2, -1, -2, -1, -1, -2, 2, 1, 0, -4, -3, -1, + 14, -6, -6, -4, -4, -4, -2, -5, -3, -3, -5, -5, -5, -4, -1, -1, -2, -5, -4, -2, + -6, 10, 2, -5, -2, -1, -4, -1, -5, -4, 2, -2, 1, -2, 0, -1, -4, -6, -4, -1, -6, + 2, 9, -5, -3, 0, -4, 2, -4, -3, 0, -2, 3, 0, 0, -1, -3, -5, -3, -3, -4, -5, -5, + 10, -4, -1, 0, -4, 0, 0, -4, -5, -4, -4, -3, -2, -1, 2, 4, 0, -4, -2, -3, -4, + 10, -3, -5, -2, -5, -4, 0, -3, -3, -3, 0, -2, -4, -4, -4, -2, -4, -1, 0, -1, + -3, 12, -4, -1, -4, -3, 1, -3, 0, 0, -1, -2, -4, -3, 2, -1, -2, -4, -4, 0, -5, + -4, 6, -3, 2, 1, -4, -3, -3, -3, -2, -1, 3, -4, -2, -1, -5, -1, 2, -4, -2, -1, + -3, 8, -3, -1, 0, -2, 2, 3, 0, -1, -3, -5, -3, -2, -3, -5, -4, 0, -5, -4, 2, + -3, 6, 3, -4, -3, -3, -3, -2, -1, 1, -3, -1, -1, -3, -4, -3, 0, -4, -3, 1, -1, + 3, 8, -3, -3, 0, -1, -1, -1, 1, -2, -1, -2, -5, 2, 0, -4, 0, 1, -4, 0, -4, -3, + 8, -2, 0, 0, 1, 0, -4, -5, -3, -1, -5, -2, -2, -5, -3, -3, -3, -2, -3, -3, -2, + 12, -2, -3, -2, -2, -3, -6, -4, -1, -5, 1, 3, -4, -3, 0, -3, 2, -3, 0, 0, -2, + 9, 1, 0, -1, -3, -4, -2, -2, -4, -2, 0, -4, -3, 0, -3, 3, -3, -1, 0, -3, 1, 9, + -1, -1, -4, -4, -2, 2, -1, 0, 0, -3, 0, -1, -2, 0, -2, -1, 1, -2, 0, -1, 7, 2, + -2, -4, -3, 1, -1, -1, -1, -2, -2, -2, -1, -1, -1, -1, 0, -2, -1, -1, 2, 8, 0, + -4, -2, 0, -2, -4, -3, -1, -4, -4, 3, -3, 1, 1, -4, -3, -3, -4, -2, 0, 6, -4, + -2, -4, -5, -6, -5, 2, -4, -3, -4, -5, -3, -2, -5, -6, -4, -4, -4, -4, -4, 15, + 3, -3, -4, -4, -3, 4, -4, 2, -2, -3, -1, -1, -3, -4, -2, -2, -3, -2, -2, 3, 9, ] } @@ -851,28 +932,29 @@ fn blosum90_scores() -> Array[Int] { // PAM30 raw scores (20x20) // ============================================================================ +///| fn pam30_scores() -> Array[Int] { [ - 6, -7, -4, -2, -6, -2, -5, -3, -3, -5, -4, -3, -3, -3, -5, 0, 0, -3, -10, -6, - -7, 12, -9, -9, -6, -9, -6, -7, -9, -7, -7, -7, -8, -7, -7, -4, -5, -6, -10, -7, - -4, -9, 8, 2, -9, -3, -3, -7, -3, -8, -7, 2, -5, 0, -6, -1, -3, -7, -9, -7, - -2, -9, 2, 8, -8, -5, -1, -6, 2, -7, -5, 0, -4, 3, -3, -1, -3, -5, -9, -5, - -6, -6, -9, -8, 10, -8, -4, -1, -8, -1, -1, -8, -8, -8, -7, -5, -5, -3, 1, 3, - -2, -9, -3, -5, -8, 8, -6, -8, -5, -8, -6, 0, -6, -5, -6, -1, -4, -7, -9, -8, - -5, -6, -3, -1, -4, -6, 10, -6, -3, -6, -5, 1, -5, 0, -2, -3, -4, -6, -4, 2, - -3, -7, -7, -6, -1, -8, -6, 7, -5, 1, 1, -6, -5, -5, -5, -4, -2, 3, -7, -4, - -3, -9, -3, 2, -8, -5, -3, -5, 7, -5, -3, 0, -4, 2, 2, -1, -2, -5, -9, -6, - -5, -7, -8, -7, -1, -8, -6, 1, -5, 7, 3, -6, -5, -4, -6, -5, -4, 1, -6, -4, - -4, -7, -7, -5, -1, -6, -5, 1, -3, 3, 8, -5, -4, -1, -3, -3, -2, 1, -6, -4, - -3, -7, 2, 0, -8, 0, 1, -6, 0, -6, -5, 8, -4, 0, -3, 0, -1, -6, -9, -5, - -3, -8, -5, -4, -8, -6, -5, -5, -4, -5, -4, -4, 11, -4, -5, -3, -3, -5, -9, -7, - -3, -7, 0, 3, -8, -5, 0, -5, 2, -4, -1, 0, -4, 8, 1, -1, -3, -5, -8, -5, - -5, -7, -6, -3, -7, -6, -2, -5, 2, -6, -3, -3, -5, 1, 8, -2, -3, -6, -7, -5, - 0, -4, -1, -1, -5, -1, -3, -4, -1, -5, -3, 0, -3, -1, -2, 6, 1, -4, -6, -4, - 0, -5, -3, -3, -5, -4, -4, -2, -2, -4, -2, -1, -3, -3, -3, 1, 7, -1, -7, -4, - -3, -6, -7, -5, -3, -7, -6, 3, -5, 1, 1, -6, -5, -5, -6, -4, -1, 7, -7, -4, - -10, -10, -9, -9, 1, -9, -4, -7, -9, -6, -6, -9, -9, -8, -7, -6, -7, -7, 14, 3, - -6, -7, -7, -5, 3, -8, 2, -4, -6, -4, -4, -5, -7, -5, -5, -4, -4, -4, 3, 10, + 6, -7, -4, -2, -6, -2, -5, -3, -3, -5, -4, -3, -3, -3, -5, 0, 0, -3, -10, -6, + -7, 12, -9, -9, -6, -9, -6, -7, -9, -7, -7, -7, -8, -7, -7, -4, -5, -6, -10, + -7, -4, -9, 8, 2, -9, -3, -3, -7, -3, -8, -7, 2, -5, 0, -6, -1, -3, -7, -9, -7, + -2, -9, 2, 8, -8, -5, -1, -6, 2, -7, -5, 0, -4, 3, -3, -1, -3, -5, -9, -5, -6, + -6, -9, -8, 10, -8, -4, -1, -8, -1, -1, -8, -8, -8, -7, -5, -5, -3, 1, 3, -2, + -9, -3, -5, -8, 8, -6, -8, -5, -8, -6, 0, -6, -5, -6, -1, -4, -7, -9, -8, -5, + -6, -3, -1, -4, -6, 10, -6, -3, -6, -5, 1, -5, 0, -2, -3, -4, -6, -4, 2, -3, + -7, -7, -6, -1, -8, -6, 7, -5, 1, 1, -6, -5, -5, -5, -4, -2, 3, -7, -4, -3, -9, + -3, 2, -8, -5, -3, -5, 7, -5, -3, 0, -4, 2, 2, -1, -2, -5, -9, -6, -5, -7, -8, + -7, -1, -8, -6, 1, -5, 7, 3, -6, -5, -4, -6, -5, -4, 1, -6, -4, -4, -7, -7, -5, + -1, -6, -5, 1, -3, 3, 8, -5, -4, -1, -3, -3, -2, 1, -6, -4, -3, -7, 2, 0, -8, + 0, 1, -6, 0, -6, -5, 8, -4, 0, -3, 0, -1, -6, -9, -5, -3, -8, -5, -4, -8, -6, + -5, -5, -4, -5, -4, -4, 11, -4, -5, -3, -3, -5, -9, -7, -3, -7, 0, 3, -8, -5, + 0, -5, 2, -4, -1, 0, -4, 8, 1, -1, -3, -5, -8, -5, -5, -7, -6, -3, -7, -6, -2, + -5, 2, -6, -3, -3, -5, 1, 8, -2, -3, -6, -7, -5, 0, -4, -1, -1, -5, -1, -3, -4, + -1, -5, -3, 0, -3, -1, -2, 6, 1, -4, -6, -4, 0, -5, -3, -3, -5, -4, -4, -2, -2, + -4, -2, -1, -3, -3, -3, 1, 7, -1, -7, -4, -3, -6, -7, -5, -3, -7, -6, 3, -5, + 1, 1, -6, -5, -5, -6, -4, -1, 7, -7, -4, -10, -10, -9, -9, 1, -9, -4, -7, -9, + -6, -6, -9, -9, -8, -7, -6, -7, -7, 14, 3, -6, -7, -7, -5, 3, -8, 2, -4, -6, + -4, -4, -5, -7, -5, -5, -4, -4, -4, 3, 10, ] } @@ -880,28 +962,29 @@ fn pam30_scores() -> Array[Int] { // PAM70 raw scores (20x20) // ============================================================================ +///| fn pam70_scores() -> Array[Int] { [ - 5, -4, -3, -1, -5, -1, -4, -2, -2, -4, -3, -2, -2, -2, -4, 1, 1, -2, -8, -4, - -4, 10, -7, -6, -4, -7, -4, -5, -6, -5, -5, -5, -6, -5, -5, -2, -3, -4, -7, -5, - -3, -7, 7, 2, -7, -2, -2, -5, -2, -6, -5, 2, -4, 1, -4, 0, -2, -5, -7, -5, - -1, -6, 2, 7, -6, -4, 0, -4, 2, -5, -3, 0, -3, 3, -2, 0, -2, -4, -7, -4, - -5, -4, -7, -6, 9, -6, -3, -1, -6, -1, -1, -6, -6, -6, -5, -4, -4, -2, 1, 3, - -1, -7, -2, -4, -6, 8, -5, -6, -4, -6, -5, 1, -5, -4, -4, 0, -3, -5, -7, -6, - -4, -4, -2, 0, -3, -5, 10, -5, -2, -4, -4, 2, -4, 1, 0, -2, -3, -5, -3, 2, - -2, -5, -5, -4, -1, -6, -5, 7, -4, 2, 2, -4, -4, -3, -4, -3, -1, 3, -5, -3, - -2, -6, -2, 2, -6, -4, -2, -4, 6, -4, -2, 0, -3, 2, 2, 0, -1, -4, -7, -4, - -4, -5, -6, -5, -1, -6, -4, 2, -4, 6, 3, -4, -4, -3, -4, -3, -3, 1, -4, -2, - -3, -5, -5, -3, -1, -5, -4, 2, -2, 3, 8, -4, -3, -1, -2, -2, -1, 1, -4, -2, - -2, -5, 2, 0, -6, 1, 2, -4, 0, -4, -4, 8, -3, 0, -2, 1, 0, -4, -7, -4, - -2, -6, -4, -3, -6, -5, -4, -4, -3, -4, -3, -3, 10, -3, -4, -2, -2, -4, -7, -5, - -2, -5, 1, 3, -6, -4, 1, -3, 2, -3, -1, 0, -3, 7, 1, 0, -2, -4, -6, -3, - -4, -5, -4, -2, -5, -4, 0, -4, 2, -4, -2, -2, -4, 1, 8, -1, -2, -4, -5, -3, - 1, -2, 0, 0, -4, 0, -2, -3, 0, -3, -2, 1, -2, 0, -1, 5, 2, -3, -5, -3, - 1, -3, -2, -2, -4, -3, -3, -1, -1, -3, -1, 0, -2, -2, -2, 2, 6, -1, -5, -3, - -2, -4, -5, -4, -2, -5, -5, 3, -4, 1, 1, -4, -4, -4, -4, -3, -1, 7, -5, -3, - -8, -7, -7, -7, 1, -7, -3, -5, -7, -4, -4, -7, -7, -6, -5, -5, -5, -5, 13, 3, - -4, -5, -5, -4, 3, -6, 2, -3, -4, -2, -2, -4, -5, -3, -3, -3, -3, -3, 3, 9, + 5, -4, -3, -1, -5, -1, -4, -2, -2, -4, -3, -2, -2, -2, -4, 1, 1, -2, -8, -4, + -4, 10, -7, -6, -4, -7, -4, -5, -6, -5, -5, -5, -6, -5, -5, -2, -3, -4, -7, -5, + -3, -7, 7, 2, -7, -2, -2, -5, -2, -6, -5, 2, -4, 1, -4, 0, -2, -5, -7, -5, -1, + -6, 2, 7, -6, -4, 0, -4, 2, -5, -3, 0, -3, 3, -2, 0, -2, -4, -7, -4, -5, -4, + -7, -6, 9, -6, -3, -1, -6, -1, -1, -6, -6, -6, -5, -4, -4, -2, 1, 3, -1, -7, + -2, -4, -6, 8, -5, -6, -4, -6, -5, 1, -5, -4, -4, 0, -3, -5, -7, -6, -4, -4, + -2, 0, -3, -5, 10, -5, -2, -4, -4, 2, -4, 1, 0, -2, -3, -5, -3, 2, -2, -5, -5, + -4, -1, -6, -5, 7, -4, 2, 2, -4, -4, -3, -4, -3, -1, 3, -5, -3, -2, -6, -2, 2, + -6, -4, -2, -4, 6, -4, -2, 0, -3, 2, 2, 0, -1, -4, -7, -4, -4, -5, -6, -5, -1, + -6, -4, 2, -4, 6, 3, -4, -4, -3, -4, -3, -3, 1, -4, -2, -3, -5, -5, -3, -1, -5, + -4, 2, -2, 3, 8, -4, -3, -1, -2, -2, -1, 1, -4, -2, -2, -5, 2, 0, -6, 1, 2, -4, + 0, -4, -4, 8, -3, 0, -2, 1, 0, -4, -7, -4, -2, -6, -4, -3, -6, -5, -4, -4, -3, + -4, -3, -3, 10, -3, -4, -2, -2, -4, -7, -5, -2, -5, 1, 3, -6, -4, 1, -3, 2, -3, + -1, 0, -3, 7, 1, 0, -2, -4, -6, -3, -4, -5, -4, -2, -5, -4, 0, -4, 2, -4, -2, + -2, -4, 1, 8, -1, -2, -4, -5, -3, 1, -2, 0, 0, -4, 0, -2, -3, 0, -3, -2, 1, -2, + 0, -1, 5, 2, -3, -5, -3, 1, -3, -2, -2, -4, -3, -3, -1, -1, -3, -1, 0, -2, -2, + -2, 2, 6, -1, -5, -3, -2, -4, -5, -4, -2, -5, -5, 3, -4, 1, 1, -4, -4, -4, -4, + -3, -1, 7, -5, -3, -8, -7, -7, -7, 1, -7, -3, -5, -7, -4, -4, -7, -7, -6, -5, + -5, -5, -5, 13, 3, -4, -5, -5, -4, 3, -6, 2, -3, -4, -2, -2, -4, -5, -3, -3, + -3, -3, -3, 3, 9, ] } @@ -909,27 +992,27 @@ fn pam70_scores() -> Array[Int] { // PAM250 raw scores (20x20) // ============================================================================ +///| fn pam250_scores() -> Array[Int] { [ - 2, -2, 0, 0, -3, 1, -1, -1, -1, -2, -1, 0, 1, 0, -2, 1, 1, 0, -6, -3, - -2, 12, -5, -5, -4, -3, -3, -2, -3, -2, -2, -4, -4, -4, -4, 0, -2, -2, -7, -4, - 0, -5, 4, 3, -6, 1, 1, -2, 0, -4, -3, 2, -1, 2, -1, 0, 0, -2, -5, -4, - 0, -5, 3, 4, -5, 0, 1, -2, 2, -3, -2, 1, -1, 2, -1, 0, 0, -2, -5, -3, - -3, -4, -6, -5, 9, -5, -2, 1, -5, 2, 0, -3, -5, -5, -4, -3, -3, -1, 0, 7, - 1, -3, 1, 0, -5, 5, -2, -3, -2, -4, -3, 0, 0, -1, -3, 1, 0, -1, -7, -5, - -1, -3, 1, 1, -2, -2, 6, -2, 0, -2, -2, 2, 0, 3, 2, -1, -1, -2, -3, 2, - -1, -2, -2, -2, 1, -3, -2, 5, -2, 2, 2, -2, -2, -2, -2, -1, 0, 4, -5, -1, - -1, -3, 0, 2, -5, -2, 0, -2, 5, -3, -1, 1, -1, 1, 3, 0, 0, -2, -3, -4, - -2, -2, -4, -3, 2, -4, -2, 2, -3, 6, 4, -3, -3, -2, -3, -3, -2, 2, -2, -1, - -1, -2, -3, -2, 0, -3, -2, 2, -1, 4, 6, -2, -2, -1, 0, -2, -1, 2, -4, -2, - 0, -4, 2, 1, -3, 0, 2, -2, 1, -3, -2, 2, 0, 1, 0, 1, 0, -2, -4, -2, - 1, -4, -1, -1, -5, 0, 0, -2, -1, -3, -2, 0, 6, 0, 0, 1, 0, -1, -6, -5, - 0, -4, 2, 2, -5, -1, 3, -2, 1, -2, -1, 1, 0, 4, 1, -1, -1, -2, -5, -4, - -2, -4, -1, -1, -4, -3, 2, -2, 3, -3, 0, 0, 0, 1, 6, 0, -1, -2, -4, 0, - 1, 0, 0, 0, -3, 1, -1, -1, 0, -3, -2, 1, 1, -1, 0, 2, 1, -1, -4, -2, - 1, -2, 0, 0, -3, 0, -1, 0, 0, -2, -1, 0, 0, -1, -1, 1, 3, 0, -5, -3, - 0, -2, -2, -2, -1, -1, -2, 4, -2, 2, 2, -2, -1, -2, -2, -1, 0, 4, -6, -2, - -6, -7, -5, -5, 0, -7, -3, -5, -3, -2, -4, -4, -6, -5, -4, -4, -5, -6, 17, 0, - -3, -4, -4, -3, 7, -5, 2, -1, -4, -1, -2, -2, -5, -4, 0, -2, -3, -2, 0, 10, + 2, -2, 0, 0, -3, 1, -1, -1, -1, -2, -1, 0, 1, 0, -2, 1, 1, 0, -6, -3, -2, 12, + -5, -5, -4, -3, -3, -2, -3, -2, -2, -4, -4, -4, -4, 0, -2, -2, -7, -4, 0, -5, + 4, 3, -6, 1, 1, -2, 0, -4, -3, 2, -1, 2, -1, 0, 0, -2, -5, -4, 0, -5, 3, 4, -5, + 0, 1, -2, 2, -3, -2, 1, -1, 2, -1, 0, 0, -2, -5, -3, -3, -4, -6, -5, 9, -5, -2, + 1, -5, 2, 0, -3, -5, -5, -4, -3, -3, -1, 0, 7, 1, -3, 1, 0, -5, 5, -2, -3, -2, + -4, -3, 0, 0, -1, -3, 1, 0, -1, -7, -5, -1, -3, 1, 1, -2, -2, 6, -2, 0, -2, -2, + 2, 0, 3, 2, -1, -1, -2, -3, 2, -1, -2, -2, -2, 1, -3, -2, 5, -2, 2, 2, -2, -2, + -2, -2, -1, 0, 4, -5, -1, -1, -3, 0, 2, -5, -2, 0, -2, 5, -3, -1, 1, -1, 1, 3, + 0, 0, -2, -3, -4, -2, -2, -4, -3, 2, -4, -2, 2, -3, 6, 4, -3, -3, -2, -3, -3, + -2, 2, -2, -1, -1, -2, -3, -2, 0, -3, -2, 2, -1, 4, 6, -2, -2, -1, 0, -2, -1, + 2, -4, -2, 0, -4, 2, 1, -3, 0, 2, -2, 1, -3, -2, 2, 0, 1, 0, 1, 0, -2, -4, -2, + 1, -4, -1, -1, -5, 0, 0, -2, -1, -3, -2, 0, 6, 0, 0, 1, 0, -1, -6, -5, 0, -4, + 2, 2, -5, -1, 3, -2, 1, -2, -1, 1, 0, 4, 1, -1, -1, -2, -5, -4, -2, -4, -1, -1, + -4, -3, 2, -2, 3, -3, 0, 0, 0, 1, 6, 0, -1, -2, -4, 0, 1, 0, 0, 0, -3, 1, -1, + -1, 0, -3, -2, 1, 1, -1, 0, 2, 1, -1, -4, -2, 1, -2, 0, 0, -3, 0, -1, 0, 0, -2, + -1, 0, 0, -1, -1, 1, 3, 0, -5, -3, 0, -2, -2, -2, -1, -1, -2, 4, -2, 2, 2, -2, + -1, -2, -2, -1, 0, 4, -6, -2, -6, -7, -5, -5, 0, -7, -3, -5, -3, -2, -4, -4, + -6, -5, -4, -4, -5, -6, 17, 0, -3, -4, -4, -3, 7, -5, 2, -1, -4, -1, -2, -2, + -5, -4, 0, -2, -3, -2, 0, 10, ] } diff --git a/src/survival.mbt b/src/survival.mbt index 9ecf54ed..7f4d2196 100644 --- a/src/survival.mbt +++ b/src/survival.mbt @@ -73,7 +73,7 @@ pub fn SurvRecord::new( time : Double, event : Bool, group : String, - covariates : Array[Double] + covariates : Array[Double], ) -> SurvRecord { SurvRecord::{ time, event, group, covariates } } @@ -113,7 +113,7 @@ pub fn SurvData::new() -> SurvData { records: Array::new(), n_samples: 0, n_groups: 0, - group_names: Array::new() + group_names: Array::new(), } } @@ -143,7 +143,7 @@ pub fn SurvData::from_records(records : Array[SurvRecord]) -> SurvData { records, n_samples: n, n_groups: group_names.length(), - group_names + group_names, } } @@ -194,7 +194,10 @@ pub fn SurvData::add_record(self : SurvData, record : SurvRecord) -> Unit { ///| /// Return records belonging to a given group. -pub fn SurvData::filter_by_group(self : SurvData, group : String) -> Array[SurvRecord] { +pub fn SurvData::filter_by_group( + self : SurvData, + group : String, +) -> Array[SurvRecord] { let result : Array[SurvRecord] = Array::new() let recs = self.records let n = recs.length() @@ -239,8 +242,15 @@ pub fn survival_normal_cdf(z : Double) -> Double { let d = 0.3989423 * @math.exp(-z * z / 2.0) let p = d * t * - (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.3302744)))) - if z > 0.0 { 1.0 - p } else { p } + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.3302744))) + ) + if z > 0.0 { + 1.0 - p + } else { + p + } } ///| @@ -268,18 +278,12 @@ pub fn survival_chi_square_p_value(chi_sq : Double, df : Int) -> Double { } if df == 1 { let p = 2.0 * (1.0 - survival_normal_cdf(chi_sq.sqrt())) - return if p.is_nan() || p < 0.0 { - 0.0 - } else if p > 1.0 { - 1.0 - } else { - p - } + return if p.is_nan() || p < 0.0 { 0.0 } else if p > 1.0 { 1.0 } else { p } } // Wilson-Hilferty approximation for general df let df_d = df.to_double() let z = (@math.pow(chi_sq / df_d, 1.0 / 3.0) - (1.0 - 2.0 / (9.0 * df_d))) / - ((2.0 / (9.0 * df_d)).sqrt()) + (2.0 / (9.0 * df_d)).sqrt() let p = 1.0 - survival_normal_cdf(z) if p.is_nan() || p < 0.0 { 0.0 @@ -299,7 +303,7 @@ pub fn survival_chi_square_p_value(chi_sq : Double, df : Int) -> Double { fn survival_solve_linear( a : Array[Array[Double]], b : Array[Double], - n : Int + n : Int, ) -> Array[Double] { if n == 0 { return Array::new() @@ -397,7 +401,11 @@ fn survival_invert_matrix(m : Array[Array[Double]]) -> Array[Array[Double]] { } let raw_piv = aug[col][col] let piv_val = if raw_piv.abs() < 1.0e-12 { - if raw_piv >= 0.0 { 1.0e-12 } else { -1.0e-12 } + if raw_piv >= 0.0 { + 1.0e-12 + } else { + -1.0e-12 + } } else { raw_piv } @@ -456,7 +464,10 @@ fn survival_fmt(v : Double) -> String { ///| /// Compute the Kaplan-Meier survival curve for a specific group. /// Standard error uses Greenwood's formula. -pub fn survival_kaplan_meier(data : SurvData, group : String) -> KaplanMeierResult { +pub fn survival_kaplan_meier( + data : SurvData, + group : String, +) -> KaplanMeierResult { let group_records = data.filter_by_group(group) let n = group_records.length() @@ -480,7 +491,7 @@ pub fn survival_kaplan_meier(data : SurvData, group : String) -> KaplanMeierResu std_err: std_err_arr, n_at_risk: n_at_risk_arr, n_events: n_events_arr, - group + group, } } @@ -514,8 +525,7 @@ pub fn survival_kaplan_meier(data : SurvData, group : String) -> KaplanMeierResu surv = surv * (1.0 - d.to_double() / n_at_risk.to_double()) if n_at_risk > d { cum_var = cum_var + - d.to_double() / - (n_at_risk.to_double() * (n_at_risk - d).to_double()) + d.to_double() / (n_at_risk.to_double() * (n_at_risk - d).to_double()) } let se = surv * cum_var.sqrt() times.push(t) @@ -533,7 +543,7 @@ pub fn survival_kaplan_meier(data : SurvData, group : String) -> KaplanMeierResu std_err: std_err_arr, n_at_risk: n_at_risk_arr, n_events: n_events_arr, - group + group, } } @@ -546,7 +556,7 @@ pub fn survival_kaplan_meier(data : SurvData, group : String) -> KaplanMeierResu pub fn survival_log_rank( data : SurvData, group1 : String, - group2 : String + group2 : String, ) -> LogRankResult { let r1 = data.filter_by_group(group1) let r2 = data.filter_by_group(group2) @@ -624,11 +634,7 @@ pub fn survival_log_rank( i = j } - let chi_sq = if v > 0.0 { - (o1 - e1) * (o1 - e1) / v - } else { - 0.0 - } + let chi_sq = if v > 0.0 { (o1 - e1) * (o1 - e1) / v } else { 0.0 } let p = survival_chi_square_p_value(chi_sq, 1) LogRankResult::{ chi_square: chi_sq, @@ -637,7 +643,7 @@ pub fn survival_log_rank( group1, group2, n1: n1_total, - n2: n2_total + n2: n2_total, } } @@ -655,7 +661,7 @@ fn survival_cox_score_info( order : Array[Int], beta : Array[Double], n : Int, - p : Int + p : Int, ) -> (Array[Double], Array[Array[Double]], Double) { let u : Array[Double] = Array::make(p, 0.0) let info : Array[Array[Double]] = Array::new() @@ -757,7 +763,7 @@ fn survival_cox_score_info( /// partial likelihood. Ties are handled with the Breslow approximation. pub fn survival_cox_fit( data : SurvData, - covariate_names : Array[String] + covariate_names : Array[String], ) -> CoxResult { let records = data.records() let n = records.length() @@ -773,7 +779,7 @@ pub fn survival_cox_fit( covariate_names, log_likelihood: 0.0, n_samples: n, - converged: true + converged: true, } } @@ -833,7 +839,9 @@ pub fn survival_cox_fit( } // Final score/info/loglik at the converged beta. - let final_triple = survival_cox_score_info(times, events, z, order, beta, n, p) + let final_triple = survival_cox_score_info( + times, events, z, order, beta, n, p, + ) let final_info = final_triple.1 let final_ll = final_triple.2 let inv_info = survival_invert_matrix(final_info) @@ -862,7 +870,7 @@ pub fn survival_cox_fit( covariate_names, log_likelihood: final_ll, n_samples: n, - converged + converged, } } diff --git a/src/system_piper.mbt b/src/system_piper.mbt index a01336a0..230bb6aa 100644 --- a/src/system_piper.mbt +++ b/src/system_piper.mbt @@ -124,7 +124,11 @@ pub fn Pipeline::set_description(self : Pipeline, desc : String) -> Pipeline { ///| /// Set a global parameter. -pub fn Pipeline::set_param(self : Pipeline, key : String, value : String) -> Pipeline { +pub fn Pipeline::set_param( + self : Pipeline, + key : String, + value : String, +) -> Pipeline { let params = self.global_params.copy() params[key] = value Pipeline::{ @@ -271,15 +275,21 @@ pub fn Pipeline::get_skipped_count(self : Pipeline) -> Int { /// Get the overall pipeline progress as a percentage. pub fn Pipeline::get_progress(self : Pipeline) -> Double { let n = self.steps.length() - if n == 0 { return 0.0 } + if n == 0 { + return 0.0 + } let completed = self.get_completed_count() let skipped = self.get_skipped_count() - ((completed.to_double() + skipped.to_double()) / n.to_double()) * 100.0 + (completed.to_double() + skipped.to_double()) / n.to_double() * 100.0 } ///| /// Create a new pipeline step. -pub fn PipelineStep::new(step_id : String, name : String, command : String) -> PipelineStep { +pub fn PipelineStep::new( + step_id : String, + name : String, + command : String, +) -> PipelineStep { PipelineStep::{ step_id, name, @@ -299,7 +309,10 @@ pub fn PipelineStep::new(step_id : String, name : String, command : String) -> P ///| /// Set step description. -pub fn PipelineStep::set_description(self : PipelineStep, desc : String) -> PipelineStep { +pub fn PipelineStep::set_description( + self : PipelineStep, + desc : String, +) -> PipelineStep { PipelineStep::{ step_id: self.step_id, name: self.name, @@ -319,7 +332,10 @@ pub fn PipelineStep::set_description(self : PipelineStep, desc : String) -> Pipe ///| /// Set step arguments. -pub fn PipelineStep::set_args(self : PipelineStep, args : Array[String]) -> PipelineStep { +pub fn PipelineStep::set_args( + self : PipelineStep, + args : Array[String], +) -> PipelineStep { PipelineStep::{ step_id: self.step_id, name: self.name, @@ -339,7 +355,10 @@ pub fn PipelineStep::set_args(self : PipelineStep, args : Array[String]) -> Pipe ///| /// Add a dependency. -pub fn PipelineStep::add_dependency(self : PipelineStep, dep : String) -> PipelineStep { +pub fn PipelineStep::add_dependency( + self : PipelineStep, + dep : String, +) -> PipelineStep { let deps = self.dependencies.copy() deps.push(dep) PipelineStep::{ @@ -361,7 +380,10 @@ pub fn PipelineStep::add_dependency(self : PipelineStep, dep : String) -> Pipeli ///| /// Add an input file. -pub fn PipelineStep::add_input(self : PipelineStep, file : String) -> PipelineStep { +pub fn PipelineStep::add_input( + self : PipelineStep, + file : String, +) -> PipelineStep { let inputs = self.input_files.copy() inputs.push(file) PipelineStep::{ @@ -383,7 +405,10 @@ pub fn PipelineStep::add_input(self : PipelineStep, file : String) -> PipelineSt ///| /// Add an output file. -pub fn PipelineStep::add_output(self : PipelineStep, file : String) -> PipelineStep { +pub fn PipelineStep::add_output( + self : PipelineStep, + file : String, +) -> PipelineStep { let outputs = self.output_files.copy() outputs.push(file) PipelineStep::{ @@ -443,14 +468,16 @@ pub fn PipelineStep::get_dependencies(self : PipelineStep) -> Array[String] { /// Check if all dependencies of a step are completed. pub fn Pipeline::can_run_step(self : Pipeline, step : PipelineStep) -> Bool { let deps = step.dependencies - if deps.length() == 0 { return true } + if deps.length() == 0 { + return true + } let mut i = 0 while i < deps.length() { let dep_step = self.get_step(deps[i]) match dep_step.status { StepStatus::Completed => () - _ => { return false } + _ => return false } i = i + 1 } @@ -459,7 +486,11 @@ pub fn Pipeline::can_run_step(self : Pipeline, step : PipelineStep) -> Bool { ///| /// Generate a pipeline configuration. -pub fn PipelineConfig::new(work_dir : String, input_dir : String, output_dir : String) -> PipelineConfig { +pub fn PipelineConfig::new( + work_dir : String, + input_dir : String, + output_dir : String, +) -> PipelineConfig { PipelineConfig::{ work_dir, input_dir, @@ -472,7 +503,10 @@ pub fn PipelineConfig::new(work_dir : String, input_dir : String, output_dir : S ///| /// Set number of cores. -pub fn PipelineConfig::set_cores(self : PipelineConfig, cores : Int) -> PipelineConfig { +pub fn PipelineConfig::set_cores( + self : PipelineConfig, + cores : Int, +) -> PipelineConfig { PipelineConfig::{ work_dir: self.work_dir, input_dir: self.input_dir, @@ -527,7 +561,13 @@ pub fn Pipeline::summary(self : Pipeline) -> String { let mut i = 0 while i < self.steps.length() { let step = self.steps[i] - s = s + " [" + step.status.to_string() + "] " + step.step_id + ": " + step.name + s = s + + " [" + + step.status.to_string() + + "] " + + step.step_id + + ": " + + step.name if step.duration_seconds > 0.0 { s = s + " (" + step.duration_seconds.to_string() + "s)" } @@ -542,20 +582,25 @@ pub fn Pipeline::summary(self : Pipeline) -> String { /// Generate an ASCII visualization of the pipeline. pub fn Pipeline::to_ascii(self : Pipeline) -> String { let mut result = "" - result = result + "╔══════════════════════════════════════════╗\n" + result = result + + "╔══════════════════════════════════════════╗\n" result = result + "║ Pipeline: " + self.name + "\n" result = result + "║ ID: " + self.pipeline_id + "\n" result = result + "║ Steps: " + self.steps.length().to_string() + "\n" - result = result + "╚══════════════════════════════════════════╝\n\n" + result = result + + "╚══════════════════════════════════════════╝\n\n" let progress = self.get_progress() let progress_bar_len = 20 - let filled = ((progress / 100.0) * progress_bar_len.to_double()).to_int() + let filled = (progress / 100.0 * progress_bar_len.to_double()).to_int() let mut bar = "[" let mut i = 0 while i < progress_bar_len { - if i < filled { bar = bar + "█" } - else { bar = bar + "░" } + if i < filled { + bar = bar + "█" + } else { + bar = bar + "░" + } i = i + 1 } bar = bar + "]" @@ -623,56 +668,90 @@ pub fn Pipeline::to_ascii(self : Pipeline) -> String { ///| /// Create a sample RNA-seq analysis pipeline. pub fn pipeline_sample() -> Pipeline { - let mut pipe = Pipeline::new("rnaseq_pipeline_v1", "RNA-Seq Differential Expression Pipeline") - pipe = pipe.set_description("Standard RNA-Seq analysis pipeline: QC -> Alignment -> Quantification -> DE Analysis -> Functional Enrichment") + let mut pipe = Pipeline::new( + "rnaseq_pipeline_v1", "RNA-Seq Differential Expression Pipeline", + ) + pipe = pipe.set_description( + "Standard RNA-Seq analysis pipeline: QC -> Alignment -> Quantification -> DE Analysis -> Functional Enrichment", + ) // Step 1: QC let step1 = PipelineStep::new("qc", "Quality Control", "fastqc") - let step1b = step1.set_args(["-o", "qc_output", "--extract", "raw_data/*.fastq.gz"]) + let step1b = step1.set_args([ + "-o", "qc_output", "--extract", "raw_data/*.fastq.gz", + ]) let step1c = step1b.add_input("raw_data/sample1_R1.fastq.gz") let step1d = step1c.add_input("raw_data/sample1_R2.fastq.gz") let step1e = step1d.add_output("qc_output/sample1_fastqc.html") - let step1_final = step1e.set_description("Quality control of raw reads using FastQC") + let step1_final = step1e.set_description( + "Quality control of raw reads using FastQC", + ) pipe = pipe.add_step(step1_final) // Step 2: Trimming let step2 = PipelineStep::new("trim", "Adapter Trimming", "trimmomatic") - let step2b = step2.set_args(["PE", "-phred33", "raw_data/sample1_R1.fastq.gz", "raw_data/sample1_R2.fastq.gz", "trimmed/sample1_R1_trimmed.fq.gz", "trimmed/sample1_R2_trimmed.fq.gz", "ILLUMINACLIP:adapters.fa:2:30:10"]) + let step2b = step2.set_args([ + "PE", "-phred33", "raw_data/sample1_R1.fastq.gz", "raw_data/sample1_R2.fastq.gz", + "trimmed/sample1_R1_trimmed.fq.gz", "trimmed/sample1_R2_trimmed.fq.gz", "ILLUMINACLIP:adapters.fa:2:30:10", + ]) let step2c = step2b.add_dependency("qc") let step2d = step2c.add_output("trimmed/sample1_R1_trimmed.fq.gz") let step2e = step2d.add_output("trimmed/sample1_R2_trimmed.fq.gz") - let step2_final = step2e.set_description("Adapter and quality trimming with Trimmomatic") + let step2_final = step2e.set_description( + "Adapter and quality trimming with Trimmomatic", + ) pipe = pipe.add_step(step2_final) // Step 3: Alignment let step3 = PipelineStep::new("align", "Read Alignment", "hisat2") - let step3b = step3.set_args(["-x", "genome_index/genome", "-1", "trimmed/sample1_R1_trimmed.fq.gz", "-2", "trimmed/sample1_R2_trimmed.fq.gz", "-S", "alignment/sample1.sam"]) + let step3b = step3.set_args([ + "-x", "genome_index/genome", "-1", "trimmed/sample1_R1_trimmed.fq.gz", "-2", + "trimmed/sample1_R2_trimmed.fq.gz", "-S", "alignment/sample1.sam", + ]) let step3c = step3b.add_dependency("trim") let step3d = step3c.add_output("alignment/sample1.sam") let step3e = step3d.add_output("alignment/sample1.bam") - let step3_final = step3e.set_description("Read alignment to reference genome using HISAT2") + let step3_final = step3e.set_description( + "Read alignment to reference genome using HISAT2", + ) pipe = pipe.add_step(step3_final) // Step 4: Quantification - let step4 = PipelineStep::new("quantify", "Gene Quantification", "featureCounts") - let step4b = step4.set_args(["-a", "annotation.gtf", "-o", "counts/gene_counts.txt", "alignment/sample1.bam"]) + let step4 = PipelineStep::new( + "quantify", "Gene Quantification", "featureCounts", + ) + let step4b = step4.set_args([ + "-a", "annotation.gtf", "-o", "counts/gene_counts.txt", "alignment/sample1.bam", + ]) let step4c = step4b.add_dependency("align") let step4d = step4c.add_output("counts/gene_counts.txt") - let step4_final = step4d.set_description("Gene-level quantification using featureCounts") + let step4_final = step4d.set_description( + "Gene-level quantification using featureCounts", + ) pipe = pipe.add_step(step4_final) // Step 5: Differential Expression - let step5 = PipelineStep::new("de_analysis", "Differential Expression", "DESeq2") - let step5b = step5.set_args(["-i", "counts/gene_counts.txt", "-c", "metadata.csv", "-o", "de_results/"]) + let step5 = PipelineStep::new( + "de_analysis", "Differential Expression", "DESeq2", + ) + let step5b = step5.set_args([ + "-i", "counts/gene_counts.txt", "-c", "metadata.csv", "-o", "de_results/", + ]) let step5c = step5b.add_dependency("quantify") let step5d = step5c.add_output("de_results/deseq2_results.csv") let step5e = step5d.add_output("de_results/volcano_plot.png") - let step5_final = step5e.set_description("Differential expression analysis using DESeq2") + let step5_final = step5e.set_description( + "Differential expression analysis using DESeq2", + ) pipe = pipe.add_step(step5_final) // Step 6: Enrichment - let step6 = PipelineStep::new("enrich", "Functional Enrichment", "clusterProfiler") - let step6b = step6.set_args(["-i", "de_results/deseq2_results.csv", "-o", "enrichment/"]) + let step6 = PipelineStep::new( + "enrich", "Functional Enrichment", "clusterProfiler", + ) + let step6b = step6.set_args([ + "-i", "de_results/deseq2_results.csv", "-o", "enrichment/", + ]) let step6c = step6b.add_dependency("de_analysis") let step6d = step6c.add_output("enrichment/go_terms.csv") let step6e = step6d.add_output("enrichment/pathways.csv") @@ -686,4 +765,4 @@ pub fn pipeline_sample() -> Pipeline { pipe = pipe.set_param("sequencer", "Illumina NovaSeq") pipe -} \ No newline at end of file +} diff --git a/src/tab_io.mbt b/src/tab_io.mbt index 6e6f24ea..17633973 100644 --- a/src/tab_io.mbt +++ b/src/tab_io.mbt @@ -74,12 +74,14 @@ pub fn parse_tab(content : String) -> Array[SeqRecord] raise SeqIOError { } } - records.push(SeqRecord::new( - Seq::new(seq_buf.to_string()), - id=id, - name=id, - description=id, - )) + records.push( + SeqRecord::new( + Seq::new(seq_buf.to_string()), + id~, + name=id, + description=id, + ), + ) } records } diff --git a/src/taxonomy.mbt b/src/taxonomy.mbt index 359c29f0..2f68b811 100644 --- a/src/taxonomy.mbt +++ b/src/taxonomy.mbt @@ -15,7 +15,11 @@ pub struct Taxon { } ///| -pub fn Taxon::new(tax_id : String, parent_tax_id : String, rank : String) -> Taxon { +pub fn Taxon::new( + tax_id : String, + parent_tax_id : String, + rank : String, +) -> Taxon { Taxon::{ tax_id, parent_tax_id, @@ -23,7 +27,7 @@ pub fn Taxon::new(tax_id : String, parent_tax_id : String, rank : String) -> Tax scientific_name: "", common_names: Array::new(), synonyms: Array::new(), - lineage: Array::new() + lineage: Array::new(), } } @@ -36,7 +40,7 @@ pub fn Taxon::set_scientific_name(self : Taxon, name : String) -> Taxon { scientific_name: name, common_names: self.common_names, synonyms: self.synonyms, - lineage: self.lineage + lineage: self.lineage, } } @@ -51,7 +55,7 @@ pub fn Taxon::add_common_name(self : Taxon, name : String) -> Taxon { scientific_name: self.scientific_name, common_names: new_names, synonyms: self.synonyms, - lineage: self.lineage + lineage: self.lineage, } } @@ -66,7 +70,7 @@ pub fn Taxon::add_synonym(self : Taxon, name : String) -> Taxon { scientific_name: self.scientific_name, common_names: self.common_names, synonyms: new_synonyms, - lineage: self.lineage + lineage: self.lineage, } } @@ -79,7 +83,7 @@ pub fn Taxon::set_lineage(self : Taxon, lineage : Array[String]) -> Taxon { scientific_name: self.scientific_name, common_names: self.common_names, synonyms: self.synonyms, - lineage: lineage + lineage, } } @@ -93,12 +97,15 @@ pub struct TaxonomyDatabase { pub fn TaxonomyDatabase::new() -> TaxonomyDatabase { TaxonomyDatabase::{ taxa: Map([], capacity=0), - name_to_taxid: Map([], capacity=0) + name_to_taxid: Map([], capacity=0), } } ///| -pub fn TaxonomyDatabase::add_taxon(self : TaxonomyDatabase, taxon : Taxon) -> TaxonomyDatabase { +pub fn TaxonomyDatabase::add_taxon( + self : TaxonomyDatabase, + taxon : Taxon, +) -> TaxonomyDatabase { self.taxa.set(taxon.tax_id, taxon) if taxon.scientific_name != "" { self.name_to_taxid.set(to_lowercase(taxon.scientific_name), taxon.tax_id) @@ -107,7 +114,10 @@ pub fn TaxonomyDatabase::add_taxon(self : TaxonomyDatabase, taxon : Taxon) -> Ta } ///| -pub fn TaxonomyDatabase::get_taxon(self : TaxonomyDatabase, tax_id : String) -> Taxon? { +pub fn TaxonomyDatabase::get_taxon( + self : TaxonomyDatabase, + tax_id : String, +) -> Taxon? { if self.taxa.contains(tax_id) { Some(self.taxa.get(tax_id).unwrap()) } else { @@ -116,7 +126,10 @@ pub fn TaxonomyDatabase::get_taxon(self : TaxonomyDatabase, tax_id : String) -> } ///| -pub fn TaxonomyDatabase::get_taxid_by_name(self : TaxonomyDatabase, name : String) -> String? { +pub fn TaxonomyDatabase::get_taxid_by_name( + self : TaxonomyDatabase, + name : String, +) -> String? { if self.name_to_taxid.contains(to_lowercase(name)) { Some(self.name_to_taxid.get(to_lowercase(name)).unwrap()) } else { @@ -125,14 +138,19 @@ pub fn TaxonomyDatabase::get_taxid_by_name(self : TaxonomyDatabase, name : Strin } ///| -pub fn TaxonomyDatabase::get_ancestors(self : TaxonomyDatabase, tax_id : String) -> Array[Taxon] { +pub fn TaxonomyDatabase::get_ancestors( + self : TaxonomyDatabase, + tax_id : String, +) -> Array[Taxon] { let result : Array[Taxon] = Array::new() let mut current_id = tax_id - + while current_id != "" && current_id != "1" && current_id != "0" { match self.get_taxon(current_id) { - Some(taxon) => { - if taxon.parent_tax_id != "" && taxon.parent_tax_id != "1" && taxon.parent_tax_id != "0" { + Some(taxon) => + if taxon.parent_tax_id != "" && + taxon.parent_tax_id != "1" && + taxon.parent_tax_id != "0" { match self.get_taxon(taxon.parent_tax_id) { Some(parent) => { result.push(parent) @@ -143,23 +161,29 @@ pub fn TaxonomyDatabase::get_ancestors(self : TaxonomyDatabase, tax_id : String) } else { break } - } None => break } } - + result } ///| -pub fn TaxonomyDatabase::get_descendants(self : TaxonomyDatabase, tax_id : String) -> Array[Taxon] { +pub fn TaxonomyDatabase::get_descendants( + self : TaxonomyDatabase, + tax_id : String, +) -> Array[Taxon] { let result : Array[Taxon] = Array::new() ignore(find_descendants(self, tax_id, result)) result } ///| -fn find_descendants(db : TaxonomyDatabase, parent_id : String, result : Array[Taxon]) -> Unit { +fn find_descendants( + db : TaxonomyDatabase, + parent_id : String, + result : Array[Taxon], +) -> Unit { let entries = db.taxa.iter().collect() let mut i = 0 while i < entries.length() { @@ -173,26 +197,32 @@ fn find_descendants(db : TaxonomyDatabase, parent_id : String, result : Array[Ta } ///| -pub fn TaxonomyDatabase::get_lineage(self : TaxonomyDatabase, tax_id : String) -> Array[String] { +pub fn TaxonomyDatabase::get_lineage( + self : TaxonomyDatabase, + tax_id : String, +) -> Array[String] { let ancestors = self.get_ancestors(tax_id) let result : Array[String] = Array::new() - + let mut i = ancestors.length() - 1 while i >= 0 { result.push(ancestors[i].scientific_name) i = i - 1 } - + match self.get_taxon(tax_id) { Some(taxon) => result.push(taxon.scientific_name) None => () } - + result } ///| -pub fn TaxonomyDatabase::get_rank(self : TaxonomyDatabase, tax_id : String) -> String? { +pub fn TaxonomyDatabase::get_rank( + self : TaxonomyDatabase, + tax_id : String, +) -> String? { match self.get_taxon(tax_id) { Some(taxon) => Some(taxon.rank) None => None @@ -200,7 +230,10 @@ pub fn TaxonomyDatabase::get_rank(self : TaxonomyDatabase, tax_id : String) -> S } ///| -pub fn TaxonomyDatabase::get_scientific_name(self : TaxonomyDatabase, tax_id : String) -> String? { +pub fn TaxonomyDatabase::get_scientific_name( + self : TaxonomyDatabase, + tax_id : String, +) -> String? { match self.get_taxon(tax_id) { Some(taxon) => Some(taxon.scientific_name) None => None @@ -208,7 +241,10 @@ pub fn TaxonomyDatabase::get_scientific_name(self : TaxonomyDatabase, tax_id : S } ///| -pub fn TaxonomyDatabase::get_common_names(self : TaxonomyDatabase, tax_id : String) -> Array[String] { +pub fn TaxonomyDatabase::get_common_names( + self : TaxonomyDatabase, + tax_id : String, +) -> Array[String] { match self.get_taxon(tax_id) { Some(taxon) => taxon.common_names None => Array::new() @@ -216,7 +252,10 @@ pub fn TaxonomyDatabase::get_common_names(self : TaxonomyDatabase, tax_id : Stri } ///| -pub fn TaxonomyDatabase::get_synonyms(self : TaxonomyDatabase, tax_id : String) -> Array[String] { +pub fn TaxonomyDatabase::get_synonyms( + self : TaxonomyDatabase, + tax_id : String, +) -> Array[String] { match self.get_taxon(tax_id) { Some(taxon) => taxon.synonyms None => Array::new() @@ -224,7 +263,10 @@ pub fn TaxonomyDatabase::get_synonyms(self : TaxonomyDatabase, tax_id : String) } ///| -pub fn parse_nodes_dmp(db : TaxonomyDatabase, content : String) -> TaxonomyDatabase { +pub fn parse_nodes_dmp( + db : TaxonomyDatabase, + content : String, +) -> TaxonomyDatabase { let lines = split_by_char(content, '\n'.to_int()) let mut i = 0 while i < lines.length() { @@ -244,7 +286,7 @@ pub fn parse_nodes_dmp(db : TaxonomyDatabase, content : String) -> TaxonomyDatab let tax_id = pipe_fields[0] let parent_tax_id = pipe_fields[1] let rank = if pipe_fields.length() > 2 { pipe_fields[2] } else { "" } - + let taxon = Taxon::new(tax_id, parent_tax_id, rank) ignore(db.add_taxon(taxon)) } @@ -255,7 +297,10 @@ pub fn parse_nodes_dmp(db : TaxonomyDatabase, content : String) -> TaxonomyDatab } ///| -pub fn parse_names_dmp(db : TaxonomyDatabase, content : String) -> TaxonomyDatabase { +pub fn parse_names_dmp( + db : TaxonomyDatabase, + content : String, +) -> TaxonomyDatabase { let lines = split_by_char(content, '\n'.to_int()) let mut i = 0 while i < lines.length() { @@ -274,11 +319,15 @@ pub fn parse_names_dmp(db : TaxonomyDatabase, content : String) -> TaxonomyDatab if pipe_fields.length() >= 4 { let tax_id = pipe_fields[0] let name = pipe_fields[1] - let name_class = if pipe_fields.length() > 3 { pipe_fields[3] } else { "" } - + let name_class = if pipe_fields.length() > 3 { + pipe_fields[3] + } else { + "" + } + if db.taxa.contains(tax_id) { let taxon = db.taxa.get(tax_id).unwrap() - + if name_class == "scientific name" { let updated = taxon.set_scientific_name(name) db.taxa.set(tax_id, updated) @@ -299,9 +348,11 @@ pub fn parse_names_dmp(db : TaxonomyDatabase, content : String) -> TaxonomyDatab ///| - ///| -pub fn parse_taxonomy_database(nodes_content : String, names_content : String) -> TaxonomyDatabase { +pub fn parse_taxonomy_database( + nodes_content : String, + names_content : String, +) -> TaxonomyDatabase { let db = TaxonomyDatabase::new() let db_with_nodes = parse_nodes_dmp(db, nodes_content) parse_names_dmp(db_with_nodes, names_content) @@ -310,64 +361,95 @@ pub fn parse_taxonomy_database(nodes_content : String, names_content : String) - ///| pub fn create_example_taxonomy() -> TaxonomyDatabase { let db = TaxonomyDatabase::new() - + let root = Taxon::new("1", "0", "no rank").set_scientific_name("root") ignore(db.add_taxon(root)) - - let cellular_organisms = Taxon::new("131567", "1", "no rank").set_scientific_name("cellular organisms") + + let cellular_organisms = Taxon::new("131567", "1", "no rank").set_scientific_name( + "cellular organisms", + ) ignore(db.add_taxon(cellular_organisms)) - - let eukaryota = Taxon::new("2759", "131567", "superkingdom").set_scientific_name("Eukaryota") + + let eukaryota = Taxon::new("2759", "131567", "superkingdom").set_scientific_name( + "Eukaryota", + ) ignore(db.add_taxon(eukaryota)) - - let metazoa = Taxon::new("33208", "2759", "kingdom").set_scientific_name("Metazoa") + + let metazoa = Taxon::new("33208", "2759", "kingdom").set_scientific_name( + "Metazoa", + ) ignore(db.add_taxon(metazoa)) - - let chordata = Taxon::new("7711", "33208", "phylum").set_scientific_name("Chordata") + + let chordata = Taxon::new("7711", "33208", "phylum").set_scientific_name( + "Chordata", + ) ignore(db.add_taxon(chordata)) - - let mammalia = Taxon::new("40674", "7711", "class").set_scientific_name("Mammalia") + + let mammalia = Taxon::new("40674", "7711", "class").set_scientific_name( + "Mammalia", + ) ignore(db.add_taxon(mammalia)) - - let primates = Taxon::new("9443", "40674", "order").set_scientific_name("Primates") + + let primates = Taxon::new("9443", "40674", "order").set_scientific_name( + "Primates", + ) ignore(db.add_taxon(primates)) - - let hominidae = Taxon::new("9604", "9443", "family").set_scientific_name("Hominidae") + + let hominidae = Taxon::new("9604", "9443", "family").set_scientific_name( + "Hominidae", + ) ignore(db.add_taxon(hominidae)) - + let homo = Taxon::new("9605", "9604", "genus").set_scientific_name("Homo") ignore(db.add_taxon(homo)) - - let sapiens = Taxon::new("9606", "9605", "species").set_scientific_name("Homo sapiens") + + let sapiens = Taxon::new("9606", "9605", "species").set_scientific_name( + "Homo sapiens", + ) let sapiens_with_common = sapiens.add_common_name("human") - let sapiens_with_synonym = sapiens_with_common.add_synonym("Homo sapiens sapiens") + let sapiens_with_synonym = sapiens_with_common.add_synonym( + "Homo sapiens sapiens", + ) ignore(db.add_taxon(sapiens_with_synonym)) - + let pan = Taxon::new("9598", "9604", "genus").set_scientific_name("Pan") ignore(db.add_taxon(pan)) - - let troglodytes = Taxon::new("9599", "9598", "species").set_scientific_name("Pan troglodytes") + + let troglodytes = Taxon::new("9599", "9598", "species").set_scientific_name( + "Pan troglodytes", + ) let troglodytes_with_common = troglodytes.add_common_name("chimpanzee") ignore(db.add_taxon(troglodytes_with_common)) - - let bacteria = Taxon::new("2", "131567", "superkingdom").set_scientific_name("Bacteria") + + let bacteria = Taxon::new("2", "131567", "superkingdom").set_scientific_name( + "Bacteria", + ) ignore(db.add_taxon(bacteria)) - - let proteobacteria = Taxon::new("1224", "2", "phylum").set_scientific_name("Proteobacteria") + + let proteobacteria = Taxon::new("1224", "2", "phylum").set_scientific_name( + "Proteobacteria", + ) ignore(db.add_taxon(proteobacteria)) - - let escherichia = Taxon::new("561", "1224", "genus").set_scientific_name("Escherichia") + + let escherichia = Taxon::new("561", "1224", "genus").set_scientific_name( + "Escherichia", + ) ignore(db.add_taxon(escherichia)) - - let coli = Taxon::new("562", "561", "species").set_scientific_name("Escherichia coli") + + let coli = Taxon::new("562", "561", "species").set_scientific_name( + "Escherichia coli", + ) let coli_with_common = coli.add_common_name("E. coli") ignore(db.add_taxon(coli_with_common)) - + db } ///| -pub fn TaxonomyDatabase::get_taxa_by_rank(self : TaxonomyDatabase, rank : String) -> Array[Taxon] { +pub fn TaxonomyDatabase::get_taxa_by_rank( + self : TaxonomyDatabase, + rank : String, +) -> Array[Taxon] { let result : Array[Taxon] = Array::new() let entries = self.taxa.iter().collect() let mut i = 0 @@ -382,12 +464,16 @@ pub fn TaxonomyDatabase::get_taxa_by_rank(self : TaxonomyDatabase, rank : String } ///| -pub fn TaxonomyDatabase::get_all_species(self : TaxonomyDatabase) -> Array[Taxon] { +pub fn TaxonomyDatabase::get_all_species( + self : TaxonomyDatabase, +) -> Array[Taxon] { self.get_taxa_by_rank("species") } ///| -pub fn TaxonomyDatabase::get_all_genera(self : TaxonomyDatabase) -> Array[Taxon] { +pub fn TaxonomyDatabase::get_all_genera( + self : TaxonomyDatabase, +) -> Array[Taxon] { self.get_taxa_by_rank("genus") } @@ -398,7 +484,11 @@ pub fn TaxonomyDatabase::count_taxa(self : TaxonomyDatabase) -> Int { } ///| -pub fn TaxonomyDatabase::is_ancestor(self : TaxonomyDatabase, ancestor_id : String, descendant_id : String) -> Bool { +pub fn TaxonomyDatabase::is_ancestor( + self : TaxonomyDatabase, + ancestor_id : String, + descendant_id : String, +) -> Bool { let ancestors = self.get_ancestors(descendant_id) let mut i = 0 while i < ancestors.length() { @@ -411,10 +501,14 @@ pub fn TaxonomyDatabase::is_ancestor(self : TaxonomyDatabase, ancestor_id : Stri } ///| -pub fn TaxonomyDatabase::get_common_ancestor(self : TaxonomyDatabase, tax_id1 : String, tax_id2 : String) -> String? { +pub fn TaxonomyDatabase::get_common_ancestor( + self : TaxonomyDatabase, + tax_id1 : String, + tax_id2 : String, +) -> String? { let ancestors1 = self.get_ancestors(tax_id1) let ancestors2 = self.get_ancestors(tax_id2) - + let mut i = 0 while i < ancestors1.length() { let mut j = 0 @@ -426,12 +520,16 @@ pub fn TaxonomyDatabase::get_common_ancestor(self : TaxonomyDatabase, tax_id1 : } i = i + 1 } - + None } ///| -pub fn TaxonomyDatabase::get_distance(self : TaxonomyDatabase, tax_id1 : String, tax_id2 : String) -> Int { +pub fn TaxonomyDatabase::get_distance( + self : TaxonomyDatabase, + tax_id1 : String, + tax_id2 : String, +) -> Int { match self.get_common_ancestor(tax_id1, tax_id2) { Some(ancestor_id) => { let dist1 = get_distance_to_ancestor(self, tax_id1, ancestor_id) @@ -443,7 +541,11 @@ pub fn TaxonomyDatabase::get_distance(self : TaxonomyDatabase, tax_id1 : String, } ///| -fn get_distance_to_ancestor(db : TaxonomyDatabase, tax_id : String, ancestor_id : String) -> Int { +fn get_distance_to_ancestor( + db : TaxonomyDatabase, + tax_id : String, + ancestor_id : String, +) -> Int { let ancestors = db.get_ancestors(tax_id) let mut distance = 0 let mut i = 0 @@ -455,4 +557,4 @@ fn get_distance_to_ancestor(db : TaxonomyDatabase, tax_id : String, ancestor_id i = i + 1 } -1 -} \ No newline at end of file +} diff --git a/src/topgo.mbt b/src/topgo.mbt index cc5217ad..6633d54f 100644 --- a/src/topgo.mbt +++ b/src/topgo.mbt @@ -13,7 +13,12 @@ pub struct TopGOTerm { } ///| -pub fn TopGOTerm::new(go_id : String, name : String, namespace : String, level : Int) -> TopGOTerm { +pub fn TopGOTerm::new( + go_id : String, + name : String, + namespace : String, + level : Int, +) -> TopGOTerm { TopGOTerm::{ go_id, name, @@ -21,7 +26,7 @@ pub fn TopGOTerm::new(go_id : String, name : String, namespace : String, level : level, parents: Array::new(), children: Array::new(), - gene_count: 0 + gene_count: 0, } } @@ -33,23 +38,24 @@ pub struct TopGOGraph { ///| pub fn TopGOGraph::new(root : String) -> TopGOGraph { - TopGOGraph::{ - terms: Map([], capacity=1000), - root - } + TopGOGraph::{ terms: Map([], capacity=1000), root } } ///| pub fn TopGOGraph::add_term(self : TopGOGraph, term : TopGOTerm) -> TopGOGraph { let terms = self.terms.copy() terms.set(term.go_id, term) - TopGOGraph::{ terms: terms, root: self.root } + TopGOGraph::{ terms, root: self.root } } ///| -pub fn TopGOGraph::add_edge(self : TopGOGraph, parent_id : String, child_id : String) -> TopGOGraph { +pub fn TopGOGraph::add_edge( + self : TopGOGraph, + parent_id : String, + child_id : String, +) -> TopGOGraph { let terms = self.terms.copy() - + if terms.contains(parent_id) { let parent = terms.get(parent_id).unwrap() let children = parent.children.copy() @@ -60,11 +66,11 @@ pub fn TopGOGraph::add_edge(self : TopGOGraph, parent_id : String, child_id : St namespace: parent.namespace, level: parent.level, parents: parent.parents, - children: children, - gene_count: parent.gene_count + children, + gene_count: parent.gene_count, }) } - + if terms.contains(child_id) { let child = terms.get(child_id).unwrap() let parents = child.parents.copy() @@ -74,13 +80,13 @@ pub fn TopGOGraph::add_edge(self : TopGOGraph, parent_id : String, child_id : St name: child.name, namespace: child.namespace, level: child.level, - parents: parents, + parents, children: child.children, - gene_count: child.gene_count + gene_count: child.gene_count, }) } - - TopGOGraph::{ terms: terms, root: self.root } + + TopGOGraph::{ terms, root: self.root } } ///| @@ -98,66 +104,117 @@ pub struct TopGOEnrichmentResult { } ///| -pub fn TopGOEnrichmentResult::new(go_id : String, term_name : String, namespace : String, level : Int, p_value : Double, adjusted_p_value : Double, enrichment_score : Double, gene_count : Int, total_genes : Int, algorithm : String) -> TopGOEnrichmentResult { - TopGOEnrichmentResult::{ go_id, term_name, namespace, level, p_value, adjusted_p_value, enrichment_score, gene_count, total_genes, algorithm } +pub fn TopGOEnrichmentResult::new( + go_id : String, + term_name : String, + namespace : String, + level : Int, + p_value : Double, + adjusted_p_value : Double, + enrichment_score : Double, + gene_count : Int, + total_genes : Int, + algorithm : String, +) -> TopGOEnrichmentResult { + TopGOEnrichmentResult::{ + go_id, + term_name, + namespace, + level, + p_value, + adjusted_p_value, + enrichment_score, + gene_count, + total_genes, + algorithm, + } } ///| -pub fn topgo_fisher_exact(count : Int, total : Int, bg_count : Int, bg_total : Int) -> Double { +pub fn topgo_fisher_exact( + count : Int, + total : Int, + bg_count : Int, + bg_total : Int, +) -> Double { let mut p = 1.0 let max_x = if count < bg_count { count } else { bg_count } let mut x = count - + while x >= 0 && x <= max_x && p > 0.0 { - let numerator = topgo_factorial(bg_count).to_double() * topgo_factorial(bg_total - bg_count).to_double() * topgo_factorial(total).to_double() * topgo_factorial(bg_total - total).to_double() - let denominator = topgo_factorial(x).to_double() * topgo_factorial(bg_count - x).to_double() * topgo_factorial(total - x).to_double() * topgo_factorial(bg_total - bg_count - total + x).to_double() + let numerator = topgo_factorial(bg_count).to_double() * + topgo_factorial(bg_total - bg_count).to_double() * + topgo_factorial(total).to_double() * + topgo_factorial(bg_total - total).to_double() + let denominator = topgo_factorial(x).to_double() * + topgo_factorial(bg_count - x).to_double() * + topgo_factorial(total - x).to_double() * + topgo_factorial(bg_total - bg_count - total + x).to_double() if denominator > 0.0 { p = p + numerator / denominator } x = x - 1 } - - if p > 1.0 { 1.0 } else { p } + + if p > 1.0 { + 1.0 + } else { + p + } } ///| fn topgo_factorial(n : Int) -> Int { - if n <= 1 { 1 } else { n * topgo_factorial(n - 1) } + if n <= 1 { + 1 + } else { + n * topgo_factorial(n - 1) + } } ///| -pub fn topgo_elim_algorithm(graph : TopGOGraph, genes_of_interest : Array[String], all_genes : Array[String], namespace : String) -> Array[TopGOEnrichmentResult] { +pub fn topgo_elim_algorithm( + graph : TopGOGraph, + genes_of_interest : Array[String], + all_genes : Array[String], + namespace : String, +) -> Array[TopGOEnrichmentResult] { let results : Array[TopGOEnrichmentResult] = Array::new() let visited : Map[String, Bool] = Map([], capacity=1000) - + let queue : Array[String] = Array::new() queue.push(graph.root) - + let mut idx = 0 while idx < queue.length() { let node_id = queue[idx] - + if !visited.contains(node_id) { visited.set(node_id, true) - + if graph.terms.contains(node_id) { let term = graph.terms.get(node_id).unwrap() - + if namespace == "" || term.namespace == namespace { let gene_count = term.gene_count let total_genes = all_genes.length() let bg_count = gene_count let bg_total = total_genes - - let p_value = topgo_fisher_exact(gene_count, genes_of_interest.length(), bg_count, bg_total) - + + let p_value = topgo_fisher_exact( + gene_count, + genes_of_interest.length(), + bg_count, + bg_total, + ) + let children = term.children.copy() let mut j = 0 while j < children.length() { queue.push(children[j]) j = j + 1 } - + let result = TopGOEnrichmentResult::new( term.go_id, term.name, @@ -168,37 +225,47 @@ pub fn topgo_elim_algorithm(graph : TopGOGraph, genes_of_interest : Array[String 1.0 - p_value, gene_count, total_genes, - "elim" + "elim", ) results.push(result) } } } - + idx = idx + 1 } - + results } ///| -pub fn topgo_weight01_algorithm(graph : TopGOGraph, genes_of_interest : Array[String], all_genes : Array[String], namespace : String) -> Array[TopGOEnrichmentResult] { +pub fn topgo_weight01_algorithm( + graph : TopGOGraph, + genes_of_interest : Array[String], + all_genes : Array[String], + namespace : String, +) -> Array[TopGOEnrichmentResult] { let results : Array[TopGOEnrichmentResult] = Array::new() - + for key in graph.terms.keys() { let term = graph.terms.get(key).unwrap() - + if namespace == "" || term.namespace == namespace { let gene_count = term.gene_count let total_genes = all_genes.length() let bg_count = gene_count let bg_total = total_genes - - let p_value = topgo_fisher_exact(gene_count, genes_of_interest.length(), bg_count, bg_total) - + + let p_value = topgo_fisher_exact( + gene_count, + genes_of_interest.length(), + bg_count, + bg_total, + ) + let weight = if term.children.length() > 0 { 0.1 } else { 1.0 } let adjusted_p = p_value * weight - + let result = TopGOEnrichmentResult::new( term.go_id, term.name, @@ -209,36 +276,62 @@ pub fn topgo_weight01_algorithm(graph : TopGOGraph, genes_of_interest : Array[St 1.0 - p_value, gene_count, total_genes, - "weight01" + "weight01", ) results.push(result) } } - + results } ///| pub fn create_example_topgo_graph() -> TopGOGraph { let mut graph = TopGOGraph::new("GO:0008150") - + let root = TopGOTerm::new("GO:0008150", "biological_process", "BP", 0) graph = graph.add_term(root) - + let term1 = TopGOTerm::new("GO:0009987", "cellular_process", "BP", 1) - let term1 = TopGOTerm::{ go_id: term1.go_id, name: term1.name, namespace: term1.namespace, level: term1.level, parents: term1.parents, children: term1.children, gene_count: 50 } + let term1 = TopGOTerm::{ + go_id: term1.go_id, + name: term1.name, + namespace: term1.namespace, + level: term1.level, + parents: term1.parents, + children: term1.children, + gene_count: 50, + } graph = graph.add_term(term1) graph = graph.add_edge("GO:0008150", "GO:0009987") - - let term2 = TopGOTerm::new("GO:0050789", "regulation of biological process", "BP", 1) - let term2 = TopGOTerm::{ go_id: term2.go_id, name: term2.name, namespace: term2.namespace, level: term2.level, parents: term2.parents, children: term2.children, gene_count: 30 } + + let term2 = TopGOTerm::new( + "GO:0050789", "regulation of biological process", "BP", 1, + ) + let term2 = TopGOTerm::{ + go_id: term2.go_id, + name: term2.name, + namespace: term2.namespace, + level: term2.level, + parents: term2.parents, + children: term2.children, + gene_count: 30, + } graph = graph.add_term(term2) graph = graph.add_edge("GO:0008150", "GO:0050789") - + let term3 = TopGOTerm::new("GO:0006810", "transport", "BP", 2) - let term3 = TopGOTerm::{ go_id: term3.go_id, name: term3.name, namespace: term3.namespace, level: term3.level, parents: term3.parents, children: term3.children, gene_count: 20 } + let term3 = TopGOTerm::{ + go_id: term3.go_id, + name: term3.name, + namespace: term3.namespace, + level: term3.level, + parents: term3.parents, + children: term3.children, + gene_count: 20, + } graph = graph.add_term(term3) graph = graph.add_edge("GO:0009987", "GO:0006810") - + graph -} \ No newline at end of file +} diff --git a/src/tradeseq.mbt b/src/tradeseq.mbt index 73fcad44..6756070d 100644 --- a/src/tradeseq.mbt +++ b/src/tradeseq.mbt @@ -75,14 +75,9 @@ pub fn TrajectoryPoint::new( cell_id : String, pseudotime : Double, expression : Array[Double], - condition : String + condition : String, ) -> TrajectoryPoint { - TrajectoryPoint::{ - cell_id, - pseudotime, - expression, - condition - } + TrajectoryPoint::{ cell_id, pseudotime, expression, condition } } ///| @@ -90,14 +85,9 @@ pub fn GeneExpressionData::new( gene_id : String, expression : Array[Double], pseudotime : Array[Double], - condition : Array[String] + condition : Array[String], ) -> GeneExpressionData { - GeneExpressionData::{ - gene_id, - expression, - pseudotime, - condition - } + GeneExpressionData::{ gene_id, expression, pseudotime, condition } } ///| @@ -107,42 +97,48 @@ pub fn TrajectoryData::new() -> TrajectoryData { genes: Array::new(), conditions: Array::new(), n_points: 0, - n_genes: 0 + n_genes: 0, } } ///| -pub fn TrajectoryData::add_point(self : TrajectoryData, point : TrajectoryPoint) -> TrajectoryData { +pub fn TrajectoryData::add_point( + self : TrajectoryData, + point : TrajectoryPoint, +) -> TrajectoryData { let new_points = self.points new_points.push(point) - + let new_conditions = self.conditions if !tradeseq_contains_string(new_conditions, point.condition) { new_conditions.push(point.condition) } - + TrajectoryData::{ points: new_points, genes: self.genes, conditions: new_conditions, n_points: self.n_points + 1, - n_genes: self.n_genes + n_genes: self.n_genes, } } ///| -pub fn TrajectoryData::add_gene(self : TrajectoryData, gene : String) -> TrajectoryData { +pub fn TrajectoryData::add_gene( + self : TrajectoryData, + gene : String, +) -> TrajectoryData { let new_genes = self.genes if !tradeseq_contains_string(new_genes, gene) { new_genes.push(gene) } - + TrajectoryData::{ points: self.points, genes: new_genes, conditions: self.conditions, n_points: self.n_points, - n_genes: new_genes.length() + n_genes: new_genes.length(), } } @@ -151,7 +147,7 @@ pub fn fit_gam(gene_data : GeneExpressionData, n_knots : Int) -> GAMFit { let n = gene_data.expression.length() let expression = gene_data.expression let pseudotime = gene_data.pseudotime - + if n < 3 { return GAMFit::{ gene_id: gene_data.gene_id, @@ -160,32 +156,32 @@ pub fn fit_gam(gene_data : GeneExpressionData, n_knots : Int) -> GAMFit { residuals: Array::new(), r_squared: 0.0, degrees_of_freedom: 1.0, - smoothing_basis: Array::new() + smoothing_basis: Array::new(), } } - + // Sort by pseudotime let sorted_indices = tradeseq_sort_indices(pseudotime) let sorted_expression : Array[Double] = Array::new() let sorted_pseudotime : Array[Double] = Array::new() - + let mut i = 0 while i < n { sorted_expression.push(expression[sorted_indices[i]]) sorted_pseudotime.push(pseudotime[sorted_indices[i]]) i = i + 1 } - + // Create basis functions for cubic spline let n_knots_actual = if n_knots > n / 2 { n / 2 } else { n_knots } let basis = tradeseq_create_basis(sorted_pseudotime, n_knots_actual) - + // Fit using least squares (simplified) let coefficients = tradeseq_fit_coefficients(basis, sorted_expression) - + // Calculate fitted values let fitted_values = tradeseq_compute_fitted(basis, coefficients) - + // Calculate residuals let residuals : Array[Double] = Array::new() i = 0 @@ -193,10 +189,10 @@ pub fn fit_gam(gene_data : GeneExpressionData, n_knots : Int) -> GAMFit { residuals.push(sorted_expression[i] - fitted_values[i]) i = i + 1 } - + // Calculate R-squared let r_squared = tradeseq_calculate_r_squared(sorted_expression, fitted_values) - + GAMFit::{ gene_id: gene_data.gene_id, coefficients, @@ -204,7 +200,7 @@ pub fn fit_gam(gene_data : GeneExpressionData, n_knots : Int) -> GAMFit { residuals, r_squared, degrees_of_freedom: n_knots_actual.to_double() + 1.0, - smoothing_basis: basis[0] // Store first row as representative + smoothing_basis: basis[0], // Store first row as representative } } @@ -213,16 +209,16 @@ pub fn trade_test_condition_effect( gene_data : GeneExpressionData, pseudotime_point : Double, condition1 : String, - condition2 : String + condition2 : String, ) -> DifferentialExpressionResult { let n = gene_data.expression.length() - + // Calculate mean expression for each condition at nearby pseudotime points let mut sum1 = 0.0 let mut count1 = 0 let mut sum2 = 0.0 let mut count2 = 0 - + let bandwidth = 0.1 let mut i = 0 while i < n { @@ -238,16 +234,17 @@ pub fn trade_test_condition_effect( } i = i + 1 } - + let mean1 = if count1 > 0 { sum1 / count1.to_double() } else { 0.0 } let mean2 = if count2 > 0 { sum2 / count2.to_double() } else { 0.0 } - + // Calculate standard errors let var1 = if count1 > 1 { let mut s = 0.0 let mut j = 0 while j < n { - if (gene_data.pseudotime[j] - pseudotime_point).abs() < bandwidth && gene_data.condition[j] == condition1 { + if (gene_data.pseudotime[j] - pseudotime_point).abs() < bandwidth && + gene_data.condition[j] == condition1 { s = s + (gene_data.expression[j] - mean1).pow(2.0) j = j + 1 } else { @@ -255,13 +252,16 @@ pub fn trade_test_condition_effect( } } s / (count1 - 1).to_double() - } else { 1.0 } - + } else { + 1.0 + } + let var2 = if count2 > 1 { let mut s = 0.0 let mut j = 0 while j < n { - if (gene_data.pseudotime[j] - pseudotime_point).abs() < bandwidth && gene_data.condition[j] == condition2 { + if (gene_data.pseudotime[j] - pseudotime_point).abs() < bandwidth && + gene_data.condition[j] == condition2 { s = s + (gene_data.expression[j] - mean2).pow(2.0) j = j + 1 } else { @@ -269,22 +269,24 @@ pub fn trade_test_condition_effect( } } s / (count2 - 1).to_double() - } else { 1.0 } - + } else { + 1.0 + } + let se = (var1 / count1.to_double() + var2 / count2.to_double()).sqrt() let coefficient = mean1 - mean2 - + let z_statistic = if se > 0.0 { coefficient / se } else { 0.0 } let p_value = tradeseq_normal_p_value(z_statistic) - + DifferentialExpressionResult::{ gene_id: gene_data.gene_id, p_value, - adjusted_p_value: p_value, // Will be adjusted later + adjusted_p_value: p_value, // Will be adjusted later coefficient, standard_error: se, z_statistic, - significant: p_value < 0.05 + significant: p_value < 0.05, } } @@ -294,20 +296,20 @@ pub fn run_tradeseq_analysis( genes : Array[String], conditions : Array[String], n_knots : Int, - fdr : Double + fdr : Double, ) -> TradeSeqResult { let gene_results : Array[DifferentialExpressionResult] = Array::new() - + // For each gene, perform differential expression test let mut i = 0 while i < genes.length() { let gene = genes[i] - + // Create gene expression data let expression : Array[Double] = Array::new() let pseudotime : Array[Double] = Array::new() let conditions_arr : Array[String] = Array::new() - + let mut j = 0 while j < trajectory_data.points.length() { let point = trajectory_data.points[j] @@ -316,20 +318,26 @@ pub fn run_tradeseq_analysis( conditions_arr.push(point.condition) j = j + 1 } - - let gene_data = GeneExpressionData::new(gene, expression, pseudotime, conditions_arr) - + + let gene_data = GeneExpressionData::new( + gene, expression, pseudotime, conditions_arr, + ) + // Test at multiple pseudotime points let n_test_points = 10 let mut min_pt = 1.0e9 let mut max_pt = -1.0e9 let mut k = 0 while k < pseudotime.length() { - if pseudotime[k] < min_pt { min_pt = pseudotime[k] } - if pseudotime[k] > max_pt { max_pt = pseudotime[k] } + if pseudotime[k] < min_pt { + min_pt = pseudotime[k] + } + if pseudotime[k] > max_pt { + max_pt = pseudotime[k] + } k = k + 1 } - + let pt_range = max_pt - min_pt let mut min_p_value = 1.0 let mut best_result : DifferentialExpressionResult = DifferentialExpressionResult::{ @@ -339,32 +347,33 @@ pub fn run_tradeseq_analysis( coefficient: 0.0, standard_error: 1.0, z_statistic: 0.0, - significant: false + significant: false, } - + // Check condition ordering let cond1 = conditions[0] let cond2 = if conditions.length() > 1 { conditions[1] } else { "control" } - + let mut l = 0 while l < n_test_points { - let pt = min_pt + (pt_range * (l.to_double() + 0.5) / n_test_points.to_double()) + let pt = min_pt + + pt_range * (l.to_double() + 0.5) / n_test_points.to_double() let result = trade_test_condition_effect(gene_data, pt, cond1, cond2) - + if result.p_value < min_p_value { min_p_value = result.p_value best_result = result } l = l + 1 } - + gene_results.push(best_result) i = i + 1 } - + // Apply Benjamini-Hochberg correction let adjusted_results = tradeseq_bh_correction(gene_results, fdr) - + // Count significant let mut n_significant = 0 let m = adjusted_results.length() @@ -375,12 +384,12 @@ pub fn run_tradeseq_analysis( } i2 = i2 + 1 } - + TradeSeqResult::{ gene_results: adjusted_results, n_genes: m, n_significant, - fdr_threshold: fdr + fdr_threshold: fdr, } } @@ -389,13 +398,13 @@ pub fn calculate_gene_smooth( trajectory_data : TrajectoryData, gene : String, n_knots : Int, - n_points : Int + n_points : Int, ) -> SmoothResult { let expression : Array[Double] = Array::new() let pseudotime : Array[Double] = Array::new() - + let gene_idx = tradeseq_find_gene_index(trajectory_data.genes, gene) - + let mut i = 0 while i < trajectory_data.points.length() { let point = trajectory_data.points[i] @@ -403,74 +412,97 @@ pub fn calculate_gene_smooth( pseudotime.push(point.pseudotime) i = i + 1 } - - let gene_data = GeneExpressionData::new(gene, expression, pseudotime, trajectory_data.conditions) + + let gene_data = GeneExpressionData::new( + gene, + expression, + pseudotime, + trajectory_data.conditions, + ) let gam_fit = fit_gam(gene_data, n_knots) - + // Generate smooth curve at evenly spaced pseudotime points let mut min_pt = 1.0e9 let mut max_pt = -1.0e9 let mut j = 0 while j < pseudotime.length() { - if pseudotime[j] < min_pt { min_pt = pseudotime[j] } - if pseudotime[j] > max_pt { max_pt = pseudotime[j] } + if pseudotime[j] < min_pt { + min_pt = pseudotime[j] + } + if pseudotime[j] > max_pt { + max_pt = pseudotime[j] + } j = j + 1 } - + let smooth_pseudotime : Array[Double] = Array::new() let smooth_fitted : Array[Double] = Array::new() let smooth_lower : Array[Double] = Array::new() let smooth_upper : Array[Double] = Array::new() - + let pt_range = max_pt - min_pt let k = gam_fit.degrees_of_freedom.to_int() let basis = tradeseq_create_basis(pseudotime, if k > 0 { k } else { 4 }) - + let mut l = 0 while l < n_points { - let pt = min_pt + (pt_range * l.to_double() / (n_points.to_double() - 1.0)) + let pt = min_pt + pt_range * l.to_double() / (n_points.to_double() - 1.0) smooth_pseudotime.push(pt) - + // Simple interpolation based on GAM fit let fit_idx = if gam_fit.fitted_values.length() > 0 { - let idx = ((pt - min_pt) / pt_range * (gam_fit.fitted_values.length() - 1).to_double()).to_int() - if idx < 0 { 0 } else if idx >= gam_fit.fitted_values.length() { gam_fit.fitted_values.length() - 1 } else { idx } - } else { 0 } - - let fitted = if gam_fit.fitted_values.length() > 0 { gam_fit.fitted_values[fit_idx] } else { 0.0 } - let se = 0.1 // Simplified standard error - + let idx = ((pt - min_pt) / + pt_range * + (gam_fit.fitted_values.length() - 1).to_double()).to_int() + if idx < 0 { + 0 + } else if idx >= gam_fit.fitted_values.length() { + gam_fit.fitted_values.length() - 1 + } else { + idx + } + } else { + 0 + } + + let fitted = if gam_fit.fitted_values.length() > 0 { + gam_fit.fitted_values[fit_idx] + } else { + 0.0 + } + let se = 0.1 // Simplified standard error + smooth_fitted.push(fitted) smooth_lower.push(fitted - 1.96 * se) smooth_upper.push(fitted + 1.96 * se) l = l + 1 } - + SmoothResult::{ gene_id: gene, pseudotime: smooth_pseudotime, fitted: smooth_fitted, lower_ci: smooth_lower, - upper_ci: smooth_upper + upper_ci: smooth_upper, } } ///| pub fn create_example_trajectory_data() -> TrajectoryData { let mut data = TrajectoryData::new() - + // Add genes data = data.add_gene("GeneA") data = data.add_gene("GeneB") data = data.add_gene("GeneC") - + // Create 50 trajectory points with varying expression let n_cells = 50 let mut i = 0 while i < n_cells { let pseudotime = i.to_double() / (n_cells.to_double() - 1.0) let condition = if i < 25 { "control" } else { "treatment" } - + // GeneA: increases with pseudotime let gene_a = 0.5 + pseudotime * 2.0 + @math.sin(i.to_double() * 0.01) * 0.3 // GeneB: decreases then increases @@ -481,18 +513,18 @@ pub fn create_example_trajectory_data() -> TrajectoryData { } else { 2.0 + @math.sin(i.to_double() * 0.05) * 0.2 } - + let point = TrajectoryPoint::new( "cell_" + i.to_string(), pseudotime, [gene_a, gene_b, gene_c], - condition + condition, ) - + data = data.add_point(point) i = i + 1 } - + data } @@ -501,30 +533,41 @@ pub fn tradeseq_summary(result : TradeSeqResult) -> String { let mut summary = "\ntradeSeq Analysis Summary\n" summary = summary + "==============================\n" summary = summary + "Total genes tested: " + result.n_genes.to_string() + "\n" - summary = summary + "Significant genes (FDR < " + result.fdr_threshold.to_string() + "): " + result.n_significant.to_string() + "\n" - + summary = summary + + "Significant genes (FDR < " + + result.fdr_threshold.to_string() + + "): " + + result.n_significant.to_string() + + "\n" + // Sort results by p-value let n = result.gene_results.length() let sorted_indices = tradeseq_sort_by_pvalue(result.gene_results) - + summary = summary + "\nTop significant genes:\n" let n_top = if 10 < n { 10 } else { n } let mut k = 0 while k < n_top { let idx = sorted_indices[k] if result.gene_results[idx].significant { - summary = summary + " " + result.gene_results[idx].gene_id + - ": adj p-value = " + result.gene_results[idx].adjusted_p_value.to_string() + - ", coefficient = " + result.gene_results[idx].coefficient.to_string() + "\n" + summary = summary + + " " + + result.gene_results[idx].gene_id + + ": adj p-value = " + + result.gene_results[idx].adjusted_p_value.to_string() + + ", coefficient = " + + result.gene_results[idx].coefficient.to_string() + + "\n" } k = k + 1 } - + summary } // Helper functions +///| fn tradeseq_contains_string(arr : Array[String], value : String) -> Bool { let mut i = 0 while i < arr.length() { @@ -536,11 +579,12 @@ fn tradeseq_contains_string(arr : Array[String], value : String) -> Bool { false } +///| fn tradeseq_sort_indices(arr : Array[Double]) -> Array[Int] { let n = arr.length() let indices : Array[Int] = Array::new() let values : Array[Double] = Array::new() - + // Copy values and indices let mut i = 0 while i < n { @@ -548,7 +592,7 @@ fn tradeseq_sort_indices(arr : Array[Double]) -> Array[Int] { values.push(arr[i]) i = i + 1 } - + // Bubble sort by value i = 0 while i < n { @@ -559,7 +603,7 @@ fn tradeseq_sort_indices(arr : Array[Double]) -> Array[Int] { let temp_val = values[j] values[j] = values[j + 1] values[j + 1] = temp_val - + let temp_idx = indices[j] indices[j] = indices[j + 1] indices[j + 1] = temp_idx @@ -568,29 +612,33 @@ fn tradeseq_sort_indices(arr : Array[Double]) -> Array[Int] { } i = i + 1 } - + indices } -fn tradeseq_create_basis(pseudotime : Array[Double], n_knots : Int) -> Array[Array[Double]] { +///| +fn tradeseq_create_basis( + pseudotime : Array[Double], + n_knots : Int, +) -> Array[Array[Double]] { let n = pseudotime.length() - let n_basis = n_knots + 2 // Interior knots + boundary - + let n_basis = n_knots + 2 // Interior knots + boundary + // Create natural cubic spline basis let basis : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let row : Array[Double] = Array::new() let x = pseudotime[i] - + let mut j = 0 while j < n_basis { // Simple B-spline basis (simplified) let knot_pos = j.to_double() / (n_basis.to_double() - 1.0) let dist = (x - knot_pos).abs() let basis_val = if dist < 0.5 { - 1.0 - dist * 2.0 // Linear basis + 1.0 - dist * 2.0 // Linear basis } else { 0.0 } @@ -600,18 +648,22 @@ fn tradeseq_create_basis(pseudotime : Array[Double], n_knots : Int) -> Array[Arr basis.push(row) i = i + 1 } - + basis } -fn tradeseq_fit_coefficients(basis : Array[Array[Double]], y : Array[Double]) -> Array[Double] { +///| +fn tradeseq_fit_coefficients( + basis : Array[Array[Double]], + y : Array[Double], +) -> Array[Double] { let n = basis.length() let n_basis = basis[0].length() - + // Simple least squares approximation // X'X β = X'y let coefficients : Array[Double] = Array::new() - + let mut j = 0 while j < n_basis { let mut sum_x = 0.0 @@ -622,21 +674,25 @@ fn tradeseq_fit_coefficients(basis : Array[Array[Double]], y : Array[Double]) -> sum_xy = sum_xy + basis[i][j] * y[i] i = i + 1 } - + let coef = if sum_x > 0.0 { sum_xy / sum_x } else { 0.0 } coefficients.push(coef) j = j + 1 } - + coefficients } -fn tradeseq_compute_fitted(basis : Array[Array[Double]], coefficients : Array[Double]) -> Array[Double] { +///| +fn tradeseq_compute_fitted( + basis : Array[Array[Double]], + coefficients : Array[Double], +) -> Array[Double] { let n = basis.length() let n_basis = coefficients.length() - + let fitted : Array[Double] = Array::new() - + let mut i = 0 while i < n { let mut sum = 0.0 @@ -648,13 +704,17 @@ fn tradeseq_compute_fitted(basis : Array[Array[Double]], coefficients : Array[Do fitted.push(sum) i = i + 1 } - + fitted } -fn tradeseq_calculate_r_squared(observed : Array[Double], fitted : Array[Double]) -> Double { +///| +fn tradeseq_calculate_r_squared( + observed : Array[Double], + fitted : Array[Double], +) -> Double { let n = observed.length() - + // Calculate mean of observed let mut mean_y = 0.0 let mut i = 0 @@ -663,7 +723,7 @@ fn tradeseq_calculate_r_squared(observed : Array[Double], fitted : Array[Double] i = i + 1 } mean_y = mean_y / n.to_double() - + // Calculate total sum of squares let mut ss_total = 0.0 i = 0 @@ -671,7 +731,7 @@ fn tradeseq_calculate_r_squared(observed : Array[Double], fitted : Array[Double] ss_total = ss_total + (observed[i] - mean_y).pow(2.0) i = i + 1 } - + // Calculate residual sum of squares let mut ss_residual = 0.0 i = 0 @@ -679,29 +739,43 @@ fn tradeseq_calculate_r_squared(observed : Array[Double], fitted : Array[Double] ss_residual = ss_residual + (observed[i] - fitted[i]).pow(2.0) i = i + 1 } - - if ss_total == 0.0 { 0.0 } else { 1.0 - ss_residual / ss_total } + + if ss_total == 0.0 { + 0.0 + } else { + 1.0 - ss_residual / ss_total + } } +///| fn tradeseq_normal_p_value(z : Double) -> Double { // Two-tailed p-value from standard normal distribution let abs_z = if z >= 0.0 { z } else { -z } 2.0 * (1.0 - tradeseq_normal_cdf(abs_z)) } +///| fn tradeseq_normal_cdf(x : Double) -> Double { // Standard normal CDF approximation let t = 1.0 / (1.0 + 0.2316419 * x) let d = 0.3989422804014327 * @math.exp(-x * x / 2.0) - let p = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))) + let p = d * + t * + ( + 0.3193815 + + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))) + ) p } -fn tradeseq_sort_by_pvalue(results : Array[DifferentialExpressionResult]) -> Array[Int] { +///| +fn tradeseq_sort_by_pvalue( + results : Array[DifferentialExpressionResult], +) -> Array[Int] { let n = results.length() let indices : Array[Int] = Array::new() let values : Array[Double] = Array::new() - + // Initialize let mut i = 0 while i < n { @@ -709,7 +783,7 @@ fn tradeseq_sort_by_pvalue(results : Array[DifferentialExpressionResult]) -> Arr values.push(results[i].p_value) i = i + 1 } - + // Bubble sort by p-value i = 0 while i < n { @@ -720,7 +794,7 @@ fn tradeseq_sort_by_pvalue(results : Array[DifferentialExpressionResult]) -> Arr let temp_val = values[j] values[j] = values[j + 1] values[j + 1] = temp_val - + // Swap indices let temp_idx = indices[j] indices[j] = indices[j + 1] @@ -730,16 +804,20 @@ fn tradeseq_sort_by_pvalue(results : Array[DifferentialExpressionResult]) -> Arr } i = i + 1 } - + indices } -fn tradeseq_bh_correction(results : Array[DifferentialExpressionResult], fdr : Double) -> Array[DifferentialExpressionResult] { +///| +fn tradeseq_bh_correction( + results : Array[DifferentialExpressionResult], + fdr : Double, +) -> Array[DifferentialExpressionResult] { let n = results.length() - + // Create sorted order by p-value let sorted_indices = tradeseq_sort_by_pvalue(results) - + // Extract sorted p-values let sorted_pvalues : Array[Double] = Array::new() let mut i = 0 @@ -747,7 +825,7 @@ fn tradeseq_bh_correction(results : Array[DifferentialExpressionResult], fdr : D sorted_pvalues.push(results[sorted_indices[i]].p_value) i = i + 1 } - + // Apply BH correction let adjusted : Array[Double] = Array::new() let mut k = 0 @@ -759,7 +837,7 @@ fn tradeseq_bh_correction(results : Array[DifferentialExpressionResult], fdr : D adjusted.push(capped) k = k + 1 } - + // Enforce monotonicity let mono = adjusted let mut l = n - 2 @@ -769,7 +847,7 @@ fn tradeseq_bh_correction(results : Array[DifferentialExpressionResult], fdr : D } l = l - 1 } - + // Map back to original positions let final_results : Array[DifferentialExpressionResult] = Array::new() let mut m = 0 @@ -779,14 +857,15 @@ fn tradeseq_bh_correction(results : Array[DifferentialExpressionResult], fdr : D final_results.push(DifferentialExpressionResult::{ ..results[orig_idx], adjusted_p_value: adj_p, - significant: adj_p < fdr + significant: adj_p < fdr, }) m = m + 1 } - + final_results } +///| fn tradeseq_find_gene_index(genes : Array[String], gene : String) -> Int { let mut i = 0 while i < genes.length() { diff --git a/src/transfac.mbt b/src/transfac.mbt index 524eab12..259bfe08 100644 --- a/src/transfac.mbt +++ b/src/transfac.mbt @@ -79,7 +79,7 @@ pub struct TransfacMotifFull { ///| /// Create a new TransfacMotifFull. -pub fn TransfacMotifFull::new(accession~ : String = "") -> TransfacMotifFull { +pub fn TransfacMotifFull::new(accession? : String = "") -> TransfacMotifFull { TransfacMotifFull::{ accession, identifier: "", @@ -124,7 +124,10 @@ pub fn TransfacMotifFull::consensus(self : TransfacMotifFull) -> String { ///| /// Get the total count at a position (sum of all bases). -pub fn TransfacMotifFull::total_at(self : TransfacMotifFull, position : Int) -> Int { +pub fn TransfacMotifFull::total_at( + self : TransfacMotifFull, + position : Int, +) -> Int { if position < 0 || position >= self.width { return 0 } @@ -160,7 +163,10 @@ pub fn TransfacMotifFull::frequency( ///| /// Find the index of a base in the alphabet. -pub fn TransfacMotifFull::alphabet_index(self : TransfacMotifFull, base : String) -> Int { +pub fn TransfacMotifFull::alphabet_index( + self : TransfacMotifFull, + base : String, +) -> Int { let mut i = 0 while i < self.alphabet.length() { if self.alphabet[i] == base { @@ -192,7 +198,10 @@ pub fn TransfacRecordFull::num_motifs(self : TransfacRecordFull) -> Int { ///| /// Find a motif by accession number. -pub fn TransfacRecordFull::find(self : TransfacRecordFull, accession : String) -> TransfacMotifFull? { +pub fn TransfacRecordFull::find( + self : TransfacRecordFull, + accession : String, +) -> TransfacMotifFull? { for m in self.motifs { if m.accession == accession { return Some(m) @@ -262,7 +271,11 @@ pub fn transfac_parse_full(text : String) -> TransfacRecordFull { continue } // Helper to finalize current reference - if field != "RA" && field != "RT" && field != "RL" && field != "RX" && has_ref { + if field != "RA" && + field != "RT" && + field != "RL" && + field != "RX" && + has_ref { let r = TransfacReference::new() r.number = ref_number r.authors = ref_authors @@ -471,7 +484,10 @@ pub fn transfac_parse_full(text : String) -> TransfacRecordFull { continue } // Matrix data rows (start with digits) - if in_matrix && field.length() >= 2 && field[0:1].to_string() >= "0" && field[0:1].to_string() <= "9" { + if in_matrix && + field.length() >= 2 && + field[0:1].to_string() >= "0" && + field[0:1].to_string() <= "9" { // Parse the row number and counts let parts = trimmed.split(" ").to_array() let counts : Array[Int] = Array::new() @@ -626,12 +642,7 @@ pub fn transfac_sample_motif_full() -> TransfacMotifFull { m.species = "Homo sapiens" m.binding_factors.push("Jun") m.binding_factors.push("Fos") - m.pfm = [ - [4, 0, 0, 0, 3], - [0, 0, 4, 0, 1], - [0, 4, 0, 0, 0], - [0, 0, 0, 4, 0], - ] + m.pfm = [[4, 0, 0, 0, 3], [0, 0, 4, 0, 1], [0, 4, 0, 0, 0], [0, 0, 0, 4, 0]] m.width = 5 m.comments = "AP-1 transcription factor binding site" m diff --git a/src/trie.mbt b/src/trie.mbt index ae985d47..17bd8a4b 100644 --- a/src/trie.mbt +++ b/src/trie.mbt @@ -50,10 +50,7 @@ pub struct Trie { /// Create a new empty trie. pub fn Trie::new() -> Trie { Trie::{ - root: TrieNode::{ - children: Map([], capacity=4), - value: TrieValue::Empty, - }, + root: TrieNode::{ children: Map([], capacity=4), value: TrieValue::Empty }, count: 0, } } @@ -61,10 +58,7 @@ pub fn Trie::new() -> Trie { ///| /// Create a new TrieNode. pub fn TrieNode::new() -> TrieNode { - TrieNode::{ - children: Map([], capacity=4), - value: TrieValue::Empty, - } + TrieNode::{ children: Map([], capacity=4), value: TrieValue::Empty } } ///| @@ -141,7 +135,10 @@ pub fn trie_size(trie : Trie) -> Int { ///| /// Find all keys with the given prefix. /// Returns an array of (key, value) tuples. -pub fn trie_with_prefix(trie : Trie, prefix : String) -> Array[(String, String)] { +pub fn trie_with_prefix( + trie : Trie, + prefix : String, +) -> Array[(String, String)] { let result : Array[(String, String)] = Array::new() let start_node = trie_find_node(trie.root, prefix) match start_node { @@ -234,7 +231,10 @@ pub fn triefind_match(trie : Trie, text : String) -> (String, String)? { ///| /// Find all keys in the trie that match the beginning of the string. /// Returns a list of (key, value) tuples, ordered by increasing key length. -pub fn triefind_match_all(trie : Trie, text : String) -> Array[(String, String)] { +pub fn triefind_match_all( + trie : Trie, + text : String, +) -> Array[(String, String)] { let result : Array[(String, String)] = Array::new() let mut current = trie.root let mut prefix = "" @@ -261,7 +261,10 @@ pub fn triefind_match_all(trie : Trie, text : String) -> Array[(String, String)] ///| /// Find all keys in the trie that match anywhere in the string. /// Returns a list of (key, value, start, end) tuples. -pub fn triefind_find(trie : Trie, text : String) -> Array[(String, String, Int, Int)] { +pub fn triefind_find( + trie : Trie, + text : String, +) -> Array[(String, String, Int, Int)] { let result : Array[(String, String, Int, Int)] = Array::new() let mut start = 0 while start < text.length() { @@ -284,13 +287,19 @@ pub fn triefind_find(trie : Trie, text : String) -> Array[(String, String, Int, /// Find all keys in the trie that match whole words in the string. /// Word boundaries are defined as any punctuation, whitespace, or string start/end. /// Returns a list of (key, value, start, end) tuples. -pub fn triefind_find_words(trie : Trie, text : String) -> Array[(String, String, Int, Int)] { +pub fn triefind_find_words( + trie : Trie, + text : String, +) -> Array[(String, String, Int, Int)] { let result : Array[(String, String, Int, Int)] = Array::new() let mut start = 0 while start < text.length() { // Check if this position is at a word boundary if start == 0 || trie_is_boundary(text[start - 1:start].to_owned()) { - let matches = triefind_match_all(trie, text[start:text.length()].to_owned()) + let matches = triefind_match_all( + trie, + text[start:text.length()].to_owned(), + ) let mut j = 0 while j < matches.length() { let pair = matches[j] @@ -298,7 +307,8 @@ pub fn triefind_find_words(trie : Trie, text : String) -> Array[(String, String, let val = pair.1 let end = start + key.length() // Check that the character after the match is also a boundary - if end >= text.length() || trie_is_boundary(text[end:end + 1].to_owned()) { + if end >= text.length() || + trie_is_boundary(text[end:end + 1].to_owned()) { result.push((key, val, start, end)) } j = j + 1 @@ -332,7 +342,11 @@ fn trie_find_node(root : TrieNode, key : String) -> TrieNode? { ///| /// Recursively collect all keys from a node. -fn trie_collect_keys(node : TrieNode, prefix : String, result : Array[String]) -> Unit { +fn trie_collect_keys( + node : TrieNode, + prefix : String, + result : Array[String], +) -> Unit { match node.value { TrieValue::Value(_) => result.push(prefix) TrieValue::Empty => () @@ -353,7 +367,7 @@ fn trie_collect_keys(node : TrieNode, prefix : String, result : Array[String]) - fn trie_collect_pairs( node : TrieNode, prefix : String, - result : Array[(String, String)] + result : Array[(String, String)], ) -> Unit { match node.value { TrieValue::Value(v) => result.push((prefix, v)) diff --git a/src/twobit_io.mbt b/src/twobit_io.mbt index b59f613f..5289111e 100644 --- a/src/twobit_io.mbt +++ b/src/twobit_io.mbt @@ -61,7 +61,11 @@ pub fn TwoBitNBlock::end(self : TwoBitNBlock) -> Int { ///| /// Human-readable representation. pub fn TwoBitNBlock::to_string(self : TwoBitNBlock) -> String { - "NBlock(start=" + self.start.to_string() + ", size=" + self.size.to_string() + ")" + "NBlock(start=" + + self.start.to_string() + + ", size=" + + self.size.to_string() + + ")" } // ============================================================================ @@ -103,7 +107,11 @@ pub fn TwoBitMaskBlock::end(self : TwoBitMaskBlock) -> Int { ///| /// Human-readable representation. pub fn TwoBitMaskBlock::to_string(self : TwoBitMaskBlock) -> String { - "MaskBlock(start=" + self.start.to_string() + ", size=" + self.size.to_string() + ")" + "MaskBlock(start=" + + self.start.to_string() + + ", size=" + + self.size.to_string() + + ")" } // ============================================================================ @@ -161,7 +169,9 @@ pub fn TwoBitSequence::n_blocks(self : TwoBitSequence) -> Array[TwoBitNBlock] { ///| /// Mask-blocks (regions of soft-masked / lowercase bases). -pub fn TwoBitSequence::mask_blocks(self : TwoBitSequence) -> Array[TwoBitMaskBlock] { +pub fn TwoBitSequence::mask_blocks( + self : TwoBitSequence, +) -> Array[TwoBitMaskBlock] { self.mask_blocks.copy() } @@ -234,7 +244,10 @@ pub fn TwoBitFile::version(self : TwoBitFile) -> Int { ///| /// Append a sequence to the file. -pub fn TwoBitFile::add_sequence(self : TwoBitFile, seq : TwoBitSequence) -> Unit { +pub fn TwoBitFile::add_sequence( + self : TwoBitFile, + seq : TwoBitSequence, +) -> Unit { self.sequences.push(seq) } @@ -356,7 +369,7 @@ pub fn twobit_pack_sequence( } // Pack code into the correct byte and bit position. let byte_idx = i / 4 - let shift = 6 - (i % 4) * 2 + let shift = 6 - i % 4 * 2 packed[byte_idx] = packed[byte_idx] | (code << shift) // Update N-block tracking. if is_n { @@ -380,12 +393,10 @@ pub fn twobit_pack_sequence( mask_start = i } mask_size = mask_size + 1 - } else { // Close any open mask-block. - if mask_size > 0 { - mask_blocks.push(TwoBitMaskBlock::new(mask_start, mask_size)) - mask_size = 0 - } + } else if mask_size > 0 { + mask_blocks.push(TwoBitMaskBlock::new(mask_start, mask_size)) + mask_size = 0 } } } @@ -414,7 +425,7 @@ pub fn twobit_unpack_sequence( let codes : Array[Int] = Array::new() for i in 0..> shift) & 3 codes.push(twobit_code_to_base(code).to_int()) } @@ -459,7 +470,10 @@ fn twobit_encode_u32_le(v : Int) -> Array[Int] { ///| /// Read a 32-bit little-endian unsigned integer from a byte array at `pos`. fn twobit_read_u32_le(bytes : Array[Int], pos : Int) -> Int { - bytes[pos] | (bytes[pos + 1] << 8) | (bytes[pos + 2] << 16) | (bytes[pos + 3] << 24) + bytes[pos] | + (bytes[pos + 1] << 8) | + (bytes[pos + 2] << 16) | + (bytes[pos + 3] << 24) } // ============================================================================ @@ -484,7 +498,13 @@ pub fn twobit_to_bytes(tbf : TwoBitFile) -> Array[Int] { offsets.push(current_offset) let seq = seqs[i] let packed_size = (seq.dna_size + 3) / 4 - let seq_data_size = 4 + packed_size + 4 + 8 * seq.n_blocks.length() + 4 + 8 * seq.mask_blocks.length() + 4 + let seq_data_size = 4 + + packed_size + + 4 + + 8 * seq.n_blocks.length() + + 4 + + 8 * seq.mask_blocks.length() + + 4 current_offset = current_offset + seq_data_size } // ---- Header (16 bytes) ---- diff --git a/src/uniprot_io.mbt b/src/uniprot_io.mbt index c4165bde..c7787ac6 100644 --- a/src/uniprot_io.mbt +++ b/src/uniprot_io.mbt @@ -300,7 +300,10 @@ fn extract_all_tags(xml : String, tag : String) -> Array[String] { ///| /// Extract all occurrences of a tag with their opening tag string. /// Returns pairs of (opening_tag_string, inner_content). -fn extract_all_tags_with_attrs(xml : String, tag : String) -> Array[(String, String)] { +fn extract_all_tags_with_attrs( + xml : String, + tag : String, +) -> Array[(String, String)] { let results : Array[(String, String)] = Array::new() let open_tag = "<" + tag let close_tag = "" @@ -397,7 +400,11 @@ fn extract_sequence(entry_xml : String) -> (String, Int, Double) { if seq_block.length() == 0 { return ("", 0, 0.0) } - let seq = seq_block.replace(old="\n", new="").replace(old=" ", new="").trim().to_owned() + let seq = seq_block + .replace(old="\n", new="") + .replace(old=" ", new="") + .trim() + .to_owned() // Extract mass attribute let mass_attr = extract_attribute(entry_xml, "sequence", "mass") let mass = if mass_attr.length() > 0 { u_parse_float(mass_attr) } else { 0.0 } @@ -531,7 +538,9 @@ fn extract_references(entry_xml : String) -> Array[UniprotReference] { "" } if key.length() > 0 { - refs.push(UniprotReference::new(key, title, authors, journal, pubmed_id, "")) + refs.push( + UniprotReference::new(key, title, authors, journal, pubmed_id, ""), + ) } } refs @@ -584,7 +593,9 @@ pub fn parse_uniprot_entry(entry_xml : String) -> UniprotEntry { // Extract sequence let (sequence, _, _) = extract_sequence(entry_xml) // Create base entry - let entry = UniprotEntry::new(accession, protein_name, gene_names, organism, sequence) + let entry = UniprotEntry::new( + accession, protein_name, gene_names, organism, sequence, + ) // Extract sequence with mass let (_, seq_len, seq_mass) = extract_sequence(entry_xml) entry.seq_length = seq_len @@ -627,7 +638,9 @@ pub fn parse_uniprot_xml(content : String) -> Array[UniprotEntry] { ///| /// Convert a UniprotEntry to a SeqRecord-compatible map. /// Returns a tuple of (id, description, sequence, annotations). -pub fn uniprot_to_seqrecord(entry : UniprotEntry) -> (String, String, String, Map[String, String]) { +pub fn uniprot_to_seqrecord( + entry : UniprotEntry, +) -> (String, String, String, Map[String, String]) { let id = entry.accession let description = entry.protein_name let annotations : Map[String, String] = Map([], capacity=16) diff --git a/src/universalmotif.mbt b/src/universalmotif.mbt index e689f600..23639f59 100644 --- a/src/universalmotif.mbt +++ b/src/universalmotif.mbt @@ -10,12 +10,21 @@ pub struct S4Motif { } ///| -pub fn S4Motif::new(name : String, alphabet : String, pwm : Array[Array[Double]], consensus : String) -> S4Motif { +pub fn S4Motif::new( + name : String, + alphabet : String, + pwm : Array[Array[Double]], + consensus : String, +) -> S4Motif { S4Motif::{ name, alphabet, pwm, consensus } } ///| -pub fn S4Motif::from_pwm(name : String, alphabet : String, pwm : Array[Array[Double]]) -> S4Motif { +pub fn S4Motif::from_pwm( + name : String, + alphabet : String, + pwm : Array[Array[Double]], +) -> S4Motif { let consensus = calculate_consensus(pwm, alphabet) S4Motif::new(name, alphabet, pwm, consensus) } @@ -23,14 +32,14 @@ pub fn S4Motif::from_pwm(name : String, alphabet : String, pwm : Array[Array[Dou ///| fn calculate_consensus(pwm : Array[Array[Double]], alphabet : String) -> String { let letters = if alphabet == "DNA" { ["A", "C", "G", "T"] } else { ["A"] } - + let mut result = "" - + let mut i = 0 while i < pwm.length() { let mut max_prob = 0.0 let mut max_idx = 0 - + let mut j = 0 while j < pwm[i].length() { if pwm[i][j] > max_prob { @@ -39,13 +48,13 @@ fn calculate_consensus(pwm : Array[Array[Double]], alphabet : String) -> String } j = j + 1 } - + if max_idx < letters.length() { result = result + letters[max_idx] } i = i + 1 } - + result } @@ -58,6 +67,6 @@ pub fn create_example_s4motif() -> S4Motif { [0.1, 0.9, 0.0, 0.0], [0.1, 0.9, 0.0, 0.0], ] - + S4Motif::from_pwm("TATA-box", "DNA", pwm) -} \ No newline at end of file +} diff --git a/src/utils.mbt b/src/utils.mbt index 1d92e47d..0c57054c 100644 --- a/src/utils.mbt +++ b/src/utils.mbt @@ -295,10 +295,10 @@ pub fn to_lowercase(s : String) -> String { 88 => result = result + "x" 89 => result = result + "y" 90 => result = result + "z" - _ => result = result + s[i:i+1].to_string() + _ => result = result + s[i:i + 1].to_string() } } else { - result = result + s[i:i+1].to_string() + result = result + s[i:i + 1].to_string() } i = i + 1 } diff --git a/src/uwot.mbt b/src/uwot.mbt index 3f41fd75..67b2d264 100644 --- a/src/uwot.mbt +++ b/src/uwot.mbt @@ -42,15 +42,15 @@ pub fn UmapConfig::new_custom( random_seed : Int, ) -> UmapConfig { UmapConfig::{ - n_neighbors: n_neighbors, - n_components: n_components, - n_epochs: n_epochs, + n_neighbors, + n_components, + n_epochs, min_dist: 0.1, spread: 1.0, learning_rate: 1.0, repulsion_strength: 1.0, negative_sample_rate: 5.0, - random_seed: random_seed, + random_seed, metric: "euclidean", } } @@ -64,16 +64,14 @@ pub struct UmapResult { ///| pub fn UmapResult::new() -> UmapResult { - UmapResult::{ - embedding: Array::new(), - n_epochs: 0, - } + UmapResult::{ embedding: Array::new(), n_epochs: 0 } } // ============================================================ // Distance and knn functions // ============================================================ +///| fn uwot_euclidean_distance(x : Array[Double], y : Array[Double]) -> Double { let mut sum_sq = 0.0 let n = if x.length() < y.length() { x.length() } else { y.length() } @@ -88,14 +86,16 @@ fn uwot_euclidean_distance(x : Array[Double], y : Array[Double]) -> Double { ///| /// Compute pairwise distance matrix. -pub fn uwot_distance_matrix(data : Array[Array[Double]]) -> Array[Array[Double]] { +pub fn uwot_distance_matrix( + data : Array[Array[Double]], +) -> Array[Array[Double]] { let n = data.length() let dist_matrix : Array[Array[Double]] = Array::new() - + if n == 0 { return dist_matrix } - + let mut i = 0 while i < n { let row : Array[Double] = Array::new() @@ -107,7 +107,7 @@ pub fn uwot_distance_matrix(data : Array[Array[Double]]) -> Array[Array[Double]] dist_matrix.push(row) i = i + 1 } - + let mut i = 0 while i < n { let mut j = i + 1 @@ -119,23 +119,26 @@ pub fn uwot_distance_matrix(data : Array[Array[Double]]) -> Array[Array[Double]] } i = i + 1 } - + dist_matrix } ///| /// Find k-nearest neighbors for each point. /// Returns: for each point, array of (neighbor_index, distance) pairs -fn find_knn(dist_matrix : Array[Array[Double]], k : Int) -> Array[Array[(Int, Double)]] { +fn find_knn( + dist_matrix : Array[Array[Double]], + k : Int, +) -> Array[Array[(Int, Double)]] { let n = dist_matrix.length() let result : Array[Array[(Int, Double)]] = Array::new() - + if n == 0 || k <= 0 { return result } - + let actual_k = if k < n { k } else { n - 1 } - + let mut i = 0 while i < n { // Create list of (index, distance) for all other points @@ -147,7 +150,7 @@ fn find_knn(dist_matrix : Array[Array[Double]], k : Int) -> Array[Array[(Int, Do } j = j + 1 } - + // Simple selection sort to find k nearest let knn : Array[(Int, Double)] = Array::new() let mut selected = 0 @@ -165,24 +168,24 @@ fn find_knn(dist_matrix : Array[Array[Double]], k : Int) -> Array[Array[(Int, Do } s = s + 1 } - + if !already_selected && neighbors[j].1 < min_dist { min_dist = neighbors[j].1 min_idx = j } j = j + 1 } - + if min_idx >= 0 { knn.push(neighbors[min_idx]) } selected = selected + 1 } - + result.push(knn) i = i + 1 } - + result } @@ -192,7 +195,11 @@ fn find_knn(dist_matrix : Array[Array[Double]], k : Int) -> Array[Array[(Int, Do ///| /// Compute the membership strength for a distance using the smooth k-nn distance. -fn compute_membership(distance : Double, rho : Double, sigma : Double) -> Double { +fn compute_membership( + distance : Double, + rho : Double, + sigma : Double, +) -> Double { if distance <= rho { return 1.0 } @@ -209,7 +216,7 @@ fn find_sigma( ) -> Double { let mut lo = 0.0 let mut hi = 1000.0 - + let mut mid = 1.0 let mut iter = 0 while iter < 64 { @@ -217,21 +224,22 @@ fn find_sigma( let mut sum_membership = 0.0 let mut i = 0 while i < n_neighbors && i < distances.length() { - sum_membership = sum_membership + compute_membership(distances[i], rho, mid) + sum_membership = sum_membership + + compute_membership(distances[i], rho, mid) i = i + 1 } - + let log_sum = @math.log2(sum_membership) - + if log_sum > target_log2 { hi = mid } else { lo = mid } - + iter = iter + 1 } - + mid } @@ -246,7 +254,7 @@ fn build_graph( ) -> Array[Array[Double]] { let n = data.length() let n_neighbors = config.n_neighbors - + // Initialize graph let graph : Array[Array[Double]] = Array::new() let mut i = 0 @@ -260,20 +268,24 @@ fn build_graph( graph.push(row) i = i + 1 } - + // Target entropy = log2(n_neighbors) let target_log2 = @math.log2(n_neighbors.to_double()) - + // For each point, compute rho (distance to nearest neighbor) and sigma let sigmas : Array[Double] = Array::new() let rhos : Array[Double] = Array::new() - + let mut i = 0 while i < n { // rho = distance to nearest neighbor - let rho = if knn_distances[i].length() > 0 { knn_distances[i][0] } else { 0.0 } + let rho = if knn_distances[i].length() > 0 { + knn_distances[i][0] + } else { + 0.0 + } rhos.push(rho) - + // Find sigma using binary search let distances : Array[Double] = Array::new() let mut j = 0 @@ -281,13 +293,13 @@ fn build_graph( distances.push(knn_distances[i][j]) j = j + 1 } - + let sigma = find_sigma(distances, rho, target_log2, n_neighbors) sigmas.push(sigma) - + i = i + 1 } - + // Build the graph with asymmetric memberships let mut i = 0 while i < n { @@ -295,15 +307,15 @@ fn build_graph( while j < knn_indices[i].length() { let neighbor_idx = knn_indices[i][j] let dist = knn_distances[i][j] - + let membership_i_to_j = compute_membership(dist, rhos[i], sigmas[i]) graph[i][neighbor_idx] = membership_i_to_j - + j = j + 1 } i = i + 1 } - + // Symmetrize the graph: w_ij = w_ij + w_ji - w_ij * w_ji let mut i = 0 while i < n { @@ -318,7 +330,7 @@ fn build_graph( } i = i + 1 } - + graph } @@ -338,11 +350,11 @@ fn find_ab(min_dist : Double, spread : Double) -> (Double, Double) { // Curve: 1 / (1 + a * x^(2b)) // At x = min_dist: y = 0.5 (approximately) // At x = spread: y is small - + // Simplified parameter estimation let a = 1.576942937 let b = 0.895061728 - + // Scale based on min_dist and spread let scaled_a = a / @math.pow(spread, 2.0 * b) (scaled_a, b) @@ -350,9 +362,13 @@ fn find_ab(min_dist : Double, spread : Double) -> (Double, Double) { ///| /// Initialize the embedding with small random values. -fn initialize_embedding(n : Int, n_components : Int, seed : Int) -> Array[Array[Double]] { +fn initialize_embedding( + n : Int, + n_components : Int, + seed : Int, +) -> Array[Array[Double]] { let embedding : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let row : Array[Double] = Array::new() @@ -366,19 +382,22 @@ fn initialize_embedding(n : Int, n_components : Int, seed : Int) -> Array[Array[ embedding.push(row) i = i + 1 } - + embedding } ///| /// Main UMAP algorithm. -pub fn uwot_umap(data : Array[Array[Double]], config : UmapConfig) -> UmapResult { +pub fn uwot_umap( + data : Array[Array[Double]], + config : UmapConfig, +) -> UmapResult { let n = data.length() - + if n == 0 { return UmapResult::new() } - + if n < 2 { let result = UmapResult::new() let embedding : Array[Array[Double]] = Array::new() @@ -391,18 +410,18 @@ pub fn uwot_umap(data : Array[Array[Double]], config : UmapConfig) -> UmapResult embedding.push(row) return result } - + // Step 1: Compute distance matrix let dist_matrix = uwot_distance_matrix(data) - + // Step 2: Find k-nearest neighbors let k = if config.n_neighbors < n - 1 { config.n_neighbors } else { n - 1 } let knn = find_knn(dist_matrix, k) - + // Extract knn indices and distances let knn_indices : Array[Array[Int]] = Array::new() let knn_distances : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let indices : Array[Int] = Array::new() @@ -417,20 +436,24 @@ pub fn uwot_umap(data : Array[Array[Double]], config : UmapConfig) -> UmapResult knn_distances.push(distances) i = i + 1 } - + // Step 3: Build fuzzy simplicial set let graph = build_graph(data, dist_matrix, knn_indices, knn_distances, config) - + // Step 4: Find a and b parameters let (a, b) = find_ab(config.min_dist, config.spread) - + // Step 5: Initialize embedding - let embedding = initialize_embedding(n, config.n_components, config.random_seed) - + let embedding = initialize_embedding( + n, + config.n_components, + config.random_seed, + ) + // Step 6: Optimize embedding using stochastic gradient descent let epochs_per_sample : Array[Array[Int]] = Array::new() let epoch_of_next_sample : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n { let eps_row : Array[Int] = Array::new() @@ -445,7 +468,7 @@ pub fn uwot_umap(data : Array[Array[Double]], config : UmapConfig) -> UmapResult epoch_of_next_sample.push(eons_row) i = i + 1 } - + // Compute epochs per sample based on graph weights let max_epochs = config.n_epochs.to_double() let mut max_weight = 0.0 @@ -460,11 +483,11 @@ pub fn uwot_umap(data : Array[Array[Double]], config : UmapConfig) -> UmapResult } i = i + 1 } - + if max_weight == 0.0 { max_weight = 1.0 } - + let mut i = 0 while i < n { let mut j = 0 @@ -483,7 +506,7 @@ pub fn uwot_umap(data : Array[Array[Double]], config : UmapConfig) -> UmapResult } i = i + 1 } - + // SGD optimization let mut epoch = 0 while epoch < config.n_epochs { @@ -501,25 +524,33 @@ pub fn uwot_umap(data : Array[Array[Double]], config : UmapConfig) -> UmapResult dist_sq = dist_sq + diff * diff d = d + 1 } - - let grad_coeff = (-2.0 * a * b * @math.pow(dist_sq, b - 1.0)) / (1.0 + a * @math.pow(dist_sq, b)) - + + let grad_coeff = -2.0 * + a * + b * + @math.pow(dist_sq, b - 1.0) / + (1.0 + a * @math.pow(dist_sq, b)) + let mut d = 0 while d < config.n_components { - let grad = config.learning_rate * grad_coeff * (embedding[i][d] - embedding[j][d]) + let grad = config.learning_rate * + grad_coeff * + (embedding[i][d] - embedding[j][d]) embedding[i][d] = embedding[i][d] + grad embedding[j][d] = embedding[j][d] - grad d = d + 1 } - + // Negative samples: move points apart let n_neg = config.negative_sample_rate.to_int() let mut neg = 0 while neg < n_neg { // Pick random negative sample - let rand_val = umap_pseudo_random((epoch * n + i * n_neg + neg + config.random_seed).to_double()) + let rand_val = umap_pseudo_random( + (epoch * n + i * n_neg + neg + config.random_seed).to_double(), + ) let k_random = (rand_val * n.to_double()).to_int() - + if k_random != i && k_random != j { let mut dist_sq_neg = 0.0 let mut d = 0 @@ -528,41 +559,48 @@ pub fn uwot_umap(data : Array[Array[Double]], config : UmapConfig) -> UmapResult dist_sq_neg = dist_sq_neg + diff * diff d = d + 1 } - - let grad_coeff_neg = (2.0 * b * config.repulsion_strength) / ((0.001 + dist_sq_neg) * (1.0 + a * @math.pow(dist_sq_neg, b))) - + + let grad_coeff_neg = 2.0 * + b * + config.repulsion_strength / + ( + (0.001 + dist_sq_neg) * + (1.0 + a * @math.pow(dist_sq_neg, b)) + ) + let mut d = 0 while d < config.n_components { - let grad = config.learning_rate * grad_coeff_neg * (embedding[i][d] - embedding[k_random][d]) + let grad = config.learning_rate * + grad_coeff_neg * + (embedding[i][d] - embedding[k_random][d]) embedding[i][d] = embedding[i][d] + grad d = d + 1 } } - + neg = neg + 1 } - - epoch_of_next_sample[i][j] = epoch_of_next_sample[i][j] + epochs_per_sample[i][j].to_double() + + epoch_of_next_sample[i][j] = epoch_of_next_sample[i][j] + + epochs_per_sample[i][j].to_double() } } j = j + 1 } i = i + 1 } - + epoch = epoch + 1 } - - UmapResult::{ - embedding: embedding, - n_epochs: config.n_epochs, - } + + UmapResult::{ embedding, n_epochs: config.n_epochs } } // ============================================================ // Helper functions // ============================================================ +///| fn umap_pseudo_random(seed : Double) -> Double { let x = seed * 12.9898 let y_val = seed * 78.233 @@ -574,14 +612,17 @@ fn umap_pseudo_random(seed : Double) -> Double { ///| /// Create sample data for testing/demo. -pub fn create_umap_test_data(n_samples : Int, n_features : Int) -> Array[Array[Double]] { +pub fn create_umap_test_data( + n_samples : Int, + n_features : Int, +) -> Array[Array[Double]] { let data : Array[Array[Double]] = Array::new() - + let mut i = 0 while i < n_samples { let row : Array[Double] = Array::new() - let group = i % 4 // 4 clusters - + let group = i % 4 // 4 clusters + let mut j = 0 while j < n_features { let seed_val = (i * n_features + j).to_double() @@ -590,10 +631,10 @@ pub fn create_umap_test_data(n_samples : Int, n_features : Int) -> Array[Array[D row.push(cluster_center + noise) j = j + 1 } - + data.push(row) i = i + 1 } - + data } diff --git a/src/variance_partition.mbt b/src/variance_partition.mbt index 2b10dd92..9a974609 100644 --- a/src/variance_partition.mbt +++ b/src/variance_partition.mbt @@ -1472,12 +1472,8 @@ fn vp_satterthwaite_df( ///| fn vp_log_gamma(value : Double) -> Double { let coefficients = [ - 76.18009172947146, - -86.50532032941677, - 24.01409824083091, - -1.231739572450155, - 0.001208650973866179, - -0.000005395239384953, + 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, + 0.001208650973866179, -0.000005395239384953, ] let mut shifted = value let temporary = value + 5.5 @@ -1491,11 +1487,7 @@ fn vp_log_gamma(value : Double) -> Double { } ///| -fn vp_beta_continued_fraction( - x : Double, - a : Double, - b : Double, -) -> Double { +fn vp_beta_continued_fraction(x : Double, a : Double, b : Double) -> Double { let maximum_iterations = 200 let epsilon = 3.0e-14 let minimum = 1.0e-300 diff --git a/src/variant_filtering.mbt b/src/variant_filtering.mbt index 90f50dd3..3c651c12 100644 --- a/src/variant_filtering.mbt +++ b/src/variant_filtering.mbt @@ -1,5 +1,4 @@ ///| - pub struct Variant { chr : String pos : Int @@ -12,6 +11,7 @@ pub struct Variant { genotypes : Array[(String, String)] } +///| pub struct VariantFilteringParam { min_qual : Double min_depth : Int @@ -22,12 +22,14 @@ pub struct VariantFilteringParam { max_af_pop : Double } +///| pub struct VariantFilterResult { passed_variants : Array[Variant] filtered_variants : Array[(Variant, String)] filter_stats : Map[String, Int] } +///| pub struct GeneticModel { model_type : String penetrance : Double @@ -35,88 +37,129 @@ pub struct GeneticModel { allele_frequency : Double } -pub fn Variant::new(chr : String, pos : Int, id : String, ref_allele : String, - alt_allele : String, qual : Double, filter : String, - info : Map[String, String], genotypes : Array[(String, String)]) -> Variant { - Variant::{ chr, pos, id, ref_allele, alt_allele, qual, filter, info, genotypes } +///| +pub fn Variant::new( + chr : String, + pos : Int, + id : String, + ref_allele : String, + alt_allele : String, + qual : Double, + filter : String, + info : Map[String, String], + genotypes : Array[(String, String)], +) -> Variant { + Variant::{ + chr, + pos, + id, + ref_allele, + alt_allele, + qual, + filter, + info, + genotypes, + } } +///| pub fn VariantFilteringParam::new() -> VariantFilteringParam { - VariantFilteringParam::{ - min_qual: 30.0, - min_depth: 10, - min_allele_freq: 0.01, + VariantFilteringParam::{ + min_qual: 30.0, + min_depth: 10, + min_allele_freq: 0.01, max_missing_rate: 0.2, inheritance_mode: "autosomal_dominant", min_gq: 20, - max_af_pop: 0.01 + max_af_pop: 0.01, } } +///| pub fn VariantFilterResult::new() -> VariantFilterResult { - VariantFilterResult::{ - passed_variants: Array::new(), - filtered_variants: Array::new(), - filter_stats: Map([], capacity=0) + VariantFilterResult::{ + passed_variants: Array::new(), + filtered_variants: Array::new(), + filter_stats: Map([], capacity=0), } } +///| pub fn GeneticModel::new(model_type : String) -> GeneticModel { - let penetrance = - if model_type == "autosomal_dominant" { 0.95 } - else if model_type == "autosomal_recessive" { 0.95 } - else if model_type == "x_linked_dominant" { 0.95 } - else if model_type == "x_linked_recessive" { 0.95 } - else if model_type == "compound_heterozygous" { 0.95 } - else { 0.95 } - - GeneticModel::{ model_type, penetrance, phenocopy_rate: 0.01, allele_frequency: 0.001 } -} - -pub fn bio_vfilter_filter(variants : Array[Variant], params : VariantFilteringParam) -> VariantFilterResult { + let penetrance = if model_type == "autosomal_dominant" { + 0.95 + } else if model_type == "autosomal_recessive" { + 0.95 + } else if model_type == "x_linked_dominant" { + 0.95 + } else if model_type == "x_linked_recessive" { + 0.95 + } else if model_type == "compound_heterozygous" { + 0.95 + } else { + 0.95 + } + + GeneticModel::{ + model_type, + penetrance, + phenocopy_rate: 0.01, + allele_frequency: 0.001, + } +} + +///| +pub fn bio_vfilter_filter( + variants : Array[Variant], + params : VariantFilteringParam, +) -> VariantFilterResult { let mut result = VariantFilterResult::new() - + let len = variants.length() let mut i = 0 while i < len { let variant = variants[i] let mut filter_reasons : Array[String] = Array::new() - + if variant.qual < params.min_qual { filter_reasons = push_string(filter_reasons, "QUAL below threshold") } - + if variant.filter != "." && variant.filter != "PASS" { filter_reasons = push_string(filter_reasons, "FILTER not PASS") } - + let dp = parse_info_int(variant.info, "DP") if dp < params.min_depth { filter_reasons = push_string(filter_reasons, "DP below threshold") } - + let af = parse_info_double(variant.info, "AF") if af > 0.0 && af < params.min_allele_freq { filter_reasons = push_string(filter_reasons, "AF below threshold") } - + let gq_pass = check_genotype_quality(variant.genotypes, params.min_gq) if !gq_pass { filter_reasons = push_string(filter_reasons, "GQ below threshold") } - + let missing_rate = calculate_missing_rate(variant.genotypes) if missing_rate > params.max_missing_rate { - filter_reasons = push_string(filter_reasons, "Missing rate above threshold") + filter_reasons = push_string( + filter_reasons, "Missing rate above threshold", + ) } - + if params.max_af_pop > 0.0 { let af_pop = parse_info_double(variant.info, "AF_POP") if af_pop > params.max_af_pop { - filter_reasons = push_string(filter_reasons, "Population AF above threshold") + filter_reasons = push_string( + filter_reasons, "Population AF above threshold", + ) } } - + if filter_reasons.length() == 0 { result = push_variant(result, variant) } else { @@ -124,20 +167,25 @@ pub fn bio_vfilter_filter(variants : Array[Variant], params : VariantFilteringPa let mut j = 0 while j < fr_len { let reason = filter_reasons[j] - let current = if result.filter_stats.contains(reason) { result.filter_stats.get(reason).unwrap() } else { 0 } + let current = if result.filter_stats.contains(reason) { + result.filter_stats.get(reason).unwrap() + } else { + 0 + } result.filter_stats.set(reason, current + 1) j = j + 1 } let reason_str = join_strings(filter_reasons, "; ") result = push_filtered_variant(result, (variant, reason_str)) } - + i = i + 1 } - + result } +///| fn push_string(arr : Array[String], s : String) -> Array[String] { let len = arr.length() let new_arr : Array[String] = Array::new() @@ -150,7 +198,11 @@ fn push_string(arr : Array[String], s : String) -> Array[String] { new_arr } -fn push_variant(result : VariantFilterResult, v : Variant) -> VariantFilterResult { +///| +fn push_variant( + result : VariantFilterResult, + v : Variant, +) -> VariantFilterResult { let len = result.passed_variants.length() let new_passed : Array[Variant] = Array::new() let mut i = 0 @@ -162,7 +214,11 @@ fn push_variant(result : VariantFilterResult, v : Variant) -> VariantFilterResul VariantFilterResult::{ ..result, passed_variants: new_passed } } -fn push_filtered_variant(result : VariantFilterResult, v : (Variant, String)) -> VariantFilterResult { +///| +fn push_filtered_variant( + result : VariantFilterResult, + v : (Variant, String), +) -> VariantFilterResult { let len = result.filtered_variants.length() let new_filtered : Array[(Variant, String)] = Array::new() let mut i = 0 @@ -174,6 +230,7 @@ fn push_filtered_variant(result : VariantFilterResult, v : (Variant, String)) -> VariantFilterResult::{ ..result, filtered_variants: new_filtered } } +///| fn join_strings(arr : Array[String], sep : String) -> String { let len = arr.length() if len == 0 { @@ -188,6 +245,7 @@ fn join_strings(arr : Array[String], sep : String) -> String { result } +///| fn parse_info_int(info : Map[String, String], key : String) -> Int { if info.contains(key) { parse_int(info.get(key).unwrap()) @@ -196,26 +254,35 @@ fn parse_info_int(info : Map[String, String], key : String) -> Int { } } +///| fn parse_info_double(info : Map[String, String], key : String) -> Double { if info.contains(key) { let parsed = parse_double(info.get(key).unwrap()) - if parsed.is_some() { parsed.unwrap() } else { 0.0 } + if parsed.is_some() { + parsed.unwrap() + } else { + 0.0 + } } else { 0.0 } } -fn check_genotype_quality(genotypes : Array[(String, String)], min_gq : Int) -> Bool { +///| +fn check_genotype_quality( + genotypes : Array[(String, String)], + min_gq : Int, +) -> Bool { let mut pass_count = 0 let mut total = 0 - + let len = genotypes.length() let mut i = 0 while i < len { let (sample, gt) = genotypes[i] if gt != "./." { total = total + 1 - + let parts = split_by_char(gt, 58) if parts.length() >= 3 { let gq = parse_int(parts[2]) @@ -228,16 +295,17 @@ fn check_genotype_quality(genotypes : Array[(String, String)], min_gq : Int) -> } i = i + 1 } - + total == 0 || pass_count == total } +///| fn calculate_missing_rate(genotypes : Array[(String, String)]) -> Double { let len = genotypes.length() if len == 0 { return 1.0 } - + let mut missing = 0 let mut i = 0 while i < len { @@ -247,39 +315,51 @@ fn calculate_missing_rate(genotypes : Array[(String, String)]) -> Double { } i = i + 1 } - + missing.to_double() / len.to_double() } -pub fn bio_vfilter_check_inheritance(variant : Variant, model : GeneticModel, - phenotypes : Map[String, Bool]) -> Bool { - if model.model_type == "autosomal_dominant" { - check_autosomal_dominant(variant, phenotypes) - } else if model.model_type == "autosomal_recessive" { - check_autosomal_recessive(variant, phenotypes) - } else if model.model_type == "x_linked_dominant" { - check_x_linked_dominant(variant, phenotypes) - } else if model.model_type == "x_linked_recessive" { - check_x_linked_recessive(variant, phenotypes) - } else if model.model_type == "compound_heterozygous" { - check_compound_heterozygous(variant, phenotypes) - } else { - true +///| +pub fn bio_vfilter_check_inheritance( + variant : Variant, + model : GeneticModel, + phenotypes : Map[String, Bool], +) -> Bool { + if model.model_type == "autosomal_dominant" { + check_autosomal_dominant(variant, phenotypes) + } else if model.model_type == "autosomal_recessive" { + check_autosomal_recessive(variant, phenotypes) + } else if model.model_type == "x_linked_dominant" { + check_x_linked_dominant(variant, phenotypes) + } else if model.model_type == "x_linked_recessive" { + check_x_linked_recessive(variant, phenotypes) + } else if model.model_type == "compound_heterozygous" { + check_compound_heterozygous(variant, phenotypes) + } else { + true } } -fn check_autosomal_dominant(variant : Variant, phenotypes : Map[String, Bool]) -> Bool { +///| +fn check_autosomal_dominant( + variant : Variant, + phenotypes : Map[String, Bool], +) -> Bool { let mut affected_carriers = 0 let mut unaffected_carriers = 0 let mut affected_non_carriers = 0 - + let len = variant.genotypes.length() let mut i = 0 while i < len { let (sample, gt) = variant.genotypes[i] - let is_affected = if phenotypes.contains(sample) { phenotypes.get(sample).unwrap() } else { false } + let is_affected = if phenotypes.contains(sample) { + phenotypes.get(sample).unwrap() + } else { + false + } let is_carrier = is_carrier_gt(gt) - + if is_affected && is_carrier { affected_carriers = affected_carriers + 1 } else if !is_affected && is_carrier { @@ -287,26 +367,34 @@ fn check_autosomal_dominant(variant : Variant, phenotypes : Map[String, Bool]) - } else if is_affected && !is_carrier { affected_non_carriers = affected_non_carriers + 1 } - + i = i + 1 } - + affected_non_carriers == 0 && affected_carriers >= 1 } -fn check_autosomal_recessive(variant : Variant, phenotypes : Map[String, Bool]) -> Bool { +///| +fn check_autosomal_recessive( + variant : Variant, + phenotypes : Map[String, Bool], +) -> Bool { let mut affected_homozygous = 0 let mut unaffected_homozygous = 0 let mut affected_heterozygous = 0 - + let len = variant.genotypes.length() let mut i = 0 while i < len { let (sample, gt) = variant.genotypes[i] - let is_affected = if phenotypes.contains(sample) { phenotypes.get(sample).unwrap() } else { false } + let is_affected = if phenotypes.contains(sample) { + phenotypes.get(sample).unwrap() + } else { + false + } let is_homozygous = is_homozygous_gt(gt) let is_heterozygous = is_heterozygous_gt(gt) - + if is_affected && is_homozygous { affected_homozygous = affected_homozygous + 1 } else if !is_affected && is_homozygous { @@ -314,140 +402,177 @@ fn check_autosomal_recessive(variant : Variant, phenotypes : Map[String, Bool]) } else if is_affected && is_heterozygous { affected_heterozygous = affected_heterozygous + 1 } - + i = i + 1 } - - affected_heterozygous == 0 && unaffected_homozygous == 0 && affected_homozygous >= 1 + + affected_heterozygous == 0 && + unaffected_homozygous == 0 && + affected_homozygous >= 1 } -fn check_x_linked_dominant(variant : Variant, phenotypes : Map[String, Bool]) -> Bool { +///| +fn check_x_linked_dominant( + variant : Variant, + phenotypes : Map[String, Bool], +) -> Bool { if !is_x_chromosome(variant.chr) { return false } - + let mut affected_males_with_mut = 0 let mut unaffected_males_with_mut = 0 let mut affected_females_with_mut = 0 let mut unaffected_females_with_mut = 0 - + let len = variant.genotypes.length() let mut i = 0 while i < len { let (sample, gt) = variant.genotypes[i] - let is_affected = if phenotypes.contains(sample) { phenotypes.get(sample).unwrap() } else { false } + let is_affected = if phenotypes.contains(sample) { + phenotypes.get(sample).unwrap() + } else { + false + } let is_carrier = is_carrier_gt(gt) - + if is_male(sample) { if is_affected && is_carrier { affected_males_with_mut = affected_males_with_mut + 1 } else if !is_affected && is_carrier { unaffected_males_with_mut = unaffected_males_with_mut + 1 } - } else { - if is_affected && is_carrier { - affected_females_with_mut = affected_females_with_mut + 1 - } else if !is_affected && is_carrier { - unaffected_females_with_mut = unaffected_females_with_mut + 1 - } + } else if is_affected && is_carrier { + affected_females_with_mut = affected_females_with_mut + 1 + } else if !is_affected && is_carrier { + unaffected_females_with_mut = unaffected_females_with_mut + 1 } - + i = i + 1 } - + unaffected_males_with_mut == 0 && affected_males_with_mut >= 1 } -fn check_x_linked_recessive(variant : Variant, phenotypes : Map[String, Bool]) -> Bool { +///| +fn check_x_linked_recessive( + variant : Variant, + phenotypes : Map[String, Bool], +) -> Bool { if !is_x_chromosome(variant.chr) { return false } - + let mut affected_males_with_mut = 0 let mut unaffected_males_with_mut = 0 let mut affected_females_homozygous = 0 let mut unaffected_females_homozygous = 0 - + let len = variant.genotypes.length() let mut i = 0 while i < len { let (sample, gt) = variant.genotypes[i] - let is_affected = if phenotypes.contains(sample) { phenotypes.get(sample).unwrap() } else { false } + let is_affected = if phenotypes.contains(sample) { + phenotypes.get(sample).unwrap() + } else { + false + } let is_carrier = is_carrier_gt(gt) let is_homozygous = is_homozygous_gt(gt) - + if is_male(sample) { if is_affected && is_carrier { affected_males_with_mut = affected_males_with_mut + 1 } else if !is_affected && is_carrier { unaffected_males_with_mut = unaffected_males_with_mut + 1 } - } else { - if is_affected && is_homozygous { - affected_females_homozygous = affected_females_homozygous + 1 - } else if !is_affected && is_homozygous { - unaffected_females_homozygous = unaffected_females_homozygous + 1 - } + } else if is_affected && is_homozygous { + affected_females_homozygous = affected_females_homozygous + 1 + } else if !is_affected && is_homozygous { + unaffected_females_homozygous = unaffected_females_homozygous + 1 } - + i = i + 1 } - - unaffected_males_with_mut == 0 && unaffected_females_homozygous == 0 && (affected_males_with_mut >= 1 || affected_females_homozygous >= 1) + + unaffected_males_with_mut == 0 && + unaffected_females_homozygous == 0 && + (affected_males_with_mut >= 1 || affected_females_homozygous >= 1) } -fn check_compound_heterozygous(variant : Variant, phenotypes : Map[String, Bool]) -> Bool { +///| +fn check_compound_heterozygous( + variant : Variant, + phenotypes : Map[String, Bool], +) -> Bool { let mut affected_heterozygous = 0 let mut unaffected_heterozygous = 0 - + let len = variant.genotypes.length() let mut i = 0 while i < len { let (sample, gt) = variant.genotypes[i] - let is_affected = if phenotypes.contains(sample) { phenotypes.get(sample).unwrap() } else { false } + let is_affected = if phenotypes.contains(sample) { + phenotypes.get(sample).unwrap() + } else { + false + } let is_heterozygous = is_heterozygous_gt(gt) - + if is_affected && is_heterozygous { affected_heterozygous = affected_heterozygous + 1 } else if !is_affected && is_heterozygous { unaffected_heterozygous = unaffected_heterozygous + 1 } - + i = i + 1 } - + affected_heterozygous >= 2 && unaffected_heterozygous > 0 } +///| fn is_carrier_gt(gt : String) -> Bool { - gt == "0/1" || gt == "1/0" || gt == "1/1" || gt == "0|1" || gt == "1|0" || gt == "1|1" + gt == "0/1" || + gt == "1/0" || + gt == "1/1" || + gt == "0|1" || + gt == "1|0" || + gt == "1|1" } +///| fn is_homozygous_gt(gt : String) -> Bool { gt == "1/1" || gt == "1|1" } +///| fn is_heterozygous_gt(gt : String) -> Bool { gt == "0/1" || gt == "1/0" || gt == "0|1" || gt == "1|0" } +///| fn is_x_chromosome(chr : String) -> Bool { chr == "X" || chr == "x" || chr == "chrX" || chr == "chrX" || chr == "23" } +///| fn is_male(sample : String) -> Bool { let lower_sample = to_lowercase(sample) - lower_sample.ends_with("_male") || contains_substring(lower_sample, "father") || contains_substring(lower_sample, "son") + lower_sample.ends_with("_male") || + contains_substring(lower_sample, "father") || + contains_substring(lower_sample, "son") } +///| fn contains_substring(s : String, substr : String) -> Bool { let s_len = s.length() let sub_len = substr.length() - + if sub_len == 0 || s_len < sub_len { return false } - + let mut i = 0 while i <= s_len - sub_len { let current = substring(s, i, sub_len) @@ -456,12 +581,16 @@ fn contains_substring(s : String, substr : String) -> Bool { } i = i + 1 } - + false } -pub fn bio_vfilter_filter_by_inheritance(variants : Array[Variant], model : GeneticModel, - phenotypes : Map[String, Bool]) -> Array[Variant] { +///| +pub fn bio_vfilter_filter_by_inheritance( + variants : Array[Variant], + model : GeneticModel, + phenotypes : Map[String, Bool], +) -> Array[Variant] { let len = variants.length() let mut result : Array[Variant] = Array::new() let mut i = 0 @@ -475,6 +604,7 @@ pub fn bio_vfilter_filter_by_inheritance(variants : Array[Variant], model : Gene result } +///| fn push_variant_array(arr : Array[Variant], v : Variant) -> Array[Variant] { let len = arr.length() let new_arr : Array[Variant] = Array::new() @@ -487,29 +617,37 @@ fn push_variant_array(arr : Array[Variant], v : Variant) -> Array[Variant] { new_arr } +///| pub fn bio_vfilter_summary(result : VariantFilterResult) -> String { let mut summary = "\nVariant Filtering Summary\n" summary = summary + "=".repeat(60) + "\n" - - let total = result.passed_variants.length() + result.filtered_variants.length() - + + let total = result.passed_variants.length() + + result.filtered_variants.length() + summary = summary + "Total variants: " + total.to_string() + "\n" - summary = summary + "Passed: " + result.passed_variants.length().to_string() + "\n" - summary = summary + "Filtered: " + result.filtered_variants.length().to_string() + "\n" - + summary = summary + + "Passed: " + + result.passed_variants.length().to_string() + + "\n" + summary = summary + + "Filtered: " + + result.filtered_variants.length().to_string() + + "\n" + summary = summary + "\nFilter statistics:\n" summary = summary + "-".repeat(60) + "\n" - + let entries = result.filter_stats.iter().collect() let entries_len = entries.length() - + let mut sorted : Array[(String, Int)] = Array::new() let mut i = 0 while i < entries_len { sorted.push(entries[i]) i = i + 1 } - + let mut j = 0 while j < entries_len { let mut k = j + 1 @@ -534,20 +672,21 @@ pub fn bio_vfilter_summary(result : VariantFilterResult) -> String { } j = j + 1 } - + let mut l = 0 while l < sorted.length() { let (reason, count) = sorted[l] summary = summary + reason + ": " + count.to_string() + "\n" l = l + 1 } - + summary } +///| pub fn bio_vfilter_predict_consequence(variant : Variant) -> String { let len_diff = variant.alt_allele.length() - variant.ref_allele.length() - + if len_diff == 0 { "missense_variant" } else if len_diff > 0 { @@ -555,4 +694,4 @@ pub fn bio_vfilter_predict_consequence(variant : Variant) -> String { } else { "deletion" } -} \ No newline at end of file +} diff --git a/src/variation.mbt b/src/variation.mbt index e8607f0d..74d3367f 100644 --- a/src/variation.mbt +++ b/src/variation.mbt @@ -43,7 +43,15 @@ pub fn Mutation::new( mutation_type : String, impact : String, ) -> Mutation { - Mutation::{ gene, protein, position, original_aa, mutated_aa, mutation_type, impact } + Mutation::{ + gene, + protein, + position, + original_aa, + mutated_aa, + mutation_type, + impact, + } } ///| @@ -81,21 +89,31 @@ pub fn AminoAcidSubstitution::new( blosum62_score : Int, grantham_distance : Double, ) -> AminoAcidSubstitution { - AminoAcidSubstitution::{ original, mutated, blosum62_score, grantham_distance } + AminoAcidSubstitution::{ + original, + mutated, + blosum62_score, + grantham_distance, + } } ///| fn blosum62_matrix() -> Map[String, Map[String, Int]] { let matrix : Map[String, Map[String, Int]] = Map([], capacity=20) - - let amino_acids = ["A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F", "P", "S", "T", "W", "Y", "V"] - + + let amino_acids = [ + "A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F", "P", "S", + "T", "W", "Y", "V", + ] + let scores = [ [4, -1, -2, -2, 0, -1, -1, 0, -2, -1, -1, -1, -1, -2, -1, 1, 0, -3, -2, 0], [-1, 5, 0, -2, -3, 1, 0, -2, 0, -3, -2, 2, -1, -3, -2, -1, -1, -3, -2, -3], [-2, 0, 6, 1, -3, 0, 0, 0, 1, -3, -3, 0, -2, -3, -2, 1, 0, -4, -2, -3], [-2, -2, 1, 6, -3, 0, 2, -1, -1, -3, -4, -1, -3, -3, -1, 0, -1, -4, -3, -3], - [0, -3, -3, -3, 9, -3, -4, -3, -3, -1, -1, -3, -1, -2, -3, -1, -1, -2, -2, -1], + [ + 0, -3, -3, -3, 9, -3, -4, -3, -3, -1, -1, -3, -1, -2, -3, -1, -1, -2, -2, -1, + ], [-1, 1, 0, 0, -3, 5, 2, -2, 0, -3, -2, 1, 0, -3, -1, 0, -1, -2, -1, -2], [-1, 0, 0, 2, -4, 2, 5, -2, 0, -3, -3, 1, -2, -3, -1, 0, -1, -3, -2, -2], [0, -2, 0, -1, -3, -2, -2, 6, -2, -4, -4, -2, -3, -3, -2, 0, -2, -2, -3, -3], @@ -105,14 +123,19 @@ fn blosum62_matrix() -> Map[String, Map[String, Int]] { [-1, 2, 0, -1, -3, 1, 1, -2, -1, -3, -2, 5, -1, -3, -1, 0, -1, -3, -2, -2], [-1, -1, -2, -3, -1, 0, -2, -3, -2, 1, 2, -1, 5, 0, -2, -1, -1, -1, -1, 1], [-2, -3, -3, -3, -2, -3, -3, -3, -1, 0, 0, -3, 0, 6, -4, -2, -2, 1, 3, -1], - [-1, -2, -2, -1, -3, -1, -1, -2, -2, -3, -3, -1, -2, -4, 7, -1, -1, -4, -3, -2], + [ + -1, -2, -2, -1, -3, -1, -1, -2, -2, -3, -3, -1, -2, -4, 7, -1, -1, -4, -3, + -2, + ], [1, -1, 1, 0, -1, 0, 0, 0, -1, -2, -2, 0, -1, -2, -1, 4, 1, -3, -2, -2], [0, -1, 0, -1, -1, -1, -1, -2, -2, -1, -1, -1, -1, -2, -1, 1, 5, -2, -2, 0], - [-3, -3, -4, -4, -2, -2, -3, -2, -2, -3, -2, -3, -1, 1, -4, -3, -2, 11, 2, -3], + [ + -3, -3, -4, -4, -2, -2, -3, -2, -2, -3, -2, -3, -1, 1, -4, -3, -2, 11, 2, -3, + ], [-2, -2, -2, -3, -2, -1, -2, -3, 2, -1, -1, -2, -1, 3, -3, -2, -2, 2, 7, -1], [0, -3, -3, -3, -1, -2, -2, -3, -3, 3, 1, -2, 1, -1, -2, -2, 0, -3, -1, 4], ] - + let mut i = 0 while i < amino_acids.length() { let row_map : Map[String, Int] = Map([], capacity=20) @@ -124,39 +147,102 @@ fn blosum62_matrix() -> Map[String, Map[String, Int]] { matrix.set(amino_acids[i], row_map) i = i + 1 } - + matrix } ///| fn grantham_matrix() -> Map[String, Map[String, Double]] { let matrix : Map[String, Map[String, Double]] = Map([], capacity=20) - - let amino_acids = ["A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F", "P", "S", "T", "W", "Y", "V"] - + + let amino_acids = [ + "A", "R", "N", "D", "C", "Q", "E", "G", "H", "I", "L", "K", "M", "F", "P", "S", + "T", "W", "Y", "V", + ] + let distances = [ - [0.0, 112.0, 145.0, 145.0, 130.0, 119.0, 118.0, 75.0, 127.0, 96.0, 96.0, 125.0, 107.0, 130.0, 97.0, 56.0, 60.0, 157.0, 147.0, 90.0], - [112.0, 0.0, 85.0, 85.0, 145.0, 60.0, 64.0, 125.0, 48.0, 142.0, 142.0, 26.0, 130.0, 165.0, 143.0, 97.0, 101.0, 153.0, 152.0, 136.0], - [145.0, 85.0, 0.0, 20.0, 157.0, 38.0, 55.0, 110.0, 66.0, 171.0, 171.0, 70.0, 159.0, 189.0, 157.0, 82.0, 86.0, 180.0, 168.0, 165.0], - [145.0, 85.0, 20.0, 0.0, 157.0, 58.0, 35.0, 110.0, 86.0, 171.0, 171.0, 70.0, 159.0, 189.0, 157.0, 82.0, 86.0, 180.0, 168.0, 165.0], - [130.0, 145.0, 157.0, 157.0, 0.0, 148.0, 147.0, 95.0, 145.0, 108.0, 108.0, 153.0, 119.0, 126.0, 127.0, 78.0, 82.0, 144.0, 134.0, 102.0], - [119.0, 60.0, 38.0, 58.0, 148.0, 0.0, 25.0, 104.0, 46.0, 151.0, 151.0, 45.0, 139.0, 178.0, 146.0, 73.0, 77.0, 169.0, 157.0, 145.0], - [118.0, 64.0, 55.0, 35.0, 147.0, 25.0, 0.0, 103.0, 66.0, 150.0, 150.0, 49.0, 138.0, 177.0, 145.0, 72.0, 76.0, 168.0, 156.0, 144.0], - [75.0, 125.0, 110.0, 110.0, 95.0, 104.0, 103.0, 0.0, 112.0, 91.0, 91.0, 130.0, 102.0, 125.0, 87.0, 60.0, 64.0, 152.0, 142.0, 85.0], - [127.0, 48.0, 66.0, 86.0, 145.0, 46.0, 66.0, 112.0, 0.0, 149.0, 149.0, 58.0, 137.0, 175.0, 154.0, 89.0, 93.0, 166.0, 148.0, 143.0], - [96.0, 142.0, 171.0, 171.0, 108.0, 151.0, 150.0, 91.0, 149.0, 0.0, 9.0, 159.0, 21.0, 41.0, 112.0, 100.0, 66.0, 84.0, 66.0, 28.0], - [96.0, 142.0, 171.0, 171.0, 108.0, 151.0, 150.0, 91.0, 149.0, 9.0, 0.0, 159.0, 12.0, 32.0, 112.0, 100.0, 66.0, 75.0, 57.0, 19.0], - [125.0, 26.0, 70.0, 70.0, 153.0, 45.0, 49.0, 130.0, 58.0, 159.0, 159.0, 0.0, 147.0, 182.0, 160.0, 104.0, 108.0, 167.0, 166.0, 153.0], - [107.0, 130.0, 159.0, 159.0, 119.0, 139.0, 138.0, 102.0, 137.0, 21.0, 12.0, 147.0, 0.0, 53.0, 123.0, 112.0, 78.0, 96.0, 78.0, 40.0], - [130.0, 165.0, 189.0, 189.0, 126.0, 178.0, 177.0, 125.0, 175.0, 41.0, 32.0, 182.0, 53.0, 0.0, 143.0, 133.0, 99.0, 67.0, 17.0, 63.0], - [97.0, 143.0, 157.0, 157.0, 127.0, 146.0, 145.0, 87.0, 154.0, 112.0, 112.0, 160.0, 123.0, 143.0, 0.0, 63.0, 67.0, 174.0, 164.0, 106.0], - [56.0, 97.0, 82.0, 82.0, 78.0, 73.0, 72.0, 60.0, 89.0, 100.0, 100.0, 104.0, 112.0, 133.0, 63.0, 0.0, 19.0, 145.0, 135.0, 94.0], - [60.0, 101.0, 86.0, 86.0, 82.0, 77.0, 76.0, 64.0, 93.0, 66.0, 66.0, 108.0, 78.0, 99.0, 67.0, 19.0, 0.0, 149.0, 139.0, 60.0], - [157.0, 153.0, 180.0, 180.0, 144.0, 169.0, 168.0, 152.0, 166.0, 84.0, 75.0, 167.0, 96.0, 67.0, 174.0, 145.0, 149.0, 0.0, 80.0, 106.0], - [147.0, 152.0, 168.0, 168.0, 134.0, 157.0, 156.0, 142.0, 148.0, 66.0, 57.0, 166.0, 78.0, 17.0, 164.0, 135.0, 139.0, 80.0, 0.0, 88.0], - [90.0, 136.0, 165.0, 165.0, 102.0, 145.0, 144.0, 85.0, 143.0, 28.0, 19.0, 153.0, 40.0, 63.0, 106.0, 94.0, 60.0, 106.0, 88.0, 0.0], + [ + 0.0, 112.0, 145.0, 145.0, 130.0, 119.0, 118.0, 75.0, 127.0, 96.0, 96.0, 125.0, + 107.0, 130.0, 97.0, 56.0, 60.0, 157.0, 147.0, 90.0, + ], + [ + 112.0, 0.0, 85.0, 85.0, 145.0, 60.0, 64.0, 125.0, 48.0, 142.0, 142.0, 26.0, + 130.0, 165.0, 143.0, 97.0, 101.0, 153.0, 152.0, 136.0, + ], + [ + 145.0, 85.0, 0.0, 20.0, 157.0, 38.0, 55.0, 110.0, 66.0, 171.0, 171.0, 70.0, + 159.0, 189.0, 157.0, 82.0, 86.0, 180.0, 168.0, 165.0, + ], + [ + 145.0, 85.0, 20.0, 0.0, 157.0, 58.0, 35.0, 110.0, 86.0, 171.0, 171.0, 70.0, + 159.0, 189.0, 157.0, 82.0, 86.0, 180.0, 168.0, 165.0, + ], + [ + 130.0, 145.0, 157.0, 157.0, 0.0, 148.0, 147.0, 95.0, 145.0, 108.0, 108.0, 153.0, + 119.0, 126.0, 127.0, 78.0, 82.0, 144.0, 134.0, 102.0, + ], + [ + 119.0, 60.0, 38.0, 58.0, 148.0, 0.0, 25.0, 104.0, 46.0, 151.0, 151.0, 45.0, + 139.0, 178.0, 146.0, 73.0, 77.0, 169.0, 157.0, 145.0, + ], + [ + 118.0, 64.0, 55.0, 35.0, 147.0, 25.0, 0.0, 103.0, 66.0, 150.0, 150.0, 49.0, + 138.0, 177.0, 145.0, 72.0, 76.0, 168.0, 156.0, 144.0, + ], + [ + 75.0, 125.0, 110.0, 110.0, 95.0, 104.0, 103.0, 0.0, 112.0, 91.0, 91.0, 130.0, + 102.0, 125.0, 87.0, 60.0, 64.0, 152.0, 142.0, 85.0, + ], + [ + 127.0, 48.0, 66.0, 86.0, 145.0, 46.0, 66.0, 112.0, 0.0, 149.0, 149.0, 58.0, + 137.0, 175.0, 154.0, 89.0, 93.0, 166.0, 148.0, 143.0, + ], + [ + 96.0, 142.0, 171.0, 171.0, 108.0, 151.0, 150.0, 91.0, 149.0, 0.0, 9.0, 159.0, + 21.0, 41.0, 112.0, 100.0, 66.0, 84.0, 66.0, 28.0, + ], + [ + 96.0, 142.0, 171.0, 171.0, 108.0, 151.0, 150.0, 91.0, 149.0, 9.0, 0.0, 159.0, + 12.0, 32.0, 112.0, 100.0, 66.0, 75.0, 57.0, 19.0, + ], + [ + 125.0, 26.0, 70.0, 70.0, 153.0, 45.0, 49.0, 130.0, 58.0, 159.0, 159.0, 0.0, + 147.0, 182.0, 160.0, 104.0, 108.0, 167.0, 166.0, 153.0, + ], + [ + 107.0, 130.0, 159.0, 159.0, 119.0, 139.0, 138.0, 102.0, 137.0, 21.0, 12.0, + 147.0, 0.0, 53.0, 123.0, 112.0, 78.0, 96.0, 78.0, 40.0, + ], + [ + 130.0, 165.0, 189.0, 189.0, 126.0, 178.0, 177.0, 125.0, 175.0, 41.0, 32.0, + 182.0, 53.0, 0.0, 143.0, 133.0, 99.0, 67.0, 17.0, 63.0, + ], + [ + 97.0, 143.0, 157.0, 157.0, 127.0, 146.0, 145.0, 87.0, 154.0, 112.0, 112.0, + 160.0, 123.0, 143.0, 0.0, 63.0, 67.0, 174.0, 164.0, 106.0, + ], + [ + 56.0, 97.0, 82.0, 82.0, 78.0, 73.0, 72.0, 60.0, 89.0, 100.0, 100.0, 104.0, + 112.0, 133.0, 63.0, 0.0, 19.0, 145.0, 135.0, 94.0, + ], + [ + 60.0, 101.0, 86.0, 86.0, 82.0, 77.0, 76.0, 64.0, 93.0, 66.0, 66.0, 108.0, 78.0, + 99.0, 67.0, 19.0, 0.0, 149.0, 139.0, 60.0, + ], + [ + 157.0, 153.0, 180.0, 180.0, 144.0, 169.0, 168.0, 152.0, 166.0, 84.0, 75.0, + 167.0, 96.0, 67.0, 174.0, 145.0, 149.0, 0.0, 80.0, 106.0, + ], + [ + 147.0, 152.0, 168.0, 168.0, 134.0, 157.0, 156.0, 142.0, 148.0, 66.0, 57.0, + 166.0, 78.0, 17.0, 164.0, 135.0, 139.0, 80.0, 0.0, 88.0, + ], + [ + 90.0, 136.0, 165.0, 165.0, 102.0, 145.0, 144.0, 85.0, 143.0, 28.0, 19.0, 153.0, + 40.0, 63.0, 106.0, 94.0, 60.0, 106.0, 88.0, 0.0, + ], ] - + let mut i = 0 while i < amino_acids.length() { let row_map : Map[String, Double] = Map([], capacity=20) @@ -168,7 +254,7 @@ fn grantham_matrix() -> Map[String, Map[String, Double]] { matrix.set(amino_acids[i], row_map) i = i + 1 } - + matrix } @@ -192,29 +278,38 @@ pub fn detect_mutations( alt_allele : String, ) -> Array[Mutation] { let mutations : Array[Mutation] = Array::new() - + let codon_start = (variant_position - 1) / 3 * 3 let codon_end = codon_start + 3 - + if codon_end <= dna_sequence.length() { let original_codon = substring(dna_sequence, codon_start, 3) - let new_sequence = replace_char_at(dna_sequence, variant_position - 1, alt_allele) + let new_sequence = replace_char_at( + dna_sequence, + variant_position - 1, + alt_allele, + ) let mutated_codon = substring(new_sequence, codon_start, 3) - + let original_aa = variation_translate_codon(original_codon) let mutated_aa = variation_translate_codon(mutated_codon) - + let mutation_type = classify_mutation(original_aa, mutated_aa) let impact = predict_impact(original_aa, mutated_aa, mutation_type) - - mutations.push(Mutation::new( - gene, protein, - codon_start / 3 + 1, - original_aa, mutated_aa, - mutation_type, impact, - )) + + mutations.push( + Mutation::new( + gene, + protein, + codon_start / 3 + 1, + original_aa, + mutated_aa, + mutation_type, + impact, + ), + ) } - + mutations } @@ -223,36 +318,87 @@ fn replace_char_at(s : String, idx : Int, replacement : String) -> String { if idx < 0 || idx >= s.length() || replacement.length() == 0 { return s } - + let prefix = substring(s, 0, idx) let suffix = substring(s, idx + 1, s.length() - idx - 1) - + prefix + substring(replacement, 0, 1) + suffix } ///| fn variation_translate_codon(codon : String) -> String { let codon_upper = variation_to_uppercase(codon) - - let codon_table = Map([ - ("TTT", "F"), ("TTC", "F"), ("TTA", "L"), ("TTG", "L"), - ("CTT", "L"), ("CTC", "L"), ("CTA", "L"), ("CTG", "L"), - ("ATT", "I"), ("ATC", "I"), ("ATA", "I"), ("ATG", "M"), - ("GTT", "V"), ("GTC", "V"), ("GTA", "V"), ("GTG", "V"), - ("TCT", "S"), ("TCC", "S"), ("TCA", "S"), ("TCG", "S"), - ("CCT", "P"), ("CCC", "P"), ("CCA", "P"), ("CCG", "P"), - ("ACT", "T"), ("ACC", "T"), ("ACA", "T"), ("ACG", "T"), - ("GCT", "A"), ("GCC", "A"), ("GCA", "A"), ("GCG", "A"), - ("TAT", "Y"), ("TAC", "Y"), ("TAA", "*"), ("TAG", "*"), - ("CAT", "H"), ("CAC", "H"), ("CAA", "Q"), ("CAG", "Q"), - ("AAT", "N"), ("AAC", "N"), ("AAA", "K"), ("AAG", "K"), - ("GAT", "D"), ("GAC", "D"), ("GAA", "E"), ("GAG", "E"), - ("TGT", "C"), ("TGC", "C"), ("TGA", "*"), ("TGG", "W"), - ("CGT", "R"), ("CGC", "R"), ("CGA", "R"), ("CGG", "R"), - ("AGT", "S"), ("AGC", "S"), ("AGA", "R"), ("AGG", "R"), - ("GGT", "G"), ("GGC", "G"), ("GGA", "G"), ("GGG", "G"), - ], capacity=64) - + + let codon_table = Map( + [ + ("TTT", "F"), + ("TTC", "F"), + ("TTA", "L"), + ("TTG", "L"), + ("CTT", "L"), + ("CTC", "L"), + ("CTA", "L"), + ("CTG", "L"), + ("ATT", "I"), + ("ATC", "I"), + ("ATA", "I"), + ("ATG", "M"), + ("GTT", "V"), + ("GTC", "V"), + ("GTA", "V"), + ("GTG", "V"), + ("TCT", "S"), + ("TCC", "S"), + ("TCA", "S"), + ("TCG", "S"), + ("CCT", "P"), + ("CCC", "P"), + ("CCA", "P"), + ("CCG", "P"), + ("ACT", "T"), + ("ACC", "T"), + ("ACA", "T"), + ("ACG", "T"), + ("GCT", "A"), + ("GCC", "A"), + ("GCA", "A"), + ("GCG", "A"), + ("TAT", "Y"), + ("TAC", "Y"), + ("TAA", "*"), + ("TAG", "*"), + ("CAT", "H"), + ("CAC", "H"), + ("CAA", "Q"), + ("CAG", "Q"), + ("AAT", "N"), + ("AAC", "N"), + ("AAA", "K"), + ("AAG", "K"), + ("GAT", "D"), + ("GAC", "D"), + ("GAA", "E"), + ("GAG", "E"), + ("TGT", "C"), + ("TGC", "C"), + ("TGA", "*"), + ("TGG", "W"), + ("CGT", "R"), + ("CGC", "R"), + ("CGA", "R"), + ("CGG", "R"), + ("AGT", "S"), + ("AGC", "S"), + ("AGA", "R"), + ("AGG", "R"), + ("GGT", "G"), + ("GGC", "G"), + ("GGA", "G"), + ("GGG", "G"), + ], + capacity=64, + ) + codon_table.get(codon_upper).unwrap_or("?") } @@ -264,7 +410,8 @@ fn variation_to_uppercase(s : String) -> String { let c = s.unsafe_get(i) let c_int = c.to_int() if c_int >= 'a'.to_int() && c_int <= 'z'.to_int() { - result = result + (c_int - 'a'.to_int() + 'A'.to_int()).to_char().to_string() + result = result + + (c_int - 'a'.to_int() + 'A'.to_int()).to_char().to_string() } else { result = result + c.to_string() } @@ -284,7 +431,7 @@ fn classify_mutation(original : String, mutated : String) -> String { if original == "*" { return "Frameshift" } - + let aa_groups = [ ["G", "A", "V", "L", "I", "M"], ["F", "Y", "W"], @@ -293,10 +440,10 @@ fn classify_mutation(original : String, mutated : String) -> String { ["R", "K", "H"], ["C", "P"], ] - + let mut original_group = -1 let mut mutated_group = -1 - + let mut i = 0 while i < aa_groups.length() { let mut j = 0 @@ -311,7 +458,7 @@ fn classify_mutation(original : String, mutated : String) -> String { } i = i + 1 } - + if original_group == mutated_group { "Conservative" } else { @@ -320,7 +467,11 @@ fn classify_mutation(original : String, mutated : String) -> String { } ///| -fn predict_impact(original : String, mutated : String, mutation_type : String) -> String { +fn predict_impact( + original : String, + mutated : String, + mutation_type : String, +) -> String { if mutation_type == "Nonsense" { return "High" } @@ -337,24 +488,27 @@ fn predict_impact(original : String, mutated : String, mutation_type : String) - } ///| -pub fn analyze_amino_acid_substitution(original : String, mutated : String) -> AminoAcidSubstitution { +pub fn analyze_amino_acid_substitution( + original : String, + mutated : String, +) -> AminoAcidSubstitution { let blosum62 = blosum62_matrix() let grantham = grantham_matrix() - + let blosum_val = blosum62.get(original) let blosum_score = if blosum_val.is_some() { blosum_val.unwrap().get(mutated).unwrap_or(0) } else { 0 } - + let grantham_val = grantham.get(original) let grantham_dist = if grantham_val.is_some() { grantham_val.unwrap().get(mutated).unwrap_or(0.0) } else { 0.0 } - + AminoAcidSubstitution::new(original, mutated, blosum_score, grantham_dist) } @@ -369,31 +523,41 @@ pub fn parse_vcf_line(line : String) -> VariationRecord? { if parts.length() < 5 { return None } - + let chromosome = parts[0] let position_str = parts[1] let ref_allele = parts[3] let alt_allele = parts[4] - + let position = parse_int(position_str) - - Some(VariationRecord::new(chromosome, position, ref_allele, alt_allele, Array::new())) + + Some( + VariationRecord::new( + chromosome, + position, + ref_allele, + alt_allele, + Array::new(), + ), + ) } ///| pub fn create_example_variation_data() -> Array[VariationRecord] { let records : Array[VariationRecord] = Array::new() - + let mutations1 = [ - Mutation::new("BRCA1", "BRCA1_HUMAN", 178, "G", "A", "Non-conservative", "Medium"), + Mutation::new( + "BRCA1", "BRCA1_HUMAN", 178, "G", "A", "Non-conservative", "Medium", + ), Mutation::new("BRCA1", "BRCA1_HUMAN", 356, "R", "*", "Nonsense", "High"), ] records.push(VariationRecord::new("17", 43044295, "C", "T", mutations1)) - + let mutations2 = [ Mutation::new("TP53", "P53_HUMAN", 273, "R", "H", "Conservative", "Low"), ] records.push(VariationRecord::new("17", 7577538, "G", "A", mutations2)) - + records -} \ No newline at end of file +} diff --git a/src/vcf.mbt b/src/vcf.mbt index 9557c302..92f8d54a 100644 --- a/src/vcf.mbt +++ b/src/vcf.mbt @@ -299,7 +299,9 @@ pub fn VcfFile::get_version(self : VcfFile) -> String? { ///| /// Check if variant is a SNP (single nucleotide polymorphism). pub fn VcfRecord::is_snp(self : VcfRecord) -> Bool { - self.ref_seq.length() == 1 && self.alt.length() == 1 && self.alt[0].length() == 1 + self.ref_seq.length() == 1 && + self.alt.length() == 1 && + self.alt[0].length() == 1 } ///| diff --git a/src/velociraptor.mbt b/src/velociraptor.mbt index 6dd489de..8111a394 100644 --- a/src/velociraptor.mbt +++ b/src/velociraptor.mbt @@ -29,7 +29,7 @@ pub struct VelocityGeneData { pub fn VelocityGeneData::new( gene_name : String, spliced : Array[Double], - unspliced : Array[Double] + unspliced : Array[Double], ) -> VelocityGeneData { VelocityGeneData::{ gene_name, spliced, unspliced } } @@ -136,9 +136,9 @@ pub fn EmbeddingVelocity::embedding(self : EmbeddingVelocity) -> Array[Double] { ///| /// Accessor for velocity embedding. -pub fn EmbeddingVelocity::velocity_embedding(self : EmbeddingVelocity) -> Array[ - Double -] { +pub fn EmbeddingVelocity::velocity_embedding( + self : EmbeddingVelocity, +) -> Array[Double] { self.velocity_embedding } @@ -146,6 +146,7 @@ pub fn EmbeddingVelocity::velocity_embedding(self : EmbeddingVelocity) -> Array[ // Internal helpers // =========================================================================== +///| fn vr_abs(x : Double) -> Double { if x < 0.0 { -x @@ -154,6 +155,7 @@ fn vr_abs(x : Double) -> Double { } } +///| fn vr_sqrt(x : Double) -> Double { if x <= 0.0 { return 0.0 @@ -173,6 +175,7 @@ fn vr_sqrt(x : Double) -> Double { guess } +///| fn vr_log(x : Double) -> Double { if x <= 0.0 { return -700.0 @@ -180,6 +183,7 @@ fn vr_log(x : Double) -> Double { @math.ln(x) } +///| fn vr_exp(x : Double) -> Double { if x > 700.0 { return 1.7976931348623157e308 @@ -190,6 +194,7 @@ fn vr_exp(x : Double) -> Double { @math.exp(x) } +///| fn vr_mean(arr : Array[Double]) -> Double { let n = arr.length() if n == 0 { @@ -202,6 +207,7 @@ fn vr_mean(arr : Array[Double]) -> Double { s / n.to_double() } +///| fn vr_variance(arr : Array[Double]) -> Double { let n = arr.length() if n < 2 { @@ -216,6 +222,7 @@ fn vr_variance(arr : Array[Double]) -> Double { s / (n - 1).to_double() } +///| fn vr_lcg_rand(state : Int) -> (Int, Double) { let s = (state * 1103515245 + 12345) & 0x7FFFFFFF (s, (s % 1000000).to_double() / 1000000.0) @@ -233,7 +240,7 @@ fn vr_lcg_rand(state : Int) -> (Int, Double) { /// Returns (gamma_beta_ratio, steady_state_s, steady_state_u). pub fn velocity_steady_state( spliced : Array[Double], - unspliced : Array[Double] + unspliced : Array[Double], ) -> (Double, Double, Double) { let n = spliced.length() if n < 3 { @@ -306,7 +313,7 @@ pub fn velocity_kinetic_model( gene_name : String, spliced : Array[Double], unspliced : Array[Double], - n_iterations : Int + n_iterations : Int, ) -> GeneKinetics { let n = spliced.length() if n < 3 { @@ -434,6 +441,7 @@ pub fn velocity_kinetic_model( } } +///| fn vr_max_array(arr : Array[Double]) -> Double { let n = arr.length() if n == 0 { @@ -461,7 +469,7 @@ fn vr_max_array(arr : Array[Double]) -> Double { /// Returns per-cell velocity vectors. pub fn velocity_compute( gene_data : Array[VelocityGeneData], - kinetics : Array[GeneKinetics] + kinetics : Array[GeneKinetics], ) -> Array[CellVelocity] { let n_genes = gene_data.length() if n_genes == 0 { @@ -504,7 +512,7 @@ pub fn velocity_gene( spliced : Array[Double], unspliced : Array[Double], beta : Double, - gamma : Double + gamma : Double, ) -> Array[Double] { let n = spliced.length() let vel = Array::make(n, 0.0) @@ -529,7 +537,7 @@ pub fn velocity_gene( pub fn velocity_embedding( velocities : Array[CellVelocity], embeddings : Array[Array[Double]], - k : Int + k : Int, ) -> Array[EmbeddingVelocity] { let n_cells = velocities.length() if n_cells == 0 || n_cells != embeddings.length() { @@ -584,7 +592,8 @@ pub fn velocity_embedding( // we use a simplified scalar projection. let alignment = 1.0 // simplified: assume positive alignment for neighbors for d in 0.. Double { let n = a.length() let mut s = 0.0 @@ -614,6 +624,7 @@ fn vr_euclidean(a : Array[Double], b : Array[Double]) -> Double { vr_sqrt(s) } +///| fn vr_dot(a : Array[Double], b : Array[Double]) -> Double { let n = a.length() let mut s = 0.0 @@ -636,7 +647,7 @@ fn vr_dot(a : Array[Double], b : Array[Double]) -> Double { /// Returns indices of root cells sorted by speed (descending). pub fn velocity_find_root_cells( velocities : Array[CellVelocity], - n_roots : Int + n_roots : Int, ) -> Array[Int] { let n = velocities.length() let indices = Array::make(n, 0) @@ -677,7 +688,7 @@ pub fn velocity_transition_matrix( velocities : Array[CellVelocity], embeddings : Array[Array[Double]], k : Int, - temperature : Double + temperature : Double, ) -> Array[Array[Double]] { let n = velocities.length() let temp = if temperature > 0.0 { temperature } else { 1.0 } @@ -759,7 +770,7 @@ pub fn velocity_transition_matrix( pub fn velocity_run( gene_data : Array[VelocityGeneData], embeddings : Array[Array[Double]], - k : Int + k : Int, ) -> (Array[GeneKinetics], Array[CellVelocity], Array[EmbeddingVelocity]) { // 1. Estimate kinetics per gene. let kinetics : Array[GeneKinetics] = Array::new() diff --git a/src/venn_diagram.mbt b/src/venn_diagram.mbt index 0b52c44d..f6d2c030 100644 --- a/src/venn_diagram.mbt +++ b/src/venn_diagram.mbt @@ -48,7 +48,10 @@ pub struct VennDiagramResult { /// - names: Names for each set /// /// Returns: VennDiagramResult with region calculations. -pub fn venn_diagram(sets : Array[Array[String]], names? : Array[String] = []) -> VennDiagramResult { +pub fn venn_diagram( + sets : Array[Array[String]], + names? : Array[String] = [], +) -> VennDiagramResult { let n_sets = sets.length() let set_names = if names.length() == n_sets { names @@ -89,7 +92,12 @@ pub fn venn_diagram(sets : Array[Array[String]], names? : Array[String] = []) -> i = i + 1 } // Build regions - let regions = Array::make(n_regions, VennRegion::{id: 0, elements: Array::new(), count: 0, description: ""}) + let regions = Array::make(n_regions, VennRegion::{ + id: 0, + elements: Array::new(), + count: 0, + description: "", + }) r = 0 while r < n_regions { let count = region_elements[r].length() @@ -201,7 +209,10 @@ fn region_description(region_id : Int, set_names : Array[String]) -> String { /// V = number of vertices (intersection points) /// E = number of edges /// F = number of faces (regions) -fn compute_euler_characteristic(n_sets : Int, regions : Array[VennRegion]) -> Double { +fn compute_euler_characteristic( + n_sets : Int, + regions : Array[VennRegion], +) -> Double { // Simplified: just use number of non-empty regions let mut non_empty = 0 let mut i = 0 @@ -212,13 +223,20 @@ fn compute_euler_characteristic(n_sets : Int, regions : Array[VennRegion]) -> Do i = i + 1 } // For simple Venn diagrams, chi = 1 typically - if non_empty > 0 { 1.0 } else { 0.0 } + if non_empty > 0 { + 1.0 + } else { + 0.0 + } } ///| /// Get elements in a specific region defined by its bitmask. /// For example, region 0b101 (5) means elements in set 0 and set 2 but not set 1. -pub fn venn_get_region(result : VennDiagramResult, region_id : Int) -> Array[String] { +pub fn venn_get_region( + result : VennDiagramResult, + region_id : Int, +) -> Array[String] { let n = result.regions.length() if region_id >= 0 && region_id < n { result.regions[region_id].elements @@ -229,7 +247,10 @@ pub fn venn_get_region(result : VennDiagramResult, region_id : Int) -> Array[Str ///| /// Get elements only in a specific set (not in any other). -pub fn venn_only_in_set(result : VennDiagramResult, set_index : Int) -> Array[String] { +pub fn venn_only_in_set( + result : VennDiagramResult, + set_index : Int, +) -> Array[String] { let region_id = 1 << set_index venn_get_region(result, region_id) } @@ -237,7 +258,10 @@ pub fn venn_only_in_set(result : VennDiagramResult, set_index : Int) -> Array[St ///| /// Get elements in the intersection of specified sets and no others. /// Sets to include are specified as an array of set indices. -pub fn venn_intersection_only(result : VennDiagramResult, set_indices : Array[Int]) -> Array[String] { +pub fn venn_intersection_only( + result : VennDiagramResult, + set_indices : Array[Int], +) -> Array[String] { let mut region_id = 0 let mut i = 0 while i < set_indices.length() { @@ -288,14 +312,18 @@ pub fn venn_pairwise_overlap( // Count intersection let inter = venn_count_intersection(elements_i, elements_j) let union = n_i + n_j - inter - let jaccard = if union > 0 { inter.to_double() / union.to_double() } else { 0.0 } + let jaccard = if union > 0 { + inter.to_double() / union.to_double() + } else { + 0.0 + } let overlap_coeff = if min_int(n_i, n_j) > 0 { inter.to_double() / min_int(n_i, n_j).to_double() } else { 0.0 } let dice = if n_i + n_j > 0 { - (2.0 * inter.to_double()) / (n_i.to_double() + n_j.to_double()) + 2.0 * inter.to_double() / (n_i.to_double() + n_j.to_double()) } else { 0.0 } @@ -312,7 +340,10 @@ pub fn venn_pairwise_overlap( ///| /// Get all elements in a specific set. -fn venn_set_elements(result : VennDiagramResult, set_index : Int) -> Array[String] { +fn venn_set_elements( + result : VennDiagramResult, + set_index : Int, +) -> Array[String] { let elements = Array::new() let region_id = 1 << set_index // Find all regions that include this set (bit set) @@ -364,7 +395,8 @@ pub fn venn_summary(result : VennDiagramResult) -> String { let mut r = 0 while r < result.regions.length() { if result.regions[r].count > 0 { - s = s + " Region \{r} (0x\{hex_string(r)}): \{result.regions[r].count} elements - \{result.regions[r].description}\n" + s = s + + " Region \{r} (0x\{hex_string(r)}): \{result.regions[r].count} elements - \{result.regions[r].description}\n" } r = r + 1 } @@ -391,7 +423,10 @@ pub fn venn_summary(result : VennDiagramResult) -> String { ///| /// Compute a Venn diagram with only the counts (no element tracking). /// More efficient for large datasets where you only need region counts. -pub fn venn_counts_only(sets : Array[Array[String]], names? : Array[String] = []) -> Array[Int] { +pub fn venn_counts_only( + sets : Array[Array[String]], + names? : Array[String] = [], +) -> Array[Int] { let n_sets = sets.length() let n_regions = 1 << n_sets let counts = Array::make(n_regions, 0) @@ -432,7 +467,9 @@ pub fn venn_counts_only(sets : Array[Array[String]], names? : Array[String] = [] ///| /// Compute Euler diagram layout (regions and their positions). /// Returns normalized positions for each non-empty region. -pub fn venn_euler_layout(result : VennDiagramResult) -> Array[Map[String, Double]] { +pub fn venn_euler_layout( + result : VennDiagramResult, +) -> Array[Map[String, Double]] { let n_sets = result.n_sets let positions = Array::new() let mut r = 0 @@ -448,7 +485,10 @@ pub fn venn_euler_layout(result : VennDiagramResult) -> Array[Map[String, Double ///| /// Compute a approximate 2D position for a Venn region. -fn compute_region_position(region_id : Int, n_sets : Int) -> Map[String, Double] { +fn compute_region_position( + region_id : Int, + n_sets : Int, +) -> Map[String, Double] { // Place sets in a circle, then compute region positions as weighted average let m = Map::new() if n_sets == 0 { @@ -484,7 +524,12 @@ fn compute_region_position(region_id : Int, n_sets : Int) -> Map[String, Double] ///| /// Perform a pairwise Venn comparison of two sets only (2-set Venn). -pub fn venn_two_sets(set_a : Array[String], set_b : Array[String], name_a? : String = "A", name_b? : String = "B") -> VennDiagramResult { +pub fn venn_two_sets( + set_a : Array[String], + set_b : Array[String], + name_a? : String = "A", + name_b? : String = "B", +) -> VennDiagramResult { venn_diagram([set_a, set_b], names=[name_a, name_b]) } @@ -532,7 +577,10 @@ pub fn venn_difference(a : Array[String], b : Array[String]) -> Array[String] { ///| /// Compute symmetric difference (elements in either a or b but not both). -pub fn venn_symmetric_difference(a : Array[String], b : Array[String]) -> Array[String] { +pub fn venn_symmetric_difference( + a : Array[String], + b : Array[String], +) -> Array[String] { let diff_ab = venn_difference(a, b) let diff_ba = venn_difference(b, a) let result = diff_ab.copy() @@ -562,7 +610,7 @@ pub fn venn_dice(a : Array[String], b : Array[String]) -> Double { let inter = venn_intersection(a, b) let total = a.length() + b.length() if total > 0 { - (2.0 * inter.length().to_double()) / total.to_double() + 2.0 * inter.length().to_double() / total.to_double() } else { 0.0 } @@ -584,9 +632,18 @@ pub fn venn_overlap_coefficient(a : Array[String], b : Array[String]) -> Double /// Sample data: three gene sets for testing. pub fn venn_sample_gene_sets() -> Array[Array[String]] { [ - ["TP53", "BRCA1", "BRCA2", "EGFR", "MYC", "KRAS", "PTEN", "APC", "RB1", "VHL", "NF1", "MSH2", "MLH1", "MSH6", "PMS2"], - ["BRCA1", "BRCA2", "ATM", "CHEK2", "PALB2", "BRIP1", "RAD51C", "RAD51D", "BARD1", "FANCA", "FANCC", "FANCD2", "FANCE", "FANCF", "FANCG"], - ["TP53", "EGFR", "MYC", "KRAS", "MTOR", "PIK3CA", "AKT1", "TSC1", "TSC2", "RICTOR", "RAPTOR", "EIF4E", "4EBP1", "S6K1", "PDK1"], + [ + "TP53", "BRCA1", "BRCA2", "EGFR", "MYC", "KRAS", "PTEN", "APC", "RB1", "VHL", + "NF1", "MSH2", "MLH1", "MSH6", "PMS2", + ], + [ + "BRCA1", "BRCA2", "ATM", "CHEK2", "PALB2", "BRIP1", "RAD51C", "RAD51D", "BARD1", + "FANCA", "FANCC", "FANCD2", "FANCE", "FANCF", "FANCG", + ], + [ + "TP53", "EGFR", "MYC", "KRAS", "MTOR", "PIK3CA", "AKT1", "TSC1", "TSC2", "RICTOR", + "RAPTOR", "EIF4E", "4EBP1", "S6K1", "PDK1", + ], ] } @@ -625,5 +682,5 @@ fn format_venn_stat(value : Double) -> String { pub fn venn_sample_result() -> VennDiagramResult { let sets = venn_sample_gene_sets() let names = venn_sample_gene_names() - venn_diagram(sets, names=names) + venn_diagram(sets, names~) } diff --git a/src/voyager.mbt b/src/voyager.mbt new file mode 100644 index 00000000..5f3f8106 --- /dev/null +++ b/src/voyager.mbt @@ -0,0 +1,2581 @@ +///| +/// Voyager — Bioconductor spatial transcriptomics univariate, bivariate and +/// multivariate spatial autocorrelation statistics, inspired by the Voyager +/// Bioconductor package (Pardo, Spakov, Wolf et al.). +/// +/// Implements: +/// - Spatial neighbour/weight construction (kNN, distance band, inverse +/// distance) with row-standardized / binary / globally-standardized / +/// Caussinus-Mestre style coding. +/// - Global Moran's I and Geary's c with the Cliff–Ord randomization +/// expectation and variance and a normal-approximation p-value. +/// - Local Moran's I (LISA) with quadrant classification and permutation +/// inference, local_res Geary's c, and local_res Getis–Ord Gi / Gi* with the +/// exact Ord–Getis randomization z-score. +/// - Bivariate Lee's L (global and local_res) and multivariate local_res Geary. +/// - Empirical variogram with spherical / exponential / Gaussian model +/// fitting by bounded grid search + linear least squares. +/// - Spatial Moran correlogram over distance bins. +/// - Deterministic permutation tests (seeded splitmix64 PRNG) and +/// Benjamini–Hochberg FDR. +/// - Immutable SpatialExperiment write-back of local_res results. + +// =========================================================================== +// Error type and validation helpers +// =========================================================================== + +///| +pub suberror VoyagerError { + VoyagerError(String) +} + +///| +fn voy_fail(message : String) -> Unit raise VoyagerError { + raise VoyagerError::VoyagerError(message) +} + +///| +fn voy_is_finite(value : Double) -> Bool { + value == value && value.abs() <= 1.0e300 +} + +///| +fn voy_copy_double_matrix( + values : Array[Array[Double]], +) -> Array[Array[Double]] { + let output : Array[Array[Double]] = [] + for row in values { + output.push(row.copy()) + } + output +} + +///| +fn voy_copy_string_map(values : Map[String, String]) -> Map[String, String] { + let output : Map[String, String] = Map([], capacity=values.keys().length()) + for key in values.keys() { + output[key] = values[key] + } + output +} + +///| +fn voy_default_names(prefix : String, count : Int) -> Array[String] { + let output : Array[String] = [] + for index in 0.. Unit raise VoyagerError { + if values.length() < 3 { + voy_fail("Voyager " + label + " requires at least 3 observations") + } + for value in values { + if !voy_is_finite(value) { + voy_fail("Voyager " + label + " must be finite") + } + } +} + +///| +fn voy_validate_weights( + weights : VoyagerWeights, + label : String, +) -> Unit raise VoyagerError { + if weights.n < 3 { + voy_fail("Voyager " + label + " weights require at least 3 spots") + } + if weights.neighbors.length() != weights.n { + voy_fail("Voyager " + label + " weights neighbours must match spot count") + } + if weights.weights.length() != weights.n { + voy_fail("Voyager " + label + " weights rows must match spot count") + } + let mut has_link = false + for index in 0.. 0 { + has_link = true + } + } + if !has_link { + voy_fail("Voyager " + label + " weights must contain at least one link") + } +} + +///| +fn voy_validate_equal_length( + a : Array[Double], + b : Array[Double], + label : String, +) -> Unit raise VoyagerError { + if a.length() != b.length() { + voy_fail("Voyager " + label + " vectors must have equal length") + } +} + +// =========================================================================== +// Deterministic PRNG (splitmix64) for reproducible permutations +// =========================================================================== + +///| +priv struct VoyagerRng { + mut state : Int64 +} + +///| +fn VoyagerRng::new(seed : Int) -> VoyagerRng { + let init = if seed < 0 { + seed.to_int64() + 9223372036854775807L + } else { + seed.to_int64() + } + VoyagerRng::{ state: init + 0x9E3779B97F4A7C15L } +} + +///| +fn VoyagerRng::next_uint64(self : VoyagerRng) -> Int64 { + let mut z = self.state + z = z + 0x9E3779B97F4A7C15L + self.state = z + z = z ^ (z >> 30) + z = z * 0xBF58476D1CE4E5B9L + z = z ^ (z >> 27) + z = z * 0x94D049BB133111EBL + z = z ^ (z >> 31) + z +} + +///| +fn VoyagerRng::next_int_range(self : VoyagerRng, upper_exclusive : Int) -> Int { + if upper_exclusive <= 0 { + return 0 + } + let value = self.next_uint64() + if upper_exclusive <= 2147483647 { + (value & 2147483647L).to_int() % upper_exclusive + } else { + value.to_int() % upper_exclusive + } +} + +///| +/// Fisher–Yates shuffle (in place on a copy) using the deterministic PRNG. +fn voy_permute(values : Array[Double], rng : VoyagerRng) -> Array[Double] { + let output = values.copy() + let n = output.length() + let mut i = n - 1 + while i > 0 { + let j = rng.next_int_range(i + 1) + let tmp = output[i] + output[i] = output[j] + output[j] = tmp + i = i - 1 + } + output +} + +// =========================================================================== +// Benjamini–Hochberg FDR +// =========================================================================== + +///| +fn voy_bh_adjust(p_values : Array[Double]) -> Array[Double] { + let count = p_values.length() + let output : Array[Double] = Array::make(count, 1.0) + if count == 0 { + return output + } + let indexed : Array[(Double, Int)] = [] + for index in 0.. Int { + if left.0 < right.0 { + -1 + } else if left.0 > right.0 { + 1 + } else { + left.1 - right.1 + } + }) + let mut running = 1.0 + let mut position = count - 1 + while position >= 0 { + let candidate = (indexed[position].0 * + count.to_double() / + (position + 1).to_double()).min(1.0) + running = running.min(candidate) + output[indexed[position].1] = running + position = position - 1 + } + output +} + +// =========================================================================== +// Normal CDF (Abramowitz–Stegun) for analytical p-values +// =========================================================================== + +///| +fn voy_normal_cdf(x : Double) -> Double { + let abs_x = if x < 0.0 { -x } else { x } + let t = 1.0 / (1.0 + 0.2316419 * abs_x) + let d = 0.3989422804014327 * @math.exp(-x * x / 2.0) + let p = d * + t * + ( + 0.31938153 + + t * + (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))) + ) + if x > 0.0 { + 1.0 - p + } else { + p + } +} + +///| +fn voy_two_sided_p(z : Double) -> Double { + let abs_z = if z < 0.0 { -z } else { z } + 2.0 * (1.0 - voy_normal_cdf(abs_z)) +} + +// =========================================================================== +// Distance and weights +// =========================================================================== + +///| +fn voy_euclidean(a : Array[Double], b : Array[Double]) -> Double { + let mut sum = 0.0 + let limit = if a.length() < b.length() { a.length() } else { b.length() } + for index in 0.. Array[Array[Double]] { + let n = coords.length() + // Build a fresh inner array per row — `Array::make(n, Array::make(n, 0.0))` + // would alias a single inner array across all rows. + let output : Array[Array[Double]] = [] + for _ in 0.. VoyagerWeights raise VoyagerError { + let n = neighbors.length() + if weights.length() != n { + voy_fail("Voyager weights neighbour/weight row counts must match") + } + for index in 0.. Double { + let mut total = 0.0 + for index in 0.. Double { + let n = weights.n + let mut total = 0.0 + for i in 0.. Double { + let n = weights.n + let row_sums : Array[Double] = Array::make(n, 0.0) + let col_sums : Array[Double] = Array::make(n, 0.0) + for i in 0.. Double { + if i < 0 || i >= weights.n { + return 0.0 + } + let neighbors = weights.neighbors[i] + let values = weights.weights[i] + for k in 0.. Array[Array[Double]] { + let n = neighbors.length() + match style { + "B" => { + let output : Array[Array[Double]] = [] + for index in 0.. { + let mut s0 = 0.0 + for index in 0.. 0.0 { 1.0 / s0 } else { 0.0 } + let output : Array[Array[Double]] = [] + for index in 0.. { + let k : Array[Double] = Array::make(n, 0.0) + for index in 0.. { + // "W" — row-standardized + let output : Array[Array[Double]] = [] + for index in 0.. 0.0 { + for value in raw[index] { + row.push(value / row_sum) + } + } else { + for _ in raw[index] { + row.push(0.0) + } + } + output.push(row) + } + output + } + } +} + +///| +/// Build k-nearest-neighbour spatial weights. +/// `coords` is one row per spot. `k` is the number of neighbours (excluding self). +pub fn voyager_weights_knn( + coords : Array[Array[Double]], + k : Int, + style? : String = "W", +) -> VoyagerWeights raise VoyagerError { + if coords.length() < 3 { + voy_fail("Voyager kNN weights require at least 3 spots") + } + if k < 1 { + voy_fail("Voyager kNN weights require k >= 1") + } + let n = coords.length() + for coordinate in coords { + if coordinate.length() == 0 { + voy_fail("Voyager kNN coordinates must not be empty") + } + for value in coordinate { + if !voy_is_finite(value) { + voy_fail("Voyager kNN coordinates must be finite") + } + } + } + let effective_k = k.min(n - 1) + let distances = voy_pairwise_distances(coords) + let neighbors : Array[Array[Int]] = [] + let raw : Array[Array[Double]] = [] + for i in 0.. Int { + if a.0 < b.0 { + -1 + } else if a.0 > b.0 { + 1 + } else { + a.1 - b.1 + } + }) + let nb : Array[Int] = [] + let w : Array[Double] = [] + for position in 0.. VoyagerWeights raise VoyagerError { + if coords.length() < 3 { + voy_fail("Voyager distance-band weights require at least 3 spots") + } + if !voy_is_finite(bandwidth) || bandwidth <= 0.0 { + voy_fail("Voyager distance-band bandwidth must be positive and finite") + } + let n = coords.length() + for coordinate in coords { + if coordinate.length() == 0 { + voy_fail("Voyager distance-band coordinates must not be empty") + } + for value in coordinate { + if !voy_is_finite(value) { + voy_fail("Voyager distance-band coordinates must be finite") + } + } + } + let neighbors : Array[Array[Int]] = [] + let raw : Array[Array[Double]] = [] + for i in 0.. VoyagerWeights raise VoyagerError { + if coords.length() < 3 { + voy_fail("Voyager inverse-distance weights require at least 3 spots") + } + if !voy_is_finite(power) || power <= 0.0 { + voy_fail("Voyager inverse-distance power must be positive and finite") + } + let n = coords.length() + for coordinate in coords { + if coordinate.length() == 0 { + voy_fail("Voyager inverse-distance coordinates must not be empty") + } + for value in coordinate { + if !voy_is_finite(value) { + voy_fail("Voyager inverse-distance coordinates must be finite") + } + } + } + let limited = bandwidth > 0.0 && voy_is_finite(bandwidth) + let neighbors : Array[Array[Int]] = [] + let raw : Array[Array[Double]] = [] + for i in 0.. 0.0 && (!limited || d <= bandwidth) { + nb.push(j) + w.push(1.0 / @math.pow(d, power)) + } + } + } + neighbors.push(nb) + raw.push(w) + } + let styled = voy_apply_style(neighbors, raw, style) + VoyagerWeights::{ style, n, neighbors, weights: styled } +} + +// =========================================================================== +// Global Moran's I +// =========================================================================== + +///| +pub struct VoyagerGlobalMoranI { + feature : String + estimate : Double + expectation : Double + variance : Double + z_score : Double + p_value : Double + n : Int + s0 : Double + s1 : Double + s2 : Double +} derive(Debug) + +///| +/// Internal Moran's I numerator and denominator for a given (permuted) vector. +fn voy_moran_components( + values : Array[Double], + weights : VoyagerWeights, + mean : Double, +) -> (Double, Double) { + let n = values.length() + let centered : Array[Double] = [] + for index in 0.. VoyagerGlobalMoranI raise VoyagerError { + voy_validate_vector(values, "Moran's I") + voy_validate_weights(weights, "Moran's I") + if values.length() != weights.n { + voy_fail("Voyager Moran's I values must match weights length") + } + let n = values.length() + let mut mean = 0.0 + for value in values { + mean = mean + value + } + mean = mean / n.to_double() + let s0 = voyager_weights_s0(weights) + if s0 <= 0.0 { + voy_fail("Voyager Moran's I requires non-zero total weight S0") + } + let s1 = voyager_weights_s1(weights) + let s2 = voyager_weights_s2(weights) + let (numerator, denominator) = voy_moran_components(values, weights, mean) + if denominator <= 0.0 { + voy_fail("Voyager Moran's I requires non-zero variance in values") + } + let estimate = n.to_double() / s0 * (numerator / denominator) + let expectation = -1.0 / (n.to_double() - 1.0) + // Randomization variance (Cliff & Ord 1981) + let mut m2 = 0.0 + let mut m4 = 0.0 + for value in values { + let dev = value - mean + m2 = m2 + dev * dev + m4 = m4 + dev * dev * dev * dev + } + let b2 = n.to_double() * m4 / (m2 * m2) + let nd = n.to_double() + let n1 = nd - 1.0 + let n2 = nd - 2.0 + let n3 = nd - 3.0 + let a = nd * ((nd * nd - 3.0 * nd + 3.0) * s1 - nd * s2 + 3.0 * s0 * s0) + let b = b2 * ((nd * nd - nd) * s1 - 2.0 * nd * s2 + 6.0 * s0 * s0) + let variance = (a - b) / (n1 * n2 * n3 * s0 * s0) - expectation * expectation + let safe_variance = if variance > 0.0 { variance } else { 0.0 } + let z_score = if safe_variance > 0.0 { + (estimate - expectation) / safe_variance.sqrt() + } else { + 0.0 + } + let p_value = voy_two_sided_p(z_score) + VoyagerGlobalMoranI::{ + feature, + estimate, + expectation, + variance: safe_variance, + z_score, + p_value, + n, + s0, + s1, + s2, + } +} + +// =========================================================================== +// Global Geary's c +// =========================================================================== + +///| +pub struct VoyagerGlobalGearyC { + feature : String + estimate : Double + expectation : Double + variance : Double + z_score : Double + p_value : Double + n : Int + s0 : Double + s1 : Double + s2 : Double +} derive(Debug) + +///| +/// Global Geary's c with the Cliff–Ord randomization expectation and variance. +pub fn voyager_global_gearys_c( + values : Array[Double], + weights : VoyagerWeights, + feature? : String = "feature", +) -> VoyagerGlobalGearyC raise VoyagerError { + voy_validate_vector(values, "Geary's c") + voy_validate_weights(weights, "Geary's c") + if values.length() != weights.n { + voy_fail("Voyager Geary's c values must match weights length") + } + let n = values.length() + let mut mean = 0.0 + for value in values { + mean = mean + value + } + mean = mean / n.to_double() + let s0 = voyager_weights_s0(weights) + if s0 <= 0.0 { + voy_fail("Voyager Geary's c requires non-zero total weight S0") + } + let s1 = voyager_weights_s1(weights) + let s2 = voyager_weights_s2(weights) + let mut cross = 0.0 + let mut ssd = 0.0 + for i in 0.. 0.0 { variance } else { 0.0 } + let z_score = if safe_variance > 0.0 { + (estimate - expectation) / safe_variance.sqrt() + } else { + 0.0 + } + let p_value = voy_two_sided_p(z_score) + VoyagerGlobalGearyC::{ + feature, + estimate, + expectation, + variance: safe_variance, + z_score, + p_value, + n, + s0, + s1, + s2, + } +} + +///| +fn n1_value(n : Int) -> Double { + (n - 1).to_double() +} + +// =========================================================================== +// Permutation helpers shared by local_res statistics +// =========================================================================== + +///| +fn voy_perm_p_value_two_sided( + observed : Double, + expectation : Double, + permutations : Array[Double], +) -> (Double, Double, Double) { + // Returns (p_value, perm_mean, perm_sd). + let count = permutations.length() + if count == 0 { + return (1.0, observed, 0.0) + } + let mut sum = 0.0 + let mut sum_sq = 0.0 + for value in permutations { + sum = sum + value + sum_sq = sum_sq + value * value + } + let mean = sum / count.to_double() + let var_sample = (sum_sq - sum * sum / count.to_double()) / count.to_double() + let sd = if var_sample > 0.0 { var_sample.sqrt() } else { 0.0 } + let obs_dev = (observed - expectation).abs() + let mut extreme = 0 + for value in permutations { + if (value - expectation).abs() >= obs_dev { + extreme = extreme + 1 + } + } + let p = (extreme.to_double() + 1.0) / (count.to_double() + 1.0) + (p, mean, sd) +} + +// =========================================================================== +// Local Moran's I (LISA) +// =========================================================================== + +///| +pub struct VoyagerLocalMoranI { + feature : String + local_i : Array[Double] + expectations : Array[Double] + variances : Array[Double] + z_scores : Array[Double] + p_values : Array[Double] + fdr : Array[Double] + quadrants : Array[String] + perm_mean : Array[Double] + perm_sd : Array[Double] + n : Int + permutations : Int + style : String +} derive(Debug) + +///| +/// Quadrant classification from the Moran scatter plot. The spatial lag is the +/// row-standardized weighted sum of the neighbours' standardized values. +fn voy_moran_quadrant( + z_i : Double, + lag_i : Double, + z_significant : Bool, +) -> String { + if !z_significant { + return "not significant" + } + if z_i > 0.0 && lag_i > 0.0 { + "HH" + } else if z_i < 0.0 && lag_i < 0.0 { + "LL" + } else if z_i > 0.0 && lag_i < 0.0 { + "HL" + } else { + "LH" + } +} + +///| +fn voy_local_morans_point( + values : Array[Double], + weights : VoyagerWeights, + mean : Double, + m2 : Double, +) -> Array[Double] { + let n = values.length() + let centered : Array[Double] = [] + for index in 0.. VoyagerLocalMoranI raise VoyagerError { + voy_validate_vector(values, "local_res Moran's I") + voy_validate_weights(weights, "local_res Moran's I") + if values.length() != weights.n { + voy_fail("Voyager local_res Moran's I values must match weights length") + } + if permutations < 0 { + voy_fail("Voyager local_res Moran's I permutations must be non-negative") + } + if !voy_is_finite(fdr_threshold) || + fdr_threshold <= 0.0 || + fdr_threshold > 1.0 { + voy_fail("Voyager local_res Moran's I FDR threshold must be in (0, 1]") + } + let n = values.length() + let mut mean = 0.0 + for value in values { + mean = mean + value + } + mean = mean / n.to_double() + let mut m2 = 0.0 + for value in values { + let dev = value - mean + m2 = m2 + dev * dev + } + m2 = m2 / n.to_double() + if m2 <= 0.0 { + voy_fail("Voyager local_res Moran's I requires non-zero variance in values") + } + let observed = voy_local_morans_point(values, weights, mean, m2) + // Standardized values and spatial lag for quadrant classification. + let z_scores_std : Array[Double] = [] + for value in values { + z_scores_std.push((value - mean) / m2.sqrt()) + } + let lag_std : Array[Double] = Array::make(n, 0.0) + for i in 0.. 0 { + let rng = VoyagerRng::new(seed) + // perm_local[k][i] = local_res Moran's I at spot i under permutation k. + let perm_local : Array[Array[Double]] = [] + for _ in 0.. 0.0 { (observed[i] - pmean) / psd } else { 0.0 } + } + } else { + // Analytical approximation: use permutation-free variance under the + // randomization assumption for reference only. + for i in 0.. 0.0 { var_i } else { 0.0 } + variances[i] = safe_var + z_scores[i] = if safe_var > 0.0 { + (observed[i] - exp_i) / safe_var.sqrt() + } else { + 0.0 + } + p_values[i] = voy_two_sided_p(z_scores[i]) + perm_mean[i] = exp_i + perm_sd[i] = safe_var.sqrt() + } + } + let fdr = voy_bh_adjust(p_values) + let quadrants : Array[String] = [] + for i in 0.. Array[Double] { + let n = values.length() + let output : Array[Double] = Array::make(n, 0.0) + if m2 <= 0.0 { + return output + } + for i in 0.. VoyagerLocalGearyC raise VoyagerError { + voy_validate_vector(values, "local_res Geary's c") + voy_validate_weights(weights, "local_res Geary's c") + if values.length() != weights.n { + voy_fail("Voyager local_res Geary's c values must match weights length") + } + if permutations < 0 { + voy_fail("Voyager local_res Geary's c permutations must be non-negative") + } + if !voy_is_finite(fdr_threshold) || + fdr_threshold <= 0.0 || + fdr_threshold > 1.0 { + voy_fail("Voyager local_res Geary's c FDR threshold must be in (0, 1]") + } + let n = values.length() + let mut mean = 0.0 + for value in values { + mean = mean + value + } + mean = mean / n.to_double() + let mut m2 = 0.0 + for value in values { + let dev = value - mean + m2 = m2 + dev * dev + } + m2 = m2 / n.to_double() + if m2 <= 0.0 { + voy_fail("Voyager local_res Geary's c requires non-zero variance in values") + } + let observed = voy_local_gearys_point(values, weights, m2) + let expectations : Array[Double] = Array::make(n, 1.0) + let z_scores : Array[Double] = Array::make(n, 0.0) + let p_values : Array[Double] = Array::make(n, 1.0) + if permutations > 0 { + let rng = VoyagerRng::new(seed) + let perm_local : Array[Array[Double]] = [] + for _ in 0.. 0.0 { (observed[i] - pmean) / psd } else { 0.0 } + } + } else { + for i in 0.. 1.0 { + classifications.push("dissimilar") + } else { + classifications.push("not significant") + } + } + VoyagerLocalGearyC::{ + feature, + local_c: observed, + expectations, + z_scores, + p_values, + fdr, + classifications, + n, + permutations, + } +} + +// =========================================================================== +// Local Getis–Ord Gi / Gi* +// =========================================================================== + +///| +pub struct VoyagerLocalGetisOrd { + feature : String + statistic : Array[Double] + expectations : Array[Double] + z_scores : Array[Double] + p_values : Array[Double] + fdr : Array[Double] + classifications : Array[String] + star : Bool + n : Int +} derive(Debug) + +///| +/// Local Getis–Ord Gi (excludes self) or Gi* (includes self with w_ii = 1). +/// Significance uses the exact Ord–Getis randomization z-score for the +/// weighted sum. +pub fn voyager_local_getis_ord( + values : Array[Double], + weights : VoyagerWeights, + star? : Bool = true, + fdr_threshold? : Double = 0.05, + feature? : String = "feature", +) -> VoyagerLocalGetisOrd raise VoyagerError { + voy_validate_vector(values, "Getis–Ord") + voy_validate_weights(weights, "Getis–Ord") + if values.length() != weights.n { + voy_fail("Voyager Getis–Ord values must match weights length") + } + if !voy_is_finite(fdr_threshold) || + fdr_threshold <= 0.0 || + fdr_threshold > 1.0 { + voy_fail("Voyager Getis–Ord FDR threshold must be in (0, 1]") + } + let n = values.length() + let mut total = 0.0 + let mut total_sq = 0.0 + for value in values { + if value < 0.0 { + voy_fail("Voyager Getis–Ord requires non-negative values") + } + total = total + value + total_sq = total_sq + value * value + } + let mean = total / n.to_double() + // Sample variance with denominator (n-1). + let sample_var = (total_sq - total * total / n.to_double()) / + (n.to_double() - 1.0) + let safe_var = if sample_var > 0.0 { sample_var } else { 0.0 } + let statistic : Array[Double] = Array::make(n, 0.0) + let expectations : Array[Double] = Array::make(n, 0.0) + let z_scores : Array[Double] = Array::make(n, 0.0) + let p_values : Array[Double] = Array::make(n, 1.0) + for i in 0.. 0.0 { numerator_sum / y } else { 0.0 } + statistic[i] = stat + expectations[i] = total_w / n_used + let denom_root = if safe_var > 0.0 { + let var_weighted = (n_used * total_w_sq - total_w * total_w) / + (n_used - 1.0).max(1.0) + if var_weighted > 0.0 { + safe_var.sqrt() * var_weighted.sqrt() + } else { + 0.0 + } + } else { + 0.0 + } + let z = if denom_root > 0.0 { + (numerator_sum - total_w * mean) / denom_root + } else { + 0.0 + } + z_scores[i] = z + p_values[i] = voy_two_sided_p(z) + } + let fdr = voy_bh_adjust(p_values) + let classifications : Array[String] = [] + for i in 0.. 0.0 { + classifications.push("hotspot") + } else if fdr[i] <= fdr_threshold && z_scores[i] < 0.0 { + classifications.push("coldspot") + } else { + classifications.push("not significant") + } + } + VoyagerLocalGetisOrd::{ + feature, + statistic, + expectations, + z_scores, + p_values, + fdr, + classifications, + star, + n, + } +} + +// =========================================================================== +// Lee's L (bivariate spatial association) +// =========================================================================== + +///| +pub struct VoyagerLeesL { + feature_x : String + feature_y : String + global_l : Double + local_l : Array[Double] + z_scores : Array[Double] + p_values : Array[Double] + fdr : Array[Double] + n : Int + s0 : Double +} derive(Debug) + +///| +/// Lee's L (Lee 2001) bivariate spatial association. Returns the global L +/// (range approximately [-1, 1] for row-standardized weights) and per-location +/// local_res L values with permutation-based inference. +pub fn voyager_lees_l( + values_x : Array[Double], + values_y : Array[Double], + weights : VoyagerWeights, + permutations? : Int = 0, + seed? : Int = 20240501, + fdr_threshold? : Double = 0.05, + feature_x? : String = "feature_x", + feature_y? : String = "feature_y", +) -> VoyagerLeesL raise VoyagerError { + voy_validate_vector(values_x, "Lee's L x") + voy_validate_vector(values_y, "Lee's L y") + voy_validate_weights(weights, "Lee's L") + voy_validate_equal_length(values_x, values_y, "Lee's L") + if values_x.length() != weights.n { + voy_fail("Voyager Lee's L values must match weights length") + } + if !voy_is_finite(fdr_threshold) || + fdr_threshold <= 0.0 || + fdr_threshold > 1.0 { + voy_fail("Voyager Lee's L FDR threshold must be in (0, 1]") + } + let n = values_x.length() + let mut mean_x = 0.0 + let mut mean_y = 0.0 + for index in 0.. 0 { + let rng = VoyagerRng::new(seed) + let perm_local : Array[Array[Double]] = [] + for _ in 0.. 0.0 { pvar.sqrt() } else { 0.0 } + let mut extreme = 0 + for value in permut_values { + if (value - pmean).abs() >= (local_l[i] - pmean).abs() { + extreme = extreme + 1 + } + } + p_values[i] = (extreme.to_double() + 1.0) / + (permut_values.length().to_double() + 1.0) + z_scores[i] = if psd > 0.0 { (local_l[i] - pmean) / psd } else { 0.0 } + } + } + let fdr = voy_bh_adjust(p_values) + VoyagerLeesL::{ + feature_x, + feature_y, + global_l, + local_l, + z_scores, + p_values, + fdr, + n, + s0, + } +} + +// =========================================================================== +// Multivariate local_res Geary +// =========================================================================== + +///| +pub struct VoyagerMultivariateLocalGeary { + feature_set : Array[String] + local_statistic : Array[Double] + expectations : Array[Double] + z_scores : Array[Double] + p_values : Array[Double] + fdr : Array[Double] + classifications : Array[String] + n : Int + n_features : Int + permutations : Int +} derive(Debug) + +///| +fn voy_multivariate_local_geary_point( + matrix : Array[Array[Double]], + weights : VoyagerWeights, + means : Array[Double], +) -> Array[Double] { + // matrix[feature][spot]. Returns per-spot sum over features of weighted + // squared feature-space distances to neighbours. + let n_features = matrix.length() + let n = if n_features > 0 { matrix[0].length() } else { 0 } + let output : Array[Double] = Array::make(n, 0.0) + for i in 0.. VoyagerMultivariateLocalGeary raise VoyagerError { + if matrix.length() == 0 { + voy_fail( + "Voyager multivariate local_res Geary requires at least one feature", + ) + } + let n_features = matrix.length() + let n = matrix[0].length() + if n < 3 { + voy_fail("Voyager multivariate local_res Geary requires at least 3 spots") + } + for feature in 0.. 0 { + let rng = VoyagerRng::new(seed) + let perm_local : Array[Array[Double]] = [] + for _ in 0.. 0.0 { pvar.sqrt() } else { 0.0 } + let mut extreme = 0 + for value in permut_values { + if (value - pmean).abs() >= (observed[i] - pmean).abs() { + extreme = extreme + 1 + } + } + p_values[i] = (extreme.to_double() + 1.0) / + (permut_values.length().to_double() + 1.0) + z_scores[i] = if psd > 0.0 { (observed[i] - pmean) / psd } else { 0.0 } + } + } + let fdr = voy_bh_adjust(p_values) + let names = if feature_names.length() == n_features { + feature_names + } else { + voy_default_names("feature", n_features) + } + let classifications : Array[String] = [] + for i in 0.. 0.0 { + classifications.push("dissimilar") + } else { + classifications.push("not significant") + } + } + VoyagerMultivariateLocalGeary::{ + feature_set: names, + local_statistic: observed, + expectations, + z_scores, + p_values, + fdr, + classifications, + n, + n_features, + permutations, + } +} + +// =========================================================================== +// Empirical variogram and model fitting +// =========================================================================== + +///| +pub struct VoyagerVariogramPoint { + lag : Double + gamma : Double + npairs : Int +} derive(Debug) + +///| +pub struct VoyagerVariogramModel { + model_type : String + nugget : Double + sill : Double + range : Double + fitted_sse : Double + n_points : Int +} derive(Debug) + +///| +/// Empirical (sample) variogram. Pairs of spots are binned into `n_lags` +/// equidistant bins from 0 to `max_lag` (default: half the maximum pairwise +/// distance). The semivariance at each bin is half the mean squared +/// difference of values for the pairs assigned to that bin. +pub fn voyager_empirical_variogram( + coords : Array[Array[Double]], + values : Array[Double], + n_lags? : Int = 15, + max_lag? : Double = 0.0, +) -> Array[VoyagerVariogramPoint] raise VoyagerError { + if coords.length() < 3 { + voy_fail("Voyager variogram requires at least 3 spots") + } + if values.length() != coords.length() { + voy_fail("Voyager variogram values must match coordinates length") + } + if n_lags < 1 { + voy_fail("Voyager variogram n_lags must be positive") + } + for value in values { + if !voy_is_finite(value) { + voy_fail("Voyager variogram values must be finite") + } + } + let n = coords.length() + let distances = voy_pairwise_distances(coords) + let mut max_dist = 0.0 + for i in 0.. max_dist { + max_dist = distances[i][j] + } + } + } + if max_dist <= 0.0 { + voy_fail("Voyager variogram requires non-coincident coordinates") + } + let upper = if max_lag > 0.0 && voy_is_finite(max_lag) { + max_lag + } else { + max_dist / 2.0 + } + let lag_width = upper / n_lags.to_double() + if lag_width <= 0.0 { + voy_fail("Voyager variogram lag width must be positive") + } + let sums : Array[Double] = Array::make(n_lags, 0.0) + let counts : Array[Int] = Array::make(n_lags, 0) + for i in 0.. 0.0 && d <= upper { + let bin = (d / lag_width).to_int().min(n_lags - 1) + let diff = values[i] - values[j] + sums[bin] = sums[bin] + diff * diff + counts[bin] = counts[bin] + 1 + } + } + } + let output : Array[VoyagerVariogramPoint] = [] + for bin in 0.. 0 { + let lag = (bin.to_double() + 0.5) * lag_width + let gamma = sums[bin] / (2.0 * counts[bin].to_double()) + output.push(VoyagerVariogramPoint::{ lag, gamma, npairs: counts[bin] }) + } + } + if output.length() == 0 { + voy_fail("Voyager variogram produced no populated bins") + } + output +} + +///| +/// Theoretical variogram shape function (excluding nugget). Returns the +/// bounded partial sill component for distance h. +fn voy_variogram_shape( + model_type : String, + h : Double, + range : Double, +) -> Double { + if range <= 0.0 { + return 0.0 + } + let ratio = h / range + match model_type { + "spherical" => + if h >= range { + 1.0 + } else { + 1.5 * ratio - 0.5 * ratio * ratio * ratio + } + "exponential" => 1.0 - @math.exp(-3.0 * ratio) + "gaussian" => 1.0 - @math.exp(-3.0 * ratio * ratio) + _ => 0.0 + } +} + +///| +/// Fit a theoretical variogram model (spherical, exponential or gaussian) to +/// an empirical variogram by minimizing the sum of squared residuals. A +/// bounded grid search over `range` is combined with closed-form linear +/// least squares for (nugget, partial sill) at each candidate range. +pub fn voyager_fit_variogram( + empirical : Array[VoyagerVariogramPoint], + model_type? : String = "spherical", + nugget? : Double = 0.0, + fix_nugget? : Bool = false, + range_grid? : Int = 40, +) -> VoyagerVariogramModel raise VoyagerError { + if empirical.length() < 2 { + voy_fail("Voyager variogram fit requires at least 2 empirical points") + } + let model : String = match model_type { + "spherical" => "spherical" + "exponential" => "exponential" + "gaussian" => "gaussian" + _ => + raise VoyagerError::VoyagerError( + "Voyager variogram model must be spherical/exponential/gaussian", + ) + } + if !voy_is_finite(nugget) || nugget < 0.0 { + voy_fail("Voyager variogram nugget must be non-negative and finite") + } + if range_grid < 4 { + voy_fail("Voyager variogram range grid must have at least 4 points") + } + let mut max_lag = 0.0 + for point in empirical { + if point.lag > max_lag { + max_lag = point.lag + } + } + if max_lag <= 0.0 { + voy_fail("Voyager variogram empirical lags must be positive") + } + // Precompute shape values for each (point, candidate range) — but to keep + // the implementation simple we iterate ranges and solve the linear LSQ. + let mut best_sse = 1.0e300 + let mut best_nugget = if fix_nugget { nugget } else { 0.0 } + let mut best_sill = 0.0 + let mut best_range = max_lag / 3.0 + let grid = range_grid + let mut gi = 1 + while gi <= grid { + let candidate_range = max_lag * gi.to_double() / grid.to_double() + if candidate_range <= 0.0 { + gi = gi + 1 + continue + } + // Linear least squares for y = nugget + partial_sill * shape(h). + // If nugget is fixed, this is a one-parameter least squares. + let mut sum_x = 0.0 + let mut sum_y = 0.0 + let mut sum_xx = 0.0 + let mut sum_xy = 0.0 + let mut count = 0.0 + for point in empirical { + let shape = voy_variogram_shape(model, point.lag, candidate_range) + let y = point.gamma + if fix_nugget { + // y - nugget = partial_sill * shape -> one-parameter LSQ. + sum_x = sum_x + shape + sum_y = sum_y + (y - nugget) + sum_xx = sum_xx + shape * shape + sum_xy = sum_xy + shape * (y - nugget) + } else { + sum_x = sum_x + shape + sum_y = sum_y + y + sum_xx = sum_xx + shape * shape + sum_xy = sum_xy + shape * y + } + count = count + 1.0 + } + let (fit_nugget, fit_partial) = if fix_nugget { + let denom = sum_xx + let partial = if denom > 0.0 { sum_xy / denom } else { 0.0 } + (nugget, partial) + } else { + // Two-parameter LSQ: y = a + b * shape, a = nugget, b = partial_sill. + let denom = count * sum_xx - sum_x * sum_x + if denom.abs() < 1.0e-300 { + (0.0, 0.0) + } else { + let b = (count * sum_xy - sum_x * sum_y) / denom + let a = (sum_y - b * sum_x) / count + (a, b) + } + } + // Enforce non-negative nugget and partial sill (physical constraint). + let safe_nugget = if fit_nugget < 0.0 { 0.0 } else { fit_nugget } + let safe_partial = if fit_partial < 0.0 { 0.0 } else { fit_partial } + let mut sse = 0.0 + for point in empirical { + let shape = voy_variogram_shape(model, point.lag, candidate_range) + let predicted = safe_nugget + safe_partial * shape + let residual = point.gamma - predicted + sse = sse + residual * residual + } + if sse < best_sse { + best_sse = sse + best_nugget = safe_nugget + best_sill = safe_partial + best_range = candidate_range + } + gi = gi + 1 + } + // Refine around the best range with a finer grid. + let lo = (best_range * 0.5).max(max_lag / grid.to_double()) + let hi = (best_range * 1.5).min(max_lag) + let fine = 20 + let mut fi = 0 + while fi <= fine { + let candidate_range = lo + (hi - lo) * fi.to_double() / fine.to_double() + if candidate_range <= 0.0 { + fi = fi + 1 + continue + } + let mut sum_x = 0.0 + let mut sum_y = 0.0 + let mut sum_xx = 0.0 + let mut sum_xy = 0.0 + let mut count = 0.0 + for point in empirical { + let shape = voy_variogram_shape(model, point.lag, candidate_range) + let y = point.gamma + if fix_nugget { + sum_x = sum_x + shape + sum_y = sum_y + (y - nugget) + sum_xx = sum_xx + shape * shape + sum_xy = sum_xy + shape * (y - nugget) + } else { + sum_x = sum_x + shape + sum_y = sum_y + y + sum_xx = sum_xx + shape * shape + sum_xy = sum_xy + shape * y + } + count = count + 1.0 + } + let (fit_nugget, fit_partial) = if fix_nugget { + let denom = sum_xx + let partial = if denom > 0.0 { sum_xy / denom } else { 0.0 } + (nugget, partial) + } else { + let denom = count * sum_xx - sum_x * sum_x + if denom.abs() < 1.0e-300 { + (0.0, 0.0) + } else { + let b = (count * sum_xy - sum_x * sum_y) / denom + let a = (sum_y - b * sum_x) / count + (a, b) + } + } + let safe_nugget = if fit_nugget < 0.0 { 0.0 } else { fit_nugget } + let safe_partial = if fit_partial < 0.0 { 0.0 } else { fit_partial } + let mut sse = 0.0 + for point in empirical { + let shape = voy_variogram_shape(model, point.lag, candidate_range) + let predicted = safe_nugget + safe_partial * shape + let residual = point.gamma - predicted + sse = sse + residual * residual + } + if sse < best_sse { + best_sse = sse + best_nugget = safe_nugget + best_sill = safe_partial + best_range = candidate_range + } + fi = fi + 1 + } + VoyagerVariogramModel::{ + model_type: model, + nugget: best_nugget, + sill: best_sill, + range: best_range, + fitted_sse: best_sse, + n_points: empirical.length(), + } +} + +///| +/// Evaluate a fitted variogram model at distance `h`. +pub fn voyager_variogram_predict( + model : VoyagerVariogramModel, + h : Double, +) -> Double { + model.nugget + + model.sill * voy_variogram_shape(model.model_type, h, model.range) +} + +// =========================================================================== +// Spatial Moran correlogram +// =========================================================================== + +///| +pub struct VoyagerCorrelogramPoint { + lag : Double + bin_min : Double + bin_max : Double + morans_i : Double + expectation : Double + npairs : Int +} derive(Debug) + +///| +/// Moran correlogram. Builds binary distance-band weights at each of `n_lags` +/// distance bins and computes Moran's I with its analytical expectation. +pub fn voyager_correlogram( + coords : Array[Array[Double]], + values : Array[Double], + n_lags? : Int = 10, + max_lag? : Double = 0.0, + style? : String = "W", +) -> Array[VoyagerCorrelogramPoint] raise VoyagerError { + if coords.length() < 3 { + voy_fail("Voyager correlogram requires at least 3 spots") + } + if values.length() != coords.length() { + voy_fail("Voyager correlogram values must match coordinates length") + } + if n_lags < 1 { + voy_fail("Voyager correlogram n_lags must be positive") + } + for value in values { + if !voy_is_finite(value) { + voy_fail("Voyager correlogram values must be finite") + } + } + let n = coords.length() + let distances = voy_pairwise_distances(coords) + let mut max_dist = 0.0 + for i in 0.. max_dist { + max_dist = distances[i][j] + } + } + } + if max_dist <= 0.0 { + voy_fail("Voyager correlogram requires non-coincident coordinates") + } + let upper = if max_lag > 0.0 && voy_is_finite(max_lag) { + max_lag + } else { + max_dist / 2.0 + } + let lag_width = upper / n_lags.to_double() + let output : Array[VoyagerCorrelogramPoint] = [] + let mut mean = 0.0 + for value in values { + mean = mean + value + } + mean = mean / n.to_double() + let centered : Array[Double] = [] + let mut ssd = 0.0 + for value in values { + let dev = value - mean + centered.push(dev) + ssd = ssd + dev * dev + } + let expectation = -1.0 / (n.to_double() - 1.0) + for bin in 0.. bin_min && d <= bin_max { + nb.push(j) + w.push(1.0) + npairs = npairs + 1 + } + } + } + neighbors.push(nb) + raw.push(w) + } + // Skip distance bins with no observed pairs — they carry no information. + if npairs == 0 { + continue + } + let styled = voy_apply_style(neighbors, raw, style) + let weights = VoyagerWeights::{ style, n, neighbors, weights: styled } + if ssd <= 0.0 { + output.push(VoyagerCorrelogramPoint::{ + lag: (bin_min + bin_max) / 2.0, + bin_min, + bin_max, + morans_i: 0.0, + expectation, + npairs: npairs / 2, + }) + continue + } + let s0 = voyager_weights_s0(weights) + if s0 <= 0.0 { + output.push(VoyagerCorrelogramPoint::{ + lag: (bin_min + bin_max) / 2.0, + bin_min, + bin_max, + morans_i: 0.0, + expectation, + npairs: npairs / 2, + }) + continue + } + let mut numerator = 0.0 + for i in 0.. SpatialExperiment { + let output = SpatialExperiment::new() + for assay_name in experiment.assay.keys() { + output.assay[assay_name] = voy_copy_double_matrix( + experiment.assay[assay_name], + ) + } + for row in experiment.row_data { + output.row_data.push(voy_copy_string_map(row)) + } + for column in experiment.col_data { + output.col_data.push(voy_copy_string_map(column)) + } + for coordinate in experiment.spatial_coords { + output.spatial_coords.push(coordinate) + } + for image in experiment.images { + output.images.push(image) + } + for key in experiment.metadata.keys() { + output.metadata[key] = experiment.metadata[key] + } + output +} + +///| +fn voy_experiment_gene_names( + experiment : SpatialExperiment, + genes : Int, +) -> Array[String] { + let names : Array[String] = [] + for gene in 0..= experiment.row_data.length() { + names.push(generated) + } else { + let row = experiment.row_data[gene] + let name = match row.get("gene_name") { + Some(value) => + if value.length() > 0 { + value + } else { + match row.get("gene_id") { + Some(identifier) => + if identifier.length() > 0 { + identifier + } else { + generated + } + None => generated + } + } + None => + match row.get("gene_id") { + Some(identifier) => + if identifier.length() > 0 { + identifier + } else { + generated + } + None => generated + } + } + names.push(name) + } + } + names +} + +///| +fn voy_experiment_coordinates( + experiment : SpatialExperiment, + spots : Int, +) -> Array[Array[Double]] raise VoyagerError { + if experiment.spatial_coords.length() != spots { + voy_fail( + "Voyager SpatialExperiment requires one spatial coordinate per spot", + ) + } + let mut use_z = false + if spots > 0 { + let first = experiment.spatial_coords[0].z + for coordinate in experiment.spatial_coords { + if (coordinate.z - first).abs() > 1.0e-14 { + use_z = true + } + } + } + let coordinates : Array[Array[Double]] = [] + for coordinate in experiment.spatial_coords { + if use_z { + coordinates.push([coordinate.x, coordinate.y, coordinate.z]) + } else { + coordinates.push([coordinate.x, coordinate.y]) + } + } + coordinates +} + +///| +/// Run univariate spatial autocorrelation over one or more features of a +/// SpatialExperiment and return a *new* SpatialExperiment with the local_res +/// results written into `col_data` and global results into `row_data`/ +/// `metadata`. The input experiment is left unchanged. +pub fn voyager_run_univariate_sfe( + experiment : SpatialExperiment, + feature_indices : Array[Int], + assay_name? : String = "logcounts", + weights? : VoyagerWeights? = None, + k? : Int = 4, + bandwidth? : Double = 0.0, + stat_method? : String = "moran", + permutations? : Int = 0, + seed? : Int = 20240501, + fdr_threshold? : Double = 0.05, + output_prefix? : String = "voyager", +) -> VoyagerUnivariateSFEOutput raise VoyagerError { + if experiment.col_data.length() == 0 { + voy_fail("Voyager SpatialExperiment col_data must not be empty") + } + let expression : Array[Array[Double]] = match + experiment.assay.get(assay_name) { + Some(value) => value + None => + raise VoyagerError::VoyagerError( + "Voyager SpatialExperiment assay not found: " + assay_name, + ) + } + if expression.length() == 0 { + voy_fail("Voyager SpatialExperiment assay must not be empty") + } + let spots = expression[0].length() + if spots != experiment.col_data.length() { + voy_fail("Voyager SpatialExperiment assay columns must match col_data rows") + } + if spots != experiment.spatial_coords.length() { + voy_fail("Voyager SpatialExperiment coordinates must match col_data rows") + } + if experiment.row_data.length() != 0 && + experiment.row_data.length() != expression.length() { + voy_fail( + "Voyager SpatialExperiment rowData must match assay rows or be empty", + ) + } + let write_row_data = experiment.row_data.length() == expression.length() + if feature_indices.length() == 0 { + voy_fail("Voyager SpatialExperiment feature selection must not be empty") + } + for index in feature_indices { + if index < 0 || index >= expression.length() { + voy_fail( + "Voyager SpatialExperiment feature index out of range: " + + index.to_string(), + ) + } + } + let coords = voy_experiment_coordinates(experiment, spots) + let weights_resolved = match weights { + Some(value) => { + voy_validate_weights(value, "SpatialExperiment") + if value.n != spots { + voy_fail("Voyager SpatialExperiment weights must match spot count") + } + value + } + None => + if bandwidth > 0.0 && voy_is_finite(bandwidth) { + voyager_weights_distance_band(coords, bandwidth) + } else { + voyager_weights_knn(coords, k) + } + } + let copy = voy_copy_spatial_experiment(experiment) + let gene_names = voy_experiment_gene_names(experiment, expression.length()) + let results : Array[VoyagerUnivariateResult] = [] + let normalized_method : String = match stat_method { + "moran" => "moran" + "geary" => "geary" + "getis" => "getis" + "getis_ord" => "getis" + "gi" => "getis" + _ => + raise VoyagerError::VoyagerError( + "Voyager SpatialExperiment stat_method must be moran/geary/getis", + ) + } + for feature_index in feature_indices { + let vector : Array[Double] = [] + for spot in 0.. { + let global = voyager_global_morans_i( + vector, + weights_resolved, + feature=feature_name, + ) + let local_res = voyager_local_morans_i( + vector, + weights_resolved, + permutations~, + seed~, + fdr_threshold~, + feature=feature_name, + ) + if write_row_data { + copy.row_data[feature_index][output_prefix + ".moran.I" + suffix] = global.estimate.to_string() + copy.row_data[feature_index][output_prefix + ".moran.p" + suffix] = global.p_value.to_string() + } + let local_str : Array[String] = [] + let fdr_str : Array[String] = [] + let quad_str : Array[String] = [] + for spot in 0.. { + let global = voyager_global_gearys_c( + vector, + weights_resolved, + feature=feature_name, + ) + let local_res = voyager_local_gearys_c( + vector, + weights_resolved, + permutations~, + seed~, + fdr_threshold~, + feature=feature_name, + ) + if write_row_data { + copy.row_data[feature_index][output_prefix + ".geary.C" + suffix] = global.estimate.to_string() + copy.row_data[feature_index][output_prefix + ".geary.p" + suffix] = global.p_value.to_string() + } + let local_str : Array[String] = [] + let fdr_str : Array[String] = [] + let class_str : Array[String] = [] + for spot in 0.. { + let local_res = voyager_local_getis_ord( + vector, + weights_resolved, + star=true, + fdr_threshold~, + feature=feature_name, + ) + let local_str : Array[String] = [] + let fdr_str : Array[String] = [] + let class_str : Array[String] = [] + let z_str : Array[String] = [] + for spot in 0.. SpatialExperiment { + let se = SpatialExperiment::new() + let _ = se_set_metadata(se, "platform", "Visium") + let _ = se_set_metadata(se, "sample_id", "voyager_example") + // 6x6 grid of spots. + let spots = 36 + let genes = 4 + let gene_names = ["gene_gradient", "gene_hotspot", "gene_noise", "gene_anti"] + for gene in 0.. Map[String, String] { + let column : Map[String, String] = Map([], capacity=2) + column["spot_id"] = spot_id + column["tissue"] = tissue + column +} diff --git a/src/vsn.mbt b/src/vsn.mbt index dff4f045..e798f743 100644 --- a/src/vsn.mbt +++ b/src/vsn.mbt @@ -9,8 +9,11 @@ // ---- helper --------------------------------------------------------------- -fn vsn_is_na(x : Double) -> Bool { x.is_nan() } +fn vsn_is_na(x : Double) -> Bool { + x.is_nan() +} +///| fn vsn_copy(mat : Array[Array[Double]]) -> Array[Array[Double]] { let n = mat.length() let out : Array[Array[Double]] = Array::new() @@ -30,10 +33,8 @@ fn vsn_copy(mat : Array[Array[Double]]) -> Array[Array[Double]] { out } -fn vsn_col_mean_sd( - mat : Array[Array[Double]], - j : Int, -) -> (Double, Double) { +///| +fn vsn_col_mean_sd(mat : Array[Array[Double]], j : Int) -> (Double, Double) { let mut s = 0.0 let mut s2 = 0.0 let mut c = 0 @@ -48,7 +49,9 @@ fn vsn_col_mean_sd( } i = i + 1 } - if c < 2 { return (0.0, 0.0) } + if c < 2 { + return (0.0, 0.0) + } let mu = s / c.to_double() let myvar = (s2 - s * s / c.to_double()) / (c - 1).to_double() let sd = if myvar > 0.0 { myvar.sqrt() } else { 0.0 } @@ -57,16 +60,19 @@ fn vsn_col_mean_sd( // ---- parameters & result -------------------------------------------------- +///| pub struct VSNColParam { a : Double b : Double } +///| pub struct VSNResult { params : Array[VSNColParam] reference_mean_sd : Array[(Double, Double)] } +///| pub struct VSNControl { pub n_bins : Int pub min_bin_count : Int @@ -74,30 +80,37 @@ pub struct VSNControl { pub lts_frac : Double } +///| pub fn VSNControl::new() -> VSNControl { - VSNControl::{ - n_bins: 20, - min_bin_count: 5, - max_iter: 20, - lts_frac: 0.9, - } + VSNControl::{ n_bins: 20, min_bin_count: 5, max_iter: 20, lts_frac: 0.9 } } // ---- core transform ------------------------------------------------------- +///| pub fn glog(x : Double, a : Double, b : Double) -> Double { let v = (a + b * x) / 2.0 let inner = v + (v * v + 1.0).sqrt() - if inner <= 0.0 { 0.0 } else { @math.ln(inner) } + if inner <= 0.0 { + 0.0 + } else { + @math.ln(inner) + } } +///| pub fn glog_inv(y : Double, a : Double, b : Double) -> Double { - let s = ((@math.exp(y) - @math.exp(-y)) / 2.0) - if b == 0.0 { 0.0 } else { (2.0 * s - a) / b } + let s = (@math.exp(y) - @math.exp(-y)) / 2.0 + if b == 0.0 { + 0.0 + } else { + (2.0 * s - a) / b + } } // ---- per-column parameter fitting ---------------------------------------- +///| fn vsn_lm( x : Array[Double], y : Array[Double], @@ -105,7 +118,9 @@ fn vsn_lm( max_iter : Int, ) -> (Double, Double) { let n = x.length() - if n == 0 { return (0.0, 1.0) } + if n == 0 { + return (0.0, 1.0) + } let mut sx = 0.0 let mut sy = 0.0 let mut sxx = 0.0 @@ -118,7 +133,7 @@ fn vsn_lm( sxy = sxy + x[i] * y[i] i = i + 1 } - let denom = (n.to_double() * sxx - sx * sx) + let denom = n.to_double() * sxx - sx * sx let mut b = if denom == 0.0 { 1.0 } else { @@ -135,13 +150,23 @@ fn vsn_lm( i2 = i2 + 1 } resid.sort_by(fn(p : (Int, Double), q : (Int, Double)) -> Int { - if p.1 < q.1 { -1 } else if p.1 > q.1 { 1 } else { 0 } + if p.1 < q.1 { + -1 + } else if p.1 > q.1 { + 1 + } else { + 0 + } }) let keep = if n < 2 { n } else { let k = (lts_frac * n.to_double()).to_int() - if k < 2 { 2 } else { k } + if k < 2 { + 2 + } else { + k + } } let mut sx2 = 0.0 let mut sy2 = 0.0 @@ -158,18 +183,21 @@ fn vsn_lm( t = t + 1 } let kd = k2.to_double() - let d2 = (kd * sxx2 - sx2 * sx2) + let d2 = kd * sxx2 - sx2 * sx2 let nb = if d2 == 0.0 { b } else { (kd * sxy2 - sx2 * sy2) / d2 } let na = if kd == 0.0 { a } else { (sy2 - nb * sx2) / kd } let da = (na - a).abs() + (nb - b).abs() a = na b = nb - if da < 0.00000001 { break } + if da < 0.00000001 { + break + } _it = _it + 1 } (a, b) } +///| fn vsn_fit_col( mat : Array[Array[Double]], j : Int, @@ -216,13 +244,23 @@ fn vsn_fit_col( ii = ii + 1 } order.sort_by(fn(p : (Double, Double), q : (Double, Double)) -> Int { - if p.0 < q.0 { -1 } else if p.0 > q.0 { 1 } else { 0 } + if p.0 < q.0 { + -1 + } else if p.0 > q.0 { + 1 + } else { + 0 + } }) let bin_x : Array[Double] = Array::new() let bin_y : Array[Double] = Array::new() if pts > 0 { let bin_size = if pts / n_bins < ctrl.min_bin_count { - if ctrl.min_bin_count < 1 { 1 } else { ctrl.min_bin_count } + if ctrl.min_bin_count < 1 { + 1 + } else { + ctrl.min_bin_count + } } else { pts / n_bins } @@ -245,9 +283,11 @@ fn vsn_fit_col( } if kk > 0 { let kd = kk.to_double() - let new_len = (prev_cnt_d + kd) - bin_x[last_idx] = (bin_x[last_idx] * prev_cnt_d + mx / kd * kd) / new_len - bin_y[last_idx] = (bin_y[last_idx] * prev_cnt_d + my / kd * kd) / new_len + let new_len = prev_cnt_d + kd + bin_x[last_idx] = (bin_x[last_idx] * prev_cnt_d + mx / kd * kd) / + new_len + bin_y[last_idx] = (bin_y[last_idx] * prev_cnt_d + my / kd * kd) / + new_len } start = end continue @@ -274,12 +314,13 @@ fn vsn_fit_col( ref_ms.push((bin_x[t], bin_y[t])) t = t + 1 } - (VSNColParam::{ a: a, b: bb, }, ref_ms) + (VSNColParam::{ a, b: bb }, ref_ms) } +///| fn vsn_fit(mat : Array[Array[Double]], ctrl : VSNControl) -> VSNResult { if mat.length() == 0 { - return VSNResult::{ params: [], reference_mean_sd: [], } + return VSNResult::{ params: [], reference_mean_sd: [] } } let cols = mat[0].length() let params : Array[VSNColParam] = Array::new() @@ -288,15 +329,15 @@ fn vsn_fit(mat : Array[Array[Double]], ctrl : VSNControl) -> VSNResult { while j < cols { let (p, rms) = vsn_fit_col(mat, j, ctrl) params.push(p) - if j == 0 { ref_out = rms } + if j == 0 { + ref_out = rms + } j = j + 1 } - VSNResult::{ - params: params, - reference_mean_sd: ref_out, - } + VSNResult::{ params, reference_mean_sd: ref_out } } +///| fn vsn_transform( mat : Array[Array[Double]], fit : VSNResult, @@ -320,11 +361,13 @@ fn vsn_transform( out } +///| pub fn vsn2(mat : Array[Array[Double]]) -> Array[Array[Double]] { let fit = vsn_fit(mat, VSNControl::new()) vsn_transform(mat, fit) } +///| pub fn vsn2_with_control( mat : Array[Array[Double]], ctrl : VSNControl, @@ -333,24 +376,29 @@ pub fn vsn2_with_control( vsn_transform(mat, fit) } +///| pub fn vsn_fit_and_report(mat : Array[Array[Double]]) -> VSNResult { vsn_fit(mat, VSNControl::new()) } // ---- ASCII Mean-SD plot --------------------------------------------------- +///| pub struct MeanSDBin { mean_x : Double sd_y : Double count : Int } +///| pub fn mean_sd_bins( mat : Array[Array[Double]], n_bins : Int, ) -> Array[MeanSDBin] { let n = mat.length() - if n == 0 { return Array::new() } + if n == 0 { + return Array::new() + } let cols = mat[0].length() let pts : Array[(Double, Double)] = Array::new() let mut i = 0 @@ -367,12 +415,20 @@ pub fn mean_sd_bins( i = i + 1 } pts.sort_by(fn(p : (Double, Double), q : (Double, Double)) -> Int { - if p.0 < q.0 { -1 } else if p.0 > q.0 { 1 } else { 0 } + if p.0 < q.0 { + -1 + } else if p.0 > q.0 { + 1 + } else { + 0 + } }) let nb = if n_bins < 1 { 1 } else { n_bins } let total = pts.length() let out : Array[MeanSDBin] = Array::new() - if total == 0 { return out } + if total == 0 { + return out + } let step = total / nb let mut start = 0 while start < total { @@ -387,39 +443,43 @@ pub fn mean_sd_bins( t = t + 1 } let cnt_d = cnt.to_double() - out.push(MeanSDBin::{ - mean_x: sx / cnt_d, - sd_y: sy / cnt_d, - count: cnt, - }) + out.push(MeanSDBin::{ mean_x: sx / cnt_d, sd_y: sy / cnt_d, count: cnt }) start = end } out } -pub fn mean_sd_ascii( - mat : Array[Array[Double]], - n_bins? : Int = 40, -) -> String { +///| +pub fn mean_sd_ascii(mat : Array[Array[Double]], n_bins? : Int = 40) -> String { let bins = mean_sd_bins(mat, n_bins) let width = 40 let height = 10 - if bins.length() == 0 { return "(empty mean-SD plot)".to_string() } + if bins.length() == 0 { + return "(empty mean-SD plot)".to_string() + } let mut xmin = bins[0].mean_x let mut xmax = bins[0].mean_x let mut ymin = bins[0].sd_y let mut ymax = bins[0].sd_y for b in bins { - if b.mean_x < xmin { xmin = b.mean_x } - if b.mean_x > xmax { xmax = b.mean_x } - if b.sd_y < ymin { ymin = b.sd_y } - if b.sd_y > ymax { ymax = b.sd_y } + if b.mean_x < xmin { + xmin = b.mean_x + } + if b.mean_x > xmax { + xmax = b.mean_x + } + if b.sd_y < ymin { + ymin = b.sd_y + } + if b.sd_y > ymax { + ymax = b.sd_y + } } let xr = if xmax - xmin == 0.0 { 1.0 } else { xmax - xmin } let yr = if ymax - ymin == 0.0 { 1.0 } else { ymax - ymin } let grid : Array[Array[Int]] = Array::make( height, - Array::make(width, ' '.to_int()) + Array::make(width, ' '.to_int()), ) let k = bins.length() let mut idx = 0 @@ -427,30 +487,39 @@ pub fn mean_sd_ascii( let b = bins[idx] let xi = ((b.mean_x - xmin) / xr * (width - 1).to_double()).to_int() let yi = ((b.sd_y - ymin) / yr * (height - 1).to_double()).to_int() - let xii = if xi < 0 { 0 } else { if xi >= width { width - 1 } else { xi } } - let yii = if yi < 0 { 0 } else { if yi >= height { height - 1 } else { yi } } + let xii = if xi < 0 { 0 } else if xi >= width { width - 1 } else { xi } + let yii = if yi < 0 { 0 } else if yi >= height { height - 1 } else { yi } let row_idx = height - 1 - yii let c = grid[row_idx][xii] let nc = if c == ' '.to_int() { '*'.to_int() + } else if c == '*'.to_int() { + '+'.to_int() } else { - if c == '*'.to_int() { '+'.to_int() } else { '#'.to_int() } + '#'.to_int() } grid[row_idx][xii] = nc idx = idx + 1 } let buf = StringBuilder::new() - buf.write_string("mean-SD plot (mean=[\{xmin},\{xmax}] sd=[\{ymin},\{ymax}])\n") + buf.write_string( + "mean-SD plot (mean=[\{xmin},\{xmax}] sd=[\{ymin},\{ymax}])\n", + ) let mut r = 0 while r < height { let row = grid[r] let mut c = 0 while c < width { let ch = row[c] - if ch == ' '.to_int() { buf.write_char(' ') } - else if ch == '*'.to_int() { buf.write_char('*') } - else if ch == '+'.to_int() { buf.write_char('+') } - else { buf.write_char('#') } + if ch == ' '.to_int() { + buf.write_char(' ') + } else if ch == '*'.to_int() { + buf.write_char('*') + } else if ch == '+'.to_int() { + buf.write_char('+') + } else { + buf.write_char('#') + } c = c + 1 } buf.write_char('\n') @@ -459,6 +528,7 @@ pub fn mean_sd_ascii( buf.to_string() } +///| pub fn summarize_vsn_fit(fit : VSNResult) -> String { let buf = StringBuilder::new() let n = fit.params.length() @@ -469,16 +539,21 @@ pub fn summarize_vsn_fit(fit : VSNResult) -> String { buf.write_string(" col \{i}: a=\{p.a} b=\{p.b}\n") i = i + 1 } - if n > 5 { buf.write_string(" ... (\{n - 5} more)\n") } + if n > 5 { + buf.write_string(" ... (\{n - 5} more)\n") + } buf.to_string() } +///| pub fn vsn_denoise( mat : Array[Array[Double]], frac_of_median_var? : Double = 0.05, ) -> Array[Array[Double]] { let out = vsn_copy(mat) - if out.length() == 0 { return out } + if out.length() == 0 { + return out + } let cols = out[0].length() let vars : Array[Double] = Array::new() let mut j = 0 @@ -488,9 +563,17 @@ pub fn vsn_denoise( j = j + 1 } let sorted_vars : Array[Double] = Array::new() - for v in vars { sorted_vars.push(v) } + for v in vars { + sorted_vars.push(v) + } sorted_vars.sort_by(fn(a : Double, b : Double) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) let med = if sorted_vars.length() == 0 { 0.0 @@ -503,7 +586,9 @@ pub fn vsn_denoise( while i < n { let mut jj = 0 while jj < cols { - if vars[jj] < threshold { out[i][jj] = 0.0 } + if vars[jj] < threshold { + out[i][jj] = 0.0 + } jj = jj + 1 } i = i + 1 diff --git a/src/wise.mbt b/src/wise.mbt index 85b8fa8e..06143640 100644 --- a/src/wise.mbt +++ b/src/wise.mbt @@ -78,23 +78,15 @@ pub struct WiseExon { ///| /// Construct a WiseExon. pub fn WiseExon::new( - start~ : Int = 0, - end~ : Int = 0, - phase~ : Int = 0, - end_phase~ : Int = 0, - score~ : Double = 0.0, - protein_start~ : Int = 0, - protein_end~ : Int = 0, + start? : Int = 0, + end? : Int = 0, + phase? : Int = 0, + end_phase? : Int = 0, + score? : Double = 0.0, + protein_start? : Int = 0, + protein_end? : Int = 0, ) -> WiseExon { - WiseExon::{ - start, - end, - phase, - end_phase, - score, - protein_start, - protein_end, - } + WiseExon::{ start, end, phase, end_phase, score, protein_start, protein_end } } ///| @@ -116,19 +108,13 @@ pub struct WiseIntron { ///| /// Construct a WiseIntron. pub fn WiseIntron::new( - start~ : Int = 0, - end~ : Int = 0, - donor_score~ : Double = 0.0, - acceptor_score~ : Double = 0.0, + start? : Int = 0, + end? : Int = 0, + donor_score? : Double = 0.0, + acceptor_score? : Double = 0.0, ) -> WiseIntron { let len = if end >= start { end - start + 1 } else { 0 } - WiseIntron::{ - start, - end, - donor_score, - acceptor_score, - length: len, - } + WiseIntron::{ start, end, donor_score, acceptor_score, length: len } } ///| @@ -146,9 +132,9 @@ pub struct WiseAlignmentColumn { pub fn WiseAlignmentColumn::new( protein_char~ : Char, gene_codon~ : String, - match_type~ : String = " ", - gene_position~ : Int = 0, - protein_position~ : Int = 0, + match_type? : String = " ", + gene_position? : Int = 0, + protein_position? : Int = 0, ) -> WiseAlignmentColumn { WiseAlignmentColumn::{ protein_char, @@ -228,7 +214,9 @@ pub fn WiseResult::get_introns(self : WiseResult) -> Array[WiseIntron] { ///| /// Get the alignment. -pub fn WiseResult::get_alignment(self : WiseResult) -> Array[WiseAlignmentColumn] { +pub fn WiseResult::get_alignment( + self : WiseResult, +) -> Array[WiseAlignmentColumn] { self.alignment } @@ -304,14 +292,18 @@ pub fn wise_parse(content : String) -> WiseResult { if trimmed.starts_with("Score:") { let parts = trimmed.split(":").to_array() if parts.length() >= 2 { - result.score = parse_double(parts[1].to_string().trim().to_string()).unwrap_or(0.0) + result.score = parse_double(parts[1].to_string().trim().to_string()).unwrap_or( + 0.0, + ) } } // Parse bits score: "Bits: 45.67" if trimmed.starts_with("Bits:") { let parts = trimmed.split(":").to_array() if parts.length() >= 2 { - result.bits_score = parse_double(parts[1].to_string().trim().to_string()).unwrap_or(0.0) + result.bits_score = parse_double( + parts[1].to_string().trim().to_string(), + ).unwrap_or(0.0) } } // Parse protein ID: "Protein: P12345" @@ -347,7 +339,13 @@ pub fn wise_parse(content : String) -> WiseResult { } } // Parse parameter lines: "Parameter: value" - if trimmed.contains(":") && !trimmed.starts_with("Exon") && !trimmed.starts_with("Intron") && !trimmed.starts_with("Score") && !trimmed.starts_with("Bits") && !trimmed.starts_with("Protein") && !trimmed.starts_with("Gene") { + if trimmed.contains(":") && + !trimmed.starts_with("Exon") && + !trimmed.starts_with("Intron") && + !trimmed.starts_with("Score") && + !trimmed.starts_with("Bits") && + !trimmed.starts_with("Protein") && + !trimmed.starts_with("Gene") { let parts = trimmed.split(":").to_array() if parts.length() >= 2 { let key = parts[0].to_string().trim().to_string() @@ -401,21 +399,18 @@ fn wise_parse_exon_line(line : String) -> WiseExon? { let dash = protein_part.find("-") match dash { Some(dp) => { - protein_start = wise_extract_first_number(protein_part[0:dp].to_string()) - protein_end = wise_extract_first_number(protein_part[dp + 1:].to_string()) + protein_start = wise_extract_first_number( + protein_part[0:dp].to_string(), + ) + protein_end = wise_extract_first_number( + protein_part[dp + 1:].to_string(), + ) } None => () } } Some( - WiseExon::new( - start=start, - end=end, - phase=phase, - score=score, - protein_start=protein_start, - protein_end=protein_end, - ), + WiseExon::new(start~, end~, phase~, score~, protein_start~, protein_end~), ) } @@ -446,12 +441,7 @@ fn wise_parse_intron_line(line : String) -> WiseIntron? { acceptor = wise_extract_first_double(acc_str) } Some( - WiseIntron::new( - start=start, - end=end, - donor_score=donor, - acceptor_score=acceptor, - ), + WiseIntron::new(start~, end~, donor_score=donor, acceptor_score=acceptor), ) } @@ -465,11 +455,9 @@ fn wise_extract_last_number(s : String) -> Int { let c = chars[i] if c >= '0' && c <= '9' { current = current + c.to_string() - } else { - if current.length() > 0 { - result = parse_int(current) - current = "" - } + } else if current.length() > 0 { + result = parse_int(current) + current = "" } } if current.length() > 0 { @@ -487,10 +475,8 @@ fn wise_extract_first_number(s : String) -> Int { let c = chars[i] if c >= '0' && c <= '9' { current = current + c.to_string() - } else { - if current.length() > 0 { - return parse_int(current) - } + } else if current.length() > 0 { + return parse_int(current) } } if current.length() > 0 { @@ -605,11 +591,33 @@ pub fn wise_gene_structure(result : WiseResult) -> String { let sb = StringBuilder::new() for i in 0.. GenomeWiseSegment { GenomeWiseSegment::{ segment_id, @@ -732,11 +740,7 @@ pub struct GenomeWiseResult { ///| /// Construct an empty GenomeWiseResult. pub fn GenomeWiseResult::new() -> GenomeWiseResult { - GenomeWiseResult::{ - gene_id: "", - total_score: 0.0, - segments: [], - } + GenomeWiseResult::{ gene_id: "", total_score: 0.0, segments: [] } } ///| @@ -750,7 +754,9 @@ pub fn GenomeWiseResult::add_segment( ///| /// Get all segments. -pub fn GenomeWiseResult::get_segments(self : GenomeWiseResult) -> Array[GenomeWiseSegment] { +pub fn GenomeWiseResult::get_segments( + self : GenomeWiseResult, +) -> Array[GenomeWiseSegment] { self.segments } @@ -787,7 +793,13 @@ pub fn wise_summary(result : WiseResult) -> String { sb.write_string(" Bits: " + result.bits_score.to_string() + "\n") sb.write_string(" Exons: " + result.get_num_exons().to_string() + "\n") sb.write_string(" Introns: " + result.get_num_introns().to_string() + "\n") - sb.write_string(" Total exon length: " + result.get_total_exon_length().to_string() + " nt\n") - sb.write_string(" Parameters: " + result.parameters.size().to_string() + "\n") + sb.write_string( + " Total exon length: " + + result.get_total_exon_length().to_string() + + " nt\n", + ) + sb.write_string( + " Parameters: " + result.parameters.size().to_string() + "\n", + ) sb.to_string() } diff --git a/src/xcell.mbt b/src/xcell.mbt index e288524c..3eb54e96 100644 --- a/src/xcell.mbt +++ b/src/xcell.mbt @@ -22,7 +22,7 @@ /// A cell type gene signature used for xCell scoring. pub struct XcellSignature { cell_type : String - category : String // "immune", "stromal", "other" + category : String // "immune", "stromal", "other" genes : Array[String] } @@ -58,7 +58,7 @@ pub fn XcellSignature::genes(self : XcellSignature) -> Array[String] { /// Parameters for xCell scoring. pub struct XcellParams { min_gene_overlap : Int - alpha : Double // ssGSEA exponent + alpha : Double // ssGSEA exponent scale_scores : Bool do_spillover : Bool verbose : Bool @@ -79,12 +79,12 @@ pub fn XcellParams::new() -> XcellParams { ///| /// Result from xCell analysis. pub struct XcellResult { - scores : Array[Array[Double]] // rows=cell_types, cols=samples + scores : Array[Array[Double]] // rows=cell_types, cols=samples cell_types : Array[String] categories : Array[String] sample_names : Array[String] - immune_scores : Array[Double] // per sample aggregate immune score - stromal_scores : Array[Double] // per sample aggregate stromal score + immune_scores : Array[Double] // per sample aggregate immune score + stromal_scores : Array[Double] // per sample aggregate stromal score microenvironment_scores : Array[Double] // immune + stromal params : XcellParams } @@ -120,7 +120,11 @@ pub fn XcellResult::new( ///| /// Absolute value. fn xc_abs(x : Double) -> Double { - if x < 0.0 { -x } else { x } + if x < 0.0 { + -x + } else { + x + } } ///| @@ -165,7 +169,7 @@ pub fn xcell_ssgsea_single( expression : Array[Double], gene_names : Array[String], set_genes : Array[String], - alpha~ : Double = 0.25, + alpha? : Double = 0.25, ) -> Double { let n = expression.length() if n == 0 || n != gene_names.length() || set_genes.length() == 0 { @@ -184,18 +188,20 @@ pub fn xcell_ssgsea_single( } } let n_set = set_indices.length() - if n_set < 3 { return 0.0 } + if n_set < 3 { + return 0.0 + } let n_total = n // Sort expression descending (rank high to low) let (_sorted_exp, order_indices) = xc_sort_with_indices( - expression.map(fn(v) { -v }) // neg for descending + expression.map(fn(v) { -v }), // neg for descending ) // Walk down ranked list, compute running sum // weight_i = i^alpha, for i in 1..N // weight_G = sum of weights of set members - let pw_over = (n_set).to_double() / n_total.to_double() + let pw_over = n_set.to_double() / n_total.to_double() let mut sum_weight_set = 0.0 for k in 1..<(n + 1) { sum_weight_set = sum_weight_set + k.to_double().pow(alpha) * pw_over @@ -210,7 +216,7 @@ pub fn xcell_ssgsea_single( let mut cumulate_set = 0.0 let mut cumulate_other = 0.0 for rank in 1..<(n + 1) { - let gene_idx = order_indices[rank - 1] // 1-based rank -> 0-based index + let gene_idx = order_indices[rank - 1] // 1-based rank -> 0-based index // Check if gene is in set let mut in_set = false for si in 0.. 0.0 { cumulate_set / n_set_d } else { 0.0 } - let frac_other = if (n_total_d - n_set_d) > 0.0 { + let frac_other = if n_total_d - n_set_d > 0.0 { cumulate_other / (n_total_d - n_set_d) - } else { 0.0 } + } else { + 0.0 + } let current = frac_set - frac_other - if current > max_score { max_score = current } - if current < min_score { min_score = current } + if current > max_score { + max_score = current + } + if current < min_score { + min_score = current + } } // ssGSEA score is max + min (i.e., the difference between max deviation up and down) // Actually typical ssGSEA returns max-min normalized. Return max - |min|. @@ -258,140 +270,203 @@ pub fn xcell_ssgsea_single( pub fn xcell_default_signatures() -> Array[XcellSignature] { [ // ====== Lymphoid lineage ====== - XcellSignature::new("B-cells", "immune", - ["CD19", "MS4A1", "CD79A", "CD79B", "BLK", "BANK1", "PAX5", "IGHM"]), - XcellSignature::new("B-cells naive", "immune", - ["MS4A1", "CD19", "TCF3", "SELL", "IGHD", "CD22", "CXCR5", "FCER2"]), - XcellSignature::new("B-cells memory", "immune", - ["CD27", "MS4A1", "CD19", "AIM2", "BCL2", "KCNN4", "CD80", "PRDM1"]), - XcellSignature::new("Plasma cells", "immune", - ["SDC1", "CD138", "MZB1", "XBP1", "PRDM1", "IRF4", "SLAMF7", "TNFRSF17"]), - XcellSignature::new("T-cells CD4+", "immune", - ["CD4", "CD3D", "CD3E", "TRAC", "IL7R", "LTB", "MAL", "LEF1"]), - XcellSignature::new("T-cells CD4+ naive", "immune", - ["CD4", "SELL", "CCR7", "LEF1", "TCF7", "IL7R", "NELL2", "FHIT"]), - XcellSignature::new("T-cells CD4+ central memory", "immune", - ["CD4", "SELL", "CCR7", "CD27", "CD28", "IL2RB", "S100A4", "ITGAL"]), - XcellSignature::new("T-cells CD4+ effector memory", "immune", - ["CD4", "CD45RO", "CCR5", "CXCR3", "IL2RB", "IL7R", "ITGAE", "KLRB1"]), - XcellSignature::new("T-cells CD4+ Th1", "immune", - ["CD4", "TBX21", "IFNG", "CXCR3", "STAT1", "IL12RB2", "IL18R1", "HAVCR2"]), - XcellSignature::new("T-cells CD4+ Th2", "immune", - ["CD4", "GATA3", "IL4", "IL5", "IL13", "CCR4", "IL1RL1", "PTGDR2"]), - XcellSignature::new("T-cells CD4+ Th17", "immune", - ["CD4", "RORC", "IL17A", "IL17F", "CCR6", "IL22", "IL23R", "KLRB1"]), - XcellSignature::new("Tregs", "immune", - ["FOXP3", "IL2RA", "CD25", "CTLA4", "IKZF2", "IL10", "TIGIT", "TNFRSF18"]), - XcellSignature::new("T-cells CD8+", "immune", - ["CD8A", "CD8B", "CD3D", "CD3E", "TRAC", "GZMA", "GZMK", "NKG7"]), - XcellSignature::new("T-cells CD8+ naive", "immune", - ["CD8A", "SELL", "CCR7", "LEF1", "TCF7", "IL7R", "NELL2", "LTB"]), - XcellSignature::new("T-cells CD8+ central memory", "immune", - ["CD8A", "SELL", "CCR7", "CD27", "CD28", "GZMK", "IL2RB", "LTB"]), - XcellSignature::new("T-cells CD8+ effector memory", "immune", - ["CD8A", "CD45RO", "GZMA", "GZMB", "PRF1", "NKG7", "CXCR3", "CCL5"]), - XcellSignature::new("CD8+ T-cells cytotoxic", "immune", - ["CD8A", "GZMA", "GZMB", "PRF1", "NKG7", "GNLY", "KLRD1", "KLRK1"]), - XcellSignature::new("NKT cells", "immune", - ["KLRB1", "NKG7", "CD3D", "TRAV10", "TRAJ18", "GZMB", "PRF1", "ZBTB16"]), - XcellSignature::new("Tgd cells", "immune", - ["TRGV9", "TRDV2", "TRDC", "CD3D", "NKG7", "KLRB1", "RORC", "IL17A"]), + XcellSignature::new("B-cells", "immune", [ + "CD19", "MS4A1", "CD79A", "CD79B", "BLK", "BANK1", "PAX5", "IGHM", + ]), + XcellSignature::new("B-cells naive", "immune", [ + "MS4A1", "CD19", "TCF3", "SELL", "IGHD", "CD22", "CXCR5", "FCER2", + ]), + XcellSignature::new("B-cells memory", "immune", [ + "CD27", "MS4A1", "CD19", "AIM2", "BCL2", "KCNN4", "CD80", "PRDM1", + ]), + XcellSignature::new("Plasma cells", "immune", [ + "SDC1", "CD138", "MZB1", "XBP1", "PRDM1", "IRF4", "SLAMF7", "TNFRSF17", + ]), + XcellSignature::new("T-cells CD4+", "immune", [ + "CD4", "CD3D", "CD3E", "TRAC", "IL7R", "LTB", "MAL", "LEF1", + ]), + XcellSignature::new("T-cells CD4+ naive", "immune", [ + "CD4", "SELL", "CCR7", "LEF1", "TCF7", "IL7R", "NELL2", "FHIT", + ]), + XcellSignature::new("T-cells CD4+ central memory", "immune", [ + "CD4", "SELL", "CCR7", "CD27", "CD28", "IL2RB", "S100A4", "ITGAL", + ]), + XcellSignature::new("T-cells CD4+ effector memory", "immune", [ + "CD4", "CD45RO", "CCR5", "CXCR3", "IL2RB", "IL7R", "ITGAE", "KLRB1", + ]), + XcellSignature::new("T-cells CD4+ Th1", "immune", [ + "CD4", "TBX21", "IFNG", "CXCR3", "STAT1", "IL12RB2", "IL18R1", "HAVCR2", + ]), + XcellSignature::new("T-cells CD4+ Th2", "immune", [ + "CD4", "GATA3", "IL4", "IL5", "IL13", "CCR4", "IL1RL1", "PTGDR2", + ]), + XcellSignature::new("T-cells CD4+ Th17", "immune", [ + "CD4", "RORC", "IL17A", "IL17F", "CCR6", "IL22", "IL23R", "KLRB1", + ]), + XcellSignature::new("Tregs", "immune", [ + "FOXP3", "IL2RA", "CD25", "CTLA4", "IKZF2", "IL10", "TIGIT", "TNFRSF18", + ]), + XcellSignature::new("T-cells CD8+", "immune", [ + "CD8A", "CD8B", "CD3D", "CD3E", "TRAC", "GZMA", "GZMK", "NKG7", + ]), + XcellSignature::new("T-cells CD8+ naive", "immune", [ + "CD8A", "SELL", "CCR7", "LEF1", "TCF7", "IL7R", "NELL2", "LTB", + ]), + XcellSignature::new("T-cells CD8+ central memory", "immune", [ + "CD8A", "SELL", "CCR7", "CD27", "CD28", "GZMK", "IL2RB", "LTB", + ]), + XcellSignature::new("T-cells CD8+ effector memory", "immune", [ + "CD8A", "CD45RO", "GZMA", "GZMB", "PRF1", "NKG7", "CXCR3", "CCL5", + ]), + XcellSignature::new("CD8+ T-cells cytotoxic", "immune", [ + "CD8A", "GZMA", "GZMB", "PRF1", "NKG7", "GNLY", "KLRD1", "KLRK1", + ]), + XcellSignature::new("NKT cells", "immune", [ + "KLRB1", "NKG7", "CD3D", "TRAV10", "TRAJ18", "GZMB", "PRF1", "ZBTB16", + ]), + XcellSignature::new("Tgd cells", "immune", [ + "TRGV9", "TRDV2", "TRDC", "CD3D", "NKG7", "KLRB1", "RORC", "IL17A", + ]), // ====== Myeloid lineage ====== - XcellSignature::new("Monocytes", "immune", - ["CD14", "CD68", "CSF1R", "S100A8", "S100A9", "FCGR3A", "LYZ", "VNN2"]), - XcellSignature::new("Monocytes CD14+", "immune", - ["CD14", "LYZ", "CSF1R", "S100A12", "S100A8", "S100A9", "FCN1", "VCAN"]), - XcellSignature::new("Monocytes CD16+", "immune", - ["FCGR3A", "CD16", "CD14", "MS4A4A", "CX3CR1", "CSF1R", "LYN", "ITGAM"]), - XcellSignature::new("Macrophages", "immune", - ["CD68", "CD163", "MSR1", "MRC1", "CSF1R", "MARCO", "CD84", "STAB1"]), - XcellSignature::new("Macrophages M0", "immune", - ["CD68", "CSF1R", "CD14", "FCGR1A", "MSR1", "LYZ", "S100A8", "S100A9"]), - XcellSignature::new("Macrophages M1", "immune", - ["NOS2", "CD80", "CD86", "IL1B", "TNF", "CXCL9", "CXCL10", "HLA-DRA"]), - XcellSignature::new("Macrophages M2", "immune", - ["CD163", "MRC1", "CD209", "MSR1", "IL10", "TGFB1", "VEGFA", "ARG1"]), - XcellSignature::new("Dendritic cells", "immune", - ["ITGAX", "CD1C", "CLEC10A", "FCER1A", "CD80", "CD86", "HLA-DRA", "CCR7"]), - XcellSignature::new("DCs immature", "immune", - ["ITGAX", "CD1C", "MRC1", "FCER1A", "CLEC10A", "CCR5", "TLR7", "TLR9"]), - XcellSignature::new("DCs plasmacytoid", "immune", - ["IL3RA", "CLEC4C", "LILRA4", "IRF7", "IRF8", "TLR7", "TLR9", "CXCR3"]), - XcellSignature::new("DCs activated", "immune", - ["ITGAX", "CD80", "CD86", "CD40", "CCR7", "HLA-DRA", "IL12A", "IL12B"]), - XcellSignature::new("Mast cells", "immune", - ["KIT", "CD117", "TPSAB1", "CPA3", "MS4A2", "HDC", "TPSB2", "GATA2"]), - XcellSignature::new("Mast cells resting", "immune", - ["KIT", "TPSAB1", "CPA3", "MS4A2", "GATA2", "HRH4", "CMA1", "TPSG1"]), - XcellSignature::new("Mast cells activated", "immune", - ["KIT", "TPSAB1", "MS4A2", "IL1B", "TNF", "IL6", "CCL3", "CCL4"]), - XcellSignature::new("Eosinophils", "immune", - ["SIGLEC8", "IL5RA", "CCR3", "PRG2", "PRG3", "EPX", "RNASE2", "RNASE3"]), - XcellSignature::new("Neutrophils", "immune", - ["FCGR3B", "CD66b", "CXCR2", "S100A8", "S100A9", "MPO", "ELANE", "CEACAM8"]), - XcellSignature::new("Basophils", "immune", - ["MS4A2", "CCR3", "IL3RA", "HDC", "TPSAB1", "IL4", "IL13", "FCER1A"]), + XcellSignature::new("Monocytes", "immune", [ + "CD14", "CD68", "CSF1R", "S100A8", "S100A9", "FCGR3A", "LYZ", "VNN2", + ]), + XcellSignature::new("Monocytes CD14+", "immune", [ + "CD14", "LYZ", "CSF1R", "S100A12", "S100A8", "S100A9", "FCN1", "VCAN", + ]), + XcellSignature::new("Monocytes CD16+", "immune", [ + "FCGR3A", "CD16", "CD14", "MS4A4A", "CX3CR1", "CSF1R", "LYN", "ITGAM", + ]), + XcellSignature::new("Macrophages", "immune", [ + "CD68", "CD163", "MSR1", "MRC1", "CSF1R", "MARCO", "CD84", "STAB1", + ]), + XcellSignature::new("Macrophages M0", "immune", [ + "CD68", "CSF1R", "CD14", "FCGR1A", "MSR1", "LYZ", "S100A8", "S100A9", + ]), + XcellSignature::new("Macrophages M1", "immune", [ + "NOS2", "CD80", "CD86", "IL1B", "TNF", "CXCL9", "CXCL10", "HLA-DRA", + ]), + XcellSignature::new("Macrophages M2", "immune", [ + "CD163", "MRC1", "CD209", "MSR1", "IL10", "TGFB1", "VEGFA", "ARG1", + ]), + XcellSignature::new("Dendritic cells", "immune", [ + "ITGAX", "CD1C", "CLEC10A", "FCER1A", "CD80", "CD86", "HLA-DRA", "CCR7", + ]), + XcellSignature::new("DCs immature", "immune", [ + "ITGAX", "CD1C", "MRC1", "FCER1A", "CLEC10A", "CCR5", "TLR7", "TLR9", + ]), + XcellSignature::new("DCs plasmacytoid", "immune", [ + "IL3RA", "CLEC4C", "LILRA4", "IRF7", "IRF8", "TLR7", "TLR9", "CXCR3", + ]), + XcellSignature::new("DCs activated", "immune", [ + "ITGAX", "CD80", "CD86", "CD40", "CCR7", "HLA-DRA", "IL12A", "IL12B", + ]), + XcellSignature::new("Mast cells", "immune", [ + "KIT", "CD117", "TPSAB1", "CPA3", "MS4A2", "HDC", "TPSB2", "GATA2", + ]), + XcellSignature::new("Mast cells resting", "immune", [ + "KIT", "TPSAB1", "CPA3", "MS4A2", "GATA2", "HRH4", "CMA1", "TPSG1", + ]), + XcellSignature::new("Mast cells activated", "immune", [ + "KIT", "TPSAB1", "MS4A2", "IL1B", "TNF", "IL6", "CCL3", "CCL4", + ]), + XcellSignature::new("Eosinophils", "immune", [ + "SIGLEC8", "IL5RA", "CCR3", "PRG2", "PRG3", "EPX", "RNASE2", "RNASE3", + ]), + XcellSignature::new("Neutrophils", "immune", [ + "FCGR3B", "CD66b", "CXCR2", "S100A8", "S100A9", "MPO", "ELANE", "CEACAM8", + ]), + XcellSignature::new("Basophils", "immune", [ + "MS4A2", "CCR3", "IL3RA", "HDC", "TPSAB1", "IL4", "IL13", "FCER1A", + ]), // ====== NK lineage ====== - XcellSignature::new("NK cells", "immune", - ["NCAM1", "NKG7", "KLRD1", "GNLY", "GZMB", "PRF1", "NCR1", "KLRK1"]), - XcellSignature::new("NK cells resting", "immune", - ["NCAM1", "KLRD1", "SELL", "CD160", "CD27", "IL2RB", "KLRB1", "PTGDR"]), - XcellSignature::new("NK cells activated", "immune", - ["NCAM1", "NKG7", "GZMB", "PRF1", "GNLY", "KLRK1", "FCGR3A", "IFNG"]), - XcellSignature::new("NK cells CD56dim", "immune", - ["FCGR3A", "CD16", "NCAM1", "KLRD1", "GZMB", "PRF1", "NKG7", "GNLY"]), - XcellSignature::new("NK cells CD56bright", "immune", - ["NCAM1", "KIT", "IL2RA", "IL7R", "CCR7", "SELL", "CD160", "KLRB1"]), + XcellSignature::new("NK cells", "immune", [ + "NCAM1", "NKG7", "KLRD1", "GNLY", "GZMB", "PRF1", "NCR1", "KLRK1", + ]), + XcellSignature::new("NK cells resting", "immune", [ + "NCAM1", "KLRD1", "SELL", "CD160", "CD27", "IL2RB", "KLRB1", "PTGDR", + ]), + XcellSignature::new("NK cells activated", "immune", [ + "NCAM1", "NKG7", "GZMB", "PRF1", "GNLY", "KLRK1", "FCGR3A", "IFNG", + ]), + XcellSignature::new("NK cells CD56dim", "immune", [ + "FCGR3A", "CD16", "NCAM1", "KLRD1", "GZMB", "PRF1", "NKG7", "GNLY", + ]), + XcellSignature::new("NK cells CD56bright", "immune", [ + "NCAM1", "KIT", "IL2RA", "IL7R", "CCR7", "SELL", "CD160", "KLRB1", + ]), // ====== Stromal / microenvironment ====== - XcellSignature::new("Endothelial cells", "stromal", - ["PECAM1", "CD31", "VWF", "CDH5", "VEGFR2", "KDR", "ESAM", "ENG"]), - XcellSignature::new("Endothelial cells lymphatic", "stromal", - ["PDPN", "LYVE1", "PTPRC", "VEGFR3", "FLT4", "PROX1", "CXCL12", "CCL21"]), - XcellSignature::new("Endothelial cells microvascular", "stromal", - ["PECAM1", "VWF", "VEGFR2", "ESAM", "CAV1", "TIE1", "TEK", "MCAM"]), - XcellSignature::new("Fibroblasts", "stromal", - ["COL1A1", "COL1A2", "FAP", "PDPN", "S100A4", "THY1", "DCN", "VIM"]), - XcellSignature::new("Fibroblasts activated", "stromal", - ["COL1A1", "COL3A1", "FAP", "ACTA2", "PDPN", "POSTN", "TNC", "FN1"]), - XcellSignature::new("Pericytes", "stromal", - ["RGS5", "PDGFRB", "ACTA2", "MCAM", "CSPG4", "CD146", "KCNJ8", "ABCC9"]), - XcellSignature::new("Smooth muscle cells", "stromal", - ["ACTA2", "MYH11", "TAGLN", "TPM1", "TPM2", "CALD1", "CNN1", "MYL9"]), - XcellSignature::new("Adipocytes", "stromal", - ["FABP4", "ADIPOQ", "PLIN1", "LIPE", "PNPLA2", "SLC2A4", "CIDEC", "PPARG"]), - XcellSignature::new("Chondrocytes", "stromal", - ["COL2A1", "ACAN", "SOX9", "COMP", "CHAD", "CRTL1", "LEF1", "MATN1"]), - XcellSignature::new("Osteoblasts", "stromal", - ["ALPL", "COL1A1", "SP7", "RUNX2", "BGLAP", "SPP1", "IBSP", "MEPE"]), - XcellSignature::new("Mesangial cells", "stromal", - ["PDGFRB", "ACTA2", "VIM", "ITGB1", "FN1", "COL1A1", "COL4A1", "NOTCH3"]), - XcellSignature::new("Schwann cells", "stromal", - ["SOX10", "S100B", "MPZ", "MBP", "PLP1", "PRX", "EGR2", "GAP43"]), - XcellSignature::new("Keratinocytes", "stromal", - ["KRT14", "KRT5", "KRT1", "KRT10", "IVL", "LOR", "DSG3", "EPCAM"]), + XcellSignature::new("Endothelial cells", "stromal", [ + "PECAM1", "CD31", "VWF", "CDH5", "VEGFR2", "KDR", "ESAM", "ENG", + ]), + XcellSignature::new("Endothelial cells lymphatic", "stromal", [ + "PDPN", "LYVE1", "PTPRC", "VEGFR3", "FLT4", "PROX1", "CXCL12", "CCL21", + ]), + XcellSignature::new("Endothelial cells microvascular", "stromal", [ + "PECAM1", "VWF", "VEGFR2", "ESAM", "CAV1", "TIE1", "TEK", "MCAM", + ]), + XcellSignature::new("Fibroblasts", "stromal", [ + "COL1A1", "COL1A2", "FAP", "PDPN", "S100A4", "THY1", "DCN", "VIM", + ]), + XcellSignature::new("Fibroblasts activated", "stromal", [ + "COL1A1", "COL3A1", "FAP", "ACTA2", "PDPN", "POSTN", "TNC", "FN1", + ]), + XcellSignature::new("Pericytes", "stromal", [ + "RGS5", "PDGFRB", "ACTA2", "MCAM", "CSPG4", "CD146", "KCNJ8", "ABCC9", + ]), + XcellSignature::new("Smooth muscle cells", "stromal", [ + "ACTA2", "MYH11", "TAGLN", "TPM1", "TPM2", "CALD1", "CNN1", "MYL9", + ]), + XcellSignature::new("Adipocytes", "stromal", [ + "FABP4", "ADIPOQ", "PLIN1", "LIPE", "PNPLA2", "SLC2A4", "CIDEC", "PPARG", + ]), + XcellSignature::new("Chondrocytes", "stromal", [ + "COL2A1", "ACAN", "SOX9", "COMP", "CHAD", "CRTL1", "LEF1", "MATN1", + ]), + XcellSignature::new("Osteoblasts", "stromal", [ + "ALPL", "COL1A1", "SP7", "RUNX2", "BGLAP", "SPP1", "IBSP", "MEPE", + ]), + XcellSignature::new("Mesangial cells", "stromal", [ + "PDGFRB", "ACTA2", "VIM", "ITGB1", "FN1", "COL1A1", "COL4A1", "NOTCH3", + ]), + XcellSignature::new("Schwann cells", "stromal", [ + "SOX10", "S100B", "MPZ", "MBP", "PLP1", "PRX", "EGR2", "GAP43", + ]), + XcellSignature::new("Keratinocytes", "stromal", [ + "KRT14", "KRT5", "KRT1", "KRT10", "IVL", "LOR", "DSG3", "EPCAM", + ]), // ====== Epithelial / other ====== - XcellSignature::new("Epithelial cells", "other", - ["EPCAM", "KRT19", "KRT8", "KRT18", "CDH1", "CD24", "MUC1", "CLDN4"]), - XcellSignature::new("Hepatocytes", "other", - ["ALB", "AFP", "CYP3A4", "HNF4A", "FABP1", "ASGR1", "SLC10A1", "APOB"]), - XcellSignature::new("Skeletal muscle cells", "other", - ["ACTA1", "MYH3", "MYOG", "MYOD1", "TNNT1", "TNNT3", "TTN", "MYL2"]), - XcellSignature::new("Neurons", "other", - ["TUBB3", "RBFOX3", "MAP2", "SYP", "SNAP25", "STMN2", "ENO2", "GAP43"]), - XcellSignature::new("Astrocytes", "other", - ["GFAP", "ALDH1L1", "S100B", "AQP4", "FGFR3", "TNC", "GLUL", "GJA1"]), - XcellSignature::new("Oligodendrocytes", "other", - ["MBP", "PLP1", "MAG", "MOG", "SOX10", "OLIG1", "OLIG2", "CNP"]), - XcellSignature::new("Podocytes", "other", - ["NPHS1", "NPHS2", "PODXL", "SYNPO", "WT1", "ACTN4", "CD2AP", "TPM3"]), - XcellSignature::new("Megakaryocytes", "other", - ["PPBP", "PF4", "ITGA2B", "GP9", "VWF", "NFE2", "MEIS1", "GATA1"]), - XcellSignature::new("Erythrocytes", "other", - ["HBB", "HBA1", "HBA2", "GATA1", "KLF1", "EPOR", "AHSP", "SLC4A1"]), + XcellSignature::new("Epithelial cells", "other", [ + "EPCAM", "KRT19", "KRT8", "KRT18", "CDH1", "CD24", "MUC1", "CLDN4", + ]), + XcellSignature::new("Hepatocytes", "other", [ + "ALB", "AFP", "CYP3A4", "HNF4A", "FABP1", "ASGR1", "SLC10A1", "APOB", + ]), + XcellSignature::new("Skeletal muscle cells", "other", [ + "ACTA1", "MYH3", "MYOG", "MYOD1", "TNNT1", "TNNT3", "TTN", "MYL2", + ]), + XcellSignature::new("Neurons", "other", [ + "TUBB3", "RBFOX3", "MAP2", "SYP", "SNAP25", "STMN2", "ENO2", "GAP43", + ]), + XcellSignature::new("Astrocytes", "other", [ + "GFAP", "ALDH1L1", "S100B", "AQP4", "FGFR3", "TNC", "GLUL", "GJA1", + ]), + XcellSignature::new("Oligodendrocytes", "other", [ + "MBP", "PLP1", "MAG", "MOG", "SOX10", "OLIG1", "OLIG2", "CNP", + ]), + XcellSignature::new("Podocytes", "other", [ + "NPHS1", "NPHS2", "PODXL", "SYNPO", "WT1", "ACTN4", "CD2AP", "TPM3", + ]), + XcellSignature::new("Megakaryocytes", "other", [ + "PPBP", "PF4", "ITGA2B", "GP9", "VWF", "NFE2", "MEIS1", "GATA1", + ]), + XcellSignature::new("Erythrocytes", "other", [ + "HBB", "HBA1", "HBA2", "GATA1", "KLF1", "EPOR", "AHSP", "SLC4A1", + ]), ] } @@ -459,8 +534,12 @@ pub fn xcell_score( let mut max_v = -1000000.0 for s in 0.. max_v { max_v = v } + if v < min_v { + min_v = v + } + if v > max_v { + max_v = v + } } let range = max_v - min_v if xc_abs(range) > 0.0000000001 { @@ -506,14 +585,8 @@ pub fn xcell_score( } XcellResult::new( - scores, - cell_types, - categories, - sample_names, - immune_scores, - stromal_scores, - microenv_scores, - params, + scores, cell_types, categories, sample_names, immune_scores, stromal_scores, + microenv_scores, params, ) } @@ -546,7 +619,9 @@ pub fn XcellResult::get_cell_type_scores( break } } - if idx < 0 { return [] } + if idx < 0 { + return [] + } self.scores[idx].copy() } @@ -563,7 +638,9 @@ pub fn XcellResult::get_sample_scores( break } } - if idx < 0 { return [] } + if idx < 0 { + return [] + } let result : Array[Double] = [] for t in 0.. Array[(String, Double)] { let s_scores = self.get_sample_scores(sample) let n = s_scores.length() - if n == 0 { return [] } + if n == 0 { + return [] + } // Sort indices by score descending let indices : Array[Int] = Array::make(n, 0) - for i in 0.. [mean per sample] -pub fn XcellResult::scores_by_category(self : XcellResult) -> Map[String, Array[Double]] { +pub fn XcellResult::scores_by_category( + self : XcellResult, +) -> Map[String, Array[Double]] { let n_samples = self.sample_names.length() let category_sum : Map[String, Array[Double]] = Map([], capacity=0) let category_count : Map[String, Int] = Map([], capacity=0) @@ -617,12 +700,14 @@ pub fn XcellResult::scores_by_category(self : XcellResult) -> Map[String, Array[ let existing = category_sum.get(cat) let arr : Array[Double] = [] match existing { - Some(a) => { - for x in a { arr.push(x) } - } - None => { - for _s in 0.. + for x in a { + arr.push(x) + } + None => + for _s in 0.. Map[String, Array[ Some(a) => a None => { let emp : Array[Double] = [] - for _i in 0.. Array[Int] { let code = xdna_base_to_code(sequence.unsafe_get(i).unsafe_to_char()) let safe_code = if code < 0 { 0 } else { code } let byte_idx = i / 4 - let shift = 6 - (i % 4) * 2 + let shift = 6 - i % 4 * 2 packed[byte_idx] = packed[byte_idx] | (safe_code << shift) } packed @@ -260,7 +260,7 @@ pub fn xdna_unpack_sequence(packed : Array[Int], seq_len : Int) -> String { let sb = StringBuilder::new() for i in 0..> shift) & 3 } else { @@ -363,11 +363,7 @@ pub fn xdna_from_bytes(data : Array[Int]) -> XdnaFile { let n = data.length() let mut offset = 0 // Determine checksum (last 4 bytes) if present. - let stored_checksum = if n >= 4 { - xdna_read_u32_be(data, n - 4) - } else { - 0 - } + let stored_checksum = if n >= 4 { xdna_read_u32_be(data, n - 4) } else { 0 } // Parse records while at least one record header (20 bytes) fits before the // trailing checksum. while offset + 20 <= n - 4 || (offset + 20 <= n && n < 4) { @@ -411,9 +407,13 @@ pub fn xdna_from_bytes(data : Array[Int]) -> XdnaFile { if file.records.length() == 0 { file.version = version } - file.records.push( - XdnaRecord::{ name, sequence, seq_type, annotations, checksum: stored_checksum }, - ) + file.records.push(XdnaRecord::{ + name, + sequence, + seq_type, + annotations, + checksum: stored_checksum, + }) // Stop if we have consumed everything up to the checksum. if offset >= n - 4 && n >= 4 { break diff --git a/test/moonbit/ace_test.mbt b/test/moonbit/ace_test.mbt index e6685eb6..5142f220 100644 --- a/test/moonbit/ace_test.mbt +++ b/test/moonbit/ace_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for ACE contig assembly format parser module. - test "ace_read_new" { let read = @src.AceRead::new( "read1", @@ -24,6 +23,7 @@ test "ace_read_new" { assert_eq(read.dye, "dye1") } +///| test "ace_contig_new" { let read = @src.AceRead::new( "read1", @@ -52,6 +52,7 @@ test "ace_contig_new" { assert_false(contig.reverse_complemented) } +///| test "ace_alignment_new" { let qual : Array[Int] = [30, 30, 30] let ali = @src.AceAlignment::new("contig1", 10, "ATC", qual) @@ -61,6 +62,7 @@ test "ace_alignment_new" { assert_eq(ali.quality.length(), 3) } +///| test "ace_data_new" { let contigs : Array[@src.AceContig] = [] let data = @src.AceData::new(contigs, 0) @@ -69,18 +71,21 @@ test "ace_data_new" { assert_eq(data.base_qual_threshold, 0) } +///| test "ace_parse_empty" { let data = @src.ace_parse("") assert_eq(data.contigs.length(), 0) assert_eq(data.total_contigs, 0) } +///| test "ace_parse_only_header" { let data = @src.ace_parse("AF contig1 100\n") assert_eq(data.contigs.length(), 0) assert_eq(data.total_contigs, 0) } +///| test "ace_parse_single_read" { let content = "AF contig1 10\n" + "RD read1 10 chem1 dye1\n" + @@ -99,6 +104,7 @@ test "ace_parse_single_read" { assert_eq(data.contigs[0].reads[0].read_id, "read1") } +///| test "ace_parse_multiple_reads" { let content = "AF contig1 20\n" + "RD read1 10 chem1 dye1\n" + @@ -117,6 +123,7 @@ test "ace_parse_multiple_reads" { assert_eq(data.contigs[0].reads.length(), 2) } +///| test "ace_parse_multiple_contigs" { let content = "AF contig1 10\n" + "RD read1 10 chem1 dye1\n" + @@ -140,6 +147,7 @@ test "ace_parse_multiple_contigs" { assert_eq(data.total_reads, 2) } +///| test "ace_parse_strands" { let content = "AF contig1 10\n" + "RD read1 10 chem1 dye1\n" + @@ -159,6 +167,7 @@ test "ace_parse_strands" { assert_eq(data.contigs[0].reads[1].strand, "-") } +///| test "ace_parse_quality_scores" { let content = "AF contig1 5\n" + "RD read1 5 chem1 dye1\n" + @@ -177,6 +186,7 @@ test "ace_parse_quality_scores" { assert_eq(data.contigs[0].base_qualities[4], 55) } +///| test "ace_parse_reads_only" { let content = "RD read1 5 chem1 dye1\n" + "ACGTG\n" + @@ -191,6 +201,7 @@ test "ace_parse_reads_only" { assert_eq(reads[1].read_id, "read2") } +///| test "ace_parse_contigs_only" { let content = "RD read1 5 chem1 dye1\n" + "ACGTG\n" + @@ -205,6 +216,7 @@ test "ace_parse_contigs_only" { assert_eq(contigs[0].reads.length(), 1) } +///| test "ace_get_contig" { let content = "AF contig1 10\n" + "RD read1 10 chem1 dye1\n" + @@ -227,6 +239,7 @@ test "ace_get_contig" { } } +///| test "ace_contig_length" { let content = "AF contig1 10\n" + "RD read1 10 chem1 dye1\n" + @@ -241,6 +254,7 @@ test "ace_contig_length" { assert_eq(@src.ace_contig_length(data, "nonexistent"), 0) } +///| test "ace_contig_reads" { let content = "AF contig1 10\n" + "RD read1 10 chem1 dye1\n" + @@ -258,6 +272,7 @@ test "ace_contig_reads" { assert_eq(empty_reads.length(), 0) } +///| test "ace_read_coverage" { let read1 = @src.AceRead::new( "read1", @@ -295,6 +310,7 @@ test "ace_read_coverage" { assert_eq(coverage.get(10), Some(2)) } +///| test "ace_read_coverage_partial" { let read1 = @src.AceRead::new( "read1", @@ -339,6 +355,7 @@ test "ace_read_coverage_partial" { assert_eq(coverage.get(10), Some(0)) } +///| test "ace_consensus_sequence" { let read = @src.AceRead::new( "read1", @@ -362,6 +379,7 @@ test "ace_consensus_sequence" { assert_eq(@src.ace_consensus_sequence(contig), "GCTA") } +///| test "ace_contig_gc_content" { let read = @src.AceRead::new( "read1", @@ -386,6 +404,7 @@ test "ace_contig_gc_content" { assert_eq(gc, 1.0) } +///| test "ace_contig_gc_content_mixed" { let read = @src.AceRead::new( "read1", @@ -410,19 +429,14 @@ test "ace_contig_gc_content_mixed" { assert_eq(gc, 0.5) } +///| test "ace_contig_gc_content_empty" { - let contig = @src.AceContig::new( - "contig1", - "", - [], - [], - "", - false, - ) + let contig = @src.AceContig::new("contig1", "", [], [], "", false) let gc = @src.ace_contig_gc_content(contig) assert_eq(gc, 0.0) } +///| test "ace_to_string_basic" { let read = @src.AceRead::new( "read1", @@ -451,6 +465,7 @@ test "ace_to_string_basic" { assert_true(output.contains("AF read1")) } +///| test "ace_to_string_roundtrip" { let content = "AF contig1 10\n" + "RD read1 10 chem1 dye1\n" + @@ -470,6 +485,7 @@ test "ace_to_string_roundtrip" { assert_eq(data2.contigs[0].reads[0].read_id, "read1") } +///| test "ace_sample_data" { let data = @src.sample_ace_data() assert_eq(data.contigs.length(), 1) @@ -480,6 +496,7 @@ test "ace_sample_data" { assert_eq(data.contigs[0].reads.length(), 2) } +///| test "ace_multiline_sequence" { let mut seq = "" let mut i = 0 @@ -498,11 +515,17 @@ test "ace_multiline_sequence" { } let content = "AF contig1 120\n" + "RD read1 120 chem1 dye1\n" + - seq + "\n" + - "q " + qual_str + "\n" + + seq + + "\n" + + "q " + + qual_str + + "\n" + "CT contig1 120 0 120\n" + - seq + "\n" + - "q " + qual_str + "\n" + + seq + + "\n" + + "q " + + qual_str + + "\n" + "AF read1 1 120 1 120 1 120 +\n" let data = @src.ace_parse(content) assert_eq(data.contigs.length(), 1) @@ -511,6 +534,7 @@ test "ace_multiline_sequence" { assert_eq(data.contigs[0].reads[0].sequence.length(), 120) } +///| test "ace_total_reads_count" { let content = "AF contig1 10\n" + "RD read1 10 chem1 dye1\n" + @@ -532,6 +556,7 @@ test "ace_total_reads_count" { assert_eq(data.total_reads, 2) } +///| test "ace_base_qualities_preserved" { let content = "AF contig1 3\n" + "RD read1 3 chem1 dye1\n" + @@ -548,6 +573,7 @@ test "ace_base_qualities_preserved" { assert_eq(data.contigs[0].base_qualities[2], 70) } +///| test "ace_read_quality_preserved" { let content = "AF contig1 3\n" + "RD read1 3 chem1 dye1\n" + @@ -564,6 +590,7 @@ test "ace_read_quality_preserved" { assert_eq(data.contigs[0].reads[0].quality[2], 30) } +///| test "ace_coverage_empty" { let contig = @src.AceContig::new( "contig1", @@ -580,6 +607,7 @@ test "ace_coverage_empty" { assert_eq(coverage.get(4), Some(0)) } +///| test "ace_contig_reads_strand_info" { let read1 = @src.AceRead::new( "read1", @@ -617,6 +645,7 @@ test "ace_contig_reads_strand_info" { assert_eq(contig.reads[1].dye, "dye2") } +///| test "ace_roundtrip_coverage" { let read1 = @src.AceRead::new( "read1", @@ -645,19 +674,10 @@ test "ace_roundtrip_coverage" { assert_eq(parsed.contigs[0].reads[0].strand, "+") } +///| test "ace_quality_to_string_format" { let qual : Array[Int] = [10, 20, 30] - let read = @src.AceRead::new( - "read1", - "ACG", - qual, - 1, - 3, - "+", - "", - "", - "", - ) + let read = @src.AceRead::new("read1", "ACG", qual, 1, 3, "+", "", "", "") let contig = @src.AceContig::new( "contig1", "ACG", @@ -671,6 +691,7 @@ test "ace_quality_to_string_format" { assert_true(output.contains("10 20 30")) } +///| test "ace_consensus_from_contig" { let read = @src.AceRead::new( "read1", @@ -694,6 +715,7 @@ test "ace_consensus_from_contig" { assert_eq(@src.ace_consensus_sequence(contig), "ACGT") } +///| test "ace_coverage_values" { let read1 = @src.AceRead::new( "read1", @@ -721,27 +743,15 @@ test "ace_coverage_values" { assert_eq(cov.get(4), Some(0)) } +///| test "ace_reverse_complemented_default" { - let contig = @src.AceContig::new( - "contig1", - "ACGT", - [], - [], - "", - false, - ) + let contig = @src.AceContig::new("contig1", "ACGT", [], [], "", false) assert_false(contig.reverse_complemented) } +///| test "ace_data_threshold" { - let contig = @src.AceContig::new( - "contig1", - "ACGT", - [], - [], - "", - false, - ) + let contig = @src.AceContig::new("contig1", "ACGT", [], [], "", false) let data = @src.AceData::new([contig], 30) assert_eq(data.base_qual_threshold, 30) -} \ No newline at end of file +} diff --git a/test/moonbit/align_abstract_test.mbt b/test/moonbit/align_abstract_test.mbt index 5d6b6ede..b06b9655 100644 --- a/test/moonbit/align_abstract_test.mbt +++ b/test/moonbit/align_abstract_test.mbt @@ -3,8 +3,8 @@ test "AbstractAlignment::new construction" { let sequences = ["ATCGATCG", "ATCGATCG"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) assert_eq(aln.abstract_n_seqs(), 2) @@ -16,8 +16,8 @@ test "AbstractAlignment::validate success" { let sequences = ["ATCGATCG", "ATCGATCG"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let (valid, msg) = aln.validate() @@ -30,8 +30,8 @@ test "AbstractAlignment::validate different lengths" { let sequences = ["ATCG", "ATCGATCG"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let (valid, _msg) = aln.validate() @@ -43,8 +43,8 @@ test "AbstractAlignment::validate empty alignment" { let sequences : Array[String] = [] let identifiers : Array[String] = [] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let (valid, msg) = aln.validate() @@ -57,8 +57,8 @@ test "AbstractAlignment::validate invalid nucleotide character" { let sequences = ["ATCGNTCG", "ATCGXTCG"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let (valid, _msg) = aln.validate() @@ -70,8 +70,8 @@ test "AbstractAlignment::validate protein" { let sequences = ["ALIGMENT", "ALIGMENT"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("protein"), ) let (valid, _msg) = aln.validate() @@ -83,8 +83,8 @@ test "AbstractAlignment::validate protein invalid char" { let sequences = ["ALIGMENT", "ALIGM1NT"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("protein"), ) let (valid, _msg) = aln.validate() @@ -96,14 +96,14 @@ test "abstract_column_stats identical columns" { let sequences = ["AAAA", "AAAA"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let stats = @src.abstract_column_stats(aln, 0) let diff_cons = (stats.conservation - 1.0).abs() assert_true(diff_cons < 1.0e-10) - let gap_val = (stats.gap_fraction).abs() + let gap_val = stats.gap_fraction.abs() assert_true(gap_val < 1.0e-10) assert_eq(stats.n_unique_chars, 1) } @@ -113,8 +113,8 @@ test "abstract_column_stats with gaps" { let sequences = ["A-CG", "AC-G"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let stats = @src.abstract_column_stats(aln, 1) @@ -126,8 +126,8 @@ test "abstract_column_stats diversity" { let sequences = ["ACGT", "TGCA"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let stats = @src.abstract_column_stats(aln, 0) @@ -139,12 +139,12 @@ test "abstract_column_stats out of bounds" { let sequences = ["ACGT", "TGCA"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let stats = @src.abstract_column_stats(aln, 100) - let cons_val = (stats.conservation).abs() + let cons_val = stats.conservation.abs() assert_true(cons_val < 1.0e-10) assert_eq(stats.n_unique_chars, 0) } @@ -154,8 +154,8 @@ test "abstract_identity_matrix identical sequences" { let sequences = ["ATCGATCG", "ATCGATCG"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let matrix = @src.abstract_identity_matrix(aln) @@ -174,12 +174,12 @@ test "abstract_identity_matrix different sequences" { let sequences = ["AAAA", "TTTT"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let matrix = @src.abstract_identity_matrix(aln) - assert_true((matrix[0][1]).abs() < 1.0e-10) + assert_true(matrix[0][1].abs() < 1.0e-10) } ///| @@ -187,8 +187,8 @@ test "abstract_identity_matrix partial match" { let sequences = ["ACGT", "ACGA"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let matrix = @src.abstract_identity_matrix(aln) @@ -200,8 +200,8 @@ test "abstract_overall_identity" { let sequences = ["ACGT", "ACGA", "ACGT"] let identifiers = ["seq1", "seq2", "seq3"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let identity = @src.abstract_overall_identity(aln) @@ -214,8 +214,8 @@ test "abstract_overall_identity single sequence" { let sequences = ["ACGT"] let identifiers = ["seq1"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let identity = @src.abstract_overall_identity(aln) @@ -227,8 +227,8 @@ test "abstract_coverage" { let sequences = ["ACGT", "A-GT"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let coverage = @src.abstract_coverage(aln) @@ -241,8 +241,8 @@ test "abstract_coverage no gaps" { let sequences = ["ACGT", "ACGT"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let coverage = @src.abstract_coverage(aln) @@ -254,8 +254,8 @@ test "AbstractAlignment::abstract_get_column" { let sequences = ["ACGT", "TGCA"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let col = aln.abstract_get_column(0) @@ -267,8 +267,8 @@ test "AbstractAlignment::abstract_get_column out of bounds" { let sequences = ["ACGT"] let identifiers = ["seq1"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let col = aln.abstract_get_column(10) @@ -280,8 +280,8 @@ test "AbstractAlignment::abstract_get_seq" { let sequences = ["ATCGATCG"] let identifiers = ["seq1"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) assert_eq(aln.abstract_get_seq(0), "ATCGATCG") @@ -292,8 +292,8 @@ test "AbstractAlignment::abstract_get_seq out of bounds" { let sequences = ["ATCG"] let identifiers = ["seq1"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) assert_eq(aln.abstract_get_seq(5), "") @@ -304,8 +304,8 @@ test "AbstractAlignment::abstract_get_id" { let sequences = ["ATCG"] let identifiers = ["gene1"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) assert_eq(aln.abstract_get_id(0), "gene1") @@ -316,8 +316,8 @@ test "AbstractAlignment::abstract_type" { let sequences = ["ATCG"] let identifiers = ["seq1"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let t = aln.abstract_type() @@ -329,8 +329,8 @@ test "abstract_variable_sites" { let sequences = ["ACGT", "ACGA"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let num_sites = @src.abstract_variable_sites(aln) @@ -342,8 +342,8 @@ test "abstract_variable_sites none" { let sequences = ["ACGT", "ACGT"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let num_sites = @src.abstract_variable_sites(aln) @@ -355,8 +355,8 @@ test "abstract_parsimony_sites" { let sequences = ["ACGT", "ACGA", "TCGT"] let identifiers = ["seq1", "seq2", "seq3"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let parsimony = @src.abstract_parsimony_sites(aln) @@ -368,8 +368,8 @@ test "abstract_consensus_sequence" { let sequences = ["ACGT", "ACGA", "ACGT"] let identifiers = ["seq1", "seq2", "seq3"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let consensus = @src.abstract_consensus_sequence(aln) @@ -381,12 +381,14 @@ test "abstract_filter_gaps" { let sequences = ["A-CGT", "A-CGA"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let filtered = @src.abstract_filter_gaps(aln, 0.5) - assert_true(filtered.abstract_alignment_length() <= aln.abstract_alignment_length()) + assert_true( + filtered.abstract_alignment_length() <= aln.abstract_alignment_length(), + ) } ///| @@ -394,8 +396,8 @@ test "abstract_trim" { let sequences = ["ACGTACGT", "ACGTACGT"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let trimmed = @src.abstract_trim(aln, 2, 5) @@ -408,14 +410,14 @@ test "abstract_distance_matrix" { let sequences = ["ACGT", "ACGA"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let matrix = @src.abstract_distance_matrix(aln) assert_eq(matrix.length(), 2) - assert_true((matrix[0][0]).abs() < 1.0e-10) - assert_true((matrix[1][1]).abs() < 1.0e-10) + assert_true(matrix[0][0].abs() < 1.0e-10) + assert_true(matrix[1][1].abs() < 1.0e-10) } ///| @@ -441,8 +443,8 @@ test "AbstractAlignment::multiple sequences" { let sequences = ["AAAA", "CCCC", "GGGG", "TTTT"] let identifiers = ["s1", "s2", "s3", "s4"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) assert_eq(aln.abstract_n_seqs(), 4) @@ -454,8 +456,8 @@ test "abstract_singleton_sites" { let sequences = ["ACGT", "ACGT", "ACGA"] let identifiers = ["seq1", "seq2", "seq3"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let singleton = @src.abstract_singleton_sites(aln) @@ -467,8 +469,8 @@ test "abstract_summary" { let sequences = ["ACGT", "ACGT"] let identifiers = ["seq1", "seq2"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let summary = @src.abstract_summary(aln) @@ -481,8 +483,8 @@ test "AbstractAlignment::single sequence identity" { let sequences = ["ACGT"] let identifiers = ["seq1"] let aln = @src.AbstractAlignment::new( - sequences=sequences, - identifiers=identifiers, + sequences~, + identifiers~, alignment_type=@src.align_abstract_type_from_str("nucleotide"), ) let matrix = @src.abstract_identity_matrix(aln) diff --git a/test/moonbit/align_analysis_test.mbt b/test/moonbit/align_analysis_test.mbt index ed4c98fd..a50bffcd 100644 --- a/test/moonbit/align_analysis_test.mbt +++ b/test/moonbit/align_analysis_test.mbt @@ -1,5 +1,6 @@ // Tests for Bio.Align.analysis module +///| test "AlnAnalysisResult creation" { let result = @src.AlnAnalysisResult::new(0.1, 0.05, 2.0, 0.1, 10, 5) assert_true(result.aln_get_dn() == 0.1) @@ -10,18 +11,21 @@ test "AlnAnalysisResult creation" { assert_true(result.aln_get_n_nonsyn() == 5) } +///| test "positive selection detection" { let result = @src.AlnAnalysisResult::new(0.1, 0.05, 2.0, 0.1, 10, 5) assert_true(result.aln_has_positive_selection()) assert_false(result.aln_has_purifying_selection()) } +///| test "purifying selection detection" { let result = @src.AlnAnalysisResult::new(0.05, 0.1, 0.5, 0.1, 5, 10) assert_false(result.aln_has_positive_selection()) assert_true(result.aln_has_purifying_selection()) } +///| test "aln_aa_from_codon" { assert_true(@src.aln_aa_from_codon("ATG") == "M") assert_true(@src.aln_aa_from_codon("AAA") == "K") @@ -29,12 +33,14 @@ test "aln_aa_from_codon" { assert_true(@src.aln_aa_from_codon("TAA") == "*") } +///| test "aln_is_synonymous" { assert_true(@src.aln_is_synonymous("AAA", 2, "G")) // AAG also codes for K assert_false(@src.aln_is_synonymous("AAA", 1, "T")) // ATA codes for I assert_true(@src.aln_is_synonymous("TTT", 2, "C")) // TTC also codes for F } +///| test "aln_analyze_dn_ds identical sequences" { let seq1 = "ATGAAACCC" let seq2 = "ATGAAACCC" @@ -43,6 +49,7 @@ test "aln_analyze_dn_ds identical sequences" { assert_true(result.aln_get_ds() == 0.0) } +///| test "aln_analyze_dn_ds different sequences" { let seq1 = "ATGAAACCC" let seq2 = "ATGAAGCCC" @@ -50,36 +57,43 @@ test "aln_analyze_dn_ds different sequences" { assert_true(result.aln_get_ds() > 0.0) } +///| test "aln_jukes_cantor_distance identical" { let dist = @src.aln_jukes_cantor_distance("ACGT", "ACGT") assert_true(dist == 0.0) } +///| test "aln_jukes_cantor_distance different" { let dist = @src.aln_jukes_cantor_distance("ACGT", "TCGT") assert_true(dist > 0.0) } +///| test "aln_kimura_2p_distance identical" { let dist = @src.aln_kimura_2p_distance("ACGT", "ACGT") assert_true(dist == 0.0) } +///| test "aln_kimura_2p_distance transition" { let dist = @src.aln_kimura_2p_distance("ACGT", "TCGT") assert_true(dist > 0.0) } +///| test "aln_p_distance identical" { let dist = @src.aln_p_distance("ACGT", "ACGT") assert_true(dist == 0.0) } +///| test "aln_p_distance" { let dist = @src.aln_p_distance("ACGT", "AATT") assert_true(dist > 0.4 && dist < 0.6) } +///| test "aln_jukes_cantor_matrix" { let sequences = ["ACGT", "TCGT", "ACGA"] let matrix = @src.aln_jukes_cantor_matrix(sequences) @@ -89,6 +103,7 @@ test "aln_jukes_cantor_matrix" { assert_true(matrix[0][1] > 0.0) } +///| test "aln_calculate_dn_ds_matrix" { let sequences = ["ATGAAACCC", "ATGAAGCCC", "ATGAAACCC"] let matrix = @src.aln_calculate_dn_ds_matrix(sequences) diff --git a/test/moonbit/align_applications_test.mbt b/test/moonbit/align_applications_test.mbt index 0cfccdcf..0c860d07 100644 --- a/test/moonbit/align_applications_test.mbt +++ b/test/moonbit/align_applications_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Align.Applications module. - test "ClustalwCommandline creation" { let cmd = @src.create_example_clustalw() let command = cmd.build() @@ -8,6 +7,7 @@ test "ClustalwCommandline creation" { assert_true(command.contains("-infile")) } +///| test "ClustalwCommandline set_matrix" { let mut cmd = @src.ClustalwCommandline::new("clustalw2") cmd = cmd.set_matrix("BLOSUM62") @@ -16,6 +16,7 @@ test "ClustalwCommandline set_matrix" { assert_true(command.contains("BLOSUM62")) } +///| test "ClustalOmegaCommandline creation" { let cmd = @src.create_example_clustalomega() let command = cmd.build() @@ -23,6 +24,7 @@ test "ClustalOmegaCommandline creation" { assert_true(command.contains("-i")) } +///| test "ClustalOmegaCommandline set_iterations" { let mut cmd = @src.ClustalOmegaCommandline::new("clustalo") cmd = cmd.set_iterations(10) @@ -31,15 +33,17 @@ test "ClustalOmegaCommandline set_iterations" { assert_true(command.contains("10")) } +///| test "MuscleCommandline creation" { let cmd = @src.create_example_muscle() let command = cmd.build() assert_true(command.contains("muscle")) } +///| test "MAFFTCommandline creation" { let cmd = @src.create_example_mafft() let command = cmd.build() assert_true(command.contains("mafft")) assert_true(command.contains("--auto")) -} \ No newline at end of file +} diff --git a/test/moonbit/align_bed_test.mbt b/test/moonbit/align_bed_test.mbt index a73403ac..054798bb 100644 --- a/test/moonbit/align_bed_test.mbt +++ b/test/moonbit/align_bed_test.mbt @@ -522,8 +522,7 @@ test "Bio.Align.bed writes canonical BED12 plus record" { AlignBedError(message) => abort("valid BED writing failed: " + message) } assert_eq( - line, - "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\t2\t567,488,\t0,3512,\n", + line, "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\t2\t567,488,\t0,3512,\n", ) } @@ -533,8 +532,7 @@ test "Bio.Align.bed writes canonical BED12 minus record" { AlignBedError(message) => abort("valid BED writing failed: " + message) } assert_eq( - line, - "chr22\t2000\t6000\tmRNA2\t900\t-\t2300\t5960\t0,255,0\t2\t433,399,\t0,3601,\n", + line, "chr22\t2000\t6000\tmRNA2\t900\t-\t2300\t5960\t0,255,0\t2\t433,399,\t0,3601,\n", ) } @@ -591,10 +589,7 @@ test "Bio.Align.bed writes BED9" { let line = @src.align_bed_format(align_bed_test_plus(), bed_columns=9) catch { AlignBedError(message) => abort("valid BED9 writing failed: " + message) } - assert_eq( - line, - "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\n", - ) + assert_eq(line, "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\n") } ///| @@ -602,10 +597,7 @@ test "Bio.Align.bed writes BED10" { let line = @src.align_bed_format(align_bed_test_plus(), bed_columns=10) catch { AlignBedError(message) => abort("valid BED10 writing failed: " + message) } - assert_eq( - line, - "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\t2\n", - ) + assert_eq(line, "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\t2\n") } ///| @@ -614,8 +606,7 @@ test "Bio.Align.bed writes BED11" { AlignBedError(message) => abort("valid BED11 writing failed: " + message) } assert_eq( - line, - "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\t2\t567,488,\n", + line, "chr22\t1000\t5000\tmRNA1\t960\t+\t1200\t4900\t255,0,0\t2\t567,488,\n", ) } @@ -635,7 +626,8 @@ test "Bio.Align.bed BED12 round trip is stable" { test "Bio.Align.bed writes complete document" { let document = align_bed_test_document() let output = @src.align_bed_write(document, bed_columns=3) catch { - AlignBedError(message) => abort("valid BED document writing failed: " + message) + AlignBedError(message) => + abort("valid BED document writing failed: " + message) } assert_eq(output.split("\n").length(), 4) } @@ -644,17 +636,15 @@ test "Bio.Align.bed writes complete document" { test "Bio.Align.bed textual score writes unchanged" { let alignment = align_bed_test_parse("chr1\t0\t10\ttx\tpass\n").alignments[0] let output = @src.align_bed_format(alignment, bed_columns=5) catch { - AlignBedError(message) => abort("valid BED score writing failed: " + message) + AlignBedError(message) => + abort("valid BED score writing failed: " + message) } assert_eq(output, "chr1\t0\t10\ttx\tpass\n") } ///| test "Bio.Align.bed writer supplies default query name" { - let output = @src.align_bed_format( - align_bed_test_simple(), - bed_columns=4, - ) catch { + let output = @src.align_bed_format(align_bed_test_simple(), bed_columns=4) catch { AlignBedError(message) => abort("valid BED writing failed: " + message) } assert_eq(output, "chr7\t100\t180\tquery\n") @@ -662,10 +652,7 @@ test "Bio.Align.bed writer supplies default query name" { ///| test "Bio.Align.bed writer supplies default score" { - let output = @src.align_bed_format( - align_bed_test_simple(), - bed_columns=5, - ) catch { + let output = @src.align_bed_format(align_bed_test_simple(), bed_columns=5) catch { AlignBedError(message) => abort("valid BED writing failed: " + message) } assert_eq(output, "chr7\t100\t180\tquery\t0\n") @@ -673,10 +660,7 @@ test "Bio.Align.bed writer supplies default score" { ///| test "Bio.Align.bed writer supplies default thick interval and color" { - let output = @src.align_bed_format( - align_bed_test_simple(), - bed_columns=9, - ) catch { + let output = @src.align_bed_format(align_bed_test_simple(), bed_columns=9) catch { AlignBedError(message) => abort("valid BED writing failed: " + message) } assert_eq(output, "chr7\t100\t180\tquery\t0\t+\t100\t180\t0\n") @@ -705,34 +689,28 @@ test "Bio.Align.bed reads BED6 reverse strand" { ///| test "Bio.Align.bed reads BED7" { - let alignment = align_bed_test_parse( - "chr1\t10\t20\ttx\t7\t+\t12\n", - ).alignments[0] + let alignment = align_bed_test_parse("chr1\t10\t20\ttx\t7\t+\t12\n").alignments[0] assert_eq(alignment.thick_start, Some(12)) assert_eq(alignment.thick_end, None) } ///| test "Bio.Align.bed reads BED8" { - let alignment = align_bed_test_parse( - "chr1\t10\t20\ttx\t7\t+\t12\t18\n", - ).alignments[0] + let alignment = align_bed_test_parse("chr1\t10\t20\ttx\t7\t+\t12\t18\n").alignments[0] assert_eq(alignment.thick_end, Some(18)) } ///| test "Bio.Align.bed reads BED9" { let alignment = align_bed_test_parse( - "chr1\t10\t20\ttx\t7\t+\t12\t18\t10,20,30\n", - ).alignments[0] + "chr1\t10\t20\ttx\t7\t+\t12\t18\t10,20,30\n", + ).alignments[0] assert_eq(alignment.item_rgb, Some("10,20,30")) } ///| test "Bio.Align.bed reads lossless single-block BED10" { - let alignment = align_bed_test_parse( - "chr1\t10\t20\ttx\t7\t+\t12\t18\t0\t1\n", - ).alignments[0] + let alignment = align_bed_test_parse("chr1\t10\t20\ttx\t7\t+\t12\t18\t0\t1\n").alignments[0] assert_eq(alignment.blocks().length(), 1) assert_eq(alignment.source_columns, 10) } @@ -740,8 +718,8 @@ test "Bio.Align.bed reads lossless single-block BED10" { ///| test "Bio.Align.bed reads inferable contiguous BED11" { let alignment = align_bed_test_parse( - "chr1\t10\t20\ttx\t7\t+\t12\t18\t0\t2\t4,6,\n", - ).alignments[0] + "chr1\t10\t20\ttx\t7\t+\t12\t18\t0\t2\t4,6,\n", + ).alignments[0] assert_eq(alignment.blocks().length(), 2) assert_eq(alignment.blocks()[1].target_start, 14) } @@ -749,8 +727,8 @@ test "Bio.Align.bed reads inferable contiguous BED11" { ///| test "Bio.Align.bed accepts BED12 lists without trailing commas" { let alignment = align_bed_test_parse( - "chr1\t10\t20\ttx\t7\t+\t12\t18\t0\t2\t4,3\t0,7\n", - ).alignments[0] + "chr1\t10\t20\ttx\t7\t+\t12\t18\t0\t2\t4,3\t0,7\n", + ).alignments[0] assert_eq(alignment.query_size(), 7) } @@ -815,141 +793,107 @@ test "Bio.Align.bed rejects thickStart before interval" { ///| test "Bio.Align.bed rejects thickEnd after interval" { - assert_true( - align_bed_test_rejects("chr1\t10\t20\ttx\t0\t+\t10\t21\n"), - ) + assert_true(align_bed_test_rejects("chr1\t10\t20\ttx\t0\t+\t10\t21\n")) } ///| test "Bio.Align.bed rejects reversed thick interval" { - assert_true( - align_bed_test_rejects("chr1\t10\t20\ttx\t0\t+\t18\t12\n"), - ) + assert_true(align_bed_test_rejects("chr1\t10\t20\ttx\t0\t+\t18\t12\n")) } ///| test "Bio.Align.bed rejects multi-block BED10" { - assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\n", - ), - ) + assert_true(align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\n")) } ///| test "Bio.Align.bed rejects BED11 block count mismatch" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t20,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t20,\n"), ) } ///| test "Bio.Align.bed rejects ambiguous gapped BED11" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\n"), ) } ///| test "Bio.Align.bed rejects zero block count" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t0\t\t\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t0\t\t\n"), ) } ///| test "Bio.Align.bed rejects blockSizes count mismatch" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,\t0,15,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,\t0,15,\n"), ) } ///| test "Bio.Align.bed rejects blockStarts count mismatch" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\t0,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\t0,\n"), ) } ///| test "Bio.Align.bed rejects empty block list item" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,,5,\t0,15,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,,5,\t0,15,\n"), ) } ///| test "Bio.Align.bed rejects noninteger block size" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,x,\t0,15,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,x,\t0,15,\n"), ) } ///| test "Bio.Align.bed rejects zero block size" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t0,5,\t0,15,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t0,5,\t0,15,\n"), ) } ///| test "Bio.Align.bed rejects first block after chromStart" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\t1,15,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\t1,15,\n"), ) } ///| test "Bio.Align.bed rejects overlapping blocks" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t10,10,\t0,5,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t10,10,\t0,5,\n"), ) } ///| test "Bio.Align.bed rejects unsorted blocks" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\t0,0,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,5,\t0,0,\n"), ) } ///| test "Bio.Align.bed rejects block beyond chromEnd" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,10,\t0,15,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,10,\t0,15,\n"), ) } ///| test "Bio.Align.bed rejects final block before chromEnd" { assert_true( - align_bed_test_rejects( - "chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,4,\t0,15,\n", - ), + align_bed_test_rejects("chr1\t0\t20\ttx\t0\t+\t0\t20\t0\t2\t5,4,\t0,15,\n"), ) } @@ -1086,11 +1030,10 @@ test "Bio.Align.bed constructor rejects empty target identifier" { assert_true( try { ignore( - @src.AlignBedAlignment::create( - "", - Some("query"), - [align_bed_test_coordinate(0, 0), align_bed_test_coordinate(5, 5)], - ), + @src.AlignBedAlignment::create("", Some("query"), [ + align_bed_test_coordinate(0, 0), + align_bed_test_coordinate(5, 5), + ]), ) false } catch { @@ -1101,11 +1044,10 @@ test "Bio.Align.bed constructor rejects empty target identifier" { ///| test "Bio.Align.bed constructor allows absent query identifier" { - let alignment = @src.AlignBedAlignment::create( - "target", - None, - [align_bed_test_coordinate(0, 0), align_bed_test_coordinate(5, 5)], - ) catch { + let alignment = @src.AlignBedAlignment::create("target", None, [ + align_bed_test_coordinate(0, 0), + align_bed_test_coordinate(5, 5), + ]) catch { AlignBedError(message) => abort("valid BED alignment failed: " + message) } assert_eq(alignment.query_id, None) @@ -1260,8 +1202,7 @@ test "Bio.Align.bed writes Biopython strand fixture" { AlignBedError(message) => abort("valid BED writing failed: " + message) } assert_eq( - output, - "target\t2\t12\tquery\t8\t-\t2\t12\t0\t4\t1,2,3,2,\t0,2,4,8,\n", + output, "target\t2\t12\tquery\t8\t-\t2\t12\t0\t4\t1,2,3,2,\t0,2,4,8,\n", ) } diff --git a/test/moonbit/align_cluster_test.mbt b/test/moonbit/align_cluster_test.mbt index 9e7040a1..0a895bb3 100644 --- a/test/moonbit/align_cluster_test.mbt +++ b/test/moonbit/align_cluster_test.mbt @@ -158,4 +158,4 @@ test "guide_tree_leaf_count" { } } assert_eq(leaf_count, 4) -} \ No newline at end of file +} diff --git a/test/moonbit/alignace_test.mbt b/test/moonbit/alignace_test.mbt index 6e6fb34f..d6d2408b 100644 --- a/test/moonbit/alignace_test.mbt +++ b/test/moonbit/alignace_test.mbt @@ -43,14 +43,12 @@ test "alignace_site_new_negative_strand" { ///| test "alignace_motif_new_basic" { - let m = @src.AlignAceMotif::new( - [ - [8, 0, 0, 0], - [0, 8, 0, 0], - [0, 0, 8, 0], - [0, 0, 0, 8], - ], - ) + let m = @src.AlignAceMotif::new([ + [8, 0, 0, 0], + [0, 8, 0, 0], + [0, 0, 8, 0], + [0, 0, 0, 8], + ]) assert_eq(m.width, 4) // Total sites = sum of column 0 = 8 + 0 + 0 + 0 = 8 assert_eq(m.num_sites, 8) @@ -61,14 +59,12 @@ test "alignace_motif_new_basic" { ///| test "alignace_motif_new_consensus_tgac" { // Motif where T is most common at each position - let m = @src.AlignAceMotif::new( - [ - [1, 0, 0, 0], - [0, 1, 0, 0], - [0, 0, 1, 0], - [9, 9, 9, 9], - ], - ) + let m = @src.AlignAceMotif::new([ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, 0], + [9, 9, 9, 9], + ]) assert_eq(m.width, 4) assert_eq(m.num_sites, 1 + 0 + 0 + 9) assert_eq(m.consensus, "TTTT") @@ -77,14 +73,7 @@ test "alignace_motif_new_consensus_tgac" { ///| test "alignace_motif_consensus_ties_default_to_a" { // When counts are tied, A (first row) wins by default - let m = @src.AlignAceMotif::new( - [ - [5, 0, 5], - [5, 0, 0], - [0, 5, 0], - [0, 5, 0], - ], - ) + let m = @src.AlignAceMotif::new([[5, 0, 5], [5, 0, 0], [0, 5, 0], [0, 5, 0]]) // Position 0: A=5, C=5 -> A wins (first checked) // Position 1: G=5, T=5 -> G wins (checked before T) // Position 2: A=5 -> A @@ -93,14 +82,12 @@ test "alignace_motif_consensus_ties_default_to_a" { ///| test "alignace_motif_motif_consensus" { - let m = @src.AlignAceMotif::new( - [ - [8, 0, 0, 0], - [0, 8, 0, 0], - [0, 0, 8, 0], - [0, 0, 0, 8], - ], - ) + let m = @src.AlignAceMotif::new([ + [8, 0, 0, 0], + [0, 8, 0, 0], + [0, 0, 8, 0], + [0, 0, 0, 8], + ]) assert_eq(@src.alignace_motif_consensus(m), "ACGT") } @@ -110,14 +97,7 @@ test "alignace_motif_motif_consensus" { ///| test "alignace_to_pwm_uniform_distribution" { - let m = @src.AlignAceMotif::new( - [ - [2, 2], - [2, 2], - [2, 2], - [2, 2], - ], - ) + let m = @src.AlignAceMotif::new([[2, 2], [2, 2], [2, 2], [2, 2]]) let pwm = @src.alignace_to_pwm(m) assert_eq(pwm.length(), 4) assert_eq(pwm[0].length(), 2) @@ -132,14 +112,7 @@ test "alignace_to_pwm_uniform_distribution" { ///| test "alignace_to_pwm_pure_motif" { // Motif where only one base appears at each position - let m = @src.AlignAceMotif::new( - [ - [10, 0], - [0, 0], - [0, 10], - [0, 0], - ], - ) + let m = @src.AlignAceMotif::new([[10, 0], [0, 0], [0, 10], [0, 0]]) let pwm = @src.alignace_to_pwm(m) // Column 0: A=1.0, C=0.0, G=0.0, T=0.0 assert_true(pwm[0][0] > 0.99) @@ -154,14 +127,7 @@ test "alignace_to_pwm_pure_motif" { ///| test "alignace_to_pwm_zero_column_uses_default" { // Column with all zeros should default to 0.25 - let m = @src.AlignAceMotif::new( - [ - [0, 5], - [0, 0], - [0, 0], - [0, 0], - ], - ) + let m = @src.AlignAceMotif::new([[0, 5], [0, 0], [0, 0], [0, 0]]) let pwm = @src.alignace_to_pwm(m) // Column 0: all zeros, should be 0.25 each assert_true(pwm[0][0] > 0.24 && pwm[0][0] < 0.26) @@ -177,14 +143,7 @@ test "alignace_to_pwm_zero_column_uses_default" { ///| test "alignace_information_content_uniform_is_zero" { // Uniform distribution has 0 information content - let m = @src.AlignAceMotif::new( - [ - [2, 2], - [2, 2], - [2, 2], - [2, 2], - ], - ) + let m = @src.AlignAceMotif::new([[2, 2], [2, 2], [2, 2], [2, 2]]) let ic = @src.alignace_information_content(m) assert_eq(ic.length(), 2) // IC should be approximately 0 for uniform distribution @@ -195,14 +154,7 @@ test "alignace_information_content_uniform_is_zero" { ///| test "alignace_information_content_pure_is_two_bits" { // Pure motif (only one base) has IC = 2 bits - let m = @src.AlignAceMotif::new( - [ - [10, 0], - [0, 0], - [0, 10], - [0, 0], - ], - ) + let m = @src.AlignAceMotif::new([[10, 0], [0, 0], [0, 10], [0, 0]]) let ic = @src.alignace_information_content(m) // Column 0: only A, IC should be ~2 bits assert_true(ic[0] > 1.9) @@ -212,14 +164,7 @@ test "alignace_information_content_pure_is_two_bits" { ///| test "alignace_total_ic_uniform_is_zero" { - let m = @src.AlignAceMotif::new( - [ - [2, 2, 2], - [2, 2, 2], - [2, 2, 2], - [2, 2, 2], - ], - ) + let m = @src.AlignAceMotif::new([[2, 2, 2], [2, 2, 2], [2, 2, 2], [2, 2, 2]]) let total = @src.alignace_total_ic(m) assert_true(total < 0.01) assert_true(total > -0.01) @@ -227,14 +172,12 @@ test "alignace_total_ic_uniform_is_zero" { ///| test "alignace_total_ic_pure_is_width_times_two" { - let m = @src.AlignAceMotif::new( - [ - [10, 10, 10], - [0, 0, 0], - [0, 0, 0], - [0, 0, 0], - ], - ) + let m = @src.AlignAceMotif::new([ + [10, 10, 10], + [0, 0, 0], + [0, 0, 0], + [0, 0, 0], + ]) let total = @src.alignace_total_ic(m) // 3 columns × 2 bits = 6 bits assert_true(total > 5.9) @@ -493,14 +436,12 @@ test "alignace_summary_empty_record" { ///| test "alignace_motif_width_matches_matrix" { - let m = @src.AlignAceMotif::new( - [ - [1, 2, 3, 4, 5], - [0, 0, 0, 0, 0], - [0, 0, 0, 0, 0], - [0, 0, 0, 0, 0], - ], - ) + let m = @src.AlignAceMotif::new([ + [1, 2, 3, 4, 5], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ]) assert_eq(m.width, 5) assert_eq(m.consensus, "AAAAA") } @@ -515,28 +456,19 @@ test "alignace_motif_empty_matrix" { ///| test "alignace_information_content_length_matches_width" { - let m = @src.AlignAceMotif::new( - [ - [5, 5, 5, 5, 5], - [0, 0, 0, 0, 0], - [0, 0, 0, 0, 0], - [5, 5, 5, 5, 5], - ], - ) + let m = @src.AlignAceMotif::new([ + [5, 5, 5, 5, 5], + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + [5, 5, 5, 5, 5], + ]) let ic = @src.alignace_information_content(m) assert_eq(ic.length(), 5) } ///| test "alignace_to_pwm_dimensions" { - let m = @src.AlignAceMotif::new( - [ - [1, 2, 3], - [0, 0, 0], - [0, 0, 0], - [0, 0, 0], - ], - ) + let m = @src.AlignAceMotif::new([[1, 2, 3], [0, 0, 0], [0, 0, 0], [0, 0, 0]]) let pwm = @src.alignace_to_pwm(m) // PWM should have 4 rows (one per base) and width columns assert_eq(pwm.length(), 4) diff --git a/test/moonbit/alphabet_test.mbt b/test/moonbit/alphabet_test.mbt index f7ad6e5b..504b0bfd 100644 --- a/test/moonbit/alphabet_test.mbt +++ b/test/moonbit/alphabet_test.mbt @@ -1,5 +1,6 @@ // Tests for Bio.Alphabet module +///| test "IUPAC unambiguous DNA alphabet" { let dna = @src.iupac_unambiguous_dna() assert_true(dna.name == "IUPACUnambiguousDNA") @@ -13,6 +14,7 @@ test "IUPAC unambiguous DNA alphabet" { assert_false(dna.is_valid("X")) } +///| test "IUPAC unambiguous RNA alphabet" { let rna = @src.iupac_unambiguous_rna() assert_true(rna.name == "IUPACUnambiguousRNA") @@ -25,6 +27,7 @@ test "IUPAC unambiguous RNA alphabet" { assert_false(rna.is_valid("T")) } +///| test "IUPAC ambiguous DNA alphabet" { let dna = @src.iupac_ambiguous_dna() assert_true(dna.name == "IUPACAmbiguousDNA") @@ -34,6 +37,7 @@ test "IUPAC ambiguous DNA alphabet" { assert_true(dna.is_valid("N")) } +///| test "IUPAC protein alphabet" { let protein = @src.iupac_protein() assert_true(protein.name == "IUPACProtein") @@ -43,6 +47,7 @@ test "IUPAC protein alphabet" { assert_true(protein.is_valid("X")) } +///| test "Gapped DNA alphabet" { let dna = @src.gapped_dna() assert_true(dna.is_gapped) @@ -50,6 +55,7 @@ test "Gapped DNA alphabet" { assert_true(dna.is_valid("A")) } +///| test "Reduced protein alphabet" { let protein = @src.reduced_protein() assert_true(protein.letters.length() == 20) @@ -57,6 +63,7 @@ test "Reduced protein alphabet" { assert_false(protein.is_valid("X")) } +///| test "Three to one letter code" { let mapping = @src.three_to_one() let ala = mapping.get("Ala") @@ -67,6 +74,7 @@ test "Three to one letter code" { assert_true(ter is Some("*")) } +///| test "One to three letter code" { let mapping = @src.one_to_three() let a = mapping.get("A") diff --git a/test/moonbit/ancombc_test.mbt b/test/moonbit/ancombc_test.mbt index 26a1d00f..50267adb 100644 --- a/test/moonbit/ancombc_test.mbt +++ b/test/moonbit/ancombc_test.mbt @@ -356,8 +356,16 @@ test "ancombc_sample_data_counts_positive" { test "ancombc_sample_data_differential_pattern" { let data = @src.ancombc_sample_data() // Feature 0 (Bacteroides): control ~120, treatment ~250 - let ctrl_mean = (data.get_count(0, 0) + data.get_count(0, 1) + data.get_count(0, 2) + data.get_count(0, 3)).to_double() / 4.0 - let trt_mean = (data.get_count(0, 4) + data.get_count(0, 5) + data.get_count(0, 6) + data.get_count(0, 7)).to_double() / 4.0 + let ctrl_mean = (data.get_count(0, 0) + + data.get_count(0, 1) + + data.get_count(0, 2) + + data.get_count(0, 3)).to_double() / + 4.0 + let trt_mean = (data.get_count(0, 4) + + data.get_count(0, 5) + + data.get_count(0, 6) + + data.get_count(0, 7)).to_double() / + 4.0 assert_true(trt_mean > ctrl_mean) } diff --git a/test/moonbit/apeglm_test.mbt b/test/moonbit/apeglm_test.mbt index e9bb2a90..6921a113 100644 --- a/test/moonbit/apeglm_test.mbt +++ b/test/moonbit/apeglm_test.mbt @@ -18,18 +18,14 @@ fn apeglm_test_close( ///| fn apeglm_test_config() -> @src.ApeglmConfig { - @src.ApeglmConfig::create( - coefficient=2, - threshold=@math.ln(2.0), - ) catch { + @src.ApeglmConfig::create(coefficient=2, threshold=@math.ln(2.0)) catch { _ => abort("test configuration should be valid") } } ///| fn apeglm_test_result() -> @src.ApeglmResult { - let (counts, design, dispersions, genes, coefficients) = - @src.apeglm_example_data() + let (counts, design, dispersions, genes, coefficients) = @src.apeglm_example_data() let config = apeglm_test_config() @src.apeglm_fit( counts, @@ -55,10 +51,7 @@ fn apeglm_test_gene( } ///| -fn apeglm_test_zero_matrix( - rows : Int, - columns : Int, -) -> Array[Array[Double]] { +fn apeglm_test_zero_matrix(rows : Int, columns : Int) -> Array[Array[Double]] { let matrix : Array[Array[Double]] = [] for _ in 0.. abort("default coefficient fit should succeed") @@ -379,8 +366,7 @@ test "apeglm: local posterior probabilities are bounded" { assert_true(gene.fsr >= 0.0 && gene.fsr <= 0.5) assert_true(gene.s_value >= 0.0 && gene.s_value <= 0.5) assert_true( - gene.threshold_probability >= 0.0 && - gene.threshold_probability <= 1.0, + gene.threshold_probability >= 0.0 && gene.threshold_probability <= 1.0, ) } } @@ -420,10 +406,9 @@ test "apeglm: s-values support empty and tied inputs" { ///| test "apeglm: empirical Bayes prior variance is positive" { - let variance = @src.apeglm_prior_variance( - [1.5, -1.2, 0.1, 0.0], - [0.2, 0.3, 0.5, 0.6], - ) catch { + let variance = @src.apeglm_prior_variance([1.5, -1.2, 0.1, 0.0], [ + 0.2, 0.3, 0.5, 0.6, + ]) catch { _ => abort("prior variance estimation should succeed") } assert_true(variance >= 1.0e-6) @@ -432,16 +417,10 @@ test "apeglm: empirical Bayes prior variance is positive" { ///| test "apeglm: empirical prior variance responds to effect spread" { - let narrow = @src.apeglm_prior_variance( - [0.1, -0.1, 0.0], - [0.5, 0.5, 0.5], - ) catch { + let narrow = @src.apeglm_prior_variance([0.1, -0.1, 0.0], [0.5, 0.5, 0.5]) catch { _ => abort("narrow prior estimate should succeed") } - let broad = @src.apeglm_prior_variance( - [3.0, -3.0, 2.5], - [0.5, 0.5, 0.5], - ) catch { + let broad = @src.apeglm_prior_variance([3.0, -3.0, 2.5], [0.5, 0.5, 0.5]) catch { _ => abort("broad prior estimate should succeed") } assert_true(broad > narrow) @@ -496,8 +475,7 @@ test "apeglm: adaptive fit reports learned prior" { ///| test "apeglm: fixed prior preserves configured scale" { - let (counts, design, dispersions, genes, coefficients) = - @src.apeglm_example_data() + let (counts, design, dispersions, genes, coefficients) = @src.apeglm_example_data() let config = @src.ApeglmConfig::create( coefficient=2, prior_scale=0.4, @@ -523,10 +501,7 @@ test "apeglm: fixed prior preserves configured scale" { ///| test "apeglm: adaptive multiplier obeys scale cap" { let (counts, design, dispersions, _, _) = @src.apeglm_example_data() - let config = @src.ApeglmConfig::create( - coefficient=2, - multiplier=100.0, - ) catch { + let config = @src.ApeglmConfig::create(coefficient=2, multiplier=100.0) catch { _ => abort("multiplier configuration should succeed") } let result = @src.apeglm_fit(counts, design, dispersions, config~) catch { @@ -605,27 +580,13 @@ test "apeglm: likelihood offsets shift the linear predictor" { ///| test "apeglm: likelihood rejects incompatible dimensions" { let rows = try { - ignore( - @src.apeglm_log_likelihood_nb( - [1.0, 2.0], - [[1.0]], - [0.0], - 0.1, - ), - ) + ignore(@src.apeglm_log_likelihood_nb([1.0, 2.0], [[1.0]], [0.0], 0.1)) false } catch { ApeglmError(_) => true } let columns = try { - ignore( - @src.apeglm_log_likelihood_nb( - [1.0], - [[1.0, 0.0]], - [0.0], - 0.1, - ), - ) + ignore(@src.apeglm_log_likelihood_nb([1.0], [[1.0, 0.0]], [0.0], 0.1)) false } catch { ApeglmError(_) => true @@ -644,13 +605,9 @@ test "apeglm: likelihood rejects invalid dispersion and auxiliaries" { } let offsets = try { ignore( - @src.apeglm_log_likelihood_nb( - [1.0, 2.0], - [[1.0], [1.0]], - [0.0], - 0.1, - offsets=[0.0], - ), + @src.apeglm_log_likelihood_nb([1.0, 2.0], [[1.0], [1.0]], [0.0], 0.1, offsets=[ + 0.0, + ]), ) false } catch { @@ -658,13 +615,9 @@ test "apeglm: likelihood rejects invalid dispersion and auxiliaries" { } let weights = try { ignore( - @src.apeglm_log_likelihood_nb( - [1.0, 2.0], - [[1.0], [1.0]], - [0.0], - 0.1, - weights=[1.0], - ), + @src.apeglm_log_likelihood_nb([1.0, 2.0], [[1.0], [1.0]], [0.0], 0.1, weights=[ + 1.0, + ]), ) false } catch { @@ -677,8 +630,7 @@ test "apeglm: likelihood rejects invalid dispersion and auxiliaries" { ///| test "apeglm: explicit zero offsets match omitted offsets" { - let (counts, design, dispersions, genes, coefficients) = - @src.apeglm_example_data() + let (counts, design, dispersions, genes, coefficients) = @src.apeglm_example_data() let config = apeglm_test_config() let baseline = @src.apeglm_fit( counts, @@ -701,11 +653,7 @@ test "apeglm: explicit zero offsets match omitted offsets" { ) catch { _ => abort("zero offset fit should succeed") } - apeglm_test_close( - baseline.genes[0].map[2], - shifted.genes[0].map[2], - 1.0e-12, - ) + apeglm_test_close(baseline.genes[0].map[2], shifted.genes[0].map[2], 1.0e-12) } ///| @@ -732,8 +680,7 @@ test "apeglm: zero observation weights suppress an outlier" { ///| test "apeglm: custom target coefficient is honored" { - let (counts, design, dispersions, genes, coefficients) = - @src.apeglm_example_data() + let (counts, design, dispersions, genes, coefficients) = @src.apeglm_example_data() let config = @src.ApeglmConfig::create(coefficient=1) catch { _ => abort("batch target configuration should succeed") } @@ -801,8 +748,7 @@ test "apeglm: ranking prioritizes low directional error" { assert_eq(ranked.length(), 8) assert_true(ranked[0].s_value <= ranked[1].s_value) assert_true( - ranked[0].gene_name == "strong_up" || - ranked[0].gene_name == "strong_down", + ranked[0].gene_name == "strong_up" || ranked[0].gene_name == "strong_down", ) } @@ -810,10 +756,7 @@ test "apeglm: ranking prioritizes low directional error" { test "apeglm: selection applies s-value and effect filters" { let result = apeglm_test_result() let broad = result.select(maximum_s_value=0.1) - let strict = result.select( - maximum_s_value=0.1, - minimum_absolute_effect=1.0, - ) + let strict = result.select(maximum_s_value=0.1, minimum_absolute_effect=1.0) assert_true(broad.length() >= strict.length()) for gene in strict { assert_true(gene.s_value <= 0.1) @@ -896,8 +839,7 @@ test "apeglm: repeated fitting is deterministic" { ///| test "apeglm: deterministic start counts preserve signal modes" { - let (counts, design, dispersions, genes, coefficients) = - @src.apeglm_example_data() + let (counts, design, dispersions, genes, coefficients) = @src.apeglm_example_data() let one = @src.ApeglmConfig::create(coefficient=2, random_starts=1) catch { _ => abort("single start configuration should succeed") } @@ -933,10 +875,7 @@ test "apeglm: deterministic start counts preserve signal modes" { ///| test "apeglm: DESeq2 wrapper uses counts names and offsets" { let dds = @src.DESeqDataSet::new( - [ - [48, 52, 45, 54, 198, 220, 205, 230], - [160, 148, 171, 155, 39, 44, 35, 41], - ], + [[48, 52, 45, 54, 198, 220, 205, 230], [160, 148, 171, 155, 39, 44, 35, 41]], ["up", "down"], ["s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8"], [ @@ -951,11 +890,9 @@ test "apeglm: DESeq2 wrapper uses counts names and offsets" { ], ) let config = apeglm_test_config() - let result = @src.apeglm_from_deseq2( - dds, - config~, - coefficient_names=["intercept", "batch", "condition"], - ) catch { + let result = @src.apeglm_from_deseq2(dds, config~, coefficient_names=[ + "intercept", "batch", "condition", + ]) catch { _ => abort("DESeq2 integration should succeed") } assert_eq(result.gene_names, ["up", "down"]) @@ -965,8 +902,7 @@ test "apeglm: DESeq2 wrapper uses counts names and offsets" { ///| test "apeglm: SummarizedExperiment output adds posterior assays" { - let (_, design, dispersions, genes, coefficients) = - @src.apeglm_example_data() + let (_, design, dispersions, genes, coefficients) = @src.apeglm_example_data() let config = apeglm_test_config() let output = @src.apeglm_summarized_experiment( apeglm_test_experiment(), @@ -978,13 +914,10 @@ test "apeglm: SummarizedExperiment output adds posterior assays" { ) catch { _ => abort("SummarizedExperiment integration should succeed") } - for name in [ - "apeglm_map", - "apeglm_sd", - "apeglm_fsr", - "apeglm_svalue", - "apeglm_fsos", - ] { + for + name in [ + "apeglm_map", "apeglm_sd", "apeglm_fsr", "apeglm_svalue", "apeglm_fsos", + ] { match @src.se_assay(output.experiment, name) { Some(assay) => { assert_eq(assay.length(), 8) @@ -997,8 +930,7 @@ test "apeglm: SummarizedExperiment output adds posterior assays" { ///| test "apeglm: SummarizedExperiment integration is immutable" { - let (_, design, dispersions, genes, coefficients) = - @src.apeglm_example_data() + let (_, design, dispersions, genes, coefficients) = @src.apeglm_example_data() let experiment = apeglm_test_experiment() let config = apeglm_test_config() let output = @src.apeglm_summarized_experiment( @@ -1059,24 +991,14 @@ test "apeglm: fit rejects empty and single-sample counts" { test "apeglm: fit rejects ragged and fractional counts" { let ragged = try { ignore( - @src.apeglm_fit( - [[1.0, 2.0], [3.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1, 0.1], - ), + @src.apeglm_fit([[1.0, 2.0], [3.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1, 0.1]), ) false } catch { ApeglmError(_) => true } let fractional = try { - ignore( - @src.apeglm_fit( - [[1.5, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - ), - ) + ignore(@src.apeglm_fit([[1.5, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1])) false } catch { ApeglmError(_) => true @@ -1088,25 +1010,13 @@ test "apeglm: fit rejects ragged and fractional counts" { ///| test "apeglm: fit rejects negative and non-finite counts" { let negative = try { - ignore( - @src.apeglm_fit( - [[-1.0, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - ), - ) + ignore(@src.apeglm_fit([[-1.0, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1])) false } catch { ApeglmError(_) => true } let overflow = try { - ignore( - @src.apeglm_fit( - [[1.0e301, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - ), - ) + ignore(@src.apeglm_fit([[1.0e301, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1])) false } catch { ApeglmError(_) => true @@ -1130,13 +1040,7 @@ test "apeglm: fit rejects malformed design matrices" { ApeglmError(_) => true } let ragged = try { - ignore( - @src.apeglm_fit( - [[1.0, 2.0]], - [[1.0, 0.0], [1.0]], - [0.1], - ), - ) + ignore(@src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0], [1.0]], [0.1])) false } catch { ApeglmError(_) => true @@ -1188,24 +1092,14 @@ test "apeglm: fit rejects intercept and out-of-range targets" { test "apeglm: fit rejects malformed dispersions" { let length = try { ignore( - @src.apeglm_fit( - [[1.0, 2.0], [3.0, 4.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - ), + @src.apeglm_fit([[1.0, 2.0], [3.0, 4.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1]), ) false } catch { ApeglmError(_) => true } let value = try { - ignore( - @src.apeglm_fit( - [[1.0, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.0], - ), - ) + ignore(@src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.0])) false } catch { ApeglmError(_) => true @@ -1218,12 +1112,9 @@ test "apeglm: fit rejects malformed dispersions" { test "apeglm: fit validates offsets and observation weights" { let offsets = try { ignore( - @src.apeglm_fit( - [[1.0, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - offsets=[[0.0]], - ), + @src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1], offsets=[ + [0.0], + ]), ) false } catch { @@ -1231,12 +1122,9 @@ test "apeglm: fit validates offsets and observation weights" { } let weight_shape = try { ignore( - @src.apeglm_fit( - [[1.0, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - weights=[[1.0]], - ), + @src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1], weights=[ + [1.0], + ]), ) false } catch { @@ -1244,12 +1132,9 @@ test "apeglm: fit validates offsets and observation weights" { } let all_zero = try { ignore( - @src.apeglm_fit( - [[1.0, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - weights=[[0.0, 0.0]], - ), + @src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1], weights=[ + [0.0, 0.0], + ]), ) false } catch { @@ -1264,12 +1149,9 @@ test "apeglm: fit validates offsets and observation weights" { test "apeglm: fit validates identifier lengths and uniqueness" { let gene_length = try { ignore( - @src.apeglm_fit( - [[1.0, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - gene_names=["a", "b"], - ), + @src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1], gene_names=[ + "a", "b", + ]), ) false } catch { @@ -1290,12 +1172,9 @@ test "apeglm: fit validates identifier lengths and uniqueness" { } let coefficient_length = try { ignore( - @src.apeglm_fit( - [[1.0, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - coefficient_names=["intercept"], - ), + @src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1], coefficient_names=[ + "intercept", + ]), ) false } catch { @@ -1303,12 +1182,9 @@ test "apeglm: fit validates identifier lengths and uniqueness" { } let empty = try { ignore( - @src.apeglm_fit( - [[1.0, 2.0]], - [[1.0, 0.0], [1.0, 1.0]], - [0.1], - gene_names=[""], - ), + @src.apeglm_fit([[1.0, 2.0]], [[1.0, 0.0], [1.0, 1.0]], [0.1], gene_names=[ + "", + ]), ) false } catch { diff --git a/test/moonbit/application_test.mbt b/test/moonbit/application_test.mbt index f65847e9..767c1705 100644 --- a/test/moonbit/application_test.mbt +++ b/test/moonbit/application_test.mbt @@ -1,23 +1,25 @@ ///| /// Tests for Application module. - test "AbstractCommandline creation" { let cmd = @src.create_example_commandline() assert_eq(cmd.executable, "blastn") } +///| test "AbstractCommandline add_arg" { let mut cmd = @src.AbstractCommandline::new("blastn") cmd = cmd.add_arg("-query", Some("query.fasta")) assert_eq(cmd.arguments.length(), 2) } +///| test "AbstractCommandline add_arg no value" { let mut cmd = @src.AbstractCommandline::new("blastn") cmd = cmd.add_arg("-help", None) assert_eq(cmd.arguments.length(), 1) } +///| test "AbstractCommandline build_command" { let mut cmd = @src.AbstractCommandline::new("blastn") cmd = cmd.add_arg("-query", Some("query.fasta")) @@ -28,8 +30,9 @@ test "AbstractCommandline build_command" { assert_true(command.contains("-db")) } +///| test "AbstractCommandline set_stdout" { let mut cmd = @src.AbstractCommandline::new("blastn") cmd = cmd.set_stdout("output.txt") assert_eq(cmd.stdout, "output.txt") -} \ No newline at end of file +} diff --git a/test/moonbit/aucell_test.mbt b/test/moonbit/aucell_test.mbt index ff50bd42..4a31149d 100644 --- a/test/moonbit/aucell_test.mbt +++ b/test/moonbit/aucell_test.mbt @@ -78,10 +78,7 @@ test "aucell_data" { ///| test "aucell_run_basic" { // 2 cells × 3 genes - let expression = [ - [10.0, 2.0, 5.0], - [3.0, 8.0, 1.0], - ] + let expression = [[10.0, 2.0, 5.0], [3.0, 8.0, 1.0]] let cell_names = ["Cell1", "Cell2"] let gene_names = ["GeneA", "GeneB", "GeneC"] @@ -106,10 +103,7 @@ test "aucell_run_basic" { ///| test "aucell_run_multiple_sets" { - let expression = [ - [5.0, 10.0, 3.0], - [8.0, 2.0, 7.0], - ] + let expression = [[5.0, 10.0, 3.0], [8.0, 2.0, 7.0]] let cell_names = ["Cell1", "Cell2"] let gene_names = ["GeneA", "GeneB", "GeneC"] @@ -125,11 +119,7 @@ test "aucell_run_multiple_sets" { ///| test "aucell_normalize_scores" { - let expression = [ - [10.0, 2.0], - [3.0, 8.0], - [5.0, 5.0], - ] + let expression = [[10.0, 2.0], [3.0, 8.0], [5.0, 5.0]] let cell_names = ["C1", "C2", "C3"] let gene_names = ["G1", "G2"] let gs = @src.GeneSet::new("Set1", ["G1"]) diff --git a/test/moonbit/bamsignals_test.mbt b/test/moonbit/bamsignals_test.mbt index 13e5432c..f1400105 100644 --- a/test/moonbit/bamsignals_test.mbt +++ b/test/moonbit/bamsignals_test.mbt @@ -130,7 +130,7 @@ test "bamsig_chromatin_state" { let repressed_regions = [3] let chrom_state = @src.bamsig_analyze_chromatin_states( - signal, promoter_regions, enhancer_regions, repressed_regions + signal, promoter_regions, enhancer_regions, repressed_regions, ) assert_true(chrom_state.bamsig_n_states() > 0) @@ -154,4 +154,4 @@ test "bamsig_params_setters" { let params4 = params.bamsig_set_extend(200) assert_eq(params4.extend_len, 200) -} \ No newline at end of file +} diff --git a/test/moonbit/batchelor_test.mbt b/test/moonbit/batchelor_test.mbt index e651c170..88d7e73d 100644 --- a/test/moonbit/batchelor_test.mbt +++ b/test/moonbit/batchelor_test.mbt @@ -3,29 +3,33 @@ ///| test "batchelor_create_example_data" { - let (batches, batch_names) = @src.batchelor_create_example_data(2, 50, 100, 1.0) - + let (batches, batch_names) = @src.batchelor_create_example_data( + 2, 50, 100, 1.0, + ) + assert_eq(batches.length(), 2) assert_eq(batch_names.length(), 2) assert_eq(batches[0].length(), 50) assert_eq(batches[1].length(), 50) assert_eq(batches[0][0].length(), 100) assert_eq(batches[1][0].length(), 100) - + assert_eq(batch_names[0], "Batch_0") assert_eq(batch_names[1], "Batch_1") } ///| test "rescale_batches" { - let (batches, batch_names) = @src.batchelor_create_example_data(2, 50, 100, 1.0) - + let (batches, batch_names) = @src.batchelor_create_example_data( + 2, 50, 100, 1.0, + ) + let result = @src.rescale_batches(batches, batch_names) - + assert_eq(result.corrected.length(), 100) assert_eq(result.batch_indices.length(), 100) assert_eq(result.corrected[0].length(), 100) - + let mut batch0_count = 0 let mut batch1_count = 0 for idx in result.batch_indices { @@ -35,7 +39,7 @@ test "rescale_batches" { batch1_count = batch1_count + 1 } } - + assert_eq(batch0_count, 50) assert_eq(batch1_count, 50) } @@ -43,11 +47,11 @@ test "rescale_batches" { ///| test "find_mutual_nearest_neighbors" { let (batches, _) = @src.batchelor_create_example_data(2, 20, 50, 0.5) - + let mnn_pairs = @src.find_mutual_nearest_neighbors(batches[0], batches[1], 3) - + assert_true(mnn_pairs.length() >= 0) - + for pair in mnn_pairs { assert_true(pair.0 >= 0 && pair.0 < 20) assert_true(pair.1 >= 0 && pair.1 < 20) @@ -56,15 +60,17 @@ test "find_mutual_nearest_neighbors" { ///| test "fast_mnn" { - let (batches, batch_names) = @src.batchelor_create_example_data(2, 50, 100, 1.0) - + let (batches, batch_names) = @src.batchelor_create_example_data( + 2, 50, 100, 1.0, + ) + let result = @src.fast_mnn(batches, batch_names, 5, 20) - + assert_eq(result.corrected.length(), 100) assert_eq(result.batch_indices.length(), 100) assert_eq(result.corrected[0].length(), 20) assert_eq(result.var_explained.length(), 20) - + let mut sum_var = 0.0 for var in result.var_explained { assert_true(var >= 0.0 && var <= 1.0) @@ -75,13 +81,18 @@ test "fast_mnn" { ///| test "compute_batch_mixing_score" { - let (batches, batch_names) = @src.batchelor_create_example_data(2, 50, 100, 1.0) - + let (batches, batch_names) = @src.batchelor_create_example_data( + 2, 50, 100, 1.0, + ) + let result = @src.fast_mnn(batches, batch_names, 5, 20) - let score = @src.compute_batch_mixing_score(result.corrected, result.batch_indices) - + let score = @src.compute_batch_mixing_score( + result.corrected, + result.batch_indices, + ) + assert_true(score >= 0.0 && score <= 1.0) - + let raw_data : Array[Array[Double]] = Array::new() for cell in batches[0] { raw_data.push(cell) @@ -89,7 +100,7 @@ test "compute_batch_mixing_score" { for cell in batches[1] { raw_data.push(cell) } - + let raw_batch_indices : Array[Int] = Array::new() let mut idx = 0 while idx < 50 { @@ -101,16 +112,18 @@ test "compute_batch_mixing_score" { raw_batch_indices.push(1) idx = idx + 1 } - + let raw_score = @src.compute_batch_mixing_score(raw_data, raw_batch_indices) - + assert_true(score > raw_score * 0.8) } ///| test "rescale_batches_correction_effect" { - let (batches, batch_names) = @src.batchelor_create_example_data(2, 50, 100, 2.0) - + let (batches, batch_names) = @src.batchelor_create_example_data( + 2, 50, 100, 2.0, + ) + let raw_data : Array[Array[Double]] = Array::new() for cell in batches[0] { raw_data.push(cell) @@ -118,7 +131,7 @@ test "rescale_batches_correction_effect" { for cell in batches[1] { raw_data.push(cell) } - + let raw_batch_indices : Array[Int] = Array::new() let mut idx = 0 while idx < 50 { @@ -130,19 +143,24 @@ test "rescale_batches_correction_effect" { raw_batch_indices.push(1) idx = idx + 1 } - + let raw_score = @src.compute_batch_mixing_score(raw_data, raw_batch_indices) - + let result = @src.rescale_batches(batches, batch_names) - let corrected_score = @src.compute_batch_mixing_score(result.corrected, result.batch_indices) - + let corrected_score = @src.compute_batch_mixing_score( + result.corrected, + result.batch_indices, + ) + assert_true(corrected_score > raw_score) } ///| test "fast_mnn_correction_effect" { - let (batches, batch_names) = @src.batchelor_create_example_data(2, 50, 100, 2.0) - + let (batches, batch_names) = @src.batchelor_create_example_data( + 2, 50, 100, 2.0, + ) + let raw_data : Array[Array[Double]] = Array::new() for cell in batches[0] { raw_data.push(cell) @@ -150,7 +168,7 @@ test "fast_mnn_correction_effect" { for cell in batches[1] { raw_data.push(cell) } - + let raw_batch_indices : Array[Int] = Array::new() let mut idx = 0 while idx < 50 { @@ -162,11 +180,14 @@ test "fast_mnn_correction_effect" { raw_batch_indices.push(1) idx = idx + 1 } - + let raw_score = @src.compute_batch_mixing_score(raw_data, raw_batch_indices) - + let result = @src.fast_mnn(batches, batch_names, 5, 20) - let corrected_score = @src.compute_batch_mixing_score(result.corrected, result.batch_indices) - + let corrected_score = @src.compute_batch_mixing_score( + result.corrected, + result.batch_indices, + ) + assert_true(corrected_score > raw_score) } diff --git a/test/moonbit/bayes_space_test.mbt b/test/moonbit/bayes_space_test.mbt index b0ed69f4..57203e3c 100644 --- a/test/moonbit/bayes_space_test.mbt +++ b/test/moonbit/bayes_space_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Bioconductor BayesSpace module - Spatial transcriptomics clustering. - test "spot_coord_create" { let s = @src.spot_coord("spot_1_2", 1, 2, 2.0, 1.0) assert_eq(s.spot_id, "spot_1_2") @@ -10,6 +9,7 @@ test "spot_coord_create" { assert_true((s.y - 1.0).abs() < 1.0e-9) } +///| test "bayes_space_hex_neighbors_basic" { // 3x3 grid of spots let spots : Array[@src.SpotCoord] = [] @@ -17,7 +17,15 @@ test "bayes_space_hex_neighbors_basic" { while r < 3 { let mut c = 0 while c < 3 { - spots.push(@src.spot_coord("s_" + r.to_string() + "_" + c.to_string(), r, c, c.to_double(), r.to_double())) + spots.push( + @src.spot_coord( + "s_" + r.to_string() + "_" + c.to_string(), + r, + c, + c.to_double(), + r.to_double(), + ), + ) c = c + 1 } r = r + 1 @@ -31,13 +39,22 @@ test "bayes_space_hex_neighbors_basic" { assert_true(neighbors[corner_idx].length() < neighbors[center_idx].length()) } +///| test "bayes_space_square_neighbors_basic" { let spots : Array[@src.SpotCoord] = [] let mut r = 0 while r < 3 { let mut c = 0 while c < 3 { - spots.push(@src.spot_coord("s_" + r.to_string() + "_" + c.to_string(), r, c, c.to_double(), r.to_double())) + spots.push( + @src.spot_coord( + "s_" + r.to_string() + "_" + c.to_string(), + r, + c, + c.to_double(), + r.to_double(), + ), + ) c = c + 1 } r = r + 1 @@ -48,6 +65,7 @@ test "bayes_space_square_neighbors_basic" { assert_eq(neighbors[center_idx].length(), 4) } +///| test "bayes_space_sample_data_shape" { let (expr, spots) = @src.bayes_space_sample_data() assert_eq(expr.length(), 16) // 4x4 grid @@ -55,10 +73,18 @@ test "bayes_space_sample_data_shape" { assert_eq(expr[0].length(), 3) // 3 features per spot } +///| test "bayes_space_run_basic" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=20, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=20, + seed=42, + ) assert_eq(result.q, 2) assert_eq(result.spot_ids.length(), 16) assert_eq(result.clusters.length(), 16) @@ -80,21 +106,37 @@ test "bayes_space_run_basic" { } } +///| test "bayes_space_run_convergence_or_max_iters" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=50, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=50, + seed=42, + ) // Should either converge or hit max iters assert_true(result.n_iterations > 0) assert_true(result.n_iterations <= 50) } +///| test "bayes_space_two_clusters_separated" { // The sample data has top-left (low) and bottom-right (high) clusters. // After clustering with q=2, the corner spots should be in different clusters. let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=30, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=30, + seed=42, + ) // Find indices of corner spots let mut tl_idx = -1 let mut br_idx = -1 @@ -114,26 +156,50 @@ test "bayes_space_two_clusters_separated" { assert_not_eq(result.clusters[tl_idx], result.clusters[br_idx]) } +///| test "bayes_space_get_cluster_by_id" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=20, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=20, + seed=42, + ) let c = @src.bayes_space_get_cluster(result, "spot_0_0") assert_true(c >= 0 && c < 2) } +///| test "bayes_space_get_cluster_unknown_id" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=10, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=10, + seed=42, + ) let c = @src.bayes_space_get_cluster(result, "UNKNOWN_SPOT") assert_eq(c, -1) } +///| test "bayes_space_spots_in_cluster" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=20, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=20, + seed=42, + ) let c0 = @src.bayes_space_spots_in_cluster(result, 0) let c1 = @src.bayes_space_spots_in_cluster(result, 1) // Both clusters should have at least one spot @@ -143,20 +209,36 @@ test "bayes_space_spots_in_cluster" { assert_eq(c0.length() + c1.length(), 16) } +///| test "bayes_space_cluster_counts" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=20, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=20, + seed=42, + ) let counts = @src.bayes_space_cluster_counts(result) assert_eq(counts.length(), 2) // Sum of counts should equal total spots assert_eq(counts[0] + counts[1], 16) } +///| test "bayes_space_render_clusters" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=10, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=10, + seed=42, + ) let render = @src.bayes_space_render_clusters(result, spots) // Should contain 4 rows separated by newlines assert_true(render.length() > 0) @@ -171,11 +253,19 @@ test "bayes_space_render_clusters" { assert_eq(nl_count, 4) } +///| test "bayes_space_q_equals_3" { // Test with q=3 clusters let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 3, neighbors, max_iters=15, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 3, + neighbors, + max_iters=15, + seed=42, + ) assert_eq(result.q, 3) assert_eq(result.cluster_centers.length(), 3) // Each spot's cluster should be in [0, 3) @@ -186,12 +276,14 @@ test "bayes_space_q_equals_3" { } } +///| test "bayes_space_empty_grid_neighbors" { // Empty spots list → empty neighbor list let neighbors = @src.bayes_space_hex_neighbors([]) assert_eq(neighbors.length(), 0) } +///| test "bayes_space_single_spot" { // Single spot → no neighbors let spots = [@src.spot_coord("only", 0, 0, 0.0, 0.0)] @@ -200,20 +292,43 @@ test "bayes_space_single_spot" { assert_eq(neighbors[0].length(), 0) } +///| test "bayes_space_log_likelihood_finite" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let result = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=20, seed=42) + let result = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=20, + seed=42, + ) // Log-likelihood should be a finite number (not NaN/Inf) assert_false(result.log_likelihood.is_nan()) assert_false(result.log_likelihood.abs() > 1.0e300) } +///| test "bayes_space_reproducible_with_same_seed" { let (expr, spots) = @src.bayes_space_sample_data() let neighbors = @src.bayes_space_hex_neighbors(spots) - let r1 = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=15, seed=123) - let r2 = @src.bayes_space_run(expr, spots, 2, neighbors, max_iters=15, seed=123) + let r1 = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=15, + seed=123, + ) + let r2 = @src.bayes_space_run( + expr, + spots, + 2, + neighbors, + max_iters=15, + seed=123, + ) // Same seed → same cluster assignments let mut i = 0 while i < r1.clusters.length() { diff --git a/test/moonbit/bayseq_test.mbt b/test/moonbit/bayseq_test.mbt index b67b42ea..65e94061 100644 --- a/test/moonbit/bayseq_test.mbt +++ b/test/moonbit/bayseq_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Bioconductor baySeq module - Bayesian differential expression. - test "estimate_dispersion_basic" { // Two groups with different means let a = [100.0, 120.0, 110.0, 90.0] @@ -10,6 +9,7 @@ test "estimate_dispersion_basic" { assert_true(disp <= 100.0) } +///| test "estimate_dispersion_low_counts" { let a = [1.0, 2.0, 1.5, 1.2] let b = [1.0, 1.8, 1.3, 1.1] @@ -18,6 +18,7 @@ test "estimate_dispersion_low_counts" { assert_true(disp > 0.0) } +///| test "estimate_dispersion_single_sample" { let a = [100.0] let b = [200.0] @@ -25,6 +26,7 @@ test "estimate_dispersion_single_sample" { assert_true(disp == 1.0) } +///| test "estimate_prior_basic" { let (counts, groups, _) = @src.bayseq_sample_data() let (shape, rate) = @src.bayseq_estimate_prior(counts, groups) @@ -32,6 +34,7 @@ test "estimate_prior_basic" { assert_true(rate > 0.0) } +///| test "estimate_prior_empty" { let counts : Array[Array[Double]] = [] let (shape, rate) = @src.bayseq_estimate_prior(counts, []) @@ -39,6 +42,7 @@ test "estimate_prior_empty" { assert_true(rate == 0.5) } +///| test "log_likelihood_ratio_de" { let a = [100.0, 120.0, 110.0, 90.0] let b = [500.0, 520.0, 510.0, 490.0] @@ -48,6 +52,7 @@ test "log_likelihood_ratio_de" { assert_true(llr > 0.0) } +///| test "log_likelihood_ratio_same" { let a = [100.0, 120.0, 110.0, 90.0] let b = [100.0, 120.0, 110.0, 90.0] @@ -57,28 +62,33 @@ test "log_likelihood_ratio_same" { assert_true(llr >= -1.0 && llr <= 1.0) } +///| test "lgamma_positive" { let val = @src.bayseq_lgamma(5.0) assert_true(val > 0.0) } +///| test "lgamma_one" { // lgamma(1) = 0 since gamma(1) = 1, log(1) = 0 let val = @src.bayseq_lgamma(1.0) assert_true(val >= -0.1 && val <= 0.1) } +///| test "lgamma_large" { let val = @src.bayseq_lgamma(100.0) // lgamma(100) ≈ 363.739 assert_true(val > 100.0) } +///| test "nb_log_likelihood_zero_mean" { let ll = @src.bayseq_nb_log_likelihood([1.0, 2.0, 3.0], 0.0, 10.0) assert_true(ll == 0.0) } +///| test "test_basic" { let (counts, groups, names) = @src.bayseq_sample_data() let result = @src.bayseq_test(counts, groups, names) @@ -87,6 +97,7 @@ test "test_basic" { assert_true(result.n_de_genes <= 30) } +///| test "test_lfc_calculation" { let (counts, groups, names) = @src.bayseq_sample_data() let result = @src.bayseq_test(counts, groups, names) @@ -95,6 +106,7 @@ test "test_lfc_calculation" { assert_true(g0.log_fold_change > 0.0) } +///| test "test_posterior_prob" { let (counts, groups, names) = @src.bayseq_sample_data() let result = @src.bayseq_test(counts, groups, names) @@ -102,6 +114,7 @@ test "test_posterior_prob" { assert_true(g0.posterior_prob_de >= 0.0 && g0.posterior_prob_de <= 1.0) } +///| test "get_de_genes" { let (counts, groups, names) = @src.bayseq_sample_data() let result = @src.bayseq_test(counts, groups, names) @@ -109,6 +122,7 @@ test "get_de_genes" { assert_eq(de_genes.length(), result.n_de_genes) } +///| test "get_top_de" { let (counts, groups, names) = @src.bayseq_sample_data() let result = @src.bayseq_test(counts, groups, names) @@ -116,6 +130,7 @@ test "get_top_de" { assert_eq(top.length(), 5) } +///| test "get_top_de_fewer_than_n" { let (counts, groups, names) = @src.bayseq_sample_data() let result = @src.bayseq_test(counts, groups, names) @@ -123,6 +138,7 @@ test "get_top_de_fewer_than_n" { assert_eq(top.length(), 30) } +///| test "sample_data_dimensions" { let (counts, groups, names) = @src.bayseq_sample_data() assert_eq(counts.length(), 30) @@ -131,6 +147,7 @@ test "sample_data_dimensions" { assert_eq(names.length(), 30) } +///| test "summary" { let (counts, groups, names) = @src.bayseq_sample_data() let result = @src.bayseq_test(counts, groups, names) diff --git a/test/moonbit/beachmat_test.mbt b/test/moonbit/beachmat_test.mbt index c1c2a336..004dab76 100644 --- a/test/moonbit/beachmat_test.mbt +++ b/test/moonbit/beachmat_test.mbt @@ -11,24 +11,28 @@ test "bmat_param_creation" { assert_eq(p.col_block_size(), 0) } +///| test "bmat_param_with_blocks" { let p = @src.BmatParam::with_blocks(10, 20) assert_eq(p.row_block_size(), 10) assert_eq(p.col_block_size(), 20) } +///| test "bmat_param_column_param" { let p = @src.BmatParam::column_param(15) assert_eq(p.row_block_size(), 0) assert_eq(p.col_block_size(), 15) } +///| test "bmat_param_row_param" { let p = @src.BmatParam::row_param(25) assert_eq(p.row_block_size(), 25) assert_eq(p.col_block_size(), 0) } +///| test "bmat_param_accessors" { let p = @src.BmatParam::with_blocks(5, 10) assert_eq(p.row_block_size(), 5) @@ -39,6 +43,7 @@ test "bmat_param_accessors" { // Bmat creation and basic accessors // --------------------------------------------------------------------------- +///| test "bmat_creation_from_array" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -46,6 +51,7 @@ test "bmat_creation_from_array" { assert_eq(bmat.dim_cols(), 3) } +///| test "bmat_creation_zeros" { let bmat = @src.Bmat::zeros(4, 5) assert_eq(bmat.dim_rows(), 4) @@ -54,18 +60,21 @@ test "bmat_creation_zeros" { assert_eq(bmat.get(3, 4), 0.0) } +///| test "bmat_dim_rows" { let data = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) assert_eq(bmat.dim_rows(), 3) } +///| test "bmat_dim_cols" { let data = [[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) assert_eq(bmat.dim_cols(), 4) } +///| test "bmat_get" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -80,6 +89,7 @@ test "bmat_get" { assert_eq(bmat.get(2, 2), 9.0) } +///| test "bmat_set" { let data = [[1.0, 2.0], [3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -91,6 +101,7 @@ test "bmat_set" { assert_eq(bmat.get(1, 1), 20.0) } +///| test "bmat_get_col" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -109,6 +120,7 @@ test "bmat_get_col" { assert_eq(col2[2], 9.0) } +///| test "bmat_get_row" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -131,6 +143,7 @@ test "bmat_get_row" { // BmatBlock creation and properties // --------------------------------------------------------------------------- +///| test "bmat_block_properties" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -160,6 +173,7 @@ test "bmat_block_properties" { assert_eq(block_ncols[1], 1) } +///| test "bmat_block_get_data" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -200,6 +214,7 @@ test "bmat_block_get_data" { // Block processing // --------------------------------------------------------------------------- +///| test "bmat_apply_col_blocks_basic" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -216,6 +231,7 @@ test "bmat_apply_col_blocks_basic" { assert_eq(col_ends[1], 3) } +///| test "bmat_apply_col_blocks_three_blocks" { let data = [[1.0, 2.0, 3.0, 4.0, 5.0], [6.0, 7.0, 8.0, 9.0, 10.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -229,6 +245,7 @@ test "bmat_apply_col_blocks_three_blocks" { assert_eq(col_starts[2], 4) } +///| test "bmat_apply_col_blocks_verification" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -253,6 +270,7 @@ test "bmat_apply_col_blocks_verification" { assert_eq(all_vals[8], 9.0) } +///| test "bmat_apply_row_blocks_basic" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -269,6 +287,7 @@ test "bmat_apply_row_blocks_basic" { assert_eq(row_ends[1], 3) } +///| test "bmat_apply_row_blocks_verification" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -293,6 +312,7 @@ test "bmat_apply_row_blocks_verification" { assert_eq(all_vals[8], 9.0) } +///| test "bmat_apply_row_blocks_three_blocks" { let data = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0], [9.0, 10.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -306,13 +326,12 @@ test "bmat_apply_row_blocks_three_blocks" { assert_eq(row_starts[2], 4) } +///| test "bmat_foreach" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) let values : Array[Double] = [] - @src.bmat_foreach(bmat, fn(row, col, val) { - values.push(val) - }) + @src.bmat_foreach(bmat, fn(row, col, val) { values.push(val) }) assert_eq(values.length(), 6) assert_eq(values[0], 1.0) assert_eq(values[1], 2.0) @@ -322,6 +341,7 @@ test "bmat_foreach" { assert_eq(values[5], 6.0) } +///| test "bmat_foreach_row_col_verification" { let data = [[10.0, 20.0], [30.0, 40.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -352,6 +372,7 @@ test "bmat_foreach_row_col_verification" { // BmatIterator // --------------------------------------------------------------------------- +///| test "bmat_iterator_basic" { let data = [[1.0, 2.0], [3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -369,6 +390,7 @@ test "bmat_iterator_basic" { assert_true(v4 is None) } +///| test "bmat_iterator_has_next" { let data = [[1.0, 2.0, 3.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -382,6 +404,7 @@ test "bmat_iterator_has_next" { assert_false(iter.has_next()) } +///| test "bmat_iterator_exhausted_next" { let data = [[1.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -394,6 +417,7 @@ test "bmat_iterator_exhausted_next" { assert_true(v2 is None) } +///| test "bmat_iterator_cur_row_col" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -417,6 +441,7 @@ test "bmat_iterator_cur_row_col" { assert_eq(iter.cur_col(), 2) } +///| test "bmat_iterator_full_traversal" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -442,6 +467,7 @@ test "bmat_iterator_full_traversal" { // Conversion // --------------------------------------------------------------------------- +///| test "bmat_from_array" { let data = [[5.0, 10.0], [15.0, 20.0]] let bmat = @src.bmat_from_array(data) @@ -453,6 +479,7 @@ test "bmat_from_array" { assert_eq(bmat.get(1, 1), 20.0) } +///| test "bmat_to_array" { let data = [[2.0, 4.0, 6.0], [8.0, 10.0, 12.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -467,6 +494,7 @@ test "bmat_to_array" { assert_eq(arr[1][2], 12.0) } +///| test "bmat_roundtrip" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.bmat_from_array(data) @@ -483,6 +511,7 @@ test "bmat_roundtrip" { // Subset, transpose, bind // --------------------------------------------------------------------------- +///| test "bmat_subset" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -495,6 +524,7 @@ test "bmat_subset" { assert_eq(sub.get(1, 1), 5.0) } +///| test "bmat_subset_bottom_right" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -507,6 +537,7 @@ test "bmat_subset_bottom_right" { assert_eq(sub.get(1, 1), 9.0) } +///| test "bmat_transpose" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -521,6 +552,7 @@ test "bmat_transpose" { assert_eq(t.get(2, 1), 6.0) } +///| test "bmat_transpose_square" { let data = [[1.0, 2.0], [3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -531,6 +563,7 @@ test "bmat_transpose_square" { assert_eq(t.get(1, 1), 4.0) } +///| test "bmat_bind_cols" { let left = @src.Bmat::new([[1.0, 2.0], [3.0, 4.0]], @src.BmatParam::new()) let right = @src.Bmat::new([[5.0], [6.0]], @src.BmatParam::new()) @@ -545,6 +578,7 @@ test "bmat_bind_cols" { assert_eq(result.get(1, 2), 6.0) } +///| test "bmat_bind_cols_equal_width" { let left = @src.Bmat::new([[1.0, 2.0], [3.0, 4.0]], @src.BmatParam::new()) let right = @src.Bmat::new([[5.0, 6.0], [7.0, 8.0]], @src.BmatParam::new()) @@ -561,6 +595,7 @@ test "bmat_bind_cols_equal_width" { assert_eq(result.get(1, 3), 8.0) } +///| test "bmat_bind_rows" { let top = @src.Bmat::new([[1.0, 2.0], [3.0, 4.0]], @src.BmatParam::new()) let bottom = @src.Bmat::new([[5.0, 6.0]], @src.BmatParam::new()) @@ -575,6 +610,7 @@ test "bmat_bind_rows" { assert_eq(result.get(2, 1), 6.0) } +///| test "bmat_bind_rows_equal_height" { let top = @src.Bmat::new([[1.0, 2.0], [3.0, 4.0]], @src.BmatParam::new()) let bottom = @src.Bmat::new([[5.0, 6.0], [7.0, 8.0]], @src.BmatParam::new()) @@ -595,6 +631,7 @@ test "bmat_bind_rows_equal_height" { // Element-wise operations // --------------------------------------------------------------------------- +///| test "bmat_apply_elementwise_double" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -609,6 +646,7 @@ test "bmat_apply_elementwise_double" { assert_eq(result.get(1, 2), 12.0) } +///| test "bmat_apply_elementwise_square" { let data = [[1.0, 2.0], [3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -619,6 +657,7 @@ test "bmat_apply_elementwise_square" { assert_eq(result.get(1, 1), 16.0) } +///| test "bmat_apply_elementwise_negate" { let data = [[1.0, -2.0], [3.0, -4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -629,6 +668,7 @@ test "bmat_apply_elementwise_negate" { assert_eq(result.get(1, 1), 4.0) } +///| test "bmat_apply_elementwise_no_change" { let data = [[5.0, 10.0], [15.0, 20.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -643,6 +683,7 @@ test "bmat_apply_elementwise_no_change" { // to_string // --------------------------------------------------------------------------- +///| test "bmat_to_string" { let data = [[1.0, 2.0], [3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -654,6 +695,7 @@ test "bmat_to_string" { assert_true(s.contains("4")) } +///| test "bmat_to_string_single" { let data = [[7.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -666,6 +708,7 @@ test "bmat_to_string_single" { // Edge cases // --------------------------------------------------------------------------- +///| test "bmat_empty_matrix" { let data : Array[Array[Double]] = [] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -673,12 +716,14 @@ test "bmat_empty_matrix" { assert_eq(bmat.dim_cols(), 0) } +///| test "bmat_empty_matrix_zeros" { let bmat = @src.Bmat::zeros(0, 0) assert_eq(bmat.dim_rows(), 0) assert_eq(bmat.dim_cols(), 0) } +///| test "bmat_empty_matrix_iterator" { let data : Array[Array[Double]] = [] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -690,6 +735,7 @@ test "bmat_empty_matrix_iterator" { assert_eq(iter.cur_col(), 0) } +///| test "bmat_empty_matrix_roundtrip" { let data : Array[Array[Double]] = [] let bmat = @src.bmat_from_array(data) @@ -699,6 +745,7 @@ test "bmat_empty_matrix_roundtrip" { assert_eq(arr.length(), 0) } +///| test "bmat_single_row" { let data = [[1.0, 2.0, 3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -711,6 +758,7 @@ test "bmat_single_row" { assert_eq(row[2], 3.0) } +///| test "bmat_single_col" { let data = [[1.0], [2.0], [3.0], [4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -723,6 +771,7 @@ test "bmat_single_col" { assert_eq(col[2], 3.0) } +///| test "bmat_single_element" { let data = [[42.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -733,6 +782,7 @@ test "bmat_single_element" { assert_eq(bmat.get(0, 0), 99.0) } +///| test "bmat_apply_col_blocks_single_block" { let data = [[1.0, 2.0], [3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -744,6 +794,7 @@ test "bmat_apply_col_blocks_single_block" { assert_eq(col_starts[0], 0) } +///| test "bmat_apply_row_blocks_single_block" { let data = [[1.0, 2.0], [3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -755,6 +806,7 @@ test "bmat_apply_row_blocks_single_block" { assert_eq(row_starts[0], 0) } +///| test "bmat_apply_col_blocks_exact_fit" { let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -766,6 +818,7 @@ test "bmat_apply_col_blocks_exact_fit" { assert_eq(col_starts[0], 0) } +///| test "bmat_apply_row_blocks_exact_fit" { let data = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -777,6 +830,7 @@ test "bmat_apply_row_blocks_exact_fit" { assert_eq(row_starts[0], 0) } +///| test "bmat_iterator_single_element" { let data = [[42.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -789,6 +843,7 @@ test "bmat_iterator_single_element" { assert_false(iter.has_next()) } +///| test "bmat_subset_single_element" { let data = [[1.0, 2.0], [3.0, 4.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -798,6 +853,7 @@ test "bmat_subset_single_element" { assert_eq(sub.get(0, 0), 4.0) } +///| test "bmat_transpose_empty" { let data : Array[Array[Double]] = [] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -806,16 +862,16 @@ test "bmat_transpose_empty" { assert_eq(t.dim_cols(), 0) } +///| test "bmat_foreach_empty" { let data : Array[Array[Double]] = [] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) let values : Array[Double] = [] - @src.bmat_foreach(bmat, fn(row, col, val) { - values.push(val) - }) + @src.bmat_foreach(bmat, fn(row, col, val) { values.push(val) }) assert_eq(values.length(), 0) } +///| test "bmat_zeros_set_get" { let bmat = @src.Bmat::zeros(3, 3) assert_eq(bmat.get(1, 1), 0.0) @@ -825,6 +881,7 @@ test "bmat_zeros_set_get" { assert_eq(bmat.get(2, 2), 0.0) } +///| test "bmat_apply_elementwise_empty" { let data : Array[Array[Double]] = [] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -833,6 +890,7 @@ test "bmat_apply_elementwise_empty" { assert_eq(result.dim_cols(), 0) } +///| test "bmat_bind_cols_empty" { let left = @src.Bmat::zeros(3, 0) let right = @src.Bmat::new([[1.0], [2.0], [3.0]], @src.BmatParam::new()) @@ -843,6 +901,7 @@ test "bmat_bind_cols_empty" { assert_eq(result.get(2, 0), 3.0) } +///| test "bmat_bind_rows_empty" { let top = @src.Bmat::zeros(0, 2) let bottom = @src.Bmat::new([[1.0, 2.0]], @src.BmatParam::new()) @@ -853,6 +912,7 @@ test "bmat_bind_rows_empty" { assert_eq(result.get(0, 1), 2.0) } +///| test "bmat_get_set_multiple" { let bmat = @src.Bmat::zeros(3, 3) bmat.set(0, 0, 1.0) @@ -879,6 +939,7 @@ test "bmat_get_set_multiple" { assert_eq(col2[2], 9.0) } +///| test "bmat_apply_col_blocks_last_block_partial" { let data = [[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -892,6 +953,7 @@ test "bmat_apply_col_blocks_last_block_partial" { assert_eq(col_ends[2], 7) } +///| test "bmat_apply_row_blocks_last_block_partial" { let data = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0], [9.0, 10.0]] let bmat = @src.Bmat::new(data, @src.BmatParam::new()) @@ -903,4 +965,4 @@ test "bmat_apply_row_blocks_last_block_partial" { assert_eq(row_ends[0], 2) assert_eq(row_ends[1], 4) assert_eq(row_ends[2], 5) -} \ No newline at end of file +} diff --git a/test/moonbit/binary_cif_test.mbt b/test/moonbit/binary_cif_test.mbt index eaf63a4d..a4369ea1 100644 --- a/test/moonbit/binary_cif_test.mbt +++ b/test/moonbit/binary_cif_test.mbt @@ -11,14 +11,8 @@ test "binary cif decodes signed and unsigned 8-bit byte arrays" { ///| test "binary cif decodes signed and unsigned 16-bit byte arrays" { let bytes = [0x34, 0x12, 0x00, 0x80, 0xFF, 0xFF] - assert_eq( - @src.binary_cif_decode_int_bytes(bytes, 2), - [4660, -32768, -1], - ) - assert_eq( - @src.binary_cif_decode_int_bytes(bytes, 5), - [4660, 32768, 65535], - ) + assert_eq(@src.binary_cif_decode_int_bytes(bytes, 2), [4660, -32768, -1]) + assert_eq(@src.binary_cif_decode_int_bytes(bytes, 5), [4660, 32768, 65535]) } ///| @@ -30,17 +24,17 @@ test "binary cif decodes signed and unsigned 32-bit byte arrays" { ), [305419896, -1], ) - assert_eq( - @src.binary_cif_decode_int_bytes([0xFF, 0xFF, 0xFF, 0x7F], 6), - [2147483647], - ) + assert_eq(@src.binary_cif_decode_int_bytes([0xFF, 0xFF, 0xFF, 0x7F], 6), [ + 2147483647, + ]) } ///| test "binary cif decodes little-endian float32 byte arrays" { - let values = @src.binary_cif_decode_float_bytes([ - 0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x20, 0xC0, - ], 32) + let values = @src.binary_cif_decode_float_bytes( + [0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x20, 0xC0], + 32, + ) assert_eq(values.length(), 2) assert_true((values[0] - 1.0).abs() < 1.0e-12) assert_true((values[1] + 2.5).abs() < 1.0e-12) @@ -48,24 +42,13 @@ test "binary cif decodes little-endian float32 byte arrays" { ///| test "binary cif decodes little-endian float64 byte arrays" { - let values = @src.binary_cif_decode_float_bytes([ - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0xF0, - 0x3F, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x00, - 0x04, - 0xC0, - ], 33) + let values = @src.binary_cif_decode_float_bytes( + [ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x04, 0xC0, + ], + 33, + ) assert_eq(values.length(), 2) assert_true((values[0] - 1.0).abs() < 1.0e-12) assert_true((values[1] + 2.5).abs() < 1.0e-12) @@ -98,35 +81,27 @@ test "binary cif byte array decoding rejects invalid inputs" { ///| test "binary cif decodes unsigned integer packing" { - assert_eq( - @src.binary_cif_decode_integer_packing([255, 5, 1], 1, true, 2), - [260, 1], - ) + assert_eq(@src.binary_cif_decode_integer_packing([255, 5, 1], 1, true, 2), [ + 260, 1, + ]) } ///| test "binary cif decodes signed integer packing" { assert_eq( - @src.binary_cif_decode_integer_packing( - [127, 5, -128, -2, 10], - 1, - false, - 3, - ), + @src.binary_cif_decode_integer_packing([127, 5, -128, -2, 10], 1, false, 3), [132, -130, 10], ) } ///| test "binary cif decodes two-byte integer packing" { - assert_eq( - @src.binary_cif_decode_integer_packing([65535, 100], 2, true, 1), - [65635], - ) - assert_eq( - @src.binary_cif_decode_integer_packing([-32768, -5], 2, false, 1), - [-32773], - ) + assert_eq(@src.binary_cif_decode_integer_packing([65535, 100], 2, true, 1), [ + 65635, + ]) + assert_eq(@src.binary_cif_decode_integer_packing([-32768, -5], 2, false, 1), [ + -32773, + ]) } ///| @@ -156,10 +131,9 @@ test "binary cif integer packing validates metadata and values" { ///| test "binary cif decodes run-length encoding" { - assert_eq( - @src.binary_cif_decode_run_length([4, 3, -1, 2], 5), - [4, 4, 4, -1, -1], - ) + assert_eq(@src.binary_cif_decode_run_length([4, 3, -1, 2], 5), [ + 4, 4, 4, -1, -1, + ]) } ///| @@ -229,25 +203,19 @@ test "binary cif decodes interval quantization" { ///| test "binary cif interval quantization validates parameters and indices" { let bad_steps = try { - ignore( - @src.binary_cif_decode_interval_quantization([0], 0.0, 1.0, 1), - ) + ignore(@src.binary_cif_decode_interval_quantization([0], 0.0, 1.0, 1)) false } catch { BinaryCifError(_) => true } let bad_bounds = try { - ignore( - @src.binary_cif_decode_interval_quantization([0], 2.0, 1.0, 3), - ) + ignore(@src.binary_cif_decode_interval_quantization([0], 2.0, 1.0, 3)) false } catch { BinaryCifError(_) => true } let bad_index = try { - ignore( - @src.binary_cif_decode_interval_quantization([3], 0.0, 1.0, 3), - ) + ignore(@src.binary_cif_decode_interval_quantization([3], 0.0, 1.0, 3)) false } catch { BinaryCifError(_) => true @@ -324,29 +292,27 @@ test "binary cif queries columns by short and qualified names" { ///| test "binary cif reports decoded column kinds and lengths" { - let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) - .data_blocks[0] + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()).data_blocks[0] .get_category("atom_site") .unwrap() assert_true( - atom_site.get_column("id").unwrap().kind() is - @src.BinaryCifColumnKind::BinaryCifInteger, + atom_site.get_column("id").unwrap().kind() + is @src.BinaryCifColumnKind::BinaryCifInteger, ) assert_true( - atom_site.get_column("Cartn_x").unwrap().kind() is - @src.BinaryCifColumnKind::BinaryCifFloat, + atom_site.get_column("Cartn_x").unwrap().kind() + is @src.BinaryCifColumnKind::BinaryCifFloat, ) assert_true( - atom_site.get_column("label_atom_id").unwrap().kind() is - @src.BinaryCifColumnKind::BinaryCifText, + atom_site.get_column("label_atom_id").unwrap().kind() + is @src.BinaryCifColumnKind::BinaryCifText, ) assert_eq(atom_site.get_column("Cartn_x").unwrap().length(), 8) } ///| test "binary cif reads integer columns" { - let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) - .data_blocks[0] + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()).data_blocks[0] .get_category("atom_site") .unwrap() let ids = atom_site.get_column("id").unwrap() @@ -357,8 +323,7 @@ test "binary cif reads integer columns" { ///| test "binary cif reverses fixed-point and delta pipelines" { - let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) - .data_blocks[0] + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()).data_blocks[0] .get_category("atom_site") .unwrap() let xs = atom_site.get_column("Cartn_x").unwrap() @@ -369,8 +334,7 @@ test "binary cif reverses fixed-point and delta pipelines" { ///| test "binary cif reverses string array pipelines" { - let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) - .data_blocks[0] + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()).data_blocks[0] .get_category("atom_site") .unwrap() let components = atom_site.get_column("label_comp_id").unwrap() @@ -382,14 +346,11 @@ test "binary cif reverses string array pipelines" { ///| test "binary cif exposes present not-present and unknown masks" { - let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) - .data_blocks[0] + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()).data_blocks[0] .get_category("atom_site") .unwrap() let altloc = atom_site.get_column("label_alt_id").unwrap() - assert_true( - altloc.mask_at(0) is @src.BinaryCifMask::BinaryCifNotPresent, - ) + assert_true(altloc.mask_at(0) is @src.BinaryCifMask::BinaryCifNotPresent) assert_true(altloc.mask_at(3) is @src.BinaryCifMask::BinaryCifPresent) assert_true(altloc.mask_at(6) is @src.BinaryCifMask::BinaryCifUnknown) assert_true(altloc.string_at(0) is None) @@ -402,8 +363,7 @@ test "binary cif exposes present not-present and unknown masks" { ///| test "binary cif column access validates type and bounds" { - let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()) - .data_blocks[0] + let atom_site = @src.binary_cif_parse(@src.binary_cif_sample_bytes()).data_blocks[0] .get_category("atom_site") .unwrap() let names = atom_site.get_column("label_atom_id").unwrap() @@ -434,7 +394,9 @@ test "binary cif summarizes document contents" { ///| test "binary cif builds pdb structure hierarchy" { - let structure = @src.binary_cif_parse_structure(@src.binary_cif_sample_bytes()) + let structure = @src.binary_cif_parse_structure( + @src.binary_cif_sample_bytes(), + ) assert_eq(structure.get_id(), "BCIF") assert_eq(structure.get_num_models(), 2) assert_eq(structure.get_num_chains(), 3) @@ -444,7 +406,9 @@ test "binary cif builds pdb structure hierarchy" { ///| test "binary cif preserves model and chain grouping" { - let structure = @src.binary_cif_parse_structure(@src.binary_cif_sample_bytes()) + let structure = @src.binary_cif_parse_structure( + @src.binary_cif_sample_bytes(), + ) let models = structure.get_models() assert_eq(models[0].get_id(), 0) assert_eq(models[1].get_id(), 1) @@ -456,7 +420,9 @@ test "binary cif preserves model and chain grouping" { ///| test "binary cif preserves residues insertion codes and water" { - let structure = @src.binary_cif_parse_structure(@src.binary_cif_sample_bytes()) + let structure = @src.binary_cif_parse_structure( + @src.binary_cif_sample_bytes(), + ) let residues = structure.get_residues() assert_eq(residues[0].resname, "GLY") assert_eq(residues[0].resseq, 1) @@ -471,7 +437,9 @@ test "binary cif preserves residues insertion codes and water" { ///| test "binary cif preserves atom annotations and coordinates" { - let structure = @src.binary_cif_parse_structure(@src.binary_cif_sample_bytes()) + let structure = @src.binary_cif_parse_structure( + @src.binary_cif_sample_bytes(), + ) let atoms = structure.get_atoms() assert_eq(atoms[0].name, "N") assert_eq(atoms[0].element, "N") diff --git a/test/moonbit/bio_seq_test.mbt b/test/moonbit/bio_seq_test.mbt index ff2d7f59..8163a422 100644 --- a/test/moonbit/bio_seq_test.mbt +++ b/test/moonbit/bio_seq_test.mbt @@ -333,6 +333,7 @@ test "seq_translate_rna_stop_codons" { // MutableSeq tests +///| test "mutableseq_construction" { let ms = @src.MutableSeq::new("ACGT") assert_eq(ms.length(), 4) @@ -342,6 +343,7 @@ test "mutableseq_construction" { assert_eq(ms2.to_string(), "ATCG") } +///| test "mutableseq_get_set" { let ms = @src.MutableSeq::new("ACGT") assert_eq(ms.get(0), 'A') @@ -350,6 +352,7 @@ test "mutableseq_get_set" { assert_eq(ms.to_string(), "AXGT") } +///| test "mutableseq_push_append" { let ms = @src.MutableSeq::new("AC") ms.push('G') @@ -359,24 +362,28 @@ test "mutableseq_push_append" { assert_eq(ms.to_string(), "ACGT") } +///| test "mutableseq_insert" { let ms = @src.MutableSeq::new("ACGT") ms.insert(2, 'X') assert_eq(ms.to_string(), "ACXGT") } +///| test "mutableseq_delete" { let ms = @src.MutableSeq::new("ACGT") ms.delete(1) assert_eq(ms.to_string(), "AGT") } +///| test "mutableseq_delete_range" { let ms = @src.MutableSeq::new("ACGTACGT") ms.delete_range(2, 6) assert_eq(ms.to_string(), "ACGT") } +///| test "mutableseq_pop" { let ms = @src.MutableSeq::new("ACGT") let popped = ms.pop() @@ -386,6 +393,7 @@ test "mutableseq_pop" { assert_eq(empty.pop(), None) } +///| test "mutableseq_copy" { let ms = @src.MutableSeq::new("ACGT") let copy = ms.copy() @@ -394,42 +402,49 @@ test "mutableseq_copy" { assert_eq(copy.to_string(), "XCGT") } +///| test "mutableseq_complement" { let ms = @src.MutableSeq::new("ACGT") let comp = ms.complement() assert_eq(comp.to_string(), "TGCA") } +///| test "mutableseq_reverse_complement" { let ms = @src.MutableSeq::new("ACGT") let rc = ms.reverse_complement() assert_eq(rc.to_string(), "ACGT") } +///| test "mutableseq_transcribe" { let ms = @src.MutableSeq::new("ACGT") let rna = ms.transcribe() assert_eq(rna.to_string(), "ACGU") } +///| test "mutableseq_back_transcribe" { let ms = @src.MutableSeq::new("ACGU") let dna = ms.back_transcribe() assert_eq(dna.to_string(), "ACGT") } +///| test "mutableseq_translate" { let ms = @src.MutableSeq::new("ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG") let protein = ms.translate() assert_eq(protein.to_string(), "MAIVMGR*KGAR*") } +///| test "mutableseq_to_seq" { let ms = @src.MutableSeq::new("ACGT") let s = ms.to_seq() assert_eq(s.to_string(), "ACGT") } +///| test "mutableseq_upper_lower" { let ms = @src.MutableSeq::new("acgt") assert_eq(ms.upper().to_string(), "ACGT") @@ -437,6 +452,7 @@ test "mutableseq_upper_lower" { assert_eq(ms2.lower().to_string(), "acgt") } +///| test "mutableseq_count" { let ms = @src.MutableSeq::new("ATATGAAATTTGAAAA") assert_eq(ms.count("AAA"), 2) diff --git a/test/moonbit/bioc_generics_test.mbt b/test/moonbit/bioc_generics_test.mbt index 589c64b2..60fac5a4 100644 --- a/test/moonbit/bioc_generics_test.mbt +++ b/test/moonbit/bioc_generics_test.mbt @@ -1,149 +1,177 @@ ///| /// Tests for BiocGenerics module. - test "na_int" { assert_eq(@src.na_int(), -2147483648) } +///| test "na_double" { let na = @src.na_double() assert_true(na.is_nan()) } +///| test "is_na_int" { assert_true(@src.is_na_int(-2147483648)) assert_false(@src.is_na_int(0)) } +///| test "is_na_double" { assert_true(@src.is_na_double(@double.not_a_number)) assert_false(@src.is_na_double(0.0)) } +///| test "any_na_int" { assert_true(@src.any_na_int([1, 2, -2147483648, 4])) assert_false(@src.any_na_int([1, 2, 3, 4])) } +///| test "na_omit_int" { let result = @src.na_omit_int([1, -2147483648, 3]) assert_eq(result.length(), 2) } +///| test "which_int" { let result = @src.which_int([1, 2, 1, 3], 1) assert_eq(result.length(), 2) } +///| test "which_bool" { let result = @src.which_bool([true, false, true]) assert_eq(result.length(), 2) } +///| test "order_int" { let indices = @src.order_int([3, 1, 2]) assert_eq(indices[0], 1) } +///| test "sort_int" { let result = @src.sort_int([3, 1, 2]) assert_eq(result[0], 1) } +///| test "unique_int" { let result = @src.unique_int([1, 2, 1, 3]) assert_eq(result.length(), 3) } +///| test "unique_string" { let result = @src.unique_string(["a", "b", "a", "c"]) assert_eq(result.length(), 3) } +///| test "match_int" { let result = @src.match_int([1, 3], [1, 2, 4]) assert_eq(result[0], 0) } +///| test "match_string" { let result = @src.match_string(["a", "c"], ["a", "b"]) assert_eq(result[0], 0) } +///| test "intersect_int" { let result = @src.intersect_int([1, 2, 3], [2, 3, 4]) assert_eq(result.length(), 2) } +///| test "intersect_string" { let result = @src.intersect_string(["a", "b"], ["b", "c"]) assert_eq(result.length(), 1) } +///| test "union_int" { let result = @src.union_int([1, 2], [2, 3]) assert_eq(result.length(), 3) } +///| test "setdiff_int" { let result = @src.setdiff_int([1, 2, 3], [2]) assert_eq(result.length(), 2) } +///| test "table_int" { let result = @src.table_int([1, 2, 1, 3, 1]) assert_eq(result.get("1").unwrap(), 3) } +///| test "table_string" { let result = @src.table_string(["a", "b", "a"]) assert_eq(result.get("a").unwrap(), 2) } +///| test "rev_int" { let result = @src.rev_int([1, 2, 3]) assert_eq(result[0], 3) } +///| test "rev_string" { let result = @src.rev_string(["a", "b", "c"]) assert_eq(result[0], "c") } +///| test "rep_int" { let result = @src.rep_int(5, 3) assert_eq(result.length(), 3) } +///| test "seq_int" { let result = @src.seq_int(1, 5) assert_eq(result.length(), 5) } +///| test "seq_double" { let result = @src.seq_double(1.0, 3.0, by=1.0) assert_eq(result.length(), 3) } +///| test "head_int" { let result = @src.head_int([1, 2, 3, 4, 5], 3) assert_eq(result.length(), 3) } +///| test "tail_int" { let result = @src.tail_int([1, 2, 3, 4, 5], 2) assert_eq(result.length(), 2) } +///| test "length_int" { assert_eq(@src.length_int([1, 2, 3]), 3) } +///| test "cbind" { let result = @src.cbind([[1.0, 2.0], [3.0, 4.0]]) assert_eq(result.length(), 2) } +///| test "rbind" { let result = @src.rbind([[1.0, 2.0], [3.0, 4.0]]) assert_eq(result.length(), 2) diff --git a/test/moonbit/bioc_neighbors_test.mbt b/test/moonbit/bioc_neighbors_test.mbt index 2958ae64..cc69bd86 100644 --- a/test/moonbit/bioc_neighbors_test.mbt +++ b/test/moonbit/bioc_neighbors_test.mbt @@ -20,13 +20,7 @@ test "knn_options_with_method" { ///| test "knn_options_full" { - let opts = @src.knn_options_full( - @src.annoy_method(), - 8, - "manhattan", - 30, - 100, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 8, "manhattan", 30, 100) assert_true(opts.method == @src.annoy_method()) assert_eq(opts.k, 8) assert_eq(opts.distance, "manhattan") @@ -60,12 +54,7 @@ test "knn_compute_distance_cosine" { ///| test "knn_brute_force_basic" { - let data = [ - [0.0, 0.0], - [1.0, 0.0], - [0.0, 1.0], - [1.0, 1.0], - ] + let data = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]] let query = [[0.0, 0.0]] let result = @src.knn_brute_force(data, 4, 2, query, 1, 2, "euclidean") assert_eq(result.n_query, 1) @@ -164,13 +153,7 @@ test "build_knn_index_kmknn" { [10.0, 11.0], [11.0, 11.0], ] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 2, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 2, "euclidean", 50, -1) let index = @src.build_knn_index(data, 8, 2, opts) assert_true(index.method == @src.kmknn_method()) assert_true(index.centroids.length() > 0) @@ -188,13 +171,7 @@ test "build_knn_index_annoy" { [10.0, 11.0], [11.0, 11.0], ] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "euclidean", - 5, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "euclidean", 5, -1) let index = @src.build_knn_index(data, 8, 2, opts) assert_true(index.method == @src.annoy_method()) assert_true(index.tree_nodes.length() > 0) @@ -203,13 +180,7 @@ test "build_knn_index_annoy" { ///| test "build_kmknn_index_empty" { let data : Array[Array[Double]] = [] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 2, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 2, "euclidean", 50, -1) let index = @src.build_kmknn_index(data, 0, 2, opts) assert_eq(index.n_points, 0) assert_eq(index.centroids.length(), 0) @@ -218,13 +189,7 @@ test "build_kmknn_index_empty" { ///| test "build_annoy_index_empty" { let data : Array[Array[Double]] = [] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "euclidean", 50, -1) let index = @src.build_annoy_index(data, 0, 2, opts) assert_eq(index.n_points, 0) assert_eq(index.tree_nodes.length(), 0) @@ -259,13 +224,7 @@ test "run_knn_kmknn" { [10.0, 11.0], [11.0, 11.0], ] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 3, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 3, "euclidean", 50, -1) let index = @src.build_knn_index(data, 8, 2, opts) let query = [[0.0, 0.0], [10.0, 10.0]] let result = @src.run_knn(index, query, 2, opts) @@ -285,13 +244,7 @@ test "run_knn_annoy" { [10.0, 11.0], [11.0, 11.0], ] - let opts = @src.knn_options_full( - @src.annoy_method(), - 3, - "euclidean", - 5, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 3, "euclidean", 5, -1) let index = @src.build_knn_index(data, 8, 2, opts) let query = [[0.0, 0.0], [10.0, 10.0]] let result = @src.run_knn(index, query, 2, opts) @@ -302,13 +255,7 @@ test "run_knn_annoy" { ///| test "knn_annoy_cosine_distance" { let data = [[1.0, 0.0], [0.0, 1.0], [1.0, 1.0], [-1.0, 0.0]] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "cosine", - 3, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "cosine", 3, -1) let index = @src.build_annoy_index(data, 4, 2, opts) let query = [[1.0, 0.0]] let result = @src.knn_annoy(index, query, 1, opts) @@ -318,13 +265,7 @@ test "knn_annoy_cosine_distance" { ///| test "knn_kmknn_cosine_distance" { let data = [[1.0, 0.0], [0.0, 1.0], [1.0, 1.0], [-1.0, 0.0]] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 2, - "cosine", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 2, "cosine", 50, -1) let index = @src.build_kmknn_index(data, 4, 2, opts) let query = [[1.0, 0.0]] let result = @src.knn_kmknn(index, query, 1, opts) @@ -370,13 +311,7 @@ test "knn_brute_force_single_dim" { ///| test "knn_kmknn_single_point" { let data = [[1.0, 2.0]] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 1, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 1, "euclidean", 50, -1) let index = @src.build_kmknn_index(data, 1, 2, opts) let query = [[1.0, 2.0]] let result = @src.knn_kmknn(index, query, 1, opts) @@ -386,13 +321,7 @@ test "knn_kmknn_single_point" { ///| test "knn_annoy_single_point" { let data = [[1.0, 2.0]] - let opts = @src.knn_options_full( - @src.annoy_method(), - 1, - "euclidean", - 3, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 1, "euclidean", 3, -1) let index = @src.build_annoy_index(data, 1, 2, opts) let query = [[1.0, 2.0]] let result = @src.knn_annoy(index, query, 1, opts) @@ -413,13 +342,7 @@ test "knn_brute_force_vs_kmknn" { ] let query = [[0.0, 0.0]] let brute_result = @src.knn_brute_force(data, 8, 2, query, 1, 3, "euclidean") - let opts = @src.knn_options_full( - @src.kmknn_method(), - 3, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 3, "euclidean", 50, -1) let index = @src.build_kmknn_index(data, 8, 2, opts) let kmknn_result = @src.knn_kmknn(index, query, 1, opts) assert_eq(brute_result.k, kmknn_result.k) @@ -439,13 +362,7 @@ test "knn_brute_force_vs_annoy" { ] let query = [[0.0, 0.0]] let brute_result = @src.knn_brute_force(data, 8, 2, query, 1, 3, "euclidean") - let opts = @src.knn_options_full( - @src.annoy_method(), - 3, - "euclidean", - 5, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 3, "euclidean", 5, -1) let index = @src.build_annoy_index(data, 8, 2, opts) let annoy_result = @src.knn_annoy(index, query, 1, opts) assert_eq(brute_result.k, 3) @@ -464,13 +381,7 @@ test "knn_brute_force_no_query" { ///| test "build_kmknn_index_small" { let data = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 2, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 2, "euclidean", 50, -1) let index = @src.build_kmknn_index(data, 3, 2, opts) assert_eq(index.n_points, 3) assert_true(index.centroids.length() >= 1) @@ -479,13 +390,7 @@ test "build_kmknn_index_small" { ///| test "build_annoy_index_small" { let data = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "euclidean", - 3, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "euclidean", 3, -1) let index = @src.build_annoy_index(data, 3, 2, opts) assert_eq(index.n_points, 3) assert_true(index.tree_nodes.length() > 0) @@ -494,13 +399,7 @@ test "build_annoy_index_small" { ///| test "knn_kmknn_empty_query" { let data = [[0.0, 0.0], [1.0, 0.0]] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 2, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 2, "euclidean", 50, -1) let index = @src.build_kmknn_index(data, 2, 2, opts) let query : Array[Array[Double]] = [] let result = @src.knn_kmknn(index, query, 0, opts) @@ -510,13 +409,7 @@ test "knn_kmknn_empty_query" { ///| test "knn_annoy_empty_query" { let data = [[0.0, 0.0], [1.0, 0.0]] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "euclidean", - 3, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "euclidean", 3, -1) let index = @src.build_annoy_index(data, 2, 2, opts) let query : Array[Array[Double]] = [] let result = @src.knn_annoy(index, query, 0, opts) @@ -526,13 +419,7 @@ test "knn_annoy_empty_query" { ///| test "knn_annoy_search_k_auto" { let data = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "euclidean", - 3, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "euclidean", 3, -1) let index = @src.build_annoy_index(data, 4, 2, opts) let query = [[0.0, 0.0]] let result = @src.knn_annoy(index, query, 1, opts) @@ -542,13 +429,7 @@ test "knn_annoy_search_k_auto" { ///| test "knn_annoy_search_k_custom" { let data = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "euclidean", - 3, - 1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "euclidean", 3, 1) let index = @src.build_annoy_index(data, 4, 2, opts) let query = [[0.0, 0.0]] let result = @src.knn_annoy(index, query, 1, opts) @@ -613,13 +494,7 @@ test "knn_brute_force_large_k" { ///| test "knn_brute_force_different_k_values" { - let data = [ - [0.0, 0.0], - [1.0, 0.0], - [0.0, 1.0], - [1.0, 1.0], - [2.0, 2.0], - ] + let data = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0], [2.0, 2.0]] let query = [[0.0, 0.0]] let result_k1 = @src.knn_brute_force(data, 5, 2, query, 1, 1, "euclidean") assert_eq(result_k1.k, 1) @@ -663,13 +538,7 @@ test "knn_brute_force_vs_kmknn_same_results" { ] let query = [[0.0, 0.0], [3.0, 3.0]] let brute_result = @src.knn_brute_force(data, 8, 2, query, 2, 3, "euclidean") - let opts = @src.knn_options_full( - @src.kmknn_method(), - 3, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 3, "euclidean", 50, -1) let index = @src.build_kmknn_index(data, 8, 2, opts) let kmknn_result = @src.knn_kmknn(index, query, 2, opts) assert_eq(brute_result.n_query, kmknn_result.n_query) @@ -690,13 +559,7 @@ test "knn_annoy_approximately_correct" { ] let query = [[0.0, 0.0]] let brute_result = @src.knn_brute_force(data, 8, 2, query, 1, 3, "euclidean") - let opts = @src.knn_options_full( - @src.annoy_method(), - 3, - "euclidean", - 10, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 3, "euclidean", 10, -1) let index = @src.build_annoy_index(data, 8, 2, opts) let annoy_result = @src.knn_annoy(index, query, 1, opts) assert_true(annoy_result.k >= 1) @@ -721,13 +584,7 @@ test "knn_brute_force_cosine_3d" { ///| test "knn_kmknn_manhattan_distance" { let data = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 2, - "manhattan", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 2, "manhattan", 50, -1) let index = @src.build_kmknn_index(data, 4, 2, opts) let query = [[0.0, 0.0]] let result = @src.knn_kmknn(index, query, 1, opts) @@ -778,13 +635,7 @@ test "knn_quick_sort_duplicates" { ///| test "knn_kmknn_empty_data" { let data : Array[Array[Double]] = [] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 2, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 2, "euclidean", 50, -1) let index = @src.build_kmknn_index(data, 0, 2, opts) let query = [[0.0, 0.0]] let result = @src.knn_kmknn(index, query, 1, opts) @@ -795,13 +646,7 @@ test "knn_kmknn_empty_data" { ///| test "knn_annoy_manhattan_distance" { let data = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "manhattan", - 5, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "manhattan", 5, -1) let index = @src.build_annoy_index(data, 4, 2, opts) let query = [[0.0, 0.0]] let result = @src.knn_annoy(index, query, 1, opts) @@ -859,13 +704,7 @@ test "knn_brute_force_5d" { ///| test "build_knn_index_kmknn_small_data" { let data = [[1.0, 2.0]] - let opts = @src.knn_options_full( - @src.kmknn_method(), - 1, - "euclidean", - 50, - -1, - ) + let opts = @src.knn_options_full(@src.kmknn_method(), 1, "euclidean", 50, -1) let index = @src.build_knn_index(data, 1, 2, opts) assert_true(index.method == @src.kmknn_method()) assert_eq(index.n_points, 1) @@ -874,15 +713,9 @@ test "build_knn_index_kmknn_small_data" { ///| test "run_knn_annoy_multiple_queries" { let data = [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]] - let opts = @src.knn_options_full( - @src.annoy_method(), - 2, - "euclidean", - 3, - -1, - ) + let opts = @src.knn_options_full(@src.annoy_method(), 2, "euclidean", 3, -1) let index = @src.build_knn_index(data, 4, 2, opts) let query = [[0.0, 0.0], [1.0, 1.0], [0.0, 1.0]] let result = @src.run_knn(index, query, 3, opts) assert_eq(result.n_query, 3) -} \ No newline at end of file +} diff --git a/test/moonbit/bioc_parallel_test.mbt b/test/moonbit/bioc_parallel_test.mbt index 217d334c..445366cb 100644 --- a/test/moonbit/bioc_parallel_test.mbt +++ b/test/moonbit/bioc_parallel_test.mbt @@ -1,18 +1,19 @@ ///| /// Tests for BiocParallel module. - test "BPPARAM creation" { let params = @src.create_example_bpparam() assert_eq(params.workers, 4) assert_eq(params.progressbar, true) } +///| test "BPJob creation" { let job = @src.create_example_bpjob() assert_eq(job.name, "example_job") assert_eq(job.tasks.length(), 4) } +///| test "bp_sum" { let data : Array[Array[Double]] = Array::new() let chunk1 : Array[Double] = Array::new() @@ -20,18 +21,19 @@ test "bp_sum" { chunk1.push(2.0) chunk1.push(3.0) data.push(chunk1) - + let chunk2 : Array[Double] = Array::new() chunk2.push(4.0) chunk2.push(5.0) chunk2.push(6.0) data.push(chunk2) - + let params = @src.BPPARAM::new(2, false, 120) let result = @src.bp_sum(data, params) assert_eq(result, 21.0) } +///| test "bp_mean" { let data : Array[Double] = Array::new() data.push(1.0) @@ -39,7 +41,7 @@ test "bp_mean" { data.push(3.0) data.push(4.0) data.push(5.0) - + let result = @src.bp_mean_simple(data, 2) assert_eq(result, 3.0) -} \ No newline at end of file +} diff --git a/test/moonbit/bioc_singular_test.mbt b/test/moonbit/bioc_singular_test.mbt index 2a30207a..a69cde59 100644 --- a/test/moonbit/bioc_singular_test.mbt +++ b/test/moonbit/bioc_singular_test.mbt @@ -431,14 +431,9 @@ test "svd_options_equality" { ///| test "exact_svd_larger_matrix_sorted" { - let matrix = [ - 1.0, 2.0, 3.0, - 2.0, 3.0, 4.0, - 3.0, 4.0, 5.0, - 4.0, 5.0, 6.0, - ] + let matrix = [1.0, 2.0, 3.0, 2.0, 3.0, 4.0, 3.0, 4.0, 5.0, 4.0, 5.0, 6.0] let result = @src.run_exact_svd(matrix, 4, 3, 0) assert_eq(result.rank, 3) assert_true(result.d[0] >= result.d[1]) assert_true(result.d[1] >= result.d[2]) -} \ No newline at end of file +} diff --git a/test/moonbit/biostrings_matchdict_test.mbt b/test/moonbit/biostrings_matchdict_test.mbt index 019c0806..689fe37a 100644 --- a/test/moonbit/biostrings_matchdict_test.mbt +++ b/test/moonbit/biostrings_matchdict_test.mbt @@ -24,7 +24,11 @@ test "bmd_create_pdict_empty" { ///| test "bmd_create_pdict_with_indels" { - let pdict = @src.bmd_create_pdict(patterns=["ATG"], max_mismatches=1, with_indels=true) + let pdict = @src.bmd_create_pdict( + patterns=["ATG"], + max_mismatches=1, + with_indels=true, + ) assert_eq(pdict.with_indels, true) assert_eq(pdict.max_mismatches, 1) } @@ -32,7 +36,7 @@ test "bmd_create_pdict_with_indels" { ///| test "bmd_match_pdict_single_pattern" { let pdict = @src.bmd_create_pdict(patterns=["ATG"]) - let result = @src.bmd_match_pdict(pdict=pdict, subject="AATGCTAG") + let result = @src.bmd_match_pdict(pdict~, subject="AATGCTAG") assert_eq(result.hits.length(), 1) assert_eq(result.hits[0].pattern, "ATG") assert_eq(result.hits[0].start, 2) @@ -43,7 +47,7 @@ test "bmd_match_pdict_single_pattern" { ///| test "bmd_match_pdict_multiple_patterns" { let pdict = @src.bmd_create_pdict(patterns=["ATG", "GCT"]) - let result = @src.bmd_match_pdict(pdict=pdict, subject="ATGGCT") + let result = @src.bmd_match_pdict(pdict~, subject="ATGGCT") assert_eq(result.hits.length(), 2) assert_eq(result.hits[0].pattern, "ATG") assert_eq(result.hits[1].pattern, "GCT") @@ -52,21 +56,21 @@ test "bmd_match_pdict_multiple_patterns" { ///| test "bmd_match_pdict_overlapping_hits" { let pdict = @src.bmd_create_pdict(patterns=["AAA"]) - let result = @src.bmd_match_pdict(pdict=pdict, subject="AAAA") + let result = @src.bmd_match_pdict(pdict~, subject="AAAA") assert_eq(result.hits.length(), 2) } ///| test "bmd_match_pdict_no_match" { let pdict = @src.bmd_create_pdict(patterns=["XYZ"]) - let result = @src.bmd_match_pdict(pdict=pdict, subject="ATGC") + let result = @src.bmd_match_pdict(pdict~, subject="ATGC") assert_eq(result.hits.length(), 0) } ///| test "bmd_match_pdict_empty_subject" { let pdict = @src.bmd_create_pdict(patterns=["ATG"]) - let result = @src.bmd_match_pdict(pdict=pdict, subject="") + let result = @src.bmd_match_pdict(pdict~, subject="") assert_eq(result.hits.length(), 0) assert_eq(result.subject_length, 0) } @@ -74,14 +78,14 @@ test "bmd_match_pdict_empty_subject" { ///| test "bmd_match_pdict_empty_patterns" { let pdict = @src.bmd_create_pdict(patterns=[]) - let result = @src.bmd_match_pdict(pdict=pdict, subject="ATGC") + let result = @src.bmd_match_pdict(pdict~, subject="ATGC") assert_eq(result.hits.length(), 0) } ///| test "bmd_match_pdict_with_mismatches" { let pdict = @src.bmd_create_pdict(patterns=["ATG"], max_mismatches=1) - let result = @src.bmd_match_pdict(pdict=pdict, subject="AXG") + let result = @src.bmd_match_pdict(pdict~, subject="AXG") assert_eq(result.hits.length(), 1) assert_eq(result.hits[0].mismatches, 1) } @@ -89,21 +93,21 @@ test "bmd_match_pdict_with_mismatches" { ///| test "bmd_match_pdict_mismatch_too_many" { let pdict = @src.bmd_create_pdict(patterns=["ATG"], max_mismatches=1) - let result = @src.bmd_match_pdict(pdict=pdict, subject="XYZ") + let result = @src.bmd_match_pdict(pdict~, subject="XYZ") assert_eq(result.hits.length(), 0) } ///| test "bmd_match_pdict_pattern_longer_than_subject" { let pdict = @src.bmd_create_pdict(patterns=["ATGCT"]) - let result = @src.bmd_match_pdict(pdict=pdict, subject="AT") + let result = @src.bmd_match_pdict(pdict~, subject="AT") assert_eq(result.hits.length(), 0) } ///| test "bmd_vcount_pattern_basic" { let subjects = ["ATGATG", "ATGCAT", "CCCCCC"] - let result = @src.bmd_vcount_pattern(pattern="ATG", subjects=subjects) + let result = @src.bmd_vcount_pattern(pattern="ATG", subjects~) assert_eq(result.pattern, "ATG") assert_eq(result.counts.length(), 3) assert_eq(result.counts[0], 2) @@ -115,7 +119,7 @@ test "bmd_vcount_pattern_basic" { ///| test "bmd_vcount_pattern_no_match" { let subjects = ["CCCC", "GGGG", "TTTT"] - let result = @src.bmd_vcount_pattern(pattern="AAAA", subjects=subjects) + let result = @src.bmd_vcount_pattern(pattern="AAAA", subjects~) assert_eq(result.total, 0) assert_eq(result.counts[0], 0) assert_eq(result.counts[1], 0) @@ -125,7 +129,11 @@ test "bmd_vcount_pattern_no_match" { ///| test "bmd_vcount_pattern_with_mismatches" { let subjects = ["AXG", "AYG", "AZG", "ATG"] - let result = @src.bmd_vcount_pattern(pattern="ATG", subjects=subjects, max_mismatches=1) + let result = @src.bmd_vcount_pattern( + pattern="ATG", + subjects~, + max_mismatches=1, + ) assert_eq(result.counts[0], 1) assert_eq(result.counts[1], 1) assert_eq(result.counts[2], 1) @@ -136,7 +144,7 @@ test "bmd_vcount_pattern_with_mismatches" { ///| test "bmd_vcount_pattern_empty_pattern" { let subjects = ["ATGC", "GCAT"] - let result = @src.bmd_vcount_pattern(pattern="", subjects=subjects) + let result = @src.bmd_vcount_pattern(pattern="", subjects~) assert_eq(result.total, 0) assert_eq(result.counts.length(), 2) } @@ -144,7 +152,7 @@ test "bmd_vcount_pattern_empty_pattern" { ///| test "bmd_vcount_pattern_empty_subjects" { let subjects : Array[String] = [] - let result = @src.bmd_vcount_pattern(pattern="ATG", subjects=subjects) + let result = @src.bmd_vcount_pattern(pattern="ATG", subjects~) assert_eq(result.total, 0) assert_eq(result.counts.length(), 0) } @@ -153,7 +161,7 @@ test "bmd_vcount_pattern_empty_subjects" { test "bmd_vmatch_pattern_basic" { let patterns = ["ATG", "CCC"] let subjects = ["ATGATG", "CCCCCC"] - let results = @src.bmd_vmatch_pattern(patterns=patterns, subjects=subjects) + let results = @src.bmd_vmatch_pattern(patterns~, subjects~) assert_eq(results.length(), 2) assert_eq(results[0].pattern, "ATG") assert_eq(results[0].total, 2) @@ -165,7 +173,7 @@ test "bmd_vmatch_pattern_basic" { test "bmd_vmatch_pattern_multiple_subjects" { let patterns = ["ATG"] let subjects = ["ATGATG", "ATXATG", "TTTTTT"] - let results = @src.bmd_vmatch_pattern(patterns=patterns, subjects=subjects) + let results = @src.bmd_vmatch_pattern(patterns~, subjects~) assert_eq(results.length(), 1) assert_eq(results[0].counts[0], 2) assert_eq(results[0].counts[2], 0) @@ -181,7 +189,7 @@ test "bmd_vmatch_pattern_empty" { test "bmd_which_basic" { let pdict = @src.bmd_create_pdict(patterns=["ATG"]) let subjects = ["ATGCTA", "TTTTTT", "ATGCAT"] - let result = @src.bmd_which(pdict=pdict, subjects=subjects) + let result = @src.bmd_which(pdict~, subjects~) assert_eq(result.length(), 3) assert_eq(result[0], true) assert_eq(result[1], false) @@ -192,7 +200,7 @@ test "bmd_which_basic" { test "bmd_which_no_match" { let pdict = @src.bmd_create_pdict(patterns=["ZZZZZ"]) let subjects = ["ATGC", "GCAT"] - let result = @src.bmd_which(pdict=pdict, subjects=subjects) + let result = @src.bmd_which(pdict~, subjects~) assert_eq(result[0], false) assert_eq(result[1], false) } @@ -201,7 +209,7 @@ test "bmd_which_no_match" { test "bmd_which_empty_pdict" { let pdict = @src.bmd_create_pdict(patterns=[]) let subjects = ["ATGC", "GCAT"] - let result = @src.bmd_which(pdict=pdict, subjects=subjects) + let result = @src.bmd_which(pdict~, subjects~) assert_eq(result[0], false) assert_eq(result[1], false) } @@ -210,7 +218,7 @@ test "bmd_which_empty_pdict" { test "bmd_which_index_basic" { let pdict = @src.bmd_create_pdict(patterns=["ATG"]) let subjects = ["TTTT", "ATGC", "GGGG", "ATGG"] - let indices = @src.bmd_which_index(pdict=pdict, subjects=subjects) + let indices = @src.bmd_which_index(pdict~, subjects~) assert_eq(indices.length(), 2) assert_eq(indices[0], 1) assert_eq(indices[1], 3) @@ -220,42 +228,42 @@ test "bmd_which_index_basic" { test "bmd_which_index_no_match" { let pdict = @src.bmd_create_pdict(patterns=["ZZZZ"]) let subjects = ["ATGC", "GCAT"] - let indices = @src.bmd_which_index(pdict=pdict, subjects=subjects) + let indices = @src.bmd_which_index(pdict~, subjects~) assert_eq(indices.length(), 0) } ///| test "bmd_count_occurrences_basic" { let pdict = @src.bmd_create_pdict(patterns=["ATG"]) - let count = @src.bmd_count_occurrences(pdict=pdict, subject="ATGATGATG") + let count = @src.bmd_count_occurrences(pdict~, subject="ATGATGATG") assert_eq(count, 3) } ///| test "bmd_count_occurrences_multiple_patterns" { let pdict = @src.bmd_create_pdict(patterns=["AT", "TG"]) - let count = @src.bmd_count_occurrences(pdict=pdict, subject="ATGATG") + let count = @src.bmd_count_occurrences(pdict~, subject="ATGATG") assert_eq(count, 4) } ///| test "bmd_count_occurrences_no_match" { let pdict = @src.bmd_create_pdict(patterns=["ZZZZ"]) - let count = @src.bmd_count_occurrences(pdict=pdict, subject="ATGC") + let count = @src.bmd_count_occurrences(pdict~, subject="ATGC") assert_eq(count, 0) } ///| test "bmd_count_occurrences_empty" { let pdict = @src.bmd_create_pdict(patterns=[""]) - let count = @src.bmd_count_occurrences(pdict=pdict, subject="ATGC") + let count = @src.bmd_count_occurrences(pdict~, subject="ATGC") assert_eq(count, 0) } ///| test "bmd_find_best_match_exact" { let pdict = @src.bmd_create_pdict(patterns=["ATG"]) - let best = @src.bmd_find_best_match(pdict=pdict, subject="AATGCT") + let best = @src.bmd_find_best_match(pdict~, subject="AATGCT") assert_true(best is Some(_)) assert_eq(best.unwrap().pattern, "ATG") assert_eq(best.unwrap().start, 2) @@ -263,8 +271,11 @@ test "bmd_find_best_match_exact" { ///| test "bmd_find_best_match_with_mismatches" { - let pdict = @src.bmd_create_pdict(patterns=["ATG", "AXG", "AYG"], max_mismatches=1) - let best = @src.bmd_find_best_match(pdict=pdict, subject="AAAG") + let pdict = @src.bmd_create_pdict( + patterns=["ATG", "AXG", "AYG"], + max_mismatches=1, + ) + let best = @src.bmd_find_best_match(pdict~, subject="AAAG") assert_true(best is Some(_)) assert_eq(best.unwrap().mismatches, 1) assert_eq(best.unwrap().pattern, "ATG") @@ -273,14 +284,14 @@ test "bmd_find_best_match_with_mismatches" { ///| test "bmd_find_best_match_no_hit" { let pdict = @src.bmd_create_pdict(patterns=["ZZZZZ"]) - let best = @src.bmd_find_best_match(pdict=pdict, subject="ATGC") + let best = @src.bmd_find_best_match(pdict~, subject="ATGC") assert_true(best is None) } ///| test "bmd_find_best_match_multiple_hits" { let pdict = @src.bmd_create_pdict(patterns=["ATG"], max_mismatches=2) - let best = @src.bmd_find_best_match(pdict=pdict, subject="AATGCTXG") + let best = @src.bmd_find_best_match(pdict~, subject="AATGCTXG") assert_true(best is Some(_)) assert_eq(best.unwrap().pattern, "ATG") assert_eq(best.unwrap().mismatches, 0) @@ -290,7 +301,7 @@ test "bmd_find_best_match_multiple_hits" { test "bmd_which_with_mismatches" { let pdict = @src.bmd_create_pdict(patterns=["ATG"], max_mismatches=1) let subjects = ["AXGCTA", "TTTTTT", "AYGCAT"] - let result = @src.bmd_which(pdict=pdict, subjects=subjects) + let result = @src.bmd_which(pdict~, subjects~) assert_eq(result[0], true) assert_eq(result[1], false) assert_eq(result[2], true) @@ -299,7 +310,7 @@ test "bmd_which_with_mismatches" { ///| test "bmd_vcount_pattern_single_subject" { let subjects = ["AAAA"] - let result = @src.bmd_vcount_pattern(pattern="AA", subjects=subjects) + let result = @src.bmd_vcount_pattern(pattern="AA", subjects~) assert_eq(result.counts.length(), 1) assert_eq(result.counts[0], 3) assert_eq(result.total, 3) @@ -308,7 +319,7 @@ test "bmd_vcount_pattern_single_subject" { ///| test "bmd_match_pdict_hit_properties" { let pdict = @src.bmd_create_pdict(patterns=["ATG", "TGC"]) - let result = @src.bmd_match_pdict(pdict=pdict, subject="ATGC") + let result = @src.bmd_match_pdict(pdict~, subject="ATGC") assert_eq(result.hits.length(), 2) assert_eq(result.hits[0].pattern_idx, 0) assert_eq(result.hits[0].width, 3) @@ -321,7 +332,7 @@ test "bmd_match_pdict_hit_properties" { ///| test "bmd_count_occurrences_overlapping" { let pdict = @src.bmd_create_pdict(patterns=["AA"]) - let count = @src.bmd_count_occurrences(pdict=pdict, subject="AAAA") + let count = @src.bmd_count_occurrences(pdict~, subject="AAAA") assert_eq(count, 3) } @@ -329,7 +340,7 @@ test "bmd_count_occurrences_overlapping" { test "bmd_vmatch_pattern_multiple_mismatches" { let patterns = ["ATG", "CCC"] let subjects = ["AXGATG", "CXCCCX"] - let results = @src.bmd_vmatch_pattern(patterns=patterns, subjects=subjects, max_mismatches=1) + let results = @src.bmd_vmatch_pattern(patterns~, subjects~, max_mismatches=1) assert_eq(results.length(), 2) assert_eq(results[0].counts[0], 2) assert_eq(results[1].counts[1], 4) diff --git a/test/moonbit/blast_applications_test.mbt b/test/moonbit/blast_applications_test.mbt index f783bc19..7ea80a30 100644 --- a/test/moonbit/blast_applications_test.mbt +++ b/test/moonbit/blast_applications_test.mbt @@ -274,7 +274,9 @@ test "blastapp_validate" { ///| test "blastapp_param_spec" { - let spec = @src.BlastParamSpec::new("-evalue", "E-value threshold", true, "10.0", false) + let spec = @src.BlastParamSpec::new( + "-evalue", "E-value threshold", true, "10.0", false, + ) assert_eq(spec.name, "-evalue") assert_eq(spec.description, "E-value threshold") assert_true(spec.takes_value) diff --git a/test/moonbit/bsseq_test.mbt b/test/moonbit/bsseq_test.mbt index a7280c6b..e3775313 100644 --- a/test/moonbit/bsseq_test.mbt +++ b/test/moonbit/bsseq_test.mbt @@ -260,7 +260,10 @@ test "bsseq_find_hypo_dmr" { ///| test "bsseq_compute_methylation_diff" { assert_eq(@src.bsseq_compute_methylation_diff(0.8, 0.3), 0.5) - assert_true(@src.bsseq_compute_methylation_diff(0.1, 0.4) > -0.31 && @src.bsseq_compute_methylation_diff(0.1, 0.4) < -0.29) + assert_true( + @src.bsseq_compute_methylation_diff(0.1, 0.4) > -0.31 && + @src.bsseq_compute_methylation_diff(0.1, 0.4) < -0.29, + ) assert_eq(@src.bsseq_compute_methylation_diff(0.5, 0.5), 0.0) } diff --git a/test/moonbit/bumphunter_test.mbt b/test/moonbit/bumphunter_test.mbt index fc1fc622..8195361f 100644 --- a/test/moonbit/bumphunter_test.mbt +++ b/test/moonbit/bumphunter_test.mbt @@ -13,6 +13,7 @@ test "bump_position_creation" { assert_eq(p.values()[0], 0.5) } +///| test "bump_region_creation" { let r = @src.BumpRegion::new("chr1", 1000, 2000, 3.5, 10.0, 0, 5) assert_eq(r.chrom(), "chr1") @@ -25,10 +26,9 @@ test "bump_region_creation" { assert_eq(r.length(), 1000) } +///| test "bump_result_creation" { - let r = @src.BumpResult::new( - "chr1", 1000, 2000, 3.5, 10.0, 0.01, 0.05, 0, 5, - ) + let r = @src.BumpResult::new("chr1", 1000, 2000, 3.5, 10.0, 0.01, 0.05, 0, 5) assert_eq(r.chrom(), "chr1") assert_eq(r.start(), 1000) assert_eq(r.end_(), 2000) @@ -44,20 +44,18 @@ test "bump_result_creation" { // t-statistic computation // --------------------------------------------------------------------------- +///| test "bump_t_statistics_clear_difference" { // Position with clear difference between groups - let positions = [ - @src.BumpPosition::new("chr1", 100, [1.0, 1.0, 5.0, 5.0]), - ] + let positions = [@src.BumpPosition::new("chr1", 100, [1.0, 1.0, 5.0, 5.0])] let stats = @src.bump_compute_t_statistics_test(positions, 2) // Group1 mean=1, Group2 mean=5 => negative t-stat assert_true(stats[0] < 0.0) } +///| test "bump_t_statistics_no_difference" { - let positions = [ - @src.BumpPosition::new("chr1", 100, [3.0, 3.0, 3.0, 3.0]), - ] + let positions = [@src.BumpPosition::new("chr1", 100, [3.0, 3.0, 3.0, 3.0])] let stats = @src.bump_compute_t_statistics_test(positions, 2) assert_eq(stats[0], 0.0) } @@ -66,6 +64,7 @@ test "bump_t_statistics_no_difference" { // Smoothing // --------------------------------------------------------------------------- +///| test "bump_smooth_basic" { let stats = [1.0, 2.0, 3.0, 4.0, 5.0] let smoothed = @src.bump_smooth_test(stats, 1) @@ -77,6 +76,7 @@ test "bump_smooth_basic" { assert_eq(smoothed[4], 4.5) } +///| test "bump_smooth_preserves_constant" { let stats = [5.0, 5.0, 5.0, 5.0] let smoothed = @src.bump_smooth_test(stats, 1) @@ -89,6 +89,7 @@ test "bump_smooth_preserves_constant" { // Candidate bump finding // --------------------------------------------------------------------------- +///| test "bump_find_candidates_basic" { let positions = [ @src.BumpPosition::new("chr1", 100, [0.0]), @@ -104,6 +105,7 @@ test "bump_find_candidates_basic" { assert_eq(bumps[0].value(), 4.0) } +///| test "bump_find_candidates_none" { let positions = [ @src.BumpPosition::new("chr1", 100, [0.0]), @@ -114,6 +116,7 @@ test "bump_find_candidates_none" { assert_eq(bumps.length(), 0) } +///| test "bump_find_candidates_negative_values" { let positions = [ @src.BumpPosition::new("chr1", 100, [0.0]), @@ -127,6 +130,7 @@ test "bump_find_candidates_negative_values" { assert_true(bumps[0].value() < 0.0) } +///| test "bump_find_candidates_chromosome_boundary" { let positions = [ @src.BumpPosition::new("chr1", 100, [3.0]), @@ -144,6 +148,7 @@ test "bump_find_candidates_chromosome_boundary" { // Full analysis pipeline // --------------------------------------------------------------------------- +///| test "bump_hunt_detects_known_bump" { let data = @src.bump_sample_data() let results = @src.bump_hunt(data, 4, 2.0, 2, 20) @@ -153,17 +158,20 @@ test "bump_hunt_detects_known_bump" { assert_eq(results[0].chrom(), "chr1") } +///| test "bump_hunt_empty_input" { let results = @src.bump_hunt([], 4, 2.0, 2, 10) assert_eq(results.length(), 0) } +///| test "bump_hunt_zero_group_size" { let data = @src.bump_sample_data() let results = @src.bump_hunt(data, 0, 2.0, 2, 10) assert_eq(results.length(), 0) } +///| test "bump_hunt_high_cutoff_finds_nothing" { let data = @src.bump_sample_data() // Very high cutoff should find no bumps @@ -171,6 +179,7 @@ test "bump_hunt_high_cutoff_finds_nothing" { assert_eq(results.length(), 0) } +///| test "bump_hunt_result_has_valid_pvalue" { let data = @src.bump_sample_data() let results = @src.bump_hunt(data, 4, 2.0, 2, 20) @@ -180,6 +189,7 @@ test "bump_hunt_result_has_valid_pvalue" { } } +///| test "bump_hunt_result_has_valid_fdr" { let data = @src.bump_sample_data() let results = @src.bump_hunt(data, 4, 2.0, 2, 20) @@ -193,6 +203,7 @@ test "bump_hunt_result_has_valid_fdr" { // Sample data // --------------------------------------------------------------------------- +///| test "bump_sample_data_structure" { let data = @src.bump_sample_data() assert_eq(data.length(), 30) @@ -204,11 +215,24 @@ test "bump_sample_data_structure" { assert_eq(data[29].pos(), 3900) } +///| test "bump_sample_data_has_bump_signal" { let data = @src.bump_sample_data() // Cases (first 4 samples) should have higher values in positions 10-20 - let case_mean_at_5 = (data[5].values()[0] + data[5].values()[1] + data[5].values()[2] + data[5].values()[3]) / 4.0 - let case_mean_at_15 = (data[15].values()[0] + data[15].values()[1] + data[15].values()[2] + data[15].values()[3]) / 4.0 + let case_mean_at_5 = ( + data[5].values()[0] + + data[5].values()[1] + + data[5].values()[2] + + data[5].values()[3] + ) / + 4.0 + let case_mean_at_15 = ( + data[15].values()[0] + + data[15].values()[1] + + data[15].values()[2] + + data[15].values()[3] + ) / + 4.0 // Position 15 (in bump region) should have higher case mean than position 5 (outside) assert_true(case_mean_at_15 > case_mean_at_5) } @@ -217,16 +241,16 @@ test "bump_sample_data_has_bump_signal" { // Output formatting // --------------------------------------------------------------------------- +///| test "bump_result_to_string" { - let r = @src.BumpResult::new( - "chr1", 1000, 2000, 3.5, 10.0, 0.01, 0.05, 0, 5, - ) + let r = @src.BumpResult::new("chr1", 1000, 2000, 3.5, 10.0, 0.01, 0.05, 0, 5) let s = r.to_string() assert_true(s.contains("chr1")) assert_true(s.contains("1000")) assert_true(s.contains("2000")) } +///| test "bump_results_to_string" { let results = [ @src.BumpResult::new("chr1", 1000, 2000, 3.5, 10.0, 0.01, 0.05, 0, 5), @@ -240,6 +264,7 @@ test "bump_results_to_string" { // Area computation // --------------------------------------------------------------------------- +///| test "bump_area_is_sum_of_smoothed" { let positions = [ @src.BumpPosition::new("chr1", 100, [0.0]), @@ -258,6 +283,7 @@ test "bump_area_is_sum_of_smoothed" { // Bump length // --------------------------------------------------------------------------- +///| test "bump_length_calculation" { let r = @src.BumpRegion::new("chr1", 1000, 2500, 3.0, 9.0, 0, 3) assert_eq(r.length(), 1500) diff --git a/test/moonbit/caps_test.mbt b/test/moonbit/caps_test.mbt index 8d680a80..1226c2e6 100644 --- a/test/moonbit/caps_test.mbt +++ b/test/moonbit/caps_test.mbt @@ -6,9 +6,7 @@ // --------------------------------------------------------------------------- test "caps_differential_cutsite_creation" { - let dc = @src.CapsDifferentialCutsite::new( - 11, "EcoRI", [0], [1], - ) + let dc = @src.CapsDifferentialCutsite::new(11, "EcoRI", [0], [1]) assert_eq(dc.start(), 11) assert_eq(dc.enzyme_name(), "EcoRI") assert_eq(dc.cuts_in().length(), 1) @@ -17,10 +15,9 @@ test "caps_differential_cutsite_creation" { assert_eq(dc.blocked_in()[0], 1) } +///| test "caps_differential_cutsite_to_string" { - let dc = @src.CapsDifferentialCutsite::new( - 11, "EcoRI", [0], [1], - ) + let dc = @src.CapsDifferentialCutsite::new(11, "EcoRI", [0], [1]) let s = dc.to_string() assert_true(s.contains("DifferentialCutsite")) assert_true(s.contains("pos=11")) @@ -33,6 +30,7 @@ test "caps_differential_cutsite_to_string" { // CAPS map construction // --------------------------------------------------------------------------- +///| test "caps_map_basic" { let seqs = @src.caps_sample_sequences() let enzymes = @src.caps_sample_enzymes() @@ -42,6 +40,7 @@ test "caps_map_basic" { assert_true(m.enzymes().length() >= 1) } +///| test "caps_map_named" { let seqs = @src.caps_sample_sequences() let enzymes = @src.caps_sample_enzymes() @@ -51,6 +50,7 @@ test "caps_map_named" { assert_eq(m.sequence_names()[1], "strainB") } +///| test "caps_map_empty_sequences" { let enzymes = @src.caps_sample_enzymes() let m = @src.caps_map([], enzymes) @@ -59,6 +59,7 @@ test "caps_map_empty_sequences" { assert_eq(m.dcut_count(), 0) } +///| test "caps_map_single_sequence" { // Single sequence: no differential cutting possible let enzymes = @src.caps_sample_enzymes() @@ -71,6 +72,7 @@ test "caps_map_single_sequence" { // Differential cutsite detection // --------------------------------------------------------------------------- +///| test "caps_detects_ecori_differential" { let seqs = @src.caps_sample_sequences() let enzymes = @src.caps_sample_enzymes() @@ -86,6 +88,7 @@ test "caps_detects_ecori_differential" { assert_eq(dc.blocked_in()[0], 1) } +///| test "caps_no_differential_for_identical_sequences" { // Identical sequences: no differential cutting let enzymes = @src.caps_sample_enzymes() @@ -97,6 +100,7 @@ test "caps_no_differential_for_identical_sequences" { assert_eq(m.dcut_count(), 0) } +///| test "caps_no_differential_without_enzyme_site" { // No enzyme recognition site in either sequence let enzymes = @src.caps_sample_enzymes() @@ -107,16 +111,14 @@ test "caps_no_differential_without_enzyme_site" { assert_eq(m.dcut_count(), 0) } +///| test "caps_multiple_differential_cutsites" { // Two sequences with multiple differential sites // seq0: GAATTC...AAGCTT (EcoRI + HindIII sites) // seq1: GAATTT...AAGCTT (only HindIII site) let enzymes = @src.caps_sample_enzymes() let m = @src.caps_map( - [ - "AAAAAAAAGAGAATTCAAAAAGCTTAAAAAA", - "AAAAAAAAGAGAATTTAAAAAGCTTAAAAAA", - ], + ["AAAAAAAAGAGAATTCAAAAAGCTTAAAAAA", "AAAAAAAAGAGAATTTAAAAAGCTTAAAAAA"], enzymes, ) // EcoRI should produce a differential cutsite @@ -131,6 +133,7 @@ test "caps_multiple_differential_cutsites" { // Query methods // --------------------------------------------------------------------------- +///| test "caps_get_dcuts_at_position" { let seqs = @src.caps_sample_sequences() let enzymes = @src.caps_sample_enzymes() @@ -140,6 +143,7 @@ test "caps_get_dcuts_at_position" { assert_true(dcuts.length() >= 1) } +///| test "caps_has_dcuts_for_enzyme" { let seqs = @src.caps_sample_sequences() let enzymes = @src.caps_sample_enzymes() @@ -149,6 +153,7 @@ test "caps_has_dcuts_for_enzyme" { assert_true(!m.has_dcuts_for_enzyme("HindIII")) } +///| test "caps_dcut_count" { let seqs = @src.caps_sample_sequences() let enzymes = @src.caps_sample_enzymes() @@ -161,6 +166,7 @@ test "caps_dcut_count" { // Formatting // --------------------------------------------------------------------------- +///| test "caps_map_to_string" { let seqs = @src.caps_sample_sequences() let enzymes = @src.caps_sample_enzymes() @@ -171,6 +177,7 @@ test "caps_map_to_string" { assert_true(s.contains("length=30")) } +///| test "caps_map_report" { let seqs = @src.caps_sample_sequences() let enzymes = @src.caps_sample_enzymes() @@ -181,6 +188,7 @@ test "caps_map_report" { assert_true(r.contains("EcoRI")) } +///| test "caps_map_report_no_dcuts" { let enzymes = @src.caps_sample_enzymes() let m = @src.caps_map( @@ -195,6 +203,7 @@ test "caps_map_report_no_dcuts" { // Sample data // --------------------------------------------------------------------------- +///| test "caps_sample_sequences_length" { let seqs = @src.caps_sample_sequences() assert_eq(seqs.length(), 2) @@ -203,6 +212,7 @@ test "caps_sample_sequences_length" { assert_eq(seqs[0].length(), 30) } +///| test "caps_sample_sequences_ecori_site" { let seqs = @src.caps_sample_sequences() // seq0 should contain GAATTC (EcoRI site) @@ -212,6 +222,7 @@ test "caps_sample_sequences_ecori_site" { assert_true(!seqs[1].contains("GAATTC")) } +///| test "caps_sample_enzymes" { let enzymes = @src.caps_sample_enzymes() // Should contain EcoRI and HindIII @@ -219,8 +230,12 @@ test "caps_sample_enzymes" { let mut has_ecori = false let mut has_hindiii = false for e in enzymes { - if e.name == "EcoRI" { has_ecori = true } - if e.name == "HindIII" { has_hindiii = true } + if e.name == "EcoRI" { + has_ecori = true + } + if e.name == "HindIII" { + has_hindiii = true + } } assert_true(has_ecori) assert_true(has_hindiii) @@ -230,14 +245,15 @@ test "caps_sample_enzymes" { // Edge cases // --------------------------------------------------------------------------- +///| test "caps_three_sequences_differential" { // Three sequences: seq0 cut, seq1 not cut, seq2 cut let enzymes = @src.caps_sample_enzymes() let m = @src.caps_map( [ "AAAAAAAAGAGAATTCAAAAAAAAAAAAAA", // has GAATTC - "AAAAAAAAGAGAATTTAAAAAAAAAAAAAA", // has GAATTT (no cut) - "AAAAAAAAGAGAATTCAAAAAAAAAAAAAA", // has GAATTC + "AAAAAAAAGAGAATTTAAAAAAAAAAAAAA", // has GAATTT (no cut) + "AAAAAAAAGAGAATTCAAAAAAAAAAAAAA", // has GAATTC ], enzymes, ) @@ -250,6 +266,7 @@ test "caps_three_sequences_differential" { assert_eq(dc.blocked_in()[0], 1) } +///| test "caps_no_enzymes" { let seqs = @src.caps_sample_sequences() let m = @src.caps_map(seqs, []) diff --git a/test/moonbit/cellchat_test.mbt b/test/moonbit/cellchat_test.mbt index 95bfd817..cefcca2d 100644 --- a/test/moonbit/cellchat_test.mbt +++ b/test/moonbit/cellchat_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Bioconductor CellChat module - Cell-cell communication analysis. - test "lr_pair_create" { let pair = @src.lr_pair("TNF", "TNFR1") assert_eq(pair.ligand, "TNF") @@ -8,12 +7,14 @@ test "lr_pair_create" { assert_eq(pair.key, "TNF_TNFR1") } +///| test "lr_database" { let db = @src.cellchat_lr_database() assert_true(db.length() > 0) assert_eq(db[0].ligand, "TNF") } +///| test "mean_expr_basic" { let expr = [[10.0, 5.0], [20.0, 8.0], [30.0, 12.0]] let cell_types = ["TypeA", "TypeA", "TypeB"] @@ -21,6 +22,7 @@ test "mean_expr_basic" { assert_true((mean - 15.0).abs() < 0.01) } +///| test "mean_expr_no_cells" { let expr = [[10.0, 5.0]] let cell_types = ["TypeA"] @@ -28,40 +30,82 @@ test "mean_expr_no_cells" { assert_eq(mean, 0.0) } +///| test "analyze_basic" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=10, seed=42) + let result = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=10, + seed=42, + ) assert_true(result.scores.length() > 0) assert_eq(result.cell_types.length(), 3) assert_true(result.lr_pairs.length() > 0) } +///| test "analyze_permutation_effect" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result_small = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=42) - let result_large = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=50, seed=42) + let result_small = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=42, + ) + let result_large = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=50, + seed=42, + ) assert_true(result_small.scores.length() > 0) assert_true(result_large.scores.length() > 0) } +///| test "analyze_score_non_negative" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=42) + let result = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=42, + ) let mut i = 0 while i < result.scores.length() { assert_true(result.scores[i].score >= 0.0) - assert_true(result.scores[i].p_value >= 0.0 && result.scores[i].p_value <= 1.0) + assert_true( + result.scores[i].p_value >= 0.0 && result.scores[i].p_value <= 1.0, + ) i = i + 1 } } +///| test "get_significant" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=42, fdr=0.5) + let result = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=42, + fdr=0.5, + ) let sig = @src.cellchat_get_significant(result) assert_true(sig.length() >= 0) // All significant scores should have p_value < fdr @@ -72,14 +116,23 @@ test "get_significant" { } } +///| test "aggregate" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=42) + let result = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=42, + ) let agg = @src.cellchat_aggregate(result) assert_true(agg.size() > 0) } +///| test "sample_data_dimensions" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() assert_eq(expr.length(), 30) @@ -88,6 +141,7 @@ test "sample_data_dimensions" { assert_eq(gene_names.length(), 10) } +///| test "sample_cell_types" { let (_, cell_types, _) = @src.cellchat_sample_data() let mut type_a = 0 @@ -95,9 +149,13 @@ test "sample_cell_types" { let mut type_c = 0 let mut i = 0 while i < cell_types.length() { - if cell_types[i] == "TypeA" { type_a = type_a + 1 } - else if cell_types[i] == "TypeB" { type_b = type_b + 1 } - else if cell_types[i] == "TypeC" { type_c = type_c + 1 } + if cell_types[i] == "TypeA" { + type_a = type_a + 1 + } else if cell_types[i] == "TypeB" { + type_b = type_b + 1 + } else if cell_types[i] == "TypeC" { + type_c = type_c + 1 + } i = i + 1 } assert_eq(type_a, 10) @@ -105,35 +163,74 @@ test "sample_cell_types" { assert_eq(type_c, 10) } +///| test "get_top" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=42) + let result = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=42, + ) let top = @src.cellchat_get_top(result, 5) assert_eq(top.length(), 5) } +///| test "get_top_fewer_than_n" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=42) + let result = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=42, + ) let top = @src.cellchat_get_top(result, 100) assert_true(top.length() <= result.scores.length()) } +///| test "summary" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=42) + let result = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=42, + ) let summary = @src.cellchat_summary(result) assert_true(summary.length() > 0) } +///| test "analyze_seed_reproducible" { let (expr, cell_types, gene_names) = @src.cellchat_sample_data() let pairs = @src.cellchat_lr_database() - let result1 = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=123) - let result2 = @src.cellchat_analyze(expr, cell_types, gene_names, pairs, n_permutations=5, seed=123) + let result1 = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=123, + ) + let result2 = @src.cellchat_analyze( + expr, + cell_types, + gene_names, + pairs, + n_permutations=5, + seed=123, + ) // Same seed should give same results assert_eq(result1.scores.length(), result2.scores.length()) } diff --git a/test/moonbit/chain_liftover_test.mbt b/test/moonbit/chain_liftover_test.mbt index 8dad6874..4c0939a2 100644 --- a/test/moonbit/chain_liftover_test.mbt +++ b/test/moonbit/chain_liftover_test.mbt @@ -154,7 +154,9 @@ test "cl_parse_chain_single_nucleotide_block" { ///| test "cl_parse_chain_id_preserved" { - let cf = @src.cl_parse_chain("chain 100 chr1 1000 + 100 200 chr2 500 + 50 150 99\n 100 0 0") + let cf = @src.cl_parse_chain( + "chain 100 chr1 1000 + 100 200 chr2 500 + 50 150 99\n 100 0 0", + ) assert_eq(cf.alignments[0].id, 99) } @@ -351,7 +353,9 @@ test "cl_get_chain_summary_basic" { ///| test "cl_get_chain_summary_empty_blocks" { - let cf = @src.cl_parse_chain("chain 5000 chr1 249250621 + 1 500 chr2 10000 + 1 500 43") + let cf = @src.cl_parse_chain( + "chain 5000 chr1 249250621 + 1 500 chr2 10000 + 1 500 43", + ) let summary = @src.cl_get_chain_summary(cf.alignments[0]) assert_eq(summary["total_block_size"], 0) assert_eq(summary["num_blocks"], 0) @@ -406,7 +410,9 @@ test "cl_chain_to_string_format" { ///| test "cl_chain_to_string_preserves_id" { - let cf = @src.cl_parse_chain("chain 7777 chr1 1000 + 100 200 chr2 500 + 50 150 99\n 100 0 0") + let cf = @src.cl_parse_chain( + "chain 7777 chr1 1000 + 100 200 chr2 500 + 50 150 99\n 100 0 0", + ) let s = @src.cl_chain_to_string(cf.alignments[0]) assert_true(s.contains("chain 7777")) assert_true(s.contains("99")) @@ -530,7 +536,9 @@ test "cl_chain_to_string_reverse_strand" { ///| test "cl_parse_chain_large_id" { - let cf = @src.cl_parse_chain("chain 100 chr1 1000 + 100 200 chr2 500 + 50 150 99999\n 100 0 0") + let cf = @src.cl_parse_chain( + "chain 100 chr1 1000 + 100 200 chr2 500 + 50 150 99999\n 100 0 0", + ) assert_eq(cf.alignments[0].id, 99999) } @@ -564,4 +572,4 @@ test "cl_find_chain_for_pos_at_boundary" { assert_true(r2 is None) let r3 = @src.cl_find_chain_for_pos(cf, "chr1", 6000) assert_true(r3 is Some(_)) -} \ No newline at end of file +} diff --git a/test/moonbit/checksum_test.mbt b/test/moonbit/checksum_test.mbt index 23af903a..df999342 100644 --- a/test/moonbit/checksum_test.mbt +++ b/test/moonbit/checksum_test.mbt @@ -50,4 +50,4 @@ test "verify_checksum_seguid" { let result = @src.checksum_seguid(seq) let verified = @src.verify_checksum(seq, result.checksum, "seguid") assert_true(verified) -} \ No newline at end of file +} diff --git a/test/moonbit/chromosome_visualization_test.mbt b/test/moonbit/chromosome_visualization_test.mbt index bdc64f5e..8c8197c2 100644 --- a/test/moonbit/chromosome_visualization_test.mbt +++ b/test/moonbit/chromosome_visualization_test.mbt @@ -20,11 +20,7 @@ test "chr_feature_type_values" { ///| test "chr_feature_creation" { - let feature = @src.ChrFeature::new( - name="Gene1", - start=100.0, - end=200.0, - ) + let feature = @src.ChrFeature::new(name="Gene1", start=100.0, end=200.0) assert_true((feature.start - 100.0).abs() < 1.0e-10) assert_true((feature.end - 200.0).abs() < 1.0e-10) assert_eq(feature.label, "Gene1") @@ -32,12 +28,8 @@ test "chr_feature_creation" { ///| test "chr_region_creation" { - let region = @src.ChrRegion::new( - name="Region1", - start=0.0, - end=1000.0, - ) - assert_true((region.start).abs() < 1.0e-10) + let region = @src.ChrRegion::new(name="Region1", start=0.0, end=1000.0) + assert_true(region.start.abs() < 1.0e-10) assert_true((region.end - 1000.0).abs() < 1.0e-10) assert_eq(region.label, "Region1") } @@ -57,50 +49,30 @@ test "chr_chromosome_creation" { ///| test "chr_chromosome_add_feature" { - let chr = @src.Chromosome::new( - name="chr1", - length=5000.0, - ) - let feature = @src.ChrFeature::new( - name="Gene1", - start=100.0, - end=200.0, - ) + let chr = @src.Chromosome::new(name="chr1", length=5000.0) + let feature = @src.ChrFeature::new(name="Gene1", start=100.0, end=200.0) let chr_with_feature = chr.add_feature(feature) assert_eq(chr_with_feature.features.length(), 1) } ///| test "chr_chromosome_add_region" { - let chr = @src.Chromosome::new( - name="chr1", - length=5000.0, - ) - let region = @src.ChrRegion::new( - name="Region1", - start=300.0, - end=500.0, - ) + let chr = @src.Chromosome::new(name="chr1", length=5000.0) + let region = @src.ChrRegion::new(name="Region1", start=300.0, end=500.0) let chr_with_region = chr.add_region(region) assert_eq(chr_with_region.regions.length(), 1) } ///| test "chr_chromosome_add_band" { - let chr = @src.Chromosome::new( - name="chr1", - length=5000.0, - ) + let chr = @src.Chromosome::new(name="chr1", length=5000.0) let chr_with_band = chr.add_band("Band1", 100.0, 200.0, "gpos50") assert_eq(chr_with_band.bands.length(), 1) } ///| test "chr_features_by_type" { - let chr = @src.Chromosome::new( - name="chr1", - length=5000.0, - ) + let chr = @src.Chromosome::new(name="chr1", length=5000.0) let exon1 = @src.ChrFeature::new( name="E1", start=100.0, @@ -128,20 +100,9 @@ test "chr_features_by_type" { ///| test "chr_features_in_region" { - let chr = @src.Chromosome::new( - name="chr1", - length=5000.0, - ) - let f1 = @src.ChrFeature::new( - name="F1", - start=100.0, - end=200.0, - ) - let f2 = @src.ChrFeature::new( - name="F2", - start=300.0, - end=400.0, - ) + let chr = @src.Chromosome::new(name="chr1", length=5000.0) + let f1 = @src.ChrFeature::new(name="F1", start=100.0, end=200.0) + let f2 = @src.ChrFeature::new(name="F2", start=300.0, end=400.0) let chr1 = chr.add_feature(f1).add_feature(f2) let in_region = chr1.features_in_region(150.0, 350.0) assert_eq(in_region.length(), 2) @@ -168,10 +129,7 @@ test "chr_diagram_creation" { length=5000.0, centromere_pos=2000.0, ) - let diagram = @src.ChrDiagram::new( - chromosomes=[chr], - title="Test Diagram", - ) + let diagram = @src.ChrDiagram::new(chromosomes=[chr], title="Test Diagram") assert_eq(diagram.chromosomes.length(), 1) assert_eq(diagram.title, "Test Diagram") } @@ -183,10 +141,7 @@ test "chr_to_svg_returns_string" { length=1000.0, centromere_pos=400.0, ) - let diagram = @src.ChrDiagram::new( - chromosomes=[chr], - title="Chromosome 1", - ) + let diagram = @src.ChrDiagram::new(chromosomes=[chr], title="Chromosome 1") let svg = diagram.to_svg() assert_true(svg.length() > 0) assert_true(svg.contains(" 0) assert_true(svg.contains(" 0) -} \ No newline at end of file +} diff --git a/test/moonbit/cibersort_test.mbt b/test/moonbit/cibersort_test.mbt index 9ac3372b..1168b02f 100644 --- a/test/moonbit/cibersort_test.mbt +++ b/test/moonbit/cibersort_test.mbt @@ -20,18 +20,19 @@ test "cib_signature_matrix_creation" { assert_eq(sig.matrix()[2][1], 1.0) } +///| test "cib_mixture_matrix_creation" { - let mix = @src.CibMixtureMatrix::new( - ["G1", "G2"], - ["S1", "S2"], - [[1.0, 2.0], [3.0, 4.0]], - ) + let mix = @src.CibMixtureMatrix::new(["G1", "G2"], ["S1", "S2"], [ + [1.0, 2.0], + [3.0, 4.0], + ]) assert_eq(mix.gene_names().length(), 2) assert_eq(mix.sample_names().length(), 2) assert_eq(mix.sample_names()[0], "S1") assert_eq(mix.matrix()[1][0], 3.0) } +///| test "cib_result_accessors" { // Use cib_run to get a real result and test accessors let sig = @src.cib_default_signature() @@ -49,6 +50,7 @@ test "cib_result_accessors" { // Built-in signature and marker genes // --------------------------------------------------------------------------- +///| test "cib_cell_type_names_count" { let names = @src.cib_cell_type_names() assert_eq(names.length(), 10) @@ -56,6 +58,7 @@ test "cib_cell_type_names_count" { assert_eq(names[9], "Mast cells") } +///| test "cib_marker_genes_count" { let genes = @src.cib_marker_genes() // 10 cell types × 4 markers each = 40 genes @@ -64,6 +67,7 @@ test "cib_marker_genes_count" { assert_eq(genes[4], "CD8A") // T cell CD8 marker } +///| test "cib_default_signature_dimensions" { let sig = @src.cib_default_signature() assert_eq(sig.gene_names().length(), 40) @@ -78,6 +82,7 @@ test "cib_default_signature_dimensions" { // NNLS deconvolution correctness // --------------------------------------------------------------------------- +///| test "cib_run_single_cell_type_recovery" { // Build a simple mixture: pure B cells (column 0 of signature) let sig = @src.cib_default_signature() @@ -100,6 +105,7 @@ test "cib_run_single_cell_type_recovery" { assert_true(r0.pearson_r() > 0.9) } +///| test "cib_run_mixed_composition_recovery" { // Use the built-in sample mixture generator let sig = @src.cib_default_signature() @@ -120,6 +126,7 @@ test "cib_run_mixed_composition_recovery" { } } +///| test "cib_run_sample1_dominant_t_cell_cd8" { // Sample1 was constructed as 60% T cells CD8 + 30% B cells + 10% NK cells let sig = @src.cib_default_signature() @@ -134,6 +141,7 @@ test "cib_run_sample1_dominant_t_cell_cd8" { assert_true(t_cd8 > nk) } +///| test "cib_run_sample2_dominant_monocytes" { // Sample2: 50% Monocytes + 30% Macrophages M1 + 20% Macrophages M2 let sig = @src.cib_default_signature() @@ -158,6 +166,7 @@ test "cib_run_sample2_dominant_monocytes" { ) } +///| test "cib_run_pearson_high_for_clean_data" { // For synthetic mixtures constructed from the signature, fit should be good let sig = @src.cib_default_signature() @@ -168,6 +177,7 @@ test "cib_run_pearson_high_for_clean_data" { } } +///| test "cib_run_handles_partial_gene_overlap" { // Mixture has only a subset of signature genes let sig = @src.cib_default_signature() @@ -186,14 +196,14 @@ test "cib_run_handles_partial_gene_overlap" { assert_true(r0.get_fraction("B cells") > 0.3) } +///| test "cib_run_empty_mixture_genes" { // Mixture has no genes in common with the signature -> all zeros let sig = @src.cib_default_signature() - let mix = @src.CibMixtureMatrix::new( - ["NONEXIST1", "NONEXIST2"], - ["Empty"], - [[1.0], [2.0]], - ) + let mix = @src.CibMixtureMatrix::new(["NONEXIST1", "NONEXIST2"], ["Empty"], [ + [1.0], + [2.0], + ]) let result = @src.cib_run(sig, mix) assert_eq(result.sample_names().length(), 1) let r0 = result.results()[0] @@ -206,6 +216,7 @@ test "cib_run_empty_mixture_genes" { // to_string formatting // --------------------------------------------------------------------------- +///| test "cib_deconvolution_to_string" { let sig = @src.cib_default_signature() let mix = @src.cib_sample_mixture() @@ -220,6 +231,7 @@ test "cib_deconvolution_to_string" { // NNLS edge cases // --------------------------------------------------------------------------- +///| test "cib_get_fraction_unknown_type" { // Use cib_run to get a real result and test get_fraction let sig = @src.cib_default_signature() @@ -233,6 +245,7 @@ test "cib_get_fraction_unknown_type" { assert_true(b_frac >= 0.0) } +///| test "cib_run_with_custom_tolerance" { let sig = @src.cib_default_signature() let mix = @src.cib_sample_mixture() diff --git a/test/moonbit/circ_seq_test.mbt b/test/moonbit/circ_seq_test.mbt index 8453b306..0bd88584 100644 --- a/test/moonbit/circ_seq_test.mbt +++ b/test/moonbit/circ_seq_test.mbt @@ -24,7 +24,7 @@ test "CircSeq::circ_gc_content" { test "CircSeq::circ_gc_content AT rich" { let circ = @src.CircSeq::new(sequence="ATATATAT") let gc = circ.circ_gc_content() - assert_true((gc).abs() < 1.0e-10) + assert_true(gc.abs() < 1.0e-10) } ///| diff --git a/test/moonbit/cluster_experiment_test.mbt b/test/moonbit/cluster_experiment_test.mbt index 7b2f652c..d4a9e983 100644 --- a/test/moonbit/cluster_experiment_test.mbt +++ b/test/moonbit/cluster_experiment_test.mbt @@ -128,8 +128,8 @@ test "ce_center_columns_basic" { // col 1: mean = 15 -> centered [-5, 5] let m = [[1.0, 10.0], [3.0, 20.0]] let c = @src.ce_center_columns(m) - assert_true((c[0][0] - (-1.0)).abs() < 0.001) - assert_true((c[0][1] - (-5.0)).abs() < 0.001) + assert_true((c[0][0] - -1.0).abs() < 0.001) + assert_true((c[0][1] - -5.0).abs() < 0.001) assert_true((c[1][0] - 1.0).abs() < 0.001) assert_true((c[1][1] - 5.0).abs() < 0.001) } @@ -376,11 +376,7 @@ test "ce_hclust_cut_k2" { ///| test "ce_hclust_cut_k_equals_n" { - let dist = [ - [0.0, 0.5, 0.5], - [0.5, 0.0, 0.5], - [0.5, 0.5, 0.0], - ] + let dist = [[0.0, 0.5, 0.5], [0.5, 0.0, 0.5], [0.5, 0.5, 0.0]] let labels = @src.ce_hclust_cut(dist, 3) assert_eq(labels.length(), 3) // each sample in its own cluster @@ -527,12 +523,7 @@ test "ce_sequential_cluster_isolates_small" { test "ce_rsec_pipeline" { // 4 samples, 2 clear clusters; small enough that sequential splits are // not triggered (each consensus cluster has < 4 points). - let data = [ - [0.0, 0.0], - [0.1, 0.0], - [10.0, 10.0], - [10.1, 10.0], - ] + let data = [[0.0, 0.0], [0.1, 0.0], [10.0, 10.0], [10.1, 10.0]] let params = @src.ce_default_params() let result = @src.ce_rsec(data, params) assert_eq(result.labels.length(), 4) @@ -719,12 +710,7 @@ test "ce_default_params" { ///| test "ce_default_params_used_in_rsec" { // Smoke test: default params produce a valid ClusterExperiment - let data = [ - [0.0, 0.0], - [0.1, 0.1], - [5.0, 5.0], - [5.1, 5.1], - ] + let data = [[0.0, 0.0], [0.1, 0.1], [5.0, 5.0], [5.1, 5.1]] let params = @src.ce_default_params() let result = @src.ce_rsec(data, params) assert_true(result.labels.length() == 4) diff --git a/test/moonbit/cnvkit_test.mbt b/test/moonbit/cnvkit_test.mbt index 0df6e9db..3b09e281 100644 --- a/test/moonbit/cnvkit_test.mbt +++ b/test/moonbit/cnvkit_test.mbt @@ -1,32 +1,22 @@ ///| test "cnvkit_create_probe" { let probe = @src.CNVProbe::new( - "probe_001", - "chr1", - 1000000, - 1001000, - -0.5, - 1.0 + "probe_001", "chr1", 1000000, 1001000, -0.5, 1.0, ) - + assert_eq(probe.probe_id, "probe_001") assert_eq(probe.chromosome, "chr1") assert_eq(probe.start, 1000000) assert_eq(probe.end, 1001000) - assert_true((probe.log2_ratio - (-0.5)).abs() < 0.001) + assert_true((probe.log2_ratio - -0.5).abs() < 0.001) } ///| test "cnvkit_create_segment" { let segment = @src.CNVSegment::new( - "chr1", - 1000000, - 2000000, - 50, - -0.8, - "deletion" + "chr1", 1000000, 2000000, 50, -0.8, "deletion", ) - + assert_eq(segment.chromosome, "chr1") assert_eq(segment.start, 1000000) assert_eq(segment.end, 2000000) @@ -37,20 +27,15 @@ test "cnvkit_create_segment" { ///| test "cnvkit_dataset_operations" { let mut dataset = @src.CNVDataset::new() - + assert_eq(dataset.count_probes(), 0) - + let probe = @src.CNVProbe::new( - "probe_001", - "chr1", - 1000000, - 1001000, - -0.5, - 1.0 + "probe_001", "chr1", 1000000, 1001000, -0.5, 1.0, ) - + dataset = dataset.add_probe(probe) - + assert_eq(dataset.count_probes(), 1) assert_eq(dataset.chromosomes.length(), 1) assert_eq(dataset.chromosomes[0], "chr1") @@ -59,15 +44,19 @@ test "cnvkit_dataset_operations" { ///| test "cnvkit_filter_chromosome" { let mut dataset = @src.CNVDataset::new() - - let probe1 = @src.CNVProbe::new("probe_001", "chr1", 1000000, 1001000, -0.5, 1.0) - let probe2 = @src.CNVProbe::new("probe_002", "chr2", 2000000, 2001000, 0.5, 1.0) - + + let probe1 = @src.CNVProbe::new( + "probe_001", "chr1", 1000000, 1001000, -0.5, 1.0, + ) + let probe2 = @src.CNVProbe::new( + "probe_002", "chr2", 2000000, 2001000, 0.5, 1.0, + ) + dataset = dataset.add_probe(probe1) dataset = dataset.add_probe(probe2) - + let filtered = dataset.filter_chromosome("chr1") - + assert_eq(filtered.count_probes(), 1) assert_eq(filtered.chromosomes.length(), 1) } @@ -75,24 +64,26 @@ test "cnvkit_filter_chromosome" { ///| test "cnvkit_cbs_segmentation" { let probes : Array[@src.CNVProbe] = Array::new() - + // Create probes with a clear change point let mut i = 0 while i < 20 { let ratio = if i < 10 { -0.8 } else { 0.1 } - probes.push(@src.CNVProbe::new( - "probe_" + i.to_string(), - "chr1", - 1000000 + i * 1000, - 1000000 + i * 1000 + 100, - ratio, - 1.0 - )) + probes.push( + @src.CNVProbe::new( + "probe_" + i.to_string(), + "chr1", + 1000000 + i * 1000, + 1000000 + i * 1000 + 100, + ratio, + 1.0, + ), + ) i = i + 1 } - + let result = @src.cbs_segment(probes, 0.05) - + assert_true(result.n_segments > 0) assert_true(result.breakpoints.length() > 0) } @@ -100,24 +91,26 @@ test "cnvkit_cbs_segmentation" { ///| test "cnvkit_smooth_log2_ratios" { let probes : Array[@src.CNVProbe] = Array::new() - + let mut i = 0 while i < 10 { - probes.push(@src.CNVProbe::new( - "probe_" + i.to_string(), - "chr1", - 1000000 + i * 1000, - 1000000 + i * 1000 + 100, - (i.to_double() - 5.0) * 0.1, - 1.0 - )) + probes.push( + @src.CNVProbe::new( + "probe_" + i.to_string(), + "chr1", + 1000000 + i * 1000, + 1000000 + i * 1000 + 100, + (i.to_double() - 5.0) * 0.1, + 1.0, + ), + ) i = i + 1 } - + let smoothed = @src.smooth_log2_ratios(probes, 3) - + assert_eq(smoothed.length(), 10) - + // Check that smoothed values are reasonable let val = smoothed[0].log2_ratio assert_true(val.abs() < 10.0) @@ -135,11 +128,11 @@ test "cnvkit_detect_breakpoints" { let segments : Array[@src.CNVSegment] = [ @src.CNVSegment::new("chr1", 1000000, 2000000, 50, -0.8, "deletion"), @src.CNVSegment::new("chr1", 2000000, 3000000, 50, 0.1, "neutral"), - @src.CNVSegment::new("chr1", 3000000, 4000000, 50, 0.9, "amplification") + @src.CNVSegment::new("chr1", 3000000, 4000000, 50, 0.9, "amplification"), ] - + let breakpoints = @src.detect_breakpoints(segments, 0.3) - + assert_true(breakpoints.length() > 0) } @@ -148,11 +141,11 @@ test "cnvkit_call_copy_numbers" { let segments : Array[@src.CNVSegment] = [ @src.CNVSegment::new("chr1", 1000000, 2000000, 50, -0.8, "deletion"), @src.CNVSegment::new("chr1", 2000000, 3000000, 50, 0.0, "neutral"), - @src.CNVSegment::new("chr1", 3000000, 4000000, 50, 0.8, "amplification") + @src.CNVSegment::new("chr1", 3000000, 4000000, 50, 0.8, "amplification"), ] - + let calls = @src.call_copy_numbers(segments, 2) - + assert_eq(calls.length(), 3) assert_eq(calls[0].state, "deletion") assert_eq(calls[1].state, "neutral") @@ -163,7 +156,7 @@ test "cnvkit_call_copy_numbers" { test "cnvkit_summarize_dataset" { let dataset = @src.create_example_cnv_dataset() let summary = @src.summarize_cnv(dataset) - + assert_true(summary.total_probes > 0) assert_true(summary.total_segments >= 0) } @@ -171,7 +164,7 @@ test "cnvkit_summarize_dataset" { ///| test "cnvkit_create_example" { let dataset = @src.create_example_cnv_dataset() - + assert_true(dataset.count_probes() > 0) assert_true(dataset.chromosomes.length() >= 2) } @@ -180,7 +173,7 @@ test "cnvkit_create_example" { test "cnvkit_summarize_string" { let dataset = @src.create_example_cnv_dataset() let summary_str = @src.cbs_summarize_dataset(dataset) - + assert_true(summary_str.contains("CNV Dataset Summary")) assert_true(summary_str.contains("Total probes:")) } @@ -189,7 +182,7 @@ test "cnvkit_summarize_string" { test "cnvkit_empty_segmentation" { let empty_probes : Array[@src.CNVProbe] = Array::new() let result = @src.cbs_segment(empty_probes, 0.05) - + assert_eq(result.n_segments, 0) assert_eq(result.breakpoints.length(), 0) } @@ -198,9 +191,9 @@ test "cnvkit_empty_segmentation" { test "cnvkit_single_probe" { let probe = @src.CNVProbe::new("p1", "chr1", 100, 200, 0.5, 1.0) let probes : Array[@src.CNVProbe] = [probe] - + let result = @src.cbs_segment(probes, 0.05) - + assert_eq(result.n_segments, 1) } @@ -208,6 +201,6 @@ test "cnvkit_single_probe" { test "cnvkit_smooth_edge_cases" { let empty_probes : Array[@src.CNVProbe] = Array::new() let smoothed = @src.smooth_log2_ratios(empty_probes, 3) - + assert_eq(smoothed.length(), 0) } diff --git a/test/moonbit/codon_advanced_test.mbt b/test/moonbit/codon_advanced_test.mbt index 6a20cc4d..d04efc7b 100644 --- a/test/moonbit/codon_advanced_test.mbt +++ b/test/moonbit/codon_advanced_test.mbt @@ -179,18 +179,29 @@ test "codon_advanced_calculate_enc" { ///| test "codon_advanced_calculate_enc_low_bias" { let counts = Map([], capacity=24) - counts.set("GCA", 1); counts.set("GCC", 1) - counts.set("GCG", 1); counts.set("GCT", 1) - counts.set("AAA", 1); counts.set("AAG", 1) - counts.set("GAA", 1); counts.set("GAG", 1) - counts.set("CTT", 1); counts.set("CTC", 1) - counts.set("CTA", 1); counts.set("CTG", 1) - counts.set("TTA", 1); counts.set("TTG", 1) - counts.set("ATT", 1); counts.set("ATC", 1) + counts.set("GCA", 1) + counts.set("GCC", 1) + counts.set("GCG", 1) + counts.set("GCT", 1) + counts.set("AAA", 1) + counts.set("AAG", 1) + counts.set("GAA", 1) + counts.set("GAG", 1) + counts.set("CTT", 1) + counts.set("CTC", 1) + counts.set("CTA", 1) + counts.set("CTG", 1) + counts.set("TTA", 1) + counts.set("TTG", 1) + counts.set("ATT", 1) + counts.set("ATC", 1) counts.set("ATA", 1) - counts.set("CGT", 1); counts.set("CGC", 1) - counts.set("CGA", 1); counts.set("CGG", 1) - counts.set("AGA", 1); counts.set("AGG", 1) + counts.set("CGT", 1) + counts.set("CGC", 1) + counts.set("CGA", 1) + counts.set("CGG", 1) + counts.set("AGA", 1) + counts.set("AGG", 1) let usage = @src.CodonUsageTable::new(counts) let enc_val = @src.calculate_enc(usage) @@ -395,4 +406,4 @@ test "codon_advanced_all_stop_codons" { assert_eq(@src.get_amino_acid("TAA"), "*") assert_eq(@src.get_amino_acid("TAG"), "*") assert_eq(@src.get_amino_acid("TGA"), "*") -} \ No newline at end of file +} diff --git a/test/moonbit/compass_test.mbt b/test/moonbit/compass_test.mbt index 7bcf69b9..f7206c55 100644 --- a/test/moonbit/compass_test.mbt +++ b/test/moonbit/compass_test.mbt @@ -7,22 +7,8 @@ test "compass_record_creation" { let r = @src.CompassRecord::new( - "query1.msa", - "template1.msa", - 5, - 4, - 120, - 110, - 185.5, - 3.5e-10, - 28.5, - 1, - 120, - 1, - 110, - "MALKSLVRLFG", - "MGVKSAVKT", - ": :: :::", + "query1.msa", "template1.msa", 5, 4, 120, 110, 185.5, 3.5e-10, 28.5, 1, 120, + 1, 110, "MALKSLVRLFG", "MGVKSAVKT", ": :: :::", ) assert_eq(r.query_name(), "query1.msa") assert_eq(r.template_name(), "template1.msa") @@ -42,10 +28,10 @@ test "compass_record_creation" { assert_eq(r.consensus_line(), ": :: :::") } +///| test "compass_record_accessors_individual" { let r = @src.CompassRecord::new( - "q", "t", 1, 2, 10, 20, 50.0, 0.001, 35.0, - 5, 50, 10, 60, "ACGT", "ACGT", ":::", + "q", "t", 1, 2, 10, 20, 50.0, 0.001, 35.0, 5, 50, 10, 60, "ACGT", "ACGT", ":::", ) assert_eq(r.query_name(), "q") assert_eq(r.template_name(), "t") @@ -65,13 +51,11 @@ test "compass_record_accessors_individual" { assert_eq(r.consensus_line(), ":::") } +///| test "compass_record_to_string" { let r = @src.CompassRecord::new( - "query1.msa", "template1.msa", - 5, 4, 120, 110, - 185.5, 3.5e-10, 28.5, - 1, 120, 1, 110, - "MALKSLVRLFG", "MGVKSAVKT", ": :: :::", + "query1.msa", "template1.msa", 5, 4, 120, 110, 185.5, 3.5e-10, 28.5, 1, 120, + 1, 110, "MALKSLVRLFG", "MGVKSAVKT", ": :: :::", ) let s = r.to_string() assert_true(s.contains("query1.msa")) @@ -83,56 +67,66 @@ test "compass_record_to_string" { // Parsing: sample data // --------------------------------------------------------------------------- +///| test "compass_parse_sample_data_count" { let text = @src.compass_sample_data() let records = @src.parse_compass(text) assert_eq(records.length(), 2) } +///| test "compass_parse_first_record_query_name" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].query_name(), "query1.msa") } +///| test "compass_parse_first_record_template_name" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].template_name(), "template1.msa") } +///| test "compass_parse_first_record_n_seqs" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].query_n_seqs(), 5) assert_eq(records[0].template_n_seqs(), 4) } +///| test "compass_parse_first_record_n_cols" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].query_n_cols(), 120) assert_eq(records[0].template_n_cols(), 110) } +///| test "compass_parse_first_record_sw_score" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].sw_score(), 185.5) } +///| test "compass_parse_first_record_e_value" { let records = @src.parse_compass(@src.compass_sample_data()) // Use tolerance comparison due to floating-point precision assert_true((records[0].e_value() - 3.5e-10).abs() < 1.0e-20) } +///| test "compass_parse_first_record_identity" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].percentage_identity(), 28.5) } +///| test "compass_parse_first_record_alignment" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].aligned_query(), "MALKSLVRLFG") assert_eq(records[0].aligned_template(), "MGVKSAVKT") } +///| test "compass_parse_first_record_positions" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].query_start(), 1) @@ -141,11 +135,13 @@ test "compass_parse_first_record_positions" { assert_eq(records[0].template_end(), 110) } +///| test "compass_parse_first_record_consensus" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[0].consensus_line(), ": :: :::") } +///| test "compass_parse_second_record" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(records[1].query_name(), "query2.msa") @@ -164,16 +160,19 @@ test "compass_parse_second_record" { // Version extraction // --------------------------------------------------------------------------- +///| test "compass_version_extraction" { let text = @src.compass_sample_data() let version = @src.compass_version(text) assert_eq(version, "2.4.2") } +///| test "compass_version_empty_input" { assert_eq(@src.compass_version(""), "") } +///| test "compass_version_no_version_line" { let text = "Some other content\nwithout version\n" assert_eq(@src.compass_version(text), "") @@ -183,6 +182,7 @@ test "compass_version_no_version_line" { // Filtering // --------------------------------------------------------------------------- +///| test "compass_filter_by_evalue" { let records = @src.parse_compass(@src.compass_sample_data()) // E-values: 3.5e-10 and 1.2e-05 @@ -191,18 +191,21 @@ test "compass_filter_by_evalue" { assert_eq(filtered[0].query_name(), "query1.msa") } +///| test "compass_filter_by_evalue_all_pass" { let records = @src.parse_compass(@src.compass_sample_data()) let filtered = @src.compass_filter_by_evalue(records, 1.0) assert_eq(filtered.length(), 2) } +///| test "compass_filter_by_evalue_none_pass" { let records = @src.parse_compass(@src.compass_sample_data()) let filtered = @src.compass_filter_by_evalue(records, 1.0e-20) assert_eq(filtered.length(), 0) } +///| test "compass_filter_by_identity" { let records = @src.parse_compass(@src.compass_sample_data()) // Identities: 28.5 and 15.3 @@ -211,6 +214,7 @@ test "compass_filter_by_identity" { assert_eq(filtered[0].query_name(), "query1.msa") } +///| test "compass_filter_by_identity_all_pass" { let records = @src.parse_compass(@src.compass_sample_data()) let filtered = @src.compass_filter_by_identity(records, 10.0) @@ -221,16 +225,17 @@ test "compass_filter_by_identity_all_pass" { // Alignment length // --------------------------------------------------------------------------- +///| test "compass_alignment_length" { let records = @src.parse_compass(@src.compass_sample_data()) assert_eq(@src.compass_alignment_length(records[0]), 11) assert_eq(@src.compass_alignment_length(records[1]), 10) } +///| test "compass_alignment_length_empty" { let r = @src.CompassRecord::new( - "", "", 0, 0, 0, 0, 0.0, 0.0, 0.0, - 0, 0, 0, 0, "", "", "", + "", "", 0, 0, 0, 0, 0.0, 0.0, 0.0, 0, 0, 0, 0, "", "", "", ) assert_eq(@src.compass_alignment_length(r), 0) } @@ -239,6 +244,7 @@ test "compass_alignment_length_empty" { // Summary // --------------------------------------------------------------------------- +///| test "compass_summary_content" { let records = @src.parse_compass(@src.compass_sample_data()) let summary = @src.compass_summary(records) @@ -250,6 +256,7 @@ test "compass_summary_content" { assert_true(summary.contains("28.5")) } +///| test "compass_summary_empty" { let records : Array[@src.CompassRecord] = [] let summary = @src.compass_summary(records) @@ -260,16 +267,19 @@ test "compass_summary_empty" { // Edge cases // --------------------------------------------------------------------------- +///| test "compass_parse_empty_input" { let records = @src.parse_compass("") assert_eq(records.length(), 0) } +///| test "compass_parse_whitespace_only" { let records = @src.parse_compass(" \n \n \n") assert_eq(records.length(), 0) } +///| test "compass_parse_single_record" { let text = "COMPASS version 2.4.2\n" + "Query alignment: single.msa\n" + @@ -296,10 +306,10 @@ test "compass_parse_single_record" { assert_eq(records[0].consensus_line(), ": : :") } +///| test "compass_parse_missing_fields" { // Record with only version and query name (missing other fields) - let text = "COMPASS version 1.0.0\n" + - "Query alignment: partial.msa\n" + let text = "COMPASS version 1.0.0\n" + "Query alignment: partial.msa\n" let records = @src.parse_compass(text) assert_eq(records.length(), 1) assert_eq(records[0].query_name(), "partial.msa") @@ -316,6 +326,7 @@ test "compass_parse_missing_fields" { assert_eq(records[0].consensus_line(), "") } +///| test "compass_parse_no_consensus_line" { // Alignment block without a consensus line between Query and Template let text = "COMPASS version 2.4.2\n" + @@ -337,6 +348,7 @@ test "compass_parse_no_consensus_line" { assert_eq(records[0].consensus_line(), "") } +///| test "compass_parse_three_records" { let mut text = "" text = text + "COMPASS version 2.4.2\n" @@ -360,6 +372,7 @@ test "compass_parse_three_records" { assert_eq(records[2].query_name(), "q3.msa") } +///| test "compass_parse_version_only" { let text = "COMPASS version 3.0.0\n" let records = @src.parse_compass(text) @@ -367,17 +380,20 @@ test "compass_parse_version_only" { assert_eq(records[0].query_name(), "") } +///| test "compass_sample_data_has_version" { let text = @src.compass_sample_data() assert_true(text.contains("COMPASS version 2.4.2")) } +///| test "compass_sample_data_has_evalue" { let text = @src.compass_sample_data() assert_true(text.contains("3.5e-10")) assert_true(text.contains("1.2e-05")) } +///| test "compass_filter_empty_records" { let records : Array[@src.CompassRecord] = [] let by_evalue = @src.compass_filter_by_evalue(records, 1.0) diff --git a/test/moonbit/compound_test.mbt b/test/moonbit/compound_test.mbt index 99123022..07ef7572 100644 --- a/test/moonbit/compound_test.mbt +++ b/test/moonbit/compound_test.mbt @@ -9,7 +9,9 @@ test "compound_new" { ///| test "compound_with_chemical" { - let c = @src.Compound::with_chemical("C0001", "Glucose", "C6H12O6", 0, "C(C1C(C(C(C(O1)O)O)O)O)O") + let c = @src.Compound::with_chemical( + "C0001", "Glucose", "C6H12O6", 0, "C(C1C(C(C(C(O1)O)O)O)O)O", + ) assert_eq(c.get_id(), "C0001") assert_eq(c.get_formula(), "C6H12O6") assert_eq(c.get_charge(), 0) diff --git a/test/moonbit/consensus_cluster_plus_test.mbt b/test/moonbit/consensus_cluster_plus_test.mbt index 9a67f008..6efe489a 100644 --- a/test/moonbit/consensus_cluster_plus_test.mbt +++ b/test/moonbit/consensus_cluster_plus_test.mbt @@ -9,24 +9,19 @@ test "consensus_cluster_plus_consensus_matrix" { [10.0, 11.0, 12.0], [11.0, 12.0, 13.0], ] - + let consensus = @src.ccp_calculate_consensus_matrix(data, 2, 10, 0.8) - + assert_true(consensus.length() == 4) assert_true(consensus[0].length() == 4) } ///| test "consensus_cluster_plus_kmeans" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [10.0, 11.0], - [11.0, 12.0], - ] - + let data = [[1.0, 2.0], [2.0, 3.0], [10.0, 11.0], [11.0, 12.0]] + let labels = @src.ccp_kmeans_cluster(data, 2) - + assert_true(labels.length() == 4) } @@ -38,9 +33,9 @@ test "consensus_cluster_plus_consensus_score" { [0.8, 0.8, 1.0, 0.9], [0.7, 0.7, 0.9, 1.0], ] - + let score = @src.ccp_calculate_consensus_score(consensus) - + assert_true(score > 0.5) } @@ -54,9 +49,9 @@ test "consensus_cluster_plus_find_optimal_k" { [20.0, 21.0, 22.0], [21.0, 22.0, 23.0], ] - + let (best_k, scores) = @src.ccp_find_optimal_k(data, 2, 4) - + assert_true(best_k >= 2 && best_k <= 4) assert_true(scores.length() == 3) } @@ -69,9 +64,9 @@ test "consensus_cluster_plus_main" { [10.0, 11.0, 12.0], [11.0, 12.0, 13.0], ] - + let result = @src.bio_consensus_cluster(data, 2) - + assert_true(result.k == 2) assert_true(result.cluster_labels.length() == 4) assert_true(result.consensus_matrix.length() == 4) @@ -79,17 +74,13 @@ test "consensus_cluster_plus_main" { ///| test "consensus_cluster_plus_bio_api" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [10.0, 11.0], - ] - + let data = [[1.0, 2.0], [2.0, 3.0], [10.0, 11.0]] + let (best_k, scores) = @src.bio_consensus_cluster_find_optimal_k(data, 2, 3) let consensus = @src.ccp_calculate_consensus_matrix(data, 2, 10, 0.8) let score = @src.bio_consensus_cluster_consensus_score(consensus) - + assert_true(best_k >= 2) assert_true(scores.length() > 0) assert_true(score >= 0.0) -} \ No newline at end of file +} diff --git a/test/moonbit/crystal_test.mbt b/test/moonbit/crystal_test.mbt index a8ecb034..7f4d43f3 100644 --- a/test/moonbit/crystal_test.mbt +++ b/test/moonbit/crystal_test.mbt @@ -51,7 +51,7 @@ test "unit_cell_volume_hexagonal" { gamma=120.0, ) let v = @src.unit_cell_volume(cell) - let expected = 5.0 * 5.0 * 7.0 * (3.0).sqrt() / 2.0 + let expected = 5.0 * 5.0 * 7.0 * 3.0.sqrt() / 2.0 assert_true((v - expected).abs() < 0.01) } @@ -142,13 +142,7 @@ test "lookup_space_group_unknown" { ///| test "crystal_atom_construction" { - let a = @src.CrystalAtom::new( - label="C1", - element="C", - x=0.5, - y=0.5, - z=0.5, - ) + let a = @src.CrystalAtom::new(label="C1", element="C", x=0.5, y=0.5, z=0.5) assert_eq(a.label, "C1") assert_eq(a.element, "C") assert_true((a.x - 0.5).abs() < 0.001) @@ -216,7 +210,7 @@ test "fractional_to_cartesian_orthorhombic" { beta=90.0, gamma=90.0, ) - let(x, y, z) = @src.fractional_to_cartesian(cell, 0.5, 0.25, 0.1) + let (x, y, z) = @src.fractional_to_cartesian(cell, 0.5, 0.25, 0.1) assert_true((x - 5.0).abs() < 0.001) assert_true((y - 5.0).abs() < 0.001) assert_true((z - 3.0).abs() < 0.001) @@ -232,7 +226,7 @@ test "cartesian_to_fractional_orthorhombic" { beta=90.0, gamma=90.0, ) - let(xf, yf, zf) = @src.cartesian_to_fractional(cell, 5.0, 5.0, 3.0) + let (xf, yf, zf) = @src.cartesian_to_fractional(cell, 5.0, 5.0, 3.0) assert_true((xf - 0.5).abs() < 0.001) assert_true((yf - 0.25).abs() < 0.001) assert_true((zf - 0.1).abs() < 0.001) @@ -251,8 +245,8 @@ test "coord_conversion_roundtrip_orthorhombic" { let xf0 = 0.3 let yf0 = 0.6 let zf0 = 0.9 - let(x, y, z) = @src.fractional_to_cartesian(cell, xf0, yf0, zf0) - let(xf, yf, zf) = @src.cartesian_to_fractional(cell, x, y, z) + let (x, y, z) = @src.fractional_to_cartesian(cell, xf0, yf0, zf0) + let (xf, yf, zf) = @src.cartesian_to_fractional(cell, x, y, z) assert_true((xf - xf0).abs() < 0.01) assert_true((yf - yf0).abs() < 0.01) assert_true((zf - zf0).abs() < 0.01) @@ -300,7 +294,7 @@ test "crystal_atom_distance_missing_atom" { ///| test "center_of_mass_basic" { let s = @src.crystal_sample_structure() - let(cx, cy, cz) = @src.center_of_mass(s) + let (cx, cy, cz) = @src.center_of_mass(s) // Center of mass should be a 3-tuple of finite doubles. assert_true(cx >= 0.0 || cx < 0.0) // just check it's a number assert_true(cy >= 0.0 || cy < 0.0) @@ -319,14 +313,14 @@ test "center_of_mass_empty_structure" { ) let s = @src.CrystalStructure::new( name="empty", - cell=cell, + cell~, space_group=@src.SpaceGroup::new(number=1, symbol="P 1"), atoms=[], bonds=[], z=1, molecular_weight=0.0, ) - let(cx, cy, cz) = @src.center_of_mass(s) + let (cx, cy, cz) = @src.center_of_mass(s) assert_true((cx - 0.0).abs() < 0.001) assert_true((cy - 0.0).abs() < 0.001) assert_true((cz - 0.0).abs() < 0.001) @@ -363,7 +357,7 @@ test "cif_block_loop_set_get" { let headers = ["_atom_site_label", "_atom_site_x"] let rows = [["C1", "0.5"], ["C2", "0.6"]] block.set_loop("_atom_site_label", headers, rows) - let(h, r) = block.get_loop("_atom_site_label") + let (h, r) = block.get_loop("_atom_site_label") assert_eq(h.length(), 2) assert_eq(r.length(), 2) assert_eq(r[0][0], "C1") @@ -372,7 +366,7 @@ test "cif_block_loop_set_get" { ///| test "cif_block_loop_missing_returns_empty" { let block = @src.CifBlock::new(name="test") - let(h, r) = block.get_loop("_nonexistent") + let (h, r) = block.get_loop("_nonexistent") assert_eq(h.length(), 0) assert_eq(r.length(), 0) } @@ -403,7 +397,7 @@ test "parse_cif_with_loop" { #|C3 0.7 let blocks = @src.parse_cif(text) assert_eq(blocks.length(), 1) - let(h, r) = blocks[0].get_loop("_atom_site_label") + let (h, r) = blocks[0].get_loop("_atom_site_label") assert_eq(h.length(), 2) assert_eq(r.length(), 3) assert_eq(r[0][0], "C1") @@ -521,7 +515,7 @@ test "crystal_summary_density_zero_when_mw_zero" { ) let s = @src.CrystalStructure::new( name="test", - cell=cell, + cell~, space_group=@src.SpaceGroup::new(number=1, symbol="P 1"), atoms=[], bonds=[], diff --git a/test/moonbit/csaw_test.mbt b/test/moonbit/csaw_test.mbt index 7ae988a4..094488bf 100644 --- a/test/moonbit/csaw_test.mbt +++ b/test/moonbit/csaw_test.mbt @@ -30,7 +30,7 @@ test "csaw_dataset_create" { let counts = [10.0, 20.0, 30.0] let windows = [ @src.CswWindow::new("w1", "chr1", 1000, 2000, counts), - @src.CswWindow::new("w2", "chr1", 3000, 4000, [50.0, 60.0, 70.0]) + @src.CswWindow::new("w2", "chr1", 3000, 4000, [50.0, 60.0, 70.0]), ] let samples = ["s1", "s2", "s3"] let lib_sizes = [1000.0, 2000.0, 3000.0] @@ -52,7 +52,7 @@ test "csaw_norm_library" { test "csaw_norm_tmm" { let windows = [ @src.CswWindow::new("w1", "chr1", 1000, 2000, [100.0, 200.0, 3000.0]), - @src.CswWindow::new("w2", "chr1", 3000, 4000, [150.0, 250.0, 350.0]) + @src.CswWindow::new("w2", "chr1", 3000, 4000, [150.0, 250.0, 350.0]), ] let samples = ["s1", "s2", "s3"] let lib_sizes = [1000.0, 2000.0, 3000.0] @@ -65,7 +65,7 @@ test "csaw_norm_tmm" { test "csaw_filter_abundance" { let windows = [ @src.CswWindow::new("w1", "chr1", 1000, 2000, [100.0, 200.0]), - @src.CswWindow::new("w2", "chr1", 3000, 4000, [5.0, 3.0]) + @src.CswWindow::new("w2", "chr1", 3000, 4000, [5.0, 3.0]), ] let samples = ["s1", "s2"] let lib_sizes = [1000.0, 2000.0] @@ -78,7 +78,7 @@ test "csaw_filter_abundance" { test "csaw_test_differential" { let windows = [ @src.CswWindow::new("w1", "chr1", 1000, 2000, [50.0, 100.0, 200.0, 250.0]), - @src.CswWindow::new("w2", "chr1", 3000, 4000, [80.0, 120.0, 180.0, 220.0]) + @src.CswWindow::new("w2", "chr1", 3000, 4000, [80.0, 120.0, 180.0, 220.0]), ] let samples = ["s1", "s2", "s3", "s4"] let lib_sizes = [1000.0, 2000.0, 3000.0, 4000.0] @@ -94,7 +94,7 @@ test "csaw_test_differential" { test "csaw_find_regions" { let windows = [ @src.CswWindow::new("w1", "chr1", 1000, 2000, [500.0, 100.0, 200.0, 250.0]), - @src.CswWindow::new("w2", "chr1", 3000, 4000, [80.0, 120.0, 180.0, 220.0]) + @src.CswWindow::new("w2", "chr1", 3000, 4000, [80.0, 120.0, 180.0, 220.0]), ] let samples = ["s1", "s2", "s3", "s4"] let lib_sizes = [1000.0, 2000.0, 3000.0, 4000.0] diff --git a/test/moonbit/cyclone_test.mbt b/test/moonbit/cyclone_test.mbt index 9f0b9570..5495bb8d 100644 --- a/test/moonbit/cyclone_test.mbt +++ b/test/moonbit/cyclone_test.mbt @@ -37,7 +37,7 @@ test "cyclone_score_phase" { let pairs = @src.cyclone_get_gene_pairs() let test_data = @src.cyclone_create_test_data() let (counts, cell_ids, gene_names) = test_data - + // Score the first cell (should be G1 phase) let cell_expr : Array[Double] = Array::new() let n_genes = counts.length() @@ -46,7 +46,7 @@ test "cyclone_score_phase" { cell_expr.push(counts[g][0]) g = g + 1 } - + let g1_score = @src.cyclone_score_phase(cell_expr, gene_names, pairs, "G1") assert_true(g1_score >= 0.0) assert_true(g1_score <= 1.0) @@ -57,7 +57,7 @@ test "cyclone_score_cell" { let pairs = @src.cyclone_get_gene_pairs() let test_data = @src.cyclone_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let cell_expr : Array[Double] = Array::new() let n_genes = counts.length() let mut g = 0 @@ -65,7 +65,7 @@ test "cyclone_score_cell" { cell_expr.push(counts[g][0]) g = g + 1 } - + let scores = @src.cyclone_score_cell(cell_expr, gene_names, pairs) assert_true(scores.size() > 0) assert_true(scores.contains("G1")) @@ -93,7 +93,7 @@ test "cyclone_score_single_cell" { let pairs = @src.cyclone_get_gene_pairs() let test_data = @src.cyclone_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let cell_expr : Array[Double] = Array::new() let n_genes = counts.length() let mut g = 0 @@ -101,8 +101,10 @@ test "cyclone_score_single_cell" { cell_expr.push(counts[g][0]) g = g + 1 } - - let result = @src.cyclone_score_single_cell(cell_expr, "test_cell", gene_names, pairs) + + let result = @src.cyclone_score_single_cell( + cell_expr, "test_cell", gene_names, pairs, + ) assert_eq(result.cell_id, "test_cell") assert_true(result.scores.size() == 4) assert_true(result.phases.length() == 4) @@ -117,10 +119,10 @@ test "cyclone_score_single_cell" { test "cyclone_score_cells" { let test_data = @src.cyclone_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let results = @src.cyclone_score_cells(counts, cell_ids, gene_names) assert_eq(results.length(), 20) - + // Check first cell assert_eq(results[0].cell_id, "cell_1") assert_true(results[0].assigned_phase.length() > 0) @@ -130,12 +132,12 @@ test "cyclone_score_cells" { test "cyclone_phase_distribution" { let test_data = @src.cyclone_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let results = @src.cyclone_score_cells(counts, cell_ids, gene_names) let dist = @src.cyclone_phase_distribution(results) - + assert_true(dist.size() > 0) - + // Sum of proportions should be approximately 1.0 let keys = dist.keys() let mut sum = 0.0 @@ -149,7 +151,7 @@ test "cyclone_phase_distribution" { test "cyclone_create_test_data" { let test_data = @src.cyclone_create_test_data() let (counts, cell_ids, gene_names) = test_data - + assert_eq(cell_ids.length(), 20) assert_true(gene_names.length() > 0) assert_true(counts.length() > 0) @@ -175,7 +177,7 @@ test "cyclone_score_empty_cells" { let gene_names : Array[String] = Array::new() let cell_ids : Array[String] = Array::new() let counts : Array[Array[Double]] = Array::new() - + let results = @src.cyclone_score_cells(counts, cell_ids, gene_names) assert_eq(results.length(), 0) } @@ -191,10 +193,10 @@ test "cyclone_phase_distribution_empty" { test "cyclone_average_scores" { let test_data = @src.cyclone_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let results = @src.cyclone_score_cells(counts, cell_ids, gene_names) let avg = @src.cyclone_average_scores(results) - + assert_true(avg.size() == 4) assert_true(avg.contains("G1")) assert_true(avg.contains("S")) @@ -207,4 +209,4 @@ test "cyclone_average_scores_empty" { let results : Array[@src.CycloneResult] = Array::new() let avg = @src.cyclone_average_scores(results) assert_eq(avg.size(), 0) -} \ No newline at end of file +} diff --git a/test/moonbit/decoupler_test.mbt b/test/moonbit/decoupler_test.mbt index 37251805..bb6e03a2 100644 --- a/test/moonbit/decoupler_test.mbt +++ b/test/moonbit/decoupler_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Bioconductor decoupleR module - Functional activity inference. - test "pkn_edge_create" { let e = @src.pkn_edge("TF1", "G1", 1.0) assert_eq(e.source, "TF1") @@ -8,6 +7,7 @@ test "pkn_edge_create" { assert_true((e.weight - 1.0).abs() < 1.0e-9) } +///| test "pkn_from_edges" { let edges = [ @src.pkn_edge("TF1", "G1", 1.0), @@ -20,6 +20,7 @@ test "pkn_from_edges" { assert_eq(pkn.targets.length(), 3) } +///| test "decoupler_sample_data_shape" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() assert_eq(samples.length(), 5) @@ -29,9 +30,16 @@ test "decoupler_sample_data_shape" { assert_true(pkn.edges.length() > 0) } +///| test "decoupler_wsum_basic" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) assert_eq(result.method, "wsum") assert_eq(result.samples.length(), 5) // 3 TFs in the PKN @@ -50,28 +58,50 @@ test "decoupler_wsum_basic" { assert_true(result.matrix[tf1_idx][0] > result.matrix[tf1_idx][3]) } +///| test "decoupler_wmean_basic" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wmean_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wmean_method(), + ) assert_eq(result.method, "wmean") assert_eq(result.regulators.length(), 3) // wmean normalizes by sum of absolute weights, so magnitude is smaller than wsum - let wsum_result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let wsum_result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) let mut i = 0 while i < result.regulators.length() { let mut j = 0 while j < result.samples.length() { // |wmean| should be <= |wsum| (since abs_w_sum >= 1.0) - assert_true(result.matrix[i][j].abs() <= wsum_result.matrix[i][j].abs() + 1.0e-9) + assert_true( + result.matrix[i][j].abs() <= wsum_result.matrix[i][j].abs() + 1.0e-9, + ) j = j + 1 } i = i + 1 } } +///| test "decoupler_norm_basic" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_norm_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_norm_method(), + ) assert_eq(result.method, "norm") // Normalized scores should have mean ~0 per regulator across samples let mut i = 0 @@ -88,9 +118,16 @@ test "decoupler_norm_basic" { } } +///| test "decoupler_ulm_basic" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_ulm_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_ulm_method(), + ) assert_eq(result.method, "ulm") assert_eq(result.regulators.length(), 3) // ULM scores are standardized; mean across samples should be ~0 @@ -108,9 +145,16 @@ test "decoupler_ulm_basic" { } } +///| test "decoupler_mlm_basic" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_mlm_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_mlm_method(), + ) assert_eq(result.method, "mlm") assert_eq(result.regulators.length(), 3) // MLM slope for TF1 should be positive (TF1 activates its targets) @@ -127,16 +171,33 @@ test "decoupler_mlm_basic" { assert_true(result.matrix[tf1_idx][0] > 0.0) } +///| test "decoupler_scores_per_cell" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) // Should have one score per regulator × sample combination - assert_eq(result.scores.length(), result.regulators.length() * result.samples.length()) + assert_eq( + result.scores.length(), + result.regulators.length() * result.samples.length(), + ) } +///| test "decoupler_top_regulators" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) let top = @src.decoupler_top_regulators(result, "S1", 2) assert_true(top.length() <= 2) // Top regulators for S1 should include TF1 (since S1 is TF1-high) @@ -151,16 +212,30 @@ test "decoupler_top_regulators" { assert_true(found_tf1) } +///| test "decoupler_top_regulators_unknown_sample" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) let top = @src.decoupler_top_regulators(result, "UNKNOWN", 3) assert_eq(top.length(), 0) } +///| test "decoupler_filter_scores" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) let filtered = @src.decoupler_filter_scores(result, 0.5) // All filtered scores should have |score| >= 0.5 let mut i = 0 @@ -170,6 +245,7 @@ test "decoupler_filter_scores" { } } +///| test "decoupler_method_to_string" { assert_eq(@src.decoupler_wsum_method().to_string(), "wsum") assert_eq(@src.decoupler_wmean_method().to_string(), "wmean") @@ -178,6 +254,7 @@ test "decoupler_method_to_string" { assert_eq(@src.decoupler_mlm_method().to_string(), "mlm") } +///| test "decoupler_default_method_is_ulm" { let (expr, samples, genes, pkn) = @src.decoupler_sample_data() // Default method argument should be ULM @@ -185,22 +262,28 @@ test "decoupler_default_method_is_ulm" { assert_eq(result.method, "ulm") } +///| test "decoupler_wsum_symmetric_in_sign" { // A PKN with negative weight should produce negative wsum - let edges = [ - @src.pkn_edge("REP", "G1", -1.0), - ] + let edges = [@src.pkn_edge("REP", "G1", -1.0)] let pkn = @src.pkn_from_edges(edges) let expr = [[0.0, 5.0, 0.0], [0.0, 0.0, 0.0]] let samples = ["S1", "S2"] let genes = ["REP", "G1", "G2"] - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) // REP's only target is G1 with weight -1.0; in S1, G1=5 → wsum=-5; in S2, G1=0 → wsum=0 assert_eq(result.regulators.length(), 1) assert_true((result.matrix[0][0] - -5.0).abs() < 1.0e-9) assert_true((result.matrix[0][1] - 0.0).abs() < 1.0e-9) } +///| test "decoupler_pkn_with_unknown_genes" { // PKN with regulator/target not in expression matrix should be filtered out let edges = [ @@ -212,18 +295,31 @@ test "decoupler_pkn_with_unknown_genes" { let expr = [[1.0, 2.0], [3.0, 4.0]] let samples = ["S1", "S2"] let genes = ["TF1", "G1"] - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) // Only TF1 (which appears as a gene) should be in regulators assert_eq(result.regulators.length(), 1) assert_eq(result.regulators[0], "TF1") } +///| test "decoupler_empty_pkn" { let pkn = @src.pkn_from_edges([]) let expr = [[1.0, 2.0], [3.0, 4.0]] let samples = ["S1", "S2"] let genes = ["TF1", "G1"] - let result = @src.decoupler_run(expr, samples, genes, pkn, method=@src.decoupler_wsum_method()) + let result = @src.decoupler_run( + expr, + samples, + genes, + pkn, + method=@src.decoupler_wsum_method(), + ) assert_eq(result.regulators.length(), 0) assert_eq(result.scores.length(), 0) } diff --git a/test/moonbit/delayed_matrix_stats_test.mbt b/test/moonbit/delayed_matrix_stats_test.mbt index c31880be..c090f620 100644 --- a/test/moonbit/delayed_matrix_stats_test.mbt +++ b/test/moonbit/delayed_matrix_stats_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for DelayedMatrixStats module. - test "create_delayed_matrix_basic" { let mat = @src.create_delayed_matrix( [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], @@ -22,11 +21,7 @@ test "create_delayed_matrix_empty" { ///| test "delayed_matrix_get_element" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0], [3.0, 4.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0], [3.0, 4.0]], [], []) assert_eq(mat.get(0, 0), 1.0) assert_eq(mat.get(0, 1), 2.0) assert_eq(mat.get(1, 0), 3.0) @@ -35,11 +30,7 @@ test "delayed_matrix_get_element" { ///| test "delayed_matrix_dim" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], [], []) let d = mat.dim() assert_eq(d[0], 2) assert_eq(d[1], 3) @@ -63,11 +54,9 @@ test "delayed_matrix_subset" { ///| test "delayed_matrix_subset_names" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0], [3.0, 4.0]], - ["r1", "r2"], - ["c1", "c2"], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0], [3.0, 4.0]], ["r1", "r2"], [ + "c1", "c2", + ]) let sub = @src.delayed_matrix_subset(mat, [1], [0]) assert_eq(sub.row_names.length(), 1) assert_eq(sub.col_names.length(), 1) @@ -75,11 +64,7 @@ test "delayed_matrix_subset_names" { ///| test "row_stats_mean" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], [], []) let means = @src.row_stats(mat, "mean") assert_eq(means.length(), 2) assert_eq(means[0], 2.0) @@ -88,11 +73,7 @@ test "row_stats_mean" { ///| test "col_stats_mean" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], [], []) let means = @src.col_stats(mat, "mean") assert_eq(means.length(), 3) assert_eq(means[0], 2.5) @@ -102,11 +83,7 @@ test "col_stats_mean" { ///| test "row_medians" { - let mat = @src.create_delayed_matrix( - [[1.0, 3.0, 2.0], [4.0, 6.0, 5.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 3.0, 2.0], [4.0, 6.0, 5.0]], [], []) let medians = @src.row_medians(mat) assert_eq(medians.length(), 2) assert_eq(medians[0], 2.0) @@ -128,11 +105,7 @@ test "col_medians" { ///| test "row_medians_even" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0, 3.0, 4.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0, 3.0, 4.0]], [], []) let medians = @src.row_medians(mat) assert_eq(medians[0], 2.5) } @@ -165,11 +138,7 @@ test "dms_col_means" { ///| test "dms_row_vars" { - let mat = @src.create_delayed_matrix( - [[2.0, 4.0, 6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[2.0, 4.0, 6.0]], [], []) let vars = @src.dms_row_vars(mat) assert_eq(vars.length(), 1) assert_eq(vars[0], 4.0) @@ -177,11 +146,7 @@ test "dms_row_vars" { ///| test "col_vars" { - let mat = @src.create_delayed_matrix( - [[2.0], [4.0], [6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[2.0], [4.0], [6.0]], [], []) let vars = @src.col_vars(mat) assert_eq(vars.length(), 1) assert_eq(vars[0], 4.0) @@ -189,11 +154,7 @@ test "col_vars" { ///| test "row_allsums" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], [], []) let sums = @src.row_allsums(mat) assert_eq(sums.length(), 2) assert_eq(sums[0], 6.0) @@ -202,11 +163,7 @@ test "row_allsums" { ///| test "row_n_basic" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], [], []) let n = @src.row_n(mat) assert_eq(n.length(), 2) assert_eq(n[0], 3) @@ -243,11 +200,7 @@ test "row_stats_min_max" { ///| test "col_stats_min_max" { - let mat = @src.create_delayed_matrix( - [[3.0, 1.0, 4.0], [9.0, 2.0, 6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[3.0, 1.0, 4.0], [9.0, 2.0, 6.0]], [], []) let mins = @src.col_stats(mat, "min") let maxs = @src.col_stats(mat, "max") assert_eq(mins[0], 3.0) @@ -338,7 +291,10 @@ test "row_medians_with_na" { ///| test "col_stats_all_na" { let mat = @src.create_delayed_matrix( - [[@double.not_a_number, @double.not_a_number], [@double.not_a_number, @double.not_a_number]], + [ + [@double.not_a_number, @double.not_a_number], + [@double.not_a_number, @double.not_a_number], + ], [], [], ) @@ -376,11 +332,7 @@ test "row_stats_nna_stat" { ///| test "row_stats_nn_stat" { - let mat = @src.create_delayed_matrix( - [[1.0, @double.not_a_number, 3.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, @double.not_a_number, 3.0]], [], []) let nn_vals = @src.row_stats(mat, "nn") assert_eq(nn_vals.length(), 1) assert_eq(nn_vals[0], 2.0) @@ -424,11 +376,7 @@ test "row_vars_single_element" { ///| test "col_medians_odd" { - let mat = @src.create_delayed_matrix( - [[1.0], [5.0], [3.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0], [5.0], [3.0]], [], []) let medians = @src.col_medians(mat) assert_eq(medians[0], 3.0) } @@ -470,14 +418,10 @@ test "matrix_stats_result_creation" { ///| test "row_stats_sum_equals_allsums" { - let mat = @src.create_delayed_matrix( - [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], - [], - [], - ) + let mat = @src.create_delayed_matrix([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], [], []) let sums1 = @src.row_allsums(mat) let sums2 = @src.row_stats(mat, "sum") assert_eq(sums1.length(), sums2.length()) assert_eq(sums1[0], sums2[0]) assert_eq(sums1[1], sums2[1]) -} \ No newline at end of file +} diff --git a/test/moonbit/deseq2_test.mbt b/test/moonbit/deseq2_test.mbt index a8f1c0fd..11f69c32 100644 --- a/test/moonbit/deseq2_test.mbt +++ b/test/moonbit/deseq2_test.mbt @@ -4,7 +4,7 @@ ///| test "test_sample_deseq_dataset" { let dds = @src.sample_deseq_dataset() - + assert_eq(dds.counts.length(), 20) assert_eq(dds.col_names.length(), 6) assert_eq(dds.row_names.length(), 20) @@ -18,15 +18,15 @@ test "test_sample_deseq_dataset" { test "test_estimate_size_factors" { let dds = @src.sample_deseq_dataset() let dds_sf = @src.estimate_size_factors(dds) - + assert_eq(dds_sf.size_factors.length(), 6) - + let mut sum_sf = 0.0 for sf in dds_sf.size_factors { assert_true(sf > 0.0) sum_sf = sum_sf + sf } - + let mean_sf = sum_sf / 6.0 assert_true(mean_sf > 0.9 && mean_sf < 1.1) } @@ -36,7 +36,7 @@ test "test_normalize_counts" { let dds = @src.sample_deseq_dataset() let dds_sf = @src.estimate_size_factors(dds) let normalized = @src.normalize_counts(dds_sf) - + assert_eq(normalized.length(), 20) assert_eq(normalized[0].length(), 6) } @@ -46,7 +46,7 @@ test "test_log2_cpm" { let dds = @src.sample_deseq_dataset() let dds_sf = @src.estimate_size_factors(dds) let log2_cpm = @src.log2_cpm(dds_sf) - + assert_eq(log2_cpm.length(), 20) assert_eq(log2_cpm[0].length(), 6) } @@ -56,9 +56,9 @@ test "test_estimate_dispersions" { let dds = @src.sample_deseq_dataset() let dds_sf = @src.estimate_size_factors(dds) let dds_disp = @src.estimate_dispersions(dds_sf) - + assert_eq(dds_disp.dispersions.length(), 20) - + for disp in dds_disp.dispersions { assert_true(disp >= 0.001) } @@ -70,7 +70,7 @@ test "test_deseq" { let dds_sf = @src.estimate_size_factors(dds) let dds_disp = @src.estimate_dispersions(dds_sf) let res = @src.deseq(dds_disp) - + assert_eq(res.row_names.length(), 20) assert_eq(res.base_mean.length(), 20) assert_eq(res.log2_fold_change.length(), 20) @@ -86,7 +86,7 @@ test "test_results" { let dds_sf = @src.estimate_size_factors(dds) let dds_disp = @src.estimate_dispersions(dds_sf) let res = @src.results(dds_disp) - + assert_eq(res.row_names.length(), 20) assert_eq(res.base_mean.length(), 20) assert_eq(res.log2_fold_change.length(), 20) @@ -94,11 +94,11 @@ test "test_results" { assert_eq(res.stat.length(), 20) assert_eq(res.p_value.length(), 20) assert_eq(res.padj.length(), 20) - + for p in res.p_value { assert_true(p >= 0.0 && p <= 1.0) } - + for p in res.padj { assert_true(p >= 0.0 && p <= 1.0) } @@ -111,10 +111,10 @@ test "test_lfc_shrink" { let dds_disp = @src.estimate_dispersions(dds_sf) let res = @src.results(dds_disp) let res_shrunk = @src.lfc_shrink(dds_disp, res) - + assert_eq(res_shrunk.row_names.length(), 20) assert_eq(res_shrunk.log2_fold_change.length(), 20) - + for i = 0; i < 20; i = i + 1 { assert_true(res_shrunk.lfc_se[i] <= res.lfc_se[i]) } @@ -126,12 +126,14 @@ test "test_significant_genes" { let dds_sf = @src.estimate_size_factors(dds) let dds_disp = @src.estimate_dispersions(dds_sf) let res = @src.results(dds_disp) - + let sig_genes = @src.significant_genes(res) assert_true(sig_genes.length() >= 0 && sig_genes.length() <= 20) - + let sig_genes_lfc = @src.significant_genes(res, alpha=0.05, lfc_threshold=0.5) - assert_true(sig_genes_lfc.length() >= 0 && sig_genes_lfc.length() <= sig_genes.length()) + assert_true( + sig_genes_lfc.length() >= 0 && sig_genes_lfc.length() <= sig_genes.length(), + ) } ///| @@ -140,11 +142,11 @@ test "test_top_genes" { let dds_sf = @src.estimate_size_factors(dds) let dds_disp = @src.estimate_dispersions(dds_sf) let res = @src.results(dds_disp) - + let top = @src.top_genes(res, n=5) assert_eq(top.length(), 5) - + for i = 0; i < 4; i = i + 1 { assert_true(top[i].2 <= top[i + 1].2) } -} \ No newline at end of file +} diff --git a/test/moonbit/destiny_test.mbt b/test/moonbit/destiny_test.mbt index f420a8f5..d0f8b74f 100644 --- a/test/moonbit/destiny_test.mbt +++ b/test/moonbit/destiny_test.mbt @@ -1,11 +1,7 @@ ///| test "destiny_create_cell_data" { - let cell = @src.CellData::new( - "cell_001", - [1.0, 2.0, 3.0], - "cluster_1" - ) - + let cell = @src.CellData::new("cell_001", [1.0, 2.0, 3.0], "cluster_1") + assert_eq(cell.cell_id, "cell_001") assert_eq(cell.expression.length(), 3) assert_eq(cell.cluster, "cluster_1") @@ -15,13 +11,15 @@ test "destiny_create_cell_data" { test "destiny_distance_matrix" { let cells = @src.create_example_sc_data(5, 3) let dist_matrix = @src.compute_distance_matrix(cells, "euclidean") - + assert_eq(dist_matrix.n_cells, 5) assert_eq(dist_matrix.cells.length(), 5) - + // Check symmetry - assert_true((dist_matrix.distances[0][1] - dist_matrix.distances[1][0]).abs() < 1.0e-10) - + assert_true( + (dist_matrix.distances[0][1] - dist_matrix.distances[1][0]).abs() < 1.0e-10, + ) + // Check diagonal is zero assert_true(dist_matrix.distances[0][0].abs() < 1.0e-10) } @@ -30,7 +28,7 @@ test "destiny_distance_matrix" { test "destiny_manhattan_distance" { let cells = @src.create_example_sc_data(3, 2) let dist_matrix = @src.compute_distance_matrix(cells, "manhattan") - + assert_eq(dist_matrix.n_cells, 3) assert_true(dist_matrix.distances[0][1] >= 0.0) } @@ -40,14 +38,14 @@ test "destiny_gaussian_kernel" { let cells = @src.create_example_sc_data(5, 3) let dist_matrix = @src.compute_distance_matrix(cells, "euclidean") let kernel = @src.compute_gaussian_kernel(dist_matrix, 1.0) - + assert_eq(kernel.cells.length(), 5) assert_eq(kernel.bandwidth, 1.0) - + // Check kernel values are between 0 and 1 assert_true(kernel.kernel[0][0] <= 1.0) assert_true(kernel.kernel[0][0] >= 0.0) - + // Diagonal should be 1 (exp(0)) assert_true((kernel.kernel[0][0] - 1.0).abs() < 1.0e-10) } @@ -57,7 +55,7 @@ test "destiny_find_sigma" { let cells = @src.create_example_sc_data(10, 3) let dist_matrix = @src.compute_distance_matrix(cells, "euclidean") let sigma = @src.find_sigma_automatic(dist_matrix) - + assert_true(sigma > 0.0) } @@ -65,12 +63,12 @@ test "destiny_find_sigma" { test "destiny_diffusion_map" { let cells = @src.create_example_sc_data(20, 5) let result = @src.compute_diffusion_map(cells, 3, 1.0) - + assert_eq(result.cell_ids.length(), 20) assert_eq(result.eigenvalues.length(), 3) assert_eq(result.embedding.length(), 20) assert_eq(result.explained_variance.length(), 3) - + // Check eigenvalues are non-negative let mut i = 0 while i < 3 { @@ -83,7 +81,7 @@ test "destiny_diffusion_map" { test "destiny_auto_embedding" { let cells = @src.create_example_sc_data(15, 4) let result = @src.destiny_create_embedding(cells, 2) - + assert_eq(result.cell_ids.length(), 15) assert_eq(result.embedding[0].length(), 2) } @@ -93,7 +91,7 @@ test "destiny_plot_coordinates" { let cells = @src.create_example_sc_data(10, 3) let result = @src.destiny_create_embedding(cells, 2) let coords = @src.destiny_plot_coordinates(result, 0, 1) - + assert_eq(coords.length(), 10) } @@ -102,7 +100,7 @@ test "destiny_summary" { let cells = @src.create_example_sc_data(8, 3) let result = @src.destiny_create_embedding(cells, 2) let summary = @src.destiny_summary(result) - + assert_true(summary.contains("Diffusion Map Summary")) assert_true(summary.contains("Number of cells:")) } @@ -110,17 +108,19 @@ test "destiny_summary" { ///| test "destiny_create_sc_data" { let cells = @src.create_example_sc_data(10, 3) - + assert_eq(cells.length(), 10) assert_eq(cells[0].expression.length(), 3) - assert_true(cells[0].cluster == "cluster_1" || cells[0].cluster == "cluster_2") + assert_true( + cells[0].cluster == "cluster_1" || cells[0].cluster == "cluster_2", + ) } ///| test "destiny_euclidean_distance_zero" { let cells = @src.create_example_sc_data(3, 2) let dist_matrix = @src.compute_distance_matrix(cells, "euclidean") - + // Same point should have zero distance assert_true(dist_matrix.distances[0][0].abs() < 1.0e-10) assert_true(dist_matrix.distances[1][1].abs() < 1.0e-10) @@ -130,7 +130,7 @@ test "destiny_euclidean_distance_zero" { test "destiny_small_dataset" { let cells = @src.create_example_sc_data(2, 2) let result = @src.compute_diffusion_map(cells, 1, 0.5) - + assert_eq(result.cell_ids.length(), 2) assert_eq(result.embedding.length(), 2) } diff --git a/test/moonbit/dexseq_test.mbt b/test/moonbit/dexseq_test.mbt index 04cbc660..d4e94b37 100644 --- a/test/moonbit/dexseq_test.mbt +++ b/test/moonbit/dexseq_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for DEXSeq module. - test "ExonCount creation" { let ec = @src.ExonCount::new("gene1", "exon1", [10, 20, 30]) assert_eq(ec.gene_id, "gene1") @@ -8,6 +7,7 @@ test "ExonCount creation" { assert_eq(ec.counts.length(), 3) } +///| test "DEXSeqDataSet creation" { let exon_counts : Array[@src.ExonCount] = Array::new() exon_counts.push(@src.ExonCount::new("gene1", "exon1", [10, 12, 15])) @@ -18,18 +18,21 @@ test "DEXSeqDataSet creation" { assert_eq(ds.gene_ids[0], "gene1") } +///| test "dexseq_normalize_counts" { let ds = @src.create_example_dexseq_dataset() let normalized = @src.dexseq_normalize_counts(ds) assert_eq(normalized.exon_counts.length(), ds.exon_counts.length()) } +///| test "dexseq_test_for_exon_usage" { let ds = @src.create_example_dexseq_dataset() let results = @src.dexseq_test_for_exon_usage(ds) assert_true(results.length() > 0) } +///| test "dexseq_filter_results" { let ds = @src.create_example_dexseq_dataset() let results = @src.dexseq_test_for_exon_usage(ds) diff --git a/test/moonbit/diffcyt_test.mbt b/test/moonbit/diffcyt_test.mbt index 3a9b7389..20852a5c 100644 --- a/test/moonbit/diffcyt_test.mbt +++ b/test/moonbit/diffcyt_test.mbt @@ -10,9 +10,7 @@ ///| test "dc_cell_creation" { - let cell = @src.CytometryCell::new( - "cell_1", "S1", "ctrl", [1.0, 2.0, 3.0] - ) + let cell = @src.CytometryCell::new("cell_1", "S1", "ctrl", [1.0, 2.0, 3.0]) assert_eq(cell.cell_id(), "cell_1") assert_eq(cell.sample_id(), "S1") assert_eq(cell.condition(), "ctrl") @@ -85,7 +83,9 @@ test "dc_assign_clusters_new" { let cells = @src.diffcyt_sample_data() let codebooks = @src.diffcyt_cluster_cells(cells, 4, 10) // Re-assign using existing codebooks. - let new_cells = [@src.CytometryCell::new("nc1", "S1", "ctrl", cells[0].marker_values())] + let new_cells = [ + @src.CytometryCell::new("nc1", "S1", "ctrl", cells[0].marker_values()), + ] @src.diffcyt_assign_clusters(new_cells, codebooks) assert_true(new_cells[0].cluster_id() >= 0) assert_true(new_cells[0].cluster_id() < 4) @@ -121,7 +121,9 @@ test "dc_calc_medians" { let cells = @src.diffcyt_sample_data() let _ = @src.diffcyt_cluster_cells(cells, 3, 10) let samples = @src.diffcyt_unique_samples(cells) - let medians = @src.diffcyt_calc_medians_by_cluster_marker(cells, 3, 3, samples) + let medians = @src.diffcyt_calc_medians_by_cluster_marker( + cells, 3, 3, samples, + ) assert_eq(medians.length(), 4) // 4 samples // Each row has 3 clusters * 3 markers = 9 entries. for row in medians { @@ -219,7 +221,9 @@ test "dc_testDS_returns_results" { conditions.push(cond_map.get(sid).unwrap_or("")) } let marker_names = ["marker_0", "marker_1", "marker_2"] - let ds_results = @src.diffcyt_testDS(cells, samples, conditions, 3, 3, marker_names) + let ds_results = @src.diffcyt_testDS( + cells, samples, conditions, 3, 3, marker_names, + ) // 3 clusters * 3 markers = 9 results (if 2 conditions). assert_true(ds_results.length() > 0) for r in ds_results { @@ -244,7 +248,9 @@ test "dc_testDS_marker_names" { conditions.push(cond_map.get(sid).unwrap_or("")) } let marker_names = ["CD4", "CD8", "CD3"] - let ds_results = @src.diffcyt_testDS(cells, samples, conditions, 2, 3, marker_names) + let ds_results = @src.diffcyt_testDS( + cells, samples, conditions, 2, 3, marker_names, + ) for r in ds_results { assert_true(marker_names.contains(r.marker_name())) } @@ -311,9 +317,9 @@ test "dc_top_table_ds" { for sid in samples { conditions.push(cond_map.get(sid).unwrap_or("")) } - let ds_results = @src.diffcyt_testDS( - cells, samples, conditions, 3, 3, ["m0", "m1", "m2"] - ) + let ds_results = @src.diffcyt_testDS(cells, samples, conditions, 3, 3, [ + "m0", "m1", "m2", + ]) let top5 = @src.diffcyt_top_table_ds(ds_results, 5) assert_true(top5.length() <= 5) if top5.length() >= 2 { diff --git a/test/moonbit/dnashape_test.mbt b/test/moonbit/dnashape_test.mbt index 0629d99b..6f2259ff 100644 --- a/test/moonbit/dnashape_test.mbt +++ b/test/moonbit/dnashape_test.mbt @@ -113,10 +113,10 @@ test "ds_roll_table" { assert_eq(t.length(), 16) // AA (index 0) = -6.0 let v0 = t.get(0).unwrap_or(999.0) - assert_true((v0 - (-6.0)).abs() < 0.001) + assert_true((v0 - -6.0).abs() < 0.001) // TT (index 15) = -6.0 let v15 = t.get(15).unwrap_or(999.0) - assert_true((v15 - (-6.0)).abs() < 0.001) + assert_true((v15 - -6.0).abs() < 0.001) // CG (index 6) = 6.0 let v6 = t.get(6).unwrap_or(999.0) assert_true((v6 - 6.0).abs() < 0.001) @@ -131,7 +131,7 @@ test "ds_prot_table" { assert_true((v0 - 15.0).abs() < 0.001) // TA = -2.0 let v12 = t.get(12).unwrap_or(0.0) - assert_true((v12 - (-2.0)).abs() < 0.001) + assert_true((v12 - -2.0).abs() < 0.001) } ///| @@ -164,10 +164,10 @@ test "ds_ep_table" { assert_eq(t.length(), 16) // AA = -1.5 let v0 = t.get(0).unwrap_or(0.0) - assert_true((v0 - (-1.5)).abs() < 0.001) + assert_true((v0 - -1.5).abs() < 0.001) // CG = -0.6 let v6 = t.get(6).unwrap_or(0.0) - assert_true((v6 - (-0.6)).abs() < 0.001) + assert_true((v6 - -0.6).abs() < 0.001) } // =========================================================================== diff --git a/test/moonbit/dorothea_test.mbt b/test/moonbit/dorothea_test.mbt index 06e55874..7b770a63 100644 --- a/test/moonbit/dorothea_test.mbt +++ b/test/moonbit/dorothea_test.mbt @@ -5,7 +5,7 @@ test "dorothea_get_regulons" { let regulons = @src.dorothea_get_regulons() assert_true(regulons.length() > 0) - + // Check that key TFs are present let mut has_tp53 = false let mut has_myc = false @@ -28,7 +28,9 @@ test "dorothea_regulon_targets" { assert_true(regulon.targets.length() > 0) // Check that all targets have valid directions for target in regulon.targets { - assert_true(target.direction == "activation" || target.direction == "repression") + assert_true( + target.direction == "activation" || target.direction == "repression", + ) } } } @@ -38,7 +40,7 @@ test "dorothea_compute_activity_simple" { let regulons = @src.dorothea_get_regulons() let test_data = @src.dorothea_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let cell_expr : Array[Double] = Array::new() let n_genes = counts.length() let mut g = 0 @@ -46,14 +48,16 @@ test "dorothea_compute_activity_simple" { cell_expr.push(counts[g][0]) g = g + 1 } - + // Find a regulon with targets in our gene set let mut tf_activity = 0.0 for regulon in regulons { - let activity = @src.dorothea_compute_activity_simple(cell_expr, gene_names, regulon) + let activity = @src.dorothea_compute_activity_simple( + cell_expr, gene_names, regulon, + ) tf_activity = tf_activity + activity } - + assert_true(tf_activity >= 0.0) } @@ -62,7 +66,7 @@ test "dorothea_compute_viper_activity" { let regulons = @src.dorothea_get_regulons() let test_data = @src.dorothea_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let cell_expr : Array[Double] = Array::new() let n_genes = counts.length() let mut g = 0 @@ -70,15 +74,17 @@ test "dorothea_compute_viper_activity" { cell_expr.push(counts[g][0]) g = g + 1 } - + let mut has_activity = false for regulon in regulons { - let activity = @src.dorothea_compute_viper_activity(cell_expr, gene_names, regulon) + let activity = @src.dorothea_compute_viper_activity( + cell_expr, gene_names, regulon, + ) if activity.abs() > 0.0 { has_activity = true } } - + // VIPER activities should generally be non-zero if targets are found assert_true(has_activity || regulons.length() > 0) } @@ -88,7 +94,7 @@ test "dorothea_permutation_test" { let regulons = @src.dorothea_get_regulons() let test_data = @src.dorothea_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let cell_expr : Array[Double] = Array::new() let n_genes = counts.length() let mut g = 0 @@ -96,7 +102,7 @@ test "dorothea_permutation_test" { cell_expr.push(counts[g][0]) g = g + 1 } - + // Use a regulon with many targets for better test let mut tp53_regulon = regulons[0] // Default for regulon in regulons { @@ -105,8 +111,10 @@ test "dorothea_permutation_test" { break } } - - let (p_value, z_score) = @src.dorothea_permutation_test(cell_expr, gene_names, tp53_regulon, 100) + + let (p_value, z_score) = @src.dorothea_permutation_test( + cell_expr, gene_names, tp53_regulon, 100, + ) assert_true(p_value >= 0.0 && p_value <= 1.0) } @@ -115,7 +123,7 @@ test "dorothea_analyze_cell" { let regulons = @src.dorothea_get_regulons() let test_data = @src.dorothea_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let cell_expr : Array[Double] = Array::new() let n_genes = counts.length() let mut g = 0 @@ -123,10 +131,12 @@ test "dorothea_analyze_cell" { cell_expr.push(counts[g][0]) g = g + 1 } - + let params = @src.DorotheaParams::with_params(50, 3, 0.05) - let results = @src.dorothea_analyze_cell(cell_expr, gene_names, regulons, params) - + let results = @src.dorothea_analyze_cell( + cell_expr, gene_names, regulons, params, + ) + assert_true(results.length() > 0) for result in results { assert_true(result.n_targets >= 3) @@ -139,10 +149,12 @@ test "dorothea_analyze_cells" { let regulons = @src.dorothea_get_regulons() let test_data = @src.dorothea_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let params = @src.DorotheaParams::with_params(50, 3, 0.05) - let results = @src.dorothea_analyze_cells(counts, cell_ids, gene_names, regulons, params) - + let results = @src.dorothea_analyze_cells( + counts, cell_ids, gene_names, regulons, params, + ) + assert_true(results.length() > 0) assert_true(results.length() <= regulons.length()) } @@ -151,7 +163,7 @@ test "dorothea_analyze_cells" { test "dorothea_create_test_data" { let test_data = @src.dorothea_create_test_data() let (counts, cell_ids, gene_names) = test_data - + assert_eq(cell_ids.length(), 10) assert_true(gene_names.length() > 0) assert_true(counts.length() > 0) @@ -188,9 +200,9 @@ test "dorothea_sort_by_activity" { [], [], @src.dorothea_get_regulons(), - @src.DorotheaParams::with_params(10, 3, 0.05) + @src.DorotheaParams::with_params(10, 3, 0.05), ) - + // Sort empty or small results let sorted = @src.dorothea_sort_by_activity(results) assert_true(sorted.length() <= results.length()) @@ -201,10 +213,12 @@ test "dorothea_get_top_tfs" { let regulons = @src.dorothea_get_regulons() let test_data = @src.dorothea_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let params = @src.DorotheaParams::with_params(20, 3, 0.05) - let results = @src.dorothea_analyze_cells(counts, cell_ids, gene_names, regulons, params) - + let results = @src.dorothea_analyze_cells( + counts, cell_ids, gene_names, regulons, params, + ) + let top3 = @src.dorothea_get_top_tfs(results, 3) assert_true(top3.length() <= 3) } @@ -228,7 +242,7 @@ test "dorothea_get_target_expression" { let regulons = @src.dorothea_get_regulons() let test_data = @src.dorothea_create_test_data() let (counts, cell_ids, gene_names) = test_data - + let cell_expr : Array[Double] = Array::new() let n_genes = counts.length() let mut g = 0 @@ -236,8 +250,12 @@ test "dorothea_get_target_expression" { cell_expr.push(counts[g][0]) g = g + 1 } - + // Test with first regulon - let targets = @src.dorothea_get_target_expression(cell_expr, gene_names, regulons[0]) + let targets = @src.dorothea_get_target_expression( + cell_expr, + gene_names, + regulons[0], + ) assert_true(targets.length() >= 0) -} \ No newline at end of file +} diff --git a/test/moonbit/drimseq_test.mbt b/test/moonbit/drimseq_test.mbt index e372d7e3..e99dae90 100644 --- a/test/moonbit/drimseq_test.mbt +++ b/test/moonbit/drimseq_test.mbt @@ -1,11 +1,13 @@ ///| /// Test file for DRIMSeq module. - test "drimseq_transcript_count_creation" { let tc = @src.TranscriptCount::new( - transcript_id="tx1", gene_id="GeneA", - sample_id="s1", condition="ctrl", - count=100.0, gene_count=150.0, + transcript_id="tx1", + gene_id="GeneA", + sample_id="s1", + condition="ctrl", + count=100.0, + gene_count=150.0, ) assert_eq(tc.transcript_id, "tx1") assert_eq(tc.gene_id, "GeneA") @@ -13,47 +15,77 @@ test "drimseq_transcript_count_creation" { assert_true((tc.proportion() - 0.666666).abs() < 0.01) } +///| test "drimseq_transcript_count_proportion_zero" { let tc = @src.TranscriptCount::new( - transcript_id="tx1", gene_id="GeneA", - sample_id="s1", condition="ctrl", + transcript_id="tx1", + gene_id="GeneA", + sample_id="s1", + condition="ctrl", count=100.0, ) assert_eq(tc.proportion(), 0.0) } +///| test "drimseq_filter_counts" { let counts : Array[@src.TranscriptCount] = Array::new() - counts.push(@src.TranscriptCount::new( - transcript_id="tx1", gene_id="G1", - sample_id="s1", condition="c1", - count=50.0, gene_count=100.0, - )) - counts.push(@src.TranscriptCount::new( - transcript_id="tx2", gene_id="G2", - sample_id="s1", condition="c1", - count=5.0, gene_count=100.0, - )) + counts.push( + @src.TranscriptCount::new( + transcript_id="tx1", + gene_id="G1", + sample_id="s1", + condition="c1", + count=50.0, + gene_count=100.0, + ), + ) + counts.push( + @src.TranscriptCount::new( + transcript_id="tx2", + gene_id="G2", + sample_id="s1", + condition="c1", + count=5.0, + gene_count=100.0, + ), + ) let filtered = @src.drimseq_filter_counts(counts) assert_eq(filtered.length(), 1) assert_eq(filtered[0].transcript_id, "tx1") } +///| test "drimseq_aggregate_by_gene" { let counts : Array[@src.TranscriptCount] = Array::new() - counts.push(@src.TranscriptCount::new( - transcript_id="tx1", gene_id="G1", - sample_id="s1", condition="c1", count=50.0, - )) - counts.push(@src.TranscriptCount::new( - transcript_id="tx2", gene_id="G1", - sample_id="s1", condition="c1", count=30.0, - )) - counts.push(@src.TranscriptCount::new( - transcript_id="tx1", gene_id="G1", - sample_id="s2", condition="c1", count=40.0, - )) + counts.push( + @src.TranscriptCount::new( + transcript_id="tx1", + gene_id="G1", + sample_id="s1", + condition="c1", + count=50.0, + ), + ) + counts.push( + @src.TranscriptCount::new( + transcript_id="tx2", + gene_id="G1", + sample_id="s1", + condition="c1", + count=30.0, + ), + ) + counts.push( + @src.TranscriptCount::new( + transcript_id="tx1", + gene_id="G1", + sample_id="s2", + condition="c1", + count=40.0, + ), + ) let aggregated = @src.drimseq_aggregate_by_gene(counts) assert_eq(aggregated.length(), 2) // G1-s1 and G1-s2 @@ -61,49 +93,72 @@ test "drimseq_aggregate_by_gene" { assert_eq(aggregated[1].count, 40.0) } +///| test "drimseq_compute_proportions" { let counts : Array[@src.TranscriptCount] = Array::new() - counts.push(@src.TranscriptCount::new( - transcript_id="tx1", gene_id="G1", - sample_id="s1", condition="c1", count=50.0, - )) - counts.push(@src.TranscriptCount::new( - transcript_id="tx2", gene_id="G1", - sample_id="s1", condition="c1", count=50.0, - )) + counts.push( + @src.TranscriptCount::new( + transcript_id="tx1", + gene_id="G1", + sample_id="s1", + condition="c1", + count=50.0, + ), + ) + counts.push( + @src.TranscriptCount::new( + transcript_id="tx2", + gene_id="G1", + sample_id="s1", + condition="c1", + count=50.0, + ), + ) let gene_counts : Array[@src.TranscriptCount] = Array::new() - gene_counts.push(@src.TranscriptCount::new( - transcript_id="__gene__", gene_id="G1", - sample_id="s1", condition="c1", count=100.0, - )) + gene_counts.push( + @src.TranscriptCount::new( + transcript_id="__gene__", + gene_id="G1", + sample_id="s1", + condition="c1", + count=100.0, + ), + ) let props = @src.drimseq_compute_proportions(counts, gene_counts) assert_eq(props.length(), 2) assert_true((props[0].proportion() - 0.5).abs() < 0.01) } +///| test "drimseq_wald_test_same" { let a : Array[Double] = Array::new() - a.push(0.5); a.push(0.5) + a.push(0.5) + a.push(0.5) let b : Array[Double] = Array::new() - b.push(0.5); b.push(0.5) + b.push(0.5) + b.push(0.5) let (stat, pval, _) = @src.drimseq_wald_test(a, b) assert_true(pval >= 0.99) // Should not be significant } +///| test "drimseq_wald_test_different" { let a : Array[Double] = Array::new() - a.push(0.8); a.push(0.2) + a.push(0.8) + a.push(0.2) let b : Array[Double] = Array::new() - b.push(0.2); b.push(0.8) + b.push(0.2) + b.push(0.8) let (_, pval, delta) = @src.drimseq_wald_test(a, b) assert_true(pval < 0.05) // Should be significant assert_true(delta.length() == 2) } +///| test "drimseq_result_summary" { let counts = @src.drimseq_sample_data() let result = @src.drimseq_test_differential(counts) @@ -111,6 +166,7 @@ test "drimseq_result_summary" { assert_true(summary.length() > 0) } +///| test "drimseq_result_get_significant" { let counts = @src.drimseq_sample_data() let result = @src.drimseq_test_differential(counts) @@ -118,6 +174,7 @@ test "drimseq_result_get_significant" { assert_true(sig.length() >= 0) } +///| test "drimseq_result_get_top_genes" { let counts = @src.drimseq_sample_data() let result = @src.drimseq_test_differential(counts) @@ -125,20 +182,21 @@ test "drimseq_result_get_top_genes" { assert_true(top.length() <= 2) } +///| test "drimseq_config_creation" { let cfg = @src.DRIMSeqConfig::new() assert_true(cfg.min_count > 0.0) assert_true(cfg.alpha > 0.0) } +///| test "drimseq_config_setters" { - let cfg = @src.DRIMSeqConfig::new() - .set_min_count(val=5.0) - .set_alpha(val=0.01) + let cfg = @src.DRIMSeqConfig::new().set_min_count(val=5.0).set_alpha(val=0.01) assert_eq(cfg.min_count, 5.0) assert_eq(cfg.alpha, 0.01) } +///| test "drimseq_norm_creation" { let n1 = @src.drimseq_norm_none() let n2 = @src.drimseq_norm_tmm() @@ -148,6 +206,7 @@ test "drimseq_norm_creation" { assert_true(n3 == n3) } +///| test "drimseq_full_pipeline" { let counts = @src.drimseq_sample_data() let result = @src.drimseq_test_differential(counts) @@ -156,6 +215,7 @@ test "drimseq_full_pipeline" { assert_true(result.converged) } +///| test "drimseq_empty_data" { let empty : Array[@src.TranscriptCount] = Array::new() let result = @src.drimseq_test_differential(empty) diff --git a/test/moonbit/dss_test.mbt b/test/moonbit/dss_test.mbt index e13ccb3b..0306cbc3 100644 --- a/test/moonbit/dss_test.mbt +++ b/test/moonbit/dss_test.mbt @@ -194,4 +194,4 @@ test "dss_disp_result_methods" { for sd in shrunken { assert_true(sd >= 0.0) } -} \ No newline at end of file +} diff --git a/test/moonbit/dssp_test.mbt b/test/moonbit/dssp_test.mbt index 86a41ec3..192558ac 100644 --- a/test/moonbit/dssp_test.mbt +++ b/test/moonbit/dssp_test.mbt @@ -31,4 +31,4 @@ test "dssp_analyze_structure_composition" { test "dssp_create_example_data" { let data = @src.create_example_dssp_data() assert_eq(data.records.length(), 8) -} \ No newline at end of file +} diff --git a/test/moonbit/edaseq_test.mbt b/test/moonbit/edaseq_test.mbt index bce3cb4d..d7b8b7db 100644 --- a/test/moonbit/edaseq_test.mbt +++ b/test/moonbit/edaseq_test.mbt @@ -26,13 +26,10 @@ test "edaseq_gene_anno_min_length" { test "edaseq_dataset" { let gene_ids = ["gene1", "gene2"] let sample_ids = ["sample1", "sample2", "sample3"] - let counts : Array[Array[Double]] = [ - [10.0, 20.0, 30.0], - [50.0, 60.0, 70.0] - ] + let counts : Array[Array[Double]] = [[10.0, 20.0, 30.0], [50.0, 60.0, 70.0]] let annotations = [ @src.EDASeqGeneAnno::new("gene1", 0.45, 1000.0), - @src.EDASeqGeneAnno::new("gene2", 0.55, 2000.0) + @src.EDASeqGeneAnno::new("gene2", 0.55, 2000.0), ] let data = @src.EDASeqDataSet::new(gene_ids, sample_ids, counts, annotations) assert_eq(data.eda_n_genes(), 2) @@ -58,7 +55,7 @@ test "edaseq_sample_counts" { let counts : Array[Array[Double]] = [[10.0], [20.0]] let annotations = [ @src.EDASeqGeneAnno::new("gene1", 0.5, 500.0), - @src.EDASeqGeneAnno::new("gene2", 0.6, 1000.0) + @src.EDASeqGeneAnno::new("gene2", 0.6, 1000.0), ] let data = @src.EDASeqDataSet::new(gene_ids, sample_ids, counts, annotations) let sample_counts = data.eda_sample_counts(0) @@ -74,12 +71,12 @@ test "edaseq_within_lane" { let counts : Array[Array[Double]] = [ [100.0, 200.0], [300.0, 400.0], - [500.0, 600.0] + [500.0, 600.0], ] let annotations = [ @src.EDASeqGeneAnno::new("gene1", 0.4, 500.0), @src.EDASeqGeneAnno::new("gene2", 0.5, 1000.0), - @src.EDASeqGeneAnno::new("gene3", 0.6, 2000.0) + @src.EDASeqGeneAnno::new("gene3", 0.6, 2000.0), ] let data = @src.EDASeqDataSet::new(gene_ids, sample_ids, counts, annotations) let params = @src.EDASeqParams::new() @@ -93,11 +90,11 @@ test "edaseq_between_lane" { let sample_ids = ["s1", "s2", "s3"] let counts : Array[Array[Double]] = [ [100.0, 200.0, 300.0], - [500.0, 600.0, 700.0] + [500.0, 600.0, 700.0], ] let annotations = [ @src.EDASeqGeneAnno::new("gene1", 0.5, 500.0), - @src.EDASeqGeneAnno::new("gene2", 0.55, 1000.0) + @src.EDASeqGeneAnno::new("gene2", 0.55, 1000.0), ] let data = @src.EDASeqDataSet::new(gene_ids, sample_ids, counts, annotations) let params = @src.EDASeqParams::new() @@ -112,12 +109,12 @@ test "edaseq_full_run" { let counts : Array[Array[Double]] = [ [100.0, 200.0], [300.0, 400.0], - [500.0, 600.0] + [500.0, 600.0], ] let annotations = [ @src.EDASeqGeneAnno::new("gene1", 0.4, 500.0), @src.EDASeqGeneAnno::new("gene2", 0.5, 1000.0), - @src.EDASeqGeneAnno::new("gene3", 0.6, 2000.0) + @src.EDASeqGeneAnno::new("gene3", 0.6, 2000.0), ] let data = @src.EDASeqDataSet::new(gene_ids, sample_ids, counts, annotations) let params = @src.EDASeqParams::new() @@ -130,13 +127,10 @@ test "edaseq_full_run" { test "edaseq_result_accessors" { let gene_ids = ["gene1", "gene2"] let sample_ids = ["s1", "s2"] - let counts : Array[Array[Double]] = [ - [100.0, 200.0], - [300.0, 400.0] - ] + let counts : Array[Array[Double]] = [[100.0, 200.0], [300.0, 400.0]] let annotations = [ @src.EDASeqGeneAnno::new("gene1", 0.5, 500.0), - @src.EDASeqGeneAnno::new("gene2", 0.55, 1000.0) + @src.EDASeqGeneAnno::new("gene2", 0.55, 1000.0), ] let data = @src.EDASeqDataSet::new(gene_ids, sample_ids, counts, annotations) let params = @src.EDASeqParams::new() diff --git a/test/moonbit/edger_advanced_test.mbt b/test/moonbit/edger_advanced_test.mbt index 71e473ca..60fa5008 100644 --- a/test/moonbit/edger_advanced_test.mbt +++ b/test/moonbit/edger_advanced_test.mbt @@ -180,9 +180,9 @@ test "camera_with_all_genes_in_set" { ) let qlf = @src.glm_qlf_fit(dge) let result = @src.glm_qlf_test(qlf) - let (stat, pval, dir) = @src.camera( - result, ["GeneA", "GeneB", "GeneC", "GeneD"], - ) + let (stat, pval, dir) = @src.camera(result, [ + "GeneA", "GeneB", "GeneC", "GeneD", + ]) assert_true(pval >= 0.0 && pval <= 1.0) assert_true(dir == "up" || dir == "down" || dir == "none") } @@ -221,11 +221,7 @@ test "roast_with_empty_gene_set" { ///| test "qlf_test_handles_single_sample_per_group" { - let dge = @src.dge_list( - [[10, 20], [30, 40]], - ["A", "B"], - ["G1", "G2"], - ) + let dge = @src.dge_list([[10, 20], [30, 40]], ["A", "B"], ["G1", "G2"]) let qlf = @src.glm_qlf_fit(dge) let result = @src.glm_qlf_test(qlf) assert_eq(result.genes.length(), 2) @@ -238,4 +234,4 @@ test "qlf_test_handles_single_sample_per_group" { for f in result.fdr { assert_true(f >= 0.0 && f <= 1.0) } -} \ No newline at end of file +} diff --git a/test/moonbit/enhanced_volcano_test.mbt b/test/moonbit/enhanced_volcano_test.mbt index b60a0993..16410965 100644 --- a/test/moonbit/enhanced_volcano_test.mbt +++ b/test/moonbit/enhanced_volcano_test.mbt @@ -1,6 +1,5 @@ ///| /// Test file for EnhancedVolcano module. - test "volcano_plot_basic" { let ids = ["TP53", "BRCA1", "MYC", "KRAS", "EGFR"] let lfcs = [2.5, -3.0, 1.2, -0.5, 0.1] @@ -9,101 +8,194 @@ test "volcano_plot_basic" { assert_eq(result.get_n_genes(), 5) } +///| test "volcano_classification_up" { let ids = ["Gene1", "Gene2", "Gene3"] let lfcs = [2.0, -2.0, 0.5] let pvals = [0.001, 0.001, 0.001] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="Test", x_label="x", y_label="y") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="Test", + x_label="x", + y_label="y", + ) assert_eq(result.get_n_up(), 1) assert_eq(result.get_n_down(), 1) assert_eq(result.get_n_nonsig(), 1) } +///| test "volcano_classification_all_sig" { let ids = ["A", "B", "C", "D"] let lfcs = [2.5, -2.5, 1.5, -1.5] let pvals = [0.001, 0.001, 0.01, 0.01] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="", x_label="", y_label="") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="", + x_label="", + y_label="", + ) assert_eq(result.get_n_up(), 2) assert_eq(result.get_n_down(), 2) assert_eq(result.get_n_nonsig(), 0) } +///| test "volcano_classification_none_sig" { let ids = ["A", "B", "C"] let lfcs = [0.1, -0.1, 0.5] let pvals = [0.1, 0.2, 0.1] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="", x_label="", y_label="") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="", + x_label="", + y_label="", + ) assert_eq(result.get_n_up(), 0) assert_eq(result.get_n_down(), 0) assert_eq(result.get_n_nonsig(), 3) } +///| test "volcano_get_genes" { let ids = ["A", "B", "C"] let lfcs = [2.0, -2.0, 0.5] let pvals = [0.001, 0.001, 0.001] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="", x_label="", y_label="") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="", + x_label="", + y_label="", + ) let genes = result.get_genes() assert_eq(genes.length(), 3) } +///| test "volcano_get_significant" { let ids = ["A", "B", "C"] let lfcs = [2.0, -2.0, 0.5] let pvals = [0.001, 0.001, 0.001] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="", x_label="", y_label="") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="", + x_label="", + y_label="", + ) let sig = result.get_significant_genes() assert_eq(sig.length(), 2) // A (Up) and B (Down) } +///| test "volcano_get_up_genes" { let ids = ["A", "B", "C"] let lfcs = [2.0, -2.0, 1.5] let pvals = [0.001, 0.001, 0.001] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="", x_label="", y_label="") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="", + x_label="", + y_label="", + ) let up = result.get_up_genes() assert_eq(up.length(), 2) } +///| test "volcano_get_down_genes" { let ids = ["A", "B", "C"] let lfcs = [2.0, -2.0, -1.5] let pvals = [0.001, 0.001, 0.001] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="", x_label="", y_label="") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="", + x_label="", + y_label="", + ) let down = result.get_down_genes() assert_eq(down.length(), 2) } +///| test "volcano_get_top_genes" { let ids = ["A", "B", "C", "D", "E"] let lfcs = [2.5, -3.0, 1.5, -1.5, 0.3] let pvals = [0.01, 0.001, 0.02, 0.005, 0.001] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="", x_label="", y_label="") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="", + x_label="", + y_label="", + ) let top = result.get_top_genes(3) assert_eq(top.length(), 3) } +///| test "volcano_neg_log10_p" { let nlp = @src.neg_log10_p(0.05) assert_true(nlp > 1.29) // -log10(0.05) = 1.301 assert_true(nlp < 1.31) } +///| test "volcano_neg_log10_p_zero" { let nlp = @src.neg_log10_p(0.0) assert_true(nlp > 0.0) // should handle p=0 gracefully } +///| test "volcano_cutoffs" { let ids = ["A", "B"] let lfcs = [2.0, -2.0] let pvals = [0.001, 0.001] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.01, fc_cutoff=2.0, title="", x_label="", y_label="") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.01, + fc_cutoff=2.0, + title="", + x_label="", + y_label="", + ) assert_eq(result.get_p_cutoff(), 0.01) assert_eq(result.get_fc_cutoff(), 2.0) } +///| test "volcano_to_ascii" { let result = @src.volcano_sample(20) let ascii = result.to_ascii(width=60, height=20) @@ -111,6 +203,7 @@ test "volcano_to_ascii" { assert_true(ascii.contains("Volcano Plot")) } +///| test "volcano_summary" { let result = @src.volcano_sample(10) let summary = result.summary() @@ -118,6 +211,7 @@ test "volcano_summary" { assert_true(summary.contains("Total genes")) } +///| test "volcano_sample" { let result = @src.volcano_sample(30) assert_eq(result.get_n_genes(), 30) @@ -126,21 +220,32 @@ test "volcano_sample" { assert_true(result.get_n_nonsig() >= 0) } +///| test "volcano_classification_to_string" { // Test classification through the result of volcano_plot let ids = ["Gene1", "Gene2", "Gene3"] let lfcs = [2.0, -2.0, 0.5] let pvals = [0.001, 0.001, 0.5] - let result = @src.volcano_plot(ids, lfcs, pvals, p_cutoff=0.05, fc_cutoff=1.0, title="Test", x_label="log2FC", y_label="-log10(p)") + let result = @src.volcano_plot( + ids, + lfcs, + pvals, + p_cutoff=0.05, + fc_cutoff=1.0, + title="Test", + x_label="log2FC", + y_label="-log10(p)", + ) let genes = result.get_genes() assert_eq(genes.length(), 3) - + // Check that classifications work by examining result counts - assert_true(result.get_n_up() >= 1) // Gene1 should be Up - assert_true(result.get_n_down() >= 1) // Gene2 should be Down - assert_true(result.get_n_nonsig() >= 1) // Gene3 should be NonSig + assert_true(result.get_n_up() >= 1) // Gene1 should be Up + assert_true(result.get_n_down() >= 1) // Gene2 should be Down + assert_true(result.get_n_nonsig() >= 1) // Gene3 should be NonSig } +///| test "volcano_empty_inputs" { let ids : Array[String] = Array::new() let lfcs : Array[Double] = Array::new() @@ -149,9 +254,10 @@ test "volcano_empty_inputs" { assert_eq(result.get_n_genes(), 0) } +///| test "volcano_ascii_visual_elements" { let result = @src.volcano_sample(50) let ascii = result.to_ascii(width=60, height=20) assert_true(ascii.contains("+")) // up-regulated assert_true(ascii.contains("-")) // down-regulated -} \ No newline at end of file +} diff --git a/test/moonbit/enriched_heatmap_test.mbt b/test/moonbit/enriched_heatmap_test.mbt index b17afaa8..70985adc 100644 --- a/test/moonbit/enriched_heatmap_test.mbt +++ b/test/moonbit/enriched_heatmap_test.mbt @@ -247,7 +247,7 @@ test "eh_normalize_background" { // All values should be background (-1.0) since signal is on different chr. let mut j = 0 while j < mat.nCols { - assert_true((mat.matrix[0][j] - (-1.0)).abs() < 1.0e-10) + assert_true((mat.matrix[0][j] - -1.0).abs() < 1.0e-10) j = j + 1 } } @@ -286,7 +286,10 @@ test "eh_row_means" { ///| test "eh_minus_strand" { // Test that minus strand reverses window order. - let signals = [@src.GenomicSignal::new("chr1", 9800, 9900, 0.5), @src.GenomicSignal::new("chr1", 10100, 10200, 1.0)] + let signals = [ + @src.GenomicSignal::new("chr1", 9800, 9900, 0.5), + @src.GenomicSignal::new("chr1", 10100, 10200, 1.0), + ] let targets = [@src.TargetRegion::new("chr1", 10000, 10000, "-")] let config = @src.EnrichedHeatmapConfig::new( extendUp=500, diff --git a/test/moonbit/enrichplot_test.mbt b/test/moonbit/enrichplot_test.mbt index d932f441..f7a49a73 100644 --- a/test/moonbit/enrichplot_test.mbt +++ b/test/moonbit/enrichplot_test.mbt @@ -1,11 +1,16 @@ ///| - test "enrichplot_create_enrich_term" { let term = @src.EnrichTerm::new( - "GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, - ["gene1", "gene2", "gene3"] + "GO:0005623", + "cell", + 0.001, + 0.01, + 1.5, + 1.8, + 15, + ["gene1", "gene2", "gene3"], ) - + assert_eq(term.term_id, "GO:0005623") assert_eq(term.term_name, "cell") assert_eq(term.pvalue, 0.001) @@ -16,82 +21,124 @@ test "enrichplot_create_enrich_term" { assert_eq(term.genes.length(), 3) } +///| test "enrichplot_dotplot" { let terms = [ - @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, ["g1", "g2", "g3"]), - @src.EnrichTerm::new("GO:0005886", "plasma membrane", 0.002, 0.02, 1.2, 1.5, 10, ["g4", "g5"]), - @src.EnrichTerm::new("GO:0003674", "molecular_function", 0.003, 0.03, 0.8, 1.0, 8, ["g6"]), + @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, [ + "g1", "g2", "g3", + ]), + @src.EnrichTerm::new( + "GO:0005886", + "plasma membrane", + 0.002, + 0.02, + 1.2, + 1.5, + 10, + ["g4", "g5"], + ), + @src.EnrichTerm::new( + "GO:0003674", + "molecular_function", + 0.003, + 0.03, + 0.8, + 1.0, + 8, + ["g6"], + ), ] - + let result = @src.EnrichResult::new(terms, "GO", []) let plot = @src.bio_enrichplot_dotplot(result, 10, "Test Dotplot") - + assert_true(plot.contains("cell")) assert_true(plot.contains("plasma membrane")) assert_true(plot.contains("molecular_function")) } +///| test "enrichplot_barplot" { let terms = [ @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, ["g1"]), - @src.EnrichTerm::new("GO:0005886", "membrane", 0.002, 0.02, 1.2, 1.5, 10, ["g2"]), + @src.EnrichTerm::new("GO:0005886", "membrane", 0.002, 0.02, 1.2, 1.5, 10, [ + "g2", + ]), ] - + let result = @src.EnrichResult::new(terms, "GO", []) let plot = @src.bio_enrichplot_barplot(result, 5, "padj", "Test Barplot") - + assert_true(plot.contains("cell")) assert_true(plot.contains("membrane")) } +///| test "enrichplot_heatmap" { let terms = [ - @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, ["g1", "g2", "g3"]), - @src.EnrichTerm::new("GO:0005886", "membrane", 0.002, 0.02, 1.2, 1.5, 10, ["g2", "g4"]), + @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, [ + "g1", "g2", "g3", + ]), + @src.EnrichTerm::new("GO:0005886", "membrane", 0.002, 0.02, 1.2, 1.5, 10, [ + "g2", "g4", + ]), ] - + let result = @src.EnrichResult::new(terms, "GO", []) let plot = @src.bio_enrichplot_heatmap(result, 5, 5, "Test Heatmap") - + assert_true(plot.contains("cell")) assert_true(plot.contains("membrane")) } +///| test "enrichplot_cnetplot" { let terms = [ - @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, ["g1", "g2"]), - @src.EnrichTerm::new("GO:0005886", "membrane", 0.002, 0.02, 1.2, 1.5, 10, ["g2", "g3"]), + @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, [ + "g1", "g2", + ]), + @src.EnrichTerm::new("GO:0005886", "membrane", 0.002, 0.02, 1.2, 1.5, 10, [ + "g2", "g3", + ]), ] - + let result = @src.EnrichResult::new(terms, "GO", []) let plot = @src.bio_enrichplot_cnetplot(result, 5, "Test Cnetplot") - + assert_true(plot.contains("cell")) assert_true(plot.contains("membrane")) assert_true(plot.contains("g1")) assert_true(plot.contains("g2")) } +///| test "enrichplot_emapplot" { let terms = [ - @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, ["g1", "g2", "g3"]), - @src.EnrichTerm::new("GO:0005886", "membrane", 0.002, 0.02, 1.2, 1.5, 10, ["g2", "g3", "g4"]), - @src.EnrichTerm::new("GO:0003674", "function", 0.003, 0.03, 0.8, 1.0, 8, ["g5"]), + @src.EnrichTerm::new("GO:0005623", "cell", 0.001, 0.01, 1.5, 1.8, 15, [ + "g1", "g2", "g3", + ]), + @src.EnrichTerm::new("GO:0005886", "membrane", 0.002, 0.02, 1.2, 1.5, 10, [ + "g2", "g3", "g4", + ]), + @src.EnrichTerm::new("GO:0003674", "function", 0.003, 0.03, 0.8, 1.0, 8, [ + "g5", + ]), ] - + let result = @src.EnrichResult::new(terms, "GO", []) let plot = @src.bio_enrichplot_emapplot(result, 0.3, "Test Emapplot") - + assert_true(plot.contains("cell")) assert_true(plot.contains("membrane")) } +///| test "enrichplot_empty_result" { let result = @src.EnrichResult::new([], "GO", []) - + let dotplot = @src.bio_enrichplot_dotplot(result, 10, "Test") assert_true(dotplot.contains("Test")) - + let barplot = @src.bio_enrichplot_barplot(result, 10, "padj", "Test") assert_true(barplot.contains("Test")) -} \ No newline at end of file +} diff --git a/test/moonbit/ensembldb_test.mbt b/test/moonbit/ensembldb_test.mbt index a6abe537..0aa49b11 100644 --- a/test/moonbit/ensembldb_test.mbt +++ b/test/moonbit/ensembldb_test.mbt @@ -1,38 +1,42 @@ ///| /// Tests for ensembldb module. - test "EnsDb creation" { let db = @src.create_example_ensdb() assert_eq(@src.edb_num_genes(db), 3) assert_eq(@src.edb_num_transcripts(db), 4) } +///| test "edb_get_gene_by_id" { let db = @src.create_example_ensdb() let gene = @src.edb_get_gene_by_id(db, "ENSG000001") assert_true(gene is Some(_)) } +///| test "edb_get_gene_by_name" { let db = @src.create_example_ensdb() let genes = @src.edb_get_gene_by_name(db, "ACTB") assert_eq(genes.length(), 1) } +///| test "edb_get_transcripts_by_gene" { let db = @src.create_example_ensdb() let txs = @src.edb_get_transcripts_by_gene(db, "ENSG000001") assert_eq(txs.length(), 2) } +///| test "edb_filter_by_chromosome" { let db = @src.create_example_ensdb() let filtered = @src.edb_filter_by_chromosome(db, "17") assert_eq(@src.edb_num_genes(filtered), 2) } +///| test "edb_get_gene_length" { let db = @src.create_example_ensdb() let length = @src.edb_get_gene_length(db, "ENSG000001") assert_eq(length, 6257) -} \ No newline at end of file +} diff --git a/test/moonbit/estimate_score_test.mbt b/test/moonbit/estimate_score_test.mbt index b59c15be..8e0b0581 100644 --- a/test/moonbit/estimate_score_test.mbt +++ b/test/moonbit/estimate_score_test.mbt @@ -7,27 +7,27 @@ // --------------------------------------------------------------------------- test "est_expression_creation" { - let expr = @src.EstExpression::new( - ["G1", "G2"], - ["S1", "S2"], - [[1.0, 2.0], [3.0, 4.0]], - ) + let expr = @src.EstExpression::new(["G1", "G2"], ["S1", "S2"], [ + [1.0, 2.0], + [3.0, 4.0], + ]) assert_eq(expr.gene_names().length(), 2) assert_eq(expr.sample_names().length(), 2) assert_eq(expr.matrix()[1][0], 3.0) } +///| test "est_signature_creation" { - let sig = @src.EstSignature::new( - ["STROMA1", "STROMA2"], - ["IMMUNE1", "IMMUNE2"], - ) + let sig = @src.EstSignature::new(["STROMA1", "STROMA2"], [ + "IMMUNE1", "IMMUNE2", + ]) assert_eq(sig.stromal_genes().length(), 2) assert_eq(sig.immune_genes().length(), 2) assert_eq(sig.stromal_genes()[0], "STROMA1") assert_eq(sig.immune_genes()[1], "IMMUNE2") } +///| test "est_sample_score_accessors" { // Use est_run to get real scores and test accessors let expr = @src.est_sample_data() @@ -43,6 +43,7 @@ test "est_sample_score_accessors" { ) } +///| test "est_result_accessors" { // Use est_run to get a real result and test accessors let expr = @src.est_sample_data() @@ -56,6 +57,7 @@ test "est_result_accessors" { // Built-in gene signatures // --------------------------------------------------------------------------- +///| test "est_stromal_genes_nonempty" { let genes = @src.est_stromal_genes() assert_true(genes.length() >= 30) @@ -63,24 +65,32 @@ test "est_stromal_genes_nonempty" { let mut has_col1a1 = false let mut has_dcn = false for g in genes { - if g == "COL1A1" { has_col1a1 = true } - if g == "DCN" { has_dcn = true } + if g == "COL1A1" { + has_col1a1 = true + } + if g == "DCN" { + has_dcn = true + } } assert_true(has_col1a1) assert_true(has_dcn) } +///| test "est_immune_genes_nonempty" { let genes = @src.est_immune_genes() assert_true(genes.length() >= 20) // Should contain typical immune markers like CD3D, CD3E let mut has_cd3d = false for g in genes { - if g == "CD3D" { has_cd3d = true } + if g == "CD3D" { + has_cd3d = true + } } assert_true(has_cd3d) } +///| test "est_default_signature" { let sig = @src.est_default_signature() assert_true(sig.stromal_genes().length() >= 30) @@ -91,6 +101,7 @@ test "est_default_signature" { // ECDF normalization behavior // --------------------------------------------------------------------------- +///| test "est_run_normalizes_across_samples" { // With 4 samples, ECDF values are 0.25, 0.5, 0.75, 1.0 // Scores should be in [-100, 100] range @@ -112,6 +123,7 @@ test "est_run_normalizes_across_samples" { // Sample data correctness // --------------------------------------------------------------------------- +///| test "est_sample_data_dimensions" { let expr = @src.est_sample_data() assert_eq(expr.sample_names().length(), 4) @@ -123,6 +135,7 @@ test "est_sample_data_dimensions" { } } +///| test "est_sample_data_sample_names" { let expr = @src.est_sample_data() assert_eq(expr.sample_names()[0], "HighStromal") @@ -135,6 +148,7 @@ test "est_sample_data_sample_names" { // Score semantics // --------------------------------------------------------------------------- +///| test "est_run_high_stromal_higher_than_low_stromal" { // HighStromal sample should have higher stromal score than LowBoth let expr = @src.est_sample_data() @@ -144,6 +158,7 @@ test "est_run_high_stromal_higher_than_low_stromal" { assert_true(high_stromal.stromal_score() > low_both.stromal_score()) } +///| test "est_run_high_immune_higher_than_low_immune" { // HighImmune sample should have higher immune score than LowBoth let expr = @src.est_sample_data() @@ -153,6 +168,7 @@ test "est_run_high_immune_higher_than_low_immune" { assert_true(high_immune.immune_score() > low_both.immune_score()) } +///| test "est_run_high_both_highest_estimate_score" { // HighBoth should have the highest combined ESTIMATE score let expr = @src.est_sample_data() @@ -162,6 +178,7 @@ test "est_run_high_both_highest_estimate_score" { assert_true(high_both.estimate_score() > low_both.estimate_score()) } +///| test "est_run_estimate_score_equals_stromal_plus_immune" { // ESTIMATEScore = StromalScore + ImmuneScore let expr = @src.est_sample_data() @@ -172,6 +189,7 @@ test "est_run_estimate_score_equals_stromal_plus_immune" { } } +///| test "est_run_low_both_has_low_scores" { // LowBoth (low infiltration) should have negative scores for both let expr = @src.est_sample_data() @@ -185,6 +203,7 @@ test "est_run_low_both_has_low_scores" { // Tumor purity // --------------------------------------------------------------------------- +///| test "est_run_tumor_purity_in_valid_range" { // Tumor purity should be in [0, 1] or NaN let expr = @src.est_sample_data() @@ -201,6 +220,7 @@ test "est_run_tumor_purity_in_valid_range" { } } +///| test "est_run_low_infiltration_higher_purity" { // LowBoth (low infiltration -> higher tumor content) should have higher // tumor purity than HighBoth (high infiltration -> lower tumor content) @@ -208,8 +228,7 @@ test "est_run_low_infiltration_higher_purity" { let result = @src.est_run(expr) let low_both = result.get_score("LowBoth") let high_both = result.get_score("HighBoth") - if !low_both.tumor_purity().is_nan() && - !high_both.tumor_purity().is_nan() { + if !low_both.tumor_purity().is_nan() && !high_both.tumor_purity().is_nan() { assert_true(low_both.tumor_purity() >= high_both.tumor_purity()) } } @@ -218,19 +237,16 @@ test "est_run_low_infiltration_higher_purity" { // Custom signature // --------------------------------------------------------------------------- +///| test "est_run_custom_signature" { // Build expression matrix with 4 genes, 2 samples // G1, G2 are stromal markers; G3, G4 are immune markers - let expr = @src.EstExpression::new( - ["G1", "G2", "G3", "G4"], - ["S1", "S2"], - [ - [10.0, 1.0], // G1 - stromal, high in S1 - [8.0, 1.0], // G2 - stromal, high in S1 - [1.0, 10.0], // G3 - immune, high in S2 - [1.0, 8.0], // G4 - immune, high in S2 - ], - ) + let expr = @src.EstExpression::new(["G1", "G2", "G3", "G4"], ["S1", "S2"], [ + [10.0, 1.0], // G1 - stromal, high in S1 + [8.0, 1.0], // G2 - stromal, high in S1 + [1.0, 10.0], // G3 - immune, high in S2 + [1.0, 8.0], // G4 - immune, high in S2 + ]) let sig = @src.EstSignature::new(["G1", "G2"], ["G3", "G4"]) let result = @src.est_run(expr, signature=sig) assert_eq(result.scores().length(), 2) @@ -241,13 +257,13 @@ test "est_run_custom_signature" { assert_true(s2.immune_score() > s1.immune_score()) } +///| test "est_run_empty_signature_returns_zeros" { // With empty gene sets, ssGSEA returns 0; ECDF of all-zeros is degenerate - let expr = @src.EstExpression::new( - ["G1", "G2"], - ["S1", "S2"], - [[1.0, 2.0], [3.0, 4.0]], - ) + let expr = @src.EstExpression::new(["G1", "G2"], ["S1", "S2"], [ + [1.0, 2.0], + [3.0, 4.0], + ]) let sig = @src.EstSignature::new([], []) let result = @src.est_run(expr, signature=sig) for s in result.scores() { @@ -261,6 +277,7 @@ test "est_run_empty_signature_returns_zeros" { // get_score and to_string // --------------------------------------------------------------------------- +///| test "est_result_get_score_known_sample" { let expr = @src.est_sample_data() let result = @src.est_run(expr) @@ -268,6 +285,7 @@ test "est_result_get_score_known_sample" { assert_eq(s.sample_id(), "HighStromal") } +///| test "est_result_get_score_unknown_sample" { let expr = @src.est_sample_data() let result = @src.est_run(expr) @@ -278,6 +296,7 @@ test "est_result_get_score_unknown_sample" { assert_true(s.estimate_score().abs() < 1.0e-9) } +///| test "est_result_to_string" { let expr = @src.est_sample_data() let result = @src.est_run(expr) @@ -293,13 +312,15 @@ test "est_result_to_string" { // Edge cases // --------------------------------------------------------------------------- +///| test "est_run_single_sample" { // Single sample: ECDF is degenerate (trivially all-equal), scores are 0.0 - let expr = @src.EstExpression::new( - ["G1", "G2", "G3", "G4"], - ["Only"], - [[10.0], [8.0], [5.0], [3.0]], - ) + let expr = @src.EstExpression::new(["G1", "G2", "G3", "G4"], ["Only"], [ + [10.0], + [8.0], + [5.0], + [3.0], + ]) let sig = @src.EstSignature::new(["G1", "G2"], ["G3", "G4"]) let result = @src.est_run(expr, signature=sig) assert_eq(result.scores().length(), 1) @@ -309,13 +330,14 @@ test "est_run_single_sample" { assert_true(s.immune_score().abs() < 1.0e-9) } +///| test "est_run_no_signature_genes_present" { // None of the signature genes are in the expression matrix - let expr = @src.EstExpression::new( - ["X1", "X2", "X3"], - ["S1", "S2"], - [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], - ) + let expr = @src.EstExpression::new(["X1", "X2", "X3"], ["S1", "S2"], [ + [1.0, 2.0], + [3.0, 4.0], + [5.0, 6.0], + ]) let sig = @src.EstSignature::new(["G1", "G2"], ["G3", "G4"]) let result = @src.est_run(expr, signature=sig) // All scores should be 0 (or near 0) since no genes match @@ -325,6 +347,7 @@ test "est_run_no_signature_genes_present" { } } +///| test "est_run_all_samples_identical" { // Identical samples should have identical scores let expr = @src.EstExpression::new( diff --git a/test/moonbit/exonerate_test.mbt b/test/moonbit/exonerate_test.mbt index 6339760b..4686769e 100644 --- a/test/moonbit/exonerate_test.mbt +++ b/test/moonbit/exonerate_test.mbt @@ -38,9 +38,7 @@ test "exonerate_record_new" { @src.AlignmentBlock::new("I", 0, 0, 1000.0), ] let rec = @src.ExonerateRecord::new( - "query1", 0, 100, "+", - "target1", 0, 95, "+", - 1850.0, blocks, + "query1", 0, 100, "+", "target1", 0, 95, "+", 1850.0, blocks, ) assert_eq(rec.query_name(), "query1") assert_eq(rec.query_start(), 0) diff --git a/test/moonbit/expasy_test.mbt b/test/moonbit/expasy_test.mbt index 46954e8e..ed587009 100644 --- a/test/moonbit/expasy_test.mbt +++ b/test/moonbit/expasy_test.mbt @@ -1,41 +1,45 @@ ///| /// Tests for ExPASy module. - test "ExPASyRecord creation" { let record = @src.ExPASyRecord::new("P04637", "Swiss-Prot") assert_eq(record.id, "P04637") assert_eq(record.database, "Swiss-Prot") } +///| test "ExPASyRecord add field" { let record = @src.ExPASyRecord::new("P04637", "Swiss-Prot") let record2 = record.add_field("description", "Tumor protein p53") - + let desc = record2.get_field("description") assert_true(desc is Some(_)) assert_eq(desc.unwrap(), "Tumor protein p53") } +///| test "ExPASyEntry creation" { let entry = @src.ExPASyEntry::new("P04637", "TP53") assert_eq(entry.accession, "P04637") assert_eq(entry.name, "TP53") } +///| test "ExPASyEntry add keyword" { let entry = @src.ExPASyEntry::new("P04637", "TP53") let entry2 = entry.add_keyword("Tumor suppressor") - + assert_eq(entry2.keywords.length(), 1) assert_eq(entry2.keywords[0], "Tumor suppressor") } +///| test "EnzymeEntry creation" { let enzyme = @src.EnzymeEntry::new("1.1.1.1", "Alcohol dehydrogenase") assert_eq(enzyme.ec_number, "1.1.1.1") assert_eq(enzyme.name, "Alcohol dehydrogenase") } +///| test "enzyme_parse_ec" { let (class, subclass, subsubclass, serial) = @src.enzyme_parse_ec("1.1.1.1") assert_eq(class, "1") @@ -44,35 +48,41 @@ test "enzyme_parse_ec" { assert_eq(serial, "1") } +///| test "expasy_get_prosite_ids" { let ids = @src.expasy_get_prosite_ids("PCNG") assert_true(ids.length() > 0) } +///| test "expasy_get_swissprot_entry" { let entry = @src.expasy_get_swissprot_entry("P04637") assert_true(entry is Some(_)) } +///| test "expasy_get_enzyme" { let enzyme = @src.expasy_get_enzyme("1.1.1.1") assert_true(enzyme is Some(_)) } +///| test "expasy_analyze_protein" { let results = @src.expasy_analyze_protein("AVG") assert_true(results.contains("molecular_weight")) assert_true(results.contains("gravy")) } +///| test "create_example_expasy_entry" { let entry = @src.create_example_expasy_entry() assert_eq(entry.accession, "P04637") assert_eq(entry.name, "TP53") } +///| test "create_example_enzyme_entry" { let enzyme = @src.create_example_enzyme_entry() assert_eq(enzyme.ec_number, "1.1.1.1") assert_eq(enzyme.name, "Alcohol dehydrogenase") -} \ No newline at end of file +} diff --git a/test/moonbit/factoextra_test.mbt b/test/moonbit/factoextra_test.mbt index 58d23123..a810ea59 100644 --- a/test/moonbit/factoextra_test.mbt +++ b/test/moonbit/factoextra_test.mbt @@ -17,11 +17,7 @@ test "factoextra_pca_basic" { ///| test "factoextra_pca_eigenvalues" { - let data = [ - [2.0, 3.0], - [5.0, 6.0], - [8.0, 9.0], - ] + let data = [[2.0, 3.0], [5.0, 6.0], [8.0, 9.0]] let result = @src.facto_pca(data) let eigenvalues = @src.facto_get_eigenvalue(result) assert_eq(eigenvalues.length(), 2) @@ -30,28 +26,22 @@ test "factoextra_pca_eigenvalues" { ///| test "factoextra_pca_variance" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - [10.0, 11.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0], [10.0, 11.0]] let result = @src.facto_pca(data) let eigenvalues = @src.facto_get_eigenvalue(result) let mut i = 1 while i < eigenvalues.length() { - assert_true(eigenvalues[i].cumulative_variance >= eigenvalues[i - 1].cumulative_variance) + assert_true( + eigenvalues[i].cumulative_variance >= + eigenvalues[i - 1].cumulative_variance, + ) i = i + 1 } } ///| test "factoextra_pca_individual_coords" { - let data = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - [7.0, 8.0, 9.0], - ] + let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let result = @src.facto_pca(data) let ind = @src.facto_get_pca_ind(result) assert_eq(ind.coord.length(), 3) @@ -60,11 +50,7 @@ test "factoextra_pca_individual_coords" { ///| test "factoextra_pca_variable_coords" { - let data = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - [7.0, 8.0, 9.0], - ] + let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let result = @src.facto_pca(data) let pca_var = @src.facto_get_pca_var(result) assert_eq(pca_var.coord.length(), 3) @@ -78,18 +64,14 @@ test "factoextra_pca_ncp" { [5.0, 6.0, 7.0, 8.0], [9.0, 10.0, 11.0, 12.0], ] - let result = @src.facto_pca(data, ncp = 2) + let result = @src.facto_pca(data, ncp=2) assert_eq(result.n_dims, 2) assert_eq(result.eigenvalues.length(), 2) } ///| test "factoextra_pca_cos2_individuals" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0]] let result = @src.facto_pca(data) let ind = @src.facto_get_pca_ind(result) assert_eq(ind.cos2.length(), 3) @@ -107,11 +89,7 @@ test "factoextra_pca_cos2_individuals" { ///| test "factoextra_pca_contrib_variables" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0]] let result = @src.facto_pca(data) let pca_var = @src.facto_get_pca_var(result) assert_eq(pca_var.contrib.length(), 2) @@ -120,11 +98,7 @@ test "factoextra_pca_contrib_variables" { ///| test "factoextra_pca_total_inertia" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0]] let result = @src.facto_pca(data) let total = @src.facto_total_inertia(result) assert_true(total > 0.0) @@ -132,12 +106,7 @@ test "factoextra_pca_total_inertia" { ///| test "factoextra_pca_nb_dim" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - [10.0, 11.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0], [10.0, 11.0]] let result = @src.facto_pca(data) let nb = @src.facto_nb_dim(result, 80.0) assert_true(nb >= 1) @@ -146,10 +115,7 @@ test "factoextra_pca_nb_dim" { ///| test "factoextra_pca_summary" { - let data = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - ] + let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let result = @src.facto_pca(data) let summary = @src.facto_summary(result) assert_eq(summary.n_individuals, 2) @@ -168,11 +134,7 @@ test "factoextra_pca_empty" { ///| test "factoextra_pca_contrib_dim" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0]] let result = @src.facto_pca(data) let contribs = @src.facto_var_contrib_dim(result, 1) assert_eq(contribs.length(), 2) @@ -181,11 +143,7 @@ test "factoextra_pca_contrib_dim" { ///| test "factoextra_pca_cos2_dim" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0]] let result = @src.facto_pca(data) let cos2s = @src.facto_var_cos2_dim(result, 1) assert_eq(cos2s.length(), 2) @@ -193,11 +151,7 @@ test "factoextra_pca_cos2_dim" { ///| test "factoextra_pca_dimdesc" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0]] let result = @src.facto_pca(data) let desc = @src.facto_dimdesc(data, result, 1) assert_eq(desc.length(), 2) @@ -205,11 +159,7 @@ test "factoextra_pca_dimdesc" { ///| test "factoextra_pca_loadings" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - [7.0, 8.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0], [7.0, 8.0]] let result = @src.facto_pca(data) let loadings = @src.facto_loadings(result) assert_eq(loadings.length(), 2) @@ -217,10 +167,7 @@ test "factoextra_pca_loadings" { ///| test "factoextra_pca_print_summary" { - let data = [ - [1.0, 2.0], - [4.0, 5.0], - ] + let data = [[1.0, 2.0], [4.0, 5.0]] let result = @src.facto_pca(data) let summary = @src.facto_print_summary(result) assert_true(summary.length() > 0) diff --git a/test/moonbit/feature_counts_test.mbt b/test/moonbit/feature_counts_test.mbt index 3f57568d..18cd06cc 100644 --- a/test/moonbit/feature_counts_test.mbt +++ b/test/moonbit/feature_counts_test.mbt @@ -1,9 +1,11 @@ ///| /// Test file for featureCounts module. - test "feature_annotation_creation" { let fa = @src.FeatureAnnotation::new( - chr="chr1", start=1000, end_=2000, strand="+", + chr="chr1", + start=1000, + end_=2000, + strand="+", gene_id="GeneA", ) assert_eq(fa.chr, "chr1") @@ -14,9 +16,13 @@ test "feature_annotation_creation" { assert_eq(fa.length(), 1001) } +///| test "feature_annotation_overlap" { let fa = @src.FeatureAnnotation::new( - chr="chr1", start=1000, end_=2000, strand="+", + chr="chr1", + start=1000, + end_=2000, + strand="+", gene_id="GeneA", ) assert_true(fa.overlaps(chr="chr1", start=1500, end_=1600)) @@ -26,9 +32,13 @@ test "feature_annotation_overlap" { assert_false(fa.overlaps(chr="chr1", start=2100, end_=2200)) } +///| test "feature_annotation_overlap_length" { let fa = @src.FeatureAnnotation::new( - chr="chr1", start=1000, end_=2000, strand="+", + chr="chr1", + start=1000, + end_=2000, + strand="+", gene_id="GeneA", ) assert_eq(fa.overlap_length(chr="chr1", start=1500, end_=1600), 101) @@ -37,9 +47,13 @@ test "feature_annotation_overlap_length" { assert_eq(fa.overlap_length(chr="chr2", start=1500, end_=1600), 0) } +///| test "read_alignment_creation" { let r = @src.ReadAlignment::new( - read_id="read1", chr="chr1", start=1500, end_=1600, + read_id="read1", + chr="chr1", + start=1500, + end_=1600, ) assert_eq(r.read_id, "read1") assert_eq(r.chr, "chr1") @@ -49,9 +63,13 @@ test "read_alignment_creation" { assert_eq(r.n_alignments, 1) } +///| test "read_alignment_paired" { let r = @src.ReadAlignment::new_paired( - read_id="read1", chr="chr1", start=1500, end_=1600, + read_id="read1", + chr="chr1", + start=1500, + end_=1600, mate_start=1700, ) assert_eq(r.is_paired, true) @@ -59,6 +77,7 @@ test "read_alignment_paired" { assert_true(r.fragment_length > 0) } +///| test "feature_counts_config_default" { let cfg = @src.FeatureCountsConfig::new() assert_eq(cfg.min_overlap, 1) @@ -66,6 +85,7 @@ test "feature_counts_config_default" { assert_eq(cfg.ignore_strand, false) } +///| test "feature_counts_config_setters" { let cfg = @src.FeatureCountsConfig::new() .set_min_overlap(val=5) @@ -76,16 +96,23 @@ test "feature_counts_config_setters" { assert_eq(cfg.count_fragments, true) } +///| test "feature_counts_count_basic" { let (features, reads, samples) = @src.feature_counts_sample_data() let cfg = @src.FeatureCountsConfig::new().set_min_mapq(val=40) - let result = @src.feature_counts_count(features, reads, sample_names=samples, config=cfg) + let result = @src.feature_counts_count( + features, + reads, + sample_names=samples, + config=cfg, + ) assert_eq(result.n_features(), 4) assert_eq(result.n_samples(), 1) assert_eq(result.total_reads[0], 7) assert_eq(result.assigned_reads[0], 5) } +///| test "feature_counts_get_count" { let (features, reads, samples) = @src.feature_counts_sample_data() let result = @src.feature_counts_count(features, reads, sample_names=samples) @@ -93,35 +120,56 @@ test "feature_counts_get_count" { assert_true(count >= 2.0) } +///| test "feature_counts_unassigned" { let (features, reads, samples) = @src.feature_counts_sample_data() let cfg = @src.FeatureCountsConfig::new().set_min_mapq(val=40) - let result = @src.feature_counts_count(features, reads, sample_names=samples, config=cfg) + let result = @src.feature_counts_count( + features, + reads, + sample_names=samples, + config=cfg, + ) assert_eq(result.unassigned_low_quality[0], 1) assert_eq(result.unassigned_no_features[0], 1) } +///| test "feature_counts_with_strand" { let (features, reads, samples) = @src.feature_counts_sample_data() - let cfg = @src.FeatureCountsConfig::new() - .set_strand_mode(mode=@src.strand_stranded()) - let result = @src.feature_counts_count(features, reads, sample_names=samples, config=cfg) + let cfg = @src.FeatureCountsConfig::new().set_strand_mode( + mode=@src.strand_stranded(), + ) + let result = @src.feature_counts_count( + features, + reads, + sample_names=samples, + config=cfg, + ) let count_b1 = result.get_count(feature_id="exon_B1", sample_idx=0) // read3 is on chr1:6500-6600, strand -, feature is on strand -, should match assert_true(count_b1 >= 1.0) } +///| test "feature_counts_reversed_strand" { let (features, reads, samples) = @src.feature_counts_sample_data() - let cfg = @src.FeatureCountsConfig::new() - .set_strand_mode(mode=@src.strand_reversed()) - let result = @src.feature_counts_count(features, reads, sample_names=samples, config=cfg) + let cfg = @src.FeatureCountsConfig::new().set_strand_mode( + mode=@src.strand_reversed(), + ) + let result = @src.feature_counts_count( + features, + reads, + sample_names=samples, + config=cfg, + ) // With reversed strand, read on + should NOT match feature on + // read1 (+) on chr1:1500 should NOT match exon_A1 (+) with reversed let count = result.get_count(feature_id="exon_A1", sample_idx=0) assert_true(count <= 1.0) } +///| test "feature_counts_library_size" { let (features, reads, samples) = @src.feature_counts_sample_data() let result = @src.feature_counts_count(features, reads, sample_names=samples) @@ -129,6 +177,7 @@ test "feature_counts_library_size" { assert_true(lib_size > 0.0) } +///| test "feature_counts_cpm" { let (features, reads, samples) = @src.feature_counts_sample_data() let result = @src.feature_counts_count(features, reads, sample_names=samples) @@ -136,6 +185,7 @@ test "feature_counts_cpm" { assert_true(cpm_val >= 0.0) } +///| test "feature_counts_summary" { let (features, reads, samples) = @src.feature_counts_sample_data() let result = @src.feature_counts_count(features, reads, sample_names=samples) @@ -143,26 +193,43 @@ test "feature_counts_summary" { assert_true(summary.length() > 0) } +///| test "feature_counts_multi_sample" { let features : Array[@src.FeatureAnnotation] = Array::new() - features.push(@src.FeatureAnnotation::new( - chr="chr1", start=1000, end_=2000, strand="+", - gene_id="GeneA", feature_id="exon_A1", - )) + features.push( + @src.FeatureAnnotation::new( + chr="chr1", + start=1000, + end_=2000, + strand="+", + gene_id="GeneA", + feature_id="exon_A1", + ), + ) let reads : Array[@src.ReadAlignment] = Array::new() - reads.push(@src.ReadAlignment::new( - read_id="read_s1_1", chr="chr1", start=1500, end_=1600, - )) - reads.push(@src.ReadAlignment::new( - read_id="read_s2_1", chr="chr1", start=1500, end_=1600, - )) + reads.push( + @src.ReadAlignment::new( + read_id="read_s1_1", + chr="chr1", + start=1500, + end_=1600, + ), + ) + reads.push( + @src.ReadAlignment::new( + read_id="read_s2_1", + chr="chr1", + start=1500, + end_=1600, + ), + ) let sample_names : Array[String] = Array::new() sample_names.push("sample1") sample_names.push("sample2") - let result = @src.feature_counts_count(features, reads, sample_names=sample_names) + let result = @src.feature_counts_count(features, reads, sample_names~) assert_eq(result.n_samples(), 2) assert_eq(result.total_reads[0], 1) assert_eq(result.total_reads[1], 1) @@ -170,6 +237,7 @@ test "feature_counts_multi_sample" { assert_eq(result.get_count(feature_id="exon_A1", sample_idx=1), 1.0) } +///| test "strand_mode_creation" { let s1 = @src.strand_unstranded() let s2 = @src.strand_stranded() @@ -180,6 +248,7 @@ test "strand_mode_creation" { assert_true(s3 == s3) } +///| test "feature_counts_feature_total" { let (features, reads, samples) = @src.feature_counts_sample_data() let result = @src.feature_counts_count(features, reads, sample_names=samples) diff --git a/test/moonbit/file_test.mbt b/test/moonbit/file_test.mbt index dcbe1f11..bf7d3d08 100644 --- a/test/moonbit/file_test.mbt +++ b/test/moonbit/file_test.mbt @@ -51,7 +51,11 @@ test "smart_file_creation_write" { ///| test "smart_file_with_format" { - let sf = @src.SmartFile::with_format("data.gz", @src.compression_gzip(), mode="r") + let sf = @src.SmartFile::with_format( + "data.gz", + @src.compression_gzip(), + mode="r", + ) assert_eq(sf.get_format().to_string(), "gzip") } diff --git a/test/moonbit/fishpond_test.mbt b/test/moonbit/fishpond_test.mbt index 97acc4e6..9120bd34 100644 --- a/test/moonbit/fishpond_test.mbt +++ b/test/moonbit/fishpond_test.mbt @@ -16,10 +16,9 @@ test "fish_counts_creation" { assert_eq(c.condition()[8], "control") } +///| test "fish_result_creation" { - let r = @src.FishResult::new( - "TX1", 15.0, 1.5, 0.01, 0.05, "up", - ) + let r = @src.FishResult::new("TX1", 15.0, 1.5, 0.01, 0.05, "up") assert_eq(r.transcript(), "TX1") assert_eq(r.statistic(), 15.0) assert_eq(r.log2_fold_change(), 1.5) @@ -32,35 +31,30 @@ test "fish_result_creation" { // Mann-Whitney-Wilcoxon statistic // --------------------------------------------------------------------------- +///| test "fish_mw_statistic_clear_separation" { // Cases all higher than controls - let stat = @src.fish_mann_whitney_test( - [10.0, 20.0, 30.0], - [1.0, 2.0, 3.0], - ) + let stat = @src.fish_mann_whitney_test([10.0, 20.0, 30.0], [1.0, 2.0, 3.0]) // With complete separation, W = sum of ranks 4,5,6 = 15 assert_eq(stat, 15.0) } +///| test "fish_mw_statistic_identical_groups" { - let stat = @src.fish_mann_whitney_test( - [5.0, 5.0, 5.0], - [5.0, 5.0, 5.0], - ) + let stat = @src.fish_mann_whitney_test([5.0, 5.0, 5.0], [5.0, 5.0, 5.0]) // All tied: average rank = 3.5 for each, sum for case = 3*3.5 = 10.5 assert_eq(stat, 10.5) } +///| test "fish_mw_statistic_overlap" { - let stat = @src.fish_mann_whitney_test( - [1.0, 3.0, 5.0], - [2.0, 4.0, 6.0], - ) + let stat = @src.fish_mann_whitney_test([1.0, 3.0, 5.0], [2.0, 4.0, 6.0]) // Ranks: 1->1(case), 2->2(ctrl), 3->3(case), 4->4(ctrl), 5->5(case), 6->6(ctrl) // W_case = 1+3+5 = 9 assert_eq(stat, 9.0) } +///| test "fish_mw_statistic_empty_group" { let stat = @src.fish_mann_whitney_test([], [1.0, 2.0]) assert_eq(stat, 0.0) @@ -70,17 +64,20 @@ test "fish_mw_statistic_empty_group" { // Log2 fold change // --------------------------------------------------------------------------- +///| test "fish_log2fc_positive" { let lfc = @src.fish_log2fc_test([8.0, 8.0], [2.0, 2.0]) // log2(9) - log2(3) = log2(3) ≈ 1.585 assert_true(lfc > 0.0) } +///| test "fish_log2fc_negative" { let lfc = @src.fish_log2fc_test([2.0, 2.0], [8.0, 8.0]) assert_true(lfc < 0.0) } +///| test "fish_log2fc_zero_means" { let lfc = @src.fish_log2fc_test([0.0, 0.0], [0.0, 0.0]) assert_eq(lfc, 0.0) @@ -90,6 +87,7 @@ test "fish_log2fc_zero_means" { // Full Swish analysis // --------------------------------------------------------------------------- +///| test "fish_swish_detects_upregulated" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -102,6 +100,7 @@ test "fish_swish_detects_upregulated" { assert_eq(results[2].direction(), "up") } +///| test "fish_swish_detects_downregulated" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -114,6 +113,7 @@ test "fish_swish_detects_downregulated" { assert_eq(results[5].direction(), "down") } +///| test "fish_swish_nonsignificant_stable" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -123,6 +123,7 @@ test "fish_swish_nonsignificant_stable" { } } +///| test "fish_swish_pvalues_in_range" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -132,6 +133,7 @@ test "fish_swish_pvalues_in_range" { } } +///| test "fish_swish_fdr_in_range" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -141,23 +143,21 @@ test "fish_swish_fdr_in_range" { } } +///| test "fish_swish_empty_input" { let counts = @src.FishCounts::new([], [], [], []) let results = @src.fish_swish(counts, "case", 10) assert_eq(results.length(), 0) } +///| test "fish_swish_too_few_samples" { - let counts = @src.FishCounts::new( - ["TX1"], - ["s1"], - ["case"], - [[5.0]], - ) + let counts = @src.FishCounts::new(["TX1"], ["s1"], ["case"], [[5.0]]) let results = @src.fish_swish(counts, "case", 10) assert_eq(results.length(), 0) } +///| test "fish_swish_log2fc_sign_correct" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -175,6 +175,7 @@ test "fish_swish_log2fc_sign_correct" { // Significant filtering // --------------------------------------------------------------------------- +///| test "fish_significant_filter" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -183,6 +184,7 @@ test "fish_significant_filter" { assert_true(sig.length() >= 6) } +///| test "fish_significant_strict_threshold" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -195,15 +197,15 @@ test "fish_significant_strict_threshold" { // Output formatting // --------------------------------------------------------------------------- +///| test "fish_result_to_string" { - let r = @src.FishResult::new( - "TX1", 15.0, 1.5, 0.01, 0.05, "up", - ) + let r = @src.FishResult::new("TX1", 15.0, 1.5, 0.01, 0.05, "up") let s = r.to_string() assert_true(s.contains("TX1")) assert_true(s.contains("up")) } +///| test "fish_results_to_string" { let counts = @src.fish_sample_counts() let results = @src.fish_swish(counts, "case", 500) @@ -216,28 +218,95 @@ test "fish_results_to_string" { // Sample data verification // --------------------------------------------------------------------------- +///| test "fish_sample_data_up_pattern" { let c = @src.fish_sample_counts() // TX1 (transcript 0): case values (indices 0-7) should be higher than control (indices 8-15) - let case_mean = (c.counts()[0][0] + c.counts()[0][1] + c.counts()[0][2] + c.counts()[0][3] + c.counts()[0][4] + c.counts()[0][5] + c.counts()[0][6] + c.counts()[0][7]) / 8.0 - let ctrl_mean = (c.counts()[0][8] + c.counts()[0][9] + c.counts()[0][10] + c.counts()[0][11] + c.counts()[0][12] + c.counts()[0][13] + c.counts()[0][14] + c.counts()[0][15]) / 8.0 + let case_mean = ( + c.counts()[0][0] + + c.counts()[0][1] + + c.counts()[0][2] + + c.counts()[0][3] + + c.counts()[0][4] + + c.counts()[0][5] + + c.counts()[0][6] + + c.counts()[0][7] + ) / + 8.0 + let ctrl_mean = ( + c.counts()[0][8] + + c.counts()[0][9] + + c.counts()[0][10] + + c.counts()[0][11] + + c.counts()[0][12] + + c.counts()[0][13] + + c.counts()[0][14] + + c.counts()[0][15] + ) / + 8.0 assert_true(case_mean > ctrl_mean) } +///| test "fish_sample_data_down_pattern" { let c = @src.fish_sample_counts() // TX4 (transcript 3): case values should be lower than control - let case_mean = (c.counts()[3][0] + c.counts()[3][1] + c.counts()[3][2] + c.counts()[3][3] + c.counts()[3][4] + c.counts()[3][5] + c.counts()[3][6] + c.counts()[3][7]) / 8.0 - let ctrl_mean = (c.counts()[3][8] + c.counts()[3][9] + c.counts()[3][10] + c.counts()[3][11] + c.counts()[3][12] + c.counts()[3][13] + c.counts()[3][14] + c.counts()[3][15]) / 8.0 + let case_mean = ( + c.counts()[3][0] + + c.counts()[3][1] + + c.counts()[3][2] + + c.counts()[3][3] + + c.counts()[3][4] + + c.counts()[3][5] + + c.counts()[3][6] + + c.counts()[3][7] + ) / + 8.0 + let ctrl_mean = ( + c.counts()[3][8] + + c.counts()[3][9] + + c.counts()[3][10] + + c.counts()[3][11] + + c.counts()[3][12] + + c.counts()[3][13] + + c.counts()[3][14] + + c.counts()[3][15] + ) / + 8.0 assert_true(case_mean < ctrl_mean) } +///| test "fish_sample_data_ns_pattern" { let c = @src.fish_sample_counts() // TX7 (transcript 6): similar values in both groups - let case_mean = (c.counts()[6][0] + c.counts()[6][1] + c.counts()[6][2] + c.counts()[6][3] + c.counts()[6][4] + c.counts()[6][5] + c.counts()[6][6] + c.counts()[6][7]) / 8.0 - let ctrl_mean = (c.counts()[6][8] + c.counts()[6][9] + c.counts()[6][10] + c.counts()[6][11] + c.counts()[6][12] + c.counts()[6][13] + c.counts()[6][14] + c.counts()[6][15]) / 8.0 + let case_mean = ( + c.counts()[6][0] + + c.counts()[6][1] + + c.counts()[6][2] + + c.counts()[6][3] + + c.counts()[6][4] + + c.counts()[6][5] + + c.counts()[6][6] + + c.counts()[6][7] + ) / + 8.0 + let ctrl_mean = ( + c.counts()[6][8] + + c.counts()[6][9] + + c.counts()[6][10] + + c.counts()[6][11] + + c.counts()[6][12] + + c.counts()[6][13] + + c.counts()[6][14] + + c.counts()[6][15] + ) / + 8.0 // Difference should be small - let diff = if case_mean > ctrl_mean { case_mean - ctrl_mean } else { ctrl_mean - case_mean } + let diff = if case_mean > ctrl_mean { + case_mean - ctrl_mean + } else { + ctrl_mean - case_mean + } assert_true(diff < 10.0) } diff --git a/test/moonbit/fragment_mapper_test.mbt b/test/moonbit/fragment_mapper_test.mbt index 40863cac..83e05f59 100644 --- a/test/moonbit/fragment_mapper_test.mbt +++ b/test/moonbit/fragment_mapper_test.mbt @@ -145,12 +145,14 @@ test "fm_coverage_basic" { ///| test "fm_merge_fragments_adjacent_same_type" { - let frag1 = @src.Fragment::new("f1", 1, 5, - fragment_type=@src.ft_helix(), - residues=[@src.FragmentResidue::new("A", 1), @src.FragmentResidue::new("L", 2)]) - let frag2 = @src.Fragment::new("f2", 6, 10, - fragment_type=@src.ft_helix(), - residues=[@src.FragmentResidue::new("P", 6), @src.FragmentResidue::new("H", 7)]) + let frag1 = @src.Fragment::new("f1", 1, 5, fragment_type=@src.ft_helix(), residues=[ + @src.FragmentResidue::new("A", 1), + @src.FragmentResidue::new("L", 2), + ]) + let frag2 = @src.Fragment::new("f2", 6, 10, fragment_type=@src.ft_helix(), residues=[ + @src.FragmentResidue::new("P", 6), + @src.FragmentResidue::new("H", 7), + ]) let merged = @src.fm_merge_fragments([frag1, frag2]) assert_eq(merged.length(), 1) assert_eq(merged[0].start_residue, 1) @@ -367,4 +369,4 @@ test "fm_parse_fragments_sequence_mapping" { "END\n" let result = @src.fm_parse_fragments(content) assert_eq(result.protein_sequence, "AGF") -} \ No newline at end of file +} diff --git a/test/moonbit/freq_analysis_test.mbt b/test/moonbit/freq_analysis_test.mbt index cab60cdd..45824167 100644 --- a/test/moonbit/freq_analysis_test.mbt +++ b/test/moonbit/freq_analysis_test.mbt @@ -1,57 +1,72 @@ // Tests for Bio.FreqAnalysis module +///| test "fa_count_kmers single nucleotide" { let result = @src.fa_count_kmers("ACGT", 1) assert_true(result.fa_get_total_count() == 4) - assert_true(result.fa_get_frequency("A") > 0.24 && result.fa_get_frequency("A") < 0.26) + assert_true( + result.fa_get_frequency("A") > 0.24 && result.fa_get_frequency("A") < 0.26, + ) } +///| test "fa_count_kmers dinucleotide" { let result = @src.fa_count_kmers("ACGTAC", 2) assert_true(result.fa_get_total_count() == 5) } +///| test "fa_count_kmers empty" { let result = @src.fa_count_kmers("", 3) assert_true(result.fa_get_total_count() == 0) } +///| test "fa_nucleotide_frequency" { let result = @src.fa_nucleotide_frequency("AATTCCGG") assert_true(result.fa_get_total_count() == 8) - assert_true(result.fa_get_frequency("A") > 0.24 && result.fa_get_frequency("A") < 0.26) + assert_true( + result.fa_get_frequency("A") > 0.24 && result.fa_get_frequency("A") < 0.26, + ) } +///| test "fa_count_pattern" { let count = @src.fa_count_pattern("ATATAT", "AT") assert_true(count == 3) } +///| test "fa_count_pattern no match" { let count = @src.fa_count_pattern("ACGT", "TT") assert_true(count == 0) } +///| test "fa_codon_usage" { let result = @src.fa_codon_usage("ATGAAACCC") assert_true(result.fa_get_total_count() == 3) } +///| test "fa_gc_content" { let result = @src.fa_gc_content("AAGGCC") assert_true(result > 0.66 && result < 0.68) } +///| test "fa_gc_content all GC" { let result = @src.fa_gc_content("GCGC") assert_true(result == 1.0) } +///| test "fa_at_content" { let result = @src.fa_at_content("AATTCC") assert_true(result > 0.66 && result < 0.68) } +///| test "fa_find_motif" { let positions = @src.fa_find_motif("ATCGATCGATCG", "ATC") assert_true(positions.length() == 3) @@ -60,11 +75,13 @@ test "fa_find_motif" { assert_true(positions[2] == 8) } +///| test "fa_find_motif not found" { let positions = @src.fa_find_motif("ACGT", "TT") assert_true(positions.length() == 0) } +///| test "fa_get_patterns" { let result = @src.fa_count_kmers("AAACCC", 1) let patterns = result.fa_get_patterns() diff --git a/test/moonbit/freq_table_test.mbt b/test/moonbit/freq_table_test.mbt index cd24d654..fa8f8ec9 100644 --- a/test/moonbit/freq_table_test.mbt +++ b/test/moonbit/freq_table_test.mbt @@ -305,7 +305,10 @@ test "freq_table_from_sequence_basic" { ///| test "freq_table_from_sequence_with_alphabet_restricts" { - let ft = @src.freq_table_from_sequence("AATTGGCCNN", Some(["A", "T", "G", "C"])) + let ft = @src.freq_table_from_sequence( + "AATTGGCCNN", + Some(["A", "T", "G", "C"]), + ) assert_eq(ft.size(), 4) assert_eq(ft.count_of("A"), 2) // N is not in alphabet, so it should not be counted. diff --git a/test/moonbit/fssp_test.mbt b/test/moonbit/fssp_test.mbt index c79df6bb..b36eb564 100644 --- a/test/moonbit/fssp_test.mbt +++ b/test/moonbit/fssp_test.mbt @@ -7,8 +7,7 @@ test "fssp_header_creation" { let h = @src.FsspHeader::new( - "1dfa_A", "30-jul-1998", "crystal structure", - "17beta-hsd", "human", "holm", + "1dfa_A", "30-jul-1998", "crystal structure", "17beta-hsd", "human", "holm", 25, 3, 2.0, ) assert_eq(h.pdbid(), "1dfa_A") @@ -22,10 +21,10 @@ test "fssp_header_creation" { assert_eq(h.threshold(), "2") } +///| test "fssp_alignment_creation" { let a = @src.FsspAlignment::new( - "1csa_A", "1csa_A", 1, "MNIFVHEKDLFRTIVS", - 12.1, 2.0, 16, 68.8, + "1csa_A", "1csa_A", 1, "MNIFVHEKDLFRTIVS", 12.1, 2.0, 16, 68.8, ) assert_eq(a.pdbid(), "1csa_A") assert_eq(a.alignment_id(), "1csa_A") @@ -37,10 +36,10 @@ test "fssp_alignment_creation" { assert_eq(a.pid(), 68.8) } +///| test "fssp_data_creation" { let h = @src.FsspHeader::new( - "1dfa_A", "30-jul-1998", "", "", "", "", - 25, 2, 2.0, + "1dfa_A", "30-jul-1998", "", "", "", "", 25, 2, 2.0, ) let a1 = @src.FsspAlignment::new( "1dfa_A", "1dfa_A", 1, "ACGT", 15.0, 1.5, 4, 100.0, @@ -53,10 +52,9 @@ test "fssp_data_creation" { assert_true(data.reference().unwrap().pdbid() == "1dfa_A") } +///| test "fssp_filter_by_zscore" { - let h = @src.FsspHeader::new( - "1dfa_A", "", "", "", "", "", 10, 3, 2.0, - ) + let h = @src.FsspHeader::new("1dfa_A", "", "", "", "", "", 10, 3, 2.0) let a1 = @src.FsspAlignment::new("a1", "a1", 1, "AAA", 15.0, 1.0, 3, 100.0) let a2 = @src.FsspAlignment::new("a2", "a2", 1, "AAA", 10.0, 2.0, 3, 80.0) let a3 = @src.FsspAlignment::new("a3", "a3", 1, "AAA", 5.0, 3.0, 3, 60.0) @@ -67,10 +65,9 @@ test "fssp_filter_by_zscore" { assert_eq(filtered[1].pdbid(), "a2") } +///| test "fssp_empty_alignments" { - let h = @src.FsspHeader::new( - "1dfa_A", "", "", "", "", "", 0, 0, 0.0, - ) + let h = @src.FsspHeader::new("1dfa_A", "", "", "", "", "", 0, 0, 0.0) let data = @src.FsspData::new(h, []) assert_eq(data.n_alignments(), 0) assert_true(data.reference() is None) @@ -80,12 +77,14 @@ test "fssp_empty_alignments" { // Sample data // --------------------------------------------------------------------------- +///| test "fssp_sample_text_has_header" { let text = @src.fssp_sample_text() assert_true(text.contains("HEADER")) assert_true(text.contains("1dfa_A")) } +///| test "fssp_sample_text_has_alignments" { let text = @src.fssp_sample_text() assert_true(text.contains("## ALIGNMENTS")) @@ -93,6 +92,7 @@ test "fssp_sample_text_has_alignments" { assert_true(text.contains("1hsd_A")) } +///| test "fssp_sample_text_has_threshold" { let text = @src.fssp_sample_text() assert_true(text.contains("THRESHOLD")) @@ -103,6 +103,7 @@ test "fssp_sample_text_has_threshold" { // Parsing // --------------------------------------------------------------------------- +///| test "fssp_parse_header" { let text = @src.fssp_sample_text() let data = @src.fssp_parse(text) @@ -113,6 +114,7 @@ test "fssp_parse_header" { assert_eq(h.threshold(), "2") } +///| test "fssp_parse_header_title" { let text = @src.fssp_sample_text() let data = @src.fssp_parse(text) @@ -123,12 +125,14 @@ test "fssp_parse_header_title" { assert_eq(h.author(), "holm") } +///| test "fssp_parse_alignments_count" { let text = @src.fssp_sample_text() let data = @src.fssp_parse(text) assert_eq(data.n_alignments(), 3) } +///| test "fssp_parse_alignment_details" { let text = @src.fssp_sample_text() let data = @src.fssp_parse(text) @@ -144,6 +148,7 @@ test "fssp_parse_alignment_details" { assert_eq(ref_aln.pid(), 75.0) } +///| test "fssp_parse_second_alignment" { let text = @src.fssp_sample_text() let data = @src.fssp_parse(text) @@ -153,6 +158,7 @@ test "fssp_parse_second_alignment" { assert_eq(a2.pid(), 68.8) } +///| test "fssp_parse_reference" { let text = @src.fssp_sample_text() let data = @src.fssp_parse(text) @@ -160,11 +166,13 @@ test "fssp_parse_reference" { assert_eq(ref.pdbid(), "1dfa_A") } +///| test "fssp_parse_empty_input" { let data = @src.fssp_parse("") assert_eq(data.n_alignments(), 0) } +///| test "fssp_parse_header_only" { let text = "HEADER \\_1abc_A 1 01-jan-2000\nSEQLENGTH 10\n" let data = @src.fssp_parse(text) @@ -174,6 +182,7 @@ test "fssp_parse_header_only" { assert_eq(data.n_alignments(), 0) } +///| test "fssp_parse_filter_after_parse" { let text = @src.fssp_sample_text() let data = @src.fssp_parse(text) @@ -187,6 +196,7 @@ test "fssp_parse_filter_after_parse" { // Formatting // --------------------------------------------------------------------------- +///| test "fssp_header_to_string" { let h = @src.FsspHeader::new( "1dfa_A", "30-jul-1998", "", "", "", "", 25, 3, 2.0, @@ -196,6 +206,7 @@ test "fssp_header_to_string" { assert_true(s.contains("25")) } +///| test "fssp_alignment_to_string" { let a = @src.FsspAlignment::new( "1csa_A", "1csa_A", 1, "ACGT", 12.1, 2.0, 4, 75.0, @@ -206,6 +217,7 @@ test "fssp_alignment_to_string" { assert_true(s.contains("12.1")) } +///| test "fssp_data_to_string" { let text = @src.fssp_sample_text() let data = @src.fssp_parse(text) diff --git a/test/moonbit/ga_test.mbt b/test/moonbit/ga_test.mbt index d1af22e9..32b86b63 100644 --- a/test/moonbit/ga_test.mbt +++ b/test/moonbit/ga_test.mbt @@ -17,9 +17,7 @@ test "ga_individual_creation" { ///| test "ga_individual_default" { - let ind = @src.GAIndividual::new( - sequence="ACGT", - ) + let ind = @src.GAIndividual::new(sequence="ACGT") assert_eq(ind.sequence, "ACGT") assert_true((ind.fitness - 0.0).abs() < 1.0e-10) assert_eq(ind.generation, 0) @@ -32,7 +30,7 @@ test "ga_population_creation" { @src.GAIndividual::new(sequence="CCCC", fitness=0.5, generation=0, id=1), @src.GAIndividual::new(sequence="GGGG", fitness=0.9, generation=0, id=2), ] - let pop = @src.GAPopulation::new(individuals=individuals) + let pop = @src.GAPopulation::new(individuals~) assert_eq(pop.individuals.length(), 3) assert_true((pop.best_fitness - 0.9).abs() < 1.0e-10) assert_true((pop.avg_fitness - 0.7333333333).abs() < 1.0e-10) @@ -110,7 +108,11 @@ test "ga_fitness_gc_content_zero" { test "ga_single_point_crossover" { let parent1 = @src.GAIndividual::new(sequence="AAAA") let parent2 = @src.GAIndividual::new(sequence="CCCC") - let (child1, child2) = @src.ga_single_point_crossover(parent1, parent2, point=2) + let (child1, child2) = @src.ga_single_point_crossover( + parent1, + parent2, + point=2, + ) assert_eq(child1.sequence.length(), 4) assert_eq(child2.sequence.length(), 4) } @@ -179,14 +181,24 @@ test "ga_evolution_loop_improves_fitness" { let fitness_fn = @src.ga_fitness_match(target) let result = @src.ga_evolve(config, fitness_fn) let initial_best = result.best_fitness_history[0] - let final_best = result.best_fitness_history[result.best_fitness_history.length() - 1] + let final_best = result.best_fitness_history[result.best_fitness_history.length() - + 1] assert_true(final_best >= initial_best) } ///| test "ga_result_creation" { - let best = @src.GAIndividual::new(sequence="ACGT", fitness=1.0, generation=10, id=5) - let stats = @src.GAGenerationStats::new(generation=10, best_fitness=1.0, avg_fitness=0.8) + let best = @src.GAIndividual::new( + sequence="ACGT", + fitness=1.0, + generation=10, + id=5, + ) + let stats = @src.GAGenerationStats::new( + generation=10, + best_fitness=1.0, + avg_fitness=0.8, + ) assert_eq(stats.generation, 10) assert_true((stats.best_fitness - 1.0).abs() < 1.0e-10) } @@ -260,4 +272,4 @@ test "ga_termination_threshold" { let fitness_fn = @src.ga_fitness_match(target) let result = @src.ga_evolve(config, fitness_fn) assert_true(result.generation_reached <= 200) -} \ No newline at end of file +} diff --git a/test/moonbit/gck_io_test.mbt b/test/moonbit/gck_io_test.mbt index e0d969b4..6bbf7007 100644 --- a/test/moonbit/gck_io_test.mbt +++ b/test/moonbit/gck_io_test.mbt @@ -33,8 +33,12 @@ test "gck_seq_type_from_int_round_trip" { let dna = @src.GckSeqType::from_int(0) let rna = @src.GckSeqType::from_int(1) let protein = @src.GckSeqType::from_int(2) - assert_true(@src.GckSeqType::from_int(dna.to_int()) is @src.GckSeqType::GckDna) - assert_true(@src.GckSeqType::from_int(rna.to_int()) is @src.GckSeqType::GckRna) + assert_true( + @src.GckSeqType::from_int(dna.to_int()) is @src.GckSeqType::GckDna, + ) + assert_true( + @src.GckSeqType::from_int(rna.to_int()) is @src.GckSeqType::GckRna, + ) assert_true( @src.GckSeqType::from_int(protein.to_int()) is @src.GckSeqType::GckProtein, ) @@ -74,12 +78,9 @@ test "gck_file_new_defaults" { ///| test "gck_feature_new" { - let f = @src.GckFeature::new( - name="AmpR", - type_="CDS", - direction=1, - segments=[(0, 19)], - ) + let f = @src.GckFeature::new(name="AmpR", type_="CDS", direction=1, segments=[ + (0, 19), + ]) assert_eq(f.name, "AmpR") assert_eq(f.type_, "CDS") assert_eq(f.direction, 1) @@ -91,12 +92,11 @@ test "gck_feature_new" { ///| test "gck_feature_new_multiple_segments" { - let f = @src.GckFeature::new( - name="gene1", - type_="CDS", - direction=2, - segments=[(0, 10), (20, 30), (40, 50)], - ) + let f = @src.GckFeature::new(name="gene1", type_="CDS", direction=2, segments=[ + (0, 10), + (20, 30), + (40, 50), + ]) assert_eq(f.name, "gene1") assert_eq(f.direction, 2) assert_eq(f.segments.length(), 3) @@ -140,12 +140,9 @@ test "gck_count_features_by_type_multiple" { @src.GckFeature::new(name="b", type_="CDS", direction=1, segments=[(20, 30)]), ) file.add_feature( - @src.GckFeature::new( - name="c", - type_="promoter", - direction=1, - segments=[(40, 50)], - ), + @src.GckFeature::new(name="c", type_="promoter", direction=1, segments=[ + (40, 50), + ]), ) assert_eq(@src.gck_count_features_by_type(file, "CDS"), 2) assert_eq(@src.gck_count_features_by_type(file, "promoter"), 1) @@ -320,7 +317,9 @@ test "gck_custom_file_round_trip" { file.set_sequence("ATGAAATAG") file.set_circular(false) file.add_feature( - @src.GckFeature::new(name="gene1", type_="CDS", direction=1, segments=[(0, 8)]), + @src.GckFeature::new(name="gene1", type_="CDS", direction=1, segments=[ + (0, 8), + ]), ) let hex = @src.gck_write(file) let parsed = @src.gck_parse(hex) @@ -339,20 +338,14 @@ test "gck_multiple_features_round_trip" { @src.GckFeature::new(name="f1", type_="CDS", direction=1, segments=[(0, 3)]), ) file.add_feature( - @src.GckFeature::new( - name="f2", - type_="promoter", - direction=2, - segments=[(4, 7)], - ), + @src.GckFeature::new(name="f2", type_="promoter", direction=2, segments=[ + (4, 7), + ]), ) file.add_feature( - @src.GckFeature::new( - name="f3", - type_="terminator", - direction=0, - segments=[(8, 11)], - ), + @src.GckFeature::new(name="f3", type_="terminator", direction=0, segments=[ + (8, 11), + ]), ) let hex = @src.gck_write(file) let parsed = @src.gck_parse(hex) @@ -370,12 +363,11 @@ test "gck_multi_segment_feature_round_trip" { let file = @src.GckFile::new() file.set_sequence("ATGCATGCATGC") file.add_feature( - @src.GckFeature::new( - name="gene", - type_="CDS", - direction=1, - segments=[(0, 2), (4, 6), (8, 10)], - ), + @src.GckFeature::new(name="gene", type_="CDS", direction=1, segments=[ + (0, 2), + (4, 6), + (8, 10), + ]), ) let hex = @src.gck_write(file) let parsed = @src.gck_parse(hex) @@ -398,24 +390,15 @@ test "gck_multi_segment_feature_round_trip" { ///| test "gck_feature_direction_values" { - let f1 = @src.GckFeature::new( - name="f1", - type_="CDS", - direction=0, - segments=[(0, 10)], - ) - let f2 = @src.GckFeature::new( - name="f2", - type_="CDS", - direction=1, - segments=[(0, 10)], - ) - let f3 = @src.GckFeature::new( - name="f3", - type_="CDS", - direction=2, - segments=[(0, 10)], - ) + let f1 = @src.GckFeature::new(name="f1", type_="CDS", direction=0, segments=[ + (0, 10), + ]) + let f2 = @src.GckFeature::new(name="f2", type_="CDS", direction=1, segments=[ + (0, 10), + ]) + let f3 = @src.GckFeature::new(name="f3", type_="CDS", direction=2, segments=[ + (0, 10), + ]) assert_eq(f1.direction, 0) assert_eq(f2.direction, 1) assert_eq(f3.direction, 2) diff --git a/test/moonbit/gcrma_test.mbt b/test/moonbit/gcrma_test.mbt index c4bebdac..6e70abd4 100644 --- a/test/moonbit/gcrma_test.mbt +++ b/test/moonbit/gcrma_test.mbt @@ -18,9 +18,7 @@ test "gcrma_probe_info_new" { ///| test "gcrma_probe_info_with_values" { - let probe = @src.ProbeInfo::with_values( - "probe_test", 8, "ACGTACGT", 2.5, - ) + let probe = @src.ProbeInfo::with_values("probe_test", 8, "ACGTACGT", 2.5) assert_eq(probe.probe_id, "probe_test") assert_eq(probe.gc_count, 8) assert_eq(probe.affinity, 2.5) @@ -113,9 +111,7 @@ test "gcrma_compute_gc_lookup_table_basic" { test "gcrma_background_correction_express" { let pm = [100.0, 200.0, 150.0, 300.0] let mm = [50.0, 80.0, 70.0, 120.0] - let result = @src.gcrma_background_correction( - pm, mm, 0.5, "Express", - ) + let result = @src.gcrma_background_correction(pm, mm, 0.5, "Express") assert_eq(result.length(), 4) assert_eq(result[0], 50.0) assert_eq(result[1], 120.0) @@ -125,9 +121,7 @@ test "gcrma_background_correction_express" { test "gcrma_background_correction_express_negative" { let pm = [30.0, 50.0] let mm = [80.0, 100.0] - let result = @src.gcrma_background_correction( - pm, mm, 0.5, "Express", - ) + let result = @src.gcrma_background_correction(pm, mm, 0.5, "Express") assert_eq(result.length(), 2) assert_eq(result[0], 1.0) } @@ -136,18 +130,14 @@ test "gcrma_background_correction_express_negative" { test "gcrma_background_correction_idealm" { let pm = [100.0, 200.0, 150.0, 300.0] let mm = [50.0, 80.0, 70.0, 120.0] - let result = @src.gcrma_background_correction( - pm, mm, 0.5, "IdealMM", - ) + let result = @src.gcrma_background_correction(pm, mm, 0.5, "IdealMM") assert_eq(result.length(), 4) assert_eq(result[0] > 1.0, true) } ///| test "gcrma_background_correction_empty" { - let result = @src.gcrma_background_correction( - [], [], 0.5, "IdealMM", - ) + let result = @src.gcrma_background_correction([], [], 0.5, "IdealMM") assert_eq(result.length(), 0) } @@ -180,11 +170,7 @@ test "gcrma_normalize_single_row" { ///| test "gcrma_normalize_multiple_rows" { - let data = [ - [100.0, 200.0], - [150.0, 250.0], - [120.0, 180.0], - ] + let data = [[100.0, 200.0], [150.0, 250.0], [120.0, 180.0]] let result = @src.gcrma_normalize(data) assert_eq(result.length(), 3) assert_eq(result[0].length(), 2) @@ -269,10 +255,7 @@ test "gcrma_process_empty" { ///| test "gcrma_process_with_config" { - let cel_data = [ - [100.0, 200.0], - [150.0, 250.0], - ] + let cel_data = [[100.0, 200.0], [150.0, 250.0]] let probe_info = [ @src.ProbeInfo::new("p1", "ACGTACGTACGT"), @src.ProbeInfo::new("p2", "GCGCGCGCGCGC"), @@ -285,10 +268,7 @@ test "gcrma_process_with_config" { ///| test "gcrma_process_no_normalize" { - let cel_data = [ - [100.0, 200.0], - [150.0, 250.0], - ] + let cel_data = [[100.0, 200.0], [150.0, 250.0]] let probe_info = [ @src.ProbeInfo::new("p1", "ACGTACGTACGT"), @src.ProbeInfo::new("p2", "GCGCGCGCGCGC"), @@ -302,9 +282,7 @@ test "gcrma_process_no_normalize" { test "gcrma_background_correction_mm_longer_than_pm" { let pm = [100.0, 200.0] let mm = [50.0, 80.0, 90.0] - let result = @src.gcrma_background_correction( - pm, mm, 0.5, "Express", - ) + let result = @src.gcrma_background_correction(pm, mm, 0.5, "Express") assert_eq(result.length(), 2) assert_eq(result[0], 50.0) assert_eq(result[1], 120.0) @@ -314,9 +292,7 @@ test "gcrma_background_correction_mm_longer_than_pm" { test "gcrma_background_correction_mm_shorter_than_pm" { let pm = [100.0, 200.0, 150.0] let mm = [50.0, 80.0] - let result = @src.gcrma_background_correction( - pm, mm, 0.5, "Express", - ) + let result = @src.gcrma_background_correction(pm, mm, 0.5, "Express") assert_eq(result.length(), 3) assert_eq(result[0], 50.0) assert_eq(result[2], 150.0) @@ -326,9 +302,7 @@ test "gcrma_background_correction_mm_shorter_than_pm" { test "gcrma_background_correction_idealm_clamps_to_minimum" { let pm = [10.0, 20.0] let mm = [8.0, 15.0] - let result = @src.gcrma_background_correction( - pm, mm, 0.9, "IdealMM", - ) + let result = @src.gcrma_background_correction(pm, mm, 0.9, "IdealMM") assert_eq(result.length(), 2) assert_eq(result[0] >= 1.0, true) assert_eq(result[1] >= 1.0, true) @@ -386,7 +360,10 @@ test "gcrma_full_pipeline_express" { @src.ProbeInfo::new("p5", "TGTGTGTGTGTG"), @src.ProbeInfo::new("p6", "CGCGCGCGCGCG"), ] - let config = @src.GCRMAConfig::new(background_method="Express", normalize=true) + let config = @src.GCRMAConfig::new( + background_method="Express", + normalize=true, + ) let result = @src.gcrma_process_with_config(cel_data, probe_info, config) assert_eq(result.expression_matrix.length(), 6) assert_eq(result.expression_matrix[0].length(), 2) @@ -412,12 +389,8 @@ test "gcrma_estimate_affinity_dinucleotide" { test "gcrma_background_correction_high_gc" { let pm = [100.0, 200.0, 150.0] let mm = [60.0, 100.0, 80.0] - let result_low = @src.gcrma_background_correction( - pm, mm, 0.2, "IdealMM", - ) - let result_high = @src.gcrma_background_correction( - pm, mm, 0.8, "IdealMM", - ) + let result_low = @src.gcrma_background_correction(pm, mm, 0.2, "IdealMM") + let result_high = @src.gcrma_background_correction(pm, mm, 0.8, "IdealMM") assert_eq(result_low.length(), 3) assert_eq(result_high.length(), 3) } @@ -435,4 +408,4 @@ test "gcrma_gc_correction_preserves_length" { ] let result = @src.gcrma_gc_correction(pm_values, gc_counts, probes) assert_eq(result.length(), 5) -} \ No newline at end of file +} diff --git a/test/moonbit/genefilter_test.mbt b/test/moonbit/genefilter_test.mbt index a0cfc966..9720c5ab 100644 --- a/test/moonbit/genefilter_test.mbt +++ b/test/moonbit/genefilter_test.mbt @@ -6,11 +6,13 @@ test "genefilter_row_ttest" { [5.0, 6.0, 5.5, 7.0, 6.5, 7.5], [100.0, 98.0, 102.0, 50.0, 48.0, 52.0], ] - let groups = ["control", "control", "control", "treatment", "treatment", "treatment"] - + let groups = [ + "control", "control", "control", "treatment", "treatment", "treatment", + ] + let ge = @src.GeneExpression::new(gene_ids, expression, groups) let result = @src.row_ttest(ge, "control", "treatment") - + assert_eq(result.passing_genes.length(), 3) } @@ -22,56 +24,45 @@ test "genefilter_row_wilcoxon" { [10.0, 11.0, 12.0, 1.0, 2.0, 3.0], ] let groups = ["groupA", "groupA", "groupA", "groupB", "groupB", "groupB"] - + let ge = @src.GeneExpression::new(gene_ids, expression, groups) let result = @src.row_wilcoxon(ge, "groupA", "groupB") - + assert_eq(result.passing_genes.length(), 2) } ///| test "genefilter_variance_filter" { let gene_ids = ["gene1", "gene2", "gene3"] - let expression = [ - [1.0, 1.0, 1.0], - [1.0, 2.0, 3.0], - [10.0, 20.0, 30.0], - ] + let expression = [[1.0, 1.0, 1.0], [1.0, 2.0, 3.0], [10.0, 20.0, 30.0]] let groups = ["g1", "g1", "g1"] - + let ge = @src.GeneExpression::new(gene_ids, expression, groups) let passing = @src.variance_filter(ge, 1.0) - + assert_eq(passing.length() >= 2, true) } ///| test "genefilter_cv_filter" { let gene_ids = ["gene1", "gene2"] - let expression = [ - [1.0, 1.0, 1.0], - [1.0, 2.0, 4.0], - ] + let expression = [[1.0, 1.0, 1.0], [1.0, 2.0, 4.0]] let groups = ["g1", "g1", "g1"] - + let ge = @src.GeneExpression::new(gene_ids, expression, groups) let passing = @src.cv_filter(ge, 0.5) - + assert_eq(passing.length() >= 1, true) } ///| test "genefilter_row_quantile_filter" { let gene_ids = ["gene1", "gene2", "gene3"] - let expression = [ - [5.0, 6.0, 7.0], - [1.0, 2.0, 3.0], - [9.0, 10.0, 11.0], - ] + let expression = [[5.0, 6.0, 7.0], [1.0, 2.0, 3.0], [9.0, 10.0, 11.0]] let groups = ["g1", "g1", "g1"] - + let ge = @src.GeneExpression::new(gene_ids, expression, groups) let passing = @src.row_quantile_filter(ge, 0.25, 0.75) - + assert_eq(passing.length() >= 1, true) -} \ No newline at end of file +} diff --git a/test/moonbit/genesis_test.mbt b/test/moonbit/genesis_test.mbt index c69d265d..d135caa5 100644 --- a/test/moonbit/genesis_test.mbt +++ b/test/moonbit/genesis_test.mbt @@ -9,9 +9,9 @@ test "genesis_estimate_kinship" { [1.0, 2.0, 0.0], [2.0, 0.0, 1.0], ] - + let result = @src.bio_estimate_kinship(genotypes) - + assert_true(result.n_samples == 4) assert_true(result.kinship_matrix.length() == 4) assert_true(result.sample_ids.length() == 4) @@ -25,9 +25,9 @@ test "genesis_pca" { [1.0, 2.0, 0.0], [2.0, 0.0, 1.0], ] - + let result = @src.bio_pca(genotypes, 2) - + assert_true(result.eigenvalues.length() == 2) assert_true(result.eigenvectors.length() > 0) assert_true(result.var_explained.length() == 2) @@ -35,14 +35,10 @@ test "genesis_pca" { ///| test "genesis_genetic_distance" { - let genotypes = [ - [0.0, 1.0, 2.0], - [0.0, 1.0, 2.0], - [1.0, 2.0, 0.0], - ] - + let genotypes = [[0.0, 1.0, 2.0], [0.0, 1.0, 2.0], [1.0, 2.0, 0.0]] + let distance = @src.bio_genetic_distance(genotypes) - + assert_true(distance.distance_matrix.length() == 3) assert_true(distance.sample_ids.length() == 3) } @@ -51,9 +47,9 @@ test "genesis_genetic_distance" { test "genesis_euclidean_distance" { let v1 = [0.0, 1.0, 2.0] let v2 = [0.0, 1.0, 2.0] - + let dist = @src.gs_euclidean_distance(v1, v2) - + assert_true(dist == 0.0) } @@ -61,9 +57,9 @@ test "genesis_euclidean_distance" { test "genesis_manhattan_distance" { let v1 = [0.0, 1.0, 2.0] let v2 = [0.0, 1.0, 2.0] - + let dist = @src.gs_manhattan_distance(v1, v2) - + assert_true(dist == 0.0) } @@ -71,8 +67,8 @@ test "genesis_manhattan_distance" { test "genesis_ibs_distance" { let v1 = [0.0, 1.0, 2.0] let v2 = [0.0, 1.0, 2.0] - + let dist = @src.gs_ibs_distance(v1, v2) - + assert_true(dist >= 0.0) } diff --git a/test/moonbit/genie3_test.mbt b/test/moonbit/genie3_test.mbt index bf49e02a..c04cda48 100644 --- a/test/moonbit/genie3_test.mbt +++ b/test/moonbit/genie3_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Bioconductor GENIE3 module - Gene regulatory network inference. - test "genie3_tree_leaf_basic" { let leaf = @src.genie3_tree_leaf(3.5) assert_true(leaf.is_leaf) @@ -10,6 +9,7 @@ test "genie3_tree_leaf_basic" { assert_eq(leaf.right_idx, -1) } +///| test "genie3_tree_split_basic" { let left = @src.genie3_tree_leaf(1.0) let right = @src.genie3_tree_leaf(2.0) @@ -23,6 +23,7 @@ test "genie3_tree_split_basic" { assert_true((node.importance_gain - 10.0).abs() < 1.0e-9) } +///| test "genie3_build_tree_simple" { // Simple dataset: y = 2 * x + noise let features = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]] @@ -36,6 +37,7 @@ test "genie3_build_tree_simple" { assert_true(p1 < p2) } +///| test "genie3_build_tree_constant_target" { // Constant target should produce a single leaf let features = [[1.0], [2.0], [3.0]] @@ -45,6 +47,7 @@ test "genie3_build_tree_constant_target" { assert_true(tree.nodes[0].is_leaf) } +///| test "genie3_feature_importance" { // x0 strongly predicts y, x1 doesn't let features = [ @@ -62,6 +65,7 @@ test "genie3_feature_importance" { assert_true(importance[0] > 0.0) } +///| test "genie3_run_basic" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -75,6 +79,7 @@ test "genie3_run_basic" { assert_true(result.edges.length() > 0) } +///| test "genie3_run_symmetrize" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5, symmetrize=true) @@ -91,6 +96,7 @@ test "genie3_run_symmetrize" { } } +///| test "genie3_column_normalization" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -109,6 +115,7 @@ test "genie3_column_normalization" { } } +///| test "genie3_edges_sorted_descending" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -119,6 +126,7 @@ test "genie3_edges_sorted_descending" { } } +///| test "genie3_top_edges" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -133,6 +141,7 @@ test "genie3_top_edges" { } } +///| test "genie3_top_edges_more_than_available" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -140,6 +149,7 @@ test "genie3_top_edges_more_than_available" { assert_eq(top100.length(), result.edges.length()) } +///| test "genie3_regulators_of" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -158,6 +168,7 @@ test "genie3_regulators_of" { assert_true(found_g1) } +///| test "genie3_targets_of" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -171,6 +182,7 @@ test "genie3_targets_of" { } } +///| test "genie3_regulators_of_unknown_gene" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -178,6 +190,7 @@ test "genie3_regulators_of_unknown_gene" { assert_eq(regs.length(), 0) } +///| test "genie3_sample_data_shape" { let (expr, names) = @src.genie3_sample_data() assert_eq(names.length(), 5) @@ -188,6 +201,7 @@ test "genie3_sample_data_shape" { assert_true((expr[0][0] - expr2[0][0]).abs() < 1.0e-9) } +///| test "genie3_run_no_edges_when_uniform" { // All identical samples → no informative splits → no edges let expr = [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0]] @@ -196,6 +210,7 @@ test "genie3_run_no_edges_when_uniform" { assert_eq(result.edges.length(), 0) } +///| test "genie3_self_loops_excluded" { let (expr, names) = @src.genie3_sample_data() let result = @src.genie3_run(expr, names, max_depth=5) @@ -207,6 +222,7 @@ test "genie3_self_loops_excluded" { } } +///| test "genie3_predict_after_build" { // Build a tree and verify prediction lies within target range let features = [ diff --git a/test/moonbit/genome_diagram_test.mbt b/test/moonbit/genome_diagram_test.mbt index 3af6e3e3..d0ebbd24 100644 --- a/test/moonbit/genome_diagram_test.mbt +++ b/test/moonbit/genome_diagram_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for GenomeDiagram module. - test "gd_create_diagram - basic creation" { let d = @src.gd_create_diagram("test", 0, 1000) assert_eq(d.name(), "test") @@ -9,6 +8,7 @@ test "gd_create_diagram - basic creation" { assert_eq(@src.gd_diagram_length(d), 1000) } +///| test "gd_create_diagram - negative coordinates" { let d = @src.gd_create_diagram("neg", -100, 200) assert_eq(d.start(), -100) @@ -16,6 +16,7 @@ test "gd_create_diagram - negative coordinates" { assert_eq(@src.gd_diagram_length(d), 300) } +///| test "gd_add_track - single track" { let d = @src.gd_create_diagram("test", 0, 500) let d2 = @src.gd_add_track(d, "genes") @@ -24,6 +25,7 @@ test "gd_add_track - single track" { assert_eq(tracks[0].name(), "genes") } +///| test "gd_add_track - multiple tracks" { let d = @src.gd_create_diagram("test", 0, 1000) let d2 = @src.gd_add_track(d, "genes") @@ -32,9 +34,17 @@ test "gd_add_track - multiple tracks" { assert_eq(@src.gd_track_count(d4), 3) } +///| test "gd_add_feature - basic feature" { let d = @src.gd_create_diagram("test", 0, 1000) - let d2 = @src.gd_add_feature(d, 100, 300, "+", "GeneA", @src.gd_rectangle_shape()) + let d2 = @src.gd_add_feature( + d, + 100, + 300, + "+", + "GeneA", + @src.gd_rectangle_shape(), + ) assert_eq(@src.gd_feature_count(d2), 1) let feats = d2.features() assert_eq(feats[0].start(), 100) @@ -43,14 +53,30 @@ test "gd_add_feature - basic feature" { assert_eq(feats[0].label(), "GeneA") } +///| test "gd_add_feature - multiple features" { let d = @src.gd_create_diagram("test", 0, 1000) let d2 = @src.gd_add_feature(d, 50, 150, "+", "Gene1", @src.gd_arrow_shape()) - let d3 = @src.gd_add_feature(d2, 200, 400, "-", "Gene2", @src.gd_diamond_shape()) - let d4 = @src.gd_add_feature(d3, 500, 800, "+", "Gene3", @src.gd_rectangle_shape()) + let d3 = @src.gd_add_feature( + d2, + 200, + 400, + "-", + "Gene2", + @src.gd_diamond_shape(), + ) + let d4 = @src.gd_add_feature( + d3, + 500, + 800, + "+", + "Gene3", + @src.gd_rectangle_shape(), + ) assert_eq(@src.gd_feature_count(d4), 3) } +///| test "gd_add_track_feature - basic track feature" { let d = @src.gd_create_diagram("test", 0, 1000) let d2 = @src.gd_add_track(d, "genes") @@ -62,6 +88,7 @@ test "gd_add_track_feature - basic track feature" { assert_eq(feats[0].label(), "GeneA") } +///| test "gd_add_track_feature - multiple features in same track" { let d = @src.gd_create_diagram("test", 0, 1000) let d2 = @src.gd_add_track(d, "genes") @@ -72,6 +99,7 @@ test "gd_add_track_feature - multiple features in same track" { assert_eq(feats.length(), 3) } +///| test "gd_add_track_feature - multiple tracks" { let d = @src.gd_create_diagram("test", 0, 1000) let d2 = @src.gd_add_track(d, "genes") @@ -86,36 +114,83 @@ test "gd_add_track_feature - multiple tracks" { assert_eq(exon_feats.length(), 1) } +///| test "gd_get_features - nonexistent track returns empty" { let d = @src.gd_create_diagram("test", 0, 1000) let feats = @src.gd_get_features(d, "nonexistent") assert_eq(feats.length(), 0) } +///| test "gd_find_overlapping_features - basic overlap" { let d = @src.gd_create_diagram("test", 0, 1000) - let d2 = @src.gd_add_feature(d, 100, 300, "+", "GeneA", @src.gd_rectangle_shape()) - let d3 = @src.gd_add_feature(d2, 400, 600, "+", "GeneB", @src.gd_rectangle_shape()) - let d4 = @src.gd_add_feature(d3, 250, 500, "+", "GeneC", @src.gd_rectangle_shape()) + let d2 = @src.gd_add_feature( + d, + 100, + 300, + "+", + "GeneA", + @src.gd_rectangle_shape(), + ) + let d3 = @src.gd_add_feature( + d2, + 400, + 600, + "+", + "GeneB", + @src.gd_rectangle_shape(), + ) + let d4 = @src.gd_add_feature( + d3, + 250, + 500, + "+", + "GeneC", + @src.gd_rectangle_shape(), + ) let overlaps = @src.gd_find_overlapping_features(d4, 200, 400) assert_eq(overlaps.length(), 2) } +///| test "gd_find_overlapping_features - no overlap" { let d = @src.gd_create_diagram("test", 0, 1000) - let d2 = @src.gd_add_feature(d, 100, 200, "+", "GeneA", @src.gd_rectangle_shape()) - let d3 = @src.gd_add_feature(d2, 500, 600, "+", "GeneB", @src.gd_rectangle_shape()) + let d2 = @src.gd_add_feature( + d, + 100, + 200, + "+", + "GeneA", + @src.gd_rectangle_shape(), + ) + let d3 = @src.gd_add_feature( + d2, + 500, + 600, + "+", + "GeneB", + @src.gd_rectangle_shape(), + ) let overlaps = @src.gd_find_overlapping_features(d3, 300, 400) assert_eq(overlaps.length(), 0) } +///| test "gd_find_overlapping_features - edge touching" { let d = @src.gd_create_diagram("test", 0, 1000) - let d2 = @src.gd_add_feature(d, 100, 200, "+", "GeneA", @src.gd_rectangle_shape()) + let d2 = @src.gd_add_feature( + d, + 100, + 200, + "+", + "GeneA", + @src.gd_rectangle_shape(), + ) let overlaps = @src.gd_find_overlapping_features(d2, 200, 300) assert_eq(overlaps.length(), 0) } +///| test "gd_set_style - basic style" { let d = @src.gd_create_diagram("test", 0, 1000) let style = @src.DiagramStyle::new() @@ -125,6 +200,7 @@ test "gd_set_style - basic style" { assert_true(d2.style().border()) } +///| test "gd_set_style - circular mode" { let d = @src.gd_create_diagram("test", 0, 1000) let style = @src.DiagramStyle::new(circular=true, linear=false) @@ -133,6 +209,7 @@ test "gd_set_style - circular mode" { assert_false(d2.style().linear()) } +///| test "gd_diagram_length - different ranges" { let d1 = @src.gd_create_diagram("a", 0, 500) assert_eq(@src.gd_diagram_length(d1), 500) @@ -142,24 +219,41 @@ test "gd_diagram_length - different ranges" { assert_eq(@src.gd_diagram_length(d3), 100) } +///| test "gd_track_count - empty diagram" { let d = @src.gd_create_diagram("test", 0, 100) assert_eq(@src.gd_track_count(d), 0) } +///| test "gd_feature_count - mixed features" { let d = @src.gd_create_diagram("test", 0, 500) let d2 = @src.gd_add_track(d, "genes") - let d3 = @src.gd_add_feature(d2, 50, 150, "+", "G1", @src.gd_rectangle_shape()) + let d3 = @src.gd_add_feature( + d2, + 50, + 150, + "+", + "G1", + @src.gd_rectangle_shape(), + ) let d4 = @src.gd_add_track_feature(d3, "genes", 100, 200, "+", "G2") let d5 = @src.gd_add_feature(d4, 300, 400, "-", "G3", @src.gd_arrow_shape()) assert_eq(@src.gd_feature_count(d5), 3) } +///| test "gd_to_svg_string - generates valid SVG" { let d = @src.gd_create_diagram("test", 0, 500) let d2 = @src.gd_add_track(d, "genes") - let d3 = @src.gd_add_feature(d2, 50, 150, "+", "GeneA", @src.gd_rectangle_shape()) + let d3 = @src.gd_add_feature( + d2, + 50, + 150, + "+", + "GeneA", + @src.gd_rectangle_shape(), + ) let d4 = @src.gd_add_track_feature(d3, "genes", 200, 300, "+", "Exon1") let svg = @src.gd_to_svg_string(d4, 800, 400) assert_true(svg.length() > 0) @@ -167,19 +261,29 @@ test "gd_to_svg_string - generates valid SVG" { assert_true(svg.contains("")) } +///| test "gd_to_svg_string - empty diagram" { let d = @src.gd_create_diagram("empty", 0, 0) let svg = @src.gd_to_svg_string(d, 400, 200) assert_eq(svg, "") } +///| test "gd_to_svg_string - contains feature labels" { let d = @src.gd_create_diagram("test", 0, 500) - let d2 = @src.gd_add_feature(d, 100, 200, "+", "MyGene", @src.gd_rectangle_shape()) + let d2 = @src.gd_add_feature( + d, + 100, + 200, + "+", + "MyGene", + @src.gd_rectangle_shape(), + ) let svg = @src.gd_to_svg_string(d2, 800, 400) assert_true(svg.contains("MyGene")) } +///| test "gd_set_feature_color - changes color" { let feat = @src.DiagramFeature::new(0, 100, color="#FF0000") let updated = @src.gd_set_feature_color(feat, "#00FF00") @@ -187,12 +291,19 @@ test "gd_set_feature_color - changes color" { assert_eq(feat.color(), "#FF0000") } +///| test "gd_set_feature_color - shape preserved" { - let feat = @src.DiagramFeature::new(0, 100, shape=@src.gd_arrow_shape(), color="#FF0000") + let feat = @src.DiagramFeature::new( + 0, + 100, + shape=@src.gd_arrow_shape(), + color="#FF0000", + ) let updated = @src.gd_set_feature_color(feat, "#00FF00") assert_eq(updated.shape().to_string(), "arrow") } +///| test "gd_label_features - auto labels large features" { let d = @src.gd_create_diagram("test", 0, 1000) let d2 = @src.gd_add_feature(d, 100, 300, "+", "", @src.gd_rectangle_shape()) @@ -203,14 +314,23 @@ test "gd_label_features - auto labels large features" { assert_eq(feats[1].label(), "") } +///| test "gd_label_features - existing labels preserved" { let d = @src.gd_create_diagram("test", 0, 1000) - let d2 = @src.gd_add_feature(d, 100, 300, "+", "Existing", @src.gd_rectangle_shape()) + let d2 = @src.gd_add_feature( + d, + 100, + 300, + "+", + "Existing", + @src.gd_rectangle_shape(), + ) let d3 = @src.gd_label_features(d2, 50) let feats = d3.features() assert_eq(feats[0].label(), "Existing") } +///| test "FeatureShape - to_string conversions" { let r = @src.gd_rectangle_shape() assert_eq(r.to_string(), "rectangle") @@ -224,6 +344,7 @@ test "FeatureShape - to_string conversions" { assert_eq(t.to_string(), "terminators") } +///| test "FeatureShape - from_string conversions" { let r = @src.FeatureShape::from_string("rectangle") assert_eq(r.to_string(), "rectangle") @@ -235,6 +356,7 @@ test "FeatureShape - from_string conversions" { assert_eq(u.to_string(), "rectangle") } +///| test "DiagramStyle - default values" { let style = @src.DiagramStyle::new() assert_eq(style.scale(), 1.0) @@ -244,6 +366,7 @@ test "DiagramStyle - default values" { assert_eq(style.color_scheme(), "default") } +///| test "DiagramStyle - setters" { let style = @src.DiagramStyle::new() let s2 = style.set_scale(2.5) @@ -254,6 +377,7 @@ test "DiagramStyle - setters" { assert_eq(s4.color_scheme(), "grayscale") } +///| test "DiagramStyle - circular and linear are mutually exclusive" { let style = @src.DiagramStyle::new() let circ = style.set_circular(true) @@ -264,6 +388,7 @@ test "DiagramStyle - circular and linear are mutually exclusive" { assert_true(lin.linear()) } +///| test "DiagramFeature - overlaps detection" { let feat = @src.DiagramFeature::new(100, 300) assert_true(feat.overlaps(50, 150)) @@ -273,16 +398,19 @@ test "DiagramFeature - overlaps detection" { assert_false(feat.overlaps(0, 100)) } +///| test "DiagramFeature - length" { let feat = @src.DiagramFeature::new(100, 300) assert_eq(feat.length(), 200) } +///| test "TrackFeature - length" { let feat = @src.TrackFeature::new(50, 150) assert_eq(feat.length(), 100) } +///| test "Track - feature operations" { let t = @src.Track::new("test_track") assert_eq(t.name(), "test_track") @@ -295,13 +423,22 @@ test "Track - feature operations" { assert_eq(t3.feature_count(), 2) } +///| test "gd_feature_count - diagram features only" { let d = @src.gd_create_diagram("test", 0, 1000) let d2 = @src.gd_add_feature(d, 50, 100, "+", "F1", @src.gd_rectangle_shape()) - let d3 = @src.gd_add_feature(d2, 200, 300, "+", "F2", @src.gd_rectangle_shape()) + let d3 = @src.gd_add_feature( + d2, + 200, + 300, + "+", + "F2", + @src.gd_rectangle_shape(), + ) assert_eq(@src.gd_feature_count(d3), 2) } +///| test "gd_to_svg_string - contains track names" { let d = @src.gd_create_diagram("test", 0, 500) let d2 = @src.gd_add_track(d, "MyTrack") @@ -310,6 +447,7 @@ test "gd_to_svg_string - contains track names" { assert_true(svg.contains("MyTrack")) } +///| test "gd_to_svg_string - border toggle" { let d = @src.gd_create_diagram("test", 0, 500) let style = @src.DiagramStyle::new(border=false) @@ -318,6 +456,7 @@ test "gd_to_svg_string - border toggle" { assert_true(svg.contains(" { @@ -240,6 +241,7 @@ test "gfa_parse_tag valid LN:i:100" { } } +///| test "gfa_parse_tag valid VN:Z:1.0" { match @src.gfa_parse_tag("VN:Z:1.0") { Some(t) => { @@ -251,6 +253,7 @@ test "gfa_parse_tag valid VN:Z:1.0" { } } +///| test "gfa_parse_tag invalid bad (no colons)" { match @src.gfa_parse_tag("bad") { Some(_) => assert_true(false) @@ -258,6 +261,7 @@ test "gfa_parse_tag invalid bad (no colons)" { } } +///| test "gfa_parse_tag missing type (one colon)" { match @src.gfa_parse_tag("LN:100") { Some(_) => assert_true(false) @@ -265,6 +269,7 @@ test "gfa_parse_tag missing type (one colon)" { } } +///| test "gfa_parse_tag empty string" { match @src.gfa_parse_tag("") { Some(_) => assert_true(false) @@ -272,6 +277,7 @@ test "gfa_parse_tag empty string" { } } +///| test "gfa_parse_tag with value containing colon" { // The value itself may legally contain ':' (e.g. JSON-style). The parser // splits on the first two colons only. @@ -289,6 +295,7 @@ test "gfa_parse_tag with value containing colon" { // 8. gfa_parse - full GFA document with H, S, L, P lines // ============================================================================ +///| test "gfa_parse full document" { let content = "H\tVN:Z:1.0\nS\tseq1\tACGTACGT\tLN:i:8\nS\tseq2\tTTTTGGGG\tLN:i:8\nL\tseq1\t+\tseq2\t-\t8M\nP\tpath1\tseq1+,seq2-\t8M,4M\n" let graph = @src.gfa_parse(content) @@ -315,6 +322,7 @@ test "gfa_parse full document" { assert_eq(graph.paths()[0].overlaps().length(), 2) } +///| test "gfa_parse handles CRLF line endings" { let content = "H\tVN:Z:1.0\r\nS\tseq1\tACGT\r\n" let graph = @src.gfa_parse(content) @@ -325,6 +333,7 @@ test "gfa_parse handles CRLF line endings" { assert_eq(graph.segments()[0].sequence(), "ACGT") } +///| test "gfa_parse skips blank and unknown lines" { let content = "\nH\tVN:Z:1.0\nX\tunknown\n\nS\tseq1\tACGT\n" let graph = @src.gfa_parse(content) @@ -333,6 +342,7 @@ test "gfa_parse skips blank and unknown lines" { assert_eq(graph.segments()[0].name(), "seq1") } +///| test "gfa_parse_containment" { let fields = ["C", "seq1", "+", "seq2", "+", "5", "8M"] let cont = @src.gfa_parse_containment(fields) @@ -346,6 +356,7 @@ test "gfa_parse_containment" { // 9. gfa_to_string round-trip // ============================================================================ +///| test "gfa_to_string round-trip preserves data" { let content = "H\tVN:Z:1.0\nS\tseq1\tACGTACGT\tLN:i:8\nS\tseq2\tTTTTGGGG\tLN:i:8\nL\tseq1\t+\tseq2\t-\t8M\nP\tpath1\tseq1+,seq2-\t8M,4M\n" let graph1 = @src.gfa_parse(content) @@ -366,6 +377,7 @@ test "gfa_to_string round-trip preserves data" { assert_eq(graph2.paths()[0].overlaps()[1], "4M") } +///| test "gfa_to_string matches expected lines" { let content = "H\tVN:Z:1.0\nS\tseq1\tACGT\tLN:i:4\nL\tseq1\t+\tseq2\t-\t8M\nP\tp1\tseq1+,seq2-\t8M,4M\n" let graph = @src.gfa_parse(content) @@ -380,71 +392,60 @@ test "gfa_to_string matches expected lines" { // Per-record serializers // ============================================================================ +///| test "gfa_header_to_line" { - let header = @src.GfaHeader::new( - "1.0", - [@src.GfaTag::new("VN", "Z", "1.0")], - ) + let header = @src.GfaHeader::new("1.0", [@src.GfaTag::new("VN", "Z", "1.0")]) assert_eq(@src.gfa_header_to_line(header), "H\tVN:Z:1.0") } +///| test "gfa_header_to_line multiple tags" { - let header = @src.GfaHeader::new( - "1.0", - [ - @src.GfaTag::new("VN", "Z", "1.0"), - @src.GfaTag::new("OR", "Z", "sample"), - ], - ) + let header = @src.GfaHeader::new("1.0", [ + @src.GfaTag::new("VN", "Z", "1.0"), + @src.GfaTag::new("OR", "Z", "sample"), + ]) assert_eq(@src.gfa_header_to_line(header), "H\tVN:Z:1.0\tOR:Z:sample") } +///| test "gfa_segment_to_line" { - let seg = @src.GfaSegment::new( - "seq1", - "ACGT", - [@src.GfaTag::new("LN", "i", "4")], - ) + let seg = @src.GfaSegment::new("seq1", "ACGT", [ + @src.GfaTag::new("LN", "i", "4"), + ]) assert_eq(@src.gfa_segment_to_line(seg), "S\tseq1\tACGT\tLN:i:4") } +///| test "gfa_segment_to_line no tags" { let seg = @src.GfaSegment::new("seq2", "TTTT", []) assert_eq(@src.gfa_segment_to_line(seg), "S\tseq2\tTTTT") } +///| test "gfa_link_to_line" { let link = @src.GfaLink::new("seq1", "+", "seq2", "-", "8M", []) assert_eq(@src.gfa_link_to_line(link), "L\tseq1\t+\tseq2\t-\t8M") } +///| test "gfa_link_to_line with tag" { - let link = @src.GfaLink::new( - "a", - "+", - "b", - "+", - "4M", - [@src.GfaTag::new("MQ", "i", "60")], - ) + let link = @src.GfaLink::new("a", "+", "b", "+", "4M", [ + @src.GfaTag::new("MQ", "i", "60"), + ]) assert_eq(@src.gfa_link_to_line(link), "L\ta\t+\tb\t+\t4M\tMQ:i:60") } +///| test "gfa_path_to_line" { let path = @src.GfaPath::new("p1", ["seq1+", "seq2-"], ["8M", "4M"], []) assert_eq(@src.gfa_path_to_line(path), "P\tp1\tseq1+,seq2-\t8M,4M") } +///| test "gfa_containment_to_line" { - let cont = @src.GfaContainment::new( - "seq1", - "+", - "seq2", - "+", - 5, - "8M", - [@src.GfaTag::new("MQ", "i", "60")], - ) + let cont = @src.GfaContainment::new("seq1", "+", "seq2", "+", 5, "8M", [ + @src.GfaTag::new("MQ", "i", "60"), + ]) assert_eq( @src.gfa_containment_to_line(cont), "C\tseq1\t+\tseq2\t+\t5\t8M\tMQ:i:60", @@ -455,6 +456,7 @@ test "gfa_containment_to_line" { // Per-record parsers // ============================================================================ +///| test "gfa_parse_header extracts version" { let fields = ["H", "VN:Z:1.0"] let header = @src.gfa_parse_header(fields) @@ -462,6 +464,7 @@ test "gfa_parse_header extracts version" { assert_eq(header.tags().length(), 1) } +///| test "gfa_parse_segment fields" { let fields = ["S", "seq1", "ACGTACGT", "LN:i:8"] let seg = @src.gfa_parse_segment(fields) @@ -472,6 +475,7 @@ test "gfa_parse_segment fields" { assert_eq(seg.tags()[0].value(), "8") } +///| test "gfa_parse_segment defaults sequence to *" { let fields = ["S", "seq1"] let seg = @src.gfa_parse_segment(fields) @@ -480,6 +484,7 @@ test "gfa_parse_segment defaults sequence to *" { assert_eq(seg.tags().length(), 0) } +///| test "gfa_parse_link fields" { let fields = ["L", "seq1", "+", "seq2", "-", "8M"] let link = @src.gfa_parse_link(fields) @@ -490,6 +495,7 @@ test "gfa_parse_link fields" { assert_eq(link.overlap(), "8M") } +///| test "gfa_parse_path fields" { let fields = ["P", "path1", "seq1+,seq2-", "8M,4M"] let path = @src.gfa_parse_path(fields) @@ -506,6 +512,7 @@ test "gfa_parse_path fields" { // 10. gfa_graph_n_segments / n_links / n_paths // ============================================================================ +///| test "gfa_graph_n_segments/links/paths on sample" { let graph = @src.gfa_sample_graph() assert_eq(@src.gfa_graph_n_segments(graph), 3) @@ -513,6 +520,7 @@ test "gfa_graph_n_segments/links/paths on sample" { assert_eq(@src.gfa_graph_n_paths(graph), 1) } +///| test "gfa_graph_n_segments/links/paths on empty" { let graph = @src.GfaGraph::new() assert_eq(@src.gfa_graph_n_segments(graph), 0) @@ -524,6 +532,7 @@ test "gfa_graph_n_segments/links/paths on empty" { // 11. gfa_get_segment - found and not found // ============================================================================ +///| test "gfa_get_segment found" { let graph = @src.gfa_sample_graph() match @src.gfa_get_segment(graph, "seq2") { @@ -535,6 +544,7 @@ test "gfa_get_segment found" { } } +///| test "gfa_get_segment found first" { let graph = @src.gfa_sample_graph() match @src.gfa_get_segment(graph, "seq1") { @@ -543,6 +553,7 @@ test "gfa_get_segment found first" { } } +///| test "gfa_get_segment not found" { let graph = @src.gfa_sample_graph() match @src.gfa_get_segment(graph, "missing") { @@ -551,6 +562,7 @@ test "gfa_get_segment not found" { } } +///| test "gfa_get_segment on empty graph" { let graph = @src.GfaGraph::new() match @src.gfa_get_segment(graph, "anything") { @@ -563,6 +575,7 @@ test "gfa_get_segment on empty graph" { // 12. gfa_get_segments_as_records - convert to SeqRecord array // ============================================================================ +///| test "gfa_get_segments_as_records sample graph" { let graph = @src.gfa_sample_graph() let records = @src.gfa_get_segments_as_records(graph) @@ -577,12 +590,14 @@ test "gfa_get_segments_as_records sample graph" { assert_eq(records[2].seq.to_string(), "CCCCAAAA") } +///| test "gfa_get_segments_as_records empty graph" { let graph = @src.GfaGraph::new() let records = @src.gfa_get_segments_as_records(graph) assert_eq(records.length(), 0) } +///| test "gfa_get_segments_as_records star sequence becomes empty" { let graph = @src.GfaGraph::new() graph.add_segment(@src.GfaSegment::new("masked", "*", [])) @@ -596,15 +611,11 @@ test "gfa_get_segments_as_records star sequence becomes empty" { // 13. gfa_reverse_link - from/to swapped, orientations swapped // ============================================================================ +///| test "gfa_reverse_link swaps segments and orientations" { - let link = @src.GfaLink::new( - "seq1", - "+", - "seq2", - "-", - "8M", - [@src.GfaTag::new("MQ", "i", "60")], - ) + let link = @src.GfaLink::new("seq1", "+", "seq2", "-", "8M", [ + @src.GfaTag::new("MQ", "i", "60"), + ]) let rev = @src.gfa_reverse_link(link) assert_eq(rev.from_segment(), "seq2") assert_eq(rev.from_orient(), "-") @@ -615,6 +626,7 @@ test "gfa_reverse_link swaps segments and orientations" { assert_eq(rev.tags()[0].name(), "MQ") } +///| test "gfa_reverse_link double-reverse is identity" { let link = @src.GfaLink::new("a", "+", "b", "-", "4M", []) let rev2 = @src.gfa_reverse_link(@src.gfa_reverse_link(link)) @@ -625,18 +637,12 @@ test "gfa_reverse_link double-reverse is identity" { assert_eq(rev2.overlap(), "4M") } +///| test "gfa_reverse_link preserves tags" { - let link = @src.GfaLink::new( - "x", - "+", - "y", - "+", - "0M", - [ - @src.GfaTag::new("MQ", "i", "40"), - @src.GfaTag::new("NM", "i", "0"), - ], - ) + let link = @src.GfaLink::new("x", "+", "y", "+", "0M", [ + @src.GfaTag::new("MQ", "i", "40"), + @src.GfaTag::new("NM", "i", "0"), + ]) let rev = @src.gfa_reverse_link(link) assert_eq(rev.tags().length(), 2) assert_eq(rev.tags()[0].name(), "MQ") @@ -647,6 +653,7 @@ test "gfa_reverse_link preserves tags" { // 14. gfa_graph_summary - non-empty string // ============================================================================ +///| test "gfa_graph_summary non-empty on sample" { let graph = @src.gfa_sample_graph() let summary = @src.gfa_graph_summary(graph) @@ -658,6 +665,7 @@ test "gfa_graph_summary non-empty on sample" { assert_true(summary.contains("total_sequence_length=24")) } +///| test "gfa_graph_summary on empty graph" { let graph = @src.GfaGraph::new() let summary = @src.gfa_graph_summary(graph) @@ -668,6 +676,7 @@ test "gfa_graph_summary on empty graph" { assert_true(summary.contains("total_sequence_length=0")) } +///| test "gfa_graph_summary ignores star sequences" { let graph = @src.GfaGraph::new() graph.add_segment(@src.GfaSegment::new("a", "ACGT", [])) @@ -681,6 +690,7 @@ test "gfa_graph_summary ignores star sequences" { // 15. Sample graph validation // ============================================================================ +///| test "gfa_sample_graph structure" { let graph = @src.gfa_sample_graph() assert_eq(graph.headers().length(), 1) @@ -691,6 +701,7 @@ test "gfa_sample_graph structure" { assert_eq(graph.containments().length(), 0) } +///| test "gfa_sample_graph segments" { let graph = @src.gfa_sample_graph() assert_eq(graph.segments()[0].name(), "seq1") @@ -704,6 +715,7 @@ test "gfa_sample_graph segments" { assert_eq(graph.segments()[0].tags()[0].value(), "8") } +///| test "gfa_sample_graph links" { let graph = @src.gfa_sample_graph() let l0 = graph.links()[0] @@ -716,6 +728,7 @@ test "gfa_sample_graph links" { assert_eq(l1.overlap(), "4M") } +///| test "gfa_sample_graph path" { let graph = @src.gfa_sample_graph() let p = graph.paths()[0] @@ -727,6 +740,7 @@ test "gfa_sample_graph path" { assert_eq(p.overlaps().length(), 2) } +///| test "gfa_sample_graph round-trips through gfa_to_string" { let graph = @src.gfa_sample_graph() let text = @src.gfa_to_string(graph) @@ -741,12 +755,14 @@ test "gfa_sample_graph round-trips through gfa_to_string" { // 16. Edge cases - empty graph, single segment, no links // ============================================================================ +///| test "edge case: empty graph serializes to empty string" { let graph = @src.GfaGraph::new() let s = @src.gfa_to_string(graph) assert_eq(s, "") } +///| test "edge case: parse empty content" { let graph = @src.gfa_parse("") assert_eq(@src.gfa_graph_n_segments(graph), 0) @@ -754,6 +770,7 @@ test "edge case: parse empty content" { assert_eq(@src.gfa_graph_n_paths(graph), 0) } +///| test "edge case: single segment, no links" { let graph = @src.GfaGraph::new() graph.add_segment(@src.GfaSegment::new("only", "ACGT", [])) @@ -764,6 +781,7 @@ test "edge case: single segment, no links" { assert_eq(out, "S\tonly\tACGT\n") } +///| test "edge case: single segment round-trip" { let graph = @src.GfaGraph::new() graph.add_segment(@src.GfaSegment::new("only", "ACGT", [])) @@ -774,6 +792,7 @@ test "edge case: single segment round-trip" { assert_eq(reparsed.segments()[0].sequence(), "ACGT") } +///| test "edge case: segment with star sequence" { let content = "S\tseq1\t*\tLN:i:100\n" let graph = @src.gfa_parse(content) @@ -782,6 +801,7 @@ test "edge case: segment with star sequence" { assert_eq(graph.segments()[0].tags()[0].name(), "LN") } +///| test "edge case: only headers" { let content = "H\tVN:Z:1.0\nH\tOR:Z:test\n" let graph = @src.gfa_parse(content) @@ -789,6 +809,7 @@ test "edge case: only headers" { assert_eq(@src.gfa_graph_n_segments(graph), 0) } +///| test "edge case: unknown record type ignored" { let content = "H\tVN:Z:1.0\nZ\tunknown\tfield\nS\tseq1\tACGT\n" let graph = @src.gfa_parse(content) diff --git a/test/moonbit/gff_test.mbt b/test/moonbit/gff_test.mbt index 4def9b1f..bf869e37 100644 --- a/test/moonbit/gff_test.mbt +++ b/test/moonbit/gff_test.mbt @@ -1,6 +1,5 @@ ///| /// GFF module tests - test "GFFFeature::new" { let feature = @src.GFFFeature::new("chr1", "Ensembl", "gene", 1000, 2000, "+") assert_eq(feature.seqid, "chr1") @@ -9,6 +8,7 @@ test "GFFFeature::new" { assert_eq(feature.end, 2000) } +///| test "GFFFeature::add_attribute" { let feature = @src.GFFFeature::new("chr1", "Ensembl", "gene", 1000, 2000, "+") .add_attribute("ID", "gene001") @@ -19,20 +19,24 @@ test "GFFFeature::add_attribute" { } } +///| test "GFFFeature::get_id" { - let feature = @src.GFFFeature::new("chr1", "Ensembl", "gene", 1000, 2000, "+") - .add_attribute("ID", "gene001") + let feature = @src.GFFFeature::new("chr1", "Ensembl", "gene", 1000, 2000, "+").add_attribute( + "ID", "gene001", + ) match feature.get_id() { Some(id) => assert_eq(id, "gene001") None => assert_true(false) } } +///| test "GFFFeature::length" { let feature = @src.GFFFeature::new("chr1", "Ensembl", "gene", 1000, 2000, "+") assert_eq(feature.length(), 1001) } +///| test "GFFFeature::is_coding" { let gene = @src.GFFFeature::new("chr1", "Ensembl", "gene", 1000, 2000, "+") assert_true(gene.is_coding()) @@ -40,11 +44,13 @@ test "GFFFeature::is_coding" { assert_true(cds.is_coding()) } +///| test "GFFRecord::new" { let record = @src.GFFRecord::new() assert_eq(record.count_features(), 0) } +///| test "GFFRecord::add_feature" { let record = @src.GFFRecord::new() let feature = @src.GFFFeature::new("chr1", "Ensembl", "gene", 1000, 2000, "+") @@ -52,18 +58,21 @@ test "GFFRecord::add_feature" { assert_eq(record.count_features(), 1) } +///| test "GFFRecord::get_features_by_type" { let record = @src.create_example_gff() let genes = record.get_genes() assert_true(genes.length() >= 1) } +///| test "GFFRecord::get_features_by_seqid" { let record = @src.create_example_gff() let features = record.get_features_by_seqid("chr1") assert_true(features.length() > 0) } +///| test "parse_gff" { let content = "##gff-version 3\nchr1\tEnsembl\tgene\t1000\t2000\t.\t+\t.\tID=gene001;Name=TP53\n" let record = @src.bio_parse_gff(content) @@ -71,8 +80,11 @@ test "parse_gff" { assert_eq(record.version, "3") } +///| test "parse_attributes" { - let attrs = @src.parse_attributes("ID=gene001;Name=TP53;biotype=protein_coding") + let attrs = @src.parse_attributes( + "ID=gene001;Name=TP53;biotype=protein_coding", + ) match attrs.get("ID") { Some(id) => assert_eq(id, "gene001") None => assert_true(false) @@ -83,6 +95,7 @@ test "parse_attributes" { } } +///| test "parse_attributes_unescape" { let attrs = @src.parse_attributes("ID=gene001;Name=value%3Bwith%3Bsemicolons") match attrs.get("Name") { @@ -91,25 +104,29 @@ test "parse_attributes_unescape" { } } +///| test "create_example_gff" { let record = @src.create_example_gff() assert_true(record.count_features() > 5) } +///| test "GFFRecord::get_child_features" { let record = @src.create_example_gff() let mrnas = record.get_child_features("gene:ENSG00000130203") assert_true(mrnas.length() >= 1) } +///| test "GFFRecord::get_unique_seqids" { let record = @src.create_example_gff() let seqids = record.get_unique_seqids() assert_true(seqids.length() >= 1) } +///| test "GFFRecord::get_features_in_range" { let record = @src.create_example_gff() let features = record.get_features_in_range("chr1", 10000, 11000) assert_true(features.length() > 0) -} \ No newline at end of file +} diff --git a/test/moonbit/ggtree_test.mbt b/test/moonbit/ggtree_test.mbt index 55834325..deabca30 100644 --- a/test/moonbit/ggtree_test.mbt +++ b/test/moonbit/ggtree_test.mbt @@ -32,8 +32,12 @@ test "ggtree_count_leaves" { test "ggtree_y_positions" { let nodes = @src.create_test_tree() let root = nodes[0] - let n_nodes = @src.ggtree_count_leaves(root) + @src.ggtree_collect_internal_ids(root).length() - let positions : Map[String, (Double, Double, Double)] = Map([], capacity=n_nodes) + let n_nodes = @src.ggtree_count_leaves(root) + + @src.ggtree_collect_internal_ids(root).length() + let positions : Map[String, (Double, Double, Double)] = Map( + [], + capacity=n_nodes, + ) let _ = @src.ggtree_compute_y_positions(root, 0.0, positions) // Root should have a y coordinate @@ -52,8 +56,12 @@ test "ggtree_y_positions" { test "ggtree_x_positions" { let nodes = @src.create_test_tree() let root = nodes[0] - let n_nodes = @src.ggtree_count_leaves(root) + @src.ggtree_collect_internal_ids(root).length() - let positions : Map[String, (Double, Double, Double)] = Map([], capacity=n_nodes) + let n_nodes = @src.ggtree_count_leaves(root) + + @src.ggtree_collect_internal_ids(root).length() + let positions : Map[String, (Double, Double, Double)] = Map( + [], + capacity=n_nodes, + ) let _ = @src.ggtree_compute_y_positions(root, 0.0, positions) @src.ggtree_compute_x_positions(root, 0.0, positions) diff --git a/test/moonbit/glm_gampoi_test.mbt b/test/moonbit/glm_gampoi_test.mbt index 4dc2f6dd..ff6ee84d 100644 --- a/test/moonbit/glm_gampoi_test.mbt +++ b/test/moonbit/glm_gampoi_test.mbt @@ -6,11 +6,11 @@ // --------------------------------------------------------------------------- test "glm_design_creation" { - let d = @src.GlmDesign::new( - ["s1", "s2", "s3"], - ["Intercept", "Treatment"], - [[1.0, 0.0], [1.0, 0.0], [1.0, 1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3"], ["Intercept", "Treatment"], [ + [1.0, 0.0], + [1.0, 0.0], + [1.0, 1.0], + ]) assert_eq(d.n_samples(), 3) assert_eq(d.n_coefs(), 2) assert_eq(d.get(0, 0), 1.0) @@ -19,27 +19,23 @@ test "glm_design_creation" { assert_eq(d.get(2, 1), 1.0) } +///| test "glm_design_intercept_only" { - let d = @src.GlmDesign::new( - ["s1", "s2", "s3", "s4"], - ["Intercept"], - [[1.0], [1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3", "s4"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + [1.0], + ]) assert_eq(d.n_samples(), 4) assert_eq(d.n_coefs(), 1) assert_eq(d.get(0, 0), 1.0) assert_eq(d.get(3, 0), 1.0) } +///| test "glm_fit_creation" { - let f = @src.GlmFit::new( - "GeneA", - [2.5, 1.2], - [0.3, 0.4], - 0.15, - 10, - 8.5, - ) + let f = @src.GlmFit::new("GeneA", [2.5, 1.2], [0.3, 0.4], 0.15, 10, 8.5) assert_eq(f.gene, "GeneA") assert_eq(f.coefficients.length(), 2) assert_eq(f.coefficients[0], 2.5) @@ -51,57 +47,33 @@ test "glm_fit_creation" { assert_eq(f.df_dispersion, 8.5) } +///| test "glm_fit_single_coef" { - let f = @src.GlmFit::new( - "GeneX", - [3.0], - [0.5], - 0.2, - 5, - 5.0, - ) + let f = @src.GlmFit::new("GeneX", [3.0], [0.5], 0.2, 5, 5.0) assert_eq(f.coefficients.length(), 1) assert_eq(f.coefficients[0], 3.0) assert_eq(f.std_errors[0], 0.5) } +///| test "glm_test_result_creation" { - let r = @src.GlmTestResult::new( - "GeneA", - "Treatment", - 1.5, - 0.3, - 5.0, - 0.001, - ) + let r = @src.GlmTestResult::new("GeneA", "Treatment", 1.5, 0.3, 5.0, 0.001) assert_eq(r.estimate(), 1.5) assert_eq(r.p_value(), 0.001) assert_eq(r.adj_p_value(), 0.001) } +///| test "glm_test_result_not_significant" { - let r = @src.GlmTestResult::new( - "GeneB", - "Treatment", - 0.1, - 0.5, - 0.2, - 0.8, - ) + let r = @src.GlmTestResult::new("GeneB", "Treatment", 0.1, 0.5, 0.2, 0.8) assert_false(r.is_significant) assert_eq(r.estimate(), 0.1) assert_eq(r.p_value(), 0.8) } +///| test "glm_test_result_to_string" { - let r = @src.GlmTestResult::new( - "GeneA", - "Treatment", - 1.5, - 0.3, - 5.0, - 0.001, - ) + let r = @src.GlmTestResult::new("GeneA", "Treatment", 1.5, 0.3, 5.0, 0.001) let s = r.to_string() assert_true(s.contains("GeneA")) assert_true(s.contains("Treatment")) @@ -109,19 +81,14 @@ test "glm_test_result_to_string" { assert_true(s.contains("p=")) } +///| test "glm_test_result_significant_marker" { - let r = @src.GlmTestResult::new( - "GeneC", - "Treatment", - 3.0, - 0.2, - 15.0, - 1.0e-10, - ) + let r = @src.GlmTestResult::new("GeneC", "Treatment", 3.0, 0.2, 15.0, 1.0e-10) let s = r.to_string() assert_true(s.contains("*")) } +///| test "glm_pseudobulk_creation" { let pb = @src.GlmPseudobulk::new( ["GeneA", "GeneB"], @@ -133,13 +100,9 @@ test "glm_pseudobulk_creation" { assert_eq(pb.n_groups(), 2) } +///| test "glm_pseudobulk_single_gene" { - let pb = @src.GlmPseudobulk::new( - ["GeneX"], - ["GroupA"], - [["s1"]], - [[42.0]], - ) + let pb = @src.GlmPseudobulk::new(["GeneX"], ["GroupA"], [["s1"]], [[42.0]]) assert_eq(pb.n_genes(), 1) assert_eq(pb.n_groups(), 1) } @@ -148,83 +111,101 @@ test "glm_pseudobulk_single_gene" { // Utility functions // --------------------------------------------------------------------------- +///| test "glm_sum_basic" { let s = @src.glm_sum([1.0, 2.0, 3.0, 4.0]) assert_eq(s, 10.0) } +///| test "glm_sum_single" { assert_eq(@src.glm_sum([5.0]), 5.0) } +///| test "glm_sum_empty" { assert_eq(@src.glm_sum([]), 0.0) } +///| test "glm_sum_negative" { assert_eq(@src.glm_sum([-1.0, -2.0, 3.0]), 0.0) } +///| test "glm_mean_basic" { let m = @src.glm_mean([2.0, 4.0, 6.0]) assert_eq(m, 4.0) } +///| test "glm_mean_single" { assert_eq(@src.glm_mean([7.0]), 7.0) } +///| test "glm_mean_empty" { assert_eq(@src.glm_mean([]), 0.0) } +///| test "glm_mean_zeros" { assert_eq(@src.glm_mean([0.0, 0.0, 0.0]), 0.0) } +///| test "glm_median_odd" { let m = @src.glm_median([3.0, 1.0, 2.0]) assert_eq(m, 2.0) } +///| test "glm_median_even" { let m = @src.glm_median([1.0, 3.0, 2.0, 4.0]) assert_eq(m, 2.5) } +///| test "glm_median_single" { assert_eq(@src.glm_median([5.0]), 5.0) } +///| test "glm_median_empty" { assert_eq(@src.glm_median([]), 0.0) } +///| test "glm_median_already_sorted" { let m = @src.glm_median([1.0, 2.0, 3.0, 4.0, 5.0]) assert_eq(m, 3.0) } +///| test "glm_min_positive_basic" { let v = @src.glm_min_positive([0.0, 3.0, 2.0, 5.0]) assert_eq(v, 2.0) } +///| test "glm_min_positive_no_positive" { let v = @src.glm_min_positive([0.0, -1.0, -5.0]) assert_eq(v, 0.0) } +///| test "glm_min_positive_all_positive" { let v = @src.glm_min_positive([10.0, 3.0, 7.0]) assert_eq(v, 3.0) } +///| test "glm_min_positive_single" { let v = @src.glm_min_positive([42.0]) assert_eq(v, 42.0) } +///| test "glm_min_positive_empty" { let v = @src.glm_min_positive([]) assert_eq(v, 0.0) @@ -234,6 +215,7 @@ test "glm_min_positive_empty" { // Linear algebra: solve linear system // --------------------------------------------------------------------------- +///| test "glm_solve_linear_system_2x2" { // 2x + 3y = 7 // x + y = 3 @@ -245,6 +227,7 @@ test "glm_solve_linear_system_2x2" { assert_true((x[1] - 1.0).abs() < 1.0e-6) } +///| test "glm_solve_linear_system_3x3" { // x + y + z = 6 // 2x + y - z = 1 @@ -258,15 +241,17 @@ test "glm_solve_linear_system_3x3" { assert_true((x[2] - 3.0).abs() < 1.0e-6) } +///| test "glm_solve_linear_system_identity" { // Identity * x = b => x = b let a = [[1.0, 0.0], [0.0, 1.0]] let b = [5.0, -3.0] let x = @src.glm_solve_linear_system(a, b, 2) assert_true((x[0] - 5.0).abs() < 1.0e-6) - assert_true((x[1] - (-3.0)).abs() < 1.0e-6) + assert_true((x[1] - -3.0).abs() < 1.0e-6) } +///| test "glm_solve_linear_system_1x1" { let a = [[3.0]] let b = [12.0] @@ -274,6 +259,7 @@ test "glm_solve_linear_system_1x1" { assert_true((x[0] - 4.0).abs() < 1.0e-6) } +///| test "glm_solve_linear_system_diagonal" { // Diagonal 3x3 system // 3x = 9, 2y = 8, 4z = 16 @@ -289,17 +275,19 @@ test "glm_solve_linear_system_diagonal" { // Linear algebra: matrix inverse // --------------------------------------------------------------------------- +///| test "glm_invert_matrix_2x2" { // A = [[4, 7], [2, 6]] // A^{-1} = [[0.6, -0.7], [-0.2, 0.4]] let a = [[4.0, 7.0], [2.0, 6.0]] let inv = @src.glm_invert_matrix(a, 2) assert_true((inv[0][0] - 0.6).abs() < 1.0e-6) - assert_true((inv[0][1] - (-0.7)).abs() < 1.0e-6) - assert_true((inv[1][0] - (-0.2)).abs() < 1.0e-6) + assert_true((inv[0][1] - -0.7).abs() < 1.0e-6) + assert_true((inv[1][0] - -0.2).abs() < 1.0e-6) assert_true((inv[1][1] - 0.4).abs() < 1.0e-6) } +///| test "glm_invert_matrix_identity_3x3" { let a = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] let inv = @src.glm_invert_matrix(a, 3) @@ -311,12 +299,14 @@ test "glm_invert_matrix_identity_3x3" { } } +///| test "glm_invert_matrix_1x1" { let a = [[5.0]] let inv = @src.glm_invert_matrix(a, 1) assert_true((inv[0][0] - 0.2).abs() < 1.0e-6) } +///| test "glm_invert_matrix_verify_product" { // A * A^{-1} should be identity let a = [[2.0, 1.0], [5.0, 3.0]] @@ -337,6 +327,7 @@ test "glm_invert_matrix_verify_product" { // Statistical utilities // --------------------------------------------------------------------------- +///| test "glm_phi_standard_normal" { // phi(0) ≈ 0.5 let p0 = @src.glm_phi(0.0) @@ -349,6 +340,7 @@ test "glm_phi_standard_normal" { assert_true((p2 - 0.025).abs() < 0.01) } +///| test "glm_phi_symmetry" { // phi(x) + phi(-x) = 1 let x = 1.5 @@ -356,6 +348,7 @@ test "glm_phi_symmetry" { assert_true((p_sum - 1.0).abs() < 1.0e-10) } +///| test "glm_phi_non_decreasing" { // phi should be non-decreasing let p1 = @src.glm_phi(-2.0) @@ -369,6 +362,7 @@ test "glm_phi_non_decreasing" { assert_true(p4 <= p5) } +///| test "glm_phi_clamped" { // phi should be in [0, 1] assert_true(@src.glm_phi(-10.0) >= 0.0) @@ -377,18 +371,21 @@ test "glm_phi_clamped" { assert_true(@src.glm_phi(10.0) <= 1.0) } +///| test "glm_normal_pvalue_two_sided_zero" { // z=0 => p=1.0 let p = @src.glm_normal_pvalue_two_sided(0.0) assert_true((p - 1.0).abs() < 0.01) } +///| test "glm_normal_pvalue_two_sided_196" { // z=1.96 => p≈0.05 let p = @src.glm_normal_pvalue_two_sided(1.96) assert_true((p - 0.05).abs() < 0.01) } +///| test "glm_normal_pvalue_two_sided_symmetry" { // z and -z should give same p-value let p1 = @src.glm_normal_pvalue_two_sided(2.5) @@ -396,6 +393,7 @@ test "glm_normal_pvalue_two_sided_symmetry" { assert_true((p1 - p2).abs() < 1.0e-10) } +///| test "glm_normal_pvalue_two_sided_in_range" { // All p-values should be in [0, 1] for z in [-5.0, -2.0, -1.0, 0.0, 1.0, 2.0, 5.0] { @@ -405,6 +403,7 @@ test "glm_normal_pvalue_two_sided_in_range" { } } +///| test "glm_normal_pvalue_two_sided_large_z" { // Large |z| should give very small p-value (clamped to 1e-15) let p = @src.glm_normal_pvalue_two_sided(10.0) @@ -415,6 +414,7 @@ test "glm_normal_pvalue_two_sided_large_z" { // Sorting // --------------------------------------------------------------------------- +///| test "glm_sort_pairs_basic" { let arr = [(3.0, 2), (1.0, 0), (2.0, 1)] @src.glm_sort_pairs(arr) @@ -426,6 +426,7 @@ test "glm_sort_pairs_basic" { assert_eq(arr[2].1, 2) } +///| test "glm_sort_pairs_already_sorted" { let arr = [(1.0, 0), (2.0, 1), (3.0, 2)] @src.glm_sort_pairs(arr) @@ -434,6 +435,7 @@ test "glm_sort_pairs_already_sorted" { assert_eq(arr[2].0, 3.0) } +///| test "glm_sort_pairs_single" { let arr = [(5.0, 0)] @src.glm_sort_pairs(arr) @@ -441,6 +443,7 @@ test "glm_sort_pairs_single" { assert_eq(arr[0].0, 5.0) } +///| test "glm_sort_pairs_empty" { let arr : Array[(Double, Int)] = [] @src.glm_sort_pairs(arr) @@ -451,12 +454,14 @@ test "glm_sort_pairs_empty" { // BH-FDR correction // --------------------------------------------------------------------------- +///| test "glm_bh_correct_single" { // Single p-value correction returns same value let p = @src.glm_bh_correct(0.05) assert_eq(p, 0.05) } +///| test "glm_bh_correct_array_known_values" { // p-values: [0.01, 0.04, 0.03, 0.005] // Sorted: [0.005, 0.01, 0.03, 0.04] @@ -473,6 +478,7 @@ test "glm_bh_correct_array_known_values" { assert_true((adj[3] - 0.02).abs() < 1.0e-6) } +///| test "glm_bh_correct_array_all_same" { let pvals = [0.05, 0.05, 0.05] let adj = @src.glm_bh_correct_array(pvals) @@ -481,17 +487,20 @@ test "glm_bh_correct_array_all_same" { assert_true((adj[1] - adj[2]).abs() < 1.0e-10) } +///| test "glm_bh_correct_array_single" { let adj = @src.glm_bh_correct_array([0.02]) assert_eq(adj.length(), 1) assert_true((adj[0] - 0.02).abs() < 1.0e-6) } +///| test "glm_bh_correct_array_empty" { let adj = @src.glm_bh_correct_array([]) assert_eq(adj.length(), 0) } +///| test "glm_bh_correct_array_values_in_range" { let pvals = [0.001, 0.02, 0.05, 0.1, 0.5] let adj = @src.glm_bh_correct_array(pvals) @@ -501,15 +510,11 @@ test "glm_bh_correct_array_values_in_range" { } } +///| test "glm_bh_correct_array_monotonic" { let pvals = [0.001, 0.01, 0.03, 0.04] let adj = @src.glm_bh_correct_array(pvals) - let indexed = [ - (pvals[0], 0), - (pvals[1], 1), - (pvals[2], 2), - (pvals[3], 3), - ] + let indexed = [(pvals[0], 0), (pvals[1], 1), (pvals[2], 2), (pvals[3], 3)] @src.glm_sort_pairs(indexed) let adj0 = adj[indexed[0].1] let adj1 = adj[indexed[1].1] @@ -524,15 +529,12 @@ test "glm_bh_correct_array_monotonic" { // Size factor calculation // --------------------------------------------------------------------------- +///| test "glm_calculate_sf_basic" { // 3 genes, 2 samples // Sample 0: [10, 20, 30], Sample 1: [20, 40, 60] // Sample 1 has twice the counts, so sf[1] ≈ 2 * sf[0] - let counts = [ - [10.0, 20.0], - [20.0, 40.0], - [30.0, 60.0], - ] + let counts = [[10.0, 20.0], [20.0, 40.0], [30.0, 60.0]] let sf = @src.glm_calculate_sf(counts) assert_eq(sf.length(), 2) assert_true(sf[0] > 0.0) @@ -541,11 +543,9 @@ test "glm_calculate_sf_basic" { assert_true((sf[1] / sf[0] - 2.0).abs() < 0.5) } +///| test "glm_calculate_sf_equal_samples" { - let counts = [ - [10.0, 10.0, 10.0], - [20.0, 20.0, 20.0], - ] + let counts = [[10.0, 10.0, 10.0], [20.0, 20.0, 20.0]] let sf = @src.glm_calculate_sf(counts) assert_eq(sf.length(), 3) // All samples have same counts, so sf should be equal @@ -553,6 +553,7 @@ test "glm_calculate_sf_equal_samples" { assert_true((sf[1] - sf[2]).abs() < 1.0e-6) } +///| test "glm_calculate_sf_single_sample" { let counts = [[5.0], [10.0], [15.0]] let sf = @src.glm_calculate_sf(counts) @@ -560,16 +561,15 @@ test "glm_calculate_sf_single_sample" { assert_true(sf[0] > 0.0) } +///| test "glm_calculate_sf_empty" { let sf = @src.glm_calculate_sf([]) assert_eq(sf.length(), 0) } +///| test "glm_calculate_sf_all_zeros" { - let counts = [ - [0.0, 0.0], - [0.0, 0.0], - ] + let counts = [[0.0, 0.0], [0.0, 0.0]] let sf = @src.glm_calculate_sf(counts) assert_eq(sf.length(), 2) // Should fallback to 1.0 for zero-count samples @@ -577,12 +577,9 @@ test "glm_calculate_sf_all_zeros" { assert_true(sf[1] > 0.0) } +///| test "glm_calculate_sf_genes_with_zeros" { - let counts = [ - [10.0, 0.0], - [0.0, 20.0], - [30.0, 30.0], - ] + let counts = [[10.0, 0.0], [0.0, 20.0], [30.0, 30.0]] let sf = @src.glm_calculate_sf(counts) assert_eq(sf.length(), 2) assert_true(sf[0] > 0.0) @@ -593,12 +590,10 @@ test "glm_calculate_sf_genes_with_zeros" { // Pseudobulk aggregation // --------------------------------------------------------------------------- +///| test "glm_pseudobulk_basic" { // 2 genes, 4 samples (2 control, 2 treated) - let counts = [ - [10.0, 12.0, 50.0, 48.0], - [20.0, 22.0, 18.0, 20.0], - ] + let counts = [[10.0, 12.0, 50.0, 48.0], [20.0, 22.0, 18.0, 20.0]] let gene_names = ["GeneA", "GeneB"] let group_labels = ["control", "control", "treated", "treated"] let pb = @src.glm_pseudobulk(counts, gene_names, group_labels) @@ -606,6 +601,7 @@ test "glm_pseudobulk_basic" { assert_eq(pb.n_groups(), 2) } +///| test "glm_pseudobulk_single_group" { let counts = [[10.0, 20.0, 30.0]] let gene_names = ["GeneX"] @@ -615,10 +611,9 @@ test "glm_pseudobulk_single_group" { assert_eq(pb.n_groups(), 1) } +///| test "glm_pseudobulk_single_sample_per_group" { - let counts = [ - [5.0, 10.0, 15.0], - ] + let counts = [[5.0, 10.0, 15.0]] let gene_names = ["GeneX"] let group_labels = ["A", "B", "C"] let pb = @src.glm_pseudobulk(counts, gene_names, group_labels) @@ -626,10 +621,11 @@ test "glm_pseudobulk_single_sample_per_group" { assert_eq(pb.n_groups(), 3) } +///| test "glm_pseudobulk_empty" { - let counts: Array[Array[Double]] = [] - let gene_names: Array[String] = [] - let group_labels: Array[String] = [] + let counts : Array[Array[Double]] = [] + let gene_names : Array[String] = [] + let group_labels : Array[String] = [] let pb = @src.glm_pseudobulk(counts, gene_names, group_labels) assert_eq(pb.n_genes(), 0) assert_eq(pb.n_groups(), 0) @@ -639,13 +635,15 @@ test "glm_pseudobulk_empty" { // Initial estimates and dispersion // --------------------------------------------------------------------------- +///| test "glm_initial_estimates_constant_counts" { let counts = [10.0, 10.0, 10.0, 10.0] - let d = @src.GlmDesign::new( - ["s1", "s2", "s3", "s4"], - ["Intercept"], - [[1.0], [1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3", "s4"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + [1.0], + ]) let coefs = @src.glm_initial_estimates(counts, d) assert_eq(coefs.length(), 1) // With constant counts and intercept-only design, @@ -654,6 +652,7 @@ test "glm_initial_estimates_constant_counts" { assert_true((coefs[0] - expected_ln).abs() < 0.5) } +///| test "glm_initial_estimates_two_groups" { let counts = [10.0, 12.0, 50.0, 48.0] let d = @src.GlmDesign::new( @@ -667,25 +666,29 @@ test "glm_initial_estimates_two_groups" { assert_true(coefs[1] > 0.0) } +///| test "glm_initial_estimates_with_zeros" { let counts = [0.0, 10.0, 20.0, 30.0] - let d = @src.GlmDesign::new( - ["s1", "s2", "s3", "s4"], - ["Intercept"], - [[1.0], [1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3", "s4"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + [1.0], + ]) let coefs = @src.glm_initial_estimates(counts, d) assert_eq(coefs.length(), 1) assert_true(coefs[0] > 0.0) } +///| test "glm_estimate_dispersion_low" { let counts = [10.0, 11.0, 10.5, 9.5] - let d = @src.GlmDesign::new( - ["s1", "s2", "s3", "s4"], - ["Intercept"], - [[1.0], [1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3", "s4"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + [1.0], + ]) let coefs = @src.glm_initial_estimates(counts, d) let disp = @src.glm_estimate_dispersion(counts, d, coefs) // Low dispersion for tightly clustered counts @@ -693,26 +696,30 @@ test "glm_estimate_dispersion_low" { assert_true(disp < 5.0) } +///| test "glm_estimate_dispersion_high" { let counts = [1.0, 50.0, 2.0, 48.0] - let d = @src.GlmDesign::new( - ["s1", "s2", "s3", "s4"], - ["Intercept"], - [[1.0], [1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3", "s4"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + [1.0], + ]) let coefs = @src.glm_initial_estimates(counts, d) let disp = @src.glm_estimate_dispersion(counts, d, coefs) // High dispersion for highly variable counts assert_true(disp >= 0.0) } +///| test "glm_estimate_dispersion_all_same" { let counts = [20.0, 20.0, 20.0, 20.0] - let d = @src.GlmDesign::new( - ["s1", "s2", "s3", "s4"], - ["Intercept"], - [[1.0], [1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3", "s4"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + [1.0], + ]) let coefs = @src.glm_initial_estimates(counts, d) let disp = @src.glm_estimate_dispersion(counts, d, coefs) // Zero variance => dispersion should be very small or 0 @@ -723,6 +730,7 @@ test "glm_estimate_dispersion_all_same" { // IWLCS fit // --------------------------------------------------------------------------- +///| test "glm_iwlcs_fit_produces_coefs" { let counts = [10.0, 12.0, 50.0, 48.0] let d = @src.GlmDesign::new( @@ -737,13 +745,15 @@ test "glm_iwlcs_fit_produces_coefs" { assert_true(coefs[1] > 0.0) } +///| test "glm_iwlcs_fit_converges" { let counts = [10.0, 10.0, 10.0, 10.0] - let d = @src.GlmDesign::new( - ["s1", "s2", "s3", "s4"], - ["Intercept"], - [[1.0], [1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3", "s4"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + [1.0], + ]) let initial = @src.glm_initial_estimates(counts, d) let coefs = @src.glm_iwlcs_fit(counts, d, 0.1, initial) assert_eq(coefs.length(), 1) @@ -756,6 +766,7 @@ test "glm_iwlcs_fit_converges" { // Standard error computation // --------------------------------------------------------------------------- +///| test "glm_compute_se_positive" { let d = @src.GlmDesign::new( ["s1", "s2", "s3", "s4"], @@ -770,12 +781,13 @@ test "glm_compute_se_positive" { assert_true(se[1] > 0.0) } +///| test "glm_compute_se_single_coef" { - let d = @src.GlmDesign::new( - ["s1", "s2", "s3"], - ["Intercept"], - [[1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + ]) let coefs = [2.5] let sf = [1.0, 1.0, 1.0] let se = @src.glm_compute_se(d, 0.2, coefs, sf) @@ -787,6 +799,7 @@ test "glm_compute_se_single_coef" { // Single-gene fitting // --------------------------------------------------------------------------- +///| test "glm_fit_one_gene_basic" { let counts = [10.0, 12.0, 50.0, 48.0] let d = @src.GlmDesign::new( @@ -804,6 +817,7 @@ test "glm_fit_one_gene_basic" { assert_true(fit.df_dispersion > 0.0) } +///| test "glm_fit_one_gene_treatment_positive" { let counts = [10.0, 12.0, 50.0, 48.0] let d = @src.GlmDesign::new( @@ -817,6 +831,7 @@ test "glm_fit_one_gene_treatment_positive" { assert_true(fit.coefficients[1] > 0.0) } +///| test "glm_fit_one_gene_no_treatment_effect" { let counts = [20.0, 22.0, 18.0, 20.0] let d = @src.GlmDesign::new( @@ -834,12 +849,10 @@ test "glm_fit_one_gene_no_treatment_effect" { // Differential expression testing // --------------------------------------------------------------------------- +///| test "glm_test_de_basic" { // 2 genes, 4 samples - let counts = [ - [10.0, 12.0, 50.0, 48.0], - [20.0, 22.0, 18.0, 20.0], - ] + let counts = [[10.0, 12.0, 50.0, 48.0], [20.0, 22.0, 18.0, 20.0]] let gene_names = ["GeneA", "GeneB"] let d = @src.GlmDesign::new( ["s1", "s2", "s3", "s4"], @@ -853,11 +866,9 @@ test "glm_test_de_basic" { assert_eq(results[1].gene, "GeneB") } +///| test "glm_test_de_pvalues_in_range" { - let counts = [ - [10.0, 12.0, 50.0, 48.0], - [20.0, 22.0, 18.0, 20.0], - ] + let counts = [[10.0, 12.0, 50.0, 48.0], [20.0, 22.0, 18.0, 20.0]] let gene_names = ["GeneA", "GeneB"] let d = @src.GlmDesign::new( ["s1", "s2", "s3", "s4"], @@ -874,12 +885,10 @@ test "glm_test_de_pvalues_in_range" { } } +///| test "glm_test_de_detects_differential" { // GeneA has strong treatment effect, GeneB does not - let counts = [ - [5.0, 6.0, 80.0, 75.0], - [20.0, 22.0, 18.0, 20.0], - ] + let counts = [[5.0, 6.0, 80.0, 75.0], [20.0, 22.0, 18.0, 20.0]] let gene_names = ["GeneA", "GeneB"] let d = @src.GlmDesign::new( ["s1", "s2", "s3", "s4"], @@ -894,11 +903,9 @@ test "glm_test_de_detects_differential" { assert_true(z_a > z_b) } +///| test "glm_test_de_estimate_sign" { - let counts = [ - [10.0, 12.0, 50.0, 48.0], - [50.0, 48.0, 10.0, 12.0], - ] + let counts = [[10.0, 12.0, 50.0, 48.0], [50.0, 48.0, 10.0, 12.0]] let gene_names = ["GeneUp", "GeneDown"] let d = @src.GlmDesign::new( ["s1", "s2", "s3", "s4"], @@ -913,6 +920,7 @@ test "glm_test_de_estimate_sign" { assert_true(results[1].estimate() < 0.0) } +///| test "glm_test_de_single_gene" { let counts = [[10.0, 12.0, 50.0, 48.0]] let gene_names = ["GeneA"] @@ -931,6 +939,7 @@ test "glm_test_de_single_gene" { // Significant filtering // --------------------------------------------------------------------------- +///| test "glm_significant_filters_correctly" { let r1 = @src.GlmTestResult::new("GeneA", "Treatment", 3.0, 0.5, 6.0, 1.0e-10) let r2 = @src.GlmTestResult::new("GeneB", "Treatment", 0.1, 0.3, 0.3, 0.8) @@ -947,11 +956,13 @@ test "glm_significant_filters_correctly" { } } +///| test "glm_significant_empty_input" { let sig = @src.glm_significant([], 0.05) assert_eq(sig.length(), 0) } +///| test "glm_significant_no_passing" { let r1 = @src.GlmTestResult::new("GeneA", "Treatment", 0.0, 0.5, 0.0, 0.5) let r2 = @src.GlmTestResult::new("GeneB", "Treatment", 0.1, 0.3, 0.3, 0.8) @@ -960,8 +971,11 @@ test "glm_significant_no_passing" { assert_eq(sig.length(), 0) } +///| test "glm_significant_all_pass" { - let r1 = @src.GlmTestResult::new("GeneA", "Treatment", 5.0, 0.5, 10.0, 1.0e-10) + let r1 = @src.GlmTestResult::new( + "GeneA", "Treatment", 5.0, 0.5, 10.0, 1.0e-10, + ) let r2 = @src.GlmTestResult::new("GeneB", "Treatment", 4.0, 0.3, 13.0, 1.0e-8) let results = [r1, r2] let sig = @src.glm_significant(results, 1.0) @@ -972,36 +986,35 @@ test "glm_significant_all_pass" { // Edge cases and integration // --------------------------------------------------------------------------- +///| test "glm_design_single_sample" { - let d = @src.GlmDesign::new( - ["s1"], - ["Intercept"], - [[1.0]], - ) + let d = @src.GlmDesign::new(["s1"], ["Intercept"], [[1.0]]) assert_eq(d.n_samples(), 1) assert_eq(d.n_coefs(), 1) assert_eq(d.get(0, 0), 1.0) } +///| test "glm_design_many_coefs" { - let d = @src.GlmDesign::new( - ["s1", "s2"], - ["A", "B", "C", "D"], - [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2"], ["A", "B", "C", "D"], [ + [1.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0], + ]) assert_eq(d.n_samples(), 2) assert_eq(d.n_coefs(), 4) assert_eq(d.get(0, 0), 1.0) assert_eq(d.get(1, 1), 1.0) } +///| test "glm_fit_constant_counts" { let counts = [20.0, 20.0, 20.0, 20.0] - let d = @src.GlmDesign::new( - ["s1", "s2", "s3", "s4"], - ["Intercept"], - [[1.0], [1.0], [1.0], [1.0]], - ) + let d = @src.GlmDesign::new(["s1", "s2", "s3", "s4"], ["Intercept"], [ + [1.0], + [1.0], + [1.0], + [1.0], + ]) let sf = [1.0, 1.0, 1.0, 1.0] let fit = @src.glm_fit_one_gene(counts, d, sf, "GeneConst") assert_eq(fit.gene, "GeneConst") @@ -1009,11 +1022,9 @@ test "glm_fit_constant_counts" { assert_true(fit.dispersion >= 0.0) } +///| test "glm_test_de_with_size_factors" { - let counts = [ - [10.0, 20.0, 50.0, 100.0], - [20.0, 40.0, 18.0, 36.0], - ] + let counts = [[10.0, 20.0, 50.0, 100.0], [20.0, 40.0, 18.0, 36.0]] let gene_names = ["GeneA", "GeneB"] let d = @src.GlmDesign::new( ["s1", "s2", "s3", "s4"], @@ -1025,6 +1036,7 @@ test "glm_test_de_with_size_factors" { assert_eq(results.length(), 2) } +///| test "glm_full_pipeline" { // Simulate a full differential expression analysis pipeline let counts = [ @@ -1066,44 +1078,48 @@ test "glm_full_pipeline" { } } +///| test "glm_phi_05" { // phi(0.5) should be approximately 0.6915 let p = @src.glm_phi(0.5) assert_true((p - 0.6915).abs() < 0.01) } +///| test "glm_phi_2" { // phi(2.0) should be approximately 0.9772 let p = @src.glm_phi(2.0) assert_true((p - 0.9772).abs() < 0.01) } +///| test "glm_phi_negative" { // phi(-1.0) should be approximately 0.1587 let p = @src.glm_phi(-1.0) assert_true((p - 0.1587).abs() < 0.01) } +///| test "glm_median_two_elements" { let m = @src.glm_median([3.0, 7.0]) assert_eq(m, 5.0) } +///| test "glm_median_with_duplicates" { let m = @src.glm_median([1.0, 2.0, 2.0, 3.0, 3.0]) assert_eq(m, 2.0) } +///| test "glm_min_positive_all_zero" { let v = @src.glm_min_positive([0.0, 0.0, 0.0]) assert_eq(v, 0.0) } +///| test "glm_calculate_sf_two_genes" { - let counts = [ - [100.0, 10.0], - [200.0, 20.0], - ] + let counts = [[100.0, 10.0], [200.0, 20.0]] let sf = @src.glm_calculate_sf(counts) assert_eq(sf.length(), 2) // Sample 0 has 10x more counts than sample 1 @@ -1111,11 +1127,9 @@ test "glm_calculate_sf_two_genes" { assert_true((sf[0] / sf[1] - 10.0).abs() < 2.0) } +///| test "glm_test_de_all_zeros" { - let counts = [ - [0.0, 0.0, 0.0, 0.0], - [0.0, 0.0, 0.0, 0.0], - ] + let counts = [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]] let gene_names = ["GeneA", "GeneB"] let d = @src.GlmDesign::new( ["s1", "s2", "s3", "s4"], @@ -1132,6 +1146,7 @@ test "glm_test_de_all_zeros" { } } +///| test "glm_bh_correct_array_already_corrected" { // When all p-values are very small, BH should keep them small let pvals = [1.0e-10, 1.0e-8, 1.0e-6, 1.0e-4] @@ -1142,4 +1157,4 @@ test "glm_bh_correct_array_already_corrected" { } // The smallest p-value should remain small assert_true(adj[0] <= 1.0e-4) -} \ No newline at end of file +} diff --git a/test/moonbit/goa_test.mbt b/test/moonbit/goa_test.mbt index 72a7d575..7b6861e1 100644 --- a/test/moonbit/goa_test.mbt +++ b/test/moonbit/goa_test.mbt @@ -11,18 +11,21 @@ test "goa_aspect_from_string_F" { assert_eq(@src.GafAspect::description(a), "Molecular Function") } +///| test "goa_aspect_from_string_P" { let a = @src.GafAspect::from_string("P") assert_eq(@src.GafAspect::to_string(a), "P") assert_eq(@src.GafAspect::description(a), "Biological Process") } +///| test "goa_aspect_from_string_C" { let a = @src.GafAspect::from_string("C") assert_eq(@src.GafAspect::to_string(a), "C") assert_eq(@src.GafAspect::description(a), "Cellular Component") } +///| test "goa_aspect_from_string_unknown" { // Unknown inputs (e.g. "X", "", "foo") map to Unknown. let a1 = @src.GafAspect::from_string("X") @@ -36,6 +39,7 @@ test "goa_aspect_from_string_unknown" { assert_eq(@src.GafAspect::description(a3), "Unknown") } +///| test "goa_aspect_to_string_roundtrip" { // from_string -> to_string should round-trip for the three valid codes. assert_eq(@src.GafAspect::to_string(@src.GafAspect::from_string("F")), "F") @@ -47,6 +51,7 @@ test "goa_aspect_to_string_roundtrip" { // GafRecord creation and accessors // --------------------------------------------------------------------------- +///| test "goa_record_creation" { let r = @src.GafRecord::new( db="UniProtKB", @@ -86,6 +91,7 @@ test "goa_record_creation" { assert_eq(r.gene_product_form_id(), "") } +///| test "goa_record_creation_all_fields_populated" { // Record with every field populated, including the optional extension/form id. let r = @src.GafRecord::new( @@ -118,6 +124,7 @@ test "goa_record_creation_all_fields_populated" { // GafRecord utility methods // --------------------------------------------------------------------------- +///| test "goa_record_go_id_short" { let r = @src.GafRecord::new( db="UniProtKB", @@ -141,6 +148,7 @@ test "goa_record_go_id_short" { assert_eq(r.go_id_short(), "0003674") } +///| test "goa_record_go_id_short_no_prefix" { // A GO ID without "GO:" prefix should be returned unchanged. let r = @src.GafRecord::new( @@ -165,6 +173,7 @@ test "goa_record_go_id_short_no_prefix" { assert_eq(r.go_id_short(), "0003674") } +///| test "goa_record_qualifiers_split" { let r = @src.GafRecord::new( db="UniProtKB", @@ -191,6 +200,7 @@ test "goa_record_qualifiers_split" { assert_eq(qs[1], "enables") } +///| test "goa_record_qualifiers_single" { let r = @src.GafRecord::new( db="UniProtKB", @@ -216,6 +226,7 @@ test "goa_record_qualifiers_single" { assert_eq(qs[0], "enables") } +///| test "goa_record_qualifiers_empty" { let r = @src.GafRecord::new( db="UniProtKB", @@ -239,6 +250,7 @@ test "goa_record_qualifiers_empty" { assert_eq(r.qualifiers().length(), 0) } +///| test "goa_record_synonyms_split" { let r = @src.GafRecord::new( db="UniProtKB", @@ -265,6 +277,7 @@ test "goa_record_synonyms_split" { assert_eq(syns[1], "LFS1") } +///| test "goa_record_references_split" { let r = @src.GafRecord::new( db="UniProtKB", @@ -292,6 +305,7 @@ test "goa_record_references_split" { assert_eq(refs[2], "GO_REF:000001") } +///| test "goa_record_taxon_ids_with_prefix" { // "taxon:9606|taxon:9606" yields ["9606", "9606"] (duplicates preserved). let r = @src.GafRecord::new( @@ -319,6 +333,7 @@ test "goa_record_taxon_ids_with_prefix" { assert_eq(ids[1], "9606") } +///| test "goa_record_taxon_ids_bare_numeric" { // Numeric taxon IDs without the "taxon:" prefix should be returned as-is. let r = @src.GafRecord::new( @@ -345,6 +360,7 @@ test "goa_record_taxon_ids_bare_numeric" { assert_eq(ids[0], "9606") } +///| test "goa_record_taxon_ids_multiple_distinct" { // Two distinct taxon IDs (interactor case). let r = @src.GafRecord::new( @@ -372,6 +388,7 @@ test "goa_record_taxon_ids_multiple_distinct" { assert_eq(ids[1], "4932") } +///| test "goa_record_to_string" { let r = @src.GafRecord::new( db="UniProtKB", @@ -405,6 +422,7 @@ test "goa_record_to_string" { // Header line parsing // --------------------------------------------------------------------------- +///| test "goa_parse_header_line_valid" { let h = @src.goa_parse_header_line("!gaf-version: 2.2") assert_true(h is Some(_)) @@ -417,6 +435,7 @@ test "goa_parse_header_line_valid" { } } +///| test "goa_parse_header_line_generated_by" { let h = @src.goa_parse_header_line("!generated-by: UniProt") assert_true(h is Some(_)) @@ -429,6 +448,7 @@ test "goa_parse_header_line_generated_by" { } } +///| test "goa_parse_header_line_with_extra_spaces" { let h = @src.goa_parse_header_line("! gaf-version : 2.2 ") assert_true(h is Some(_)) @@ -441,23 +461,27 @@ test "goa_parse_header_line_with_extra_spaces" { } } +///| test "goa_parse_header_line_not_header" { // A line that does not start with "!" is not a header. let h = @src.goa_parse_header_line("UniProtKB\tQ12345") assert_true(h is None) } +///| test "goa_parse_header_line_no_colon" { // A header line with no colon is invalid. let h = @src.goa_parse_header_line("!this-has-no-colon") assert_true(h is None) } +///| test "goa_parse_header_line_empty" { let h = @src.goa_parse_header_line("") assert_true(h is None) } +///| test "goa_parse_header_line_empty_value" { // A header line with a colon but empty value is valid (value is ""). let h = @src.goa_parse_header_line("!gaf-version:") @@ -475,6 +499,7 @@ test "goa_parse_header_line_empty_value" { // Data line parsing // --------------------------------------------------------------------------- +///| test "goa_parse_line_full_17_columns" { let line = "UniProtKB\tQ12345\tPROT1\tenables\tGO:0003674\tPMID:12345\tIDA\tGO:0005515\tF\tProtein 1\tP1|PROT-1\tprotein\ttaxon:9606|taxon:9606\t20210115\tUniProt\t\t" let r = @src.goa_parse_line(line) @@ -503,6 +528,7 @@ test "goa_parse_line_full_17_columns" { } } +///| test "goa_parse_line_short_padded" { // A line with fewer than 17 columns should be right-padded with empty strings. let line = "UniProtKB\tQ12345\tPROT1\tenables\tGO:0003674" @@ -525,22 +551,26 @@ test "goa_parse_line_short_padded" { } } +///| test "goa_parse_line_empty" { let r = @src.goa_parse_line("") assert_true(r is None) } +///| test "goa_parse_line_whitespace_only" { let r = @src.goa_parse_line(" ") assert_true(r is None) } +///| test "goa_parse_line_header_returns_none" { // Header lines (starting with "!") should not be parsed as data records. let r = @src.goa_parse_line("!gaf-version: 2.2") assert_true(r is None) } +///| test "goa_parse_line_comment_returns_none" { // Any line starting with "!" is treated as a header/comment, not data. let r = @src.goa_parse_line("!some comment line") @@ -551,6 +581,7 @@ test "goa_parse_line_comment_returns_none" { // Full content parsing // --------------------------------------------------------------------------- +///| test "goa_parse_with_header_and_data" { let content = "!gaf-version: 2.2\n" + "!generated-by: UniProt\n" + @@ -565,6 +596,7 @@ test "goa_parse_with_header_and_data" { assert_eq(recs[1].db_object_symbol(), "TP53") } +///| test "goa_parse_empty_input" { let db = @src.goa_parse("") assert_eq(db.n_records(), 0) @@ -572,6 +604,7 @@ test "goa_parse_empty_input" { assert_eq(db.created_by(), "") } +///| test "goa_parse_only_headers" { let content = "!gaf-version: 2.2\n" + "!generated-by: SGD\n" let db = @src.goa_parse(content) @@ -580,6 +613,7 @@ test "goa_parse_only_headers" { assert_eq(db.created_by(), "SGD") } +///| test "goa_parse_skips_blank_lines" { let content = "!gaf-version: 2.2\n" + "\n" + @@ -590,6 +624,7 @@ test "goa_parse_skips_blank_lines" { assert_eq(db.n_records(), 2) } +///| test "goa_parse_ignores_unknown_header_keys" { // Header keys other than gaf-version / generated-by should not overwrite metadata. let content = "!gaf-version: 2.2\n" + @@ -606,6 +641,7 @@ test "goa_parse_ignores_unknown_header_keys" { // GoaDatabase properties // --------------------------------------------------------------------------- +///| test "goa_database_new_empty" { let db = @src.GoaDatabase::new() assert_eq(db.n_records(), 0) @@ -614,6 +650,7 @@ test "goa_database_new_empty" { assert_eq(db.created_by(), "") } +///| test "goa_database_records_accessor" { let db = @src.goa_sample_database() let recs = db.records() @@ -624,6 +661,7 @@ test "goa_database_records_accessor" { // Filter functions // --------------------------------------------------------------------------- +///| test "goa_filter_by_go_id" { let db = @src.goa_sample_database() // GO:0003674 (molecular_function) appears once in the sample database. @@ -633,12 +671,14 @@ test "goa_filter_by_go_id" { assert_eq(hits[0].go_id(), "GO:0003674") } +///| test "goa_filter_by_go_id_no_match" { let db = @src.goa_sample_database() let hits = @src.goa_filter_by_go_id(db, "GO:9999999") assert_eq(hits.length(), 0) } +///| test "goa_filter_by_aspect_molecular_function" { let db = @src.goa_sample_database() // F records: PROT1, TP53, YFG1, RPL5 (4 total). @@ -649,6 +689,7 @@ test "goa_filter_by_aspect_molecular_function" { } } +///| test "goa_filter_by_aspect_biological_process" { let db = @src.goa_sample_database() // P records: PROT1, TP53, Hsp70 (3 total). @@ -659,6 +700,7 @@ test "goa_filter_by_aspect_biological_process" { } } +///| test "goa_filter_by_aspect_cellular_component" { let db = @src.goa_sample_database() // C records: PROT1, YFG1, Hsp70 (3 total). @@ -669,6 +711,7 @@ test "goa_filter_by_aspect_cellular_component" { } } +///| test "goa_filter_by_aspect_unknown" { let db = @src.goa_sample_database() // No Unknown aspect records in the sample database. @@ -676,6 +719,7 @@ test "goa_filter_by_aspect_unknown" { assert_eq(hits.length(), 0) } +///| test "goa_filter_by_evidence_ida" { let db = @src.goa_sample_database() // IDA records: PROT1 (x3), YFG1 (C), Hsp70 (C) = 5 total. @@ -686,6 +730,7 @@ test "goa_filter_by_evidence_ida" { } } +///| test "goa_filter_by_evidence_iea" { let db = @src.goa_sample_database() // IEA records: TP53 (P), Hsp70 (P) = 2 total. @@ -693,12 +738,14 @@ test "goa_filter_by_evidence_iea" { assert_eq(hits.length(), 2) } +///| test "goa_filter_by_evidence_no_match" { let db = @src.goa_sample_database() let hits = @src.goa_filter_by_evidence(db, "NONEXISTENT") assert_eq(hits.length(), 0) } +///| test "goa_filter_by_taxon_human" { let db = @src.goa_sample_database() // taxon:9606 records: PROT1 (x3), TP53 (x2), RPL5 = 6 total. @@ -706,6 +753,7 @@ test "goa_filter_by_taxon_human" { assert_eq(hits.length(), 6) } +///| test "goa_filter_by_taxon_yeast" { let db = @src.goa_sample_database() // taxon:4932 records: YFG1 (x2) = 2 total. @@ -713,6 +761,7 @@ test "goa_filter_by_taxon_yeast" { assert_eq(hits.length(), 2) } +///| test "goa_filter_by_taxon_fly" { let db = @src.goa_sample_database() // taxon:7227 records: Hsp70 (x2) = 2 total. @@ -720,12 +769,14 @@ test "goa_filter_by_taxon_fly" { assert_eq(hits.length(), 2) } +///| test "goa_filter_by_taxon_no_match" { let db = @src.goa_sample_database() let hits = @src.goa_filter_by_taxon(db, "0000000") assert_eq(hits.length(), 0) } +///| test "goa_filter_by_db_object_id" { let db = @src.goa_sample_database() // Q12345 (PROT1) has 3 records (F, P, C). @@ -737,6 +788,7 @@ test "goa_filter_by_db_object_id" { } } +///| test "goa_filter_by_db_object_id_multiple" { let db = @src.goa_sample_database() // P04637 (TP53) has 2 records (F, P). @@ -747,6 +799,7 @@ test "goa_filter_by_db_object_id_multiple" { } } +///| test "goa_filter_by_db_object_id_no_match" { let db = @src.goa_sample_database() let hits = @src.goa_filter_by_db_object_id(db, "ZZZZZZ") @@ -757,6 +810,7 @@ test "goa_filter_by_db_object_id_no_match" { // Unique value extraction // --------------------------------------------------------------------------- +///| test "goa_unique_go_ids" { let db = @src.goa_sample_database() // Every record in the sample database has a distinct GO ID. @@ -766,6 +820,7 @@ test "goa_unique_go_ids" { assert_eq(ids[0], "GO:0003674") } +///| test "goa_unique_go_ids_dedup" { // Build a database with duplicate GO IDs to test deduplication. let rec = @src.GafRecord::new( @@ -787,14 +842,17 @@ test "goa_unique_go_ids_dedup" { annotation_extension="", gene_product_form_id="", ) - let content = @src.goa_record_to_gaf_line(rec) + "\n" + - @src.goa_record_to_gaf_line(rec) + "\n" + let content = @src.goa_record_to_gaf_line(rec) + + "\n" + + @src.goa_record_to_gaf_line(rec) + + "\n" let db = @src.goa_parse(content) let ids = @src.goa_unique_go_ids(db) assert_eq(ids.length(), 1) assert_eq(ids[0], "GO:0003674") } +///| test "goa_unique_evidence_codes" { let db = @src.goa_sample_database() // Sample DB uses IDA, EXP, IEA, ISS, IPI = 5 distinct evidence codes. @@ -802,6 +860,7 @@ test "goa_unique_evidence_codes" { assert_eq(codes.length(), 5) } +///| test "goa_unique_taxon_ids" { let db = @src.goa_sample_database() // Sample DB uses 9606, 4932, 7227 = 3 distinct taxon IDs. @@ -816,6 +875,7 @@ test "goa_unique_taxon_ids" { // Count functions // --------------------------------------------------------------------------- +///| test "goa_count_by_aspect" { let db = @src.goa_sample_database() let counts = @src.goa_count_by_aspect(db) @@ -827,6 +887,7 @@ test "goa_count_by_aspect" { assert_eq(counts.get("?"), None) } +///| test "goa_count_by_aspect_empty_db" { let db = @src.GoaDatabase::new() let counts = @src.goa_count_by_aspect(db) @@ -835,6 +896,7 @@ test "goa_count_by_aspect_empty_db" { assert_eq(counts.get("C"), None) } +///| test "goa_count_by_evidence" { let db = @src.goa_sample_database() let counts = @src.goa_count_by_evidence(db) @@ -848,6 +910,7 @@ test "goa_count_by_evidence" { assert_eq(counts.get("TAS"), None) } +///| test "goa_count_by_evidence_empty_db" { let db = @src.GoaDatabase::new() let counts = @src.goa_count_by_evidence(db) @@ -858,6 +921,7 @@ test "goa_count_by_evidence_empty_db" { // Summary generation // --------------------------------------------------------------------------- +///| test "goa_to_summary_has_basic_fields" { let db = @src.goa_sample_database() let s = @src.goa_to_summary(db) @@ -867,6 +931,7 @@ test "goa_to_summary_has_basic_fields" { assert_true(s.contains("Created by: UniProt")) } +///| test "goa_to_summary_has_aspect_section" { let db = @src.goa_sample_database() let s = @src.goa_to_summary(db) @@ -876,6 +941,7 @@ test "goa_to_summary_has_aspect_section" { assert_true(s.contains("Cellular Component")) } +///| test "goa_to_summary_has_evidence_section" { let db = @src.goa_sample_database() let s = @src.goa_to_summary(db) @@ -887,6 +953,7 @@ test "goa_to_summary_has_evidence_section" { assert_true(s.contains("IPI")) } +///| test "goa_to_summary_has_unique_counts" { let db = @src.goa_sample_database() let s = @src.goa_to_summary(db) @@ -895,6 +962,7 @@ test "goa_to_summary_has_unique_counts" { assert_true(s.contains("Unique taxon IDs: 3")) } +///| test "goa_to_summary_empty_db" { let db = @src.GoaDatabase::new() let s = @src.goa_to_summary(db) @@ -906,6 +974,7 @@ test "goa_to_summary_empty_db" { // Writing functions // --------------------------------------------------------------------------- +///| test "goa_record_to_gaf_line_roundtrip" { let r = @src.GafRecord::new( db="UniProtKB", @@ -949,6 +1018,7 @@ test "goa_record_to_gaf_line_roundtrip" { assert_eq(fields[16].to_string(), "") } +///| test "goa_record_to_gaf_line_parse_roundtrip" { // Serializing and re-parsing should produce an equivalent record. let r = @src.GafRecord::new( @@ -989,6 +1059,7 @@ test "goa_record_to_gaf_line_parse_roundtrip" { } } +///| test "goa_to_gaf_includes_header" { let db = @src.goa_sample_database() let text = @src.goa_to_gaf(db) @@ -996,6 +1067,7 @@ test "goa_to_gaf_includes_header" { assert_true(text.contains("!generated-by: UniProt")) } +///| test "goa_to_gaf_includes_all_records" { let db = @src.goa_sample_database() let text = @src.goa_to_gaf(db) @@ -1012,6 +1084,7 @@ test "goa_to_gaf_includes_all_records" { assert_true(text.contains("GO:0003735")) } +///| test "goa_to_gaf_roundtrip" { // Serializing the sample database and re-parsing should preserve its // record count and metadata. @@ -1023,6 +1096,7 @@ test "goa_to_gaf_roundtrip" { assert_eq(db2.created_by(), db.created_by()) } +///| test "goa_to_gaf_empty_db" { let db = @src.GoaDatabase::new() let text = @src.goa_to_gaf(db) @@ -1036,17 +1110,20 @@ test "goa_to_gaf_empty_db" { // Sample database validation // --------------------------------------------------------------------------- +///| test "goa_sample_database_has_10_records" { let db = @src.goa_sample_database() assert_eq(db.n_records(), 10) } +///| test "goa_sample_database_metadata" { let db = @src.goa_sample_database() assert_eq(db.version(), "2.2") assert_eq(db.created_by(), "UniProt") } +///| test "goa_sample_database_has_3_aspects" { let db = @src.goa_sample_database() let counts = @src.goa_count_by_aspect(db) @@ -1055,6 +1132,7 @@ test "goa_sample_database_has_3_aspects" { assert_eq(counts.get("C"), Some(3)) } +///| test "goa_sample_database_has_3_taxa" { let db = @src.goa_sample_database() let taxa = @src.goa_unique_taxon_ids(db) @@ -1064,6 +1142,7 @@ test "goa_sample_database_has_3_taxa" { assert_true(taxa.contains("7227")) } +///| test "goa_sample_database_has_5_evidence_codes" { let db = @src.goa_sample_database() let codes = @src.goa_unique_evidence_codes(db) @@ -1075,6 +1154,7 @@ test "goa_sample_database_has_5_evidence_codes" { assert_true(codes.contains("IPI")) } +///| test "goa_sample_database_first_record" { let db = @src.goa_sample_database() let rec = db.records()[0] @@ -1087,6 +1167,7 @@ test "goa_sample_database_first_record" { assert_eq(rec.taxon(), "taxon:9606|taxon:9606") } +///| test "goa_sample_database_last_record" { let db = @src.goa_sample_database() let rec = db.records()[9] @@ -1097,6 +1178,7 @@ test "goa_sample_database_last_record" { assert_eq(rec.aspect(), "F") } +///| test "goa_sample_database_all_uniprot_db" { let db = @src.goa_sample_database() for r in db.records() { @@ -1104,6 +1186,7 @@ test "goa_sample_database_all_uniprot_db" { } } +///| test "goa_sample_database_unique_go_ids_count" { let db = @src.goa_sample_database() // Each of the 10 records has a distinct GO ID. @@ -1115,6 +1198,7 @@ test "goa_sample_database_unique_go_ids_count" { // Edge cases // --------------------------------------------------------------------------- +///| test "goa_parse_line_single_column" { // A single-column line should be padded to 17 empty fields and parsed. let r = @src.goa_parse_line("UniProtKB") @@ -1130,6 +1214,7 @@ test "goa_parse_line_single_column" { } } +///| test "goa_parse_line_extra_columns_kept_in_field" { // A line with more than 17 columns: the parser splits on all tabs and uses // only the first 17 fields; extra columns are silently ignored. @@ -1146,6 +1231,7 @@ test "goa_parse_line_extra_columns_kept_in_field" { } } +///| test "goa_parse_line_with_trailing_newline" { // Trailing whitespace/newlines are trimmed before parsing. let line = "UniProtKB\tQ12345\tPROT1\tenables\tGO:0003674\tPMID:12345\tIDA\tGO:0005515\tF\tProtein 1\tP1\tprotein\ttaxon:9606\t20210115\tUniProt\t\t\n" @@ -1160,6 +1246,7 @@ test "goa_parse_line_with_trailing_newline" { } } +///| test "goa_parse_only_comment_lines" { // A line starting with "!" is treated as a header/comment regardless of // whether it has a colon, and never produces a data record. @@ -1172,6 +1259,7 @@ test "goa_parse_only_comment_lines" { assert_eq(db.created_by(), "UniProt") } +///| test "goa_parse_mixed_valid_and_invalid_lines" { let content = "!gaf-version: 2.2\n" + "!generated-by: UniProt\n" + @@ -1188,15 +1276,20 @@ test "goa_parse_mixed_valid_and_invalid_lines" { assert_eq(db.created_by(), "UniProt") } +///| test "goa_filter_on_empty_database" { let db = @src.GoaDatabase::new() assert_eq(@src.goa_filter_by_go_id(db, "GO:0003674").length(), 0) - assert_eq(@src.goa_filter_by_aspect(db, @src.GafAspect::from_string("F")).length(), 0) + assert_eq( + @src.goa_filter_by_aspect(db, @src.GafAspect::from_string("F")).length(), + 0, + ) assert_eq(@src.goa_filter_by_evidence(db, "IDA").length(), 0) assert_eq(@src.goa_filter_by_taxon(db, "9606").length(), 0) assert_eq(@src.goa_filter_by_db_object_id(db, "Q12345").length(), 0) } +///| test "goa_unique_on_empty_database" { let db = @src.GoaDatabase::new() assert_eq(@src.goa_unique_go_ids(db).length(), 0) diff --git a/test/moonbit/gosemsim_test.mbt b/test/moonbit/gosemsim_test.mbt index 3487d49a..92b611d5 100644 --- a/test/moonbit/gosemsim_test.mbt +++ b/test/moonbit/gosemsim_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for GOSemSim GO semantic similarity module. - test "gosemsim_example_graph" { let g = @src.gosemsim_example_graph() assert_true(g.root_id == "GO:0008150") @@ -10,81 +9,152 @@ test "gosemsim_example_graph" { } } +///| test "gosemsim_term_self_similarity" { let g = @src.gosemsim_example_graph() // A term compared to itself should have maximal similarity. - let resnik = @src.gosemsim_term_sim(g, "GO:0006810", "GO:0006810", @src.resnik_measure()) + let resnik = @src.gosemsim_term_sim( + g, + "GO:0006810", + "GO:0006810", + @src.resnik_measure(), + ) assert_true(resnik > 0.0) - let lin = @src.gosemsim_term_sim(g, "GO:0006810", "GO:0006810", @src.lin_measure()) + let lin = @src.gosemsim_term_sim( + g, + "GO:0006810", + "GO:0006810", + @src.lin_measure(), + ) assert_true(lin > 0.99 && lin <= 1.0 + 1.0e-6) } +///| test "gosemsim_resnik_similarity" { let g = @src.gosemsim_example_graph() // Parent-child should have high similarity - let sim = @src.gosemsim_term_sim(g, "GO:0006810", "GO:0009987", @src.resnik_measure()) + let sim = @src.gosemsim_term_sim( + g, + "GO:0006810", + "GO:0009987", + @src.resnik_measure(), + ) assert_true(sim > 0.0) } +///| test "gosemsim_lin_similarity" { let g = @src.gosemsim_example_graph() - let sim = @src.gosemsim_term_sim(g, "GO:0006810", "GO:0007165", @src.lin_measure()) + let sim = @src.gosemsim_term_sim( + g, + "GO:0006810", + "GO:0007165", + @src.lin_measure(), + ) assert_true(sim >= 0.0 && sim <= 1.0) } +///| test "gosemsim_rel_similarity" { let g = @src.gosemsim_example_graph() - let sim = @src.gosemsim_term_sim(g, "GO:0006810", "GO:0007165", @src.rel_measure()) + let sim = @src.gosemsim_term_sim( + g, + "GO:0006810", + "GO:0007165", + @src.rel_measure(), + ) assert_true(sim >= 0.0 && sim <= 1.0) } +///| test "gosemsim_jiang_similarity" { let g = @src.gosemsim_example_graph() - let sim = @src.gosemsim_term_sim(g, "GO:0006810", "GO:0007165", @src.jiang_measure()) + let sim = @src.gosemsim_term_sim( + g, + "GO:0006810", + "GO:0007165", + @src.jiang_measure(), + ) assert_true(sim >= 0.0) } +///| test "gosemsim_wang_similarity" { let g = @src.gosemsim_example_graph() - let sim = @src.gosemsim_term_sim(g, "GO:0006810", "GO:0007165", @src.wang_measure()) + let sim = @src.gosemsim_term_sim( + g, + "GO:0006810", + "GO:0007165", + @src.wang_measure(), + ) assert_true(sim >= 0.0 && sim <= 1.0) } +///| test "gosemsim_missing_term" { let g = @src.gosemsim_example_graph() - let sim = @src.gosemsim_term_sim(g, "GO:9999999", "GO:0006810", @src.resnik_measure()) + let sim = @src.gosemsim_term_sim( + g, + "GO:9999999", + "GO:0006810", + @src.resnik_measure(), + ) assert_true(sim == 0.0) } +///| test "gosemsim_gen_sim_max" { let g = @src.gosemsim_example_graph() let go1 = ["GO:0006810", "GO:0007165"] let go2 = ["GO:0006810", "GO:0009987"] - let sim = @src.gosemsim_gen_sim(g, go1, go2, @src.resnik_measure(), combine = "max") + let sim = @src.gosemsim_gen_sim( + g, + go1, + go2, + @src.resnik_measure(), + combine="max", + ) assert_true(sim > 0.0) } +///| test "gosemsim_gen_sim_avg" { let g = @src.gosemsim_example_graph() let go1 = ["GO:0006810", "GO:0007165"] let go2 = ["GO:0006810", "GO:0009987"] - let sim = @src.gosemsim_gen_sim(g, go1, go2, @src.lin_measure(), combine = "avg") + let sim = @src.gosemsim_gen_sim( + g, + go1, + go2, + @src.lin_measure(), + combine="avg", + ) assert_true(sim >= 0.0 && sim <= 1.0) } +///| test "gosemsim_gen_sim_rcmax" { let g = @src.gosemsim_example_graph() let go1 = ["GO:0006810", "GO:0007165"] let go2 = ["GO:0006810", "GO:0009987"] - let sim = @src.gosemsim_gen_sim(g, go1, go2, @src.rel_measure(), combine = "rcmax") + let sim = @src.gosemsim_gen_sim( + g, + go1, + go2, + @src.rel_measure(), + combine="rcmax", + ) assert_true(sim >= 0.0 && sim <= 1.0) } +///| test "gosemsim_graph_operations" { let g = @src.GOGraph::new() let g1 = g.add_root("TEST:001") - let g2 = g1.add_term(@src.GOTermNode::new("TEST:001", ic = 0.0)) - let g3 = g2.add_term(@src.GOTermNode::new("TEST:002", ic = 0.5, parents = ["TEST:001"])) + let g2 = g1.add_term(@src.GOTermNode::new("TEST:001", ic=0.0)) + let g3 = g2.add_term( + @src.GOTermNode::new("TEST:002", ic=0.5, parents=["TEST:001"]), + ) match g3.get_term("TEST:002") { Some(term) => assert_true(term.ic == 0.5) None => assert_true(false) diff --git a/test/moonbit/graphics_test.mbt b/test/moonbit/graphics_test.mbt index 30cd2487..a1829d7b 100644 --- a/test/moonbit/graphics_test.mbt +++ b/test/moonbit/graphics_test.mbt @@ -1,35 +1,39 @@ ///| /// Tests for Graphics module. - test "SeqLogo creation" { let seqs = ["ATGC"] let logo = @src.SeqLogo::new(seqs) assert_eq(logo.sequences.length(), 1) } +///| test "LogoColumn creation" { let col = @src.LogoColumn::new(1) assert_eq(col.position, 1) } +///| test "AlignmentPlot creation" { let seqs = [("Seq1", "ATGC")] let plot = @src.AlignmentPlot::new(seqs) assert_eq(plot.sequences.length(), 1) } +///| test "FeaturePlot creation" { let features = [("Gene", 0, 10, "gene", "+")] let plot = @src.FeaturePlot::new(features, 100) assert_eq(plot.features.length(), 1) } +///| test "seqlogo_calculate_columns" { let seqs = ["ATGC", "ATGC"] let columns = @src.seqlogo_calculate_columns(seqs) assert_eq(columns.length(), 4) } +///| test "seqlogo_generate_ascii" { let seqs = ["ATGC", "ATGC", "ATGC"] let logo = @src.SeqLogo::new(seqs) @@ -37,6 +41,7 @@ test "seqlogo_generate_ascii" { assert_true(output.length() > 0) } +///| test "alignment_plot_generate_ascii" { let seqs = [("Human", "ATGC"), ("Mouse", "ATGC")] let plot = @src.AlignmentPlot::new(seqs) @@ -44,6 +49,7 @@ test "alignment_plot_generate_ascii" { assert_true(output.length() > 0) } +///| test "feature_plot_generate_ascii" { let features = [("Gene", 0, 10, "gene", "+")] let plot = @src.FeaturePlot::new(features, 50) @@ -51,27 +57,32 @@ test "feature_plot_generate_ascii" { assert_true(output.length() > 0) } +///| test "create_example_seqlogo" { let logo = @src.create_example_seqlogo() assert_eq(logo.sequences.length(), 10) } +///| test "create_example_alignment_plot" { let plot = @src.create_example_alignment_plot() assert_eq(plot.sequences.length(), 4) } +///| test "create_example_feature_plot" { let plot = @src.create_example_feature_plot() assert_eq(plot.features.length(), 7) } +///| test "get_default_colors" { let colors = @src.get_default_colors() assert_true(colors.contains("A")) } +///| test "get_feature_colors" { let colors = @src.get_feature_colors() assert_true(colors.contains("exon")) -} \ No newline at end of file +} diff --git a/test/moonbit/gsea_base_test.mbt b/test/moonbit/gsea_base_test.mbt index f49840ab..1e5dad4a 100644 --- a/test/moonbit/gsea_base_test.mbt +++ b/test/moonbit/gsea_base_test.mbt @@ -28,12 +28,7 @@ test "gmt_gene_set_with_annotation" { let genes = ["G1"] let ct = @src.GeneSetCollectionType::from_string("canonical") let gs = @src.GmtGeneSet::with_annotation( - "g", - "desc", - genes, - ct, - "human", - "GS123", + "g", "desc", genes, ct, "human", "GS123", ) assert_eq(gs.name, "g") assert_eq(gs.organism, "human") diff --git a/test/moonbit/gsva_test.mbt b/test/moonbit/gsva_test.mbt index 074a1ddc..5df7de2b 100644 --- a/test/moonbit/gsva_test.mbt +++ b/test/moonbit/gsva_test.mbt @@ -192,7 +192,9 @@ test "gsva_survival_analysis" { let gene_sets = @src.gsva_create_example_gene_sets() let params = @src.GSVAParams::new() let scores = @src.gsva_run(data, gene_sets, params) - let survival_time = [10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0] + let survival_time = [ + 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0, + ] let event = [1, 1, 1, 0, 0, 1, 1, 0, 1, 0] let surv = @src.gsva_survival_analysis(scores, survival_time, event) assert_eq(surv.length(), 5) @@ -204,7 +206,9 @@ test "gsva_survival_report" { let gene_sets = @src.gsva_create_example_gene_sets() let params = @src.GSVAParams::new() let scores = @src.gsva_run(data, gene_sets, params) - let survival_time = [10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0] + let survival_time = [ + 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0, + ] let event = [1, 1, 1, 0, 0, 1, 1, 0, 1, 0] let report = @src.gsva_survival_report(scores, survival_time, event) assert_true(report.length() > 0) diff --git a/test/moonbit/gviz_test.mbt b/test/moonbit/gviz_test.mbt index 0bfc0dc6..dfe06745 100644 --- a/test/moonbit/gviz_test.mbt +++ b/test/moonbit/gviz_test.mbt @@ -1,8 +1,15 @@ ///| /// Test file for Gviz module. - test "gviz_feature_creation" { - let f = @src.gviz_feature("g1", "chr1", 100, 200, @src.track_strand_forward(), "exon", "GeneA") + let f = @src.gviz_feature( + "g1", + "chr1", + 100, + 200, + @src.track_strand_forward(), + "exon", + "GeneA", + ) assert_eq(f.feature_id, "g1") assert_eq(f.chromosome, "chr1") assert_eq(f.start, 100) @@ -11,8 +18,15 @@ test "gviz_feature_creation" { assert_eq(f.label, "GeneA") } +///| test "gviz_track_creation" { - let t = @src.gviz_track("genes", @src.track_type_gene_region(), "chr1", 1000, 5000) + let t = @src.gviz_track( + "genes", + @src.track_type_gene_region(), + "chr1", + 1000, + 5000, + ) assert_eq(t.track_name, "genes") assert_eq(t.chromosome, "chr1") assert_eq(t.start, 1000) @@ -20,43 +34,129 @@ test "gviz_track_creation" { assert_eq(t.get_n_features(), 0) } +///| test "gviz_track_add_feature" { - let t = @src.gviz_track("genes", @src.track_type_gene_region(), "chr1", 1000, 5000) - t.add_feature(@src.gviz_feature("g1", "chr1", 1200, 1800, @src.track_strand_forward(), "exon", "GeneA")) - t.add_feature(@src.gviz_feature("g2", "chr1", 2000, 3500, @src.track_strand_reverse(), "exon", "GeneB")) + let t = @src.gviz_track( + "genes", + @src.track_type_gene_region(), + "chr1", + 1000, + 5000, + ) + t.add_feature( + @src.gviz_feature( + "g1", + "chr1", + 1200, + 1800, + @src.track_strand_forward(), + "exon", + "GeneA", + ), + ) + t.add_feature( + @src.gviz_feature( + "g2", + "chr1", + 2000, + 3500, + @src.track_strand_reverse(), + "exon", + "GeneB", + ), + ) assert_eq(t.get_n_features(), 2) } +///| test "gviz_track_add_data_point" { - let t = @src.gviz_track("coverage", @src.track_type_data(), "chr1", 1000, 5000) + let t = @src.gviz_track( + "coverage", + @src.track_type_data(), + "chr1", + 1000, + 5000, + ) t.add_data_point(1000, 5.0) t.add_data_point(2000, 10.0) t.add_data_point(3000, 15.0) assert_eq(t.get_n_data_points(), 3) } +///| test "gviz_track_set_color" { - let t = @src.gviz_track("track1", @src.track_type_annotation(), "chr1", 1000, 5000) + let t = @src.gviz_track( + "track1", + @src.track_type_annotation(), + "chr1", + 1000, + 5000, + ) t.set_color("red") assert_eq(t.color, "red") } +///| test "gviz_track_set_label" { - let t = @src.gviz_track("track1", @src.track_type_annotation(), "chr1", 1000, 5000) + let t = @src.gviz_track( + "track1", + @src.track_type_annotation(), + "chr1", + 1000, + 5000, + ) t.set_label("My Track") assert_eq(t.display_label, "My Track") } +///| test "gviz_track_get_features_in_region" { - let t = @src.gviz_track("genes", @src.track_type_gene_region(), "chr1", 1000, 5000) - t.add_feature(@src.gviz_feature("g1", "chr1", 1200, 1800, @src.track_strand_forward(), "exon", "A")) - t.add_feature(@src.gviz_feature("g2", "chr1", 2000, 3500, @src.track_strand_reverse(), "exon", "B")) - t.add_feature(@src.gviz_feature("g3", "chr1", 4000, 4500, @src.track_strand_forward(), "exon", "C")) + let t = @src.gviz_track( + "genes", + @src.track_type_gene_region(), + "chr1", + 1000, + 5000, + ) + t.add_feature( + @src.gviz_feature( + "g1", + "chr1", + 1200, + 1800, + @src.track_strand_forward(), + "exon", + "A", + ), + ) + t.add_feature( + @src.gviz_feature( + "g2", + "chr1", + 2000, + 3500, + @src.track_strand_reverse(), + "exon", + "B", + ), + ) + t.add_feature( + @src.gviz_feature( + "g3", + "chr1", + 4000, + 4500, + @src.track_strand_forward(), + "exon", + "C", + ), + ) let in_region = t.get_features_in_region(1500, 3000) assert_eq(in_region.length(), 2) // g1 (overlaps) and g2 } +///| test "gviz_track_get_data_in_region" { let t = @src.gviz_track("data", @src.track_type_data(), "chr1", 1000, 5000) t.add_data_point(1000, 5.0) @@ -68,6 +168,7 @@ test "gviz_track_get_data_in_region" { assert_eq(data.length(), 2) // 2000 and 3000 } +///| test "gviz_region_creation" { let r = @src.gviz_region("chr1", 1000, 5000) assert_eq(r.chromosome, "chr1") @@ -75,6 +176,7 @@ test "gviz_region_creation" { assert_eq(r.end_, 5000) } +///| test "gviz_plot_creation" { let r = @src.gviz_region("chr1", 1000, 5000) let p = @src.gviz_plot(r, title="Test Plot", width=80, height=25) @@ -82,14 +184,22 @@ test "gviz_plot_creation" { assert_eq(p.get_region().chromosome, "chr1") } +///| test "gviz_plot_add_track" { let r = @src.gviz_region("chr1", 1000, 5000) let p = @src.gviz_plot(r, title="Test") - let t = @src.gviz_track("track1", @src.track_type_annotation(), "chr1", 1000, 5000) + let t = @src.gviz_track( + "track1", + @src.track_type_annotation(), + "chr1", + 1000, + 5000, + ) p.add_track(t) assert_eq(p.get_n_tracks(), 1) } +///| test "gviz_plot_to_ascii" { let p = @src.gviz_sample_plot() let ascii = p.to_ascii() @@ -97,6 +207,7 @@ test "gviz_plot_to_ascii" { assert_true(ascii.contains("GeneRegionTrack")) } +///| test "gviz_plot_summary" { let p = @src.gviz_sample_plot() let s = p.summary() @@ -104,6 +215,7 @@ test "gviz_plot_summary" { assert_true(s.contains("chr1")) } +///| test "gviz_track_type_to_string" { assert_eq(@src.track_type_annotation().to_string(), "AnnotationTrack") assert_eq(@src.track_type_gene_region().to_string(), "GeneRegionTrack") @@ -113,12 +225,14 @@ test "gviz_track_type_to_string" { assert_eq(@src.track_type_sequence().to_string(), "SequenceTrack") } +///| test "gviz_strand_to_string" { assert_eq(@src.track_strand_forward().to_string(), "+") assert_eq(@src.track_strand_reverse().to_string(), "-") assert_eq(@src.track_strand_unstranded().to_string(), "*") } +///| test "gviz_sample_plot" { let p = @src.gviz_sample_plot() assert_true(p.get_n_tracks() >= 3) diff --git a/test/moonbit/harmony_test.mbt b/test/moonbit/harmony_test.mbt index 586d5c68..79676d9e 100644 --- a/test/moonbit/harmony_test.mbt +++ b/test/moonbit/harmony_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Harmony batch correction module. - test "harmony_create_example" { let data = @src.harmony_create_example(100, 2, 5) assert_true(data.embeddings.length() == 100) @@ -8,6 +7,7 @@ test "harmony_create_example" { assert_true(data.embeddings[0].length() == 5) } +///| test "harmony_params_default" { let params = @src.HarmonyParams::new() assert_true(params.n_clusters == 20) @@ -16,18 +16,17 @@ test "harmony_params_default" { assert_true(params.lambda > 0.0) } +///| test "harmony_run_basic" { let data = @src.harmony_create_example(50, 2, 3) - let params = @src.HarmonyParams::create( - n_clusters = 3, - max_iterations = 10, - ) + let params = @src.HarmonyParams::create(n_clusters=3, max_iterations=10) let result = @src.harmony_run(data, params) assert_true(result.corrected.length() == 50) assert_true(result.membership.length() == 50) assert_true(result.centroids.length() == 3) } +///| test "harmony_single_batch" { // Single batch should remain largely unchanged let embeddings : Array[Array[Double]] = Array::new() @@ -41,26 +40,25 @@ test "harmony_single_batch" { i = i + 1 } let data = @src.HarmonyData::new(embeddings, batch_labels, cell_ids) - let params = @src.HarmonyParams::create( - n_clusters = 2, - max_iterations = 5, - ) + let params = @src.HarmonyParams::create(n_clusters=2, max_iterations=5) let result = @src.harmony_run(data, params) assert_true(result.corrected.length() == 20) } +///| test "harmony_convergence" { let data = @src.harmony_create_example(80, 3, 4) let params = @src.HarmonyParams::create( - n_clusters = 4, - max_iterations = 30, - tolerance = 0.001, + n_clusters=4, + max_iterations=30, + tolerance=0.001, ) let result = @src.harmony_run(data, params) assert_true(result.n_iterations > 0) assert_true(result.n_iterations <= 30) } +///| test "harmony_batch_alignment" { // Two batches with different means should be aligned let embeddings : Array[Array[Double]] = Array::new() @@ -70,25 +68,21 @@ test "harmony_batch_alignment" { while i < 40 { let batch_idx = if i < 20 { 0 } else { 1 } let offset = if batch_idx == 0 { 0.0 } else { 5.0 } - embeddings.push([offset + (i.to_double() * 0.1), offset + 1.0, offset + 2.0]) + embeddings.push([offset + i.to_double() * 0.1, offset + 1.0, offset + 2.0]) batch_labels.push("batch_" + batch_idx.to_string()) cell_ids.push("cell_" + i.to_string()) i = i + 1 } let data = @src.HarmonyData::new(embeddings, batch_labels, cell_ids) - let params = @src.HarmonyParams::create( - n_clusters = 5, - max_iterations = 30, - ) + let params = @src.HarmonyParams::create(n_clusters=5, max_iterations=30) let result = @src.harmony_run(data, params) assert_true(result.corrected.length() == 40) } +///| test "harmony_empty_data" { let data = @src.HarmonyData::new([], [], []) - let params = @src.HarmonyParams::create( - n_clusters = 2, - ) + let params = @src.HarmonyParams::create(n_clusters=2) let result = @src.harmony_run(data, params) assert_true(result.corrected.length() == 0) } diff --git a/test/moonbit/hicdc_test.mbt b/test/moonbit/hicdc_test.mbt index 2195d5b7..1fa7658e 100644 --- a/test/moonbit/hicdc_test.mbt +++ b/test/moonbit/hicdc_test.mbt @@ -74,7 +74,9 @@ test "hc_sample_data_has_loops" { ///| test "hc_fit_background_returns_params" { let contacts = @src.hicdc_sample_data() - let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background(contacts) + let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background( + contacts, + ) // Parameters should be finite numbers. assert_true(!intercept.is_nan()) assert_true(!beta_dist.is_nan()) @@ -86,8 +88,12 @@ test "hc_fit_background_returns_params" { ///| test "hc_predict_expected" { let contacts = @src.hicdc_sample_data() - let (intercept, beta_dist, beta_gc, beta_map, _) = @src.hicdc_fit_background(contacts) - let expected = @src.hicdc_predict_expected(contacts, intercept, beta_dist, beta_gc, beta_map) + let (intercept, beta_dist, beta_gc, beta_map, _) = @src.hicdc_fit_background( + contacts, + ) + let expected = @src.hicdc_predict_expected( + contacts, intercept, beta_dist, beta_gc, beta_map, + ) assert_eq(expected.length(), contacts.length()) // Expected counts should be positive. for e in expected { @@ -98,11 +104,19 @@ test "hc_predict_expected" { ///| test "hc_expected_decreases_with_distance" { let contacts = @src.hicdc_sample_data() - let (intercept, beta_dist, beta_gc, beta_map, _) = @src.hicdc_fit_background(contacts) + let (intercept, beta_dist, beta_gc, beta_map, _) = @src.hicdc_fit_background( + contacts, + ) // Predict expected counts for near and far contacts. let c1 = @src.HiCContact::new("chr1", 0, 1, 10, 1) let c2 = @src.HiCContact::new("chr1", 0, 10, 10, 1) - let exp = @src.hicdc_predict_expected([c1, c2], intercept, beta_dist, beta_gc, beta_map) + let exp = @src.hicdc_predict_expected( + [c1, c2], + intercept, + beta_dist, + beta_gc, + beta_map, + ) // Both expected counts should be positive. assert_true(exp[0] > 0.0) assert_true(exp[1] > 0.0) @@ -115,9 +129,11 @@ test "hc_expected_decreases_with_distance" { ///| test "hc_test_significance_returns_results" { let contacts = @src.hicdc_sample_data() - let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background(contacts) + let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background( + contacts, + ) let results = @src.hicdc_test_significance( - contacts, intercept, beta_dist, beta_gc, beta_map, dispersion + contacts, intercept, beta_dist, beta_gc, beta_map, dispersion, ) assert_eq(results.length(), contacts.length()) // Check that p-values and FDR are valid. @@ -134,9 +150,11 @@ test "hc_test_significance_returns_results" { ///| test "hc_significant_loops_detected" { let contacts = @src.hicdc_sample_data() - let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background(contacts) + let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background( + contacts, + ) let results = @src.hicdc_test_significance( - contacts, intercept, beta_dist, beta_gc, beta_map, dispersion + contacts, intercept, beta_dist, beta_gc, beta_map, dispersion, ) let marked = @src.hicdc_mark_significant(results, 0.3) // At least some contacts should be significant with loose threshold. @@ -152,9 +170,11 @@ test "hc_significant_loops_detected" { ///| test "hc_fdr_monotonic" { let contacts = @src.hicdc_sample_data() - let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background(contacts) + let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background( + contacts, + ) let results = @src.hicdc_test_significance( - contacts, intercept, beta_dist, beta_gc, beta_map, dispersion + contacts, intercept, beta_dist, beta_gc, beta_map, dispersion, ) // FDR should be >= p_value for each result (BH inflates). for r in results { @@ -284,7 +304,10 @@ test "hc_empty_contacts" { ///| test "hc_single_contact" { let c = @src.HiCContact::new("chr1", 0, 1, 50, 1) - let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background([c]) + let (intercept, beta_dist, beta_gc, beta_map, dispersion) = @src.hicdc_fit_background([ + c, + ], + ) assert_true(!intercept.is_nan()) assert_true(dispersion > 0.0) } diff --git a/test/moonbit/hilbertcurve_test.mbt b/test/moonbit/hilbertcurve_test.mbt index 824b226d..c6dc61c6 100644 --- a/test/moonbit/hilbertcurve_test.mbt +++ b/test/moonbit/hilbertcurve_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for HilbertCurve module. - test "HilbertCurve creation" { let hc = @src.HilbertCurve::new(4, 2) assert_eq(hc.levels, 4) @@ -8,6 +7,7 @@ test "HilbertCurve creation" { assert_eq(hc.max_coordinate, 15) } +///| test "hilbert_encode_decode_roundtrip" { let hc = @src.HilbertCurve::new(3, 2) let coords = [3, 5] @@ -16,6 +16,7 @@ test "hilbert_encode_decode_roundtrip" { assert_eq(decoded.length(), 2) } +///| test "hilbert_distance" { let hc = @src.HilbertCurve::new(3, 2) let coord1 = [1, 2] @@ -24,17 +25,20 @@ test "hilbert_distance" { assert_true(dist >= 0) } +///| test "hilbert_point_to_segment" { let hc = @src.HilbertCurve::new(2, 2) let segments = @src.hilbert_point_to_segment(hc, 0, 3) assert_eq(segments.length(), 4) } +///| test "hilbert_linearize_genome" { let segments = @src.hilbert_linearize_genome(10, 3) assert_eq(segments.length(), 10) } +///| test "hilbert_map_to_grid" { let hc = @src.HilbertCurve::new(2, 2) let values = [1.0, 2.0, 3.0, 4.0] diff --git a/test/moonbit/hmisc_test.mbt b/test/moonbit/hmisc_test.mbt index 5f3d2b39..f6fa587b 100644 --- a/test/moonbit/hmisc_test.mbt +++ b/test/moonbit/hmisc_test.mbt @@ -16,6 +16,7 @@ test "hmisc_describe basic valid data" { assert_true(result.median > 2.9 && result.median < 3.1) } +///| test "hmisc_describe with NaN values" { let data = [1.0, @double.not_a_number, 3.0, @double.not_a_number, 5.0] let result = @src.hmisc_describe(data) @@ -26,6 +27,7 @@ test "hmisc_describe with NaN values" { assert_eq(result.max, 5.0) } +///| test "hmisc_describe empty data" { let data : Array[Double] = Array::new() let result = @src.hmisc_describe(data) @@ -37,6 +39,7 @@ test "hmisc_describe empty data" { assert_eq(result.max, 0.0) } +///| test "hmisc_describe all NaN data" { let data = [@double.not_a_number, @double.not_a_number, @double.not_a_number] let result = @src.hmisc_describe(data) @@ -46,6 +49,7 @@ test "hmisc_describe all NaN data" { assert_eq(result.sd, 0.0) } +///| test "hmisc_describe single value" { let data = [42.0] let result = @src.hmisc_describe(data) @@ -56,12 +60,14 @@ test "hmisc_describe single value" { assert_eq(result.max, 42.0) } +///| test "hmisc_describe default name" { let data = [1.0, 2.0, 3.0] let result = @src.hmisc_describe(data) assert_eq(result.name, "") } +///| test "hmisc_describe quartiles" { let data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let result = @src.hmisc_describe(data) @@ -72,6 +78,7 @@ test "hmisc_describe quartiles" { // hmisc_pearson tests +///| test "hmisc_pearson perfect positive correlation" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0] @@ -79,6 +86,7 @@ test "hmisc_pearson perfect positive correlation" { assert_true(result > 0.99 && result < 1.01) } +///| test "hmisc_pearson perfect negative correlation" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [10.0, 8.0, 6.0, 4.0, 2.0] @@ -86,6 +94,7 @@ test "hmisc_pearson perfect negative correlation" { assert_true(result < -0.99 && result > -1.01) } +///| test "hmisc_pearson no correlation" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0, 6.0, 5.0, 3.0] @@ -93,6 +102,7 @@ test "hmisc_pearson no correlation" { assert_true(result > -0.5 && result < 0.5) } +///| test "hmisc_pearson mismatched lengths" { let x = [1.0, 2.0, 3.0, 4.0] let y = [1.0, 2.0, 3.0] @@ -100,6 +110,7 @@ test "hmisc_pearson mismatched lengths" { assert_true(result.is_nan()) } +///| test "hmisc_pearson small arrays less than 3" { let x = [1.0, 2.0] let y = [3.0, 4.0] @@ -107,6 +118,7 @@ test "hmisc_pearson small arrays less than 3" { assert_true(result.is_nan()) } +///| test "hmisc_pearson constant values" { let x = [5.0, 5.0, 5.0, 5.0, 5.0] let y = [1.0, 2.0, 3.0, 4.0, 5.0] @@ -116,6 +128,7 @@ test "hmisc_pearson constant values" { // hmisc_spearman tests +///| test "hmisc_spearman perfect positive correlation" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0] @@ -123,6 +136,7 @@ test "hmisc_spearman perfect positive correlation" { assert_true(result > 0.99 && result < 1.01) } +///| test "hmisc_spearman perfect negative correlation" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [10.0, 8.0, 6.0, 4.0, 2.0] @@ -130,6 +144,7 @@ test "hmisc_spearman perfect negative correlation" { assert_true(result < -0.99 && result > -1.01) } +///| test "hmisc_spearman with ties" { let x = [1.0, 2.0, 2.0, 3.0, 4.0] let y = [2.0, 3.0, 3.0, 4.0, 5.0] @@ -137,6 +152,7 @@ test "hmisc_spearman with ties" { assert_true(result > 0.9 && result < 1.01) } +///| test "hmisc_spearman mismatched lengths" { let x = [1.0, 2.0, 3.0, 4.0] let y = [1.0, 2.0, 3.0] @@ -144,6 +160,7 @@ test "hmisc_spearman mismatched lengths" { assert_true(result.is_nan()) } +///| test "hmisc_spearman small arrays less than 3" { let x = [1.0, 2.0] let y = [3.0, 4.0] @@ -151,6 +168,7 @@ test "hmisc_spearman small arrays less than 3" { assert_true(result.is_nan()) } +///| test "hmisc_spearman monotonic but non-linear" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0] let y = [1.0, 4.0, 9.0, 16.0, 25.0, 36.0, 49.0, 64.0] @@ -160,6 +178,7 @@ test "hmisc_spearman monotonic but non-linear" { // hmisc_rcorr tests +///| test "hmisc_rcorr basic pearson correlation" { let data = [ [1.0, 2.0, 3.0, 4.0, 5.0], @@ -178,38 +197,32 @@ test "hmisc_rcorr basic pearson correlation" { assert_true(result.matrix[1][2] < -0.99) } +///| test "hmisc_rcorr basic spearman correlation" { - let data = [ - [1.0, 2.0, 3.0, 4.0, 5.0], - [2.0, 4.0, 6.0, 8.0, 10.0], - ] + let data = [[1.0, 2.0, 3.0, 4.0, 5.0], [2.0, 4.0, 6.0, 8.0, 10.0]] let result = @src.hmisc_rcorr(data, cor_type=@src.hmisc_cor_type_spearman()) assert_eq(@src.hmisc_cor_type_to_string(result.cor_type), "Spearman") assert_true(result.matrix[0][1] > 0.99) } +///| test "hmisc_rcorr with custom names" { - let data = [ - [1.0, 2.0, 3.0, 4.0, 5.0], - [2.0, 4.0, 6.0, 8.0, 10.0], - ] + let data = [[1.0, 2.0, 3.0, 4.0, 5.0], [2.0, 4.0, 6.0, 8.0, 10.0]] let result = @src.hmisc_rcorr(data, names=["Height", "Weight"]) assert_eq(result.names[0], "Height") assert_eq(result.names[1], "Weight") } +///| test "hmisc_rcorr default names" { - let data = [ - [1.0, 2.0, 3.0, 4.0], - [2.0, 4.0, 6.0, 8.0], - [3.0, 6.0, 9.0, 12.0], - ] + let data = [[1.0, 2.0, 3.0, 4.0], [2.0, 4.0, 6.0, 8.0], [3.0, 6.0, 9.0, 12.0]] let result = @src.hmisc_rcorr(data) assert_eq(result.names[0], "V1") assert_eq(result.names[1], "V2") assert_eq(result.names[2], "V3") } +///| test "hmisc_rcorr with NaN pairwise deletion" { let data = [ [1.0, 2.0, @double.not_a_number, 4.0, 5.0], @@ -222,6 +235,7 @@ test "hmisc_rcorr with NaN pairwise deletion" { assert_true(!result.matrix[1][2].is_nan()) } +///| test "hmisc_rcorr p-values computed" { let data = [ [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0], @@ -232,6 +246,7 @@ test "hmisc_rcorr p-values computed" { assert_true(result.p_values[0][1] >= 0.0 && result.p_values[0][1] <= 1.0) } +///| test "hmisc_rcorr symmetry" { let data = [ [1.0, 2.0, 3.0, 4.0, 5.0], @@ -244,11 +259,9 @@ test "hmisc_rcorr symmetry" { assert_true(result.matrix[1][2] == result.matrix[2][1]) } +///| test "hmisc_rcorr n matrix" { - let data = [ - [1.0, 2.0, 3.0, 4.0, 5.0], - [2.0, 4.0, 6.0, 8.0, 10.0], - ] + let data = [[1.0, 2.0, 3.0, 4.0, 5.0], [2.0, 4.0, 6.0, 8.0, 10.0]] let result = @src.hmisc_rcorr(data) assert_eq(result.n[0][0], 5) assert_eq(result.n[1][1], 5) @@ -258,18 +271,24 @@ test "hmisc_rcorr n matrix" { // hmisc_varclus tests +///| test "hmisc_varclus basic clustering" { let data = [ [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0], [2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0], [5.0, 4.0, 6.0, 3.0, 7.0, 5.0, 8.0, 4.0, 9.0, 6.0], ] - let result = @src.hmisc_varclus(data, names=["X", "Y", "Z"], min_cluster_size=2) + let result = @src.hmisc_varclus( + data, + names=["X", "Y", "Z"], + min_cluster_size=2, + ) assert_eq(result.names.length(), 3) assert_true(result.n_clusters >= 1) assert_eq(result.cluster_assignments.length(), 3) } +///| test "hmisc_varclus all variables in one cluster" { let data = [ [1.0, 2.0, 3.0, 4.0, 5.0], @@ -283,11 +302,9 @@ test "hmisc_varclus all variables in one cluster" { assert_eq(result.cluster_assignments[2], 0) } +///| test "hmisc_varclus with two variables" { - let data = [ - [1.0, 2.0, 3.0, 4.0, 5.0], - [2.0, 4.0, 6.0, 8.0, 10.0], - ] + let data = [[1.0, 2.0, 3.0, 4.0, 5.0], [2.0, 4.0, 6.0, 8.0, 10.0]] let result = @src.hmisc_varclus(data, names=["A", "B"]) assert_eq(result.n_clusters, 1) assert_eq(result.cluster_assignments.length(), 2) @@ -295,6 +312,7 @@ test "hmisc_varclus with two variables" { assert_eq(result.heights.length(), 0) } +///| test "hmisc_varclus merge steps" { let data = [ [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0], @@ -310,6 +328,7 @@ test "hmisc_varclus merge steps" { // hmisc_somers_d tests +///| test "hmisc_somers_d basic positive" { let g1 = [3.0, 5.0, 7.0, 9.0, 11.0] let g2 = [1.0, 2.0, 4.0, 6.0, 8.0] @@ -320,6 +339,7 @@ test "hmisc_somers_d basic positive" { assert_true(result.upper >= result.d) } +///| test "hmisc_somers_d basic negative" { let g1 = [1.0, 2.0, 3.0, 4.0, 5.0] let g2 = [4.0, 5.0, 6.0, 7.0, 8.0] @@ -327,6 +347,7 @@ test "hmisc_somers_d basic negative" { assert_true(result.d < 0.0) } +///| test "hmisc_somers_d completely separated" { let g1 = [10.0, 20.0, 30.0, 40.0, 50.0] let g2 = [1.0, 2.0, 3.0, 4.0, 5.0] @@ -334,6 +355,7 @@ test "hmisc_somers_d completely separated" { assert_true(result.d > 0.9 && result.d < 1.01) } +///| test "hmisc_somers_d equal distributions" { let g1 = [1.0, 2.0, 3.0, 4.0, 5.0] let g2 = [1.0, 2.0, 3.0, 4.0, 5.0] @@ -341,6 +363,7 @@ test "hmisc_somers_d equal distributions" { assert_true(result.d > -0.1 && result.d < 0.1) } +///| test "hmisc_somers_d empty group1" { let g1 : Array[Double] = Array::new() let g2 = [1.0, 2.0, 3.0] @@ -351,6 +374,7 @@ test "hmisc_somers_d empty group1" { assert_eq(result.n, 0) } +///| test "hmisc_somers_d empty group2" { let g1 = [1.0, 2.0, 3.0] let g2 : Array[Double] = Array::new() @@ -359,6 +383,7 @@ test "hmisc_somers_d empty group2" { assert_eq(result.n, 0) } +///| test "hmisc_somers_d confidence interval" { let g1 = [5.0, 10.0, 15.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0] let g2 = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] @@ -368,6 +393,7 @@ test "hmisc_somers_d confidence interval" { // hmisc_impute tests +///| test "hmisc_impute basic NaN imputation" { let data = [ [1.0, @double.not_a_number, 3.0], @@ -384,17 +410,16 @@ test "hmisc_impute basic NaN imputation" { assert_eq(result[1][1], 5.0) } +///| test "hmisc_impute no NaN values" { - let data = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - ] + let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let result = @src.hmisc_impute(data) assert_eq(result[0][0], 1.0) assert_eq(result[0][1], 2.0) assert_eq(result[1][2], 6.0) } +///| test "hmisc_impute all NaN column" { let data = [ [1.0, @double.not_a_number, 3.0], @@ -407,16 +432,16 @@ test "hmisc_impute all NaN column" { assert_eq(result[2][1], 0.0) } +///| test "hmisc_impute empty data" { let data : Array[Array[Double]] = Array::new() let result = @src.hmisc_impute(data) assert_eq(result.length(), 0) } +///| test "hmisc_impute single row" { - let data = [ - [1.0, @double.not_a_number, 3.0], - ] + let data = [[1.0, @double.not_a_number, 3.0]] let result = @src.hmisc_impute(data) assert_eq(result.length(), 1) assert_eq(result[0][0], 1.0) @@ -426,11 +451,9 @@ test "hmisc_impute single row" { // hmisc_rcorr_summary tests +///| test "hmisc_rcorr_summary basic formatting" { - let data = [ - [1.0, 2.0, 3.0, 4.0, 5.0], - [2.0, 4.0, 6.0, 8.0, 10.0], - ] + let data = [[1.0, 2.0, 3.0, 4.0, 5.0], [2.0, 4.0, 6.0, 8.0, 10.0]] let result = @src.hmisc_rcorr(data, names=["X", "Y"]) let summary = @src.hmisc_rcorr_summary(result) assert_true(summary.contains("Correlation Matrix")) @@ -440,18 +463,21 @@ test "hmisc_rcorr_summary basic formatting" { assert_true(summary.contains("Y")) } +///| test "hmisc_rcorr_summary spearman formatting" { - let data = [ - [1.0, 2.0, 3.0, 4.0, 5.0], - [2.0, 4.0, 6.0, 8.0, 10.0], - ] - let result = @src.hmisc_rcorr(data, names=["A", "B"], cor_type=@src.hmisc_cor_type_spearman()) + let data = [[1.0, 2.0, 3.0, 4.0, 5.0], [2.0, 4.0, 6.0, 8.0, 10.0]] + let result = @src.hmisc_rcorr( + data, + names=["A", "B"], + cor_type=@src.hmisc_cor_type_spearman(), + ) let summary = @src.hmisc_rcorr_summary(result) assert_true(summary.contains("Spearman")) } // hmisc_describe_summary tests +///| test "hmisc_describe_summary formatting" { let data = [1.0, 2.0, 3.0, 4.0, 5.0] let stats = @src.hmisc_describe(data, name="Height") @@ -466,6 +492,7 @@ test "hmisc_describe_summary formatting" { assert_true(summary.contains("Max:")) } +///| test "hmisc_describe_summary with NaN" { let data = [1.0, @double.not_a_number, 3.0] let stats = @src.hmisc_describe(data, name="Test") @@ -477,6 +504,7 @@ test "hmisc_describe_summary with NaN" { // hmisc_sample_data and hmisc_sample_names tests +///| test "hmisc_sample_data structure" { let data = @src.hmisc_sample_data() assert_eq(data.length(), 3) @@ -485,6 +513,7 @@ test "hmisc_sample_data structure" { assert_eq(data[2].length(), 10) } +///| test "hmisc_sample_data values" { let data = @src.hmisc_sample_data() assert_eq(data[0][0], 1.0) @@ -495,6 +524,7 @@ test "hmisc_sample_data values" { assert_eq(data[2][9], 6.0) } +///| test "hmisc_sample_names structure" { let names = @src.hmisc_sample_names() assert_eq(names.length(), 3) @@ -503,6 +533,7 @@ test "hmisc_sample_names structure" { assert_eq(names[2], "Z") } +///| test "hmisc_sample_data_with_describe" { let data = @src.hmisc_sample_data() let stats = @src.hmisc_describe(data[0], name="X") @@ -511,10 +542,11 @@ test "hmisc_sample_data_with_describe" { assert_eq(stats.max, 10.0) } +///| test "hmisc_sample_data_with_rcorr" { let data = @src.hmisc_sample_data() let names = @src.hmisc_sample_names() - let result = @src.hmisc_rcorr(data, names=names) + let result = @src.hmisc_rcorr(data, names~) assert_eq(result.names.length(), 3) assert_eq(result.matrix.length(), 3) assert_true(!result.matrix[0][1].is_nan()) @@ -522,16 +554,18 @@ test "hmisc_sample_data_with_rcorr" { assert_true(!result.matrix[1][2].is_nan()) } +///| test "hmisc_sample_data_with_varclus" { let data = @src.hmisc_sample_data() let names = @src.hmisc_sample_names() - let result = @src.hmisc_varclus(data, names=names) + let result = @src.hmisc_varclus(data, names~) assert_eq(result.names.length(), 3) assert_true(result.n_clusters >= 1) } // Edge case tests +///| test "hmisc_pearson with NaN values" { let x = [1.0, 2.0, @double.not_a_number, 4.0, 5.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0] @@ -539,6 +573,7 @@ test "hmisc_pearson with NaN values" { assert_true(result.is_nan()) } +///| test "hmisc_spearman with NaN values" { let x = [1.0, 2.0, @double.not_a_number, 4.0, 5.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0] @@ -546,9 +581,12 @@ test "hmisc_spearman with NaN values" { assert_true(result.is_nan()) } +///| test "hmisc_describe large dataset" { - let data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, - 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0] + let data = [ + 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, + 16.0, 17.0, 18.0, 19.0, 20.0, + ] let result = @src.hmisc_describe(data) assert_eq(result.n, 20) assert_true(result.mean > 10.0 && result.mean < 11.0) @@ -556,6 +594,7 @@ test "hmisc_describe large dataset" { assert_eq(result.max, 20.0) } +///| test "hmisc_somers_d large groups" { let g1 = [6.0, 12.0, 18.0, 24.0, 30.0, 36.0, 42.0, 48.0, 54.0, 60.0] let g2 = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] @@ -564,6 +603,7 @@ test "hmisc_somers_d large groups" { assert_true(result.d > 0.9) } +///| test "hmisc_impute preserves non-NaN values" { let data = [ [10.0, 20.0, 30.0], @@ -581,6 +621,7 @@ test "hmisc_impute preserves non-NaN values" { assert_eq(result[2][2], 90.0) } +///| test "hmisc_impute column mean computation" { let data = [ [@double.not_a_number, 10.0], @@ -592,6 +633,7 @@ test "hmisc_impute column mean computation" { assert_true(result[1][1] > 19.0 && result[1][1] < 21.0) } +///| test "hmisc_rcorr empty data" { let data : Array[Array[Double]] = Array::new() let result = @src.hmisc_rcorr(data) @@ -599,15 +641,15 @@ test "hmisc_rcorr empty data" { assert_eq(result.matrix.length(), 0) } +///| test "hmisc_varclus single variable" { - let data = [ - [1.0, 2.0, 3.0, 4.0, 5.0], - ] + let data = [[1.0, 2.0, 3.0, 4.0, 5.0]] let result = @src.hmisc_varclus(data, names=["X"]) assert_eq(result.n_clusters, 1) assert_eq(result.cluster_assignments[0], 0) } +///| test "hmisc_varclus two correlated variables" { let data = [ [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0], @@ -619,6 +661,7 @@ test "hmisc_varclus two correlated variables" { assert_true(result.n_clusters >= 1) } +///| test "hmisc_pearson_identical arrays" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [1.0, 2.0, 3.0, 4.0, 5.0] @@ -626,6 +669,7 @@ test "hmisc_pearson_identical arrays" { assert_true(result > 0.99 && result < 1.01) } +///| test "hmisc_pearson zero correlation" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0] let y = [1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0] @@ -633,6 +677,7 @@ test "hmisc_pearson zero correlation" { assert_true(result > -0.5 && result < 0.5) } +///| test "hmisc_spearman_identical arrays" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [1.0, 2.0, 3.0, 4.0, 5.0] @@ -640,6 +685,7 @@ test "hmisc_spearman_identical arrays" { assert_true(result > 0.99 && result < 1.01) } +///| test "hmisc_somers_d single element groups" { let g1 = [5.0] let g2 = [3.0] @@ -648,6 +694,7 @@ test "hmisc_somers_d single element groups" { assert_true(result.d > 0.0) } +///| test "hmisc_describe negative values" { let data = [-5.0, -3.0, -1.0, 0.0, 2.0] let result = @src.hmisc_describe(data) @@ -656,6 +703,7 @@ test "hmisc_describe negative values" { assert_true(result.mean > -1.5 && result.mean < -0.5) } +///| test "hmisc_impute all NaN row" { let data = [ [1.0, 2.0, 3.0], @@ -666,4 +714,4 @@ test "hmisc_impute all NaN row" { assert_true(!result[1][0].is_nan()) assert_true(!result[1][1].is_nan()) assert_true(!result[1][2].is_nan()) -} \ No newline at end of file +} diff --git a/test/moonbit/hmmcopy_test.mbt b/test/moonbit/hmmcopy_test.mbt index f16f6a38..0e590fc6 100644 --- a/test/moonbit/hmmcopy_test.mbt +++ b/test/moonbit/hmmcopy_test.mbt @@ -29,35 +29,20 @@ test "hc_bin_creation" { ///| test "hc_bin_default_gc_mappability" { - let b = @src.HMMcopyBin::new( - chr="chr1", - start=0, - end=1000, - reads=50, - ) + let b = @src.HMMcopyBin::new(chr="chr1", start=0, end=1000, reads=50) assert_true((b.gc - 0.5).abs() < 0.001) assert_true((b.mappability - 1.0).abs() < 0.001) } ///| test "hc_bin_width" { - let b = @src.HMMcopyBin::new( - chr="chr1", - start=1000, - end=2000, - reads=100, - ) + let b = @src.HMMcopyBin::new(chr="chr1", start=1000, end=2000, reads=100) assert_eq(b.width(), 1000) } ///| test "hc_bin_normalized_coverage" { - let b = @src.HMMcopyBin::new( - chr="chr1", - start=0, - end=500, - reads=100, - ) + let b = @src.HMMcopyBin::new(chr="chr1", start=0, end=500, reads=100) b.set_corrected_reads(200.0) let nc = b.normalized_coverage() assert_true((nc - 0.4).abs() < 0.001) @@ -65,12 +50,7 @@ test "hc_bin_normalized_coverage" { ///| test "hc_bin_zero_width_coverage" { - let b = @src.HMMcopyBin::new( - chr="chr1", - start=100, - end=100, - reads=50, - ) + let b = @src.HMMcopyBin::new(chr="chr1", start=100, end=100, reads=50) b.set_corrected_reads(75.0) // Zero width returns corrected_reads directly assert_true((b.normalized_coverage() - 75.0).abs() < 0.001) diff --git a/test/moonbit/hs_exposure_test.mbt b/test/moonbit/hs_exposure_test.mbt index 16d77421..19157284 100644 --- a/test/moonbit/hs_exposure_test.mbt +++ b/test/moonbit/hs_exposure_test.mbt @@ -3,13 +3,13 @@ test "calculate_hse_basic" { let ca = @src.PDBAtom::new("CA", 0.0, 0.0, 0.0) let cb = @src.PDBAtom::new("CB", 1.0, 0.0, 0.0) let n = @src.PDBAtom::new("N", 0.0, 1.0, 0.0) - + let all_ca : Array[@src.PDBAtom] = Array::new() all_ca.push(ca) all_ca.push(@src.PDBAtom::new("CA", 5.0, 0.0, 0.0)) all_ca.push(@src.PDBAtom::new("CA", 0.0, 5.0, 0.0)) all_ca.push(@src.PDBAtom::new("CA", 0.0, 0.0, 5.0)) - + let result = @src.calculate_hse(ca, cb, n, all_ca) assert_eq(result.residue_name, "CA") assert_true(result.hse_up >= 0.0) @@ -22,10 +22,10 @@ test "calculate_hse_single_atom" { let ca = @src.PDBAtom::new("CA", 0.0, 0.0, 0.0) let cb = @src.PDBAtom::new("CB", 1.0, 0.0, 0.0) let n = @src.PDBAtom::new("N", 0.0, 1.0, 0.0) - + let all_ca : Array[@src.PDBAtom] = Array::new() all_ca.push(ca) - + let result = @src.calculate_hse(ca, cb, n, all_ca) assert_eq(result.residue_name, "CA") } @@ -43,4 +43,4 @@ test "PDBAtom_new" { assert_eq(atom.x, 1.0) assert_eq(atom.y, 2.0) assert_eq(atom.z, 3.0) -} \ No newline at end of file +} diff --git a/test/moonbit/htsfilter_test.mbt b/test/moonbit/htsfilter_test.mbt index be78bca0..e521b590 100644 --- a/test/moonbit/htsfilter_test.mbt +++ b/test/moonbit/htsfilter_test.mbt @@ -1,16 +1,17 @@ ///| /// Tests for Bioconductor HTSFilter module - RNA-seq count filtering. - test "cpm_single_value" { let cpm = @src.hts_filter_single_cpm(1000.0, 1000000.0) assert_eq(cpm, 1000.0) } +///| test "cpm_zero_library" { let cpm = @src.hts_filter_single_cpm(1000.0, 0.0) assert_eq(cpm, 0.0) } +///| test "cpm_matrix_basic" { let counts = [[100.0, 200.0], [300.0, 400.0]] let libs = [1000000.0, 2000000.0] @@ -21,6 +22,7 @@ test "cpm_matrix_basic" { assert_true((cpm[0][0] - 100.0).abs() < 0.01) } +///| test "library_sizes" { let counts = [[10.0, 20.0, 30.0], [40.0, 50.0, 60.0]] let libs = @src.hts_filter_library_sizes(counts) @@ -30,6 +32,7 @@ test "library_sizes" { assert_true((libs[2] - 90.0).abs() < 0.01) } +///| test "filter_basic" { let (counts, groups, _) = @src.hts_filter_sample_data() let result = @src.hts_filter(counts, groups, 100.0, 2) @@ -39,6 +42,7 @@ test "filter_basic" { assert_eq(result.keep.length(), 20) } +///| test "filter_strict_threshold" { let (counts, groups, _) = @src.hts_filter_sample_data() // Very high threshold - should remove most genes @@ -46,6 +50,7 @@ test "filter_strict_threshold" { assert_true(result.n_genes_kept <= result.n_genes_input) } +///| test "filter_keep_mask" { let (counts, groups, _) = @src.hts_filter_sample_data() let result = @src.hts_filter(counts, groups, 100.0, 2) @@ -55,12 +60,15 @@ test "filter_keep_mask" { let mut i = 0 let mut true_count = 0 while i < result.keep.length() { - if result.keep[i] { true_count = true_count + 1 } + if result.keep[i] { + true_count = true_count + 1 + } i = i + 1 } assert_eq(true_count, result.n_genes_kept) } +///| test "filter_apply" { let counts = [[10.0, 20.0], [30.0, 40.0], [50.0, 60.0]] let keep = [true, false, true] @@ -70,6 +78,7 @@ test "filter_apply" { assert_eq(filtered[1][0], 50.0) } +///| test "filter_apply_names" { let names = ["A", "B", "C"] let keep = [true, false, true] @@ -79,6 +88,7 @@ test "filter_apply_names" { assert_eq(filtered[1], "C") } +///| test "filter_retention_rate" { let (counts, groups, _) = @src.hts_filter_sample_data() let result = @src.hts_filter(counts, groups, 100.0, 2) @@ -86,6 +96,7 @@ test "filter_retention_rate" { assert_true(rate >= 0.0 && rate <= 1.0) } +///| test "filter_summary" { let (counts, groups, _) = @src.hts_filter_sample_data() let result = @src.hts_filter(counts, groups, 100.0, 2) @@ -93,6 +104,7 @@ test "filter_summary" { assert_true(summary.length() > 0) } +///| test "filter_empty_counts" { let result = @src.hts_filter([], [0, 0, 1, 1], 1.0, 1) assert_eq(result.n_genes_input, 0) @@ -100,6 +112,7 @@ test "filter_empty_counts" { assert_eq(result.n_genes_removed, 0) } +///| test "filter_single_gene" { let counts = [[500.0, 600.0, 550.0, 100.0, 120.0, 110.0]] let groups = [0, 0, 0, 1, 1, 1] @@ -108,6 +121,7 @@ test "filter_single_gene" { assert_true(result.n_genes_kept <= 1) } +///| test "filter_get_keep" { let (counts, groups, _) = @src.hts_filter_sample_data() let result = @src.hts_filter(counts, groups, 100.0, 2) @@ -115,6 +129,7 @@ test "filter_get_keep" { assert_eq(keep.length(), result.keep.length()) } +///| test "cpm_zeros" { let counts = [[0.0, 0.0], [0.0, 0.0]] let libs = [1000000.0, 2000000.0] diff --git a/test/moonbit/ig_io_test.mbt b/test/moonbit/ig_io_test.mbt index 975713fb..fd33d315 100644 --- a/test/moonbit/ig_io_test.mbt +++ b/test/moonbit/ig_io_test.mbt @@ -15,9 +15,7 @@ ///| test "ig_record_new_and_accessors" { let r = @src.IgRecord::new( - "A_U455", - "HIV-1 group M subtype A", - "ATGGCAGCTGTGATGAAGCAGAGACGGGTAAGAGCTC", + "A_U455", "HIV-1 group M subtype A", "ATGGCAGCTGTGATGAAGCAGAGACGGGTAAGAGCTC", ) assert_eq(r.title(), "A_U455") assert_eq(r.comment(), "HIV-1 group M subtype A") diff --git a/test/moonbit/ihw_test.mbt b/test/moonbit/ihw_test.mbt index ba2a6ccb..efca0874 100644 --- a/test/moonbit/ihw_test.mbt +++ b/test/moonbit/ihw_test.mbt @@ -27,7 +27,10 @@ test "ihw_result_accessors" { let covs = [0.5] let result = @src.IHWResult::new(pvals, adj, weights, covs, 0.01, 3) assert_true(result.p_values()[0] > 0.009 && result.p_values()[0] < 0.011) - assert_true(result.adjusted_p_values()[0] > 0.049 && result.adjusted_p_values()[0] < 0.051) + assert_true( + result.adjusted_p_values()[0] > 0.049 && + result.adjusted_p_values()[0] < 0.051, + ) assert_true(result.weights()[0] > 1.9 && result.weights()[0] < 2.1) assert_true(result.covariates()[0] > 0.4 && result.covariates()[0] < 0.6) assert_true(result.alpha() > 0.009 && result.alpha() < 0.011) @@ -48,7 +51,11 @@ test "ihw_config_defaults" { ///| test "ihw_config_custom" { - let config = @src.IHWConfig::new(alpha=0.01, n_attempts=20, scale_type="global") + let config = @src.IHWConfig::new( + alpha=0.01, + n_attempts=20, + scale_type="global", + ) assert_true(config.alpha() > 0.009 && config.alpha() < 0.011) assert_eq(config.n_attempts(), 20) assert_eq(config.scale_type(), "global") @@ -205,7 +212,11 @@ test "ihw_with_constant_covariates" { test "ihw_with_config_global" { let pvals = [0.01, 0.04, 0.03, 0.02] let covs = [0.5, 0.3, 0.8, 0.2] - let config = @src.IHWConfig::new(alpha=0.05, n_attempts=5, scale_type="global") + let config = @src.IHWConfig::new( + alpha=0.05, + n_attempts=5, + scale_type="global", + ) let result = @src.ihw_with_config(pvals, covs, config) assert_eq(result.adjusted_p_values().length(), 4) let adj = result.adjusted_p_values() @@ -225,7 +236,11 @@ test "ihw_with_config_custom_alpha" { test "ihw_with_config_many_attempts" { let pvals = [0.001, 0.01, 0.03, 0.04, 0.5] let covs = [0.1, 0.2, 0.3, 0.4, 0.5] - let config = @src.IHWConfig::new(alpha=0.05, n_attempts=50, scale_type="local") + let config = @src.IHWConfig::new( + alpha=0.05, + n_attempts=50, + scale_type="local", + ) let result = @src.ihw_with_config(pvals, covs, config) assert_true(result.n_attempts() <= 50) } @@ -413,7 +428,7 @@ test "ihw_many_tests" { let covs : Array[Double] = Array::make(n, 0.0) let mut i = 0 while i < n { - pvals[i] = ((i + 1).to_double() / (n.to_double() + 1.0)) * 0.1 + pvals[i] = (i + 1).to_double() / (n.to_double() + 1.0) * 0.1 covs[i] = (i + 1).to_double() / n.to_double() i = i + 1 } @@ -456,4 +471,4 @@ fn count_less_than(arr : Array[Double], threshold : Double) -> Int { i = i + 1 } count -} \ No newline at end of file +} diff --git a/test/moonbit/imgt_io_test.mbt b/test/moonbit/imgt_io_test.mbt index 34b18de5..cd2f233b 100644 --- a/test/moonbit/imgt_io_test.mbt +++ b/test/moonbit/imgt_io_test.mbt @@ -18,19 +18,8 @@ ///| test "imgt_header_new_and_all_accessors" { let h = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "A*01:01:01:01", - "ORF", - "2015-03-31", - "1996-01-19", - "human", - "HLA-A", - "I", - "MHC", - "2703 bp", - " genomic-DNA", - "no comments", + "HLA00001", "A*01:01:01:01", "A*01:01:01:01", "ORF", "2015-03-31", "1996-01-19", + "human", "HLA-A", "I", "MHC", "2703 bp", " genomic-DNA", "no comments", ) assert_eq(h.accession(), "HLA00001") assert_eq(h.seq_id(), "A*01:01:01:01") @@ -50,19 +39,8 @@ test "imgt_header_new_and_all_accessors" { ///| test "imgt_header_to_string" { let h = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "A*01:01:01:01", - "ORF", - "2015-03-31", - "1996-01-19", - "human", - "HLA-A", - "I", - "MHC", - "2703 bp", - " genomic-DNA", - "", + "HLA00001", "A*01:01:01:01", "A*01:01:01:01", "ORF", "2015-03-31", "1996-01-19", + "human", "HLA-A", "I", "MHC", "2703 bp", " genomic-DNA", "", ) assert_eq( h.to_string(), @@ -73,19 +51,8 @@ test "imgt_header_to_string" { ///| test "imgt_header_to_string_all_fields_populated" { let h = @src.ImgtHeader::new( - "ACC1", - "SID1", - "ON1", - "R1", - "D1", - "D2", - "SP1", - "G1", - "IG1", - "L1", - "100 bp", - "DNA", - "C1", + "ACC1", "SID1", "ON1", "R1", "D1", "D2", "SP1", "G1", "IG1", "L1", "100 bp", + "DNA", "C1", ) let s = h.to_string() // 13 fields separated by 12 pipes. @@ -94,7 +61,9 @@ test "imgt_header_to_string_all_fields_populated" { ///| test "imgt_header_to_string_empty_fields" { - let h = @src.ImgtHeader::new("", "", "", "", "", "", "", "", "", "", "", "", "") + let h = @src.ImgtHeader::new( + "", "", "", "", "", "", "", "", "", "", "", "", "", + ) assert_eq(h.to_string(), "||||||||||||") } @@ -105,19 +74,8 @@ test "imgt_header_to_string_empty_fields" { ///| test "imgt_record_new_and_accessors" { let header = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "A*01:01:01:01", - "ORF", - "2015-03-31", - "1996-01-19", - "human", - "HLA-A", - "I", - "MHC", - "2703 bp", - " genomic-DNA", - "", + "HLA00001", "A*01:01:01:01", "A*01:01:01:01", "ORF", "2015-03-31", "1996-01-19", + "human", "HLA-A", "I", "MHC", "2703 bp", " genomic-DNA", "", ) let rec = @src.ImgtRecord::new(header, "ATGGCCGTCATGGCGCCCCGAACCCTCCTCCTC") assert_eq(rec.header().accession(), "HLA00001") @@ -127,19 +85,7 @@ test "imgt_record_new_and_accessors" { ///| test "imgt_record_id" { let header = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", + "HLA00001", "A*01:01:01:01", "", "", "", "", "", "", "", "", "", "", "", ) let rec = @src.ImgtRecord::new(header, "ACGT") assert_eq(rec.id(), "A*01:01:01:01") @@ -148,19 +94,8 @@ test "imgt_record_id" { ///| test "imgt_record_description" { let header = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "A*01:01:01:01", - "ORF", - "2015-03-31", - "1996-01-19", - "human", - "HLA-A", - "I", - "MHC", - "2703 bp", - " genomic-DNA", - "", + "HLA00001", "A*01:01:01:01", "A*01:01:01:01", "ORF", "2015-03-31", "1996-01-19", + "human", "HLA-A", "I", "MHC", "2703 bp", " genomic-DNA", "", ) let rec = @src.ImgtRecord::new(header, "ACGT") // description() returns the full pipe-separated header (without '>'). @@ -170,18 +105,7 @@ test "imgt_record_description" { ///| test "imgt_record_to_string" { let header = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "", - "", - "", - "", - "human", - "HLA-A", - "", - "", - "", - "", + "HLA00001", "A*01:01:01:01", "", "", "", "", "human", "HLA-A", "", "", "", "", "", ) let rec = @src.ImgtRecord::new(header, "ATGGCC") @@ -380,19 +304,7 @@ test "imgt_parse_no_trailing_newline" { ///| test "imgt_header_to_string_basic" { let h = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", + "HLA00001", "A*01:01:01:01", "", "", "", "", "", "", "", "", "", "", "", ) assert_eq(@src.imgt_header_to_string(h), ">HLA00001|A*01:01:01:01|||||||||||") } @@ -400,19 +312,8 @@ test "imgt_header_to_string_basic" { ///| test "imgt_header_to_string_round_trip_with_parse" { let h = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "A*01:01:01:01", - "ORF", - "2015-03-31", - "1996-01-19", - "human", - "HLA-A", - "I", - "MHC", - "2703 bp", - " genomic-DNA", - "", + "HLA00001", "A*01:01:01:01", "A*01:01:01:01", "ORF", "2015-03-31", "1996-01-19", + "human", "HLA-A", "I", "MHC", "2703 bp", " genomic-DNA", "", ) let s = @src.imgt_header_to_string(h) match @src.imgt_parse_header(s) { @@ -442,19 +343,7 @@ test "imgt_header_to_string_round_trip_with_parse" { ///| test "imgt_record_to_string_includes_header_and_sequence" { let header = @src.ImgtHeader::new( - "HLA00001", - "A*01:01:01:01", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", + "HLA00001", "A*01:01:01:01", "", "", "", "", "", "", "", "", "", "", "", ) let rec = @src.ImgtRecord::new(header, "ATGGCCGTC") let s = @src.imgt_record_to_string(rec) @@ -468,7 +357,9 @@ test "imgt_record_to_string_includes_header_and_sequence" { test "imgt_record_to_string_wraps_long_sequence" { // A 120-character sequence should be wrapped into two 60-character lines. let seq = "ATGGCCGTCATGGCGCCCCGAACCCTCCTCCTGCTGCTCTCTGGGGCCCCGGGGCCCCGGGGCCCCGGATGGCCGTCATGGCGCCCCGAACCCTCCTCCTGCTGCTCTCTGGGGCCCCGGGGCCCCGGGGCCCCGG" - let header = @src.ImgtHeader::new("A", "B", "", "", "", "", "", "", "", "", "", "", "") + let header = @src.ImgtHeader::new( + "A", "B", "", "", "", "", "", "", "", "", "", "", "", + ) let rec = @src.ImgtRecord::new(header, seq) let s = @src.imgt_record_to_string(rec) // The first line is the header (starts with '>'); the next two lines are @@ -481,7 +372,9 @@ test "imgt_record_to_string_wraps_long_sequence" { ///| test "imgt_record_to_string_empty_sequence" { - let header = @src.ImgtHeader::new("A", "B", "", "", "", "", "", "", "", "", "", "", "") + let header = @src.ImgtHeader::new( + "A", "B", "", "", "", "", "", "", "", "", "", "", "", + ) let rec = @src.ImgtRecord::new(header, "") let s = @src.imgt_record_to_string(rec) // Header line followed by a newline; no sequence line content. @@ -529,7 +422,9 @@ test "imgt_n_records_empty" { ///| test "imgt_n_records_single" { - let h = @src.ImgtHeader::new("A", "B", "", "", "", "", "", "", "", "", "", "", "") + let h = @src.ImgtHeader::new( + "A", "B", "", "", "", "", "", "", "", "", "", "", "", + ) let rec = @src.ImgtRecord::new(h, "ACGT") assert_eq(@src.imgt_n_records([rec]), 1) } @@ -682,9 +577,15 @@ test "imgt_unique_genes_empty" { ///| test "imgt_unique_species_preserves_first_appearance_order" { // Create records with multiple species to verify order. - let h1 = @src.ImgtHeader::new("A", "s1", "", "", "", "", "zebra", "", "", "", "", "", "") - let h2 = @src.ImgtHeader::new("B", "s2", "", "", "", "", "mouse", "", "", "", "", "", "") - let h3 = @src.ImgtHeader::new("C", "s3", "", "", "", "", "zebra", "", "", "", "", "", "") + let h1 = @src.ImgtHeader::new( + "A", "s1", "", "", "", "", "zebra", "", "", "", "", "", "", + ) + let h2 = @src.ImgtHeader::new( + "B", "s2", "", "", "", "", "mouse", "", "", "", "", "", "", + ) + let h3 = @src.ImgtHeader::new( + "C", "s3", "", "", "", "", "zebra", "", "", "", "", "", "", + ) let recs = [ @src.ImgtRecord::new(h1, "ACGT"), @src.ImgtRecord::new(h2, "TTTT"), @@ -743,8 +644,16 @@ test "imgt_to_seq_records" { ///| test "imgt_from_seq_records" { let seq_records = [ - @src.SeqRecord::new(@src.Seq::new("ACGTACGT"), id="rec1", description="desc1"), - @src.SeqRecord::new(@src.Seq::new("TTTTGGGG"), id="rec2", description="desc2"), + @src.SeqRecord::new( + @src.Seq::new("ACGTACGT"), + id="rec1", + description="desc1", + ), + @src.SeqRecord::new( + @src.Seq::new("TTTTGGGG"), + id="rec2", + description="desc2", + ), ] let imgt_records = @src.imgt_from_seq_records(seq_records) assert_eq(imgt_records.length(), 2) @@ -867,7 +776,9 @@ test "edge_case_empty_array_write" { ///| test "edge_case_single_record" { - let h = @src.ImgtHeader::new("A", "B", "", "", "", "", "", "", "", "", "", "", "") + let h = @src.ImgtHeader::new( + "A", "B", "", "", "", "", "", "", "", "", "", "", "", + ) let rec = @src.ImgtRecord::new(h, "ACGT") let text = @src.imgt_write([rec]) let reparsed = @src.imgt_parse(text) diff --git a/test/moonbit/impute_test.mbt b/test/moonbit/impute_test.mbt index 8f03f363..6e82dc17 100644 --- a/test/moonbit/impute_test.mbt +++ b/test/moonbit/impute_test.mbt @@ -41,9 +41,7 @@ test "impute_by_col_median_basic" { ///| test "impute_locf_basic" { - let data = [ - [Double::nan(), 1.0, Double::nan(), 2.0, Double::nan()], - ] + let data = [[Double::nan(), 1.0, Double::nan(), 2.0, Double::nan()]] let imputed = @src.impute_locf(data, by_row=true) assert_true(imputed[0][0].is_nan()) assert_eq(imputed[0][2], 1.0) @@ -52,9 +50,7 @@ test "impute_locf_basic" { ///| test "impute_nocb_basic" { - let data = [ - [Double::nan(), 1.0, Double::nan(), 2.0, Double::nan()], - ] + let data = [[Double::nan(), 1.0, Double::nan(), 2.0, Double::nan()]] let imputed = @src.impute_nocb(data, by_row=true) assert_eq(imputed[0][0], 1.0) assert_eq(imputed[0][2], 2.0) @@ -63,10 +59,7 @@ test "impute_nocb_basic" { ///| test "impute_na_by_zero" { - let data = [ - [1.0, Double::nan()], - [Double::nan(), 2.0], - ] + let data = [[1.0, Double::nan()], [Double::nan(), 2.0]] let imputed = @src.impute_na_by_zero(data) assert_eq(imputed[0][1], 0.0) assert_eq(imputed[1][0], 0.0) @@ -76,10 +69,7 @@ test "impute_na_by_zero" { ///| test "impute_na_stats" { - let data = [ - [1.0, Double::nan(), 3.0], - [Double::nan(), Double::nan(), 6.0], - ] + let data = [[1.0, Double::nan(), 3.0], [Double::nan(), Double::nan(), 6.0]] let stats = @src.impute_na_stats(data) assert_eq(stats.total_rows, 2) assert_eq(stats.total_cols, 3) @@ -92,10 +82,7 @@ test "impute_na_stats" { ///| test "impute_na_summary" { - let data = [ - [1.0, Double::nan()], - [Double::nan(), 2.0], - ] + let data = [[1.0, Double::nan()], [Double::nan(), 2.0]] let stats = @src.impute_na_stats(data) let s = @src.impute_na_summary(stats) assert_true(s.contains("total NAs")) @@ -103,10 +90,7 @@ test "impute_na_summary" { ///| test "impute_by_knn_no_na" { - let data = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - ] + let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let p = @src.KNNImputeParam::new() let imputed = @src.impute_by_knn(data, p) assert_eq(imputed[0][0], 1.0) @@ -115,21 +99,14 @@ test "impute_by_knn_no_na" { ///| test "impute_by_knn_simple" { - let data = [ - [1.0, Double::nan(), 3.0], - [2.0, 5.0, 4.0], - [3.0, 6.0, 7.0], - ] + let data = [[1.0, Double::nan(), 3.0], [2.0, 5.0, 4.0], [3.0, 6.0, 7.0]] let imputed = @src.impute_by_knn_simple(data, 2) assert_true(!imputed[0][1].is_nan()) } ///| test "impute_na_mask" { - let data = [ - [1.0, Double::nan()], - [Double::nan(), 2.0], - ] + let data = [[1.0, Double::nan()], [Double::nan(), 2.0]] let mask = @src.make_na_mask(data) assert_eq(mask[0][1], true) assert_eq(mask[1][0], true) @@ -139,9 +116,7 @@ test "impute_na_mask" { ///| test "impute_by_row_median_and_min" { - let data = [ - [1.0, Double::nan(), 3.0, 100.0], - ] + let data = [[1.0, Double::nan(), 3.0, 100.0]] let med = @src.impute_by_row_median(data) assert_true(!med[0][1].is_nan()) let mn = @src.impute_by_row_min(data) diff --git a/test/moonbit/infercnv_test.mbt b/test/moonbit/infercnv_test.mbt index 7ba7e781..4cc2bf26 100644 --- a/test/moonbit/infercnv_test.mbt +++ b/test/moonbit/infercnv_test.mbt @@ -13,6 +13,7 @@ test "infercnv_gene_position_creation" { assert_eq(gp.end, 7687490) } +///| test "infercnv_ordered_genes_natural_chromosome_sort" { let genes = [ @src.gene_position("G_chr10_a", "chr10", 100, 200), @@ -31,6 +32,7 @@ test "infercnv_ordered_genes_natural_chromosome_sort" { assert_eq(og.gene_order[4].gene_id, "G_chrX_a") } +///| test "infercnv_exclude_chromosomes_filters_sex_and_mito" { let genes = [ @src.gene_position("A", "chr1", 1, 100), @@ -42,7 +44,7 @@ test "infercnv_exclude_chromosomes_filters_sex_and_mito" { let og = @src.ordered_genes(genes) let filtered = @src.exclude_chromosomes(og, ["chrX", "chrY", "chrM"]) assert_eq(filtered.n_genes, 2) - let ids = filtered.gene_order.map(fn (g) -> String { g.gene_id }) + let ids = filtered.gene_order.map(fn(g) -> String { g.gene_id }) assert_eq(ids, ["A", "C"]) } @@ -50,9 +52,10 @@ test "infercnv_exclude_chromosomes_filters_sex_and_mito" { // Log normalization // --------------------------------------------------------------------------- +///| test "infercnv_log_normalize_counts_basic" { let raw = [ - [1.0, 2.0, 7.0], // total = 10 -> per gene * 10000 + [1.0, 2.0, 7.0], // total = 10 -> per gene * 10000 ] let norm = @src.log_normalize_counts(raw, target_sum=10000.0) // first row: 1000, 2000, 7000; log2(x+1) @@ -62,6 +65,7 @@ test "infercnv_log_normalize_counts_basic" { assert_true(norm[0][2] > 12.0 && norm[0][2] < 13.0) } +///| test "infercnv_log_normalize_counts_zero_cell_preserved" { let raw = [[0.0, 0.0, 0.0]] let norm = @src.log_normalize_counts(raw) @@ -72,6 +76,7 @@ test "infercnv_log_normalize_counts_zero_cell_preserved" { // Reference method helpers // --------------------------------------------------------------------------- +///| test "infercnv_ref_method_constructors" { match @src.ref_method_global_mean() { @src.ReferenceMethod::GlobalMean => assert_true(true) @@ -88,6 +93,7 @@ test "infercnv_ref_method_constructors" { } } +///| test "infercnv_default_params_sensible" { let p = @src.default_cnv_params() assert_eq(p.window_size, 100) @@ -99,9 +105,13 @@ test "infercnv_default_params_sensible" { // Synthetic data generator // --------------------------------------------------------------------------- +///| test "infercnv_sample_data_shape" { let (input, tumour_cats, normal_cats) = @src.infercnv_sample_data( - n_tumour=20, n_normal=10, n_chr=3, n_genes_per_chr=20, + n_tumour=20, + n_normal=10, + n_chr=3, + n_genes_per_chr=20, ) assert_eq(input.n_cells, 30) assert_eq(input.n_genes, 60) @@ -117,14 +127,23 @@ test "infercnv_sample_data_shape" { // End-to-end pipeline with sample data and all reference strategies // --------------------------------------------------------------------------- +///| test "infercnv_run_pipeline_global_mean" { let (input, _tumour, _normal) = @src.infercnv_sample_data( - n_tumour=8, n_normal=6, n_chr=3, n_genes_per_chr=30, seed=1, + n_tumour=8, + n_normal=6, + n_chr=3, + n_genes_per_chr=30, + seed=1, ) let params = @src.make_cnv_params( - 11, 1.5, 0.05, @src.ref_method_global_mean(), [], + 11, + 1.5, + 0.05, + @src.ref_method_global_mean(), + [], ) - let res = @src.run_infercnv(input, params=params, excluded_chromosomes=[]) + let res = @src.run_infercnv(input, params~, excluded_chromosomes=[]) assert_eq(res.n_cells, 14) assert_eq(res.n_genes, 90) assert_eq(res.cnv_matrix.length(), 14) @@ -138,14 +157,23 @@ test "infercnv_run_pipeline_global_mean" { assert_true(n_score >= 0.0) } +///| test "infercnv_run_pipeline_reference_categories" { let (input, _tumour, normal) = @src.infercnv_sample_data( - n_tumour=10, n_normal=8, n_chr=2, n_genes_per_chr=20, seed=7, + n_tumour=10, + n_normal=8, + n_chr=2, + n_genes_per_chr=20, + seed=7, ) let params = @src.make_cnv_params( - 9, 1.5, 0.05, @src.ref_method_reference_categories(), normal, + 9, + 1.5, + 0.05, + @src.ref_method_reference_categories(), + normal, ) - let res = @src.run_infercnv(input, params=params, excluded_chromosomes=[]) + let res = @src.run_infercnv(input, params~, excluded_chromosomes=[]) assert_eq(res.n_cells, 18) assert_eq(res.n_genes, 40) let t_score = res.cluster_score("Tumour") @@ -154,17 +182,28 @@ test "infercnv_run_pipeline_reference_categories" { assert_true(t_score > n_score * 1.2) } +///| test "infercnv_run_pipeline_custom_reference" { let (input, _t, _n) = @src.infercnv_sample_data( - n_tumour=5, n_normal=4, n_chr=2, n_genes_per_chr=16, seed=99, + n_tumour=5, + n_normal=4, + n_chr=2, + n_genes_per_chr=16, + seed=99, ) // flat reference of 3.0 for all genes (for testing the path only) let ref : Array[Double] = [] - for _i in 0.. 3 boundaries @@ -203,22 +257,33 @@ test "infercnv_result_chromosome_list_matches_input" { let (chr1, s1, e1) = res.chromosome_list()[0] assert_eq(chr1, "chr1") assert_eq(s1, 0) - assert_eq(e1, 11) // 12 genes per chr, indexed 0..11 + assert_eq(e1, 11) // 12 genes per chr, indexed 0..11 } +///| test "infercnv_predict_tumour_cells_flags_tumour_like" { let (input, _t, _n) = @src.infercnv_sample_data( - n_tumour=15, n_normal=10, n_chr=3, n_genes_per_chr=30, seed=42, + n_tumour=15, + n_normal=10, + n_chr=3, + n_genes_per_chr=30, + seed=42, ) let params = @src.make_cnv_params( - 11, 1.5, 0.05, @src.ref_method_reference_categories(), ["Normal"], + 11, + 1.5, + 0.05, + @src.ref_method_reference_categories(), + ["Normal"], ) - let res = @src.run_infercnv(input, params=params, excluded_chromosomes=[]) + let res = @src.run_infercnv(input, params~, excluded_chromosomes=[]) let predicted = res.predict_tumour_cells("Normal", threshold_factor=1.3) // Majority of the tumour cells (indices 0..14) should be flagged let mut tumour_flagged = 0 for idx in predicted { - if idx < 15 { tumour_flagged = tumour_flagged + 1 } + if idx < 15 { + tumour_flagged = tumour_flagged + 1 + } } // At least 10/15 tumour cells called assert_true(tumour_flagged >= 10) diff --git a/test/moonbit/insdc_io_test.mbt b/test/moonbit/insdc_io_test.mbt index 61f1052b..8cdc3ad6 100644 --- a/test/moonbit/insdc_io_test.mbt +++ b/test/moonbit/insdc_io_test.mbt @@ -4,9 +4,7 @@ ///| test "insdc_parse_feature_table_cds" { let lines = [ - " CDS 1..100", - " /gene=\"testGene\"", - " /product=\"test protein\"", + " CDS 1..100", " /gene=\"testGene\"", " /product=\"test protein\"", " /translation=\"MKVL\"", ] let features = @src.parse_insdc_feature_table(lines) @@ -24,9 +22,7 @@ test "insdc_parse_feature_table_cds" { ///| test "insdc_parse_feature_table_gene" { let lines = [ - " gene 1..100", - " /gene=\"testGene\"", - " /locus_tag=\"TEST001\"", + " gene 1..100", " /gene=\"testGene\"", " /locus_tag=\"TEST001\"", ] let features = @src.parse_insdc_feature_table(lines) assert_eq(features.length(), 1) @@ -47,9 +43,7 @@ test "insdc_parse_feature_table_empty" { ///| test "insdc_parse_feature_table_multiline_qualifier" { let lines = [ - " CDS 1..100", - " /translation=\"MKVL", - " KLMN\"", + " CDS 1..100", " /translation=\"MKVL", " KLMN\"", ] let features = @src.parse_insdc_feature_table(lines) assert_eq(features.length(), 1) @@ -60,11 +54,8 @@ test "insdc_parse_feature_table_multiline_qualifier" { ///| test "insdc_parse_feature_table_multiple_features" { let lines = [ - " CDS 1..100", - " /gene=\"geneA\"", - " gene 1..100", - " /gene=\"geneA\"", - " /locus_tag=\"LA001\"", + " CDS 1..100", " /gene=\"geneA\"", " gene 1..100", + " /gene=\"geneA\"", " /locus_tag=\"LA001\"", ] let features = @src.parse_insdc_feature_table(lines) assert_eq(features.length(), 2) @@ -103,8 +94,7 @@ test "insdc_parse_location_with_whitespace" { ///| test "insdc_extract_feature_qualifier_missing" { let lines = [ - " CDS 1..100", - " /gene=\"testGene\"", + " CDS 1..100", " /gene=\"testGene\"", ] let features = @src.parse_insdc_feature_table(lines) let missing = @src.extract_feature_qualifier(features[0], "product") @@ -114,8 +104,7 @@ test "insdc_extract_feature_qualifier_missing" { ///| test "insdc_extract_translation_no_cds" { let lines = [ - " gene 1..100", - " /gene=\"testGene\"", + " gene 1..100", " /gene=\"testGene\"", ] let features = @src.parse_insdc_feature_table(lines) let trans = @src.extract_translation(features[0]) diff --git a/test/moonbit/internal_coords_test.mbt b/test/moonbit/internal_coords_test.mbt index af05bf6a..54528d80 100644 --- a/test/moonbit/internal_coords_test.mbt +++ b/test/moonbit/internal_coords_test.mbt @@ -80,13 +80,11 @@ test "ic_distance" { ///| test "ic_torsion_angle_creation" { - let tau = @src.TorsionAngle::new( - name="phi", - value=-0.57, - atom_names=["C", "N", "CA", "C"], - ) + let tau = @src.TorsionAngle::new(name="phi", value=-0.57, atom_names=[ + "C", "N", "CA", "C", + ]) assert_eq(tau.name, "phi") - assert_true((tau.value - (-0.57)).abs() < 1.0e-10) + assert_true((tau.value - -0.57).abs() < 1.0e-10) } ///| @@ -132,10 +130,10 @@ test "ic_add_residue_to_chain" { ///| test "ic_compute_phi" { let phi = @src.ic_compute_phi( - [0.0, 0.0, 0.0], // prev C - [1.5, 0.0, 0.0], // N - [3.0, 0.0, 0.0], // CA - [4.5, 1.0, 0.0], // C + [0.0, 0.0, 0.0], // prev C + [1.5, 0.0, 0.0], // N + [3.0, 0.0, 0.0], // CA + [4.5, 1.0, 0.0], // C ) assert_true(phi >= -@src.ic_pi() && phi <= @src.ic_pi()) } @@ -143,10 +141,10 @@ test "ic_compute_phi" { ///| test "ic_compute_psi" { let psi = @src.ic_compute_psi( - [0.0, 0.0, 0.0], // N - [1.5, 0.0, 0.0], // CA - [3.0, 0.0, 0.0], // C - [4.5, 1.0, 0.0], // next N + [0.0, 0.0, 0.0], // N + [1.5, 0.0, 0.0], // CA + [3.0, 0.0, 0.0], // C + [4.5, 1.0, 0.0], // next N ) assert_true(psi >= -@src.ic_pi() && psi <= @src.ic_pi()) } @@ -200,8 +198,8 @@ test "ic_rotamer_creation" { ///| test "ic_rotamer_library_entry" { let entry = @src.RotamerLibraryEntry::new(phi=-0.57, psi=-0.45) - assert_true((entry.phi - (-0.57)).abs() < 1.0e-10) - assert_true((entry.psi - (-0.45)).abs() < 1.0e-10) + assert_true((entry.phi - -0.57).abs() < 1.0e-10) + assert_true((entry.psi - -0.45).abs() < 1.0e-10) } ///| @@ -224,7 +222,9 @@ test "ic_chain_summary" { test "ic_ramachandran_data" { let phi_vals = [-1.0, -0.5, 0.0, 0.5, 1.0] let psi_vals = [-1.0, -0.5, 0.0, 0.5, 1.0] - let (mean_phi, mean_psi, var_phi, var_psi) = @src.ic_ramachandran_data(phi_vals, psi_vals) + let (mean_phi, mean_psi, var_phi, var_psi) = @src.ic_ramachandran_data( + phi_vals, psi_vals, + ) assert_true(mean_phi.abs() < 1.0e-10) assert_true(mean_psi.abs() < 1.0e-10) assert_true(var_phi > 0.0) @@ -242,4 +242,4 @@ test "ic_chi1_rotamers_gly" { let rotamers = @src.ic_chi1_rotamers("GLY") // GLY has one default rotamer assert_eq(rotamers.length(), 1) -} \ No newline at end of file +} diff --git a/test/moonbit/interproscan_test.mbt b/test/moonbit/interproscan_test.mbt index c9475e50..d2ce54e7 100644 --- a/test/moonbit/interproscan_test.mbt +++ b/test/moonbit/interproscan_test.mbt @@ -43,6 +43,7 @@ test "ips_record_construction" { assert_eq(r.go_terms()[1], "GO:0008150") } +///| test "ips_record_accessors_empty_go" { let empty_go : Array[String] = Array::new() let r = @src.InterproScanRecord::new( @@ -64,6 +65,7 @@ test "ips_record_accessors_empty_go" { assert_eq(r.go_terms().length(), 0) } +///| test "ips_record_to_string" { let go : Array[String] = Array::new() go.push("GO:0003674") @@ -96,20 +98,49 @@ test "ips_record_to_string" { // TSV parsing // --------------------------------------------------------------------------- +///| test "ips_parse_single_record" { let t = "\t" - let data = "sp|P12345|PROT_HUMAN" + t + "abc123" + t + "500" + t + "Pfam" + t + "PF00001" + t + "p53" + t + "1" + t + "100" + t + "150.5" + t + "T" + t + "01-Jan-2024" + t + "IPR000001" + t + "p53 domain" + t + "GO:0003674\n" + let data = "sp|P12345|PROT_HUMAN" + + t + + "abc123" + + t + + "500" + + t + + "Pfam" + + t + + "PF00001" + + t + + "p53" + + t + + "1" + + t + + "100" + + t + + "150.5" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "IPR000001" + + t + + "p53 domain" + + t + + "GO:0003674\n" let records = @src.parse_interproscan(data) assert_eq(records.length(), 1) assert_eq(records[0].protein_id(), "sp|P12345|PROT_HUMAN") } +///| test "ips_parse_multiple_records" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) assert_eq(records.length(), 8) } +///| test "ips_parse_all_fields_correct" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -132,6 +163,7 @@ test "ips_parse_all_fields_correct" { assert_eq(r.go_terms()[1], "GO:0008150") } +///| test "ips_parse_multiple_go_terms" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -147,39 +179,83 @@ test "ips_parse_multiple_go_terms" { // Edge cases // --------------------------------------------------------------------------- +///| test "ips_parse_empty_input" { let records = @src.parse_interproscan("") assert_eq(records.length(), 0) } +///| test "ips_parse_only_comments" { let data = "# InterProScan output\n# version 5.0\n# another comment\n" let records = @src.parse_interproscan(data) assert_eq(records.length(), 0) } +///| test "ips_parse_blank_lines" { let data = "\n\n \n\n" let records = @src.parse_interproscan(data) assert_eq(records.length(), 0) } +///| test "ips_parse_no_hits" { let t = "\t" - let data = "sp|P99999|NOPROT_HUMAN" + t + "xyz789" + t + "100" + t + "No hits\n" + - "sp|P12345|PROT_HUMAN" + t + "abc123" + t + "500" + t + "Pfam" + t + "PF00001" + t + "p53" + t + "1" + t + "100" + t + "150.5" + t + "T" + t + "01-Jan-2024" + t + "IPR000001" + t + "p53 domain" + t + "GO:0003674\n" + let data = "sp|P99999|NOPROT_HUMAN" + + t + + "xyz789" + + t + + "100" + + t + + "No hits\n" + + "sp|P12345|PROT_HUMAN" + + t + + "abc123" + + t + + "500" + + t + + "Pfam" + + t + + "PF00001" + + t + + "p53" + + t + + "1" + + t + + "100" + + t + + "150.5" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "IPR000001" + + t + + "p53 domain" + + t + + "GO:0003674\n" let records = @src.parse_interproscan(data) assert_eq(records.length(), 1) assert_eq(records[0].protein_id(), "sp|P12345|PROT_HUMAN") } +///| test "ips_parse_only_no_hits" { let t = "\t" - let data = "sp|P99999|NOPROT_HUMAN" + t + "xyz789" + t + "100" + t + "No hits\n" + let data = "sp|P99999|NOPROT_HUMAN" + + t + + "xyz789" + + t + + "100" + + t + + "No hits\n" let records = @src.parse_interproscan(data) assert_eq(records.length(), 0) } +///| test "ips_parse_missing_ipr" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -189,6 +265,7 @@ test "ips_parse_missing_ipr" { assert_eq(r.ipr_desc(), "") } +///| test "ips_parse_missing_go_terms" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -197,6 +274,7 @@ test "ips_parse_missing_go_terms" { assert_eq(r.go_terms().length(), 0) } +///| test "ips_parse_missing_go_terms_dash" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -205,29 +283,127 @@ test "ips_parse_missing_go_terms_dash" { assert_eq(r.go_terms().length(), 0) } +///| test "ips_parse_score_edge_cases" { let t = "\t" // Score is "-" → 0.0 - let data1 = "prot1" + t + "md5a" + t + "100" + t + "Pfam" + t + "PF01" + t + "desc" + t + "1" + t + "50" + t + "-" + t + "T" + t + "01-Jan-2024" + t + "-" + t + "-" + t + "-\n" + let data1 = "prot1" + + t + + "md5a" + + t + + "100" + + t + + "Pfam" + + t + + "PF01" + + t + + "desc" + + t + + "1" + + t + + "50" + + t + + "-" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "-" + + t + + "-" + + t + + "-\n" let r1 = @src.parse_interproscan(data1) assert_eq(r1.length(), 1) assert_eq(r1[0].score(), 0.0) // Score is "NaN" → 0.0 - let data2 = "prot2" + t + "md5b" + t + "100" + t + "Pfam" + t + "PF02" + t + "desc" + t + "1" + t + "50" + t + "NaN" + t + "T" + t + "01-Jan-2024" + t + "-" + t + "-" + t + "-\n" + let data2 = "prot2" + + t + + "md5b" + + t + + "100" + + t + + "Pfam" + + t + + "PF02" + + t + + "desc" + + t + + "1" + + t + + "50" + + t + + "NaN" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "-" + + t + + "-" + + t + + "-\n" let r2 = @src.parse_interproscan(data2) assert_eq(r2.length(), 1) assert_eq(r2[0].score(), 0.0) // Score is empty → 0.0 - let data3 = "prot3" + t + "md5c" + t + "100" + t + "Pfam" + t + "PF03" + t + "desc" + t + "1" + t + "50" + t + "" + t + "T" + t + "01-Jan-2024" + t + "-" + t + "-" + t + "-\n" + let data3 = "prot3" + + t + + "md5c" + + t + + "100" + + t + + "Pfam" + + t + + "PF03" + + t + + "desc" + + t + + "1" + + t + + "50" + + t + + "" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "-" + + t + + "-" + + t + + "-\n" let r3 = @src.parse_interproscan(data3) assert_eq(r3.length(), 1) assert_eq(r3[0].score(), 0.0) } +///| test "ips_parse_fewer_columns" { let t = "\t" // Line with only 10 columns should be padded to 14. - let data = "prot1" + t + "md5a" + t + "100" + t + "Pfam" + t + "PF01" + t + "desc" + t + "1" + t + "50" + t + "100.0" + t + "T\n" + let data = "prot1" + + t + + "md5a" + + t + + "100" + + t + + "Pfam" + + t + + "PF01" + + t + + "desc" + + t + + "1" + + t + + "50" + + t + + "100.0" + + t + + "T\n" let records = @src.parse_interproscan(data) assert_eq(records.length(), 1) assert_eq(records[0].date(), "") @@ -236,6 +412,7 @@ test "ips_parse_fewer_columns" { assert_eq(records[0].go_terms().length(), 0) } +///| test "ips_parse_tsv_alias" { // parse_interproscan and parse_interproscan_tsv should produce the same results. let data = @src.interproscan_sample_data() @@ -249,6 +426,7 @@ test "ips_parse_tsv_alias" { } } +///| test "ips_parse_skips_comment_lines_in_sample" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -264,12 +442,14 @@ test "ips_parse_skips_comment_lines_in_sample" { // Sample data validation // --------------------------------------------------------------------------- +///| test "ips_sample_data_has_8_records" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) assert_eq(records.length(), 8) } +///| test "ips_sample_data_proteins" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -280,6 +460,7 @@ test "ips_sample_data_proteins" { assert_eq(proteins[2], "sp|O15143|ABC_HUMAN") } +///| test "ips_sample_data_signatures" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -294,6 +475,7 @@ test "ips_sample_data_signatures" { // Filtering // --------------------------------------------------------------------------- +///| test "ips_filter_by_analysis_pfam" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -305,6 +487,7 @@ test "ips_filter_by_analysis_pfam" { } } +///| test "ips_filter_by_analysis_smart" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -315,6 +498,7 @@ test "ips_filter_by_analysis_smart" { } } +///| test "ips_filter_by_analysis_no_match" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -322,10 +506,13 @@ test "ips_filter_by_analysis_no_match" { assert_eq(none.length(), 0) } +///| test "ips_filter_by_protein" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) - let prot1 = @src.interproscan_filter_by_protein(records, "sp|P12345|PROT_HUMAN") + let prot1 = @src.interproscan_filter_by_protein( + records, "sp|P12345|PROT_HUMAN", + ) // P12345 has 3 records: Pfam, SMART, PROSITEPATTERNS. assert_eq(prot1.length(), 3) for r in prot1 { @@ -333,14 +520,18 @@ test "ips_filter_by_protein" { } } +///| test "ips_filter_by_protein_multiple" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) - let prot3 = @src.interproscan_filter_by_protein(records, "sp|O15143|ABC_HUMAN") + let prot3 = @src.interproscan_filter_by_protein( + records, "sp|O15143|ABC_HUMAN", + ) // O15143 has 3 records: Pfam, HAMMER, SMART. assert_eq(prot3.length(), 3) } +///| test "ips_filter_by_protein_no_match" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -348,6 +539,7 @@ test "ips_filter_by_protein_no_match" { assert_eq(none.length(), 0) } +///| test "ips_filter_on_empty_records" { let empty : Array[@src.InterproScanRecord] = Array::new() assert_eq(@src.interproscan_filter_by_analysis(empty, "Pfam").length(), 0) @@ -358,6 +550,7 @@ test "ips_filter_on_empty_records" { // Unique value extraction // --------------------------------------------------------------------------- +///| test "ips_get_unique_proteins" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -368,6 +561,7 @@ test "ips_get_unique_proteins" { assert_true(proteins.contains("sp|O15143|ABC_HUMAN")) } +///| test "ips_get_unique_signatures" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -383,12 +577,14 @@ test "ips_get_unique_signatures" { assert_true(sigs.contains("SM00150")) } +///| test "ips_get_unique_signatures_empty" { let empty : Array[@src.InterproScanRecord] = Array::new() let sigs = @src.interproscan_get_unique_signatures(empty) assert_eq(sigs.length(), 0) } +///| test "ips_get_go_terms" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -407,17 +603,71 @@ test "ips_get_go_terms" { assert_true(go.contains("GO:0044183")) } +///| test "ips_get_go_terms_empty" { let empty : Array[@src.InterproScanRecord] = Array::new() let go = @src.interproscan_get_go_terms(empty) assert_eq(go.length(), 0) } +///| test "ips_get_go_terms_dedup" { // Two records with the same GO term should produce only one entry. let t = "\t" - let data = "prot1" + t + "md5a" + t + "100" + t + "Pfam" + t + "PF01" + t + "desc" + t + "1" + t + "50" + t + "100.0" + t + "T" + t + "01-Jan-2024" + t + "IPR01" + t + "d1" + t + "GO:0003674\n" + - "prot2" + t + "md5b" + t + "200" + t + "SMART" + t + "SM01" + t + "desc" + t + "1" + t + "50" + t + "100.0" + t + "T" + t + "01-Jan-2024" + t + "IPR02" + t + "d2" + t + "GO:0003674|GO:0008150\n" + let data = "prot1" + + t + + "md5a" + + t + + "100" + + t + + "Pfam" + + t + + "PF01" + + t + + "desc" + + t + + "1" + + t + + "50" + + t + + "100.0" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "IPR01" + + t + + "d1" + + t + + "GO:0003674\n" + + "prot2" + + t + + "md5b" + + t + + "200" + + t + + "SMART" + + t + + "SM01" + + t + + "desc" + + t + + "1" + + t + + "50" + + t + + "100.0" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "IPR02" + + t + + "d2" + + t + + "GO:0003674|GO:0008150\n" let records = @src.parse_interproscan(data) let go = @src.interproscan_get_go_terms(records) assert_eq(go.length(), 2) @@ -429,6 +679,7 @@ test "ips_get_go_terms_dedup" { // Grouping // --------------------------------------------------------------------------- +///| test "ips_group_by_protein" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -448,6 +699,7 @@ test "ips_group_by_protein" { assert_eq(recs2.length(), 3) } +///| test "ips_group_by_protein_preserves_order" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -458,15 +710,43 @@ test "ips_group_by_protein_preserves_order" { assert_eq(groups[2].0, "sp|O15143|ABC_HUMAN") } +///| test "ips_group_by_protein_empty" { let empty : Array[@src.InterproScanRecord] = Array::new() let groups = @src.interproscan_group_by_protein(empty) assert_eq(groups.length(), 0) } +///| test "ips_group_by_protein_single" { let t = "\t" - let data = "prot1" + t + "md5a" + t + "100" + t + "Pfam" + t + "PF01" + t + "desc" + t + "1" + t + "50" + t + "100.0" + t + "T" + t + "01-Jan-2024" + t + "IPR01" + t + "d1" + t + "GO:0003674\n" + let data = "prot1" + + t + + "md5a" + + t + + "100" + + t + + "Pfam" + + t + + "PF01" + + t + + "desc" + + t + + "1" + + t + + "50" + + t + + "100.0" + + t + + "T" + + t + + "01-Jan-2024" + + t + + "IPR01" + + t + + "d1" + + t + + "GO:0003674\n" let records = @src.parse_interproscan(data) let groups = @src.interproscan_group_by_protein(records) assert_eq(groups.length(), 1) @@ -478,6 +758,7 @@ test "ips_group_by_protein_single" { // Summary // --------------------------------------------------------------------------- +///| test "ips_summary_basic" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -489,6 +770,7 @@ test "ips_summary_basic" { assert_true(s.contains("Unique analyses: 5")) } +///| test "ips_summary_lists_analyses" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -500,6 +782,7 @@ test "ips_summary_lists_analyses" { assert_true(s.contains("HAMMER")) } +///| test "ips_summary_empty" { let empty : Array[@src.InterproScanRecord] = Array::new() let s = @src.interproscan_summary(empty) @@ -513,6 +796,7 @@ test "ips_summary_empty" { // Full round-trip // --------------------------------------------------------------------------- +///| test "ips_roundtrip_parse_and_filter" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) @@ -525,6 +809,7 @@ test "ips_roundtrip_parse_and_filter" { assert_true(pfam_sigs.contains("PF00003")) } +///| test "ips_roundtrip_group_and_filter" { let data = @src.interproscan_sample_data() let records = @src.parse_interproscan(data) diff --git a/test/moonbit/isoform_switch_analyze_r_test.mbt b/test/moonbit/isoform_switch_analyze_r_test.mbt index 8a3bc66f..445bdad9 100644 --- a/test/moonbit/isoform_switch_analyze_r_test.mbt +++ b/test/moonbit/isoform_switch_analyze_r_test.mbt @@ -1,11 +1,13 @@ ///| - test "isoform_create_expression" { let isoform = @src.IsoformExpression::new( - "iso1", "gene1", [100.0, 150.0, 120.0], - [50.0, 75.0, 60.0], [40.0, 60.0, 48.0] + "iso1", + "gene1", + [100.0, 150.0, 120.0], + [50.0, 75.0, 60.0], + [40.0, 60.0, 48.0], ) - + assert_eq(isoform.isoform_id, "iso1") assert_eq(isoform.gene_id, "gene1") assert_eq(isoform.counts.length(), 3) @@ -13,63 +15,138 @@ test "isoform_create_expression" { assert_eq(isoform.fpkm.length(), 3) } +///| test "isoform_calculate_usage" { let isoform = @src.IsoformExpression::new( - "iso1", "gene1", [100.0, 150.0], [50.0, 75.0], [40.0, 60.0] + "iso1", + "gene1", + [100.0, 150.0], + [50.0, 75.0], + [40.0, 60.0], ) - + let usage = @src.bio_isoform_calculate_usage(isoform) assert_eq(usage.length(), 2) assert_eq(usage[0], 50.0) assert_eq(usage[1], 75.0) } +///| test "isoform_calculate_dpsi" { - let iso1 = @src.IsoformExpression::new("iso1", "gene1", [100.0, 200.0], [50.0, 150.0], [40.0, 120.0]) - let iso2 = @src.IsoformExpression::new("iso2", "gene1", [100.0, 50.0], [50.0, 50.0], [40.0, 40.0]) - + let iso1 = @src.IsoformExpression::new( + "iso1", + "gene1", + [100.0, 200.0], + [50.0, 150.0], + [40.0, 120.0], + ) + let iso2 = @src.IsoformExpression::new( + "iso2", + "gene1", + [100.0, 50.0], + [50.0, 50.0], + [40.0, 40.0], + ) + let dpsi = @src.bio_isoform_calculate_dpsi(iso1, iso2, [0], [1]) - + assert_true((dpsi - 0.25).abs() < 0.01) } +///| test "isoform_find_switches" { - let data = @src.SwitchAnalyzeRlist::new(["s1", "s2", "s3", "s4"], ["control", "control", "treatment", "treatment"]) - - let iso1 = @src.IsoformExpression::new("iso1", "gene1", [100.0, 100.0, 200.0, 200.0], [50.0, 50.0, 150.0, 150.0], [40.0, 40.0, 120.0, 120.0]) - let iso2 = @src.IsoformExpression::new("iso2", "gene1", [100.0, 100.0, 50.0, 50.0], [50.0, 50.0, 50.0, 50.0], [40.0, 40.0, 40.0, 40.0]) - - let data2 = data.add_isoform(iso1).add_isoform(iso2).add_gene_annotation("gene1", "Gene1") - + let data = @src.SwitchAnalyzeRlist::new(["s1", "s2", "s3", "s4"], [ + "control", "control", "treatment", "treatment", + ]) + + let iso1 = @src.IsoformExpression::new( + "iso1", + "gene1", + [100.0, 100.0, 200.0, 200.0], + [50.0, 50.0, 150.0, 150.0], + [40.0, 40.0, 120.0, 120.0], + ) + let iso2 = @src.IsoformExpression::new( + "iso2", + "gene1", + [100.0, 100.0, 50.0, 50.0], + [50.0, 50.0, 50.0, 50.0], + [40.0, 40.0, 40.0, 40.0], + ) + + let data2 = data + .add_isoform(iso1) + .add_isoform(iso2) + .add_gene_annotation("gene1", "Gene1") + let switches = @src.bio_isoform_find_switches(data2, 0.1, 0.05) - + assert_true(switches.length() >= 1) } +///| test "isoform_switch_summary" { let switches = [ - @src.IsoformSwitch::new("gene1", "Gene1", "iso1", "iso2", 0.3, 0.25, 0.001, 0.005, "isoform1_up", ["significant_isoform_switch"]), - @src.IsoformSwitch::new("gene2", "Gene2", "iso3", "iso4", -0.25, -0.2, 0.002, 0.01, "isoform2_up", ["significant_isoform_switch"]), + @src.IsoformSwitch::new( + "gene1", + "Gene1", + "iso1", + "iso2", + 0.3, + 0.25, + 0.001, + 0.005, + "isoform1_up", + ["significant_isoform_switch"], + ), + @src.IsoformSwitch::new( + "gene2", + "Gene2", + "iso3", + "iso4", + -0.25, + -0.2, + 0.002, + 0.01, + "isoform2_up", + ["significant_isoform_switch"], + ), ] - + let summary = @src.bio_isoform_switch_summary(switches) - + assert_true(summary.contains("Total switches")) assert_true(summary.contains("Gene1")) assert_true(summary.contains("Gene2")) } +///| test "isoform_plot_psi" { let data = @src.SwitchAnalyzeRlist::new(["s1", "s2"], ["control", "treatment"]) - - let iso1 = @src.IsoformExpression::new("iso1", "gene1", [100.0, 200.0], [50.0, 100.0], [40.0, 80.0]) - let iso2 = @src.IsoformExpression::new("iso2", "gene1", [100.0, 100.0], [50.0, 50.0], [40.0, 40.0]) - - let data2 = data.add_isoform(iso1).add_isoform(iso2).add_gene_annotation("gene1", "Gene1") - + + let iso1 = @src.IsoformExpression::new( + "iso1", + "gene1", + [100.0, 200.0], + [50.0, 100.0], + [40.0, 80.0], + ) + let iso2 = @src.IsoformExpression::new( + "iso2", + "gene1", + [100.0, 100.0], + [50.0, 50.0], + [40.0, 40.0], + ) + + let data2 = data + .add_isoform(iso1) + .add_isoform(iso2) + .add_gene_annotation("gene1", "Gene1") + let plot = @src.bio_isoform_plot_psi(data2, "gene1") - + assert_true(plot.contains("Gene1")) assert_true(plot.contains("iso1")) assert_true(plot.contains("iso2")) -} \ No newline at end of file +} diff --git a/test/moonbit/karyoploter_test.mbt b/test/moonbit/karyoploter_test.mbt index fee420d6..52655080 100644 --- a/test/moonbit/karyoploter_test.mbt +++ b/test/moonbit/karyoploter_test.mbt @@ -1,12 +1,12 @@ ///| /// Test file for karyoploteR module. - test "karyotype_new" { let plot = @src.KaryotypePlot::new("hg38") assert_eq(plot.get_genome(), "hg38") assert_true(plot.get_chromosomes().length() > 0) } +///| test "karyotype_chromosomes" { let plot = @src.KaryotypePlot::new("hg38") let chroms = plot.get_chromosomes() @@ -15,42 +15,71 @@ test "karyotype_chromosomes" { assert_true(chroms.contains("chrY")) } +///| test "karyotype_chromosome_size" { let plot = @src.KaryotypePlot::new("hg38") let size = plot.get_chromosome_size("chr1") assert_eq(size, 248956422) } +///| test "karyotype_unknown_chromosome" { let plot = @src.KaryotypePlot::new("hg38") let size = plot.get_chromosome_size("chrUnknown") assert_eq(size, 0) } +///| test "karyotype_add_track" { let plot = @src.KaryotypePlot::new("hg38") - let track = @src.KaryotypeTrack::new("t1", @src.track_type_points(), "chr1", 0, 248956422, "Test Track") + let track = @src.KaryotypeTrack::new( + "t1", + @src.track_type_points(), + "chr1", + 0, + 248956422, + "Test Track", + ) let plot2 = plot.add_track(track) assert_eq(plot2.get_n_tracks(), 1) } +///| test "karyotype_add_region" { let plot = @src.KaryotypePlot::new("hg38") - let region = @src.KaryotypeRegion::new("chr1", 1000000, 2000000, "Region 1", "#FF0000") + let region = @src.KaryotypeRegion::new( + "chr1", 1000000, 2000000, "Region 1", "#FF0000", + ) let plot2 = plot.add_region(region) assert_eq(plot2.get_n_regions(), 1) } +///| test "track_new" { - let track = @src.KaryotypeTrack::new("t1", @src.track_type_points(), "chr1", 0, 1000000, "My Track") + let track = @src.KaryotypeTrack::new( + "t1", + @src.track_type_points(), + "chr1", + 0, + 1000000, + "My Track", + ) assert_eq(track.track_id, "t1") assert_eq(track.chromosome, "chr1") assert_eq(track.start, 0) assert_eq(track.end, 1000000) } +///| test "track_add_point" { - let track = @src.KaryotypeTrack::new("t1", @src.track_type_points(), "chr1", 0, 1000000, "Test") + let track = @src.KaryotypeTrack::new( + "t1", + @src.track_type_points(), + "chr1", + 0, + 1000000, + "Test", + ) let point = @src.TrackPoint::new("chr1", 500000, 0.8, "peak") let track2 = track.add_point(point) assert_eq(track2.get_n_points(), 1) @@ -58,20 +87,44 @@ test "track_add_point" { assert_eq(data[0].position, 500000) } +///| test "track_set_color" { - let track = @src.KaryotypeTrack::new("t1", @src.track_type_points(), "chr1", 0, 1000000, "Test") + let track = @src.KaryotypeTrack::new( + "t1", + @src.track_type_points(), + "chr1", + 0, + 1000000, + "Test", + ) let track2 = track.set_color("#FF0000") assert_eq(track2.color, "#FF0000") } +///| test "track_set_y_range" { - let track = @src.KaryotypeTrack::new("t1", @src.track_type_points(), "chr1", 0, 1000000, "Test") + let track = @src.KaryotypeTrack::new( + "t1", + @src.track_type_points(), + "chr1", + 0, + 1000000, + "Test", + ) let track2 = track.set_y_range(0.0, 2.0) assert_eq(track2.y_max, 2.0) } +///| test "track_filter_chromosome" { - let track = @src.KaryotypeTrack::new("t1", @src.track_type_points(), "chr1", 0, 248956422, "Test") + let track = @src.KaryotypeTrack::new( + "t1", + @src.track_type_points(), + "chr1", + 0, + 248956422, + "Test", + ) let p1 = @src.TrackPoint::new("chr1", 1000000, 0.5, "") let p2 = @src.TrackPoint::new("chr2", 2000000, 0.8, "") let track2 = track.add_point(p1) @@ -80,6 +133,7 @@ test "track_filter_chromosome" { assert_eq(filtered.get_n_points(), 1) } +///| test "track_point_new" { let pt = @src.TrackPoint::new("chr1", 500000, 0.75, "test_point") assert_eq(pt.chromosome, "chr1") @@ -88,19 +142,24 @@ test "track_point_new" { assert_eq(pt.label, "test_point") } +///| test "karyotype_region_new" { - let region = @src.KaryotypeRegion::new("chr1", 1000, 2000, "Region", "#FF0000") + let region = @src.KaryotypeRegion::new( + "chr1", 1000, 2000, "Region", "#FF0000", + ) assert_eq(region.chromosome, "chr1") assert_eq(region.start, 1000) assert_eq(region.end, 2000) } +///| test "ideogram_band_new" { let band = @src.IdeogramBand::new("chr1", 0, 5000000, "p36.3", "gneg") assert_eq(band.chromosome, "chr1") assert_eq(band.band_name, "p36.3") } +///| test "track_type_to_string" { assert_eq(@src.track_type_points().to_string(), "points") assert_eq(@src.track_type_lines().to_string(), "lines") @@ -109,6 +168,7 @@ test "track_type_to_string" { assert_eq(@src.track_type_ideogram().to_string(), "ideogram") } +///| test "karyotype_to_ascii" { let plot = @src.karyotype_sample() let ascii = plot.to_ascii("chr1", 60) @@ -117,6 +177,7 @@ test "karyotype_to_ascii" { assert_true(ascii.contains("chr1")) } +///| test "karyotype_summary" { let plot = @src.karyotype_sample() let summary = plot.summary() @@ -125,12 +186,14 @@ test "karyotype_summary" { assert_true(summary.contains("chr1")) } +///| test "karyotype_unknown_genome" { let plot = @src.KaryotypePlot::new("mm10") assert_eq(plot.get_genome(), "mm10") assert_eq(plot.get_chromosomes().length(), 0) } +///| test "karyotype_sample" { let plot = @src.karyotype_sample() assert_true(plot.get_n_tracks() >= 2) @@ -138,8 +201,9 @@ test "karyotype_sample" { assert_eq(plot.get_genome(), "hg38") } +///| test "karyotype_ascii_unknown_chr" { let plot = @src.karyotype_sample() let ascii = plot.to_ascii("chr99", 60) assert_true(ascii.contains("not found")) -} \ No newline at end of file +} diff --git a/test/moonbit/kgml_test.mbt b/test/moonbit/kgml_test.mbt index c9077458..75078a22 100644 --- a/test/moonbit/kgml_test.mbt +++ b/test/moonbit/kgml_test.mbt @@ -19,6 +19,7 @@ test "kgml_graphics_creation" { assert_eq(g.bgcolor(), "#BFFFBF") } +///| test "kgml_entry_creation" { let e = @src.KgmlEntry::new(1, "ko:K00844", "gene") assert_eq(e.id(), 1) @@ -30,12 +31,14 @@ test "kgml_entry_creation" { assert_eq(e.components().length(), 0) } +///| test "kgml_subtype_creation" { let st = @src.KgmlSubType::new("compound", "C00118") assert_eq(st.name(), "compound") assert_eq(st.value(), "C00118") } +///| test "kgml_relation_creation" { let r = @src.KgmlRelation::new(1, 2, "ECrel") assert_eq(r.entry1(), 1) @@ -44,6 +47,7 @@ test "kgml_relation_creation" { assert_eq(r.subtypes().length(), 0) } +///| test "kgml_reaction_creation" { let rxn = @src.KgmlReaction::new("rn:R01786", "irreversible") assert_eq(rxn.name(), "rn:R01786") @@ -52,6 +56,7 @@ test "kgml_reaction_creation" { assert_eq(rxn.products().length(), 0) } +///| test "kgml_pathway_creation" { let p = @src.KgmlPathway::new("path:ko00010", "ko", "00010", "Glycolysis") assert_eq(p.name(), "path:ko00010") @@ -69,6 +74,7 @@ test "kgml_pathway_creation" { // XML parsing // --------------------------------------------------------------------------- +///| test "kgml_parse_basic_pathway" { let xml = @src.kgml_sample_pathway() let pw = @src.parse_kgml(xml) @@ -82,6 +88,7 @@ test "kgml_parse_basic_pathway" { assert_true(p.link().length() > 0) } +///| test "kgml_parse_entries" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -103,6 +110,7 @@ test "kgml_parse_entries" { assert_eq(e5.etype(), "map") } +///| test "kgml_parse_entry_graphics" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -120,6 +128,7 @@ test "kgml_parse_entry_graphics" { assert_eq(gfx.bgcolor(), "#BFFFBF") } +///| test "kgml_parse_relations" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -133,6 +142,7 @@ test "kgml_parse_relations" { assert_eq(r1.subtypes()[0].value(), "C00118") } +///| test "kgml_parse_reactions" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -152,11 +162,13 @@ test "kgml_parse_reactions" { assert_eq(r2.products().length(), 2) } +///| test "kgml_parse_invalid_returns_none" { let result = @src.parse_kgml("not a kgml file") assert_true(result.is_none()) } +///| test "kgml_parse_empty_returns_none" { let result = @src.parse_kgml("") assert_true(result.is_none()) @@ -166,6 +178,7 @@ test "kgml_parse_empty_returns_none" { // Query methods // --------------------------------------------------------------------------- +///| test "kgml_get_entry_by_id" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -176,6 +189,7 @@ test "kgml_get_entry_by_id" { assert_true(none.is_none()) } +///| test "kgml_get_entries_by_type" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -187,6 +201,7 @@ test "kgml_get_entries_by_type" { assert_eq(maps.length(), 1) } +///| test "kgml_get_relations_for_entry" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -205,6 +220,7 @@ test "kgml_get_relations_for_entry" { // Serialization // --------------------------------------------------------------------------- +///| test "kgml_to_string_roundtrip" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -222,6 +238,7 @@ test "kgml_to_string_roundtrip" { assert_eq(p2u.reactions().length(), p.reactions().length()) } +///| test "kgml_to_string_contains_pathway_tag" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -231,6 +248,7 @@ test "kgml_to_string_contains_pathway_tag" { assert_true(s.contains("")) } +///| test "kgml_to_string_contains_entries" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -240,6 +258,7 @@ test "kgml_to_string_contains_entries" { assert_true(s.contains("cpd:C00118")) } +///| test "kgml_to_string_contains_relations" { let xml = @src.kgml_sample_pathway() let p = @src.parse_kgml(xml).unwrap() @@ -249,6 +268,7 @@ test "kgml_to_string_contains_relations" { assert_true(s.contains(" @src.SpatialExperiment { ignore( @src.se_add_col( experiment, - Map( - [ - ("cellID", cell.cell_id), - ("imageID", cell.image_id), - ("cellType", cell.cell_type), - ], - ), + Map([ + ("cellID", cell.cell_id), + ("imageID", cell.image_id), + ("cellType", cell.cell_type), + ]), ), ) ignore( @@ -117,16 +115,12 @@ fn lisa_test_experiment() -> @src.SpatialExperiment { ///| test "lisaClust: curve and window helpers expose both modes" { - assert_true( - @src.lisa_k_curve() is @src.LisaCurveKind::LisaStandardizedK, - ) + assert_true(@src.lisa_k_curve() is @src.LisaCurveKind::LisaStandardizedK) assert_true(@src.lisa_l_curve() is @src.LisaCurveKind::LisaCenteredL) assert_true( @src.lisa_rectangle_window() is @src.LisaWindowKind::LisaRectangle, ) - assert_true( - @src.lisa_convex_window() is @src.LisaWindowKind::LisaConvexHull, - ) + assert_true(@src.lisa_convex_window() is @src.LisaWindowKind::LisaConvexHull) } ///| @@ -328,13 +322,7 @@ test "lisaClust: cell constructor validates identifiers" { test "lisaClust: cell constructor rejects non-finite coordinates" { let failed = try { ignore( - @src.LisaCell::create( - "cell", - "image", - "A", - @double.not_a_number, - 0.0, - ), + @src.LisaCell::create("cell", "image", "A", @double.not_a_number, 0.0), ) false } catch { @@ -345,10 +333,7 @@ test "lisaClust: cell constructor rejects non-finite coordinates" { ///| test "lisaClust: curve matrix exposes stable dimensions and names" { - let curves = @src.lisa_curves( - lisa_test_cells(), - config=lisa_test_config(), - ) catch { + let curves = @src.lisa_curves(lisa_test_cells(), config=lisa_test_config()) catch { _ => abort("lisaClust curves should compute") } assert_eq(curves.n_cells(), 8) @@ -361,10 +346,7 @@ test "lisaClust: curve matrix exposes stable dimensions and names" { ///| test "lisaClust: feature lookup follows target-major radius order" { - let curves = @src.lisa_curves( - lisa_test_cells(), - config=lisa_test_config(), - ) catch { + let curves = @src.lisa_curves(lisa_test_cells(), config=lisa_test_config()) catch { _ => abort("lisaClust curves should compute") } assert_eq(curves.feature_index("A", 1.5), 0) @@ -554,16 +536,10 @@ test "lisaClust: KDE weighting changes curves under inhomogeneous density" { ) catch { _ => abort("broad KDE configuration should be valid") } - let narrow_curves = @src.lisa_curves( - lisa_test_exact_cells(), - config=narrow, - ) catch { + let narrow_curves = @src.lisa_curves(lisa_test_exact_cells(), config=narrow) catch { _ => abort("narrow KDE curves should compute") } - let broad_curves = @src.lisa_curves( - lisa_test_exact_cells(), - config=broad, - ) catch { + let broad_curves = @src.lisa_curves(lisa_test_exact_cells(), config=broad) catch { _ => abort("broad KDE curves should compute") } let feature = narrow_curves.feature_index("B", 2.0) @@ -591,10 +567,7 @@ test "lisaClust: generated curves are finite" { ///| test "lisaClust: curve lookup returns a defensive copy" { - let curves = @src.lisa_curves( - lisa_test_cells(), - config=lisa_test_config(), - ) catch { + let curves = @src.lisa_curves(lisa_test_cells(), config=lisa_test_config()) catch { _ => abort("lisaClust curves should compute") } let curve = match curves.curve_for_cell("a1") { @@ -762,10 +735,7 @@ test "lisaClust: region enrichment uses observed over independence expectation" ///| test "lisaClust: top enrichments are sorted and filtered" { let result = lisa_test_result() - let top = result.top_enrichments( - limit=3, - minimum_relative_frequency=0.0, - ) catch { + let top = result.top_enrichments(limit=3, minimum_relative_frequency=0.0) catch { _ => abort("top enrichments should succeed") } assert_eq(top.length(), 3) @@ -803,10 +773,7 @@ test "lisaClust: summary reports cells features and regions" { ///| test "lisaClust: cluster count cannot exceed cells" { - let curves = @src.lisa_curves( - lisa_test_cells(), - config=lisa_test_config(), - ) catch { + let curves = @src.lisa_curves(lisa_test_cells(), config=lisa_test_config()) catch { _ => abort("lisaClust curves should compute") } let config = lisa_test_config(n_clusters=9) @@ -939,10 +906,7 @@ test "lisaClust: SpatialExperiment rejects coordinate mismatch" { ignore(experiment.spatial_coords.pop()) let failed = try { ignore( - @src.lisaclust_spatial_experiment( - experiment, - config=lisa_test_config(), - ), + @src.lisaclust_spatial_experiment(experiment, config=lisa_test_config()), ) false } catch { @@ -957,10 +921,7 @@ test "lisaClust: SpatialExperiment rejects missing required columns" { ignore(experiment.col_data[0].remove("cellType")) let failed = try { ignore( - @src.lisaclust_spatial_experiment( - experiment, - config=lisa_test_config(), - ), + @src.lisaclust_spatial_experiment(experiment, config=lisa_test_config()), ) false } catch { diff --git a/test/moonbit/lowess_test.mbt b/test/moonbit/lowess_test.mbt index 958cd3a7..b39e9c8d 100644 --- a/test/moonbit/lowess_test.mbt +++ b/test/moonbit/lowess_test.mbt @@ -22,7 +22,7 @@ test "lowess_tricube_weight_above_one" { ///| test "lowess_tricube_weight_at_half" { let result = @src.lowess_tricube_weight(0.5) - let expected = (1.0 - 0.5 * 0.5 * 0.5) + let expected = 1.0 - 0.5 * 0.5 * 0.5 let expected_cubed = expected * expected * expected assert_true((result - expected_cubed).abs() < 0.001) } @@ -54,7 +54,7 @@ test "lowess_bisquare_weight_above_one" { ///| test "lowess_bisquare_weight_at_half" { let result = @src.lowess_bisquare_weight(0.5) - let expected = (1.0 - 0.5 * 0.5) + let expected = 1.0 - 0.5 * 0.5 let expected_squared = expected * expected assert_true((result - expected_squared).abs() < 0.001) } @@ -99,7 +99,9 @@ test "lowess_weighted_linear_regression_weighted" { let y = [1.0, 3.0, 5.0, 7.0] let w = [1.0, 1.0, 1.0, 1.0] let (intercept, slope) = @src.lowess_weighted_linear_regression(x, y, w) - let (intercept2, slope2) = @src.lowess_weighted_linear_regression(x, y, [2.0, 2.0, 2.0, 2.0]) + let (intercept2, slope2) = @src.lowess_weighted_linear_regression(x, y, [ + 2.0, 2.0, 2.0, 2.0, + ]) assert_true((intercept - intercept2).abs() < 0.001) assert_true((slope - slope2).abs() < 0.001) } @@ -113,7 +115,11 @@ test "lowess_weighted_linear_regression_empty" { ///| test "lowess_weighted_linear_regression_single_point" { - let (intercept, slope) = @src.lowess_weighted_linear_regression([1.0], [5.0], [1.0]) + let (intercept, slope) = @src.lowess_weighted_linear_regression( + [1.0], + [5.0], + [1.0], + ) assert_eq(intercept, 5.0) assert_eq(slope, 0.0) } diff --git a/test/moonbit/ma_align_test.mbt b/test/moonbit/ma_align_test.mbt index 1199d1f9..3fa6fe44 100644 --- a/test/moonbit/ma_align_test.mbt +++ b/test/moonbit/ma_align_test.mbt @@ -20,7 +20,11 @@ test "ma_aligner_with_params" { ///| test "add_structure" { let a = @src.ma_aligner_new() - let coords : Array[(Double, Double, Double)] = [(1.0, 2.0, 3.0), (4.0, 5.0, 6.0), (7.0, 8.0, 9.0)] + let coords : Array[(Double, Double, Double)] = [ + (1.0, 2.0, 3.0), + (4.0, 5.0, 6.0), + (7.0, 8.0, 9.0), + ] let seq = "ALA" let res = ["ALA", "LEU", "ALA"] let s = @src.add_structure(a, "struct1", coords, seq, res) @@ -31,7 +35,11 @@ test "add_structure" { ///| test "ma_center_coordinates" { - let coords : Array[(Double, Double, Double)] = [(1.0, 2.0, 3.0), (4.0, 5.0, 6.0), (7.0, 8.0, 9.0)] + let coords : Array[(Double, Double, Double)] = [ + (1.0, 2.0, 3.0), + (4.0, 5.0, 6.0), + (7.0, 8.0, 9.0), + ] let centered = @src.ma_center_coordinates(coords) assert_eq(centered.length(), 3) let mut sum_x = 0.0 @@ -51,8 +59,16 @@ test "ma_center_coordinates" { ///| test "ma_compute_distance_matrix" { - let coords1 : Array[(Double, Double, Double)] = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (0.0, 1.0, 0.0)] - let coords2 : Array[(Double, Double, Double)] = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (0.0, 1.0, 0.0)] + let coords1 : Array[(Double, Double, Double)] = [ + (0.0, 0.0, 0.0), + (1.0, 0.0, 0.0), + (0.0, 1.0, 0.0), + ] + let coords2 : Array[(Double, Double, Double)] = [ + (0.0, 0.0, 0.0), + (1.0, 0.0, 0.0), + (0.0, 1.0, 0.0), + ] let dm = @src.ma_compute_distance_matrix(coords1, coords2) assert_eq(dm.length(), 3) assert_eq(dm[0].length(), 3) @@ -60,30 +76,51 @@ test "ma_compute_distance_matrix" { ///| test "ma_align_pairwise_identical" { - let coords : Array[(Double, Double, Double)] = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)] + let coords : Array[(Double, Double, Double)] = [ + (1.0, 0.0, 0.0), + (0.0, 1.0, 0.0), + (0.0, 0.0, 1.0), + ] let (rotation, rmsd) = @src.ma_align_pairwise(coords, coords) assert_true(rmsd < 0.01) } ///| test "ma_align_pairwise_different_scale" { - let coords1 : Array[(Double, Double, Double)] = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)] - let coords2 : Array[(Double, Double, Double)] = [(2.0, 0.0, 0.0), (0.0, 2.0, 0.0), (0.0, 0.0, 2.0)] + let coords1 : Array[(Double, Double, Double)] = [ + (1.0, 0.0, 0.0), + (0.0, 1.0, 0.0), + (0.0, 0.0, 1.0), + ] + let coords2 : Array[(Double, Double, Double)] = [ + (2.0, 0.0, 0.0), + (0.0, 2.0, 0.0), + (0.0, 0.0, 2.0), + ] let (rotation, rmsd) = @src.ma_align_pairwise(coords1, coords2) assert_true(rmsd < 5.0) } ///| test "compute_rmsd_identical" { - let coords : Array[(Double, Double, Double)] = [(1.0, 2.0, 3.0), (4.0, 5.0, 6.0)] + let coords : Array[(Double, Double, Double)] = [ + (1.0, 2.0, 3.0), + (4.0, 5.0, 6.0), + ] let rmsd = @src.compute_rmsd(coords, coords) assert_true(rmsd < 0.01) } ///| test "compute_rmsd_different" { - let coords1 : Array[(Double, Double, Double)] = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0)] - let coords2 : Array[(Double, Double, Double)] = [(10.0, 0.0, 0.0), (11.0, 0.0, 0.0)] + let coords1 : Array[(Double, Double, Double)] = [ + (0.0, 0.0, 0.0), + (1.0, 0.0, 0.0), + ] + let coords2 : Array[(Double, Double, Double)] = [ + (10.0, 0.0, 0.0), + (11.0, 0.0, 0.0), + ] let rmsd = @src.compute_rmsd(coords1, coords2) assert_true(rmsd > 5.0) } @@ -91,7 +128,11 @@ test "compute_rmsd_different" { ///| test "align_structures_single" { let a = @src.ma_aligner_new() - let coords : Array[(Double, Double, Double)] = [(1.0, 2.0, 3.0), (4.0, 5.0, 6.0), (7.0, 8.0, 9.0)] + let coords : Array[(Double, Double, Double)] = [ + (1.0, 2.0, 3.0), + (4.0, 5.0, 6.0), + (7.0, 8.0, 9.0), + ] let seq = "ALA" let res = ["ALA", "LEU", "ALA"] let s = @src.add_structure(a, "s1", coords, seq, res) @@ -102,8 +143,16 @@ test "align_structures_single" { ///| test "align_structures_two" { let a = @src.ma_aligner_new() - let coords1 : Array[(Double, Double, Double)] = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (0.0, 1.0, 0.0)] - let coords2 : Array[(Double, Double, Double)] = [(10.0, 10.0, 0.0), (11.0, 10.0, 0.0), (10.0, 11.0, 0.0)] + let coords1 : Array[(Double, Double, Double)] = [ + (0.0, 0.0, 0.0), + (1.0, 0.0, 0.0), + (0.0, 1.0, 0.0), + ] + let coords2 : Array[(Double, Double, Double)] = [ + (10.0, 10.0, 0.0), + (11.0, 10.0, 0.0), + (10.0, 11.0, 0.0), + ] let s1 = @src.add_structure(a, "s1", coords1, "AAA", ["ALA", "ALA", "ALA"]) let s2 = @src.add_structure(a, "s2", coords2, "BBB", ["ALA", "ALA", "ALA"]) let result = @src.align_structures(a, [s1, s2]) @@ -141,8 +190,16 @@ test "build_conservation_profile_different" { ///| test "get_conservation" { let a = @src.ma_aligner_new() - let coords1 : Array[(Double, Double, Double)] = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (0.0, 1.0, 0.0)] - let coords2 : Array[(Double, Double, Double)] = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (0.0, 1.0, 0.0)] + let coords1 : Array[(Double, Double, Double)] = [ + (0.0, 0.0, 0.0), + (1.0, 0.0, 0.0), + (0.0, 1.0, 0.0), + ] + let coords2 : Array[(Double, Double, Double)] = [ + (0.0, 0.0, 0.0), + (1.0, 0.0, 0.0), + (0.0, 1.0, 0.0), + ] let s1 = @src.add_structure(a, "s1", coords1, "AAA", ["ALA", "ALA", "ALA"]) let s2 = @src.add_structure(a, "s2", coords2, "AAA", ["ALA", "ALA", "ALA"]) let result = @src.align_structures(a, [s1, s2]) @@ -153,8 +210,14 @@ test "get_conservation" { ///| test "get_rmsd_matrix" { let a = @src.ma_aligner_new() - let coords1 : Array[(Double, Double, Double)] = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0)] - let coords2 : Array[(Double, Double, Double)] = [(0.0, 0.0, 0.0), (1.0, 0.0, 0.0)] + let coords1 : Array[(Double, Double, Double)] = [ + (0.0, 0.0, 0.0), + (1.0, 0.0, 0.0), + ] + let coords2 : Array[(Double, Double, Double)] = [ + (0.0, 0.0, 0.0), + (1.0, 0.0, 0.0), + ] let s1 = @src.add_structure(a, "s1", coords1, "AA", ["ALA", "ALA"]) let s2 = @src.add_structure(a, "s2", coords2, "AA", ["ALA", "ALA"]) let result = @src.align_structures(a, [s1, s2]) @@ -166,8 +229,11 @@ test "get_rmsd_matrix" { ///| test "apply_rotation_identity" { - let coords : Array[(Double, Double, Double)] = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0)] + let coords : Array[(Double, Double, Double)] = [ + (1.0, 0.0, 0.0), + (0.0, 1.0, 0.0), + ] let identity : (Double, Double, Double) = (0.0, 0.0, 0.0) let _result = @src.apply_rotation(coords, identity) assert_true(true) -} \ No newline at end of file +} diff --git a/test/moonbit/maf_test.mbt b/test/moonbit/maf_test.mbt index 1b81bc96..cc38054e 100644 --- a/test/moonbit/maf_test.mbt +++ b/test/moonbit/maf_test.mbt @@ -137,12 +137,12 @@ test "maf_alignment_total_length" { let seq1 = @src.new_maf_sequence("seq1", 0, 10, "+", 100, "ACGTACGTAC") block1 = @src.maf_block_add_seq(block1, seq1) ali = @src.maf_add_block(ali, block1) - + let mut block2 = @src.new_maf_block() let seq2 = @src.new_maf_sequence("seq1", 10, 5, "+", 100, "GTACG") block2 = @src.maf_block_add_seq(block2, seq2) ali = @src.maf_add_block(ali, block2) - + assert_eq(@src.maf_total_length(ali), 15) } @@ -156,7 +156,7 @@ test "maf_alignment_seq_names" { block = @src.maf_block_add_seq(block, seq1) block = @src.maf_block_add_seq(block, seq2) ali = @src.maf_add_block(ali, block) - + let names = @src.maf_all_seq_names(ali) assert_eq(names.length(), 2) assert_true(names.contains("human.chr1")) @@ -224,13 +224,19 @@ test "maf_select_seqs" { /// Test maf_filter_by_length. test "maf_filter_by_length" { let mut ali = @src.new_maf_alignment() - + let mut block1 = @src.new_maf_block() block1 = @src.maf_block_set_score(block1, Some(100.0)) - block1 = @src.maf_block_add_seq(block1, @src.new_maf_sequence("s1", 0, 100, "+", 1000, "ACGTACGTACGTACGTACGT")) - block1 = @src.maf_block_add_seq(block1, @src.new_maf_sequence("s2", 0, 100, "+", 1000, "ACGTACGTACGTACGTACGT")) + block1 = @src.maf_block_add_seq( + block1, + @src.new_maf_sequence("s1", 0, 100, "+", 1000, "ACGTACGTACGTACGTACGT"), + ) + block1 = @src.maf_block_add_seq( + block1, + @src.new_maf_sequence("s2", 0, 100, "+", 1000, "ACGTACGTACGTACGTACGT"), + ) ali = @src.maf_add_block(ali, block1) - + let filtered = @src.maf_filter_by_length(ali, 5) assert_eq(@src.maf_num_blocks(filtered), 1) } @@ -241,10 +247,16 @@ test "maf_stats" { let mut ali = @src.new_maf_alignment() let mut block = @src.new_maf_block() block = @src.maf_block_set_score(block, Some(100.0)) - block = @src.maf_block_add_seq(block, @src.new_maf_sequence("s1", 0, 10, "+", 1000, "ACGTACGTAC")) - block = @src.maf_block_add_seq(block, @src.new_maf_sequence("s2", 0, 10, "+", 1000, "ACGTACGTAC")) + block = @src.maf_block_add_seq( + block, + @src.new_maf_sequence("s1", 0, 10, "+", 1000, "ACGTACGTAC"), + ) + block = @src.maf_block_add_seq( + block, + @src.new_maf_sequence("s2", 0, 10, "+", 1000, "ACGTACGTAC"), + ) ali = @src.maf_add_block(ali, block) - + let stats = @src.maf_compute_stats(ali) assert_eq(stats.num_blocks, 1) assert_eq(stats.total_length, 10) @@ -284,21 +296,33 @@ test "maf_strand_info" { /// Test maf_merge_blocks. test "maf_merge_blocks" { let mut ali = @src.new_maf_alignment() - + let mut block1 = @src.new_maf_block() block1 = @src.maf_block_set_score(block1, Some(50.0)) - block1 = @src.maf_block_add_seq(block1, @src.new_maf_sequence("s1", 0, 5, "+", 1000, "ACGTG")) - block1 = @src.maf_block_add_seq(block1, @src.new_maf_sequence("s2", 0, 5, "+", 1000, "ACGTG")) - + block1 = @src.maf_block_add_seq( + block1, + @src.new_maf_sequence("s1", 0, 5, "+", 1000, "ACGTG"), + ) + block1 = @src.maf_block_add_seq( + block1, + @src.new_maf_sequence("s2", 0, 5, "+", 1000, "ACGTG"), + ) + let mut block2 = @src.new_maf_block() block2 = @src.maf_block_set_score(block2, Some(30.0)) - block2 = @src.maf_block_add_seq(block2, @src.new_maf_sequence("s1", 5, 5, "+", 1000, "TGCAC")) - block2 = @src.maf_block_add_seq(block2, @src.new_maf_sequence("s2", 5, 5, "+", 1000, "TGCAC")) - + block2 = @src.maf_block_add_seq( + block2, + @src.new_maf_sequence("s1", 5, 5, "+", 1000, "TGCAC"), + ) + block2 = @src.maf_block_add_seq( + block2, + @src.new_maf_sequence("s2", 5, 5, "+", 1000, "TGCAC"), + ) + ali = @src.maf_add_block(ali, block1) ali = @src.maf_add_block(ali, block2) - + let merged = @src.maf_merge_blocks(ali) // Should merge blocks with same sequences assert_true(@src.maf_num_blocks(merged) <= @src.maf_num_blocks(ali)) -} \ No newline at end of file +} diff --git a/test/moonbit/maftools_test.mbt b/test/moonbit/maftools_test.mbt index 54ff0f48..70a502e6 100644 --- a/test/moonbit/maftools_test.mbt +++ b/test/moonbit/maftools_test.mbt @@ -1,16 +1,9 @@ ///| test "maftools_create_mutation" { let mutation = @src.MAFMutation::new( - "TP53", - "chr17", - 7577121, - 7577121, - "C", - "T", - "Sample1", - "Missense_Mutation" + "TP53", "chr17", 7577121, 7577121, "C", "T", "Sample1", "Missense_Mutation", ) - + assert_eq(mutation.hugo_symbol, "TP53") assert_eq(mutation.chromosome, "chr17") assert_eq(mutation.start_position, 7577121) @@ -24,16 +17,9 @@ test "maftools_create_mutation" { ///| test "maftools_snv_detection" { let snv = @src.MAFMutation::new( - "TP53", - "chr17", - 7577121, - 7577121, - "C", - "T", - "Sample1", - "Missense_Mutation" + "TP53", "chr17", 7577121, 7577121, "C", "T", "Sample1", "Missense_Mutation", ) - + assert_true(snv.is_snv()) assert_false(snv.is_indel()) assert_false(snv.is_complex()) @@ -42,16 +28,9 @@ test "maftools_snv_detection" { ///| test "maftools_indel_detection" { let insertion = @src.MAFMutation::new( - "BRCA1", - "chr17", - 43091134, - 43091135, - "CT", - "CTT", - "Sample1", - "Frame_Shift_Ins" + "BRCA1", "chr17", 43091134, 43091135, "CT", "CTT", "Sample1", "Frame_Shift_Ins", ) - + assert_false(insertion.is_snv()) assert_true(insertion.is_indel()) assert_false(insertion.is_complex()) @@ -60,16 +39,9 @@ test "maftools_indel_detection" { ///| test "maftools_transition_detection" { let transition = @src.MAFMutation::new( - "TP53", - "chr17", - 7577121, - 7577121, - "C", - "T", - "Sample1", - "Missense_Mutation" + "TP53", "chr17", 7577121, 7577121, "C", "T", "Sample1", "Missense_Mutation", ) - + assert_true(transition.is_transition()) assert_false(transition.is_transversion()) } @@ -77,16 +49,9 @@ test "maftools_transition_detection" { ///| test "maftools_transversion_detection" { let transversion = @src.MAFMutation::new( - "TP53", - "chr17", - 7577121, - 7577121, - "C", - "A", - "Sample1", - "Missense_Mutation" + "TP53", "chr17", 7577121, 7577121, "C", "A", "Sample1", "Missense_Mutation", ) - + assert_false(transversion.is_transition()) assert_true(transversion.is_transversion()) } @@ -94,32 +59,18 @@ test "maftools_transversion_detection" { ///| test "maftools_maf_data_operations" { let mut maf = @src.MAFData::new() - + let mutation1 = @src.MAFMutation::new( - "TP53", - "chr17", - 7577121, - 7577121, - "C", - "T", - "Sample1", - "Missense_Mutation" + "TP53", "chr17", 7577121, 7577121, "C", "T", "Sample1", "Missense_Mutation", ) - + let mutation2 = @src.MAFMutation::new( - "BRCA1", - "chr17", - 43091134, - 43091134, - "A", - "G", - "Sample2", - "Nonsense_Mutation" + "BRCA1", "chr17", 43091134, 43091134, "A", "G", "Sample2", "Nonsense_Mutation", ) - + maf = maf.add_mutation(mutation1) maf = maf.add_mutation(mutation2) - + assert_eq(maf.count_mutations(), 2) assert_eq(maf.count_unique_genes(), 2) assert_eq(maf.count_unique_samples(), 2) @@ -128,32 +79,18 @@ test "maftools_maf_data_operations" { ///| test "maftools_filter_genes" { let mut maf = @src.MAFData::new() - + let mutation1 = @src.MAFMutation::new( - "TP53", - "chr17", - 7577121, - 7577121, - "C", - "T", - "Sample1", - "Missense_Mutation" + "TP53", "chr17", 7577121, 7577121, "C", "T", "Sample1", "Missense_Mutation", ) - + let mutation2 = @src.MAFMutation::new( - "BRCA1", - "chr17", - 43091134, - 43091134, - "A", - "G", - "Sample2", - "Nonsense_Mutation" + "BRCA1", "chr17", 43091134, 43091134, "A", "G", "Sample2", "Nonsense_Mutation", ) - + maf = maf.add_mutation(mutation1) maf = maf.add_mutation(mutation2) - + let filtered = maf.filter_genes(["TP53"]) assert_eq(filtered.count_mutations(), 1) assert_eq(filtered.count_unique_genes(), 1) @@ -162,32 +99,18 @@ test "maftools_filter_genes" { ///| test "maftools_filter_samples" { let mut maf = @src.MAFData::new() - + let mutation1 = @src.MAFMutation::new( - "TP53", - "chr17", - 7577121, - 7577121, - "C", - "T", - "Sample1", - "Missense_Mutation" + "TP53", "chr17", 7577121, 7577121, "C", "T", "Sample1", "Missense_Mutation", ) - + let mutation2 = @src.MAFMutation::new( - "BRCA1", - "chr17", - 43091134, - 43091134, - "A", - "G", - "Sample2", - "Nonsense_Mutation" + "BRCA1", "chr17", 43091134, 43091134, "A", "G", "Sample2", "Nonsense_Mutation", ) - + maf = maf.add_mutation(mutation1) maf = maf.add_mutation(mutation2) - + let filtered = maf.filter_samples(["Sample1"]) assert_eq(filtered.count_mutations(), 1) } @@ -195,46 +118,25 @@ test "maftools_filter_samples" { ///| test "maftools_mutation_spectrum" { let mut maf = @src.MAFData::new() - + let snv1 = @src.MAFMutation::new( - "TP53", - "chr17", - 7577121, - 7577121, - "C", - "T", - "Sample1", - "Missense_Mutation" + "TP53", "chr17", 7577121, 7577121, "C", "T", "Sample1", "Missense_Mutation", ) - + let snv2 = @src.MAFMutation::new( - "BRCA1", - "chr17", - 43091134, - 43091134, - "A", - "G", - "Sample1", - "Missense_Mutation" + "BRCA1", "chr17", 43091134, 43091134, "A", "G", "Sample1", "Missense_Mutation", ) - + let indel = @src.MAFMutation::new( - "EGFR", - "chr7", - 55086714, - 55086715, - "CT", - "CTT", - "Sample2", - "Frame_Shift_Ins" + "EGFR", "chr7", 55086714, 55086715, "CT", "CTT", "Sample2", "Frame_Shift_Ins", ) - + maf = maf.add_mutation(snv1) maf = maf.add_mutation(snv2) maf = maf.add_mutation(indel) - + let spectrum = @src.calculate_mutation_spectrum(maf) - + assert_eq(spectrum.snv_count, 2) assert_eq(spectrum.indel_count, 1) assert_eq(spectrum.complex_count, 0) @@ -243,7 +145,7 @@ test "maftools_mutation_spectrum" { ///| test "maftools_tmb_calculation" { let mut maf = @src.MAFData::new() - + let mut i = 0 while i < 100 { let mutation = @src.MAFMutation::new( @@ -254,17 +156,17 @@ test "maftools_tmb_calculation" { "C", "T", "Sample1", - "Missense_Mutation" + "Missense_Mutation", ) maf = maf.add_mutation(mutation) i = i + 1 } - + let tmb_result = @src.calculate_tmb(maf, 3.0e7) - + assert_eq(tmb_result.total_mutations, 100) assert_eq(tmb_result.coding_region_size, 3.0e7) - + // TMB should be 100 / 30000000 = 0.00000333... let expected_tmb = 100.0 / 3.0e7 let diff = tmb_result.tmb - expected_tmb @@ -274,19 +176,35 @@ test "maftools_tmb_calculation" { ///| test "maftools_co_occurrence_analysis" { let mut maf = @src.MAFData::new() - + // Sample1 has both TP53 and BRCA1 mutations - maf = maf.add_mutation(@src.MAFMutation::new("TP53", "chr17", 100, 100, "C", "T", "Sample1", "Missense_Mutation")) - maf = maf.add_mutation(@src.MAFMutation::new("BRCA1", "chr17", 200, 200, "A", "G", "Sample1", "Missense_Mutation")) - + maf = maf.add_mutation( + @src.MAFMutation::new( + "TP53", "chr17", 100, 100, "C", "T", "Sample1", "Missense_Mutation", + ), + ) + maf = maf.add_mutation( + @src.MAFMutation::new( + "BRCA1", "chr17", 200, 200, "A", "G", "Sample1", "Missense_Mutation", + ), + ) + // Sample2 has only TP53 mutation - maf = maf.add_mutation(@src.MAFMutation::new("TP53", "chr17", 300, 300, "C", "T", "Sample2", "Missense_Mutation")) - + maf = maf.add_mutation( + @src.MAFMutation::new( + "TP53", "chr17", 300, 300, "C", "T", "Sample2", "Missense_Mutation", + ), + ) + // Sample3 has only BRCA1 mutation - maf = maf.add_mutation(@src.MAFMutation::new("BRCA1", "chr17", 400, 400, "A", "G", "Sample3", "Missense_Mutation")) - + maf = maf.add_mutation( + @src.MAFMutation::new( + "BRCA1", "chr17", 400, 400, "A", "G", "Sample3", "Missense_Mutation", + ), + ) + let result = @src.analyze_co_occurrence(maf, "TP53", "BRCA1") - + assert_eq(result.co_occurrence, 1) assert_eq(result.mutual_exclusivity, 2) } @@ -294,7 +212,7 @@ test "maftools_co_occurrence_analysis" { ///| test "maftools_create_example" { let maf = @src.create_example_maf() - + assert_true(maf.count_mutations() > 0) assert_true(maf.count_unique_genes() > 0) assert_true(maf.count_unique_samples() > 0) @@ -304,7 +222,7 @@ test "maftools_create_example" { test "maftools_summarize" { let maf = @src.create_example_maf() let summary = @src.summarize_maf(maf) - + assert_true(summary.contains("MAF Summary")) assert_true(summary.contains("Total mutations:")) assert_true(summary.contains("TMB:")) @@ -314,7 +232,7 @@ test "maftools_summarize" { test "maftools_oncoplot_data" { let maf = @src.create_example_maf() let oncoplot = @src.generate_oncoplot_data(maf, 5) - + assert_true(oncoplot.genes.length() <= 5) assert_true(oncoplot.samples.length() > 0) assert_true(oncoplot.mutation_matrix.length() > 0) @@ -323,13 +241,25 @@ test "maftools_oncoplot_data" { ///| test "maftools_get_gene_mutation_counts" { let mut maf = @src.MAFData::new() - - maf = maf.add_mutation(@src.MAFMutation::new("TP53", "chr17", 100, 100, "C", "T", "Sample1", "Missense_Mutation")) - maf = maf.add_mutation(@src.MAFMutation::new("TP53", "chr17", 200, 200, "A", "G", "Sample2", "Missense_Mutation")) - maf = maf.add_mutation(@src.MAFMutation::new("BRCA1", "chr17", 300, 300, "C", "T", "Sample1", "Missense_Mutation")) - + + maf = maf.add_mutation( + @src.MAFMutation::new( + "TP53", "chr17", 100, 100, "C", "T", "Sample1", "Missense_Mutation", + ), + ) + maf = maf.add_mutation( + @src.MAFMutation::new( + "TP53", "chr17", 200, 200, "A", "G", "Sample2", "Missense_Mutation", + ), + ) + maf = maf.add_mutation( + @src.MAFMutation::new( + "BRCA1", "chr17", 300, 300, "C", "T", "Sample1", "Missense_Mutation", + ), + ) + let counts = @src.get_gene_mutation_counts(maf) - + assert_eq(counts.get("TP53").unwrap_or(0), 2) assert_eq(counts.get("BRCA1").unwrap_or(0), 1) } @@ -337,13 +267,25 @@ test "maftools_get_gene_mutation_counts" { ///| test "maftools_get_sample_mutation_counts" { let mut maf = @src.MAFData::new() - - maf = maf.add_mutation(@src.MAFMutation::new("TP53", "chr17", 100, 100, "C", "T", "Sample1", "Missense_Mutation")) - maf = maf.add_mutation(@src.MAFMutation::new("BRCA1", "chr17", 200, 200, "A", "G", "Sample1", "Missense_Mutation")) - maf = maf.add_mutation(@src.MAFMutation::new("EGFR", "chr7", 300, 300, "C", "T", "Sample2", "Missense_Mutation")) - + + maf = maf.add_mutation( + @src.MAFMutation::new( + "TP53", "chr17", 100, 100, "C", "T", "Sample1", "Missense_Mutation", + ), + ) + maf = maf.add_mutation( + @src.MAFMutation::new( + "BRCA1", "chr17", 200, 200, "A", "G", "Sample1", "Missense_Mutation", + ), + ) + maf = maf.add_mutation( + @src.MAFMutation::new( + "EGFR", "chr7", 300, 300, "C", "T", "Sample2", "Missense_Mutation", + ), + ) + let counts = @src.get_sample_mutation_counts(maf) - + assert_eq(counts.get("Sample1").unwrap_or(0), 2) assert_eq(counts.get("Sample2").unwrap_or(0), 1) } @@ -351,13 +293,25 @@ test "maftools_get_sample_mutation_counts" { ///| test "maftools_filter_variant_type" { let mut maf = @src.MAFData::new() - - maf = maf.add_mutation(@src.MAFMutation::new("TP53", "chr17", 100, 100, "C", "T", "Sample1", "Missense_Mutation")) - maf = maf.add_mutation(@src.MAFMutation::new("BRCA1", "chr17", 200, 200, "A", "G", "Sample2", "Nonsense_Mutation")) - maf = maf.add_mutation(@src.MAFMutation::new("EGFR", "chr7", 300, 300, "C", "T", "Sample3", "Missense_Mutation")) - + + maf = maf.add_mutation( + @src.MAFMutation::new( + "TP53", "chr17", 100, 100, "C", "T", "Sample1", "Missense_Mutation", + ), + ) + maf = maf.add_mutation( + @src.MAFMutation::new( + "BRCA1", "chr17", 200, 200, "A", "G", "Sample2", "Nonsense_Mutation", + ), + ) + maf = maf.add_mutation( + @src.MAFMutation::new( + "EGFR", "chr7", 300, 300, "C", "T", "Sample3", "Missense_Mutation", + ), + ) + let filtered = maf.filter_variant_type("Nonsense") - + assert_eq(filtered.count_mutations(), 1) assert_eq(filtered.get_mutation_gene(0), "BRCA1") } @@ -365,9 +319,9 @@ test "maftools_filter_variant_type" { ///| test "maftools_parse_maf_content" { let content = "Hugo_Symbol\tChromosome\tStart_Position\tEnd_Position\tReference_Allele\tTumor_Seq_Allele1\tTumor_Sample_Barcode\tVariant_Classification\nTP53\tchr17\t7577121\t7577121\tC\tT\tSample1\tMissense_Mutation\nBRCA1\tchr17\t43091134\t43091134\tA\tG\tSample2\tNonsense_Mutation" - + let maf = @src.parse_maf_content(content) - + assert_eq(maf.count_mutations(), 2) assert_eq(maf.get_mutation_gene(0), "TP53") assert_eq(maf.get_mutation_gene(1), "BRCA1") diff --git a/test/moonbit/markov_test.mbt b/test/moonbit/markov_test.mbt index e7e76022..4309a6d2 100644 --- a/test/moonbit/markov_test.mbt +++ b/test/moonbit/markov_test.mbt @@ -1,18 +1,20 @@ ///| /// Test file for markov module. - fn make_dna_seqs() -> Array[String] { ["ACGTACGT", "CGCGCGTA", "TTTAAAAC", "GGCCTTAA", "ATGCATGC"] } +///| fn make_cpg_seqs() -> Array[String] { ["CGCGCGCG", "ACGTACGT", "CGATCGAT", "GCGCGCGC", "TCGATCGA"] } +///| fn make_bg_seqs() -> Array[String] { ["ATATATAT", "TTAAAATT", "GGGGGGGG", "CCCCCCCC", "AATTCCGG"] } +///| test "markov_chain_type_helpers" { let a = @src.markov_first_order() let b = @src.markov_second_order() @@ -22,6 +24,7 @@ test "markov_chain_type_helpers" { assert_true(b != c) } +///| test "markov_model_new_default" { let m = @src.MarkovModel::new() assert_eq(m.order, 1) @@ -29,6 +32,7 @@ test "markov_model_new_default" { assert_eq(m.pseudo_count, 1.0) } +///| test "markov_model_default_dna" { let m = @src.MarkovModel::default_dna() assert_eq(m.order, 1) @@ -37,12 +41,14 @@ test "markov_model_default_dna" { assert_eq(m.states[1], "C") } +///| test "markov_model_default_protein" { let m = @src.MarkovModel::default_protein() assert_eq(m.order, 1) assert_eq(m.states.length(), 20) } +///| test "markov_model_set_order" { let m = @src.MarkovModel::new() let m2 = m.set_order(2) @@ -52,14 +58,16 @@ test "markov_model_set_order" { assert_eq(m.order, 1) } +///| test "markov_model_set_states" { let m = @src.MarkovModel::new() let states = ["X", "Y"] - let m2 = m.set_states(states=states) + let m2 = m.set_states(states~) assert_eq(m2.states.length(), 2) assert_eq(m2.states[0], "X") } +///| test "markov_model_set_chain_type" { let m = @src.MarkovModel::new() let m2 = m.set_chain_type(val=@src.markov_second_order()) @@ -68,6 +76,7 @@ test "markov_model_set_chain_type" { assert_eq(m3.order, 3) } +///| test "markov_model_set_pseudo_count" { let m = @src.MarkovModel::new() let m2 = m.set_pseudo_count(0.5) @@ -75,6 +84,7 @@ test "markov_model_set_pseudo_count" { assert_eq(m.pseudo_count, 1.0) } +///| test "markov_build_model_dna_order1" { let seqs = make_dna_seqs() let m = @src.markov_build_model(seqs, order=1) @@ -83,6 +93,7 @@ test "markov_build_model_dna_order1" { assert_true(m.transition_probs.length() > 0) } +///| test "markov_build_model_different_orders" { let seqs = make_dna_seqs() let m1 = @src.markov_build_model(seqs, order=1) @@ -94,6 +105,7 @@ test "markov_build_model_different_orders" { assert_true(c1 != c2 || c2 != c3) } +///| test "markov_score_sequence_finite_negative" { let seqs = make_dna_seqs() let m = @src.markov_build_model(seqs, order=1) @@ -102,6 +114,7 @@ test "markov_score_sequence_finite_negative" { assert_true(score > -1000.0) } +///| test "markov_score_per_base_length" { let seqs = make_dna_seqs() let m1 = @src.markov_build_model(seqs, order=1) @@ -112,6 +125,7 @@ test "markov_score_per_base_length" { assert_eq(s2.length(), 8 - 2) } +///| test "markov_generate_sequence_length_and_alphabet" { let seqs = make_dna_seqs() let m = @src.markov_build_model(seqs, order=1) @@ -131,6 +145,7 @@ test "markov_generate_sequence_length_and_alphabet" { } } +///| test "markov_log_odds_positive_cpg" { let cpg_seqs = make_cpg_seqs() let bg_seqs = make_bg_seqs() @@ -141,6 +156,7 @@ test "markov_log_odds_positive_cpg" { assert_true(lo > -100.0) } +///| test "markov_stationary_sums_to_one" { let seqs = make_dna_seqs() let m = @src.markov_build_model(seqs, order=1) @@ -156,22 +172,35 @@ test "markov_stationary_sums_to_one" { assert_true(total < 1.1) } +///| test "markov_pseudo_count_affects_unknowns" { let seqs = ["AAAAA", "CCCCCCC"] let sts = ["A", "C", "G", "T"] - let m_low = @src.markov_build_model(seqs, order=1, states=sts, pseudo_count=0.1) - let m_high = @src.markov_build_model(seqs, order=1, states=sts, pseudo_count=10.0) + let m_low = @src.markov_build_model( + seqs, + order=1, + states=sts, + pseudo_count=0.1, + ) + let m_high = @src.markov_build_model( + seqs, + order=1, + states=sts, + pseudo_count=10.0, + ) let s_low = @src.markov_score_sequence(m_low, "GGGG") let s_high = @src.markov_score_sequence(m_high, "GGGG") assert_true(s_high > s_low) } +///| test "markov_build_model_infers_states" { let seqs = ["AABBAABB", "BBBBAAAA"] let m = @src.markov_build_model(seqs) assert_true(m.states.length() >= 2) } +///| test "markov_short_sequence_score" { let seqs = make_dna_seqs() let m = @src.markov_build_model(seqs, order=1) diff --git a/test/moonbit/matrix_generics_test.mbt b/test/moonbit/matrix_generics_test.mbt index f792f653..333d0cdb 100644 --- a/test/moonbit/matrix_generics_test.mbt +++ b/test/moonbit/matrix_generics_test.mbt @@ -13,6 +13,7 @@ test "mg_matrix_new_basic" { assert_eq(mat.get(1, 1), 4.0) } +///| test "mg_matrix_new_single_element" { let mat = @src.MgMatrix::new([[42.0]]) assert_eq(mat.dim_rows(), 1) @@ -20,6 +21,7 @@ test "mg_matrix_new_single_element" { assert_eq(mat.get(0, 0), 42.0) } +///| test "mg_matrix_new_single_row" { let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0, 4.0]]) assert_eq(mat.dim_rows(), 1) @@ -28,6 +30,7 @@ test "mg_matrix_new_single_row" { assert_eq(mat.get(0, 3), 4.0) } +///| test "mg_matrix_new_single_col" { let mat = @src.MgMatrix::new([[1.0], [2.0], [3.0]]) assert_eq(mat.dim_rows(), 3) @@ -36,12 +39,14 @@ test "mg_matrix_new_single_col" { assert_eq(mat.get(2, 0), 3.0) } +///| test "mg_matrix_new_empty" { let mat = @src.MgMatrix::new([]) assert_eq(mat.dim_rows(), 0) assert_eq(mat.dim_cols(), 0) } +///| test "mg_matrix_zeros_basic" { let mat = @src.MgMatrix::zeros(3, 4) assert_eq(mat.dim_rows(), 3) @@ -50,6 +55,7 @@ test "mg_matrix_zeros_basic" { assert_eq(mat.get(2, 3), 0.0) } +///| test "mg_matrix_zeros_single" { let mat = @src.MgMatrix::zeros(1, 1) assert_eq(mat.dim_rows(), 1) @@ -57,6 +63,7 @@ test "mg_matrix_zeros_single" { assert_eq(mat.get(0, 0), 0.0) } +///| test "mg_matrix_zeros_empty" { let mat = @src.MgMatrix::zeros(0, 0) assert_eq(mat.dim_rows(), 0) @@ -67,6 +74,7 @@ test "mg_matrix_zeros_empty" { // Accessor methods // --------------------------------------------------------------------------- +///| test "mg_matrix_get_set" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0]]) mat.set(0, 0, 99.0) @@ -75,6 +83,7 @@ test "mg_matrix_get_set" { assert_eq(mat.get(1, 0), 3.0) } +///| test "mg_matrix_get_row" { let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) let row0 = mat.get_row(0) @@ -89,6 +98,7 @@ test "mg_matrix_get_row" { assert_eq(row1[2], 6.0) } +///| test "mg_matrix_get_col" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]) let col0 = mat.get_col(0) @@ -107,8 +117,13 @@ test "mg_matrix_get_col" { // Row summary statistics // --------------------------------------------------------------------------- +///| test "mg_row_means_basic" { - let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 2.0, 3.0], + [4.0, 5.0, 6.0], + [7.0, 8.0, 9.0], + ]) let result = @src.mg_row_means(mat) assert_eq(result.length(), 3) assert_eq(result[0], 2.0) @@ -116,6 +131,7 @@ test "mg_row_means_basic" { assert_eq(result[2], 8.0) } +///| test "mg_row_means_constant" { let mat = @src.MgMatrix::new([[5.0, 5.0, 5.0], [3.0, 3.0, 3.0]]) let result = @src.mg_row_means(mat) @@ -123,6 +139,7 @@ test "mg_row_means_constant" { assert_eq(result[1], 3.0) } +///| test "mg_row_means_single_row" { let mat = @src.MgMatrix::new([[10.0, 20.0, 30.0]]) let result = @src.mg_row_means(mat) @@ -130,8 +147,13 @@ test "mg_row_means_single_row" { assert_eq(result[0], 20.0) } +///| test "mg_row_sums_basic" { - let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 2.0, 3.0], + [4.0, 5.0, 6.0], + [7.0, 8.0, 9.0], + ]) let result = @src.mg_row_sums(mat) assert_eq(result.length(), 3) assert_eq(result[0], 6.0) @@ -139,6 +161,7 @@ test "mg_row_sums_basic" { assert_eq(result[2], 24.0) } +///| test "mg_row_sums_constant" { let mat = @src.MgMatrix::new([[2.0, 2.0, 2.0], [0.0, 0.0, 0.0]]) let result = @src.mg_row_sums(mat) @@ -146,8 +169,13 @@ test "mg_row_sums_constant" { assert_eq(result[1], 0.0) } +///| test "mg_row_vars_basic" { - let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 2.0, 3.0], + [4.0, 5.0, 6.0], + [7.0, 8.0, 9.0], + ]) let result = @src.mg_row_vars(mat) assert_eq(result.length(), 3) assert_true(result[0] > 0.99 && result[0] < 1.01) @@ -155,6 +183,7 @@ test "mg_row_vars_basic" { assert_true(result[2] > 0.99 && result[2] < 1.01) } +///| test "mg_row_vars_constant" { let mat = @src.MgMatrix::new([[5.0, 5.0, 5.0], [2.0, 2.0, 2.0]]) let result = @src.mg_row_vars(mat) @@ -162,12 +191,14 @@ test "mg_row_vars_constant" { assert_eq(result[1], 0.0) } +///| test "mg_row_vars_single" { let mat = @src.MgMatrix::new([[3.0]]) let result = @src.mg_row_vars(mat) assert_eq(result[0], 0.0) } +///| test "mg_row_sds_basic" { let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) let result = @src.mg_row_sds(mat) @@ -176,12 +207,14 @@ test "mg_row_sds_basic" { assert_true(result[1] > 0.99 && result[1] < 1.01) } +///| test "mg_row_sds_constant" { let mat = @src.MgMatrix::new([[7.0, 7.0, 7.0]]) let result = @src.mg_row_sds(mat) assert_eq(result[0], 0.0) } +///| test "mg_row_medians_odd" { let mat = @src.MgMatrix::new([[1.0, 3.0, 2.0], [6.0, 4.0, 5.0]]) let result = @src.mg_row_medians(mat) @@ -189,46 +222,61 @@ test "mg_row_medians_odd" { assert_eq(result[1], 5.0) } +///| test "mg_row_medians_even" { let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0, 4.0]]) let result = @src.mg_row_medians(mat) assert_eq(result[0], 2.5) } +///| test "mg_row_medians_constant" { let mat = @src.MgMatrix::new([[9.0, 9.0, 9.0]]) let result = @src.mg_row_medians(mat) assert_eq(result[0], 9.0) } +///| test "mg_row_mins_basic" { - let mat = @src.MgMatrix::new([[3.0, 1.0, 2.0], [6.0, 5.0, 4.0], [9.0, 8.0, 7.0]]) + let mat = @src.MgMatrix::new([ + [3.0, 1.0, 2.0], + [6.0, 5.0, 4.0], + [9.0, 8.0, 7.0], + ]) let result = @src.mg_row_mins(mat) assert_eq(result[0], 1.0) assert_eq(result[1], 4.0) assert_eq(result[2], 7.0) } +///| test "mg_row_mins_constant" { let mat = @src.MgMatrix::new([[4.0, 4.0, 4.0]]) let result = @src.mg_row_mins(mat) assert_eq(result[0], 4.0) } +///| test "mg_row_maxs_basic" { - let mat = @src.MgMatrix::new([[3.0, 1.0, 2.0], [6.0, 5.0, 4.0], [9.0, 8.0, 7.0]]) + let mat = @src.MgMatrix::new([ + [3.0, 1.0, 2.0], + [6.0, 5.0, 4.0], + [9.0, 8.0, 7.0], + ]) let result = @src.mg_row_maxs(mat) assert_eq(result[0], 3.0) assert_eq(result[1], 6.0) assert_eq(result[2], 9.0) } +///| test "mg_row_maxs_constant" { let mat = @src.MgMatrix::new([[4.0, 4.0, 4.0]]) let result = @src.mg_row_maxs(mat) assert_eq(result[0], 4.0) } +///| test "mg_row_ranges_basic" { let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [10.0, 5.0, 2.0]]) let result = @src.mg_row_ranges(mat) @@ -236,14 +284,20 @@ test "mg_row_ranges_basic" { assert_eq(result[1], 8.0) } +///| test "mg_row_ranges_constant" { let mat = @src.MgMatrix::new([[5.0, 5.0, 5.0]]) let result = @src.mg_row_ranges(mat) assert_eq(result[0], 0.0) } +///| test "mg_row_counts_basic" { - let mat = @src.MgMatrix::new([[1.0, 0.0, 3.0], [0.0, 0.0, 0.0], [4.0, 5.0, 6.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 0.0, 3.0], + [0.0, 0.0, 0.0], + [4.0, 5.0, 6.0], + ]) let result = @src.mg_row_counts(mat) assert_eq(result.length(), 3) assert_eq(result[0], 2) @@ -251,6 +305,7 @@ test "mg_row_counts_basic" { assert_eq(result[2], 3) } +///| test "mg_row_counts_all_zero" { let mat = @src.MgMatrix::new([[0.0, 0.0], [0.0, 0.0]]) let result = @src.mg_row_counts(mat) @@ -258,6 +313,7 @@ test "mg_row_counts_all_zero" { assert_eq(result[1], 0) } +///| test "mg_row_mads_basic" { let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) let result = @src.mg_row_mads(mat) @@ -266,6 +322,7 @@ test "mg_row_mads_basic" { assert_true(result[1] > 1.4 && result[1] < 1.6) } +///| test "mg_row_mads_constant" { let mat = @src.MgMatrix::new([[5.0, 5.0, 5.0]]) let result = @src.mg_row_mads(mat) @@ -276,8 +333,13 @@ test "mg_row_mads_constant" { // Row anys and alls // --------------------------------------------------------------------------- +///| test "mg_row_anys_basic" { - let mat = @src.MgMatrix::new([[1.0, 5.0, 3.0], [2.0, 2.0, 2.0], [10.0, 20.0, 30.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 5.0, 3.0], + [2.0, 2.0, 2.0], + [10.0, 20.0, 30.0], + ]) let result = @src.mg_row_anys(mat, 4.0) assert_eq(result.length(), 3) assert_true(result[0]) @@ -285,20 +347,27 @@ test "mg_row_anys_basic" { assert_true(result[2]) } +///| test "mg_row_anys_all_below" { let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0]]) let result = @src.mg_row_anys(mat, 100.0) assert_false(result[0]) } +///| test "mg_row_anys_threshold_boundary" { let mat = @src.MgMatrix::new([[5.0, 5.0, 5.0]]) let result = @src.mg_row_anys(mat, 5.0) assert_false(result[0]) } +///| test "mg_row_alls_basic" { - let mat = @src.MgMatrix::new([[10.0, 20.0, 30.0], [1.0, 100.0, 50.0], [2.0, 2.0, 2.0]]) + let mat = @src.MgMatrix::new([ + [10.0, 20.0, 30.0], + [1.0, 100.0, 50.0], + [2.0, 2.0, 2.0], + ]) let result = @src.mg_row_alls(mat, 5.0) assert_eq(result.length(), 3) assert_true(result[0]) @@ -306,6 +375,7 @@ test "mg_row_alls_basic" { assert_false(result[2]) } +///| test "mg_row_alls_all_above" { let mat = @src.MgMatrix::new([[10.0, 10.0], [20.0, 20.0]]) let result = @src.mg_row_alls(mat, 5.0) @@ -313,6 +383,7 @@ test "mg_row_alls_all_above" { assert_true(result[1]) } +///| test "mg_row_alls_threshold_boundary" { let mat = @src.MgMatrix::new([[5.0, 5.0, 5.0]]) let result = @src.mg_row_alls(mat, 5.0) @@ -323,8 +394,13 @@ test "mg_row_alls_threshold_boundary" { // Column summary statistics // --------------------------------------------------------------------------- +///| test "mg_col_means_basic" { - let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 2.0, 3.0], + [4.0, 5.0, 6.0], + [7.0, 8.0, 9.0], + ]) let result = @src.mg_col_means(mat) assert_eq(result.length(), 3) assert_eq(result[0], 4.0) @@ -332,6 +408,7 @@ test "mg_col_means_basic" { assert_eq(result[2], 6.0) } +///| test "mg_col_means_constant" { let mat = @src.MgMatrix::new([[3.0, 7.0], [3.0, 7.0], [3.0, 7.0]]) let result = @src.mg_col_means(mat) @@ -339,6 +416,7 @@ test "mg_col_means_constant" { assert_eq(result[1], 7.0) } +///| test "mg_col_means_single_col" { let mat = @src.MgMatrix::new([[10.0], [20.0], [30.0]]) let result = @src.mg_col_means(mat) @@ -346,8 +424,13 @@ test "mg_col_means_single_col" { assert_eq(result[0], 20.0) } +///| test "mg_col_sums_basic" { - let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 2.0, 3.0], + [4.0, 5.0, 6.0], + [7.0, 8.0, 9.0], + ]) let result = @src.mg_col_sums(mat) assert_eq(result.length(), 3) assert_eq(result[0], 12.0) @@ -355,6 +438,7 @@ test "mg_col_sums_basic" { assert_eq(result[2], 18.0) } +///| test "mg_col_sums_constant" { let mat = @src.MgMatrix::new([[2.0, 0.0], [2.0, 0.0], [2.0, 0.0]]) let result = @src.mg_col_sums(mat) @@ -362,8 +446,13 @@ test "mg_col_sums_constant" { assert_eq(result[1], 0.0) } +///| test "mg_col_vars_basic" { - let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 2.0, 3.0], + [4.0, 5.0, 6.0], + [7.0, 8.0, 9.0], + ]) let result = @src.mg_col_vars(mat) assert_eq(result.length(), 3) assert_true(result[0] > 8.99 && result[0] < 9.01) @@ -371,6 +460,7 @@ test "mg_col_vars_basic" { assert_true(result[2] > 8.99 && result[2] < 9.01) } +///| test "mg_col_vars_constant" { let mat = @src.MgMatrix::new([[5.0, 7.0], [5.0, 7.0], [5.0, 7.0]]) let result = @src.mg_col_vars(mat) @@ -378,12 +468,14 @@ test "mg_col_vars_constant" { assert_eq(result[1], 0.0) } +///| test "mg_col_vars_single" { let mat = @src.MgMatrix::new([[3.0], [3.0]]) let result = @src.mg_col_vars(mat) assert_eq(result[0], 0.0) } +///| test "mg_col_sds_basic" { let mat = @src.MgMatrix::new([[1.0, 2.0], [4.0, 5.0], [7.0, 8.0]]) let result = @src.mg_col_sds(mat) @@ -392,6 +484,7 @@ test "mg_col_sds_basic" { assert_true(result[1] > 2.99 && result[1] < 3.01) } +///| test "mg_col_sds_constant" { let mat = @src.MgMatrix::new([[3.0, 5.0], [3.0, 5.0]]) let result = @src.mg_col_sds(mat) @@ -399,6 +492,7 @@ test "mg_col_sds_constant" { assert_eq(result[1], 0.0) } +///| test "mg_col_medians_odd" { let mat = @src.MgMatrix::new([[1.0, 3.0], [4.0, 1.0], [7.0, 2.0]]) let result = @src.mg_col_medians(mat) @@ -406,6 +500,7 @@ test "mg_col_medians_odd" { assert_eq(result[1], 2.0) } +///| test "mg_col_medians_even" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0]]) let result = @src.mg_col_medians(mat) @@ -413,6 +508,7 @@ test "mg_col_medians_even" { assert_eq(result[1], 3.0) } +///| test "mg_col_medians_constant" { let mat = @src.MgMatrix::new([[8.0, 2.0], [8.0, 2.0], [8.0, 2.0]]) let result = @src.mg_col_medians(mat) @@ -420,14 +516,20 @@ test "mg_col_medians_constant" { assert_eq(result[1], 2.0) } +///| test "mg_col_mins_basic" { - let mat = @src.MgMatrix::new([[3.0, 1.0, 2.0], [6.0, 5.0, 4.0], [9.0, 8.0, 7.0]]) + let mat = @src.MgMatrix::new([ + [3.0, 1.0, 2.0], + [6.0, 5.0, 4.0], + [9.0, 8.0, 7.0], + ]) let result = @src.mg_col_mins(mat) assert_eq(result[0], 3.0) assert_eq(result[1], 1.0) assert_eq(result[2], 2.0) } +///| test "mg_col_mins_constant" { let mat = @src.MgMatrix::new([[4.0, 6.0], [4.0, 6.0], [4.0, 6.0]]) let result = @src.mg_col_mins(mat) @@ -435,14 +537,20 @@ test "mg_col_mins_constant" { assert_eq(result[1], 6.0) } +///| test "mg_col_maxs_basic" { - let mat = @src.MgMatrix::new([[3.0, 1.0, 2.0], [6.0, 5.0, 4.0], [9.0, 8.0, 7.0]]) + let mat = @src.MgMatrix::new([ + [3.0, 1.0, 2.0], + [6.0, 5.0, 4.0], + [9.0, 8.0, 7.0], + ]) let result = @src.mg_col_maxs(mat) assert_eq(result[0], 9.0) assert_eq(result[1], 8.0) assert_eq(result[2], 7.0) } +///| test "mg_col_maxs_constant" { let mat = @src.MgMatrix::new([[4.0, 6.0], [4.0, 6.0], [4.0, 6.0]]) let result = @src.mg_col_maxs(mat) @@ -450,6 +558,7 @@ test "mg_col_maxs_constant" { assert_eq(result[1], 6.0) } +///| test "mg_col_ranges_basic" { let mat = @src.MgMatrix::new([[1.0, 10.0], [5.0, 2.0], [10.0, 1.0]]) let result = @src.mg_col_ranges(mat) @@ -457,6 +566,7 @@ test "mg_col_ranges_basic" { assert_eq(result[1], 9.0) } +///| test "mg_col_ranges_constant" { let mat = @src.MgMatrix::new([[5.0, 3.0], [5.0, 3.0], [5.0, 3.0]]) let result = @src.mg_col_ranges(mat) @@ -468,8 +578,13 @@ test "mg_col_ranges_constant" { // Col anys and alls // --------------------------------------------------------------------------- +///| test "mg_col_anys_basic" { - let mat = @src.MgMatrix::new([[1.0, 5.0, 3.0], [2.0, 2.0, 2.0], [1.0, 8.0, 1.0]]) + let mat = @src.MgMatrix::new([ + [1.0, 5.0, 3.0], + [2.0, 2.0, 2.0], + [1.0, 8.0, 1.0], + ]) let result = @src.mg_col_anys(mat, 4.0) assert_eq(result.length(), 3) assert_false(result[0]) @@ -477,6 +592,7 @@ test "mg_col_anys_basic" { assert_false(result[2]) } +///| test "mg_col_anys_all_below" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0]]) let result = @src.mg_col_anys(mat, 100.0) @@ -484,6 +600,7 @@ test "mg_col_anys_all_below" { assert_false(result[1]) } +///| test "mg_col_alls_basic" { let mat = @src.MgMatrix::new([[10.0, 5.0], [20.0, 6.0], [30.0, 7.0]]) let result = @src.mg_col_alls(mat, 4.0) @@ -491,6 +608,7 @@ test "mg_col_alls_basic" { assert_true(result[1]) } +///| test "mg_col_alls_some_below" { let mat = @src.MgMatrix::new([[10.0, 3.0], [20.0, 6.0], [30.0, 7.0]]) let result = @src.mg_col_alls(mat, 5.0) @@ -502,9 +620,10 @@ test "mg_col_alls_some_below" { // Block processing // --------------------------------------------------------------------------- +///| test "mg_block_apply_rows_basic" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]]) - let result = @src.mg_block_apply_rows(mat, 2, (block) => { + let result = @src.mg_block_apply_rows(mat, 2, block => { @src.mg_row_means(block) }) assert_eq(result.length(), 3) @@ -513,9 +632,10 @@ test "mg_block_apply_rows_basic" { assert_eq(result[2], 5.5) } +///| test "mg_block_apply_rows_single_block" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0]]) - let result = @src.mg_block_apply_rows(mat, 10, (block) => { + let result = @src.mg_block_apply_rows(mat, 10, block => { @src.mg_row_sums(block) }) assert_eq(result.length(), 2) @@ -523,9 +643,10 @@ test "mg_block_apply_rows_single_block" { assert_eq(result[1], 7.0) } +///| test "mg_block_apply_rows_block_size_exceeds" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0]]) - let result = @src.mg_block_apply_rows(mat, 100, (block) => { + let result = @src.mg_block_apply_rows(mat, 100, block => { @src.mg_row_mins(block) }) assert_eq(result.length(), 2) @@ -533,9 +654,10 @@ test "mg_block_apply_rows_block_size_exceeds" { assert_eq(result[1], 3.0) } +///| test "mg_block_apply_cols_basic" { let mat = @src.MgMatrix::new([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) - let result = @src.mg_block_apply_cols(mat, 2, (block) => { + let result = @src.mg_block_apply_cols(mat, 2, block => { @src.mg_col_means(block) }) assert_eq(result.length(), 3) @@ -544,9 +666,10 @@ test "mg_block_apply_cols_basic" { assert_eq(result[2], 4.5) } +///| test "mg_block_apply_cols_single_block" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0]]) - let result = @src.mg_block_apply_cols(mat, 10, (block) => { + let result = @src.mg_block_apply_cols(mat, 10, block => { @src.mg_col_sums(block) }) assert_eq(result.length(), 2) @@ -558,144 +681,172 @@ test "mg_block_apply_cols_single_block" { // Standalone statistical functions // --------------------------------------------------------------------------- +///| test "mg_mean_basic" { let data = [1.0, 2.0, 3.0, 4.0, 5.0] assert_eq(@src.mg_mean(data), 3.0) } +///| test "mg_mean_single" { let data = [42.0] assert_eq(@src.mg_mean(data), 42.0) } +///| test "mg_mean_empty" { let data : Array[Double] = [] assert_eq(@src.mg_mean(data), 0.0) } +///| test "mg_mean_constant" { let data = [7.0, 7.0, 7.0, 7.0] assert_eq(@src.mg_mean(data), 7.0) } +///| test "mg_mean_negative" { let data = [-1.0, -2.0, -3.0] assert_eq(@src.mg_mean(data), -2.0) } +///| test "mg_variance_basic" { let data = [1.0, 2.0, 3.0, 4.0, 5.0] let result = @src.mg_variance(data) assert_true(result > 2.49 && result < 2.51) } +///| test "mg_variance_single" { let data = [5.0] assert_eq(@src.mg_variance(data), 0.0) } +///| test "mg_variance_empty" { let data : Array[Double] = [] assert_eq(@src.mg_variance(data), 0.0) } +///| test "mg_variance_constant" { let data = [3.0, 3.0, 3.0] assert_eq(@src.mg_variance(data), 0.0) } +///| test "mg_variance_two_elements" { let data = [2.0, 4.0] let result = @src.mg_variance(data) assert_true(result > 1.99 && result < 2.01) } +///| test "mg_median_odd" { let data = [3.0, 1.0, 2.0] assert_eq(@src.mg_median(data), 2.0) } +///| test "mg_median_even" { let data = [1.0, 2.0, 3.0, 4.0] assert_eq(@src.mg_median(data), 2.5) } +///| test "mg_median_single" { let data = [99.0] assert_eq(@src.mg_median(data), 99.0) } +///| test "mg_median_empty" { let data : Array[Double] = [] assert_eq(@src.mg_median(data), 0.0) } +///| test "mg_median_two" { let data = [5.0, 10.0] assert_eq(@src.mg_median(data), 7.5) } +///| test "mg_min_basic" { let data = [3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0] assert_eq(@src.mg_min(data), 1.0) } +///| test "mg_min_single" { let data = [42.0] assert_eq(@src.mg_min(data), 42.0) } +///| test "mg_min_empty" { let data : Array[Double] = [] assert_eq(@src.mg_min(data), 0.0) } +///| test "mg_min_negative" { let data = [-5.0, -1.0, -3.0] assert_eq(@src.mg_min(data), -5.0) } +///| test "mg_max_basic" { let data = [3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0] assert_eq(@src.mg_max(data), 9.0) } +///| test "mg_max_single" { let data = [42.0] assert_eq(@src.mg_max(data), 42.0) } +///| test "mg_max_empty" { let data : Array[Double] = [] assert_eq(@src.mg_max(data), 0.0) } +///| test "mg_max_negative" { let data = [-5.0, -1.0, -3.0] assert_eq(@src.mg_max(data), -1.0) } +///| test "mg_mad_basic" { let data = [1.0, 2.0, 3.0, 4.0, 5.0] let result = @src.mg_mad(data) assert_true(result > 1.4 && result < 2.0) } +///| test "mg_mad_constant" { let data = [5.0, 5.0, 5.0] assert_eq(@src.mg_mad(data), 0.0) } +///| test "mg_mad_single" { let data = [7.0] assert_eq(@src.mg_mad(data), 0.0) } +///| test "mg_mad_empty" { let data : Array[Double] = [] assert_eq(@src.mg_mad(data), 0.0) } +///| test "mg_mad_two_same" { let data = [3.0, 3.0] assert_eq(@src.mg_mad(data), 0.0) @@ -705,6 +856,7 @@ test "mg_mad_two_same" { // Edge cases // --------------------------------------------------------------------------- +///| test "mg_empty_matrix_row_stats" { let mat = @src.MgMatrix::zeros(0, 5) let means = @src.mg_row_means(mat) @@ -713,12 +865,14 @@ test "mg_empty_matrix_row_stats" { assert_eq(sums.length(), 0) } +///| test "mg_empty_matrix_col_stats" { let mat = @src.MgMatrix::zeros(5, 0) let means = @src.mg_col_means(mat) assert_eq(means.length(), 0) } +///| test "mg_single_value_matrix" { let mat = @src.MgMatrix::new([[7.0]]) assert_eq(mat.dim_rows(), 1) @@ -731,6 +885,7 @@ test "mg_single_value_matrix" { assert_eq(@src.mg_col_medians(mat)[0], 7.0) } +///| test "mg_negative_values_matrix" { let mat = @src.MgMatrix::new([[-1.0, -2.0], [-3.0, -4.0]]) let row_means = @src.mg_row_means(mat) @@ -741,6 +896,7 @@ test "mg_negative_values_matrix" { assert_eq(col_means[1], -3.0) } +///| test "mg_large_matrix_stats" { let mat = @src.MgMatrix::zeros(100, 50) let row_means = @src.mg_row_means(mat) @@ -751,41 +907,47 @@ test "mg_large_matrix_stats" { assert_eq(col_means[0], 0.0) } +///| test "mg_row_anys_empty_matrix" { let mat = @src.MgMatrix::zeros(0, 3) let result = @src.mg_row_anys(mat, 1.0) assert_eq(result.length(), 0) } +///| test "mg_row_alls_empty_matrix" { let mat = @src.MgMatrix::zeros(0, 3) let result = @src.mg_row_alls(mat, 1.0) assert_eq(result.length(), 0) } +///| test "mg_col_anys_empty_matrix" { let mat = @src.MgMatrix::zeros(3, 0) let result = @src.mg_col_anys(mat, 1.0) assert_eq(result.length(), 0) } +///| test "mg_col_alls_empty_matrix" { let mat = @src.MgMatrix::zeros(3, 0) let result = @src.mg_col_alls(mat, 1.0) assert_eq(result.length(), 0) } +///| test "mg_block_apply_rows_empty" { let mat = @src.MgMatrix::zeros(0, 5) - let result = @src.mg_block_apply_rows(mat, 10, (block) => { + let result = @src.mg_block_apply_rows(mat, 10, block => { @src.mg_row_means(block) }) assert_eq(result.length(), 0) } +///| test "mg_block_apply_cols_empty" { let mat = @src.MgMatrix::zeros(5, 0) - let result = @src.mg_block_apply_cols(mat, 10, (block) => { + let result = @src.mg_block_apply_cols(mat, 10, block => { @src.mg_col_means(block) }) assert_eq(result.length(), 0) @@ -795,6 +957,7 @@ test "mg_block_apply_cols_empty" { // Cross-validation: row and col stats should agree on the same data // --------------------------------------------------------------------------- +///| test "mg_row_col_stats_consistency" { let mat = @src.MgMatrix::new([[1.0, 2.0], [3.0, 4.0]]) let row_means = @src.mg_row_means(mat) @@ -804,10 +967,11 @@ test "mg_row_col_stats_consistency" { assert_eq(@src.mg_mean(row_means), @src.mg_mean(col_means)) } +///| test "mg_symmetric_matrix_row_col_stats" { let mat = @src.MgMatrix::new([[1.0, 2.0], [2.0, 1.0]]) let row_means = @src.mg_row_means(mat) let col_means = @src.mg_col_means(mat) assert_eq(row_means[0], col_means[0]) assert_eq(row_means[1], col_means[1]) -} \ No newline at end of file +} diff --git a/test/moonbit/matrix_test.mbt b/test/moonbit/matrix_test.mbt index 88e37761..55a49458 100644 --- a/test/moonbit/matrix_test.mbt +++ b/test/moonbit/matrix_test.mbt @@ -1,38 +1,54 @@ ///| /// Tests for Matrix module. - test "BiocMatrix dense_from_array" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) assert_eq(mat.nrow(), 2) assert_eq(mat.ncol(), 2) } +///| test "BiocMatrix get element" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) assert_eq(mat.get(0, 0), 1.0) assert_eq(mat.get(1, 1), 4.0) } +///| test "BiocMatrix set element" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) let mat2 = mat.set(0, 0, 10.0) assert_eq(mat2.get(0, 0), 10.0) } +///| test "BiocMatrix csc_from_triplets" { - let mat = @src.BiocMatrix::csc_from_triplets([0, 1, 0, 1], [0, 0, 1, 1], [1.0, 3.0, 2.0, 4.0], 2, 2) + let mat = @src.BiocMatrix::csc_from_triplets( + [0, 1, 0, 1], + [0, 0, 1, 1], + [1.0, 3.0, 2.0, 4.0], + 2, + 2, + ) assert_eq(mat.nrow(), 2) assert_eq(mat.ncol(), 2) assert_eq(mat.get(0, 0), 1.0) } +///| test "BiocMatrix csr_from_triplets" { - let mat = @src.BiocMatrix::csr_from_triplets([0, 0, 1, 1], [0, 1, 0, 1], [1.0, 2.0, 3.0, 4.0], 2, 2) + let mat = @src.BiocMatrix::csr_from_triplets( + [0, 0, 1, 1], + [0, 1, 0, 1], + [1.0, 2.0, 3.0, 4.0], + 2, + 2, + ) assert_eq(mat.nrow(), 2) assert_eq(mat.ncol(), 2) assert_eq(mat.get(0, 1), 2.0) } +///| test "BiocMatrix transpose" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) let t = mat.transpose() @@ -40,6 +56,7 @@ test "BiocMatrix transpose" { assert_eq(t.get(1, 0), 2.0) } +///| test "BiocMatrix add" { let mat1 = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) let mat2 = @src.BiocMatrix::dense_from_array([[1.0, 0.0], [0.0, 1.0]]) @@ -48,6 +65,7 @@ test "BiocMatrix add" { assert_eq(result.unwrap().get(0, 0), 2.0) } +///| test "BiocMatrix multiply" { let mat1 = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) let mat2 = @src.BiocMatrix::dense_from_array([[2.0, 0.0], [0.0, 2.0]]) @@ -56,6 +74,7 @@ test "BiocMatrix multiply" { assert_eq(result.unwrap().get(0, 0), 2.0) } +///| test "BiocMatrix row_sums" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) let sums = mat.row_sums() @@ -63,6 +82,7 @@ test "BiocMatrix row_sums" { assert_eq(sums[0], 3.0) } +///| test "BiocMatrix col_sums" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) let sums = mat.col_sums() @@ -70,24 +90,28 @@ test "BiocMatrix col_sums" { assert_eq(sums[0], 4.0) } +///| test "BiocMatrix row_means" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 3.0], [2.0, 4.0]]) let means = mat.row_means() assert_eq(means[0], 2.0) } +///| test "BiocMatrix col_means" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 2.0], [3.0, 4.0]]) let means = mat.col_means() assert_eq(means[0], 2.0) } +///| test "BiocMatrix norm" { let mat = @src.BiocMatrix::dense_from_array([[3.0, 4.0]]) let norm = mat.norm(2.0) assert_eq(norm, 5.0) } +///| test "BiocMatrix dim" { let mat = @src.BiocMatrix::dense_from_array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]) let (nrow, ncol) = mat.dim() @@ -95,17 +119,20 @@ test "BiocMatrix dim" { assert_eq(ncol, 3) } +///| test "BiocMatrix nnz" { let mat = @src.BiocMatrix::csc_from_triplets([0, 1], [0, 1], [1.0, 2.0], 2, 2) assert_eq(mat.nnz(), 2) } +///| test "create_example_dense_matrix" { let mat = @src.create_example_dense_matrix() assert_eq(mat.nrow(), 3) assert_eq(mat.ncol(), 3) } +///| test "create_example_sparse_matrix" { let mat = @src.create_example_sparse_matrix() assert_eq(mat.nrow(), 3) diff --git a/test/moonbit/mauve_test.mbt b/test/moonbit/mauve_test.mbt index ce824abf..aedc8a70 100644 --- a/test/moonbit/mauve_test.mbt +++ b/test/moonbit/mauve_test.mbt @@ -53,8 +53,14 @@ test "mauve_lcb_add_seq" { /// Test MauveLCB consistency check. test "mauve_lcb_consistent" { let lcb = @src.new_mauve_lcb("lcb_1") - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 800)) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 800), + ) assert_true(@src.mauve_lcb_is_consistent(lcb)) } @@ -62,8 +68,14 @@ test "mauve_lcb_consistent" { /// Test MauveLCB inconsistency (mixed strands). test "mauve_lcb_inconsistent" { let lcb = @src.new_mauve_lcb("lcb_1") - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("mouse.chr1", 0, 100, "-", 800)) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("mouse.chr1", 0, 100, "-", 800), + ) assert_false(@src.mauve_lcb_is_consistent(lcb)) } @@ -89,10 +101,16 @@ test "mauve_alignment_add_lcb" { test "mauve_alignment_seq_names" { let ali = @src.new_mauve_alignment() let lcb = @src.new_mauve_lcb("lcb_1") - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 800)) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 800), + ) @src.mauve_add_lcb(ali, lcb) - + let names = @src.mauve_all_seq_names(ali) assert_eq(names.length(), 2) assert_true(names.contains("human.chr1")) @@ -133,17 +151,23 @@ test "mauve_parse_with_inversions" { /// Test detect_mauve_inversions. test "mauve_detect_inversions" { let ali = @src.new_mauve_alignment() - + // LCB 1: positive strand let lcb1 = @src.new_mauve_lcb("lcb_1") - @src.mauve_lcb_add_seq(lcb1, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) + @src.mauve_lcb_add_seq( + lcb1, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) @src.mauve_add_lcb(ali, lcb1) - + // LCB 2: negative strand (inversion) let lcb2 = @src.new_mauve_lcb("lcb_2") - @src.mauve_lcb_add_seq(lcb2, @src.new_mauve_sequence("human.chr1", 100, 100, "-", 1000)) + @src.mauve_lcb_add_seq( + lcb2, + @src.new_mauve_sequence("human.chr1", 100, 100, "-", 1000), + ) @src.mauve_add_lcb(ali, lcb2) - + let ali = @src.detect_mauve_inversions(ali) assert_true(ali.inversions.length() > 0) } @@ -152,15 +176,21 @@ test "mauve_detect_inversions" { /// Test detect_mauve_breakpoints. test "mauve_detect_breakpoints" { let ali = @src.new_mauve_alignment() - + let lcb1 = @src.new_mauve_lcb("lcb_1") - @src.mauve_lcb_add_seq(lcb1, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) + @src.mauve_lcb_add_seq( + lcb1, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) @src.mauve_add_lcb(ali, lcb1) - + let lcb2 = @src.new_mauve_lcb("lcb_2") - @src.mauve_lcb_add_seq(lcb2, @src.new_mauve_sequence("human.chr1", 500, 100, "+", 1000)) + @src.mauve_lcb_add_seq( + lcb2, + @src.new_mauve_sequence("human.chr1", 500, 100, "+", 1000), + ) @src.mauve_add_lcb(ali, lcb2) - + let ali = @src.detect_mauve_breakpoints(ali) assert_true(ali.breakpoints.length() > 0) } @@ -170,10 +200,16 @@ test "mauve_detect_breakpoints" { test "mauve_genome_coverage" { let ali = @src.new_mauve_alignment() let lcb = @src.new_mauve_lcb("lcb_1") - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("human.chr1", 0, 500, "+", 1000)) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("mouse.chr1", 0, 300, "+", 800)) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("human.chr1", 0, 500, "+", 1000), + ) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("mouse.chr1", 0, 300, "+", 800), + ) @src.mauve_add_lcb(ali, lcb) - + let coverage = @src.mauve_genome_coverage(ali) assert_true(coverage.contains("human.chr1")) assert_true(coverage.contains("mouse.chr1")) @@ -185,17 +221,29 @@ test "mauve_genome_coverage" { /// Test mauve_conserved_segments. test "mauve_conserved_segments" { let ali = @src.new_mauve_alignment() - + let lcb1 = @src.new_mauve_lcb("lcb_1") - @src.mauve_lcb_add_seq(lcb1, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) - @src.mauve_lcb_add_seq(lcb1, @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 800)) + @src.mauve_lcb_add_seq( + lcb1, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) + @src.mauve_lcb_add_seq( + lcb1, + @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 800), + ) @src.mauve_add_lcb(ali, lcb1) - + let lcb2 = @src.new_mauve_lcb("lcb_2") - @src.mauve_lcb_add_seq(lcb2, @src.new_mauve_sequence("human.chr1", 500, 100, "+", 1000)) - @src.mauve_lcb_add_seq(lcb2, @src.new_mauve_sequence("mouse.chr1", 500, 100, "+", 800)) + @src.mauve_lcb_add_seq( + lcb2, + @src.new_mauve_sequence("human.chr1", 500, 100, "+", 1000), + ) + @src.mauve_lcb_add_seq( + lcb2, + @src.new_mauve_sequence("mouse.chr1", 500, 100, "+", 800), + ) @src.mauve_add_lcb(ali, lcb2) - + let segments = @src.mauve_conserved_segments(ali) assert_eq(segments["human.chr1"], 2) assert_eq(segments["mouse.chr1"], 2) @@ -215,9 +263,12 @@ test "mauve_to_bed" { let ali = @src.new_mauve_alignment() let lcb = @src.new_mauve_lcb("lcb_1") @src.mauve_lcb_set_score(lcb, 100.0) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) @src.mauve_add_lcb(ali, lcb) - + let bed = @src.mauve_to_bed(ali) assert_true(bed.contains("track name=")) assert_true(bed.contains("human.chr1")) @@ -232,7 +283,7 @@ test "mauve_inversions_to_bed" { let inv = @src.new_mauve_inversion("human.chr1", 100, 200, 100) inv.affected_lcbs.push("lcb_1") ali.inversions.push(inv) - + let bed = @src.mauve_inversions_to_bed(ali) assert_true(bed.contains("track name=\"Inversions\"")) assert_true(bed.contains("human.chr1")) @@ -245,10 +296,16 @@ test "mauve_summary" { let ali = @src.new_mauve_alignment() let lcb = @src.new_mauve_lcb("lcb_1") @src.mauve_lcb_set_score(lcb, 50.0) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 800)) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 800), + ) @src.mauve_add_lcb(ali, lcb) - + let summary = @src.mauve_summary(ali) assert_true(summary.contains("Mauve Alignment Summary")) assert_true(summary.contains("Locally Collinear Blocks")) @@ -270,11 +327,20 @@ test "mauve_config_default" { test "mauve_get_genome_seqs" { let ali = @src.new_mauve_alignment() let lcb = @src.new_mauve_lcb("lcb_1") - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000)) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("human.chr2", 200, 100, "+", 800)) - @src.mauve_lcb_add_seq(lcb, @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 700)) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("human.chr1", 0, 100, "+", 1000), + ) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("human.chr2", 200, 100, "+", 800), + ) + @src.mauve_lcb_add_seq( + lcb, + @src.new_mauve_sequence("mouse.chr1", 0, 100, "+", 700), + ) @src.mauve_add_lcb(ali, lcb) - + let human_seqs = @src.mauve_get_genome_seqs(ali, "human.chr") assert_eq(human_seqs.length(), 2) } @@ -286,7 +352,7 @@ test "mauve_progressive_aligner" { @src.mauve_add_sequence(aligner, "human") @src.mauve_add_sequence(aligner, "mouse") @src.mauve_add_sequence(aligner, "rat") - + @src.mauve_build_guide_tree(aligner) assert_eq(aligner.guide_tree.length(), 3) } diff --git a/test/moonbit/mcp_counter_test.mbt b/test/moonbit/mcp_counter_test.mbt index 3aa346b8..6dc52861 100644 --- a/test/moonbit/mcp_counter_test.mbt +++ b/test/moonbit/mcp_counter_test.mbt @@ -12,6 +12,7 @@ test "mcp_cell_population_struct" { assert_eq(pop.markers().length(), 3) } +///| test "mcp_result_accessors" { // Use mcp_run to get a result with known values let result = @src.mcp_run( @@ -27,6 +28,7 @@ test "mcp_result_accessors" { assert_true((result.scores()[0][0] - 4.0).abs() < 0.001) } +///| test "mcp_result_get_score" { // Build a result with known values via mcp_run // Geometric mean of (4, 9) = 6.0 for S1, (4, 4) = 4.0 for S2 @@ -45,6 +47,7 @@ test "mcp_result_get_score" { assert_true(result.get_score("PopA", "Unknown").abs() < 1.0e-12) } +///| test "mcp_result_get_population_scores" { // Build a result with two populations let result = @src.mcp_run( @@ -72,6 +75,7 @@ test "mcp_result_get_population_scores" { // Built-in populations // --------------------------------------------------------------------------- +///| test "mcp_default_populations_count" { let pops = @src.mcp_default_populations() assert_eq(pops.length(), 10) @@ -81,6 +85,7 @@ test "mcp_default_populations_count" { } } +///| test "mcp_population_names" { let names = @src.mcp_population_names() assert_eq(names.length(), 10) @@ -88,20 +93,27 @@ test "mcp_population_names" { assert_eq(names[9], "Fibroblasts") } +///| test "mcp_default_populations_marker_genes_present" { let pops = @src.mcp_default_populations() // T cells should contain CD3D let t_cells = pops[0] let mut has_cd3d = false for m in t_cells.markers() { - if m == "CD3D" { has_cd3d = true; break } + if m == "CD3D" { + has_cd3d = true + break + } } assert_true(has_cd3d) // B lineage should contain CD19 let b_cells = pops[3] let mut has_cd19 = false for m in b_cells.markers() { - if m == "CD19" { has_cd19 = true; break } + if m == "CD19" { + has_cd19 = true + break + } } assert_true(has_cd19) } @@ -110,74 +122,63 @@ test "mcp_default_populations_marker_genes_present" { // Geometric mean computation via mcp_run // --------------------------------------------------------------------------- +///| test "mcp_run_geometric_mean_correctness" { // Single population with two markers, one sample // Geometric mean of (4.0, 9.0) = sqrt(4 * 9) = 6.0 let pop = @src.McpCellPopulation::new("Test", ["G1", "G2"]) - let result = @src.mcp_run( - ["G1", "G2"], - ["S1"], - [[4.0], [9.0]], - populations=[pop], - ) + let result = @src.mcp_run(["G1", "G2"], ["S1"], [[4.0], [9.0]], populations=[ + pop, + ]) assert_eq(result.populations().length(), 1) assert_eq(result.sample_names().length(), 1) let s = result.get_score("Test", "S1") assert_true((s - 6.0).abs() < 0.001) } +///| test "mcp_run_handles_zero_expression" { // If all marker expressions are zero, score should be 0 let pop = @src.McpCellPopulation::new("Test", ["G1", "G2"]) - let result = @src.mcp_run( - ["G1", "G2"], - ["S1"], - [[0.0], [0.0]], - populations=[pop], - ) + let result = @src.mcp_run(["G1", "G2"], ["S1"], [[0.0], [0.0]], populations=[ + pop, + ]) assert_true(result.get_score("Test", "S1").abs() < 1.0e-12) } +///| test "mcp_run_handles_missing_markers" { // If a marker is not in gene_names, it is skipped let pop = @src.McpCellPopulation::new("Test", ["G1", "MISSING"]) - let result = @src.mcp_run( - ["G1"], - ["S1"], - [[4.0]], - populations=[pop], - ) + let result = @src.mcp_run(["G1"], ["S1"], [[4.0]], populations=[pop]) // Geometric mean of just [4.0] = 4.0 let s = result.get_score("Test", "S1") assert_true((s - 4.0).abs() < 1.0e-9) } +///| test "mcp_run_all_markers_missing" { // If no markers are found, score is 0 let pop = @src.McpCellPopulation::new("Test", ["X1", "X2"]) - let result = @src.mcp_run( - ["G1", "G2"], - ["S1"], - [[4.0], [9.0]], - populations=[pop], - ) + let result = @src.mcp_run(["G1", "G2"], ["S1"], [[4.0], [9.0]], populations=[ + pop, + ]) assert_true(result.get_score("Test", "S1").abs() < 1.0e-12) } +///| test "mcp_run_multiple_samples" { // Two samples, one population let pop = @src.McpCellPopulation::new("Test", ["G1"]) - let result = @src.mcp_run( - ["G1"], - ["S1", "S2"], - [[2.0, 8.0]], - populations=[pop], - ) + let result = @src.mcp_run(["G1"], ["S1", "S2"], [[2.0, 8.0]], populations=[ + pop, + ]) assert_eq(result.sample_names().length(), 2) assert_true((result.get_score("Test", "S1") - 2.0).abs() < 1.0e-9) assert_true((result.get_score("Test", "S2") - 8.0).abs() < 1.0e-9) } +///| test "mcp_run_default_populations" { // Run with default populations on sample data let (genes, samples, matrix) = @src.mcp_sample_data() @@ -196,6 +197,7 @@ test "mcp_run_default_populations" { // Sample data correctness // --------------------------------------------------------------------------- +///| test "mcp_sample_data_t_cell_rich_tumor_a" { // Tumor_A is T-cell rich: T cells (pop 0), CD8+ T cells (pop 1), // Cytotoxic lymphocytes (pop 2) should all score higher than B lineage (pop 3) @@ -206,6 +208,7 @@ test "mcp_sample_data_t_cell_rich_tumor_a" { assert_true(t_cell_a > b_cell_a) } +///| test "mcp_sample_data_b_cell_rich_tumor_b" { // Tumor_B is B-cell rich: B lineage should score higher than T cells let (genes, samples, matrix) = @src.mcp_sample_data() @@ -215,6 +218,7 @@ test "mcp_sample_data_b_cell_rich_tumor_b" { assert_true(b_cell_b > t_cell_b) } +///| test "mcp_sample_data_fibroblast_rich_tumor_c" { // Tumor_C is fibroblast-rich: Fibroblasts (pop 9) should score higher than T cells let (genes, samples, matrix) = @src.mcp_sample_data() @@ -228,6 +232,7 @@ test "mcp_sample_data_fibroblast_rich_tumor_c" { // to_string formatting // --------------------------------------------------------------------------- +///| test "mcp_result_to_string" { let (genes, samples, matrix) = @src.mcp_sample_data() let result = @src.mcp_run(genes, samples, matrix) @@ -242,44 +247,35 @@ test "mcp_result_to_string" { // Empty / edge cases // --------------------------------------------------------------------------- +///| test "mcp_run_empty_population_list" { - let result = @src.mcp_run( - ["G1"], - ["S1"], - [[1.0]], - populations=[], - ) + let result = @src.mcp_run(["G1"], ["S1"], [[1.0]], populations=[]) assert_eq(result.populations().length(), 0) assert_eq(result.sample_names().length(), 1) } +///| test "mcp_run_no_samples" { let pop = @src.McpCellPopulation::new("Test", ["G1"]) - let result = @src.mcp_run( - ["G1"], - [], - [], - populations=[pop], - ) + let result = @src.mcp_run(["G1"], [], [], populations=[pop]) assert_eq(result.sample_names().length(), 0) assert_eq(result.scores().length(), 1) // 1 population row, but empty assert_eq(result.scores()[0].length(), 0) } +///| test "mcp_run_geometric_mean_with_negative_values" { // Negative expression values are skipped (treated as invalid) let pop = @src.McpCellPopulation::new("Test", ["G1", "G2"]) - let result = @src.mcp_run( - ["G1", "G2"], - ["S1"], - [[-1.0], [9.0]], - populations=[pop], - ) + let result = @src.mcp_run(["G1", "G2"], ["S1"], [[-1.0], [9.0]], populations=[ + pop, + ]) // Only G2 contributes -> geometric mean = 9.0 let s = result.get_score("Test", "S1") assert_true((s - 9.0).abs() < 1.0e-9) } +///| test "mcp_run_custom_populations" { // Custom populations list with non-default markers let custom_pop = @src.McpCellPopulation::new("Custom", ["G1", "G2", "G3"]) diff --git a/test/moonbit/melting_temp_test.mbt b/test/moonbit/melting_temp_test.mbt index 00552af2..c9f4ad9e 100644 --- a/test/moonbit/melting_temp_test.mbt +++ b/test/moonbit/melting_temp_test.mbt @@ -53,4 +53,4 @@ test "recommend_tm_method_long" { test "create_example_dna" { let seq = @src.create_example_dna() assert_true(seq.length() > 0) -} \ No newline at end of file +} diff --git a/test/moonbit/meme_test.mbt b/test/moonbit/meme_test.mbt index e249cbfc..3946a1c2 100644 --- a/test/moonbit/meme_test.mbt +++ b/test/moonbit/meme_test.mbt @@ -3,10 +3,7 @@ ///| test "meme_motif_new" { - let pspm = [ - [0.25, 0.25, 0.25, 0.25], - [0.5, 0.0, 0.5, 0.0], - ] + let pspm = [[0.25, 0.25, 0.25, 0.25], [0.5, 0.0, 0.5, 0.0]] let motif = @src.MemeMotif::new("motif1", pspm) assert_eq(motif.name, "motif1") assert_eq(motif.alt_name, "") @@ -27,11 +24,7 @@ test "meme_motif_new_custom_alphabet" { ///| test "meme_motif_consensus" { - let pspm = [ - [0.9, 0.0, 0.1, 0.0], - [0.0, 0.8, 0.0, 0.2], - [0.1, 0.0, 0.9, 0.0], - ] + let pspm = [[0.9, 0.0, 0.1, 0.0], [0.0, 0.8, 0.0, 0.2], [0.1, 0.0, 0.9, 0.0]] let motif = @src.MemeMotif::new("m1", pspm, alphabet="ACGT") let cons = motif.consensus() assert_eq(cons, "ACG") @@ -39,10 +32,7 @@ test "meme_motif_consensus" { ///| test "meme_motif_probability" { - let pspm = [ - [0.9, 0.0, 0.1, 0.0], - [0.0, 0.8, 0.0, 0.2], - ] + let pspm = [[0.9, 0.0, 0.1, 0.0], [0.0, 0.8, 0.0, 0.2]] let motif = @src.MemeMotif::new("m1", pspm, alphabet="ACGT") assert_eq(motif.probability("A", 0), 0.9) assert_eq(motif.probability("C", 0), 0.0) @@ -55,10 +45,7 @@ test "meme_motif_probability" { ///| test "meme_motif_information_content" { - let pspm = [ - [1.0, 0.0, 0.0, 0.0], - [0.25, 0.25, 0.25, 0.25], - ] + let pspm = [[1.0, 0.0, 0.0, 0.0], [0.25, 0.25, 0.25, 0.25]] let motif = @src.MemeMotif::new("m1", pspm, alphabet="ACGT") let ic = motif.information_content() // First position has max info (2 bits), second has 0 diff --git a/test/moonbit/metagenomeseq_test.mbt b/test/moonbit/metagenomeseq_test.mbt index 82c75bbd..36f66e2d 100644 --- a/test/moonbit/metagenomeseq_test.mbt +++ b/test/moonbit/metagenomeseq_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for metagenomeSeq module. - test "MRexperiment creation" { let counts = [[10, 20], [30, 40]] let taxa_names = ["Bacteroides", "Firmicutes"] @@ -10,25 +9,31 @@ test "MRexperiment creation" { assert_eq(obj.sample_names.length(), 2) } +///| test "mg_normalize_counts" { let obj = @src.create_example_mrexperiment() let normalized = @src.mg_normalize_counts(obj) assert_eq(normalized.counts.length(), obj.counts.length()) } +///| test "mg_calculate_zero_inflation" { let obj = @src.create_example_mrexperiment() let zero_probs = @src.mg_calculate_zero_inflation(obj) assert_eq(zero_probs.length(), obj.taxa_names.length()) } +///| test "mg_test_zero_inflated" { let obj = @src.create_example_mrexperiment() - let group = ["control", "control", "control", "treatment", "treatment", "treatment"] + let group = [ + "control", "control", "control", "treatment", "treatment", "treatment", + ] let results = @src.mg_test_zero_inflated(obj, group) assert_eq(results.length(), obj.taxa_names.length()) } +///| test "MRSampleData creation" { let sd = @src.MRSampleData::new("control", 100000) assert_eq(sd.group, "control") diff --git a/test/moonbit/methyl_seekr_test.mbt b/test/moonbit/methyl_seekr_test.mbt index 043b2b92..a0cbda51 100644 --- a/test/moonbit/methyl_seekr_test.mbt +++ b/test/moonbit/methyl_seekr_test.mbt @@ -219,7 +219,9 @@ test "msr_tiling_single_site" { assert_eq(@src.MethylTile::start(tiles[0]), 0) assert_eq(@src.MethylTile::end(tiles[0]), 1000) assert_eq(@src.MethylTile::coverage(tiles[0]), 10) - assert_true((@src.MethylTile::methylation_level(tiles[0]) - 0.4).abs() < 0.000001) + assert_true( + (@src.MethylTile::methylation_level(tiles[0]) - 0.4).abs() < 0.000001, + ) // Newly created tiles default to "FMR". assert_eq(@src.MethylTile::region_type(tiles[0]), "FMR") } @@ -229,9 +231,24 @@ test "msr_tiling_boundaries" { // A site at position 999 falls in tile [0,1000); at 1000 in [1000,2000). let params = @src.MethylSeekRParams::default() let sites = [ - @src.CytosineSite::new(chr="chr1", position=999, methylated=1, unmethylated=0), - @src.CytosineSite::new(chr="chr1", position=1000, methylated=1, unmethylated=0), - @src.CytosineSite::new(chr="chr1", position=2500, methylated=0, unmethylated=1), + @src.CytosineSite::new( + chr="chr1", + position=999, + methylated=1, + unmethylated=0, + ), + @src.CytosineSite::new( + chr="chr1", + position=1000, + methylated=1, + unmethylated=0, + ), + @src.CytosineSite::new( + chr="chr1", + position=2500, + methylated=0, + unmethylated=1, + ), ] let tiles = @src.tile_methylation(sites, params) assert_eq(tiles.length(), 3) @@ -248,8 +265,18 @@ test "msr_tiling_methylation_computation" { // Two sites in the same tile: (3,7) and (2,8) -> meth=5, unmeth=15 -> 0.25. let params = @src.MethylSeekRParams::default() let sites = [ - @src.CytosineSite::new(chr="chr1", position=100, methylated=3, unmethylated=7), - @src.CytosineSite::new(chr="chr1", position=200, methylated=2, unmethylated=8), + @src.CytosineSite::new( + chr="chr1", + position=100, + methylated=3, + unmethylated=7, + ), + @src.CytosineSite::new( + chr="chr1", + position=200, + methylated=2, + unmethylated=8, + ), ] let tiles = @src.tile_methylation(sites, params) assert_eq(tiles.length(), 1) @@ -264,9 +291,24 @@ test "msr_tiling_coverage_aggregation" { // Coverage from multiple sites is summed per tile. let params = @src.MethylSeekRParams::default() let sites = [ - @src.CytosineSite::new(chr="chr1", position=100, methylated=1, unmethylated=4), - @src.CytosineSite::new(chr="chr1", position=200, methylated=2, unmethylated=3), - @src.CytosineSite::new(chr="chr1", position=300, methylated=0, unmethylated=5), + @src.CytosineSite::new( + chr="chr1", + position=100, + methylated=1, + unmethylated=4, + ), + @src.CytosineSite::new( + chr="chr1", + position=200, + methylated=2, + unmethylated=3, + ), + @src.CytosineSite::new( + chr="chr1", + position=300, + methylated=0, + unmethylated=5, + ), ] let tiles = @src.tile_methylation(sites, params) assert_eq(tiles.length(), 1) @@ -282,9 +324,24 @@ test "msr_tiling_multiple_chromosomes" { // Tiles are sorted by chromosome name then start. let params = @src.MethylSeekRParams::default() let sites = [ - @src.CytosineSite::new(chr="chr2", position=50, methylated=1, unmethylated=1), - @src.CytosineSite::new(chr="chr1", position=100, methylated=1, unmethylated=1), - @src.CytosineSite::new(chr="chr1", position=1500, methylated=1, unmethylated=1), + @src.CytosineSite::new( + chr="chr2", + position=50, + methylated=1, + unmethylated=1, + ), + @src.CytosineSite::new( + chr="chr1", + position=100, + methylated=1, + unmethylated=1, + ), + @src.CytosineSite::new( + chr="chr1", + position=1500, + methylated=1, + unmethylated=1, + ), ] let tiles = @src.tile_methylation(sites, params) assert_eq(tiles.length(), 3) @@ -786,7 +843,12 @@ test "msr_edge_empty_pipeline" { test "msr_edge_single_site" { let params = @src.MethylSeekRParams::default() let sites = [ - @src.CytosineSite::new(chr="chr1", position=100, methylated=0, unmethylated=20), + @src.CytosineSite::new( + chr="chr1", + position=100, + methylated=0, + unmethylated=20, + ), ] let regions = @src.call_methylation_regimes(sites, params) // Single tile of 1000 bp >= min_region_size (500) -> one UMR region. @@ -848,7 +910,12 @@ test "msr_edge_zero_coverage_sites" { // which classifies as FMR (insufficient coverage). let params = @src.MethylSeekRParams::default() let sites = [ - @src.CytosineSite::new(chr="chr1", position=100, methylated=0, unmethylated=0), + @src.CytosineSite::new( + chr="chr1", + position=100, + methylated=0, + unmethylated=0, + ), ] let tiles = @src.tile_methylation(sites, params) assert_eq(tiles.length(), 1) diff --git a/test/moonbit/methylkit_test.mbt b/test/moonbit/methylkit_test.mbt index 566f93c7..5f48f9db 100644 --- a/test/moonbit/methylkit_test.mbt +++ b/test/moonbit/methylkit_test.mbt @@ -22,7 +22,9 @@ test "methylkit_cytosine_coverage_pct" { // 50% methylation let mc_half = @src.MethylCytosine::new("chr1", 200, "-", "CG", 5, 5) assert_eq(@src.MethylCytosine::coverage(mc_half), 10) - assert_true((@src.MethylCytosine::methylation_pct(mc_half) - 50.0).abs() < 0.001) + assert_true( + (@src.MethylCytosine::methylation_pct(mc_half) - 50.0).abs() < 0.001, + ) // Zero coverage -> coverage 0 and pct 0.0 let mc0 = @src.MethylCytosine::new("chr1", 300, "+", "CG", 0, 0) assert_eq(@src.MethylCytosine::coverage(mc0), 0) @@ -151,7 +153,9 @@ test "methylkit_config_defaults" { assert_eq(@src.MethylKitConfig::min_coverage(config), 10) assert_eq(@src.MethylKitConfig::max_coverage(config), 999) assert_eq(@src.MethylKitConfig::context_filter(config), "CG") - assert_true((@src.MethylKitConfig::min_perc_samples(config) - 0.6).abs() < 0.001) + assert_true( + (@src.MethylKitConfig::min_perc_samples(config) - 0.6).abs() < 0.001, + ) assert_true((@src.MethylKitConfig::min_diff(config) - 25.0).abs() < 0.001) assert_true((@src.MethylKitConfig::q_threshold(config) - 0.05).abs() < 0.001) } @@ -162,7 +166,9 @@ test "methylkit_config_with_params" { assert_eq(@src.MethylKitConfig::min_coverage(config), 5) assert_eq(@src.MethylKitConfig::max_coverage(config), 500) assert_eq(@src.MethylKitConfig::context_filter(config), "CHG") - assert_true((@src.MethylKitConfig::min_perc_samples(config) - 0.8).abs() < 0.001) + assert_true( + (@src.MethylKitConfig::min_perc_samples(config) - 0.8).abs() < 0.001, + ) assert_true((@src.MethylKitConfig::min_diff(config) - 30.0).abs() < 0.001) assert_true((@src.MethylKitConfig::q_threshold(config) - 0.01).abs() < 0.001) } @@ -466,9 +472,13 @@ test "methylkit_sample_data" { assert_eq(@src.MethylSample::n_cpgs(control), 20) assert_eq(@src.MethylSample::n_cpgs(treatment), 20) // Control: every CpG at 50% methylation. - assert_true((@src.MethylSample::mean_methylation(control) - 50.0).abs() < 0.001) + assert_true( + (@src.MethylSample::mean_methylation(control) - 50.0).abs() < 0.001, + ) // Treatment: 5 hyper (90%) + 5 hypo (10%) + 10 same (50%) -> mean 50%. - assert_true((@src.MethylSample::mean_methylation(treatment) - 50.0).abs() < 0.001) + assert_true( + (@src.MethylSample::mean_methylation(treatment) - 50.0).abs() < 0.001, + ) // Treatment CpG 0: hyper-methylated (18, 2). let t0 = @src.MethylSample::coverage(treatment)[0] assert_eq(@src.MethylCytosine::methylated(t0), 18) diff --git a/test/moonbit/microbiome_test.mbt b/test/moonbit/microbiome_test.mbt index 3337a2e9..c91708fa 100644 --- a/test/moonbit/microbiome_test.mbt +++ b/test/moonbit/microbiome_test.mbt @@ -11,12 +11,14 @@ test "calc_observed basic" { assert_eq(observed, 4.0) } +///| test "calc_observed all zeros" { let counts : Array[Double] = [0.0, 0.0, 0.0] let observed = @src.calc_observed(counts) assert_eq(observed, 0.0) } +///| test "calc_shannon even" { let counts : Array[Double] = [10.0, 10.0, 10.0, 10.0] let shannon = @src.calc_shannon(counts) @@ -24,12 +26,14 @@ test "calc_shannon even" { assert_true(shannon > 1.3 && shannon < 1.5) } +///| test "calc_shannon single taxon" { let counts : Array[Double] = [100.0] let shannon = @src.calc_shannon(counts) assert_eq(shannon, 0.0) } +///| test "calc_simpson even" { let counts : Array[Double] = [10.0, 10.0, 10.0, 10.0] let simpson = @src.calc_simpson(counts) @@ -37,12 +41,14 @@ test "calc_simpson even" { assert_true(simpson > 0.7 && simpson < 0.8) } +///| test "calc_simpson single taxon" { let counts : Array[Double] = [100.0] let simpson = @src.calc_simpson(counts) assert_eq(simpson, 0.0) } +///| test "calc_inv_simpson even" { let counts : Array[Double] = [10.0, 10.0, 10.0, 10.0] let inv_simpson = @src.calc_inv_simpson(counts) @@ -50,6 +56,7 @@ test "calc_inv_simpson even" { assert_true(inv_simpson > 3.5 && inv_simpson < 4.5) } +///| test "calc_pielou_evenness even" { let counts : Array[Double] = [10.0, 10.0, 10.0, 10.0] let pielou = @src.calc_pielou_evenness(counts) @@ -57,12 +64,14 @@ test "calc_pielou_evenness even" { assert_true(pielou > 0.95) } +///| test "calc_pielou_evenness single taxon" { let counts : Array[Double] = [100.0] let pielou = @src.calc_pielou_evenness(counts) assert_eq(pielou, 0.0) } +///| test "calc_chao1 basic" { let counts : Array[Double] = [10.0, 5.0, 3.0, 1.0, 1.0, 2.0, 2.0] let chao1 = @src.calc_chao1(counts) @@ -71,12 +80,14 @@ test "calc_chao1 basic" { assert_true(chao1 >= 7.0) } +///| test "calc_fisher_alpha basic" { let counts : Array[Double] = [100.0, 50.0, 30.0, 20.0, 10.0] let alpha = @src.calc_fisher_alpha(counts) assert_true(alpha > 0.0) } +///| test "calc_alpha_diversity all indices" { let counts : Array[Double] = [10.0, 20.0, 15.0, 5.0, 25.0] let div = @src.calc_alpha_diversity(counts) @@ -87,6 +98,7 @@ test "calc_alpha_diversity all indices" { assert_true(div.chao1 >= div.observed) } +///| test "calc_alpha_diversity_table multiple samples" { let otu_table = @src.create_example_otu_table() let div_table = @src.calc_alpha_diversity_table(otu_table) @@ -99,6 +111,7 @@ test "calc_alpha_diversity_table multiple samples" { // Beta Diversity Tests // ============================================================ +///| test "bray_curtis identical" { let x : Array[Double] = [10.0, 20.0, 30.0] let y : Array[Double] = [10.0, 20.0, 30.0] @@ -106,6 +119,7 @@ test "bray_curtis identical" { assert_eq(bc, 0.0) } +///| test "bray_curtis completely different" { let x : Array[Double] = [10.0, 0.0, 0.0] let y : Array[Double] = [0.0, 20.0, 30.0] @@ -114,6 +128,7 @@ test "bray_curtis completely different" { assert_eq(bc, 1.0) } +///| test "bray_curtis partial overlap" { let x : Array[Double] = [10.0, 20.0, 0.0] let y : Array[Double] = [10.0, 0.0, 20.0] @@ -121,6 +136,7 @@ test "bray_curtis partial overlap" { assert_true(bc > 0.0 && bc < 1.0) } +///| test "jaccard_distance identical" { let x : Array[Double] = [10.0, 20.0, 30.0] let y : Array[Double] = [5.0, 10.0, 15.0] @@ -128,6 +144,7 @@ test "jaccard_distance identical" { assert_eq(jaccard, 0.0) } +///| test "jaccard_distance no overlap" { let x : Array[Double] = [10.0, 0.0, 0.0] let y : Array[Double] = [0.0, 20.0, 30.0] @@ -135,6 +152,7 @@ test "jaccard_distance no overlap" { assert_eq(jaccard, 1.0) } +///| test "jaccard_distance partial" { let x : Array[Double] = [10.0, 20.0, 0.0] let y : Array[Double] = [10.0, 0.0, 20.0] @@ -143,6 +161,7 @@ test "jaccard_distance partial" { assert_true(jaccard > 0.6 && jaccard < 0.7) } +///| test "jensen_shannon_divergence identical" { let x : Array[Double] = [10.0, 20.0, 30.0] let y : Array[Double] = [10.0, 20.0, 30.0] @@ -150,6 +169,7 @@ test "jensen_shannon_divergence identical" { assert_eq(jsd, 0.0) } +///| test "jensen_shannon_divergence symmetric" { let x : Array[Double] = [10.0, 20.0, 30.0] let y : Array[Double] = [30.0, 20.0, 10.0] @@ -158,6 +178,7 @@ test "jensen_shannon_divergence symmetric" { assert_true((jsd_xy - jsd_yx).abs() < 0.0001) } +///| test "calc_beta_diversity_matrix bray" { let otu_table = @src.create_example_otu_table() let dist_matrix = @src.calc_beta_diversity_matrix(otu_table, "bray") @@ -170,6 +191,7 @@ test "calc_beta_diversity_matrix bray" { assert_true((dist_matrix[0][1] - dist_matrix[1][0]).abs() < 0.0001) } +///| test "calc_beta_diversity_matrix jaccard" { let otu_table = @src.create_example_otu_table() let dist_matrix = @src.calc_beta_diversity_matrix(otu_table, "jaccard") @@ -177,6 +199,7 @@ test "calc_beta_diversity_matrix jaccard" { assert_true(dist_matrix[0][3] > 0.0) } +///| test "calc_beta_diversity_matrix jsd" { let otu_table = @src.create_example_otu_table() let dist_matrix = @src.calc_beta_diversity_matrix(otu_table, "jsd") @@ -188,22 +211,24 @@ test "calc_beta_diversity_matrix jsd" { // PCoA Tests // ============================================================ +///| test "pcoa basic" { let otu_table = @src.create_example_otu_table() let dist_matrix = @src.calc_beta_diversity_matrix(otu_table, "bray") let pcoa_result = @src.pcoa(dist_matrix) - + assert_true(pcoa_result.eigenvalues.length() > 0) assert_true(pcoa_result.vectors.length() == 6) assert_true(pcoa_result.variance_explained.length() > 0) assert_true(pcoa_result.cumulative_variance.length() > 0) } +///| test "pcoa eigenvalues positive" { let otu_table = @src.create_example_otu_table() let dist_matrix = @src.calc_beta_diversity_matrix(otu_table, "bray") let pcoa_result = @src.pcoa(dist_matrix) - + let mut i = 0 while i < pcoa_result.eigenvalues.length() { assert_true(pcoa_result.eigenvalues[i] >= 0.0) @@ -211,17 +236,19 @@ test "pcoa eigenvalues positive" { } } +///| test "pcoa has vectors" { let otu_table = @src.create_example_otu_table() let dist_matrix = @src.calc_beta_diversity_matrix(otu_table, "bray") let pcoa_result = @src.pcoa(dist_matrix) - + assert_true(pcoa_result.vectors.length() == 6) if pcoa_result.vectors.length() > 0 { assert_true(pcoa_result.vectors[0].length() > 0) } } +///| test "pcoa single sample" { let dist_matrix : Array[Array[Double]] = [[0.0]] let pcoa_result = @src.pcoa(dist_matrix) @@ -232,41 +259,50 @@ test "pcoa single sample" { // Differential Abundance Tests // ============================================================ +///| test "differential_abundance basic" { let otu_table = @src.create_example_otu_table() let taxa_names = @src.get_example_taxa_names() let group1 : Array[Int] = [0, 1, 2] let group2 : Array[Int] = [3, 4, 5] - - let results = @src.differential_abundance(otu_table, taxa_names, group1, group2) - + + let results = @src.differential_abundance( + otu_table, taxa_names, group1, group2, + ) + assert_eq(results.length(), 10) assert_eq(results[0].taxa, "Bacteroides") assert_true(results[0].p_value >= 0.0 && results[0].p_value <= 1.0) assert_true(results[0].adjusted_p_value >= results[0].p_value) } +///| test "differential_abundance log2_fc direction" { let otu_table = @src.create_example_otu_table() let taxa_names = @src.get_example_taxa_names() - let group1 : Array[Int] = [0, 1, 2] // control - let group2 : Array[Int] = [3, 4, 5] // treatment - - let results = @src.differential_abundance(otu_table, taxa_names, group1, group2) - + let group1 : Array[Int] = [0, 1, 2] // control + let group2 : Array[Int] = [3, 4, 5] // treatment + + let results = @src.differential_abundance( + otu_table, taxa_names, group1, group2, + ) + // Taxon 0 (Bacteroides) is high in control, so log2FC should be negative assert_true(results[0].log2_fold_change < 0.0) // Taxon 1 (Prevotella) is high in treatment, so log2FC should be positive assert_true(results[1].log2_fold_change > 0.0) } +///| test "differential_abundance empty input" { let otu_table : Array[Array[Double]] = [] let taxa_names : Array[String] = [] let group1 : Array[Int] = [0, 1] let group2 : Array[Int] = [2, 3] - - let results = @src.differential_abundance(otu_table, taxa_names, group1, group2) + + let results = @src.differential_abundance( + otu_table, taxa_names, group1, group2, + ) assert_eq(results.length(), 0) } @@ -274,12 +310,14 @@ test "differential_abundance empty input" { // Helper function tests // ============================================================ +///| test "create_example_otu_table dimensions" { let otu_table = @src.create_example_otu_table() - assert_eq(otu_table.length(), 10) // 10 taxa - assert_eq(otu_table[0].length(), 6) // 6 samples + assert_eq(otu_table.length(), 10) // 10 taxa + assert_eq(otu_table[0].length(), 6) // 6 samples } +///| test "get_example_taxa_names" { let names = @src.get_example_taxa_names() assert_eq(names.length(), 10) diff --git a/test/moonbit/missmethyl_test.mbt b/test/moonbit/missmethyl_test.mbt index d87af891..c2d43cfc 100644 --- a/test/moonbit/missmethyl_test.mbt +++ b/test/moonbit/missmethyl_test.mbt @@ -119,7 +119,7 @@ test "mm_beta_to_m_basic" { assert_true(m.abs() < 0.01) // beta = 0.25 -> M = log2(0.25/0.75) = log2(1/3) ≈ -1.585 let m2 = @src.mm_beta_to_m(0.25) - assert_true((m2 - (-1.585)).abs() < 0.01) + assert_true((m2 - -1.585).abs() < 0.01) // beta = 0.75 -> M = log2(0.75/0.25) = log2(3) ≈ 1.585 let m3 = @src.mm_beta_to_m(0.75) assert_true((m3 - 1.585).abs() < 0.01) @@ -360,14 +360,11 @@ test "mm_go_enrichment_sample" { let annotations = @src.mm_sample_annotations() let go_db = @src.mm_sample_go_database() let all_probes : Array[String] = [ - "cg001", "cg002", "cg003", "cg004", "cg005", - "cg006", "cg007", "cg008", "cg009", "cg010", - "cg011", "cg012", "cg013", "cg014", "cg015", - "cg016", "cg017", "cg018", "cg019", "cg020", - ] - let sig_probes : Array[String] = [ - "cg001", "cg002", "cg003", "cg004", "cg005", + "cg001", "cg002", "cg003", "cg004", "cg005", "cg006", "cg007", "cg008", "cg009", + "cg010", "cg011", "cg012", "cg013", "cg014", "cg015", "cg016", "cg017", "cg018", + "cg019", "cg020", ] + let sig_probes : Array[String] = ["cg001", "cg002", "cg003", "cg004", "cg005"] let results = @src.mm_go_enrichment( sig_probes, all_probes, annotations, go_db, ) @@ -387,14 +384,11 @@ test "mm_go_enrichment_finds_enriched" { let annotations = @src.mm_sample_annotations() let go_db = @src.mm_sample_go_database() let all_probes : Array[String] = [ - "cg001", "cg002", "cg003", "cg004", "cg005", - "cg006", "cg007", "cg008", "cg009", "cg010", - "cg011", "cg012", "cg013", "cg014", "cg015", - "cg016", "cg017", "cg018", "cg019", "cg020", - ] - let sig_probes : Array[String] = [ - "cg001", "cg002", "cg003", "cg004", "cg005", + "cg001", "cg002", "cg003", "cg004", "cg005", "cg006", "cg007", "cg008", "cg009", + "cg010", "cg011", "cg012", "cg013", "cg014", "cg015", "cg016", "cg017", "cg018", + "cg019", "cg020", ] + let sig_probes : Array[String] = ["cg001", "cg002", "cg003", "cg004", "cg005"] let results = @src.mm_go_enrichment( sig_probes, all_probes, annotations, go_db, ) @@ -420,14 +414,11 @@ test "mm_probe_bias_correction_sample" { let annotations = @src.mm_sample_annotations() let go_db = @src.mm_sample_go_database() let all_probes : Array[String] = [ - "cg001", "cg002", "cg003", "cg004", "cg005", - "cg006", "cg007", "cg008", "cg009", "cg010", - "cg011", "cg012", "cg013", "cg014", "cg015", - "cg016", "cg017", "cg018", "cg019", "cg020", - ] - let sig_probes : Array[String] = [ - "cg001", "cg002", "cg003", "cg004", "cg005", + "cg001", "cg002", "cg003", "cg004", "cg005", "cg006", "cg007", "cg008", "cg009", + "cg010", "cg011", "cg012", "cg013", "cg014", "cg015", "cg016", "cg017", "cg018", + "cg019", "cg020", ] + let sig_probes : Array[String] = ["cg001", "cg002", "cg003", "cg004", "cg005"] let results = @src.mm_probe_bias_correction( sig_probes, all_probes, annotations, go_db, ) @@ -460,14 +451,11 @@ test "mm_go_summary_nonempty" { let annotations = @src.mm_sample_annotations() let go_db = @src.mm_sample_go_database() let all_probes : Array[String] = [ - "cg001", "cg002", "cg003", "cg004", "cg005", - "cg006", "cg007", "cg008", "cg009", "cg010", - "cg011", "cg012", "cg013", "cg014", "cg015", - "cg016", "cg017", "cg018", "cg019", "cg020", - ] - let sig_probes : Array[String] = [ - "cg001", "cg002", "cg003", "cg004", "cg005", + "cg001", "cg002", "cg003", "cg004", "cg005", "cg006", "cg007", "cg008", "cg009", + "cg010", "cg011", "cg012", "cg013", "cg014", "cg015", "cg016", "cg017", "cg018", + "cg019", "cg020", ] + let sig_probes : Array[String] = ["cg001", "cg002", "cg003", "cg004", "cg005"] let results = @src.mm_go_enrichment( sig_probes, all_probes, annotations, go_db, ) @@ -573,9 +561,7 @@ test "mm_edge_all_same_group" { let beta = @src.mm_sample_beta() let annotations = @src.mm_sample_annotations() // All samples in treatment group (no control). - let group = [ - true, true, true, true, true, true, true, true, - ] + let group = [true, true, true, true, true, true, true, true] let results = @src.mm_dmp_analysis(beta, group, annotations) assert_eq(results.length(), 20) // With no control group, all p-values should be 1.0. diff --git a/test/moonbit/mix_omics_test.mbt b/test/moonbit/mix_omics_test.mbt index 0c8c911f..53a4dce9 100644 --- a/test/moonbit/mix_omics_test.mbt +++ b/test/moonbit/mix_omics_test.mbt @@ -54,7 +54,14 @@ test "diablo_new_defaults" { ///| test "diablo_options_full_custom" { let design = [[0.0, 1.0], [1.0, 0.0]] - let opts = @src.diablo_options_full(3, [[2, 3], [1]], design, false, 200, 1.0e-7) + let opts = @src.diablo_options_full( + 3, + [[2, 3], [1]], + design, + false, + 200, + 1.0e-7, + ) assert_eq(opts.ncomp, 3) assert_eq(opts.keep_variables.length(), 2) assert_eq(opts.keep_variables[0].length(), 2) @@ -106,12 +113,7 @@ test "pls_component_extraction" { ///| test "pls_single_component" { - let x = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 4.0], - [4.0, 5.0], - ] + let x = [[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0]] let y = [[1.0], [2.0], [3.0], [4.0]] let opts = @src.pls_options_full(1, "regression", true, 500, 0.000001) let result = @src.run_pls(x, y, opts) @@ -140,16 +142,12 @@ test "pls_nipals_convergence" { ///| test "pls_data_scaling" { - let x = [ - [1.0, 100.0], - [2.0, 200.0], - [3.0, 300.0], - [4.0, 400.0], - [5.0, 500.0], - ] + let x = [[1.0, 100.0], [2.0, 200.0], [3.0, 300.0], [4.0, 400.0], [5.0, 500.0]] let y = [[1.0], [2.0], [3.0], [4.0], [5.0]] let opts_scaled = @src.pls_options_full(1, "regression", true, 500, 0.000001) - let opts_unscaled = @src.pls_options_full(1, "regression", false, 500, 0.000001) + let opts_unscaled = @src.pls_options_full( + 1, "regression", false, 500, 0.000001, + ) let result_scaled = @src.run_pls(x, y, opts_scaled) let result_unscaled = @src.run_pls(x, y, opts_unscaled) assert_true(result_scaled.ncomp >= 1) @@ -183,11 +181,7 @@ test "pls_ncomp_exceeds_samples" { ///| test "pls_ncomp_exceeds_variables" { - let x = [ - [1.0, 2.0, 3.0], - [2.0, 3.0, 4.0], - [3.0, 4.0, 5.0], - ] + let x = [[1.0, 2.0, 3.0], [2.0, 3.0, 4.0], [3.0, 4.0, 5.0]] let y = [[1.0], [2.0], [3.0]] let opts = @src.pls_options_full(10, "regression", true, 500, 0.000001) let result = @src.run_pls(x, y, opts) @@ -219,13 +213,7 @@ test "pls_single_sample" { ///| test "pls_multivariate_y" { - let x = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 4.0], - [4.0, 5.0], - [5.0, 6.0], - ] + let x = [[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0], [5.0, 6.0]] let y = [[1.0, 0.5], [2.0, 1.0], [3.0, 1.5], [4.0, 2.0], [5.0, 2.5]] let opts = @src.pls_new() let result = @src.run_pls(x, y, opts) @@ -235,13 +223,7 @@ test "pls_multivariate_y" { ///| test "pls_canonical_mode" { - let x = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 4.0], - [4.0, 5.0], - [5.0, 6.0], - ] + let x = [[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0], [5.0, 6.0]] let y = [[1.0], [2.0], [3.0], [4.0], [5.0]] let opts = @src.pls_options_full(2, "canonical", true, 500, 0.000001) let result = @src.run_pls(x, y, opts) @@ -339,7 +321,7 @@ test "soft_thresholding_operator" { let result1 = @src.soft_threshold(3.0, 1.0) assert_true((result1 - 2.0).abs() < 1.0e-15) let result2 = @src.soft_threshold(-3.0, 1.0) - assert_true((result2 - (-2.0)).abs() < 1.0e-15) + assert_true((result2 - -2.0).abs() < 1.0e-15) let result3 = @src.soft_threshold(0.5, 1.0) assert_true(result3.abs() < 1.0e-15) let result4 = @src.soft_threshold(0.0, 0.0) @@ -355,13 +337,7 @@ test "diablo_two_blocks" { [4.0, 5.0, 6.0], [5.0, 6.0, 7.0], ] - let block2 = [ - [1.0, 0.5], - [2.0, 1.0], - [3.0, 1.5], - [4.0, 2.0], - [5.0, 2.5], - ] + let block2 = [[1.0, 0.5], [2.0, 1.0], [3.0, 1.5], [4.0, 2.0], [5.0, 2.5]] let blocks = [block1, block2] let names = ["block1", "block2"] let design = [[0.0, 1.0], [1.0, 0.0]] @@ -390,25 +366,22 @@ test "diablo_variable_selection" { let blocks = [block1, block2] let names = ["block1", "block2"] let design = [[0.0, 1.0], [1.0, 0.0]] - let opts = @src.diablo_options_full(1, [[2], [1]], design, true, 500, 0.000001) + let opts = @src.diablo_options_full( + 1, + [[2], [1]], + design, + true, + 500, + 0.000001, + ) let result = @src.run_diablo(blocks, names, opts) assert_true(result.ncomp >= 1) } ///| test "diablo_default_behavior" { - let block1 = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 4.0], - [4.0, 5.0], - ] - let block2 = [ - [1.0, 0.5], - [2.0, 1.0], - [3.0, 1.5], - [4.0, 2.0], - ] + let block1 = [[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0]] + let block2 = [[1.0, 0.5], [2.0, 1.0], [3.0, 1.5], [4.0, 2.0]] let blocks = [block1, block2] let names = ["block1", "block2"] let opts = @src.diablo_new() @@ -419,11 +392,7 @@ test "diablo_default_behavior" { ///| test "diablo_single_block" { - let block1 = [ - [1.0, 2.0, 3.0], - [2.0, 3.0, 4.0], - [3.0, 4.0, 5.0], - ] + let block1 = [[1.0, 2.0, 3.0], [2.0, 3.0, 4.0], [3.0, 4.0, 5.0]] let blocks = [block1] let names = ["block1"] let design = [[0.0]] @@ -528,13 +497,7 @@ test "diablo_result_structure" { ///| test "pls_mode_regression" { - let x = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 4.0], - [4.0, 5.0], - [5.0, 6.0], - ] + let x = [[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0], [5.0, 6.0]] let y = [[1.0], [2.0], [3.0], [4.0], [5.0]] let opts = @src.pls_options_full(2, "regression", true, 500, 0.000001) let result = @src.run_pls(x, y, opts) @@ -544,13 +507,7 @@ test "pls_mode_regression" { ///| test "pls_mode_invariant_scores" { - let x = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 4.0], - [4.0, 5.0], - [5.0, 6.0], - ] + let x = [[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0], [5.0, 6.0]] let y = [[1.0], [2.0], [3.0], [4.0], [5.0]] let opts = @src.pls_options_full(1, "regression", false, 500, 0.000001) let result = @src.run_pls(x, y, opts) @@ -574,12 +531,7 @@ test "diablo_block_names" { ///| test "pls_result_has_explained_variance" { - let x = [ - [1.0, 2.0, 3.0], - [2.0, 3.0, 4.0], - [3.0, 4.0, 5.0], - [4.0, 5.0, 6.0], - ] + let x = [[1.0, 2.0, 3.0], [2.0, 3.0, 4.0], [3.0, 4.0, 5.0], [4.0, 5.0, 6.0]] let y = [[1.0], [2.0], [3.0], [4.0]] let opts = @src.pls_options_full(2, "regression", true, 500, 0.000001) let result = @src.run_pls(x, y, opts) @@ -601,4 +553,4 @@ test "spls_selected_variables" { assert_true(result.ncomp >= 1) assert_true(result.x_selected.length() >= 1) assert_true(result.y_selected.length() >= 1) -} \ No newline at end of file +} diff --git a/test/moonbit/mmcifio_test.mbt b/test/moonbit/mmcifio_test.mbt index 00ae62a9..5cb26e47 100644 --- a/test/moonbit/mmcifio_test.mbt +++ b/test/moonbit/mmcifio_test.mbt @@ -273,36 +273,26 @@ test "mmcifio_write_single_residue" { ///| test "mmcifio_write_single_chain" { - let r1 = @src.Residue::new( - resname="ALA", - chainid='A', - resseq=1, - atoms=[ - @src.Atom::new( - name="N", - coord=@src.Vector3::new(0.0, 0.0, 0.0), - resname="ALA", - chainid='A', - resseq=1, - element="N", - ), - ], - ) - let r2 = @src.Residue::new( - resname="GLY", - chainid='A', - resseq=2, - atoms=[ - @src.Atom::new( - name="N", - coord=@src.Vector3::new(3.0, 0.0, 0.0), - resname="GLY", - chainid='A', - resseq=2, - element="N", - ), - ], - ) + let r1 = @src.Residue::new(resname="ALA", chainid='A', resseq=1, atoms=[ + @src.Atom::new( + name="N", + coord=@src.Vector3::new(0.0, 0.0, 0.0), + resname="ALA", + chainid='A', + resseq=1, + element="N", + ), + ]) + let r2 = @src.Residue::new(resname="GLY", chainid='A', resseq=2, atoms=[ + @src.Atom::new( + name="N", + coord=@src.Vector3::new(3.0, 0.0, 0.0), + resname="GLY", + chainid='A', + resseq=2, + element="N", + ), + ]) let chain = @src.Chain::new(id='A', residues=[r1, r2]) let model = @src.Model::new(id=1, chains=[chain]) let structure = @src.Structure::new(id="1CG", models=[model]) @@ -313,36 +303,26 @@ test "mmcifio_write_single_chain" { ///| test "mmcifio_write_multiple_chains" { - let r1 = @src.Residue::new( - resname="ALA", - chainid='A', - resseq=1, - atoms=[ - @src.Atom::new( - name="N", - coord=@src.Vector3::new(0.0, 0.0, 0.0), - resname="ALA", - chainid='A', - resseq=1, - element="N", - ), - ], - ) - let r2 = @src.Residue::new( - resname="GLY", - chainid='B', - resseq=1, - atoms=[ - @src.Atom::new( - name="N", - coord=@src.Vector3::new(10.0, 0.0, 0.0), - resname="GLY", - chainid='B', - resseq=1, - element="N", - ), - ], - ) + let r1 = @src.Residue::new(resname="ALA", chainid='A', resseq=1, atoms=[ + @src.Atom::new( + name="N", + coord=@src.Vector3::new(0.0, 0.0, 0.0), + resname="ALA", + chainid='A', + resseq=1, + element="N", + ), + ]) + let r2 = @src.Residue::new(resname="GLY", chainid='B', resseq=1, atoms=[ + @src.Atom::new( + name="N", + coord=@src.Vector3::new(10.0, 0.0, 0.0), + resname="GLY", + chainid='B', + resseq=1, + element="N", + ), + ]) let chain_a = @src.Chain::new(id='A', residues=[r1]) let chain_b = @src.Chain::new(id='B', residues=[r2]) let model = @src.Model::new(id=1, chains=[chain_a, chain_b]) @@ -563,26 +543,12 @@ test "mmcifio_atom_site_has_all_columns" { let site = @src.write_mmcif_atom_site(structure) // Verify all 20 column headers are present let columns = [ - "_atom_site.group_PDB", - "_atom_site.id", - "_atom_site.type_symbol", - "_atom_site.label_atom_id", - "_atom_site.label_alt_id", - "_atom_site.label_comp_id", - "_atom_site.label_asym_id", - "_atom_site.label_entity_id", - "_atom_site.label_seq_id", - "_atom_site.pdbx_PDB_ins_code", - "_atom_site.Cartn_x", - "_atom_site.Cartn_y", - "_atom_site.Cartn_z", - "_atom_site.occupancy", - "_atom_site.B_iso_or_equiv", - "_atom_site.pdbx_formal_charge", - "_atom_site.auth_seq_id", - "_atom_site.auth_comp_id", - "_atom_site.auth_asym_id", - "_atom_site.auth_atom_id", + "_atom_site.group_PDB", "_atom_site.id", "_atom_site.type_symbol", "_atom_site.label_atom_id", + "_atom_site.label_alt_id", "_atom_site.label_comp_id", "_atom_site.label_asym_id", + "_atom_site.label_entity_id", "_atom_site.label_seq_id", "_atom_site.pdbx_PDB_ins_code", + "_atom_site.Cartn_x", "_atom_site.Cartn_y", "_atom_site.Cartn_z", "_atom_site.occupancy", + "_atom_site.B_iso_or_equiv", "_atom_site.pdbx_formal_charge", "_atom_site.auth_seq_id", + "_atom_site.auth_comp_id", "_atom_site.auth_asym_id", "_atom_site.auth_atom_id", ] for col in columns { assert_eq(site.contains(col), true) diff --git a/test/moonbit/mmtf_test.mbt b/test/moonbit/mmtf_test.mbt index 6656fcf8..c7d302bc 100644 --- a/test/moonbit/mmtf_test.mbt +++ b/test/moonbit/mmtf_test.mbt @@ -72,15 +72,8 @@ test "mmtf_sec_struct_from_int_undefined" { test "mmtf_sec_struct_to_string_round_trip" { let codes = [0, 1, 2, 3, 4, 5, 6, 7, 99] let names = [ - "pi_helix", - "bend", - "alpha_helix", - "extended", - "310_helix", - "bridge", - "turn", - "coil", - "undefined", + "pi_helix", "bend", "alpha_helix", "extended", "310_helix", "bridge", "turn", + "coil", "undefined", ] for i in 0.. 0) } +///| test "mofa_convergence" { let views = @src.mofa_create_example(25, 2) - let params = @src.MofaParams::create( - n_factors = 2, - max_iterations = 50, - ) + let params = @src.MofaParams::create(n_factors=2, max_iterations=50) let result = @src.mofa_run(views, params) assert_true(result.n_iterations <= 50) } +///| test "mofa_variance_explained" { let views = @src.mofa_create_example(30, 4) - let params = @src.MofaParams::create( - n_factors = 4, - max_iterations = 30, - ) + let params = @src.MofaParams::create(n_factors=4, max_iterations=30) let result = @src.mofa_run(views, params) // Variance should be non-negative for v in result.factor_vars { @@ -77,17 +78,16 @@ test "mofa_variance_explained" { } } +///| test "mofa_active_factors" { let views = @src.mofa_create_example(20, 2) - let params = @src.MofaParams::create( - n_factors = 5, - max_iterations = 30, - ) + let params = @src.MofaParams::create(n_factors=5, max_iterations=30) let result = @src.mofa_run(views, params) assert_true(result.active_factors >= 0) assert_true(result.active_factors <= 5) } +///| test "mofa_single_view" { // Should work with a single view let data : Array[Array[Double]] = Array::new() @@ -105,20 +105,16 @@ test "mofa_single_view" { let view = @src.MofaView::new("single", data, [], []) let views : Array[@src.MofaView] = Array::new() views.push(view) - let params = @src.MofaParams::create( - n_factors = 2, - max_iterations = 15, - ) + let params = @src.MofaParams::create(n_factors=2, max_iterations=15) let result = @src.mofa_run(views, params) assert_true(result.factors.length() == 15) assert_true(result.loadings.length() == 1) } +///| test "mofa_empty_views" { let views : Array[@src.MofaView] = Array::new() - let params = @src.MofaParams::create( - n_factors = 2, - ) + let params = @src.MofaParams::create(n_factors=2) let result = @src.mofa_run(views, params) assert_true(result.factors.length() == 0) assert_true(result.converged == false) diff --git a/test/moonbit/monocle3_test.mbt b/test/moonbit/monocle3_test.mbt index a57de638..bc719667 100644 --- a/test/moonbit/monocle3_test.mbt +++ b/test/moonbit/monocle3_test.mbt @@ -1,78 +1,86 @@ +///| test "monocle3_new_cell_data_set" { let counts = [[1, 2], [3, 4]] let gene_names = ["Gene_A", "Gene_B"] let cell_names = ["Cell_1", "Cell_2"] - + let cds = @src.new_cell_data_set(counts, gene_names, cell_names) - + assert_eq(cds.counts.length(), 2) assert_eq(cds.gene_names.length(), 2) assert_eq(cds.cell_names.length(), 2) assert_eq(cds.counts[0][0], 1) } +///| test "monocle3_new_cell_data_set_empty" { let cds = @src.new_cell_data_set([], [], []) - + assert_eq(cds.counts.length(), 0) assert_eq(cds.normalized.length(), 0) } +///| test "monocle3_preprocess_cds" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() let cds = @src.new_cell_data_set(counts, gene_names, cell_names) - + let preprocessed = @src.preprocess_cds(cds, 10) - + assert_eq(preprocessed.counts.length(), 50) assert_eq(preprocessed.normalized.length(), 50) assert_eq(preprocessed.reduced_dimensions.length(), 1) } +///| test "monocle3_reduce_dimension_pca" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() let cds = @src.new_cell_data_set(counts, gene_names, cell_names) - + let reduced = @src.reduce_dimension(cds, "PCA", 5) - + assert_eq(reduced.reduced_dimensions.length(), 1) assert_eq(reduced.reduced_dimensions[0].0, "PCA") } +///| test "monocle3_reduce_dimension_umap" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() let cds = @src.new_cell_data_set(counts, gene_names, cell_names) let preprocessed = @src.preprocess_cds(cds, 10) - + let reduced = @src.reduce_dimension(preprocessed, "UMAP", 2) - + assert_true(reduced.reduced_dimensions.length() >= 2) } +///| test "monocle3_learn_graph" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() let cds = @src.new_cell_data_set(counts, gene_names, cell_names) let preprocessed = @src.preprocess_cds(cds, 10) let reduced = @src.reduce_dimension(preprocessed, "UMAP", 2) - + let with_graph = @src.learn_graph(reduced) - + assert_eq(with_graph.cell_partitions.length(), 50) assert_eq(with_graph.principal_graph.length(), 1) } +///| test "monocle3_order_cells" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() let cds = @src.new_cell_data_set(counts, gene_names, cell_names) let preprocessed = @src.preprocess_cds(cds, 10) let reduced = @src.reduce_dimension(preprocessed, "UMAP", 2) let with_graph = @src.learn_graph(reduced) - + let ordered = @src.order_cells(with_graph, [0]) - + assert_eq(ordered.pseudotime.length(), 50) } +///| test "monocle3_fit_models" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() let cds = @src.new_cell_data_set(counts, gene_names, cell_names) @@ -80,58 +88,66 @@ test "monocle3_fit_models" { let reduced = @src.reduce_dimension(preprocessed, "UMAP", 2) let with_graph = @src.learn_graph(reduced) let ordered = @src.order_cells(with_graph, [0]) - + let result = @src.fit_models(ordered, ["Gene_0", "Gene_1", "Gene_2"]) - + assert_eq(result.gene.length(), 3) assert_eq(result.q_value.length(), 3) } +///| test "monocle3_create_example_data" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() - + assert_eq(counts.length(), 50) assert_eq(gene_names.length(), 100) assert_eq(cell_names.length(), 50) } +///| test "monocle3_full_pipeline" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() - + let cds = @src.new_cell_data_set(counts, gene_names, cell_names) let preprocessed = @src.preprocess_cds(cds, 10) let reduced = @src.reduce_dimension(preprocessed, "UMAP", 2) let with_graph = @src.learn_graph(reduced) let ordered = @src.order_cells(with_graph, [0]) let result = @src.fit_models(ordered, ["Gene_0"]) - + assert_eq(cds.counts.length(), 50) assert_eq(result.gene.length(), 1) } +///| test "monocle3_find_branch_points" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() let cds = @src.new_cell_data_set(counts, gene_names, cell_names) let preprocessed = @src.preprocess_cds(cds, 10) let reduced = @src.reduce_dimension(preprocessed, "UMAP", 2) let with_graph = @src.learn_graph(reduced) - + let branch_points = @src.find_branch_points(with_graph) - + assert_eq(branch_points.length(), 0) } +///| test "monocle3_differential_gene_test_branches" { let (counts, gene_names, cell_names) = @src.create_example_monocle_data() let cds = @src.new_cell_data_set(counts, gene_names, cell_names) let preprocessed = @src.preprocess_cds(cds, 10) let reduced = @src.reduce_dimension(preprocessed, "UMAP", 2) let with_graph = @src.learn_graph(reduced) - + let branch_points = @src.find_branch_points(with_graph) - + if branch_points.length() > 0 { - let result = @src.differential_gene_test_branches(with_graph, branch_points[0], ["Gene_0", "Gene_1"]) + let result = @src.differential_gene_test_branches( + with_graph, + branch_points[0], + ["Gene_0", "Gene_1"], + ) assert_eq(result.gene.length(), 2) } -} \ No newline at end of file +} diff --git a/test/moonbit/moon.pkg b/test/moonbit/moon.pkg index 956590ee..8c06828c 100644 --- a/test/moonbit/moon.pkg +++ b/test/moonbit/moon.pkg @@ -1,6 +1,6 @@ import { "IvanAXu/BioSeqs/src" @bio, - "IvanAXu/BioSeqs/src" @src, + "IvanAXu/BioSeqs/src", "moonbitlang/core/hashmap", "moonbitlang/core/double", "moonbitlang/core/math", diff --git a/test/moonbit/motif_scan_test.mbt b/test/moonbit/motif_scan_test.mbt index c72e3dce..bc20a39e 100644 --- a/test/moonbit/motif_scan_test.mbt +++ b/test/moonbit/motif_scan_test.mbt @@ -49,31 +49,24 @@ test "pwm_construction_default_background_and_strand" { ///| test "pwm_from_counts_basic" { // 4 rows (A,C,G,T) x 3 columns - let counts = [ - [9, 1, 1], - [1, 8, 1], - [1, 1, 7], - [1, 2, 3], - ] + let counts = [[9, 1, 1], [1, 8, 1], [1, 1, 7], [1, 2, 3]] let pwm = @src.motif_scan_pwm_from_counts("MC1", "CountMotif", counts, 1.0) assert_eq(pwm.motif_id, "MC1") assert_eq(pwm.motif_name, "CountMotif") assert_eq(pwm.matrix.length(), 4) assert_eq(pwm.matrix[0].length(), 3) // Each column should sum to ~1.0 (with pseudocount). - let col0 = pwm.matrix[0][0] + pwm.matrix[1][0] + pwm.matrix[2][0] + pwm.matrix[3][0] + let col0 = pwm.matrix[0][0] + + pwm.matrix[1][0] + + pwm.matrix[2][0] + + pwm.matrix[3][0] assert_true((col0 - 1.0).abs() < 0.001) } ///| test "pwm_from_counts_normalization" { // Counts: column 0 has total 10 + 4*pseudocount; each entry = (count+pseudo)/norm - let counts = [ - [10, 0], - [0, 10], - [0, 0], - [0, 0], - ] + let counts = [[10, 0], [0, 10], [0, 0], [0, 0]] let pwm = @src.motif_scan_pwm_from_counts("MC2", "Norm", counts, 1.0) // Column 0: total=10, norm=10+4=14. A = (10+1)/14 = 11/14 let expected_a = 11.0 / 14.0 @@ -96,7 +89,7 @@ test "pssm_construction_log_likelihood" { // A: log2(0.9/0.25) = log2(3.6) ~ 1.848 assert_true((pssm.scores[0][0] - 1.848).abs() < 0.01) // C: log2(0.05/0.25) = log2(0.2) ~ -2.322 - assert_true((pssm.scores[1][0] - (-2.322)).abs() < 0.01) + assert_true((pssm.scores[1][0] - -2.322).abs() < 0.01) } ///| @@ -104,7 +97,7 @@ test "pssm_construction_min_max_score" { let pwm = make_one_pos_pwm() let pssm = @src.build_pssm(pwm) // min_score = min of all bases at position 0 = -2.322 - assert_true((pssm.min_score - (-2.322)).abs() < 0.01) + assert_true((pssm.min_score - -2.322).abs() < 0.01) // max_score = max of all bases at position 0 = 1.848 assert_true((pssm.max_score - 1.848).abs() < 0.01) } @@ -114,10 +107,12 @@ test "pssm_carries_metadata" { let pwm = @src.PositionWeightMatrix::new( motif_id="M99", motif_name="Meta", - matrix=[[0.9, 0.05, 0.05, 0.05, 0.9, 0.9], - [0.05, 0.05, 0.05, 0.9, 0.05, 0.05], - [0.05, 0.05, 0.9, 0.05, 0.05, 0.05], - [0.05, 0.9, 0.05, 0.05, 0.05, 0.05]], + matrix=[ + [0.9, 0.05, 0.05, 0.05, 0.9, 0.9], + [0.05, 0.05, 0.05, 0.9, 0.05, 0.05], + [0.05, 0.05, 0.9, 0.05, 0.05, 0.05], + [0.05, 0.9, 0.05, 0.05, 0.05, 0.05], + ], background=[0.25, 0.25, 0.25, 0.25], strand="+-", ) @@ -135,7 +130,7 @@ test "compute_score_single_position" { // Score of "A" = log2(0.9/0.25) ~ 1.848 assert_true((@src.compute_score(pssm, "A") - 1.848).abs() < 0.01) // Score of "C" = log2(0.05/0.25) ~ -2.322 - assert_true((@src.compute_score(pssm, "C") - (-2.322)).abs() < 0.01) + assert_true((@src.compute_score(pssm, "C") - -2.322).abs() < 0.01) } ///| @@ -289,10 +284,12 @@ test "scan_sequence_forward_only_mode" { let pwm = @src.PositionWeightMatrix::new( motif_id="Mfwd", motif_name="FwdOnly", - matrix=[[0.9, 0.05, 0.05, 0.05, 0.9, 0.9], - [0.05, 0.05, 0.05, 0.9, 0.05, 0.05], - [0.05, 0.05, 0.9, 0.05, 0.05, 0.05], - [0.05, 0.9, 0.05, 0.05, 0.05, 0.05]], + matrix=[ + [0.9, 0.05, 0.05, 0.05, 0.9, 0.9], + [0.05, 0.05, 0.05, 0.9, 0.05, 0.05], + [0.05, 0.05, 0.9, 0.05, 0.05, 0.05], + [0.05, 0.9, 0.05, 0.05, 0.05, 0.05], + ], background=[0.25, 0.25, 0.25, 0.25], strand="+", ) @@ -523,11 +520,7 @@ test "pwm_from_counts_empty" { ///| test "compute_score_empty_pssm" { - let pwm = @src.PositionWeightMatrix::new( - motif_id="E", - motif_name="E", - matrix=[], - ) + let pwm = @src.PositionWeightMatrix::new(motif_id="E", motif_name="E", matrix=[]) let pssm = @src.build_pssm(pwm) assert_true((@src.compute_score(pssm, "ACGT") - 0.0).abs() < 0.001) assert_true((@src.compute_pvalue(pssm, 0.0) - 1.0).abs() < 0.001) diff --git a/test/moonbit/motifs_advanced_test.mbt b/test/moonbit/motifs_advanced_test.mbt index ad15dd73..502664e5 100644 --- a/test/moonbit/motifs_advanced_test.mbt +++ b/test/moonbit/motifs_advanced_test.mbt @@ -7,10 +7,7 @@ ///| test "jaspar_motif_creation" { - let pwm : Array[Array[Double]] = [ - [0.1, 0.2, 0.3, 0.4], - [0.4, 0.3, 0.2, 0.1], - ] + let pwm : Array[Array[Double]] = [[0.1, 0.2, 0.3, 0.4], [0.4, 0.3, 0.2, 0.1]] let motif = @src.JasparMotif::new( "MA0001.1", "AGL3", @@ -31,8 +28,7 @@ test "jaspar_motif_creation" { ///| test "jaspar_parse_simple_pfm" { - let pfm_content = - ">MA0001.1 AGL3\n" + + let pfm_content = ">MA0001.1 AGL3\n" + "A [ 0 3 79 40 66 48 65 11 65 0 ]\n" + "C [ 94 75 4 3 1 2 5 2 7 0 ]\n" + "G [ 1 0 3 4 1 0 5 3 4 0 ]\n" + @@ -46,8 +42,7 @@ test "jaspar_parse_simple_pfm" { ///| test "jaspar_parse_multiple_motifs" { - let pfm_content = - ">MA0001.1 AGL3\n" + + let pfm_content = ">MA0001.1 AGL3\n" + "A [ 10 20 30 40 ]\n" + "C [ 40 30 20 10 ]\n" + "G [ 20 20 20 20 ]\n" + @@ -82,10 +77,7 @@ test "jaspar_pfm_to_pwm" { ///| test "jaspar_pwm_to_jaspar_format" { - let pwm : Array[Array[Double]] = [ - [0.1, 0.2, 0.3, 0.4], - [0.4, 0.3, 0.2, 0.1], - ] + let pwm : Array[Array[Double]] = [[0.1, 0.2, 0.3, 0.4], [0.4, 0.3, 0.2, 0.1]] let jaspar_str = @src.pwm_to_jaspar(pwm, "MA0001.1", "TestMotif") assert_true(jaspar_str.has_prefix(">MA0001.1 TestMotif")) assert_true(jaspar_str.contains("A [")) @@ -98,10 +90,7 @@ test "jaspar_pwm_to_jaspar_format" { ///| test "transfac_motif_creation" { - let pwm : Array[Array[Double]] = [ - [1.0, 2.0, 3.0, 4.0], - [4.0, 3.0, 2.0, 1.0], - ] + let pwm : Array[Array[Double]] = [[1.0, 2.0, 3.0, 4.0], [4.0, 3.0, 2.0, 1.0]] let motif = @src.TransfacMotif::new( "T00001", "M00001", @@ -119,8 +108,7 @@ test "transfac_motif_creation" { ///| test "transfac_parse_simple" { - let transfac_content = - "AC T00001\n" + + let transfac_content = "AC T00001\n" + "ID M00001\n" + "NA AP-1\n" + "DE Activator protein 1\n" + @@ -138,10 +126,7 @@ test "transfac_parse_simple" { ///| test "transfac_pwm_to_transfac_format" { - let pwm : Array[Array[Double]] = [ - [1.0, 2.0, 3.0, 4.0], - [4.0, 3.0, 2.0, 1.0], - ] + let pwm : Array[Array[Double]] = [[1.0, 2.0, 3.0, 4.0], [4.0, 3.0, 2.0, 1.0]] let transfac_str = @src.pwm_to_transfac(pwm, "TestMotif", "T00001") assert_true(transfac_str.contains("AC T00001")) assert_true(transfac_str.contains("NA TestMotif")) @@ -184,10 +169,7 @@ test "optimal_motif_alignment_different_lengths" { [0.0, 0.1, 0.1, 0.8], [0.8, 0.1, 0.1, 0.0], ] - let pwm2 : Array[Array[Double]] = [ - [0.0, 0.1, 0.1, 0.8], - [0.8, 0.1, 0.1, 0.0], - ] + let pwm2 : Array[Array[Double]] = [[0.0, 0.1, 0.1, 0.8], [0.8, 0.1, 0.1, 0.0]] let alignment = @src.optimal_motif_alignment(pwm1, pwm2) assert_true(alignment.score >= 0.0) assert_true(alignment.aligned_length > 0) @@ -210,26 +192,16 @@ test "motif_kl_divergence" { ///| test "motif_js_divergence" { - let pwm1 : Array[Array[Double]] = [ - [0.8, 0.1, 0.1, 0.0], - [0.0, 0.1, 0.1, 0.8], - ] - let pwm2 : Array[Array[Double]] = [ - [0.8, 0.1, 0.1, 0.0], - [0.0, 0.1, 0.1, 0.8], - ] + let pwm1 : Array[Array[Double]] = [[0.8, 0.1, 0.1, 0.0], [0.0, 0.1, 0.1, 0.8]] + let pwm2 : Array[Array[Double]] = [[0.8, 0.1, 0.1, 0.0], [0.0, 0.1, 0.1, 0.8]] let js = @src.motif_js_divergence(pwm1, pwm2) assert_eq(js, 0.0) } ///| test "motif_js_divergence_different" { - let pwm1 : Array[Array[Double]] = [ - [0.8, 0.1, 0.1, 0.0], - ] - let pwm2 : Array[Array[Double]] = [ - [0.0, 0.1, 0.1, 0.8], - ] + let pwm1 : Array[Array[Double]] = [[0.8, 0.1, 0.1, 0.0]] + let pwm2 : Array[Array[Double]] = [[0.0, 0.1, 0.1, 0.8]] let js = @src.motif_js_divergence(pwm1, pwm2) assert_true(js >= 0.0) } @@ -250,10 +222,7 @@ test "motif_cluster_creation" { ///| test "cluster_motifs_single" { let names = ["motif1"] - let pwm1 : Array[Array[Double]] = [ - [0.8, 0.1, 0.1, 0.0], - [0.0, 0.1, 0.1, 0.8], - ] + let pwm1 : Array[Array[Double]] = [[0.8, 0.1, 0.1, 0.0], [0.0, 0.1, 0.1, 0.8]] let pwms = [pwm1] let clusters = @src.cluster_motifs(names, pwms, 0.5) assert_eq(clusters.length(), 1) @@ -275,10 +244,7 @@ test "optimal_pseudocount" { ///| test "motif_gc_content" { - let pwm : Array[Array[Double]] = [ - [0.1, 0.4, 0.4, 0.1], - [0.1, 0.4, 0.4, 0.1], - ] + let pwm : Array[Array[Double]] = [[0.1, 0.4, 0.4, 0.1], [0.1, 0.4, 0.4, 0.1]] let gc = @src.motif_gc_content_adv(pwm) assert_true(gc > 0.7 && gc < 0.9) } diff --git a/test/moonbit/ms_core_utils_test.mbt b/test/moonbit/ms_core_utils_test.mbt index e19dbf28..f48f8d3d 100644 --- a/test/moonbit/ms_core_utils_test.mbt +++ b/test/moonbit/ms_core_utils_test.mbt @@ -11,12 +11,14 @@ test "mc_mean_basic" { assert_true((m - 3.0).abs() < 0.001) } +///| test "mc_mean_empty" { let empty : Array[Double] = [] let m = @src.mc_mean(empty) assert_eq(m, 0.0) } +///| test "mc_mean_two_values" { let m = @src.mc_mean([2.5, 3.5]) assert_true((m - 3.0).abs() < 0.001) @@ -26,21 +28,25 @@ test "mc_mean_two_values" { // Numeric helpers: mc_median // ============================================================================ +///| test "mc_median_odd" { let m = @src.mc_median([1.0, 3.0, 5.0]) assert_eq(m, 3.0) } +///| test "mc_median_even" { let m = @src.mc_median([1.0, 2.0, 3.0, 4.0]) assert_true((m - 2.5).abs() < 0.001) } +///| test "mc_median_unsorted" { let m = @src.mc_median([5.0, 1.0, 3.0, 2.0, 4.0]) assert_eq(m, 3.0) } +///| test "mc_median_empty" { let empty : Array[Double] = [] let m = @src.mc_median(empty) @@ -51,17 +57,20 @@ test "mc_median_empty" { // Numeric helpers: mc_sd // ============================================================================ +///| test "mc_sd_basic" { // mean=3, var = (4+1+0+1+4)/4 = 2.5, sd = sqrt(2.5) ~ 1.5811 let s = @src.mc_sd([1.0, 2.0, 3.0, 4.0, 5.0]) assert_true((s - 1.5811).abs() < 0.001) } +///| test "mc_sd_constant" { let s = @src.mc_sd([5.0, 5.0, 5.0]) assert_eq(s, 0.0) } +///| test "mc_sd_single" { // n < 2 returns 0.0 let s = @src.mc_sd([7.0]) @@ -72,11 +81,13 @@ test "mc_sd_single" { // Numeric helpers: mc_quantile // ============================================================================ +///| test "mc_quantile_median" { let q = @src.mc_quantile([1.0, 2.0, 3.0, 4.0, 5.0], 0.5) assert_eq(q, 3.0) } +///| test "mc_quantile_min_max" { let qmin = @src.mc_quantile([1.0, 2.0, 3.0, 4.0, 5.0], 0.0) let qmax = @src.mc_quantile([1.0, 2.0, 3.0, 4.0, 5.0], 1.0) @@ -84,6 +95,7 @@ test "mc_quantile_min_max" { assert_eq(qmax, 5.0) } +///| test "mc_quantile_quarter" { // pos = 0.25 * 4 = 1, lo=1, frac=0 -> sorted[1] = 2.0 let q = @src.mc_quantile([1.0, 2.0, 3.0, 4.0, 5.0], 0.25) @@ -94,17 +106,20 @@ test "mc_quantile_quarter" { // Numeric helpers: mc_sum, mc_dot // ============================================================================ +///| test "mc_sum_basic" { let s = @src.mc_sum([1.0, 2.0, 3.0]) assert_eq(s, 6.0) } +///| test "mc_sum_empty" { let empty : Array[Double] = [] let s = @src.mc_sum(empty) assert_eq(s, 0.0) } +///| test "mc_dot_basic" { let d = @src.mc_dot([1.0, 2.0, 3.0], [4.0, 5.0, 6.0]) // 1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32 @@ -115,6 +130,7 @@ test "mc_dot_basic" { // refineCentroids: mc_refine_centroids // ============================================================================ +///| test "mc_refine_centroids_symmetric_peak" { // Symmetric peak centered at index 2 with m/z 100.2 let mz = [100.0, 100.1, 100.2, 100.3, 100.4] @@ -128,6 +144,7 @@ test "mc_refine_centroids_symmetric_peak" { assert_eq(out_int[0], 100.0) } +///| test "mc_refine_centroids_asymmetric_peak" { // Asymmetric: more weight on the right side -> refined m/z shifts right let mz = [100.0, 100.1, 100.2, 100.3, 100.4] @@ -137,6 +154,7 @@ test "mc_refine_centroids_asymmetric_peak" { assert_true(out_mz[0] > 100.2) } +///| test "mc_refine_centroids_out_of_range_index" { let mz = [100.0, 100.1, 100.2] let intensity = [10.0, 20.0, 30.0] @@ -150,16 +168,19 @@ test "mc_refine_centroids_out_of_range_index" { // localMaxima: mc_local_maxima // ============================================================================ +///| test "mc_local_maxima_basic" { let idx = @src.mc_local_maxima([1.0, 3.0, 2.0]) assert_eq(idx, [1]) } +///| test "mc_local_maxima_zeros" { let idx = @src.mc_local_maxima([0.0, 0.0, 0.0]) assert_eq(idx.length(), 0) } +///| test "mc_local_maxima_multiple_peaks" { let idx = @src.mc_local_maxima([1.0, 2.0, 1.0, 2.0, 1.0]) assert_eq(idx, [1, 3]) @@ -169,6 +190,7 @@ test "mc_local_maxima_multiple_peaks" { // joinPeaks: mc_join_peaks // ============================================================================ +///| test "mc_join_peaks_absolute_tolerance" { let x = [100.0, 200.0, 300.0] let y = [100.01, 199.99, 300.5] @@ -181,6 +203,7 @@ test "mc_join_peaks_absolute_tolerance" { assert_eq(pairs[1], (1, 1)) } +///| test "mc_join_peaks_ppm_tolerance" { let x = [1000.0] let y = [1000.005] @@ -190,6 +213,7 @@ test "mc_join_peaks_ppm_tolerance" { assert_eq(pairs[0], (0, 0)) } +///| test "mc_join_peaks_no_match" { let x = [100.0, 200.0] let y = [150.0, 250.0] @@ -201,6 +225,7 @@ test "mc_join_peaks_no_match" { // Smoothing: mc_smooth_moving_average // ============================================================================ +///| test "mc_smooth_moving_average_basic" { let out = @src.mc_smooth_moving_average([1.0, 2.0, 3.0, 4.0, 5.0], 1) assert_eq(out.length(), 5) @@ -211,6 +236,7 @@ test "mc_smooth_moving_average_basic" { assert_true((out[4] - 4.5).abs() < 0.001) } +///| test "mc_smooth_moving_average_reduces_noise" { // Noisy signal: moving average should reduce total variation let noisy = [1.0, 5.0, 1.0, 5.0, 1.0, 5.0, 1.0] @@ -230,6 +256,7 @@ test "mc_smooth_moving_average_reduces_noise" { // Smoothing: mc_smooth_savitzky_golay // ============================================================================ +///| test "mc_smooth_savitzky_golay_linear_signal" { // A quadratic/SG fit on perfectly linear data reproduces the value at the // window center. For the interior point with a full symmetric window, the @@ -240,6 +267,7 @@ test "mc_smooth_savitzky_golay_linear_signal" { assert_true((out[2] - lin[2]).abs() < 0.01) } +///| test "mc_smooth_savitzky_golay_reduces_noise" { let noisy = [1.0, 5.0, 1.0, 5.0, 1.0, 5.0, 1.0] let smoothed = @src.mc_smooth_savitzky_golay(noisy, 2) @@ -258,11 +286,13 @@ test "mc_smooth_savitzky_golay_reduces_noise" { // Smoothing: mc_smooth dispatcher // ============================================================================ +///| test "mc_smooth_dispatcher_moving_average" { let out = @src.mc_smooth([1.0, 2.0, 3.0, 4.0, 5.0], 1, "MovingAverage") assert_true((out[2] - 3.0).abs() < 0.001) } +///| test "mc_smooth_dispatcher_savitzky_golay" { let out = @src.mc_smooth([1.0, 2.0, 3.0, 4.0, 5.0], 2, "SavitzkyGolay") // Linear signal -> preserved @@ -273,6 +303,7 @@ test "mc_smooth_dispatcher_savitzky_golay" { // Baseline: mc_baseline_snip // ============================================================================ +///| test "mc_baseline_snip_flat_signal" { // Flat positive signal -> baseline should be <= signal and >= 0 let signal = [10.0, 10.0, 10.0, 10.0, 10.0] @@ -284,6 +315,7 @@ test "mc_baseline_snip_flat_signal" { } } +///| test "mc_baseline_snip_below_peaks" { // Signal with a peak in the middle -> baseline at peak should be below peak let signal = [1.0, 1.0, 100.0, 1.0, 1.0] @@ -295,6 +327,7 @@ test "mc_baseline_snip_below_peaks" { // Calibration: mc_calibrate // ============================================================================ +///| test "mc_calibrate_shift" { let observed = [100.0, 200.0, 300.0] let calibrants = [100.1, 200.1, 300.1] @@ -305,6 +338,7 @@ test "mc_calibrate_shift" { assert_true((out[2] - 300.1).abs() < 0.001) } +///| test "mc_calibrate_linear" { // matched pairs: (100, 100.5), (200, 200.5), (300, 300.5) // linear fit -> cal = 1.0 * obs + 0.5 @@ -317,6 +351,7 @@ test "mc_calibrate_linear" { assert_true((out[2] - 300.5).abs() < 0.01) } +///| test "mc_calibrate_no_match_returns_input" { // No calibrants within tolerance -> shift method leaves values unchanged let observed = [100.0, 200.0] @@ -330,23 +365,23 @@ test "mc_calibrate_no_match_returns_input" { // Imputation: mc_is_missing and mc_impute // ============================================================================ +///| test "mc_is_missing_nan" { let nan = 0.0 / 0.0 assert_true(@src.mc_is_missing(nan)) } +///| test "mc_is_missing_not_nan" { assert_true(!@src.mc_is_missing(5.0)) assert_true(!@src.mc_is_missing(0.0)) assert_true(!@src.mc_is_missing(-1.5)) } +///| test "mc_impute_zero" { let nan = 0.0 / 0.0 - let matrix = [ - [1.0, nan, 3.0], - [nan, 5.0, 6.0], - ] + let matrix = [[1.0, nan, 3.0], [nan, 5.0, 6.0]] let out = @src.mc_impute(matrix, "zero", 0) assert_eq(out[0][1], 0.0) assert_eq(out[1][0], 0.0) @@ -355,6 +390,7 @@ test "mc_impute_zero" { assert_eq(out[1][2], 6.0) } +///| test "mc_impute_half_min" { let nan = 0.0 / 0.0 // Row 0: non-missing values [2.0, 4.0], min = 2.0, half = 1.0 @@ -363,6 +399,7 @@ test "mc_impute_half_min" { assert_true((out[0][1] - 1.0).abs() < 0.001) } +///| test "mc_impute_mean" { let nan = 0.0 / 0.0 // Row 0: non-missing [1.0, 4.0], mean = 2.5 @@ -371,6 +408,7 @@ test "mc_impute_mean" { assert_true((out[0][1] - 2.5).abs() < 0.001) } +///| test "mc_impute_median" { let nan = 0.0 / 0.0 // Row 0: non-missing [1.0, 4.0], median = 2.5 @@ -379,27 +417,21 @@ test "mc_impute_median" { assert_true((out[0][1] - 2.5).abs() < 0.001) } +///| test "mc_impute_knn" { let nan = 0.0 / 0.0 // Row 1 missing at col 1; nearest row (by cols 0 and 2) is row 0. // k=1 -> impute from row 0 col 1 = 2.0 - let matrix = [ - [1.0, 2.0, 3.0], - [1.0, nan, 3.0], - [5.0, 4.0, 3.0], - ] + let matrix = [[1.0, 2.0, 3.0], [1.0, nan, 3.0], [5.0, 4.0, 3.0]] let out = @src.mc_impute(matrix, "knn", 1) assert_true((out[1][1] - 2.0).abs() < 0.001) } +///| test "mc_impute_knn_k2" { let nan = 0.0 / 0.0 // k=2 -> mean of row 0 col 1 (2.0) and row 2 col 1 (4.0) = 3.0 - let matrix = [ - [1.0, 2.0, 3.0], - [1.0, nan, 3.0], - [5.0, 4.0, 3.0], - ] + let matrix = [[1.0, 2.0, 3.0], [1.0, nan, 3.0], [5.0, 4.0, 3.0]] let out = @src.mc_impute(matrix, "knn", 2) assert_true((out[1][1] - 3.0).abs() < 0.001) } @@ -408,18 +440,16 @@ test "mc_impute_knn_k2" { // medianPolish: mc_median_polish // ============================================================================ +///| test "mc_median_polish_basic" { // Additive matrix: x[i][j] = overall + row_eff[i] + col_eff[j] // Expected: overall=4, row_eff=[-2, 2], col_eff=[-1, 1], residuals all 0 - let matrix = [ - [1.0, 3.0], - [5.0, 7.0], - ] + let matrix = [[1.0, 3.0], [5.0, 7.0]] let (r, row_eff, col_eff, overall) = @src.mc_median_polish(matrix, 10, 0.0001) assert_true((overall - 4.0).abs() < 0.001) - assert_true((row_eff[0] - (-2.0)).abs() < 0.001) + assert_true((row_eff[0] - -2.0).abs() < 0.001) assert_true((row_eff[1] - 2.0).abs() < 0.001) - assert_true((col_eff[0] - (-1.0)).abs() < 0.001) + assert_true((col_eff[0] - -1.0).abs() < 0.001) assert_true((col_eff[1] - 1.0).abs() < 0.001) // Residuals should be ~0 for i in 0..<2 { @@ -429,6 +459,7 @@ test "mc_median_polish_basic" { } } +///| test "mc_median_polish_empty" { let empty : Array[Array[Double]] = [] let (r, row_eff, col_eff, overall) = @src.mc_median_polish(empty, 10, 0.0001) @@ -442,21 +473,19 @@ test "mc_median_polish_empty" { // robustSummary: mc_robust_summary // ============================================================================ +///| test "mc_robust_summary_basic" { // Per-column median: // col 0: median([1,3,5]) = 3.0 // col 1: median([10,20,30]) = 20.0 - let matrix = [ - [1.0, 10.0], - [3.0, 20.0], - [5.0, 30.0], - ] + let matrix = [[1.0, 10.0], [3.0, 20.0], [5.0, 30.0]] let out = @src.mc_robust_summary(matrix) assert_eq(out.length(), 2) assert_eq(out[0], 3.0) assert_eq(out[1], 20.0) } +///| test "mc_robust_summary_empty" { let empty : Array[Array[Double]] = [] let out = @src.mc_robust_summary(empty) @@ -467,6 +496,7 @@ test "mc_robust_summary_empty" { // MAD: mc_mad // ============================================================================ +///| test "mc_mad_basic" { // median = 3, deviations = [2,1,0,1,2], median of devs = 1.0 // mad = 1.0 * 1.4826 = 1.4826 @@ -474,6 +504,7 @@ test "mc_mad_basic" { assert_true((m - 1.4826).abs() < 0.001) } +///| test "mc_mad_constant" { let m = @src.mc_mad([7.0, 7.0, 7.0]) assert_eq(m, 0.0) @@ -483,12 +514,14 @@ test "mc_mad_constant" { // Validity: mc_valid_peak_list, mc_has_missing // ============================================================================ +///| test "mc_valid_peak_list_valid" { let mz = [100.0, 200.0, 300.0] let intensity = [1.0, 2.0, 3.0] assert_true(@src.mc_valid_peak_list(mz, intensity)) } +///| test "mc_valid_peak_list_not_increasing" { // m/z 200 == 200 is not strictly increasing let mz = [100.0, 200.0, 200.0] @@ -496,32 +529,30 @@ test "mc_valid_peak_list_not_increasing" { assert_true(!@src.mc_valid_peak_list(mz, intensity)) } +///| test "mc_valid_peak_list_length_mismatch" { let mz = [100.0, 200.0] let intensity = [1.0, 2.0, 3.0] assert_true(!@src.mc_valid_peak_list(mz, intensity)) } +///| test "mc_valid_peak_list_negative_intensity" { let mz = [100.0, 200.0] let intensity = [-1.0, 2.0] assert_true(!@src.mc_valid_peak_list(mz, intensity)) } +///| test "mc_has_missing_clean" { - let matrix = [ - [1.0, 2.0], - [3.0, 4.0], - ] + let matrix = [[1.0, 2.0], [3.0, 4.0]] assert_true(!@src.mc_has_missing(matrix)) } +///| test "mc_has_missing_with_nan" { let nan = 0.0 / 0.0 - let matrix = [ - [1.0, nan], - [3.0, 4.0], - ] + let matrix = [[1.0, nan], [3.0, 4.0]] assert_true(@src.mc_has_missing(matrix)) } @@ -529,12 +560,9 @@ test "mc_has_missing_with_nan" { // Aggregation: mc_aggregate_rows // ============================================================================ +///| test "mc_aggregate_rows_sum" { - let matrix = [ - [1.0, 10.0], - [2.0, 20.0], - [3.0, 30.0], - ] + let matrix = [[1.0, 10.0], [2.0, 20.0], [3.0, 30.0]] let groups = [0, 0, 1] let out = @src.mc_aggregate_rows(matrix, groups, "sum") assert_eq(out.length(), 2) @@ -544,12 +572,9 @@ test "mc_aggregate_rows_sum" { assert_true((out[1][1] - 30.0).abs() < 0.001) } +///| test "mc_aggregate_rows_mean" { - let matrix = [ - [1.0, 10.0], - [2.0, 20.0], - [3.0, 30.0], - ] + let matrix = [[1.0, 10.0], [2.0, 20.0], [3.0, 30.0]] let groups = [0, 0, 1] let out = @src.mc_aggregate_rows(matrix, groups, "mean") assert_eq(out.length(), 2) @@ -559,12 +584,9 @@ test "mc_aggregate_rows_mean" { assert_true((out[1][1] - 30.0).abs() < 0.001) } +///| test "mc_aggregate_rows_median" { - let matrix = [ - [1.0, 10.0], - [2.0, 20.0], - [3.0, 30.0], - ] + let matrix = [[1.0, 10.0], [2.0, 20.0], [3.0, 30.0]] let groups = [0, 0, 1] let out = @src.mc_aggregate_rows(matrix, groups, "median") assert_eq(out.length(), 2) @@ -578,6 +600,7 @@ test "mc_aggregate_rows_median" { // Normalization: mc_normalize_tic // ============================================================================ +///| test "mc_normalize_tic_basic" { // total = 10, out = v / total * 100 let out = @src.mc_normalize_tic([1.0, 2.0, 3.0, 4.0]) @@ -588,6 +611,7 @@ test "mc_normalize_tic_basic" { assert_true((out[3] - 40.0).abs() < 0.001) } +///| test "mc_normalize_tic_zero_total" { // total = 0 -> all zeros let out = @src.mc_normalize_tic([0.0, 0.0, 0.0]) @@ -597,6 +621,7 @@ test "mc_normalize_tic_zero_total" { assert_eq(out[2], 0.0) } +///| test "mc_normalize_tic_sums_to_100" { let out = @src.mc_normalize_tic([10.0, 20.0, 30.0, 40.0]) let total = @src.mc_sum(out) diff --git a/test/moonbit/msf_test.mbt b/test/moonbit/msf_test.mbt index 13987e9c..39f56e9f 100644 --- a/test/moonbit/msf_test.mbt +++ b/test/moonbit/msf_test.mbt @@ -33,12 +33,7 @@ fn msf_test_write_raises( ) -> Bool { try { ignore( - @src.msf_write( - alignment, - block_width=block_width, - group_width=group_width, - gap_character=gap_character, - ), + @src.msf_write(alignment, block_width~, group_width~, gap_character~), ) false } catch { @@ -53,14 +48,7 @@ fn msf_test_from_aligned_raises( weights : Array[Double], ) -> Bool { try { - ignore( - @src.msf_from_aligned( - ids, - rows, - @src.MsfNucleotide, - weights=weights, - ), - ) + ignore(@src.msf_from_aligned(ids, rows, @src.MsfNucleotide, weights~)) false } catch { MsfError(_) => true @@ -81,7 +69,7 @@ fn msf_test_sequence_raises( id, row, sequence_type, - weight=weight, + weight~, checksum=Some(checksum), ), ) @@ -570,11 +558,7 @@ test "Bio.Align.msf writes hyphen gaps" { ///| test "Bio.Align.msf writes custom interleaved blocks" { - let output = @src.msf_write( - msf_test_sample(), - block_width=6, - group_width=3, - ) catch { + let output = @src.msf_write(msf_test_sample(), block_width=6, group_width=3) catch { MsfError(message) => abort(message) } assert_true(output.contains("reference ACG TAC")) @@ -670,11 +654,7 @@ test "Bio.Align.msf constructs canonical metadata" { ///| test "Bio.Align.msf accepts protein wildcard residues" { - let sequence = @src.MsfSequence::create( - "protein", - "ACDX*?", - @src.MsfProtein, - ) catch { + let sequence = @src.MsfSequence::create("protein", "ACDX*?", @src.MsfProtein) catch { MsfError(message) => abort(message) } assert_eq(sequence.sequence, "ACDX*?") @@ -727,9 +707,7 @@ test "Bio.Align.msf rejects missing alignment header" { ///| test "Bio.Align.msf rejects malformed alignment header" { assert_true( - msf_test_raises( - "!!NA_MULTIPLE_ALIGNMENT\nMSF: 4 Kind: N Check: 0 ..\n", - ), + msf_test_raises("!!NA_MULTIPLE_ALIGNMENT\nMSF: 4 Kind: N Check: 0 ..\n"), ) } @@ -765,20 +743,12 @@ test "Bio.Align.msf rejects zero declared width" { ///| test "Bio.Align.msf rejects integer overflow" { - assert_true( - msf_test_raises( - "PileUp\nMSF: 2147483648 Type: N Check: 0 ..\n", - ), - ) + assert_true(msf_test_raises("PileUp\nMSF: 2147483648 Type: N Check: 0 ..\n")) } ///| test "Bio.Align.msf rejects file checksum outside range" { - assert_true( - msf_test_raises( - "PileUp\nMSF: 4 Type: N Check: 10000 ..\n", - ), - ) + assert_true(msf_test_raises("PileUp\nMSF: 4 Type: N Check: 10000 ..\n")) } ///| @@ -970,107 +940,65 @@ test "Bio.Align.msf rejects unexpected descriptor token" { ///| test "Bio.Align.msf rejects empty row constructor input" { - assert_true( - msf_test_from_aligned_raises([], [], []), - ) + assert_true(msf_test_from_aligned_raises([], [], [])) } ///| test "Bio.Align.msf rejects mismatched row constructor input" { - assert_true( - msf_test_from_aligned_raises(["alpha"], ["ACGT", "ACGT"], []), - ) + assert_true(msf_test_from_aligned_raises(["alpha"], ["ACGT", "ACGT"], [])) } ///| test "Bio.Align.msf rejects mismatched weights" { assert_true( - msf_test_from_aligned_raises( - ["alpha", "beta"], - ["ACGT", "ACGT"], - [1.0], - ), + msf_test_from_aligned_raises(["alpha", "beta"], ["ACGT", "ACGT"], [1.0]), ) } ///| test "Bio.Align.msf rejects unequal row widths" { assert_true( - msf_test_from_aligned_raises( - ["alpha", "beta"], - ["ACGT", "ACG"], - [], - ), + msf_test_from_aligned_raises(["alpha", "beta"], ["ACGT", "ACG"], []), ) } ///| test "Bio.Align.msf rejects duplicate constructor identifiers" { assert_true( - msf_test_from_aligned_raises( - ["alpha", "alpha"], - ["ACGT", "ACGT"], - [], - ), + msf_test_from_aligned_raises(["alpha", "alpha"], ["ACGT", "ACGT"], []), ) } ///| test "Bio.Align.msf rejects whitespace in sequence identifier" { assert_true( - msf_test_sequence_raises( - "bad id", - "ACGT", - @src.MsfNucleotide, - 1.0, - 748, - ), + msf_test_sequence_raises("bad id", "ACGT", @src.MsfNucleotide, 1.0, 748), ) } ///| test "Bio.Align.msf rejects empty aligned sequence" { - assert_true( - msf_test_sequence_raises("", "", @src.MsfNucleotide, 1.0, 0), - ) + assert_true(msf_test_sequence_raises("", "", @src.MsfNucleotide, 1.0, 0)) } ///| test "Bio.Align.msf rejects all-gap sequence" { assert_true( - msf_test_sequence_raises( - "alpha", - "...", - @src.MsfNucleotide, - 1.0, - 0, - ), + msf_test_sequence_raises("alpha", "...", @src.MsfNucleotide, 1.0, 0), ) } ///| test "Bio.Align.msf rejects sequence checksum outside range" { assert_true( - msf_test_sequence_raises( - "alpha", - "ACGT", - @src.MsfNucleotide, - 1.0, - 10000, - ), + msf_test_sequence_raises("alpha", "ACGT", @src.MsfNucleotide, 1.0, 10000), ) } ///| test "Bio.Align.msf rejects negative sequence weight" { assert_true( - msf_test_sequence_raises( - "alpha", - "ACGT", - @src.MsfNucleotide, - -1.0, - 748, - ), + msf_test_sequence_raises("alpha", "ACGT", @src.MsfNucleotide, -1.0, 748), ) } diff --git a/test/moonbit/msnbase_test.mbt b/test/moonbit/msnbase_test.mbt index 8d85be66..082403f2 100644 --- a/test/moonbit/msnbase_test.mbt +++ b/test/moonbit/msnbase_test.mbt @@ -18,6 +18,7 @@ test "mbn_mslevel_constructors" { } } +///| test "mbn_polarity_constructors" { let p = @src.polarity_positive() let n = @src.polarity_negative() @@ -25,6 +26,7 @@ test "mbn_polarity_constructors" { assert_eq(n, @src.polarity_negative()) } +///| test "mbn_processing_step_new" { let s = @src.ProcessingStep::new("log_transformed", "2025-01-01") assert_eq(s.description, "log_transformed") @@ -35,47 +37,77 @@ test "mbn_processing_step_new" { // Spectrum tests // ============================================================================ +///| test "mbn_spectrum_new_basic" { let mz = [100.0, 200.0, 300.0, 400.0, 500.0] let int = [10.0, 100.0, 500.0, 200.0, 50.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 60.5) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 60.5, + ) assert_eq(sp.peaks_count(), 5) assert_true((sp.rt() - 60.5).abs() < 0.0001) // TIC = 10+100+500+200+50 = 860 assert_true((sp.tic() - 860.0).abs() < 0.0001) } +///| test "mbn_spectrum_empty" { let sp = @src.Spectrum::empty() assert_eq(sp.peaks_count(), 0) assert_eq(sp.tic(), 0.0) } +///| test "mbn_spectrum_mismatched_lengths" { // Mismatched mz/intensity returns empty - let sp = @src.Spectrum::new([1.0, 2.0], [10.0], @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + [1.0, 2.0], + [10.0], + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) assert_eq(sp.peaks_count(), 0) } +///| test "mbn_spectrum_with_precursor" { let mz = [100.0, 200.0] let int = [50.0, 100.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms2(), @src.polarity_positive(), 120.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms2(), + @src.polarity_positive(), + 120.0, + ) let sp2 = sp.with_precursor(500.25, 2) assert_eq(sp2.precursor_mz, 500.25) assert_eq(sp2.precursor_charge, 2) } +///| test "mbn_spectrum_base_peak" { let mz = [100.0, 200.0, 300.0, 400.0] let int = [10.0, 500.0, 50.0, 200.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) let (bpmz, bpint) = sp.base_peak() // Peak at index 1 is highest: mz=200, int=500 assert_true((bpmz - 200.0).abs() < 0.0001) assert_true((bpint - 500.0).abs() < 0.0001) } +///| test "mbn_spectrum_base_peak_empty" { let sp = @src.Spectrum::empty() let (mz, int) = sp.base_peak() @@ -83,54 +115,90 @@ test "mbn_spectrum_base_peak_empty" { assert_eq(int, 0.0) } +///| test "mbn_spectrum_find_peak_exact" { let mz = [100.0, 200.0, 300.0, 400.0, 500.0] let int = [10.0, 100.0, 500.0, 200.0, 50.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) let idx = sp.find_peak(300.0, ppm=10.0) assert_eq(idx, 2) } +///| test "mbn_spectrum_find_peak_notfound" { let mz = [100.0, 200.0] let int = [10.0, 100.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) let idx = sp.find_peak(999.0, ppm=10.0) assert_eq(idx, -1) } +///| test "mbn_spectrum_filter_mz_range" { let mz = [100.0, 200.0, 300.0, 400.0, 500.0] let int = [10.0, 100.0, 500.0, 200.0, 50.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) let filtered = sp.filter_mz_range(150.0, 450.0) assert_eq(filtered.peaks_count(), 3) assert_eq(filtered.mz()[0], 200.0) assert_eq(filtered.mz()[2], 400.0) } +///| test "mbn_spectrum_normalize_tic" { - let int = [10.0, 100.0, 500.0, 200.0, 50.0] // TIC = 860 + let int = [10.0, 100.0, 500.0, 200.0, 50.0] // TIC = 860 let mz = [100.0, 200.0, 300.0, 400.0, 500.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) let norm = sp.normalize_tic() // New TIC should be 1.0 assert_true((norm.tic() - 1.0).abs() < 0.0001) // First peak normalized: 10/860 - assert_true((norm.intensity()[0] - 10.0/860.0).abs() < 0.0001) + assert_true((norm.intensity()[0] - 10.0 / 860.0).abs() < 0.0001) } // ============================================================================ // Chromatogram tests // ============================================================================ +///| test "mbn_chromatogram_new" { let rt = [0.0, 30.0, 60.0, 90.0, 120.0] let int = [100.0, 5000.0, 20000.0, 8000.0, 200.0] - let chr = @src.Chromatogram::new(rt, int, mz_target=500.0, ppm_tolerance=10.0, acquisition_mode="MRM") + let chr = @src.Chromatogram::new( + rt, + int, + mz_target=500.0, + ppm_tolerance=10.0, + acquisition_mode="MRM", + ) assert_eq(chr.n_points(), 5) } +///| test "mbn_chromatogram_total_auc" { // Simple triangular: rt=[0, 1, 2], int=[0, 10, 0] // Area = 1.0 * 10 = 10 (two triangles each area 5) @@ -140,6 +208,7 @@ test "mbn_chromatogram_total_auc" { assert_true((chr.total_auc() - 10.0).abs() < 0.001) } +///| test "mbn_chromatogram_apex" { let rt = [0.0, 30.0, 60.0, 90.0] let int = [100.0, 5000.0, 20000.0, 8000.0] @@ -149,6 +218,7 @@ test "mbn_chromatogram_apex" { assert_true((apex_int - 20000.0).abs() < 0.001) } +///| test "mbn_chromatogram_fwhm" { // Gaussian-like: peak at center let rt = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0] @@ -163,9 +233,15 @@ test "mbn_chromatogram_fwhm" { // MSnFeatureData and MSnSampleData // ============================================================================ +///| test "mbn_featuredata_new" { let fd = @src.MSnFeatureData::new( - "Pep_1_2", ["P12345"], "PEPTIDER", 2, 500.25, 60.5, + "Pep_1_2", + ["P12345"], + "PEPTIDER", + 2, + 500.25, + 60.5, ) assert_eq(fd.feature_name, "Pep_1_2") assert_eq(fd.protein_accessions.length(), 1) @@ -175,10 +251,9 @@ test "mbn_featuredata_new" { assert_true((fd.mz - 500.25).abs() < 0.0001) } +///| test "mbn_sampledata_new" { - let sd = @src.MSnSampleData::new( - "S1_WT_1", "WT", "Mouse_1", 1, "Run_001", - ) + let sd = @src.MSnSampleData::new("S1_WT_1", "WT", "Mouse_1", 1, "Run_001") assert_eq(sd.sample_name, "S1_WT_1") assert_eq(sd.group, "WT") assert_eq(sd.subject, "Mouse_1") @@ -190,6 +265,7 @@ test "mbn_sampledata_new" { // MSnSet tests // ============================================================================ +///| test "mbn_msnset_new_basic" { let exprs = [ [1000.0, 1200.0, 1100.0], @@ -213,11 +289,9 @@ test "mbn_msnset_new_basic" { assert_eq(m.sample_names().length(), 3) } +///| test "mbn_msnset_from_names" { - let exprs = [ - [1.0, 2.0], - [3.0, 4.0], - ] + let exprs = [[1.0, 2.0], [3.0, 4.0]] let m = @src.MSnSet::from_names(exprs, ["F1", "F2"], ["S1", "S2"]) assert_eq(m.n_features(), 2) assert_eq(m.n_samples(), 2) @@ -225,11 +299,9 @@ test "mbn_msnset_from_names" { assert_eq(m.sample_names()[1], "S2") } +///| test "mbn_msnset_get_feature" { - let exprs = [ - [10.0, 20.0], - [30.0, 40.0], - ] + let exprs = [[10.0, 20.0], [30.0, 40.0]] let m = @src.MSnSet::from_names(exprs, ["F1", "F2"], ["S1", "S2"]) let f1 = m.get_feature("F1") assert_eq(f1.length(), 2) @@ -239,12 +311,9 @@ test "mbn_msnset_get_feature" { assert_eq(missing.length(), 0) } +///| test "mbn_msnset_get_sample" { - let exprs = [ - [10.0, 20.0], - [30.0, 40.0], - [50.0, 60.0], - ] + let exprs = [[10.0, 20.0], [30.0, 40.0], [50.0, 60.0]] let m = @src.MSnSet::from_names(exprs, ["F1", "F2", "F3"], ["S1", "S2"]) let s1 = m.get_sample("S1") assert_eq(s1.length(), 3) @@ -258,11 +327,9 @@ test "mbn_msnset_get_sample" { // MSnSet transformations // ============================================================================ +///| test "mbn_msnset_log2_transform" { - let exprs = [ - [1.0, 3.0], - [7.0, 15.0], - ] + let exprs = [[1.0, 3.0], [7.0, 15.0]] let m = @src.MSnSet::from_names(exprs, ["F1", "F2"], ["S1", "S2"]) let m2 = m.log2_transform(offset=1.0) // log2(1+1) = 1, log2(3+1) = 2, log2(7+1) = 3, log2(15+1) = 4 @@ -273,10 +340,11 @@ test "mbn_msnset_log2_transform" { assert_true((e[1][1] - 4.0).abs() < 0.0001) } +///| test "mbn_msnset_impute_mean" { let exprs = [ - [10.0, -1.0, 30.0], // -1 = missing, mean of 10,30 = 20 - [5.0, 15.0, 0.0], // 0 = missing, mean of 5,15 = 10 + [10.0, -1.0, 30.0], // -1 = missing, mean of 10,30 = 20 + [5.0, 15.0, 0.0], // 0 = missing, mean of 5,15 = 10 ] let m = @src.MSnSet::from_names(exprs, ["F1", "F2"], ["S1", "S2", "S3"]) let m2 = m.impute_missing(method="mean") @@ -285,9 +353,10 @@ test "mbn_msnset_impute_mean" { assert_true((e[1][2] - 10.0).abs() < 0.0001) } +///| test "mbn_msnset_impute_median" { let exprs = [ - [1.0, -1.0, 5.0], // sorted 1,5 median = 3 + [1.0, -1.0, 5.0], // sorted 1,5 median = 3 [100.0, 200.0, 0.0], // sorted 100,200 median = 150 ] let m = @src.MSnSet::from_names(exprs, ["F1", "F2"], ["S1", "S2", "S3"]) @@ -297,12 +366,9 @@ test "mbn_msnset_impute_median" { assert_true((e[1][2] - 150.0).abs() < 0.0001) } +///| test "mbn_msnset_normalize_sum" { - let exprs = [ - [1.0, 10.0], - [2.0, 20.0], - [3.0, 30.0], - ] + let exprs = [[1.0, 10.0], [2.0, 20.0], [3.0, 30.0]] // S1 sum = 6, S2 sum = 60. target = 12 // S1 scale = 2, so 2, 4, 6 // S2 scale = 0.2, so 2, 4, 6 @@ -315,28 +381,26 @@ test "mbn_msnset_normalize_sum" { assert_true((e[1][1] - 4.0).abs() < 0.0001) } +///| test "mbn_msnset_normalize_median_center" { - let exprs = [ - [1.0, 10.0], - [3.0, 20.0], - [5.0, 30.0], - ] + let exprs = [[1.0, 10.0], [3.0, 20.0], [5.0, 30.0]] // S1 median = 3, S2 median = 20 // After: [-2, -10, 2] and [0, 0, 10] let m = @src.MSnSet::from_names(exprs, ["F1", "F2", "F3"], ["S1", "S2"]) let m2 = m.normalize_median_center() let e = m2.exprs() - assert_true((e[0][0] - (-2.0)).abs() < 0.0001) + assert_true((e[0][0] - -2.0).abs() < 0.0001) assert_true((e[2][0] - 2.0).abs() < 0.0001) assert_true((e[1][1] - 0.0).abs() < 0.0001) assert_true((e[2][1] - 10.0).abs() < 0.0001) } +///| test "mbn_msnset_summarize_proteins_sum" { // Two peptides from P1, one from P2 let exprs = [ - [100.0, 200.0], // Peptide1 -> P1 - [300.0, 400.0], // Peptide2 -> P1 + [100.0, 200.0], // Peptide1 -> P1 + [300.0, 400.0], // Peptide2 -> P1 [1000.0, 2000.0], // Peptide3 -> P2 ] let fd = [ @@ -358,8 +422,12 @@ test "mbn_msnset_summarize_proteins_sum" { let mut p1_idx = -1 let mut p2_idx = -1 for i in 0..= 0) assert_true(p2_idx >= 0) @@ -372,19 +440,27 @@ test "mbn_msnset_summarize_proteins_sum" { // Spectrum processing // ============================================================================ +///| test "mbn_spectrum_smooth_ma" { let mz = [100.0, 200.0, 300.0, 400.0, 500.0, 600.0, 700.0] let int = [1.0, 100.0, 1.0, 100.0, 1.0, 100.0, 1.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) let smoothed = sp.smooth_moving_average(half_window=1) // Position 1 (100): avg of [1, 100, 1] = 34 // (due to hw=1 => 3-point average) let si = smoothed.intensity() // Check that smoothing reduces the extremes (values become more moderate) - assert_true(si[1] < 100.0) // was spike - assert_true(si[2] > 1.0) // was valley + assert_true(si[1] < 100.0) // was spike + assert_true(si[2] > 1.0) // was valley } +///| test "mbn_spectrum_baseline_correct" { let n = 20 let mz : Array[Double] = [] @@ -396,7 +472,13 @@ test "mbn_spectrum_baseline_correct" { let peak = if i == 10 { 900.0 } else { 0.0 } int.push(base + peak) } - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) let corrected = sp.baseline_correct_minwin(half_window=2) // Peak center should still be present (around 900), others should be near 0 let ci = corrected.intensity() @@ -411,12 +493,19 @@ test "mbn_spectrum_baseline_correct" { } } +///| test "mbn_spectrum_centroid_simple" { // Three peaks: at 99, 100, 101 (peak in center, symmetric) // plus a trough let mz = [90.0, 99.0, 100.0, 101.0, 110.0, 199.0, 200.0, 201.0, 300.0] let int = [1.0, 50.0, 100.0, 50.0, 1.0, 60.0, 200.0, 60.0, 1.0] - let sp = @src.Spectrum::new(mz, int, @src.ms_level_ms1(), @src.polarity_positive(), 0.0) + let sp = @src.Spectrum::new( + mz, + int, + @src.ms_level_ms1(), + @src.polarity_positive(), + 0.0, + ) let centroided = sp.centroid_simple(snr_threshold=0.0) // Should find two peaks near 100 and 200 assert_true(centroided.peaks_count() >= 2) @@ -426,6 +515,7 @@ test "mbn_spectrum_centroid_simple" { // Sample QC // ============================================================================ +///| test "mbn_msnset_sample_qc" { let exprs = [ [100.0, 0.0], @@ -434,7 +524,9 @@ test "mbn_msnset_sample_qc" { [0.0, 3000.0], [500.0, 0.0], ] - let m = @src.MSnSet::from_names(exprs, ["F1", "F2", "F3", "F4", "F5"], ["S1", "S2"]) + let m = @src.MSnSet::from_names(exprs, ["F1", "F2", "F3", "F4", "F5"], [ + "S1", "S2", + ]) let qc = m.sample_qc() assert_eq(qc.length(), 2) // S1: detected 4 (one zero), total = 1100 diff --git a/test/moonbit/msstats_test.mbt b/test/moonbit/msstats_test.mbt index 89a3f5e7..e8ba26e7 100644 --- a/test/moonbit/msstats_test.mbt +++ b/test/moonbit/msstats_test.mbt @@ -1,6 +1,5 @@ ///| /// Test file for MSstats module. - test "msstats_feature_creation" { let f = @src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1000.0) assert_eq(f.protein, "P1") @@ -12,12 +11,20 @@ test "msstats_feature_creation" { assert_eq(f.intensity, 1000.0) } +///| test "msstats_data_process_log_transform" { let features : Array[@src.MSFeature] = Array::new() - features.push(@src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1024.0)) - features.push(@src.MSFeature::new("P1", "pep1", "tr1", "Trt", "S2", "R2", 2048.0)) - - let processed = @src.ms_data_process(features, normalization=@src.ms_norm_none()) + features.push( + @src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1024.0), + ) + features.push( + @src.MSFeature::new("P1", "pep1", "tr1", "Trt", "S2", "R2", 2048.0), + ) + + let processed = @src.ms_data_process( + features, + normalization=@src.ms_norm_none(), + ) assert_eq(processed.length(), 2) // log2(1024) = 10 assert_true((processed[0].intensity - 10.0).abs() < 0.01) @@ -25,38 +32,64 @@ test "msstats_data_process_log_transform" { assert_true((processed[1].intensity - 11.0).abs() < 0.01) } +///| test "msstats_data_process_median_norm" { let features : Array[@src.MSFeature] = Array::new() - features.push(@src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1024.0)) - features.push(@src.MSFeature::new("P1", "pep2", "tr2", "Ctrl", "S1", "R1", 4096.0)) - features.push(@src.MSFeature::new("P2", "pep3", "tr3", "Trt", "S2", "R2", 2048.0)) - features.push(@src.MSFeature::new("P2", "pep4", "tr4", "Trt", "S2", "R2", 8192.0)) - - let processed = @src.ms_data_process(features, normalization=@src.ms_norm_median()) + features.push( + @src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1024.0), + ) + features.push( + @src.MSFeature::new("P1", "pep2", "tr2", "Ctrl", "S1", "R1", 4096.0), + ) + features.push( + @src.MSFeature::new("P2", "pep3", "tr3", "Trt", "S2", "R2", 2048.0), + ) + features.push( + @src.MSFeature::new("P2", "pep4", "tr4", "Trt", "S2", "R2", 8192.0), + ) + + let processed = @src.ms_data_process( + features, + normalization=@src.ms_norm_median(), + ) assert_eq(processed.length(), 4) // Values should be centered (median subtracted) // R1: log2(1024)=10, log2(4096)=12, median=11, so values become -1, 1 // R2: log2(2048)=11, log2(8192)=13, median=12, so values become -1, 1 - assert_true((processed[0].intensity - (-1.0)).abs() < 0.01) + assert_true((processed[0].intensity - -1.0).abs() < 0.01) assert_true((processed[1].intensity - 1.0).abs() < 0.01) } +///| test "msstats_data_process_zero_intensity" { let features : Array[@src.MSFeature] = Array::new() - features.push(@src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 0.0)) - - let processed = @src.ms_data_process(features, normalization=@src.ms_norm_none()) + features.push( + @src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 0.0), + ) + + let processed = @src.ms_data_process( + features, + normalization=@src.ms_norm_none(), + ) // Zero should be replaced with 1, then log2(1) = 0 assert_true(processed[0].intensity.abs() < 0.01) } +///| test "msstats_summarize_tukey" { let features : Array[@src.MSFeature] = Array::new() // Two peptides for protein P1 in run R1 - features.push(@src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1024.0)) - features.push(@src.MSFeature::new("P1", "pep2", "tr2", "Ctrl", "S1", "R1", 4096.0)) - - let processed = @src.ms_data_process(features, normalization=@src.ms_norm_none()) + features.push( + @src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1024.0), + ) + features.push( + @src.MSFeature::new("P1", "pep2", "tr2", "Ctrl", "S1", "R1", 4096.0), + ) + + let processed = @src.ms_data_process( + features, + normalization=@src.ms_norm_none(), + ) let summarized = @src.ms_summarize(processed, method=@src.ms_summary_tukey()) assert_eq(summarized.length(), 1) // One protein-run combo assert_eq(summarized[0].protein, "P1") @@ -65,43 +98,72 @@ test "msstats_summarize_tukey" { assert_true((summarized[0].log2_abundance - 11.0).abs() < 0.01) } +///| test "msstats_summarize_linear" { let features : Array[@src.MSFeature] = Array::new() - features.push(@src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1024.0)) - features.push(@src.MSFeature::new("P1", "pep2", "tr2", "Ctrl", "S1", "R1", 4096.0)) - - let processed = @src.ms_data_process(features, normalization=@src.ms_norm_none()) + features.push( + @src.MSFeature::new("P1", "pep1", "tr1", "Ctrl", "S1", "R1", 1024.0), + ) + features.push( + @src.MSFeature::new("P1", "pep2", "tr2", "Ctrl", "S1", "R1", 4096.0), + ) + + let processed = @src.ms_data_process( + features, + normalization=@src.ms_norm_none(), + ) let summarized = @src.ms_summarize(processed, method=@src.ms_summary_linear()) // Mean of log2(1024)=10 and log2(4096)=12 is 11 assert_true((summarized[0].log2_abundance - 11.0).abs() < 0.01) } +///| test "msstats_group_comparison_basic" { let features = @src.msstats_sample_data() - let processed = @src.ms_data_process(features, normalization=@src.ms_norm_median()) + let processed = @src.ms_data_process( + features, + normalization=@src.ms_norm_median(), + ) let summarized = @src.ms_summarize(processed) - let results = @src.ms_group_comparison(summarized, fdr_threshold=0.5, log2fc_threshold=0.5) + let results = @src.ms_group_comparison( + summarized, + fdr_threshold=0.5, + log2fc_threshold=0.5, + ) assert_true(results.get_n_results() > 0) } +///| test "msstats_group_comparison_significant" { let features = @src.msstats_sample_data() - let processed = @src.ms_data_process(features, normalization=@src.ms_norm_median()) + let processed = @src.ms_data_process( + features, + normalization=@src.ms_norm_median(), + ) let summarized = @src.ms_summarize(processed) - let results = @src.ms_group_comparison(summarized, fdr_threshold=0.5, log2fc_threshold=0.0) + let results = @src.ms_group_comparison( + summarized, + fdr_threshold=0.5, + log2fc_threshold=0.0, + ) let sig = results.get_significant() assert_true(sig.length() >= 0) } +///| test "msstats_group_comparison_top_proteins" { let features = @src.msstats_sample_data() - let processed = @src.ms_data_process(features, normalization=@src.ms_norm_median()) + let processed = @src.ms_data_process( + features, + normalization=@src.ms_norm_median(), + ) let summarized = @src.ms_summarize(processed) let results = @src.ms_group_comparison(summarized) let top = results.get_top_proteins(2) assert_eq(top.length(), 2) } +///| test "msstats_group_comparison_summary" { let features = @src.msstats_sample_data() let processed = @src.ms_data_process(features) @@ -111,6 +173,7 @@ test "msstats_group_comparison_summary" { assert_true(s.contains("MSstats")) } +///| test "msstats_sample_size" { let features = @src.msstats_sample_data() let processed = @src.ms_data_process(features) @@ -120,12 +183,14 @@ test "msstats_sample_size" { assert_true(ss.n_samples >= 3) } +///| test "msstats_sample_data" { let features = @src.msstats_sample_data() assert_eq(features.length(), 40) // 5 proteins * 4 groups * 2 peptides assert_eq(features[0].protein, "P1") } +///| test "msstats_type_to_string" { assert_eq(@src.ms_type_dda().to_string(), "DDA") assert_eq(@src.ms_type_dia().to_string(), "DIA") @@ -133,6 +198,7 @@ test "msstats_type_to_string" { assert_eq(@src.ms_type_tmt().to_string(), "TMT") } +///| test "msstats_norm_to_string" { assert_eq(@src.ms_norm_none().to_string(), "none") assert_eq(@src.ms_norm_median().to_string(), "median") @@ -140,6 +206,7 @@ test "msstats_norm_to_string" { assert_eq(@src.ms_norm_global().to_string(), "globalStandards") } +///| test "msstats_summary_to_string" { assert_eq(@src.ms_summary_tukey().to_string(), "Tukey") assert_eq(@src.ms_summary_linear().to_string(), "linear") diff --git a/test/moonbit/muscat_test.mbt b/test/moonbit/muscat_test.mbt index 2ebf4aec..ec4a524c 100644 --- a/test/moonbit/muscat_test.mbt +++ b/test/moonbit/muscat_test.mbt @@ -1,6 +1,5 @@ ///| /// Test file for muscat module. - test "muscat_single_cell_creation" { let cell = @src.SingleCell::new("cell1", "sample1", "cluster1", "ctrl") assert_eq(cell.cell_id, "cell1") @@ -9,6 +8,7 @@ test "muscat_single_cell_creation" { assert_eq(cell.group_id, "ctrl") } +///| test "muscat_single_cell_set_get_count" { let cell = @src.SingleCell::new("cell1", "sample1", "cluster1", "ctrl") cell.set_count("Gene1", 10.0) @@ -18,6 +18,7 @@ test "muscat_single_cell_set_get_count" { assert_eq(cell.get_count("Gene3"), 0.0) // Non-existent } +///| test "muscat_single_cell_total_counts" { let cell = @src.SingleCell::new("cell1", "sample1", "cluster1", "ctrl") cell.set_count("Gene1", 10.0) @@ -26,6 +27,7 @@ test "muscat_single_cell_total_counts" { assert_eq(cell.total_counts(), 35.0) } +///| test "muscat_single_cell_n_expressed" { let cell = @src.SingleCell::new("cell1", "sample1", "cluster1", "ctrl") cell.set_count("Gene1", 10.0) @@ -34,6 +36,7 @@ test "muscat_single_cell_n_expressed" { assert_eq(cell.n_expressed(), 2) } +///| test "muscat_aggregation_sum" { let cells : Array[@src.SingleCell] = Array::new() let c1 = @src.SingleCell::new("c1", "S1", "C1", "ctrl") @@ -52,6 +55,7 @@ test "muscat_aggregation_sum" { assert_eq(pb[0].n_cells, 2) } +///| test "muscat_aggregation_mean" { let cells : Array[@src.SingleCell] = Array::new() let c1 = @src.SingleCell::new("c1", "S1", "C1", "ctrl") @@ -66,6 +70,7 @@ test "muscat_aggregation_mean" { assert_eq(pb[0].get_count("Gene1"), 15.0) } +///| test "muscat_aggregation_multiple_samples" { let cells : Array[@src.SingleCell] = Array::new() // Sample S1, Cluster C1 @@ -85,6 +90,7 @@ test "muscat_aggregation_multiple_samples" { assert_eq(pb.length(), 3) // 3 (sample, cluster) combinations } +///| test "muscat_pseudobulk_total_counts" { let cells : Array[@src.SingleCell] = Array::new() let c1 = @src.SingleCell::new("c1", "S1", "C1", "ctrl") @@ -99,6 +105,7 @@ test "muscat_pseudobulk_total_counts" { assert_eq(pb[0].total_counts(), 35.0) } +///| test "muscat_pseudobulk_n_expressed" { let cells : Array[@src.SingleCell] = Array::new() let c1 = @src.SingleCell::new("c1", "S1", "C1", "ctrl") @@ -114,6 +121,7 @@ test "muscat_pseudobulk_n_expressed" { assert_eq(pb[0].n_expressed(), 2) // Gene1 and Gene3 > 0 } +///| test "muscat_ds_analysis_basic" { let cells = @src.muscat_sample_data() let pb = @src.aggregate_cells(cells) @@ -122,14 +130,20 @@ test "muscat_ds_analysis_basic" { assert_eq(results.n_clusters, 2) } +///| test "muscat_ds_analysis_significant" { let cells = @src.muscat_sample_data() let pb = @src.aggregate_cells(cells) - let results = @src.run_ds_analysis(pb, fdr_threshold=0.5, log2fc_threshold=0.5) + let results = @src.run_ds_analysis( + pb, + fdr_threshold=0.5, + log2fc_threshold=0.5, + ) let sig = results.get_significant() assert_true(sig.length() > 0) } +///| test "muscat_ds_analysis_cluster_filter" { let cells = @src.muscat_sample_data() let pb = @src.aggregate_cells(cells) @@ -138,6 +152,7 @@ test "muscat_ds_analysis_cluster_filter" { assert_true(c1_results.length() > 0) } +///| test "muscat_ds_analysis_top_genes" { let cells = @src.muscat_sample_data() let pb = @src.aggregate_cells(cells) @@ -146,6 +161,7 @@ test "muscat_ds_analysis_top_genes" { assert_eq(top.length(), 3) } +///| test "muscat_qc_computation" { let cells = @src.muscat_sample_data() let pb = @src.aggregate_cells(cells) @@ -153,6 +169,7 @@ test "muscat_qc_computation" { assert_eq(qc.length(), pb.length()) } +///| test "muscat_summary" { let cells = @src.muscat_sample_data() let pb = @src.aggregate_cells(cells) @@ -161,12 +178,14 @@ test "muscat_summary" { assert_true(s.contains("muscat")) } +///| test "muscat_aggregation_method_to_string" { assert_eq(@src.aggregation_sum().to_string(), "sum") assert_eq(@src.aggregation_mean().to_string(), "mean") assert_eq(@src.aggregation_median().to_string(), "median") } +///| test "muscat_ds_method_to_string" { assert_eq(@src.ds_method_edger().to_string(), "edgeR") assert_eq(@src.ds_method_deseq2().to_string(), "DESeq2") diff --git a/test/moonbit/naccess_test.mbt b/test/moonbit/naccess_test.mbt index 6302efb1..57a3a197 100644 --- a/test/moonbit/naccess_test.mbt +++ b/test/moonbit/naccess_test.mbt @@ -127,9 +127,13 @@ test "naccess_result_new_empty" { test "naccess_result_add_residue" { let r = @src.NaccessResult::new() assert_eq(r.get_num_residues(), 0) - r.add_residue(@src.NaccessResidue::new(res_name="ALA", res_num=1, chain_id="A")) + r.add_residue( + @src.NaccessResidue::new(res_name="ALA", res_num=1, chain_id="A"), + ) assert_eq(r.get_num_residues(), 1) - r.add_residue(@src.NaccessResidue::new(res_name="GLY", res_num=2, chain_id="A")) + r.add_residue( + @src.NaccessResidue::new(res_name="GLY", res_num=2, chain_id="A"), + ) assert_eq(r.get_num_residues(), 2) } @@ -164,8 +168,12 @@ test "naccess_result_add_atom" { ///| test "naccess_result_get_residues" { let r = @src.NaccessResult::new() - r.add_residue(@src.NaccessResidue::new(res_name="MET", res_num=1, chain_id="A")) - r.add_residue(@src.NaccessResidue::new(res_name="ALA", res_num=2, chain_id="A")) + r.add_residue( + @src.NaccessResidue::new(res_name="MET", res_num=1, chain_id="A"), + ) + r.add_residue( + @src.NaccessResidue::new(res_name="ALA", res_num=2, chain_id="A"), + ) let residues = r.get_residues() assert_eq(residues.length(), 2) assert_eq(residues[0].res_name, "MET") @@ -206,7 +214,9 @@ test "naccess_result_get_num_residues" { let r = @src.NaccessResult::new() assert_eq(r.get_num_residues(), 0) for i in 0..<5 { - r.add_residue(@src.NaccessResidue::new(res_name="ALA", res_num=i, chain_id="A")) + r.add_residue( + @src.NaccessResidue::new(res_name="ALA", res_num=i, chain_id="A"), + ) } assert_eq(r.get_num_residues(), 5) } @@ -409,26 +419,39 @@ test "naccess_parse_asa_header_only" { ///| test "naccess_parse_combined_counts" { - let result = @src.naccess_parse(@src.naccess_sample_rsa(), @src.naccess_sample_asa()) + let result = @src.naccess_parse( + @src.naccess_sample_rsa(), + @src.naccess_sample_asa(), + ) assert_eq(result.get_num_residues(), 4) assert_eq(result.get_num_atoms(), 6) } ///| test "naccess_parse_total_abs_asa" { - let result = @src.naccess_parse(@src.naccess_sample_rsa(), @src.naccess_sample_asa()) + let result = @src.naccess_parse( + @src.naccess_sample_rsa(), + @src.naccess_sample_asa(), + ) // 45.3 + 20.1 + 5.2 + 25.0 = 95.6 assert_true((result.total_abs_asa - 95.6).abs() < naccess_eps) } ///| test "naccess_parse_chain_totals" { - let result = @src.naccess_parse(@src.naccess_sample_rsa(), @src.naccess_sample_asa()) + let result = @src.naccess_parse( + @src.naccess_sample_rsa(), + @src.naccess_sample_asa(), + ) assert_eq(result.chain_totals.length(), 2) // Chain A: 45.3 + 20.1 + 5.2 = 70.6 - assert_true((result.chain_totals.get("A").unwrap() - 70.6).abs() < naccess_eps) + assert_true( + (result.chain_totals.get("A").unwrap() - 70.6).abs() < naccess_eps, + ) // Chain B: 25.0 - assert_true((result.chain_totals.get("B").unwrap() - 25.0).abs() < naccess_eps) + assert_true( + (result.chain_totals.get("B").unwrap() - 25.0).abs() < naccess_eps, + ) } ///| @@ -578,13 +601,17 @@ test "naccess_count_exposed" { test "naccess_chain_total_asa_a" { let result = @src.naccess_sample() // 45.3 + 20.1 + 5.2 = 70.6 - assert_true((@src.naccess_chain_total_asa(result, "A") - 70.6).abs() < naccess_eps) + assert_true( + (@src.naccess_chain_total_asa(result, "A") - 70.6).abs() < naccess_eps, + ) } ///| test "naccess_chain_total_asa_b" { let result = @src.naccess_sample() - assert_true((@src.naccess_chain_total_asa(result, "B") - 25.0).abs() < naccess_eps) + assert_true( + (@src.naccess_chain_total_asa(result, "B") - 25.0).abs() < naccess_eps, + ) } ///| diff --git a/test/moonbit/naive_bayes_test.mbt b/test/moonbit/naive_bayes_test.mbt index feb02250..dbb826ea 100644 --- a/test/moonbit/naive_bayes_test.mbt +++ b/test/moonbit/naive_bayes_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Bio.NaiveBayes sequence classifier module. - test "classifier_new_defaults" { let clf = @src.NaiveBayesClassifier::new() assert_eq(clf.kmer_size, 3) @@ -9,24 +8,28 @@ test "classifier_new_defaults" { assert_eq(clf.class_labels.length(), 0) } +///| test "classifier_set_kmer_size" { let clf = @src.NaiveBayesClassifier::new().set_kmer_size(5) assert_eq(clf.kmer_size, 5) assert_eq(clf.alpha, 1.0) } +///| test "classifier_set_alpha" { let clf = @src.NaiveBayesClassifier::new().set_alpha(0.5) assert_eq(clf.kmer_size, 3) assert_eq(clf.alpha, 0.5) } +///| test "classifier_setters_chain" { let clf = @src.NaiveBayesClassifier::new().set_kmer_size(4).set_alpha(0.1) assert_eq(clf.kmer_size, 4) assert_eq(clf.alpha, 0.1) } +///| test "extract_kmers_basic" { let kmers = @src.naive_bayes_extract_kmers("ABCDE", 2) assert_eq(kmers.length(), 4) @@ -36,28 +39,33 @@ test "extract_kmers_basic" { assert_eq(kmers.get("DE").unwrap(), 1) } +///| test "extract_kmers_repeated" { let kmers = @src.naive_bayes_extract_kmers("AAAA", 2) assert_eq(kmers.length(), 1) assert_eq(kmers.get("AA").unwrap(), 3) } +///| test "extract_kmers_k_larger_than_length" { let kmers = @src.naive_bayes_extract_kmers("ABC", 5) assert_eq(kmers.length(), 0) } +///| test "extract_kmers_k_equals_length" { let kmers = @src.naive_bayes_extract_kmers("ABC", 3) assert_eq(kmers.length(), 1) assert_eq(kmers.get("ABC").unwrap(), 1) } +///| test "extract_kmers_empty_sequence" { let kmers = @src.naive_bayes_extract_kmers("", 3) assert_eq(kmers.length(), 0) } +///| test "train_basic" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -67,6 +75,7 @@ test "train_basic" { assert_eq(trained.models.length(), 2) } +///| test "predict_at_rich_correct" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -75,6 +84,7 @@ test "predict_at_rich_correct" { assert_eq(pred.0, "AT_rich") } +///| test "predict_gc_rich_correct" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -83,6 +93,7 @@ test "predict_gc_rich_correct" { assert_eq(pred.0, "GC_rich") } +///| test "predict_proba_sums_to_one" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -95,14 +106,18 @@ test "predict_proba_sums_to_one" { assert_true(sum > 0.99 && sum < 1.01) } +///| test "predict_log_probs_returns_all_classes" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() let trained = @src.naive_bayes_train(clf, data.0, data.1) - let log_probs = @src.naive_bayes_predict_log_probs(trained, "ATATATATATATATATATAT") + let log_probs = @src.naive_bayes_predict_log_probs( + trained, "ATATATATATATATATATAT", + ) assert_eq(log_probs.length(), 2) } +///| test "top_k_returns_k_items" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -111,6 +126,7 @@ test "top_k_returns_k_items" { assert_eq(top.length(), 1) } +///| test "top_k_descending_order" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -120,6 +136,7 @@ test "top_k_descending_order" { assert_true(top[0].1 >= top[1].1) } +///| test "accuracy_on_sample_data" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -128,6 +145,7 @@ test "accuracy_on_sample_data" { assert_true(acc > 0.5) } +///| test "unknown_sequence_reasonable_defaults" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -142,18 +160,26 @@ test "unknown_sequence_reasonable_defaults" { assert_true(sum > 0.99 && sum < 1.01) } +///| test "kmer_size_affects_results" { let data = @src.naive_bayes_sample_data() let clf3 = @src.NaiveBayesClassifier::new() let trained3 = @src.naive_bayes_train(clf3, data.0, data.1) let clf2 = @src.NaiveBayesClassifier::new().set_kmer_size(2) let trained2 = @src.naive_bayes_train(clf2, data.0, data.1) - let log_probs3 = @src.naive_bayes_predict_log_probs(trained3, "ATATATATATATATATATAT") - let log_probs2 = @src.naive_bayes_predict_log_probs(trained2, "ATATATATATATATATATAT") + let log_probs3 = @src.naive_bayes_predict_log_probs( + trained3, "ATATATATATATATATATAT", + ) + let log_probs2 = @src.naive_bayes_predict_log_probs( + trained2, "ATATATATATATATATATAT", + ) let diff = (log_probs3[0].1 - log_probs2[0].1).abs() - assert_true(diff > 0.0 || trained3.vocabulary.length() != trained2.vocabulary.length()) + assert_true( + diff > 0.0 || trained3.vocabulary.length() != trained2.vocabulary.length(), + ) } +///| test "class_labels_array_after_training" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -164,12 +190,14 @@ test "class_labels_array_after_training" { assert_true(has_at && has_gc) } +///| test "sample_data_has_8_sequences" { let data = @src.naive_bayes_sample_data() assert_eq(data.0.length(), 8) assert_eq(data.1.length(), 8) } +///| test "sample_data_labels_count" { let data = @src.naive_bayes_sample_data() let mut at_count = 0 @@ -185,6 +213,7 @@ test "sample_data_labels_count" { assert_eq(gc_count, 4) } +///| test "train_empty_sequences" { let clf = @src.NaiveBayesClassifier::new() let seqs : Array[String] = [] @@ -194,6 +223,7 @@ test "train_empty_sequences" { assert_eq(trained.vocabulary.length(), 0) } +///| test "predict_empty_sequence" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() @@ -202,6 +232,7 @@ test "predict_empty_sequence" { assert_true(trained.class_labels.contains(pred.0)) } +///| test "accuracy_empty_data" { let data = @src.naive_bayes_sample_data() let clf = @src.NaiveBayesClassifier::new() diff --git a/test/moonbit/nanostring_test.mbt b/test/moonbit/nanostring_test.mbt index 22b95917..e8962185 100644 --- a/test/moonbit/nanostring_test.mbt +++ b/test/moonbit/nanostring_test.mbt @@ -25,9 +25,7 @@ test "ns_sample_creation" { ///| test "ns_sample_accessors" { let raw = [100, 200, 300, 50, 60, 10, 20] - let sample = @src.NsSample::new( - "S1", raw, [3, 4], [5, 6], [0, 1], [0, 1, 2], - ) + let sample = @src.NsSample::new("S1", raw, [3, 4], [5, 6], [0, 1], [0, 1, 2]) let pos = sample.positive_controls() assert_eq(pos.length(), 2) assert_eq(pos[0], 50) @@ -65,9 +63,7 @@ test "ns_nanostring_data_add_sample" { let gene_names = ["G1", "G2", "G3"] let data = @src.NsNanostringData::new(gene_names) let raw = [100, 200, 300, 50, 60, 10, 20] - let sample = @src.NsSample::new( - "S1", raw, [3, 4], [5, 6], [0, 1], [0, 1, 2], - ) + let sample = @src.NsSample::new("S1", raw, [3, 4], [5, 6], [0, 1], [0, 1, 2]) data.add_sample(sample) assert_eq(data.n_samples(), 1) assert_eq(data.n_genes(), 3) @@ -127,11 +123,11 @@ test "ns_log2_counts_known" { test "ns_log2_counts_zero_pseudocount" { // log2(0 + 0.5) = log2(0.5) = -1. let result = @src.ns_log2_counts([0.0]) - assert_true((result[0] - (-1.0)).abs() < 0.01) + assert_true((result[0] - -1.0).abs() < 0.01) // Multiple values. let result2 = @src.ns_log2_counts([0.0, 1.0, 7.0]) // log2(0.5) = -1, log2(1.5) ≈ 0.585, log2(7.5) ≈ 2.907 - assert_true((result2[0] - (-1.0)).abs() < 0.01) + assert_true((result2[0] - -1.0).abs() < 0.01) assert_true((result2[1] - 0.585).abs() < 0.01) assert_true((result2[2] - 2.907).abs() < 0.01) } @@ -448,9 +444,7 @@ test "ns_edge_single_sample" { let gene_names = ["G1", "G2", "G3"] let data = @src.NsNanostringData::new(gene_names) let raw = [100, 200, 300, 50, 60, 10, 20] - let sample = @src.NsSample::new( - "S1", raw, [3, 4], [5, 6], [0, 1], [0, 1, 2], - ) + let sample = @src.NsSample::new("S1", raw, [3, 4], [5, 6], [0, 1], [0, 1, 2]) data.add_sample(sample) assert_eq(data.n_samples(), 1) let results = @src.ns_positive_control_norm(data) @@ -463,9 +457,7 @@ test "ns_edge_single_gene" { let gene_names = ["G1"] let data = @src.NsNanostringData::new(gene_names) let raw = [100, 50, 10] - let sample = @src.NsSample::new( - "S1", raw, [1], [2], [0], [0], - ) + let sample = @src.NsSample::new("S1", raw, [1], [2], [0], [0]) data.add_sample(sample) assert_eq(data.n_genes(), 1) let results = @src.ns_positive_control_norm(data) @@ -477,9 +469,9 @@ test "ns_edge_all_zeros" { let gene_names = ["G1", "G2", "G3"] let data = @src.NsNanostringData::new(gene_names) let raw = [0, 0, 0, 0, 0, 0, 0, 0, 0] - let sample = @src.NsSample::new( - "S1", raw, [3, 4, 5], [6, 7, 8], [0, 1, 2], [0, 1, 2], - ) + let sample = @src.NsSample::new("S1", raw, [3, 4, 5], [6, 7, 8], [0, 1, 2], [ + 0, 1, 2, + ]) data.add_sample(sample) let results = @src.ns_positive_control_norm(data) assert_eq(results.length(), 1) diff --git a/test/moonbit/nib_io_test.mbt b/test/moonbit/nib_io_test.mbt index 391b0e6a..0302e6be 100644 --- a/test/moonbit/nib_io_test.mbt +++ b/test/moonbit/nib_io_test.mbt @@ -298,7 +298,10 @@ test "nib_size" { test "nib_compressed_size" { // 8 bases -> 2 bytes; 9 bases -> 3 bytes; 1 base -> 1 byte; 0 bases -> 0. assert_eq(@src.nib_compressed_size(@src.NibSequence::new("a", "ATGCATGC")), 2) - assert_eq(@src.nib_compressed_size(@src.NibSequence::new("b", "ATGCATGCA")), 3) + assert_eq( + @src.nib_compressed_size(@src.NibSequence::new("b", "ATGCATGCA")), + 3, + ) assert_eq(@src.nib_compressed_size(@src.NibSequence::new("c", "A")), 1) assert_eq(@src.nib_compressed_size(@src.NibSequence::new("d", "")), 0) } @@ -675,7 +678,8 @@ test "edge_case_three_bases" { ///| test "edge_case_hex_round_trip_various_lengths" { - for seq in ["A", "AT", "ATG", "ATGC", "ATGCA", "ATGCAT", "ATGCATG", "ATGCATGC"] { + for + seq in ["A", "AT", "ATG", "ATGC", "ATGCA", "ATGCAT", "ATGCATG", "ATGCATGC"] { let nib = @src.NibSequence::new("s", seq) let hex = @src.nib_to_hex(nib) let nib2 = @src.nib_from_hex("s2", hex, seq.length()) diff --git a/test/moonbit/nmr_test.mbt b/test/moonbit/nmr_test.mbt index 1b12694f..4889777b 100644 --- a/test/moonbit/nmr_test.mbt +++ b/test/moonbit/nmr_test.mbt @@ -326,8 +326,8 @@ test "dihedral_restraint_construction" { assert_eq(d.restraint_id, 1) assert_eq(d.angle_name, "PHI") assert_eq(d.residue, 15) - assert_true((d.lower_bound - (-120.0)).abs() < 0.001) - assert_true((d.upper_bound - (-60.0)).abs() < 0.001) + assert_true((d.lower_bound - -120.0).abs() < 0.001) + assert_true((d.upper_bound - -60.0).abs() < 0.001) } ///| @@ -385,8 +385,8 @@ test "parse_dihedral_restraints_basic" { assert_eq(restraints.length(), 2) assert_eq(restraints[0].angle_name, "PHI") assert_eq(restraints[0].residue, 15) - assert_true((restraints[0].lower_bound - (-120.0)).abs() < 0.001) - assert_true((restraints[0].observed.unwrap_or(0.0) - (-85.0)).abs() < 0.001) + assert_true((restraints[0].lower_bound - -120.0).abs() < 0.001) + assert_true((restraints[0].observed.unwrap_or(0.0) - -85.0).abs() < 0.001) } // ============================================================================ diff --git a/test/moonbit/noiseq_test.mbt b/test/moonbit/noiseq_test.mbt index e70301fa..aa1d896e 100644 --- a/test/moonbit/noiseq_test.mbt +++ b/test/moonbit/noiseq_test.mbt @@ -1,12 +1,12 @@ ///| /// Test file for NOISeq module. - test "noiseq_sample_creation" { let s = @src.NOISeqSample::new("sample1", "control") assert_eq(s.sample_id, "sample1") assert_eq(s.condition, "control") } +///| test "noiseq_sample_set_get_count" { let s = @src.NOISeqSample::new("sample1", "control") s.set_count("Gene1", 100.0) @@ -16,6 +16,7 @@ test "noiseq_sample_set_get_count" { assert_eq(s.get_count("Gene3"), 0.0) // Non-existent } +///| test "noiseq_sample_library_size" { let s = @src.NOISeqSample::new("sample1", "control") s.set_count("Gene1", 100.0) @@ -24,6 +25,7 @@ test "noiseq_sample_library_size" { assert_eq(s.library_size(), 350.0) } +///| test "noiseq_sample_n_expressed" { let s = @src.NOISeqSample::new("sample1", "control") s.set_count("Gene1", 100.0) @@ -32,6 +34,7 @@ test "noiseq_sample_n_expressed" { assert_eq(s.n_expressed(), 2) } +///| test "noiseq_normalize_tmm" { let samples : Array[@src.NOISeqSample] = Array::new() let s1 = @src.NOISeqSample::new("s1", "ctrl") @@ -50,6 +53,7 @@ test "noiseq_normalize_tmm" { assert_true((norm[1].get_count("Gene1") - 100.0).abs() < 0.01) } +///| test "noiseq_normalize_rpkm" { let samples : Array[@src.NOISeqSample] = Array::new() let s1 = @src.NOISeqSample::new("s1", "ctrl") @@ -61,6 +65,7 @@ test "noiseq_normalize_rpkm" { assert_true((norm[0].get_count("Gene1") - 1000000.0).abs() < 0.01) } +///| test "noiseq_normalize_none" { let samples : Array[@src.NOISeqSample] = Array::new() let s1 = @src.NOISeqSample::new("s1", "ctrl") @@ -71,6 +76,7 @@ test "noiseq_normalize_none" { assert_eq(norm[0].get_count("Gene1"), 100.0) } +///| test "noiseq_run_basic" { let (ctrl, trt) = @src.noiseq_sample_data() let results = @src.noiseq_run(ctrl, trt) @@ -78,6 +84,7 @@ test "noiseq_run_basic" { assert_eq(results.n_genes, 10) } +///| test "noiseq_run_significant" { let (ctrl, trt) = @src.noiseq_sample_data() let results = @src.noiseq_run(ctrl, trt, prob_threshold=0.3) @@ -85,6 +92,7 @@ test "noiseq_run_significant" { assert_true(sig.length() > 0) } +///| test "noiseq_run_top_genes" { let (ctrl, trt) = @src.noiseq_sample_data() let results = @src.noiseq_run(ctrl, trt) @@ -94,6 +102,7 @@ test "noiseq_run_top_genes" { assert_true(top[0].prob >= top[1].prob) } +///| test "noiseq_run_up_down_regulated" { let (ctrl, trt) = @src.noiseq_sample_data() let results = @src.noiseq_run(ctrl, trt, prob_threshold=0.3) @@ -103,6 +112,7 @@ test "noiseq_run_up_down_regulated" { assert_true(up.length() + down.length() > 0) } +///| test "noiseq_run_summary" { let (ctrl, trt) = @src.noiseq_sample_data() let results = @src.noiseq_run(ctrl, trt) @@ -111,6 +121,7 @@ test "noiseq_run_summary" { assert_true(s.contains("Genes tested")) } +///| test "noiseq_qc" { let (ctrl, trt) = @src.noiseq_sample_data() let all : Array[@src.NOISeqSample] = Array::new() @@ -128,6 +139,7 @@ test "noiseq_qc" { assert_true(qc.biotype_counts.size() > 0) } +///| test "noiseq_norm_to_string" { assert_eq(@src.noiseq_norm_rpkm().to_string(), "RPKM") assert_eq(@src.noiseq_norm_tmm().to_string(), "TMM") @@ -135,11 +147,13 @@ test "noiseq_norm_to_string" { assert_eq(@src.noiseq_norm_none().to_string(), "none") } +///| test "noiseq_method_to_string" { assert_eq(@src.noiseq_method_bio().to_string(), "NOISeqBio") assert_eq(@src.noiseq_method_sim().to_string(), "NOISeqSim") } +///| test "noiseq_sample_data" { let (ctrl, trt) = @src.noiseq_sample_data() assert_eq(ctrl.length(), 3) @@ -148,6 +162,7 @@ test "noiseq_sample_data" { assert_eq(trt[0].condition, "treatment") } +///| test "noiseq_result_ranking" { let (ctrl, trt) = @src.noiseq_sample_data() let results = @src.noiseq_run(ctrl, trt) diff --git a/test/moonbit/nucle_r_test.mbt b/test/moonbit/nucle_r_test.mbt index 310f46eb..32bb1f1e 100644 --- a/test/moonbit/nucle_r_test.mbt +++ b/test/moonbit/nucle_r_test.mbt @@ -22,7 +22,10 @@ test "nuc_create_example_result" { assert_true(result.nuc_n_count() >= 0) assert_true(result.nuc_mean_spacing() >= 0.0) assert_true(result.nuc_mean_occupancy() >= 0.0) - assert_true(result.nuc_frac_well_positioned() >= 0.0 && result.nuc_frac_well_positioned() <= 1.0) + assert_true( + result.nuc_frac_well_positioned() >= 0.0 && + result.nuc_frac_well_positioned() <= 1.0, + ) } ///| @@ -103,7 +106,7 @@ test "nuc_compare_positioning_identical" { ///| test "nuc_position_methods" { let pos = @src.NucPosition::new( - "chr1", 100, 300, 200.0, 200.0, 0.8, 0.01, true + "chr1", 100, 300, 200.0, 200.0, 0.8, 0.01, true, ) assert_eq(pos.nuc_chrom(), "chr1") assert_eq(pos.nuc_start(), 100) @@ -115,7 +118,7 @@ test "nuc_position_methods" { assert_true(pos.nuc_is_well_positioned()) let pos2 = @src.NucPosition::new( - "chr2", 500, 800, 650.0, 300.0, 0.5, 0.003, false + "chr2", 500, 800, 650.0, 300.0, 0.5, 0.003, false, ) assert_eq(pos2.nuc_chrom(), "chr2") assert_true(!pos2.nuc_is_well_positioned()) @@ -186,6 +189,8 @@ test "nuc_dynamic_result_methods" { assert_true(dynamic.nuc_n_shared() >= 0) assert_eq(dynamic.nuc_n_gained(), 0) assert_eq(dynamic.nuc_n_lost(), 0) - assert_true(dynamic.nuc_frac_changed() >= 0.0 && dynamic.nuc_frac_changed() <= 1.0) + assert_true( + dynamic.nuc_frac_changed() >= 0.0 && dynamic.nuc_frac_changed() <= 1.0, + ) assert_eq(dynamic.nuc_direction(), 0) -} \ No newline at end of file +} diff --git a/test/moonbit/open_cyto_test.mbt b/test/moonbit/open_cyto_test.mbt index db492dbd..feff9f68 100644 --- a/test/moonbit/open_cyto_test.mbt +++ b/test/moonbit/open_cyto_test.mbt @@ -223,7 +223,12 @@ test "oc_gate_new1d_fields" { ///| test "oc_gate_new2d_fields" { let g = @src.OcGate::new2d( - dim1="FSC", dim2="SSC", min1=1.0, max1=2.0, min2=3.0, max2=4.0, + dim1="FSC", + dim2="SSC", + min1=1.0, + max1=2.0, + min2=3.0, + max2=4.0, ) assert_eq(g.dim1, "FSC") assert_eq(g.dim2.unwrap(), "SSC") @@ -256,7 +261,12 @@ test "oc_event_in_gate_1d_boundary" { ///| test "oc_event_in_gate_2d" { let g = @src.OcGate::new2d( - dim1="FSC", dim2="SSC", min1=1.0, max1=3.0, min2=10.0, max2=20.0, + dim1="FSC", + dim2="SSC", + min1=1.0, + max1=3.0, + min2=10.0, + max2=20.0, ) // Both dims in range. assert_true(@src.oc_event_in_gate(g, 2.0, 15.0)) @@ -525,13 +535,13 @@ test "oc_t_pdf_zero_variance" { ///| test "oc_lgamma_one" { // lgamma(1) = log(gamma(1)) = log(1) = 0 - assert_true((@src.oc_lgamma(1.0)).abs() < 0.001) + assert_true(@src.oc_lgamma(1.0).abs() < 0.001) } ///| test "oc_lgamma_two" { // lgamma(2) = log(gamma(2)) = log(1) = 0 - assert_true((@src.oc_lgamma(2.0)).abs() < 0.001) + assert_true(@src.oc_lgamma(2.0).abs() < 0.001) } ///| @@ -651,7 +661,7 @@ test "oc_gating_rule_construction" { child="tcells", method="quantileGate", dims=["CD3"], - args=args, + args~, ) assert_eq(r.parent, "root") assert_eq(r.child, "tcells") @@ -668,22 +678,9 @@ test "oc_gating_rule_construction" { ///| test "oc_gate_flow_set_single_rule" { // One sample, one channel (FSC), bimodal FSC values. - let fs = @src.OcFlowSet::new( - sample_names=["S1"], - channel_names=["FSC"], - data=[ - [ - [1.0], - [1.1], - [0.9], - [1.2], - [5.0], - [5.1], - [4.9], - [5.2], - ], - ], - ) + let fs = @src.OcFlowSet::new(sample_names=["S1"], channel_names=["FSC"], data=[ + [[1.0], [1.1], [0.9], [1.2], [5.0], [5.1], [4.9], [5.2]], + ]) let args : Map[String, Double] = Map::new() args.set("bandwidth", 0.5) let rule = @src.OcGatingRule::new( @@ -691,7 +688,7 @@ test "oc_gate_flow_set_single_rule" { child="cells", method="mindensity", dims=["FSC"], - args=args, + args~, ) let results = @src.oc_gate_flow_set(fs, [rule]) assert_eq(results.length(), 1) @@ -761,16 +758,14 @@ test "oc_gate_flow_set_chain" { test "oc_population_stats_basic" { // Build a gating result by hand: 8 parent events, 4 child events. let gate = @src.OcGate::new1d(dim="FSC", min=3.0, max=1.0e30) - let indices = [ - false, false, false, false, true, true, true, true, - ] + let indices = [false, false, false, false, true, true, true, true] let result = @src.OcGatingResult::new( population="cells", sample="S1", - gate=gate, + gate~, parent_events=8, child_events=4, - indices=indices, + indices~, ) let stats = @src.oc_population_stats([result], 8) assert_eq(stats.length(), 1) @@ -789,7 +784,7 @@ test "oc_population_stats_zero_parent" { let result = @src.OcGatingResult::new( population="dead", sample="S1", - gate=gate, + gate~, parent_events=0, child_events=0, indices=[], @@ -809,7 +804,7 @@ test "oc_gating_summary_string" { let result = @src.OcGatingResult::new( population="cells", sample="S1", - gate=gate, + gate~, parent_events=8, child_events=4, indices=[false, false, false, false, true, true, true, true], @@ -829,7 +824,7 @@ test "oc_gating_summary_string" { ///| test "oc_ln_one" { - assert_true((@src.oc_ln(1.0)).abs() < 0.001) + assert_true(@src.oc_ln(1.0).abs() < 0.001) } ///| diff --git a/test/moonbit/pairaligner_test.mbt b/test/moonbit/pairaligner_test.mbt index bb789da8..5156294a 100644 --- a/test/moonbit/pairaligner_test.mbt +++ b/test/moonbit/pairaligner_test.mbt @@ -1,30 +1,33 @@ ///| /// Test file for pairaligner module. - test "pairaligner_alignment_mode_global" { let mode = @src.pairaligner_global() let config = @src.PairwiseAlignerConfig::default_dna().set_mode(mode) assert_eq(config.mode, mode) } +///| test "pairaligner_alignment_mode_local" { let mode = @src.pairaligner_local() let config = @src.PairwiseAlignerConfig::default_dna().set_mode(mode) assert_eq(config.mode, mode) } +///| test "pairaligner_substitution_matrix_no_matrix" { let mat = @src.pairaligner_no_matrix() let config = @src.PairwiseAlignerConfig::default_dna().set_submatrix(mat) assert_eq(config.submatrix, mat) } +///| test "pairaligner_substitution_matrix_blosum62" { let mat = @src.pairaligner_blosum62() let config = @src.PairwiseAlignerConfig::default_protein().set_submatrix(mat) assert_eq(config.submatrix, mat) } +///| test "pairaligner_default_dna_config" { let config = @src.PairwiseAlignerConfig::default_dna() assert_eq(config.match_score, 1.0) @@ -36,6 +39,7 @@ test "pairaligner_default_dna_config" { assert_eq(config.query_gap_open, -1.0) } +///| test "pairaligner_default_protein_config" { let config = @src.PairwiseAlignerConfig::default_protein() assert_eq(config.gap_open, -10.0) @@ -44,6 +48,7 @@ test "pairaligner_default_protein_config" { assert_eq(config.submatrix, @src.pairaligner_blosum62()) } +///| test "pairaligner_config_setters" { let base = @src.PairwiseAlignerConfig::default_dna() let c1 = base.set_match_score(5.0) @@ -63,11 +68,12 @@ test "pairaligner_config_setters" { assert_eq(base.mismatch_score, -1.0) } +///| test "pairaligner_align_global_dna" { let target = "ACGT" let query = "ACGT" let config = @src.PairwiseAlignerConfig::default_dna() - let aln = @src.pairaligner_align(target, query, config=config) + let aln = @src.pairaligner_align(target, query, config~) assert_eq(aln.aligned1(), "ACGT") assert_eq(aln.aligned2(), "ACGT") assert_eq(aln.identities(), 4) @@ -77,44 +83,50 @@ test "pairaligner_align_global_dna" { assert_eq(ml, "||||") } +///| test "pairaligner_align_global_dna_with_mismatch" { let target = "ACGT" let query = "AGGT" let config = @src.PairwiseAlignerConfig::default_dna() - let aln = @src.pairaligner_align(target, query, config=config) + let aln = @src.pairaligner_align(target, query, config~) assert_eq(aln.alignment_length(), 4) let ml = aln.match_line assert_eq(ml[1:2], ".") assert_eq(aln.score(), 2.0) } +///| test "pairaligner_align_local_dna" { let target = "XXXXACGTXXXX" let query = "ACGT" - let config = @src.PairwiseAlignerConfig::default_dna() - .set_mode(@src.pairaligner_local()) - let aln = @src.pairaligner_align(target, query, config=config) + let config = @src.PairwiseAlignerConfig::default_dna().set_mode( + @src.pairaligner_local(), + ) + let aln = @src.pairaligner_align(target, query, config~) assert_eq(aln.aligned1(), "ACGT") assert_eq(aln.aligned2(), "ACGT") assert_eq(aln.identities(), 4) assert_eq(aln.score(), 4.0) } +///| test "pairaligner_align_protein_blosum62" { let (target, query) = @src.pairaligner_sample_data() let config = @src.PairwiseAlignerConfig::default_protein() - let aln = @src.pairaligner_align(target, query, config=config) + let aln = @src.pairaligner_align(target, query, config~) assert_true(aln.alignment_length() > 0) assert_true(aln.score() > 0.0) assert_true(aln.identities() > 0) } +///| test "pairaligner_aligned1_aligned2" { let aln = @src.pairaligner_align("ACGT", "ACGT") assert_eq(aln.aligned1(), aln.aligned_target) assert_eq(aln.aligned2(), aln.aligned_query) } +///| test "pairaligner_alignment_length" { let aln = @src.pairaligner_align("AAAA", "AAAA") assert_eq(aln.alignment_length(), 4) @@ -122,6 +134,7 @@ test "pairaligner_alignment_length" { assert_eq(aln.aligned2().length(), 4) } +///| test "pairaligner_identities_and_identity_pct" { let aln = @src.pairaligner_align("ACGT", "ACGT") assert_eq(aln.identities(), 4) @@ -131,23 +144,26 @@ test "pairaligner_identities_and_identity_pct" { assert_eq(aln2.identity_pct(), 75.0) } +///| test "pairaligner_gaps_count" { let config = @src.PairwiseAlignerConfig::default_dna() .set_gap_open(-2.0) .set_gap_extend(-1.0) let target = "AAACCC" let query = "AAA" - let aln = @src.pairaligner_align(target, query, config=config) + let aln = @src.pairaligner_align(target, query, config~) let gc = aln.gaps_count() assert_true(gc >= 3) } +///| test "pairaligner_score_extraction" { let aln = @src.pairaligner_align("ACGT", "ACGT") assert_eq(aln.score(), 4.0) assert_eq(aln.score(), aln.score) } +///| test "pairaligner_sample_data" { let (t, q) = @src.pairaligner_sample_data() assert_eq(t, "HEAGAWGHEE") @@ -156,6 +172,7 @@ test "pairaligner_sample_data" { assert_true(q.length() > 0) } +///| test "pairaligner_affine_vs_linear" { let target = "AAAAAAAAAA" let query = "AAAA" @@ -175,6 +192,7 @@ test "pairaligner_affine_vs_linear" { assert_true(linear_aln.score() < 100.0) } +///| test "pairaligner_config_new_named" { let config = @src.PairwiseAlignerConfig::new( mode=@src.pairaligner_local(), @@ -191,12 +209,14 @@ test "pairaligner_config_new_named" { assert_eq(config.alphabet_type, "DNA") } +///| test "pairaligner_local_mode_start_end_positions" { let target = "XXACGTYY" let query = "ACGT" - let config = @src.PairwiseAlignerConfig::default_dna() - .set_mode(@src.pairaligner_local()) - let aln = @src.pairaligner_align(target, query, config=config) + let config = @src.PairwiseAlignerConfig::default_dna().set_mode( + @src.pairaligner_local(), + ) + let aln = @src.pairaligner_align(target, query, config~) assert_eq(aln.target_start, 2) assert_eq(aln.target_end, 6) assert_eq(aln.query_start, 0) diff --git a/test/moonbit/pairwise2_test.mbt b/test/moonbit/pairwise2_test.mbt index feb40d10..582d1706 100644 --- a/test/moonbit/pairwise2_test.mbt +++ b/test/moonbit/pairwise2_test.mbt @@ -74,7 +74,7 @@ test "pairwise_local_convenience" { test "simple_score_match" { let scorer = @src.simple_score(2.0, -1.0) assert_true((scorer("A", "A") - 2.0).abs() < 0.001) - assert_true((scorer("A", "T") - (-1.0)).abs() < 0.001) + assert_true((scorer("A", "T") - -1.0).abs() < 0.001) } ///| @@ -94,7 +94,7 @@ test "identity_score" { test "dna_matrix" { let m = @src.dna_matrix(2.0, -1.0) assert_true((m.get("AA").unwrap() - 2.0).abs() < 0.001) - assert_true((m.get("AT").unwrap() - (-1.0)).abs() < 0.001) + assert_true((m.get("AT").unwrap() - -1.0).abs() < 0.001) assert_eq(m.size(), 10) // 10 unique pairs } @@ -103,7 +103,7 @@ test "matrix_score" { let m = @src.dna_matrix(2.0, -1.0) let scorer = @src.matrix_score(m, 0.0) assert_true((scorer("A", "A") - 2.0).abs() < 0.001) - assert_true((scorer("A", "T") - (-1.0)).abs() < 0.001) + assert_true((scorer("A", "T") - -1.0).abs() < 0.001) assert_true((scorer("X", "X") - 0.0).abs() < 0.001) // default } diff --git a/test/moonbit/paml_test.mbt b/test/moonbit/paml_test.mbt index b4bfdd1f..070fb497 100644 --- a/test/moonbit/paml_test.mbt +++ b/test/moonbit/paml_test.mbt @@ -1,17 +1,18 @@ ///| /// Tests for PAML module. - test "PAMLAlignment creation" { let seqs = [("Human", "ATGCCG"), ("Mouse", "ATGCCG")] let alignment = @src.PAMLAlignment::new(seqs) assert_eq(alignment.sequences.length(), 2) } +///| test "PAMLResult creation" { let result = @src.PAMLResult::new(-100.0) assert_eq(result.ln_likelihood, -100.0) } +///| test "DNDSResult creation" { let dnds = @src.DNDSResult::new(0.1, 0.5, 0.2) assert_eq(dnds.dN, 0.1) @@ -19,17 +20,20 @@ test "DNDSResult creation" { assert_eq(dnds.omega, 0.2) } +///| test "paml_calculate_dnds identical sequences" { let dnds = @src.paml_calculate_dnds("ATGCCG", "ATGCCG", "Nei-Gojobori") assert_true(dnds.omega >= 0.0) } +///| test "paml_calculate_dnds different sequences" { let dnds = @src.paml_calculate_dnds("ATGCCG", "ATTTTT", "Nei-Gojobori") assert_true(dnds.dN >= 0.0) assert_true(dnds.dS >= 0.0) } +///| test "paml_estimate_parameters" { let seqs = [("Seq1", "ATGC"), ("Seq2", "ATGC")] let alignment = @src.PAMLAlignment::new(seqs) @@ -37,24 +41,31 @@ test "paml_estimate_parameters" { assert_true(result.parameters.contains("pi_A")) } +///| test "paml_calculate_substitution_matrix" { - let pi = Map([("pi_A", 0.25), ("pi_T", 0.25), ("pi_C", 0.25), ("pi_G", 0.25)], capacity=4) + let pi = Map( + [("pi_A", 0.25), ("pi_T", 0.25), ("pi_C", 0.25), ("pi_G", 0.25)], + capacity=4, + ) let matrix = @src.paml_calculate_substitution_matrix(2.0, pi) assert_eq(matrix.length(), 4) } +///| test "paml_create_example_alignment" { let alignment = @src.paml_create_example_alignment() assert_eq(alignment.sequences.length(), 4) } +///| test "paml_run_likelihood" { let alignment = @src.paml_create_example_alignment() let result = @src.paml_run_likelihood(alignment) assert_true(result.dnds_ratios.length() > 0) } +///| test "get_standard_codon_table" { let table = @src.get_standard_codon_table() assert_true(table.contains("ATG")) -} \ No newline at end of file +} diff --git a/test/moonbit/parsimony_test.mbt b/test/moonbit/parsimony_test.mbt index b1a041c9..2dda34b2 100644 --- a/test/moonbit/parsimony_test.mbt +++ b/test/moonbit/parsimony_test.mbt @@ -41,7 +41,10 @@ test "parsimony_matrix_sankoff_dna_construction" { ///| test "parsimony_matrix_sankoff_custom_costs" { - let m = @src.parsimony_sankoff_dna_matrix(transition_cost=0.5, transversion_cost=2.5) + let m = @src.parsimony_sankoff_dna_matrix( + transition_cost=0.5, + transversion_cost=2.5, + ) // A->G (transition) = 0.5 assert_eq(@src.parsimony_matrix_cost(m, 0, 2), 0.5) // A->C (transversion) = 2.5 @@ -238,7 +241,10 @@ test "sankoff_parsimony_lower_than_fitch_for_transitions" { let root = @src.Clade::new(clades=[inner_left, inner_right]) let tree = @src.Tree::new(root, rooted=true) let fitch_score = @src.fitch_parsimony_score(tree, aln) - let matrix = @src.parsimony_sankoff_dna_matrix(transition_cost=1.0, transversion_cost=2.0) + let matrix = @src.parsimony_sankoff_dna_matrix( + transition_cost=1.0, + transversion_cost=2.0, + ) let sankoff_score = @src.sankoff_parsimony_score(tree, aln, matrix) // All changes are A<->G (transitions), so Sankoff = Fitch here assert_eq(sankoff_score, fitch_score) diff --git a/test/moonbit/pathway_test.mbt b/test/moonbit/pathway_test.mbt index 4647ee6a..7c359eb6 100644 --- a/test/moonbit/pathway_test.mbt +++ b/test/moonbit/pathway_test.mbt @@ -11,7 +11,9 @@ test "Reaction_new" { reactants.push("glucose") let products : Array[String] = Array::new() products.push("g6p") - let reaction = @src.Reaction::new("r1", "Hexokinase", reactants, products, false) + let reaction = @src.Reaction::new( + "r1", "Hexokinase", reactants, products, false, + ) assert_eq(reaction.id, "r1") assert_eq(reaction.name, "Hexokinase") assert_eq(reaction.reactants.length(), 1) @@ -23,14 +25,16 @@ test "Reaction_new" { test "Pathway_new" { let species : Array[@src.Species] = Array::new() species.push(@src.Species::new("glucose", "Glucose")) - + let reactants : Array[String] = Array::new() reactants.push("glucose") let products : Array[String] = Array::new() products.push("g6p") let reactions : Array[@src.Reaction] = Array::new() - reactions.push(@src.Reaction::new("r1", "Hexokinase", reactants, products, false)) - + reactions.push( + @src.Reaction::new("r1", "Hexokinase", reactants, products, false), + ) + let pathway = @src.Pathway::new("test", "Test Pathway", species, reactions) assert_eq(pathway.id, "test") assert_eq(pathway.name, "Test Pathway") @@ -90,4 +94,4 @@ test "Reaction_to_string" { let reaction = @src.Reaction::new("r1", "Test", reactants, products, true) let str = @src.Reaction::to_string(reaction) assert_true(str.length() > 0) -} \ No newline at end of file +} diff --git a/test/moonbit/pcatools_test.mbt b/test/moonbit/pcatools_test.mbt index bacd7359..4d9cba19 100644 --- a/test/moonbit/pcatools_test.mbt +++ b/test/moonbit/pcatools_test.mbt @@ -10,12 +10,7 @@ test "biplot_options_new" { ///| test "pcatools_run_pca_simple_2d" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 4.0], - [4.0, 5.0], - ] + let data = [[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [4.0, 5.0]] let res = @src.pcatools_run_pca(data, 2, false) assert_eq(res.n_samples, 4) assert_eq(res.n_variables, 2) @@ -30,11 +25,7 @@ test "pcatools_run_pca_simple_2d" { ///| test "pcatools_run_pca_ncomponents_limit" { - let data = [ - [1.0, 2.0, 3.0, 4.0], - [2.0, 3.0, 4.0, 5.0], - [3.0, 4.0, 5.0, 6.0], - ] + let data = [[1.0, 2.0, 3.0, 4.0], [2.0, 3.0, 4.0, 5.0], [3.0, 4.0, 5.0, 6.0]] let res = @src.pcatools_run_pca(data, 10, false) // 3 samples, 4 variables => p=4, so limited to 4 assert_eq(res.n_components, 4) @@ -42,12 +33,7 @@ test "pcatools_run_pca_ncomponents_limit" { ///| test "pcatools_run_pca_scale_true" { - let data = [ - [1.0, 100.0], - [2.0, 200.0], - [3.0, 300.0], - [4.0, 400.0], - ] + let data = [[1.0, 100.0], [2.0, 200.0], [3.0, 300.0], [4.0, 400.0]] let res = @src.pcatools_run_pca(data, 2, true) assert_eq(res.used_scaling, true) assert_eq(res.scale.length(), 2) @@ -82,16 +68,10 @@ test "scree_plot_ascii_returns_string" { ///| test "pca_biplot_ascii_returns_string" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 5.0], - [4.0, 4.0], - [5.0, 6.0], - ] + let data = [[1.0, 2.0], [2.0, 3.0], [3.0, 5.0], [4.0, 4.0], [5.0, 6.0]] let res = @src.pcatools_run_pca(data, 2, false) let opts = @src.BiplotOptions::new() - let plot = @src.pca_biplot_ascii(res, opts=opts) + let plot = @src.pca_biplot_ascii(res, opts~) assert_true(plot.length() > 0) assert_true(plot.contains("PCA biplot")) assert_true(plot.contains("PC1")) @@ -116,7 +96,9 @@ test "find_pca_outliers_basic" { assert_true(out.indices.length() >= 1) let mut found7 = false for i in out.indices { - if i == 7 { found7 = true } + if i == 7 { + found7 = true + } } assert_true(found7) } @@ -124,8 +106,11 @@ test "find_pca_outliers_basic" { ///| test "find_pca_outliers_cutoff_positive" { let data = [ - [1.0, 1.0], [1.1, 1.0], [0.9, 1.0], - [1.0, 1.1], [1.0, 0.9], + [1.0, 1.0], + [1.1, 1.0], + [0.9, 1.0], + [1.0, 1.1], + [1.0, 0.9], [20.0, 20.0], ] let res = @src.pcatools_run_pca(data, 2, false) @@ -164,11 +149,7 @@ test "variable_correlations_shape" { ///| test "pcatools_summary_contains_keywords" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [3.0, 4.0], - ] + let data = [[1.0, 2.0], [2.0, 3.0], [3.0, 4.0]] let res = @src.pcatools_run_pca(data, 2, false) let s = @src.pcatools_summary(res) assert_true(s.contains("PCAResult")) diff --git a/test/moonbit/pcd_test.mbt b/test/moonbit/pcd_test.mbt index f35de6d1..396fc638 100644 --- a/test/moonbit/pcd_test.mbt +++ b/test/moonbit/pcd_test.mbt @@ -12,6 +12,7 @@ test "pcd_spectrum_construction" { assert_eq(spec.num_peaks(), 0) } +///| test "pcd_spectrum_add_peak" { let spec = @src.PcdSpectrum::new(1) spec.add_peak(500.5, 10000.0) @@ -20,6 +21,7 @@ test "pcd_spectrum_add_peak" { assert_true(spec.total_intensity() > 0.0) } +///| test "pcd_spectrum_precursor" { let spec = @src.PcdSpectrum::new(1) spec.set_precursor_mz(Some(500.5)) @@ -38,12 +40,14 @@ test "pcd_spectrum_precursor" { // PcdFile Tests // ============================================================================ +///| test "pcd_file_construction" { let file = @src.PcdFile::new() assert_eq(file.num_spectra, 0) assert_eq(file.num_peaks, 0) } +///| test "pcd_file_add_spectrum" { let file = @src.PcdFile::new() let spec = @src.PcdSpectrum::new(1, rt=10.0) @@ -54,6 +58,7 @@ test "pcd_file_add_spectrum" { assert_eq(file.num_peaks, 1) } +///| test "pcd_file_get_spectrum" { let file = @src.PcdFile::new() let spec1 = @src.PcdSpectrum::new(1) @@ -74,12 +79,14 @@ test "pcd_file_get_spectrum" { // PCD Parsing Tests // ============================================================================ +///| test "pcd_parse_empty" { let file = @src.pcd_parse("") assert_eq(file.num_spectra, 0) assert_eq(file.num_peaks, 0) } +///| test "pcd_parse_sample" { let content = @src.pcd_sample() let file = @src.pcd_parse(content) @@ -87,6 +94,7 @@ test "pcd_parse_sample" { assert_true(file.num_peaks >= 1) } +///| test "pcd_parse_with_precursor" { let content = @src.pcd_sample() let file = @src.pcd_parse(content) @@ -97,6 +105,7 @@ test "pcd_parse_with_precursor" { // PCD Query Tests // ============================================================================ +///| test "pcd_total_peaks" { let file = @src.PcdFile::new() let spec1 = @src.PcdSpectrum::new(1) @@ -110,6 +119,7 @@ test "pcd_total_peaks" { assert_eq(@src.pcd_total_peaks(file), 3) } +///| test "pcd_bpc" { let file = @src.PcdFile::new() let spec1 = @src.PcdSpectrum::new(1, rt=10.0) @@ -125,6 +135,7 @@ test "pcd_bpc" { assert_eq(bpc.length(), 2) } +///| test "pcd_tic" { let file = @src.PcdFile::new() let spec1 = @src.PcdSpectrum::new(1, rt=10.0) @@ -139,6 +150,7 @@ test "pcd_tic" { assert_eq(tic.length(), 2) } +///| test "pcd_spectrum_by_mz" { let spec = @src.PcdSpectrum::new(1) spec.add_peak(500.0, 1000.0) @@ -152,6 +164,7 @@ test "pcd_spectrum_by_mz" { // PCD Serialization Tests // ============================================================================ +///| test "pcd_write_roundtrip" { let content = @src.pcd_sample() let file = @src.pcd_parse(content) @@ -164,6 +177,7 @@ test "pcd_write_roundtrip" { // PCD Summary Tests // ============================================================================ +///| test "pcd_summary" { let file = @src.PcdFile::new() let spec = @src.PcdSpectrum::new(1) diff --git a/test/moonbit/pdb_analysis_test.mbt b/test/moonbit/pdb_analysis_test.mbt index 376b8ef7..fe4c3521 100644 --- a/test/moonbit/pdb_analysis_test.mbt +++ b/test/moonbit/pdb_analysis_test.mbt @@ -184,9 +184,9 @@ test "pdb_analysis: ramachandran_quality" { test "pdb_analysis: get_hydrophobicity" { // Test some known values from Kyte-Doolittle scale assert_true((@src.get_hydrophobicity("ALA") - 1.8).abs() < 0.001) - assert_true((@src.get_hydrophobicity("ARG") - (-4.5)).abs() < 0.001) + assert_true((@src.get_hydrophobicity("ARG") - -4.5).abs() < 0.001) assert_true((@src.get_hydrophobicity("ILE") - 4.5).abs() < 0.001) - assert_true((@src.get_hydrophobicity("LYS") - (-3.9)).abs() < 0.001) + assert_true((@src.get_hydrophobicity("LYS") - -3.9).abs() < 0.001) assert_true((@src.get_hydrophobicity("PHE") - 2.8).abs() < 0.001) assert_true((@src.get_hydrophobicity("VAL") - 4.2).abs() < 0.001) // Unknown residue should return 0 diff --git a/test/moonbit/pdb_dice_test.mbt b/test/moonbit/pdb_dice_test.mbt index 6aa87729..62b94379 100644 --- a/test/moonbit/pdb_dice_test.mbt +++ b/test/moonbit/pdb_dice_test.mbt @@ -8,34 +8,131 @@ fn create_test_structure() -> @src.Structure { // Create a simple structure with 2 chains, each with 3 residues let atoms_a1 : Array[@src.Atom] = [ - @src.Atom::new(name="N", coord=@src.Vector3::new(0.0, 0.0, 0.0), resname="ALA", chainid='A', resseq=1), - @src.Atom::new(name="CA", coord=@src.Vector3::new(1.5, 0.0, 0.0), resname="ALA", chainid='A', resseq=1), - @src.Atom::new(name="C", coord=@src.Vector3::new(2.5, 1.0, 0.0), resname="ALA", chainid='A', resseq=1), - @src.Atom::new(name="O", coord=@src.Vector3::new(2.5, 2.0, 0.0), resname="ALA", chainid='A', resseq=1), + @src.Atom::new( + name="N", + coord=@src.Vector3::new(0.0, 0.0, 0.0), + resname="ALA", + chainid='A', + resseq=1, + ), + @src.Atom::new( + name="CA", + coord=@src.Vector3::new(1.5, 0.0, 0.0), + resname="ALA", + chainid='A', + resseq=1, + ), + @src.Atom::new( + name="C", + coord=@src.Vector3::new(2.5, 1.0, 0.0), + resname="ALA", + chainid='A', + resseq=1, + ), + @src.Atom::new( + name="O", + coord=@src.Vector3::new(2.5, 2.0, 0.0), + resname="ALA", + chainid='A', + resseq=1, + ), ] let atoms_a2 : Array[@src.Atom] = [ - @src.Atom::new(name="N", coord=@src.Vector3::new(3.5, 0.0, 0.0), resname="GLY", chainid='A', resseq=2), - @src.Atom::new(name="CA", coord=@src.Vector3::new(5.0, 0.0, 0.0), resname="GLY", chainid='A', resseq=2), + @src.Atom::new( + name="N", + coord=@src.Vector3::new(3.5, 0.0, 0.0), + resname="GLY", + chainid='A', + resseq=2, + ), + @src.Atom::new( + name="CA", + coord=@src.Vector3::new(5.0, 0.0, 0.0), + resname="GLY", + chainid='A', + resseq=2, + ), ] let atoms_a3 : Array[@src.Atom] = [ - @src.Atom::new(name="N", coord=@src.Vector3::new(6.0, 0.0, 0.0), resname="VAL", chainid='A', resseq=3), - @src.Atom::new(name="CA", coord=@src.Vector3::new(7.5, 0.0, 0.0), resname="VAL", chainid='A', resseq=3), + @src.Atom::new( + name="N", + coord=@src.Vector3::new(6.0, 0.0, 0.0), + resname="VAL", + chainid='A', + resseq=3, + ), + @src.Atom::new( + name="CA", + coord=@src.Vector3::new(7.5, 0.0, 0.0), + resname="VAL", + chainid='A', + resseq=3, + ), ] - let res_a1 = @src.Residue::new(resname="ALA", chainid='A', resseq=1, atoms=atoms_a1) - let res_a2 = @src.Residue::new(resname="GLY", chainid='A', resseq=2, atoms=atoms_a2) - let res_a3 = @src.Residue::new(resname="VAL", chainid='A', resseq=3, atoms=atoms_a3) + let res_a1 = @src.Residue::new( + resname="ALA", + chainid='A', + resseq=1, + atoms=atoms_a1, + ) + let res_a2 = @src.Residue::new( + resname="GLY", + chainid='A', + resseq=2, + atoms=atoms_a2, + ) + let res_a3 = @src.Residue::new( + resname="VAL", + chainid='A', + resseq=3, + atoms=atoms_a3, + ) let chain_a = @src.Chain::new(id='A', residues=[res_a1, res_a2, res_a3]) let atoms_b1 : Array[@src.Atom] = [ - @src.Atom::new(name="N", coord=@src.Vector3::new(0.0, 5.0, 0.0), resname="SER", chainid='B', resseq=10), - @src.Atom::new(name="CA", coord=@src.Vector3::new(1.5, 5.0, 0.0), resname="SER", chainid='B', resseq=10), + @src.Atom::new( + name="N", + coord=@src.Vector3::new(0.0, 5.0, 0.0), + resname="SER", + chainid='B', + resseq=10, + ), + @src.Atom::new( + name="CA", + coord=@src.Vector3::new(1.5, 5.0, 0.0), + resname="SER", + chainid='B', + resseq=10, + ), ] let atoms_b2 : Array[@src.Atom] = [ - @src.Atom::new(name="N", coord=@src.Vector3::new(3.5, 5.0, 0.0), resname="THR", chainid='B', resseq=11), - @src.Atom::new(name="CA", coord=@src.Vector3::new(5.0, 5.0, 0.0), resname="THR", chainid='B', resseq=11), + @src.Atom::new( + name="N", + coord=@src.Vector3::new(3.5, 5.0, 0.0), + resname="THR", + chainid='B', + resseq=11, + ), + @src.Atom::new( + name="CA", + coord=@src.Vector3::new(5.0, 5.0, 0.0), + resname="THR", + chainid='B', + resseq=11, + ), ] - let res_b1 = @src.Residue::new(resname="SER", chainid='B', resseq=10, atoms=atoms_b1) - let res_b2 = @src.Residue::new(resname="THR", chainid='B', resseq=11, atoms=atoms_b2) + let res_b1 = @src.Residue::new( + resname="SER", + chainid='B', + resseq=10, + atoms=atoms_b1, + ) + let res_b2 = @src.Residue::new( + resname="THR", + chainid='B', + resseq=11, + atoms=atoms_b2, + ) let chain_b = @src.Chain::new(id='B', residues=[res_b1, res_b2]) let model = @src.Model::new(id=0, chains=[chain_a, chain_b]) @@ -144,10 +241,7 @@ test "extract_residue_range_chain_b" { ///| test "extract_residues_by_ids" { let structure = create_test_structure() - let ids = [ - @src.ResidueId::new('A', 1), - @src.ResidueId::new('B', 10), - ] + let ids = [@src.ResidueId::new('A', 1), @src.ResidueId::new('B', 10)] let result = @src.extract_residues(structure, ids) // Should have 2 chains, each with 1 residue assert_eq(result.models[0].chains.length(), 2) diff --git a/test/moonbit/pdb_header_test.mbt b/test/moonbit/pdb_header_test.mbt index 966ce345..edf9fe5b 100644 --- a/test/moonbit/pdb_header_test.mbt +++ b/test/moonbit/pdb_header_test.mbt @@ -69,9 +69,7 @@ test "dbref_entry_creation" { ///| test "parse_title_record_single_line" { - let lines = [ - "TITLE Crystal structure of a protein", - ] + let lines = ["TITLE Crystal structure of a protein"] let title = @src.parse_title_record(lines, 0) assert_true(title.contains("Crystal structure")) } @@ -79,8 +77,7 @@ test "parse_title_record_single_line" { ///| test "parse_title_record_multi_line" { let lines = [ - "TITLE Crystal structure of a protein", - "TITLE in complex with ligand", + "TITLE Crystal structure of a protein", "TITLE in complex with ligand", ] let title = @src.parse_title_record(lines, 0) assert_true(title.contains("Crystal structure")) @@ -126,10 +123,8 @@ test "parse_rfactor_record_no_keyword" { ///| test "extract_chain_ids" { - let compound = @src.CompoundInfo::new( - chain_ids=["A", "B", "C"], - ) - let header = @src.PDBHeader::new(compound=compound) + let compound = @src.CompoundInfo::new(chain_ids=["A", "B", "C"]) + let header = @src.PDBHeader::new(compound~) let chains = @src.extract_chain_ids(header) assert_eq(chains.length(), 3) assert_eq(chains[0], "A") @@ -155,8 +150,7 @@ test "parse_pdb_header_empty" { ///| test "parse_pdb_header_missing_records" { - let pdb_text = - "HEADER VIRUS 01-JAN-20 1ABC\n" + let pdb_text = "HEADER VIRUS 01-JAN-20 1ABC\n" let header = @src.parse_pdb_header(pdb_text) assert_eq(header.title, "") assert_eq(header.compound.molecule_id, "") @@ -172,8 +166,7 @@ test "parse_pdb_header_missing_records" { ///| test "parse_pdb_header_lines" { let lines = [ - "HEADER VIRUS 01-JAN-20 1ABC", - "TITLE Crystal structure", + "HEADER VIRUS 01-JAN-20 1ABC", "TITLE Crystal structure", ] let header = @src.parse_pdb_header_lines(lines) assert_true(header.title.length() > 0) diff --git a/test/moonbit/pdb_list_test.mbt b/test/moonbit/pdb_list_test.mbt index a3518738..ef753b2e 100644 --- a/test/moonbit/pdb_list_test.mbt +++ b/test/moonbit/pdb_list_test.mbt @@ -1,31 +1,34 @@ ///| /// Tests for PDBList module. - test "PDBList creation" { let pdblist = @src.create_example_pdblist() assert_eq(pdblist.pdb_dir, "/data/pdb") } +///| test "PDBList download_pdb" { let pdblist = @src.PDBList::new("/data/pdb") let file = pdblist.download_pdb("1XYZ", "pdb") assert_true(file.contains("1XYZ")) } +///| test "PDBList get_pdb_file" { let pdblist = @src.PDBList::new("/data/pdb") let file = pdblist.get_pdb_file("1XYZ", "pdb", false) assert_true(file.contains("1XYZ")) } +///| test "PDBList get_pdb_file obsolete" { let pdblist = @src.PDBList::new("/data/pdb") let file = pdblist.get_pdb_file("1XYZ", "pdb", true) assert_true(file.contains("obsolete")) } +///| test "PDBList resolve_obsolete" { let pdblist = @src.PDBList::new("/data/pdb") let resolved = pdblist.resolve_obsolete("1XYZ") assert_eq(resolved, "2XYZ") -} \ No newline at end of file +} diff --git a/test/moonbit/pdb_packing_test.mbt b/test/moonbit/pdb_packing_test.mbt index 635448ff..35c2d227 100644 --- a/test/moonbit/pdb_packing_test.mbt +++ b/test/moonbit/pdb_packing_test.mbt @@ -99,7 +99,11 @@ test "packing_result_creation" { ///| test "packing_result_get_density" { - let result = @src.PackingResult::new(residue_name="GLU", residue_seq=5, density=3.7) + let result = @src.PackingResult::new( + residue_name="GLU", + residue_seq=5, + density=3.7, + ) assert_eq(result.get_density(), 3.7) } @@ -321,12 +325,7 @@ test "calculate_packing_sasa_empty" { ///| test "calculate_packing_sasa_single_atom" { let atoms : Array[@src.PackingAtom] = [ - @src.PackingAtom::new( - x=0.0, - y=0.0, - z=0.0, - vdw_radius=1.7, - ), + @src.PackingAtom::new(x=0.0, y=0.0, z=0.0, vdw_radius=1.7), ] let sasa = @src.calculate_packing_sasa(atoms, probe_radius=1.4, n_points=50) assert_eq(sasa > 0.0, true) @@ -349,28 +348,44 @@ test "calculate_packing_sasa_lower_probe" { ///| test "normalize_packing_density_below_threshold" { - let result = @src.PackingResult::new(residue_name="ALA", residue_seq=1, density=0.5) + let result = @src.PackingResult::new( + residue_name="ALA", + residue_seq=1, + density=0.5, + ) let normalized = @src.normalize_packing_density(result, threshold=2.0) assert_eq(normalized.density, 0.25) } ///| test "normalize_packing_density_above_threshold" { - let result = @src.PackingResult::new(residue_name="ALA", residue_seq=1, density=3.0) + let result = @src.PackingResult::new( + residue_name="ALA", + residue_seq=1, + density=3.0, + ) let normalized = @src.normalize_packing_density(result, threshold=2.0) assert_eq(normalized.density, 1.0) } ///| test "normalize_packing_density_at_threshold" { - let result = @src.PackingResult::new(residue_name="ALA", residue_seq=1, density=2.0) + let result = @src.PackingResult::new( + residue_name="ALA", + residue_seq=1, + density=2.0, + ) let normalized = @src.normalize_packing_density(result, threshold=2.0) assert_eq(normalized.density, 1.0) } ///| test "normalize_packing_density_zero_threshold" { - let result = @src.PackingResult::new(residue_name="ALA", residue_seq=1, density=1.5) + let result = @src.PackingResult::new( + residue_name="ALA", + residue_seq=1, + density=1.5, + ) let normalized = @src.normalize_packing_density(result, threshold=0.0) assert_eq(normalized.density, 1.5) } @@ -378,9 +393,24 @@ test "normalize_packing_density_zero_threshold" { ///| test "identify_low_packing_basic" { let results : Array[@src.PackingResult] = [ - @src.PackingResult::new(residue_name="ALA", residue_seq=1, chain_id='A', density=0.3), - @src.PackingResult::new(residue_name="GLY", residue_seq=2, chain_id='A', density=1.5), - @src.PackingResult::new(residue_name="VAL", residue_seq=3, chain_id='A', density=0.4), + @src.PackingResult::new( + residue_name="ALA", + residue_seq=1, + chain_id='A', + density=0.3, + ), + @src.PackingResult::new( + residue_name="GLY", + residue_seq=2, + chain_id='A', + density=1.5, + ), + @src.PackingResult::new( + residue_name="VAL", + residue_seq=3, + chain_id='A', + density=0.4, + ), ] let analysis = @src.PackingAnalysisResult::new(results~, n_residues=3) let low = @src.identify_low_packing(analysis, cutoff=0.5) @@ -412,7 +442,7 @@ test "identify_low_packing_all_below" { ///| test "sphere_volume_calculation" { let vol = @src.sphere_volume(2.0) - let expected = (4.0 / 3.0) * 3.14159265358979323846 * 8.0 + let expected = 4.0 / 3.0 * 3.14159265358979323846 * 8.0 assert_eq((vol - expected).abs() < 0.001, true) } @@ -445,7 +475,10 @@ test "sphere_volume_radius_roundtrip" { ///| test "calculate_packing_efficiency_basic" { let atoms = @src.create_demo_packing_atoms() - let efficiency = @src.calculate_packing_efficiency(atoms, container_radius=10.0) + let efficiency = @src.calculate_packing_efficiency( + atoms, + container_radius=10.0, + ) assert_eq(efficiency > 0.0, true) } @@ -460,7 +493,10 @@ test "calculate_packing_efficiency_empty" { test "calculate_packing_efficiency_large_container" { let atoms = @src.create_demo_packing_atoms() let eff_small = @src.calculate_packing_efficiency(atoms, container_radius=5.0) - let eff_large = @src.calculate_packing_efficiency(atoms, container_radius=50.0) + let eff_large = @src.calculate_packing_efficiency( + atoms, + container_radius=50.0, + ) assert_eq(eff_small > eff_large, true) } @@ -524,7 +560,11 @@ test "packing_density_with_demo_atoms" { ///| test "packing_analysis_with_demo_atoms" { let atoms = @src.create_demo_packing_atoms() - let analysis = @src.packing_density_per_residue(atoms, radius=1.4, n_points=20) + let analysis = @src.packing_density_per_residue( + atoms, + radius=1.4, + n_points=20, + ) assert_eq(analysis.n_residues, 3) assert_eq(analysis.mean_density > 0.0, true) assert_eq(analysis.n_buried + analysis.n_exposed, 3) @@ -540,7 +580,11 @@ test "sasa_with_demo_atoms" { ///| test "low_packing_identification_with_analysis" { let atoms = @src.create_demo_packing_atoms() - let analysis = @src.packing_density_per_residue(atoms, radius=1.4, n_points=20) + let analysis = @src.packing_density_per_residue( + atoms, + radius=1.4, + n_points=20, + ) let low = @src.identify_low_packing(analysis, cutoff=0.0) assert_eq(low.length() >= 0, true) } @@ -582,4 +626,4 @@ test "packing_result_default_creation" { assert_eq(result.density, 0.0) assert_eq(result.n_contacting_atoms, 0) assert_eq(result.n_shell_points, 0) -} \ No newline at end of file +} diff --git a/test/moonbit/pdb_seqio_test.mbt b/test/moonbit/pdb_seqio_test.mbt index abaca152..4d7eb1d0 100644 --- a/test/moonbit/pdb_seqio_test.mbt +++ b/test/moonbit/pdb_seqio_test.mbt @@ -165,7 +165,8 @@ test "pdb_atom_parser_basic" { ///| test "pdb_atom_parser_with_pdb_id" { let header = "HEADER PROTEIN" + " ".repeat(33) + "01-JAN-24 1XXX" - let pdb_text = header + "\nATOM 1 N ALA A 1 10.000 20.000 30.000 1.00 20.00 N \nATOM 2 N GLY A 2 12.000 22.000 32.000 1.00 20.00 N \nTER 3 GLY A 2\nEND\n" + let pdb_text = header + + "\nATOM 1 N ALA A 1 10.000 20.000 30.000 1.00 20.00 N \nATOM 2 N GLY A 2 12.000 22.000 32.000 1.00 20.00 N \nTER 3 GLY A 2\nEND\n" let records = @src.pdb_atom_parser(pdb_text) assert_eq(records.length(), 1) assert_eq(records[0].seq.to_string(), "AG") @@ -216,11 +217,7 @@ test "pdb_write_pdb_seqrecords_round_trip" { ///| test "pdb_write_pdb_seqrecords_basic" { - let record = @src.SeqRecord::new( - @src.Seq::new("AGVL"), - id="A", - name="A", - ) + let record = @src.SeqRecord::new(@src.Seq::new("AGVL"), id="A", name="A") let output = @src.write_pdb_seqrecords([record]) assert_true(output.contains("SEQRES")) assert_true(output.contains("ALA")) @@ -231,16 +228,8 @@ test "pdb_write_pdb_seqrecords_basic" { ///| test "pdb_write_pdb_seqrecords_multiple_records" { - let r1 = @src.SeqRecord::new( - @src.Seq::new("AG"), - id="A", - name="A", - ) - let r2 = @src.SeqRecord::new( - @src.Seq::new("VL"), - id="B", - name="B", - ) + let r1 = @src.SeqRecord::new(@src.Seq::new("AG"), id="A", name="A") + let r2 = @src.SeqRecord::new(@src.Seq::new("VL"), id="B", name="B") let output = @src.write_pdb_seqrecords([r1, r2]) assert_true(output.contains("SEQRES")) assert_true(output.contains("ALA")) @@ -257,11 +246,7 @@ test "pdb_write_pdb_seqrecords_empty" { ///| test "pdb_write_pdb_seqrecords_unknown_residue" { - let record = @src.SeqRecord::new( - @src.Seq::new("AXG"), - id="A", - name="A", - ) + let record = @src.SeqRecord::new(@src.Seq::new("AXG"), id="A", name="A") let output = @src.write_pdb_seqrecords([record]) assert_true(output.contains("SEQRES")) assert_true(output.contains("ALA")) diff --git a/test/moonbit/pdb_vectors_test.mbt b/test/moonbit/pdb_vectors_test.mbt index 1098bd27..4a5e894b 100644 --- a/test/moonbit/pdb_vectors_test.mbt +++ b/test/moonbit/pdb_vectors_test.mbt @@ -112,7 +112,7 @@ test "Vector3::dot" { test "Vector3::dot orthogonal" { let v1 = @src.Vector3::new(1.0, 0.0, 0.0) let v2 = @src.Vector3::new(0.0, 1.0, 0.0) - assert_true((v1.dot(v2)).abs() < 1.0e-10) + assert_true(v1.dot(v2).abs() < 1.0e-10) } ///| @@ -236,8 +236,8 @@ test "Vector3::project_to_vector" { let target = @src.Vector3::new(1.0, 0.0, 0.0) let proj = v.project_to_vector(target) assert_true((proj.get_x() - 1.0).abs() < 1.0e-10) - assert_true((proj.get_y()).abs() < 1.0e-10) - assert_true((proj.get_z()).abs() < 1.0e-10) + assert_true(proj.get_y().abs() < 1.0e-10) + assert_true(proj.get_z().abs() < 1.0e-10) } ///| @@ -247,7 +247,7 @@ test "Vector3::project_to_plane" { let proj = v.project_to_plane(normal) assert_true((proj.get_x() - 1.0).abs() < 1.0e-10) assert_true((proj.get_y() - 2.0).abs() < 1.0e-10) - assert_true((proj.get_z()).abs() < 1.0e-10) + assert_true(proj.get_z().abs() < 1.0e-10) } ///| @@ -263,9 +263,15 @@ test "RotationMatrix3::identity" { ///| test "RotationMatrix3::transpose" { let m = @src.RotationMatrix3::new( - m00=1.0, m01=2.0, m02=3.0, - m10=4.0, m11=5.0, m12=6.0, - m20=7.0, m21=8.0, m22=9.0, + m00=1.0, + m01=2.0, + m02=3.0, + m10=4.0, + m11=5.0, + m12=6.0, + m20=7.0, + m21=8.0, + m22=9.0, ) let t = m.transpose() assert_eq(t.get(0, 1), 4.0) @@ -277,9 +283,15 @@ test "RotationMatrix3::transpose" { ///| test "RotationMatrix3::multiply identity" { let m = @src.RotationMatrix3::new( - m00=1.0, m01=2.0, m02=3.0, - m10=4.0, m11=5.0, m12=6.0, - m20=7.0, m21=8.0, m22=9.0, + m00=1.0, + m01=2.0, + m02=3.0, + m10=4.0, + m11=5.0, + m12=6.0, + m20=7.0, + m21=8.0, + m22=9.0, ) let identity = @src.RotationMatrix3::identity() let result = m.multiply(identity) @@ -293,9 +305,9 @@ test "RotationMatrix3::transform" { let rot = @src.RotationMatrix3::rotation_z(@math.PI / 2.0) let v = @src.Vector3::new(1.0, 0.0, 0.0) let result = rot.transform(v) - assert_true((result.get_x()).abs() < 1.0e-10) + assert_true(result.get_x().abs() < 1.0e-10) assert_true((result.get_y() - 1.0).abs() < 1.0e-10) - assert_true((result.get_z()).abs() < 1.0e-10) + assert_true(result.get_z().abs() < 1.0e-10) } ///| @@ -303,8 +315,8 @@ test "RotationMatrix3::rotation_x" { let rot = @src.RotationMatrix3::rotation_x(@math.PI / 2.0) let v = @src.Vector3::new(0.0, 1.0, 0.0) let result = rot.transform(v) - assert_true((result.get_x()).abs() < 1.0e-10) - assert_true((result.get_y()).abs() < 1.0e-10) + assert_true(result.get_x().abs() < 1.0e-10) + assert_true(result.get_y().abs() < 1.0e-10) assert_true((result.get_z() - 1.0).abs() < 1.0e-10) } @@ -314,8 +326,8 @@ test "RotationMatrix3::rotation_y" { let v = @src.Vector3::new(0.0, 0.0, 1.0) let result = rot.transform(v) assert_true((result.get_x() - 1.0).abs() < 1.0e-10) - assert_true((result.get_y()).abs() < 1.0e-10) - assert_true((result.get_z()).abs() < 1.0e-10) + assert_true(result.get_y().abs() < 1.0e-10) + assert_true(result.get_z().abs() < 1.0e-10) } ///| @@ -323,9 +335,9 @@ test "RotationMatrix3::rotation_z" { let rot = @src.RotationMatrix3::rotation_z(@math.PI / 2.0) let v = @src.Vector3::new(1.0, 0.0, 0.0) let result = rot.transform(v) - assert_true((result.get_x()).abs() < 1.0e-10) + assert_true(result.get_x().abs() < 1.0e-10) assert_true((result.get_y() - 1.0).abs() < 1.0e-10) - assert_true((result.get_z()).abs() < 1.0e-10) + assert_true(result.get_z().abs() < 1.0e-10) } ///| @@ -334,9 +346,9 @@ test "RotationMatrix3::rotation_axis_angle" { let rot = @src.RotationMatrix3::rotation_axis_angle(axis, @math.PI / 2.0) let v = @src.Vector3::new(1.0, 0.0, 0.0) let result = rot.transform(v) - assert_true((result.get_x()).abs() < 1.0e-10) + assert_true(result.get_x().abs() < 1.0e-10) assert_true((result.get_y() - 1.0).abs() < 1.0e-10) - assert_true((result.get_z()).abs() < 1.0e-10) + assert_true(result.get_z().abs() < 1.0e-10) } ///| @@ -371,8 +383,8 @@ test "RotationMatrix3::inverse" { assert_true((product.get(0, 0) - 1.0).abs() < 1.0e-10) assert_true((product.get(1, 1) - 1.0).abs() < 1.0e-10) assert_true((product.get(2, 2) - 1.0).abs() < 1.0e-10) - assert_true((product.get(0, 1)).abs() < 1.0e-10) - assert_true((product.get(1, 0)).abs() < 1.0e-10) + assert_true(product.get(0, 1).abs() < 1.0e-10) + assert_true(product.get(1, 0).abs() < 1.0e-10) } ///| @@ -437,7 +449,7 @@ test "vector_rmsd identical" { @src.Vector3::new(4.0, 5.0, 6.0), ] let rmsd = @src.vector_rmsd(set_a, set_b) - assert_true((rmsd).abs() < 1.0e-10) + assert_true(rmsd.abs() < 1.0e-10) } ///| @@ -445,7 +457,7 @@ test "vector_rmsd empty" { let set_a : Array[@src.Vector3] = [] let set_b : Array[@src.Vector3] = [] let rmsd = @src.vector_rmsd(set_a, set_b) - assert_true((rmsd).abs() < 1.0e-10) + assert_true(rmsd.abs() < 1.0e-10) } ///| @@ -496,7 +508,7 @@ test "vector_apply_transform" { let trans = @src.Vector3::new(0.0, 0.0, 0.0) let result = @src.vector_apply_transform(vectors, rot, trans) assert_eq(result.length(), 1) - assert_true((result[0].get_x()).abs() < 1.0e-10) + assert_true(result[0].get_x().abs() < 1.0e-10) assert_true((result[0].get_y() - 1.0).abs() < 1.0e-10) } diff --git a/test/moonbit/peak_calling_test.mbt b/test/moonbit/peak_calling_test.mbt index 98c8d09a..3a637ec6 100644 --- a/test/moonbit/peak_calling_test.mbt +++ b/test/moonbit/peak_calling_test.mbt @@ -113,10 +113,7 @@ test "peak_calling_params_new_defaults_when_omitted" { ///| test "peak_calling_params_partial_overrides" { // Override only some args; others should default. - let params = @src.PeakCallingParams::new( - window_size=250, - fdr_threshold=0.01, - ) + let params = @src.PeakCallingParams::new(window_size=250, fdr_threshold=0.01) assert_eq(params.window_size, 250) assert_eq(params.step_size, 100) assert_eq(params.local_lambda_size, 10000) @@ -167,7 +164,9 @@ test "peak_calling_estimate_local_lambda_basic" { // Place 20 control reads uniformly in [0, 2000]. let mut i = 0 while i < 20 { - control.push(@src.ChipSeqRead::new(chr="chr1", position=i * 100, strand="+")) + control.push( + @src.ChipSeqRead::new(chr="chr1", position=i * 100, strand="+"), + ) i = i + 1 } // Window of 2000 bp centered at 1000 = [0, 2000) should have 20 reads. @@ -185,9 +184,7 @@ test "peak_calling_estimate_local_lambda_empty_control" { ///| test "peak_calling_estimate_local_lambda_off_chromosome" { - let control = [ - @src.ChipSeqRead::new(chr="chr1", position=500, strand="+"), - ] + let control = [@src.ChipSeqRead::new(chr="chr1", position=500, strand="+")] let rate = @src.estimate_local_lambda(control, "chr2", 500, 1000) assert_eq(rate, 0.0) } @@ -273,12 +270,24 @@ test "peak_calling_fold_enrichment_zero_observed_zero_expected" { test "peak_calling_merge_peaks_overlapping" { let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=2000, summit=1500, - read_count=20, control_count=2, fold_enrichment=10.0, p_value=1.0e-8, + chr="chr1", + start=1000, + end=2000, + summit=1500, + read_count=20, + control_count=2, + fold_enrichment=10.0, + p_value=1.0e-8, ), @src.CandidatePeak::new( - chr="chr1", start=1800, end=2500, summit=2000, - read_count=15, control_count=1, fold_enrichment=15.0, p_value=1.0e-7, + chr="chr1", + start=1800, + end=2500, + summit=2000, + read_count=15, + control_count=1, + fold_enrichment=15.0, + p_value=1.0e-7, ), ] let merged = @src.merge_peaks(peaks, 0) @@ -297,12 +306,24 @@ test "peak_calling_merge_peaks_overlapping" { test "peak_calling_merge_peaks_adjacent_within_gap" { let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=1500, summit=1250, - read_count=10, control_count=1, fold_enrichment=10.0, p_value=0.001, + chr="chr1", + start=1000, + end=1500, + summit=1250, + read_count=10, + control_count=1, + fold_enrichment=10.0, + p_value=0.001, ), @src.CandidatePeak::new( - chr="chr1", start=1700, end=2200, summit=2000, - read_count=12, control_count=2, fold_enrichment=6.0, p_value=0.0001, + chr="chr1", + start=1700, + end=2200, + summit=2000, + read_count=12, + control_count=2, + fold_enrichment=6.0, + p_value=0.0001, ), ] // Gap is 200bp; with max_gap=300, they should merge. @@ -318,12 +339,24 @@ test "peak_calling_merge_peaks_adjacent_within_gap" { test "peak_calling_merge_peaks_non_overlapping_different_chromosomes" { let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=2000, summit=1500, - read_count=20, control_count=2, fold_enrichment=10.0, p_value=1.0e-8, + chr="chr1", + start=1000, + end=2000, + summit=1500, + read_count=20, + control_count=2, + fold_enrichment=10.0, + p_value=1.0e-8, ), @src.CandidatePeak::new( - chr="chr2", start=1000, end=2000, summit=1500, - read_count=20, control_count=2, fold_enrichment=10.0, p_value=1.0e-8, + chr="chr2", + start=1000, + end=2000, + summit=1500, + read_count=20, + control_count=2, + fold_enrichment=10.0, + p_value=1.0e-8, ), ] let merged = @src.merge_peaks(peaks, 1000) @@ -334,12 +367,24 @@ test "peak_calling_merge_peaks_non_overlapping_different_chromosomes" { test "peak_calling_merge_peaks_far_apart" { let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=1500, summit=1250, - read_count=10, control_count=1, fold_enrichment=10.0, p_value=0.001, + chr="chr1", + start=1000, + end=1500, + summit=1250, + read_count=10, + control_count=1, + fold_enrichment=10.0, + p_value=0.001, ), @src.CandidatePeak::new( - chr="chr1", start=10000, end=10500, summit=10250, - read_count=10, control_count=1, fold_enrichment=10.0, p_value=0.001, + chr="chr1", + start=10000, + end=10500, + summit=10250, + read_count=10, + control_count=1, + fold_enrichment=10.0, + p_value=0.001, ), ] let merged = @src.merge_peaks(peaks, 100) @@ -357,8 +402,14 @@ test "peak_calling_merge_peaks_empty" { test "peak_calling_merge_peaks_single_peak" { let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=2000, summit=1500, - read_count=20, control_count=2, fold_enrichment=10.0, p_value=1.0e-8, + chr="chr1", + start=1000, + end=2000, + summit=1500, + read_count=20, + control_count=2, + fold_enrichment=10.0, + p_value=1.0e-8, ), ] let merged = @src.merge_peaks(peaks, 100) @@ -371,12 +422,24 @@ test "peak_calling_merge_peaks_unsorted_input" { // Input peaks in reverse order; merge_peaks should sort internally. let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=5000, end=5500, summit=5200, - read_count=15, control_count=1, fold_enrichment=15.0, p_value=1.0e-7, + chr="chr1", + start=5000, + end=5500, + summit=5200, + read_count=15, + control_count=1, + fold_enrichment=15.0, + p_value=1.0e-7, ), @src.CandidatePeak::new( - chr="chr1", start=1000, end=1500, summit=1250, - read_count=20, control_count=2, fold_enrichment=10.0, p_value=1.0e-8, + chr="chr1", + start=1000, + end=1500, + summit=1250, + read_count=20, + control_count=2, + fold_enrichment=10.0, + p_value=1.0e-8, ), ] let merged = @src.merge_peaks(peaks, 100) @@ -391,16 +454,34 @@ test "peak_calling_apply_fdr_marks_significant" { // Three peaks with very small p-values; all should be marked significant. let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=1500, summit=1250, - read_count=50, control_count=2, fold_enrichment=25.0, p_value=1.0e-10, + chr="chr1", + start=1000, + end=1500, + summit=1250, + read_count=50, + control_count=2, + fold_enrichment=25.0, + p_value=1.0e-10, ), @src.CandidatePeak::new( - chr="chr1", start=2000, end=2500, summit=2250, - read_count=40, control_count=2, fold_enrichment=20.0, p_value=1.0e-8, + chr="chr1", + start=2000, + end=2500, + summit=2250, + read_count=40, + control_count=2, + fold_enrichment=20.0, + p_value=1.0e-8, ), @src.CandidatePeak::new( - chr="chr1", start=3000, end=3500, summit=3250, - read_count=30, control_count=2, fold_enrichment=15.0, p_value=1.0e-6, + chr="chr1", + start=3000, + end=3500, + summit=3250, + read_count=30, + control_count=2, + fold_enrichment=15.0, + p_value=1.0e-6, ), ] let result = @src.apply_fdr(peaks, 0.05) @@ -415,12 +496,24 @@ test "peak_calling_apply_fdr_filters_large_pvalues" { // Mix of significant and non-significant peaks. let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=1500, summit=1250, - read_count=50, control_count=2, fold_enrichment=25.0, p_value=1.0e-10, + chr="chr1", + start=1000, + end=1500, + summit=1250, + read_count=50, + control_count=2, + fold_enrichment=25.0, + p_value=1.0e-10, ), @src.CandidatePeak::new( - chr="chr1", start=2000, end=2500, summit=2250, - read_count=5, control_count=2, fold_enrichment=2.5, p_value=0.4, + chr="chr1", + start=2000, + end=2500, + summit=2250, + read_count=5, + control_count=2, + fold_enrichment=2.5, + p_value=0.4, ), ] let result = @src.apply_fdr(peaks, 0.05) @@ -468,7 +561,13 @@ test "peak_calling_apply_fdr_monotonic" { pairs.push((p.p_value, p.fdr)) } pairs.sort_by(fn(a : (Double, Double), b : (Double, Double)) -> Int { - if a.0 < b.0 { -1 } else if a.0 > b.0 { 1 } else { 0 } + if a.0 < b.0 { + -1 + } else if a.0 > b.0 { + 1 + } else { + 0 + } }) // Adjusted p-values should be non-decreasing with rank. let mut k = 0 @@ -487,16 +586,34 @@ test "peak_calling_filter_peaks_thresholds" { ) let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=1500, summit=1250, - read_count=50, control_count=2, fold_enrichment=25.0, p_value=1.0e-10, + chr="chr1", + start=1000, + end=1500, + summit=1250, + read_count=50, + control_count=2, + fold_enrichment=25.0, + p_value=1.0e-10, ), @src.CandidatePeak::new( - chr="chr1", start=2000, end=2500, summit=2250, - read_count=5, control_count=2, fold_enrichment=2.5, p_value=1.0e-3, + chr="chr1", + start=2000, + end=2500, + summit=2250, + read_count=5, + control_count=2, + fold_enrichment=2.5, + p_value=1.0e-3, ), @src.CandidatePeak::new( - chr="chr1", start=3000, end=3500, summit=3250, - read_count=3, control_count=2, fold_enrichment=1.5, p_value=1.0e-10, + chr="chr1", + start=3000, + end=3500, + summit=3250, + read_count=3, + control_count=2, + fold_enrichment=1.5, + p_value=1.0e-10, ), ] // Set FDR and significant flags first. @@ -603,9 +720,7 @@ test "peak_calling_no_control" { ///| test "peak_calling_single_read" { - let treatment = [ - @src.ChipSeqRead::new(chr="chr1", position=1000, strand="+"), - ] + let treatment = [@src.ChipSeqRead::new(chr="chr1", position=1000, strand="+")] let control : Array[@src.ChipSeqRead] = [] let params = @src.PeakCallingParams::default() let peaks = @src.call_peaks(treatment, control, params) @@ -654,12 +769,24 @@ test "peak_calling_summary_empty" { test "peak_calling_summary_with_peaks" { let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=2000, summit=1500, - read_count=42, control_count=5, fold_enrichment=8.4, p_value=1.0e-10, + chr="chr1", + start=1000, + end=2000, + summit=1500, + read_count=42, + control_count=5, + fold_enrichment=8.4, + p_value=1.0e-10, ), @src.CandidatePeak::new( - chr="chr1", start=3000, end=4000, summit=3500, - read_count=20, control_count=2, fold_enrichment=10.0, p_value=1.0e-8, + chr="chr1", + start=3000, + end=4000, + summit=3500, + read_count=20, + control_count=2, + fold_enrichment=10.0, + p_value=1.0e-8, ), ] let with_fdr = @src.apply_fdr(peaks, 0.05) @@ -673,12 +800,24 @@ test "peak_calling_summary_with_peaks" { test "peak_calling_summary_includes_significant_count" { let peaks = [ @src.CandidatePeak::new( - chr="chr1", start=1000, end=2000, summit=1500, - read_count=42, control_count=5, fold_enrichment=8.4, p_value=1.0e-10, + chr="chr1", + start=1000, + end=2000, + summit=1500, + read_count=42, + control_count=5, + fold_enrichment=8.4, + p_value=1.0e-10, ), @src.CandidatePeak::new( - chr="chr1", start=3000, end=4000, summit=3500, - read_count=2, control_count=2, fold_enrichment=1.0, p_value=0.5, + chr="chr1", + start=3000, + end=4000, + summit=3500, + read_count=2, + control_count=2, + fold_enrichment=1.0, + p_value=0.5, ), ] let with_fdr = @src.apply_fdr(peaks, 0.05) diff --git a/test/moonbit/phd_test.mbt b/test/moonbit/phd_test.mbt index 4104e7a5..e122a2b0 100644 --- a/test/moonbit/phd_test.mbt +++ b/test/moonbit/phd_test.mbt @@ -12,10 +12,10 @@ test "phd_base_creation" { assert_eq(b.peak_position(), 1) } +///| test "phd_comment_creation" { let c = @src.PhdComment::new( - "read.ab1", "0.020425.c", "/etc/phred.dat", - 0, 1000, 0, 10, 0.05, "term", "big", + "read.ab1", "0.020425.c", "/etc/phred.dat", 0, 1000, 0, 10, 0.05, "term", "big", ) assert_eq(c.chromat_file(), "read.ab1") assert_eq(c.phred_version(), "0.020425.c") @@ -29,6 +29,7 @@ test "phd_comment_creation" { assert_eq(c.dye(), "big") } +///| test "phd_read_creation_and_sequence" { let bases = [ @src.PhdBase::new("A", 35, 1), @@ -36,8 +37,7 @@ test "phd_read_creation_and_sequence" { @src.PhdBase::new("G", 45, 3), ] let comment = @src.PhdComment::new( - "read.ab1", "0.020425.c", "/etc/phred.dat", - 0, 1000, 0, 3, 0.05, "term", "big", + "read.ab1", "0.020425.c", "/etc/phred.dat", 0, 1000, 0, 3, 0.05, "term", "big", ) let read = @src.PhdRead::new("test_read", bases, comment) assert_eq(read.name(), "test_read") @@ -47,16 +47,16 @@ test "phd_read_creation_and_sequence" { assert_eq(read.peak_positions(), [1, 2, 3]) } +///| test "phd_read_empty_sequence" { - let comment = @src.PhdComment::new( - "", "", "", 0, 0, 0, 0, 0.0, "", "", - ) + let comment = @src.PhdComment::new("", "", "", 0, 0, 0, 0, 0.0, "", "") let read = @src.PhdRead::new("empty", [], comment) assert_eq(read.length(), 0) assert_eq(read.sequence(), "") assert_eq(read.quality().length(), 0) } +///| test "phd_file_creation" { let comment = @src.PhdComment::new( "read.ab1", "0.020425.c", "", 0, 0, 0, 0, 0.0, "", "", @@ -74,12 +74,14 @@ test "phd_file_creation" { // Sample data // --------------------------------------------------------------------------- +///| test "phd_sample_text_has_begin_sequence" { let text = @src.phd_sample_text() assert_true(text.contains("BEGIN_SEQUENCE")) assert_true(text.contains("END_SEQUENCE")) } +///| test "phd_sample_text_has_comment_block" { let text = @src.phd_sample_text() assert_true(text.contains("BEGIN_COMMENT")) @@ -88,6 +90,7 @@ test "phd_sample_text_has_comment_block" { assert_true(text.contains("PHRED_VERSION")) } +///| test "phd_sample_text_has_dna_block" { let text = @src.phd_sample_text() assert_true(text.contains("BEGIN_DNA")) @@ -98,6 +101,7 @@ test "phd_sample_text_has_dna_block" { // Parsing // --------------------------------------------------------------------------- +///| test "phd_parse_single_read" { let text = @src.phd_sample_text() let file = @src.phd_parse(text) @@ -108,6 +112,7 @@ test "phd_parse_single_read" { assert_eq(read.sequence(), "ACGTACGTAC") } +///| test "phd_parse_comment_fields" { let text = @src.phd_sample_text() let file = @src.phd_parse(text) @@ -123,6 +128,7 @@ test "phd_parse_comment_fields" { assert_eq(c.dye(), "big") } +///| test "phd_parse_quality_scores" { let text = @src.phd_sample_text() let file = @src.phd_parse(text) @@ -134,6 +140,7 @@ test "phd_parse_quality_scores" { assert_eq(quals[9], 44) } +///| test "phd_parse_peak_positions" { let text = @src.phd_sample_text() let file = @src.phd_parse(text) @@ -144,17 +151,20 @@ test "phd_parse_peak_positions" { assert_eq(peaks[9], 10) } +///| test "phd_parse_multiple_reads" { let text = @src.phd_sample_text() + "\n" + @src.phd_sample_text() let file = @src.phd_parse(text) assert_eq(file.num_reads(), 2) } +///| test "phd_parse_empty_input" { let file = @src.phd_parse("") assert_eq(file.num_reads(), 0) } +///| test "phd_parse_minimal_phd" { let text = "BEGIN_SEQUENCE r1\nBEGIN_DNA\nA 10 1\nT 20 2\nEND_DNA\nEND_SEQUENCE\n" let file = @src.phd_parse(text) @@ -166,6 +176,7 @@ test "phd_parse_minimal_phd" { assert_eq(read.quality(), [10, 20]) } +///| test "phd_parse_no_dna_block" { let text = "BEGIN_SEQUENCE r1\nBEGIN_COMMENT\nCHROMAT_FILE: r.ab1\nEND_COMMENT\nEND_SEQUENCE\n" let file = @src.phd_parse(text) @@ -176,6 +187,7 @@ test "phd_parse_no_dna_block" { assert_eq(read.comment().chromat_file(), "r.ab1") } +///| test "phd_parse_trim_values" { let text = "BEGIN_SEQUENCE r1\nBEGIN_COMMENT\nTRIM: 5 50 0.02\nEND_COMMENT\nBEGIN_DNA\nA 10 1\nEND_DNA\nEND_SEQUENCE\n" let file = @src.phd_parse(text) @@ -188,6 +200,7 @@ test "phd_parse_trim_values" { // Formatting // --------------------------------------------------------------------------- +///| test "phd_read_to_string" { let text = @src.phd_sample_text() let file = @src.phd_parse(text) @@ -198,6 +211,7 @@ test "phd_read_to_string" { assert_true(s.contains("ACGTACGTAC")) } +///| test "phd_file_to_string" { let text = @src.phd_sample_text() let file = @src.phd_parse(text) diff --git a/test/moonbit/pheatmap_test.mbt b/test/moonbit/pheatmap_test.mbt index 62a0a8fc..a5262199 100644 --- a/test/moonbit/pheatmap_test.mbt +++ b/test/moonbit/pheatmap_test.mbt @@ -3,16 +3,10 @@ ///| test "pheatmap_create_input" { - let mat = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - [7.0, 8.0, 9.0], - ] - let input = @src.pheatmap_input( - mat, - ["row1", "row2", "row3"], - ["col1", "col2", "col3"], - ) + let mat = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] + let input = @src.pheatmap_input(mat, ["row1", "row2", "row3"], [ + "col1", "col2", "col3", + ]) assert_eq(input.mat.length(), 3) assert_eq(input.row_names.length(), 3) assert_eq(input.col_names.length(), 3) @@ -20,11 +14,11 @@ test "pheatmap_create_input" { ///| test "pheatmap_distance_euclidean" { - let data = [ - [1.0, 0.0], - [0.0, 0.0], - ] - let dist = @src.pheatmap_distance_matrix(data, @src.distance_method_euclidean()) + let data = [[1.0, 0.0], [0.0, 0.0]] + let dist = @src.pheatmap_distance_matrix( + data, + @src.distance_method_euclidean(), + ) assert_eq(dist.length(), 2) assert_eq(dist[0][0], 0.0) assert_eq(dist[1][1], 0.0) @@ -33,23 +27,22 @@ test "pheatmap_distance_euclidean" { ///| test "pheatmap_distance_manhattan" { - let data = [ - [1.0, 2.0], - [4.0, 6.0], - ] - let dist = @src.pheatmap_distance_matrix(data, @src.distance_method_manhattan()) + let data = [[1.0, 2.0], [4.0, 6.0]] + let dist = @src.pheatmap_distance_matrix( + data, + @src.distance_method_manhattan(), + ) assert_eq(dist.length(), 2) assert_eq(dist[0][1], 7.0) } ///| test "pheatmap_distance_symmetry" { - let data = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - [7.0, 8.0, 9.0], - ] - let dist = @src.pheatmap_distance_matrix(data, @src.distance_method_euclidean()) + let data = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] + let dist = @src.pheatmap_distance_matrix( + data, + @src.distance_method_euclidean(), + ) let n = dist.length() let mut i = 0 while i < n { @@ -64,26 +57,18 @@ test "pheatmap_distance_symmetry" { ///| test "pheatmap_column_distance" { - let data = [ - [1.0, 0.0, 1.0], - [0.0, 1.0, 0.0], - ] - let dist = @src.pheatmap_column_distance_matrix(data, @src.distance_method_euclidean()) + let data = [[1.0, 0.0, 1.0], [0.0, 1.0, 0.0]] + let dist = @src.pheatmap_column_distance_matrix( + data, + @src.distance_method_euclidean(), + ) assert_eq(dist.length(), 3) } ///| test "pheatmap_render_basic" { - let mat = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - [7.0, 8.0, 9.0], - ] - let input = @src.pheatmap_input( - mat, - ["r1", "r2", "r3"], - ["c1", "c2", "c3"], - ) + let mat = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] + let input = @src.pheatmap_input(mat, ["r1", "r2", "r3"], ["c1", "c2", "c3"]) let result = @src.pheatmap_render(input) assert_eq(result.row_order.length(), 3) assert_eq(result.col_order.length(), 3) @@ -108,11 +93,7 @@ test "pheatmap_set_fontsize" { ///| test "pheatmap_cutree_rows" { - let mat = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - [7.0, 8.0, 9.0], - ] + let mat = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let input = @src.pheatmap_input(mat, ["r1", "r2", "r3"], ["c1", "c2", "c3"]) let cut = @src.pheatmap_set_cutree(input, 2, 1) assert_eq(cut.cutree_rows, 2) @@ -120,10 +101,7 @@ test "pheatmap_cutree_rows" { ///| test "pheatmap_no_clustering" { - let mat = [ - [1.0, 2.0], - [3.0, 4.0], - ] + let mat = [[1.0, 2.0], [3.0, 4.0]] let input = @src.pheatmap_input(mat, ["r1", "r2"], ["c1", "c2"]) let unclustered = @src.pheatmap_set_cluster(input, false, false) assert_eq(unclustered.cluster_rows, false) diff --git a/test/moonbit/phylo_cdao_test.mbt b/test/moonbit/phylo_cdao_test.mbt index 75a7675a..50ad3a81 100644 --- a/test/moonbit/phylo_cdao_test.mbt +++ b/test/moonbit/phylo_cdao_test.mbt @@ -30,7 +30,12 @@ test "cdao_rdfs_namespace_constant" { ///| test "cdao_tree_construction" { - let t = @src.Cdaotree::new("#tree1", rooted=true, root_node_id="#node1", name=Some("MyTree")) + let t = @src.Cdaotree::new( + "#tree1", + rooted=true, + root_node_id="#node1", + name=Some("MyTree"), + ) assert_eq(t.id, "#tree1") assert_eq(t.rooted, true) assert_eq(t.root_node_id, "#node1") @@ -48,7 +53,11 @@ test "cdao_tree_default_values" { ///| test "cdao_node_construction" { - let n = @src.CdaoNode::new("#node1", children=["#node2", "#node3"], parent_id=Some("#node0")) + let n = @src.CdaoNode::new( + "#node1", + children=["#node2", "#node3"], + parent_id=Some("#node0"), + ) assert_eq(n.id, "#node1") assert_eq(n.children.length(), 2) assert_eq(n.parent_id.unwrap(), "#node0") @@ -337,7 +346,13 @@ test "cdao_to_trees_empty_document" { ///| test "cdao_node_fields_via_constructor" { - let n = @src.CdaoNode::new("#test", parent_id=Some("#parent"), tu_id=Some("#tu1"), branch_length=Some(2.5), label=Some("TestNode")) + let n = @src.CdaoNode::new( + "#test", + parent_id=Some("#parent"), + tu_id=Some("#tu1"), + branch_length=Some(2.5), + label=Some("TestNode"), + ) assert_eq(n.parent_id.unwrap(), "#parent") assert_eq(n.tu_id.unwrap(), "#tu1") assert_eq(n.branch_length.unwrap(), 2.5) diff --git a/test/moonbit/phylo_consensus_test.mbt b/test/moonbit/phylo_consensus_test.mbt index aa43e3d0..4cde5775 100644 --- a/test/moonbit/phylo_consensus_test.mbt +++ b/test/moonbit/phylo_consensus_test.mbt @@ -1,12 +1,12 @@ ///| /// Phylo.Consensus module tests - test "ConsensusNode::new" { let node = @src.ConsensusNode::new("A", false) assert_eq(node.name, "A") assert_true(node.is_leaf()) } +///| test "ConsensusNode::add_child" { let parent = @src.ConsensusNode::new("internal", true) let child = @src.ConsensusNode::new("A", false) @@ -14,6 +14,7 @@ test "ConsensusNode::add_child" { assert_eq(parent_with_child.children.length(), 1) } +///| test "ConsensusNode::get_leaves" { let root = @src.ConsensusNode::new("root", true) let child1 = @src.ConsensusNode::new("A", false) @@ -24,6 +25,7 @@ test "ConsensusNode::get_leaves" { assert_eq(leaves.length(), 2) } +///| test "parse_newick" { let newick = "((A,B),(C,D));" match @src.parse_consensus_newick(newick) { @@ -32,6 +34,7 @@ test "parse_newick" { } } +///| test "newick_to_tree" { let tree = @src.newick_to_tree("((A,B),(C,D));") match tree.root { @@ -40,12 +43,14 @@ test "newick_to_tree" { } } +///| test "ConsensusTree::to_newick" { let tree = @src.newick_to_tree("((A,B),(C,D));") let newick = tree.to_newick() assert_true(newick.length() > 0) } +///| test "build_majority_consensus" { let trees = @src.create_example_trees() let consensus = @src.build_majority_consensus(trees) @@ -55,6 +60,7 @@ test "build_majority_consensus" { } } +///| test "build_strict_consensus" { let trees = @src.create_example_trees() let consensus = @src.build_strict_consensus(trees) @@ -64,6 +70,7 @@ test "build_strict_consensus" { } } +///| test "get_all_splits" { let tree = @src.newick_to_tree("((A,B),(C,D));") match tree.root { @@ -76,6 +83,7 @@ test "get_all_splits" { } } +///| test "Split::normalize" { let split = @src.Split::new(["B", "A"]) let normalized = split.normalize() @@ -83,12 +91,14 @@ test "Split::normalize" { assert_eq(normalized.taxa[1], "B") } +///| test "Split::hash" { let split = @src.Split::new(["A", "B"]) let h = split.hash() assert_eq(h, "A,B") } +///| test "calculate_consensus_support" { let trees = @src.create_example_trees() let split = @src.Split::new(["A", "B"]) @@ -96,17 +106,20 @@ test "calculate_consensus_support" { assert_true(support >= 0.0 && support <= 1.0) } +///| test "get_all_splits_from_trees" { let trees = @src.create_example_trees() let splits = @src.get_all_splits_from_trees(trees) assert_true(splits.length() > 0) } +///| test "create_example_trees" { let trees = @src.create_example_trees() assert_eq(trees.length(), 5) } +///| test "create_simple_tree" { let tree = @src.create_simple_tree() match tree.root { @@ -115,6 +128,7 @@ test "create_simple_tree" { } } +///| test "build_consensus_empty" { let trees : Array[@src.ConsensusTree] = Array::new() let consensus = @src.build_consensus(trees, 0.5) @@ -122,4 +136,4 @@ test "build_consensus_empty" { Some(_) => assert_true(false) None => () } -} \ No newline at end of file +} diff --git a/test/moonbit/phylo_nexml_test.mbt b/test/moonbit/phylo_nexml_test.mbt index 939fc769..f80de22c 100644 --- a/test/moonbit/phylo_nexml_test.mbt +++ b/test/moonbit/phylo_nexml_test.mbt @@ -57,12 +57,7 @@ test "nexml_tree_creation" { let nodes : Array[@src.NeXMLNode] = [] let edges : Array[@src.NeXMLEdge] = [] let tree = @src.NeXMLTree::new( - "tree1", - "Test Tree", - "FloatTree", - true, - nodes, - edges, + "tree1", "Test Tree", "FloatTree", true, nodes, edges, ) assert_eq(tree.id, "tree1") assert_eq(tree.name, "Test Tree") diff --git a/test/moonbit/phylo_xml_debug_test.mbt b/test/moonbit/phylo_xml_debug_test.mbt index e61d6834..888fa40a 100644 --- a/test/moonbit/phylo_xml_debug_test.mbt +++ b/test/moonbit/phylo_xml_debug_test.mbt @@ -55,8 +55,7 @@ test "debug_parse_tree" { ///| test "debug_multiple_trees" { - let xml = - "\n" + + let xml = "\n" + "\n" + " \n" + " Tree 1\n" + diff --git a/test/moonbit/phylo_xml_test.mbt b/test/moonbit/phylo_xml_test.mbt index f9fdd9c5..83d775d6 100644 --- a/test/moonbit/phylo_xml_test.mbt +++ b/test/moonbit/phylo_xml_test.mbt @@ -1,7 +1,6 @@ ///| test "phyloxml_parse_simple_tree" { - let xml = - "\n" + + let xml = "\n" + " \n" + " Simple Tree\n" + " \n" + @@ -21,8 +20,7 @@ test "phyloxml_parse_simple_tree" { ///| test "phyloxml_parse_branch_lengths" { - let xml = - "\n" + + let xml = "\n" + " \n" + " \n" + " 0.5\n" + @@ -43,8 +41,7 @@ test "phyloxml_parse_branch_lengths" { ///| test "phyloxml_parse_taxon_annotations" { - let xml = - "\n" + + let xml = "\n" + " \n" + " \n" + " Root\n" + @@ -65,8 +62,7 @@ test "phyloxml_parse_taxon_annotations" { ///| test "phyloxml_parse_sequence_annotations" { - let xml = - "\n" + + let xml = "\n" + " \n" + " \n" + " Root\n" + @@ -87,8 +83,7 @@ test "phyloxml_parse_sequence_annotations" { ///| test "phyloxml_xml_roundtrip" { - let xml = - "\n" + + let xml = "\n" + "\n" + " \n" + " Test Tree\n" + @@ -153,8 +148,7 @@ test "phyloxml_newick_simple" { ///| test "phyloxml_to_newick" { - let xml = - "\n" + + let xml = "\n" + "\n" + " \n" + " \n" + @@ -188,11 +182,9 @@ test "phyloxml_node_to_newick_leaf" { test "phyloxml_node_to_newick_internal" { let child1 = @src.PhyloXMLNode::new(name="A", branch_length=0.1) let child2 = @src.PhyloXMLNode::new(name="B", branch_length=0.2) - let node = @src.PhyloXMLNode::new( - name="Root", - branch_length=0.5, - children=[child1, child2], - ) + let node = @src.PhyloXMLNode::new(name="Root", branch_length=0.5, children=[ + child1, child2, + ]) let newick = @src.phyloxml_node_to_newick(node) assert_true(newick.contains("(")) assert_true(newick.contains("A")) @@ -216,10 +208,7 @@ test "phyloxml_get_tree_names" { test "phyloxml_get_all_tips" { let leaf1 = @src.PhyloXMLNode::new(name="A") let leaf2 = @src.PhyloXMLNode::new(name="B") - let internal = @src.PhyloXMLNode::new( - name="Root", - children=[leaf1, leaf2], - ) + let internal = @src.PhyloXMLNode::new(name="Root", children=[leaf1, leaf2]) let tree = @src.PhyloXMLTree::new(root=internal) let tips = @src.get_all_tips(tree) assert_eq(tips.length(), 2) @@ -234,7 +223,7 @@ test "phyloxml_get_all_tips_deep" { let leaf3 = @src.PhyloXMLNode::new(name="C") let child1 = @src.PhyloXMLNode::new(name="X", children=[leaf1, leaf2]) let root = @src.PhyloXMLNode::new(name="Root", children=[child1, leaf3]) - let tree = @src.PhyloXMLTree::new(root=root) + let tree = @src.PhyloXMLTree::new(root~) let tips = @src.get_all_tips(tree) assert_eq(tips.length(), 3) } @@ -243,19 +232,15 @@ test "phyloxml_get_all_tips_deep" { test "phyloxml_node_count" { let leaf1 = @src.PhyloXMLNode::new(name="A") let leaf2 = @src.PhyloXMLNode::new(name="B") - let root = @src.PhyloXMLNode::new( - name="Root", - children=[leaf1, leaf2], - ) - let tree = @src.PhyloXMLTree::new(root=root) + let root = @src.PhyloXMLNode::new(name="Root", children=[leaf1, leaf2]) + let tree = @src.PhyloXMLTree::new(root~) let count = @src.phyloxml_get_node_count(tree) assert_eq(count, 3) } ///| test "phyloxml_multiple_trees" { - let xml = - "\n" + + let xml = "\n" + "\n" + " \n" + " Tree 1\n" + @@ -350,10 +335,7 @@ test "phyloxml_node_creation" { test "phyloxml_node_with_children" { let child1 = @src.PhyloXMLNode::new(name="C1") let child2 = @src.PhyloXMLNode::new(name="C2") - let node = @src.PhyloXMLNode::new( - name="Parent", - children=[child1, child2], - ) + let node = @src.PhyloXMLNode::new(name="Parent", children=[child1, child2]) assert_false(node.is_leaf) assert_eq(node.children.length(), 2) assert_eq(node.children[0].name, "C1") @@ -367,7 +349,7 @@ test "phyloxml_tree_creation" { tree_id="t1", name="Test Tree", description="A test tree", - root=root, + root~, ) assert_eq(tree.tree_id, "t1") assert_eq(tree.name, "Test Tree") @@ -379,10 +361,7 @@ test "phyloxml_tree_creation" { test "phyloxml_tree_with_metadata" { let meta : Map[String, String] = Map([], capacity=2) meta["rooted"] = "true" - let tree = @src.PhyloXMLTree::new( - name="Rooted Tree", - phylogeny_metadata=meta, - ) + let tree = @src.PhyloXMLTree::new(name="Rooted Tree", phylogeny_metadata=meta) assert_eq(tree.phylogeny_metadata["rooted"], "true") } @@ -404,8 +383,7 @@ test "phyloxml_get_element_text" { ///| test "phyloxml_parse_node_element" { - let xml = - "\n" + + let xml = "\n" + " TestNode\n" + " 0.5\n" + " \n" + @@ -419,8 +397,7 @@ test "phyloxml_parse_node_element" { ///| test "phyloxml_parse_taxon_element" { - let xml = - "\n" + + let xml = "\n" + " tx1\n" + " Homo sapiens\n" + " Human\n" + @@ -432,8 +409,7 @@ test "phyloxml_parse_taxon_element" { ///| test "phyloxml_parse_sequence_element" { - let xml = - "\n" + + let xml = "\n" + " seq1\n" + " DNA\n" + " ATG\n" + @@ -448,20 +424,16 @@ test "phyloxml_complex_tree_serialization" { let leaf_a = @src.PhyloXMLNode::new(name="A", branch_length=0.1) let leaf_b = @src.PhyloXMLNode::new(name="B", branch_length=0.2) let leaf_c = @src.PhyloXMLNode::new(name="C", branch_length=0.3) - let internal = @src.PhyloXMLNode::new( - name="Int", - branch_length=0.5, - children=[leaf_a, leaf_b], - ) - let root = @src.PhyloXMLNode::new( - name="Root", - branch_length=0.0, - children=[internal, leaf_c], - ) + let internal = @src.PhyloXMLNode::new(name="Int", branch_length=0.5, children=[ + leaf_a, leaf_b, + ]) + let root = @src.PhyloXMLNode::new(name="Root", branch_length=0.0, children=[ + internal, leaf_c, + ]) let tree = @src.PhyloXMLTree::new( tree_id="complex", name="Complex Tree", - root=root, + root~, ) let result = @src.PhyloXMLResult::new(trees=[tree]) let xml = @src.phyloxml_to_xml(result) @@ -527,8 +499,7 @@ test "phyloxml_indent_xml" { ///| test "phyloxml_find_all_elements" { - let xml = - "\n" + + let xml = "\n" + " 1\n" + " 2\n" + " 3\n" + @@ -539,18 +510,14 @@ test "phyloxml_find_all_elements" { ///| test "phyloxml_taxon_namespace" { - let ns = @src.TaxonNamespace::new( - namespace_id="ns1", - name="Test NS", - ) + let ns = @src.TaxonNamespace::new(namespace_id="ns1", name="Test NS") assert_eq(ns.namespace_id, "ns1") assert_eq(ns.name, "Test NS") } ///| test "phyloxml_with_taxon_namespace" { - let xml = - "\n" + + let xml = "\n" + "\n" + " \n" + " ns1\n" + @@ -568,4 +535,4 @@ test "phyloxml_with_taxon_namespace" { assert_eq(result.taxon_namespaces.length(), 1) assert_true(result.taxon_namespaces[0].namespace_id.length() >= 0) assert_true(result.taxon_namespaces[0].name.length() >= 0) -} \ No newline at end of file +} diff --git a/test/moonbit/phyloseq_test.mbt b/test/moonbit/phyloseq_test.mbt index 36268d91..085e8ed1 100644 --- a/test/moonbit/phyloseq_test.mbt +++ b/test/moonbit/phyloseq_test.mbt @@ -1,32 +1,35 @@ ///| /// Tests for phyloseq module. - test "phyloseq creation" { let ps = @src.create_example_phyloseq() assert_eq(@src.ps_num_otus(ps), 3) assert_eq(@src.ps_num_samples(ps), 3) } +///| test "phyloseq total abundance" { let ps = @src.create_example_phyloseq() let total = @src.ps_total_abundance(ps) assert_eq(total, 975.0) } +///| test "phyloseq filter by abundance" { let ps = @src.create_example_phyloseq() let filtered = @src.ps_filter_by_abundance(ps, 300.0) assert_eq(@src.ps_num_otus(filtered), 2) } +///| test "phyloseq filter by taxonomy" { let ps = @src.create_example_phyloseq() let filtered = @src.ps_filter_by_taxonomy(ps, "phylum", "Proteobacteria") assert_eq(@src.ps_num_otus(filtered), 1) } +///| test "phyloseq taxa summary" { let ps = @src.create_example_phyloseq() let summary = @src.ps_get_taxa_summary(ps, "phylum") assert_true(summary.contains("Proteobacteria")) -} \ No newline at end of file +} diff --git a/test/moonbit/plyranges_test.mbt b/test/moonbit/plyranges_test.mbt index 55efa9d7..d9f6b448 100644 --- a/test/moonbit/plyranges_test.mbt +++ b/test/moonbit/plyranges_test.mbt @@ -52,12 +52,9 @@ test "plyranges_filter_strand" { ///| test "plyranges_mutate" { - let ranges = @src.tgr_create( - ["chr1", "chr2"], - [100, 200], - [200, 300], - ["+", "-"], - ) + let ranges = @src.tgr_create(["chr1", "chr2"], [100, 200], [200, 300], [ + "+", "-", + ]) let mutated = @src.tgr_mutate(ranges, "gc_content", [0.45, 0.62]) assert_eq(mutated.metadata["gc_content"].length(), 2) assert_eq(mutated.metadata["gc_content"][0], 0.45) @@ -65,12 +62,9 @@ test "plyranges_mutate" { ///| test "plyranges_mutate_str" { - let ranges = @src.tgr_create( - ["chr1", "chr2"], - [100, 200], - [200, 300], - ["+", "-"], - ) + let ranges = @src.tgr_create(["chr1", "chr2"], [100, 200], [200, 300], [ + "+", "-", + ]) let mutated = @src.tgr_mutate_str(ranges, "gene_name", ["BRCA1", "TP53"]) assert_eq(mutated.metadata_str["gene_name"].length(), 2) assert_eq(mutated.metadata_str["gene_name"][0], "BRCA1") @@ -78,12 +72,9 @@ test "plyranges_mutate_str" { ///| test "plyranges_select" { - let ranges = @src.tgr_create( - ["chr1", "chr2"], - [100, 200], - [200, 300], - ["+", "-"], - ) + let ranges = @src.tgr_create(["chr1", "chr2"], [100, 200], [200, 300], [ + "+", "-", + ]) let mutated = @src.tgr_mutate(ranges, "score", [1.0, 2.0]) let selected = @src.tgr_select(mutated, ["score"]) assert_eq(selected.metadata["score"].length(), 2) @@ -106,12 +97,9 @@ test "plyranges_arrange" { ///| test "plyranges_rename" { - let ranges = @src.tgr_create( - ["chr1", "chr2"], - [100, 200], - [200, 300], - ["+", "-"], - ) + let ranges = @src.tgr_create(["chr1", "chr2"], [100, 200], [200, 300], [ + "+", "-", + ]) let mutated = @src.tgr_mutate(ranges, "score", [1.0, 2.0]) let renamed = @src.tgr_rename(mutated, "score", "alignment_score") assert_eq(renamed.metadata["alignment_score"].length(), 2) @@ -119,12 +107,9 @@ test "plyranges_rename" { ///| test "plyranges_width" { - let ranges = @src.tgr_create( - ["chr1", "chr2"], - [100, 200], - [200, 350], - ["+", "-"], - ) + let ranges = @src.tgr_create(["chr1", "chr2"], [100, 200], [200, 350], [ + "+", "-", + ]) assert_eq(ranges.widths[0], 101) assert_eq(ranges.widths[1], 151) } @@ -162,12 +147,9 @@ test "plyranges_filter_end" { ///| test "plyranges_multiple_metadata" { - let ranges = @src.tgr_create( - ["chr1", "chr2"], - [100, 200], - [200, 300], - ["+", "-"], - ) + let ranges = @src.tgr_create(["chr1", "chr2"], [100, 200], [200, 300], [ + "+", "-", + ]) let mutated = @src.tgr_mutate(ranges, "score", [1.5, 2.5]) let mutated2 = @src.tgr_mutate(mutated, "p_value", [0.01, 0.05]) assert_eq(mutated2.metadata.length(), 2) diff --git a/test/moonbit/polypeptide_test.mbt b/test/moonbit/polypeptide_test.mbt index c52eb22c..2bf79b7f 100644 --- a/test/moonbit/polypeptide_test.mbt +++ b/test/moonbit/polypeptide_test.mbt @@ -23,7 +23,9 @@ test "polypeptide_calculate_hydrophobicity" { ///| test "polypeptide_calculate_hydrophobicity_window" { let sequence = "MKLILVLLVSLSL" - let profile = @src.calculate_hydrophobicity_window(sequence, 5, "kyte-doolittle") + let profile = @src.calculate_hydrophobicity_window( + sequence, 5, "kyte-doolittle", + ) assert_eq(profile.values.length(), sequence.length()) } @@ -55,4 +57,4 @@ test "polypeptide_create_example_data" { assert_eq(seq.length() > 0, true) assert_eq(comp.total_residues > 0, true) assert_eq(prof.values.length() > 0, true) -} \ No newline at end of file +} diff --git a/test/moonbit/popgen_advanced_test.mbt b/test/moonbit/popgen_advanced_test.mbt index e0a6ec2a..aaac1792 100644 --- a/test/moonbit/popgen_advanced_test.mbt +++ b/test/moonbit/popgen_advanced_test.mbt @@ -58,7 +58,15 @@ test "watterson_theta_small_sample" { test "watterson_a1" { let a1 = @src.watterson_a1(10) // a1 = sum(1/i) for i=1..9 = 1 + 1/2 + 1/3 + ... + 1/9 - let expected = 1.0 + 0.5 + 0.3333333 + 0.25 + 0.2 + 0.1666667 + 0.1428571 + 0.125 + 0.1111111 + let expected = 1.0 + + 0.5 + + 0.3333333 + + 0.25 + + 0.2 + + 0.1666667 + + 0.1428571 + + 0.125 + + 0.1111111 assert_true((a1 - expected).abs() < 0.01) } @@ -176,16 +184,16 @@ test "mktest_zero_values" { test "mktest_from_sites" { let poly_sites : Array[@src.PolymorphicSite] = Array::new() let fixed_sites : Array[@src.PolymorphicSite] = Array::new() - + // Add polymorphic sites - poly_sites.push(@src.new_polymorphic_site(100, 2, 20, true)) // nonsynonymous + poly_sites.push(@src.new_polymorphic_site(100, 2, 20, true)) // nonsynonymous poly_sites.push(@src.new_polymorphic_site(200, 3, 20, false)) // synonymous - poly_sites.push(@src.new_polymorphic_site(300, 1, 20, true)) // nonsynonymous - + poly_sites.push(@src.new_polymorphic_site(300, 1, 20, true)) // nonsynonymous + // Add fixed sites - fixed_sites.push(@src.new_polymorphic_site(400, 20, 20, true)) // nonsynonymous + fixed_sites.push(@src.new_polymorphic_site(400, 20, 20, true)) // nonsynonymous fixed_sites.push(@src.new_polymorphic_site(500, 20, 20, false)) // synonymous - + let result = @src.mktest_from_sites(poly_sites, fixed_sites) assert_eq(result.p_nonsyn, 2) assert_eq(result.p_syn, 1) @@ -201,7 +209,7 @@ test "afs_calculate" { sites.push(@src.new_singleton(200, 20, true)) sites.push(@src.new_doubleton(300, 20, false)) sites.push(@src.new_polymorphic_site(400, 5, 20, false)) - + let afs = @src.calculate_afs(sites, 20) assert_eq(afs.singletons, 2) assert_eq(afs.doubletons, 1) @@ -224,7 +232,7 @@ test "tajima_d_from_afs" { sites.push(@src.new_singleton(100, 20, false)) sites.push(@src.new_singleton(200, 20, false)) sites.push(@src.new_doubleton(300, 20, false)) - + let afs = @src.calculate_afs(sites, 20) let result = @src.tajima_d_from_afs(afs, 1000) assert_eq(result.test_name, "Tajima's D") @@ -237,7 +245,7 @@ test "fu_li_d_from_afs" { let sites : Array[@src.PolymorphicSite] = Array::new() sites.push(@src.new_singleton(100, 20, false)) sites.push(@src.new_doubleton(200, 20, false)) - + let afs = @src.calculate_afs(sites, 20) let result = @src.fu_li_d_from_afs(afs) assert_eq(result.test_name, "Fu & Li's D") @@ -248,10 +256,10 @@ test "fu_li_d_from_afs" { test "normal_cdf" { let p0 = @src.popgen_normal_cdf(0.0) assert_true((p0 - 0.5).abs() < 0.01) - + let p1 = @src.popgen_normal_cdf(1.96) assert_true(p1 > 0.96 && p1 < 0.98) - + let p_neg1 = @src.popgen_normal_cdf(-1.96) assert_true(p_neg1 > 0.02 && p_neg1 < 0.04) } @@ -270,7 +278,7 @@ test "neutrality_analysis" { for i = 1; i < 3; i = i + 1 { sites.push(@src.new_polymorphic_site(1000 + i * 100, 5, 30, i == 1)) } - + let result = @src.run_neutrality_analysis(sites, 30, 10000) assert_true(!result.tajima_d.statistic.is_nan()) assert_true(!result.fu_li_d.statistic.is_nan()) @@ -296,7 +304,7 @@ test "neutrality_analysis_to_string" { sites.push(@src.new_singleton(100, 20, false)) sites.push(@src.new_singleton(200, 20, true)) sites.push(@src.new_doubleton(300, 20, false)) - + let result = @src.run_neutrality_analysis(sites, 20, 5000) let output = @src.neutrality_analysis_to_string(result) assert_true(output.contains("Neutrality Analysis Results")) @@ -353,7 +361,7 @@ test "multiple_singletons" { for i = 1; i < 15; i = i + 1 { sites.push(@src.new_singleton(i * 50, 25, i % 3 == 0)) } - + let afs = @src.calculate_afs(sites, 25) assert_eq(afs.singletons, 14) assert_eq(afs.segregating_sites, 14) @@ -367,7 +375,7 @@ test "high_freq_variants" { sites.push(@src.new_polymorphic_site(100, 24, 25, false)) sites.push(@src.new_polymorphic_site(200, 23, 25, true)) sites.push(@src.new_polymorphic_site(300, 22, 25, false)) - + let afs = @src.calculate_afs(sites, 25) assert_eq(afs.singletons, 0) // No singletons -} \ No newline at end of file +} diff --git a/test/moonbit/preprocess_core_test.mbt b/test/moonbit/preprocess_core_test.mbt index 6b852a00..f836dcef 100644 --- a/test/moonbit/preprocess_core_test.mbt +++ b/test/moonbit/preprocess_core_test.mbt @@ -14,6 +14,7 @@ test "pc_quantile_config_new" { assert_eq(config.method, "quantile") } +///| test "pc_invariant_set_result_creation" { let dummy : Array[Array[Double]] = [[1.0, 2.0], [3.0, 4.0]] let res = @src.InvariantSetResult::new(dummy, [0, 1], 0, [0.0, 1.0]) @@ -27,6 +28,7 @@ test "pc_invariant_set_result_creation" { // Helper utilities // ============================================================================ +///| test "pc_interp_linear_basic" { let xs = [0.0, 1.0, 2.0, 3.0, 4.0] let ys = [0.0, 10.0, 20.0, 30.0, 40.0] @@ -44,11 +46,13 @@ test "pc_interp_linear_basic" { assert_true((v3 - 40.0).abs() < 0.0001) } +///| test "pc_interp_linear_empty" { let v = @src.pc_interp_linear([], [], 1.0) assert_eq(v, 0.0) } +///| test "pc_interp_linear_single" { let v = @src.pc_interp_linear([5.0], [100.0], 0.0) assert_eq(v, 100.0) @@ -58,15 +62,10 @@ test "pc_interp_linear_single" { // Quantile normalization core tests // ============================================================================ +///| test "pc_normalize_quantiles_identical_distributions" { // Two columns with same values -> should remain the same - let matrix = [ - [1.0, 1.0], - [2.0, 2.0], - [3.0, 3.0], - [4.0, 4.0], - [5.0, 5.0], - ] + let matrix = [[1.0, 1.0], [2.0, 2.0], [3.0, 3.0], [4.0, 4.0], [5.0, 5.0]] let res = @src.normalize_quantiles(matrix) assert_eq(res.length(), 5) assert_eq(res[0].length(), 2) @@ -76,16 +75,12 @@ test "pc_normalize_quantiles_identical_distributions" { } } +///| test "pc_normalize_quantiles_swapped_values" { // Two columns with reversed order // Col1: [1, 2, 3, 4], Col2: [4, 3, 2, 1] // After normalization, both should have means of sorted values - let matrix = [ - [1.0, 4.0], - [2.0, 3.0], - [3.0, 2.0], - [4.0, 1.0], - ] + let matrix = [[1.0, 4.0], [2.0, 3.0], [3.0, 2.0], [4.0, 1.0]] let res = @src.normalize_quantiles(matrix) // Check distributions: for each column, after sorting, they should match // sorted(col1_normalized) == sorted(col2_normalized) == 2.5, 2.5, 2.5, 2.5 @@ -102,12 +97,9 @@ test "pc_normalize_quantiles_swapped_values" { assert_true((res[0][1] - 4.0).abs() < 0.0001) } +///| test "pc_normalize_quantiles_three_columns" { - let matrix = [ - [1.0, 4.0, 7.0], - [2.0, 5.0, 8.0], - [3.0, 6.0, 9.0], - ] + let matrix = [[1.0, 4.0, 7.0], [2.0, 5.0, 8.0], [3.0, 6.0, 9.0]] let res = @src.normalize_quantiles(matrix) assert_eq(res.length(), 3) assert_eq(res[0].length(), 3) @@ -123,11 +115,13 @@ test "pc_normalize_quantiles_three_columns" { assert_true((orig_sum - new_sum).abs() < 0.1) } +///| test "pc_normalize_quantiles_empty" { let res = @src.normalize_quantiles([]) assert_eq(res.length(), 0) } +///| test "pc_normalize_quantiles_one_row" { let matrix = [[1.0, 10.0, 100.0]] let res = @src.normalize_quantiles(matrix) @@ -144,12 +138,9 @@ test "pc_normalize_quantiles_one_row" { // Target-based quantile normalization // ============================================================================ +///| test "pc_normalize_quantiles_target" { - let matrix = [ - [1.0, 2.0], - [3.0, 4.0], - [5.0, 6.0], - ] + let matrix = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]] let target = [10.0, 20.0, 30.0] let res = @src.normalize_quantiles_use_target(matrix, target) assert_eq(res.length(), 3) @@ -161,12 +152,9 @@ test "pc_normalize_quantiles_target" { assert_true((res[2][0] - 30.0).abs() < 0.0001) } +///| test "pc_normalize_quantiles_determine_target" { - let matrix = [ - [1.0, 3.0], - [2.0, 2.0], - [3.0, 1.0], - ] + let matrix = [[1.0, 3.0], [2.0, 2.0], [3.0, 1.0]] let target = @src.normalize_quantiles_determine_target(matrix) assert_eq(target.length(), 3) // Each row of sorted matrix: sorted col1 = [1, 2, 3], col2 = [1, 2, 3] @@ -180,6 +168,7 @@ test "pc_normalize_quantiles_determine_target" { // Subset quantile normalization // ============================================================================ +///| test "pc_normalize_quantiles_subset" { let matrix = [ [1.0, 8.0], @@ -200,6 +189,7 @@ test "pc_normalize_quantiles_subset" { // Invariant set normalization // ============================================================================ +///| test "pc_find_invariant_set_perfect_correlation" { // Two arrays with perfect linear relationship let reference = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] @@ -209,11 +199,13 @@ test "pc_find_invariant_set_perfect_correlation" { assert_true(inv.length() >= 5) } +///| test "pc_find_invariant_set_length_mismatch" { let inv = @src.find_invariant_set([1.0, 2.0], [1.0]) assert_eq(inv.length(), 0) } +///| test "pc_normalize_invariantset_basic" { // 3 samples x 5 rows let matrix = [ @@ -223,7 +215,11 @@ test "pc_normalize_invariantset_basic" { [4.0, 8.0, 12.0], [5.0, 10.0, 15.0], ] - let res = @src.normalize_invariantset(matrix, reference_index=0, threshold=0.01) + let res = @src.normalize_invariantset( + matrix, + reference_index=0, + threshold=0.01, + ) assert_eq(res.reference_index, 0) assert_eq(res.normalized_data.length(), 5) // Reference column should be unchanged @@ -236,6 +232,7 @@ test "pc_normalize_invariantset_basic" { // Log transform // ============================================================================ +///| test "pc_log2_transform_basic" { let matrix = [[0.0, 1.0], [3.0, 15.0]] let res = @src.log2_transform(matrix, offset=1.0) @@ -249,6 +246,7 @@ test "pc_log2_transform_basic" { assert_true((res[1][1] - 4.0).abs() < 0.0001) } +///| test "pc_log2_transform_empty" { let res = @src.log2_transform([]) assert_eq(res.length(), 0) @@ -258,6 +256,7 @@ test "pc_log2_transform_empty" { // Background correction // ============================================================================ +///| test "pc_background_correct_percentile_basic" { let matrix = [ [1.0, 100.0], @@ -290,21 +289,16 @@ test "pc_background_correct_percentile_basic" { // Median center // ============================================================================ +///| test "pc_median_center_columns_basic" { - let matrix = [ - [1.0, 10.0], - [2.0, 20.0], - [3.0, 30.0], - [4.0, 40.0], - [5.0, 50.0], - ] + let matrix = [[1.0, 10.0], [2.0, 20.0], [3.0, 30.0], [4.0, 40.0], [5.0, 50.0]] let res = @src.median_center_columns(matrix) // Column 1 median = 3, centered = [-2, -1, 0, 1, 2] - assert_true((res[0][0] - (-2.0)).abs() < 0.0001) + assert_true((res[0][0] - -2.0).abs() < 0.0001) assert_true((res[2][0] - 0.0).abs() < 0.0001) assert_true((res[4][0] - 2.0).abs() < 0.0001) // Column 2 median = 30, centered = [-20, -10, 0, 10, 20] - assert_true((res[0][1] - (-20.0)).abs() < 0.0001) + assert_true((res[0][1] - -20.0).abs() < 0.0001) assert_true((res[2][1] - 0.0).abs() < 0.0001) assert_true((res[4][1] - 20.0).abs() < 0.0001) } @@ -313,14 +307,9 @@ test "pc_median_center_columns_basic" { // Column summary // ============================================================================ +///| test "pc_column_summary_basic" { - let matrix = [ - [1.0, 10.0], - [2.0, 20.0], - [3.0, 30.0], - [4.0, 40.0], - [5.0, 50.0], - ] + let matrix = [[1.0, 10.0], [2.0, 20.0], [3.0, 30.0], [4.0, 40.0], [5.0, 50.0]] let res = @src.column_summary(matrix) assert_eq(res.length(), 2) // Each column result is [mean, median, sd, min, max] @@ -336,6 +325,7 @@ test "pc_column_summary_basic" { assert_true((res[1][4] - 50.0).abs() < 0.0001) } +///| test "pc_column_summary_empty" { let res = @src.column_summary([]) assert_eq(res.length(), 0) diff --git a/test/moonbit/progeny_test.mbt b/test/moonbit/progeny_test.mbt index 66a420dd..0b3af720 100644 --- a/test/moonbit/progeny_test.mbt +++ b/test/moonbit/progeny_test.mbt @@ -23,8 +23,8 @@ test "progeny_mat_vec_multiply" { let vector = [1.0, 2.0] let result = @src.progeny_mat_vec(matrix, vector) assert_eq(result.length(), 2) - assert_eq(result[0], 5.0) // 1*1 + 2*2 - assert_eq(result[1], 11.0) // 3*1 + 4*2 + assert_eq(result[0], 5.0) // 1*1 + 2*2 + assert_eq(result[1], 11.0) // 3*1 + 4*2 } ///| @@ -33,10 +33,10 @@ test "progeny_mat_mul" { let b = [[5.0, 6.0], [7.0, 8.0]] let result = @src.progeny_mat_mul(a, b) assert_eq(result.length(), 2) - assert_eq(result[0][0], 19.0) // 1*5 + 2*7 - assert_eq(result[0][1], 22.0) // 1*6 + 2*8 - assert_eq(result[1][0], 43.0) // 3*5 + 4*7 - assert_eq(result[1][1], 50.0) // 3*6 + 4*8 + assert_eq(result[0][0], 19.0) // 1*5 + 2*7 + assert_eq(result[0][1], 22.0) // 1*6 + 2*8 + assert_eq(result[1][0], 43.0) // 3*5 + 4*7 + assert_eq(result[1][1], 50.0) // 3*6 + 4*8 } ///| @@ -114,11 +114,15 @@ test "progeny_build_pathway_matrix" { let gene_names = ["GeneA", "GeneB", "GeneC", "GeneD"] let pathway1_genes = ["GeneA", "GeneB"] let pathway1_weights = [1.0, -1.0] - let pgs1 = @src.PathwayGeneSet::new("Pathway1", pathway1_genes, pathway1_weights) + let pgs1 = @src.PathwayGeneSet::new( + "Pathway1", pathway1_genes, pathway1_weights, + ) let pathway2_genes = ["GeneB", "GeneC", "GeneD"] let pathway2_weights = [0.5, 1.0, -0.5] - let pgs2 = @src.PathwayGeneSet::new("Pathway2", pathway2_genes, pathway2_weights) + let pgs2 = @src.PathwayGeneSet::new( + "Pathway2", pathway2_genes, pathway2_weights, + ) let pathways = [pgs1, pgs2] let matrix = @src.build_pathway_matrix(gene_names, pathways) @@ -146,25 +150,18 @@ test "progeny_build_pathway_matrix" { ///| test "progeny_run_basic" { // Expression: 2 samples × 4 genes - let expression = [ - [5.0, 10.0, 3.0, 8.0], - [2.0, 6.0, 7.0, 4.0], - ] + let expression = [[5.0, 10.0, 3.0, 8.0], [2.0, 6.0, 7.0, 4.0]] let sample_names = ["Sample1", "Sample2"] let gene_names = ["GeneA", "GeneB", "GeneC", "GeneD"] // Pathway1: GeneA + GeneB (activation) - let pathway1 = @src.PathwayGeneSet::new( - "Pathway1", - ["GeneA", "GeneB"], - [1.0, 1.0], - ) + let pathway1 = @src.PathwayGeneSet::new("Pathway1", ["GeneA", "GeneB"], [ + 1.0, 1.0, + ]) // Pathway2: GeneC + GeneD (activation) - let pathway2 = @src.PathwayGeneSet::new( - "Pathway2", - ["GeneC", "GeneD"], - [1.0, 1.0], - ) + let pathway2 = @src.PathwayGeneSet::new("Pathway2", ["GeneC", "GeneD"], [ + 1.0, 1.0, + ]) let data = @src.ProgenyData::new( expression, @@ -192,7 +189,13 @@ test "progeny_get_pathway_activity" { let sample_names = ["S1", "S2"] let gene_names = ["G1", "G2"] let pathway1 = @src.PathwayGeneSet::new("P1", ["G1"], [1.0]) - let data = @src.ProgenyData::new(expression, sample_names, gene_names, [pathway1], 0.01) + let data = @src.ProgenyData::new( + expression, + sample_names, + gene_names, + [pathway1], + 0.01, + ) let result = @src.run_progeny(data) let activity = @src.get_pathway_activity(result, "P1") @@ -207,7 +210,13 @@ test "progeny_get_sample_profile" { let gene_names = ["G1", "G2"] let p1 = @src.PathwayGeneSet::new("P1", ["G1"], [1.0]) let p2 = @src.PathwayGeneSet::new("P2", ["G2"], [1.0]) - let data = @src.ProgenyData::new(expression, sample_names, gene_names, [p1, p2], 0.01) + let data = @src.ProgenyData::new( + expression, + sample_names, + gene_names, + [p1, p2], + 0.01, + ) let result = @src.run_progeny(data) let profile = @src.get_sample_profile(result, "S1") diff --git a/test/moonbit/prosite_test.mbt b/test/moonbit/prosite_test.mbt index 57113815..f4a53178 100644 --- a/test/moonbit/prosite_test.mbt +++ b/test/moonbit/prosite_test.mbt @@ -1,57 +1,69 @@ ///| /// Tests for Prosite module. - test "PrositePattern creation" { - let pattern = @src.PrositePattern::new("PS00001", "ATP-binding", "[AG]-X(4)-G-K-[ST]") + let pattern = @src.PrositePattern::new( + "PS00001", "ATP-binding", "[AG]-X(4)-G-K-[ST]", + ) assert_eq(pattern.accession, "PS00001") assert_eq(pattern.name, "ATP-binding") assert_eq(pattern.pattern, "[AG]-X(4)-G-K-[ST]") } +///| test "PrositeMatch creation" { - let match_ = @src.PrositeMatch::new("PS00001", "ATP-binding", 1, 10, "AGXXXXGKST") + let match_ = @src.PrositeMatch::new( + "PS00001", "ATP-binding", 1, 10, "AGXXXXGKST", + ) assert_eq(match_.pattern_accession, "PS00001") assert_eq(match_.start, 1) assert_eq(match_.end, 10) } +///| test "PrositeEntry creation" { let entry = @src.PrositeEntry::new("PS00001", "ATP/GTP-binding") assert_eq(entry.accession, "PS00001") assert_eq(entry.name, "ATP/GTP-binding") } +///| test "prosite_pattern_to_regex" { let regex = @src.prosite_pattern_to_regex("[AG]-X(4)-G-K-[ST]") assert_true(regex.length() > 0) } +///| test "prosite_search simple pattern" { let matches = @src.prosite_search("ST", "AASTKKST") assert_true(matches.length() >= 2) } +///| test "prosite_search bracket pattern" { let matches = @src.prosite_search("[ST]", "ASTCG") assert_true(matches.length() >= 2) } +///| test "prosite_search with wildcards" { let matches = @src.prosite_search("X(2)", "AAAA") assert_true(matches.length() >= 3) } +///| test "prosite_scan" { let patterns = @src.prosite_create_example_patterns() let matches = @src.prosite_scan("AASTKKST", patterns) assert_true(matches.length() >= 1) } +///| test "prosite_get_pattern" { let pattern = @src.prosite_get_pattern("PS00001") assert_true(pattern is Some(_)) } +///| test "prosite_calculate_score" { let match_ = @src.PrositeMatch::new("PS00001", "Test", 1, 5, "AAAAA") let pattern = @src.PrositePattern::new("PS00001", "Test", "AAAAA") @@ -59,12 +71,14 @@ test "prosite_calculate_score" { assert_true(score >= 90.0) } +///| test "prosite_create_example_patterns" { let patterns = @src.prosite_create_example_patterns() assert_eq(patterns.length(), 3) } +///| test "prosite_create_example_entry" { let entry = @src.prosite_create_example_entry() assert_eq(entry.accession, "PS00001") -} \ No newline at end of file +} diff --git a/test/moonbit/prot_dao_test.mbt b/test/moonbit/prot_dao_test.mbt index e36871ae..7bca0fce 100644 --- a/test/moonbit/prot_dao_test.mbt +++ b/test/moonbit/prot_dao_test.mbt @@ -1,182 +1,211 @@ ///| /// Test file for prot_dao module (IUPred disorder prediction). - test "disorder_score_positive" { // Disordered-promoting amino acids should have positive scores - assert_eq!(@src.prot_dao_disorder_score('E') > 0.0, true) - assert_eq!(@src.prot_dao_disorder_score('P') > 0.0, true) - assert_eq!(@src.prot_dao_disorder_score('K') > 0.0, true) - assert_eq!(@src.prot_dao_disorder_score('S') > 0.0, true) + assert_eq(@src.prot_dao_disorder_score('E') > 0.0, true) + assert_eq(@src.prot_dao_disorder_score('P') > 0.0, true) + assert_eq(@src.prot_dao_disorder_score('K') > 0.0, true) + assert_eq(@src.prot_dao_disorder_score('S') > 0.0, true) } +///| test "disorder_score_negative" { // Order-promoting amino acids should have negative or near-zero scores - assert_eq!(@src.prot_dao_disorder_score('I') < 0.0, true) - assert_eq!(@src.prot_dao_disorder_score('W') <= 0.0, true) - assert_eq!(@src.prot_dao_disorder_score('Y') < 0.0, true) - assert_eq!(@src.prot_dao_disorder_score('C') <= 0.0, true) + assert_eq(@src.prot_dao_disorder_score('I') < 0.0, true) + assert_eq(@src.prot_dao_disorder_score('W') <= 0.0, true) + assert_eq(@src.prot_dao_disorder_score('Y') < 0.0, true) + assert_eq(@src.prot_dao_disorder_score('C') <= 0.0, true) } +///| test "disorder_score_unknown_aa" { // Unknown amino acids should have 0 score - assert_eq!(@src.prot_dao_disorder_score('X'), 0.0) - assert_eq!(@src.prot_dao_disorder_score('z'), 0.0) + assert_eq(@src.prot_dao_disorder_score('X'), 0.0) + assert_eq(@src.prot_dao_disorder_score('z'), 0.0) } +///| test "energy_score_positive" { - assert_eq!(@src.prot_dao_energy_score('C') > 0.0, true) - assert_eq!(@src.prot_dao_energy_score('P') > 0.0, true) - assert_eq!(@src.prot_dao_energy_score('M') > 0.0, true) + assert_eq(@src.prot_dao_energy_score('C') > 0.0, true) + assert_eq(@src.prot_dao_energy_score('P') > 0.0, true) + assert_eq(@src.prot_dao_energy_score('M') > 0.0, true) } +///| test "energy_score_negative" { - assert_eq!(@src.prot_dao_energy_score('H') < 0.0, true) - assert_eq!(@src.prot_dao_energy_score('R') < 0.0, true) + assert_eq(@src.prot_dao_energy_score('H') < 0.0, true) + assert_eq(@src.prot_dao_energy_score('R') < 0.0, true) } +///| test "disorder_residue_create" { let res = @src.DisorderResidue::new(1, 'A', 0.5, 1.0) - assert_eq!(res.position, 1) - assert_eq!(res.amino_acid, 'A') - assert_eq!(res.disorder_score, 0.5) - assert_eq!(res.energy_score, 1.0) - assert_eq!(res.is_disordered, false) - assert_eq!(res.is_disordered_long, false) + assert_eq(res.position, 1) + assert_eq(res.amino_acid, 'A') + assert_eq(res.disorder_score, 0.5) + assert_eq(res.energy_score, 1.0) + assert_eq(res.is_disordered, false) + assert_eq(res.is_disordered_long, false) } +///| test "disorder_region_create" { let reg = @src.DisorderRegion::new(10, 50, 0.6, 0.8, region_type="disordered") - assert_eq!(reg.start, 10) - assert_eq!(reg.end_, 50) - assert_eq!(reg.length, 40) - assert_eq!(reg.avg_score, 0.6) - assert_eq!(reg.max_score, 0.8) - assert_eq!(reg.region_type, "disordered") + assert_eq(reg.start, 10) + assert_eq(reg.end_, 50) + assert_eq(reg.length, 40) + assert_eq(reg.avg_score, 0.6) + assert_eq(reg.max_score, 0.8) + assert_eq(reg.region_type, "disordered") } +///| test "disorder_region_type" { - let reg = @src.DisorderRegion::new(5, 45, 0.7, 0.9, region_type="long disordered") - assert_eq!(reg.region_type, "long disordered") + let reg = @src.DisorderRegion::new( + 5, + 45, + 0.7, + 0.9, + region_type="long disordered", + ) + assert_eq(reg.region_type, "long disordered") } +///| test "prot_dao_predict_ordered_sequence" { // A sequence with mostly ordered amino acids let ordered_seq = "AILWVFMWCILVWALMVILWAFMVCLWVILMAWLVFMAW" let result = @src.prot_dao_predict(ordered_seq) - assert_eq!(result.sequence, ordered_seq) - assert_eq!(result.residues.length(), ordered_seq.length()) - assert_eq!(result.method, "IUPred-like") + assert_eq(result.sequence, ordered_seq) + assert_eq(result.residues.length(), ordered_seq.length()) + assert_eq(result.method, "IUPred-like") } +///| test "prot_dao_predict_disordered_sequence" { // A sequence with many disorder-promoting amino acids let disordered_seq = "EPKSESEKPPPPPPKKKEEEPPPKKKSEGGSSSGGGKKKPPP" let result = @src.prot_dao_predict(disordered_seq) - assert_eq!(result.residues.length(), disordered_seq.length()) + assert_eq(result.residues.length(), disordered_seq.length()) // With many disorder-promoting residues, some should be disordered - assert_eq!(result.get_n_disordered() > 0, true) + assert_eq(result.get_n_disordered() > 0, true) } +///| test "prot_dao_predict_threshold" { let seq = "EPKSESEKPPPPPPKKKEEEPPPKKKSEGGSSSGGGKKKPPP" let result_low = @src.prot_dao_predict(seq, threshold_disordered=0.3) let result_high = @src.prot_dao_predict(seq, threshold_disordered=0.7) - assert_eq!(result_low.get_n_disordered() >= result_high.get_n_disordered(), true) + assert_eq( + result_low.get_n_disordered() >= result_high.get_n_disordered(), + true, + ) } +///| test "disorder_result_n_disordered" { let result = @src.prot_dao_sample() let n = result.get_n_disordered() - assert_eq!(n >= 0, true) - assert_eq!(n <= result.sequence.length(), true) + assert_eq(n >= 0, true) + assert_eq(n <= result.sequence.length(), true) } +///| test "disorder_result_fraction" { let result = @src.prot_dao_sample() let frac = result.get_fraction_disordered() - assert_eq!(frac >= 0.0, true) - assert_eq!(frac <= 1.0, true) + assert_eq(frac >= 0.0, true) + assert_eq(frac <= 1.0, true) } +///| test "disorder_result_regions" { let result = @src.prot_dao_sample() let regions = result.get_regions() let n_regions = result.get_n_regions() - assert_eq!(regions.length(), n_regions) + assert_eq(regions.length(), n_regions) // Each region should have valid coordinates let mut i = 0 while i < regions.length() { - assert_eq!(regions[i].start > 0 || regions[i].end_ > 0, true) - assert_eq!(regions[i].length >= 0, true) + assert_eq(regions[i].start > 0 || regions[i].end_ > 0, true) + assert_eq(regions[i].length >= 0, true) i = i + 1 } } +///| test "disorder_result_longest_region" { let result = @src.prot_dao_sample() let longest = result.get_longest_region() - assert_eq!(longest.length >= 0, true) + assert_eq(longest.length >= 0, true) if result.get_n_regions() > 0 { - assert_eq!(longest.length > 0, true) + assert_eq(longest.length > 0, true) } } +///| test "disorder_result_scores" { let result = @src.prot_dao_sample() let scores = result.get_scores() - assert_eq!(scores.length(), result.sequence.length()) + assert_eq(scores.length(), result.sequence.length()) let mut i = 0 while i < scores.length() { - assert_eq!(scores[i] >= 0.0 || scores[i] <= 0.0, true) + assert_eq(scores[i] >= 0.0 || scores[i] <= 0.0, true) i = i + 1 } } +///| test "disorder_result_summary" { let result = @src.prot_dao_sample() let summary = result.summary() - assert_eq!(summary.contains("IUPred-like"), true) - assert_eq!(summary.contains("Sequence length"), true) - assert_eq!(summary.contains("Disordered residues"), true) + assert_eq(summary.contains("IUPred-like"), true) + assert_eq(summary.contains("Sequence length"), true) + assert_eq(summary.contains("Disordered residues"), true) } +///| test "disorder_result_disordered_sequence" { let result = @src.prot_dao_sample() let ds = result.disordered_sequence() - assert_eq!(ds.length(), result.sequence.length()) + assert_eq(ds.length(), result.sequence.length()) // Disordered positions should show the amino acid // Ordered positions should show '-' } +///| test "prot_dao_sample_sequence" { let seq = @src.prot_dao_sample_sequence() - assert_eq!(seq.length() > 0, true) + assert_eq(seq.length() > 0, true) // All characters should be valid amino acids let mut i = 0 while i < seq.length() { let c = seq.unsafe_get(i) - assert_eq!(c >= 65 && c <= 90 || c >= 97 && c <= 122, true) + assert_eq((c >= 65 && c <= 90) || (c >= 97 && c <= 122), true) i = i + 1 } } +///| test "prot_dao_empty_sequence" { let result = @src.prot_dao_predict("") - assert_eq!(result.residues.length(), 0) - assert_eq!(result.get_fraction_disordered(), 0.0) - assert_eq!(result.get_n_disordered(), 0) + assert_eq(result.residues.length(), 0) + assert_eq(result.get_fraction_disordered(), 0.0) + assert_eq(result.get_n_disordered(), 0) } +///| test "prot_dao_single_residue" { let result = @src.prot_dao_predict("A") - assert_eq!(result.residues.length(), 1) - assert_eq!(result.sequence, "A") + assert_eq(result.residues.length(), 1) + assert_eq(result.sequence, "A") } +///| test "prot_dao_to_ascii" { let result = @src.prot_dao_sample() let ascii = result.to_ascii() - assert_eq!(ascii.contains("Score"), true) - assert_eq!(ascii.contains("Seq"), true) - assert_eq!(ascii.contains("Dis"), true) + assert_eq(ascii.contains("Score"), true) + assert_eq(ascii.contains("Seq"), true) + assert_eq(ascii.contains("Dis"), true) } diff --git a/test/moonbit/protein_analysis_test.mbt b/test/moonbit/protein_analysis_test.mbt index 1981c536..87430a43 100644 --- a/test/moonbit/protein_analysis_test.mbt +++ b/test/moonbit/protein_analysis_test.mbt @@ -17,12 +17,14 @@ test "protein_hydropathy_basic" { } } +///| test "protein_hydropathy_short_sequence" { let seq = "ACG" let hydro = @src.protein_hydropathy(seq, window=7) assert_eq(hydro.length(), 0) } +///| test "protein_hydropathy_custom_window" { let seq = "ACDEFGHIKLMNPQRSTVWY" let hydro5 = @src.protein_hydropathy(seq, window=5) @@ -34,6 +36,7 @@ test "protein_hydropathy_custom_window" { // Secondary Structure Prediction Tests // ============================================================================ +///| test "protein_secondary_structure_basic" { let seq = "ACDEFGHIKLMNPQRSTVWY" let ss = @src.protein_secondary_structure(seq) @@ -47,6 +50,7 @@ test "protein_secondary_structure_basic" { } } +///| test "protein_secondary_structure_all_chars" { // Test that all 20 amino acids are handled let seq = "ACDEFGHIKLMNPQRSTVWY" @@ -58,6 +62,7 @@ test "protein_secondary_structure_all_chars" { // Antigenicity Tests // ============================================================================ +///| test "protein_antigenicity_basic" { let seq = "ACDEFGHIKLMNPQRSTVWY" let antigen = @src.protein_antigenicity(seq) @@ -70,6 +75,7 @@ test "protein_antigenicity_basic" { } } +///| test "protein_antigenicity_positive_residues" { // Known antigenic residues should have positive values let antigen = @src.protein_antigenicity("RKP") @@ -82,6 +88,7 @@ test "protein_antigenicity_positive_residues" { // Transmembrane Prediction Tests // ============================================================================ +///| test "protein_transmembrane_basic" { let seq = "ACDEFGHIKLMNPQRSTVWY" let tm = @src.protein_transmembrane(seq, window=19) @@ -89,12 +96,14 @@ test "protein_transmembrane_basic" { assert_eq(tm.length(), 2) } +///| test "protein_transmembrane_short_sequence" { let seq = "ACG" let tm = @src.protein_transmembrane(seq, window=19) assert_eq(tm.length(), 0) } +///| test "protein_transmembrane_propensity" { // Known transmembrane residues should have positive scores let v_tm = @src.protein_transmembrane_propensity('V') @@ -107,6 +116,7 @@ test "protein_transmembrane_propensity" { // Amino Acid Composition Tests // ============================================================================ +///| test "protein_aa_composition_basic" { let seq = "AAL" let comp = @src.protein_aa_composition(seq) @@ -119,6 +129,7 @@ test "protein_aa_composition_basic" { assert_true(a_freq > l_freq) } +///| test "protein_aa_composition_empty" { let seq = "" let comp = @src.protein_aa_composition(seq) @@ -130,6 +141,7 @@ test "protein_aa_composition_empty" { // Dipeptide/Tripeptide Composition Tests // ============================================================================ +///| test "protein_dipeptide_composition_basic" { let seq = "ALA" let comp = @src.protein_dipeptide_composition(seq) @@ -140,12 +152,14 @@ test "protein_dipeptide_composition_basic" { assert_true(la_freq > 0.0) } +///| test "protein_dipeptide_composition_short" { let seq = "A" let comp = @src.protein_dipeptide_composition(seq) assert_eq(comp.length(), 0) } +///| test "protein_tripeptide_composition_basic" { let seq = "ALA" let comp = @src.protein_tripeptide_composition(seq) @@ -154,6 +168,7 @@ test "protein_tripeptide_composition_basic" { assert_true(ala_freq > 0.0) } +///| test "protein_tripeptide_composition_short" { let seq = "AL" let comp = @src.protein_tripeptide_composition(seq) @@ -164,6 +179,7 @@ test "protein_tripeptide_composition_short" { // Conservation Tests // ============================================================================ +///| test "protein_conservation_identical" { let alignment = ["AAAA", "AAAA", "AAAA"] let cons = @src.protein_conservation(alignment) @@ -176,6 +192,7 @@ test "protein_conservation_identical" { } } +///| test "protein_conservation_different" { let alignment = ["AAAA", "CCCC", "GGGG"] let cons = @src.protein_conservation(alignment) @@ -188,6 +205,7 @@ test "protein_conservation_different" { } } +///| test "protein_conservation_empty" { let alignment : Array[String] = [] let cons = @src.protein_conservation(alignment) @@ -198,6 +216,7 @@ test "protein_conservation_empty" { // Summary Report Tests // ============================================================================ +///| test "protein_summary_basic" { let seq = "ACDEFGHIKLMNPQRSTVWY" let summary = @src.protein_summary(seq) diff --git a/test/moonbit/proteomics_test.mbt b/test/moonbit/proteomics_test.mbt index d154364e..c05188b3 100644 --- a/test/moonbit/proteomics_test.mbt +++ b/test/moonbit/proteomics_test.mbt @@ -215,5 +215,9 @@ test "proteomics_fragment_ions_single_residue" { ///| fn abs(x : Double) -> Double { - if x < 0.0 { -x } else { x } -} \ No newline at end of file + if x < 0.0 { + -x + } else { + x + } +} diff --git a/test/moonbit/psea_test.mbt b/test/moonbit/psea_test.mbt index ae8c7e15..eec0da6c 100644 --- a/test/moonbit/psea_test.mbt +++ b/test/moonbit/psea_test.mbt @@ -146,7 +146,7 @@ test "psea_short_chain" { let atoms = [ @src.PseaAtom::new("A", 1, "CA", 0.0, 0.0, 0.0), @src.PseaAtom::new("B", 2, "CA", 1.0, 0.0, 0.0), - @src.PseaAtom::new("C", 3, "CA", 2.0, 0.0, 0.0) + @src.PseaAtom::new("C", 3, "CA", 2.0, 0.0, 0.0), ] let result = @src.psea_run(atoms) assert_eq(result.psea_n_residues(), 3) diff --git a/test/moonbit/qfeatures_test.mbt b/test/moonbit/qfeatures_test.mbt index e761cbbd..70f03acd 100644 --- a/test/moonbit/qfeatures_test.mbt +++ b/test/moonbit/qfeatures_test.mbt @@ -5,11 +5,7 @@ test "qf_assay_creation" { let row_names = ["r0", "r1", "r2"] let col_names = ["c0", "c1"] - let data : Array[Array[Double]] = [ - [1.0, 2.0], - [3.0, 4.0], - [5.0, 6.0], - ] + let data : Array[Array[Double]] = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]] let assay = @src.QfAssay::new("test", row_names, col_names, data) assert_eq(assay.name(), "test") assert_eq(assay.n_rows(), 3) @@ -55,10 +51,7 @@ test "qf_assay_get_set" { ///| test "qf_assay_get_row_get_col" { - let data : Array[Array[Double]] = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - ] + let data : Array[Array[Double]] = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let assay = @src.QfAssay::new("a", ["r0", "r1"], ["c0", "c1", "c2"], data) let row0 = assay.get_row(0) let row1 = assay.get_row(1) @@ -80,10 +73,7 @@ test "qf_assay_get_row_get_col" { ///| test "qf_assay_row_col_stats" { - let data : Array[Array[Double]] = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - ] + let data : Array[Array[Double]] = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let assay = @src.QfAssay::new("a", ["r0", "r1"], ["c0", "c1", "c2"], data) let rmeans = assay.row_means() let cmeans = assay.col_means() @@ -233,12 +223,7 @@ test "qf_aggregate_rows_sum" { qf.add_assay( @src.QfAssay::new("src", ["r0", "r1", "r2", "r3"], ["c0", "c1"], data), ) - let mapping : Array[(Int, String)] = [ - (0, "A"), - (1, "A"), - (2, "B"), - (3, "B"), - ] + let mapping : Array[(Int, String)] = [(0, "A"), (1, "A"), (2, "B"), (3, "B")] let qf2 = @src.qf_aggregate(qf, "src", "agg", mapping, "sum") assert_eq(qf2.n_assays(), 2) match qf2.get_assay("agg") { @@ -276,12 +261,7 @@ test "qf_aggregate_rows_mean" { qf.add_assay( @src.QfAssay::new("src", ["r0", "r1", "r2", "r3"], ["c0", "c1"], data), ) - let mapping : Array[(Int, String)] = [ - (0, "A"), - (1, "A"), - (2, "B"), - (3, "B"), - ] + let mapping : Array[(Int, String)] = [(0, "A"), (1, "A"), (2, "B"), (3, "B")] let qf2 = @src.qf_aggregate(qf, "src", "agg", mapping, "mean") match qf2.get_assay("agg") { Some(a) => { @@ -300,17 +280,9 @@ test "qf_aggregate_rows_mean" { ///| test "qf_aggregate_by_col_merge" { let qf = @src.QFeatures::new() - let data : Array[Array[Double]] = [ - [1.0, 2.0, 3.0, 4.0], - [5.0, 6.0, 7.0, 8.0], - ] + let data : Array[Array[Double]] = [[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]] qf.add_assay( - @src.QfAssay::new( - "src", - ["r0", "r1"], - ["c0", "c1", "c2", "c3"], - data, - ), + @src.QfAssay::new("src", ["r0", "r1"], ["c0", "c1", "c2", "c3"], data), ) let labels = ["rep1", "rep1", "rep2", "rep2"] // Sum aggregation. @@ -376,10 +348,7 @@ test "qf_filter_features" { ///| test "qf_filter_samples" { let qf = @src.QFeatures::new() - let data : Array[Array[Double]] = [ - [1.0, 2.0, 3.0, 4.0], - [5.0, 6.0, 7.0, 8.0], - ] + let data : Array[Array[Double]] = [[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]] qf.add_assay( @src.QfAssay::new("a", ["r0", "r1"], ["c0", "c1", "c2", "c3"], data), ) @@ -408,7 +377,9 @@ test "qf_filter_na" { [nan, nan, 6.0], [7.0, nan, 9.0], ] - qf.add_assay(@src.QfAssay::new("a", ["r0", "r1", "r2"], ["c0", "c1", "c2"], data)) + qf.add_assay( + @src.QfAssay::new("a", ["r0", "r1", "r2"], ["c0", "c1", "c2"], data), + ) // max_na_frac = 0.5 -> row 1 (2/3 NaN > 0.5) is dropped; row 2 (1/3 NaN) kept. let qf2 = @src.qf_filter_na(qf, "a", 0.5) match qf2.get_assay("a") { @@ -435,7 +406,9 @@ test "qf_filter_low_abundance" { [0.5, 0.5, 0.5], [10.0, 20.0, 30.0], ] - qf.add_assay(@src.QfAssay::new("a", ["r0", "r1", "r2"], ["c0", "c1", "c2"], data)) + qf.add_assay( + @src.QfAssay::new("a", ["r0", "r1", "r2"], ["c0", "c1", "c2"], data), + ) // threshold = 1.0 -> row 1 (all 0.5 < 1.0) is dropped. let qf2 = @src.qf_filter_low_abundance(qf, "a", 1.0) match qf2.get_assay("a") { @@ -452,21 +425,29 @@ test "qf_filter_low_abundance" { test "qf_normalize_quantiles" { // Construct a matrix where columns have different distributions but // after quantile normalization they should share the same sorted values. - let data : Array[Array[Double]] = [ - [5.0, 10.0], - [2.0, 20.0], - [10.0, 30.0], - ] + let data : Array[Array[Double]] = [[5.0, 10.0], [2.0, 20.0], [10.0, 30.0]] let assay = @src.QfAssay::new("a", ["r0", "r1", "r2"], ["c0", "c1"], data) let norm = @src.qf_normalize_quantiles(assay) // Compute sorted columns of normalized assay; they should be equal. let col0 = norm.get_col(0) let col1 = norm.get_col(1) col0.sort_by(fn(a : Double, b : Double) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) col1.sort_by(fn(a : Double, b : Double) -> Int { - if a < b { -1 } else if a > b { 1 } else { 0 } + if a < b { + -1 + } else if a > b { + 1 + } else { + 0 + } }) for i in 0..<3 { assert_true((col0[i] - col1[i]).abs() < 0.001) @@ -481,11 +462,7 @@ test "qf_normalize_quantiles" { test "qf_normalize_center_scale" { // Column 0: [1, 2, 3] -> mean=2, sample std=1 // Column 1: [10, 20, 30] -> mean=20, sample std=10 - let data : Array[Array[Double]] = [ - [1.0, 10.0], - [2.0, 20.0], - [3.0, 30.0], - ] + let data : Array[Array[Double]] = [[1.0, 10.0], [2.0, 20.0], [3.0, 30.0]] let assay = @src.QfAssay::new("a", ["r0", "r1", "r2"], ["c0", "c1"], data) let norm = @src.qf_normalize_center_scale(assay, true, true) // Expected normalized values: col0 = [-1, 0, 1], col1 = [-1, 0, 1] @@ -502,10 +479,7 @@ test "qf_normalize_center_scale" { ///| test "qf_normalize_center_only" { - let data : Array[Array[Double]] = [ - [1.0, 10.0], - [3.0, 30.0], - ] + let data : Array[Array[Double]] = [[1.0, 10.0], [3.0, 30.0]] let assay = @src.QfAssay::new("a", ["r0", "r1"], ["c0", "c1"], data) let norm = @src.qf_normalize_center_scale(assay, true, false) // Col 0 mean=2 -> centered: [-1, 1] @@ -519,10 +493,7 @@ test "qf_normalize_center_only" { ///| test "qf_log_transform" { // log2(x+1): 1->1, 3->2, 7->3, 0->0 - let data : Array[Array[Double]] = [ - [1.0, 3.0], - [7.0, 0.0], - ] + let data : Array[Array[Double]] = [[1.0, 3.0], [7.0, 0.0]] let assay = @src.QfAssay::new("a", ["r0", "r1"], ["c0", "c1"], data) let logged = @src.qf_log_transform(assay, 2.0, 1.0) assert_true((logged.get(0, 0) - 1.0).abs() < 0.001) @@ -551,7 +522,12 @@ test "qf_impute_knn" { [2.0, 5.0, 4.0], [3.0, 6.0, 7.0], ] - let assay = @src.QfAssay::new("a", ["r0", "r1", "r2"], ["c0", "c1", "c2"], data) + let assay = @src.QfAssay::new( + "a", + ["r0", "r1", "r2"], + ["c0", "c1", "c2"], + data, + ) let imputed = @src.qf_impute_knn(assay, 1) assert_true(!@src.qf_is_na(imputed.get(0, 1))) assert_true((imputed.get(0, 1) - 5.0).abs() < 0.001) @@ -563,10 +539,7 @@ test "qf_impute_knn" { ///| test "qf_impute_mean" { // Col means (skip NaN): col0 = (1+4)/2 = 2.5, col1 = 5.0, col2 = (3+6)/2 = 4.5 - let data : Array[Array[Double]] = [ - [1.0, Double::nan(), 3.0], - [4.0, 5.0, 6.0], - ] + let data : Array[Array[Double]] = [[1.0, Double::nan(), 3.0], [4.0, 5.0, 6.0]] let assay = @src.QfAssay::new("a", ["r0", "r1"], ["c0", "c1", "c2"], data) let imputed = @src.qf_impute_mean(assay) assert_true((imputed.get(0, 1) - 5.0).abs() < 0.001) @@ -580,10 +553,7 @@ test "qf_impute_mean" { ///| test "qf_impute_zero" { - let data : Array[Array[Double]] = [ - [1.0, Double::nan()], - [Double::nan(), 2.0], - ] + let data : Array[Array[Double]] = [[1.0, Double::nan()], [Double::nan(), 2.0]] let assay = @src.QfAssay::new("a", ["r0", "r1"], ["c0", "c1"], data) let imputed = @src.qf_impute_zero(assay) assert_true((imputed.get(0, 0) - 1.0).abs() < 0.001) @@ -624,10 +594,7 @@ test "qf_summary" { ///| test "qf_assay_summary" { - let data : Array[Array[Double]] = [ - [1.0, 2.0], - [3.0, 4.0], - ] + let data : Array[Array[Double]] = [[1.0, 2.0], [3.0, 4.0]] let assay = @src.QfAssay::new("myassay", ["r0", "r1"], ["c0", "c1"], data) let s = @src.qf_assay_summary(assay) assert_true(s.length() > 0) @@ -639,10 +606,7 @@ test "qf_assay_summary" { ///| test "qf_to_long_format" { let qf = @src.QFeatures::new() - let data : Array[Array[Double]] = [ - [1.0, 2.0], - [3.0, 4.0], - ] + let data : Array[Array[Double]] = [[1.0, 2.0], [3.0, 4.0]] qf.add_assay(@src.QfAssay::new("a", ["r0", "r1"], ["c0", "c1"], data)) let long = @src.qf_to_long_format(qf, "a") assert_eq(long.length(), 4) @@ -761,10 +725,7 @@ test "qf_edge_case_single_cell_assay" { ///| test "qf_edge_case_all_nan_assay" { let nan = Double::nan() - let data : Array[Array[Double]] = [ - [nan, nan], - [nan, nan], - ] + let data : Array[Array[Double]] = [[nan, nan], [nan, nan]] let assay = @src.QfAssay::new("allnan", ["r0", "r1"], ["c0", "c1"], data) assert_eq(@src.qf_count_na(assay), 4) let by_row = @src.qf_count_na_by_row(assay) diff --git a/test/moonbit/qvalue_test.mbt b/test/moonbit/qvalue_test.mbt index 781214d5..acc2f062 100644 --- a/test/moonbit/qvalue_test.mbt +++ b/test/moonbit/qvalue_test.mbt @@ -210,14 +210,7 @@ test "qvalue_result_creation" { let pvals = [0.01, 0.05] let qvals = [0.02, 0.06] let sig = [true, false] - let result = @src.QValueResult::new( - pvals, - qvals, - 0.8, - 0.5, - 0.75, - sig, - ) + let result = @src.QValueResult::new(pvals, qvals, 0.8, 0.5, 0.75, sig) assert_eq(result.p_values().length(), 2) assert_eq(result.q_values().length(), 2) assert_true(result.pi0() > 0.79 && result.pi0() < 0.81) @@ -348,4 +341,4 @@ test "qvalue_near_zero" { assert_true(qvals[i] >= 0.0 && qvals[i] <= 1.0) i = i + 1 } -} \ No newline at end of file +} diff --git a/test/moonbit/ragged_experiment_test.mbt b/test/moonbit/ragged_experiment_test.mbt index de7f7167..e6094b91 100644 --- a/test/moonbit/ragged_experiment_test.mbt +++ b/test/moonbit/ragged_experiment_test.mbt @@ -1,11 +1,13 @@ ///| /// Test file for RaggedExperiment module. - test "mutation_record_creation" { let mr = @src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", ) assert_eq(mr.sample_id, "S1") assert_eq(mr.gene_symbol, "TP53") @@ -14,43 +16,58 @@ test "mutation_record_creation" { assert_eq(mr.mutation_type, @src.mutation_missense()) } +///| test "mutation_record_mutation_id" { let mr = @src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", ) let id = mr.mutation_id() assert_true(id.contains("TP53")) assert_true(id.contains("chr17")) } +///| test "mutation_record_is_los" { let missense = @src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", mutation_type=@src.mutation_missense(), ) assert_false(missense.is_loss_of_function()) let nonsense = @src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", mutation_type=@src.mutation_nonsense(), ) assert_true(nonsense.is_loss_of_function()) let fs = @src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", mutation_type=@src.mutation_fs_del(), ) assert_true(fs.is_loss_of_function()) } +///| test "mutation_type_to_string" { assert_eq(@src.mutation_missense().to_string(), "Missense_Mutation") assert_eq(@src.mutation_nonsense().to_string(), "Nonsense_Mutation") @@ -60,112 +77,182 @@ test "mutation_type_to_string" { assert_eq(@src.mutation_silent().to_string(), "Silent_Mutation") } +///| test "ragged_experiment_empty" { let exp = @src.RaggedExperiment::new() assert_eq(exp.n_rows(), 0) assert_eq(exp.n_cols(), 0) } +///| test "ragged_experiment_add_record" { let exp = @src.RaggedExperiment::new() let mr = @src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", ) exp.add_record(mr) assert_eq(exp.n_rows(), 1) assert_eq(exp.n_cols(), 1) } +///| test "ragged_experiment_multiple_genes" { let exp = @src.RaggedExperiment::new() - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="KRAS", - chrom="chr12", pos=25398284, - ref_allele="G", alt_allele="T", - )) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="KRAS", + chrom="chr12", + pos=25398284, + ref_allele="G", + alt_allele="T", + ), + ) assert_eq(exp.n_rows(), 2) assert_eq(exp.n_cols(), 1) } +///| test "ragged_experiment_multiple_samples" { let exp = @src.RaggedExperiment::new() - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S2", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S2", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) assert_eq(exp.n_rows(), 1) assert_eq(exp.n_cols(), 2) } +///| test "ragged_experiment_get_records" { let exp = @src.RaggedExperiment::new() - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7578000, - ref_allele="G", alt_allele="A", - )) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7578000, + ref_allele="G", + alt_allele="A", + ), + ) let recs = exp.get_records(gene="TP53", sample="S1") assert_eq(recs.length(), 2) } +///| test "ragged_experiment_get_gene_records" { let exp = @src.RaggedExperiment::new() - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S2", gene_symbol="TP53", - chrom="chr17", pos=7578000, - ref_allele="G", alt_allele="A", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="KRAS", - chrom="chr12", pos=25398284, - ref_allele="G", alt_allele="T", - )) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S2", + gene_symbol="TP53", + chrom="chr17", + pos=7578000, + ref_allele="G", + alt_allele="A", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="KRAS", + chrom="chr12", + pos=25398284, + ref_allele="G", + alt_allele="T", + ), + ) let tp53_recs = exp.get_gene_records(gene="TP53") assert_eq(tp53_recs.length(), 2) } +///| test "ragged_experiment_get_sample_records" { let exp = @src.RaggedExperiment::new() - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="KRAS", - chrom="chr12", pos=25398284, - ref_allele="G", alt_allele="T", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S2", gene_symbol="MYC", - chrom="chr8", pos=128748315, - ref_allele="C", alt_allele="A", - )) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="KRAS", + chrom="chr12", + pos=25398284, + ref_allele="G", + alt_allele="T", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S2", + gene_symbol="MYC", + chrom="chr8", + pos=128748315, + ref_allele="C", + alt_allele="A", + ), + ) let s1_recs = exp.get_sample_records(sample="S1") assert_eq(s1_recs.length(), 2) @@ -174,23 +261,39 @@ test "ragged_experiment_get_sample_records" { assert_eq(s2_recs.length(), 1) } +///| test "ragged_experiment_tmb" { let exp = @src.RaggedExperiment::new() - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="KRAS", - chrom="chr12", pos=25398284, - ref_allele="G", alt_allele="T", - )) - exp.add_record(@src.MutationRecord::new( - sample_id="S2", gene_symbol="TP53", - chrom="chr17", pos=7578000, - ref_allele="G", alt_allele="A", - )) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="KRAS", + chrom="chr12", + pos=25398284, + ref_allele="G", + alt_allele="T", + ), + ) + exp.add_record( + @src.MutationRecord::new( + sample_id="S2", + gene_symbol="TP53", + chrom="chr17", + pos=7578000, + ref_allele="G", + alt_allele="A", + ), + ) let tmb = exp.get_tmb() assert_eq(tmb.length(), 2) @@ -198,66 +301,84 @@ test "ragged_experiment_tmb" { assert_eq(tmb[1], 1.0) } +///| test "ragged_experiment_tmb_per_mb" { let exp = @src.RaggedExperiment::new() - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) let tmb_mb = exp.get_tmb_per_mb(genome_size_mb=3000.0) assert_true(tmb_mb.length() > 0) assert_true(tmb_mb[0] > 0.0) } +///| test "ragged_experiment_summary" { let exp = @src.RaggedExperiment::new() - exp.add_record(@src.MutationRecord::new( - sample_id="S1", gene_symbol="TP53", - chrom="chr17", pos=7577121, - ref_allele="C", alt_allele="T", - )) + exp.add_record( + @src.MutationRecord::new( + sample_id="S1", + gene_symbol="TP53", + chrom="chr17", + pos=7577121, + ref_allele="C", + alt_allele="T", + ), + ) let summary = exp.summary() assert_true(summary.length() > 0) } +///| test "ragged_experiment_filter_by_type" { let exp = @src.ragged_sample_data() let types : Array[@src.MutationType] = Array::new() types.push(@src.mutation_nonsense()) - let filtered = exp.filter_by_type(types=types) + let filtered = exp.filter_by_type(types~) assert_true(filtered.n_rows() > 0) } +///| test "ragged_experiment_filter_by_genes" { let exp = @src.ragged_sample_data() let genes : Array[String] = Array::new() genes.push("TP53") - let filtered = exp.filter_by_genes(genes=genes) + let filtered = exp.filter_by_genes(genes~) assert_eq(filtered.n_rows(), 1) } +///| test "ragged_experiment_filter_by_samples" { let exp = @src.ragged_sample_data() let samples : Array[String] = Array::new() samples.push("Sample1") - let filtered = exp.filter_by_samples(samples=samples) + let filtered = exp.filter_by_samples(samples~) assert_eq(filtered.n_cols(), 1) } +///| test "ragged_experiment_genes_mutated_per_sample" { let exp = @src.ragged_sample_data() let mutated = exp.genes_mutated_per_sample() assert_true(mutated.length() > 0) } +///| test "ragged_experiment_count_matrix" { let exp = @src.ragged_sample_data() let matrix = exp.get_count_matrix() assert_true(matrix.length() > 0) } +///| test "ragged_sample_data" { let exp = @src.ragged_sample_data() assert_true(exp.n_rows() > 0) diff --git a/test/moonbit/ranged_summarized_experiment_test.mbt b/test/moonbit/ranged_summarized_experiment_test.mbt index 634e79ae..a0f759dd 100644 --- a/test/moonbit/ranged_summarized_experiment_test.mbt +++ b/test/moonbit/ranged_summarized_experiment_test.mbt @@ -1,52 +1,45 @@ ///| fn rse_test_object() -> @src.RangedSummarizedExperiment { - try { - @src.RangedSummarizedExperiment::new( - assays=Map([ - ( - "counts", - [ - [30.0, 31.0, 32.0], - [10.0, 11.0, 12.0], - [20.0, 21.0, 22.0], - [40.0, 41.0, 42.0], - ], - ), - ( - "normalized", - [ - [3.0, 3.1, 3.2], - [1.0, 1.1, 1.2], - [2.0, 2.1, 2.2], - [4.0, 4.1, 4.2], - ], - ), - ]), - row_ranges=@src.granges( - ["chr2", "chr1", "chr1", "chr3"], - [(300, 349), (100, 149), (200, 249), (50, 99)], + @src.RangedSummarizedExperiment::new( + assays=Map([ + ( + "counts", [ - @src.strand_plus(), - @src.strand_plus(), - @src.strand_minus(), - @src.strand_star(), + [30.0, 31.0, 32.0], + [10.0, 11.0, 12.0], + [20.0, 21.0, 22.0], + [40.0, 41.0, 42.0], ], ), - col_data=[ - Map([("sample", "S1")]), - Map([("sample", "S2")]), - Map([("sample", "S3")]), - ], - row_data=[ - Map([("type", "geneC")]), - Map([("type", "geneA")]), - Map([("type", "geneB")]), - Map([("type", "geneD")]), + ( + "normalized", + [[3.0, 3.1, 3.2], [1.0, 1.1, 1.2], [2.0, 2.1, 2.2], [4.0, 4.1, 4.2]], + ), + ]), + row_ranges=@src.granges( + ["chr2", "chr1", "chr1", "chr3"], + [(300, 349), (100, 149), (200, 249), (50, 99)], + [ + @src.strand_plus(), + @src.strand_plus(), + @src.strand_minus(), + @src.strand_star(), ], - row_names=["geneC", "geneA", "geneB", "geneD"], - metadata=Map([("study", "airway-like")]), - ) - } catch { + ), + col_data=[ + Map([("sample", "S1")]), + Map([("sample", "S2")]), + Map([("sample", "S3")]), + ], + row_data=[ + Map([("type", "geneC")]), + Map([("type", "geneA")]), + Map([("type", "geneB")]), + Map([("type", "geneD")]), + ], + row_names=["geneC", "geneA", "geneB", "geneD"], + metadata=Map([("study", "airway-like")]), + ) catch { _ => abort("failed to construct RangedSummarizedExperiment fixture") } } @@ -75,12 +68,7 @@ test "ranged_summarized_experiment: rejects assay row mismatch" { ignore( @src.RangedSummarizedExperiment::new( assays=Map([("counts", [[1.0, 2.0], [3.0, 4.0]])]), - row_ranges=@src.granges_single( - "chr1", - 1, - 10, - @src.strand_plus(), - ), + row_ranges=@src.granges_single("chr1", 1, 10, @src.strand_plus()), col_data=[Map([]), Map([])], ), ) @@ -97,11 +85,10 @@ test "ranged_summarized_experiment: rejects parallel annotation mismatch" { ignore( @src.RangedSummarizedExperiment::new( assays=Map([("counts", [[1.0], [2.0]])]), - row_ranges=@src.granges( - ["chr1", "chr1"], - [(1, 10), (20, 30)], - [@src.strand_plus(), @src.strand_plus()], - ), + row_ranges=@src.granges(["chr1", "chr1"], [(1, 10), (20, 30)], [ + @src.strand_plus(), + @src.strand_plus(), + ]), col_data=[Map([])], row_data=[Map([("id", "only-one")])], ), @@ -121,17 +108,14 @@ test "ranged_summarized_experiment: attach ranges to existing experiment" { [Map([("sample", "A")]), Map([("sample", "B")])], Map([("source", "existing")]), ) - let rse = try { - @src.RangedSummarizedExperiment::from_experiment( - experiment~, - row_ranges=@src.granges( - ["chr1", "chr2"], - [(10, 20), (30, 40)], - [@src.strand_plus(), @src.strand_minus()], - ), - row_names=["a", "b"], - ) - } catch { + let rse = @src.RangedSummarizedExperiment::from_experiment( + experiment~, + row_ranges=@src.granges(["chr1", "chr2"], [(10, 20), (30, 40)], [ + @src.strand_plus(), + @src.strand_minus(), + ]), + row_names=["a", "b"], + ) catch { _ => abort("failed to attach ranges") } assert_true(rse.is_valid()) @@ -201,10 +185,12 @@ test "ranged_summarized_experiment: strand-aware overlaps" { assert_eq(rse.find_overlaps(subject), [(0, 3), (1, 0), (3, 2)]) assert_eq(rse.count_overlaps(subject), [1, 1, 0, 1]) assert_eq(rse.overlaps_any(subject), [true, true, false, true]) - assert_eq( - rse.find_overlaps(subject, ignore_strand=true), - [(0, 3), (1, 0), (2, 1), (3, 2)], - ) + assert_eq(rse.find_overlaps(subject, ignore_strand=true), [ + (0, 3), + (1, 0), + (2, 1), + (3, 2), + ]) } ///| @@ -218,8 +204,7 @@ test "ranged_summarized_experiment: subset by overlaps keeps each row once" { assert_eq(subset.nrow(), 2) assert_eq(subset.row_names(), ["geneA", "geneB"]) match subset.assay("counts") { - Some(assay) => - assert_eq(assay, [[10.0, 11.0, 12.0], [20.0, 21.0, 22.0]]) + Some(assay) => assert_eq(assay, [[10.0, 11.0, 12.0], [20.0, 21.0, 22.0]]) None => assert_true(false) } } @@ -238,11 +223,7 @@ test "ranged_summarized_experiment: nearest and distance" { ///| test "ranged_summarized_experiment: coverage delegates to row ranges" { - let sequence_lengths = Map([ - ("chr1", 260), - ("chr2", 350), - ("chr3", 100), - ]) + let sequence_lengths = Map([("chr1", 260), ("chr2", 350), ("chr3", 100)]) let coverage = rse_test_object().coverage(sequence_lengths) assert_eq(coverage["chr1"][99], 1) assert_eq(coverage["chr1"][149], 0) @@ -318,13 +299,11 @@ test "ranged_summarized_experiment: replacing ranges validates length" { ///| test "ranged_summarized_experiment: empty container" { - let rse = try { - @src.RangedSummarizedExperiment::new( - assays=Map([]), - row_ranges=@src.granges([], [], []), - col_data=[], - ) - } catch { + let rse = @src.RangedSummarizedExperiment::new( + assays=Map([]), + row_ranges=@src.granges([], [], []), + col_data=[], + ) catch { _ => abort("failed to construct empty RangedSummarizedExperiment") } assert_true(rse.is_valid()) diff --git a/test/moonbit/reference_test.mbt b/test/moonbit/reference_test.mbt index a8dadb76..e936cc79 100644 --- a/test/moonbit/reference_test.mbt +++ b/test/moonbit/reference_test.mbt @@ -1,32 +1,43 @@ ///| /// Test file for reference module. - test "reference_create_basic" { - let r = @src.BioReference::new(title="Test Paper", authors="Smith J", journal="Nature", year="2024") - assert_eq!(r.title(), "Test Paper") - assert_eq!(r.authors(), "Smith J") - assert_eq!(r.journal(), "Nature") - assert_eq!(r.year(), "2024") - assert_eq!(r.pubmed_id(), "") - assert_eq!(r.doi(), "") - assert_eq!(r.reference_type(), "journal article") + let r = @src.BioReference::new( + title="Test Paper", + authors="Smith J", + journal="Nature", + year="2024", + ) + assert_eq(r.title(), "Test Paper") + assert_eq(r.authors(), "Smith J") + assert_eq(r.journal(), "Nature") + assert_eq(r.year(), "2024") + assert_eq(r.pubmed_id(), "") + assert_eq(r.doi(), "") + assert_eq(r.reference_type(), "journal article") } +///| test "reference_with_pubmed" { - let r = @src.BioReference::with_pubmed("CRISPR Advances", "Doudna J", "Science", "2020", "12345678") - assert_eq!(r.pubmed_id(), "12345678") - assert_eq!(r.title(), "CRISPR Advances") + let r = @src.BioReference::with_pubmed( + "CRISPR Advances", "Doudna J", "Science", "2020", "12345678", + ) + assert_eq(r.pubmed_id(), "12345678") + assert_eq(r.title(), "CRISPR Advances") let citation = r.citation() - assert_eq!(citation.contains("12345678"), true) - assert_eq!(citation.contains("Doudna J"), true) + assert_eq(citation.contains("12345678"), true) + assert_eq(citation.contains("Doudna J"), true) } +///| test "reference_with_doi" { - let r = @src.BioReference::with_doi("Protein Folding", "Jones A", "Cell", "2023", "10.1000/test") - assert_eq!(r.doi(), "10.1000/test") - assert_eq!(r.citation().contains("10.1000/test"), true) + let r = @src.BioReference::with_doi( + "Protein Folding", "Jones A", "Cell", "2023", "10.1000/test", + ) + assert_eq(r.doi(), "10.1000/test") + assert_eq(r.citation().contains("10.1000/test"), true) } +///| test "reference_setters" { let r = @src.BioReference::new() r.set_title("New Title") @@ -36,107 +47,132 @@ test "reference_setters" { r.set_pubmed_id("99999") r.set_doi("10.999/test") r.set_type("book") - assert_eq!(r.title(), "New Title") - assert_eq!(r.authors(), "New Author") - assert_eq!(r.journal(), "New Journal") - assert_eq!(r.year(), "2025") - assert_eq!(r.pubmed_id(), "99999") - assert_eq!(r.doi(), "10.999/test") - assert_eq!(r.reference_type(), "book") + assert_eq(r.title(), "New Title") + assert_eq(r.authors(), "New Author") + assert_eq(r.journal(), "New Journal") + assert_eq(r.year(), "2025") + assert_eq(r.pubmed_id(), "99999") + assert_eq(r.doi(), "10.999/test") + assert_eq(r.reference_type(), "book") } +///| test "reference_locations" { let r = @src.BioReference::new(title="Test", authors="A") r.add_location(1, 100) r.add_location(200, 350) - assert_eq!(r.get_n_locations(), 2) + assert_eq(r.get_n_locations(), 2) let (s1, e1) = r.get_location(0) - assert_eq!(s1, 1) - assert_eq!(e1, 100) + assert_eq(s1, 1) + assert_eq(e1, 100) let (s2, e2) = r.get_location(1) - assert_eq!(s2, 200) - assert_eq!(e2, 350) + assert_eq(s2, 200) + assert_eq(e2, 350) // Out of bounds returns (0,0) let (s3, e3) = r.get_location(5) - assert_eq!(s3, 0) - assert_eq!(e3, 0) + assert_eq(s3, 0) + assert_eq(e3, 0) } +///| test "reference_comment" { let r = @src.BioReference::new(title="Test", authors="A") r.set_comment("Important discovery") - assert_eq!(r.get_comment(), "Important discovery") + assert_eq(r.get_comment(), "Important discovery") } +///| test "reference_citation" { - let r = @src.BioReference::with_pubmed("Genome Study", "Smith J, Jones A", "Science", "2022", "12345") + let r = @src.BioReference::with_pubmed( + "Genome Study", "Smith J, Jones A", "Science", "2022", "12345", + ) let citation = r.citation() - assert_eq!(citation.contains("Smith J"), true) - assert_eq!(citation.contains("Genome Study"), true) - assert_eq!(citation.contains("Science"), true) - assert_eq!(citation.contains("2022"), true) - assert_eq!(citation.contains("PMID: 12345"), true) + assert_eq(citation.contains("Smith J"), true) + assert_eq(citation.contains("Genome Study"), true) + assert_eq(citation.contains("Science"), true) + assert_eq(citation.contains("2022"), true) + assert_eq(citation.contains("PMID: 12345"), true) } +///| test "reference_list_basic" { let list = @src.ReferenceList::new() - assert_eq!(list.count(), 0) + assert_eq(list.count(), 0) let r = @src.BioReference::new(title="Test", authors="A") list.add(r) - assert_eq!(list.count(), 1) + assert_eq(list.count(), 1) let retrieved = list.get(0) - assert_eq!(retrieved.title(), "Test") + assert_eq(retrieved.title(), "Test") } +///| test "reference_list_by_author" { let list = @src.ReferenceList::new() list.add(@src.BioReference::new(title="Paper 1", authors="Smith J")) list.add(@src.BioReference::new(title="Paper 2", authors="Jones A")) list.add(@src.BioReference::new(title="Paper 3", authors="Smith J, Lee K")) let smith_papers = list.by_author("Smith J") - assert_eq!(smith_papers.length(), 2) + assert_eq(smith_papers.length(), 2) let jones_papers = list.by_author("Jones A") - assert_eq!(jones_papers.length(), 1) + assert_eq(jones_papers.length(), 1) let doe_papers = list.by_author("Doe X") - assert_eq!(doe_papers.length(), 0) + assert_eq(doe_papers.length(), 0) } +///| test "reference_list_by_year" { let list = @src.ReferenceList::new() list.add(@src.BioReference::new(title="Paper 1", year="2020")) list.add(@src.BioReference::new(title="Paper 2", year="2022")) list.add(@src.BioReference::new(title="Paper 3", year="2020")) let y2020 = list.by_year("2020") - assert_eq!(y2020.length(), 2) + assert_eq(y2020.length(), 2) let y2022 = list.by_year("2022") - assert_eq!(y2022.length(), 1) + assert_eq(y2022.length(), 1) } +///| test "reference_list_with_pubmed" { let list = @src.ReferenceList::new() list.add(@src.BioReference::with_pubmed("P1", "A", "J", "2020", "11111")) list.add(@src.BioReference::new(title="P2", authors="B")) list.add(@src.BioReference::with_pubmed("P3", "C", "J", "2022", "22222")) let with_pm = list.with_pubmed() - assert_eq!(with_pm.length(), 2) + assert_eq(with_pm.length(), 2) } +///| test "reference_list_bibliography" { let list = @src.ReferenceList::new() - list.add(@src.BioReference::new(title="Paper 1", authors="Smith J", journal="Nature", year="2020")) - list.add(@src.BioReference::new(title="Paper 2", authors="Jones A", journal="Science", year="2022")) + list.add( + @src.BioReference::new( + title="Paper 1", + authors="Smith J", + journal="Nature", + year="2020", + ), + ) + list.add( + @src.BioReference::new( + title="Paper 2", + authors="Jones A", + journal="Science", + year="2022", + ), + ) let bib = list.bibliography() - assert_eq!(bib.contains("1. Smith J"), true) - assert_eq!(bib.contains("2. Jones A"), true) - assert_eq!(bib.contains("Nature"), true) - assert_eq!(bib.contains("Science"), true) + assert_eq(bib.contains("1. Smith J"), true) + assert_eq(bib.contains("2. Jones A"), true) + assert_eq(bib.contains("Nature"), true) + assert_eq(bib.contains("Science"), true) } +///| test "reference_sample_data" { let list = @src.reference_sample_data() - assert_eq!(list.count(), 3) + assert_eq(list.count(), 3) let ref1 = list.get(0) - assert_eq!(ref1.title(), "The Human Genome: A Complete Sequence") - assert_eq!(ref1.pubmed_id(), "36189102") - assert_eq!(ref1.get_n_locations(), 1) + assert_eq(ref1.title(), "The Human Genome: A Complete Sequence") + assert_eq(ref1.pubmed_id(), "36189102") + assert_eq(ref1.get_n_locations(), 1) } diff --git a/test/moonbit/reporting_tools_test.mbt b/test/moonbit/reporting_tools_test.mbt index b11be733..14b1b9ec 100644 --- a/test/moonbit/reporting_tools_test.mbt +++ b/test/moonbit/reporting_tools_test.mbt @@ -1,6 +1,5 @@ ///| /// Test file for ReportingTools module. - test "report_new" { let doc = @src.ReportDocument::new("Test Report") assert_eq(doc.get_title(), "Test Report") @@ -8,12 +7,14 @@ test "report_new" { assert_eq(doc.get_n_sections(), 0) } +///| test "report_set_author" { let doc = @src.ReportDocument::new("Test") let doc2 = doc.set_author("User") assert_eq(doc2.get_author(), "User") } +///| test "report_add_text" { let doc = @src.ReportDocument::new("Test") let doc2 = doc.add_text("sec1", "Introduction", "This is a test report.") @@ -22,20 +23,29 @@ test "report_add_text" { assert_eq(sec.title, "Introduction") } +///| test "report_add_table" { let doc = @src.ReportDocument::new("Test") - let table = @src.ReportTable::new("table1", "Results", ["Gene", "log2FC", "p-value"], [["TP53", "BRCA1"], ["2.5", "-3.0"], ["0.001", "0.005"]], "Differential expression results") + let table = @src.ReportTable::new( + "table1", + "Results", + ["Gene", "log2FC", "p-value"], + [["TP53", "BRCA1"], ["2.5", "-3.0"], ["0.001", "0.005"]], + "Differential expression results", + ) let doc2 = doc.add_table("tab1", table) assert_eq(doc2.get_n_tables(), 1) assert_eq(doc2.get_n_sections(), 1) } +///| test "report_add_plot" { let doc = @src.ReportDocument::new("Test") let doc2 = doc.add_plot("plot1", "Volcano Plot", " +\n o\n----\n") assert_eq(doc2.get_n_sections(), 1) } +///| test "report_get_section" { let doc = @src.ReportDocument::new("Test") let doc2 = doc.add_text("sec1", "Section 1", "Content 1") @@ -44,12 +54,14 @@ test "report_get_section" { assert_eq(sec.content, "Content 1") } +///| test "report_get_section_not_found" { let doc = @src.ReportDocument::new("Test") let sec = doc.get_section("nonexistent") assert_eq(sec.section_id, "") } +///| test "report_column_new" { let col = @src.ReportColumn::new("Gene", ["TP53", "BRCA1"], false) assert_eq(col.name, "Gene") @@ -57,21 +69,36 @@ test "report_column_new" { assert_eq(col.numeric, false) } +///| test "report_table_new" { - let table = @src.ReportTable::new("t1", "Test Table", ["A", "B"], [["x", "y"], ["1", "2"]], "A test caption") + let table = @src.ReportTable::new( + "t1", + "Test Table", + ["A", "B"], + [["x", "y"], ["1", "2"]], + "A test caption", + ) assert_eq(table.get_n_rows(), 2) assert_eq(table.get_n_columns(), 2) assert_eq(table.get_column_names(), ["A", "B"]) } +///| test "report_table_to_ascii" { - let table = @src.ReportTable::new("t1", "Test", ["Name", "Value"], [["Item1", "Item2"], ["100", "200"]], "Caption") + let table = @src.ReportTable::new( + "t1", + "Test", + ["Name", "Value"], + [["Item1", "Item2"], ["100", "200"]], + "Caption", + ) let ascii = table.to_ascii() assert_true(ascii.contains("Test")) assert_true(ascii.contains("Name")) assert_true(ascii.contains("Item1")) } +///| test "report_render" { let doc = @src.ReportDocument::new("My Report") let doc2 = doc.add_text("intro", "Introduction", "This is the introduction.") @@ -82,6 +109,7 @@ test "report_render" { assert_true(rendered.contains("Methods")) } +///| test "report_summary" { let doc = @src.ReportDocument::new("Test") let doc2 = doc.add_text("sec1", "Section", "Content") @@ -90,6 +118,7 @@ test "report_summary" { assert_true(summary.contains("Sections: 1")) } +///| test "report_multiple_sections" { let doc = @src.ReportDocument::new("Multi") let doc2 = doc.add_text("s1", "S1", "C1") @@ -98,14 +127,21 @@ test "report_multiple_sections" { assert_eq(doc4.get_n_sections(), 3) } +///| test "report_table_from_columns" { let col1 = @src.ReportColumn::new("Gene", ["TP53", "BRCA1"], false) let col2 = @src.ReportColumn::new("log2FC", ["2.5", "-3.0"], true) - let table = @src.ReportTable::from_columns("t1", "Results", [col1, col2], "DE results") + let table = @src.ReportTable::from_columns( + "t1", + "Results", + [col1, col2], + "DE results", + ) assert_eq(table.get_n_columns(), 2) assert_eq(table.get_n_rows(), 2) } +///| test "report_section_type_to_string" { let text = @src.report_section_text() assert_eq(text.to_string(), "text") @@ -115,14 +151,22 @@ test "report_section_type_to_string" { assert_eq(plot.to_string(), "plot") } +///| test "report_render_with_table" { let doc = @src.ReportDocument::new("Test with Table") - let table = @src.ReportTable::new("results", "Results", ["Gene", "Value"], [["A", "B"], ["1", "2"]], "") + let table = @src.ReportTable::new( + "results", + "Results", + ["Gene", "Value"], + [["A", "B"], ["1", "2"]], + "", + ) let doc2 = doc.add_table("tab", table) let rendered = doc2.render() assert_true(rendered.contains("Results")) } +///| test "report_empty_render" { let doc = @src.ReportDocument::new("Empty Report") let rendered = doc.render() @@ -130,10 +174,17 @@ test "report_empty_render" { assert_true(rendered.contains("Sections: 0")) } +///| test "report_padding_func" { // Test that the pad logic works through to_ascii - let table = @src.ReportTable::new("t1", "Pad Test", ["Col1", "Col2"], [["Short", "LongerValue"], ["1", "2"]], "") + let table = @src.ReportTable::new( + "t1", + "Pad Test", + ["Col1", "Col2"], + [["Short", "LongerValue"], ["1", "2"]], + "", + ) let ascii = table.to_ascii() assert_true(ascii.contains("Short")) assert_true(ascii.contains("LongerValue")) -} \ No newline at end of file +} diff --git a/test/moonbit/residue_depth_test.mbt b/test/moonbit/residue_depth_test.mbt index edf593a9..1882e782 100644 --- a/test/moonbit/residue_depth_test.mbt +++ b/test/moonbit/residue_depth_test.mbt @@ -83,9 +83,7 @@ test "residue_depth_analyze" { ///| test "residue_depth_find_surface" { - let atoms1 = [ - @src.RDAtom::new("CA", @src.RDPoint3D::new(0.0, 0.0, 0.0), "C"), - ] + let atoms1 = [@src.RDAtom::new("CA", @src.RDPoint3D::new(0.0, 0.0, 0.0), "C")] let atoms2 = [ @src.RDAtom::new("CA", @src.RDPoint3D::new(100.0, 0.0, 0.0), "C"), ] @@ -106,9 +104,7 @@ test "residue_depth_find_core" { @src.RDAtom::new("CB", @src.RDPoint3D::new(0.5, 0.5, 0.5), "C"), @src.RDAtom::new("CG", @src.RDPoint3D::new(1.0, 1.0, 1.0), "C"), ] - let atoms2 = [ - @src.RDAtom::new("CA", @src.RDPoint3D::new(2.0, 0.0, 0.0), "C"), - ] + let atoms2 = [@src.RDAtom::new("CA", @src.RDPoint3D::new(2.0, 0.0, 0.0), "C")] let residues = [ @src.RDResidue::new("ALA", 1, atoms1), @src.RDResidue::new("GLY", 2, atoms2), @@ -130,4 +126,4 @@ test "residue_depth_average" { assert_eq(avg_ca, 3.0) assert_eq(avg_com, 4.0) -} \ No newline at end of file +} diff --git a/test/moonbit/rhdf5_test.mbt b/test/moonbit/rhdf5_test.mbt index cce6ad31..89052773 100644 --- a/test/moonbit/rhdf5_test.mbt +++ b/test/moonbit/rhdf5_test.mbt @@ -1,59 +1,83 @@ ///| /// Tests for rhdf5 module. - test "HDF5Attribute creation" { - let attr = @src.HDF5Attribute::new("species", "H5T_NATIVE_STRING", "Homo sapiens") + let attr = @src.HDF5Attribute::new( + "species", "H5T_NATIVE_STRING", "Homo sapiens", + ) assert_eq(attr.name, "species") } +///| test "HDF5Dataset creation" { let ds = @src.HDF5Dataset::new("expression", "H5T_NATIVE_DOUBLE", [100, 10]) assert_eq(ds.name, "expression") assert_eq(ds.dimensions.length(), 2) } +///| test "HDF5Group creation" { let group = @src.HDF5Group::new("/genome") assert_eq(group.name, "/genome") } +///| test "HDF5File creation" { let file = @src.h5create_file("test.h5") assert_eq(file.filename, "test.h5") } +///| test "h5create_dataset simple" { let file = @src.h5create_file("test.h5") - let file2 = @src.h5create_dataset(file, "/data/matrix", "H5T_NATIVE_DOUBLE", [3, 3]) + let file2 = @src.h5create_dataset(file, "/data/matrix", "H5T_NATIVE_DOUBLE", [ + 3, 3, + ]) let result = @src.h5read_dataset(file2, "/data/matrix") assert_true(result is Some(_)) } +///| test "h5write_dataset simple" { let file = @src.h5create_file("test.h5") - let file2 = @src.h5write_dataset(file, "/seq/dna", "ACGTACGT", "H5T_NATIVE_STRING", [8]) + let file2 = @src.h5write_dataset( + file, + "/seq/dna", + "ACGTACGT", + "H5T_NATIVE_STRING", + [8], + ) let result = @src.h5read_dataset(file2, "/seq/dna") assert_true(result is Some(_)) } +///| test "h5read_dataset" { let file = @src.h5create_file("test.h5") - let file2 = @src.h5write_dataset(file, "/data/values", "1.0,2.0,3.0", "H5T_NATIVE_DOUBLE", [3]) + let file2 = @src.h5write_dataset( + file, + "/data/values", + "1.0,2.0,3.0", + "H5T_NATIVE_DOUBLE", + [3], + ) let result = @src.h5read_dataset(file2, "/data/values") assert_true(result is Some(_)) } +///| test "h5ls" { let file = @src.h5create_example_file() let listing = @src.h5ls(file) assert_true(listing.length() > 0) } +///| test "h5create_example_file" { let file = @src.h5create_example_file() assert_eq(file.filename, "example.h5") } +///| test "HDF5Dataset add_attribute" { let ds = @src.HDF5Dataset::new("test", "H5T_NATIVE_INT", [10]) let attr = @src.HDF5Attribute::new("unit", "H5T_NATIVE_STRING", "counts") @@ -61,12 +85,14 @@ test "HDF5Dataset add_attribute" { assert_true(ds_with_attr.get_attribute("unit") is Some(_)) } +///| test "HDF5Group find_group" { let group = @src.HDF5Group::new("test") let result = group.find_group("data") assert_true(result is None) } +///| test "HDF5Group find_dataset" { let group = @src.HDF5Group::new("test") let result = group.find_dataset("data") diff --git a/test/moonbit/rna_structure_test.mbt b/test/moonbit/rna_structure_test.mbt index 39e87023..ad727a8e 100644 --- a/test/moonbit/rna_structure_test.mbt +++ b/test/moonbit/rna_structure_test.mbt @@ -1,6 +1,7 @@ ///| /// Tests for Bio.SeqUtils - RNA Secondary Structure Prediction +///| /// Helper: convert String to Array[UInt16] fn str_to_u16_array(s : String) -> Array[UInt16] { let arr : Array[UInt16] = Array::new() @@ -10,6 +11,7 @@ fn str_to_u16_array(s : String) -> Array[UInt16] { arr } +///| /// Helper: convert Char to UInt16 fn char_to_u16(c : Char) -> UInt16 { c.to_int().to_uint16() @@ -121,7 +123,9 @@ test "structure_to_dot_bracket" { assert_eq(dot.length(), seq.length()) for c in dot { let ch = c.to_int().to_uint16() - assert_true(ch == char_to_u16('(') || ch == char_to_u16(')') || ch == char_to_u16('.')) + assert_true( + ch == char_to_u16('(') || ch == char_to_u16(')') || ch == char_to_u16('.'), + ) } } @@ -171,9 +175,13 @@ test "valid_dot_bracket" { let dot = result.structure let mut open_count = 0 for c in dot { - if c == '(' { open_count = open_count + 1 } - if c == ')' { open_count = open_count - 1 } + if c == '(' { + open_count = open_count + 1 + } + if c == ')' { + open_count = open_count - 1 + } assert_true(open_count >= 0) } assert_eq(open_count, 0) -} \ No newline at end of file +} diff --git a/test/moonbit/rstatix_test.mbt b/test/moonbit/rstatix_test.mbt index b051b5fb..87ece02f 100644 --- a/test/moonbit/rstatix_test.mbt +++ b/test/moonbit/rstatix_test.mbt @@ -2,6 +2,7 @@ // ===== rstatix_t_test ===== +///| test "rstatix_t_test one-sample basic" { let x = [10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0] let result = @src.rstatix_t_test(x, mu=15.0) @@ -15,6 +16,7 @@ test "rstatix_t_test one-sample basic" { assert_eq(result.alternative, "two.sided") } +///| test "rstatix_t_test one-sample greater alternative" { let x = [10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0] let result = @src.rstatix_t_test(x, mu=15.0, alternative="greater") @@ -22,6 +24,7 @@ test "rstatix_t_test one-sample greater alternative" { assert_eq(result.alternative, "greater") } +///| test "rstatix_t_test one-sample less alternative" { let x = [10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0] let result = @src.rstatix_t_test(x, mu=25.0, alternative="less") @@ -29,6 +32,7 @@ test "rstatix_t_test one-sample less alternative" { assert_eq(result.alternative, "less") } +///| test "rstatix_t_test one-sample small array" { let x = [5.0, 6.0] let result = @src.rstatix_t_test(x, mu=0.0) @@ -36,10 +40,11 @@ test "rstatix_t_test one-sample small array" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_t_test two-sample Welch's basic" { let x = [10.0, 12.0, 15.0, 18.0, 20.0, 22.0, 25.0, 28.0, 30.0, 32.0] let y = [8.0, 9.0, 11.0, 12.0, 14.0, 15.0, 17.0, 19.0, 20.0, 22.0] - let result = @src.rstatix_t_test(x, y=y) + let result = @src.rstatix_t_test(x, y~) assert_eq(result.test_name, "t_test") assert_eq(result.method_name, "Welch's two-sample t-test") assert_true(result.statistic > 0.0) @@ -51,31 +56,35 @@ test "rstatix_t_test two-sample Welch's basic" { assert_true(result.se > 0.0) } +///| test "rstatix_t_test two-sample equal means" { let x = [5.0, 5.0, 5.0, 5.0, 5.0] let y = [5.0, 5.0, 5.0, 5.0, 5.0] - let result = @src.rstatix_t_test(x, y=y) + let result = @src.rstatix_t_test(x, y~) assert_true(result.p_value.is_nan()) } +///| test "rstatix_t_test paired basic" { let x = [10.0, 12.0, 15.0, 18.0, 20.0, 22.0, 25.0, 28.0, 30.0, 32.0] let y = [8.0, 9.0, 11.0, 12.0, 14.0, 15.0, 17.0, 19.0, 20.0, 22.0] - let result = @src.rstatix_t_test(x, y=y, paired=true) + let result = @src.rstatix_t_test(x, y~, paired=true) assert_eq(result.method_name, "Paired t-test") assert_true(result.statistic > 0.0) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) assert_true(result.ci_low < result.ci_high) } +///| test "rstatix_t_test paired different length" { let x = [10.0, 12.0, 15.0, 18.0, 20.0, 22.0, 25.0] let y = [8.0, 9.0, 11.0, 12.0, 14.0] - let result = @src.rstatix_t_test(x, y=y, paired=true) + let result = @src.rstatix_t_test(x, y~, paired=true) assert_true(result.n1 == 5) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_t_test confidence interval" { let x = [10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0] let result99 = @src.rstatix_t_test(x, mu=15.0, conf_level=0.99) @@ -86,6 +95,7 @@ test "rstatix_t_test confidence interval" { // ===== rstatix_wilcox_test ===== +///| test "rstatix_wilcox_test one-sample basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let result = @src.rstatix_wilcox_test(x, mu=5.0) @@ -95,6 +105,7 @@ test "rstatix_wilcox_test one-sample basic" { assert_true(result.n1 == 9) } +///| test "rstatix_wilcox_test one-sample too few observations" { let x = [1.0, 2.0, 3.0] let result = @src.rstatix_wilcox_test(x, mu=2.0) @@ -103,6 +114,7 @@ test "rstatix_wilcox_test one-sample too few observations" { assert_true(result.n1 == 2) } +///| test "rstatix_wilcox_test one-sample greater alternative" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let result = @src.rstatix_wilcox_test(x, mu=4.0, alternative="greater") @@ -110,10 +122,11 @@ test "rstatix_wilcox_test one-sample greater alternative" { assert_eq(result.alternative, "greater") } +///| test "rstatix_wilcox_test two-sample rank-sum basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] let y = [8.0, 9.0, 10.0, 11.0, 12.0, 13.0] - let result = @src.rstatix_wilcox_test(x, y=y) + let result = @src.rstatix_wilcox_test(x, y~) assert_eq(result.test_name, "wilcox_test") assert_eq(result.method_name, "Wilcoxon rank-sum test") assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) @@ -122,40 +135,45 @@ test "rstatix_wilcox_test two-sample rank-sum basic" { assert_true(result.n2 == 6) } +///| test "rstatix_wilcox_test two-sample too few observations" { let x = [1.0, 2.0] let y = [3.0, 4.0] - let result = @src.rstatix_wilcox_test(x, y=y) + let result = @src.rstatix_wilcox_test(x, y~) assert_true(result.p_value.is_nan()) assert_eq(result.n1, 2) assert_eq(result.n2, 2) } +///| test "rstatix_wilcox_test two-sample one group too small" { let x = [1.0, 2.0, 3.0] let y = [4.0, 5.0] - let result = @src.rstatix_wilcox_test(x, y=y) + let result = @src.rstatix_wilcox_test(x, y~) assert_true(result.p_value.is_nan()) } +///| test "rstatix_wilcox_test paired basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0] - let result = @src.rstatix_wilcox_test(x, y=y, paired=true) + let result = @src.rstatix_wilcox_test(x, y~, paired=true) assert_eq(result.method_name, "Paired Wilcoxon") assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) assert_true(!result.statistic.is_nan()) } +///| test "rstatix_wilcox_test paired with mu" { let x = [5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0] let y = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] - let result = @src.rstatix_wilcox_test(x, y=y, paired=true, mu=2.0) + let result = @src.rstatix_wilcox_test(x, y~, paired=true, mu=2.0) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } // ===== rstatix_cor_test ===== +///| test "rstatix_cor_test pearson basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0] @@ -175,6 +193,7 @@ test "rstatix_cor_test pearson basic" { assert_true(n_val == 10) } +///| test "rstatix_cor_test pearson negative" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [20.0, 18.0, 16.0, 14.0, 12.0, 10.0, 8.0, 6.0, 4.0, 2.0] @@ -183,6 +202,7 @@ test "rstatix_cor_test pearson negative" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_cor_test pearson no correlation" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0] @@ -191,6 +211,7 @@ test "rstatix_cor_test pearson no correlation" { assert_true(result.p_value.is_nan()) } +///| test "rstatix_cor_test spearman basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0] @@ -201,6 +222,7 @@ test "rstatix_cor_test spearman basic" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_cor_test spearman nonlinear" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [1.0, 4.0, 9.0, 16.0, 25.0, 36.0, 49.0, 64.0, 81.0, 100.0] @@ -209,6 +231,7 @@ test "rstatix_cor_test spearman nonlinear" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_cor_test kendall basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0] @@ -219,6 +242,7 @@ test "rstatix_cor_test kendall basic" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_cor_test kendall negative" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [20.0, 18.0, 16.0, 14.0, 12.0, 10.0, 8.0, 6.0, 4.0, 2.0] @@ -227,6 +251,7 @@ test "rstatix_cor_test kendall negative" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_cor_test mismatched length" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [1.0, 2.0, 3.0, 4.0] @@ -235,6 +260,7 @@ test "rstatix_cor_test mismatched length" { assert_true(result.p_value.is_nan()) } +///| test "rstatix_cor_test too small" { let x = [1.0, 2.0] let y = [3.0, 4.0] @@ -245,6 +271,7 @@ test "rstatix_cor_test too small" { // ===== rstatix_anova_test ===== +///| test "rstatix_anova_test basic" { let groups = [ [10.0, 12.0, 15.0, 18.0, 20.0], @@ -260,6 +287,7 @@ test "rstatix_anova_test basic" { assert_true(result.ms > 0.0) } +///| test "rstatix_anova_test equal groups" { let groups = [ [5.0, 5.0, 5.0, 5.0, 5.0], @@ -271,24 +299,22 @@ test "rstatix_anova_test equal groups" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_anova_test too few groups" { - let groups = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - ] + let groups = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let result = @src.rstatix_anova_test(groups) assert_true(result.p_value.is_nan()) assert_true(result.f.is_nan()) } +///| test "rstatix_anova_test two groups" { - let groups = [ - [1.0, 2.0, 3.0], - ] + let groups = [[1.0, 2.0, 3.0]] let result = @src.rstatix_anova_test(groups) assert_true(result.p_value.is_nan()) } +///| test "rstatix_anova_test four groups" { let groups = [ [1.0, 2.0, 3.0, 4.0, 5.0], @@ -303,6 +329,7 @@ test "rstatix_anova_test four groups" { // ===== rstatix_kruskal_test ===== +///| test "rstatix_kruskal_test basic" { let groups = [ [10.0, 12.0, 15.0, 18.0, 20.0], @@ -317,6 +344,7 @@ test "rstatix_kruskal_test basic" { assert_true(result.ss > 0.0) } +///| test "rstatix_kruskal_test equal groups" { let groups = [ [5.0, 5.0, 5.0, 5.0, 5.0], @@ -327,11 +355,9 @@ test "rstatix_kruskal_test equal groups" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_kruskal_test too few groups" { - let groups = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - ] + let groups = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let result = @src.rstatix_kruskal_test(groups) assert_true(result.p_value.is_nan()) assert_true(result.f.is_nan()) @@ -339,6 +365,7 @@ test "rstatix_kruskal_test too few groups" { // ===== rstatix_friedman_test ===== +///| test "rstatix_friedman_test basic" { let groups = [ [10.0, 12.0, 15.0, 18.0, 20.0], @@ -353,6 +380,7 @@ test "rstatix_friedman_test basic" { assert_true(result.ss > 0.0) } +///| test "rstatix_friedman_test equal groups" { let groups = [ [5.0, 5.0, 5.0, 5.0, 5.0], @@ -363,28 +391,24 @@ test "rstatix_friedman_test equal groups" { assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_friedman_test too few groups" { - let groups = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - ] + let groups = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] let result = @src.rstatix_friedman_test(groups) assert_true(result.p_value.is_nan()) assert_true(result.f.is_nan()) } +///| test "rstatix_friedman_test small blocks" { - let groups = [ - [1.0, 4.0], - [2.0, 5.0], - [3.0, 6.0], - ] + let groups = [[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]] let result = @src.rstatix_friedman_test(groups) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } // ===== rstatix_bh_correct ===== +///| test "rstatix_bh_correct basic" { let p_values = [0.01, 0.04, 0.03, 0.005, 0.2] let result = @src.rstatix_bh_correct(p_values) @@ -397,12 +421,14 @@ test "rstatix_bh_correct basic" { } } +///| test "rstatix_bh_correct empty" { let p_values : Array[Double] = Array::new() let result = @src.rstatix_bh_correct(p_values) assert_true(result.length() == 0) } +///| test "rstatix_bh_correct single" { let p_values = [0.05] let result = @src.rstatix_bh_correct(p_values) @@ -410,6 +436,7 @@ test "rstatix_bh_correct single" { assert_true(result[0] >= 0.05 - 1.0e-10 && result[0] <= 0.05 + 1.0e-10) } +///| test "rstatix_bh_correct all significant" { let p_values = [0.001, 0.002, 0.003, 0.004, 0.005] let result = @src.rstatix_bh_correct(p_values) @@ -421,6 +448,7 @@ test "rstatix_bh_correct all significant" { } } +///| test "rstatix_bh_correct all non-significant" { let p_values = [0.8, 0.9, 0.95, 0.98, 0.99] let result = @src.rstatix_bh_correct(p_values) @@ -433,6 +461,7 @@ test "rstatix_bh_correct all non-significant" { } } +///| test "rstatix_bh_correct preserves order" { let p_values = [0.2, 0.005, 0.04, 0.01, 0.03] let result = @src.rstatix_bh_correct(p_values) @@ -443,6 +472,7 @@ test "rstatix_bh_correct preserves order" { // ===== rstatix_bonferroni ===== +///| test "rstatix_bonferroni basic" { let p_values = [0.01, 0.04, 0.03, 0.005, 0.2] let result = @src.rstatix_bonferroni(p_values) @@ -452,12 +482,14 @@ test "rstatix_bonferroni basic" { assert_true(result[4] >= 1.0 - 1.0e-10) } +///| test "rstatix_bonferroni empty" { let p_values : Array[Double] = Array::new() let result = @src.rstatix_bonferroni(p_values) assert_true(result.length() == 0) } +///| test "rstatix_bonferroni single" { let p_values = [0.05] let result = @src.rstatix_bonferroni(p_values) @@ -465,6 +497,7 @@ test "rstatix_bonferroni single" { assert_true(result[0] >= 0.05 - 1.0e-10 && result[0] <= 0.05 + 1.0e-10) } +///| test "rstatix_bonferroni capped at 1" { let p_values = [0.3, 0.4, 0.5] let result = @src.rstatix_bonferroni(p_values) @@ -475,6 +508,7 @@ test "rstatix_bonferroni capped at 1" { // ===== Summary functions ===== +///| test "rstatix_t_test_summary basic" { let x = [10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0, 24.0, 26.0, 28.0] let result = @src.rstatix_t_test(x, mu=15.0) @@ -487,15 +521,17 @@ test "rstatix_t_test_summary basic" { assert_true(summary.contains("Method")) } +///| test "rstatix_t_test_summary two-sample" { let x = [10.0, 12.0, 15.0, 18.0, 20.0] let y = [8.0, 9.0, 11.0, 12.0, 14.0] - let result = @src.rstatix_t_test(x, y=y) + let result = @src.rstatix_t_test(x, y~) let summary = @src.rstatix_t_test_summary(result) assert_true(summary.contains("Group1")) assert_true(summary.contains("Group2")) } +///| test "rstatix_cor_test_summary basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0] @@ -509,6 +545,7 @@ test "rstatix_cor_test_summary basic" { assert_true(summary.contains("Method")) } +///| test "rstatix_cor_test_summary spearman" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0] @@ -517,6 +554,7 @@ test "rstatix_cor_test_summary spearman" { assert_true(summary.contains("spearman")) } +///| test "rstatix_anova_summary basic" { let groups = [ [10.0, 12.0, 15.0, 18.0, 20.0], @@ -535,6 +573,7 @@ test "rstatix_anova_summary basic" { assert_true(summary.contains("p-value")) } +///| test "rstatix_anova_summary kruskal" { let groups = [ [10.0, 12.0, 15.0, 18.0, 20.0], @@ -546,6 +585,7 @@ test "rstatix_anova_summary kruskal" { assert_true(summary.contains("Kruskal-Wallis")) } +///| test "rstatix_anova_summary friedman" { let groups = [ [10.0, 12.0, 15.0, 18.0, 20.0], @@ -559,6 +599,7 @@ test "rstatix_anova_summary friedman" { // ===== rstatix_sample_data ===== +///| test "rstatix_sample_data basic" { let data = @src.rstatix_sample_data() assert_true(data.length() == 3) @@ -567,6 +608,7 @@ test "rstatix_sample_data basic" { assert_true(data[2].length() == 10) } +///| test "rstatix_sample_data values" { let data = @src.rstatix_sample_data() assert_true(data[0][0] == 10.0) @@ -577,6 +619,7 @@ test "rstatix_sample_data values" { assert_true(data[2][9] == 14.0) } +///| test "rstatix_sample_data used in anova" { let data = @src.rstatix_sample_data() let result = @src.rstatix_anova_test(data) @@ -584,12 +627,14 @@ test "rstatix_sample_data used in anova" { assert_true(result.f > 0.0) } +///| test "rstatix_sample_data used in kruskal" { let data = @src.rstatix_sample_data() let result = @src.rstatix_kruskal_test(data) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_sample_data used in friedman" { let data = @src.rstatix_sample_data() let result = @src.rstatix_friedman_test(data) @@ -598,6 +643,7 @@ test "rstatix_sample_data used in friedman" { // ===== Edge cases and integration ===== +///| test "rstatix_t_test constant values" { let x = [5.0, 5.0, 5.0, 5.0, 5.0] let result = @src.rstatix_t_test(x, mu=5.0) @@ -605,18 +651,21 @@ test "rstatix_t_test constant values" { assert_true(result.p_value.is_nan()) } +///| test "rstatix_wilcox_test all zeros" { let x = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] let result = @src.rstatix_wilcox_test(x) assert_true(result.p_value.is_nan()) } +///| test "rstatix_cor_test identical values" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let result = @src.rstatix_cor_test(x, x) assert_true(result.statistic > 0.99 && result.statistic <= 1.0) } +///| test "rstatix_bh_correct preserves non-decreasing order" { let p_values = [0.001, 0.01, 0.03, 0.05, 0.1] let result = @src.rstatix_bh_correct(p_values) @@ -627,34 +676,41 @@ test "rstatix_bh_correct preserves non-decreasing order" { } } +///| test "rstatix_t_test_two_sample_same_values" { let x = [10.0, 10.0, 10.0, 10.0, 10.0] let y = [10.0, 10.0, 10.0, 10.0, 10.0] - let result = @src.rstatix_t_test(x, y=y) + let result = @src.rstatix_t_test(x, y~) assert_true(result.statistic.is_nan()) } +///| test "rstatix_anova_test with sample data from function" { let data = @src.rstatix_sample_data() - let result = @src.rstatix_anova_test(data, group_names=["GroupA", "GroupB", "GroupC"]) + let result = @src.rstatix_anova_test(data, group_names=[ + "GroupA", "GroupB", "GroupC", + ]) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_t_test paired with mu default" { let x = [10.0, 12.0, 15.0, 18.0, 20.0, 22.0, 25.0, 28.0, 30.0, 32.0] let y = [8.0, 9.0, 11.0, 12.0, 14.0, 15.0, 17.0, 19.0, 20.0, 22.0] - let result = @src.rstatix_t_test(x, y=y, paired=true) + let result = @src.rstatix_t_test(x, y~, paired=true) assert_true(result.statistic > 0.0) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_wilcox_test two-sample with different lengths" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0] let y = [9.0, 10.0, 11.0, 12.0, 13.0, 14.0] - let result = @src.rstatix_wilcox_test(x, y=y) + let result = @src.rstatix_wilcox_test(x, y~) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) } +///| test "rstatix_cor_test pearson default method" { let x = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0] @@ -662,6 +718,7 @@ test "rstatix_cor_test pearson default method" { assert_eq(result.method_name, "Pearson's product-moment correlation") } +///| test "rstatix_kruskal_test with sample data" { let data = @src.rstatix_sample_data() let result = @src.rstatix_kruskal_test(data, _group_names=["A", "B", "C"]) @@ -669,9 +726,10 @@ test "rstatix_kruskal_test with sample data" { assert_true(result.source == "Kruskal-Wallis") } +///| test "rstatix_friedman_test with sample data" { let data = @src.rstatix_sample_data() let result = @src.rstatix_friedman_test(data, _group_names=["A", "B", "C"]) assert_true(result.p_value >= 0.0 && result.p_value <= 1.0) assert_true(result.source == "Friedman") -} \ No newline at end of file +} diff --git a/test/moonbit/rtsne_test.mbt b/test/moonbit/rtsne_test.mbt index 2fb8c168..b52479aa 100644 --- a/test/moonbit/rtsne_test.mbt +++ b/test/moonbit/rtsne_test.mbt @@ -6,10 +6,7 @@ // ============================================================ test "calc_distance_matrix square" { - let data : Array[Array[Double]] = [ - [0.0, 0.0], - [3.0, 4.0], - ] + let data : Array[Array[Double]] = [[0.0, 0.0], [3.0, 4.0]] let dist = @src.calc_distance_matrix(data) assert_eq(dist.length(), 2) assert_eq(dist[0].length(), 2) @@ -20,12 +17,14 @@ test "calc_distance_matrix square" { assert_eq(dist[1][0], 5.0) } +///| test "calc_distance_matrix empty" { let data : Array[Array[Double]] = [] let dist = @src.calc_distance_matrix(data) assert_eq(dist.length(), 0) } +///| test "calc_distance_matrix single point" { let data : Array[Array[Double]] = [[1.0, 2.0, 3.0]] let dist = @src.calc_distance_matrix(data) @@ -37,6 +36,7 @@ test "calc_distance_matrix single point" { // t-SNE config tests // ============================================================ +///| test "tsne_config default" { let config = @src.TsneConfig::new() assert_eq(config.perplexity, 30.0) @@ -50,13 +50,14 @@ test "tsne_config default" { // t-SNE algorithm tests // ============================================================ +///| test "tsne basic 2d" { let data = @src.create_tsne_test_data(10, 5) assert_eq(data.length(), 10) assert_eq(data[0].length(), 5) - + let test_config = @src.TsneConfig::new_custom(3.0, 100, 2, 42) - + let result = @src.tsne(data, test_config) assert_eq(result.embedding.length(), 10) assert_eq(result.embedding[0].length(), 2) @@ -64,6 +65,7 @@ test "tsne basic 2d" { assert_eq(result.costs.length(), 100) } +///| test "tsne empty data" { let data : Array[Array[Double]] = [] let config = @src.TsneConfig::new() @@ -71,6 +73,7 @@ test "tsne empty data" { assert_eq(result.embedding.length(), 0) } +///| test "tsne single sample" { let data : Array[Array[Double]] = [[1.0, 2.0, 3.0]] let config = @src.TsneConfig::new() @@ -79,12 +82,13 @@ test "tsne single sample" { assert_true(result.embedding.length() <= 1) } +///| test "tsne costs decrease" { let data = @src.create_tsne_test_data(15, 4) let config = @src.TsneConfig::new_custom(3.0, 50, 2, 42) - + let result = @src.tsne(data, config) - + // Costs should be finite if result.costs.length() > 10 { // Check that costs are not NaN or infinite @@ -95,10 +99,11 @@ test "tsne costs decrease" { } } +///| test "tsne different dims" { let data = @src.create_tsne_test_data(10, 5) let config = @src.TsneConfig::new_custom(3.0, 50, 3, 42) - + let result = @src.tsne(data, config) assert_eq(result.embedding[0].length(), 3) } @@ -107,19 +112,21 @@ test "tsne different dims" { // Test data generation tests // ============================================================ +///| test "create_tsne_test_data dimensions" { let data = @src.create_tsne_test_data(20, 8) assert_eq(data.length(), 20) assert_eq(data[0].length(), 8) } +///| test "create_tsne_test_data clusters" { let data = @src.create_tsne_test_data(9, 3) // 3 clusters, each should have similar values // Cluster 0: samples 0, 3, 6 // Cluster 1: samples 1, 4, 7 // Cluster 2: samples 2, 5, 8 - + // Check that cluster 0 is different from cluster 1 let mut sum0 = 0.0 let mut j = 0 @@ -127,14 +134,14 @@ test "create_tsne_test_data clusters" { sum0 = sum0 + data[0][j] j = j + 1 } - + let mut sum1 = 0.0 j = 0 while j < 3 { sum1 = sum1 + data[1][j] j = j + 1 } - + // Clusters should be separated assert_true(sum1 > sum0) } diff --git a/test/moonbit/s4vectors_test.mbt b/test/moonbit/s4vectors_test.mbt index 3ccb1769..50921427 100644 --- a/test/moonbit/s4vectors_test.mbt +++ b/test/moonbit/s4vectors_test.mbt @@ -2,7 +2,7 @@ test "s4vectors_rle_from_vector" { let vec = ["A", "A", "A", "B", "B", "C", "C", "C", "C", "A", "A"] let rle = @src.Rle::from_vector(vec) - + assert_eq(rle.values.length(), 4) assert_eq(rle.lengths.length(), 4) } @@ -11,7 +11,7 @@ test "s4vectors_rle_from_vector" { test "s4vectors_rle_length" { let vec = ["A", "A", "B", "B", "B"] let rle = @src.Rle::from_vector(vec) - + assert_eq(rle.length(), 5) } @@ -19,7 +19,7 @@ test "s4vectors_rle_length" { test "s4vectors_rle_get" { let vec = ["A", "A", "B", "C", "C", "C"] let rle = @src.Rle::from_vector(vec) - + assert_eq(rle.get(0), "A") assert_eq(rle.get(2), "B") assert_eq(rle.get(5), "C") @@ -29,9 +29,9 @@ test "s4vectors_rle_get" { test "s4vectors_dataframe_basic" { let col1 = @src.S4DataFrameColumn::new("gene_id", ["gene1", "gene2", "gene3"]) let col2 = @src.S4DataFrameColumn::new("expression", ["10.5", "25.3", "5.8"]) - + let df = @src.S4DataFrame::new([col1, col2], ["row1", "row2", "row3"]) - + assert_eq(df.nrow(), 3) assert_eq(df.ncol(), 2) } @@ -40,25 +40,25 @@ test "s4vectors_dataframe_basic" { test "s4vectors_dataframe_colnames" { let col1 = @src.S4DataFrameColumn::new("gene_id", ["gene1", "gene2"]) let col2 = @src.S4DataFrameColumn::new("expression", ["10.5", "25.3"]) - + let df = @src.S4DataFrame::new([col1, col2], []) let names = df.colnames() - + assert_eq(names.length(), 2) } ///| test "s4vectors_hits_basic" { let hits = @src.Hits::new([0, 0, 1, 2], [1, 2, 0, 1], 3, 3) - + assert_eq(hits.n_hits(), 4) } ///| test "s4vectors_hits_count_query_hits" { let hits = @src.Hits::new([0, 0, 1, 2], [1, 2, 0, 1], 3, 3) - + let counts = hits.count_query_hits() - + assert_eq(counts.length(), 3) -} \ No newline at end of file +} diff --git a/test/moonbit/sasa_test.mbt b/test/moonbit/sasa_test.mbt index 8149442b..61259184 100644 --- a/test/moonbit/sasa_test.mbt +++ b/test/moonbit/sasa_test.mbt @@ -13,19 +13,19 @@ fn make_atom( resseq : Int, ) -> @src.Atom { @src.Atom::new( - name=name, + name~, coord=@src.Vector3::new(x, y, z), - resname=resname, + resname~, chainid='A', - resseq=resseq, - element=element, + resseq~, + element~, ) } ///| /// Helper: place all given atoms into a single residue on chain A. fn make_structure(atoms : Array[@src.Atom]) -> @src.Structure { - let res = @src.Residue::new(resname="UNK", chainid='A', resseq=1, atoms=atoms) + let res = @src.Residue::new(resname="UNK", chainid='A', resseq=1, atoms~) let chain = @src.Chain::new(id='A', residues=[res]) let model = @src.Model::new(id=1, chains=[chain]) @src.Structure::new(id="test", models=[model]) @@ -240,8 +240,9 @@ test "sasa_total_backbone_sidechain" { let atom_res = @src.sasa_calc(s, 100, 1.4) let summary = @src.sasa_calc_total(atom_res) assert_true( - (summary.get_backbone_sasa() + summary.get_sidechain_sasa() - - summary.get_total_sasa()).abs() < + (summary.get_backbone_sasa() + + summary.get_sidechain_sasa() - + summary.get_total_sasa()).abs() < 1.0e-9, ) assert_true(summary.get_backbone_sasa() > 0.0) @@ -310,7 +311,10 @@ test "sasa_all_backbone_atoms_sidechain_zero" { let res_res = @src.sasa_calc_residue(atom_res, s) assert_eq(res_res.length(), 1) assert_true(res_res[0].get_sidechain_sasa() == 0.0) - assert_true((res_res[0].get_backbone_sasa() - res_res[0].get_total_sasa()).abs() < 1.0e-9) + assert_true( + (res_res[0].get_backbone_sasa() - res_res[0].get_total_sasa()).abs() < + 1.0e-9, + ) } ///| diff --git a/test/moonbit/sc3_test.mbt b/test/moonbit/sc3_test.mbt index 54428771..d3376d35 100644 --- a/test/moonbit/sc3_test.mbt +++ b/test/moonbit/sc3_test.mbt @@ -3,14 +3,10 @@ ///| test "sc3_preprocess" { - let data = [ - [0.0, 1.0, 10.0], - [0.0, 2.0, 20.0], - [0.0, 3.0, 30.0], - ] - + let data = [[0.0, 1.0, 10.0], [0.0, 2.0, 20.0], [0.0, 3.0, 30.0]] + let processed = @src.sc3_preprocess(data) - + assert_true(processed.length() == 3) assert_true(processed[0].length() == 3) } @@ -23,53 +19,38 @@ test "sc3_pca" { [3.0, 4.0, 5.0], [10.0, 11.0, 12.0], ] - + let pcs = @src.sc3_pca(data, 2) - + assert_true(pcs.length() == 4) assert_true(pcs[0].length() == 2) } ///| test "sc3_kmeans" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [10.0, 11.0], - [11.0, 12.0], - ] - + let data = [[1.0, 2.0], [2.0, 3.0], [10.0, 11.0], [11.0, 12.0]] + let labels = @src.sc3_kmeans(data, 2) - + assert_true(labels.length() == 4) } ///| test "sc3_silhouette" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [10.0, 11.0], - [11.0, 12.0], - ] + let data = [[1.0, 2.0], [2.0, 3.0], [10.0, 11.0], [11.0, 12.0]] let labels = [0, 0, 1, 1] - + let scores = @src.sc3_calculate_silhouette(data, labels, 2) - + assert_true(scores.length() == 4) } ///| test "sc3_gap_statistics" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [10.0, 11.0], - [11.0, 12.0], - ] - + let data = [[1.0, 2.0], [2.0, 3.0], [10.0, 11.0], [11.0, 12.0]] + let gaps = @src.sc3_calculate_gap_statistics(data, 3) - + assert_true(gaps.length() == 3) } @@ -81,9 +62,9 @@ test "sc3_consensus_cluster" { [10.0, 11.0, 12.0], [11.0, 12.0, 13.0], ] - + let result = @src.bio_sc3_cluster(data, 2) - + assert_true(result.k == 2) assert_true(result.cluster_labels.length() == 4) assert_true(result.consensus_matrix.length() == 4) @@ -91,16 +72,12 @@ test "sc3_consensus_cluster" { ///| test "sc3_bio_api" { - let data = [ - [1.0, 2.0], - [2.0, 3.0], - [10.0, 11.0], - ] - + let data = [[1.0, 2.0], [2.0, 3.0], [10.0, 11.0]] + let pcs = @src.bio_sc3_pca(data, 2) let labels = @src.sc3_kmeans(pcs, 2) let scores = @src.bio_sc3_silhouette(pcs, labels, 2) - + assert_true(pcs.length() == 3) assert_true(scores.length() == 3) -} \ No newline at end of file +} diff --git a/test/moonbit/scenic_test.mbt b/test/moonbit/scenic_test.mbt index a22db54a..bac87835 100644 --- a/test/moonbit/scenic_test.mbt +++ b/test/moonbit/scenic_test.mbt @@ -6,32 +6,28 @@ // --------------------------------------------------------------------------- test "scenic_co_expression_module_creation" { - let mod_ = @src.co_expression_module( - "TP53", - ["G1", "G2", "G3"], - [0.9, 0.7, 0.5], - ) + let mod_ = @src.co_expression_module("TP53", ["G1", "G2", "G3"], [ + 0.9, 0.7, 0.5, + ]) assert_eq(mod_.tf_name, "TP53") assert_eq(mod_.targets.length(), 3) assert_eq(mod_.weights[0], 0.9) } +///| test "scenic_regulon_creation" { - let reg = @src.scenic_regulon( - "MYC", - ["G1", "G2", "G3", "G4"], - [1.0, 0.8, 0.6, 0.4], - ) + let reg = @src.scenic_regulon("MYC", ["G1", "G2", "G3", "G4"], [ + 1.0, 0.8, 0.6, 0.4, + ]) assert_eq(reg.tf_name, "MYC") assert_eq(reg.n_targets, 4) assert_eq(reg.targets[2], "G3") } +///| test "scenic_input_creation" { - let expr = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] // 2 genes x 3 cells - let input = @src.scenic_input( - expr, ["TF1", "G1"], ["C1", "C2", "C3"], ["TF1"], - ) + let expr = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]] // 2 genes x 3 cells + let input = @src.scenic_input(expr, ["TF1", "G1"], ["C1", "C2", "C3"], ["TF1"]) assert_eq(input.n_genes, 2) assert_eq(input.n_cells, 3) assert_eq(input.tf_names.length(), 1) @@ -41,6 +37,7 @@ test "scenic_input_creation" { // Binarize method constructors // --------------------------------------------------------------------------- +///| test "scenic_binarize_method_constructors" { match @src.binarize_mean_std() { @src.BinarizeMethod::MeanStd => assert_true(true) @@ -60,16 +57,15 @@ test "scenic_binarize_method_constructors" { // Synthetic data generator // --------------------------------------------------------------------------- +///| test "scenic_sample_data_shape" { - let input = @src.scenic_sample_data( - n_genes=60, n_cells=40, n_tfs=4, seed=10, - ) + let input = @src.scenic_sample_data(n_genes=60, n_cells=40, n_tfs=4, seed=10) assert_eq(input.n_genes, 60) assert_eq(input.n_cells, 40) assert_eq(input.tf_names.length(), 4) assert_eq(input.gene_names[0], "TF1") assert_eq(input.gene_names[4], "G1") - assert_eq(input.expression.length(), 60) // gene x cell + assert_eq(input.expression.length(), 60) // gene x cell assert_eq(input.expression[0].length(), 40) } @@ -77,13 +73,10 @@ test "scenic_sample_data_shape" { // Step 1: Co-expression modules // --------------------------------------------------------------------------- +///| test "scenic_build_coexpression_modules_basic" { - let input = @src.scenic_sample_data( - n_genes=50, n_cells=30, n_tfs=3, seed=42, - ) - let modules = @src.build_coexpression_modules( - input, min_targets=5, top_k=20, - ) + let input = @src.scenic_sample_data(n_genes=50, n_cells=30, n_tfs=3, seed=42) + let modules = @src.build_coexpression_modules(input, min_targets=5, top_k=20) // Should produce a module for each TF assert_eq(modules.length(), 3) for mod_ in modules { @@ -93,12 +86,13 @@ test "scenic_build_coexpression_modules_basic" { } } +///| test "scenic_build_coexpression_modules_skip_unknown_tf" { // TF name not in gene_names -> should be skipped let expr = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]] - let input = @src.scenic_input( - expr, ["G1", "G2", "G3"], ["C1", "C2"], ["NONEXISTENT"], - ) + let input = @src.scenic_input(expr, ["G1", "G2", "G3"], ["C1", "C2"], [ + "NONEXISTENT", + ]) let modules = @src.build_coexpression_modules(input, min_targets=1, top_k=5) assert_eq(modules.length(), 0) } @@ -107,15 +101,14 @@ test "scenic_build_coexpression_modules_skip_unknown_tf" { // Step 2: Regulon construction // --------------------------------------------------------------------------- +///| test "scenic_build_regulons_prunes_by_weight" { - let input = @src.scenic_sample_data( - n_genes=50, n_cells=30, n_tfs=3, seed=7, - ) - let modules = @src.build_coexpression_modules( - input, min_targets=5, top_k=20, - ) + let input = @src.scenic_sample_data(n_genes=50, n_cells=30, n_tfs=3, seed=7) + let modules = @src.build_coexpression_modules(input, min_targets=5, top_k=20) let regulons = @src.build_regulons( - modules, weight_quantile=0.5, min_targets=3, + modules, + weight_quantile=0.5, + min_targets=3, ) // Each regulon should have fewer or equal targets than its module assert_eq(regulons.length(), modules.length()) @@ -125,23 +118,29 @@ test "scenic_build_regulons_prunes_by_weight" { } } +///| test "scenic_build_regulons_filters_small_modules" { let modules = [ @src.co_expression_module("TF1", ["G1", "G2"], [0.9, 0.8]), - @src.co_expression_module("TF2", ["G1", "G2", "G3", "G4", "G5"], [0.9, 0.8, 0.7, 0.6, 0.5]), + @src.co_expression_module("TF2", ["G1", "G2", "G3", "G4", "G5"], [ + 0.9, 0.8, 0.7, 0.6, 0.5, + ]), ] - let regulons = @src.build_regulons(modules, weight_quantile=0.0, min_targets=5) + let regulons = @src.build_regulons( + modules, + weight_quantile=0.0, + min_targets=5, + ) // TF1 module has only 2 targets -> filtered out assert_eq(regulons.length(), 1) assert_eq(regulons[0].tf_name, "TF2") } +///| test "scenic_prune_by_motif_ranking" { - let mod_ = @src.co_expression_module( - "TF1", - ["G1", "G2", "G3", "G4", "G5"], - [0.9, 0.8, 0.7, 0.6, 0.5], - ) + let mod_ = @src.co_expression_module("TF1", ["G1", "G2", "G3", "G4", "G5"], [ + 0.9, 0.8, 0.7, 0.6, 0.5, + ]) // Motif ranking: G1, G3, G5 are in top 3 let motif_ranked = ["G1", "G3", "G5", "G2", "G4", "G6", "G7", "G8"] let reg = @src.prune_by_motif_ranking(mod_, motif_ranked, rank_threshold=3) @@ -157,32 +156,34 @@ test "scenic_prune_by_motif_ranking" { // Step 3: AUCell scoring // --------------------------------------------------------------------------- +///| test "scenic_build_cell_rankings" { let expr = [ - [5.0, 1.0, 3.0], // gene 0: high in cell 0 - [2.0, 4.0, 1.0], // gene 1: high in cell 1 - [1.0, 3.0, 2.0], // gene 2 + [5.0, 1.0, 3.0], // gene 0: high in cell 0 + [2.0, 4.0, 1.0], // gene 1: high in cell 1 + [1.0, 3.0, 2.0], // gene 2 ] - let input = @src.scenic_input( - expr, ["G0", "G1", "G2"], ["C0", "C1", "C2"], [], - ) + let input = @src.scenic_input(expr, ["G0", "G1", "G2"], ["C0", "C1", "C2"], []) let rankings = @src.build_cell_rankings(input) // Cell 0: gene 0 has expr 5.0 (highest), gene 1 has 2.0, gene 2 has 1.0 - assert_eq(rankings[0][0], 0) // gene 0 first - assert_eq(rankings[0][1], 1) // gene 1 second - assert_eq(rankings[0][2], 2) // gene 2 third + assert_eq(rankings[0][0], 0) // gene 0 first + assert_eq(rankings[0][1], 1) // gene 1 second + assert_eq(rankings[0][2], 2) // gene 2 third } +///| test "scenic_compute_regulon_activity_basic" { - let input = @src.scenic_sample_data( - n_genes=40, n_cells=20, n_tfs=2, seed=99, - ) - let modules = @src.build_coexpression_modules( - input, min_targets=5, top_k=15, + let input = @src.scenic_sample_data(n_genes=40, n_cells=20, n_tfs=2, seed=99) + let modules = @src.build_coexpression_modules(input, min_targets=5, top_k=15) + let regulons = @src.build_regulons( + modules, + weight_quantile=0.3, + min_targets=3, ) - let regulons = @src.build_regulons(modules, weight_quantile=0.3, min_targets=3) let auc_matrix = @src.compute_regulon_activity( - regulons, input, auc_threshold_pct=0.1, + regulons, + input, + auc_threshold_pct=0.1, ) assert_eq(auc_matrix.length(), regulons.length()) assert_eq(auc_matrix[0].length(), input.n_cells) @@ -198,26 +199,32 @@ test "scenic_compute_regulon_activity_basic" { // Step 4: Binarization // --------------------------------------------------------------------------- +///| test "scenic_binarize_mean_std" { let auc_matrix = [ - [0.1, 0.2, 0.8, 0.9, 0.1, 0.85], // bimodal: low {0.1,0.2,0.1}, high {0.8,0.9,0.85} + [0.1, 0.2, 0.8, 0.9, 0.1, 0.85], // bimodal: low {0.1,0.2,0.1}, high {0.8,0.9,0.85} ] let (binary, thresholds) = @src.binarize_activity( - auc_matrix, 6, method=@src.binarize_mean_std(), + auc_matrix, + 6, + method=@src.binarize_mean_std(), ) assert_eq(thresholds.length(), 1) assert_true(thresholds[0] > 0.3 && thresholds[0] < 0.7) // High-AUC cells should be 1, low-AUC cells should be 0 - assert_eq(binary[0][2], 1) // 0.8 > threshold - assert_eq(binary[0][0], 0) // 0.1 < threshold + assert_eq(binary[0][2], 1) // 0.8 > threshold + assert_eq(binary[0][0], 0) // 0.1 < threshold } +///| test "scenic_binarize_kmeans2" { let auc_matrix = [ - [0.1, 0.1, 0.1, 0.9, 0.9, 0.9], // clearly bimodal + [0.1, 0.1, 0.1, 0.9, 0.9, 0.9], // clearly bimodal ] let (binary, thresholds) = @src.binarize_activity( - auc_matrix, 6, method=@src.binarize_kmeans2(), + auc_matrix, + 6, + method=@src.binarize_kmeans2(), ) // K-means should separate at ~0.5 assert_true(thresholds[0] > 0.3 && thresholds[0] < 0.7) @@ -225,51 +232,50 @@ test "scenic_binarize_kmeans2" { assert_eq(binary[0][3], 1) } +///| test "scenic_binarize_median" { - let auc_matrix = [ - [0.1, 0.2, 0.3, 0.4, 0.5, 0.9], - ] + let auc_matrix = [[0.1, 0.2, 0.3, 0.4, 0.5, 0.9]] let (binary, _thresholds) = @src.binarize_activity( - auc_matrix, 6, method=@src.binarize_median(), + auc_matrix, + 6, + method=@src.binarize_median(), ) // Median of sorted [0.1,0.2,0.3,0.4,0.5,0.9] = 0.35 // Values > 0.35: 0.4, 0.5, 0.9 -> 1 - assert_eq(binary[0][5], 1) // 0.9 - assert_eq(binary[0][0], 0) // 0.1 + assert_eq(binary[0][5], 1) // 0.9 + assert_eq(binary[0][0], 0) // 0.1 } // --------------------------------------------------------------------------- // Cell state assignment // --------------------------------------------------------------------------- +///| test "scenic_assign_cell_states_basic" { // 2 regulons, 4 cells // Regulon 0 active in cells 0,1; Regulon 1 active in cells 2,3 - let binary = [ - [1, 1, 0, 0], - [0, 0, 1, 1], - ] + let binary = [[1, 1, 0, 0], [0, 0, 1, 1]] let (labels, n_clusters, masters) = @src.assign_cell_states( - binary, ["TF1", "TF2"], 4, + binary, + ["TF1", "TF2"], + 4, ) - assert_eq(labels[0], 1) // cell 0 -> cluster 1 (TF1) - assert_eq(labels[1], 1) // cell 1 -> cluster 1 - assert_eq(labels[2], 2) // cell 2 -> cluster 2 (TF2) - assert_eq(labels[3], 2) // cell 3 -> cluster 2 + assert_eq(labels[0], 1) // cell 0 -> cluster 1 (TF1) + assert_eq(labels[1], 1) // cell 1 -> cluster 1 + assert_eq(labels[2], 2) // cell 2 -> cluster 2 (TF2) + assert_eq(labels[3], 2) // cell 3 -> cluster 2 assert_eq(n_clusters, 2) assert_eq(masters.length(), 2) } +///| test "scenic_assign_cell_states_no_active_regulon" { - let binary = [ - [0, 0, 0], - [0, 0, 0], - ] - let (labels, _n, masters) = @src.assign_cell_states( - binary, ["TF1", "TF2"], 3, - ) + let binary = [[0, 0, 0], [0, 0, 0]] + let (labels, _n, masters) = @src.assign_cell_states(binary, ["TF1", "TF2"], 3) // All cells should be in cluster 0 (no active regulon) - for l in labels { assert_eq(l, 0) } + for l in labels { + assert_eq(l, 0) + } assert_eq(masters.length(), 0) } @@ -277,13 +283,20 @@ test "scenic_assign_cell_states_no_active_regulon" { // End-to-end pipeline // --------------------------------------------------------------------------- +///| test "scenic_run_pipeline_end_to_end" { let input = @src.scenic_sample_data( - n_genes=60, n_cells=40, n_tfs=4, seed=2025, + n_genes=60, + n_cells=40, + n_tfs=4, + seed=2025, ) let result = @src.run_scenic( - input, min_targets=5, top_k=20, - weight_quantile=0.3, auc_threshold_pct=0.1, + input, + min_targets=5, + top_k=20, + weight_quantile=0.3, + auc_threshold_pct=0.1, binarize_method=@src.binarize_mean_std(), ) assert_eq(result.n_cells, 40) @@ -295,10 +308,9 @@ test "scenic_run_pipeline_end_to_end" { assert_eq(result.thresholds.length(), result.n_regulons) } +///| test "scenic_result_summary" { - let input = @src.scenic_sample_data( - n_genes=40, n_cells=20, n_tfs=3, seed=1, - ) + let input = @src.scenic_sample_data(n_genes=40, n_cells=20, n_tfs=3, seed=1) let result = @src.run_scenic(input) let s = result.summary() assert_true(s.contains("regulons=")) @@ -306,10 +318,9 @@ test "scenic_result_summary" { assert_true(s.contains("clusters=")) } +///| test "scenic_result_auc_at" { - let input = @src.scenic_sample_data( - n_genes=40, n_cells=10, n_tfs=2, seed=5, - ) + let input = @src.scenic_sample_data(n_genes=40, n_cells=10, n_tfs=2, seed=5) let result = @src.run_scenic(input) // Valid indices should return a value in [0,1] if result.n_regulons > 0 { @@ -321,24 +332,22 @@ test "scenic_result_auc_at" { assert_eq(result.auc_at(999, 0), 0.0) } +///| test "scenic_result_top_regulons" { - let input = @src.scenic_sample_data( - n_genes=50, n_cells=30, n_tfs=4, seed=8, - ) + let input = @src.scenic_sample_data(n_genes=50, n_cells=30, n_tfs=4, seed=8) let result = @src.run_scenic(input) let top = result.top_regulons(n=3) assert_true(top.length() <= 3) if top.length() >= 2 { let (_, s0) = top[0] let (_, s1) = top[1] - assert_true(s0 >= s1) // sorted descending + assert_true(s0 >= s1) // sorted descending } } +///| test "scenic_result_regulon_targets" { - let input = @src.scenic_sample_data( - n_genes=40, n_cells=20, n_tfs=2, seed=3, - ) + let input = @src.scenic_sample_data(n_genes=40, n_cells=20, n_tfs=2, seed=3) let result = @src.run_scenic(input) if result.n_regulons > 0 { let targets = result.regulon_targets(0) diff --git a/test/moonbit/scmap_test.mbt b/test/moonbit/scmap_test.mbt index deb74bcb..2deb171c 100644 --- a/test/moonbit/scmap_test.mbt +++ b/test/moonbit/scmap_test.mbt @@ -15,12 +15,14 @@ test "scmap_reference_creation" { assert_eq(ref.cell_types()[6], "NK_cell") } +///| test "scmap_reference_unique_types" { let ref = @src.scmap_sample_reference() let types = ref.unique_cell_types() assert_eq(types.length(), 3) } +///| test "scmap_query_creation" { let q = @src.scmap_sample_query() assert_eq(q.gene_names().length(), 10) @@ -30,10 +32,9 @@ test "scmap_query_creation" { assert_eq(q.cell_names()[2], "query_unknown") } +///| test "scmap_assignment_creation" { - let a = @src.ScmapAssignment::new( - "cell1", "T_cell", 0.85, 0.3, "cluster", - ) + let a = @src.ScmapAssignment::new("cell1", "T_cell", 0.85, 0.3, "cluster") assert_eq(a.cell_name(), "cell1") assert_eq(a.assigned_type(), "T_cell") assert_eq(a.best_correlation(), 0.85) @@ -45,6 +46,7 @@ test "scmap_assignment_creation" { // scmap-cluster method // --------------------------------------------------------------------------- +///| test "scmap_cluster_classifies_t_cell" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -56,6 +58,7 @@ test "scmap_cluster_classifies_t_cell" { assert_eq(assignments[0].method(), "cluster") } +///| test "scmap_cluster_classifies_b_cell" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -65,6 +68,7 @@ test "scmap_cluster_classifies_b_cell" { assert_eq(assignments[1].assigned_type(), "B_cell") } +///| test "scmap_cluster_high_threshold_unassigned" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -75,6 +79,7 @@ test "scmap_cluster_high_threshold_unassigned" { } } +///| test "scmap_cluster_correlation_is_valid" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -85,6 +90,7 @@ test "scmap_cluster_correlation_is_valid" { } } +///| test "scmap_cluster_best_gt_second_best" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -98,6 +104,7 @@ test "scmap_cluster_best_gt_second_best" { // scmap-cell method // --------------------------------------------------------------------------- +///| test "scmap_cell_classifies_t_cell" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -107,6 +114,7 @@ test "scmap_cell_classifies_t_cell" { assert_eq(assignments[0].method(), "cell") } +///| test "scmap_cell_classifies_b_cell" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -115,6 +123,7 @@ test "scmap_cell_classifies_b_cell" { assert_eq(assignments[1].assigned_type(), "B_cell") } +///| test "scmap_cell_k_neighbours_parameter" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -123,6 +132,7 @@ test "scmap_cell_k_neighbours_parameter" { assert_eq(assignments.length(), 3) } +///| test "scmap_cell_high_threshold_unassigned" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -140,6 +150,7 @@ test "scmap_cell_high_threshold_unassigned" { // Summary utilities // --------------------------------------------------------------------------- +///| test "scmap_summary_counts" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -156,16 +167,16 @@ test "scmap_summary_counts" { assert_eq(total, assignments.length()) } +///| test "scmap_assignment_to_string" { - let a = @src.ScmapAssignment::new( - "cell1", "T_cell", 0.85, 0.3, "cluster", - ) + let a = @src.ScmapAssignment::new("cell1", "T_cell", 0.85, 0.3, "cluster") let s = a.to_string() assert_true(s.contains("cell1")) assert_true(s.contains("T_cell")) assert_true(s.contains("cluster")) } +///| test "scmap_assignments_to_string" { let ref = @src.scmap_sample_reference() let query = @src.scmap_sample_query() @@ -179,6 +190,7 @@ test "scmap_assignments_to_string" { // Sample data verification // --------------------------------------------------------------------------- +///| test "scmap_sample_reference_expression_structure" { let ref = @src.scmap_sample_reference() // 10 genes × 9 cells @@ -190,6 +202,7 @@ test "scmap_sample_reference_expression_structure" { assert_true(ref.expression()[3][3] > ref.expression()[3][0]) } +///| test "scmap_sample_query_expression_structure" { let q = @src.scmap_sample_query() // 10 genes × 3 cells @@ -203,6 +216,7 @@ test "scmap_sample_query_expression_structure" { // Edge cases // --------------------------------------------------------------------------- +///| test "scmap_cluster_single_query_cell" { let ref = @src.scmap_sample_reference() // Create a single-cell query using the T cell reference profile @@ -215,6 +229,7 @@ test "scmap_cluster_single_query_cell" { assert_eq(assignments.length(), 1) } +///| test "scmap_cell_single_query_cell" { let ref = @src.scmap_sample_reference() let q = @src.scmap_sample_query() diff --git a/test/moonbit/scnorm_test.mbt b/test/moonbit/scnorm_test.mbt index 8d4dffd2..f3dd380e 100644 --- a/test/moonbit/scnorm_test.mbt +++ b/test/moonbit/scnorm_test.mbt @@ -12,7 +12,7 @@ test "scnorm_library_sizes" { let counts : Array[Array[Double]] = [ [10.0, 20.0, 30.0], [5.0, 15.0, 25.0], - [50.0, 100.0, 150.0] + [50.0, 100.0, 150.0], ] let sizes = @src.sc_norm_library_sizes(counts) assert_eq(sizes.length(), 3) @@ -61,7 +61,7 @@ test "scnorm_full_run" { let count_matrix : Array[Array[Double]] = [ [10.0, 20.0, 30.0], [50.0, 60.0, 70.0], - [100.0, 200.0, 300.0] + [100.0, 200.0, 300.0], ] let gene_ids = ["gene1", "gene2", "gene3"] let cell_ids = ["cell1", "cell2", "cell3"] @@ -74,7 +74,7 @@ test "scnorm_full_run" { test "scnorm_result_accessors" { let count_matrix : Array[Array[Double]] = [ [10.0, 20.0, 30.0], - [50.0, 60.0, 70.0] + [50.0, 60.0, 70.0], ] let gene_ids = ["gene1", "gene2"] let cell_ids = ["cell1", "cell2", "cell3"] diff --git a/test/moonbit/scop_test.mbt b/test/moonbit/scop_test.mbt index c1ed0188..0e899c9d 100644 --- a/test/moonbit/scop_test.mbt +++ b/test/moonbit/scop_test.mbt @@ -17,6 +17,7 @@ test "scop_node_type_name" { assert_eq(@src.scop_node_type_name("xx"), "unknown") } +///| test "scop_node_type_code" { assert_eq(@src.scop_node_type_code("root"), "ro") assert_eq(@src.scop_node_type_code("class"), "cl") @@ -28,6 +29,7 @@ test "scop_node_type_code" { assert_eq(@src.scop_node_type_code("domain"), "px") } +///| test "scop_node_type_order" { assert_true(@src.scop_node_type_order("ro") < @src.scop_node_type_order("cl")) assert_true(@src.scop_node_type_order("cl") < @src.scop_node_type_order("cf")) @@ -42,18 +44,21 @@ test "scop_node_type_order" { // Residues parsing // --------------------------------------------------------------------------- +///| test "scop_parse_residues_dash" { let r = @src.scop_parse_residues("-") assert_eq(r.pdbid(), "") assert_eq(r.fragments().length(), 0) } +///| test "scop_parse_residues_empty" { let r = @src.scop_parse_residues("") assert_eq(r.pdbid(), "") assert_eq(r.fragments().length(), 0) } +///| test "scop_parse_residues_paren_dash" { let r = @src.scop_parse_residues("(-)") assert_eq(r.pdbid(), "") @@ -63,6 +68,7 @@ test "scop_parse_residues_paren_dash" { assert_eq(r.fragments()[0].end_(), "") } +///| test "scop_parse_residues_with_pdbid" { let r = @src.scop_parse_residues("1bba A:10-20,B:") assert_eq(r.pdbid(), "1bba") @@ -77,6 +83,7 @@ test "scop_parse_residues_with_pdbid" { assert_eq(r.fragments()[1].end_(), "") } +///| test "scop_parse_residues_single_chain" { let r = @src.scop_parse_residues("A:1-141") assert_eq(r.pdbid(), "") @@ -86,6 +93,7 @@ test "scop_parse_residues_single_chain" { assert_eq(r.fragments()[0].end_(), "141") } +///| test "scop_residues_to_string_roundtrip" { let r = @src.scop_parse_residues("1hba A:1-141") let s = @src.scop_residues_to_string(r) @@ -97,6 +105,7 @@ test "scop_residues_to_string_roundtrip" { assert_eq(r2.fragments()[0].end_(), "141") } +///| test "scop_residues_to_string_dash" { let r = @src.ScopResidues::new("", []) let s = @src.scop_residues_to_string(r) @@ -107,12 +116,15 @@ test "scop_residues_to_string_dash" { // Record creation and accessors // --------------------------------------------------------------------------- +///| test "scop_cla_record_creation" { let res = @src.scop_parse_residues("1hba A:1-141") let hier : Map[String, Int] = Map([], capacity=8) hier.set("cl", 100) hier.set("cf", 200) - let r = @src.ClaRecord::new("d1hba_", "1hba", res, "a.1.1.1.1.1.1", 1000, hier) + let r = @src.ClaRecord::new( + "d1hba_", "1hba", res, "a.1.1.1.1.1.1", 1000, hier, + ) assert_eq(r.sid(), "d1hba_") assert_eq(r.pdbid(), "1hba") assert_eq(r.sccs(), "a.1.1.1.1.1.1") @@ -120,6 +132,7 @@ test "scop_cla_record_creation" { assert_eq(r.hierarchy().get("cl").unwrap(), 100) } +///| test "scop_des_record_creation" { let r = @src.DesRecord::new( 1000, "px", "a.1.1.1.1.1.1", "d1hba_", "1hba Hemoglobin alpha chain", @@ -131,6 +144,7 @@ test "scop_des_record_creation" { assert_eq(r.description(), "1hba Hemoglobin alpha chain") } +///| test "scop_hie_record_creation" { let r = @src.HieRecord::new(600, 500, [1000, 1001]) assert_eq(r.sunid(), 600) @@ -144,6 +158,7 @@ test "scop_hie_record_creation" { // File parsers // --------------------------------------------------------------------------- +///| test "scop_parse_cla_line" { let line = "d1hba_\t1hba\tA:1-141\ta.1.1.1.1.1.1\t1000\tcl=100,cf=200,sf=300,fa=400,dm=500,sp=600,px=1000" let r = @src.scop_parse_cla_line(line) @@ -157,16 +172,19 @@ test "scop_parse_cla_line" { assert_eq(rec.hierarchy().get("px").unwrap(), 1000) } +///| test "scop_parse_cla_line_comment" { let r = @src.scop_parse_cla_line("# comment line") assert_true(r.is_none()) } +///| test "scop_parse_cla_line_empty" { let r = @src.scop_parse_cla_line("") assert_true(r.is_none()) } +///| test "scop_parse_des_line" { let line = "1000\tpx\ta.1.1.1.1.1.1\td1hba_\t1hba Hemoglobin alpha chain" let r = @src.scop_parse_des_line(line) @@ -177,6 +195,7 @@ test "scop_parse_des_line" { assert_eq(rec.name(), "d1hba_") } +///| test "scop_parse_des_line_class" { let line = "100\tcl\ta\t-\tAll alpha proteins" let r = @src.scop_parse_des_line(line) @@ -188,6 +207,7 @@ test "scop_parse_des_line_class" { assert_eq(rec.description(), "All alpha proteins") } +///| test "scop_parse_hie_line" { let line = "600\t500\t1000,1001" let r = @src.scop_parse_hie_line(line) @@ -198,6 +218,7 @@ test "scop_parse_hie_line" { assert_eq(rec.children().length(), 2) } +///| test "scop_parse_hie_line_root" { let line = "0\t-\t100" let r = @src.scop_parse_hie_line(line) @@ -208,6 +229,7 @@ test "scop_parse_hie_line_root" { assert_eq(rec.children().length(), 1) } +///| test "scop_parse_hie_line_leaf" { let line = "1000\t600\t-" let r = @src.scop_parse_hie_line(line) @@ -218,6 +240,7 @@ test "scop_parse_hie_line_leaf" { assert_eq(rec.children().length(), 0) } +///| test "scop_parse_cla_multiple" { let content = @src.scop_sample_cla() let records = @src.scop_parse_cla(content) @@ -226,6 +249,7 @@ test "scop_parse_cla_multiple" { assert_eq(records[1].sid(), "d1hbb_") } +///| test "scop_parse_des_multiple" { let content = @src.scop_sample_des() let records = @src.scop_parse_des(content) @@ -233,6 +257,7 @@ test "scop_parse_des_multiple" { assert_eq(records.length(), 9) } +///| test "scop_parse_hie_multiple" { let content = @src.scop_sample_hie() let records = @src.scop_parse_hie(content) @@ -243,6 +268,7 @@ test "scop_parse_hie_multiple" { // Scop hierarchy construction and queries // --------------------------------------------------------------------------- +///| test "scop_build_hierarchy" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -255,6 +281,7 @@ test "scop_build_hierarchy" { assert_eq(scop.get_domains().length(), 2) } +///| test "scop_get_node_by_sunid" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -269,6 +296,7 @@ test "scop_get_node_by_sunid" { assert_true(none.is_none()) } +///| test "scop_get_domain_by_sid" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -285,6 +313,7 @@ test "scop_get_domain_by_sid" { assert_true(none.is_none()) } +///| test "scop_get_parent" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -301,6 +330,7 @@ test "scop_get_parent" { assert_true(root_parent.is_none()) } +///| test "scop_get_children" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -317,6 +347,7 @@ test "scop_get_children" { assert_eq(scop.get_children(leaf).length(), 0) } +///| test "scop_get_ascendent_by_code" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -334,6 +365,7 @@ test "scop_get_ascendent_by_code" { assert_eq(fa.unwrap().sunid(), 400) } +///| test "scop_get_ascendent_by_long_name" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -347,6 +379,7 @@ test "scop_get_ascendent_by_long_name" { assert_eq(fold.unwrap().description(), "Globin-like") } +///| test "scop_get_descendents" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -365,6 +398,7 @@ test "scop_get_descendents" { assert_eq(families[0].sunid(), 400) } +///| test "scop_get_descendents_long_name" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -374,6 +408,7 @@ test "scop_get_descendents_long_name" { assert_eq(domains.length(), 2) } +///| test "scop_node_is_domain" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -389,27 +424,32 @@ test "scop_node_is_domain" { // SCCS comparison // --------------------------------------------------------------------------- +///| test "scop_cmp_sccs_equal" { assert_eq(@src.scop_cmp_sccs("a.1.1.1", "a.1.1.1"), 0) } +///| test "scop_cmp_sccs_letter_diff" { assert_true(@src.scop_cmp_sccs("a.1.1.1", "b.1.1.1") < 0) assert_true(@src.scop_cmp_sccs("b.1.1.1", "a.1.1.1") > 0) } +///| test "scop_cmp_sccs_numeric_diff" { assert_true(@src.scop_cmp_sccs("a.1.1.1", "a.1.1.2") < 0) assert_true(@src.scop_cmp_sccs("a.1.1.2", "a.1.1.1") > 0) assert_true(@src.scop_cmp_sccs("a.1.1.1", "a.1.2.1") < 0) } +///| test "scop_cmp_sccs_length_diff" { // Shorter prefix sorts first when all compared components are equal assert_true(@src.scop_cmp_sccs("a.1", "a.1.1") < 0) assert_true(@src.scop_cmp_sccs("a.1.1", "a.1") > 0) } +///| test "scop_cmp_sccs_numeric_not_lexical" { // Numerically, 2 < 11, so a.1.2 < a.1.11 (NOT lexical where "2" > "11") assert_true(@src.scop_cmp_sccs("a.1.2", "a.1.11") < 0) @@ -420,6 +460,7 @@ test "scop_cmp_sccs_numeric_not_lexical" { // Serialization // --------------------------------------------------------------------------- +///| test "scop_write_hie" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -432,6 +473,7 @@ test "scop_write_hie" { assert_true(output.contains("1000\t600\t-")) } +///| test "scop_write_des" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -442,6 +484,7 @@ test "scop_write_des" { assert_true(output.contains("d1hba_")) } +///| test "scop_write_cla" { let cla = @src.scop_parse_cla(@src.scop_sample_cla()) let des = @src.scop_parse_des(@src.scop_sample_des()) @@ -457,6 +500,7 @@ test "scop_write_cla" { // Empty Scop // --------------------------------------------------------------------------- +///| test "scop_empty" { let scop = @src.scop_empty() assert_eq(scop.root().sunid(), 0) diff --git a/test/moonbit/searchio_new_test.mbt b/test/moonbit/searchio_new_test.mbt index 3f488995..43a13c89 100644 --- a/test/moonbit/searchio_new_test.mbt +++ b/test/moonbit/searchio_new_test.mbt @@ -20,9 +20,16 @@ test "SearchIOHsp::new construction" { ///| test "SearchIOHsp::n_identical" { let hsp = @src.SearchIOHsp::new( - bitscore=200.5, evalue=1.0e-50, identity=95.0, positives=97.0, - gap=2.0, alignment_length=100, - query_start=1, query_end=100, hit_start=1, hit_end=100, + bitscore=200.5, + evalue=1.0e-50, + identity=95.0, + positives=97.0, + gap=2.0, + alignment_length=100, + query_start=1, + query_end=100, + hit_start=1, + hit_end=100, ) assert_eq(hsp.n_identical(), 95) } @@ -30,9 +37,16 @@ test "SearchIOHsp::n_identical" { ///| test "SearchIOHsp::n_positives" { let hsp = @src.SearchIOHsp::new( - bitscore=200.5, evalue=1.0e-50, identity=95.0, positives=97.0, - gap=2.0, alignment_length=100, - query_start=1, query_end=100, hit_start=1, hit_end=100, + bitscore=200.5, + evalue=1.0e-50, + identity=95.0, + positives=97.0, + gap=2.0, + alignment_length=100, + query_start=1, + query_end=100, + hit_start=1, + hit_end=100, ) assert_eq(hsp.n_positives(), 97) } @@ -40,9 +54,16 @@ test "SearchIOHsp::n_positives" { ///| test "SearchIOHsp::n_gaps" { let hsp = @src.SearchIOHsp::new( - bitscore=200.5, evalue=1.0e-50, identity=95.0, positives=97.0, - gap=2.0, alignment_length=100, - query_start=1, query_end=100, hit_start=1, hit_end=100, + bitscore=200.5, + evalue=1.0e-50, + identity=95.0, + positives=97.0, + gap=2.0, + alignment_length=100, + query_start=1, + query_end=100, + hit_start=1, + hit_end=100, ) assert_eq(hsp.n_gaps(), 2) } @@ -50,9 +71,16 @@ test "SearchIOHsp::n_gaps" { ///| test "SearchIOHsp::with_query_seq" { let hsp = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = hsp.with_query_seq("ATCGATCG") assert_eq(hsp2.query_seq, "ATCGATCG") @@ -61,9 +89,16 @@ test "SearchIOHsp::with_query_seq" { ///| test "SearchIOHsp::with_hit_seq" { let hsp = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = hsp.with_hit_seq("ATCGATCG") assert_eq(hsp2.hit_seq, "ATCGATCG") @@ -72,9 +107,16 @@ test "SearchIOHsp::with_hit_seq" { ///| test "SearchIOHsp::with_midline" { let hsp = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = hsp.with_midline("||||||..") assert_eq(hsp2.midline, "||||||..") @@ -83,9 +125,16 @@ test "SearchIOHsp::with_midline" { ///| test "SearchIOHsp::with_frames" { let hsp = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = hsp.with_frames(1, -1) assert_eq(hsp2.query_frame, 1) @@ -94,7 +143,11 @@ test "SearchIOHsp::with_frames" { ///| test "SearchIOHit::new construction" { - let hit = @src.SearchIOHit::new(id="hit1", description="Test hit", seq_length=1000) + let hit = @src.SearchIOHit::new( + id="hit1", + description="Test hit", + seq_length=1000, + ) assert_eq(hit.id, "hit1") assert_eq(hit.description, "Test hit") assert_eq(hit.seq_length, 1000) @@ -104,14 +157,28 @@ test "SearchIOHit::new construction" { ///| test "SearchIOHit::add_hsp and best_hsp" { let hsp1 = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = @src.SearchIOHsp::new( - bitscore=200.0, evalue=1.0e-40, identity=95.0, positives=97.0, - gap=0.5, alignment_length=80, - query_start=51, query_end=130, hit_start=51, hit_end=130, + bitscore=200.0, + evalue=1.0e-40, + identity=95.0, + positives=97.0, + gap=0.5, + alignment_length=80, + query_start=51, + query_end=130, + hit_start=51, + hit_end=130, ) let hit = @src.SearchIOHit::new(id="hit1", description="Test", seq_length=500) let hit_with_hsps = hit.add_hsp(hsp1).add_hsp(hsp2) @@ -137,14 +204,28 @@ test "SearchIOHit::best_hsp empty" { ///| test "SearchIOHit::sum_bitscore" { let hsp1 = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = @src.SearchIOHsp::new( - bitscore=200.0, evalue=1.0e-40, identity=95.0, positives=97.0, - gap=0.5, alignment_length=80, - query_start=51, query_end=130, hit_start=51, hit_end=130, + bitscore=200.0, + evalue=1.0e-40, + identity=95.0, + positives=97.0, + gap=0.5, + alignment_length=80, + query_start=51, + query_end=130, + hit_start=51, + hit_end=130, ) let hit = @src.SearchIOHit::new(id="hit1", description="Test", seq_length=500) let hit_with_hsps = hit.add_hsp(hsp1).add_hsp(hsp2) @@ -155,7 +236,10 @@ test "SearchIOHit::sum_bitscore" { ///| test "SearchIOQueryResult::new construction" { let qr = @src.SearchIOQueryResult::new( - id="query1", description="Test query", seq_length=500, database="nr", + id="query1", + description="Test query", + seq_length=500, + database="nr", ) assert_eq(qr.id, "query1") assert_eq(qr.description, "Test query") @@ -166,9 +250,16 @@ test "SearchIOQueryResult::new construction" { ///| test "SearchIOQueryResult::add_hit" { let qr = @src.SearchIOQueryResult::new( - id="query1", description="Test", seq_length=500, database="nr", + id="query1", + description="Test", + seq_length=500, + database="nr", + ) + let hit = @src.SearchIOHit::new( + id="hit1", + description="Hit 1", + seq_length=300, ) - let hit = @src.SearchIOHit::new(id="hit1", description="Hit 1", seq_length=300) let qr2 = qr.add_hit(hit) assert_eq(qr2.n_hits, 1) } @@ -176,20 +267,47 @@ test "SearchIOQueryResult::add_hit" { ///| test "SearchIOQueryResult::sort_by_score" { let hsp1 = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = @src.SearchIOHsp::new( - bitscore=200.0, evalue=1.0e-40, identity=95.0, positives=97.0, - gap=0.5, alignment_length=80, - query_start=1, query_end=80, hit_start=1, hit_end=80, + bitscore=200.0, + evalue=1.0e-40, + identity=95.0, + positives=97.0, + gap=0.5, + alignment_length=80, + query_start=1, + query_end=80, + hit_start=1, + hit_end=80, ) - let hit1 = @src.SearchIOHit::new(id="low", description="Low score", seq_length=300).add_hsp(hsp1) - let hit2 = @src.SearchIOHit::new(id="high", description="High score", seq_length=400).add_hsp(hsp2) + let hit1 = @src.SearchIOHit::new( + id="low", + description="Low score", + seq_length=300, + ).add_hsp(hsp1) + let hit2 = @src.SearchIOHit::new( + id="high", + description="High score", + seq_length=400, + ).add_hsp(hsp2) let qr = @src.SearchIOQueryResult::new( - id="query1", description="Test", seq_length=500, database="nr", - ).add_hit(hit1).add_hit(hit2) + id="query1", + description="Test", + seq_length=500, + database="nr", + ) + .add_hit(hit1) + .add_hit(hit2) let sorted = qr.sort_by_score() assert_eq(sorted.hits[0].id, "high") assert_eq(sorted.hits[1].id, "low") @@ -198,20 +316,43 @@ test "SearchIOQueryResult::sort_by_score" { ///| test "SearchIOQueryResult::filter_evalue" { let hsp1 = @src.SearchIOHsp::new( - bitscore=100.0, evalue=0.05, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=0.05, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = @src.SearchIOHsp::new( - bitscore=200.0, evalue=1.0e-40, identity=95.0, positives=97.0, - gap=0.5, alignment_length=80, - query_start=1, query_end=80, hit_start=1, hit_end=80, + bitscore=200.0, + evalue=1.0e-40, + identity=95.0, + positives=97.0, + gap=0.5, + alignment_length=80, + query_start=1, + query_end=80, + hit_start=1, + hit_end=80, + ) + let hit1 = @src.SearchIOHit::new(id="hit1", description="", seq_length=300).add_hsp( + hsp1, + ) + let hit2 = @src.SearchIOHit::new(id="hit2", description="", seq_length=400).add_hsp( + hsp2, ) - let hit1 = @src.SearchIOHit::new(id="hit1", description="", seq_length=300).add_hsp(hsp1) - let hit2 = @src.SearchIOHit::new(id="hit2", description="", seq_length=400).add_hsp(hsp2) let qr = @src.SearchIOQueryResult::new( - id="query1", description="", seq_length=500, database="nr", - ).add_hit(hit1).add_hit(hit2) + id="query1", + description="", + seq_length=500, + database="nr", + ) + .add_hit(hit1) + .add_hit(hit2) let filtered = qr.filter_evalue(0.01) assert_eq(filtered.n_hits, 1) assert_eq(filtered.hits[0].id, "hit2") @@ -220,26 +361,59 @@ test "SearchIOQueryResult::filter_evalue" { ///| test "SearchIOQueryResult::top_n" { let hsp1 = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, ) let hsp2 = @src.SearchIOHsp::new( - bitscore=200.0, evalue=1.0e-40, identity=95.0, positives=97.0, - gap=0.5, alignment_length=80, - query_start=1, query_end=80, hit_start=1, hit_end=80, + bitscore=200.0, + evalue=1.0e-40, + identity=95.0, + positives=97.0, + gap=0.5, + alignment_length=80, + query_start=1, + query_end=80, + hit_start=1, + hit_end=80, ) let hsp3 = @src.SearchIOHsp::new( - bitscore=150.0, evalue=1.0e-30, identity=92.0, positives=94.0, - gap=0.8, alignment_length=60, - query_start=1, query_end=60, hit_start=1, hit_end=60, + bitscore=150.0, + evalue=1.0e-30, + identity=92.0, + positives=94.0, + gap=0.8, + alignment_length=60, + query_start=1, + query_end=60, + hit_start=1, + hit_end=60, + ) + let hit1 = @src.SearchIOHit::new(id="low", description="", seq_length=300).add_hsp( + hsp1, + ) + let hit2 = @src.SearchIOHit::new(id="high", description="", seq_length=400).add_hsp( + hsp2, + ) + let hit3 = @src.SearchIOHit::new(id="mid", description="", seq_length=350).add_hsp( + hsp3, ) - let hit1 = @src.SearchIOHit::new(id="low", description="", seq_length=300).add_hsp(hsp1) - let hit2 = @src.SearchIOHit::new(id="high", description="", seq_length=400).add_hsp(hsp2) - let hit3 = @src.SearchIOHit::new(id="mid", description="", seq_length=350).add_hsp(hsp3) let qr = @src.SearchIOQueryResult::new( - id="query1", description="", seq_length=500, database="nr", - ).add_hit(hit1).add_hit(hit2).add_hit(hit3) + id="query1", + description="", + seq_length=500, + database="nr", + ) + .add_hit(hit1) + .add_hit(hit2) + .add_hit(hit3) let tops = qr.top_n(2) assert_eq(tops.length(), 2) assert_eq(tops[0].id, "high") @@ -249,13 +423,25 @@ test "SearchIOQueryResult::top_n" { ///| test "SearchIOQueryResult::top_n exceeds total" { let hsp = @src.SearchIOHsp::new( - bitscore=100.0, evalue=1.0e-20, identity=90.0, positives=92.0, - gap=1.0, alignment_length=50, - query_start=1, query_end=50, hit_start=1, hit_end=50, + bitscore=100.0, + evalue=1.0e-20, + identity=90.0, + positives=92.0, + gap=1.0, + alignment_length=50, + query_start=1, + query_end=50, + hit_start=1, + hit_end=50, + ) + let hit = @src.SearchIOHit::new(id="hit1", description="", seq_length=300).add_hsp( + hsp, ) - let hit = @src.SearchIOHit::new(id="hit1", description="", seq_length=300).add_hsp(hsp) let qr = @src.SearchIOQueryResult::new( - id="query1", description="", seq_length=500, database="nr", + id="query1", + description="", + seq_length=500, + database="nr", ).add_hit(hit) let tops = qr.top_n(5) assert_eq(tops.length(), 1) @@ -264,7 +450,10 @@ test "SearchIOQueryResult::top_n exceeds total" { ///| test "SearchIOQueryResult::with_total_hits" { let qr = @src.SearchIOQueryResult::new( - id="query1", description="", seq_length=500, database="nr", + id="query1", + description="", + seq_length=500, + database="nr", ) let qr2 = qr.with_total_hits(100) assert_eq(qr2.total_hits, 100) @@ -298,7 +487,10 @@ test "search_io_mock_blast_tabular" { ///| test "SearchIOIterator::parse_blast_tabular basic" { let content = @src.search_io_mock_blast_tabular() - let iter = @src.SearchIOIterator::new(content, @src.search_io_format_from_str("blast-tab")) + let iter = @src.SearchIOIterator::new( + content, + @src.search_io_format_from_str("blast-tab"), + ) let results = iter.parse_blast_tabular() assert_true(results.length() >= 0) } @@ -306,7 +498,10 @@ test "SearchIOIterator::parse_blast_tabular basic" { ///| test "SearchIOIterator::parse_blast_tabular hit count" { let content = @src.search_io_mock_blast_tabular() - let iter = @src.SearchIOIterator::new(content, @src.search_io_format_from_str("blast-tab")) + let iter = @src.SearchIOIterator::new( + content, + @src.search_io_format_from_str("blast-tab"), + ) let results = iter.parse_blast_tabular() assert_true(results.length() >= 0) } @@ -314,21 +509,30 @@ test "SearchIOIterator::parse_blast_tabular hit count" { ///| test "SearchIOIterator::parse_blast_tabular scores" { let content = @src.search_io_mock_blast_tabular() - let iter = @src.SearchIOIterator::new(content, @src.search_io_format_from_str("blast-tab")) + let iter = @src.SearchIOIterator::new( + content, + @src.search_io_format_from_str("blast-tab"), + ) let results = iter.parse_blast_tabular() assert_true(results.length() >= 0) } ///| test "SearchIOIterator::parse empty content" { - let iter = @src.SearchIOIterator::new("", @src.search_io_format_from_str("blast-tab")) + let iter = @src.SearchIOIterator::new( + "", + @src.search_io_format_from_str("blast-tab"), + ) let results = iter.parse_blast_tabular() assert_eq(results.length(), 0) } ///| test "SearchIOIterator::parse empty content text" { - let iter = @src.SearchIOIterator::new("", @src.search_io_format_from_str("blast-text")) + let iter = @src.SearchIOIterator::new( + "", + @src.search_io_format_from_str("blast-text"), + ) let results = iter.parse_blast_text() assert_eq(results.length(), 0) } @@ -340,7 +544,10 @@ test "SearchIOIterator::parse blast text basic" { ">hit1 description\n" + "Score = 200.5 (520 bits), Expect = 1.0e-50\n" + "Identities = 95/100 (95%)\n" - let iter = @src.SearchIOIterator::new(text, @src.search_io_format_from_str("blast-text")) + let iter = @src.SearchIOIterator::new( + text, + @src.search_io_format_from_str("blast-text"), + ) let results = iter.parse_blast_text() assert_true(results.length() >= 0) } @@ -348,7 +555,10 @@ test "SearchIOIterator::parse blast text basic" { ///| test "SearchIOIterator::parse dispatch" { let content = @src.search_io_mock_blast_tabular() - let iter = @src.SearchIOIterator::new(content, @src.search_io_format_from_str("blast-tab")) + let iter = @src.SearchIOIterator::new( + content, + @src.search_io_format_from_str("blast-tab"), + ) let results = iter.parse() assert_true(results.length() >= 0) } @@ -356,7 +566,10 @@ test "SearchIOIterator::parse dispatch" { ///| test "SearchIOIterator::parse unknown format returns empty" { let content = "some content" - let iter = @src.SearchIOIterator::new(content, @src.search_io_format_from_str("unknown")) + let iter = @src.SearchIOIterator::new( + content, + @src.search_io_format_from_str("unknown"), + ) let results = iter.parse() assert_eq(results.length(), 0) } diff --git a/test/moonbit/seq_complexity_test.mbt b/test/moonbit/seq_complexity_test.mbt index ff10eaa2..3a3125bc 100644 --- a/test/moonbit/seq_complexity_test.mbt +++ b/test/moonbit/seq_complexity_test.mbt @@ -134,6 +134,7 @@ test "seq_complexity: sequence_similarity_empty" { // LCC (Wooton-Federhen) tests +///| test "seq_complexity: lcc_basic" { let scores = @src.lcc("ATCGATCGATCGATCG", window=12, k=3) assert_true(scores.length() > 0) @@ -144,6 +145,7 @@ test "seq_complexity: lcc_basic" { } } +///| test "seq_complexity: lcc_low_complexity" { let scores = @src.lcc("AAAAAAAAAAAAAAAA", window=12, k=3) assert_true(scores.length() > 0) @@ -153,20 +155,28 @@ test "seq_complexity: lcc_low_complexity" { } } +///| test "seq_complexity: lcc_empty" { let scores = @src.lcc("", window=12, k=3) assert_eq(scores.length(), 0) } +///| test "seq_complexity: lcc_short" { let scores = @src.lcc("AC", window=12, k=3) assert_eq(scores.length(), 0) } +///| test "seq_complexity: lcc_low_complexity_regions" { // Mix of low complexity and high complexity let seq = "AAAAAAAAAAAAAACGATCGATCG" - let regions = @src.lcc_low_complexity_regions(seq, window=12, k=3, threshold=0.15) + let regions = @src.lcc_low_complexity_regions( + seq, + window=12, + k=3, + threshold=0.15, + ) // Should find low complexity region at the beginning assert_true(regions.length() > 0) } diff --git a/test/moonbit/seq_location_test.mbt b/test/moonbit/seq_location_test.mbt index 6326c089..59b6fe7d 100644 --- a/test/moonbit/seq_location_test.mbt +++ b/test/moonbit/seq_location_test.mbt @@ -1,161 +1,227 @@ ///| /// Test file for seq_location module. - test "exact_position" { let pos = @src.exact_position(42) - assert_eq!(pos.get(), 42) - assert_eq!(pos.to_string(), "42") - assert_eq!(pos.is_exact(), true) + assert_eq(pos.get(), 42) + assert_eq(pos.to_string(), "42") + assert_eq(pos.is_exact(), true) } +///| test "before_position" { let pos = @src.before_position(50) - assert_eq!(pos.get(), 50) - assert_eq!(pos.to_string(), "<50") - assert_eq!(pos.is_exact(), false) + assert_eq(pos.get(), 50) + assert_eq(pos.to_string(), "<50") + assert_eq(pos.is_exact(), false) } +///| test "after_position" { let pos = @src.after_position(100) - assert_eq!(pos.get(), 100) - assert_eq!(pos.to_string(), ">100") - assert_eq!(pos.is_exact(), false) + assert_eq(pos.get(), 100) + assert_eq(pos.to_string(), ">100") + assert_eq(pos.is_exact(), false) } +///| test "one_of_position" { let opts : Array[@src.Pos] = Array::new() opts.push(@src.exact_position(5)) opts.push(@src.exact_position(7)) opts.push(@src.exact_position(9)) let pos = @src.one_of_position(7, opts) - assert_eq!(pos.get(), 7) - assert_eq!(pos.is_exact(), false) + assert_eq(pos.get(), 7) + assert_eq(pos.is_exact(), false) let s = pos.to_string() - assert_eq!(s.starts_with("{"), true) - assert_eq!(s.contains("5"), true) - assert_eq!(s.contains("7"), true) - assert_eq!(s.contains("9"), true) + assert_eq(s.starts_with("{"), true) + assert_eq(s.contains("5"), true) + assert_eq(s.contains("7"), true) + assert_eq(s.contains("9"), true) } +///| test "within_position" { - let pos = @src.within_position(50, @src.exact_position(40), @src.exact_position(60)) - assert_eq!(pos.get(), 50) - assert_eq!(pos.is_exact(), false) + let pos = @src.within_position( + 50, + @src.exact_position(40), + @src.exact_position(60), + ) + assert_eq(pos.get(), 50) + assert_eq(pos.is_exact(), false) let s = pos.to_string() - assert_eq!(s.starts_with("("), true) - assert_eq!(s.contains("40"), true) - assert_eq!(s.contains("60"), true) + assert_eq(s.starts_with("("), true) + assert_eq(s.contains("40"), true) + assert_eq(s.contains("60"), true) } +///| test "simple_location_basic" { - let loc = @src.simple_location(@src.exact_position(10), @src.exact_position(50), strand="+") - assert_eq!(loc.start(), 10) - assert_eq!(loc.end(), 50) - assert_eq!(loc.strand(), "+") - assert_eq!(loc.len(), 40) - assert_eq!(loc.is_compound(), false) - assert_eq!(loc.to_string(), "10..50") + let loc = @src.simple_location( + @src.exact_position(10), + @src.exact_position(50), + strand="+", + ) + assert_eq(loc.start(), 10) + assert_eq(loc.end(), 50) + assert_eq(loc.strand(), "+") + assert_eq(loc.len(), 40) + assert_eq(loc.is_compound(), false) + assert_eq(loc.to_string(), "10..50") } +///| test "simple_location_reverse_strand" { - let loc = @src.simple_location(@src.exact_position(100), @src.exact_position(200), strand="-") - assert_eq!(loc.strand(), "-") - assert_eq!(loc.len(), 100) + let loc = @src.simple_location( + @src.exact_position(100), + @src.exact_position(200), + strand="-", + ) + assert_eq(loc.strand(), "-") + assert_eq(loc.len(), 100) } +///| test "simple_location_overlaps" { - let loc1 = @src.simple_location(@src.exact_position(10), @src.exact_position(50)) - let loc2 = @src.simple_location(@src.exact_position(30), @src.exact_position(70)) - let loc3 = @src.simple_location(@src.exact_position(100), @src.exact_position(200)) - assert_eq!(loc1.overlaps(loc2), true) - assert_eq!(loc1.overlaps(loc3), false) + let loc1 = @src.simple_location( + @src.exact_position(10), + @src.exact_position(50), + ) + let loc2 = @src.simple_location( + @src.exact_position(30), + @src.exact_position(70), + ) + let loc3 = @src.simple_location( + @src.exact_position(100), + @src.exact_position(200), + ) + assert_eq(loc1.overlaps(loc2), true) + assert_eq(loc1.overlaps(loc3), false) } +///| test "simple_location_contains" { - let loc = @src.simple_location(@src.exact_position(10), @src.exact_position(50)) - assert_eq!(loc.contains(10), true) - assert_eq!(loc.contains(25), true) - assert_eq!(loc.contains(49), true) - assert_eq!(loc.contains(5), false) - assert_eq!(loc.contains(50), false) - assert_eq!(loc.contains(100), false) + let loc = @src.simple_location( + @src.exact_position(10), + @src.exact_position(50), + ) + assert_eq(loc.contains(10), true) + assert_eq(loc.contains(25), true) + assert_eq(loc.contains(49), true) + assert_eq(loc.contains(5), false) + assert_eq(loc.contains(50), false) + assert_eq(loc.contains(100), false) } +///| test "compound_location_basic" { - let exon1 = @src.simple_location(@src.exact_position(0), @src.exact_position(100)) - let exon2 = @src.simple_location(@src.exact_position(200), @src.exact_position(350)) + let exon1 = @src.simple_location( + @src.exact_position(0), + @src.exact_position(100), + ) + let exon2 = @src.simple_location( + @src.exact_position(200), + @src.exact_position(350), + ) let locs : Array[@src.Loc] = Array::new() locs.push(exon1) locs.push(exon2) let cl = @src.compound_location(locs, strand="+") - assert_eq!(cl.is_compound(), true) - assert_eq!(cl.parts().length(), 2) - assert_eq!(cl.len(), 250) + assert_eq(cl.is_compound(), true) + assert_eq(cl.parts().length(), 2) + assert_eq(cl.len(), 250) } +///| test "compound_from_simple" { let starts : Array[Int] = [0, 200, 500] let ends : Array[Int] = [100, 350, 600] let cl = @src.compound_from_simple(starts, ends, strand="+") - assert_eq!(cl.is_compound(), true) - assert_eq!(cl.parts().length(), 3) - assert_eq!(cl.len(), 350) // 100 + 150 + 100 + assert_eq(cl.is_compound(), true) + assert_eq(cl.parts().length(), 3) + assert_eq(cl.len(), 350) // 100 + 150 + 100 } +///| test "compound_location_overlaps" { - let exon1 = @src.simple_location(@src.exact_position(0), @src.exact_position(100)) - let exon2 = @src.simple_location(@src.exact_position(200), @src.exact_position(350)) + let exon1 = @src.simple_location( + @src.exact_position(0), + @src.exact_position(100), + ) + let exon2 = @src.simple_location( + @src.exact_position(200), + @src.exact_position(350), + ) let locs : Array[@src.Loc] = Array::new() locs.push(exon1) locs.push(exon2) let cl = @src.compound_location(locs) - let overlapping = @src.simple_location(@src.exact_position(50), @src.exact_position(150)) - let not_overlapping = @src.simple_location(@src.exact_position(400), @src.exact_position(500)) - assert_eq!(cl.overlaps(overlapping), true) - assert_eq!(cl.overlaps(not_overlapping), false) + let overlapping = @src.simple_location( + @src.exact_position(50), + @src.exact_position(150), + ) + let not_overlapping = @src.simple_location( + @src.exact_position(400), + @src.exact_position(500), + ) + assert_eq(cl.overlaps(overlapping), true) + assert_eq(cl.overlaps(not_overlapping), false) } +///| test "compound_location_contains" { - let exon1 = @src.simple_location(@src.exact_position(0), @src.exact_position(100)) - let exon2 = @src.simple_location(@src.exact_position(200), @src.exact_position(350)) + let exon1 = @src.simple_location( + @src.exact_position(0), + @src.exact_position(100), + ) + let exon2 = @src.simple_location( + @src.exact_position(200), + @src.exact_position(350), + ) let locs : Array[@src.Loc] = Array::new() locs.push(exon1) locs.push(exon2) let cl = @src.compound_location(locs) - assert_eq!(cl.contains(50), true) - assert_eq!(cl.contains(250), true) - assert_eq!(cl.contains(150), false) - assert_eq!(cl.contains(400), false) + assert_eq(cl.contains(50), true) + assert_eq(cl.contains(250), true) + assert_eq(cl.contains(150), false) + assert_eq(cl.contains(400), false) } +///| test "location_genbank_format" { - let loc = @src.simple_location(@src.exact_position(9), @src.exact_position(50)) + let loc = @src.simple_location( + @src.exact_position(9), + @src.exact_position(50), + ) let gb = @src.location_to_genbank(loc) - assert_eq!(gb.contains("10"), true) - assert_eq!(gb.contains("50"), true) + assert_eq(gb.contains("10"), true) + assert_eq(gb.contains("50"), true) } +///| test "from_genbank_coords" { let loc = @src.from_genbank_coords(10, 50, strand="+") - assert_eq!(loc.start(), 9) - assert_eq!(loc.end(), 50) - assert_eq!(loc.strand(), "+") - assert_eq!(loc.len(), 41) + assert_eq(loc.start(), 9) + assert_eq(loc.end(), 50) + assert_eq(loc.strand(), "+") + assert_eq(loc.len(), 41) } +///| test "parse_genbank_location_simple" { let loc = @src.parse_genbank_location("10..50") - assert_eq!(loc.start(), 9) // 0-based - assert_eq!(loc.end(), 50) - assert_eq!(loc.len(), 41) + assert_eq(loc.start(), 9) // 0-based + assert_eq(loc.end(), 50) + assert_eq(loc.len(), 41) } +///| test "seq_location_sample" { let samples = @src.seq_location_sample() - assert_eq!(samples.length(), 5) + assert_eq(samples.length(), 5) // First is simple forward - assert_eq!(samples[0].is_compound(), false) + assert_eq(samples[0].is_compound(), false) // Third is compound - assert_eq!(samples[2].is_compound(), true) + assert_eq(samples[2].is_compound(), true) } diff --git a/test/moonbit/seq_quality_trim_test.mbt b/test/moonbit/seq_quality_trim_test.mbt index a27c52c1..c61d1a39 100644 --- a/test/moonbit/seq_quality_trim_test.mbt +++ b/test/moonbit/seq_quality_trim_test.mbt @@ -113,7 +113,10 @@ test "sqt_trim_adapter_perfect_match" { let qual = "IIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" let (t_seq, _) = @src.sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, + seq, + qual, + adapter, + allowed_mismatches=0, ) assert_eq(t_seq, "ACGTACGT") assert_eq(t_seq.length(), 8) @@ -125,7 +128,10 @@ test "sqt_trim_adapter_with_mismatches" { let qual = "IIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" let (t_seq, _) = @src.sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=2, + seq, + qual, + adapter, + allowed_mismatches=2, ) assert_eq(t_seq, "ACGTACGT") } @@ -136,7 +142,10 @@ test "sqt_trim_adapter_no_match" { let qual = "IIIIIIIIIIIIIIII" let adapter = "GGGGGGGG" let (t_seq, _) = @src.sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, + seq, + qual, + adapter, + allowed_mismatches=0, ) assert_eq(t_seq, "ACGTACGTACGTACGT") assert_eq(t_seq.length(), 16) @@ -146,9 +155,7 @@ test "sqt_trim_adapter_no_match" { test "sqt_trim_adapter_empty_adapter" { let seq = "ACGTACGT" let qual = "IIIIIIII" - let (t_seq, _) = @src.sqt_trim_adapter( - seq, qual, "", allowed_mismatches=0, - ) + let (t_seq, _) = @src.sqt_trim_adapter(seq, qual, "", allowed_mismatches=0) assert_eq(t_seq, "ACGTACGT") } @@ -158,7 +165,10 @@ test "sqt_trim_adapter_short_sequence" { let qual = "II" let adapter = "AGATCGGAA" let (t_seq, _) = @src.sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, + seq, + qual, + adapter, + allowed_mismatches=0, ) assert_eq(t_seq, "AC") } @@ -169,7 +179,10 @@ test "sqt_trim_adapter_at_beginning" { let qual = "IIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" let (t_seq, _) = @src.sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, + seq, + qual, + adapter, + allowed_mismatches=0, ) assert_eq(t_seq.length(), 0) } @@ -180,7 +193,10 @@ test "sqt_trim_adapter_partial_overlap" { let qual = "IIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" let (t_seq, _) = @src.sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=1, + seq, + qual, + adapter, + allowed_mismatches=1, ) assert_eq(t_seq, "ACGTACGT") } @@ -191,7 +207,10 @@ test "sqt_trim_adapter_at_3_prime_end" { let qual = "IIIIIIIIIIIIIIIIIIIII" let adapter = "AGATCGGAA" let (t_seq, _) = @src.sqt_trim_adapter( - seq, qual, adapter, allowed_mismatches=0, + seq, + qual, + adapter, + allowed_mismatches=0, ) assert_eq(t_seq, "ACGTACGTACGT") } @@ -344,9 +363,7 @@ test "sqt_trim_reads_batch_with_adapter_config" { ] let qual_config = @src.QualityConfig::new(20, 4, 4, 20) let adapter_config = @src.AdapterConfig::new(["AGATCGGAA"], 4, 0) - let results = @src.sqt_trim_reads( - reads, qual_config, Some(adapter_config), - ) + let results = @src.sqt_trim_reads(reads, qual_config, Some(adapter_config)) assert_eq(results.length(), 1) assert_eq(results[0].trimmed_seq, "ACGTACGT") assert_true(results[0].trim_type == "adapter:AGATCGGAA") @@ -354,9 +371,7 @@ test "sqt_trim_reads_batch_with_adapter_config" { ///| test "sqt_trim_reads_quality_trim_only" { - let reads = [ - @src.FastqRead::new("r1", "ACGTACGT", "IIII####"), - ] + let reads = [@src.FastqRead::new("r1", "ACGTACGT", "IIII####")] let qual_config = @src.QualityConfig::new(20, 4, 4, 20) let results = @src.sqt_trim_reads(reads, qual_config, None) assert_eq(results.length(), 1) @@ -365,9 +380,7 @@ test "sqt_trim_reads_quality_trim_only" { ///| test "sqt_trim_reads_poly_a_trim" { - let reads = [ - @src.FastqRead::new("r1", "ACGTACGGGAAAA", "IIIIIIIIIIIIII"), - ] + let reads = [@src.FastqRead::new("r1", "ACGTACGGGAAAA", "IIIIIIIIIIIIII")] let qual_config = @src.QualityConfig::new(20, 4, 4, 20) let results = @src.sqt_trim_reads(reads, qual_config, None) assert_eq(results.length(), 1) @@ -381,9 +394,7 @@ test "sqt_trim_reads_adapter_at_end" { ] let qual_config = @src.QualityConfig::new(20, 4, 4, 20) let adapter_config = @src.AdapterConfig::new(["AGATCGGAA"], 4, 0) - let results = @src.sqt_trim_reads( - reads, qual_config, Some(adapter_config), - ) + let results = @src.sqt_trim_reads(reads, qual_config, Some(adapter_config)) assert_eq(results.length(), 1) assert_eq(results[0].trimmed_seq, "ACGTACGTACGT") } @@ -398,9 +409,7 @@ test "sqt_trim_reads_empty_batch" { ///| test "sqt_trim_reads_preserves_original_data" { - let reads = [ - @src.FastqRead::new("read_orig", "ACGTACGT", "IIIIIIII"), - ] + let reads = [@src.FastqRead::new("read_orig", "ACGTACGT", "IIIIIIII")] let qual_config = @src.QualityConfig::new(20, 4, 4, 20) let results = @src.sqt_trim_reads(reads, qual_config, None) assert_eq(results.length(), 1) @@ -416,7 +425,9 @@ test "sqt_compute_stats_basic" { @src.FastqRead::new("r2", "TTTTTTTT", "IIIIIIII"), ] let results = [ - @src.TrimResult::new("r1", "ACGTACGT", "ACGTACGT", "IIIIIIII", "IIIIIIII", "none"), + @src.TrimResult::new( + "r1", "ACGTACGT", "ACGTACGT", "IIIIIIII", "IIIIIIII", "none", + ), @src.TrimResult::new("r2", "TTTTTTTT", "", "IIIIIIII", "", "poly_A"), ] let stats = @src.sqt_compute_stats(results, reads) @@ -434,8 +445,12 @@ test "sqt_compute_stats_gc_content" { @src.FastqRead::new("at_high", "AAAATTTT", "IIIIIIII"), ] let results = [ - @src.TrimResult::new("gc_high", "GGGGCCCC", "GGGGCCCC", "IIIIIIII", "IIIIIIII", "none"), - @src.TrimResult::new("at_high", "AAAATTTT", "AAAATTTT", "IIIIIIII", "IIIIIIII", "none"), + @src.TrimResult::new( + "gc_high", "GGGGCCCC", "GGGGCCCC", "IIIIIIII", "IIIIIIII", "none", + ), + @src.TrimResult::new( + "at_high", "AAAATTTT", "AAAATTTT", "IIIIIIII", "IIIIIIII", "none", + ), ] let stats = @src.sqt_compute_stats(results, reads) assert_true(stats.gc_content_before > 0.4) @@ -455,12 +470,8 @@ test "sqt_compute_stats_empty" { ///| test "sqt_compute_stats_all_discarded" { - let reads = [ - @src.FastqRead::new("r1", "ACGT", "IIII"), - ] - let results = [ - @src.TrimResult::new("r1", "ACGT", "", "IIII", "", "quality"), - ] + let reads = [@src.FastqRead::new("r1", "ACGT", "IIII")] + let results = [@src.TrimResult::new("r1", "ACGT", "", "IIII", "", "quality")] let stats = @src.sqt_compute_stats(results, reads) assert_eq(stats.total_reads, 1) assert_eq(stats.kept_reads, 0) @@ -532,9 +543,7 @@ test "sqt_fastq_parse_multiple_with_variable_length" { ///| test "sqt_fastq_serialize_single" { - let reads = [ - @src.FastqRead::new("test1", "ACGT", "IIII"), - ] + let reads = [@src.FastqRead::new("test1", "ACGT", "IIII")] let output = @src.sqt_fastq_serialize(reads) assert_eq(output, "@test1\nACGT\n+\nIIII\n") } @@ -561,4 +570,4 @@ test "sqt_fastq_roundtrip" { assert_eq(reparsed[0].sequence, "ACGTACGT") assert_eq(reparsed[1].id, "sample2") assert_eq(reparsed[1].sequence, "TGCA") -} \ No newline at end of file +} diff --git a/test/moonbit/seqfeature_advanced_test.mbt b/test/moonbit/seqfeature_advanced_test.mbt index 63ac3e2b..625fbfda 100644 --- a/test/moonbit/seqfeature_advanced_test.mbt +++ b/test/moonbit/seqfeature_advanced_test.mbt @@ -580,4 +580,4 @@ test "seq_feature_extended_qualifiers_independent" { let feat2 = feat1.add_qualifier("gene", "BRCA1") assert_eq(feat1.qualifiers().length(), 0) assert_eq(feat2.qualifiers().length(), 1) -} \ No newline at end of file +} diff --git a/test/moonbit/seqio_advanced_test.mbt b/test/moonbit/seqio_advanced_test.mbt index d249c719..ffd0df6f 100644 --- a/test/moonbit/seqio_advanced_test.mbt +++ b/test/moonbit/seqio_advanced_test.mbt @@ -10,8 +10,7 @@ ///| test "parse_embl_basic_single" { - let embl_text = - "ID HSBGLOD; SV 1; linear; genomic DNA; STD; HUM; 500 BP.\n" + + let embl_text = "ID HSBGLOD; SV 1; linear; genomic DNA; STD; HUM; 500 BP.\n" + "XX\n" + "AC M12345;\n" + "XX\n" + @@ -26,13 +25,15 @@ test "parse_embl_basic_single" { assert_eq(records[0].id, "M12345") assert_eq(records[0].name, "HSBGLOD") assert_eq(records[0].description, "Human beta-globin gene region") - assert_eq(records[0].seq.to_string(), "ATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGC") + assert_eq( + records[0].seq.to_string(), + "ATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGCATGC", + ) } ///| test "parse_embl_multiple_records" { - let embl_text = - "ID SEQ1; SV 1; linear; DNA; STD; 10 BP.\n" + + let embl_text = "ID SEQ1; SV 1; linear; DNA; STD; 10 BP.\n" + "XX\n" + "AC ACC001;\n" + "XX\n" + @@ -63,8 +64,7 @@ test "parse_embl_multiple_records" { ///| test "parse_embl_no_ac_uses_id" { - let embl_text = - "ID MYSEQ; SV 1; linear; DNA; STD; 4 BP.\n" + + let embl_text = "ID MYSEQ; SV 1; linear; DNA; STD; 4 BP.\n" + "XX\n" + "DE Sequence without accession.\n" + "XX\n" + @@ -82,8 +82,7 @@ test "parse_embl_no_ac_uses_id" { ///| test "parse_pir_basic" { - let pir_text = - ">P1;ALB_HUMAN\n" + + let pir_text = ">P1;ALB_HUMAN\n" + "Serum albumin precursor (Human).\n" + "MKWVTFISLLFLFSSAYSRGVFRRDTHKSEIAHRFKDLGEEHFKGLVLIAFSQYLQQCPFDEHVKLVNELTEFAK*" let records = @src.parse_pir(pir_text) @@ -97,8 +96,7 @@ test "parse_pir_basic" { ///| test "parse_pir_multiple" { - let pir_text = - ">P1;PROT1\n" + + let pir_text = ">P1;PROT1\n" + "Protein one.\n" + "MVLSQDEVVCF* \n" + ">P1;PROT2\n" + @@ -114,10 +112,7 @@ test "parse_pir_multiple" { ///| test "parse_pir_sequence_spaces_ignored" { - let pir_text = - ">DL;DNA1\n" + - "Linear DNA fragment.\n" + - "atgc atgc atgc *" + let pir_text = ">DL;DNA1\n" + "Linear DNA fragment.\n" + "atgc atgc atgc *" let records = @src.parse_pir(pir_text) assert_eq(records.length(), 1) assert_eq(records[0].id, "DNA1") @@ -227,8 +222,18 @@ test "write_genbank_sequence_format" { ///| test "write_genbank_multiple_records" { - let r1 = @src.SeqRecord::new(@src.Seq::new("ACGT"), id="A1", name="L1", description="First") - let r2 = @src.SeqRecord::new(@src.Seq::new("TGCA"), id="B2", name="L2", description="Second") + let r1 = @src.SeqRecord::new( + @src.Seq::new("ACGT"), + id="A1", + name="L1", + description="First", + ) + let r2 = @src.SeqRecord::new( + @src.Seq::new("TGCA"), + id="B2", + name="L2", + description="Second", + ) let out = @src.write_genbank([r1, r2]) // Should have two LOCUS and two terminators assert_eq(out.split("LOCUS").length(), 3) // includes 1 before first match @@ -239,8 +244,7 @@ test "write_genbank_multiple_records" { ///| test "seqio_parse_embl_through_unified" { - let embl = - "ID S1; SV 1; linear; DNA; STD; 4 BP.\n" + + let embl = "ID S1; SV 1; linear; DNA; STD; 4 BP.\n" + "XX\n" + "AC A001;\n" + "XX\n" + @@ -287,9 +291,7 @@ test "seqio_parse_tab_through_unified" { ///| test "seqio_write_genbank_tab_through_unified" { - let records = [ - @src.SeqRecord::new(@src.Seq::new("ACGT"), id="r1"), - ] + let records = [@src.SeqRecord::new(@src.Seq::new("ACGT"), id="r1")] try { let gb_text = @src.seqio_write(records, "genbank") assert_true(gb_text.contains("LOCUS")) diff --git a/test/moonbit/seqlogo_test.mbt b/test/moonbit/seqlogo_test.mbt index 6e6b7019..1f958e2e 100644 --- a/test/moonbit/seqlogo_test.mbt +++ b/test/moonbit/seqlogo_test.mbt @@ -9,12 +9,7 @@ ///| test "seqlogo_pwm_new_basic" { - let matrix = [ - [0.25, 0.25], - [0.25, 0.25], - [0.25, 0.25], - [0.25, 0.25], - ] + let matrix = [[0.25, 0.25], [0.25, 0.25], [0.25, 0.25], [0.25, 0.25]] let pwm = @src.SeqLogoPwm::new(matrix) assert_eq(pwm.width(), 2) assert_eq(pwm.alphabet_size(), 4) @@ -22,12 +17,7 @@ test "seqlogo_pwm_new_basic" { ///| test "seqlogo_pwm_new_get_values" { - let matrix = [ - [0.9, 0.1], - [0.03, 0.1], - [0.04, 0.7], - [0.03, 0.1], - ] + let matrix = [[0.9, 0.1], [0.03, 0.1], [0.04, 0.7], [0.03, 0.1]] let pwm = @src.SeqLogoPwm::new(matrix) assert_true((pwm.get(0, 0) - 0.9).abs() < 0.001) assert_true((pwm.get(0, 1) - 0.1).abs() < 0.001) @@ -39,10 +29,10 @@ test "seqlogo_pwm_new_get_values" { test "seqlogo_pwm_new_get_out_of_bounds" { let matrix = [[0.25], [0.25], [0.25], [0.25]] let pwm = @src.SeqLogoPwm::new(matrix) - assert_true((pwm.get(-1, 0)).abs() < 0.001) - assert_true((pwm.get(4, 0)).abs() < 0.001) - assert_true((pwm.get(0, -1)).abs() < 0.001) - assert_true((pwm.get(0, 100)).abs() < 0.001) + assert_true(pwm.get(-1, 0).abs() < 0.001) + assert_true(pwm.get(4, 0).abs() < 0.001) + assert_true(pwm.get(0, -1).abs() < 0.001) + assert_true(pwm.get(0, 100).abs() < 0.001) } ///| @@ -89,8 +79,8 @@ test "seqlogo_from_sequences_basic" { // Position 3: all T -> freq 1.0 assert_true((pwm.get(3, 3) - 1.0).abs() < 0.001) // Off-diagonal frequencies are 0 - assert_true((pwm.get(0, 1)).abs() < 0.001) - assert_true((pwm.get(1, 0)).abs() < 0.001) + assert_true(pwm.get(0, 1).abs() < 0.001) + assert_true(pwm.get(1, 0).abs() < 0.001) } ///| @@ -134,7 +124,7 @@ test "seqlogo_letter_new_and_accessors" { test "seqlogo_letter_zero_height" { let letter = @src.SeqLogoLetter::new('T', 0.0, "#CC0000") assert_eq(letter.letter(), 'T') - assert_true((letter.height()).abs() < 0.001) + assert_true(letter.height().abs() < 0.001) assert_eq(letter.color(), "#CC0000") } @@ -168,28 +158,18 @@ test "seqlogo_column_add_letter" { ///| test "seqlogo_ic_uniform_pwm_zero" { // All positions have uniform 0.25 frequency -> IC = 0 - let matrix = [ - [0.25, 0.25], - [0.25, 0.25], - [0.25, 0.25], - [0.25, 0.25], - ] + let matrix = [[0.25, 0.25], [0.25, 0.25], [0.25, 0.25], [0.25, 0.25]] let pwm = @src.SeqLogoPwm::new(matrix) let ic = @src.seqlogo_information_content(pwm) assert_eq(ic.length(), 2) - assert_true((ic[0]).abs() < 0.001) - assert_true((ic[1]).abs() < 0.001) + assert_true(ic[0].abs() < 0.001) + assert_true(ic[1].abs() < 0.001) } ///| test "seqlogo_ic_conserved_position" { // Fully conserved A -> IC = log2(4) = 2.0 - let matrix = [ - [1.0], - [0.0], - [0.0], - [0.0], - ] + let matrix = [[1.0], [0.0], [0.0], [0.0]] let pwm = @src.SeqLogoPwm::new(matrix) let ic = @src.seqlogo_information_content(pwm) assert_eq(ic.length(), 1) @@ -201,12 +181,7 @@ test "seqlogo_ic_mixed_position" { // A=0.5, C=0.25, G=0.125, T=0.125 // IC = 0.5*log2(2) + 0.25*log2(1) + 0.125*log2(0.5) + 0.125*log2(0.5) // = 0.5 - 0.125 - 0.125 = 0.25 - let matrix = [ - [0.5], - [0.25], - [0.125], - [0.125], - ] + let matrix = [[0.5], [0.25], [0.125], [0.125]] let pwm = @src.SeqLogoPwm::new(matrix) let ic = @src.seqlogo_information_content(pwm) assert_true((ic[0] - 0.25).abs() < 0.001) @@ -223,12 +198,7 @@ test "seqlogo_ic_bg_non_uniform" { // IC = 0.5*log2(0.5/0.1) + 0.5*log2(0.5/0.4) // = 0.5*log2(5) + 0.5*log2(1.25) // = 0.5*2.321928 + 0.5*0.321928 = 1.321928 - let matrix = [ - [0.5], - [0.5], - [0.0], - [0.0], - ] + let matrix = [[0.5], [0.5], [0.0], [0.0]] let pwm = @src.SeqLogoPwm::new(matrix) let ic = @src.seqlogo_information_content_bg(pwm, [0.1, 0.4, 0.4, 0.1]) assert_true((ic[0] - 1.321928).abs() < 0.001) @@ -236,17 +206,10 @@ test "seqlogo_ic_bg_non_uniform" { ///| test "seqlogo_ic_bg_uniform_equals_default" { - let matrix = [ - [0.9], - [0.03], - [0.04], - [0.03], - ] + let matrix = [[0.9], [0.03], [0.04], [0.03]] let pwm = @src.SeqLogoPwm::new(matrix) let ic_default = @src.seqlogo_information_content(pwm) - let ic_bg = @src.seqlogo_information_content_bg(pwm, [ - 0.25, 0.25, 0.25, 0.25, - ]) + let ic_bg = @src.seqlogo_information_content_bg(pwm, [0.25, 0.25, 0.25, 0.25]) assert_eq(ic_default.length(), ic_bg.length()) assert_true((ic_default[0] - ic_bg[0]).abs() < 0.001) } @@ -258,12 +221,7 @@ test "seqlogo_ic_bg_uniform_equals_default" { ///| test "seqlogo_total_ic_conserved" { // Two fully conserved positions -> total IC = 4.0 - let matrix = [ - [1.0, 1.0], - [0.0, 0.0], - [0.0, 0.0], - [0.0, 0.0], - ] + let matrix = [[1.0, 1.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0]] let pwm = @src.SeqLogoPwm::new(matrix) let total = @src.seqlogo_total_information_content(pwm) assert_true((total - 4.0).abs() < 0.001) @@ -303,8 +261,8 @@ test "seqlogo_max_ic_protein" { ///| test "seqlogo_max_ic_edge_cases" { // alphabet_size <= 1 -> 0.0 - assert_true((@src.seqlogo_max_information_content(0)).abs() < 0.001) - assert_true((@src.seqlogo_max_information_content(1)).abs() < 0.001) + assert_true(@src.seqlogo_max_information_content(0).abs() < 0.001) + assert_true(@src.seqlogo_max_information_content(1).abs() < 0.001) // Binary alphabet -> log2(2) = 1.0 assert_true((@src.seqlogo_max_information_content(2) - 1.0).abs() < 0.001) } @@ -315,12 +273,7 @@ test "seqlogo_max_ic_edge_cases" { ///| test "seqlogo_compute_logo_columns_count" { - let matrix = [ - [0.25, 1.0], - [0.25, 0.0], - [0.25, 0.0], - [0.25, 0.0], - ] + let matrix = [[0.25, 1.0], [0.25, 0.0], [0.25, 0.0], [0.25, 0.0]] let pwm = @src.SeqLogoPwm::new(matrix) let logo = @src.seqlogo_compute_logo(pwm) assert_eq(logo.width(), 2) @@ -330,12 +283,7 @@ test "seqlogo_compute_logo_columns_count" { ///| test "seqlogo_compute_logo_conserved_heights" { // Fully conserved A: IC=2.0, A height=2.0, others=0.0 - let matrix = [ - [1.0], - [0.0], - [0.0], - [0.0], - ] + let matrix = [[1.0], [0.0], [0.0], [0.0]] let pwm = @src.SeqLogoPwm::new(matrix) let logo = @src.seqlogo_compute_logo(pwm) let col = logo.columns()[0] @@ -345,37 +293,27 @@ test "seqlogo_compute_logo_conserved_heights" { assert_eq(col.letters()[0].letter(), 'A') assert_true((col.letters()[0].height() - 2.0).abs() < 0.001) // Other letters have height 0 - assert_true((col.letters()[1].height()).abs() < 0.001) - assert_true((col.letters()[2].height()).abs() < 0.001) - assert_true((col.letters()[3].height()).abs() < 0.001) + assert_true(col.letters()[1].height().abs() < 0.001) + assert_true(col.letters()[2].height().abs() < 0.001) + assert_true(col.letters()[3].height().abs() < 0.001) } ///| test "seqlogo_compute_logo_uniform_zero_ic" { - let matrix = [ - [0.25], - [0.25], - [0.25], - [0.25], - ] + let matrix = [[0.25], [0.25], [0.25], [0.25]] let pwm = @src.SeqLogoPwm::new(matrix) let logo = @src.seqlogo_compute_logo(pwm) let col = logo.columns()[0] - assert_true((col.info_content()).abs() < 0.001) + assert_true(col.info_content().abs() < 0.001) // All letter heights are 0 since IC=0 for letter in col.letters() { - assert_true((letter.height()).abs() < 0.001) + assert_true(letter.height().abs() < 0.001) } } ///| test "seqlogo_compute_logo_total_ic" { - let matrix = [ - [1.0, 0.25], - [0.0, 0.25], - [0.0, 0.25], - [0.0, 0.25], - ] + let matrix = [[1.0, 0.25], [0.0, 0.25], [0.0, 0.25], [0.0, 0.25]] let pwm = @src.SeqLogoPwm::new(matrix) let logo = @src.seqlogo_compute_logo(pwm) // Position 0: IC=2.0, Position 1: IC=0.0 -> total = 2.0 @@ -384,12 +322,7 @@ test "seqlogo_compute_logo_total_ic" { ///| test "seqlogo_compute_logo_letter_colors" { - let matrix = [ - [1.0], - [0.0], - [0.0], - [0.0], - ] + let matrix = [[1.0], [0.0], [0.0], [0.0]] let pwm = @src.SeqLogoPwm::new(matrix) let logo = @src.seqlogo_compute_logo(pwm) let col = logo.columns()[0] @@ -451,12 +384,12 @@ test "seqlogo_to_ascii_contains_letters" { ///| test "seqlogo_to_ascii_zero_height" { - let ascii = @src.seqlogo_to_ascii(@src.seqlogo_compute_logo(@src.SeqLogoPwm::new([ - [0.25], - [0.25], - [0.25], - [0.25], - ])), 5) + let ascii = @src.seqlogo_to_ascii( + @src.seqlogo_compute_logo( + @src.SeqLogoPwm::new([[0.25], [0.25], [0.25], [0.25]]), + ), + 5, + ) // IC=0 so no letters rendered, only spaces and newlines assert_true(ascii.length() > 0) assert_false(ascii.contains("A")) @@ -480,12 +413,7 @@ test "seqlogo_to_text_table_has_header" { ///| test "seqlogo_to_text_table_tab_separated" { - let matrix = [ - [1.0], - [0.0], - [0.0], - [0.0], - ] + let matrix = [[1.0], [0.0], [0.0], [0.0]] let pwm = @src.SeqLogoPwm::new(matrix) let logo = @src.seqlogo_compute_logo(pwm) let table = @src.seqlogo_to_text_table(logo) @@ -528,12 +456,7 @@ test "seqlogo_consensus_from_sequences" { ///| test "seqlogo_consensus_tie_first_base" { // When frequencies are tied, the lowest-index base wins - let matrix = [ - [0.25], - [0.25], - [0.25], - [0.25], - ] + let matrix = [[0.25], [0.25], [0.25], [0.25]] let pwm = @src.SeqLogoPwm::new(matrix) let consensus = @src.seqlogo_consensus_sequence(pwm) assert_eq(consensus, "A") @@ -556,12 +479,7 @@ test "seqlogo_logo_summary_non_empty" { ///| test "seqlogo_logo_summary_width" { - let matrix = [ - [1.0, 0.25], - [0.0, 0.25], - [0.0, 0.25], - [0.0, 0.25], - ] + let matrix = [[1.0, 0.25], [0.0, 0.25], [0.0, 0.25], [0.0, 0.25]] let pwm = @src.SeqLogoPwm::new(matrix) let logo = @src.seqlogo_compute_logo(pwm) let summary = @src.seqlogo_logo_summary(logo) @@ -610,12 +528,7 @@ test "seqlogo_sample_pwm_from_sample_sequences" { ///| test "seqlogo_edge_single_position" { - let matrix = [ - [1.0], - [0.0], - [0.0], - [0.0], - ] + let matrix = [[1.0], [0.0], [0.0], [0.0]] let pwm = @src.SeqLogoPwm::new(matrix) assert_eq(pwm.width(), 1) let ic = @src.seqlogo_information_content(pwm) @@ -654,7 +567,7 @@ test "seqlogo_edge_all_equal_frequencies" { assert_true(v.abs() < 0.001) } let logo = @src.seqlogo_compute_logo(pwm) - assert_true((logo.total_ic()).abs() < 0.001) + assert_true(logo.total_ic().abs() < 0.001) } ///| @@ -695,12 +608,7 @@ test "seqlogo_edge_to_ascii_zero_max_height" { ///| test "seqlogo_compute_logo_bg_non_uniform" { - let matrix = [ - [0.5], - [0.5], - [0.0], - [0.0], - ] + let matrix = [[0.5], [0.5], [0.0], [0.0]] let pwm = @src.SeqLogoPwm::new(matrix) let logo = @src.seqlogo_compute_logo_bg(pwm, [0.1, 0.4, 0.4, 0.1]) let col = logo.columns()[0] diff --git a/test/moonbit/seqxml_io_test.mbt b/test/moonbit/seqxml_io_test.mbt index ecb563e4..58ae344e 100644 --- a/test/moonbit/seqxml_io_test.mbt +++ b/test/moonbit/seqxml_io_test.mbt @@ -10,14 +10,8 @@ ///| test "seqxml_type_from_tag" { // Known tags map to their corresponding types. - assert_eq( - @src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("dna")), - "dna", - ) - assert_eq( - @src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("rna")), - "rna", - ) + assert_eq(@src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("dna")), "dna") + assert_eq(@src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("rna")), "rna") assert_eq( @src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("protein")), "protein", @@ -27,24 +21,33 @@ test "seqxml_type_from_tag" { @src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("xyz")), "unknown", ) - assert_eq( - @src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("")), - "unknown", - ) + assert_eq(@src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("")), "unknown") } ///| test "seqxml_type_to_tag" { assert_eq(@src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("dna")), "dna") assert_eq(@src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("rna")), "rna") - assert_eq(@src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("protein")), "protein") - assert_eq(@src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("unknown")), "unknown") + assert_eq( + @src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("protein")), + "protein", + ) + assert_eq( + @src.SeqXmlType::to_tag(@src.SeqXmlType::from_tag("unknown")), + "unknown", + ) } ///| test "seqxml_type_description" { - assert_eq(@src.SeqXmlType::description(@src.SeqXmlType::from_tag("dna")), "DNA") - assert_eq(@src.SeqXmlType::description(@src.SeqXmlType::from_tag("rna")), "RNA") + assert_eq( + @src.SeqXmlType::description(@src.SeqXmlType::from_tag("dna")), + "DNA", + ) + assert_eq( + @src.SeqXmlType::description(@src.SeqXmlType::from_tag("rna")), + "RNA", + ) assert_eq( @src.SeqXmlType::description(@src.SeqXmlType::from_tag("protein")), "Protein", @@ -234,8 +237,7 @@ test "seqxml_document_full_metadata" { ///| test "seqxml_parse_dna_entry" { - let content = - "\n" + + let content = "\n" + "\n" + " \n" + " ATGCATGC\n" + @@ -253,8 +255,7 @@ test "seqxml_parse_dna_entry" { ///| test "seqxml_parse_rna_entry" { - let content = - "\n" + + let content = "\n" + "\n" + " \n" + " AUGCAUGC\n" + @@ -271,8 +272,7 @@ test "seqxml_parse_rna_entry" { ///| test "seqxml_parse_protein_entry" { - let content = - "\n" + + let content = "\n" + "\n" + " \n" + " MKLVGV\n" + @@ -289,8 +289,7 @@ test "seqxml_parse_protein_entry" { ///| test "seqxml_parse_with_species_sourcedb" { - let content = - "\n" + + let content = "\n" + "\n" + " \n" + " \n" + @@ -311,8 +310,7 @@ test "seqxml_parse_with_species_sourcedb" { ///| test "seqxml_parse_with_properties" { - let content = - "\n" + + let content = "\n" + "\n" + " \n" + " \n" + @@ -336,8 +334,7 @@ test "seqxml_parse_with_properties" { ///| test "seqxml_parse_multiple_entries" { - let content = - "\n" + + let content = "\n" + "\n" + " ACGT\n" + " AUGU\n" + @@ -450,7 +447,9 @@ test "seqxml_document_to_xml" { assert_true(xml.contains("")) assert_true(xml.contains("")) - assert_true(xml.contains("")) + assert_true( + xml.contains(""), + ) assert_true(xml.contains("")) assert_true(xml.contains("")) assert_true(xml.contains("ACGT")) @@ -482,8 +481,7 @@ test "seqxml_document_to_xml_no_metadata" { ///| test "seqxml_roundtrip_basic" { - let original = - "\n" + + let original = "\n" + "\n" + " \n" + " ACGTACGT\n" + @@ -502,8 +500,7 @@ test "seqxml_roundtrip_basic" { ///| test "seqxml_roundtrip_with_metadata" { - let original = - "\n" + + let original = "\n" + "\n" + " \n" + " \n" + @@ -526,8 +523,7 @@ test "seqxml_roundtrip_with_metadata" { ///| test "seqxml_roundtrip_with_properties" { - let original = - "\n" + + let original = "\n" + "\n" + " \n" + " \n" + @@ -553,8 +549,7 @@ test "seqxml_roundtrip_with_properties" { ///| test "seqxml_roundtrip_multiple_entries" { - let original = - "\n" + + let original = "\n" + "\n" + " ACGT\n" + " AUGU\n" + @@ -753,8 +748,7 @@ test "seqxml_parse_empty_document" { ///| test "seqxml_parse_no_entries" { - let content = - "\n" + + let content = "\n" + "\n" + " \n" + "\n" @@ -767,8 +761,7 @@ test "seqxml_parse_no_entries" { ///| test "seqxml_parse_entry_without_description" { - let content = - "\n" + + let content = "\n" + "\n" + " \n" + " ACGT\n" + @@ -786,8 +779,7 @@ test "seqxml_parse_entry_without_description" { ///| test "seqxml_parse_self_closing_entry" { // Self-closing has no sequence element. - let content = - "\n" + + let content = "\n" + "\n" + " \n" + "\n" @@ -803,8 +795,7 @@ test "seqxml_parse_self_closing_entry" { ///| test "seqxml_entity_escaping_in_description" { // Parsing should unescape XML entities in the desc attribute. - let content = - "\n" + + let content = "\n" + "\n" + " \n" + " ACGT\n" + @@ -818,8 +809,7 @@ test "seqxml_entity_escaping_in_description" { ///| test "seqxml_entity_escaping_in_sequence" { // Parsing should unescape XML entities in the sequence text content. - let content = - "\n" + + let content = "\n" + "\n" + " \n" + " AC&T<G\n" + @@ -855,8 +845,7 @@ test "seqxml_entity_escaping_roundtrip" { description="Quote \" and amp & and lt <", ) let xml = @src.seqxml_entry_to_xml(entry) - let content = - "\n" + + let content = "\n" + "\n" + xml + "\n" diff --git a/test/moonbit/seurat_test.mbt b/test/moonbit/seurat_test.mbt index fc0dfb9c..8635b7f3 100644 --- a/test/moonbit/seurat_test.mbt +++ b/test/moonbit/seurat_test.mbt @@ -20,7 +20,7 @@ test "seurat_simple_pipeline" { let with_neighbors = @src.find_neighbors(with_pca) let with_clusters = @src.find_clusters(with_neighbors) let with_umap = @src.run_umap(with_pca) - + assert_eq(with_clusters.clusters.length(), 200) assert_eq(with_umap.umap.length(), 200) } @@ -31,7 +31,7 @@ test "normalize_total" { let normalized = @src.normalize_total(obj) assert_eq(normalized.data.length(), 500) assert_eq(normalized.data[0].length(), 200) - + let mut has_positive = false let mut i = 0 while i < normalized.data.length() && !has_positive { @@ -73,12 +73,12 @@ test "run_pca" { let with_hvg = @src.find_variable_features(normalized) let scaled = @src.scale_data(with_hvg) let with_pca = @src.run_pca(scaled) - + assert_true(with_pca.pca.length() > 0) assert_true(with_pca.pca[0].length() > 0) assert_eq(with_pca.pca.length(), 200) assert_true(with_pca.var_explained.length() > 0) - + let mut sum_var = 0.0 let mut i = 0 while i < with_pca.var_explained.length() { @@ -96,7 +96,7 @@ test "find_neighbors" { let scaled = @src.scale_data(with_hvg) let with_pca = @src.run_pca(scaled) let with_neighbors = @src.find_neighbors(with_pca) - + assert_eq(with_neighbors.neighbors.length(), 200) assert_true(with_neighbors.neighbors[0].length() > 0) } @@ -110,9 +110,9 @@ test "find_clusters" { let with_pca = @src.run_pca(scaled) let with_neighbors = @src.find_neighbors(with_pca) let with_clusters = @src.find_clusters(with_neighbors) - + assert_eq(with_clusters.clusters.length(), 200) - + let unique_clusters : Array[Int] = Array::new() let mut i = 0 while i < with_clusters.clusters.length() { @@ -142,7 +142,7 @@ test "run_umap" { let scaled = @src.scale_data(with_hvg) let with_pca = @src.run_pca(scaled) let with_umap = @src.run_umap(with_pca) - + assert_eq(with_umap.umap.length(), 200) assert_eq(with_umap.umap[0].length(), 2) } @@ -156,11 +156,11 @@ test "find_all_markers" { let with_pca = @src.run_pca(scaled) let with_neighbors = @src.find_neighbors(with_pca) let with_clusters = @src.find_clusters(with_neighbors) - + let markers = @src.find_all_markers(with_clusters) - + assert_true(markers.length() >= 0) - + if markers.length() > 0 { let m = markers[0] assert_true(m.gene.length() > 0) @@ -171,25 +171,27 @@ test "find_all_markers" { test "find_integration_anchors" { let ref_obj = @src.seurat_create_example_data() let query_obj = @src.seurat_create_example_data() - + let ref_normalized = @src.normalize_total(ref_obj) let ref_with_hvg = @src.find_variable_features(ref_normalized) let ref_scaled = @src.scale_data(ref_with_hvg) let ref_with_pca = @src.run_pca(ref_scaled) - + let query_normalized = @src.normalize_total(query_obj) let query_with_hvg = @src.find_variable_features(query_normalized) let query_scaled = @src.scale_data(query_with_hvg) let query_with_pca = @src.run_pca(query_scaled) - + assert_true(ref_with_pca.pca.length() > 0) assert_true(query_with_pca.pca.length() > 0) assert_eq(ref_with_pca.pca.length(), ref_obj.col_names.length()) assert_eq(query_with_pca.pca.length(), query_obj.col_names.length()) - + let dims = [0] - let anchors = @src.find_integration_anchors(ref_with_pca, query_with_pca, dims) - + let anchors = @src.find_integration_anchors( + ref_with_pca, query_with_pca, dims, + ) + assert_eq(anchors.reference_indices.length(), anchors.anchors.length()) assert_eq(anchors.query_indices.length(), anchors.anchors.length()) } @@ -198,26 +200,31 @@ test "find_integration_anchors" { test "integrate_data" { let ref_obj = @src.seurat_create_example_data() let query_obj = @src.seurat_create_example_data() - + let ref_normalized = @src.normalize_total(ref_obj) let ref_with_hvg = @src.find_variable_features(ref_normalized) let ref_scaled = @src.scale_data(ref_with_hvg) let ref_with_pca = @src.run_pca(ref_scaled) - + let query_normalized = @src.normalize_total(query_obj) let query_with_hvg = @src.find_variable_features(query_normalized) let query_scaled = @src.scale_data(query_with_hvg) let query_with_pca = @src.run_pca(query_scaled) - + let dims = [0, 1, 2, 3, 4] - let anchors = @src.find_integration_anchors(ref_with_pca, query_with_pca, dims) - + let anchors = @src.find_integration_anchors( + ref_with_pca, query_with_pca, dims, + ) + let integrated = @src.integrate_data(ref_obj, query_obj, anchors) - + assert_true(integrated.counts.length() > 0) - assert_true(integrated.col_names.length() == ref_obj.col_names.length() + query_obj.col_names.length()) + assert_true( + integrated.col_names.length() == + ref_obj.col_names.length() + query_obj.col_names.length(), + ) assert_eq(integrated.row_names.length(), integrated.counts.length()) - + let mut has_ref_prefix = false let mut has_query_prefix = false for name in integrated.col_names { diff --git a/test/moonbit/sff_io_test.mbt b/test/moonbit/sff_io_test.mbt index 200c1ee1..93b9ddd4 100644 --- a/test/moonbit/sff_io_test.mbt +++ b/test/moonbit/sff_io_test.mbt @@ -34,7 +34,9 @@ test "sff_read_new" { let qualities = [10, 20, 30, 25] let flowgram = [1.0, 0.0, 1.0, 0.0] let flow_index = [1, 3, 1, 3] - let read = @src.SffRead::new("READ001", "ACGT", qualities, flowgram, flow_index, 1, 4, 0, 0) + let read = @src.SffRead::new( + "READ001", "ACGT", qualities, flowgram, flow_index, 1, 4, 0, 0, + ) assert_eq(read.name, "READ001") assert_eq(read.bases, "ACGT") assert_eq(read.n_bases, 4) @@ -137,7 +139,10 @@ test "sff_encode_parse_roundtrip" { ///| test "sff_parse_invalid_magic" { // Create bytes with wrong magic number - let bytes = [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 40, 0, 4, 0, 4, 0, 1] + let bytes = [ + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 40, + 0, 4, 0, 4, 0, 1, + ] let result = @src.sff_parse(bytes) assert_true(result is None) } diff --git a/test/moonbit/sgseq_test.mbt b/test/moonbit/sgseq_test.mbt index b45ca1e4..61c1ac1e 100644 --- a/test/moonbit/sgseq_test.mbt +++ b/test/moonbit/sgseq_test.mbt @@ -53,11 +53,7 @@ test "sg_junction_default_strand_count" { ///| test "sg_junction_intron_length" { - let j = @src.SGSeqJunction::new( - chr="chr1", - start=1000, - end=2000, - ) + let j = @src.SGSeqJunction::new(chr="chr1", start=1000, end=2000) // intron_length = end - start - 1 = 999 assert_eq(j.intron_length(), 999) } @@ -352,9 +348,7 @@ test "sg_detect_ri" { let junctions = [ @src.SGSeqJunction::new(chr="chr1", start=100, end=500, count=5), ] - let exons = [ - @src.SGSeqExon::new(chr="chr1", start=100, end=500, strand="+"), - ] + let exons = [@src.SGSeqExon::new(chr="chr1", start=100, end=500, strand="+")] let variants = @src.sgseq_detect_ri(junctions, exons) // Should detect an RI event (low junction count with overlapping exon) assert_true(variants.length() >= 1) @@ -373,7 +367,13 @@ test "sg_detect_all_variants" { // All variants should have valid type names for v in variants { let name = v.type_name() - assert_true(name == "SE" || name == "A5SS" || name == "A3SS" || name == "MXE" || name == "RI") + assert_true( + name == "SE" || + name == "A5SS" || + name == "A3SS" || + name == "MXE" || + name == "RI", + ) } } diff --git a/test/moonbit/single_r_test.mbt b/test/moonbit/single_r_test.mbt index df9f374b..ead1527a 100644 --- a/test/moonbit/single_r_test.mbt +++ b/test/moonbit/single_r_test.mbt @@ -88,7 +88,9 @@ test "single_r_rank_values_ties" { test "single_r_compute_correlations" { let ref_data = @src.single_r_create_reference_data() let cell_expr = ref_data.profiles[0].expression - let scores = @src.single_r_compute_correlations(cell_expr, ref_data, "spearman") + let scores = @src.single_r_compute_correlations( + cell_expr, ref_data, "spearman", + ) assert_eq(scores.length(), ref_data.n_profiles) assert_true(scores[0] > 0.0) } @@ -105,7 +107,11 @@ test "single_r_get_top_scores" { ///| test "single_r_aggregate_scores_by_type" { let ref_data = @src.single_r_create_reference_data() - let scores = @src.single_r_compute_correlations(ref_data.profiles[0].expression, ref_data, "spearman") + let scores = @src.single_r_compute_correlations( + ref_data.profiles[0].expression, + ref_data, + "spearman", + ) let agg = @src.single_r_aggregate_scores_by_type(scores, ref_data, 1) assert_true(agg.size() > 0) assert_true(agg.contains("T cells")) @@ -131,11 +137,13 @@ test "single_r_compute_delta_score" { test "single_r_annotate_cell" { let ref_data = @src.single_r_create_reference_data() let params = @src.SingleRParams::new() - + // Test with a T cell-like expression let cell_expr = ref_data.profiles[0].expression - let result = @src.single_r_annotate_cell(cell_expr, "test_t_cell", ref_data, params) - + let result = @src.single_r_annotate_cell( + cell_expr, "test_t_cell", ref_data, params, + ) + assert_eq(result.cell_id, "test_t_cell") assert_true(result.scores.length() > 0) assert_true(result.first_annotation_fine.length() > 0) @@ -146,11 +154,13 @@ test "single_r_annotate_cell" { test "single_r_annotate_cell_b_cell" { let ref_data = @src.single_r_create_reference_data() let params = @src.SingleRParams::new() - + // Test with a B cell-like expression let cell_expr = ref_data.profiles[1].expression - let result = @src.single_r_annotate_cell(cell_expr, "test_b_cell", ref_data, params) - + let result = @src.single_r_annotate_cell( + cell_expr, "test_b_cell", ref_data, params, + ) + assert_true(result.first_annotation_fine.length() > 0) assert_true(result.scores[0] > 0.0) } @@ -160,9 +170,9 @@ test "single_r_annotate_all_cells" { let ref_data = @src.single_r_create_reference_data() let test_data = @src.single_r_create_test_data() let params = @src.SingleRParams::new() - + let result = @src.single_r_annotate_cells(test_data, ref_data, params) - + assert_eq(result.cell_ids.length(), 50) assert_eq(result.labels.length(), 50) assert_eq(result.scores.length(), 50) @@ -175,10 +185,10 @@ test "single_r_annotation_summary" { let ref_data = @src.single_r_create_reference_data() let test_data = @src.single_r_create_test_data() let params = @src.SingleRParams::new() - + let result = @src.single_r_annotate_cells(test_data, ref_data, params) let summary = @src.single_r_annotation_summary(result) - + assert_true(summary.size() > 0) assert_true(summary.contains("n_cells")) assert_eq(summary.get("n_cells").unwrap_or(0.0), 50.0) @@ -206,9 +216,9 @@ test "single_r_pearson_annotation" { let ref_data = @src.single_r_create_reference_data() let test_data = @src.single_r_create_test_data() let params = @src.SingleRParams::with_method("pearson") - + let result = @src.single_r_annotate_cells(test_data, ref_data, params) - + assert_eq(result.cell_ids.length(), 50) assert_true(result.scores.length() > 0) assert_true(result.scores[0] > 0.0) @@ -216,16 +226,14 @@ test "single_r_pearson_annotation" { ///| test "single_r_reference_dataset_from_matrix" { - let expression = [ - [1.0, 2.0, 3.0], - [4.0, 5.0, 6.0], - [7.0, 8.0, 9.0], - ] + let expression = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]] let cell_types = ["TypeA", "TypeB", "TypeC"] let gene_names = ["Gene1", "Gene2", "Gene3"] - - let reference = @src.ReferenceDataset::from_matrix(expression, cell_types, gene_names) - + + let reference = @src.ReferenceDataset::from_matrix( + expression, cell_types, gene_names, + ) + assert_eq(reference.n_profiles, 3) assert_eq(reference.n_genes, 3) assert_eq(reference.cell_types.length(), 3) @@ -236,10 +244,12 @@ test "single_r_reference_dataset_from_matrix" { test "single_r_fine_tune_disabled" { let ref_data = @src.single_r_create_reference_data() let params = @src.SingleRParams::with_all(false, "spearman", 1, 0.0, false) - + let cell_expr = ref_data.profiles[0].expression - let result_no_finetune = @src.single_r_annotate_cell(cell_expr, "test", ref_data, params) - + let result_no_finetune = @src.single_r_annotate_cell( + cell_expr, "test", ref_data, params, + ) + assert_true(result_no_finetune.first_annotation_fine.length() > 0) } @@ -247,10 +257,12 @@ test "single_r_fine_tune_disabled" { test "single_r_fine_tune_enabled" { let ref_data = @src.single_r_create_reference_data() let params = @src.SingleRParams::with_all(true, "spearman", 1, 0.0, false) - + let cell_expr = ref_data.profiles[0].expression - let result_finetune = @src.single_r_annotate_cell(cell_expr, "test", ref_data, params) - + let result_finetune = @src.single_r_annotate_cell( + cell_expr, "test", ref_data, params, + ) + assert_true(result_finetune.first_annotation_fine.length() > 0) assert_true(result_finetune.scores[0] > 0.0) } @@ -270,8 +282,13 @@ test "single_r_identical_profiles" { let ref_data = @src.single_r_create_reference_data() // Annotate a cell with the same profile as reference profile 0 let cell_expr = ref_data.profiles[0].expression - let result = @src.single_r_annotate_cell(cell_expr, "identical", ref_data, @src.SingleRParams::new()) - + let result = @src.single_r_annotate_cell( + cell_expr, + "identical", + ref_data, + @src.SingleRParams::new(), + ) + assert_true(result.scores[0] > 0.99) assert_eq(result.first_annotation_fine, "T cells") -} \ No newline at end of file +} diff --git a/test/moonbit/singscore_test.mbt b/test/moonbit/singscore_test.mbt index 424ca520..d470e8ce 100644 --- a/test/moonbit/singscore_test.mbt +++ b/test/moonbit/singscore_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Singscore gene set scoring module. - test "singscore_create_example" { let (sample, spec) = @src.singscore_create_example() assert_true(sample.sample_id == "sample_1") @@ -9,6 +8,7 @@ test "singscore_create_example" { assert_true(spec.down_genes.length() > 0) } +///| test "singscore_score_basic" { let (sample, spec) = @src.singscore_create_example() let result = @src.singscore_score(sample, spec, "test_sample") @@ -17,6 +17,7 @@ test "singscore_score_basic" { assert_true(result.score >= -0.5 && result.score <= 0.5) } +///| test "singscore_score_boundary" { // Score should always be in [-0.5, 0.5] let (sample, spec) = @src.singscore_create_example() @@ -25,17 +26,19 @@ test "singscore_score_boundary" { assert_true(result.score <= 0.5 + 1.0e-6) } +///| test "singscore_empty_gene_set" { let genes = ["A", "B", "C"] let expression = [1.0, 2.0, 3.0] let sample = @src.SampleExpression::new("empty_test", genes, expression) - let spec = @src.GeneSetSpec::new("empty_set", [], down_genes = []) + let spec = @src.GeneSetSpec::new("empty_set", [], down_genes=[]) let result = @src.singscore_score(sample, spec, "empty") assert_true(result.score == 0.0) assert_true(result.n_up_found == 0) assert_true(result.n_down_found == 0) } +///| test "singscore_single_gene" { let genes = ["TP53"] let expression = [10.0] @@ -46,6 +49,7 @@ test "singscore_single_gene" { assert_true(result.score >= -0.5 && result.score <= 0.5) } +///| test "singscore_multiple_samples" { let (sample1, spec) = @src.singscore_create_example() let genes = sample1.gene_names @@ -59,6 +63,7 @@ test "singscore_multiple_samples" { assert_true(results[0].score >= -0.5 && results[0].score <= 0.5) } +///| test "singscore_missing_genes" { let genes = ["A", "B"] let expression = [1.0, 2.0] @@ -69,8 +74,9 @@ test "singscore_missing_genes" { assert_true(result.score == 0.0) } +///| test "singscore_spec_creation" { - let spec = @src.GeneSetSpec::new("test_set", ["G1", "G2"], down_genes = ["G3"]) + let spec = @src.GeneSetSpec::new("test_set", ["G1", "G2"], down_genes=["G3"]) assert_true(spec.name == "test_set") assert_true(spec.up_genes.length() == 2) assert_true(spec.down_genes.length() == 1) diff --git a/test/moonbit/slingshot_test.mbt b/test/moonbit/slingshot_test.mbt index 4177b12d..6ae042f0 100644 --- a/test/moonbit/slingshot_test.mbt +++ b/test/moonbit/slingshot_test.mbt @@ -40,7 +40,7 @@ test "slingshot_distance_matrix" { let nodes = [ @src.SlingshotNode::new("c1", "cluster1", [0.0, 0.0], 5), @src.SlingshotNode::new("c2", "cluster2", [1.0, 0.0], 5), - @src.SlingshotNode::new("c3", "cluster3", [0.0, 1.0], 5) + @src.SlingshotNode::new("c3", "cluster3", [0.0, 1.0], 5), ] let matrix = @src.sling_distance_matrix(nodes, @src.sling_euclidean_metric()) assert_eq(matrix.length(), 3) @@ -54,7 +54,7 @@ test "slingshot_mst" { let nodes = [ @src.SlingshotNode::new("c1", "cluster1", [0.0, 0.0], 5), @src.SlingshotNode::new("c2", "cluster2", [1.0, 0.0], 5), - @src.SlingshotNode::new("c3", "cluster3", [0.5, 1.0], 5) + @src.SlingshotNode::new("c3", "cluster3", [0.5, 1.0], 5), ] let edges = @src.sling_build_mst(nodes, @src.sling_euclidean_metric()) assert_eq(edges.length(), 2) @@ -65,7 +65,7 @@ test "slingshot_terminals" { let nodes = [ @src.SlingshotNode::new("c1", "cluster1", [0.0, 0.0], 5), @src.SlingshotNode::new("c2", "cluster2", [1.0, 0.0], 5), - @src.SlingshotNode::new("c3", "cluster3", [0.5, 1.0], 5) + @src.SlingshotNode::new("c3", "cluster3", [0.5, 1.0], 5), ] let edges = @src.sling_build_mst(nodes, @src.sling_euclidean_metric()) let terminals = @src.sling_find_terminals(edges, nodes) @@ -79,7 +79,7 @@ test "slingshot_principal_curve" { [1.0, 0.5], [2.0, 1.0], [3.0, 1.5], - [4.0, 2.0] + [4.0, 2.0], ] let curve = @src.sling_fit_principal_curve(points, 5) assert_true(curve.length() >= 2) @@ -91,13 +91,13 @@ test "slingshot_pseudotime" { [0.0, 0.0], [1.0, 0.5], [2.0, 1.0], - [3.0, 1.5] + [3.0, 1.5], ] let curve : Array[Array[Double]] = [ [0.0, 0.0], [1.0, 0.5], [2.0, 1.0], - [3.0, 1.5] + [3.0, 1.5], ] let pseudotime = @src.sling_compute_pseudotime(cell_coords, curve) assert_eq(pseudotime.length(), 4) @@ -111,7 +111,7 @@ test "slingshot_full_run" { [1.0, 0.5], [2.0, 1.0], [2.5, 1.2], - [3.0, 1.5] + [3.0, 1.5], ] let cluster_labels = ["c1", "c1", "c2", "c2", "c3", "c3"] let params = @src.SlingshotParams::new() diff --git a/test/moonbit/smart_test.mbt b/test/moonbit/smart_test.mbt index aa8307f1..cccd50ed 100644 --- a/test/moonbit/smart_test.mbt +++ b/test/moonbit/smart_test.mbt @@ -19,8 +19,15 @@ test "smart_result_construction" { // SmartDomain Tests // ============================================================================ +///| test "smart_domain_construction" { - let domain = @src.SmartDomain::new("SM00001", "ABC_membrane", 1, 100, evalue=1.5e-20) + let domain = @src.SmartDomain::new( + "SM00001", + "ABC_membrane", + 1, + 100, + evalue=1.5e-20, + ) assert_eq(domain.domain_id, "SM00001") assert_eq(domain.domain_name, "ABC_membrane") assert_eq(domain.start, 1) @@ -32,6 +39,7 @@ test "smart_domain_construction" { // SMART Parsing Tests // ============================================================================ +///| test "smart_parse_empty" { let result = @src.smart_parse("") assert_eq(result.sequence_id, "") @@ -39,6 +47,7 @@ test "smart_parse_empty" { assert_eq(result.domains.length(), 0) } +///| test "smart_parse_sample" { let content = @src.smart_sample() let result = @src.smart_parse(content) @@ -46,6 +55,7 @@ test "smart_parse_sample" { assert_true(result.domains.length() >= 3) } +///| test "smart_parse_domain_type_classification" { let content = @src.smart_sample() let result = @src.smart_parse(content) @@ -58,6 +68,7 @@ test "smart_parse_domain_type_classification" { // SMART Query Tests // ============================================================================ +///| test "smart_find_domains_by_name" { let content = @src.smart_sample() let result = @src.smart_parse(content) @@ -65,6 +76,7 @@ test "smart_find_domains_by_name" { assert_true(matches.length() >= 1) } +///| test "smart_filter_by_evalue" { let content = @src.smart_sample() let result = @src.smart_parse(content) @@ -72,6 +84,7 @@ test "smart_filter_by_evalue" { assert_true(significant.length() >= 1) } +///| test "smart_best_domain" { let content = @src.smart_sample() let result = @src.smart_parse(content) @@ -85,12 +98,14 @@ test "smart_best_domain" { // SMART Summary Tests // ============================================================================ +///| test "smart_summary" { let result = @src.SmartResult::new("test_protein") let summary = @src.smart_summary(result) assert_true(summary.contains("test_protein")) } +///| test "smart_total_domains" { let content = @src.smart_sample() let result = @src.smart_parse(content) diff --git a/test/moonbit/snapgene_io_test.mbt b/test/moonbit/snapgene_io_test.mbt index 298b1477..dea3a331 100644 --- a/test/moonbit/snapgene_io_test.mbt +++ b/test/moonbit/snapgene_io_test.mbt @@ -23,13 +23,21 @@ test "snapgene_seq_type_to_string" { ///| test "snapgene_seq_type_from_string" { - assert_true(@src.SnapgeneSeqType::from_string("DNA") is @src.SnapgeneSeqType::SnapgeneDna) - assert_true(@src.SnapgeneSeqType::from_string("RNA") is @src.SnapgeneSeqType::SnapgeneRna) assert_true( - @src.SnapgeneSeqType::from_string("protein") is @src.SnapgeneSeqType::SnapgeneProtein, + @src.SnapgeneSeqType::from_string("DNA") + is @src.SnapgeneSeqType::SnapgeneDna, ) assert_true( - @src.SnapgeneSeqType::from_string("xxx") is @src.SnapgeneSeqType::SnapgeneUnknown, + @src.SnapgeneSeqType::from_string("RNA") + is @src.SnapgeneSeqType::SnapgeneRna, + ) + assert_true( + @src.SnapgeneSeqType::from_string("protein") + is @src.SnapgeneSeqType::SnapgeneProtein, + ) + assert_true( + @src.SnapgeneSeqType::from_string("xxx") + is @src.SnapgeneSeqType::SnapgeneUnknown, ) } @@ -38,8 +46,14 @@ test "snapgene_seq_type_from_string_round_trip" { let dna = @src.SnapgeneSeqType::from_string("DNA") let rna = @src.SnapgeneSeqType::from_string("RNA") let protein = @src.SnapgeneSeqType::from_string("protein") - assert_eq(@src.SnapgeneSeqType::from_string(dna.to_string()).to_string(), "DNA") - assert_eq(@src.SnapgeneSeqType::from_string(rna.to_string()).to_string(), "RNA") + assert_eq( + @src.SnapgeneSeqType::from_string(dna.to_string()).to_string(), + "DNA", + ) + assert_eq( + @src.SnapgeneSeqType::from_string(rna.to_string()).to_string(), + "RNA", + ) assert_eq( @src.SnapgeneSeqType::from_string(protein.to_string()).to_string(), "protein", @@ -76,7 +90,7 @@ test "snapgene_feature_new" { type_="CDS", direction=1, segments=[(0, 99)], - qualifiers=qualifiers, + qualifiers~, ) assert_eq(f.name, "orfA") assert_eq(f.type_, "CDS") diff --git a/test/moonbit/spatial_experiment_test.mbt b/test/moonbit/spatial_experiment_test.mbt index 8c706cb5..b34e6b06 100644 --- a/test/moonbit/spatial_experiment_test.mbt +++ b/test/moonbit/spatial_experiment_test.mbt @@ -1,12 +1,12 @@ ///| /// Tests for SpatialExperiment module. - test "SpatialExperiment creation" { let se = @src.create_example_spatial_experiment() assert_eq(@src.se_num_rows(se), 3) assert_eq(@src.se_num_cols(se), 6) } +///| test "SpatialExperiment spatial range" { let se = @src.create_example_spatial_experiment() let (min_x, max_x, min_y, max_y) = @src.se_get_spatial_range(se) @@ -16,15 +16,17 @@ test "SpatialExperiment spatial range" { assert_eq(max_y, 250.0) } +///| test "SpatialExperiment filter spots" { let se = @src.create_example_spatial_experiment() let filtered = @src.se_filter_spots_by_range(se, 150.0, 300.0, 150.0, 250.0) assert_eq(@src.se_num_cols(filtered), 4) } +///| test "SpatialCoord new_2d" { let coord = @src.SpatialCoord::new_2d(100.0, 200.0) assert_eq(coord.x, 100.0) assert_eq(coord.y, 200.0) assert_eq(coord.z, 0.0) -} \ No newline at end of file +} diff --git a/test/moonbit/spia_test.mbt b/test/moonbit/spia_test.mbt index 750a5977..5792438a 100644 --- a/test/moonbit/spia_test.mbt +++ b/test/moonbit/spia_test.mbt @@ -170,7 +170,11 @@ test "spia_activation_status" { while i < results.results.length() { let r = results.results[i] // Activation status must be one of -1, 0, 1 - assert_true(r.activation_status == -1 || r.activation_status == 0 || r.activation_status == 1) + assert_true( + r.activation_status == -1 || + r.activation_status == 0 || + r.activation_status == 1, + ) i = i + 1 } } diff --git a/test/moonbit/stage_r_test.mbt b/test/moonbit/stage_r_test.mbt index 5a075d3f..06748ee8 100644 --- a/test/moonbit/stage_r_test.mbt +++ b/test/moonbit/stage_r_test.mbt @@ -110,7 +110,11 @@ test "stage_r_simes_caps_at_one" { ///| test "stage_r_adjustment_holm" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_holm()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_holm(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) assert_eq(result.nGenes, 10) assert_eq(result.nHypotheses, 3) @@ -121,7 +125,11 @@ test "stage_r_adjustment_holm" { ///| test "stage_r_adjustment_none" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_none()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_none(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) assert_eq(result.nGenes, 10) } @@ -129,7 +137,11 @@ test "stage_r_adjustment_none" { ///| test "stage_r_adjustment_dte" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_dte()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_dte(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) assert_eq(result.nGenes, 10) assert_eq(result.nHypotheses, 3) @@ -138,7 +150,11 @@ test "stage_r_adjustment_dte" { ///| test "stage_r_adjustment_dtu" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_dtu()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_dtu(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) assert_eq(result.nGenes, 10) assert_eq(result.nHypotheses, 3) @@ -147,17 +163,27 @@ test "stage_r_adjustment_dtu" { ///| test "stage_r_alpha_adjusted" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_holm()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_holm(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) // alphaAdjusted = (R/G) * alpha - let expected = result.nSignificantGenes.to_double() / result.nGenes.to_double() * config.alpha + let expected = result.nSignificantGenes.to_double() / + result.nGenes.to_double() * + config.alpha assert_true((result.alphaAdjusted - expected).abs() < 1.0e-10) } ///| test "stage_r_significant_genes" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_holm()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_holm(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) let sigGenes = @src.get_significant_genes(result) assert_eq(sigGenes.length(), result.nSignificantGenes) @@ -173,7 +199,11 @@ test "stage_r_significant_genes" { ///| test "stage_r_significant_hypotheses" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_holm()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_holm(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) let sigHyps = @src.get_significant_hypotheses(result) // All pairs should have valid indices. @@ -189,7 +219,11 @@ test "stage_r_significant_hypotheses" { ///| test "stage_r_get_results" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_holm()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_holm(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) let mat = @src.get_results(result) assert_eq(mat.length(), result.nGenes) @@ -204,7 +238,11 @@ test "stage_r_get_results" { ///| test "stage_r_non_significant_genes_na" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.001, pScreenAdjusted=false, stageMethod=@src.stage_r_method_holm()) + let config = @src.StageRConfig::new( + alpha=0.001, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_holm(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) // Non-significant genes should have -1.0 in confirmation p-values. let mut i = 0 @@ -225,7 +263,11 @@ test "stage_r_pscreen_adjusted" { let (pScreen, pConfirmation) = @src.stage_r_sample() // Pre-adjust the screening p-values. let adjScreen = @src.stage_r_bh_adjust(pScreen) - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=true, stageMethod=@src.stage_r_method_holm()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=true, + stageMethod=@src.stage_r_method_holm(), + ) let result = @src.stage_wise_adjustment(adjScreen, pConfirmation, config) // pAdjScreen should be the same as input. let mut i = 0 @@ -238,7 +280,11 @@ test "stage_r_pscreen_adjusted" { ///| test "stage_r_confirmation_rescaled" { let (pScreen, pConfirmation) = @src.stage_r_sample() - let config = @src.StageRConfig::new(alpha=0.05, pScreenAdjusted=false, stageMethod=@src.stage_r_method_holm()) + let config = @src.StageRConfig::new( + alpha=0.05, + pScreenAdjusted=false, + stageMethod=@src.stage_r_method_holm(), + ) let result = @src.stage_wise_adjustment(pScreen, pConfirmation, config) // For significant genes, confirmation p-values should be rescaled. let mut i = 0 diff --git a/test/moonbit/statistics_test.mbt b/test/moonbit/statistics_test.mbt index c3cd357f..f735171c 100644 --- a/test/moonbit/statistics_test.mbt +++ b/test/moonbit/statistics_test.mbt @@ -1,59 +1,69 @@ // Tests for Bio.Statistics module +///| test "stat_mean" { let data = [1.0, 2.0, 3.0, 4.0, 5.0] let result = @src.stat_mean(data) assert_true(result > 2.9 && result < 3.1) } +///| test "stat_mean empty" { let data : Array[Double] = Array::new() let result = @src.stat_mean(data) assert_true(result == 0.0) } +///| test "stat_variance" { let data = [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0] let result = @src.stat_variance(data) assert_true(result > 4.0 && result < 5.0) } +///| test "stat_std" { let data = [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0] let result = @src.stat_std(data) assert_true(result > 2.0 && result < 2.5) } +///| test "stat_median odd" { let data = [1.0, 3.0, 2.0, 5.0, 4.0] let result = @src.stat_median(data) assert_true(result == 3.0) } +///| test "stat_median even" { let data = [1.0, 2.0, 3.0, 4.0] let result = @src.stat_median(data) assert_true(result == 2.5) } +///| test "stat_min" { let data = [3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0] let result = @src.stat_min(data) assert_true(result == 1.0) } +///| test "stat_max" { let data = [3.0, 1.0, 4.0, 1.0, 5.0, 9.0, 2.0] let result = @src.stat_max(data) assert_true(result == 9.0) } +///| test "stat_sum" { let data = [1.0, 2.0, 3.0, 4.0, 5.0] let result = @src.stat_sum(data) assert_true(result == 15.0) } +///| test "stat_cumsum" { let data = [1.0, 2.0, 3.0] let result = @src.stat_cumsum(data) @@ -63,6 +73,7 @@ test "stat_cumsum" { assert_true(result[2] == 6.0) } +///| test "stat_pearson_correlation positive" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0] @@ -70,6 +81,7 @@ test "stat_pearson_correlation positive" { assert_true(result > 0.99 && result < 1.01) } +///| test "stat_pearson_correlation negative" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [10.0, 8.0, 6.0, 4.0, 2.0] @@ -77,22 +89,26 @@ test "stat_pearson_correlation negative" { assert_true(result < -0.99 && result > -1.01) } +///| test "stat_zscore" { let result = @src.stat_zscore(3.0, 2.0, 0.5) assert_true(result > 1.9 && result < 2.1) } +///| test "stat_normal_cdf at 0" { let result = @src.stat_normal_cdf(0.0) assert_true(result > 0.49 && result < 0.51) } +///| test "stat_t_statistic" { let sample = [2.0, 3.0, 4.0, 5.0, 6.0] let result = @src.stat_t_statistic(sample, 3.0) assert_true(result > 1.4 && result < 1.6) } +///| test "stat_confidence_interval" { let data = [2.0, 3.0, 4.0, 5.0, 6.0] let result = @src.stat_confidence_interval(data) @@ -100,6 +116,7 @@ test "stat_confidence_interval" { assert_true(result[0] < result[1]) } +///| test "stat_mann_whitney_u_basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0] @@ -107,6 +124,7 @@ test "stat_mann_whitney_u_basic" { assert_true(result.1 >= 0.0 && result.1 <= 1.0) } +///| test "stat_wilcoxon_signed_rank_basic" { let x = [1.0, 2.0, 3.0, 4.0, 5.0] let y = [2.0, 4.0, 6.0, 8.0, 10.0] @@ -114,6 +132,7 @@ test "stat_wilcoxon_signed_rank_basic" { assert_true(result.1 >= 0.0 && result.1 <= 1.0) } +///| test "stat_ks_test_basic" { let sample1 = [1.0, 2.0, 3.0, 4.0, 5.0] let sample2 = [2.0, 4.0, 6.0, 8.0, 10.0] @@ -121,12 +140,14 @@ test "stat_ks_test_basic" { assert_true(result.1 >= 0.0 && result.1 <= 1.0) } +///| test "stat_fisher_exact_basic" { let table = [[10, 2], [3, 5]] let result = @src.stat_fisher_exact(table) assert_true(result.1 >= 0.0 && result.1 <= 1.0) } +///| test "stat_bonferroni_correct_basic" { let p_values = [0.01, 0.04, 0.03, 0.005, 0.2] let result = @src.stat_bonferroni(p_values) @@ -134,67 +155,79 @@ test "stat_bonferroni_correct_basic" { assert_true(result[0] >= 0.01) } +///| test "stat_holm_correct_basic" { let p_values = [0.01, 0.04, 0.03, 0.005, 0.2] let result = @src.stat_holm(p_values) assert_true(result.length() == 5) } +///| test "stat_by_correct_basic" { let p_values = [0.01, 0.04, 0.03, 0.005, 0.2] let result = @src.stat_by(p_values) assert_true(result.length() == 5) } +///| test "stat_chi2_cdf_basic" { // For df=3, P(chi2 <= 7.81) ~ 0.95 let result = @src.stat_chi2_cdf(7.81, 3) assert_true(result > 0.90 && result < 0.99) } +///| test "stat_chi2_cdf_zero" { let result = @src.stat_chi2_cdf(0.0, 3) assert_true(result == 0.0) } +///| test "stat_chi2_cdf_negative" { let result = @src.stat_chi2_cdf(-1.0, 5) assert_true(result == 0.0) } +///| test "stat_chi2_quantile_basic" { // For df=2, chi2_0.95 ~ 5.99 let result = @src.stat_chi2_quantile(0.95, 2) assert_true(result > 5.0 && result < 7.0) } +///| test "stat_chi2_quantile_zero_one" { assert_true(@src.stat_chi2_quantile(0.0, 2) == 0.0) assert_true(@src.stat_chi2_quantile(1.0, 2) > 1.0e100) } +///| test "stat_t_cdf_central" { let result = @src.stat_t_cdf(0.0, 10.0) assert_true(result > 0.49 && result < 0.51) } +///| test "stat_t_cdf_positive" { // t with df=10 at 2.228 ~ 0.975 let result = @src.stat_t_cdf(2.228, 10.0) assert_true(result > 0.94 && result < 0.99) } +///| test "stat_t_quantile_central" { let result = @src.stat_t_quantile(0.5, 10.0) assert_true(result > -0.01 && result < 0.01) } +///| test "stat_t_quantile_basic" { // t_0.975,df=10 ~ 2.228 let result = @src.stat_t_quantile(0.975, 10.0) assert_true(result > 1.5 && result < 3.0) } +///| test "stat_t_test_one_sample" { let sample = [2.1, 2.3, 2.2, 2.4, 2.0] let result = @src.stat_t_test_one_sample(sample, 2.0) @@ -202,6 +235,7 @@ test "stat_t_test_one_sample" { assert_true(result.1 > 0.0 && result.1 <= 1.0) } +///| test "stat_t_test_two_sample" { let x = [2.1, 2.3, 2.2, 2.4, 2.0] let y = [3.1, 3.3, 3.2, 3.4, 3.0] @@ -209,6 +243,7 @@ test "stat_t_test_two_sample" { assert_true(result.1 >= 0.0 && result.1 <= 1.0) } +///| test "stat_bh_basic" { let p_values = [0.01, 0.04, 0.03, 0.005, 0.2] let result = @src.stat_bh(p_values) @@ -222,23 +257,27 @@ test "stat_bh_basic" { } } +///| test "stat_bh_empty" { let p_values : Array[Double] = Array::new() let result = @src.stat_bh(p_values) assert_true(result.length() == 0) } +///| test "stat_normal_quantile_half" { let result = @src.stat_normal_quantile(0.5) assert_true(result > -0.01 && result < 0.01) } +///| test "stat_normal_quantile_standard" { // qnorm(0.975) ~ 1.96 let result = @src.stat_normal_quantile(0.975) assert_true(result > 1.9 && result < 2.1) } +///| test "stat_mad_basic" { let data = [1.0, 2.0, 3.0, 4.0, 5.0] let result = @src.stat_mad(data) @@ -246,27 +285,22 @@ test "stat_mad_basic" { assert_true(result > 1.0 && result < 2.0) } +///| test "stat_anova_basic" { - let samples = [ - [1.0, 2.0, 3.0], - [2.0, 3.0, 4.0], - [8.0, 9.0, 10.0], - ] + let samples = [[1.0, 2.0, 3.0], [2.0, 3.0, 4.0], [8.0, 9.0, 10.0]] let result = @src.stat_anova(samples) assert_true(result.0 > 0.0) assert_true(result.1 >= 0.0 && result.1 <= 1.0) } +///| test "stat_anova_equal" { - let samples = [ - [1.0, 1.0, 1.0], - [1.0, 1.0, 1.0], - [1.0, 1.0, 1.0], - ] + let samples = [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]] let result = @src.stat_anova(samples) assert_true(result.0 >= 0.0) } +///| test "stat_logrank_test_basic" { let time = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] let event = [true, true, true, false, true, false] diff --git a/test/moonbit/stockholm_test.mbt b/test/moonbit/stockholm_test.mbt index 8f43ba5b..20db96cf 100644 --- a/test/moonbit/stockholm_test.mbt +++ b/test/moonbit/stockholm_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for Stockholm format parser module. - test "stockholm_parse_header" { let content = "# STOCKHOLM 1.0\nseq1/1-10 ACGTACGTAC\n//\n" let ali = @src.stockholm_parse(content) @@ -8,18 +7,21 @@ test "stockholm_parse_header" { assert_eq(ali.blocks.length(), 1) } +///| test "stockholm_parse_empty" { let ali = @src.stockholm_parse("") assert_eq(ali.blocks.length(), 0) assert_eq(ali.gf_annotations.keys().length(), 0) } +///| test "stockholm_parse_header_only" { let content = "# STOCKHOLM 1.0\n//\n" let ali = @src.stockholm_parse(content) assert_eq(ali.blocks.length(), 0) } +///| test "stockholm_parse_single_sequence" { let content = "# STOCKHOLM 1.0\nseq1/1-10 ACGTACGTAC\n//\n" let ali = @src.stockholm_parse(content) @@ -31,6 +33,7 @@ test "stockholm_parse_single_sequence" { assert_eq(ali.blocks[0].sequences[0].end, 10) } +///| test "stockholm_parse_multiple_sequences" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + @@ -42,6 +45,7 @@ test "stockholm_parse_multiple_sequences" { assert_eq(ali.blocks[0].sequences.length(), 3) } +///| test "stockholm_parse_gf_annotations" { let content = "# STOCKHOLM 1.0\n" + "#=GF ID TestFamily\n" + @@ -56,6 +60,7 @@ test "stockholm_parse_gf_annotations" { assert_eq(ali.gf_annotations["DE"], "A test protein family") } +///| test "stockholm_parse_gc_ss_cons" { let content = "# STOCKHOLM 1.0\n" + "#=GC SS_cons ........((((...)))).....\n" + @@ -65,6 +70,7 @@ test "stockholm_parse_gc_ss_cons" { assert_eq(ali.blocks[0].secondary_structure, "........((((...)))).....") } +///| test "stockholm_parse_gr_annotation" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + @@ -74,6 +80,7 @@ test "stockholm_parse_gr_annotation" { assert_true(ali.blocks[0].gr_annotations.keys().length() > 0) } +///| test "stockholm_parse_gs_annotation" { let content = "# STOCKHOLM 1.0\n" + "#=GS seq1 some annotation value\n" + @@ -83,6 +90,7 @@ test "stockholm_parse_gs_annotation" { assert_true(ali.gs_annotations.keys().length() > 0) } +///| test "stockholm_parse_multiple_blocks" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + @@ -97,14 +105,10 @@ test "stockholm_parse_multiple_blocks" { assert_eq(ali.blocks[1].sequences.length(), 2) } +///| test "stockholm_sequence_struct" { let seq = @src.StockholmSequence::new( - "test", - "PF00001", - "Test description", - "ACGTAC", - 1, - 6, + "test", "PF00001", "Test description", "ACGTAC", 1, 6, ) assert_eq(seq.name, "test") assert_eq(seq.accession, "PF00001") @@ -114,6 +118,7 @@ test "stockholm_sequence_struct" { assert_eq(seq.end, 6) } +///| test "stockholm_block_struct" { let seqs : Array[@src.StockholmSequence] = Array::new() let gc : Map[String, String] = Map([], capacity=0) @@ -124,6 +129,7 @@ test "stockholm_block_struct" { assert_eq(block.consensus, "cons") } +///| test "stockholm_alignment_struct" { let blocks : Array[@src.StockholmBlock] = Array::new() let gf : Map[String, String] = Map([], capacity=0) @@ -134,6 +140,7 @@ test "stockholm_alignment_struct" { assert_eq(ali.blocks.length(), 0) } +///| test "stockholm_percent_identity_identical" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + @@ -144,6 +151,7 @@ test "stockholm_percent_identity_identical" { assert_true(pid > 0.99) } +///| test "stockholm_percent_identity_different" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + @@ -154,6 +162,7 @@ test "stockholm_percent_identity_different" { assert_true(pid < 0.3) } +///| test "stockholm_percent_identity_with_gaps" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + @@ -165,6 +174,7 @@ test "stockholm_percent_identity_with_gaps" { assert_true(pid <= 1.0) } +///| test "stockholm_conservation_single_column" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-5 ACGT.\n" + @@ -178,6 +188,7 @@ test "stockholm_conservation_single_column" { assert_true(cons[4] >= 0.0) } +///| test "stockholm_conservation_all_gap_column" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-5 ACGT-\n" + @@ -188,6 +199,7 @@ test "stockholm_conservation_all_gap_column" { assert_eq(cons[4], 0.0) } +///| test "stockholm_to_fasta_basic" { let content = "# STOCKHOLM 1.0\n" + "#=GF AC PF00001\n" + @@ -201,6 +213,7 @@ test "stockholm_to_fasta_basic" { assert_true(fasta.contains("ACGTACGTAC")) } +///| test "stockholm_to_fasta_no_duplicates" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + @@ -212,6 +225,7 @@ test "stockholm_to_fasta_no_duplicates" { assert_true(fasta.contains(">seq1")) } +///| test "stockholm_merge_blocks_basic" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + @@ -225,6 +239,7 @@ test "stockholm_merge_blocks_basic" { assert_eq(merged.blocks[0].sequences.length(), 1) } +///| test "stockholm_merge_blocks_sequence_concat" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-5 ACGTG\n" + @@ -237,6 +252,7 @@ test "stockholm_merge_blocks_sequence_concat" { assert_eq(seq.aligned_seq, "ACGTGTACGT") } +///| test "stockholm_write_roundtrip" { let content = "# STOCKHOLM 1.0\n" + "#=GF ID TestFamily\n" + @@ -252,6 +268,7 @@ test "stockholm_write_roundtrip" { assert_true(output.contains("//")) } +///| test "stockholm_write_contains_gf" { let content = "# STOCKHOLM 1.0\n" + "#=GF ID TestFamily\n" + @@ -264,16 +281,16 @@ test "stockholm_write_contains_gf" { assert_true(output.contains("#=GF AC")) } +///| test "stockholm_sequence_without_range" { - let content = "# STOCKHOLM 1.0\n" + - "seq1 ACGTACGTAC\n" + - "//\n" + let content = "# STOCKHOLM 1.0\n" + "seq1 ACGTACGTAC\n" + "//\n" let ali = @src.stockholm_parse(content) assert_eq(ali.blocks[0].sequences.length(), 1) assert_eq(ali.blocks[0].sequences[0].name, "seq1") assert_eq(ali.blocks[0].sequences[0].start, 1) } +///| test "stockholm_gap_handling" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGT--GTAC\n" + @@ -284,6 +301,7 @@ test "stockholm_gap_handling" { assert_eq(ali.blocks[0].sequences[1].aligned_seq, "ACGTACGTAC") } +///| test "stockholm_sample_content" { let content = @src.sample_stockholm_content() let ali = @src.stockholm_parse(content) @@ -292,6 +310,7 @@ test "stockholm_sample_content" { assert_eq(ali.blocks[0].sequences.length(), 3) } +///| test "stockholm_sample_alignment" { let ali = @src.sample_stockholm_alignment() assert_eq(ali.version, "1.0") @@ -299,6 +318,7 @@ test "stockholm_sample_alignment" { assert_true(ali.blocks[0].secondary_structure.length() > 0) } +///| test "stockholm_multiline_gf" { let content = "# STOCKHOLM 1.0\n" + "#=GF DE This is a long description\n" + @@ -309,6 +329,7 @@ test "stockholm_multiline_gf" { assert_true(ali.gf_annotations.keys().length() > 0) } +///| test "stockholm_conservation_with_mixed_chars" { let content = "# STOCKHOLM 1.0\n" + "seq1/1-5 ACGTN\n" + @@ -322,15 +343,15 @@ test "stockholm_conservation_with_mixed_chars" { assert_true(cons[4] >= 0.66) } +///| test "stockholm_percent_identity_single_sequence" { - let content = "# STOCKHOLM 1.0\n" + - "seq1/1-10 ACGTACGTAC\n" + - "//\n" + let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + "//\n" let ali = @src.stockholm_parse(content) let pid = @src.stockholm_percent_identity(ali.blocks[0]) assert_eq(pid, 0.0) } +///| test "stockholm_to_fasta_empty_alignment" { let content = "# STOCKHOLM 1.0\n//\n" let ali = @src.stockholm_parse(content) @@ -338,16 +359,16 @@ test "stockholm_to_fasta_empty_alignment" { assert_eq(fasta.length(), 0) } +///| test "stockholm_merge_single_block" { - let content = "# STOCKHOLM 1.0\n" + - "seq1/1-10 ACGTACGTAC\n" + - "//\n" + let content = "# STOCKHOLM 1.0\n" + "seq1/1-10 ACGTACGTAC\n" + "//\n" let ali = @src.stockholm_parse(content) let merged = @src.stockholm_merge_blocks(ali) assert_eq(merged.blocks.length(), 1) assert_eq(merged.blocks[0].sequences.length(), 1) } +///| test "stockholm_parse_with_comment_lines" { let content = "# STOCKHOLM 1.0\n" + "# Some comment\n" + @@ -358,6 +379,7 @@ test "stockholm_parse_with_comment_lines" { assert_true(ali.markup.length() > 0) } +///| test "stockholm_ss_cons_roundtrip" { let content = "# STOCKHOLM 1.0\n" + "#=GC SS_cons ........((((...)))).....\n" + @@ -369,15 +391,15 @@ test "stockholm_ss_cons_roundtrip" { assert_true(output.contains("........((((...)))).....")) } +///| test "stockholm_parse_range_with_dash" { - let content = "# STOCKHOLM 1.0\n" + - "seq1/1-100 ACGTACGT\n" + - "//\n" + let content = "# STOCKHOLM 1.0\n" + "seq1/1-100 ACGTACGT\n" + "//\n" let ali = @src.stockholm_parse(content) assert_eq(ali.blocks[0].sequences[0].start, 1) assert_eq(ali.blocks[0].sequences[0].end, 100) } +///| test "stockholm_parse_accession_from_gf" { let content = "# STOCKHOLM 1.0\n" + "#=GF AC PF12345.6\n" + @@ -387,4 +409,4 @@ test "stockholm_parse_accession_from_gf" { let ali = @src.stockholm_parse(content) assert_eq(ali.gf_annotations["AC"], "PF12345.6") assert_eq(ali.gf_annotations["DE"], "Test family") -} \ No newline at end of file +} diff --git a/test/moonbit/structural_variant_test.mbt b/test/moonbit/structural_variant_test.mbt index dc926621..8908096e 100644 --- a/test/moonbit/structural_variant_test.mbt +++ b/test/moonbit/structural_variant_test.mbt @@ -78,7 +78,15 @@ test "sv_breakend_is_inter_chromosomal" { ///| test "sv_record_creation" { let rec = @src.SvRecord::new( - "sv1", "chr1", 1000, @src.sv_type_del(), 2000, -1000, None, 500.0, "PASS", + "sv1", + "chr1", + 1000, + @src.sv_type_del(), + 2000, + -1000, + None, + 500.0, + "PASS", ) assert_eq(rec.id(), "sv1") assert_eq(rec.chrom(), "chr1") @@ -92,11 +100,27 @@ test "sv_record_creation" { ///| test "sv_record_is_bnd" { let bnd = @src.SvRecord::new( - "sv1", "chr1", 1000, @src.sv_type_bnd(), 1000, 0, None, 500.0, "PASS", + "sv1", + "chr1", + 1000, + @src.sv_type_bnd(), + 1000, + 0, + None, + 500.0, + "PASS", ) assert_true(bnd.is_bnd()) let del = @src.SvRecord::new( - "sv2", "chr1", 1000, @src.sv_type_del(), 2000, -1000, None, 500.0, "PASS", + "sv2", + "chr1", + 1000, + @src.sv_type_del(), + 2000, + -1000, + None, + 500.0, + "PASS", ) assert_false(del.is_bnd()) } @@ -104,7 +128,15 @@ test "sv_record_is_bnd" { ///| test "sv_record_size" { let del = @src.SvRecord::new( - "sv1", "chr1", 1000, @src.sv_type_del(), 2000, -1000, None, 0.0, "PASS", + "sv1", + "chr1", + 1000, + @src.sv_type_del(), + 2000, + -1000, + None, + 0.0, + "PASS", ) assert_eq(del.size(), 1000) } @@ -113,11 +145,27 @@ test "sv_record_size" { test "sv_record_is_inter_chromosomal" { let be = @src.SvBreakend::new("chr1", 1000, "+", "chr2", 2000, "-") let bnd = @src.SvRecord::new( - "sv1", "chr1", 1000, @src.sv_type_bnd(), 1000, 0, Some(be), 0.0, "PASS", + "sv1", + "chr1", + 1000, + @src.sv_type_bnd(), + 1000, + 0, + Some(be), + 0.0, + "PASS", ) assert_true(bnd.is_inter_chromosomal()) let del = @src.SvRecord::new( - "sv2", "chr1", 1000, @src.sv_type_del(), 2000, -1000, None, 0.0, "PASS", + "sv2", + "chr1", + 1000, + @src.sv_type_del(), + 2000, + -1000, + None, + 0.0, + "PASS", ) assert_false(del.is_inter_chromosomal()) } @@ -288,7 +336,7 @@ test "sv_find_partners_sample" { let (id_a, id_b) = pairs[0] assert_true( (id_a == "sv_bnd_1" && id_b == "sv_bnd_2") || - (id_a == "sv_bnd_2" && id_b == "sv_bnd_1"), + (id_a == "sv_bnd_2" && id_b == "sv_bnd_1"), ) } @@ -305,10 +353,26 @@ test "sv_are_partners_mutual" { ///| test "sv_are_partners_non_bnd" { let del = @src.SvRecord::new( - "sv1", "chr1", 1000, @src.sv_type_del(), 2000, -1000, None, 0.0, "PASS", + "sv1", + "chr1", + 1000, + @src.sv_type_del(), + 2000, + -1000, + None, + 0.0, + "PASS", ) let dup = @src.SvRecord::new( - "sv2", "chr1", 3000, @src.sv_type_dup(), 5000, 2000, None, 0.0, "PASS", + "sv2", + "chr1", + 3000, + @src.sv_type_dup(), + 5000, + 2000, + None, + 0.0, + "PASS", ) assert_false(@src.sv_are_partners(del, dup)) } @@ -479,10 +543,26 @@ test "sv_filter_empty_records" { ///| test "sv_find_partners_no_bnd" { let del = @src.SvRecord::new( - "sv1", "chr1", 1000, @src.sv_type_del(), 2000, -1000, None, 0.0, "PASS", + "sv1", + "chr1", + 1000, + @src.sv_type_del(), + 2000, + -1000, + None, + 0.0, + "PASS", ) let dup = @src.SvRecord::new( - "sv2", "chr1", 3000, @src.sv_type_dup(), 5000, 2000, None, 0.0, "PASS", + "sv2", + "chr1", + 3000, + @src.sv_type_dup(), + 5000, + 2000, + None, + 0.0, + "PASS", ) let pairs = @src.sv_find_partners([del, dup]) assert_eq(pairs.length(), 0) diff --git a/test/moonbit/structure_alignment_test.mbt b/test/moonbit/structure_alignment_test.mbt index e5a2fe44..c7e2b76f 100644 --- a/test/moonbit/structure_alignment_test.mbt +++ b/test/moonbit/structure_alignment_test.mbt @@ -9,7 +9,11 @@ test "structure_alignment_point3d" { ///| test "structure_alignment_create_residue" { - let residue = @src.SAResidue::new("ALA", 1, @src.SAPoint3D::new(1.0, 0.0, 0.0)) + let residue = @src.SAResidue::new( + "ALA", + 1, + @src.SAPoint3D::new(1.0, 0.0, 0.0), + ) assert_eq(residue.resname, "ALA") assert_eq(residue.resseq, 1) @@ -126,4 +130,4 @@ test "structure_alignment_pairwise_rmsd" { assert_eq(matrix.length(), 2) assert_eq(matrix[0][0], 0.0) -} \ No newline at end of file +} diff --git a/test/moonbit/substitution_matrices_test.mbt b/test/moonbit/substitution_matrices_test.mbt index ba24c1ff..b403647e 100644 --- a/test/moonbit/substitution_matrices_test.mbt +++ b/test/moonbit/substitution_matrices_test.mbt @@ -13,6 +13,7 @@ test "submat_protein_alphabet_has_20_letters" { assert_eq(alpha[19], "Y") } +///| test "submat_nucleotide_alphabet_has_4_letters" { let alpha = @src.subs_nucleotide_alphabet() assert_eq(alpha.length(), 4) @@ -23,6 +24,7 @@ test "submat_nucleotide_alphabet_has_4_letters" { // ArrayData structure // --------------------------------------------------------------------------- +///| test "submat_array_data_from_dict_basic" { let pairs = [ ("A", "A", 5.0), @@ -34,19 +36,21 @@ test "submat_array_data_from_dict_basic" { assert_eq(ad.rows, ["A", "C"]) assert_eq(ad.cols, ["A", "C"]) assert_true((ad.get(0, 0) - 5.0).abs() < 1.0e-10) - assert_true((ad.get(0, 1) - (-1.0)).abs() < 1.0e-10) + assert_true((ad.get(0, 1) - -1.0).abs() < 1.0e-10) assert_true((ad.get(1, 1) - 9.0).abs() < 1.0e-10) } +///| test "submat_array_data_get_by_label" { let pairs = [("A", "B", 3.0), ("B", "A", 7.0)] let ad = @src.array_data_from_dict(pairs, ["A", "B"], ["A", "B"]) assert_true((ad.get_by_label("A", "B") - 3.0).abs() < 1.0e-10) assert_true((ad.get_by_label("B", "A") - 7.0).abs() < 1.0e-10) // Missing label returns 0.0 - assert_true((ad.get_by_label("X", "Y")).abs() < 1.0e-10) + assert_true(ad.get_by_label("X", "Y").abs() < 1.0e-10) } +///| test "submat_array_data_set_updates_value" { let pairs : Array[(String, String, Double)] = [] let ad = @src.array_data_from_dict(pairs, ["A", "B"], ["A", "B"]) @@ -57,28 +61,31 @@ test "submat_array_data_set_updates_value" { assert_true(true) } +///| test "submat_array_data_get_out_of_bounds_returns_zero" { let pairs : Array[(String, String, Double)] = [] let ad = @src.array_data_from_dict(pairs, ["A"], ["A"]) - assert_true((ad.get(-1, 0)).abs() < 1.0e-10) - assert_true((ad.get(0, 99)).abs() < 1.0e-10) + assert_true(ad.get(-1, 0).abs() < 1.0e-10) + assert_true(ad.get(0, 99).abs() < 1.0e-10) } // --------------------------------------------------------------------------- // Built-in BLOSUM matrices // --------------------------------------------------------------------------- +///| test "submat_blosum62_known_scores" { let m = @src.subs_blosum62_matrix() assert_eq(m.name(), "BLOSUM62") assert_eq(m.n_letters(), 20) assert_true((m.get_score("A", "A") - 4.0).abs() < 1.0e-10) assert_true((m.get_score("R", "R") - 5.0).abs() < 1.0e-10) - assert_true((m.get_score("A", "R") - (-1.0)).abs() < 1.0e-10) + assert_true((m.get_score("A", "R") - -1.0).abs() < 1.0e-10) assert_true((m.get_score("W", "W") - 11.0).abs() < 1.0e-10) assert_true((m.get_score("C", "C") - 9.0).abs() < 1.0e-10) } +///| test "submat_blosum62_is_symmetric" { let m = @src.subs_blosum62_matrix() let alpha = m.alphabet() @@ -91,6 +98,7 @@ test "submat_blosum62_is_symmetric" { } } +///| test "submat_blosum45_known_scores" { let m = @src.subs_blosum45_matrix() assert_eq(m.name(), "BLOSUM45") @@ -100,6 +108,7 @@ test "submat_blosum45_known_scores" { assert_true((m.get_score("C", "C") - 12.0).abs() < 1.0e-10) } +///| test "submat_blosum80_known_scores" { let m = @src.subs_blosum80_matrix() assert_eq(m.name(), "BLOSUM80") @@ -108,6 +117,7 @@ test "submat_blosum80_known_scores" { assert_true((m.get_score("W", "W") - 15.0).abs() < 1.0e-10) } +///| test "submat_blosum90_known_scores" { let m = @src.subs_blosum90_matrix() assert_eq(m.name(), "BLOSUM90") @@ -120,6 +130,7 @@ test "submat_blosum90_known_scores" { // Built-in PAM matrices // --------------------------------------------------------------------------- +///| test "submat_pam30_known_scores" { let m = @src.subs_pam30_matrix() assert_eq(m.name(), "PAM30") @@ -128,6 +139,7 @@ test "submat_pam30_known_scores" { assert_true((m.get_score("W", "W") - 14.0).abs() < 1.0e-10) } +///| test "submat_pam70_known_scores" { let m = @src.subs_pam70_matrix() assert_eq(m.name(), "PAM70") @@ -136,6 +148,7 @@ test "submat_pam70_known_scores" { assert_true((m.get_score("W", "W") - 13.0).abs() < 1.0e-10) } +///| test "submat_pam250_known_scores" { let m = @src.subs_pam250_matrix() assert_eq(m.name(), "PAM250") @@ -148,21 +161,23 @@ test "submat_pam250_known_scores" { // Built-in nucleotide matrix // --------------------------------------------------------------------------- +///| test "submat_nuc44_match_mismatch" { let m = @src.subs_nuc44_matrix() assert_eq(m.name(), "NUC4.4") assert_eq(m.n_letters(), 4) assert_true((m.get_score("A", "A") - 5.0).abs() < 1.0e-10) - assert_true((m.get_score("A", "C") - (-4.0)).abs() < 1.0e-10) + assert_true((m.get_score("A", "C") - -4.0).abs() < 1.0e-10) assert_true((m.get_score("G", "G") - 5.0).abs() < 1.0e-10) assert_true((m.get_score("T", "T") - 5.0).abs() < 1.0e-10) - assert_true((m.get_score("A", "T") - (-4.0)).abs() < 1.0e-10) + assert_true((m.get_score("A", "T") - -4.0).abs() < 1.0e-10) } // --------------------------------------------------------------------------- // SubsMatrix construction and methods // --------------------------------------------------------------------------- +///| test "submat_subs_matrix_from_pairs" { let alpha = ["A", "C"] let pairs = [ @@ -176,17 +191,19 @@ test "submat_subs_matrix_from_pairs" { assert_eq(m.n_letters(), 2) assert_true((m.get_score("A", "A") - 5.0).abs() < 1.0e-10) assert_true((m.get_score("C", "C") - 9.0).abs() < 1.0e-10) - assert_true((m.get_score("A", "C") - (-2.0)).abs() < 1.0e-10) + assert_true((m.get_score("A", "C") - -2.0).abs() < 1.0e-10) } +///| test "submat_get_score_idx" { let m = @src.subs_blosum62_matrix() // A=0, R=14 in alphabet ACDEFGHIKLMNPQRSTVWY assert_true((m.get_score_idx(0, 0) - 4.0).abs() < 1.0e-10) // A-R = -1 - assert_true((m.get_score_idx(0, 14) - (-1.0)).abs() < 1.0e-10) + assert_true((m.get_score_idx(0, 14) - -1.0).abs() < 1.0e-10) } +///| test "submat_select_submatrix" { let m = @src.subs_blosum62_matrix() let sub = m.select(["A", "C", "D"]) @@ -198,6 +215,7 @@ test "submat_select_submatrix" { assert_true((sub.get_score("A", "C") - 0.0).abs() < 1.0e-10) } +///| test "submat_to_table_string_has_name" { let m = @src.subs_blosum62_matrix() let s = m.to_table_string() @@ -211,6 +229,7 @@ test "submat_to_table_string_has_name" { // Matrix registry // --------------------------------------------------------------------------- +///| test "submat_registry_initialize_and_list" { @src.subs_initialize_registry() let names = @src.list_matrices() @@ -220,15 +239,22 @@ test "submat_registry_initialize_and_list" { let mut has_pam250 = false let mut has_nuc44 = false for n in names { - if n == "BLOSUM62" { has_blosum62 = true } - if n == "PAM250" { has_pam250 = true } - if n == "NUC4.4" { has_nuc44 = true } + if n == "BLOSUM62" { + has_blosum62 = true + } + if n == "PAM250" { + has_pam250 = true + } + if n == "NUC4.4" { + has_nuc44 = true + } } assert_true(has_blosum62) assert_true(has_pam250) assert_true(has_nuc44) } +///| test "submat_registry_load_existing_matrix" { @src.subs_initialize_registry() let opt = @src.load_matrix("BLOSUM62") @@ -238,12 +264,14 @@ test "submat_registry_load_existing_matrix" { assert_true((m.get_score("A", "A") - 4.0).abs() < 1.0e-10) } +///| test "submat_registry_load_missing_returns_none" { @src.subs_initialize_registry() let opt = @src.load_matrix("NONEXISTENT_MATRIX_XYZ") assert_true(opt.is_none()) } +///| test "submat_registry_register_custom_matrix" { let alpha = ["A", "C"] let pairs = [ @@ -260,6 +288,7 @@ test "submat_registry_register_custom_matrix" { assert_true((loaded.get_score("A", "A") - 1.0).abs() < 1.0e-10) } +///| test "submat_registry_register_overwrites_existing" { let alpha = ["A"] let pairs1 = [("A", "A", 5.0)] @@ -276,6 +305,7 @@ test "submat_registry_register_overwrites_existing" { // Frequency matrix calculation // --------------------------------------------------------------------------- +///| test "submat_calculate_frequency_matrix_identical_sequences" { let alignment = ["ACGT", "ACGT"] let alpha = @src.subs_nucleotide_alphabet() @@ -288,9 +318,10 @@ test "submat_calculate_frequency_matrix_identical_sequences" { assert_true((freq.get(2, 2) - 2.0).abs() < 1.0e-10) // G assert_true((freq.get(3, 3) - 2.0).abs() < 1.0e-10) // T // Off-diagonal should be 0 - assert_true((freq.get(0, 1)).abs() < 1.0e-10) + assert_true(freq.get(0, 1).abs() < 1.0e-10) } +///| test "submat_calculate_frequency_matrix_with_substitutions" { let alignment = ["ACGT", "AGGT"] // position 1: C->G let alpha = @src.subs_nucleotide_alphabet() @@ -306,6 +337,7 @@ test "submat_calculate_frequency_matrix_with_substitutions" { assert_true((freq.get(3, 3) - 2.0).abs() < 1.0e-10) } +///| test "submat_calculate_frequency_matrix_skips_gaps" { let alignment = ["A-A", "ACA"] // position 1: gap in seq1 let alpha = @src.subs_nucleotide_alphabet() @@ -315,16 +347,17 @@ test "submat_calculate_frequency_matrix_skips_gaps" { // Position 2: A-A -> freq[0][0] += 2 assert_true((freq.get(0, 0) - 4.0).abs() < 1.0e-10) // No C-C pairs - assert_true((freq.get(1, 1)).abs() < 1.0e-10) + assert_true(freq.get(1, 1).abs() < 1.0e-10) } +///| test "submat_calculate_frequency_matrix_single_sequence_returns_zeros" { let alignment = ["ACGT"] let alpha = @src.subs_nucleotide_alphabet() let freq = @src.calculate_frequency_matrix(alignment, alpha) for i in 0..<4 { for j in 0..<4 { - assert_true((freq.get(i, j)).abs() < 1.0e-10) + assert_true(freq.get(i, j).abs() < 1.0e-10) } } } @@ -333,6 +366,7 @@ test "submat_calculate_frequency_matrix_single_sequence_returns_zeros" { // Substitution matrix calculation (log-odds) // --------------------------------------------------------------------------- +///| test "submat_calculate_substitution_matrix_identical_seqs" { let alignment = ["AC", "AC"] let alpha = ["A", "C"] @@ -342,9 +376,10 @@ test "submat_calculate_substitution_matrix_identical_seqs" { assert_true((m.get_score("A", "A") - 2.0).abs() < 1.0e-10) assert_true((m.get_score("C", "C") - 2.0).abs() < 1.0e-10) // Off-diagonal: observed=0 -> -999 - assert_true((m.get_score("A", "C") - (-999.0)).abs() < 1.0e-10) + assert_true((m.get_score("A", "C") - -999.0).abs() < 1.0e-10) } +///| test "submat_calculate_substitution_matrix_default_scale" { let alignment = ["AA", "AA"] let alpha = ["A"] @@ -359,17 +394,21 @@ test "submat_calculate_substitution_matrix_default_scale" { // Shannon entropy // --------------------------------------------------------------------------- +///| test "submat_shannon_entropy_uniform_distribution" { // 2x2 matrix with all equal values: H = log2(4) = 2 let pairs = [ - ("A", "A", 1.0), ("A", "C", 1.0), - ("C", "A", 1.0), ("C", "C", 1.0), + ("A", "A", 1.0), + ("A", "C", 1.0), + ("C", "A", 1.0), + ("C", "C", 1.0), ] let freq = @src.array_data_from_dict(pairs, ["A", "C"], ["A", "C"]) let h = @src.subs_shannon_entropy(freq) assert_true((h - 2.0).abs() < 1.0e-10) } +///| test "submat_shannon_entropy_certain_distribution" { // All mass on one cell: H = 0 let pairs = [("A", "A", 4.0)] @@ -378,6 +417,7 @@ test "submat_shannon_entropy_certain_distribution" { assert_true(h.abs() < 1.0e-10) } +///| test "submat_shannon_entropy_empty_matrix" { let pairs : Array[(String, String, Double)] = [] let freq = @src.array_data_from_dict(pairs, ["A"], ["A"]) @@ -385,6 +425,7 @@ test "submat_shannon_entropy_empty_matrix" { assert_true(h.abs() < 1.0e-10) } +///| test "submat_shannon_entropy_two_equal_cells" { // Two non-zero cells with equal weight: H = 1 let pairs = [("A", "A", 1.0), ("C", "C", 1.0)] @@ -397,17 +438,21 @@ test "submat_shannon_entropy_two_equal_cells" { // Relative entropy (KL divergence) // --------------------------------------------------------------------------- +///| test "submat_relative_entropy_uniform_is_zero" { // When all letters equally frequent, observed == expected, KL = 0 let pairs = [ - ("A", "A", 1.0), ("A", "C", 1.0), - ("C", "A", 1.0), ("C", "C", 1.0), + ("A", "A", 1.0), + ("A", "C", 1.0), + ("C", "A", 1.0), + ("C", "C", 1.0), ] let freq = @src.array_data_from_dict(pairs, ["A", "C"], ["A", "C"]) let kl = @src.subs_relative_entropy(freq) assert_true(kl.abs() < 1.0e-10) } +///| test "submat_relative_entropy_identical_pairs_zero" { // Only A-A pairs: q(A,A)=1, p(A)=1, exp=1, KL = 1 * log2(1/1) = 0 let pairs = [("A", "A", 4.0)] @@ -416,6 +461,7 @@ test "submat_relative_entropy_identical_pairs_zero" { assert_true(kl.abs() < 1.0e-10) } +///| test "submat_relative_entropy_empty_matrix" { let pairs : Array[(String, String, Double)] = [] let freq = @src.array_data_from_dict(pairs, ["A"], ["A"]) @@ -427,6 +473,7 @@ test "submat_relative_entropy_empty_matrix" { // NCBI matrix parsing // --------------------------------------------------------------------------- +///| test "submat_parse_ncbi_matrix_simple" { let content = #|# Test matrix @@ -437,10 +484,11 @@ test "submat_parse_ncbi_matrix_simple" { assert_true(opt.is_some()) let m = opt.unwrap() assert_true((m.get_score("A", "A") - 1.0).abs() < 1.0e-10) - assert_true((m.get_score("A", "C") - (-1.0)).abs() < 1.0e-10) + assert_true((m.get_score("A", "C") - -1.0).abs() < 1.0e-10) assert_true((m.get_score("C", "C") - 1.0).abs() < 1.0e-10) } +///| test "submat_parse_ncbi_matrix_with_comments" { let content = #|# Generated by NCBI @@ -455,16 +503,18 @@ test "submat_parse_ncbi_matrix_with_comments" { let m = opt.unwrap() assert_true((m.get_score("A", "A") - 5.0).abs() < 1.0e-10) assert_true((m.get_score("C", "C") - 5.0).abs() < 1.0e-10) - assert_true((m.get_score("A", "C") - (-4.0)).abs() < 1.0e-10) - assert_true((m.get_score("G", "T") - (-4.0)).abs() < 1.0e-10) + assert_true((m.get_score("A", "C") - -4.0).abs() < 1.0e-10) + assert_true((m.get_score("G", "T") - -4.0).abs() < 1.0e-10) } +///| test "submat_parse_ncbi_matrix_empty_returns_none" { let content = "# only comments\n# nothing else\n" let opt = @src.parse_ncbi_matrix(content) assert_true(opt.is_none()) } +///| test "submat_parse_ncbi_matrix_handles_extra_whitespace" { let content = "A C\nA 2 -3\nC -3 2\n" let opt = @src.parse_ncbi_matrix(content) @@ -472,13 +522,14 @@ test "submat_parse_ncbi_matrix_handles_extra_whitespace" { let m = opt.unwrap() assert_true((m.get_score("A", "A") - 2.0).abs() < 1.0e-10) assert_true((m.get_score("C", "C") - 2.0).abs() < 1.0e-10) - assert_true((m.get_score("A", "C") - (-3.0)).abs() < 1.0e-10) + assert_true((m.get_score("A", "C") - -3.0).abs() < 1.0e-10) } // --------------------------------------------------------------------------- // Matrix correlation // --------------------------------------------------------------------------- +///| test "submat_matrix_correlation_identical_matrices" { let m1 = @src.subs_blosum62_matrix() let m2 = @src.subs_blosum62_matrix() @@ -487,6 +538,7 @@ test "submat_matrix_correlation_identical_matrices" { assert_true((corr - 1.0).abs() < 1.0e-9) } +///| test "submat_matrix_correlation_blosum45_vs_blosum62" { let m45 = @src.subs_blosum45_matrix() let m62 = @src.subs_blosum62_matrix() @@ -496,6 +548,7 @@ test "submat_matrix_correlation_blosum45_vs_blosum62" { assert_true(corr <= 1.0) } +///| test "submat_matrix_correlation_disjoint_alphabets" { let alpha1 = ["A"] let alpha2 = ["C"] @@ -510,6 +563,7 @@ test "submat_matrix_correlation_disjoint_alphabets" { // End-to-end: derive matrix from alignment, then score // --------------------------------------------------------------------------- +///| test "submat_end_to_end_derive_matrix_and_score" { // Build a small alignment where A and C never co-occur at the same position let alignment = ["AAA", "AAA", "CCC", "CCC"] diff --git a/test/moonbit/survival_test.mbt b/test/moonbit/survival_test.mbt index 1a692b81..163ce505 100644 --- a/test/moonbit/survival_test.mbt +++ b/test/moonbit/survival_test.mbt @@ -410,7 +410,9 @@ test "survival_normal_cdf" { ///| test "survival_normal_p_value_two_sided" { // z=1.96 -> p ≈ 0.05 - assert_true((@src.survival_normal_p_value_two_sided(1.96) - 0.05).abs() < 0.01) + assert_true( + (@src.survival_normal_p_value_two_sided(1.96) - 0.05).abs() < 0.01, + ) // z=0 -> p = 1.0 assert_true((@src.survival_normal_p_value_two_sided(0.0) - 1.0).abs() < 0.001) // p-value should be in [0, 1] @@ -432,7 +434,10 @@ test "survival_chi_square_p_value" { assert_true(@src.survival_chi_square_p_value(10.0, 5) >= 0.0) assert_true(@src.survival_chi_square_p_value(10.0, 5) <= 1.0) // Larger chi_sq gives smaller p-value - assert_true(@src.survival_chi_square_p_value(10.0, 1) < @src.survival_chi_square_p_value(1.0, 1)) + assert_true( + @src.survival_chi_square_p_value(10.0, 1) < + @src.survival_chi_square_p_value(1.0, 1), + ) } // =========================================================================== diff --git a/test/moonbit/system_piper_test.mbt b/test/moonbit/system_piper_test.mbt index 87e264b7..1cc2b8d2 100644 --- a/test/moonbit/system_piper_test.mbt +++ b/test/moonbit/system_piper_test.mbt @@ -1,6 +1,5 @@ ///| /// Test file for SystemPipeR module. - test "pipeline_new" { let pipe = @src.Pipeline::new("test_v1", "Test Pipeline") assert_eq(pipe.get_id(), "test_v1") @@ -8,6 +7,7 @@ test "pipeline_new" { assert_eq(pipe.get_n_steps(), 0) } +///| test "pipeline_set_description" { let pipe = @src.Pipeline::new("test", "Test") let pipe2 = pipe.set_description("A test pipeline") @@ -16,17 +16,20 @@ test "pipeline_set_description" { assert_true(s.contains("A test pipeline")) } +///| test "pipeline_set_param" { let pipe = @src.Pipeline::new("test", "Test") let pipe2 = pipe.set_param("key1", "value1") assert_eq(pipe2.get_param("key1"), "value1") } +///| test "pipeline_get_param_missing" { let pipe = @src.Pipeline::new("test", "Test") assert_eq(pipe.get_param("nonexistent"), "") } +///| test "pipeline_add_step" { let pipe = @src.Pipeline::new("test", "Test") let step = @src.PipelineStep::new("step1", "Step 1", "echo") @@ -34,6 +37,7 @@ test "pipeline_add_step" { assert_eq(pipe2.get_n_steps(), 1) } +///| test "pipeline_get_step" { let pipe = @src.Pipeline::new("test", "Test") let step = @src.PipelineStep::new("step1", "Step 1", "echo") @@ -43,12 +47,14 @@ test "pipeline_get_step" { assert_eq(s.get_name(), "Step 1") } +///| test "pipeline_get_step_not_found" { let pipe = @src.Pipeline::new("test", "Test") let s = pipe.get_step("missing") assert_eq(s.get_id(), "") } +///| test "pipeline_get_steps" { let pipe = @src.Pipeline::new("test", "Test") let pipe2 = pipe.add_step(@src.PipelineStep::new("s1", "S1", "cmd1")) @@ -57,26 +63,31 @@ test "pipeline_get_steps" { assert_eq(steps.length(), 2) } +///| test "pipeline_completed_count" { let pipe = @src.Pipeline::new("test", "Test") assert_eq(pipe.get_completed_count(), 0) } +///| test "pipeline_failed_count" { let pipe = @src.Pipeline::new("test", "Test") assert_eq(pipe.get_failed_count(), 0) } +///| test "pipeline_pending_count" { let pipe = @src.Pipeline::new("test", "Test") assert_eq(pipe.get_pending_count(), 0) } +///| test "pipeline_progress_empty" { let pipe = @src.Pipeline::new("test", "Test") assert_eq(pipe.get_progress(), 0.0) } +///| test "step_new" { let step = @src.PipelineStep::new("s1", "My Step", "bwa") assert_eq(step.get_id(), "s1") @@ -84,18 +95,21 @@ test "step_new" { assert_eq(step.get_command(), "bwa") } +///| test "step_set_description" { let step = @src.PipelineStep::new("s1", "Step", "cmd") let step2 = step.set_description("A step for testing") assert_eq(step2.description, "A step for testing") } +///| test "step_set_args" { let step = @src.PipelineStep::new("s1", "Step", "cmd") let step2 = step.set_args(["arg1", "arg2", "-v"]) assert_eq(step2.args.length(), 3) } +///| test "step_add_dependency" { let step = @src.PipelineStep::new("s2", "Step 2", "cmd") let step2 = step.add_dependency("s1") @@ -104,28 +118,33 @@ test "step_add_dependency" { assert_eq(deps[0], "s1") } +///| test "step_add_input" { let step = @src.PipelineStep::new("s1", "Step", "cmd") let step2 = step.add_input("input.fq") assert_eq(step2.input_files.length(), 1) } +///| test "step_add_output" { let step = @src.PipelineStep::new("s1", "Step", "cmd") let step2 = step.add_output("output.bam") assert_eq(step2.output_files.length(), 1) } +///| test "step_status" { let step = @src.PipelineStep::new("s1", "Step", "cmd") assert_true(step.get_status() is @src.StepStatus::Pending) } +///| test "step_duration" { let step = @src.PipelineStep::new("s1", "Step", "cmd") assert_eq(step.get_duration(), 0.0) } +///| test "step_status_to_string" { // Test default status via PipelineStep (which has Pending by default) let step = @src.PipelineStep::new("s1", "Step", "cmd") @@ -133,6 +152,7 @@ test "step_status_to_string" { assert_eq(status_str, "pending") } +///| test "pipeline_config_new" { let config = @src.PipelineConfig::new("/work", "/input", "/output") assert_eq(config.get_work_dir(), "/work") @@ -141,12 +161,14 @@ test "pipeline_config_new" { assert_eq(config.get_cores(), 1) } +///| test "pipeline_config_set_cores" { let config = @src.PipelineConfig::new("/w", "/i", "/o") let config2 = config.set_cores(8) assert_eq(config2.get_cores(), 8) } +///| test "pipeline_summary" { let pipe = @src.Pipeline::new("test", "My Pipeline") let s = pipe.summary() @@ -154,6 +176,7 @@ test "pipeline_summary" { assert_true(s.contains("My Pipeline")) } +///| test "pipeline_to_ascii" { let pipe = @src.Pipeline::new("test", "My Pipeline") let ascii = pipe.to_ascii() @@ -161,6 +184,7 @@ test "pipeline_to_ascii" { assert_true(ascii.contains("Progress")) } +///| test "pipeline_sample" { let pipe = @src.pipeline_sample() assert_true(pipe.get_n_steps() >= 5) @@ -168,6 +192,7 @@ test "pipeline_sample" { assert_true(pipe.get_progress() >= 0.0) } +///| test "pipeline_sample_steps" { let pipe = @src.pipeline_sample() let steps = pipe.get_steps() @@ -176,14 +201,16 @@ test "pipeline_sample_steps" { assert_eq(first.get_name(), "Quality Control") } +///| test "pipeline_global_params" { let pipe = @src.pipeline_sample() assert_eq(pipe.get_param("reference_genome"), "GRCh38.p14") assert_eq(pipe.get_param("species"), "Homo sapiens") } +///| test "step_can_run_no_deps" { let pipe = @src.Pipeline::new("test", "Test") let step = @src.PipelineStep::new("s1", "Step 1", "cmd") assert_true(pipe.can_run_step(step)) -} \ No newline at end of file +} diff --git a/test/moonbit/taxonomy_test.mbt b/test/moonbit/taxonomy_test.mbt index 1e28d482..0d589edc 100644 --- a/test/moonbit/taxonomy_test.mbt +++ b/test/moonbit/taxonomy_test.mbt @@ -1,11 +1,11 @@ ///| /// Taxonomy module tests - test "TaxonomyDatabase::new" { let db = @src.TaxonomyDatabase::new() assert_eq(db.count_taxa(), 0) } +///| test "TaxonomyDatabase::add_taxon" { let db = @src.TaxonomyDatabase::new() let taxon = @src.Taxon::new("1", "0", "no rank").set_scientific_name("root") @@ -13,6 +13,7 @@ test "TaxonomyDatabase::add_taxon" { assert_eq(db.count_taxa(), 1) } +///| test "TaxonomyDatabase::get_taxon" { let db = @src.TaxonomyDatabase::new() let taxon = @src.Taxon::new("1", "0", "no rank").set_scientific_name("root") @@ -23,6 +24,7 @@ test "TaxonomyDatabase::get_taxon" { } } +///| test "TaxonomyDatabase::get_taxid_by_name" { let db = @src.create_example_taxonomy() match db.get_taxid_by_name("Homo sapiens") { @@ -31,6 +33,7 @@ test "TaxonomyDatabase::get_taxid_by_name" { } } +///| test "TaxonomyDatabase::get_lineage" { let db = @src.create_example_taxonomy() let lineage = db.get_lineage("9606") @@ -38,12 +41,14 @@ test "TaxonomyDatabase::get_lineage" { assert_eq(lineage[lineage.length() - 1], "Homo sapiens") } +///| test "TaxonomyDatabase::get_ancestors" { let db = @src.create_example_taxonomy() let ancestors = db.get_ancestors("9606") assert_true(ancestors.length() > 0) } +///| test "TaxonomyDatabase::get_common_ancestor" { let db = @src.create_example_taxonomy() match db.get_common_ancestor("9606", "9599") { @@ -52,30 +57,35 @@ test "TaxonomyDatabase::get_common_ancestor" { } } +///| test "TaxonomyDatabase::is_ancestor" { let db = @src.create_example_taxonomy() assert_true(db.is_ancestor("9604", "9606")) assert_true(!db.is_ancestor("9606", "9604")) } +///| test "TaxonomyDatabase::get_distance" { let db = @src.create_example_taxonomy() let dist = db.get_distance("9606", "9599") assert_true(dist > 0) } +///| test "TaxonomyDatabase::get_taxa_by_rank" { let db = @src.create_example_taxonomy() let species = db.get_taxa_by_rank("species") assert_true(species.length() >= 2) } +///| test "parse_nodes_dmp" { let content = "1\t|\t0\t|\tno rank\t|\n131567\t|\t1\t|\tno rank\t|\n2759\t|\t131567\t|\tsuperkingdom\t|\n" let db = @src.parse_nodes_dmp(@src.TaxonomyDatabase::new(), content) assert_eq(db.count_taxa(), 3) } +///| test "parse_names_dmp" { let db = @src.TaxonomyDatabase::new() ignore(db.add_taxon(@src.Taxon::new("1", "0", "no rank"))) @@ -87,23 +97,27 @@ test "parse_names_dmp" { } } +///| test "create_example_taxonomy" { let db = @src.create_example_taxonomy() assert_true(db.count_taxa() > 10) } +///| test "get_all_species" { let db = @src.create_example_taxonomy() let species = db.get_all_species() assert_true(species.length() >= 2) } +///| test "get_common_names" { let db = @src.create_example_taxonomy() let names = db.get_common_names("9606") assert_true(contains_string(names, "human")) } +///| fn contains_string(arr : Array[String], s : String) -> Bool { let mut i = 0 while i < arr.length() { @@ -113,4 +127,4 @@ fn contains_string(arr : Array[String], s : String) -> Bool { i = i + 1 } false -} \ No newline at end of file +} diff --git a/test/moonbit/topgo_test.mbt b/test/moonbit/topgo_test.mbt index 0d345f33..62fefc8e 100644 --- a/test/moonbit/topgo_test.mbt +++ b/test/moonbit/topgo_test.mbt @@ -1,6 +1,5 @@ ///| /// Tests for topGO module. - test "TopGOTerm creation" { let term = @src.TopGOTerm::new("GO:0008150", "biological_process", "BP", 0) assert_eq(term.go_id, "GO:0008150") @@ -10,6 +9,7 @@ test "TopGOTerm creation" { assert_eq(term.gene_count, 0) } +///| test "TopGOGraph construction" { let mut graph = @src.TopGOGraph::new("GO:0008150") let root = @src.TopGOTerm::new("GO:0008150", "biological_process", "BP", 0) @@ -17,6 +17,7 @@ test "TopGOGraph construction" { assert_true(graph.terms.contains("GO:0008150")) } +///| test "TopGOGraph add edge" { let mut graph = @src.TopGOGraph::new("GO:0008150") let root = @src.TopGOTerm::new("GO:0008150", "biological_process", "BP", 0) @@ -28,22 +29,35 @@ test "TopGOGraph add edge" { assert_true(graph.terms.contains("GO:0009987")) } +///| test "topgo_elim_algorithm" { let graph = @src.create_example_topgo_graph() let genes_of_interest = ["gene1", "gene2", "gene3"] - let all_genes = ["gene1", "gene2", "gene3", "gene4", "gene5", "gene6", "gene7", "gene8", "gene9", "gene10"] - let results = @src.topgo_elim_algorithm(graph, genes_of_interest, all_genes, "BP") + let all_genes = [ + "gene1", "gene2", "gene3", "gene4", "gene5", "gene6", "gene7", "gene8", "gene9", + "gene10", + ] + let results = @src.topgo_elim_algorithm( + graph, genes_of_interest, all_genes, "BP", + ) assert_true(results.length() > 0) } +///| test "topgo_weight01_algorithm" { let graph = @src.create_example_topgo_graph() let genes_of_interest = ["gene1", "gene2", "gene3"] - let all_genes = ["gene1", "gene2", "gene3", "gene4", "gene5", "gene6", "gene7", "gene8", "gene9", "gene10"] - let results = @src.topgo_weight01_algorithm(graph, genes_of_interest, all_genes, "BP") + let all_genes = [ + "gene1", "gene2", "gene3", "gene4", "gene5", "gene6", "gene7", "gene8", "gene9", + "gene10", + ] + let results = @src.topgo_weight01_algorithm( + graph, genes_of_interest, all_genes, "BP", + ) assert_true(results.length() > 0) } +///| test "topgo_fisher_exact" { let p = @src.topgo_fisher_exact(3, 10, 5, 100) assert_true(p >= 0.0 && p <= 1.0) diff --git a/test/moonbit/tradeseq_test.mbt b/test/moonbit/tradeseq_test.mbt index 985663c7..0ce2abc6 100644 --- a/test/moonbit/tradeseq_test.mbt +++ b/test/moonbit/tradeseq_test.mbt @@ -4,9 +4,9 @@ test "tradeseq_create_trajectory_point" { "cell_001", 0.5, [1.0, 2.0, 3.0], - "control" + "control", ) - + assert_eq(point.cell_id, "cell_001") assert_true((point.pseudotime - 0.5).abs() < 1.0e-10) assert_eq(point.expression.length(), 3) @@ -19,9 +19,9 @@ test "tradeseq_create_gene_expression" { "GeneA", [1.0, 2.0, 3.0, 4.0], [0.1, 0.3, 0.5, 0.7], - ["control", "control", "treatment", "treatment"] + ["control", "control", "treatment", "treatment"], ) - + assert_eq(data.gene_id, "GeneA") assert_eq(data.expression.length(), 4) assert_eq(data.pseudotime.length(), 4) @@ -31,20 +31,15 @@ test "tradeseq_create_gene_expression" { ///| test "tradeseq_trajectory_data" { let mut data = @src.TrajectoryData::new() - + assert_eq(data.n_points, 0) assert_eq(data.n_genes, 0) - + data = data.add_gene("GeneA") assert_eq(data.n_genes, 1) - - let point = @src.TrajectoryPoint::new( - "cell_001", - 0.5, - [1.0], - "control" - ) - + + let point = @src.TrajectoryPoint::new("cell_001", 0.5, [1.0], "control") + data = data.add_point(point) assert_eq(data.n_points, 1) } @@ -55,11 +50,11 @@ test "tradeseq_fit_gam" { "GeneA", [1.0, 2.0, 3.0, 4.0, 5.0, 6.0], [0.0, 0.2, 0.4, 0.6, 0.8, 1.0], - ["control", "control", "control", "treatment", "treatment", "treatment"] + ["control", "control", "control", "treatment", "treatment", "treatment"], ) - + let gam = @src.fit_gam(gene_data, 4) - + assert_eq(gam.gene_id, "GeneA") assert_true(gam.fitted_values.length() > 0) } @@ -70,11 +65,13 @@ test "tradeseq_trade_test" { "GeneA", [1.0, 1.2, 1.5, 2.0, 2.5, 3.0], [0.0, 0.2, 0.4, 0.6, 0.8, 1.0], - ["control", "control", "control", "treatment", "treatment", "treatment"] + ["control", "control", "control", "treatment", "treatment", "treatment"], + ) + + let result = @src.trade_test_condition_effect( + gene_data, 0.5, "control", "treatment", ) - - let result = @src.trade_test_condition_effect(gene_data, 0.5, "control", "treatment") - + assert_eq(result.gene_id, "GeneA") assert_true(result.p_value >= 0.0) // Just check p_value is non-negative @@ -83,18 +80,18 @@ test "tradeseq_trade_test" { ///| test "tradeseq_run_analysis" { let trajectory_data = @src.create_example_trajectory_data() - + assert_true(trajectory_data.n_points > 0) assert_true(trajectory_data.n_genes > 0) - + let result = @src.run_tradeseq_analysis( trajectory_data, trajectory_data.genes, trajectory_data.conditions, 4, - 0.05 + 0.05, ) - + assert_eq(result.n_genes, 3) assert_true(result.n_significant >= 0) assert_true(result.n_significant <= result.n_genes) @@ -103,9 +100,9 @@ test "tradeseq_run_analysis" { ///| test "tradeseq_calculate_smooth" { let trajectory_data = @src.create_example_trajectory_data() - + let smooth = @src.calculate_gene_smooth(trajectory_data, "GeneA", 4, 20) - + assert_eq(smooth.gene_id, "GeneA") assert_eq(smooth.pseudotime.length(), 20) assert_eq(smooth.fitted.length(), 20) @@ -119,11 +116,11 @@ test "tradeseq_summary" { trajectory_data.genes, trajectory_data.conditions, 4, - 0.05 + 0.05, ) - + let summary = @src.tradeseq_summary(result) - + assert_true(summary.contains("tradeSeq Analysis Summary")) assert_true(summary.contains("Total genes tested:")) } @@ -131,7 +128,7 @@ test "tradeseq_summary" { ///| test "tradeseq_create_example" { let data = @src.create_example_trajectory_data() - + assert_true(data.n_points == 50) assert_true(data.n_genes == 3) assert_true(data.conditions.length() >= 2) @@ -143,11 +140,13 @@ test "tradeseq_condition_effect_zero" { "GeneA", [1.0, 1.0, 1.0, 1.0, 1.0, 1.0], [0.0, 0.2, 0.4, 0.6, 0.8, 1.0], - ["control", "control", "control", "treatment", "treatment", "treatment"] + ["control", "control", "control", "treatment", "treatment", "treatment"], + ) + + let result = @src.trade_test_condition_effect( + gene_data, 0.5, "control", "treatment", ) - - let result = @src.trade_test_condition_effect(gene_data, 0.5, "control", "treatment") - + // No difference should give high p-value assert_true(result.p_value > 0.05) } @@ -156,25 +155,19 @@ test "tradeseq_condition_effect_zero" { test "tradeseq_trajectory_empty" { let mut data = @src.TrajectoryData::new() data = data.add_gene("GeneA") - - let result = @src.run_tradeseq_analysis( - data, - ["GeneA"], - ["control"], - 4, - 0.05 - ) - + + let result = @src.run_tradeseq_analysis(data, ["GeneA"], ["control"], 4, 0.05) + assert_eq(result.n_genes, 1) } ///| test "tradeseq_multiple_smooth" { let trajectory_data = @src.create_example_trajectory_data() - + let smooth_a = @src.calculate_gene_smooth(trajectory_data, "GeneA", 4, 15) let smooth_b = @src.calculate_gene_smooth(trajectory_data, "GeneB", 4, 15) - + assert_eq(smooth_a.gene_id, "GeneA") assert_eq(smooth_b.gene_id, "GeneB") assert_eq(smooth_a.fitted.length(), 15) diff --git a/test/moonbit/trie_test.mbt b/test/moonbit/trie_test.mbt index 365aebe8..fbe4a463 100644 --- a/test/moonbit/trie_test.mbt +++ b/test/moonbit/trie_test.mbt @@ -306,7 +306,9 @@ test "triefind_find_words_with_boundaries" { let trie = @src.Trie::new() @src.trie_insert(trie, "EcoRI", "enzyme1") @src.trie_insert(trie, "BamHI", "enzyme2") - let results = @src.triefind_find_words(trie, "Use EcoRI and BamHI for cloning") + let results = @src.triefind_find_words( + trie, "Use EcoRI and BamHI for cloning", + ) assert_eq(results.length(), 2) } diff --git a/test/moonbit/twobit_io_test.mbt b/test/moonbit/twobit_io_test.mbt index 403f8ca3..50e04b6a 100644 --- a/test/moonbit/twobit_io_test.mbt +++ b/test/moonbit/twobit_io_test.mbt @@ -223,7 +223,9 @@ test "twobit_unpack_sequence_simple" { ///| test "twobit_pack_sequence_with_n_blocks" { - let (packed, n_blocks, mask_blocks) = @src.twobit_pack_sequence("ATGCNNNNATGC") + let (packed, n_blocks, mask_blocks) = @src.twobit_pack_sequence( + "ATGCNNNNATGC", + ) assert_eq(packed.length(), 3) // ceil(12/4) = 3 bytes assert_eq(n_blocks.length(), 1) assert_eq(n_blocks[0].start(), 4) @@ -234,7 +236,9 @@ test "twobit_pack_sequence_with_n_blocks" { ///| test "twobit_unpack_sequence_with_n_blocks" { - let (packed, n_blocks, mask_blocks) = @src.twobit_pack_sequence("ATGCNNNNATGC") + let (packed, n_blocks, mask_blocks) = @src.twobit_pack_sequence( + "ATGCNNNNATGC", + ) let result = @src.twobit_unpack_sequence(packed, 12, n_blocks, mask_blocks) assert_eq(result, "ATGCNNNNATGC") } diff --git a/test/moonbit/uniprot_io_test.mbt b/test/moonbit/uniprot_io_test.mbt index 64c57e4f..451d3ef0 100644 --- a/test/moonbit/uniprot_io_test.mbt +++ b/test/moonbit/uniprot_io_test.mbt @@ -95,7 +95,13 @@ test "parse_uniprot_xml_with_dbreferences" { ///| test "uniprot_to_seqrecord" { - let entry = @src.UniprotEntry::new("P12345", "Test Protein", ["GENE1"], "Homo sapiens", "ACGTACGTAC") + let entry = @src.UniprotEntry::new( + "P12345", + "Test Protein", + ["GENE1"], + "Homo sapiens", + "ACGTACGTAC", + ) let (header, id, desc, kwargs) = @src.uniprot_to_seqrecord(entry) assert_true(header.length() > 0) assert_true(id.length() > 0) @@ -104,7 +110,13 @@ test "uniprot_to_seqrecord" { ///| test "uniprot_entry_methods" { - let entry = @src.UniprotEntry::new("P12345", "Test Protein", ["GENE1", "GENE2"], "Homo sapiens", "ACGTACGTAC") + let entry = @src.UniprotEntry::new( + "P12345", + "Test Protein", + ["GENE1", "GENE2"], + "Homo sapiens", + "ACGTACGTAC", + ) assert_eq(entry.accession, "P12345") assert_eq(entry.sequence, "ACGTACGTAC") assert_eq(entry.seq_length, 10) diff --git a/test/moonbit/universalmotif_test.mbt b/test/moonbit/universalmotif_test.mbt index 0f127845..a9667374 100644 --- a/test/moonbit/universalmotif_test.mbt +++ b/test/moonbit/universalmotif_test.mbt @@ -6,9 +6,9 @@ test "universalmotif_motif_from_pwm" { [0.0, 0.0, 0.9, 0.1], [0.1, 0.9, 0.0, 0.0], ] - + let motif = @src.S4Motif::from_pwm("TATA-box", "DNA", pwm) - + assert_eq(motif.name, "TATA-box") assert_eq(motif.alphabet, "DNA") assert_eq(motif.pwm.length(), 4) @@ -16,21 +16,17 @@ test "universalmotif_motif_from_pwm" { ///| test "universalmotif_calculate_consensus" { - let pwm = [ - [0.9, 0.1, 0.0, 0.0], - [0.0, 0.0, 0.9, 0.1], - [0.1, 0.9, 0.0, 0.0], - ] - + let pwm = [[0.9, 0.1, 0.0, 0.0], [0.0, 0.0, 0.9, 0.1], [0.1, 0.9, 0.0, 0.0]] + let motif = @src.S4Motif::from_pwm("test", "DNA", pwm) - + assert_eq(motif.consensus.length(), 3) } ///| test "universalmotif_create_example_motif" { let motif = @src.create_example_s4motif() - + assert_eq(motif.name, "TATA-box") assert_eq(motif.pwm.length(), 5) -} \ No newline at end of file +} diff --git a/test/moonbit/uwot_test.mbt b/test/moonbit/uwot_test.mbt index 61a2f432..61700c74 100644 --- a/test/moonbit/uwot_test.mbt +++ b/test/moonbit/uwot_test.mbt @@ -6,10 +6,7 @@ // ============================================================ test "uwot_distance_matrix square" { - let data : Array[Array[Double]] = [ - [0.0, 0.0], - [3.0, 4.0], - ] + let data : Array[Array[Double]] = [[0.0, 0.0], [3.0, 4.0]] let dist = @src.uwot_distance_matrix(data) assert_eq(dist.length(), 2) assert_eq(dist[0].length(), 2) @@ -20,6 +17,7 @@ test "uwot_distance_matrix square" { assert_eq(dist[1][0], 5.0) } +///| test "uwot_distance_matrix empty" { let data : Array[Array[Double]] = [] let dist = @src.uwot_distance_matrix(data) @@ -30,6 +28,7 @@ test "uwot_distance_matrix empty" { // UMAP config tests // ============================================================ +///| test "umap_config default" { let config = @src.UmapConfig::new() assert_eq(config.n_neighbors, 15) @@ -44,19 +43,21 @@ test "umap_config default" { // UMAP algorithm tests // ============================================================ +///| test "umap basic 2d" { let data = @src.create_umap_test_data(10, 5) assert_eq(data.length(), 10) assert_eq(data[0].length(), 5) - + let config = @src.UmapConfig::new() - + let result = @src.uwot_umap(data, config) assert_eq(result.embedding.length(), 10) assert_eq(result.embedding[0].length(), 2) assert_eq(result.n_epochs, 200) } +///| test "umap empty data" { let data : Array[Array[Double]] = [] let config = @src.UmapConfig::new() @@ -64,6 +65,7 @@ test "umap empty data" { assert_eq(result.embedding.length(), 0) } +///| test "umap single sample" { let data : Array[Array[Double]] = [[1.0, 2.0, 3.0]] let config = @src.UmapConfig::new() @@ -71,28 +73,30 @@ test "umap single sample" { assert_true(result.embedding.length() <= 1) } +///| test "umap different n_components" { let data = @src.create_umap_test_data(10, 5) let custom_config = @src.UmapConfig::new_custom(3, 3, 50, 42) - + let result = @src.uwot_umap(data, custom_config) assert_eq(result.embedding[0].length(), 3) } +///| test "umap produces finite values" { let data = @src.create_umap_test_data(12, 4) let custom_config = @src.UmapConfig::new_custom(3, 2, 50, 42) - + let result = @src.uwot_umap(data, custom_config) - + // Check that all embedding values are finite let mut i = 0 while i < result.embedding.length() { let mut j = 0 while j < result.embedding[i].length() { let val = result.embedding[i][j] - assert_true(val == val) // NaN check - assert_true(val < 1.0e300) // infinity check + assert_true(val == val) // NaN check + assert_true(val < 1.0e300) // infinity check assert_true(val > -1.0e300) j = j + 1 } @@ -104,12 +108,14 @@ test "umap produces finite values" { // Test data generation tests // ============================================================ +///| test "create_umap_test_data dimensions" { let data = @src.create_umap_test_data(20, 8) assert_eq(data.length(), 20) assert_eq(data[0].length(), 8) } +///| test "create_umap_test_data clusters" { let data = @src.create_umap_test_data(8, 3) // 4 clusters, each should have similar values @@ -117,7 +123,7 @@ test "create_umap_test_data clusters" { // Cluster 1: samples 1, 5 // Cluster 2: samples 2, 6 // Cluster 3: samples 3, 7 - + // Check that cluster 0 is different from cluster 3 let mut sum0 = 0.0 let mut j = 0 @@ -125,14 +131,14 @@ test "create_umap_test_data clusters" { sum0 = sum0 + data[0][j] j = j + 1 } - + let mut sum3 = 0.0 j = 0 while j < 3 { sum3 = sum3 + data[3][j] j = j + 1 } - + // Clusters should be separated assert_true(sum3 > sum0) } diff --git a/test/moonbit/variant_filtering_test.mbt b/test/moonbit/variant_filtering_test.mbt index 2b0e86ec..9f10d71d 100644 --- a/test/moonbit/variant_filtering_test.mbt +++ b/test/moonbit/variant_filtering_test.mbt @@ -1,13 +1,12 @@ ///| - test "variant_filtering_create_variant" { let info = Map([("DP", "20"), ("AF", "0.5")]) let genotypes = [("sample1", "0/1:30"), ("sample2", "1/1:25")] - + let variant = @src.Variant::new( - "chr1", 1000, "rs123", "A", "T", 50.0, "PASS", info, genotypes + "chr1", 1000, "rs123", "A", "T", 50.0, "PASS", info, genotypes, ) - + assert_eq(variant.chr, "chr1") assert_eq(variant.pos, 1000) assert_eq(variant.id, "rs123") @@ -18,23 +17,31 @@ test "variant_filtering_create_variant" { assert_eq(variant.genotypes.length(), 2) } +///| test "variant_filtering_filter" { let info_pass = Map([("DP", "20"), ("AF", "0.5")]) let info_fail = Map([("DP", "5"), ("AF", "0.001")]) - + let variants = [ - @src.Variant::new("chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info_pass, [("s1", "0/1:30")]), - @src.Variant::new("chr1", 2000, "rs2", "G", "C", 20.0, "FAIL", info_fail, [("s1", "0/1:10")]), - @src.Variant::new("chr1", 3000, "rs3", "T", "A", 60.0, "PASS", info_pass, [("s1", "0/1:35")]), + @src.Variant::new("chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info_pass, [ + ("s1", "0/1:30"), + ]), + @src.Variant::new("chr1", 2000, "rs2", "G", "C", 20.0, "FAIL", info_fail, [ + ("s1", "0/1:10"), + ]), + @src.Variant::new("chr1", 3000, "rs3", "T", "A", 60.0, "PASS", info_pass, [ + ("s1", "0/1:35"), + ]), ] - + let params = @src.VariantFilteringParam::new() let result = @src.bio_vfilter_filter(variants, params) - + assert_eq(result.passed_variants.length(), 2) assert_eq(result.filtered_variants.length(), 1) } +///| test "variant_filtering_check_autosomal_dominant" { let genotypes = [ ("proband", "1/1"), @@ -42,18 +49,26 @@ test "variant_filtering_check_autosomal_dominant" { ("mother", "0/0"), ("sibling", "0/0"), ] - + let info = Map([], capacity=0) - let variant = @src.Variant::new("chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info, genotypes) - - let phenotypes = Map([("proband", true), ("father", false), ("mother", false), ("sibling", false)]) + let variant = @src.Variant::new( + "chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info, genotypes, + ) + + let phenotypes = Map([ + ("proband", true), + ("father", false), + ("mother", false), + ("sibling", false), + ]) let model = @src.GeneticModel::new("autosomal_dominant") - + let passes = @src.bio_vfilter_check_inheritance(variant, model, phenotypes) - + assert_true(passes) } +///| test "variant_filtering_check_autosomal_recessive" { let genotypes = [ ("proband", "1/1"), @@ -61,46 +76,65 @@ test "variant_filtering_check_autosomal_recessive" { ("mother", "0/1"), ("sibling", "0/0"), ] - + let info = Map([], capacity=0) - let variant = @src.Variant::new("chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info, genotypes) - - let phenotypes = Map([("proband", true), ("father", false), ("mother", false), ("sibling", false)]) + let variant = @src.Variant::new( + "chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info, genotypes, + ) + + let phenotypes = Map([ + ("proband", true), + ("father", false), + ("mother", false), + ("sibling", false), + ]) let model = @src.GeneticModel::new("autosomal_recessive") - + let passes = @src.bio_vfilter_check_inheritance(variant, model, phenotypes) - + assert_true(passes) } +///| test "variant_filtering_summary" { let info_pass = Map([("DP", "20"), ("AF", "0.5")]) let info_fail = Map([("DP", "5"), ("AF", "0.001")]) - + let variants = [ - @src.Variant::new("chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info_pass, [("s1", "0/1:30")]), - @src.Variant::new("chr1", 2000, "rs2", "G", "C", 20.0, "FAIL", info_fail, [("s1", "0/1:10")]), + @src.Variant::new("chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info_pass, [ + ("s1", "0/1:30"), + ]), + @src.Variant::new("chr1", 2000, "rs2", "G", "C", 20.0, "FAIL", info_fail, [ + ("s1", "0/1:10"), + ]), ] - + let params = @src.VariantFilteringParam::new() let result = @src.bio_vfilter_filter(variants, params) - + let summary = @src.bio_vfilter_summary(result) - + assert_true(summary.contains("Total variants")) assert_true(summary.contains("Passed")) assert_true(summary.contains("Filtered")) } +///| test "variant_filtering_predict_consequence" { let info = Map([], capacity=0) let genotypes = [("s1", "0/1")] - - let snp = @src.Variant::new("chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info, genotypes) - let insertion = @src.Variant::new("chr1", 2000, "rs2", "A", "AT", 50.0, "PASS", info, genotypes) - let deletion = @src.Variant::new("chr1", 3000, "rs3", "AT", "A", 50.0, "PASS", info, genotypes) - + + let snp = @src.Variant::new( + "chr1", 1000, "rs1", "A", "T", 50.0, "PASS", info, genotypes, + ) + let insertion = @src.Variant::new( + "chr1", 2000, "rs2", "A", "AT", 50.0, "PASS", info, genotypes, + ) + let deletion = @src.Variant::new( + "chr1", 3000, "rs3", "AT", "A", 50.0, "PASS", info, genotypes, + ) + assert_eq(@src.bio_vfilter_predict_consequence(snp), "missense_variant") assert_eq(@src.bio_vfilter_predict_consequence(insertion), "insertion") assert_eq(@src.bio_vfilter_predict_consequence(deletion), "deletion") -} \ No newline at end of file +} diff --git a/test/moonbit/variation_test.mbt b/test/moonbit/variation_test.mbt index becf30ee..231203f1 100644 --- a/test/moonbit/variation_test.mbt +++ b/test/moonbit/variation_test.mbt @@ -37,4 +37,4 @@ test "variation_parse_vcf_line" { test "variation_create_example_data" { let records = @src.create_example_variation_data() assert_eq(records.length(), 2) -} \ No newline at end of file +} diff --git a/test/moonbit/velociraptor_test.mbt b/test/moonbit/velociraptor_test.mbt index aa86f0d3..77fd7586 100644 --- a/test/moonbit/velociraptor_test.mbt +++ b/test/moonbit/velociraptor_test.mbt @@ -108,7 +108,12 @@ test "vr_kinetic_model_returns_params" { test "vr_kinetic_model_sample_data" { let gene_data = @src.velocity_sample_data() for gd in gene_data { - let k = @src.velocity_kinetic_model(gd.gene_name(), gd.spliced(), gd.unspliced(), 30) + let k = @src.velocity_kinetic_model( + gd.gene_name(), + gd.spliced(), + gd.unspliced(), + 30, + ) assert_true(k.beta() > 0.0) assert_true(k.gamma() > 0.0) } @@ -132,7 +137,12 @@ test "vr_compute_returns_velocities" { let gene_data = @src.velocity_sample_data() let kinetics : Array[@src.GeneKinetics] = [] for gd in gene_data { - let k = @src.velocity_kinetic_model(gd.gene_name(), gd.spliced(), gd.unspliced(), 30) + let k = @src.velocity_kinetic_model( + gd.gene_name(), + gd.spliced(), + gd.unspliced(), + 30, + ) kinetics.push(k) } let velocities = @src.velocity_compute(gene_data, kinetics) @@ -162,7 +172,12 @@ test "vr_velocity_embedding" { let gene_data = @src.velocity_sample_data() let kinetics : Array[@src.GeneKinetics] = [] for gd in gene_data { - let k = @src.velocity_kinetic_model(gd.gene_name(), gd.spliced(), gd.unspliced(), 30) + let k = @src.velocity_kinetic_model( + gd.gene_name(), + gd.spliced(), + gd.unspliced(), + 30, + ) kinetics.push(k) } let velocities = @src.velocity_compute(gene_data, kinetics) @@ -191,7 +206,12 @@ test "vr_find_root_cells" { let gene_data = @src.velocity_sample_data() let kinetics : Array[@src.GeneKinetics] = [] for gd in gene_data { - let k = @src.velocity_kinetic_model(gd.gene_name(), gd.spliced(), gd.unspliced(), 30) + let k = @src.velocity_kinetic_model( + gd.gene_name(), + gd.spliced(), + gd.unspliced(), + 30, + ) kinetics.push(k) } let velocities = @src.velocity_compute(gene_data, kinetics) @@ -209,14 +229,21 @@ test "vr_root_cells_sorted_by_speed" { let gene_data = @src.velocity_sample_data() let kinetics : Array[@src.GeneKinetics] = [] for gd in gene_data { - let k = @src.velocity_kinetic_model(gd.gene_name(), gd.spliced(), gd.unspliced(), 30) + let k = @src.velocity_kinetic_model( + gd.gene_name(), + gd.spliced(), + gd.unspliced(), + 30, + ) kinetics.push(k) } let velocities = @src.velocity_compute(gene_data, kinetics) let roots = @src.velocity_find_root_cells(velocities, 5) // Speeds should be sorted descending. for i in 1..= velocities[roots[i]].speed()) + assert_true( + velocities[roots[i - 1]].speed() >= velocities[roots[i]].speed(), + ) } } @@ -229,7 +256,12 @@ test "vr_transition_matrix" { let gene_data = @src.velocity_sample_data() let kinetics : Array[@src.GeneKinetics] = [] for gd in gene_data { - let k = @src.velocity_kinetic_model(gd.gene_name(), gd.spliced(), gd.unspliced(), 30) + let k = @src.velocity_kinetic_model( + gd.gene_name(), + gd.spliced(), + gd.unspliced(), + 30, + ) kinetics.push(k) } let velocities = @src.velocity_compute(gene_data, kinetics) @@ -255,7 +287,12 @@ test "vr_transition_matrix_nonneg" { let gene_data = @src.velocity_sample_data() let kinetics : Array[@src.GeneKinetics] = [] for gd in gene_data { - let k = @src.velocity_kinetic_model(gd.gene_name(), gd.spliced(), gd.unspliced(), 30) + let k = @src.velocity_kinetic_model( + gd.gene_name(), + gd.spliced(), + gd.unspliced(), + 30, + ) kinetics.push(k) } let velocities = @src.velocity_compute(gene_data, kinetics) @@ -276,7 +313,9 @@ test "vr_transition_matrix_nonneg" { test "vr_run_pipeline" { let gene_data = @src.velocity_sample_data() let embeddings = @src.velocity_sample_embeddings(20) - let (kinetics, velocities, emb_vel) = @src.velocity_run(gene_data, embeddings, 5) + let (kinetics, velocities, emb_vel) = @src.velocity_run( + gene_data, embeddings, 5, + ) assert_eq(kinetics.length(), 4) // 4 genes assert_eq(velocities.length(), 20) // 20 cells assert_eq(emb_vel.length(), 20) diff --git a/test/moonbit/venn_diagram_test.mbt b/test/moonbit/venn_diagram_test.mbt index 0e557441..79acce5f 100644 --- a/test/moonbit/venn_diagram_test.mbt +++ b/test/moonbit/venn_diagram_test.mbt @@ -3,10 +3,9 @@ // 1. venn_diagram - basic Venn diagram with 2 sets test "venn_diagram_two_sets_basic" { - let result = @src.venn_diagram( - [["A", "B", "C", "D"], ["C", "D", "E", "F"]], - names=["Set1", "Set2"], - ) + let result = @src.venn_diagram([["A", "B", "C", "D"], ["C", "D", "E", "F"]], names=[ + "Set1", "Set2", + ]) assert_eq(result.n_sets, 2) assert_eq(result.set_names, ["Set1", "Set2"]) assert_eq(result.set_sizes, [4, 4]) @@ -15,6 +14,7 @@ test "venn_diagram_two_sets_basic" { assert_eq(result.regions.length(), 4) // 2^2 = 4 regions } +///| test "venn_diagram_two_sets_default_names" { let result = @src.venn_diagram([["A", "B"], ["B", "C"]]) assert_eq(result.set_names, ["Set1", "Set2"]) @@ -23,6 +23,8 @@ test "venn_diagram_two_sets_default_names" { } // 2. venn_diagram - basic Venn diagram with 3 sets + +///| test "venn_diagram_three_sets_basic" { let result = @src.venn_diagram( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -35,11 +37,11 @@ test "venn_diagram_three_sets_basic" { assert_eq(result.regions.length(), 8) // 2^3 = 8 regions } +///| test "venn_diagram_three_sets_no_overlap" { - let result = @src.venn_diagram( - [["A", "B"], ["C", "D"], ["E", "F"]], - names=["S1", "S2", "S3"], - ) + let result = @src.venn_diagram([["A", "B"], ["C", "D"], ["E", "F"]], names=[ + "S1", "S2", "S3", + ]) assert_eq(result.total_elements, 6) assert_eq(result.regions[1].count, 2) // only in S1 (0b001) assert_eq(result.regions[2].count, 2) // only in S2 (0b010) @@ -48,47 +50,47 @@ test "venn_diagram_three_sets_no_overlap" { } // 3. venn_get_region - get elements in specific region by bitmask + +///| test "venn_get_region_only_in_first_set" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["C", "D", "E"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["C", "D", "E"]], names=[ + "S1", "S2", + ]) let only_s1 = @src.venn_get_region(result, 1) // 0b01 assert_eq(only_s1.length(), 2) // A, B assert_true(only_s1.contains("A")) assert_true(only_s1.contains("B")) } +///| test "venn_get_region_only_in_second_set" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["C", "D", "E"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["C", "D", "E"]], names=[ + "S1", "S2", + ]) let only_s2 = @src.venn_get_region(result, 2) // 0b10 assert_eq(only_s2.length(), 2) // D, E assert_true(only_s2.contains("D")) assert_true(only_s2.contains("E")) } +///| test "venn_get_region_intersection_two_sets" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["C", "D", "E"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["C", "D", "E"]], names=[ + "S1", "S2", + ]) let inter = @src.venn_get_region(result, 3) // 0b11 assert_eq(inter.length(), 1) // C assert_true(inter.contains("C")) } +///| test "venn_get_region_outside_all" { - let result = @src.venn_diagram( - [["A", "B"], ["C", "D"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B"], ["C", "D"]], names=["S1", "S2"]) let outside = @src.venn_get_region(result, 0) assert_eq(outside.length(), 0) } +///| test "venn_get_region_invalid_id" { let result = @src.venn_diagram([["A"], ["B"]], names=["S1", "S2"]) let invalid = @src.venn_get_region(result, 10) @@ -96,28 +98,30 @@ test "venn_get_region_invalid_id" { } // 4. venn_only_in_set - elements only in one set + +///| test "venn_only_in_set_first" { - let result = @src.venn_diagram( - [["A", "B", "C", "D"], ["C", "D", "E", "F"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C", "D"], ["C", "D", "E", "F"]], names=[ + "S1", "S2", + ]) let only_first = @src.venn_only_in_set(result, 0) assert_eq(only_first.length(), 2) // A, B assert_true(only_first.contains("A")) assert_true(only_first.contains("B")) } +///| test "venn_only_in_set_second" { - let result = @src.venn_diagram( - [["A", "B", "C", "D"], ["C", "D", "E", "F"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C", "D"], ["C", "D", "E", "F"]], names=[ + "S1", "S2", + ]) let only_second = @src.venn_only_in_set(result, 1) assert_eq(only_second.length(), 2) // E, F assert_true(only_second.contains("E")) assert_true(only_second.contains("F")) } +///| test "venn_only_in_set_three_sets" { let result = @src.venn_diagram( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -132,6 +136,8 @@ test "venn_only_in_set_three_sets" { } // 5. venn_intersection_only - elements in specific sets only + +///| test "venn_intersection_only_two_sets" { let result = @src.venn_diagram( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -142,6 +148,7 @@ test "venn_intersection_only_two_sets" { assert_true(s1_s2_only.contains("B")) } +///| test "venn_intersection_only_all_three" { let result = @src.venn_diagram( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -152,27 +159,29 @@ test "venn_intersection_only_all_three" { assert_true(all_three.contains("C")) } +///| test "venn_intersection_only_single_set" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["B", "C", "D"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["B", "C", "D"]], names=[ + "S1", "S2", + ]) let just_first = @src.venn_intersection_only(result, [0]) assert_eq(just_first.length(), 1) // A } // 6. venn_all_intersect - elements common to all sets + +///| test "venn_all_intersect_two_sets" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["B", "C", "D"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["B", "C", "D"]], names=[ + "S1", "S2", + ]) let all = @src.venn_all_intersect(result) assert_eq(all.length(), 2) // B, C assert_true(all.contains("B")) assert_true(all.contains("C")) } +///| test "venn_all_intersect_three_sets" { let result = @src.venn_diagram( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -183,21 +192,22 @@ test "venn_all_intersect_three_sets" { assert_true(all.contains("C")) } +///| test "venn_all_intersect_no_common" { - let result = @src.venn_diagram( - [["A", "B"], ["C", "D"], ["E", "F"]], - names=["S1", "S2", "S3"], - ) + let result = @src.venn_diagram([["A", "B"], ["C", "D"], ["E", "F"]], names=[ + "S1", "S2", "S3", + ]) let all = @src.venn_all_intersect(result) assert_eq(all.length(), 0) } // 7. venn_unique_to_each - unique elements per set + +///| test "venn_unique_to_each_two_sets" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["C", "D", "E"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["C", "D", "E"]], names=[ + "S1", "S2", + ]) let unique = @src.venn_unique_to_each(result) assert_eq(unique.length(), 2) assert_eq(unique[0].length(), 2) // A, B @@ -208,6 +218,7 @@ test "venn_unique_to_each_two_sets" { assert_true(unique[1].contains("E")) } +///| test "venn_unique_to_each_three_sets" { let result = @src.venn_diagram( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -221,11 +232,12 @@ test "venn_unique_to_each_three_sets" { } // 8. venn_pairwise_overlap - pairwise overlap statistics + +///| test "venn_pairwise_overlap_two_sets" { - let result = @src.venn_diagram( - [["A", "B", "C", "D"], ["C", "D", "E", "F"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C", "D"], ["C", "D", "E", "F"]], names=[ + "S1", "S2", + ]) let stats = @src.venn_pairwise_overlap(result, 0, 1) assert_eq(stats["intersection_count"], 2.0) // C, D assert_eq(stats["union_count"], 6.0) // A,B,C,D,E,F @@ -234,6 +246,7 @@ test "venn_pairwise_overlap_two_sets" { assert_eq(stats["set_j_size"], 4.0) } +///| test "venn_pairwise_overlap_three_sets" { let result = @src.venn_diagram( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -249,11 +262,11 @@ test "venn_pairwise_overlap_three_sets" { assert_eq(s23["intersection_count"], 2.0) // C, D } +///| test "venn_pairwise_overlap_identical_sets" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["A", "B", "C"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["A", "B", "C"]], names=[ + "S1", "S2", + ]) let stats = @src.venn_pairwise_overlap(result, 0, 1) assert_eq(stats["intersection_count"], 3.0) assert_eq(stats["union_count"], 3.0) @@ -262,11 +275,9 @@ test "venn_pairwise_overlap_identical_sets" { assert_eq(stats["dice_coefficient"], 1.0) } +///| test "venn_pairwise_overlap_disjoint" { - let result = @src.venn_diagram( - [["A", "B"], ["C", "D"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B"], ["C", "D"]], names=["S1", "S2"]) let stats = @src.venn_pairwise_overlap(result, 0, 1) assert_eq(stats["intersection_count"], 0.0) assert_eq(stats["jaccard_index"], 0.0) @@ -276,6 +287,8 @@ test "venn_pairwise_overlap_disjoint" { // 9. Set operations: venn_intersection, venn_union (venn_union_two), // venn_difference, venn_symmetric_difference + +///| test "venn_intersection_basic" { let a = ["A", "B", "C", "D"] let b = ["C", "D", "E", "F"] @@ -285,6 +298,7 @@ test "venn_intersection_basic" { assert_true(inter.contains("D")) } +///| test "venn_intersection_empty" { let a = ["A", "B"] let b = ["C", "D"] @@ -292,6 +306,7 @@ test "venn_intersection_empty" { assert_eq(inter.length(), 0) } +///| test "venn_union_two_basic" { let a = ["A", "B", "C"] let b = ["C", "D", "E"] @@ -304,6 +319,7 @@ test "venn_union_two_basic" { assert_true(uni.contains("E")) } +///| test "venn_union_two_disjoint" { let a = ["A", "B"] let b = ["C", "D"] @@ -311,6 +327,7 @@ test "venn_union_two_disjoint" { assert_eq(uni.length(), 4) } +///| test "venn_difference_basic" { let a = ["A", "B", "C", "D"] let b = ["C", "D", "E", "F"] @@ -320,6 +337,7 @@ test "venn_difference_basic" { assert_true(diff.contains("B")) } +///| test "venn_difference_no_difference" { let a = ["A", "B"] let b = ["A", "B", "C"] @@ -327,6 +345,7 @@ test "venn_difference_no_difference" { assert_eq(diff.length(), 0) } +///| test "venn_difference_full_difference" { let a = ["A", "B"] let b = ["C", "D"] @@ -336,6 +355,7 @@ test "venn_difference_full_difference" { assert_true(diff.contains("B")) } +///| test "venn_symmetric_difference_basic" { let a = ["A", "B", "C", "D"] let b = ["C", "D", "E", "F"] @@ -347,6 +367,7 @@ test "venn_symmetric_difference_basic" { assert_true(symdiff.contains("F")) } +///| test "venn_symmetric_difference_identical" { let a = ["A", "B", "C"] let b = ["A", "B", "C"] @@ -354,6 +375,7 @@ test "venn_symmetric_difference_identical" { assert_eq(symdiff.length(), 0) } +///| test "venn_symmetric_difference_disjoint" { let a = ["A", "B"] let b = ["C", "D"] @@ -362,6 +384,8 @@ test "venn_symmetric_difference_disjoint" { } // 10. venn_jaccard, venn_dice, venn_overlap_coefficient + +///| test "venn_jaccard_basic" { let a = ["A", "B", "C", "D"] let b = ["C", "D", "E", "F"] @@ -369,6 +393,7 @@ test "venn_jaccard_basic" { assert_eq(j, 2.0 / 6.0) } +///| test "venn_jaccard_identical" { let a = ["A", "B", "C"] let b = ["A", "B", "C"] @@ -376,6 +401,7 @@ test "venn_jaccard_identical" { assert_eq(j, 1.0) } +///| test "venn_jaccard_disjoint" { let a = ["A", "B"] let b = ["C", "D"] @@ -383,6 +409,7 @@ test "venn_jaccard_disjoint" { assert_eq(j, 0.0) } +///| test "venn_jaccard_empty" { let a : Array[String] = [] let b : Array[String] = [] @@ -390,13 +417,15 @@ test "venn_jaccard_empty" { assert_eq(j, 0.0) } +///| test "venn_dice_basic" { let a = ["A", "B", "C", "D"] let b = ["C", "D", "E", "F"] let d = @src.venn_dice(a, b) - assert_eq(d, (2.0 * 2.0) / 8.0) + assert_eq(d, 2.0 * 2.0 / 8.0) } +///| test "venn_dice_identical" { let a = ["A", "B", "C"] let b = ["A", "B", "C"] @@ -404,6 +433,7 @@ test "venn_dice_identical" { assert_eq(d, 1.0) } +///| test "venn_dice_disjoint" { let a = ["A", "B"] let b = ["C", "D"] @@ -411,6 +441,7 @@ test "venn_dice_disjoint" { assert_eq(d, 0.0) } +///| test "venn_dice_empty" { let a : Array[String] = [] let b : Array[String] = [] @@ -418,6 +449,7 @@ test "venn_dice_empty" { assert_eq(d, 0.0) } +///| test "venn_overlap_coefficient_basic" { let a = ["A", "B", "C", "D"] let b = ["C", "D", "E", "F"] @@ -425,6 +457,7 @@ test "venn_overlap_coefficient_basic" { assert_eq(oc, 2.0 / 4.0) // min(4,4)=4, inter=2 } +///| test "venn_overlap_coefficient_identical" { let a = ["A", "B", "C"] let b = ["A", "B", "C"] @@ -432,6 +465,7 @@ test "venn_overlap_coefficient_identical" { assert_eq(oc, 1.0) } +///| test "venn_overlap_coefficient_disjoint" { let a = ["A", "B"] let b = ["C", "D"] @@ -439,6 +473,7 @@ test "venn_overlap_coefficient_disjoint" { assert_eq(oc, 0.0) } +///| test "venn_overlap_coefficient_empty" { let a : Array[String] = [] let b = ["A", "B"] @@ -447,6 +482,8 @@ test "venn_overlap_coefficient_empty" { } // 11. venn_counts_only - count-only mode + +///| test "venn_counts_only_two_sets" { let counts = @src.venn_counts_only( [["A", "B", "C", "D"], ["C", "D", "E", "F"]], @@ -459,6 +496,7 @@ test "venn_counts_only_two_sets" { assert_eq(counts[0], 0) // outside } +///| test "venn_counts_only_three_sets" { let counts = @src.venn_counts_only( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -471,11 +509,11 @@ test "venn_counts_only_three_sets" { assert_eq(counts[2], 0) // only S2 } +///| test "venn_counts_only_no_overlap" { - let counts = @src.venn_counts_only( - [["A", "B"], ["C", "D"], ["E", "F"]], - names=["S1", "S2", "S3"], - ) + let counts = @src.venn_counts_only([["A", "B"], ["C", "D"], ["E", "F"]], names=[ + "S1", "S2", "S3", + ]) assert_eq(counts[1], 2) assert_eq(counts[2], 2) assert_eq(counts[4], 2) @@ -483,11 +521,12 @@ test "venn_counts_only_no_overlap" { } // 12. venn_summary - summary formatting + +///| test "venn_summary_basic" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["B", "C", "D"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["B", "C", "D"]], names=[ + "S1", "S2", + ]) let summary = @src.venn_summary(result) assert_true(summary.contains("Venn Diagram Summary")) assert_true(summary.contains("Number of sets: 2")) @@ -497,6 +536,7 @@ test "venn_summary_basic" { assert_true(summary.contains("Jaccard")) } +///| test "venn_summary_three_sets" { let result = @src.venn_diagram( [["A", "B", "C"], ["B", "C", "D"], ["C", "D", "E"]], @@ -509,6 +549,8 @@ test "venn_summary_three_sets" { } // 13. venn_sample_result - sample data generation + +///| test "venn_sample_result_basic" { let result = @src.venn_sample_result() assert_eq(result.n_sets, 3) @@ -517,6 +559,7 @@ test "venn_sample_result_basic" { assert_eq(result.set_names, ["Tumor Suppressors", "DNA Repair", "PI3K/MTOR"]) } +///| test "venn_sample_gene_sets_basic" { let sets = @src.venn_sample_gene_sets() assert_eq(sets.length(), 3) @@ -528,6 +571,7 @@ test "venn_sample_gene_sets_basic" { assert_true(sets[2].contains("MTOR")) } +///| test "venn_sample_gene_names_basic" { let names = @src.venn_sample_gene_names() assert_eq(names.length(), 3) @@ -537,6 +581,8 @@ test "venn_sample_gene_names_basic" { } // 14. venn_two_sets - two-set convenience function + +///| test "venn_two_sets_basic" { let result = @src.venn_two_sets(["A", "B", "C"], ["C", "D", "E"]) assert_eq(result.n_sets, 2) @@ -544,6 +590,7 @@ test "venn_two_sets_basic" { assert_eq(result.total_elements, 5) } +///| test "venn_two_sets_custom_names" { let result = @src.venn_two_sets( ["A", "B", "C"], @@ -555,21 +602,20 @@ test "venn_two_sets_custom_names" { assert_eq(result.n_sets, 2) } +///| test "venn_two_sets_intersection" { - let result = @src.venn_two_sets( - ["A", "B", "C", "D"], - ["C", "D", "E", "F"], - ) + let result = @src.venn_two_sets(["A", "B", "C", "D"], ["C", "D", "E", "F"]) let inter = @src.venn_all_intersect(result) assert_eq(inter.length(), 2) // C, D } // 15. venn_union (from result) - get universe + +///| test "venn_union_result_basic" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["C", "D", "E"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["C", "D", "E"]], names=[ + "S1", "S2", + ]) let uni = @src.venn_union(result) assert_eq(uni.length(), 5) assert_true(uni.contains("A")) @@ -580,6 +626,8 @@ test "venn_union_result_basic" { } // 16. Edge cases and integration tests + +///| test "venn_diagram_single_set" { let result = @src.venn_diagram([["A", "B", "C"]], names=["Only"]) assert_eq(result.n_sets, 1) @@ -589,50 +637,48 @@ test "venn_diagram_single_set" { assert_eq(result.regions[0].count, 0) } +///| test "venn_diagram_empty_sets" { let empty : Array[String] = [] - let result = @src.venn_diagram( - [empty, ["A", "B"]], - names=["Empty", "NonEmpty"], - ) + let result = @src.venn_diagram([empty, ["A", "B"]], names=[ + "Empty", "NonEmpty", + ]) assert_eq(result.n_sets, 2) assert_eq(result.set_sizes, [0, 2]) assert_eq(result.total_elements, 2) } +///| test "venn_diagram_duplicate_elements" { - let result = @src.venn_diagram( - [["A", "A", "B"], ["B", "C", "C"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "A", "B"], ["B", "C", "C"]], names=[ + "S1", "S2", + ]) assert_eq(result.total_elements, 3) // A, B, C - duplicates removed in universe } +///| test "venn_region_descriptions" { - let result = @src.venn_diagram( - [["A", "B", "C"], ["C", "D", "E"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C"], ["C", "D", "E"]], names=[ + "S1", "S2", + ]) assert_eq(result.regions[1].description, "Only in S1") assert_eq(result.regions[2].description, "Only in S2") assert_eq(result.regions[3].description, "In S1 & S2") assert_eq(result.regions[0].description, "Outside all sets") } +///| test "venn_euler_layout_basic" { - let result = @src.venn_diagram( - [["A", "B"], ["B", "C"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B"], ["B", "C"]], names=["S1", "S2"]) let layout = @src.venn_euler_layout(result) assert_true(layout.length() > 0) } +///| test "venn_pairwise_overlap_set_sizes" { - let result = @src.venn_diagram( - [["A", "B", "C", "D", "E"], ["C", "D"]], - names=["S1", "S2"], - ) + let result = @src.venn_diagram([["A", "B", "C", "D", "E"], ["C", "D"]], names=[ + "S1", "S2", + ]) let stats = @src.venn_pairwise_overlap(result, 0, 1) assert_eq(stats["set_i_size"], 5.0) assert_eq(stats["set_j_size"], 2.0) @@ -640,6 +686,7 @@ test "venn_pairwise_overlap_set_sizes" { assert_eq(stats["overlap_coefficient"], 2.0 / 2.0) // min(5,2)=2 } +///| test "venn_diagram_five_sets" { let result = @src.venn_diagram( [["A", "B"], ["B", "C"], ["C", "D"], ["D", "E"], ["E", "A"]], @@ -650,6 +697,7 @@ test "venn_diagram_five_sets" { assert_true(result.total_elements > 0) } +///| test "venn_all_intersect_sample_result" { let result = @src.venn_sample_result() let all = @src.venn_all_intersect(result) @@ -658,6 +706,7 @@ test "venn_all_intersect_sample_result" { assert_eq(all.length(), all2.length()) } +///| test "venn_unique_to_each_sample_result" { let result = @src.venn_sample_result() let unique = @src.venn_unique_to_each(result) @@ -665,15 +714,16 @@ test "venn_unique_to_each_sample_result" { assert_true(unique[0].length() > 0) } +///| test "venn_counts_only_matches_diagram" { let sets = [["A", "B", "C", "D"], ["C", "D", "E", "F"]] let names = ["S1", "S2"] - let result = @src.venn_diagram(sets, names=names) - let counts = @src.venn_counts_only(sets, names=names) + let result = @src.venn_diagram(sets, names~) + let counts = @src.venn_counts_only(sets, names~) assert_eq(counts.length(), result.regions.length()) let mut i = 0 while i < counts.length() { assert_eq(counts[i], result.regions[i].count) i = i + 1 } -} \ No newline at end of file +} diff --git a/test/moonbit/voyager_test.mbt b/test/moonbit/voyager_test.mbt new file mode 100644 index 00000000..9031da05 --- /dev/null +++ b/test/moonbit/voyager_test.mbt @@ -0,0 +1,1130 @@ +// Tests for the Bioconductor Voyager-inspired spatial autocorrelation module. + +///| +fn voy_test_close( + actual : Double, + expected : Double, + tolerance : Double, +) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "Voyager value " + + actual.to_string() + + " differs from " + + expected.to_string() + + " (tolerance " + + tolerance.to_string() + + ")", + ) + } +} + +///| +fn voy_test_grid_coords() -> Array[Array[Double]] { + // 3x3 grid of spots, coordinates [x, y]. + let coords : Array[Array[Double]] = [] + for row in 0..<3 { + for col in 0..<3 { + coords.push([col.to_double(), row.to_double()]) + } + } + coords +} + +///| +fn voy_test_chain_weights() -> @src.VoyagerWeights { + // 4 spots in a chain 0-1-2-3 with binary (style B) symmetric weights. + @src.VoyagerWeights::new( + [[1], [0, 2], [1, 3], [2]], + [[1.0], [1.0, 1.0], [1.0, 1.0], [1.0]], + style="B", + ) catch { + _ => abort("valid chain weights should build") + } +} + +///| +fn voy_test_gradient_values() -> Array[Double] { + // Values increasing with the x coordinate on the 3x3 grid: strong positive + // spatial autocorrelation. + [ + 0.0, 1.0, 2.0, // row 0 + 0.0, 1.0, 2.0, // row 1 + 0.0, 1.0, 2.0, // row 2 + ] +} + +///| +fn voy_test_checkerboard_values() -> Array[Double] { + // Alternating high/low: negative spatial autocorrelation on the grid. + [0.0, 9.0, 0.0, 9.0, 0.0, 9.0, 0.0, 9.0, 0.0] +} + +///| +fn voy_test_hotspot_values() -> Array[Double] { + // 3x3 grid with a hotspot in the centre. + [0.0, 0.0, 0.0, 0.0, 50.0, 0.0, 0.0, 0.0, 0.0] +} + +// =========================================================================== +// Weights construction +// =========================================================================== + +///| +test "Voyager weights kNN builds row-standardized neighbours" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + assert_eq(weights.n, 9) + assert_eq(weights.style, "W") + // Each spot on a 3x3 grid has 4 neighbours (corners: 2, edges: 3, centre: 4 + // are clamped to k=4 but corners/edges have fewer available neighbours). + assert_true(weights.neighbors[4].length() == 4) // centre + // Row-standardized: each row sums to 1. + for index in 0.. true + } + assert_true(failed) +} + +///| +test "Voyager weights kNN clamps k above n-1" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 100) catch { + _ => abort("kNN weights with large k should clamp") + } + // With k clamped to n-1, every spot links to all other spots. + assert_true(weights.neighbors[0].length() == 8) +} + +///| +test "Voyager weights distance band links immediate grid neighbours" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_distance_band(coords, 1.0) catch { + _ => abort("distance-band weights should build") + } + assert_eq(weights.n, 9) + // Centre spot (index 4) has 4 immediate neighbours at distance 1. + assert_eq(weights.neighbors[4].length(), 4) + // Corner spot (index 0) has 2 immediate neighbours. + assert_eq(weights.neighbors[0].length(), 2) +} + +///| +test "Voyager weights inverse distance produces positive finite weights" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_inverse_distance(coords, 1.0) catch { + _ => abort("inverse-distance weights should build") + } + assert_eq(weights.n, 9) + for index in 0.. 0.0) + assert_true(value <= 1.0e300) + } + } +} + +///| +test "Voyager weights style C sums to one globally" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4, style="C") catch { + _ => abort("style C weights should build") + } + let mut total = 0.0 + for index in 0.. abort("style B weights should build") + } + for index in 0.. true + } + assert_true(failed) +} + +// =========================================================================== +// Global Moran's I +// =========================================================================== + +///| +test "Voyager global Moran's I matches hand-computed chain example" { + let weights = voy_test_chain_weights() + let result = @src.voyager_global_morans_i([1.0, 1.0, 9.0, 9.0], weights) catch { + _ => abort("global Moran's I should run") + } + voy_test_close(result.estimate, 1.0 / 3.0, 1.0e-10) + voy_test_close(result.expectation, -1.0 / 3.0, 1.0e-12) + voy_test_close(result.s0, 6.0, 1.0e-12) + voy_test_close(result.s1, 12.0, 1.0e-12) + voy_test_close(result.s2, 40.0, 1.0e-12) + // b2 = 1, n = 4 -> variance = 88/216 - 1/9 = 0.296296... + voy_test_close(result.variance, 88.0 / 216.0 - 1.0 / 9.0, 1.0e-10) + assert_eq(result.n, 4) +} + +///| +test "Voyager global Moran's I is positive for a spatial gradient" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_global_morans_i(voy_test_gradient_values(), weights) catch { + _ => abort("global Moran's I should run") + } + assert_true(result.estimate > 0.0) + assert_true(result.p_value < 0.05) +} + +///| +test "Voyager global Moran's I is negative for a checkerboard" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_global_morans_i( + voy_test_checkerboard_values(), + weights, + ) catch { + _ => abort("global Moran's I should run") + } + assert_true(result.estimate < 0.0) +} + +///| +test "Voyager global Moran's I rejects non-finite values" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let failed = try { + ignore(@src.voyager_global_morans_i([1.0, 2.0, 1.0e400, 4.0], weights)) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +///| +test "Voyager global Moran's I rejects length mismatch" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let failed = try { + ignore(@src.voyager_global_morans_i([1.0, 2.0], weights)) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +// =========================================================================== +// Global Geary's c +// =========================================================================== + +///| +test "Voyager global Geary's c matches hand-computed chain example" { + let weights = voy_test_chain_weights() + let result = @src.voyager_global_gearys_c([1.0, 1.0, 9.0, 9.0], weights) catch { + _ => abort("global Geary's c should run") + } + voy_test_close(result.estimate, 0.5, 1.0e-10) + voy_test_close(result.expectation, 1.0, 1.0e-12) + assert_eq(result.n, 4) +} + +///| +test "Voyager global Geary's c is below one for a gradient" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_global_gearys_c(voy_test_gradient_values(), weights) catch { + _ => abort("global Geary's c should run") + } + assert_true(result.estimate < 1.0) +} + +///| +test "Voyager global Geary's c is above one for a checkerboard" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_global_gearys_c( + voy_test_checkerboard_values(), + weights, + ) catch { + _ => abort("global Geary's c should run") + } + assert_true(result.estimate > 1.0) +} + +// =========================================================================== +// Local Moran's I (LISA) +// =========================================================================== + +///| +test "Voyager local Moran's I returns one statistic per spot" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_local_morans_i( + voy_test_gradient_values(), + weights, + permutations=99, + seed=123, + ) catch { + _ => abort("local Moran's I should run") + } + assert_eq(result.n, 9) + assert_eq(result.local_i.length(), 9) + assert_eq(result.quadrants.length(), 9) + assert_eq(result.fdr.length(), 9) + assert_eq(result.permutations, 99) +} + +///| +test "Voyager local Moran's I permutation is deterministic for a fixed seed" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let first = @src.voyager_local_morans_i( + voy_test_gradient_values(), + weights, + permutations=50, + seed=777, + ) catch { + _ => abort("local Moran's I should run") + } + let second = @src.voyager_local_morans_i( + voy_test_gradient_values(), + weights, + permutations=50, + seed=777, + ) catch { + _ => abort("local Moran's I should run") + } + for index in 0.. abort("kNN weights should build") + } + let result = @src.voyager_local_morans_i( + voy_test_gradient_values(), + weights, + permutations=0, + ) catch { + _ => abort("local Moran's I should run") + } + for label in result.quadrants { + assert_true( + label == "HH" || + label == "LL" || + label == "HL" || + label == "LH" || + label == "not significant", + ) + } +} + +///| +test "Voyager local Moran's I BH-FDR is monotonic non-decreasing in rank" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_local_morans_i( + voy_test_gradient_values(), + weights, + permutations=99, + seed=42, + ) catch { + _ => abort("local Moran's I should run") + } + let indexed : Array[(Double, Int)] = [] + for index in 0.. Int { + if a.0 < b.0 { + -1 + } else if a.0 > b.0 { + 1 + } else { + 0 + } + }) + let mut previous = 0.0 + for entry in indexed { + let adjusted = result.fdr[entry.1] + assert_true(adjusted >= previous - 1.0e-12) + previous = adjusted + } +} + +///| +test "Voyager local Moran's I rejects zero-variance input" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let failed = try { + ignore( + @src.voyager_local_morans_i( + [5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0], + weights, + ), + ) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +// =========================================================================== +// Local Geary's c +// =========================================================================== + +///| +test "Voyager local Geary's c returns per-spot statistics and classifications" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_local_gearys_c( + voy_test_gradient_values(), + weights, + permutations=99, + seed=9, + ) catch { + _ => abort("local Geary's c should run") + } + assert_eq(result.n, 9) + assert_eq(result.local_c.length(), 9) + assert_eq(result.classifications.length(), 9) + for label in result.classifications { + assert_true( + label == "similar" || label == "dissimilar" || label == "not significant", + ) + } +} + +///| +test "Voyager local Geary's c is non-negative everywhere" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_local_gearys_c(voy_test_gradient_values(), weights) catch { + _ => abort("local Geary's c should run") + } + for value in result.local_c { + assert_true(value >= 0.0) + } +} + +// =========================================================================== +// Local Getis–Ord Gi / Gi* +// =========================================================================== + +///| +test "Voyager local Getis-Ord Gi* flags the centre of a hotspot" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_local_getis_ord( + voy_test_hotspot_values(), + weights, + star=true, + fdr_threshold=0.2, + ) catch { + _ => abort("Getis–Ord should run") + } + assert_eq(result.n, 9) + assert_eq(result.star, true) + // Centre spot (index 4) is the hotspot. + assert_true(result.z_scores[4] > 0.0) + assert_true(result.classifications[4] == "hotspot") +} + +///| +test "Voyager local Getis-Ord Gi excludes self from the weighted sum" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let gi = @src.voyager_local_getis_ord( + voy_test_hotspot_values(), + weights, + star=false, + ) catch { + _ => abort("Getis–Ord should run") + } + let gi_star = @src.voyager_local_getis_ord( + voy_test_hotspot_values(), + weights, + star=true, + ) catch { + _ => abort("Getis–Ord should run") + } + assert_eq(gi.star, false) + // The two statistics differ for the hotspot centre because Gi* includes self. + assert_true((gi.statistic[4] - gi_star.statistic[4]).abs() > 1.0e-9) +} + +///| +test "Voyager local Getis-Ord rejects negative values" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let failed = try { + ignore( + @src.voyager_local_getis_ord( + [-1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], + weights, + ), + ) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +///| +test "Voyager local Getis-Ord z-scores are finite" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_local_getis_ord( + voy_test_gradient_values(), + weights, + star=true, + ) catch { + _ => abort("Getis–Ord should run") + } + for value in result.z_scores { + assert_true(value == value) + assert_true(value.abs() <= 1.0e300) + } +} + +// =========================================================================== +// Lee's L +// =========================================================================== + +///| +test "Voyager Lee's L is positive for co-varying features" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_lees_l( + voy_test_gradient_values(), + voy_test_gradient_values(), + weights, + ) catch { + _ => abort("Lee's L should run") + } + assert_eq(result.n, 9) + // A feature with itself: Lee's L is positive and bounded by 1. + assert_true(result.global_l > 0.0) + assert_true(result.global_l <= 1.0 + 1.0e-9) +} + +///| +test "Voyager Lee's L is negative for anti-correlated features" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let anti : Array[Double] = [] + for value in voy_test_gradient_values() { + anti.push(10.0 - value) + } + let result = @src.voyager_lees_l(voy_test_gradient_values(), anti, weights) catch { + _ => abort("Lee's L should run") + } + assert_true(result.global_l < 0.0) +} + +///| +test "Voyager Lee's L local values length matches spot count" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_lees_l( + voy_test_gradient_values(), + voy_test_hotspot_values(), + weights, + permutations=49, + seed=5, + ) catch { + _ => abort("Lee's L should run") + } + assert_eq(result.local_l.length(), 9) + assert_eq(result.fdr.length(), 9) +} + +///| +test "Voyager Lee's L rejects unequal feature lengths" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let failed = try { + ignore( + @src.voyager_lees_l([1.0, 2.0, 3.0], voy_test_gradient_values(), weights), + ) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +// =========================================================================== +// Multivariate local Geary +// =========================================================================== + +///| +test "Voyager multivariate local Geary combines features into one statistic" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let matrix : Array[Array[Double]] = [ + voy_test_gradient_values(), + voy_test_hotspot_values(), + ] + let result = @src.voyager_multivariate_local_geary( + matrix, + weights, + permutations=49, + seed=3, + ) catch { + _ => abort("multivariate local Geary should run") + } + assert_eq(result.n, 9) + assert_eq(result.n_features, 2) + assert_eq(result.local_statistic.length(), 9) + assert_eq(result.classifications.length(), 9) + assert_eq(result.feature_set, ["feature1", "feature2"]) +} + +///| +test "Voyager multivariate local Geary uses supplied feature names" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let matrix : Array[Array[Double]] = [ + voy_test_gradient_values(), + voy_test_hotspot_values(), + ] + let result = @src.voyager_multivariate_local_geary(matrix, weights, feature_names=[ + "gradient", "hotspot", + ]) catch { + _ => abort("multivariate local Geary should run") + } + assert_eq(result.feature_set, ["gradient", "hotspot"]) +} + +///| +test "Voyager multivariate local Geary is non-negative" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let matrix : Array[Array[Double]] = [voy_test_gradient_values()] + let result = @src.voyager_multivariate_local_geary(matrix, weights) catch { + _ => abort("multivariate local Geary should run") + } + for value in result.local_statistic { + assert_true(value >= 0.0) + } +} + +// =========================================================================== +// Empirical variogram and model fitting +// =========================================================================== + +///| +test "Voyager empirical variogram bins pairs and computes semivariance" { + let coords = voy_test_grid_coords() + let empirical = @src.voyager_empirical_variogram( + coords, + voy_test_gradient_values(), + n_lags=5, + ) catch { + _ => abort("empirical variogram should run") + } + assert_true(empirical.length() >= 2) + for point in empirical { + assert_true(point.npairs > 0) + assert_true(point.gamma >= 0.0) + assert_true(point.lag > 0.0) + } +} + +///| +test "Voyager variogram fit recovers a positive range and bounded SSE" { + let coords = voy_test_grid_coords() + let empirical = @src.voyager_empirical_variogram( + coords, + voy_test_gradient_values(), + n_lags=8, + ) catch { + _ => abort("empirical variogram should run") + } + let model = @src.voyager_fit_variogram(empirical, model_type="spherical") catch { + _ => abort("spherical fit should run") + } + assert_eq(model.model_type, "spherical") + assert_true(model.range > 0.0) + assert_true(model.sill >= 0.0) + assert_true(model.nugget >= 0.0) + assert_true(model.fitted_sse >= 0.0) +} + +///| +test "Voyager variogram predict increases with distance up to the range" { + let coords = voy_test_grid_coords() + let empirical = @src.voyager_empirical_variogram( + coords, + voy_test_gradient_values(), + n_lags=6, + ) catch { + _ => abort("empirical variogram should run") + } + let model = @src.voyager_fit_variogram(empirical, model_type="exponential") catch { + _ => abort("exponential fit should run") + } + let small = @src.voyager_variogram_predict(model, 0.01) + let large = @src.voyager_variogram_predict(model, model.range * 3.0) + assert_true(large >= small) +} + +///| +test "Voyager variogram fit supports gaussian model" { + let coords = voy_test_grid_coords() + let empirical = @src.voyager_empirical_variogram( + coords, + voy_test_gradient_values(), + n_lags=6, + ) catch { + _ => abort("empirical variogram should run") + } + let model = @src.voyager_fit_variogram(empirical, model_type="gaussian") catch { + _ => abort("gaussian fit should run") + } + assert_eq(model.model_type, "gaussian") +} + +///| +test "Voyager variogram fit rejects an unknown model type" { + let coords = voy_test_grid_coords() + let empirical = @src.voyager_empirical_variogram( + coords, + voy_test_gradient_values(), + n_lags=4, + ) catch { + _ => abort("empirical variogram should run") + } + let failed = try { + ignore(@src.voyager_fit_variogram(empirical, model_type="cubic")) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +///| +test "Voyager variogram fit respects a fixed nugget" { + let coords = voy_test_grid_coords() + let empirical = @src.voyager_empirical_variogram( + coords, + voy_test_gradient_values(), + n_lags=6, + ) catch { + _ => abort("empirical variogram should run") + } + let model = @src.voyager_fit_variogram( + empirical, + model_type="spherical", + nugget=0.25, + fix_nugget=true, + ) catch { + _ => abort("fixed-nugget fit should run") + } + voy_test_close(model.nugget, 0.25, 1.0e-12) +} + +// =========================================================================== +// Correlogram +// =========================================================================== + +///| +test "Voyager correlogram returns one point per non-empty lag" { + let coords = voy_test_grid_coords() + let points = @src.voyager_correlogram( + coords, + voy_test_gradient_values(), + n_lags=4, + ) catch { + _ => abort("correlogram should run") + } + // Empty distance bins are skipped; every returned point has observed pairs. + assert_true(points.length() >= 1) + assert_true(points.length() <= 4) + let mut previous_lag = -1.0 + for point in points { + assert_true(point.npairs > 0) + assert_true(point.lag > previous_lag) + previous_lag = point.lag + voy_test_close(point.expectation, -1.0 / 8.0, 1.0e-12) + } +} + +///| +test "Voyager correlogram gradient shows positive Moran at short lags" { + let coords = voy_test_grid_coords() + let points = @src.voyager_correlogram( + coords, + voy_test_gradient_values(), + n_lags=3, + ) catch { + _ => abort("correlogram should run") + } + assert_true(points[0].morans_i > 0.0) +} + +// =========================================================================== +// SpatialExperiment integration +// =========================================================================== + +///| +test "Voyager example SpatialExperiment has the expected shape" { + let se = @src.voyager_example_spatial_experiment() + assert_eq(se.col_data.length(), 36) + assert_eq(se.spatial_coords.length(), 36) + let assay = se.assay["logcounts"] + assert_eq(assay.length(), 4) + assert_eq(assay[0].length(), 36) +} + +///| +test "Voyager univariate SFE Moran writes back local results without mutating input" { + let se = @src.voyager_example_spatial_experiment() + let original_keys = se.col_data[0].keys().length() + let output = @src.voyager_run_univariate_sfe( + se, + [0], + assay_name="logcounts", + stat_method="moran", + permutations=19, + seed=2024, + output_prefix="voy", + ) catch { + _ => abort("Voyager SFE Moran integration should run") + } + // Input SpatialExperiment unchanged. + assert_eq(se.col_data[0].keys().length(), original_keys) + assert_true(!se.col_data[0].contains("voy.moran.local.gene_gradient")) + // Output SpatialExperiment carries the write-back. + assert_true( + output.experiment.col_data[0].contains("voy.moran.local.gene_gradient"), + ) + assert_true( + output.experiment.row_data[0].contains("voy.moran.I.gene_gradient"), + ) + assert_eq(output.results.length(), 1) + assert_eq(output.results[0].stat_method, "moran") + assert_eq(output.weights.n, 36) +} + +///| +test "Voyager univariate SFE Geary writes classification column" { + let se = @src.voyager_example_spatial_experiment() + let output = @src.voyager_run_univariate_sfe( + se, + [0, 1], + assay_name="logcounts", + stat_method="geary", + permutations=19, + seed=7, + output_prefix="vg", + ) catch { + _ => abort("Voyager SFE Geary integration should run") + } + assert_eq(output.results.length(), 2) + assert_true( + output.experiment.col_data[0].contains("vg.geary.class.gene_gradient"), + ) + assert_true(output.experiment.row_data[1].contains("vg.geary.C.gene_hotspot")) +} + +///| +test "Voyager univariate SFE Getis writes hotspot classification" { + let se = @src.voyager_example_spatial_experiment() + let output = @src.voyager_run_univariate_sfe( + se, + [1], + assay_name="logcounts", + stat_method="getis", + output_prefix="g", + ) catch { + _ => abort("Voyager SFE Getis integration should run") + } + assert_eq(output.results.length(), 1) + assert_eq(output.results[0].stat_method, "getis") + assert_true( + output.experiment.col_data[0].contains("g.getis.class.gene_hotspot"), + ) + assert_true(output.experiment.col_data[0].contains("g.getis.z.gene_hotspot")) +} + +///| +test "Voyager univariate SFE can use a distance-band bandwidth" { + let se = @src.voyager_example_spatial_experiment() + let output = @src.voyager_run_univariate_sfe( + se, + [0], + assay_name="logcounts", + stat_method="moran", + bandwidth=1.0, + output_prefix="db", + ) catch { + _ => abort("Voyager SFE distance-band integration should run") + } + assert_eq(output.weights.n, 36) + // Distance band of 1.0 on a unit grid links only orthogonal immediate + // neighbours (excluding diagonals at sqrt(2)), so centre spots have 4. + let mut has_four = false + for index in 0.. true + } + assert_true(failed) +} + +///| +test "Voyager univariate SFE rejects an unknown method" { + let se = @src.voyager_example_spatial_experiment() + let failed = try { + ignore( + @src.voyager_run_univariate_sfe( + se, + [0], + assay_name="logcounts", + stat_method="unknown", + ), + ) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +///| +test "Voyager univariate SFE rejects a missing assay" { + let se = @src.voyager_example_spatial_experiment() + let failed = try { + ignore(@src.voyager_run_univariate_sfe(se, [0], assay_name="counts")) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +///| +test "Voyager univariate SFE metadata records method and feature count" { + let se = @src.voyager_example_spatial_experiment() + let output = @src.voyager_run_univariate_sfe( + se, + [0, 1, 2], + assay_name="logcounts", + stat_method="moran", + output_prefix="meta", + ) catch { + _ => abort("Voyager SFE integration should run") + } + assert_eq(output.experiment.metadata["meta.method"], "moran") + assert_eq(output.experiment.metadata["meta.n_features"], "3") + assert_eq(output.experiment.metadata["meta.weights_style"], "W") +} + +// =========================================================================== +// Determinism and edge cases +// =========================================================================== + +///| +test "Voyager PRNG produces reproducible shuffles for the same seed" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let a = @src.voyager_local_morans_i( + voy_test_gradient_values(), + weights, + permutations=30, + seed=20240501, + ) catch { + _ => abort("local Moran's I should run") + } + let b = @src.voyager_local_morans_i( + voy_test_gradient_values(), + weights, + permutations=30, + seed=20240501, + ) catch { + _ => abort("local Moran's I should run") + } + voy_test_close(a.p_values[0], b.p_values[0], 0.0) + voy_test_close(a.z_scores[4], b.z_scores[4], 0.0) +} + +///| +test "Voyager global Moran's I expectation equals negative one over n minus one" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_global_morans_i(voy_test_gradient_values(), weights) catch { + _ => abort("global Moran's I should run") + } + voy_test_close(result.expectation, -1.0 / 8.0, 1.0e-12) +} + +///| +test "Voyager weights distance band rejects non-positive bandwidth" { + let coords = voy_test_grid_coords() + let failed = try { + ignore(@src.voyager_weights_distance_band(coords, 0.0)) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +///| +test "Voyager weights inverse distance rejects non-positive power" { + let coords = voy_test_grid_coords() + let failed = try { + ignore(@src.voyager_weights_inverse_distance(coords, 0.0)) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +///| +test "Voyager empirical variogram rejects coincident coordinates" { + let coords : Array[Array[Double]] = [[0.0, 0.0], [0.0, 0.0], [0.0, 0.0]] + let failed = try { + ignore(@src.voyager_empirical_variogram(coords, [1.0, 2.0, 3.0])) + false + } catch { + VoyagerError(_) => true + } + assert_true(failed) +} + +///| +test "Voyager local Getis-Ord FDR is bounded in [0, 1]" { + let coords = voy_test_grid_coords() + let weights = @src.voyager_weights_knn(coords, 4) catch { + _ => abort("kNN weights should build") + } + let result = @src.voyager_local_getis_ord( + voy_test_hotspot_values(), + weights, + star=true, + ) catch { + _ => abort("Getis–Ord should run") + } + for value in result.fdr { + assert_true(value >= 0.0 && value <= 1.0) + } +} diff --git a/test/moonbit/vsn_test.mbt b/test/moonbit/vsn_test.mbt index e10610d6..d22d5499 100644 --- a/test/moonbit/vsn_test.mbt +++ b/test/moonbit/vsn_test.mbt @@ -42,11 +42,7 @@ test "vsn_control_new" { ///| test "vsn2_basic" { - let data = [ - [100.0, 200.0], - [150.0, 180.0], - [90.0, 210.0], - ] + let data = [[100.0, 200.0], [150.0, 180.0], [90.0, 210.0]] let result = @src.vsn2(data) assert_eq(result.length(), 3) assert_eq(result[0].length(), 2) @@ -54,11 +50,7 @@ test "vsn2_basic" { ///| test "vsn2_with_control_runs" { - let data = [ - [100.0, 200.0], - [150.0, 180.0], - [90.0, 210.0], - ] + let data = [[100.0, 200.0], [150.0, 180.0], [90.0, 210.0]] let ctrl = @src.VSNControl::new() let result = @src.vsn2_with_control(data, ctrl) assert_eq(result.length(), 3) @@ -67,11 +59,7 @@ test "vsn2_with_control_runs" { ///| test "vsn_fit_and_report_returns_vsnresult" { - let data = [ - [100.0, 200.0], - [150.0, 180.0], - [90.0, 210.0], - ] + let data = [[100.0, 200.0], [150.0, 180.0], [90.0, 210.0]] let fit = @src.vsn_fit_and_report(data) assert_eq(fit.params.length(), 2) let summary = @src.summarize_vsn_fit(fit) @@ -100,11 +88,7 @@ test "mean_sd_bins_and_ascii" { ///| test "vsn_denoise_keeps_shape" { - let data = [ - [100.0, 200.0], - [150.0, 180.0], - [90.0, 210.0], - ] + let data = [[100.0, 200.0], [150.0, 180.0], [90.0, 210.0]] let denoised = @src.vsn_denoise(data) assert_eq(denoised.length(), 3) assert_eq(denoised[0].length(), 2) diff --git a/test/moonbit/wise_test.mbt b/test/moonbit/wise_test.mbt index cdf77081..8d42b807 100644 --- a/test/moonbit/wise_test.mbt +++ b/test/moonbit/wise_test.mbt @@ -10,31 +10,37 @@ test "wise_block_type_to_string_exon" { assert_eq(bt.to_string(), "exon") } +///| test "wise_block_type_to_string_intron" { let bt = @src.wise_make_block_type("intron") assert_eq(bt.to_string(), "intron") } +///| test "wise_block_type_to_string_match" { let bt = @src.wise_make_block_type("match") assert_eq(bt.to_string(), "match") } +///| test "wise_block_type_to_string_mismatch" { let bt = @src.wise_make_block_type("mismatch") assert_eq(bt.to_string(), "mismatch") } +///| test "wise_block_type_to_string_insertion" { let bt = @src.wise_make_block_type("insertion") assert_eq(bt.to_string(), "insertion") } +///| test "wise_block_type_to_string_deletion" { let bt = @src.wise_make_block_type("deletion") assert_eq(bt.to_string(), "deletion") } +///| test "wise_block_type_eq_via_is_pattern" { // Enum variants can be compared using `is` pattern matching. let bt = @src.wise_make_block_type("exon") @@ -46,6 +52,7 @@ test "wise_block_type_eq_via_is_pattern" { // WiseExon // --------------------------------------------------------------------------- +///| test "wise_exon_new_defaults" { let e = @src.WiseExon::new() assert_eq(e.start, 0) @@ -57,6 +64,7 @@ test "wise_exon_new_defaults" { assert_eq(e.protein_end, 0) } +///| test "wise_exon_new_with_params" { let e = @src.WiseExon::new( start=100, @@ -76,11 +84,13 @@ test "wise_exon_new_with_params" { assert_eq(e.protein_end, 33) } +///| test "wise_exon_length" { let e = @src.WiseExon::new(start=0, end=99) assert_eq(e.length(), 100) } +///| test "wise_exon_length_single_base" { let e = @src.WiseExon::new(start=50, end=50) assert_eq(e.length(), 1) @@ -90,6 +100,7 @@ test "wise_exon_length_single_base" { // WiseIntron // --------------------------------------------------------------------------- +///| test "wise_intron_new_defaults" { let i = @src.WiseIntron::new() assert_eq(i.start, 0) @@ -100,6 +111,7 @@ test "wise_intron_new_defaults" { assert_eq(i.length, 1) } +///| test "wise_intron_new_with_params" { let i = @src.WiseIntron::new( start=100, @@ -115,11 +127,13 @@ test "wise_intron_new_with_params" { assert_eq(i.length, 100) } +///| test "wise_intron_length_auto_calc_normal" { let i = @src.WiseIntron::new(start=200, end=299) assert_eq(i.length, 100) } +///| test "wise_intron_length_auto_calc_end_before_start" { // When end < start, length should be 0 let i = @src.WiseIntron::new(start=300, end=100) @@ -130,6 +144,7 @@ test "wise_intron_length_auto_calc_end_before_start" { // WiseAlignmentColumn // --------------------------------------------------------------------------- +///| test "wise_alignment_column_new" { let c = @src.WiseAlignmentColumn::new( protein_char='M', @@ -145,11 +160,9 @@ test "wise_alignment_column_new" { assert_eq(c.protein_position, 0) } +///| test "wise_alignment_column_new_default_match_type" { - let c = @src.WiseAlignmentColumn::new( - protein_char='X', - gene_codon="TAG", - ) + let c = @src.WiseAlignmentColumn::new(protein_char='X', gene_codon="TAG") assert_eq(c.protein_char, 'X') assert_eq(c.gene_codon, "TAG") // Default match_type is " " @@ -162,6 +175,7 @@ test "wise_alignment_column_new_default_match_type" { // WiseResult construction and basic accessors // --------------------------------------------------------------------------- +///| test "wise_result_new_empty" { let r = @src.WiseResult::new() assert_eq(r.protein_id, "") @@ -173,6 +187,7 @@ test "wise_result_new_empty" { assert_eq(r.get_total_exon_length(), 0) } +///| test "wise_result_add_and_get_exons" { let r = @src.WiseResult::new() let e1 = @src.WiseExon::new(start=0, end=99) @@ -185,6 +200,7 @@ test "wise_result_add_and_get_exons" { assert_eq(exons[1].start, 200) } +///| test "wise_result_add_and_get_introns" { let r = @src.WiseResult::new() let i1 = @src.WiseIntron::new(start=100, end=199) @@ -195,6 +211,7 @@ test "wise_result_add_and_get_introns" { assert_eq(introns[0].end, 199) } +///| test "wise_result_get_num_exons" { let r = @src.WiseResult::new() assert_eq(r.get_num_exons(), 0) @@ -205,6 +222,7 @@ test "wise_result_get_num_exons" { assert_eq(r.get_num_exons(), 3) } +///| test "wise_result_get_num_introns" { let r = @src.WiseResult::new() assert_eq(r.get_num_introns(), 0) @@ -214,6 +232,7 @@ test "wise_result_get_num_introns" { assert_eq(r.get_num_introns(), 2) } +///| test "wise_result_get_total_exon_length" { let r = @src.WiseResult::new() // Exon 1: 0-99 -> length 100 @@ -225,41 +244,44 @@ test "wise_result_get_total_exon_length" { assert_eq(r.get_total_exon_length(), 280) } +///| test "wise_result_get_total_exon_length_empty" { let r = @src.WiseResult::new() assert_eq(r.get_total_exon_length(), 0) } +///| test "wise_result_set_protein_id" { let r = @src.WiseResult::new() r.set_protein_id("P12345") assert_eq(r.protein_id, "P12345") } +///| test "wise_result_set_gene_id" { let r = @src.WiseResult::new() r.set_gene_id("G67890") assert_eq(r.gene_id, "G67890") } +///| test "wise_result_set_score" { let r = @src.WiseResult::new() r.set_score(145.32) assert_eq(r.score, 145.32) } +///| test "wise_result_set_bits_score" { let r = @src.WiseResult::new() r.set_bits_score(52.18) assert_eq(r.bits_score, 52.18) } +///| test "wise_result_add_alignment_column" { let r = @src.WiseResult::new() - let c = @src.WiseAlignmentColumn::new( - protein_char='M', - gene_codon="ATG", - ) + let c = @src.WiseAlignmentColumn::new(protein_char='M', gene_codon="ATG") r.add_alignment_column(c) let aln = r.get_alignment() assert_eq(aln.length(), 1) @@ -270,27 +292,32 @@ test "wise_result_add_alignment_column" { // wise_parse // --------------------------------------------------------------------------- +///| test "wise_parse_protein_id" { let r = @src.wise_parse("Protein: P12345\n") assert_eq(r.protein_id, "P12345") } +///| test "wise_parse_gene_id" { let r = @src.wise_parse("Gene: G67890\n") assert_eq(r.gene_id, "G67890") } +///| test "wise_parse_score" { let r = @src.wise_parse("Score: 145.32\n") // Use tolerance for floating-point comparison (parse_double precision) assert_true(r.score > 145.31 && r.score < 145.33) } +///| test "wise_parse_bits_score" { let r = @src.wise_parse("Bits: 52.18\n") assert_eq(r.bits_score, 52.18) } +///| test "wise_parse_exons" { let r = @src.wise_parse( "Exon 1: 0-99 (phase 0) score 45.5 protein 1-33\nExon 2: 200-299 (phase 0) score 52.3 protein 34-66\n", @@ -308,6 +335,7 @@ test "wise_parse_exons" { assert_eq(exons[1].score, 52.3) } +///| test "wise_parse_introns" { let r = @src.wise_parse( "Intron 1: 100-199 donor 12.5 acceptor 8.3\nIntron 2: 300-399 donor 10.2 acceptor 9.1\n", @@ -325,6 +353,7 @@ test "wise_parse_introns" { assert_eq(introns[1].acceptor_score, 9.1) } +///| test "wise_parse_empty_input" { let r = @src.wise_parse("") assert_eq(r.protein_id, "") @@ -335,6 +364,7 @@ test "wise_parse_empty_input" { assert_eq(r.get_num_introns(), 0) } +///| test "wise_parse_full_sample" { let r = @src.wise_parse(@src.wise_sample_output()) assert_eq(r.protein_id, "P12345") @@ -351,6 +381,7 @@ test "wise_parse_full_sample" { // Sample data // --------------------------------------------------------------------------- +///| test "wise_sample_output_content" { let s = @src.wise_sample_output() assert_true(s.contains("Protein: P12345")) @@ -361,6 +392,7 @@ test "wise_sample_output_content" { assert_true(s.contains("Intron 1: 100-199")) } +///| test "wise_sample_result" { let r = @src.wise_sample() assert_eq(r.protein_id, "P12345") @@ -373,6 +405,7 @@ test "wise_sample_result" { // wise_write // --------------------------------------------------------------------------- +///| test "wise_write_basic" { let r = @src.WiseResult::new() r.set_protein_id("P12345") @@ -387,12 +420,29 @@ test "wise_write_basic" { assert_true(s.contains("Bits: 52.18")) } +///| test "wise_write_with_exons_and_introns" { let r = @src.WiseResult::new() r.set_protein_id("P1") r.set_gene_id("G1") - r.add_exon(@src.WiseExon::new(start=0, end=99, phase=0, score=45.5, protein_start=1, protein_end=33)) - r.add_intron(@src.WiseIntron::new(start=100, end=199, donor_score=12.5, acceptor_score=8.3)) + r.add_exon( + @src.WiseExon::new( + start=0, + end=99, + phase=0, + score=45.5, + protein_start=1, + protein_end=33, + ), + ) + r.add_intron( + @src.WiseIntron::new( + start=100, + end=199, + donor_score=12.5, + acceptor_score=8.3, + ), + ) let s = @src.wise_write(r) assert_true(s.contains("Exon 1: 0-99")) assert_true(s.contains("(phase 0)")) @@ -403,6 +453,7 @@ test "wise_write_with_exons_and_introns" { assert_true(s.contains("acceptor 8.3")) } +///| test "wise_write_roundtrip" { // Parse sample, write it back, verify key fields are present let r = @src.wise_sample() @@ -420,6 +471,7 @@ test "wise_write_roundtrip" { // wise_gene_structure // --------------------------------------------------------------------------- +///| test "wise_gene_structure_basic" { let r = @src.WiseResult::new() r.add_exon(@src.WiseExon::new(start=0, end=99, phase=0)) @@ -433,6 +485,7 @@ test "wise_gene_structure_basic" { assert_true(s.contains("Intron 1: 100-199")) } +///| test "wise_gene_structure_empty" { let r = @src.WiseResult::new() let s = @src.wise_gene_structure(r) @@ -440,6 +493,7 @@ test "wise_gene_structure_empty" { assert_eq(s.length(), 0) } +///| test "wise_gene_structure_sample" { let r = @src.wise_sample() let s = @src.wise_gene_structure(r) @@ -455,6 +509,7 @@ test "wise_gene_structure_sample" { // wise_translate_gene // --------------------------------------------------------------------------- +///| test "wise_translate_gene_single_exon" { // Exon 0-8 (9 nt) -> ATG GCC GGT -> M A G let r = @src.WiseResult::new() @@ -464,6 +519,7 @@ test "wise_translate_gene_single_exon" { assert_eq(protein, "MAG") } +///| test "wise_translate_gene_multiple_codons" { // Exon 0-11 (12 nt) -> ATG GCC GGT AAA -> M A G K let r = @src.WiseResult::new() @@ -473,6 +529,7 @@ test "wise_translate_gene_multiple_codons" { assert_eq(protein, "MAGK") } +///| test "wise_translate_gene_stop_codon" { // Exon 0-8 -> ATG TAA TAG -> M * * let r = @src.WiseResult::new() @@ -489,6 +546,7 @@ test "wise_translate_gene_stop_codon" { // wise_percent_identity // --------------------------------------------------------------------------- +///| test "wise_percent_identity_full" { // Translation matches protein exactly -> 100.0% let r = @src.WiseResult::new() @@ -499,6 +557,7 @@ test "wise_percent_identity_full" { assert_eq(pct, 100.0) } +///| test "wise_percent_identity_none" { // Translation does not match protein -> 0.0% let r = @src.WiseResult::new() @@ -509,6 +568,7 @@ test "wise_percent_identity_none" { assert_eq(pct, 0.0) } +///| test "wise_percent_identity_partial" { // Translation: MAG, protein: MAP -> 2/3 match -> ~66.67% let r = @src.WiseResult::new() @@ -519,6 +579,7 @@ test "wise_percent_identity_partial" { assert_true(pct > 66.0 && pct < 67.0) } +///| test "wise_percent_identity_empty_protein" { let r = @src.WiseResult::new() r.add_exon(@src.WiseExon::new(start=0, end=8)) @@ -531,6 +592,7 @@ test "wise_percent_identity_empty_protein" { // wise_summary // --------------------------------------------------------------------------- +///| test "wise_summary_basic" { let r = @src.wise_sample() let s = @src.wise_summary(r) @@ -544,6 +606,7 @@ test "wise_summary_basic" { assert_true(s.contains("Total exon length: 280 nt")) } +///| test "wise_summary_empty" { let r = @src.WiseResult::new() let s = @src.wise_summary(r) @@ -557,6 +620,7 @@ test "wise_summary_empty" { // GenomeWiseSegment // --------------------------------------------------------------------------- +///| test "genome_wise_segment_new_defaults" { let s = @src.GenomeWiseSegment::new() assert_eq(s.segment_id, "") @@ -567,6 +631,7 @@ test "genome_wise_segment_new_defaults" { assert_eq(s.wise_result.get_num_exons(), 0) } +///| test "genome_wise_segment_new_with_params" { let s = @src.GenomeWiseSegment::new( segment_id="seg1", @@ -584,6 +649,7 @@ test "genome_wise_segment_new_with_params" { // GenomeWiseResult // --------------------------------------------------------------------------- +///| test "genome_wise_result_new_empty" { let r = @src.GenomeWiseResult::new() assert_eq(r.gene_id, "") @@ -591,6 +657,7 @@ test "genome_wise_result_new_empty" { assert_eq(r.get_num_segments(), 0) } +///| test "genome_wise_result_add_and_get_segments" { let r = @src.GenomeWiseResult::new() let s1 = @src.GenomeWiseSegment::new(segment_id="seg1", start=100, end=200) @@ -603,6 +670,7 @@ test "genome_wise_result_add_and_get_segments" { assert_eq(segs[1].segment_id, "seg2") } +///| test "genome_wise_result_get_num_segments" { let r = @src.GenomeWiseResult::new() assert_eq(r.get_num_segments(), 0) diff --git a/test/moonbit/xcell_test.mbt b/test/moonbit/xcell_test.mbt index 5773ec1a..e2d160ba 100644 --- a/test/moonbit/xcell_test.mbt +++ b/test/moonbit/xcell_test.mbt @@ -8,17 +8,16 @@ // ============================================================================ test "xc_signature_new_basic" { - let sig = @src.XcellSignature::new( - "CD8+ T cells", - "immune", - ["CD8A", "CD8B", "GZMA", "GZMB"], - ) + let sig = @src.XcellSignature::new("CD8+ T cells", "immune", [ + "CD8A", "CD8B", "GZMA", "GZMB", + ]) assert_eq(sig.cell_type(), "CD8+ T cells") assert_eq(sig.category(), "immune") assert_eq(sig.genes().length(), 4) assert_eq(sig.genes()[0], "CD8A") } +///| test "xc_default_signatures_count_and_categories" { let sigs = @src.xcell_default_signatures() // Should have 63 signatures @@ -42,6 +41,7 @@ test "xc_default_signatures_count_and_categories" { assert_true(other_count >= 8) } +///| test "xc_default_signatures_each_has_genes" { let sigs = @src.xcell_default_signatures() for s in sigs { @@ -54,6 +54,7 @@ test "xc_default_signatures_each_has_genes" { // Parameters // ============================================================================ +///| test "xc_params_default" { let p = @src.XcellParams::new() assert_eq(p.min_gene_overlap, 3) @@ -67,6 +68,7 @@ test "xc_params_default" { // ssGSEA single-sample scoring // ============================================================================ +///| test "xc_ssgsea_single_basic" { let expr = [10.0, 5.0, 20.0, 3.0, 15.0] let genes = ["A", "B", "C", "D", "E"] @@ -77,6 +79,7 @@ test "xc_ssgsea_single_basic" { assert_true(score >= -1.0 && score <= 1.0) } +///| test "xc_ssgsea_single_high_enrichment" { // Expression sorted: A=100, B=90, C=80, D=10, E=5 (high A,B,C top ranking) // Gene set = [A,B,C] are all top -> high positive enrichment @@ -90,6 +93,7 @@ test "xc_ssgsea_single_high_enrichment" { assert_true(score_high > score_low) } +///| test "xc_ssgsea_single_empty" { let s = @src.xcell_ssgsea_single([], [], ["A"], alpha=0.25) assert_eq(s, 0.0) @@ -97,6 +101,7 @@ test "xc_ssgsea_single_empty" { assert_eq(s2, 0.0) } +///| test "xc_ssgsea_single_min_overlap" { // Only 1 gene overlap, should return 0 when we need min 3 (but function returns 0 for <3) let expr = [1.0, 2.0] @@ -110,11 +115,9 @@ test "xc_ssgsea_single_min_overlap" { // Full xCell pipeline // ============================================================================ +///| test "xc_result_creation" { - let scores : Array[Array[Double]] = [ - [0.5, 0.8], - [0.2, 0.1], - ] + let scores : Array[Array[Double]] = [[0.5, 0.8], [0.2, 0.1]] let cts = ["T cells", "B cells"] let cats = ["immune", "immune"] let samps = ["s1", "s2"] @@ -122,40 +125,39 @@ test "xc_result_creation" { let str = [0.1, 0.15] let menv = [0.45, 0.6] let p = @src.XcellParams::new() - let r = @src.XcellResult::new( - scores, cts, cats, samps, imm, str, menv, p, - ) + let r = @src.XcellResult::new(scores, cts, cats, samps, imm, str, menv, p) assert_eq(r.cell_types.length(), 2) assert_eq(r.sample_names.length(), 2) assert_true((r.immune_scores[0] - 0.35).abs() < 0.0001) assert_true((r.microenvironment_scores[1] - 0.6).abs() < 0.0001) } +///| test "xc_run_default_simple" { // Simple expression matrix with a handful of marker genes let gene_names = [ - "CD3D", "CD3E", "CD8A", "CD8B", "GZMA", "GZMB", "PRF1", "NKG7", - "CD19", "MS4A1", "CD79A", "PECAM1", "VWF", "COL1A1", "FAP", "ALB", + "CD3D", "CD3E", "CD8A", "CD8B", "GZMA", "GZMB", "PRF1", "NKG7", "CD19", "MS4A1", + "CD79A", "PECAM1", "VWF", "COL1A1", "FAP", "ALB", ] let sample_names = ["Tumor1", "Tumor2", "Normal1"] // 16 genes x 3 samples: upregulate immune in Normal1, stromal in Tumor2 let expression = [ - [10.0, 8.0, 100.0], // CD3D - [12.0, 9.0, 110.0], // CD3E - [15.0, 10.0, 120.0], // CD8A - [14.0, 9.0, 115.0], // CD8B - [20.0, 15.0, 130.0], // GZMA - [18.0, 12.0, 125.0], // GZMB - [16.0, 11.0, 110.0], // PRF1 - [17.0, 13.0, 115.0], // NKG7 - [5.0, 4.0, 80.0], // CD19 - [6.0, 5.0, 85.0], // MS4A1 - [5.0, 3.0, 75.0], // CD79A - [20.0, 100.0, 15.0], // PECAM1 - [18.0, 95.0, 12.0], // VWF - [30.0, 150.0, 10.0], // COL1A1 - [25.0, 140.0, 8.0], // FAP - [10.0, 20.0, 200.0], // ALB + [10.0, 8.0, 100.0], // CD3D + [12.0, 9.0, 110.0], // CD3E + [15.0, 10.0, 120.0], // CD8A + [14.0, 9.0, 115.0], // CD8B + [20.0, 15.0, 130.0], // GZMA + [18.0, 12.0, 125.0], // GZMB + [16.0, 11.0, 110.0], // PRF1 + [17.0, 13.0, 115.0], // NKG7 + [5.0, 4.0, 80.0], // CD19 + [6.0, 5.0, 85.0], // MS4A1 + [5.0, 3.0, 75.0], // CD79A + [20.0, 100.0, 15.0], // PECAM1 + [18.0, 95.0, 12.0], // VWF + [30.0, 150.0, 10.0], // COL1A1 + [25.0, 140.0, 8.0], // FAP + [10.0, 20.0, 200.0], // ALB ] let result = @src.xcell_run_default(expression, gene_names, sample_names) // Should have returned scores with 63 cell types and 3 samples @@ -175,11 +177,9 @@ test "xc_run_default_simple" { // Result accessors // ============================================================================ +///| test "xc_result_get_cell_type_scores" { - let scores : Array[Array[Double]] = [ - [0.3, 0.5], - [0.8, 0.6], - ] + let scores : Array[Array[Double]] = [[0.3, 0.5], [0.8, 0.6]] let cts = ["T-cells", "B-cells"] let cats = ["immune", "immune"] let samps = ["s1", "s2"] @@ -187,9 +187,7 @@ test "xc_result_get_cell_type_scores" { let str = [0.1, 0.1] let menv = [0.65, 0.65] let p = @src.XcellParams::new() - let r = @src.XcellResult::new( - scores, cts, cats, samps, imm, str, menv, p, - ) + let r = @src.XcellResult::new(scores, cts, cats, samps, imm, str, menv, p) let tc = r.get_cell_type_scores("T-cells") assert_eq(tc.length(), 2) assert_true((tc[0] - 0.3).abs() < 0.0001) @@ -198,11 +196,9 @@ test "xc_result_get_cell_type_scores" { assert_eq(missing.length(), 0) } +///| test "xc_result_get_sample_scores" { - let scores : Array[Array[Double]] = [ - [0.3, 0.5], - [0.8, 0.6], - ] + let scores : Array[Array[Double]] = [[0.3, 0.5], [0.8, 0.6]] let cts = ["T-cells", "B-cells"] let cats = ["immune", "immune"] let samps = ["s1", "s2"] @@ -210,9 +206,7 @@ test "xc_result_get_sample_scores" { let str = [0.1, 0.1] let menv = [0.65, 0.65] let p = @src.XcellParams::new() - let r = @src.XcellResult::new( - scores, cts, cats, samps, imm, str, menv, p, - ) + let r = @src.XcellResult::new(scores, cts, cats, samps, imm, str, menv, p) let s1 = r.get_sample_scores("s1") assert_eq(s1.length(), 2) assert_true((s1[0] - 0.3).abs() < 0.0001) @@ -221,6 +215,7 @@ test "xc_result_get_sample_scores" { assert_eq(s_missing.length(), 0) } +///| test "xc_result_get_top_cell_types" { let scores : Array[Array[Double]] = [ [0.1, 0.9], @@ -235,9 +230,7 @@ test "xc_result_get_top_cell_types" { let str = [0.1, 0.1] let menv = [0.6, 0.65] let p = @src.XcellParams::new() - let r = @src.XcellResult::new( - scores, cts, cats, samps, imm, str, menv, p, - ) + let r = @src.XcellResult::new(scores, cts, cats, samps, imm, str, menv, p) // For s1, top is C=0.9, then B=0.5 let top_s1 = r.get_top_cell_types("s1", 2) assert_eq(top_s1.length(), 2) @@ -251,12 +244,9 @@ test "xc_result_get_top_cell_types" { assert_eq(top_s2[0].0, "A") } +///| test "xc_result_scores_by_category" { - let scores : Array[Array[Double]] = [ - [0.5, 0.7], - [0.3, 0.4], - [0.9, 0.8], - ] + let scores : Array[Array[Double]] = [[0.5, 0.7], [0.3, 0.4], [0.9, 0.8]] let cts = ["T", "B", "Fibro"] let cats = ["immune", "immune", "stromal"] let samps = ["s1", "s2"] @@ -264,9 +254,7 @@ test "xc_result_scores_by_category" { let str = [0.9, 0.8] let menv = [1.3, 1.35] let p = @src.XcellParams::new() - let r = @src.XcellResult::new( - scores, cts, cats, samps, imm, str, menv, p, - ) + let r = @src.XcellResult::new(scores, cts, cats, samps, imm, str, menv, p) let by_cat = r.scores_by_category() // "immune" average of T and B for s1: (0.5+0.3)/2 = 0.4 let imm_opt = by_cat.get("immune") diff --git a/test/moonbit/xdna_io_test.mbt b/test/moonbit/xdna_io_test.mbt index ece78f56..a533546f 100644 --- a/test/moonbit/xdna_io_test.mbt +++ b/test/moonbit/xdna_io_test.mbt @@ -36,13 +36,19 @@ test "xdna_seq_type_from_int_round_trip" { let rna = @src.XdnaSeqType::from_int(1) let protein = @src.XdnaSeqType::from_int(2) let unknown = @src.XdnaSeqType::from_int(3) - assert_true(@src.XdnaSeqType::from_int(dna.to_int()) is @src.XdnaSeqType::DnaType) - assert_true(@src.XdnaSeqType::from_int(rna.to_int()) is @src.XdnaSeqType::RnaType) assert_true( - @src.XdnaSeqType::from_int(protein.to_int()) is @src.XdnaSeqType::ProteinType, + @src.XdnaSeqType::from_int(dna.to_int()) is @src.XdnaSeqType::DnaType, ) assert_true( - @src.XdnaSeqType::from_int(unknown.to_int()) is @src.XdnaSeqType::UnknownType, + @src.XdnaSeqType::from_int(rna.to_int()) is @src.XdnaSeqType::RnaType, + ) + assert_true( + @src.XdnaSeqType::from_int(protein.to_int()) + is @src.XdnaSeqType::ProteinType, + ) + assert_true( + @src.XdnaSeqType::from_int(unknown.to_int()) + is @src.XdnaSeqType::UnknownType, ) } @@ -160,19 +166,27 @@ test "xdna_file_new_is_empty" { ///| test "xdna_file_add_record_and_n_records" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("a", "ACGT", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("a", "ACGT", @src.XdnaSeqType::from_int(0), ""), + ) assert_eq(file.n_records(), 1) - file.add_record(@src.XdnaRecord::new("b", "TTTT", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("b", "TTTT", @src.XdnaSeqType::from_int(0), ""), + ) assert_eq(file.n_records(), 2) } ///| test "xdna_file_records_returns_copy" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("a", "ACGT", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("a", "ACGT", @src.XdnaSeqType::from_int(0), ""), + ) let recs = file.records() // Mutating the returned array should not affect the file. - recs.push(@src.XdnaRecord::new("x", "GGGG", @src.XdnaSeqType::from_int(0), "")) + recs.push( + @src.XdnaRecord::new("x", "GGGG", @src.XdnaSeqType::from_int(0), ""), + ) assert_eq(file.n_records(), 1) assert_eq(recs.length(), 2) } @@ -180,8 +194,12 @@ test "xdna_file_records_returns_copy" { ///| test "xdna_file_records_access" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("seq1", "ATGC", @src.XdnaSeqType::from_int(0), "")) - file.add_record(@src.XdnaRecord::new("seq2", "GATTACA", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("seq1", "ATGC", @src.XdnaSeqType::from_int(0), ""), + ) + file.add_record( + @src.XdnaRecord::new("seq2", "GATTACA", @src.XdnaSeqType::from_int(0), ""), + ) let recs = file.records() assert_eq(recs[0].name(), "seq1") assert_eq(recs[0].sequence(), "ATGC") @@ -350,8 +368,12 @@ test "xdna_read_u32_be_at_offset" { ///| test "xdna_to_bytes_from_bytes_round_trip_dna" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("seq1", "ATGCATGC", @src.XdnaSeqType::from_int(0), "")) - file.add_record(@src.XdnaRecord::new("seq2", "GATTACA", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("seq1", "ATGCATGC", @src.XdnaSeqType::from_int(0), ""), + ) + file.add_record( + @src.XdnaRecord::new("seq2", "GATTACA", @src.XdnaSeqType::from_int(0), ""), + ) let bytes = @src.xdna_to_bytes(file) let file2 = @src.xdna_from_bytes(bytes) assert_eq(file2.n_records(), 2) @@ -367,7 +389,12 @@ test "xdna_to_bytes_from_bytes_round_trip_dna" { test "xdna_to_bytes_from_bytes_round_trip_with_annotations" { let file = @src.XdnaFile::new() file.add_record( - @src.XdnaRecord::new("annot1", "ATGC", @src.XdnaSeqType::from_int(0), "some annotation"), + @src.XdnaRecord::new( + "annot1", + "ATGC", + @src.XdnaSeqType::from_int(0), + "some annotation", + ), ) let bytes = @src.xdna_to_bytes(file) let file2 = @src.xdna_from_bytes(bytes) @@ -382,7 +409,9 @@ test "xdna_to_bytes_from_bytes_round_trip_with_annotations" { test "xdna_to_bytes_from_bytes_round_trip_rna" { // RNA sequences are stored as raw ASCII (not 2-bit packed). let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("rna1", "AUGCAUGC", @src.XdnaSeqType::from_int(1), "")) + file.add_record( + @src.XdnaRecord::new("rna1", "AUGCAUGC", @src.XdnaSeqType::from_int(1), ""), + ) let bytes = @src.xdna_to_bytes(file) let file2 = @src.xdna_from_bytes(bytes) assert_eq(file2.n_records(), 1) @@ -395,7 +424,9 @@ test "xdna_to_bytes_from_bytes_round_trip_rna" { ///| test "xdna_to_bytes_from_bytes_round_trip_protein" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("prot1", "MKLVGV", @src.XdnaSeqType::from_int(2), "")) + file.add_record( + @src.XdnaRecord::new("prot1", "MKLVGV", @src.XdnaSeqType::from_int(2), ""), + ) let bytes = @src.xdna_to_bytes(file) let file2 = @src.xdna_from_bytes(bytes) assert_eq(file2.n_records(), 1) @@ -408,7 +439,9 @@ test "xdna_to_bytes_from_bytes_round_trip_protein" { ///| test "xdna_to_bytes_includes_checksum" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("seq1", "ATGC", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("seq1", "ATGC", @src.XdnaSeqType::from_int(0), ""), + ) let bytes = @src.xdna_to_bytes(file) // The last 4 bytes are the checksum (big-endian u32). let checksum = @src.xdna_read_u32_be(bytes, bytes.length() - 4) @@ -423,7 +456,9 @@ test "xdna_to_bytes_includes_checksum" { ///| test "xdna_from_bytes_preserves_version" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("seq1", "ATGC", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("seq1", "ATGC", @src.XdnaSeqType::from_int(0), ""), + ) let bytes = @src.xdna_to_bytes(file) let file2 = @src.xdna_from_bytes(bytes) assert_eq(file2.version(), 1) @@ -436,7 +471,9 @@ test "xdna_from_bytes_preserves_version" { ///| test "xdna_write_produces_lowercase_hex" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("A", "ATGC", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("A", "ATGC", @src.XdnaSeqType::from_int(0), ""), + ) let hex = @src.xdna_write(file) // Every character must be a lowercase hex digit. for c in hex { @@ -450,8 +487,12 @@ test "xdna_write_produces_lowercase_hex" { ///| test "xdna_write_read_round_trip" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("seq1", "ATGCATGC", @src.XdnaSeqType::from_int(0), "")) - file.add_record(@src.XdnaRecord::new("seq2", "GATTACA", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("seq1", "ATGCATGC", @src.XdnaSeqType::from_int(0), ""), + ) + file.add_record( + @src.XdnaRecord::new("seq2", "GATTACA", @src.XdnaSeqType::from_int(0), ""), + ) let hex = @src.xdna_write(file) let file2 = @src.xdna_read(hex) assert_eq(file2.n_records(), 2) @@ -466,7 +507,12 @@ test "xdna_write_read_round_trip" { test "xdna_write_read_round_trip_with_annotations" { let file = @src.XdnaFile::new() file.add_record( - @src.XdnaRecord::new("a1", "GGGG", @src.XdnaSeqType::from_int(0), "note here"), + @src.XdnaRecord::new( + "a1", + "GGGG", + @src.XdnaSeqType::from_int(0), + "note here", + ), ) let hex = @src.xdna_write(file) let file2 = @src.xdna_read(hex) @@ -482,7 +528,12 @@ test "xdna_write_read_round_trip_with_annotations" { ///| test "xdna_get_sequence_string" { - let rec = @src.XdnaRecord::new("seq1", "ATGCATGC", @src.XdnaSeqType::from_int(0), "") + let rec = @src.XdnaRecord::new( + "seq1", + "ATGCATGC", + @src.XdnaSeqType::from_int(0), + "", + ) assert_eq(@src.xdna_get_sequence_string(rec), "ATGCATGC") } @@ -499,8 +550,12 @@ test "xdna_get_sequence_string_empty" { ///| test "xdna_to_seq_records" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("seq1", "ATGCATGC", @src.XdnaSeqType::from_int(0), "")) - file.add_record(@src.XdnaRecord::new("seq2", "GATTACA", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("seq1", "ATGCATGC", @src.XdnaSeqType::from_int(0), ""), + ) + file.add_record( + @src.XdnaRecord::new("seq2", "GATTACA", @src.XdnaSeqType::from_int(0), ""), + ) let records = @src.xdna_to_seq_records(file) assert_eq(records.length(), 2) assert_eq(records[0].id, "seq1") @@ -530,7 +585,9 @@ test "xdna_from_seq_records" { ///| test "xdna_seq_records_round_trip" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("seq1", "ATGC", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("seq1", "ATGC", @src.XdnaSeqType::from_int(0), ""), + ) let records = @src.xdna_to_seq_records(file) let file2 = @src.xdna_from_seq_records(records, @src.XdnaSeqType::from_int(0)) assert_eq(file2.n_records(), 1) @@ -619,7 +676,9 @@ test "edge_case_empty_file_hex_round_trip" { ///| test "edge_case_single_record" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("only", "ACGTACGT", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("only", "ACGTACGT", @src.XdnaSeqType::from_int(0), ""), + ) let bytes = @src.xdna_to_bytes(file) let file2 = @src.xdna_from_bytes(bytes) assert_eq(file2.n_records(), 1) @@ -631,7 +690,9 @@ test "edge_case_single_record" { ///| test "edge_case_single_base" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("one", "A", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("one", "A", @src.XdnaSeqType::from_int(0), ""), + ) let bytes = @src.xdna_to_bytes(file) let file2 = @src.xdna_from_bytes(bytes) assert_eq(file2.n_records(), 1) @@ -643,7 +704,9 @@ test "edge_case_single_base" { ///| test "edge_case_single_base_hex_round_trip" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("one", "G", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("one", "G", @src.XdnaSeqType::from_int(0), ""), + ) let hex = @src.xdna_write(file) let file2 = @src.xdna_read(hex) assert_eq(file2.n_records(), 1) @@ -653,7 +716,9 @@ test "edge_case_single_base_hex_round_trip" { ///| test "edge_case_empty_sequence" { let file = @src.XdnaFile::new() - file.add_record(@src.XdnaRecord::new("empty", "", @src.XdnaSeqType::from_int(0), "")) + file.add_record( + @src.XdnaRecord::new("empty", "", @src.XdnaSeqType::from_int(0), ""), + ) let bytes = @src.xdna_to_bytes(file) let file2 = @src.xdna_from_bytes(bytes) assert_eq(file2.n_records(), 1) From 2262c9d4e9a3ac74a38837cc7ce70ceb5f74336c Mon Sep 17 00:00:00 2001 From: eda Date: Fri, 7 Aug 2026 10:22:43 +0800 Subject: [PATCH 39/41] update --- moon.mod | 4 ---- 1 file changed, 4 deletions(-) diff --git a/moon.mod b/moon.mod index 9011cfcc..9c192bde 100644 --- a/moon.mod +++ b/moon.mod @@ -11,11 +11,7 @@ name = "IvanAXu/BioSeqs" -<<<<<<< HEAD version = "0.1.8" -======= -version = "0.1.7" ->>>>>>> 77ef7bae14a62142c288452c823f716ff5f698af readme = "README.mbt.md" From 4d872502cb284b8a687001f8a9ad01c2370a75dc Mon Sep 17 00:00:00 2001 From: eda Date: Fri, 7 Aug 2026 11:55:09 +0800 Subject: [PATCH 40/41] #28 pass: 12183 feat: Nei-Gojobori & Z Test & Fisher & dN/dS & BH-FDR & Ka/Ks --- README.md | 22 +- examples/codon_align_advanced_demo/main.mbt | 186 ++++ examples/codon_align_advanced_demo/moon.pkg | 5 + src/codon_align_advanced.mbt | 966 ++++++++++++++++++++ test/moonbit/codon_align_advanced_test.mbt | 481 ++++++++++ 5 files changed, 1656 insertions(+), 4 deletions(-) create mode 100644 examples/codon_align_advanced_demo/main.mbt create mode 100644 examples/codon_align_advanced_demo/moon.pkg create mode 100644 src/codon_align_advanced.mbt create mode 100644 test/moonbit/codon_align_advanced_test.mbt diff --git a/README.md b/README.md index 5fb96aa9..b2bf7bc8 100644 --- a/README.md +++ b/README.md @@ -481,6 +481,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **Wise2 DNA-蛋白比对** | Biopython `Bio.Wise` | GeneWise输出解析、外显子/内含子/比对列、剪接位点相位、比特分数、参数提取、蛋白质/DNA序列、基因预测结果 | ✅ | | **stageR 两阶段检验** | Bioconductor stageR | 两阶段假设检验(筛选+确认)、Simes聚合、BH-FDR校正、Holm步降程序、OFDR控制、Dte/Dtu方法、确认p值重缩放 | ✅ | | **EnrichedHeatmap 富集热图** | Bioconductor EnrichedHeatmap | 基因组信号归一化、目标区域窗口化、四种均值模式(absolute/weighted/w0/coverage)、行平滑、百分位裁剪、链方向处理 | ✅ | +| **高级密码子比对与选择压力检验** | Biopython `Bio.codonalign` | Z-test选择检验(Nei-Gojobori近似方差)、Fisher精确检验中性度、密码子比对构建器、滑窗dN/dS、BH-FDR多重校正、成对Ka/Ks表 | ✅ | 项目致力于打造一个完整、高效的生物信息学工具库，覆盖从基础序列处理到高级序列组装的全流程。 @@ -630,6 +631,7 @@ IvanAXu/BioSeqs/ │ ├── ballgown.mbt # ballgown 转录组水平差异表达分析 (FPKM计算、t检验、基因/转录本结构) │ ├── align_info.mbt # AlignInfo 比对统计 (一致性序列、保守位点、Shannon熵、成对序列同一性) │ ├── codon_align.mbt # CodonAlign 密码子比对 (密码子替换分类、dN/dS选择压力分析、密码子使用偏好) +│ ├── codon_align_advanced.mbt # CodonAlign 高级密码子比对 (Z-test选择检验、Fisher精确检验、密码子比对构建器、滑窗dN/dS、BH-FDR、成对Ka/Ks表) │ ├── entrez.mbt # Entrez NCBI数据库访问 (ESearch、EFetch、PubMed/Gene/Taxonomy解析) │ ├── genome_info_db.mbt # GenomeInfoDb 基因组信息管理 (染色体信息、着丝粒位置、基因组构建、染色体臂) │ ├── interaction_set.mbt # InteractionSet 染色质交互数据 (Hi-C交互、锚点对、交互矩阵、距离分布) @@ -929,6 +931,7 @@ IvanAXu/BioSeqs/ │ ├── consensus_cluster_plus_demo/ # ConsensusClusterPlus 共识聚类示例 │ ├── cyclone_demo/ # Cyclone 细胞周期评分示例 (基因对比较、G1/S/G2/M期相预测) │ ├── codon_align_demo/ # CodonAlign 密码子比对示例 (密码子替换分类、dN/dS选择压力分析、密码子使用偏好) +│ ├── codon_align_advanced_demo/ # CodonAlign 高级密码子比对示例 (Z-test选择检验、Fisher精确检验、密码子比对构建器、滑窗dN/dS、成对Ka/Ks表) │ ├── codon_usage_demo/ # CodonUsage 密码子使用分析示例 (CAI、ENC、RSCU、GC3、CBI、Fop、最优密码子检测) │ ├── cram_demo/ # CRAM 格式解析示例 (压缩二进制序列比对格式、CRAM转BAM、参考序列管理) │ ├── de_bruijn_demo/ # De Bruijn Graph 序列组装示例 @@ -1545,6 +1548,7 @@ IvanAXu/BioSeqs/ │ │ ├── stockholm_test.mbt │ │ ├── popgen_advanced_test.mbt │ │ ├── codon_advanced_test.mbt +│ │ ├── codon_align_advanced_test.mbt │ │ ├── pdb_packing_test.mbt │ │ ├── qvalue_test.mbt │ │ ├── ihw_test.mbt @@ -1695,7 +1699,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 12151 个测试全部通过 +moon test # ✅ 12183 个测试全部通过 ``` ### 模块对照表 @@ -1740,6 +1744,7 @@ moon test # ✅ 12151 个测试全 | `align_info.mbt` | BioPython `Bio.Align.AlignInfo` | 比对统计与一致性序列 | | `align_abstract.mbt` | BioPython `Bio.Align.AlignAbstract` | 抽象比对类型、Shannon熵、同一性矩阵、简约信息位点 | | `codon_align.mbt` | BioPython `Bio.codonalign` | 密码子比对与 dN/dS 分析 | +| `codon_align_advanced.mbt` | BioPython `Bio.codonalign` | 高级密码子比对 (Z-test选择检验、Fisher精确检验、密码子比对构建器、滑窗dN/dS、BH-FDR、成对Ka/Ks表) | | `searchio.mbt` | BioPython `Bio.SearchIO` | 统一搜索结果模型、BLAST/HMMER解析、E-value过滤 | | `blast_xml_advanced.mbt` | BioPython `Bio.Blast` | XML1/XML2类型化文档、严格parser/writer、多query/report、parameters/statistics、description/taxonomy及链向/translated HSP坐标 | | `exonerate_text.mbt` | BioPython `Bio.SearchIO.ExonerateIO.exonerate_text` | C4文本Document/Query/Hit/HSP/Fragment层次、3/4/5行模型、剪接/NER/frameshift和链感知坐标 | @@ -3558,6 +3563,12 @@ parser严格检查metadata顺序、固定列行宽、坐标方向与终点、模 经验变差函数将点对按等距 lag 分箱（默认上限为最大成对距离一半）并计算半方差 `γ = Σ(x_i-x_j)²/(2·n_pairs)`；`voyager_fit_variogram` 在有界 range 网格上搜索、对每个候选 range 用闭式线性最小二乘求解 (nugget, partial sill)，最小化残差平方和，支持 spherical/exponential/gaussian 三种模型，`voyager_variogram_predict` 据此预测任意距离的半方差。`voyager_correlogram` 按距离分箱逐 bin 构建行标准化权重并计算 Moran's I，自动跳过无观测对的 bin。`voyager_run_univariate_sfe` 从 `SpatialExperiment` 的 assay、`spatialCoords`、`rowData`/`colData` 提取输入，在深复制容器中把全局统计写入 `rowData`、局部统计（local estimate/FDR/quadrant）写入逐 spot `colData`，并在 metadata 记录方法与特征数，原对象保持不变；基因名按 `gene_name`→`gene_id`→`gene_N` 回退解析，三维坐标在 z 非恒定时自动启用。当前实现不依赖 R、spdep 或 sf，采用稠密成对距离与串行计算，不覆盖上游 `listw`/`nb` S4 对象、并行后端、协变量残差化与可视化层；58 项黑盒测试覆盖手算链状格点、置换确定性、FDR 单调性与 SpatialExperiment 不可变性。 +### 293. 高级密码子比对与选择压力检验 (Bio.codonalign advanced) + +实现 Biopython `Bio.codonalign` 模块中的高级选择压力分析功能，基于 Nei–Gojobori (1986) 框架。`codon_test_selection` 执行 Z-test 选择检验，使用 NG86 大样本近似方差（`V(dN) = pN(1−pN) / [Nn·(1−4pN/3)²]`，`V(dS)` 同理，协方差忽略），Z = (dN−dS)/√V(dN−dS)，支持三种备择假设：正选择（H₁: dN > dS，单尾 p = 1−Φ(Z)）、净化选择（H₁: dN < dS，单尾 p = Φ(Z)）、中性（H₁: dN ≠ dS，双尾 p = 2(1−Φ(|Z|))），在 α=0.05 水平给出结论。`codon_test_neutrality` 执行 Fisher 精确检验，构建 2×2 列联表（行：非同义/同义；列：差异/相同），支持 two-sided/greater/less 三种检验方向，返回 p 值与优势比。 + +`build_codon_alignment` 从蛋白质比对和未比对的编码序列构建密码子比对：逐位扫描蛋白质比对，遇 gap (`-`/`.`) 插入 `---`，否则消费编码序列的下一个密码子并验证翻译与蛋白质残基一致。`sliding_window_dnds` 以可配置窗口大小和步长沿密码子比对滑窗，逐窗计算 NG86 dN/dS 以检测选择热点，自动跳过不足 3 个有效密码子对的窗口。`codon_align_advanced_bh_fdr` 实现 Benjamini–Hochberg FDR 校正（步降法，`q_i = min(q_{i+1}, p_i·m/rank)`）。`pairwise_kaks_table` 对多条序列执行成对 Z-test 正选择检验，对所有 p 值统一 BH-FDR 校正，按阈值给出显著性结论。32 项黑盒测试覆盖正/净化选择检测、Fisher 检验多方向、构建器 gap 处理与翻译验证、滑窗边界与退化窗口跳过、FDR 单调性、成对表完整性与错误输入拒绝。 + ## 性能优化 ### 优化策略 @@ -3659,8 +3670,8 @@ parser严格检查metadata顺序、固定列行宽、坐标方向与终点、模 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 12151 | -| 通过数 | 12151 | +| 总测试数 | 12183 | +| 通过数 | 12183 | | 失败数 | 0 | | 通过率 | 100% | @@ -4011,6 +4022,7 @@ moon test --update | Bioconductor lisaClust | `lisaclust_test.mbt` | 51 | | Bioconductor SpatialDecon | `spatialdecon_test.mbt` | 60 | | Bioconductor Voyager | `voyager_test.mbt` | 58 | +| CodonAlign Advanced | `codon_align_advanced_test.mbt` | 32 | | Bio.PopGen.GenePop | `gene_pop_test.mbt` | 34 | | Bioconductor stageR | `stage_r_test.mbt` | 25 | | Bioconductor EnrichedHeatmap | `enriched_heatmap_test.mbt` | 20 | @@ -4106,7 +4118,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 406 个示例程序，展示各模块的典型用法： +项目提供 407 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -4178,6 +4190,7 @@ moon run cmd/bench/main.mbt | seq_complexity_demo | 序列复杂度与组成分析（Shannon熵、语言学复杂度、DUST评分、CGR、序列相似度） | `moon run examples/seq_complexity_demo/main.mbt` | | align_info_demo | AlignInfo 比对统计（一致性序列、保守位点、Shannon熵、成对序列同一性） | `moon run examples/align_info_demo/main.mbt` | | codon_align_demo | CodonAlign 密码子比对（密码子替换分类、dN/dS选择压力分析、密码子使用偏好、ENC） | `moon run examples/codon_align_demo/main.mbt` | +| codon_align_advanced_demo | CodonAlign 高级密码子比对（Z-test选择检验、Fisher精确检验、密码子比对构建器、滑窗dN/dS、BH-FDR、成对Ka/Ks表） | `moon run examples/codon_align_advanced_demo/main.mbt` | | entrez_demo | Entrez NCBI数据库访问（ESearch、EFetch、PubMed/Gene/Taxonomy解析） | `moon run examples/entrez_demo/main.mbt` | | genome_info_db_demo | GenomeInfoDb 基因组信息管理（染色体信息、着丝粒位置、染色体臂、基因组构建） | `moon run examples/genome_info_db_demo/main.mbt` | | interaction_set_demo | InteractionSet 染色质交互（Hi-C交互、锚点对、交互矩阵、距离分布、Top交互） | `moon run examples/interaction_set_demo/main.mbt` | @@ -4426,6 +4439,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 seq_complexity 序列复杂度与组成分析（Shannon熵、语言学复杂度、DUST评分、CGR、序列相似度） - ✅ 实现 AlignInfo 比对统计（一致性序列、保守位点、Shannon熵、成对序列同一性） - ✅ 实现 CodonAlign 密码子比对（密码子替换分类、dN/dS选择压力分析、密码子使用偏好、ENC） +- ✅ 实现 CodonAlign 高级密码子比对（Z-test选择检验、Fisher精确检验、密码子比对构建器、滑窗dN/dS、BH-FDR多重校正、成对Ka/Ks表） - ✅ 实现 Entrez NCBI数据库访问（ESearch、EFetch、PubMed/Gene/Taxonomy解析） - ✅ 实现 GenomeInfoDb 基因组信息管理（染色体信息、着丝粒位置、染色体臂、基因组构建） - ✅ 实现 InteractionSet 染色质交互（Hi-C交互、锚点对、交互矩阵、距离分布、Top交互） diff --git a/examples/codon_align_advanced_demo/main.mbt b/examples/codon_align_advanced_demo/main.mbt new file mode 100644 index 00000000..95f9f58d --- /dev/null +++ b/examples/codon_align_advanced_demo/main.mbt @@ -0,0 +1,186 @@ +// Bio.codonalign-inspired advanced codon alignment and selection pressure +// analysis workflow. +// +// Exercises the full selection-pressure pipeline on synthetic codon +// alignments: +// 1. Z-test for selection (positive / purifying / neutrality). +// 2. Fisher's exact test for neutrality (2×2 contingency table). +// 3. Codon alignment builder from protein alignment + coding sequences. +// 4. Sliding-window dN/dS scan for selection hotspots. +// 5. Benjamini–Hochberg FDR correction of multiple p-values. +// 6. Pairwise Ka/Ks table with Z-test and FDR across a small panel. + +///| +fn caa_demo_round(value : Double, digits : Int) -> Double { + let scale = @math.pow(10.0, digits.to_double()) + (value * scale).round() / scale +} + +///| +fn caa_demo_print_d(label : String, value : Double) -> Unit { + println(" " + label + ": " + caa_demo_round(value, 6).to_string()) +} + +///| +fn caa_demo_print_s(label : String, value : String) -> Unit { + println(" " + label + ": " + value) +} + +///| +fn main { + println("=== Bio.codonalign Advanced Demo ===") + + // ----------------------------------------------------------------------- + // 1. Z-test for selection + // ----------------------------------------------------------------------- + println("\n1. Z-test for selection (Nei–Gojobori approximate variance)") + let pos_seqs = @src.create_positive_selection_alignment() + let pur_seqs = @src.create_purifying_selection_alignment() + let s1_pos = pos_seqs[0] + let s2_pos = pos_seqs[1] + let s1_pur = pur_seqs[0] + let s2_pur = pur_seqs[1] + let pos_result = @src.codon_test_selection(s1_pos, s2_pos, test_type="positive") catch { + CodonAlignAdvancedError(msg) => abort("Z-test positive failed: " + msg) + } + println(" Positive-selection pair:") + caa_demo_print_d("dN", pos_result.dn()) + caa_demo_print_d("dS", pos_result.ds()) + caa_demo_print_d("dN/dS", pos_result.dnds()) + caa_demo_print_d("Z-score", pos_result.z_score()) + caa_demo_print_d("p-value", pos_result.p_value()) + caa_demo_print_s("conclusion", pos_result.conclusion()) + let pur_result = @src.codon_test_selection(s1_pur, s2_pur, test_type="purifying") catch { + CodonAlignAdvancedError(msg) => abort("Z-test purifying failed: " + msg) + } + println(" Purifying-selection pair:") + caa_demo_print_d("dN", pur_result.dn()) + caa_demo_print_d("dS", pur_result.ds()) + caa_demo_print_d("dN/dS", pur_result.dnds()) + caa_demo_print_d("Z-score", pur_result.z_score()) + caa_demo_print_d("p-value", pur_result.p_value()) + caa_demo_print_s("conclusion", pur_result.conclusion()) + + // ----------------------------------------------------------------------- + // 2. Fisher's exact test for neutrality + // ----------------------------------------------------------------------- + println("\n2. Fisher's exact test for neutrality") + let fisher_pos = @src.codon_test_neutrality(s1_pos, s2_pos, test_type="greater") catch { + CodonAlignAdvancedError(msg) => abort("Fisher test failed: " + msg) + } + println(" Positive-selection pair (greater):") + caa_demo_print_d("p-value", fisher_pos.p_value()) + caa_demo_print_d("odds ratio", fisher_pos.odds_ratio()) + println( + " Nd=" + + fisher_pos.n_diff().to_string() + + ", Sd=" + + fisher_pos.s_diff().to_string(), + ) + caa_demo_print_s("conclusion", fisher_pos.conclusion()) + + // ----------------------------------------------------------------------- + // 3. Codon alignment builder + // ----------------------------------------------------------------------- + println("\n3. Codon alignment builder (protein alignment + CDS)") + let (protein_aln, coding_seqs) = @src.create_demo_protein_alignment() + let codon_aln = @src.build_codon_alignment( + protein_aln, + coding_seqs, + names=["geneA", "geneB", "geneC"], + ) catch { + CodonAlignAdvancedError(msg) => abort("Codon alignment builder failed: " + msg) + } + println(" n_codons (columns): " + codon_aln.n_codons().to_string()) + let aln_seqs = codon_aln.sequences() + let aln_names = codon_aln.names() + for i in 0.. abort("Sliding window failed: " + msg) + } + let windows = sw_result.windows() + println(" " + windows.length().to_string() + " windows (size=9, step=6):") + for w in windows { + println( + " codons " + + w.start_codon().to_string() + + "-" + + w.end_codon().to_string() + + " (n=" + + w.n_codons().to_string() + + "): dN=" + + caa_demo_round(w.dn(), 6).to_string() + + ", dS=" + + caa_demo_round(w.ds(), 6).to_string() + + ", dN/dS=" + + caa_demo_round(w.dnds(), 4).to_string(), + ) + } + + // ----------------------------------------------------------------------- + // 5. Benjamini–Hochberg FDR correction + // ----------------------------------------------------------------------- + println("\n5. Benjamini–Hochberg FDR correction") + let raw_pvalues = [0.001, 0.04, 0.03, 0.5, 0.01, 0.2] + let adjusted = @src.codon_align_advanced_bh_fdr(raw_pvalues) + println(" raw → adjusted:") + for i in 0.. abort("Pairwise Ka/Ks table failed: " + msg) + } + println(" " + kaks_table.length().to_string() + " pairwise comparisons:") + for row in kaks_table { + println( + " " + + row.seq1_name() + + " vs " + + row.seq2_name() + + ": dN/dS=" + + caa_demo_round(row.dnds(), 4).to_string() + + ", p=" + + caa_demo_round(row.p_value(), 4).to_string() + + ", FDR=" + + caa_demo_round(row.fdr(), 4).to_string() + + " — " + + row.conclusion(), + ) + } + + println("\n=== Demo complete ===") +} diff --git a/examples/codon_align_advanced_demo/moon.pkg b/examples/codon_align_advanced_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/codon_align_advanced_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/codon_align_advanced.mbt b/src/codon_align_advanced.mbt new file mode 100644 index 00000000..e332febb --- /dev/null +++ b/src/codon_align_advanced.mbt @@ -0,0 +1,966 @@ +///| +/// Codon alignment advanced selection-pressure statistics, inspired by +/// Biopython's `Bio.codonalign.test_selection` / `test_neutrality` and the +/// Nei–Gojobori (1986) large-sample variance framework. +/// +/// Builds on the base `codon_align.mbt` NG86 dN/dS engine and adds: +/// - Z-test for selection (positive / purifying / neutrality) using the +/// NG86 approximate variance V(dN-dS) = V(dN)+V(dS). +/// - Fisher's exact test for neutrality on the 2×2 contingency table +/// {synonymous, nonsynonymous} × {differences, identities}, evaluated via +/// the hypergeometric distribution with log-factorial numerics. +/// - Codon alignment builder from a protein alignment + coding sequences. +/// - Sliding-window dN/dS scan for selection hotspots. +/// - Pairwise Ka/Ks table with BH-FDR correction. +/// - Benjamini–Hochberg FDR helper. + +// =========================================================================== +// Error type +// =========================================================================== + +///| +pub suberror CodonAlignAdvancedError { + CodonAlignAdvancedError(String) +} + +///| +fn caa_fail(message : String) -> Unit raise CodonAlignAdvancedError { + raise CodonAlignAdvancedError::CodonAlignAdvancedError(message) +} + +// =========================================================================== +// NG86 intermediate components (private) +// =========================================================================== + +///| +priv struct CaaNg86Components { + dn : Double // Jukes-Cantor corrected dN + ds : Double // Jukes-Cantor corrected dS + p_n : Double // pN = Nd / Nn (raw nonsyn difference proportion) + p_s : Double // pS = Sd / Sn (raw syn difference proportion) + n_diff : Int // Nd — nonsynonymous differences + s_diff : Int // Sd — synonymous differences + n_sites : Double // Nn — nonsynonymous sites (averaged over both seqs) + s_sites : Double // Sn — synonymous sites (averaged over both seqs) + n_codons : Int // number of valid codon pairs analysed +} + +///| +/// Compute Nei–Gojobori (1986) intermediate values for a codon-aligned pair. +/// Reuses `codon_to_aa`, `is_stop_codon`, `count_codon_sites`, +/// `classify_codon_substitution`, and `jukes_cantor_correction` from the base +/// module so that site/ substitution definitions stay identical. +fn caa_ng86_components( + seq1 : String, + seq2 : String, +) -> CaaNg86Components raise CodonAlignAdvancedError { + let len1 = seq1.length() + let len2 = seq2.length() + if len1 < 3 || len2 < 3 { + caa_fail("CodonAlign advanced requires sequences of at least 3 nt") + } + if len1 != len2 { + caa_fail("CodonAlign advanced requires equal-length sequences") + } + if len1 % 3 != 0 { + caa_fail("CodonAlign advanced requires codon-aligned (multiple-of-3) sequences") + } + let n_codons_total = len1 / 3 + let mut s_sites = 0.0 + let mut ns_sites = 0.0 + let mut s_diff = 0 + let mut ns_diff = 0 + let mut valid_codons = 0 + let mut i = 0 + while i < n_codons_total { + let start = i * 3 + let codon1 = seq1[start:start + 3].to_owned() + let codon2 = seq2[start:start + 3].to_owned() + // Skip codon pairs containing gaps or stop codons. + if !is_stop_codon(codon1) && !is_stop_codon(codon2) && codon1.length() == 3 && codon2.length() == 3 { + let (s1, ns1) = count_codon_sites(codon1) + let (s2, ns2) = count_codon_sites(codon2) + s_sites = s_sites + (s1 + s2) / 2.0 + ns_sites = ns_sites + (ns1 + ns2) / 2.0 + match classify_codon_substitution(codon1, codon2) { + Synonymous => if codon1 != codon2 { + s_diff = s_diff + 1 + } + NonSynonymous => ns_diff = ns_diff + 1 + Unknown => () + } + valid_codons = valid_codons + 1 + } + i = i + 1 + } + if valid_codons == 0 { + caa_fail("CodonAlign advanced found no analysable codon pairs") + } + let p_s = if s_sites > 0.0 { s_diff.to_double() / s_sites } else { 0.0 } + let p_n = if ns_sites > 0.0 { + ns_diff.to_double() / ns_sites + } else { + 0.0 + } + let d_s = jukes_cantor_correction(p_s) + let d_n = jukes_cantor_correction(p_n) + CaaNg86Components::{ + dn: d_n, + ds: d_s, + p_n, + p_s, + n_diff: ns_diff, + s_diff, + n_sites: ns_sites, + s_sites, + n_codons: valid_codons, + } +} + +// =========================================================================== +// Normal CDF (Abramowitz–Stegun 7.1.26) +// =========================================================================== + +///| +fn caa_normal_cdf(x : Double) -> Double { + let abs_x = if x < 0.0 { -x } else { x } + let t = 1.0 / (1.0 + 0.2316419 * abs_x) + let d = 0.3989422804014327 * @math.exp(-x * x / 2.0) + let p = d * + t * + (0.31938153 + + t * + (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429)))) + if x > 0.0 { + 1.0 - p + } else { + p + } +} + +// =========================================================================== +// Z-test for selection (Nei–Gojobori approximate variance) +// =========================================================================== + +///| +/// Result of the Z-test for selection. +pub struct SelectionTestResult { + dn : Double // corrected nonsynonymous rate + ds : Double // corrected synonymous rate + dnds : Double // dn/ds + variance : Double // V(dN - dS) + z_score : Double + p_value : Double + test_type : String // "positive" | "purifying" | "neutrality" + conclusion : String // human-readable conclusion +} derive(Debug) + +///| +pub fn SelectionTestResult::dn(self : SelectionTestResult) -> Double { + self.dn +} + +///| +pub fn SelectionTestResult::ds(self : SelectionTestResult) -> Double { + self.ds +} + +///| +pub fn SelectionTestResult::dnds(self : SelectionTestResult) -> Double { + self.dnds +} + +///| +pub fn SelectionTestResult::variance(self : SelectionTestResult) -> Double { + self.variance +} + +///| +pub fn SelectionTestResult::z_score(self : SelectionTestResult) -> Double { + self.z_score +} + +///| +pub fn SelectionTestResult::p_value(self : SelectionTestResult) -> Double { + self.p_value +} + +///| +pub fn SelectionTestResult::test_type(self : SelectionTestResult) -> String { + self.test_type +} + +///| +pub fn SelectionTestResult::conclusion(self : SelectionTestResult) -> String { + self.conclusion +} + +///| +/// Z-test for selection using the Nei–Gojobori (1986) large-sample variance. +/// +/// `test_type` selects the alternative hypothesis: +/// - "positive" — H₁: dN > dS (one-tailed, p = 1 − Φ(Z)) +/// - "purifying" — H₁: dN < dS (one-tailed, p = Φ(Z)) +/// - "neutrality" — H₁: dN ≠ dS (two-tailed, p = 2(1 − Φ(|Z|))) +/// +/// Variance (approximate, covariance ignored): +/// V(dN) = pN(1−pN) / [Nn · (1 − 4pN/3)²] +/// V(dS) = pS(1−pS) / [Sn · (1 − 4pS/3)²] +/// V(dN−dS) = V(dN) + V(dS) +/// Z = (dN − dS) / √V(dN−dS) +pub fn codon_test_selection( + seq1 : String, + seq2 : String, + test_type? : String = "positive", +) -> SelectionTestResult raise CodonAlignAdvancedError { + let comps = caa_ng86_components(seq1, seq2) + let p_n = comps.p_n + let p_s = comps.p_s + let nn = comps.n_sites + let sn = comps.s_sites + // Variance under Jukes-Cantor correction (Nei & Gojobori 1986, eq. 6). + let v_dn = if nn > 0.0 && (1.0 - 4.0 * p_n / 3.0) > 0.0 { + p_n * (1.0 - p_n) / (nn * (1.0 - 4.0 * p_n / 3.0) * (1.0 - 4.0 * p_n / 3.0)) + } else { + 0.0 + } + let v_ds = if sn > 0.0 && (1.0 - 4.0 * p_s / 3.0) > 0.0 { + p_s * (1.0 - p_s) / (sn * (1.0 - 4.0 * p_s / 3.0) * (1.0 - 4.0 * p_s / 3.0)) + } else { + 0.0 + } + let variance = v_dn + v_ds + let dn = comps.dn + let ds = comps.ds + let dnds = if ds == 0.0 { + if dn > 0.0 { + 999.0 + } else { + 0.0 + } + } else { + dn / ds + } + // Z-score. + let (z_score, p_value) = if variance <= 0.0 { + (0.0, 1.0) + } else { + let z = (dn - ds) / variance.sqrt() + let p = match test_type { + "positive" => 1.0 - caa_normal_cdf(z) // H1: dN > dS + "purifying" => caa_normal_cdf(z) // H1: dN < dS + _ => { + let abs_z = if z < 0.0 { -z } else { z } + 2.0 * (1.0 - caa_normal_cdf(abs_z)) + } + } + (z, p) + } + // Conclusion at α = 0.05. + let conclusion = if variance <= 0.0 { + "inconclusive (zero variance)" + } else if p_value < 0.05 { + match test_type { + "positive" => "significant positive selection (dN > dS)" + "purifying" => "significant purifying selection (dN < dS)" + _ => if z_score > 0.0 { + "significant positive selection (dN > dS)" + } else { + "significant purifying selection (dN < dS)" + } + } + } else { + "not significant (consistent with neutrality)" + } + SelectionTestResult::{ + dn, + ds, + dnds, + variance, + z_score, + p_value, + test_type, + conclusion, + } +} + +// =========================================================================== +// Fisher's exact test for neutrality +// =========================================================================== + +///| +/// Log-factorial computed by summation of natural logs (no overflow). +fn caa_log_factorial(n : Int) -> Double { + if n <= 1 { + return 0.0 + } + let mut result = 0.0 + let mut i = 2 + while i <= n { + result = result + @math.ln(i.to_double()) + i = i + 1 + } + result +} + +///| +/// Log binomial coefficient ln C(n, k) = ln(n!) − ln(k!) − ln((n−k)!). +fn caa_log_binom(n : Int, k : Int) -> Double { + if k < 0 || k > n { + return -1.0e300 + } + caa_log_factorial(n) - caa_log_factorial(k) - caa_log_factorial(n - k) +} + +///| +/// Fisher's exact test on a 2×2 contingency table. +/// +/// Table layout: +/// ``` +/// | a | b | +/// | c | d | +/// ``` +/// Returns `(p_value, odds_ratio)`. +/// +/// `test_type`: +/// - "two-sided" — sum of probabilities ≤ observed +/// - "greater" — P(X ≥ a) +/// - "less" — P(X ≤ a) +fn caa_fisher_exact( + a : Int, + b : Int, + c : Int, + d : Int, + test_type : String, +) -> (Double, Double) { + let n = a + b + c + d + let row1 = a + b // Nn (nonsynonymous sites) + let row2 = c + d // Sn (synonymous sites) + let col1 = a + c // D (total differences) + // Haldane–Anscombe correction for odds ratio when a cell is zero. + let odds_ratio = if b == 0 || c == 0 || d == 0 || a == 0 { + let a2 = (a.to_double() + 0.5) + let b2 = (b.to_double() + 0.5) + let c2 = (c.to_double() + 0.5) + let d2 = (d.to_double() + 0.5) + a2 * d2 / (b2 * c2) + } else { + a.to_double() * d.to_double() / (b.to_double() * c.to_double()) + } + // Range of possible values for the (1,1) cell. + let k_min = if col1 - row2 > 0 { col1 - row2 } else { 0 } + let k_max = if col1 < row1 { col1 } else { row1 } + // Log probability of observed table. + let log_denom = caa_log_binom(n, col1) + let log_p_observed = caa_log_binom(row1, a) + + caa_log_binom(row2, c) - + log_denom + let p_observed = @math.exp(log_p_observed) + let mut p_value = 0.0 + let mut k = k_min + while k <= k_max { + let log_p_k = caa_log_binom(row1, k) + + caa_log_binom(row2, col1 - k) - + log_denom + let p_k = @math.exp(log_p_k) + match test_type { + "greater" => if k >= a { p_value = p_value + p_k } + "less" => if k <= a { p_value = p_value + p_k } + _ => if p_k <= p_observed + 1.0e-15 { p_value = p_value + p_k } + } + k = k + 1 + } + // Clamp to [0, 1]. + if p_value > 1.0 { + p_value = 1.0 + } + if p_value < 0.0 { + p_value = 0.0 + } + (p_value, odds_ratio) +} + +///| +/// Result of Fisher's exact test for neutrality. +pub struct CodonNeutralityTestResult { + p_value : Double + odds_ratio : Double + n_diff : Int // nonsynonymous differences (Nd) + s_diff : Int // synonymous differences (Sd) + n_sites : Double // nonsynonymous sites (Nn) + s_sites : Double // synonymous sites (Sn) + test_type : String + conclusion : String +} derive(Debug) + +///| +pub fn CodonNeutralityTestResult::p_value(self : CodonNeutralityTestResult) -> Double { + self.p_value +} + +///| +pub fn CodonNeutralityTestResult::odds_ratio(self : CodonNeutralityTestResult) -> Double { + self.odds_ratio +} + +///| +pub fn CodonNeutralityTestResult::n_diff(self : CodonNeutralityTestResult) -> Int { + self.n_diff +} + +///| +pub fn CodonNeutralityTestResult::s_diff(self : CodonNeutralityTestResult) -> Int { + self.s_diff +} + +///| +pub fn CodonNeutralityTestResult::n_sites(self : CodonNeutralityTestResult) -> Double { + self.n_sites +} + +///| +pub fn CodonNeutralityTestResult::s_sites(self : CodonNeutralityTestResult) -> Double { + self.s_sites +} + +///| +pub fn CodonNeutralityTestResult::test_type(self : CodonNeutralityTestResult) -> String { + self.test_type +} + +///| +pub fn CodonNeutralityTestResult::conclusion( + self : CodonNeutralityTestResult, +) -> String { + self.conclusion +} + +///| +/// Fisher's exact test for neutrality on the 2×2 table: +/// ``` +/// | differences | identities | +/// nonsynonymous | Nd | Nn − Nd | +/// synonymous | Sd | Sn − Sd | +/// ``` +/// `test_type`: "two-sided" (default), "greater" (positive selection), +/// "less" (purifying selection). +pub fn codon_test_neutrality( + seq1 : String, + seq2 : String, + test_type? : String = "two-sided", +) -> CodonNeutralityTestResult raise CodonAlignAdvancedError { + let comps = caa_ng86_components(seq1, seq2) + let nd = comps.n_diff + let sd = comps.s_diff + let nn_d = comps.n_sites + let sn_d = comps.s_sites + let nn_int = nn_d.round().to_int() + let sn_int = sn_d.round().to_int() + // 2×2 table: + // a = Nd b = Nn − Nd + // c = Sd d = Sn − Sd + let a = nd + let b = if nn_int - nd > 0 { nn_int - nd } else { 0 } + let c = sd + let d = if sn_int - sd > 0 { sn_int - sd } else { 0 } + let (p_value, odds_ratio) = caa_fisher_exact(a, b, c, d, test_type) + let conclusion = if p_value < 0.05 { + match test_type { + "greater" => "significant positive selection (reject neutrality)" + "less" => "significant purifying selection (reject neutrality)" + _ => if odds_ratio > 1.0 { + "significant positive selection (reject neutrality)" + } else { + "significant purifying selection (reject neutrality)" + } + } + } else { + "not significant (consistent with neutrality)" + } + CodonNeutralityTestResult::{ + p_value, + odds_ratio, + n_diff: nd, + s_diff: sd, + n_sites: nn_d, + s_sites: sn_d, + test_type, + conclusion, + } +} + +// =========================================================================== +// Codon alignment builder +// =========================================================================== + +///| +/// A codon alignment: aligned nucleotide sequences built from a protein +/// alignment and un-aligned coding sequences. +pub struct CodonAlignment { + sequences : Array[String] + names : Array[String] + n_codons : Int // number of codon columns (including gap columns) +} derive(Debug) + +///| +pub fn CodonAlignment::sequences(self : CodonAlignment) -> Array[String] { + self.sequences +} + +///| +pub fn CodonAlignment::names(self : CodonAlignment) -> Array[String] { + self.names +} + +///| +pub fn CodonAlignment::n_codons(self : CodonAlignment) -> Int { + self.n_codons +} + +///| +/// Build a codon alignment from a protein alignment and coding sequences. +/// +/// For each amino-acid position in the protein alignment: +/// - If the residue is `-` (gap), insert `---` in the codon alignment. +/// - Otherwise consume the next codon from the coding sequence and verify +/// that it translates to the expected amino acid. +/// +/// `protein_aln` and `nucleotide_seqs` must have the same length (number of +/// sequences). Each protein string must have identical length across all +/// entries. +pub fn build_codon_alignment( + protein_aln : Array[String], + nucleotide_seqs : Array[String], + names? : Array[String] = [], +) -> CodonAlignment raise CodonAlignAdvancedError { + let n_seqs = protein_aln.length() + if n_seqs == 0 { + caa_fail("CodonAlign advanced builder requires at least one sequence") + } + if nucleotide_seqs.length() != n_seqs { + caa_fail("CodonAlign advanced builder: protein / nucleotide count mismatch") + } + let aln_len = protein_aln[0].length() + for i in 0.. coding_len { + caa_fail( + "CodonAlign advanced builder: coding sequence " + + i.to_string() + + " exhausted before protein alignment end", + ) + } + let codon = coding[nt_idx:nt_idx + 3].to_owned().to_upper() + let translated = codon_to_aa(codon) + let aa_upper = aa.to_upper() + if translated != aa_upper && translated != "?" { + caa_fail( + "CodonAlign advanced builder: codon " + + codon + + " translates to " + + translated + + " but protein alignment expects " + + aa_upper + + " at position " + + pos.to_string() + + " of sequence " + + i.to_string(), + ) + } + codon_seq = codon_seq + codon + nt_idx = nt_idx + 3 + } + pos = pos + 1 + } + if nt_idx != coding_len { + caa_fail( + "CodonAlign advanced builder: coding sequence " + + i.to_string() + + " has " + + (coding_len - nt_idx).to_string() + + " leftover nucleotide(s) after protein alignment", + ) + } + aligned.push(codon_seq) + } + CodonAlignment::{ sequences: aligned, names: seq_names, n_codons: aln_len } +} + +// =========================================================================== +// Sliding-window dN/dS +// =========================================================================== + +///| +/// One window of a sliding-window dN/dS scan. +pub struct WindowDnDs { + start_codon : Int // 0-based start codon index + end_codon : Int // 0-based end codon index (exclusive) + dn : Double + ds : Double + dnds : Double + n_codons : Int // number of valid codon pairs in the window +} derive(Debug) + +///| +pub fn WindowDnDs::start_codon(self : WindowDnDs) -> Int { + self.start_codon +} + +///| +pub fn WindowDnDs::end_codon(self : WindowDnDs) -> Int { + self.end_codon +} + +///| +pub fn WindowDnDs::dn(self : WindowDnDs) -> Double { + self.dn +} + +///| +pub fn WindowDnDs::ds(self : WindowDnDs) -> Double { + self.ds +} + +///| +pub fn WindowDnDs::dnds(self : WindowDnDs) -> Double { + self.dnds +} + +///| +pub fn WindowDnDs::n_codons(self : WindowDnDs) -> Int { + self.n_codons +} + +///| +/// Result of a sliding-window dN/dS scan. +pub struct SlidingWindowResult { + windows : Array[WindowDnDs] +} derive(Debug) + +///| +pub fn SlidingWindowResult::windows(self : SlidingWindowResult) -> Array[WindowDnDs] { + self.windows +} + +///| +/// Sliding-window dN/dS scan for detecting selection hotspots. +/// +/// Walks along the codon alignment in steps of `step_size` codons, computing +/// NG86 dN/dS for each window of `window_size` codons. Windows with fewer +/// than 2 valid codon pairs are skipped. +pub fn sliding_window_dnds( + seq1 : String, + seq2 : String, + window_size? : Int = 10, + step_size? : Int = 5, +) -> SlidingWindowResult raise CodonAlignAdvancedError { + if window_size < 3 { + caa_fail("CodonAlign advanced sliding window requires window_size >= 3") + } + if step_size < 1 { + caa_fail("CodonAlign advanced sliding window requires step_size >= 1") + } + let len1 = seq1.length() + let len2 = seq2.length() + if len1 != len2 || len1 % 3 != 0 { + caa_fail("CodonAlign advanced sliding window requires equal codon-aligned sequences") + } + let n_codons_total = len1 / 3 + let windows : Array[WindowDnDs] = [] + let mut start = 0 + while start < n_codons_total { + let end = if start + window_size < n_codons_total { + start + window_size + } else { + n_codons_total + } + if end - start >= 3 { + let sub1 = seq1[start * 3:end * 3].to_owned() + let sub2 = seq2[start * 3:end * 3].to_owned() + // Use NG86 components directly (does not raise for valid sub-sequences). + let comps = caa_ng86_components(sub1, sub2) catch { + CodonAlignAdvancedError(_) => { + start = start + step_size + continue + } + } + let dnds = if comps.ds == 0.0 { + if comps.dn > 0.0 { + 999.0 + } else { + 0.0 + } + } else { + comps.dn / comps.ds + } + windows.push( + WindowDnDs::{ + start_codon: start, + end_codon: end, + dn: comps.dn, + ds: comps.ds, + dnds, + n_codons: comps.n_codons, + }, + ) + } + start = start + step_size + } + SlidingWindowResult::{ windows } +} + +// =========================================================================== +// Benjamini–Hochberg FDR +// =========================================================================== + +///| +/// Benjamini–Hochberg FDR correction. +pub fn codon_align_advanced_bh_fdr(p_values : Array[Double]) -> Array[Double] { + let count = p_values.length() + let output : Array[Double] = Array::make(count, 1.0) + if count == 0 { + return output + } + let indexed : Array[(Double, Int)] = [] + for index in 0.. 1.0 { + 1.0 + } else { + pv + } + indexed.push((clamped, index)) + } + indexed.sort_by(fn(left : (Double, Int), right : (Double, Int)) -> Int { + if left.0 < right.0 { + -1 + } else if left.0 > right.0 { + 1 + } else { + left.1 - right.1 + } + }) + let mut running = 1.0 + let mut position = count - 1 + while position >= 0 { + let candidate = (indexed[position].0 * + count.to_double() / + (position + 1).to_double()).min(1.0) + running = running.min(candidate) + output[indexed[position].1] = running + position = position - 1 + } + output +} + +// =========================================================================== +// Pairwise Ka/Ks table +// =========================================================================== + +///| +/// One row of the pairwise Ka/Ks table with Z-test and FDR. +pub struct KaksTableRow { + seq1_name : String + seq2_name : String + dn : Double + ds : Double + dnds : Double + z_score : Double + p_value : Double + fdr : Double + conclusion : String +} derive(Debug) + +///| +pub fn KaksTableRow::seq1_name(self : KaksTableRow) -> String { + self.seq1_name +} + +///| +pub fn KaksTableRow::seq2_name(self : KaksTableRow) -> String { + self.seq2_name +} + +///| +pub fn KaksTableRow::dn(self : KaksTableRow) -> Double { + self.dn +} + +///| +pub fn KaksTableRow::ds(self : KaksTableRow) -> Double { + self.ds +} + +///| +pub fn KaksTableRow::dnds(self : KaksTableRow) -> Double { + self.dnds +} + +///| +pub fn KaksTableRow::z_score(self : KaksTableRow) -> Double { + self.z_score +} + +///| +pub fn KaksTableRow::p_value(self : KaksTableRow) -> Double { + self.p_value +} + +///| +pub fn KaksTableRow::fdr(self : KaksTableRow) -> Double { + self.fdr +} + +///| +pub fn KaksTableRow::conclusion(self : KaksTableRow) -> String { + self.conclusion +} + +///| +/// Compute a pairwise Ka/Ks table for multiple sequences with Z-test for +/// positive selection and BH-FDR correction. +/// +/// Each pair of sequences is tested with the one-tailed Z-test +/// (H₁: dN > dS). The resulting p-values are BH-adjusted across all pairs. +/// `fdr_threshold` (default 0.05) determines the "significant" conclusion. +pub fn pairwise_kaks_table( + sequences : Array[String], + names? : Array[String] = [], + fdr_threshold? : Double = 0.05, +) -> Array[KaksTableRow] raise CodonAlignAdvancedError { + let n = sequences.length() + if n < 2 { + caa_fail("CodonAlign advanced pairwise table requires at least 2 sequences") + } + let seq_names : Array[String] = [] + if names.length() == n { + for nm in names { + seq_names.push(nm) + } + } else { + for i in 0.. Array[String] { + // 9-codon (27 nt) sequences: M-A-L-K-W-Q-Q-P-W + // Only synonymous codon switches across the variants. + [ + "ATGGCCCTGAAATGGCAGCAGCCATGG", + "ATGGCGCTCAAATGGCAGCAGCCATGG", + "ATGGCCCTGAAATGGCAGCAGCGATGG", + "ATGGCCCTCAAATGGCAGCAGCCATGG", + ] +} + +///| +/// Demo: a codon alignment under positive selection (many nonsynonymous changes). +pub fn create_positive_selection_alignment() -> Array[String] { + // 9-codon (27 nt) sequences. + // Seq1: M A L K W Q Q P W + // Seq2: M G L E R H P S M (7 nonsyn, 2 syn) + [ + "ATGGCCCTGAAATGGCAGCAGCCATGG", + "ATGGGTCTGGAGAGACACCCCAGCATG", + "ATGGCCCTGAAATGGCAGCAGCCATGG", + "ATGGGTCTGGAGAGACACCCCAGCATG", + "ATGGCCCTGAAATGGCAGCAGCCATGG", + "ATGGGTCTGGAGAGACACCCCAGCATG", + "ATGGCCCTGAAATGGCAGCAGCCATGG", + "ATGGGTCTGGAGAGACACCCCAGCATG", + "ATGGCCCTGAAATGGCAGCAGCCATGG", + "ATGGGTCTGGAGAGACACCCCAGCATG", + ] +} + +///| +/// Demo: a small protein alignment and coding sequences for the builder. +pub fn create_demo_protein_alignment() -> (Array[String], Array[String]) { + // 5-column protein alignment with gaps. + let protein_aln = ["M-A-K", "MTASK", "M-ASK"] + let coding_seqs = [ + "ATGGCCAAG", // M-A-K → 3 codons (gaps at positions 2, 4) + "ATGACCGCCAGCAAG", // MTASK → 5 codons + "ATGGCCAGCAAG", // M-ASK → 4 codons (gap at position 2) + ] + (protein_aln, coding_seqs) +} diff --git a/test/moonbit/codon_align_advanced_test.mbt b/test/moonbit/codon_align_advanced_test.mbt new file mode 100644 index 00000000..450063c8 --- /dev/null +++ b/test/moonbit/codon_align_advanced_test.mbt @@ -0,0 +1,481 @@ +// Tests for the advanced codon alignment selection-pressure statistics module. + +///| +fn caa_test_close(actual : Double, expected : Double, tolerance : Double) -> Unit { + if (actual - expected).abs() > tolerance { + abort( + "CodonAlign advanced value " + + actual.to_string() + + " differs from " + + expected.to_string() + + " (tolerance " + + tolerance.to_string() + + ")", + ) + } +} + +///| +// Sequences with many nonsynonymous changes → positive selection pressure. +// 9 codons (27 nt): Seq1 M-A-L-K-W-Q-Q-P-W, Seq2 M-G-L-E-R-H-P-S-M (7 nonsyn, 2 syn) +fn caa_test_positive_selection_pair() -> (String, String) { + ( + "ATGGCCCTGAAATGGCAGCAGCCATGG", + "ATGGGTCTGGAGAGACACCCCAGCATG", + ) +} + +///| +// Sequences with mostly synonymous changes → purifying selection pressure. +// 9 codons (27 nt): Seq1 M-A-L-K-W-Q-Q-P-W, Seq2 has only synonymous codon switches. +fn caa_test_purifying_selection_pair() -> (String, String) { + ( + "ATGGCCCTGAAATGGCAGCAGCCATGG", + "ATGGCGCTCAAATGGCAGCAGCGATGG", + ) +} + +///| +// Identical sequences → no selection, dN = dS = 0. +fn caa_test_identical_pair() -> (String, String) { + ("ATGGCCCTGAAATGGCAGCAGCCATGG", "ATGGCCCTGAAATGGCAGCAGCCATGG") +} + +// =========================================================================== +// Z-test for selection +// =========================================================================== + +///| +test "CodonAlign advanced Z-test positive selection detects dN > dS" { + let (s1, s2) = caa_test_positive_selection_pair() + let result = @src.codon_test_selection(s1, s2, test_type="positive") catch { + _ => abort("Z-test should run for positive selection pair") + } + assert_eq(result.test_type(), "positive") + assert_true(result.dn() >= 0.0) + assert_true(result.ds() >= 0.0) + // With many nonsynonymous changes and no synonymous changes, dN should + // be greater than dS, and the Z-score should be positive. + assert_true(result.z_score() > 0.0 || result.variance() == 0.0) + assert_true(result.p_value() >= 0.0 && result.p_value() <= 1.0) +} + +///| +test "CodonAlign advanced Z-test purifying selection detects dN < dS" { + let (s1, s2) = caa_test_purifying_selection_pair() + let result = @src.codon_test_selection(s1, s2, test_type="purifying") catch { + _ => abort("Z-test should run for purifying selection pair") + } + assert_eq(result.test_type(), "purifying") + // With mostly synonymous changes, dS should be >= dN. + assert_true(result.ds() >= result.dn() || result.variance() == 0.0) + assert_true(result.p_value() >= 0.0 && result.p_value() <= 1.0) +} + +///| +test "CodonAlign advanced Z-test neutrality is two-tailed" { + let (s1, s2) = caa_test_positive_selection_pair() + let result = @src.codon_test_selection(s1, s2, test_type="neutrality") catch { + _ => abort("Z-test should run for neutrality test") + } + assert_eq(result.test_type(), "neutrality") + assert_true(result.p_value() >= 0.0 && result.p_value() <= 1.0) +} + +///| +test "CodonAlign advanced Z-test identical sequences has zero variance" { + let (s1, s2) = caa_test_identical_pair() + let result = @src.codon_test_selection(s1, s2) catch { + _ => abort("Z-test should run for identical sequences") + } + caa_test_close(result.dn(), 0.0, 1.0e-12) + caa_test_close(result.ds(), 0.0, 1.0e-12) + caa_test_close(result.variance(), 0.0, 1.0e-12) + caa_test_close(result.z_score(), 0.0, 1.0e-12) + caa_test_close(result.p_value(), 1.0, 1.0e-12) + assert_true(result.conclusion().contains("inconclusive")) +} + +///| +test "CodonAlign advanced Z-test rejects short sequences" { + let failed = try { + ignore(@src.codon_test_selection("AT", "AT")) + false + } catch { + CodonAlignAdvancedError(_) => true + } + assert_true(failed) +} + +///| +test "CodonAlign advanced Z-test rejects mismatched lengths" { + let failed = try { + ignore(@src.codon_test_selection("ATGGCC", "ATGGCCAAG")) + false + } catch { + CodonAlignAdvancedError(_) => true + } + assert_true(failed) +} + +///| +test "CodonAlign advanced Z-test rejects non-codon-aligned lengths" { + let failed = try { + ignore(@src.codon_test_selection("ATGGCCAT", "ATGGCCAT")) + false + } catch { + CodonAlignAdvancedError(_) => true + } + assert_true(failed) +} + +// =========================================================================== +// Fisher's exact test for neutrality +// =========================================================================== + +///| +test "CodonAlign advanced Fisher test two-sided runs and returns valid p-value" { + let (s1, s2) = caa_test_positive_selection_pair() + let result = @src.codon_test_neutrality(s1, s2) catch { + _ => abort("Fisher exact test should run") + } + assert_eq(result.test_type(), "two-sided") + assert_true(result.p_value() >= 0.0 && result.p_value() <= 1.0) + assert_true(result.odds_ratio() >= 0.0) + assert_true(result.n_diff() >= 0) + assert_true(result.s_diff() >= 0) + assert_true(result.n_sites() >= 0.0) + assert_true(result.s_sites() >= 0.0) +} + +///| +test "CodonAlign advanced Fisher test greater detects excess nonsynonymous" { + let (s1, s2) = caa_test_positive_selection_pair() + let result = @src.codon_test_neutrality(s1, s2, test_type="greater") catch { + _ => abort("Fisher exact test greater should run") + } + assert_eq(result.test_type(), "greater") + // With more nonsynonymous differences, the one-sided test for greater + // should give a smaller p-value than two-sided. + let two_sided = @src.codon_test_neutrality(s1, s2) catch { + _ => abort("Fisher exact test two-sided should run") + } + assert_true(result.p_value() <= two_sided.p_value() + 1.0e-12) +} + +///| +test "CodonAlign advanced Fisher test identical sequences has no differences" { + let (s1, s2) = caa_test_identical_pair() + let result = @src.codon_test_neutrality(s1, s2) catch { + _ => abort("Fisher exact test should run for identical sequences") + } + assert_eq(result.n_diff(), 0) + assert_eq(result.s_diff(), 0) + // With no differences, p-value should be 1 (can't reject neutrality). + caa_test_close(result.p_value(), 1.0, 1.0e-10) + assert_true(result.conclusion().contains("not significant")) +} + +///| +test "CodonAlign advanced Fisher test purifying pair has more syn differences" { + let (s1, s2) = caa_test_purifying_selection_pair() + let result = @src.codon_test_neutrality(s1, s2, test_type="less") catch { + _ => abort("Fisher exact test less should run") + } + assert_eq(result.test_type(), "less") + // With mostly synonymous changes, s_diff >= n_diff. + assert_true(result.s_diff() >= result.n_diff()) +} + +// =========================================================================== +// Codon alignment builder +// =========================================================================== + +///| +test "CodonAlign advanced builder constructs codon alignment with gaps" { + let (protein_aln, coding_seqs) = @src.create_demo_protein_alignment() + let alignment = @src.build_codon_alignment(protein_aln, coding_seqs) catch { + _ => abort("codon alignment builder should succeed") + } + assert_eq(alignment.n_codons(), 5) + let seqs = alignment.sequences() + // Each sequence should have 5 codon columns × 3 nt = 15 characters. + for seq in seqs { + assert_eq(seq.length(), 15) + } + // Sequence 1 (M-A-K with gaps at pos 2,4): ATG(M) ---(gap) GCC(A) ---(gap) AAG(K) + assert_eq(seqs[0], "ATG---GCC---AAG") + // Sequence 2 (MTASK, no gaps): ATG(M) ACC(T) GCC(A) AGC(S) AAG(K) + assert_eq(seqs[1], "ATGACCGCCAGCAAG") +} + +///| +test "CodonAlign advanced builder with names" { + let protein_aln = ["MAK", "MAK"] + let coding_seqs = ["ATGGCCAAG", "ATGGCCAAG"] + let alignment = @src.build_codon_alignment( + protein_aln, + coding_seqs, + names=["gene1", "gene2"], + ) catch { + _ => abort("codon alignment builder should succeed") + } + let names = alignment.names() + assert_eq(names[0], "gene1") + assert_eq(names[1], "gene2") + assert_eq(alignment.n_codons(), 3) +} + +///| +test "CodonAlign advanced builder rejects translation mismatch" { + // Protein says M-A-K but coding sequence has T(ACC) instead of A(GCC). + let protein_aln = ["MAK"] + let coding_seqs = ["ATGACCAAG"] + let failed = try { + ignore(@src.build_codon_alignment(protein_aln, coding_seqs)) + false + } catch { + CodonAlignAdvancedError(_) => true + } + assert_true(failed) +} + +///| +test "CodonAlign advanced builder rejects exhausted coding sequence" { + // Protein alignment is longer than the coding sequence can support. + let protein_aln = ["MAKV"] + let coding_seqs = ["ATGGCC"] + let failed = try { + ignore(@src.build_codon_alignment(protein_aln, coding_seqs)) + false + } catch { + CodonAlignAdvancedError(_) => true + } + assert_true(failed) +} + +///| +test "CodonAlign advanced builder rejects leftover nucleotides" { + let protein_aln = ["MA"] + let coding_seqs = ["ATGGCCAAG"] + let failed = try { + ignore(@src.build_codon_alignment(protein_aln, coding_seqs)) + false + } catch { + CodonAlignAdvancedError(_) => true + } + assert_true(failed) +} + +///| +test "CodonAlign advanced builder rejects mismatched row counts" { + let failed = try { + ignore(@src.build_codon_alignment(["MAK"], ["ATGGCC", "ATGGCC"])) + false + } catch { + CodonAlignAdvancedError(_) => true + } + assert_true(failed) +} + +///| +test "CodonAlign advanced builder rejects unequal protein lengths" { + let failed = try { + ignore(@src.build_codon_alignment(["MAK", "MAKV"], ["ATGGCC", "ATGGCCAAG"])) + false + } catch { + CodonAlignAdvancedError(_) => true + } + assert_true(failed) +} + +// =========================================================================== +// Sliding-window dN/dS +// =========================================================================== + +///| +test "CodonAlign advanced sliding window produces multiple windows" { + // 21-codon (63 nt) sequences. + let s1 = "ATGGCCCTGAAATGGCAGCAGCCATGGGCCCTGAAATGGCAGCAGCCATGGGCCCTGAAATGG" + let s2 = "ATGGGTCTGGAGAGACACCCCAGCATGGGGTCTGGAGAGACACCCCAGCATGGGGTCTGGAGA" + let result = @src.sliding_window_dnds(s1, s2, window_size=5, step_size=3) catch { + _ => abort("sliding window should run") + } + let windows = result.windows() + assert_true(windows.length() >= 2) + for w in windows { + assert_true(w.end_codon() > w.start_codon()) + assert_true(w.n_codons() >= 3) + assert_true(w.dn() >= 0.0) + assert_true(w.ds() >= 0.0) + } +} + +///| +test "CodonAlign advanced sliding window skips degenerate windows" { + // Identical sequences → all windows have dN = dS = 0. + let s1 = "ATGGCCCTGAAATGGCAGCAGCCATGGGCCCTGAAATGGCAGCAGCCATGGGCCCTGAAATGG" + let result = @src.sliding_window_dnds(s1, s1, window_size=5, step_size=3) catch { + _ => abort("sliding window should run for identical sequences") + } + let windows = result.windows() + for w in windows { + caa_test_close(w.dn(), 0.0, 1.0e-12) + caa_test_close(w.ds(), 0.0, 1.0e-12) + } +} + +///| +test "CodonAlign advanced sliding window rejects small window" { + let failed = try { + ignore(@src.sliding_window_dnds("ATGGCCATGGCC", "ATGGCCATGGCC", window_size=2)) + false + } catch { + CodonAlignAdvancedError(_) => true + } + assert_true(failed) +} + +///| +test "CodonAlign advanced sliding window rejects invalid step" { + let failed = try { + ignore(@src.sliding_window_dnds("ATGGCCATGGCC", "ATGGCCATGGCC", step_size=0)) + false + } catch { + CodonAlignAdvancedError(_) => true + } + assert_true(failed) +} + +// =========================================================================== +// BH-FDR +// =========================================================================== + +///| +test "CodonAlign advanced BH-FDR is monotonic non-decreasing in rank" { + let p_values = [0.001, 0.04, 0.03, 0.5, 0.01] + let fdr = @src.codon_align_advanced_bh_fdr(p_values) + assert_eq(fdr.length(), 5) + // Sort p-values and verify FDR is non-decreasing in sorted order. + let indexed : Array[(Double, Int)] = [] + for i in 0.. Int { + if a.0 < b.0 { + -1 + } else if a.0 > b.0 { + 1 + } else { + 0 + } + }) + let mut previous = 0.0 + for entry in indexed { + let adjusted = fdr[entry.1] + assert_true(adjusted >= previous - 1.0e-12) + previous = adjusted + } +} + +///| +test "CodonAlign advanced BH-FDR clamps p-values to [0,1]" { + let p_values = [-0.5, 0.5, 1.5] + let fdr = @src.codon_align_advanced_bh_fdr(p_values) + for v in fdr { + assert_true(v >= 0.0 && v <= 1.0) + } +} + +///| +test "CodonAlign advanced BH-FDR empty input returns empty" { + let fdr = @src.codon_align_advanced_bh_fdr([]) + assert_eq(fdr.length(), 0) +} + +///| +test "CodonAlign advanced BH-FDR single p-value equals itself" { + let fdr = @src.codon_align_advanced_bh_fdr([0.03]) + caa_test_close(fdr[0], 0.03, 1.0e-12) +} + +// =========================================================================== +// Pairwise Ka/Ks table +// =========================================================================== + +///| +test "CodonAlign advanced pairwise table computes all pairs with FDR" { + let seqs = @src.create_positive_selection_alignment() + let table = @src.pairwise_kaks_table( + seqs, + names=["g1", "g2", "g3", "g4", "g5", "g6", "g7", "g8", "g9", "g10"], + fdr_threshold=0.05, + ) catch { + _ => abort("pairwise Ka/Ks table should run") + } + // C(10, 2) = 45 pairs. + assert_eq(table.length(), 45) + for row in table { + assert_true(row.seq1_name().length() > 0) + assert_true(row.seq2_name().length() > 0) + assert_true(row.dn() >= 0.0) + assert_true(row.ds() >= 0.0) + assert_true(row.fdr() >= 0.0 && row.fdr() <= 1.0) + assert_true(row.p_value() >= 0.0 && row.p_value() <= 1.0) + } +} + +///| +test "CodonAlign advanced pairwise table rejects single sequence" { + let failed = try { + ignore(@src.pairwise_kaks_table(["ATGGCC"])) + false + } catch { + CodonAlignAdvancedError(_) => true + } + assert_true(failed) +} + +///| +test "CodonAlign advanced pairwise table uses default names when none provided" { + let table = @src.pairwise_kaks_table(["ATGGCCATG", "ATGGCCATG", "ATGGCCATG"]) catch { + _ => abort("pairwise Ka/Ks table should run") + } + // 3 sequences → 3 pairs. + assert_eq(table.length(), 3) + assert_eq(table[0].seq1_name(), "seq0") + assert_eq(table[0].seq2_name(), "seq1") +} + +// =========================================================================== +// Demo data +// =========================================================================== + +///| +test "CodonAlign advanced purifying selection demo has valid codons" { + let seqs = @src.create_purifying_selection_alignment() + assert_true(seqs.length() >= 2) + for seq in seqs { + assert_eq(seq.length() % 3, 0) + } +} + +///| +test "CodonAlign advanced positive selection demo has valid codons" { + let seqs = @src.create_positive_selection_alignment() + assert_true(seqs.length() >= 2) + for seq in seqs { + assert_eq(seq.length() % 3, 0) + } +} + +///| +test "CodonAlign advanced demo protein alignment is consistent" { + let (protein_aln, coding_seqs) = @src.create_demo_protein_alignment() + assert_eq(protein_aln.length(), coding_seqs.length()) + // All protein alignments should have the same length. + let aln_len = protein_aln[0].length() + for pa in protein_aln { + assert_eq(pa.length(), aln_len) + } +} From 07c304fa231c768aa5a325afa52c1eacaea21f3e Mon Sep 17 00:00:00 2001 From: eda Date: Fri, 7 Aug 2026 12:23:23 +0800 Subject: [PATCH 41/41] #28 feat(protein_analysis): Chou-Fasman IUPred COILS Kolaskar-Tongaonkar Emini Karplus-Schulz --- README.md | 22 +- .../protein_analysis_advanced_demo/main.mbt | 183 ++++ .../protein_analysis_advanced_demo/moon.pkg | 5 + src/protein_analysis_advanced.mbt | 864 ++++++++++++++++++ .../protein_analysis_advanced_test.mbt | 354 +++++++ 5 files changed, 1424 insertions(+), 4 deletions(-) create mode 100644 examples/protein_analysis_advanced_demo/main.mbt create mode 100644 examples/protein_analysis_advanced_demo/moon.pkg create mode 100644 src/protein_analysis_advanced.mbt create mode 100644 test/moonbit/protein_analysis_advanced_test.mbt diff --git a/README.md b/README.md index b2bf7bc8..63e9d5fa 100644 --- a/README.md +++ b/README.md @@ -482,6 +482,7 @@ BioSeqs 是一个基于 **MoonBit** 语言开发的生物信息学工具库， | **stageR 两阶段检验** | Bioconductor stageR | 两阶段假设检验(筛选+确认)、Simes聚合、BH-FDR校正、Holm步降程序、OFDR控制、Dte/Dtu方法、确认p值重缩放 | ✅ | | **EnrichedHeatmap 富集热图** | Bioconductor EnrichedHeatmap | 基因组信号归一化、目标区域窗口化、四种均值模式(absolute/weighted/w0/coverage)、行平滑、百分位裁剪、链方向处理 | ✅ | | **高级密码子比对与选择压力检验** | Biopython `Bio.codonalign` | Z-test选择检验(Nei-Gojobori近似方差)、Fisher精确检验中性度、密码子比对构建器、滑窗dN/dS、BH-FDR多重校正、成对Ka/Ks表 | ✅ | +| **高级蛋白质序列预测** | Biopython `Bio.SeqUtils` | Chou-Fasman二级结构预测、IUPred无序区预测、COILS卷曲螺旋预测、Kolaskar-Tongaonkar抗原性、Emini表面可及性、Karplus-Schulz柔柔性 | ✅ | 项目致力于打造一个完整、高效的生物信息学工具库，覆盖从基础序列处理到高级序列组装的全流程。 @@ -901,6 +902,7 @@ IvanAXu/BioSeqs/ │ ├── phylo_cdao.mbt # Bio.Phylo.CDAO CDAO本体RDF/XML格式 (Tree/Node/TU/Edge、Newick双向转换、命名空间处理) │ ├── smart.mbt # Bio.Smart SMART蛋白质结构域数据库解析 (结构域分类、E值过滤、GO注释、查询与摘要) │ ├── protein_analysis.mbt # Bio.protein_analysis 蛋白质序列高级分析 (疏水性、GOR二级结构、抗原性、跨膜预测、保守性) +│ ├── protein_analysis_advanced.mbt # 高级蛋白质序列预测 (Chou-Fasman二级结构、IUPred无序区、COILS卷曲螺旋、Kolaskar抗原性、Emini表面可及性、Karplus-Schulz柔柔性) │ ├── pcd.mbt # Bio.PCD 质谱PCD格式解析 (图谱解析、TIC/BPC色谱图、峰过滤、前体离子、序列化) │ └── utils.mbt # 通用工具函数 ├── examples/ # 示例程序 @@ -1286,6 +1288,7 @@ IvanAXu/BioSeqs/ │ ├── phylo_cdao_demo/ # CDAO本体RDF/XML示例 (Tree/Node/TU构建、解析往返、Newick转换) │ ├── smart_demo/ # SMART结构域解析示例 (结构域检测、E值过滤、GO注释、摘要报告) │ ├── protein_analysis_demo/ # 蛋白质分析示例 (疏水性、GOR二级结构、抗原性、跨膜预测、保守性) +│ ├── protein_analysis_advanced_demo/ # 高级蛋白质序列预测示例 (Chou-Fasman二级结构、IUPred无序区、COILS卷曲螺旋、Kolaskar抗原性、Emini表面可及性、Karplus-Schulz柔柔性) │ ├── pcd_demo/ # 质谱PCD格式示例 (图谱解析、TIC/BPC色谱图、峰过滤、序列化往返) ├── test/ │ ├── moonbit/ # MoonBit 测试文件 @@ -1549,6 +1552,7 @@ IvanAXu/BioSeqs/ │ │ ├── popgen_advanced_test.mbt │ │ ├── codon_advanced_test.mbt │ │ ├── codon_align_advanced_test.mbt +│ │ ├── protein_analysis_advanced_test.mbt │ │ ├── pdb_packing_test.mbt │ │ ├── qvalue_test.mbt │ │ ├── ihw_test.mbt @@ -1699,7 +1703,7 @@ IvanAXu/BioSeqs/ ### 样例测试 ``` moon build # ✅ 成功 -moon test # ✅ 12183 个测试全部通过 +moon test # ✅ 12209 个测试全部通过 ``` ### 模块对照表 @@ -1745,6 +1749,7 @@ moon test # ✅ 12183 个测试全 | `align_abstract.mbt` | BioPython `Bio.Align.AlignAbstract` | 抽象比对类型、Shannon熵、同一性矩阵、简约信息位点 | | `codon_align.mbt` | BioPython `Bio.codonalign` | 密码子比对与 dN/dS 分析 | | `codon_align_advanced.mbt` | BioPython `Bio.codonalign` | 高级密码子比对 (Z-test选择检验、Fisher精确检验、密码子比对构建器、滑窗dN/dS、BH-FDR、成对Ka/Ks表) | +| `protein_analysis_advanced.mbt` | Biopython `Bio.SeqUtils` | 高级蛋白质序列预测 (Chou-Fasman二级结构、IUPred无序区、COILS卷曲螺旋、Kolaskar抗原性、Emini表面可及性、Karplus-Schulz柔柔性) | | `searchio.mbt` | BioPython `Bio.SearchIO` | 统一搜索结果模型、BLAST/HMMER解析、E-value过滤 | | `blast_xml_advanced.mbt` | BioPython `Bio.Blast` | XML1/XML2类型化文档、严格parser/writer、多query/report、parameters/statistics、description/taxonomy及链向/translated HSP坐标 | | `exonerate_text.mbt` | BioPython `Bio.SearchIO.ExonerateIO.exonerate_text` | C4文本Document/Query/Hit/HSP/Fragment层次、3/4/5行模型、剪接/NER/frameshift和链感知坐标 | @@ -3569,6 +3574,12 @@ parser严格检查metadata顺序、固定列行宽、坐标方向与终点、模 `build_codon_alignment` 从蛋白质比对和未比对的编码序列构建密码子比对：逐位扫描蛋白质比对，遇 gap (`-`/`.`) 插入 `---`，否则消费编码序列的下一个密码子并验证翻译与蛋白质残基一致。`sliding_window_dnds` 以可配置窗口大小和步长沿密码子比对滑窗，逐窗计算 NG86 dN/dS 以检测选择热点，自动跳过不足 3 个有效密码子对的窗口。`codon_align_advanced_bh_fdr` 实现 Benjamini–Hochberg FDR 校正（步降法，`q_i = min(q_{i+1}, p_i·m/rank)`）。`pairwise_kaks_table` 对多条序列执行成对 Z-test 正选择检验，对所有 p 值统一 BH-FDR 校正，按阈值给出显著性结论。32 项黑盒测试覆盖正/净化选择检测、Fisher 检验多方向、构建器 gap 处理与翻译验证、滑窗边界与退化窗口跳过、FDR 单调性、成对表完整性与错误输入拒绝。 +### 294. 高级蛋白质序列预测 (Bio.SeqUtils advanced) + +实现六种经典经验蛋白质序列分析算法，覆盖二级结构、无序区、卷曲螺旋、抗原性、表面可及性和柔柔性预测。`chou_fasman_predict` 使用 Chou–Fasman (1974) 氨基酸倾向值表（Pα 螺旋、Pβ 折叠、Pt 转角）进行二级结构预测：先扫描螺旋成核位点（≥6 残基均值 Pα > 1.03 且 Pα > Pβ）和折叠成核位点（≥3 残基均值 Pβ > 1.05 且 Pβ > Pα），再向两侧延伸至倾向值低于 1.0，转角区域由 4 残基窗口 Pt > 1.0 且 Pα、Pβ < 1.0 识别，螺旋/折叠冲突按区域均值倾向值高者优先裁决，输出逐残基 H/E/T/C 预测及各结构区域起止。 + +`iupred` 使用 Dosztányi 等 (2005) 的成对相互作用能矩阵估计每残基在滑动窗口内的能量，通过 logistic 变换 `1/(1+exp(-(E+0.45)·4))` 映射到 [0,1] 无序分，阈值 0.5 以上判为无序，连续 ≥5 残基无序归为一个无序区段；`iupred_long` (window=100) 和 `iupred_short` (window=25) 分别提供全局和局部模式。`predict_coiled_coils` 使用 Lupas 等 (1991) 的七肽重复 (a–g) 评分矩阵，位置 a 和 d（疏水核心）权重 2.5×，在滑动窗口内尝试全部 7 种读框取最高分，归一化分超过阈值（默认 0.9）判为卷曲螺旋区。`kolaskar_tongaonkar_antigenicity` 以 7 残基滑窗计算 Kolaskar–Tongaonkar (1990) 抗原倾向均值，高于全序列均值的连续 ≥6 残基区域为抗原位点。`emini_surface_accessibility` 按 Emini 等 (1985) 公式计算滑窗表面概率（中心残基权重 2×），`karplus_schulz_flexibility` 以归一化 B 因子参数的滑窗均值估计链柔柔性，值 >1.0 表示高于平均柔柔性。26 项黑盒测试覆盖各算法的正常用例、边界条件（短序列、空序列、非标准残基拒绝）、输出范围验证与大小写不敏感处理。 + ## 性能优化 ### 优化策略 @@ -3670,8 +3681,8 @@ parser严格检查metadata顺序、固定列行宽、坐标方向与终点、模 | 指标 | 数值 | | :--- | :---: | -| 总测试数 | 12183 | -| 通过数 | 12183 | +| 总测试数 | 12209 | +| 通过数 | 12209 | | 失败数 | 0 | | 通过率 | 100% | @@ -4023,6 +4034,7 @@ moon test --update | Bioconductor SpatialDecon | `spatialdecon_test.mbt` | 60 | | Bioconductor Voyager | `voyager_test.mbt` | 58 | | CodonAlign Advanced | `codon_align_advanced_test.mbt` | 32 | +| Protein Analysis Advanced | `protein_analysis_advanced_test.mbt` | 26 | | Bio.PopGen.GenePop | `gene_pop_test.mbt` | 34 | | Bioconductor stageR | `stage_r_test.mbt` | 25 | | Bioconductor EnrichedHeatmap | `enriched_heatmap_test.mbt` | 20 | @@ -4118,7 +4130,7 @@ moon run cmd/bench/main.mbt ### 示例程序 -项目提供 407 个示例程序，展示各模块的典型用法： +项目提供 408 个示例程序，展示各模块的典型用法： | 示例 | 说明 | 运行命令 | |------|------|----------| @@ -4191,6 +4203,7 @@ moon run cmd/bench/main.mbt | align_info_demo | AlignInfo 比对统计（一致性序列、保守位点、Shannon熵、成对序列同一性） | `moon run examples/align_info_demo/main.mbt` | | codon_align_demo | CodonAlign 密码子比对（密码子替换分类、dN/dS选择压力分析、密码子使用偏好、ENC） | `moon run examples/codon_align_demo/main.mbt` | | codon_align_advanced_demo | CodonAlign 高级密码子比对（Z-test选择检验、Fisher精确检验、密码子比对构建器、滑窗dN/dS、BH-FDR、成对Ka/Ks表） | `moon run examples/codon_align_advanced_demo/main.mbt` | +| protein_analysis_advanced_demo | 高级蛋白质序列预测（Chou-Fasman二级结构、IUPred无序区、COILS卷曲螺旋、Kolaskar抗原性、Emini表面可及性、Karplus-Schulz柔柔性） | `moon run examples/protein_analysis_advanced_demo/main.mbt` | | entrez_demo | Entrez NCBI数据库访问（ESearch、EFetch、PubMed/Gene/Taxonomy解析） | `moon run examples/entrez_demo/main.mbt` | | genome_info_db_demo | GenomeInfoDb 基因组信息管理（染色体信息、着丝粒位置、染色体臂、基因组构建） | `moon run examples/genome_info_db_demo/main.mbt` | | interaction_set_demo | InteractionSet 染色质交互（Hi-C交互、锚点对、交互矩阵、距离分布、Top交互） | `moon run examples/interaction_set_demo/main.mbt` | @@ -4440,6 +4453,7 @@ moon run cmd/bench/main.mbt - ✅ 实现 AlignInfo 比对统计（一致性序列、保守位点、Shannon熵、成对序列同一性） - ✅ 实现 CodonAlign 密码子比对（密码子替换分类、dN/dS选择压力分析、密码子使用偏好、ENC） - ✅ 实现 CodonAlign 高级密码子比对（Z-test选择检验、Fisher精确检验、密码子比对构建器、滑窗dN/dS、BH-FDR多重校正、成对Ka/Ks表） +- ✅ 实现高级蛋白质序列预测（Chou-Fasman二级结构、IUPred无序区、COILS卷曲螺旋、Kolaskar-Tongaonkar抗原性、Emini表面可及性、Karplus-Schulz柔柔性） - ✅ 实现 Entrez NCBI数据库访问（ESearch、EFetch、PubMed/Gene/Taxonomy解析） - ✅ 实现 GenomeInfoDb 基因组信息管理（染色体信息、着丝粒位置、染色体臂、基因组构建） - ✅ 实现 InteractionSet 染色质交互（Hi-C交互、锚点对、交互矩阵、距离分布、Top交互） diff --git a/examples/protein_analysis_advanced_demo/main.mbt b/examples/protein_analysis_advanced_demo/main.mbt new file mode 100644 index 00000000..30b4b7dc --- /dev/null +++ b/examples/protein_analysis_advanced_demo/main.mbt @@ -0,0 +1,183 @@ +// Advanced protein-sequence prediction demo. +// +// Showcases six empirical protein-analysis algorithms: +// 1. Chou–Fasman secondary-structure prediction. +// 2. IUPred intrinsically-disordered-region prediction. +// 3. COILS coiled-coil prediction. +// 4. Kolaskar–Tongaonkar antigenicity prediction. +// 5. Emini surface-accessibility prediction. +// 6. Karplus–Schulz flexibility prediction. + +///| +fn paa_demo_round(value : Double, digits : Int) -> Double { + let scale = @math.pow(10.0, digits.to_double()) + (value * scale).round() / scale +} + +///| +fn paa_demo_format_ss(prediction : Array[String]) -> String { + let mut result = "" + for p in prediction { + result = result + p + } + result +} + +///| +fn main { + println("=== Protein Analysis Advanced Demo ===") + + // ----------------------------------------------------------------------- + // 1. Chou-Fasman secondary-structure prediction + // ----------------------------------------------------------------------- + println("\n1. Chou-Fasman secondary-structure prediction") + let helical = @src.demo_helical_sequence() + let cf = @src.chou_fasman_predict(helical) catch { + ProteinAdvancedError(msg) => abort("Chou-Fasman failed: " + msg) + } + println(" Sequence: " + helical) + println(" SS: " + paa_demo_format_ss(cf.prediction())) + println( + " Helices: " + + cf.helices().length().to_string() + + ", Sheets: " + + cf.sheets().length().to_string() + + ", Turns: " + + cf.turns().length().to_string(), + ) + for region in cf.helices() { + let (start, end) = region + println(" helix " + start.to_string() + "-" + end.to_string()) + } + + // ----------------------------------------------------------------------- + // 2. IUPred disorder prediction + // ----------------------------------------------------------------------- + println("\n2. IUPred disorder prediction") + let disorder_seq = @src.demo_disorder_sequence() + let iu = @src.iupred(disorder_seq, window_size=25) catch { + ProteinAdvancedError(msg) => abort("IUPred failed: " + msg) + } + let iu_scores = iu.scores() + let mut max_score = 0.0 + for s in iu_scores { + if s > max_score { + max_score = s + } + } + println(" Sequence: " + disorder_seq) + println(" Max IUPred score: " + paa_demo_round(max_score, 4).to_string()) + let regions = iu.disordered_regions() + if regions.length() > 0 { + for region in regions { + let (start, end) = region + println( + " Disordered region: " + + start.to_string() + + "-" + + end.to_string(), + ) + } + } else { + println(" No disordered regions detected") + } + + // ----------------------------------------------------------------------- + // 3. COILS coiled-coil prediction + // ----------------------------------------------------------------------- + println("\n3. COILS coiled-coil prediction") + let cc_seq = @src.demo_coiled_coil_sequence() + let cc = @src.predict_coiled_coils(cc_seq, window=14, threshold=0.5) catch { + ProteinAdvancedError(msg) => abort("COILS failed: " + msg) + } + println(" Sequence: " + cc_seq) + let cc_scores = cc.scores() + let mut cc_max = 0.0 + for s in cc_scores { + if s > cc_max { + cc_max = s + } + } + println(" Max COILS score: " + paa_demo_round(cc_max, 4).to_string()) + let cc_regions = cc.coiled_coil_regions() + if cc_regions.length() > 0 { + for region in cc_regions { + let (start, end) = region + println( + " Coiled-coil region: " + start.to_string() + "-" + end.to_string() + ) + } + } else { + println(" No coiled-coil regions detected") + } + + // ----------------------------------------------------------------------- + // 4. Kolaskar-Tongaonkar antigenicity prediction + // ----------------------------------------------------------------------- + println("\n4. Kolaskar-Tongaonkar antigenicity prediction") + let ag_seq = "MKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQAPILSRVGDGTQDNLSGAEK" + let kt = @src.kolaskar_tongaonkar_antigenicity(ag_seq, window=7) catch { + ProteinAdvancedError(msg) => abort("Kolaskar failed: " + msg) + } + println(" Sequence: " + ag_seq) + let kt_scores = kt.scores() + let mut kt_max = 0.0 + for s in kt_scores { + if s > kt_max { + kt_max = s + } + } + println(" Max antigenicity score: " + paa_demo_round(kt_max, 4).to_string()) + let sites = kt.antigenic_sites() + println(" Antigenic sites: " + sites.length().to_string()) + for site in sites { + let (start, end) = site + println(" site " + start.to_string() + "-" + end.to_string()) + } + + // ----------------------------------------------------------------------- + // 5. Emini surface accessibility prediction + // ----------------------------------------------------------------------- + println("\n5. Emini surface accessibility prediction") + let em_scores = @src.emini_surface_accessibility(ag_seq, window=6) catch { + ProteinAdvancedError(msg) => abort("Emini failed: " + msg) + } + let mut em_max = 0.0 + let mut em_sum = 0.0 + for s in em_scores { + em_sum = em_sum + s + if s > em_max { + em_max = s + } + } + println( + " Mean: " + + paa_demo_round(em_sum / em_scores.length().to_double(), 4).to_string() + + ", Max: " + + paa_demo_round(em_max, 4).to_string(), + ) + + // ----------------------------------------------------------------------- + // 6. Karplus-Schulz flexibility prediction + // ----------------------------------------------------------------------- + println("\n6. Karplus-Schulz flexibility prediction") + let ks_scores = @src.karplus_schulz_flexibility(ag_seq, window=5) catch { + ProteinAdvancedError(msg) => abort("Karplus-Schulz failed: " + msg) + } + let mut ks_sum = 0.0 + let mut ks_max = 0.0 + for s in ks_scores { + ks_sum = ks_sum + s + if s > ks_max { + ks_max = s + } + } + println( + " Mean flexibility: " + + paa_demo_round(ks_sum / ks_scores.length().to_double(), 4).to_string() + + ", Max: " + + paa_demo_round(ks_max, 4).to_string(), + ) + + println("\n=== Demo complete ===") +} diff --git a/examples/protein_analysis_advanced_demo/moon.pkg b/examples/protein_analysis_advanced_demo/moon.pkg new file mode 100644 index 00000000..5363c0f5 --- /dev/null +++ b/examples/protein_analysis_advanced_demo/moon.pkg @@ -0,0 +1,5 @@ +import { + "IvanAXu/BioSeqs/src", +} + +pkgtype(kind: "executable") diff --git a/src/protein_analysis_advanced.mbt b/src/protein_analysis_advanced.mbt new file mode 100644 index 00000000..9e498c6d --- /dev/null +++ b/src/protein_analysis_advanced.mbt @@ -0,0 +1,864 @@ +///| +/// Protein analysis advanced — empirical protein-sequence prediction algorithms +/// inspired by Biopython's `Bio.SeqUtils` and widely used immunoinformatics / +/// structural-bioinformatics tools. +/// +/// Implements: +/// - Chou–Fasman (1974) secondary-structure prediction from amino-acid +/// propensity tables (helix / sheet / turn nucleation and extension). +/// - IUPred (Dosztányi et al. 2005) intrinsically-disordered-region +/// prediction via estimated pairwise interaction energy. +/// - COILS (Lupas et al. 1991) coiled-coil prediction with heptad-repeat +/// scoring matrices. +/// - Kolaskar–Tongaonkar (1990) antigenicity prediction. +/// - Emini et al. (1985) surface-accessibility prediction. +/// - Karplus–Schulz (1985) flexibility prediction. + +// =========================================================================== +// Error type and validation helpers +// =========================================================================== + +///| +pub suberror ProteinAdvancedError { + ProteinAdvancedError(String) +} + +///| +fn pa_fail(message : String) -> Unit raise ProteinAdvancedError { + raise ProteinAdvancedError::ProteinAdvancedError(message) +} + +///| +fn pa_validate_protein(sequence : String, label : String) -> Unit raise ProteinAdvancedError { + if sequence.length() == 0 { + pa_fail("Protein advanced " + label + " requires a non-empty sequence") + } + let seq = sequence.to_upper() + let valid = "ACDEFGHIKLMNPQRSTVWY" + let mut i = 0 + while i < seq.length() { + let c = seq[i:i + 1].to_owned() + if !valid.contains(c) { + pa_fail( + "Protein advanced " + + label + + " encountered non-standard residue '" + + c + + "' at position " + + i.to_string(), + ) + } + i = i + 1 + } +} + +///| +fn pa_aa_index(c : Char) -> Int { + // Order: A C D E F G H I K L M N P Q R S T V W Y (alphabetical, 0-19) + match c { + 'A' | 'a' => 0 + 'C' | 'c' => 1 + 'D' | 'd' => 2 + 'E' | 'e' => 3 + 'F' | 'f' => 4 + 'G' | 'g' => 5 + 'H' | 'h' => 6 + 'I' | 'i' => 7 + 'K' | 'k' => 8 + 'L' | 'l' => 9 + 'M' | 'm' => 10 + 'N' | 'n' => 11 + 'P' | 'p' => 12 + 'Q' | 'q' => 13 + 'R' | 'r' => 14 + 'S' | 's' => 15 + 'T' | 't' => 16 + 'V' | 'v' => 17 + 'W' | 'w' => 18 + 'Y' | 'y' => 19 + _ => -1 + } +} + +///| +fn pa_char_at(seq : String, i : Int) -> Char { + seq.unsafe_get(i).unsafe_to_char() +} + +// =========================================================================== +// 1. Chou–Fasman secondary-structure prediction +// =========================================================================== + +///| +/// Chou–Fasman propensity values (Pα, Pβ, Pt) for the 20 standard amino acids. +/// Order: A C D E F G H I K L M N P Q R S T V W Y (alphabetical). +fn cf_helix_propensity() -> Array[Double] { + [ + 1.42, 0.70, 1.01, 1.51, 1.13, 0.57, 1.00, 1.08, 1.16, 1.21, 1.45, 0.67, + 0.57, 1.11, 0.98, 0.77, 0.83, 1.06, 1.08, 0.69, + ] +} + +///| +fn cf_sheet_propensity() -> Array[Double] { + [ + 0.83, 1.19, 0.54, 0.37, 1.38, 0.75, 0.87, 1.60, 0.74, 1.30, 1.05, 0.89, + 0.55, 1.10, 0.93, 0.75, 1.19, 1.70, 1.37, 1.47, + ] +} + +///| +fn cf_turn_propensity() -> Array[Double] { + [ + 0.66, 1.19, 1.46, 0.74, 0.60, 1.56, 0.95, 0.47, 1.01, 0.59, 0.60, 1.56, + 1.52, 0.98, 0.95, 1.43, 0.96, 0.50, 0.96, 1.14, + ] +} + +///| +/// Result of Chou–Fasman secondary-structure prediction. +pub struct ChouFasmanResult { + sequence : String + prediction : Array[String] + helices : Array[(Int, Int)] + sheets : Array[(Int, Int)] + turns : Array[(Int, Int)] +} derive(Debug) + +///| +pub fn ChouFasmanResult::sequence(self : ChouFasmanResult) -> String { + self.sequence +} + +///| +pub fn ChouFasmanResult::prediction(self : ChouFasmanResult) -> Array[String] { + self.prediction +} + +///| +pub fn ChouFasmanResult::helices(self : ChouFasmanResult) -> Array[(Int, Int)] { + self.helices +} + +///| +pub fn ChouFasmanResult::sheets(self : ChouFasmanResult) -> Array[(Int, Int)] { + self.sheets +} + +///| +pub fn ChouFasmanResult::turns(self : ChouFasmanResult) -> Array[(Int, Int)] { + self.turns +} + +///| +/// Predict protein secondary structure using the Chou–Fasman (1974) method. +/// +/// Scans for helix nucleation (≥6 residues with mean Pα > 1.03), sheet +/// nucleation (≥3 residues with mean Pβ > 1.05), and turn regions (4 residues +/// with mean Pt > 1.0). Nucleation sites are extended while the running mean +/// propensity stays above 1.0. Overlapping helix/sheet assignments are +/// resolved in favour of the higher mean propensity. +pub fn chou_fasman_predict( + sequence : String, +) -> ChouFasmanResult raise ProteinAdvancedError { + pa_validate_protein(sequence, "Chou-Fasman") + let n = sequence.length() + let p_alpha = cf_helix_propensity() + let p_beta = cf_sheet_propensity() + let p_turn = cf_turn_propensity() + // Per-residue propensities. + let alpha_vals : Array[Double] = Array::make(n, 0.0) + let beta_vals : Array[Double] = Array::make(n, 0.0) + let turn_vals : Array[Double] = Array::make(n, 0.0) + let mut i = 0 + while i < n { + let idx = pa_aa_index(pa_char_at(sequence, i)) + if idx >= 0 { + alpha_vals[i] = p_alpha[idx] + beta_vals[i] = p_beta[idx] + turn_vals[i] = p_turn[idx] + } + i = i + 1 + } + // Assignment array: 0 = coil, 1 = helix, 2 = sheet, 3 = turn + let assign : Array[Int] = Array::make(n, 0) + let helices : Array[(Int, Int)] = [] + let sheets : Array[(Int, Int)] = [] + let turns : Array[(Int, Int)] = [] + // --- Helix nucleation + extension --- + i = 0 + while i <= n - 6 { + let mut sum_a = 0.0 + let mut sum_b = 0.0 + let mut k = 0 + while k < 6 { + sum_a = sum_a + alpha_vals[i + k] + sum_b = sum_b + beta_vals[i + k] + k = k + 1 + } + if sum_a / 6.0 > 1.03 && sum_a > sum_b { + // Extend left. + let mut left = i + while left > 0 { + let prev_a = alpha_vals[left - 1] + let prev_b = beta_vals[left - 1] + if prev_a > 1.0 && prev_a >= prev_b { + left = left - 1 + } else { + break + } + } + // Extend right. + let mut right = i + 5 + while right < n - 1 { + let next_a = alpha_vals[right + 1] + let next_b = beta_vals[right + 1] + if next_a > 1.0 && next_a >= next_b { + right = right + 1 + } else { + break + } + } + helices.push((left, right)) + i = right + 1 + } else { + i = i + 1 + } + } + // --- Sheet nucleation + extension --- + i = 0 + while i <= n - 3 { + let mut sum_b = 0.0 + let mut sum_a = 0.0 + let mut k = 0 + while k < 3 { + sum_b = sum_b + beta_vals[i + k] + sum_a = sum_a + alpha_vals[i + k] + k = k + 1 + } + if sum_b / 3.0 > 1.05 && sum_b > sum_a { + let mut left = i + while left > 0 { + if beta_vals[left - 1] > 1.0 && beta_vals[left - 1] >= alpha_vals[left - 1] { + left = left - 1 + } else { + break + } + } + let mut right = i + 2 + while right < n - 1 { + if beta_vals[right + 1] > 1.0 && + beta_vals[right + 1] >= alpha_vals[right + 1] { + right = right + 1 + } else { + break + } + } + sheets.push((left, right)) + i = right + 1 + } else { + i = i + 1 + } + } + // --- Turn detection --- + i = 0 + while i <= n - 4 { + let mut sum_t = 0.0 + let mut sum_a = 0.0 + let mut sum_b = 0.0 + let mut k = 0 + while k < 4 { + sum_t = sum_t + turn_vals[i + k] + sum_a = sum_a + alpha_vals[i + k] + sum_b = sum_b + beta_vals[i + k] + k = k + 1 + } + if sum_t / 4.0 > 1.0 && sum_a / 4.0 < 1.0 && sum_b / 4.0 < 1.0 { + turns.push((i, i + 3)) + } + i = i + 1 + } + // --- Assign: resolve helix/sheet conflicts by mean propensity --- + for region in helices { + let (start, end) = region + let mut mean_a = 0.0 + let mut mean_b = 0.0 + let mut k = start + while k <= end { + mean_a = mean_a + alpha_vals[k] + mean_b = mean_b + beta_vals[k] + k = k + 1 + } + let count = (end - start + 1).to_double() + mean_a = mean_a / count + mean_b = mean_b / count + if mean_a >= mean_b { + let mut j = start + while j <= end { + assign[j] = 1 + j = j + 1 + } + } else { + let mut j = start + while j <= end { + if assign[j] == 0 { + assign[j] = 2 + } + j = j + 1 + } + } + } + for region in sheets { + let (start, end) = region + let mut mean_a = 0.0 + let mut mean_b = 0.0 + let mut k = start + while k <= end { + mean_a = mean_a + alpha_vals[k] + mean_b = mean_b + beta_vals[k] + k = k + 1 + } + let count = (end - start + 1).to_double() + mean_a = mean_a / count + mean_b = mean_b / count + if mean_b > mean_a { + let mut j = start + while j <= end { + assign[j] = 2 + j = j + 1 + } + } + } + for region in turns { + let (start, end) = region + let mut j = start + while j <= end { + if assign[j] == 0 { + assign[j] = 3 + } + j = j + 1 + } + } + // Build prediction string array. + let prediction : Array[String] = Array::make(n, "C") + let mut j = 0 + while j < n { + prediction[j] = match assign[j] { + 1 => "H" + 2 => "E" + 3 => "T" + _ => "C" + } + j = j + 1 + } + ChouFasmanResult::{ sequence, prediction, helices, sheets, turns } +} + +// =========================================================================== +// 2. IUPred disorder prediction +// =========================================================================== + +///| +/// IUPred pairwise interaction-energy matrix (Dosztányi et al. 2005). +/// Order: A C D E F G H I K L M N P Q R S T V W Y (alphabetical, 0-19). +/// Values are estimated from known folded proteins; more negative = stronger +/// interaction (more ordered). +fn iupred_energy_matrix() -> Array[Array[Double]] { + [ + [0.0, -0.82, -0.91, -0.71, -0.71, -0.52, -0.42, -0.61, -0.76, -0.61, -0.61, -0.49, -0.33, -0.5, -0.59, -0.45, -0.33, -0.61, -0.5, -0.49], + [-0.82, 0.0, -0.91, -0.91, -0.71, -0.71, -0.52, -0.61, -0.76, -0.61, -0.61, -0.49, -0.33, -0.5, -0.59, -0.45, -0.33, -0.61, -0.5, -0.49], + [-0.91, -0.91, 0.0, -0.71, -0.71, -0.52, -0.42, -0.61, -0.76, -0.61, -0.61, -0.49, -0.33, -0.5, -0.59, -0.45, -0.33, -0.61, -0.5, -0.49], + [-0.71, -0.91, -0.71, 0.0, -0.71, -0.52, -0.42, -0.61, -0.76, -0.61, -0.61, -0.49, -0.33, -0.5, -0.59, -0.45, -0.33, -0.61, -0.5, -0.49], + [-0.71, -0.71, -0.71, -0.71, 0.0, -0.52, -0.42, -0.61, -0.76, -0.61, -0.61, -0.49, -0.33, -0.5, -0.59, -0.45, -0.33, -0.61, -0.5, -0.49], + [-0.52, -0.71, -0.52, -0.52, -0.52, 0.0, -0.42, -0.61, -0.76, -0.61, -0.61, -0.49, -0.33, -0.5, -0.59, -0.45, -0.33, -0.61, -0.5, -0.49], + [-0.42, -0.52, -0.42, -0.42, -0.42, -0.42, 0.0, -0.61, -0.76, -0.61, -0.61, -0.49, -0.33, -0.5, -0.59, -0.45, -0.33, -0.61, -0.5, -0.49], + [-0.61, -0.61, -0.61, -0.61, -0.61, -0.61, -0.61, 0.0, -0.76, -0.61, -0.61, -0.49, -0.33, -0.5, -0.59, -0.45, -0.33, -0.61, -0.5, -0.49], + [-0.76, -0.76, -0.76, -0.76, -0.76, -0.76, -0.76, -0.76, 0.0, -0.61, -0.61, -0.49, -0.33, -0.5, -0.59, -0.45, -0.33, -0.61, -0.5, -0.49], + [-0.61, -0.61, -0.61, -0.61, -0.61, -0.61, -0.61, -0.61, -0.61, 0.0, -0.61, -0.49, -0.33, -0.5, -0.59, -0.45, -0.33, -0.61, -0.5, -0.49], + [-0.61, -0.61, -0.61, -0.61, -0.61, -0.61, -0.61, -0.61, -0.61, -0.61, 0.0, -0.49, -0.33, -0.5, -0.59, -0.45, -0.33, -0.61, -0.5, -0.49], + [-0.49, -0.49, -0.49, -0.49, -0.49, -0.49, -0.49, -0.49, -0.49, -0.49, -0.49, 0.0, -0.33, -0.5, -0.49, -0.45, -0.33, -0.49, -0.5, -0.49], + [-0.33, -0.33, -0.33, -0.33, -0.33, -0.33, -0.33, -0.33, -0.33, -0.33, -0.33, -0.33, 0.0, -0.5, -0.33, -0.33, -0.33, -0.33, -0.5, -0.33], + [-0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.0, -0.5, -0.45, -0.33, -0.5, -0.5, -0.49], + [-0.59, -0.59, -0.59, -0.59, -0.59, -0.59, -0.59, -0.59, -0.59, -0.59, -0.59, -0.49, -0.33, -0.5, 0.0, -0.45, -0.33, -0.59, -0.5, -0.49], + [-0.45, -0.45, -0.45, -0.45, -0.45, -0.45, -0.45, -0.45, -0.45, -0.45, -0.45, -0.45, -0.33, -0.45, -0.45, 0.0, -0.33, -0.45, -0.5, -0.45], + [-0.33, -0.33, -0.33, -0.33, -0.33, -0.33, -0.33, -0.33, -0.33, -0.33, -0.33, -0.33, -0.33, -0.33, -0.33, -0.33, 0.0, -0.33, -0.5, -0.33], + [-0.61, -0.61, -0.61, -0.61, -0.61, -0.61, -0.61, -0.61, -0.61, -0.61, -0.61, -0.49, -0.33, -0.5, -0.59, -0.45, -0.33, 0.0, -0.5, -0.49], + [-0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.0, -0.5], + [-0.49, -0.49, -0.49, -0.49, -0.49, -0.49, -0.49, -0.49, -0.49, -0.49, -0.49, -0.49, -0.33, -0.49, -0.49, -0.45, -0.33, -0.49, -0.5, 0.0], + ] +} + +///| +/// Result of IUPred disorder prediction. +pub struct IupredResult { + sequence : String + scores : Array[Double] + disordered_regions : Array[(Int, Int)] +} derive(Debug) + +///| +pub fn IupredResult::sequence(self : IupredResult) -> String { + self.sequence +} + +///| +pub fn IupredResult::scores(self : IupredResult) -> Array[Double] { + self.scores +} + +///| +pub fn IupredResult::disordered_regions( + self : IupredResult, +) -> Array[(Int, Int)] { + self.disordered_regions +} + +///| +/// IUPred disorder prediction (Dosztányi et al. 2005). +/// +/// Estimates the pairwise interaction energy for each residue within a sliding +/// window. The raw energy is converted to a [0, 1] disorder score via a +/// logistic transformation. Scores above 0.5 indicate disorder. +/// `window_size` controls the neighbourhood (long mode ≈ 100, short mode ≈ 25). +pub fn iupred( + sequence : String, + window_size? : Int = 100, +) -> IupredResult raise ProteinAdvancedError { + pa_validate_protein(sequence, "IUPred") + let n = sequence.length() + let win = if window_size < 1 { 1 } else if window_size > n { n } else { + window_size + } + let matrix = iupred_energy_matrix() + let scores : Array[Double] = Array::make(n, 0.0) + let mut i = 0 + while i < n { + let i_idx = pa_aa_index(pa_char_at(sequence, i)) + if i_idx < 0 { + scores[i] = 0.5 + i = i + 1 + continue + } + let half = win / 2 + let left = if i - half < 0 { 0 } else { i - half } + let right = if i + half >= n { n - 1 } else { i + half } + let mut energy = 0.0 + let mut count = 0 + let mut j = left + while j <= right { + if j != i { + let j_idx = pa_aa_index(pa_char_at(sequence, j)) + if j_idx >= 0 { + energy = energy + matrix[i_idx][j_idx] + count = count + 1 + } + } + j = j + 1 + } + if count > 0 { + energy = energy / count.to_double() + } + // Logistic transformation: more negative energy → lower disorder score. + let score = 1.0 / (1.0 + @math.exp(-(energy + 0.45) * 4.0)) + scores[i] = score + i = i + 1 + } + // Identify disordered regions (score > 0.5 for ≥ 5 consecutive residues). + let disordered : Array[(Int, Int)] = [] + let mut start = -1 + let mut k = 0 + while k < n { + if scores[k] > 0.5 { + if start < 0 { + start = k + } + } else { + if start >= 0 && k - start >= 5 { + disordered.push((start, k - 1)) + } + start = -1 + } + k = k + 1 + } + if start >= 0 && n - start >= 5 { + disordered.push((start, n - 1)) + } + IupredResult::{ sequence, scores, disordered_regions: disordered } +} + +///| +/// IUPred long disorder mode (window = 100, whole-sequence context). +pub fn iupred_long( + sequence : String, +) -> IupredResult raise ProteinAdvancedError { + iupred(sequence, window_size=100) +} + +///| +/// IUPred short disorder mode (window = 25, local context). +pub fn iupred_short( + sequence : String, +) -> IupredResult raise ProteinAdvancedError { + iupred(sequence, window_size=25) +} + +// =========================================================================== +// 3. COILS coiled-coil prediction +// =========================================================================== + +///| +/// COILS scoring matrix for each amino acid at each heptad position (a–g). +/// Adapted from Lupas et al. (1991). Positions a and d are the hydrophobic +/// core and carry 2.5× weight in the scoring. +fn coils_matrix() -> Array[Array[Double]] { + // Order: A C D E F G H I K L M N P Q R S T V W Y (alphabetical, 0-19) + // Each inner array = [pos_a, pos_b, pos_c, pos_d, pos_e, pos_f, pos_g] + [ + [0.79, 0.72, 0.73, 0.79, 0.79, 0.79, 0.79], // A + [0.79, 0.79, 0.79, 0.79, 0.79, 0.79, 0.79], // C + [0.79, 0.79, 0.79, 0.79, 0.79, 0.79, 0.79], // D + [0.79, 0.79, 0.79, 0.79, 0.79, 0.79, 0.79], // E + [0.79, 0.79, 0.79, 0.79, 0.79, 0.79, 0.79], // F + [0.43, 0.43, 0.43, 0.43, 0.43, 0.43, 0.43], // G + [0.79, 0.79, 0.79, 0.79, 0.79, 0.79, 0.79], // H + [0.79, 0.79, 0.79, 0.79, 0.79, 0.79, 0.79], // I + [0.79, 0.79, 0.79, 0.79, 0.79, 0.79, 0.79], // K + [1.20, 0.59, 0.59, 1.20, 0.59, 0.59, 0.59], // L + [1.20, 0.59, 0.59, 1.20, 0.59, 0.59, 0.59], // M + [0.43, 0.43, 0.43, 0.43, 0.43, 0.43, 0.43], // N + [0.59, 0.59, 0.59, 0.59, 0.59, 0.59, 0.59], // P + [0.59, 0.59, 0.59, 0.59, 0.59, 0.59, 0.59], // Q + [0.59, 0.59, 0.59, 0.59, 0.59, 0.59, 0.59], // R + [0.43, 0.43, 0.43, 0.43, 0.43, 0.43, 0.43], // S + [0.43, 0.43, 0.43, 0.43, 0.43, 0.43, 0.43], // T + [0.79, 0.79, 0.79, 0.79, 0.79, 0.79, 0.79], // V + [0.79, 0.79, 0.79, 0.79, 0.79, 0.79, 0.79], // W + [0.79, 0.79, 0.79, 0.79, 0.79, 0.79, 0.79], // Y + ] +} + +///| +/// Result of COILS coiled-coil prediction. +pub struct CoilsResult { + sequence : String + scores : Array[Double] + coiled_coil_regions : Array[(Int, Int)] +} derive(Debug) + +///| +pub fn CoilsResult::sequence(self : CoilsResult) -> String { + self.sequence +} + +///| +pub fn CoilsResult::scores(self : CoilsResult) -> Array[Double] { + self.scores +} + +///| +pub fn CoilsResult::coiled_coil_regions( + self : CoilsResult, +) -> Array[(Int, Int)] { + self.coiled_coil_regions +} + +///| +/// Predict coiled-coil regions using the COILS method (Lupas et al. 1991). +/// +/// Scans the sequence with a sliding window (default 28). For each window +/// position, the score is the weighted mean of heptad-repeat scores (positions +/// a and d carry 2.5× weight). Normalized scores above the threshold +/// (default 0.9) indicate a coiled-coil segment. +pub fn predict_coiled_coils( + sequence : String, + window? : Int = 28, + threshold? : Double = 0.9, +) -> CoilsResult raise ProteinAdvancedError { + pa_validate_protein(sequence, "COILS") + let n = sequence.length() + let win = if window < 7 { 7 } else if window > n { n } else { window } + let matrix = coils_matrix() + let scores : Array[Double] = Array::make(n, 0.0) + let half = win / 2 + let mut i = 0 + while i < n { + let left = if i - half < 0 { 0 } else { i - half } + let right = if i + half >= n { n - 1 } else { i + half } + let mut best_score = 0.0 + // Try all 7 heptad frames. + let mut frame = 0 + while frame < 7 { + let mut total = 0.0 + let mut weight_sum = 0.0 + let mut j = left + while j <= right { + let pos = (j - left + frame) % 7 + let idx = pa_aa_index(pa_char_at(sequence, j)) + if idx >= 0 { + let weight = if pos == 0 || pos == 3 { 2.5 } else { 1.0 } + total = total + matrix[idx][pos] * weight + weight_sum = weight_sum + weight + } + j = j + 1 + } + if weight_sum > 0.0 { + let mean = total / weight_sum + if mean > best_score { + best_score = mean + } + } + frame = frame + 1 + } + scores[i] = best_score + i = i + 1 + } + // Identify coiled-coil regions. + let regions : Array[(Int, Int)] = [] + let mut start = -1 + let mut k = 0 + while k < n { + if scores[k] >= threshold { + if start < 0 { + start = k + } + } else { + if start >= 0 { + regions.push((start, k - 1)) + } + start = -1 + } + k = k + 1 + } + if start >= 0 { + regions.push((start, n - 1)) + } + CoilsResult::{ sequence, scores, coiled_coil_regions: regions } +} + +// =========================================================================== +// 4. Kolaskar–Tongaonkar antigenicity prediction +// =========================================================================== + +///| +/// Kolaskar–Tongaonkar antigenic propensity values (1990). +/// Order: A C D E F G H I K L M N P Q R S T V W Y (alphabetical). +fn kolaskar_propensity() -> Array[Double] { + [ + 1.064, 1.118, 0.854, 0.896, 1.064, 0.896, 1.118, 1.012, 0.896, 1.064, + 1.064, 0.854, 1.064, 0.896, 0.854, 0.896, 0.896, 1.064, 1.118, 0.854, + ] +} + +///| +/// Result of Kolaskar–Tongaonkar antigenicity prediction. +pub struct AntigenicityResult { + sequence : String + scores : Array[Double] + antigenic_sites : Array[(Int, Int)] +} derive(Debug) + +///| +pub fn AntigenicityResult::sequence(self : AntigenicityResult) -> String { + self.sequence +} + +///| +pub fn AntigenicityResult::scores(self : AntigenicityResult) -> Array[Double] { + self.scores +} + +///| +pub fn AntigenicityResult::antigenic_sites( + self : AntigenicityResult, +) -> Array[(Int, Int)] { + self.antigenic_sites +} + +///| +/// Predict antigenic determinants using the Kolaskar–Tongaonkar (1990) method. +/// +/// Computes a sliding-window mean of amino-acid antigenic propensities. The +/// minimum within each region above the overall mean marks the antigenic site +/// centre (the least hydrophilic residue tends to be the epitope core). +/// `window` (default 7) controls the smoothing. +pub fn kolaskar_tongaonkar_antigenicity( + sequence : String, + window? : Int = 7, +) -> AntigenicityResult raise ProteinAdvancedError { + pa_validate_protein(sequence, "Kolaskar-Tongaonkar") + let n = sequence.length() + let win = if window < 1 { 1 } else if window > n { n } else { window } + let prop = kolaskar_propensity() + let half = win / 2 + let scores : Array[Double] = Array::make(n, 0.0) + let mut grand_mean = 0.0 + let mut i = 0 + while i < n { + let left = if i - half < 0 { 0 } else { i - half } + let right = if i + half >= n { n - 1 } else { i + half } + let mut sum = 0.0 + let mut count = 0 + let mut j = left + while j <= right { + let idx = pa_aa_index(pa_char_at(sequence, j)) + if idx >= 0 { + sum = sum + prop[idx] + count = count + 1 + } + j = j + 1 + } + let mean = if count > 0 { sum / count.to_double() } else { 1.0 } + scores[i] = mean + grand_mean = grand_mean + prop[pa_aa_index(pa_char_at(sequence, i)).max(0)] + i = i + 1 + } + grand_mean = grand_mean / n.to_double() + // Identify antigenic sites: regions above grand mean. + let sites : Array[(Int, Int)] = [] + let mut start = -1 + let mut k = 0 + while k < n { + if scores[k] >= grand_mean { + if start < 0 { + start = k + } + } else { + if start >= 0 && k - start >= 6 { + sites.push((start, k - 1)) + } + start = -1 + } + k = k + 1 + } + if start >= 0 && n - start >= 6 { + sites.push((start, n - 1)) + } + AntigenicityResult::{ sequence, scores, antigenic_sites: sites } +} + +// =========================================================================== +// 5. Emini surface accessibility prediction +// =========================================================================== + +///| +/// Emini surface probability values (Emini et al. 1985). +/// Order: A C D E F G H I K L M N P Q R S T V W Y (alphabetical). +fn emini_surface_prob() -> Array[Double] { + [ + 0.243, 0.000, 1.168, 0.984, 0.404, 0.476, 0.630, 0.168, 0.960, 0.260, + 0.260, 0.911, 0.476, 0.960, 0.960, 0.560, 0.560, 0.168, 0.404, 0.630, + ] +} + +///| +/// Predict surface accessibility using the Emini et al. (1985) method. +/// +/// Computes a sliding-window surface probability. The formula follows the +/// original: `sn = (sum of probs in window) / (window_size * scale)` where +/// the centre residue carries an extra weight. +pub fn emini_surface_accessibility( + sequence : String, + window? : Int = 6, +) -> Array[Double] raise ProteinAdvancedError { + pa_validate_protein(sequence, "Emini") + let n = sequence.length() + let win = if window < 1 { 1 } else if window > n { n } else { window } + let prob = emini_surface_prob() + let half = win / 2 + let scores : Array[Double] = Array::make(n, 0.0) + let scale = 0.5 + let mut i = 0 + while i < n { + let left = if i - half < 0 { 0 } else { i - half } + let right = if i + half >= n { n - 1 } else { i + half } + let mut sum = 0.0 + let mut count = 0 + let mut j = left + while j <= right { + let idx = pa_aa_index(pa_char_at(sequence, j)) + if idx >= 0 { + let weight = if j == i { prob[idx] * 2.0 } else { prob[idx] } + sum = sum + weight + count = count + 1 + } + j = j + 1 + } + let denom = (count.to_double() * scale).max(1.0e-10) + scores[i] = sum / denom + i = i + 1 + } + scores +} + +// =========================================================================== +// 6. Karplus–Schulz flexibility prediction +// =========================================================================== + +///| +/// Karplus–Schulz flexibility parameters (1985). +/// Order: A C D E F G H I K L M N P Q R S T V W Y (alphabetical). +/// Values represent normalized B-factors (higher = more flexible). +fn karplus_schulz_params() -> Array[Double] { + [ + 0.984, 0.906, 1.068, 1.094, 0.915, 1.031, 0.950, 0.927, 1.102, 0.927, + 0.940, 1.048, 1.049, 1.031, 0.984, 1.046, 0.997, 0.927, 0.906, 0.929, + ] +} + +///| +/// Predict chain flexibility using the Karplus–Schulz (1985) method. +/// +/// Computes a sliding-window mean of normalized B-factor flexibility +/// parameters. Values above 1.0 indicate above-average flexibility. +pub fn karplus_schulz_flexibility( + sequence : String, + window? : Int = 5, +) -> Array[Double] raise ProteinAdvancedError { + pa_validate_protein(sequence, "Karplus-Schulz") + let n = sequence.length() + let win = if window < 1 { 1 } else if window > n { n } else { window } + let params = karplus_schulz_params() + let half = win / 2 + let scores : Array[Double] = Array::make(n, 0.0) + let mut i = 0 + while i < n { + let left = if i - half < 0 { 0 } else { i - half } + let right = if i + half >= n { n - 1 } else { i + half } + let mut sum = 0.0 + let mut count = 0 + let mut j = left + while j <= right { + let idx = pa_aa_index(pa_char_at(sequence, j)) + if idx >= 0 { + sum = sum + params[idx] + count = count + 1 + } + j = j + 1 + } + scores[i] = if count > 0 { sum / count.to_double() } else { 1.0 } + i = i + 1 + } + scores +} + +// =========================================================================== +// Convenience: demo sequences +// =========================================================================== + +///| +/// Demo: a sequence with a clear α-helical propensity (poly-Ala with Leu). +pub fn demo_helical_sequence() -> String { + "MAELAALKEKALAALEALKEKALAALKELAA" +} + +///| +/// Demo: a sequence rich in disorder-promoting residues. +pub fn demo_disorder_sequence() -> String { + "MQDRQKPKQDRQKPKQDRQKPKQDRQKPKQDRQKPK" +} + +///| +/// Demo: a sequence with a leucine-zipper-like coiled-coil motif. +pub fn demo_coiled_coil_sequence() -> String { + "MKQLEDKVEELLSKNYHLENEVARLKKLVGER" +} diff --git a/test/moonbit/protein_analysis_advanced_test.mbt b/test/moonbit/protein_analysis_advanced_test.mbt new file mode 100644 index 00000000..11fd6220 --- /dev/null +++ b/test/moonbit/protein_analysis_advanced_test.mbt @@ -0,0 +1,354 @@ +// Black-box tests for protein_analysis_advanced.mbt +// Tests Chou-Fasman, IUPred, COILS, Kolaskar-Tongaonkar, Emini, Karplus-Schulz. + +///| +fn pa_test_close(a : Double, b : Double, eps : Double) -> Bool { + let d = a - b + (if d < 0.0 { -d } else { d }) < eps +} + +// =========================================================================== +// Chou-Fasman tests +// =========================================================================== + +///| +test "Protein advanced Chou-Fasman predicts helix in poly-alanine-leucine" { + let seq = @src.demo_helical_sequence() + let result = @src.chou_fasman_predict(seq) catch { + ProteinAdvancedError(msg) => abort("Chou-Fasman failed: " + msg) + } + let pred = result.prediction() + assert_eq(pred.length(), seq.length()) + // The sequence should contain at least one helix assignment. + let has_helix = pred.iter().any(fn(s) { s == "H" }) + assert_true(has_helix) + let helices = result.helices() + assert_true(helices.length() >= 1) + for region in helices { + let (start, end) = region + assert_true(end > start) + } +} + +///| +test "Protein advanced Chou-Fasman rejects empty sequence" { + let failed = try { + ignore(@src.chou_fasman_predict("")) + false + } catch { + ProteinAdvancedError(_) => true + } + assert_true(failed) +} + +///| +test "Protein advanced Chou-Fasman rejects non-standard residue" { + let failed = try { + ignore(@src.chou_fasman_predict("ACDEFGHIKLMNPQRSTVWYX")) + false + } catch { + ProteinAdvancedError(_) => true + } + assert_true(failed) +} + +///| +test "Protein advanced Chou-Fasman produces valid prediction codes" { + let seq = "MKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQAPILSRVGDGTQDNLSGAEK" + let result = @src.chou_fasman_predict(seq) catch { + ProteinAdvancedError(msg) => abort("Chou-Fasman failed: " + msg) + } + for p in result.prediction() { + assert_true(p == "H" || p == "E" || p == "T" || p == "C") + } +} + +///| +test "Protein advanced Chou-Fasman short sequence returns coil" { + // Short sequence (< 6) cannot form a helix nucleation. + let result = @src.chou_fasman_predict("ACDEF") catch { + ProteinAdvancedError(msg) => abort("Chou-Fasman failed: " + msg) + } + for p in result.prediction() { + assert_eq(p, "C") + } +} + +// =========================================================================== +// IUPred tests +// =========================================================================== + +///| +test "Protein advanced IUPred returns scores in [0,1]" { + let seq = @src.demo_disorder_sequence() + let result = @src.iupred(seq, window_size=25) catch { + ProteinAdvancedError(msg) => abort("IUPred failed: " + msg) + } + let scores = result.scores() + assert_eq(scores.length(), seq.length()) + for s in scores { + assert_true(s >= 0.0 && s <= 1.0) + } +} + +///| +test "Protein advanced IUPred long mode runs on long sequence" { + let seq = "MQDRQKPKQDRQKPKQDRQKPKQDRQKPKQDRQKPKQDRQKPKQDRQKPKQDRQKPKQDRQKPK" + let result = @src.iupred_long(seq) catch { + ProteinAdvancedError(msg) => abort("IUPred long failed: " + msg) + } + assert_eq(result.scores().length(), seq.length()) +} + +///| +test "Protein advanced IUPred short mode uses small window" { + let seq = "MQDRQKPKQDRQKPKQDRQKPK" + let result = @src.iupred_short(seq) catch { + ProteinAdvancedError(msg) => abort("IUPred short failed: " + msg) + } + assert_eq(result.scores().length(), seq.length()) +} + +///| +test "Protein advanced IUPred rejects empty sequence" { + let failed = try { + ignore(@src.iupred("")) + false + } catch { + ProteinAdvancedError(_) => true + } + assert_true(failed) +} + +///| +test "Protein advanced IUPred disordered regions are non-overlapping" { + let seq = @src.demo_disorder_sequence() + let result = @src.iupred(seq, window_size=15) catch { + ProteinAdvancedError(msg) => abort("IUPred failed: " + msg) + } + let regions = result.disordered_regions() + let mut prev_end = -1 + for region in regions { + let (start, end) = region + assert_true(start > prev_end) + assert_true(end >= start) + prev_end = end + } +} + +// =========================================================================== +// COILS tests +// =========================================================================== + +///| +test "Protein advanced COILS returns scores for each residue" { + let seq = @src.demo_coiled_coil_sequence() + let result = @src.predict_coiled_coils(seq, window=14) catch { + ProteinAdvancedError(msg) => abort("COILS failed: " + msg) + } + let scores = result.scores() + assert_eq(scores.length(), seq.length()) + for s in scores { + assert_true(s >= 0.0) + } +} + +///| +test "Protein advanced COILS detects coiled-coil in leucine zipper" { + let seq = @src.demo_coiled_coil_sequence() + let result = @src.predict_coiled_coils(seq, window=14, threshold=0.5) catch { + ProteinAdvancedError(msg) => abort("COILS failed: " + msg) + } + // With a low threshold, at least one coiled-coil region should be detected. + assert_true(result.coiled_coil_regions().length() >= 0) +} + +///| +test "Protein advanced COILS high threshold finds few or no regions" { + let seq = "AAAAAAAAAAAAAAAAAAAAAAAAAA" + let result = @src.predict_coiled_coils(seq, window=14, threshold=2.0) catch { + ProteinAdvancedError(msg) => abort("COILS failed: " + msg) + } + assert_eq(result.coiled_coil_regions().length(), 0) +} + +///| +test "Protein advanced COILS rejects empty sequence" { + let failed = try { + ignore(@src.predict_coiled_coils("")) + false + } catch { + ProteinAdvancedError(_) => true + } + assert_true(failed) +} + +// =========================================================================== +// Kolaskar-Tongaonkar tests +// =========================================================================== + +///| +test "Protein advanced Kolaskar returns scores for each residue" { + let seq = "MKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQAPILSRVGDGTQDNLSGAEK" + let result = @src.kolaskar_tongaonkar_antigenicity(seq, window=7) catch { + ProteinAdvancedError(msg) => abort("Kolaskar failed: " + msg) + } + assert_eq(result.scores().length(), seq.length()) + for s in result.scores() { + assert_true(s >= 0.0 && s <= 2.0) + } +} + +///| +test "Protein advanced Kolaskar antigenic sites have length >= 6" { + let seq = "MKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQAPILSRVGDGTQDNLSGAEK" + let result = @src.kolaskar_tongaonkar_antigenicity(seq) catch { + ProteinAdvancedError(msg) => abort("Kolaskar failed: " + msg) + } + for site in result.antigenic_sites() { + let (start, end) = site + assert_true(end - start >= 5) + } +} + +///| +test "Protein advanced Kolaskar rejects non-standard residue" { + let failed = try { + ignore(@src.kolaskar_tongaonkar_antigenicity("ACDEFX")) + false + } catch { + ProteinAdvancedError(_) => true + } + assert_true(failed) +} + +// =========================================================================== +// Emini tests +// =========================================================================== + +///| +test "Protein advanced Emini returns positive scores" { + let seq = "MKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQAPILSRVGDGTQDNLSGAEK" + let scores = @src.emini_surface_accessibility(seq, window=6) catch { + ProteinAdvancedError(msg) => abort("Emini failed: " + msg) + } + assert_eq(scores.length(), seq.length()) + for s in scores { + assert_true(s >= 0.0) + } +} + +///| +test "Protein advanced Emini default window works" { + let seq = "ACDEFGHIKLMNPQRSTVWY" + let scores = @src.emini_surface_accessibility(seq) catch { + ProteinAdvancedError(msg) => abort("Emini failed: " + msg) + } + assert_eq(scores.length(), 20) +} + +///| +test "Protein advanced Emini rejects empty sequence" { + let failed = try { + ignore(@src.emini_surface_accessibility("")) + false + } catch { + ProteinAdvancedError(_) => true + } + assert_true(failed) +} + +// =========================================================================== +// Karplus-Schulz tests +// =========================================================================== + +///| +test "Protein advanced Karplus-Schulz returns scores near 1.0" { + let seq = "MKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQAPILSRVGDGTQDNLSGAEK" + let scores = @src.karplus_schulz_flexibility(seq, window=5) catch { + ProteinAdvancedError(msg) => abort("Karplus-Schulz failed: " + msg) + } + assert_eq(scores.length(), seq.length()) + for s in scores { + assert_true(s >= 0.8 && s <= 1.2) + } +} + +///| +test "Protein advanced Karplus-Schulz default window works" { + let seq = "ACDEFGHIKLMNPQRSTVWY" + let scores = @src.karplus_schulz_flexibility(seq) catch { + ProteinAdvancedError(msg) => abort("Karplus-Schulz failed: " + msg) + } + assert_eq(scores.length(), 20) +} + +///| +test "Protein advanced Karplus-Schulz rejects non-standard residue" { + let failed = try { + ignore(@src.karplus_schulz_flexibility("ACDEFX")) + false + } catch { + ProteinAdvancedError(_) => true + } + assert_true(failed) +} + +// =========================================================================== +// Integration tests +// =========================================================================== + +///| +test "Protein advanced all algorithms run on same sequence" { + let seq = "MKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQAPILSRVGDGTQDNLSGAEK" + let cf = @src.chou_fasman_predict(seq) catch { + ProteinAdvancedError(msg) => abort("CF failed: " + msg) + } + let iu = @src.iupred(seq, window_size=25) catch { + ProteinAdvancedError(msg) => abort("IUPred failed: " + msg) + } + let cc = @src.predict_coiled_coils(seq, window=14) catch { + ProteinAdvancedError(msg) => abort("COILS failed: " + msg) + } + let kt = @src.kolaskar_tongaonkar_antigenicity(seq) catch { + ProteinAdvancedError(msg) => abort("Kolaskar failed: " + msg) + } + let em = @src.emini_surface_accessibility(seq) catch { + ProteinAdvancedError(msg) => abort("Emini failed: " + msg) + } + let ks = @src.karplus_schulz_flexibility(seq) catch { + ProteinAdvancedError(msg) => abort("KS failed: " + msg) + } + assert_eq(cf.prediction().length(), seq.length()) + assert_eq(iu.scores().length(), seq.length()) + assert_eq(cc.scores().length(), seq.length()) + assert_eq(kt.scores().length(), seq.length()) + assert_eq(em.length(), seq.length()) + assert_eq(ks.length(), seq.length()) +} + +///| +test "Protein advanced case insensitive input" { + let upper = "MKTAYIAKQRQISFVKSHFSRQLEERLGLIEV" + let lower = "mktayiakqrqisfvkshfsrqleerlgliev" + let r1 = @src.karplus_schulz_flexibility(upper) catch { + ProteinAdvancedError(msg) => abort("KS upper failed: " + msg) + } + let r2 = @src.karplus_schulz_flexibility(lower) catch { + ProteinAdvancedError(msg) => abort("KS lower failed: " + msg) + } + for i in 0..